././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7151437 igraph-0.9.9/0000755000175100001710000000000000000000000013603 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/LICENSE0000644000175100001710000004310300000000000014611 0ustar00runnerdocker00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/MANIFEST.in0000644000175100001710000000016500000000000015343 0ustar00runnerdocker00000000000000include src/_igraph/*.h include MANIFEST.in include scripts/mkdoc.sh include tests/*.py graft vendor/source/igraph ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7151437 igraph-0.9.9/PKG-INFO0000644000175100001710000000451500000000000014705 0ustar00runnerdocker00000000000000Metadata-Version: 2.1 Name: igraph Version: 0.9.9 Summary: High performance graph data structures and algorithms Home-page: https://igraph.org/python Author: Tamas Nepusz Author-email: ntamas@gmail.com License: GNU General Public License (GPL) Project-URL: Bug Tracker, https://github.com/igraph/python-igraph/issues Project-URL: Changelog, https://github.com/igraph/python-igraph/blob/master/CHANGELOG.md Project-URL: CI, https://github.com/igraph/python-igraph/actions Project-URL: Documentation, https://igraph.org/python/doc Project-URL: Source Code, https://github.com/igraph/python-igraph Description: Python interface to the igraph high performance graph library, primarily aimed at complex network research and analysis. Graph plotting functionality is provided by the Cairo library, so make sure you install the Python bindings of Cairo if you want to generate publication-quality graph plots. You can try either `pycairo `_ or `cairocffi `_, ``cairocffi`` is recommended because there were bug reports affecting igraph graph plots in Jupyter notebooks when using ``pycairo`` (but not with ``cairocffi``). Keywords: graph,network,mathematics,math,graph theory,discrete mathematics Platform: ALL Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: Operating System :: OS Independent Classifier: Programming Language :: C Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Information Analysis Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Scientific/Engineering :: Physics Classifier: Topic :: Scientific/Engineering :: Bio-Informatics Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires-Python: >=3.6 Provides-Extra: plotting Provides-Extra: test Provides-Extra: doc ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/README.md0000644000175100001710000002103700000000000015065 0ustar00runnerdocker00000000000000 [![Build and test with tox](https://github.com/igraph/python-igraph/actions/workflows/build.yml/badge.svg)](https://github.com/igraph/python-igraph/actions/workflows/build.yml) [![PyPI pyversions](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10-blue)](https://pypi.python.org/pypi/igraph) [![PyPI wheels](https://img.shields.io/pypi/wheel/igraph.svg)](https://pypi.python.org/pypi/igraph) Python interface for the igraph library --------------------------------------- igraph is a library for creating and manipulating graphs. It is intended to be as powerful (ie. fast) as possible to enable the analysis of large graphs. This repository contains the source code to the Python interface of igraph. You can learn more about igraph [on our website](http://igraph.org/python/). ## Installation from PyPI We aim to provide wheels on PyPI for most of the stock Python versions; typically at least the three most recent minor releases from Python 3.x. Therefore, running the following command should work without having to compile anything during installation: ``` pip install igraph ``` See details in [Installing Python Modules](https://docs.python.org/3/installing/). ### Installation from source with pip on Debian / Ubuntu and derivatives If you need to compile igraph from source for some reason, you need to install some dependencies first: ``` sudo apt install build-essential python-dev libxml2 libxml2-dev zlib1g-dev ``` and then run ``` pip install igraph ``` This should compile the C core of igraph as well as the Python extension automatically. ### Installation from source on Windows It is now also possible to compile `igraph` from source under Windows for Python 3.6 and later. Make sure that you have Microsoft Visual Studio 2015 or later installed, and of course Python 3.6 or later. First extract the source to a suitable directory. If you launch the Developer command prompt and navigate to the directory where you extracted the source code, you should be able to build and install igraph using `python setup.py install` You may need to set the architecture that you are building on explicitly by setting the environment variable ``` set IGRAPH_CMAKE_EXTRA_ARGS=-A [arch] ``` where `[arch]` is either `Win32` for 32-bit builds or `x64` for 64-bit builds. #### Enabling GraphML By default, GraphML is disabled, because `libxml2` is not available on Windows in the standard installation. You can install `libxml2` on Windows using [`vcpkg`](https://github.com/Microsoft/vcpkg). After installation of `vcpkg` you can install `libxml2` as follows ``` vcpkg.exe install libxml2:x64-windows-static-md ``` for 64-bit version (for 32-bit versions you can use the `x86-windows-static-md` triplet). You need to integrate `vcpkg` in the build environment using ``` vcpkg.exe integrate install ``` This mentions that > CMake projects should use: `-DCMAKE_TOOLCHAIN_FILE=[vcpkg build script]` which we will do next. In order to build `igraph` correctly, you also need to set some other environment variables before building `igraph`: ``` set IGRAPH_CMAKE_EXTRA_ARGS=-DVCPKG_TARGET_TRIPLET=x64-windows-static-md -DCMAKE_TOOLCHAIN_FILE=[vcpkg build script] set IGRAPH_EXTRA_LIBRARY_PATH=[vcpkg directory]/installed/x64-windows-static-md/lib/ set IGRAPH_STATIC_EXTENSION=True set IGRAPH_EXTRA_LIBRARIES=libxml2,lzma,zlib,iconv,charset set IGRAPH_EXTRA_DYNAMIC_LIBRARIES: wsock32,ws2_32 ``` You can now build and install `igraph` again by simply running `python setup.py build`. Please make sure to use a clean source tree, if you built previously without GraphML, it will not update the build. ### Linking to an existing igraph installation The source code of the Python package includes the source code of the matching igraph version that the Python interface should compile against. However, if you want to link the Python interface to a custom installation of the C core that has already been compiled and installed on your system, you can ask `setup.py` to use the pre-compiled version. This option requires that your custom installation of igraph is discoverable with `pkg-config`. First, check whether `pkg-config` can tell you the required compiler and linker flags for igraph: ```bash pkg-config --cflags --libs igraph ``` If `pkg-config` responds with a set of compiler and linker flags and not an error message, you are probably okay. You can then proceed with the installation using pip: ```bash pip install igraph --install-option="--use-pkg-config" ``` Alternatively, if you have already downloaded and extracted the source code of igraph, you can run `setup.py` directly: ```bash python setup.py build --use-pkg-config ``` This option is primarily intended for package maintainers in Linux distributions so they can ensure that the packaged Python interface links to the packaged igraph library instead of bringing its own copy. It is also useful on macOS if you want to link to the igraph library installed from Homebrew. Due to the lack of support of `pkg-config` on Window, it is currently not possible to build against an external library on Windows. ## Compiling the development version If you have downloaded the source code from Github and not PyPI, chances are that you have the latest development version, which contains a matching version of the C core of igraph as a git submodule. Therefore, to install the bleeding edge version, you need to instruct git to check out the submodules first: ```bash git submodule update --init ``` Compiling the development version additionally requires `flex` and `bison`. You can install those on Ubuntu using ```bash sudo apt install bison flex ``` On macOS you can install these from Homebrew or MacPorts. On Windows you can install `winflexbison3` from Chocolatey. Then, running the setup script should work if you have a C compiler and the necessary build dependencies (see the previous section): ```bash python setup.py build ``` ## Running unit tests Unit tests can be executed from the project directory with `tox` or with the built-in unittest module: ```bash python -m unittest ``` ## Contributing Contributions to `igraph` are welcome! If you want to add a feature, fix a bug, or suggest an improvement, open an issue on this repository and we'll try to answer. If you have a piece of code that you would like to see included in the main tree, open a PR on this repo. To start developing `igraph`, follow the steps below (these are for Linux, Windows users should change the system commands a little). First, clone this repo (e.g. via https) and enter the folder: ```bash git clone https://github.com/igraph/python-igraph.git cd python-igraph ``` Second, check out the necessary git submodules: ```bash git submodule update --init ``` and install igraph in development mode so your changes in the Python source code are picked up automatically by Python: ```bash python setup.py develop ``` **NOTE**: Building requires `CMake`, a C compiler, and a few more dependencies. Changes that you make to the Python code do not need any extra action. However, if you adjust the source code of the C extension, you need to rebuild it by running `python setup.py develop` again. However, compilation of igraph's C core is cached in ``vendor/build`` and ``vendor/install`` so subsequent builds are much faster than the first one as the C core does not need to be recompiled. ## Notes ### Supported Python versions We aim to keep up with the development cycle of Python and support all official Python versions that have not reached their end of life yet. Currently this means that we support Python 3.6 to 3.9, inclusive. Please refer to [this page](https://devguide.python.org/#branchstatus) for the status of Python branches and let us know if you encounter problems with `igraph` on any of the non-EOL Python versions. Continuous integration tests are regularly executed on all non-EOL Python branches. ### PyPy This version of igraph is compatible with [PyPy](http://pypy.org/) and is regularly tested on [PyPy](http://pypy.org/) with ``tox``. However, the PyPy version falls behind the CPython version in terms of performance; for instance, running all the tests takes ~5 seconds on my machine with CPython and ~15 seconds with PyPy. This can probably be attributed to the need for emulating CPython reference counting, and does not seem to be alleviated by the JIT. There are also some subtle differences between the CPython and PyPy versions: - Docstrings defined in the C source code are not visible from PyPy. - ``GraphBase`` is hashable and iterable in PyPy but not in CPython. Since ``GraphBase`` is internal anyway, this is likely to stay this way. ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3991392 igraph-0.9.9/scripts/0000755000175100001710000000000000000000000015272 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/scripts/igraph0000755000175100001710000000017700000000000016477 0ustar00runnerdocker00000000000000#!/usr/bin/env python """Small script to execute the igraph command line interface""" from igraph.app.shell import main main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/scripts/mkdoc.sh0000755000175100001710000000432600000000000016733 0ustar00runnerdocker00000000000000#!/bin/sh # # Creates the API documentation for igraph's Python interface using PyDoctor # # Usage: ./mkdoc.sh SCRIPTS_FOLDER=`dirname $0` cd ${SCRIPTS_FOLDER}/.. ROOT_FOLDER=`pwd` DOC_API_FOLDER=${ROOT_FOLDER}/doc/api cd ${ROOT_FOLDER} if [ ! -d ".venv" ]; then # Create a virtual environment for pydoctor python3 -m venv .venv .venv/bin/pip install -U pydoctor wheel fi PYDOCTOR=.venv/bin/pydoctor if [ ! -f ${PYDOCTOR} ]; then echo "PyDoctor not installed in the virtualenv of the project, exiting..." exit 1 fi PWD=`pwd` echo "Patching PyDoctor..." $SCRIPTS_FOLDER/patch-pydoctor.sh ${ROOT_FOLDER} ${SCRIPTS_FOLDER} echo "Removing existing documentation..." rm -rf "${DOC_API_FOLDER}/html" "${DOC_API_FOLDER}/pdf" echo "Removing existing igraph and python-igraph eggs from virtualenv..." SITE_PACKAGES_DIR=`.venv/bin/python3 -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])'` rm -rf "${SITE_PACKAGES_DIR}"/igraph*.egg rm -rf "${SITE_PACKAGES_DIR}"/igraph*.egg-link rm -rf "${SITE_PACKAGES_DIR}"/python_igraph*.egg rm -rf "${SITE_PACKAGES_DIR}"/python_igraph*.egg-link echo "Installing igraph in virtualenv..." rm -f dist/*.whl && .venv/bin/python setup.py bdist_wheel && .venv/bin/pip install --force-reinstall dist/*.whl IGRAPHDIR=`.venv/bin/python3 -c 'import igraph, os; print(os.path.dirname(igraph.__file__))'` echo "Generating HTML documentation..." "$PYDOCTOR" \ --project-name "igraph" \ --project-url "https://igraph.org/python" \ --introspect-c-modules \ --make-html \ --html-output "${DOC_API_FOLDER}/html" \ ${IGRAPHDIR} # PDF not supported by PyDoctor DOC2DASH=`which doc2dash 2>/dev/null || true` if [ "x$DOC2DASH" != x ]; then echo "Generating Dash docset..." "$DOC2DASH" \ --online-redirect-url "https://igraph.org/python/doc/api" \ --name "python-igraph" \ -d "${DOC_API_FOLDER}" \ -f \ "${DOC_API_FOLDER}/html" DASH_READY=1 else echo "WARNING: doc2dash not installed, skipping Dash docset generation." DASH_READY=0 fi echo "" echo "HTML API documentation generated in ${DOC_API_FOLDER}/html" if [ "x${DASH_READY}" = x1 ]; then echo "Dash docset generated in ${DOC_API_FOLDER}/python-igraph.docset" fi cd "$PWD" ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7151437 igraph-0.9.9/setup.cfg0000644000175100001710000000004600000000000015424 0ustar00runnerdocker00000000000000[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/setup.py0000644000175100001710000010203600000000000015317 0ustar00runnerdocker00000000000000#!usr/bin/env python import os import platform import sys ########################################################################### # Check Python's version info and exit early if it is too old if sys.version_info < (3, 6): print("This module requires Python >= 3.6") sys.exit(0) ########################################################################### from setuptools import setup, Command, Extension import glob import shlex import shutil import subprocess import sysconfig from contextlib import contextmanager from pathlib import Path from select import select from shutil import which from time import sleep from typing import List, Iterable, Iterator, Optional, Tuple, TypeVar, Union ########################################################################### LIBIGRAPH_FALLBACK_INCLUDE_DIRS = ["/usr/include/igraph", "/usr/local/include/igraph"] LIBIGRAPH_FALLBACK_LIBRARIES = ["igraph"] LIBIGRAPH_FALLBACK_LIBRARY_DIRS = [] # Check whether we are compiling for PyPy. Headers will not be installed # for PyPy. SKIP_HEADER_INSTALL = (platform.python_implementation() == "PyPy") or ( "SKIP_HEADER_INSTALL" in os.environ ) ########################################################################### T = TypeVar("T") def building_on_windows_msvc() -> bool: """Returns True when using the non-MinGW CPython interpreter on Windows""" return platform.system() == "Windows" and sysconfig.get_platform() != "mingw" def exclude_from_list(items: Iterable[T], items_to_exclude: Iterable[T]) -> List[T]: """Excludes certain items from a list, keeping the original order of the remaining items.""" itemset = set(items_to_exclude) return [item for item in items if item not in itemset] def find_static_library(library_name: str, library_path: List[str]) -> Optional[str]: """Given the raw name of a library in `library_name`, tries to find a static library with this name in the given `library_path`. `library_path` is automatically extended with common library directories on Linux and Mac OS X.""" variants = ["lib{0}.a", "{0}.a", "{0}.lib", "lib{0}.lib"] if is_unix_like(): extra_libdirs = [ "/opt/homebrew/lib", # for newer Homebrew installations on macOS "/usr/local/lib64", "/usr/local/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib", "/lib64", "/lib", ] else: extra_libdirs = [] for path in extra_libdirs: if path not in library_path and os.path.isdir(path): library_path.append(path) for path in library_path: for variant in variants: full_path = os.path.join(path, variant.format(library_name)) if os.path.isfile(full_path): return full_path def first(iterable: Iterable[T]) -> T: """Returns the first element from the given iterable.""" for item in iterable: return item raise ValueError("iterable is empty") def get_output(args, encoding: str = "utf-8") -> Tuple[str, int]: """Returns the output of a command returning a single line of output, and the exit code of the command. """ PIPE = subprocess.PIPE try: p = subprocess.Popen(args, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE) stdout, stderr = p.communicate() returncode = p.returncode except OSError: stdout, stderr = None, None returncode = 77 if isinstance(stdout, bytes): stdout = str(stdout, encoding=encoding) if isinstance(stderr, bytes): stderr = str(stderr, encoding=encoding) return (stdout or ""), returncode def get_output_single_line(args, encoding: str = "utf-8") -> Tuple[str, int]: """Returns the first line of the output of a command, stripped from any trailing newlines, and the exit code of the command. """ stdout, returncode = get_output(args, encoding=encoding) line, _, _ = stdout.partition("\n") return line, returncode def is_unix_like(platform: str = sys.platform) -> bool: """Returns whether the given platform is a Unix-like platform with the usual Unix filesystem. When the parameter is omitted, it defaults to ``sys.platform`` """ platform = platform or sys.platform platform = platform.lower() return ( platform.startswith("linux") or platform.startswith("darwin") or platform.startswith("cygwin") ) def wait_for_keypress(seconds: float) -> None: """Wait for a keypress or until the given number of seconds have passed, whichever happens first. """ while seconds > 0: if seconds > 1: plural = "s" else: plural = "" sys.stdout.write( "\rContinuing in %2d second%s; press Enter to continue " "immediately. " % (seconds, plural) ) sys.stdout.flush() if platform.system() == "Windows": from msvcrt import kbhit # type: ignore for _ in range(10): if kbhit(): seconds = 0 break sleep(0.1) else: rlist, _, _ = select([sys.stdin], [], [], 1) if rlist: sys.stdin.readline() seconds = 0 break seconds -= 1 sys.stdout.write("\r" + " " * 65 + "\r") @contextmanager def working_directory(dir: Union[str, Path]) -> Iterator[None]: cwd = os.getcwd() os.chdir(dir) try: yield finally: os.chdir(cwd) ########################################################################### class IgraphCCoreCMakeBuilder: """Class responsible for downloading and building the C core of igraph if it is not installed yet, assuming that the C core uses CMake as the build tool. This is the case from igraph 0.9. """ def compile_in( self, source_folder: Path, build_folder: Path, install_folder: Path ) -> Union[bool, List[str]]: """Compiles igraph from its source code in the given folder. Parameters: source_folder: absolute path to the folder that contains igraph's source files build_folder: absolute path to the folder where the build should be executed install_folder: absolute path to the folder where the built library should be installed Returns: False if the build failed or the list of libraries to link to when linking the Python interface to igraph """ with working_directory(build_folder): return self._compile_in(source_folder, build_folder, install_folder) def _compile_in( self, source_folder: Path, build_folder: Path, install_folder: Path ) -> Union[bool, List[str]]: cmake = which("cmake") if not cmake: print( "igraph uses CMake as the build system. You need to install CMake " "before compiling igraph." ) return False build_to_source_folder = os.path.relpath(source_folder, build_folder) print("Configuring build...") args = [cmake] # Build the Python interface with vendored libraries for deps in "ARPACK BLAS CXSPARSE GLPK GMP LAPACK".split(): args.append("-DIGRAPH_USE_INTERNAL_" + deps + "=ON") # -fPIC is needed on Linux so we can link to a static igraph lib from a # Python shared library args.append("-DCMAKE_POSITION_INDEPENDENT_CODE=ON") # No need to build tests args.append("-DBUILD_TESTING=OFF") # Add any extra CMake args from environment variables if "IGRAPH_CMAKE_EXTRA_ARGS" in os.environ: args.extend(shlex.split(os.environ["IGRAPH_CMAKE_EXTRA_ARGS"])) # Finally, add the source folder path args.append(str(build_to_source_folder)) retcode = subprocess.call(args) if retcode: return False print("Running build...") # We are _not_ using a parallel build; this is intentional, see igraph/igraph#1755 retcode = subprocess.call([cmake, "--build", ".", "--config", "Release"]) if retcode: return False print("Installing build...") retcode = subprocess.call( [ cmake, "--install", ".", "--prefix", str(install_folder), "--config", "Release", ] ) if retcode: return False pkgconfig_candidates = [ install_folder / "lib" / "pkgconfig" / "igraph.pc", install_folder / "lib64" / "pkgconfig" / "igraph.pc", ] for candidate in pkgconfig_candidates: if candidate.exists(): return self._parse_pkgconfig_file(candidate) raise RuntimeError( "no igraph.pc was found in the installation folder of igraph" ) def create_build_config_file( self, install_folder: Path, libraries: List[str] ) -> None: with (install_folder / "build.cfg").open("w") as fp: fp.write(repr(libraries)) def _parse_pkgconfig_file(self, filename: Path) -> List[str]: building_on_windows = building_on_windows_msvc() if building_on_windows: libraries = ["igraph"] else: libraries = [] with filename.open("r") as fp: for line in fp: if line.startswith("Libs: ") or line.startswith("Libs.private: "): words = line.strip().split() libraries.extend( word[2:] for word in words if word.startswith("-l") ) if not libraries: # Educated guess libraries = ["igraph"] return libraries ########################################################################### class BuildConfiguration: def __init__(self): self.include_dirs = [] self.library_dirs = [] self.runtime_library_dirs = [] self.libraries = [] self.extra_compile_args = [] self.extra_link_args = [] self.define_macros = [] self.extra_objects = [] self.static_extension = False self.use_pkgconfig = False self.c_core_built = False self._has_pkgconfig = None self.excluded_include_dirs = [] self.excluded_library_dirs = [] self.wait = platform.system() != "Windows" @property def has_pkgconfig(self) -> bool: """Returns whether ``pkg-config`` is available on the current system and it knows about igraph or not.""" if self._has_pkgconfig is None: if self.use_pkgconfig: _, exit_code = get_output_single_line(["pkg-config", "igraph"]) self._has_pkgconfig = exit_code == 0 else: self._has_pkgconfig = False return self._has_pkgconfig @property def build_c_core(self) -> Command: """Returns a class representing a custom setup.py command that builds the C core of igraph. This is used in CI environments where we want to build the C core of igraph once and then build the Python interface for various Python versions without having to recompile the C core all the time. If is also used as a custom building block of `build_ext`. """ buildcfg = self class build_c_core(Command): description = "Compile the C core of igraph only" user_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): buildcfg.c_core_built = buildcfg.compile_igraph_from_vendor_source() return build_c_core @property def build_ext(self) -> Command: """Returns a class that can be used as a replacement for the ``build_ext`` command in ``setuptools`` and that will compile the C core of igraph before compiling the Python extension. """ from setuptools.command.build_ext import build_ext buildcfg = self class custom_build_ext(build_ext): def run(self): # Bail out if we don't have the Python include files include_dir = sysconfig.get_path('include') if not os.path.isfile(os.path.join(include_dir, "Python.h")): print("You will need the Python headers to compile this extension.") sys.exit(1) # Check whether the user asked us to discover a pre-built igraph # with pkg-config detected = False if buildcfg.use_pkgconfig: detected = buildcfg.detect_from_pkgconfig() if not detected: print( "Cannot find the C core of igraph on this system using pkg-config." ) sys.exit(1) else: # Build the C core from the vendored igraph source self.run_command("build_c_core") if not buildcfg.c_core_built: # Fall back to an educated guess if everything else failed if not detected: buildcfg.use_educated_guess() # Add any extra library paths if needed; this is needed for the # Appveyor CI build if "IGRAPH_EXTRA_LIBRARY_PATH" in os.environ: buildcfg.library_dirs = ( list(os.environ["IGRAPH_EXTRA_LIBRARY_PATH"].split(os.pathsep)) + buildcfg.library_dirs ) # Add extra libraries that may have been specified if "IGRAPH_EXTRA_LIBRARIES" in os.environ: extra_libraries = os.environ["IGRAPH_EXTRA_LIBRARIES"].split(",") buildcfg.libraries.extend(extra_libraries) # Override static specification based on environment variable if "IGRAPH_STATIC_EXTENSION" in os.environ: if os.environ["IGRAPH_STATIC_EXTENSION"].lower() in [ "true", "1", "on", ]: buildcfg.static_extension = True else: buildcfg.static_extension = False # Replaces library names with full paths to static libraries # where possible. libm.a is excluded because it caused problems # on Sabayon Linux where libm.a is probably not compiled with # -fPIC if buildcfg.static_extension: if buildcfg.static_extension == "only_igraph": buildcfg.replace_static_libraries(only=["igraph"]) else: buildcfg.replace_static_libraries(exclusions=["m"]) # Add extra libraries that may have been specified if "IGRAPH_EXTRA_DYNAMIC_LIBRARIES" in os.environ: extra_libraries = os.environ[ "IGRAPH_EXTRA_DYNAMIC_LIBRARIES" ].split(",") buildcfg.libraries.extend(extra_libraries) # Remove C++ standard library as we will use the C++ linker for lib in ("c++", "stdc++"): if lib in buildcfg.libraries: buildcfg.libraries.remove(lib) # Prints basic build information buildcfg.print_build_info() # Find the igraph extension and configure it with the settings # of this build configuration ext = first( extension for extension in self.extensions if extension.name == "igraph._igraph" ) buildcfg.configure(ext) # Run the original build_ext command build_ext.run(self) return custom_build_ext @property def sdist(self): """Returns a class that can be used as a replacement for the ``sdist`` command in ``setuptools`` and that will clean up ``vendor/source/igraph`` before running the original ``sdist`` command. """ from setuptools.command.sdist import sdist def is_git_repo(folder) -> bool: return (Path(folder) / ".git").exists() def cleanup_git_repo(folder) -> None: with working_directory(folder): if os.path.exists(".git"): retcode = subprocess.call("git clean -dfx", shell=True) if retcode: raise RuntimeError(f"Failed to clean {folder} with git") class custom_sdist(sdist): def run(self): igraph_source_repo = Path("vendor", "source", "igraph") igraph_build_dir = Path("vendor", "build", "igraph") version_file = igraph_source_repo / "IGRAPH_VERSION" version = None # Check whether the source repo contains an IGRAPH_VERSION file, # and extract the version number from that if version_file.exists(): version = version_file.read_text().strip().split("\n")[0] # If no IGRAPH_VERSION file exists, but we have a git repo, try # git describe if not version and is_git_repo(igraph_source_repo): with working_directory(igraph_source_repo): version = ( subprocess.check_output("git describe", shell=True) .decode("utf-8") .strip() ) # If we still don't have a version number, try to parse it from # include/igraph_version.h if not version: version_header = igraph_build_dir / "include" / "igraph_version.h" if not version_header.exists(): raise RuntimeError( "You need to build the C core of igraph first before generating a source tarball of the Python interface of igraph" ) with version_header.open("r") as fp: lines = [ line.strip() for line in fp if line.startswith("#define IGRAPH_VERSION ") ] if len(lines) == 1: version = lines[0].split('"')[1] if not isinstance(version, str) or len(version) < 5: raise RuntimeError( f"Cannot determine the version number of the C core in {igraph_source_repo}" ) if not is_git_repo(igraph_source_repo): # The Python interface was extracted from an official # tarball so there is no need to tweak anything return sdist.run(self) else: # Clean up vendor/source/igraph with git cleanup_git_repo(igraph_source_repo) # Copy the generated parser sources from the build folder parser_dir = igraph_build_dir / "src" / "io" / "parsers" if parser_dir.is_dir(): shutil.copytree( parser_dir, igraph_source_repo / "src" / "io" / "parsers" ) else: raise RuntimeError( "You need to build the C core of igraph first before " "generating a source tarball of the Python interface" ) # Add a version file to the tarball version_file.write_text(version) # Run the original sdist command retval = sdist.run(self) # Clean up vendor/source/igraph with git again cleanup_git_repo(igraph_source_repo) return retval return custom_sdist def compile_igraph_from_vendor_source(self) -> bool: """Compiles igraph from the vendored source code inside `vendor/source/igraph`. This folder typically comes from a git submodule. """ vendor_folder = Path("vendor") source_folder = vendor_folder / "source" / "igraph" build_folder = vendor_folder / "build" / "igraph" install_folder = vendor_folder / "install" / "igraph" if install_folder.exists(): # Vendored igraph already compiled and installed, just use it self.use_vendored_igraph() return True if (source_folder / "CMakeLists.txt").exists(): igraph_builder = IgraphCCoreCMakeBuilder() else: print("Cannot find vendored igraph source in {0}".format(source_folder)) print("") return False print("We are going to build the C core of igraph.") print(" Source folder: {0}".format(source_folder)) print(" Build folder: {0}".format(build_folder)) print(" Install folder: {0}".format(install_folder)) print("") source_folder = source_folder.resolve() build_folder = build_folder.resolve() install_folder = install_folder.resolve() Path(build_folder).mkdir(parents=True, exist_ok=True) libraries = igraph_builder.compile_in( source_folder=source_folder, build_folder=build_folder, install_folder=install_folder, ) if libraries is False: print("Build failed for the C core of igraph.") print("") sys.exit(1) assert not isinstance(libraries, bool) igraph_builder.create_build_config_file(install_folder, libraries) self.use_vendored_igraph() return True def configure(self, ext) -> None: """Configures the given Extension object using this build configuration.""" ext.include_dirs = exclude_from_list( self.include_dirs, self.excluded_include_dirs ) ext.library_dirs = exclude_from_list( self.library_dirs, self.excluded_library_dirs ) ext.runtime_library_dirs = self.runtime_library_dirs ext.libraries = self.libraries ext.extra_compile_args = self.extra_compile_args ext.extra_link_args = self.extra_link_args ext.extra_objects = self.extra_objects ext.define_macros = self.define_macros def detect_from_pkgconfig(self) -> bool: """Detects the igraph include directory, library directory and the list of libraries to link to using ``pkg-config``.""" if not buildcfg.has_pkgconfig: return False cmd = ["pkg-config", "igraph", "--cflags", "--libs"] if self.static_extension: cmd += ["--static"] line, exit_code = get_output_single_line(cmd) if exit_code > 0 or len(line) == 0: return False opts = line.strip().split() self.libraries = [opt[2:] for opt in opts if opt.startswith("-l")] self.library_dirs = [opt[2:] for opt in opts if opt.startswith("-L")] self.include_dirs = [opt[2:] for opt in opts if opt.startswith("-I")] return True def print_build_info(self) -> None: """Prints the include and library path being used for debugging purposes.""" if self.static_extension == "only_igraph": build_type = "dynamic extension with vendored igraph source" elif self.static_extension: build_type = "static extension" else: build_type = "dynamic extension" print("Build type: %s" % build_type) print("Include path: %s" % " ".join(self.include_dirs)) if self.excluded_include_dirs: print(" - excluding: %s" % " ".join(self.excluded_include_dirs)) print("Library path: %s" % " ".join(self.library_dirs)) if self.excluded_library_dirs: print(" - excluding: %s" % " ".join(self.excluded_library_dirs)) print("Runtime library path: %s" % " ".join(self.runtime_library_dirs)) print("Linked dynamic libraries: %s" % " ".join(self.libraries)) print("Linked static libraries: %s" % " ".join(self.extra_objects)) print("Extra compiler options: %s" % " ".join(self.extra_compile_args)) print("Extra linker options: %s" % " ".join(self.extra_link_args)) def process_args_from_command_line(self): """Preprocesses the command line options before they are passed to setup.py and sets up the build configuration.""" # Yes, this is ugly, but we don't want to interfere with setup.py's own # option handling opts_to_remove = [] for idx, option in enumerate(sys.argv): if not option.startswith("--"): continue if option == "--static": opts_to_remove.append(idx) self.static_extension = True elif option == "--no-pkg-config": opts_to_remove.append(idx) self.use_pkgconfig = False elif option == "--no-wait": opts_to_remove.append(idx) self.wait = False elif option == "--use-pkg-config": opts_to_remove.append(idx) self.use_pkgconfig = True for idx in reversed(opts_to_remove): sys.argv[idx : (idx + 1)] = [] def replace_static_libraries(self, only=None, exclusions=None): """Replaces references to libraries with full paths to their static versions if the static version is to be found on the library path.""" if exclusions is None: exclusions = [] for library_name in set(self.libraries) - set(exclusions): if only is not None and library_name not in only: continue static_lib = find_static_library(library_name, self.library_dirs) if static_lib: print(f"Found {library_name} as static library in {static_lib}.") self.libraries.remove(library_name) self.extra_objects.append(static_lib) else: print(f"Warning: could not find static library of {library_name}.") def use_vendored_igraph(self) -> None: """Assumes that igraph is installed already in ``vendor/install/igraph`` and sets up the include and library paths and the library names accordingly.""" building_on_windows = building_on_windows_msvc() vendor_dir = Path("vendor") / "install" / "igraph" buildcfg.include_dirs = [str(vendor_dir / "include" / "igraph")] buildcfg.library_dirs = [] for candidate in ("lib", "lib64"): candidate = vendor_dir / candidate if candidate.exists(): buildcfg.library_dirs.append(str(candidate)) break else: raise RuntimeError( "cannot detect igraph library dir within " + str(vendor_dir) ) if not buildcfg.static_extension: buildcfg.static_extension = "only_igraph" if building_on_windows: buildcfg.define_macros.append(("IGRAPH_STATIC", "1")) buildcfg_file = vendor_dir / "build.cfg" if buildcfg_file.exists(): buildcfg.libraries = eval(buildcfg_file.open("r").read()) def use_educated_guess(self) -> None: """Tries to guess the proper library names, include and library paths if everything else failed.""" global LIBIGRAPH_FALLBACK_LIBRARIES global LIBIGRAPH_FALLBACK_INCLUDE_DIRS global LIBIGRAPH_FALLBACK_LIBRARY_DIRS print("WARNING: we were not able to detect where igraph is installed on") print("your machine (if it is installed at all). We will use the fallback") print("library and include paths hardcoded in setup.py and hope that the") print("C core of igraph is installed there.") print("") print("If the compilation fails and you are sure that igraph is installed") print("on your machine, adjust the following two variables in setup.py") print("accordingly and try again:") print("") print("- LIBIGRAPH_FALLBACK_INCLUDE_DIRS") print("- LIBIGRAPH_FALLBACK_LIBRARY_DIRS") print("") if self.wait: wait_for_keypress(seconds=10) self.libraries = LIBIGRAPH_FALLBACK_LIBRARIES[:] if self.static_extension: self.libraries.extend(["xml2", "z", "m", "stdc++"]) self.include_dirs = LIBIGRAPH_FALLBACK_INCLUDE_DIRS[:] self.library_dirs = LIBIGRAPH_FALLBACK_LIBRARY_DIRS[:] ########################################################################### # Import version number from version.py so we only need to change it in # one place when a new release is created __version__: str = "" exec(open("src/igraph/version.py").read()) # Process command line options buildcfg = BuildConfiguration() buildcfg.process_args_from_command_line() # Define the extension sources = glob.glob(os.path.join("src", "_igraph", "*.c")) sources.append(os.path.join("src", "_igraph", "force_cpp_linker.cpp")) igraph_extension = Extension("igraph._igraph", sources) description = """Python interface to the igraph high performance graph library, primarily aimed at complex network research and analysis. Graph plotting functionality is provided by the Cairo library, so make sure you install the Python bindings of Cairo if you want to generate publication-quality graph plots. You can try either `pycairo `_ or `cairocffi `_, ``cairocffi`` is recommended because there were bug reports affecting igraph graph plots in Jupyter notebooks when using ``pycairo`` (but not with ``cairocffi``). """ headers = ["src/_igraph/igraphmodule_api.h"] if not SKIP_HEADER_INSTALL else [] options = dict( name="igraph", version=__version__, url="https://igraph.org/python", description="High performance graph data structures and algorithms", long_description=description, license="GNU General Public License (GPL)", author="Tamas Nepusz", author_email="ntamas@gmail.com", project_urls={ "Bug Tracker": "https://github.com/igraph/python-igraph/issues", "Changelog": "https://github.com/igraph/python-igraph/blob/master/CHANGELOG.md", "CI": "https://github.com/igraph/python-igraph/actions", "Documentation": "https://igraph.org/python/doc", "Source Code": "https://github.com/igraph/python-igraph", }, ext_modules=[igraph_extension], package_dir={ # make sure to use the next line and not the more logical and restrictive # "igraph": "src/igraph" because that one breaks 'setup.py develop'. # See: https://github.com/igraph/python-igraph/issues/464 "": "src" }, packages=["igraph", "igraph.app", "igraph.drawing", "igraph.remote"], scripts=["scripts/igraph"], install_requires=["texttable>=1.6.2"], extras_require={ "plotting": ["cairocffi>=1.2.0"], "test": [ "networkx>=2.5", "pytest>=6.2.5", "numpy>=1.19.0; platform_python_implementation != 'PyPy'", "pandas>=1.1.0; platform_python_implementation != 'PyPy'", "scipy>=1.5.0; platform_python_implementation != 'PyPy'", ], "doc": [ "Sphinx>=4.2.0", "sphinxbootstrap4theme>=0.6.0" ] }, python_requires=">=3.6", headers=headers, platforms="ALL", keywords=[ "graph", "network", "mathematics", "math", "graph theory", "discrete mathematics", ], classifiers=[ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Intended Audience :: Science/Research", "Operating System :: OS Independent", "Programming Language :: C", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3 :: Only", "Topic :: Scientific/Engineering", "Topic :: Scientific/Engineering :: Information Analysis", "Topic :: Scientific/Engineering :: Mathematics", "Topic :: Scientific/Engineering :: Physics", "Topic :: Scientific/Engineering :: Bio-Informatics", "Topic :: Software Development :: Libraries :: Python Modules", ], cmdclass={ "build_c_core": buildcfg.build_c_core, # used by CI "build_ext": buildcfg.build_ext, "sdist": buildcfg.sdist, }, ) setup(**options) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392 igraph-0.9.9/src/0000755000175100001710000000000000000000000014372 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4071393 igraph-0.9.9/src/_igraph/0000755000175100001710000000000000000000000016003 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/arpackobject.c0000644000175100001710000002121500000000000020600 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2007-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "arpackobject.h" #include "graphobject.h" #include "error.h" PyTypeObject* igraphmodule_ARPACKOptionsType; PyObject* igraphmodule_arpack_options_default; /** * \ingroup python_interface_arpack * \brief Allocates a new ARPACK parameters object */ PyObject* igraphmodule_ARPACKOptions_new() { igraphmodule_ARPACKOptionsObject* self; self = PyObject_New(igraphmodule_ARPACKOptionsObject, igraphmodule_ARPACKOptionsType); if (self) { igraph_arpack_options_init(&self->params); igraph_arpack_options_init(&self->params_out); } return (PyObject*)self; } /** * \ingroup python_interface_arpack * \brief Deallocates a Python representation of a given ARPACK parameters object */ static void igraphmodule_ARPACKOptions_dealloc(igraphmodule_ARPACKOptionsObject* self) { PyTypeObject *tp = Py_TYPE(self); PyObject_Del((PyObject*)self); Py_DECREF(tp); /* needed because heap-allocated types are refcounted */ } /** \ingroup python_interface_arpack * \brief Returns one of the attributes of a given ARPACK parameters object */ static PyObject* igraphmodule_ARPACKOptions_getattr( igraphmodule_ARPACKOptionsObject* self, char* attrname) { PyObject *result = NULL; if (strcmp(attrname, "bmat") == 0) { char buf[2] = { self->params_out.bmat[0], 0 }; result=PyUnicode_FromString(buf); } else if (strcmp(attrname, "n") == 0) { result=PyLong_FromLong(self->params_out.n); } else if (strcmp(attrname, "which") == 0) { char buf[3] = { self->params.which[0], self->params.which[1], 0 }; result=PyUnicode_FromString(buf); } else if (strcmp(attrname, "nev") == 0) { result=PyLong_FromLong(self->params.nev); } else if (strcmp(attrname, "tol") == 0) { result=PyFloat_FromDouble((double)self->params.tol); } else if (strcmp(attrname, "ncv") == 0) { result=PyLong_FromLong(self->params.ncv); } else if (strcmp(attrname, "ldv") == 0) { result=PyLong_FromLong(self->params.ldv); } else if (strcmp(attrname, "ishift") == 0) { result=PyLong_FromLong(self->params.ishift); } else if (strcmp(attrname, "maxiter") == 0 || strcmp(attrname, "mxiter") == 0) { result=PyLong_FromLong(self->params.mxiter); } else if (strcmp(attrname, "nb") == 0) { result=PyLong_FromLong(self->params.nb); } else if (strcmp(attrname, "mode") == 0) { result=PyLong_FromLong(self->params.mode); } else if (strcmp(attrname, "start") == 0) { result=PyLong_FromLong(self->params.start); } else if (strcmp(attrname, "sigma") == 0) { result=PyFloat_FromDouble((double)self->params.sigma); } else if (strcmp(attrname, "info") == 0) { result=PyLong_FromLong(self->params_out.info); } else if (strcmp(attrname, "iter") == 0) { result=PyLong_FromLong(self->params_out.iparam[2]); } else if (strcmp(attrname, "nconv") == 0) { result=PyLong_FromLong(self->params_out.iparam[4]); } else if (strcmp(attrname, "numop") == 0) { result=PyLong_FromLong(self->params_out.iparam[8]); } else if (strcmp(attrname, "numopb") == 0) { result=PyLong_FromLong(self->params_out.iparam[9]); } else if (strcmp(attrname, "numreo") == 0) { result=PyLong_FromLong(self->params_out.iparam[10]); } else { PyErr_SetString(PyExc_AttributeError, attrname); } return result; } /** \ingroup python_interface_arpack * \brief Sets one of the attributes of a given ARPACK parameters object */ static int igraphmodule_ARPACKOptions_setattr( igraphmodule_ARPACKOptionsObject* self, char* attrname, PyObject* value) { if (value == 0) { PyErr_SetString(PyExc_TypeError, "attribute can not be deleted"); return -1; } if (strcmp(attrname, "maxiter") == 0 || strcmp(attrname, "mxiter") == 0) { if (PyLong_Check(value)) { long int n=PyLong_AsLong(value); if (n>0) self->params.mxiter=(igraph_integer_t)n; else { PyErr_SetString(PyExc_ValueError, "maxiter must be positive"); return -1; } } else { PyErr_SetString(PyExc_ValueError, "integer expected"); return -1; } } else if (strcmp(attrname, "tol") == 0) { if (PyLong_Check(value)) { self->params.tol = (igraph_real_t) PyLong_AsLong(value); } else if (PyFloat_Check(value)) { self->params.tol = (igraph_real_t) PyFloat_AsDouble(value); } else { PyErr_SetString(PyExc_ValueError, "integer or float expected"); return -1; } } else { PyErr_SetString(PyExc_AttributeError, attrname); return -1; } return 0; } /** \ingroup python_interface_arpack */ igraph_arpack_options_t *igraphmodule_ARPACKOptions_get( igraphmodule_ARPACKOptionsObject *self) { self->params_out = self->params; self->params_out.iparam[0] = self->params.ishift; self->params_out.iparam[2] = self->params.mxiter; self->params_out.iparam[3] = self->params.nb; self->params_out.iparam[6] = self->params.mode; self->params_out.lworkl = 0; self->params_out.info = self->params.start; return &self->params_out; } /** \ingroup python_interface_arpack * \brief Formats an \c igraph.ARPACKOptions object in a * human-consumable format. * * \return the formatted textual representation as a \c PyObject */ PyObject* igraphmodule_ARPACKOptions_str(igraphmodule_ARPACKOptionsObject *self) { return PyUnicode_FromString("ARPACK parameters"); } PyDoc_STRVAR( igraphmodule_ARPACKOptions_doc, "Class representing the parameters of the ARPACK module.\n\n" "ARPACK is a Fortran implementation of the implicitly restarted\n" "Arnoldi method, an algorithm for calculating some of the\n" "eigenvalues and eigenvectors of a given matrix. igraph uses this\n" "package occasionally, and this class can be used to fine-tune the\n" "behaviour of ARPACK in such cases.\n\n" "The class has several attributes which are not documented here,\n" "since they are usually of marginal use to the ordinary user.\n" "See the source code of the original ARPACK Fortran package\n" "(especially the file C{dsaupd.f}) for a detailed explanation of the\n" "parameters. Only the most basic attributes are explained here. Most\n" "of them are read only unless stated otherwise.\n\n" " - C{bmat}: type of the eigenproblem solved. C{'I'} means standard\n" " eigenproblem (A*x = lambda*x), C{'G'} means generalized\n" " eigenproblem (A*x = lambda*B*x).\n\n" " - C{n}: dimension of the eigenproblem\n\n" " - C{tol}: precision. If less than or equal to zero, the standard\n" " machine precision is used as computed by the LAPACK utility\n" " called C{dlamch}. This can be modified.\n\n" " - C{mxiter}: maximum number of update iterations to take. This\n" " can be modified. You can also use C{maxiter}.\n\n" " - C{iter}: actual number of update iterations taken\n\n" " - C{numop}: total number of OP*x operations\n\n" " - C{numopb}: total number of B*x operations if C{bmat} is C{'G'}\n\n" " - C{numreo}: total number of steps of re-orthogonalization\n\n" ); PyType_Slot igraphmodule_ARPACKOptions_slots[] = { { Py_tp_new, igraphmodule_ARPACKOptions_new }, { Py_tp_dealloc, igraphmodule_ARPACKOptions_dealloc }, { Py_tp_getattr, igraphmodule_ARPACKOptions_getattr }, { Py_tp_setattr, igraphmodule_ARPACKOptions_setattr }, { Py_tp_str, igraphmodule_ARPACKOptions_str }, { Py_tp_doc, (void*) igraphmodule_ARPACKOptions_doc }, { 0 } }; /** \ingroup python_interface_arpack * Python type specification for \c igraph.ARPACKOptions */ PyType_Spec igraphmodule_ARPACKOptions_spec = { "igraph.ARPACKOptions", /* name */ sizeof(igraphmodule_ARPACKOptionsObject), /* basicsize */ 0, /* itemsize */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* flags */ igraphmodule_ARPACKOptions_slots, /* slots */ }; int igraphmodule_ARPACKOptions_register_type() { igraphmodule_ARPACKOptionsType = (PyTypeObject*) PyType_FromSpec(&igraphmodule_ARPACKOptions_spec); return igraphmodule_ARPACKOptionsType == 0; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/arpackobject.h0000644000175100001710000000317200000000000020607 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_ARPACKOBJECT_H #define PYTHON_ARPACKOBJECT_H #define Py_LIMITED_API 0x03060000 #include "preamble.h" #include #include "graphobject.h" /** * \ingroup python_interface * \defgroup python_interface_arpack ARPACK parameters object */ /** * \ingroup python_interface_arpack * \brief A structure representing ARPACK parameters */ typedef struct { PyObject_HEAD igraph_arpack_options_t params; igraph_arpack_options_t params_out; } igraphmodule_ARPACKOptionsObject; extern PyTypeObject* igraphmodule_ARPACKOptionsType; extern PyObject* igraphmodule_arpack_options_default; int igraphmodule_ARPACKOptions_register_type(); PyObject* igraphmodule_ARPACKOptions_new(void); igraph_arpack_options_t *igraphmodule_ARPACKOptions_get(igraphmodule_ARPACKOptionsObject *self); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/attributes.c0000644000175100001710000017234300000000000020347 0ustar00runnerdocker00000000000000/* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #define Py_LIMITED_API 0x03060000 #include "attributes.h" #include "common.h" #include "convert.h" #include "pyhelpers.h" int igraphmodule_i_attribute_struct_init(igraphmodule_i_attribute_struct *attrs) { int i; for (i=0; i<3; i++) { attrs->attrs[i] = PyDict_New(); if (PyErr_Occurred()) return 1; RC_ALLOC("dict", attrs->attrs[i]); } attrs->vertex_name_index = 0; return 0; } void igraphmodule_i_attribute_struct_destroy(igraphmodule_i_attribute_struct *attrs) { int i; for (i=0; i<3; i++) { if (attrs->attrs[i]) { RC_DEALLOC("dict", attrs->attrs[i]); Py_DECREF(attrs->attrs[i]); } } if (attrs->vertex_name_index) { RC_DEALLOC("dict", attrs->vertex_name_index); Py_DECREF(attrs->vertex_name_index); } } int igraphmodule_i_attribute_struct_index_vertex_names( igraphmodule_i_attribute_struct *attrs, igraph_bool_t force) { Py_ssize_t n = 0; PyObject *name_list, *key, *value; if (attrs->vertex_name_index && !force) return 0; if (attrs->vertex_name_index == 0) { attrs->vertex_name_index = PyDict_New(); if (attrs->vertex_name_index == 0) { return 1; } } else PyDict_Clear(attrs->vertex_name_index); name_list = PyDict_GetItemString(attrs->attrs[1], "name"); if (name_list == 0) return 0; /* no name attribute */ n = PyList_Size(name_list) - 1; while (n >= 0) { key = PyList_GetItem(name_list, n); /* we don't own a reference to key */ if (key == 0) { return 1; } value = PyLong_FromLong(n); /* we do own a reference to value */ if (value == 0) { return 1; } if (PyDict_SetItem(attrs->vertex_name_index, key, value)) { /* probably unhashable vertex name. If the error is a TypeError, convert * it to a more readable error message */ if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError)) { PyErr_Format( PyExc_RuntimeError, "error while indexing vertex names; did you accidentally try to " "use a non-hashable object as a vertex name earlier?" " Check the name of vertex %R (%R)", value, key ); } return 1; } /* PyDict_SetItem did an INCREF for both the key and a value, therefore we * have to drop our reference on value */ Py_DECREF(value); n--; } return 0; } void igraphmodule_i_attribute_struct_invalidate_vertex_name_index( igraphmodule_i_attribute_struct *attrs) { if (attrs->vertex_name_index == 0) return; Py_DECREF(attrs->vertex_name_index); attrs->vertex_name_index = 0; } void igraphmodule_invalidate_vertex_name_index(igraph_t *graph) { igraphmodule_i_attribute_struct_invalidate_vertex_name_index(ATTR_STRUCT(graph)); } void igraphmodule_index_vertex_names(igraph_t *graph, igraph_bool_t force) { igraphmodule_i_attribute_struct_index_vertex_names(ATTR_STRUCT(graph), force); } int igraphmodule_PyObject_matches_attribute_record(PyObject* object, igraph_attribute_record_t* record) { if (record == 0) { return 0; } if (PyUnicode_Check(object)) { return PyUnicode_IsEqualToASCIIString(object, record->name); } return 0; } int igraphmodule_get_vertex_id_by_name(igraph_t *graph, PyObject* o, igraph_integer_t* vid) { igraphmodule_i_attribute_struct* attrs = ATTR_STRUCT(graph); PyObject* o_vid = NULL; int tmp; if (graph) { attrs = ATTR_STRUCT(graph); if (igraphmodule_i_attribute_struct_index_vertex_names(attrs, 0)) return 1; o_vid = PyDict_GetItem(attrs->vertex_name_index, o); } if (o_vid == NULL) { PyErr_Format(PyExc_ValueError, "no such vertex: %R", o); return 1; } if (!PyLong_Check(o_vid)) { PyErr_SetString(PyExc_ValueError, "non-numeric vertex ID assigned to vertex name. This is most likely a bug."); return 1; } if (PyLong_AsInt(o_vid, &tmp)) return 1; *vid = tmp; return 0; } /** * \brief Checks whether the given graph has the given graph attribute. * * \param graph the graph * \param name the name of the attribute being searched for */ igraph_bool_t igraphmodule_has_graph_attribute(const igraph_t *graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_GRAPH]; return name != 0 && dict != 0 && PyDict_GetItemString(dict, name) != 0; } /** * \brief Checks whether the given graph has the given vertex attribute. * * \param graph the graph * \param name the name of the attribute being searched for */ igraph_bool_t igraphmodule_has_vertex_attribute(const igraph_t *graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_VERTEX]; return name != 0 && dict != 0 && PyDict_GetItemString(dict, name) != 0; } /** * \brief Checks whether the given graph has the given edge attribute. * * \param graph the graph * \param name the name of the attribute being searched for */ igraph_bool_t igraphmodule_has_edge_attribute(const igraph_t *graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; return name != 0 && dict != 0 && PyDict_GetItemString(dict, name) != 0; } /** * \brief Creates a new edge attribute and sets the values to None. * * This returns the actual list that we use to store the edge attributes, so * be careful when modifying it - any modification will propagate back to the * graph itself. You have been warned. * * \param graph the graph * \param name the name of the attribute being created * \returns a Python list of the values or \c NULL if the given * attribute exists already (no exception set). The returned * reference is borrowed. */ PyObject* igraphmodule_create_edge_attribute(const igraph_t* graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; PyObject *values; Py_ssize_t i, n; if (dict == 0) { dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE] = PyDict_New(); } if (PyDict_GetItemString(dict, name)) return 0; n = igraph_ecount(graph); values = PyList_New(n); if (values == 0) return 0; for (i = 0; i < n; i++) { Py_INCREF(Py_None); if (PyList_SetItem(values, i, Py_None)) { /* reference stolen */ Py_DECREF(values); Py_DECREF(Py_None); return 0; } } if (PyDict_SetItemString(dict, name, values)) { Py_DECREF(values); return 0; } Py_DECREF(values); return values; } /** * \brief Returns the values of the given edge attribute for all edges in the * given graph. * * This returns the actual list that we use to store the edge attributes, so * be careful when modifying it - any modification will propagate back to the * graph itself. You have been warned. * * \param graph the graph * \param name the name of the attribute being searched for * \returns a Python list or \c NULL if there is no such attribute * (no exception set). The returned reference is borrowed. */ PyObject* igraphmodule_get_edge_attribute_values(const igraph_t* graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; if (dict == 0) return 0; return PyDict_GetItemString(dict, name); } /** * \brief Returns the values of the given edge attribute for all edges in the * given graph, optionally creating it if it does not exist. * * This returns the actual list that we use to store the edge attributes, so * be careful when modifying it - any modification will propagate back to the * graph itself. You have been warned. * * \param graph the graph * \param name the name of the attribute being searched for * \returns a Python list (borrowed reference) */ PyObject* igraphmodule_create_or_get_edge_attribute_values(const igraph_t* graph, const char* name) { PyObject *dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE], *result; if (dict == 0) return 0; result = PyDict_GetItemString(dict, name); if (result != 0) return result; return igraphmodule_create_edge_attribute(graph, name); } /* Attribute handlers for the Python interface */ /* Initialization */ static int igraphmodule_i_attribute_init(igraph_t *graph, igraph_vector_ptr_t *attr) { igraphmodule_i_attribute_struct* attrs; long int i, n; attrs=(igraphmodule_i_attribute_struct*)calloc(1, sizeof(igraphmodule_i_attribute_struct)); if (!attrs) IGRAPH_ERROR("not enough memory to allocate attribute hashes", IGRAPH_ENOMEM); if (igraphmodule_i_attribute_struct_init(attrs)) { PyErr_PrintEx(0); free(attrs); IGRAPH_ERROR("not enough memory to allocate attribute hashes", IGRAPH_ENOMEM); } graph->attr=(void*)attrs; /* See if we have graph attributes */ if (attr) { PyObject *dict=attrs->attrs[0], *value; char *s; n = igraph_vector_ptr_size(attr); for (i=0; itype) { case IGRAPH_ATTRIBUTE_NUMERIC: value=PyFloat_FromDouble((double)VECTOR(*(igraph_vector_t*)attr_rec->value)[0]); break; case IGRAPH_ATTRIBUTE_STRING: igraph_strvector_get((igraph_strvector_t*)attr_rec->value, 0, &s); if (s == 0) value=PyUnicode_FromString(""); else value=PyUnicode_FromString(s); break; case IGRAPH_ATTRIBUTE_BOOLEAN: value=VECTOR(*(igraph_vector_bool_t*)attr_rec->value)[0] ? Py_True : Py_False; Py_INCREF(value); break; default: IGRAPH_WARNING("unsupported attribute type (not string, numeric or Boolean)"); value=0; break; } if (value) { if (PyDict_SetItemString(dict, attr_rec->name, value)) { Py_DECREF(value); igraphmodule_i_attribute_struct_destroy(attrs); free(graph->attr); graph->attr = 0; IGRAPH_ERROR("failed to add attributes to graph attribute hash", IGRAPH_FAILURE); } Py_DECREF(value); value=0; } } } return IGRAPH_SUCCESS; } /* Destruction */ static void igraphmodule_i_attribute_destroy(igraph_t *graph) { igraphmodule_i_attribute_struct* attrs; /* printf("Destroying attribute table\n"); */ if (graph->attr) { attrs=(igraphmodule_i_attribute_struct*)graph->attr; igraphmodule_i_attribute_struct_destroy(attrs); free(attrs); } } /* Copying */ static int igraphmodule_i_attribute_copy(igraph_t *to, const igraph_t *from, igraph_bool_t ga, igraph_bool_t va, igraph_bool_t ea) { igraphmodule_i_attribute_struct *fromattrs, *toattrs; PyObject *key, *value, *newval, *o=NULL; igraph_bool_t copy_attrs[3] = { ga, va, ea }; int i, j; Py_ssize_t pos = 0; if (from->attr) { fromattrs=ATTR_STRUCT(from); /* what to do with the original value of toattrs? */ toattrs=(igraphmodule_i_attribute_struct*)calloc(1, sizeof(igraphmodule_i_attribute_struct)); if (!toattrs) IGRAPH_ERROR("not enough memory to allocate attribute hashes", IGRAPH_ENOMEM); if (igraphmodule_i_attribute_struct_init(toattrs)) { PyErr_PrintEx(0); free(toattrs); IGRAPH_ERROR("not enough memory to allocate attribute hashes", IGRAPH_ENOMEM); } to->attr=toattrs; for (i=0; i<3; i++) { if (!copy_attrs[i]) continue; if (!PyDict_Check(fromattrs->attrs[i])) { toattrs->attrs[i]=fromattrs->attrs[i]; Py_XINCREF(fromattrs->attrs[i]); continue; } pos = 0; while (PyDict_Next(fromattrs->attrs[i], &pos, &key, &value)) { /* value is only borrowed, so copy it */ if (i>0) { newval=PyList_New(PyList_Size(value)); for (j=0; j < PyList_Size(value); j++) { o=PyList_GetItem(value, j); Py_INCREF(o); PyList_SetItem(newval, j, o); } } else { newval=value; Py_INCREF(newval); } PyDict_SetItem(toattrs->attrs[i], key, newval); Py_DECREF(newval); /* compensate for PyDict_SetItem */ } } } return IGRAPH_SUCCESS; } /* Adding vertices */ static int igraphmodule_i_attribute_add_vertices(igraph_t *graph, long int nv, igraph_vector_ptr_t *attr) { /* Extend the end of every value in the vertex hash with nv pieces of None */ PyObject *key, *value, *dict; long int i, j, k, l; igraph_attribute_record_t *attr_rec; igraph_bool_t *added_attrs=0; Py_ssize_t pos = 0; if (!graph->attr) return IGRAPH_SUCCESS; if (nv<0) return IGRAPH_SUCCESS; if (attr) { added_attrs = (igraph_bool_t*)calloc((size_t)igraph_vector_ptr_size(attr), sizeof(igraph_bool_t)); if (!added_attrs) IGRAPH_ERROR("can't add vertex attributes", IGRAPH_ENOMEM); IGRAPH_FINALLY(free, added_attrs); } dict=ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_VERTEX]; if (!PyDict_Check(dict)) IGRAPH_ERROR("vertex attribute hash type mismatch", IGRAPH_EINVAL); while (PyDict_Next(dict, &pos, &key, &value)) { if (!PyList_Check(value)) IGRAPH_ERROR("vertex attribute hash member is not a list", IGRAPH_EINVAL); /* Check if we have specific values for the given attribute */ attr_rec=0; if (attr) { j=igraph_vector_ptr_size(attr); for (i=0; itype) { case IGRAPH_ATTRIBUTE_NUMERIC: o=PyFloat_FromDouble((double)VECTOR(*(igraph_vector_t*)attr_rec->value)[i]); break; case IGRAPH_ATTRIBUTE_STRING: igraph_strvector_get((igraph_strvector_t*)attr_rec->value, i, &s); o=PyUnicode_FromString(s); break; case IGRAPH_ATTRIBUTE_BOOLEAN: o=VECTOR(*(igraph_vector_bool_t*)attr_rec->value)[i] ? Py_True : Py_False; Py_INCREF(o); break; default: IGRAPH_WARNING("unsupported attribute type (not string, numeric or Boolean)"); o=0; break; } if (o) { if (PyList_Append(value, o) == -1) IGRAPH_ERROR("can't extend a vertex attribute hash member", IGRAPH_FAILURE); else Py_DECREF(o); } } /* Invalidate the vertex name index if needed */ if (!strcmp(attr_rec->name, "name")) igraphmodule_i_attribute_struct_invalidate_vertex_name_index(ATTR_STRUCT(graph)); } else { for (i=0; itype) { case IGRAPH_ATTRIBUTE_NUMERIC: o=PyFloat_FromDouble((double)VECTOR(*(igraph_vector_t*)attr_rec->value)[i]); break; case IGRAPH_ATTRIBUTE_STRING: igraph_strvector_get((igraph_strvector_t*)attr_rec->value, i, &s); o=PyUnicode_FromString(s); break; case IGRAPH_ATTRIBUTE_BOOLEAN: o=VECTOR(*(igraph_vector_bool_t*)attr_rec->value)[i] ? Py_True : Py_False; Py_INCREF(o); break; default: IGRAPH_WARNING("unsupported attribute type (not string, numeric or Boolean)"); o=0; break; } if (o) PyList_SetItem(value, i+j, o); } /* Invalidate the vertex name index if needed */ if (!strcmp(attr_rec->name, "name")) igraphmodule_i_attribute_struct_invalidate_vertex_name_index(ATTR_STRUCT(graph)); PyDict_SetItemString(dict, attr_rec->name, value); Py_DECREF(value); /* compensate for PyDict_SetItemString */ } free(added_attrs); IGRAPH_FINALLY_CLEAN(1); } return IGRAPH_SUCCESS; } /* Permuting vertices */ static int igraphmodule_i_attribute_permute_vertices(const igraph_t *graph, igraph_t *newgraph, const igraph_vector_t *idx) { long int n, i; PyObject *key, *value, *dict, *newdict, *newlist, *o; Py_ssize_t pos=0; dict=ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_VERTEX]; if (!PyDict_Check(dict)) return 1; newdict=PyDict_New(); if (!newdict) return 1; n=igraph_vector_size(idx); pos=0; while (PyDict_Next(dict, &pos, &key, &value)) { newlist=PyList_New(n); for (i=0; iattr) return IGRAPH_SUCCESS; if (ne<0) return IGRAPH_SUCCESS; if (attr) { added_attrs = (igraph_bool_t*)calloc((size_t)igraph_vector_ptr_size(attr), sizeof(igraph_bool_t)); if (!added_attrs) IGRAPH_ERROR("can't add vertex attributes", IGRAPH_ENOMEM); IGRAPH_FINALLY(free, added_attrs); } dict=ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; if (!PyDict_Check(dict)) IGRAPH_ERROR("edge attribute hash type mismatch", IGRAPH_EINVAL); while (PyDict_Next(dict, &pos, &key, &value)) { if (!PyList_Check(value)) IGRAPH_ERROR("edge attribute hash member is not a list", IGRAPH_EINVAL); /* Check if we have specific values for the given attribute */ attr_rec=0; if (attr) { j=igraph_vector_ptr_size(attr); for (i=0; itype) { case IGRAPH_ATTRIBUTE_NUMERIC: o=PyFloat_FromDouble((double)VECTOR(*(igraph_vector_t*)attr_rec->value)[i]); break; case IGRAPH_ATTRIBUTE_STRING: igraph_strvector_get((igraph_strvector_t*)attr_rec->value, i, &s); o=PyUnicode_FromString(s); break; case IGRAPH_ATTRIBUTE_BOOLEAN: o=VECTOR(*(igraph_vector_bool_t*)attr_rec->value)[i] ? Py_True : Py_False; Py_INCREF(o); break; default: IGRAPH_WARNING("unsupported attribute type (not string, numeric or Boolean)"); o=0; break; } if (o) { if (PyList_Append(value, o) == -1) IGRAPH_ERROR("can't extend an edge attribute hash member", IGRAPH_FAILURE); else Py_DECREF(o); } } } else { for (i=0; itype) { case IGRAPH_ATTRIBUTE_NUMERIC: o=PyFloat_FromDouble((double)VECTOR(*(igraph_vector_t*)attr_rec->value)[i]); break; case IGRAPH_ATTRIBUTE_STRING: igraph_strvector_get((igraph_strvector_t*)attr_rec->value, i, &s); o=PyUnicode_FromString(s); break; case IGRAPH_ATTRIBUTE_BOOLEAN: o=VECTOR(*(igraph_vector_bool_t*)attr_rec->value)[i] ? Py_True : Py_False; Py_INCREF(o); break; default: IGRAPH_WARNING("unsupported attribute type (not string, numeric or Boolean)"); o=0; break; } if (o) { PyList_SetItem(value, i+j, o); } } PyDict_SetItemString(dict, attr_rec->name, value); Py_DECREF(value); /* compensate for PyDict_SetItemString */ } free(added_attrs); IGRAPH_FINALLY_CLEAN(1); } return IGRAPH_SUCCESS; } /* Deleting edges, currently unused */ /* static void igraphmodule_i_attribute_delete_edges(igraph_t *graph, const igraph_vector_t *idx) { long int n, i, ndeleted=0; PyObject *key, *value, *dict, *o; Py_ssize_t pos=0; dict=ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; if (!PyDict_Check(dict)) return; n=igraph_vector_size(idx); for (i=0; i 0 ? PyList_GetItem(values, (Py_ssize_t)VECTOR(*v)[0]) : Py_None; if (item == 0) { Py_DECREF(res); return 0; } Py_INCREF(item); if (PyList_SetItem(res, i, item)) { /* reference to item stolen */ Py_DECREF(item); Py_DECREF(res); return 0; } } return res; } /* Auxiliary function for combining vertices/edges. Given a merge list * (which specifies the vertex/edge IDs that were merged and the source * attribute values, returns a new list with the new attribute values. * Each new attribute is derived from a randomly selected entry of the set of * merged vertices/edges. */ static PyObject* igraphmodule_i_ac_random(PyObject* values, const igraph_vector_ptr_t *merges) { long int i, len = igraph_vector_ptr_size(merges); PyObject *res, *item, *num; PyObject *random_module = PyImport_ImportModule("random"); PyObject *random_func; if (random_module == 0) return 0; random_func = PyObject_GetAttrString(random_module, "random"); Py_DECREF(random_module); if (random_func == 0) return 0; res = PyList_New(len); for (i = 0; i < len; i++) { igraph_vector_t *v = (igraph_vector_t*)VECTOR(*merges)[i]; long int n = igraph_vector_size(v); if (n > 0) { num = PyObject_CallObject(random_func, 0); if (num == 0) { Py_DECREF(random_func); Py_DECREF(res); return 0; } item = PyList_GetItem(values, (Py_ssize_t)VECTOR(*v)[(long int)(n*PyFloat_AsDouble(num))]); if (item == 0) { Py_DECREF(random_func); Py_DECREF(res); return 0; } Py_DECREF(num); } else { item = Py_None; } Py_INCREF(item); if (PyList_SetItem(res, i, item)) { /* reference to item stolen */ Py_DECREF(item); Py_DECREF(random_func); Py_DECREF(res); return 0; } } Py_DECREF(random_func); return res; } /* Auxiliary function for combining vertices/edges. Given a merge list * (which specifies the vertex/edge IDs that were merged and the source * attribute values, returns a new list with the new attribute values. * Each new attribute is derived from the last entry of the set of merged * vertices/edges. */ static PyObject* igraphmodule_i_ac_last(PyObject* values, const igraph_vector_ptr_t *merges) { long int i, len = igraph_vector_ptr_size(merges); PyObject *res, *item; res = PyList_New(len); for (i = 0; i < len; i++) { igraph_vector_t *v = (igraph_vector_t*)VECTOR(*merges)[i]; long int n = igraph_vector_size(v); item = (n > 0) ? PyList_GetItem(values, (Py_ssize_t)VECTOR(*v)[n-1]) : Py_None; if (item == 0) { Py_DECREF(res); return 0; } Py_INCREF(item); if (PyList_SetItem(res, i, item)) { /* reference to item stolen */ Py_DECREF(item); Py_DECREF(res); return 0; } } return res; } /* Auxiliary function for combining vertices/edges. Given a merge list * (which specifies the vertex/edge IDs that were merged and the source * attribute values, returns a new list with the new attribute values. * Each new attribute is derived from the mean of the attributes of * the merged vertices/edges. */ static PyObject* igraphmodule_i_ac_mean(PyObject* values, const igraph_vector_ptr_t *merges) { long int i, len = igraph_vector_ptr_size(merges); PyObject *res, *item; res = PyList_New(len); for (i = 0; i < len; i++) { igraph_vector_t *v = (igraph_vector_t*)VECTOR(*merges)[i]; igraph_real_t num = 0.0, mean = 0.0; long int j, n = igraph_vector_size(v); for (j = 0; j < n; ) { item = PyList_GetItem(values, (Py_ssize_t)VECTOR(*v)[j]); if (item == 0) { Py_DECREF(res); return 0; } if (igraphmodule_PyObject_to_real_t(item, &num)) { PyErr_SetString(PyExc_TypeError, "mean can only be invoked on numeric attributes"); Py_DECREF(res); return 0; } j++; num -= mean; mean += num / j; } /* reference to new float stolen */ item = PyFloat_FromDouble((double)mean); if (PyList_SetItem(res, i, item)) { /* reference to item stolen */ Py_DECREF(item); Py_DECREF(res); return 0; } } return res; } /* Auxiliary function for combining vertices/edges. Given a merge list * (which specifies the vertex/edge IDs that were merged and the source * attribute values, returns a new list with the new attribute values. * Each new attribute is derived from the median of the attributes of * the merged vertices/edges. */ static PyObject* igraphmodule_i_ac_median(PyObject* values, const igraph_vector_ptr_t *merges) { long int i, len = igraph_vector_ptr_size(merges); PyObject *res, *list, *item; res = PyList_New(len); for (i = 0; i < len; i++) { igraph_vector_t *v = (igraph_vector_t*)VECTOR(*merges)[i]; long int j, n = igraph_vector_size(v); list = PyList_New(n); for (j = 0; j < n; j++) { item = PyList_GetItem(values, (Py_ssize_t)VECTOR(*v)[j]); if (item == 0) { Py_DECREF(res); return 0; } Py_INCREF(item); if (PyList_SetItem(list, j, item)) { /* reference to item stolen */ Py_DECREF(item); Py_DECREF(list); Py_DECREF(res); return 0; } } /* sort the list */ if (PyList_Sort(list)) { Py_DECREF(list); Py_DECREF(res); return 0; } if (n == 0) { item = Py_None; Py_INCREF(item); } else if (n % 2 == 1) { item = PyList_GetItem(list, n / 2); if (item == 0) { Py_DECREF(list); Py_DECREF(res); return 0; } Py_INCREF(item); } else { igraph_real_t num1, num2; item = PyList_GetItem(list, n / 2 - 1); if (item == 0) { Py_DECREF(list); Py_DECREF(res); return 0; } if (igraphmodule_PyObject_to_real_t(item, &num1)) { Py_DECREF(list); Py_DECREF(res); return 0; } item = PyList_GetItem(list, n / 2); if (item == 0) { Py_DECREF(list); Py_DECREF(res); return 0; } if (igraphmodule_PyObject_to_real_t(item, &num2)) { Py_DECREF(list); Py_DECREF(res); return 0; } item = PyFloat_FromDouble((num1 + num2) / 2); } /* reference to item stolen */ if (PyList_SetItem(res, i, item)) { Py_DECREF(item); Py_DECREF(list); Py_DECREF(res); return 0; } } return res; } static void igraphmodule_i_free_attribute_combination_records( igraph_attribute_combination_record_t* records) { igraph_attribute_combination_record_t* ptr = records; while (ptr->name != 0) { free((char*)ptr->name); ptr++; } free(records); } /* Auxiliary function for the common parts of * igraphmodule_i_attribute_combine_vertices and * igraphmodule_i_attribute_combine_edges */ static int igraphmodule_i_attribute_combine_dicts(PyObject *dict, PyObject *newdict, const igraph_vector_ptr_t *merges, const igraph_attribute_combination_t *comb) { PyObject *key, *value; Py_ssize_t pos; igraph_attribute_combination_record_t* todo; Py_ssize_t i, n; if (!PyDict_Check(dict) || !PyDict_Check(newdict)) return 1; /* Allocate memory for the attribute_combination_records */ n = PyDict_Size(dict); todo = (igraph_attribute_combination_record_t*)calloc( n+1, sizeof(igraph_attribute_combination_record_t) ); if (todo == 0) { IGRAPH_ERROR("cannot allocate memory for attribute combination", IGRAPH_ENOMEM); } for (i = 0; i < n+1; i++) todo[i].name = 0; /* sentinel elements */ IGRAPH_FINALLY(igraphmodule_i_free_attribute_combination_records, todo); /* Collect what to do for each attribute in the source dict */ pos = 0; i = 0; while (PyDict_Next(dict, &pos, &key, &value)) { todo[i].name = PyUnicode_CopyAsString(key); if (todo[i].name == 0) IGRAPH_ERROR("PyUnicode_CopyAsString failed", IGRAPH_FAILURE); igraph_attribute_combination_query(comb, todo[i].name, &todo[i].type, &todo[i].func); i++; } /* Combine the attributes. Here we make use of the fact that PyDict_Next * will iterate over the dict in the same order */ pos = 0; i = 0; while (PyDict_Next(dict, &pos, &key, &value)) { PyObject *empty_str; PyObject *func; PyObject *newvalue; /* Safety check */ if (!PyUnicode_IsEqualToASCIIString(key, todo[i].name)) { IGRAPH_ERROR("PyDict_Next iteration order not consistent. " "This should never happen. Please report the bug to the igraph " "developers!", IGRAPH_FAILURE); } newvalue = 0; switch (todo[i].type) { case IGRAPH_ATTRIBUTE_COMBINE_DEFAULT: case IGRAPH_ATTRIBUTE_COMBINE_IGNORE: break; case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION: func = (PyObject*)todo[i].func; newvalue = igraphmodule_i_ac_func(value, merges, func); break; case IGRAPH_ATTRIBUTE_COMBINE_SUM: newvalue = igraphmodule_i_ac_sum(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_PROD: newvalue = igraphmodule_i_ac_prod(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_MIN: newvalue = igraphmodule_i_ac_builtin_func(value, merges, "min"); break; case IGRAPH_ATTRIBUTE_COMBINE_MAX: newvalue = igraphmodule_i_ac_builtin_func(value, merges, "max"); break; case IGRAPH_ATTRIBUTE_COMBINE_RANDOM: newvalue = igraphmodule_i_ac_random(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_FIRST: newvalue = igraphmodule_i_ac_first(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_LAST: newvalue = igraphmodule_i_ac_last(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_MEAN: newvalue = igraphmodule_i_ac_mean(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN: newvalue = igraphmodule_i_ac_median(value, merges); break; case IGRAPH_ATTRIBUTE_COMBINE_CONCAT: empty_str = PyUnicode_FromString(""); func = PyObject_GetAttrString(empty_str, "join"); newvalue = igraphmodule_i_ac_func(value, merges, func); Py_DECREF(func); Py_DECREF(empty_str); break; default: IGRAPH_ERROR("Unsupported combination type. " "This should never happen. Please report the bug to the igraph " "developers!", IGRAPH_FAILURE); } if (newvalue) { if (PyDict_SetItem(newdict, key, newvalue)) { Py_DECREF(newvalue); /* PyDict_SetItem does not steal reference */ IGRAPH_ERROR("PyDict_SetItem failed when combining attributes.", IGRAPH_FAILURE); } Py_DECREF(newvalue); /* PyDict_SetItem does not steal reference */ } else { /* We can arrive here for two reasons: first, if the attribute is to * be ignored explicitly; second, if there was an error. */ if (PyErr_Occurred()) { IGRAPH_ERROR("Unexpected failure when combining attributes", IGRAPH_FAILURE); } } i++; } igraphmodule_i_free_attribute_combination_records(todo); IGRAPH_FINALLY_CLEAN(1); return 0; } /* Combining vertices */ static int igraphmodule_i_attribute_combine_vertices(const igraph_t *graph, igraph_t *newgraph, const igraph_vector_ptr_t *merges, const igraph_attribute_combination_t *comb) { PyObject *dict, *newdict; int result; /* Get the attribute dicts */ dict = ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_VERTEX]; newdict = ATTR_STRUCT_DICT(newgraph)[ATTRHASH_IDX_VERTEX]; /* Combine the attribute dicts */ result = igraphmodule_i_attribute_combine_dicts(dict, newdict, merges, comb); /* Invalidate vertex name index */ igraphmodule_i_attribute_struct_invalidate_vertex_name_index(ATTR_STRUCT(graph)); return result; } /* Combining edges */ static int igraphmodule_i_attribute_combine_edges(const igraph_t *graph, igraph_t *newgraph, const igraph_vector_ptr_t *merges, const igraph_attribute_combination_t *comb) { PyObject *dict, *newdict; /* Get the attribute dicts */ dict=ATTR_STRUCT_DICT(graph)[ATTRHASH_IDX_EDGE]; newdict=ATTR_STRUCT_DICT(newgraph)[ATTRHASH_IDX_EDGE]; return igraphmodule_i_attribute_combine_dicts(dict, newdict, merges, comb); } /* Getting attribute names and types */ static int igraphmodule_i_attribute_get_info(const igraph_t *graph, igraph_strvector_t *gnames, igraph_vector_t *gtypes, igraph_strvector_t *vnames, igraph_vector_t *vtypes, igraph_strvector_t *enames, igraph_vector_t *etypes) { igraph_strvector_t *names[3] = { gnames, vnames, enames }; igraph_vector_t *types[3] = { gtypes, vtypes, etypes }; int retval; long int i, j, k, l, m; for (i=0; i<3; i++) { igraph_strvector_t *n = names[i]; igraph_vector_t *t = types[i]; PyObject *dict = ATTR_STRUCT_DICT(graph)[i]; PyObject *keys; PyObject *values; PyObject *o=0; keys=PyDict_Keys(dict); if (!keys) IGRAPH_ERROR("Internal error in PyDict_Keys", IGRAPH_FAILURE); if (n) { retval = igraphmodule_PyList_to_strvector_t(keys, n); if (retval) return retval; } if (t) { k=PyList_Size(keys); igraph_vector_resize(t, k); for (j=0; j0) { for (i=0; iob_type) : 0; if (type_obj != 0) { PyErr_Format(PyExc_TypeError, "igraph supports string attribute names only, got %R", type_obj); } else { PyErr_Format(PyExc_TypeError, "igraph supports string attribute names only"); } return 0; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/attributes.h0000644000175100001710000000744000000000000020347 0ustar00runnerdocker00000000000000/* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PY_IGRAPH_ATTRIBUTES_H #define PY_IGRAPH_ATTRIBUTES_H #include "preamble.h" #include #include #include #include #include #define ATTRHASH_IDX_GRAPH 0 #define ATTRHASH_IDX_VERTEX 1 #define ATTRHASH_IDX_EDGE 2 typedef struct { PyObject* attrs[3]; PyObject* vertex_name_index; } igraphmodule_i_attribute_struct; #define ATTR_STRUCT(graph) ((igraphmodule_i_attribute_struct*)((graph)->attr)) #define ATTR_STRUCT_DICT(graph) ((igraphmodule_i_attribute_struct*)((graph)->attr))->attrs #define ATTR_NAME_INDEX(graph) ((igraphmodule_i_attribute_struct*)((graph)->attr))->vertex_name_index int igraphmodule_i_attribute_get_type(const igraph_t *graph, igraph_attribute_type_t *type, igraph_attribute_elemtype_t elemtype, const char *name); int igraphmodule_i_get_numeric_graph_attr(const igraph_t *graph, const char *name, igraph_vector_t *value); int igraphmodule_i_get_numeric_vertex_attr(const igraph_t *graph, const char *name, igraph_vs_t vs, igraph_vector_t *value); int igraphmodule_i_get_numeric_edge_attr(const igraph_t *graph, const char *name, igraph_es_t es, igraph_vector_t *value); int igraphmodule_i_get_string_graph_attr(const igraph_t *graph, const char *name, igraph_strvector_t *value); int igraphmodule_i_get_string_vertex_attr(const igraph_t *graph, const char *name, igraph_vs_t vs, igraph_strvector_t *value); int igraphmodule_i_get_string_edge_attr(const igraph_t *graph, const char *name, igraph_es_t es, igraph_strvector_t *value); int igraphmodule_i_get_boolean_graph_attr(const igraph_t *graph, const char *name, igraph_vector_bool_t *value); int igraphmodule_i_get_boolean_vertex_attr(const igraph_t *graph, const char *name, igraph_vs_t vs, igraph_vector_bool_t *value); int igraphmodule_i_get_boolean_edge_attr(const igraph_t *graph, const char *name, igraph_es_t es, igraph_vector_bool_t *value); int igraphmodule_attribute_name_check(PyObject* obj); void igraphmodule_initialize_attribute_handler(void); void igraphmodule_index_vertex_names(igraph_t *graph, igraph_bool_t force); void igraphmodule_invalidate_vertex_name_index(igraph_t *graph); int igraphmodule_get_vertex_id_by_name(igraph_t *graph, PyObject* o, igraph_integer_t* id); PyObject* igraphmodule_create_edge_attribute(const igraph_t* graph, const char* name); PyObject* igraphmodule_create_or_get_edge_attribute_values(const igraph_t* graph, const char* name); PyObject* igraphmodule_get_edge_attribute_values(const igraph_t* graph, const char* name); igraph_bool_t igraphmodule_has_graph_attribute(const igraph_t *graph, const char* name); igraph_bool_t igraphmodule_has_vertex_attribute(const igraph_t *graph, const char* name); igraph_bool_t igraphmodule_has_edge_attribute(const igraph_t *graph, const char* name); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/bfsiter.c0000644000175100001710000002055100000000000017610 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "bfsiter.h" #include "common.h" #include "error.h" #include "vertexobject.h" /** * \ingroup python_interface * \defgroup python_interface_bfsiter BFS iterator object */ PyTypeObject igraphmodule_BFSIterType; /** * \ingroup python_interface_bfsiter * \brief Allocate a new BFS iterator object for a given graph and a given root * \param g the graph object being referenced * \param vid the root vertex index * \param advanced whether the iterator should be advanced (returning distance and parent as well) * \return the allocated PyObject */ PyObject* igraphmodule_BFSIter_new(igraphmodule_GraphObject *g, PyObject *root, igraph_neimode_t mode, igraph_bool_t advanced) { igraphmodule_BFSIterObject* o; long int no_of_nodes, r; o=PyObject_GC_New(igraphmodule_BFSIterObject, &igraphmodule_BFSIterType); Py_INCREF(g); o->gref=g; o->graph=&g->g; if (!PyLong_Check(root) && !PyObject_IsInstance(root, (PyObject*)&igraphmodule_VertexType)) { PyErr_SetString(PyExc_TypeError, "root must be integer or igraph.Vertex"); return NULL; } no_of_nodes=igraph_vcount(&g->g); o->visited=(char*)calloc(no_of_nodes, sizeof(char)); if (o->visited == 0) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if (igraph_dqueue_init(&o->queue, 100)) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if (igraph_vector_init(&o->neis, 0)) { PyErr_SetString(PyExc_MemoryError, "out of memory"); igraph_dqueue_destroy(&o->queue); return NULL; } if (PyLong_Check(root)) { r=PyLong_AsLong(root); } else { r=((igraphmodule_VertexObject*)root)->idx; } if (igraph_dqueue_push(&o->queue, r) || igraph_dqueue_push(&o->queue, 0) || igraph_dqueue_push(&o->queue, -1)) { igraph_dqueue_destroy(&o->queue); igraph_vector_destroy(&o->neis); PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } o->visited[r]=1; if (!igraph_is_directed(&g->g)) mode=IGRAPH_ALL; o->mode=mode; o->advanced=advanced; PyObject_GC_Track(o); RC_ALLOC("BFSIter", o); return (PyObject*)o; } /** * \ingroup python_interface_bfsiter * \brief Support for cyclic garbage collection in Python * * This is necessary because the \c igraph.BFSIter object contains several * other \c PyObject pointers and they might point back to itself. */ int igraphmodule_BFSIter_traverse(igraphmodule_BFSIterObject *self, visitproc visit, void *arg) { int vret; RC_TRAVERSE("BFSIter", self); if (self->gref) { vret=visit((PyObject*)self->gref, arg); if (vret != 0) return vret; } return 0; } /** * \ingroup python_interface_bfsiter * \brief Clears the iterator's subobject (before deallocation) */ int igraphmodule_BFSIter_clear(igraphmodule_BFSIterObject *self) { PyObject *tmp; PyObject_GC_UnTrack(self); tmp=(PyObject*)self->gref; self->gref=NULL; Py_XDECREF(tmp); igraph_dqueue_destroy(&self->queue); igraph_vector_destroy(&self->neis); free(self->visited); self->visited=0; return 0; } /** * \ingroup python_interface_bfsiter * \brief Deallocates a Python representation of a given BFS iterator object */ void igraphmodule_BFSIter_dealloc(igraphmodule_BFSIterObject* self) { igraphmodule_BFSIter_clear(self); RC_DEALLOC("BFSIter", self); PyObject_GC_Del(self); } PyObject* igraphmodule_BFSIter_iter(igraphmodule_BFSIterObject* self) { Py_INCREF(self); return (PyObject*)self; } PyObject* igraphmodule_BFSIter_iternext(igraphmodule_BFSIterObject* self) { if (!igraph_dqueue_empty(&self->queue)) { igraph_integer_t vid = (igraph_integer_t)igraph_dqueue_pop(&self->queue); igraph_integer_t dist = (igraph_integer_t)igraph_dqueue_pop(&self->queue); igraph_integer_t parent = (igraph_integer_t)igraph_dqueue_pop(&self->queue); long int i; if (igraph_neighbors(self->graph, &self->neis, vid, self->mode)) { igraphmodule_handle_igraph_error(); return NULL; } for (i=0; ineis); i++) { igraph_integer_t neighbor = (igraph_integer_t)VECTOR(self->neis)[i]; if (self->visited[neighbor]==0) { self->visited[neighbor]=1; if (igraph_dqueue_push(&self->queue, neighbor) || igraph_dqueue_push(&self->queue, dist+1) || igraph_dqueue_push(&self->queue, vid)) { igraphmodule_handle_igraph_error(); return NULL; } } } if (self->advanced) { PyObject *vertexobj, *parentobj; vertexobj = igraphmodule_Vertex_New(self->gref, vid); if (!vertexobj) return NULL; if (parent >= 0) { parentobj = igraphmodule_Vertex_New(self->gref, parent); if (!parentobj) return NULL; } else { Py_INCREF(Py_None); parentobj=Py_None; } return Py_BuildValue("NlN", vertexobj, (long int)dist, parentobj); } else { return igraphmodule_Vertex_New(self->gref, vid); } } else { return NULL; } } /** * \ingroup python_interface_bfsiter * Method table for the \c igraph.BFSIter object */ PyMethodDef igraphmodule_BFSIter_methods[] = { {NULL} }; /** \ingroup python_interface_bfsiter * Python type object referencing the methods Python calls when it performs various operations on * a BFS iterator of a graph */ PyTypeObject igraphmodule_BFSIterType = { PyVarObject_HEAD_INIT(0, 0) "igraph.BFSIter", // tp_name sizeof(igraphmodule_BFSIterObject), // tp_basicsize 0, // tp_itemsize (destructor)igraphmodule_BFSIter_dealloc, // tp_dealloc 0, // tp_print 0, // tp_getattr 0, // tp_setattr 0, /* tp_compare (2.x) / tp_reserved (3.x) */ 0, // tp_repr 0, // tp_as_number 0, // tp_as_sequence 0, // tp_as_mapping 0, // tp_hash 0, // tp_call 0, // tp_str 0, // tp_getattro 0, // tp_setattro 0, // tp_as_buffer Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, // tp_flags "igraph BFS iterator object", // tp_doc (traverseproc) igraphmodule_BFSIter_traverse, /* tp_traverse */ (inquiry) igraphmodule_BFSIter_clear, /* tp_clear */ 0, // tp_richcompare 0, // tp_weaklistoffset (getiterfunc)igraphmodule_BFSIter_iter, /* tp_iter */ (iternextfunc)igraphmodule_BFSIter_iternext, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/bfsiter.h0000644000175100001710000000324000000000000017611 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_BFSITER_H #define PYTHON_BFSITER_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_bfsiter * \brief A structure representing a BFS iterator of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_dqueue_t queue; igraph_vector_t neis; igraph_t *graph; char *visited; igraph_neimode_t mode; igraph_bool_t advanced; } igraphmodule_BFSIterObject; PyObject* igraphmodule_BFSIter_new(igraphmodule_GraphObject *g, PyObject *o, igraph_neimode_t mode, igraph_bool_t advanced); int igraphmodule_BFSIter_traverse(igraphmodule_BFSIterObject *self, visitproc visit, void *arg); int igraphmodule_BFSIter_clear(igraphmodule_BFSIterObject *self); void igraphmodule_BFSIter_dealloc(igraphmodule_BFSIterObject* self); extern PyTypeObject igraphmodule_BFSIterType; #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/common.c0000644000175100001710000000467500000000000017453 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "common.h" #include "structmember.h" /** * \ingroup python_interface * \brief Handler function for all unimplemented \c igraph.Graph methods * * This function is called whenever an unimplemented \c igraph.Graph method * is called ("unimplemented" meaning that there is a method name in the * method table of \c igraph.Graph , but there isn't any working implementation * either because the underlying \c igraph API might be subject to change * or because the calling format from Python is not decided yet (or maybe * because of laziness or lack of time ;)) * * All of the parameters are ignored, they are here just to make the * function satisfy the requirements of \c PyCFunction, thus allowing it * to be included in a method table. * * \return NULL */ PyObject* igraphmodule_unimplemented(PyObject* self, PyObject* args, PyObject* kwds) { PyErr_SetString(PyExc_NotImplementedError, "This method is unimplemented."); return NULL; } /** * \ingroup python_interface * \brief Resolves a weak reference to an \c igraph.Graph * \return the \c igraph.Graph object or NULL if the weak reference is dead. * Sets an exception in the latter case. */ PyObject* igraphmodule_resolve_graph_weakref(PyObject* ref) { PyObject *o; #ifndef PYPY_VERSION /* PyWeakref_Check is not implemented in PyPy yet */ if (!PyWeakref_Check(ref)) { PyErr_SetString(PyExc_TypeError, "weak reference expected"); return NULL; } #endif /* PYPY_VERSION */ o=PyWeakref_GetObject(ref); if (o == Py_None) { PyErr_SetString(PyExc_TypeError, "underlying graph has already been destroyed"); return NULL; } return o; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/common.h0000644000175100001710000000357300000000000017454 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_COMMON_H #define PYTHON_COMMON_H #include "preamble.h" #ifdef RC_DEBUG # define RC_ALLOC(T, P) fprintf(stderr, "[ alloc ] " T " @ %p\n", P) # define RC_DECREF(T, P) fprintf(stderr, "[ ref - ] " T " @ %p (was: %d)\n", P, (int)P->ob_refcnt); # define RC_INCREF(T, P) fprintf(stderr, "[ ref + ] " T " @ %p (was: %d)\n", P, (int)P->ob_refcnt); # define RC_PRINT(P) fprintf(stderr, "[refcntr] %s @ %p = %d\n", ((PyTypeObject*)P->ob_type)->tp_name, P, (int)P->ob_refcnt); # define RC_DEALLOC(T, P) fprintf(stderr, "[dealloc] " T " @ %p\n", P); # define RC_TRAVERSE(T, P) #else # define RC_ALLOC(T, P) # define RC_DECREF(T, P) # define RC_INCREF(T, P) # define RC_PRINT(P) # define RC_DEALLOC(T, P) # define RC_TRAVERSE(T, P) #endif #ifndef Py_RETURN #define Py_RETURN(x) { if (x) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } #endif #define ATTRIBUTE_TYPE_VERTEX 1 #define ATTRIBUTE_TYPE_EDGE 2 PyObject* igraphmodule_unimplemented(PyObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_resolve_graph_weakref(PyObject* ref); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/convert.c0000644000175100001710000027377100000000000017650 0ustar00runnerdocker00000000000000/* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /************************ Miscellaneous functions *************************/ #include #include "attributes.h" #include "convert.h" #include "edgeseqobject.h" #include "edgeobject.h" #include "error.h" #include "graphobject.h" #include "memory.h" #include "pyhelpers.h" #include "vertexseqobject.h" #include "vertexobject.h" #if defined(_MSC_VER) #define strcasecmp _stricmp #endif /** * \brief Converts a Python long to a C int * * This is similar to PyLong_AsLong, but it checks for overflow first and * throws an exception if necessary. * * Returns -1 if there was an error, 0 otherwise. */ int PyLong_AsInt(PyObject* obj, int* result) { long dummy = PyLong_AsLong(obj); if (dummy < INT_MIN) { PyErr_SetString(PyExc_OverflowError, "long integer too small for conversion to C int"); return -1; } if (dummy > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "long integer too large for conversion to C int"); return -1; } *result = (int)dummy; return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to a corresponding igraph enum. * * The numeric value is returned as an integer that must be converted * explicitly to the corresponding igraph enum type. This is to allow one * to use the same common conversion routine for multiple enum types. * * \param o a Python object to be converted * \param translation the translation table between strings and the * enum values. Strings are treated as case-insensitive, but it is * assumed that the translation table keys are lowercase. The last * entry of the table must contain NULL values. * \param result the result is returned here. The default value must be * passed in before calling this function, since this value is * returned untouched if the given Python object is Py_None. * \return 0 if everything is OK, 1 otherwise. An appropriate exception * is raised in this case. */ int igraphmodule_PyObject_to_enum(PyObject *o, igraphmodule_enum_translation_table_entry_t* table, int *result) { char *s, *s2; int i, best, best_result, best_unique; if (o == 0 || o == Py_None) return 0; if (PyLong_Check(o)) return PyLong_AsInt(o, result); s = PyUnicode_CopyAsString(o); if (s == 0) { PyErr_SetString(PyExc_TypeError, "int, long or string expected"); return -1; } /* Convert string to lowercase */ for (s2 = s; *s2; s2++) { *s2 = tolower(*s2); } /* Search for matches */ best = 0; best_unique = 0; best_result = -1; while (table->name != 0) { if (strcmp(s, table->name) == 0) { /* Exact match found */ *result = table->value; free(s); return 0; } /* Find length of longest prefix that matches */ for (i = 0; s[i] == table->name[i]; i++); if (i > best) { /* Found a better match than before */ best = i; best_unique = 1; best_result = table->value; } else if (i == best) { /* Best match is not unique */ best_unique = 0; } table++; } free(s); if (best_unique) { PyErr_Warn( PyExc_DeprecationWarning, "Partial string matches of enum members are deprecated since igraph 0.9.3; " "use strings that identify an enum member unambiguously." ); *result = best_result; return 0; } else { PyErr_SetObject(PyExc_ValueError, o); return -1; } } /** * \ingroup python_interface_conversion * \brief Converts a Python object to a corresponding igraph enum, strictly. * * The numeric value is returned as an integer that must be converted * explicitly to the corresponding igraph enum type. This is to allow one * to use the same common conversion routine for multiple enum types. * * \param o a Python object to be converted * \param translation the translation table between strings and the * enum values. Strings are treated as case-insensitive, but it is * assumed that the translation table keys are lowercase. The last * entry of the table must contain NULL values. * \param result the result is returned here. The default value must be * passed in before calling this function, since this value is * returned untouched if the given Python object is Py_None. * \return 0 if everything is OK, -1 otherwise. An appropriate exception * is raised in this case. */ int igraphmodule_PyObject_to_enum_strict(PyObject *o, igraphmodule_enum_translation_table_entry_t* table, int *result) { char *s, *s2; if (o == 0 || o == Py_None) { return 0; } if (PyLong_Check(o)) { return PyLong_AsInt(o, result); } s = PyUnicode_CopyAsString(o); if (s == 0) { PyErr_SetString(PyExc_TypeError, "int, long or string expected"); return -1; } /* Convert string to lowercase */ for (s2 = s; *s2; s2++) { *s2 = tolower(*s2); } /* Search for exact matches */ while (table->name != 0) { if (strcmp(s, table->name) == 0) { *result = table->value; free(s); return 0; } table++; } free(s); PyErr_SetObject(PyExc_ValueError, o); return -1; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_neimode_t */ int igraphmodule_PyObject_to_neimode_t(PyObject *o, igraph_neimode_t *result) { static igraphmodule_enum_translation_table_entry_t neimode_tt[] = { {"in", IGRAPH_IN}, {"out", IGRAPH_OUT}, {"all", IGRAPH_ALL}, {0,0} }; return igraphmodule_PyObject_to_enum(o, neimode_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_add_weights_t */ int igraphmodule_PyObject_to_add_weights_t(PyObject *o, igraph_add_weights_t *result) { static igraphmodule_enum_translation_table_entry_t add_weights_tt[] = { {"true", IGRAPH_ADD_WEIGHTS_YES}, {"yes", IGRAPH_ADD_WEIGHTS_YES}, {"false", IGRAPH_ADD_WEIGHTS_NO}, {"no", IGRAPH_ADD_WEIGHTS_NO}, {"auto", IGRAPH_ADD_WEIGHTS_IF_PRESENT}, {"if_present", IGRAPH_ADD_WEIGHTS_IF_PRESENT}, {0,0} }; if (o == Py_True) { *result = IGRAPH_ADD_WEIGHTS_YES; return 0; } if (o == Py_False) { *result = IGRAPH_ADD_WEIGHTS_NO; return 0; } return igraphmodule_PyObject_to_enum(o, add_weights_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_adjacency_t */ int igraphmodule_PyObject_to_adjacency_t(PyObject *o, igraph_adjacency_t *result) { static igraphmodule_enum_translation_table_entry_t adjacency_tt[] = { {"directed", IGRAPH_ADJ_DIRECTED}, {"undirected", IGRAPH_ADJ_UNDIRECTED}, {"upper", IGRAPH_ADJ_UPPER}, {"lower", IGRAPH_ADJ_LOWER}, {"minimum", IGRAPH_ADJ_MIN}, {"maximum", IGRAPH_ADJ_MAX}, {"min", IGRAPH_ADJ_MIN}, {"max", IGRAPH_ADJ_MAX}, {"plus", IGRAPH_ADJ_PLUS}, {0,0} }; return igraphmodule_PyObject_to_enum(o, adjacency_tt, (int*)result); } int igraphmodule_PyObject_to_attribute_combination_type_t(PyObject* o, igraph_attribute_combination_type_t *result) { static igraphmodule_enum_translation_table_entry_t attribute_combination_type_tt[] = { {"ignore", IGRAPH_ATTRIBUTE_COMBINE_IGNORE}, {"sum", IGRAPH_ATTRIBUTE_COMBINE_SUM}, {"prod", IGRAPH_ATTRIBUTE_COMBINE_PROD}, {"product", IGRAPH_ATTRIBUTE_COMBINE_PROD}, {"min", IGRAPH_ATTRIBUTE_COMBINE_MIN}, {"max", IGRAPH_ATTRIBUTE_COMBINE_MAX}, {"random", IGRAPH_ATTRIBUTE_COMBINE_RANDOM}, {"first", IGRAPH_ATTRIBUTE_COMBINE_FIRST}, {"last", IGRAPH_ATTRIBUTE_COMBINE_LAST}, {"mean", IGRAPH_ATTRIBUTE_COMBINE_MEAN}, {"median", IGRAPH_ATTRIBUTE_COMBINE_MEDIAN}, {"concat", IGRAPH_ATTRIBUTE_COMBINE_CONCAT}, {"concatenate", IGRAPH_ATTRIBUTE_COMBINE_CONCAT}, {0, 0} }; if (o == Py_None) { *result = IGRAPH_ATTRIBUTE_COMBINE_IGNORE; return 0; } if (PyCallable_Check(o)) { *result = IGRAPH_ATTRIBUTE_COMBINE_FUNCTION; return 0; } return igraphmodule_PyObject_to_enum(o, attribute_combination_type_tt, (int*)result); } int igraphmodule_PyObject_to_eigen_algorithm_t(PyObject *object, igraph_eigen_algorithm_t *a) { static igraphmodule_enum_translation_table_entry_t eigen_algorithm_tt[] = { {"auto", IGRAPH_EIGEN_AUTO}, {"lapack", IGRAPH_EIGEN_LAPACK}, {"arpack", IGRAPH_EIGEN_ARPACK}, {"comp_auto", IGRAPH_EIGEN_COMP_AUTO}, {"comp_lapack", IGRAPH_EIGEN_COMP_LAPACK}, {"comp_arpack", IGRAPH_EIGEN_COMP_ARPACK}, {0,0} }; if (object == Py_None) { *a = IGRAPH_EIGEN_ARPACK; return 0; } else { return igraphmodule_PyObject_to_enum(object, eigen_algorithm_tt, (int*)a); } } int igraphmodule_PyObject_to_eigen_which_t(PyObject *object, igraph_eigen_which_t *w) { PyObject *key, *value; Py_ssize_t pos = 0; static igraphmodule_enum_translation_table_entry_t eigen_which_position_tt[] = { { "LM", IGRAPH_EIGEN_LM}, { "SM", IGRAPH_EIGEN_SM}, { "LA", IGRAPH_EIGEN_LA}, { "SA", IGRAPH_EIGEN_SA}, { "BE", IGRAPH_EIGEN_BE}, { "LR", IGRAPH_EIGEN_LR}, { "SR", IGRAPH_EIGEN_SR}, { "LI", IGRAPH_EIGEN_LI}, { "SI", IGRAPH_EIGEN_SI}, { "ALL", IGRAPH_EIGEN_ALL}, { "INTERVAL", IGRAPH_EIGEN_INTERVAL}, { "SELECT", IGRAPH_EIGEN_SELECT} }; static igraphmodule_enum_translation_table_entry_t lapack_dgeevc_balance_tt[] = { { "none", IGRAPH_LAPACK_DGEEVX_BALANCE_NONE }, { "perm", IGRAPH_LAPACK_DGEEVX_BALANCE_PERM }, { "scale", IGRAPH_LAPACK_DGEEVX_BALANCE_SCALE }, { "both", IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH } }; w->pos = IGRAPH_EIGEN_LM; w->howmany = 1; w->il = w->iu = -1; w->vl = IGRAPH_NEGINFINITY; w->vu = IGRAPH_INFINITY; w->vestimate = 0; w->balance = IGRAPH_LAPACK_DGEEVX_BALANCE_NONE; if (object != Py_None && !PyDict_Check(object)) { PyErr_SetString(PyExc_TypeError, "Python dictionary expected"); return -1; } if (object != Py_None) { while (PyDict_Next(object, &pos, &key, &value)) { char *kv; PyObject *temp_bytes; if (!PyUnicode_Check(key)) { PyErr_SetString(PyExc_TypeError, "Dict key must be string"); return -1; } temp_bytes = PyUnicode_AsEncodedString(key, "ascii", "ignore"); if (temp_bytes == 0) { /* Exception set already by PyUnicode_AsEncodedString */ return -1; } kv = strdup(PyBytes_AS_STRING(temp_bytes)); Py_DECREF(temp_bytes); if (!strcasecmp(kv, "pos")) { igraphmodule_PyObject_to_enum(value, eigen_which_position_tt, (int*) &w->pos); } else if (!strcasecmp(kv, "howmany")) { w->howmany = (int) PyLong_AsLong(value); } else if (!strcasecmp(kv, "il")) { w->il = (int) PyLong_AsLong(value); } else if (!strcasecmp(kv, "iu")) { w->iu = (int) PyLong_AsLong(value); } else if (!strcasecmp(kv, "vl")) { w->vl = PyFloat_AsDouble(value); } else if (!strcasecmp(kv, "vu")) { w->vu = PyFloat_AsDouble(value); } else if (!strcasecmp(kv, "vestimate")) { w->vestimate = (int) PyLong_AsLong(value); } else if (!strcasecmp(kv, "balance")) { igraphmodule_PyObject_to_enum(value, lapack_dgeevc_balance_tt, (int*) &w->balance); } else { PyErr_SetString(PyExc_TypeError, "Unknown eigen parameter"); if (kv != 0) { free(kv); } return -1; } if (kv != 0) { free(kv); } } } return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_barabasi_algorithm_t */ int igraphmodule_PyObject_to_barabasi_algorithm_t(PyObject *o, igraph_barabasi_algorithm_t *result) { static igraphmodule_enum_translation_table_entry_t barabasi_algorithm_tt[] = { {"bag", IGRAPH_BARABASI_BAG}, {"psumtree", IGRAPH_BARABASI_PSUMTREE}, {"psumtree_multiple", IGRAPH_BARABASI_PSUMTREE_MULTIPLE}, {0,0} }; return igraphmodule_PyObject_to_enum(o, barabasi_algorithm_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_connectedness_t */ int igraphmodule_PyObject_to_connectedness_t(PyObject *o, igraph_connectedness_t *result) { static igraphmodule_enum_translation_table_entry_t connectedness_tt[] = { {"weak", IGRAPH_WEAK}, {"strong", IGRAPH_STRONG}, {0,0} }; return igraphmodule_PyObject_to_enum(o, connectedness_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_vconn_nei_t */ int igraphmodule_PyObject_to_vconn_nei_t(PyObject *o, igraph_vconn_nei_t *result) { static igraphmodule_enum_translation_table_entry_t vconn_nei_tt[] = { {"error", IGRAPH_VCONN_NEI_ERROR}, {"negative", IGRAPH_VCONN_NEI_NEGATIVE}, {"number_of_nodes", IGRAPH_VCONN_NEI_NUMBER_OF_NODES}, {"nodes", IGRAPH_VCONN_NEI_NUMBER_OF_NODES}, {"ignore", IGRAPH_VCONN_NEI_IGNORE}, {0,0} }; return igraphmodule_PyObject_to_enum(o, vconn_nei_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_bliss_sh_t */ int igraphmodule_PyObject_to_bliss_sh_t(PyObject *o, igraph_bliss_sh_t *result) { static igraphmodule_enum_translation_table_entry_t bliss_sh_tt[] = { {"f", IGRAPH_BLISS_F}, {"fl", IGRAPH_BLISS_FL}, {"fs", IGRAPH_BLISS_FS}, {"fm", IGRAPH_BLISS_FM}, {"flm", IGRAPH_BLISS_FLM}, {"fsm", IGRAPH_BLISS_FSM}, {0,0} }; return igraphmodule_PyObject_to_enum(o, bliss_sh_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_community_comparison_t */ int igraphmodule_PyObject_to_community_comparison_t(PyObject *o, igraph_community_comparison_t *result) { static igraphmodule_enum_translation_table_entry_t commcmp_tt[] = { {"vi", IGRAPH_COMMCMP_VI}, {"meila", IGRAPH_COMMCMP_VI}, {"nmi", IGRAPH_COMMCMP_NMI}, {"danon", IGRAPH_COMMCMP_NMI}, {"split-join", IGRAPH_COMMCMP_SPLIT_JOIN}, {"split_join", IGRAPH_COMMCMP_SPLIT_JOIN}, {"rand", IGRAPH_COMMCMP_RAND}, {"adjusted_rand", IGRAPH_COMMCMP_ADJUSTED_RAND}, {0,0} }; return igraphmodule_PyObject_to_enum(o, commcmp_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_degseq_t */ int igraphmodule_PyObject_to_degseq_t(PyObject *o, igraph_degseq_t *result) { static igraphmodule_enum_translation_table_entry_t degseq_tt[] = { {"simple", IGRAPH_DEGSEQ_SIMPLE}, {"no_multiple", IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE}, {"vl", IGRAPH_DEGSEQ_VL}, {"viger-latapy", IGRAPH_DEGSEQ_VL}, {0,0} }; return igraphmodule_PyObject_to_enum(o, degseq_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_fas_algorithm_t */ int igraphmodule_PyObject_to_fas_algorithm_t(PyObject *o, igraph_fas_algorithm_t *result) { static igraphmodule_enum_translation_table_entry_t fas_algorithm_tt[] = { {"approx_eades", IGRAPH_FAS_APPROX_EADES}, {"eades", IGRAPH_FAS_APPROX_EADES}, {"exact", IGRAPH_FAS_EXACT_IP}, {"exact_ip", IGRAPH_FAS_EXACT_IP}, {"ip", IGRAPH_FAS_EXACT_IP}, {0,0} }; return igraphmodule_PyObject_to_enum(o, fas_algorithm_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_get_adjacency_t */ int igraphmodule_PyObject_to_get_adjacency_t(PyObject *o, igraph_get_adjacency_t *result) { static igraphmodule_enum_translation_table_entry_t get_adjacency_tt[] = { {"lower", IGRAPH_GET_ADJACENCY_LOWER}, {"upper", IGRAPH_GET_ADJACENCY_UPPER}, {"both", IGRAPH_GET_ADJACENCY_BOTH}, {0,0} }; return igraphmodule_PyObject_to_enum(o, get_adjacency_tt, (int*)result); } /** * \brief Converts a Python object to an igraph \c igraph_layout_grid_t */ int igraphmodule_PyObject_to_layout_grid_t(PyObject *o, igraph_layout_grid_t *result) { static igraphmodule_enum_translation_table_entry_t layout_grid_tt[] = { {"auto", IGRAPH_LAYOUT_AUTOGRID}, {"grid", IGRAPH_LAYOUT_GRID}, {"nogrid", IGRAPH_LAYOUT_NOGRID}, {0,0} }; if (o == Py_True) { *result = IGRAPH_LAYOUT_GRID; return 0; } else if (o == Py_False) { *result = IGRAPH_LAYOUT_NOGRID; return 0; } else { return igraphmodule_PyObject_to_enum(o, layout_grid_tt, (int*)result); } } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_random_walk_stuck_t */ int igraphmodule_PyObject_to_random_walk_stuck_t(PyObject *o, igraph_random_walk_stuck_t *result) { static igraphmodule_enum_translation_table_entry_t random_walk_stuck_tt[] = { {"return", IGRAPH_RANDOM_WALK_STUCK_RETURN}, {"error", IGRAPH_RANDOM_WALK_STUCK_ERROR}, {0,0} }; return igraphmodule_PyObject_to_enum(o, random_walk_stuck_tt, (int*)result); } /** * \brief Converts a Python object to an igraph \c igraph_reciprocity_t */ int igraphmodule_PyObject_to_reciprocity_t(PyObject *o, igraph_reciprocity_t *result) { static igraphmodule_enum_translation_table_entry_t reciprocity_tt[] = { {"default", IGRAPH_RECIPROCITY_DEFAULT}, {"ratio", IGRAPH_RECIPROCITY_RATIO}, {0,0} }; return igraphmodule_PyObject_to_enum(o, reciprocity_tt, (int*)result); } /** * \brief Converts a Python object to an igraph \c igraph_rewiring_t */ int igraphmodule_PyObject_to_rewiring_t(PyObject *o, igraph_rewiring_t *result) { static igraphmodule_enum_translation_table_entry_t rewiring_tt[] = { {"simple", IGRAPH_REWIRING_SIMPLE}, {"simple_loops", IGRAPH_REWIRING_SIMPLE_LOOPS}, {"loops", IGRAPH_REWIRING_SIMPLE_LOOPS}, {0,0} }; return igraphmodule_PyObject_to_enum(o, rewiring_tt, (int*)result); } /** * \brief Converts a Python object to an igraph \c igraph_spinglass_implementation_t */ int igraphmodule_PyObject_to_spinglass_implementation_t(PyObject *o, igraph_spinglass_implementation_t *result) { static igraphmodule_enum_translation_table_entry_t spinglass_implementation_tt[] = { {"original", IGRAPH_SPINCOMM_IMP_ORIG}, {"negative", IGRAPH_SPINCOMM_IMP_NEG}, {0,0} }; return igraphmodule_PyObject_to_enum(o, spinglass_implementation_tt, (int*)result); } /** * \brief Converts a Python object to an igraph \c igraph_spincomm_update_t */ int igraphmodule_PyObject_to_spincomm_update_t(PyObject *o, igraph_spincomm_update_t *result) { static igraphmodule_enum_translation_table_entry_t spincomm_update_tt[] = { {"simple", IGRAPH_SPINCOMM_UPDATE_SIMPLE}, {"config", IGRAPH_SPINCOMM_UPDATE_CONFIG}, {0,0} }; return igraphmodule_PyObject_to_enum(o, spincomm_update_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_star_mode_t */ int igraphmodule_PyObject_to_star_mode_t(PyObject *o, igraph_star_mode_t *result) { static igraphmodule_enum_translation_table_entry_t star_mode_tt[] = { {"in", IGRAPH_STAR_IN}, {"out", IGRAPH_STAR_OUT}, {"mutual", IGRAPH_STAR_MUTUAL}, {"undirected", IGRAPH_STAR_UNDIRECTED}, {0,0} }; return igraphmodule_PyObject_to_enum(o, star_mode_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_subgraph_implementation_t */ int igraphmodule_PyObject_to_subgraph_implementation_t(PyObject *o, igraph_subgraph_implementation_t *result) { static igraphmodule_enum_translation_table_entry_t subgraph_impl_tt[] = { {"auto", IGRAPH_SUBGRAPH_AUTO}, {"copy_and_delete", IGRAPH_SUBGRAPH_COPY_AND_DELETE}, {"old", IGRAPH_SUBGRAPH_COPY_AND_DELETE}, {"create_from_scratch", IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH}, {"new", IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH}, {0,0} }; return igraphmodule_PyObject_to_enum(o, subgraph_impl_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_to_directed_t */ int igraphmodule_PyObject_to_to_directed_t(PyObject *o, igraph_to_directed_t *result) { static igraphmodule_enum_translation_table_entry_t to_directed_tt[] = { {"acyclic", IGRAPH_TO_DIRECTED_ACYCLIC}, {"arbitrary", IGRAPH_TO_DIRECTED_ARBITRARY}, {"mutual", IGRAPH_TO_DIRECTED_MUTUAL}, {"random", IGRAPH_TO_DIRECTED_RANDOM}, {0,0} }; if (o == Py_True) { *result = IGRAPH_TO_DIRECTED_MUTUAL; return 0; } else if (o == Py_False) { *result = IGRAPH_TO_DIRECTED_ARBITRARY; return 0; } return igraphmodule_PyObject_to_enum(o, to_directed_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_to_undirected_t */ int igraphmodule_PyObject_to_to_undirected_t(PyObject *o, igraph_to_undirected_t *result) { static igraphmodule_enum_translation_table_entry_t to_undirected_tt[] = { {"each", IGRAPH_TO_UNDIRECTED_EACH}, {"collapse", IGRAPH_TO_UNDIRECTED_COLLAPSE}, {"mutual", IGRAPH_TO_UNDIRECTED_MUTUAL}, {0,0} }; if (o == Py_True) { *result = IGRAPH_TO_UNDIRECTED_COLLAPSE; return 0; } else if (o == Py_False) { *result = IGRAPH_TO_UNDIRECTED_EACH; return 0; } return igraphmodule_PyObject_to_enum(o, to_undirected_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an \c igraph_transitivity_mode_t */ int igraphmodule_PyObject_to_transitivity_mode_t(PyObject *o, igraph_transitivity_mode_t *result) { static igraphmodule_enum_translation_table_entry_t transitivity_mode_tt[] = { {"zero", IGRAPH_TRANSITIVITY_ZERO}, {"0", IGRAPH_TRANSITIVITY_ZERO}, {"nan", IGRAPH_TRANSITIVITY_NAN}, {0,0} }; return igraphmodule_PyObject_to_enum(o, transitivity_mode_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_tree_mode_t */ int igraphmodule_PyObject_to_tree_mode_t(PyObject *o, igraph_tree_mode_t *result) { static igraphmodule_enum_translation_table_entry_t tree_mode_tt[] = { {"in", IGRAPH_TREE_IN}, {"out", IGRAPH_TREE_OUT}, {"all", IGRAPH_TREE_UNDIRECTED}, {"undirected", IGRAPH_TREE_UNDIRECTED}, {"tree_in", IGRAPH_TREE_IN}, {"tree_out", IGRAPH_TREE_OUT}, {"tree_all", IGRAPH_TREE_UNDIRECTED}, {0,0} }; return igraphmodule_PyObject_to_enum(o, tree_mode_tt, (int*)result); } /** * \brief Extracts a pointer to the internal \c igraph_t from a graph object * * Raises suitable Python exceptions when needed. * * \param object the Python object to be converted. If it is Py_None, the * result pointer is untouched (so it should be null by default). * \param result the pointer is stored here * * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_igraph_t(PyObject *o, igraph_t **result) { if (o == Py_None) return 0; if (!PyObject_TypeCheck(o, &igraphmodule_GraphType)) { PyErr_Format(PyExc_TypeError, "expected graph object, got %s", o->ob_type->tp_name); return 1; } *result = &((igraphmodule_GraphObject*)o)->g; return 0; } /** * \brief Converts a Python object to an igraph \c igraph_integer_t * * Raises suitable Python exceptions when needed. * * \param object the Python object to be converted * \param v the result is returned here * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_integer_t(PyObject *object, igraph_integer_t *v) { int retval, num; if (object == NULL) { } else if (PyLong_Check(object)) { retval = PyLong_AsInt(object, &num); if (retval) return retval; *v = num; return 0; } else if (PyNumber_Check(object)) { PyObject *i = PyNumber_Long(object); if (i == NULL) return 1; retval = PyLong_AsInt(i, &num); Py_DECREF(i); if (retval) return retval; *v = num; return 0; } PyErr_BadArgument(); return 1; } /** * \brief Converts a Python object to an igraph \c igraph_real_t * * Raises suitable Python exceptions when needed. * * \param object the Python object to be converted * \param v the result is returned here * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_real_t(PyObject *object, igraph_real_t *v) { #ifdef PYPY_VERSION /* PyFloatObject is not defined in pypy, but PyFloat_AS_DOUBLE() is * supported on PyObject: /pypy/module/cpyext/floatobject.py. Also, * don't worry, the typedef is local to this function. */ typedef PyObject PyFloatObject; #endif /* PYPY_VERSION */ if (object == NULL) { } else if (PyLong_Check(object)) { double d = PyLong_AsDouble(object); *v=(igraph_real_t)d; return 0; } else if (PyFloat_Check(object)) { double d = PyFloat_AS_DOUBLE((PyFloatObject*)object); *v=(igraph_real_t)d; return 0; } else if (PyNumber_Check(object)) { PyObject *i = PyNumber_Float(object); double d; if (i == NULL) return 1; d = PyFloat_AS_DOUBLE((PyFloatObject*)i); Py_DECREF(i); *v = (igraph_real_t)d; return 0; } PyErr_BadArgument(); return 1; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_vector_t * The incoming \c igraph_vector_t should be uninitialized. Raises suitable * Python exceptions when needed. * * \param list the Python list to be converted * \param v the \c igraph_vector_t containing the result * \param need_non_negative if true, checks whether all elements are non-negative * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_vector_t(PyObject *list, igraph_vector_t *v, igraph_bool_t need_non_negative) { PyObject *item, *it; Py_ssize_t size_hint; int ok; igraph_integer_t number; if (PyBaseString_Check(list)) { /* It is highly unlikely that a string (although it is a sequence) will * provide us with integers */ PyErr_SetString(PyExc_TypeError, "expected a sequence or an iterable containing integers"); return 1; } /* if the list is a sequence, we can pre-allocate the vector to its length */ if (PySequence_Check(list)) { size_hint = PySequence_Size(list); if (size_hint < 0) { /* should not happen but let's try to recover */ size_hint = 0; } } else { size_hint = 0; } /* initialize the result vector */ if (igraph_vector_init(v, 0)) { igraphmodule_handle_igraph_error(); return 1; } /* if we have a size hint, allocate the required space */ if (size_hint > 0) { if (igraph_vector_reserve(v, size_hint)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(v); return 1; } } /* try to use an iterator first */ it = PyObject_GetIter(list); if (it) { while ((item = PyIter_Next(it)) != 0) { ok = 1; if (igraphmodule_PyObject_to_integer_t(item, &number)) { PyErr_SetString(PyExc_ValueError, "iterable must yield integers"); ok=0; } else { if (need_non_negative && number < 0) { PyErr_SetString(PyExc_ValueError, "iterable must yield non-negative integers"); ok=0; } } Py_DECREF(item); if (!ok) { igraph_vector_destroy(v); Py_DECREF(it); return 1; } if (igraph_vector_push_back(v, number)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(v); Py_DECREF(it); return 1; } } Py_DECREF(it); } else { /* list is not iterable; maybe it's a single number? */ PyErr_Clear(); if (igraphmodule_PyObject_to_integer_t(list, &number)) { PyErr_SetString(PyExc_TypeError, "sequence or iterable expected"); igraph_vector_destroy(v); return 1; } else { if (need_non_negative && number < 0) { PyErr_SetString(PyExc_ValueError, "non-negative integers expected"); igraph_vector_destroy(v); return 1; } if (igraph_vector_push_back(v, number)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(v); return 1; } } } return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python list of floats to an igraph \c igraph_vector_t * The incoming \c igraph_vector_t should be uninitialized. Raises suitable * Python exceptions when needed. * * \param list the Python list to be converted * \param v the \c igraph_vector_t containing the result * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_float_to_vector_t(PyObject *list, igraph_vector_t *v) { PyObject *item, *it; Py_ssize_t size_hint; int ok; igraph_real_t number; if (PyBaseString_Check(list)) { /* It is highly unlikely that a string (although it is a sequence) will * provide us with numbers */ PyErr_SetString(PyExc_TypeError, "expected a sequence or an iterable containing numbers"); return 1; } /* if the list is a sequence, we can pre-allocate the vector to its length */ if (PySequence_Check(list)) { size_hint = PySequence_Size(list); if (size_hint < 0) { /* should not happen but let's try to recover */ size_hint = 0; } } else { size_hint = 0; } /* initialize the result vector */ if (igraph_vector_init(v, 0)) { igraphmodule_handle_igraph_error(); return 1; } /* if we have a size hint, allocate the required space */ if (size_hint > 0) { if (igraph_vector_reserve(v, size_hint)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(v); return 1; } } /* try to use an iterator first */ it = PyObject_GetIter(list); if (it) { while ((item = PyIter_Next(it)) != 0) { ok = 1; if (igraphmodule_PyObject_to_real_t(item, &number)) { PyErr_SetString(PyExc_ValueError, "iterable must yield numbers"); ok=0; } Py_DECREF(item); if (!ok) { igraph_vector_destroy(v); Py_DECREF(it); return 1; } if (igraph_vector_push_back(v, number)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(v); Py_DECREF(it); return 1; } } Py_DECREF(it); } else { /* list is not iterable; maybe it's a single number? */ PyErr_Clear(); if (igraphmodule_PyObject_to_real_t(list, &number)) { PyErr_SetString(PyExc_TypeError, "sequence or iterable expected"); igraph_vector_destroy(v); return 1; } else { igraph_vector_push_back(v, number); } } return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python list of ints to an igraph \c igraph_vector_int_t * The incoming \c igraph_vector_int_t should be uninitialized. * Raises suitable Python exceptions when needed. * * This function is almost identical to * \ref igraphmodule_PyObject_to_vector_t . Make sure you fix bugs * in both cases (if any). * * \param list the Python list to be converted * \param v the \c igraph_vector_int_t containing the result * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_vector_int_t(PyObject *list, igraph_vector_int_t *v) { PyObject *item; int value=0; Py_ssize_t i, j, k; int ok, retval; if (PyBaseString_Check(list)) { /* It is highly unlikely that a string (although it is a sequence) will * provide us with integers or integer pairs */ PyErr_SetString(PyExc_TypeError, "expected a sequence or an iterable containing integers"); return 1; } if (!PySequence_Check(list)) { /* try to use an iterator */ PyObject *it = PyObject_GetIter(list); if (it) { PyObject *item; igraph_vector_int_init(v, 0); while ((item = PyIter_Next(it)) != 0) { ok = 1; if (!PyNumber_Check(item)) { PyErr_SetString(PyExc_TypeError, "iterable must return numbers"); ok=0; } else { PyObject *item2 = PyNumber_Long(item); if (item2 == 0) { PyErr_SetString(PyExc_TypeError, "can't convert a list item to integer"); ok = 0; } else { ok = (PyLong_AsInt(item, &value) == 0); Py_DECREF(item2); } } if (ok == 0) { igraph_vector_int_destroy(v); Py_DECREF(item); Py_DECREF(it); return 1; } if (igraph_vector_int_push_back(v, value)) { igraphmodule_handle_igraph_error(); igraph_vector_int_destroy(v); Py_DECREF(item); Py_DECREF(it); return 1; } Py_DECREF(item); } Py_DECREF(it); return 0; } else { PyErr_SetString(PyExc_TypeError, "sequence or iterable expected"); return 1; } return 0; } j=PySequence_Size(list); igraph_vector_int_init(v, j); for (i=0, k=0; i>=1; list=PyList_New(n); /* populate the list with data */ for (i=0, j=0; iitemsize != sizeof(igraph_real_t)) { PyErr_SetString( PyExc_TypeError, "item size of buffer must match the size of igraph_real_t" ); return 1; } if (buffer->ndim != 2) { PyErr_SetString(PyExc_TypeError, "edge list buffers must be two-dimensional"); return 1; } if (buffer->shape[1] != 2) { PyErr_SetString(PyExc_TypeError, "edge list buffers must have two columns"); return 1; } if (buffer->strides[0] != 2 * buffer->itemsize || buffer->strides[1] != buffer->itemsize) { PyErr_SetString(PyExc_TypeError, "edge list buffers must be contiguous"); return 1; } igraph_vector_view(v, buffer->buf, buffer->len / buffer->itemsize); if (list_is_owned) { *list_is_owned = 0; } return 0; } it = PyObject_GetIter(list); if (!it) return 1; igraph_vector_init(v, 0); if (list_is_owned) { *list_is_owned = 1; } while ((item = PyIter_Next(it)) != 0) { ok = 1; if (!PySequence_Check(item) || PySequence_Size(item) != 2) { PyErr_SetString(PyExc_TypeError, "iterable must return pairs of integers or strings"); ok=0; } else { i1 = PySequence_ITEM(item, 0); if (i1 == 0) { i2 = 0; } else { i2 = PySequence_ITEM(item, 1); } ok = (i1 != 0 && i2 != 0); ok = ok && !igraphmodule_PyObject_to_vid(i1, &idx1, graph); ok = ok && !igraphmodule_PyObject_to_vid(i2, &idx2, graph); Py_XDECREF(i1); Py_XDECREF(i2); /* PySequence_ITEM returned new ref */ } Py_DECREF(item); if (ok) { if (igraph_vector_push_back(v, idx1)) { igraphmodule_handle_igraph_error(); ok = 0; } if (ok && igraph_vector_push_back(v, idx2)) { igraphmodule_handle_igraph_error(); ok = 0; } } if (!ok) { igraph_vector_destroy(v); Py_DECREF(it); return 1; } } Py_DECREF(it); return 0; } /** * \ingroup python_interface_conversion * \brief Converts an attribute name or a sequence to a vector_t * * This function is useful for the interface of igraph C calls accepting * edge or vertex weights. The function checks the given Python object. If * it is None, returns a null pointer instead of an \c igraph_vector_t. * If it is a sequence, it converts the sequence to a newly allocated * \c igraph_vector_t and return a pointer to it. Otherwise it interprets the * object as an attribute name and returns the attribute values corresponding * to the name as an \c igraph_vector_t, or returns a null pointer if the attribute * does not exist. * * Note that if the function returned a pointer to an \c igraph_vector_t, * it is the caller's responsibility to destroy the object and free its * pointer after having finished using it. * * \param o the Python object being converted. * \param self a Python Graph object being used when attributes are queried * \param vptr the pointer to the allocated vector is returned here. * \param attr_type the type of the attribute being handled * \return 0 if everything was OK, nonzero otherwise. */ int igraphmodule_attrib_to_vector_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_t **vptr, int attr_type) { igraph_vector_t *result; *vptr = 0; if (attr_type != ATTRIBUTE_TYPE_EDGE && attr_type != ATTRIBUTE_TYPE_VERTEX) return 1; if (o == Py_None) return 0; if (PyUnicode_Check(o)) { /* Check whether the attribute exists and is numeric */ igraph_attribute_type_t at; igraph_attribute_elemtype_t et; long int n; char *name = PyUnicode_CopyAsString(o); if (attr_type == ATTRIBUTE_TYPE_VERTEX) { et = IGRAPH_ATTRIBUTE_VERTEX; n = igraph_vcount(&self->g); } else { et = IGRAPH_ATTRIBUTE_EDGE; n = igraph_ecount(&self->g); } if (igraphmodule_i_attribute_get_type(&self->g, &at, et, name)) { /* exception was set by igraphmodule_i_attribute_get_type */ free(name); return 1; } if (at != IGRAPH_ATTRIBUTE_NUMERIC) { PyErr_SetString(PyExc_ValueError, "attribute values must be numeric"); free(name); return 1; } /* Now that the attribute type has been checked, allocate the target * vector */ result = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t)); if (result==0) { PyErr_NoMemory(); free(name); return 1; } igraph_vector_init(result, n); if (attr_type == ATTRIBUTE_TYPE_VERTEX) { if (igraphmodule_i_get_numeric_vertex_attr(&self->g, name, igraph_vss_all(), result)) { /* exception has already been set, so return */ igraph_vector_destroy(result); free(name); free(result); return 1; } } else { if (igraphmodule_i_get_numeric_edge_attr(&self->g, name, igraph_ess_all(IGRAPH_EDGEORDER_ID), result)) { /* exception has already been set, so return */ igraph_vector_destroy(result); free(name); free(result); return 1; } } free(name); *vptr = result; } else if (PySequence_Check(o)) { result = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t)); if (result==0) { PyErr_NoMemory(); return 1; } if (igraphmodule_PyObject_float_to_vector_t(o, result)) { igraph_vector_destroy(result); free(result); return 1; } *vptr = result; } else { PyErr_SetString(PyExc_TypeError, "unhandled type"); return 1; } return 0; } /** * \ingroup python_interface_conversion * \brief Converts an attribute name or a sequence to a vector_int_t * * Similar to igraphmodule_attrib_to_vector_t and * igraphmodule_attrib_to_vector_long_t. Make sure you fix bugs * in all three places (if any). * * Note that if the function returned a pointer to an \c igraph_vector_int_t, * it is the caller's responsibility to destroy the object and free its * pointer after having finished using it. * * \param o the Python object being converted. * \param self a Python Graph object being used when attributes are queried * \param vptr the pointer to the allocated vector is returned here. * \param attr_type the type of the attribute being handled * \return 0 if everything was OK, nonzero otherwise. */ int igraphmodule_attrib_to_vector_int_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_int_t **vptr, int attr_type) { igraph_vector_int_t *result; *vptr = 0; if (attr_type != ATTRIBUTE_TYPE_EDGE && attr_type != ATTRIBUTE_TYPE_VERTEX) return 1; if (o == Py_None) return 0; if (PyUnicode_Check(o)) { igraph_vector_t* dummy = 0; long int i, n; if (igraphmodule_attrib_to_vector_t(o, self, &dummy, attr_type)) return 1; if (dummy == 0) return 0; n = igraph_vector_size(dummy); result = (igraph_vector_int_t*)calloc(1, sizeof(igraph_vector_int_t)); igraph_vector_int_init(result, n); if (result==0) { igraph_vector_destroy(dummy); free(dummy); PyErr_NoMemory(); return 1; } for (i=0; ig); } else { et = IGRAPH_ATTRIBUTE_EDGE; n = igraph_ecount(&self->g); } if (igraphmodule_i_attribute_get_type(&self->g, &at, et, name)) { /* exception was set by igraphmodule_i_attribute_get_type */ free(name); return 1; } if (at == IGRAPH_ATTRIBUTE_BOOLEAN) { /* The attribute is a real Boolean attribute. Allocate the target * vector */ result = (igraph_vector_bool_t*)calloc(1, sizeof(igraph_vector_bool_t)); if (result==0) { PyErr_NoMemory(); free(name); return 1; } igraph_vector_bool_init(result, n); if (attr_type == ATTRIBUTE_TYPE_VERTEX) { if (igraphmodule_i_get_boolean_vertex_attr(&self->g, name, igraph_vss_all(), result)) { /* exception has already been set, so return */ igraph_vector_bool_destroy(result); free(name); free(result); return 1; } } else { if (igraphmodule_i_get_boolean_edge_attr(&self->g, name, igraph_ess_all(IGRAPH_EDGEORDER_ID), result)) { /* exception has already been set, so return */ igraph_vector_bool_destroy(result); free(name); free(result); return 1; } } free(name); *vptr = result; } else if (at == IGRAPH_ATTRIBUTE_NUMERIC) { /* The attribute is a numeric attribute, so we fall back to * attrib_to_vector_t and then convert the result */ igraph_vector_t *dummy = 0; free(name); if (igraphmodule_attrib_to_vector_t(o, self, &dummy, attr_type)) { return 1; } if (dummy == 0) { return 0; } n = igraph_vector_size(dummy); result = (igraph_vector_bool_t*)calloc(1, sizeof(igraph_vector_bool_t)); igraph_vector_bool_init(result, n); if (result==0) { igraph_vector_destroy(dummy); free(dummy); PyErr_NoMemory(); return 1; } for (i=0; i 0 ? min_cols : 0; for (i = 0; i < nr; i++) { row = PySequence_GetItem(o, i); if (!PySequence_Check(row)) { Py_DECREF(row); PyErr_SetString(PyExc_TypeError, "matrix expected (list of sequences)"); return 1; } n = PySequence_Size(row); Py_DECREF(row); if (n > nc) { nc = n; } } igraph_matrix_init(m, nr, nc); for (i = 0; i < nr; i++) { row = PySequence_GetItem(o, i); n = PySequence_Size(row); for (j = 0; j < n; j++) { item = PySequence_GetItem(row, j); if (PyLong_Check(item)) { MATRIX(*m, i, j) = (igraph_real_t)PyLong_AsLong(item); } else if (PyLong_Check(item)) { MATRIX(*m, i, j) = (igraph_real_t)PyLong_AsLong(item); } else if (PyFloat_Check(item)) { MATRIX(*m, i, j) = (igraph_real_t)PyFloat_AsDouble(item); } else if (!was_warned) { PyErr_Warn(PyExc_Warning, "non-numeric value in matrix ignored"); was_warned=1; } Py_DECREF(item); } Py_DECREF(row); } return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python list of lists to an \c igraph_vector_ptr_t * containing \c igraph_vector_t items. * * The returned vector will have an item destructor that destroys the * contained vectors, so it is important to call \c igraph_vector_ptr_destroy_all * on it instead of \c igraph_vector_ptr_destroy when the vector is no longer * needed. * * \param o the Python object representing the list of lists * \param m the address of an uninitialized \c igraph_vector_ptr_t * \return 0 if everything was OK, 1 otherwise. Sets appropriate exceptions. */ int igraphmodule_PyObject_to_vector_ptr_t(PyObject* list, igraph_vector_ptr_t* vec, igraph_bool_t need_non_negative) { PyObject *it, *item; igraph_vector_t *subvec; if (PyUnicode_Check(list)) { PyErr_SetString(PyExc_TypeError, "expected iterable (but not string)"); return 1; } it = PyObject_GetIter(list); if (!it) { return 1; } if (igraph_vector_ptr_init(vec, 0)) { igraphmodule_handle_igraph_error(); Py_DECREF(it); return 1; } IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(vec, igraph_vector_destroy); while ((item = PyIter_Next(it)) != 0) { subvec = igraph_Calloc(1, igraph_vector_t); if (subvec == 0) { Py_DECREF(item); Py_DECREF(it); PyErr_NoMemory(); return 1; } if (igraphmodule_PyObject_to_vector_t(item, subvec, need_non_negative)) { Py_DECREF(item); Py_DECREF(it); igraph_vector_destroy(subvec); igraph_vector_ptr_destroy_all(vec); return 1; } Py_DECREF(item); if (igraph_vector_ptr_push_back(vec, subvec)) { Py_DECREF(it); igraph_vector_destroy(subvec); igraph_vector_ptr_destroy_all(vec); return 1; } /* ownership of 'subvec' taken by 'vec' here */ } Py_DECREF(it); return 0; } /** * \ingroup python_interface_conversion * \brief Converts an \c igraph_strvector_t to a Python string list * * \param v the \c igraph_strvector_t containing the vector to be converted * \return the Python string list as a \c PyObject*, or \c NULL if an error occurred */ PyObject* igraphmodule_strvector_t_to_PyList(igraph_strvector_t *v) { PyObject* list; Py_ssize_t n, i; char* ptr; n=igraph_strvector_size(v); if (n<0) return igraphmodule_handle_igraph_error(); // create a new Python list list=PyList_New(n); /* populate the list with data */ for (i=0; ig); Py_DECREF(t); } return 0; } /** * \ingroup python_interface_conversion * \brief Appends the contents of a Python iterator returning graphs to * an \c igraph_vectorptr_t, and also stores the class of the first graph * * The incoming \c igraph_vector_ptr_t should be INITIALIZED. * Raises suitable Python exceptions when needed. * * \param it the Python iterator * \param v the \c igraph_vector_ptr_t which will contain the result * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t_with_type(PyObject *it, igraph_vector_ptr_t *v, PyTypeObject **g_type) { PyObject *t; int first = 1; while ((t=PyIter_Next(it))) { if (!PyObject_TypeCheck(t, &igraphmodule_GraphType)) { PyErr_SetString(PyExc_TypeError, "iterable argument must contain graphs"); Py_DECREF(t); return 1; } if (first) { *g_type = Py_TYPE(t); first = 0; } igraph_vector_ptr_push_back(v, &((igraphmodule_GraphObject*)t)->g); Py_DECREF(t); } return 0; } /** * \ingroup python_interface_conversion * \brief Tries to interpret a Python object as a single vertex ID * * \param o the Python object * \param vid the vertex ID will be stored here * \param graph the graph that will be used to interpret vertex names * if a string was given in o. It may also be a null pointer * if we don't need name lookups. * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_vid(PyObject *o, igraph_integer_t *vid, igraph_t *graph) { int retval, tmp; if (o == Py_None || o == 0) { *vid = 0; } else if (PyLong_Check(o)) { /* Single vertex ID */ if (PyLong_AsInt(o, &tmp)) return 1; *vid = tmp; } else if (graph != 0 && PyBaseString_Check(o)) { /* Single vertex ID from vertex name */ if (igraphmodule_get_vertex_id_by_name(graph, o, vid)) return 1; } else if (PyObject_IsInstance(o, (PyObject*)&igraphmodule_VertexType)) { /* Single vertex ID from Vertex object */ igraphmodule_VertexObject *vo = (igraphmodule_VertexObject*)o; *vid = igraphmodule_Vertex_get_index_igraph_integer(vo); } else if (PyIndex_Check(o)) { /* Other numeric type that can be converted to an index */ PyObject* num = PyNumber_Index(o); if (num) { if (PyLong_Check(num)) { retval = PyLong_AsInt(num, &tmp); if (retval) { Py_DECREF(num); return 1; } *vid = tmp; } else { PyErr_SetString(PyExc_TypeError, "PyNumber_Index returned invalid type"); Py_DECREF(num); return 1; } Py_DECREF(num); } else return 1; } else { PyErr_SetString(PyExc_TypeError, "only non-negative integers, strings or igraph.Vertex objects can be converted to vertex IDs"); return 1; } if (*vid < 0) { PyErr_Format(PyExc_ValueError, "vertex IDs must be positive, got: %ld", (long)(*vid)); return 1; } return 0; } /** * \ingroup python_interface_conversion * \brief Tries to interpret a Python object as a vertex selector * * \param o the Python object * \param vs the \c igraph_vs_t which will contain the result * \param graph an \c igraph_t object which will be used to interpret vertex * names (if the supplied Python object contains strings) * \param return_single will be 1 if the selector selected only a single vertex, * 0 otherwise * \param single_vid if the selector selected only a single vertex, the ID * of the selected vertex will also be returned here. * * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_vs_t(PyObject *o, igraph_vs_t *vs, igraph_t *graph, igraph_bool_t *return_single, igraph_integer_t *single_vid) { igraph_integer_t vid; igraph_vector_t vector; if (o == 0 || o == Py_None) { /* Returns a vertex sequence for all vertices */ if (return_single) *return_single = 0; igraph_vs_all(vs); return 0; } if (PyObject_IsInstance(o, (PyObject*)&igraphmodule_VertexSeqType)) { /* Returns a vertex sequence from a VertexSeq object */ igraphmodule_VertexSeqObject *vso = (igraphmodule_VertexSeqObject*)o; if (igraph_vs_copy(vs, &vso->vs)) { igraphmodule_handle_igraph_error(); return 1; } if (return_single) { *return_single = 0; } return 0; } if (PySlice_Check(o) && graph != 0) { /* Returns a vertex sequence from a slice */ Py_ssize_t no_of_vertices = igraph_vcount(graph); Py_ssize_t start, stop, step, slicelength, i; if (PySlice_GetIndicesEx(o, no_of_vertices, &start, &stop, &step, &slicelength)) return 1; if (start == 0 && slicelength == no_of_vertices) { igraph_vs_all(vs); } else { if (igraph_vector_init(&vector, slicelength)) { igraphmodule_handle_igraph_error(); return 1; } for (i = 0; i < slicelength; i++, start += step) { VECTOR(vector)[i] = start; } if (igraph_vs_vector_copy(vs, &vector)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&vector); return 1; } igraph_vector_destroy(&vector); } if (return_single) { *return_single = 0; } return 0; } if (igraphmodule_PyObject_to_vid(o, &vid, graph)) { /* Object cannot be converted to a single vertex ID, * assume it is a sequence or iterable */ PyObject *iterator; PyObject *item; if (PyBaseString_Check(o)) { /* Special case: strings and unicode objects are sequences, but they * will not yield valid vertex IDs */ return 1; } /* Clear the exception set by igraphmodule_PyObject_to_vid */ PyErr_Clear(); iterator = PyObject_GetIter(o); if (iterator == NULL) { PyErr_SetString(PyExc_TypeError, "conversion to vertex sequence failed"); return 1; } if (igraph_vector_init(&vector, 0)) { igraphmodule_handle_igraph_error(); return 1; } while ((item = PyIter_Next(iterator))) { vid = -1; if (igraphmodule_PyObject_to_vid(item, &vid, graph)) break; Py_DECREF(item); if (igraph_vector_push_back(&vector, vid)) { igraphmodule_handle_igraph_error(); /* no need to destroy 'vector' here; will be done outside the loop due * to PyErr_Occurred */ break; } } Py_DECREF(iterator); if (PyErr_Occurred()) { igraph_vector_destroy(&vector); return 1; } if (igraph_vs_vector_copy(vs, &vector)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&vector); return 1; } if (return_single) { *return_single = 0; } return 0; } /* The object can be converted into a single vertex ID */ if (return_single) *return_single = 1; if (single_vid) *single_vid = vid; igraph_vs_1(vs, vid); return 0; } /** * \ingroup python_interface_conversion * \brief Tries to interpret a Python object as a single edge ID * * \param o the Python object * \param eid the edge ID will be stored here * \param graph the graph that will be used to interpret vertex names and * indices if o is a tuple. It may also be a null pointer * if we don't want to handle tuples. * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_eid(PyObject *o, igraph_integer_t *eid, igraph_t *graph) { int retval, tmp; igraph_integer_t vid1, vid2; if (o == Py_None || o == 0) { *eid = 0; } else if (PyLong_Check(o)) { /* Single edge ID */ if (PyLong_AsInt(o, &tmp)) return 1; *eid = tmp; } else if (PyObject_IsInstance(o, (PyObject*)&igraphmodule_EdgeType)) { /* Single edge ID from Edge object */ igraphmodule_EdgeObject *eo = (igraphmodule_EdgeObject*)o; *eid = igraphmodule_Edge_get_index_igraph_integer(eo); } else if (PyIndex_Check(o)) { /* Other numeric type that can be converted to an index */ PyObject* num = PyNumber_Index(o); if (num) { if (PyLong_Check(num)) { retval = PyLong_AsInt(num, &tmp); if (retval) { Py_DECREF(num); return 1; } *eid = tmp; } else { PyErr_SetString(PyExc_TypeError, "PyNumber_Index returned invalid type"); Py_DECREF(num); return 1; } Py_DECREF(num); } else return 1; } else if (graph != 0 && PyTuple_Check(o)) { PyObject *o1, *o2; o1 = PyTuple_GetItem(o, 0); if (!o1) return 1; o2 = PyTuple_GetItem(o, 1); if (!o2) return 1; if (igraphmodule_PyObject_to_vid(o1, &vid1, graph)) return 1; if (igraphmodule_PyObject_to_vid(o2, &vid2, graph)) return 1; retval = igraph_get_eid(graph, eid, vid1, vid2, 1, 0); if (retval == IGRAPH_EINVVID) { PyErr_Format(PyExc_ValueError, "no edge from vertex #%ld to #%ld; no such vertex ID", (long int)vid1, (long int)vid2); return 1; } else if (retval) { igraphmodule_handle_igraph_error(); return 1; } if (*eid < 0) { PyErr_Format(PyExc_ValueError, "no edge from vertex #%ld to #%ld", (long int)vid1, (long int)vid2); return 1; } } else { PyErr_SetString(PyExc_TypeError, "only non-negative integers, igraph.Edge objects or tuples of vertex IDs can be " "converted to edge IDs"); return 1; } if (*eid < 0) { PyErr_Format(PyExc_ValueError, "edge IDs must be positive, got: %ld", (long)(*eid)); return 1; } return 0; } /** * \ingroup python_interface_conversion * \brief Tries to interpret a Python object as an edge selector * * \param o the Python object * \param vs the \c igraph_es_t which will contain the result * \param graph an \c igraph_t object which will be used to interpret vertex * names and tuples (if the supplied Python object contains them) * \param return_single will be 1 if the selector selected only a single edge, * 0 otherwise * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_es_t(PyObject *o, igraph_es_t *es, igraph_t *graph, igraph_bool_t *return_single) { igraph_integer_t eid; igraph_vector_t vector; if (o == 0 || o == Py_None) { /* Returns an edge sequence for all edges */ if (return_single) *return_single = 0; igraph_es_all(es, IGRAPH_EDGEORDER_ID); return 0; } if (PyObject_IsInstance(o, (PyObject*)&igraphmodule_EdgeSeqType)) { /* Returns an edge sequence from an EdgeSeq object */ igraphmodule_EdgeSeqObject *eso = (igraphmodule_EdgeSeqObject*)o; if (igraph_es_copy(es, &eso->es)) { igraphmodule_handle_igraph_error(); return 1; } if (return_single) *return_single = 0; return 0; } if (igraphmodule_PyObject_to_eid(o, &eid, graph)) { /* Object cannot be converted to a single edge ID, * assume it is a sequence or iterable */ PyObject *iterator; PyObject *item; /* Clear the exception set by igraphmodule_PyObject_to_eid */ PyErr_Clear(); iterator = PyObject_GetIter(o); if (iterator == NULL) { PyErr_SetString(PyExc_TypeError, "conversion to edge sequence failed"); return 1; } if (igraph_vector_init(&vector, 0)) { igraphmodule_handle_igraph_error(); return 1; } while ((item = PyIter_Next(iterator))) { eid = -1; if (igraphmodule_PyObject_to_eid(item, &eid, graph)) { break; } Py_DECREF(item); if (igraph_vector_push_back(&vector, eid)) { igraphmodule_handle_igraph_error(); /* no need to destroy 'vector' here; will be done outside the loop due * to PyErr_Occurred */ break; } } Py_DECREF(iterator); if (PyErr_Occurred()) { igraph_vector_destroy(&vector); return 1; } if (igraph_vector_size(&vector) > 0) { igraph_es_vector_copy(es, &vector); } else { igraph_es_none(es); } igraph_vector_destroy(&vector); if (return_single) { *return_single = 0; } return 0; } /* The object can be converted into a single edge ID */ if (return_single) { *return_single = 1; } /* if (single_eid) *single_eid = eid; */ igraph_es_1(es, eid); return 0; } /** * \ingroup python_interface_conversion * \brief Tries to interpret a Python object as a numeric attribute value list * * \param o the Python object * \param v the \c igraph_vector_t which will contain the result * \param g a \c igraphmodule_GraphObject object or \c NULL - used when the * provided Python object is not a list and we're trying to interpret it as * an attribute name. * \param type the attribute type (graph = 0, vertex = 1, edge = 2) to be used * \param def default value if the attribute name supplied is \c None * if \c o is not a list. * \return 0 if everything was OK, 1 otherwise * * If the Python object is not a list, tries to interpret it as an attribute * name. */ int igraphmodule_PyObject_to_attribute_values(PyObject *o, igraph_vector_t *v, igraphmodule_GraphObject* g, int type, igraph_real_t def) { PyObject* list = o; long i, n; if (o==NULL) return 1; if (o == Py_None) { if (type == ATTRHASH_IDX_VERTEX) n=igraph_vcount(&g->g); else if (type == ATTRHASH_IDX_EDGE) n=igraph_ecount(&g->g); else n=1; if (igraph_vector_init(v, n)) return 1; for (i=0; ig.attr)[type], o); if (!list) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return 1; } } n=PyList_Size(list); if (igraph_vector_init(v, n)) return 1; for (i=0; iOPTION); \ Py_XDECREF(o1); \ } \ o1 = PyObject_GetAttrString(obj, #OPTION); \ igraphmodule_PyObject_to_##TYPE##_t(o1, &options->OPTION); \ Py_XDECREF(o1); \ } while (0) #define CONVERT_DRL_OPTION_BLOCK(NAME) do { \ CONVERT_DRL_OPTION(NAME##_iterations, integer); \ CONVERT_DRL_OPTION(NAME##_temperature, real); \ CONVERT_DRL_OPTION(NAME##_attraction, real); \ CONVERT_DRL_OPTION(NAME##_damping_mult, real); \ } while (0) if (!retval) { CONVERT_DRL_OPTION(edge_cut, real); CONVERT_DRL_OPTION_BLOCK(init); CONVERT_DRL_OPTION_BLOCK(liquid); CONVERT_DRL_OPTION_BLOCK(expansion); CONVERT_DRL_OPTION_BLOCK(cooldown); CONVERT_DRL_OPTION_BLOCK(crunch); CONVERT_DRL_OPTION_BLOCK(simmer); PyErr_Clear(); } #undef CONVERT_DRL_OPTION #undef CONVERT_DRL_OPTION_BLOCK } if (retval) { igraphmodule_handle_igraph_error(); return 1; } return 0; } int igraphmodule_i_PyObject_pair_to_attribute_combination_record_t( PyObject* name, PyObject* value, igraph_attribute_combination_record_t *result) { if (igraphmodule_PyObject_to_attribute_combination_type_t(value, &result->type)) return 1; if (result->type == IGRAPH_ATTRIBUTE_COMBINE_FUNCTION) { result->func = (void*) value; } else { result->func = 0; } if (name == Py_None) result->name = 0; else if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "keys must be strings or None in attribute combination specification dicts"); return 1; } else { result->name = PyUnicode_CopyAsString(name); } return 0; } /** * \brief Converts a Python object to an \c igraph_attribute_combination_t * * Raises suitable Python exceptions when needed. * * An \c igraph_attribute_combination_t specifies how the attributes of multiple * vertices/edges should be combined when they are collapsed into a single vertex * or edge (e.g., when simplifying a graph). For each attribute, one can specify * a Python callable object to call or one of a list of recognised strings which * map to simple functions. The recognised strings are as follows: * * - \c "ignore" - the attribute will be ignored * - \c "sum" - the attribute values will be added * - \c "prod" - the product of the attribute values will be taken * - \c "min" - the minimum attribute value will be used * - \c "max" - the maximum attribute value will be used * - \c "random" - a random value will be selected * - \c "first" - the first value encountered will be selected * - \c "last" - the last value encountered will be selected * - \c "mean" - the mean of the attributes will be selected * - \c "median" - the median of the attributes will be selected * - \c "concat" - the attribute values will be concatenated * * The Python object being converted must either be a string, a callable or a dict. * If a string is given, it is considered as an \c igraph_attribute_combination_t * object that combines all attributes according to the function given by that * string. If a callable is given, it is considered as an * \c igraph_attribute_combination_t that combines all attributes by calling the * callable and taking its return value. If a dict is given, its key-value pairs * are iterated, the keys specify the attribute names (a key of None means all * explicitly not specified attributes), the values specify the functions to * call for those attributes. * * \param object the Python object to be converted * \param result the result is returned here. It must be an uninitialized * \c igraph_attribute_combination_t object, it will be initialized accordingly. * It is the responsibility of the caller to * \return 0 if everything was OK, 1 otherwise */ int igraphmodule_PyObject_to_attribute_combination_t(PyObject* object, igraph_attribute_combination_t *result) { igraph_attribute_combination_record_t rec; if (igraph_attribute_combination_init(result)) { igraphmodule_handle_igraph_error(); return 1; } if (object == Py_None) { return 0; } if (PyDict_Check(object)) { /* a full-fledged dict was passed */ PyObject *key, *value; Py_ssize_t pos = 0; while (PyDict_Next(object, &pos, &key, &value)) { if (igraphmodule_i_PyObject_pair_to_attribute_combination_record_t(key, value, &rec)) { igraph_attribute_combination_destroy(result); return 1; } igraph_attribute_combination_add(result, rec.name, rec.type, rec.func); free((char*)rec.name); /* was allocated in pair_to_attribute_combination_record_t above */ } } else { /* assume it is a string or callable */ if (igraphmodule_i_PyObject_pair_to_attribute_combination_record_t(Py_None, object, &rec)) { igraph_attribute_combination_destroy(result); return 1; } igraph_attribute_combination_add(result, 0, rec.type, rec.func); free((char*)rec.name); /* was allocated in pair_to_attribute_combination_record_t above */ } return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_pagerank_algo_t */ int igraphmodule_PyObject_to_pagerank_algo_t(PyObject *o, igraph_pagerank_algo_t *result) { static igraphmodule_enum_translation_table_entry_t pagerank_algo_tt[] = { {"prpack", IGRAPH_PAGERANK_ALGO_PRPACK}, {"arpack", IGRAPH_PAGERANK_ALGO_ARPACK}, {0,0} }; return igraphmodule_PyObject_to_enum(o, pagerank_algo_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_edge_type_sw_t */ int igraphmodule_PyObject_to_edge_type_sw_t(PyObject *o, igraph_edge_type_sw_t *result) { int result_int = *result; int retval; static igraphmodule_enum_translation_table_entry_t edge_type_sw_tt[] = { {"simple", IGRAPH_SIMPLE_SW}, {"loops", IGRAPH_LOOPS_SW}, {"multi", IGRAPH_MULTI_SW}, {"all", IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW}, {0,0} }; retval = igraphmodule_PyObject_to_enum_strict(o, edge_type_sw_tt, &result_int); if (retval) { return retval; } *result = result_int; return 0; } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_realize_degseq_t */ int igraphmodule_PyObject_to_realize_degseq_t(PyObject *o, igraph_realize_degseq_t *result) { static igraphmodule_enum_translation_table_entry_t realize_degseq_tt[] = { {"smallest", IGRAPH_REALIZE_DEGSEQ_SMALLEST}, {"largest", IGRAPH_REALIZE_DEGSEQ_LARGEST}, {"index", IGRAPH_REALIZE_DEGSEQ_INDEX}, {0,0} }; return igraphmodule_PyObject_to_enum_strict(o, realize_degseq_tt, (int*)result); } /** * \ingroup python_interface_conversion * \brief Converts a Python object to an igraph \c igraph_random_tree_t */ int igraphmodule_PyObject_to_random_tree_t(PyObject *o, igraph_random_tree_t *result) { static igraphmodule_enum_translation_table_entry_t random_tree_tt[] = { {"prufer", IGRAPH_RANDOM_TREE_PRUFER}, {"lerw", IGRAPH_RANDOM_TREE_LERW}, {0,0} }; return igraphmodule_PyObject_to_enum_strict(o, random_tree_tt, (int*)result); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/convert.h0000644000175100001710000002023200000000000017633 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /************************ Miscellaneous functions *************************/ /** \defgroup python_interface_conversion Converting between Python and igraph data types * \ingroup python_interface */ #ifndef PYTHON_CONVERT_H #define PYTHON_CONVERT_H #include "preamble.h" #include #include #include "graphobject.h" typedef enum { IGRAPHMODULE_TYPE_INT=0, IGRAPHMODULE_TYPE_FLOAT } igraphmodule_conv_t; typedef struct { const char* name; int value; } igraphmodule_enum_translation_table_entry_t; int PyLong_AsInt(PyObject* obj, int* result); /* Conversion from PyObject to enum types */ int igraphmodule_PyObject_to_enum(PyObject *o, igraphmodule_enum_translation_table_entry_t *table, int *result); int igraphmodule_PyObject_to_enum_strict(PyObject *o, igraphmodule_enum_translation_table_entry_t *table, int *result); int igraphmodule_PyObject_to_add_weights_t(PyObject *o, igraph_add_weights_t *result); int igraphmodule_PyObject_to_adjacency_t(PyObject *o, igraph_adjacency_t *result); int igraphmodule_PyObject_to_attribute_combination_type_t(PyObject* o, igraph_attribute_combination_type_t *type); int igraphmodule_PyObject_to_barabasi_algorithm_t(PyObject *o, igraph_barabasi_algorithm_t *result); int igraphmodule_PyObject_to_bliss_sh_t(PyObject *o, igraph_bliss_sh_t *result); int igraphmodule_PyObject_to_community_comparison_t(PyObject *obj, igraph_community_comparison_t *result); int igraphmodule_PyObject_to_connectedness_t(PyObject *o, igraph_connectedness_t *result); int igraphmodule_PyObject_to_degseq_t(PyObject *o, igraph_degseq_t *result); int igraphmodule_PyObject_to_fas_algorithm_t(PyObject *o, igraph_fas_algorithm_t *result); int igraphmodule_PyObject_to_get_adjacency_t(PyObject *o, igraph_get_adjacency_t *result); int igraphmodule_PyObject_to_layout_grid_t(PyObject *o, igraph_layout_grid_t *result); int igraphmodule_PyObject_to_neimode_t(PyObject *o, igraph_neimode_t *result); int igraphmodule_PyObject_to_pagerank_algo_t(PyObject *o, igraph_pagerank_algo_t *result); int igraphmodule_PyObject_to_edge_type_sw_t(PyObject *o, igraph_edge_type_sw_t *result); int igraphmodule_PyObject_to_realize_degseq_t(PyObject *o, igraph_realize_degseq_t *result); int igraphmodule_PyObject_to_random_tree_t(PyObject *o, igraph_random_tree_t *result); int igraphmodule_PyObject_to_random_walk_stuck_t(PyObject *o, igraph_random_walk_stuck_t *result); int igraphmodule_PyObject_to_reciprocity_t(PyObject *o, igraph_reciprocity_t *result); int igraphmodule_PyObject_to_rewiring_t(PyObject *o, igraph_rewiring_t *result); int igraphmodule_PyObject_to_spinglass_implementation_t(PyObject *o, igraph_spinglass_implementation_t *result); int igraphmodule_PyObject_to_spincomm_update_t(PyObject *o, igraph_spincomm_update_t *result); int igraphmodule_PyObject_to_star_mode_t(PyObject *o, igraph_star_mode_t *result); int igraphmodule_PyObject_to_subgraph_implementation_t(PyObject *o, igraph_subgraph_implementation_t *result); int igraphmodule_PyObject_to_to_directed_t(PyObject *o, igraph_to_directed_t *result); int igraphmodule_PyObject_to_to_undirected_t(PyObject *o, igraph_to_undirected_t *result); int igraphmodule_PyObject_to_transitivity_mode_t(PyObject *o, igraph_transitivity_mode_t *result); int igraphmodule_PyObject_to_tree_mode_t(PyObject *o, igraph_tree_mode_t *result); int igraphmodule_PyObject_to_vconn_nei_t(PyObject *o, igraph_vconn_nei_t *result); /* Conversion from PyObject to igraph types */ int igraphmodule_PyObject_to_integer_t(PyObject *object, igraph_integer_t *v); int igraphmodule_PyObject_to_real_t(PyObject *object, igraph_real_t *v); int igraphmodule_PyObject_to_igraph_t(PyObject *o, igraph_t **result); int igraphmodule_PyObject_to_vector_t(PyObject *list, igraph_vector_t *v, igraph_bool_t need_non_negative); int igraphmodule_PyObject_float_to_vector_t(PyObject *list, igraph_vector_t *v); int igraphmodule_PyObject_to_vector_int_t(PyObject *list, igraph_vector_int_t *v); int igraphmodule_PyObject_to_vector_long_t(PyObject *list, igraph_vector_long_t *v); int igraphmodule_PyObject_to_vector_bool_t(PyObject *list, igraph_vector_bool_t *v); int igraphmodule_PyObject_to_vector_ptr_t(PyObject *list, igraph_vector_ptr_t *v, igraph_bool_t need_non_negative); int igraphmodule_PyObject_to_edgelist( PyObject *list, igraph_vector_t *v, igraph_t *graph, igraph_bool_t *list_is_owned ); int igraphmodule_PyList_to_matrix_t(PyObject *o, igraph_matrix_t *m); int igraphmodule_PyList_to_matrix_t_with_minimum_column_count(PyObject *o, igraph_matrix_t *m, int min_cols); PyObject* igraphmodule_strvector_t_to_PyList(igraph_strvector_t *v); int igraphmodule_PyList_to_strvector_t(PyObject* v, igraph_strvector_t *result); int igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t(PyObject *it, igraph_vector_ptr_t *v); int igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t_with_type(PyObject *it, igraph_vector_ptr_t *v, PyTypeObject **g_type); int igraphmodule_PyObject_to_vid(PyObject *o, igraph_integer_t *vid, igraph_t *graph); int igraphmodule_PyObject_to_vs_t(PyObject *o, igraph_vs_t *vs, igraph_t *graph, igraph_bool_t *return_single, igraph_integer_t *single_vid); int igraphmodule_PyObject_to_eid(PyObject *o, igraph_integer_t *eid, igraph_t *graph); int igraphmodule_PyObject_to_es_t(PyObject *o, igraph_es_t *es, igraph_t *graph, igraph_bool_t *return_single); int igraphmodule_PyObject_to_attribute_values(PyObject *o, igraph_vector_t *v, igraphmodule_GraphObject* g, int type, igraph_real_t def); int igraphmodule_PyObject_to_drl_options_t(PyObject *obj, igraph_layout_drl_options_t *options); int igraphmodule_PyObject_to_attribute_combination_t(PyObject* object, igraph_attribute_combination_t *type); int igraphmodule_PyObject_to_eigen_algorithm_t(PyObject *object, igraph_eigen_algorithm_t *a); int igraphmodule_PyObject_to_eigen_which_t(PyObject *object, igraph_eigen_which_t *w); /* Conversion from attributes to igraph types */ int igraphmodule_attrib_to_vector_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_t **vptr, int attr_type); int igraphmodule_attrib_to_vector_int_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_int_t **vptr, int attr_type); int igraphmodule_attrib_to_vector_long_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_long_t **vptr, int attr_type); int igraphmodule_attrib_to_vector_bool_t(PyObject *o, igraphmodule_GraphObject *self, igraph_vector_bool_t **vptr, int attr_type); /* Conversion from igraph types to PyObjects */ PyObject* igraphmodule_vector_bool_t_to_PyList(const igraph_vector_bool_t *v); PyObject* igraphmodule_vector_t_to_PyList(const igraph_vector_t *v, igraphmodule_conv_t type); PyObject* igraphmodule_vector_t_to_PyTuple(const igraph_vector_t *v); PyObject* igraphmodule_vector_t_pair_to_PyList(const igraph_vector_t *v1, const igraph_vector_t *v2); PyObject* igraphmodule_vector_t_to_PyList_pairs(const igraph_vector_t *v); PyObject* igraphmodule_vector_ptr_t_to_PyList(const igraph_vector_ptr_t *v, igraphmodule_conv_t type); PyObject* igraphmodule_vector_int_t_to_PyList(const igraph_vector_int_t *v); PyObject* igraphmodule_vector_long_t_to_PyList(const igraph_vector_long_t *v); PyObject* igraphmodule_matrix_t_to_PyList(const igraph_matrix_t *m, igraphmodule_conv_t type); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/dfsiter.c0000644000175100001710000002373300000000000017617 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2020 The igraph development team This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "dfsiter.h" #include "common.h" #include "error.h" #include "vertexobject.h" /** * \ingroup python_interface * \defgroup python_interface_dfsiter DFS iterator object */ PyTypeObject igraphmodule_DFSIterType; /** * \ingroup python_interface_dfsiter * \brief Allocate a new DFS iterator object for a given graph and a given root * \param g the graph object being referenced * \param vid the root vertex index * \param advanced whether the iterator should be advanced (returning distance and parent as well) * \return the allocated PyObject */ PyObject* igraphmodule_DFSIter_new(igraphmodule_GraphObject *g, PyObject *root, igraph_neimode_t mode, igraph_bool_t advanced) { igraphmodule_DFSIterObject* o; long int no_of_nodes, r; o=PyObject_GC_New(igraphmodule_DFSIterObject, &igraphmodule_DFSIterType); Py_INCREF(g); o->gref=g; o->graph=&g->g; if (!PyLong_Check(root) && !PyObject_IsInstance(root, (PyObject*)&igraphmodule_VertexType)) { PyErr_SetString(PyExc_TypeError, "root must be integer or igraph.Vertex"); return NULL; } no_of_nodes=igraph_vcount(&g->g); o->visited=(char*)calloc(no_of_nodes, sizeof(char)); if (o->visited == 0) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if (igraph_stack_init(&o->stack, 100)) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if (igraph_vector_init(&o->neis, 0)) { PyErr_SetString(PyExc_MemoryError, "out of memory"); igraph_stack_destroy(&o->stack); return NULL; } if (PyLong_Check(root)) { r=PyLong_AsLong(root); } else { r = ((igraphmodule_VertexObject*)root)->idx; } /* push the root onto the stack */ if (igraph_stack_push(&o->stack, r) || igraph_stack_push(&o->stack, 0) || igraph_stack_push(&o->stack, -1)) { igraph_stack_destroy(&o->stack); igraph_vector_destroy(&o->neis); PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } o->visited[r] = 1; if (!igraph_is_directed(&g->g)) mode=IGRAPH_ALL; o->mode=mode; o->advanced=advanced; PyObject_GC_Track(o); RC_ALLOC("DFSIter", o); return (PyObject*)o; } /** * \ingroup python_interface_dfsiter * \brief Support for cyclic garbage collection in Python * * This is necessary because the \c igraph.DFSIter object contains several * other \c PyObject pointers and they might point back to itself. */ int igraphmodule_DFSIter_traverse(igraphmodule_DFSIterObject *self, visitproc visit, void *arg) { int vret; RC_TRAVERSE("DFSIter", self); if (self->gref) { vret=visit((PyObject*)self->gref, arg); if (vret != 0) return vret; } return 0; } /** * \ingroup python_interface_dfsiter * \brief Clears the iterator's subobject (before deallocation) */ int igraphmodule_DFSIter_clear(igraphmodule_DFSIterObject *self) { PyObject *tmp; PyObject_GC_UnTrack(self); tmp=(PyObject*)self->gref; self->gref = NULL; Py_XDECREF(tmp); igraph_stack_destroy(&self->stack); igraph_vector_destroy(&self->neis); free(self->visited); self->visited = 0; return 0; } /** * \ingroup python_interface_dfsiter * \brief Deallocates a Python representation of a given DFS iterator object */ void igraphmodule_DFSIter_dealloc(igraphmodule_DFSIterObject* self) { igraphmodule_DFSIter_clear(self); RC_DEALLOC("DFSIter", self); PyObject_GC_Del(self); } PyObject* igraphmodule_DFSIter_iter(igraphmodule_DFSIterObject* self) { Py_INCREF(self); return (PyObject*)self; } PyObject* igraphmodule_DFSIter_iternext(igraphmodule_DFSIterObject* self) { /* the design is to return the top of the stack and then proceed until * we have found an unvisited neighbor and push that on top */ igraph_integer_t parent_out, dist_out, vid_out; igraph_bool_t any = 0; /* nothing on the stack, end of iterator */ if(igraph_stack_empty(&self->stack)) { return NULL; } /* peek at the top element on the stack * because we save three things, pop 3 in inverse order and push them back */ parent_out = (igraph_integer_t)igraph_stack_pop(&self->stack); dist_out = (igraph_integer_t)igraph_stack_pop(&self->stack); vid_out = (igraph_integer_t)igraph_stack_pop(&self->stack); igraph_stack_push(&self->stack, (long int) vid_out); igraph_stack_push(&self->stack, (long int) dist_out); igraph_stack_push(&self->stack, (long int) parent_out); /* look for neighbors until you found one or until you have exausted the graph */ while (!any && !igraph_stack_empty(&self->stack)) { igraph_integer_t parent = (igraph_integer_t)igraph_stack_pop(&self->stack); igraph_integer_t dist = (igraph_integer_t)igraph_stack_pop(&self->stack); igraph_integer_t vid = (igraph_integer_t)igraph_stack_pop(&self->stack); igraph_stack_push(&self->stack, (long int) vid); igraph_stack_push(&self->stack, (long int) dist); igraph_stack_push(&self->stack, (long int) parent); long int i; /* the values above are returned at at this stage. However, we must * prepare for the next iteration by putting the next unvisited * neighbor onto the stack */ if (igraph_neighbors(self->graph, &self->neis, vid, self->mode)) { igraphmodule_handle_igraph_error(); return NULL; } for (i=0; ineis); i++) { igraph_integer_t neighbor = (igraph_integer_t)VECTOR(self->neis)[i]; /* new neighbor, push the next item onto the stack */ if (self->visited[neighbor] == 0) { any = 1; self->visited[neighbor]=1; if (igraph_stack_push(&self->stack, neighbor) || igraph_stack_push(&self->stack, dist+1) || igraph_stack_push(&self->stack, vid)) { igraphmodule_handle_igraph_error(); return NULL; } break; } } /* no new neighbors, end of subtree */ if (!any) { igraph_stack_pop(&self->stack); igraph_stack_pop(&self->stack); igraph_stack_pop(&self->stack); } } /* no matter what the stack situation is: that is a worry for the next cycle * now just return the top of the stack as it was at the function entry */ PyObject *vertexobj = igraphmodule_Vertex_New(self->gref, vid_out); if (self->advanced) { PyObject *parentobj; if (!vertexobj) return NULL; if (parent_out >= 0) { parentobj = igraphmodule_Vertex_New(self->gref, parent_out); if (!parentobj) return NULL; } else { Py_INCREF(Py_None); parentobj=Py_None; } return Py_BuildValue("NlN", vertexobj, (long int)dist_out, parentobj); } else { return vertexobj; } } /** * \ingroup python_interface_dfsiter * Method table for the \c igraph.DFSIter object */ PyMethodDef igraphmodule_DFSIter_methods[] = { {NULL} }; /** \ingroup python_interface_dfsiter * Python type object referencing the methods Python calls when it performs various operations on * a DFS iterator of a graph */ PyTypeObject igraphmodule_DFSIterType = { PyVarObject_HEAD_INIT(0, 0) "igraph.DFSIter", // tp_name sizeof(igraphmodule_DFSIterObject), // tp_basicsize 0, // tp_itemsize (destructor)igraphmodule_DFSIter_dealloc, // tp_dealloc 0, // tp_print 0, // tp_getattr 0, // tp_setattr 0, /* tp_compare (2.x) / tp_reserved (3.x) */ 0, // tp_repr 0, // tp_as_number 0, // tp_as_sequence 0, // tp_as_mapping 0, // tp_hash 0, // tp_call 0, // tp_str 0, // tp_getattro 0, // tp_setattro 0, // tp_as_buffer Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, // tp_flags "igraph DFS iterator object", // tp_doc (traverseproc) igraphmodule_DFSIter_traverse, /* tp_traverse */ (inquiry) igraphmodule_DFSIter_clear, /* tp_clear */ 0, // tp_richcompare 0, // tp_weaklistoffset (getiterfunc)igraphmodule_DFSIter_iter, /* tp_iter */ (iternextfunc)igraphmodule_DFSIter_iternext, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/dfsiter.h0000644000175100001710000000322600000000000017617 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2020 The igraph development team This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_DFSITER_H #define PYTHON_DFSITER_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_dfsiter * \brief A structure representing a DFS iterator of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_stack_t stack; igraph_vector_t neis; igraph_t *graph; char *visited; igraph_neimode_t mode; igraph_bool_t advanced; } igraphmodule_DFSIterObject; PyObject* igraphmodule_DFSIter_new(igraphmodule_GraphObject *g, PyObject *o, igraph_neimode_t mode, igraph_bool_t advanced); int igraphmodule_DFSIter_traverse(igraphmodule_DFSIterObject *self, visitproc visit, void *arg); int igraphmodule_DFSIter_clear(igraphmodule_DFSIterObject *self); void igraphmodule_DFSIter_dealloc(igraphmodule_DFSIterObject* self); extern PyTypeObject igraphmodule_DFSIterType; #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/edgeobject.c0000644000175100001710000005475400000000000020261 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim: set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "edgeobject.h" #include "error.h" #include "graphobject.h" #include "pyhelpers.h" #include "vertexobject.h" /** * \ingroup python_interface * \defgroup python_interface_edge Edge object */ PyTypeObject igraphmodule_EdgeType; /** * \ingroup python_interface_edge * \brief Checks whether the given Python object is an edge */ int igraphmodule_Edge_Check(PyObject* obj) { if (!obj) return 0; return PyObject_IsInstance(obj, (PyObject*)(&igraphmodule_EdgeType)); } /** * \ingroup python_interface_edge * \brief Checks whether the index in the given edge object is a valid one. * \return nonzero if the edge object is valid. Raises an appropriate Python * exception and returns zero if the edge object is invalid. */ int igraphmodule_Edge_Validate(PyObject* obj) { igraph_integer_t n; igraphmodule_EdgeObject *self; igraphmodule_GraphObject *graph; if (!igraphmodule_Edge_Check(obj)) { PyErr_SetString(PyExc_TypeError, "object is not an Edge"); return 0; } self = (igraphmodule_EdgeObject*)obj; graph = self->gref; if (graph == 0) { PyErr_SetString(PyExc_ValueError, "Edge object refers to a null graph"); return 0; } if (self->idx < 0) { PyErr_SetString(PyExc_ValueError, "Edge object refers to a negative edge index"); return 0; } n = igraph_ecount(&graph->g); if (self->idx >= n) { PyErr_SetString(PyExc_ValueError, "Edge object refers to a nonexistent edge"); return 0; } return 1; } /** * \ingroup python_interface_edge * \brief Allocates a new Python edge object * \param gref weak reference of the \c igraph.Graph being referenced by the edge * \param idx the index of the edge * * \warning \c igraph references its edges by indices, so if * you delete some edges from the graph, the edge indices will * change. Since the \c igraph.Edge objects do not follow these * changes, your existing edge objects will point to elsewhere * (or they might even get invalidated). */ PyObject* igraphmodule_Edge_New(igraphmodule_GraphObject *gref, igraph_integer_t idx) { igraphmodule_EdgeObject* self; self=PyObject_New(igraphmodule_EdgeObject, &igraphmodule_EdgeType); if (self) { RC_ALLOC("Edge", self); Py_INCREF(gref); self->gref=gref; self->idx=idx; self->hash=-1; } return (PyObject*)self; } /** * \ingroup python_interface_edge * \brief Clears the edge's subobject (before deallocation) */ int igraphmodule_Edge_clear(igraphmodule_EdgeObject *self) { PyObject *tmp; tmp=(PyObject*)self->gref; self->gref=NULL; Py_XDECREF(tmp); return 0; } /** * \ingroup python_interface_edge * \brief Deallocates a Python representation of a given edge object */ void igraphmodule_Edge_dealloc(igraphmodule_EdgeObject* self) { igraphmodule_Edge_clear(self); RC_DEALLOC("Edge", self); PyObject_Del((PyObject*)self); } /** \ingroup python_interface_edge * \brief Formats an \c igraph.Edge object as a string * * \return the formatted textual representation as a \c PyObject */ PyObject* igraphmodule_Edge_repr(igraphmodule_EdgeObject *self) { PyObject *s; PyObject *attrs; attrs = igraphmodule_Edge_attributes(self); if (attrs == 0) return NULL; s = PyUnicode_FromFormat("igraph.Edge(%R, %ld, %R)", (PyObject*)self->gref, (long int)self->idx, attrs); Py_DECREF(attrs); return s; } /** \ingroup python_interface_edge * \brief Returns the hash code of the edge */ long igraphmodule_Edge_hash(igraphmodule_EdgeObject* self) { long hash_graph; long hash_index; long result; PyObject* index_o; if (self->hash != -1) return self->hash; index_o = PyLong_FromLong((long int)self->idx); if (index_o == 0) return -1; hash_index = PyObject_Hash(index_o); Py_DECREF(index_o); if (hash_index == -1) return -1; /* Graph objects are unhashable from Python so we cannot call PyObject_Hash * directly. */ hash_graph = igraphmodule_Py_HashPointer(self->gref); if (hash_graph == -1) return -1; result = hash_graph ^ hash_index; if (result == -1) result = 590923713U; self->hash = result; return result; } /** \ingroup python_interface_edge * \brief Rich comparison of an edge with another */ PyObject* igraphmodule_Edge_richcompare(igraphmodule_EdgeObject *a, PyObject *b, int op) { igraphmodule_EdgeObject* self = a; igraphmodule_EdgeObject* other; if (!igraphmodule_Edge_Check(b)) Py_RETURN_NOTIMPLEMENTED; other = (igraphmodule_EdgeObject*)b; if (self->gref != other->gref) Py_RETURN_FALSE; switch (op) { case Py_EQ: Py_RETURN(self->idx == other->idx); case Py_NE: Py_RETURN(self->idx != other->idx); case Py_LE: Py_RETURN(self->idx <= other->idx); case Py_LT: Py_RETURN(self->idx < other->idx); case Py_GE: Py_RETURN(self->idx >= other->idx); case Py_GT: Py_RETURN(self->idx > other->idx); default: Py_RETURN_NOTIMPLEMENTED; } } /** \ingroup python_interface_edge * \brief Returns the number of edge attributes */ Py_ssize_t igraphmodule_Edge_attribute_count(igraphmodule_EdgeObject* self) { igraphmodule_GraphObject *o = self->gref; if (!o) return 0; if (!((PyObject**)o->g.attr)[1]) return 0; return PyDict_Size(((PyObject**)o->g.attr)[1]); } /** \ingroup python_interface_edge * \brief Returns the list of attribute names */ PyObject* igraphmodule_Edge_attribute_names(igraphmodule_EdgeObject* self) { if (!self->gref) return NULL; return igraphmodule_Graph_edge_attributes(self->gref); } /** \ingroup python_interface_edge * \brief Returns a dict with attribute names and values */ PyObject* igraphmodule_Edge_attributes(igraphmodule_EdgeObject* self) { igraphmodule_GraphObject *o = self->gref; PyObject *names, *dict; long int i, n; if (!igraphmodule_Edge_Validate((PyObject*)self)) return 0; dict=PyDict_New(); if (!dict) return NULL; names=igraphmodule_Graph_edge_attributes(o); if (!names) { Py_DECREF(dict); return NULL; } n = PyList_Size(names); for (i=0; ig.attr)[ATTRHASH_IDX_EDGE], name); if (dictit) { PyObject *value = PyList_GetItem(dictit, self->idx); if (value) { /* no need to Py_INCREF, PyDict_SetItem will do that */ PyDict_SetItem(dict, name, value); } } } } Py_DECREF(names); return dict; } /** * \ingroup python_interface_edge * \brief Updates some attributes of an edge * * \param self the edge object * \param args positional arguments * \param kwds keyword arguments */ PyObject* igraphmodule_Edge_update_attributes(PyObject* self, PyObject* args, PyObject* kwds) { return igraphmodule_Vertex_update_attributes(self, args, kwds); } /** \ingroup python_interface_edge * \brief Returns the corresponding value to a given attribute of the edge * \param self the edge object * \param s the attribute name to be queried */ PyObject* igraphmodule_Edge_get_attribute(igraphmodule_EdgeObject* self, PyObject* s) { igraphmodule_GraphObject *o = self->gref; PyObject* result; if (!igraphmodule_Edge_Validate((PyObject*)self)) return 0; if (!igraphmodule_attribute_name_check(s)) return 0; result=PyDict_GetItem(((PyObject**)o->g.attr)[2], s); if (result) { /* result is a list, so get the element with index self->idx */ if (!PyList_Check(result)) { PyErr_SetString(igraphmodule_InternalError, "Edge attribute dict member is not a list"); return NULL; } result=PyList_GetItem(result, self->idx); Py_INCREF(result); return result; } /* result is NULL, check whether there was an error */ if (!PyErr_Occurred()) PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return NULL; } /** \ingroup python_interface_edge * \brief Sets the corresponding value of a given attribute of the edge * \param self the edge object * \param k the attribute name to be set * \param v the value to be set * \return 0 if everything's ok, -1 in case of error */ int igraphmodule_Edge_set_attribute(igraphmodule_EdgeObject* self, PyObject* k, PyObject* v) { igraphmodule_GraphObject *o=self->gref; PyObject* result; int r; if (!igraphmodule_Edge_Validate((PyObject*)self)) return -1; if (!igraphmodule_attribute_name_check(k)) return -1; if (v==NULL) // we are deleting attribute return PyDict_DelItem(((PyObject**)o->g.attr)[2], k); result=PyDict_GetItem(((PyObject**)o->g.attr)[2], k); if (result) { /* result is a list, so set the element with index self->idx */ if (!PyList_Check(result)) { PyErr_SetString(igraphmodule_InternalError, "Vertex attribute dict member is not a list"); return -1; } /* we actually don't own a reference here to v, so we must increase * its reference count, because PyList_SetItem will "steal" a reference! * It took me 1.5 hours between London and Manchester to figure it out */ Py_INCREF(v); r=PyList_SetItem(result, self->idx, v); if (r == -1) { Py_DECREF(v); } return r; } /* result is NULL, check whether there was an error */ if (!PyErr_Occurred()) { /* no, there wasn't, so we must simply add the attribute */ int n=(int)igraph_ecount(&o->g), i; result=PyList_New(n); for (i=0; iidx) { Py_INCREF(Py_None); if (PyList_SetItem(result, i, Py_None) == -1) { Py_DECREF(Py_None); Py_DECREF(result); return -1; } } else { /* Same game with the reference count here */ Py_INCREF(v); if (PyList_SetItem(result, i, v) == -1) { Py_DECREF(v); Py_DECREF(result); return -1; } } } if (PyDict_SetItem(((PyObject**)o->g.attr)[2], k, result) == -1) { Py_DECREF(result); /* TODO: is it needed here? maybe not! */ return -1; } Py_DECREF(result); /* compensating for PyDict_SetItem */ return 0; } return -1; } /** * \ingroup python_interface_edge * Returns the source vertex index of an edge */ PyObject* igraphmodule_Edge_get_from(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } return PyLong_FromLong((long int)from); } /** * \ingroup python_interface_edge * Returns the source vertex index of an edge */ PyObject* igraphmodule_Edge_get_source_vertex(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } return igraphmodule_Vertex_New(o, from); } /** * \ingroup python_interface_edge * Returns the target vertex index of an edge */ PyObject* igraphmodule_Edge_get_to(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } return PyLong_FromLong((long)to); } /** * \ingroup python_interface_edge * Returns the target vertex of an edge */ PyObject* igraphmodule_Edge_get_target_vertex(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } return igraphmodule_Vertex_New(o, to); } /** * \ingroup python_interface_edge * Returns the edge index */ PyObject* igraphmodule_Edge_get_index(igraphmodule_EdgeObject* self, void* closure) { return PyLong_FromLong((long int)self->idx); } /** * \ingroup python_interface_edge * Returns the edge index as an igraph_integer_t */ igraph_integer_t igraphmodule_Edge_get_index_igraph_integer(igraphmodule_EdgeObject* self) { return self->idx; } /** * \ingroup python_interface_edge * Returns the edge index as an ordinary C long */ long igraphmodule_Edge_get_index_long(igraphmodule_EdgeObject* self) { return (long)self->idx; } /** * \ingroup python_interface_edge * Returns the source and target vertex index of an edge */ PyObject* igraphmodule_Edge_get_tuple(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } return Py_BuildValue("(ii)", (long)from, (long)to); } /** * \ingroup python_interface_edge * Returns the source and target vertex of an edge */ PyObject* igraphmodule_Edge_get_vertex_tuple(igraphmodule_EdgeObject* self, void* closure) { igraphmodule_GraphObject *o = self->gref; igraph_integer_t from, to; PyObject *from_o, *to_o; if (!igraphmodule_Edge_Validate((PyObject*)self)) return NULL; if (igraph_edge(&o->g, self->idx, &from, &to)) { igraphmodule_handle_igraph_error(); return NULL; } from_o = igraphmodule_Vertex_New(o, from); if (!from_o) { return NULL; } to_o = igraphmodule_Vertex_New(o, to); if (!to_o) { Py_DECREF(from_o); return NULL; } return Py_BuildValue("(NN)", from_o, to_o); /* steals references */ } /** \ingroup python_interface_edge * Returns the graph where the edge belongs */ PyObject* igraphmodule_Edge_get_graph(igraphmodule_EdgeObject* self, void* closure) { Py_INCREF(self->gref); return (PyObject*)self->gref; } #define GRAPH_PROXY_METHOD(FUNC, METHODNAME) \ PyObject* igraphmodule_Edge_##FUNC(igraphmodule_EdgeObject* self, PyObject* args, PyObject* kwds) { \ PyObject *new_args, *item, *result; \ long int i, num_args = args ? PyTuple_Size(args)+1 : 1; \ \ /* Prepend ourselves to args */ \ new_args = PyTuple_New(num_args); \ Py_INCREF(self); PyTuple_SET_ITEM(new_args, 0, (PyObject*)self); \ for (i = 1; i < num_args; i++) { \ item = PyTuple_GET_ITEM(args, i-1); \ Py_INCREF(item); PyTuple_SET_ITEM(new_args, i, item); \ } \ \ /* Get the method instance */ \ item = PyObject_GetAttrString((PyObject*)(self->gref), METHODNAME); \ result = PyObject_Call(item, new_args, kwds); \ Py_DECREF(item); \ Py_DECREF(new_args); \ return result; \ } GRAPH_PROXY_METHOD(count_multiple, "count_multiple"); GRAPH_PROXY_METHOD(delete, "delete_edges"); GRAPH_PROXY_METHOD(is_loop, "is_loop"); GRAPH_PROXY_METHOD(is_multiple, "is_multiple"); GRAPH_PROXY_METHOD(is_mutual, "is_mutual"); #undef GRAPH_PROXY_METHOD #define GRAPH_PROXY_METHOD_SPEC(FUNC, METHODNAME) \ {METHODNAME, (PyCFunction)igraphmodule_Edge_##FUNC, METH_VARARGS | METH_KEYWORDS, \ "Proxy method to L{Graph." METHODNAME "()}\n\n" \ "This method calls the " METHODNAME " method of the L{Graph} class " \ "with this edge as the first argument, and returns the result.\n\n"\ "@see: L{Graph." METHODNAME "()} for details."} #define GRAPH_PROXY_METHOD_SPEC_2(FUNC, METHODNAME, METHODNAME_IN_GRAPH) \ {METHODNAME, (PyCFunction)igraphmodule_Edge_##FUNC, METH_VARARGS | METH_KEYWORDS, \ "Proxy method to L{Graph." METHODNAME_IN_GRAPH "()}\n\n" \ "This method calls the " METHODNAME_IN_GRAPH " method of the L{Graph} class " \ "with this edge as the first argument, and returns the result.\n\n"\ "@see: L{Graph." METHODNAME_IN_GRAPH "()} for details."} /** * \ingroup python_interface_edge * Method table for the \c igraph.Edge object */ PyMethodDef igraphmodule_Edge_methods[] = { {"attributes", (PyCFunction)igraphmodule_Edge_attributes, METH_NOARGS, "attributes()\n--\n\n" "Returns a dict of attribute names and values for the edge\n" }, {"attribute_names", (PyCFunction)igraphmodule_Edge_attribute_names, METH_NOARGS, "attribute_names()\n--\n\n" "Returns the list of edge attribute names\n" }, {"update_attributes", (PyCFunction)igraphmodule_Edge_update_attributes, METH_VARARGS | METH_KEYWORDS, "update_attributes(E, **F)\n--\n\n" "Updates the attributes of the edge from dict/iterable E and F.\n\n" "If E has a C{keys()} method, it does: C{for k in E: self[k] = E[k]}.\n" "If E lacks a C{keys()} method, it does: C{for (k, v) in E: self[k] = v}.\n" "In either case, this is followed by: C{for k in F: self[k] = F[k]}.\n\n" "This method thus behaves similarly to the C{update()} method of Python\n" "dictionaries." }, GRAPH_PROXY_METHOD_SPEC(count_multiple, "count_multiple"), GRAPH_PROXY_METHOD_SPEC_2(delete, "delete", "delete_edges"), GRAPH_PROXY_METHOD_SPEC(is_loop, "is_loop"), GRAPH_PROXY_METHOD_SPEC(is_multiple, "is_multiple"), GRAPH_PROXY_METHOD_SPEC(is_mutual, "is_mutual"), {NULL} }; #undef GRAPH_PROXY_METHOD_SPEC #undef GRAPH_PROXY_METHOD_SPEC_2 /** * \ingroup python_interface_edge * Getter/setter table for the \c igraph.Edge object */ PyGetSetDef igraphmodule_Edge_getseters[] = { {"source", (getter)igraphmodule_Edge_get_from, NULL, "Source vertex index of this edge", NULL }, {"source_vertex", (getter)igraphmodule_Edge_get_source_vertex, NULL, "Source vertex of this edge", NULL }, {"target", (getter)igraphmodule_Edge_get_to, NULL, "Target vertex index of this edge", NULL }, {"target_vertex", (getter)igraphmodule_Edge_get_target_vertex, NULL, "Target vertex of this edge", NULL }, {"tuple", (getter)igraphmodule_Edge_get_tuple, NULL, "Source and target vertex index of this edge as a tuple", NULL }, {"vertex_tuple", (getter)igraphmodule_Edge_get_vertex_tuple, NULL, "Source and target vertex of this edge as a tuple", NULL }, {"index", (getter)igraphmodule_Edge_get_index, NULL, "Index of this edge", NULL, }, {"graph", (getter)igraphmodule_Edge_get_graph, NULL, "The graph the edge belongs to", NULL, }, {NULL} }; /** \ingroup python_interface_edge * This structure is the collection of functions necessary to implement * the edge as a mapping (i.e. to allow the retrieval and setting of * igraph attributes in Python as if it were of a Python mapping type) */ PyMappingMethods igraphmodule_Edge_as_mapping = { // returns the number of edge attributes (lenfunc)igraphmodule_Edge_attribute_count, // returns an attribute by name (binaryfunc)igraphmodule_Edge_get_attribute, // sets an attribute by name (objobjargproc)igraphmodule_Edge_set_attribute }; /** \ingroup python_interface_edge * Python type object referencing the methods Python calls when it performs various operations on * an edge of a graph */ PyTypeObject igraphmodule_EdgeType = { PyVarObject_HEAD_INIT(0, 0) "igraph.Edge", // tp_name sizeof(igraphmodule_EdgeObject), // tp_basicsize 0, // tp_itemsize (destructor)igraphmodule_Edge_dealloc, // tp_dealloc 0, // tp_print 0, // tp_getattr 0, // tp_setattr 0, /* tp_compare (2.x) / tp_reserved (3.x) */ (reprfunc)igraphmodule_Edge_repr, // tp_repr 0, // tp_as_number 0, // tp_as_sequence &igraphmodule_Edge_as_mapping, // tp_as_mapping (hashfunc)igraphmodule_Edge_hash, /* tp_hash */ 0, // tp_call 0, // tp_str 0, // tp_getattro 0, // tp_setattro 0, // tp_as_buffer Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags "Class representing a single edge in a graph.\n\n" "The edge is referenced by its index, so if the underlying graph\n" "changes, the semantics of the edge object might change as well\n" "(if the edge indices are altered in the original graph).\n\n" "The attributes of the edge can be accessed by using the edge\n" "as a hash:\n\n" " >>> e[\"weight\"] = 2 #doctest: +SKIP\n" " >>> print(e[\"weight\"]) #doctest: +SKIP\n" " 2\n", // tp_doc 0, // tp_traverse 0, // tp_clear (richcmpfunc)igraphmodule_Edge_richcompare, /* tp_richcompare */ 0, // tp_weaklistoffset 0, // tp_iter 0, // tp_iternext igraphmodule_Edge_methods, // tp_methods 0, // tp_members igraphmodule_Edge_getseters, // tp_getset }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/edgeobject.h0000644000175100001710000000372000000000000020251 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_EDGEOBJECT_H #define PYTHON_EDGEOBJECT_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_edge * \brief A structure representing an edge of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_integer_t idx; long hash; } igraphmodule_EdgeObject; int igraphmodule_Edge_clear(igraphmodule_EdgeObject *self); void igraphmodule_Edge_dealloc(igraphmodule_EdgeObject* self); int igraphmodule_Edge_Check(PyObject *obj); int igraphmodule_Edge_Validate(PyObject *obj); PyObject* igraphmodule_Edge_New(igraphmodule_GraphObject *gref, igraph_integer_t idx); PyObject* igraphmodule_Edge_repr(igraphmodule_EdgeObject *self); PyObject* igraphmodule_Edge_attributes(igraphmodule_EdgeObject* self); PyObject* igraphmodule_Edge_attribute_names(igraphmodule_EdgeObject* self); igraph_integer_t igraphmodule_Edge_get_index_igraph_integer(igraphmodule_EdgeObject* self); long igraphmodule_Edge_get_index_long(igraphmodule_EdgeObject* self); PyObject* igraphmodule_Edge_update_attributes(PyObject* self, PyObject* args, PyObject* kwds); extern PyTypeObject igraphmodule_EdgeType; #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/edgeseqobject.c0000644000175100001710000010036300000000000020756 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim: set ts=2 sts=2 sw=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "common.h" #include "convert.h" #include "edgeseqobject.h" #include "edgeobject.h" #include "error.h" #include "pyhelpers.h" #define GET_GRAPH(obj) (((igraphmodule_GraphObject*)obj->gref)->g) /** * \ingroup python_interface * \defgroup python_interface_edgeseq Edge sequence object */ PyTypeObject igraphmodule_EdgeSeqType; /** * \ingroup python_interface_edgeseq * \brief Allocate a new edge sequence object for a given graph * \param g the graph object being referenced * \return the allocated PyObject */ PyObject* igraphmodule_EdgeSeq_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) { igraphmodule_EdgeSeqObject* o; o=(igraphmodule_EdgeSeqObject*)PyType_GenericNew(subtype, args, kwds); if (o == NULL) return NULL; igraph_es_all(&o->es, IGRAPH_EDGEORDER_ID); o->gref=0; o->weakreflist=0; RC_ALLOC("EdgeSeq", o); return (PyObject*)o; } /** * \ingroup python_interface_edgeseq * \brief Copies an edge sequence object * \return the copied PyObject */ igraphmodule_EdgeSeqObject* igraphmodule_EdgeSeq_copy(igraphmodule_EdgeSeqObject* o) { igraphmodule_EdgeSeqObject *copy; copy=(igraphmodule_EdgeSeqObject*)PyType_GenericNew(Py_TYPE(o), 0, 0); if (copy == NULL) return NULL; if (igraph_es_type(&o->es) == IGRAPH_ES_VECTOR) { igraph_vector_t v; if (igraph_vector_copy(&v, o->es.data.vecptr)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_vector_copy(©->es, &v)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return 0; } igraph_vector_destroy(&v); } else { copy->es = o->es; } copy->gref = o->gref; if (o->gref) Py_INCREF(o->gref); RC_ALLOC("EdgeSeq(copy)", copy); return copy; } /** * \ingroup python_interface_edgeseq * \brief Initialize a new edge sequence object for a given graph * \return the initialized PyObject */ int igraphmodule_EdgeSeq_init(igraphmodule_EdgeSeqObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "graph", "edges", NULL }; PyObject *g, *esobj=Py_None; igraph_es_t es; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist, &igraphmodule_GraphType, &g, &esobj)) return -1; if (esobj == Py_None) { /* If es is None, we are selecting all the edges */ igraph_es_all(&es, IGRAPH_EDGEORDER_ID); } else if (PyLong_Check(esobj)) { /* We selected a single edge */ long int idx = PyLong_AsLong(esobj); if (idx < 0 || idx >= igraph_ecount(&((igraphmodule_GraphObject*)g)->g)) { PyErr_SetString(PyExc_ValueError, "edge index out of range"); return -1; } igraph_es_1(&es, (igraph_integer_t)idx); } else { /* We selected multiple edges */ igraph_vector_t v; igraph_integer_t n = igraph_ecount(&((igraphmodule_GraphObject*)g)->g); if (igraphmodule_PyObject_to_vector_t(esobj, &v, 1)) return -1; if (!igraph_vector_isininterval(&v, 0, n-1)) { igraph_vector_destroy(&v); PyErr_SetString(PyExc_ValueError, "edge index out of range"); return -1; } if (igraph_es_vector_copy(&es, &v)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return -1; } igraph_vector_destroy(&v); } self->es = es; Py_INCREF(g); self->gref = (igraphmodule_GraphObject*)g; return 0; } /** * \ingroup python_interface_edgeseq * \brief Deallocates a Python representation of a given edge sequence object */ void igraphmodule_EdgeSeq_dealloc(igraphmodule_EdgeSeqObject* self) { if (self->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *)self); if (self->gref) { igraph_es_destroy(&self->es); Py_DECREF(self->gref); self->gref=0; } Py_TYPE(self)->tp_free((PyObject*)self); RC_DEALLOC("EdgeSeq", self); } /** * \ingroup python_interface_edgeseq * \brief Returns the length of the sequence (i.e. the number of edges in the graph) */ int igraphmodule_EdgeSeq_sq_length(igraphmodule_EdgeSeqObject* self) { igraph_t *g; igraph_integer_t result; g=&GET_GRAPH(self); if (igraph_es_size(g, &self->es, &result)) { igraphmodule_handle_igraph_error(); return -1; } return (int)result; } /** * \ingroup python_interface_edgeseq * \brief Returns the item at the given index in the sequence */ PyObject* igraphmodule_EdgeSeq_sq_item(igraphmodule_EdgeSeqObject* self, Py_ssize_t i) { igraph_t *g; igraph_integer_t idx = -1; if (!self->gref) return NULL; g=&GET_GRAPH(self); switch (igraph_es_type(&self->es)) { case IGRAPH_ES_ALL: if (i < 0) { i = igraph_ecount(g) + i; } if (i >= 0 && i < igraph_ecount(g)) { idx = (igraph_integer_t)i; } break; case IGRAPH_ES_VECTOR: case IGRAPH_ES_VECTORPTR: if (i < 0) { i = igraph_vector_size(self->es.data.vecptr) + i; } if (i >= 0 && i < igraph_vector_size(self->es.data.vecptr)) { idx = (igraph_integer_t)VECTOR(*self->es.data.vecptr)[i]; } break; case IGRAPH_ES_1: if (i == 0 || i == -1) { idx = self->es.data.eid; } break; case IGRAPH_ES_SEQ: if (i < 0) { i = self->es.data.seq.to - self->es.data.seq.from + i; } if (i >= 0 && i < self->es.data.seq.to - self->es.data.seq.from) { idx = self->es.data.seq.from + (igraph_integer_t)i; } break; /* TODO: IGRAPH_ES_PAIRS, IGRAPH_ES_ADJ, IGRAPH_ES_PATH, IGRAPH_ES_MULTIPATH - someday :) They are unused yet in the Python interface */ } if (idx < 0) { PyErr_SetString(PyExc_IndexError, "edge index out of range"); return NULL; } return igraphmodule_Edge_New(self->gref, idx); } /** \ingroup python_interface_edgeseq * \brief Returns the list of attribute names */ PyObject* igraphmodule_EdgeSeq_attribute_names(igraphmodule_EdgeSeqObject* self) { return igraphmodule_Graph_edge_attributes(self->gref); } /** \ingroup python_interface_edgeseq * \brief Returns the list of values for a given attribute */ PyObject* igraphmodule_EdgeSeq_get_attribute_values(igraphmodule_EdgeSeqObject* self, PyObject* o) { igraphmodule_GraphObject *gr = self->gref; PyObject *result=0, *values, *item; long int i, n; if (!igraphmodule_attribute_name_check(o)) return 0; PyErr_Clear(); values=PyDict_GetItem(ATTR_STRUCT_DICT(&gr->g)[ATTRHASH_IDX_EDGE], o); if (!values) { PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return NULL; } else if (PyErr_Occurred()) return NULL; switch (igraph_es_type(&self->es)) { case IGRAPH_ES_NONE: n = 0; result = PyList_New(0); break; case IGRAPH_ES_ALL: n = PyList_Size(values); result = PyList_New(n); if (!result) return 0; for (i=0; ies.data.vecptr); result = PyList_New(n); if (!result) return 0; for (i=0; ies.data.vecptr)[i]); Py_INCREF(item); PyList_SET_ITEM(result, i, item); } break; case IGRAPH_ES_SEQ: n = self->es.data.seq.to - self->es.data.seq.from; result = PyList_New(n); if (!result) return 0; for (i=0; ies.data.seq.from+i); Py_INCREF(item); PyList_SET_ITEM(result, i, item); } break; default: PyErr_SetString(PyExc_RuntimeError, "invalid edge selector"); } return result; } PyObject* igraphmodule_EdgeSeq_is_all(igraphmodule_EdgeSeqObject* self) { if (igraph_es_is_all(&self->es)) Py_RETURN_TRUE; Py_RETURN_FALSE; } PyObject* igraphmodule_EdgeSeq_get_attribute_values_mapping(igraphmodule_EdgeSeqObject *self, PyObject *o) { Py_ssize_t index; /* Handle integer indices according to the sequence protocol */ if (PyIndex_Check(o)) { index = PyNumber_AsSsize_t(o, 0); return igraphmodule_EdgeSeq_sq_item(self, index); } /* Handle strings according to the mapping protocol */ if (PyBaseString_Check(o)) { return igraphmodule_EdgeSeq_get_attribute_values(self, o); } /* Handle iterables and slices by calling the select() method */ if (PySlice_Check(o) || PyObject_HasAttrString(o, "__iter__")) { PyObject *result, *args; args = PyTuple_Pack(1, o); if (!args) { return NULL; } result = igraphmodule_EdgeSeq_select(self, args); Py_DECREF(args); return result; } /* Handle everything else according to the mapping protocol */ return igraphmodule_EdgeSeq_get_attribute_values(self, o); } /** \ingroup python_interface_edgeseq * \brief Sets the list of values for a given attribute */ int igraphmodule_EdgeSeq_set_attribute_values_mapping(igraphmodule_EdgeSeqObject* self, PyObject* attrname, PyObject* values) { PyObject *dict, *list, *item; igraphmodule_GraphObject *gr; igraph_vector_t es; long i, j, n, no_of_edges; gr = self->gref; dict = ATTR_STRUCT_DICT(&gr->g)[ATTRHASH_IDX_EDGE]; if (!igraphmodule_attribute_name_check(attrname)) return -1; if (values == 0) { if (igraph_es_type(&self->es) == IGRAPH_ES_ALL) return PyDict_DelItem(dict, attrname); PyErr_SetString(PyExc_TypeError, "can't delete attribute from an edge sequence not representing the whole graph"); return -1; } if (PyUnicode_Check(values) || !PySequence_Check(values)) { /* If values is a string or not a sequence, we construct a list with a * single element (the value itself) and then call ourselves again */ int result; PyObject *newList = PyList_New(1); if (newList == 0) return -1; Py_INCREF(values); PyList_SET_ITEM(newList, 0, values); /* reference stolen here */ result = igraphmodule_EdgeSeq_set_attribute_values_mapping(self, attrname, newList); Py_DECREF(newList); return result; } n=PySequence_Size(values); if (n<0) return -1; if (igraph_es_type(&self->es) == IGRAPH_ES_ALL) { no_of_edges = (long)igraph_ecount(&gr->g); if (n == 0 && no_of_edges > 0) { PyErr_SetString(PyExc_ValueError, "sequence must not be empty"); return -1; } /* Check if we already have attributes with the given name */ list = PyDict_GetItem(dict, attrname); if (list != 0) { /* Yes, we have. Modify its items to the items found in values */ for (i=0, j=0; ig, self->es, &es)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&es); return -1; } no_of_edges = (long)igraph_vector_size(&es); if (n == 0 && no_of_edges > 0) { PyErr_SetString(PyExc_ValueError, "sequence must not be empty"); igraph_vector_destroy(&es); return -1; } /* Check if we already have attributes with the given name */ list = PyDict_GetItem(dict, attrname); if (list != 0) { /* Yes, we have. Modify its items to the items found in values */ for (i=0, j=0; ig); list = PyList_New(n2); if (list == 0) { igraph_vector_destroy(&es); return -1; } for (i=0; ies); igraph_vector_t v, v2; long i, j, n, m; gr = self->gref; result = igraphmodule_EdgeSeq_copy(self); if (result == 0) return NULL; /* First, filter by positional arguments */ n = PyTuple_Size(args); for (i = 0; i < n; i++) { PyObject *item = PyTuple_GET_ITEM(args, i); if (item == Py_None) { /* None means: select nothing */ igraph_es_destroy(&result->es); igraph_es_none(&result->es); /* We can simply bail out here */ return (PyObject*) result; } else if (PyCallable_Check(item)) { /* Call the callable for every edge in the current sequence to * determine what's up */ igraph_bool_t was_excluded = 0; igraph_vector_t v; if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } m = PySequence_Size((PyObject*)result); for (j = 0; j < m; j++) { PyObject *edge = PySequence_GetItem((PyObject*)result, j); PyObject *call_result; if (edge == 0) { Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } call_result = PyObject_CallFunctionObjArgs(item, edge, NULL); if (call_result == 0) { Py_DECREF(edge); Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } if (PyObject_IsTrue(call_result)) { igraph_vector_push_back(&v, igraphmodule_Edge_get_index_long((igraphmodule_EdgeObject*)edge)); } else { was_excluded = 1; } Py_DECREF(call_result); Py_DECREF(edge); } if (was_excluded) { igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return NULL; } } igraph_vector_destroy(&v); } else if (PyLong_Check(item)) { /* Integers are treated specially: from now on, all remaining items * in the argument list must be integers and they will be used together * to restrict the edge set. Integers are interpreted as indices on the * edge set and NOT on the original, untouched edge sequence of the * graph */ if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (!working_on_whole_graph) { /* Extract the current vertex sequence into a vector */ if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_as_vector(&gr->g, self->es, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); } else { /* v2 left uninitialized, we are not going to use it as it would * simply contain integers from 0 to ecount(g)-1 */ m = igraph_ecount(&gr->g); } for (; i < n; i++) { PyObject *item2 = PyTuple_GET_ITEM(args, i); long idx; if (!PyLong_Check(item2)) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "edge indices expected"); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } idx = PyLong_AsLong(item2); if (idx >= m || idx < 0) { PyErr_SetString(PyExc_ValueError, "edge index out of range"); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } if (igraph_vector_push_back(&v, working_on_whole_graph ? idx : VECTOR(v2)[idx])) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } } if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } else { /* Iterators and everything that was not handled directly */ PyObject *iter, *item2; /* Allocate stuff */ if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (!working_on_whole_graph) { /* Extract the current vertex sequence into a vector */ if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_as_vector(&gr->g, self->es, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); } else { /* v2 left uninitialized, we are not going to use it as it would * simply contain integers from 0 to ecount(g)-1 */ m = igraph_ecount(&gr->g); } /* Create an appropriate iterator */ if (PySlice_Check(item)) { /* Create an iterator from the slice (which is not iterable by default )*/ Py_ssize_t start, stop, step, sl; PyObject* range; igraph_bool_t ok; ok = (PySlice_GetIndicesEx(item, m, &start, &stop, &step, &sl) == 0); if (ok) { range = igraphmodule_PyRange_create(start, stop, step); ok = (range != 0); } if (ok) { iter = PyObject_GetIter(range); Py_DECREF(range); ok = (iter != 0); } if (!ok) { igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } PyErr_SetString(PyExc_TypeError, "error while converting slice to iterator"); Py_DECREF(result); return 0; } } else { /* Simply create the iterator corresponding to the object */ iter = PyObject_GetIter(item); } /* Did we manage to get an iterator? */ if (iter == 0) { igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } PyErr_SetString(PyExc_TypeError, "invalid edge filter among positional arguments"); Py_DECREF(result); return 0; } /* Do the iteration */ while ((item2 = PyIter_Next(iter)) != 0) { if (igraphmodule_PyObject_to_integer_t(item2, &igraph_idx)) { /* We simply ignore elements that we don't know */ Py_DECREF(item2); } else { Py_DECREF(item2); if (igraph_idx >= m || igraph_idx < 0) { PyErr_SetString(PyExc_ValueError, "edge index out of range"); Py_DECREF(result); Py_DECREF(iter); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } if (igraph_vector_push_back(&v, working_on_whole_graph ? igraph_idx : VECTOR(v2)[(long int) igraph_idx])) { Py_DECREF(result); Py_DECREF(iter); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } } } /* Deallocate stuff */ if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } Py_DECREF(iter); if (PyErr_Occurred()) { igraph_vector_destroy(&v); Py_DECREF(result); return 0; } igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } } return (PyObject*)result; } /** * \ingroup python_interface_edgeseq * Method table for the \c igraph.EdgeSeq object */ PyMethodDef igraphmodule_EdgeSeq_methods[] = { {"attribute_names", (PyCFunction)igraphmodule_EdgeSeq_attribute_names, METH_NOARGS, "attribute_names()\n--\n\n" "Returns the attribute name list of the graph's edges\n" }, {"find", (PyCFunction)igraphmodule_EdgeSeq_find, METH_VARARGS, "find(condition)\n--\n\n" "For internal use only.\n" }, {"get_attribute_values", (PyCFunction)igraphmodule_EdgeSeq_get_attribute_values, METH_O, "get_attribute_values(attrname)\n--\n\n" "Returns the value of a given edge attribute for all edges.\n\n" "@param attrname: the name of the attribute\n" }, {"is_all", (PyCFunction)igraphmodule_EdgeSeq_is_all, METH_NOARGS, "is_all()\n--\n\n" "Returns whether the edge sequence contains all the edges exactly once, in\n" "the order of their edge IDs.\n\n" "This is used for optimizations in some of the edge selector routines.\n" }, {"set_attribute_values", (PyCFunction)igraphmodule_EdgeSeq_set_attribute_values, METH_VARARGS | METH_KEYWORDS, "set_attribute_values(attrname, values)\n--\n\n" "Sets the value of a given edge attribute for all vertices\n" "@param attrname: the name of the attribute\n" "@param values: the new attribute values in a list\n" }, {"select", (PyCFunction)igraphmodule_EdgeSeq_select, METH_VARARGS, "select(*args, **kwds)\n--\n\n" "For internal use only.\n" }, {NULL} }; /** * \ingroup python_interface_edgeseq * This is the collection of functions necessary to implement the * edge sequence as a real sequence (e.g. allowing to reference * edges by indices) */ static PySequenceMethods igraphmodule_EdgeSeq_as_sequence = { (lenfunc)igraphmodule_EdgeSeq_sq_length, 0, /* sq_concat */ 0, /* sq_repeat */ (ssizeargfunc)igraphmodule_EdgeSeq_sq_item, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ 0, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; /** * \ingroup python_interface_edgeseq * This is the collection of functions necessary to implement the * edge sequence as a mapping (which maps attribute names to values) */ static PyMappingMethods igraphmodule_EdgeSeq_as_mapping = { /* returns the number of edge attributes */ (lenfunc) 0, /* returns the values of an attribute by name */ (binaryfunc) igraphmodule_EdgeSeq_get_attribute_values_mapping, /* sets the values of an attribute by name */ (objobjargproc) igraphmodule_EdgeSeq_set_attribute_values_mapping, }; /** * \ingroup python_interface_edgeseq * Returns the graph where the edge sequence belongs */ PyObject* igraphmodule_EdgeSeq_get_graph(igraphmodule_EdgeSeqObject* self, void* closure) { Py_INCREF(self->gref); return (PyObject*)self->gref; } /** * \ingroup python_interface_edgeseq * Returns the indices of the edges in this edge sequence */ PyObject* igraphmodule_EdgeSeq_get_indices(igraphmodule_EdgeSeqObject* self, void* closure) { igraphmodule_GraphObject *gr = self->gref; igraph_vector_t es; PyObject *result; if (igraph_vector_init(&es, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_as_vector(&gr->g, self->es, &es)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&es); return 0; } result = igraphmodule_vector_t_to_PyList(&es, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&es); return result; } /** * \ingroup python_interface_edgeseq * Getter/setter table for the \c igraph.EdgeSeq object */ PyGetSetDef igraphmodule_EdgeSeq_getseters[] = { {"graph", (getter)igraphmodule_EdgeSeq_get_graph, NULL, "The graph the edge sequence belongs to", NULL}, {"indices", (getter)igraphmodule_EdgeSeq_get_indices, NULL, "The edge indices in this edge sequence", NULL, }, {NULL} }; /** \ingroup python_interface_edgeseq * Python type object referencing the methods Python calls when it performs various operations on * an edge sequence of a graph */ PyTypeObject igraphmodule_EdgeSeqType = { PyVarObject_HEAD_INIT(0, 0) "igraph._igraph.EdgeSeq", /* tp_name */ sizeof(igraphmodule_EdgeSeqObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)igraphmodule_EdgeSeq_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare (2.x) / tp_reserved (3.x) */ 0, /* tp_repr */ 0, /* tp_as_number */ &igraphmodule_EdgeSeq_as_sequence, /* tp_as_sequence */ &igraphmodule_EdgeSeq_as_mapping, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ "Low-level representation of an edge sequence.\n\n" /* tp_doc */ "Don't use it directly, use L{igraph.EdgeSeq} instead.\n\n" "@deffield ref: Reference", 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(igraphmodule_EdgeSeqObject, weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ igraphmodule_EdgeSeq_methods, /* tp_methods */ 0, /* tp_members */ igraphmodule_EdgeSeq_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) igraphmodule_EdgeSeq_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) igraphmodule_EdgeSeq_new, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weakreflist */ }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/edgeseqobject.h0000644000175100001710000000363700000000000020771 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_EDGESEQOBJECT_H #define PYTHON_EDGESEQOBJECT_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_edgeseq * \brief A structure representing the edge sequence of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_es_t es; PyObject* weakreflist; } igraphmodule_EdgeSeqObject; PyObject* igraphmodule_EdgeSeq_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds); igraphmodule_EdgeSeqObject* igraphmodule_EdgeSeq_copy( igraphmodule_EdgeSeqObject *o); int igraphmodule_EdgeSeq_init(igraphmodule_EdgeSeqObject *self, PyObject *args, PyObject *kwds); void igraphmodule_EdgeSeq_dealloc(igraphmodule_EdgeSeqObject* self); int igraphmodule_EdgeSeq_sq_length(igraphmodule_EdgeSeqObject *self); PyObject* igraphmodule_EdgeSeq_find(igraphmodule_EdgeSeqObject *self, PyObject *args); PyObject* igraphmodule_EdgeSeq_select(igraphmodule_EdgeSeqObject *self, PyObject *args); PyObject* igraphmodule_EdgeSeq_get_graph(igraphmodule_EdgeSeqObject *self, void* closure); extern PyTypeObject igraphmodule_EdgeSeqType; #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/error.c0000644000175100001710000000614200000000000017303 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "error.h" #include /** \ingroup python_interface_errors * \brief Exception type to be returned when an internal \c igraph error occurs. */ PyObject* igraphmodule_InternalError; /** * \ingroup python_interface_errors * \brief Generic error handler for internal \c igraph errors. * * Since now \c igraph supports error handler functions, a special * function called \c igraphmodule_igraph_error_hook is responsible * for providing a meaningful error message. If it fails (or it isn't * even called), this function will provide a default error message. * * \return Always returns \c NULL, and all callers are advised to pass this * \c NULL value to their callers until it is propagated to the Python * interpreter. */ PyObject* igraphmodule_handle_igraph_error() { if (!PyErr_Occurred()) { PyErr_SetString( igraphmodule_InternalError, "Internal igraph error. Please contact the author!" ); } return NULL; } /** * \ingroup python_interface_errors * \brief Warning hook for \c igraph */ void igraphmodule_igraph_warning_hook(const char *reason, const char *file, int line, int igraph_errno) { char buf[4096]; snprintf(buf, sizeof(buf), "%s at %s:%i", reason, file, line); PyErr_Warn(PyExc_RuntimeWarning, buf); } /** * \ingroup python_interface_errors * \brief Error hook for \c igraph */ void igraphmodule_igraph_error_hook(const char *reason, const char *file, int line, int igraph_errno) { char buf[4096]; char* punctuation = ""; PyObject *exc = igraphmodule_InternalError; if (igraph_errno == IGRAPH_UNIMPLEMENTED) exc = PyExc_NotImplementedError; if (igraph_errno == IGRAPH_ENOMEM) exc = PyExc_MemoryError; /* add a full stop at the end of the error message for nicer formatting */ if (reason && strlen(reason) > 1) { char last_char = reason[strlen(reason) - 1]; if (last_char != '.' && last_char != '?' && last_char != '!') { punctuation = "."; } } snprintf( buf, sizeof(buf), "Error at %s:%i: %s%s -- %s", file, line, reason, punctuation, igraph_strerror(igraph_errno) ); IGRAPH_FINALLY_FREE(); /* make sure we are not masking already thrown exceptions */ if (!PyErr_Occurred()) PyErr_SetString(exc, buf); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/error.h0000644000175100001710000000307200000000000017307 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_ERROR_H #define PYTHON_ERROR_H #include "preamble.h" #include /** \defgroup python_interface_errors Error handling * \ingroup python_interface */ PyObject* igraphmodule_handle_igraph_error(void); void igraphmodule_igraph_warning_hook(const char *reason, const char *file, int line, int igraph_errno); void igraphmodule_igraph_error_hook(const char *reason, const char *file, int line, int igraph_errno); extern PyObject* igraphmodule_InternalError; #define IGRAPH_PYCHECK(a) do { \ int igraph_i_pyret=(a); \ if (IGRAPH_UNLIKELY(igraph_i_pyret != 0)) {\ igraphmodule_handle_igraph_error(); \ IGRAPH_FINALLY_FREE(); \ return 0; \ } } while (0) #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/filehandle.c0000644000175100001710000001465700000000000020257 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2010-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "filehandle.h" #include "pyhelpers.h" #ifndef PYPY_VERSION static int igraphmodule_i_filehandle_init_cpython_3(igraphmodule_filehandle_t* handle, PyObject* object, char* mode) { int fp; if (object == 0 || PyLong_Check(object)) { PyErr_SetString(PyExc_TypeError, "string or file-like object expected"); return 1; } handle->fp = 0; handle->need_close = 0; handle->object = 0; if (PyBaseString_Check(object)) { /* We have received a string; we need to open the file denoted by this * string now and mark that we opened the file ourselves (so we need * to close it when igraphmodule_filehandle_destroy is invoked). */ handle->object = igraphmodule_PyFile_FromObject(object, mode); if (handle->object == 0) { /* Could not open the file; just return an error code because an * exception was raised already */ return 1; } /* Remember that we need to close the file ourselves */ handle->need_close = 1; } else { /* This is probably a file-like object; store a reference for it and * we will handle it later */ handle->object = object; Py_INCREF(handle->object); } /* At this stage, handle->object is something we can handle. * We have to call PyObject_AsFileDescriptor instead * and then fdopen() it to get the corresponding FILE* object. */ fp = PyObject_AsFileDescriptor(handle->object); if (fp == -1) { igraphmodule_filehandle_destroy(handle); /* This already called Py_DECREF(handle->object), no need to call it */ return 1; } handle->fp = fdopen(fp, mode); if (handle->fp == 0) { igraphmodule_filehandle_destroy(handle); /* This already called Py_DECREF(handle->object), no need to call it */ PyErr_SetString(PyExc_RuntimeError, "fdopen() failed unexpectedly"); return 1; } return 0; } #else /* PYPY_VERSION */ static int igraphmodule_i_filehandle_init_pypy_3(igraphmodule_filehandle_t* handle, PyObject* object, char* mode) { int fp; if (object == 0 || PyLong_Check(object)) { PyErr_SetString(PyExc_TypeError, "string or file-like object expected"); return 1; } handle->fp = 0; handle->need_close = 0; handle->object = 0; if (PyBaseString_Check(object)) { /* We have received a string; we need to open the file denoted by this * string now and mark that we opened the file ourselves (so we need * to close it when igraphmodule_filehandle_destroy is invoked). */ handle->object = igraphmodule_PyFile_FromObject(object, mode); if (handle->object == 0) { /* Could not open the file; just return an error code because an * exception was raised already */ return 1; } /* Remember that we need to close the file ourselves */ handle->need_close = 1; } else { /* This is probably a file-like object; store a reference for it and * we will handle it later */ handle->object = object; Py_INCREF(handle->object); } /* At this stage, handle->object is something we can handle. * We have to call PyObject_AsFileDescriptor instead * and then fdopen() it to get the corresponding FILE* object. */ fp = PyObject_AsFileDescriptor(handle->object); if (fp == -1) { igraphmodule_filehandle_destroy(handle); /* This already called Py_DECREF(handle->object), no need to call it */ return 1; } handle->fp = fdopen(fp, mode); if (handle->fp == 0) { igraphmodule_filehandle_destroy(handle); /* This already called Py_DECREF(handle->object), no need to call it */ PyErr_SetString(PyExc_RuntimeError, "fdopen() failed unexpectedly"); return 1; } return 0; } #endif /** * \ingroup python_interface_filehandle * \brief Constructs a new file handle object from a Python object. * * \return 0 if everything was OK, 1 otherwise. An appropriate Python * exception is raised in this case. */ int igraphmodule_filehandle_init(igraphmodule_filehandle_t* handle, PyObject* object, char* mode) { #ifdef PYPY_VERSION return igraphmodule_i_filehandle_init_pypy_3(handle, object, mode); #else return igraphmodule_i_filehandle_init_cpython_3(handle, object, mode); #endif } /** * \ingroup python_interface_filehandle * \brief Destroys the file handle object. */ void igraphmodule_filehandle_destroy(igraphmodule_filehandle_t* handle) { PyObject *exc_type = 0, *exc_value = 0, *exc_traceback = 0; if (handle->fp != 0) { fflush(handle->fp); if (handle->need_close && !handle->object) { fclose(handle->fp); } handle->fp = 0; } if (handle->object != 0) { /* igraphmodule_PyFile_Close might mess up the stored exception, so let's * store the current exception state and restore it */ PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); if (handle->need_close) { if (igraphmodule_PyFile_Close(handle->object)) { PyErr_WriteUnraisable(Py_None); } } Py_DECREF(handle->object); PyErr_Restore(exc_type, exc_value, exc_traceback); exc_type = exc_value = exc_traceback = 0; handle->object = 0; } handle->need_close = 0; } /** * \ingroup python_interface_filehandle * \brief Returns the file encapsulated by the given \c igraphmodule_filehandle_t. */ FILE* igraphmodule_filehandle_get(const igraphmodule_filehandle_t* handle) { return handle->fp; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/filehandle.h0000644000175100001710000000277700000000000020264 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2010-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_FILEHANDLE_H #define PYTHON_FILEHANDLE_H #include "preamble.h" #include /** * \defgroup python_interface_filehandle File handle object */ /** * \ingroup python_interface_filehandle * \brief A structure encapsulating a Python object and a \c FILE* pointer * created out of it. */ typedef struct { PyObject* object; FILE* fp; unsigned short int need_close; } igraphmodule_filehandle_t; int igraphmodule_filehandle_init(igraphmodule_filehandle_t* handle, PyObject* object, char* mode); FILE* igraphmodule_filehandle_get(const igraphmodule_filehandle_t* handle); void igraphmodule_filehandle_destroy(igraphmodule_filehandle_t* handle); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/force_cpp_linker.cpp0000644000175100001710000000026000000000000022011 0ustar00runnerdocker00000000000000/* The purpose of this file is to make Python use the C++ linker instead of * the standard C linker because igraph's core static library needs the C++ * standard library */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/graphobject.c0000644000175100001710000230026300000000000020445 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "arpackobject.h" #include "bfsiter.h" #include "dfsiter.h" #include "common.h" #include "convert.h" #include "edgeseqobject.h" #include "error.h" #include "filehandle.h" #include "graphobject.h" #include "indexing.h" #include "memory.h" #include "pyhelpers.h" #include "vertexseqobject.h" #include PyTypeObject igraphmodule_GraphType; #define CREATE_GRAPH_FROM_TYPE(py_graph, c_graph, py_type) { \ py_graph = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( \ py_type, &c_graph \ ); \ } #define CREATE_GRAPH(py_graph, c_graph) { \ py_graph = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( \ Py_TYPE(self), &c_graph \ ); \ } /********************************************************************** * Basic implementation of igraph.Graph * **********************************************************************/ /** \defgroup python_interface_graph Graph object * \ingroup python_interface */ /** * \ingroup python_interface_internal * \brief Initializes the internal structures in an \c igraph.Graph object's * C representation. * * This function must be called whenever we create a new Graph object with * \c tp_alloc */ void igraphmodule_Graph_init_internal(igraphmodule_GraphObject * self) { if (!self) return; self->destructor = NULL; self->weakreflist = NULL; } /** * \ingroup python_interface_graph * \brief Creates a new igraph object in Python * * This function is called whenever a new \c igraph.Graph object is created in * Python. An optional \c n parameter can be passed from Python, * representing the number of vertices in the graph. If it is omitted, * the default value is 0. * * Example call from Python: \verbatim g = igraph.Graph(5); \endverbatim * * In fact, the parameters are processed by \c igraphmodule_Graph_init * * \return the new \c igraph.Graph object or NULL if an error occurred. * * \sa igraphmodule_Graph_init * \sa igraph_empty */ PyObject *igraphmodule_Graph_new(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; self = (igraphmodule_GraphObject *) type->tp_alloc(type, 0); RC_ALLOC("Graph", self); igraphmodule_Graph_init_internal(self); return (PyObject *) self; } /** * \ingroup python_interface_graph * \brief Clears the graph object's subobject (before deallocation) */ int igraphmodule_Graph_clear(igraphmodule_GraphObject * self) { PyObject *tmp; PyObject_GC_UnTrack(self); tmp = self->destructor; self->destructor = NULL; Py_XDECREF(tmp); return 0; } /** * \ingroup python_interface_graph * \brief Support for cyclic garbage collection in Python * * This is necessary because the \c igraph.Graph object contains several * other \c PyObject pointers and they might point back to itself. */ int igraphmodule_Graph_traverse(igraphmodule_GraphObject * self, visitproc visit, void *arg) { int vret, i; RC_TRAVERSE("Graph", self); if (self->destructor) { vret = visit(self->destructor, arg); if (vret != 0) return vret; } if (self->g.attr) { for (i = 0; i < 3; i++) { vret = visit(((PyObject **) (self->g.attr))[i], arg); if (vret != 0) return vret; } } return 0; } /** * \ingroup python_interface_graph * \brief Deallocates a Python representation of a given igraph object */ void igraphmodule_Graph_dealloc(igraphmodule_GraphObject * self) { PyObject *r; /* Clear weak references */ if (self->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *) self); igraph_destroy(&self->g); if (self->destructor != NULL && PyCallable_Check(self->destructor)) { r = PyObject_CallObject(self->destructor, NULL); if (r) { Py_DECREF(r); } } igraphmodule_Graph_clear(self); RC_DEALLOC("Graph", self); Py_TYPE(self)->tp_free((PyObject*)self); } /** * \ingroup python_interface_graph * \brief Initializes a new \c igraph object in Python * * This function is called whenever a new \c igraph.Graph object is initialized in * Python (note that initializing is not equal to creating: an object might * be created but not initialized when it is being recovered from a serialized * state). * * Throws \c AssertionError in Python if \c vcount is less than or equal to zero. * \return the new \c igraph.Graph object or NULL if an error occurred. * * \sa igraphmodule_Graph_new * \sa igraph_empty * \sa igraph_create */ int igraphmodule_Graph_init(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "n", "edges", "directed", "__ptr", NULL }; long int n = 0; PyObject *edges = NULL, *dir = Py_False, *ptr_o = 0; void* ptr = 0; igraph_vector_t edges_vector; igraph_bool_t edges_vector_owned = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lOOO!", kwlist, &n, &edges, &dir, &PyCapsule_Type, &ptr_o)) return -1; /* Safety check: if ptr is not null, it means that we have been explicitly * given a pointer to an igraph_t for which we must take ownership. * This means that n should be zero and edges should not be specified */ if (ptr_o && (n != 0 || edges != NULL)) { PyErr_SetString(PyExc_ValueError, "neither n nor edges should be given " "in the call to Graph.__init__() when the graph is " "pre-initialized with a C pointer"); return -1; } if (ptr_o) { /* We must take ownership of an igraph graph */ ptr = PyCapsule_GetPointer(ptr_o, "__igraph_t"); if (ptr == 0) { PyErr_SetString(PyExc_ValueError, "pointer should not be null"); } else { self->g = *(igraph_t*)ptr; } } else if (edges) { /* Caller specified an edge list, so we use igraph_create */ /* We have to convert the Python list to a igraph_vector_t */ if (igraphmodule_PyObject_to_edgelist(edges, &edges_vector, 0, &edges_vector_owned)) { igraphmodule_handle_igraph_error(); return -1; } if (igraph_create (&self->g, &edges_vector, (igraph_integer_t) n, PyObject_IsTrue(dir))) { igraphmodule_handle_igraph_error(); if (edges_vector_owned) { igraph_vector_destroy(&edges_vector); } return -1; } if (edges_vector_owned) { igraph_vector_destroy(&edges_vector); } } else { /* No edge list was specified, and no previously initialized graph object * was fed into our object, so let's use igraph_empty */ if (igraph_empty(&self->g, (igraph_integer_t) n, PyObject_IsTrue(dir))) { igraphmodule_handle_igraph_error(); return -1; } } return 0; } /** \ingroup python_interface_graph * \brief Creates an \c igraph.Graph subtype from an existing \c igraph_t * * The newly created instance (which will be a subtype of )\c igraph.Graph) * will take ownership of the given \c igraph_t. This function is not * accessible from Python, however it is in the header file for other C API * functions to use. */ PyObject* igraphmodule_Graph_subclass_from_igraph_t( PyTypeObject* type, igraph_t *graph ) { PyObject* result; PyObject* capsule; PyObject* args; PyObject* kwds; if (!PyType_IsSubtype(type, &igraphmodule_GraphType)) { PyErr_SetString(PyExc_TypeError, "igraph._igraph.GraphBase expected"); return 0; } capsule = PyCapsule_New(graph, "__igraph_t", 0); if (capsule == 0) { return 0; } args = PyTuple_New(0); if (args == 0) { Py_DECREF(capsule); return 0; } kwds = PyDict_New(); if (kwds == 0) { Py_DECREF(args); Py_DECREF(capsule); return 0; } if (PyDict_SetItemString(kwds, "__ptr", capsule)) { Py_DECREF(kwds); Py_DECREF(args); Py_DECREF(capsule); return 0; } /* kwds now holds a reference to the capsule so we can release it */ Py_DECREF(capsule); /* Call the type */ result = PyObject_Call((PyObject*) type, args, kwds); /* Release args and kwds */ Py_DECREF(args); Py_DECREF(kwds); return result; } /** \ingroup python_interface_graph * \brief Creates an \c igraph.Graph object from an existing \c igraph_t * * The newly created \c igraph.Graph object will take ownership of the * given \c igraph_t. This function is not accessible from Python the * normal way, but it is exposed via the C API of the Python module. * See \c api.h for more details. */ PyObject* igraphmodule_Graph_from_igraph_t(igraph_t *graph) { return igraphmodule_Graph_subclass_from_igraph_t( &igraphmodule_GraphType, graph ); } /** \ingroup python_interface_graph * \brief Formats an \c igraph.Graph object in a human-readable format. * * This function is rather simple now, it returns the number of vertices * and edges in a string. * * \return the formatted textual representation as a \c PyObject */ PyObject *igraphmodule_Graph_str(igraphmodule_GraphObject * self) { if (igraph_is_directed(&self->g)) return PyUnicode_FromFormat("Directed graph (|V| = %ld, |E| = %ld)", (long)igraph_vcount(&self->g), (long)igraph_ecount(&self->g)); else return PyUnicode_FromFormat("Undirected graph (|V| = %ld, |E| = %ld)", (long)igraph_vcount(&self->g), (long)igraph_ecount(&self->g)); } /** \ingroup python_interface_copy * \brief Creates a copy of the graph * \return the copy of the graph */ PyObject *igraphmodule_Graph_copy(igraphmodule_GraphObject * self) { igraphmodule_GraphObject *result; igraph_t g; if (igraph_copy(&g, &self->g)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH(result, g); return (PyObject *) result; } /********************************************************************** * The most basic igraph interface * **********************************************************************/ /** \ingroup python_interface_graph * \brief Returns the number of vertices in an \c igraph.Graph object. * \return the number of vertices as a \c PyObject * \sa igraph_vcount */ PyObject *igraphmodule_Graph_vcount(igraphmodule_GraphObject * self) { return PyLong_FromLong(igraph_vcount(&self->g)); } /** \ingroup python_interface_graph * \brief Returns the number of edges in an \c igraph.Graph object. * \return the number of edges as a \c PyObject * \sa igraph_ecount */ PyObject *igraphmodule_Graph_ecount(igraphmodule_GraphObject * self) { return PyLong_FromLong(igraph_ecount(&self->g)); } /** \ingroup python_interface_graph * \brief Checks whether an \c igraph.Graph object is a DAG. * \return \c True if the graph is directed, \c False otherwise. * \sa igraph_is_dag */ PyObject *igraphmodule_Graph_is_dag(igraphmodule_GraphObject * self) { igraph_bool_t res; if (igraph_is_dag(&self->g, &res)) { igraphmodule_handle_igraph_error(); return NULL; } if (res) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Checks whether an \c igraph.Graph object is directed. * \return \c True if the graph is directed, \c False otherwise. * \sa igraph_is_directed */ PyObject *igraphmodule_Graph_is_directed(igraphmodule_GraphObject * self) { if (igraph_is_directed(&self->g)) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** * \ingroup python_interface_graph * \brief Checks whether a matching is valid in the context of an \c igraph.Graph * object. * \sa igraph_is_matching */ PyObject *igraphmodule_Graph_is_matching(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds) { static char* kwlist[] = { "matching", "types", NULL }; PyObject *matching_o, *types_o = Py_None; igraph_vector_long_t* matching = 0; igraph_vector_bool_t* types = 0; igraph_bool_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &matching_o, &types_o)) return NULL; if (igraphmodule_attrib_to_vector_long_t(matching_o, self, &matching, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) { if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } return NULL; } if (igraph_is_matching(&self->g, types, matching, &result)) { if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** * \ingroup python_interface_graph * \brief Checks whether a matching is valid and maximal in the context of an * \c igraph.Graph object. * \sa igraph_is_maximal_matching */ PyObject *igraphmodule_Graph_is_maximal_matching(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds) { static char* kwlist[] = { "matching", "types", NULL }; PyObject *matching_o, *types_o = Py_None; igraph_vector_long_t* matching = 0; igraph_vector_bool_t* types = 0; igraph_bool_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &matching_o, &types_o)) return NULL; if (igraphmodule_attrib_to_vector_long_t(matching_o, self, &matching, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) { if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } return NULL; } if (igraph_is_maximal_matching(&self->g, types, matching, &result)) { if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } if (matching != 0) { igraph_vector_long_destroy(matching); free(matching); } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Checks whether an \c igraph.Graph object is simple. * \return \c True if the graph is simple, \c False otherwise. * \sa igraph_is_simple */ PyObject *igraphmodule_Graph_is_simple(igraphmodule_GraphObject *self) { igraph_bool_t res; if (igraph_is_simple(&self->g, &res)) { igraphmodule_handle_igraph_error(); return NULL; } if (res) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Determines whether a graph is a (directed or undirected) tree * \sa igraph_is_tree */ PyObject *igraphmodule_Graph_is_tree(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", NULL }; PyObject *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_OUT; igraph_bool_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) { return NULL; } if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) { return NULL; } if (igraph_is_tree(&self->g, &result, /* root = */ 0, mode)) { igraphmodule_handle_igraph_error(); return NULL; } if (result) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } /** \ingroup python_interface_graph * \brief Adds vertices to an \c igraph.Graph * \return the extended \c igraph.Graph object * \sa igraph_add_vertices */ PyObject *igraphmodule_Graph_add_vertices(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { long n; if (!PyArg_ParseTuple(args, "l", &n)) return NULL; if (igraph_add_vertices(&self->g, (igraph_integer_t) n, 0)) { igraphmodule_handle_igraph_error(); return NULL; } Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Removes vertices from an \c igraph.Graph * \return the modified \c igraph.Graph object * * \todo Need more error checking on vertex IDs. (igraph fails when an * invalid vertex ID is given) * \sa igraph_delete_vertices */ PyObject *igraphmodule_Graph_delete_vertices(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = 0; igraph_vs_t vs; if (!PyArg_ParseTuple(args, "|O", &list)) return NULL; /* no arguments means delete all. */ /*Py_None also means all for now, but it is deprecated */ if (list == Py_None) { PyErr_Warn(PyExc_DeprecationWarning, "Graph.delete_vertices(None) is " "deprecated since igraph 0.8.3, please use " "Graph.delete_vertices() instead"); } /* this already converts no arguments and Py_None to all vertices */ if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, 0, 0)) return NULL; if (igraph_delete_vertices(&self->g, vs)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); return NULL; } igraph_vs_destroy(&vs); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Adds edges to an \c igraph.Graph * \return the extended \c igraph.Graph object * * \todo Need more error checking on vertex IDs. (igraph fails when an * invalid vertex ID is given) * \sa igraph_add_edges */ PyObject *igraphmodule_Graph_add_edges(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list; igraph_vector_t v; igraph_bool_t v_owned = 0; if (!PyArg_ParseTuple(args, "O", &list)) return NULL; if (igraphmodule_PyObject_to_edgelist(list, &v, &self->g, &v_owned)) return NULL; /* do the hard work :) */ if (igraph_add_edges(&self->g, &v, 0)) { igraphmodule_handle_igraph_error(); if (v_owned) { igraph_vector_destroy(&v); } return NULL; } if (v_owned) { igraph_vector_destroy(&v); } Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Deletes edges from an \c igraph.Graph * \return the extended \c igraph.Graph object * * \todo Need more error checking on vertex IDs. (igraph fails when an * invalid vertex ID is given) * \sa igraph_delete_edges */ PyObject *igraphmodule_Graph_delete_edges(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = 0; igraph_es_t es; static char *kwlist[] = { "edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; /* no arguments means delete all. */ /*Py_None also means all for now, but it is deprecated */ if (list == Py_None) { PyErr_Warn(PyExc_DeprecationWarning, "Graph.delete_vertices(None) is " "deprecated since igraph 0.8.3, please use " "Graph.delete_vertices() instead"); } /* this already converts no arguments and Py_None to all vertices */ if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, 0)) { /* something bad happened during conversion, return immediately */ return NULL; } if (igraph_delete_edges(&self->g, es)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); return NULL; } igraph_es_destroy(&es); Py_RETURN_NONE; } /********************************************************************** * Structural properties * **********************************************************************/ /** \ingroup python_interface_graph * \brief The degree of some vertices in an \c igraph.Graph * \return the degree list as a Python object * \sa igraph_degree */ PyObject *igraphmodule_Graph_degree(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = Py_None; PyObject *loops = Py_True; PyObject *dtype_o = Py_None; PyObject *dmode_o = Py_None; igraph_neimode_t dmode = IGRAPH_ALL; igraph_vector_t result; igraph_vs_t vs; igraph_bool_t return_single = 0; static char *kwlist[] = { "vertices", "mode", "loops", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &list, &dmode_o, &loops, &dtype_o)) return NULL; if (dmode_o == Py_None && dtype_o != Py_None) { dmode_o = dtype_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) { return NULL; } if (igraph_vector_init(&result, 0)) { igraph_vs_destroy(&vs); return NULL; } if (igraph_degree(&self->g, &result, vs, dmode, PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); else list = PyLong_FromLong((long int)VECTOR(result)[0]); igraph_vector_destroy(&result); igraph_vs_destroy(&vs); return list; } /** * \ingroup python_interface_graph * \brief Structural diversity index of some vertices in an \c igraph.Graph * \sa igraph_diversity */ PyObject *igraphmodule_Graph_diversity(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = Py_None; PyObject *weights_o = Py_None; igraph_vector_t result, *weights = 0; igraph_vs_t vs; igraph_bool_t return_single = 0; igraph_integer_t no_of_nodes; static char *kwlist[] = { "vertices", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &list, &weights_o)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&result, 0)) { igraph_vs_destroy(&vs); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } if (weights == 0) { /* Handle this case here because igraph_diversity bails out when no weights * are given. */ if (igraph_vs_size(&self->g, &vs, &no_of_nodes)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } if (igraph_vector_resize(&result, no_of_nodes)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } igraph_vector_fill(&result, 1.0); } else { if (igraph_diversity(&self->g, weights, &result, vs)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); igraph_vector_destroy(&result); igraph_vector_destroy(weights); free(weights); return NULL; } igraph_vector_destroy(weights); free(weights); } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(result)[0]); igraph_vector_destroy(&result); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief The strength (weighted degree) of some vertices in an \c igraph.Graph * \return the strength list as a Python object * \sa igraph_strength */ PyObject *igraphmodule_Graph_strength(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = Py_None; PyObject *loops = Py_True; PyObject *dtype_o = Py_None; PyObject *dmode_o = Py_None; PyObject *weights_o = Py_None; igraph_neimode_t dmode = IGRAPH_ALL; igraph_vector_t result, *weights = 0; igraph_vs_t vs; igraph_bool_t return_single = 0; static char *kwlist[] = { "vertices", "mode", "loops", "weights", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOO", kwlist, &list, &dmode_o, &loops, &weights_o, &dtype_o)) return NULL; if (dmode_o == Py_None && dtype_o != Py_None) { dmode_o = dtype_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&result, 0)) { igraph_vs_destroy(&vs); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } if (igraph_strength(&self->g, &result, vs, dmode, PyObject_IsTrue(loops), weights)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); igraph_vector_destroy(&result); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(result)[0]); igraph_vector_destroy(&result); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Calculates the graph density * \return the density * \sa igraph_density */ PyObject *igraphmodule_Graph_density(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "loops", NULL }; igraph_real_t result; PyObject *loops = Py_False; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &loops)) return NULL; if (igraph_density(&self->g, &result, PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(result); } /** \ingroup python_interface_graph * \brief The maximum degree of some vertices in an \c igraph.Graph * \return the maxium degree as a Python object * \sa igraph_maxdegree */ PyObject *igraphmodule_Graph_maxdegree(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list = Py_None; igraph_neimode_t dmode = IGRAPH_ALL; PyObject *dtype_o = Py_None; PyObject *dmode_o = Py_None; PyObject *loops = Py_False; igraph_integer_t result; igraph_vs_t vs; igraph_bool_t return_single = 0; static char *kwlist[] = { "vertices", "mode", "loops", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &list, &dmode_o, &loops, &dtype_o)) return NULL; if (dmode_o == Py_None && dtype_o != Py_None) { dmode_o = dtype_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_maxdegree(&self->g, &result, vs, dmode, PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); return NULL; } igraph_vs_destroy(&vs); return PyLong_FromLong((long)result); } /** \ingroup python_interface_graph * \brief Checks whether an edge is a loop edge * \return a boolean or a list of booleans * \sa igraph_is_loop */ PyObject *igraphmodule_Graph_is_loop(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *list = Py_None; igraph_vector_bool_t result; igraph_es_t es; igraph_bool_t return_single = 0; static char *kwlist[] = { "edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, &return_single)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_bool_init(&result, 0)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); return NULL; } if (igraph_is_loop(&self->g, &result, es)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); igraph_vector_bool_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_bool_t_to_PyList(&result); else { list = (VECTOR(result)[0]) ? Py_True : Py_False; Py_INCREF(list); } igraph_vector_bool_destroy(&result); igraph_es_destroy(&es); return list; } /** \ingroup python_interface_graph * \brief Checks whether an edge is a multiple edge * \return a boolean or a list of booleans * \sa igraph_is_multiple */ PyObject *igraphmodule_Graph_is_multiple(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *list = Py_None; igraph_vector_bool_t result; igraph_es_t es; igraph_bool_t return_single = 0; static char *kwlist[] = { "edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, &return_single)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_bool_init(&result, 0)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); return NULL; } if (igraph_is_multiple(&self->g, &result, es)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); igraph_vector_bool_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_bool_t_to_PyList(&result); else { list = (VECTOR(result)[0]) ? Py_True : Py_False; Py_INCREF(list); } igraph_vector_bool_destroy(&result); igraph_es_destroy(&es); return list; } /** \ingroup python_interface_graph * \brief Checks whether an edge is mutual * \return a boolean or a list of booleans * \sa igraph_is_mutual */ PyObject *igraphmodule_Graph_is_mutual(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *list = Py_None; igraph_vector_bool_t result; igraph_es_t es; igraph_bool_t return_single = 0; static char *kwlist[] = { "edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, &return_single)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_bool_init(&result, 0)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); return NULL; } if (igraph_is_mutual(&self->g, &result, es)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); igraph_vector_bool_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_bool_t_to_PyList(&result); else { list = (VECTOR(result)[0]) ? Py_True : Py_False; Py_INCREF(list); } igraph_vector_bool_destroy(&result); igraph_es_destroy(&es); return list; } /** \ingroup python_interface_graph * \brief Checks whether an \c igraph.Graph object has multiple edges. * \return \c True if the graph has multiple edges, \c False otherwise. * \sa igraph_has_multiple */ PyObject *igraphmodule_Graph_has_multiple(igraphmodule_GraphObject *self) { igraph_bool_t res; if (igraph_has_multiple(&self->g, &res)) { igraphmodule_handle_igraph_error(); return NULL; } if (res) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Checks the multiplicity of the edges * \return the edge multiplicities as a Python list * \sa igraph_count_multiple */ PyObject *igraphmodule_Graph_count_multiple(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *list = Py_None; igraph_vector_t result; igraph_es_t es; igraph_bool_t return_single = 0; static char *kwlist[] = { "edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, &return_single)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&result, 0)) { igraph_es_destroy(&es); return NULL; } if (igraph_count_multiple(&self->g, &result, es)) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); igraph_vector_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); else list = PyLong_FromLong((long int)VECTOR(result)[0]); igraph_vector_destroy(&result); igraph_es_destroy(&es); return list; } /** \ingroup python_interface_graph * \brief The neighbors of a given vertex in an \c igraph.Graph * This method accepts a single vertex ID as a parameter, and returns the * neighbors of the given vertex in the form of an integer list. A * second argument may be passed as well, meaning the type of neighbors to * be returned (\c OUT for successors, \c IN for predecessors or \c ALL * for both of them). This argument is ignored for undirected graphs. * * \return the neighbor list as a Python list object * \sa igraph_neighbors */ PyObject *igraphmodule_Graph_neighbors(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list, *dtype_o=Py_None, *dmode_o=Py_None, *index_o; igraph_neimode_t dmode = IGRAPH_ALL; igraph_integer_t idx; igraph_vector_t result; static char *kwlist[] = { "vertex", "mode", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist, &index_o, &dmode_o, &dtype_o)) return NULL; if (dmode_o == Py_None && dtype_o != Py_None) { dmode_o = dtype_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) return NULL; if (igraphmodule_PyObject_to_vid(index_o, &idx, &self->g)) return NULL; if (igraph_vector_init(&result, 1)) return igraphmodule_handle_igraph_error(); if (igraph_neighbors(&self->g, &result, idx, dmode)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief The incident edges of a given vertex in an \c igraph.Graph * This method accepts a single vertex ID as a parameter, and returns the * IDs of the incident edges of the given vertex in the form of an integer list. * A second argument may be passed as well, meaning the type of neighbors to * be returned (\c OUT for successors, \c IN for predecessors or \c ALL * for both of them). This argument is ignored for undirected graphs. * * \return the adjacency list as a Python list object * \sa igraph_incident */ PyObject *igraphmodule_Graph_incident(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list, *dmode_o = Py_None, *dtype_o = Py_None, *index_o; igraph_neimode_t dmode = IGRAPH_OUT; igraph_integer_t idx; igraph_vector_t result; static char *kwlist[] = { "vertex", "mode", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist, &index_o, &dmode_o, &dtype_o)) return NULL; if (dmode_o == Py_None && dtype_o != Py_None) { dmode_o = dtype_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) return NULL; if (igraphmodule_PyObject_to_vid(index_o, &idx, &self->g)) return NULL; igraph_vector_init(&result, 1); if (igraph_incident(&self->g, &result, idx, dmode)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief Calculates the graph reciprocity * \return the reciprocity * \sa igraph_reciprocity */ PyObject *igraphmodule_Graph_reciprocity(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "ignore_loops", "mode", NULL }; igraph_real_t result; igraph_reciprocity_t mode = IGRAPH_RECIPROCITY_DEFAULT; PyObject *ignore_loops = Py_True, *mode_o = Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &ignore_loops, &mode_o)) return NULL; if (igraphmodule_PyObject_to_reciprocity_t(mode_o, &mode)) return NULL; if (igraph_reciprocity(&self->g, &result, PyObject_IsTrue(ignore_loops), mode)) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(result); } /** \ingroup python_interface_graph * \brief The successors of a given vertex in an \c igraph.Graph * This method accepts a single vertex ID as a parameter, and returns the * successors of the given vertex in the form of an integer list. It * is equivalent to calling \c igraph.Graph.neighbors with \c type=OUT * * \return the successor list as a Python list object * \sa igraph_neighbors */ PyObject *igraphmodule_Graph_successors(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list, *index_o; igraph_integer_t idx; igraph_vector_t result; static char *kwlist[] = { "vertex", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &index_o)) return NULL; if (igraphmodule_PyObject_to_vid(index_o, &idx, &self->g)) return NULL; igraph_vector_init(&result, 1); if (igraph_neighbors(&self->g, &result, idx, IGRAPH_OUT)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief The predecessors of a given vertex in an \c igraph.Graph * This method accepts a single vertex ID as a parameter, and returns the * predecessors of the given vertex in the form of an integer list. It * is equivalent to calling \c igraph.Graph.neighbors with \c type=IN * * \return the predecessor list as a Python list object * \sa igraph_neighbors */ PyObject *igraphmodule_Graph_predecessors(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *list, *index_o; igraph_integer_t idx; igraph_vector_t result; static char *kwlist[] = { "vertex", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &index_o)) return NULL; if (igraphmodule_PyObject_to_vid(index_o, &idx, &self->g)) return NULL; igraph_vector_init(&result, 1); if (igraph_neighbors(&self->g, &result, idx, IGRAPH_IN)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief Decides whether a graph is connected. * \return Py_True if the graph is connected, Py_False otherwise * \sa igraph_is_connected */ PyObject *igraphmodule_Graph_is_connected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "mode", NULL }; PyObject *mode_o = Py_None; igraph_connectedness_t mode = IGRAPH_STRONG; igraph_bool_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_connectedness_t(mode_o, &mode)) return NULL; if (igraph_is_connected(&self->g, &res, mode)) { igraphmodule_handle_igraph_error(); return NULL; } if (res) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Decides whether there is an edge from a given vertex to an other one. * \return Py_True if the vertices are directly connected, Py_False otherwise * \sa igraph_are_connected */ PyObject *igraphmodule_Graph_are_connected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v1", "v2", NULL }; PyObject *v1, *v2; igraph_integer_t idx1, idx2; igraph_bool_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &v1, &v2)) return NULL; if (igraphmodule_PyObject_to_vid(v1, &idx1, &self->g)) return NULL; if (igraphmodule_PyObject_to_vid(v2, &idx2, &self->g)) return NULL; if (igraph_are_connected(&self->g, idx1, idx2, &res)) return igraphmodule_handle_igraph_error(); if (res) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Returns the ID of an arbitrary edge between the given two vertices * \sa igraph_get_eid */ PyObject *igraphmodule_Graph_get_eid(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v1", "v2", "directed", "error", NULL }; PyObject *v1, *v2; PyObject *directed = Py_True; PyObject *error = Py_True; igraph_integer_t idx1, idx2; igraph_integer_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, &v1, &v2, &directed, &error)) return NULL; if (igraphmodule_PyObject_to_vid(v1, &idx1, &self->g)) return NULL; if (igraphmodule_PyObject_to_vid(v2, &idx2, &self->g)) return NULL; if (igraph_get_eid(&self->g, &result, idx1, idx2, PyObject_IsTrue(directed), PyObject_IsTrue(error))) return igraphmodule_handle_igraph_error(); return PyLong_FromLong(result); } /** \ingroup python_interface_graph * \brief Returns the IDs of some edges between some vertices * \sa igraph_get_eids */ PyObject *igraphmodule_Graph_get_eids(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "pairs", "path", "directed", "error", NULL }; PyObject *pairs_o = Py_None, *path_o = Py_None; PyObject *directed = Py_True; PyObject *error = Py_True; PyObject *result = NULL; igraph_vector_t pairs, path, res; igraph_bool_t pairs_owned = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &pairs_o, &path_o, &directed, &error)) return NULL; if (igraph_vector_init(&res, 0)) return igraphmodule_handle_igraph_error(); if (pairs_o != Py_None) { if (igraphmodule_PyObject_to_edgelist(pairs_o, &pairs, &self->g, &pairs_owned)) { igraph_vector_destroy(&res); return NULL; } } if (path_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(path_o, &path, 1)) { igraph_vector_destroy(&res); if (pairs_owned) { igraph_vector_destroy(&pairs); } return NULL; } } if (igraph_get_eids(&self->g, &res, pairs_o == Py_None ? 0 : &pairs, path_o == Py_None ? 0 : &path, PyObject_IsTrue(directed), PyObject_IsTrue(error))) { if (pairs_owned) { igraph_vector_destroy(&pairs); } if (path_o != Py_None) { igraph_vector_destroy(&path); } igraph_vector_destroy(&res); return igraphmodule_handle_igraph_error(); } if (pairs_owned) { igraph_vector_destroy(&pairs); } if (path_o != Py_None) { igraph_vector_destroy(&path); } result = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return result; } /** \ingroup python_interface_graph * \brief Calculates the diameter of an \c igraph.Graph * This method accepts two optional parameters: the first one is * a boolean meaning whether to consider directed paths (and is * ignored for undirected graphs). The second one is only meaningful * in unconnected graphs: it is \c True if the longest geodesic * within a component should be returned and \c False if the number of * vertices should be returned. They both have a default value of \c False. * * \return the diameter as a Python integer * \sa igraph_diameter */ PyObject *igraphmodule_Graph_diameter(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *dir = Py_True, *vcount_if_unconnected = Py_True; PyObject *weights_o = Py_None; igraph_vector_t *weights = 0; igraph_real_t diameter; static char *kwlist[] = { "directed", "unconn", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &dir, &vcount_if_unconnected, &weights_o)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (weights) { if (igraph_diameter_dijkstra(&self->g, weights, &diameter, 0, 0, 0, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(weights); free(weights); return NULL; } igraph_vector_destroy(weights); free(weights); return PyFloat_FromDouble((double)diameter); } else { if (igraph_diameter(&self->g, &diameter, 0, 0, 0, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); return NULL; } /* The diameter is integer in this case, except if igraph_diameter() * returned NaN or infinity for some reason */ if (ceilf(diameter) == diameter && isfinite(diameter)) { return PyLong_FromLong((long)diameter); } else { return PyFloat_FromDouble((double)diameter); } } } /** \ingroup python_interface_graph * \brief Returns a path of the actual diameter of the graph * \sa igraph_diameter */ PyObject *igraphmodule_Graph_get_diameter(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *dir = Py_True, *vcount_if_unconnected = Py_True, *result; PyObject *weights_o = Py_None; igraph_vector_t *weights = 0; igraph_vector_t res; static char *kwlist[] = { "directed", "unconn", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &dir, &vcount_if_unconnected, &weights_o)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; igraph_vector_init(&res, 0); if (weights) { if (igraph_diameter_dijkstra(&self->g, weights, 0, 0, 0, &res, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(weights); free(weights); igraph_vector_destroy(&res); return NULL; } igraph_vector_destroy(weights); free(weights); } else { if (igraph_diameter(&self->g, 0, 0, 0, &res, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); return NULL; } } result = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return result; } /** \ingroup python_interface_graph * \brief Returns the farthest points and their distances in the graph * \sa igraph_distance */ PyObject *igraphmodule_Graph_farthest_points(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *dir = Py_True, *vcount_if_unconnected = Py_True; PyObject *weights_o = Py_None; igraph_vector_t *weights = 0; igraph_integer_t from, to; igraph_real_t len; static char *kwlist[] = { "directed", "unconn", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &dir, &vcount_if_unconnected, &weights_o)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (weights) { if (igraph_diameter_dijkstra(&self->g, weights, &len, &from, &to, 0, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(weights); free(weights); return NULL; } igraph_vector_destroy(weights); free(weights); if (from >= 0) { return Py_BuildValue("lld", (long)from, (long)to, (double)len); } else { return Py_BuildValue("OOd", Py_None, Py_None, (double)len); } } else { if (igraph_diameter(&self->g, &len, &from, &to, 0, PyObject_IsTrue(dir), PyObject_IsTrue(vcount_if_unconnected))) { igraphmodule_handle_igraph_error(); return NULL; } /* if len is finite and integer (which it typically is, unless it's * infinite), then return a Python int as the third value; otherwise * return a float */ if (ceilf(len) == len && isfinite(len)) { if (from >= 0) { return Py_BuildValue("lll", (long)from, (long)to, (long)len); } else { return Py_BuildValue("OOl", Py_None, Py_None, (long)len); } } else { if (from >= 0) { return Py_BuildValue("lld", (long)from, (long)to, (double)len); } else { return Py_BuildValue("OOd", Py_None, Py_None, (double)len); } } } } /** * \ingroup python_interface_graph * \brief Calculates the girth of an \c igraph.Graph */ PyObject *igraphmodule_Graph_girth(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *sc = Py_False; static char *kwlist[] = { "return_shortest_circle", NULL }; igraph_integer_t girth; igraph_vector_t vids; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &sc)) return NULL; igraph_vector_init(&vids, 0); if (igraph_girth(&self->g, &girth, &vids)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&vids); return NULL; } if (PyObject_IsTrue(sc)) { PyObject* o; o=igraphmodule_vector_t_to_PyList(&vids, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&vids); return o; } return PyLong_FromLong((long)girth); } /** * \ingroup python_interface_graph * \brief Calculates the convergence degree of the edges in a graph */ PyObject *igraphmodule_Graph_convergence_degree(igraphmodule_GraphObject *self) { igraph_vector_t result; PyObject *o; igraph_vector_init(&result, 0); if (igraph_convergence_degree(&self->g, &result, 0, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } o=igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&result); return o; } /** * \ingroup python_interface_graph * \brief Calculates the sizes of the convergence fields in a graph */ PyObject *igraphmodule_Graph_convergence_field_size(igraphmodule_GraphObject *self) { igraph_vector_t ins, outs; PyObject *o1, *o2; igraph_vector_init(&ins, 0); igraph_vector_init(&outs, 0); if (igraph_convergence_degree(&self->g, 0, &ins, &outs)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&ins); igraph_vector_destroy(&outs); return NULL; } o1=igraphmodule_vector_t_to_PyList(&ins, IGRAPHMODULE_TYPE_INT); o2=igraphmodule_vector_t_to_PyList(&outs, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&ins); igraph_vector_destroy(&outs); return Py_BuildValue("NN", o1, o2); } /** * \ingroup python_interface_graph * \brief Calculates the average nearest neighbor degree of the vertices * of a \c igraph.Graph */ PyObject *igraphmodule_Graph_knn(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "vids", "weights", NULL }; PyObject *vids_obj = Py_None, *weights_obj = Py_None; PyObject *knn_obj, *knnk_obj; igraph_vector_t *weights = 0; igraph_vector_t knn, knnk; igraph_vs_t vids; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &vids_obj, &weights_obj)) { return NULL; } if (igraph_vector_init(&knn, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&knnk, 0)) { igraph_vector_destroy(&knn); igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_PyObject_to_vs_t(vids_obj, &vids, &self->g, 0, 0)) { igraph_vector_destroy(&knn); igraph_vector_destroy(&knnk); igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_obj, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vids); igraph_vector_destroy(&knn); igraph_vector_destroy(&knnk); return NULL; } if (igraph_avg_nearest_neighbor_degree(&self->g, vids, IGRAPH_ALL, IGRAPH_ALL, &knn, &knnk, weights)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vids); igraph_vector_destroy(&knn); igraph_vector_destroy(&knnk); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } igraph_vs_destroy(&vids); if (weights) { igraph_vector_destroy(weights); free(weights); } knn_obj = igraphmodule_vector_t_to_PyList(&knn, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&knn); if (!knn_obj) { igraph_vector_destroy(&knnk); return NULL; } knnk_obj = igraphmodule_vector_t_to_PyList(&knnk, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&knnk); if (!knnk_obj) { Py_DECREF(knn_obj); return NULL; } return Py_BuildValue("NN", knn_obj, knnk_obj); } /** \ingroup python_interface_graph * \brief Calculates the radius of an \c igraph.Graph * * \return the radius as a Python integer * \sa igraph_radius */ PyObject *igraphmodule_Graph_radius(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_OUT; igraph_real_t radius; static char *kwlist[] = { "mode", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_radius(&self->g, &radius, mode)) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble((double)radius); } /** \ingroup python_interface_graph * \brief Converts a tree graph into a Prufer sequence * \return the Prufer sequence as a Python object * \sa igraph_to_prufer */ PyObject *igraphmodule_Graph_to_prufer(igraphmodule_GraphObject * self) { igraph_vector_int_t result; PyObject *list; if (igraph_vector_int_init(&result, 0)) { return NULL; } if (igraph_to_prufer(&self->g, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_int_destroy(&result); return NULL; } list = igraphmodule_vector_int_t_to_PyList(&result); igraph_vector_int_destroy(&result); return list; } /********************************************************************** * Deterministic and non-deterministic graph generators * **********************************************************************/ /** \ingroup python_interface_graph * \brief Generates a graph from its adjacency matrix * \return a reference to the newly generated Python igraph object * \sa igraph_adjacency */ PyObject *igraphmodule_Graph_Adjacency(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraph_matrix_t m; PyObject *matrix, *mode_o = Py_None; igraph_adjacency_t mode = IGRAPH_ADJ_DIRECTED; static char *kwlist[] = { "matrix", "mode", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist, &PyList_Type, &matrix, &mode_o)) return NULL; if (igraphmodule_PyObject_to_adjacency_t(mode_o, &mode)) return NULL; if (igraphmodule_PyList_to_matrix_t(matrix, &m)) { PyErr_SetString(PyExc_TypeError, "Error while converting adjacency matrix"); return NULL; } if (igraph_adjacency(&g, &m, mode)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&m); return NULL; } igraph_matrix_destroy(&m); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph from the Graph Atlas * \return a reference to the newly generated Python igraph object * \sa igraph_atlas */ PyObject *igraphmodule_Graph_Atlas(PyTypeObject * type, PyObject * args) { long n; igraphmodule_GraphObject *self; igraph_t g; if (!PyArg_ParseTuple(args, "l", &n)) return NULL; if (igraph_atlas(&g, (igraph_integer_t) n)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on the Barabasi-Albert model * This is intended to be a class method in Python, so the first argument * is the type object and not the Python igraph object (because we have * to allocate that in this method). * * \return a reference to the newly generated Python igraph object * \sa igraph_barabasi_game */ PyObject *igraphmodule_Graph_Barabasi(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, m = 1; float power = 1.0f, zero_appeal = 1.0f; igraph_vector_t outseq; igraph_t *start_from = 0; igraph_barabasi_algorithm_t algo = IGRAPH_BARABASI_PSUMTREE; PyObject *m_obj = 0, *outpref = Py_False, *directed = Py_False; PyObject *implementation_o = Py_None; PyObject *start_from_o = Py_None; static char *kwlist[] = { "n", "m", "outpref", "directed", "power", "zero_appeal", "implementation", "start_from", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|OOOffOO", kwlist, &n, &m_obj, &outpref, &directed, &power, &zero_appeal, &implementation_o, &start_from_o)) return NULL; if (igraphmodule_PyObject_to_barabasi_algorithm_t(implementation_o, &algo)) return NULL; if (igraphmodule_PyObject_to_igraph_t(start_from_o, &start_from)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (m_obj == 0) { igraph_vector_init(&outseq, 0); m = 1; } else if (m_obj != 0) { /* let's check whether we have a constant out-degree or a list */ if (PyLong_Check(m_obj)) { m = PyLong_AsLong(m_obj); igraph_vector_init(&outseq, 0); } else if (PyList_Check(m_obj)) { if (igraphmodule_PyObject_to_vector_t(m_obj, &outseq, 1)) { /* something bad happened during conversion */ return NULL; } } else { PyErr_SetString(PyExc_TypeError, "m must be an integer or a list of integers"); return NULL; } } if (igraph_barabasi_game(&g, (igraph_integer_t) n, (igraph_real_t) power, (igraph_integer_t) m, &outseq, PyObject_IsTrue(outpref), (igraph_real_t) zero_appeal, PyObject_IsTrue(directed), algo, start_from)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&outseq); return NULL; } igraph_vector_destroy(&outseq); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a bipartite graph * \return a reference to the newly generated Python igraph object * \sa igraph_barabasi_game */ PyObject *igraphmodule_Graph_Bipartite(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraph_vector_bool_t types; igraph_vector_t edges; igraph_bool_t edges_owned = 0; PyObject *types_o, *edges_o, *directed = Py_False; static char *kwlist[] = { "types", "edges", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist, &types_o, &edges_o, &directed)) return NULL; if (igraphmodule_PyObject_to_vector_bool_t(types_o, &types)) return NULL; if (igraphmodule_PyObject_to_edgelist(edges_o, &edges, 0, &edges_owned)) { igraph_vector_bool_destroy(&types); return NULL; } if (igraph_create_bipartite(&g, &types, &edges, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); if (edges_owned) { igraph_vector_destroy(&edges); } igraph_vector_bool_destroy(&types); return NULL; } if (edges_owned) { igraph_vector_destroy(&edges); } igraph_vector_bool_destroy(&types); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a De Bruijn graph * \sa igraph_kautz */ PyObject *igraphmodule_Graph_De_Bruijn(PyTypeObject *type, PyObject *args, PyObject *kwds) { long int m, n; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = {"m", "n", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll", kwlist, &m, &n)) return NULL; if (igraph_de_bruijn(&g, (igraph_integer_t) m, (igraph_integer_t) n)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject*)self; } /** \ingroup python_interface_graph * \brief Generates a random graph with a given degree sequence * This is intended to be a class method in Python, so the first argument * is the type object and not the Python igraph object (because we have * to allocate that in this method). * * \return a reference to the newly generated Python igraph object * \sa igraph_degree_sequence_game */ PyObject *igraphmodule_Graph_Degree_Sequence(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraph_vector_t outseq, inseq; igraph_degseq_t meth = IGRAPH_DEGSEQ_SIMPLE; igraph_bool_t has_inseq = 0; PyObject *outdeg = NULL, *indeg = NULL, *method = NULL; static char *kwlist[] = { "out", "in_", "method", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O!O", kwlist, &PyList_Type, &outdeg, &PyList_Type, &indeg, &method)) return NULL; if (igraphmodule_PyObject_to_degseq_t(method, &meth)) return NULL; if (igraphmodule_PyObject_to_vector_t(outdeg, &outseq, 1)) return NULL; if (indeg) { if (igraphmodule_PyObject_to_vector_t(indeg, &inseq, 1)) { igraph_vector_destroy(&outseq); return NULL; } has_inseq=1; } if (igraph_degree_sequence_game(&g, &outseq, has_inseq ? &inseq : 0, meth)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&outseq); if (has_inseq) igraph_vector_destroy(&inseq); return NULL; } igraph_vector_destroy(&outseq); if (has_inseq) igraph_vector_destroy(&inseq); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on the Erdos-Renyi model * \return a reference to the newly generated Python igraph object * \sa igraph_erdos_renyi_game */ PyObject *igraphmodule_Graph_Erdos_Renyi(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, m = -1; double p = -1.0; igraph_erdos_renyi_t t; PyObject *loops = Py_False, *directed = Py_False; static char *kwlist[] = { "n", "p", "m", "directed", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|dlOO", kwlist, &n, &p, &m, &directed, &loops)) return NULL; if (m == -1 && p == -1.0) { /* no density parameters were given, throw exception */ PyErr_SetString(PyExc_TypeError, "Either m or p must be given."); return NULL; } if (m != -1 && p != -1.0) { /* both density parameters were given, throw exception */ PyErr_SetString(PyExc_TypeError, "Only one must be given from m and p."); return NULL; } t = (m == -1) ? IGRAPH_ERDOS_RENYI_GNP : IGRAPH_ERDOS_RENYI_GNM; if (igraph_erdos_renyi_game(&g, t, (igraph_integer_t) n, (igraph_real_t) (m == -1 ? p : m), PyObject_IsTrue(directed), PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on a simple growing model with vertex types * \return a reference to the newly generated Python igraph object * \sa igraph_establishment_game */ PyObject *igraphmodule_Graph_Establishment(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, types, k; PyObject *type_dist, *pref_matrix; PyObject *directed = Py_False; igraph_matrix_t pm; igraph_vector_t td; char *kwlist[] = { "n", "k", "type_dist", "pref_matrix", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "llO!O!|O", kwlist, &n, &k, &PyList_Type, &type_dist, &PyList_Type, &pref_matrix, &directed)) return NULL; if (n <= 0 || k <= 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices and the amount of connection trials per step must be positive."); return NULL; } types = PyList_Size(type_dist); if (igraphmodule_PyList_to_matrix_t(pref_matrix, &pm)) { PyErr_SetString(PyExc_TypeError, "Error while converting preference matrix"); return NULL; } if (igraph_matrix_nrow(&pm) != igraph_matrix_ncol(&pm) || igraph_matrix_nrow(&pm) != types) { PyErr_SetString(PyExc_ValueError, "Preference matrix must have exactly the same rows and columns as the number of types"); igraph_matrix_destroy(&pm); return NULL; } if (igraphmodule_PyObject_to_vector_t(type_dist, &td, 1)) { PyErr_SetString(PyExc_ValueError, "Error while converting type distribution vector"); igraph_matrix_destroy(&pm); return NULL; } if (igraph_establishment_game(&g, (igraph_integer_t) n, (igraph_integer_t) types, (igraph_integer_t) k, &td, &pm, PyObject_IsTrue(directed), 0)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); return NULL; } igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a famous graph by name * \return a reference to the newly generated Python igraph object * \sa igraph_famous */ PyObject *igraphmodule_Graph_Famous(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; const char* name; static char *kwlist[] = { "name", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &name)) return NULL; if (igraph_famous(&g, name)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on the forest fire model * \return a reference to the newly generated Python igraph object * \sa igraph_forest_fire_game */ PyObject *igraphmodule_Graph_Forest_Fire(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, ambs=1; double fw_prob, bw_factor=0.0; PyObject *directed = Py_False; static char *kwlist[] = {"n", "fw_prob", "bw_factor", "ambs", "directed", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ld|dlO", kwlist, &n, &fw_prob, &bw_factor, &ambs, &directed)) return NULL; if (igraph_forest_fire_game(&g, (igraph_integer_t)n, (igraph_real_t)fw_prob, (igraph_real_t)bw_factor, (igraph_integer_t)ambs, (igraph_bool_t)(PyObject_IsTrue(directed)))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a full graph * \return a reference to the newly generated Python igraph object * \sa igraph_full */ PyObject *igraphmodule_Graph_Full(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n; PyObject *loops = Py_False, *directed = Py_False; char *kwlist[] = { "n", "directed", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|OO", kwlist, &n, &directed, &loops)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (igraph_full(&g, (igraph_integer_t) n, PyObject_IsTrue(directed), PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a full bipartite graph * \sa igraph_full_bipartite */ PyObject *igraphmodule_Graph_Full_Bipartite(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraph_vector_bool_t vertex_types; igraph_neimode_t mode = IGRAPH_ALL; long int n1, n2; PyObject *mode_o = Py_None, *directed = Py_False, *vertex_types_o = 0; static char *kwlist[] = { "n1", "n2", "directed", "mode", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|OO", kwlist, &n1, &n2, &directed, &mode_o)) return NULL; if (n1 < 0 || n2 < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_vector_bool_init(&vertex_types, n1+n2)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_full_bipartite(&g, &vertex_types, (igraph_integer_t) n1, (igraph_integer_t) n2, PyObject_IsTrue(directed), mode)) { igraph_vector_bool_destroy(&vertex_types); igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); vertex_types_o = igraphmodule_vector_bool_t_to_PyList(&vertex_types); igraph_vector_bool_destroy(&vertex_types); if (vertex_types_o == 0) return NULL; return Py_BuildValue("NN", (PyObject *) self, vertex_types_o); } /** \ingroup python_interface_graph * \brief Generates a full citation graph * \return a reference to the newly generated Python igraph object * \sa igraph_full */ PyObject *igraphmodule_Graph_Full_Citation(PyTypeObject *type, PyObject *args, PyObject *kwds) { igraphmodule_GraphObject *self; igraph_t g; long n; PyObject *directed = Py_False; char *kwlist[] = { "n", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|O", kwlist, &n, &directed)) return NULL; if (igraph_full_citation(&g, (igraph_integer_t) n, (igraph_bool_t) PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on the geometric random model * \return a reference to the newly generated Python igraph object * \sa igraph_grg_game */ PyObject *igraphmodule_Graph_GRG(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n; double r; PyObject *torus = Py_False; PyObject *o_xs, *o_ys; igraph_vector_t xs, ys; static char *kwlist[] = { "n", "radius", "torus", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ld|O", kwlist, &n, &r, &torus)) return NULL; if (igraph_vector_init(&xs, 0)) { igraphmodule_handle_igraph_error(); return NULL; } else if (igraph_vector_init(&ys, 0)) { igraph_vector_destroy(&xs); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_grg_game(&g, (igraph_integer_t) n, (igraph_real_t) r, PyObject_IsTrue(torus), &xs, &ys)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&xs); igraph_vector_destroy(&ys); return NULL; } o_xs = igraphmodule_vector_t_to_PyList(&xs, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&xs); if (!o_xs) { igraph_destroy(&g); igraph_vector_destroy(&ys); return NULL; } o_ys = igraphmodule_vector_t_to_PyList(&ys, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&ys); if (!o_ys) { igraph_destroy(&g); Py_DECREF(o_xs); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return Py_BuildValue("NNN", (PyObject*)self, o_xs, o_ys); } /** \ingroup python_interface_graph * \brief Generates a growing random graph * \return a reference to the newly generated Python igraph object * \sa igraph_growing_random_game */ PyObject *igraphmodule_Graph_Growing_Random(PyTypeObject * type, PyObject * args, PyObject * kwds) { long n, m; PyObject *directed = NULL, *citation = NULL; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "m", "directed", "citation", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|O!O!", kwlist, &n, &m, &PyBool_Type, &directed, &PyBool_Type, &citation)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (m < 0) { PyErr_SetString(PyExc_ValueError, "Number of new edges per iteration must be positive."); return NULL; } if (igraph_growing_random_game(&g, (igraph_integer_t) n, (igraph_integer_t) m, (directed == Py_True), (citation == Py_True))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a bipartite graph from an incidence matrix * \return a reference to the newly generated Python igraph object * \sa igraph_incidence */ PyObject *igraphmodule_Graph_Incidence(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_matrix_t matrix; igraph_vector_bool_t vertex_types; igraph_t g; PyObject *matrix_o, *vertex_types_o; PyObject *mode_o = Py_None, *directed = Py_False, *multiple = Py_False; igraph_neimode_t mode = IGRAPH_OUT; static char *kwlist[] = { "matrix", "directed", "mode", "multiple", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|OOO", kwlist, &PyList_Type, &matrix_o, &directed, &mode_o, &multiple)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_vector_bool_init(&vertex_types, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_PyList_to_matrix_t(matrix_o, &matrix)) { igraph_vector_bool_destroy(&vertex_types); PyErr_SetString(PyExc_TypeError, "Error while converting incidence matrix"); return NULL; } if (igraph_incidence(&g, &vertex_types, &matrix, PyObject_IsTrue(directed), mode, PyObject_IsTrue(multiple))) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&matrix); igraph_vector_bool_destroy(&vertex_types); return NULL; } igraph_matrix_destroy(&matrix); CREATE_GRAPH_FROM_TYPE(self, g, type); vertex_types_o = igraphmodule_vector_bool_t_to_PyList(&vertex_types); igraph_vector_bool_destroy(&vertex_types); if (vertex_types_o == 0) return NULL; return Py_BuildValue("NN", (PyObject *) self, vertex_types_o); } /** \ingroup python_interface_graph * \brief Generates a graph with a given isomorphism class * This is intended to be a class method in Python, so the first argument * is the type object and not the Python igraph object (because we have * to allocate that in this method). * * \return a reference to the newly generated Python igraph object * \sa igraph_isoclass_create */ PyObject *igraphmodule_Graph_Isoclass(PyTypeObject * type, PyObject * args, PyObject * kwds) { long int n, isoclass; PyObject *directed = Py_False; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "cls", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|O", kwlist, &n, &isoclass, &directed)) return NULL; if (n < 3 || n > 4) { PyErr_SetString(PyExc_ValueError, "Only graphs with 3 or 4 vertices are supported"); return NULL; } if (igraph_isoclass_create(&g, (igraph_integer_t) n, (igraph_integer_t) isoclass, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a Kautz graph * \sa igraph_kautz */ PyObject *igraphmodule_Graph_Kautz(PyTypeObject *type, PyObject *args, PyObject *kwds) { long int m, n; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = {"m", "n", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll", kwlist, &m, &n)) return NULL; if (igraph_kautz(&g, (igraph_integer_t) m, (igraph_integer_t) n)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject*)self; } /** \ingroup python_interface_graph * \brief Generates a k-regular random graph * \return a reference to the newly generated Python igraph object * \sa igraph_k_regular_game */ PyObject *igraphmodule_Graph_K_Regular(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long int n, k; PyObject *directed_o = Py_False, *multiple_o = Py_False; static char *kwlist[] = { "n", "k", "directed", "multiple", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|OO", kwlist, &n, &k, &directed_o, &multiple_o)) return NULL; if (igraph_k_regular_game(&g, (igraph_integer_t) n, (igraph_integer_t) k, PyObject_IsTrue(directed_o), PyObject_IsTrue(multiple_o))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject*)self; } /** \ingroup python_interface_graph * \brief Generates a regular lattice * \return a reference to the newly generated Python igraph object * \sa igraph_lattice */ PyObject *igraphmodule_Graph_Lattice(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraph_vector_t dimvector; long int nei = 1; igraph_bool_t directed; igraph_bool_t mutual; igraph_bool_t circular; PyObject *o_directed = Py_False, *o_mutual = Py_True, *o_circular = Py_True; PyObject *o_dimvector = Py_None; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "dim", "nei", "directed", "mutual", "circular", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|lOOO", kwlist, &PyList_Type, &o_dimvector, &nei, &o_directed, &o_mutual, &o_circular)) return NULL; directed = PyObject_IsTrue(o_directed); mutual = PyObject_IsTrue(o_mutual); circular = PyObject_IsTrue(o_circular); if (igraphmodule_PyObject_to_vector_t(o_dimvector, &dimvector, 1)) return NULL; if (igraph_lattice(&g, &dimvector, (igraph_integer_t) nei, directed, mutual, circular)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&dimvector); return NULL; } igraph_vector_destroy(&dimvector); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a 3-regular Hamiltonian graph from LCF notation * \return a reference to the newly generated Python igraph object * \sa igraph_lattice */ PyObject *igraphmodule_Graph_LCF(PyTypeObject *type, PyObject *args, PyObject *kwds) { igraph_vector_t shifts; long int repeats, n; PyObject *o_shifts; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "shifts", "repeats", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "lOl", kwlist, &n, &o_shifts, &repeats)) return NULL; if (igraphmodule_PyObject_to_vector_t(o_shifts, &shifts, 0)) return NULL; if (igraph_lcf_vector(&g, (igraph_integer_t) n, &shifts, (igraph_integer_t) repeats)) { igraph_vector_destroy(&shifts); igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_destroy(&shifts); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph with a specified degree sequence * \return a reference to the newly generated Python igraph object * \sa igraph_realize_degree_sequence */ PyObject *igraphmodule_Graph_Realize_Degree_Sequence(PyTypeObject *type, PyObject *args, PyObject *kwds) { igraph_vector_t outdeg, indeg; igraph_vector_t *indegp = 0; igraph_edge_type_sw_t allowed_edge_types = IGRAPH_SIMPLE_SW; igraph_realize_degseq_t method = IGRAPH_REALIZE_DEGSEQ_SMALLEST; PyObject *outdeg_o, *indeg_o = Py_None; PyObject *edge_types_o = Py_None, *method_o = Py_None; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "out", "in_", "allowed_edge_types", "method", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &outdeg_o, &indeg_o, &edge_types_o, &method_o)) return NULL; /* allowed edge types */ if (igraphmodule_PyObject_to_edge_type_sw_t(edge_types_o, &allowed_edge_types)) return NULL; /* methods */ if (igraphmodule_PyObject_to_realize_degseq_t(method_o, &method)) return NULL; /* Outdegree vector */ if (igraphmodule_PyObject_to_vector_t(outdeg_o, &outdeg, 0)) return NULL; /* Indegree vector, Py_None means undirected graph */ if (indeg_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(indeg_o, &indeg, 0)) { igraph_vector_destroy(&outdeg); return NULL; } indegp = &indeg; } /* C function takes care of multi-sw and directed corner case */ if (igraph_realize_degree_sequence(&g, &outdeg, indegp, allowed_edge_types, method)) { igraph_vector_destroy(&outdeg); if (indegp != 0) { igraph_vector_destroy(indegp); } igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_destroy(&outdeg); if (indegp != 0) { igraph_vector_destroy(indegp); } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on vertex types and connection preferences * \return a reference to the newly generated Python igraph object * \sa igraph_preference_game */ PyObject *igraphmodule_Graph_Preference(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, types; PyObject *type_dist, *pref_matrix; PyObject *directed = Py_False; PyObject *loops = Py_False; igraph_matrix_t pm; igraph_vector_t td; igraph_vector_t type_vec; PyObject *type_vec_o; PyObject *attribute_key = Py_None; igraph_bool_t store_attribs; char *kwlist[] = { "n", "type_dist", "pref_matrix", "attribute", "directed", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "lO!O!|OOO", kwlist, &n, &PyList_Type, &type_dist, &PyList_Type, &pref_matrix, &attribute_key, &directed, &loops)) return NULL; types = PyList_Size(type_dist); if (igraphmodule_PyList_to_matrix_t(pref_matrix, &pm)) return NULL; if (igraphmodule_PyObject_float_to_vector_t(type_dist, &td)) { igraph_matrix_destroy(&pm); return NULL; } store_attribs = (attribute_key && attribute_key != Py_None); if (store_attribs && igraph_vector_init(&type_vec, (igraph_integer_t) n)) { igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_preference_game(&g, (igraph_integer_t) n, (igraph_integer_t) types, &td, 0, &pm, store_attribs ? &type_vec : 0, PyObject_IsTrue(directed), PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); if (store_attribs) igraph_vector_destroy(&type_vec); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); if (store_attribs) { type_vec_o = igraphmodule_vector_t_to_PyList(&type_vec, IGRAPHMODULE_TYPE_INT); if (type_vec_o == 0) { igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); igraph_vector_destroy(&type_vec); Py_DECREF(self); return NULL; } if (attribute_key != Py_None && attribute_key != 0) { if (PyDict_SetItem(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_VERTEX], attribute_key, type_vec_o) == -1) { Py_DECREF(type_vec_o); igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); igraph_vector_destroy(&type_vec); Py_DECREF(self); return NULL; } } Py_DECREF(type_vec_o); igraph_vector_destroy(&type_vec); } igraph_matrix_destroy(&pm); igraph_vector_destroy(&td); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on asymmetric vertex types and connection preferences * \return a reference to the newly generated Python igraph object * \sa igraph_asymmetric_preference_game */ PyObject *igraphmodule_Graph_Asymmetric_Preference(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, in_types, out_types; PyObject *type_dist_matrix, *pref_matrix; PyObject *loops = Py_False; igraph_matrix_t pm; igraph_matrix_t td; igraph_vector_t in_type_vec, out_type_vec; PyObject *type_vec_o; PyObject *attribute_key = Py_None; igraph_bool_t store_attribs; char *kwlist[] = { "n", "type_dist_matrix", "pref_matrix", "attribute", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "lO!O!|OO", kwlist, &n, &PyList_Type, &type_dist_matrix, &PyList_Type, &pref_matrix, &attribute_key, &loops)) return NULL; if (igraphmodule_PyList_to_matrix_t(pref_matrix, &pm)) return NULL; if (igraphmodule_PyList_to_matrix_t(type_dist_matrix, &td)) { igraph_matrix_destroy(&pm); return NULL; } in_types = igraph_matrix_nrow(&pm); out_types = igraph_matrix_ncol(&pm); store_attribs = (attribute_key && attribute_key != Py_None); if (store_attribs) { if (igraph_vector_init(&in_type_vec, (igraph_integer_t) n)) { igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&out_type_vec, (igraph_integer_t) n)) { igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); igraph_vector_destroy(&in_type_vec); igraphmodule_handle_igraph_error(); return NULL; } } if (igraph_asymmetric_preference_game(&g, (igraph_integer_t) n, (igraph_integer_t) in_types, (igraph_integer_t) out_types, &td, &pm, store_attribs ? &in_type_vec : 0, store_attribs ? &out_type_vec : 0, PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&in_type_vec); igraph_vector_destroy(&out_type_vec); igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); if (store_attribs) { type_vec_o = igraphmodule_vector_t_pair_to_PyList(&in_type_vec, &out_type_vec); if (type_vec_o == NULL) { igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); igraph_vector_destroy(&in_type_vec); igraph_vector_destroy(&out_type_vec); Py_DECREF(self); return NULL; } if (attribute_key != Py_None && attribute_key != 0) { if (PyDict_SetItem(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_VERTEX], attribute_key, type_vec_o) == -1) { Py_DECREF(type_vec_o); igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); igraph_vector_destroy(&in_type_vec); igraph_vector_destroy(&out_type_vec); Py_DECREF(self); return NULL; } } Py_DECREF(type_vec_o); igraph_vector_destroy(&in_type_vec); igraph_vector_destroy(&out_type_vec); } igraph_matrix_destroy(&pm); igraph_matrix_destroy(&td); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a bipartite graph based on the Erdos-Renyi model * \return a reference to the newly generated Python igraph object * \sa igraph_bipartite_game */ PyObject *igraphmodule_Graph_Random_Bipartite(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long int n1, n2, m = -1; double p = -1.0; igraph_erdos_renyi_t t; igraph_neimode_t neimode = IGRAPH_ALL; PyObject *directed_o = Py_False, *neimode_o = NULL; igraph_vector_bool_t vertex_types; PyObject *vertex_types_o; static char *kwlist[] = { "n1", "n2", "p", "m", "directed", "neimode", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|dlOO", kwlist, &n1, &n2, &p, &m, &directed_o, &neimode_o)) return NULL; if (m == -1 && p == -1.0) { /* no density parameters were given, throw exception */ PyErr_SetString(PyExc_TypeError, "Either m or p must be given."); return NULL; } if (m != -1 && p != -1.0) { /* both density parameters were given, throw exception */ PyErr_SetString(PyExc_TypeError, "Only one must be given from m and p."); return NULL; } t = (m == -1) ? IGRAPH_ERDOS_RENYI_GNP : IGRAPH_ERDOS_RENYI_GNM; if (igraphmodule_PyObject_to_neimode_t(neimode_o, &neimode)) return NULL; if (igraph_vector_bool_init(&vertex_types, n1+n2)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_bipartite_game(&g, &vertex_types, t, (igraph_integer_t) n1, (igraph_integer_t) n2, (igraph_real_t) p, (igraph_integer_t) m, PyObject_IsTrue(directed_o), neimode)) { igraph_vector_bool_destroy(&vertex_types); igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); vertex_types_o = igraphmodule_vector_bool_t_to_PyList(&vertex_types); igraph_vector_bool_destroy(&vertex_types); if (vertex_types_o == 0) return NULL; return Py_BuildValue("NN", (PyObject *) self, vertex_types_o); } /** \ingroup python_interface_graph * \brief Generates a graph based on sort of a "windowed" Barabasi-Albert model * \return a reference to the newly generated Python igraph object * \sa igraph_recent_degree_game */ PyObject *igraphmodule_Graph_Recent_Degree(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long n, m = 0, window = 0; float power = 0.0f, zero_appeal = 0.0f; igraph_vector_t outseq; PyObject *m_obj, *outpref = Py_False, *directed = Py_False; char *kwlist[] = { "n", "m", "window", "outpref", "directed", "power", "zero_appeal", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "lOl|OOff", kwlist, &n, &m_obj, &window, &outpref, &directed, &power, &zero_appeal)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } // let's check whether we have a constant out-degree or a list if (PyLong_Check(m_obj)) { m = PyLong_AsLong(m_obj); igraph_vector_init(&outseq, 0); } else if (PyList_Check(m_obj)) { if (igraphmodule_PyObject_to_vector_t(m_obj, &outseq, 1)) { // something bad happened during conversion return NULL; } } if (igraph_recent_degree_game(&g, (igraph_integer_t) n, (igraph_real_t) power, (igraph_integer_t) window, (igraph_integer_t) m, &outseq, PyObject_IsTrue(outpref), (igraph_real_t) zero_appeal, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&outseq); return NULL; } igraph_vector_destroy(&outseq); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a ring-shaped graph * \return a reference to the newly generated Python igraph object * \sa igraph_ring */ PyObject *igraphmodule_Graph_Ring(PyTypeObject * type, PyObject * args, PyObject * kwds) { long n; PyObject *directed = Py_False, *mutual = Py_False, *circular = Py_True; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "directed", "mutual", "circular", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|O!O!O!", kwlist, &n, &PyBool_Type, &directed, &PyBool_Type, &mutual, &PyBool_Type, &circular)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (igraph_ring(&g, (igraph_integer_t) n, (directed == Py_True), (mutual == Py_True), (circular == Py_True))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on a stochastic blockmodel * \return a reference to the newly generated Python igraph object * \sa igraph_sbm_game */ PyObject *igraphmodule_Graph_SBM(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; long int n; PyObject *block_sizes_o, *pref_matrix_o; PyObject *directed_o = Py_False; PyObject *loops_o = Py_False; igraph_matrix_t pref_matrix; igraph_vector_int_t block_sizes; static char *kwlist[] = { "n", "pref_matrix", "block_sizes", "directed", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "lO!O!|OO", kwlist, &n, &PyList_Type, &pref_matrix_o, &PyList_Type, &block_sizes_o, &directed_o, &loops_o)) return NULL; if (igraphmodule_PyList_to_matrix_t(pref_matrix_o, &pref_matrix)) return NULL; if (igraphmodule_PyObject_to_vector_int_t(block_sizes_o, &block_sizes)) { igraph_matrix_destroy(&pref_matrix); return NULL; } if (igraph_sbm_game(&g, (igraph_integer_t) n, &pref_matrix, &block_sizes, PyObject_IsTrue(directed_o), PyObject_IsTrue(loops_o))) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&pref_matrix); igraph_vector_int_destroy(&block_sizes); return NULL; } igraph_matrix_destroy(&pref_matrix); igraph_vector_int_destroy(&block_sizes); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a star graph * \return a reference to the newly generated Python igraph object * \sa igraph_star */ PyObject *igraphmodule_Graph_Star(PyTypeObject * type, PyObject * args, PyObject * kwds) { long n, center = 0; igraph_star_mode_t mode = IGRAPH_STAR_UNDIRECTED; PyObject* mode_o = Py_None; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "mode", "center", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|Ol", kwlist, &n, &mode_o, ¢er)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (center >= n || center < 0) { PyErr_SetString(PyExc_ValueError, "Central vertex ID should be between 0 and n-1"); return NULL; } if (igraphmodule_PyObject_to_star_mode_t(mode_o, &mode)) { PyErr_SetString(PyExc_ValueError, "Mode should be either \"in\", \"out\", \"mutual\" or \"undirected\""); return NULL; } if (igraph_star(&g, (igraph_integer_t) n, mode, (igraph_integer_t) center)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a non-growing random graph with edge probabilities * proportional to node fitnesses. * \return a reference to the newly generated Python igraph object * \sa igraph_static_fitness_game */ PyObject *igraphmodule_Graph_Static_Fitness(PyTypeObject *type, PyObject* args, PyObject* kwds) { igraphmodule_GraphObject *self; igraph_t g; long int m; PyObject *fitness_out_o = Py_None, *fitness_in_o = Py_None; PyObject *fitness_o = Py_None; PyObject *multiple = Py_False, *loops = Py_False; igraph_vector_t fitness_out, fitness_in; static char *kwlist[] = { "m", "fitness_out", "fitness_in", "loops", "multiple", "fitness", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|OOOOO", kwlist, &m, &fitness_out_o, &fitness_in_o, &loops, &multiple, &fitness_o)) return NULL; /* This trickery allows us to use "fitness" or "fitness_out" as * keyword argument, with "fitness_out" taking precedence over * "fitness" */ if (fitness_out_o == Py_None) fitness_out_o = fitness_o; if (fitness_out_o == Py_None) { PyErr_SetString(PyExc_TypeError, "Required argument 'fitness_out' (pos 2) not found"); return NULL; } if (igraphmodule_PyObject_float_to_vector_t(fitness_out_o, &fitness_out)) return NULL; if (fitness_in_o != Py_None) { if (igraphmodule_PyObject_float_to_vector_t(fitness_in_o, &fitness_in)) { igraph_vector_destroy(&fitness_out); return NULL; } } if (igraph_static_fitness_game(&g, (igraph_integer_t) m, &fitness_out, fitness_in_o == Py_None ? 0 : &fitness_in, PyObject_IsTrue(loops), PyObject_IsTrue(multiple))) { igraph_vector_destroy(&fitness_out); if (fitness_in_o != Py_None) igraph_vector_destroy(&fitness_in); igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_destroy(&fitness_out); if (fitness_in_o != Py_None) igraph_vector_destroy(&fitness_in); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a non-growing random graph with prescribed power-law * degree distributions. * \return a reference to the newly generated Python igraph object * \sa igraph_static_power_law_game */ PyObject *igraphmodule_Graph_Static_Power_Law(PyTypeObject *type, PyObject* args, PyObject* kwds) { igraphmodule_GraphObject *self; igraph_t g; long int n, m; float exponent_out = -1.0f, exponent_in = -1.0f, exponent = -1.0f; PyObject *multiple = Py_False, *loops = Py_False; PyObject *finite_size_correction = Py_True; static char *kwlist[] = { "n", "m", "exponent_out", "exponent_in", "loops", "multiple", "finite_size_correction", "exponent", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|ffOOOf", kwlist, &n, &m, &exponent_out, &exponent_in, &loops, &multiple, &finite_size_correction, &exponent)) return NULL; /* This trickery allows us to use "exponent" or "exponent_out" as * keyword argument, with "exponent_out" taking precedence over * "exponent" */ if (exponent_out == -1.0) exponent_out = exponent; if (exponent_out == -1.0) { PyErr_SetString(PyExc_TypeError, "Required argument 'exponent_out' (pos 3) not found"); return NULL; } if (igraph_static_power_law_game(&g, (igraph_integer_t) n, (igraph_integer_t) m, exponent_out, exponent_in, PyObject_IsTrue(loops), PyObject_IsTrue(multiple), PyObject_IsTrue(finite_size_correction))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a tree graph where almost all vertices have an equal number of children * \return a reference to the newly generated Python igraph object * \sa igraph_tree */ PyObject *igraphmodule_Graph_Tree(PyTypeObject * type, PyObject * args, PyObject * kwds) { long int n, children; PyObject *tree_mode_o = Py_None, *tree_type_o = Py_None; igraph_tree_mode_t mode = IGRAPH_TREE_UNDIRECTED; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "children", "mode", "type", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|OO", kwlist, &n, &children, &tree_mode_o, &tree_type_o)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } if (tree_mode_o == Py_None && tree_type_o != Py_None) { tree_mode_o = tree_type_o; PY_IGRAPH_DEPRECATED("type=... keyword argument is deprecated since igraph 0.6, use mode=... instead"); } if (igraphmodule_PyObject_to_tree_mode_t(tree_mode_o, &mode)) { return NULL; } if (igraph_tree(&g, (igraph_integer_t) n, (igraph_integer_t) children, mode)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a random tree using one of a few methods. * * This method has three parameters: * - n is the number of nodes in the tree. * - directed is a bool that specifies if the edges should be directed. If so, they * point away from the root. * - method is one of: * - 'Prufer' aka sample Pruefer sequences and convert to trees. * - 'lerw' aka loop-erased random walk on the complete graph to sample spanning * trees. * * \return a reference to the newly generated Python igraph object * \sa igraph_tree */ PyObject *igraphmodule_Graph_Tree_Game(PyTypeObject * type, PyObject * args, PyObject * kwds) { long int n; PyObject *directed_o = Py_False, *tree_method_o = Py_None; igraph_bool_t directed; igraph_random_tree_t tree_method = IGRAPH_RANDOM_TREE_LERW; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "n", "directed", "method", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|OO", kwlist, &n, &directed_o, &tree_method_o)) return NULL; if (n < 0) { PyErr_SetString(PyExc_ValueError, "Number of vertices must be positive."); return NULL; } directed = PyObject_IsTrue(directed_o); if (igraphmodule_PyObject_to_random_tree_t(tree_method_o, &tree_method)) return NULL; if (igraph_tree_game(&g, (igraph_integer_t) n, directed, tree_method)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph based on the Watts-Strogatz model * \return a reference to the newly generated Python igraph object * \sa igraph_watts_strogatz_game */ PyObject *igraphmodule_Graph_Watts_Strogatz(PyTypeObject * type, PyObject * args, PyObject * kwds) { long int nei = 1, dim, size; double p; PyObject* loops = Py_False; PyObject* multiple = Py_False; igraphmodule_GraphObject *self; igraph_t g; static char *kwlist[] = { "dim", "size", "nei", "p", "loops", "multiple", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "llld|OO", kwlist, &dim, &size, &nei, &p, &loops, &multiple)) return NULL; if (igraph_watts_strogatz_game(&g, (igraph_integer_t) dim, (igraph_integer_t) size, (igraph_integer_t) nei, p, PyObject_IsTrue(loops), PyObject_IsTrue(multiple))) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Generates a graph from its weighted adjacency matrix * \return a reference to the newly generated Python igraph object * \sa igraph_weighted_adjacency */ PyObject *igraphmodule_Graph_Weighted_Adjacency(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraph_matrix_t m; PyObject *matrix, *mode_o = Py_None, *attr_o = Py_None, *s = 0; PyObject *loops = Py_True; char* attr = 0; igraph_adjacency_t mode = IGRAPH_ADJ_DIRECTED; static char *kwlist[] = { "matrix", "mode", "attr", "loops", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|OOO", kwlist, &PyList_Type, &matrix, &mode_o, &attr_o, &loops)) return NULL; if (igraphmodule_PyObject_to_adjacency_t(mode_o, &mode)) return NULL; if (attr_o != Py_None) { s = PyObject_Str(attr_o); if (s) { attr = PyUnicode_CopyAsString(s); if (attr == 0) return NULL; } else return NULL; } if (igraphmodule_PyList_to_matrix_t(matrix, &m)) { if (attr != 0) free(attr); PyErr_SetString(PyExc_TypeError, "Error while converting adjacency matrix"); return NULL; } if (igraph_weighted_adjacency(&g, &m, mode, attr ? attr : "weight", PyObject_IsTrue(loops))) { igraphmodule_handle_igraph_error(); if (attr != 0) free(attr); igraph_matrix_destroy(&m); return NULL; } if (attr != 0) free(attr); igraph_matrix_destroy(&m); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /********************************************************************** * Advanced structural properties of graphs * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates the articulation points of a graph. * \return the list of articulation points in a PyObject * \sa igraph_articulation_points */ PyObject *igraphmodule_Graph_articulation_points(igraphmodule_GraphObject *self) { igraph_vector_t res; PyObject *o; if (igraph_vector_init(&res, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_articulation_points(&self->g, &res)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&res); return NULL; } igraph_vector_sort(&res); o = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return o; } /** \ingroup python_interface_graph * \brief Calculates the nominal assortativity coefficient * \sa igraph_assortativity_nominal */ PyObject *igraphmodule_Graph_assortativity_nominal(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "types", "directed", NULL }; PyObject *types_o = Py_None, *directed = Py_True; igraph_real_t res; int ret; igraph_vector_t *types = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &types_o, &directed)) return NULL; if (igraphmodule_attrib_to_vector_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) return NULL; ret = igraph_assortativity_nominal(&self->g, types, &res, PyObject_IsTrue(directed)); if (types) { igraph_vector_destroy(types); free(types); } if (ret) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates the assortativity coefficient * \sa igraph_assortativity */ PyObject *igraphmodule_Graph_assortativity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "types1", "types2", "directed", NULL }; PyObject *types1_o = Py_None, *types2_o = Py_None, *directed = Py_True; igraph_real_t res; int ret; igraph_vector_t *types1 = 0, *types2 = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist, &types1_o, &types2_o, &directed)) return NULL; if (igraphmodule_attrib_to_vector_t(types1_o, self, &types1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_t(types2_o, self, &types2, ATTRIBUTE_TYPE_VERTEX)) { if (types1) { igraph_vector_destroy(types1); free(types1); } return NULL; } ret = igraph_assortativity(&self->g, types1, types2, &res, PyObject_IsTrue(directed)); if (types1) { igraph_vector_destroy(types1); free(types1); } if (types2) { igraph_vector_destroy(types2); free(types2); } if (ret) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates the assortativity coefficient for degrees * \sa igraph_assortativity_degree */ PyObject *igraphmodule_Graph_assortativity_degree(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "directed", NULL }; PyObject *directed = Py_True; igraph_real_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &directed)) return NULL; if (igraph_assortativity_degree(&self->g, &res, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates Kleinberg's authority scores of the vertices in the graph * \sa igraph_authority_score */ PyObject *igraphmodule_Graph_authority_score( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "scale", "arpack_options", "return_eigenvalue", NULL }; PyObject *scale_o = Py_True, *weights_o = Py_None; PyObject *arpack_options_o = igraphmodule_arpack_options_default; igraphmodule_ARPACKOptionsObject *arpack_options; PyObject *return_eigenvalue = Py_False; PyObject *res_o; igraph_real_t value; igraph_vector_t res, *weights = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO!O", kwlist, &weights_o, &scale_o, igraphmodule_ARPACKOptionsType, &arpack_options_o, &return_eigenvalue)) return NULL; if (igraph_vector_init(&res, 0)) return igraphmodule_handle_igraph_error(); if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (igraph_authority_score(&self->g, &res, &value, PyObject_IsTrue(scale_o), weights, igraphmodule_ARPACKOptions_get(arpack_options))) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&res); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } res_o = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); if (res_o == NULL) return igraphmodule_handle_igraph_error(); if (PyObject_IsTrue(return_eigenvalue)) { PyObject *ev_o = PyFloat_FromDouble((double)value); if (ev_o == NULL) { Py_DECREF(res_o); return igraphmodule_handle_igraph_error(); } return Py_BuildValue("NN", res_o, ev_o); } return res_o; } /** \ingroup python_interface_graph * \brief Calculates the average path length in a graph. * \return the average path length as a PyObject * \sa igraph_average_path_length */ PyObject *igraphmodule_Graph_average_path_length(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "directed", "unconn", NULL }; PyObject *directed = Py_True, *unconn = Py_True; igraph_real_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!O!", kwlist, &PyBool_Type, &directed, &PyBool_Type, &unconn)) return NULL; if (igraph_average_path_length(&self->g, &res, 0, (directed == Py_True), (unconn == Py_True))) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates the betweennesses of some vertices in a graph. * \return the betweennesses as a list (or a single float) * \sa igraph_betweenness */ PyObject *igraphmodule_Graph_betweenness(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "directed", "cutoff", "weights", "nobigint", NULL }; PyObject *directed = Py_True; PyObject *vobj = Py_None, *list; PyObject *cutoff = Py_None; PyObject *weights_o = Py_None; PyObject *nobigint = Py_True; igraph_vector_t res, *weights = 0; igraph_bool_t return_single = 0; igraph_vs_t vs; /* nobigint is now unused but we kept here for sake of backwards compatibility */ if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOO", kwlist, &vobj, &directed, &cutoff, &weights_o, &nobigint)) { return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); if (weights) { igraph_vector_destroy(weights); free(weights); } return igraphmodule_handle_igraph_error(); } if (cutoff == Py_None) { if (igraph_betweenness(&self->g, &res, vs, PyObject_IsTrue(directed), weights)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); return NULL; } } else if (PyNumber_Check(cutoff)) { PyObject *cutoff_num = PyNumber_Float(cutoff); if (cutoff_num == NULL) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_betweenness_cutoff(&self->g, &res, vs, PyObject_IsTrue(directed), weights, (igraph_real_t)PyFloat_AsDouble(cutoff_num))) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } Py_DECREF(cutoff_num); igraphmodule_handle_igraph_error(); return NULL; } Py_DECREF(cutoff_num); } else { PyErr_SetString(PyExc_TypeError, "cutoff value must be None or integer"); igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(res)[0]); igraph_vector_destroy(&res); igraph_vs_destroy(&vs); if (weights) { igraph_vector_destroy(weights); free(weights); } return list; } /** \ingroup python_interface_graph * \brief Calculates the bibliographic coupling of some vertices in a graph. * \return the bibliographic coupling values in a matrix * \sa igraph_bibcoupling */ PyObject *igraphmodule_Graph_bibcoupling(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "vertices", NULL }; PyObject *vobj = NULL, *list; igraph_matrix_t res; igraph_vs_t vs; igraph_bool_t return_single = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &vobj)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_matrix_init(&res, 1, igraph_vcount(&self->g))) { igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_bibcoupling(&self->g, &res, vs)) { igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } /* TODO: Return a single list instead of a matrix if only one vertex was given */ list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Calculates the biconnected components of a graph. * \return the list of spanning trees of biconnected components in a PyObject * \sa igraph_biconnected_components */ PyObject *igraphmodule_Graph_biconnected_components(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_ptr_t components; igraph_vector_t points; igraph_bool_t return_articulation_points; igraph_integer_t no; PyObject *result, *aps=Py_False; static char* kwlist[] = {"return_articulation_points", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &aps)) return NULL; return_articulation_points = PyObject_IsTrue(aps); if (igraph_vector_ptr_init(&components, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (return_articulation_points) { if (igraph_vector_init(&points, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy(&components); return NULL; } } if (igraph_biconnected_components(&self->g, &no, &components, 0, 0, return_articulation_points ? &points : 0)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy(&components); if (return_articulation_points) igraph_vector_destroy(&points); return NULL; } result = igraphmodule_vector_ptr_t_to_PyList(&components, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&components, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&components); if (return_articulation_points) { PyObject *result2; igraph_vector_sort(&points); result2 = igraphmodule_vector_t_to_PyList(&points, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&points); return Py_BuildValue("NN", result, result2); /* references stolen */ } return result; } /** \ingroup python_interface_graph * \brief Returns the one-mode projections of a bipartite graph * \return the two projections as new igraph objects * \sa igraph_bipartite_projection */ PyObject *igraphmodule_Graph_bipartite_projection(igraphmodule_GraphObject * self, PyObject* args, PyObject* kwds) { PyObject *types_o = Py_None, *multiplicity_o = Py_True, *mul1 = 0, *mul2 = 0; igraphmodule_GraphObject *result1 = 0, *result2 = 0; igraph_vector_bool_t* types = 0; igraph_vector_t multiplicities[2]; igraph_t g1, g2; igraph_t *p_g1 = &g1, *p_g2 = &g2; long int probe1 = -1; long int which = -1; static char* kwlist[] = {"types", "multiplicity", "probe1", "which", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oll", kwlist, &types_o, &multiplicity_o, &probe1, &which)) return NULL; if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (which == 0) { p_g2 = 0; } else if (which == 1) { p_g1 = 0; } if (PyObject_IsTrue(multiplicity_o)) { if (igraph_vector_init(&multiplicities[0], 0)) { if (types) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&multiplicities[1], 0)) { igraph_vector_destroy(&multiplicities[0]); if (types) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_bipartite_projection(&self->g, types, p_g1, p_g2, p_g1 ? &multiplicities[0] : 0, p_g2 ? &multiplicities[1] : 0, (igraph_integer_t) probe1)) { igraph_vector_destroy(&multiplicities[0]); igraph_vector_destroy(&multiplicities[1]); if (types) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } } else { if (igraph_bipartite_projection(&self->g, types, p_g1, p_g2, 0, 0, (igraph_integer_t) probe1)) { if (types) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } } if (types) { igraph_vector_bool_destroy(types); free(types); } if (p_g1) { CREATE_GRAPH(result1, g1); } if (p_g2) { CREATE_GRAPH(result2, g2); } if (PyObject_IsTrue(multiplicity_o)) { if (p_g1) { mul1 = igraphmodule_vector_t_to_PyList(&multiplicities[0], IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&multiplicities[0]); if (mul1 == NULL) { igraph_vector_destroy(&multiplicities[1]); return NULL; } } else { igraph_vector_destroy(&multiplicities[0]); } if (p_g2) { mul2 = igraphmodule_vector_t_to_PyList(&multiplicities[1], IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&multiplicities[1]); if (mul2 == NULL) return NULL; } else { igraph_vector_destroy(&multiplicities[1]); } if (p_g1 && p_g2) { return Py_BuildValue("NNNN", result1, result2, mul1, mul2); } else if (p_g1) { return Py_BuildValue("NN", result1, mul1); } else { return Py_BuildValue("NN", result2, mul2); } } else { if (p_g1 && p_g2) { return Py_BuildValue("NN", result1, result2); } else if (p_g1) { return (PyObject*)result1; } else { return (PyObject*)result2; } } } /** \ingroup python_interface_graph * \brief Returns the sizes of the two one-mode projections of a bipartite graph * \return the two one-mode projections as new igraph objects * \sa igraph_bipartite_projection_size */ PyObject *igraphmodule_Graph_bipartite_projection_size(igraphmodule_GraphObject * self, PyObject* args, PyObject* kwds) { PyObject *types_o = Py_None; igraph_vector_bool_t* types = 0; igraph_integer_t vcount1, vcount2, ecount1, ecount2; static char* kwlist[] = {"types", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &types_o)) return NULL; if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraph_bipartite_projection_size(&self->g, types, &vcount1, &ecount1, &vcount2, &ecount2)) { if (types) { igraph_vector_bool_destroy(types); free(types); } igraphmodule_handle_igraph_error(); return NULL; } if (types) { igraph_vector_bool_destroy(types); free(types); } return Py_BuildValue("llll", (long)vcount1, (long)ecount1, (long)vcount2, (long)ecount2); } /** \ingroup python_interface_graph * \brief Calculates the bridges of a graph. * \return the list of bridges in a PyObject * \sa igraph_bridges */ PyObject *igraphmodule_Graph_bridges(igraphmodule_GraphObject *self) { igraph_vector_t res; PyObject *o; if (igraph_vector_init(&res, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_bridges(&self->g, &res)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&res); return NULL; } igraph_vector_sort(&res); o = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return o; } PyObject *igraphmodule_Graph_chordal_completion( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds ) { static char *kwlist[] = { "alpha", "alpham1", NULL }; PyObject *alpha_o = Py_None, *alpham1_o = Py_None, *res_o; igraph_vector_t alpha, alpham1, edges; igraph_vector_t *alpha_ptr = 0, *alpham1_ptr = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &alpha_o, &alpham1_o)) { return NULL; } if (alpha_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(alpha_o, &alpha, IGRAPHMODULE_TYPE_INT)) { return NULL; } alpha_ptr = α } if (alpham1_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(alpham1_o, &alpham1, IGRAPHMODULE_TYPE_INT)) { if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } return NULL; } alpham1_ptr = &alpham1; } if (igraph_vector_init(&edges, 0)) { igraphmodule_handle_igraph_error(); if (alpham1_ptr) { igraph_vector_destroy(alpham1_ptr); } if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } return NULL; } if (igraph_is_chordal( &self->g, alpha_ptr, /* alpha */ alpham1_ptr, /* alpham1 */ 0, /* chordal */ &edges, /* fill_in */ NULL /* new_graph */ )) { igraph_vector_destroy(&edges); if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } if (alpham1_ptr) { igraph_vector_destroy(alpham1_ptr); } igraphmodule_handle_igraph_error(); return NULL; } if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } if (alpham1_ptr) { igraph_vector_destroy(alpham1_ptr); } res_o = igraphmodule_vector_t_to_PyList_pairs(&edges); igraph_vector_destroy(&edges); return res_o; } /** \ingroup python_interface_graph * \brief Calculates the closeness centrality of some vertices in a graph. * \return the closeness centralities as a list (or a single float) * \sa igraph_betweenness */ PyObject *igraphmodule_Graph_closeness(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "mode", "cutoff", "weights", "normalized", NULL }; PyObject *vobj = Py_None, *list = NULL, *cutoff = Py_None, *mode_o = Py_None, *weights_o = Py_None, *normalized_o = Py_True; igraph_vector_t res, *weights = 0; igraph_neimode_t mode = IGRAPH_ALL; int return_single = 0; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOO", kwlist, &vobj, &mode_o, &cutoff, &weights_o, &normalized_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); return NULL; } if (cutoff == Py_None) { if (igraph_closeness(&self->g, &res, 0, 0, vs, mode, weights, PyObject_IsTrue(normalized_o))) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); return NULL; } } else if (PyNumber_Check(cutoff)) { PyObject *cutoff_num = PyNumber_Float(cutoff); if (cutoff_num == NULL) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_closeness_cutoff(&self->g, &res, 0, 0, vs, mode, weights, (igraph_real_t)PyFloat_AsDouble(cutoff_num), PyObject_IsTrue(normalized_o))) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); Py_DECREF(cutoff_num); return NULL; } Py_DECREF(cutoff_num); } if (weights) { igraph_vector_destroy(weights); free(weights); } if (!return_single) list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(res)[0]); igraph_vector_destroy(&res); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Calculates the harmonic centrality of some vertices in a graph. * \return the harmonic centralities as a list (or a single float) * \sa igraph_closeness */ PyObject *igraphmodule_Graph_harmonic_centrality(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "mode", "cutoff", "weights", "normalized", NULL }; PyObject *vobj = Py_None, *list = NULL, *cutoff = Py_None, *mode_o = Py_None, *weights_o = Py_None, *normalized_o = Py_True; igraph_vector_t res, *weights = 0; igraph_neimode_t mode = IGRAPH_ALL; int return_single = 0; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOO", kwlist, &vobj, &mode_o, &cutoff, &weights_o, &normalized_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); return NULL; } if (cutoff == Py_None) { if (igraph_harmonic_centrality(&self->g, &res, vs, mode, weights, PyObject_IsTrue(normalized_o))) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); return NULL; } } else if (PyNumber_Check(cutoff)) { PyObject *cutoff_num = PyNumber_Float(cutoff); if (cutoff_num == NULL) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_harmonic_centrality_cutoff(&self->g, &res, vs, mode, weights, (igraph_real_t)PyFloat_AsDouble(cutoff_num), PyObject_IsTrue(normalized_o))) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); Py_DECREF(cutoff_num); return NULL; } Py_DECREF(cutoff_num); } if (weights) { igraph_vector_destroy(weights); free(weights); } if (!return_single) list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(res)[0]); igraph_vector_destroy(&res); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Calculates the (weakly or strongly) connected components in a graph. * \return a list containing the cluster ID for every vertex in the graph * \sa igraph_clusters */ PyObject *igraphmodule_Graph_clusters(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", NULL }; igraph_connectedness_t mode = IGRAPH_STRONG; igraph_vector_t res1, res2; igraph_integer_t no; PyObject *list, *mode_o = Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_connectedness_t(mode_o, &mode)) return NULL; igraph_vector_init(&res1, igraph_vcount(&self->g)); igraph_vector_init(&res2, 10); if (igraph_clusters(&self->g, &res1, &res2, &no, mode)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&res1); igraph_vector_destroy(&res2); return NULL; } list = igraphmodule_vector_t_to_PyList(&res1, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res1); igraph_vector_destroy(&res2); return list; } /** \ingroup python_interface_graph * \brief Calculates Burt's constraint scores for a given graph * \sa igraph_constraint */ PyObject *igraphmodule_Graph_constraint(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "weights", NULL }; PyObject *vids_obj = Py_None, *weight_obj = Py_None, *list; igraph_vector_t result, weights; igraph_vs_t vids; igraph_bool_t return_single = 0; if (!PyArg_ParseTupleAndKeywords (args, kwds, "|OO", kwlist, &vids_obj, &weight_obj)) return NULL; if (igraph_vector_init(&result, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_PyObject_to_attribute_values(weight_obj, &weights, self, ATTRHASH_IDX_EDGE, 1.0)) { igraph_vector_destroy(&result); return NULL; } if (igraphmodule_PyObject_to_vs_t(vids_obj, &vids, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); igraph_vector_destroy(&weights); return NULL; } if (igraph_constraint(&self->g, &result, vids, &weights)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vids); igraph_vector_destroy(&result); igraph_vector_destroy(&weights); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble((double)VECTOR(result)[0]); igraph_vs_destroy(&vids); igraph_vector_destroy(&result); igraph_vector_destroy(&weights); return list; } /** \ingroup python_interface_graph * \brief Calculates the cocitation scores of some vertices in a graph. * \return the cocitation scores in a matrix * \sa igraph_cocitation */ PyObject *igraphmodule_Graph_cocitation(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "vertices", NULL }; PyObject *vobj = NULL, *list = NULL; igraph_matrix_t res; int return_single = 0; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &vobj)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_matrix_init(&res, 1, igraph_vcount(&self->g))) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_cocitation(&self->g, &res, vs)) { igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } /* TODO: Return a single list instead of a matrix if only one vertex was given */ list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Replaces multiple vertices with a single one. * \return None. * \sa igraph_contract_vertices */ PyObject *igraphmodule_Graph_contract_vertices(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char* kwlist[] = {"mapping", "combine_attrs", NULL }; PyObject *mapping_o, *combination_o = Py_None; igraph_vector_t mapping; igraph_attribute_combination_t combination; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &mapping_o, &combination_o)) return NULL; if (igraphmodule_PyObject_to_attribute_combination_t( combination_o, &combination)) return NULL; if (igraphmodule_PyObject_to_vector_t(mapping_o, &mapping, 1)) { igraph_attribute_combination_destroy(&combination); return NULL; } if (igraph_contract_vertices(&self->g, &mapping, &combination)) { igraph_attribute_combination_destroy(&combination); igraph_vector_destroy(&mapping); return NULL; } igraph_attribute_combination_destroy(&combination); igraph_vector_destroy(&mapping); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Decomposes a graph into components. * \return a list of graph objects, each containing a copy of a component in the original graph. * \sa igraph_components */ PyObject *igraphmodule_Graph_decompose(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "mode", "maxcompno", "minelements", NULL }; igraph_connectedness_t mode = IGRAPH_STRONG; PyObject *list, *mode_o = Py_None; igraphmodule_GraphObject *o; long maxcompno = -1, minelements = -1, n, i; igraph_vector_ptr_t components; igraph_t *g; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oll", kwlist, &mode_o, &maxcompno, &minelements)) return NULL; if (igraphmodule_PyObject_to_connectedness_t(mode_o, &mode)) return NULL; igraph_vector_ptr_init(&components, 3); if (igraph_decompose(&self->g, &components, mode, maxcompno, minelements)) { igraph_vector_ptr_destroy(&components); igraphmodule_handle_igraph_error(); return NULL; } /* We have to create a Python igraph object for every graph returned */ n = igraph_vector_ptr_size(&components); list = PyList_New(n); for (i = 0; i < n; i++) { g = (igraph_t *) VECTOR(components)[i]; CREATE_GRAPH(o, *g); PyList_SET_ITEM(list, i, (PyObject *) o); /* reference has been transferred by PyList_SET_ITEM, no need to DECREF * * we mustn't call igraph_destroy here, because it would free the vertices * and the edges as well, but we need them in o->g. So just call free */ free(g); } igraph_vector_ptr_destroy(&components); return list; } /** \ingroup python_interface_graph * \brief Calculates the eccentricities of some vertices in a graph. * \return the eccentricities as a list (or a single float) * \sa igraph_eccentricity */ PyObject *igraphmodule_Graph_eccentricity(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds) { static char *kwlist[] = { "vertices", "mode", NULL }; PyObject *vobj = Py_None, *list = NULL, *mode_o = Py_None; igraph_vector_t res; igraph_neimode_t mode = IGRAPH_OUT; int return_single = 0; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &vobj, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_eccentricity(&self->g, &res, vs, mode)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&res); igraphmodule_handle_igraph_error(); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(res)[0]); igraph_vector_destroy(&res); igraph_vs_destroy(&vs); return list; } PyObject* igraphmodule_Graph_eigen_adjacency(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "algorithm", "which", "arpack_options", NULL }; PyObject *algorithm_o = Py_None, *which_o = Py_None; PyObject *arpack_options_o = igraphmodule_arpack_options_default; igraph_eigen_algorithm_t algorithm; igraph_eigen_which_t which; igraphmodule_ARPACKOptionsObject *arpack_options; igraph_vector_t values; igraph_matrix_t vectors; PyObject *values_o, *vectors_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO!", kwlist, &algorithm_o, &which_o, igraphmodule_ARPACKOptionsType, &arpack_options)) { return NULL; } if (igraphmodule_PyObject_to_eigen_algorithm_t(algorithm_o, &algorithm)) { return NULL; } if (igraphmodule_PyObject_to_eigen_which_t(which_o, &which)) { return NULL; } if (igraph_vector_init(&values, 0)) { return NULL; } if (igraph_matrix_init(&vectors, 0, 0)) { igraph_vector_destroy(&values); return igraphmodule_handle_igraph_error(); } arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (igraph_eigen_adjacency(&self->g, algorithm, &which, igraphmodule_ARPACKOptions_get(arpack_options), /*storage=*/ 0, &values, &vectors, /*cmplxvalues=*/ 0, /*cmplxvectors=*/ 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&values); igraph_matrix_destroy(&vectors); return NULL; } values_o = igraphmodule_vector_t_to_PyList(&values, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&values); vectors_o = igraphmodule_matrix_t_to_PyList(&vectors, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&vectors); return Py_BuildValue("NN", values_o, vectors_o); } /** \ingroup python_interface_graph * \brief Calculates the edge betweennesses in the graph * \return a list containing the edge betweenness for every edge * \sa igraph_edge_betweenness */ PyObject *igraphmodule_Graph_edge_betweenness(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "directed", "cutoff", "weights", NULL }; igraph_vector_t res, *weights = 0; PyObject *list, *directed = Py_True, *cutoff = Py_None; PyObject *weights_o = Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &directed, &cutoff, &weights_o)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; igraph_vector_init(&res, igraph_ecount(&self->g)); if (cutoff == Py_None) { if (igraph_edge_betweenness(&self->g, &res, PyObject_IsTrue(directed), weights)) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&res); return NULL; } } else if (PyNumber_Check(cutoff)) { PyObject *cutoff_num = PyNumber_Float(cutoff); if (!cutoff_num) { if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&res); return NULL; } if (igraph_edge_betweenness_cutoff(&self->g, &res, PyObject_IsTrue(directed), weights, (igraph_real_t)PyFloat_AsDouble(cutoff_num))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&res); if (weights) { igraph_vector_destroy(weights); free(weights); } Py_DECREF(cutoff_num); return NULL; } Py_DECREF(cutoff_num); } else { PyErr_SetString(PyExc_TypeError, "cutoff value must be None or integer"); igraph_vector_destroy(&res); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); return list; } /** \ingroup python_interface_graph * \brief Calculates the edge connectivity of the graph * \return the edge connectivity * \sa igraph_edge_connectivity, igraph_st_edge_connectivity */ PyObject *igraphmodule_Graph_edge_connectivity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "source", "target", "checks", NULL }; PyObject *checks = Py_True; long int source = -1, target = -1; igraph_integer_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|llO", kwlist, &source, &target, &checks)) return NULL; if (source < 0 && target < 0) { if (igraph_edge_connectivity(&self->g, &res, PyObject_IsTrue(checks))) { igraphmodule_handle_igraph_error(); return NULL; } } else if (source >= 0 && target >= 0) { if (igraph_st_edge_connectivity(&self->g, &res, (igraph_integer_t) source, (igraph_integer_t) target)) { igraphmodule_handle_igraph_error(); return NULL; } } else { PyErr_SetString(PyExc_ValueError, "if source or target is given, the other one must also be specified"); return NULL; } return PyLong_FromLong(res); } /** \ingroup python_interface_graph * \brief Calculates the eigenvector centralities of the vertices in the graph * \sa igraph_eigenvector_centrality */ PyObject *igraphmodule_Graph_eigenvector_centrality( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "directed", "scale", "weights", "arpack_options", "return_eigenvalue", NULL }; PyObject *directed_o = Py_True; PyObject *scale_o = Py_True; PyObject *weights_o = Py_None; PyObject *arpack_options_o = igraphmodule_arpack_options_default; igraphmodule_ARPACKOptionsObject *arpack_options; PyObject *return_eigenvalue = Py_False; PyObject *res_o; igraph_real_t value; igraph_vector_t *weights=0, res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO!O", kwlist, &directed_o, &scale_o, &weights_o, igraphmodule_ARPACKOptionsType, &arpack_options, &return_eigenvalue)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraph_vector_init(&res, 0)) { if (weights) { igraph_vector_destroy(weights); free(weights); } return igraphmodule_handle_igraph_error(); } arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (igraph_eigenvector_centrality(&self->g, &res, &value, PyObject_IsTrue(directed_o), PyObject_IsTrue(scale_o), weights, igraphmodule_ARPACKOptions_get(arpack_options))) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&res); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } res_o = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); if (res_o == NULL) return igraphmodule_handle_igraph_error(); if (PyObject_IsTrue(return_eigenvalue)) { PyObject *ev_o = PyFloat_FromDouble((double)value); if (ev_o == NULL) { Py_DECREF(res_o); return igraphmodule_handle_igraph_error(); } return Py_BuildValue("NN", res_o, ev_o); } return res_o; } /** \ingroup python_interface_graph * \brief Calculates a feedback arc set for a graph * \return a list containing the indices in the chosen feedback arc set * \sa igraph_feedback_arc_set */ PyObject *igraphmodule_Graph_feedback_arc_set( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "method", NULL }; igraph_vector_t* weights = 0; igraph_vector_t result; igraph_fas_algorithm_t algo = IGRAPH_FAS_APPROX_EADES; PyObject *weights_o = Py_None, *result_o = NULL, *algo_o = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &weights_o, &algo_o)) return NULL; if (igraphmodule_PyObject_to_fas_algorithm_t(algo_o, &algo)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraph_vector_init(&result, 0)) { if (weights) { igraph_vector_destroy(weights); free(weights); } } if (igraph_feedback_arc_set(&self->g, &result, weights, algo)) { if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&result); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } result_o = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return result_o; } /** \ingroup python_interface_graph * \brief Calculates the shortest paths from/to a given node in the graph * \return a list containing shortest paths from/to the given node * \sa igraph_get_shortest_paths */ PyObject *igraphmodule_Graph_get_shortest_paths(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v", "to", "weights", "mode", "output", NULL }; igraph_vector_t *res, *weights=0; igraph_neimode_t mode = IGRAPH_OUT; long int i, j; igraph_integer_t from, no_of_target_nodes; igraph_vs_t to; PyObject *list, *item, *mode_o=Py_None, *weights_o=Py_None, *output_o=Py_None, *from_o = Py_None, *to_o=Py_None; igraph_vector_ptr_t *ptrvec=0; igraph_bool_t use_edges = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOOO!", kwlist, &from_o, &to_o, &weights_o, &mode_o, &PyUnicode_Type, &output_o)) return NULL; if (output_o == 0 || output_o == Py_None || PyUnicode_IsEqualToASCIIString(output_o, "vpath")) { use_edges = 0; } else if (PyUnicode_IsEqualToASCIIString(output_o, "epath")) { use_edges = 1; } else { PyErr_SetString(PyExc_ValueError, "output argument must be \"vpath\" or \"epath\""); return NULL; } if (igraphmodule_PyObject_to_vid(from_o, &from, &self->g)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraphmodule_PyObject_to_vs_t(to_o, &to, &self->g, 0, 0)) { if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_vs_size(&self->g, &to, &no_of_target_nodes)) { if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); igraphmodule_handle_igraph_error(); return NULL; } ptrvec = (igraph_vector_ptr_t *) calloc(1, sizeof(igraph_vector_ptr_t)); if (!ptrvec) { PyErr_SetString(PyExc_MemoryError, ""); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); return NULL; } if (igraph_vector_ptr_init(ptrvec, no_of_target_nodes)) { PyErr_SetString(PyExc_MemoryError, ""); free(ptrvec); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); return NULL; } res = (igraph_vector_t *) calloc(no_of_target_nodes, sizeof(igraph_vector_t)); if (!res) { PyErr_SetString(PyExc_MemoryError, ""); igraph_vector_ptr_destroy(ptrvec); free(ptrvec); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); return NULL; } for (i = 0; i < no_of_target_nodes; i++) { VECTOR(*ptrvec)[i] = &res[i]; igraph_vector_init(&res[i], 0); } if (igraph_get_shortest_paths_dijkstra(&self->g, use_edges ? 0 : ptrvec, use_edges ? ptrvec : 0, from, to, weights, mode, 0, 0)) { igraphmodule_handle_igraph_error(); for (j = 0; j < no_of_target_nodes; j++) igraph_vector_destroy(&res[j]); free(res); igraph_vector_ptr_destroy(ptrvec); free(ptrvec); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); return NULL; } igraph_vector_ptr_destroy(ptrvec); free(ptrvec); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&to); list = PyList_New(no_of_target_nodes); if (!list) { for (j = 0; j < no_of_target_nodes; j++) igraph_vector_destroy(&res[j]); free(res); return NULL; } for (i = 0; i < no_of_target_nodes; i++) { item = igraphmodule_vector_t_to_PyList(&res[i], IGRAPHMODULE_TYPE_INT); if (!item || PyList_SetItem(list, i, item)) { if (item) { Py_DECREF(item); } Py_DECREF(list); for (j = 0; j < no_of_target_nodes; j++) igraph_vector_destroy(&res[j]); free(res); return NULL; } } for (j = 0; j < no_of_target_nodes; j++) igraph_vector_destroy(&res[j]); free(res); return list; } /** \ingroup python_interface_graph * \brief Calculates all of the shortest paths from/to a given node in the graph * \return a list containing shortest paths from/to the given node * \sa igraph_get_shortest_paths */ PyObject *igraphmodule_Graph_get_all_shortest_paths(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v", "to", "weights", "mode", NULL }; igraph_vector_ptr_t res; igraph_vector_t *weights = 0; igraph_neimode_t mode = IGRAPH_OUT; long int i, j; igraph_integer_t from; igraph_vs_t to; PyObject *list, *item, *from_o, *mode_o=Py_None, *to_o=Py_None, *weights_o=Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &from_o, &to_o, &weights_o, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vid(from_o, &from, &self->g)) return NULL; if (igraphmodule_PyObject_to_vs_t(to_o, &to, &self->g, 0, 0)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&to); return NULL; } if (igraph_vector_ptr_init(&res, 1)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&to); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_get_all_shortest_paths_dijkstra(&self->g, &res, NULL, from, to, weights, mode)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy(&res); igraph_vs_destroy(&to); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } igraph_vs_destroy(&to); if (weights) { igraph_vector_destroy(weights); free(weights); } IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&res, igraph_vector_destroy); j = igraph_vector_ptr_size(&res); list = PyList_New(j); if (!list) { igraph_vector_ptr_destroy_all(&res); return NULL; } for (i = 0; i < j; i++) { item = igraphmodule_vector_t_to_PyList((igraph_vector_t *) igraph_vector_ptr_e(&res, i), IGRAPHMODULE_TYPE_INT); if (!item) { Py_DECREF(list); igraph_vector_ptr_destroy_all(&res); return NULL; } if (PyList_SetItem(list, i, item)) { Py_DECREF(list); Py_DECREF(item); igraph_vector_ptr_destroy_all(&res); return NULL; } } igraph_vector_ptr_destroy_all(&res); return list; } /** \ingroup python_interface_graph * \brief Calculates all the simple paths from a single source to other nodes * in the graph. * * \return a list containing all simple paths from the given node to the given * nodes * \sa igraph_get_all_simple_paths */ PyObject *igraphmodule_Graph_get_all_simple_paths(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v", "to", "cutoff", "mode", NULL }; igraph_vector_int_t res; igraph_neimode_t mode = IGRAPH_OUT; igraph_integer_t from; igraph_vs_t to; igraph_integer_t cutoff; PyObject *list, *from_o, *mode_o=Py_None, *to_o=Py_None, *cutoff_o=Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &from_o, &to_o, &cutoff_o, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (PyLong_AsInt(cutoff_o, &cutoff)) return NULL; if (igraphmodule_PyObject_to_vid(from_o, &from, &self->g)) return NULL; if (igraphmodule_PyObject_to_vs_t(to_o, &to, &self->g, 0, 0)) return NULL; if (igraph_vector_int_init(&res, 0)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&to); return NULL; } if (igraph_get_all_simple_paths(&self->g, &res, from, to, cutoff, mode)) { igraphmodule_handle_igraph_error(); igraph_vector_int_destroy(&res); igraph_vs_destroy(&to); return NULL; } igraph_vs_destroy(&to); list = igraphmodule_vector_int_t_to_PyList(&res); return list; } /** \ingroup python_interface_graph * \brief Calculates Kleinberg's hub scores of the vertices in the graph * \sa igraph_hub_score */ PyObject *igraphmodule_Graph_hub_score( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "scale", "arpack_options", "return_eigenvalue", NULL }; PyObject *scale_o = Py_True, *weights_o = Py_None; PyObject *arpack_options_o = igraphmodule_arpack_options_default; igraphmodule_ARPACKOptionsObject *arpack_options; PyObject *return_eigenvalue = Py_False; PyObject *res_o; igraph_real_t value; igraph_vector_t res, *weights = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO!O", kwlist, &weights_o, &scale_o, igraphmodule_ARPACKOptionsType, &arpack_options, &return_eigenvalue)) return NULL; if (igraph_vector_init(&res, 0)) return igraphmodule_handle_igraph_error(); if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (igraph_hub_score(&self->g, &res, &value, PyObject_IsTrue(scale_o), weights, igraphmodule_ARPACKOptions_get(arpack_options))) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&res); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } res_o = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); if (res_o == NULL) return igraphmodule_handle_igraph_error(); if (PyObject_IsTrue(return_eigenvalue)) { PyObject *ev_o = PyFloat_FromDouble((double)value); if (ev_o == NULL) { Py_DECREF(res_o); return igraphmodule_handle_igraph_error(); } return Py_BuildValue("NN", res_o, ev_o); } return res_o; } PyObject *igraphmodule_Graph_is_chordal( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds ) { static char *kwlist[] = { "alpha", "alpham1", NULL }; PyObject *alpha_o = Py_None, *alpham1_o = Py_None; igraph_vector_t alpha, alpham1; igraph_vector_t *alpha_ptr = 0, *alpham1_ptr = 0; igraph_bool_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &alpha_o, &alpham1_o)) { return NULL; } if (alpha_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(alpha_o, &alpha, IGRAPHMODULE_TYPE_INT)) { return NULL; } alpha_ptr = α } if (alpham1_o != Py_None) { if (igraphmodule_PyObject_to_vector_t(alpham1_o, &alpham1, IGRAPHMODULE_TYPE_INT)) { if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } return NULL; } alpham1_ptr = &alpham1; } if (igraph_is_chordal( &self->g, alpha_ptr, /* alpha */ alpham1_ptr, /* alpham1 */ &res, NULL, /* fill_in */ NULL /* new_graph */ )) { if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } if (alpham1_ptr) { igraph_vector_destroy(alpham1_ptr); } igraphmodule_handle_igraph_error(); return NULL; } if (alpha_ptr) { igraph_vector_destroy(alpha_ptr); } if (alpham1_ptr) { igraph_vector_destroy(alpham1_ptr); } return res ? Py_True : Py_False; } /** \ingroup python_interface_graph * \brief Returns the line graph of the graph * \return the line graph as a new igraph object * \sa igraph_linegraph */ PyObject *igraphmodule_Graph_linegraph(igraphmodule_GraphObject * self) { igraph_t lg; igraphmodule_GraphObject *result; if (igraph_linegraph(&self->g, &lg)) { igraphmodule_handle_igraph_error(); return NULL; } CREATE_GRAPH(result, lg); return (PyObject *) result; } /** * \ingroup python_interface_graph * \brief Conducts a maximum cardinality search on the graph. * \sa igraph_maximum_cardinality_search */ PyObject *igraphmodule_Graph_maximum_cardinality_search(igraphmodule_GraphObject *self) { igraph_vector_t alpha, alpham1; PyObject *alpha_o, *alpham1_o; if (igraph_vector_init(&alpha, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&alpham1, 0)) { igraph_vector_destroy(&alpha); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_maximum_cardinality_search(&self->g, &alpha, &alpham1)) { igraph_vector_destroy(&alpha); igraph_vector_destroy(&alpham1); return NULL; } alpha_o = igraphmodule_vector_t_to_PyList(&alpha, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&alpha); if (!alpha_o) { igraph_vector_destroy(&alpham1); return NULL; } alpham1_o = igraphmodule_vector_t_to_PyList(&alpham1, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&alpham1); if (!alpham1_o) { Py_DECREF(alpha_o); return NULL; } return PyTuple_Pack(2, alpha_o, alpham1_o); } /** * \ingroup python_interface_graph * \brief Returns the k-neighborhood of some vertices in the * graph. * \sa igraph_neighborhood */ PyObject *igraphmodule_Graph_neighborhood(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "vertices", "order", "mode", "mindist", NULL }; PyObject *vobj = Py_None; PyObject *mode_o = 0; PyObject *result; long int order = 1; int mindist = 0; igraph_neimode_t mode = IGRAPH_ALL; igraph_bool_t return_single = 0; igraph_vs_t vs; igraph_vector_ptr_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OlOi", kwlist, &vobj, &order, &mode_o, &mindist)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { return igraphmodule_handle_igraph_error(); } if (igraph_vector_ptr_init(&res, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_neighborhood(&self->g, &res, vs, (igraph_integer_t) order, mode, mindist)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } igraph_vs_destroy(&vs); if (!return_single) result = igraphmodule_vector_ptr_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); else result = igraphmodule_vector_t_to_PyList((igraph_vector_t*)VECTOR(res)[0], IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&res, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&res); return result; } /** * \ingroup python_interface_graph * \brief Returns the size of the k-neighborhood of some vertices in the * graph. * \sa igraph_neighborhood_size */ PyObject *igraphmodule_Graph_neighborhood_size(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "vertices", "order", "mode", "mindist", NULL }; PyObject *vobj = Py_None; PyObject *mode_o = 0; PyObject *result; long int order = 1; int mindist = 0; igraph_neimode_t mode = IGRAPH_ALL; igraph_bool_t return_single = 0; igraph_vs_t vs; igraph_vector_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OlOi", kwlist, &vobj, &order, &mode_o, &mindist)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_neighborhood_size(&self->g, &res, vs, (igraph_integer_t) order, mode, mindist)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } igraph_vs_destroy(&vs); if (!return_single) result = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); else result = PyLong_FromLong((long)VECTOR(res)[0]); igraph_vector_destroy(&res); return result; } /** \ingroup python_interface_graph * \brief Calculates the Google personalized PageRank value of some vertices in the graph. * \return the personalized PageRank values * \sa igraph_personalized_pagerank */ PyObject *igraphmodule_Graph_personalized_pagerank(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "vertices", "directed", "damping", "reset", "reset_vertices", "weights", "arpack_options", "implementation", "niter", "eps", NULL }; PyObject *directed = Py_True; PyObject *vobj = Py_None, *wobj = Py_None, *robj = Py_None, *rvsobj = Py_None; PyObject *list; PyObject *arpack_options_o = igraphmodule_arpack_options_default; igraphmodule_ARPACKOptionsObject *arpack_options; double damping = 0.85; igraph_vector_t res; igraph_vector_t *reset = 0; igraph_vector_t weights; igraph_bool_t return_single = 0; igraph_vs_t vs, reset_vs; igraph_pagerank_algo_t algo=IGRAPH_PAGERANK_ALGO_PRPACK; PyObject *algo_o = Py_None; long niter=1000; float eps=0.001f; void *opts; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOdOOOO!Olf", kwlist, &vobj, &directed, &damping, &robj, &rvsobj, &wobj, igraphmodule_ARPACKOptionsType, &arpack_options_o, &algo_o, &niter, &eps)) return NULL; if (robj != Py_None && rvsobj != Py_None) { PyErr_SetString(PyExc_ValueError, "only reset or reset_vs can be defined, not both"); return NULL; } if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (robj != Py_None) { if (igraphmodule_attrib_to_vector_t(robj, self, &reset, ATTRIBUTE_TYPE_VERTEX)) { igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } } else if (rvsobj != Py_None) { if (igraphmodule_PyObject_to_vs_t(rvsobj, &reset_vs, &self->g, 0, 0)) { igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } } if (igraphmodule_PyObject_to_attribute_values(wobj, &weights, self, ATTRHASH_IDX_EDGE, 1.0)) { igraph_vs_destroy(&vs); if (rvsobj != Py_None) igraph_vs_destroy(&reset_vs); if (reset) { igraph_vector_destroy(reset); free(reset); } return NULL; } if (igraph_vector_init(&res, 0)) { igraph_vs_destroy(&vs); if (rvsobj != Py_None) igraph_vs_destroy(&reset_vs); if (reset) { igraph_vector_destroy(reset); free(reset); } igraph_vector_destroy(&weights); return igraphmodule_handle_igraph_error(); } if (igraphmodule_PyObject_to_pagerank_algo_t(algo_o, &algo)) return NULL; if (algo == IGRAPH_PAGERANK_ALGO_ARPACK) { opts = igraphmodule_ARPACKOptions_get(arpack_options); } else { opts = 0; } if (rvsobj != Py_None) retval = igraph_personalized_pagerank_vs(&self->g, algo, &res, 0, vs, PyObject_IsTrue(directed), damping, reset_vs, &weights, opts); else retval = igraph_personalized_pagerank(&self->g, algo, &res, 0, vs, PyObject_IsTrue(directed), damping, reset, &weights, opts); if (retval) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); if (rvsobj != Py_None) igraph_vs_destroy(&reset_vs); if (reset) { igraph_vector_destroy(reset); free(reset); } igraph_vector_destroy(&weights); igraph_vector_destroy(&res); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(res)[0]); igraph_vector_destroy(&res); igraph_vs_destroy(&vs); if (rvsobj != Py_None) igraph_vs_destroy(&reset_vs); igraph_vector_destroy(&weights); if (reset) { igraph_vector_destroy(reset); free(reset); } return list; } /** \ingroup python_interface_graph * \brief Calculates the path length histogram of the graph * \sa igraph_path_length_hist */ PyObject *igraphmodule_Graph_path_length_hist(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "directed", NULL }; PyObject *directed = Py_True, *result; igraph_real_t unconn; igraph_vector_t res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &directed)) return NULL; if (igraph_vector_init(&res, 0)) return igraphmodule_handle_igraph_error(); if (igraph_path_length_hist(&self->g, &res, &unconn, PyObject_IsTrue(directed))) { igraph_vector_destroy(&res); return igraphmodule_handle_igraph_error(); } result=igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return Py_BuildValue("Nd", result, (double)unconn); } /** \ingroup python_interface_graph * \brief Permutes the vertices of the graph * \return the new graph as a new igraph object * \sa igraph_permute_vertices */ PyObject *igraphmodule_Graph_permute_vertices(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "permutation", NULL }; igraph_t pg; igraph_vector_t perm; igraphmodule_GraphObject *result; PyObject *list; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &PyList_Type, &list)) return NULL; if (igraphmodule_PyObject_to_vector_t(list, &perm, 1)) return NULL; if (igraph_permute_vertices(&self->g, &pg, &perm)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&perm); return NULL; } igraph_vector_destroy(&perm); CREATE_GRAPH(result, pg); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Rewires a graph while preserving degree distribution * \return the rewired graph * \sa igraph_rewire */ PyObject *igraphmodule_Graph_rewire(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "n", "mode", NULL }; long int n = 1000; PyObject *mode_o = Py_None; igraph_rewiring_t mode = IGRAPH_REWIRING_SIMPLE; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lO", kwlist, &n, &mode_o)) return NULL; if (igraphmodule_PyObject_to_rewiring_t(mode_o, &mode)) return NULL; if (igraph_rewire(&self->g, (igraph_integer_t) n, mode)) { igraphmodule_handle_igraph_error(); return NULL; } Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Rewires the edges of a graph wth constant probability * \return the rewired graph * \sa igraph_rewire_edges */ PyObject *igraphmodule_Graph_rewire_edges(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "prob", "loops", "multiple", NULL }; double prob; PyObject *loops_o = Py_False, *multiple_o = Py_False; if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|OO", kwlist, &prob, &loops_o, &multiple_o)) return NULL; if (igraph_rewire_edges(&self->g, prob, PyObject_IsTrue(loops_o), PyObject_IsTrue(multiple_o))) { igraphmodule_handle_igraph_error(); return NULL; } Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Calculates shortest paths in a graph. * \return the shortest path lengths for the given vertices * \sa igraph_shortest_paths, igraph_shortest_paths_dijkstra, * igraph_shortest_paths_bellman_ford, igraph_shortest_paths_johnson */ PyObject *igraphmodule_Graph_shortest_paths(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "weights", "mode", NULL }; PyObject *from_o = NULL, *to_o = NULL, *mode_o = NULL, *weights_o = Py_None; PyObject *list = NULL; igraph_matrix_t res; igraph_vector_t *weights=0; igraph_neimode_t mode = IGRAPH_OUT; int return_single_from = 0, return_single_to = 0, e = 0; igraph_vs_t from_vs, to_vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &from_o, &to_o, &weights_o, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return 0; if (igraphmodule_PyObject_to_vs_t(from_o, &from_vs, &self->g, &return_single_from, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_PyObject_to_vs_t(to_o, &to_vs, &self->g, &return_single_to, 0)) { igraph_vs_destroy(&from_vs); igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&from_vs); igraph_vs_destroy(&to_vs); return NULL; } if (igraph_matrix_init(&res, 1, igraph_vcount(&self->g))) { if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_vs_destroy(&from_vs); igraph_vs_destroy(&to_vs); return igraphmodule_handle_igraph_error(); } /* Select the most suitable algorithm */ if (weights) { if (igraph_vector_min(weights) > 0) { /* Only positive weights, use Dijkstra's algorithm */ e = igraph_shortest_paths_dijkstra(&self->g, &res, from_vs, to_vs, weights, mode); } else { /* There are negative weights. For a small number of sources, use Bellman-Ford. * Otherwise, use Johnson's algorithm */ igraph_integer_t vs_size; e = igraph_vs_size(&self->g, &from_vs, &vs_size); if (!e) { if (vs_size <= 100 || mode != IGRAPH_OUT) { e = igraph_shortest_paths_bellman_ford(&self->g, &res, from_vs, to_vs, weights, mode); } else { e = igraph_shortest_paths_johnson(&self->g, &res, from_vs, to_vs, weights); } } } } else { /* No weights, use a simple BFS */ e = igraph_shortest_paths(&self->g, &res, from_vs, to_vs, mode); } if (e) { if (weights) igraph_vector_destroy(weights); igraph_matrix_destroy(&res); igraph_vs_destroy(&from_vs); igraph_vs_destroy(&to_vs); igraphmodule_handle_igraph_error(); return NULL; } if (weights) { igraph_vector_destroy(weights); list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); } else { list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); } if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_matrix_destroy(&res); igraph_vs_destroy(&from_vs); igraph_vs_destroy(&to_vs); return list; } /** \ingroup python_interface_graph * \brief Calculates the Jaccard similarities of some vertices in a graph. * \return the similarity scores in a matrix * \sa igraph_similarity_jaccard */ PyObject *igraphmodule_Graph_similarity_jaccard(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "pairs", "mode", "loops", NULL }; PyObject *vertices_o = Py_None, *pairs_o = Py_None; PyObject *list = NULL, *loops = Py_True, *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_ALL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &vertices_o, &pairs_o, &mode_o, &loops)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (vertices_o != Py_None && pairs_o != Py_None) { PyErr_SetString(PyExc_ValueError, "at most one of `vertices` and `pairs` " "must be given"); return NULL; } if (pairs_o == Py_None) { /* Case #1: vertices, returning matrix */ igraph_matrix_t res; igraph_vs_t vs; int return_single = 0; if (igraphmodule_PyObject_to_vs_t(vertices_o, &vs, &self->g, &return_single, 0)) return NULL; if (igraph_matrix_init(&res, 0, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_similarity_jaccard(&self->g, &res, vs, mode, PyObject_IsTrue(loops))) { igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } igraph_vs_destroy(&vs); list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&res); } else { /* Case #2: vertex pairs or edges, returning list */ igraph_vector_t edges; igraph_vector_t res; igraph_bool_t edges_owned; if (igraphmodule_PyObject_to_edgelist(pairs_o, &edges, 0, &edges_owned)) return NULL; if (igraph_vector_init(&res, igraph_vector_size(&edges) / 2)) { igraph_vector_destroy(&edges); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_similarity_jaccard_pairs(&self->g, &res, &edges, mode, PyObject_IsTrue(loops))) { igraph_vector_destroy(&res); if (edges_owned) { igraph_vector_destroy(&edges); } igraphmodule_handle_igraph_error(); return NULL; } if (edges_owned) { igraph_vector_destroy(&edges); } list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); } return list; } /** \ingroup python_interface_graph * \brief Calculates the Dice similarities of some vertices in a graph. * \return the similarity scores in a matrix * \sa igraph_similarity_dice */ PyObject *igraphmodule_Graph_similarity_dice(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "pairs", "mode", "loops", NULL }; PyObject *vertices_o = Py_None, *pairs_o = Py_None; PyObject *list = NULL, *loops = Py_True, *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_ALL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &vertices_o, &pairs_o, &mode_o, &loops)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (vertices_o != Py_None && pairs_o != Py_None) { PyErr_SetString(PyExc_ValueError, "at most one of `vertices` and `pairs` " "must be given"); return NULL; } if (pairs_o == Py_None) { /* Case #1: vertices, returning matrix */ igraph_matrix_t res; igraph_vs_t vs; int return_single = 0; if (igraphmodule_PyObject_to_vs_t(vertices_o, &vs, &self->g, &return_single, 0)) return NULL; if (igraph_matrix_init(&res, 0, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_similarity_dice(&self->g, &res, vs, mode, PyObject_IsTrue(loops))) { igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } igraph_vs_destroy(&vs); list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&res); } else { /* Case #2: vertex pairs or edges, returning list */ igraph_vector_t edges; igraph_vector_t res; igraph_bool_t edges_owned; if (igraphmodule_PyObject_to_edgelist(pairs_o, &edges, 0, &edges_owned)) return NULL; if (igraph_vector_init(&res, igraph_vector_size(&edges) / 2)) { if (edges_owned) { igraph_vector_destroy(&edges); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_similarity_dice_pairs(&self->g, &res, &edges, mode, PyObject_IsTrue(loops))) { igraph_vector_destroy(&res); if (edges_owned) { igraph_vector_destroy(&edges); } igraphmodule_handle_igraph_error(); return NULL; } if (edges_owned) { igraph_vector_destroy(&edges); } list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&res); } return list; } /** \ingroup python_interface_graph * \brief Calculates the inverse log-weighted similarities of some vertices in * a graph. * \return the similarity scores in a matrix * \sa igraph_similarity_inverse_log_weighted */ PyObject *igraphmodule_Graph_similarity_inverse_log_weighted( igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "mode", NULL }; PyObject *vobj = NULL, *list = NULL, *mode_o = Py_None; igraph_matrix_t res; igraph_neimode_t mode = IGRAPH_ALL; int return_single = 0; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &vobj, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) return NULL; if (igraph_matrix_init(&res, 0, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_similarity_inverse_log_weighted(&self->g,&res,vs,mode)) { igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); igraphmodule_handle_igraph_error(); return NULL; } list = igraphmodule_matrix_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&res); igraph_vs_destroy(&vs); return list; } /** \ingroup python_interface_graph * \brief Calculates a spanning tree for a graph * \return the spanning tree or a list of edges participating in the spanning tree * \sa igraph_minimum_spanning_tree_unweighted * \sa igraph_minimum_spanning_tree_unweighted * \sa igraph_minimum_spanning_tree_prim */ PyObject *igraphmodule_Graph_spanning_tree(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "weights", NULL }; igraph_vector_t* ws = 0; igraph_vector_t res; PyObject *weights_o = Py_None, *result = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &weights_o)) return NULL; if (igraph_vector_init(&res, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &ws, ATTRIBUTE_TYPE_EDGE)) { igraph_vector_destroy(&res); return NULL; } if (igraph_minimum_spanning_tree(&self->g, &res, ws)) { if (ws != 0) { igraph_vector_destroy(ws); free(ws); } igraph_vector_destroy(&res); igraphmodule_handle_igraph_error(); return NULL; } if (ws != 0) { igraph_vector_destroy(ws); free(ws); } result = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return result; } /** \ingroup python_interface_graph * \brief Simplifies a graph by removing loops and/or multiple edges * \return the simplified graph. * \sa igraph_simplify */ PyObject *igraphmodule_Graph_simplify(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "multiple", "loops", "combine_edges", NULL }; PyObject *multiple = Py_True, *loops = Py_True, *comb_o = Py_None; igraph_attribute_combination_t comb; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &multiple, &loops, &comb_o)) return NULL; if (igraphmodule_PyObject_to_attribute_combination_t(comb_o, &comb)) return NULL; if (igraph_simplify(&self->g, PyObject_IsTrue(multiple), PyObject_IsTrue(loops), &comb)) { igraph_attribute_combination_destroy(&comb); igraphmodule_handle_igraph_error(); return NULL; } igraph_attribute_combination_destroy(&comb); Py_INCREF(self); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Calculates the vertex indices within the same component as a given vertex * \return the vertex indices in a list * \sa igraph_subcomponent */ PyObject *igraphmodule_Graph_subcomponent(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "v", "mode", NULL }; igraph_vector_t res; igraph_neimode_t mode = IGRAPH_ALL; igraph_integer_t from; PyObject *list = NULL, *mode_o = Py_None, *from_o = Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &from_o, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vid(from_o, &from, &self->g)) return NULL; igraph_vector_init(&res, 0); if (igraph_subcomponent(&self->g, &res, from, mode)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&res); return NULL; } list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&res); return list; } /** \ingroup python_interface_graph * \brief Returns an induced subgraph of the graph based on the given vertices * \return the subgraph as a new igraph object * \sa igraph_induced_subgraph */ PyObject *igraphmodule_Graph_induced_subgraph(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "implementation", NULL }; igraph_vs_t vs; igraph_t sg; igraphmodule_GraphObject *result; PyObject *list, *impl_o = Py_None; igraph_subgraph_implementation_t impl = IGRAPH_SUBGRAPH_AUTO; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &list, &impl_o)) return NULL; if (igraphmodule_PyObject_to_subgraph_implementation_t(impl_o, &impl)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, 0, 0)) return NULL; if (igraph_induced_subgraph(&self->g, &sg, vs, impl)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); return NULL; } igraph_vs_destroy(&vs); CREATE_GRAPH(result, sg); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Returns a subgraph of the graph based on the given edges * \return the subgraph as a new igraph object * \sa igraph_subgraph_edges */ PyObject *igraphmodule_Graph_subgraph_edges(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "edges", "delete_vertices", NULL }; igraph_es_t es; igraph_t sg; igraphmodule_GraphObject *result; PyObject *list, *delete_vertices = Py_True; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &list, &delete_vertices)) return NULL; if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, 0)) return NULL; if (igraph_subgraph_edges(&self->g, &sg, es, PyObject_IsTrue(delete_vertices))) { igraphmodule_handle_igraph_error(); igraph_es_destroy(&es); return NULL; } CREATE_GRAPH(result, sg); igraph_es_destroy(&es); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Calculates the graph transitivity (a.k.a. clustering coefficient) * \return the clustering coefficient * \sa igraph_transitivity_undirected */ PyObject *igraphmodule_Graph_transitivity_undirected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", NULL }; igraph_real_t res; PyObject *mode_o = Py_None; igraph_transitivity_mode_t mode = IGRAPH_TRANSITIVITY_NAN; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_transitivity_mode_t(mode_o, &mode)) return NULL; if (igraph_transitivity_undirected(&self->g, &res, mode)) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates the average of vertex transitivities over the graph * \sa igraph_transitivity_avglocal_undirected */ PyObject *igraphmodule_Graph_transitivity_avglocal_undirected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", NULL }; igraph_real_t res; PyObject *mode_o = Py_None; igraph_transitivity_mode_t mode = IGRAPH_TRANSITIVITY_NAN; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_transitivity_mode_t(mode_o, &mode)) return NULL; if (igraph_transitivity_avglocal_undirected(&self->g, &res, mode)) { igraphmodule_handle_igraph_error(); return NULL; } return PyFloat_FromDouble(res); } /** \ingroup python_interface_graph * \brief Calculates the local transitivity of given vertices * \return the transitivities in a list * \sa igraph_transitivity_local_undirected */ PyObject *igraphmodule_Graph_transitivity_local_undirected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vertices", "mode", "weights", NULL }; PyObject *vobj = NULL, *mode_o = Py_None, *list = NULL; PyObject *weights_o = Py_None; igraph_vector_t result; igraph_vector_t *weights = 0; igraph_bool_t return_single = 0; igraph_vs_t vs; igraph_transitivity_mode_t mode = IGRAPH_TRANSITIVITY_NAN; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &vobj, &mode_o, &weights_o)) return NULL; if (igraphmodule_PyObject_to_transitivity_mode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(vobj, &vs, &self->g, &return_single, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&result, 0)) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&result); return NULL; } if (weights == 0) { retval = igraph_transitivity_local_undirected(&self->g, &result, vs, mode); } else { retval = igraph_transitivity_barrat(&self->g, &result, vs, weights, mode); } igraph_vs_destroy(&vs); if (weights) { igraph_vector_destroy(weights); free(weights); } if (retval) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } if (!return_single) list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_FLOAT); else list = PyFloat_FromDouble(VECTOR(result)[0]); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief Calculates a possible topological sorting * \return a possible topological sorting as a list * \sa igraph_topological_sorting */ PyObject *igraphmodule_Graph_topological_sorting(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", "warnings", NULL }; PyObject *list, *mode_o=Py_None; PyObject *warnings_o=Py_True; igraph_neimode_t mode = IGRAPH_OUT; igraph_vector_t result; igraph_warning_handler_t* old_handler = 0; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &mode_o, &warnings_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_vector_init(&result, 0)) return igraphmodule_handle_igraph_error(); if (!PyObject_IsTrue(warnings_o)) { /* Turn off the warnings temporarily */ old_handler = igraph_set_warning_handler(igraph_warning_handler_ignore); } retval = igraph_topological_sorting(&self->g, &result, mode); if (!PyObject_IsTrue(warnings_o)) { /* Restore the warning handler */ igraph_set_warning_handler(old_handler); } if (retval) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } /** \ingroup python_interface_graph * \brief Calculates the vertex connectivity of the graph * \return the vertex connectivity * \sa igraph_vertex_connectivity, igraph_st_vertex_connectivity */ PyObject *igraphmodule_Graph_vertex_connectivity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "source", "target", "checks", "neighbors", NULL }; PyObject *checks = Py_True, *neis = Py_None; long int source = -1, target = -1; igraph_integer_t res; igraph_vconn_nei_t neighbors = IGRAPH_VCONN_NEI_ERROR; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|llOO", kwlist, &source, &target, &checks, &neis)) return NULL; if (source < 0 && target < 0) { if (igraph_vertex_connectivity(&self->g, &res, PyObject_IsTrue(checks))) { igraphmodule_handle_igraph_error(); return NULL; } } else if (source >= 0 && target >= 0) { if (igraphmodule_PyObject_to_vconn_nei_t(neis, &neighbors)) return NULL; if (igraph_st_vertex_connectivity(&self->g, &res, (igraph_integer_t) source, (igraph_integer_t) target, neighbors)) { igraphmodule_handle_igraph_error(); return NULL; } } else { PyErr_SetString(PyExc_ValueError, "if source or target is given, the other one must also be specified"); return NULL; } if (!IGRAPH_FINITE(res)) { return PyFloat_FromDouble(res); } return PyLong_FromLong(res); } /********************************************************************** * Bipartite graphs * **********************************************************************/ /** \ingroup python_interface_graph * \brief Checks whether a graph is bipartite * \return a boolean or a (boolean, list of booleans) pair * \sa igraph_is_bipartite */ PyObject *igraphmodule_Graph_is_bipartite(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *types_o, *return_types_o = Py_False; igraph_vector_bool_t types; igraph_bool_t return_types = 0, result; static char *kwlist[] = { "return_types", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &return_types_o)) return NULL; return_types = PyObject_IsTrue(return_types_o); if (return_types) { if (igraph_vector_bool_init(&types, igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_is_bipartite(&self->g, &result, &types)) { igraph_vector_bool_destroy(&types); igraphmodule_handle_igraph_error(); return NULL; } if (result) { types_o = igraphmodule_vector_bool_t_to_PyList(&types); if (!types_o) { igraph_vector_bool_destroy(&types); return NULL; } igraph_vector_bool_destroy(&types); // reference to types_o will be stolen by Py_BuildValue return Py_BuildValue("ON", Py_True, types_o); } else { igraph_vector_bool_destroy(&types); return Py_BuildValue("OO", Py_False, Py_None); } } else { if (igraph_is_bipartite(&self->g, &result, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } } /********************************************************************** * Motifs, dyad and triad census * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates the dyad census of the graph * \return the dyad census as a 3-tuple * \sa igraph_dyad_census */ PyObject *igraphmodule_Graph_dyad_census(igraphmodule_GraphObject *self) { igraph_integer_t mut, asym, nul; PyObject *list; if (igraph_dyad_census(&self->g, &mut, &asym, &nul)) { return igraphmodule_handle_igraph_error(); } list = Py_BuildValue("lll", (long)mut, (long)asym, (long)nul); return list; } typedef struct { PyObject* func; PyObject* graph; } igraphmodule_i_Graph_motifs_randesu_callback_data_t; igraph_bool_t igraphmodule_i_Graph_motifs_randesu_callback(const igraph_t *graph, igraph_vector_t *vids, int isoclass, void* extra) { igraphmodule_i_Graph_motifs_randesu_callback_data_t* data = (igraphmodule_i_Graph_motifs_randesu_callback_data_t*)extra; PyObject* vector; PyObject* result; igraph_bool_t retval; vector = igraphmodule_vector_t_to_PyList(vids, IGRAPHMODULE_TYPE_INT); if (vector == NULL) { /* Error in conversion, return 1 */ return 1; } result = PyObject_CallFunction(data->func, "OOi", data->graph, vector, isoclass); Py_DECREF(vector); if (result == NULL) { /* Error in callback, return 1 */ return 1; } retval = PyObject_IsTrue(result); Py_DECREF(result); return retval; } /** \ingroup python_interface_graph * \brief Counts the motifs of the graph sorted by isomorphism classes * \return the number of motifs found for each isomorphism class * \sa igraph_motifs_randesu */ PyObject *igraphmodule_Graph_motifs_randesu(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_t result, cut_prob; long int size=3; PyObject* cut_prob_list=Py_None; PyObject* callback=Py_None; PyObject *list; static char* kwlist[] = {"size", "cut_prob", "callback", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lOO", kwlist, &size, &cut_prob_list, &callback)) return NULL; if (cut_prob_list == Py_None) { if (igraph_vector_init(&cut_prob, size)) { return igraphmodule_handle_igraph_error(); } igraph_vector_fill(&cut_prob, 0); } else { if (igraphmodule_PyObject_float_to_vector_t(cut_prob_list, &cut_prob)) return NULL; } if (callback == Py_None) { if (igraph_vector_init(&result, 1)) { igraph_vector_destroy(&cut_prob); return igraphmodule_handle_igraph_error(); } if (igraph_motifs_randesu(&self->g, &result, (igraph_integer_t) size, &cut_prob)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); igraph_vector_destroy(&cut_prob); return NULL; } igraph_vector_destroy(&cut_prob); list = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return list; } else if (PyCallable_Check(callback)) { igraphmodule_i_Graph_motifs_randesu_callback_data_t data; data.graph = (PyObject*)self; data.func = callback; if (igraph_motifs_randesu_callback(&self->g, (igraph_integer_t) size, &cut_prob, igraphmodule_i_Graph_motifs_randesu_callback, &data)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&cut_prob); return NULL; } igraph_vector_destroy(&cut_prob); /* Don't let exceptions from the callback function go unnoticed */ if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } else { PyErr_SetString(PyExc_TypeError, "callback must be callable or None"); return NULL; } } /** \ingroup python_interface_graph * \brief Counts the total number of motifs of the graph * \return the total number of motifs * \sa igraph_motifs_randesu */ PyObject *igraphmodule_Graph_motifs_randesu_no(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_t cut_prob; igraph_integer_t result; long int size=3; PyObject* cut_prob_list=Py_None; static char* kwlist[] = {"size", "cut_prob", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lO", kwlist, &size, &cut_prob_list)) return NULL; if (cut_prob_list == Py_None) { if (igraph_vector_init(&cut_prob, size)) { return igraphmodule_handle_igraph_error(); } igraph_vector_fill(&cut_prob, 0); } else { if (igraphmodule_PyObject_float_to_vector_t(cut_prob_list, &cut_prob)) { return NULL; } } if (igraph_motifs_randesu_no(&self->g, &result, (igraph_integer_t) size, &cut_prob)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&cut_prob); return NULL; } igraph_vector_destroy(&cut_prob); return PyLong_FromLong((long)result); } /** \ingroup python_interface_graph * \brief Estimates the total number of motifs of the graph * \return the estimated total number of motifs * \sa igraph_motifs_randesu_estimate */ PyObject *igraphmodule_Graph_motifs_randesu_estimate(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_t cut_prob; igraph_integer_t result; long size=3; PyObject* cut_prob_list=Py_None; PyObject *sample=Py_None; static char* kwlist[] = {"size", "cut_prob", "sample", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lOO", kwlist, &size, &cut_prob_list, &sample)) return NULL; if (sample == Py_None) { PyErr_SetString(PyExc_TypeError, "sample size must be given"); return NULL; } if (cut_prob_list == Py_None) { if (igraph_vector_init(&cut_prob, size)) { return igraphmodule_handle_igraph_error(); } igraph_vector_fill(&cut_prob, 0); } else { if (igraphmodule_PyObject_float_to_vector_t(cut_prob_list, &cut_prob)) { return NULL; } } if (PyLong_Check(sample)) { /* samples chosen randomly */ long int ns = PyLong_AsLong(sample); if (igraph_motifs_randesu_estimate(&self->g, &result, (igraph_integer_t) size, &cut_prob, (igraph_integer_t) ns, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&cut_prob); return NULL; } } else { /* samples given in advance */ igraph_vector_t samp; if (igraphmodule_PyObject_to_vector_t(sample, &samp, 1)) { igraph_vector_destroy(&cut_prob); return NULL; } if (igraph_motifs_randesu_estimate(&self->g, &result, (igraph_integer_t) size, &cut_prob, 0, &samp)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&cut_prob); return NULL; } } igraph_vector_destroy(&cut_prob); return PyLong_FromLong((long)result); } /** \ingroup python_interface_graph * \brief Calculates the triad census of the graph * \return the triad census as a list * \sa igraph_triad_census */ PyObject *igraphmodule_Graph_triad_census(igraphmodule_GraphObject *self) { igraph_vector_t result; PyObject *list; if (igraph_vector_init(&result, 16)) { return igraphmodule_handle_igraph_error(); } if (igraph_triad_census(&self->g, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); return NULL; } list = igraphmodule_vector_t_to_PyTuple(&result); igraph_vector_destroy(&result); return list; } /********************************************************************** * Graph layout algorithms * **********************************************************************/ /** \ingroup python_interface_graph * \brief Places the vertices of a graph uniformly on a circle. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_circle */ PyObject *igraphmodule_Graph_layout_circle(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_matrix_t m; int ret; long dim = 2; PyObject *result; PyObject *order_o = Py_None; igraph_vs_t order; static char *kwlist[] = { "dim", "order", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lO", kwlist, &dim, &order_o)) return NULL; if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (dim != 2 && order_o != Py_None) { PyErr_SetString(PyExc_NotImplementedError, "vertex ordering is supported "\ "for 2 dimensions only"); return NULL; } if (igraphmodule_PyObject_to_vs_t(order_o, &order, &self->g, 0, 0)) { return NULL; } if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&order); return NULL; } if (dim == 2) ret = igraph_layout_circle(&self->g, &m, order); else ret = igraph_layout_sphere(&self->g, &m); igraph_vs_destroy(&order); if (ret) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph randomly. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_random */ PyObject *igraphmodule_Graph_layout_random(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_matrix_t m; int ret; long dim = 2; PyObject *result; static char *kwlist[] = { "dim", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|l", kwlist, &dim)) return NULL; if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } if (dim == 2) ret = igraph_layout_random(&self->g, &m); else ret = igraph_layout_random_3d(&self->g, &m); if (ret) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a grid * \sa igraph_layout_grid, igraph_layout_grid_3d */ PyObject *igraphmodule_Graph_layout_grid(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "width", "height", "dim", NULL }; igraph_matrix_t m; PyObject *result; long int width = 0, height = 0, dim = 2; int ret; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lll", kwlist, &width, &height, &dim)) return NULL; if (dim == 2 && height > 0) { PyErr_SetString(PyExc_ValueError, "height must not be given if dim=2"); return NULL; } if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } if (dim == 2) ret = igraph_layout_grid(&self->g, &m, width); else ret = igraph_layout_grid_3d(&self->g, &m, width, height); if (ret != IGRAPH_SUCCESS) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&m); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices in a star-like layout * \sa igraph_layout_star */ PyObject *igraphmodule_Graph_layout_star(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "center", "order", NULL }; igraph_matrix_t m; PyObject *result, *order_o = Py_None, *center_o = Py_None; igraph_integer_t center = 0; igraph_vector_t* order = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, ¢er_o, &order_o)) return NULL; if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_PyObject_to_vid(center_o, ¢er, &self->g)) return NULL; if (order_o != Py_None) { order = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t)); if (!order) { igraph_matrix_destroy(&m); PyErr_NoMemory(); return NULL; } if (igraphmodule_PyObject_to_vector_t(order_o, order, 1)) { igraph_matrix_destroy(&m); free(order); igraphmodule_handle_igraph_error(); return NULL; } } if (igraph_layout_star(&self->g, &m, center, order)) { if (order) { igraph_vector_destroy(order); free(order); } igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a plane according to the Kamada-Kawai algorithm. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_kamada_kawai */ PyObject *igraphmodule_Graph_layout_kamada_kawai(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "maxiter", "epsilon", "kkconst", "seed", "minx", "maxx", "miny", "maxy", "minz", "maxz", "dim", NULL }; igraph_matrix_t m; igraph_bool_t use_seed=0; int ret; long int niter = 1000, dim = 2; double kkconst, epsilon = 0.0; PyObject *result, *seed_o=Py_None; PyObject *minx_o=Py_None, *maxx_o=Py_None; PyObject *miny_o=Py_None, *maxy_o=Py_None; PyObject *minz_o=Py_None, *maxz_o=Py_None; igraph_vector_t *minx=0, *maxx=0; igraph_vector_t *miny=0, *maxy=0; igraph_vector_t *minz=0, *maxz=0; #define DESTROY_VECTORS { \ if (minx) { igraph_vector_destroy(minx); free(minx); } \ if (maxx) { igraph_vector_destroy(maxx); free(maxx); } \ if (miny) { igraph_vector_destroy(miny); free(miny); } \ if (maxy) { igraph_vector_destroy(maxy); free(maxy); } \ if (minz) { igraph_vector_destroy(minz); free(minz); } \ if (maxz) { igraph_vector_destroy(maxz); free(maxz); } \ } kkconst = igraph_vcount(&self->g); if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lddOOOOOOOl", kwlist, &niter, &epsilon, &kkconst, &seed_o, &minx_o, &maxx_o, &miny_o, &maxy_o, &minz_o, &maxz_o, &dim)) return NULL; if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (seed_o == 0 || seed_o == Py_None) { if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } } else { use_seed=1; if (igraphmodule_PyList_to_matrix_t(seed_o, &m)) return NULL; } /* Convert minimum and maximum x-y-z values */ if (igraphmodule_attrib_to_vector_t(minx_o, self, &minx, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxx_o, self, &maxx, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(miny_o, self, &miny, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxy_o, self, &maxy, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (dim > 2) { if (igraphmodule_attrib_to_vector_t(minz_o, self, &minz, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxz_o, self, &maxz, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } } if (dim == 2) ret = igraph_layout_kamada_kawai (&self->g, &m, use_seed, (igraph_integer_t) niter, epsilon, kkconst, /*weights=*/ 0, /*bounds*/ minx, maxx, miny, maxy); else ret = igraph_layout_kamada_kawai_3d (&self->g, &m, use_seed, (igraph_integer_t) niter, epsilon, kkconst, /*weights=*/ 0, /*bounds*/ minx, maxx, miny, maxy, minz, maxz); DESTROY_VECTORS; #undef DESTROY_VECTORS if (ret) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a plane according to the Davidson-Harel algorithm. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_davidson_harel */ PyObject* igraphmodule_Graph_layout_davidson_harel(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "seed", "maxiter", "fineiter", "cool_fact", "weight_node_dist", "weight_border", "weight_edge_lengths", "weight_edge_crossings", "weight_node_edge_dist", NULL }; igraph_matrix_t m; igraph_bool_t use_seed=0; long int maxiter=10; long int fineiter=-1; double cool_fact=0.75; double weight_node_dist=1.0; double weight_border=0.0; double weight_edge_lengths=-1; double weight_edge_crossings=-1; double weight_node_edge_dist=-1; igraph_real_t density; PyObject *result; PyObject *seed_o=Py_None; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Olldddddd", kwlist, &seed_o, &maxiter, &fineiter, &cool_fact, &weight_node_dist, &weight_border, &weight_edge_lengths, &weight_edge_crossings, &weight_node_edge_dist)) return NULL; /* Provide default parameters based on the properties of the graph */ if (fineiter < 0) { fineiter = log(igraph_vcount(&self->g)) / log(2); if (fineiter > 10) { fineiter = 10; } } if (weight_edge_lengths < 0 || weight_edge_crossings < 0 || weight_node_edge_dist < 0) { if (igraph_density(&self->g, &density, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (weight_edge_lengths < 0) { weight_edge_lengths = density / 10.0; } if (weight_edge_crossings < 0) { weight_edge_crossings = 1.0 - sqrt(density); if (weight_edge_crossings < 0) { weight_edge_crossings = 0; } } if (weight_node_edge_dist < 0) { weight_node_edge_dist = 0.2 * (1 - density); if (weight_node_edge_dist < 0) { weight_node_edge_dist = 0; } } } /* Allocate result matrix if needed */ if (seed_o == 0 || seed_o == Py_None) { if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } } else { if (igraphmodule_PyList_to_matrix_t(seed_o, &m)) { return NULL; } use_seed=1; } retval = igraph_layout_davidson_harel(&self->g, &m, use_seed, (igraph_integer_t) maxiter, (igraph_integer_t) fineiter, cool_fact, weight_node_dist, weight_border, weight_edge_lengths, weight_edge_crossings, weight_node_edge_dist); if (retval) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a plane according to the DrL algorithm. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_drl */ PyObject* igraphmodule_Graph_layout_drl(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "seed", "fixed", "options", "dim", NULL }; igraph_matrix_t m; igraph_bool_t use_seed=0; igraph_vector_t *weights=0; igraph_vector_bool_t *fixed=0; igraph_layout_drl_options_t options; PyObject *result; PyObject *wobj=Py_None, *fixed_o=Py_None, *seed_o=Py_None, *options_o=Py_None; long dim = 2; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOl", kwlist, &wobj, &seed_o, &fixed_o, &options_o, &dim)) return NULL; if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (igraphmodule_PyObject_to_drl_options_t(options_o, &options)) return NULL; if (fixed_o != 0 && fixed_o != Py_None) { /* Apparently the "fixed" argument does not do anything in the DrL * implementation so we throw a warning if the user tries to use it */ PyErr_Warn(PyExc_DeprecationWarning, "The fixed=... argument of the DrL " "layout is ignored; it is kept only for sake of backwards " "compatibility. The DrL layout algorithm does not support " "permanently fixed nodes."); fixed = (igraph_vector_bool_t*)malloc(sizeof(igraph_vector_bool_t)); if (!fixed) { PyErr_NoMemory(); return NULL; } if (igraphmodule_PyObject_to_vector_bool_t(fixed_o, fixed)) { free(fixed); return NULL; } } if (seed_o == 0 || seed_o == Py_None) { if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); if (fixed) { igraph_vector_bool_destroy(fixed); free(fixed); } return NULL; } } else { if (igraphmodule_PyList_to_matrix_t(seed_o, &m)) { if (fixed) { igraph_vector_bool_destroy(fixed); free(fixed); } return NULL; } use_seed=1; } /* Convert the weight parameter to a vector */ if (igraphmodule_attrib_to_vector_t(wobj, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); if (fixed) { igraph_vector_bool_destroy(fixed); free(fixed); } igraphmodule_handle_igraph_error(); return NULL; } if (dim == 2) { retval = igraph_layout_drl(&self->g, &m, use_seed, &options, weights, fixed); } else { retval = igraph_layout_drl_3d(&self->g, &m, use_seed, &options, weights, fixed); } if (retval) { igraph_matrix_destroy(&m); if (weights) { igraph_vector_destroy(weights); free(weights); } if (fixed) { igraph_vector_bool_destroy(fixed); free(fixed); } igraphmodule_handle_igraph_error(); return NULL; } if (weights) { igraph_vector_destroy(weights); free(weights); } if (fixed) { igraph_vector_bool_destroy(fixed); free(fixed); } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a plane according to the Fruchterman-Reingold algorithm. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_fruchterman_reingold */ PyObject *igraphmodule_Graph_layout_fruchterman_reingold(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "weights", "niter", "start_temp", "seed", "minx", "maxx", "miny", "maxy", "minz", "maxz", "dim", "grid", NULL }; igraph_matrix_t m; igraph_bool_t use_seed=0; igraph_vector_t *weights=0; igraph_vector_t *minx=0, *maxx=0; igraph_vector_t *miny=0, *maxy=0; igraph_vector_t *minz=0, *maxz=0; igraph_layout_grid_t grid = IGRAPH_LAYOUT_AUTOGRID; int ret; long int niter = 500, dim = 2; double start_temp; PyObject *result; PyObject *wobj=Py_None, *seed_o=Py_None; PyObject *minx_o=Py_None, *maxx_o=Py_None; PyObject *miny_o=Py_None, *maxy_o=Py_None; PyObject *minz_o=Py_None, *maxz_o=Py_None; PyObject *grid_o=Py_None; #define DESTROY_VECTORS { \ if (weights) { igraph_vector_destroy(weights); free(weights); } \ if (minx) { igraph_vector_destroy(minx); free(minx); } \ if (maxx) { igraph_vector_destroy(maxx); free(maxx); } \ if (miny) { igraph_vector_destroy(miny); free(miny); } \ if (maxy) { igraph_vector_destroy(maxy); free(maxy); } \ if (minz) { igraph_vector_destroy(minz); free(minz); } \ if (maxz) { igraph_vector_destroy(maxz); free(maxz); } \ } start_temp = sqrt(igraph_vcount(&self->g)) / 10.0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OldOOOOOOOlO", kwlist, &wobj, &niter, &start_temp, &seed_o, &minx_o, &maxx_o, &miny_o, &maxy_o, &minz_o, &maxz_o, &dim, &grid_o)) return NULL; if (dim != 2 && dim != 3) { PyErr_SetString(PyExc_ValueError, "number of dimensions must be either 2 or 3"); return NULL; } if (igraphmodule_PyObject_to_layout_grid_t(grid_o, &grid)) { return NULL; } if (seed_o == 0 || seed_o == Py_None) { if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } } else { if (igraphmodule_PyList_to_matrix_t(seed_o, &m)) return NULL; use_seed=1; } /* Convert the weight parameter to a vector */ if (igraphmodule_attrib_to_vector_t(wobj, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } /* Convert minimum and maximum x-y-z values */ if (igraphmodule_attrib_to_vector_t(minx_o, self, &minx, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxx_o, self, &maxx, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(miny_o, self, &miny, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxy_o, self, &maxy, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (dim > 2) { if (igraphmodule_attrib_to_vector_t(minz_o, self, &minz, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(maxz_o, self, &maxz, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); DESTROY_VECTORS; igraphmodule_handle_igraph_error(); return NULL; } } if (dim == 2) { ret = igraph_layout_fruchterman_reingold (&self->g, &m, use_seed, (igraph_integer_t) niter, start_temp, grid, weights, minx, maxx, miny, maxy); } else { ret = igraph_layout_fruchterman_reingold_3d (&self->g, &m, use_seed, (igraph_integer_t) niter, start_temp, weights, minx, maxx, miny, maxy, minz, maxz); } DESTROY_VECTORS; if (ret) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } #undef DESTROY_VECTORS result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices on a plane according to the layout algorithm in * graphopt 0.4.1 * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_graphopt */ PyObject *igraphmodule_Graph_layout_graphopt(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "niter", "node_charge", "node_mass", "spring_length", "spring_constant", "max_sa_movement", "seed", NULL }; igraph_matrix_t m; long int niter = 500; double node_charge = 0.001, node_mass = 30; long spring_length = 0; double spring_constant = 1, max_sa_movement = 5; PyObject *result, *seed_o = Py_None; igraph_bool_t use_seed=0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lddlddO", kwlist, &niter, &node_charge, &node_mass, &spring_length, &spring_constant, &max_sa_movement, &seed_o)) return NULL; if (seed_o == 0 || seed_o == Py_None) { if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } } else { use_seed=1; if (igraphmodule_PyList_to_matrix_t(seed_o, &m)) return NULL; } if (igraph_layout_graphopt(&self->g, &m, (igraph_integer_t) niter, node_charge, node_mass, spring_length, spring_constant, max_sa_movement, use_seed)) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph according to the Large Graph Layout * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_lgl */ PyObject *igraphmodule_Graph_layout_lgl(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "maxiter", "maxdelta", "area", "coolexp", "repulserad", "cellsize", "root", NULL }; igraph_matrix_t m; PyObject *result, *root_o = Py_None; long int maxiter = 150; igraph_integer_t proot = -1; double maxdelta, area, coolexp, repulserad, cellsize; maxdelta = igraph_vcount(&self->g); area = -1; coolexp = 1.5; repulserad = -1; cellsize = -1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ldddddO", kwlist, &maxiter, &maxdelta, &area, &coolexp, &repulserad, &cellsize, &root_o)) return NULL; if (area <= 0) area = igraph_vcount(&self->g)*igraph_vcount(&self->g); if (repulserad <= 0) repulserad = area*igraph_vcount(&self->g); if (cellsize <= 0) cellsize = sqrt(sqrt(area)); if (igraphmodule_PyObject_to_vid(root_o, &proot, &self->g)) return NULL; if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_layout_lgl(&self->g, &m, (igraph_integer_t) maxiter, maxdelta, area, coolexp, repulserad, cellsize, proot)) { igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph using multidimensional scaling * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_mds */ PyObject *igraphmodule_Graph_layout_mds(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "dist", "dim", "arpack_options", NULL }; igraph_matrix_t m; igraph_matrix_t *dist = 0; long int dim = 2; PyObject *dist_o = Py_None; PyObject *arpack_options_o = igraphmodule_arpack_options_default; PyObject *result; /* arpack_options_o is now unused but we kept here for sake of backwards * compatibility */ if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OlO!", kwlist, &dist_o, &dim, igraphmodule_ARPACKOptionsType, &arpack_options_o)) return NULL; if (dist_o != Py_None) { dist = (igraph_matrix_t*)malloc(sizeof(igraph_matrix_t)); if (!dist) { PyErr_NoMemory(); return NULL; } if (igraphmodule_PyList_to_matrix_t(dist_o, dist)) { free(dist); return NULL; } } if (igraph_matrix_init(&m, 1, 1)) { if (dist) { igraph_matrix_destroy(dist); free(dist); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_layout_mds(&self->g, &m, dist, dim)) { if (dist) { igraph_matrix_destroy(dist); free(dist); } igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } if (dist) { igraph_matrix_destroy(dist); free(dist); } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph according to the Reingold-Tilford * tree layout algorithm * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_reingold_tilford */ PyObject *igraphmodule_Graph_layout_reingold_tilford(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", "root", "rootlevel", NULL }; igraph_matrix_t m; igraph_vector_t roots, *roots_p = 0; igraph_vector_t rootlevels, *rootlevels_p = 0; PyObject *roots_o=Py_None, *rootlevels_o=Py_None, *mode_o=Py_None; igraph_neimode_t mode = IGRAPH_OUT; PyObject *result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &mode_o, &roots_o, &rootlevels_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (roots_o != Py_None) { roots_p = &roots; if (igraphmodule_PyObject_to_vector_t(roots_o, roots_p, 1)) return 0; } if (rootlevels_o != Py_None) { rootlevels_p = &rootlevels; if (igraphmodule_PyObject_to_vector_t(rootlevels_o, rootlevels_p, 1)) { if (roots_p) igraph_vector_destroy(roots_p); return 0; } } if (igraph_matrix_init(&m, 1, 1)) { if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_layout_reingold_tilford(&self->g, &m, mode, roots_p, rootlevels_p)) { igraph_matrix_destroy(&m); if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); igraphmodule_handle_igraph_error(); return NULL; } if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph according to the Reingold-Tilford * tree layout algorithm in a polar coordinate system * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_reingold_tilford */ PyObject *igraphmodule_Graph_layout_reingold_tilford_circular( igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", "root", "rootlevel", NULL }; igraph_matrix_t m; igraph_vector_t roots, *roots_p = 0; igraph_vector_t rootlevels, *rootlevels_p = 0; PyObject *roots_o=Py_None, *rootlevels_o=Py_None, *mode_o=Py_None; igraph_neimode_t mode = IGRAPH_OUT; PyObject *result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &mode_o, &roots_o, &rootlevels_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (roots_o != Py_None) { roots_p = &roots; if (igraphmodule_PyObject_to_vector_t(roots_o, roots_p, 1)) return 0; } if (rootlevels_o != Py_None) { rootlevels_p = &rootlevels; if (igraphmodule_PyObject_to_vector_t(rootlevels_o, rootlevels_p, 1)) { if (roots_p) igraph_vector_destroy(roots_p); return 0; } } if (igraph_matrix_init(&m, 1, 1)) { if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_layout_reingold_tilford_circular(&self->g, &m, mode, roots_p, rootlevels_p)) { igraph_matrix_destroy(&m); if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); igraphmodule_handle_igraph_error(); return NULL; } if (roots_p) igraph_vector_destroy(roots_p); if (rootlevels_p) igraph_vector_destroy(rootlevels_p); result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a graph according to the Sugiyama layout. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_sugiyama */ PyObject *igraphmodule_Graph_layout_sugiyama( igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "layers", "weights", "hgap", "vgap", "maxiter", "return_extended_graph", NULL }; igraph_matrix_t m; igraph_t extd_graph; igraph_vector_t extd_to_orig_eids; igraph_vector_t *weights = 0, *layers = 0; double hgap = 1, vgap = 1; long int maxiter = 100; PyObject *layers_o = Py_None, *weights_o = Py_None, *extd_to_orig_eids_o = Py_None; PyObject *return_extended_graph = Py_False; PyObject *result; igraphmodule_GraphObject *graph_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOddlO", kwlist, &layers_o, &weights_o, &hgap, &vgap, &maxiter, &return_extended_graph)) return NULL; if (igraph_vector_init(&extd_to_orig_eids, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_matrix_init(&m, 1, 1)) { igraph_vector_destroy(&extd_to_orig_eids); igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(layers_o, self, &layers, ATTRIBUTE_TYPE_VERTEX)) { igraph_vector_destroy(&extd_to_orig_eids); igraph_matrix_destroy(&m); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { if (layers != 0) { igraph_vector_destroy(layers); free(layers); } igraph_vector_destroy(&extd_to_orig_eids); igraph_matrix_destroy(&m); return NULL; } if (igraph_layout_sugiyama(&self->g, &m, (PyObject_IsTrue(return_extended_graph) ? &extd_graph : 0), (PyObject_IsTrue(return_extended_graph) ? &extd_to_orig_eids : 0), layers, hgap, vgap, maxiter, weights)) { if (layers != 0) { igraph_vector_destroy(layers); free(layers); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } igraph_vector_destroy(&extd_to_orig_eids); igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } if (layers != 0) { igraph_vector_destroy(layers); free(layers); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); if (PyObject_IsTrue(return_extended_graph)) { CREATE_GRAPH(graph_o, extd_graph); extd_to_orig_eids_o = igraphmodule_vector_t_to_PyList(&extd_to_orig_eids, IGRAPHMODULE_TYPE_INT); result = Py_BuildValue("NNN", result, graph_o, extd_to_orig_eids_o); } igraph_vector_destroy(&extd_to_orig_eids); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Places the vertices of a bipartite graph according to a simple two-layer * Sugiyama layout. * \return the calculated coordinates as a Python list of lists * \sa igraph_layout_bipartite */ PyObject *igraphmodule_Graph_layout_bipartite( igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "types", "hgap", "vgap", "maxiter", NULL }; igraph_matrix_t m; igraph_vector_bool_t *types = 0; double hgap = 1, vgap = 1; long int maxiter = 100; PyObject *types_o = Py_None; PyObject *result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oddl", kwlist, &types_o, &hgap, &vgap, &maxiter)) return NULL; if (igraph_matrix_init(&m, 1, 1)) { igraphmodule_handle_igraph_error(); return NULL; } if (types_o == Py_None) { types_o = PyUnicode_FromString("type"); } else { Py_INCREF(types_o); } if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) { igraph_matrix_destroy(&m); Py_DECREF(types_o); return NULL; } Py_DECREF(types_o); if (igraph_layout_bipartite(&self->g, types, &m, hgap, vgap, maxiter)) { if (types != 0) { igraph_vector_bool_destroy(types); free(types); } igraph_matrix_destroy(&m); igraphmodule_handle_igraph_error(); return NULL; } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&m); return (PyObject *) result; } /********************************************************************** * Conversion between various graph representations * **********************************************************************/ /** \ingroup python_interface_graph * \brief Returns the adjacency matrix of a graph. * \return the adjacency matrix as a Python list of lists * \sa igraph_get_adjacency */ PyObject *igraphmodule_Graph_get_adjacency(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "type", "eids", NULL }; igraph_get_adjacency_t mode = IGRAPH_GET_ADJACENCY_BOTH; igraph_matrix_t m; PyObject *result, *mode_o = Py_None, *eids = Py_False; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &mode_o, &eids)) return NULL; if (igraphmodule_PyObject_to_get_adjacency_t(mode_o, &mode)) return NULL; if (igraph_matrix_init (&m, igraph_vcount(&self->g), igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_get_adjacency(&self->g, &m, mode, PyObject_IsTrue(eids))) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&m); return NULL; } result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&m); return result; } /** \ingroup python_interface_graph * \brief Returns the incidence matrix of a bipartite graph. * \return the incidence matrix as a Python list of lists * \sa igraph_get_incidence */ PyObject *igraphmodule_Graph_get_incidence(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "types", NULL }; igraph_matrix_t matrix; igraph_vector_t row_ids, col_ids; igraph_vector_bool_t *types; PyObject *matrix_o, *row_ids_o, *col_ids_o, *types_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &types_o)) return NULL; if (igraph_vector_init(&row_ids, 0)) return NULL; if (igraph_vector_init(&col_ids, 0)) { igraph_vector_destroy(&row_ids); return NULL; } if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) { igraph_vector_destroy(&row_ids); igraph_vector_destroy(&col_ids); return NULL; } if (igraph_matrix_init(&matrix, 1, 1)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&row_ids); igraph_vector_destroy(&col_ids); if (types) { igraph_vector_bool_destroy(types); free(types); } return NULL; } if (igraph_get_incidence(&self->g, types, &matrix, &row_ids, &col_ids)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&row_ids); igraph_vector_destroy(&col_ids); if (types) { igraph_vector_bool_destroy(types); free(types); } igraph_matrix_destroy(&matrix); return NULL; } if (types) { igraph_vector_bool_destroy(types); free(types); } matrix_o = igraphmodule_matrix_t_to_PyList(&matrix, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&matrix); row_ids_o = igraphmodule_vector_t_to_PyList(&row_ids, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&row_ids); col_ids_o = igraphmodule_vector_t_to_PyList(&col_ids, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&col_ids); return Py_BuildValue("NNN", matrix_o, row_ids_o, col_ids_o); } /** \ingroup python_interface_graph * \brief Returns the Laplacian matrix of a graph. * \return the Laplacian matrix as a Python list of lists * \sa igraph_laplacian */ PyObject *igraphmodule_Graph_laplacian(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "weights", "normalized", NULL }; igraph_matrix_t m; PyObject *result; PyObject *weights_o = Py_None; PyObject *normalized = Py_False; igraph_vector_t *weights = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &weights_o, &normalized)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraph_matrix_init (&m, igraph_vcount(&self->g), igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (igraph_laplacian(&self->g, &m, /*sparseres=*/ 0, PyObject_IsTrue(normalized), weights)) { igraphmodule_handle_igraph_error(); if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_matrix_destroy(&m); return NULL; } if (PyObject_IsTrue(normalized) || weights) { result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_FLOAT); } else { result = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_INT); } if (weights) { igraph_vector_destroy(weights); free(weights); } igraph_matrix_destroy(&m); return result; } /** \ingroup python_interface_graph * \brief Returns the list of edges in a graph. * \return the list of edges, every edge is represented by a pair * \sa igraph_get_edgelist */ PyObject *igraphmodule_Graph_get_edgelist(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_vector_t edgelist; PyObject *result; igraph_vector_init(&edgelist, igraph_ecount(&self->g)); if (igraph_get_edgelist(&self->g, &edgelist, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&edgelist); return NULL; } result = igraphmodule_vector_t_to_PyList_pairs(&edgelist); igraph_vector_destroy(&edgelist); return (PyObject *) result; } /** \ingroup python_interface_graph * \function igraphmodule_Graph_to_undirected * \brief Converts a directed graph to an undirected one. * \return The undirected graph. * \sa igraph_to_undirected */ PyObject *igraphmodule_Graph_to_undirected(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *mode_o = Py_None, *comb_o = Py_None; igraph_to_undirected_t mode = IGRAPH_TO_UNDIRECTED_COLLAPSE; igraph_attribute_combination_t comb; static char *kwlist[] = { "mode", "combine_edges", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &mode_o, &comb_o)) return NULL; if (igraphmodule_PyObject_to_to_undirected_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_attribute_combination_t(comb_o, &comb)) return NULL; if (igraph_to_undirected(&self->g, mode, &comb)) { igraph_attribute_combination_destroy(&comb); igraphmodule_handle_igraph_error(); return NULL; } igraph_attribute_combination_destroy(&comb); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \function igraphmodule_Graph_to_directed * \brief Converts an undirected graph to a directed one. * \return The directed graph. * \sa igraph_to_directed */ PyObject *igraphmodule_Graph_to_directed(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *mutual_o = Py_None; PyObject *mode_o = Py_None; igraph_to_directed_t mode = IGRAPH_TO_DIRECTED_MUTUAL; static char *kwlist[] = { "mode", "mutual", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &mode_o, &mutual_o)) return NULL; if (mode_o == Py_None) { /* mode argument omitted so we fall back to 'mutual' for sake of * compatibility and print a warning */ if (mutual_o == Py_None) { /* mutual was not given either, so this is okay */ mode = IGRAPH_TO_DIRECTED_MUTUAL; } else { mode = PyObject_IsTrue(mutual_o) ? IGRAPH_TO_DIRECTED_MUTUAL : IGRAPH_TO_DIRECTED_ARBITRARY; PyErr_Warn(PyExc_DeprecationWarning, "The 'mutual' argument is deprecated since " "igraph 0.9.3, please use mode=... instead"); } } else { if (igraphmodule_PyObject_to_to_directed_t(mode_o, &mode)) { return NULL; } } if (igraph_to_directed(&self->g, mode)) { igraphmodule_handle_igraph_error(); return NULL; } Py_RETURN_NONE; } /********************************************************************** * Reading/writing foreing graph formats * **********************************************************************/ /** \ingroup python_interface_graph * \brief Reads a DIMACS file and creates a graph from it. * \return the graph * \sa igraph_read_graph_dimacs */ PyObject *igraphmodule_Graph_Read_DIMACS(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraphmodule_filehandle_t fobj; igraph_integer_t source = 0, target = 0; igraph_vector_t capacity; igraph_t g; PyObject *fname = NULL, *directed = Py_False, *capacity_obj; static char *kwlist[] = { "f", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O|O", kwlist, &fname, &directed)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_vector_init(&capacity, 0)) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } if (igraph_read_graph_dimacs(&g, igraphmodule_filehandle_get(&fobj), 0, 0, &source, &target, &capacity, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&capacity); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); capacity_obj = igraphmodule_vector_t_to_PyList(&capacity, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&capacity); if (!capacity_obj) return NULL; CREATE_GRAPH_FROM_TYPE(self, g, type); return Py_BuildValue("NiiN", (PyObject *) self, (long)source, (long)target, capacity_obj); } /** \ingroup python_interface_graph * \brief Reads an UCINET DL file and creates a graph from it. * \return the graph * \sa igraph_read_graph_dl */ PyObject *igraphmodule_Graph_Read_DL(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; igraph_t g; igraphmodule_filehandle_t fobj; PyObject *fname = NULL, *directed = Py_True; static char *kwlist[] = { "f", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O|O", kwlist, &fname, &directed)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_dl(&g, igraphmodule_filehandle_get(&fobj), PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject*)self; } /** \ingroup python_interface_graph * \brief Reads an edge list from a file and creates a graph from it. * \return the graph * \sa igraph_read_graph_edgelist */ PyObject *igraphmodule_Graph_Read_Edgelist(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *directed = Py_True, *fname = NULL; igraphmodule_filehandle_t fobj; igraph_t g; static char *kwlist[] = { "f", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &fname, &directed)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_edgelist(&g, igraphmodule_filehandle_get(&fobj), 0, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads an edge list from an NCOL file and creates a graph from it. * \return the graph * \sa igraph_read_graph_ncol */ PyObject *igraphmodule_Graph_Read_Ncol(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *names = Py_True, *weights = Py_None, *directed = Py_True; PyObject *fname = NULL; igraphmodule_filehandle_t fobj; igraph_add_weights_t add_weights = IGRAPH_ADD_WEIGHTS_IF_PRESENT; igraph_t g; static char *kwlist[] = { "f", "names", "weights", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &fname, &names, &weights, &directed)) return NULL; if (igraphmodule_PyObject_to_add_weights_t(weights, &add_weights)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_ncol(&g, igraphmodule_filehandle_get(&fobj), 0, PyObject_IsTrue(names), add_weights, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads an edge list from an LGL file and creates a graph from it. * \return the graph * \sa igraph_read_graph_lgl */ PyObject *igraphmodule_Graph_Read_Lgl(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *names = Py_True, *weights = Py_None, *directed = Py_True; PyObject *fname = NULL; igraphmodule_filehandle_t fobj; igraph_add_weights_t add_weights = IGRAPH_ADD_WEIGHTS_IF_PRESENT; igraph_t g; static char *kwlist[] = { "f", "names", "weights", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &fname, &names, &weights, &directed)) return NULL; if (igraphmodule_PyObject_to_add_weights_t(weights, &add_weights)) return NULL; if (kwds && PyDict_Check(kwds) && \ PyDict_GetItemString(kwds, "directed") == NULL) { if (PyErr_Occurred()) return NULL; } if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_lgl(&g, igraphmodule_filehandle_get(&fobj), PyObject_IsTrue(names), add_weights, PyObject_IsTrue(directed))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads an edge list from a Pajek file and creates a graph from it. * \return the graph * \sa igraph_read_graph_pajek */ PyObject *igraphmodule_Graph_Read_Pajek(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *fname = NULL; igraphmodule_filehandle_t fobj; igraph_t g; static char *kwlist[] = { "f", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_pajek(&g, igraphmodule_filehandle_get(&fobj))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads a GML file and creates a graph from it. * \return the graph * \sa igraph_read_graph_gml */ PyObject *igraphmodule_Graph_Read_GML(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *fname = NULL; igraphmodule_filehandle_t fobj; igraph_t g; static char *kwlist[] = { "f", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_gml(&g, igraphmodule_filehandle_get(&fobj))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads a GraphDB file and creates a graph from it. * \return the graph * \sa igraph_read_graph_graphdb */ PyObject *igraphmodule_Graph_Read_GraphDB(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *fname = NULL, *directed_o = Py_False; igraph_t g; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "directed", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &fname, &directed_o)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_graphdb(&g, igraphmodule_filehandle_get(&fobj), PyObject_IsTrue(directed_o))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Reads a GraphML file and creates a graph from it. * \return the graph * \sa igraph_read_graph_graphml */ PyObject *igraphmodule_Graph_Read_GraphML(PyTypeObject * type, PyObject * args, PyObject * kwds) { igraphmodule_GraphObject *self; PyObject *fname = NULL; long int index = 0; igraph_t g; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "index", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|l", kwlist, &fname, &index)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "r")) return NULL; if (igraph_read_graph_graphml(&g, igraphmodule_filehandle_get(&fobj), (igraph_integer_t) index)) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); CREATE_GRAPH_FROM_TYPE(self, g, type); return (PyObject *) self; } /** \ingroup python_interface_graph * \brief Writes the graph as a DIMACS file * \return none * \sa igraph_write_graph_dimacs */ PyObject *igraphmodule_Graph_write_dimacs(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { long source = 0, target = 0; PyObject *capacity_obj = Py_None, *fname = NULL; igraphmodule_filehandle_t fobj; igraph_vector_t* capacity = 0; static char *kwlist[] = { "f", "source", "target", "capacity", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oll|O", kwlist, &fname, &source, &target, &capacity_obj)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (capacity_obj == Py_None) { capacity_obj = PyUnicode_FromString("capacity"); } else { Py_INCREF(capacity_obj); } if (igraphmodule_attrib_to_vector_t(capacity_obj, self, &capacity, ATTRIBUTE_TYPE_EDGE)) { igraphmodule_filehandle_destroy(&fobj); Py_DECREF(capacity_obj); return NULL; } Py_DECREF(capacity_obj); if (igraph_write_graph_dimacs(&self->g, igraphmodule_filehandle_get(&fobj), source, target, capacity)) { igraphmodule_handle_igraph_error(); if (capacity) { igraph_vector_destroy(capacity); free(capacity); } igraphmodule_filehandle_destroy(&fobj); return NULL; } if (capacity) { igraph_vector_destroy(capacity); free(capacity); } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the graph as a DOT (GraphViz) file * \return none * \sa igraph_write_graph_dot */ PyObject *igraphmodule_Graph_write_dot(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_dot(&self->g, igraphmodule_filehandle_get(&fobj))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the edge list to a file * \return none * \sa igraph_write_graph_edgelist */ PyObject *igraphmodule_Graph_write_edgelist(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_edgelist(&self->g, igraphmodule_filehandle_get(&fobj))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the graph as a GML file * \return none * \sa igraph_write_graph_gml */ PyObject *igraphmodule_Graph_write_gml(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *ids = Py_None, *fname = NULL; PyObject *creator = Py_None; igraph_vector_t idvec, *idvecptr=0; char *creator_str=0; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "creator", "ids", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist, &fname, &creator, &ids)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (PyList_Check(ids)) { idvecptr = &idvec; if (igraphmodule_PyObject_to_vector_t(ids, idvecptr, 0)) { igraphmodule_filehandle_destroy(&fobj); return NULL; } } if (creator != Py_None) { PyObject* o = PyObject_Str(creator); if (o == 0) { if (idvecptr) igraph_vector_destroy(idvecptr); igraphmodule_filehandle_destroy(&fobj); } creator_str = PyUnicode_CopyAsString(o); Py_DECREF(o); if (creator_str == 0) { if (idvecptr) igraph_vector_destroy(idvecptr); igraphmodule_filehandle_destroy(&fobj); } } if (igraph_write_graph_gml(&self->g, igraphmodule_filehandle_get(&fobj), idvecptr, creator_str)) { if (idvecptr) { igraph_vector_destroy(idvecptr); } if (creator_str) free(creator_str); igraphmodule_filehandle_destroy(&fobj); igraphmodule_handle_igraph_error(); return NULL; } if (idvecptr) { igraph_vector_destroy(idvecptr); } if (creator_str) free(creator_str); igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the edge list to a file in .ncol format * \return none * \sa igraph_write_graph_ncol */ PyObject *igraphmodule_Graph_write_ncol(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; char *names = "name"; char *weights = "weight"; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "names", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|zz", kwlist, &fname, &names, &weights)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_ncol(&self->g, igraphmodule_filehandle_get(&fobj), names, weights)) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the edge list to a file in .lgl format * \return none * \sa igraph_write_graph_lgl */ PyObject *igraphmodule_Graph_write_lgl(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; char *names = "name"; char *weights = "weight"; PyObject *isolates = Py_True; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "names", "weights", "isolates", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|zzO", kwlist, &fname, &names, &weights, &isolates)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_lgl(&self->g, igraphmodule_filehandle_get(&fobj), names, weights, PyObject_IsTrue(isolates))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the graph as a Pajek .net file * \return none * \sa igraph_write_graph_pajek */ PyObject *igraphmodule_Graph_write_pajek(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; static char *kwlist[] = { "f", NULL }; igraphmodule_filehandle_t fobj; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_pajek(&self->g, igraphmodule_filehandle_get(&fobj))) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the graph to a GraphML file * \return none * \sa igraph_write_graph_graphml */ PyObject *igraphmodule_Graph_write_graphml(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; static char *kwlist[] = { "f", NULL }; igraphmodule_filehandle_t fobj; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &fname)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_graphml(&self->g, igraphmodule_filehandle_get(&fobj), /*prefixattr=*/ 1)) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /** \ingroup python_interface_graph * \brief Writes the edge list to a file in LEDA native format * \return none * \sa igraph_write_graph_leda */ PyObject *igraphmodule_Graph_write_leda(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *fname = NULL; char *vertex_attr_name = "name"; char *edge_attr_name = "weight"; igraphmodule_filehandle_t fobj; static char *kwlist[] = { "f", "names", "weights", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|zz", kwlist, &fname, &vertex_attr_name, &edge_attr_name)) return NULL; if (igraphmodule_filehandle_init(&fobj, fname, "w")) return NULL; if (igraph_write_graph_leda(&self->g, igraphmodule_filehandle_get(&fobj), vertex_attr_name, edge_attr_name)) { igraphmodule_handle_igraph_error(); igraphmodule_filehandle_destroy(&fobj); return NULL; } igraphmodule_filehandle_destroy(&fobj); Py_RETURN_NONE; } /********************************************************************** * Routines related to graph isomorphism * **********************************************************************/ /** * \ingroup python_interface_graph * \brief Calculates the canonical permutation of a graph using BLISS * \sa igraph_canonical_permutation */ PyObject *igraphmodule_Graph_canonical_permutation( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "sh", "color", NULL }; PyObject *sh_o = Py_None; PyObject *color_o = Py_None; PyObject *list; igraph_bliss_sh_t sh = IGRAPH_BLISS_FL; igraph_vector_t labeling; igraph_vector_int_t *color = 0; int retval; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &sh_o, &color_o)) return NULL; if (igraphmodule_PyObject_to_bliss_sh_t(sh_o, &sh)) return NULL; if (igraph_vector_init(&labeling, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color_o, self, &color, ATTRIBUTE_TYPE_VERTEX)) return NULL; retval = igraph_canonical_permutation(&self->g, color, &labeling, sh, 0); if (color) { igraph_vector_int_destroy(color); free(color); } if (retval) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&labeling); return NULL; } list = igraphmodule_vector_t_to_PyList(&labeling, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&labeling); return list; } /** \ingroup python_interface_graph * \brief Calculates the isomorphism class of a graph or its subgraph * \sa igraph_isoclass, igraph_isoclass_subgraph */ PyObject *igraphmodule_Graph_isoclass(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { Py_ssize_t n; igraph_integer_t isoclass = 0; PyObject *vids = 0; char *kwlist[] = { "vertices", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "|O!", kwlist, &PyList_Type, &vids)) return NULL; n = vids ? PyList_Size(vids) : igraph_vcount(&self->g); if (n < 3 || n > 4) { PyErr_SetString(PyExc_ValueError, "Graph or subgraph must have 3 or 4 vertices."); return NULL; } if (vids) { igraph_vector_t vidsvec; if (igraphmodule_PyObject_to_vector_t(vids, &vidsvec, 1)) { PyErr_SetString(PyExc_ValueError, "Error while converting PyList to igraph_vector_t"); return NULL; } if (igraph_isoclass_subgraph(&self->g, &vidsvec, &isoclass)) { igraphmodule_handle_igraph_error(); return NULL; } } else { if (igraph_isoclass(&self->g, &isoclass)) { igraphmodule_handle_igraph_error(); return NULL; } } return PyLong_FromLong((long)isoclass); } /** \ingroup python_interface_graph * \brief Determines whether the graph is isomorphic to another graph. * * \sa igraph_isomorphic */ PyObject *igraphmodule_Graph_isomorphic(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_bool_t result = 0; PyObject *o = Py_None; igraphmodule_GraphObject *other; static char *kwlist[] = { "other", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!", kwlist, &igraphmodule_GraphType, &o)) return NULL; if (o == Py_None) other = self; else other = (igraphmodule_GraphObject *) o; if (igraph_isomorphic(&self->g, &other->g, &result)) { igraphmodule_handle_igraph_error(); return NULL; } if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Determines whether the graph is isomorphic to another graph, * using the BLISS isomorphism algorithm * * The actual code is almost the same as igraphmodule_Graph_isomorphic_vf2. * Be sure to correct bugs in both interfaces if applicable! * * \sa igraph_isomorphic_bliss */ PyObject *igraphmodule_Graph_isomorphic_bliss(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_bool_t result = 0; PyObject *o=Py_None, *return1=Py_False, *return2=Py_False; PyObject *sho1=Py_None, *sho2=Py_None; PyObject *color1_o=Py_None, *color2_o=Py_None; igraphmodule_GraphObject *other; igraph_vector_t mapping_12, mapping_21, *map12=0, *map21=0; igraph_bliss_sh_t sh1=IGRAPH_BLISS_FL, sh2=IGRAPH_BLISS_FL; igraph_vector_int_t *color1=0, *color2=0; int retval; static char *kwlist[] = { "other", "return_mapping_12", "return_mapping_21", "sh1", "sh2", "color1", "color2", NULL }; /* TODO: convert igraph_bliss_info_t when needed */ if (!PyArg_ParseTupleAndKeywords (args, kwds, "|O!OOOOOO", kwlist, &igraphmodule_GraphType, &o, &return1, &return2, &sho1, &sho2, &color1_o, &color2_o)) return NULL; if (igraphmodule_PyObject_to_bliss_sh_t(sho1, &sh1)) return NULL; sh2 = sh1; if (igraphmodule_PyObject_to_bliss_sh_t(sho2, &sh2)) return NULL; if (sho2 != Py_None && sh2 != sh1) { PY_IGRAPH_WARN("sh2 is ignored in isomorphic_bliss() and is always assumed to " "be equal to sh1"); } sh2 = sh1; if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, self, &color2, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (o == Py_None) other = self; else other = (igraphmodule_GraphObject *) o; if (PyObject_IsTrue(return1)) { igraph_vector_init(&mapping_12, 0); map12 = &mapping_12; } if (PyObject_IsTrue(return2)) { igraph_vector_init(&mapping_21, 0); map21 = &mapping_21; } retval = igraph_isomorphic_bliss(&self->g, &other->g, color1, color2, &result, map12, map21, sh1, 0, 0); if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (retval) { igraphmodule_handle_igraph_error(); return NULL; } if (!map12 && !map21) { if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } else { PyObject *iso, *m1, *m2; iso = result ? Py_True : Py_False; Py_INCREF(iso); if (map12) { m1 = igraphmodule_vector_t_to_PyList(map12, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map12); if (!m1) { Py_DECREF(iso); if (map21) igraph_vector_destroy(map21); return NULL; } } else { m1 = Py_None; Py_INCREF(m1); } if (map21) { m2 = igraphmodule_vector_t_to_PyList(map21, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map21); if (!m2) { Py_DECREF(iso); Py_DECREF(m1); return NULL; } } else { m2 = Py_None; Py_INCREF(m2); } return Py_BuildValue("NNN", iso, m1, m2); } } typedef struct { PyObject* node_compat_fn; PyObject* edge_compat_fn; PyObject* callback_fn; PyObject* graph1; PyObject* graph2; } igraphmodule_i_Graph_isomorphic_vf2_callback_data_t; igraph_bool_t igraphmodule_i_Graph_isomorphic_vf2_callback_fn( const igraph_vector_t *map12, const igraph_vector_t *map21, void* extra) { igraphmodule_i_Graph_isomorphic_vf2_callback_data_t* data = (igraphmodule_i_Graph_isomorphic_vf2_callback_data_t*)extra; igraph_bool_t retval; PyObject *map12_o, *map21_o; PyObject *result; map12_o = igraphmodule_vector_t_to_PyList(map12, IGRAPHMODULE_TYPE_INT); if (map12_o == NULL) { /* Error in conversion, return 0 to stop the search */ PyErr_WriteUnraisable(data->callback_fn); return 0; } map21_o = igraphmodule_vector_t_to_PyList(map21, IGRAPHMODULE_TYPE_INT); if (map21_o == NULL) { /* Error in conversion, return 0 to stop the search */ PyErr_WriteUnraisable(data->callback_fn); Py_DECREF(map21_o); return 0; } result = PyObject_CallFunction(data->callback_fn, "OOOO", data->graph1, data->graph2, map12_o, map21_o); Py_DECREF(map12_o); Py_DECREF(map21_o); if (result == NULL) { /* Error in callback, return 0 */ PyErr_WriteUnraisable(data->callback_fn); return 0; } retval = PyObject_IsTrue(result); Py_DECREF(result); return retval; } igraph_bool_t igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn( const igraph_t *graph1, const igraph_t *graph2, const igraph_integer_t cand1, const igraph_integer_t cand2, void* extra) { igraphmodule_i_Graph_isomorphic_vf2_callback_data_t* data = (igraphmodule_i_Graph_isomorphic_vf2_callback_data_t*)extra; igraph_bool_t retval; PyObject *result; result = PyObject_CallFunction(data->node_compat_fn, "OOll", data->graph1, data->graph2, (long)cand1, (long)cand2); if (result == NULL) { /* Error in callback, return 0 */ PyErr_WriteUnraisable(data->node_compat_fn); return 0; } retval = PyObject_IsTrue(result); Py_DECREF(result); return retval; } igraph_bool_t igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn( const igraph_t *graph1, const igraph_t *graph2, const igraph_integer_t cand1, const igraph_integer_t cand2, void* extra) { igraphmodule_i_Graph_isomorphic_vf2_callback_data_t* data = (igraphmodule_i_Graph_isomorphic_vf2_callback_data_t*)extra; igraph_bool_t retval; PyObject *result; result = PyObject_CallFunction(data->edge_compat_fn, "OOll", data->graph1, data->graph2, (long)cand1, (long)cand2); if (result == NULL) { /* Error in callback, return 0 */ PyErr_WriteUnraisable(data->edge_compat_fn); return 0; } retval = PyObject_IsTrue(result); Py_DECREF(result); return retval; } /** \ingroup python_interface_graph * \brief Determines whether the graph is isomorphic to another graph, * using the VF2 isomorphism algorithm * * The actual code is almost the same as igraphmodule_Graph_subisomorphic. * Be sure to correct bugs in both interfaces if applicable! * * \sa igraph_isomorphic_vf2 */ PyObject *igraphmodule_Graph_isomorphic_vf2(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_bool_t result = 0; PyObject *o=Py_None, *return1=Py_False, *return2=Py_False; PyObject *color1_o=Py_None, *color2_o=Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *callback_fn=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; igraphmodule_GraphObject *other; igraph_vector_t mapping_12, mapping_21; igraph_vector_t *map12=0, *map21=0; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; int retval; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "return_mapping_12", "return_mapping_21", "callback", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "|O!OOOOOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &return1, &return2, &callback_fn, &node_compat_fn, &edge_compat_fn)) return NULL; if (o == Py_None) other=self; else other=(igraphmodule_GraphObject*)o; if (callback_fn != Py_None && !PyCallable_Check(callback_fn)) { PyErr_SetString(PyExc_TypeError, "callback must be None or callable"); return NULL; } if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } if (PyObject_IsTrue(return1)) { igraph_vector_init(&mapping_12, 0); map12 = &mapping_12; } if (PyObject_IsTrue(return2)) { igraph_vector_init(&mapping_21, 0); map21 = &mapping_21; } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = callback_fn == Py_None ? 0 : callback_fn; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (callback_data.callback_fn == 0) { retval = igraph_isomorphic_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, map12, map21, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data); } else { retval = igraph_isomorphic_function_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, map12, map21, igraphmodule_i_Graph_isomorphic_vf2_callback_fn, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data); } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } if (retval) { igraphmodule_handle_igraph_error(); return NULL; } if (!map12 && !map21) { if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } else { PyObject *m1, *m2; if (map12) { m1 = igraphmodule_vector_t_to_PyList(map12, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map12); if (!m1) { if (map21) igraph_vector_destroy(map21); return NULL; } } else { m1 = Py_None; Py_INCREF(m1); } if (map21) { m2 = igraphmodule_vector_t_to_PyList(map21, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map21); if (!m2) { Py_DECREF(m1); return NULL; } } else { m2 = Py_None; Py_INCREF(m2); } return Py_BuildValue("ONN", result ? Py_True : Py_False, m1, m2); } } /** \ingroup python_interface_graph * \brief Counts the number of isomorphisms of two given graphs * * The actual code is almost the same as igraphmodule_Graph_count_subisomorphisms. * Make sure you correct bugs in both interfaces if applicable! * * \sa igraph_count_isomorphisms_vf2 */ PyObject *igraphmodule_Graph_count_isomorphisms_vf2(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_integer_t result = 0; PyObject *o = Py_None; PyObject *color1_o=Py_None, *color2_o=Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; igraphmodule_GraphObject *other; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "|O!OOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &node_compat_fn, &edge_compat_fn)) return NULL; if (o == Py_None) other=self; else other=(igraphmodule_GraphObject*)o; if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = 0; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (igraph_count_isomorphisms_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } igraphmodule_handle_igraph_error(); return NULL; } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } return PyLong_FromLong(result); } /** \ingroup python_interface_graph * \brief Returns all isomorphisms of two given graphs * * The actual code is almost the same as igraphmodule_Graph_get_subisomorphisms. * Make sure you correct bugs in both interfaces if applicable! * * \sa igraph_get_isomorphisms_vf2 */ PyObject *igraphmodule_Graph_get_isomorphisms_vf2(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_ptr_t result; PyObject *o = Py_None; PyObject *color1_o = Py_None, *color2_o = Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; PyObject *res; igraphmodule_GraphObject *other; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "|O!OOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &node_compat_fn, &edge_compat_fn)) return NULL; if (o == Py_None) other=self; else other=(igraphmodule_GraphObject*)o; if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } if (igraph_vector_ptr_init(&result, 0)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } return igraphmodule_handle_igraph_error(); } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = 0; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (igraph_get_isomorphisms_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data)) { igraphmodule_handle_igraph_error(); if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } igraph_vector_ptr_destroy(&result); return NULL; } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } res = igraphmodule_vector_ptr_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&result, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&result); return res; } /** \ingroup python_interface_graph * \brief Determines whether a subgraph of the graph is isomorphic to another graph * using the VF2 algorithm. * * \sa igraph_subisomorphic_vf2 */ PyObject *igraphmodule_Graph_subisomorphic_vf2(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_bool_t result = 0; PyObject *o, *return1=Py_False, *return2=Py_False; PyObject *color1_o=Py_None, *color2_o=Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *callback_fn=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; igraphmodule_GraphObject *other; igraph_vector_t mapping_12, mapping_21, *map12=0, *map21=0; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; int retval; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "return_mapping_12", "return_mapping_21", "callback", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O!|OOOOOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &return1, &return2, &callback_fn, &node_compat_fn, &edge_compat_fn)) return NULL; other=(igraphmodule_GraphObject*)o; if (callback_fn != Py_None && !PyCallable_Check(callback_fn)) { PyErr_SetString(PyExc_TypeError, "callback must be None or callable"); return NULL; } if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } if (PyObject_IsTrue(return1)) { igraph_vector_init(&mapping_12, 0); map12 = &mapping_12; } if (PyObject_IsTrue(return2)) { igraph_vector_init(&mapping_21, 0); map21 = &mapping_21; } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = callback_fn == Py_None ? 0 : callback_fn; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (callback_data.callback_fn == 0) { retval = igraph_subisomorphic_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, map12, map21, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data); } else { retval = igraph_subisomorphic_function_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, map12, map21, igraphmodule_i_Graph_isomorphic_vf2_callback_fn, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data); } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } if (retval) { igraphmodule_handle_igraph_error(); return NULL; } if (!map12 && !map21) { if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } else { PyObject *m1, *m2; if (map12) { m1 = igraphmodule_vector_t_to_PyList(map12, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map12); if (!m1) { if (map21) igraph_vector_destroy(map21); return NULL; } } else { m1 = Py_None; Py_INCREF(m1); } if (map21) { m2 = igraphmodule_vector_t_to_PyList(map21, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map21); if (!m2) { Py_DECREF(m1); return NULL; } } else { m2 = Py_None; Py_INCREF(m2); } return Py_BuildValue("ONN", result ? Py_True : Py_False, m1, m2); } } /** \ingroup python_interface_graph * \brief Counts the number of subisomorphisms of two given graphs * * The actual code is almost the same as igraphmodule_Graph_count_isomorphisms. * Make sure you correct bugs in both interfaces if applicable! * * \sa igraph_count_subisomorphisms_vf2 */ PyObject *igraphmodule_Graph_count_subisomorphisms_vf2(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_integer_t result = 0; PyObject *o = Py_None; PyObject *color1_o = Py_None, *color2_o = Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_GraphObject *other; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O!|OOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &node_compat_fn, &edge_compat_fn)) return NULL; other=(igraphmodule_GraphObject*)o; if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = 0; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (igraph_count_subisomorphisms_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data)) { igraphmodule_handle_igraph_error(); if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } return NULL; } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } return PyLong_FromLong(result); } /** \ingroup python_interface_graph * \brief Returns all subisomorphisms of two given graphs * * The actual code is almost the same as igraphmodule_Graph_get_isomorphisms. * Make sure you correct bugs in both interfaces if applicable! * * \sa igraph_get_isomorphisms_vf2 */ PyObject *igraphmodule_Graph_get_subisomorphisms_vf2(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { igraph_vector_ptr_t result; PyObject *o; PyObject *color1_o=Py_None, *color2_o=Py_None; PyObject *edge_color1_o=Py_None, *edge_color2_o=Py_None; PyObject *node_compat_fn=Py_None, *edge_compat_fn=Py_None; PyObject *res; igraphmodule_GraphObject *other; igraph_vector_int_t *color1=0, *color2=0; igraph_vector_int_t *edge_color1=0, *edge_color2=0; igraphmodule_i_Graph_isomorphic_vf2_callback_data_t callback_data; static char *kwlist[] = { "other", "color1", "color2", "edge_color1", "edge_color2", "node_compat_fn", "edge_compat_fn", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O!|OOOOOO", kwlist, &igraphmodule_GraphType, &o, &color1_o, &color2_o, &edge_color1_o, &edge_color2_o, &node_compat_fn, &edge_compat_fn)) return NULL; if (igraph_vector_ptr_init(&result, 0)) { return igraphmodule_handle_igraph_error(); } other=(igraphmodule_GraphObject*)o; if (node_compat_fn != Py_None && !PyCallable_Check(node_compat_fn)) { PyErr_SetString(PyExc_TypeError, "node_compat_fn must be None or callable"); return NULL; } if (edge_compat_fn != Py_None && !PyCallable_Check(edge_compat_fn)) { PyErr_SetString(PyExc_TypeError, "edge_compat_fn must be None or callable"); return NULL; } if (igraphmodule_attrib_to_vector_int_t(color1_o, self, &color1, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_int_t(color2_o, other, &color2, ATTRIBUTE_TYPE_VERTEX)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color1_o, self, &edge_color1, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } return NULL; } if (igraphmodule_attrib_to_vector_int_t(edge_color2_o, other, &edge_color2, ATTRIBUTE_TYPE_EDGE)) { if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } return NULL; } callback_data.graph1 = (PyObject*)self; callback_data.graph2 = (PyObject*)other; callback_data.callback_fn = 0; callback_data.node_compat_fn = node_compat_fn == Py_None ? 0 : node_compat_fn; callback_data.edge_compat_fn = edge_compat_fn == Py_None ? 0 : edge_compat_fn; if (igraph_get_subisomorphisms_vf2(&self->g, &other->g, color1, color2, edge_color1, edge_color2, &result, node_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_node_compat_fn, edge_compat_fn == Py_None ? 0 : igraphmodule_i_Graph_isomorphic_vf2_edge_compat_fn, &callback_data)) { igraphmodule_handle_igraph_error(); if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } igraph_vector_ptr_destroy(&result); return NULL; } if (color1) { igraph_vector_int_destroy(color1); free(color1); } if (color2) { igraph_vector_int_destroy(color2); free(color2); } if (edge_color1) { igraph_vector_int_destroy(edge_color1); free(edge_color1); } if (edge_color2) { igraph_vector_int_destroy(edge_color2); free(edge_color2); } res = igraphmodule_vector_ptr_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&result, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&result); return res; } /** \ingroup python_interface_graph * \brief Determines whether a subgraph of the graph is isomorphic to another graph * using the LAD algorithm. * * \sa igraph_subisomorphic_lad */ PyObject *igraphmodule_Graph_subisomorphic_lad(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { igraph_bool_t result = 0; PyObject *o, *return_mapping=Py_False, *domains_o=Py_None, *induced=Py_False; float time_limit = 0; igraphmodule_GraphObject *other; igraph_vector_ptr_t domains; igraph_vector_ptr_t* p_domains = 0; igraph_vector_t mapping, *map=0; static char *kwlist[] = { "pattern", "domains", "induced", "time_limit", "return_mapping", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|OOfO", kwlist, &igraphmodule_GraphType, &o, &domains_o, &induced, &time_limit, &return_mapping)) return NULL; other=(igraphmodule_GraphObject*)o; if (domains_o != Py_None) { if (igraphmodule_PyObject_to_vector_ptr_t(domains_o, &domains, 1)) return NULL; p_domains = &domains; } if (PyObject_IsTrue(return_mapping)) { if (igraph_vector_init(&mapping, 0)) { if (p_domains) igraph_vector_ptr_destroy_all(p_domains); igraphmodule_handle_igraph_error(); return NULL; } map = &mapping; } if (igraph_subisomorphic_lad(&other->g, &self->g, p_domains, &result, map, 0, PyObject_IsTrue(induced), (int)time_limit)) { if (p_domains) igraph_vector_ptr_destroy_all(p_domains); igraphmodule_handle_igraph_error(); return NULL; } if (p_domains) igraph_vector_ptr_destroy_all(p_domains); if (!map) { if (result) Py_RETURN_TRUE; Py_RETURN_FALSE; } else { PyObject *m = igraphmodule_vector_t_to_PyList(map, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(map); if (!m) return NULL; return Py_BuildValue("ON", result ? Py_True : Py_False, m); } } /** \ingroup python_interface_graph * \brief Finds all the subisomorphisms of a graph to another graph using the LAD * algorithm * * \sa igraph_subisomorphic_lad */ PyObject *igraphmodule_Graph_get_subisomorphisms_lad( igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject *o, *domains_o=Py_None, *induced=Py_False, *result; float time_limit = 0; igraphmodule_GraphObject *other; igraph_vector_ptr_t domains; igraph_vector_ptr_t* p_domains = 0; igraph_vector_ptr_t mappings; static char *kwlist[] = { "pattern", "domains", "induced", "time_limit", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|OOf", kwlist, &igraphmodule_GraphType, &o, &domains_o, &induced, &time_limit)) return NULL; other=(igraphmodule_GraphObject*)o; if (domains_o != Py_None) { if (igraphmodule_PyObject_to_vector_ptr_t(domains_o, &domains, 1)) return NULL; p_domains = &domains; } if (igraph_vector_ptr_init(&mappings, 0)) { igraphmodule_handle_igraph_error(); if (p_domains) igraph_vector_ptr_destroy_all(p_domains); return NULL; } if (igraph_subisomorphic_lad(&other->g, &self->g, p_domains, 0, 0, &mappings, PyObject_IsTrue(induced), (int)time_limit)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy_all(&mappings); if (p_domains) igraph_vector_ptr_destroy_all(p_domains); return NULL; } if (p_domains) igraph_vector_ptr_destroy_all(p_domains); result = igraphmodule_vector_ptr_t_to_PyList(&mappings, IGRAPHMODULE_TYPE_INT); igraph_vector_ptr_destroy_all(&mappings); return result; } /********************************************************************** * Graph attribute handling * **********************************************************************/ /** \ingroup python_interface_graph * \brief Returns the number of graph attributes */ Py_ssize_t igraphmodule_Graph_attribute_count(igraphmodule_GraphObject * self) { return PyDict_Size(((PyObject **) self->g.attr)[ATTRHASH_IDX_GRAPH]); } /** \ingroup python_interface_graph * \brief Handles the subscript operator on the graph. * * When the subscript is a string, returns the corresponding value of the * given attribute in the graph. When the subscript is a tuple of length * 2, retrieves the adjacency matrix representation of the graph between * some vertices. */ PyObject *igraphmodule_Graph_mp_subscript(igraphmodule_GraphObject * self, PyObject * s) { PyObject *result = 0; if (PyTuple_Check(s) && PyTuple_Size(s) >= 2) { /* Adjacency matrix representation */ PyObject *ri = PyTuple_GET_ITEM(s, 0); PyObject *ci = PyTuple_GET_ITEM(s, 1); PyObject *attr; if (PyTuple_Size(s) == 2) { attr = 0; } else if (PyTuple_Size(s) == 3) { attr = PyTuple_GET_ITEM(s, 2); } else { PyErr_SetString(PyExc_TypeError, "adjacency matrix indexing must use at most three arguments"); return 0; } return igraphmodule_Graph_adjmatrix_get_index(&self->g, ri, ci, attr); } /* Ordinary attribute retrieval */ result = PyDict_GetItem(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_GRAPH], s); if (result) { Py_INCREF(result); return result; } /* result is NULL, check whether there was an error */ if (!PyErr_Occurred()) PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return NULL; } /** \ingroup python_interface_graph * \brief Handles the subscript assignment operator on the graph. * * If k is a string, sets the value of the corresponding attribute of the graph. * If k is a tuple of length 2, sets part of the adjacency matrix. * * \return 0 if everything's ok, -1 in case of error */ int igraphmodule_Graph_mp_assign_subscript(igraphmodule_GraphObject * self, PyObject * k, PyObject * v) { PyObject* dict = ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_GRAPH]; if (PyTuple_Check(k) && PyTuple_Size(k) >= 2) { /* Adjacency matrix representation */ PyObject *ri, *ci, *attr; if (v == NULL) { PyErr_SetString(PyExc_NotImplementedError, "cannot delete parts " "of the adjacency matrix of a graph"); return -1; } ri = PyTuple_GET_ITEM(k, 0); ci = PyTuple_GET_ITEM(k, 1); if (PyTuple_Size(k) == 2) { attr = 0; } else if (PyTuple_Size(k) == 3) { attr = PyTuple_GET_ITEM(k, 2); } else { PyErr_SetString(PyExc_TypeError, "adjacency matrix indexing must use at most three arguments"); return 0; } return igraphmodule_Graph_adjmatrix_set_index(&self->g, ri, ci, attr, v); } /* Ordinary attribute setting/deletion */ if (v == NULL) return PyDict_DelItem(dict, k); if (PyDict_SetItem(dict, k, v) == -1) return -1; return 0; } /** \ingroup python_interface_graph * \brief Returns the attribute list of the graph */ PyObject *igraphmodule_Graph_attributes(igraphmodule_GraphObject * self) { return PyDict_Keys(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_GRAPH]); } /** \ingroup python_interface_graph * \brief Returns the attribute list of the graph's vertices */ PyObject *igraphmodule_Graph_vertex_attributes(igraphmodule_GraphObject * self) { return PyDict_Keys(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_VERTEX]); } /** \ingroup python_interface_graph * \brief Returns the attribute list of the graph's edges */ PyObject *igraphmodule_Graph_edge_attributes(igraphmodule_GraphObject * self) { return PyDict_Keys(ATTR_STRUCT_DICT(&self->g)[ATTRHASH_IDX_EDGE]); } /********************************************************************** * Graph operations * * Disjoint union, union and intersection are in operators.c * **********************************************************************/ /** \ingroup python_interface_graph * \brief Creates the difference of two graphs (operator version) */ PyObject *igraphmodule_Graph_difference(igraphmodule_GraphObject * self, PyObject * other) { igraphmodule_GraphObject *o, *result; igraph_t g; if (!PyObject_TypeCheck(other, &igraphmodule_GraphType)) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } o = (igraphmodule_GraphObject *) other; if (igraph_difference(&g, &self->g, &o->g)) { igraphmodule_handle_igraph_error(); return NULL; } /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ CREATE_GRAPH(result, g); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Creates the complementer of a graph */ PyObject *igraphmodule_Graph_complementer(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "loops", NULL }; igraphmodule_GraphObject *result; PyObject *o = Py_True; igraph_t g; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &o)) return NULL; if (igraph_complementer(&g, &self->g, PyObject_IsTrue(o))) { igraphmodule_handle_igraph_error(); return NULL; } /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ CREATE_GRAPH(result, g); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Creates the complementer of a graph (operator version) */ PyObject *igraphmodule_Graph_complementer_op(igraphmodule_GraphObject * self) { igraphmodule_GraphObject *result; igraph_t g; if (igraph_complementer(&g, &self->g, 0)) { igraphmodule_handle_igraph_error(); return NULL; } /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ CREATE_GRAPH(result, g); return (PyObject *) result; } /** \ingroup python_interface_graph * \brief Creates the composition of two graphs */ PyObject *igraphmodule_Graph_compose(igraphmodule_GraphObject * self, PyObject * other) { igraphmodule_GraphObject *o, *result; igraph_t g; if (!PyObject_TypeCheck(other, &igraphmodule_GraphType)) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } o = (igraphmodule_GraphObject *) other; if (igraph_compose(&g, &self->g, &o->g, /*edge_map1=*/ 0, /*edge_map2=*/ 0)) { igraphmodule_handle_igraph_error(); return NULL; } /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ CREATE_GRAPH(result, g); return (PyObject *) result; } /********************************************************************** * Graph traversal algorithms * **********************************************************************/ /** \ingroup python_interface_graph * \brief Conducts a breadth first search (BFS) on the graph */ PyObject *igraphmodule_Graph_bfs(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vid", "mode", NULL }; long vid; PyObject *l1, *l2, *l3, *result, *mode_o=Py_None; igraph_neimode_t mode = IGRAPH_OUT; igraph_vector_t vids; igraph_vector_t layers; igraph_vector_t parents; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|O", kwlist, &vid, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_vector_init(&vids, igraph_vcount(&self->g))) return igraphmodule_handle_igraph_error(); if (igraph_vector_init(&layers, igraph_vcount(&self->g))) { igraph_vector_destroy(&vids); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&parents, igraph_vcount(&self->g))) { igraph_vector_destroy(&vids); igraph_vector_destroy(&parents); return igraphmodule_handle_igraph_error(); } if (igraph_bfs_simple (&self->g, (igraph_integer_t) vid, mode, &vids, &layers, &parents)) { igraphmodule_handle_igraph_error(); return NULL; } l1 = igraphmodule_vector_t_to_PyList(&vids, IGRAPHMODULE_TYPE_INT); l2 = igraphmodule_vector_t_to_PyList(&layers, IGRAPHMODULE_TYPE_INT); l3 = igraphmodule_vector_t_to_PyList(&parents, IGRAPHMODULE_TYPE_INT); if (l1 && l2 && l3) { result = Py_BuildValue("NNN", l1, l2, l3); /* references stolen */ } else { if (l1) { Py_DECREF(l1); } if (l2) { Py_DECREF(l2); } if (l3) { Py_DECREF(l3); } result = NULL; } igraph_vector_destroy(&vids); igraph_vector_destroy(&layers); igraph_vector_destroy(&parents); return result; } /** \ingroup python_interface_graph * \brief Constructs a breadth first search (BFS) iterator of the graph */ PyObject *igraphmodule_Graph_bfsiter(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "vid", "mode", "advanced", NULL }; PyObject *root, *adv = Py_False, *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_OUT; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O|OO", kwlist, &root, &mode_o, &adv)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; return igraphmodule_BFSIter_new(self, root, mode, PyObject_IsTrue(adv)); } /** \ingroup python_interface_graph * \brief Unfolds a graph into a tree using BFS */ PyObject *igraphmodule_Graph_unfold_tree(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "roots", "mode", NULL }; igraphmodule_GraphObject *result_o; PyObject *mapping_o, *mode_o=Py_None, *roots_o=Py_None; igraph_neimode_t mode = IGRAPH_OUT; igraph_vs_t vs; igraph_vector_t mapping, vids; igraph_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &roots_o, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_vs_t(roots_o, &vs, &self->g, 0, 0)) return NULL; if (igraph_vector_init(&mapping, igraph_vcount(&self->g))) { igraph_vs_destroy(&vs); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&vids, 0)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&mapping); return igraphmodule_handle_igraph_error(); } if (igraph_vs_as_vector(&self->g, vs, &vids)) { igraph_vs_destroy(&vs); igraph_vector_destroy(&vids); igraph_vector_destroy(&mapping); return igraphmodule_handle_igraph_error(); } igraph_vs_destroy(&vs); if (igraph_unfold_tree(&self->g, &result, mode, &vids, &mapping)) { igraph_vector_destroy(&vids); igraph_vector_destroy(&mapping); igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_destroy(&vids); mapping_o = igraphmodule_vector_t_to_PyList(&mapping, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&mapping); if (!mapping_o) { igraph_destroy(&result); return NULL; } CREATE_GRAPH(result_o, result); return Py_BuildValue("NN", result_o, mapping_o); } /** \ingroup python_interface_graph * \brief Constructs a depth first search (DFS) iterator of the graph */ PyObject *igraphmodule_Graph_dfsiter(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "vid", "mode", "advanced", NULL }; PyObject *root, *adv = Py_False, *mode_o = Py_None; igraph_neimode_t mode = IGRAPH_OUT; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O|OO", kwlist, &root, &mode_o, &adv)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; return igraphmodule_DFSIter_new(self, root, mode, PyObject_IsTrue(adv)); } /********************************************************************** * Dominator * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates the dominator tree for the graph */ PyObject *igraphmodule_Graph_dominator(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "vid", "mode", NULL }; PyObject *list = Py_None; PyObject *mode_o = Py_None; long int root = -1; igraph_vector_t dom; igraph_neimode_t mode = IGRAPH_OUT; int res ; if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|O", kwlist, &root, &mode_o)) { return NULL; } if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) { return NULL; } if (mode == IGRAPH_ALL) { mode = IGRAPH_OUT; } if (igraph_vector_init(&dom, 0)) { return NULL; } res = igraph_dominator_tree(&self->g, root, &dom, NULL, NULL, mode); if(res) { igraph_vector_destroy(&dom); return NULL; } list = igraphmodule_vector_t_to_PyList(&dom, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&dom); return list; } /********************************************************************** * Maximum flows * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates the value of the maximum flow in the graph */ PyObject *igraphmodule_Graph_maxflow_value(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; PyObject *capacity_object = Py_None; igraph_vector_t capacity_vector; igraph_real_t result; long int vid1 = -1, vid2 = -1; igraph_integer_t v1, v2; igraph_maxflow_stats_t stats; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|O", kwlist, &vid1, &vid2, &capacity_object)) return NULL; v1 = (igraph_integer_t) vid1; v2 = (igraph_integer_t) vid2; if (igraphmodule_PyObject_to_attribute_values(capacity_object, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); if (igraph_maxflow_value(&self->g, &result, v1, v2, &capacity_vector, &stats)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } igraph_vector_destroy(&capacity_vector); return PyFloat_FromDouble(result); } /** \ingroup python_interface_graph * \brief Calculates the maximum flow of the graph */ PyObject *igraphmodule_Graph_maxflow(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; PyObject *capacity_object = Py_None, *flow_o, *cut_o, *partition_o; igraph_vector_t capacity_vector; igraph_real_t result; long int vid1 = -1, vid2 = -1; igraph_integer_t v1, v2; igraph_vector_t flow, cut, partition; igraph_maxflow_stats_t stats; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ll|O", kwlist, &vid1, &vid2, &capacity_object)) return NULL; v1 = (igraph_integer_t) vid1; v2 = (igraph_integer_t) vid2; if (igraphmodule_PyObject_to_attribute_values(capacity_object, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); if (igraph_vector_init(&flow, 0)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&cut, 0)) { igraph_vector_destroy(&capacity_vector); igraph_vector_destroy(&flow); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&partition, 0)) { igraph_vector_destroy(&capacity_vector); igraph_vector_destroy(&flow); igraph_vector_destroy(&cut); return igraphmodule_handle_igraph_error(); } if (igraph_maxflow(&self->g, &result, &flow, &cut, &partition, 0, v1, v2, &capacity_vector, &stats)) { igraph_vector_destroy(&capacity_vector); igraph_vector_destroy(&flow); igraph_vector_destroy(&cut); igraph_vector_destroy(&partition); return igraphmodule_handle_igraph_error(); } igraph_vector_destroy(&capacity_vector); flow_o = igraphmodule_vector_t_to_PyList(&flow, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&flow); if (flow_o == NULL) { igraph_vector_destroy(&cut); igraph_vector_destroy(&partition); return NULL; } cut_o = igraphmodule_vector_t_to_PyList(&cut, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&cut); if (cut_o == NULL) { igraph_vector_destroy(&partition); return NULL; } partition_o = igraphmodule_vector_t_to_PyList(&partition, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&partition); if (partition_o == NULL) return NULL; return Py_BuildValue("dNNN", (double)result, flow_o, cut_o, partition_o); } /********************************************************************** * Minimum cuts (edge separators) * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates all s-t cuts in a graph */ PyObject *igraphmodule_Graph_all_st_cuts(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", NULL }; igraph_integer_t source, target; igraph_vector_ptr_t cuts, partition1s; PyObject *source_o, *target_o; PyObject *cuts_o, *partition1s_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &source_o, &target_o)) return NULL; if (igraphmodule_PyObject_to_vid(source_o, &source, &self->g)) return NULL; if (igraphmodule_PyObject_to_vid(target_o, &target, &self->g)) return NULL; if (igraph_vector_ptr_init(&partition1s, 0)) { return igraphmodule_handle_igraph_error(); } if (igraph_vector_ptr_init(&cuts, 0)) { igraph_vector_ptr_destroy(&partition1s); return igraphmodule_handle_igraph_error(); } if (igraph_all_st_cuts(&self->g, &cuts, &partition1s, source, target)) { igraph_vector_ptr_destroy(&cuts); igraph_vector_ptr_destroy(&partition1s); return igraphmodule_handle_igraph_error(); } IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&cuts, igraph_vector_destroy); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&partition1s, igraph_vector_destroy); cuts_o = igraphmodule_vector_ptr_t_to_PyList(&cuts, IGRAPHMODULE_TYPE_INT); igraph_vector_ptr_destroy_all(&cuts); if (cuts_o == NULL) { igraph_vector_ptr_destroy_all(&partition1s); return NULL; } partition1s_o = igraphmodule_vector_ptr_t_to_PyList(&partition1s, IGRAPHMODULE_TYPE_INT); igraph_vector_ptr_destroy_all(&partition1s); if (partition1s_o == NULL) return NULL; return Py_BuildValue("NN", cuts_o, partition1s_o); } /** \ingroup python_interface_graph * \brief Calculates all minimum s-t cuts in a graph */ PyObject *igraphmodule_Graph_all_st_mincuts(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; igraph_integer_t source, target; igraph_real_t value; igraph_vector_ptr_t cuts, partition1s; igraph_vector_t capacity_vector; PyObject *source_o, *target_o, *capacity_o = Py_None; PyObject *cuts_o, *partition1s_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOO", kwlist, &source_o, &target_o, &capacity_o)) return NULL; if (igraphmodule_PyObject_to_vid(source_o, &source, &self->g)) return NULL; if (igraphmodule_PyObject_to_vid(target_o, &target, &self->g)) return NULL; if (igraph_vector_ptr_init(&partition1s, 0)) { return igraphmodule_handle_igraph_error(); } if (igraph_vector_ptr_init(&cuts, 0)) { igraph_vector_ptr_destroy(&partition1s); return igraphmodule_handle_igraph_error(); } if (igraphmodule_PyObject_to_attribute_values(capacity_o, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) { igraph_vector_ptr_destroy(&cuts); igraph_vector_ptr_destroy(&partition1s); return igraphmodule_handle_igraph_error(); } if (igraph_all_st_mincuts(&self->g, &value, &cuts, &partition1s, source, target, &capacity_vector)) { igraph_vector_ptr_destroy(&cuts); igraph_vector_ptr_destroy(&partition1s); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } igraph_vector_destroy(&capacity_vector); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&cuts, igraph_vector_destroy); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&partition1s, igraph_vector_destroy); cuts_o = igraphmodule_vector_ptr_t_to_PyList(&cuts, IGRAPHMODULE_TYPE_INT); igraph_vector_ptr_destroy_all(&cuts); if (cuts_o == NULL) { igraph_vector_ptr_destroy_all(&partition1s); return NULL; } partition1s_o = igraphmodule_vector_ptr_t_to_PyList(&partition1s, IGRAPHMODULE_TYPE_INT); igraph_vector_ptr_destroy_all(&partition1s); if (partition1s_o == NULL) return NULL; return Py_BuildValue("dNN", (double)value, cuts_o, partition1s_o); } /** \ingroup python_interface_graph * \brief Calculates the value of the minimum cut in the graph */ PyObject *igraphmodule_Graph_mincut_value(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; PyObject *capacity_object = Py_None; igraph_vector_t capacity_vector; igraph_real_t result, mincut; igraph_integer_t v1, v2; long vid1 = -1, vid2 = -1; long n; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|llO", kwlist, &vid1, &vid2, &capacity_object)) return NULL; if (igraphmodule_PyObject_to_attribute_values(capacity_object, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); v1 = (igraph_integer_t) vid1; v2 = (igraph_integer_t) vid2; if (v1 == -1 && v2 == -1) { if (igraph_mincut_value(&self->g, &result, &capacity_vector)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } } else if (v1 == -1) { n = igraph_vcount(&self->g); result = -1; for (v1 = 0; v1 < n; v1++) { if (v2 == v1) continue; if (igraph_st_mincut_value(&self->g, &mincut, v1, v2, &capacity_vector)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (result < 0 || result > mincut) result = mincut; } if (result < 0) result = 0.0; } else if (v2 == -1) { n = igraph_vcount(&self->g); result = -1; for (v2 = 0; v2 < n; v2++) { if (v2 == v1) continue; if (igraph_st_mincut_value(&self->g, &mincut, v1, v2, &capacity_vector)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (result < 0.0 || result > mincut) result = mincut; } if (result < 0) result = 0.0; } else { if (igraph_st_mincut_value(&self->g, &result, v1, v2, &capacity_vector)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } } igraph_vector_destroy(&capacity_vector); return PyFloat_FromDouble(result); } /** \ingroup python_interface_graph * \brief Calculates a minimum cut in a graph */ PyObject *igraphmodule_Graph_mincut(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; PyObject *capacity_object = Py_None, *cut_o, *part_o, *part2_o, *result; PyObject *source_o = Py_None, *target_o = Py_None; int retval; igraph_vector_t capacity_vector; igraph_real_t value; igraph_vector_t partition, partition2, cut; igraph_integer_t source = -1, target = -1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &source_o, &target_o, &capacity_object)) return NULL; if (source_o != Py_None && igraphmodule_PyObject_to_vid(source_o, &source, &self->g)) return NULL; if (target_o != Py_None && igraphmodule_PyObject_to_vid(target_o, &target, &self->g)) return NULL; if (igraphmodule_PyObject_to_attribute_values(capacity_object, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); if (igraph_vector_init(&partition, 0)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&partition2, 0)) { igraph_vector_destroy(&partition); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&cut, 0)) { igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (source == -1 && target == -1) { retval = igraph_mincut(&self->g, &value, &partition, &partition2, &cut, &capacity_vector); } else if (source == -1 || target == -1) { retval = IGRAPH_UNIMPLEMENTED; PyErr_SetString(PyExc_ValueError, "if you specify one of 'source' and 'target', " "you must specify the other one as well"); } else { retval = igraph_st_mincut(&self->g, &value, &cut, &partition, &partition2, source, target, &capacity_vector); } if (retval) { igraph_vector_destroy(&cut); igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); igraph_vector_destroy(&capacity_vector); if (!PyErr_Occurred()) igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_destroy(&capacity_vector); cut_o=igraphmodule_vector_t_to_PyList(&cut, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&cut); if (!cut_o) { igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); return 0; } part_o=igraphmodule_vector_t_to_PyList(&partition, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&partition); if (!part_o) { Py_DECREF(cut_o); igraph_vector_destroy(&partition2); return 0; } part2_o=igraphmodule_vector_t_to_PyList(&partition2, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&partition2); if (!part2_o) { Py_DECREF(part_o); Py_DECREF(cut_o); return 0; } result = Py_BuildValue("dNNN", (double)value, cut_o, part_o, part2_o); return result; } /** \ingroup python_interface_graph * \brief Calculates the Gomory-Hu tree of an undirected graph */ PyObject *igraphmodule_Graph_gomory_hu_tree(igraphmodule_GraphObject * self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "capacity", NULL }; igraph_vector_t capacity_vector; igraph_vector_t flow_vector; igraph_t tree; PyObject *capacity_o = Py_None; PyObject *flow_o; igraphmodule_GraphObject *tree_o; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &capacity_o)) return NULL; if (igraphmodule_PyObject_to_attribute_values(capacity_o, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); if (igraph_vector_init(&flow_vector, 0)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_gomory_hu_tree(&self->g, &tree, &flow_vector, &capacity_vector)) { igraph_vector_destroy(&flow_vector); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } igraph_vector_destroy(&capacity_vector); flow_o = igraphmodule_vector_t_to_PyList(&flow_vector, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&flow_vector); if (!flow_o) { igraph_destroy(&tree); return 0; } CREATE_GRAPH(tree_o, tree); if (!tree_o) { igraph_destroy(&tree); return 0; } return Py_BuildValue("NN", tree_o, flow_o); } /** \ingroup python_interface_graph * \brief Calculates a minimum s-t cut in a graph */ PyObject *igraphmodule_Graph_st_mincut(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "source", "target", "capacity", NULL }; igraph_integer_t source, target; PyObject *cut_o, *part_o, *part2_o, *result; PyObject *source_o, *target_o, *capacity_o = Py_None; igraph_vector_t capacity_vector; igraph_real_t value; igraph_vector_t partition, partition2, cut; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOO", kwlist, &source_o, &target_o, &capacity_o)) return NULL; if (igraphmodule_PyObject_to_vid(source_o, &source, &self->g)) return NULL; if (igraphmodule_PyObject_to_vid(target_o, &target, &self->g)) return NULL; if (igraphmodule_PyObject_to_attribute_values(capacity_o, &capacity_vector, self, ATTRHASH_IDX_EDGE, 1.0)) return igraphmodule_handle_igraph_error(); if (igraph_vector_init(&partition, 0)) { igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&partition2, 0)) { igraph_vector_destroy(&partition); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&cut, 0)) { igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } if (igraph_st_mincut(&self->g, &value, &cut, &partition, &partition2, source, target, &capacity_vector)) { igraph_vector_destroy(&cut); igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); igraph_vector_destroy(&capacity_vector); return igraphmodule_handle_igraph_error(); } igraph_vector_destroy(&capacity_vector); cut_o=igraphmodule_vector_t_to_PyList(&cut, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&cut); if (!cut_o) { igraph_vector_destroy(&partition); igraph_vector_destroy(&partition2); return NULL; } part_o=igraphmodule_vector_t_to_PyList(&partition, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&partition); if (!part_o) { Py_DECREF(cut_o); igraph_vector_destroy(&partition2); return NULL; } part2_o=igraphmodule_vector_t_to_PyList(&partition2, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&partition2); if (!part2_o) { Py_DECREF(part_o); Py_DECREF(cut_o); return NULL; } result = Py_BuildValue("dNNN", (double)value, cut_o, part_o, part2_o); return result; } /********************************************************************** * Vertex separators * **********************************************************************/ /** \ingroup python_interface_graph * \brief Returns all minimal s-t separators of a graph */ PyObject *igraphmodule_Graph_all_minimal_st_separators( igraphmodule_GraphObject * self) { PyObject* result_o; igraph_vector_ptr_t result; if (igraph_vector_ptr_init(&result, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_all_minimal_st_separators(&self->g, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy(&result); return NULL; } result_o = igraphmodule_vector_ptr_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&result, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&result); return result_o; } /** \ingroup python_interface_graph * \brief Checks whether a given vertex set is a vertex separator */ PyObject *igraphmodule_Graph_is_separator(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject* list = Py_None; igraph_bool_t result; igraph_vs_t vs; static char *kwlist[] = { "vertices", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, 0, 0)) { return NULL; } if (igraph_is_separator(&self->g, vs, &result)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); return NULL; } igraph_vs_destroy(&vs); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Checks whether a given vertex set is a minimal vertex separator */ PyObject *igraphmodule_Graph_is_minimal_separator(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { PyObject* list = Py_None; igraph_bool_t result; igraph_vs_t vs; static char *kwlist[] = { "vertices", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) return NULL; if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, 0, 0)) { return NULL; } if (igraph_is_minimal_separator(&self->g, vs, &result)) { igraphmodule_handle_igraph_error(); igraph_vs_destroy(&vs); return NULL; } igraph_vs_destroy(&vs); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } /** \ingroup python_interface_graph * \brief Returns the minimum size separators of the graph */ PyObject *igraphmodule_Graph_minimum_size_separators( igraphmodule_GraphObject * self) { PyObject* result_o; igraph_vector_ptr_t result; if (igraph_vector_ptr_init(&result, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_minimum_size_separators(&self->g, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_ptr_destroy(&result); return NULL; } result_o = igraphmodule_vector_ptr_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&result, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&result); return result_o; } /********************************************************************** * Cohesive blocks * **********************************************************************/ /** \ingroup python_interface_graph * \brief Calculates the cohesive block structure of a graph */ PyObject *igraphmodule_Graph_cohesive_blocks(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { PyObject *blocks_o, *cohesion_o, *parents_o, *result_o; igraph_vector_ptr_t blocks; igraph_vector_t cohesion, parents; if (igraph_vector_ptr_init(&blocks, 0)) { igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&cohesion, 0)) { igraph_vector_ptr_destroy(&blocks); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_vector_init(&parents, 0)) { igraph_vector_ptr_destroy(&blocks); igraph_vector_destroy(&cohesion); igraphmodule_handle_igraph_error(); return NULL; } if (igraph_cohesive_blocks(&self->g, &blocks, &cohesion, &parents, 0)) { igraph_vector_ptr_destroy(&blocks); igraph_vector_destroy(&cohesion); igraph_vector_destroy(&parents); igraphmodule_handle_igraph_error(); return NULL; } blocks_o = igraphmodule_vector_ptr_t_to_PyList(&blocks, IGRAPHMODULE_TYPE_INT); IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&blocks, igraph_vector_destroy); igraph_vector_ptr_destroy_all(&blocks); if (blocks_o == NULL) { igraph_vector_destroy(&parents); igraph_vector_destroy(&cohesion); return NULL; } cohesion_o = igraphmodule_vector_t_to_PyList(&cohesion, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&cohesion); if (cohesion_o == NULL) { Py_DECREF(blocks_o); igraph_vector_destroy(&parents); return NULL; } parents_o = igraphmodule_vector_t_to_PyList(&parents, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&parents); if (parents_o == NULL) { Py_DECREF(blocks_o); Py_DECREF(cohesion_o); return NULL; } result_o = Py_BuildValue("NNN", blocks_o, cohesion_o, parents_o); if (result_o == NULL) { Py_DECREF(parents_o); Py_DECREF(blocks_o); Py_DECREF(cohesion_o); return NULL; } return result_o; } /********************************************************************** * Cliques and independent sets * **********************************************************************/ /** \ingroup python_interface_graph * \brief Find all or some cliques in a graph */ PyObject *igraphmodule_Graph_cliques(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "min", "max", NULL }; PyObject *list, *item; long int min_size = 0, max_size = 0; long int i, j, n; igraph_vector_ptr_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ll", kwlist, &min_size, &max_size)) return NULL; if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_cliques(&self->g, &result, (igraph_integer_t) min_size, (igraph_integer_t) max_size)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (long)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } /** \ingroup python_interface_graph * \brief Find all largest cliques in a graph */ PyObject *igraphmodule_Graph_largest_cliques(igraphmodule_GraphObject * self) { PyObject *list, *item; long int i, j, n; igraph_vector_ptr_t result; if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_largest_cliques(&self->g, &result)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (long)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } /** \ingroup python_interface_graph * \brief Finds a maximum matching in a bipartite graph */ PyObject *igraphmodule_Graph_maximum_bipartite_matching(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds) { static char* kwlist[] = { "types", "weights", "eps", NULL }; PyObject *types_o = Py_None, *weights_o = Py_None, *result_o; igraph_vector_bool_t* types = 0; igraph_vector_t* weights = 0; igraph_vector_long_t result; double eps = -1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Od", kwlist, &types_o, &weights_o, &eps)) return NULL; if (eps < 0) eps = DBL_EPSILON * 1000; if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { if (types != 0) { igraph_vector_bool_destroy(types); free(types); } return NULL; } if (igraph_vector_long_init(&result, 0)) { if (types != 0) { igraph_vector_bool_destroy(types); free(types); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } igraphmodule_handle_igraph_error(); return NULL; } if (igraph_maximum_bipartite_matching(&self->g, types, 0, 0, &result, weights, eps)) { if (types != 0) { igraph_vector_bool_destroy(types); free(types); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } igraph_vector_long_destroy(&result); igraphmodule_handle_igraph_error(); return NULL; } if (types != 0) { igraph_vector_bool_destroy(types); free(types); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } result_o = igraphmodule_vector_long_t_to_PyList(&result); igraph_vector_long_destroy(&result); return result_o; } /** \ingroup python_interface_graph * \brief Find all maximal cliques in a graph */ PyObject *igraphmodule_Graph_maximal_cliques(igraphmodule_GraphObject * self, PyObject* args, PyObject* kwds) { static char* kwlist[] = { "min", "max", "file", NULL }; PyObject *list, *item, *file = Py_None; long int i = 0, j = 0; igraph_integer_t min, max; Py_ssize_t n; igraph_vector_ptr_t result; igraphmodule_filehandle_t filehandle; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|llO", kwlist, &i, &j, &file)) return NULL; min = (igraph_integer_t) i; max = (igraph_integer_t) j; if (file == Py_None) { if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_maximal_cliques(&self->g, &result, min, max)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (Py_ssize_t)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } else { if (igraphmodule_filehandle_init(&filehandle, file, "w")) { return igraphmodule_handle_igraph_error(); } if (igraph_maximal_cliques_file(&self->g, igraphmodule_filehandle_get(&filehandle), min, max)) { igraphmodule_filehandle_destroy(&filehandle); return igraphmodule_handle_igraph_error(); } igraphmodule_filehandle_destroy(&filehandle); Py_RETURN_NONE; } } /** \ingroup python_interface_graph * \brief Returns the clique number of the graph */ PyObject *igraphmodule_Graph_clique_number(igraphmodule_GraphObject * self) { PyObject *result; igraph_integer_t i; if (igraph_clique_number(&self->g, &i)) return igraphmodule_handle_igraph_error(); result = PyLong_FromLong((long)i); return result; } /** \ingroup python_interface_graph * \brief Find all or some independent vertex sets in a graph */ PyObject *igraphmodule_Graph_independent_vertex_sets(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "min", "max", NULL }; PyObject *list, *item; long int min_size = 0, max_size = 0; long int i, j, n; igraph_vector_ptr_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ll", kwlist, &min_size, &max_size)) return NULL; if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_independent_vertex_sets(&self->g, &result, (igraph_integer_t) min_size, (igraph_integer_t) max_size)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (long)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } /** \ingroup python_interface_graph * \brief Find all largest independent_vertex_sets in a graph */ PyObject *igraphmodule_Graph_largest_independent_vertex_sets(igraphmodule_GraphObject * self) { PyObject *list, *item; long int i, j, n; igraph_vector_ptr_t result; if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_largest_independent_vertex_sets(&self->g, &result)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (long)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } /** \ingroup python_interface_graph * \brief Find all maximal independent vertex sets in a graph */ PyObject *igraphmodule_Graph_maximal_independent_vertex_sets(igraphmodule_GraphObject * self) { PyObject *list, *item; long int i, j, n; igraph_vector_ptr_t result; if (igraph_vector_ptr_init(&result, 0)) { PyErr_SetString(PyExc_MemoryError, ""); return NULL; } if (igraph_maximal_independent_vertex_sets(&self->g, &result)) { igraph_vector_ptr_destroy(&result); return igraphmodule_handle_igraph_error(); } n = (long)igraph_vector_ptr_size(&result); list = PyList_New(n); if (!list) return NULL; for (i = 0; i < n; i++) { igraph_vector_t *vec = (igraph_vector_t *) VECTOR(result)[i]; item = igraphmodule_vector_t_to_PyTuple(vec); if (!item) { for (j = i; j < n; j++) igraph_vector_destroy((igraph_vector_t *) VECTOR(result)[j]); igraph_vector_ptr_destroy_all(&result); Py_DECREF(list); return NULL; } else { PyList_SET_ITEM(list, i, item); } igraph_vector_destroy(vec); } igraph_vector_ptr_destroy_all(&result); return list; } /** \ingroup python_interface_graph * \brief Returns the independence number of the graph */ PyObject *igraphmodule_Graph_independence_number(igraphmodule_GraphObject * self) { PyObject *result; igraph_integer_t i; if (igraph_independence_number(&self->g, &i)) return igraphmodule_handle_igraph_error(); result = PyLong_FromLong((long)i); return result; } /********************************************************************** * K-core decomposition * **********************************************************************/ /** \ingroup python_interface_graph * \brief Returns the corenesses of the graph vertices * \return a new PyCObject */ PyObject *igraphmodule_Graph_coreness(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "mode", NULL }; igraph_neimode_t mode = IGRAPH_ALL; igraph_vector_t result; PyObject *o, *mode_o = Py_None; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraph_vector_init(&result, igraph_vcount(&self->g))) return igraphmodule_handle_igraph_error(); if (igraph_coreness(&self->g, &result, mode)) { igraph_vector_destroy(&result); return igraphmodule_handle_igraph_error(); } o = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); return o; } /********************************************************************** * Community structure detection and related routines * **********************************************************************/ /** * Modularity calculation */ PyObject *igraphmodule_Graph_modularity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"membership", "weights", "resolution", "directed", 0}; igraph_vector_t membership; igraph_vector_t *weights=0; double resolution = 1; igraph_real_t modularity; PyObject *mvec, *wvec=Py_None; PyObject *directed = Py_True; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OdO", kwlist, &mvec, &wvec, &resolution, &directed)) return NULL; if (igraphmodule_PyObject_to_vector_t(mvec, &membership, 1)) return NULL; if (igraphmodule_attrib_to_vector_t(wvec, self, &weights, ATTRIBUTE_TYPE_EDGE)){ igraph_vector_destroy(&membership); return NULL; } if (igraph_modularity(&self->g, &membership, weights, resolution, PyObject_IsTrue(directed), &modularity)) { igraph_vector_destroy(&membership); if (weights) { igraph_vector_destroy(weights); free(weights); } return NULL; } igraph_vector_destroy(&membership); if (weights) { igraph_vector_destroy(weights); free(weights); } return PyFloat_FromDouble(modularity); } /** * Newman's edge betweenness method */ PyObject *igraphmodule_Graph_community_edge_betweenness(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "directed", "weights", NULL }; PyObject *directed = Py_True; PyObject *weights_o = Py_None; PyObject *res, *qs, *ms; igraph_matrix_t merges; igraph_vector_t q; igraph_vector_t *weights = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &directed, &weights_o)) return NULL; if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) return NULL; if (igraph_matrix_init(&merges, 0, 0)) { if (weights != 0) { igraph_vector_destroy(weights); free(weights); } return igraphmodule_handle_igraph_error(); } if (igraph_vector_init(&q, 0)) { igraph_matrix_destroy(&merges); if (weights != 0) { igraph_vector_destroy(weights); free(weights); } return igraphmodule_handle_igraph_error(); } if (igraph_community_edge_betweenness(&self->g, /* removed_edges = */ 0, /* edge_betweenness = */ 0, /* merges = */ &merges, /* bridges = */ 0, /* modularity = */ weights ? 0 : &q, /* membership = */ 0, PyObject_IsTrue(directed), weights)) { igraphmodule_handle_igraph_error(); if (weights != 0) { igraph_vector_destroy(weights); free(weights); } igraph_matrix_destroy(&merges); igraph_vector_destroy(&q); return NULL; } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } if (weights == 0) { /* Calculate modularity vector only in the unweighted case as we don't * calculate modularities for the weighted case */ qs=igraphmodule_vector_t_to_PyList(&q, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&q); if (!qs) { igraph_matrix_destroy(&merges); return NULL; } } else { qs = Py_None; Py_INCREF(qs); } ms=igraphmodule_matrix_t_to_PyList(&merges, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&merges); if (ms == NULL) { Py_DECREF(qs); return NULL; } res=Py_BuildValue("NN", ms, qs); /* steals references */ return res; } /** * Newman's leading eigenvector method, precise implementation */ PyObject *igraphmodule_Graph_community_leading_eigenvector(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "n", "weights", "arpack_options", NULL }; long int n=-1; PyObject *cl, *res, *merges, *weights_obj = Py_None; igraph_vector_t members; igraph_vector_t *weights = 0; igraph_matrix_t m; igraph_real_t q; igraphmodule_ARPACKOptionsObject *arpack_options; PyObject *arpack_options_o = igraphmodule_arpack_options_default; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|lOO!", kwlist, &n, &weights_obj, igraphmodule_ARPACKOptionsType, &arpack_options_o)) { return NULL; } if (igraph_vector_init(&members, 0)) return igraphmodule_handle_igraph_error(); if (igraph_matrix_init(&m, 0, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&members); return 0; } if (n<0) n = igraph_vcount(&self->g); else n -= 1; if (igraphmodule_attrib_to_vector_t(weights_obj, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_matrix_destroy(&m); igraph_vector_destroy(&members); return NULL; } arpack_options = (igraphmodule_ARPACKOptionsObject*)arpack_options_o; if (igraph_community_leading_eigenvector(&self->g, weights, &m, &members, (igraph_integer_t) n, igraphmodule_ARPACKOptions_get(arpack_options), &q, 0, 0, 0, 0, 0, 0)){ igraph_matrix_destroy(&m); igraph_vector_destroy(&members); if (weights != 0) { igraph_vector_destroy(weights); free(weights); } return igraphmodule_handle_igraph_error(); } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } cl = igraphmodule_vector_t_to_PyList(&members, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&members); if (cl == 0) { igraph_matrix_destroy(&m); return 0; } merges = igraphmodule_matrix_t_to_PyList(&m, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&m); if (merges == 0) return 0; res=Py_BuildValue("NNd", cl, merges, (double)q); return res; } /** * Clauset et al's greedy modularity optimization algorithm */ PyObject *igraphmodule_Graph_community_fastgreedy(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "weights", NULL }; PyObject *ms, *qs, *res, *weights = Py_None; igraph_matrix_t merges; igraph_vector_t q, *ws=0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &weights)) { return NULL; } if (igraphmodule_attrib_to_vector_t(weights, self, &ws, ATTRIBUTE_TYPE_EDGE)) return NULL; igraph_matrix_init(&merges, 0, 0); igraph_vector_init(&q, 0); if (igraph_community_fastgreedy(&self->g, ws, &merges, &q, 0)) { if (ws) { igraph_vector_destroy(ws); free(ws); } igraph_vector_destroy(&q); igraph_matrix_destroy(&merges); return igraphmodule_handle_igraph_error(); } if (ws) { igraph_vector_destroy(ws); free(ws); } qs=igraphmodule_vector_t_to_PyList(&q, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&q); if (!qs) { igraph_matrix_destroy(&merges); return NULL; } ms=igraphmodule_matrix_t_to_PyList(&merges, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&merges); if (ms == NULL) { Py_DECREF(qs); return NULL; } res=Py_BuildValue("NN", ms, qs); /* steals references */ return res; } /** * Infomap community detection algorithm of Martin Rosvall and Carl T. Bergstrom, */ PyObject *igraphmodule_Graph_community_infomap(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "edge_weights", "vertex_weights", "trials", NULL }; PyObject *e_weights = Py_None, *v_weights = Py_None; unsigned int nb_trials = 10; igraph_vector_t *e_ws = 0, *v_ws = 0; igraph_vector_t membership; PyObject *res = Py_False; igraph_real_t codelength; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOI", kwlist, &e_weights, &v_weights, &nb_trials)) { return NULL; } if (igraph_vector_init(&membership, igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(e_weights, self, &e_ws, ATTRIBUTE_TYPE_EDGE)) { igraph_vector_destroy(&membership); return NULL; } if (igraphmodule_attrib_to_vector_t(v_weights, self, &v_ws, ATTRIBUTE_TYPE_VERTEX)){ igraph_vector_destroy(&membership); if (e_ws) { igraph_vector_destroy(e_ws); free(e_ws); } return NULL; } if (igraph_community_infomap(/*in */ &self->g, /*e_weight=*/ e_ws, /*v_weight=*/ v_ws, /*nb_trials=*/nb_trials, /*out*/ &membership, &codelength)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&membership); if (e_ws) { igraph_vector_destroy(e_ws); free(e_ws); } if (v_ws) { igraph_vector_destroy(v_ws); free(v_ws); } return NULL; } if (e_ws) { igraph_vector_destroy(e_ws); free(e_ws); } if (v_ws) { igraph_vector_destroy(v_ws); free(v_ws); } res = igraphmodule_vector_t_to_PyList(&membership, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&membership); if (!res) return NULL; return Py_BuildValue("Nd", res, (double)codelength); } /** * The label propagation algorithm of Raghavan et al */ PyObject *igraphmodule_Graph_community_label_propagation( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "initial", "fixed", NULL }; PyObject *weights_o = Py_None, *initial_o = Py_None, *fixed_o = Py_None; PyObject *result; igraph_vector_t membership, *ws = 0, *initial = 0; igraph_vector_bool_t fixed; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &weights_o, &initial_o, &fixed_o)) { return NULL; } if (fixed_o != Py_None) { if (igraphmodule_PyObject_to_vector_bool_t(fixed_o, &fixed)) return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &ws, ATTRIBUTE_TYPE_EDGE)) { if (fixed_o != Py_None) igraph_vector_bool_destroy(&fixed); return NULL; } if (igraphmodule_attrib_to_vector_t(initial_o, self, &initial, ATTRIBUTE_TYPE_VERTEX)){ if (fixed_o != Py_None) igraph_vector_bool_destroy(&fixed); if (ws) { igraph_vector_destroy(ws); free(ws); } return NULL; } igraph_vector_init(&membership, igraph_vcount(&self->g)); if (igraph_community_label_propagation(&self->g, &membership, ws, initial, (fixed_o != Py_None ? &fixed : 0), 0)) { if (fixed_o != Py_None) igraph_vector_bool_destroy(&fixed); if (ws) { igraph_vector_destroy(ws); free(ws); } if (initial) { igraph_vector_destroy(initial); free(initial); } igraph_vector_destroy(&membership); return igraphmodule_handle_igraph_error(); } if (fixed_o != Py_None) igraph_vector_bool_destroy(&fixed); if (ws) { igraph_vector_destroy(ws); free(ws); } if (initial) { igraph_vector_destroy(initial); free(initial); } result=igraphmodule_vector_t_to_PyList(&membership, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&membership); return result; } /** * Multilevel algorithm of Blondel et al */ PyObject *igraphmodule_Graph_community_multilevel(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "weights", "return_levels", "resolution", NULL }; PyObject *return_levels = Py_False; PyObject *mss, *qs, *res, *weights = Py_None; igraph_matrix_t memberships; igraph_vector_t membership, modularity; double resolution = 1; igraph_vector_t *ws; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOd", kwlist, &weights, &return_levels, &resolution)) { return NULL; } if (igraphmodule_attrib_to_vector_t(weights, self, &ws, ATTRIBUTE_TYPE_EDGE)) return NULL; igraph_matrix_init(&memberships, 0, 0); igraph_vector_init(&membership, 0); igraph_vector_init(&modularity, 0); if (igraph_community_multilevel(&self->g, ws, resolution, &membership, &memberships, &modularity)) { if (ws) { igraph_vector_destroy(ws); free(ws); } igraph_vector_destroy(&membership); igraph_vector_destroy(&modularity); igraph_matrix_destroy(&memberships); return igraphmodule_handle_igraph_error(); } if (ws) { igraph_vector_destroy(ws); free(ws); } qs=igraphmodule_vector_t_to_PyList(&modularity, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&modularity); if (!qs) { igraph_vector_destroy(&membership); igraph_matrix_destroy(&memberships); return NULL; } if (PyObject_IsTrue(return_levels)) { mss=igraphmodule_matrix_t_to_PyList(&memberships, IGRAPHMODULE_TYPE_INT); if (!mss) { res = mss; } else { res=Py_BuildValue("NN", mss, qs); /* steals references */ } } else { res=igraphmodule_vector_t_to_PyList(&membership, IGRAPHMODULE_TYPE_INT); } igraph_vector_destroy(&membership); igraph_matrix_destroy(&memberships); return res; } /** * Optimal modularity by integer programming */ PyObject *igraphmodule_Graph_community_optimal_modularity( igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"weights", NULL}; PyObject *weights_o = Py_None; igraph_real_t modularity; igraph_vector_t membership; igraph_vector_t* weights = 0; PyObject *res; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &weights_o)) return NULL; if (igraph_vector_init(&membership, igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vector_destroy(&membership); return NULL; } if (igraph_community_optimal_modularity(&self->g, &modularity, &membership, weights)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&membership); if (weights != 0) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } res = igraphmodule_vector_t_to_PyList(&membership, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&membership); if (!res) return NULL; return Py_BuildValue("Nd", res, (double)modularity); } /** * Spinglass community detection method of Reichardt & Bornholdt */ PyObject *igraphmodule_Graph_community_spinglass(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"weights", "spins", "parupdate", "start_temp", "stop_temp", "cool_fact", "update_rule", "gamma", "implementation", "lambda_", NULL}; PyObject *weights_o = Py_None; PyObject *parupdate_o = Py_False; PyObject *update_rule_o = Py_None; PyObject *impl_o = Py_None; PyObject *res; long int spins = 25; double start_temp = 1.0; double stop_temp = 0.01; double cool_fact = 0.99; igraph_spinglass_implementation_t impl = IGRAPH_SPINCOMM_IMP_ORIG; igraph_spincomm_update_t update_rule = IGRAPH_SPINCOMM_UPDATE_CONFIG; double gamma = 1; double lambda = 1; igraph_vector_t *weights = 0, membership; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OlOdddOdOd", kwlist, &weights_o, &spins, &parupdate_o, &start_temp, &stop_temp, &cool_fact, &update_rule_o, &gamma, &impl_o, &lambda)) return NULL; if (igraphmodule_PyObject_to_spincomm_update_t(update_rule_o, &update_rule)) { return NULL; } if (igraphmodule_PyObject_to_spinglass_implementation_t(impl_o, &impl)) { return NULL; } if (igraph_vector_init(&membership, igraph_vcount(&self->g))) { igraphmodule_handle_igraph_error(); return NULL; } if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights, ATTRIBUTE_TYPE_EDGE)) { igraph_vector_destroy(&membership); return NULL; } if (igraph_community_spinglass(&self->g, weights, 0, 0, &membership, 0, (igraph_integer_t) spins, PyObject_IsTrue(parupdate_o), start_temp, stop_temp, cool_fact, update_rule, gamma, impl, lambda)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&membership); if (weights != 0) { igraph_vector_destroy(weights); free(weights); } return NULL; } if (weights != 0) { igraph_vector_destroy(weights); free(weights); } res = igraphmodule_vector_t_to_PyList(&membership, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&membership); return res; } /** * Walktrap community detection of Latapy & Pons */ PyObject *igraphmodule_Graph_community_walktrap(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "weights", "steps", NULL }; PyObject *ms, *qs, *res, *weights = Py_None; igraph_matrix_t merges; int steps=4; igraph_vector_t q, *ws=0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi", kwlist, &weights, &steps)) return NULL; if (igraphmodule_attrib_to_vector_t(weights, self, &ws, ATTRIBUTE_TYPE_EDGE)) return NULL; igraph_matrix_init(&merges, 0, 0); igraph_vector_init(&q, 0); if (igraph_community_walktrap(&self->g, ws, steps, &merges, &q, 0)) { if (ws) { igraph_vector_destroy(ws); free(ws); } igraph_vector_destroy(&q); igraph_matrix_destroy(&merges); return igraphmodule_handle_igraph_error(); } if (ws) { igraph_vector_destroy(ws); free(ws); } qs = igraphmodule_vector_t_to_PyList(&q, IGRAPHMODULE_TYPE_FLOAT); igraph_vector_destroy(&q); if (!qs) { igraph_matrix_destroy(&merges); return NULL; } ms = igraphmodule_matrix_t_to_PyList(&merges, IGRAPHMODULE_TYPE_INT); igraph_matrix_destroy(&merges); if (ms == NULL) { Py_DECREF(qs); return NULL; } res=Py_BuildValue("NN", ms, qs); /* steals references */ return res; } /** * Leiden community detection method of Traag, Waltman & van Eck */ PyObject *igraphmodule_Graph_community_leiden(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"edge_weights", "node_weights", "resolution_parameter", "normalize_resolution", "beta", "initial_membership", "n_iterations", NULL}; PyObject *edge_weights_o = Py_None; PyObject *node_weights_o = Py_None; PyObject *initial_membership_o = Py_None; PyObject *res = Py_None; int error = 0, i; long int n_iterations = 2; double resolution_parameter = 1.0; double beta = 0.01; igraph_vector_t *edge_weights = NULL, *node_weights = NULL, *membership = NULL; igraph_bool_t start = 1; igraph_bool_t normalize_resolution = 0; igraph_integer_t nb_clusters = 0; igraph_real_t quality = 0.0, prev_quality = -IGRAPH_INFINITY; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOdidOl", kwlist, &edge_weights_o, &node_weights_o, &resolution_parameter, &normalize_resolution, &beta, &initial_membership_o, &n_iterations)) return NULL; /* Get edge weights */ if (igraphmodule_attrib_to_vector_t(edge_weights_o, self, &edge_weights, ATTRIBUTE_TYPE_EDGE)) { igraphmodule_handle_igraph_error(); error = -1; } /* Get node weights */ if (!error && igraphmodule_attrib_to_vector_t(node_weights_o, self, &node_weights, ATTRIBUTE_TYPE_VERTEX)) { igraphmodule_handle_igraph_error(); error = -1; } /* Get initial membership */ if (!error && igraphmodule_attrib_to_vector_t(initial_membership_o, self, &membership, ATTRIBUTE_TYPE_VERTEX)) { igraphmodule_handle_igraph_error(); error = -1; } if (!error && membership == 0) { start = 0; membership = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t)); if (membership==0) { PyErr_NoMemory(); error = -1; } else { igraph_vector_init(membership, 0); } } if (normalize_resolution) { /* If we need to normalize the resolution parameter, * we will need to have node weights. */ if (node_weights == 0) { node_weights = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t)); if (node_weights==0) { PyErr_NoMemory(); error = -1; } else { igraph_vector_init(node_weights, 0); if (igraph_strength(&self->g, node_weights, igraph_vss_all(), IGRAPH_ALL, 0, edge_weights)) { igraphmodule_handle_igraph_error(); error = -1; } } } resolution_parameter /= igraph_vector_sum(node_weights); } /* Run actual Leiden algorithm for several iterations. */ if (!error) { if (n_iterations >= 0) { for (i = 0; !error && i < n_iterations; i++) { error = igraph_community_leiden(&self->g, edge_weights, node_weights, resolution_parameter, beta, start, membership, &nb_clusters, &quality); start = 1; } } else { while (!error && prev_quality < quality) { prev_quality = quality; error = igraph_community_leiden(&self->g, edge_weights, node_weights, resolution_parameter, beta, start, membership, &nb_clusters, &quality); start = 1; } } } if (edge_weights != 0) { igraph_vector_destroy(edge_weights); free(edge_weights); } if (node_weights != 0) { igraph_vector_destroy(node_weights); free(node_weights); } if (!error && membership != 0) { res = igraphmodule_vector_t_to_PyList(membership, IGRAPHMODULE_TYPE_INT); } if (membership != 0) { igraph_vector_destroy(membership); free(membership); } if (!error) { return res; } else { return NULL; } } /********************************************************************** * Random walks * **********************************************************************/ /** * Simple random walk of a given length */ PyObject *igraphmodule_Graph_random_walk(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { static char *kwlist[] = { "start", "steps", "mode", "stuck", NULL }; PyObject *start_o, *mode_o = Py_None, *stuck_o = Py_None, *res; igraph_integer_t start; int steps=10; igraph_neimode_t mode = IGRAPH_OUT; igraph_random_walk_stuck_t stuck = IGRAPH_RANDOM_WALK_STUCK_RETURN; igraph_vector_t walk; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OiOO", kwlist, &start_o, &steps, &mode_o, &stuck_o)) return NULL; if (igraphmodule_PyObject_to_vid(start_o, &start, &self->g)) return NULL; if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) return NULL; if (igraphmodule_PyObject_to_random_walk_stuck_t(stuck_o, &stuck)) return NULL; if (igraph_vector_init(&walk, steps)) return igraphmodule_handle_igraph_error(); if (igraph_random_walk(&self->g, &walk, start, mode, steps, stuck)) { igraph_vector_destroy(&walk); return igraphmodule_handle_igraph_error(); } res = igraphmodule_vector_t_to_PyList(&walk, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&walk); return res; } /********************************************************************** * Special internal methods that you won't need to mess around with * **********************************************************************/ /** \defgroup python_interface_internal Internal functions * \ingroup python_interface */ PyObject *igraphmodule_Graph___graph_as_capsule__(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { return PyCapsule_New((void *)&self->g, 0, 0); } /** \ingroup python_interface_internal * \brief Returns the pointer of the encapsulated igraph graph as an ordinary * Python integer. This allows us to use igraph graphs with the Python ctypes * module without any additional conversions. */ PyObject *igraphmodule_Graph__raw_pointer(igraphmodule_GraphObject *self) { return PyLong_FromLong((long int)&self->g); } /** \ingroup python_interface_internal * \brief Registers a destructor to be called when the object is destroyed * \return the previous destructor (if any) * Unimplemented. */ PyObject *igraphmodule_Graph___register_destructor__(igraphmodule_GraphObject * self, PyObject * args, PyObject * kwds) { char *kwlist[] = { "destructor", NULL }; PyObject *destructor = NULL, *result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &destructor)) return NULL; if (!PyCallable_Check(destructor)) { PyErr_SetString(PyExc_TypeError, "The destructor must be callable!"); return NULL; } result = self->destructor; self->destructor = destructor; Py_INCREF(self->destructor); if (!result) Py_RETURN_NONE; return result; } /** \ingroup python_interface * \brief Member list of the \c igraph.Graph object type */ #define OFF(x) offsetof(igraphmodule_GraphObject, x) /** \ingroup python_interface * \brief Method list of the \c igraph.Graph object type */ struct PyMethodDef igraphmodule_Graph_methods[] = { //////////////////////////// // BASIC IGRAPH INTERFACE // //////////////////////////// // interface to igraph_vcount {"vcount", (PyCFunction) igraphmodule_Graph_vcount, METH_NOARGS, "vcount()\n--\n\n" "Counts the number of vertices.\n\n" "@return: the number of vertices in the graph.\n" "@rtype: integer\n"}, // interface to igraph_ecount {"ecount", (PyCFunction) igraphmodule_Graph_ecount, METH_NOARGS, "ecount()\n--\n\n" "Counts the number of edges.\n\n" "@return: the number of edges in the graph.\n" "@rtype: integer\n"}, // interface to igraph_is_dag {"is_dag", (PyCFunction) igraphmodule_Graph_is_dag, METH_NOARGS, "is_dag()\n--\n\n" "Checks whether the graph is a DAG (directed acyclic graph).\n\n" "A DAG is a directed graph with no directed cycles.\n\n" "@return: C{True} if it is a DAG, C{False} otherwise.\n" "@rtype: boolean"}, // interface to igraph_is_directed {"is_directed", (PyCFunction) igraphmodule_Graph_is_directed, METH_NOARGS, "is_directed()\n--\n\n" "Checks whether the graph is directed.\n\n" "@return: C{True} if it is directed, C{False} otherwise.\n" "@rtype: boolean"}, /* interface to igraph_is_simple */ {"is_simple", (PyCFunction) igraphmodule_Graph_is_simple, METH_NOARGS, "is_simple()\n--\n\n" "Checks whether the graph is simple (no loop or multiple edges).\n\n" "@return: C{True} if it is simple, C{False} otherwise.\n" "@rtype: boolean"}, /* interface to igraph_is_tree */ {"is_tree", (PyCFunction) igraphmodule_Graph_is_tree, METH_VARARGS | METH_KEYWORDS, "is_tree(mode=\"out\")\n--\n\n" "Checks whether the graph is a (directed or undirected) tree graph.\n\n" "For directed trees, the function may require that the edges are oriented\n" "outwards from the root or inwards to the root, depending on the value\n" "of the C{mode} argument.\n\n" "@param mode: for directed graphs, specifies how the edge directions\n" " should be taken into account. C{\"all\"} means that the edge directions\n" " must be ignored, C{\"out\"} means that the edges must be oriented away\n" " from the root, C{\"in\"} means that the edges must be oriented\n" " towards the root. Ignored for undirected graphs.\n" "@return: C{True} if the graph is a tree, C{False} otherwise.\n" "@rtype: boolean"}, /* interface to igraph_add_vertices */ {"add_vertices", (PyCFunction) igraphmodule_Graph_add_vertices, METH_VARARGS, "add_vertices(n)\n--\n\n" "Adds vertices to the graph.\n\n" "@param n: the number of vertices to be added\n"}, /* interface to igraph_delete_vertices */ {"delete_vertices", (PyCFunction) igraphmodule_Graph_delete_vertices, METH_VARARGS, "delete_vertices(vs)\n--\n\n" "Deletes vertices and all its edges from the graph.\n\n" "@param vs: a single vertex ID or the list of vertex IDs\n" " to be deleted. No argument deletes all vertices.\n"}, /* interface to igraph_add_edges */ {"add_edges", (PyCFunction) igraphmodule_Graph_add_edges, METH_VARARGS, "add_edges(es)\n--\n\n" "Adds edges to the graph.\n\n" "@param es: the list of edges to be added. Every edge is\n" " represented with a tuple, containing the vertex IDs of the\n" " two endpoints. Vertices are enumerated from zero.\n"}, /* interface to igraph_delete_edges */ {"delete_edges", (PyCFunction) igraphmodule_Graph_delete_edges, METH_VARARGS | METH_KEYWORDS, "delete_edges(es)\n--\n\n" "Removes edges from the graph.\n\n" "All vertices will be kept, even if they lose all their edges.\n" "Nonexistent edges will be silently ignored.\n\n" "@param es: the list of edges to be removed. Edges are identifed by\n" " edge IDs. L{EdgeSeq} objects are also accepted here. No argument\n" " deletes all edges.\n"}, /* interface to igraph_degree */ {"degree", (PyCFunction) igraphmodule_Graph_degree, METH_VARARGS | METH_KEYWORDS, "degree(vertices, mode=\"all\", loops=True)\n--\n\n" "Returns some vertex degrees from the graph.\n\n" "This method accepts a single vertex ID or a list of vertex IDs as a\n" "parameter, and returns the degree of the given vertices (in the\n" "form of a single integer or a list, depending on the input\n" "parameter).\n" "\n" "@param vertices: a single vertex ID or a list of vertex IDs\n" "@param mode: the type of degree to be returned (C{\"out\"} for\n" " out-degrees, C{\"in\"} for in-degrees or C{\"all\"} for the sum of\n" " them).\n" "@param loops: whether self-loops should be counted.\n"}, /* interface to igraph_strength */ {"strength", (PyCFunction) igraphmodule_Graph_strength, METH_VARARGS | METH_KEYWORDS, "strength(vertices, mode=\"all\", loops=True, weights=None)\n--\n\n" "Returns the strength (weighted degree) of some vertices from the graph\n\n" "This method accepts a single vertex ID or a list of vertex IDs as a\n" "parameter, and returns the strength (that is, the sum of the weights\n" "of all incident edges) of the given vertices (in the\n" "form of a single integer or a list, depending on the input\n" "parameter).\n" "\n" "@param vertices: a single vertex ID or a list of vertex IDs\n" "@param mode: the type of degree to be returned (C{\"out\"} for\n" " out-degrees, C{\"in\"} for in-degrees or C{\"all\"} for the sum of\n" " them).\n" "@param loops: whether self-loops should be counted.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name. ``None`` means to treat the graph as\n" " unweighted, falling back to ordinary degree calculations.\n" }, /* interface to igraph_is_loop */ {"is_loop", (PyCFunction) igraphmodule_Graph_is_loop, METH_VARARGS | METH_KEYWORDS, "is_loop(edges=None)\n--\n\n" "Checks whether a specific set of edges contain loop edges\n\n" "@param edges: edge indices which we want to check. If C{None}, all\n" " edges are checked.\n" "@return: a list of booleans, one for every edge given\n"}, /* interface to igraph_is_multiple */ {"is_multiple", (PyCFunction) igraphmodule_Graph_is_multiple, METH_VARARGS | METH_KEYWORDS, "is_multiple(edges=None)\n--\n\n" "Checks whether an edge is a multiple edge.\n\n" "Also works for a set of edges -- in this case, every edge is checked\n" "one by one. Note that if there are multiple edges going between a\n" "pair of vertices, there is always one of them that is I{not}\n" "reported as multiple (only the others). This allows one to easily\n" "detect the edges that have to be deleted in order to make the graph\n" "free of multiple edges.\n\n" "@param edges: edge indices which we want to check. If C{None}, all\n" " edges are checked.\n" "@return: a list of booleans, one for every edge given\n"}, /* interface to igraph_has_multiple */ {"has_multiple", (PyCFunction) igraphmodule_Graph_has_multiple, METH_NOARGS, "has_multiple()\n--\n\n" "Checks whether the graph has multiple edges.\n\n" "@return: C{True} if the graph has at least one multiple edge,\n" " C{False} otherwise.\n" "@rtype: boolean"}, /* interface to igraph_is_mutual */ {"is_mutual", (PyCFunction) igraphmodule_Graph_is_mutual, METH_VARARGS | METH_KEYWORDS, "is_mutual(edges=None)\n--\n\n" "Checks whether an edge has an opposite pair.\n\n" "Also works for a set of edges -- in this case, every edge is checked\n" "one by one. The result will be a list of booleans (or a single boolean\n" "if only an edge index is supplied), every boolean corresponding to an\n" "edge in the edge set supplied. C{True} is returned for a given edge\n" "M{a} --> M{b} if there exists another edge M{b} --> M{a} in the\n" "original graph (not the given edge set!). All edges in an undirected\n" "graph are mutual. In case there are multiple edges between M{a}\n" "and M{b}, it is enough to have at least one edge in either direction\n" "to report all edges between them as mutual, so the multiplicity\n" "of edges do not matter.\n\n" "@param edges: edge indices which we want to check. If C{None}, all\n" " edges are checked.\n" "@return: a list of booleans, one for every edge given\n"}, /* interface to igraph_count_multiple */ {"count_multiple", (PyCFunction) igraphmodule_Graph_count_multiple, METH_VARARGS | METH_KEYWORDS, "count_multiple(edges=None)\n--\n\n" "Counts the multiplicities of the given edges.\n\n" "@param edges: edge indices for which we want to count their\n" " multiplicity. If C{None}, all edges are counted.\n" "@return: the multiplicities of the given edges as a list.\n"}, /* interface to igraph_neighbors */ {"neighbors", (PyCFunction) igraphmodule_Graph_neighbors, METH_VARARGS | METH_KEYWORDS, "neighbors(vertex, mode=\"all\")\n--\n\n" "Returns adjacent vertices to a given vertex.\n\n" "@param vertex: a vertex ID\n" "@param mode: whether to return only successors (C{\"out\"}),\n" " predecessors (C{\"in\"}) or both (C{\"all\"}). Ignored for undirected\n" " graphs."}, {"successors", (PyCFunction) igraphmodule_Graph_successors, METH_VARARGS | METH_KEYWORDS, "successors(vertex)\n--\n\n" "Returns the successors of a given vertex.\n\n" "Equivalent to calling the L{neighbors()} method with type=C{\"out\"}."}, {"predecessors", (PyCFunction) igraphmodule_Graph_predecessors, METH_VARARGS | METH_KEYWORDS, "predecessors(vertex)\n--\n\n" "Returns the predecessors of a given vertex.\n\n" "Equivalent to calling the L{neighbors()} method with type=C{\"in\"}."}, /* interface to igraph_get_eid */ {"get_eid", (PyCFunction) igraphmodule_Graph_get_eid, METH_VARARGS | METH_KEYWORDS, "get_eid(v1, v2, directed=True, error=True)\n--\n\n" "Returns the edge ID of an arbitrary edge between vertices v1 and v2\n\n" "@param v1: the ID or name of the first vertex\n" "@param v2: the ID or name of the second vertex\n" "@param directed: whether edge directions should be considered in\n" " directed graphs. The default is C{True}. Ignored for undirected\n" " graphs.\n" "@param error: if C{True}, an exception will be raised when the\n" " given edge does not exist. If C{False}, -1 will be returned in\n" " that case.\n" "@return: the edge ID of an arbitrary edge between vertices v1 and v2\n"}, /* interface to igraph_get_eids */ {"get_eids", (PyCFunction) igraphmodule_Graph_get_eids, METH_VARARGS | METH_KEYWORDS, "get_eids(pairs=None, path=None, directed=True, error=True)\n--\n\n" "Returns the edge IDs of some edges between some vertices.\n\n" "This method can operate in two different modes, depending on which\n" "of the keyword arguments C{pairs} and C{path} are given.\n\n" "The method does not consider multiple edges; if there are multiple\n" "edges between a pair of vertices, only the ID of one of the edges\n" "is returned.\n\n" "@param pairs: a list of integer pairs. Each integer pair is considered\n" " as a source-target vertex pair; the corresponding edge is looked up\n" " in the graph and the edge ID is returned for each pair.\n" "@param path: a list of vertex IDs. The list is considered as a\n" " continuous path from the first vertex to the last, passing\n" " through the intermediate vertices. The corresponding edge IDs\n" " between the first and the second, the second and the third and\n" " so on are looked up in the graph and the edge IDs are returned.\n" " If both C{path} and C{pairs} are given, the two lists are\n" " concatenated.\n" "@param directed: whether edge directions should be considered in\n" " directed graphs. The default is C{True}. Ignored for undirected\n" " graphs.\n" "@param error: if C{True}, an exception will be raised if a given\n" " edge does not exist. If C{False}, -1 will be returned in\n" " that case.\n" "@return: the edge IDs in a list\n"}, /* interface to igraph_incident */ {"incident", (PyCFunction) igraphmodule_Graph_incident, METH_VARARGS | METH_KEYWORDS, "incident(vertex, mode=\"out\")\n--\n\n" "Returns the edges a given vertex is incident on.\n\n" "@param vertex: a vertex ID\n" "@param mode: whether to return only successors (C{\"out\"}),\n" " predecessors (C{\"in\"}) or both (C{\"all\"}). Ignored for undirected\n" " graphs."}, ////////////////////// // GRAPH GENERATORS // ////////////////////// /* interface to igraph_adjacency */ {"Adjacency", (PyCFunction) igraphmodule_Graph_Adjacency, METH_CLASS | METH_VARARGS | METH_KEYWORDS, "Adjacency(matrix, mode=\"directed\")\n--\n\n" "Generates a graph from its adjacency matrix.\n\n" "@param matrix: the adjacency matrix\n" "@param mode: the mode to be used. Possible values are:\n" "\n" " - C{\"directed\"} - the graph will be directed and a matrix\n" " element gives the number of edges between two vertices.\n" " - C{\"undirected\"} - alias to C{\"max\"} for convenience.\n" " - C{\"max\"} - undirected graph will be created and the number of\n" " edges between vertex M{i} and M{j} is M{max(A(i,j), A(j,i))}\n" " - C{\"min\"} - like C{\"max\"}, but with M{min(A(i,j), A(j,i))}\n" " - C{\"plus\"} - like C{\"max\"}, but with M{A(i,j) + A(j,i)}\n" " - C{\"upper\"} - undirected graph with the upper right triangle of\n" " the matrix (including the diagonal)\n" " - C{\"lower\"} - undirected graph with the lower left triangle of\n" " the matrix (including the diagonal)\n" }, /* interface to igraph_asymmetric_preference_game */ {"Asymmetric_Preference", (PyCFunction) igraphmodule_Graph_Asymmetric_Preference, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Asymmetric_Preference(n, type_dist_matrix, pref_matrix, attribute=None, loops=False)\n--\n\n" "Generates a graph based on asymmetric vertex types and connection probabilities.\n\n" "This is the asymmetric variant of L{Preference()}.\n" "A given number of vertices are generated. Every vertex is assigned to an\n" "\"incoming\" and an \"outgoing\" vertex type according to the given joint\n" "type probabilities. Finally, every vertex pair is evaluated and a\n" "directed edge is created between them with a probability depending on\n" "the \"outgoing\" type of the source vertex and the \"incoming\" type of\n" "the target vertex.\n\n" "@param n: the number of vertices in the graph\n" "@param type_dist_matrix: matrix giving the joint distribution of vertex\n" " types\n" "@param pref_matrix: matrix giving the connection probabilities for\n" " different vertex types.\n" "@param attribute: the vertex attribute name used to store the vertex\n" " types. If C{None}, vertex types are not stored.\n" "@param loops: whether loop edges are allowed.\n"}, // interface to igraph_atlas {"Atlas", (PyCFunction) igraphmodule_Graph_Atlas, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Atlas(idx)\n--\n\n" "Generates a graph from the Graph Atlas.\n\n" "@param idx: The index of the graph to be generated.\n" " Indices start from zero, graphs are listed:\n\n" " 1. in increasing order of number of vertices;\n" " 2. for a fixed number of vertices, in increasing order of the\n" " number of edges;\n" " 3. for fixed numbers of vertices and edges, in increasing order\n" " of the degree sequence, for example 111223 < 112222;\n" " 4. for fixed degree sequence, in increasing number of automorphisms.\n\n" "@newfield ref: Reference\n" "@ref: I{An Atlas of Graphs} by Ronald C. Read and Robin J. Wilson,\n" " Oxford University Press, 1998."}, // interface to igraph_barabasi_game {"Barabasi", (PyCFunction) igraphmodule_Graph_Barabasi, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Barabasi(n, m, outpref=False, directed=False, power=1,\n" " zero_appeal=1, implementation=\"psumtree\", start_from=None)\n--\n\n" "Generates a graph based on the Barabasi-Albert model.\n\n" "@param n: the number of vertices\n" "@param m: either the number of outgoing edges generated for\n" " each vertex or a list containing the number of outgoing\n" " edges for each vertex explicitly.\n" "@param outpref: C{True} if the out-degree of a given vertex\n" " should also increase its citation probability (as well as\n" " its in-degree), but it defaults to C{False}.\n" "@param directed: C{True} if the generated graph should be\n" " directed (default: C{False}).\n" "@param power: the power constant of the nonlinear model.\n" " It can be omitted, and in this case the usual linear model\n" " will be used.\n" "@param zero_appeal: the attractivity of vertices with degree\n" " zero.\n\n" "@param implementation: the algorithm to use to generate the\n" " network. Possible values are:\n\n" " - C{\"bag\"}: the algorithm that was the default in\n" " igraph before 0.6. It works by putting the ids of the\n" " vertices into a bag (multiset) exactly as many times\n" " as their in-degree, plus once more. The required number\n" " of cited vertices are then drawn from the bag with\n" " replacement. It works only for I{power}=1 and\n" " I{zero_appeal}=1.\n\n" " - C{\"psumtree\"}: this algorithm uses a partial prefix-sum\n" " tree to generate the graph. It does not generate multiple\n" " edges and it works for any values of I{power} and\n" " I{zero_appeal}.\n\n" " - C{\"psumtree_multiple\"}: similar to C{\"psumtree\"}, but\n" " it will generate multiple edges as well. igraph before\n" " 0.6 used this algorithm for I{power}s other than 1.\n\n" "@param start_from: if given and not C{None}, this must be another\n" " L{GraphBase} object. igraph will use this graph as a starting\n" " point for the preferential attachment model.\n\n" "@newfield ref: Reference\n" "@ref: Barabasi, A-L and Albert, R. 1999. Emergence of scaling\n" " in random networks. Science, 286 509-512."}, /* interface to igraph_create_bipartite */ {"_Bipartite", (PyCFunction) igraphmodule_Graph_Bipartite, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "_Bipartite(types, edges, directed=False)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.Bipartite()\n\n"}, /* interface to igraph_de_bruijn */ {"De_Bruijn", (PyCFunction) igraphmodule_Graph_De_Bruijn, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "De_Bruijn(m, n)\n--\n\n" "Generates a de Bruijn graph with parameters (m, n)\n\n" "A de Bruijn graph represents relationships between strings. An alphabet\n" "of M{m} letters are used and strings of length M{n} are considered.\n" "A vertex corresponds to every possible string and there is a directed edge\n" "from vertex M{v} to vertex M{w} if the string of M{v} can be transformed into\n" "the string of M{w} by removing its first letter and appending a letter to it.\n" "\n" "Please note that the graph will have M{m^n} vertices and even more edges,\n" "so probably you don't want to supply too big numbers for M{m} and M{n}.\n\n" "@param m: the size of the alphabet\n" "@param n: the length of the strings\n" }, // interface to igraph_establishment_game {"Establishment", (PyCFunction) igraphmodule_Graph_Establishment, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Establishment(n, k, type_dist, pref_matrix, directed=False)\n--\n\n" "Generates a graph based on a simple growing model with vertex types.\n\n" "A single vertex is added at each time step. This new vertex tries to\n" "connect to k vertices in the graph. The probability that such a\n" "connection is realized depends on the types of the vertices involved.\n" "\n" "@param n: the number of vertices in the graph\n" "@param k: the number of connections tried in each step\n" "@param type_dist: list giving the distribution of vertex types\n" "@param pref_matrix: matrix (list of lists) giving the connection\n" " probabilities for different vertex types\n" "@param directed: whether to generate a directed graph.\n"}, // interface to igraph_erdos_renyi_game {"Erdos_Renyi", (PyCFunction) igraphmodule_Graph_Erdos_Renyi, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Erdos_Renyi(n, p, m, directed=False, loops=False)\n--\n\n" "Generates a graph based on the Erdos-Renyi model.\n\n" "@param n: the number of vertices.\n" "@param p: the probability of edges. If given, C{m} must be missing.\n" "@param m: the number of edges. If given, C{p} must be missing.\n" "@param directed: whether to generate a directed graph.\n" "@param loops: whether self-loops are allowed.\n"}, /* interface to igraph_famous */ {"Famous", (PyCFunction) igraphmodule_Graph_Famous, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Famous(name)\n--\n\n" "Generates a famous graph based on its name.\n\n" "Several famous graphs are known to C{igraph} including (but not limited to)\n" "the Chvatal graph, the Petersen graph or the Tutte graph. This method\n" "generates one of them based on its name (case insensitive). See the\n" "documentation of the C interface of C{igraph} for the names available:\n" "U{https://igraph.org/c/doc}.\n\n" "@param name: the name of the graph to be generated.\n" }, /* interface to igraph_forest_fire_game */ {"Forest_Fire", (PyCFunction) igraphmodule_Graph_Forest_Fire, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Forest_Fire(n, fw_prob, bw_factor=0.0, ambs=1, directed=False)\n--\n\n" "Generates a graph based on the forest fire model\n\n" "The forest fire model is a growing graph model. In every time step, a new\n" "vertex is added to the graph. The new vertex chooses an ambassador (or\n" "more than one if M{ambs>1}) and starts a simulated forest fire at its\n" "ambassador(s). The fire spreads through the edges. The spreading probability\n" "along an edge is given by M{fw_prob}. The fire may also spread backwards\n" "on an edge by probability M{fw_prob * bw_factor}. When the fire ended, the\n" "newly added vertex connects to the vertices ``burned'' in the previous\n" "fire.\n\n" "@param n: the number of vertices in the graph\n" "@param fw_prob: forward burning probability\n" "@param bw_factor: ratio of backward and forward burning probability\n" "@param ambs: number of ambassadors chosen in each step\n" "@param directed: whether the graph will be directed\n" }, /* interface to igraph_full_citation */ {"Full_Citation", (PyCFunction) igraphmodule_Graph_Full_Citation, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Full_Citation(n, directed=False)\n--\n\n" "Generates a full citation graph\n\n" "A full citation graph is a graph where the vertices are indexed from 0 to\n" "M{n-1} and vertex M{i} has a directed edge towards all vertices with an\n" "index less than M{i}.\n\n" "@param n: the number of vertices.\n" "@param directed: whether to generate a directed graph.\n"}, /* interface to igraph_full */ {"Full", (PyCFunction) igraphmodule_Graph_Full, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Full(n, directed=False, loops=False)\n--\n\n" "Generates a full graph (directed or undirected, with or without loops).\n\n" "@param n: the number of vertices.\n" "@param directed: whether to generate a directed graph.\n" "@param loops: whether self-loops are allowed.\n"}, /* interface to igraph_full_bipartite */ {"_Full_Bipartite", (PyCFunction) igraphmodule_Graph_Full_Bipartite, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "_Full_Bipartite(n1, n2, directed=False, loops=False)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.Full_Bipartite()\n\n"}, /* interface to igraph_grg_game */ {"_GRG", (PyCFunction) igraphmodule_Graph_GRG, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "_GRG(n, radius, torus=False)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.GRG()\n\n"}, /* interface to igraph_growing_random_game */ {"Growing_Random", (PyCFunction) igraphmodule_Graph_Growing_Random, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Growing_Random(n, m, directed=False, citation=False)\n--\n\n" "Generates a growing random graph.\n\n" "@param n: The number of vertices in the graph\n" "@param m: The number of edges to add in each step (after adding a new vertex)\n" "@param directed: whether the graph should be directed.\n" "@param citation: whether the new edges should originate from the most\n" " recently added vertex.\n"}, /* interface to igraph_incidence */ {"_Incidence", (PyCFunction) igraphmodule_Graph_Incidence, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "_Incidence(matrix, directed=False, mode=\"all\", multiple=False)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.Incidence()\n\n"}, /* interface to igraph_kautz */ {"Kautz", (PyCFunction) igraphmodule_Graph_Kautz, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Kautz(m, n)\n--\n\n" "Generates a Kautz graph with parameters (m, n)\n\n" "A Kautz graph is a labeled graph, vertices are labeled by strings\n" "of length M{n+1} above an alphabet with M{m+1} letters, with\n" "the restriction that every two consecutive letters in the string\n" "must be different. There is a directed edge from a vertex M{v} to\n" "another vertex M{w} if it is possible to transform the string of\n" "M{v} into the string of M{w} by removing the first letter and\n" "appending a letter to it.\n\n" "@param m: the size of the alphabet minus one\n" "@param n: the length of the strings minus one\n" }, /* interface to igraph_k_regular */ {"K_Regular", (PyCFunction) igraphmodule_Graph_K_Regular, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "K_Regular(n, k, directed=False, multiple=False)\n--\n\n" "Generates a k-regular random graph\n\n" "A k-regular random graph is a random graph where each vertex has degree k.\n" "If the graph is directed, both the in-degree and the out-degree of each vertex\n" "will be k.\n\n" "@param n: The number of vertices in the graph\n\n" "@param k: The degree of each vertex if the graph is undirected, or the in-degree\n" " and out-degree of each vertex if the graph is directed\n" "@param directed: whether the graph should be directed.\n" "@param multiple: whether it is allowed to create multiple edges.\n" }, /* interface to igraph_preference_game */ {"Preference", (PyCFunction) igraphmodule_Graph_Preference, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Preference(n, type_dist, pref_matrix, attribute=None, directed=False, loops=False)\n--\n\n" "Generates a graph based on vertex types and connection probabilities.\n\n" "This is practically the nongrowing variant of L{Establishment}.\n" "A given number of vertices are generated. Every vertex is assigned to a\n" "vertex type according to the given type probabilities. Finally, every\n" "vertex pair is evaluated and an edge is created between them with a\n" "probability depending on the types of the vertices involved.\n\n" "@param n: the number of vertices in the graph\n" "@param type_dist: list giving the distribution of vertex types\n" "@param pref_matrix: matrix giving the connection probabilities for\n" " different vertex types.\n" "@param attribute: the vertex attribute name used to store the vertex\n" " types. If C{None}, vertex types are not stored.\n" "@param directed: whether to generate a directed graph.\n" "@param loops: whether loop edges are allowed.\n"}, /* interface to igraph_bipartite_game */ {"_Random_Bipartite", (PyCFunction) igraphmodule_Graph_Random_Bipartite, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "_Random_Bipartite(n1, n2, p=None, m=None, directed=False, neimode=\"all\")\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.Random_Bipartite()\n\n"}, /* interface to igraph_recent_degree_game */ {"Recent_Degree", (PyCFunction) igraphmodule_Graph_Recent_Degree, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Recent_Degree(n, m, window, outpref=False, directed=False, power=1)\n--\n\n" "Generates a graph based on a stochastic model where the probability\n" "of an edge gaining a new node is proportional to the edges gained in\n" "a given time window.\n\n" "@param n: the number of vertices\n" "@param m: either the number of outgoing edges generated for\n" " each vertex or a list containing the number of outgoing\n" " edges for each vertex explicitly.\n" "@param window: size of the window in time steps\n" "@param outpref: C{True} if the out-degree of a given vertex\n" " should also increase its citation probability (as well as\n" " its in-degree), but it defaults to C{False}.\n" "@param directed: C{True} if the generated graph should be\n" " directed (default: C{False}).\n" "@param power: the power constant of the nonlinear model.\n" " It can be omitted, and in this case the usual linear model\n" " will be used.\n"}, /* interface to igraph_sbm_game */ {"SBM", (PyCFunction) igraphmodule_Graph_SBM, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "SBM(n, pref_matrix, block_sizes, directed=False, loops=False)\n--\n\n" "Generates a graph based on a stochastic blockmodel.\n\n" "A given number of vertices are generated. Every vertex is assigned to a\n" "vertex type according to the given block sizes. Vertices of the same\n" "type will be assigned consecutive vertex IDs. Finally, every\n" "vertex pair is evaluated and an edge is created between them with a\n" "probability depending on the types of the vertices involved. The\n" "probabilities are taken from the preference matrix.\n\n" "@param n: the number of vertices in the graph\n" "@param pref_matrix: matrix giving the connection probabilities for\n" " different vertex types.\n" "@param block_sizes: list giving the number of vertices in each block; must\n" " sum up to I{n}.\n" "@param directed: whether to generate a directed graph.\n" "@param loops: whether loop edges are allowed.\n"}, // interface to igraph_star {"Star", (PyCFunction) igraphmodule_Graph_Star, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Star(n, mode=\"undirected\", center=0)\n--\n\n" "Generates a star graph.\n\n" "@param n: the number of vertices in the graph\n" "@param mode: Gives the type of the star graph to create. Should be\n" " either \"in\", \"out\", \"mutual\" or \"undirected\"\n" "@param center: Vertex ID for the central vertex in the star.\n"}, // interface to igraph_lattice {"Lattice", (PyCFunction) igraphmodule_Graph_Lattice, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Lattice(dim, nei=1, directed=False, mutual=True, circular=True)\n--\n\n" "Generates a regular lattice.\n\n" "@param dim: list with the dimensions of the lattice\n" "@param nei: value giving the distance (number of steps) within which\n" " two vertices will be connected.\n" "@param directed: whether to create a directed graph.\n" "@param mutual: whether to create all connections as mutual\n" " in case of a directed graph.\n" "@param circular: whether the generated lattice is periodic.\n"}, /* interface to igraph_lcf */ {"LCF", (PyCFunction) igraphmodule_Graph_LCF, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "LCF(n, shifts, repeats)\n--\n\n" "Generates a graph from LCF notation.\n\n" "LCF is short for Lederberg-Coxeter-Frucht, it is a concise notation\n" "for 3-regular Hamiltonian graphs. It consists of three parameters,\n" "the number of vertices in the graph, a list of shifts giving\n" "additional edges to a cycle backbone and another integer giving how\n" "many times the shifts should be performed. See\n" "U{http://mathworld.wolfram.com/LCFNotation.html} for details.\n\n" "@param n: the number of vertices\n" "@param shifts: the shifts in a list or tuple\n" "@param repeats: the number of repeats\n" }, {"Realize_Degree_Sequence", (PyCFunction) igraphmodule_Graph_Realize_Degree_Sequence, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Realize_Degree_Sequence(out, in_=None, allowed_edge_types=\"simple\", method=\"smallest\")\n--\n\n" "Generates a graph from a degree sequence.\n" "\n" "This method implements a Havel-Hakimi style graph construction from a given\n" "degree sequence. In each step, the algorithm picks two vertices in a\n" "deterministic manner and connects them. The way the vertices are picked is\n" "defined by the C{method} parameter. The allowed edge types (i.e. whether\n" "multiple or loop edges are allowed) are specified in the C{allowed_edge_types}\n" "parameter.\n" "\n" "@param outdeg: the degree sequence of an undirected graph (if indeg=None),\n" " or the out-degree sequence of a directed graph.\n" "@param indeg: None to generate an undirected graph, the in-degree sequence\n" " to generate a directed graph.\n" "@param allowed_edge_types: controls whether loops or multi-edges are allowed\n" " during the generation process. Note that not all combinations are supported\n" " for all types of graphs; an exception will be raised for unsupported\n" " combinations. Possible values are:\n" "\n" " - C{\"simple\"}: simple graphs (no self-loops, no multi-edges)\n" " - C{\"loops\"}: single self-loops allowed, but not multi-edges\n" " - C{\"multi\"}: multi-edges allowed, but not self-loops\n" " - C{\"all\"}: multi-edges and self-loops allowed\n" "\n" "@param method: controls how the vertices are selected during the generation\n" " process. Possible values are:\n" "\n" " - C{smallest}: The vertex with smallest remaining degree first.\n" " - C{largest}: The vertex with the largest remaining degree first.\n" " - C{index}: The vertices are selected in order of their index.\n" }, // interface to igraph_ring {"Ring", (PyCFunction) igraphmodule_Graph_Ring, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Ring(n, directed=False, mutual=False, circular=True)\n--\n\n" "Generates a ring graph.\n\n" "@param n: the number of vertices in the ring\n" "@param directed: whether to create a directed ring.\n" "@param mutual: whether to create mutual edges in a directed ring.\n" "@param circular: whether to create a closed ring.\n"}, /* interface to igraph_static_fitness_game */ {"Static_Fitness", (PyCFunction) igraphmodule_Graph_Static_Fitness, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Static_Fitness(m, fitness_out, fitness_in=None, loops=False, multiple=False)\n--\n\n" "Generates a non-growing graph with edge probabilities proportional to node\n" "fitnesses.\n\n" "The algorithm randomly selects vertex pairs and connects them until the given\n" "number of edges are created. Each vertex is selected with a probability\n" "proportional to its fitness; for directed graphs, a vertex is selected as a\n" "source proportional to its out-fitness and as a target proportional to its\n" "in-fitness.\n\n" "@param m: the number of edges in the graph\n" "@param fitness_out: a numeric vector with non-negative entries, one for each\n" " vertex. These values represent the fitness scores (out-fitness scores for\n" " directed graphs). I{fitness} is an alias of this keyword argument.\n" "@param fitness_in: a numeric vector with non-negative entries, one for each\n" " vertex. These values represent the in-fitness scores for directed graphs.\n" " For undirected graphs, this argument must be C{None}.\n" "@param loops: whether loop edges are allowed.\n" "@param multiple: whether multiple edges are allowed.\n" "@return: a directed or undirected graph with the prescribed power-law\n" " degree distributions.\n" }, /* interface to igraph_static_power_law_game */ {"Static_Power_Law", (PyCFunction) igraphmodule_Graph_Static_Power_Law, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Static_Power_Law(n, m, exponent_out, exponent_in=-1, loops=False, " "multiple=False, finite_size_correction=True)\n--\n\n" "Generates a non-growing graph with prescribed power-law degree distributions.\n\n" "@param n: the number of vertices in the graph\n" "@param m: the number of edges in the graph\n" "@param exponent_out: the exponent of the out-degree distribution, which\n" " must be between 2 and infinity (inclusive). When I{exponent_in} is\n" " not given or negative, the graph will be undirected and this parameter\n" " specifies the degree distribution. I{exponent} is an alias to this\n" " keyword argument.\n" "@param exponent_in: the exponent of the in-degree distribution, which\n" " must be between 2 and infinity (inclusive) It can also be negative, in\n" " which case an undirected graph will be generated.\n" "@param loops: whether loop edges are allowed.\n" "@param multiple: whether multiple edges are allowed.\n" "@param finite_size_correction: whether to apply a finite-size correction\n" " to the generated fitness values for exponents less than 3. See the\n" " paper of Cho et al for more details.\n" "@return: a directed or undirected graph with the prescribed power-law\n" " degree distributions.\n" "\n" "@newfield ref: Reference\n" "@ref: Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution\n" " in scale-free networks. Phys Rev Lett 87(27):278701, 2001.\n" "@ref: Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in\n" " scale-free networks under the Achlioptas process. Phys Rev Lett\n" " 103:135702, 2009.\n" }, // interface to igraph_tree {"Tree", (PyCFunction) igraphmodule_Graph_Tree, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Tree(n, children, type=\"undirected\")\n--\n\n" "Generates a tree in which almost all vertices have the same number of children.\n\n" "@param n: the number of vertices in the graph\n" "@param children: the number of children of a vertex in the graph\n" "@param type: determines whether the tree should be directed, and if\n" " this is the case, also its orientation. Must be one of\n" " C{\"in\"}, C{\"out\"} and C{\"undirected\"}.\n"}, /* interface to igraph_degree_sequence_game */ {"Degree_Sequence", (PyCFunction) igraphmodule_Graph_Degree_Sequence, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Degree_Sequence(out, in_=None, method=\"simple\")\n--\n\n" "Generates a graph with a given degree sequence.\n\n" "@param out: the out-degree sequence for a directed graph. If the\n" " in-degree sequence is omitted, the generated graph\n" " will be undirected, so this will be the in-degree\n" " sequence as well\n" "@param in_: the in-degree sequence for a directed graph.\n" " If omitted, the generated graph will be undirected.\n" "@param method: the generation method to be used. One of the following:\n" " \n" " - C{\"simple\"} -- simple generator that sometimes generates\n" " loop edges and multiple edges. The generated graph is not\n" " guaranteed to be connected.\n" " - C{\"no_multiple\"} -- similar to C{\"simple\"} but avoids the\n" " generation of multiple and loop edges at the expense of increased\n" " time complexity. The method will re-start the generation every time\n" " it gets stuck in a configuration where it is not possible to insert\n" " any more edges without creating loops or multiple edges, and there\n" " is no upper bound on the number of iterations, but it will succeed\n" " eventually if the input degree sequence is graphical and throw an\n" " exception if the input degree sequence is not graphical.\n" " - C{\"vl\"} -- a more sophisticated generator that can sample\n" " undirected, connected simple graphs uniformly. It uses\n" " Monte-Carlo methods to randomize the graphs.\n" " This generator should be favoured if undirected and connected\n" " graphs are to be generated and execution time is not a concern.\n" " igraph uses the original implementation of Fabien Viger; see the\n" " following URL and the paper cited on it for the details of the\n" " algorithm: U{https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html}.\n" }, /* interface to igraph_isoclass_create */ {"Isoclass", (PyCFunction) igraphmodule_Graph_Isoclass, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Isoclass(n, cls, directed=False)\n--\n\n" "Generates a graph with a given isomorphism class.\n\n" "@param n: the number of vertices in the graph (3 or 4)\n" "@param cls: the isomorphism class\n" "@param directed: whether the graph should be directed.\n"}, /* interface to igraph_tree_game */ {"Tree_Game", (PyCFunction) igraphmodule_Graph_Tree_Game, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Tree_Game(n, directed=False, method=\"lerw\")\n--\n\n" "Generates a random tree by sampling uniformly from the set of labelled\n" "trees with a given number of nodes.\n\n" "@param n: the number of vertices in the tree\n" "@param directed: whether the graph should be directed\n" "@param method: the generation method to be used. One of the following:\n" " \n" " - C{\"prufer\"} -- samples Prufer sequences uniformly, then converts\n" " them to trees\n" " - C{\"lerw\"} -- performs a loop-erased random walk on the complete\n" " graph to uniformly sample its spanning trees (Wilson's algorithm).\n" " This is the default choice as it supports both directed and\n" " undirected graphs.\n" }, /* interface to igraph_watts_strogatz_game */ {"Watts_Strogatz", (PyCFunction) igraphmodule_Graph_Watts_Strogatz, METH_VARARGS | METH_CLASS | METH_KEYWORDS, "Watts_Strogatz(dim, size, nei, p, loops=False, multiple=False)\n--\n\n" "@param dim: the dimension of the lattice\n" "@param size: the size of the lattice along all dimensions\n" "@param nei: value giving the distance (number of steps) within which\n" " two vertices will be connected.\n" "@param p: rewiring probability\n\n" "@param loops: specifies whether loop edges are allowed\n" "@param multiple: specifies whether multiple edges are allowed\n" "@see: L{Lattice()}, L{rewire()}, L{rewire_edges()} if more flexibility is\n" " needed\n" "@newfield ref: Reference\n" "@ref: Duncan J Watts and Steven H Strogatz: I{Collective dynamics of\n" " small world networks}, Nature 393, 440-442, 1998\n"}, /* interface to igraph_weighted_adjacency */ {"Weighted_Adjacency", (PyCFunction) igraphmodule_Graph_Weighted_Adjacency, METH_CLASS | METH_VARARGS | METH_KEYWORDS, "Weighted_Adjacency(matrix, mode=\"directed\", attr=\"weight\", loops=True)\n--\n\n" "Generates a graph from its adjacency matrix.\n\n" "@param matrix: the adjacency matrix\n" "@param mode: the mode to be used. Possible values are:\n" "\n" " - C{\"directed\"} - the graph will be directed and a matrix\n" " element gives the number of edges between two vertices.\n" " - C{\"undirected\"} - alias to C{\"max\"} for convenience.\n" " - C{\"max\"} - undirected graph will be created and the number of\n" " edges between vertex M{i} and M{j} is M{max(A(i,j), A(j,i))}\n" " - C{\"min\"} - like C{\"max\"}, but with M{min(A(i,j), A(j,i))}\n" " - C{\"plus\"} - like C{\"max\"}, but with M{A(i,j) + A(j,i)}\n" " - C{\"upper\"} - undirected graph with the upper right triangle of\n" " the matrix (including the diagonal)\n" " - C{\"lower\"} - undirected graph with the lower left triangle of\n" " the matrix (including the diagonal)\n" "@param attr: the name of the edge attribute that stores the edge\n" " weights.\n" "@param loops: whether to include loop edges. When C{False}, the diagonal\n" " of the adjacency matrix will be ignored.\n" }, ///////////////////////////////////// // STRUCTURAL PROPERTIES OF GRAPHS // ///////////////////////////////////// // interface to igraph_are_connected {"are_connected", (PyCFunction) igraphmodule_Graph_are_connected, METH_VARARGS | METH_KEYWORDS, "are_connected(v1, v2)\n--\n\n" "Decides whether two given vertices are directly connected.\n\n" "@param v1: the ID or name of the first vertex\n" "@param v2: the ID or name of the second vertex\n" "@return: C{True} if there exists an edge from v1 to v2, C{False}\n" " otherwise.\n"}, /* interface to igraph_articulation_points */ {"articulation_points", (PyCFunction)igraphmodule_Graph_articulation_points, METH_NOARGS, "articulation_points()\n--\n\n" "Returns the list of articulation points in the graph.\n\n" "A vertex is an articulation point if its removal increases the number of\n" "connected components in the graph.\n" }, /* interface to igraph_assortativity */ {"assortativity", (PyCFunction)igraphmodule_Graph_assortativity, METH_VARARGS | METH_KEYWORDS, "assortativity(types1, types2=None, directed=True)\n--\n\n" "Returns the assortativity of the graph based on numeric properties\n" "of the vertices.\n\n" "This coefficient is basically the correlation between the actual\n" "connectivity patterns of the vertices and the pattern expected from the\n" "disribution of the vertex types.\n\n" "See equation (21) in Newman MEJ: Mixing patterns in networks, Phys Rev E\n" "67:026126 (2003) for the proper definition. The actual calculation is\n" "performed using equation (26) in the same paper for directed graphs, and\n" "equation (4) in Newman MEJ: Assortative mixing in networks, Phys Rev Lett\n" "89:208701 (2002) for undirected graphs.\n\n" "@param types1: vertex types in a list or the name of a vertex attribute\n" " holding vertex types. Types are ideally denoted by numeric values.\n" "@param types2: in directed assortativity calculations, each vertex can\n" " have an out-type and an in-type. In this case, I{types1} contains the\n" " out-types and this parameter contains the in-types in a list or the\n" " name of a vertex attribute. If C{None}, it is assumed to be equal\n" " to I{types1}.\n\n" "@param directed: whether to consider edge directions or not.\n" "@return: the assortativity coefficient\n\n" "@newfield ref: Reference\n" "@ref: Newman MEJ: Mixing patterns in networks, Phys Rev E 67:026126, 2003.\n" "@ref: Newman MEJ: Assortative mixing in networks, Phys Rev Lett 89:208701,\n" " 2002.\n" "@see: L{assortativity_degree()} when the types are the vertex degrees\n" }, /* interface to igraph_assortativity_degree */ {"assortativity_degree", (PyCFunction)igraphmodule_Graph_assortativity_degree, METH_VARARGS | METH_KEYWORDS, "assortativity_degree(directed=True)\n--\n\n" "Returns the assortativity of a graph based on vertex degrees.\n\n" "See L{assortativity()} for the details. L{assortativity_degree()} simply\n" "calls L{assortativity()} with the vertex degrees as types.\n\n" "@param directed: whether to consider edge directions for directed graphs\n" " or not. This argument is ignored for undirected graphs.\n" "@return: the assortativity coefficient\n\n" "@see: L{assortativity()}\n" }, /* interface to igraph_assortativity_nominal */ {"assortativity_nominal", (PyCFunction)igraphmodule_Graph_assortativity_nominal, METH_VARARGS | METH_KEYWORDS, "assortativity_nominal(types, directed=True)\n--\n\n" "Returns the assortativity of the graph based on vertex categories.\n\n" "Assuming that the vertices belong to different categories, this\n" "function calculates the assortativity coefficient, which specifies\n" "the extent to which the connections stay within categories. The\n" "assortativity coefficient is one if all the connections stay within\n" "categories and minus one if all the connections join vertices of\n" "different categories. For a randomly connected network, it is\n" "asymptotically zero.\n\n" "See equation (2) in Newman MEJ: Mixing patterns in networks, Phys Rev E\n" "67:026126 (2003) for the proper definition.\n\n" "@param types: vertex types in a list or the name of a vertex attribute\n" " holding vertex types. Types should be denoted by numeric values.\n" "@param directed: whether to consider edge directions or not.\n" "@return: the assortativity coefficient\n\n" "@newfield ref: Reference\n" "@ref: Newman MEJ: Mixing patterns in networks, Phys Rev E 67:026126, 2003.\n" }, /* interface to igraph_average_path_length */ {"average_path_length", (PyCFunction) igraphmodule_Graph_average_path_length, METH_VARARGS | METH_KEYWORDS, "average_path_length(directed=True, unconn=True)\n--\n\n" "Calculates the average path length in a graph.\n\n" "@param directed: whether to consider directed paths in case of a\n" " directed graph. Ignored for undirected graphs.\n" "@param unconn: what to do when the graph is unconnected. If C{True},\n" " the average of the geodesic lengths in the components is\n" " calculated. Otherwise for all unconnected vertex pairs,\n" " a path length equal to the number of vertices is used.\n" "@return: the average path length in the graph\n"}, /* interface to igraph_authority_score */ {"authority_score", (PyCFunction)igraphmodule_Graph_authority_score, METH_VARARGS | METH_KEYWORDS, "authority_score(weights=None, scale=True, arpack_options=None, return_eigenvalue=False)\n--\n\n" "Calculates Kleinberg's authority score for the vertices of the graph\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param scale: whether to normalize the scores so that the largest one\n" " is 1.\n" "@param arpack_options: an L{ARPACKOptions} object used to fine-tune\n" " the ARPACK eigenvector calculation. If omitted, the module-level\n" " variable called C{arpack_options} is used.\n" "@param return_eigenvalue: whether to return the largest eigenvalue\n" "@return: the authority scores in a list and optionally the largest eigenvalue\n" " as a second member of a tuple\n\n" "@see: hub_score()\n" }, /* interface to igraph_betweenness[_estimate] */ {"betweenness", (PyCFunction) igraphmodule_Graph_betweenness, METH_VARARGS | METH_KEYWORDS, "betweenness(vertices=None, directed=True, cutoff=None, weights=None)\n--\n\n" "Calculates or estimates the betweenness of vertices in a graph.\n\n" "Keyword arguments:\n" "@param vertices: the vertices for which the betweennesses must be returned.\n" " If C{None}, assumes all of the vertices in the graph.\n" "@param directed: whether to consider directed paths.\n" "@param cutoff: if it is an integer, only paths less than or equal to this\n" " length are considered, effectively resulting in an estimation of the\n" " betweenness for the given vertices. If C{None}, the exact betweenness is\n" " returned.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: the (possibly estimated) betweenness of the given vertices in a list\n"}, /* interface to biconnected_components */ {"biconnected_components", (PyCFunction) igraphmodule_Graph_biconnected_components, METH_VARARGS | METH_KEYWORDS, "biconnected_components(return_articulation_points=True)\n--\n\n" "Calculates the biconnected components of the graph.\n\n" "Components containing a single vertex only are not considered as being\n" "biconnected.\n\n" "@param return_articulation_points: whether to return the articulation\n" " points as well\n" "@return: a list of lists containing edge indices making up spanning trees\n" " of the biconnected components (one spanning tree for each component)\n" " and optionally the list of articulation points" }, /* interface to igraph_bipartite_projection */ {"bipartite_projection", (PyCFunction) igraphmodule_Graph_bipartite_projection, METH_VARARGS | METH_KEYWORDS, "bipartite_projection(types, multiplicity=True, probe1=-1, which=-1)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.bipartite_projection()\n"}, /* interface to igraph_bipartite_projection_size */ {"bipartite_projection_size", (PyCFunction) igraphmodule_Graph_bipartite_projection_size, METH_VARARGS | METH_KEYWORDS, "bipartite_projection_size(types)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.bipartite_projection_size()\n"}, /* interface to igraph_bridges */ {"bridges", (PyCFunction)igraphmodule_Graph_bridges, METH_NOARGS, "bridges()\n--\n\n" "Returns the list of bridges in the graph.\n\n" "An edge is a bridge if its removal increases the number of (weakly) connected\n" "components in the graph.\n" }, /* interface to igraph_is_chordal with alternative arguments */ {"chordal_completion", (PyCFunction)igraphmodule_Graph_chordal_completion, METH_VARARGS | METH_KEYWORDS, "chordal_complation(alpha=None, alpham1=None)\n--\n\n" "Returns the list of edges needed to be added to the graph to make it chordal.\n\n" "A graph is chordal if each of its cycles of four or more nodes\n" "has a chord, i.e. an edge joining two nodes that are not\n" "adjacent in the cycle. An equivalent definition is that any\n" "chordless cycles have at most three nodes.\n\n" "The chordal completion of a graph is the list of edges that needed to be\n" "added to the graph to make it chordal. It is an empty list if the graph is\n" "already chordal.\n\n" "Note that at the moment igraph does not guarantee that the returned\n" "chordal completion is I{minimal}; there may exist a subset of the returned\n" "chordal completion that is still a valid chordal completion.\n\n" "@param alpha: the alpha vector from the result of calling\n" " L{maximum_cardinality_search()} on the graph. Useful only if you already\n" " have the alpha vector; simply passing C{None} here will make igraph\n" " calculate the alpha vector on its own.\n" "@param alpham1: the inverse alpha vector from the result of calling\n" " L{maximum_cardinality_search()} on the graph. Useful only if you already\n" " have the inverse alpha vector; simply passing C{None} here will make\n" " igraph calculate the inverse alpha vector on its own.\n" "@return: the list of edges to add to the graph; each item in the list is a\n" " source-target pair of vertex indices.\n" }, /* interface to igraph_closeness */ {"closeness", (PyCFunction) igraphmodule_Graph_closeness, METH_VARARGS | METH_KEYWORDS, "closeness(vertices=None, mode=\"all\", cutoff=None, weights=None, " "normalized=True)\n--\n\n" "Calculates the closeness centralities of given vertices in a graph.\n\n" "The closeness centerality of a vertex measures how easily other\n" "vertices can be reached from it (or the other way: how easily it\n" "can be reached from the other vertices). It is defined as the\n" "number of vertices minus one divided by the sum of\n" "the lengths of all geodesics from/to the given vertex.\n\n" "If the graph is not connected, and there is no path between two\n" "vertices, the number of vertices is used instead the length of\n" "the geodesic. This is always longer than the longest possible\n" "geodesic.\n\n" "@param vertices: the vertices for which the closenesses must\n" " be returned. If C{None}, uses all of the vertices in the graph.\n" "@param mode: must be one of C{\"in\"}, C{\"out\"} and C{\"all\"}. C{\"in\"} means\n" " that the length of the incoming paths, C{\"out\"} means that the\n" " length of the outgoing paths must be calculated. C{\"all\"} means\n" " that both of them must be calculated.\n" "@param cutoff: if it is an integer, only paths less than or equal to this\n" " length are considered, effectively resulting in an estimation of the\n" " closeness for the given vertices (which is always an underestimation of the\n" " real closeness, since some vertex pairs will appear as disconnected even\n" " though they are connected).. If C{None}, the exact closeness is\n" " returned.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param normalized: Whether to normalize the raw closeness scores by\n" " multiplying by the number of vertices minus one.\n" "@return: the calculated closenesses in a list\n"}, /* interface to igraph_harmonic_centrality */ {"harmonic_centrality", (PyCFunction) igraphmodule_Graph_harmonic_centrality, METH_VARARGS | METH_KEYWORDS, "harmonic_centrality(vertices=None, mode=\"all\", cutoff=None, weights=None, " "normalized=True)\n--\n\n" "Calculates the harmonic centralities of given vertices in a graph.\n\n" "The harmonic centerality of a vertex measures how easily other\n" "vertices can be reached from it (or the other way: how easily it\n" "can be reached from the other vertices). It is defined as the\n" "mean inverse distance to all other vertices.\n\n" "If the graph is not connected, and there is no path between two\n" "vertices, the inverse distance is taken to be zero.\n\n" "@param vertices: the vertices for which the harmonic centrality must\n" " be returned. If C{None}, uses all of the vertices in the graph.\n" "@param mode: must be one of C{\"in\"}, C{\"out\"} and C{\"all\"}. C{\"in\"} means\n" " that the length of the incoming paths, C{\"out\"} means that the\n" " length of the outgoing paths must be calculated. C{\"all\"} means\n" " that both of them must be calculated.\n" "@param cutoff: if it is not C{None}, only paths less than or equal to this\n" " length are considered.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param normalized: Whether to normalize the result. If True, the\n" " result is the mean inverse path length to other vertices, i.e. it\n" " is normalized by the number of vertices minus one. If False, the\n" " result is the sum of inverse path lengths to other vertices.\n" "@return: the calculated harmonic centralities in a list\n"}, /* interface to igraph_clusters */ {"clusters", (PyCFunction) igraphmodule_Graph_clusters, METH_VARARGS | METH_KEYWORDS, "clusters(mode=\"strong\")\n--\n\n" "Calculates the (strong or weak) clusters for a given graph.\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{VertexClustering} object.\n" " It is advised to use that.\n" "@param mode: must be either C{\"strong\"} or C{\"weak\"}, depending on\n" " the clusters being sought. Optional, defaults to C{\"strong\"}.\n" "@return: the component index for every node in the graph.\n"}, {"copy", (PyCFunction) igraphmodule_Graph_copy, METH_NOARGS, "copy()\n--\n\n" "Creates a copy of the graph.\n\n" "Attributes are copied by reference; in other words, if you use\n" "mutable Python objects as attribute values, these objects will still\n" "be shared between the old and new graph. You can use `deepcopy()`\n" "from the `copy` module if you need a truly deep copy of the graph.\n" }, {"decompose", (PyCFunction) igraphmodule_Graph_decompose, METH_VARARGS | METH_KEYWORDS, "decompose(mode=\"strong\", maxcompno=None, minelements=1)\n--\n\n" "Decomposes the graph into subgraphs.\n\n" "@param mode: must be either C{\"strong\"} or C{\"weak\"}, depending on\n" " the clusters being sought. Optional, defaults to C{\"strong\"}.\n" "@param maxcompno: maximum number of components to return.\n" " C{None} means all possible components.\n" "@param minelements: minimum number of vertices in a component.\n" " By setting this to 2, isolated vertices are not returned\n" " as separate components.\n" "@return: a list of the subgraphs. Every returned subgraph is a\n" " copy of the original.\n"}, /* interface to igraph_contract_vertices */ {"contract_vertices", (PyCFunction) igraphmodule_Graph_contract_vertices, METH_VARARGS | METH_KEYWORDS, "contract_vertices(mapping, combine_attrs=None)\n--\n\n" "Contracts some vertices in the graph, i.e. replaces groups of vertices\n" "with single vertices. Edges are not affected.\n\n" "@param mapping: numeric vector which gives the mapping between old and\n" " new vertex IDs. Vertices having the same new vertex ID in this vector\n" " will be remapped into a single new vertex. It is safe to pass the\n" " membership vector of a L{VertexClustering} object here.\n" "@param combine_attrs: specifies how to combine the attributes of\n" " the vertices being collapsed into a single one. If it is C{None},\n" " all the attributes will be lost. If it is a function, the\n" " attributes of the vertices will be collected and passed on to\n" " that function which will return the new attribute value that has to\n" " be assigned to the single collapsed vertex. It can also be one of\n" " the following string constants which define built-in collapsing\n" " functions: C{sum}, C{prod}, C{mean}, C{median}, C{max}, C{min},\n" " C{first}, C{last}, C{random}. You can also specify different\n" " combination functions for different attributes by passing a dict\n" " here which maps attribute names to functions. See\n" " L{simplify()} for more details.\n" "@return: C{None}.\n" "@see: L{simplify()}\n" }, /* interface to igraph_constraint */ {"constraint", (PyCFunction) igraphmodule_Graph_constraint, METH_VARARGS | METH_KEYWORDS, "constraint(vertices=None, weights=None)\n--\n\n" "Calculates Burt's constraint scores for given vertices in a graph.\n\n" "Burt's constraint is higher if ego has less, or mutually stronger\n" "related (i.e. more redundant) contacts. Burt's measure of\n" "constraint, C[i], of vertex i's ego network V[i], is defined for\n" "directed and valued graphs as follows:\n\n" "C[i] = sum( sum( (p[i,q] p[q,j])^2, q in V[i], q != i,j ), j in V[], j != i)\n\n" "for a graph of order (ie. number od vertices) N, where proportional\n" "tie strengths are defined as follows:\n\n" "p[i,j]=(a[i,j]+a[j,i]) / sum(a[i,k]+a[k,i], k in V[i], k != i),\n" "a[i,j] are elements of A and the latter being the graph adjacency matrix.\n\n" "For isolated vertices, constraint is undefined.\n\n" "@param vertices: the vertices to be analysed or C{None} for all vertices.\n" "@param weights: weights associated to the edges. Can be an attribute name\n" " as well. If C{None}, every edge will have the same weight.\n" "@return: constraint scores for all given vertices in a matrix."}, /* interface to igraph_density */ {"density", (PyCFunction) igraphmodule_Graph_density, METH_VARARGS | METH_KEYWORDS, "density(loops=False)\n--\n\n" "Calculates the density of the graph.\n\n" "@param loops: whether to take loops into consideration. If C{True},\n" " the algorithm assumes that there might be some loops in the graph\n" " and calculates the density accordingly. If C{False}, the algorithm\n" " assumes that there can't be any loops.\n" "@return: the density of the graph."}, /* interfaces to igraph_diameter */ {"diameter", (PyCFunction) igraphmodule_Graph_diameter, METH_VARARGS | METH_KEYWORDS, "diameter(directed=True, unconn=True, weights=None)\n--\n\n" "Calculates the diameter of the graph.\n\n" "@param directed: whether to consider directed paths.\n" "@param unconn: if C{True} and the graph is unconnected, the\n" " longest geodesic within a component will be returned. If\n" " C{False} and the graph is unconnected, the result is the\n" " number of vertices if there are no weights or infinity\n" " if there are weights.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: the diameter"}, {"get_diameter", (PyCFunction) igraphmodule_Graph_get_diameter, METH_VARARGS | METH_KEYWORDS, "get_diameter(directed=True, unconn=True, weights=None)\n--\n\n" "Returns a path with the actual diameter of the graph.\n\n" "If there are many shortest paths with the length of the diameter,\n" "it returns the first one it founds.\n\n" "@param directed: whether to consider directed paths.\n" "@param unconn: if C{True} and the graph is unconnected, the\n" " longest geodesic within a component will be returned. If\n" " C{False} and the graph is unconnected, the result is the\n" " number of vertices if there are no weights or infinity\n" " if there are weights.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: the vertices in the path in order."}, {"farthest_points", (PyCFunction) igraphmodule_Graph_farthest_points, METH_VARARGS | METH_KEYWORDS, "farthest_points(directed=True, unconn=True, weights=None)\n--\n\n" "Returns two vertex IDs whose distance equals the actual diameter\n" "of the graph.\n\n" "If there are many shortest paths with the length of the diameter,\n" "it returns the first one it found.\n\n" "@param directed: whether to consider directed paths.\n" "@param unconn: if C{True} and the graph is unconnected, the\n" " longest geodesic within a component will be returned. If\n" " C{False} and the graph is unconnected, the result contains the\n" " number of vertices if there are no weights or infinity\n" " if there are weights.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: a triplet containing the two vertex IDs and their distance.\n" " The IDs are C{None} if the graph is unconnected and C{unconn}\n" " is C{False}."}, /* interface to igraph_diversity */ {"diversity", (PyCFunction) igraphmodule_Graph_diversity, METH_VARARGS | METH_KEYWORDS, "diversity(vertices=None, weights=None)\n--\n\n" "Calculates the structural diversity index of the vertices.\n\n" "The structural diversity index of a vertex is simply the (normalized)\n" "Shannon entropy of the weights of the edges incident on the vertex.\n\n" "The measure is defined for undirected graphs only; edge directions are\n" "ignored.\n\n" "@param vertices: the vertices for which the diversity indices must\n" " be returned. If C{None}, uses all of the vertices in the graph.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: the calculated diversity indices in a list, or a single number if\n" " a single vertex was supplied.\n" "@newfield ref: Reference\n" "@ref: Eagle N, Macy M and Claxton R: Network diversity and economic\n" " development, Science 328, 1029--1031, 2010." }, /* interface to igraph_eccentricity */ {"eccentricity", (PyCFunction) igraphmodule_Graph_eccentricity, METH_VARARGS | METH_KEYWORDS, "eccentricity(vertices=None, mode=\"all\")\n--\n\n" "Calculates the eccentricities of given vertices in a graph.\n\n" "The eccentricity of a vertex is calculated by measuring the\n" "shortest distance from (or to) the vertex, to (or from) all other\n" "vertices in the graph, and taking the maximum.\n\n" "@param vertices: the vertices for which the eccentricity scores must\n" " be returned. If C{None}, uses all of the vertices in the graph.\n" "@param mode: must be one of C{\"in\"}, C{\"out\"} and C{\"all\"}. C{\"in\"} means\n" " that edge directions are followed; C{\"out\"} means that edge directions\n" " are followed the opposite direction; C{\"all\"} means that directions are\n" " ignored. The argument has no effect for undirected graphs.\n" "@return: the calculated eccentricities in a list, or a single number if\n" " a single vertex was supplied.\n"}, /* interface to igraph_edge_betweenness[_estimate] */ {"edge_betweenness", (PyCFunction) igraphmodule_Graph_edge_betweenness, METH_VARARGS | METH_KEYWORDS, "edge_betweenness(directed=True, cutoff=None, weights=None)\n--\n\n" "Calculates or estimates the edge betweennesses in a graph.\n\n" "@param directed: whether to consider directed paths.\n" "@param cutoff: if it is an integer, only paths less than or equal to this\n" " length are considered, effectively resulting in an estimation of the\n" " betweenness values. If C{None}, the exact betweennesses are\n" " returned.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: a list with the (exact or estimated) edge betweennesses of all\n" " edges.\n"}, {"eigen_adjacency", (PyCFunction) igraphmodule_Graph_eigen_adjacency, METH_VARARGS | METH_KEYWORDS, "" }, /* interface to igraph_[st_]edge_connectivity */ {"edge_connectivity", (PyCFunction) igraphmodule_Graph_edge_connectivity, METH_VARARGS | METH_KEYWORDS, "edge_connectivity(source=-1, target=-1, checks=True)\n--\n\n" "Calculates the edge connectivity of the graph or between some vertices.\n\n" "The edge connectivity between two given vertices is the number of edges\n" "that have to be removed in order to disconnect the two vertices into two\n" "separate components. This is also the number of edge disjoint directed\n" "paths between the vertices. The edge connectivity of the graph is the minimal\n" "edge connectivity over all vertex pairs.\n\n" "This method calculates the edge connectivity of a given vertex pair if both\n" "the source and target vertices are given. If none of them is given (or they\n" "are both negative), the overall edge connectivity is returned.\n\n" "@param source: the source vertex involved in the calculation.\n" "@param target: the target vertex involved in the calculation.\n" "@param checks: if the whole graph connectivity is calculated and this is\n" " C{True}, igraph performs some basic checks before calculation. If the\n" " graph is not strongly connected, then the connectivity is obviously\n" " zero. If the minimum degree is one, then the connectivity is\n" " also one. These simple checks are much faster than checking the entire\n" " graph, therefore it is advised to set this to C{True}. The parameter\n" " is ignored if the connectivity between two given vertices is computed.\n" "@return: the edge connectivity\n" }, /* interface to igraph_eigenvector_centrality */ {"eigenvector_centrality", (PyCFunction) igraphmodule_Graph_eigenvector_centrality, METH_VARARGS | METH_KEYWORDS, "eigenvector_centrality(directed=True, scale=True, weights=None, " "return_eigenvalue=False, arpack_options=None)\n--\n\n" "Calculates the eigenvector centralities of the vertices in a graph.\n\n" "Eigenvector centrality is a measure of the importance of a node in a\n" "network. It assigns relative scores to all nodes in the network based\n" "on the principle that connections from high-scoring nodes contribute\n" "more to the score of the node in question than equal connections from\n" "low-scoring nodes. In practice, the centralities are determined by calculating\n" "eigenvector corresponding to the largest positive eigenvalue of the\n" "adjacency matrix. In the undirected case, this function considers\n" "the diagonal entries of the adjacency matrix to be twice the number of\n" "self-loops on the corresponding vertex.\n\n" "In the directed case, the left eigenvector of the adjacency matrix is\n" "calculated. In other words, the centrality of a vertex is proportional\n" "to the sum of centralities of vertices pointing to it.\n\n" "Eigenvector centrality is meaningful only for connected graphs.\n" "Graphs that are not connected should be decomposed into connected\n" "components, and the eigenvector centrality calculated for each separately.\n\n" "@param directed: whether to consider edge directions in a directed\n" " graph. Ignored for undirected graphs.\n" "@param scale: whether to normalize the centralities so the largest\n" " one will always be 1.\n" "@param weights: edge weights given as a list or an edge attribute. If\n" " C{None}, all edges have equal weight.\n" "@param return_eigenvalue: whether to return the actual largest\n" " eigenvalue along with the centralities\n" "@param arpack_options: an L{ARPACKOptions} object that can be used\n" " to fine-tune the calculation. If it is omitted, the module-level\n" " variable called C{arpack_options} is used.\n" "@return: the eigenvector centralities in a list and optionally the\n" " largest eigenvalue (as a second member of a tuple)" }, /* interface to igraph_feedback_arc_set */ {"feedback_arc_set", (PyCFunction) igraphmodule_Graph_feedback_arc_set, METH_VARARGS | METH_KEYWORDS, "feedback_arc_set(weights=None, method=\"eades\")\n--\n\n" "Calculates an approximately or exactly minimal feedback arc set.\n\n" "A feedback arc set is a set of edges whose removal makes the graph acyclic.\n" "Since this is always possible by removing all the edges, we are in general\n" "interested in removing the smallest possible number of edges, or an edge set\n" "with as small total weight as possible. This method calculates one such edge\n" "set. Note that the task is trivial for an undirected graph as it is enough\n" "to find a spanning tree and then remove all the edges not in the spanning\n" "tree. Of course it is more complicated for directed graphs.\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name. When given, the algorithm will strive to\n" " remove lightweight edges in order to minimize the total weight of the\n" " feedback arc set.\n" "@param method: the algorithm to use. C{\"eades\"} uses the greedy cycle\n" " breaking heuristic of Eades, Lin and Smyth, which is linear in the number\n" " of edges but not necessarily optimal; however, it guarantees that the\n" " number of edges to be removed is smaller than |E|/2 - |V|/6. C{\"ip\"} uses\n" " an integer programming formulation which is guaranteed to yield an optimal\n" " result, but is too slow for large graphs.\n" "@return: the IDs of the edges to be removed, in a list.\n\n" "@newfield ref: Reference\n" "@ref: Eades P, Lin X and Smyth WF: A fast and effective heuristic for the\n" " feedback arc set problem. In: Proc Inf Process Lett 319-323, 1993.\n" }, // interface to igraph_get_shortest_paths {"get_shortest_paths", (PyCFunction) igraphmodule_Graph_get_shortest_paths, METH_VARARGS | METH_KEYWORDS, "get_shortest_paths(v, to=None, weights=None, mode=\"out\", output=\"vpath\")\n--\n\n" "Calculates the shortest paths from/to a given node in a graph.\n\n" "@param v: the source/destination for the calculated paths\n" "@param to: a vertex selector describing the destination/source for\n" " the calculated paths. This can be a single vertex ID, a list of\n" " vertex IDs, a single vertex name, a list of vertex names or a\n" " L{VertexSeq} object. C{None} means all the vertices.\n" "@param weights: edge weights in a list or the name of an edge attribute\n" " holding edge weights. If C{None}, all edges are assumed to have\n" " equal weight.\n" "@param mode: the directionality of the paths. C{\"in\"} means to\n" " calculate incoming paths, C{\"out\"} means to calculate outgoing\n" " paths, C{\"all\"} means to calculate both ones.\n" "@param output: determines what should be returned. If this is\n" " C{\"vpath\"}, a list of vertex IDs will be returned, one path\n" " for each target vertex. For unconnected graphs, some of the list\n" " elements may be empty. Note that in case of mode=C{\"in\"}, the vertices\n" " in a path are returned in reversed order. If C{output=\"epath\"},\n" " edge IDs are returned instead of vertex IDs.\n" "@return: see the documentation of the C{output} parameter.\n"}, /* interface to igraph_get_all_shortest_paths */ {"get_all_shortest_paths", (PyCFunction) igraphmodule_Graph_get_all_shortest_paths, METH_VARARGS | METH_KEYWORDS, "get_all_shortest_paths(v, to=None, weights=None, mode=\"out\")\n--\n\n" "Calculates all of the shortest paths from/to a given node in a graph.\n\n" "@param v: the source for the calculated paths\n" "@param to: a vertex selector describing the destination for\n" " the calculated paths. This can be a single vertex ID, a list of\n" " vertex IDs, a single vertex name, a list of vertex names or a\n" " L{VertexSeq} object. C{None} means all the vertices.\n" "@param weights: edge weights in a list or the name of an edge attribute\n" " holding edge weights. If C{None}, all edges are assumed to have\n" " equal weight.\n" "@param mode: the directionality of the paths. C{\"in\"} means to\n" " calculate incoming paths, C{\"out\"} means to calculate outgoing\n" " paths, C{\"all\"} means to calculate both ones.\n" "@return: all of the shortest path from the given node to every other\n" " reachable node in the graph in a list. Note that in case of mode=C{\"in\"},\n" " the vertices in a path are returned in reversed order!"}, /* interface to igraph_get_all_simple_paths */ {"_get_all_simple_paths", (PyCFunction) igraphmodule_Graph_get_all_simple_paths, METH_VARARGS | METH_KEYWORDS, "_get_all_simple_paths(v, to=None, cutoff=-1, mode=\"out\")\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.get_all_simple_paths()\n\n" }, /* interface to igraph_girth */ {"girth", (PyCFunction)igraphmodule_Graph_girth, METH_VARARGS | METH_KEYWORDS, "girth(return_shortest_circle=False)\n--\n\n" "Returns the girth of the graph.\n\n" "The girth of a graph is the length of the shortest circle in it.\n\n" "@param return_shortest_circle: whether to return one of the shortest\n" " circles found in the graph.\n" "@return: the length of the shortest circle or (if C{return_shortest_circle})\n" " is true, the shortest circle itself as a list\n" }, /* interface to igraph_convergence_degree */ {"convergence_degree", (PyCFunction)igraphmodule_Graph_convergence_degree, METH_NOARGS, "convergence_degree()\n--\n\n" "Undocumented (yet)." }, /* interface to igraph_convergence_field_size */ {"convergence_field_size", (PyCFunction)igraphmodule_Graph_convergence_field_size, METH_NOARGS, "convergence_field_size()\n--\n\n" "Undocumented (yet)." }, /* interface to igraph_hub_score */ {"hub_score", (PyCFunction)igraphmodule_Graph_hub_score, METH_VARARGS | METH_KEYWORDS, "hub_score(weights=None, scale=True, arpack_options=None, return_eigenvalue=False)\n--\n\n" "Calculates Kleinberg's hub score for the vertices of the graph\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param scale: whether to normalize the scores so that the largest one\n" " is 1.\n" "@param arpack_options: an L{ARPACKOptions} object used to fine-tune\n" " the ARPACK eigenvector calculation. If omitted, the module-level\n" " variable called C{arpack_options} is used.\n" "@param return_eigenvalue: whether to return the largest eigenvalue\n" "@return: the hub scores in a list and optionally the largest eigenvalue\n" " as a second member of a tuple\n\n" "@see: authority_score()\n" }, /* interface to igraph_induced_subgraph */ {"induced_subgraph", (PyCFunction) igraphmodule_Graph_induced_subgraph, METH_VARARGS | METH_KEYWORDS, "induced_subgraph(vertices, implementation=\"auto\")\n--\n\n" "Returns a subgraph spanned by the given vertices.\n\n" "@param vertices: a list containing the vertex IDs which\n" " should be included in the result.\n" "@param implementation: the implementation to use when constructing\n" " the new subgraph. igraph includes two implementations at the\n" " moment. C{\"copy_and_delete\"} copies the original graph and\n" " removes those vertices that are not in the given set. This is more\n" " efficient if the size of the subgraph is comparable to the original\n" " graph. The other implementation (C{\"create_from_scratch\"})\n" " constructs the result graph from scratch and then copies the\n" " attributes accordingly. This is a better solution if the subgraph\n" " is relatively small, compared to the original graph. C{\"auto\"}\n" " selects between the two implementations automatically, based on\n" " the ratio of the size of the subgraph and the size of the original\n" " graph.\n" "@return: the subgraph\n"}, /* interface to igraph_is_bipartite */ {"is_bipartite", (PyCFunction) igraphmodule_Graph_is_bipartite, METH_VARARGS | METH_KEYWORDS, "is_bipartite(return_types=False)\n--\n\n" "Decides whether the graph is bipartite or not.\n\n" "Vertices of a bipartite graph can be partitioned into two groups A\n" "and B in a way that all edges go between the two groups.\n\n" "@param return_types: if C{False}, the method will simply\n" " return C{True} or C{False} depending on whether the graph is\n" " bipartite or not. If C{True}, the actual group assignments\n" " are also returned as a list of boolean values. (Note that\n" " the group assignment is not unique, especially if the graph\n" " consists of multiple components, since the assignments of\n" " components are independent from each other).\n" "@return: C{True} if the graph is bipartite, C{False} if not.\n" " If C{return_types} is C{True}, the group assignment is also\n" " returned.\n" }, /* interface to igraph_is_chordal */ {"is_chordal", (PyCFunction)igraphmodule_Graph_is_chordal, METH_VARARGS | METH_KEYWORDS, "is_chordal(alpha=None, alpham1=None)\n--\n\n" "Returns whether the graph is chordal or not.\n\n" "A graph is chordal if each of its cycles of four or more nodes\n" "has a chord, i.e. an edge joining two nodes that are not\n" "adjacent in the cycle. An equivalent definition is that any\n" "chordless cycles have at most three nodes.\n\n" "@param alpha: the alpha vector from the result of calling\n" " L{maximum_cardinality_search()} on the graph. Useful only if you already\n" " have the alpha vector; simply passing C{None} here will make igraph\n" " calculate the alpha vector on its own.\n" "@param alpham1: the inverse alpha vector from the result of calling\n" " L{maximum_cardinality_search()} on the graph. Useful only if you already\n" " have the inverse alpha vector; simply passing C{None} here will make\n" " igraph calculate the inverse alpha vector on its own.\n" "@return: C{True} if the graph is chordal, C{False} otherwise.\n" }, /* interface to igraph_avg_nearest_neighbor_degree */ {"knn", (PyCFunction) igraphmodule_Graph_knn, METH_VARARGS | METH_KEYWORDS, "knn(vids=None, weights=None)\n--\n\n" "Calculates the average degree of the neighbors for each vertex, and\n" "the same quantity as the function of vertex degree.\n\n" "@param vids: the vertices for which the calculation is performed.\n" " C{None} means all vertices.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name. If this is given, the vertex strength\n" " will be used instead of the vertex degree in the calculations, but\n" " the \"ordinary\" vertex degree will be used for the second (degree-\n" " dependent) list in the result.\n" "@return: two lists in a tuple. The first list contains the average\n" " degree of neighbors for each vertex, the second contains the average\n" " degree of neighbors as a function of vertex degree. The zeroth element\n" " of this list corresponds to vertices of degree 1.\n" }, /* interface to igraph_is_connected */ {"is_connected", (PyCFunction) igraphmodule_Graph_is_connected, METH_VARARGS | METH_KEYWORDS, "is_connected(mode=\"strong\")\n--\n\n" "Decides whether the graph is connected.\n\n" "@param mode: whether we should calculate strong or weak connectivity.\n" "@return: C{True} if the graph is connected, C{False} otherwise.\n"}, /* interface to igraph_linegraph */ {"linegraph", (PyCFunction) igraphmodule_Graph_linegraph, METH_VARARGS | METH_KEYWORDS, "linegraph()\n--\n\n" "Returns the line graph of the graph.\n\n" "The line graph M{L(G)} of an undirected graph is defined as follows:\n" "M{L(G)} has one vertex for each edge in G and two vertices in M{L(G)}\n" "are connected iff their corresponding edges in the original graph\n" "share an end point.\n\n" "The line graph of a directed graph is slightly different: two vertices\n" "are connected by a directed edge iff the target of the first vertex's\n" "corresponding edge is the same as the source of the second vertex's\n" "corresponding edge.\n" }, /* interface to igraph_maxdegree */ {"maxdegree", (PyCFunction) igraphmodule_Graph_maxdegree, METH_VARARGS | METH_KEYWORDS, "maxdegree(vertices=None, mode=\"all\", loops=False)\n--\n\n" "Returns the maximum degree of a vertex set in the graph.\n\n" "This method accepts a single vertex ID or a list of vertex IDs as a\n" "parameter, and returns the degree of the given vertices (in the\n" "form of a single integer or a list, depending on the input\n" "parameter).\n" "\n" "@param vertices: a single vertex ID or a list of vertex IDs, or\n" " C{None} meaning all the vertices in the graph.\n" "@param mode: the type of degree to be returned (C{\"out\"} for\n" " out-degrees, C{\"in\"} IN for in-degrees or C{\"all\"} for the sum of\n" " them).\n" "@param loops: whether self-loops should be counted.\n"}, /* interface to maximum_cardinality_search */ {"maximum_cardinality_search", (PyCFunction) igraphmodule_Graph_maximum_cardinality_search, METH_NOARGS, "maximum_cardinality_search()\n--\n\n" "Conducts a maximum cardinality search on the graph. The function computes\n" "a rank I{alpha} for each vertex such that visiting vertices in decreasing\n" "rank order corresponds to always choosing the vertex with the most already\n" "visited neighbors as the next one to visit.\n\n" "Maximum cardinality search is useful in deciding the chordality of a graph:\n" "a graph is chordal if and only if any two neighbors of a vertex that are\n" "higher in rank than the original vertex are connected to each other.\n\n" "The result of this function can be passed to L{is_chordal()} to speed up\n" "the chordality computation if you also need the result of the maximum\n" "cardinality search for other purposes.\n\n" "@return: a tuple consisting of the rank vector and its inverse.\n" }, /* interface to igraph_neighborhood */ {"neighborhood", (PyCFunction) igraphmodule_Graph_neighborhood, METH_VARARGS | METH_KEYWORDS, "neighborhood(vertices=None, order=1, mode=\"all\", mindist=0)\n--\n\n" "For each vertex specified by I{vertices}, returns the\n" "vertices reachable from that vertex in at most I{order} steps. If\n" "I{mindist} is larger than zero, vertices that are reachable in less\n" "than I{mindist} steps are excluded.\n\n" "@param vertices: a single vertex ID or a list of vertex IDs, or\n" " C{None} meaning all the vertices in the graph.\n" "@param order: the order of the neighborhood, i.e. the maximum number of\n" " steps to take from the seed vertex.\n" "@param mode: specifies how to take into account the direction of\n" " the edges if a directed graph is analyzed. C{\"out\"} means that\n" " only the outgoing edges are followed, so all vertices reachable\n" " from the source vertex in at most I{order} steps are counted.\n" " C{\"in\"} means that only the incoming edges are followed (in\n" " reverse direction of course), so all vertices from which the source\n" " vertex is reachable in at most I{order} steps are counted. C{\"all\"}\n" " treats directed edges as undirected.\n" "@param mindist: the minimum distance required to include a vertex in the\n" " result. If this is one, the seed vertex is not included. If this is two,\n" " the direct neighbors of the seed vertex are not included either, and so on.\n" "@return: a single list specifying the neighborhood if I{vertices}\n" " was an integer specifying a single vertex index, or a list of lists\n" " if I{vertices} was a list or C{None}.\n" }, /* interface to igraph_neighborhood_size */ {"neighborhood_size", (PyCFunction) igraphmodule_Graph_neighborhood_size, METH_VARARGS | METH_KEYWORDS, "neighborhood_size(vertices=None, order=1, mode=\"all\", mindist=0)\n--\n\n" "For each vertex specified by I{vertices}, returns the number of\n" "vertices reachable from that vertex in at most I{order} steps. If\n" "I{mindist} is larger than zero, vertices that are reachable in less\n" "than I{mindist} steps are excluded.\n\n" "@param vertices: a single vertex ID or a list of vertex IDs, or\n" " C{None} meaning all the vertices in the graph.\n" "@param order: the order of the neighborhood, i.e. the maximum number of\n" " steps to take from the seed vertex.\n" "@param mode: specifies how to take into account the direction of\n" " the edges if a directed graph is analyzed. C{\"out\"} means that\n" " only the outgoing edges are followed, so all vertices reachable\n" " from the source vertex in at most I{order} steps are counted.\n" " C{\"in\"} means that only the incoming edges are followed (in\n" " reverse direction of course), so all vertices from which the source\n" " vertex is reachable in at most I{order} steps are counted. C{\"all\"}\n" " treats directed edges as undirected.\n" "@param mindist: the minimum distance required to include a vertex in the\n" " result. If this is one, the seed vertex is not counted. If this is two,\n" " the direct neighbors of the seed vertex are not counted either, and so on.\n" "@return: a single number specifying the neighborhood size if I{vertices}\n" " was an integer specifying a single vertex index, or a list of sizes\n" " if I{vertices} was a list or C{None}.\n" }, /* interface to igraph_personalized_pagerank */ {"personalized_pagerank", (PyCFunction) igraphmodule_Graph_personalized_pagerank, METH_VARARGS | METH_KEYWORDS, "personalized_pagerank(vertices=None, directed=True, damping=0.85,\n" " reset=None, reset_vertices=None, weights=None, \n" " arpack_options=None, implementation=\"prpack\", niter=1000,\n" " eps=0.001)\n--\n\n" "Calculates the personalized PageRank values of a graph.\n\n" "The personalized PageRank calculation is similar to the PageRank\n" "calculation, but the random walk is reset to a non-uniform distribution\n" "over the vertices in every step with probability M{1-damping} instead of a\n" "uniform distribution.\n\n" "@param vertices: the indices of the vertices being queried.\n" " C{None} means all of the vertices.\n" "@param directed: whether to consider directed paths.\n" "@param damping: the damping factor.\n" " M{1-damping} is the PageRank value for vertices with no\n" " incoming links.\n" "@param reset: the distribution over the vertices to be used when resetting\n" " the random walk. Can be a sequence, an iterable or a vertex attribute\n" " name as long as they return a list of floats whose length is equal to\n" " the number of vertices. If C{None}, a uniform distribution is assumed,\n" " which makes the method equivalent to the original PageRank algorithm.\n" "@param reset_vertices: an alternative way to specify the distribution\n" " over the vertices to be used when resetting the random walk. Simply\n" " supply a list of vertex IDs here, or a L{VertexSeq} or a L{Vertex}.\n" " Resetting will take place using a uniform distribution over the specified\n" " vertices.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param arpack_options: an L{ARPACKOptions} object used to fine-tune\n" " the ARPACK eigenvector calculation. If omitted, the module-level\n" " variable called C{arpack_options} is used. This argument is\n" " ignored if not the ARPACK implementation is used, see the \n" " I{implementation} argument.\n" "@param implementation: which implementation to use to solve the \n" " PageRank eigenproblem. Possible values are:\n\n" " - C{\"prpack\"}: use the PRPACK library. This is a new \n" " implementation in igraph 0.7\n\n" " - C{\"arpack\"}: use the ARPACK library. This implementation\n" " was used from version 0.5, until version 0.7.\n\n" " - C{\"power\"}: use a simple power method. This is the\n" " implementation that was used before igraph version 0.5.\n\n" "@param niter: The number of iterations to use in the power method\n" " implementation. It is ignored in the other implementations.\n" "@param eps: The power method implementation will consider the\n" " calculation as complete if the difference of PageRank values between\n" " iterations change less than this value for every node. It is \n" " ignored by the other implementations.\n" "@return: a list with the personalized PageRank values of the specified\n" " vertices.\n"}, /* interface to igraph_path_length_hist */ {"path_length_hist", (PyCFunction) igraphmodule_Graph_path_length_hist, METH_VARARGS | METH_KEYWORDS, "path_length_hist(directed=True)\n--\n\n" "Calculates the path length histogram of the graph\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param directed: whether to consider directed paths\n" "@return: a tuple. The first item of the tuple is a list of path lengths,\n" " the M{i}th element of the list contains the number of paths with length\n" " M{i+1}. The second item contains the number of unconnected vertex pairs\n" " as a float (since it might not fit into an integer)\n" }, /* interface to igraph_permute_vertices */ {"permute_vertices", (PyCFunction) igraphmodule_Graph_permute_vertices, METH_VARARGS | METH_KEYWORDS, "permute_vertices(permutation)\n--\n\n" "Permutes the vertices of the graph according to the given permutation\n" "and returns the new graph.\n\n" "Vertex M{k} of the original graph will become vertex M{permutation[k]}\n" "in the new graph. No validity checks are performed on the permutation\n" "vector.\n\n" "@return: the new graph\n" }, /* interfaces to igraph_radius */ {"radius", (PyCFunction) igraphmodule_Graph_radius, METH_VARARGS | METH_KEYWORDS, "radius(mode=\"out\")\n--\n\n" "Calculates the radius of the graph.\n\n" "The radius of a graph is defined as the minimum eccentricity of\n" "its vertices (see L{eccentricity()}).\n" "@param mode: what kind of paths to consider for the calculation\n" " in case of directed graphs. C{OUT} considers paths that follow\n" " edge directions, C{IN} considers paths that follow the opposite\n" " edge directions, C{ALL} ignores edge directions. The argument is\n" " ignored for undirected graphs.\n" "@return: the radius\n" "@see: L{eccentricity()}" }, /* interface to igraph_reciprocity */ {"reciprocity", (PyCFunction) igraphmodule_Graph_reciprocity, METH_VARARGS | METH_KEYWORDS, "reciprocity(ignore_loops=True, mode=\"default\")\n--\n\n" "Reciprocity defines the proportion of mutual connections in a\n" "directed graph. It is most commonly defined as the probability\n" "that the opposite counterpart of a directed edge is also included\n" "in the graph. This measure is calculated if C{mode} is C{\"default\"}.\n" "\n" "Prior to igraph 0.6, another measure was implemented, defined as\n" "the probability of mutual connection between a vertex pair if we\n" "know that there is a (possibly non-mutual) connection between them.\n" "In other words, (unordered) vertex pairs are classified into three\n" "groups: (1) disconnected, (2) non-reciprocally connected and (3)\n" "reciprocally connected. The result is the size of group (3), divided\n" "by the sum of sizes of groups (2) and (3). This measure is calculated\n" "if C{mode} is C{\"ratio\"}.\n" "\n" "@param ignore_loops: whether loop edges should be ignored.\n" "@param mode: the algorithm to use to calculate the reciprocity; see\n" " above for more details.\n" "@return: the reciprocity of the graph\n" }, /* interface to igraph_rewire */ {"rewire", (PyCFunction) igraphmodule_Graph_rewire, METH_VARARGS | METH_KEYWORDS, "rewire(n=1000, mode=\"simple\")\n--\n\n" "Randomly rewires the graph while preserving the degree distribution.\n\n" "Please note that the rewiring is done \"in-place\", so the original\n" "graph will be modified. If you want to preserve the original graph,\n" "use the L{copy} method before.\n\n" "@param n: the number of rewiring trials.\n" "@param mode: the rewiring algorithm to use. It can either be C{\"simple\"} or\n" " C{\"loops\"}; the former does not create or destroy loop edges while the\n" " latter does.\n"}, /* interface to igraph_rewire_edges */ {"rewire_edges", (PyCFunction) igraphmodule_Graph_rewire_edges, METH_VARARGS | METH_KEYWORDS, "rewire_edges(prob, loops=False, multiple=False)\n--\n\n" "Rewires the edges of a graph with constant probability.\n\n" "Each endpoint of each edge of the graph will be rewired with a constant\n" "probability, given in the first argument.\n\n" "Please note that the rewiring is done \"in-place\", so the original\n" "graph will be modified. If you want to preserve the original graph,\n" "use the L{copy} method before.\n\n" "@param prob: rewiring probability\n" "@param loops: whether the algorithm is allowed to create loop edges\n" "@param multiple: whether the algorithm is allowed to create multiple\n" " edges.\n"}, /* interface to igraph_shortest_paths */ {"shortest_paths", (PyCFunction) igraphmodule_Graph_shortest_paths, METH_VARARGS | METH_KEYWORDS, "shortest_paths(source=None, target=None, weights=None, mode=\"out\")\n--\n\n" "Calculates shortest path lengths for given vertices in a graph.\n\n" "The algorithm used for the calculations is selected automatically:\n" "a simple BFS is used for unweighted graphs, Dijkstra's algorithm is\n" "used when all the weights are positive. Otherwise, the Bellman-Ford\n" "algorithm is used if the number of requested source vertices is larger\n" "than 100 and Johnson's algorithm is used otherwise.\n\n" "@param source: a list containing the source vertex IDs which should be\n" " included in the result. If C{None}, all vertices will be considered.\n" "@param target: a list containing the target vertex IDs which should be\n" " included in the result. If C{None}, all vertices will be considered.\n" "@param weights: a list containing the edge weights. It can also be\n" " an attribute name (edge weights are retrieved from the given\n" " attribute) or C{None} (all edges have equal weight).\n" "@param mode: the type of shortest paths to be used for the\n" " calculation in directed graphs. C{\"out\"} means only outgoing,\n" " C{\"in\"} means only incoming paths. C{\"all\"} means to consider\n" " the directed graph as an undirected one.\n" "@return: the shortest path lengths for given vertices in a matrix\n"}, /* interface to igraph_simplify */ {"simplify", (PyCFunction) igraphmodule_Graph_simplify, METH_VARARGS | METH_KEYWORDS, "simplify(multiple=True, loops=True, combine_edges=None)\n--\n\n" "Simplifies a graph by removing self-loops and/or multiple edges.\n\n" "\n" "For example, suppose you have a graph with an edge attribute named\n" "C{weight}. C{graph.simplify(combine_edges=max)} will take the\n" "maximum of the weights of multiple edges and assign that weight to\n" "the collapsed edge. C{graph.simplify(combine_edges=sum)} will\n" "take the sum of the weights. You can also write\n" "C{graph.simplify(combine_edges=dict(weight=\"sum\"))} or\n" "C{graph.simplify(combine_edges=dict(weight=sum))}, since\n" "C{sum} is recognised both as a Python built-in function and as\n" "a string constant.\n\n" "@param multiple: whether to remove multiple edges.\n" "@param loops: whether to remove loops.\n" "@param combine_edges: specifies how to combine the attributes of\n" " multiple edges between the same pair of vertices into a single\n" " attribute. If it is C{None}, only one of the edges will be kept\n" " and all the attributes will be lost. If it is a function, the\n" " attributes of multiple edges will be collected and passed on to\n" " that function which will return the new attribute value that has to\n" " be assigned to the single collapsed edge. It can also be one of\n" " the following string constants:\n\n" " - C{\"ignore\"}: all the edge attributes will be ignored.\n\n" " - C{\"sum\"}: the sum of the edge attribute values will be used for\n" " the new edge.\n\n" " - C{\"product\"}: the product of the edge attribute values will be used for\n" " the new edge.\n" " - C{\"mean\"}: the mean of the edge attribute values will be used for\n" " the new edge.\n\n" " - C{\"median\"}: the median of the edge attribute values will be used for\n" " the new edge.\n\n" " - C{\"min\"}: the minimum of the edge attribute values will be used for\n" " the new edge.\n\n" " - C{\"max\"}: the maximum of the edge attribute values will be used for\n" " the new edge.\n\n" " - C{\"first\"}: the attribute value of the first edge in the collapsed set\n" " will be used for the new edge.\n\n" " - C{\"last\"}: the attribute value of the last edge in the collapsed set\n" " will be used for the new edge.\n\n" " - C{\"random\"}: a randomly selected value will be used for the new edge\n\n" " - C{\"concat\"}: the attribute values will be concatenated for the new\n" " edge.\n\n" " You can also use a dict mapping edge attribute names to functions or\n" " the above string constants if you want to make the behaviour of the\n" " simplification process depend on the name of the attribute.\n" " C{None} is a special key in this dict, its value will be used for all\n" " the attributes not specified explicitly in the dictionary.\n" }, /* interface to igraph_minimum_spanning_tree */ {"_spanning_tree", (PyCFunction) igraphmodule_Graph_spanning_tree, METH_VARARGS | METH_KEYWORDS, "_spanning_tree(weights=None)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.spanning_tree()"}, // interface to igraph_subcomponent {"subcomponent", (PyCFunction) igraphmodule_Graph_subcomponent, METH_VARARGS | METH_KEYWORDS, "subcomponent(v, mode=\"all\")\n--\n\n" "Determines the indices of vertices which are in the same component as a given vertex.\n\n" "@param v: the index of the vertex used as the source/destination\n" "@param mode: if equals to C{\"in\"}, returns the vertex IDs from\n" " where the given vertex can be reached. If equals to C{\"out\"},\n" " returns the vertex IDs which are reachable from the given\n" " vertex. If equals to C{\"all\"}, returns all vertices within the\n" " same component as the given vertex, ignoring edge directions.\n" " Note that this is not equal to calculating the union of the \n" " results of C{\"in\"} and C{\"out\"}.\n" "@return: the indices of vertices which are in the same component as a given vertex.\n"}, /* interface to igraph_subgraph_edges */ {"subgraph_edges", (PyCFunction) igraphmodule_Graph_subgraph_edges, METH_VARARGS | METH_KEYWORDS, "subgraph_edges(edges, delete_vertices=True)\n--\n\n" "Returns a subgraph spanned by the given edges.\n\n" "@param edges: a list containing the edge IDs which should\n" " be included in the result.\n" "@param delete_vertices: if C{True}, vertices not incident on\n" " any of the specified edges will be deleted from the result.\n" " If C{False}, all vertices will be kept.\n" "@return: the subgraph\n"}, /* interface to igraph_topological_sorting */ {"topological_sorting", (PyCFunction) igraphmodule_Graph_topological_sorting, METH_VARARGS | METH_KEYWORDS, "topological_sorting(mode=\"out\")\n--\n\n" "Calculates a possible topological sorting of the graph.\n\n" "Returns a partial sorting and issues a warning if the graph is not\n" "a directed acyclic graph.\n\n" "@param mode: if C{\"out\"}, vertices are returned according to the\n" " forward topological order -- all vertices come before their\n" " successors. If C{\"in\"}, all vertices come before their ancestors.\n" "@return: a possible topological ordering as a list"}, /* interface to to_prufer */ {"to_prufer", (PyCFunction) igraphmodule_Graph_to_prufer, METH_NOARGS, "to_prufer()\n--\n\n" "Converts a tree graph into a Prufer sequence.\n\n" "@return: the Prufer sequence as a list" }, // interface to igraph_transitivity_undirected {"transitivity_undirected", (PyCFunction) igraphmodule_Graph_transitivity_undirected, METH_VARARGS | METH_KEYWORDS, "transitivity_undirected(mode=\"nan\")\n--\n\n" "Calculates the global transitivity (clustering coefficient) of the\n" "graph.\n\n" "The transitivity measures the probability that two neighbors of a\n" "vertex are connected. More precisely, this is the ratio of the\n" "triangles and connected triplets in the graph. The result is a\n" "single real number. Directed graphs are considered as undirected\n" "ones.\n\n" "Note that this measure is different from the local transitivity\n" "measure (see L{transitivity_local_undirected()}) as it calculates\n" "a single value for the whole graph.\n\n" "@param mode: if C{TRANSITIVITY_ZERO} or C{\"zero\"}, the result will\n" " be zero if the graph does not have any triplets. If C{\"nan\"} or\n" " C{TRANSITIVITY_NAN}, the result will be C{NaN} (not a number).\n" "@return: the transitivity\n" "@see: L{transitivity_local_undirected()}, L{transitivity_avglocal_undirected()}\n" "@newfield ref: Reference\n" "@ref: S. Wasserman and K. Faust: I{Social Network Analysis: Methods and\n" " Applications}. Cambridge: Cambridge University Press, 1994." }, /* interface to igraph_transitivity_local_undirected and * igraph_transitivity_barrat */ {"transitivity_local_undirected", (PyCFunction) igraphmodule_Graph_transitivity_local_undirected, METH_VARARGS | METH_KEYWORDS, "transitivity_local_undirected(vertices=None, mode=\"nan\", weights=None)\n--\n\n" "Calculates the local transitivity (clustering coefficient) of the\n" "given vertices in the graph.\n\n" "The transitivity measures the probability that two neighbors of a\n" "vertex are connected. In case of the local transitivity, this\n" "probability is calculated separately for each vertex.\n\n" "Note that this measure is different from the global transitivity\n" "measure (see L{transitivity_undirected()}) as it calculates\n" "a transitivity value for each vertex individually.\n\n" "The traditional local transitivity measure applies for unweighted graphs\n" "only. When the C{weights} argument is given, this function calculates\n" "the weighted local transitivity proposed by Barrat et al (see references).\n\n" "@param vertices: a list containing the vertex IDs which should be\n" " included in the result. C{None} means all of the vertices.\n" "@param mode: defines how to treat vertices with degree less than two.\n" " If C{TRANSITIVITT_ZERO} or C{\"zero\"}, these vertices will have\n" " zero transitivity. If C{TRANSITIVITY_NAN} or C{\"nan\"}, these\n" " vertices will have C{NaN} (not a number) as their transitivity.\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@return: the transitivities for the given vertices in a list\n" "@see: L{transitivity_undirected()}, L{transitivity_avglocal_undirected()}\n" "@newfield ref: Reference\n" "@ref: Watts DJ and Strogatz S: I{Collective dynamics of small-world\n" " networks}. Nature 393(6884):440-442, 1998.\n" "@ref: Barrat A, Barthelemy M, Pastor-Satorras R and Vespignani A:\n" " I{The architecture of complex weighted networks}. PNAS 101, 3747 (2004).\n" " U{http://arxiv.org/abs/cond-mat/0311416}." }, /* interface to igraph_transitivity_avglocal_undirected */ {"transitivity_avglocal_undirected", (PyCFunction) igraphmodule_Graph_transitivity_avglocal_undirected, METH_VARARGS | METH_KEYWORDS, "transitivity_avglocal_undirected(mode=\"nan\")\n--\n\n" "Calculates the average of the vertex transitivities of the graph.\n\n" "The transitivity measures the probability that two neighbors of a\n" "vertex are connected. In case of the average local transitivity,\n" "this probability is calculated for each vertex and then the average\n" "is taken. Vertices with less than two neighbors require special\n" "treatment, they will either be left out from the calculation or\n" "they will be considered as having zero transitivity, depending on\n" "the I{mode} parameter.\n\n" "Note that this measure is different from the global transitivity measure\n" "(see L{transitivity_undirected()}) as it simply takes the average local\n" "transitivity across the whole network.\n\n" "@param mode: defines how to treat vertices with degree less than two.\n" " If C{TRANSITIVITT_ZERO} or C{\"zero\"}, these vertices will have\n" " zero transitivity. If C{TRANSITIVITY_NAN} or C{\"nan\"}, these\n" " vertices will be excluded from the average.\n" "@see: L{transitivity_undirected()}, L{transitivity_local_undirected()}\n" "@newfield ref: Reference\n" "@ref: D. J. Watts and S. Strogatz: I{Collective dynamics of small-world\n" " networks}. Nature 393(6884):440-442, 1998." }, /* interface to igraph_unfold_tree */ {"unfold_tree", (PyCFunction) igraphmodule_Graph_unfold_tree, METH_VARARGS | METH_KEYWORDS, "unfold_tree(sources=None, mode=\"out\")\n--\n\n" "Unfolds the graph using a BFS to a tree by duplicating vertices as necessary.\n\n" "@param sources: the source vertices to start the unfolding from. It should be a\n" " list of vertex indices, preferably one vertex from each connected component.\n" " You can use L{topological_sorting()} to determine a suitable set. A single\n" " vertex index is also accepted.\n" "@param mode: which edges to follow during the BFS. C{OUT} follows outgoing edges,\n" " C{IN} follows incoming edges, C{ALL} follows both. Ignored for undirected\n" " graphs.\n" "@return: the unfolded tree graph and a mapping from the new vertex indices to the\n" " old ones.\n" }, /* interface to igraph_[st_]vertex_connectivity */ {"vertex_connectivity", (PyCFunction) igraphmodule_Graph_vertex_connectivity, METH_VARARGS | METH_KEYWORDS, "vertex_connectivity(source=-1, target=-1, checks=True, neighbors=\"error\")\n--\n\n" "Calculates the vertex connectivity of the graph or between some vertices.\n\n" "The vertex connectivity between two given vertices is the number of vertices\n" "that have to be removed in order to disconnect the two vertices into two\n" "separate components. This is also the number of vertex disjoint directed\n" "paths between the vertices (apart from the source and target vertices of\n" "course). The vertex connectivity of the graph is the minimal vertex\n" "connectivity over all vertex pairs.\n\n" "This method calculates the vertex connectivity of a given vertex pair if both\n" "the source and target vertices are given. If none of them is given (or they\n" "are both negative), the overall vertex connectivity is returned.\n\n" "@param source: the source vertex involved in the calculation.\n" "@param target: the target vertex involved in the calculation.\n" "@param checks: if the whole graph connectivity is calculated and this is\n" " C{True}, igraph performs some basic checks before calculation. If the\n" " graph is not strongly connected, then the connectivity is obviously\n" " zero. If the minimum degree is one, then the connectivity is\n" " also one. These simple checks are much faster than checking the entire\n" " graph, therefore it is advised to set this to C{True}. The parameter\n" " is ignored if the connectivity between two given vertices is computed.\n" "@param neighbors: tells igraph what to do when the two vertices are\n" " connected. C{\"error\"} raises an exception, C{\"infinity\"} returns\n" " infinity, C{\"ignore\"} ignores the edge.\n" "@return: the vertex connectivity\n" }, /***********************/ /* SIMILARITY MEASURES */ /***********************/ /* interface to igraph_bibcoupling */ {"bibcoupling", (PyCFunction) igraphmodule_Graph_bibcoupling, METH_VARARGS | METH_KEYWORDS, "bibcoupling(vertices=None)\n--\n\n" "Calculates bibliographic coupling scores for given vertices in a graph.\n\n" "@param vertices: the vertices to be analysed. If C{None}, all vertices\n" " will be considered.\n" "@return: bibliographic coupling scores for all given vertices in a matrix."}, /* interface to igraph_cocitation */ {"cocitation", (PyCFunction) igraphmodule_Graph_cocitation, METH_VARARGS | METH_KEYWORDS, "cocitation(vertices=None)\n--\n\n" "Calculates cocitation scores for given vertices in a graph.\n\n" "@param vertices: the vertices to be analysed. If C{None}, all vertices\n" " will be considered.\n" "@return: cocitation scores for all given vertices in a matrix."}, /* interface to igraph_similarity_dice */ {"similarity_dice", (PyCFunction) igraphmodule_Graph_similarity_dice, METH_VARARGS | METH_KEYWORDS, "similarity_dice(vertices=None, pairs=None, mode=\"all\", loops=True)\n--\n\n" "Dice similarity coefficient of vertices.\n\n" "The Dice similarity coefficient of two vertices is twice the number of\n" "their common neighbors divided by the sum of their degrees. This\n" "coefficient is very similar to the Jaccard coefficient, but usually\n" "gives higher similarities than its counterpart.\n\n" "@param vertices: the vertices to be analysed. If C{None} and I{pairs} is also\n" " C{None}, all vertices will be considered.\n" "@param pairs: the vertex pairs to be analysed. If this is given, I{vertices}\n" " must be C{None}, and the similarity values will be calculated only for the\n" " given pairs. Vertex pairs must be specified as tuples of vertex IDs.\n" "@param mode: which neighbors should be considered for directed graphs.\n" " Can be C{\"all\"}, C{\"in\"} or C{\"out\"}, ignored for undirected graphs.\n" "@param loops: whether vertices should be considered adjacent to\n" " themselves. Setting this to C{True} assumes a loop edge for all vertices\n" " even if none is present in the graph. Setting this to C{False} may\n" " result in strange results: nonadjacent vertices may have larger\n" " similarities compared to the case when an edge is added between them --\n" " however, this might be exactly the result you want to get.\n" "@return: the pairwise similarity coefficients for the vertices specified,\n" " in the form of a matrix if C{pairs} is C{None} or in the form of a list\n" " if C{pairs} is not C{None}.\n" }, /* interface to igraph_similarity_inverse_log_weighted */ {"similarity_inverse_log_weighted", (PyCFunction) igraphmodule_Graph_similarity_inverse_log_weighted, METH_VARARGS | METH_KEYWORDS, "similarity_inverse_log_weighted(vertices=None, mode=\"all\")\n--\n\n" "Inverse log-weighted similarity coefficient of vertices.\n\n" "Each vertex is assigned a weight which is 1 / log(degree). The\n" "log-weighted similarity of two vertices is the sum of the weights\n" "of their common neighbors.\n\n" "@param vertices: the vertices to be analysed. If C{None}, all vertices\n" " will be considered.\n" "@param mode: which neighbors should be considered for directed graphs.\n" " Can be C{\"all\"}, C{\"in\"} or C{\"out\"}, ignored for undirected graphs.\n" " C{\"in\"} means that the weights are determined by the out-degrees, C{\"out\"}\n" " means that the weights are determined by the in-degrees.\n" "@return: the pairwise similarity coefficients for the vertices specified,\n" " in the form of a matrix (list of lists).\n" }, /* interface to igraph_similarity_jaccard */ {"similarity_jaccard", (PyCFunction) igraphmodule_Graph_similarity_jaccard, METH_VARARGS | METH_KEYWORDS, "similarity_jaccard(vertices=None, pairs=None, mode=\"all\", loops=True)\n--\n\n" "Jaccard similarity coefficient of vertices.\n\n" "The Jaccard similarity coefficient of two vertices is the number of their\n" "common neighbors divided by the number of vertices that are adjacent to\n" "at least one of them.\n\n" "@param vertices: the vertices to be analysed. If C{None} and I{pairs} is also\n" " C{None}, all vertices will be considered.\n" "@param pairs: the vertex pairs to be analysed. If this is given, I{vertices}\n" " must be C{None}, and the similarity values will be calculated only for the\n" " given pairs. Vertex pairs must be specified as tuples of vertex IDs.\n" "@param mode: which neighbors should be considered for directed graphs.\n" " Can be C{\"all\"}, C{\"in\"} or C{\"out\"}, ignored for undirected graphs.\n" "@param loops: whether vertices should be considered adjacent to\n" " themselves. Setting this to C{True} assumes a loop edge for all vertices\n" " even if none is present in the graph. Setting this to C{False} may\n" " result in strange results: nonadjacent vertices may have larger\n" " similarities compared to the case when an edge is added between them --\n" " however, this might be exactly the result you want to get.\n" "@return: the pairwise similarity coefficients for the vertices specified,\n" " in the form of a matrix if C{pairs} is C{None} or in the form of a list\n" " if C{pairs} is not C{None}.\n" }, /******************/ /* MOTIF COUNTING */ /******************/ {"motifs_randesu", (PyCFunction) igraphmodule_Graph_motifs_randesu, METH_VARARGS | METH_KEYWORDS, "motifs_randesu(size=3, cut_prob=None, callback=None)\n--\n\n" "Counts the number of motifs in the graph\n\n" "Motifs are small subgraphs of a given structure in a graph. It is\n" "argued that the motif profile (ie. the number of different motifs in\n" "the graph) is characteristic for different types of networks and\n" "network function is related to the motifs in the graph.\n\n" "This function is able to find the different motifs of size three\n" "and four (ie. the number of different subgraphs with three and four\n" "vertices) in the network.\n\n" "In a big network the total number of motifs can be very large, so\n" "it takes a lot of time to find all of them. In such cases, a sampling\n" "method can be used. This function is capable of doing sampling via\n" "the I{cut_prob} argument. This argument gives the probability that\n" "a branch of the motif search tree will not be explored.\n\n" "@newfield ref: Reference\n" "@ref: S. Wernicke and F. Rasche: FANMOD: a tool for fast network\n" " motif detection, Bioinformatics 22(9), 1152--1153, 2006.\n\n" "@param size: the size of the motifs (3 or 4).\n" "@param cut_prob: the cut probabilities for different levels of the search\n" " tree. This must be a list of length I{size} or C{None} to find all\n" " motifs.\n" "@param callback: C{None} or a callable that will be called for every motif\n" " found in the graph. The callable must accept three parameters: the graph\n" " itself, the list of vertices in the motif and the isomorphism class of the\n" " motif (see L{isoclass()}). The search will stop when the callback\n" " returns an object with a non-zero truth value or raises an exception.\n" "@return: the list of motifs if I{callback} is C{None}, or C{None} otherwise\n" "@see: Graph.motifs_randesu_no()\n" }, {"motifs_randesu_no", (PyCFunction) igraphmodule_Graph_motifs_randesu_no, METH_VARARGS | METH_KEYWORDS, "motifs_randesu_no(size=3, cut_prob=None)\n--\n\n" "Counts the total number of motifs in the graph\n\n" "Motifs are small subgraphs of a given structure in a graph.\n" "This function counts the total number of motifs in a graph without\n" "assigning isomorphism classes to them.\n\n" "@newfield ref: Reference\n" "@ref: S. Wernicke and F. Rasche: FANMOD: a tool for fast network\n" " motif detection, Bioinformatics 22(9), 1152--1153, 2006.\n\n" "@param size: the size of the motifs (3 or 4).\n" "@param cut_prob: the cut probabilities for different levels of the search\n" " tree. This must be a list of length I{size} or C{None} to find all\n" " motifs.\n" "@see: Graph.motifs_randesu()\n" }, {"motifs_randesu_estimate", (PyCFunction) igraphmodule_Graph_motifs_randesu_estimate, METH_VARARGS | METH_KEYWORDS, "motifs_randesu_estimate(size=3, cut_prob=None, sample=None)\n--\n\n" "Counts the total number of motifs in the graph\n\n" "Motifs are small subgraphs of a given structure in a graph.\n" "This function estimates the total number of motifs in a graph without\n" "assigning isomorphism classes to them by extrapolating from a random\n" "sample of vertices.\n\n" "@newfield ref: Reference\n" "@ref: S. Wernicke and F. Rasche: FANMOD: a tool for fast network\n" " motif detection, Bioinformatics 22(9), 1152--1153, 2006.\n\n" "@param size: the size of the motifs (3 or 4).\n" "@param cut_prob: the cut probabilities for different levels of the search\n" " tree. This must be a list of length I{size} or C{None} to find all\n" " motifs.\n" "@param sample: the size of the sample or the vertex IDs of the vertices\n" " to be used for sampling.\n" "@see: Graph.motifs_randesu()\n" }, {"dyad_census", (PyCFunction) igraphmodule_Graph_dyad_census, METH_NOARGS, "dyad_census()\n--\n\n" "Dyad census, as defined by Holland and Leinhardt\n\n" "Dyad census means classifying each pair of vertices of a directed\n" "graph into three categories: mutual, there is an edge from I{a} to\n" "I{b} and also from I{b} to I{a}; asymmetric, there is an edge\n" "either from I{a} to I{b} or from I{b} to I{a} but not the other way\n" "and null, no edges between I{a} and I{b}.\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{DyadCensus} object.\n" " It is advised to use that.\n\n" "@return: the number of mutual, asymmetric and null connections in a\n" " 3-tuple." }, {"triad_census", (PyCFunction) igraphmodule_Graph_triad_census, METH_NOARGS, "triad_census()\n--\n\n" "Triad census, as defined by Davis and Leinhardt\n\n" "Calculating the triad census means classifying every triplets of\n" "vertices in a directed graph. A triplet can be in one of 16 states,\n" "these are listed in the documentation of the C interface of igraph.\n" "\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{TriadCensus} object.\n" " It is advised to use that. The name of the triplet classes are\n" " also documented there.\n\n" }, /********************/ /* LAYOUT FUNCTIONS */ /********************/ /* interface to igraph_layout_bipartite */ {"layout_bipartite", (PyCFunction) igraphmodule_Graph_layout_bipartite, METH_VARARGS | METH_KEYWORDS, "layout_bipartite(types=\"type\", hgap=1, vgap=1, maxiter=100)\n--\n\n" "Place the vertices of a bipartite graph in two layers.\n\n" "The layout is created by placing the vertices in two rows, according\n" "to their types. The positions of the vertices within the rows are\n" "then optimized to minimize the number of edge crossings using the\n" "heuristic used by the Sugiyama layout algorithm.\n\n" "@param types: an igraph vector containing the vertex types, or an\n" " attribute name. Anything that evalulates to C{False} corresponds to\n" " vertices of the first kind, everything else to the second kind.\n" "@param hgap: minimum horizontal gap between vertices in the same layer.\n" "@param vgap: vertical gap between the two layers.\n" "@param maxiter: maximum number of iterations to take in the crossing\n" " reduction step. Increase this if you feel that you are getting too many\n" " edge crossings.\n" "@return: the calculated layout."}, /* interface to igraph_layout_circle */ {"layout_circle", (PyCFunction) igraphmodule_Graph_layout_circle, METH_VARARGS | METH_KEYWORDS, "layout_circle(dim=2, order=None)\n--\n\n" "Places the vertices of the graph uniformly on a circle or a sphere.\n\n" "@param dim: the desired number of dimensions for the layout. dim=2\n" " means a 2D layout, dim=3 means a 3D layout.\n" "@param order: the order in which the vertices are placed along the\n" " circle. Not supported when I{dim} is not equal to 2.\n" "@return: the calculated layout."}, /* interface to igraph_layout_grid */ {"layout_grid", (PyCFunction) igraphmodule_Graph_layout_grid, METH_VARARGS | METH_KEYWORDS, "layout_grid(width=0, height=0, dim=2)\n--\n\n" "Places the vertices of a graph in a 2D or 3D grid.\n\n" "@param width: the number of vertices in a single row of the layout.\n" " Zero or negative numbers mean that the width should be determined\n" " automatically.\n" "@param height: the number of vertices in a single column of the layout.\n" " Zero or negative numbers mean that the height should be determined\n" " automatically. It must not be given if the number of dimensions is 2.\n" "@param dim: the desired number of dimensions for the layout. dim=2\n" " means a 2D layout, dim=3 means a 3D layout.\n" "@return: the calculated layout."}, /* interface to igraph_layout_star */ {"layout_star", (PyCFunction) igraphmodule_Graph_layout_star, METH_VARARGS | METH_KEYWORDS, "layout_star(center=0, order=None)\n--\n\n" "Calculates a star-like layout for the graph.\n\n" "@param center: the ID of the vertex to put in the center\n" "@param order: a numeric vector giving the order of the vertices\n" " (including the center vertex!). If it is C{None}, the vertices\n" " will be placed in increasing vertex ID order.\n" "@return: the calculated layout." }, /* interface to igraph_layout_kamada_kawai */ {"layout_kamada_kawai", (PyCFunction) igraphmodule_Graph_layout_kamada_kawai, METH_VARARGS | METH_KEYWORDS, "layout_kamada_kawai(maxiter=1000, epsilon=0, kkconst=None, seed=None, " "minx=None, maxx=None, miny=None, maxy=None, minz=None, maxz=None, dim=2)\n--\n\n" "Places the vertices on a plane according to the Kamada-Kawai algorithm.\n\n" "This is a force directed layout, see Kamada, T. and Kawai, S.:\n" "An Algorithm for Drawing General Undirected Graphs.\n" "Information Processing Letters, 31/1, 7--15, 1989.\n\n" "@param maxiter: the maximum number of iterations to perform.\n" "@param seed: if C{None}, uses a random starting layout for the\n" " algorithm. If a matrix (list of lists), uses the given matrix\n" " as the starting position.\n" "@param epsilon: quit if the energy of the system changes less than\n" " epsilon. See the original paper for details.\n" "@param kkconst: the Kamada-Kawai vertex attraction constant.\n" " C{None} means the square of the number of vertices.\n" "@param minx: if not C{None}, it must be a vector with exactly as many\n" " elements as there are vertices in the graph. Each element is a\n" " minimum constraint on the X value of the vertex in the layout.\n" "@param maxx: similar to I{minx}, but with maximum constraints\n" "@param miny: similar to I{minx}, but with the Y coordinates\n" "@param maxy: similar to I{maxx}, but with the Y coordinates\n" "@param minz: similar to I{minx}, but with the Z coordinates. Use only\n" " for 3D layouts (C{dim}=3).\n" "@param maxz: similar to I{maxx}, but with the Z coordinates. Use only\n" " for 3D layouts (C{dim}=3).\n" "@param dim: the desired number of dimensions for the layout. dim=2\n" " means a 2D layout, dim=3 means a 3D layout.\n" "@return: the calculated layout." }, /* interface to igraph_layout_davidson_harel */ {"layout_davidson_harel", (PyCFunction) igraphmodule_Graph_layout_davidson_harel, METH_VARARGS | METH_KEYWORDS, "layout_davidson_harel(seed=None, maxiter=10, fineiter=-1, cool_fact=0.75, " "weight_node_dist=1.0, weight_border=0.0, weight_edge_lengths=-1, " "weight_edge_crossings=-1, weight_node_edge_dist=-1)\n--\n\n" "Places the vertices on a 2D plane according to the Davidson-Harel layout\n" "algorithm.\n\n" "The algorithm uses simulated annealing and a sophisticated energy function,\n" "which is unfortunately hard to parameterize for different graphs. The\n" "original publication did not disclose any parameter values, and the ones\n" "below were determined by experimentation.\n\n" "The algorithm consists of two phases: an annealing phase and a fine-tuning\n" "phase. There is no simulated annealing in the second phase.\n\n" "@param seed: if C{None}, uses a random starting layout for the algorithm.\n" " If a matrix (list of lists), uses the given matrix as the starting\n" " position.\n" "@param maxiter: Number of iterations to perform in the annealing phase.\n" "@param fineiter: Number of iterations to perform in the fine-tuning phase.\n" " Negative numbers set up a reasonable default from the base-2 logarithm\n" " of the vertex count, bounded by 10 from above.\n" "@param cool_fact: Cooling factor of the simulated annealing phase.\n" "@param weight_node_dist: Weight for the node-node distances in the energy\n" " function.\n" "@param weight_border: Weight for the distance from the border component of\n" " the energy function. Zero means that vertices are allowed to sit on the\n" " border of the area designated for the layout.\n" "@param weight_edge_lengths: Weight for the edge length component of the\n" " energy function. Negative numbers are replaced by the density of the\n" " graph divided by 10.\n" "@param weight_edge_crossings: Weight for the edge crossing component of the\n" " energy function. Negative numbers are replaced by one minus the square\n" " root of the density of the graph.\n" "@param weight_node_edge_dist: Weight for the node-edge distance component\n" " of the energy function. Negative numbers are replaced by 0.2 minus\n" " 0.2 times the density of the graph.\n" "@return: the calculated layout." }, /* interface to igraph_layout_drl */ {"layout_drl", (PyCFunction) igraphmodule_Graph_layout_drl, METH_VARARGS | METH_KEYWORDS, "layout_drl(weights=None, fixed=None, seed=None, options=None, dim=2)\n--\n\n" "Places the vertices on a 2D plane or in the 3D space ccording to the DrL\n" "layout algorithm.\n\n" "This is an algorithm suitable for quite large graphs, but it can be\n" "surprisingly slow for small ones (where the simpler force-based layouts\n" "like C{layout_kamada_kawai()} or C{layout_fruchterman_reingold()} are\n" "more useful.\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param seed: if C{None}, uses a random starting layout for the\n" " algorithm. If a matrix (list of lists), uses the given matrix\n" " as the starting position.\n" "@param fixed: ignored. We used to assume that the DrL layout supports\n" " fixed nodes, but later it turned out that the argument has no effect\n" " in the original DrL code. We kept the argument for sake of backwards\n" " compatibility, but it will have no effect on the final layout.\n" "@param options: if you give a string argument here, you can select from\n" " five default preset parameterisations: C{default}, C{coarsen} for a\n" " coarser layout, C{coarsest} for an even coarser layout, C{refine} for\n" " refining an existing layout and C{final} for finalizing a layout. If\n" " you supply an object that is not a string, the DrL layout parameters\n" " are retrieved from the respective keys of the object (so it should\n" " be a dict or something else that supports the mapping protocol).\n" " The following keys can be used:\n" " \n" " - C{edge_cut}: edge cutting is done in the late stages of the\n" " algorithm in order to achieve less dense layouts. Edges are\n" " cut if there is a lot of stress on them (a large value in the\n" " objective function sum). The edge cutting parameter is a value\n" " between 0 and 1 with 0 representing no edge cutting and 1\n" " representing maximal edge cutting.\n\n" " - C{init_iterations}: number of iterations in the initialization\n" " phase\n\n" " - C{init_temperature}: start temperature during initialization\n\n" " - C{init_attraction}: attraction during initialization\n\n" " - C{init_damping_mult}: damping multiplier during initialization\n\n" " - C{liquid_iterations}, C{liquid_temperature}, C{liquid_attraction},\n" " C{liquid_damping_mult}: same parameters for the liquid phase\n\n" " - C{expansion_iterations}, C{expansion_temperature},\n" " C{expansion_attraction}, C{expansion_damping_mult}:\n" " parameters for the expansion phase\n\n" " - C{cooldown_...}: parameters for the cooldown phase\n\n" " - C{crunch_...}: parameters for the crunch phase\n\n" " - C{simmer_...}: parameters for the simmer phase\n\n" " \n" " Instead of a mapping, you can also use an arbitrary Python object\n" " here: if the object does not support the mapping protocol, an\n" " attribute of the object with the same name is looked up instead. If\n" " a parameter cannot be found either as a key or an attribute, the\n" " default from the C{default} preset will be used.\n\n" "@param dim: the desired number of dimensions for the layout. dim=2\n" " means a 2D layout, dim=3 means a 3D layout.\n" "@return: the calculated layout." }, /* interface to igraph_layout_fruchterman_reingold */ {"layout_fruchterman_reingold", (PyCFunction) igraphmodule_Graph_layout_fruchterman_reingold, METH_VARARGS | METH_KEYWORDS, "layout_fruchterman_reingold(weights=None, niter=500, seed=None, " "start_temp=None, minx=None, maxx=None, miny=None, " "maxy=None, minz=None, maxz=None, grid=\"auto\")\n--\n\n" "Places the vertices on a 2D plane according to the\n" "Fruchterman-Reingold algorithm.\n\n" "This is a force directed layout, see Fruchterman, T. M. J. and Reingold, E. M.:\n" "Graph Drawing by Force-directed Placement.\n" "Software -- Practice and Experience, 21/11, 1129--1164, 1991\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param niter: the number of iterations to perform. The default\n" " is 500.\n" "@param start_temp: Real scalar, the start temperature. This is the \n" " maximum amount of movement alloved along one axis, within one step,\n" " for a vertex. Currently it is decreased linearly to zero during\n" " the iteration. The default is the square root of the number of \n" " vertices divided by 10.\n" "@param minx: if not C{None}, it must be a vector with exactly as many\n" " elements as there are vertices in the graph. Each element is a\n" " minimum constraint on the X value of the vertex in the layout.\n" "@param maxx: similar to I{minx}, but with maximum constraints\n" "@param miny: similar to I{minx}, but with the Y coordinates\n" "@param maxy: similar to I{maxx}, but with the Y coordinates\n" "@param minz: similar to I{minx}, but with the Z coordinates. Use only\n" " for 3D layouts (C{dim}=3).\n" "@param maxz: similar to I{maxx}, but with the Z coordinates. Use only\n" " for 3D layouts (C{dim}=3).\n" "@param seed: if C{None}, uses a random starting layout for the\n" " algorithm. If a matrix (list of lists), uses the given matrix\n" " as the starting position.\n" "@param grid: whether to use a faster, but less accurate grid-based\n" " implementation of the algorithm. C{\"auto\"} decides based on the number\n" " of vertices in the graph; a grid will be used if there are at least 1000\n" " vertices. C{\"grid\"} is equivalent to C{True}, C{\"nogrid\"} is equivalent\n" " to C{False}.\n" "@return: the calculated layout." }, /* interface to igraph_layout_graphopt */ {"layout_graphopt", (PyCFunction) igraphmodule_Graph_layout_graphopt, METH_VARARGS | METH_KEYWORDS, "layout_graphopt(niter=500, node_charge=0.001, node_mass=30, " "spring_length=0, spring_constant=1, max_sa_movement=5, seed=None)\n--\n\n" "This is a port of the graphopt layout algorithm by Michael Schmuhl.\n" "graphopt version 0.4.1 was rewritten in C and the support for layers\n" "was removed.\n\n" "graphopt uses physical analogies for defining attracting and repelling\n" "forces among the vertices and then the physical system is simulated\n" "until it reaches an equilibrium or the maximal number of iterations is\n" "reached.\n\n" "See U{http://www.schmuhl.org/graphopt/} for the original graphopt.\n\n" "@param niter: the number of iterations to perform. Should be a couple\n" " of hundred in general.\n\n" "@param node_charge: the charge of the vertices, used to calculate electric\n" " repulsion.\n" "@param node_mass: the mass of the vertices, used for the spring forces\n" "@param spring_length: the length of the springs\n" "@param spring_constant: the spring constant\n" "@param max_sa_movement: the maximum amount of movement allowed in a single\n" " step along a single axis.\n" "@param seed: a matrix containing a seed layout from which the algorithm\n" " will be started. If C{None}, a random layout will be used.\n" "@return: the calculated layout." }, /* interface to igraph_layout_lgl */ {"layout_lgl", (PyCFunction) igraphmodule_Graph_layout_lgl, METH_VARARGS | METH_KEYWORDS, "layout_lgl(maxiter=150, maxdelta=-1, area=-1, coolexp=1.5, " "repulserad=-1, cellsize=-1, root=None)\n--\n\n" "Places the vertices on a 2D plane according to the Large Graph Layout.\n\n" "@param maxiter: the number of iterations to perform.\n" "@param maxdelta: the maximum distance to move a vertex in\n" " an iteration. If negative, defaults to the number of vertices.\n" "@param area: the area of the square on which the vertices\n" " will be placed. If negative, defaults to the number of vertices\n" " squared.\n" "@param coolexp: the cooling exponent of the simulated annealing.\n" "@param repulserad: determines the radius at which vertex-vertex\n" " repulsion cancels out attraction of adjacent vertices.\n" " If negative, defaults to M{area} times the number of vertices.\n" "@param cellsize: the size of the grid cells. When calculating the\n" " repulsion forces, only vertices in the same or neighboring\n" " grid cells are taken into account. Defaults to the fourth\n" " root of M{area}.\n" "@param root: the root vertex, this is placed first, its neighbors\n" " in the first iteration, second neighbors in the second,\n" " etc. C{None} means that a random vertex will be chosen.\n" "@return: the calculated layout." }, /* interface to igraph_layout_mds */ {"layout_mds", (PyCFunction) igraphmodule_Graph_layout_mds, METH_VARARGS | METH_KEYWORDS, "layout_mds(dist=None, dim=2, arpack_options=None)\n--\n\n" "Places the vertices in an Euclidean space with the given number of\n" "dimensions using multidimensional scaling.\n\n" "This layout requires a distance matrix, where the intersection of\n" "row M{i} and column M{j} specifies the desired distance between\n" "vertex M{i} and vertex M{j}. The algorithm will try to place the\n" "vertices in a way that approximates the distance relations\n" "prescribed in the distance matrix. igraph uses the classical\n" "multidimensional scaling by Torgerson (see reference below).\n\n" "For unconnected graphs, the method will decompose the graph into\n" "weakly connected components and then lay out the components\n" "individually using the appropriate parts of the distance matrix.\n\n" "@param dist: the distance matrix. It must be symmetric and the\n" " symmetry is not checked -- results are unspecified when a\n" " non-symmetric distance matrix is used. If this parameter is\n" " C{None}, the shortest path lengths will be used as distances.\n" " Directed graphs are treated as undirected when calculating\n" " the shortest path lengths to ensure symmetry.\n" "@param dim: the number of dimensions. For 2D layouts, supply\n" " 2 here; for 3D layouts, supply 3.\n" "@param arpack_options: an L{ARPACKOptions} object used to fine-tune\n" " the ARPACK eigenvector calculation. If omitted, the module-level\n" " variable called C{arpack_options} is used.\n" "@return: the calculated layout.\n\n" "@newfield ref: Reference\n" "@ref: Cox & Cox: Multidimensional Scaling (1994), Chapman and\n" " Hall, London.\n" }, /* interface to igraph_layout_reingold_tilford */ {"layout_reingold_tilford", (PyCFunction) igraphmodule_Graph_layout_reingold_tilford, METH_VARARGS | METH_KEYWORDS, "layout_reingold_tilford(mode=\"out\", root=None, rootlevel=None)\n--\n\n" "Places the vertices on a 2D plane according to the Reingold-Tilford\n" "layout algorithm.\n\n" "This is a tree layout. If the given graph is not a tree, a breadth-first\n" "search is executed first to obtain a possible spanning tree.\n\n" "@param mode: specifies which edges to consider when builing the tree.\n" " If it is C{OUT} then only the outgoing, if it is C{IN} then only the\n" " incoming edges of a parent are considered. If it is C{ALL} then all\n" " edges are used (this was the behaviour in igraph 0.5 and before).\n" " This parameter also influences how the root vertices are calculated\n" " if they are not given. See the I{root} parameter.\n" "@param root: the index of the root vertex or root vertices.\n" " If this is a non-empty vector then the supplied vertex IDs are\n" " used as the roots of the trees (or a single tree if the graph is\n" " connected). If this is C{None} or an empty list, the root vertices\n" " are automatically calculated in such a way so that all other vertices\n" " would be reachable from them. Currently, automatic root selection\n" " prefers low eccentricity vertices in small graphs (fewer than 500\n" " vertices) and high degree vertices in large graphs. This heuristic\n" " may change in future versions. Specify roots manually for a consistent\n" " output.\n" "@param rootlevel: this argument is useful when drawing forests which are\n" " not trees. It specifies the level of the root vertices for every tree\n" " in the forest.\n" "@return: the calculated layout.\n\n" "@see: layout_reingold_tilford_circular\n" "@newfield ref: Reference\n" "@ref: EM Reingold, JS Tilford: I{Tidier Drawings of Trees.}\n" "IEEE Transactions on Software Engineering 7:22, 223-228, 1981."}, /* interface to igraph_layout_reingold_tilford_circular */ {"layout_reingold_tilford_circular", (PyCFunction) igraphmodule_Graph_layout_reingold_tilford_circular, METH_VARARGS | METH_KEYWORDS, "layout_reingold_tilford_circular(mode=\"out\", root=None, rootlevel=None)\n--\n\n" "Circular Reingold-Tilford layout for trees.\n\n" "This layout is similar to the Reingold-Tilford layout, but the vertices\n" "are placed in a circular way, with the root vertex in the center.\n\n" "See L{layout_reingold_tilford} for the explanation of the parameters.\n\n" "@return: the calculated layout.\n\n" "@see: layout_reingold_tilford\n" "@newfield ref: Reference\n" "@ref: EM Reingold, JS Tilford: I{Tidier Drawings of Trees.}\n" "IEEE Transactions on Software Engineering 7:22, 223-228, 1981."}, /* interface to igraph_layout_random */ {"layout_random", (PyCFunction) igraphmodule_Graph_layout_random, METH_VARARGS | METH_KEYWORDS, "layout_random(dim=2)\n--\n\n" "Places the vertices of the graph randomly.\n\n" "@param dim: the desired number of dimensions for the layout. dim=2\n" " means a 2D layout, dim=3 means a 3D layout.\n" "@return: the coordinate pairs in a list."}, /* interface to igraph_layout_sugiyama */ {"_layout_sugiyama", (PyCFunction) igraphmodule_Graph_layout_sugiyama, METH_VARARGS | METH_KEYWORDS, "Internal function, undocumented.\n\n" "@see: Graph.layout_sugiyama()\n\n"}, //////////////////////////// // VISITOR-LIKE FUNCTIONS // //////////////////////////// {"bfs", (PyCFunction) igraphmodule_Graph_bfs, METH_VARARGS | METH_KEYWORDS, "bfs(vid, mode=\"out\")\n--\n\n" "Conducts a breadth first search (BFS) on the graph.\n\n" "@param vid: the root vertex ID\n" "@param mode: either C{\"in\"} or C{\"out\"} or C{\"all\"}, ignored\n" " for undirected graphs.\n" "@return: a tuple with the following items:\n" " - The vertex IDs visited (in order)\n" " - The start indices of the layers in the vertex list\n" " - The parent of every vertex in the BFS\n"}, {"bfsiter", (PyCFunction) igraphmodule_Graph_bfsiter, METH_VARARGS | METH_KEYWORDS, "bfsiter(vid, mode=\"out\", advanced=False)\n--\n\n" "Constructs a breadth first search (BFS) iterator of the graph.\n\n" "@param vid: the root vertex ID\n" "@param mode: either C{\"in\"} or C{\"out\"} or C{\"all\"}.\n" "@param advanced: if C{False}, the iterator returns the next\n" " vertex in BFS order in every step. If C{True}, the iterator\n" " returns the distance of the vertex from the root and the\n" " parent of the vertex in the BFS tree as well.\n" "@return: the BFS iterator as an L{igraph.BFSIter} object.\n"}, {"dfsiter", (PyCFunction) igraphmodule_Graph_dfsiter, METH_VARARGS | METH_KEYWORDS, "dfsiter(vid, mode=\"out\", advanced=False)\n--\n\n" "Constructs a depth first search (DFS) iterator of the graph.\n\n" "@param vid: the root vertex ID\n" "@param mode: either C{\"in\"} or C{\"out\"} or C{\"all\"}.\n" "@param advanced: if C{False}, the iterator returns the next\n" " vertex in DFS order in every step. If C{True}, the iterator\n" " returns the distance of the vertex from the root and the\n" " parent of the vertex in the DFS tree as well.\n" "@return: the DFS iterator as an L{igraph.DFSIter} object.\n"}, ///////////////// // CONVERSIONS // ///////////////// // interface to igraph_get_adjacency {"get_adjacency", (PyCFunction) igraphmodule_Graph_get_adjacency, METH_VARARGS | METH_KEYWORDS, "get_adjacency(type=\"both\", eids=False)\n--\n\n" "Returns the adjacency matrix of a graph.\n\n" "@param type: one of C{\"lower\"} (uses the lower triangle of the matrix),\n" " C{\"upper\"} (uses the upper triangle) or C{\"both\"} (uses both parts).\n" " Ignored for directed graphs.\n" "@param eids: if C{True}, the result matrix will contain\n" " zeros for non-edges and the ID of the edge plus one\n" " for edges in the appropriate cell. If C{False}, the\n" " result matrix will contain the number of edges for\n" " each vertex pair.\n" "@return: the adjacency matrix.\n"}, // interface to igraph_get_edgelist {"get_edgelist", (PyCFunction) igraphmodule_Graph_get_edgelist, METH_NOARGS, "get_edgelist()\n--\n\n" "Returns the edge list of a graph."}, /* interface to igraph_get_incidence */ {"get_incidence", (PyCFunction) igraphmodule_Graph_get_incidence, METH_VARARGS | METH_KEYWORDS, "get_incidence(types)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.get_incidence()\n\n"}, /* interface to igraph_to_directed */ {"to_directed", (PyCFunction) igraphmodule_Graph_to_directed, METH_VARARGS | METH_KEYWORDS, "to_directed(mode=\"mutual\")\n--\n\n" "Converts an undirected graph to directed.\n\n" "@param mode: specifies how to convert undirected edges into\n" " directed ones. C{True} or C{\"mutual\"} creates a mutual edge pair\n" " for each undirected edge. C{False} or C{\"arbitrary\"} picks an\n" " arbitrary (but deterministic) edge direction for each edge.\n" " C{\"random\"} picks a random direction for each edge. C{\"acyclic\"}\n" " picks the edge directions in a way that the resulting graph will be\n" " acyclic if there were no self-loops in the original graph.\n" }, // interface to igraph_to_undirected {"to_undirected", (PyCFunction) igraphmodule_Graph_to_undirected, METH_VARARGS | METH_KEYWORDS, "to_undirected(mode=\"collapse\", combine_edges=None)\n--\n\n" "Converts a directed graph to undirected.\n\n" "@param mode: specifies what to do with multiple directed edges\n" " going between the same vertex pair. C{True} or C{\"collapse\"}\n" " means that only a single edge should be created from multiple\n" " directed edges. C{False} or C{\"each\"} means that every edge\n" " will be kept (with the arrowheads removed). C{\"mutual\"}\n" " creates one undirected edge for each mutual directed edge pair.\n" "@param combine_edges: specifies how to combine the attributes of\n" " multiple edges between the same pair of vertices into a single\n" " attribute. See L{simplify()} for more details.\n" }, /* interface to igraph_laplacian */ {"laplacian", (PyCFunction) igraphmodule_Graph_laplacian, METH_VARARGS | METH_KEYWORDS, "laplacian(weights=None, normalized=False)\n--\n\n" "Returns the Laplacian matrix of a graph.\n\n" "The Laplacian matrix is similar to the adjacency matrix, but the edges\n" "are denoted with -1 and the diagonal contains the node degrees.\n\n" "Normalized Laplacian matrices have 1 or 0 in their diagonals (0 for vertices\n" "with no edges), edges are denoted by 1 / sqrt(d_i * d_j) where d_i is the\n" "degree of node i.\n\n" "Multiple edges and self-loops are silently ignored. Although it is\n" "possible to calculate the Laplacian matrix of a directed graph, it does\n" "not make much sense.\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name. When edge weights are used, the degree\n" " of a node is considered to be the weight of its incident edges.\n" "@param normalized: whether to return the normalized Laplacian matrix.\n" "@return: the Laplacian matrix.\n"}, /////////////////////////////// // LOADING AND SAVING GRAPHS // /////////////////////////////// // interface to igraph_read_graph_dimacs {"Read_DIMACS", (PyCFunction) igraphmodule_Graph_Read_DIMACS, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_DIMACS(f, directed=False)\n--\n\n" "Reads a graph from a file conforming to the DIMACS minimum-cost flow file format.\n\n" "For the exact description of the format, see\n" "U{http://lpsolve.sourceforge.net/5.5/DIMACS.htm}\n\n" "Restrictions compared to the official description of the format:\n\n" " - igraph's DIMACS reader requires only three fields in an arc definition,\n" " describing the edge's source and target node and its capacity.\n" " - Source vertices are identified by 's' in the FLOW field, target vertices are\n" " identified by 't'.\n" " - Node indices start from 1. Only a single source and target node is allowed.\n\n" "@param f: the name of the file or a Python file handle\n" "@param directed: whether the generated graph should be directed.\n" "@return: the generated graph, the source and the target of the flow and the edge\n" " capacities in a tuple\n"}, /* interface to igraph_read_graph_dl */ {"Read_DL", (PyCFunction) igraphmodule_Graph_Read_DL, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_DL(f, directed=True)\n--\n\n" "Reads an UCINET DL file and creates a graph based on it.\n\n" "@param f: the name of the file or a Python file handle\n" "@param directed: whether the generated graph should be directed.\n"}, /* interface to igraph_read_graph_edgelist */ {"Read_Edgelist", (PyCFunction) igraphmodule_Graph_Read_Edgelist, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_Edgelist(f, directed=True)\n--\n\n" "Reads an edge list from a file and creates a graph based on it.\n\n" "Please note that the vertex indices are zero-based. A vertex of zero\n" "degree will be created for every integer that is in range but does not\n" "appear in the edgelist.\n\n" "@param f: the name of the file or a Python file handle\n" "@param directed: whether the generated graph should be directed.\n"}, /* interface to igraph_read_graph_graphdb */ {"Read_GraphDB", (PyCFunction) igraphmodule_Graph_Read_GraphDB, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_GraphDB(f, directed=False)\n--\n\n" "Reads a GraphDB format file and creates a graph based on it.\n\n" "GraphDB is a binary format, used in the graph database for\n" "isomorphism testing (see U{http://amalfi.dis.unina.it/graph/}).\n\n" "@param f: the name of the file or a Python file handle\n" "@param directed: whether the generated graph should be directed.\n"}, /* interface to igraph_read_graph_graphml */ {"Read_GraphML", (PyCFunction) igraphmodule_Graph_Read_GraphML, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_GraphML(f, index=0)\n--\n\n" "Reads a GraphML format file and creates a graph based on it.\n\n" "@param f: the name of the file or a Python file handle\n" "@param index: if the GraphML file contains multiple graphs,\n" " specifies the one that should be loaded. Graph indices\n" " start from zero, so if you want to load the first graph,\n" " specify 0 here.\n"}, /* interface to igraph_read_graph_gml */ {"Read_GML", (PyCFunction) igraphmodule_Graph_Read_GML, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_GML(f)\n--\n\n" "Reads a GML file and creates a graph based on it.\n\n" "@param f: the name of the file or a Python file handle\n" }, /* interface to igraph_read_graph_ncol */ {"Read_Ncol", (PyCFunction) igraphmodule_Graph_Read_Ncol, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_Ncol(f, names=True, weights=\"if_present\", directed=True)\n--\n\n" "Reads an .ncol file used by LGL.\n\n" "It is also useful for creating graphs from \"named\" (and\n" "optionally weighted) edge lists.\n\n" "This format is used by the Large Graph Layout program. See the\n" "U{repository of LGL }\n" "for more information.\n\n" "LGL originally cannot deal with graphs containing multiple or loop\n" "edges, but this condition is not checked here, as igraph is happy\n" "with these.\n\n" "@param f: the name of the file or a Python file handle\n" "@param names: If C{True}, the vertex names are added as a\n" " vertex attribute called 'name'.\n" "@param weights: If True, the edge weights are added as an\n" " edge attribute called 'weight', even if there are no\n" " weights in the file. If False, the edge weights are never\n" " added, even if they are present. C{\"auto\"} or C{\"if_present\"}\n" " means that weights are added if there is at least one weighted\n" " edge in the input file, but they are not added otherwise.\n" "@param directed: whether the graph being created should be\n" " directed\n" }, /* interface to igraph_read_graph_lgl */ {"Read_Lgl", (PyCFunction) igraphmodule_Graph_Read_Lgl, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_Lgl(f, names=True, weights=\"if_present\", directed=True)\n--\n\n" "Reads an .lgl file used by LGL.\n\n" "It is also useful for creating graphs from \"named\" (and\n" "optionally weighted) edge lists.\n\n" "This format is used by the Large Graph Layout program. See the\n" "U{documentation of LGL }\n" "regarding the exact format description.\n\n" "LGL originally cannot deal with graphs containing multiple or loop\n" "edges, but this condition is not checked here, as igraph is happy\n" "with these.\n\n" "@param f: the name of the file or a Python file handle\n" "@param names: If C{True}, the vertex names are added as a\n" " vertex attribute called 'name'.\n" "@param weights: If True, the edge weights are added as an\n" " edge attribute called 'weight', even if there are no\n" " weights in the file. If False, the edge weights are never\n" " added, even if they are present. C{\"auto\"} or C{\"if_present\"}\n" " means that weights are added if there is at least one weighted\n" " edge in the input file, but they are not added otherwise.\n" "@param directed: whether the graph being created should be\n" " directed\n" }, /* interface to igraph_read_graph_pajek */ {"Read_Pajek", (PyCFunction) igraphmodule_Graph_Read_Pajek, METH_VARARGS | METH_KEYWORDS | METH_CLASS, "Read_Pajek(f)\n--\n\n" "Reads a Pajek format file and creates a graph based on it.\n\n" "@param f: the name of the file or a Python file handle\n"}, /* interface to igraph_write_graph_dimacs */ {"write_dimacs", (PyCFunction) igraphmodule_Graph_write_dimacs, METH_VARARGS | METH_KEYWORDS, "write_dimacs(f, source, target, capacity=None)\n--\n\n" "Writes the graph in DIMACS format to the given file.\n\n" "@param f: the name of the file to be written or a Python file handle\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@param capacity: the capacities of the edges in a list. If it is not a\n" " list, the corresponding edge attribute will be used to retrieve\n" " capacities."}, /* interface to igraph_write_graph_dot */ {"write_dot", (PyCFunction) igraphmodule_Graph_write_dot, METH_VARARGS | METH_KEYWORDS, "write_dot(f)\n--\n\n" "Writes the graph in DOT format to the given file.\n\n" "DOT is the format used by the U{GraphViz }\n" "software package.\n\n" "@param f: the name of the file to be written or a Python file handle\n" }, /* interface to igraph_write_graph_edgelist */ {"write_edgelist", (PyCFunction) igraphmodule_Graph_write_edgelist, METH_VARARGS | METH_KEYWORDS, "write_edgelist(f)\n--\n\n" "Writes the edge list of a graph to a file.\n\n" "Directed edges are written in (from, to) order.\n\n" "@param f: the name of the file to be written or a Python file handle\n"}, /* interface to igraph_write_graph_gml */ {"write_gml", (PyCFunction) igraphmodule_Graph_write_gml, METH_VARARGS | METH_KEYWORDS, "write_gml(f, creator=None, ids=None)\n--\n\n" "Writes the graph in GML format to the given file.\n\n" "@param f: the name of the file to be written or a Python file handle\n" "@param creator: optional creator information to be written to the file.\n" " If C{None}, the current date and time is added.\n" "@param ids: optional numeric vertex IDs to use in the file. This must\n" " be a list of integers or C{None}. If C{None}, the C{id} attribute of\n" " the vertices are used, or if they don't exist, numeric vertex IDs\n" " will be generated automatically."}, /* interface to igraph_write_graph_ncol */ {"write_ncol", (PyCFunction) igraphmodule_Graph_write_ncol, METH_VARARGS | METH_KEYWORDS, "write_ncol(f, names=\"name\", weights=\"weights\")\n--\n\n" "Writes the edge list of a graph to a file in .ncol format.\n\n" "Note that multiple edges and/or loops break the LGL software,\n" "but igraph does not check for this condition. Unless you know\n" "that the graph does not have multiple edges and/or loops, it\n" "is wise to call L{simplify()} before saving.\n\n" "@param f: the name of the file to be written or a Python file handle\n" "@param names: the name of the vertex attribute containing the name\n" " of the vertices. If you don't want to store vertex names,\n" " supply C{None} here.\n" "@param weights: the name of the edge attribute containing the weight\n" " of the vertices. If you don't want to store weights,\n" " supply C{None} here.\n"}, /* interface to igraph_write_graph_lgl */ {"write_lgl", (PyCFunction) igraphmodule_Graph_write_lgl, METH_VARARGS | METH_KEYWORDS, "write_lgl(f, names=\"name\", weights=\"weights\", isolates=True)\n--\n\n" "Writes the edge list of a graph to a file in .lgl format.\n\n" "Note that multiple edges and/or loops break the LGL software,\n" "but igraph does not check for this condition. Unless you know\n" "that the graph does not have multiple edges and/or loops, it\n" "is wise to call L{simplify()} before saving.\n\n" "@param f: the name of the file to be written or a Python file handle\n" "@param names: the name of the vertex attribute containing the name\n" " of the vertices. If you don't want to store vertex names,\n" " supply C{None} here.\n" "@param weights: the name of the edge attribute containing the weight\n" " of the vertices. If you don't want to store weights,\n" " supply C{None} here.\n" "@param isolates: whether to include isolated vertices in the output.\n"}, /* interface to igraph_write_graph_pajek */ {"write_pajek", (PyCFunction) igraphmodule_Graph_write_pajek, METH_VARARGS | METH_KEYWORDS, "write_pajek(f)\n--\n\n" "Writes the graph in Pajek format to the given file.\n\n" "@param f: the name of the file to be written or a Python file handle\n" }, /* interface to igraph_write_graph_edgelist */ {"write_graphml", (PyCFunction) igraphmodule_Graph_write_graphml, METH_VARARGS | METH_KEYWORDS, "write_graphml(f)\n--\n\n" "Writes the graph to a GraphML file.\n\n" "@param f: the name of the file to be written or a Python file handle\n" }, /* interface to igraph_write_graph_leda */ {"write_leda", (PyCFunction) igraphmodule_Graph_write_leda, METH_VARARGS | METH_KEYWORDS, "write_leda(f, names=\"name\", weights=\"weights\")\n--\n\n" "Writes the graph to a file in LEDA native format.\n\n" "The LEDA format supports at most one attribute per vertex and edge. You can\n" "specify which vertex and edge attribute you want to use. Note that the\n" "name of the attribute is not saved in the LEDA file.\n\n" "@param f: the name of the file to be written or a Python file handle\n" "@param names: the name of the vertex attribute to be stored along with\n" " the vertices. It is usually used to store the vertex names (hence the\n" " name of the keyword argument), but you may also use a numeric attribute.\n" " If you don't want to store any vertex attributes, supply C{None} here.\n" "@param weights: the name of the edge attribute to be stored along with\n" " the edges. It is usually used to store the edge weights (hence the\n" " name of the keyword argument), but you may also use a string attribute.\n" " If you don't want to store any edge attributes, supply C{None} here.\n"}, /***************/ /* ISOMORPHISM */ /***************/ {"canonical_permutation", (PyCFunction) igraphmodule_Graph_canonical_permutation, METH_VARARGS | METH_KEYWORDS, "canonical_permutation(sh=\"fl\", color=None)\n--\n\n" "Calculates the canonical permutation of a graph using the BLISS isomorphism\n" "algorithm.\n\n" "Passing the permutation returned here to L{permute_vertices()} will\n" "transform the graph into its canonical form.\n\n" "See U{http://www.tcs.hut.fi/Software/bliss/index.html} for more information\n" "about the BLISS algorithm and canonical permutations.\n\n" "@param sh: splitting heuristics for graph as a case-insensitive string,\n" " with the following possible values:\n\n" " - C{\"f\"}: first non-singleton cell\n\n" " - C{\"fl\"}: first largest non-singleton cell\n\n" " - C{\"fs\"}: first smallest non-singleton cell\n\n" " - C{\"fm\"}: first maximally non-trivially connected non-singleton\n" " cell\n\n" " - C{\"flm\"}: largest maximally non-trivially connected\n" " non-singleton cell\n\n" " - C{\"fsm\"}: smallest maximally non-trivially connected\n" " non-singleton cell\n\n" "@param color: optional vector storing a coloring of the vertices\n " "with respect to which the isomorphism is computed." "If C{None}, all vertices have the same color.\n" "@return: a permutation vector containing vertex IDs. Vertex 0 in the original\n" " graph will be mapped to an ID contained in the first element of this\n" " vector; vertex 1 will be mapped to the second and so on.\n" }, {"isoclass", (PyCFunction) igraphmodule_Graph_isoclass, METH_VARARGS | METH_KEYWORDS, "isoclass(vertices)\n--\n\n" "Returns the isomorphism class of the graph or its subgraph.\n\n" "Isomorphy class calculations are implemented only for graphs with\n" "3 or 4 vertices.\n\n" "@param vertices: a list of vertices if we want to calculate the\n" " isomorphism class for only a subset of vertices. C{None} means to\n" " use the full graph.\n" "@return: the isomorphism class of the (sub)graph\n\n"}, {"isomorphic", (PyCFunction) igraphmodule_Graph_isomorphic, METH_VARARGS | METH_KEYWORDS, "isomorphic(other)\n--\n\n" "Checks whether the graph is isomorphic to another graph.\n\n" "The algorithm being used is selected using a simple heuristic:\n\n" " - If one graph is directed and the other undirected, an exception\n" " is thrown.\n\n" " - If the two graphs does not have the same number of vertices and\n" " edges, it returns with C{False}\n\n" " - If the graphs have three or four vertices, then an O(1) algorithm\n" " is used with precomputed data.\n\n" " - Otherwise if the graphs are directed, then the VF2 isomorphism\n" " algorithm is used (see L{isomorphic_vf2}).\n\n" " - Otherwise the BLISS isomorphism algorithm is used, see\n" " L{isomorphic_bliss}.\n\n" "@return: C{True} if the graphs are isomorphic, C{False} otherwise.\n" }, {"isomorphic_bliss", (PyCFunction) igraphmodule_Graph_isomorphic_bliss, METH_VARARGS | METH_KEYWORDS, "isomorphic_bliss(other, return_mapping_12=False, return_mapping_21=False,\n" " sh1=\"fl\", sh2=None, color1=None, color2=None)\n--\n\n" "Checks whether the graph is isomorphic to another graph, using the\n" "BLISS isomorphism algorithm.\n\n" "See U{http://www.tcs.hut.fi/Software/bliss/index.html} for more information\n" "about the BLISS algorithm.\n\n" "@param other: the other graph with which we want to compare the graph.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param return_mapping_12: if C{True}, calculates the mapping which maps\n" " the vertices of the first graph to the second.\n" "@param return_mapping_21: if C{True}, calculates the mapping which maps\n" " the vertices of the second graph to the first.\n" "@param sh1: splitting heuristics for the first graph as a\n" " case-insensitive string, with the following possible values:\n\n" " - C{\"f\"}: first non-singleton cell\n\n" " - C{\"fl\"}: first largest non-singleton cell\n\n" " - C{\"fs\"}: first smallest non-singleton cell\n\n" " - C{\"fm\"}: first maximally non-trivially connected non-singleton\n" " cell\n\n" " - C{\"flm\"}: largest maximally non-trivially connected\n" " non-singleton cell\n\n" " - C{\"fsm\"}: smallest maximally non-trivially connected\n" " non-singleton cell\n\n" "@param sh2: splitting heuristics to be used for the second graph.\n" " This must be the same as C{sh1}; alternatively, it can be C{None},\n" " in which case it will automatically use the same value as C{sh1}.\n" " Currently it is present for backwards compatibility only.\n" "@return: if no mapping is calculated, the result is C{True} if the graphs\n" " are isomorphic, C{False} otherwise. If any or both mappings are\n" " calculated, the result is a 3-tuple, the first element being the\n" " above mentioned boolean, the second element being the 1 -> 2 mapping\n" " and the third element being the 2 -> 1 mapping. If the corresponding\n" " mapping was not calculated, C{None} is returned in the appropriate\n" " element of the 3-tuple.\n"}, {"isomorphic_vf2", (PyCFunction) igraphmodule_Graph_isomorphic_vf2, METH_VARARGS | METH_KEYWORDS, "isomorphic_vf2(other=None, color1=None, color2=None, edge_color1=None,\n" " edge_color2=None, return_mapping_12=False, return_mapping_21=False,\n" " node_compat_fn=None, edge_compat_fn=None, callback=None)\n--\n\n" "Checks whether the graph is isomorphic to another graph, using the\n" "VF2 isomorphism algorithm.\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph with which we want to compare the graph.\n" " If C{None}, the automorphjisms of the graph will be tested.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param return_mapping_12: if C{True}, calculates the mapping which maps\n" " the vertices of the first graph to the second.\n" "@param return_mapping_21: if C{True}, calculates the mapping which maps\n" " the vertices of the second graph to the first.\n" "@param callback: if not C{None}, the isomorphism search will not stop at\n" " the first match; it will call this callback function instead for every\n" " isomorphism found. The callback function must accept four arguments:\n" " the first graph, the second graph, a mapping from the nodes of the\n" " first graph to the second, and a mapping from the nodes of the second\n" " graph to the first. The function must return C{True} if the search\n" " should continue or C{False} otherwise.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: if no mapping is calculated, the result is C{True} if the graphs\n" " are isomorphic, C{False} otherwise. If any or both mappings are\n" " calculated, the result is a 3-tuple, the first element being the\n" " above mentioned boolean, the second element being the 1 -> 2 mapping\n" " and the third element being the 2 -> 1 mapping. If the corresponding\n" " mapping was not calculated, C{None} is returned in the appropriate\n" " element of the 3-tuple.\n"}, {"count_isomorphisms_vf2", (PyCFunction) igraphmodule_Graph_count_isomorphisms_vf2, METH_VARARGS | METH_KEYWORDS, "count_isomorphisms_vf2(other=None, color1=None, color2=None, edge_color1=None,\n" " edge_color2=None, node_compat_fn=None, edge_compat_fn=None)\n--\n\n" "Determines the number of isomorphisms between the graph and another one\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph. If C{None}, the number of automorphisms\n" " will be returned.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: the number of isomorphisms between the two given graphs (or the\n" " number of automorphisms if C{other} is C{None}.\n"}, {"get_isomorphisms_vf2", (PyCFunction) igraphmodule_Graph_get_isomorphisms_vf2, METH_VARARGS | METH_KEYWORDS, "get_isomorphisms_vf2(other=None, color1=None, color2=None, edge_color1=None, " "edge_color2=None, node_compat_fn=None, edge_compat_fn=None)\n--\n\n" "Returns all isomorphisms between the graph and another one\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph. If C{None}, the automorphisms\n" " will be returned.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: a list of lists, each item of the list containing the mapping\n" " from vertices of the second graph to the vertices of the first one\n"}, {"subisomorphic_vf2", (PyCFunction) igraphmodule_Graph_subisomorphic_vf2, METH_VARARGS | METH_KEYWORDS, "subisomorphic_vf2(other, color1=None, color2=None, edge_color1=None,\n" " edge_color2=None, return_mapping_12=False, return_mapping_21=False,\n" " callback=None, node_compat_fn=None, edge_compat_fn=None)\n--\n\n" "Checks whether a subgraph of the graph is isomorphic to another graph.\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph with which we want to compare the graph.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param return_mapping_12: if C{True}, calculates the mapping which maps\n" " the vertices of the first graph to the second. The mapping can contain\n" " -1 if a given node is not mapped.\n" "@param return_mapping_21: if C{True}, calculates the mapping which maps\n" " the vertices of the second graph to the first. The mapping can contain\n" " -1 if a given node is not mapped.\n" "@param callback: if not C{None}, the subisomorphism search will not stop at\n" " the first match; it will call this callback function instead for every\n" " subisomorphism found. The callback function must accept four arguments:\n" " the first graph, the second graph, a mapping from the nodes of the\n" " first graph to the second, and a mapping from the nodes of the second\n" " graph to the first. The function must return C{True} if the search\n" " should continue or C{False} otherwise.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: if no mapping is calculated, the result is C{True} if the graph\n" " contains a subgraph that's isomorphic to the given one, C{False}\n" " otherwise. If any or both mappings are calculated, the result is a\n" " 3-tuple, the first element being the above mentioned boolean, the\n" " second element being the 1 -> 2 mapping and the third element being\n" " the 2 -> 1 mapping. If the corresponding mapping was not calculated,\n" " C{None} is returned in the appropriate element of the 3-tuple.\n"}, {"count_subisomorphisms_vf2", (PyCFunction) igraphmodule_Graph_count_subisomorphisms_vf2, METH_VARARGS | METH_KEYWORDS, "count_subisomorphisms_vf2(other, color1=None, color2=None,\n" " edge_color1=None, edge_color2=None, node_compat_fn=None,\n" " edge_compat_fn=None)\n--\n\n" "Determines the number of subisomorphisms between the graph and another one\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: the number of subisomorphisms between the two given graphs\n"}, {"get_subisomorphisms_vf2", (PyCFunction) igraphmodule_Graph_get_subisomorphisms_vf2, METH_VARARGS | METH_KEYWORDS, "get_subisomorphisms_vf2(other, color1=None, color2=None,\n" " edge_color1=None, edge_color2=None, node_compat_fn=None,\n" " edge_compat_fn=None)\n--\n\n" "Returns all subisomorphisms between the graph and another one\n\n" "Vertex and edge colors may be used to restrict the isomorphisms, as only\n" "vertices and edges with the same color will be allowed to match each other.\n\n" "@param other: the other graph.\n" "@param color1: optional vector storing the coloring of the vertices of\n" " the first graph. If C{None}, all vertices have the same color.\n" "@param color2: optional vector storing the coloring of the vertices of\n" " the second graph. If C{None}, all vertices have the same color.\n" "@param edge_color1: optional vector storing the coloring of the edges of\n" " the first graph. If C{None}, all edges have the same color.\n" "@param edge_color2: optional vector storing the coloring of the edges of\n" " the second graph. If C{None}, all edges have the same color.\n" "@param node_compat_fn: a function that receives the two graphs and two\n" " node indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the nodes given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on node-specific\n" " criteria that are too complicated to be represented by node color\n" " vectors (i.e. the C{color1} and C{color2} parameters). C{None} means\n" " that every node is compatible with every other node.\n" "@param edge_compat_fn: a function that receives the two graphs and two\n" " edge indices (one from the first graph, one from the second graph) and\n" " returns C{True} if the edges given by the two indices are compatible\n" " (i.e. they could be matched to each other) or C{False} otherwise. This\n" " can be used to restrict the set of isomorphisms based on edge-specific\n" " criteria that are too complicated to be represented by edge color\n" " vectors (i.e. the C{edge_color1} and C{edge_color2} parameters). C{None}\n" " means that every edge is compatible with every other node.\n" "@return: a list of lists, each item of the list containing the mapping\n" " from vertices of the second graph to the vertices of the first one\n"}, {"subisomorphic_lad", (PyCFunction) igraphmodule_Graph_subisomorphic_lad, METH_VARARGS | METH_KEYWORDS, "subisomorphic_lad(other, domains=None, induced=False, time_limit=0, \n" " return_mapping=False)\n--\n\n" "Checks whether a subgraph of the graph is isomorphic to another graph.\n\n" "The optional C{domains} argument may be used to restrict vertices that\n" "may match each other. You can also specify whether you are interested\n" "in induced subgraphs only or not.\n\n" "@param other: the pattern graph we are looking for in the graph.\n" "@param domains: a list of lists, one sublist belonging to each vertex in\n" " the template graph. Sublist M{i} contains the indices of the vertices in\n" " the original graph that may match vertex M{i} in the template graph.\n" " C{None} means that every vertex may match every other vertex.\n" "@param induced: whether to consider induced subgraphs only.\n" "@param time_limit: an optimal time limit in seconds. Only the integral\n" " part of this number is taken into account. If the time limit is\n" " exceeded, the method will throw an exception.\n" "@param return_mapping: when C{True}, the function will return a tuple,\n" " where the first element is a boolean denoting whether a subisomorphism\n" " has been found or not, and the second element describes the mapping\n" " of the vertices from the template graph to the original graph. When\n" " C{False}, only the boolean is returned.\n" "@return: if no mapping is calculated, the result is C{True} if the graph\n" " contains a subgraph that is isomorphic to the given template, C{False}\n" " otherwise. If the mapping is calculated, the result is a tuple, the first\n" " element being the above mentioned boolean, and the second element being\n" " the mapping from the target to the original graph.\n"}, {"get_subisomorphisms_lad", (PyCFunction) igraphmodule_Graph_get_subisomorphisms_lad, METH_VARARGS | METH_KEYWORDS, "get_subisomorphisms_lad(other, domains=None, induced=False, time_limit=0)\n--\n\n" "Returns all subisomorphisms between the graph and another one using the LAD\n" "algorithm.\n\n" "The optional C{domains} argument may be used to restrict vertices that\n" "may match each other. You can also specify whether you are interested\n" "in induced subgraphs only or not.\n\n" "@param other: the pattern graph we are looking for in the graph.\n" "@param domains: a list of lists, one sublist belonging to each vertex in\n" " the template graph. Sublist M{i} contains the indices of the vertices in\n" " the original graph that may match vertex M{i} in the template graph.\n" " C{None} means that every vertex may match every other vertex.\n" "@param induced: whether to consider induced subgraphs only.\n" "@param time_limit: an optimal time limit in seconds. Only the integral\n" " part of this number is taken into account. If the time limit is\n" " exceeded, the method will throw an exception.\n" "@return: a list of lists, each item of the list containing the mapping\n" " from vertices of the second graph to the vertices of the first one\n"}, //////////////////////// // ATTRIBUTE HANDLING // //////////////////////// {"attributes", (PyCFunction) igraphmodule_Graph_attributes, METH_NOARGS, "attributes()\n--\n\n" "@return: the attribute name list of the graph\n"}, {"vertex_attributes", (PyCFunction) igraphmodule_Graph_vertex_attributes, METH_NOARGS, "vertex_attributes()\n--\n\n" "@return: the attribute name list of the vertices of the graph\n"}, {"edge_attributes", (PyCFunction) igraphmodule_Graph_edge_attributes, METH_NOARGS, "edge_attributes()\n--\n\n" "@return: the attribute name list of the edges of the graph\n"}, /////////////// // OPERATORS // /////////////// {"complementer", (PyCFunction) igraphmodule_Graph_complementer, METH_VARARGS | METH_KEYWORDS, "complementer(loops=False)\n--\n\n" "Returns the complementer of the graph\n\n" "@param loops: whether to include loop edges in the complementer.\n" "@return: the complementer of the graph\n"}, {"compose", (PyCFunction) igraphmodule_Graph_compose, METH_O, "compose(other)\n--\n\nReturns the composition of two graphs."}, {"difference", (PyCFunction) igraphmodule_Graph_difference, METH_O, "difference(other)\n--\n\nSubtracts the given graph from the original"}, /**********************/ /* DOMINATORS */ /**********************/ {"dominator", (PyCFunction) igraphmodule_Graph_dominator, METH_VARARGS | METH_KEYWORDS, "dominator(vid, mode=\"out\")\n--\n\n" "Returns the dominator tree from the given root node\n\n" "@param vid: the root vertex ID\n" "@param mode: either C{\"in\"} or C{\"out\"}\n" "@return: a list containing the dominator tree for the current graph." }, /*****************/ /* MAXIMUM FLOWS */ /*****************/ {"maxflow_value", (PyCFunction) igraphmodule_Graph_maxflow_value, METH_VARARGS | METH_KEYWORDS, "maxflow_value(source, target, capacity=None)\n--\n\n" "Returns the value of the maximum flow between the source and target vertices.\n\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@param capacity: the capacity of the edges. It must be a list or a valid\n" " attribute name or C{None}. In the latter case, every edge will have the\n" " same capacity.\n" "@return: the value of the maximum flow between the given vertices\n"}, {"maxflow", (PyCFunction) igraphmodule_Graph_maxflow, METH_VARARGS | METH_KEYWORDS, "maxflow(source, target, capacity=None)\n--\n\n" "Returns the maximum flow between the source and target vertices.\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{Flow} object. It is advised\n" " to use that.\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@param capacity: the capacity of the edges. It must be a list or a valid\n" " attribute name or C{None}. In the latter case, every edge will have the\n" " same capacity.\n" "@return: a tuple containing the following: the value of the maximum flow\n" " between the given vertices, the flow value on all the edges, the edge\n" " IDs that are part of the corresponding minimum cut, and the vertex IDs\n" " on one side of the cut. For directed graphs, the flow value vector gives\n" " the flow value on each edge. For undirected graphs, the flow value is\n" " positive if the flow goes from the smaller vertex ID to the bigger one\n" " and negative if the flow goes from the bigger vertex ID to the smaller." }, /**********************/ /* CUTS, MINIMUM CUTS */ /**********************/ {"all_st_cuts", (PyCFunction) igraphmodule_Graph_all_st_cuts, METH_VARARGS | METH_KEYWORDS, "all_st_cuts(source, target)\n--\n\n" "Returns all the cuts between the source and target vertices in a\n" "directed graph.\n\n" "This function lists all edge-cuts between a source and a target vertex.\n" "Every cut is listed exactly once.\n\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a list of L{Cut} objects. It is\n" " advised to use that.\n" "@return: a tuple where the first element is a list of lists of edge IDs\n" " representing a cut and the second element is a list of lists of vertex\n" " IDs representing the sets of vertices that were separated by the cuts.\n" }, {"all_st_mincuts", (PyCFunction) igraphmodule_Graph_all_st_mincuts, METH_VARARGS | METH_KEYWORDS, "all_st_mincuts(source, target)\n--\n\n" "Returns all minimum cuts between the source and target vertices in a\n" "directed graph.\n\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a list of L{Cut} objects. It is\n" " advised to use that.\n" }, {"mincut_value", (PyCFunction) igraphmodule_Graph_mincut_value, METH_VARARGS | METH_KEYWORDS, "mincut_value(source=-1, target=-1, capacity=None)\n--\n\n" "Returns the minimum cut between the source and target vertices or within\n" "the whole graph.\n\n" "@param source: the source vertex ID. If negative, the calculation is\n" " done for every vertex except the target and the minimum is returned.\n" "@param target: the target vertex ID. If negative, the calculation is\n" " done for every vertex except the source and the minimum is returned.\n" "@param capacity: the capacity of the edges. It must be a list or a valid\n" " attribute name or C{None}. In the latter case, every edge will have the\n" " same capacity.\n" "@return: the value of the minimum cut between the given vertices\n"}, {"mincut", (PyCFunction) igraphmodule_Graph_mincut, METH_VARARGS | METH_KEYWORDS, "mincut(source=None, target=None, capacity=None)\n--\n\n" "Calculates the minimum cut between the source and target vertices or\n" "within the whole graph.\n\n" "The minimum cut is the minimum set of edges that needs to be removed\n" "to separate the source and the target (if they are given) or to disconnect\n" "the graph (if the source and target are not given). The minimum is\n" "calculated using the weights (capacities) of the edges, so the cut with\n" "the minimum total capacity is calculated.\n" "For undirected graphs and no source and target, the method uses the Stoer-Wagner\n" "algorithm. For a given source and target, the method uses the push-relabel\n" "algorithm; see the references below.\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{Cut} object. It is advised\n" " to use that.\n" "@param source: the source vertex ID. If C{None}, target must also be\n" " {None} and the calculation will be done for the entire graph (i.e. all\n" " possible vertex pairs).\n" "@param target: the target vertex ID. If C{None}, source must also be\n" " {None} and the calculation will be done for the entire graph (i.e. all\n" " possible vertex pairs).\n" "@param capacity: the capacity of the edges. It must be a list or a valid\n" " attribute name or C{None}. In the latter case, every edge will have the\n" " same capacity.\n" "@return: the value of the minimum cut, the IDs of vertices in the\n" " first and second partition, and the IDs of edges in the cut,\n" " packed in a 4-tuple\n\n" "@newfield ref: Reference\n" "@ref: M. Stoer, F. Wagner: A simple min-cut algorithm. Journal of\n" " the ACM 44(4):585-591, 1997.\n" "@ref: A. V. Goldberg, R. E. Tarjan: A new approach to the maximum-flow problem.\n" " Journal of the ACM 35(4):921-940, 1988.\n" }, {"st_mincut", (PyCFunction) igraphmodule_Graph_st_mincut, METH_VARARGS | METH_KEYWORDS, "st_mincut(source, target, capacity=None)\n--\n\n" "Calculates the minimum cut between the source and target vertices in a\n" "graph.\n\n" "@param source: the source vertex ID\n" "@param target: the target vertex ID\n" "@param capacity: the capacity of the edges. It must be a list or a valid\n" " attribute name or C{None}. In the latter case, every edge will have the\n" " same capacity.\n" "@return: the value of the minimum cut, the IDs of vertices in the\n" " first and second partition, and the IDs of edges in the cut,\n" " packed in a 4-tuple\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a list of L{Cut} objects. It is\n" " advised to use that.\n" }, {"gomory_hu_tree", (PyCFunction) igraphmodule_Graph_gomory_hu_tree, METH_VARARGS | METH_KEYWORDS, "gomory_hu_tree(capacity=None)\n--\n\n" "Internal function, undocumented.\n\n" "@see: Graph.gomory_hu_tree()\n\n" }, /*********************/ /* VERTEX SEPARATORS */ /*********************/ {"all_minimal_st_separators", (PyCFunction) igraphmodule_Graph_all_minimal_st_separators, METH_NOARGS, "all_minimal_st_separators()\n--\n\n" "Returns a list containing all the minimal s-t separators of a graph.\n\n" "A minimal separator is a set of vertices whose removal disconnects the graph,\n" "while the removal of any subset of the set keeps the graph connected.\n\n" "@return: a list where each item lists the vertex indices of a given\n" " minimal s-t separator.\n" "@newfield ref: Reference\n" "@ref: Anne Berry, Jean-Paul Bordat and Olivier Cogis: Generating all the\n" " minimal separators of a graph. In: Peter Widmayer, Gabriele Neyer and\n" " Stephan Eidenbenz (eds.): Graph-theoretic concepts in computer science,\n" " 1665, 167--172, 1999. Springer.\n"}, {"is_minimal_separator", (PyCFunction) igraphmodule_Graph_is_minimal_separator, METH_VARARGS | METH_KEYWORDS, "is_minimal_separator(vertices)\n--\n\n" "Decides whether the given vertex set is a minimal separator.\n\n" "A minimal separator is a set of vertices whose removal disconnects the graph,\n" "while the removal of any subset of the set keeps the graph connected.\n\n" "@param vertices: a single vertex ID or a list of vertex IDs\n" "@return: C{True} is the given vertex set is a minimal separator, C{False}\n" " otherwise.\n"}, {"is_separator", (PyCFunction) igraphmodule_Graph_is_separator, METH_VARARGS | METH_KEYWORDS, "is_separator(vertices)\n--\n\n" "Decides whether the removal of the given vertices disconnects the graph.\n\n" "@param vertices: a single vertex ID or a list of vertex IDs\n" "@return: C{True} is the given vertex set is a separator, C{False} if not.\n"}, {"minimum_size_separators", (PyCFunction) igraphmodule_Graph_minimum_size_separators, METH_NOARGS, "minimum_size_separators()\n--\n\n" "Returns a list containing all separator vertex sets of minimum size.\n\n" "A vertex set is a separator if its removal disconnects the graph. This method\n" "lists all the separators for which no smaller separator set exists in the\n" "given graph.\n\n" "@return: a list where each item lists the vertex indices of a given\n" " separator of minimum size.\n" "@newfield ref: Reference\n" "@ref: Arkady Kanevsky: Finding all minimum-size separating vertex sets\n" " in a graph. Networks 23:533--541, 1993.\n"}, /*******************/ /* COHESIVE BLOCKS */ /*******************/ {"cohesive_blocks", (PyCFunction) igraphmodule_Graph_cohesive_blocks, METH_NOARGS, "cohesive_blocks()\n--\n\n" "Calculates the cohesive block structure of the graph.\n\n" "@attention: this function has a more convenient interface in class\n" " L{Graph} which wraps the result in a L{CohesiveBlocks} object.\n" " It is advised to use that.\n" }, /********************************/ /* CLIQUES AND INDEPENDENT SETS */ /********************************/ {"cliques", (PyCFunction) igraphmodule_Graph_cliques, METH_VARARGS | METH_KEYWORDS, "cliques(min=0, max=0)\n--\n\n" "Returns some or all cliques of the graph as a list of tuples.\n\n" "A clique is a complete subgraph -- a set of vertices where an edge\n" "is present between any two of them (excluding loops)\n\n" "@param min: the minimum size of cliques to be returned. If zero or\n" " negative, no lower bound will be used.\n" "@param max: the maximum size of cliques to be returned. If zero or\n" " negative, no upper bound will be used."}, {"largest_cliques", (PyCFunction) igraphmodule_Graph_largest_cliques, METH_NOARGS, "largest_cliques()\n--\n\n" "Returns the largest cliques of the graph as a list of tuples.\n\n" "Quite intuitively a clique is considered largest if there is no clique\n" "with more vertices in the whole graph. All largest cliques are maximal\n" "(i.e. nonextendable) but not all maximal cliques are largest.\n\n" "@see: L{clique_number()} for the size of the largest cliques or\n" " L{maximal_cliques()} for the maximal cliques"}, {"maximal_cliques", (PyCFunction) igraphmodule_Graph_maximal_cliques, METH_VARARGS | METH_KEYWORDS, "maximal_cliques(min=0, max=0, file=None)\n--\n\n" "Returns the maximal cliques of the graph as a list of tuples.\n\n" "A maximal clique is a clique which can't be extended by adding any other\n" "vertex to it. A maximal clique is not necessarily one of the largest\n" "cliques in the graph.\n\n" "@param min: the minimum size of maximal cliques to be returned. If zero\n" " or negative, no lower bound will be used.\n\n" "@param max: the maximum size of maximal cliques to be returned. If zero\n" " or negative, no upper bound will be used. If nonzero, the size of every\n" " maximal clique found will be compared to this value and a clique will\n" " be returned only if its size is smaller than this limit.\n\n" "@param file: a file object or the name of the file to write the results\n" " to. When this argument is C{None}, the maximal cliques will be returned\n" " as a list of lists.\n" "@return: the maximal cliques of the graph as a list of lists, or C{None}\n" " if the C{file} argument was given." "@see: L{largest_cliques()} for the largest cliques."}, {"clique_number", (PyCFunction) igraphmodule_Graph_clique_number, METH_NOARGS, "clique_number()\n--\n\n" "Returns the clique number of the graph.\n\n" "The clique number of the graph is the size of the largest clique.\n\n" "@see: L{largest_cliques()} for the largest cliques."}, {"independent_vertex_sets", (PyCFunction) igraphmodule_Graph_independent_vertex_sets, METH_VARARGS | METH_KEYWORDS, "independent_vertex_sets(min=0, max=0)\n--\n\n" "Returns some or all independent vertex sets of the graph as a list of tuples.\n\n" "Two vertices are independent if there is no edge between them. Members\n" "of an independent vertex set are mutually independent.\n\n" "@param min: the minimum size of sets to be returned. If zero or\n" " negative, no lower bound will be used.\n" "@param max: the maximum size of sets to be returned. If zero or\n" " negative, no upper bound will be used."}, {"largest_independent_vertex_sets", (PyCFunction) igraphmodule_Graph_largest_independent_vertex_sets, METH_NOARGS, "largest_independent_vertex_sets()\n--\n\n" "Returns the largest independent vertex sets of the graph as a list of tuples.\n\n" "Quite intuitively an independent vertex set is considered largest if\n" "there is no other set with more vertices in the whole graph. All largest\n" "sets are maximal (i.e. nonextendable) but not all maximal sets\n" "are largest.\n\n" "@see: L{independence_number()} for the size of the largest independent\n" " vertex sets or L{maximal_independent_vertex_sets()} for the maximal\n" " (nonextendable) independent vertex sets"}, {"maximal_independent_vertex_sets", (PyCFunction) igraphmodule_Graph_maximal_independent_vertex_sets, METH_NOARGS, "maximal_independent_vertex_sets()\n--\n\n" "Returns the maximal independent vertex sets of the graph as a list of tuples.\n\n" "A maximal independent vertex set is an independent vertex set\n" "which can't be extended by adding any other vertex to it. A maximal\n" "independent vertex set is not necessarily one of the largest\n" "independent vertex sets in the graph.\n\n" "@see: L{largest_independent_vertex_sets()} for the largest independent\n" " vertex sets\n\n" "@newfield ref: Reference\n" "@ref: S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka: I{A new\n" " algorithm for generating all the maximal independent sets}.\n" " SIAM J Computing, 6:505--517, 1977."}, {"independence_number", (PyCFunction) igraphmodule_Graph_independence_number, METH_NOARGS, "independence_number()\n--\n\n" "Returns the independence number of the graph.\n\n" "The independence number of the graph is the size of the largest\n" "independent vertex set.\n\n" "@see: L{largest_independent_vertex_sets()} for the largest independent\n" " vertex sets"}, /*********************************/ /* COMMUNITIES AND DECOMPOSITION */ /*********************************/ {"modularity", (PyCFunction) igraphmodule_Graph_modularity, METH_VARARGS | METH_KEYWORDS, "modularity(membership, weights=None, resolution=1, directed=True)\n--\n\n" "Calculates the modularity of the graph with respect to some vertex types.\n\n" "The modularity of a graph w.r.t. some division measures how good the\n" "division is, or how separated are the different vertex types from each\n" "other. It is defined as M{Q=1/(2m) * sum(Aij-gamma*ki*kj/(2m)delta(ci,cj),i,j)}.\n" "M{m} is the number of edges, M{Aij} is the element of the M{A} adjacency\n" "matrix in row M{i} and column M{j}, M{ki} is the degree of node M{i},\n" "M{kj} is the degree of node M{j}, M{Ci} and C{cj} are the types of\n" "the two vertices (M{i} and M{j}), and M{gamma} is a resolution parameter\n" "that defaults to 1 for the classical definition of modularity. M{delta(x,y)}\n" "is one iff M{x=y}, 0 otherwise.\n\n" "If edge weights are given, the definition of modularity is modified as\n" "follows: M{Aij} becomes the weight of the corresponding edge, M{ki}\n" "is the total weight of edges incident on vertex M{i}, M{kj} is the\n" "total weight of edges incident on vertex M{j} and M{m} is the total\n" "edge weight in the graph.\n\n" "@attention: method overridden in L{Graph} to allow L{VertexClustering}\n" " objects as a parameter. This method is not strictly necessary, since\n" " the L{VertexClustering} class provides a variable called C{modularity}.\n" "@param membership: the membership vector, e.g. the vertex type index for\n" " each vertex.\n" "@param weights: optional edge weights or C{None} if all edges are weighed\n" " equally.\n" "@param resolution: the resolution parameter I{gamma} in the formula above.\n" " The classical definition of modularity is retrieved when the resolution\n" " parameter is set to 1.\n" "@param directed: whether to consider edge directions if the graph is directed.\n" " C{True} will use the directed variant of the modularity measure where the\n" " in- and out-degrees of nodes are treated separately; C{False} will treat\n" " directed graphs as undirected.\n" "@return: the modularity score. Score larger than 0.3 usually indicates\n" " strong community structure.\n" "@newfield ref: Reference\n" "@ref: MEJ Newman and M Girvan: Finding and evaluating community structure\n" " in networks. Phys Rev E 69 026113, 2004.\n" }, {"coreness", (PyCFunction) igraphmodule_Graph_coreness, METH_VARARGS | METH_KEYWORDS, "coreness(mode=\"all\")\n--\n\n" "Finds the coreness (shell index) of the vertices of the network.\n\n" "The M{k}-core of a graph is a maximal subgraph in which each vertex\n" "has at least degree k. (Degree here means the degree in the\n" "subgraph of course). The coreness of a vertex is M{k} if it\n" "is a member of the M{k}-core but not a member of the M{k+1}-core.\n\n" "@param mode: whether to compute the in-corenesses (C{\"in\"}), the\n" " out-corenesses (C{\"out\"}) or the undirected corenesses (C{\"all\"}).\n" " Ignored and assumed to be C{\"all\"} for undirected graphs.\n" "@return: the corenesses for each vertex.\n\n" "@newfield ref: Reference\n" "@ref: Vladimir Batagelj, Matjaz Zaversnik: I{An M{O(m)} Algorithm\n" " for Core Decomposition of Networks.}"}, {"community_fastgreedy", (PyCFunction) igraphmodule_Graph_community_fastgreedy, METH_VARARGS | METH_KEYWORDS, "community_fastgreedy(weights=None)\n--\n\n" "Finds the community structure of the graph according to the algorithm of\n" "Clauset et al based on the greedy optimization of modularity.\n\n" "This is a bottom-up algorithm: initially every vertex belongs to a separate\n" "community, and communities are merged one by one. In every step, the two\n" "communities being merged are the ones which result in the maximal increase\n" "in modularity.\n\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights\n" "@return: a tuple with the following elements:\n" " 1. The list of merges\n" " 2. The modularity scores before each merge\n" "\n" "@newfield ref: Reference\n" "@ref: A. Clauset, M. E. J. Newman and C. Moore: I{Finding community\n" " structure in very large networks.} Phys Rev E 70, 066111 (2004).\n" "@see: modularity()\n" }, {"community_infomap", (PyCFunction) igraphmodule_Graph_community_infomap, METH_VARARGS | METH_KEYWORDS, "community_infomap(edge_weights=None, vertex_weights=None, trials=10)\n--\n\n" "Finds the community structure of the network according to the Infomap\n" "method of Martin Rosvall and Carl T. Bergstrom.\n\n" "See U{http://www.mapequation.org} for a visualization of the algorithm\n" "or one of the references provided below.\n\n" "@param edge_weights: name of an edge attribute or a list containing\n" " edge weights.\n" "@param vertex_weights: name of an vertex attribute or a list containing\n" " vertex weights.\n" "@param trials: the number of attempts to partition the network.\n" "@return: the calculated membership vector and the corresponding\n" " codelength in a tuple.\n" "\n" "@newfield ref: Reference\n" "@ref: M. Rosvall and C. T. Bergstrom: I{Maps of information flow reveal\n" " community structure in complex networks}. PNAS 105, 1118 (2008).\n" " U{http://arxiv.org/abs/0707.0609}\n" "@ref: M. Rosvall, D. Axelsson and C. T. Bergstrom: I{The map equation}.\n" " Eur Phys J Special Topics 178, 13 (2009). U{http://arxiv.org/abs/0906.1405}\n" }, {"community_label_propagation", (PyCFunction) igraphmodule_Graph_community_label_propagation, METH_VARARGS | METH_KEYWORDS, "community_label_propagation(weights=None, initial=None, fixed=None)\n--\n\n" "Finds the community structure of the graph according to the label\n" "propagation method of Raghavan et al.\n\n" "Initially, each vertex is assigned a different label. After that,\n" "each vertex chooses the dominant label in its neighbourhood in each\n" "iteration. Ties are broken randomly and the order in which the\n" "vertices are updated is randomized before every iteration. The algorithm\n" "ends when vertices reach a consensus.\n\n" "Note that since ties are broken randomly, there is no guarantee that\n" "the algorithm returns the same community structure after each run.\n" "In fact, they frequently differ. See the paper of Raghavan et al\n" "on how to come up with an aggregated community structure.\n\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights\n" "@param initial: name of a vertex attribute or a list containing\n" " the initial vertex labels. Labels are identified by integers from\n" " zero to M{n-1} where M{n} is the number of vertices. Negative\n" " numbers may also be present in this vector, they represent unlabeled\n" " vertices.\n" "@param fixed: a list of booleans for each vertex. C{True} corresponds\n" " to vertices whose labeling should not change during the algorithm.\n" " It only makes sense if initial labels are also given. Unlabeled\n" " vertices cannot be fixed. Note that vertex attribute names are not\n" " accepted here.\n" "@return: the resulting membership vector\n" "\n" "@newfield ref: Reference\n" "@ref: Raghavan, U.N. and Albert, R. and Kumara, S. Near linear\n" " time algorithm to detect community structures in large-scale\n" " networks. Phys Rev E 76:036106, 2007. U{http://arxiv.org/abs/0709.2938}.\n" }, {"community_leading_eigenvector", (PyCFunction) igraphmodule_Graph_community_leading_eigenvector, METH_VARARGS | METH_KEYWORDS, "community_leading_eigenvector(n=-1, arpack_options=None, weights=None)\n--\n\n" "A proper implementation of Newman's eigenvector community structure\n" "detection. Each split is done by maximizing the modularity regarding\n" "the original network. See the reference for details.\n\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param n: the desired number of communities. If negative, the algorithm\n" " tries to do as many splits as possible. Note that the algorithm\n" " won't split a community further if the signs of the leading eigenvector\n" " are all the same.\n" "@param arpack_options: an L{ARPACKOptions} object used to fine-tune\n" " the ARPACK eigenvector calculation. If omitted, the module-level\n" " variable called C{arpack_options} is used.\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights\n" "@return: a tuple where the first element is the membership vector of the\n" " clustering and the second element is the merge matrix.\n\n" "@newfield ref: Reference\n" "@ref: MEJ Newman: Finding community structure in networks using the\n" " eigenvectors of matrices, arXiv:physics/0605087\n" }, {"community_multilevel", (PyCFunction) igraphmodule_Graph_community_multilevel, METH_VARARGS | METH_KEYWORDS, "community_multilevel(weights=None, return_levels=True, resolution=1)\n--\n\n" "Finds the community structure of the graph according to the multilevel\n" "algorithm of Blondel et al. This is a bottom-up algorithm: initially\n" "every vertex belongs to a separate community, and vertices are moved\n" "between communities iteratively in a way that maximizes the vertices'\n" "local contribution to the overall modularity score. When a consensus is\n" "reached (i.e. no single move would increase the modularity score), every\n" "community in the original graph is shrank to a single vertex (while\n" "keeping the total weight of the incident edges) and the process continues\n" "on the next level. The algorithm stops when it is not possible to increase\n" "the modularity any more after shrinking the communities to vertices.\n\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights\n" "@param return_levels: if C{True}, returns the multilevel result. If\n" " C{False}, only the best level (corresponding to the best modularity)\n" " is returned.\n" "@param resolution: the resolution parameter to use in the modularity measure.\n" " Smaller values result in a smaller number of larger clusters, while higher\n" " values yield a large number of small clusters. The classical modularity\n" " measure assumes a resolution parameter of 1.\n" "@return: either a single list describing the community membership of each\n" " vertex (if C{return_levels} is C{False}), or a list of community membership\n" " vectors, one corresponding to each level and a list of corresponding\n" " modularities (if C{return_levels} is C{True}).\n" "\n" "@newfield ref: Reference\n" "@ref: VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast\n" " unfolding of community hierarchies in large networks. J Stat Mech\n" " P10008 (2008), http://arxiv.org/abs/0803.0476\n" "@see: modularity()\n" }, {"community_edge_betweenness", (PyCFunction)igraphmodule_Graph_community_edge_betweenness, METH_VARARGS | METH_KEYWORDS, "community_edge_betweenness(directed=True, weights=None)\n--\n\n" "Community structure detection based on the betweenness of the edges in\n" "the network. This algorithm was invented by M Girvan and MEJ Newman,\n" "see: M Girvan and MEJ Newman: Community structure in social and biological\n" "networks, Proc. Nat. Acad. Sci. USA 99, 7821-7826 (2002).\n\n" "The idea is that the betweenness of the edges connecting two communities\n" "is typically high. So we gradually remove the edge with the highest\n" "betweenness from the network and recalculate edge betweenness after every\n" "removal, as long as all edges are removed.\n\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param directed: whether to take into account the directedness of the edges\n" " when we calculate the betweenness values.\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights.\n\n" "@return: a tuple with the merge matrix that describes the dendrogram\n" " and the modularity scores before each merge. The modularity scores\n" " use the weights if the original graph was weighted.\n" }, {"community_optimal_modularity", (PyCFunction) igraphmodule_Graph_community_optimal_modularity, METH_VARARGS | METH_KEYWORDS, "community_optimal_modularity(weights=None)\n--\n\n" "Calculates the optimal modularity score of the graph and the\n" "corresponding community structure.\n\n" "This function uses the GNU Linear Programming Kit to solve a large\n" "integer optimization problem in order to find the optimal modularity\n" "score and the corresponding community structure, therefore it is\n" "unlikely to work for graphs larger than a few (less than a hundred)\n" "vertices. Consider using one of the heuristic approaches instead if\n" "you have such a large graph.\n\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights.\n\n" "@return: the calculated membership vector and the corresponding\n" " modularity in a tuple.\n" }, {"community_spinglass", (PyCFunction) igraphmodule_Graph_community_spinglass, METH_VARARGS | METH_KEYWORDS, "community_spinglass(weights=None, spins=25, parupdate=False, " "start_temp=1, stop_temp=0.01, cool_fact=0.99, update_rule=\"config\", " "gamma=1, implementation=\"orig\", lambda_=1)\n--\n\n" "Finds the community structure of the graph according to the spinglass\n" "community detection method of Reichardt & Bornholdt.\n\n" "@param weights: edge weights to be used. Can be a sequence or iterable or\n" " even an edge attribute name.\n" "@param spins: integer, the number of spins to use. This is the upper limit\n" " for the number of communities. It is not a problem to supply a\n" " (reasonably) big number here, in which case some spin states will be\n" " unpopulated.\n" "@param parupdate: whether to update the spins of the vertices in parallel\n" " (synchronously) or not\n" "@param start_temp: the starting temperature\n" "@param stop_temp: the stop temperature\n" "@param cool_fact: cooling factor for the simulated annealing\n" "@param update_rule: specifies the null model of the simulation. Possible\n" " values are C{\"config\"} (a random graph with the same vertex degrees\n" " as the input graph) or C{\"simple\"} (a random graph with the same number\n" " of edges)\n" "@param gamma: the gamma argument of the algorithm, specifying the balance\n" " between the importance of present and missing edges within a community.\n" " The default value of 1.0 assigns equal importance to both of them.\n" "@param implementation: currently igraph contains two implementations for\n" " the spinglass community detection algorithm. The faster original\n" " implementation is the default. The other implementation is able to take\n" " into account negative weights, this can be chosen by setting\n" " C{implementation} to C{\"neg\"}.\n" "@param lambda_: the lambda argument of the algorithm, which specifies the\n" " balance between the importance of present and missing negatively\n" " weighted edges within a community. Smaller values of lambda lead\n" " to communities with less negative intra-connectivity. If the argument\n" " is zero, the algorithm reduces to a graph coloring algorithm, using\n" " the number of spins as colors. This argument is ignored if the\n" " original implementation is used.\n" "@return: the community membership vector.\n" }, {"community_leiden", (PyCFunction) igraphmodule_Graph_community_leiden, METH_VARARGS | METH_KEYWORDS, "community_leiden(edge_weights=None, node_weights=None, " "resolution_parameter=1.0, normalize_resolution=False, beta=0.01, " "initial_membership=None, n_iterations=2)\n--\n\n" "Finds the community structure of the graph using the Leiden algorithm of\n" "Traag, van Eck & Waltman.\n\n" "@param edge_weights: edge weights to be used. Can be a sequence or\n" " iterable or even an edge attribute name.\n" "@param node_weights: the node weights used in the Leiden algorithm.\n" "@param resolution_parameter: the resolution parameter to use.\n" " Higher resolutions lead to more smaller communities, while \n" " lower resolutions lead to fewer larger communities.\n" "@param normalize_resolution: if set to true, the resolution parameter\n" " will be divided by the sum of the node weights. If this is not\n" " supplied, it will default to the node degree, or weighted degree\n" " in case edge_weights are supplied.\n" "@param beta: parameter affecting the randomness in the Leiden \n" " algorithm. This affects only the refinement step of the algorithm.\n" "@param initial_membership: if provided, the Leiden algorithm\n" " will try to improve this provided membership. If no argument is\n" " provided, the aglorithm simply starts from the singleton partition.\n" "@param n_iterations: the number of iterations to iterate the Leiden\n" " algorithm. Each iteration may improve the partition further.\n" "@return: the community membership vector.\n" }, {"community_walktrap", (PyCFunction) igraphmodule_Graph_community_walktrap, METH_VARARGS | METH_KEYWORDS, "community_walktrap(weights=None, steps=None)\n--\n\n" "Finds the community structure of the graph according to the random walk\n" "method of Latapy & Pons.\n\n" "The basic idea of the algorithm is that short random walks tend to stay\n" "in the same community. The method provides a dendrogram.\n\n" "@attention: this function is wrapped in a more convenient syntax in the\n" " derived class L{Graph}. It is advised to use that instead of this version.\n\n" "@param weights: name of an edge attribute or a list containing\n" " edge weights\n" "@return: a tuple with the list of merges and the modularity scores corresponding\n" " to each merge\n" "\n" "@newfield ref: Reference\n" "@ref: Pascal Pons, Matthieu Latapy: Computing communities in large networks\n" " using random walks, U{http://arxiv.org/abs/physics/0512106}.\n" "@see: modularity()\n" }, /*************/ /* MATCHINGS */ /*************/ {"_is_matching", (PyCFunction)igraphmodule_Graph_is_matching, METH_VARARGS | METH_KEYWORDS, "_is_matching(matching, types=None)\n--\n\n" "Internal function, undocumented.\n\n" }, {"_is_maximal_matching", (PyCFunction)igraphmodule_Graph_is_maximal_matching, METH_VARARGS | METH_KEYWORDS, "_is_maximal_matching(matching, types=None)\n--\n\n" "Internal function, undocumented.\n\n" "Use L{igraph.Matching.is_maximal} instead.\n" }, {"_maximum_bipartite_matching", (PyCFunction)igraphmodule_Graph_maximum_bipartite_matching, METH_VARARGS | METH_KEYWORDS, "_maximum_bipartite_matching(types, weights=None)\n--\n\n" "Internal function, undocumented.\n\n" "@see: L{igraph.Graph.maximum_bipartite_matching}\n" }, /****************/ /* RANDOM WALKS */ /****************/ {"random_walk", (PyCFunction)igraphmodule_Graph_random_walk, METH_VARARGS | METH_KEYWORDS, "random_walk(start, steps, mode=\"out\", stuck=\"return\")\n--\n\n" "Performs a random walk of a given length from a given node.\n\n" "@param start: the starting vertex of the walk\n" "@param steps: the number of steps that the random walk should take\n" "@param mode: whether to follow outbound edges only (C{\"out\"}),\n" " inbound edges only (C{\"in\"}) or both (C{\"all\"}). Ignored for undirected\n" " graphs." "@param stuck: what to do when the random walk gets stuck. C{\"return\"}\n" " returns a partial random walk; C{\"error\"} throws an exception.\n" "@return: a random walk that starts from the given vertex and has at most\n" " the given length (shorter if the random walk got stuck)\n" }, /**********************/ /* INTERNAL FUNCTIONS */ /**********************/ {"__graph_as_capsule", (PyCFunction) igraphmodule_Graph___graph_as_capsule__, METH_VARARGS | METH_KEYWORDS, "__graph_as_capsule()\n\n" "Returns the igraph graph encapsulated by the Python object as\n" "a PyCapsule\n\n." "A PyCapsule is practically a regular C pointer, wrapped in a\n" "Python object. This function should not be used directly by igraph\n" "users, it is useful only in the case when the underlying igraph object\n" "must be passed to other C code through Python.\n\n"}, {"_raw_pointer", (PyCFunction) igraphmodule_Graph__raw_pointer, METH_NOARGS, "_raw_pointer()\n--\n\n" "Returns the memory address of the igraph graph encapsulated by the Python\n" "object as an ordinary Python integer.\n\n" "This function should not be used directly by igraph users, it is useful\n" "only if you want to access some unwrapped function in the C core of igraph\n" "using the ctypes module.\n\n"}, {"__register_destructor", (PyCFunction) igraphmodule_Graph___register_destructor__, METH_VARARGS | METH_KEYWORDS, "__register_destructor(destructor)\n--\n\n" "Registers a destructor to be called when the object is freed by\n" "Python. This function should not be used directly by igraph users."}, {NULL} }; /** \ingroup python_interface_graph * This structure is the collection of functions necessary to implement * the graph as a mapping (i.e. to allow the retrieval and setting of * igraph attributes in Python as if it were of a Python mapping type) */ PyMappingMethods igraphmodule_Graph_as_mapping = { /* __len__ function intentionally left unimplemented */ 0, /* returns an attribute by name or returns part of the adjacency matrix */ (binaryfunc) igraphmodule_Graph_mp_subscript, /* sets an attribute by name or sets part of the adjacency matrix */ (objobjargproc) igraphmodule_Graph_mp_assign_subscript }; /** \ingroup python_interface * \brief Collection of methods to allow numeric operators to be used on the graph */ PyNumberMethods igraphmodule_Graph_as_number = { 0, /* nb_add */ 0, /*nb_subtract */ 0, /*nb_multiply */ 0, /*nb_remainder */ 0, /*nb_divmod */ 0, /*nb_power */ 0, /*nb_negative */ 0, /*nb_positive */ 0, /*nb_absolute */ 0, /*nb_nonzero (2.x) / nb_bool (3.x) */ (unaryfunc) igraphmodule_Graph_complementer_op, /*nb_invert */ 0, /*nb_lshift */ 0, /*nb_rshift */ 0, /*nb_and */ 0, /*nb_xor */ 0, /*nb_or */ 0, /*nb_int */ 0, /*nb_long (2.x) / nb_reserved (3.x)*/ 0, /*nb_float */ 0, /*nb_inplace_add */ 0, /*nb_inplace_subtract */ 0, /*nb_inplace_multiply */ 0, /*nb_inplace_remainder */ 0, /*nb_inplace_power */ 0, /*nb_inplace_lshift */ 0, /*nb_inplace_rshift */ 0, /*nb_inplace_and */ 0, /*nb_inplace_xor */ 0, /*nb_inplace_or */ 0, /*nb_floor_divide */ 0, /*nb_true_divide */ 0, /*nb_inplace_floor_divide */ 0, /*nb_inplace_true_divide */ 0, /*nb_index */ }; /** \ingroup python_interface_graph * Python type object referencing the methods Python calls when it performs various operations on an igraph (creating, printing and so on) */ PyTypeObject igraphmodule_GraphType = { PyVarObject_HEAD_INIT(0, 0) "igraph._igraph.GraphBase", /* tp_name */ sizeof(igraphmodule_GraphObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) igraphmodule_Graph_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare (2.x) / tp_reserved (3.x) */ 0, /* tp_repr */ &igraphmodule_Graph_as_number, /* tp_as_number */ 0, /* tp_as_sequence */ &igraphmodule_Graph_as_mapping, /* tp_as_mapping */ #ifndef PYPY_VERSION (hashfunc) PyObject_HashNotImplemented, /* tp_hash */ #else /* PyObject_HashNotImplemented raises an exception but it is not handled * properly by PyPy so we don't use it */ 0, /* tp_hash */ #endif 0, /* tp_call */ (reprfunc) igraphmodule_Graph_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ "Low-level representation of a graph.\n\n" "Don't use it directly, use L{igraph.Graph} instead.\n\n" "@deffield ref: Reference", /* tp_doc */ (traverseproc) igraphmodule_Graph_traverse, /* tp_traverse */ (inquiry) igraphmodule_Graph_clear, /* tp_clear */ 0, /* tp_richcompare */ offsetof(igraphmodule_GraphObject, weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ igraphmodule_Graph_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) igraphmodule_Graph_init, /* tp_init */ 0, /* tp_alloc */ igraphmodule_Graph_new, /* tp_new */ 0, /* tp_free */ }; #undef CREATE_GRAPH ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/graphobject.h0000644000175100001710000004206600000000000020454 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_GRAPHOBJECT_H #define PYTHON_GRAPHOBJECT_H #include "preamble.h" #include #include "structmember.h" #include "common.h" extern PyTypeObject igraphmodule_GraphType; /** * \ingroup python_interface * \brief A structure containing all the fields required to access an igraph from Python */ typedef struct { PyObject_HEAD // The graph object igraph_t g; // Python object to be called upon destruction PyObject* destructor; // Python object representing the sequence of vertices PyObject* vseq; // Python object representing the sequence of edges PyObject* eseq; // Python object of the weak reference list PyObject* weakreflist; } igraphmodule_GraphObject; void igraphmodule_Graph_init_internal(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_new(PyTypeObject *type, PyObject *args, PyObject *kwds); int igraphmodule_Graph_clear(igraphmodule_GraphObject *self); int igraphmodule_Graph_traverse(igraphmodule_GraphObject *self, visitproc visit, void *arg); void igraphmodule_Graph_dealloc(igraphmodule_GraphObject* self); int igraphmodule_Graph_init(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_subclass_from_igraph_t(PyTypeObject* type, igraph_t *graph); PyObject* igraphmodule_Graph_from_igraph_t(igraph_t *graph); PyObject* igraphmodule_Graph_str(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_vcount(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_ecount(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_is_dag(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_is_directed(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_is_simple(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_add_vertices(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_delete_vertices(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_add_edges(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_delete_edges(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_degree(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_is_loop(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_count_multiple(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_neighbors(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_successors(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_predecessors(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_get_eid(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Adjacency(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Asymmetric_Preference(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Atlas(PyTypeObject *type, PyObject *args); PyObject* igraphmodule_Graph_Barabasi(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Degree_Sequence(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Establishment(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Erdos_Renyi(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Famous(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Forest_Fire(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Full_Citation(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Full(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_GRG(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Growing_Random(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Isoclass(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Lattice(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_LCF(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Realize_Degree_Sequence(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Preference(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Recent_Degree(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Ring(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_SBM(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Star(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Tree(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Tree_Game(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Watts_Strogatz(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_is_connected(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_are_connected(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_adjacency_spectral_embedding(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_articulation_points(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_average_path_length(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_betweenness(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_bibcoupling(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_closeness(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_clusters(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_cocitation(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_constraint(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_copy(igraphmodule_GraphObject *self); PyObject* igraphmodule_Graph_decompose(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_density(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_diameter(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_edge_betweenness(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_eigen_adjacency(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_get_shortest_paths(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_get_all_shortest_paths(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_maxdegree(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_pagerank(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_path_length_hist(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_reciprocity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_rewire(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_shortest_paths(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_spanning_tree(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_simplify(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_subcomponent(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_subgraph(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_transitivity_undirected(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_transitivity_local_undirected(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_scan1(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_circle(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_sphere(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_random(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_random_3d(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_kamada_kawai(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_kamada_kawai_3d(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_drl(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_fruchterman_reingold(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_fruchterman_reingold_3d(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_lgl(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_layout_reingold_tilford(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_get_adjacency(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_get_edgelist(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_to_undirected(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_to_directed(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_laplacian(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_DIMACS(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_Edgelist(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_GML(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_Ncol(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_Lgl(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_Pajek(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_Read_GraphML(PyTypeObject *type, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_dimacs(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_dot(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_edgelist(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_ncol(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_lgl(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_gml(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_write_graphml(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_isoclass(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_isomorphic(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_count_isomorphisms(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_get_isomorphisms(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_subisomorphic(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_count_subisomorphisms(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_get_subisomorphisms(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); Py_ssize_t igraphmodule_Graph_attribute_count(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_get_attribute(igraphmodule_GraphObject* self, PyObject* s); int igraphmodule_Graph_set_attribute(igraphmodule_GraphObject* self, PyObject* k, PyObject* v); PyObject* igraphmodule_Graph_attributes(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_vertex_attributes(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_edge_attributes(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_get_vertices(igraphmodule_GraphObject* self, void* closure); PyObject* igraphmodule_Graph_get_edges(igraphmodule_GraphObject* self, void* closure); PyObject* igraphmodule_Graph_complementer(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_complementer_op(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_compose(igraphmodule_GraphObject* self, PyObject* other); PyObject* igraphmodule_Graph_difference(igraphmodule_GraphObject* self, PyObject* other); PyObject* igraphmodule_Graph_disjoint_union(igraphmodule_GraphObject* self, PyObject* other); PyObject* igraphmodule_Graph_bfs(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_bfsiter(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_maxflow(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_maxflow_value(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_mincut(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_mincut_value(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_cliques(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_maximal_cliques(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_largest_cliques(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_clique_number(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_independent_sets(igraphmodule_GraphObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule_Graph_maximal_independent_sets(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_largest_independent_sets(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_independence_number(igraphmodule_GraphObject* self); PyObject* igraphmodule_Graph_community_edge_betweenness(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_community_fastgreedy(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject *igraphmodule_Graph_community_infomap(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_community_label_propagation(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_community_leading_eigenvector(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject *igraphmodule_Graph_community_multilevel(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject *igraphmodule_Graph_community_optimal_modularity(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_community_spinglass(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_community_walktrap(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_modularity(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph_leiden(igraphmodule_GraphObject* self, PyObject *args, PyObject *kwds); PyObject *igraphmodule_Graph_is_bipartite(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph___graph_as_cobject__(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); PyObject* igraphmodule_Graph___register_destructor__(igraphmodule_GraphObject *self, PyObject *args, PyObject *kwds); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/igraphmodule.c0000644000175100001710000010172400000000000020634 0ustar00runnerdocker00000000000000/* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "preamble.h" #include #include "arpackobject.h" #include "attributes.h" #include "bfsiter.h" #include "dfsiter.h" #include "common.h" #include "convert.h" #include "edgeobject.h" #include "edgeseqobject.h" #include "error.h" #include "graphobject.h" #include "random.h" #include "vertexobject.h" #include "vertexseqobject.h" #include "operators.h" #define IGRAPH_MODULE #include "igraphmodule_api.h" /** * \defgroup python_interface Python module implementation * \brief Functions implementing a Python interface to \a igraph * * These functions provide a way to access \a igraph functions from Python. * It should be of interest of \a igraph developers only. Classes, functions * and methods exposed to Python are still to be documented. Until it is done, * just type the following to get help about \a igraph functions in Python * (assuming you have \c igraph.so somewhere in your Python library path): * * \verbatim import igraph help(igraph) help(igraph.Graph) \endverbatim * * Most of the functions provided here share the same calling conventions * (which are determined by the Python/C API). Since the role of the * arguments are the same across many functions, I won't explain them * everywhere, just give a quick overview of the common argument names here. * * \param self the Python igraph.Graph object the method is working on * \param args pointer to the Python tuple containing the arguments * \param kwds pointer to the Python hash containing the keyword parameters * \param type the type object of a Python igraph.Graph object. Used usually * in constructors and class methods. * * Any arguments not documented here should be mentioned at the documentation * of the appropriate method. * * The functions which implement a Python method always return a pointer to * a \c PyObject. According to Python conventions, this is \c NULL if and * only if an exception was thrown by the method (or any of the functions * it has called). When I explain the return value of a function which * provides interface to an \a igraph function, I won't cover the case of * returning a \c NULL value, because this is the same for every such method. * The conclusion is that a method can return \c NULL even if I don't state * it explicitly. * * Also please take into consideration that I'm documenting the C calls * with the abovementioned parameters here, and \em not the Python methods * which are presented to the user using the Python interface of \a igraph. * If you are looking for the documentation of the classes, methods and * functions exposed to Python, please use the \c help calls from Python * or use \c pydoc to generate a formatted version. * * \section weakrefs The usage of weak references in the Python interface * * Many classes implemented in the Python interface (e.g. VertexSeq, Vertex...) * use weak references to keep track of the graph they are referencing to. * The use of weak references is twofold: * * -# If we assign a VertexSeq or a Vertex of a given graph to a local * variable and then destroy the graph, real references keep the graph * alive and do not return the memory back to Python. * -# If we use real references, a Graph object will hold a reference * to its VertexSeq (because we don't want to allocate a new VertexSeq * object for the same graph every time it is requested), and the * VertexSeq will also hold a reference to the Graph. This is a circular * reference. Python does not reclaim the memory occupied by the Graph * back when the Graph is destroyed, because the VertexSeq is holding a * reference to it. Similarly, VertexSeq doesn't get freed because the * Graph is holding a reference to it. These situations can only be * resolved by the Python garbage collector which is invoked at regular * intervals. Unfortunately, the garbage collector refuses to break * circular references and free the objects participating in the circle * when any of the objects has a \c __del__ method. In this case, * \c igraph.Graph has one (which frees the underlying \c igraph_t * graph), therefore our graphs never get freed when we use real * references. */ /** * Whether the module was initialized already */ static igraph_bool_t igraphmodule_initialized = 0; /** * Module-specific global variables */ struct module_state { PyObject* progress_handler; PyObject* status_handler; }; static struct module_state _state = { 0, 0 }; #define GETSTATE(m) (&_state) static int igraphmodule_traverse(PyObject *m, visitproc visit, void* arg) { Py_VISIT(GETSTATE(m)->progress_handler); Py_VISIT(GETSTATE(m)->status_handler); return 0; } static int igraphmodule_clear(PyObject *m) { Py_CLEAR(GETSTATE(m)->progress_handler); Py_CLEAR(GETSTATE(m)->status_handler); return 0; } static int igraphmodule_igraph_interrupt_hook(void* data) { if (PyErr_CheckSignals()) { IGRAPH_FINALLY_FREE(); return IGRAPH_INTERRUPTED; } return IGRAPH_SUCCESS; } int igraphmodule_igraph_progress_hook(const char* message, igraph_real_t percent, void* data) { PyObject* progress_handler = GETSTATE(0)->progress_handler; if (progress_handler) { PyObject *result; if (PyCallable_Check(progress_handler)) { result=PyObject_CallFunction(progress_handler, "sd", message, (double)percent); if (result) Py_DECREF(result); else return IGRAPH_INTERRUPTED; } } return IGRAPH_SUCCESS; } int igraphmodule_igraph_status_hook(const char* message, void*data) { PyObject* status_handler = GETSTATE(0)->status_handler; if (status_handler) { PyObject *result; if (PyCallable_Check(status_handler)) { result = PyObject_CallFunction(status_handler, "s", message); if (result) Py_DECREF(result); else return IGRAPH_INTERRUPTED; } } return IGRAPH_SUCCESS; } PyObject* igraphmodule_set_progress_handler(PyObject* self, PyObject* o) { PyObject* progress_handler; if (!PyCallable_Check(o) && o != Py_None) { PyErr_SetString(PyExc_TypeError, "Progress handler must be callable."); return NULL; } progress_handler = GETSTATE(self)->progress_handler; if (o == progress_handler) Py_RETURN_NONE; Py_XDECREF(progress_handler); if (o == Py_None) o = 0; Py_XINCREF(o); GETSTATE(self)->progress_handler=o; Py_RETURN_NONE; } PyObject* igraphmodule_set_status_handler(PyObject* self, PyObject* o) { PyObject* status_handler; if (!PyCallable_Check(o) && o != Py_None) { PyErr_SetString(PyExc_TypeError, "Status handler must be callable."); return NULL; } status_handler = GETSTATE(self)->status_handler; if (o == status_handler) Py_RETURN_NONE; Py_XDECREF(status_handler); if (o == Py_None) o = 0; Py_INCREF(o); GETSTATE(self)->status_handler = o; Py_RETURN_NONE; } PyObject* igraphmodule_convex_hull(PyObject* self, PyObject* args, PyObject* kwds) { static char* kwlist[] = {"vs", "coords", NULL}; PyObject *vs, *o, *o1=0, *o2=0, *coords = Py_False; igraph_matrix_t mtrx; igraph_vector_t result; igraph_matrix_t resmat; long no_of_nodes, i; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist, &PyList_Type, &vs, &coords)) return NULL; no_of_nodes=PyList_Size(vs); if (igraph_matrix_init(&mtrx, no_of_nodes, 2)) { igraphmodule_handle_igraph_error(); return NULL; } for (i=0; i= 2) { o1=PyList_GetItem(o, 0); o2=PyList_GetItem(o, 1); if (PyList_Size(o) > 2) PyErr_Warn(PyExc_Warning, "vertex with more than 2 coordinates found, considering only the first 2"); } else { PyErr_SetString(PyExc_TypeError, "vertex with less than 2 coordinates found"); igraph_matrix_destroy(&mtrx); return NULL; } } else if (PyTuple_Check(o)) { if (PyTuple_Size(o) >= 2) { o1=PyTuple_GetItem(o, 0); o2=PyTuple_GetItem(o, 1); if (PyTuple_Size(o) > 2) PyErr_Warn(PyExc_Warning, "vertex with more than 2 coordinates found, considering only the first 2"); } else { PyErr_SetString(PyExc_TypeError, "vertex with less than 2 coordinates found"); igraph_matrix_destroy(&mtrx); return NULL; } } if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) { PyErr_SetString(PyExc_TypeError, "vertex coordinates must be numeric"); igraph_matrix_destroy(&mtrx); return NULL; } /* o, o1 and o2 were borrowed, but now o1 and o2 are actual references! */ o1=PyNumber_Float(o1); o2=PyNumber_Float(o2); if (!o1 || !o2) { PyErr_SetString(PyExc_TypeError, "vertex coordinate conversion to float failed"); Py_XDECREF(o1); Py_XDECREF(o2); igraph_matrix_destroy(&mtrx); return NULL; } MATRIX(mtrx, i, 0)=(igraph_real_t)PyFloat_AsDouble(o1); MATRIX(mtrx, i, 1)=(igraph_real_t)PyFloat_AsDouble(o2); Py_DECREF(o1); Py_DECREF(o2); } if (!PyObject_IsTrue(coords)) { if (igraph_vector_init(&result, 0)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&mtrx); return NULL; } if (igraph_convex_hull(&mtrx, &result, 0)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&mtrx); igraph_vector_destroy(&result); return NULL; } o=igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); } else { if (igraph_matrix_init(&resmat, 0, 0)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&mtrx); return NULL; } if (igraph_convex_hull(&mtrx, 0, &resmat)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&mtrx); igraph_matrix_destroy(&resmat); return NULL; } o=igraphmodule_matrix_t_to_PyList(&resmat, IGRAPHMODULE_TYPE_FLOAT); igraph_matrix_destroy(&resmat); } igraph_matrix_destroy(&mtrx); return o; } PyObject* igraphmodule_community_to_membership(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "merges", "nodes", "steps", "return_csize", NULL }; PyObject *merges_o, *return_csize = Py_False, *result_o; igraph_matrix_t merges; igraph_vector_t result, csize, *csize_p = 0; long int nodes, steps; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!ll|O", kwlist, &PyList_Type, &merges_o, &nodes, &steps, &return_csize)) return NULL; if (igraphmodule_PyList_to_matrix_t_with_minimum_column_count(merges_o, &merges, 2)) return NULL; if (igraph_vector_init(&result, nodes)) { igraphmodule_handle_igraph_error(); igraph_matrix_destroy(&merges); return NULL; } if (PyObject_IsTrue(return_csize)) { igraph_vector_init(&csize, 0); csize_p = &csize; } if (igraph_community_to_membership(&merges, (igraph_integer_t)nodes, (igraph_integer_t)steps, &result, csize_p)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&result); if (csize_p) igraph_vector_destroy(csize_p); igraph_matrix_destroy(&merges); return NULL; } igraph_matrix_destroy(&merges); result_o = igraphmodule_vector_t_to_PyList(&result, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&result); if (csize_p) { PyObject* csize_o = igraphmodule_vector_t_to_PyList(csize_p, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(csize_p); if (csize_o) return Py_BuildValue("NN", result_o, csize_o); Py_DECREF(result_o); return NULL; } return result_o; } PyObject* igraphmodule_compare_communities(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "comm1", "comm2", "method", NULL }; PyObject *comm1_o, *comm2_o, *method_o = Py_None; igraph_vector_t comm1, comm2; igraph_community_comparison_t method = IGRAPH_COMMCMP_VI; igraph_real_t result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist, &comm1_o, &comm2_o, &method_o)) return NULL; if (igraphmodule_PyObject_to_community_comparison_t(method_o, &method)) return NULL; if (igraphmodule_PyObject_to_vector_t(comm1_o, &comm1, 0)) return NULL; if (igraphmodule_PyObject_to_vector_t(comm2_o, &comm2, 0)) { igraph_vector_destroy(&comm1); return NULL; } if (igraph_compare_communities(&comm1, &comm2, &result, method)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&comm1); igraph_vector_destroy(&comm2); return NULL; } igraph_vector_destroy(&comm1); igraph_vector_destroy(&comm2); return PyFloat_FromDouble((double)result); } PyObject* igraphmodule_is_degree_sequence(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "out_deg", "in_deg", NULL }; PyObject *out_deg_o = 0, *in_deg_o = 0; igraph_vector_t out_deg, in_deg; igraph_bool_t is_directed, result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &out_deg_o, &in_deg_o)) return NULL; is_directed = (in_deg_o != 0 && in_deg_o != Py_None); if (igraphmodule_PyObject_to_vector_t(out_deg_o, &out_deg, 0)) return NULL; if (is_directed && igraphmodule_PyObject_to_vector_t(in_deg_o, &in_deg, 0)) { igraph_vector_destroy(&out_deg); return NULL; } if (igraph_is_graphical(&out_deg, is_directed ? &in_deg : 0, IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&out_deg); if (is_directed) igraph_vector_destroy(&in_deg); return NULL; } igraph_vector_destroy(&out_deg); if (is_directed) igraph_vector_destroy(&in_deg); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } PyObject* igraphmodule_is_graphical_degree_sequence(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "out_deg", "in_deg", NULL }; PyObject *out_deg_o = 0, *in_deg_o = 0; igraph_vector_t out_deg, in_deg; igraph_bool_t is_directed, result; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &out_deg_o, &in_deg_o)) return NULL; is_directed = (in_deg_o != 0 && in_deg_o != Py_None); if (igraphmodule_PyObject_to_vector_t(out_deg_o, &out_deg, 0)) return NULL; if (is_directed && igraphmodule_PyObject_to_vector_t(in_deg_o, &in_deg, 0)) { igraph_vector_destroy(&out_deg); return NULL; } if (igraph_is_graphical(&out_deg, is_directed ? &in_deg : 0, IGRAPH_SIMPLE_SW, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&out_deg); if (is_directed) igraph_vector_destroy(&in_deg); return NULL; } igraph_vector_destroy(&out_deg); if (is_directed) igraph_vector_destroy(&in_deg); if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } PyObject* igraphmodule_is_graphical(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "out_deg", "in_deg", "loops", "multiple", NULL }; PyObject *out_deg_o = 0, *in_deg_o = 0; PyObject *loops = Py_False, *multiple = Py_False; igraph_vector_t out_deg, in_deg; igraph_bool_t is_directed, result; int allowed_edge_types; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOO", kwlist, &out_deg_o, &in_deg_o, &loops, &multiple)) return NULL; is_directed = (in_deg_o != 0 && in_deg_o != Py_None); if (igraphmodule_PyObject_to_vector_t(out_deg_o, &out_deg, 0)) return NULL; if (is_directed && igraphmodule_PyObject_to_vector_t(in_deg_o, &in_deg, 0)) { igraph_vector_destroy(&out_deg); return NULL; } allowed_edge_types = IGRAPH_SIMPLE_SW; if (PyObject_IsTrue(loops)) { allowed_edge_types |= IGRAPH_LOOPS_SW; } if (PyObject_IsTrue(multiple)) { allowed_edge_types |= IGRAPH_MULTI_SW; } if (igraph_is_graphical(&out_deg, is_directed ? &in_deg : 0, allowed_edge_types, &result)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&out_deg); if (is_directed) { igraph_vector_destroy(&in_deg); } return NULL; } igraph_vector_destroy(&out_deg); if (is_directed) { igraph_vector_destroy(&in_deg); } if (result) Py_RETURN_TRUE; else Py_RETURN_FALSE; } PyObject* igraphmodule_power_law_fit(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "data", "xmin", "force_continuous", NULL }; PyObject *data_o, *force_continuous_o = Py_False; igraph_vector_t data; igraph_plfit_result_t result; double xmin = -1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|dO", kwlist, &data_o, &xmin, &force_continuous_o)) return NULL; if (igraphmodule_PyObject_float_to_vector_t(data_o, &data)) return NULL; if (igraph_power_law_fit(&data, &result, xmin, PyObject_IsTrue(force_continuous_o))) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&data); return NULL; } igraph_vector_destroy(&data); return Py_BuildValue("Oddddd", result.continuous ? Py_True : Py_False, result.alpha, result.xmin, result.L, result.D, result.p); } PyObject* igraphmodule_split_join_distance(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "comm1", "comm2", NULL }; PyObject *comm1_o, *comm2_o; igraph_vector_t comm1, comm2; igraph_integer_t distance12, distance21; if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &comm1_o, &comm2_o)) return NULL; if (igraphmodule_PyObject_to_vector_t(comm1_o, &comm1, 0)) return NULL; if (igraphmodule_PyObject_to_vector_t(comm2_o, &comm2, 0)) { igraph_vector_destroy(&comm1); return NULL; } if (igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&comm1); igraph_vector_destroy(&comm2); return NULL; } igraph_vector_destroy(&comm1); igraph_vector_destroy(&comm2); return Py_BuildValue("ll", (long)distance12, (long)distance21); } /** \ingroup python_interface * \brief Method table for the igraph Python module */ static PyMethodDef igraphmodule_methods[] = { {"community_to_membership", (PyCFunction)igraphmodule_community_to_membership, METH_VARARGS | METH_KEYWORDS, "community_to_membership(merges, nodes, steps, return_csize=False)\n--\n\n" }, {"_compare_communities", (PyCFunction)igraphmodule_compare_communities, METH_VARARGS | METH_KEYWORDS, "_compare_communities(comm1, comm2, method=\"vi\")\n--\n\n" }, {"_power_law_fit", (PyCFunction)igraphmodule_power_law_fit, METH_VARARGS | METH_KEYWORDS, "_power_law_fit(data, xmin=-1, force_continuous=False)\n--\n\n" }, {"convex_hull", (PyCFunction)igraphmodule_convex_hull, METH_VARARGS | METH_KEYWORDS, "convex_hull(vs, coords=False)\n--\n\n" "Calculates the convex hull of a given point set.\n\n" "@param vs: the point set as a list of lists\n" "@param coords: if C{True}, the function returns the\n" " coordinates of the corners of the convex hull polygon,\n" " otherwise returns the corner indices.\n" "@return: either the hull's corner coordinates or the point\n" " indices corresponding to them, depending on the C{coords}\n" " parameter." }, {"is_degree_sequence", (PyCFunction)igraphmodule_is_degree_sequence, METH_VARARGS | METH_KEYWORDS, "is_degree_sequence(out_deg, in_deg=None)\n--\n\n" "Deprecated since 0.9 in favour of L{is_graphical()}.\n\n" "Returns whether a list of degrees can be a degree sequence of some graph.\n\n" "Note that it is not required for the graph to be simple; in other words,\n" "this function may return C{True} for degree sequences that can be realized\n" "using one or more multiple or loop edges only.\n\n" "In particular, this function checks whether\n\n" " - all the degrees are non-negative\n" " - for undirected graphs, the sum of degrees are even\n" " - for directed graphs, the two degree sequences are of the same length and\n" " equal sums\n\n" "@param out_deg: the list of degrees. For directed graphs, this list must\n" " contain the out-degrees of the vertices.\n" "@param in_deg: the list of in-degrees for directed graphs. This parameter\n" " must be C{None} for undirected graphs.\n" "@return: C{True} if there exists some graph that can realize the given degree\n" " sequence, C{False} otherwise.\n" }, {"is_graphical", (PyCFunction)igraphmodule_is_graphical, METH_VARARGS | METH_KEYWORDS, "is_graphical(out_deg, in_deg=None, loops=False, multiple=False)\n--\n\n" "Returns whether a list of degrees can be a degree sequence of some graph,\n" "with or without multiple and loop edges, depending on the allowed edge types\n" "in the remaining arguments.\n\n" "@param out_deg: the list of degrees. For directed graphs, this list must\n" " contain the out-degrees of the vertices.\n" "@param in_deg: the list of in-degrees for directed graphs. This parameter\n" " must be C{None} for undirected graphs.\n" "@param loops: whether loop edges are allowed.\n" "@param multiple: whether multiple edges are allowed.\n" "@return: C{True} if there exists some graph that can realize the given\n" " degree sequence with the given edge types, C{False} otherwise.\n" }, {"is_graphical_degree_sequence", (PyCFunction)igraphmodule_is_graphical_degree_sequence, METH_VARARGS | METH_KEYWORDS, "is_graphical_degree_sequence(out_deg, in_deg=None)\n--\n\n" "Deprecated since 0.9 in favour of L{is_graphical()}.\n\n" "Returns whether a list of degrees can be a degree sequence of some simple graph.\n\n" "Note that it is required for the graph to be simple; in other words,\n" "this function will return C{False} for degree sequences that cannot be realized\n" "without using one or more multiple or loop edges.\n\n" "@param out_deg: the list of degrees. For directed graphs, this list must\n" " contain the out-degrees of the vertices.\n" "@param in_deg: the list of in-degrees for directed graphs. This parameter\n" " must be C{None} for undirected graphs.\n" "@return: C{True} if there exists some simple graph that can realize the given\n" " degree sequence, C{False} otherwise.\n" }, {"set_progress_handler", igraphmodule_set_progress_handler, METH_O, "set_progress_handler(handler)\n--\n\n" "Sets the handler to be called when igraph is performing a long operation.\n" "@param handler: the progress handler function. It must accept two\n" " arguments, the first is the message informing the user about\n" " what igraph is doing right now, the second is the actual\n" " progress information (a percentage).\n" }, {"set_random_number_generator", igraph_rng_Python_set_generator, METH_O, "set_random_number_generator(generator)\n--\n\n" "Sets the random number generator used by igraph.\n" "@param generator: the generator to be used. It must be a Python object\n" " with at least three attributes: C{random}, C{randint} and C{gauss}.\n" " Each of them must be callable and their signature and behaviour\n" " must be identical to C{random.random}, C{random.randint} and\n" " C{random.gauss}. By default, igraph uses the C{random} module for\n" " random number generation, but you can supply your alternative\n" " implementation here. If the given generator is C{None}, igraph\n" " reverts to the default Mersenne twister generator implemented in the\n" " C layer, which might be slightly faster than calling back to Python\n" " for random numbers, but you cannot set its seed or save its state.\n" }, {"set_status_handler", igraphmodule_set_status_handler, METH_O, "set_status_handler(handler)\n--\n\n" "Sets the handler to be called when igraph tries to display a status\n" "message.\n\n" "This is used to communicate the progress of some calculations where\n" "no reasonable progress percentage can be given (so it is not possible\n" "to use the progress handler).\n\n" "@param handler: the status handler function. It must accept a single\n" " argument, the message that informs the user about what igraph is\n" " doing right now.\n" }, {"_split_join_distance", (PyCFunction)igraphmodule_split_join_distance, METH_VARARGS | METH_KEYWORDS, "_split_join_distance(comm1, comm2)\n--\n\n" }, {"_disjoint_union", (PyCFunction)igraphmodule__disjoint_union, METH_VARARGS | METH_KEYWORDS, "_disjoint_union(graphs)\n--\n\n" }, {"_union", (PyCFunction)igraphmodule__union, METH_VARARGS | METH_KEYWORDS, "_union(graphs, edgemaps)\n--\n\n" }, {"_intersection", (PyCFunction)igraphmodule__intersection, METH_VARARGS | METH_KEYWORDS, "_intersection(graphs, edgemaps)\n--\n\n" }, {NULL, NULL, 0, NULL} }; #define MODULE_DOCS \ "Low-level Python interface for the igraph library. " \ "Should not be used directly.\n" /** * Module definition table */ static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "igraph._igraph", /* m_name */ MODULE_DOCS, /* m_doc */ sizeof(struct module_state), /* m_size */ igraphmodule_methods, /* m_methods */ 0, /* m_reload */ igraphmodule_traverse, /* m_traverse */ igraphmodule_clear, /* m_clear */ 0 /* m_free */ }; /****************** Exported API functions *******************/ /** * \brief Constructs a new Python Graph object from an existing igraph_t * * The newly created Graph object will take ownership of igraph_t and * it will destroy it when the Python object is destructed. * * Returns a null pointer in case of an error and sets the appropriate * Python exception. */ PyObject* PyIGraph_FromCGraph(igraph_t* g) { return igraphmodule_Graph_from_igraph_t(g); } /** * \brief Extracts the pointer to the \c igraph_t held by a Graph instance * * The ownership of the \c igraph_t object remains with the Graph instance, * so make sure you don't call \c igraph_destroy() on the extracted pointer. * * Returns a null pointer in case of an error and sets the appropriate * Python exception. */ igraph_t* PyIGraph_ToCGraph(PyObject* graph) { igraph_t *result = 0; if (graph == Py_None) { PyErr_SetString(PyExc_TypeError, "expected Graph, got None"); return 0; } if (igraphmodule_PyObject_to_igraph_t(graph, &result)) return 0; if (result == 0) PyErr_SetString(PyExc_ValueError, "null pointer stored inside a Graph " "object. Probably a bug."); return result; } extern PyObject* igraphmodule_InternalError; extern PyObject* igraphmodule_arpack_options_default; #define INITERROR return NULL PyObject* PyInit__igraph(void) { PyObject* m; static void *PyIGraph_API[PyIGraph_API_pointers]; PyObject *c_api_object; /* Check if the module is already initialized (possibly in another Python * interpreter. If so, bail out as we don't support this. */ if (igraphmodule_initialized) { PyErr_SetString(PyExc_RuntimeError, "igraph module is already initialized " "in a different Python interpreter"); INITERROR; } /* Initialize VertexSeq, EdgeSeq */ if (PyType_Ready(&igraphmodule_VertexSeqType) < 0) INITERROR; if (PyType_Ready(&igraphmodule_EdgeSeqType) < 0) INITERROR; /* Initialize Vertex, Edge */ igraphmodule_VertexType.tp_clear = (inquiry)igraphmodule_Vertex_clear; if (PyType_Ready(&igraphmodule_VertexType) < 0) INITERROR; igraphmodule_EdgeType.tp_clear = (inquiry)igraphmodule_Edge_clear; if (PyType_Ready(&igraphmodule_EdgeType) < 0) INITERROR; /* Initialize Graph, BFSIter, ARPACKOptions etc */ if (igraphmodule_ARPACKOptions_register_type()) INITERROR; if (PyType_Ready(&igraphmodule_GraphType) < 0) INITERROR; if (PyType_Ready(&igraphmodule_BFSIterType) < 0) INITERROR; if (PyType_Ready(&igraphmodule_DFSIterType) < 0) INITERROR; /* Initialize the core module */ m = PyModule_Create(&moduledef); if (m == NULL) INITERROR; /* Initialize random number generator */ igraphmodule_init_rng(m); /* Add the types to the core module */ PyModule_AddObject(m, "GraphBase", (PyObject*)&igraphmodule_GraphType); PyModule_AddObject(m, "BFSIter", (PyObject*)&igraphmodule_BFSIterType); PyModule_AddObject(m, "DFSIter", (PyObject*)&igraphmodule_DFSIterType); PyModule_AddObject(m, "ARPACKOptions", (PyObject*)igraphmodule_ARPACKOptionsType); PyModule_AddObject(m, "Edge", (PyObject*)&igraphmodule_EdgeType); PyModule_AddObject(m, "EdgeSeq", (PyObject*)&igraphmodule_EdgeSeqType); PyModule_AddObject(m, "Vertex", (PyObject*)&igraphmodule_VertexType); PyModule_AddObject(m, "VertexSeq", (PyObject*)&igraphmodule_VertexSeqType); /* Internal error exception type */ igraphmodule_InternalError = PyErr_NewException("igraph._igraph.InternalError", PyExc_Exception, NULL); PyModule_AddObject(m, "InternalError", igraphmodule_InternalError); /* ARPACK default options variable */ igraphmodule_arpack_options_default = igraphmodule_ARPACKOptions_new(); PyModule_AddObject(m, "arpack_options", igraphmodule_arpack_options_default); /* Useful constants */ PyModule_AddIntConstant(m, "OUT", IGRAPH_OUT); PyModule_AddIntConstant(m, "IN", IGRAPH_IN); PyModule_AddIntConstant(m, "ALL", IGRAPH_ALL); PyModule_AddIntConstant(m, "STAR_OUT", IGRAPH_STAR_OUT); PyModule_AddIntConstant(m, "STAR_IN", IGRAPH_STAR_IN); PyModule_AddIntConstant(m, "STAR_MUTUAL", IGRAPH_STAR_MUTUAL); PyModule_AddIntConstant(m, "STAR_UNDIRECTED", IGRAPH_STAR_UNDIRECTED); PyModule_AddIntConstant(m, "TREE_OUT", IGRAPH_TREE_OUT); PyModule_AddIntConstant(m, "TREE_IN", IGRAPH_TREE_IN); PyModule_AddIntConstant(m, "TREE_UNDIRECTED", IGRAPH_TREE_UNDIRECTED); PyModule_AddIntConstant(m, "STRONG", IGRAPH_STRONG); PyModule_AddIntConstant(m, "WEAK", IGRAPH_WEAK); PyModule_AddIntConstant(m, "GET_ADJACENCY_UPPER", IGRAPH_GET_ADJACENCY_UPPER); PyModule_AddIntConstant(m, "GET_ADJACENCY_LOWER", IGRAPH_GET_ADJACENCY_LOWER); PyModule_AddIntConstant(m, "GET_ADJACENCY_BOTH", IGRAPH_GET_ADJACENCY_BOTH); PyModule_AddIntConstant(m, "REWIRING_SIMPLE", IGRAPH_REWIRING_SIMPLE); PyModule_AddIntConstant(m, "REWIRING_SIMPLE_LOOPS", IGRAPH_REWIRING_SIMPLE_LOOPS); PyModule_AddIntConstant(m, "ADJ_DIRECTED", IGRAPH_ADJ_DIRECTED); PyModule_AddIntConstant(m, "ADJ_UNDIRECTED", IGRAPH_ADJ_UNDIRECTED); PyModule_AddIntConstant(m, "ADJ_MAX", IGRAPH_ADJ_MAX); PyModule_AddIntConstant(m, "ADJ_MIN", IGRAPH_ADJ_MIN); PyModule_AddIntConstant(m, "ADJ_PLUS", IGRAPH_ADJ_PLUS); PyModule_AddIntConstant(m, "ADJ_UPPER", IGRAPH_ADJ_UPPER); PyModule_AddIntConstant(m, "ADJ_LOWER", IGRAPH_ADJ_LOWER); PyModule_AddIntConstant(m, "BLISS_F", IGRAPH_BLISS_F); PyModule_AddIntConstant(m, "BLISS_FL", IGRAPH_BLISS_FL); PyModule_AddIntConstant(m, "BLISS_FS", IGRAPH_BLISS_FS); PyModule_AddIntConstant(m, "BLISS_FM", IGRAPH_BLISS_FM); PyModule_AddIntConstant(m, "BLISS_FLM", IGRAPH_BLISS_FLM); PyModule_AddIntConstant(m, "BLISS_FSM", IGRAPH_BLISS_FSM); PyModule_AddIntConstant(m, "TRANSITIVITY_NAN", IGRAPH_TRANSITIVITY_NAN); PyModule_AddIntConstant(m, "TRANSITIVITY_ZERO", IGRAPH_TRANSITIVITY_ZERO); PyModule_AddIntConstant(m, "SIMPLE_SW", IGRAPH_SIMPLE_SW); PyModule_AddIntConstant(m, "LOOPS_SW", IGRAPH_LOOPS_SW); PyModule_AddIntConstant(m, "MULTI_SW", IGRAPH_MULTI_SW); /* More useful constants */ { const char* version; igraph_version(&version, 0, 0, 0); PyModule_AddStringConstant(m, "__igraph_version__", version); } PyModule_AddStringConstant(m, "__build_date__", __DATE__); /* initialize error, progress, warning and interruption handler */ igraph_set_error_handler(igraphmodule_igraph_error_hook); igraph_set_progress_handler(igraphmodule_igraph_progress_hook); igraph_set_status_handler(igraphmodule_igraph_status_hook); igraph_set_warning_handler(igraphmodule_igraph_warning_hook); igraph_set_interruption_handler(igraphmodule_igraph_interrupt_hook); /* initialize attribute handlers */ igraphmodule_initialize_attribute_handler(); /* Initialize the C API pointer array */ PyIGraph_API[PyIGraph_FromCGraph_NUM] = (void *)PyIGraph_FromCGraph; PyIGraph_API[PyIGraph_ToCGraph_NUM] = (void *)PyIGraph_ToCGraph; /* Create a CObject containing the API pointer array's address */ c_api_object = PyCapsule_New((void*)PyIGraph_API, "igraph._igraph._C_API", 0); if (c_api_object != 0) { PyModule_AddObject(m, "_C_API", c_api_object); } igraphmodule_initialized = 1; return m; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/igraphmodule_api.h0000644000175100001710000000500600000000000021466 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef Py_IGRAPHMODULE_H #define Py_IGRAPHMODULE_H #ifdef __cplusplus extern "C" { #endif /* C API functions */ #define PyIGraph_FromCGraph_NUM 0 #define PyIGraph_FromCGraph_RETURN PyObject* #define PyIGraph_FromCGraph_PROTO (igraph_t *graph) #define PyIGraph_ToCGraph_NUM 1 #define PyIGraph_ToCGraph_RETURN igraph_t* #define PyIGraph_ToCGraph_PROTO (PyObject *graph) /* Total number of C API pointers */ #define PyIGraph_API_pointers 2 #ifdef IGRAPH_MODULE /* This section is used when compiling igraphmodule.c */ static PyIGraph_FromCGraph_RETURN PyIGraph_FromCGraph PyIGraph_FromCGraph_PROTO; static PyIGraph_ToCGraph_RETURN PyIGraph_ToCGraph PyIGraph_ToCGraph_PROTO; #else /* This section is used in modules that use igraph's API */ static void** PyIGraph_API; # define PyIGraph_FromCGraph \ (*(PyIGraph_FromCGraph_RETURN (*)PyIGraph_FromCGraph_PROTO) \ PyIGraph_API[PyIGraph_FromCGraph_NUM]) # define PyIGraph_ToCGraph \ (*(PyIGraph_ToCGraph_RETURN (*)PyIGraph_ToCGraph_PROTO) \ PyIGraph_API[PyIGraph_ToCGraph_NUM]) /* Return -1 and set exception on error, 0 on success */ static int import_igraph(void) { PyObject *c_api_object; PyObject *module; module = PyImport_ImportModule("igraph._igraph"); if (module == 0) return -1; c_api_object = PyObject_GetAttrString(module, "_C_API"); if (c_api_object == 0) { Py_DECREF(module); return -1; } if (PyCObject_Check(c_api_object)) PyIGraph_API = (void**)PyCObject_AsVoidPtr(c_api_object); Py_DECREF(c_api_object); Py_DECREF(module); return 0; } #endif #ifdef __cplusplus } #endif #endif /* !defined(Py_IGRAPHMODULE_H) */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/indexing.c0000644000175100001710000004113100000000000017754 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library - Python interface. Copyright (C) 2006-2011 Tamas Nepusz 5 Avenue Road, Staines, Middlesex, TW18 3AW, United Kingdom This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "convert.h" #include "error.h" #include "indexing.h" #include "platform.h" #include "pyhelpers.h" /***************************************************************************/ static PyObject* igraphmodule_i_Graph_adjmatrix_indexing_get_value_for_vertex_pair( igraph_t* graph, igraph_integer_t from, igraph_integer_t to, PyObject* values) { igraph_integer_t eid; PyObject* result; /* Retrieving a single edge */ igraph_get_eid(graph, &eid, from, to, /* directed = */1, /* error = */0); if (eid >= 0) { /* Edge found, get the value of the attribute */ if (values == 0) { return PyLong_FromLong(1L); } else { result = PyList_GetItem(values, eid); Py_XINCREF(result); return result; } } else { /* No such edge, return zero */ return PyLong_FromLong(0L); } } static PyObject* igraphmodule_i_Graph_adjmatrix_get_index_row(igraph_t* graph, igraph_integer_t from, igraph_vs_t* to, igraph_neimode_t neimode, PyObject* values); PyObject* igraphmodule_Graph_adjmatrix_get_index(igraph_t* graph, PyObject* row_index, PyObject* column_index, PyObject* attr_name) { PyObject *result = 0, *values; igraph_vs_t vs1, vs2; igraph_integer_t vid1 = -1, vid2 = -1; char* attr; if (igraphmodule_PyObject_to_vs_t(row_index, &vs1, graph, 0, &vid1)) return NULL; if (igraphmodule_PyObject_to_vs_t(column_index, &vs2, graph, 0, &vid2)) return NULL; if (attr_name == 0) { /* Using the "weight" attribute by default */ values = igraphmodule_get_edge_attribute_values(graph, "weight"); } else { /* Specifying the name of the attribute */ attr = igraphmodule_PyObject_ConvertToCString(attr_name); values = igraphmodule_get_edge_attribute_values(graph, attr); free(attr); } if (vid1 >= 0 && vid2 >= 0) { /* Retrieving an edge between vid1 and vid2 */ result = igraphmodule_i_Graph_adjmatrix_indexing_get_value_for_vertex_pair( graph, vid1, vid2, values); } else if (vid1 >= 0) { /* Retrieving the successors of vid1 */ result = igraphmodule_i_Graph_adjmatrix_get_index_row( graph, vid1, &vs2, IGRAPH_OUT, values); } else if (vid2 >= 0) { /* Retrieving the predecessors of vid2 */ result = igraphmodule_i_Graph_adjmatrix_get_index_row( graph, vid2, &vs1, IGRAPH_IN, values); } else { /* Retrieving a submatrix */ igraph_vit_t vit; PyObject *item; if (igraph_vit_create(graph, vs1, &vit)) { igraphmodule_handle_igraph_error(); result = 0; } else { result = PyList_New(0); if (result != 0) { while (!IGRAPH_VIT_END(vit)) { vid1 = IGRAPH_VIT_GET(vit); item = igraphmodule_i_Graph_adjmatrix_get_index_row(graph, vid1, &vs2, IGRAPH_OUT, values); if (item == 0) { Py_DECREF(result); result = 0; break; } if (PyList_Append(result, item)) { /* error while appending */ Py_DECREF(item); Py_DECREF(result); result = 0; break; } Py_DECREF(item); IGRAPH_VIT_NEXT(vit); } } igraph_vit_destroy(&vit); } } igraph_vs_destroy(&vs1); igraph_vs_destroy(&vs2); return result; } static PyObject* igraphmodule_i_Graph_adjmatrix_get_index_row(igraph_t* graph, igraph_integer_t from, igraph_vs_t* to, igraph_neimode_t neimode, PyObject* values) { igraph_vector_t eids; igraph_integer_t eid; igraph_vit_t vit; PyObject *result = 0, *item; long int i, n; igraph_integer_t v; if (igraph_vs_is_all(to)) { /* Simple case: all edges */ IGRAPH_PYCHECK(igraph_vector_init(&eids, 0)); IGRAPH_FINALLY(igraph_vector_destroy, &eids); IGRAPH_PYCHECK(igraph_incident(graph, &eids, from, neimode)); n = igraph_vector_size(&eids); result = igraphmodule_PyList_Zeroes(igraph_vcount(graph)); if (result == 0) { IGRAPH_FINALLY_FREE(); return 0; } for (i = 0; i < n; i++) { eid = (igraph_integer_t)VECTOR(eids)[i]; v = IGRAPH_OTHER(graph, eid, from); if (values) item = PyList_GetItem(values, eid); else item = PyLong_FromLong(1); Py_INCREF(item); PyList_SetItem(result, v, item); /* reference stolen here */ } IGRAPH_FINALLY_CLEAN(1); igraph_vector_destroy(&eids); return result; } /* More complicated case: only some vertices */ IGRAPH_PYCHECK(igraph_vit_create(graph, *to, &vit)); IGRAPH_FINALLY(igraph_vit_destroy, &vit); result = PyList_New(0); if (result == 0) { IGRAPH_FINALLY_FREE(); return 0; } while (!IGRAPH_VIT_END(vit)) { v = IGRAPH_VIT_GET(vit); if (neimode == IGRAPH_OUT) { item = igraphmodule_i_Graph_adjmatrix_indexing_get_value_for_vertex_pair( graph, from, v, values); } else { item = igraphmodule_i_Graph_adjmatrix_indexing_get_value_for_vertex_pair( graph, v, from, values); } if (item == 0) { IGRAPH_FINALLY_FREE(); Py_DECREF(result); return 0; } if (PyList_Append(result, item)) { /* error while appending */ Py_DECREF(item); Py_DECREF(result); result = 0; break; } Py_DECREF(item); IGRAPH_VIT_NEXT(vit); } igraph_vit_destroy(&vit); IGRAPH_FINALLY_CLEAN(1); return result; } /***************************************************************************/ /** * Determines whether the given Python value means that the user would like * to delete the edge the value is being assigned to in the adjacency matrix * assignment syntax. */ static INLINE igraph_bool_t deleting_edge(PyObject* value) { return value == Py_None || value == Py_False || (PyLong_Check(value) && PyLong_AsLong(value) == 0); } /** * Structure to hold data related to newly added/removed edges during an * adjacency matrix assignment. */ typedef struct { igraph_vector_t to_add; PyObject* to_add_values; igraph_vector_t to_delete; } igraphmodule_i_Graph_adjmatrix_set_index_data_t; int igraphmodule_i_Graph_adjmatrix_set_index_data_init( igraphmodule_i_Graph_adjmatrix_set_index_data_t* data) { if (igraph_vector_init(&data->to_add, 0)) { igraphmodule_handle_igraph_error(); return -1; } if (igraph_vector_init(&data->to_delete, 0)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&data->to_delete); return -1; } data->to_add_values = PyList_New(0); if (data->to_add_values == 0) { igraph_vector_destroy(&data->to_add); igraph_vector_destroy(&data->to_delete); return -1; } return 0; } void igraphmodule_i_Graph_adjmatrix_set_index_data_destroy( igraphmodule_i_Graph_adjmatrix_set_index_data_t* data) { igraph_vector_destroy(&data->to_add); igraph_vector_destroy(&data->to_delete); Py_DECREF(data->to_add_values); } static int igraphmodule_i_Graph_adjmatrix_set_index_row(igraph_t* graph, igraph_integer_t from, igraph_vs_t* to, igraph_neimode_t neimode, PyObject* values, PyObject* new_value, igraphmodule_i_Graph_adjmatrix_set_index_data_t* data) { PyObject *iter = 0, *item; igraph_vit_t vit; igraph_integer_t v, v1, v2, eid; igraph_bool_t deleting, ok = 1; /* Check whether new_value is an iterable (and not a string). If not, * every assignment will use the same value (that is, new_value) */ if (!PyBaseString_Check(new_value)) { iter = PyObject_GetIter(new_value); if (PyErr_Occurred()) { /* Object is not an iterable. Clear the exception */ iter = 0; PyErr_Clear(); } } if (igraph_vit_create(graph, *to, &vit)) { Py_XDECREF(iter); igraphmodule_handle_igraph_error(); return -1; } v1 = from; v2 = from; /* The two branches of the next `if' are almost the same; make sure * you make changes to both branches if appropriate! */ if (iter != 0) { /* The new value is an iterable, so it must have exactly as many elements * as the number of vertices in the graph. If it has less, we simply * skip the rest (with a warning) */ while (!IGRAPH_VIT_END(vit) && (item = PyIter_Next(iter)) != 0) { v = IGRAPH_VIT_GET(vit); /* Get the ID of the edge between from and v */ if (neimode == IGRAPH_OUT) { v2 = v; } else { v1 = v; } igraph_get_eid(graph, &eid, v1, v2, /* directed = */1, /* error = */0); if (deleting_edge(item)) { /* Deleting edges if eid != -1 */ if (eid != -1) { if (igraph_vector_push_back(&data->to_delete, eid)) { igraphmodule_handle_igraph_error(); igraph_vector_clear(&data->to_delete); ok = 0; break; } } } else { if (eid == -1) { /* Adding edges */ if (igraph_vector_push_back(&data->to_add, v1) || igraph_vector_push_back(&data->to_add, v2)) { igraphmodule_handle_igraph_error(); igraph_vector_clear(&data->to_add); ok = 0; break; } if (values != 0) { Py_INCREF(new_value); if (PyList_Append(data->to_add_values, new_value)) { Py_DECREF(new_value); igraph_vector_clear(&data->to_add); ok = 0; break; } } } else if (values != 0) { /* Setting attribute */ Py_INCREF(item); if (PyList_SetItem(values, eid, item)) { Py_DECREF(item); igraph_vector_clear(&data->to_add); } } } Py_DECREF(item); IGRAPH_VIT_NEXT(vit); } if (!IGRAPH_VIT_END(vit)) { PyErr_WarnEx(PyExc_RuntimeWarning, "iterable was shorter than the number of vertices in the vertex " "sequence", 1); } } else { /* The new value is not an iterable; setting the same value for * more than one edge */ deleting = deleting_edge(new_value); while (!IGRAPH_VIT_END(vit)) { v = IGRAPH_VIT_GET(vit); /* Get the ID of the edge between from and v */ if (neimode == IGRAPH_OUT) { v2 = v; } else { v1 = v; } igraph_get_eid(graph, &eid, v1, v2, /* directed = */1, /* error = */0); if (deleting) { /* Deleting edges if eid != -1 */ if (eid != -1) { if (igraph_vector_push_back(&data->to_delete, eid)) { igraphmodule_handle_igraph_error(); igraph_vector_clear(&data->to_delete); ok = 0; break; } } } else { if (eid == -1) { /* Adding edges */ if (igraph_vector_push_back(&data->to_add, v1) || igraph_vector_push_back(&data->to_add, v2)) { igraphmodule_handle_igraph_error(); igraph_vector_clear(&data->to_add); ok = 0; break; } if (values != 0) { Py_INCREF(new_value); if (PyList_Append(data->to_add_values, new_value)) { Py_DECREF(new_value); igraph_vector_clear(&data->to_add); ok = 0; break; } } } else if (values != 0) { /* Setting attribute */ Py_INCREF(new_value); if (PyList_SetItem(values, eid, new_value)) { Py_DECREF(new_value); igraph_vector_clear(&data->to_add); } } } IGRAPH_VIT_NEXT(vit); } } Py_XDECREF(iter); igraph_vit_destroy(&vit); return ok ? 0 : -1; } int igraphmodule_Graph_adjmatrix_set_index(igraph_t* graph, PyObject* row_index, PyObject* column_index, PyObject* attr_name, PyObject* new_value) { PyObject *values; igraph_vs_t vs1, vs2; igraph_vit_t vit; igraph_integer_t vid1 = -1, vid2 = -1, eid = -1; igraph_bool_t ok = 1; igraphmodule_i_Graph_adjmatrix_set_index_data_t data; char* attr; if (igraphmodule_PyObject_to_vs_t(row_index, &vs1, graph, 0, &vid1)) return -1; if (igraphmodule_PyObject_to_vs_t(column_index, &vs2, graph, 0, &vid2)) return -1; if (attr_name == 0) { /* Using the "weight" attribute by default */ values = igraphmodule_get_edge_attribute_values(graph, "weight"); } else { /* Specifying the name of the attribute */ attr = igraphmodule_PyObject_ConvertToCString(attr_name); values = igraphmodule_create_or_get_edge_attribute_values(graph, attr); free(attr); } if (vid1 >= 0 && vid2 >= 0) { /* Setting an edge between vid1 and vid2 */ igraph_get_eid(graph, &eid, vid1, vid2, /* directed = */1, /* error = */0); if (deleting_edge(new_value)) { if (eid != -1) { /* Deleting the edge between vid1 and vid2 if it is there */ if (igraph_delete_edges(graph, igraph_ess_1(eid))) { igraphmodule_handle_igraph_error(); ok = 0; } } } else { /* Adding the edge between vid1 and vid2 if it is not there */ if (eid == -1) { eid = igraph_ecount(graph); if (igraph_add_edge(graph, vid1, vid2)) { igraphmodule_handle_igraph_error(); ok = 0; } } if (ok && values != 0) { /* Set the attribute value */ Py_INCREF(new_value); PyList_SetItem(values, eid, new_value); /* reference stolen here */ } } } else { /* In all the non-trivial cases, we do the modifications in three phases; * in the first phase, we modify the attribute values of edges that are to * stay (but possibly with a different attribute value) and collect the * list of edges to be added (and their attribute values) and the list of * edge to be deleted. In the second phase, we do the deletions in one * batch. Finally, we add the edges to be added. */ igraphmodule_i_Graph_adjmatrix_set_index_data_init(&data); /* First phase */ if (vid1 >= 0) { /* vs1 is a single vertex, vs2 is not */ ok = (igraphmodule_i_Graph_adjmatrix_set_index_row( graph, vid1, &vs2, IGRAPH_OUT, values, new_value, &data) == 0); } else if (vid2 >= 0) { /* vs2 is a single vertex, vs1 is not */ ok = (igraphmodule_i_Graph_adjmatrix_set_index_row( graph, vid2, &vs1, IGRAPH_IN, values, new_value, &data) == 0); } else { /* Complete submatrix */ if (igraph_vit_create(graph, vs1, &vit)) { igraphmodule_handle_igraph_error(); ok = 0; } else { while (!IGRAPH_VIT_END(vit)) { vid1 = IGRAPH_VIT_GET(vit); if (igraphmodule_i_Graph_adjmatrix_set_index_row( graph, vid1, &vs2, IGRAPH_OUT, values, new_value, &data) == 0) { ok = 0; break; } IGRAPH_VIT_NEXT(vit); } igraph_vit_destroy(&vit); } } if (ok) { /* Second phase: do the deletions in one batch */ if (igraph_delete_edges(graph, igraph_ess_vector(&data.to_delete))) { igraphmodule_handle_igraph_error(); ok = 0; } } if (ok) { /* Third phase: add the new edges in one batch */ if (!igraph_vector_empty(&data.to_add)) { eid = igraph_ecount(graph); igraph_add_edges(graph, &data.to_add, 0); if (values != 0) { PyList_SetSlice(values, eid, eid+PyList_Size(data.to_add_values), data.to_add_values); if (PyList_Size(values) != igraph_ecount(graph)) { PyErr_SetString(PyExc_ValueError, "hmmm, attribute value list " "length mismatch, this is most likely a bug."); ok = 0; } } } } igraphmodule_i_Graph_adjmatrix_set_index_data_destroy(&data); } igraph_vs_destroy(&vs1); igraph_vs_destroy(&vs2); return ok ? 0 : -1; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/indexing.h0000644000175100001710000000250300000000000017761 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library - Python interface. Copyright (C) 2006-2011 Tamas Nepusz 5 Avenue Road, Staines, Middlesex, TW18 3AW, United Kingdom This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_INDEXING_H #define PYTHON_INDEXING_H #include "preamble.h" #include PyObject* igraphmodule_Graph_adjmatrix_get_index(igraph_t* graph, PyObject* row_index, PyObject* column_index, PyObject* attr_name); int igraphmodule_Graph_adjmatrix_set_index(igraph_t* graph, PyObject* row_index, PyObject* column_index, PyObject* attr_name, PyObject* value); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/operators.c0000644000175100001710000002123100000000000020164 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "common.h" #include "convert.h" #include "error.h" #include "graphobject.h" /** \ingroup python_interface_graph * \brief Creates the disjoint union of two or more graphs */ PyObject *igraphmodule__disjoint_union(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "graphs", NULL }; PyObject *it, *graphs; long int no_of_graphs; igraph_vector_ptr_t gs; PyObject *result; PyTypeObject *result_type; igraph_t g; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &graphs)) return NULL; /* Needs to be an iterable */ it = PyObject_GetIter(graphs); if (!it) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } /* Get all elements, store the graphs in an igraph_vector_ptr */ if (igraph_vector_ptr_init(&gs, 0)) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } if (igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t_with_type(it, &gs, &result_type)) { Py_DECREF(it); igraph_vector_ptr_destroy(&gs); return NULL; } Py_DECREF(it); no_of_graphs = (long int) igraph_vector_ptr_size(&gs); /* Create disjoint union */ if (igraph_disjoint_union_many(&g, &gs)) { igraph_vector_ptr_destroy(&gs); igraphmodule_handle_igraph_error(); return NULL; } igraph_vector_ptr_destroy(&gs); /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ if (no_of_graphs > 0) { result = igraphmodule_Graph_subclass_from_igraph_t( result_type, &g); } else { result = igraphmodule_Graph_from_igraph_t(&g); } return result; } /** \ingroup python_interface_graph * \brief Creates the union of two or more graphs */ PyObject *igraphmodule__union(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "graphs", "edgemaps", NULL }; PyObject *it, *em_list = 0, *graphs, *with_edgemaps_o; int with_edgemaps = 0; long int no_of_graphs; igraph_vector_ptr_t gs; igraphmodule_GraphObject *o; PyObject *result; PyTypeObject *result_type; igraph_t g; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &graphs, &with_edgemaps_o)) return NULL; if (PyObject_IsTrue(with_edgemaps_o)) with_edgemaps = 1; /* Needs to be an iterable */ it = PyObject_GetIter(graphs); if (!it) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } /* Get all elements, store the graphs in an igraph_vector_ptr */ if (igraph_vector_ptr_init(&gs, 0)) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } if (igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t_with_type(it, &gs, &result_type)) { Py_DECREF(it); igraph_vector_ptr_destroy(&gs); return NULL; } Py_DECREF(it); no_of_graphs = (long int) igraph_vector_ptr_size(&gs); if (with_edgemaps) { /* prepare edgemaps */ igraph_vector_ptr_t edgemaps; if (igraph_vector_ptr_init(&edgemaps, 0)) { return igraphmodule_handle_igraph_error(); } /* Create union */ if (igraph_union_many(&g, &gs, &edgemaps)) { igraph_vector_ptr_destroy(&gs); igraph_vector_ptr_destroy(&edgemaps); igraphmodule_handle_igraph_error(); return NULL; } /* extract edgemaps */ long int i; em_list = PyList_New((Py_ssize_t) no_of_graphs); for (i = 0; i < no_of_graphs; i++) { long int j; long int no_of_edges = (long int) igraph_ecount(VECTOR(gs)[i]); igraph_vector_t *map = VECTOR(edgemaps)[i]; PyObject *emi = PyList_New((Py_ssize_t) no_of_edges); for (j = 0; j < no_of_edges; j++) { PyObject *dest = PyLong_FromLong(VECTOR(*map)[j]); PyList_SET_ITEM(emi, (Py_ssize_t) j, dest); } PyList_SET_ITEM(em_list, (Py_ssize_t) i, emi); } igraph_vector_ptr_destroy(&edgemaps); } else { /* Create union */ if (igraph_union_many(&g, &gs, /* edgemaps */ 0)) { igraph_vector_ptr_destroy(&gs); igraphmodule_handle_igraph_error(); return NULL; } } igraph_vector_ptr_destroy(&gs); /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ if (no_of_graphs > 0) { o = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( result_type, &g); } else { o = (igraphmodule_GraphObject*) igraphmodule_Graph_from_igraph_t(&g); } if (with_edgemaps) { /* wrap in a dictionary */ result = PyDict_New(); PyDict_SetItemString(result, "graph", (PyObject *) o); Py_DECREF(o); PyDict_SetItemString(result, "edgemaps", em_list); } else { result = (PyObject *) o; } return result; } /** \ingroup python_interface_graph * \brief Creates the intersection of two or more graphs */ PyObject *igraphmodule__intersection(PyObject *self, PyObject *args, PyObject *kwds) { static char* kwlist[] = { "graphs", "edgemaps", NULL }; PyObject *it, *em_list = 0, *graphs, *with_edgemaps_o; int with_edgemaps = 0; long int no_of_graphs; igraph_vector_ptr_t gs; igraphmodule_GraphObject *o; PyObject *result; PyTypeObject *result_type; igraph_t g; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &graphs, &with_edgemaps_o)) return NULL; if (PyObject_IsTrue(with_edgemaps_o)) with_edgemaps = 1; /* Needs to be an iterable */ it = PyObject_GetIter(graphs); if (!it) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } /* Get all elements, store the graphs in an igraph_vector_ptr */ if (igraph_vector_ptr_init(&gs, 0)) { Py_DECREF(it); return igraphmodule_handle_igraph_error(); } if (igraphmodule_append_PyIter_of_graphs_to_vector_ptr_t_with_type(it, &gs, &result_type)) { Py_DECREF(it); igraph_vector_ptr_destroy(&gs); return NULL; } Py_DECREF(it); no_of_graphs = (long int) igraph_vector_ptr_size(&gs); if (with_edgemaps) { /* prepare edgemaps */ igraph_vector_ptr_t edgemaps; if (igraph_vector_ptr_init(&edgemaps, 0)) { return igraphmodule_handle_igraph_error(); } /* Create intersection */ if (igraph_intersection_many(&g, &gs, &edgemaps)) { igraph_vector_ptr_destroy(&gs); igraph_vector_ptr_destroy(&edgemaps); igraphmodule_handle_igraph_error(); return NULL; } long int i; em_list = PyList_New((Py_ssize_t) no_of_graphs); for (i = 0; i < no_of_graphs; i++) { long int j; long int no_of_edges = (long int) igraph_ecount(VECTOR(gs)[i]); igraph_vector_t *map = VECTOR(edgemaps)[i]; PyObject *emi = PyList_New((Py_ssize_t) no_of_edges); for (j = 0; j < no_of_edges; j++) { PyObject *dest = PyLong_FromLong(VECTOR(*map)[j]); PyList_SET_ITEM(emi, (Py_ssize_t) j, dest); } PyList_SET_ITEM(em_list, (Py_ssize_t) i, emi); } igraph_vector_ptr_destroy(&edgemaps); } else { /* Create intersection */ if (igraph_intersection_many(&g, &gs, /* edgemaps */ 0)) { igraph_vector_ptr_destroy(&gs); igraphmodule_handle_igraph_error(); return NULL; } } igraph_vector_ptr_destroy(&gs); /* this is correct as long as attributes are not copied by the * operator. if they are copied, the initialization should not empty * the attribute hashes */ if (no_of_graphs > 0) { o = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( result_type, &g); } else { o = (igraphmodule_GraphObject*) igraphmodule_Graph_from_igraph_t(&g); } if (with_edgemaps) { /* wrap in a dictionary */ result = PyDict_New(); PyDict_SetItemString(result, "graph", (PyObject *) o); Py_DECREF(o); PyDict_SetItemString(result, "edgemaps", em_list); Py_DECREF(em_list); } else { result = (PyObject *) o; } return result; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/operators.h0000644000175100001710000000221600000000000020173 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_OPERATORS_H #define PYTHON_OPERATORS_H #include "preamble.h" PyObject* igraphmodule__disjoint_union(PyObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule__union(PyObject* self, PyObject* args, PyObject* kwds); PyObject* igraphmodule__intersection(PyObject* self, PyObject* args, PyObject* kwds); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/platform.h0000644000175100001710000000177400000000000020011 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim: set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_PLATFORM_H #define PYTHON_PLATFORM_H #ifdef _MSC_VER # define INLINE __forceinline #else # define INLINE inline #endif #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/preamble.h0000644000175100001710000000171600000000000017750 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2021 The igraph development team This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_IGRAPH_PREAMBLE_H #define PYTHON_IGRAPH_PREAMBLE_H #define PY_SSIZE_T_CLEAN #include #endif /* PYTHON_IGRAPH_PREAMBLE_H */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/pyhelpers.c0000644000175100001710000001177400000000000020174 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library - Python interface. Copyright (C) 2006-2011 Tamas Nepusz 5 Avenue Road, Staines, Middlesex, TW18 3AW, United Kingdom This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "pyhelpers.h" /** * Closes a Python file-like object by calling its close() method. */ int igraphmodule_PyFile_Close(PyObject* fileObj) { PyObject *result; result = PyObject_CallMethod(fileObj, "close", 0); if (result) { Py_DECREF(result); return 0; } else { /* Exception raised already */ return 1; } } /** * Creates a Python file-like object from a Python object storing a string and * an ordinary C string storing the mode to open the file in. */ PyObject* igraphmodule_PyFile_FromObject(PyObject* filename, const char* mode) { PyObject *ioModule, *fileObj; ioModule = PyImport_ImportModule("io"); if (ioModule == 0) return 0; fileObj = PyObject_CallMethod(ioModule, "open", "Os", filename, mode); Py_DECREF(ioModule); return fileObj; } /** * Creates a Python list and fills it with a pre-defined item. * * \param len the length of the list to be created * \param item the item with which the list will be filled */ PyObject* igraphmodule_PyList_NewFill(Py_ssize_t len, PyObject* item) { Py_ssize_t i; PyObject* result = PyList_New(len); if (result == 0) return 0; for (i = 0; i < len; i++) { Py_INCREF(item); PyList_SET_ITEM(result, i, item); /* reference to item stolen */ } return result; } /** * Creates a Python list and fills it with zeroes. * * \param len the length of the list to be created */ PyObject* igraphmodule_PyList_Zeroes(Py_ssize_t len) { PyObject* zero = PyLong_FromLong(0); PyObject* result; if (zero == 0) return 0; result = igraphmodule_PyList_NewFill(len, zero); Py_DECREF(zero); return result; } /** * Converts a Python object to its string representation and returns it as * a C string. * * It is the responsibility of the caller to release the C string. */ char* igraphmodule_PyObject_ConvertToCString(PyObject* string) { char* result; if (string == 0) return 0; if (!PyBaseString_Check(string)) { string = PyObject_Str(string); if (string == 0) return 0; } else { Py_INCREF(string); } result = PyUnicode_CopyAsString(string); Py_DECREF(string); return result; } /** * Creates a Python range object with the given start and stop indices and step * size. * * The function returns a new reference. It is the responsibility of the caller * to release it. Returns \c NULL in case of an error. */ PyObject* igraphmodule_PyRange_create(Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step) { static PyObject* builtin_module = 0; static PyObject* range_func = 0; PyObject* result; if (builtin_module == 0) { builtin_module = PyImport_ImportModule("builtins"); if (builtin_module == 0) { return 0; } } if (range_func == 0) { range_func = PyObject_GetAttrString(builtin_module, "range"); if (range_func == 0) { return 0; } } result = PyObject_CallFunction(range_func, "lll", start, stop, step); return result; } char* PyUnicode_CopyAsString(PyObject* string) { PyObject* bytes; char* result; if (PyBytes_Check(string)) { bytes = string; Py_INCREF(bytes); } else { bytes = PyUnicode_AsUTF8String(string); } if (bytes == 0) return 0; result = strdup(PyBytes_AS_STRING(bytes)); Py_DECREF(bytes); if (result == 0) PyErr_NoMemory(); return result; } int PyUnicode_IsEqualToUTF8String(PyObject* py_string, const char* c_string) { PyObject* c_string_conv; int result; if (!PyUnicode_Check(py_string)) return 0; c_string_conv = PyUnicode_FromString(c_string); if (c_string_conv == 0) return 0; result = (PyUnicode_Compare(py_string, c_string_conv) == 0); Py_DECREF(c_string_conv); return result; } /** * Generates a hash value for a plain C pointer. * * This function is a copy of \c _Py_HashPointer from \c Objects/object.c in * the source code of Python's C implementation. */ long igraphmodule_Py_HashPointer(void *p) { long x; size_t y = (size_t)p; /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid * excessive hash collisions for dicts and sets */ y = (y >> 4) | (y << (8 * sizeof(p) - 4)); x = (long)y; if (x == -1) x = -2; return x; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/pyhelpers.h0000644000175100001710000000363100000000000020172 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */ /* IGraph library - Python interface. Copyright (C) 2006-2011 Tamas Nepusz 5 Avenue Road, Staines, Middlesex, TW18 3AW, United Kingdom This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_HELPERS_H #define PYTHON_HELPERS_H #include "preamble.h" int igraphmodule_PyFile_Close(PyObject* fileObj); PyObject* igraphmodule_PyFile_FromObject(PyObject* filename, const char* mode); PyObject* igraphmodule_PyList_NewFill(Py_ssize_t len, PyObject* item); PyObject* igraphmodule_PyList_Zeroes(Py_ssize_t len); char* igraphmodule_PyObject_ConvertToCString(PyObject* string); PyObject* igraphmodule_PyRange_create(Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step); int PyUnicode_IsEqualToUTF8String(PyObject* py_string, const char* c_string); long igraphmodule_Py_HashPointer(void *p); #define PyBaseString_Check(o) (PyUnicode_Check(o) || PyBytes_Check(o)) #define PyUnicode_IsEqualToASCIIString(uni, string) \ (PyUnicode_CompareWithASCIIString(uni, string) == 0) char* PyUnicode_CopyAsString(PyObject* string); #define PY_IGRAPH_DEPRECATED(msg) \ PyErr_WarnEx(PyExc_DeprecationWarning, (msg), 1) #define PY_IGRAPH_WARN(msg) \ PyErr_WarnEx(PyExc_RuntimeWarning, (msg), 1) #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/random.c0000644000175100001710000002265500000000000017441 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim:set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "random.h" #include #include /** * \ingroup python_interface_rng * \brief Internal data structure for storing references to the * functions and arguments used from Python's random number generator. */ typedef struct { PyObject* getrandbits_func; PyObject* randint_func; PyObject* random_func; PyObject* gauss_func; PyObject* rng_bits_as_pyobject; PyObject* zero_as_pyobject; PyObject* one_as_pyobject; PyObject* rng_max_as_pyobject; } igraph_i_rng_Python_state_t; /* igraph_rng_get_int31() is potentially faster if the max value of the RNG * is 0x7FFFFFFF; however, in case of Python, it is actually _slower_ because * Python long integers are not terribly efficient. We are better off with using * any other value here */ #define RNG_MAX 0xFFFFFFFF /* This must be consistent with the value of RNG_MAX above */ #define RNG_BITS 32 static igraph_i_rng_Python_state_t igraph_rng_Python_state = {0, 0, 0}; static igraph_rng_t igraph_rng_Python = {0, 0, 0}; static igraph_rng_t igraph_rng_default_saved = {0, 0, 0}; int igraph_rng_Python_init(void **state) { IGRAPH_ERROR("Python RNG error, unsupported function called", IGRAPH_EINTERNAL); return 0; } void igraph_rng_Python_destroy(void *state) { igraph_error("Python RNG error, unsupported function called", __FILE__, __LINE__, IGRAPH_EINTERNAL); } /** * \ingroup python_interface_rng * \brief Sets the random number generator used by igraph. */ PyObject* igraph_rng_Python_set_generator(PyObject* self, PyObject* object) { igraph_i_rng_Python_state_t new_state, old_state; PyObject* func; if (object == Py_None) { /* Reverting to the default igraph random number generator instead * of the Python-based one */ igraph_rng_set_default(&igraph_rng_default_saved); Py_RETURN_NONE; } #define GET_FUNC(name) { \ func = PyObject_GetAttrString(object, name); \ if (func == 0) {\ return 0; \ } else if (!PyCallable_Check(func)) { \ PyErr_SetString(PyExc_TypeError, "'" name "' attribute must be callable"); \ return 0; \ } \ } #define GET_OPTIONAL_FUNC(name) { \ if (PyObject_HasAttrString(object, name)) { \ func = PyObject_GetAttrString(object, name); \ if (func == 0) { \ return 0; \ } else if (!PyCallable_Check(func)) { \ PyErr_SetString(PyExc_TypeError, "'" name "' attribute must be callable"); \ return 0; \ } \ } else { \ func = 0; \ } \ } GET_OPTIONAL_FUNC("getrandbits"); new_state.getrandbits_func = func; GET_FUNC("randint"); new_state.randint_func = func; GET_FUNC("random"); new_state.random_func = func; GET_FUNC("gauss"); new_state.gauss_func = func; /* construct the arguments of getrandbits(RNG_BITS) and randint(0, RNG_MAX) * in advance */ new_state.rng_bits_as_pyobject = PyLong_FromLong(RNG_BITS); if (new_state.rng_bits_as_pyobject == 0) { return 0; } new_state.zero_as_pyobject = PyLong_FromLong(0); if (new_state.zero_as_pyobject == 0) { return 0; } new_state.one_as_pyobject = PyLong_FromLong(1); if (new_state.one_as_pyobject == 0) { return 0; } new_state.rng_max_as_pyobject = PyLong_FromUnsignedLong(RNG_MAX); if (new_state.rng_max_as_pyobject == 0) { return 0; } #undef GET_FUNC #undef GET_OPTIONAL_FUNC old_state = igraph_rng_Python_state; igraph_rng_Python_state = new_state; Py_XDECREF(old_state.getrandbits_func); Py_XDECREF(old_state.randint_func); Py_XDECREF(old_state.random_func); Py_XDECREF(old_state.gauss_func); Py_XDECREF(old_state.rng_bits_as_pyobject); Py_XDECREF(old_state.zero_as_pyobject); Py_XDECREF(old_state.one_as_pyobject); Py_XDECREF(old_state.rng_max_as_pyobject); igraph_rng_set_default(&igraph_rng_Python); Py_RETURN_NONE; } /** * \ingroup python_interface_rng * \brief Sets the seed of the random generator. */ int igraph_rng_Python_seed(void *state, unsigned long int seed) { IGRAPH_ERROR("Python RNG error, unsupported function called", IGRAPH_EINTERNAL); return 0; } /** * \ingroup python_interface_rng * \brief Generates an unsigned long integer using the Python random number generator. */ unsigned long int igraph_rng_Python_get(void *state) { PyObject* result; PyObject* exc_type; unsigned long int retval; if (igraph_rng_Python_state.getrandbits_func) { /* This is the preferred code path if the random module given by the user * supports getrandbits(); it is faster than randint() but still slower * than simply calling random() */ result = PyObject_CallFunctionObjArgs( igraph_rng_Python_state.getrandbits_func, igraph_rng_Python_state.rng_bits_as_pyobject, 0 ); } else { /* We want to avoid hitting this path at all costs because randint() is * very costly in the Python layer */ result = PyObject_CallFunctionObjArgs( igraph_rng_Python_state.randint_func, igraph_rng_Python_state.zero_as_pyobject, igraph_rng_Python_state.rng_max_as_pyobject, 0 ); } if (result == 0) { exc_type = PyErr_Occurred(); if (exc_type == PyExc_KeyboardInterrupt) { /* KeyboardInterrupt is okay, we don't report it, just store it and let * the caller handler it at the earliest convenience */ } else { /* All other exceptions are reported and cleared */ PyErr_WriteUnraisable(exc_type); PyErr_Clear(); } /* Fallback to the C random generator */ return rand() * RNG_MAX; } else { retval = PyLong_AsUnsignedLong(result); Py_DECREF(result); return retval; } } /** * \ingroup python_interface_rng * \brief Generates a real number between 0 and 1 using the Python random number generator. */ igraph_real_t igraph_rng_Python_get_real(void *state) { PyObject* exc_type; double retval; PyObject* result = PyObject_CallObject(igraph_rng_Python_state.random_func, 0); if (result == 0) { exc_type = PyErr_Occurred(); if (exc_type == PyExc_KeyboardInterrupt) { /* KeyboardInterrupt is okay, we don't report it, just store it and let * the caller handler it at the earliest convenience */ } else { /* All other exceptions are reported and cleared */ PyErr_WriteUnraisable(exc_type); PyErr_Clear(); } /* Fallback to the C random generator */ return rand(); } else { retval = PyFloat_AsDouble(result); Py_DECREF(result); return retval; } } /** * \ingroup python_interface_rng * \brief Generates a real number distributed according to the normal distribution * around zero with unit variance. */ igraph_real_t igraph_rng_Python_get_norm(void *state) { PyObject* exc_type; double retval; PyObject* result = PyObject_CallFunctionObjArgs( igraph_rng_Python_state.gauss_func, igraph_rng_Python_state.zero_as_pyobject, igraph_rng_Python_state.one_as_pyobject, 0 ); if (result == 0) { exc_type = PyErr_Occurred(); if (exc_type == PyExc_KeyboardInterrupt) { /* KeyboardInterrupt is okay, we don't report it, just store it and let * the caller handler it at the earliest convenience */ } else { /* All other exceptions are reported and cleared */ PyErr_WriteUnraisable(exc_type); PyErr_Clear(); } /* Fallback to the C random generator */ return 0; } else { retval = PyFloat_AsDouble(result); Py_DECREF(result); return retval; } } /** * \ingroup python_interface_rng * \brief Specification table for Python's random number generator. * This tells igraph which functions to call to obtain random numbers. */ igraph_rng_type_t igraph_rngtype_Python = { /* name= */ "Python random generator", /* min= */ 0, /* max= */ RNG_MAX, /* init= */ igraph_rng_Python_init, /* destroy= */ igraph_rng_Python_destroy, /* seed= */ igraph_rng_Python_seed, /* get= */ igraph_rng_Python_get, /* get_real */ igraph_rng_Python_get_real, /* get_norm= */ igraph_rng_Python_get_norm, /* get_geom= */ 0, /* get_binom= */ 0 }; void igraphmodule_init_rng(PyObject* igraph_module) { PyObject* random_module; if (igraph_rng_default_saved.type == 0) { igraph_rng_default_saved = *igraph_rng_default(); } if (igraph_rng_Python.state != 0) return; random_module = PyImport_ImportModule("random"); if (random_module == 0) { PyErr_WriteUnraisable(PyErr_Occurred()); PyErr_Clear(); return; } igraph_rng_Python.type = &igraph_rngtype_Python; igraph_rng_Python.state = &igraph_rng_Python_state; if (igraph_rng_Python_set_generator(igraph_module, random_module) == 0) { PyErr_WriteUnraisable(PyErr_Occurred()); PyErr_Clear(); return; } Py_DECREF(random_module); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/random.h0000644000175100001710000000201300000000000017430 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_RANDOM_H #define PYTHON_RANDOM_H #include "preamble.h" void igraphmodule_init_rng(PyObject*); PyObject* igraph_rng_Python_set_generator(PyObject* self, PyObject* object); #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/vertexobject.c0000644000175100001710000007061300000000000020662 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim: set ts=2 sw=2 sts=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "convert.h" #include "edgeobject.h" #include "error.h" #include "graphobject.h" #include "pyhelpers.h" #include "vertexobject.h" /** * \ingroup python_interface * \defgroup python_interface_vertex Vertex object */ PyTypeObject igraphmodule_VertexType; /** * \ingroup python_interface_vertex * \brief Checks whether the given Python object is a vertex */ int igraphmodule_Vertex_Check(PyObject* obj) { if (!obj) return 0; return PyObject_IsInstance(obj, (PyObject*)(&igraphmodule_VertexType)); } /** * \ingroup python_interface_vertex * \brief Checks whether the index in the given vertex object is a valid one. * \return nonzero if the vertex object is valid. Raises an appropriate Python * exception and returns zero if the vertex object is invalid. */ int igraphmodule_Vertex_Validate(PyObject* obj) { igraph_integer_t n; igraphmodule_VertexObject *self; igraphmodule_GraphObject *graph; if (!igraphmodule_Vertex_Check(obj)) { PyErr_SetString(PyExc_TypeError, "object is not a Vertex"); return 0; } self = (igraphmodule_VertexObject*)obj; graph = self->gref; if (graph == 0) { PyErr_SetString(PyExc_ValueError, "Vertex object refers to a null graph"); return 0; } if (self->idx < 0) { PyErr_SetString(PyExc_ValueError, "Vertex object refers to a negative vertex index"); return 0; } n = igraph_vcount(&graph->g); if (self->idx >= n) { PyErr_SetString(PyExc_ValueError, "Vertex object refers to a nonexistent vertex"); return 0; } return 1; } /** * \ingroup python_interface_vertex * \brief Allocates a new Python vertex object * \param gref the \c igraph.Graph being referenced by the vertex * \param idx the index of the vertex * * \warning \c igraph references its vertices by indices, so if * you delete some vertices from the graph, the vertex indices will * change. Since the \c igraph.Vertex objects do not follow these * changes, your existing vertex objects will point to elsewhere * (or they might even get invalidated). */ PyObject* igraphmodule_Vertex_New(igraphmodule_GraphObject *gref, igraph_integer_t idx) { igraphmodule_VertexObject* self; self=PyObject_New(igraphmodule_VertexObject, &igraphmodule_VertexType); if (self) { RC_ALLOC("Vertex", self); Py_INCREF(gref); self->gref=gref; self->idx=idx; self->hash=-1; } return (PyObject*)self; } /** * \ingroup python_interface_vertex * \brief Clears the vertex's subobject (before deallocation) */ int igraphmodule_Vertex_clear(igraphmodule_VertexObject *self) { PyObject *tmp; tmp=(PyObject*)self->gref; self->gref=NULL; Py_XDECREF(tmp); return 0; } /** * \ingroup python_interface_vertex * \brief Deallocates a Python representation of a given vertex object */ void igraphmodule_Vertex_dealloc(igraphmodule_VertexObject* self) { igraphmodule_Vertex_clear(self); RC_DEALLOC("Vertex", self); PyObject_Del((PyObject*)self); } /** \ingroup python_interface_vertex * \brief Formats an \c igraph.Vertex object to a string * * \return the formatted textual representation as a \c PyObject */ PyObject* igraphmodule_Vertex_repr(igraphmodule_VertexObject *self) { PyObject *s; PyObject *attrs; attrs = igraphmodule_Vertex_attributes(self); if (attrs == 0) return NULL; s = PyUnicode_FromFormat("igraph.Vertex(%R, %ld, %R)", (PyObject*)self->gref, (long int)self->idx, attrs); Py_DECREF(attrs); return s; } /** \ingroup python_interface_vertex * \brief Returns the hash code of the vertex */ long igraphmodule_Vertex_hash(igraphmodule_VertexObject* self) { long hash_graph; long hash_index; long result; PyObject* index_o; if (self->hash != -1) return self->hash; index_o = PyLong_FromLong((long int)self->idx); if (index_o == 0) return -1; hash_index = PyObject_Hash(index_o); Py_DECREF(index_o); if (hash_index == -1) return -1; /* Graph objects are unhashable from Python so we cannot call PyObject_Hash * directly. */ hash_graph = igraphmodule_Py_HashPointer(self->gref); if (hash_graph == -1) return -1; result = hash_graph ^ hash_index; if (result == -1) result = 590923713U; self->hash = result; return result; } /** \ingroup python_interface_vertex * \brief Rich comparison of a vertex with another */ PyObject* igraphmodule_Vertex_richcompare(igraphmodule_VertexObject *a, PyObject *b, int op) { igraphmodule_VertexObject* self = a; igraphmodule_VertexObject* other; if (!igraphmodule_Vertex_Check(b)) Py_RETURN_NOTIMPLEMENTED; other = (igraphmodule_VertexObject*)b; if (self->gref != other->gref) Py_RETURN_FALSE; switch (op) { case Py_EQ: Py_RETURN(self->idx == other->idx); case Py_NE: Py_RETURN(self->idx != other->idx); case Py_LE: Py_RETURN(self->idx <= other->idx); case Py_LT: Py_RETURN(self->idx < other->idx); case Py_GE: Py_RETURN(self->idx >= other->idx); case Py_GT: Py_RETURN(self->idx > other->idx); default: Py_RETURN_NOTIMPLEMENTED; } } /** \ingroup python_interface_vertex * \brief Returns the number of vertex attributes */ Py_ssize_t igraphmodule_Vertex_attribute_count(igraphmodule_VertexObject* self) { igraphmodule_GraphObject *o = self->gref; if (!o) return 0; if (!((PyObject**)o->g.attr)[1]) return 0; return PyDict_Size(((PyObject**)o->g.attr)[1]); } /** \ingroup python_interface_vertex * \brief Returns the list of attribute names */ PyObject* igraphmodule_Vertex_attribute_names(igraphmodule_VertexObject* self) { if (!self->gref) return NULL; return igraphmodule_Graph_vertex_attributes(self->gref); } /** \ingroup python_interface_vertex * \brief Returns a dict with attribue names and values */ PyObject* igraphmodule_Vertex_attributes(igraphmodule_VertexObject* self) { igraphmodule_GraphObject *o = self->gref; PyObject *names, *dict; long i, n; if (!igraphmodule_Vertex_Validate((PyObject*)self)) return 0; dict=PyDict_New(); if (!dict) return NULL; names=igraphmodule_Graph_vertex_attributes(o); if (!names) { Py_DECREF(dict); return NULL; } n=PyList_Size(names); for (i=0; ig.attr)[ATTRHASH_IDX_VERTEX], name); if (dictit) { PyObject *value = PyList_GetItem(dictit, self->idx); if (value) { /* No need to Py_INCREF, PyDict_SetItem will do that */ PyDict_SetItem(dict, name, value); } } } } Py_DECREF(names); return dict; } /** * \ingroup python_interface_vertex * \brief Updates some attributes of a vertex * * Incidentally, this method is re-used intact in edgeobject.c for edges. * * \param self the vertex object * \param args positional arguments * \param kwds keyword arguments */ PyObject* igraphmodule_Vertex_update_attributes(PyObject* self, PyObject* args, PyObject* kwds) { PyObject* items[] = { Py_None, kwds, 0 }; PyObject** pObj; PyObject *key, *value, *it, *item, *keys; igraph_bool_t ok = 1; if (!PyArg_ParseTuple(args, "|O", &items[0])) return NULL; pObj = items; for (pObj = items; ok && *pObj != 0; pObj++) { PyObject* obj = *pObj; PyObject* keys_func; if (obj == Py_None) continue; keys_func = PyObject_GetAttrString(obj, "keys"); if (keys_func == 0) PyErr_Clear(); if (keys_func != 0 && PyCallable_Check(keys_func)) { /* Object has a "keys" method, so we iterate over the keys */ keys = PyObject_CallObject(keys_func, 0); if (keys == 0) { ok = 0; } else { /* Iterate over the keys */ it = PyObject_GetIter(keys); if (it == 0) { ok = 0; } else { while (ok && ((key = PyIter_Next(it)) != 0)) { value = PyObject_GetItem(obj, key); if (value == 0) { ok = 0; } else { PyObject_SetItem((PyObject*)self, key, value); Py_DECREF(value); } Py_DECREF(key); } Py_DECREF(it); if (PyErr_Occurred()) ok = 0; } Py_DECREF(keys); } } else { /* Object does not have a "keys" method; assume that it * yields tuples when treated as an iterator */ it = PyObject_GetIter(obj); if (!it) { ok = 0; } else { while (ok && ((item = PyIter_Next(it)) != 0)) { if (!PySequence_Check(item) || PyBaseString_Check(item)) { PyErr_SetString(PyExc_TypeError, "cannot convert update sequence element to a sequence"); ok = 0; } else { key = PySequence_GetItem(item, 0); if (key == 0) { ok = 0; } else { value = PySequence_GetItem(item, 1); if (value == 0) { ok = 0; } else { PyObject_SetItem((PyObject*)self, key, value); Py_DECREF(value); } Py_DECREF(key); } } Py_DECREF(item); } Py_DECREF(it); if (PyErr_Occurred()) ok = 0; } } if (keys_func != 0) { Py_DECREF(keys_func); } } if (ok) Py_RETURN_NONE; return 0; } /** * \ingroup python_interface_vertex * \brief Returns the inbound and outbound edges of a vertex * * \param self the vertex object * \param args positional arguments * \param kwds keyword arguments */ PyObject* igraphmodule_Vertex_all_edges(PyObject* self) { return PyObject_CallMethod(self, "incident", "i", (int) IGRAPH_ALL); } /** * \ingroup python_interface_vertex * \brief Returns the inbound edges of a vertex * * \param self the vertex object * \param args positional arguments * \param kwds keyword arguments */ PyObject* igraphmodule_Vertex_in_edges(PyObject* self) { return PyObject_CallMethod(self, "incident", "i", (int) IGRAPH_IN); } /** * \ingroup python_interface_vertex * \brief Returns the outbound edges of a vertex * * \param self the vertex object * \param args positional arguments * \param kwds keyword arguments */ PyObject* igraphmodule_Vertex_out_edges(PyObject* self) { return PyObject_CallMethod(self, "incident", "i", (int) IGRAPH_OUT); } /** \ingroup python_interface_vertex * \brief Returns the corresponding value to a given attribute of the vertex * \param self the vertex object * \param s the attribute name to be queried */ PyObject* igraphmodule_Vertex_get_attribute(igraphmodule_VertexObject* self, PyObject* s) { igraphmodule_GraphObject *o = self->gref; PyObject* result; if (!igraphmodule_Vertex_Validate((PyObject*)self)) return 0; if (!igraphmodule_attribute_name_check(s)) return 0; result=PyDict_GetItem(((PyObject**)o->g.attr)[ATTRHASH_IDX_VERTEX], s); if (result) { /* result is a list, so get the element with index self->idx */ if (!PyList_Check(result)) { PyErr_SetString(igraphmodule_InternalError, "Vertex attribute dict member is not a list"); return NULL; } result=PyList_GetItem(result, self->idx); Py_INCREF(result); return result; } /* result is NULL, check whether there was an error */ if (!PyErr_Occurred()) PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return NULL; } /** \ingroup python_interface_vertex * \brief Sets the corresponding value of a given attribute of the vertex * \param self the vertex object * \param k the attribute name to be set * \param v the value to be set * \return 0 if everything's ok, -1 in case of error */ int igraphmodule_Vertex_set_attribute(igraphmodule_VertexObject* self, PyObject* k, PyObject* v) { igraphmodule_GraphObject *o=self->gref; PyObject* result; int r; if (!igraphmodule_Vertex_Validate((PyObject*)self)) return -1; if (!igraphmodule_attribute_name_check(k)) return -1; if (PyUnicode_IsEqualToASCIIString(k, "name")) igraphmodule_invalidate_vertex_name_index(&o->g); if (v==NULL) // we are deleting attribute return PyDict_DelItem(((PyObject**)o->g.attr)[ATTRHASH_IDX_VERTEX], k); result=PyDict_GetItem(((PyObject**)o->g.attr)[ATTRHASH_IDX_VERTEX], k); if (result) { /* result is a list, so set the element with index self->idx */ if (!PyList_Check(result)) { PyErr_SetString(igraphmodule_InternalError, "Vertex attribute dict member is not a list"); return -1; } /* we actually don't own a reference here to v, so we must increase * its reference count, because PyList_SetItem will "steal" a reference! * It took me 1.5 hours between London and Manchester to figure it out */ Py_INCREF(v); r=PyList_SetItem(result, self->idx, v); if (r == -1) { Py_DECREF(v); } return r; } /* result is NULL, check whether there was an error */ if (!PyErr_Occurred()) { /* no, there wasn't, so we must simply add the attribute */ int n=(int)igraph_vcount(&o->g), i; result=PyList_New(n); for (i=0; iidx) { Py_INCREF(Py_None); if (PyList_SetItem(result, i, Py_None) == -1) { Py_DECREF(Py_None); Py_DECREF(result); return -1; } } else { /* Same game with the reference count here */ Py_INCREF(v); if (PyList_SetItem(result, i, v) == -1) { Py_DECREF(v); Py_DECREF(result); return -1; } } } if (PyDict_SetItem(((PyObject**)o->g.attr)[1], k, result) == -1) { Py_DECREF(result); return -1; } Py_DECREF(result); /* compensating for PyDict_SetItem */ return 0; } return -1; } /** * \ingroup python_interface_vertex * Returns the vertex index */ PyObject* igraphmodule_Vertex_get_index(igraphmodule_VertexObject* self, void* closure) { return PyLong_FromLong((long int)self->idx); } /** * \ingroup python_interface_vertex * Returns the vertex index as an igraph_integer_t */ igraph_integer_t igraphmodule_Vertex_get_index_igraph_integer(igraphmodule_VertexObject* self) { return self->idx; } /** * \ingroup python_interface_vertex * Returns the vertex index as an ordinary C long */ long igraphmodule_Vertex_get_index_long(igraphmodule_VertexObject* self) { return (long)self->idx; } /** * \ingroup python_interface_vertexseq * Returns the graph where the vertex belongs */ PyObject* igraphmodule_Vertex_get_graph(igraphmodule_VertexObject* self, void* closure) { Py_INCREF(self->gref); return (PyObject*)self->gref; } /**************************************************************************/ /* Implementing proxy method in Vertex that just forward the call to the * appropriate Graph method. * * These methods may also execute a postprocessing function on the result * of the Graph method; for instance, this mechanism is used to turn the * result of Graph.neighbors() (which is a list of vertex indices) into a * list of Vertex objects. */ /* Dummy postprocessing function that does nothing. */ static PyObject* _identity(igraphmodule_VertexObject* vertex, PyObject* obj) { Py_INCREF(obj); return obj; } /* Postprocessing function that converts a Python list of integers into a * list of edges in-place. */ static PyObject* _convert_to_edge_list(igraphmodule_VertexObject* vertex, PyObject* obj) { Py_ssize_t i, n; if (!PyList_Check(obj)) { PyErr_SetString(PyExc_TypeError, "_convert_to_edge_list expected list of integers"); return NULL; } n = PyList_Size(obj); for (i = 0; i < n; i++) { PyObject* idx = PyList_GET_ITEM(obj, i); PyObject* v; int idx_int; if (!PyLong_Check(idx)) { PyErr_SetString(PyExc_TypeError, "_convert_to_edge_list expected list of integers"); return NULL; } if (PyLong_AsInt(idx, &idx_int)) return NULL; v = igraphmodule_Edge_New(vertex->gref, idx_int); PyList_SetItem(obj, i, v); /* reference to v stolen, reference to idx discarded */ } Py_INCREF(obj); return obj; } /* Postprocessing function that converts a Python list of integers into a * list of vertices in-place. */ static PyObject* _convert_to_vertex_list(igraphmodule_VertexObject* vertex, PyObject* obj) { Py_ssize_t i, n; if (!PyList_Check(obj)) { PyErr_SetString(PyExc_TypeError, "_convert_to_vertex_list expected list of integers"); return NULL; } n = PyList_Size(obj); for (i = 0; i < n; i++) { PyObject* idx = PyList_GET_ITEM(obj, i); PyObject* v; int idx_int; if (!PyLong_Check(idx)) { PyErr_SetString(PyExc_TypeError, "_convert_to_vertex_list expected list of integers"); return NULL; } if (PyLong_AsInt(idx, &idx_int)) return NULL; v = igraphmodule_Vertex_New(vertex->gref, idx_int); PyList_SetItem(obj, i, v); /* reference to v stolen, reference to idx discarded */ } Py_INCREF(obj); return obj; } #define GRAPH_PROXY_METHOD_PP(FUNC, METHODNAME, POSTPROCESS) \ PyObject* igraphmodule_Vertex_##FUNC(igraphmodule_VertexObject* self, PyObject* args, PyObject* kwds) { \ PyObject *new_args, *item, *result; \ long int i, num_args = args ? PyTuple_Size(args)+1 : 1; \ \ /* Prepend ourselves to args */ \ new_args = PyTuple_New(num_args); \ Py_INCREF(self); PyTuple_SET_ITEM(new_args, 0, (PyObject*)self); \ for (i = 1; i < num_args; i++) { \ item = PyTuple_GET_ITEM(args, i-1); \ Py_INCREF(item); PyTuple_SET_ITEM(new_args, i, item); \ } \ \ /* Get the method instance */ \ item = PyObject_GetAttrString((PyObject*)(self->gref), METHODNAME); \ result = PyObject_Call(item, new_args, kwds); \ Py_DECREF(item); \ Py_DECREF(new_args); \ \ /* Optional postprocessing */ \ if (result) { \ PyObject* pp_result = POSTPROCESS(self, result); \ Py_DECREF(result); \ return pp_result; \ } \ return NULL; \ } #define GRAPH_PROXY_METHOD(FUNC, METHODNAME) \ GRAPH_PROXY_METHOD_PP(FUNC, METHODNAME, _identity) GRAPH_PROXY_METHOD(betweenness, "betweenness"); GRAPH_PROXY_METHOD(closeness, "closeness"); GRAPH_PROXY_METHOD(constraint, "constraint"); GRAPH_PROXY_METHOD(degree, "degree"); GRAPH_PROXY_METHOD(delete, "delete_vertices"); GRAPH_PROXY_METHOD(diversity, "diversity"); GRAPH_PROXY_METHOD(eccentricity, "eccentricity"); GRAPH_PROXY_METHOD(get_shortest_paths, "get_shortest_paths"); GRAPH_PROXY_METHOD_PP(incident, "incident", _convert_to_edge_list); GRAPH_PROXY_METHOD(indegree, "indegree"); GRAPH_PROXY_METHOD(is_minimal_separator, "is_minimal_separator"); GRAPH_PROXY_METHOD(is_separator, "is_separator"); GRAPH_PROXY_METHOD_PP(neighbors, "neighbors", _convert_to_vertex_list); GRAPH_PROXY_METHOD(outdegree, "outdegree"); GRAPH_PROXY_METHOD(pagerank, "pagerank"); GRAPH_PROXY_METHOD_PP(predecessors, "predecessors", _convert_to_vertex_list); GRAPH_PROXY_METHOD(personalized_pagerank, "personalized_pagerank"); GRAPH_PROXY_METHOD(shortest_paths, "shortest_paths"); GRAPH_PROXY_METHOD(strength, "strength"); GRAPH_PROXY_METHOD_PP(successors, "successors", _convert_to_vertex_list); #undef GRAPH_PROXY_METHOD #define GRAPH_PROXY_METHOD_SPEC(FUNC, METHODNAME) \ {METHODNAME, (PyCFunction)igraphmodule_Vertex_##FUNC, METH_VARARGS | METH_KEYWORDS, \ "Proxy method to L{Graph." METHODNAME "()}\n\n" \ "This method calls the C{" METHODNAME "()} method of the L{Graph} class " \ "with this vertex as the first argument, and returns the result.\n\n"\ "@see: L{Graph." METHODNAME "()} for details."} #define GRAPH_PROXY_METHOD_SPEC_2(FUNC, METHODNAME, METHODNAME_IN_GRAPH) \ {METHODNAME, (PyCFunction)igraphmodule_Vertex_##FUNC, METH_VARARGS | METH_KEYWORDS, \ "Proxy method to L{Graph." METHODNAME_IN_GRAPH "()}\n\n" \ "This method calls the C{" METHODNAME_IN_GRAPH "} method of the L{Graph} class " \ "with this vertex as the first argument, and returns the result.\n\n"\ "@see: L{Graph." METHODNAME_IN_GRAPH "()} for details."} /** * \ingroup python_interface_vertex * Method table for the \c igraph.Vertex object */ PyMethodDef igraphmodule_Vertex_methods[] = { {"attributes", (PyCFunction)igraphmodule_Vertex_attributes, METH_NOARGS, "attributes()\n--\n\n" "Returns a dict of attribute names and values for the vertex\n" }, {"attribute_names", (PyCFunction)igraphmodule_Vertex_attribute_names, METH_NOARGS, "attribute_names()\n--\n\n" "Returns the list of vertex attribute names\n" }, {"update_attributes", (PyCFunction)igraphmodule_Vertex_update_attributes, METH_VARARGS | METH_KEYWORDS, "update_attributes(E, **F)\n--\n\n" "Updates the attributes of the vertex from dict/iterable E and F.\n\n" "If E has a C{keys()} method, it does: C{for k in E: self[k] = E[k]}.\n" "If E lacks a C{keys()} method, it does: C{for (k, v) in E: self[k] = v}.\n" "In either case, this is followed by: C{for k in F: self[k] = F[k]}.\n\n" "This method thus behaves similarly to the C{update()} method of Python\n" "dictionaries." }, {"all_edges", (PyCFunction)igraphmodule_Vertex_all_edges, METH_NOARGS, "Proxy method to L{Graph.incident(..., mode=\"all\")}\n\n" \ "This method calls the incident() method of the L{Graph} class " \ "with this vertex as the first argument and \"all\" as the mode " \ "argument, and returns the result.\n\n"\ "@see: L{Graph.incident()} for details."}, {"in_edges", (PyCFunction)igraphmodule_Vertex_in_edges, METH_NOARGS, "Proxy method to L{Graph.incident(..., mode=\"in\")}\n\n" \ "This method calls the incident() method of the L{Graph} class " \ "with this vertex as the first argument and \"in\" as the mode " \ "argument, and returns the result.\n\n"\ "@see: L{Graph.incident()} for details."}, {"out_edges", (PyCFunction)igraphmodule_Vertex_out_edges, METH_NOARGS, "Proxy method to L{Graph.incident(..., mode=\"out\")}\n\n" \ "This method calls the incident() method of the L{Graph} class " \ "with this vertex as the first argument and \"out\" as the mode " \ "argument, and returns the result.\n\n"\ "@see: L{Graph.incident()} for details."}, GRAPH_PROXY_METHOD_SPEC(betweenness, "betweenness"), GRAPH_PROXY_METHOD_SPEC(closeness, "closeness"), GRAPH_PROXY_METHOD_SPEC(constraint, "constraint"), GRAPH_PROXY_METHOD_SPEC(degree, "degree"), GRAPH_PROXY_METHOD_SPEC_2(delete, "delete", "delete_vertices"), GRAPH_PROXY_METHOD_SPEC(diversity, "diversity"), GRAPH_PROXY_METHOD_SPEC(eccentricity, "eccentricity"), GRAPH_PROXY_METHOD_SPEC(get_shortest_paths, "get_shortest_paths"), GRAPH_PROXY_METHOD_SPEC(incident, "incident"), GRAPH_PROXY_METHOD_SPEC(indegree, "indegree"), GRAPH_PROXY_METHOD_SPEC(is_minimal_separator, "is_minimal_separator"), GRAPH_PROXY_METHOD_SPEC(is_separator, "is_separator"), GRAPH_PROXY_METHOD_SPEC(neighbors, "neighbors"), GRAPH_PROXY_METHOD_SPEC(outdegree, "outdegree"), GRAPH_PROXY_METHOD_SPEC(pagerank, "pagerank"), GRAPH_PROXY_METHOD_SPEC(predecessors, "predecessors"), GRAPH_PROXY_METHOD_SPEC(personalized_pagerank, "personalized_pagerank"), GRAPH_PROXY_METHOD_SPEC(shortest_paths, "shortest_paths"), GRAPH_PROXY_METHOD_SPEC(strength, "strength"), GRAPH_PROXY_METHOD_SPEC(successors, "successors"), {NULL} }; #undef GRAPH_PROXY_METHOD_SPEC #undef GRAPH_PROXY_METHOD_SPEC_2 /** \ingroup python_interface_vertex * This structure is the collection of functions necessary to implement * the vertex as a mapping (i.e. to allow the retrieval and setting of * igraph attributes in Python as if it were of a Python mapping type) */ PyMappingMethods igraphmodule_Vertex_as_mapping = { // returns the number of vertex attributes (lenfunc)igraphmodule_Vertex_attribute_count, // returns an attribute by name (binaryfunc)igraphmodule_Vertex_get_attribute, // sets an attribute by name (objobjargproc)igraphmodule_Vertex_set_attribute }; /** * \ingroup python_interface_vertex * Getter/setter table for the \c igraph.Vertex object */ PyGetSetDef igraphmodule_Vertex_getseters[] = { {"index", (getter)igraphmodule_Vertex_get_index, NULL, "Index of the vertex", NULL }, {"graph", (getter)igraphmodule_Vertex_get_graph, NULL, "The graph the vertex belongs to", NULL }, {NULL} }; /** \ingroup python_interface_vertex * Python type object referencing the methods Python calls when it performs various operations on * a vertex of a graph */ PyTypeObject igraphmodule_VertexType = { PyVarObject_HEAD_INIT(0, 0) "igraph.Vertex", /* tp_name */ sizeof(igraphmodule_VertexObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)igraphmodule_Vertex_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare (2.x) / tp_reserved (3.x) */ (reprfunc)igraphmodule_Vertex_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ &igraphmodule_Vertex_as_mapping, /* tp_as_mapping */ (hashfunc)igraphmodule_Vertex_hash, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ "Class representing a single vertex in a graph.\n\n" "The vertex is referenced by its index, so if the underlying graph\n" "changes, the semantics of the vertex object might change as well\n" "(if the vertex indices are altered in the original graph).\n\n" "The attributes of the vertex can be accessed by using the vertex\n" "as a hash:\n\n" " >>> v[\"color\"] = \"red\" #doctest: +SKIP\n" " >>> print(v[\"color\"]) #doctest: +SKIP\n" " red\n", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc)igraphmodule_Vertex_richcompare, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ igraphmodule_Vertex_methods, /* tp_methods */ 0, /* tp_members */ igraphmodule_Vertex_getseters, /* tp_getset */ }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/vertexobject.h0000644000175100001710000000377700000000000020676 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_VERTEXOBJECT_H #define PYTHON_VERTEXOBJECT_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_vertex * \brief A structure representing a vertex of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_integer_t idx; long hash; } igraphmodule_VertexObject; int igraphmodule_Vertex_clear(igraphmodule_VertexObject *self); void igraphmodule_Vertex_dealloc(igraphmodule_VertexObject* self); int igraphmodule_Vertex_Check(PyObject *obj); int igraphmodule_Vertex_Validate(PyObject *obj); PyObject* igraphmodule_Vertex_New(igraphmodule_GraphObject *gref, igraph_integer_t idx); PyObject* igraphmodule_Vertex_repr(igraphmodule_VertexObject *self); PyObject* igraphmodule_Vertex_attributes(igraphmodule_VertexObject* self); PyObject* igraphmodule_Vertex_attribute_names(igraphmodule_VertexObject* self); igraph_integer_t igraphmodule_Vertex_get_index_igraph_integer(igraphmodule_VertexObject* self); long igraphmodule_Vertex_get_index_long(igraphmodule_VertexObject* self); PyObject* igraphmodule_Vertex_update_attributes(PyObject* self, PyObject* args, PyObject* kwds); extern PyTypeObject igraphmodule_VertexType; #endif ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/vertexseqobject.c0000644000175100001710000010603600000000000021372 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* vim: set ts=2 sts=2 sw=2 et: */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "attributes.h" #include "common.h" #include "convert.h" #include "error.h" #include "pyhelpers.h" #include "vertexseqobject.h" #include "vertexobject.h" #define GET_GRAPH(obj) (((igraphmodule_GraphObject*)obj->gref)->g) /** * \ingroup python_interface * \defgroup python_interface_vertexseq Vertex sequence object */ PyTypeObject igraphmodule_VertexSeqType; /** * \ingroup python_interface_vertexseq * \brief Allocate a new vertex sequence object for a given graph * \return the allocated PyObject */ PyObject* igraphmodule_VertexSeq_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) { igraphmodule_VertexSeqObject *o; o=(igraphmodule_VertexSeqObject*)PyType_GenericNew(subtype, args, kwds); if (o == NULL) return NULL; igraph_vs_all(&o->vs); o->gref=0; o->weakreflist=0; RC_ALLOC("VertexSeq", o); return (PyObject*)o; } /** * \ingroup python_interface_vertexseq * \brief Copies a vertex sequence object * \return the copied PyObject */ igraphmodule_VertexSeqObject* igraphmodule_VertexSeq_copy(igraphmodule_VertexSeqObject* o) { igraphmodule_VertexSeqObject *copy; copy=(igraphmodule_VertexSeqObject*)PyType_GenericNew(Py_TYPE(o), 0, 0); if (copy == NULL) return NULL; if (igraph_vs_type(&o->vs) == IGRAPH_VS_VECTOR) { igraph_vector_t v; if (igraph_vector_copy(&v, o->vs.data.vecptr)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_vs_vector_copy(©->vs, &v)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return 0; } igraph_vector_destroy(&v); } else { copy->vs = o->vs; } copy->gref = o->gref; if (o->gref) Py_INCREF(o->gref); RC_ALLOC("VertexSeq(copy)", copy); return copy; } /** * \ingroup python_interface_vertexseq * \brief Initialize a new vertex sequence object for a given graph * \return the initialized PyObject */ int igraphmodule_VertexSeq_init(igraphmodule_VertexSeqObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = { "graph", "vertices", NULL }; PyObject *g, *vsobj=Py_None; igraph_vs_t vs; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O", kwlist, &igraphmodule_GraphType, &g, &vsobj)) return -1; if (vsobj == Py_None) { /* If vs is None, we are selecting all the vertices */ igraph_vs_all(&vs); } else if (PyLong_Check(vsobj)) { /* We selected a single vertex */ long int idx = PyLong_AsLong(vsobj); if (idx < 0 || idx >= igraph_vcount(&((igraphmodule_GraphObject*)g)->g)) { PyErr_SetString(PyExc_ValueError, "vertex index out of range"); return -1; } igraph_vs_1(&vs, (igraph_integer_t)idx); } else { igraph_vector_t v; igraph_integer_t n = igraph_vcount(&((igraphmodule_GraphObject*)g)->g); if (igraphmodule_PyObject_to_vector_t(vsobj, &v, 1)) return -1; if (!igraph_vector_isininterval(&v, 0, n-1)) { igraph_vector_destroy(&v); PyErr_SetString(PyExc_ValueError, "vertex index out of range"); return -1; } if (igraph_vs_vector_copy(&vs, &v)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return -1; } igraph_vector_destroy(&v); } self->vs = vs; Py_INCREF(g); self->gref = (igraphmodule_GraphObject*)g; return 0; } /** * \ingroup python_interface_vertexseq * \brief Deallocates a Python representation of a given vertex sequence object */ void igraphmodule_VertexSeq_dealloc(igraphmodule_VertexSeqObject* self) { if (self->weakreflist != NULL) PyObject_ClearWeakRefs((PyObject *) self); if (self->gref) { igraph_vs_destroy(&self->vs); Py_DECREF(self->gref); self->gref=0; } Py_TYPE(self)->tp_free((PyObject*)self); RC_DEALLOC("VertexSeq", self); } /** * \ingroup python_interface_vertexseq * \brief Returns the length of the sequence */ int igraphmodule_VertexSeq_sq_length(igraphmodule_VertexSeqObject* self) { igraph_t *g; igraph_integer_t result; if (!self->gref) return -1; g=&GET_GRAPH(self); if (igraph_vs_size(g, &self->vs, &result)) { igraphmodule_handle_igraph_error(); return -1; } return (int)result; } /** * \ingroup python_interface_vertexseq * \brief Returns the item at the given index in the sequence */ PyObject* igraphmodule_VertexSeq_sq_item(igraphmodule_VertexSeqObject* self, Py_ssize_t i) { igraph_t *g; igraph_integer_t idx = -1; if (!self->gref) return NULL; g=&GET_GRAPH(self); switch (igraph_vs_type(&self->vs)) { case IGRAPH_VS_ALL: if (i < 0) { i = igraph_vcount(g) + i; } if (i >= 0 && i < igraph_vcount(g)) { idx = (igraph_integer_t)i; } break; case IGRAPH_VS_VECTOR: case IGRAPH_VS_VECTORPTR: if (i < 0) { i = igraph_vector_size(self->vs.data.vecptr) + i; } if (i >= 0 && i < igraph_vector_size(self->vs.data.vecptr)) { idx = (igraph_integer_t)VECTOR(*self->vs.data.vecptr)[i]; } break; case IGRAPH_VS_1: if (i == 0 || i == -1) { idx = self->vs.data.vid; } break; case IGRAPH_VS_SEQ: if (i < 0) { i = self->vs.data.seq.to - self->vs.data.seq.from + i; } if (i >= 0 && i < self->vs.data.seq.to - self->vs.data.seq.from) { idx = self->vs.data.seq.from + (igraph_integer_t)i; } break; /* TODO: IGRAPH_VS_ADJ, IGRAPH_VS_NONADJ - someday :) They are unused yet in the Python interface */ } if (idx < 0) { PyErr_SetString(PyExc_IndexError, "vertex index out of range"); return NULL; } return igraphmodule_Vertex_New(self->gref, idx); } /** \ingroup python_interface_vertexseq * \brief Returns the list of attribute names */ PyObject* igraphmodule_VertexSeq_attribute_names(igraphmodule_VertexSeqObject* self) { return igraphmodule_Graph_vertex_attributes(self->gref); } /** \ingroup python_interface_vertexseq * \brief Returns the list of values for a given attribute */ PyObject* igraphmodule_VertexSeq_get_attribute_values(igraphmodule_VertexSeqObject* self, PyObject* o) { igraphmodule_GraphObject *gr = self->gref; PyObject *result=0, *values, *item; long int i, n; if (!igraphmodule_attribute_name_check(o)) return 0; PyErr_Clear(); values=PyDict_GetItem(ATTR_STRUCT_DICT(&gr->g)[ATTRHASH_IDX_VERTEX], o); if (!values) { PyErr_SetString(PyExc_KeyError, "Attribute does not exist"); return NULL; } else if (PyErr_Occurred()) return NULL; switch (igraph_vs_type(&self->vs)) { case IGRAPH_VS_NONE: n = 0; result = PyList_New(0); break; case IGRAPH_VS_ALL: n = PyList_Size(values); result = PyList_New(n); if (!result) return 0; for (i=0; ivs.data.vecptr); result = PyList_New(n); if (!result) return 0; for (i=0; ivs.data.vecptr)[i]); Py_INCREF(item); PyList_SET_ITEM(result, i, item); } break; case IGRAPH_VS_SEQ: n = self->vs.data.seq.to - self->vs.data.seq.from; result = PyList_New(n); if (!result) return 0; for (i=0; ivs.data.seq.from+i); Py_INCREF(item); PyList_SET_ITEM(result, i, item); } break; default: PyErr_SetString(PyExc_RuntimeError, "invalid vertex selector"); } return result; } PyObject* igraphmodule_VertexSeq_get_attribute_values_mapping(igraphmodule_VertexSeqObject *self, PyObject *o) { long int index; /* Handle integer indices according to the sequence protocol */ if (PyIndex_Check(o)) { index = PyNumber_AsSsize_t(o, 0); return igraphmodule_VertexSeq_sq_item(self, index); } /* Handle strings according to the mapping protocol */ if (PyBaseString_Check(o)) { return igraphmodule_VertexSeq_get_attribute_values(self, o); } /* Handle iterables and slices by calling the select() method */ if (PySlice_Check(o) || PyObject_HasAttrString(o, "__iter__")) { PyObject *result, *args; args = PyTuple_Pack(1, o); if (!args) { return NULL; } result = igraphmodule_VertexSeq_select(self, args); Py_DECREF(args); return result; } /* Handle everything else according to the mapping protocol */ return igraphmodule_VertexSeq_get_attribute_values(self, o); } /** \ingroup python_interface_vertexseq * \brief Sets the list of values for a given attribute */ int igraphmodule_VertexSeq_set_attribute_values_mapping(igraphmodule_VertexSeqObject* self, PyObject* attrname, PyObject* values) { PyObject *dict, *list, *item; igraphmodule_GraphObject *gr; igraph_vector_t vs; long i, j, n, no_of_nodes; gr = self->gref; dict = ATTR_STRUCT_DICT(&gr->g)[ATTRHASH_IDX_VERTEX]; if (!igraphmodule_attribute_name_check(attrname)) return -1; if (PyUnicode_IsEqualToASCIIString(attrname, "name")) igraphmodule_invalidate_vertex_name_index(&gr->g); if (values == 0) { if (igraph_vs_type(&self->vs) == IGRAPH_VS_ALL) return PyDict_DelItem(dict, attrname); PyErr_SetString(PyExc_TypeError, "can't delete attribute from a vertex sequence not representing the whole graph"); return -1; } if (PyUnicode_Check(values) || !PySequence_Check(values)) { /* If values is a string or not a sequence, we construct a list with a * single element (the value itself) and then call ourselves again */ int result; PyObject *newList = PyList_New(1); if (newList == 0) return -1; Py_INCREF(values); PyList_SET_ITEM(newList, 0, values); /* reference stolen here */ result = igraphmodule_VertexSeq_set_attribute_values_mapping(self, attrname, newList); Py_DECREF(newList); return result; } n=PySequence_Size(values); if (n<0) return -1; if (igraph_vs_type(&self->vs) == IGRAPH_VS_ALL) { no_of_nodes = (long)igraph_vcount(&gr->g); if (n == 0 && no_of_nodes > 0) { PyErr_SetString(PyExc_ValueError, "sequence must not be empty"); return -1; } /* Check if we already have attributes with the given name */ list = PyDict_GetItem(dict, attrname); if (list != 0) { /* Yes, we have. Modify its items to the items found in values */ for (i=0, j=0; ig, self->vs, &vs)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&vs); return -1; } no_of_nodes = (long)igraph_vector_size(&vs); if (n == 0 && no_of_nodes > 0) { PyErr_SetString(PyExc_ValueError, "sequence must not be empty"); igraph_vector_destroy(&vs); return -1; } /* Check if we already have attributes with the given name */ list = PyDict_GetItem(dict, attrname); if (list != 0) { /* Yes, we have. Modify its items to the items found in values */ for (i=0, j=0; ig); list = PyList_New(n2); if (list == 0) { igraph_vector_destroy(&vs); return -1; } for (i=0; igref->g, item, &i)) return NULL; /* We now have the ID of the vertex in the graph. If the vertex sequence * itself represents the full vertex sequence of the graph, we can return * here. If not, we have to check whether the vertex sequence contains this * ID or not. */ if (igraph_vs_is_all(&self->vs)) return PySequence_GetItem((PyObject*)self, i); if (igraph_vit_create(&self->gref->g, self->vs, &vit)) { igraphmodule_handle_igraph_error(); return NULL; } for (n = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), n++) { if (IGRAPH_VIT_GET(vit) == i) { igraph_vit_destroy(&vit); return PySequence_GetItem((PyObject*)self, n); } } igraph_vit_destroy(&vit); PyErr_SetString(PyExc_ValueError, "vertex with the given name exists but not in the current sequence"); return NULL; } PyErr_SetString(PyExc_IndexError, "no such vertex"); return NULL; } /** * \ingroup python_interface_vertexseq * \brief Selects a subset of the vertex sequence based on some criteria */ PyObject* igraphmodule_VertexSeq_select(igraphmodule_VertexSeqObject *self, PyObject *args) { igraphmodule_VertexSeqObject *result; igraphmodule_GraphObject *gr; igraph_integer_t igraph_idx; igraph_bool_t working_on_whole_graph = igraph_vs_is_all(&self->vs); igraph_vector_t v, v2; long i, j, n, m; gr = self->gref; result = igraphmodule_VertexSeq_copy(self); if (result == 0) return NULL; /* First, filter by positional arguments */ n = PyTuple_Size(args); for (i = 0; i < n; i++) { PyObject *item = PyTuple_GET_ITEM(args, i); if (item == Py_None) { /* None means: select nothing */ igraph_vs_destroy(&result->vs); igraph_vs_none(&result->vs); /* We can simply bail out here */ return (PyObject*) result; } else if (PyCallable_Check(item)) { /* Call the callable for every vertex in the current sequence to * determine what's up */ igraph_bool_t was_excluded = 0; igraph_vector_t v; if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } m = PySequence_Size((PyObject*)result); for (j = 0; j < m; j++) { PyObject *vertex = PySequence_GetItem((PyObject*)result, j); PyObject *call_result; if (vertex == 0) { Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } call_result = PyObject_CallFunctionObjArgs(item, vertex, NULL); if (call_result == 0) { Py_DECREF(vertex); Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } if (PyObject_IsTrue(call_result)) { igraph_vector_push_back(&v, igraphmodule_Vertex_get_index_long((igraphmodule_VertexObject*)vertex)); } else { was_excluded = 1; } Py_DECREF(call_result); Py_DECREF(vertex); } if (was_excluded) { igraph_vs_destroy(&result->vs); if (igraph_vs_vector_copy(&result->vs, &v)) { Py_DECREF(result); igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return NULL; } } igraph_vector_destroy(&v); } else if (PyLong_Check(item)) { /* Integers are treated specially: from now on, all remaining items * in the argument list must be integers and they will be used together * to restrict the vertex set. Integers are interpreted as indices on the * vertex set and NOT on the original, untouched vertex sequence of the * graph */ if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (!working_on_whole_graph) { /* Extract the current vertex sequence into a vector */ if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return 0; } if (igraph_vs_as_vector(&gr->g, self->vs, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); } else { /* v2 left uninitialized, we are not going to use it as it would * simply contain integers from 0 to vcount(g)-1 */ m = igraph_vcount(&gr->g); } for (; i < n; i++) { PyObject *item2 = PyTuple_GET_ITEM(args, i); long idx; if (!PyLong_Check(item2)) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "vertex indices expected"); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } idx = PyLong_AsLong(item2); if (idx >= m || idx < 0) { PyErr_SetString(PyExc_ValueError, "vertex index out of range"); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } if (igraph_vector_push_back(&v, working_on_whole_graph ? idx : VECTOR(v2)[idx])) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } } if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } igraph_vs_destroy(&result->vs); if (igraph_vs_vector_copy(&result->vs, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } else { /* Iterators, slices and everything that was not handled directly */ PyObject *iter=0, *item2; /* Allocate stuff */ if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); Py_DECREF(result); return 0; } if (!working_on_whole_graph) { /* Extract the current vertex sequence into a vector */ if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); Py_DECREF(result); igraphmodule_handle_igraph_error(); return 0; } if (igraph_vs_as_vector(&gr->g, self->vs, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); Py_DECREF(result); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); } else { /* v2 left uninitialized, we are not going to use it as it would * simply contain integers from 0 to vcount(g)-1 */ m = igraph_vcount(&gr->g); } /* Create an appropriate iterator */ if (PySlice_Check(item)) { /* Create an iterator from the slice (which is not iterable by default) */ Py_ssize_t start, stop, step, sl; PyObject* range; igraph_bool_t ok; ok = (PySlice_GetIndicesEx(item, m, &start, &stop, &step, &sl) == 0); if (ok) { range = igraphmodule_PyRange_create(start, stop, step); ok = (range != 0); } if (ok) { iter = PyObject_GetIter(range); Py_DECREF(range); ok = (iter != 0); } if (!ok) { igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } PyErr_SetString(PyExc_TypeError, "error while converting slice to iterator"); Py_DECREF(result); return 0; } } else { /* Simply create the iterator corresponding to the object */ iter = PyObject_GetIter(item); } /* Did we manage to get an iterator? */ if (iter == 0) { igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } PyErr_SetString(PyExc_TypeError, "invalid vertex filter among positional arguments"); Py_DECREF(result); return 0; } /* Do the iteration */ while ((item2 = PyIter_Next(iter)) != 0) { if (igraphmodule_PyObject_to_integer_t(item2, &igraph_idx)) { /* We simply ignore elements that we don't know */ Py_DECREF(item2); } else { Py_DECREF(item2); if (igraph_idx >= m || igraph_idx < 0) { PyErr_SetString(PyExc_ValueError, "vertex index out of range"); Py_DECREF(result); Py_DECREF(iter); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } if (igraph_vector_push_back(&v, working_on_whole_graph ? igraph_idx : VECTOR(v2)[(long int) igraph_idx])) { Py_DECREF(result); Py_DECREF(iter); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } return NULL; } } } /* Deallocate stuff */ if (!working_on_whole_graph) { igraph_vector_destroy(&v2); } Py_DECREF(iter); if (PyErr_Occurred()) { igraph_vector_destroy(&v); Py_DECREF(result); return 0; } igraph_vs_destroy(&result->vs); if (igraph_vs_vector_copy(&result->vs, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } } return (PyObject*)result; } /** * \ingroup python_interface_vertexseq * Converts a vertex sequence to an igraph vector containing the corresponding * vertex indices. The vector MUST be initialized and will be resized if needed. * \return 0 if everything was ok, 1 otherwise */ int igraphmodule_VertexSeq_to_vector_t(igraphmodule_VertexSeqObject *self, igraph_vector_t *v) { return igraph_vs_as_vector(&self->gref->g, self->vs, v); } /** * \ingroup python_interface_vertexseq * Returns the graph where the vertex sequence belongs */ PyObject* igraphmodule_VertexSeq_get_graph(igraphmodule_VertexSeqObject* self, void* closure) { Py_INCREF(self->gref); return (PyObject*)self->gref; } /** * \ingroup python_interface_vertexseq * Returns the indices of the vertices in this vertex sequence */ PyObject* igraphmodule_VertexSeq_get_indices(igraphmodule_VertexSeqObject* self, void* closure) { igraphmodule_GraphObject *gr = self->gref; igraph_vector_t vs; PyObject *result; if (igraph_vector_init(&vs, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_vs_as_vector(&gr->g, self->vs, &vs)) { igraphmodule_handle_igraph_error(); igraph_vector_destroy(&vs); return 0; } result = igraphmodule_vector_t_to_PyList(&vs, IGRAPHMODULE_TYPE_INT); igraph_vector_destroy(&vs); return result; } /** * \ingroup python_interface_vertexseq * Returns the internal dictionary mapping vertex names to vertex IDs. */ PyObject* igraphmodule_VertexSeq__name_index(igraphmodule_VertexSeqObject* self, void* closure) { igraphmodule_GraphObject *gr = self->gref; PyObject* result = ATTR_NAME_INDEX(&gr->g); if (result == 0) Py_RETURN_NONE; Py_INCREF(result); return result; } /** * \ingroup python_interface_vertexseq * Re-creates the dictionary that maps vertex names to vertex IDs. */ PyObject* igraphmodule_VertexSeq__reindex_names(igraphmodule_VertexSeqObject* self) { igraphmodule_index_vertex_names(&self->gref->g, 1); Py_RETURN_NONE; } /** * \ingroup python_interface_vertexseq * Method table for the \c igraph.VertexSeq object */ PyMethodDef igraphmodule_VertexSeq_methods[] = { {"attribute_names", (PyCFunction)igraphmodule_VertexSeq_attribute_names, METH_NOARGS, "attribute_names()\n--\n\n" "Returns the attribute name list of the graph's vertices\n" }, {"find", (PyCFunction)igraphmodule_VertexSeq_find, METH_VARARGS, "find(condition)\n--\n\n" "For internal use only.\n" }, {"get_attribute_values", (PyCFunction)igraphmodule_VertexSeq_get_attribute_values, METH_O, "get_attribute_values(attrname)\n--\n\n" "Returns the value of a given vertex attribute for all vertices in a list.\n\n" "The values stored in the list are exactly the same objects that are stored\n" "in the vertex attribute, meaning that in the case of mutable objects,\n" "the modification of the list element does affect the attribute stored in\n" "the vertex. In the case of immutable objects, modification of the list\n" "does not affect the attribute values.\n\n" "@param attrname: the name of the attribute\n" }, {"set_attribute_values", (PyCFunction)igraphmodule_VertexSeq_set_attribute_values, METH_VARARGS | METH_KEYWORDS, "set_attribute_values(attrname, values)\n--\n\n" "Sets the value of a given vertex attribute for all vertices\n\n" "@param attrname: the name of the attribute\n" "@param values: the new attribute values in a list\n" }, {"select", (PyCFunction)igraphmodule_VertexSeq_select, METH_VARARGS, "select(*args, **kwds)\n--\n\n" "For internal use only.\n" }, {"_reindex_names", (PyCFunction)igraphmodule_VertexSeq__reindex_names, METH_NOARGS, "_reindex_names()\n--\n\n" "Re-creates the dictionary that maps vertex names to IDs.\n\n" "For internal use only.\n" }, {NULL} }; /** * \ingroup python_interface_vertexseq * This is the collection of functions necessary to implement the * vertex sequence as a real sequence (e.g. allowing to reference * vertices by indices) */ static PySequenceMethods igraphmodule_VertexSeq_as_sequence = { (lenfunc)igraphmodule_VertexSeq_sq_length, 0, /* sq_concat */ 0, /* sq_repeat */ (ssizeargfunc)igraphmodule_VertexSeq_sq_item, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ 0, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; /** * \ingroup python_interface_vertexseq * This is the collection of functions necessary to implement the * vertex sequence as a mapping (which maps attribute names to values) */ static PyMappingMethods igraphmodule_VertexSeq_as_mapping = { /* this must be null, otherwise it f.cks up sq_length when inherited */ (lenfunc) 0, /* returns the values of an attribute by name */ (binaryfunc) igraphmodule_VertexSeq_get_attribute_values_mapping, /* sets the values of an attribute by name */ (objobjargproc) igraphmodule_VertexSeq_set_attribute_values_mapping, }; /** * \ingroup python_interface_vertexseq * Getter/setter table for the \c igraph.VertexSeq object */ PyGetSetDef igraphmodule_VertexSeq_getseters[] = { {"graph", (getter)igraphmodule_VertexSeq_get_graph, NULL, "The graph the vertex sequence belongs to", NULL, }, {"indices", (getter)igraphmodule_VertexSeq_get_indices, NULL, "The vertex indices in this vertex sequence", NULL, }, {"_name_index", (getter)igraphmodule_VertexSeq__name_index, NULL, "The internal index mapping vertex names to IDs", NULL }, {NULL} }; /** \ingroup python_interface_vertexseq * Python type object referencing the methods Python calls when it performs various operations on * a vertex sequence of a graph */ PyTypeObject igraphmodule_VertexSeqType = { PyVarObject_HEAD_INIT(0, 0) "igraph._igraph.VertexSeq", /* tp_name */ sizeof(igraphmodule_VertexSeqObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)igraphmodule_VertexSeq_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare (2.x) / tp_reserved (3.x) */ 0, /* tp_repr */ 0, /* tp_as_number */ &igraphmodule_VertexSeq_as_sequence, /* tp_as_sequence */ &igraphmodule_VertexSeq_as_mapping, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ "Low-level representation of a vertex sequence.\n\n" /* tp_doc */ "Don't use it directly, use L{igraph.VertexSeq} instead.\n\n" "@deffield ref: Reference", 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(igraphmodule_VertexSeqObject, weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ igraphmodule_VertexSeq_methods, /* tp_methods */ 0, /* tp_members */ igraphmodule_VertexSeq_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) igraphmodule_VertexSeq_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) igraphmodule_VertexSeq_new, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weakreflist */ }; ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/_igraph/vertexseqobject.h0000644000175100001710000000371600000000000021400 0ustar00runnerdocker00000000000000/* -*- mode: C -*- */ /* IGraph library. Copyright (C) 2006-2012 Tamas Nepusz This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef PYTHON_VERTEXSEQOBJECT_H #define PYTHON_VERTEXSEQOBJECT_H #include "preamble.h" #include "graphobject.h" /** * \ingroup python_interface_vertexseq * \brief A structure representing the vertex sequence of a graph */ typedef struct { PyObject_HEAD igraphmodule_GraphObject* gref; igraph_vs_t vs; PyObject* weakreflist; } igraphmodule_VertexSeqObject; PyObject* igraphmodule_VertexSeq_new(PyTypeObject *subtype, PyObject* args, PyObject* kwds); int igraphmodule_VertexSeq_init(igraphmodule_VertexSeqObject* self, PyObject* args, PyObject* kwds); void igraphmodule_VertexSeq_dealloc(igraphmodule_VertexSeqObject* self); int igraphmodule_VertexSeq_sq_length(igraphmodule_VertexSeqObject *self); PyObject* igraphmodule_VertexSeq_find(igraphmodule_VertexSeqObject *self, PyObject *args); PyObject* igraphmodule_VertexSeq_select(igraphmodule_VertexSeqObject *self, PyObject *args); int igraphmodule_VertexSeq_to_vector_t(igraphmodule_VertexSeqObject *self, igraph_vector_t *v); PyObject* igraphmodule_VertexSeq_get_graph(igraphmodule_VertexSeqObject *self, void* closure); extern PyTypeObject igraphmodule_VertexSeqType; #endif ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4071393 igraph-0.9.9/src/igraph/0000755000175100001710000000000000000000000015644 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/__init__.py0000644000175100001710000064602400000000000017771 0ustar00runnerdocker00000000000000""" IGraph library. """ __license__ = """ Copyright (C) 2006-2012 Tamás Nepusz Pázmány Péter sétány 1/a, 1117 Budapest, Hungary This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA """ from igraph._igraph import ( ADJ_DIRECTED, ADJ_LOWER, ADJ_MAX, ADJ_MIN, ADJ_PLUS, ADJ_UNDIRECTED, ADJ_UPPER, ALL, ARPACKOptions, BFSIter, BLISS_F, BLISS_FL, BLISS_FLM, BLISS_FM, BLISS_FS, BLISS_FSM, DFSIter, Edge, EdgeSeq as _EdgeSeq, GET_ADJACENCY_BOTH, GET_ADJACENCY_LOWER, GET_ADJACENCY_UPPER, GraphBase, IN, InternalError, OUT, REWIRING_SIMPLE, REWIRING_SIMPLE_LOOPS, STAR_IN, STAR_MUTUAL, STAR_OUT, STAR_UNDIRECTED, STRONG, TRANSITIVITY_NAN, TRANSITIVITY_ZERO, TREE_IN, TREE_OUT, TREE_UNDIRECTED, Vertex, VertexSeq as _VertexSeq, WEAK, arpack_options as default_arpack_options, community_to_membership, convex_hull, is_degree_sequence, is_graphical, is_graphical_degree_sequence, set_progress_handler, set_random_number_generator, set_status_handler, __igraph_version__ ) from igraph.clustering import ( Clustering, VertexClustering, Dendrogram, VertexDendrogram, Cover, VertexCover, CohesiveBlocks, compare_communities, split_join_distance, ) from igraph.cut import Cut, Flow from igraph.configuration import Configuration, init as init_configuration from igraph.drawing import BoundingBox, DefaultGraphDrawer, Plot, Point, Rectangle, plot from igraph.drawing.colors import ( Palette, GradientPalette, AdvancedGradientPalette, RainbowPalette, PrecalculatedPalette, ClusterColoringPalette, color_name_to_rgb, color_name_to_rgba, hsv_to_rgb, hsva_to_rgba, hsl_to_rgb, hsla_to_rgba, rgb_to_hsv, rgba_to_hsva, rgb_to_hsl, rgba_to_hsla, palettes, known_colors, ) from igraph.datatypes import Matrix, DyadCensus, TriadCensus, UniqueIdGenerator from igraph.formula import construct_graph_from_formula from igraph.layout import Layout from igraph.matching import Matching from igraph.operators import disjoint_union, union, intersection from igraph.statistics import ( FittedPowerLaw, Histogram, RunningMean, mean, median, percentile, quantile, power_law_fit, ) from igraph.summary import GraphSummary, summary from igraph.utils import ( dbl_epsilon, multidict, named_temporary_file, numpy_to_contiguous_memoryview, rescale, safemin, safemax, ) from igraph.version import __version__, __version_info__ from igraph.sparse_matrix import ( _graph_from_sparse_matrix, _graph_from_weighted_sparse_matrix, ) import os import math import gzip import sys import operator from collections import defaultdict from shutil import copyfileobj from warnings import warn def deprecated(message): """Prints a warning message related to the deprecation of some igraph feature.""" warn(message, DeprecationWarning, stacklevel=3) class Graph(GraphBase): """Generic graph. This class is built on top of L{GraphBase}, so the order of the methods in the generated API documentation is a little bit obscure: inherited methods come after the ones implemented directly in the subclass. L{Graph} provides many functions that L{GraphBase} does not, mostly because these functions are not speed critical and they were easier to implement in Python than in pure C. An example is the attribute handling in the constructor: the constructor of L{Graph} accepts three dictionaries corresponding to the graph, vertex and edge attributes while the constructor of L{GraphBase} does not. This extension was needed to make L{Graph} serializable through the C{pickle} module. L{Graph} also overrides some functions from L{GraphBase} to provide a more convenient interface; e.g., layout functions return a L{Layout} instance from L{Graph} instead of a list of coordinate pairs. Graphs can also be indexed by strings or pairs of vertex indices or vertex names. When a graph is indexed by a string, the operation translates to the retrieval, creation, modification or deletion of a graph attribute: >>> g = Graph.Full(3) >>> g["name"] = "Triangle graph" >>> g["name"] 'Triangle graph' >>> del g["name"] When a graph is indexed by a pair of vertex indices or names, the graph itself is treated as an adjacency matrix and the corresponding cell of the matrix is returned: >>> g = Graph.Full(3) >>> g.vs["name"] = ["A", "B", "C"] >>> g[1, 2] 1 >>> g["A", "B"] 1 >>> g["A", "B"] = 0 >>> g.ecount() 2 Assigning values different from zero or one to the adjacency matrix will be translated to one, unless the graph is weighted, in which case the numbers will be treated as weights: >>> g.is_weighted() False >>> g["A", "B"] = 2 >>> g["A", "B"] 1 >>> g.es["weight"] = 1.0 >>> g.is_weighted() True >>> g["A", "B"] = 2 >>> g["A", "B"] 2 >>> g.es["weight"] [1.0, 1.0, 2] """ # Some useful aliases omega = GraphBase.clique_number alpha = GraphBase.independence_number shell_index = GraphBase.coreness cut_vertices = GraphBase.articulation_points blocks = GraphBase.biconnected_components evcent = GraphBase.eigenvector_centrality vertex_disjoint_paths = GraphBase.vertex_connectivity edge_disjoint_paths = GraphBase.edge_connectivity cohesion = GraphBase.vertex_connectivity adhesion = GraphBase.edge_connectivity # Compatibility aliases shortest_paths_dijkstra = GraphBase.shortest_paths subgraph = GraphBase.induced_subgraph def __init__(self, *args, **kwds): """__init__(n=0, edges=None, directed=False, graph_attrs=None, vertex_attrs=None, edge_attrs=None) Constructs a graph from scratch. @keyword n: the number of vertices. Can be omitted, the default is zero. Note that if the edge list contains vertices with indexes larger than or equal to M{m}, then the number of vertices will be adjusted accordingly. @keyword edges: the edge list where every list item is a pair of integers. If any of the integers is larger than M{n-1}, the number of vertices is adjusted accordingly. C{None} means no edges. @keyword directed: whether the graph should be directed @keyword graph_attrs: the attributes of the graph as a dictionary. @keyword vertex_attrs: the attributes of the vertices as a dictionary. Every dictionary value must be an iterable with exactly M{n} items. @keyword edge_attrs: the attributes of the edges as a dictionary. Every dictionary value must be an iterable with exactly M{m} items where M{m} is the number of edges. """ # Pop the special __ptr keyword argument ptr = kwds.pop("__ptr", None) # Set up default values for the parameters. This should match the order # in *args kwd_order = ( "n", "edges", "directed", "graph_attrs", "vertex_attrs", "edge_attrs", ) params = [0, [], False, {}, {}, {}] # Is there any keyword argument in kwds that we don't know? If so, # freak out. unknown_kwds = set(kwds.keys()) unknown_kwds.difference_update(kwd_order) if unknown_kwds: raise TypeError( "{0}.__init__ got an unexpected keyword argument {1!r}".format( self.__class__.__name__, unknown_kwds.pop() ) ) # If the first argument is a list or any other iterable, assume that # the number of vertices were omitted args = list(args) if len(args) > 0 and hasattr(args[0], "__iter__"): args.insert(0, params[0]) # Override default parameters from args params[: len(args)] = args # Override default parameters from keywords for idx, k in enumerate(kwd_order): if k in kwds: params[idx] = kwds[k] # Now, translate the params list to argument names nverts, edges, directed, graph_attrs, vertex_attrs, edge_attrs = params # When the number of vertices is None, assume that the user meant zero if nverts is None: nverts = 0 # When 'edges' is None, assume that the user meant an empty list if edges is None: edges = [] # When 'edges' is a NumPy array or matrix, convert it into a memoryview # as the lower-level C API works with memoryviews only try: from numpy import ndarray, matrix if isinstance(edges, (ndarray, matrix)): edges = numpy_to_contiguous_memoryview(edges) except ImportError: pass # Initialize the graph if ptr: GraphBase.__init__(self, __ptr=ptr) else: GraphBase.__init__(self, nverts, edges, directed) # Set the graph attributes for key, value in graph_attrs.items(): if isinstance(key, int): key = str(key) self[key] = value # Set the vertex attributes for key, value in vertex_attrs.items(): if isinstance(key, int): key = str(key) self.vs[key] = value # Set the edge attributes for key, value in edge_attrs.items(): if isinstance(key, int): key = str(key) self.es[key] = value def add_edge(self, source, target, **kwds): """Adds a single edge to the graph. Keyword arguments (except the source and target arguments) will be assigned to the edge as attributes. The performance cost of adding a single edge or several edges to a graph is similar. Thus, when adding several edges, a single C{add_edges()} call is more efficient than multiple C{add_edge()} calls. @param source: the source vertex of the edge or its name. @param target: the target vertex of the edge or its name. @return: the newly added edge as an L{Edge} object. Use C{add_edges([(source, target)])} if you don't need the L{Edge} object and want to avoid the overhead of creating it. """ eid = self.ecount() self.add_edges([(source, target)]) edge = self.es[eid] for key, value in kwds.items(): edge[key] = value return edge def add_edges(self, es, attributes=None): """Adds some edges to the graph. @param es: the list of edges to be added. Every edge is represented with a tuple containing the vertex IDs or names of the two endpoints. Vertices are enumerated from zero. @param attributes: dict of sequences, all of length equal to the number of edges to be added, containing the attributes of the new edges. """ eid = self.ecount() res = GraphBase.add_edges(self, es) n = self.ecount() - eid if (attributes is not None) and (n > 0): for key, val in list(attributes.items()): self.es[eid:][key] = val return res def add_vertex(self, name=None, **kwds): """Adds a single vertex to the graph. Keyword arguments will be assigned as vertex attributes. Note that C{name} as a keyword argument is treated specially; if a graph has C{name} as a vertex attribute, it allows one to refer to vertices by their names in most places where igraph expects a vertex ID. @return: the newly added vertex as a L{Vertex} object. Use C{add_vertices(1)} if you don't need the L{Vertex} object and want to avoid the overhead of creating t. """ vid = self.vcount() self.add_vertices(1) vertex = self.vs[vid] for key, value in kwds.items(): vertex[key] = value if name is not None: vertex["name"] = name return vertex def add_vertices(self, n, attributes=None): """Adds some vertices to the graph. Note that if C{n} is a sequence of strings, indicating the names of the new vertices, and attributes has a key C{name}, the two conflict. In that case the attribute will be applied. @param n: the number of vertices to be added, or the name of a single vertex to be added, or a sequence of strings, each corresponding to the name of a vertex to be added. Names will be assigned to the C{name} vertex attribute. @param attributes: dict of sequences, all of length equal to the number of vertices to be added, containing the attributes of the new vertices. If n is a string (so a single vertex is added), then the values of this dict are the attributes themselves, but if n=1 then they have to be lists of length 1. """ if isinstance(n, str): # Adding a single vertex with a name m = self.vcount() result = GraphBase.add_vertices(self, 1) self.vs[m]["name"] = n if attributes is not None: for key, val in list(attributes.items()): self.vs[m][key] = val elif hasattr(n, "__iter__"): m = self.vcount() if not hasattr(n, "__len__"): names = list(n) else: names = n result = GraphBase.add_vertices(self, len(names)) if len(names) > 0: self.vs[m:]["name"] = names if attributes is not None: for key, val in list(attributes.items()): self.vs[m:][key] = val else: result = GraphBase.add_vertices(self, n) if (attributes is not None) and (n > 0): m = self.vcount() - n for key, val in list(attributes.items()): self.vs[m:][key] = val return result def as_directed(self, *args, **kwds): """Returns a directed copy of this graph. Arguments are passed on to L{to_directed()} that is invoked on the copy. """ copy = self.copy() copy.to_directed(*args, **kwds) return copy def as_undirected(self, *args, **kwds): """Returns an undirected copy of this graph. Arguments are passed on to L{to_undirected()} that is invoked on the copy. """ copy = self.copy() copy.to_undirected(*args, **kwds) return copy def delete_edges(self, *args, **kwds): """Deletes some edges from the graph. The set of edges to be deleted is determined by the positional and keyword arguments. If the function is called without any arguments, all edges are deleted. If any keyword argument is present, or the first positional argument is callable, an edge sequence is derived by calling L{EdgeSeq.select} with the same positional and keyword arguments. Edges in the derived edge sequence will be removed. Otherwise the first positional argument is considered as follows: - C{None} - deletes all edges (deprecated since 0.8.3) - a single integer - deletes the edge with the given ID - a list of integers - deletes the edges denoted by the given IDs - a list of 2-tuples - deletes the edges denoted by the given source-target vertex pairs. When multiple edges are present between a given source-target vertex pair, only one is removed. @deprecated: C{delete_edges(None)} has been replaced by C{delete_edges()} - with no arguments - since igraph 0.8.3. """ if len(args) == 0 and len(kwds) == 0: return GraphBase.delete_edges(self) if len(kwds) > 0 or (callable(args[0]) and not isinstance(args[0], EdgeSeq)): edge_seq = self.es(*args, **kwds) else: edge_seq = args[0] return GraphBase.delete_edges(self, edge_seq) def indegree(self, *args, **kwds): """Returns the in-degrees in a list. See L{degree} for possible arguments. """ kwds["mode"] = IN return self.degree(*args, **kwds) def outdegree(self, *args, **kwds): """Returns the out-degrees in a list. See L{degree} for possible arguments. """ kwds["mode"] = OUT return self.degree(*args, **kwds) def all_st_cuts(self, source, target): """\ Returns all the cuts between the source and target vertices in a directed graph. This function lists all edge-cuts between a source and a target vertex. Every cut is listed exactly once. @param source: the source vertex ID @param target: the target vertex ID @return: a list of L{Cut} objects. @newfield ref: Reference @ref: JS Provan and DR Shier: A paradigm for listing (s,t)-cuts in graphs. Algorithmica 15, 351--372, 1996. """ return [ Cut(self, cut=cut, partition=part) for cut, part in zip(*GraphBase.all_st_cuts(self, source, target)) ] def all_st_mincuts(self, source, target, capacity=None): """\ Returns all the mincuts between the source and target vertices in a directed graph. This function lists all minimum edge-cuts between a source and a target vertex. @param source: the source vertex ID @param target: the target vertex ID @param capacity: the edge capacities (weights). If C{None}, all edges have equal weight. May also be an attribute name. @return: a list of L{Cut} objects. @newfield ref: Reference @ref: JS Provan and DR Shier: A paradigm for listing (s,t)-cuts in graphs. Algorithmica 15, 351--372, 1996. """ value, cuts, parts = GraphBase.all_st_mincuts(self, source, target, capacity) return [ Cut(self, value, cut=cut, partition=part) for cut, part in zip(cuts, parts) ] def biconnected_components(self, return_articulation_points=False): """\ Calculates the biconnected components of the graph. @param return_articulation_points: whether to return the articulation points as well @return: a L{VertexCover} object describing the biconnected components, and optionally the list of articulation points as well """ if return_articulation_points: trees, aps = GraphBase.biconnected_components(self, True) else: trees = GraphBase.biconnected_components(self, False) clusters = [] if trees: edgelist = self.get_edgelist() for tree in trees: cluster = set() for edge_id in tree: cluster.update(edgelist[edge_id]) clusters.append(sorted(cluster)) clustering = VertexCover(self, clusters) if return_articulation_points: return clustering, aps else: return clustering blocks = biconnected_components def clear(self): """Clears the graph, deleting all vertices, edges, and attributes. @see: L{delete_vertices} and L{delete_edges}. """ self.delete_vertices() for attr in self.attributes(): del self[attr] def cohesive_blocks(self): """Calculates the cohesive block structure of the graph. Cohesive blocking is a method of determining hierarchical subsets of graph vertices based on their structural cohesion (i.e. vertex connectivity). For a given graph G, a subset of its vertices S is said to be maximally k-cohesive if there is no superset of S with vertex connectivity greater than or equal to k. Cohesive blocking is a process through which, given a k-cohesive set of vertices, maximally l-cohesive subsets are recursively identified with l > k. Thus a hierarchy of vertex subsets is obtained in the end, with the entire graph G at its root. @return: an instance of L{CohesiveBlocks}. See the documentation of L{CohesiveBlocks} for more information. @see: L{CohesiveBlocks} """ return CohesiveBlocks(self, *GraphBase.cohesive_blocks(self)) def clusters(self, mode="strong"): """Calculates the (strong or weak) clusters (connected components) for a given graph. @param mode: must be either C{"strong"} or C{"weak"}, depending on the clusters being sought. Optional, defaults to C{"strong"}. @return: a L{VertexClustering} object""" return VertexClustering(self, GraphBase.clusters(self, mode)) components = clusters def degree_distribution(self, bin_width=1, *args, **kwds): """Calculates the degree distribution of the graph. Unknown keyword arguments are directly passed to L{degree()}. @param bin_width: the bin width of the histogram @return: a histogram representing the degree distribution of the graph. """ result = Histogram(bin_width, self.degree(*args, **kwds)) return result def dyad_census(self, *args, **kwds): """Calculates the dyad census of the graph. Dyad census means classifying each pair of vertices of a directed graph into three categories: mutual (there is an edge from I{a} to I{b} and also from I{b} to I{a}), asymmetric (there is an edge from I{a} to I{b} or from I{b} to I{a} but not the other way round) and null (there is no connection between I{a} and I{b}). @return: a L{DyadCensus} object. @newfield ref: Reference @ref: Holland, P.W. and Leinhardt, S. (1970). A Method for Detecting Structure in Sociometric Data. American Journal of Sociology, 70, 492-513. """ return DyadCensus(GraphBase.dyad_census(self, *args, **kwds)) def get_adjacency( self, type=GET_ADJACENCY_BOTH, attribute=None, default=0, eids=False ): """Returns the adjacency matrix of a graph. @param type: either C{GET_ADJACENCY_LOWER} (uses the lower triangle of the matrix) or C{GET_ADJACENCY_UPPER} (uses the upper triangle) or C{GET_ADJACENCY_BOTH} (uses both parts). Ignored for directed graphs. @param attribute: if C{None}, returns the ordinary adjacency matrix. When the name of a valid edge attribute is given here, the matrix returned will contain the default value at the places where there is no edge or the value of the given attribute where there is an edge. Multiple edges are not supported, the value written in the matrix in this case will be unpredictable. This parameter is ignored if I{eids} is C{True} @param default: the default value written to the cells in the case of adjacency matrices with attributes. @param eids: specifies whether the edge IDs should be returned in the adjacency matrix. Since zero is a valid edge ID, the cells in the matrix that correspond to unconnected vertex pairs will contain -1 instead of 0 if I{eids} is C{True}. If I{eids} is C{False}, the number of edges will be returned in the matrix for each vertex pair. @return: the adjacency matrix as a L{Matrix}. """ if ( type != GET_ADJACENCY_LOWER and type != GET_ADJACENCY_UPPER and type != GET_ADJACENCY_BOTH ): # Maybe it was called with the first argument as the attribute name type, attribute = attribute, type if type is None: type = GET_ADJACENCY_BOTH if eids: result = Matrix(GraphBase.get_adjacency(self, type, eids)) result -= 1 return result if attribute is None: return Matrix(GraphBase.get_adjacency(self, type)) if attribute not in self.es.attribute_names(): raise ValueError("Attribute does not exist") data = [[default] * self.vcount() for _ in range(self.vcount())] if self.is_directed(): for edge in self.es: data[edge.source][edge.target] = edge[attribute] return Matrix(data) if type == GET_ADJACENCY_BOTH: for edge in self.es: source, target = edge.tuple data[source][target] = edge[attribute] data[target][source] = edge[attribute] elif type == GET_ADJACENCY_UPPER: for edge in self.es: data[min(edge.tuple)][max(edge.tuple)] = edge[attribute] else: for edge in self.es: data[max(edge.tuple)][min(edge.tuple)] = edge[attribute] return Matrix(data) def get_adjacency_sparse(self, attribute=None): """Returns the adjacency matrix of a graph as a SciPy CSR matrix. @param attribute: if C{None}, returns the ordinary adjacency matrix. When the name of a valid edge attribute is given here, the matrix returned will contain the default value at the places where there is no edge or the value of the given attribute where there is an edge. @return: the adjacency matrix as a C{scipy.sparse.csr_matrix}. """ try: from scipy import sparse except ImportError: raise ImportError( "You should install scipy in order to use this function" ) edges = self.get_edgelist() if attribute is None: weights = [1] * len(edges) else: if attribute not in self.es.attribute_names(): raise ValueError("Attribute does not exist") weights = self.es[attribute] N = self.vcount() mtx = sparse.csr_matrix((weights, list(zip(*edges))), shape=(N, N)) if not self.is_directed(): mtx = mtx + sparse.triu(mtx, 1).T + sparse.tril(mtx, -1).T return mtx def get_adjlist(self, mode="out"): """Returns the adjacency list representation of the graph. The adjacency list representation is a list of lists. Each item of the outer list belongs to a single vertex of the graph. The inner list contains the neighbors of the given vertex. @param mode: if C{\"out\"}, returns the successors of the vertex. If C{\"in\"}, returns the predecessors of the vertex. If C{\"all"\"}, both the predecessors and the successors will be returned. Ignored for undirected graphs. """ return [self.neighbors(idx, mode) for idx in range(self.vcount())] def get_all_simple_paths(self, v, to=None, cutoff=-1, mode="out"): """Calculates all the simple paths from a given node to some other nodes (or all of them) in a graph. A path is simple if its vertices are unique, i.e. no vertex is visited more than once. Note that potentially there are exponentially many paths between two vertices of a graph, especially if your graph is lattice-like. In this case, you may run out of memory when using this function. @param v: the source for the calculated paths @param to: a vertex selector describing the destination for the calculated paths. This can be a single vertex ID, a list of vertex IDs, a single vertex name, a list of vertex names or a L{VertexSeq} object. C{None} means all the vertices. @param cutoff: maximum length of path that is considered. If negative, paths of all lengths are considered. @param mode: the directionality of the paths. C{\"in\"} means to calculate incoming paths, C{\"out\"} means to calculate outgoing paths, C{\"all\"} means to calculate both ones. @return: all of the simple paths from the given node to every other reachable node in the graph in a list. Note that in case of mode=C{\"in\"}, the vertices in a path are returned in reversed order! """ paths = self._get_all_simple_paths(v, to, cutoff, mode) prev = 0 result = [] for index, item in enumerate(paths): if item < 0: result.append(paths[prev:index]) prev = index + 1 return result def get_inclist(self, mode="out"): """Returns the incidence list representation of the graph. The incidence list representation is a list of lists. Each item of the outer list belongs to a single vertex of the graph. The inner list contains the IDs of the incident edges of the given vertex. @param mode: if C{\"out\"}, returns the successors of the vertex. If C{\"in\"}, returns the predecessors of the vertex. If C{\"all\"}, both the predecessors and the successors will be returned. Ignored for undirected graphs. """ return [self.incident(idx, mode) for idx in range(self.vcount())] def gomory_hu_tree(self, capacity=None, flow="flow"): """Calculates the Gomory-Hu tree of an undirected graph with optional edge capacities. The Gomory-Hu tree is a concise representation of the value of all the maximum flows (or minimum cuts) in a graph. The vertices of the tree correspond exactly to the vertices of the original graph in the same order. Edges of the Gomory-Hu tree are annotated by flow values. The value of the maximum flow (or minimum cut) between an arbitrary (u,v) vertex pair in the original graph is then given by the minimum flow value (i.e. edge annotation) along the shortest path between u and v in the Gomory-Hu tree. @param capacity: the edge capacities (weights). If C{None}, all edges have equal weight. May also be an attribute name. @param flow: the name of the edge attribute in the returned graph in which the flow values will be stored. @return: the Gomory-Hu tree as a L{Graph} object. """ graph, flow_values = GraphBase.gomory_hu_tree(self, capacity) graph.es[flow] = flow_values return graph def is_named(self): """Returns whether the graph is named. A graph is named if and only if it has a C{"name"} vertex attribute. """ return "name" in self.vertex_attributes() def is_weighted(self): """Returns whether the graph is weighted. A graph is weighted if and only if it has a C{"weight"} edge attribute. """ return "weight" in self.edge_attributes() def maxflow(self, source, target, capacity=None): """Returns a maximum flow between the given source and target vertices in a graph. A maximum flow from I{source} to I{target} is an assignment of non-negative real numbers to the edges of the graph, satisfying two properties: 1. For each edge, the flow (i.e. the assigned number) is not more than the capacity of the edge (see the I{capacity} argument) 2. For every vertex except the source and the target, the incoming flow is the same as the outgoing flow. The value of the flow is the incoming flow of the target or the outgoing flow of the source (which are equal). The maximum flow is the maximum possible such value. @param capacity: the edge capacities (weights). If C{None}, all edges have equal weight. May also be an attribute name. @return: a L{Flow} object describing the maximum flow """ return Flow(self, *GraphBase.maxflow(self, source, target, capacity)) def mincut(self, source=None, target=None, capacity=None): """Calculates the minimum cut between the given source and target vertices or within the whole graph. The minimum cut is the minimum set of edges that needs to be removed to separate the source and the target (if they are given) or to disconnect the graph (if neither the source nor the target are given). The minimum is calculated using the weights (capacities) of the edges, so the cut with the minimum total capacity is calculated. For undirected graphs and no source and target, the method uses the Stoer-Wagner algorithm. For a given source and target, the method uses the push-relabel algorithm; see the references below. @param source: the source vertex ID. If C{None}, the target must also be C{None} and the calculation will be done for the entire graph (i.e. all possible vertex pairs). @param target: the target vertex ID. If C{None}, the source must also be C{None} and the calculation will be done for the entire graph (i.e. all possible vertex pairs). @param capacity: the edge capacities (weights). If C{None}, all edges have equal weight. May also be an attribute name. @return: a L{Cut} object describing the minimum cut """ return Cut(self, *GraphBase.mincut(self, source, target, capacity)) def st_mincut(self, source, target, capacity=None): """Calculates the minimum cut between the source and target vertices in a graph. @param source: the source vertex ID @param target: the target vertex ID @param capacity: the capacity of the edges. It must be a list or a valid attribute name or C{None}. In the latter case, every edge will have the same capacity. @return: the value of the minimum cut, the IDs of vertices in the first and second partition, and the IDs of edges in the cut, packed in a 4-tuple """ return Cut(self, *GraphBase.st_mincut(self, source, target, capacity)) def modularity(self, membership, weights=None): """Calculates the modularity score of the graph with respect to a given clustering. The modularity of a graph w.r.t. some division measures how good the division is, or how separated are the different vertex types from each other. It's defined as M{Q=1/(2m)*sum(Aij-ki*kj/(2m)delta(ci,cj),i,j)}. M{m} is the number of edges, M{Aij} is the element of the M{A} adjacency matrix in row M{i} and column M{j}, M{ki} is the degree of node M{i}, M{kj} is the degree of node M{j}, and M{Ci} and C{cj} are the types of the two vertices (M{i} and M{j}). M{delta(x,y)} is one iff M{x=y}, 0 otherwise. If edge weights are given, the definition of modularity is modified as follows: M{Aij} becomes the weight of the corresponding edge, M{ki} is the total weight of edges adjacent to vertex M{i}, M{kj} is the total weight of edges adjacent to vertex M{j} and M{m} is the total edge weight in the graph. @param membership: a membership list or a L{VertexClustering} object @param weights: optional edge weights or C{None} if all edges are weighed equally. Attribute names are also allowed. @return: the modularity score @newfield ref: Reference @ref: MEJ Newman and M Girvan: Finding and evaluating community structure in networks. Phys Rev E 69 026113, 2004. """ if isinstance(membership, VertexClustering): if membership.graph != self: raise ValueError("clustering object belongs to another graph") return GraphBase.modularity(self, membership.membership, weights) else: return GraphBase.modularity(self, membership, weights) def path_length_hist(self, directed=True): """Returns the path length histogram of the graph @param directed: whether to consider directed paths. Ignored for undirected graphs. @return: a L{Histogram} object. The object will also have an C{unconnected} attribute that stores the number of unconnected vertex pairs (where the second vertex can not be reached from the first one). The latter one will be of type long (and not a simple integer), since this can be I{very} large. """ data, unconn = GraphBase.path_length_hist(self, directed) hist = Histogram(bin_width=1) for i, length in enumerate(data): hist.add(i + 1, length) hist.unconnected = int(unconn) return hist def pagerank( self, vertices=None, directed=True, damping=0.85, weights=None, arpack_options=None, implementation="prpack", niter=1000, eps=0.001, ): """Calculates the PageRank values of a graph. @param vertices: the indices of the vertices being queried. C{None} means all of the vertices. @param directed: whether to consider directed paths. @param damping: the damping factor. M{1-damping} is the PageRank value for nodes with no incoming links. It is also the probability of resetting the random walk to a uniform distribution in each step. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param arpack_options: an L{ARPACKOptions} object used to fine-tune the ARPACK eigenvector calculation. If omitted, the module-level variable called C{arpack_options} is used. This argument is ignored if not the ARPACK implementation is used, see the I{implementation} argument. @param implementation: which implementation to use to solve the PageRank eigenproblem. Possible values are: - C{"prpack"}: use the PRPACK library. This is a new implementation in igraph 0.7 - C{"arpack"}: use the ARPACK library. This implementation was used from version 0.5, until version 0.7. - C{"power"}: use a simple power method. This is the implementation that was used before igraph version 0.5. @param niter: The number of iterations to use in the power method implementation. It is ignored in the other implementations @param eps: The power method implementation will consider the calculation as complete if the difference of PageRank values between iterations change less than this value for every node. It is ignored by the other implementations. @return: a list with the Google PageRank values of the specified vertices.""" if arpack_options is None: arpack_options = default_arpack_options return self.personalized_pagerank( vertices, directed, damping, None, None, weights, arpack_options, implementation, niter, eps, ) def spanning_tree(self, weights=None, return_tree=True): """Calculates a minimum spanning tree for a graph. @param weights: a vector containing weights for every edge in the graph. C{None} means that the graph is unweighted. @param return_tree: whether to return the minimum spanning tree (when C{return_tree} is C{True}) or to return the IDs of the edges in the minimum spanning tree instead (when C{return_tree} is C{False}). The default is C{True} for historical reasons as this argument was introduced in igraph 0.6. @return: the spanning tree as a L{Graph} object if C{return_tree} is C{True} or the IDs of the edges that constitute the spanning tree if C{return_tree} is C{False}. @newfield ref: Reference @ref: Prim, R.C.: I{Shortest connection networks and some generalizations}. Bell System Technical Journal 36:1389-1401, 1957. """ result = GraphBase._spanning_tree(self, weights) if return_tree: return self.subgraph_edges(result, delete_vertices=False) return result def transitivity_avglocal_undirected(self, mode="nan", weights=None): """Calculates the average of the vertex transitivities of the graph. In the unweighted case, the transitivity measures the probability that two neighbors of a vertex are connected. In case of the average local transitivity, this probability is calculated for each vertex and then the average is taken. Vertices with less than two neighbors require special treatment, they will either be left out from the calculation or they will be considered as having zero transitivity, depending on the I{mode} parameter. The calculation is slightly more involved for weighted graphs; in this case, weights are taken into account according to the formula of Barrat et al (see the references). Note that this measure is different from the global transitivity measure (see L{transitivity_undirected()}) as it simply takes the average local transitivity across the whole network. @param mode: defines how to treat vertices with degree less than two. If C{TRANSITIVITY_ZERO} or C{"zero"}, these vertices will have zero transitivity. If C{TRANSITIVITY_NAN} or C{"nan"}, these vertices will be excluded from the average. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @see: L{transitivity_undirected()}, L{transitivity_local_undirected()} @newfield ref: Reference @ref: Watts DJ and Strogatz S: I{Collective dynamics of small-world networks}. Nature 393(6884):440-442, 1998. @ref: Barrat A, Barthelemy M, Pastor-Satorras R and Vespignani A: I{The architecture of complex weighted networks}. PNAS 101, 3747 (2004). U{http://arxiv.org/abs/cond-mat/0311416}. """ if weights is None: return GraphBase.transitivity_avglocal_undirected(self, mode) xs = self.transitivity_local_undirected(mode=mode, weights=weights) return sum(xs) / float(len(xs)) def triad_census(self, *args, **kwds): """Calculates the triad census of the graph. @return: a L{TriadCensus} object. @newfield ref: Reference @ref: Davis, J.A. and Leinhardt, S. (1972). The Structure of Positive Interpersonal Relations in Small Groups. In: J. Berger (Ed.), Sociological Theories in Progress, Volume 2, 218-251. Boston: Houghton Mifflin. """ return TriadCensus(GraphBase.triad_census(self, *args, **kwds)) # Automorphisms def count_automorphisms_vf2( self, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None ): """Returns the number of automorphisms of the graph. This function simply calls C{count_isomorphisms_vf2} with the graph itself. See C{count_isomorphisms_vf2} for an explanation of the parameters. @return: the number of automorphisms of the graph @see: Graph.count_isomorphisms_vf2 """ return self.count_isomorphisms_vf2( self, color1=color, color2=color, edge_color1=edge_color, edge_color2=edge_color, node_compat_fn=node_compat_fn, edge_compat_fn=edge_compat_fn, ) def get_automorphisms_vf2( self, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None ): """Returns all the automorphisms of the graph This function simply calls C{get_isomorphisms_vf2} with the graph itself. See C{get_isomorphisms_vf2} for an explanation of the parameters. @return: a list of lists, each item containing a possible mapping of the graph vertices to itself according to the automorphism @see: Graph.get_isomorphisms_vf2 """ return self.get_isomorphisms_vf2( self, color1=color, color2=color, edge_color1=edge_color, edge_color2=edge_color, node_compat_fn=node_compat_fn, edge_compat_fn=edge_compat_fn, ) # Various clustering algorithms -- mostly wrappers around GraphBase def community_fastgreedy(self, weights=None): """Community structure based on the greedy optimization of modularity. This algorithm merges individual nodes into communities in a way that greedily maximizes the modularity score of the graph. It can be proven that if no merge can increase the current modularity score, the algorithm can be stopped since no further increase can be achieved. This algorithm is said to run almost in linear time on sparse graphs. @param weights: edge attribute name or a list containing edge weights @return: an appropriate L{VertexDendrogram} object. @newfield ref: Reference @ref: A Clauset, MEJ Newman and C Moore: Finding community structure in very large networks. Phys Rev E 70, 066111 (2004). """ merges, qs = GraphBase.community_fastgreedy(self, weights) # qs may be shorter than |V|-1 if we are left with a few separated # communities in the end; take this into account diff = self.vcount() - len(qs) qs.reverse() if qs: optimal_count = qs.index(max(qs)) + diff + 1 else: optimal_count = diff return VertexDendrogram( self, merges, optimal_count, modularity_params=dict(weights=weights) ) def community_infomap(self, edge_weights=None, vertex_weights=None, trials=10): """Finds the community structure of the network according to the Infomap method of Martin Rosvall and Carl T. Bergstrom. @param edge_weights: name of an edge attribute or a list containing edge weights. @param vertex_weights: name of an vertex attribute or a list containing vertex weights. @param trials: the number of attempts to partition the network. @return: an appropriate L{VertexClustering} object with an extra attribute called C{codelength} that stores the code length determined by the algorithm. @newfield ref: Reference @ref: M. Rosvall and C. T. Bergstrom: Maps of information flow reveal community structure in complex networks, PNAS 105, 1118 (2008). U{http://dx.doi.org/10.1073/pnas.0706851105}, U{http://arxiv.org/abs/0707.0609}. @ref: M. Rosvall, D. Axelsson, and C. T. Bergstrom: The map equation, Eur. Phys. J. Special Topics 178, 13 (2009). U{http://dx.doi.org/10.1140/epjst/e2010-01179-1}, U{http://arxiv.org/abs/0906.1405}. """ membership, codelength = GraphBase.community_infomap( self, edge_weights, vertex_weights, trials ) return VertexClustering( self, membership, params={"codelength": codelength}, modularity_params={"weights": edge_weights}, ) def community_leading_eigenvector_naive(self, clusters=None, return_merges=False): """Naive implementation of Newman's eigenvector community structure detection. This function splits the network into two components according to the leading eigenvector of the modularity matrix and then recursively takes the given number of steps by splitting the communities as individual networks. This is not the correct way, however, see the reference for explanation. Consider using the correct L{community_leading_eigenvector} method instead. @param clusters: the desired number of communities. If C{None}, the algorithm tries to do as many splits as possible. Note that the algorithm won't split a community further if the signs of the leading eigenvector are all the same, so the actual number of discovered communities can be less than the desired one. @param return_merges: whether the returned object should be a dendrogram instead of a single clustering. @return: an appropriate L{VertexClustering} or L{VertexDendrogram} object. @newfield ref: Reference @ref: MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087""" if clusters is None: clusters = -1 cl, merges, q = GraphBase.community_leading_eigenvector_naive( self, clusters, return_merges ) if merges is None: return VertexClustering(self, cl, modularity=q) else: return VertexDendrogram(self, merges, safemax(cl) + 1) def community_leading_eigenvector( self, clusters=None, weights=None, arpack_options=None ): """Newman's leading eigenvector method for detecting community structure. This is the proper implementation of the recursive, divisive algorithm: each split is done by maximizing the modularity regarding the original network. @param clusters: the desired number of communities. If C{None}, the algorithm tries to do as many splits as possible. Note that the algorithm won't split a community further if the signs of the leading eigenvector are all the same, so the actual number of discovered communities can be less than the desired one. @param weights: name of an edge attribute or a list containing edge weights. @param arpack_options: an L{ARPACKOptions} object used to fine-tune the ARPACK eigenvector calculation. If omitted, the module-level variable called C{arpack_options} is used. @return: an appropriate L{VertexClustering} object. @newfield ref: Reference @ref: MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087""" if clusters is None: clusters = -1 kwds = dict(weights=weights) if arpack_options is not None: kwds["arpack_options"] = arpack_options membership, _, q = GraphBase.community_leading_eigenvector( self, clusters, **kwds ) return VertexClustering(self, membership, modularity=q) def community_label_propagation(self, weights=None, initial=None, fixed=None): """Finds the community structure of the graph according to the label propagation method of Raghavan et al. Initially, each vertex is assigned a different label. After that, each vertex chooses the dominant label in its neighbourhood in each iteration. Ties are broken randomly and the order in which the vertices are updated is randomized before every iteration. The algorithm ends when vertices reach a consensus. Note that since ties are broken randomly, there is no guarantee that the algorithm returns the same community structure after each run. In fact, they frequently differ. See the paper of Raghavan et al on how to come up with an aggregated community structure. @param weights: name of an edge attribute or a list containing edge weights @param initial: name of a vertex attribute or a list containing the initial vertex labels. Labels are identified by integers from zero to M{n-1} where M{n} is the number of vertices. Negative numbers may also be present in this vector, they represent unlabeled vertices. @param fixed: a list of booleans for each vertex. C{True} corresponds to vertices whose labeling should not change during the algorithm. It only makes sense if initial labels are also given. Unlabeled vertices cannot be fixed. It may also be the name of a vertex attribute; each attribute value will be interpreted as a Boolean. @return: an appropriate L{VertexClustering} object. @newfield ref: Reference @ref: Raghavan, U.N. and Albert, R. and Kumara, S. Near linear time algorithm to detect community structures in large-scale networks. Phys Rev E 76:036106, 2007. U{http://arxiv.org/abs/0709.2938}. """ if isinstance(fixed, str): fixed = [bool(o) for o in self.vs[fixed]] cl = GraphBase.community_label_propagation(self, weights, initial, fixed) return VertexClustering(self, cl, modularity_params=dict(weights=weights)) def community_multilevel(self, weights=None, return_levels=False): """Community structure based on the multilevel algorithm of Blondel et al. This is a bottom-up algorithm: initially every vertex belongs to a separate community, and vertices are moved between communities iteratively in a way that maximizes the vertices' local contribution to the overall modularity score. When a consensus is reached (i.e. no single move would increase the modularity score), every community in the original graph is shrank to a single vertex (while keeping the total weight of the adjacent edges) and the process continues on the next level. The algorithm stops when it is not possible to increase the modularity any more after shrinking the communities to vertices. This algorithm is said to run almost in linear time on sparse graphs. @param weights: edge attribute name or a list containing edge weights @param return_levels: if C{True}, the communities at each level are returned in a list. If C{False}, only the community structure with the best modularity is returned. @return: a list of L{VertexClustering} objects, one corresponding to each level (if C{return_levels} is C{True}), or a L{VertexClustering} corresponding to the best modularity. @newfield ref: Reference @ref: VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large networks, J Stat Mech P10008 (2008), http://arxiv.org/abs/0803.0476 """ if self.is_directed(): raise ValueError("input graph must be undirected") if return_levels: levels, qs = GraphBase.community_multilevel(self, weights, True) result = [] for level, q in zip(levels, qs): result.append( VertexClustering( self, level, q, modularity_params=dict(weights=weights) ) ) else: membership = GraphBase.community_multilevel(self, weights, False) result = VertexClustering( self, membership, modularity_params=dict(weights=weights) ) return result def community_optimal_modularity(self, *args, **kwds): """Calculates the optimal modularity score of the graph and the corresponding community structure. This function uses the GNU Linear Programming Kit to solve a large integer optimization problem in order to find the optimal modularity score and the corresponding community structure, therefore it is unlikely to work for graphs larger than a few (less than a hundred) vertices. Consider using one of the heuristic approaches instead if you have such a large graph. @return: the calculated membership vector and the corresponding modularity in a tuple.""" membership, modularity = GraphBase.community_optimal_modularity( self, *args, **kwds ) return VertexClustering(self, membership, modularity) def community_edge_betweenness(self, clusters=None, directed=True, weights=None): """Community structure based on the betweenness of the edges in the network. The idea is that the betweenness of the edges connecting two communities is typically high, as many of the shortest paths between nodes in separate communities go through them. So we gradually remove the edge with the highest betweenness and recalculate the betweennesses after every removal. This way sooner or later the network falls of to separate components. The result of the clustering will be represented by a dendrogram. @param clusters: the number of clusters we would like to see. This practically defines the "level" where we "cut" the dendrogram to get the membership vector of the vertices. If C{None}, the dendrogram is cut at the level which maximizes the modularity when the graph is unweighted; otherwise the dendrogram is cut at at a single cluster (because cluster count selection based on modularities does not make sense for this method if not all the weights are equal). @param directed: whether the directionality of the edges should be taken into account or not. @param weights: name of an edge attribute or a list containing edge weights. @return: a L{VertexDendrogram} object, initally cut at the maximum modularity or at the desired number of clusters. """ merges, qs = GraphBase.community_edge_betweenness(self, directed, weights) if qs is not None: qs.reverse() if clusters is None: if qs: clusters = qs.index(max(qs)) + 1 else: clusters = 1 return VertexDendrogram( self, merges, clusters, modularity_params=dict(weights=weights) ) def community_spinglass(self, *args, **kwds): """Finds the community structure of the graph according to the spinglass community detection method of Reichardt & Bornholdt. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param spins: integer, the number of spins to use. This is the upper limit for the number of communities. It is not a problem to supply a (reasonably) big number here, in which case some spin states will be unpopulated. @param parupdate: whether to update the spins of the vertices in parallel (synchronously) or not @param start_temp: the starting temperature @param stop_temp: the stop temperature @param cool_fact: cooling factor for the simulated annealing @param update_rule: specifies the null model of the simulation. Possible values are C{"config"} (a random graph with the same vertex degrees as the input graph) or C{"simple"} (a random graph with the same number of edges) @param gamma: the gamma argument of the algorithm, specifying the balance between the importance of present and missing edges within a community. The default value of 1.0 assigns equal importance to both of them. @param implementation: currently igraph contains two implementations of the spinglass community detection algorithm. The faster original implementation is the default. The other implementation is able to take into account negative weights, this can be chosen by setting C{implementation} to C{"neg"} @param lambda_: the lambda argument of the algorithm, which specifies the balance between the importance of present and missing negatively weighted edges within a community. Smaller values of lambda lead to communities with less negative intra-connectivity. If the argument is zero, the algorithm reduces to a graph coloring algorithm, using the number of spins as colors. This argument is ignored if the original implementation is used. Note the underscore at the end of the argument name; this is due to the fact that lambda is a reserved keyword in Python. @return: an appropriate L{VertexClustering} object. @newfield ref: Reference @ref: Reichardt J and Bornholdt S: Statistical mechanics of community detection. Phys Rev E 74:016110 (2006). U{http://arxiv.org/abs/cond-mat/0603718}. @ref: Traag VA and Bruggeman J: Community detection in networks with positive and negative links. Phys Rev E 80:036115 (2009). U{http://arxiv.org/abs/0811.2329}. """ membership = GraphBase.community_spinglass(self, *args, **kwds) if "weights" in kwds: modularity_params = dict(weights=kwds["weights"]) else: modularity_params = {} return VertexClustering(self, membership, modularity_params=modularity_params) def community_walktrap(self, weights=None, steps=4): """Community detection algorithm of Latapy & Pons, based on random walks. The basic idea of the algorithm is that short random walks tend to stay in the same community. The result of the clustering will be represented as a dendrogram. @param weights: name of an edge attribute or a list containing edge weights @param steps: length of random walks to perform @return: a L{VertexDendrogram} object, initially cut at the maximum modularity. @newfield ref: Reference @ref: Pascal Pons, Matthieu Latapy: Computing communities in large networks using random walks, U{http://arxiv.org/abs/physics/0512106}. """ merges, qs = GraphBase.community_walktrap(self, weights, steps) qs.reverse() if qs: optimal_count = qs.index(max(qs)) + 1 else: optimal_count = 1 return VertexDendrogram( self, merges, optimal_count, modularity_params=dict(weights=weights) ) def k_core(self, *args): """Returns some k-cores of the graph. The method accepts an arbitrary number of arguments representing the desired indices of the M{k}-cores to be returned. The arguments can also be lists or tuples. The result is a single L{Graph} object if an only integer argument was given, otherwise the result is a list of L{Graph} objects representing the desired k-cores in the order the arguments were specified. If no argument is given, returns all M{k}-cores in increasing order of M{k}. """ if len(args) == 0: indices = range(self.vcount()) return_single = False else: return_single = True indices = [] for arg in args: try: indices.extend(arg) except Exception: indices.append(arg) if len(indices) > 1 or hasattr(args[0], "__iter__"): return_single = False corenesses = self.coreness() result = [] vidxs = range(self.vcount()) for idx in indices: core_idxs = [vidx for vidx in vidxs if corenesses[vidx] >= idx] result.append(self.subgraph(core_idxs)) if return_single: return result[0] return result def community_leiden( self, objective_function="CPM", weights=None, resolution_parameter=1.0, beta=0.01, initial_membership=None, n_iterations=2, node_weights=None, ): """Finds the community structure of the graph using the Leiden algorithm of Traag, van Eck & Waltman. @param objective_function: whether to use the Constant Potts Model (CPM) or modularity. Must be either C{"CPM"} or C{"modularity"}. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param resolution_parameter: the resolution parameter to use. Higher resolutions lead to more smaller communities, while lower resolutions lead to fewer larger communities. @param beta: parameter affecting the randomness in the Leiden algorithm. This affects only the refinement step of the algorithm. @param initial_membership: if provided, the Leiden algorithm will try to improve this provided membership. If no argument is provided, the aglorithm simply starts from the singleton partition. @param n_iterations: the number of iterations to iterate the Leiden algorithm. Each iteration may improve the partition further. Using a negative number of iterations will run until a stable iteration is encountered (i.e. the quality was not increased during that iteration). @param node_weights: the node weights used in the Leiden algorithm. If this is not provided, it will be automatically determined on the basis of whether you want to use CPM or modularity. If you do provide this, please make sure that you understand what you are doing. @return: an appropriate L{VertexClustering} object. @newfield ref: Reference @ref: Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvain to Leiden: guaranteeing well-connected communities. Scientific reports, 9(1), 5233. doi: 10.1038/s41598-019-41695-z """ if objective_function.lower() not in ("cpm", "modularity"): raise ValueError('objective_function must be "CPM" or "modularity".') membership = GraphBase.community_leiden( self, edge_weights=weights, node_weights=node_weights, resolution_parameter=resolution_parameter, normalize_resolution=(objective_function == "modularity"), beta=beta, initial_membership=initial_membership, n_iterations=n_iterations, ) if weights is not None: modularity_params = dict(weights=weights) else: modularity_params = {} return VertexClustering(self, membership, modularity_params=modularity_params) def layout(self, layout=None, *args, **kwds): """Returns the layout of the graph according to a layout algorithm. Parameters and keyword arguments not specified here are passed to the layout algorithm directly. See the documentation of the layout algorithms for the explanation of these parameters. Registered layout names understood by this method are: - C{auto}, C{automatic}: automatic layout (see L{layout_auto}) - C{bipartite}: bipartite layout (see L{layout_bipartite}) - C{circle}, C{circular}: circular layout (see L{layout_circle}) - C{dh}, C{davidson_harel}: Davidson-Harel layout (see L{layout_davidson_harel}) - C{drl}: DrL layout for large graphs (see L{layout_drl}) - C{drl_3d}: 3D DrL layout for large graphs (see L{layout_drl}) - C{fr}, C{fruchterman_reingold}: Fruchterman-Reingold layout (see L{layout_fruchterman_reingold}). - C{fr_3d}, C{fr3d}, C{fruchterman_reingold_3d}: 3D Fruchterman- Reingold layout (see L{layout_fruchterman_reingold}). - C{grid}: regular grid layout in 2D (see L{layout_grid}) - C{grid_3d}: regular grid layout in 3D (see L{layout_grid_3d}) - C{graphopt}: the graphopt algorithm (see L{layout_graphopt}) - C{kk}, C{kamada_kawai}: Kamada-Kawai layout (see L{layout_kamada_kawai}) - C{kk_3d}, C{kk3d}, C{kamada_kawai_3d}: 3D Kamada-Kawai layout (see L{layout_kamada_kawai}) - C{lgl}, C{large}, C{large_graph}: Large Graph Layout (see L{layout_lgl}) - C{mds}: multidimensional scaling layout (see L{layout_mds}) - C{random}: random layout (see L{layout_random}) - C{random_3d}: random 3D layout (see L{layout_random}) - C{rt}, C{tree}, C{reingold_tilford}: Reingold-Tilford tree layout (see L{layout_reingold_tilford}) - C{rt_circular}, C{reingold_tilford_circular}: circular Reingold-Tilford tree layout (see L{layout_reingold_tilford_circular}) - C{sphere}, C{spherical}, C{circle_3d}, C{circular_3d}: spherical layout (see L{layout_circle}) - C{star}: star layout (see L{layout_star}) - C{sugiyama}: Sugiyama layout (see L{layout_sugiyama}) @param layout: the layout to use. This can be one of the registered layout names or a callable which returns either a L{Layout} object or a list of lists containing the coordinates. If C{None}, uses the value of the C{plotting.layout} configuration key. @return: a L{Layout} object. """ if layout is None: layout = config["plotting.layout"] if hasattr(layout, "__call__"): method = layout else: layout = layout.lower() if layout[-3:] == "_3d": kwds["dim"] = 3 layout = layout[:-3] elif layout[-2:] == "3d": kwds["dim"] = 3 layout = layout[:-2] method = getattr(self.__class__, self._layout_mapping[layout]) if not hasattr(method, "__call__"): raise ValueError("layout method must be callable") layout = method(self, *args, **kwds) if not isinstance(layout, Layout): layout = Layout(layout) return layout def layout_auto(self, *args, **kwds): """Chooses and runs a suitable layout function based on simple topological properties of the graph. This function tries to choose an appropriate layout function for the graph using the following rules: 1. If the graph has an attribute called C{layout}, it will be used. It may either be a L{Layout} instance, a list of coordinate pairs, the name of a layout function, or a callable function which generates the layout when called with the graph as a parameter. 2. Otherwise, if the graph has vertex attributes called C{x} and C{y}, these will be used as coordinates in the layout. When a 3D layout is requested (by setting C{dim} to 3), a vertex attribute named C{z} will also be needed. 3. Otherwise, if the graph is connected and has at most 100 vertices, the Kamada-Kawai layout will be used (see L{layout_kamada_kawai()}). 4. Otherwise, if the graph has at most 1000 vertices, the Fruchterman-Reingold layout will be used (see L{layout_fruchterman_reingold()}). 5. If everything else above failed, the DrL layout algorithm will be used (see L{layout_drl()}). All the arguments of this function except C{dim} are passed on to the chosen layout function (in case we have to call some layout function). @keyword dim: specifies whether we would like to obtain a 2D or a 3D layout. @return: a L{Layout} object. """ if "layout" in self.attributes(): layout = self["layout"] if isinstance(layout, Layout): # Layouts are used intact return layout if isinstance(layout, (list, tuple)): # Lists/tuples are converted to layouts return Layout(layout) if hasattr(layout, "__call__"): # Callables are called return Layout(layout(*args, **kwds)) # Try Graph.layout() return self.layout(layout, *args, **kwds) dim = kwds.get("dim", 2) vattrs = self.vertex_attributes() if "x" in vattrs and "y" in vattrs: if dim == 3 and "z" in vattrs: return Layout(list(zip(self.vs["x"], self.vs["y"], self.vs["z"]))) else: return Layout(list(zip(self.vs["x"], self.vs["y"]))) if self.vcount() <= 100 and self.is_connected(): algo = "kk" elif self.vcount() <= 1000: algo = "fr" else: algo = "drl" return self.layout(algo, *args, **kwds) def layout_sugiyama( self, layers=None, weights=None, hgap=1, vgap=1, maxiter=100, return_extended_graph=False, ): """Places the vertices using a layered Sugiyama layout. This is a layered layout that is most suitable for directed acyclic graphs, although it works on undirected or cyclic graphs as well. Each vertex is assigned to a layer and each layer is placed on a horizontal line. Vertices within the same layer are then permuted using the barycenter heuristic that tries to minimize edge crossings. Dummy vertices will be added on edges that span more than one layer. The returned layout therefore contains more rows than the number of nodes in the original graph; the extra rows correspond to the dummy vertices. @param layers: a vector specifying a non-negative integer layer index for each vertex, or the name of a numeric vertex attribute that contains the layer indices. If C{None}, a layering will be determined automatically. For undirected graphs, a spanning tree will be extracted and vertices will be assigned to layers using a breadth first search from the node with the largest degree. For directed graphs, cycles are broken by reversing the direction of edges in an approximate feedback arc set using the heuristic of Eades, Lin and Smyth, and then using longest path layering to place the vertices in layers. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param hgap: minimum horizontal gap between vertices in the same layer. @param vgap: vertical gap between layers. The layer index will be multiplied by I{vgap} to obtain the Y coordinate. @param maxiter: maximum number of iterations to take in the crossing reduction step. Increase this if you feel that you are getting too many edge crossings. @param return_extended_graph: specifies that the extended graph with the added dummy vertices should also be returned. When this is C{True}, the result will be a tuple containing the layout and the extended graph. The first |V| nodes of the extended graph will correspond to the nodes of the original graph, the remaining ones are dummy nodes. Plotting the extended graph with the returned layout and hidden dummy nodes will produce a layout that is similar to the original graph, but with the added edge bends. The extended graph also contains an edge attribute called C{_original_eid} which specifies the ID of the edge in the original graph from which the edge of the extended graph was created. @return: the calculated layout, which may (and usually will) have more rows than the number of vertices; the remaining rows correspond to the dummy nodes introduced in the layering step. When C{return_extended_graph} is C{True}, it will also contain the extended graph. @newfield ref: Reference @ref: K Sugiyama, S Tagawa, M Toda: Methods for visual understanding of hierarchical system structures. IEEE Systems, Man and Cybernetics\ 11(2):109-125, 1981. @ref: P Eades, X Lin and WF Smyth: A fast effective heuristic for the feedback arc set problem. Information Processing Letters 47:319-323, 1993. """ if not return_extended_graph: return Layout( GraphBase._layout_sugiyama( self, layers, weights, hgap, vgap, maxiter, return_extended_graph ) ) layout, extd_graph, extd_to_orig_eids = GraphBase._layout_sugiyama( self, layers, weights, hgap, vgap, maxiter, return_extended_graph ) extd_graph.es["_original_eid"] = extd_to_orig_eids return Layout(layout), extd_graph def maximum_bipartite_matching(self, types="type", weights=None, eps=None): """Finds a maximum matching in a bipartite graph. A maximum matching is a set of edges such that each vertex is incident on at most one matched edge and the number (or weight) of such edges in the set is as large as possible. @param types: vertex types in a list or the name of a vertex attribute holding vertex types. Types should be denoted by zeros and ones (or C{False} and C{True}) for the two sides of the bipartite graph. If omitted, it defaults to C{type}, which is the default vertex type attribute for bipartite graphs. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param eps: a small real number used in equality tests in the weighted bipartite matching algorithm. Two real numbers are considered equal in the algorithm if their difference is smaller than this value. This is required to avoid the accumulation of numerical errors. If you pass C{None} here, igraph will try to determine an appropriate value automatically. @return: an instance of L{Matching}.""" if eps is None: eps = -1 matches = GraphBase._maximum_bipartite_matching(self, types, weights, eps) return Matching(self, matches, types=types) ############################################# # Auxiliary I/O functions def to_networkx(self, create_using=None): """Converts the graph to networkx format. @param create_using: specifies which NetworkX graph class to use when constructing the graph. C{None} means to let igraph infer the most appropriate class based on whether the graph is directed and whether it has multi-edges. """ import networkx as nx # Graph: decide on directness and mutliplicity if create_using is None: if self.has_multiple(): cls = nx.MultiDiGraph if self.is_directed() else nx.MultiGraph else: cls = nx.DiGraph if self.is_directed() else nx.Graph else: cls = create_using # Graph attributes kw = {x: self[x] for x in self.attributes()} g = cls(**kw) # Nodes and node attributes for i, v in enumerate(self.vs): # TODO: use _nx_name if the attribute is present so we can achieve # a lossless round-trip in terms of vertex names g.add_node(i, **v.attributes()) # Edges and edge attributes for edge in self.es: g.add_edge(edge.source, edge.target, **edge.attributes()) return g @classmethod def from_networkx(cls, g): """Converts the graph from networkx Vertex names will be converted to "_nx_name" attribute and the vertices will get new ids from 0 up (as standard in igraph). @param g: networkx Graph or DiGraph """ # Graph attributes gattr = dict(g.graph) # Nodes vnames = list(g.nodes) vattr = {"_nx_name": vnames} vcount = len(vnames) vd = {v: i for i, v in enumerate(vnames)} # NOTE: we do not need a special class for multigraphs, it is taken # care for at the edge level rather than at the graph level. graph = cls( n=vcount, directed=g.is_directed(), graph_attrs=gattr, vertex_attrs=vattr ) # Node attributes for v, datum in g.nodes.data(): for key, val in list(datum.items()): graph.vs[vd[v]][key] = val # Edges and edge attributes eattr_names = {name for (_, _, data) in g.edges.data() for name in data} eattr = {name: [] for name in eattr_names} edges = [] for (u, v, data) in g.edges.data(): edges.append((vd[u], vd[v])) for name in eattr_names: eattr[name].append(data.get(name)) graph.add_edges(edges, eattr) return graph def to_graph_tool( self, graph_attributes=None, vertex_attributes=None, edge_attributes=None ): """Converts the graph to graph-tool Data types: graph-tool only accepts specific data types. See the following web page for a list: https://graph-tool.skewed.de/static/doc/quickstart.html Note: because of the restricted data types in graph-tool, vertex and edge attributes require to be type-consistent across all vertices or edges. If you set the property for only some vertices/edges, the other will be tagged as None in igraph, so they can only be converted to graph-tool with the type 'object' and any other conversion will fail. @param graph_attributes: dictionary of graph attributes to transfer. Keys are attributes from the graph, values are data types (see below). C{None} means no graph attributes are transferred. @param vertex_attributes: dictionary of vertex attributes to transfer. Keys are attributes from the vertices, values are data types (see below). C{None} means no vertex attributes are transferred. @param edge_attributes: dictionary of edge attributes to transfer. Keys are attributes from the edges, values are data types (see below). C{None} means no vertex attributes are transferred. """ import graph_tool as gt # Graph g = gt.Graph(directed=self.is_directed()) # Nodes vc = self.vcount() g.add_vertex(vc) # Graph attributes if graph_attributes is not None: for x, dtype in list(graph_attributes.items()): # Strange syntax for setting internal properties gprop = g.new_graph_property(str(dtype)) g.graph_properties[x] = gprop g.graph_properties[x] = self[x] # Vertex attributes if vertex_attributes is not None: for x, dtype in list(vertex_attributes.items()): # Create a new vertex property g.vertex_properties[x] = g.new_vertex_property(str(dtype)) # Fill the values from the igraph.Graph for i in range(vc): g.vertex_properties[x][g.vertex(i)] = self.vs[i][x] # Edges and edge attributes if edge_attributes is not None: for x, dtype in list(edge_attributes.items()): g.edge_properties[x] = g.new_edge_property(str(dtype)) for edge in self.es: e = g.add_edge(edge.source, edge.target) if edge_attributes is not None: for x, dtype in list(edge_attributes.items()): prop = edge.attributes().get(x, None) g.edge_properties[x][e] = prop return g @classmethod def from_graph_tool(cls, g): """Converts the graph from graph-tool @param g: graph-tool Graph """ # Graph attributes gattr = dict(g.graph_properties) # Nodes vcount = g.num_vertices() # Graph graph = cls(n=vcount, directed=g.is_directed(), graph_attrs=gattr) # Node attributes for key, val in g.vertex_properties.items(): prop = val.get_array() for i in range(vcount): graph.vs[i][key] = prop[i] # Edges and edge attributes # NOTE: graph-tool is quite strongly typed, so each property is always # defined for all edges, using default values for the type. E.g. for a # string property/attribute the missing edges get an empty string. edges = [] eattr_names = list(g.edge_properties) eattr = {name: [] for name in eattr_names} for e in g.edges(): edges.append((int(e.source()), int(e.target()))) for name, attr_map in g.edge_properties.items(): eattr[name].append(attr_map[e]) graph.add_edges(edges, eattr) return graph def write_adjacency(self, f, sep=" ", eol="\n", *args, **kwds): """Writes the adjacency matrix of the graph to the given file All the remaining arguments not mentioned here are passed intact to L{Graph.get_adjacency}. @param f: the name of the file to be written. @param sep: the string that separates the matrix elements in a row @param eol: the string that separates the rows of the matrix. Please note that igraph is able to read back the written adjacency matrix if and only if this is a single newline character """ if isinstance(f, str): f = open(f, "w") matrix = self.get_adjacency(*args, **kwds) for row in matrix: f.write(sep.join(map(str, row))) f.write(eol) f.close() @classmethod def Read_Adjacency( cls, f, sep=None, comment_char="#", attribute=None, *args, **kwds ): """Constructs a graph based on an adjacency matrix from the given file. Additional positional and keyword arguments not mentioned here are passed intact to L{Adjacency}. @param f: the name of the file to be read or a file object @param sep: the string that separates the matrix elements in a row. C{None} means an arbitrary sequence of whitespace characters. @param comment_char: lines starting with this string are treated as comments. @param attribute: an edge attribute name where the edge weights are stored in the case of a weighted adjacency matrix. If C{None}, no weights are stored, values larger than 1 are considered as edge multiplicities. @return: the created graph""" if isinstance(f, str): f = open(f) matrix, ri = [], 0 for line in f: line = line.strip() if len(line) == 0: continue if line.startswith(comment_char): continue row = [float(x) for x in line.split(sep)] matrix.append(row) ri += 1 f.close() if attribute is None: graph = cls.Adjacency(matrix, *args, **kwds) else: kwds["attr"] = attribute graph = cls.Weighted_Adjacency(matrix, *args, **kwds) return graph @classmethod def Adjacency(cls, matrix, mode="directed", *args, **kwargs): """Generates a graph from its adjacency matrix. @param matrix: the adjacency matrix. Possible types are: - a list of lists - a numpy 2D array or matrix (will be converted to list of lists) - a scipy.sparse matrix (will be converted to a COO matrix, but not to a dense matrix) @param mode: the mode to be used. Possible values are: - C{"directed"} - the graph will be directed and a matrix element gives the number of edges between two vertex. - C{"undirected"} - alias to C{"max"} for convenience. - C{"max"} - undirected graph will be created and the number of edges between vertex M{i} and M{j} is M{max(A(i,j), A(j,i))} - C{"min"} - like C{"max"}, but with M{min(A(i,j), A(j,i))} - C{"plus"} - like C{"max"}, but with M{A(i,j) + A(j,i)} - C{"upper"} - undirected graph with the upper right triangle of the matrix (including the diagonal) - C{"lower"} - undirected graph with the lower left triangle of the matrix (including the diagonal) """ try: import numpy as np except ImportError: np = None try: from scipy import sparse except ImportError: sparse = None if (sparse is not None) and isinstance(matrix, sparse.spmatrix): return _graph_from_sparse_matrix(cls, matrix, mode=mode) if (np is not None) and isinstance(matrix, np.ndarray): matrix = matrix.tolist() return super().Adjacency(matrix, mode=mode) @classmethod def Weighted_Adjacency(cls, matrix, mode="directed", attr="weight", loops=True): """Generates a graph from its weighted adjacency matrix. @param matrix: the adjacency matrix. Possible types are: - a list of lists - a numpy 2D array or matrix (will be converted to list of lists) - a scipy.sparse matrix (will be converted to a COO matrix, but not to a dense matrix) @param mode: the mode to be used. Possible values are: - C{"directed"} - the graph will be directed and a matrix element gives the number of edges between two vertex. - C{"undirected"} - alias to C{"max"} for convenience. - C{"max"} - undirected graph will be created and the number of edges between vertex M{i} and M{j} is M{max(A(i,j), A(j,i))} - C{"min"} - like C{"max"}, but with M{min(A(i,j), A(j,i))} - C{"plus"} - like C{"max"}, but with M{A(i,j) + A(j,i)} - C{"upper"} - undirected graph with the upper right triangle of the matrix (including the diagonal) - C{"lower"} - undirected graph with the lower left triangle of the matrix (including the diagonal) These values can also be given as strings without the C{ADJ} prefix. @param attr: the name of the edge attribute that stores the edge weights. @param loops: whether to include loop edges. When C{False}, the diagonal of the adjacency matrix will be ignored. """ try: import numpy as np except ImportError: np = None try: from scipy import sparse except ImportError: sparse = None if sparse is not None and isinstance(matrix, sparse.spmatrix): return _graph_from_weighted_sparse_matrix( cls, matrix, mode=mode, attr=attr, loops=loops, ) if np is not None and isinstance(matrix, np.ndarray): matrix = matrix.tolist() return super().Weighted_Adjacency( matrix, mode=mode, attr=attr, loops=loops, ) def write_dimacs(self, f, source=None, target=None, capacity="capacity"): """Writes the graph in DIMACS format to the given file. @param f: the name of the file to be written or a Python file handle. @param source: the source vertex ID. If C{None}, igraph will try to infer it from the C{source} graph attribute. @param target: the target vertex ID. If C{None}, igraph will try to infer it from the C{target} graph attribute. @param capacity: the capacities of the edges in a list or the name of an edge attribute that holds the capacities. If there is no such edge attribute, every edge will have a capacity of 1. """ if source is None: try: source = self["source"] except KeyError: raise ValueError( "source vertex must be provided in the 'source' graph " "attribute or in the 'source' argument of write_dimacs()" ) if target is None: try: target = self["target"] except KeyError: raise ValueError( "target vertex must be provided in the 'target' graph " "attribute or in the 'target' argument of write_dimacs()" ) if isinstance(capacity, str) and capacity not in self.edge_attributes(): warn("'%s' edge attribute does not exist" % capacity) capacity = [1] * self.ecount() return GraphBase.write_dimacs(self, f, source, target, capacity) def write_graphmlz(self, f, compresslevel=9): """Writes the graph to a zipped GraphML file. The library uses the gzip compression algorithm, so the resulting file can be unzipped with regular gzip uncompression (like C{gunzip} or C{zcat} from Unix command line) or the Python C{gzip} module. Uses a temporary file to store intermediate GraphML data, so make sure you have enough free space to store the unzipped GraphML file as well. @param f: the name of the file to be written. @param compresslevel: the level of compression. 1 is fastest and produces the least compression, and 9 is slowest and produces the most compression.""" with named_temporary_file() as tmpfile: self.write_graphml(tmpfile) outf = gzip.GzipFile(f, "wb", compresslevel) copyfileobj(open(tmpfile, "rb"), outf) outf.close() @classmethod def Read_DIMACS(cls, f, directed=False): """Reads a graph from a file conforming to the DIMACS minimum-cost flow file format. For the exact definition of the format, see U{http://lpsolve.sourceforge.net/5.5/DIMACS.htm}. Restrictions compared to the official description of the format are as follows: - igraph's DIMACS reader requires only three fields in an arc definition, describing the edge's source and target node and its capacity. - Source vertices are identified by 's' in the FLOW field, target vertices are identified by 't'. - Node indices start from 1. Only a single source and target node is allowed. @param f: the name of the file or a Python file handle @param directed: whether the generated graph should be directed. @return: the generated graph. The indices of the source and target vertices are attached as graph attributes C{source} and C{target}, the edge capacities are stored in the C{capacity} edge attribute. """ graph, source, target, cap = super().Read_DIMACS(f, directed) graph.es["capacity"] = cap graph["source"] = source graph["target"] = target return graph @classmethod def Read_GraphMLz(cls, f, index=0): """Reads a graph from a zipped GraphML file. @param f: the name of the file @param index: if the GraphML file contains multiple graphs, specified the one that should be loaded. Graph indices start from zero, so if you want to load the first graph, specify 0 here. @return: the loaded graph object""" with named_temporary_file() as tmpfile: with open(tmpfile, "wb") as outf: copyfileobj(gzip.GzipFile(f, "rb"), outf) return cls.Read_GraphML(tmpfile, index=index) def write_pickle(self, fname=None, version=-1): """Saves the graph in Python pickled format @param fname: the name of the file or a stream to save to. If C{None}, saves the graph to a string and returns the string. @param version: pickle protocol version to be used. If -1, uses the highest protocol available @return: C{None} if the graph was saved successfully to the given file, or a string if C{fname} was C{None}. """ import pickle as pickle if fname is None: return pickle.dumps(self, version) if not hasattr(fname, "write"): file_was_opened = True fname = open(fname, "wb") else: file_was_opened = False result = pickle.dump(self, fname, version) if file_was_opened: fname.close() return result def write_picklez(self, fname=None, version=-1): """Saves the graph in Python pickled format, compressed with gzip. Saving in this format is a bit slower than saving in a Python pickle without compression, but the final file takes up much less space on the hard drive. @param fname: the name of the file or a stream to save to. @param version: pickle protocol version to be used. If -1, uses the highest protocol available @return: C{None} if the graph was saved successfully to the given file. """ import pickle as pickle file_was_opened = False if not hasattr(fname, "write"): file_was_opened = True fname = gzip.open(fname, "wb") elif not isinstance(fname, gzip.GzipFile): file_was_opened = True fname = gzip.GzipFile(mode="wb", fileobj=fname) result = pickle.dump(self, fname, version) if file_was_opened: fname.close() return result @classmethod def Read_Pickle(cls, fname=None): """Reads a graph from Python pickled format @param fname: the name of the file, a stream to read from, or a string containing the pickled data. @return: the created graph object. """ import pickle as pickle if hasattr(fname, "read"): # Probably a file or a file-like object result = pickle.load(fname) else: try: fp = open(fname, "rb") except UnicodeDecodeError: try: # We are on Python 3.6 or above and we are passing a pickled # stream that cannot be decoded as Unicode. Try unpickling # directly. result = pickle.loads(fname) except TypeError: raise IOError( "Cannot load file. If fname is a file name, that " "filename may be incorrect." ) except IOError: try: # No file with the given name, try unpickling directly. result = pickle.loads(fname) except TypeError: raise IOError( "Cannot load file. If fname is a file name, that " "filename may be incorrect." ) else: result = pickle.load(fp) fp.close() if not isinstance(result, cls): raise TypeError("unpickled object is not a %s" % cls.__name__) return result @classmethod def Read_Picklez(cls, fname): """Reads a graph from compressed Python pickled format, uncompressing it on-the-fly. @param fname: the name of the file or a stream to read from. @return: the created graph object. """ import pickle as pickle if hasattr(fname, "read"): # Probably a file or a file-like object if isinstance(fname, gzip.GzipFile): result = pickle.load(fname) else: result = pickle.load(gzip.GzipFile(mode="rb", fileobj=fname)) else: result = pickle.load(gzip.open(fname, "rb")) if not isinstance(result, cls): raise TypeError("unpickled object is not a %s" % cls.__name__) return result def write_svg( self, fname, layout="auto", width=None, height=None, labels="label", colors="color", shapes="shape", vertex_size=10, edge_colors="color", edge_stroke_widths="width", font_size=16, *args, **kwds ): """Saves the graph as an SVG (Scalable Vector Graphics) file The file will be Inkscape (http://inkscape.org) compatible. In Inkscape, as nodes are rearranged, the edges auto-update. @param fname: the name of the file or a Python file handle @param layout: the layout of the graph. Can be either an explicitly specified layout (using a list of coordinate pairs) or the name of a layout algorithm (which should refer to a method in the L{Graph} object, but without the C{layout_} prefix. @param width: the preferred width in pixels (default: 400) @param height: the preferred height in pixels (default: 400) @param labels: the vertex labels. Either it is the name of a vertex attribute to use, or a list explicitly specifying the labels. It can also be C{None}. @param colors: the vertex colors. Either it is the name of a vertex attribute to use, or a list explicitly specifying the colors. A color can be anything acceptable in an SVG file. @param shapes: the vertex shapes. Either it is the name of a vertex attribute to use, or a list explicitly specifying the shapes as integers. Shape 0 means hidden (nothing is drawn), shape 1 is a circle, shape 2 is a rectangle and shape 3 is a rectangle that automatically sizes to the inner text. @param vertex_size: vertex size in pixels @param edge_colors: the edge colors. Either it is the name of an edge attribute to use, or a list explicitly specifying the colors. A color can be anything acceptable in an SVG file. @param edge_stroke_widths: the stroke widths of the edges. Either it is the name of an edge attribute to use, or a list explicitly specifying the stroke widths. The stroke width can be anything acceptable in an SVG file. @param font_size: font size. If it is a string, it is written into the SVG file as-is (so you can specify anything which is valid as the value of the C{font-size} style). If it is a number, it is interpreted as pixel size and converted to the proper attribute value accordingly. """ if width is None and height is None: width = 400 height = 400 elif width is None: width = height elif height is None: height = width if width <= 0 or height <= 0: raise ValueError("width and height must be positive") if isinstance(layout, str): layout = self.layout(layout, *args, **kwds) if isinstance(labels, str): try: labels = self.vs.get_attribute_values(labels) except KeyError: labels = [x + 1 for x in range(self.vcount())] elif labels is None: labels = [""] * self.vcount() if isinstance(colors, str): try: colors = self.vs.get_attribute_values(colors) except KeyError: colors = ["red"] * self.vcount() if isinstance(shapes, str): try: shapes = self.vs.get_attribute_values(shapes) except KeyError: shapes = [1] * self.vcount() if isinstance(edge_colors, str): try: edge_colors = self.es.get_attribute_values(edge_colors) except KeyError: edge_colors = ["black"] * self.ecount() if isinstance(edge_stroke_widths, str): try: edge_stroke_widths = self.es.get_attribute_values(edge_stroke_widths) except KeyError: edge_stroke_widths = [2] * self.ecount() if not isinstance(font_size, str): font_size = "%spx" % str(font_size) else: if ";" in font_size: raise ValueError("font size can't contain a semicolon") vcount = self.vcount() labels.extend(str(i + 1) for i in range(len(labels), vcount)) colors.extend(["red"] * (vcount - len(colors))) if isinstance(fname, str): f = open(fname, "w") our_file = True else: f = fname our_file = False bbox = BoundingBox(layout.bounding_box()) sizes = [width - 2 * vertex_size, height - 2 * vertex_size] w, h = bbox.width, bbox.height ratios = [] if w == 0: ratios.append(1.0) else: ratios.append(sizes[0] / w) if h == 0: ratios.append(1.0) else: ratios.append(sizes[1] / h) layout = [ [ (row[0] - bbox.left) * ratios[0] + vertex_size, (row[1] - bbox.top) * ratios[1] + vertex_size, ] for row in layout ] directed = self.is_directed() print('', file=f) print( "", file=f, ) print(file=f) print( ''.format(width, height), end=" ", file=f) edge_color_dict = {} print('', file=f) for e_col in set(edge_colors): if e_col == "#000000": marker_index = "" else: marker_index = str(len(edge_color_dict)) # Print an arrow marker for each possible line color # This is a copy of Inkscape's standard Arrow 2 marker print("', file=f) print(" ', file=f) print("", file=f) edge_color_dict[e_col] = "Arrow2Lend{0}".format(marker_index) print("", file=f) print( '', file=f, ) for eidx, edge in enumerate(self.es): vidxs = edge.tuple x1 = layout[vidxs[0]][0] y1 = layout[vidxs[0]][1] x2 = layout[vidxs[1]][0] y2 = layout[vidxs[1]][1] angle = math.atan2(y2 - y1, x2 - x1) x2 -= vertex_size * math.cos(angle) y2 -= vertex_size * math.sin(angle) print("', file=f) print(" ", file=f) print(file=f) print( ' ', file=f, ) print(" ", file=f) if any(x == 3 for x in shapes): # Only import tkFont if we really need it. Unfortunately, this will # flash up an unneccesary Tk window in some cases import tkinter.font import tkinter as tk # This allows us to dynamically size the width of the nodes. # Unfortunately this works only with font sizes specified in pixels. if font_size.endswith("px"): font_size_in_pixels = int(font_size[:-2]) else: try: font_size_in_pixels = int(font_size) except Exception: raise ValueError( "font sizes must be specified in pixels " "when any of the nodes has shape=3 (i.e. " "node size determined by text size)" ) tk_window = tk.Tk() font = tkinter.font.Font( root=tk_window, font=("Sans", font_size_in_pixels, tkinter.font.NORMAL) ) else: tk_window = None for vidx in range(self.vcount()): print( ' '.format( vidx, layout[vidx][0], layout[vidx][1] ), file=f, ) if shapes[vidx] == 1: # Undocumented feature: can handle two colors but only for circles c = str(colors[vidx]) if " " in c: c = c.split(" ") vs = str(vertex_size) print( ' '.format( vs, c[0] ), file=f, ) print( ' '.format( vs, c[1] ), file=f, ) print( ' '.format(vs), file=f, ) else: print( ' '.format( str(vertex_size), str(colors[vidx]) ), file=f, ) elif shapes[vidx] == 2: print( ' '.format( vertex_size, vertex_size * 2, vidx, colors[vidx] ), file=f, ) elif shapes[vidx] == 3: (vertex_width, vertex_height) = ( font.measure(str(labels[vidx])) + 2, font.metrics("linespace") + 2, ) print( ' '.format( vertex_width / 2.0, vertex_height / 2.0, vertex_width, vertex_height, vidx, colors[vidx], ), file=f, ) print( ' '.format( vertex_size / 2.0, vidx, font_size ), file=f, ) print( '' '{2}'.format( vertex_size / 2.0, vidx, str(labels[vidx]) ), file=f, ) print(" ", file=f) print("", file=f) print(file=f) print("", file=f) if our_file: f.close() if tk_window: tk_window.destroy() @classmethod def _identify_format(cls, filename): """_identify_format(filename) Tries to identify the format of the graph stored in the file with the given filename. It identifies most file formats based on the extension of the file (and not on syntactic evaluation). The only exception is the adjacency matrix format and the edge list format: the first few lines of the file are evaluated to decide between the two. @note: Internal function, should not be called directly. @param filename: the name of the file or a file object whose C{name} attribute is set. @return: the format of the file as a string. """ import os.path if hasattr(filename, "name") and hasattr(filename, "read"): # It is most likely a file try: filename = filename.name except Exception: return None root, ext = os.path.splitext(filename) ext = ext.lower() if ext == ".gz": _, ext2 = os.path.splitext(root) ext2 = ext2.lower() if ext2 == ".pickle": return "picklez" elif ext2 == ".graphml": return "graphmlz" if ext in [ ".dimacs", ".dl", ".dot", ".edge", ".edgelist", ".edges", ".gml", ".graphml", ".graphmlz", ".gw", ".lgl", ".lgr", ".ncol", ".net", ".pajek", ".pickle", ".picklez", ".svg", ]: return ext[1:] if ext == ".txt" or ext == ".dat": # Most probably an adjacency matrix or an edge list f = open(filename, "r") line = f.readline() if line is None: return "edges" parts = line.strip().split() if len(parts) == 2: line = f.readline() if line is None: return "edges" parts = line.strip().split() if len(parts) == 2: line = f.readline() if line is None: # This is a 2x2 matrix, it can be a matrix or an edge # list as well and we cannot decide return None else: parts = line.strip().split() if len(parts) == 0: return None return "edges" else: # Not a matrix return None else: return "adjacency" @classmethod def Read(cls, f, format=None, *args, **kwds): """Unified reading function for graphs. This method tries to identify the format of the graph given in the first parameter and calls the corresponding reader method. The remaining arguments are passed to the reader method without any changes. @param f: the file containing the graph to be loaded @param format: the format of the file (if known in advance). C{None} means auto-detection. Possible values are: C{"ncol"} (NCOL format), C{"lgl"} (LGL format), C{"graphdb"} (GraphDB format), C{"graphml"}, C{"graphmlz"} (GraphML and gzipped GraphML format), C{"gml"} (GML format), C{"net"}, C{"pajek"} (Pajek format), C{"dimacs"} (DIMACS format), C{"edgelist"}, C{"edges"} or C{"edge"} (edge list), C{"adjacency"} (adjacency matrix), C{"dl"} (DL format used by UCINET), C{"pickle"} (Python pickled format), C{"picklez"} (gzipped Python pickled format) @raises IOError: if the file format can't be identified and none was given. """ if isinstance(f, os.PathLike): f = str(f) if format is None: format = cls._identify_format(f) try: reader = cls._format_mapping[format][0] except (KeyError, IndexError): raise IOError("unknown file format: %s" % str(format)) if reader is None: raise IOError("no reader method for file format: %s" % str(format)) reader = getattr(cls, reader) return reader(f, *args, **kwds) Load = Read def write(self, f, format=None, *args, **kwds): """Unified writing function for graphs. This method tries to identify the format of the graph given in the first parameter (based on extension) and calls the corresponding writer method. The remaining arguments are passed to the writer method without any changes. @param f: the file containing the graph to be saved @param format: the format of the file (if one wants to override the format determined from the filename extension, or the filename itself is a stream). C{None} means auto-detection. Possible values are: - C{"adjacency"}: adjacency matrix format - C{"dimacs"}: DIMACS format - C{"dot"}, C{"graphviz"}: GraphViz DOT format - C{"edgelist"}, C{"edges"} or C{"edge"}: numeric edge list format - C{"gml"}: GML format - C{"graphml"} and C{"graphmlz"}: standard and gzipped GraphML format - C{"gw"}, C{"leda"}, C{"lgr"}: LEDA native format - C{"lgl"}: LGL format - C{"ncol"}: NCOL format - C{"net"}, C{"pajek"}: Pajek format - C{"pickle"}, C{"picklez"}: standard and gzipped Python pickled format - C{"svg"}: SVG format @raises IOError: if the file format can't be identified and none was given. """ if isinstance(f, os.PathLike): f = str(f) if format is None: format = self._identify_format(f) try: writer = self._format_mapping[format][1] except (KeyError, IndexError): raise IOError("unknown file format: %s" % str(format)) if writer is None: raise IOError("no writer method for file format: %s" % str(format)) writer = getattr(self, writer) return writer(f, *args, **kwds) save = write ##################################################### # Constructor for dict-like representation of graphs @classmethod def DictList( cls, vertices, edges, directed=False, vertex_name_attr="name", edge_foreign_keys=("source", "target"), iterative=False, ): """Constructs a graph from a list-of-dictionaries representation. This representation assumes that vertices and edges are encoded in two lists, each list containing a Python dict for each vertex and each edge, respectively. A distinguished element of the vertex dicts contain a vertex ID which is used in the edge dicts to refer to source and target vertices. All the remaining elements of the dict are considered vertex and edge attributes. Note that the implementation does not assume that the objects passed to this method are indeed lists of dicts, but they should be iterable and they should yield objects that behave as dicts. So, for instance, a database query result is likely to be fit as long as it's iterable and yields dict-like objects with every iteration. @param vertices: the data source for the vertices or C{None} if there are no special attributes assigned to vertices and we should simply use the edge list of dicts to infer vertex names. @param edges: the data source for the edges. @param directed: whether the constructed graph will be directed @param vertex_name_attr: the name of the distinguished key in the dicts in the vertex data source that contains the vertex names. Ignored if C{vertices} is C{None}. @param edge_foreign_keys: the name of the attributes in the dicts in the edge data source that contain the source and target vertex names. @param iterative: whether to add the edges to the graph one by one, iteratively, or to build a large edge list first and use that to construct the graph. The latter approach is faster but it may not be suitable if your dataset is large. The default is to add the edges in a batch from an edge list. @return: the graph that was constructed """ def create_list_from_indices(indices, n): result = [None] * n for i, v in indices: result[i] = v return result # Construct the vertices vertex_attrs, n = {}, 0 if vertices: for idx, vertex_data in enumerate(vertices): for k, v in vertex_data.items(): try: vertex_attrs[k].append((idx, v)) except KeyError: vertex_attrs[k] = [(idx, v)] n += 1 for k, v in vertex_attrs.items(): vertex_attrs[k] = create_list_from_indices(v, n) else: vertex_attrs[vertex_name_attr] = [] vertex_names = vertex_attrs[vertex_name_attr] # Check for duplicates in vertex_names if len(vertex_names) != len(set(vertex_names)): raise ValueError("vertex names are not unique") # Create a reverse mapping from vertex names to indices vertex_name_map = UniqueIdGenerator(initial=vertex_names) # Construct the edges efk_src, efk_dest = edge_foreign_keys if iterative: g = cls(n, [], directed, {}, vertex_attrs) for idx, edge_data in enumerate(edges): src_name, dst_name = edge_data[efk_src], edge_data[efk_dest] v1 = vertex_name_map[src_name] if v1 == n: g.add_vertices(1) g.vs[n][vertex_name_attr] = src_name n += 1 v2 = vertex_name_map[dst_name] if v2 == n: g.add_vertices(1) g.vs[n][vertex_name_attr] = dst_name n += 1 g.add_edge(v1, v2) for k, v in edge_data.items(): g.es[idx][k] = v return g else: edge_list, edge_attrs, m = [], {}, 0 for idx, edge_data in enumerate(edges): v1 = vertex_name_map[edge_data[efk_src]] v2 = vertex_name_map[edge_data[efk_dest]] edge_list.append((v1, v2)) for k, v in edge_data.items(): try: edge_attrs[k].append((idx, v)) except KeyError: edge_attrs[k] = [(idx, v)] m += 1 for k, v in edge_attrs.items(): edge_attrs[k] = create_list_from_indices(v, m) # It may have happened that some vertices were added during # the process if len(vertex_name_map) > n: diff = len(vertex_name_map) - n more = [None] * diff for k, v in vertex_attrs.items(): v.extend(more) vertex_attrs[vertex_name_attr] = list(vertex_name_map.values()) n = len(vertex_name_map) # Create the graph return cls(n, edge_list, directed, {}, vertex_attrs, edge_attrs) ##################################################### # Constructor for tuple-like representation of graphs @classmethod def TupleList( cls, edges, directed=False, vertex_name_attr="name", edge_attrs=None, weights=False, ): """Constructs a graph from a list-of-tuples representation. This representation assumes that the edges of the graph are encoded in a list of tuples (or lists). Each item in the list must have at least two elements, which specify the source and the target vertices of the edge. The remaining elements (if any) specify the edge attributes of that edge, where the names of the edge attributes originate from the C{edge_attrs} list. The names of the vertices will be stored in the vertex attribute given by C{vertex_name_attr}. The default parameters of this function are suitable for creating unweighted graphs from lists where each item contains the source vertex and the target vertex. If you have a weighted graph, you can use items where the third item contains the weight of the edge by setting C{edge_attrs} to C{"weight"} or C{["weight"]}. If you have even more edge attributes, add them to the end of each item in the C{edges} list and also specify the corresponding edge attribute names in C{edge_attrs} as a list. @param edges: the data source for the edges. This must be a list where each item is a tuple (or list) containing at least two items: the name of the source and the target vertex. Note that names will be assigned to the C{name} vertex attribute (or another vertex attribute if C{vertex_name_attr} is specified), even if all the vertex names in the list are in fact numbers. @param directed: whether the constructed graph will be directed @param vertex_name_attr: the name of the vertex attribute that will contain the vertex names. @param edge_attrs: the names of the edge attributes that are filled with the extra items in the edge list (starting from index 2, since the first two items are the source and target vertices). C{None} means that only the source and target vertices will be extracted from each item. If you pass a string here, it will be wrapped in a list for convenience. @param weights: alternative way to specify that the graph is weighted. If you set C{weights} to C{true} and C{edge_attrs} is not given, it will be assumed that C{edge_attrs} is C{["weight"]} and igraph will parse the third element from each item into an edge weight. If you set C{weights} to a string, it will be assumed that C{edge_attrs} contains that string only, and igraph will store the edge weights in that attribute. @return: the graph that was constructed """ if edge_attrs is None: if not weights: edge_attrs = () else: if not isinstance(weights, str): weights = "weight" edge_attrs = [weights] else: if weights: raise ValueError( "`weights` must be False if `edge_attrs` is " "not None" ) if isinstance(edge_attrs, str): edge_attrs = [edge_attrs] # Set up a vertex ID generator idgen = UniqueIdGenerator() # Construct the edges and the edge attributes edge_list = [] edge_attributes = {} for name in edge_attrs: edge_attributes[name] = [] for item in edges: edge_list.append((idgen[item[0]], idgen[item[1]])) for index, name in enumerate(edge_attrs, 2): try: edge_attributes[name].append(item[index]) except IndexError: edge_attributes[name].append(None) # Set up the "name" vertex attribute vertex_attributes = {} vertex_attributes[vertex_name_attr] = list(idgen.values()) n = len(idgen) # Construct the graph return cls(n, edge_list, directed, {}, vertex_attributes, edge_attributes) ################################# # Constructor for graph formulae Formula = classmethod(construct_graph_from_formula) ########################### # Vertex and edge sequence @property def vs(self): """The vertex sequence of the graph""" return VertexSeq(self) @property def es(self): """The edge sequence of the graph""" return EdgeSeq(self) ############################################# # Friendlier interface for bipartite methods @classmethod def Bipartite(cls, types, edges, directed=False, *args, **kwds): """Creates a bipartite graph with the given vertex types and edges. This is similar to the default constructor of the graph, the only difference is that it checks whether all the edges go between the two vertex classes and it assigns the type vector to a C{type} attribute afterwards. Examples: >>> g = Graph.Bipartite([0, 1, 0, 1], [(0, 1), (2, 3), (0, 3)]) >>> g.is_bipartite() True >>> g.vs["type"] [False, True, False, True] @param types: the vertex types as a boolean list. Anything that evaluates to C{False} will denote a vertex of the first kind, anything that evaluates to C{True} will denote a vertex of the second kind. @param edges: the edges as a list of tuples. @param directed: whether to create a directed graph. Bipartite networks are usually undirected, so the default is C{False} @return: the graph with a binary vertex attribute named C{"type"} that stores the vertex classes. """ result = cls._Bipartite(types, edges, directed, *args, **kwds) result.vs["type"] = [bool(x) for x in types] return result @classmethod def Full_Bipartite(cls, n1, n2, directed=False, mode="all", *args, **kwds): """Generates a full bipartite graph (directed or undirected, with or without loops). >>> g = Graph.Full_Bipartite(2, 3) >>> g.is_bipartite() True >>> g.vs["type"] [False, False, True, True, True] @param n1: the number of vertices of the first kind. @param n2: the number of vertices of the second kind. @param directed: whether tp generate a directed graph. @param mode: if C{"out"}, then all vertices of the first kind are connected to the others; C{"in"} specifies the opposite direction, C{"all"} creates mutual edges. Ignored for undirected graphs. @return: the graph with a binary vertex attribute named C{"type"} that stores the vertex classes. """ result, types = cls._Full_Bipartite(n1, n2, directed, mode, *args, **kwds) result.vs["type"] = types return result @classmethod def Random_Bipartite( cls, n1, n2, p=None, m=None, directed=False, neimode="all", *args, **kwds ): """Generates a random bipartite graph with the given number of vertices and edges (if m is given), or with the given number of vertices and the given connection probability (if p is given). If m is given but p is not, the generated graph will have n1 vertices of type 1, n2 vertices of type 2 and m randomly selected edges between them. If p is given but m is not, the generated graph will have n1 vertices of type 1 and n2 vertices of type 2, and each edge will exist between them with probability p. @param n1: the number of vertices of type 1. @param n2: the number of vertices of type 2. @param p: the probability of edges. If given, C{m} must be missing. @param m: the number of edges. If given, C{p} must be missing. @param directed: whether to generate a directed graph. @param neimode: if the graph is directed, specifies how the edges will be generated. If it is C{"all"}, edges will be generated in both directions (from type 1 to type 2 and vice versa) independently. If it is C{"out"} edges will always point from type 1 to type 2. If it is C{"in"}, edges will always point from type 2 to type 1. This argument is ignored for undirected graphs. """ if p is None: p = -1 if m is None: m = -1 result, types = cls._Random_Bipartite( n1, n2, p, m, directed, neimode, *args, **kwds ) result.vs["type"] = types return result @classmethod def GRG(cls, n, radius, torus=False): """Generates a random geometric graph. The algorithm drops the vertices randomly on the 2D unit square and connects them if they are closer to each other than the given radius. The coordinates of the vertices are stored in the vertex attributes C{x} and C{y}. @param n: The number of vertices in the graph @param radius: The given radius @param torus: This should be C{True} if we want to use a torus instead of a square. """ result, xs, ys = cls._GRG(n, radius, torus) result.vs["x"] = xs result.vs["y"] = ys return result @classmethod def Incidence( cls, matrix, directed=False, mode="out", multiple=False, weighted=None, *args, **kwds ): """Creates a bipartite graph from an incidence matrix. Example: >>> g = Graph.Incidence([[0, 1, 1], [1, 1, 0]]) @param matrix: the incidence matrix. @param directed: whether to create a directed graph. @param mode: defines the direction of edges in the graph. If C{"out"}, then edges go from vertices of the first kind (corresponding to rows of the matrix) to vertices of the second kind (the columns of the matrix). If C{"in"}, the opposite direction is used. C{"all"} creates mutual edges. Ignored for undirected graphs. @param multiple: defines what to do with non-zero entries in the matrix. If C{False}, non-zero entries will create an edge no matter what the value is. If C{True}, non-zero entries are rounded up to the nearest integer and this will be the number of multiple edges created. @param weighted: defines whether to create a weighted graph from the incidence matrix. If it is c{None} then an unweighted graph is created and the multiple argument is used to determine the edges of the graph. If it is a string then for every non-zero matrix entry, an edge is created and the value of the entry is added as an edge attribute named by the weighted argument. If it is C{True} then a weighted graph is created and the name of the edge attribute will be ‘weight’. @raise ValueError: if the weighted and multiple are passed together. @return: the graph with a binary vertex attribute named C{"type"} that stores the vertex classes. """ is_weighted = True if weighted or weighted == "" else False if is_weighted and multiple: raise ValueError("arguments weighted and multiple can not co-exist") result, types = cls._Incidence(matrix, directed, mode, multiple, *args, **kwds) result.vs["type"] = types if is_weighted: weight_attr = "weight" if weighted is True else weighted _, rows, _ = result.get_incidence() num_vertices_of_first_kind = len(rows) for edge in result.es: source, target = edge.tuple if source in rows: edge[weight_attr] = matrix[source][ target - num_vertices_of_first_kind ] else: edge[weight_attr] = matrix[target][ source - num_vertices_of_first_kind ] return result @classmethod def DataFrame(cls, edges, directed=True, vertices=None, use_vids=False): """Generates a graph from one or two dataframes. @param edges: pandas DataFrame containing edges and metadata. The first two columns of this DataFrame contain the source and target vertices for each edge. These indicate the vertex *names* rather than IDs unless `use_vids` is True and these are non-negative integers. Further columns may contain edge attributes. @param directed: bool setting whether the graph is directed @param vertices: None (default) or pandas DataFrame containing vertex metadata. The first column of the DataFrame must contain the unique vertex *names*. If `use_vids` is True, the DataFrame's index must contain the vertex IDs as a sequence of intergers from `0` to `len(vertices) - 1`. All other columns will be added as vertex attributes by column name. @use_vids: whether to interpret the first two columns of the `edges` argument as vertex ids (0-based integers) instead of vertex names. If this argument is set to True and the first two columns of `edges` are not integers, an error is thrown. @return: the graph Vertex names in either the `edges` or `vertices` arguments that are set to NaN (not a number) will be set to the string "NA". That might lead to unexpected behaviour: fill your NaNs with values before calling this function to mitigate. """ try: import pandas as pd except ImportError: raise ImportError("You should install pandas in order to use this function") try: import numpy as np except: raise ImportError("You should install numpy in order to use this function") if edges.shape[1] < 2: raise ValueError("The 'edges' DataFrame must contain at least two columns") if vertices is not None and vertices.shape[1] < 1: raise ValueError("The 'vertices' DataFrame must contain at least one column") if use_vids: if not (str(edges.dtypes[0]).startswith("int") and str(edges.dtypes[1]).startswith("int")): raise TypeError(f"Source and target IDs must be 0-based integers, found types {edges.dtypes.tolist()[:2]}") elif (edges.iloc[:, :2] < 0).any(axis=None): raise ValueError("Source and target IDs must not be negative") if vertices is not None: vertices = vertices.sort_index() if not vertices.index.equals(pd.RangeIndex.from_range(range(vertices.shape[0]))): if not str(vertices.index.dtype).startswith("int"): raise TypeError(f"Vertex IDs must be 0-based integers, found type {vertices.index.dtype}") elif (vertices.index < 0).any(axis=None): raise ValueError("Vertex IDs must not be negative") else: raise ValueError(f"Vertex IDs must be an integer sequence from 0 to {vertices.shape[0] - 1}") else: # Handle if some source and target names in 'edges' are 'NA' if edges.iloc[:, :2].isna().any(axis=None): warn("In the first two columns of 'edges' NA elements were replaced with string \"NA\"") edges = edges.copy() edges.iloc[:, :2].fillna("NA", inplace=True) # Bring DataFrame(s) into same format as with 'use_vids=True' if vertices is None: vertices = pd.DataFrame({"name": np.unique(edges.values[:, :2])}) if vertices.iloc[:, 0].isna().any(): warn("In the first column of 'vertices' NA elements were replaced with string \"NA\"") vertices = vertices.copy() vertices.iloc[:, 0].fillna("NA", inplace=True) if vertices.iloc[:, 0].duplicated().any(): raise ValueError("Vertex names must be unique") if vertices.shape[1] > 1 and "name" in vertices.columns[1:]: raise ValueError("Vertex attribute conflict: DataFrame already contains column 'name'") vertices = vertices.rename({vertices.columns[0]: "name"}, axis=1).reset_index(drop=True) # Map source and target names in 'edges' to IDs vid_map = pd.Series(vertices.index, index=vertices.iloc[:, 0]) edges = edges.copy() edges.iloc[:, 0] = edges.iloc[:, 0].map(vid_map) edges.iloc[:, 1] = edges.iloc[:, 1].map(vid_map) # Create graph if vertices is None: nv = edges.iloc[:, :2].max().max() + 1 g = Graph(n=nv, directed=directed) else: if not edges.iloc[:, :2].isin(vertices.index).all(axis=None): raise ValueError("Some vertices in the edge DataFrame are missing from vertices DataFrame") nv = vertices.shape[0] g = Graph(n=nv, directed=directed) # Add vertex attributes for col in vertices.columns: g.vs[col] = vertices[col].tolist() # add edges including optional attributes e_list = list(edges.iloc[:, :2].itertuples(index=False, name=None)) e_attr = edges.iloc[:, 2:].to_dict(orient='list') if edges.shape[1] > 2 else None g.add_edges(e_list, e_attr) return g def get_vertex_dataframe(self): """Export vertices with attributes to pandas.DataFrame If you want to use vertex names as index, you can do: >>> from string import ascii_letters >>> graph = Graph.GRG(25, 0.4) >>> graph.vs["name"] = ascii_letters[:graph.vcount()] >>> df = graph.get_vertex_dataframe() >>> df.set_index('name', inplace=True) @return: a pandas.DataFrame representing vertices and their attributes. The index uses vertex IDs, from 0 to N - 1 where N is the number of vertices. """ try: import pandas as pd except ImportError: raise ImportError("You should install pandas in order to use this function") df = pd.DataFrame( {attr: self.vs[attr] for attr in self.vertex_attributes()}, index=list(range(self.vcount())), ) df.index.name = "vertex ID" return df def get_edge_dataframe(self): """Export edges with attributes to pandas.DataFrame If you want to use source and target vertex IDs as index, you can do: >>> from string import ascii_letters >>> graph = Graph.GRG(25, 0.4) >>> graph.vs["name"] = ascii_letters[:graph.vcount()] >>> df = graph.get_edge_dataframe() >>> df.set_index(['source', 'target'], inplace=True) The index will be a pandas.MultiIndex. You can use the `drop=False` option to keep the `source` and `target` columns. If you want to use vertex names in the source and target columns: >>> df = graph.get_edge_dataframe() >>> df_vert = graph.get_vertex_dataframe() >>> df['source'].replace(df_vert['name'], inplace=True) >>> df['target'].replace(df_vert['name'], inplace=True) >>> df_vert.set_index('name', inplace=True) # Optional @return: a pandas.DataFrame representing edges and their attributes. The index uses edge IDs, from 0 to M - 1 where M is the number of edges. The first two columns of the dataframe represent the IDs of source and target vertices for each edge. These columns have names "source" and "target". If your edges have attributes with the same names, they will be present in the dataframe, but not in the first two columns. """ try: import pandas as pd except ImportError: raise ImportError("You should install pandas in order to use this function") df = pd.DataFrame( {attr: self.es[attr] for attr in self.edge_attributes()}, index=list(range(self.ecount())), ) df.index.name = "edge ID" df.insert(0, "source", [e.source for e in self.es], allow_duplicates=True) df.insert(1, "target", [e.target for e in self.es], allow_duplicates=True) return df def bipartite_projection( self, types="type", multiplicity=True, probe1=-1, which="both" ): """Projects a bipartite graph into two one-mode graphs. Edge directions are ignored while projecting. Examples: >>> g = Graph.Full_Bipartite(10, 5) >>> g1, g2 = g.bipartite_projection() >>> g1.isomorphic(Graph.Full(10)) True >>> g2.isomorphic(Graph.Full(5)) True @param types: an igraph vector containing the vertex types, or an attribute name. Anything that evalulates to C{False} corresponds to vertices of the first kind, everything else to the second kind. @param multiplicity: if C{True}, then igraph keeps the multiplicity of the edges in the projection in an edge attribute called C{"weight"}. E.g., if there is an A-C-B and an A-D-B triplet in the bipartite graph and there is no other X (apart from X=B and X=D) for which an A-X-B triplet would exist in the bipartite graph, the multiplicity of the A-B edge in the projection will be 2. @param probe1: this argument can be used to specify the order of the projections in the resulting list. If given and non-negative, then it is considered as a vertex ID; the projection containing the vertex will be the first one in the result. @param which: this argument can be used to specify which of the two projections should be returned if only one of them is needed. Passing 0 here means that only the first projection is returned, while 1 means that only the second projection is returned. (Note that we use 0 and 1 because Python indexing is zero-based). C{False} is equivalent to 0 and C{True} is equivalent to 1. Any other value means that both projections will be returned in a tuple. @return: a tuple containing the two projected one-mode graphs if C{which} is not 1 or 2, or the projected one-mode graph specified by the C{which} argument if its value is 0, 1, C{False} or C{True}. """ superclass_meth = super().bipartite_projection if which is False: which = 0 elif which is True: which = 1 if which != 0 and which != 1: which = -1 if multiplicity: if which == 0: g1, w1 = superclass_meth(types, True, probe1, which) g2, w2 = None, None elif which == 1: g1, w1 = None, None g2, w2 = superclass_meth(types, True, probe1, which) else: g1, g2, w1, w2 = superclass_meth(types, True, probe1, which) if g1 is not None: g1.es["weight"] = w1 if g2 is not None: g2.es["weight"] = w2 return g1, g2 else: return g1 else: g2.es["weight"] = w2 return g2 else: return superclass_meth(types, False, probe1, which) def bipartite_projection_size(self, types="type", *args, **kwds): """Calculates the number of vertices and edges in the bipartite projections of this graph according to the specified vertex types. This is useful if you have a bipartite graph and you want to estimate the amount of memory you would need to calculate the projections themselves. @param types: an igraph vector containing the vertex types, or an attribute name. Anything that evalulates to C{False} corresponds to vertices of the first kind, everything else to the second kind. @return: a 4-tuple containing the number of vertices and edges in the first projection, followed by the number of vertices and edges in the second projection. """ return super().bipartite_projection_size(types, *args, **kwds) def get_incidence(self, types="type", *args, **kwds): """Returns the incidence matrix of a bipartite graph. The incidence matrix is an M{n} times M{m} matrix, where M{n} and M{m} are the number of vertices in the two vertex classes. @param types: an igraph vector containing the vertex types, or an attribute name. Anything that evalulates to C{False} corresponds to vertices of the first kind, everything else to the second kind. @return: the incidence matrix and two lists in a triplet. The first list defines the mapping between row indices of the matrix and the original vertex IDs. The second list is the same for the column indices. """ return super().get_incidence(types, *args, **kwds) ########################### # DFS (C version will come soon) def dfs(self, vid, mode=OUT): """Conducts a depth first search (DFS) on the graph. @param vid: the root vertex ID @param mode: either C{\"in\"} or C{\"out\"} or C{\"all\"}, ignored for undirected graphs. @return: a tuple with the following items: - The vertex IDs visited (in order) - The parent of every vertex in the DFS """ nv = self.vcount() added = [False for v in range(nv)] stack = [] # prepare output vids = [] parents = [] # ok start from vid stack.append((vid, self.neighbors(vid, mode=mode))) vids.append(vid) parents.append(vid) added[vid] = True # go down the rabbit hole while stack: vid, neighbors = stack[-1] if neighbors: # Get next neighbor to visit neighbor = neighbors.pop() if not added[neighbor]: # Add hanging subtree neighbor stack.append((neighbor, self.neighbors(neighbor, mode=mode))) vids.append(neighbor) parents.append(vid) added[neighbor] = True else: # No neighbor found, end of subtree stack.pop() return (vids, parents) ########################### # ctypes support @property def _as_parameter_(self): return self._raw_pointer() ################### # Custom operators def __iadd__(self, other): """In-place addition (disjoint union). @see: L{__add__} """ if isinstance(other, (int, str)): self.add_vertices(other) return self elif isinstance(other, tuple) and len(other) == 2: self.add_edges([other]) return self elif isinstance(other, list): if not other: return self if isinstance(other[0], tuple): self.add_edges(other) return self if isinstance(other[0], str): self.add_vertices(other) return self return NotImplemented def __add__(self, other): """Copies the graph and extends the copy depending on the type of the other object given. @param other: if it is an integer, the copy is extended by the given number of vertices. If it is a string, the copy is extended by a single vertex whose C{name} attribute will be equal to the given string. If it is a tuple with two elements, the copy is extended by a single edge. If it is a list of tuples, the copy is extended by multiple edges. If it is a L{Graph}, a disjoint union is performed. """ if isinstance(other, (int, str)): g = self.copy() g.add_vertices(other) elif isinstance(other, tuple) and len(other) == 2: g = self.copy() g.add_edges([other]) elif isinstance(other, list): if len(other) > 0: if isinstance(other[0], tuple): g = self.copy() g.add_edges(other) elif isinstance(other[0], str): g = self.copy() g.add_vertices(other) elif isinstance(other[0], Graph): return self.disjoint_union(other) else: return NotImplemented else: return self.copy() elif isinstance(other, Graph): return self.disjoint_union(other) else: return NotImplemented return g def __and__(self, other): """Graph intersection operator. @param other: the other graph to take the intersection with. @return: the intersected graph. """ if isinstance(other, Graph): return self.intersection(other) else: return NotImplemented def __isub__(self, other): """In-place subtraction (difference). @see: L{__sub__}""" if isinstance(other, int): self.delete_vertices([other]) elif isinstance(other, tuple) and len(other) == 2: self.delete_edges([other]) elif isinstance(other, list): if len(other) > 0: if isinstance(other[0], tuple): self.delete_edges(other) elif isinstance(other[0], (int, str)): self.delete_vertices(other) else: return NotImplemented elif isinstance(other, Vertex): self.delete_vertices(other) elif isinstance(other, VertexSeq): self.delete_vertices(other) elif isinstance(other, Edge): self.delete_edges(other) elif isinstance(other, EdgeSeq): self.delete_edges(other) else: return NotImplemented return self def __sub__(self, other): """Removes the given object(s) from the graph @param other: if it is an integer, removes the vertex with the given ID from the graph (note that the remaining vertices will get re-indexed!). If it is a tuple, removes the given edge. If it is a graph, takes the difference of the two graphs. Accepts lists of integers or lists of tuples as well, but they can't be mixed! Also accepts L{Edge} and L{EdgeSeq} objects. """ if isinstance(other, Graph): return self.difference(other) result = self.copy() if isinstance(other, (int, str)): result.delete_vertices([other]) elif isinstance(other, tuple) and len(other) == 2: result.delete_edges([other]) elif isinstance(other, list): if len(other) > 0: if isinstance(other[0], tuple): result.delete_edges(other) elif isinstance(other[0], (int, str)): result.delete_vertices(other) else: return NotImplemented else: return result elif isinstance(other, Vertex): result.delete_vertices(other) elif isinstance(other, VertexSeq): result.delete_vertices(other) elif isinstance(other, Edge): result.delete_edges(other) elif isinstance(other, EdgeSeq): result.delete_edges(other) else: return NotImplemented return result def __mul__(self, other): """Copies exact replicas of the original graph an arbitrary number of times. @param other: if it is an integer, multiplies the graph by creating the given number of identical copies and taking the disjoint union of them. """ if isinstance(other, int): if other == 0: return Graph() elif other == 1: return self elif other > 1: return self.disjoint_union([self] * (other - 1)) else: return NotImplemented return NotImplemented def __bool__(self): """Returns True if the graph has at least one vertex, False otherwise.""" return self.vcount() > 0 def __or__(self, other): """Graph union operator. @param other: the other graph to take the union with. @return: the union graph. """ if isinstance(other, Graph): return self.union(other) else: return NotImplemented def __coerce__(self, other): """Coercion rules. This method is needed to allow the graph to react to additions with lists, tuples, integers, strings, vertices, edges and so on. """ if isinstance(other, (int, tuple, list, str)): return self, other if isinstance(other, Vertex): return self, other if isinstance(other, VertexSeq): return self, other if isinstance(other, Edge): return self, other if isinstance(other, EdgeSeq): return self, other return NotImplemented @classmethod def _reconstruct(cls, attrs, *args, **kwds): """Reconstructs a Graph object from Python's pickled format. This method is for internal use only, it should not be called directly.""" result = cls(*args, **kwds) result.__dict__.update(attrs) return result def __reduce__(self): """Support for pickling.""" constructor = self.__class__ gattrs, vattrs, eattrs = {}, {}, {} for attr in self.attributes(): gattrs[attr] = self[attr] for attr in self.vs.attribute_names(): vattrs[attr] = self.vs[attr] for attr in self.es.attribute_names(): eattrs[attr] = self.es[attr] parameters = ( self.vcount(), self.get_edgelist(), self.is_directed(), gattrs, vattrs, eattrs, ) return (constructor, parameters, self.__dict__) __iter__ = None # needed for PyPy __hash__ = None # needed for PyPy def __plot__(self, context, bbox, palette, *args, **kwds): """Plots the graph to the given Cairo context in the given bounding box The visual style of vertices and edges can be modified at three places in the following order of precedence (lower indices override higher indices): 1. Keyword arguments of this function (or of L{plot()} which is passed intact to C{Graph.__plot__()}. 2. Vertex or edge attributes, specified later in the list of keyword arguments. 3. igraph-wide plotting defaults (see L{igraph.config.Configuration}) 4. Built-in defaults. E.g., if the C{vertex_size} keyword attribute is not present, but there exists a vertex attribute named C{size}, the sizes of the vertices will be specified by that attribute. Besides the usual self-explanatory plotting parameters (C{context}, C{bbox}, C{palette}), it accepts the following keyword arguments: - C{autocurve}: whether to use curves instead of straight lines for multiple edges on the graph plot. This argument may be C{True} or C{False}; when omitted, C{True} is assumed for graphs with less than 10.000 edges and C{False} otherwise. - C{drawer_factory}: a subclass of L{AbstractCairoGraphDrawer} which will be used to draw the graph. You may also provide a function here which takes two arguments: the Cairo context to draw on and a bounding box (an instance of L{BoundingBox}). If this keyword argument is missing, igraph will use the default graph drawer which should be suitable for most purposes. It is safe to omit this keyword argument unless you need to use a specific graph drawer. - C{keep_aspect_ratio}: whether to keep the aspect ratio of the layout that igraph calculates to place the nodes. C{True} means that the layout will be scaled proportionally to fit into the bounding box where the graph is to be drawn but the aspect ratio will be kept the same (potentially leaving empty space next to, below or above the graph). C{False} means that the layout will be scaled independently along the X and Y axis in order to fill the entire bounding box. The default is C{False}. - C{layout}: the layout to be used. If not an instance of L{Layout}, it will be passed to L{layout} to calculate the layout. Note that if you want a deterministic layout that does not change with every plot, you must either use a deterministic layout function (like L{layout_circle}) or calculate the layout in advance and pass a L{Layout} object here. - C{margin}: the top, right, bottom, left margins as a 4-tuple. If it has less than 4 elements or is a single float, the elements will be re-used until the length is at least 4. - C{mark_groups}: whether to highlight some of the vertex groups by colored polygons. This argument can be one of the following: - C{False}: no groups will be highlighted - C{True}: only valid if the object plotted is a L{VertexClustering} or L{VertexCover}. The vertex groups in the clutering or cover will be highlighted such that the i-th group will be colored by the i-th color from the current palette. If used when plotting a graph, it will throw an error. - A dict mapping tuples of vertex indices to color names. The given vertex groups will be highlighted by the given colors. - A list containing pairs or an iterable yielding pairs, where the first element of each pair is a list of vertex indices and the second element is a color. - A L{VertexClustering} or L{VertexCover} instance. The vertex groups in the clustering or cover will be highlighted such that the i-th group will be colored by the i-th color from the current palette. In place of lists of vertex indices, you may also use L{VertexSeq} instances. In place of color names, you may also use color indices into the current palette. C{None} as a color name will mean that the corresponding group is ignored. - C{vertex_size}: size of the vertices. The corresponding vertex attribute is called C{size}. The default is 10. Vertex sizes are measured in the unit of the Cairo context on which igraph is drawing. - C{vertex_color}: color of the vertices. The corresponding vertex attribute is C{color}, the default is red. Colors can be specified either by common X11 color names (see the source code of L{igraph.drawing.colors} for a list of known colors), by 3-tuples of floats (ranging between 0 and 255 for the R, G and B components), by CSS-style string specifications (C{#rrggbb}) or by integer color indices of the specified palette. - C{vertex_frame_color}: color of the frame (i.e. stroke) of the vertices. The corresponding vertex attribute is C{frame_color}, the default is black. See C{vertex_color} for the possible ways of specifying a color. - C{vertex_frame_width}: the width of the frame (i.e. stroke) of the vertices. The corresponding vertex attribute is C{frame_width}. The default is 1. Vertex frame widths are measured in the unit of the Cairo context on which igraph is drawing. - C{vertex_shape}: shape of the vertices. Alternatively it can be specified by the C{shape} vertex attribute. Possibilities are: C{square}, {circle}, {triangle}, {triangle-down} or C{hidden}. See the source code of L{igraph.drawing} for a list of alternative shape names that are also accepted and mapped to these. - C{vertex_label}: labels drawn next to the vertices. The corresponding vertex attribute is C{label}. - C{vertex_label_dist}: distance of the midpoint of the vertex label from the center of the corresponding vertex. The corresponding vertex attribute is C{label_dist}. - C{vertex_label_color}: color of the label. Corresponding vertex attribute: C{label_color}. See C{vertex_color} for color specification syntax. - C{vertex_label_size}: font size of the label, specified in the unit of the Cairo context on which we are drawing. Corresponding vertex attribute: C{label_size}. - C{vertex_label_angle}: the direction of the line connecting the midpoint of the vertex with the midpoint of the label. This can be used to position the labels relative to the vertices themselves in conjunction with C{vertex_label_dist}. Corresponding vertex attribute: C{label_angle}. The default is C{-math.pi/2}. - C{vertex_order}: drawing order of the vertices. This must be a list or tuple containing vertex indices; vertices are then drawn according to this order. - C{vertex_order_by}: an alternative way to specify the drawing order of the vertices; this attribute is interpreted as the name of a vertex attribute, and vertices are drawn such that those with a smaller attribute value are drawn first. You may also reverse the order by passing a tuple here; the first element of the tuple should be the name of the attribute, the second element specifies whether the order is reversed (C{True}, C{False}, C{"asc"} and C{"desc"} are accepted values). - C{edge_color}: color of the edges. The corresponding edge attribute is C{color}, the default is red. See C{vertex_color} for color specification syntax. - C{edge_curved}: whether the edges should be curved. Positive numbers correspond to edges curved in a counter-clockwise direction, negative numbers correspond to edges curved in a clockwise direction. Zero represents straight edges. C{True} is interpreted as 0.5, C{False} is interpreted as 0. The default is 0 which makes all the edges straight. - C{edge_width}: width of the edges in the default unit of the Cairo context on which we are drawing. The corresponding edge attribute is C{width}, the default is 1. - C{edge_arrow_size}: arrow size of the edges. The corresponding edge attribute is C{arrow_size}, the default is 1. - C{edge_arrow_width}: width of the arrowhead on the edge. The corresponding edge attribute is C{arrow_width}, the default is 1. - C{edge_order}: drawing order of the edges. This must be a list or tuple containing edge indices; edges are then drawn according to this order. - C{edge_order_by}: an alternative way to specify the drawing order of the edges; this attribute is interpreted as the name of an edge attribute, and edges are drawn such that those with a smaller attribute value are drawn first. You may also reverse the order by passing a tuple here; the first element of the tuple should be the name of the attribute, the second element specifies whether the order is reversed (C{True}, C{False}, C{"asc"} and C{"desc"} are accepted values). """ drawer_factory = kwds.get("drawer_factory", DefaultGraphDrawer) if "drawer_factory" in kwds: del kwds["drawer_factory"] drawer = drawer_factory(context, bbox) drawer.draw(self, palette, *args, **kwds) def __str__(self): """Returns a string representation of the graph. Behind the scenes, this method constructs a L{GraphSummary} instance and invokes its C{__str__} method with a verbosity of 1 and attribute printing turned off. See the documentation of L{GraphSummary} for more details about the output. """ params = dict( verbosity=1, width=78, print_graph_attributes=False, print_vertex_attributes=False, print_edge_attributes=False, ) return self.summary(**params) def summary(self, verbosity=0, width=None, *args, **kwds): """Returns the summary of the graph. The output of this method is similar to the output of the C{__str__} method. If I{verbosity} is zero, only the header line is returned (see C{__str__} for more details), otherwise the header line and the edge list is printed. Behind the scenes, this method constructs a L{GraphSummary} object and invokes its C{__str__} method. @param verbosity: if zero, only the header line is returned (see C{__str__} for more details), otherwise the header line and the full edge list is printed. @param width: the number of characters to use in one line. If C{None}, no limit will be enforced on the line lengths. @return: the summary of the graph. """ return str(GraphSummary(self, verbosity, width, *args, **kwds)) def disjoint_union(self, other): """Creates the disjoint union of two (or more) graphs. @param other: graph or list of graphs to be united with the current one. @return: the disjoint union graph """ if isinstance(other, GraphBase): other = [other] return disjoint_union([self] + other) def union(self, other, byname="auto"): """Creates the union of two (or more) graphs. @param other: graph or list of graphs to be united with the current one. @param byname: whether to use vertex names instead of ids. See L{igraph.union} for details. @return: the union graph """ if isinstance(other, GraphBase): other = [other] return union([self] + other, byname=byname) def intersection(self, other, byname="auto"): """Creates the intersection of two (or more) graphs. @param other: graph or list of graphs to be intersected with the current one. @param byname: whether to use vertex names instead of ids. See L{igraph.intersection} for details. @return: the intersection graph """ if isinstance(other, GraphBase): other = [other] return intersection([self] + other, byname=byname) _format_mapping = { "ncol": ("Read_Ncol", "write_ncol"), "lgl": ("Read_Lgl", "write_lgl"), "graphdb": ("Read_GraphDB", None), "graphmlz": ("Read_GraphMLz", "write_graphmlz"), "graphml": ("Read_GraphML", "write_graphml"), "gml": ("Read_GML", "write_gml"), "dot": (None, "write_dot"), "graphviz": (None, "write_dot"), "net": ("Read_Pajek", "write_pajek"), "pajek": ("Read_Pajek", "write_pajek"), "dimacs": ("Read_DIMACS", "write_dimacs"), "adjacency": ("Read_Adjacency", "write_adjacency"), "adj": ("Read_Adjacency", "write_adjacency"), "edgelist": ("Read_Edgelist", "write_edgelist"), "edge": ("Read_Edgelist", "write_edgelist"), "edges": ("Read_Edgelist", "write_edgelist"), "pickle": ("Read_Pickle", "write_pickle"), "picklez": ("Read_Picklez", "write_picklez"), "svg": (None, "write_svg"), "gw": (None, "write_leda"), "leda": (None, "write_leda"), "lgr": (None, "write_leda"), "dl": ("Read_DL", None), } _layout_mapping = { "auto": "layout_auto", "automatic": "layout_auto", "bipartite": "layout_bipartite", "circle": "layout_circle", "circular": "layout_circle", "davidson_harel": "layout_davidson_harel", "dh": "layout_davidson_harel", "drl": "layout_drl", "fr": "layout_fruchterman_reingold", "fruchterman_reingold": "layout_fruchterman_reingold", "graphopt": "layout_graphopt", "grid": "layout_grid", "kk": "layout_kamada_kawai", "kamada_kawai": "layout_kamada_kawai", "lgl": "layout_lgl", "large": "layout_lgl", "large_graph": "layout_lgl", "mds": "layout_mds", "random": "layout_random", "rt": "layout_reingold_tilford", "tree": "layout_reingold_tilford", "reingold_tilford": "layout_reingold_tilford", "rt_circular": "layout_reingold_tilford_circular", "reingold_tilford_circular": "layout_reingold_tilford_circular", "sphere": "layout_sphere", "spherical": "layout_sphere", "star": "layout_star", "sugiyama": "layout_sugiyama", } # After adjusting something here, don't forget to update the docstring # of Graph.layout if necessary! ############################################################## class VertexSeq(_VertexSeq): """Class representing a sequence of vertices in the graph. This class is most easily accessed by the C{vs} field of the L{Graph} object, which returns an ordered sequence of all vertices in the graph. The vertex sequence can be refined by invoking the L{VertexSeq.select()} method. L{VertexSeq.select()} can also be accessed by simply calling the L{VertexSeq} object. An alternative way to create a vertex sequence referring to a given graph is to use the constructor directly: >>> g = Graph.Full(3) >>> vs = VertexSeq(g) >>> restricted_vs = VertexSeq(g, [0, 1]) The individual vertices can be accessed by indexing the vertex sequence object. It can be used as an iterable as well, or even in a list comprehension: >>> g=Graph.Full(3) >>> for v in g.vs: ... v["value"] = v.index ** 2 ... >>> [v["value"] ** 0.5 for v in g.vs] [0.0, 1.0, 2.0] The vertex set can also be used as a dictionary where the keys are the attribute names. The values corresponding to the keys are the values of the given attribute for every vertex selected by the sequence. >>> g=Graph.Full(3) >>> for idx, v in enumerate(g.vs): ... v["weight"] = idx*(idx+1) ... >>> g.vs["weight"] [0, 2, 6] >>> g.vs.select(1,2)["weight"] = [10, 20] >>> g.vs["weight"] [0, 10, 20] If you specify a sequence that is shorter than the number of vertices in the VertexSeq, the sequence is reused: >>> g = Graph.Tree(7, 2) >>> g.vs["color"] = ["red", "green"] >>> g.vs["color"] ['red', 'green', 'red', 'green', 'red', 'green', 'red'] You can even pass a single string or integer, it will be considered as a sequence of length 1: >>> g.vs["color"] = "red" >>> g.vs["color"] ['red', 'red', 'red', 'red', 'red', 'red', 'red'] Some methods of the vertex sequences are simply proxy methods to the corresponding methods in the L{Graph} object. One such example is C{VertexSeq.degree()}: >>> g=Graph.Tree(7, 2) >>> g.vs.degree() [2, 3, 3, 1, 1, 1, 1] >>> g.vs.degree() == g.degree() True """ def attributes(self): """Returns the list of all the vertex attributes in the graph associated to this vertex sequence.""" return self.graph.vertex_attributes() def find(self, *args, **kwds): """Returns the first vertex of the vertex sequence that matches some criteria. The selection criteria are equal to the ones allowed by L{VertexSeq.select}. See L{VertexSeq.select} for more details. For instance, to find the first vertex with name C{foo} in graph C{g}: >>> g.vs.find(name="foo") #doctest:+SKIP To find an arbitrary isolated vertex: >>> g.vs.find(_degree=0) #doctest:+SKIP """ # Shortcut: if "name" is in kwds, there are no positional arguments, # and the specified name is a string, we try that first because that # attribute is indexed. Note that we cannot do this if name is an # integer, because it would then translate to g.vs.select(name), which # searches by _index_ if the argument is an integer if not args: if "name" in kwds: name = kwds.pop("name") elif "name_eq" in kwds: name = kwds.pop("name_eq") else: name = None if name is not None: if isinstance(name, str): args = [name] else: # put back what we popped kwds["name"] = name if args: # Selecting first based on positional arguments, then checking # the criteria specified by the (remaining) keyword arguments vertex = _VertexSeq.find(self, *args) if not kwds: return vertex vs = self.graph.vs.select(vertex.index) else: vs = self # Selecting based on keyword arguments vs = vs.select(**kwds) if vs: return vs[0] raise ValueError("no such vertex") def select(self, *args, **kwds): """Selects a subset of the vertex sequence based on some criteria The selection criteria can be specified by the positional and the keyword arguments. Positional arguments are always processed before keyword arguments. - If the first positional argument is C{None}, an empty sequence is returned. - If the first positional argument is a callable object, the object will be called for every vertex in the sequence. If it returns C{True}, the vertex will be included, otherwise it will be excluded. - If the first positional argument is an iterable, it must return integers and they will be considered as indices of the current vertex set (NOT the whole vertex set of the graph -- the difference matters when one filters a vertex set that has already been filtered by a previous invocation of L{VertexSeq.select()}. In this case, the indices do not refer directly to the vertices of the graph but to the elements of the filtered vertex sequence. - If the first positional argument is an integer, all remaining arguments are expected to be integers. They are considered as indices of the current vertex set again. Keyword arguments can be used to filter the vertices based on their attributes. The name of the keyword specifies the name of the attribute and the filtering operator, they should be concatenated by an underscore (C{_}) character. Attribute names can also contain underscores, but operator names don't, so the operator is always the largest trailing substring of the keyword name that does not contain an underscore. Possible operators are: - C{eq}: equal to - C{ne}: not equal to - C{lt}: less than - C{gt}: greater than - C{le}: less than or equal to - C{ge}: greater than or equal to - C{in}: checks if the value of an attribute is in a given list - C{notin}: checks if the value of an attribute is not in a given list For instance, if you want to filter vertices with a numeric C{age} property larger than 200, you have to write: >>> g.vs.select(age_gt=200) #doctest: +SKIP Similarly, to filter vertices whose C{type} is in a list of predefined types: >>> list_of_types = ["HR", "Finance", "Management"] >>> g.vs.select(type_in=list_of_types) #doctest: +SKIP If the operator is omitted, it defaults to C{eq}. For instance, the following selector selects vertices whose C{cluster} property equals to 2: >>> g.vs.select(cluster=2) #doctest: +SKIP In the case of an unknown operator, it is assumed that the recognized operator is part of the attribute name and the actual operator is C{eq}. Attribute names inferred from keyword arguments are treated specially if they start with an underscore (C{_}). These are not real attributes but refer to specific properties of the vertices, e.g., its degree. The rule is as follows: if an attribute name starts with an underscore, the rest of the name is interpreted as a method of the L{Graph} object. This method is called with the vertex sequence as its first argument (all others left at default values) and vertices are filtered according to the value returned by the method. For instance, if you want to exclude isolated vertices: >>> g = Graph.Famous("zachary") >>> non_isolated = g.vs.select(_degree_gt=0) For properties that take a long time to be computed (e.g., betweenness centrality for large graphs), it is advised to calculate the values in advance and store it in a graph attribute. The same applies when you are selecting based on the same property more than once in the same C{select()} call to avoid calculating it twice unnecessarily. For instance, the following would calculate betweenness centralities twice: >>> edges = g.vs.select(_betweenness_gt=10, _betweenness_lt=30) It is advised to use this instead: >>> g.vs["bs"] = g.betweenness() >>> edges = g.vs.select(bs_gt=10, bs_lt=30) @return: the new, filtered vertex sequence""" vs = _VertexSeq.select(self, *args) operators = { "lt": operator.lt, "gt": operator.gt, "le": operator.le, "ge": operator.ge, "eq": operator.eq, "ne": operator.ne, "in": lambda a, b: a in b, "notin": lambda a, b: a not in b, } for keyword, value in kwds.items(): if "_" not in keyword or keyword.rindex("_") == 0: keyword += "_eq" attr, _, op = keyword.rpartition("_") try: func = operators[op] except KeyError: # No such operator, assume that it's part of the attribute name attr, op, func = keyword, "eq", operators["eq"] if attr[0] == "_": # Method call, not an attribute values = getattr(vs.graph, attr[1:])(vs) else: values = vs[attr] filtered_idxs = [i for i, v in enumerate(values) if func(v, value)] vs = vs.select(filtered_idxs) return vs def __call__(self, *args, **kwds): """Shorthand notation to select() This method simply passes all its arguments to L{VertexSeq.select()}. """ return self.select(*args, **kwds) ############################################################## class EdgeSeq(_EdgeSeq): """Class representing a sequence of edges in the graph. This class is most easily accessed by the C{es} field of the L{Graph} object, which returns an ordered sequence of all edges in the graph. The edge sequence can be refined by invoking the L{EdgeSeq.select()} method. L{EdgeSeq.select()} can also be accessed by simply calling the L{EdgeSeq} object. An alternative way to create an edge sequence referring to a given graph is to use the constructor directly: >>> g = Graph.Full(3) >>> es = EdgeSeq(g) >>> restricted_es = EdgeSeq(g, [0, 1]) The individual edges can be accessed by indexing the edge sequence object. It can be used as an iterable as well, or even in a list comprehension: >>> g=Graph.Full(3) >>> for e in g.es: ... print(e.tuple) ... (0, 1) (0, 2) (1, 2) >>> [max(e.tuple) for e in g.es] [1, 2, 2] The edge sequence can also be used as a dictionary where the keys are the attribute names. The values corresponding to the keys are the values of the given attribute of every edge in the graph: >>> g=Graph.Full(3) >>> for idx, e in enumerate(g.es): ... e["weight"] = idx*(idx+1) ... >>> g.es["weight"] [0, 2, 6] >>> g.es["weight"] = range(3) >>> g.es["weight"] [0, 1, 2] If you specify a sequence that is shorter than the number of edges in the EdgeSeq, the sequence is reused: >>> g = Graph.Tree(7, 2) >>> g.es["color"] = ["red", "green"] >>> g.es["color"] ['red', 'green', 'red', 'green', 'red', 'green'] You can even pass a single string or integer, it will be considered as a sequence of length 1: >>> g.es["color"] = "red" >>> g.es["color"] ['red', 'red', 'red', 'red', 'red', 'red'] Some methods of the edge sequences are simply proxy methods to the corresponding methods in the L{Graph} object. One such example is C{EdgeSeq.is_multiple()}: >>> g=Graph(3, [(0,1), (1,0), (1,2)]) >>> g.es.is_multiple() [False, True, False] >>> g.es.is_multiple() == g.is_multiple() True """ def attributes(self): """Returns the list of all the edge attributes in the graph associated to this edge sequence.""" return self.graph.edge_attributes() def find(self, *args, **kwds): """Returns the first edge of the edge sequence that matches some criteria. The selection criteria are equal to the ones allowed by L{VertexSeq.select}. See L{VertexSeq.select} for more details. For instance, to find the first edge with weight larger than 5 in graph C{g}: >>> g.es.find(weight_gt=5) #doctest:+SKIP """ if args: # Selecting first based on positional arguments, then checking # the criteria specified by the keyword arguments edge = _EdgeSeq.find(self, *args) if not kwds: return edge es = self.graph.es.select(edge.index) else: es = self # Selecting based on positional arguments es = es.select(**kwds) if es: return es[0] raise ValueError("no such edge") def select(self, *args, **kwds): """Selects a subset of the edge sequence based on some criteria The selection criteria can be specified by the positional and the keyword arguments. Positional arguments are always processed before keyword arguments. - If the first positional argument is C{None}, an empty sequence is returned. - If the first positional argument is a callable object, the object will be called for every edge in the sequence. If it returns C{True}, the edge will be included, otherwise it will be excluded. - If the first positional argument is an iterable, it must return integers and they will be considered as indices of the current edge set (NOT the whole edge set of the graph -- the difference matters when one filters an edge set that has already been filtered by a previous invocation of L{EdgeSeq.select()}. In this case, the indices do not refer directly to the edges of the graph but to the elements of the filtered edge sequence. - If the first positional argument is an integer, all remaining arguments are expected to be integers. They are considered as indices of the current edge set again. Keyword arguments can be used to filter the edges based on their attributes and properties. The name of the keyword specifies the name of the attribute and the filtering operator, they should be concatenated by an underscore (C{_}) character. Attribute names can also contain underscores, but operator names don't, so the operator is always the largest trailing substring of the keyword name that does not contain an underscore. Possible operators are: - C{eq}: equal to - C{ne}: not equal to - C{lt}: less than - C{gt}: greater than - C{le}: less than or equal to - C{ge}: greater than or equal to - C{in}: checks if the value of an attribute is in a given list - C{notin}: checks if the value of an attribute is not in a given list For instance, if you want to filter edges with a numeric C{weight} property larger than 50, you have to write: >>> g.es.select(weight_gt=50) #doctest: +SKIP Similarly, to filter edges whose C{type} is in a list of predefined types: >>> list_of_types = ["inhibitory", "excitatory"] >>> g.es.select(type_in=list_of_types) #doctest: +SKIP If the operator is omitted, it defaults to C{eq}. For instance, the following selector selects edges whose C{type} property is C{intracluster}: >>> g.es.select(type="intracluster") #doctest: +SKIP In the case of an unknown operator, it is assumed that the recognized operator is part of the attribute name and the actual operator is C{eq}. Keyword arguments are treated specially if they start with an underscore (C{_}). These are not real attributes but refer to specific properties of the edges, e.g., their centrality. The rules are as follows: 1. C{_source} or {_from} means the source vertex of an edge. For undirected graphs, only the C{eq} operator is supported and it is treated as {_incident} (since undirected graphs have no notion of edge directionality). 2. C{_target} or {_to} means the target vertex of an edge. For undirected graphs, only the C{eq} operator is supported and it is treated as {_incident} (since undirected graphs have no notion of edge directionality). 3. C{_within} ignores the operator and checks whether both endpoints of the edge lie within a specified set. 4. C{_between} ignores the operator and checks whether I{one} endpoint of the edge lies within a specified set and the I{other} endpoint lies within another specified set. The two sets must be given as a tuple. 5. C{_incident} ignores the operator and checks whether the edge is incident on a specific vertex or a set of vertices. 6. Otherwise, the rest of the name is interpreted as a method of the L{Graph} object. This method is called with the edge sequence as its first argument (all others left at default values) and edges are filtered according to the value returned by the method. For instance, if you want to exclude edges with a betweenness centrality less than 2: >>> g = Graph.Famous("zachary") >>> excl = g.es.select(_edge_betweenness_ge = 2) To select edges originating from vertices 2 and 4: >>> edges = g.es.select(_source_in = [2, 4]) To select edges lying entirely within the subgraph spanned by vertices 2, 3, 4 and 7: >>> edges = g.es.select(_within = [2, 3, 4, 7]) To select edges with one endpoint in the vertex set containing vertices 2, 3, 4 and 7 and the other endpoint in the vertex set containing vertices 8 and 9: >>> edges = g.es.select(_between = ([2, 3, 4, 7], [8, 9])) For properties that take a long time to be computed (e.g., betweenness centrality for large graphs), it is advised to calculate the values in advance and store it in a graph attribute. The same applies when you are selecting based on the same property more than once in the same C{select()} call to avoid calculating it twice unnecessarily. For instance, the following would calculate betweenness centralities twice: >>> edges = g.es.select(_edge_betweenness_gt=10, # doctest:+SKIP ... _edge_betweenness_lt=30) It is advised to use this instead: >>> g.es["bs"] = g.edge_betweenness() >>> edges = g.es.select(bs_gt=10, bs_lt=30) @return: the new, filtered edge sequence """ es = _EdgeSeq.select(self, *args) is_directed = self.graph.is_directed() def _ensure_set(value): if isinstance(value, VertexSeq): value = set(v.index for v in value) elif not isinstance(value, (set, frozenset)): value = set(value) return value operators = { "lt": operator.lt, "gt": operator.gt, "le": operator.le, "ge": operator.ge, "eq": operator.eq, "ne": operator.ne, "in": lambda a, b: a in b, "notin": lambda a, b: a not in b, } # TODO(ntamas): some keyword arguments should be prioritized over # others; for instance, we have optimized code paths for _source and # _target in directed and undirected graphs if es.is_all() is True; # these should be executed first. This matters only if there are # multiple keyword arguments and es.is_all() is True. for keyword, value in kwds.items(): if "_" not in keyword or keyword.rindex("_") == 0: keyword += "_eq" pos = keyword.rindex("_") attr, op = keyword[0:pos], keyword[pos + 1 :] try: func = operators[op] except KeyError: # No such operator, assume that it's part of the attribute name attr, op, func = keyword, "eq", operators["eq"] if attr[0] == "_": if attr in ("_source", "_from", "_target", "_to") and not is_directed: if op not in ("eq", "in"): raise RuntimeError("unsupported for undirected graphs") # translate to _incident to avoid confusion attr = "_incident" if func == operators["eq"]: if hasattr(value, "__iter__") and not isinstance(value, str): value = set(value) else: value = set([value]) if attr in ("_source", "_from"): if es.is_all() and op == "eq": # shortcut here: use .incident() as it is much faster filtered_idxs = sorted(es.graph.incident(value, mode="out")) func = None # TODO(ntamas): there are more possibilities; we could # optimize "ne", "in" and "notin" in similar ways else: values = [e.source for e in es] if op == "in" or op == "notin": value = _ensure_set(value) elif attr in ("_target", "_to"): if es.is_all() and op == "eq": # shortcut here: use .incident() as it is much faster filtered_idxs = sorted(es.graph.incident(value, mode="in")) func = None # TODO(ntamas): there are more possibilities; we could # optimize "ne", "in" and "notin" in similar ways else: values = [e.target for e in es] if op == "in" or op == "notin": value = _ensure_set(value) elif attr == "_incident": func = None # ignoring function, filtering here value = _ensure_set(value) # Fetch all the edges that are incident on at least one of # the vertices specified candidates = set() for v in value: candidates.update(es.graph.incident(v)) if not es.is_all(): # Find those that are in the current edge sequence filtered_idxs = [ i for i, e in enumerate(es) if e.index in candidates ] else: # We are done, the filtered indexes are in the candidates set filtered_idxs = sorted(candidates) elif attr == "_within": func = None # ignoring function, filtering here value = _ensure_set(value) # Fetch all the edges that are incident on at least one of # the vertices specified candidates = set() for v in value: candidates.update(es.graph.incident(v)) if not es.is_all(): # Find those where both endpoints are OK filtered_idxs = [ i for i, e in enumerate(es) if e.index in candidates and e.source in value and e.target in value ] else: # Optimized version when the edge sequence contains all # the edges exactly once in increasing order of edge IDs filtered_idxs = [ i for i in candidates if es[i].source in value and es[i].target in value ] elif attr == "_between": if len(value) != 2: raise ValueError( "_between selector requires two vertex ID lists" ) func = None # ignoring function, filtering here set1 = _ensure_set(value[0]) set2 = _ensure_set(value[1]) # Fetch all the edges that are incident on at least one of # the vertices specified candidates = set() for v in set1: candidates.update(es.graph.incident(v)) for v in set2: candidates.update(es.graph.incident(v)) if not es.is_all(): # Find those where both endpoints are OK filtered_idxs = [ i for i, e in enumerate(es) if (e.source in set1 and e.target in set2) or (e.target in set1 and e.source in set2) ] else: # Optimized version when the edge sequence contains all # the edges exactly once in increasing order of edge IDs filtered_idxs = [ i for i in candidates if (es[i].source in set1 and es[i].target in set2) or (es[i].target in set1 and es[i].source in set2) ] else: # Method call, not an attribute values = getattr(es.graph, attr[1:])(es) else: values = es[attr] # If we have a function to apply on the values, do that; otherwise # we assume that filtered_idxs has already been calculated. if func is not None: filtered_idxs = [i for i, v in enumerate(values) if func(v, value)] es = es.select(filtered_idxs) return es def __call__(self, *args, **kwds): """Shorthand notation to select() This method simply passes all its arguments to L{EdgeSeq.select()}. """ return self.select(*args, **kwds) ############################################################## # Additional methods of VertexSeq and EdgeSeq that call Graph methods def _graphmethod(func=None, name=None): """Auxiliary decorator This decorator allows some methods of L{VertexSeq} and L{EdgeSeq} to call their respective counterparts in L{Graph} to avoid code duplication. @param func: the function being decorated. This function will be called on the results of the original L{Graph} method. If C{None}, defaults to the identity function. @param name: the name of the corresponding method in L{Graph}. If C{None}, it defaults to the name of the decorated function. @return: the decorated function """ if name is None: name = func.__name__ method = getattr(Graph, name) if hasattr(func, "__call__"): def decorated(*args, **kwds): self = args[0].graph return func(args[0], method(self, *args, **kwds)) else: def decorated(*args, **kwds): self = args[0].graph return method(self, *args, **kwds) decorated.__name__ = name decorated.__doc__ = """Proxy method to L{Graph.%(name)s()} This method calls the C{%(name)s()} method of the L{Graph} class restricted to this sequence, and returns the result. @see: Graph.%(name)s() for details. """ % { "name": name } return decorated def _add_proxy_methods(): # Proxy methods for VertexSeq and EdgeSeq that forward their arguments to # the corresponding Graph method are constructed here. Proxy methods for # Vertex and Edge are added in the C source code. Make sure that you update # the C source whenever you add a proxy method here if that makes sense for # an individual vertex or edge decorated_methods = {} decorated_methods[VertexSeq] = [ "degree", "betweenness", "bibcoupling", "closeness", "cocitation", "constraint", "diversity", "eccentricity", "get_shortest_paths", "maxdegree", "pagerank", "personalized_pagerank", "shortest_paths", "similarity_dice", "similarity_jaccard", "subgraph", "indegree", "outdegree", "isoclass", "delete_vertices", "is_separator", "is_minimal_separator", ] decorated_methods[EdgeSeq] = [ "count_multiple", "delete_edges", "is_loop", "is_multiple", "is_mutual", "subgraph_edges", ] rename_methods = {} rename_methods[VertexSeq] = {"delete_vertices": "delete"} rename_methods[EdgeSeq] = {"delete_edges": "delete", "subgraph_edges": "subgraph"} for cls, methods in decorated_methods.items(): for method in methods: new_method_name = rename_methods[cls].get(method, method) setattr(cls, new_method_name, _graphmethod(None, method)) setattr( EdgeSeq, "edge_betweenness", _graphmethod( lambda self, result: [result[i] for i in self.indices], "edge_betweenness" ), ) _add_proxy_methods() ############################################################## # Making sure that layout methods always return a Layout def _layout_method_wrapper(func): """Wraps an existing layout method to ensure that it returns a Layout instead of a list of lists. @param func: the method to wrap. Must be a method of the Graph object. @return: a new method """ def result(*args, **kwds): layout = func(*args, **kwds) if not isinstance(layout, Layout): layout = Layout(layout) return layout result.__name__ = func.__name__ result.__doc__ = func.__doc__ return result for name in dir(Graph): if not name.startswith("layout_"): continue if name in ("layout_auto", "layout_sugiyama"): continue setattr(Graph, name, _layout_method_wrapper(getattr(Graph, name))) ############################################################## # Adding aliases for the 3D versions of the layout methods def _3d_version_for(func): """Creates an alias for the 3D version of the given layout algoritm. This function is a decorator that creates a method which calls I{func} after attaching C{dim=3} to the list of keyword arguments. @param func: must be a method of the Graph object. @return: a new method """ def result(*args, **kwds): kwds["dim"] = 3 return func(*args, **kwds) result.__name__ = "%s_3d" % func.__name__ result.__doc__ = """Alias for L{%s()} with dim=3.\n\n@see: Graph.%s()""" % ( func.__name__, func.__name__, ) return result Graph.layout_fruchterman_reingold_3d = _3d_version_for( Graph.layout_fruchterman_reingold ) Graph.layout_kamada_kawai_3d = _3d_version_for(Graph.layout_kamada_kawai) Graph.layout_random_3d = _3d_version_for(Graph.layout_random) Graph.layout_grid_3d = _3d_version_for(Graph.layout_grid) Graph.layout_sphere = _3d_version_for(Graph.layout_circle) ############################################################## def autocurve(graph, attribute="curved", default=0): """Calculates curvature values for each of the edges in the graph to make sure that multiple edges are shown properly on a graph plot. This function checks the multiplicity of each edge in the graph and assigns curvature values (numbers between -1 and 1, corresponding to CCW (-1), straight (0) and CW (1) curved edges) to them. The assigned values are either stored in an edge attribute or returned as a list, depending on the value of the I{attribute} argument. @param graph: the graph on which the calculation will be run @param attribute: the name of the edge attribute to save the curvature values to. The default value is C{curved}, which is the name of the edge attribute the default graph plotter checks to decide whether an edge should be curved on the plot or not. If I{attribute} is C{None}, the result will not be stored. @param default: the default curvature for single edges. Zero means that single edges will be straight. If you want single edges to be curved as well, try passing 0.5 or -0.5 here. @return: the list of curvature values if I{attribute} is C{None}, otherwise C{None}. """ # The following loop could be re-written in C if it turns out to be a # bottleneck. Unfortunately we cannot use Graph.count_multiple() here # because we have to ignore edge directions. multiplicities = defaultdict(list) for edge in graph.es: u, v = edge.tuple if u > v: multiplicities[v, u].append(edge.index) else: multiplicities[u, v].append(edge.index) result = [default] * graph.ecount() for eids in multiplicities.values(): # Is it a single edge? if len(eids) < 2: continue if len(eids) % 2 == 1: # Odd number of edges; the last will be straight result[eids.pop()] = 0 # Arrange the remaining edges curve = 2.0 / (len(eids) + 2) dcurve, sign = curve, 1 for idx, eid in enumerate(eids): edge = graph.es[eid] if edge.source > edge.target: result[eid] = -sign * curve else: result[eid] = sign * curve if idx % 2 == 1: curve += dcurve sign *= -1 if attribute is None: return result graph.es[attribute] = result def get_include(): """Returns the folder that contains the C API headers of the Python interface of igraph.""" import igraph paths = [ # The following path works if igraph is installed already os.path.join( sys.prefix, "include", "python{0}.{1}".format(*sys.version_info), "igraph", ), # Fallback for cases when igraph is not installed but # imported directly from the source tree os.path.join(os.path.dirname(igraph.__file__), "..", "src", "_igraph"), ] for path in paths: if os.path.exists(os.path.join(path, "igraphmodule_api.h")): return os.path.abspath(path) raise ValueError("cannot find the header files of the Python interface of igraph") def read(filename, *args, **kwds): """Loads a graph from the given filename. This is just a convenience function, calls L{Graph.Read} directly. All arguments are passed unchanged to L{Graph.Read} @param filename: the name of the file to be loaded """ return Graph.Read(filename, *args, **kwds) load = read def write(graph, filename, *args, **kwds): """Saves a graph to the given file. This is just a convenience function, calls L{Graph.write} directly. All arguments are passed unchanged to L{Graph.write} @param graph: the graph to be saved @param filename: the name of the file to be written """ return graph.write(filename, *args, **kwds) save = write config = init_configuration() """The main configuration object of igraph. Use this object to modify igraph's behaviour, typically when used in interactive mode. """ del construct_graph_from_formula ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4111395 igraph-0.9.9/src/igraph/app/0000755000175100001710000000000000000000000016424 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/app/__init__.py0000644000175100001710000000004000000000000020527 0ustar00runnerdocker00000000000000"""User interfaces of igraph""" ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/app/shell.py0000644000175100001710000004377200000000000020122 0ustar00runnerdocker00000000000000"""Command-line user interface of igraph The command-line interface launches a Python shell with the igraph module automatically imported into the main namespace. This is mostly a convenience module and it is used only by the C{igraph} command line script which executes a suitable Python shell and automatically imports C{igraph}'s classes and functions in the top-level namespace. Supported Python shells are: - IDLE shell (class L{IDLEShell}) - IPython shell (class L{IPythonShell}) - Classic Python shell (class L{ClassicPythonShell}) The shells are tried in the above mentioned preference order one by one, unless the C{global.shells} configuration key is set which overrides the default order. IDLE shell is only tried in Windows unless explicitly stated by C{global.shells}, since Linux and Mac OS X users are likely to invoke igraph from the command line. """ import re import sys from igraph import __version__ from igraph._igraph import set_progress_handler, set_status_handler from igraph.configuration import Configuration class TerminalController: """ A class that can be used to portably generate formatted output to a terminal. `TerminalController` defines a set of instance variables whose values are initialized to the control sequence necessary to perform a given action. These can be simply included in normal output to the terminal: >>> term = TerminalController() >>> print('This is '+term.GREEN+'green'+term.NORMAL) This is green Alternatively, the `render()` method can used, which replaces '${action}' with the string required to perform 'action': >>> term = TerminalController() >>> print(term.render('This is ${GREEN}green${NORMAL}')) This is green If the terminal doesn't support a given action, then the value of the corresponding instance variable will be set to ''. As a result, the above code will still work on terminals that do not support color, except that their output will not be colored. Also, this means that you can test whether the terminal supports a given action by simply testing the truth value of the corresponding instance variable: >>> term = TerminalController() >>> if term.CLEAR_SCREEN: ... print 'This terminal supports clearning the screen.' ... Finally, if the width and height of the terminal are known, then they will be stored in the `COLS` and `LINES` attributes. @author: Edward Loper """ # Cursor movement: BOL = "" #: Move the cursor to the beginning of the line UP = "" #: Move the cursor up one line DOWN = "" #: Move the cursor down one line LEFT = "" #: Move the cursor left one char RIGHT = "" #: Move the cursor right one char # Deletion: CLEAR_SCREEN = "" #: Clear the screen and move to home position CLEAR_EOL = "" #: Clear to the end of the line. CLEAR_BOL = "" #: Clear to the beginning of the line. CLEAR_EOS = "" #: Clear to the end of the screen # Output modes: BOLD = "" #: Turn on bold mode BLINK = "" #: Turn on blink mode DIM = "" #: Turn on half-bright mode REVERSE = "" #: Turn on reverse-video mode NORMAL = "" #: Turn off all modes # Cursor display: HIDE_CURSOR = "" #: Make the cursor invisible SHOW_CURSOR = "" #: Make the cursor visible # Terminal size: COLS = None #: Width of the terminal (None for unknown) LINES = None #: Height of the terminal (None for unknown) # Foreground colors: BLACK = BLUE = GREEN = CYAN = RED = MAGENTA = YELLOW = WHITE = "" # Background colors: BG_BLACK = BG_BLUE = BG_GREEN = BG_CYAN = "" BG_RED = BG_MAGENTA = BG_YELLOW = BG_WHITE = "" _STRING_CAPABILITIES = """ BOL=cr UP=cuu1 DOWN=cud1 LEFT=cub1 RIGHT=cuf1 CLEAR_SCREEN=clear CLEAR_EOL=el CLEAR_BOL=el1 CLEAR_EOS=ed BOLD=bold BLINK=blink DIM=dim REVERSE=rev UNDERLINE=smul NORMAL=sgr0 HIDE_CURSOR=cinvis SHOW_CURSOR=cnorm""".split() _COLORS = """BLACK BLUE GREEN CYAN RED MAGENTA YELLOW WHITE""".split() _ANSICOLORS = "BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE".split() def __init__(self, term_stream=sys.stdout): """ Create a `TerminalController` and initialize its attributes with appropriate values for the current terminal. `term_stream` is the stream that will be used for terminal output; if this stream is not a tty, then the terminal is assumed to be a dumb terminal (i.e., have no capabilities). """ # Curses isn't available on all platforms try: import curses except ImportError: return # If the stream isn't a tty, then assume it has no capabilities. if not term_stream.isatty(): return # Check the terminal type. If we fail, then assume that the # terminal has no capabilities. try: curses.setupterm() except Exception: return # Look up numeric capabilities. self.COLS = curses.tigetnum("cols") self.LINES = curses.tigetnum("lines") # Look up string capabilities. for capability in self._STRING_CAPABILITIES: (attrib, cap_name) = capability.split("=") setattr(self, attrib, self._tigetstr(cap_name) or "") # Colors set_fg = self._tigetstr("setf") if set_fg: for i, color in zip(range(len(self._COLORS)), self._COLORS): setattr(self, color, self._tparm(set_fg, i) or "") set_fg_ansi = self._tigetstr("setaf") if set_fg_ansi: for i, color in zip(range(len(self._ANSICOLORS)), self._ANSICOLORS): setattr(self, color, self._tparm(set_fg_ansi, i) or "") set_bg = self._tigetstr("setb") if set_bg: for i, color in zip(range(len(self._COLORS)), self._COLORS): setattr(self, "BG_" + color, self._tparm(set_bg, i) or "") set_bg_ansi = self._tigetstr("setab") if set_bg_ansi: for i, color in zip(range(len(self._ANSICOLORS)), self._ANSICOLORS): setattr(self, "BG_" + color, self._tparm(set_bg_ansi, i) or "") @staticmethod def _tigetstr(cap_name): """Rewrites string capabilities to remove "delays" which are not required for modern terminals""" # String capabilities can include "delays" of the form "$<2>". # For any modern terminal, we should be able to just ignore # these, so strip them out. import curses cap = curses.tigetstr(cap_name) or b"" cap = cap.decode("latin-1") return re.sub(r"\$<\d+>[/*]?", "", cap) @staticmethod def _tparm(cap_name, param): import curses cap = curses.tparm(cap_name.encode("latin-1"), param) or b"" return cap.decode("latin-1") def render(self, template): """ Replace each $-substitutions in the given template string with the corresponding terminal control string (if it's defined) or '' (if it's not). """ return re.sub("r\$\$|\${\w+}", self._render_sub, template) # noqa: W605 def _render_sub(self, match): """Helper function for L{render}""" s = match.group() if s == "$$": return s else: return getattr(self, s[2:-1]) class ProgressBar: """ A 2-line progress bar, which looks like:: Header 20% [===========----------------------------------] The progress bar is colored, if the terminal supports color output; and adjusts to the width of the terminal. """ BAR = "%3d%% ${GREEN}[${BOLD}%s%s${NORMAL}${GREEN}]${NORMAL}" HEADER = "${BOLD}${CYAN}%s${NORMAL}\n" def __init__(self, term): self.term = term if not (self.term.CLEAR_EOL and self.term.UP and self.term.BOL): raise ValueError( "Terminal isn't capable enough -- you " "should use a simpler progress display." ) self.width = self.term.COLS or 75 self.progress_bar = term.render(self.BAR) self.header = self.term.render(self.HEADER % "".center(self.width)) self.cleared = True #: true if we haven't drawn the bar yet. self.last_percent = 0 self.last_message = "" def update(self, percent=None, message=None): """Updates the progress bar. @param percent: the percentage to be shown. If C{None}, the previous value will be used. @param message: the message to be shown above the progress bar. If C{None}, the previous message will be used. """ if self.cleared: sys.stdout.write("\n" + self.header) self.cleared = False if message is None: message = self.last_message else: self.last_message = message if percent is None: percent = self.last_percent else: self.last_percent = percent n = int((self.width - 10) * (percent / 100.0)) sys.stdout.write( self.term.BOL + self.term.UP + self.term.UP + self.term.CLEAR_EOL + self.term.render(self.HEADER % message.center(self.width)) + (self.progress_bar % (percent, "=" * n, "-" * (self.width - 10 - n))) + "\n" ) def update_message(self, message): """Updates the message of the progress bar. @param message: the message to be shown above the progress bar """ return self.update(message=message.strip()) def clear(self): """Clears the progress bar (i.e. removes it from the screen)""" if not self.cleared: sys.stdout.write( self.term.BOL + self.term.CLEAR_EOL + self.term.UP + self.term.CLEAR_EOL + self.term.UP + self.term.CLEAR_EOL ) self.cleared = True self.last_percent = 0 self.last_message = "" class Shell: """Superclass of the embeddable shells supported by igraph""" def __init__(self): pass def __call__(self): raise NotImplementedError("abstract class") def supports_progress_bar(self): """Checks whether the shell supports progress bars. This is done by checking for the existence of an attribute called C{_progress_handler}.""" return hasattr(self, "_progress_handler") def supports_status_messages(self): """Checks whether the shell supports status messages. This is done by checking for the existence of an attribute called C{_status_handler}.""" return hasattr(self, "_status_handler") def get_progress_handler(self): """Returns the progress handler (if exists) or None (if not).""" if self.supports_progress_bar(): return self._progress_handler return None def get_status_handler(self): """Returns the status handler (if exists) or None (if not).""" if self.supports_status_messages(): return self._status_handler return None class IDLEShell(Shell): """IDLE embedded shell interface. This class allows igraph to be embedded in IDLE (the Tk Python IDE). @todo: no progress bar support yet. Shell/Restart Shell command should re-import igraph again.""" def __init__(self): """Constructor. Imports IDLE's embedded shell. The implementation of this method is ripped from idlelib.PyShell.main() after removing the unnecessary parts.""" Shell.__init__(self) import idlelib.PyShell idlelib.PyShell.use_subprocess = True try: sys.ps1 except AttributeError: sys.ps1 = ">>> " root = idlelib.PyShell.Tk(className="Idle") idlelib.PyShell.fixwordbreaks(root) root.withdraw() flist = idlelib.PyShell.PyShellFileList(root) if not flist.open_shell(): raise NotImplementedError self._shell = flist.pyshell self._root = root def __call__(self): """Starts the shell""" self._shell.interp.execsource("from igraph import *") self._root.mainloop() self._root.destroy() class ConsoleProgressBarMixin: """Mixin class for console shells that support a progress bar.""" def __init__(self): try: self.__class__.progress_bar = ProgressBar(TerminalController()) except ValueError: # Terminal is not capable enough, disable progress handler self._disable_handlers() except TypeError: # Probably running in Python 3.x and we hit a str/bytes issue; # as a temporary solution, disable the progress handler self._disable_handlers() def _disable_handlers(self): """Disables the status and progress handlers if the terminal is not capable enough.""" try: del self.__class__._progress_handler except AttributeError: pass try: del self.__class__._status_handler except AttributeError: pass @classmethod def _progress_handler(cls, message, percentage): """Progress bar handler, called when C{igraph} reports the progress of an operation @param message: message provided by C{igraph} @param percentage: percentage provided by C{igraph} """ if percentage >= 100: cls.progress_bar.clear() else: cls.progress_bar.update(percentage, message) @classmethod def _status_handler(cls, message): """Status message handler, called when C{igraph} sends a status message to be displayed. @param message: message provided by C{igraph} """ cls.progress_bar.update_message(message) class IPythonShell(Shell, ConsoleProgressBarMixin): """IPython embedded shell interface. This class allows igraph to be embedded in IPython's interactive shell.""" def __init__(self): """Constructor. Imports IPython's embedded shell with separator lines removed.""" Shell.__init__(self) ConsoleProgressBarMixin.__init__(self) # We cannot use IPShellEmbed here because generator expressions do not # work there (e.g., set(g.degree(x) for x in [1,2,3])) where g comes # from an external context import sys from IPython import __version__ as ipython_version self.ipython_version = ipython_version try: # IPython >= 0.11 supports this try: from IPython.terminal.ipapp import TerminalIPythonApp except ImportError: from IPython.frontend.terminal.ipapp import TerminalIPythonApp self._shell = TerminalIPythonApp.instance() sys.argv.append("--nosep") except ImportError: # IPython 0.10 and earlier import IPython.Shell self._shell = IPython.Shell.start() self._shell.IP.runsource("from igraph import *") sys.argv.append("-nosep") def __call__(self): """Starts the embedded shell.""" print("igraph %s running inside " % __version__, end="") if self._shell.__class__.__name__ == "TerminalIPythonApp": self._shell.initialize() self._shell.shell.ex("from igraph import *") self._shell.start() else: self._shell.mainloop() class ClassicPythonShell(Shell, ConsoleProgressBarMixin): """Classic Python shell interface. This class allows igraph to be embedded in Python's shell.""" def __init__(self): """Constructor. Imports Python's classic shell""" Shell.__init__(self) ConsoleProgressBarMixin.__init__(self) self._shell = None def __call__(self): """Starts the embedded shell.""" if self._shell is None: from code import InteractiveConsole self._shell = InteractiveConsole() print("igraph %s running inside " % __version__, end="", file=sys.stderr) self._shell.runsource("from igraph import *") self._shell.interact() def main(): """The main entry point for igraph when invoked from the command line shell""" config = Configuration.instance() if config.filename: print("Using configuration from %s" % config.filename, file=sys.stderr) else: print("No configuration file, using defaults", file=sys.stderr) if "shells" in config: parts = [part.strip() for part in config["shells"].split(",")] shell_classes = [] available_classes = dict( [ (k, v) for k, v in globals().items() if isinstance(v, type) and issubclass(v, Shell) ] ) for part in parts: cls = available_classes.get(part, None) if cls is None: print("Warning: unknown shell class `%s'" % part, file=sys.stderr) continue shell_classes.append(cls) else: shell_classes = [IPythonShell, ClassicPythonShell] import platform if platform.system() == "Windows": shell_classes.insert(0, IDLEShell) shell = None for shell_class in shell_classes: try: shell = shell_class() break except Exception: # Try the next one if "Classic" in str(shell_class): raise pass if isinstance(shell, Shell): if config["verbose"]: if shell.supports_progress_bar(): set_progress_handler(shell.get_progress_handler()) if shell.supports_status_messages(): set_status_handler(shell.get_status_handler()) shell() else: print("No suitable Python shell was found.", file=sys.stderr) print("Check configuration variable `general.shells'.", file=sys.stderr) if __name__ == "__main__": sys.exit(main()) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/clustering.py0000644000175100001710000017703600000000000020413 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Classes related to graph clustering.""" from copy import deepcopy from math import pi from io import StringIO from igraph import community_to_membership from igraph.configuration import Configuration from igraph.datatypes import UniqueIdGenerator from igraph.drawing.colors import ClusterColoringPalette from igraph.statistics import Histogram from igraph.summary import _get_wrapper_for_width from igraph.utils import str_to_orientation class Clustering: """Class representing a clustering of an arbitrary ordered set. This is now used as a base for L{VertexClustering}, but it might be useful for other purposes as well. Members of an individual cluster can be accessed by the C{[]} operator: >>> cl = Clustering([0,0,0,0,1,1,1,2,2,2,2]) >>> cl[0] [0, 1, 2, 3] The membership vector can be accessed by the C{membership} property: >>> cl.membership [0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2] The number of clusters can be retrieved by the C{len} function: >>> len(cl) 3 You can iterate over the clustering object as if it were a regular list of clusters: >>> for cluster in cl: ... print(" ".join(str(idx) for idx in cluster)) ... 0 1 2 3 4 5 6 7 8 9 10 If you need all the clusters at once as lists, you can simply convert the clustering object to a list: >>> cluster_list = list(cl) >>> print(cluster_list) [[0, 1, 2, 3], [4, 5, 6], [7, 8, 9, 10]] """ def __init__(self, membership, params=None): """Constructor. @param membership: the membership list -- that is, the cluster index in which each element of the set belongs to. @param params: additional parameters to be stored in this object's dictionary.""" self._membership = list(membership) if len(self._membership) > 0: self._len = max(m for m in self._membership if m is not None) + 1 else: self._len = 0 if params: self.__dict__.update(params) def __getitem__(self, idx): """Returns the members of the specified cluster. @param idx: the index of the cluster @return: the members of the specified cluster as a list @raise IndexError: if the index is out of bounds""" if idx < 0 or idx >= self._len: raise IndexError("cluster index out of range") return [i for i, e in enumerate(self._membership) if e == idx] def __iter__(self): """Iterates over the clusters in this clustering. This method will return a generator that generates the clusters one by one.""" clusters = [[] for _ in range(self._len)] for idx, cluster in enumerate(self._membership): clusters[cluster].append(idx) return iter(clusters) def __len__(self): """Returns the number of clusters. @return: the number of clusters """ return self._len def __str__(self): return self.summary(verbosity=1, width=78) def as_cover(self): """Returns a L{Cover} that contains the same clusters as this clustering.""" return Cover(self._graph, self) def compare_to(self, other, *args, **kwds): """Compares this clustering to another one using some similarity or distance metric. This is a convenience method that simply calls L{compare_communities} with the two clusterings as arguments. Any extra positional or keyword argument is also forwarded to L{compare_communities}.""" return compare_communities(self, other, *args, **kwds) @property def membership(self): """Returns the membership vector.""" return self._membership[:] @property def n(self): """Returns the number of elements covered by this clustering.""" return len(self._membership) def size(self, idx): """Returns the size of a given cluster. @param idx: the cluster in which we are interested. """ return len(self[idx]) def sizes(self, *args): """Returns the size of given clusters. The indices are given as positional arguments. If there are no positional arguments, the function will return the sizes of all clusters. """ counts = [0] * len(self) for x in self._membership: counts[x] += 1 if args: return [counts[idx] for idx in args] return counts def size_histogram(self, bin_width=1): """Returns the histogram of cluster sizes. @param bin_width: the bin width of the histogram @return: a L{Histogram} object """ return Histogram(bin_width, self.sizes()) def summary(self, verbosity=0, width=None): """Returns the summary of the clustering. The summary includes the number of items and clusters, and also the list of members for each of the clusters if the verbosity is nonzero. @param verbosity: determines whether the cluster members should be printed. Zero verbosity prints the number of items and clusters only. @return: the summary of the clustering as a string. """ out = StringIO() print( "Clustering with %d elements and %d clusters" % ( len(self._membership), len(self), ), file=out, ) if verbosity < 1: return out.getvalue().strip() ndigits = len(str(len(self))) wrapper = _get_wrapper_for_width(width, subsequent_indent=" " * (ndigits + 3)) for idx, cluster in enumerate(self._formatted_cluster_iterator()): wrapper.initial_indent = "[%*d] " % (ndigits, idx) print("\n".join(wrapper.wrap(cluster)), file=out) return out.getvalue().strip() def _formatted_cluster_iterator(self): """Iterates over the clusters and formats them into a string to be presented in the summary.""" for cluster in self: yield ", ".join(str(member) for member in cluster) class VertexClustering(Clustering): """The clustering of the vertex set of a graph. This class extends L{Clustering} by linking it to a specific L{Graph} object and by optionally storing the modularity score of the clustering. It also provides some handy methods like getting the subgraph corresponding to a cluster and such. @note: since this class is linked to a L{Graph}, destroying the graph by the C{del} operator does not free the memory occupied by the graph if there exists a L{VertexClustering} that references the L{Graph}. """ # Allow None to be passed to __plot__ as the "palette" keyword argument _default_palette = None def __init__( self, graph, membership=None, modularity=None, params=None, modularity_params=None, ): """Creates a clustering object for a given graph. @param graph: the graph that will be associated to the clustering @param membership: the membership list. The length of the list must be equal to the number of vertices in the graph. If C{None}, every vertex is assumed to belong to the same cluster. @param modularity: the modularity score of the clustering. If C{None}, it will be calculated when needed. @param params: additional parameters to be stored in this object. @param modularity_params: arguments that should be passed to L{Graph.modularity} when the modularity is (re)calculated. If the original graph was weighted, you should pass a dictionary containing a C{weight} key with the appropriate value here. """ if membership is None: Clustering.__init__(self, [0] * graph.vcount(), params) else: if len(membership) != graph.vcount(): raise ValueError("membership list has invalid length") Clustering.__init__(self, membership, params) self._graph = graph self._modularity = modularity self._modularity_dirty = modularity is None if modularity_params is None: self._modularity_params = {} else: self._modularity_params = dict(modularity_params) @classmethod def FromAttribute(cls, graph, attribute, intervals=None, params=None): """Creates a vertex clustering based on the value of a vertex attribute. Vertices having the same attribute will correspond to the same cluster. @param graph: the graph on which we are working @param attribute: name of the attribute on which the clustering is based. @param intervals: for numeric attributes, you can either pass a single number or a list of numbers here. A single number means that the vertices will be put in bins of that width and vertices ending up in the same bin will be in the same cluster. A list of numbers specify the bin positions explicitly; e.g., C{[10, 20, 30]} means that there will be four categories: vertices with the attribute value less than 10, between 10 and 20, between 20 and 30 and over 30. Intervals are closed from the left and open from the right. @param params: additional parameters to be stored in this object. @return: a new VertexClustering object """ from bisect import bisect def safeintdiv(x, y): """Safe integer division that handles None gracefully""" if x is None: return None return int(x / y) def safebisect(intervals, x): """Safe list bisection that handles None gracefully""" if x is None: return None return bisect(intervals, x) try: _ = iter(intervals) iterable = True except TypeError: iterable = False if intervals is None: vec = graph.vs[attribute] elif iterable: intervals = list(intervals) vec = [safebisect(intervals, x) for x in graph.vs[attribute]] else: intervals = float(intervals) vec = [safeintdiv(x, intervals) for x in graph.vs[attribute]] idgen = UniqueIdGenerator() idgen[None] = None vec = [idgen[i] for i in vec] return cls(graph, vec, None, params) def as_cover(self): """Returns a L{VertexCover} that contains the same clusters as this clustering.""" return VertexCover(self._graph, self) def cluster_graph(self, combine_vertices=None, combine_edges=None): """Returns a graph where each cluster is contracted into a single vertex. In the resulting graph, vertex M{i} represents cluster M{i} in this clustering. Vertex M{i} and M{j} will be connected if there was at least one connected vertex pair M{(a, b)} in the original graph such that vertex M{a} was in cluster M{i} and vertex M{b} was in cluster M{j}. @param combine_vertices: specifies how to derive the attributes of the vertices in the new graph from the attributes of the old ones. See L{Graph.contract_vertices()} for more details. @param combine_edges: specifies how to derive the attributes of the edges in the new graph from the attributes of the old ones. See L{Graph.simplify()} for more details. If you specify C{False} here, edges will not be combined, and the number of edges between the vertices representing the original clusters will be equal to the number of edges between the members of those clusters in the original graph. @return: the new graph. """ result = self.graph.copy() result.contract_vertices(self.membership, combine_vertices) if combine_edges is not False: result.simplify(combine_edges=combine_edges) return result def crossing(self): """Returns a boolean vector where element M{i} is C{True} iff edge M{i} lies between clusters, C{False} otherwise.""" membership = self.membership return [ membership[v1] != membership[v2] for v1, v2 in self.graph.get_edgelist() ] @property def modularity(self): """Returns the modularity score""" if self._modularity_dirty: return self._recalculate_modularity_safe() return self._modularity q = modularity @property def graph(self): """Returns the graph belonging to this object""" return self._graph def recalculate_modularity(self): """Recalculates the stored modularity value. This method must be called before querying the modularity score of the clustering through the class member C{modularity} or C{q} if the graph has been modified (edges have been added or removed) since the creation of the L{VertexClustering} object. @return: the new modularity score """ self._modularity = self._graph.modularity( self._membership, **self._modularity_params ) self._modularity_dirty = False return self._modularity def _recalculate_modularity_safe(self): """Recalculates the stored modularity value and swallows all exceptions raised by the modularity function (if any). @return: the new modularity score or C{None} if the modularity function could not be calculated. """ try: return self.recalculate_modularity() except Exception: return None finally: self._modularity_dirty = False def subgraph(self, idx): """Get the subgraph belonging to a given cluster. Precondition: the vertex set of the graph hasn't been modified since the moment the cover was constructed. @param idx: the cluster index @return: a copy of the subgraph """ return self._graph.subgraph(self[idx]) def subgraphs(self): """Gets all the subgraphs belonging to each of the clusters. Precondition: the vertex set of the graph hasn't been modified since the moment the cover was constructed. @return: a list containing copies of the subgraphs """ return [self._graph.subgraph(cl) for cl in self] def giant(self): """Returns the largest cluster of the clustered graph. The largest cluster is a cluster for which no larger cluster exists in the clustering. It may also be known as the I{giant community} if the clustering represents the result of a community detection function. Precondition: the vertex set of the graph hasn't been modified since the moment the cover was constructed. @note: there can be multiple largest clusters, this method will return the copy of an arbitrary one if there are multiple largest clusters. @return: a copy of the largest cluster. """ ss = self.sizes() max_size = max(ss) return self.subgraph(ss.index(max_size)) def __plot__(self, context, bbox, palette, *args, **kwds): """Plots the clustering to the given Cairo context in the given bounding box. This is done by calling L{Graph.__plot__()} with the same arguments, but coloring the graph vertices according to the current clustering (unless overridden by the C{vertex_color} argument explicitly). This method understands all the positional and keyword arguments that are understood by L{Graph.__plot__()}, only the differences will be highlighted here: - C{mark_groups}: whether to highlight some of the vertex groups by colored polygons. Besides the values accepted by L{Graph.__plot__} (i.e., a dict mapping colors to vertex indices, a list containing lists of vertex indices, or C{False}), the following are also accepted: - C{True}: all the groups will be highlighted, the colors matching the corresponding color indices from the current palette (see the C{palette} keyword argument of L{Graph.__plot__}. - A dict mapping cluster indices or tuples of vertex indices to color names. The given clusters or vertex groups will be highlighted by the given colors. - A list of cluster indices. This is equivalent to passing a dict mapping numeric color indices from the current palette to cluster indices; therefore, the cluster referred to by element I{i} of the list will be highlighted by color I{i} from the palette. The value of the C{plotting.mark_groups} configuration key is also taken into account here; if that configuration key is C{True} and C{mark_groups} is not given explicitly, it will automatically be set to C{True}. In place of lists of vertex indices, you may also use L{VertexSeq} instances. In place of color names, you may also use color indices into the current palette. C{None} as a color name will mean that the corresponding group is ignored. - C{palette}: the palette used to resolve numeric color indices to RGBA values. By default, this is an instance of L{ClusterColoringPalette}. @see: L{Graph.__plot__()} for more supported keyword arguments. """ if "edge_color" not in kwds and "color" not in self.graph.edge_attributes(): # Set up a default edge coloring based on internal vs external edges colors = ["grey20", "grey80"] kwds["edge_color"] = [ colors[is_crossing] for is_crossing in self.crossing() ] if palette is None: palette = ClusterColoringPalette(len(self)) if "mark_groups" not in kwds: if Configuration.instance()["plotting.mark_groups"]: kwds["mark_groups"] = self else: kwds["mark_groups"] = _handle_mark_groups_arg_for_clustering( kwds["mark_groups"], self ) if "vertex_color" not in kwds: kwds["vertex_color"] = self.membership return self._graph.__plot__(context, bbox, palette, *args, **kwds) def _formatted_cluster_iterator(self): """Iterates over the clusters and formats them into a string to be presented in the summary.""" if self._graph.is_named(): names = self._graph.vs["name"] for cluster in self: yield ", ".join(str(names[member]) for member in cluster) else: for cluster in self: yield ", ".join(str(member) for member in cluster) ############################################################################### class Dendrogram: """The hierarchical clustering (dendrogram) of some dataset. A hierarchical clustering means that we know not only the way the elements are separated into groups, but also the exact history of how individual elements were joined into larger subgroups. This class internally represents the hierarchy by a matrix with n rows and 2 columns -- or more precisely, a list of lists of size 2. This is exactly the same as the original format used by C{igraph}'s C core. The M{i}th row of the matrix contains the indices of the two clusters being joined in time step M{i}. The joint group will be represented by the ID M{n+i}, with M{i} starting from one. The ID of the joint group will be referenced in the upcoming steps instead of any of its individual members. So, IDs less than or equal to M{n} (where M{n} is the number of rows in the matrix) mean the original members of the dataset (with ID from 0 to M{n}), while IDs up from M{n+1} mean joint groups. As an example, take a look at the dendrogram and the internal representation of a given clustering of five nodes:: 0 -+ | 1 -+-+ | 2 ---+-+ <====> [[0, 1], [3, 4], [2, 5], [6, 7]] | 3 -+ | | | 4 -+---+--- """ def __init__(self, merges): """Creates a hierarchical clustering. @param merges: the merge history either in matrix or tuple format""" self._merges = [tuple(pair) for pair in merges] self._nmerges = len(self._merges) if self._nmerges: self._nitems = max(self._merges[-1]) - self._nmerges + 2 else: self._nitems = 0 self._names = None @staticmethod def _convert_matrix_to_tuple_repr(merges, n=None): """Converts the matrix representation of a clustering to a tuple representation. @param merges: the matrix representation of the clustering @return: the tuple representation of the clustering """ if n is None: n = len(merges) + 1 tuple_repr = range(n) idxs = range(n) for rowidx, row in enumerate(merges): i, j = row try: idxi, idxj = idxs[i], idxs[j] tuple_repr[idxi] = (tuple_repr[idxi], tuple_repr[idxj]) tuple_repr[idxj] = None except IndexError: raise ValueError( "malformed matrix, subgroup referenced " + "before being created in step %d" % rowidx ) idxs.append(j) return [x for x in tuple_repr if x is not None] def _traverse_inorder(self): """Conducts an inorder traversal of the merge tree. The inorder traversal returns the nodes on the last level in the order they should be drawn so that no edges cross each other. @return: the result of the inorder traversal in a list.""" result = [] seen_nodes = set() for node_index in reversed(range(self._nitems + self._nmerges)): if node_index in seen_nodes: continue stack = [node_index] while stack: last = stack.pop() seen_nodes.add(last) if last < self._nitems: # 'last' is a regular node so the traversal ends here, we # can append it to the results result.append(last) else: # 'last' is a merge node, so let us proceed with the entry # where this merge node was created stack.extend(self._merges[last - self._nitems]) return result def __str__(self): return self.summary(verbosity=1) def format(self, format="newick"): """Formats the dendrogram in a foreign format. Currently only the Newick format is supported. Example: >>> d = Dendrogram([(2, 3), (0, 1), (4, 5)]) >>> d.format() '((2,3)4,(0,1)5)6;' >>> d.names = list("ABCDEFG") >>> d.format() '((C,D)E,(A,B)F)G;' """ if format == "newick": n = self._nitems + self._nmerges if self._names is None: nodes = list(range(n)) else: nodes = list(self._names) if len(nodes) < n: nodes.extend("" for _ in range(n - len(nodes))) for k, (i, j) in enumerate(self._merges, self._nitems): nodes[k] = "(%s,%s)%s" % (nodes[i], nodes[j], nodes[k]) nodes[i] = nodes[j] = None return nodes[-1] + ";" raise ValueError("unsupported format: %r" % format) def summary(self, verbosity=0, max_leaf_count=40): """Returns the summary of the dendrogram. The summary includes the number of leafs and branches, and also an ASCII art representation of the dendrogram unless it is too large. @param verbosity: determines whether the ASCII representation of the dendrogram should be printed. Zero verbosity prints only the number of leafs and branches. @param max_leaf_count: the maximal number of leafs to print in the ASCII representation. If the dendrogram has more leafs than this limit, the ASCII representation will not be printed even if the verbosity is larger than or equal to 1. @return: the summary of the dendrogram as a string. """ out = StringIO() print( "Dendrogram, %d elements, %d merges" % ( self._nitems, self._nmerges, ), file=out, ) if self._nitems == 0 or verbosity < 1 or self._nitems > max_leaf_count: return out.getvalue().strip() print("", file=out) positions = [None] * self._nitems inorder = self._traverse_inorder() distance = 2 level_distance = 2 nextp = 0 for idx, element in enumerate(inorder): positions[element] = nextp inorder[idx] = str(element) nextp += max(distance, len(inorder[idx]) + 1) width = max(positions) + 1 # Print the nodes on the lowest level print((" " * (distance - 1)).join(inorder), file=out) midx = 0 max_community_idx = self._nitems while midx < self._nmerges: char_array = [" "] * width for position in positions: if position >= 0: char_array[position] = "|" char_str = "".join(char_array) for _ in range(level_distance - 1): print(char_str, file=out) # Print the lines cidx_incr = 0 while midx < self._nmerges: id1, id2 = self._merges[midx] if id1 >= max_community_idx or id2 >= max_community_idx: break midx += 1 pos1, pos2 = positions[id1], positions[id2] positions[id1], positions[id2] = -1, -1 if pos1 > pos2: pos1, pos2 = pos2, pos1 positions.append((pos1 + pos2) // 2) dashes = "-" * (pos2 - pos1 - 1) char_array[pos1 : (pos2 + 1)] = "`%s'" % dashes cidx_incr += 1 max_community_idx += cidx_incr print("".join(char_array), file=out) return out.getvalue().strip() def _item_box_size(self, context, horiz, idx): """Calculates the amount of space needed for drawing an individual vertex at the bottom of the dendrogram.""" if self._names is None or self._names[idx] is None: x_bearing, _, _, height, x_advance, _ = context.text_extents("") else: x_bearing, _, _, height, x_advance, _ = context.text_extents( str(self._names[idx]) ) if horiz: return x_advance - x_bearing, height return height, x_advance - x_bearing def _plot_item(self, context, horiz, idx, x, y): """Plots a dendrogram item to the given Cairo context @param context: the Cairo context we are plotting on @param horiz: whether the dendrogram is horizontally oriented @param idx: the index of the item @param x: the X position of the item @param y: the Y position of the item """ if self._names is None or self._names[idx] is None: return height = self._item_box_size(context, True, idx)[1] if horiz: context.move_to(x, y + height) context.show_text(str(self._names[idx])) else: context.save() context.translate(x, y) context.rotate(-pi / 2.0) context.move_to(0, height) context.show_text(str(self._names[idx])) context.restore() def __plot__(self, context, bbox, palette, *args, **kwds): """Draws the dendrogram on the given Cairo context Supported keyword arguments are: - C{orientation}: the orientation of the dendrogram. Must be one of the following values: C{left-right}, C{bottom-top}, C{right-left} or C{top-bottom}. Individual elements are always placed at the former edge and merges are performed towards the latter edge. Possible aliases: C{horizontal} = C{left-right}, C{vertical} = C{bottom-top}, C{lr} = C{left-right}, C{rl} = C{right-left}, C{tb} = C{top-bottom}, C{bt} = C{bottom-top}. The default is C{left-right}. """ from igraph.layout import Layout if self._names is None: self._names = [str(x) for x in range(self._nitems)] orientation = str_to_orientation( kwds.get("orientation", "lr"), reversed_vertical=True ) horiz = orientation in ("lr", "rl") # Get the font height font_height = context.font_extents()[2] # Calculate space needed for individual items at the # bottom of the dendrogram item_boxes = [ self._item_box_size(context, horiz, idx) for idx in range(self._nitems) ] # Small correction for cases when the right edge of the labels is # aligned with the tips of the dendrogram branches ygap = 2 if orientation == "bt" else 0 xgap = 2 if orientation == "lr" else 0 item_boxes = [(x + xgap, y + ygap) for x, y in item_boxes] # Calculate coordinates layout = Layout([(0, 0)] * self._nitems, dim=2) inorder = self._traverse_inorder() if not horiz: x, y = 0, 0 for idx, element in enumerate(inorder): layout[element] = (x, 0) x += max(font_height, item_boxes[element][0]) for id1, id2 in self._merges: y += 1 layout.append(((layout[id1][0] + layout[id2][0]) / 2.0, y)) # Mirror or rotate the layout if necessary if orientation == "bt": layout.mirror(1) else: x, y = 0, 0 for idx, element in enumerate(inorder): layout[element] = (0, y) y += max(font_height, item_boxes[element][1]) for id1, id2 in self._merges: x += 1 layout.append((x, (layout[id1][1] + layout[id2][1]) / 2.0)) # Mirror or rotate the layout if necessary if orientation == "rl": layout.mirror(0) # Rescale layout to the bounding box maxw = max(e[0] for e in item_boxes) maxh = max(e[1] for e in item_boxes) # w, h: width and height of the area containing the dendrogram # tree without the items. # delta_x, delta_y: displacement of the dendrogram tree width, height = float(bbox.width), float(bbox.height) delta_x, delta_y = 0, 0 if horiz: width -= maxw if orientation == "lr": delta_x = maxw else: height -= maxh if orientation == "tb": delta_y = maxh if horiz: delta_y += font_height / 2.0 else: delta_x += font_height / 2.0 layout.fit_into( (delta_x, delta_y, width - delta_x, height - delta_y), keep_aspect_ratio=False, ) context.save() context.translate(bbox.left, bbox.top) context.set_source_rgb(0.0, 0.0, 0.0) context.set_line_width(1) # Draw items if horiz: sgn = 0 if orientation == "rl" else -1 for idx in range(self._nitems): x = layout[idx][0] + sgn * item_boxes[idx][0] y = layout[idx][1] - item_boxes[idx][1] / 2.0 self._plot_item(context, horiz, idx, x, y) else: sgn = 1 if orientation == "bt" else 0 for idx in range(self._nitems): x = layout[idx][0] - item_boxes[idx][0] / 2.0 y = layout[idx][1] + sgn * item_boxes[idx][1] self._plot_item(context, horiz, idx, x, y) # Draw dendrogram lines if not horiz: for idx, (id1, id2) in enumerate(self._merges): x0, y0 = layout[id1] x1, y1 = layout[id2] x2, y2 = layout[idx + self._nitems] context.move_to(x0, y0) context.line_to(x0, y2) context.line_to(x1, y2) context.line_to(x1, y1) context.stroke() else: for idx, (id1, id2) in enumerate(self._merges): x0, y0 = layout[id1] x1, y1 = layout[id2] x2, y2 = layout[idx + self._nitems] context.move_to(x0, y0) context.line_to(x2, y0) context.line_to(x2, y1) context.line_to(x1, y1) context.stroke() context.restore() @property def merges(self): """Returns the performed merges in matrix format""" return deepcopy(self._merges) @property def names(self): """Returns the names of the nodes in the dendrogram""" return self._names @names.setter def names(self, items): """Sets the names of the nodes in the dendrogram""" if items is None: self._names = None return items = list(items) if len(items) < self._nitems: raise ValueError("must specify at least %d names" % self._nitems) n = self._nitems + self._nmerges self._names = items[:n] if len(self._names) < n: self._names.extend("" for _ in range(n - len(self._names))) class VertexDendrogram(Dendrogram): """The dendrogram resulting from the hierarchical clustering of the vertex set of a graph.""" def __init__( self, graph, merges, optimal_count=None, params=None, modularity_params=None ): """Creates a dendrogram object for a given graph. @param graph: the graph that will be associated to the clustering @param merges: the merges performed given in matrix form. @param optimal_count: the optimal number of clusters where the dendrogram should be cut. This is a hint usually provided by the clustering algorithm that produces the dendrogram. C{None} means that such a hint is not available; the optimal count will then be selected based on the modularity in such a case. @param params: additional parameters to be stored in this object. @param modularity_params: arguments that should be passed to L{Graph.modularity} when the modularity is (re)calculated. If the original graph was weighted, you should pass a dictionary containing a C{weight} key with the appropriate value here. """ Dendrogram.__init__(self, merges) self._graph = graph self._optimal_count = optimal_count if modularity_params is None: self._modularity_params = {} else: self._modularity_params = dict(modularity_params) def as_clustering(self, n=None): """Cuts the dendrogram at the given level and returns a corresponding L{VertexClustering} object. @param n: the desired number of clusters. Merges are replayed from the beginning until the membership vector has exactly M{n} distinct elements or until there are no more recorded merges, whichever happens first. If C{None}, the optimal count hint given by the clustering algorithm will be used If the optimal count was not given either, it will be calculated by selecting the level where the modularity is maximal. @return: a new L{VertexClustering} object. """ if n is None: n = self.optimal_count num_elts = self._graph.vcount() idgen = UniqueIdGenerator() membership = community_to_membership(self._merges, num_elts, num_elts - n) membership = [idgen[m] for m in membership] return VertexClustering( self._graph, membership, modularity_params=self._modularity_params ) @property def optimal_count(self): """Returns the optimal number of clusters for this dendrogram. If an optimal count hint was given at construction time, this property simply returns the hint. If such a count was not given, this method calculates the optimal number of clusters by maximizing the modularity along all the possible cuts in the dendrogram. """ if self._optimal_count is not None: return self._optimal_count n = self._graph.vcount() max_q, optimal_count = 0, 1 for step in range(min(n - 1, len(self._merges))): membs = community_to_membership(self._merges, n, step) q = self._graph.modularity(membs, **self._modularity_params) if q > max_q: optimal_count = n - step max_q = q self._optimal_count = optimal_count return optimal_count @optimal_count.setter def optimal_count(self, value): self._optimal_count = max(int(value), 1) def __plot__(self, context, bbox, palette, *args, **kwds): """Draws the vertex dendrogram on the given Cairo context See L{Dendrogram.__plot__} for the list of supported keyword arguments.""" from igraph.drawing.metamagic import AttributeCollectorBase class VisualVertexBuilder(AttributeCollectorBase): _kwds_prefix = "vertex_" label = None builder = VisualVertexBuilder(self._graph.vs, kwds) self._names = [vertex.label for vertex in builder] self._names = [ name if name is not None else str(idx) for idx, name in enumerate(self._names) ] result = Dendrogram.__plot__(self, context, bbox, palette, *args, **kwds) del self._names return result ############################################################################### class Cover: """Class representing a cover of an arbitrary ordered set. Covers are similar to clusterings, but each element of the set may belong to more than one cluster in a cover, and elements not belonging to any cluster are also allowed. L{Cover} instances provide a similar API as L{Clustering} instances; for instance, iterating over a L{Cover} will iterate over the clusters just like with a regular L{Clustering} instance. However, they are not derived from each other or from a common superclass, and there might be functions that exist only in one of them or the other. Clusters of an individual cover can be accessed by the C{[]} operator: >>> cl = Cover([[0,1,2,3], [2,3,4], [0,1,6]]) >>> cl[0] [0, 1, 2, 3] The membership vector can be accessed by the C{membership} property. Note that contrary to L{Clustering} instances, the membership vector will contain lists that contain the cluster indices each item belongs to: >>> cl.membership [[0, 2], [0, 2], [0, 1], [0, 1], [1], [], [2]] The number of clusters can be retrieved by the C{len} function: >>> len(cl) 3 You can iterate over the cover as if it were a regular list of clusters: >>> for cluster in cl: ... print(" ".join(str(idx) for idx in cluster)) ... 0 1 2 3 2 3 4 0 1 6 If you need all the clusters at once as lists, you can simply convert the cover to a list: >>> cluster_list = list(cl) >>> print(cluster_list) [[0, 1, 2, 3], [2, 3, 4], [0, 1, 6]] L{Clustering} objects can readily be converted to L{Cover} objects using the constructor: >>> clustering = Clustering([0, 0, 0, 0, 1, 1, 1, 2, 2, 2]) >>> cover = Cover(clustering) >>> list(clustering) == list(cover) True """ def __init__(self, clusters, n=0): """Constructs a cover with the given clusters. @param clusters: the clusters in this cover, as a list or iterable. Each cluster is specified by a list or tuple that contains the IDs of the items in this cluster. IDs start from zero. @param n: the total number of elements in the set that is covered by this cover. If it is less than the number of unique elements found in all the clusters, we will simply use the number of unique elements, so it is safe to leave this at zero. You only have to specify this parameter if there are some elements that are covered by none of the clusters. """ self._clusters = [list(cluster) for cluster in clusters] try: self._n = max(max(cluster) + 1 for cluster in self._clusters if cluster) except ValueError: self._n = 0 self._n = max(n, self._n) def __getitem__(self, index): """Returns the cluster with the given index.""" return self._clusters[index] def __iter__(self): """Iterates over the clusters in this cover.""" return iter(self._clusters) def __len__(self): """Returns the number of clusters in this cover.""" return len(self._clusters) def __str__(self): """Returns a string representation of the cover.""" return self.summary(verbosity=1, width=78) @property def membership(self): """Returns the membership vector of this cover. The membership vector of a cover covering I{n} elements is a list of length I{n}, where element I{i} contains the cluster indices of the I{i}th item. """ result = [[] for _ in range(self._n)] for idx, cluster in enumerate(self): for item in cluster: result[item].append(idx) return result @property def n(self): """Returns the number of elements in the set covered by this cover.""" return self._n def size(self, idx): """Returns the size of a given cluster. @param idx: the cluster in which we are interested. """ return len(self[idx]) def sizes(self, *args): """Returns the size of given clusters. The indices are given as positional arguments. If there are no positional arguments, the function will return the sizes of all clusters. """ if args: return [len(self._clusters[idx]) for idx in args] return [len(cluster) for cluster in self] def size_histogram(self, bin_width=1): """Returns the histogram of cluster sizes. @param bin_width: the bin width of the histogram @return: a L{Histogram} object """ return Histogram(bin_width, self.sizes()) def summary(self, verbosity=0, width=None): """Returns the summary of the cover. The summary includes the number of items and clusters, and also the list of members for each of the clusters if the verbosity is nonzero. @param verbosity: determines whether the cluster members should be printed. Zero verbosity prints the number of items and clusters only. @return: the summary of the cover as a string. """ out = StringIO() print("Cover with %d clusters" % len(self), file=out) if verbosity < 1: return out.getvalue().strip() ndigits = len(str(len(self))) wrapper = _get_wrapper_for_width(width, subsequent_indent=" " * (ndigits + 3)) for idx, cluster in enumerate(self._formatted_cluster_iterator()): wrapper.initial_indent = "[%*d] " % (ndigits, idx) print("\n".join(wrapper.wrap(cluster)), file=out) return out.getvalue().strip() def _formatted_cluster_iterator(self): """Iterates over the clusters and formats them into a string to be presented in the summary.""" for cluster in self: yield ", ".join(str(member) for member in cluster) class VertexCover(Cover): """The cover of the vertex set of a graph. This class extends L{Cover} by linking it to a specific L{Graph} object. It also provides some handy methods like getting the subgraph corresponding to a cluster and such. @note: since this class is linked to a L{Graph}, destroying the graph by the C{del} operator does not free the memory occupied by the graph if there exists a L{VertexCover} that references the L{Graph}. """ def __init__(self, graph, clusters=None): """Creates a cover object for a given graph. @param graph: the graph that will be associated to the cover @param clusters: the list of clusters. If C{None}, it is assumed that there is only a single cluster that covers the whole graph. """ if clusters is None: clusters = [range(graph.vcount())] Cover.__init__(self, clusters, n=graph.vcount()) if self._n > graph.vcount(): raise ValueError( "cluster list contains vertex ID larger than the " "number of vertices in the graph" ) self._graph = graph def crossing(self): """Returns a boolean vector where element M{i} is C{True} iff edge M{i} lies between clusters, C{False} otherwise.""" membership = [frozenset(cluster) for cluster in self.membership] return [ membership[v1].isdisjoint(membership[v2]) for v1, v2 in self.graph.get_edgelist() ] @property def graph(self): """Returns the graph belonging to this object""" return self._graph def subgraph(self, idx): """Get the subgraph belonging to a given cluster. Precondition: the vertex set of the graph hasn't been modified since the moment the cover was constructed. @param idx: the cluster index @return: a copy of the subgraph """ return self._graph.subgraph(self[idx]) def subgraphs(self): """Gets all the subgraphs belonging to each of the clusters. Precondition: the vertex set of the graph hasn't been modified since the moment the cover was constructed. @return: a list containing copies of the subgraphs """ return [self._graph.subgraph(cl) for cl in self] def __plot__(self, context, bbox, palette, *args, **kwds): """Plots the cover to the given Cairo context in the given bounding box. This is done by calling L{Graph.__plot__()} with the same arguments, but drawing nice colored blobs around the vertex groups. This method understands all the positional and keyword arguments that are understood by L{Graph.__plot__()}, only the differences will be highlighted here: - C{mark_groups}: whether to highlight the vertex clusters by colored polygons. Besides the values accepted by L{Graph.__plot__} (i.e., a dict mapping colors to vertex indices, a list containing lists of vertex indices, or C{False}), the following are also accepted: - C{True}: all the clusters will be highlighted, the colors matching the corresponding color indices from the current palette (see the C{palette} keyword argument of L{Graph.__plot__}. - A dict mapping cluster indices or tuples of vertex indices to color names. The given clusters or vertex groups will be highlighted by the given colors. - A list of cluster indices. This is equivalent to passing a dict mapping numeric color indices from the current palette to cluster indices; therefore, the cluster referred to by element I{i} of the list will be highlighted by color I{i} from the palette. The value of the C{plotting.mark_groups} configuration key is also taken into account here; if that configuration key is C{True} and C{mark_groups} is not given explicitly, it will automatically be set to C{True}. In place of lists of vertex indices, you may also use L{VertexSeq} instances. In place of color names, you may also use color indices into the current palette. C{None} as a color name will mean that the corresponding group is ignored. - C{palette}: the palette used to resolve numeric color indices to RGBA values. By default, this is an instance of L{ClusterColoringPalette}. @see: L{Graph.__plot__()} for more supported keyword arguments. """ if "edge_color" not in kwds and "color" not in self.graph.edge_attributes(): # Set up a default edge coloring based on internal vs external edges colors = ["grey20", "grey80"] kwds["edge_color"] = [ colors[is_crossing] for is_crossing in self.crossing() ] if "palette" in kwds: palette = kwds["palette"] else: palette = ClusterColoringPalette(len(self)) if "mark_groups" not in kwds: if Configuration.instance()["plotting.mark_groups"]: kwds["mark_groups"] = self else: kwds["mark_groups"] = _handle_mark_groups_arg_for_clustering( kwds["mark_groups"], self ) return self._graph.__plot__(context, bbox, palette, *args, **kwds) def _formatted_cluster_iterator(self): """Iterates over the clusters and formats them into a string to be presented in the summary.""" if self._graph.is_named(): names = self._graph.vs["name"] for cluster in self: yield ", ".join(str(names[member]) for member in cluster) else: for cluster in self: yield ", ".join(str(member) for member in cluster) class CohesiveBlocks(VertexCover): """The cohesive block structure of a graph. Instances of this type are created by L{Graph.cohesive_blocks()}. See the documentation of L{Graph.cohesive_blocks()} for an explanation of what cohesive blocks are. This class provides a few more methods that make handling of cohesive block structures easier. """ def __init__(self, graph, blocks=None, cohesion=None, parent=None): """Constructs a new cohesive block structure for the given graph. If any of I{blocks}, I{cohesion} or I{parent} is C{None}, all the arguments will be ignored and L{Graph.cohesive_blocks()} will be called to calculate the cohesive blocks. Otherwise, these three variables should describe the *result* of a cohesive block structure calculation. Chances are that you never have to construct L{CohesiveBlocks} instances directly, just use L{Graph.cohesive_blocks()}. @param graph: the graph itself @param blocks: a list containing the blocks; each block is described as a list containing vertex IDs. @param cohesion: the cohesion of each block. The length of this list must be equal to the length of I{blocks}. @param parent: the parent block of each block. Negative values or C{None} mean that there is no parent block for that block. There should be only one parent block, which covers the entire graph. @see: Graph.cohesive_blocks() """ if blocks is None or cohesion is None or parent is None: blocks, cohesion, parent = graph.cohesive_blocks() VertexCover.__init__(self, graph, blocks) self._cohesion = cohesion self._parent = parent for idx, p in enumerate(self._parent): if p < 0: self._parent[idx] = None def cohesion(self, idx): """Returns the cohesion of the group with the given index.""" return self._cohesion[idx] def cohesions(self): """Returns the list of cohesion values for each group.""" return self._cohesion[:] def hierarchy(self): """Returns a new graph that describes the hierarchical relationships between the groups. The new graph will be a directed tree; an edge will point from vertex M{i} to vertex M{j} if group M{i} is a superset of group M{j}. In other words, the edges point downwards. """ from igraph import Graph edges = [ pair for pair in zip(self._parent, range(len(self))) if pair[0] is not None ] return Graph(edges, directed=True) def max_cohesion(self, idx): """Finds the maximum cohesion score among all the groups that contain the given vertex.""" result = 0 for cohesion, cluster in zip(self._cohesion, self._clusters): if idx in cluster: result = max(result, cohesion) return result def max_cohesions(self): """For each vertex in the graph, returns the maximum cohesion score among all the groups that contain the vertex.""" result = [0] * self._graph.vcount() for cohesion, cluster in zip(self._cohesion, self._clusters): for idx in cluster: result[idx] = max(result[idx], cohesion) return result def parent(self, idx): """Returns the parent group index of the group with the given index or C{None} if the given group is the root.""" return self._parent[idx] def parents(self): """Returns the list of parent group indices for each group or C{None} if the given group is the root.""" return self._parent[:] def __plot__(self, context, bbox, palette, *args, **kwds): """Plots the cohesive block structure to the given Cairo context in the given bounding box. Since a L{CohesiveBlocks} instance is also a L{VertexCover}, keyword arguments accepted by L{VertexCover.__plot__()} are also accepted here. The only difference is that the vertices are colored according to their maximal cohesions by default, and groups are marked by colored blobs except the last group which encapsulates the whole graph. See the documentation of L{VertexCover.__plot__()} for more details. """ prepare_groups = False if "mark_groups" not in kwds: if Configuration.instance()["plotting.mark_groups"]: prepare_groups = True elif kwds["mark_groups"] is True: prepare_groups = True if prepare_groups: colors = [pair for pair in enumerate(self.cohesions()) if pair[1] > 1] kwds["mark_groups"] = colors if "vertex_color" not in kwds: kwds["vertex_color"] = self.max_cohesions() return VertexCover.__plot__(self, context, bbox, palette, *args, **kwds) def _handle_mark_groups_arg_for_clustering(mark_groups, clustering): """Handles the mark_groups=... keyword argument in plotting methods of clusterings. This is an internal method, you shouldn't need to mess around with it. Its purpose is to handle the extended semantics of the mark_groups=... keyword argument in the C{__plot__} method of L{VertexClustering} and L{VertexCover} instances, namely the feature that numeric IDs are resolved to clusters automatically. """ # Handle the case of mark_groups = True, mark_groups containing a list or # tuple of cluster IDs, and and mark_groups yielding (cluster ID, color) # pairs if mark_groups is True: group_iter = ((group, color) for color, group in enumerate(clustering)) elif isinstance(mark_groups, dict): group_iter = mark_groups.iteritems() elif hasattr(mark_groups, "__getitem__") and hasattr(mark_groups, "__len__"): # Lists, tuples try: first = mark_groups[0] except Exception: # Hmm. Maybe not a list or tuple? first = None if first is not None: # Okay. Is the first element of the list a single number? if isinstance(first, int): # Yes. Seems like we have a list of cluster indices. # Assign color indices automatically. group_iter = ((group, color) for color, group in enumerate(mark_groups)) else: # No. Seems like we have good ol' group-color pairs. group_iter = mark_groups else: group_iter = mark_groups elif hasattr(mark_groups, "__iter__"): # Iterators etc group_iter = mark_groups else: group_iter = {}.iteritems() def cluster_index_resolver(): for group, color in group_iter: if isinstance(group, int): group = clustering[group] yield group, color return cluster_index_resolver() ############################################################## def _prepare_community_comparison(comm1, comm2, remove_none=False): """Auxiliary method that takes two community structures either as membership lists or instances of L{Clustering}, and returns a tuple whose two elements are membership lists. This is used by L{compare_communities} and L{split_join_distance}. @param comm1: the first community structure as a membership list or as a L{Clustering} object. @param comm2: the second community structure as a membership list or as a L{Clustering} object. @param remove_none: whether to remove C{None} entries from the membership lists. If C{remove_none} is C{False}, a C{None} entry in either C{comm1} or C{comm2} will result in an exception. If C{remove_none} is C{True}, C{None} values are filtered away and only the remaining lists are compared. """ def _ensure_list(obj): if isinstance(obj, Clustering): return obj.membership return list(obj) vec1, vec2 = _ensure_list(comm1), _ensure_list(comm2) if len(vec1) != len(vec2): raise ValueError("the two membership vectors must be equal in length") if remove_none and (None in vec1 or None in vec2): idxs_to_remove = [ i for i in range(len(vec1)) if vec1[i] is None or vec2[i] is None ] idxs_to_remove.reverse() n = len(vec1) for i in idxs_to_remove: n -= 1 vec1[i], vec1[n] = vec1[n], vec1[i] vec2[i], vec2[n] = vec2[n], vec2[i] del vec1[n:] del vec2[n:] return vec1, vec2 def compare_communities(comm1, comm2, method="vi", remove_none=False): """Compares two community structures using various distance measures. @param comm1: the first community structure as a membership list or as a L{Clustering} object. @param comm2: the second community structure as a membership list or as a L{Clustering} object. @param method: the measure to use. C{"vi"} or C{"meila"} means the variation of information metric of Meila (2003), C{"nmi"} or C{"danon"} means the normalized mutual information as defined by Danon et al (2005), C{"split-join"} means the split-join distance of van Dongen (2000), C{"rand"} means the Rand index of Rand (1971), C{"adjusted_rand"} means the adjusted Rand index of Hubert and Arabie (1985). @param remove_none: whether to remove C{None} entries from the membership lists. This is handy if your L{Clustering} object was constructed using L{VertexClustering.FromAttribute} using an attribute which was not defined for all the vertices. If C{remove_none} is C{False}, a C{None} entry in either C{comm1} or C{comm2} will result in an exception. If C{remove_none} is C{True}, C{None} values are filtered away and only the remaining lists are compared. @return: the calculated measure. @newfield ref: Reference @ref: Meila M: Comparing clusterings by the variation of information. In: Scholkopf B, Warmuth MK (eds). Learning Theory and Kernel Machines: 16th Annual Conference on Computational Learning Theory and 7th Kernel Workship, COLT/Kernel 2003, Washington, DC, USA. Lecture Notes in Computer Science, vol. 2777, Springer, 2003. ISBN: 978-3-540-40720-1. @ref: Danon L, Diaz-Guilera A, Duch J, Arenas A: Comparing community structure identification. J Stat Mech P09008, 2005. @ref: van Dongen D: Performance criteria for graph clustering and Markov cluster experiments. Technical Report INS-R0012, National Research Institute for Mathematics and Computer Science in the Netherlands, Amsterdam, May 2000. @ref: Rand WM: Objective criteria for the evaluation of clustering methods. J Am Stat Assoc 66(336):846-850, 1971. @ref: Hubert L and Arabie P: Comparing partitions. Journal of Classification 2:193-218, 1985. """ import igraph._igraph vec1, vec2 = _prepare_community_comparison(comm1, comm2, remove_none) return igraph._igraph._compare_communities(vec1, vec2, method) def split_join_distance(comm1, comm2, remove_none=False): """Calculates the split-join distance between two community structures. The split-join distance is a distance measure defined on the space of partitions of a given set. It is the sum of the projection distance of one partition from the other and vice versa, where the projection number of A from B is if calculated as follows: 1. For each set in A, find the set in B with which it has the maximal overlap, and take note of the size of the overlap. 2. Take the sum of the maximal overlap sizes for each set in A. 3. Subtract the sum from M{n}, the number of elements in the partition. Note that the projection distance is asymmetric, that's why it has to be calculated in both directions and then added together. This function returns the projection distance of C{comm1} from C{comm2} and the projection distance of C{comm2} from C{comm1}, and returns them in a pair. The actual split-join distance is the sum of the two distances. The reason why it is presented this way is that one of the elements being zero then implies that one of the partitions is a subpartition of the other (and if it is close to zero, then one of the partitions is close to being a subpartition of the other). @param comm1: the first community structure as a membership list or as a L{Clustering} object. @param comm2: the second community structure as a membership list or as a L{Clustering} object. @param remove_none: whether to remove C{None} entries from the membership lists. This is handy if your L{Clustering} object was constructed using L{VertexClustering.FromAttribute} using an attribute which was not defined for all the vertices. If C{remove_none} is C{False}, a C{None} entry in either C{comm1} or C{comm2} will result in an exception. If C{remove_none} is C{True}, C{None} values are filtered away and only the remaining lists are compared. @return: the projection distance of C{comm1} from C{comm2} and vice versa in a tuple. The split-join distance is the sum of the two. @newfield ref: Reference @ref: van Dongen D: Performance criteria for graph clustering and Markov cluster experiments. Technical Report INS-R0012, National Research Institute for Mathematics and Computer Science in the Netherlands, Amsterdam, May 2000. @see: L{compare_communities()} with C{method = "split-join"} if you are not interested in the individual projection distances but only the sum of them. """ import igraph._igraph vec1, vec2 = _prepare_community_comparison(comm1, comm2, remove_none) return igraph._igraph._split_join_distance(vec1, vec2) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/configuration.py0000644000175100001710000004063300000000000021073 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Configuration framework for igraph. igraph has some parameters which usually affect the behaviour of many functions. This module provides the framework for altering and querying igraph parameters as well as saving them to and retrieving them from disk. """ import sys if sys.version_info < (3, 2): from configparser import SafeConfigParser as ConfigParser else: from configparser import ConfigParser import platform import os.path def get_platform_image_viewer(): """Returns the path of an image viewer on the given platform. Deprecated since igraph 0.9.1 and will be removed in 0.10.0. @deprecated: This function was only used by the now-deprecated C{show()} method of the Plot class. """ plat = platform.system() if plat == "Darwin": # Most likely Mac OS X return "open" elif plat == "Linux": # Linux has a whole lot of choices, try to find one choices = [ "eog", "gthumb", "gqview", "kuickshow", "xnview", "display", "gpicview", "gwenview", "qiv", "gimv", "ristretto", "geeqie", "eom", ] paths = ["/usr/bin", "/bin"] for path in paths: for choice in choices: full_path = os.path.join(path, choice) if os.path.isfile(full_path): return full_path return "" elif plat == "FreeBSD": # FreeBSD also has a whole lot of choices, try to find one choices = [ "eog", "gthumb", "geeqie", "display", "gpicview", "gwenview", "qiv", "gimv", "ristretto", "geeqie", "eom", ] paths = ["%%LOCALBASE%%/bin"] for path in paths: for choice in choices: full_path = os.path.join(path, choice) if os.path.isfile(full_path): return full_path return "" elif plat == "Windows" or plat == "Microsoft": # Thanks to Dale Hunscher # Use the built-in Windows image viewer, if available return "start" else: # Unknown system return "" class Configuration: """Class representing igraph configuration details. Note that there is one primary instance of this class, which is used by igraph itself to retrieve configuration parameters when needed. You can access this instance with the L{instance()} method. You I{may} construct other instances by invoking the constructor directly, but these instances will I{not} affect igraph's behaviour. If you are interested in configuring igraph, use L{igraph.config} to get hold of the singleton instance and then modify it. General ideas ============= The configuration of igraph is stored in the form of name-value pairs. This object provides an interface to the configuration data using the syntax known from dict: >>> c = Configuration() >>> c["general.verbose"] = True >>> print(c["general.verbose"]) True Configuration keys are organized into sections, and the name to be used for a given key is always in the form C{section.keyname}, like C{general.verbose} in the example above. In that case, C{general} is the name of the configuration section, and C{verbose} is the name of the key. If the name of the section is omitted, it defaults to C{general}, so C{general.verbose} can be referred to as C{verbose}: >>> c = Configuration() >>> c["verbose"] = True >>> print(c["general.verbose"]) True User-level configuration is stored in C{~/.igraphrc} per default on Linux and Mac OS X systems, or in C{C:\\Documents and Settings\\username\\.igraphrc} on Windows systems. However, this configuration is read only when C{igraph} is launched through its shell interface defined in L{igraph.app.shell}. This behaviour might change before version 1.0. Known configuration keys ======================== The known configuration keys are presented below, sorted by section. When referring to them in program code, don't forget to add the section name, expect in the case of section C{general}. General settings ---------------- These settings are all stored in section C{general}. - B{shells}: the list of preferred Python shells to be used with the command-line C{igraph} script. The shells in the list are tried one by one until any of them is found on the system. C{igraph} functions are then imported into the main namespace of the shell and the shell is launched. Known shells and their respective class names to be used can be found in L{igraph.app.shell}. Example: C{IPythonShell, ClassicPythonShell}. This is the default, by the way. - B{verbose}: whether L{igraph} should talk more than really necessary. For instance, if set to C{True}, some functions display progress bars. Application settings -------------------- These settings specify the external applications that are possibly used by C{igraph}. They are all stored in section C{apps}. - B{image_viewer}: image viewer application. If set to an empty string, it will be determined automatically from the platform C{igraph} runs on. On Mac OS X, it defaults to the Preview application. On Linux, it chooses a viewer from several well-known Linux viewers like C{gthumb}, C{kuickview} and so on (see the source code for the full list). On Windows, it defaults to the system's built-in image viewer. Plotting settings ----------------- These settings specify the default values used by plotting functions. They are all stored in section C{plotting}. - B{layout}: default graph layout algorithm to be used. - B{mark_groups}: whether to mark the clusters by polygons when plotting a clustering object. - B{palette}: default palette to be used for converting integer numbers to colors. See L{colors.Palette} for more information. Valid palette names are stored in C{colors.palettes}. - B{wrap_labels}: whether to try to wrap the labels of the vertices automatically if they don't fit within the vertex. Default: C{False}. Shell settings -------------- These settings specify options for external environments in which igraph is embedded (e.g., IPython and its Qt console). These settings are stored in section C{shell}. - B{ipython.inlining.Plot}: whether to show instances of the L{Plot} class inline in IPython's console if the console supports it. Default: C{True} """ class Types: """Static class for the implementation of custom getter/setter functions for configuration keys""" def __init__(self): pass @staticmethod def setboolean(obj, section, key, value): """Sets a boolean value in the given configuration object. @param obj: a configuration object @param section: the section of the value to be set @param key: the key of the value to be set @param value: the value itself. C{0}, C{false}, C{no} and C{off} means false, C{1}, C{true}, C{yes} and C{on} means true, everything else results in a C{ValueError} being thrown. Values are case insensitive """ value = str(value).lower() if value in ("0", "false", "no", "off"): value = "false" elif value in ("1", "true", "yes", "on"): value = "true" else: raise ValueError("value cannot be coerced to boolean type") obj.set(section, key, value) @staticmethod def setint(obj, section, key, value): """Sets an integer value in the given configuration object. @param obj: a configuration object @param section: the section of the value to be set @param key: the key of the value to be set @param value: the value itself. """ obj.set(section, key, str(int(value))) @staticmethod def setfloat(obj, section, key, value): """Sets a float value in the given configuration object. Note that float values are converted to strings in the configuration object, which may lead to some precision loss. @param obj: a configuration object @param section: the section of the value to be set @param key: the key of the value to be set @param value: the value itself. """ obj.set(section, key, str(float(value))) _types = { "boolean": {"getter": ConfigParser.getboolean, "setter": Types.setboolean}, "int": {"getter": ConfigParser.getint, "setter": Types.setint}, "float": {"getter": ConfigParser.getfloat, "setter": Types.setfloat}, } _sections = ("general", "apps", "plotting", "remote", "shell") _definitions = { "general.shells": {"default": "IPythonShell,ClassicPythonShell"}, "general.verbose": {"default": True, "type": "boolean"}, "apps.image_viewer": {"default": get_platform_image_viewer()}, "plotting.layout": {"default": "auto"}, "plotting.mark_groups": {"default": False, "type": "boolean"}, "plotting.palette": {"default": "gray"}, "plotting.wrap_labels": {"default": False, "type": "boolean"}, "shell.ipython.inlining.Plot": {"default": True, "type": "boolean"}, } # The singleton instance we are using throughout other modules _instance = None def __init__(self, filename=None): """Creates a new configuration instance. @param filename: file or file pointer to be read. Can be omitted. """ self._config = ConfigParser() self._filename = None # Create default sections for sec in self._sections: self._config.add_section(sec) # Create default values for name, definition in self._definitions.items(): if "default" in definition: self[name] = definition["default"] if filename is not None: self.load(filename) @property def filename(self): """Returns the filename associated to the object. It is usually the name of the configuration file that was used when creating the object. L{Configuration.load} always overwrites it with the filename given to it. If C{None}, the configuration was either created from scratch or it was updated from a stream without name information.""" return self._filename def _get(self, section, key): """Internal function that returns the value of a given key in a given section.""" definition = self._definitions.get("%s.%s" % (section, key), {}) getter = None if "type" in definition: getter = self._types[definition["type"]].get("getter") if getter is None: getter = self._config.__class__.get return getter(self._config, section, key) @staticmethod def _item_to_section_key(item): """Converts an item description to a section-key pair. @param item: the item to be converted @return: if C{item} contains a period (C{.}), it is splitted into two parts at the first period, then the two parts are returned, so the part before the period is the section. If C{item} does not contain a period, the section is assumed to be C{general}, and the second part of the returned pair contains C{item} unchanged""" if "." in item: section, key = item.split(".", 1) else: section, key = "general", item return section, key def __contains__(self, item): """Checks whether the given configuration item is set. @param item: the configuration key to check. @return: C{True} if the key has an associated value, C{False} otherwise. """ section, key = self._item_to_section_key(item) return self._config.has_option(section, key) def __getitem__(self, item): """Returns the given configuration item. @param item: the configuration key to retrieve. @return: the configuration value""" section, key = self._item_to_section_key(item) if key == "*": # Special case: retrieving all the keys within a section and # returning it in a dict keys = self._config.items(section) return dict((key, self._get(section, key)) for key, _ in keys) else: return self._get(section, key) def __setitem__(self, item, value): """Sets the given configuration item. @param item: the configuration key to set @param value: the new value of the configuration key """ section, key = self._item_to_section_key(item) definition = self._definitions.get("%s.%s" % (section, key), {}) setter = None if "type" in definition: setter = self._types[definition["type"]].get("setter", None) if setter is None: setter = self._config.__class__.set return setter(self._config, section, key, value) def __delitem__(self, item): """Deletes the given item from the configuration. If the item has a default value, the default value is written back instead of the current value. Without a default value, the item is really deleted. """ section, key = self._item_to_section_key(item) definition = self._definitions.get("%s.%s" % (section, key), {}) if "default" in definition: self[item] = definition["default"] else: self._config.remove_option(section, key) def has_key(self, item): """Checks if the configuration has a given key. @param item: the key being sought""" if "." in item: section, key = item.split(".", 1) else: section, key = "general", item return self._config.has_option(section, key) def load(self, stream=None): """Loads the configuration from the given file. @param stream: name of a file or a file object. The configuration will be loaded from here. Can be omitted, in this case, the user-level configuration is loaded. """ stream = stream or get_user_config_file() if isinstance(stream, str): stream = open(stream, "r") file_was_open = True self._config.readfp(stream) self._filename = getattr(stream, "name", None) if file_was_open: stream.close() def save(self, stream=None): """Saves the configuration. @param stream: name of a file or a file object. The configuration will be saved there. Can be omitted, in this case, the user-level configuration file will be overwritten. """ stream = stream or get_user_config_file() if not hasattr(stream, "write") or not hasattr(stream, "close"): stream = open(stream, "w") file_was_open = True self._config.write(stream) if file_was_open: stream.close() @classmethod def instance(cls): """Returns the single instance of the configuration object.""" if cls._instance is None: cfile = get_user_config_file() try: config = cls(cfile) except IOError: # No config file yet, whatever config = cls() cls._instance = config return cls._instance def get_user_config_file(): """Returns the path where the user-level configuration file is stored""" return os.path.expanduser("~/.igraphrc") def init(): """Default mechanism to initiate igraph configuration This method loads the user-specific configuration file from the user's home directory, or if it does not exist, creates a default configuration. The method is safe to be called multiple times, it will not parse the configuration file twice. @return: the L{Configuration} object loaded or created.""" return Configuration.instance() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/cut.py0000644000175100001710000001317200000000000017015 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Classes representing cuts and flows on graphs.""" from igraph.clustering import VertexClustering class Cut(VertexClustering): """A cut of a given graph. This is a simple class used to represent cuts returned by L{Graph.mincut()}, L{Graph.all_st_cuts()} and other functions that calculate cuts. A cut is a special vertex clustering with only two clusters. Besides the usual L{VertexClustering} methods, it also has the following attributes: - C{value} - the value (capacity) of the cut. It is equal to the number of edges if there are no capacities on the edges. - C{partition} - vertex IDs in the parts created after removing edges in the cut - C{cut} - edge IDs in the cut - C{es} - an edge selector restricted to the edges in the cut. You can use indexing on this object to obtain lists of vertex IDs for both sides of the partition. This class is usually not instantiated directly, everything is taken care of by the functions that return cuts. Examples: >>> from igraph import Graph >>> g = Graph.Ring(20) >>> mc = g.mincut() >>> print(mc.value) 2.0 >>> print(min(len(x) for x in mc)) 1 >>> mc.es["color"] = "red" """ def __init__(self, graph, value=None, cut=None, partition=None, partition2=None): """Initializes the cut. This should not be called directly, everything is taken care of by the functions that return cuts. """ # Input validation if partition is None or cut is None: raise ValueError("partition and cut must be given") # Set up a membership vector, initialize parent class membership = [1] * graph.vcount() for vid in partition: membership[vid] = 0 VertexClustering.__init__(self, graph, membership) if value is None: # Value of the cut not given, count the number of edges value = len(cut) self._value = float(value) self._partition = sorted(partition) self._cut = cut def __repr__(self): return "%s(%r, %r, %r, %r)" % ( self.__class__.__name__, self._graph, self._value, self._cut, self._partition, ) def __str__(self): return "Graph cut (%d edges, %d vs %d vertices, value=%.4f)" % ( len(self._cut), len(self._partition), self._graph.vcount() - len(self._partition), self._value, ) @property def es(self): """Returns an edge selector restricted to the cut""" return self._graph.es.select(self.cut) @property def partition(self): """Returns the vertex IDs partitioned according to the cut""" return list(self) @property def cut(self): """Returns the edge IDs in the cut""" return self._cut @property def value(self): """Returns the sum of edge capacities in the cut""" return self._value class Flow(Cut): """A flow of a given graph. This is a simple class used to represent flows returned by L{Graph.maxflow}. It has the following attributes: - C{graph} - the graph on which this flow is defined - C{value} - the value (capacity) of the flow - C{flow} - the flow values on each edge. For directed graphs, this is simply a list where element M{i} corresponds to the flow on edge M{i}. For undirected graphs, the direction of the flow is not constrained (since the edges are undirected), hence positive flow always means a flow from the smaller vertex ID to the larger, while negative flow means a flow from the larger vertex ID to the smaller. - C{cut} - edge IDs in the minimal cut corresponding to the flow. - C{partition} - vertex IDs in the parts created after removing edges in the cut - C{es} - an edge selector restricted to the edges in the cut. This class is usually not instantiated directly, everything is taken care of by L{Graph.maxflow}. Examples: >>> from igraph import Graph >>> g = Graph.Ring(20) >>> mf = g.maxflow(0, 10) >>> print(mf.value) 2.0 >>> mf.es["color"] = "red" """ def __init__(self, graph, value, flow, cut, partition): """Initializes the flow. This should not be called directly, everything is taken care of by L{Graph.maxflow}. """ super().__init__(graph, value, cut, partition) self._flow = flow def __repr__(self): return "%s(%r, %r, %r, %r, %r)" % ( self.__class__.__name__, self._graph, self._value, self._flow, self._cut, self._partition, ) def __str__(self): return "Graph flow (%d edges, %d vs %d vertices, value=%.4f)" % ( len(self._cut), len(self._partition), self._graph.vcount() - len(self._partition), self._value, ) @property def flow(self): """Returns the flow values for each edge. For directed graphs, this is simply a list where element M{i} corresponds to the flow on edge M{i}. For undirected graphs, the direction of the flow is not constrained (since the edges are undirected), hence positive flow always means a flow from the smaller vertex ID to the larger, while negative flow means a flow from the larger vertex ID to the smaller. """ return self._flow ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/datatypes.py0000644000175100001710000006606300000000000020227 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Additional auxiliary data types""" from itertools import islice class Matrix: """Simple matrix data type. Of course there are much more advanced matrix data types for Python (for instance, the C{ndarray} data type of Numeric Python) and this implementation does not want to compete with them. The only role of this data type is to provide a convenient interface for the matrices returned by the C{Graph} object (for instance, allow indexing with tuples in the case of adjacency matrices and so on). """ def __init__(self, data=None): """Initializes a matrix. @param data: the elements of the matrix as a list of lists, or C{None} to create a 0x0 matrix. """ self._nrow, self._ncol, self._data = 0, 0, [] self.data = data @classmethod def Fill(cls, value, *args): """Creates a matrix filled with the given value @param value: the value to be used @keyword shape: the shape of the matrix. Can be a single integer, two integers or a tuple. If a single integer is given here, the matrix is assumed to be square-shaped. """ if len(args) < 1: raise TypeError("expected an integer or a tuple") if len(args) == 1: if hasattr(args[0], "__len__"): height, width = int(args[0][0]), int(args[0][1]) else: height, width = int(args[0]), int(args[0]) else: height, width = int(args[0]), int(args[1]) mtrx = [[value] * width for _ in range(height)] return cls(mtrx) @classmethod def Zero(cls, *args): """Creates a matrix filled with zeros. @keyword shape: the shape of the matrix. Can be a single integer, two integers or a tuple. If a single integer is given here, the matrix is assumed to be square-shaped. """ result = cls.Fill(0, *args) return result @classmethod def Identity(cls, *args): """Creates an identity matrix. @keyword shape: the shape of the matrix. Can be a single integer, two integers or a tuple. If a single integer is given here, the matrix is assumed to be square-shaped. """ result = cls.Fill(0, *args) for i in range(min(result.shape)): result._data[i][i] = 1 return result def _set_data(self, data=None): """Sets the data stored in the matrix""" if data is not None: self._data = [list(row) for row in data] self._nrow = len(self._data) if self._nrow > 0: self._ncol = max(len(row) for row in self._data) else: self._ncol = 0 for row in self._data: if len(row) < self._ncol: row.extend([0] * (self._ncol - len(row))) def _get_data(self): """Returns the data stored in the matrix as a list of lists""" return [list(row) for row in self._data] data = property(_get_data, _set_data) @property def shape(self): """Returns the shape of the matrix as a tuple""" return self._nrow, self._ncol def __add__(self, other): """Adds the given value to the matrix. @param other: either a scalar or a matrix. Scalars will be added to each element of the matrix. Matrices will be added together elementwise. @return: the result matrix """ if isinstance(other, Matrix): if self.shape != other.shape: raise ValueError("matrix shapes do not match") return self.__class__( [ [a + b for a, b in zip(row_a, row_b)] for row_a, row_b in zip(self, other) ] ) else: return self.__class__([[item + other for item in row] for row in self]) def __eq__(self, other): """Checks whether a given matrix is equal to another one""" return ( isinstance(other, Matrix) and self._nrow == other._nrow and self._ncol == other._ncol and self._data == other._data ) def __getitem__(self, i): """Returns a single item, a row or a column of the matrix @param i: if a single integer, returns the M{i}th row as a list. If a slice, returns the corresponding rows as another L{Matrix} object. If a 2-tuple, the first element of the tuple is used to select a row and the second is used to select a column. """ if isinstance(i, int): return list(self._data[i]) elif isinstance(i, slice): return self.__class__(self._data[i]) elif isinstance(i, tuple): try: first = i[0] except IndexError: first = slice(None) try: second = i[1] except IndexError: second = slice(None) if type(first) == slice and type(second) == slice: return self.__class__(row[second] for row in self._data[first]) elif type(first) == slice: return [row[second] for row in self._data[first]] else: return self._data[first][second] else: raise IndexError("invalid matrix index") def __hash__(self): """Returns a hash value for a matrix.""" return hash(self._nrow, self._ncol, self._data) def __iadd__(self, other): """In-place addition of a matrix or scalar.""" if isinstance(other, Matrix): if self.shape != other.shape: raise ValueError("matrix shapes do not match") for row_a, row_b in zip(self._data, other): for i in range(len(row_a)): row_a[i] += row_b[i] else: for row in self._data: for i in range(len(row)): row[i] += other return self def __isub__(self, other): """In-place subtraction of a matrix or scalar.""" if isinstance(other, Matrix): if self.shape != other.shape: raise ValueError("matrix shapes do not match") for row_a, row_b in zip(self._data, other): for i in range(len(row_a)): row_a[i] -= row_b[i] else: for row in self._data: for i in range(len(row)): row[i] -= other return self def __ne__(self, other): """Checks whether a given matrix is not equal to another one""" return not self == other def __setitem__(self, i, value): """Sets a single item, a row or a column of the matrix @param i: if a single integer, sets the M{i}th row as a list. If a slice, sets the corresponding rows from another L{Matrix} object. If a 2-tuple, the first element of the tuple is used to select a row and the second is used to select a column. @param value: the new value """ if isinstance(i, int): # Setting a row if len(value) != len(self._data[i]): raise ValueError("new value must have %d items" % self._ncol) self._data[i] = list(value) elif isinstance(i, slice): # Setting multiple rows if len(value) != len(self._data[i]): raise ValueError("new value must have %d items" % self._ncol) if any(len(row) != self._ncol for row in value): raise ValueError("rows of new value must have %d items" % self._ncol) self._data[i] = [list(row) for row in value] elif isinstance(i, tuple): try: first = i[0] except IndexError: first = slice(None) try: second = i[1] except IndexError: second = slice(None) if type(first) == slice and type(second) == slice: # Setting a submatrix # TODO raise NotImplementedError elif type(first) == slice: # Setting a submatrix raise NotImplementedError else: # Setting a single element self._data[first][second] = value else: raise IndexError("invalid matrix index") def __sub__(self, other): """Subtracts the given value from the matrix. @param other: either a scalar or a matrix. Scalars will be subtracted from each element of the matrix. Matrices will be subtracted together elementwise. @return: the result matrix """ if isinstance(other, Matrix): if self.shape != other.shape: raise ValueError("matrix shapes do not match") return self.__class__( [ [a - b for a, b in zip(row_a, row_b)] for row_a, row_b in zip(self, other) ] ) else: return self.__class__([[item - other for item in row] for row in self]) def __repr__(self): class_name = self.__class__.__name__ rows = ("[%s]" % ", ".join(repr(item) for item in row) for row in self) return "%s([%s])" % (class_name, ", ".join(rows)) def __str__(self): rows = ("[%s]" % ", ".join(repr(item) for item in row) for row in self) return "[%s]" % "\n ".join(rows) def __iter__(self): """Support for iteration. This is actually implemented as a generator, so there is no need for a separate iterator class. The generator returns I{copies} of the rows in the matrix as lists to avoid messing around with the internals. Feel free to do anything with the copies, the changes won't be reflected in the original matrix.""" return (list(row) for row in self._data) def __plot__(self, context, bbox, palette, **kwds): """Plots the matrix to the given Cairo context in the given box Besides the usual self-explanatory plotting parameters (C{context}, C{bbox}, C{palette}), it accepts the following keyword arguments: - C{style}: the style of the plot. C{boolean} is useful for plotting matrices with boolean (C{True}/C{False} or 0/1) values: C{False} will be shown with a white box and C{True} with a black box. C{palette} uses the given palette to represent numbers by colors, the minimum will be assigned to palette color index 0 and the maximum will be assigned to the length of the palette. C{None} draws transparent cell backgrounds only. The default style is C{boolean} (but it may change in the future). C{None} values in the matrix are treated specially in both cases: nothing is drawn in the cell corresponding to C{None}. - C{square}: whether the cells of the matrix should be square or not. Default is C{True}. - C{grid_width}: line width of the grid shown on the matrix. If zero or negative, the grid is turned off. The grid is also turned off if the size of a cell is less than three times the given line width. Default is C{1}. Fractional widths are also allowed. - C{border_width}: line width of the border drawn around the matrix. If zero or negative, the border is turned off. Default is C{1}. - C{row_names}: the names of the rows - C{col_names}: the names of the columns. - C{values}: values to be displayed in the cells. If C{None} or C{False}, no values are displayed. If C{True}, the values come from the matrix being plotted. If it is another matrix, the values of that matrix are shown in the cells. In this case, the shape of the value matrix must match the shape of the matrix being plotted. - C{value_format}: a format string or a callable that specifies how the values should be plotted. If it is a callable, it must be a function that expects a single value and returns a string. Example: C{"%#.2f"} for floating-point numbers with always exactly two digits after the decimal point. See the Python documentation of the C{%} operator for details on the format string. If the format string is not given, it defaults to the C{str} function. If only the row names or the column names are given and the matrix is square-shaped, the same names are used for both column and row names. """ grid_width = float(kwds.get("grid_width", 1.0)) border_width = float(kwds.get("border_width", 1.0)) style = kwds.get("style", "boolean") row_names = kwds.get("row_names") col_names = kwds.get("col_names", row_names) values = kwds.get("values") value_format = kwds.get("value_format", str) # Validations if style not in ("boolean", "palette", "none", None): raise ValueError("invalid style") if style == "none": style = None if row_names is None and col_names is not None: row_names = col_names if row_names is not None: row_names = [str(name) for name in islice(row_names, self._nrow)] if len(row_names) < self._nrow: row_names.extend([""] * (self._nrow - len(row_names))) if col_names is not None: col_names = [str(name) for name in islice(col_names, self._ncol)] if len(col_names) < self._ncol: col_names.extend([""] * (self._ncol - len(col_names))) if values is False: values = None if values is True: values = self if isinstance(values, list): values = Matrix(list) if values is not None and not isinstance(values, Matrix): raise TypeError("values must be None, False, True or a matrix") if values is not None and values.shape != self.shape: raise ValueError("values must be a matrix of size %s" % self.shape) # Calculate text extents if needed if row_names is not None or col_names is not None: te = context.text_extents space_width = te(" ")[4] max_row_name_width = max([te(s)[4] for s in row_names]) + space_width max_col_name_width = max([te(s)[4] for s in col_names]) + space_width else: max_row_name_width, max_col_name_width = 0, 0 # Calculate sizes total_width = float(bbox.width) - max_row_name_width total_height = float(bbox.height) - max_col_name_width dx = total_width / self.shape[1] dy = total_height / self.shape[0] if kwds.get("square", True): dx, dy = min(dx, dy), min(dx, dy) total_width, total_height = dx * self.shape[1], dy * self.shape[0] ox = bbox.left + (bbox.width - total_width - max_row_name_width) / 2.0 oy = bbox.top + (bbox.height - total_height - max_col_name_width) / 2.0 ox += max_row_name_width oy += max_col_name_width # Determine rescaling factors for the palette if needed if style == "palette": mi, ma = self.min(), self.max() color_offset = mi color_ratio = (len(palette) - 1) / float(ma - mi) # Validate grid width if dx < 3 * grid_width or dy < 3 * grid_width: grid_width = 0.0 if grid_width > 0: context.set_line_width(grid_width) else: # When the grid width is zero, we will still stroke the # rectangles, but with the same color as the fill color # of the cell - otherwise we would get thin white lines # between the cells as a drawing artifact context.set_line_width(1) # Draw row names (if any) context.set_source_rgb(0.0, 0.0, 0.0) if row_names is not None: x, y = ox, oy for heading in row_names: _, _, _, h, xa, _ = context.text_extents(heading) context.move_to(x - xa - space_width, y + (dy + h) / 2.0) context.show_text(heading) y += dy # Draw column names (if any) if col_names is not None: context.save() context.translate(ox, oy) context.rotate(-1.5707963285) # pi/2 x, y = 0.0, 0.0 for heading in col_names: _, _, _, h, _, _ = context.text_extents(heading) context.move_to(x + space_width, y + (dx + h) / 2.0) context.show_text(heading) y += dx context.restore() # Draw matrix x, y = ox, oy if style is None: fill = lambda: None # noqa: E731 else: fill = context.fill_preserve for row in self: for item in row: if item is None: x += dx continue if style == "boolean": if item: context.set_source_rgb(0.0, 0.0, 0.0) else: context.set_source_rgb(1.0, 1.0, 1.0) elif style == "palette": cidx = int((item - color_offset) * color_ratio) if cidx < 0: cidx = 0 context.set_source_rgba(*palette.get(cidx)) context.rectangle(x, y, dx, dy) if grid_width > 0: fill() context.set_source_rgb(0.5, 0.5, 0.5) context.stroke() else: fill() context.stroke() x += dx x, y = ox, y + dy # Draw cell values if values is not None: x, y = ox, oy context.set_source_rgb(0.0, 0.0, 0.0) for row in values.data: if hasattr(value_format, "__call__"): values = [value_format(item) for item in row] else: values = [value_format % item for item in row] for item in values: th, tw = context.text_extents(item)[3:5] context.move_to(x + (dx - tw) / 2.0, y + (dy + th) / 2.0) context.show_text(item) x += dx x, y = ox, y + dy # Draw borders if border_width > 0: context.set_line_width(border_width) context.set_source_rgb(0.0, 0.0, 0.0) context.rectangle(ox, oy, dx * self.shape[1], dy * self.shape[0]) context.stroke() def min(self, dim=None): """Returns the minimum of the matrix along the given dimension @param dim: the dimension. 0 means determining the column minimums, 1 means determining the row minimums. If C{None}, the global minimum is returned. """ if dim == 1: return [min(row) for row in self._data] if dim == 0: return [min(row[idx] for row in self._data) for idx in range(self._ncol)] return min(min(row) for row in self._data) def max(self, dim=None): """Returns the maximum of the matrix along the given dimension @param dim: the dimension. 0 means determining the column maximums, 1 means determining the row maximums. If C{None}, the global maximum is returned. """ if dim == 1: return [max(row) for row in self._data] if dim == 0: return [max(row[idx] for row in self._data) for idx in range(self._ncol)] return max(max(row) for row in self._data) class DyadCensus(tuple): """Dyad census of a graph. This is a pretty simple class - basically it is a tuple, but it allows the user to refer to its individual items by the names C{mutual} (or C{mut}), C{asymmetric} (or C{asy} or C{asym} or C{asymm}) and C{null}. Examples: >>> from igraph import Graph >>> g=Graph.Erdos_Renyi(100, 0.2, directed=True) >>> dc=g.dyad_census() >>> print(dc.mutual) #doctest:+SKIP 179 >>> print(dc["asym"]) #doctest:+SKIP 1609 >>> print(tuple(dc), list(dc)) #doctest:+SKIP (179, 1609, 3162) [179, 1609, 3162] >>> print(sorted(dc.as_dict().items())) #doctest:+ELLIPSIS [('asymmetric', ...), ('mutual', ...), ('null', ...)] """ _remap = { "mutual": 0, "mut": 0, "sym": 0, "symm": 0, "asy": 1, "asym": 1, "asymm": 1, "asymmetric": 1, "null": 2, } def __getitem__(self, idx): return tuple.__getitem__(self, self._remap.get(idx, idx)) def __getattr__(self, attr): if attr in self._remap: return tuple.__getitem__(self, self._remap[attr]) raise AttributeError("no such attribute: %s" % attr) def __repr__(self): return "DyadCensus((%d, %d, %d))" % self def __str__(self): return "%d mutual, %d asymmetric, %d null dyads" % self def as_dict(self): """Converts the dyad census to a dict using the known dyad names.""" return {"mutual": self[0], "asymmetric": self[1], "null": self[2]} class TriadCensus(tuple): """Triad census of a graph. This is a pretty simple class - basically it is a tuple, but it allows the user to refer to its individual items by the following triad names: - C{003} -- the empty graph - C{012} -- a graph with a single directed edge (C{A --> B, C}) - C{102} -- a graph with a single mutual edge (C{A <-> B, C}) - C{021D} -- the binary out-tree (C{A <-- B --> C}) - C{021U} -- the binary in-tree (C{A --> B <-- C}) - C{021C} -- the directed line (C{A --> B --> C}) - C{111D} -- C{A <-> B <-- C} - C{111U} -- C{A <-> B --> C} - C{030T} -- C{A --> B <-- C, A --> C} - C{030C} -- C{A <-- B <-- C, A --> C} - C{201} -- C{A <-> B <-> C} - C{120D} -- C{A <-- B --> C, A <-> C} - C{120U} -- C{A --> B <-- C, A <-> C} - C{120C} -- C{A --> B --> C, A <-> C} - C{210C} -- C{A --> B <-> C, A <-> C} - C{300} -- the complete graph (C{A <-> B <-> C, A <-> C}) Attribute and item accessors are provided. Due to the syntax of Python, attribute names are not allowed to start with a number, therefore the triad names must be prepended with a lowercase C{t} when accessing them as attributes. This is not necessary with the item accessor syntax. Examples: >>> from igraph import Graph >>> g=Graph.Erdos_Renyi(100, 0.2, directed=True) >>> tc=g.triad_census() >>> print(tc.t003) #doctest:+SKIP 39864 >>> print(tc["030C"]) #doctest:+SKIP 1206 """ _remap = { "003": 0, "012": 1, "102": 2, "021D": 3, "021U": 4, "021C": 5, "111D": 6, "111U": 7, "030T": 8, "030C": 9, "201": 10, "120D": 11, "120U": 12, "120C": 13, "210": 14, "300": 15, } def __getitem__(self, idx): if isinstance(idx, str): idx = idx.upper() return tuple.__getitem__(self, self._remap.get(idx, idx)) def __getattr__(self, attr): if isinstance(attr, str) and attr[0] == "t" and attr[1:].upper() in self._remap: return tuple.__getitem__(self, self._remap[attr[1:].upper()]) raise AttributeError("no such attribute: %s" % attr) def __repr__(self): return "TriadCensus((%s))" % ", ".join(str(item) for item in self) def __str__(self): maxidx = len(self) maxcount = max(self) numwidth = len(str(maxcount)) captionwidth = max(len(key) for key in self._remap) colcount = 4 rowcount = maxidx / colcount if rowcount * colcount < maxidx: rowcount += 1 invmap = dict((v, k) for k, v in self._remap.items()) result, row, idx = [], [], 0 for _ in range(rowcount): for _ in range(colcount): if idx >= maxidx: break row.append( "%-*s: %*d" % (captionwidth, invmap.get(idx, ""), numwidth, self[idx]) ) idx += 1 result.append(" | ".join(row)) row = [] return "\n".join(result) class UniqueIdGenerator: """A dictionary-like class that can be used to assign unique IDs to names (say, vertex names). Usage: >>> gen = UniqueIdGenerator() >>> gen["A"] 0 >>> gen["B"] 1 >>> gen["C"] 2 >>> gen["A"] # Retrieving already existing ID 0 >>> gen.add("D") # Synonym of gen["D"] 3 >>> len(gen) # Number of already used IDs 4 >>> "C" in gen True >>> "E" in gen False """ def __init__(self, id_generator=None, initial=None): """Creates a new unique ID generator. `id_generator` specifies how do we assign new IDs to elements that do not have an ID yet. If it is `None`, elements will be assigned integer identifiers starting from 0. If it is an integer, elements will be assigned identifiers starting from the given integer. If it is an iterator or generator, its `next` method will be called every time a new ID is needed.""" if id_generator is None: id_generator = 0 if isinstance(id_generator, int): import itertools self._generator = itertools.count(id_generator) else: self._generator = id_generator self._ids = {} if initial: for value in initial: self.add(value) def __contains__(self, item): """Checks whether `item` already has an ID or not.""" return item in self._ids def __getitem__(self, item): """Retrieves the ID corresponding to `item`. Generates a new ID for `item` if it is the first time we request an ID for it.""" try: return self._ids[item] except KeyError: self._ids[item] = next(self._generator) return self._ids[item] def __setitem__(self, item, value): """Overrides the ID for `item`.""" self._ids[item] = value def __len__(self): """"Returns the number of items""" return len(self._ids) def reverse_dict(self): """Returns the reverse mapping, i.e., the one that maps from generated IDs to their corresponding objects""" return dict((v, k) for k, v in self._ids.items()) def values(self): """Returns the values stored so far. If the generator generates items according to the standard sorting order, the values returned will be exactly in the order they were added. This holds for integer IDs for instance (but for many other ID generators as well).""" return sorted(list(self._ids.keys()), key=self._ids.__getitem__) add = __getitem__ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4111395 igraph-0.9.9/src/igraph/drawing/0000755000175100001710000000000000000000000017277 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/__init__.py0000644000175100001710000005067600000000000021426 0ustar00runnerdocker00000000000000""" Drawing and plotting routines for IGraph. Plotting is dependent on the C{pycairo} or C{cairocffi} libraries that provide Python bindings to the popular U{Cairo library}. This means that if you don't have U{pycairo} or U{cairocffi} installed, you won't be able to use the plotting capabilities. However, you can still use L{Graph.write_svg} to save the graph to an SVG file and view it from U{Mozilla Firefox} (free) or edit it in U{Inkscape} (free), U{Skencil} (formerly known as Sketch, also free) or Adobe Illustrator. Whenever the documentation refers to the C{pycairo} library, you can safely replace it with C{cairocffi} as the two are API-compatible. """ from warnings import warn import os import platform import time from io import BytesIO from igraph.configuration import Configuration from igraph.drawing.colors import Palette, palettes from igraph.drawing.graph import DefaultGraphDrawer, MatplotlibGraphDrawer from igraph.drawing.utils import ( BoundingBox, Point, Rectangle, find_cairo, find_matplotlib, ) from igraph.utils import _is_running_in_ipython, named_temporary_file __all__ = ("BoundingBox", "DefaultGraphDrawer", "Plot", "Point", "Rectangle", "plot") cairo = find_cairo() ##################################################################### class Plot: """Class representing an arbitrary plot Every plot has an associated surface object where the plotting is done. The surface is an instance of C{cairo.Surface}, a member of the C{pycairo} library. The surface itself provides a unified API to various plotting targets like SVG files, X11 windows, PostScript files, PNG files and so on. C{igraph} usually does not know on which surface it is plotting right now, since C{pycairo} takes care of the actual drawing. Everything that's supported by C{pycairo} should be supported by this class as well. Current Cairo surfaces include: - C{cairo.GlitzSurface} -- OpenGL accelerated surface for the X11 Window System. - C{cairo.ImageSurface} -- memory buffer surface. Can be written to a C{PNG} image file. - C{cairo.PDFSurface} -- PDF document surface. - C{cairo.PSSurface} -- PostScript document surface. - C{cairo.SVGSurface} -- SVG (Scalable Vector Graphics) document surface. - C{cairo.Win32Surface} -- Microsoft Windows screen rendering. - C{cairo.XlibSurface} -- X11 Window System screen rendering. If you create a C{Plot} object with a string given as the target surface, the string will be treated as a filename, and its extension will decide which surface class will be used. Please note that not all surfaces might be available, depending on your C{pycairo} installation. A C{Plot} has an assigned default palette (see L{igraph.drawing.colors.Palette}) which is used for plotting objects. A C{Plot} object also has a list of objects to be plotted with their respective bounding boxes, palettes and opacities. Palettes assigned to an object override the default palette of the plot. Objects can be added by the L{Plot.add} method and removed by the L{Plot.remove} method. """ def __init__(self, target=None, bbox=None, palette=None, background=None): """Creates a new plot. @param target: the target surface to write to. It can be one of the following types: - C{None} -- an appropriate surface will be created and the object will be plotted there. - C{cairo.Surface} -- the given Cairo surface will be used. - C{string} -- a file with the given name will be created and an appropriate Cairo surface will be attached to it. @param bbox: the bounding box of the surface. It is interpreted differently with different surfaces: PDF and PS surfaces will treat it as points (1 point = 1/72 inch). Image surfaces will treat it as pixels. SVG surfaces will treat it as an abstract unit, but it will mostly be interpreted as pixels when viewing the SVG file in Firefox. @param palette: the palette primarily used on the plot if the added objects do not specify a private palette. Must be either an L{igraph.drawing.colors.Palette} object or a string referring to a valid key of C{igraph.drawing.colors.palettes} (see module L{igraph.drawing.colors}) or C{None}. In the latter case, the default palette given by the configuration key C{plotting.palette} is used. @param background: the background color. If C{None}, the background will be transparent. You can use any color specification here that is understood by L{igraph.drawing.colors.color_name_to_rgba}. """ self._filename = None self._surface_was_created = not isinstance(target, cairo.Surface) self._need_tmpfile = False # Several Windows-specific hacks will be used from now on, thanks # to Dale Hunscher for debugging and fixing all that stuff self._windows_hacks = "Windows" in platform.platform() if bbox is None: self.bbox = BoundingBox(600, 600) elif isinstance(bbox, tuple) or isinstance(bbox, list): self.bbox = BoundingBox(bbox) else: self.bbox = bbox if palette is None: config = Configuration.instance() palette = config["plotting.palette"] if not isinstance(palette, Palette): palette = palettes[palette] self._palette = palette if target is None: self._need_tmpfile = True self._surface = cairo.ImageSurface( cairo.FORMAT_ARGB32, int(self.bbox.width), int(self.bbox.height) ) elif isinstance(target, cairo.Surface): self._surface = target else: self._filename = target _, ext = os.path.splitext(target) ext = ext.lower() if ext == ".pdf": self._surface = cairo.PDFSurface( target, self.bbox.width, self.bbox.height ) elif ext == ".ps" or ext == ".eps": self._surface = cairo.PSSurface( target, self.bbox.width, self.bbox.height ) elif ext == ".png": self._surface = cairo.ImageSurface( cairo.FORMAT_ARGB32, int(self.bbox.width), int(self.bbox.height) ) elif ext == ".svg": self._surface = cairo.SVGSurface( target, self.bbox.width, self.bbox.height ) else: raise ValueError("image format not handled by Cairo: %s" % ext) self._ctx = cairo.Context(self._surface) self._objects = [] self._is_dirty = False self.background = background def add(self, obj, bbox=None, palette=None, opacity=1.0, *args, **kwds): """Adds an object to the plot. Arguments not specified here are stored and passed to the object's plotting function when necessary. Since you are most likely interested in the arguments acceptable by graphs, see L{Graph.__plot__} for more details. @param obj: the object to be added @param bbox: the bounding box of the object. If C{None}, the object will fill the entire area of the plot. @param palette: the color palette used for drawing the object. If the object tries to get a color assigned to a positive integer, it will use this palette. If C{None}, defaults to the global palette of the plot. @param opacity: the opacity of the object being plotted, in the range 0.0-1.0 @see: Graph.__plot__ """ if opacity < 0.0 or opacity > 1.0: raise ValueError("opacity must be between 0.0 and 1.0") if bbox is None: bbox = self.bbox if not isinstance(bbox, BoundingBox): bbox = BoundingBox(bbox) self._objects.append((obj, bbox, palette, opacity, args, kwds)) self.mark_dirty() @property def background(self): """Returns the background color of the plot. C{None} means a transparent background. """ return self._background @background.setter def background(self, color): """Sets the background color of the plot. C{None} means a transparent background. You can use any color specification here that is understood by the C{get} method of the current palette or by L{igraph.drawing.colors.color_name_to_rgb}. """ if color is None: self._background = None else: self._background = self._palette.get(color) def remove(self, obj, bbox=None, idx=1): """Removes an object from the plot. If the object has been added multiple times and no bounding box was specified, it removes the instance which occurs M{idx}th in the list of identical instances of the object. @param obj: the object to be removed @param bbox: optional bounding box specification for the object. If given, only objects with exactly this bounding box will be considered. @param idx: if multiple objects match the specification given by M{obj} and M{bbox}, only the M{idx}th occurrence will be removed. @return: C{True} if the object has been removed successfully, C{False} if the object was not on the plot at all or M{idx} was larger than the count of occurrences """ for i in range(len(self._objects)): current_obj, current_bbox = self._objects[i][0:2] if current_obj is obj and (bbox is None or current_bbox == bbox): idx -= 1 if idx == 0: self._objects[i : (i + 1)] = [] self.mark_dirty() return True return False def mark_dirty(self): """Marks the plot as dirty (should be redrawn)""" self._is_dirty = True def redraw(self, context=None): """Redraws the plot""" ctx = context or self._ctx if self._background is not None: ctx.set_source_rgba(*self._background) ctx.rectangle(0, 0, self.bbox.width, self.bbox.height) ctx.fill() for obj, bbox, palette, opacity, args, kwds in self._objects: if palette is None: palette = getattr(obj, "_default_palette", self._palette) plotter = getattr(obj, "__plot__", None) if plotter is None: warn("%s does not support plotting" % (obj,)) else: if opacity < 1.0: ctx.push_group() else: ctx.save() plotter(ctx, bbox, palette, *args, **kwds) if opacity < 1.0: ctx.pop_group_to_source() ctx.paint_with_alpha(opacity) else: ctx.restore() self._is_dirty = False def save(self, fname=None): """Saves the plot. @param fname: the filename to save to. It is ignored if the surface of the plot is not an C{ImageSurface}. """ if self._is_dirty: self.redraw() if isinstance(self._surface, cairo.ImageSurface): if fname is None and self._need_tmpfile: with named_temporary_file(prefix="igraph", suffix=".png") as fname: self._surface.write_to_png(fname) return None fname = fname or self._filename if fname is None: raise ValueError( "no file name is known for the surface " + "and none given" ) return self._surface.write_to_png(fname) if fname is not None: warn("filename is ignored for surfaces other than ImageSurface") self._ctx.show_page() self._surface.finish() def show(self): """Saves the plot to a temporary file and shows it. This method is deprecated from igraph 0.9.1 and will be removed in version 0.10.0. @deprecated: Opening an image viewer with a temporary file never worked reliably across platforms. """ warn("Plot.show() is deprecated from igraph 0.9.1", DeprecationWarning) if not isinstance(self._surface, cairo.ImageSurface): sur = cairo.ImageSurface( cairo.FORMAT_ARGB32, int(self.bbox.width), int(self.bbox.height) ) ctx = cairo.Context(sur) self.redraw(ctx) else: sur = self._surface ctx = self._ctx if self._is_dirty: self.redraw(ctx) with named_temporary_file(prefix="igraph", suffix=".png") as tmpfile: sur.write_to_png(tmpfile) config = Configuration.instance() imgviewer = config["apps.image_viewer"] if not imgviewer: # No image viewer was given and none was detected. This # should only happen on unknown platforms. plat = platform.system() raise NotImplementedError( "showing plots is not implemented on this platform: %s" % plat ) else: os.system("%s %s" % (imgviewer, tmpfile)) if platform.system() == "Darwin" or self._windows_hacks: # On Mac OS X and Windows, launched applications are likely to # fork and give control back to Python immediately. # Chances are that the temporary image file gets removed # before the image viewer has a chance to open it, so # we wait here a little bit. Yes, this is quite hackish :( time.sleep(5) def _repr_svg_(self): """Returns an SVG representation of this plot as a string. This method is used by IPython to display this plot inline. """ io = BytesIO() # Create a new SVG surface and use that to get the SVG representation, # which will end up in io surface = cairo.SVGSurface(io, self.bbox.width, self.bbox.height) context = cairo.Context(surface) # Plot the graph on this context self.redraw(context) # No idea why this is needed but python crashes without context.show_page() surface.finish() # Return the raw SVG representation result = io.getvalue().decode("utf-8") return result, {"isolated": True} # put it inside an iframe @property def bounding_box(self): """Returns the bounding box of the Cairo surface as a L{BoundingBox} object""" return BoundingBox(self.bbox) @property def height(self): """Returns the height of the Cairo surface on which the plot is drawn""" return self.bbox.height @property def surface(self): """Returns the Cairo surface on which the plot is drawn""" return self._surface @property def width(self): """Returns the width of the Cairo surface on which the plot is drawn""" return self.bbox.width ##################################################################### def plot(obj, target=None, bbox=(0, 0, 600, 600), *args, **kwds): """Plots the given object to the given target. Positional and keyword arguments not explicitly mentioned here will be passed down to the C{__plot__} method of the object being plotted. Since you are most likely interested in the keyword arguments available for graph plots, see L{Graph.__plot__} as well. @param obj: the object to be plotted @param target: the target where the object should be plotted. It can be one of the following types: - C{matplotib.axes.Axes} -- a matplotlib/pyplot axes in which the graph will be plotted. Drawing is delegated to the chosen matplotlib backend, and you can use interactive backends and matplotlib functions to save to file as well. - C{string} -- a file with the given name will be created and an appropriate Cairo surface will be attached to it. The supported image formats are: PNG, PDF, SVG and PostScript. - C{cairo.Surface} -- the given Cairo surface will be used. This can refer to a PNG image, an arbitrary window, an SVG file, anything that Cairo can handle. - C{None} -- a temporary file will be created and the object will be plotted there. igraph will attempt to open an image viewer and show the temporary file. This feature is deprecated from igraph version 0.9.1 and will be removed in 0.10.0. @param bbox: the bounding box of the plot. It must be a tuple with either two or four integers, or a L{BoundingBox} object. If this is a tuple with two integers, it is interpreted as the width and height of the plot (in pixels for PNG images and on-screen plots, or in points for PDF, SVG and PostScript plots, where 72 pt = 1 inch = 2.54 cm). If this is a tuple with four integers, the first two denotes the X and Y coordinates of a corner and the latter two denoting the X and Y coordinates of the opposite corner. @keyword opacity: the opacity of the object being plotted. It can be used to overlap several plots of the same graph if you use the same layout for them -- for instance, you might plot a graph with opacity 0.5 and then plot its spanning tree over it with opacity 0.1. To achieve this, you'll need to modify the L{Plot} object returned with L{Plot.add}. @keyword palette: the palette primarily used on the plot if the added objects do not specify a private palette. Must be either an L{igraph.drawing.colors.Palette} object or a string referring to a valid key of C{igraph.drawing.colors.palettes} (see module L{igraph.drawing.colors}) or C{None}. In the latter case, the default palette given by the configuration key C{plotting.palette} is used. @keyword margin: the top, right, bottom, left margins as a 4-tuple. If it has less than 4 elements or is a single float, the elements will be re-used until the length is at least 4. The default margin is 20 on each side. @keyword inline: whether to try and show the plot object inline in the current IPython notebook. Passing C{None} here or omitting this keyword argument will look up the preferred behaviour from the C{shell.ipython.inlining.Plot} configuration key. Note that this keyword argument has an effect only if igraph is run inside IPython and C{target} is C{None}. @return: an appropriate L{Plot} object. @see: Graph.__plot__ """ _, plt = find_matplotlib() if hasattr(plt, "Axes") and isinstance(target, plt.Axes): result = MatplotlibGraphDrawer(ax=target) result.draw(obj, *args, **kwds) return if not isinstance(bbox, BoundingBox): bbox = BoundingBox(bbox) result = Plot(target, bbox, background=kwds.get("background", "white")) if "margin" in kwds: bbox = bbox.contract(kwds["margin"]) del kwds["margin"] else: bbox = bbox.contract(20) result.add(obj, bbox, *args, **kwds) if target is None and _is_running_in_ipython(): # Get the default value of the `inline` argument from the configuration if # needed inline = kwds.get("inline") if inline is None: config = Configuration.instance() inline = config["shell.ipython.inlining.Plot"] # If we requested an inline plot, just return the result and IPython will # call its _repr_svg_ method. If we requested a non-inline plot, show the # plot in a separate window and return nothing if inline: return result else: result.show() return # We are either not in IPython or the user specified an explicit plot target, # so just show or save the result if target is None: result.show() elif isinstance(target, str): result.save() # Also return the plot itself return result ##################################################################### ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/baseclasses.py0000644000175100001710000001172200000000000022144 0ustar00runnerdocker00000000000000""" Abstract base classes for the drawing routines. """ from igraph.drawing.utils import BoundingBox from math import pi ##################################################################### class AbstractDrawer: """Abstract class that serves as a base class for anything that draws an igraph object.""" def draw(self, *args, **kwds): """Abstract method, must be implemented in derived classes.""" raise NotImplementedError("abstract class") ##################################################################### class AbstractCairoDrawer(AbstractDrawer): """Abstract class that serves as a base class for anything that draws on a Cairo context within a given bounding box. A subclass of L{AbstractCairoDrawer} is guaranteed to have an attribute named C{context} that represents the Cairo context to draw on, and an attribute named C{bbox} for the L{BoundingBox} of the drawing area. """ def __init__(self, context, bbox): """Constructs the drawer and associates it to the given Cairo context and the given L{BoundingBox}. @param context: the context on which we will draw @param bbox: the bounding box within which we will draw. Can be anything accepted by the constructor of L{BoundingBox} (i.e., a 2-tuple, a 4-tuple or a L{BoundingBox} object). """ self.context = context self._bbox = None self.bbox = bbox @property def bbox(self): """The bounding box of the drawing area where this drawer will draw.""" return self._bbox @bbox.setter def bbox(self, bbox): """Sets the bounding box of the drawing area where this drawer will draw.""" if not isinstance(bbox, BoundingBox): self._bbox = BoundingBox(bbox) else: self._bbox = bbox def draw(self, *args, **kwds): """Abstract method, must be implemented in derived classes.""" raise NotImplementedError("abstract class") def _mark_point(self, x, y, color=0, size=4): """Marks the given point with a small circle on the canvas. Used primarily for debugging purposes. @param x: the X coordinate of the point to mark @param y: the Y coordinate of the point to mark @param color: the color of the marker. It can be a 3-tuple (RGB components, alpha=0.5), a 4-tuple (RGBA components) or an index where zero means red, 1 means green, 2 means blue and so on. @param size: the diameter of the marker. """ if isinstance(color, int): colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (0, 1, 1), (1, 0, 1)] color = colors[color % len(colors)] if len(color) == 3: color += (0.5,) ctx = self.context ctx.save() ctx.set_source_rgba(*color) ctx.arc(x, y, size / 2.0, 0, 2 * pi) ctx.fill() ctx.restore() ##################################################################### class AbstractXMLRPCDrawer(AbstractDrawer): """Abstract drawer that uses a remote service via XML-RPC to draw something on a remote display. """ def __init__(self, url, service=None): """Constructs an abstract drawer using the XML-RPC service at the given URL. @param url: the URL where the XML-RPC calls for the service should be addressed to. @param service: the name of the service at the XML-RPC address. If C{None}, requests will be directed to the server proxy object constructed by C{xmlrpclib.ServerProxy}; if not C{None}, the given attribute will be looked up in the server proxy object. """ import xmlrpc.client url = self._resolve_hostname(url) self.server = xmlrpc.client.ServerProxy(url) if service is None: self.service = self.server else: self.service = getattr(self.server, service) @staticmethod def _resolve_hostname(url): """Parses the given URL, resolves the hostname to an IP address and returns a new URL with the resolved IP address. This speeds up things big time on Mac OS X where an IP lookup would be performed for every XML-RPC call otherwise.""" from urllib.parse import urlparse, urlunparse import re url_parts = urlparse(url) hostname = url_parts.netloc if re.match("[0-9.:]+$", hostname): # the hostname is already an IP address, possibly with a port return url from socket import gethostbyname if ":" in hostname: hostname = hostname[0 : hostname.index(":")] hostname = gethostbyname(hostname) if url_parts.port is not None: hostname = "%s:%d" % (hostname, url_parts.port) url_parts = list(url_parts) url_parts[1] = hostname return urlunparse(url_parts) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/colors.py0000644000175100001710000026451500000000000021167 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Color handling functions. """ from igraph.datatypes import Matrix from igraph.utils import str_to_orientation from math import ceil __all__ = ( "Palette", "GradientPalette", "AdvancedGradientPalette", "RainbowPalette", "PrecalculatedPalette", "ClusterColoringPalette", "color_name_to_rgb", "color_name_to_rgba", "hsv_to_rgb", "hsva_to_rgba", "hsl_to_rgb", "hsla_to_rgba", "rgb_to_hsv", "rgba_to_hsva", "rgb_to_hsl", "rgba_to_hsla", "palettes", "known_colors", ) class Palette: """Base class of color palettes. Color palettes are mappings that assign integers from the range 0..M{n-1} to colors (4-tuples). M{n} is called the size or length of the palette. C{igraph} comes with a number of predefined palettes, so this class is useful for you only if you want to define your own palette. This can be done by subclassing this class and implementing the L{Palette._get} method as necessary. Palettes can also be used as lists or dicts, for the C{__getitem__} method is overridden properly to call L{Palette.get}. """ def __init__(self, n): self._length = n self._cache = {} def clear_cache(self): """Clears the result cache. The return values of L{Palette.get} are cached. Use this method to clear the cache. """ self._cache = {} def get(self, v): """Returns the given color from the palette. Values are cached: if the specific value given has already been looked up, its value will be returned from the cache instead of calculating it again. Use L{Palette.clear_cache} to clear the cache if necessary. @note: you shouldn't override this method in subclasses, override L{_get} instead. If you override this method, lookups in the L{known_colors} dict won't work, so you won't be able to refer to colors by names or RGBA quadruplets, only by integer indices. The caching functionality will disappear as well. However, feel free to override this method if this is exactly the behaviour you want. @param v: the color to be retrieved. If it is an integer, it is passed to L{Palette._get} to be translated to an RGBA quadruplet. Otherwise it is passed to L{color_name_to_rgb()} to determine the RGBA values. @return: the color as an RGBA quadruplet""" if isinstance(v, list): v = tuple(v) try: return self._cache[v] except KeyError: pass if isinstance(v, int): if v < 0: raise IndexError("color index must be non-negative") if v >= self._length: raise IndexError("color index too large") result = self._get(v) else: result = color_name_to_rgba(v) self._cache[v] = result return result def get_many(self, colors): """Returns multiple colors from the palette. Values are cached: if the specific value given has already been looked upon, its value will be returned from the cache instead of calculating it again. Use L{Palette.clear_cache} to clear the cache if necessary. @param colors: the list of colors to be retrieved. The palette class tries to make an educated guess here: if it is not possible to interpret the value you passed here as a list of colors, the class will simply try to interpret it as a single color by forwarding the value to L{Palette.get}. @return: the colors as a list of RGBA quadruplets. The result will be a list even if you passed a single color index or color name. """ if isinstance(colors, (str, int)): # Single color name or index return [self.get(colors)] # Multiple colors return [self.get(color) for color in colors] def _get(self, v): """Override this method in a subclass to create a custom palette. You can safely assume that v is an integer in the range 0..M{n-1} where M{n} is the size of the palette. @param v: numerical index of the color to be retrieved @return: a 4-tuple containing the RGBA values""" raise NotImplementedError("abstract class") __getitem__ = get @property def length(self): """Returns the number of colors in this palette""" return self._length def __len__(self): """Returns the number of colors in this palette""" return self._length def __plot__(self, context, bbox, palette, *args, **kwds): """Plots the colors of the palette on the given Cairo context Supported keyword arguments are: - C{border_width}: line width of the border shown around the palette. If zero or negative, the border is turned off. Default is C{1}. - C{grid_width}: line width of the grid that separates palette cells. If zero or negative, the grid is turned off. The grid is also turned off if the size of a cell is less than three times the given line width. Default is C{0}. Fractional widths are also allowed. - C{orientation}: the orientation of the palette. Must be one of the following values: C{left-right}, C{bottom-top}, C{right-left} or C{top-bottom}. Possible aliases: C{horizontal} = C{left-right}, C{vertical} = C{bottom-top}, C{lr} = C{left-right}, C{rl} = C{right-left}, C{tb} = C{top-bottom}, C{bt} = C{bottom-top}. The default is C{left-right}. """ border_width = float(kwds.get("border_width", 1.0)) grid_width = float(kwds.get("grid_width", 0.0)) orientation = str_to_orientation(kwds.get("orientation", "lr")) # Construct a matrix and plot that indices = list(range(len(self))) if orientation in ("rl", "bt"): indices.reverse() if orientation in ("lr", "rl"): matrix = Matrix([indices]) else: matrix = Matrix([[i] for i in indices]) return matrix.__plot__( context, bbox, self, style="palette", square=False, grid_width=grid_width, border_width=border_width, ) def __repr__(self): return "<%s with %d colors>" % (self.__class__.__name__, self._length) class GradientPalette(Palette): """Base class for gradient palettes Gradient palettes contain a gradient between two given colors. Example: >>> pal = GradientPalette("red", "blue", 5) >>> pal.get(0) (1.0, 0.0, 0.0, 1.0) >>> pal.get(2) (0.5, 0.0, 0.5, 1.0) >>> pal.get(4) (0.0, 0.0, 1.0, 1.0) """ def __init__(self, color1, color2, n=256): """Creates a gradient palette. @param color1: the color where the gradient starts. @param color2: the color where the gradient ends. @param n: the number of colors in the palette. """ Palette.__init__(self, n) self._color1 = color_name_to_rgba(color1) self._color2 = color_name_to_rgba(color2) def _get(self, v): """Returns the color corresponding to the given color index. @param v: numerical index of the color to be retrieved @return: a 4-tuple containing the RGBA values""" ratio = float(v) / (len(self) - 1) return tuple( self._color1[x] * (1 - ratio) + self._color2[x] * ratio for x in range(4) ) class AdvancedGradientPalette(Palette): """Advanced gradient that consists of more than two base colors. Example: >>> pal = AdvancedGradientPalette(["red", "black", "blue"], n=9) >>> pal.get(2) (0.5, 0.0, 0.0, 1.0) >>> pal.get(7) (0.0, 0.0, 0.75, 1.0) """ def __init__(self, colors, indices=None, n=256): """Creates an advanced gradient palette @param colors: the colors in the gradient. @param indices: the color indices belonging to the given colors. If C{None}, the colors are distributed equidistantly @param n: the total number of colors in the palette """ Palette.__init__(self, n) if indices is None: diff = float(n - 1) / (len(colors) - 1) indices = [i * diff for i in range(len(colors))] elif not hasattr(indices, "__iter__"): indices = [float(x) for x in indices] self._indices, self._colors = list(zip(*sorted(zip(indices, colors)))) self._colors = [color_name_to_rgba(color) for color in self._colors] self._dists = [ curr - prev for curr, prev in zip(self._indices[1:], self._indices) ] def _get(self, v): """Returns the color corresponding to the given color index. @param v: numerical index of the color to be retrieved @return: a 4-tuple containing the RGBA values""" colors = self._colors for i in range(len(self._indices) - 1): if self._indices[i] <= v and self._indices[i + 1] >= v: dist = self._dists[i] ratio = float(v - self._indices[i]) / dist return tuple( [ colors[i][x] * (1 - ratio) + colors[i + 1][x] * ratio for x in range(4) ] ) return (0.0, 0.0, 0.0, 1.0) class RainbowPalette(Palette): """A palette that varies the hue of the colors along a scale. Colors in a rainbow palette all have the same saturation, value and alpha components, while the hue is varied between two given extremes linearly. This palette has the advantage that it wraps around nicely if the hue is varied between zero and one (which is the default). Example: >>> pal = RainbowPalette(n=120) >>> pal.get(0) (1.0, 0.0, 0.0, 1.0) >>> pal.get(20) (1.0, 1.0, 0.0, 1.0) >>> pal.get(40) (0.0, 1.0, 0.0, 1.0) >>> pal = RainbowPalette(n=120, s=1, v=0.5, alpha=0.75) >>> pal.get(60) (0.0, 0.5, 0.5, 0.75) >>> pal.get(80) (0.0, 0.0, 0.5, 0.75) >>> pal.get(100) (0.5, 0.0, 0.5, 0.75) >>> pal = RainbowPalette(n=120) >>> pal2 = RainbowPalette(n=120, start=0.5, end=0.5) >>> pal.get(60) == pal2.get(0) True >>> pal.get(90) == pal2.get(30) True This palette was modeled after the C{rainbow} command of R. """ def __init__(self, n=256, s=1, v=1, start=0, end=1, alpha=1): """Creates a rainbow palette. @param n: the number of colors in the palette. @param s: the saturation of the colors in the palette. @param v: the value component of the colors in the palette. @param start: the hue at which the rainbow begins (between 0 and 1). @param end: the hue at which the rainbow ends (between 0 and 1). @param alpha: the alpha component of the colors in the palette. """ Palette.__init__(self, n) self._s = float(clamp(s, 0, 1)) self._v = float(clamp(v, 0, 1)) self._alpha = float(clamp(alpha, 0, 1)) self._start = float(start) if end == self._start: end += 1 self._dh = (end - self._start) / n def _get(self, v): """Returns the color corresponding to the given color index. @param v: numerical index of the color to be retrieved @return: a 4-tuple containing the RGBA values""" return hsva_to_rgba(self._start + v * self._dh, self._s, self._v, self._alpha) class PrecalculatedPalette(Palette): """A palette that returns colors from a pre-calculated list of colors""" def __init__(self, items): """Creates the palette backed by the given list. The list must contain RGBA quadruplets or color names, which will be resolved first by L{color_name_to_rgba()}. Anything that is understood by L{color_name_to_rgba()} is OK here.""" Palette.__init__(self, len(items)) for idx, color in enumerate(items): if isinstance(color, str): color = color_name_to_rgba(color) self._cache[idx] = color def _get(self, v): """This method will only be called if the requested color index is outside the size of the palette. In that case, we throw an exception""" raise ValueError("palette index outside bounds: %s" % v) class ClusterColoringPalette(PrecalculatedPalette): """A palette suitable for coloring vertices when plotting a clustering. This palette tries to make sure that the colors are easily distinguishable. This is achieved by using a set of base colors and their lighter and darker variants, depending on the number of elements in the palette. When the desired size of the palette is less than or equal to the number of base colors (denoted by M{n}), only the bsae colors will be used. When the size of the palette is larger than M{n} but less than M{2*n}, the base colors and their lighter variants will be used. Between M{2*n} and M{3*n}, the base colors and their lighter and darker variants will be used. Above M{3*n}, more darker and lighter variants will be generated, but this makes the individual colors less and less distinguishable. """ def __init__(self, n): base_colors = ["red", "green", "blue", "yellow", "magenta", "cyan", "#808080"] base_colors = [color_name_to_rgba(name) for name in base_colors] num_base_colors = len(base_colors) colors = base_colors[:] blocks_to_add = ceil(float(n - num_base_colors) / num_base_colors) ratio_increment = 1.0 / (ceil(blocks_to_add / 2.0) + 1) adding_darker = True ratio = ratio_increment while len(colors) < n: if adding_darker: new_block = [darken(color, ratio) for color in base_colors] else: new_block = [lighten(color, ratio) for color in base_colors] ratio += ratio_increment colors.extend(new_block) adding_darker = not adding_darker colors = colors[0:n] PrecalculatedPalette.__init__(self, colors) def clamp(value, min_value, max_value): """Clamps the given value between min and max""" if value > max_value: return max_value if value < min_value: return min_value return value def color_name_to_rgb(color, palette=None): """Converts a color given in one of the supported color formats to R-G-B values. This is done by calling L{color_name_to_rgba} and then throwing away the alpha value. @see: color_name_to_rgba for more details about what formats are understood by this function. """ return color_name_to_rgba(color, palette)[:3] def color_name_to_rgba(color, palette=None): """Converts a color given in one of the supported color formats to R-G-B-A values. Examples: >>> color_name_to_rgba("red") (1.0, 0.0, 0.0, 1.0) >>> color_name_to_rgba("#ff8000") == (1.0, 128/255.0, 0.0, 1.0) True >>> color_name_to_rgba("#ff800080") == (1.0, 128/255.0, 0.0, 128/255.0) True >>> color_name_to_rgba("#08f") == (0.0, 136/255.0, 1.0, 1.0) True >>> color_name_to_rgba("rgb(100%, 50%, 0%)") (1.0, 0.5, 0.0, 1.0) >>> color_name_to_rgba("rgba(100%, 50%, 0%, 25%)") (1.0, 0.5, 0.0, 0.25) >>> color_name_to_rgba("hsla(120, 100%, 50%, 0.5)") (0.0, 1.0, 0.0, 0.5) >>> color_name_to_rgba("hsl(60, 100%, 50%)") (1.0, 1.0, 0.0, 1.0) >>> color_name_to_rgba("hsv(60, 100%, 100%)") (1.0, 1.0, 0.0, 1.0) @param color: the color to be converted in one of the following formats: - B{CSS3 color specification}: C{#rrggbb}, C{#rgb}, C{#rrggbbaa}, C{#rgba}, C{rgb(red, green, blue)}, C{rgba(red, green, blue, alpha)}, C{hsl(hue, saturation, lightness)}, C{hsla(hue, saturation, lightness, alpha)}, C{hsv(hue, saturation, value)} and C{hsva(hue, saturation, value, alpha)} where the components are given as hexadecimal numbers in the first four cases and as decimals or percentages (0%-100%) in the remaining cases. Red, green and blue components are between 0 and 255; hue is between 0 and 360; saturation, lightness and value is between 0 and 100; alpha is between 0 and 1. - B{Valid HTML color names}, i.e. those that are present in the HTML 4.0 specification - B{Valid X11 color names}, see U{http://en.wikipedia.org/wiki/X11_color_names} - B{Red-green-blue components} given separately in either a comma-, slash- or whitespace-separated string or a list or a tuple, in the range of 0-255. An alpha value of 255 (maximal opacity) will be assumed. - B{Red-green-blue-alpha components} given separately in either a comma-, slash- or whitespace-separated string or a list or a tuple, in the range of 0-255 - B{A single palette index} given either as a string or a number. Uses the palette given in the C{palette} parameter of the method call. @param palette: the palette to be used if a single number is passed to the method. Must be an instance of L{colors.Palette}. @return: the RGBA values corresponding to the given color in a 4-tuple. Since these colors are primarily used by Cairo routines, the tuples contain floats in the range 0.0-1.0 """ if not isinstance(color, str): if hasattr(color, "__iter__"): components = list(color) else: # A single index is given as a number try: components = palette.get(color) except AttributeError: raise ValueError("palette index used when no palette was given") if len(components) < 4: components += [1.0] * (4 - len(components)) else: if color[0] == "#": color = color[1:] if len(color) == 3: components = [int(i, 16) * 17.0 / 255.0 for i in color] components.append(1.0) elif len(color) == 4: components = [int(i, 16) * 17.0 / 255.0 for i in color] elif len(color) == 6: components = [int(color[i : i + 2], 16) / 255.0 for i in (0, 2, 4)] components.append(1.0) elif len(color) == 8: components = [int(color[i : i + 2], 16) / 255.0 for i in (0, 2, 4, 6)] elif color.lower() in known_colors: components = known_colors[color.lower()] else: color_mode = "rgba" maximums = (255.0, 255.0, 255.0, 1.0) for mode in ["rgb(", "rgba(", "hsv(", "hsva(", "hsl(", "hsla("]: if color.startswith(mode) and color[-1] == ")": color = color[len(mode) : -1] color_mode = mode[:-1] if mode[0] == "h": maximums = (360.0, 100.0, 100.0, 1.0) break if " " in color or "/" in color or "," in color: color = color.replace(",", " ").replace("/", " ") components = color.split() for idx, comp in enumerate(components): if comp[-1] == "%": components[idx] = float(comp[:-1]) / 100.0 else: components[idx] = float(comp) / maximums[idx] if len(components) < 4: components += [1.0] * (4 - len(components)) if color_mode[:3] == "hsv": components = hsva_to_rgba(*components) elif color_mode[:3] == "hsl": components = hsla_to_rgba(*components) else: components = palette.get(int(color)) # At this point, the components are floats return tuple(clamp(val, 0.0, 1.0) for val in components) def color_to_html_format(color): """Formats a color given as a 3-tuple or 4-tuple in HTML format. The HTML format is simply given by C{#rrggbbaa}, where C{rr} gives the red component in hexadecimal format, C{gg} gives the green component C{bb} gives the blue component and C{gg} gives the alpha level. The alpha level is optional. """ color = [int(clamp(component * 256, 0, 255)) for component in color] if len(color) == 4: return "#{0:02X}{1:02X}{2:02X}{3:02X}".format(*color) return "#{0:02X}{1:02X}{2:02X}".format(*color) def darken(color, ratio=0.5): """Creates a darker version of a color given by an RGB triplet. This is done by mixing the original color with black using the given ratio. A ratio of 1.0 will yield a completely black color, a ratio of 0.0 will yield the original color. The alpha values are left intact. """ ratio = 1.0 - ratio red, green, blue, alpha = color return (red * ratio, green * ratio, blue * ratio, alpha) def hsla_to_rgba(h, s, l, alpha=1.0): # noqa: E741 """Converts a color given by its HSLA coordinates (hue, saturation, lightness, alpha) to RGBA coordinates. Each of the HSLA coordinates must be in the range [0, 1]. """ # This is based on the formulae found at: # http://en.wikipedia.org/wiki/HSL_and_HSV c = s * (1 - 2 * abs(l - 0.5)) h1 = (h * 6) % 6 x = c * (1 - abs(h1 % 2 - 1)) m = l - c / 2.0 h1 = int(h1) if h1 < 3: if h1 < 1: return (c + m, x + m, m, alpha) elif h1 < 2: return (x + m, c + m, m, alpha) else: return (m, c + m, x + m, alpha) else: if h1 < 4: return (m, x + m, c + m, alpha) elif h1 < 5: return (x + m, m, c + m, alpha) else: return (c + m, m, x + m, alpha) def hsl_to_rgb(h, s, l): # noqa: E741 """Converts a color given by its HSL coordinates (hue, saturation, lightness) to RGB coordinates. Each of the HSL coordinates must be in the range [0, 1]. """ return hsla_to_rgba(h, s, l)[:3] def hsva_to_rgba(h, s, v, alpha=1.0): """Converts a color given by its HSVA coordinates (hue, saturation, value, alpha) to RGB coordinates. Each of the HSVA coordinates must be in the range [0, 1]. """ # This is based on the formulae found at: # http://en.wikipedia.org/wiki/HSL_and_HSV c = v * s h1 = (h * 6) % 6 x = c * (1 - abs(h1 % 2 - 1)) m = v - c h1 = int(h1) if h1 < 3: if h1 < 1: return (c + m, x + m, m, alpha) elif h1 < 2: return (x + m, c + m, m, alpha) else: return (m, c + m, x + m, alpha) else: if h1 < 4: return (m, x + m, c + m, alpha) elif h1 < 5: return (x + m, m, c + m, alpha) else: return (c + m, m, x + m, alpha) def hsv_to_rgb(h, s, v): """Converts a color given by its HSV coordinates (hue, saturation, value) to RGB coordinates. Each of the HSV coordinates must be in the range [0, 1]. """ return hsva_to_rgba(h, s, v)[:3] def rgba_to_hsla(r, g, b, alpha=1.0): """Converts a color given by its RGBA coordinates to HSLA coordinates (hue, saturation, lightness, alpha). Each of the RGBA coordinates must be in the range [0, 1]. """ alpha = float(alpha) rgb_min, rgb_max = float(min(r, g, b)), float(max(r, g, b)) if rgb_min == rgb_max: return 0.0, 0.0, rgb_min, alpha lightness = (rgb_min + rgb_max) / 2.0 d = rgb_max - rgb_min if lightness > 0.5: sat = d / (2 - rgb_max - rgb_min) else: sat = d / (rgb_max + rgb_min) d *= 6.0 if rgb_max == r: hue = (g - b) / d if g < b: hue += 1 elif rgb_max == g: hue = 1 / 3.0 + (b - r) / d else: hue = 2 / 3.0 + (r - g) / d return hue, sat, lightness, alpha def rgba_to_hsva(r, g, b, alpha=1.0): """Converts a color given by its RGBA coordinates to HSVA coordinates (hue, saturation, value, alpha). Each of the RGBA coordinates must be in the range [0, 1]. """ # This is based on the formulae found at: # http://en.literateprograms.org/RGB_to_HSV_color_space_conversion_(C) rgb_min, rgb_max = float(min(r, g, b)), float(max(r, g, b)) alpha = float(alpha) value = float(rgb_max) if value <= 0: return 0.0, 0.0, 0.0, alpha sat = 1.0 - rgb_min / value if sat <= 0: return 0.0, 0.0, value, alpha d = rgb_max - rgb_min r = (r - rgb_min) / d g = (g - rgb_min) / d b = (b - rgb_min) / d rgb_max = max(r, g, b) if rgb_max == r: hue = 0.0 + (g - b) / 6.0 if hue < 0: hue += 1 elif rgb_max == g: hue = 1 / 3.0 + (b - r) / 6.0 else: hue = 2 / 3.0 + (r - g) / 6.0 return hue, sat, value, alpha def rgb_to_hsl(r, g, b): """Converts a color given by its RGB coordinates to HSL coordinates (hue, saturation, lightness). Each of the RGB coordinates must be in the range [0, 1]. """ return rgba_to_hsla(r, g, b)[:3] def rgb_to_hsv(r, g, b): """Converts a color given by its RGB coordinates to HSV coordinates (hue, saturation, value). Each of the RGB coordinates must be in the range [0, 1]. """ return rgba_to_hsva(r, g, b)[:3] def lighten(color, ratio=0.5): """Creates a lighter version of a color given by an RGB triplet. This is done by mixing the original color with white using the given ratio. A ratio of 1.0 will yield a completely white color, a ratio of 0.0 will yield the original color. """ red, green, blue, alpha = color return ( red + (1.0 - red) * ratio, green + (1.0 - green) * ratio, blue + (1.0 - blue) * ratio, alpha, ) known_colors = { "alice blue": (0.94117647058823528, 0.97254901960784312, 1.0, 1.0), "aliceblue": (0.94117647058823528, 0.97254901960784312, 1.0, 1.0), "antique white": ( 0.98039215686274506, 0.92156862745098034, 0.84313725490196079, 1.0, ), "antiquewhite": ( 0.98039215686274506, 0.92156862745098034, 0.84313725490196079, 1.0, ), "antiquewhite1": (1.0, 0.93725490196078431, 0.85882352941176465, 1.0), "antiquewhite2": ( 0.93333333333333335, 0.87450980392156863, 0.80000000000000004, 1.0, ), "antiquewhite3": ( 0.80392156862745101, 0.75294117647058822, 0.69019607843137254, 1.0, ), "antiquewhite4": ( 0.54509803921568623, 0.51372549019607838, 0.47058823529411764, 1.0, ), "aqua": (0.0, 1.0, 1.0, 1.0), "aquamarine": (0.49803921568627452, 1.0, 0.83137254901960789, 1.0), "aquamarine1": (0.49803921568627452, 1.0, 0.83137254901960789, 1.0), "aquamarine2": (0.46274509803921571, 0.93333333333333335, 0.77647058823529413, 1.0), "aquamarine3": (0.40000000000000002, 0.80392156862745101, 0.66666666666666663, 1.0), "aquamarine4": (0.27058823529411763, 0.54509803921568623, 0.45490196078431372, 1.0), "azure": (0.94117647058823528, 1.0, 1.0, 1.0), "azure1": (0.94117647058823528, 1.0, 1.0, 1.0), "azure2": (0.8784313725490196, 0.93333333333333335, 0.93333333333333335, 1.0), "azure3": (0.75686274509803919, 0.80392156862745101, 0.80392156862745101, 1.0), "azure4": (0.51372549019607838, 0.54509803921568623, 0.54509803921568623, 1.0), "beige": (0.96078431372549022, 0.96078431372549022, 0.86274509803921573, 1.0), "bisque": (1.0, 0.89411764705882357, 0.7686274509803922, 1.0), "bisque1": (1.0, 0.89411764705882357, 0.7686274509803922, 1.0), "bisque2": (0.93333333333333335, 0.83529411764705885, 0.71764705882352942, 1.0), "bisque3": (0.80392156862745101, 0.71764705882352942, 0.61960784313725492, 1.0), "bisque4": (0.54509803921568623, 0.49019607843137253, 0.41960784313725491, 1.0), "black": (0.0, 0.0, 0.0, 1.0), "blanched almond": (1.0, 0.92156862745098034, 0.80392156862745101, 1.0), "blanchedalmond": (1.0, 0.92156862745098034, 0.80392156862745101, 1.0), "blue": (0.0, 0.0, 1.0, 1.0), "blue violet": (0.54117647058823526, 0.16862745098039217, 0.88627450980392153, 1.0), "blue1": (0.0, 0.0, 1.0, 1.0), "blue2": (0.0, 0.0, 0.93333333333333335, 1.0), "blue3": (0.0, 0.0, 0.80392156862745101, 1.0), "blue4": (0.0, 0.0, 0.54509803921568623, 1.0), "blueviolet": (0.54117647058823526, 0.16862745098039217, 0.88627450980392153, 1.0), "brown": (0.6470588235294118, 0.16470588235294117, 0.16470588235294117, 1.0), "brown1": (1.0, 0.25098039215686274, 0.25098039215686274, 1.0), "brown2": (0.93333333333333335, 0.23137254901960785, 0.23137254901960785, 1.0), "brown3": (0.80392156862745101, 0.20000000000000001, 0.20000000000000001, 1.0), "brown4": (0.54509803921568623, 0.13725490196078433, 0.13725490196078433, 1.0), "burlywood": (0.87058823529411766, 0.72156862745098038, 0.52941176470588236, 1.0), "burlywood1": (1.0, 0.82745098039215681, 0.60784313725490191, 1.0), "burlywood2": (0.93333333333333335, 0.77254901960784317, 0.56862745098039214, 1.0), "burlywood3": (0.80392156862745101, 0.66666666666666663, 0.49019607843137253, 1.0), "burlywood4": (0.54509803921568623, 0.45098039215686275, 0.33333333333333331, 1.0), "cadet blue": (0.37254901960784315, 0.61960784313725492, 0.62745098039215685, 1.0), "cadetblue": (0.37254901960784315, 0.61960784313725492, 0.62745098039215685, 1.0), "cadetblue1": (0.59607843137254901, 0.96078431372549022, 1.0, 1.0), "cadetblue2": (0.55686274509803924, 0.89803921568627454, 0.93333333333333335, 1.0), "cadetblue3": (0.47843137254901963, 0.77254901960784317, 0.80392156862745101, 1.0), "cadetblue4": (0.32549019607843138, 0.52549019607843139, 0.54509803921568623, 1.0), "chartreuse": (0.49803921568627452, 1.0, 0.0, 1.0), "chartreuse1": (0.49803921568627452, 1.0, 0.0, 1.0), "chartreuse2": (0.46274509803921571, 0.93333333333333335, 0.0, 1.0), "chartreuse3": (0.40000000000000002, 0.80392156862745101, 0.0, 1.0), "chartreuse4": (0.27058823529411763, 0.54509803921568623, 0.0, 1.0), "chocolate": (0.82352941176470584, 0.41176470588235292, 0.11764705882352941, 1.0), "chocolate1": (1.0, 0.49803921568627452, 0.14117647058823529, 1.0), "chocolate2": (0.93333333333333335, 0.46274509803921571, 0.12941176470588237, 1.0), "chocolate3": (0.80392156862745101, 0.40000000000000002, 0.11372549019607843, 1.0), "chocolate4": (0.54509803921568623, 0.27058823529411763, 0.074509803921568626, 1.0), "coral": (1.0, 0.49803921568627452, 0.31372549019607843, 1.0), "coral1": (1.0, 0.44705882352941179, 0.33725490196078434, 1.0), "coral2": (0.93333333333333335, 0.41568627450980394, 0.31372549019607843, 1.0), "coral3": (0.80392156862745101, 0.35686274509803922, 0.27058823529411763, 1.0), "coral4": (0.54509803921568623, 0.24313725490196078, 0.18431372549019609, 1.0), "cornflower blue": ( 0.39215686274509803, 0.58431372549019611, 0.92941176470588238, 1.0, ), "cornflowerblue": ( 0.39215686274509803, 0.58431372549019611, 0.92941176470588238, 1.0, ), "cornsilk": (1.0, 0.97254901960784312, 0.86274509803921573, 1.0), "cornsilk1": (1.0, 0.97254901960784312, 0.86274509803921573, 1.0), "cornsilk2": (0.93333333333333335, 0.90980392156862744, 0.80392156862745101, 1.0), "cornsilk3": (0.80392156862745101, 0.78431372549019607, 0.69411764705882351, 1.0), "cornsilk4": (0.54509803921568623, 0.53333333333333333, 0.47058823529411764, 1.0), "crimson": (0.8627450980392157, 0.0784313725490196, 0.23529411764705882, 1.0), "cyan": (0.0, 1.0, 1.0, 1.0), "cyan1": (0.0, 1.0, 1.0, 1.0), "cyan2": (0.0, 0.93333333333333335, 0.93333333333333335, 1.0), "cyan3": (0.0, 0.80392156862745101, 0.80392156862745101, 1.0), "cyan4": (0.0, 0.54509803921568623, 0.54509803921568623, 1.0), "dark blue": (0.0, 0.0, 0.54509803921568623, 1.0), "dark cyan": (0.0, 0.54509803921568623, 0.54509803921568623, 1.0), "dark goldenrod": ( 0.72156862745098038, 0.52549019607843139, 0.043137254901960784, 1.0, ), "dark gray": (0.66274509803921566, 0.66274509803921566, 0.66274509803921566, 1.0), "dark green": (0.0, 0.39215686274509803, 0.0, 1.0), "dark grey": (0.66274509803921566, 0.66274509803921566, 0.66274509803921566, 1.0), "dark khaki": (0.74117647058823533, 0.71764705882352942, 0.41960784313725491, 1.0), "dark magenta": (0.54509803921568623, 0.0, 0.54509803921568623, 1.0), "dark olive green": ( 0.33333333333333331, 0.41960784313725491, 0.18431372549019609, 1.0, ), "dark orange": (1.0, 0.5490196078431373, 0.0, 1.0), "dark orchid": (0.59999999999999998, 0.19607843137254902, 0.80000000000000004, 1.0), "dark red": (0.54509803921568623, 0.0, 0.0, 1.0), "dark salmon": (0.9137254901960784, 0.58823529411764708, 0.47843137254901963, 1.0), "dark sea green": ( 0.5607843137254902, 0.73725490196078436, 0.5607843137254902, 1.0, ), "dark slate blue": ( 0.28235294117647058, 0.23921568627450981, 0.54509803921568623, 1.0, ), "dark slate gray": ( 0.18431372549019609, 0.30980392156862746, 0.30980392156862746, 1.0, ), "dark slate grey": ( 0.18431372549019609, 0.30980392156862746, 0.30980392156862746, 1.0, ), "dark turquoise": (0.0, 0.80784313725490198, 0.81960784313725488, 1.0), "dark violet": (0.58039215686274515, 0.0, 0.82745098039215681, 1.0), "darkblue": (0.0, 0.0, 0.54509803921568623, 1.0), "darkcyan": (0.0, 0.54509803921568623, 0.54509803921568623, 1.0), "darkgoldenrod": ( 0.72156862745098038, 0.52549019607843139, 0.043137254901960784, 1.0, ), "darkgoldenrod1": (1.0, 0.72549019607843135, 0.058823529411764705, 1.0), "darkgoldenrod2": ( 0.93333333333333335, 0.67843137254901964, 0.054901960784313725, 1.0, ), "darkgoldenrod3": ( 0.80392156862745101, 0.58431372549019611, 0.047058823529411764, 1.0, ), "darkgoldenrod4": ( 0.54509803921568623, 0.396078431372549, 0.031372549019607843, 1.0, ), "darkgray": (0.66274509803921566, 0.66274509803921566, 0.66274509803921566, 1.0), "darkgreen": (0.0, 0.39215686274509803, 0.0, 1.0), "darkgrey": (0.66274509803921566, 0.66274509803921566, 0.66274509803921566, 1.0), "darkkhaki": (0.74117647058823533, 0.71764705882352942, 0.41960784313725491, 1.0), "darkmagenta": (0.54509803921568623, 0.0, 0.54509803921568623, 1.0), "darkolivegreen": ( 0.33333333333333331, 0.41960784313725491, 0.18431372549019609, 1.0, ), "darkolivegreen1": (0.792156862745098, 1.0, 0.4392156862745098, 1.0), "darkolivegreen2": ( 0.73725490196078436, 0.93333333333333335, 0.40784313725490196, 1.0, ), "darkolivegreen3": ( 0.63529411764705879, 0.80392156862745101, 0.35294117647058826, 1.0, ), "darkolivegreen4": ( 0.43137254901960786, 0.54509803921568623, 0.23921568627450981, 1.0, ), "darkorange": (1.0, 0.5490196078431373, 0.0, 1.0), "darkorange1": (1.0, 0.49803921568627452, 0.0, 1.0), "darkorange2": (0.93333333333333335, 0.46274509803921571, 0.0, 1.0), "darkorange3": (0.80392156862745101, 0.40000000000000002, 0.0, 1.0), "darkorange4": (0.54509803921568623, 0.27058823529411763, 0.0, 1.0), "darkorchid": (0.59999999999999998, 0.19607843137254902, 0.80000000000000004, 1.0), "darkorchid1": (0.74901960784313726, 0.24313725490196078, 1.0, 1.0), "darkorchid2": (0.69803921568627447, 0.22745098039215686, 0.93333333333333335, 1.0), "darkorchid3": (0.60392156862745094, 0.19607843137254902, 0.80392156862745101, 1.0), "darkorchid4": (0.40784313725490196, 0.13333333333333333, 0.54509803921568623, 1.0), "darkred": (0.54509803921568623, 0.0, 0.0, 1.0), "darksalmon": (0.9137254901960784, 0.58823529411764708, 0.47843137254901963, 1.0), "darkseagreen": (0.5607843137254902, 0.73725490196078436, 0.5607843137254902, 1.0), "darkseagreen1": (0.75686274509803919, 1.0, 0.75686274509803919, 1.0), "darkseagreen2": ( 0.70588235294117652, 0.93333333333333335, 0.70588235294117652, 1.0, ), "darkseagreen3": ( 0.60784313725490191, 0.80392156862745101, 0.60784313725490191, 1.0, ), "darkseagreen4": ( 0.41176470588235292, 0.54509803921568623, 0.41176470588235292, 1.0, ), "darkslateblue": ( 0.28235294117647058, 0.23921568627450981, 0.54509803921568623, 1.0, ), "darkslategray": ( 0.18431372549019609, 0.30980392156862746, 0.30980392156862746, 1.0, ), "darkslategray1": (0.59215686274509804, 1.0, 1.0, 1.0), "darkslategray2": ( 0.55294117647058827, 0.93333333333333335, 0.93333333333333335, 1.0, ), "darkslategray3": ( 0.47450980392156861, 0.80392156862745101, 0.80392156862745101, 1.0, ), "darkslategray4": ( 0.32156862745098042, 0.54509803921568623, 0.54509803921568623, 1.0, ), "darkslategrey": ( 0.18431372549019609, 0.30980392156862746, 0.30980392156862746, 1.0, ), "darkturquoise": (0.0, 0.80784313725490198, 0.81960784313725488, 1.0), "darkviolet": (0.58039215686274515, 0.0, 0.82745098039215681, 1.0), "deep pink": (1.0, 0.078431372549019607, 0.57647058823529407, 1.0), "deep sky blue": (0.0, 0.74901960784313726, 1.0, 1.0), "deeppink": (1.0, 0.078431372549019607, 0.57647058823529407, 1.0), "deeppink1": (1.0, 0.078431372549019607, 0.57647058823529407, 1.0), "deeppink2": (0.93333333333333335, 0.070588235294117646, 0.53725490196078429, 1.0), "deeppink3": (0.80392156862745101, 0.062745098039215685, 0.46274509803921571, 1.0), "deeppink4": (0.54509803921568623, 0.039215686274509803, 0.31372549019607843, 1.0), "deepskyblue": (0.0, 0.74901960784313726, 1.0, 1.0), "deepskyblue1": (0.0, 0.74901960784313726, 1.0, 1.0), "deepskyblue2": (0.0, 0.69803921568627447, 0.93333333333333335, 1.0), "deepskyblue3": (0.0, 0.60392156862745094, 0.80392156862745101, 1.0), "deepskyblue4": (0.0, 0.40784313725490196, 0.54509803921568623, 1.0), "dim gray": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "dim grey": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "dimgray": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "dimgrey": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "dodger blue": (0.11764705882352941, 0.56470588235294117, 1.0, 1.0), "dodgerblue": (0.11764705882352941, 0.56470588235294117, 1.0, 1.0), "dodgerblue1": (0.11764705882352941, 0.56470588235294117, 1.0, 1.0), "dodgerblue2": (0.10980392156862745, 0.52549019607843139, 0.93333333333333335, 1.0), "dodgerblue3": ( 0.094117647058823528, 0.45490196078431372, 0.80392156862745101, 1.0, ), "dodgerblue4": ( 0.062745098039215685, 0.30588235294117649, 0.54509803921568623, 1.0, ), "firebrick": (0.69803921568627447, 0.13333333333333333, 0.13333333333333333, 1.0), "firebrick1": (1.0, 0.18823529411764706, 0.18823529411764706, 1.0), "firebrick2": (0.93333333333333335, 0.17254901960784313, 0.17254901960784313, 1.0), "firebrick3": (0.80392156862745101, 0.14901960784313725, 0.14901960784313725, 1.0), "firebrick4": (0.54509803921568623, 0.10196078431372549, 0.10196078431372549, 1.0), "floral white": (1.0, 0.98039215686274506, 0.94117647058823528, 1.0), "floralwhite": (1.0, 0.98039215686274506, 0.94117647058823528, 1.0), "forest green": ( 0.13333333333333333, 0.54509803921568623, 0.13333333333333333, 1.0, ), "forestgreen": (0.13333333333333333, 0.54509803921568623, 0.13333333333333333, 1.0), "fuchsia": (1.0, 0.0, 1.0, 1.0), "gainsboro": (0.86274509803921573, 0.86274509803921573, 0.86274509803921573, 1.0), "ghost white": (0.97254901960784312, 0.97254901960784312, 1.0, 1.0), "ghostwhite": (0.97254901960784312, 0.97254901960784312, 1.0, 1.0), "gold": (1.0, 0.84313725490196079, 0.0, 1.0), "gold1": (1.0, 0.84313725490196079, 0.0, 1.0), "gold2": (0.93333333333333335, 0.78823529411764703, 0.0, 1.0), "gold3": (0.80392156862745101, 0.67843137254901964, 0.0, 1.0), "gold4": (0.54509803921568623, 0.45882352941176469, 0.0, 1.0), "goldenrod": (0.85490196078431369, 0.6470588235294118, 0.12549019607843137, 1.0), "goldenrod1": (1.0, 0.75686274509803919, 0.14509803921568629, 1.0), "goldenrod2": (0.93333333333333335, 0.70588235294117652, 0.13333333333333333, 1.0), "goldenrod3": (0.80392156862745101, 0.60784313725490191, 0.11372549019607843, 1.0), "goldenrod4": (0.54509803921568623, 0.41176470588235292, 0.078431372549019607, 1.0), "gray": (0.74509803921568629, 0.74509803921568629, 0.74509803921568629, 1.0), "gray0": (0.0, 0.0, 0.0, 1.0), "gray1": (0.011764705882352941, 0.011764705882352941, 0.011764705882352941, 1.0), "gray10": (0.10196078431372549, 0.10196078431372549, 0.10196078431372549, 1.0), "gray100": (1.0, 1.0, 1.0, 1.0), "gray11": (0.10980392156862745, 0.10980392156862745, 0.10980392156862745, 1.0), "gray12": (0.12156862745098039, 0.12156862745098039, 0.12156862745098039, 1.0), "gray13": (0.12941176470588237, 0.12941176470588237, 0.12941176470588237, 1.0), "gray14": (0.14117647058823529, 0.14117647058823529, 0.14117647058823529, 1.0), "gray15": (0.14901960784313725, 0.14901960784313725, 0.14901960784313725, 1.0), "gray16": (0.16078431372549021, 0.16078431372549021, 0.16078431372549021, 1.0), "gray17": (0.16862745098039217, 0.16862745098039217, 0.16862745098039217, 1.0), "gray18": (0.1803921568627451, 0.1803921568627451, 0.1803921568627451, 1.0), "gray19": (0.18823529411764706, 0.18823529411764706, 0.18823529411764706, 1.0), "gray2": (0.019607843137254902, 0.019607843137254902, 0.019607843137254902, 1.0), "gray20": (0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 1.0), "gray21": (0.21176470588235294, 0.21176470588235294, 0.21176470588235294, 1.0), "gray22": (0.2196078431372549, 0.2196078431372549, 0.2196078431372549, 1.0), "gray23": (0.23137254901960785, 0.23137254901960785, 0.23137254901960785, 1.0), "gray24": (0.23921568627450981, 0.23921568627450981, 0.23921568627450981, 1.0), "gray25": (0.25098039215686274, 0.25098039215686274, 0.25098039215686274, 1.0), "gray26": (0.25882352941176473, 0.25882352941176473, 0.25882352941176473, 1.0), "gray27": (0.27058823529411763, 0.27058823529411763, 0.27058823529411763, 1.0), "gray28": (0.27843137254901962, 0.27843137254901962, 0.27843137254901962, 1.0), "gray29": (0.29019607843137257, 0.29019607843137257, 0.29019607843137257, 1.0), "gray3": (0.031372549019607843, 0.031372549019607843, 0.031372549019607843, 1.0), "gray30": (0.30196078431372547, 0.30196078431372547, 0.30196078431372547, 1.0), "gray31": (0.30980392156862746, 0.30980392156862746, 0.30980392156862746, 1.0), "gray32": (0.32156862745098042, 0.32156862745098042, 0.32156862745098042, 1.0), "gray33": (0.32941176470588235, 0.32941176470588235, 0.32941176470588235, 1.0), "gray34": (0.3411764705882353, 0.3411764705882353, 0.3411764705882353, 1.0), "gray35": (0.34901960784313724, 0.34901960784313724, 0.34901960784313724, 1.0), "gray36": (0.36078431372549019, 0.36078431372549019, 0.36078431372549019, 1.0), "gray37": (0.36862745098039218, 0.36862745098039218, 0.36862745098039218, 1.0), "gray38": (0.38039215686274508, 0.38039215686274508, 0.38039215686274508, 1.0), "gray39": (0.38823529411764707, 0.38823529411764707, 0.38823529411764707, 1.0), "gray4": (0.039215686274509803, 0.039215686274509803, 0.039215686274509803, 1.0), "gray40": (0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1.0), "gray41": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "gray42": (0.41960784313725491, 0.41960784313725491, 0.41960784313725491, 1.0), "gray43": (0.43137254901960786, 0.43137254901960786, 0.43137254901960786, 1.0), "gray44": (0.4392156862745098, 0.4392156862745098, 0.4392156862745098, 1.0), "gray45": (0.45098039215686275, 0.45098039215686275, 0.45098039215686275, 1.0), "gray46": (0.45882352941176469, 0.45882352941176469, 0.45882352941176469, 1.0), "gray47": (0.47058823529411764, 0.47058823529411764, 0.47058823529411764, 1.0), "gray48": (0.47843137254901963, 0.47843137254901963, 0.47843137254901963, 1.0), "gray49": (0.49019607843137253, 0.49019607843137253, 0.49019607843137253, 1.0), "gray5": (0.050980392156862744, 0.050980392156862744, 0.050980392156862744, 1.0), "gray50": (0.49803921568627452, 0.49803921568627452, 0.49803921568627452, 1.0), "gray51": (0.50980392156862742, 0.50980392156862742, 0.50980392156862742, 1.0), "gray52": (0.52156862745098043, 0.52156862745098043, 0.52156862745098043, 1.0), "gray53": (0.52941176470588236, 0.52941176470588236, 0.52941176470588236, 1.0), "gray54": (0.54117647058823526, 0.54117647058823526, 0.54117647058823526, 1.0), "gray55": (0.5490196078431373, 0.5490196078431373, 0.5490196078431373, 1.0), "gray56": (0.5607843137254902, 0.5607843137254902, 0.5607843137254902, 1.0), "gray57": (0.56862745098039214, 0.56862745098039214, 0.56862745098039214, 1.0), "gray58": (0.58039215686274515, 0.58039215686274515, 0.58039215686274515, 1.0), "gray59": (0.58823529411764708, 0.58823529411764708, 0.58823529411764708, 1.0), "gray6": (0.058823529411764705, 0.058823529411764705, 0.058823529411764705, 1.0), "gray60": (0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1.0), "gray61": (0.61176470588235299, 0.61176470588235299, 0.61176470588235299, 1.0), "gray62": (0.61960784313725492, 0.61960784313725492, 0.61960784313725492, 1.0), "gray63": (0.63137254901960782, 0.63137254901960782, 0.63137254901960782, 1.0), "gray64": (0.63921568627450975, 0.63921568627450975, 0.63921568627450975, 1.0), "gray65": (0.65098039215686276, 0.65098039215686276, 0.65098039215686276, 1.0), "gray66": (0.6588235294117647, 0.6588235294117647, 0.6588235294117647, 1.0), "gray67": (0.6705882352941176, 0.6705882352941176, 0.6705882352941176, 1.0), "gray68": (0.67843137254901964, 0.67843137254901964, 0.67843137254901964, 1.0), "gray69": (0.69019607843137254, 0.69019607843137254, 0.69019607843137254, 1.0), "gray7": (0.070588235294117646, 0.070588235294117646, 0.070588235294117646, 1.0), "gray70": (0.70196078431372544, 0.70196078431372544, 0.70196078431372544, 1.0), "gray71": (0.70980392156862748, 0.70980392156862748, 0.70980392156862748, 1.0), "gray72": (0.72156862745098038, 0.72156862745098038, 0.72156862745098038, 1.0), "gray73": (0.72941176470588232, 0.72941176470588232, 0.72941176470588232, 1.0), "gray74": (0.74117647058823533, 0.74117647058823533, 0.74117647058823533, 1.0), "gray75": (0.74901960784313726, 0.74901960784313726, 0.74901960784313726, 1.0), "gray76": (0.76078431372549016, 0.76078431372549016, 0.76078431372549016, 1.0), "gray77": (0.7686274509803922, 0.7686274509803922, 0.7686274509803922, 1.0), "gray78": (0.7803921568627451, 0.7803921568627451, 0.7803921568627451, 1.0), "gray79": (0.78823529411764703, 0.78823529411764703, 0.78823529411764703, 1.0), "gray8": (0.078431372549019607, 0.078431372549019607, 0.078431372549019607, 1.0), "gray80": (0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 1.0), "gray81": (0.81176470588235294, 0.81176470588235294, 0.81176470588235294, 1.0), "gray82": (0.81960784313725488, 0.81960784313725488, 0.81960784313725488, 1.0), "gray83": (0.83137254901960789, 0.83137254901960789, 0.83137254901960789, 1.0), "gray84": (0.83921568627450982, 0.83921568627450982, 0.83921568627450982, 1.0), "gray85": (0.85098039215686272, 0.85098039215686272, 0.85098039215686272, 1.0), "gray86": (0.85882352941176465, 0.85882352941176465, 0.85882352941176465, 1.0), "gray87": (0.87058823529411766, 0.87058823529411766, 0.87058823529411766, 1.0), "gray88": (0.8784313725490196, 0.8784313725490196, 0.8784313725490196, 1.0), "gray89": (0.8901960784313725, 0.8901960784313725, 0.8901960784313725, 1.0), "gray9": (0.090196078431372548, 0.090196078431372548, 0.090196078431372548, 1.0), "gray90": (0.89803921568627454, 0.89803921568627454, 0.89803921568627454, 1.0), "gray91": (0.90980392156862744, 0.90980392156862744, 0.90980392156862744, 1.0), "gray92": (0.92156862745098034, 0.92156862745098034, 0.92156862745098034, 1.0), "gray93": (0.92941176470588238, 0.92941176470588238, 0.92941176470588238, 1.0), "gray94": (0.94117647058823528, 0.94117647058823528, 0.94117647058823528, 1.0), "gray95": (0.94901960784313721, 0.94901960784313721, 0.94901960784313721, 1.0), "gray96": (0.96078431372549022, 0.96078431372549022, 0.96078431372549022, 1.0), "gray97": (0.96862745098039216, 0.96862745098039216, 0.96862745098039216, 1.0), "gray98": (0.98039215686274506, 0.98039215686274506, 0.98039215686274506, 1.0), "gray99": (0.9882352941176471, 0.9882352941176471, 0.9882352941176471, 1.0), "green": (0.0, 1.0, 0.0, 1.0), "green yellow": (0.67843137254901964, 1.0, 0.18431372549019609, 1.0), "green1": (0.0, 1.0, 0.0, 1.0), "green2": (0.0, 0.93333333333333335, 0.0, 1.0), "green3": (0.0, 0.80392156862745101, 0.0, 1.0), "green4": (0.0, 0.54509803921568623, 0.0, 1.0), "greenyellow": (0.67843137254901964, 1.0, 0.18431372549019609, 1.0), "grey": (0.74509803921568629, 0.74509803921568629, 0.74509803921568629, 1.0), "grey0": (0.0, 0.0, 0.0, 1.0), "grey1": (0.011764705882352941, 0.011764705882352941, 0.011764705882352941, 1.0), "grey10": (0.10196078431372549, 0.10196078431372549, 0.10196078431372549, 1.0), "grey100": (1.0, 1.0, 1.0, 1.0), "grey11": (0.10980392156862745, 0.10980392156862745, 0.10980392156862745, 1.0), "grey12": (0.12156862745098039, 0.12156862745098039, 0.12156862745098039, 1.0), "grey13": (0.12941176470588237, 0.12941176470588237, 0.12941176470588237, 1.0), "grey14": (0.14117647058823529, 0.14117647058823529, 0.14117647058823529, 1.0), "grey15": (0.14901960784313725, 0.14901960784313725, 0.14901960784313725, 1.0), "grey16": (0.16078431372549021, 0.16078431372549021, 0.16078431372549021, 1.0), "grey17": (0.16862745098039217, 0.16862745098039217, 0.16862745098039217, 1.0), "grey18": (0.1803921568627451, 0.1803921568627451, 0.1803921568627451, 1.0), "grey19": (0.18823529411764706, 0.18823529411764706, 0.18823529411764706, 1.0), "grey2": (0.019607843137254902, 0.019607843137254902, 0.019607843137254902, 1.0), "grey20": (0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 1.0), "grey21": (0.21176470588235294, 0.21176470588235294, 0.21176470588235294, 1.0), "grey22": (0.2196078431372549, 0.2196078431372549, 0.2196078431372549, 1.0), "grey23": (0.23137254901960785, 0.23137254901960785, 0.23137254901960785, 1.0), "grey24": (0.23921568627450981, 0.23921568627450981, 0.23921568627450981, 1.0), "grey25": (0.25098039215686274, 0.25098039215686274, 0.25098039215686274, 1.0), "grey26": (0.25882352941176473, 0.25882352941176473, 0.25882352941176473, 1.0), "grey27": (0.27058823529411763, 0.27058823529411763, 0.27058823529411763, 1.0), "grey28": (0.27843137254901962, 0.27843137254901962, 0.27843137254901962, 1.0), "grey29": (0.29019607843137257, 0.29019607843137257, 0.29019607843137257, 1.0), "grey3": (0.031372549019607843, 0.031372549019607843, 0.031372549019607843, 1.0), "grey30": (0.30196078431372547, 0.30196078431372547, 0.30196078431372547, 1.0), "grey31": (0.30980392156862746, 0.30980392156862746, 0.30980392156862746, 1.0), "grey32": (0.32156862745098042, 0.32156862745098042, 0.32156862745098042, 1.0), "grey33": (0.32941176470588235, 0.32941176470588235, 0.32941176470588235, 1.0), "grey34": (0.3411764705882353, 0.3411764705882353, 0.3411764705882353, 1.0), "grey35": (0.34901960784313724, 0.34901960784313724, 0.34901960784313724, 1.0), "grey36": (0.36078431372549019, 0.36078431372549019, 0.36078431372549019, 1.0), "grey37": (0.36862745098039218, 0.36862745098039218, 0.36862745098039218, 1.0), "grey38": (0.38039215686274508, 0.38039215686274508, 0.38039215686274508, 1.0), "grey39": (0.38823529411764707, 0.38823529411764707, 0.38823529411764707, 1.0), "grey4": (0.039215686274509803, 0.039215686274509803, 0.039215686274509803, 1.0), "grey40": (0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1.0), "grey41": (0.41176470588235292, 0.41176470588235292, 0.41176470588235292, 1.0), "grey42": (0.41960784313725491, 0.41960784313725491, 0.41960784313725491, 1.0), "grey43": (0.43137254901960786, 0.43137254901960786, 0.43137254901960786, 1.0), "grey44": (0.4392156862745098, 0.4392156862745098, 0.4392156862745098, 1.0), "grey45": (0.45098039215686275, 0.45098039215686275, 0.45098039215686275, 1.0), "grey46": (0.45882352941176469, 0.45882352941176469, 0.45882352941176469, 1.0), "grey47": (0.47058823529411764, 0.47058823529411764, 0.47058823529411764, 1.0), "grey48": (0.47843137254901963, 0.47843137254901963, 0.47843137254901963, 1.0), "grey49": (0.49019607843137253, 0.49019607843137253, 0.49019607843137253, 1.0), "grey5": (0.050980392156862744, 0.050980392156862744, 0.050980392156862744, 1.0), "grey50": (0.49803921568627452, 0.49803921568627452, 0.49803921568627452, 1.0), "grey51": (0.50980392156862742, 0.50980392156862742, 0.50980392156862742, 1.0), "grey52": (0.52156862745098043, 0.52156862745098043, 0.52156862745098043, 1.0), "grey53": (0.52941176470588236, 0.52941176470588236, 0.52941176470588236, 1.0), "grey54": (0.54117647058823526, 0.54117647058823526, 0.54117647058823526, 1.0), "grey55": (0.5490196078431373, 0.5490196078431373, 0.5490196078431373, 1.0), "grey56": (0.5607843137254902, 0.5607843137254902, 0.5607843137254902, 1.0), "grey57": (0.56862745098039214, 0.56862745098039214, 0.56862745098039214, 1.0), "grey58": (0.58039215686274515, 0.58039215686274515, 0.58039215686274515, 1.0), "grey59": (0.58823529411764708, 0.58823529411764708, 0.58823529411764708, 1.0), "grey6": (0.058823529411764705, 0.058823529411764705, 0.058823529411764705, 1.0), "grey60": (0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1.0), "grey61": (0.61176470588235299, 0.61176470588235299, 0.61176470588235299, 1.0), "grey62": (0.61960784313725492, 0.61960784313725492, 0.61960784313725492, 1.0), "grey63": (0.63137254901960782, 0.63137254901960782, 0.63137254901960782, 1.0), "grey64": (0.63921568627450975, 0.63921568627450975, 0.63921568627450975, 1.0), "grey65": (0.65098039215686276, 0.65098039215686276, 0.65098039215686276, 1.0), "grey66": (0.6588235294117647, 0.6588235294117647, 0.6588235294117647, 1.0), "grey67": (0.6705882352941176, 0.6705882352941176, 0.6705882352941176, 1.0), "grey68": (0.67843137254901964, 0.67843137254901964, 0.67843137254901964, 1.0), "grey69": (0.69019607843137254, 0.69019607843137254, 0.69019607843137254, 1.0), "grey7": (0.070588235294117646, 0.070588235294117646, 0.070588235294117646, 1.0), "grey70": (0.70196078431372544, 0.70196078431372544, 0.70196078431372544, 1.0), "grey71": (0.70980392156862748, 0.70980392156862748, 0.70980392156862748, 1.0), "grey72": (0.72156862745098038, 0.72156862745098038, 0.72156862745098038, 1.0), "grey73": (0.72941176470588232, 0.72941176470588232, 0.72941176470588232, 1.0), "grey74": (0.74117647058823533, 0.74117647058823533, 0.74117647058823533, 1.0), "grey75": (0.74901960784313726, 0.74901960784313726, 0.74901960784313726, 1.0), "grey76": (0.76078431372549016, 0.76078431372549016, 0.76078431372549016, 1.0), "grey77": (0.7686274509803922, 0.7686274509803922, 0.7686274509803922, 1.0), "grey78": (0.7803921568627451, 0.7803921568627451, 0.7803921568627451, 1.0), "grey79": (0.78823529411764703, 0.78823529411764703, 0.78823529411764703, 1.0), "grey8": (0.078431372549019607, 0.078431372549019607, 0.078431372549019607, 1.0), "grey80": (0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 1.0), "grey81": (0.81176470588235294, 0.81176470588235294, 0.81176470588235294, 1.0), "grey82": (0.81960784313725488, 0.81960784313725488, 0.81960784313725488, 1.0), "grey83": (0.83137254901960789, 0.83137254901960789, 0.83137254901960789, 1.0), "grey84": (0.83921568627450982, 0.83921568627450982, 0.83921568627450982, 1.0), "grey85": (0.85098039215686272, 0.85098039215686272, 0.85098039215686272, 1.0), "grey86": (0.85882352941176465, 0.85882352941176465, 0.85882352941176465, 1.0), "grey87": (0.87058823529411766, 0.87058823529411766, 0.87058823529411766, 1.0), "grey88": (0.8784313725490196, 0.8784313725490196, 0.8784313725490196, 1.0), "grey89": (0.8901960784313725, 0.8901960784313725, 0.8901960784313725, 1.0), "grey9": (0.090196078431372548, 0.090196078431372548, 0.090196078431372548, 1.0), "grey90": (0.89803921568627454, 0.89803921568627454, 0.89803921568627454, 1.0), "grey91": (0.90980392156862744, 0.90980392156862744, 0.90980392156862744, 1.0), "grey92": (0.92156862745098034, 0.92156862745098034, 0.92156862745098034, 1.0), "grey93": (0.92941176470588238, 0.92941176470588238, 0.92941176470588238, 1.0), "grey94": (0.94117647058823528, 0.94117647058823528, 0.94117647058823528, 1.0), "grey95": (0.94901960784313721, 0.94901960784313721, 0.94901960784313721, 1.0), "grey96": (0.96078431372549022, 0.96078431372549022, 0.96078431372549022, 1.0), "grey97": (0.96862745098039216, 0.96862745098039216, 0.96862745098039216, 1.0), "grey98": (0.98039215686274506, 0.98039215686274506, 0.98039215686274506, 1.0), "grey99": (0.9882352941176471, 0.9882352941176471, 0.9882352941176471, 1.0), "honeydew": (0.94117647058823528, 1.0, 0.94117647058823528, 1.0), "honeydew1": (0.94117647058823528, 1.0, 0.94117647058823528, 1.0), "honeydew2": (0.8784313725490196, 0.93333333333333335, 0.8784313725490196, 1.0), "honeydew3": (0.75686274509803919, 0.80392156862745101, 0.75686274509803919, 1.0), "honeydew4": (0.51372549019607838, 0.54509803921568623, 0.51372549019607838, 1.0), "hot pink": (1.0, 0.41176470588235292, 0.70588235294117652, 1.0), "hotpink": (1.0, 0.41176470588235292, 0.70588235294117652, 1.0), "hotpink1": (1.0, 0.43137254901960786, 0.70588235294117652, 1.0), "hotpink2": (0.93333333333333335, 0.41568627450980394, 0.65490196078431373, 1.0), "hotpink3": (0.80392156862745101, 0.37647058823529411, 0.56470588235294117, 1.0), "hotpink4": (0.54509803921568623, 0.22745098039215686, 0.3843137254901961, 1.0), "indian red": (0.80392156862745101, 0.36078431372549019, 0.36078431372549019, 1.0), "indianred": (0.80392156862745101, 0.36078431372549019, 0.36078431372549019, 1.0), "indianred1": (1.0, 0.41568627450980394, 0.41568627450980394, 1.0), "indianred2": (0.93333333333333335, 0.38823529411764707, 0.38823529411764707, 1.0), "indianred3": (0.80392156862745101, 0.33333333333333331, 0.33333333333333331, 1.0), "indianred4": (0.54509803921568623, 0.22745098039215686, 0.22745098039215686, 1.0), "indigo": (0.29411764705882354, 0.0, 0.5098039215686274, 1.0), "ivory": (1.0, 1.0, 0.94117647058823528, 1.0), "ivory1": (1.0, 1.0, 0.94117647058823528, 1.0), "ivory2": (0.93333333333333335, 0.93333333333333335, 0.8784313725490196, 1.0), "ivory3": (0.80392156862745101, 0.80392156862745101, 0.75686274509803919, 1.0), "ivory4": (0.54509803921568623, 0.54509803921568623, 0.51372549019607838, 1.0), "khaki": (0.94117647058823528, 0.90196078431372551, 0.5490196078431373, 1.0), "khaki1": (1.0, 0.96470588235294119, 0.5607843137254902, 1.0), "khaki2": (0.93333333333333335, 0.90196078431372551, 0.52156862745098043, 1.0), "khaki3": (0.80392156862745101, 0.77647058823529413, 0.45098039215686275, 1.0), "khaki4": (0.54509803921568623, 0.52549019607843139, 0.30588235294117649, 1.0), "lavender": (0.90196078431372551, 0.90196078431372551, 0.98039215686274506, 1.0), "lavender blush": (1.0, 0.94117647058823528, 0.96078431372549022, 1.0), "lavenderblush": (1.0, 0.94117647058823528, 0.96078431372549022, 1.0), "lavenderblush1": (1.0, 0.94117647058823528, 0.96078431372549022, 1.0), "lavenderblush2": ( 0.93333333333333335, 0.8784313725490196, 0.89803921568627454, 1.0, ), "lavenderblush3": ( 0.80392156862745101, 0.75686274509803919, 0.77254901960784317, 1.0, ), "lavenderblush4": ( 0.54509803921568623, 0.51372549019607838, 0.52549019607843139, 1.0, ), "lawn green": (0.48627450980392156, 0.9882352941176471, 0.0, 1.0), "lawngreen": (0.48627450980392156, 0.9882352941176471, 0.0, 1.0), "lemon chiffon": (1.0, 0.98039215686274506, 0.80392156862745101, 1.0), "lemonchiffon": (1.0, 0.98039215686274506, 0.80392156862745101, 1.0), "lemonchiffon1": (1.0, 0.98039215686274506, 0.80392156862745101, 1.0), "lemonchiffon2": ( 0.93333333333333335, 0.9137254901960784, 0.74901960784313726, 1.0, ), "lemonchiffon3": ( 0.80392156862745101, 0.78823529411764703, 0.6470588235294118, 1.0, ), "lemonchiffon4": ( 0.54509803921568623, 0.53725490196078429, 0.4392156862745098, 1.0, ), "light blue": (0.67843137254901964, 0.84705882352941175, 0.90196078431372551, 1.0), "light coral": (0.94117647058823528, 0.50196078431372548, 0.50196078431372548, 1.0), "light cyan": (0.8784313725490196, 1.0, 1.0, 1.0), "light goldenrod": ( 0.93333333333333335, 0.8666666666666667, 0.50980392156862742, 1.0, ), "light goldenrod yellow": ( 0.98039215686274506, 0.98039215686274506, 0.82352941176470584, 1.0, ), "light gray": (0.82745098039215681, 0.82745098039215681, 0.82745098039215681, 1.0), "light green": (0.56470588235294117, 0.93333333333333335, 0.56470588235294117, 1.0), "light grey": (0.82745098039215681, 0.82745098039215681, 0.82745098039215681, 1.0), "light pink": (1.0, 0.71372549019607845, 0.75686274509803919, 1.0), "light salmon": (1.0, 0.62745098039215685, 0.47843137254901963, 1.0), "light sea green": ( 0.12549019607843137, 0.69803921568627447, 0.66666666666666663, 1.0, ), "light sky blue": ( 0.52941176470588236, 0.80784313725490198, 0.98039215686274506, 1.0, ), "light slate blue": (0.51764705882352946, 0.4392156862745098, 1.0, 1.0), "light slate gray": ( 0.46666666666666667, 0.53333333333333333, 0.59999999999999998, 1.0, ), "light slate grey": ( 0.46666666666666667, 0.53333333333333333, 0.59999999999999998, 1.0, ), "light steel blue": ( 0.69019607843137254, 0.7686274509803922, 0.87058823529411766, 1.0, ), "light yellow": (1.0, 1.0, 0.8784313725490196, 1.0), "lightblue": (0.67843137254901964, 0.84705882352941175, 0.90196078431372551, 1.0), "lightblue1": (0.74901960784313726, 0.93725490196078431, 1.0, 1.0), "lightblue2": (0.69803921568627447, 0.87450980392156863, 0.93333333333333335, 1.0), "lightblue3": (0.60392156862745094, 0.75294117647058822, 0.80392156862745101, 1.0), "lightblue4": (0.40784313725490196, 0.51372549019607838, 0.54509803921568623, 1.0), "lightcoral": (0.94117647058823528, 0.50196078431372548, 0.50196078431372548, 1.0), "lightcyan": (0.8784313725490196, 1.0, 1.0, 1.0), "lightcyan1": (0.8784313725490196, 1.0, 1.0, 1.0), "lightcyan2": (0.81960784313725488, 0.93333333333333335, 0.93333333333333335, 1.0), "lightcyan3": (0.70588235294117652, 0.80392156862745101, 0.80392156862745101, 1.0), "lightcyan4": (0.47843137254901963, 0.54509803921568623, 0.54509803921568623, 1.0), "lightgoldenrod": ( 0.93333333333333335, 0.8666666666666667, 0.50980392156862742, 1.0, ), "lightgoldenrod1": (1.0, 0.92549019607843142, 0.54509803921568623, 1.0), "lightgoldenrod2": ( 0.93333333333333335, 0.86274509803921573, 0.50980392156862742, 1.0, ), "lightgoldenrod3": ( 0.80392156862745101, 0.74509803921568629, 0.4392156862745098, 1.0, ), "lightgoldenrod4": ( 0.54509803921568623, 0.50588235294117645, 0.29803921568627451, 1.0, ), "lightgoldenrodyellow": ( 0.98039215686274506, 0.98039215686274506, 0.82352941176470584, 1.0, ), "lightgray": (0.82745098039215681, 0.82745098039215681, 0.82745098039215681, 1.0), "lightgreen": (0.56470588235294117, 0.93333333333333335, 0.56470588235294117, 1.0), "lightgrey": (0.82745098039215681, 0.82745098039215681, 0.82745098039215681, 1.0), "lightpink": (1.0, 0.71372549019607845, 0.75686274509803919, 1.0), "lightpink1": (1.0, 0.68235294117647061, 0.72549019607843135, 1.0), "lightpink2": (0.93333333333333335, 0.63529411764705879, 0.67843137254901964, 1.0), "lightpink3": (0.80392156862745101, 0.5490196078431373, 0.58431372549019611, 1.0), "lightpink4": (0.54509803921568623, 0.37254901960784315, 0.396078431372549, 1.0), "lightsalmon": (1.0, 0.62745098039215685, 0.47843137254901963, 1.0), "lightsalmon1": (1.0, 0.62745098039215685, 0.47843137254901963, 1.0), "lightsalmon2": ( 0.93333333333333335, 0.58431372549019611, 0.44705882352941179, 1.0, ), "lightsalmon3": (0.80392156862745101, 0.50588235294117645, 0.3843137254901961, 1.0), "lightsalmon4": (0.54509803921568623, 0.3411764705882353, 0.25882352941176473, 1.0), "lightseagreen": ( 0.12549019607843137, 0.69803921568627447, 0.66666666666666663, 1.0, ), "lightskyblue": ( 0.52941176470588236, 0.80784313725490198, 0.98039215686274506, 1.0, ), "lightskyblue1": (0.69019607843137254, 0.88627450980392153, 1.0, 1.0), "lightskyblue2": ( 0.64313725490196083, 0.82745098039215681, 0.93333333333333335, 1.0, ), "lightskyblue3": ( 0.55294117647058827, 0.71372549019607845, 0.80392156862745101, 1.0, ), "lightskyblue4": ( 0.37647058823529411, 0.4823529411764706, 0.54509803921568623, 1.0, ), "lightslateblue": (0.51764705882352946, 0.4392156862745098, 1.0, 1.0), "lightslategray": ( 0.46666666666666667, 0.53333333333333333, 0.59999999999999998, 1.0, ), "lightslategrey": ( 0.46666666666666667, 0.53333333333333333, 0.59999999999999998, 1.0, ), "lightsteelblue": ( 0.69019607843137254, 0.7686274509803922, 0.87058823529411766, 1.0, ), "lightsteelblue1": (0.792156862745098, 0.88235294117647056, 1.0, 1.0), "lightsteelblue2": ( 0.73725490196078436, 0.82352941176470584, 0.93333333333333335, 1.0, ), "lightsteelblue3": ( 0.63529411764705879, 0.70980392156862748, 0.80392156862745101, 1.0, ), "lightsteelblue4": ( 0.43137254901960786, 0.4823529411764706, 0.54509803921568623, 1.0, ), "lightyellow": (1.0, 1.0, 0.8784313725490196, 1.0), "lightyellow1": (1.0, 1.0, 0.8784313725490196, 1.0), "lightyellow2": ( 0.93333333333333335, 0.93333333333333335, 0.81960784313725488, 1.0, ), "lightyellow3": ( 0.80392156862745101, 0.80392156862745101, 0.70588235294117652, 1.0, ), "lightyellow4": ( 0.54509803921568623, 0.54509803921568623, 0.47843137254901963, 1.0, ), "lime": (0.0, 1.0, 0.0, 1.0), "lime green": (0.19607843137254902, 0.80392156862745101, 0.19607843137254902, 1.0), "limegreen": (0.19607843137254902, 0.80392156862745101, 0.19607843137254902, 1.0), "linen": (0.98039215686274506, 0.94117647058823528, 0.90196078431372551, 1.0), "magenta": (1.0, 0.0, 1.0, 1.0), "magenta1": (1.0, 0.0, 1.0, 1.0), "magenta2": (0.93333333333333335, 0.0, 0.93333333333333335, 1.0), "magenta3": (0.80392156862745101, 0.0, 0.80392156862745101, 1.0), "magenta4": (0.54509803921568623, 0.0, 0.54509803921568623, 1.0), "maroon": (0.69019607843137254, 0.18823529411764706, 0.37647058823529411, 1.0), "maroon1": (1.0, 0.20392156862745098, 0.70196078431372544, 1.0), "maroon2": (0.93333333333333335, 0.18823529411764706, 0.65490196078431373, 1.0), "maroon3": (0.80392156862745101, 0.16078431372549021, 0.56470588235294117, 1.0), "maroon4": (0.54509803921568623, 0.10980392156862745, 0.3843137254901961, 1.0), "medium aquamarine": ( 0.40000000000000002, 0.80392156862745101, 0.66666666666666663, 1.0, ), "medium blue": (0.0, 0.0, 0.80392156862745101, 1.0), "medium orchid": ( 0.72941176470588232, 0.33333333333333331, 0.82745098039215681, 1.0, ), "medium purple": ( 0.57647058823529407, 0.4392156862745098, 0.85882352941176465, 1.0, ), "medium sea green": ( 0.23529411764705882, 0.70196078431372544, 0.44313725490196076, 1.0, ), "medium slate blue": ( 0.4823529411764706, 0.40784313725490196, 0.93333333333333335, 1.0, ), "medium spring green": (0.0, 0.98039215686274506, 0.60392156862745094, 1.0), "medium turquoise": ( 0.28235294117647058, 0.81960784313725488, 0.80000000000000004, 1.0, ), "medium violet red": ( 0.7803921568627451, 0.082352941176470587, 0.52156862745098043, 1.0, ), "mediumaquamarine": ( 0.40000000000000002, 0.80392156862745101, 0.66666666666666663, 1.0, ), "mediumblue": (0.0, 0.0, 0.80392156862745101, 1.0), "mediumorchid": ( 0.72941176470588232, 0.33333333333333331, 0.82745098039215681, 1.0, ), "mediumorchid1": (0.8784313725490196, 0.40000000000000002, 1.0, 1.0), "mediumorchid2": ( 0.81960784313725488, 0.37254901960784315, 0.93333333333333335, 1.0, ), "mediumorchid3": ( 0.70588235294117652, 0.32156862745098042, 0.80392156862745101, 1.0, ), "mediumorchid4": ( 0.47843137254901963, 0.21568627450980393, 0.54509803921568623, 1.0, ), "mediumpurple": (0.57647058823529407, 0.4392156862745098, 0.85882352941176465, 1.0), "mediumpurple1": (0.6705882352941176, 0.50980392156862742, 1.0, 1.0), "mediumpurple2": ( 0.62352941176470589, 0.47450980392156861, 0.93333333333333335, 1.0, ), "mediumpurple3": ( 0.53725490196078429, 0.40784313725490196, 0.80392156862745101, 1.0, ), "mediumpurple4": ( 0.36470588235294116, 0.27843137254901962, 0.54509803921568623, 1.0, ), "mediumseagreen": ( 0.23529411764705882, 0.70196078431372544, 0.44313725490196076, 1.0, ), "mediumslateblue": ( 0.4823529411764706, 0.40784313725490196, 0.93333333333333335, 1.0, ), "mediumspringgreen": (0.0, 0.98039215686274506, 0.60392156862745094, 1.0), "mediumturquoise": ( 0.28235294117647058, 0.81960784313725488, 0.80000000000000004, 1.0, ), "mediumvioletred": ( 0.7803921568627451, 0.082352941176470587, 0.52156862745098043, 1.0, ), "midnight blue": ( 0.098039215686274508, 0.098039215686274508, 0.4392156862745098, 1.0, ), "midnightblue": ( 0.098039215686274508, 0.098039215686274508, 0.4392156862745098, 1.0, ), "mint cream": (0.96078431372549022, 1.0, 0.98039215686274506, 1.0), "mintcream": (0.96078431372549022, 1.0, 0.98039215686274506, 1.0), "misty rose": (1.0, 0.89411764705882357, 0.88235294117647056, 1.0), "mistyrose": (1.0, 0.89411764705882357, 0.88235294117647056, 1.0), "mistyrose1": (1.0, 0.89411764705882357, 0.88235294117647056, 1.0), "mistyrose2": (0.93333333333333335, 0.83529411764705885, 0.82352941176470584, 1.0), "mistyrose3": (0.80392156862745101, 0.71764705882352942, 0.70980392156862748, 1.0), "mistyrose4": (0.54509803921568623, 0.49019607843137253, 0.4823529411764706, 1.0), "moccasin": (1.0, 0.89411764705882357, 0.70980392156862748, 1.0), "navajo white": (1.0, 0.87058823529411766, 0.67843137254901964, 1.0), "navajowhite": (1.0, 0.87058823529411766, 0.67843137254901964, 1.0), "navajowhite1": (1.0, 0.87058823529411766, 0.67843137254901964, 1.0), "navajowhite2": ( 0.93333333333333335, 0.81176470588235294, 0.63137254901960782, 1.0, ), "navajowhite3": ( 0.80392156862745101, 0.70196078431372544, 0.54509803921568623, 1.0, ), "navajowhite4": ( 0.54509803921568623, 0.47450980392156861, 0.36862745098039218, 1.0, ), "navy": (0.0, 0.0, 0.50196078431372548, 1.0), "navy blue": (0.0, 0.0, 0.50196078431372548, 1.0), "navyblue": (0.0, 0.0, 0.50196078431372548, 1.0), "old lace": (0.99215686274509807, 0.96078431372549022, 0.90196078431372551, 1.0), "oldlace": (0.99215686274509807, 0.96078431372549022, 0.90196078431372551, 1.0), "olive": (0.5, 0.5, 0.0, 1.0), "olive drab": (0.41960784313725491, 0.55686274509803924, 0.13725490196078433, 1.0), "olivedrab": (0.41960784313725491, 0.55686274509803924, 0.13725490196078433, 1.0), "olivedrab1": (0.75294117647058822, 1.0, 0.24313725490196078, 1.0), "olivedrab2": (0.70196078431372544, 0.93333333333333335, 0.22745098039215686, 1.0), "olivedrab3": (0.60392156862745094, 0.80392156862745101, 0.19607843137254902, 1.0), "olivedrab4": (0.41176470588235292, 0.54509803921568623, 0.13333333333333333, 1.0), "orange": (1.0, 0.6470588235294118, 0.0, 1.0), "orange red": (1.0, 0.27058823529411763, 0.0, 1.0), "orange1": (1.0, 0.6470588235294118, 0.0, 1.0), "orange2": (0.93333333333333335, 0.60392156862745094, 0.0, 1.0), "orange3": (0.80392156862745101, 0.52156862745098043, 0.0, 1.0), "orange4": (0.54509803921568623, 0.35294117647058826, 0.0, 1.0), "orangered": (1.0, 0.27058823529411763, 0.0, 1.0), "orangered1": (1.0, 0.27058823529411763, 0.0, 1.0), "orangered2": (0.93333333333333335, 0.25098039215686274, 0.0, 1.0), "orangered3": (0.80392156862745101, 0.21568627450980393, 0.0, 1.0), "orangered4": (0.54509803921568623, 0.14509803921568629, 0.0, 1.0), "orchid": (0.85490196078431369, 0.4392156862745098, 0.83921568627450982, 1.0), "orchid1": (1.0, 0.51372549019607838, 0.98039215686274506, 1.0), "orchid2": (0.93333333333333335, 0.47843137254901963, 0.9137254901960784, 1.0), "orchid3": (0.80392156862745101, 0.41176470588235292, 0.78823529411764703, 1.0), "orchid4": (0.54509803921568623, 0.27843137254901962, 0.53725490196078429, 1.0), "pale goldenrod": ( 0.93333333333333335, 0.90980392156862744, 0.66666666666666663, 1.0, ), "pale green": (0.59607843137254901, 0.98431372549019602, 0.59607843137254901, 1.0), "pale turquoise": ( 0.68627450980392157, 0.93333333333333335, 0.93333333333333335, 1.0, ), "pale violet red": ( 0.85882352941176465, 0.4392156862745098, 0.57647058823529407, 1.0, ), "palegoldenrod": ( 0.93333333333333335, 0.90980392156862744, 0.66666666666666663, 1.0, ), "palegreen": (0.59607843137254901, 0.98431372549019602, 0.59607843137254901, 1.0), "palegreen1": (0.60392156862745094, 1.0, 0.60392156862745094, 1.0), "palegreen2": (0.56470588235294117, 0.93333333333333335, 0.56470588235294117, 1.0), "palegreen3": (0.48627450980392156, 0.80392156862745101, 0.48627450980392156, 1.0), "palegreen4": (0.32941176470588235, 0.54509803921568623, 0.32941176470588235, 1.0), "paleturquoise": ( 0.68627450980392157, 0.93333333333333335, 0.93333333333333335, 1.0, ), "paleturquoise1": (0.73333333333333328, 1.0, 1.0, 1.0), "paleturquoise2": ( 0.68235294117647061, 0.93333333333333335, 0.93333333333333335, 1.0, ), "paleturquoise3": ( 0.58823529411764708, 0.80392156862745101, 0.80392156862745101, 1.0, ), "paleturquoise4": ( 0.40000000000000002, 0.54509803921568623, 0.54509803921568623, 1.0, ), "palevioletred": ( 0.85882352941176465, 0.4392156862745098, 0.57647058823529407, 1.0, ), "palevioletred1": (1.0, 0.50980392156862742, 0.6705882352941176, 1.0), "palevioletred2": ( 0.93333333333333335, 0.47450980392156861, 0.62352941176470589, 1.0, ), "palevioletred3": ( 0.80392156862745101, 0.40784313725490196, 0.53725490196078429, 1.0, ), "palevioletred4": ( 0.54509803921568623, 0.27843137254901962, 0.36470588235294116, 1.0, ), "papaya whip": (1.0, 0.93725490196078431, 0.83529411764705885, 1.0), "papayawhip": (1.0, 0.93725490196078431, 0.83529411764705885, 1.0), "peach puff": (1.0, 0.85490196078431369, 0.72549019607843135, 1.0), "peachpuff": (1.0, 0.85490196078431369, 0.72549019607843135, 1.0), "peachpuff1": (1.0, 0.85490196078431369, 0.72549019607843135, 1.0), "peachpuff2": (0.93333333333333335, 0.79607843137254897, 0.67843137254901964, 1.0), "peachpuff3": (0.80392156862745101, 0.68627450980392157, 0.58431372549019611, 1.0), "peachpuff4": (0.54509803921568623, 0.46666666666666667, 0.396078431372549, 1.0), "peru": (0.80392156862745101, 0.52156862745098043, 0.24705882352941178, 1.0), "pink": (1.0, 0.75294117647058822, 0.79607843137254897, 1.0), "pink1": (1.0, 0.70980392156862748, 0.77254901960784317, 1.0), "pink2": (0.93333333333333335, 0.66274509803921566, 0.72156862745098038, 1.0), "pink3": (0.80392156862745101, 0.56862745098039214, 0.61960784313725492, 1.0), "pink4": (0.54509803921568623, 0.38823529411764707, 0.42352941176470588, 1.0), "plum": (0.8666666666666667, 0.62745098039215685, 0.8666666666666667, 1.0), "plum1": (1.0, 0.73333333333333328, 1.0, 1.0), "plum2": (0.93333333333333335, 0.68235294117647061, 0.93333333333333335, 1.0), "plum3": (0.80392156862745101, 0.58823529411764708, 0.80392156862745101, 1.0), "plum4": (0.54509803921568623, 0.40000000000000002, 0.54509803921568623, 1.0), "powder blue": (0.69019607843137254, 0.8784313725490196, 0.90196078431372551, 1.0), "powderblue": (0.69019607843137254, 0.8784313725490196, 0.90196078431372551, 1.0), "purple": (0.62745098039215685, 0.12549019607843137, 0.94117647058823528, 1.0), "purple1": (0.60784313725490191, 0.18823529411764706, 1.0, 1.0), "purple2": (0.56862745098039214, 0.17254901960784313, 0.93333333333333335, 1.0), "purple3": (0.49019607843137253, 0.14901960784313725, 0.80392156862745101, 1.0), "purple4": (0.33333333333333331, 0.10196078431372549, 0.54509803921568623, 1.0), "rebecca purple": (0.4, 0.2, 0.6, 1.0), "rebeccapurple": (0.4, 0.2, 0.6, 1.0), "red": (1.0, 0.0, 0.0, 1.0), "red1": (1.0, 0.0, 0.0, 1.0), "red2": (0.93333333333333335, 0.0, 0.0, 1.0), "red3": (0.80392156862745101, 0.0, 0.0, 1.0), "red4": (0.54509803921568623, 0.0, 0.0, 1.0), "rosy brown": (0.73725490196078436, 0.5607843137254902, 0.5607843137254902, 1.0), "rosybrown": (0.73725490196078436, 0.5607843137254902, 0.5607843137254902, 1.0), "rosybrown1": (1.0, 0.75686274509803919, 0.75686274509803919, 1.0), "rosybrown2": (0.93333333333333335, 0.70588235294117652, 0.70588235294117652, 1.0), "rosybrown3": (0.80392156862745101, 0.60784313725490191, 0.60784313725490191, 1.0), "rosybrown4": (0.54509803921568623, 0.41176470588235292, 0.41176470588235292, 1.0), "royal blue": (0.25490196078431371, 0.41176470588235292, 0.88235294117647056, 1.0), "royalblue": (0.25490196078431371, 0.41176470588235292, 0.88235294117647056, 1.0), "royalblue1": (0.28235294117647058, 0.46274509803921571, 1.0, 1.0), "royalblue2": (0.2627450980392157, 0.43137254901960786, 0.93333333333333335, 1.0), "royalblue3": (0.22745098039215686, 0.37254901960784315, 0.80392156862745101, 1.0), "royalblue4": (0.15294117647058825, 0.25098039215686274, 0.54509803921568623, 1.0), "saddle brown": ( 0.54509803921568623, 0.27058823529411763, 0.074509803921568626, 1.0, ), "saddlebrown": ( 0.54509803921568623, 0.27058823529411763, 0.074509803921568626, 1.0, ), "salmon": (0.98039215686274506, 0.50196078431372548, 0.44705882352941179, 1.0), "salmon1": (1.0, 0.5490196078431373, 0.41176470588235292, 1.0), "salmon2": (0.93333333333333335, 0.50980392156862742, 0.3843137254901961, 1.0), "salmon3": (0.80392156862745101, 0.4392156862745098, 0.32941176470588235, 1.0), "salmon4": (0.54509803921568623, 0.29803921568627451, 0.22352941176470589, 1.0), "sandy brown": (0.95686274509803926, 0.64313725490196083, 0.37647058823529411, 1.0), "sandybrown": (0.95686274509803926, 0.64313725490196083, 0.37647058823529411, 1.0), "sea green": (0.1803921568627451, 0.54509803921568623, 0.3411764705882353, 1.0), "seagreen": (0.1803921568627451, 0.54509803921568623, 0.3411764705882353, 1.0), "seagreen1": (0.32941176470588235, 1.0, 0.62352941176470589, 1.0), "seagreen2": (0.30588235294117649, 0.93333333333333335, 0.58039215686274515, 1.0), "seagreen3": (0.2627450980392157, 0.80392156862745101, 0.50196078431372548, 1.0), "seagreen4": (0.1803921568627451, 0.54509803921568623, 0.3411764705882353, 1.0), "seashell": (1.0, 0.96078431372549022, 0.93333333333333335, 1.0), "seashell1": (1.0, 0.96078431372549022, 0.93333333333333335, 1.0), "seashell2": (0.93333333333333335, 0.89803921568627454, 0.87058823529411766, 1.0), "seashell3": (0.80392156862745101, 0.77254901960784317, 0.74901960784313726, 1.0), "seashell4": (0.54509803921568623, 0.52549019607843139, 0.50980392156862742, 1.0), "sienna": (0.62745098039215685, 0.32156862745098042, 0.17647058823529413, 1.0), "sienna1": (1.0, 0.50980392156862742, 0.27843137254901962, 1.0), "sienna2": (0.93333333333333335, 0.47450980392156861, 0.25882352941176473, 1.0), "sienna3": (0.80392156862745101, 0.40784313725490196, 0.22352941176470589, 1.0), "sienna4": (0.54509803921568623, 0.27843137254901962, 0.14901960784313725, 1.0), "silver": (0.75, 0.75, 0.75, 1.0), "sky blue": (0.52941176470588236, 0.80784313725490198, 0.92156862745098034, 1.0), "skyblue": (0.52941176470588236, 0.80784313725490198, 0.92156862745098034, 1.0), "skyblue1": (0.52941176470588236, 0.80784313725490198, 1.0, 1.0), "skyblue2": (0.49411764705882355, 0.75294117647058822, 0.93333333333333335, 1.0), "skyblue3": (0.42352941176470588, 0.65098039215686276, 0.80392156862745101, 1.0), "skyblue4": (0.29019607843137257, 0.4392156862745098, 0.54509803921568623, 1.0), "slate blue": (0.41568627450980394, 0.35294117647058826, 0.80392156862745101, 1.0), "slate gray": (0.4392156862745098, 0.50196078431372548, 0.56470588235294117, 1.0), "slate grey": (0.4392156862745098, 0.50196078431372548, 0.56470588235294117, 1.0), "slateblue": (0.41568627450980394, 0.35294117647058826, 0.80392156862745101, 1.0), "slateblue1": (0.51372549019607838, 0.43529411764705883, 1.0, 1.0), "slateblue2": (0.47843137254901963, 0.40392156862745099, 0.93333333333333335, 1.0), "slateblue3": (0.41176470588235292, 0.34901960784313724, 0.80392156862745101, 1.0), "slateblue4": (0.27843137254901962, 0.23529411764705882, 0.54509803921568623, 1.0), "slategray": (0.4392156862745098, 0.50196078431372548, 0.56470588235294117, 1.0), "slategray1": (0.77647058823529413, 0.88627450980392153, 1.0, 1.0), "slategray2": (0.72549019607843135, 0.82745098039215681, 0.93333333333333335, 1.0), "slategray3": (0.62352941176470589, 0.71372549019607845, 0.80392156862745101, 1.0), "slategray4": (0.42352941176470588, 0.4823529411764706, 0.54509803921568623, 1.0), "slategrey": (0.4392156862745098, 0.50196078431372548, 0.56470588235294117, 1.0), "snow": (1.0, 0.98039215686274506, 0.98039215686274506, 1.0), "snow1": (1.0, 0.98039215686274506, 0.98039215686274506, 1.0), "snow2": (0.93333333333333335, 0.9137254901960784, 0.9137254901960784, 1.0), "snow3": (0.80392156862745101, 0.78823529411764703, 0.78823529411764703, 1.0), "snow4": (0.54509803921568623, 0.53725490196078429, 0.53725490196078429, 1.0), "spring green": (0.0, 1.0, 0.49803921568627452, 1.0), "springgreen": (0.0, 1.0, 0.49803921568627452, 1.0), "springgreen1": (0.0, 1.0, 0.49803921568627452, 1.0), "springgreen2": (0.0, 0.93333333333333335, 0.46274509803921571, 1.0), "springgreen3": (0.0, 0.80392156862745101, 0.40000000000000002, 1.0), "springgreen4": (0.0, 0.54509803921568623, 0.27058823529411763, 1.0), "steel blue": (0.27450980392156865, 0.50980392156862742, 0.70588235294117652, 1.0), "steelblue": (0.27450980392156865, 0.50980392156862742, 0.70588235294117652, 1.0), "steelblue1": (0.38823529411764707, 0.72156862745098038, 1.0, 1.0), "steelblue2": (0.36078431372549019, 0.67450980392156867, 0.93333333333333335, 1.0), "steelblue3": (0.30980392156862746, 0.58039215686274515, 0.80392156862745101, 1.0), "steelblue4": (0.21176470588235294, 0.39215686274509803, 0.54509803921568623, 1.0), "tan": (0.82352941176470584, 0.70588235294117652, 0.5490196078431373, 1.0), "tan1": (1.0, 0.6470588235294118, 0.30980392156862746, 1.0), "tan2": (0.93333333333333335, 0.60392156862745094, 0.28627450980392155, 1.0), "tan3": (0.80392156862745101, 0.52156862745098043, 0.24705882352941178, 1.0), "tan4": (0.54509803921568623, 0.35294117647058826, 0.16862745098039217, 1.0), "teal": (0.0, 0.5, 0.5, 1.0), "thistle": (0.84705882352941175, 0.74901960784313726, 0.84705882352941175, 1.0), "thistle1": (1.0, 0.88235294117647056, 1.0, 1.0), "thistle2": (0.93333333333333335, 0.82352941176470584, 0.93333333333333335, 1.0), "thistle3": (0.80392156862745101, 0.70980392156862748, 0.80392156862745101, 1.0), "thistle4": (0.54509803921568623, 0.4823529411764706, 0.54509803921568623, 1.0), "tomato": (1.0, 0.38823529411764707, 0.27843137254901962, 1.0), "tomato1": (1.0, 0.38823529411764707, 0.27843137254901962, 1.0), "tomato2": (0.93333333333333335, 0.36078431372549019, 0.25882352941176473, 1.0), "tomato3": (0.80392156862745101, 0.30980392156862746, 0.22352941176470589, 1.0), "tomato4": (0.54509803921568623, 0.21176470588235294, 0.14901960784313725, 1.0), "turquoise": (0.25098039215686274, 0.8784313725490196, 0.81568627450980391, 1.0), "turquoise1": (0.0, 0.96078431372549022, 1.0, 1.0), "turquoise2": (0.0, 0.89803921568627454, 0.93333333333333335, 1.0), "turquoise3": (0.0, 0.77254901960784317, 0.80392156862745101, 1.0), "turquoise4": (0.0, 0.52549019607843139, 0.54509803921568623, 1.0), "violet": (0.93333333333333335, 0.50980392156862742, 0.93333333333333335, 1.0), "violet red": (0.81568627450980391, 0.12549019607843137, 0.56470588235294117, 1.0), "violetred": (0.81568627450980391, 0.12549019607843137, 0.56470588235294117, 1.0), "violetred1": (1.0, 0.24313725490196078, 0.58823529411764708, 1.0), "violetred2": (0.93333333333333335, 0.22745098039215686, 0.5490196078431373, 1.0), "violetred3": (0.80392156862745101, 0.19607843137254902, 0.47058823529411764, 1.0), "violetred4": (0.54509803921568623, 0.13333333333333333, 0.32156862745098042, 1.0), "web gray": (0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 1.0), "webgray": (0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 1.0), "web green": (0.0, 0.5019607843137255, 0.0, 1.0), "webgreen": (0.0, 0.5019607843137255, 0.0, 1.0), "webgray": (0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 1.0), "web grey": (0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 1.0), "webgrey": (0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 1.0), "web maroon": (0.5019607843137255, 0.0, 0.0, 1.0), "webmaroon": (0.5019607843137255, 0.0, 0.0, 1.0), "web purple": (0.4980392156862745, 0.0, 0.4980392156862745, 1.0), "webpurple": (0.4980392156862745, 0.0, 0.4980392156862745, 1.0), "wheat": (0.96078431372549022, 0.87058823529411766, 0.70196078431372544, 1.0), "wheat1": (1.0, 0.90588235294117647, 0.72941176470588232, 1.0), "wheat2": (0.93333333333333335, 0.84705882352941175, 0.68235294117647061, 1.0), "wheat3": (0.80392156862745101, 0.72941176470588232, 0.58823529411764708, 1.0), "wheat4": (0.54509803921568623, 0.49411764705882355, 0.40000000000000002, 1.0), "white": (1.0, 1.0, 1.0, 1.0), "white smoke": (0.96078431372549022, 0.96078431372549022, 0.96078431372549022, 1.0), "whitesmoke": (0.96078431372549022, 0.96078431372549022, 0.96078431372549022, 1.0), "yellow": (1.0, 1.0, 0.0, 1.0), "yellow green": ( 0.60392156862745094, 0.80392156862745101, 0.19607843137254902, 1.0, ), "yellow1": (1.0, 1.0, 0.0, 1.0), "yellow2": (0.93333333333333335, 0.93333333333333335, 0.0, 1.0), "yellow3": (0.80392156862745101, 0.80392156862745101, 0.0, 1.0), "yellow4": (0.54509803921568623, 0.54509803921568623, 0.0, 1.0), "yellowgreen": (0.60392156862745094, 0.80392156862745101, 0.19607843137254902, 1.0), } palettes = { "gray": GradientPalette("black", "white"), "red-blue": GradientPalette("red", "blue"), "red-purple-blue": AdvancedGradientPalette(["red", "purple", "blue"]), "red-green": GradientPalette("red", "green"), "red-yellow-green": AdvancedGradientPalette(["red", "yellow", "green"]), "red-black-green": AdvancedGradientPalette(["red", "black", "green"]), "rainbow": RainbowPalette(), "heat": AdvancedGradientPalette(["red", "yellow", "white"], indices=[0, 192, 255]), "terrain": AdvancedGradientPalette( ["hsv(120, 100%, 65%)", "hsv(60, 100%, 90%)", "hsv(0, 0%, 95%)"] ), } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/coord.py0000644000175100001710000000752300000000000020766 0ustar00runnerdocker00000000000000""" Coordinate systems and related plotting routines """ from igraph.drawing.baseclasses import AbstractCairoDrawer from igraph.drawing.utils import BoundingBox ##################################################################### class CoordinateSystem(AbstractCairoDrawer): """Class implementing a coordinate system object. Coordinate system objects are used when drawing plots which 2D or 3D coordinate system axes. This is an abstract class which must be extended in order to use it. In general, you'll only need the documentation of this class if you intend to implement an own coordinate system not present in igraph yet. """ def __init__(self, context, bbox): """Initializes the coordinate system. @param context: the context on which the coordinate system will be drawn. @param bbox: the bounding box that will contain the coordinate system. """ AbstractCairoDrawer.__init__(self, context, bbox) def draw(self): """Draws the coordinate system. This method must be overridden in derived classes. """ raise NotImplementedError("abstract class") def local_to_context(self, x, y): """Converts local coordinates to the context coordinate system (given by the bounding box). This method must be overridden in derived classes.""" raise NotImplementedError("abstract class") class DescartesCoordinateSystem(CoordinateSystem): """Class implementing a 2D Descartes coordinate system object.""" def __init__(self, context, bbox, bounds): """Initializes the coordinate system. @param context: the context on which the coordinate system will be drawn. @param bbox: the bounding box that will contain the coordinate system. @param bounds: minimum and maximum X and Y values in a 4-tuple. """ self._bounds, self._bbox = None, None self._sx, self._sy = None, None self._ox, self._oy, self._ox2, self._oy2 = None, None, None, None CoordinateSystem.__init__(self, context, bbox) self.bbox = bbox self.bounds = bounds @property def bbox(self): """Returns the bounding box of the coordinate system""" return BoundingBox(self._bbox.coords) @bbox.setter def bbox(self, bbox): """Sets the bounding box of the coordinate system""" self._bbox = bbox self._recalc_scale_factors() @property def bounds(self): """Returns the lower and upper bounds of the X and Y values""" return self._bounds.coords @bounds.setter def bounds(self, bounds): """Sets the lower and upper bounds of the X and Y values""" self._bounds = BoundingBox(bounds) self._recalc_scale_factors() def _recalc_scale_factors(self): """Recalculates some cached scale factors used within the class""" if self._bounds is None: return self._sx = self._bbox.width / self._bounds.width self._sy = self._bbox.height / self._bounds.height self._ox = self._bounds.left self._oy = self._bounds.top self._ox2 = self._bbox.left self._oy2 = self._bbox.bottom def draw(self): """Draws the coordinate system.""" # Draw the frame coords = self.bbox.coords self.context.set_source_rgb(0.0, 0.0, 0.0) self.context.set_line_width(1) self.context.rectangle( coords[0], coords[1], coords[2] - coords[0], coords[3] - coords[1] ) self.context.stroke() def local_to_context(self, x, y): """Converts local coordinates to the context coordinate system (given by the bounding box). """ return (x - self._ox) * self._sx + self._ox2, self._oy2 - ( y - self._oy ) * self._sy ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/edge.py0000644000175100001710000004436000000000000020564 0ustar00runnerdocker00000000000000""" Drawers for various edge styles in graph plots. """ __all__ = ( "AbstractEdgeDrawer", "AlphaVaryingEdgeDrawer", "ArrowEdgeDrawer", "DarkToLightEdgeDrawer", "LightToDarkEdgeDrawer", "TaperedEdgeDrawer", ) from igraph.drawing.colors import clamp from igraph.drawing.metamagic import AttributeCollectorBase from igraph.drawing.text import TextAlignment from igraph.drawing.utils import evaluate_cubic_bezier_curve, find_cairo, get_bezier_control_points_for_curved_edge from math import atan2, cos, pi, sin, sqrt cairo = find_cairo() class AbstractEdgeDrawer: """Abstract edge drawer object from which all concrete edge drawer implementations are derived.""" def __init__(self, context, palette): """Constructs the edge drawer. @param context: a Cairo context on which the edges will be drawn. @param palette: the palette that can be used to map integer color indices to colors when drawing edges """ self.context = context self.palette = palette self.VisualEdgeBuilder = self._construct_visual_edge_builder() @staticmethod def _curvature_to_float(value): """Converts values given to the 'curved' edge style argument in plotting calls to floating point values.""" if value is None or value is False: return 0.0 if value is True: return 0.5 return float(value) def _construct_visual_edge_builder(self): """Construct the visual edge builder that will collect the visual attributes of an edge when it is being drawn.""" class VisualEdgeBuilder(AttributeCollectorBase): """Builder that collects some visual properties of an edge for drawing""" _kwds_prefix = "edge_" arrow_size = 1.0 arrow_width = 1.0 color = ("#444", self.palette.get) curved = (0.0, self._curvature_to_float) label = None label_color = ("black", self.palette.get) label_size = 12.0 font = "sans-serif" width = 1.0 return VisualEdgeBuilder def draw_directed_edge(self, edge, src_vertex, dest_vertex): """Draws a directed edge. @param edge: the edge to be drawn. Visual properties of the edge are defined by the attributes of this object. @param src_vertex: the source vertex. Visual properties are given again as attributes. @param dest_vertex: the target vertex. Visual properties are given again as attributes. """ raise NotImplementedError() def draw_loop_edge(self, edge, vertex): """Draws a loop edge. The default implementation draws a small circle. @param edge: the edge to be drawn. Visual properties of the edge are defined by the attributes of this object. @param vertex: the vertex to which the edge is attached. Visual properties are given again as attributes. """ ctx = self.context ctx.set_source_rgba(*edge.color) ctx.set_line_width(edge.width) radius = vertex.size * 1.5 center_x = vertex.position[0] + cos(pi / 4) * radius / 2.0 center_y = vertex.position[1] - sin(pi / 4) * radius / 2.0 ctx.arc(center_x, center_y, radius / 2.0, 0, pi * 2) ctx.stroke() def draw_undirected_edge(self, edge, src_vertex, dest_vertex): """Draws an undirected edge. The default implementation of this method draws undirected edges as straight lines. Loop edges are drawn as small circles. @param edge: the edge to be drawn. Visual properties of the edge are defined by the attributes of this object. @param src_vertex: the source vertex. Visual properties are given again as attributes. @param dest_vertex: the target vertex. Visual properties are given again as attributes. """ if src_vertex == dest_vertex: # TODO return self.draw_loop_edge(edge, src_vertex) ctx = self.context ctx.set_source_rgba(*edge.color) ctx.set_line_width(edge.width) ctx.move_to(*src_vertex.position) if edge.curved: (x1, y1), (x2, y2) = src_vertex.position, dest_vertex.position aux1, aux2 = get_bezier_control_points_for_curved_edge(x1, y1, x2, y2, edge['curved']) ctx.curve_to(aux1[0], aux1[1], aux2[0], aux2[1], *dest_vertex.position) else: ctx.line_to(*dest_vertex.position) ctx.stroke() def get_label_position(self, edge, src_vertex, dest_vertex): """Returns the position where the label of an edge should be drawn. The default implementation returns the midpoint of the edge and an alignment that tries to avoid overlapping the label with the edge. @param edge: the edge to be drawn. Visual properties of the edge are defined by the attributes of this object. @param src_vertex: the source vertex. Visual properties are given again as attributes. @param dest_vertex: the target vertex. Visual properties are given again as attributes. @return: a tuple containing two more tuples: the desired position of the label and the desired alignment of the label, where the position is given as C{(x, y)} and the alignment is given as C{(horizontal, vertical)}. Members of the alignment tuple are taken from constants in the L{TextAlignment} class. """ # Determine the angle of the line dx = dest_vertex.position[0] - src_vertex.position[0] dy = dest_vertex.position[1] - src_vertex.position[1] if dx != 0 or dy != 0: # Note that we use -dy because the Y axis points downwards angle = atan2(-dy, dx) % (2 * pi) else: angle = None # Determine the midpoint if edge['curved']: (x1, y1), (x2, y2) = src_vertex.position, dest_vertex.position aux1, aux2 = get_bezier_control_points_for_curved_edge(x1, y1, x2, y2, edge['curved']) pos = evaluate_cubic_bezier_curve(x1, y1, *aux1, *aux2, x2, y2, .5) else: pos = ( (src_vertex.position[0] + dest_vertex.position[0]) / 2.0, (src_vertex.position[1] + dest_vertex.position[1]) / 2, ) # Determine the alignment based on the angle pi4 = pi / 4 if angle is None: halign, valign = TextAlignment.CENTER, TextAlignment.CENTER else: index = int((angle / pi4) % 8) halign = [ TextAlignment.RIGHT, TextAlignment.RIGHT, TextAlignment.RIGHT, TextAlignment.RIGHT, TextAlignment.LEFT, TextAlignment.LEFT, TextAlignment.LEFT, TextAlignment.LEFT, ][index] valign = [ TextAlignment.BOTTOM, TextAlignment.CENTER, TextAlignment.CENTER, TextAlignment.TOP, TextAlignment.TOP, TextAlignment.CENTER, TextAlignment.CENTER, TextAlignment.BOTTOM, ][index] return pos, (halign, valign) class ArrowEdgeDrawer(AbstractEdgeDrawer): """Edge drawer implementation that draws undirected edges as straight lines and directed edges as arrows. """ def draw_directed_edge(self, edge, src_vertex, dest_vertex): if src_vertex == dest_vertex: # TODO return self.draw_loop_edge(edge, src_vertex) ctx = self.context (x1, y1), (x2, y2) = src_vertex.position, dest_vertex.position (x_src, y_src), (x_dest, y_dest) = src_vertex.position, dest_vertex.position def bezier_cubic(x0, y0, x1, y1, x2, y2, x3, y3, t): """Computes the Bezier curve from point (x0,y0) to (x3,y3) via control points (x1,y1) and (x2,y2) with parameter t. """ xt = ( (1.0 - t) ** 3 * x0 + 3.0 * t * (1.0 - t) ** 2 * x1 + 3.0 * t ** 2 * (1.0 - t) * x2 + t ** 3 * x3 ) yt = ( (1.0 - t) ** 3 * y0 + 3.0 * t * (1.0 - t) ** 2 * y1 + 3.0 * t ** 2 * (1.0 - t) * y2 + t ** 3 * y3 ) return xt, yt def euclidean_distance(x1, y1, x2, y2): """Computes the Euclidean distance between points (x1,y1) and (x2,y2).""" return sqrt((1.0 * x1 - x2) ** 2 + (1.0 * y1 - y2) ** 2) def intersect_bezier_circle( x0, y0, x1, y1, x2, y2, x3, y3, radius, max_iter=10 ): """Binary search solver for finding the intersection of a Bezier curve and a circle centered at the curve's end point. Returns the x,y of the intersection point. TODO: implement safeguard to ensure convergence in ALL possible cases. """ precision = radius / 20.0 source_target_distance = euclidean_distance(x0, y0, x3, y3) radius = float(radius) t0 = 1.0 t1 = 1.0 - radius / source_target_distance xt1, yt1 = bezier_cubic(x0, y0, x1, y1, x2, y2, x3, y3, t1) distance_t0 = 0 distance_t1 = euclidean_distance(x3, y3, xt1, yt1) counter = 0 while abs(distance_t1 - radius) > precision and counter < max_iter: if ((distance_t1 - radius) > 0) != ((distance_t0 - radius) > 0): t_new = (t0 + t1) / 2.0 else: if abs(distance_t1 - radius) < abs(distance_t0 - radius): # If t1 gets us closer to the circumference step in the # same direction t_new = t1 + (t1 - t0) / 2.0 else: t_new = t1 - (t1 - t0) t_new = 1 if t_new > 1 else (0 if t_new < 0 else t_new) t0, t1 = t1, t_new distance_t0 = distance_t1 xt1, yt1 = bezier_cubic(x0, y0, x1, y1, x2, y2, x3, y3, t1) distance_t1 = euclidean_distance(x3, y3, xt1, yt1) counter += 1 return bezier_cubic(x0, y0, x1, y1, x2, y2, x3, y3, t1) # Draw the edge ctx.set_source_rgba(*edge.color) ctx.set_line_width(edge.width) ctx.move_to(x1, y1) if edge.curved: # Calculate the curve aux1, aux2 = get_bezier_control_points_for_curved_edge(x1, x2, y1, y2, edge.curved) # Coordinates of the control points of the Bezier curve xc1, yc1 = aux1 xc2, yc2 = aux2 # Determine where the edge intersects the circumference of the # vertex shape: Tip of the arrow x2, y2 = intersect_bezier_circle( x_src, y_src, xc1, yc1, xc2, yc2, x_dest, y_dest, dest_vertex.size / 2.0 ) # Calculate the arrow head coordinates angle = atan2(y_dest - y2, x_dest - x2) # navid arrow_size = 15.0 * edge.arrow_size arrow_width = 10.0 / edge.arrow_width aux_points = [ ( x2 - arrow_size * cos(angle - pi / arrow_width), y2 - arrow_size * sin(angle - pi / arrow_width), ), ( x2 - arrow_size * cos(angle + pi / arrow_width), y2 - arrow_size * sin(angle + pi / arrow_width), ), ] # Midpoint of the base of the arrow triangle x_arrow_mid, y_arrow_mid = (aux_points[0][0] + aux_points[1][0]) / 2.0, ( aux_points[0][1] + aux_points[1][1] ) / 2.0 # Vector representing the base of the arrow triangle x_arrow_base_vec, y_arrow_base_vec = ( aux_points[0][0] - aux_points[1][0] ), (aux_points[0][1] - aux_points[1][1]) # Recalculate the curve such that it lands on the base of the arrow triangle aux1 = (2 * x_src + x_arrow_mid) / 3.0 - edge.curved * 0.5 * ( y_arrow_mid - y_src ), (2 * y_src + y_arrow_mid) / 3.0 + edge.curved * 0.5 * ( x_arrow_mid - x_src ) aux2 = (x_src + 2 * x_arrow_mid) / 3.0 - edge.curved * 0.5 * ( y_arrow_mid - y_src ), (y_src + 2 * y_arrow_mid) / 3.0 + edge.curved * 0.5 * ( x_arrow_mid - x_src ) # Offset the second control point (aux2) such that it falls precisely # on the normal to the arrow base vector. Strictly speaking, # offset_length is the offset length divided by the length of the # arrow base vector. offset_length = (x_arrow_mid - aux2[0]) * x_arrow_base_vec + ( y_arrow_mid - aux2[1] ) * y_arrow_base_vec offset_length /= ( euclidean_distance(0, 0, x_arrow_base_vec, y_arrow_base_vec) ** 2 ) aux2 = ( aux2[0] + x_arrow_base_vec * offset_length, aux2[1] + y_arrow_base_vec * offset_length, ) # Draw the curve from the first vertex to the midpoint of the base # of the arrow head ctx.curve_to(aux1[0], aux1[1], aux2[0], aux2[1], x_arrow_mid, y_arrow_mid) else: # Determine where the edge intersects the circumference of the # vertex shape. x2, y2 = dest_vertex.shape.intersection_point( x2, y2, x1, y1, dest_vertex.size ) # Draw the arrowhead angle = atan2(y_dest - y2, x_dest - x2) arrow_size = 15.0 * edge.arrow_size arrow_width = 10.0 / edge.arrow_width aux_points = [ ( x2 - arrow_size * cos(angle - pi / arrow_width), y2 - arrow_size * sin(angle - pi / arrow_width), ), ( x2 - arrow_size * cos(angle + pi / arrow_width), y2 - arrow_size * sin(angle + pi / arrow_width), ), ] # Midpoint of the base of the arrow triangle x_arrow_mid, y_arrow_mid = (aux_points[0][0] + aux_points[1][0]) / 2.0, ( aux_points[0][1] + aux_points[1][1] ) / 2.0 # Draw the line ctx.line_to(x_arrow_mid, y_arrow_mid) # Draw the edge ctx.stroke() # Draw the arrow head ctx.move_to(x2, y2) ctx.line_to(*aux_points[0]) ctx.line_to(*aux_points[1]) ctx.line_to(x2, y2) ctx.fill() class TaperedEdgeDrawer(AbstractEdgeDrawer): """Edge drawer implementation that draws undirected edges as straight lines and directed edges as tapered lines that are wider at the source and narrow at the destination. """ def draw_directed_edge(self, edge, src_vertex, dest_vertex): if src_vertex == dest_vertex: # TODO return self.draw_loop_edge(edge, src_vertex) # Determine where the edge intersects the circumference of the # destination vertex. src_pos, dest_pos = src_vertex.position, dest_vertex.position dest_pos = dest_vertex.shape.intersection_point( dest_pos[0], dest_pos[1], src_pos[0], src_pos[1], dest_vertex.size ) ctx = self.context # Draw the edge ctx.set_source_rgba(*edge.color) ctx.set_line_width(edge.width) angle = atan2(dest_pos[1] - src_pos[1], dest_pos[0] - src_pos[0]) arrow_size = src_vertex.size / 4.0 aux_points = [ ( src_pos[0] + arrow_size * cos(angle + pi / 2), src_pos[1] + arrow_size * sin(angle + pi / 2), ), ( src_pos[0] + arrow_size * cos(angle - pi / 2), src_pos[1] + arrow_size * sin(angle - pi / 2), ), ] ctx.move_to(*dest_pos) ctx.line_to(*aux_points[0]) ctx.line_to(*aux_points[1]) ctx.line_to(*dest_pos) ctx.fill() class AlphaVaryingEdgeDrawer(AbstractEdgeDrawer): """Edge drawer implementation that draws undirected edges as straight lines and directed edges by varying the alpha value of the specified edge color between the source and the destination. """ def __init__(self, context, alpha_at_src, alpha_at_dest): super().__init__(context) self.alpha_at_src = (clamp(float(alpha_at_src), 0.0, 1.0),) self.alpha_at_dest = (clamp(float(alpha_at_dest), 0.0, 1.0),) def draw_directed_edge(self, edge, src_vertex, dest_vertex): if src_vertex == dest_vertex: # TODO return self.draw_loop_edge(edge, src_vertex) src_pos, dest_pos = src_vertex.position, dest_vertex.position ctx = self.context # Set up the gradient lg = cairo.LinearGradient(src_pos[0], src_pos[1], dest_pos[0], dest_pos[1]) edge_color = edge.color[:3] + self.alpha_at_src edge_color_end = edge_color[:3] + self.alpha_at_dest lg.add_color_stop_rgba(0, *edge_color) lg.add_color_stop_rgba(1, *edge_color_end) # Draw the edge ctx.set_source(lg) ctx.set_line_width(edge.width) ctx.move_to(*src_pos) ctx.line_to(*dest_pos) ctx.stroke() class LightToDarkEdgeDrawer(AlphaVaryingEdgeDrawer): """Edge drawer implementation that draws undirected edges as straight lines and directed edges by using an alpha value of zero (total transparency) at the source and an alpha value of one (full opacity) at the destination. The alpha value is interpolated in-between. """ def __init__(self, context): super().__init__(context, 0.0, 1.0) class DarkToLightEdgeDrawer(AlphaVaryingEdgeDrawer): """Edge drawer implementation that draws undirected edges as straight lines and directed edges by using an alpha value of one (full opacity) at the source and an alpha value of zero (total transparency) at the destination. The alpha value is interpolated in-between. """ def __init__(self, context): super().__init__(context, 1.0, 0.0) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/graph.py0000644000175100001710000015640300000000000020763 0ustar00runnerdocker00000000000000""" Drawing routines to draw graphs. This module contains routines to draw graphs on: - Cairo surfaces (L{DefaultGraphDrawer}) - Matplotlib axes (L{MatplotlibGraphDrawer}) It also contains routines to send an igraph graph directly to (U{Cytoscape}) using the (U{CytoscapeRPC plugin}), see L{CytoscapeGraphDrawer}. L{CytoscapeGraphDrawer} can also fetch the current network from Cytoscape and convert it to igraph format. """ from math import atan2, cos, pi, sin, tan, sqrt from warnings import warn from igraph._igraph import convex_hull, VertexSeq from igraph.configuration import Configuration from igraph.drawing.baseclasses import ( AbstractDrawer, AbstractCairoDrawer, AbstractXMLRPCDrawer, ) from igraph.drawing.colors import color_to_html_format, color_name_to_rgb from igraph.drawing.edge import ArrowEdgeDrawer from igraph.drawing.text import TextAlignment, TextDrawer from igraph.drawing.metamagic import AttributeCollectorBase from igraph.drawing.shapes import PolygonDrawer from igraph.drawing.utils import find_cairo, Point from igraph.drawing.vertex import DefaultVertexDrawer from igraph.layout import Layout __all__ = ( "DefaultGraphDrawer", "MatplotlibGraphDrawer", "CytoscapeGraphDrawer", "UbiGraphDrawer" ) cairo = find_cairo() ##################################################################### class AbstractGraphDrawer(AbstractDrawer): """Abstract class that serves as a base class for anything that draws an igraph.Graph.""" def draw(self, graph, *args, **kwds): """Abstract method, must be implemented in derived classes.""" raise NotImplementedError("abstract class") def ensure_layout(self, layout, graph=None): """Helper method that ensures that I{layout} is an instance of L{Layout}. If it is not, the method will try to convert it to a L{Layout} according to the following rules: - If I{layout} is a string, it is assumed to be a name of an igraph layout, and it will be passed on to the C{layout} method of the given I{graph} if I{graph} is not C{None}. - If I{layout} is C{None}, the C{layout} method of I{graph} will be invoked with no parameters, which will call the default layout algorithm. - Otherwise, I{layout} will be passed on to the constructor of L{Layout}. This handles lists of lists, lists of tuples and such. If I{layout} is already a L{Layout} instance, it will still be copied and a copy will be returned. This is because graph drawers are allowed to transform the layout for their purposes, and we don't want the transformation to propagate back to the caller. """ if isinstance(layout, Layout): layout = Layout(layout.coords) elif isinstance(layout, str) or layout is None: layout = graph.layout(layout) else: layout = Layout(layout) return layout ##################################################################### class AbstractCairoGraphDrawer(AbstractGraphDrawer, AbstractCairoDrawer): """Abstract base class for graph drawers that draw on a Cairo canvas.""" def __init__(self, context, bbox): """Constructs the graph drawer and associates it to the given Cairo context and the given L{BoundingBox}. @param context: the context on which we will draw @param bbox: the bounding box within which we will draw. Can be anything accepted by the constructor of L{BoundingBox} (i.e., a 2-tuple, a 4-tuple or a L{BoundingBox} object). """ AbstractCairoDrawer.__init__(self, context, bbox) AbstractGraphDrawer.__init__(self) ##################################################################### class DefaultGraphDrawer(AbstractCairoGraphDrawer): """Class implementing the default visualisation of a graph. The default visualisation of a graph draws the nodes on a 2D plane according to a given L{Layout}, then draws a straight or curved edge between nodes connected by edges. This is the visualisation used when one invokes the L{plot()} function on a L{Graph} object. See L{Graph.__plot__()} for the keyword arguments understood by this drawer.""" def __init__( self, context, bbox, vertex_drawer_factory=DefaultVertexDrawer, edge_drawer_factory=ArrowEdgeDrawer, label_drawer_factory=TextDrawer, ): """Constructs the graph drawer and associates it to the given Cairo context and the given L{BoundingBox}. @param context: the context on which we will draw @param bbox: the bounding box within which we will draw. Can be anything accepted by the constructor of L{BoundingBox} (i.e., a 2-tuple, a 4-tuple or a L{BoundingBox} object). @param vertex_drawer_factory: a factory method that returns an L{AbstractCairoVertexDrawer} instance bound to a given Cairo context. The factory method must take three parameters: the Cairo context, the bounding box of the drawing area and the palette to be used for drawing colored vertices. The default vertex drawer is L{DefaultVertexDrawer}. @param edge_drawer_factory: a factory method that returns an L{AbstractEdgeDrawer} instance bound to a given Cairo context. The factory method must take two parameters: the Cairo context and the palette to be used for drawing colored edges. You can use any of the actual L{AbstractEdgeDrawer} implementations here to control the style of edges drawn by igraph. The default edge drawer is L{ArrowEdgeDrawer}. @param label_drawer_factory: a factory method that returns a L{TextDrawer} instance bound to a given Cairo context. The method must take one parameter: the Cairo context. The default label drawer is L{TextDrawer}. """ AbstractCairoGraphDrawer.__init__(self, context, bbox) self.vertex_drawer_factory = vertex_drawer_factory self.edge_drawer_factory = edge_drawer_factory self.label_drawer_factory = label_drawer_factory def _determine_edge_order(self, graph, kwds): """Returns the order in which the edge of the given graph have to be drawn, assuming that the relevant keyword arguments (C{edge_order} and C{edge_order_by}) are given in C{kwds} as a dictionary. If neither C{edge_order} nor C{edge_order_by} is present in C{kwds}, this function returns C{None} to indicate that the graph drawer is free to choose the most convenient edge ordering.""" if "edge_order" in kwds: # Edge order specified explicitly return kwds["edge_order"] if kwds.get("edge_order_by") is None: # No edge order specified return None # Order edges by the value of some attribute edge_order_by = kwds["edge_order_by"] reverse = False if isinstance(edge_order_by, tuple): edge_order_by, reverse = edge_order_by if isinstance(reverse, str): reverse = reverse.lower().startswith("desc") attrs = graph.es[edge_order_by] edge_order = sorted( list(range(len(attrs))), key=attrs.__getitem__, reverse=bool(reverse) ) return edge_order def _determine_vertex_order(self, graph, kwds): """Returns the order in which the vertices of the given graph have to be drawn, assuming that the relevant keyword arguments (C{vertex_order} and C{vertex_order_by}) are given in C{kwds} as a dictionary. If neither C{vertex_order} nor C{vertex_order_by} is present in C{kwds}, this function returns C{None} to indicate that the graph drawer is free to choose the most convenient vertex ordering.""" if "vertex_order" in kwds: # Vertex order specified explicitly return kwds["vertex_order"] if kwds.get("vertex_order_by") is None: # No vertex order specified return None # Order vertices by the value of some attribute vertex_order_by = kwds["vertex_order_by"] reverse = False if isinstance(vertex_order_by, tuple): vertex_order_by, reverse = vertex_order_by if isinstance(reverse, str): reverse = reverse.lower().startswith("desc") attrs = graph.vs[vertex_order_by] vertex_order = sorted( list(range(len(attrs))), key=attrs.__getitem__, reverse=bool(reverse) ) return vertex_order def draw(self, graph, palette, *args, **kwds): # Some abbreviations for sake of simplicity directed = graph.is_directed() context = self.context # Calculate/get the layout of the graph layout = self.ensure_layout(kwds.get("layout", None), graph) # Determine the size of the margin on each side margin = kwds.get("margin", 0) try: margin = list(margin) except TypeError: margin = [margin] while len(margin) < 4: margin.extend(margin) # Contract the drawing area by the margin and fit the layout bbox = self.bbox.contract(margin) layout.fit_into(bbox, keep_aspect_ratio=kwds.get("keep_aspect_ratio", False)) # Decide whether we need to calculate the curvature of edges # automatically -- and calculate them if needed. autocurve = kwds.get("autocurve", None) if autocurve or ( autocurve is None and "edge_curved" not in kwds and "curved" not in graph.edge_attributes() and graph.ecount() < 10000 ): from igraph import autocurve default = kwds.get("edge_curved", 0) if default is True: default = 0.5 default = float(default) kwds["edge_curved"] = autocurve(graph, attribute=None, default=default) # Construct the vertex, edge and label drawers vertex_drawer = self.vertex_drawer_factory(context, bbox, palette, layout) edge_drawer = self.edge_drawer_factory(context, palette) label_drawer = self.label_drawer_factory(context) # Construct the visual vertex/edge builders based on the specifications # provided by the vertex_drawer and the edge_drawer vertex_builder = vertex_drawer.VisualVertexBuilder(graph.vs, kwds) edge_builder = edge_drawer.VisualEdgeBuilder(graph.es, kwds) # Determine the order in which we will draw the vertices and edges vertex_order = self._determine_vertex_order(graph, kwds) edge_order = self._determine_edge_order(graph, kwds) # Draw the highlighted groups (if any) if "mark_groups" in kwds: mark_groups = kwds["mark_groups"] # Deferred import to avoid a cycle in the import graph from igraph.clustering import VertexClustering, VertexCover # Figure out what to do with mark_groups in order to be able to # iterate over it and get memberlist-color pairs if isinstance(mark_groups, dict): # Dictionary mapping vertex indices or tuples of vertex # indices to colors group_iter = iter(mark_groups.items()) elif isinstance(mark_groups, (VertexClustering, VertexCover)): # Vertex clustering group_iter = ((group, color) for color, group in enumerate(mark_groups)) elif hasattr(mark_groups, "__iter__"): # Lists, tuples, iterators etc group_iter = iter(mark_groups) else: # False group_iter = iter({}.items()) # We will need a polygon drawer to draw the convex hulls polygon_drawer = PolygonDrawer(context, bbox) # Iterate over color-memberlist pairs for group, color_id in group_iter: if not group or color_id is None: continue color = palette.get(color_id) if isinstance(group, VertexSeq): group = [vertex.index for vertex in group] if not hasattr(group, "__iter__"): raise TypeError("group membership list must be iterable") # Get the vertex indices that constitute the convex hull hull = [group[i] for i in convex_hull([layout[idx] for idx in group])] # Calculate the preferred rounding radius for the corners corner_radius = 1.25 * max(vertex_builder[idx].size for idx in hull) # Construct the polygon polygon = [layout[idx] for idx in hull] if len(polygon) == 2: # Expand the polygon (which is a flat line otherwise) a, b = Point(*polygon[0]), Point(*polygon[1]) c = corner_radius * (a - b).normalized() n = Point(-c[1], c[0]) polygon = [a + n, b + n, b - c, b - n, a - n, a + c] else: # Expand the polygon around its center of mass center = Point( *[sum(coords) / float(len(coords)) for coords in zip(*polygon)] ) polygon = [ Point(*point).towards(center, -corner_radius) for point in polygon ] # Draw the hull context.set_source_rgba(color[0], color[1], color[2], color[3] * 0.25) polygon_drawer.draw_path(polygon, corner_radius=corner_radius) context.fill_preserve() context.set_source_rgba(*color) context.stroke() # Construct the iterator that we will use to draw the edges es = graph.es if edge_order is None: # Default edge order edge_coord_iter = zip(es, edge_builder) else: # Specified edge order edge_coord_iter = ((es[i], edge_builder[i]) for i in edge_order) # Draw the edges if directed: drawer_method = edge_drawer.draw_directed_edge else: drawer_method = edge_drawer.draw_undirected_edge for edge, visual_edge in edge_coord_iter: src, dest = edge.tuple src_vertex, dest_vertex = vertex_builder[src], vertex_builder[dest] drawer_method(visual_edge, src_vertex, dest_vertex) # Construct the iterator that we will use to draw the vertices vs = graph.vs if vertex_order is None: # Default vertex order vertex_coord_iter = zip(vs, vertex_builder, layout) else: # Specified vertex order vertex_coord_iter = ( (vs[i], vertex_builder[i], layout[i]) for i in vertex_order ) # Draw the vertices drawer_method = vertex_drawer.draw context.set_line_width(1) for vertex, visual_vertex, coords in vertex_coord_iter: drawer_method(visual_vertex, vertex, coords) # Decide whether the labels have to be wrapped wrap = kwds.get("wrap_labels") if wrap is None: wrap = Configuration.instance()["plotting.wrap_labels"] wrap = bool(wrap) # Construct the iterator that we will use to draw the vertex labels if vertex_order is None: # Default vertex order vertex_coord_iter = zip(vertex_builder, layout) else: # Specified vertex order vertex_coord_iter = ((vertex_builder[i], layout[i]) for i in vertex_order) # Draw the vertex labels for vertex, coords in vertex_coord_iter: if vertex.label is None: continue # Set the font family, size, color and text context.select_font_face( vertex.font, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL ) context.set_font_size(vertex.label_size) context.set_source_rgba(*vertex.label_color) label_drawer.text = vertex.label if vertex.label_dist: # Label is displaced from the center of the vertex. _, yb, w, h, _, _ = label_drawer.text_extents() w, h = w / 2.0, h / 2.0 radius = vertex.label_dist * vertex.size / 2.0 # First we find the reference point that is at distance `radius' # from the vertex in the direction given by `label_angle'. # Then we place the label in a way that the line connecting the # center of the bounding box of the label with the center of the # vertex goes through the reference point and the reference # point lies exactly on the bounding box of the vertex. alpha = vertex.label_angle % (2 * pi) cx = coords[0] + radius * cos(alpha) cy = coords[1] - radius * sin(alpha) # Now we have the reference point. We have to decide which side # of the label box will intersect with the line that connects # the center of the label with the center of the vertex. if w > 0: beta = atan2(h, w) % (2 * pi) else: beta = pi / 2.0 gamma = pi - beta if alpha > 2 * pi - beta or alpha <= beta: # Intersection at left edge of label cx += w cy -= tan(alpha) * w elif alpha > beta and alpha <= gamma: # Intersection at bottom edge of label try: cx += h / tan(alpha) except Exception: pass # tan(alpha) == inf cy -= h elif alpha > gamma and alpha <= gamma + 2 * beta: # Intersection at right edge of label cx -= w cy += tan(alpha) * w else: # Intersection at top edge of label try: cx -= h / tan(alpha) except Exception: pass # tan(alpha) == inf cy += h # Draw the label label_drawer.draw_at(cx - w, cy - h - yb, wrap=wrap) else: # Label is exactly in the center of the vertex cx, cy = coords half_size = vertex.size / 2.0 label_drawer.bbox = ( cx - half_size, cy - half_size, cx + half_size, cy + half_size, ) label_drawer.draw(wrap=wrap) # Construct the iterator that we will use to draw the edge labels es = graph.es if edge_order is None: # Default edge order edge_coord_iter = zip(es, edge_builder) else: # Specified edge order edge_coord_iter = ((es[i], edge_builder[i]) for i in edge_order) # Draw the edge labels for edge, visual_edge in edge_coord_iter: if visual_edge.label is None: continue # Set the font family, size, color and text context.select_font_face( visual_edge.font, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL ) context.set_font_size(visual_edge.label_size) context.set_source_rgba(*visual_edge.label_color) label_drawer.text = visual_edge.label # Ask the edge drawer to propose an anchor point for the label src, dest = edge.tuple src_vertex, dest_vertex = vertex_builder[src], vertex_builder[dest] (x, y), (halign, valign) = edge_drawer.get_label_position( edge, src_vertex, dest_vertex ) # Measure the text _, yb, w, h, _, _ = label_drawer.text_extents() w /= 2.0 h /= 2.0 # Place the text relative to the edge if halign == TextAlignment.RIGHT: x -= w elif halign == TextAlignment.LEFT: x += w if valign == TextAlignment.BOTTOM: y -= h - yb / 2.0 elif valign == TextAlignment.TOP: y += h # Draw the edge label label_drawer.halign = halign label_drawer.valign = valign label_drawer.bbox = (x - w, y - h, x + w, y + h) label_drawer.draw(wrap=wrap) ##################################################################### class UbiGraphDrawer(AbstractXMLRPCDrawer, AbstractGraphDrawer): """Graph drawer that draws a given graph on an UbiGraph display using the XML-RPC API of UbiGraph. The following vertex attributes are supported: C{color}, C{label}, C{shape}, C{size}. See the Ubigraph documentation for supported shape names. Sizes are relative to the default Ubigraph size. The following edge attributes are supported: C{color}, C{label}, C{width}. Edge widths are relative to the default Ubigraph width. All color specifications supported by igraph (e.g., color names, palette indices, RGB triplets, RGBA quadruplets, HTML format) are understood by the Ubigraph graph drawer. The drawer also has two attributes, C{vertex_defaults} and C{edge_defaults}. These are dictionaries that can be used to set default values for the vertex/edge attributes in Ubigraph. @deprecated: UbiGraph has not received updates since 2008 and is now not available for download (at least not from the official sources). The UbiGraph graph drawer will be removed from igraph in 0.10.0. """ def __init__(self, url="http://localhost:20738/RPC2"): """Constructs an UbiGraph drawer using the display at the given URL.""" super().__init__(url, "ubigraph") self.vertex_defaults = dict(color="#ff0000", shape="cube", size=1.0) self.edge_defaults = dict(color="#ffffff", width=1.0) warn( "UbiGraphDrawer is deprecated from igraph 0.9.4", DeprecationWarning ) def draw(self, graph, *args, **kwds): """Draws the given graph on an UbiGraph display. @keyword clear: whether to clear the current UbiGraph display before plotting. Default: C{True}.""" display = self.service # Clear the display and set the default visual attributes if kwds.get("clear", True): display.clear() for k, v in self.vertex_defaults.items(): display.set_vertex_style_attribute(0, k, str(v)) for k, v in self.edge_defaults.items(): display.set_edge_style_attribute(0, k, str(v)) # Custom color converter function def color_conv(color): return color_to_html_format(color_name_to_rgb(color)) # Construct the visual vertex/edge builders class VisualVertexBuilder(AttributeCollectorBase): """Collects some visual properties of a vertex for drawing""" _kwds_prefix = "vertex_" color = (str(self.vertex_defaults["color"]), color_conv) label = None shape = str(self.vertex_defaults["shape"]) size = float(self.vertex_defaults["size"]) class VisualEdgeBuilder(AttributeCollectorBase): """Collects some visual properties of an edge for drawing""" _kwds_prefix = "edge_" color = (str(self.edge_defaults["color"]), color_conv) label = None width = float(self.edge_defaults["width"]) vertex_builder = VisualVertexBuilder(graph.vs, kwds) edge_builder = VisualEdgeBuilder(graph.es, kwds) # Add the vertices n = graph.vcount() new_vertex = display.new_vertex vertex_ids = [new_vertex() for _ in range(n)] # Add the edges new_edge = display.new_edge eids = [ new_edge(vertex_ids[edge.source], vertex_ids[edge.target]) for edge in graph.es ] # Add arrowheads if needed if graph.is_directed(): display.set_edge_style_attribute(0, "arrow", "true") # Set the vertex attributes set_attr = display.set_vertex_attribute vertex_defaults = self.vertex_defaults for vertex_id, vertex in zip(vertex_ids, vertex_builder): if vertex.color != vertex_defaults["color"]: set_attr(vertex_id, "color", vertex.color) if vertex.label: set_attr(vertex_id, "label", str(vertex.label)) if vertex.shape != vertex_defaults["shape"]: set_attr(vertex_id, "shape", vertex.shape) if vertex.size != vertex_defaults["size"]: set_attr(vertex_id, "size", str(vertex.size)) # Set the edge attributes set_attr = display.set_edge_attribute edge_defaults = self.edge_defaults for edge_id, edge in zip(eids, edge_builder): if edge.color != edge_defaults["color"]: set_attr(edge_id, "color", edge.color) if edge.label: set_attr(edge_id, "label", edge.label) if edge.width != edge_defaults["width"]: set_attr(edge_id, "width", str(edge.width)) ##################################################################### class CytoscapeGraphDrawer(AbstractXMLRPCDrawer, AbstractGraphDrawer): """Graph drawer that sends/receives graphs to/from Cytoscape using CytoscapeRPC. This graph drawer cooperates with U{Cytoscape} using U{CytoscapeRPC}. You need to install the CytoscapeRPC plugin first and start the XML-RPC server on a given port (port 9000 by default) from the appropriate Plugins submenu in Cytoscape. Graph, vertex and edge attributes are transferred to Cytoscape whenever possible (i.e. when a suitable mapping exists between a Python type and a Cytoscape type). If there is no suitable Cytoscape type for a Python type, the drawer will use a string attribute on the Cytoscape side and invoke C{str()} on the Python attributes. If an attribute to be created on the Cytoscape side already exists with a different type, an underscore will be appended to the attribute name to resolve the type conflict. You can use the C{network_id} attribute of this class to figure out the network ID of the last graph drawn with this drawer. """ def __init__(self, url="http://localhost:9000/Cytoscape"): """Constructs a Cytoscape graph drawer using the XML-RPC interface of Cytoscape at the given URL.""" super().__init__(url, "Cytoscape") self.network_id = None def draw(self, graph, name="Network from igraph", create_view=True, *args, **kwds): """Sends the given graph to Cytoscape as a new network. @param name: the name of the network in Cytoscape. @param create_view: whether to create a view for the network in Cytoscape.The default is C{True}. @keyword node_ids: specifies the identifiers of the nodes to be used in Cytoscape. This must either be the name of a vertex attribute or a list specifying the identifiers, one for each node in the graph. The default is C{None}, which simply uses the vertex index for each vertex.""" from xmlrpc.client import Fault cy = self.service # Create the network if not create_view: try: network_id = cy.createNetwork(name, False) except Fault: warn( "CytoscapeRPC too old, cannot create network without view." " Consider upgrading CytoscapeRPC to use this feature." ) network_id = cy.createNetwork(name) else: network_id = cy.createNetwork(name) self.network_id = network_id # Create the nodes if "node_ids" in kwds: node_ids = kwds["node_ids"] if isinstance(node_ids, str): node_ids = graph.vs[node_ids] else: node_ids = list(range(graph.vcount())) node_ids = [str(identifier) for identifier in node_ids] cy.createNodes(network_id, node_ids) # Create the edges edgelists = [[], []] for v1, v2 in graph.get_edgelist(): edgelists[0].append(node_ids[v1]) edgelists[1].append(node_ids[v2]) edge_ids = cy.createEdges( network_id, edgelists[0], edgelists[1], ["unknown"] * graph.ecount(), [graph.is_directed()] * graph.ecount(), False, ) if "layout" in kwds: # Calculate/get the layout of the graph layout = self.ensure_layout(kwds["layout"], graph) size = 100 * graph.vcount() ** 0.5 layout.fit_into((size, size), keep_aspect_ratio=True) layout.translate(-size / 2.0, -size / 2.0) cy.setNodesPositions(network_id, node_ids, *list(zip(*list(layout)))) else: # Ask Cytoscape to perform the default layout so the user can # at least see something in Cytoscape while the attributes are # being transferred cy.performDefaultLayout(network_id) # Send the network attributes attr_names = set(cy.getNetworkAttributeNames()) for attr in graph.attributes(): cy_type, value = self.infer_cytoscape_type([graph[attr]]) value = value[0] if value is None: continue # Resolve type conflicts (if any) try: while ( attr in attr_names and cy.getNetworkAttributeType(attr) != cy_type ): attr += "_" except Fault: # getNetworkAttributeType is not available in some older versions # so we simply pass here pass cy.addNetworkAttributes(attr, cy_type, {network_id: value}) # Send the node attributes attr_names = set(cy.getNodeAttributeNames()) for attr in graph.vertex_attributes(): cy_type, values = self.infer_cytoscape_type(graph.vs[attr]) values = dict(pair for pair in zip(node_ids, values) if pair[1] is not None) # Resolve type conflicts (if any) while attr in attr_names and cy.getNodeAttributeType(attr) != cy_type: attr += "_" # Send the attribute values cy.addNodeAttributes(attr, cy_type, values, True) # Send the edge attributes attr_names = set(cy.getEdgeAttributeNames()) for attr in graph.edge_attributes(): cy_type, values = self.infer_cytoscape_type(graph.es[attr]) values = dict(pair for pair in zip(edge_ids, values) if pair[1] is not None) # Resolve type conflicts (if any) while attr in attr_names and cy.getEdgeAttributeType(attr) != cy_type: attr += "_" # Send the attribute values cy.addEdgeAttributes(attr, cy_type, values) def fetch(self, name=None, directed=False, keep_canonical_names=False): """Fetches the network with the given name from Cytoscape. When fetching networks from Cytoscape, the C{canonicalName} attributes of vertices and edges are not converted by default. Use the C{keep_canonical_names} parameter to retrieve these attributes as well. @param name: the name of the network in Cytoscape. @param directed: whether the network is directed. @param keep_canonical_names: whether to keep the C{canonicalName} vertex/edge attributes that are added automatically by Cytoscape @return: an appropriately constructed igraph L{Graph}.""" from igraph import Graph cy = self.service # Check the version number. Anything older than 1.3 is bad. version = cy.version() if " " in version: version = version.split(" ")[0] version = tuple(map(int, version.split(".")[:2])) if version < (1, 3): raise NotImplementedError( "CytoscapeGraphDrawer requires " "Cytoscape-RPC 1.3 or newer" ) # Find out the ID of the network we are interested in if name is None: network_id = cy.getNetworkID() else: network_id = [k for k, v in cy.getNetworkList().items() if v == name] if not network_id: raise ValueError("no such network: %r" % name) elif len(network_id) > 1: raise ValueError("more than one network exists with name: %r" % name) network_id = network_id[0] # Fetch the list of all the nodes and edges vertices = cy.getNodes(network_id) edges = cy.getEdges(network_id) n, m = len(vertices), len(edges) # Fetch the graph attributes graph_attrs = cy.getNetworkAttributes(network_id) # Fetch the vertex attributes vertex_attr_names = cy.getNodeAttributeNames() vertex_attrs = {} for attr_name in vertex_attr_names: if attr_name == "canonicalName" and not keep_canonical_names: continue has_attr = cy.nodesHaveAttribute(attr_name, vertices) filtered = [idx for idx, ok in enumerate(has_attr) if ok] values = cy.getNodesAttributes( attr_name, [name for name, ok in zip(vertices, has_attr) if ok] ) attrs = [None] * n for idx, value in zip(filtered, values): attrs[idx] = value vertex_attrs[attr_name] = attrs # Fetch the edge attributes edge_attr_names = cy.getEdgeAttributeNames() edge_attrs = {} for attr_name in edge_attr_names: if attr_name == "canonicalName" and not keep_canonical_names: continue has_attr = cy.edgesHaveAttribute(attr_name, edges) filtered = [idx for idx, ok in enumerate(has_attr) if ok] values = cy.getEdgesAttributes( attr_name, [name for name, ok in zip(edges, has_attr) if ok] ) attrs = [None] * m for idx, value in zip(filtered, values): attrs[idx] = value edge_attrs[attr_name] = attrs # Create a vertex name index vertex_name_index = dict((v, k) for k, v in enumerate(vertices)) del vertices # Remap the edges list to numeric IDs edge_list = [] for edge in edges: parts = edge.split() edge_list.append((vertex_name_index[parts[0]], vertex_name_index[parts[2]])) del edges return Graph( n, edge_list, directed=directed, graph_attrs=graph_attrs, vertex_attrs=vertex_attrs, edge_attrs=edge_attrs, ) @staticmethod def infer_cytoscape_type(values): """Returns a Cytoscape type that can be used to represent all the values in `values` and an appropriately converted copy of `values` that is suitable for an XML-RPC call. Note that the string type in Cytoscape is used as a catch-all type; if no other type fits, attribute values will be converted to string and then posted to Cytoscape. ``None`` entries are allowed in `values`, they will be ignored on the Cytoscape side. """ types = [type(value) for value in values if value is not None] if all(t == bool for t in types): return "BOOLEAN", values if all(issubclass(t, (int, int)) for t in types): return "INTEGER", values if all(issubclass(t, float) for t in types): return "FLOATING", values return "STRING", [ str(value) if not isinstance(value, str) else value for value in values ] ##################################################################### class GephiGraphStreamingDrawer(AbstractGraphDrawer): """Graph drawer that sends a graph to a file-like object (e.g., socket, URL connection, file) using the Gephi graph streaming format. The Gephi graph streaming format is a simple JSON-based format that can be used to post mutations to a graph (i.e. node and edge additions, removals and updates) to a remote component. For instance, one can open up Gephi (U{http://www.gephi.org}), install the Gephi graph streaming plugin and then send a graph from igraph straight into the Gephi window by using C{GephiGraphStreamingDrawer} with the appropriate URL where Gephi is listening. The C{connection} property exposes the L{GephiConnection} that the drawer uses. The drawer also has a property called C{streamer} which exposes the underlying L{GephiGraphStreamer} that is responsible for generating the JSON objects, encoding them and writing them to a file-like object. If you want to customize the encoding process, this is the object where you can tweak things to your taste. """ def __init__(self, conn=None, *args, **kwds): """Constructs a Gephi graph streaming drawer that will post graphs to the given Gephi connection. If C{conn} is C{None}, the remaining arguments of the constructor are forwarded intact to the constructor of L{GephiConnection} in order to create a connection. This means that any of the following are valid: - C{GephiGraphStreamingDrawer()} will construct a drawer that connects to workspace 0 of the local Gephi instance on port 8080. - C{GephiGraphStreamingDrawer(workspace=2)} will connect to workspace 2 of the local Gephi instance on port 8080. - C{GephiGraphStreamingDrawer(port=1234)} will connect to workspace 0 of the local Gephi instance on port 1234. - C{GephiGraphStreamingDrawer(host="remote", port=1234, workspace=7)} will connect to workspace 7 of the Gephi instance on host C{remote}, port 1234. - C{GephiGraphStreamingDrawer(url="http://remote:1234/workspace7)} is the same as above, but with an explicit URL. """ super().__init__() from igraph.remote.gephi import GephiGraphStreamer, GephiConnection self.connection = conn or GephiConnection(*args, **kwds) self.streamer = GephiGraphStreamer() def draw(self, graph, *args, **kwds): """Draws (i.e. sends) the given graph to the destination of the drawer using the Gephi graph streaming API. The following keyword arguments are allowed: - ``encoder`` lets one specify an instance of ``json.JSONEncoder`` that will be used to encode the JSON objects. """ self.streamer.post(graph, self.connection, encoder=kwds.get("encoder")) ##################################################################### class MatplotlibGraphDrawer(AbstractGraphDrawer): """Graph drawer that uses a pyplot.Axes as context""" _shape_dict = { "rectangle": "s", "circle": "o", "hidden": "none", "triangle-up": "^", "triangle-down": "v", } def __init__(self, ax): """Constructs the graph drawer and associates it with the mpl axes""" self.ax = ax def draw(self, graph, *args, **kwds): # NOTE: matplotlib has numpy as a dependency, so we can use it in here from collections import defaultdict import matplotlib as mpl import matplotlib.markers as mmarkers from matplotlib.path import Path from matplotlib.patches import FancyArrowPatch from matplotlib.patches import ArrowStyle import numpy as np # Deferred import to avoid a cycle in the import graph from igraph.clustering import VertexClustering, VertexCover def shrink_vertex(ax, aux, vcoord, vsize_squared): """Shrink edge by vertex size""" aux_display, vcoord_display = ax.transData.transform([aux, vcoord]) d = sqrt(((aux_display - vcoord_display) ** 2).sum()) fr = sqrt(vsize_squared) / d if d > 0 else 0 end_display = vcoord_display + fr * (aux_display - vcoord_display) end = ax.transData.inverted().transform(end_display) return end def callback_factory(ax, vcoord, vsizes, arrows): def callback_edge_offset(event): for arrow, src, tgt in arrows: v1, v2 = vcoord[src], vcoord[tgt] # This covers both cases (curved and straight) aux1, aux2 = arrow._path_original.vertices[[1, -2]] start = shrink_vertex(ax, aux1, v1, vsizes[src]) end = shrink_vertex(ax, aux2, v2, vsizes[tgt]) arrow._path_original.vertices[0] = start arrow._path_original.vertices[-1] = end return callback_edge_offset ax = self.ax # FIXME: deal with unnamed *args # graph is not necessarily a graph, it can be a VertexClustering. If so # extract the graph. The clustering itself can be overridden using # the "mark_groups" option clustering = None if isinstance(graph, (VertexClustering, VertexCover)): clustering = graph graph = clustering.graph # Get layout layout = kwds.get("layout", graph.layout()) if isinstance(layout, str): layout = graph.layout(layout) # Vertex coordinates vcoord = layout.coords # mark groups: the used data structure is eventually the dict option: # tuples of vertex indices as the keys, colors as the values. We # convert other formats into that one here if "mark_groups" not in kwds: kwds["mark_groups"] = False if kwds["mark_groups"] is False: pass elif (kwds["mark_groups"] is True) and (clustering is not None): pass elif isinstance(kwds["mark_groups"], (VertexClustering, VertexCover)): if clustering is not None: raise ValueError( "mark_groups cannot override a clustering with another" ) else: clustering = kwds["mark_groups"] kwds["mark_groups"] = True else: try: mg_iter = iter(kwds["mark_groups"]) except TypeError: raise TypeError("mark_groups is not in the right format") kwds["mark_groups"] = dict(mg_iter) # If a clustering is set and marks are requested but without a specific # colormap, make the colormap # Two things need coloring: vertices and groups/clusters (polygon) # The coloring needs to be coordinated between the two. if clustering is not None: # If mark_groups is a dict, we don't need a default color dict, we # can just use the mark_groups dict. If mark_groups is False and # vertex_color is set, we don't need either because the colors are # already fully specified. In all other cases, we need a default # color dict. if isinstance(kwds["mark_groups"], dict): group_colordict = kwds["mark_groups"] elif (kwds["mark_groups"] is False) and ("vertex_color" in kwds): pass else: membership = clustering.membership if isinstance(clustering, VertexCover): membership = [x[0] for x in membership] clusters = sorted(set(membership)) n_colors = len(clusters) cmap = mpl.cm.get_cmap("viridis") colors = [cmap(1.0 * i / n_colors) for i in range(n_colors)] cluster_colordict = {g: c for g, c in zip(clusters, colors)} # mark_groups if not explicitly marked group_colordict = defaultdict(list) for i, g in enumerate(membership): color = cluster_colordict[g] group_colordict[color].append(i) del cluster_colordict # Invert keys and values group_colordict = {tuple(v): k for k, v in group_colordict.items()} # If mark_groups is set but not defined, make a default colormap if kwds["mark_groups"] is True: kwds["mark_groups"] = group_colordict if "vertex_color" not in kwds: kwds["vertex_color"] = ['none' for m in membership] for group_vs, color in group_colordict.items(): for i in group_vs: kwds["vertex_color"][i] = color # Now mark_groups is either a dict or False # If vertex_color is not set, we can rely on mark_groups if a dict, # else we need to make up the same colormap as if we were requested groups if "vertex_color" not in kwds: if isinstance(kwds["mark_groups"], dict): membership = clustering.membership if isinstance(clustering, VertexCover): membership = [x[0] for x in membership] # Mark groups if "mark_groups" in kwds and isinstance(kwds["mark_groups"], dict): for idx, color in kwds["mark_groups"].items(): points = [vcoord[i] for i in idx] vertices = np.asarray(convex_hull(points, coords=True)) # 15% expansion vertices += 0.15 * (vertices - vertices.mean(axis=0)) # NOTE: we could include a corner cutting algorithm close to # the vertices (e.g. Chaikin) for beautification, or a corner # radius like it's done in the Cairo interface polygon = mpl.patches.Polygon( vertices, facecolor=color, alpha=0.3, zorder=0, edgecolor=color, lw=2, ) ax.add_artist(polygon) # Vertex properties nv = graph.vcount() # Vertex size vsizes = kwds.get("vertex_size", 5) # Enforce numpy array for sizes, because (1) we need the square and (2) # they are needed to calculate autoshrinking of edges if np.isscalar(vsizes): vsizes = np.repeat(vsizes, nv) else: vsizes = np.asarray(vsizes) # ax.scatter uses the *square* of diameter vsizes **= 2 # Vertex color c = kwds.get("vertex_color", "steelblue") # Vertex opacity alpha = kwds.get("alpha", 1.0) # Vertex labels label = kwds.get("vertex_label", None) # Vertex label size label_size = kwds.get("vertex_label_size", mpl.rcParams["font.size"]) # Vertex zorder vzorder = kwds.get("vertex_order", 2) # Vertex shapes # mpl shapes use slightly different names from Cairo, but we want the # API to feel consistent, so we use a conversion dictionary shapes = kwds.get("vertex_shape", "o") if shapes is not None: if isinstance(shapes, str): shapes = self._shape_dict.get(shapes, shapes) elif isinstance(shapes, mmarkers.MarkerStyle): pass # Scatter vertices x, y = list(zip(*vcoord)) ax.scatter(x, y, s=vsizes, c=c, marker=shapes, zorder=vzorder, alpha=alpha) # Vertex labels if label is not None: for i, lab in enumerate(label): xi, yi = x[i], y[i] ax.text(xi, yi, lab, fontsize=label_size) # Find the X and Y range of coordinates; use a minimum range even if there # is only one vertex to avoid singularities and division by zero later dx, dy = max(x) - min(x), max(y) - min(y) if dx <= 0: dx = 1 ax.set_xlim(min(x) - dx / 2, max(x) + dx / 2) else: ax.set_xlim(min(x) - 0.05 * dx, max(x) + 0.05 * dx) if dy <= 0: dy = 1 ax.set_ylim(min(y) - dy / 2, max(y) + dy / 2) else: ax.set_ylim(min(y) - 0.05 * dy, max(y) + 0.05 * dy) # Edge properties ne = graph.ecount() ec = kwds.get("edge_color", "black") edge_width = kwds.get("edge_width", 1) arrow_width = kwds.get("edge_arrow_width", 2) arrow_length = kwds.get("edge_arrow_size", 4) ealpha = kwds.get("edge_alpha", 1.0) ezorder = kwds.get("edge_order", 1.0) try: ezorder = float(ezorder) ezorder = [ezorder] * ne except TypeError: pass # Decide whether we need to calculate the curvature of edges # automatically -- and calculate them if needed. autocurve = kwds.get("autocurve", None) if autocurve or ( autocurve is None and "edge_curved" not in kwds and "curved" not in graph.edge_attributes() and graph.ecount() < 10000 ): from igraph import autocurve default = kwds.get("edge_curved", 0) if default is True: default = 0.5 default = float(default) ecurved = autocurve(graph, attribute=None, default=default) elif "edge_curved" in kwds: ecurved = kwds["edge_curved"] elif "curved" in graph.edge_attributes(): ecurved = graph.es["curved"] else: ecurved = [0] * ne # Arrow style for directed and undirected graphs if graph.is_directed(): arrowstyle = ArrowStyle( "-|>", head_length=arrow_length, head_width=arrow_width, ) else: arrowstyle = "-" # Edge coordinates and curvature nloops = [0 for x in range(ne)] arrows = [] for ie, edge in enumerate(graph.es): src, tgt = edge.source, edge.target x1, y1 = vcoord[src] x2, y2 = vcoord[tgt] # Loops require special treatment if src == tgt: # Find all non-loop edges nloopstot = 0 angles = [] for tgtn in graph.neighbors(src): if tgtn == src: nloopstot += 1 continue xn, yn = vcoord[tgtn] angles.append(180.0 / pi * atan2(yn - y1, xn - x1) % 360) # with .neighbors(mode=ALL), which is default, loops are double # counted nloopstot //= 2 angles = sorted(set(angles)) # Only loops or one non-loop if len(angles) < 2: ashift = angles[0] if angles else 270 if nloopstot == 1: # Only one self loop, use a quadrant only angles = [(ashift + 135) % 360, (ashift + 225) % 360] else: nshift = 360.0 / nloopstot angles = [ (ashift + nshift * nloops[src]) % 360, (ashift + nshift * (nloops[src] + 1)) % 360, ] nloops[src] += 1 else: angles.append(angles[0] + 360) idiff = 0 diff = 0 for i in range(len(angles) - 1): diffi = abs(angles[i + 1] - angles[i]) if diffi > diff: idiff = i diff = diffi angles = angles[idiff : idiff + 2] ashift = angles[0] nshift = (angles[1] - angles[0]) / nloopstot angles = [ (ashift + nshift * nloops[src]), (ashift + nshift * (nloops[src] + 1)), ] nloops[src] += 1 # this is not great, but alright angspan = angles[1] - angles[0] if angspan < 180: angmid1 = angles[0] + 0.1 * angspan angmid2 = angles[1] - 0.1 * angspan else: angmid1 = angles[0] + 0.5 * (angspan - 180) + 45 angmid2 = angles[1] - 0.5 * (angspan - 180) - 45 aux1 = ( x1 + 0.2 * dx * cos(pi / 180 * angmid1), y1 + 0.2 * dy * sin(pi / 180 * angmid1), ) aux2 = ( x1 + 0.2 * dx * cos(pi / 180 * angmid2), y1 + 0.2 * dy * sin(pi / 180 * angmid2), ) start = shrink_vertex(ax, aux1, (x1, y1), vsizes[src]) end = shrink_vertex(ax, aux2, (x2, y2), vsizes[tgt]) path = Path( [start, aux1, aux2, end], # Cubic bezier by mpl codes=[1, 4, 4, 4], ) else: curved = ecurved[ie] if curved: aux1 = (2 * x1 + x2) / 3.0 - curved * 0.5 * (y2 - y1), ( 2 * y1 + y2 ) / 3.0 + curved * 0.5 * (x2 - x1) aux2 = (x1 + 2 * x2) / 3.0 - curved * 0.5 * (y2 - y1), ( y1 + 2 * y2 ) / 3.0 + curved * 0.5 * (x2 - x1) start = shrink_vertex(ax, aux1, (x1, y1), vsizes[src]) end = shrink_vertex(ax, aux2, (x2, y2), vsizes[tgt]) path = Path( [start, aux1, aux2, end], # Cubic bezier by mpl codes=[1, 4, 4, 4], ) else: start = shrink_vertex(ax, (x2, y2), (x1, y1), vsizes[src]) end = shrink_vertex(ax, (x1, y1), (x2, y2), vsizes[tgt]) path = Path([start, end], codes=[1, 2]) arrow = FancyArrowPatch( path=path, arrowstyle=arrowstyle, lw=edge_width, color=ec, alpha=ealpha, zorder=ezorder[ie], ) ax.add_artist(arrow) # Store arrows and their sources and targets for autoscaling arrows.append((arrow, src, tgt)) # Autoscaling during zoom, figure resize, reset axis limits callback = callback_factory(ax, vcoord, vsizes, arrows) ax.get_figure().canvas.mpl_connect("resize_event", callback) ax.callbacks.connect("xlim_changed", callback) ax.callbacks.connect("ylim_changed", callback) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/metamagic.py0000644000175100001710000003310500000000000021602 0ustar00runnerdocker00000000000000"""Auxiliary classes for the default graph drawer in igraph. This module contains heavy metaclass magic. If you don't understand the logic behind these classes, probably you don't need them either. igraph's default graph drawer uses various data sources to determine the visual appearance of vertices and edges. These data sources are the following (in order of precedence): - The keyword arguments passed to the L{igraph.plot()} function (or to L{igraph.Graph.__plot__()} as a matter of fact, since L{igraph.plot()} just passes these attributes on). For instance, a keyword argument named C{vertex_label} can be used to set the labels of vertices. - The attributes of the vertices/edges being drawn. For instance, a vertex that has a C{label} attribute will use that label when drawn by the default graph drawer. - The global configuration of igraph. For instance, if the global L{igraph.config.Configuration} instance has a key called C{plotting.vertex_color}, that will be used as a default color for the vertices. - If all else fails, there is a built-in default; for instance, the default vertex color is C{"red"}. This is hard-wired in the source code. The logic above can be useful in other graph drawers as well, not only in the default one, therefore it is refactored into the classes found in this module. Different graph drawers may inspect different vertex or edge attributes, hence the classes that collect the attributes from the various data sources are generated in run-time using a metaclass called L{AttributeCollectorMeta}. You don't have to use L{AttributeCollectorMeta} directly, just implement a subclass of L{AttributeCollectorBase} and it will ensure that the appropriate metaclass is used. With L{AttributeCollectorBase}, you can use a simple declarative syntax to specify which attributes you are interested in. For example:: class VisualEdgeBuilder(AttributeCollectorBase): arrow_size = 1.0 arrow_width = 1.0 color = ("black", palette.get) width = 1.0 for edge in VisualEdgeBuilder(graph.es): print edge.color The above class is a visual edge builder -- a class that gives the visual attributes of the edges of a graph that is specified at construction time. It specifies that the attributes we are interested in are C{arrow_size}, C{arrow_width}, C{color} and C{width}; the default values are also given. For C{color}, we also specify that a method called {palette.get} should be called on every attribute value to translate color names to RGB values. For the other three attributes, C{float} will implicitly be called on all attribute values, this is inferred from the type of the default value itself. @see: AttributeCollectorMeta, AttributeCollectorBase """ from configparser import NoOptionError from igraph.configuration import Configuration __all__ = ("AttributeSpecification", "AttributeCollectorBase") class AttributeSpecification: """Class that describes how the value of a given attribute should be retrieved. The class contains the following members: - C{name}: the name of the attribute. This is also used when we are trying to get its value from a vertex/edge attribute of a graph. - C{alt_name}: alternative name of the attribute. This is used when we are trying to get its value from a Python dict or an L{igraph.Configuration} object. If omitted at construction time, it will be equal to C{name}. - C{default}: the default value of the attribute when none of the sources we try can provide a meaningful value. - C{transform}: optional transformation to be performed on the attribute value. If C{None} or omitted, it defaults to the type of the default value. - C{func}: when given, this function will be called with an index in order to derive the value of the attribute. """ __slots__ = ("name", "alt_name", "default", "transform", "accessor", "func") def __init__(self, name, default=None, alt_name=None, transform=None, func=None): if isinstance(default, tuple): default, transform = default self.name = name self.default = default self.alt_name = alt_name or name self.transform = transform or None self.func = func self.accessor = None if self.transform and not hasattr(self.transform, "__call__"): raise TypeError("transform must be callable") if self.transform is None and self.default is not None: self.transform = type(self.default) class AttributeCollectorMeta(type): """Metaclass for attribute collector classes Classes that use this metaclass are intended to collect vertex/edge attributes from various sources (a Python dict, a vertex/edge sequence, default values from the igraph configuration and such) in a given order of precedence. See the module documentation for more details. This metaclass enables the user to use a simple declarative syntax to specify which attributes he is interested in. For each vertex/edge attribute, a corresponding class attribute must be defined with a value that describes the default value of that attribute if no other data source provides us with any suitable value. The default value can also be a tuple; in that case, the first element of the tuple is the actual default value, the second element is a converter function that will convert the attribute values to a format expected by the caller who uses the class being defined. There is a special class attribute called C{_kwds_prefix}; this is not used as an attribute declaration. It can contain a string which will be used to derive alternative names for the attributes when the attribute is accessed in a Python dict. This is useful in many situations; for instance, the default graph drawer would want to access the vertex colors using the C{color} vertex attribute, but when it looks at the keyword arguments passed to the original call of L{igraph.Graph.__plot__}, the C{vertex_color} keyword argument should be looked up because we also have colors for the edges. C{_kwds_prefix} will be prepended to the attribute names when they are looked up in a dict of keyword arguments. If you require a more fine-tuned behaviour, you can assign an L{AttributeSpecification} instance to a class attribute directly. @see: AttributeCollectorBase """ def __new__(mcs, name, bases, attrs): attr_specs = [] for attr, value in attrs.items(): if attr.startswith("_") or hasattr(value, "__call__"): continue if isinstance(value, AttributeSpecification): attr_spec = value elif isinstance(value, dict): attr_spec = AttributeSpecification(attr, **value) else: attr_spec = AttributeSpecification(attr, value) attr_specs.append(attr_spec) prefix = attrs.get("_kwds_prefix", None) if prefix: for attr_spec in attr_specs: if attr_spec.name == attr_spec.alt_name: attr_spec.alt_name = "%s%s" % (prefix, attr_spec.name) attrs["_attributes"] = attr_specs attrs["Element"] = mcs.record_generator( "%s.Element" % name, (attr_spec.name for attr_spec in attr_specs) ) return super().__new__(mcs, name, bases, attrs) @classmethod def record_generator(mcs, name, slots): """Generates a simple class that has the given slots and nothing else""" class Element: """A simple class that holds the attributes collected by the attribute collector""" __slots__ = tuple(slots) def __init__(self, attrs=()): for attr, value in attrs: setattr(self, attr, value) Element.__name__ = name return Element class AttributeCollectorBase(object, metaclass=AttributeCollectorMeta): """Base class for attribute collector subclasses. Classes that inherit this class may use a declarative syntax to specify which vertex or edge attributes they intend to collect. See L{AttributeCollectorMeta} for the details. """ def __init__(self, seq, kwds=None): """Constructs a new attribute collector that uses the given vertex/edge sequence and the given dict as data sources. @param seq: an L{igraph.VertexSeq} or L{igraph.EdgeSeq} class that will be used as a data source for attributes. @param kwds: a Python dict that will be used to override the attributes collected from I{seq} if necessary. """ elt = self.__class__.Element self._cache = [elt() for _ in range(len(seq))] self.seq = seq self.kwds = kwds or {} for attr_spec in self._attributes: values = self._collect_attributes(attr_spec) attr_name = attr_spec.name for cache_elt, val in zip(self._cache, values): setattr(cache_elt, attr_name, val) def _collect_attributes(self, attr_spec, config=None): """Collects graph visualization attributes from various sources. This method can be used to collect the attributes required for graph visualization from various sources. Attribute value sources are: - A specific value of a Python dict belonging to a given key. This dict is given by the argument M{self.kwds} at construction time, and the name of the key is determined by the argument specification given in M{attr_spec}. - A vertex or edge sequence of a graph, given in M{self.seq} - The global configuration, given in M{config} - A default value when all other sources fail to provide the value. This is also given in M{attr_spec}. @param attr_spec: an L{AttributeSpecification} object which contains the name of the attribute when it is coming from a list of Python keyword arguments, the name of the attribute when it is coming from the graph attributes directly, the default value of the attribute and an optional callable transformation to call on the values. This can be used to ensure that the attributes are of a given type. @param config: a L{Configuration} object to be used for determining the defaults if all else fails. If C{None}, the global igraph configuration will be used @return: the collected attributes """ kwds = self.kwds seq = self.seq n = len(seq) # Special case if the attribute name is "label" if attr_spec.name == "label": if attr_spec.alt_name in kwds and kwds[attr_spec.alt_name] is None: return [None] * n # If the attribute uses an external callable to derive the attribute # values, call it and store the results if attr_spec.func is not None: func = attr_spec.func result = [func(i) for i in range(n)] return result # Get the configuration object if config is None: config = Configuration.instance() # Fetch the defaults from the vertex/edge sequence try: attrs = seq[attr_spec.name] except KeyError: attrs = None # Override them from the keyword arguments (if any) result = kwds.get(attr_spec.alt_name, None) if attrs: if not result: result = attrs else: if isinstance(result, str): result = [result] * n try: len(result) except TypeError: result = [result] * n result = [result[idx] or attrs[idx] for idx in range(len(result))] # Special case for string overrides, strings are not treated # as sequences here if isinstance(result, str): result = [result] * n # If the result is still not a sequence, make it one try: len(result) except TypeError: result = [result] * n # If it is not a list, ensure that it is a list if not hasattr(result, "extend"): result = list(result) # Ensure that the length is n while len(result) < n: if len(result) <= n / 2: result.extend(result) else: result.extend(result[0 : (n - len(result))]) # By now, the length of the result vector should be n as requested # Get the configuration defaults try: default = config["plotting.%s" % attr_spec.alt_name] except NoOptionError: default = None if default is None: default = attr_spec.default # Fill the None values with the default values for idx in range(len(result)): if result[idx] is None: result[idx] = default # Finally, do the transformation if attr_spec.transform is not None: transform = attr_spec.transform result = [transform(x) for x in result] return result def __getitem__(self, index): """Returns the collected attributes of the vertex/edge with the given index.""" return self._cache[index] def __len__(self): return len(self.seq) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/shapes.py0000644000175100001710000003752200000000000021145 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Shape drawing classes for igraph Vertex shapes in igraph are usually referred to by short names like C{"rect"} or C{"circle"}. This module contains the classes that implement the actual drawing routines for these shapes, and a resolver class that determines the appropriate shape drawer class given the short name. Classes that are derived from L{ShapeDrawer} in this module are automatically registered by L{ShapeDrawerDirectory}. If you implement a custom shape drawer, you must register it in L{ShapeDrawerDirectory} manually if you wish to refer to it by a name in the C{shape} attribute of vertices. """ __all__ = ("ShapeDrawerDirectory",) from math import atan2, copysign, cos, pi, sin import sys from igraph.drawing.baseclasses import AbstractCairoDrawer from igraph.drawing.utils import Point from igraph.utils import consecutive_pairs class ShapeDrawer: """Static class, the ancestor of all vertex shape drawer classes. Custom shapes must implement at least the C{draw_path} method of the class. The method I{must not} stroke or fill, it should just set up the current Cairo path appropriately.""" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws the path of the shape on the given Cairo context, without stroking or filling it. This method must be overridden in derived classes implementing custom shapes and declared as a static method using C{staticmethod(...)}. @param ctx: the context to draw on @param center_x: the X coordinate of the center of the object @param center_y: the Y coordinate of the center of the object @param width: the width of the object @param height: the height of the object. If C{None}, equals to the width. """ raise NotImplementedError("abstract class") @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the shape centered at (center_x, center_y) intersects with a line drawn from (source_x, source_y) to (center_x, center_y). Can be overridden in derived classes. Must always be defined as a static method using C{staticmethod(...)} @param width: the width of the shape @param height: the height of the shape. If C{None}, defaults to the width @return: the intersection point (the closest to (source_x, source_y) if there are more than one) or (center_x, center_y) if there is no intersection """ return center_x, center_y class NullDrawer(ShapeDrawer): """Static drawer class which draws nothing. This class is used for graph vertices with unknown shapes""" names = ["null", "none", "empty", "hidden", ""] @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws nothing.""" pass class RectangleDrawer(ShapeDrawer): """Static class which draws rectangular vertices""" names = "rectangle rect rectangular square box" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws a rectangle-shaped path on the Cairo context without stroking or filling it. @see: ShapeDrawer.draw_path""" height = height or width ctx.rectangle(center_x - width / 2, center_y - height / 2, width, height) @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the rectangle centered at (center_x, center_y) having the given width and height intersects with a line drawn from (source_x, source_y) to (center_x, center_y). @see: ShapeDrawer.intersection_point""" height = height or width delta_x, delta_y = center_x - source_x, center_y - source_y if delta_x == 0 and delta_y == 0: return center_x, center_y if delta_y > 0 and delta_x <= delta_y and delta_x >= -delta_y: # this is the top edge ry = center_y - height / 2 ratio = (height / 2) / delta_y return center_x - ratio * delta_x, ry if delta_y < 0 and delta_x <= -delta_y and delta_x >= delta_y: # this is the bottom edge ry = center_y + height / 2 ratio = (height / 2) / -delta_y return center_x - ratio * delta_x, ry if delta_x > 0 and delta_y <= delta_x and delta_y >= -delta_x: # this is the left edge rx = center_x - width / 2 ratio = (width / 2) / delta_x return rx, center_y - ratio * delta_y if delta_x < 0 and delta_y <= -delta_x and delta_y >= delta_x: # this is the right edge rx = center_x + width / 2 ratio = (width / 2) / -delta_x return rx, center_y - ratio * delta_y if delta_x == 0: if delta_y > 0: return center_x, center_y - height / 2 return center_x, center_y + height / 2 if delta_y == 0: if delta_x > 0: return center_x - width / 2, center_y return center_x + width / 2, center_y class CircleDrawer(ShapeDrawer): """Static class which draws circular vertices""" names = "circle circular" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws a circular path on the Cairo context without stroking or filling it. Height is ignored, it is the width that determines the diameter of the circle. @see: ShapeDrawer.draw_path""" ctx.arc(center_x, center_y, width / 2, 0, 2 * pi) @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the circle centered at (center_x, center_y) intersects with a line drawn from (source_x, source_y) to (center_x, center_y). @see: ShapeDrawer.intersection_point""" height = height or width angle = atan2(center_y - source_y, center_x - source_x) return center_x - width / 2 * cos(angle), center_y - height / 2 * sin(angle) class UpTriangleDrawer(ShapeDrawer): """Static class which draws upright triangles""" names = "triangle triangle-up up-triangle arrow arrow-up up-arrow" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws an upright triangle on the Cairo context without stroking or filling it. @see: ShapeDrawer.draw_path""" height = height or width ctx.move_to(center_x - width / 2, center_y + height / 2) ctx.line_to(center_x, center_y - height / 2) ctx.line_to(center_x + width / 2, center_y + height / 2) ctx.close_path() @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the triangle centered at (center_x, center_y) intersects with a line drawn from (source_x, source_y) to (center_x, center_y). @see: ShapeDrawer.intersection_point""" # TODO: finish it properly height = height or width return center_x, center_y class DownTriangleDrawer(ShapeDrawer): """Static class which draws triangles pointing down""" names = "down-triangle triangle-down arrow-down down-arrow" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws a triangle on the Cairo context without stroking or filling it. @see: ShapeDrawer.draw_path""" height = height or width ctx.move_to(center_x - width / 2, center_y - height / 2) ctx.line_to(center_x, center_y + height / 2) ctx.line_to(center_x + width / 2, center_y - height / 2) ctx.close_path() @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the triangle centered at (center_x, center_y) intersects with a line drawn from (source_x, source_y) to (center_x, center_y). @see: ShapeDrawer.intersection_point""" # TODO: finish it properly height = height or width return center_x, center_y class DiamondDrawer(ShapeDrawer): """Static class which draws diamonds (i.e. rhombuses)""" names = "diamond rhombus" @staticmethod def draw_path(ctx, center_x, center_y, width, height=None): """Draws a rhombus on the Cairo context without stroking or filling it. @see: ShapeDrawer.draw_path""" height = height or width ctx.move_to(center_x - width / 2, center_y) ctx.line_to(center_x, center_y + height / 2) ctx.line_to(center_x + width / 2, center_y) ctx.line_to(center_x, center_y - height / 2) ctx.close_path() @staticmethod def intersection_point(center_x, center_y, source_x, source_y, width, height=None): """Determines where the rhombus centered at (center_x, center_y) intersects with a line drawn from (source_x, source_y) to (center_x, center_y). @see: ShapeDrawer.intersection_point""" height = height or width if height == 0 and width == 0: return center_x, center_y delta_x, delta_y = source_x - center_x, source_y - center_y # Treat edge case when delta_x = 0 if delta_x == 0: if delta_y == 0: return center_x, center_y else: return center_x, center_y + copysign(height / 2, delta_y) width = copysign(width, delta_x) height = copysign(height, delta_y) f = height / (height + width * delta_y / delta_x) return center_x + f * width / 2, center_y + (1 - f) * height / 2 ##################################################################### class PolygonDrawer(AbstractCairoDrawer): """Class that is used to draw polygons. The corner points of the polygon can be set by the C{points} property of the drawer, or passed at construction time. Most drawing methods in this class also have an extra C{points} argument that can be used to override the set of points in the C{points} property.""" def __init__(self, context, bbox=(1, 1), points=[]): """Constructs a new polygon drawer that draws on the given Cairo context. @param context: the Cairo context to draw on @param bbox: ignored, leave it at its default value @param points: the list of corner points """ super().__init__(context, bbox) self.points = points def draw_path(self, points=None, corner_radius=0): """Sets up a Cairo path for the outline of a polygon on the given Cairo context. @param points: the coordinates of the corners of the polygon, in clockwise or counter-clockwise order, or C{None} if we are about to use the C{points} property of the class. @param corner_radius: if zero, an ordinary polygon will be drawn. If positive, the corners of the polygon will be rounded with the given radius. """ if points is None: points = self.points self.context.new_path() if len(points) < 2: # Well, a polygon must have at least two corner points return ctx = self.context if corner_radius <= 0: # No rounded corners, this is simple ctx.move_to(*points[-1]) for point in points: ctx.line_to(*point) return # Rounded corners. First, we will take each side of the # polygon and find what the corner radius should be on # each corner. If the side is longer than 2r (where r is # equal to corner_radius), the radius allowed by that side # is r; if the side is shorter, the radius is the length # of the side / 2. For each corner, the final corner radius # is the smaller of the radii on the two sides adjacent to # the corner. points = [Point(*point) for point in points] side_vecs = [v - u for u, v in consecutive_pairs(points, circular=True)] half_side_lengths = [side.length() / 2 for side in side_vecs] corner_radii = [corner_radius] * len(points) for idx in range(len(corner_radii)): prev_idx = -1 if idx == 0 else idx - 1 radii = [corner_radius, half_side_lengths[prev_idx], half_side_lengths[idx]] corner_radii[idx] = min(radii) # Okay, move to the last corner, adjusted by corner_radii[-1] # towards the first corner ctx.move_to(*(points[-1].towards(points[0], corner_radii[-1]))) # Now, for each point in points, draw a line towards the # corner, stopping before it in a distance of corner_radii[idx], # then draw the corner u = points[-1] for idx, (v, w) in enumerate(consecutive_pairs(points, True)): radius = corner_radii[idx] ctx.line_to(*v.towards(u, radius)) aux1 = v.towards(u, radius / 2) aux2 = v.towards(w, radius / 2) ctx.curve_to( aux1.x, aux1.y, aux2.x, aux2.y, *v.towards(w, corner_radii[idx]) ) u = v def draw(self, points=None): """Draws the polygon using the current stroke of the Cairo context. @param points: the coordinates of the corners of the polygon, in clockwise or counter-clockwise order, or C{None} if we are about to use the C{points} property of the class. """ self.draw_path(points) self.context.stroke() ##################################################################### class ShapeDrawerDirectory: """Static class that resolves shape names to their corresponding shape drawer classes. Classes that are derived from L{ShapeDrawer} in this module are automatically registered by L{ShapeDrawerDirectory} when the module is loaded for the first time. """ known_shapes = {} @classmethod def register(cls, drawer_class): """Registers the given shape drawer class under the given names. @param drawer_class: the shape drawer class to be registered """ names = drawer_class.names if isinstance(names, str): names = names.split() for name in names: cls.known_shapes[name] = drawer_class @classmethod def register_namespace(cls, namespace): """Registers all L{ShapeDrawer} classes in the given namespace @param namespace: a Python dict mapping names to Python objects.""" for name, value in namespace.items(): if name.startswith("__"): continue if isinstance(value, type): if issubclass(value, ShapeDrawer) and value != ShapeDrawer: cls.register(value) @classmethod def resolve(cls, shape): """Given a shape name, returns the corresponding shape drawer class @param shape: the name of the shape @return: the corresponding shape drawer class @raise ValueError: if the shape is unknown """ try: return cls.known_shapes[shape] except KeyError: raise ValueError("unknown shape: %s" % shape) @classmethod def resolve_default(cls, shape, default=NullDrawer): """Given a shape name, returns the corresponding shape drawer class or the given default shape drawer if the shape name is unknown. @param shape: the name of the shape @param default: the default shape drawer to return when the shape is unknown @return: the shape drawer class corresponding to the given name or the default shape drawer class if the name is unknown """ return cls.known_shapes.get(shape, default) ShapeDrawerDirectory.register_namespace(sys.modules[__name__].__dict__) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/text.py0000644000175100001710000003153400000000000020643 0ustar00runnerdocker00000000000000""" Drawers for labels on plots. """ import re from igraph.drawing.baseclasses import AbstractCairoDrawer from warnings import warn __all__ = ("TextAlignment", "TextDrawer") __docformat__ = "restructuredtext en" ##################################################################### class TextAlignment: """Text alignment constants.""" LEFT, CENTER, RIGHT = "left", "center", "right" TOP, BOTTOM = "top", "bottom" ##################################################################### class TextDrawer(AbstractCairoDrawer): """Class that draws text on a Cairo context. This class supports multi-line text unlike the original Cairo text drawing methods.""" LEFT, CENTER, RIGHT = "left", "center", "right" TOP, BOTTOM = "top", "bottom" def __init__(self, context, text="", halign="center", valign="center"): """Constructs a new instance that will draw the given `text` on the given Cairo `context`.""" super().__init__(context, (0, 0)) self.text = text self.halign = halign self.valign = valign def draw(self, wrap=False): """Draws the text in the current bounding box of the drawer. Since the class itself is an instance of `AbstractCairoDrawer`, it has an attribute named ``bbox`` which will be used as a bounding box. @param wrap: whether to allow re-wrapping of the text if it does not fit within the bounding box horizontally. """ ctx = self.context bbox = self.bbox text_layout = self.get_text_layout(bbox.left, bbox.top, bbox.width, wrap) if not text_layout: return _, font_descent, line_height = ctx.font_extents()[:3] yb = ctx.text_extents(text_layout[0][2])[1] total_height = len(text_layout) * line_height if self.valign == self.BOTTOM: # Bottom vertical alignment dy = bbox.height - total_height - yb + font_descent elif self.valign == self.CENTER: # Centered vertical alignment dy = (bbox.height - total_height - yb + font_descent + line_height) / 2.0 else: # Top vertical alignment dy = line_height for ref_x, ref_y, line in text_layout: ctx.move_to(ref_x, ref_y + dy) ctx.show_text(line) ctx.new_path() def get_text_layout(self, x=None, y=None, width=None, wrap=False): """Calculates the layout of the current text. `x` and `y` denote the coordinates where the drawing should start. If they are both ``None``, the current position of the context will be used. Vertical alignment settings are not taken into account in this method as the text is not drawn within a box. @param x: The X coordinate of the reference point where the layout should start. @param y: The Y coordinate of the reference point where the layout should start. @param width: The width of the box in which the text will be fitted. It matters only when the text is right-aligned or centered. The text will overflow the box if any of the lines is longer than the box width and `wrap` is ``False``. @param wrap: whether to allow re-wrapping of the text if it does not fit within the given width. @return: a list consisting of ``(x, y, line)`` tuples where ``x`` and ``y`` refer to reference points on the Cairo canvas and ``line`` refers to the corresponding text that should be plotted there. """ ctx = self.context if x is None or y is None: x, y = ctx.get_current_point() line_height = ctx.font_extents()[2] if wrap and width and width > 0: iterlines = self._iterlines_wrapped(width) elif wrap: warn("ignoring wrap=True as no width was specified") iterlines = self._iterlines() else: iterlines = self._iterlines() result = [] if self.halign == self.CENTER: # Centered alignment if width is None: width = self.text_extents()[2] for line, line_width, x_bearing in iterlines: result.append((x + (width - line_width) / 2.0 - x_bearing, y, line)) y += line_height elif self.halign == self.RIGHT: # Right alignment if width is None: width = self.text_extents()[2] x += width for line, line_width, x_bearing in iterlines: result.append((x - line_width - x_bearing, y, line)) y += line_height else: # Left alignment for line, _, x_bearing in iterlines: result.append((x - x_bearing, y, line)) y += line_height return result def draw_at(self, x=None, y=None, width=None, wrap=False): """Draws the text by setting up an appropriate path on the Cairo context and filling it. `x` and `y` denote the coordinates where the drawing should start. If they are both ``None``, the current position of the context will be used. Vertical alignment settings are not taken into account in this method as the text is not drawn within a box. @param x: The X coordinate of the reference point where the layout should start. @param y: The Y coordinate of the reference point where the layout should start. @param width: The width of the box in which the text will be fitted. It matters only when the text is right-aligned or centered. The text will overflow the box if any of the lines is longer than the box width and `wrap` is ``False``. @param wrap: whether to allow re-wrapping of the text if it does not fit within the given width. """ ctx = self.context for ref_x, ref_y, line in self.get_text_layout(x, y, width, wrap): ctx.move_to(ref_x, ref_y) ctx.show_text(line) ctx.new_path() def _iterlines(self): """Iterates over the label line by line and returns a tuple containing the folloing for each line: the line itself, the width of the line and the X-bearing of the line.""" ctx = self.context for line in self._text.split("\n"): xb, _, line_width, _, _, _ = ctx.text_extents(line) yield (line, line_width, xb) def _iterlines_wrapped(self, width): """Iterates over the label line by line and returns a tuple containing the folloing for each line: the line itself, the width of the line and the X-bearing of the line. The difference between this method and `_iterlines()` is that this method is allowed to re-wrap the line if necessary. @param width: The width of the box in which the text will be fitted. Lines will be wrapped if they are wider than this width. """ ctx = self.context for line in self._text.split("\n"): xb, _, line_width, _, _, _ = ctx.text_extents(line) if line_width <= width: yield (line, line_width, xb) continue # We have to wrap the line current_line, current_width, last_sep_width = [], 0, 0 for match in re.finditer(r"(\S+)(\s+)?", line): word, sep = match.groups() word_width = ctx.text_extents(word)[4] if sep: sep_width = ctx.text_extents(sep)[4] else: sep_width = 0 current_width += word_width if current_width >= width and current_line: yield ("".join(current_line), current_width - word_width, 0) # Starting a new line current_line, current_width = [word], word_width if sep is not None: current_line.append(sep) else: current_width += last_sep_width current_line.append(word) if sep is not None: current_line.append(sep) last_sep_width = sep_width if current_line: yield ("".join(current_line), current_width, 0) @property def text(self): """Returns the text to be drawn.""" return self._text @text.setter def text(self, text): """Sets the text that will be drawn. If `text` is ``None``, it will be mapped to an empty string; otherwise, it will be converted to a string.""" if text is None: self._text = "" else: self._text = str(text) def text_extents(self): """Returns the X-bearing, Y-bearing, width, height, X-advance and Y-advance of the text. For multi-line text, the X-bearing and Y-bearing correspond to the first line, while the X-advance is extracted from the last line. and the Y-advance is the sum of all the Y-advances. The width and height correspond to the entire bounding box of the text.""" lines = self.text.split("\n") if len(lines) <= 1: return self.context.text_extents(self.text) ( x_bearing, y_bearing, width, height, x_advance, y_advance, ) = self.context.text_extents(lines[0]) line_height = self.context.font_extents()[2] for line in lines[1:]: _, _, w, _, x_advance, ya = self.context.text_extents(line) width = max(width, w) height += line_height y_advance += ya return x_bearing, y_bearing, width, height, x_advance, y_advance def test(): """Testing routine for L{TextDrawer}""" import math from igraph.drawing.utils import find_cairo cairo = find_cairo() text = "The quick brown fox\njumps over a\nlazy dog" width, height = (600, 1000) surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height) context = cairo.Context(surface) drawer = TextDrawer(context, text) context.set_source_rgb(1, 1, 1) context.set_font_size(16.0) context.rectangle(0, 0, width, height) context.fill() context.set_source_rgb(0.5, 0.5, 0.5) for i in range(200, width, 200): context.move_to(i, 0) context.line_to(i, height) context.stroke() for i in range(200, height, 200): context.move_to(0, i) context.line_to(width, i) context.stroke() context.set_source_rgb(0.75, 0.75, 0.75) context.set_line_width(0.5) for i in range(100, width, 200): context.move_to(i, 0) context.line_to(i, height) context.stroke() for i in range(100, height, 200): context.move_to(0, i) context.line_to(width, i) context.stroke() def mark_point(red, green, blue): """Marks the current point on the canvas by the given color""" x, y = context.get_current_point() context.set_source_rgba(red, green, blue, 0.5) context.arc(x, y, 4, 0, 2 * math.pi) context.fill() # Testing drawer.draw_at() for i, halign in enumerate(("left", "center", "right")): # Mark the reference points context.move_to(i * 200, 40) mark_point(0, 0, 1) context.move_to(i * 200, 140) mark_point(0, 0, 1) # Draw the text context.set_source_rgb(0, 0, 0) drawer.halign = halign drawer.draw_at(i * 200, 40) drawer.draw_at(i * 200, 140, width=200) # Mark the new reference point mark_point(1, 0, 0) # Testing TextDrawer.draw() for i, halign in enumerate(("left", "center", "right")): for j, valign in enumerate(("top", "center", "bottom")): # Draw the text context.set_source_rgb(0, 0, 0) drawer.halign = halign drawer.valign = valign drawer.bbox = (i * 200, j * 200 + 200, i * 200 + 200, j * 200 + 400) drawer.draw() # Mark the new reference point mark_point(1, 0, 0) # Testing TextDrawer.wrap() drawer.text = ( "Jackdaws love my big sphinx of quartz. Yay, wrapping! " + "Jackdaws love my big sphinx of quartz.\n\n" + "Jackdaws love my big sphinx of quartz." ) drawer.valign = TextDrawer.TOP for i, halign in enumerate(("left", "center", "right")): context.move_to(i * 200, 840) # Mark the reference point mark_point(0, 0, 1) # Draw the text context.set_source_rgb(0, 0, 0) drawer.halign = halign drawer.draw_at(i * 200, 840, width=199, wrap=True) # Mark the new reference point mark_point(1, 0, 0) surface.write_to_png("test.png") if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/utils.py0000644000175100001710000004604300000000000021020 0ustar00runnerdocker00000000000000""" Utility classes for drawing routines. """ from math import atan2, cos, sin from operator import itemgetter __all__ = ("BoundingBox", "Point", "Rectangle") ##################################################################### class Rectangle: """Class representing a rectangle.""" __slots__ = ("_left", "_top", "_right", "_bottom") def __init__(self, *args): """Creates a rectangle. The corners of the rectangle can be specified by either a tuple (four items, two for each corner, respectively), four separate numbers (X and Y coordinates for each corner) or two separate numbers (width and height, the upper left corner is assumed to be at (0,0))""" coords = None if len(args) == 1: if isinstance(args[0], Rectangle): coords = args[0].coords elif len(args[0]) >= 4: coords = tuple(args[0])[0:4] elif len(args[0]) == 2: coords = (0, 0, args[0][0], args[0][1]) elif len(args) == 4: coords = tuple(args) elif len(args) == 2: coords = (0, 0, args[0], args[1]) if coords is None: raise ValueError("invalid coordinate format") try: coords = tuple(float(coord) for coord in coords) except ValueError: raise ValueError("invalid coordinate format, numbers expected") self.coords = coords @property def coords(self): """The coordinates of the corners. The coordinates are returned as a 4-tuple in the following order: left edge, top edge, right edge, bottom edge. """ return self._left, self._top, self._right, self._bottom @coords.setter def coords(self, coords): """Sets the coordinates of the corners. @param coords: a 4-tuple with the coordinates of the corners """ self._left, self._top, self._right, self._bottom = coords if self._left > self._right: self._left, self._right = self._right, self._left if self._top > self._bottom: self._bottom, self._top = self._top, self._bottom @property def width(self): """The width of the rectangle""" return self._right - self._left @width.setter def width(self, value): """Sets the width of the rectangle by adjusting the right edge.""" self._right = self._left + value @property def height(self): """The height of the rectangle""" return self._bottom - self._top @height.setter def height(self, value): """Sets the height of the rectangle by adjusting the bottom edge.""" self._bottom = self._top + value @property def left(self): """The X coordinate of the left side of the box""" return self._left @left.setter def left(self, value): """Sets the X coordinate of the left side of the box""" self._left = float(value) self._right = max(self._left, self._right) @property def right(self): """The X coordinate of the right side of the box""" return self._right @right.setter def right(self, value): """Sets the X coordinate of the right side of the box""" self._right = float(value) self._left = min(self._left, self._right) @property def top(self): """The Y coordinate of the top edge of the box""" return self._top @top.setter def top(self, value): """Sets the Y coordinate of the top edge of the box""" self._top = value self._bottom = max(self._bottom, self._top) @property def bottom(self): """The Y coordinate of the bottom edge of the box""" return self._bottom @bottom.setter def bottom(self, value): """Sets the Y coordinate of the bottom edge of the box""" self._bottom = value self._top = min(self._bottom, self._top) @property def midx(self): """The X coordinate of the center of the box""" return (self._left + self._right) / 2.0 @midx.setter def midx(self, value): """Moves the center of the box to the given X coordinate""" dx = value - (self._left + self._right) / 2.0 self._left += dx self._right += dx @property def midy(self): """The Y coordinate of the center of the box""" return (self._top + self._bottom) / 2.0 @midy.setter def midy(self, value): """Moves the center of the box to the given Y coordinate""" dy = value - (self._top + self._bottom) / 2.0 self._top += dy self._bottom += dy @property def shape(self): """The shape of the rectangle (width, height)""" return self._right - self._left, self._bottom - self._top @shape.setter def shape(self, shape): """Sets the shape of the rectangle (width, height).""" self.width, self.height = shape def contract(self, margins): """Contracts the rectangle by the given margins. @return: a new L{Rectangle} object. """ if isinstance(margins, int) or isinstance(margins, float): margins = [float(margins)] * 4 if len(margins) != 4: raise ValueError("margins must be a 4-tuple or a single number") nx1, ny1 = self._left + margins[0], self._top + margins[1] nx2, ny2 = self._right - margins[2], self._bottom - margins[3] if nx1 > nx2: nx1 = (nx1 + nx2) / 2.0 nx2 = nx1 if ny1 > ny2: ny1 = (ny1 + ny2) / 2.0 ny2 = ny1 return self.__class__(nx1, ny1, nx2, ny2) def expand(self, margins): """Expands the rectangle by the given margins. @return: a new L{Rectangle} object. """ if isinstance(margins, int) or isinstance(margins, float): return self.contract(-float(margins)) return self.contract([-float(margin) for margin in margins]) def isdisjoint(self, other): """Returns ``True`` if the two rectangles have no intersection. Example:: >>> r1 = Rectangle(10, 10, 30, 30) >>> r2 = Rectangle(20, 20, 50, 50) >>> r3 = Rectangle(70, 70, 90, 90) >>> r1.isdisjoint(r2) False >>> r2.isdisjoint(r1) False >>> r1.isdisjoint(r3) True >>> r3.isdisjoint(r1) True """ return ( self._left > other._right or self._right < other._left or self._top > other._bottom or self._bottom < other._top ) def isempty(self): """Returns ``True`` if the rectangle is empty (i.e. it has zero width and height). Example:: >>> r1 = Rectangle(10, 10, 30, 30) >>> r2 = Rectangle(70, 70, 90, 90) >>> r1.isempty() False >>> r2.isempty() False >>> r1.intersection(r2).isempty() True """ return self._left == self._right and self._top == self._bottom def intersection(self, other): """Returns the intersection of this rectangle with another. Example:: >>> r1 = Rectangle(10, 10, 30, 30) >>> r2 = Rectangle(20, 20, 50, 50) >>> r3 = Rectangle(70, 70, 90, 90) >>> r1.intersection(r2) Rectangle(20.0, 20.0, 30.0, 30.0) >>> r2 & r1 Rectangle(20.0, 20.0, 30.0, 30.0) >>> r2.intersection(r1) == r1.intersection(r2) True >>> r1.intersection(r3) Rectangle(0.0, 0.0, 0.0, 0.0) """ if self.isdisjoint(other): return Rectangle(0, 0, 0, 0) return Rectangle( max(self._left, other._left), max(self._top, other._top), min(self._right, other._right), min(self._bottom, other._bottom), ) __and__ = intersection def translate(self, dx, dy): """Translates the rectangle in-place. Example: >>> r = Rectangle(10, 20, 50, 70) >>> r.translate(30, -10) >>> r Rectangle(40.0, 10.0, 80.0, 60.0) @param dx: the X coordinate of the translation vector @param dy: the Y coordinate of the translation vector """ self._left += dx self._right += dx self._top += dy self._bottom += dy def union(self, other): """Returns the union of this rectangle with another. The resulting rectangle is the smallest rectangle that contains both rectangles. Example:: >>> r1 = Rectangle(10, 10, 30, 30) >>> r2 = Rectangle(20, 20, 50, 50) >>> r3 = Rectangle(70, 70, 90, 90) >>> r1.union(r2) Rectangle(10.0, 10.0, 50.0, 50.0) >>> r2 | r1 Rectangle(10.0, 10.0, 50.0, 50.0) >>> r2.union(r1) == r1.union(r2) True >>> r1.union(r3) Rectangle(10.0, 10.0, 90.0, 90.0) """ return Rectangle( min(self._left, other._left), min(self._top, other._top), max(self._right, other._right), max(self._bottom, other._bottom), ) __or__ = union def __ior__(self, other): """Expands this rectangle to include itself and another completely while still being as small as possible. Example:: >>> r1 = Rectangle(10, 10, 30, 30) >>> r2 = Rectangle(20, 20, 50, 50) >>> r3 = Rectangle(70, 70, 90, 90) >>> r1 |= r2 >>> r1 Rectangle(10.0, 10.0, 50.0, 50.0) >>> r1 |= r3 >>> r1 Rectangle(10.0, 10.0, 90.0, 90.0) """ self._left = min(self._left, other._left) self._top = min(self._top, other._top) self._right = max(self._right, other._right) self._bottom = max(self._bottom, other._bottom) return self def __repr__(self): return "%s(%s, %s, %s, %s)" % ( self.__class__.__name__, self._left, self._top, self._right, self._bottom, ) def __eq__(self, other): return self.coords == other.coords def __ne__(self, other): return self.coords != other.coords def __bool__(self): return self._left != self._right or self._top != self._bottom def __hash__(self): return hash(self.coords) ##################################################################### class BoundingBox(Rectangle): """Class representing a bounding box (a rectangular area) that encloses some objects.""" def __ior__(self, other): """Replaces this bounding box with the union of itself and another. Example:: >>> box1 = BoundingBox(10, 20, 50, 60) >>> box2 = BoundingBox(70, 40, 100, 90) >>> box1 |= box2 >>> print(box1) BoundingBox(10.0, 20.0, 100.0, 90.0) """ self._left = min(self._left, other._left) self._top = min(self._top, other._top) self._right = max(self._right, other._right) self._bottom = max(self._bottom, other._bottom) return self def __or__(self, other): """Takes the union of this bounding box with another. The result is a bounding box which encloses both bounding boxes. Example:: >>> box1 = BoundingBox(10, 20, 50, 60) >>> box2 = BoundingBox(70, 40, 100, 90) >>> box1 | box2 BoundingBox(10.0, 20.0, 100.0, 90.0) """ return self.__class__( min(self._left, other._left), min(self._top, other._top), max(self._right, other._right), max(self._bottom, other._bottom), ) ##################################################################### class FakeModule: """Fake module that raises an exception for everything""" def __init__(self, message): """Constructor. @param message: message to print in exceptions raised from this module """ self._message = message def __getattr__(self, _): raise AttributeError(self._message) def __call__(self, _): raise TypeError(self._message) def __setattr__(self, key, value): if key == "_message": super().__setattr__(key, value) else: raise AttributeError(self._message) ##################################################################### def find_cairo(): """Tries to import the ``cairo`` Python module if it is installed, also trying ``cairocffi`` (a drop-in replacement of ``cairo``). Returns a fake module if everything fails. """ module_names = ["cairo", "cairocffi"] module = FakeModule("Plotting not available; please install pycairo or cairocffi") for module_name in module_names: try: module = __import__(module_name) break except ImportError: pass return module ##################################################################### def find_matplotlib(): """Tries to import the ``matplotlib`` Python module if it is installed. Returns a fake module if everything fails. """ try: import matplotlib as mpl has_mpl = True except ImportError: mpl = FakeModule("You need to install matplotlib to use this functionality") has_mpl = False if has_mpl: import matplotlib.pyplot as plt else: plt = FakeModule( "You need to install matplotlib.pyplot to use this functionality" ) return mpl, plt ##################################################################### class Point(tuple): """Class representing a point on the 2D plane.""" __slots__ = () _fields = ("x", "y") def __new__(cls, x, y): """Creates a new point with the given coordinates""" return tuple.__new__(cls, (x, y)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): """Creates a new point from a sequence or iterable""" result = new(cls, iterable) if len(result) != 2: raise TypeError("Expected 2 arguments, got %d" % len(result)) return result def __repr__(self): """Returns a nicely formatted representation of the point""" return "Point(x=%r, y=%r)" % self def _asdict(self): """Returns a new dict which maps field names to their values""" return dict(zip(self._fields, self)) def _replace(self, **kwds): """Returns a new point object replacing specified fields with new values""" result = self._make(map(kwds.pop, ("x", "y"), self)) if kwds: raise ValueError("Got unexpected field names: %r" % list(kwds.keys())) return result def __getnewargs__(self): """Return self as a plain tuple. Used by copy and pickle.""" return tuple(self) x = property(itemgetter(0), doc="Alias for field number 0") y = property(itemgetter(1), doc="Alias for field number 1") def __add__(self, other): """Adds the coordinates of a point to another one""" return self.__class__(x=self.x + other.x, y=self.y + other.y) def __sub__(self, other): """Subtracts the coordinates of a point to another one""" return self.__class__(x=self.x - other.x, y=self.y - other.y) def __mul__(self, scalar): """Multiplies the coordinates by a scalar""" return self.__class__(x=self.x * scalar, y=self.y * scalar) __rmul__ = __mul__ def __div__(self, scalar): """Divides the coordinates by a scalar""" return self.__class__(x=self.x / scalar, y=self.y / scalar) def as_polar(self): """Returns the polar coordinate representation of the point. @return: the radius and the angle in a tuple. """ return len(self), atan2(self.y, self.x) def distance(self, other): """Returns the distance of the point from another one. Example: >>> p1 = Point(5, 7) >>> p2 = Point(8, 3) >>> p1.distance(p2) 5.0 """ dx, dy = self.x - other.x, self.y - other.y return (dx * dx + dy * dy) ** 0.5 def interpolate(self, other, ratio=0.5): """Linearly interpolates between the coordinates of this point and another one. @param other: the other point @param ratio: the interpolation ratio between 0 and 1. Zero will return this point, 1 will return the other point. """ ratio = float(ratio) return Point( x=self.x * (1.0 - ratio) + other.x * ratio, y=self.y * (1.0 - ratio) + other.y * ratio, ) def length(self): """Returns the length of the vector pointing from the origin to this point.""" return (self.x ** 2 + self.y ** 2) ** 0.5 def normalized(self): """Normalizes the coordinates of the point s.t. its length will be 1 after normalization. Returns the normalized point.""" len = self.length() if len == 0: return Point(x=self.x, y=self.y) return Point(x=self.x / len, y=self.y / len) def sq_length(self): """Returns the squared length of the vector pointing from the origin to this point.""" return self.x ** 2 + self.y ** 2 def towards(self, other, distance=0): """Returns the point that is at a given distance from this point towards another one.""" if not distance: return self angle = atan2(other.y - self.y, other.x - self.x) return Point(self.x + distance * cos(angle), self.y + distance * sin(angle)) @classmethod def FromPolar(cls, radius, angle): """Constructs a point from polar coordinates. `radius` is the distance of the point from the origin; `angle` is the angle between the X axis and the vector pointing to the point from the origin. """ return cls(radius * cos(angle), radius * sin(angle)) def evaluate_cubic_bezier_curve(x0, y0, x1, y1, x2, y2, x3, y3, t): """Evaluates the Bezier curve from point (x0,y0) to (x3,y3) via control points (x1,y1) and (x2,y2) with parameter t. """ xt = ( (1.0 - t) ** 3 * x0 + 3.0 * t * (1.0 - t) ** 2 * x1 + 3.0 * t ** 2 * (1.0 - t) * x2 + t ** 3 * x3 ) yt = ( (1.0 - t) ** 3 * y0 + 3.0 * t * (1.0 - t) ** 2 * y1 + 3.0 * t ** 2 * (1.0 - t) * y2 + t ** 3 * y3 ) return xt, yt def get_bezier_control_points_for_curved_edge(x1, y1, x2, y2, curvature): """Helper function that calculates the Bezier control points for a curved edge that goes from (x1, y1) to (x2, y2). """ aux1 = (2 * x1 + x2) / 3.0 - curvature * 0.5 * (y2 - y1), ( 2 * y1 + y2 ) / 3.0 + curvature * 0.5 * (x2 - x1) aux2 = (x1 + 2 * x2) / 3.0 - curvature * 0.5 * (y2 - y1), ( y1 + 2 * y2 ) / 3.0 + curvature * 0.5 * (x2 - x1) return aux1, aux2 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/drawing/vertex.py0000644000175100001710000001051400000000000021167 0ustar00runnerdocker00000000000000""" Drawing routines to draw the vertices of graphs. This module provides implementations of vertex drawers, i.e. drawers that the default graph drawer will use to draw vertices. """ from igraph.drawing.baseclasses import AbstractDrawer, AbstractCairoDrawer from igraph.drawing.metamagic import AttributeCollectorBase from igraph.drawing.shapes import ShapeDrawerDirectory from math import pi __all__ = ("AbstractVertexDrawer", "AbstractCairoVertexDrawer", "DefaultVertexDrawer") class AbstractVertexDrawer(AbstractDrawer): """Abstract vertex drawer object from which all concrete vertex drawer implementations are derived.""" def __init__(self, palette, layout): """Constructs the vertex drawer and associates it to the given palette. @param palette: the palette that can be used to map integer color indices to colors when drawing vertices @param layout: the layout of the vertices in the graph being drawn """ self.layout = layout self.palette = palette def draw(self, visual_vertex, vertex, coords): """Draws the given vertex. @param visual_vertex: object specifying the visual properties of the vertex. Its structure is defined by the VisualVertexBuilder of the L{DefaultGraphDrawer}; see its source code. @param vertex: the raw igraph vertex being drawn @param coords: the X and Y coordinates of the vertex as specified by the layout algorithm, scaled into the bounding box. """ raise NotImplementedError("abstract class") class AbstractCairoVertexDrawer(AbstractVertexDrawer, AbstractCairoDrawer): """Abstract base class for vertex drawers that draw on a Cairo canvas.""" def __init__(self, context, bbox, palette, layout): """Constructs the vertex drawer and associates it to the given Cairo context and the given L{BoundingBox}. @param context: the context on which we will draw @param bbox: the bounding box within which we will draw. Can be anything accepted by the constructor of L{BoundingBox} (i.e., a 2-tuple, a 4-tuple or a L{BoundingBox} object). @param palette: the palette that can be used to map integer color indices to colors when drawing vertices @param layout: the layout of the vertices in the graph being drawn """ AbstractCairoDrawer.__init__(self, context, bbox) AbstractVertexDrawer.__init__(self, palette, layout) class DefaultVertexDrawer(AbstractCairoVertexDrawer): """The default vertex drawer implementation of igraph.""" def __init__(self, context, bbox, palette, layout): AbstractCairoVertexDrawer.__init__(self, context, bbox, palette, layout) self.VisualVertexBuilder = self._construct_visual_vertex_builder() def _construct_visual_vertex_builder(self): class VisualVertexBuilder(AttributeCollectorBase): """Collects some visual properties of a vertex for drawing""" _kwds_prefix = "vertex_" color = ("red", self.palette.get) frame_color = ("black", self.palette.get) frame_width = 1.0 label = None label_angle = -pi / 2 label_dist = 0.0 label_color = ("black", self.palette.get) font = "sans-serif" label_size = 14.0 position = dict(func=self.layout.__getitem__) shape = ("circle", ShapeDrawerDirectory.resolve_default) size = 20.0 width = None height = None return VisualVertexBuilder def draw(self, visual_vertex, vertex, coords): context = self.context width = ( visual_vertex.width if visual_vertex.width is not None else visual_vertex.size ) height = ( visual_vertex.height if visual_vertex.height is not None else visual_vertex.size ) visual_vertex.shape.draw_path(context, coords[0], coords[1], width, height) context.set_source_rgba(*visual_vertex.color) context.fill_preserve() context.set_source_rgba(*visual_vertex.frame_color) context.set_line_width(visual_vertex.frame_width) context.stroke() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/formula.py0000644000175100001710000001760200000000000017671 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Implementation of `igraph.Graph.Formula()` You should use this module directly only if you have a very strong reason to do so. In almost all cases, you are better off with calling `igraph.Graph.Formula()`. """ from io import StringIO from igraph.datatypes import UniqueIdGenerator import re import tokenize import token __all__ = ("construct_graph_from_formula",) def generate_edges(formula): """Parses an edge specification from the head of the given formula part and yields the following: - startpoint(s) of the edge by vertex names - endpoint(s) of the edge by names or an empty list if the vertices are isolated - a pair of bools to denote whether we had arrowheads at the start and end vertices """ if formula == "": yield [], [""], [False, False] return name_tokens = set([token.NAME, token.NUMBER, token.STRING]) edge_chars = "<>-+" start_names, end_names, arrowheads = [], [], [False, False] parsing_vertices = True # Tokenize the formula token_gen = tokenize.generate_tokens(StringIO(formula).__next__) for token_info in token_gen: # Do the state transitions token_type, tok, _, _, _ = token_info if parsing_vertices: if all(ch in edge_chars for ch in tok) and token_type == token.OP: parsing_vertices = False # Check the edge we currently have if start_names and end_names: # We have a whole edge yield start_names, end_names, arrowheads start_names, end_names = end_names, [] arrowheads = [False, False] else: if any(ch not in edge_chars for ch in tok): parsing_vertices = True if parsing_vertices: # We are parsing vertex names at the moment if token_type in name_tokens: # We found a vertex name if token_type == token.STRING: end_names.append(eval(tok)) else: end_names.append(str(tok)) elif tok == ":" and token_type == token.OP: # Separating semicolon between vertex names, we just go on continue elif token_type == token.NEWLINE: # Newlines are fine pass elif token_type == token.ENDMARKER: # End markers are fine pass else: msg = ( "invalid token found in edge specification: %s; " "token_type=%r; tok=%r" % (formula, token_type, tok) ) raise SyntaxError(msg) else: # We are parsing an edge operator if "<" in tok: if ">" in tok: arrowheads = [True, True] else: arrowheads[0] = True elif ">" in tok: arrowheads[1] = True elif "+" in tok: if tok[0] == "+": arrowheads[0] = True if len(tok) > 1 and tok[-1] == "+": arrowheads[1] = True # The final edge yield start_names, end_names, arrowheads def construct_graph_from_formula(cls, formula=None, attr="name", simplify=True): """Graph.Formula(formula = None, attr = "name", simplify = True) Generates a graph from a graph formula A graph formula is a simple string representation of a graph. It is very handy for creating small graphs quickly. The string consists of vertex names separated by edge operators. An edge operator is a sequence of dashes (C{-}) that may or may not start with an arrowhead (C{<} at the beginning of the sequence or C{>} at the end of the sequence). The edge operators can be arbitrarily long, i.e., you may use as many dashes to draw them as you like. This makes a total of four different edge operators: - C{-----} makes an undirected edge - C{<----} makes a directed edge pointing from the vertex on the right hand side of the operator to the vertex on the left hand side - C{---->} is the opposite of C{<----} - C{<--->} creates a mutual directed edge pair between the two vertices If you only use the undirected edge operator (C{-----}), the graph will be undirected. Otherwise it will be directed. Vertex names used in the formula will be assigned to the C{name} vertex attribute of the graph. Some simple examples: >>> from igraph import Graph >>> print(Graph.Formula()) # empty graph IGRAPH UN-- 0 0 -- + attr: name (v) >>> g = Graph.Formula("A-B") # undirected graph >>> g.vs["name"] ['A', 'B'] >>> print(g) IGRAPH UN-- 2 1 -- + attr: name (v) + edges (vertex names): A--B >>> g.get_edgelist() [(0, 1)] >>> g2 = Graph.Formula("A-----------B") >>> g2.isomorphic(g) True >>> g = Graph.Formula("A ---> B") # directed graph >>> g.vs["name"] ['A', 'B'] >>> print(g) IGRAPH DN-- 2 1 -- + attr: name (v) + edges (vertex names): A->B If you have may disconnected componnets, you can separate them with commas. You can also specify isolated vertices: >>> g = Graph.Formula("A--B, C--D, E--F, G--H, I, J, K") >>> print(", ".join(g.vs["name"])) A, B, C, D, E, F, G, H, I, J, K >>> g.clusters().membership [0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 6] The colon (C{:}) operator can be used to specify vertex sets. If an edge operator connects two vertex sets, then every vertex from the first vertex set will be connected to every vertex in the second set: >>> g = Graph.Formula("A:B:C:D --- E:F:G") >>> g.isomorphic(Graph.Full_Bipartite(4, 3)) True Note that you have to quote vertex names if they include spaces or special characters: >>> g = Graph.Formula('"this is" +- "a silly" -+ "graph here"') >>> g.vs["name"] ['this is', 'a silly', 'graph here'] @param formula: the formula itself @param attr: name of the vertex attribute where the vertex names will be stored @param simplify: whether the simplify the constructed graph @return: the constructed graph: """ # If we have no formula, return an empty graph if formula is None: return cls(0, vertex_attrs={attr: []}) vertex_ids, edges, directed = UniqueIdGenerator(), [], False # Loop over each part in the formula for part in re.compile(r"[,\n]").split(formula): # Strip leading and trailing whitespace in the part part = part.strip() # Parse the first vertex specification from the formula for start_names, end_names, arrowheads in generate_edges(part): start_ids = [vertex_ids[name] for name in start_names] end_ids = [vertex_ids[name] for name in end_names] if not arrowheads[0] and not arrowheads[1]: # This is an undirected edge. Do we have a directed graph? if not directed: # Nope, add the edge edges.extend((id1, id2) for id1 in start_ids for id2 in end_ids) else: # This is a directed edge directed = True if arrowheads[1]: edges.extend((id1, id2) for id1 in start_ids for id2 in end_ids) if arrowheads[0]: edges.extend((id2, id1) for id1 in start_ids for id2 in end_ids) # Grab the vertex names into a list vertex_attrs = {} vertex_attrs[attr] = list(vertex_ids.values()) # Construct and return the graph result = cls(len(vertex_ids), edges, directed, vertex_attrs=vertex_attrs) if simplify: result.simplify() return result ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/layout.py0000644000175100001710000004117500000000000017543 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Layout-related code in the IGraph library. This package contains the implementation of the L{Layout} object. """ from math import sin, cos, pi from igraph.drawing.utils import BoundingBox from igraph.statistics import RunningMean class Layout: """Represents the layout of a graph. A layout is practically a list of coordinates in an n-dimensional space. This class is generic in the sense that it can store coordinates in any n-dimensional space. Layout objects are not associated directly with a graph. This is deliberate: there were times when I worked with almost identical copies of the same graph, the only difference was that they had different colors assigned to the vertices. It was particularly convenient for me to use the same layout for all of them, especially when I made figures for a paper. However, C{igraph} will of course refuse to draw a graph with a layout that has less coordinates than the node count of the graph. Layouts behave exactly like lists when they are accessed using the item index operator (C{[...]}). They can even be iterated through. Items returned by the index operator are only copies of the coordinates, but the stored coordinates can be modified by directly assigning to an index. >>> layout = Layout([(0, 1), (0, 2)]) >>> coords = layout[1] >>> print(coords) [0, 2] >>> coords = (0, 3) >>> print(layout[1]) [0, 2] >>> layout[1] = coords >>> print(layout[1]) [0, 3] """ def __init__(self, coords=None, dim=None): """Constructor. @param coords: the coordinates to be stored in the layout. @param dim: the number of dimensions. If C{None}, the number of dimensions is determined automatically from the length of the first item of the coordinate list. If there are no entries in the coordinate list, the default will be 2. Generally, this should be given if the length of the coordinate list is zero, otherwise it should be left as is. """ if coords: self._coords = [list(coord) for coord in coords] else: self._coords = [] if dim is None: if len(self._coords) == 0: self._dim = 2 else: self._dim = len(self._coords[0]) else: self._dim = int(dim) for row in self._coords: if len(row) != self._dim: raise ValueError( "all items in the coordinate list " + "must have a length of %d" % self._dim ) def __len__(self): return len(self._coords) def __getitem__(self, idx): return self._coords[idx] def __setitem__(self, idx, value): if len(value) != self._dim: raise ValueError("assigned item must have %d elements" % self._dim) self._coords[idx] = list(value) def __delitem__(self, idx): del self._coords[idx] def __copy__(self): return self.__class__(self.coords, self.dim) def __repr__(self): if not self.coords: vertex_count = "no vertices" elif len(self.coords) == 1: vertex_count = "1 vertex" else: vertex_count = "%d vertices" % len(self.coords) if self.dim == 1: dim_count = "1 dimension" else: dim_count = "%d dimensions" % self.dim return "<%s with %s and %s>" % ( self.__class__.__name__, vertex_count, dim_count, ) @property def dim(self): """Returns the number of dimensions""" return self._dim @property def coords(self): """The coordinates as a list of lists""" return [row[:] for row in self._coords] def append(self, value): """Appends a new point to the layout""" if len(value) < self._dim: raise ValueError("appended item must have %d elements" % self._dim) self._coords.append([float(coord) for coord in value[0 : self._dim]]) def mirror(self, dim): """Mirrors the layout along the given dimension(s) @param dim: the list of dimensions or a single dimension """ if isinstance(dim, int): dim = [dim] else: dim = [int(x) for x in dim] for current_dim in dim: for row in self._coords: row[current_dim] *= -1 def rotate(self, angle, dim1=0, dim2=1, **kwds): """Rotates the layout by the given degrees on the plane defined by the given two dimensions. @param angle: the angle of the rotation, specified in degrees. @param dim1: the first axis of the plane of the rotation. @param dim2: the second axis of the plane of the rotation. @keyword origin: the origin of the rotation. If not specified, the origin will be the origin of the coordinate system. """ origin = list(kwds.get("origin", [0.0] * self._dim)) if len(origin) != self._dim: raise ValueError("origin must have %d dimensions" % self._dim) radian = angle * pi / 180.0 cos_alpha, sin_alpha = cos(radian), sin(radian) for idx, row in enumerate(self._coords): x, y = row[dim1] - origin[dim1], row[dim2] - origin[dim2] row[dim1] = cos_alpha * x - sin_alpha * y + origin[dim1] row[dim2] = sin_alpha * x + cos_alpha * y + origin[dim2] def scale(self, *args, **kwds): """Scales the layout. Scaling parameters can be provided either through the C{scale} keyword argument or through plain unnamed arguments. If a single integer or float is given, it is interpreted as a uniform multiplier to be applied on all dimensions. If it is a list or tuple, its length must be equal to the number of dimensions in the layout, and each element must be an integer or float describing the scaling coefficient in one of the dimensions. @keyword scale: scaling coefficients (integer, float, list or tuple) @keyword origin: the origin of scaling (this point will stay in place). Optional, defaults to the origin of the coordinate system being used. """ origin = list(kwds.get("origin", [0.0] * self._dim)) if len(origin) != self._dim: raise ValueError("origin must have %d dimensions" % self._dim) scaling = kwds.get("scale") or args if isinstance(scaling, (int, float)): scaling = [scaling] if len(scaling) == 0: raise ValueError("scaling factor must be given") elif len(scaling) == 1: if type(scaling[0]) == int or type(scaling[0]) == float: scaling *= self._dim else: scaling = scaling[0] if len(scaling) != self._dim: raise ValueError("scaling factor list must have %d elements" % self._dim) for idx, row in enumerate(self._coords): self._coords[idx] = [ (row[d] - origin[d]) * scaling[d] + origin[d] for d in range(self._dim) ] def translate(self, *args, **kwds): """Translates the layout. The translation vector can be provided either through the C{v} keyword argument or through plain unnamed arguments. If unnamed arguments are used, the vector can be supplied as a single list (or tuple) or just as a series of arguments. In all cases, the translation vector must have the same number of dimensions as the layout. @keyword v: the translation vector """ v = kwds.get("v") or args if len(v) == 0: raise ValueError("translation vector must be given") elif len(v) == 1 and type(v[0]) != int and type(v[0]) != float: v = v[0] if len(v) != self._dim: raise ValueError("translation vector must have %d dimensions" % self._dim) for idx, row in enumerate(self._coords): self._coords[idx] = [row[d] + v[d] for d in range(self._dim)] def to_radial(self, min_angle=100, max_angle=80, min_radius=0.0, max_radius=1.0): """Converts a planar layout to a radial one This method applies only to 2D layouts. The X coordinate of the layout is transformed to an angle, with min(x) corresponding to the parameter called I{min_angle} and max(y) corresponding to I{max_angle}. Angles are given in degrees, zero degree corresponds to the direction pointing upwards. The Y coordinate is interpreted as a radius, with min(y) belonging to the minimum and max(y) to the maximum radius given in the arguments. This is not a fully generic polar coordinate transformation, but it is fairly useful in creating radial tree layouts from ordinary top-down ones (that's why the Y coordinate belongs to the radius). It can also be used in conjunction with the Fruchterman-Reingold layout algorithm via its I{miny} and I{maxy} parameters (see L{Graph.layout_fruchterman_reingold()}) to produce radial layouts where the radius belongs to some property of the vertices. @param min_angle: the angle corresponding to the minimum X value @param max_angle: the angle corresponding to the maximum X value @param min_radius: the radius corresponding to the minimum Y value @param max_radius: the radius corresponding to the maximum Y value """ if self._dim != 2: raise TypeError("implemented only for 2D layouts") bbox = self.bounding_box() while min_angle > max_angle: max_angle += 360 while min_angle > 360: min_angle -= 360 max_angle -= 360 while min_angle < 0: min_angle += 360 max_angle += 360 ratio_x = (max_angle - min_angle) / bbox.width ratio_x *= pi / 180.0 min_angle *= pi / 180.0 ratio_y = (max_radius - min_radius) / bbox.height for idx, (x, y) in enumerate(self._coords): alpha = (x - bbox.left) * ratio_x + min_angle radius = (y - bbox.top) * ratio_y + min_radius self._coords[idx] = [cos(alpha) * radius, -sin(alpha) * radius] def transform(self, function, *args, **kwds): """Performs an arbitrary transformation on the layout Additional positional and keyword arguments are passed intact to the given function. @param function: a function which receives the coordinates as a tuple and returns the transformed tuple. """ self._coords = [ list(function(tuple(row), *args, **kwds)) for row in self._coords ] def centroid(self): """Returns the centroid of the layout. The centroid of the layout is the arithmetic mean of the points in the layout. @return: the centroid as a list of floats""" centroid = [RunningMean() for _ in range(self._dim)] for row in self._coords: for dim in range(self._dim): centroid[dim].add(row[dim]) return [rm.mean for rm in centroid] def boundaries(self, border=0): """Returns the boundaries of the layout. The boundaries are the minimum and maximum coordinates along all dimensions. @param border: this value gets subtracted from the minimum bounds and gets added to the maximum bounds before returning the coordinates of the box. Defaults to zero. @return: the minimum and maximum coordinates along all dimensions, in a tuple containing two lists, one for the minimum coordinates, the other one for the maximum. @raises ValueError: if the layout contains no layout items """ if not self._coords: raise ValueError("layout contains no layout items") mins, maxs = [], [] for dim in range(self._dim): col = [row[dim] for row in self._coords] mins.append(min(col) - border) maxs.append(max(col) + border) return mins, maxs def bounding_box(self, border=0): """Returns the bounding box of the layout. The bounding box of the layout is the smallest box enclosing all the points in the layout. @param border: this value gets subtracted from the minimum bounds and gets added to the maximum bounds before returning the coordinates of the box. Defaults to zero. @return: the coordinates of the lower left and the upper right corner of the box. "Lower left" means the minimum coordinates and "upper right" means the maximum. These are encapsulated in a L{BoundingBox} object. """ if self._dim != 2: raise ValueError("Layout.boundary_box() supports 2D layouts only") try: (x0, y0), (x1, y1) = self.boundaries(border) return BoundingBox(x0, y0, x1, y1) except ValueError: return BoundingBox(0, 0, 0, 0) def center(self, *args, **kwds): """Centers the layout around the given point. The point itself can be supplied as multiple unnamed arguments, as a simple unnamed list or as a keyword argument. This operation moves the centroid of the layout to the given point. If no point is supplied, defaults to the origin of the coordinate system. @keyword p: the point where the centroid of the layout will be after the operation.""" center = kwds.get("p") or args if len(center) == 0: center = [0.0] * self._dim elif len(center) == 1 and type(center[0]) != int and type(center[0]) != float: center = center[0] if len(center) != self._dim: raise ValueError("the given point must have %d dimensions" % self._dim) centroid = self.centroid() vec = [center[d] - centroid[d] for d in range(self._dim)] self.translate(vec) def copy(self): """Creates an exact copy of the layout.""" return self.__copy__() def fit_into(self, bbox, keep_aspect_ratio=True): """Fits the layout into the given bounding box. The layout will be modified in-place. @param bbox: the bounding box in which to fit the layout. If the dimension of the layout is d, it can either be a d-tuple (defining the sizes of the box), a 2d-tuple (defining the coordinates of the top left and the bottom right point of the box), or a L{BoundingBox} object (for 2D layouts only). @param keep_aspect_ratio: whether to keep the aspect ratio of the current layout. If C{False}, the layout will be rescaled to fit exactly into the bounding box. If C{True}, the original aspect ratio of the layout will be kept and it will be centered within the bounding box. """ if isinstance(bbox, BoundingBox): if self._dim != 2: raise TypeError("bounding boxes work for 2D layouts only") corner, target_sizes = [bbox.left, bbox.top], [bbox.width, bbox.height] elif len(bbox) == self._dim: corner, target_sizes = [0.0] * self._dim, list(bbox) elif len(bbox) == 2 * self._dim: corner, opposite_corner = list(bbox[0 : self._dim]), list(bbox[self._dim :]) for i in range(self._dim): if corner[i] > opposite_corner[i]: corner[i], opposite_corner[i] = opposite_corner[i], corner[i] target_sizes = [ max_val - min_val for min_val, max_val in zip(corner, opposite_corner) ] try: mins, maxs = self.boundaries() except ValueError: mins, maxs = [0.0] * self._dim, [0.0] * self._dim sizes = [max_val - min_val for min_val, max_val in zip(mins, maxs)] for i, size in enumerate(sizes): if size == 0: sizes[i] = 2 mins[i] -= 1 maxs[i] += 1 ratios = [ float(target_size) / current_size for current_size, target_size in zip(sizes, target_sizes) ] if keep_aspect_ratio: min_ratio = min(ratios) ratios = [min_ratio] * self._dim translations = [] for i in range(self._dim): trans = (target_sizes[i] - ratios[i] * sizes[i]) / 2.0 trans -= mins[i] * ratios[i] - corner[i] translations.append(trans) self.scale(*ratios) self.translate(*translations) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/matching.py0000644000175100001710000001362400000000000020016 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Classes representing matchings on graphs.""" from igraph._igraph import Vertex class Matching: """A matching of vertices in a graph. A matching of an undirected graph is a set of edges such that each vertex is incident on at most one matched edge. When each vertex is incident on I{exactly} one matched edge, the matching called I{perfect}. This class is used in C{igraph} to represent non-perfect and perfect matchings in undirected graphs. This class is usually not instantiated directly, everything is taken care of by the functions that return matchings. Examples: >>> from igraph import Graph >>> g = Graph.Famous("noperfectmatching") >>> matching = g.maximum_matching() """ def __init__(self, graph, matching, types=None): """Initializes the matching. @param graph: the graph the matching belongs to @param matching: a numeric vector where element I{i} corresponds to vertex I{i} of the graph. Element I{i} is -1 or if the corresponding vertex is unmatched, otherwise it contains the index of the vertex to which vertex I{i} is matched. @param types: the types of the vertices if the graph is bipartite. It must either be the name of a vertex attribute (which will be retrieved for all vertices) or a list. Elements in the list will be converted to boolean values C{True} or C{False}, and this will determine which part of the bipartite graph a given vertex belongs to. @raise ValueError: if the matching vector supplied does not describe a valid matching of the graph. """ self._graph = graph self._matching = None self._num_matched = 0 self._types = None if isinstance(types, str): types = graph.vs[types] self.types = types self.matching = matching def __len__(self): return self._num_matched def __repr__(self): if self._types is not None: return "%s(%r,%r,types=%r)" % ( self.__class__.__name__, self._graph, self._matching, self._types, ) else: return "%s(%r,%r)" % (self.__class__.__name__, self._graph, self._matching) def __str__(self): if self._types is not None: return "Bipartite graph matching (%d matched vertex pairs)" % len(self) else: return "Graph matching (%d matched vertex pairs)" % len(self) def edges(self): """Returns an edge sequence that contains the edges in the matching. If there are multiple edges between a pair of matched vertices, only one of them will be returned. """ get_eid = self._graph.get_eid eidxs = [ get_eid(u, v, directed=False) for u, v in enumerate(self._matching) if v != -1 and u <= v ] return self._graph.es[eidxs] @property def graph(self): """Returns the graph corresponding to the matching.""" return self._graph def is_maximal(self): """Returns whether the matching is maximal. A matching is maximal when it is not possible to extend it any more with extra edges; in other words, unmatched vertices in the graph must be adjacent to matched vertices only. """ return self._graph._is_maximal_matching(self._matching, types=self._types) def is_matched(self, vertex): """Returns whether the given vertex is matched to another one.""" if isinstance(vertex, Vertex): vertex = vertex.index return self._matching[vertex] >= 0 def match_of(self, vertex): """Returns the vertex a given vertex is matched to. @param vertex: the vertex we are interested in; either an integer index or an instance of L{Vertex}. @return: the index of the vertex matched to the given vertex, either as an integer index (if I{vertex} was integer) or as an instance of L{Vertex}. When the vertex is unmatched, returns C{None}. """ if isinstance(vertex, Vertex): matched = self._matching[vertex.index] if matched < 0: return None return self._graph.vs[matched] matched = self._matching[vertex] if matched < 0: return None return matched @property def matching(self): """Returns the matching vector where element I{i} contains the ID of the vertex that vertex I{i} is matched to. The matching vector will contain C{-1} for unmatched vertices. """ return self._matching @matching.setter def matching(self, value): """Sets the matching vector. @param value: the matching vector which must contain the ID of the vertex matching vertex I{i} at the I{i}th position, or C{-1} if the vertex is unmatched. @raise ValueError: if the matching vector supplied does not describe a valid matching of the graph. """ if not self.graph._is_matching(value, types=self._types): raise ValueError("not a valid matching") self._matching = list(value) self._num_matched = sum(1 for i in self._matching if i >= 0) // 2 @property def types(self): """Returns the type vector if the graph is bipartite. Element I{i} of the type vector will be C{False} or C{True} depending on which side of the bipartite graph vertex I{i} belongs to. For non-bipartite graphs, this property returns C{None}. """ return self._types @types.setter def types(self, value): types = [bool(x) for x in value] if len(types) < self._graph.vcount(): raise ValueError("type vector too short") self._types = types ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/operators.py0000644000175100001710000004075200000000000020244 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Implementation of union, disjoint union and intersection operators.""" __all__ = ("disjoint_union", "union", "intersection") __docformat__ = "restructuredtext en" from igraph._igraph import GraphBase, _union, _intersection, _disjoint_union from warnings import warn def disjoint_union(graphs): """Graph disjoint union. The disjoint union of two or more graphs is created. This function keeps the attributes of all graphs. All graph, vertex and edge attributes are copied to the result. If an attribute is present in multiple graphs and would result a name clash, then this attribute is renamed by adding suffixes: _1, _2, etc. An error is generated if some input graphs are directed and others are undirected. @param graphs: list of graphs. A lazy sequence is not acceptable. @return: the disjoint union graph """ if any(not isinstance(g, GraphBase) for g in graphs): raise TypeError("Not all elements are graphs") ngr = len(graphs) # Trivial cases if ngr == 0: raise ValueError("disjoint_union() needs at least one graph") if ngr == 1: return graphs[0].copy() # Now there are at least two graphs graph_union = _disjoint_union(graphs) # Graph attributes # NOTE: a_first_graph tracks which graph has the 1st occurrence of an # attribute, while a_conflict track attributes with naming conflicts a_first_graph = {} a_conflict = set() for ig, g in enumerate(graphs, 1): # NOTE: a_name is the name of the attribute, a_value its value for a_name in g.attributes(): a_value = g[a_name] # No conflicts if a_name not in graph_union.attributes(): a_first_graph[a_name] = ig graph_union[a_name] = a_value continue if graph_union[a_name] == a_value: continue if a_name not in a_conflict: # New conflict a_conflict.add(a_name) igf = a_first_graph[a_name] graph_union["{:}_{:}".format(a_name, igf)] = graph_union[a_name] del graph_union[a_name] graph_union["{:}_{:}".format(a_name, ig)] = a_value # Vertex attributes i = 0 for g in graphs: nv = g.vcount() for attr in g.vertex_attributes(): graph_union.vs[i : i + nv][attr] = g.vs[attr] i += nv # Edge attributes i = 0 for g in graphs: ne = g.ecount() for attr in g.edge_attributes(): graph_union.es[i : i + ne][attr] = g.es[attr] i += ne return graph_union def union(graphs, byname="auto"): """Graph union. The union of two or more graphs is created. The graphs may have identical or overlapping vertex sets. Edges which are included in at least one graph will be part of the new graph. This function keeps the attributes of all graphs. All graph, vertex and edge attributes are copied to the result. If an attribute is present in multiple graphs and would result a name clash, then this attribute is renamed by adding suffixes: _1, _2, etc. The 'name' vertex attribute is treated specially if the operation is performed based on symbolic vertex names. In this case 'name' must be present in all graphs, and it is not renamed in the result graph. An error is generated if some input graphs are directed and others are undirected. @param graphs: list of graphs. A lazy sequence is not acceptable. @param byname: bool or 'auto' specifying the function behaviour with respect to names vertices (i.e. vertices with the 'name' attribute). If False, ignore vertex names. If True, merge vertices based on names. If 'auto', use True if all graphs have named vertices and False otherwise (in the latter case, a warning is generated too). @return: the union graph """ if any(not isinstance(g, GraphBase) for g in graphs): raise TypeError("Not all elements are graphs") if byname not in (True, False, "auto"): raise ValueError('"byname" should be a bool or "auto"') ngr = len(graphs) n_named = sum(g.is_named() for g in graphs) if byname == "auto": byname = n_named == ngr if n_named not in (0, ngr): warn("Some, but not all graphs are named, not using vertex names") elif byname and (n_named != ngr): raise AttributeError("Some graphs are not named") # Now we know that byname is only used is all graphs are named # Trivial cases if ngr == 0: raise ValueError("union() needs at least one graph") if ngr == 1: return graphs[0].copy() # Now there are at least two graphs if byname: allnames = [g.vs["name"] for g in graphs] uninames = list(set.union(*(set(vns) for vns in allnames))) permutation_map = {x: i for i, x in enumerate(uninames)} nve = len(uninames) newgraphs = [] for g, vertex_names in zip(graphs, allnames): # Make a copy ng = g.copy() # Add the missing vertices v_missing = list(set(uninames) - set(vertex_names)) ng.add_vertices(v_missing) # Reorder vertices to match uninames # vertex k -> p[k] permutation = [permutation_map[x] for x in ng.vs["name"]] ng = ng.permute_vertices(permutation) newgraphs.append(ng) else: newgraphs = graphs # If any graph has any edge attributes, we need edgemaps edgemaps = any(len(g.edge_attributes()) for g in graphs) res = _union(newgraphs, edgemaps) if edgemaps: graph_union = res["graph"] edgemaps = res["edgemaps"] else: graph_union = res # Graph attributes a_first_graph = {} a_conflict = set() for ig, g in enumerate(newgraphs, 1): # NOTE: a_name is the name of the attribute, a_value its value for a_name in g.attributes(): a_value = g[a_name] # No conflicts if a_name not in graph_union.attributes(): a_first_graph[a_name] = ig graph_union[a_name] = a_value continue if graph_union[a_name] == a_value: continue if a_name not in a_conflict: # New conflict a_conflict.add(a_name) igf = a_first_graph[a_name] # Delete the previous attribute and set attribute with # a record about the graph of origin graph_union["{:}_{:}".format(a_name, igf)] = graph_union[a_name] del graph_union[a_name] graph_union["{:}_{:}".format(a_name, ig)] = a_value # Vertex attributes if byname: graph_union.vs["name"] = uninames attrs = set.union(*(set(g.vertex_attributes()) for g in newgraphs)) - set(["name"]) nve = graph_union.vcount() for a_name in attrs: # Check for conflicts at at least one vertex conflict = False vals = [None for i in range(nve)] for g in newgraphs: if a_name in g.vertex_attributes(): for i, a_value in enumerate(g.vs[a_name]): if a_value is None: continue if vals[i] is None: vals[i] = a_value continue if vals[i] != a_value: conflict = True break if conflict: break if not conflict: graph_union.vs[a_name] = vals continue # There is a conflict, name after the graph number for ig, g in enumerate(newgraphs, 1): if a_name in g.vertex_attributes(): graph_union.vs["{:}_{:}".format(a_name, ig)] = g.vs[a_name] # Edge attributes if edgemaps: attrs = set.union(*(set(g.edge_attributes()) for g in newgraphs)) ne = graph_union.ecount() for a_name in attrs: # Check for conflicts at at least one edge conflict = False vals = [None for i in range(ne)] for g, emap in zip(newgraphs, edgemaps): if a_name not in g.edge_attributes(): continue for iu, a_value in zip(emap, g.es[a_name]): if a_value is None: continue if vals[iu] is None: vals[iu] = a_value continue if vals[iu] != a_value: print(g, g.vs["name"], emap, a_value, iu, vals[iu]) conflict = True break if conflict: break if not conflict: graph_union.es[a_name] = vals continue # There is a conflict, name after the graph number for ig, (g, emap) in enumerate(zip(newgraphs, edgemaps), 1): if a_name not in g.edge_attributes(): continue # Pass through map vals = [None for i in range(ne)] for iu, a_value in zip(emap, g.es[a_name]): vals[iu] = a_value graph_union.es["{:}_{:}".format(a_name, ig)] = vals return graph_union def intersection(graphs, byname="auto", keep_all_vertices=True): """Graph intersection. The intersection of two or more graphs is created. The graphs may have identical or overlapping vertex sets. Edges which are included in all graphs will be part of the new graph. This function keeps the attributes of all graphs. All graph, vertex and edge attributes are copied to the result. If an attribute is present in multiple graphs and would result a name clash, then this attribute is renamed by adding suffixes: _1, _2, etc. The 'name' vertex attribute is treated specially if the operation is performed based on symbolic vertex names. In this case 'name' must be present in all graphs, and it is not renamed in the result graph. An error is generated if some input graphs are directed and others are undirected. @param graphs: list of graphs. A lazy sequence is not acceptable. @param byname: bool or 'auto' specifying the function behaviour with respect to names vertices (i.e. vertices with the 'name' attribute). If False, ignore vertex names. If True, merge vertices based on names. If 'auto', use True if all graphs have named vertices and False otherwise (in the latter case, a warning is generated too). @param keep_all_vertices: bool specifying if vertices that are not present in all graphs should be kept in the intersection. @return: the intersection graph """ if any(not isinstance(g, GraphBase) for g in graphs): raise TypeError("Not all elements are graphs") if byname not in (True, False, "auto"): raise ValueError('"byname" should be a bool or "auto"') ngr = len(graphs) n_named = sum(g.is_named() for g in graphs) if byname == "auto": byname = n_named == ngr if n_named not in (0, ngr): warn("Some, but not all graphs are named, not using vertex names") elif byname and (n_named != ngr): raise AttributeError("Some graphs are not named") # Now we know that byname is only used is all graphs are named # Trivial cases if ngr == 0: raise ValueError("intersection() needs at least one graph") if ngr == 1: return graphs[0].copy() # Now there are at least two graphs if byname: allnames = [g.vs["name"] for g in graphs] if keep_all_vertices: uninames = list(set.union(*(set(vns) for vns in allnames))) else: uninames = list(set.intersection(*(set(vns) for vns in allnames))) permutation_map = {x: i for i, x in enumerate(uninames)} nv = len(uninames) newgraphs = [] for g, vertex_names in zip(graphs, allnames): # Make a copy ng = g.copy() if keep_all_vertices: # Add the missing vertices v_missing = list(set(uninames) - set(vertex_names)) ng.add_vertices(v_missing) else: # Delete the private vertices v_private = list(set(vertex_names) - set(uninames)) ng.delete_vertices(v_private) # Reorder vertices to match uninames # vertex k -> p[k] permutation = [permutation_map[x] for x in ng.vs["name"]] ng = ng.permute_vertices(permutation) newgraphs.append(ng) else: newgraphs = graphs # If any graph has any edge attributes, we need edgemaps edgemaps = any(len(g.edge_attributes()) for g in graphs) res = _intersection(newgraphs, edgemaps) if edgemaps: graph_intsec = res["graph"] edgemaps = res["edgemaps"] else: graph_intsec = res # Graph attributes a_first_graph = {} a_conflict = set() for ig, g in enumerate(newgraphs, 1): # NOTE: a_name is the name of the attribute, a_value its value for a_name in g.attributes(): a_value = g[a_name] # No conflicts if a_name not in graph_intsec.attributes(): a_first_graph[a_name] = ig graph_intsec[a_name] = a_value continue if graph_intsec[a_name] == a_value: continue if a_name not in a_conflict: # New conflict a_conflict.add(a_name) igf = a_first_graph[a_name] graph_intsec["{:}_{:}".format(a_name, igf)] = graph_intsec[a_name] del graph_intsec[a_name] graph_intsec["{:}_{:}".format(a_name, ig)] = a_value # Vertex attributes if byname: graph_intsec.vs["name"] = uninames attrs = set.union(*(set(g.vertex_attributes()) for g in newgraphs)) - set(["name"]) nv = graph_intsec.vcount() for a_name in attrs: # Check for conflicts at at least one vertex conflict = False vals = [None for i in range(nv)] for g in newgraphs: if a_name not in g.vertex_attributes(): continue for i, a_value in enumerate(g.vs[a_name]): if a_value is None: continue if vals[i] is None: vals[i] = a_value continue if vals[i] != a_value: conflict = True break if conflict: break if not conflict: graph_intsec.vs[a_name] = vals continue # There is a conflict, name after the graph number for ig, g in enumerate(newgraphs, 1): if a_name in g.vertex_attributes(): graph_intsec.vs["{:}_{:}".format(a_name, ig)] = g.vs[a_name] # Edge attributes if edgemaps: attrs = set.union(*(set(g.edge_attributes()) for g in newgraphs)) ne = graph_intsec.ecount() for a_name in attrs: # Check for conflicts at at least one edge conflict = False vals = [None for i in range(ne)] for g, emap in zip(newgraphs, edgemaps): if a_name not in g.edge_attributes(): continue for iu, a_value in zip(emap, g.es[a_name]): if iu == -1: continue if a_value is None: continue if vals[iu] is None: vals[iu] = a_value continue if vals[iu] != a_value: conflict = True break if conflict: break if not conflict: graph_intsec.es[a_name] = vals continue # There is a conflict, name after the graph number for ig, (g, emap) in enumerate(zip(newgraphs, edgemaps), 1): if a_name not in g.edge_attributes(): continue # Pass through map vals = [None for i in range(ne)] for iu, a_value in zip(emap, g.es[a_name]): if iu == -1: continue vals[iu] = a_value graph_intsec.es["{:}_{:}".format(a_name, ig)] = vals return graph_intsec ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4111395 igraph-0.9.9/src/igraph/remote/0000755000175100001710000000000000000000000017137 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/remote/__init__.py0000644000175100001710000000010500000000000021244 0ustar00runnerdocker00000000000000"""Classes that help igraph communicate with remote applications.""" ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/remote/gephi.py0000644000175100001710000002417000000000000020611 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Classes that help igraph communicate with Gephi (http://www.gephi.org).""" import json import urllib.error import urllib.parse import urllib.request __all__ = ("GephiConnection", "GephiGraphStreamer", "GephiGraphStreamingAPIFormat") __docformat__ = "restructuredtext en" class GephiConnection: """Object that represents a connection to a Gephi master server.""" def __init__(self, url=None, host="127.0.0.1", port=8080, workspace=1): """Constructs a connection to a Gephi master server. The connection object can be constructed either by specifying the `url` directly, or by specifying the `host`, `port` and `workspace` arguments. The latter three are evaluated only if `url` is None; otherwise the `url` will take precedence. The `url` argument does not have to include the operation (e.g., ``?operation=updateGraph``); the connection will take care of it. E.g., if you wish to connect to workspace 2 in a local Gephi instance on port 7341, the correct form to use for the `url` is as follows:: http://localhost:7341/workspace0 """ self._pending_operations = [] self._autoflush_threshold = 1024 self.url = url or self._construct_default_url(host, port, workspace) def __del__(self): try: self.close() except urllib.error.URLError: # Happens when Gephi is closed before the connection is destroyed pass def _construct_default_url(self, host, port, workspace): return "http://%s:%d/workspace%d" % (host, port, workspace) def close(self): """Flushes all the pending operations to the Gephi master server in a single request.""" self.flush() def flush(self): """Flushes all the pending operations to the Gephi master server in a single request.""" data = b"".join(self._pending_operations) self._pending_operations = [] conn = urllib.request.urlopen(self._update_url, data=data) return conn.read() @property def url(self): """The URL of the Gephi workspace where the data will be sent.""" return self._url_root @url.setter def url(self, value): self._url_root = value self._get_url = self._url_root + "?operation=getGraph" self._update_url = self._url_root + "?operation=updateGraph" def write(self, data): """Sends the given raw data to the Gephi streaming master server in an HTTP POST request.""" self._pending_operations.append(data) if len(self._pending_operations) >= self._autoflush_threshold: self.flush() def __repr__(self): return "%s(url=%r)" % (self.__class__.__name__, self.url) class GephiGraphStreamingAPIFormat: """Object that implements the Gephi graph streaming API format and returns Python objects corresponding to the events defined in the API. """ def get_add_node_event(self, identifier, attributes={}): """Generates a Python object corresponding to the event that adds a node with the given identifier and attributes in the Gephi graph streaming API. Example:: >>> api = GephiGraphStreamingAPIFormat() >>> api.get_add_node_event("spam") {'an': {'spam': {}}} >>> api.get_add_node_event("spam", dict(ham="eggs")) {'an': {'spam': {'ham': 'eggs'}}} """ return {"an": {identifier: attributes}} def get_add_edge_event(self, identifier, source, target, directed, attributes={}): """Generates a Python object corresponding to the event that adds an edge with the given source, target, directednessr and attributes in the Gephi graph streaming API. """ result = dict(attributes) result["source"] = source result["target"] = target result["directed"] = bool(directed) return {"ae": {identifier: result}} def get_change_node_event(self, identifier, attributes): """Generates a Python object corresponding to the event that changes the attributes of some node in the Gephi graph streaming API. The given attributes are merged into the existing ones; use C{None} as the attribute value to delete a given attribute. Example:: >>> api = GephiGraphStreamingAPIFormat() >>> api.get_change_node_event("spam", dict(ham="eggs")) {'cn': {'spam': {'ham': 'eggs'}}} >>> api.get_change_node_event("spam", dict(ham=None)) {'cn': {'spam': {'ham': None}}} """ return {"cn": {identifier: attributes}} def get_change_edge_event(self, identifier, attributes): """Generates a Python object corresponding to the event that changes the attributes of some edge in the Gephi graph streaming API. The given attributes are merged into the existing ones; use C{None} as the attribute value to delete a given attribute. Example:: >>> api = GephiGraphStreamingAPIFormat() >>> api.get_change_edge_event("spam", dict(ham="eggs")) {'ce': {'spam': {'ham': 'eggs'}}} >>> api.get_change_edge_event("spam", dict(ham=None)) {'ce': {'spam': {'ham': None}}} """ return {"ce": {identifier: attributes}} def get_delete_node_event(self, identifier): """Generates a Python object corresponding to the event that deletes a node with the given identifier in the Gephi graph streaming API. Example:: >>> api = GephiGraphStreamingAPIFormat() >>> api.get_delete_node_event("spam") {'dn': {'spam': {}}} """ return {"dn": {identifier: {}}} def get_delete_edge_event(self, identifier): """Generates a Python object corresponding to the event that deletes an edge with the given identifier in the Gephi graph streaming API. Example:: >>> api = GephiGraphStreamingAPIFormat() >>> api.get_delete_edge_event("spam:ham") {'de': {'spam:ham': {}}} """ return {"de": {identifier: {}}} class GephiGraphStreamer: """Class that produces JSON event objects that stream an igraph graph to Gephi using the Gephi Graph Streaming API. The Gephi graph streaming format is a simple JSON-based format that can be used to post mutations to a graph (i.e. node and edge additions, removals and updates) to a remote component. For instance, one can open up Gephi (http://www.gephi.org), install the Gephi graph streaming plugin and then send a graph from igraph straight into the Gephi window by using `GephiGraphStreamer` with the appropriate URL where Gephi is listening. Example:: >>> from cStringIO import StringIO >>> from igraph import Graph >>> buf = StringIO() >>> streamer = GephiGraphStreamer() >>> graph = Graph.Formula("A --> B, B --> C") >>> streamer.post(graph, buf) >>> print(buf.getvalue()) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE {"an": {"igraph:...:v:0": {"name": "A"}}} {"an": {"igraph:...:v:1": {"name": "B"}}} {"an": {"igraph:...:v:2": {"name": "C"}}} {"ae": {"igraph:...:e:0:1": {...}}} {"ae": {"igraph:...:e:1:2": {...}}} """ def __init__(self, encoder=None): """Constructs a Gephi graph streamer that will post graphs to a given file-like object or a Gephi connection. `encoder` must either be ``None`` or an instance of ``json.JSONEncoder`` and it must contain the JSON encoder to be used when posting JSON objects. """ self.encoder = encoder or json.JSONEncoder(ensure_ascii=True) self.format = GephiGraphStreamingAPIFormat() def iterjsonobj(self, graph): """Iterates over the JSON objects that build up the graph using the Gephi graph streaming API. The objects returned from this function are Python objects; they must be formatted with ``json.dumps`` before sending them to the destination.""" # Construct a unique ID prefix id_prefix = "igraph:%s" % (hex(id(graph)),) # Add the vertices add_node = self.format.get_add_node_event for vertex in graph.vs: yield add_node("%s:v:%d" % (id_prefix, vertex.index), vertex.attributes()) # Add the edges add_edge = self.format.get_add_edge_event directed = graph.is_directed() for edge in graph.es: yield add_edge( "%s:e:%d:%d" % (id_prefix, edge.source, edge.target), "%s:v:%d" % (id_prefix, edge.source), "%s:v:%d" % (id_prefix, edge.target), directed, edge.attributes(), ) def post(self, graph, destination, encoder=None): """Posts the given graph to the destination of the streamer using the given JSON encoder. When `encoder` is ``None``, it falls back to the default JSON encoder of the streamer in the `encoder` property. `destination` must be a file-like object or an instance of `GephiConnection`. """ encoder = encoder or self.encoder for jsonobj in self.iterjsonobj(graph): self.send_event(jsonobj, destination, encoder=encoder, flush=False) destination.flush() def send_event(self, event, destination, encoder=None, flush=True): """Sends a single JSON event to the given destination using the given JSON encoder. When `encoder` is ``None``, it falls back to the default JSON encoder of the streamer in the `encoder` property. `destination` must be a file-like object or an instance of `GephiConnection`. The method flushes the destination after sending the event. If you want to avoid this (e.g., because you are sending many events), set `flush` to ``False``. """ encoder = encoder or self.encoder destination.write(encoder.encode(event).encode("utf-8")) destination.write(b"\r\n") if flush: destination.flush() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/sparse_matrix.py0000644000175100001710000001311000000000000021073 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Implementation of Python-level sparse matrix operations.""" from __future__ import with_statement __all__ = () __docformat__ = "restructuredtext en" from operator import add from igraph._igraph import ( ADJ_DIRECTED, ADJ_UNDIRECTED, ADJ_MAX, ADJ_MIN, ADJ_PLUS, ADJ_UPPER, ADJ_LOWER, ) _SUPPORTED_MODES = ("directed", "undirected", "max", "min", "plus", "lower", "upper") def _convert_mode_argument(mode): # resolve mode constants, convert to lowercase mode = ( { ADJ_DIRECTED: "directed", ADJ_UNDIRECTED: "undirected", ADJ_MAX: "max", ADJ_MIN: "min", ADJ_PLUS: "plus", ADJ_UPPER: "upper", ADJ_LOWER: "lower", } .get(mode, mode) .lower() ) if mode not in _SUPPORTED_MODES: raise ValueError("mode should be one of " + (" ".join(_SUPPORTED_MODES))) if mode == "undirected": mode = "max" return mode # Logic to get graph from scipy sparse matrix. This would be simple if there # weren't so many modes. def _graph_from_sparse_matrix(klass, matrix, mode="directed"): """Construct graph from sparse matrix, unweighted""" # This function assumes there is scipy and the matrix is a scipy sparse # matrix. The caller should make sure those conditions are met. from scipy import sparse if not isinstance(matrix, sparse.coo_matrix): matrix = matrix.tocoo() nvert = max(matrix.shape) if min(matrix.shape) != nvert: raise ValueError("Matrix must be square") # Shorthand notation m = matrix mode = _convert_mode_argument(mode) if mode == "directed": edges = sum( ([(i, j)] * n for i, j, n in zip(m.row, m.col, m.data)), [], ) elif mode in ("max", "plus"): fun = max if mode == "max" else add nedges = {} for i, j, n in zip(m.row, m.col, m.data): pair = (i, j) if i < j else (j, i) nedges[pair] = fun(nedges.get(pair, 0), n) edges = sum( ([e] * n for e, n in nedges.items()), [], ) elif mode == "min": tmp = {(i, j): n for i, j, n in zip(m.row, m.col, m.data)} nedges = {} for pair, weight in tmp.items(): i, j = pair if i == j: nedges[pair] = weight elif i < j: nedges[pair] = min(weight, tmp.get((j, i), 0)) edges = sum( ([e] * n for e, n in nedges.items()), [], ) elif mode == "upper": edges = sum( ([(i, j)] * n for i, j, n in zip(m.row, m.col, m.data) if j >= i), [], ) elif mode == "lower": edges = sum( ([(i, j)] * n for i, j, n in zip(m.row, m.col, m.data) if j <= i), [], ) else: raise ValueError("invalid mode") return klass(nvert, edges=edges, directed=(mode == "directed")) def _graph_from_weighted_sparse_matrix( klass, matrix, mode=ADJ_DIRECTED, attr="weight", loops=True ): """Construct graph from sparse matrix, weighted NOTE: Of course, you cannot emcompass a fully general weighted multigraph with a single adjacency matrix, so we don't try to do it here either. """ # This function assumes there is scipy and the matrix is a scipy sparse # matrix. The caller should make sure those conditions are met. from scipy import sparse if not isinstance(matrix, sparse.coo_matrix): matrix = matrix.tocoo() nvert = max(matrix.shape) if min(matrix.shape) != nvert: raise ValueError("Matrix must be square") # Shorthand notation m = matrix mode = _convert_mode_argument(mode) if mode == "directed": if not loops: edges, weights = [], [] for i, j, n in zip(m.row, m.col, m.data): if i != j: edges.append((i, j)) weights.append(n) else: edges = list(zip(m.row, m.col)) weights = list(m.data) elif mode in ("max", "plus"): fun = max if mode == "max" else add nedges = {} for i, j, n in zip(m.row, m.col, m.data): if i == j and not loops: continue pair = (i, j) if i < j else (j, i) nedges[pair] = fun(nedges.get(pair, 0), n) edges, weights = zip(*nedges.items()) elif mode == "min": tmp = {(i, j): n for i, j, n in zip(m.row, m.col, m.data)} nedges = {} for pair, weight in tmp.items(): i, j = pair if i == j and loops: nedges[pair] = weight elif i < j: nedges[pair] = min(weight, tmp.get((j, i), 0)) edges, weights = [], [] for pair in sorted(nedges.keys()): weight = nedges[pair] if weight != 0: edges.append(pair) weights.append(nedges[pair]) elif mode == "upper": edges, weights = [], [] for i, j, n in zip(m.row, m.col, m.data): if j > i or (loops and j == i): edges.append((i, j)) weights.append(n) elif mode == "lower": edges, weights = [], [] for i, j, n in zip(m.row, m.col, m.data): if j < i or (loops and j == i): edges.append((i, j)) weights.append(n) else: raise ValueError("invalid mode") return klass( nvert, edges=edges, directed=(mode == "directed"), edge_attrs={attr: weights} ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/statistics.py0000644000175100001710000005372400000000000020423 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """ Statistics related stuff in igraph """ import math __all__ = ( "FittedPowerLaw", "Histogram", "RunningMean", "mean", "median", "percentile", "quantile", "power_law_fit", ) class FittedPowerLaw: """Result of fitting a power-law to a vector of samples Example: >>> result = power_law_fit([1, 2, 3, 4, 5, 6]) >>> result # doctest:+ELLIPSIS FittedPowerLaw(continuous=False, alpha=2.42..., xmin=3.0, L=-7.54..., \ D=0.21..., p=0.993...) >>> print(result) # doctest:+ELLIPSIS Fitted power-law distribution on discrete data Exponent (alpha) = 2.42... Cutoff (xmin) = 3.000000 Log-likelihood = -7.54... H0: data was drawn from the fitted distribution KS test statistic = 0.21... p-value = 0.993... H0 could not be rejected at significance level 0.05 >>> result.alpha # doctest:+ELLIPSIS 2.42... >>> result.xmin 3.0 >>> result.continuous False """ def __init__(self, continuous, alpha, xmin, L, D, p): self.continuous = continuous self.xmin = xmin self.alpha = alpha self.L = L self.D = D self.p = p def __repr__(self): return "%s(continuous=%r, alpha=%r, xmin=%r, L=%r, D=%r, p=%r)" % ( self.__class__.__name__, self.continuous, self.alpha, self.xmin, self.L, self.D, self.p, ) def __str__(self): return self.summary(significance=0.05) def summary(self, significance=0.05): """Returns the summary of the power law fit. @param significance: the significance level of the Kolmogorov-Smirnov test used to decide whether the input data could have come from the fitted distribution @return: the summary as a string """ result = [ "Fitted power-law distribution on %s data" % ("discrete", "continuous")[bool(self.continuous)] ] result.append("") result.append("Exponent (alpha) = %f" % self.alpha) result.append("Cutoff (xmin) = %f" % self.xmin) result.append("") result.append("Log-likelihood = %f" % self.L) result.append("") result.append("H0: data was drawn from the fitted distribution") result.append("") result.append("KS test statistic = %f" % self.D) result.append("p-value = %f" % self.p) result.append("") if self.p < significance: result.append("H0 rejected at significance level %g" % significance) else: result.append( "H0 could not be rejected at significance " "level %g" % significance ) return "\n".join(result) class Histogram: """Generic histogram class for real numbers Example: >>> h = Histogram(5) # Initializing, bin width = 5 >>> h << [2,3,2,7,8,5,5,0,7,9] # Adding more items >>> print(h) N = 10, mean +- sd: 4.8000 +- 2.9740 [ 0, 5): **** (4) [ 5, 10): ****** (6) """ def __init__(self, bin_width=1, data=None): """Initializes the histogram with the given data set. @param bin_width: the bin width of the histogram. @param data: the data set to be used. Must contain real numbers. """ self._bin_width = float(bin_width) self._bins = None self._min, self._max = None, None self._running_mean = RunningMean() self.clear() if data: self.add_many(data) def _get_bin(self, num, create=False): """Returns the bin index corresponding to the given number. @param num: the number for which the bin is being sought @param create: whether to create a new bin if no bin exists yet. @return: the index of the bin or C{None} if no bin exists yet and {create} is C{False}.""" if len(self._bins) == 0: if not create: result = None else: self._min = int(num / self._bin_width) * self._bin_width self._max = self._min + self._bin_width self._bins = [0] result = 0 return result if num >= self._min: binidx = int((num - self._min) / self._bin_width) if binidx < len(self._bins): return binidx if not create: return None extra_bins = binidx - len(self._bins) + 1 self._bins.extend([0] * extra_bins) self._max = self._min + len(self._bins) * self._bin_width return binidx if not create: return None extra_bins = int(math.ceil((self._min - num) / self._bin_width)) self._bins[0:0] = [0] * extra_bins self._min -= extra_bins * self._bin_width self._max = self._min + len(self._bins) * self._bin_width return 0 @property def n(self): """Returns the number of elements in the histogram""" return len(self._running_mean) @property def mean(self): """Returns the mean of the elements in the histogram""" return self._running_mean.mean @property def sd(self): """Returns the standard deviation of the elements in the histogram""" return self._running_mean.sd @property def var(self): """Returns the variance of the elements in the histogram""" return self._running_mean.var def add(self, num, repeat=1): """Adds a single number to the histogram. @param num: the number to be added @param repeat: number of repeated additions """ num = float(num) binidx = self._get_bin(num, True) self._bins[binidx] += repeat self._running_mean.add(num, repeat) def add_many(self, data): """Adds a single number or the elements of an iterable to the histogram. @param data: the data to be added""" try: iterator = iter(data) except TypeError: iterator = iter([data]) for x in iterator: self.add(x) __lshift__ = add_many def clear(self): """Clears the collected data""" self._bins = [] self._min, self._max = None, None self._running_mean = RunningMean() def bins(self): """Generator returning the bins of the histogram in increasing order @return: a tuple with the following elements: left bound, right bound, number of elements in the bin""" x = self._min for elem in self._bins: yield (x, x + self._bin_width, elem) x += self._bin_width def __plot__(self, context, bbox, _, **kwds): """Plotting support""" from igraph.drawing.coord import DescartesCoordinateSystem coord_system = DescartesCoordinateSystem( context, bbox, ( kwds.get("min", self._min), 0, kwds.get("max", self._max), kwds.get("max_value", max(self._bins)), ), ) # Draw the boxes context.set_line_width(1) context.set_source_rgb(1.0, 0.0, 0.0) x = self._min for value in self._bins: top_left_x, top_left_y = coord_system.local_to_context(x, value) x += self._bin_width bottom_right_x, bottom_right_y = coord_system.local_to_context(x, 0) context.rectangle( top_left_x, top_left_y, bottom_right_x - top_left_x, bottom_right_y - top_left_y, ) context.fill() # Draw the axes coord_system.draw() def to_string(self, max_width=78, show_bars=True, show_counts=True): """Returns the string representation of the histogram. @param max_width: the maximal width of each line of the string This value may not be obeyed if it is too small. @param show_bars: specify whether the histogram bars should be shown @param show_counts: specify whether the histogram counts should be shown. If both I{show_bars} and I{show_counts} are C{False}, only a general descriptive statistics (number of elements, mean and standard deviation) is shown. """ if self._min is None or self._max is None: return "N = 0" # Determine how many decimal digits should we use if int(self._min) == self._min and int(self._bin_width) == self._bin_width: number_format = "%d" else: number_format = "%.3f" num_length = max(len(number_format % self._min), len(number_format % self._max)) number_format = "%" + str(num_length) + number_format[1:] format_string = "[%s, %s): %%s" % (number_format, number_format) # Calculate the scale of the bars on the histogram if show_bars: maxval = max(self._bins) if show_counts: maxval_length = len(str(maxval)) scale = maxval // (max_width - 2 * num_length - maxval_length - 9) else: scale = maxval // (max_width - 2 * num_length - 6) scale = max(scale, 1) result = ["N = %d, mean +- sd: %.4f +- %.4f" % (self.n, self.mean, self.sd)] if show_bars: # Print the bars if scale > 1: result.append("Each * represents %d items" % scale) if show_counts: format_string += " (%d)" for left, right, cnt in self.bins(): result.append( format_string % (left, right, "*" * (cnt // scale), cnt) ) else: for left, right, cnt in self.bins(): result.append(format_string % (left, right, "*" * (cnt // scale))) elif show_counts: # Print the counts only for left, right, cnt in self.bins(): result.append(format_string % (left, right, cnt)) return "\n".join(result) def __str__(self): return self.to_string() class RunningMean: """Running mean calculator. This class can be used to calculate the mean of elements from a list, tuple, iterable or any other data source. The mean is calculated on the fly without explicitly summing the values, so it can be used for data sets with arbitrary item count. Also capable of returning the standard deviation (also calculated on the fly) """ def __init__(self, items=None, n=0.0, mean=0.0, sd=0.0): """RunningMean(items=None, n=0.0, mean=0.0, sd=0.0) Initializes the running mean calculator. There are two possible ways to initialize the calculator. First, one can provide an iterable of items; alternatively, one can specify the number of items, the mean and the standard deviation if we want to continue an interrupted calculation. @param items: the items that are used to initialize the running mean calcuator. If C{items} is given, C{n}, C{mean} and C{sd} must be zeros. @param n: the initial number of elements already processed. If this is given, C{items} must be C{None}. @param mean: the initial mean. If this is given, C{items} must be C{None}. @param sd: the initial standard deviation. If this is given, C{items} must be C{None}.""" if items is not None: if n != 0 or mean != 0 or sd != 0: raise ValueError("n, mean and sd must be zeros if items is not None") self.clear() self.add_many(items) else: self._nitems = float(n) self._mean = float(mean) if n > 1: self._sqdiff = float(sd) ** 2 * float(n - 1) self._sd = float(sd) else: self._sqdiff = 0.0 self._sd = 0.0 def add(self, value, repeat=1): """RunningMean.add(value, repeat=1) Adds the given value to the elements from which we calculate the mean and the standard deviation. @param value: the element to be added @param repeat: number of repeated additions """ repeat = int(repeat) self._nitems += repeat delta = value - self._mean self._mean += repeat * delta / self._nitems self._sqdiff += (repeat * delta) * (value - self._mean) if self._nitems > 1: self._sd = (self._sqdiff / (self._nitems - 1)) ** 0.5 def add_many(self, values): """RunningMean.add(values) Adds the values in the given iterable to the elements from which we calculate the mean. Can also accept a single number. The left shift (C{<<}) operator is aliased to this function, so you can use it to add elements as well: >>> rm=RunningMean() >>> rm << [1,2,3,4] >>> rm.result # doctest:+ELLIPSIS (2.5, 1.290994...) @param values: the element(s) to be added @type values: iterable""" try: iterator = iter(values) except TypeError: iterator = iter([values]) for value in iterator: self.add(value) def clear(self): """Resets the running mean calculator.""" self._nitems, self._mean = 0.0, 0.0 self._sqdiff, self._sd = 0.0, 0.0 @property def result(self): """Returns the current mean and standard deviation as a tuple""" return self._mean, self._sd @property def mean(self): """Returns the current mean""" return self._mean @property def sd(self): """Returns the current standard deviation""" return self._sd @property def var(self): """Returns the current variation""" return self._sd ** 2 def __repr__(self): return "%s(n=%r, mean=%r, sd=%r)" % ( self.__class__.__name__, int(self._nitems), self._mean, self._sd, ) def __str__(self): return "Running mean (N=%d, %f +- %f)" % (self._nitems, self._mean, self._sd) __lshift__ = add_many def __float__(self): return float(self._mean) def __int__(self): return int(self._mean) def __complex__(self): return complex(self._mean) def __len__(self): return int(self._nitems) def mean(xs): """Returns the mean of an iterable. Example: >>> mean([1, 4, 7, 11]) 5.75 @param xs: an iterable yielding numbers. @return: the mean of the numbers provided by the iterable. @see: RunningMean() if you also need the variance or the standard deviation """ return RunningMean(xs).mean def median(xs, sort=True): """Returns the median of an unsorted or sorted numeric vector. @param xs: the vector itself. @param sort: whether to sort the vector. If you know that the vector is sorted already, pass C{False} here. @return: the median, which will always be a float, even if the vector contained integers originally. """ if sort: xs = sorted(xs) mid = int(len(xs) / 2) if 2 * mid == len(xs): return float(xs[mid - 1] + xs[mid]) / 2 else: return float(xs[mid]) def percentile(xs, p=(25, 50, 75), sort=True): """Returns the pth percentile of an unsorted or sorted numeric vector. This is equivalent to calling quantile(xs, p/100.0); see L{quantile} for more details on the calculation. Example: >>> round(percentile([15, 20, 40, 35, 50], 40), 2) 26.0 >>> for perc in percentile([15, 20, 40, 35, 50], (0, 25, 50, 75, 100)): ... print("%.2f" % perc) ... 15.00 17.50 35.00 45.00 50.00 @param xs: the vector itself. @param p: the percentile we are looking for. It may also be a list if you want to calculate multiple quantiles with a single call. The default value calculates the 25th, 50th and 75th percentile. @param sort: whether to sort the vector. If you know that the vector is sorted already, pass C{False} here. @return: the pth percentile, which will always be a float, even if the vector contained integers originally. If p is a list, the result will also be a list containing the percentiles for each item in the list. """ if hasattr(p, "__iter__"): return quantile(xs, (x / 100.0 for x in p), sort) return quantile(xs, p / 100.0, sort) def power_law_fit(data, xmin=None, method="auto", return_alpha_only=False): """Fitting a power-law distribution to empirical data @param data: the data to fit, a list containing integer values @param xmin: the lower bound for fitting the power-law. If C{None}, the optimal xmin value will be estimated as well. Zero means that the smallest possible xmin value will be used. @param method: the fitting method to use. The following methods are implemented so far: - C{continuous}, C{hill}: exact maximum likelihood estimation when the input data comes from a continuous scale. This is known as the Hill estimator. The statistical error of this estimator is M{(alpha-1) / sqrt(n)}, where alpha is the estimated exponent and M{n} is the number of data points above M{xmin}. The estimator is known to exhibit a small finite sample-size bias of order M{O(n^-1)}, which is small when M{n > 100}. igraph will try to compensate for the finite sample size if n is small. - C{discrete}: exact maximum likelihood estimation when the input comes from a discrete scale (see Clauset et al among the references). - C{auto}: exact maximum likelihood estimation where the continuous method is used if the input vector contains at least one fractional value and the discrete method is used if the input vector contains integers only. @return: a L{FittedPowerLaw} object. The fitted C{xmin} value and the power-law exponent can be queried from the C{xmin} and C{alpha} properties of the returned object. @newfield ref: Reference @ref: MEJ Newman: Power laws, Pareto distributions and Zipf's law. Contemporary Physics 46, 323-351 (2005) @ref: A Clauset, CR Shalizi, MEJ Newman: Power-law distributions in empirical data. E-print (2007). arXiv:0706.1062""" from igraph._igraph import _power_law_fit if xmin is None or xmin < 0: xmin = -1 method = method.lower() if method not in ("continuous", "hill", "discrete", "auto"): raise ValueError("unknown method: %s" % method) force_continuous = method in ("continuous", "hill") fit = FittedPowerLaw(*_power_law_fit(data, xmin, force_continuous)) if return_alpha_only: from igraph import deprecated deprecated( "The return_alpha_only keyword argument of power_law_fit is " "deprecated from igraph 0.7 and will be removed in igraph 0.8" ) return fit.alpha else: return fit def quantile(xs, q=(0.25, 0.5, 0.75), sort=True): """Returns the qth quantile of an unsorted or sorted numeric vector. There are a number of different ways to calculate the sample quantile. The method implemented by igraph is the one recommended by NIST. First we calculate a rank n as q(N+1), where N is the number of items in xs, then we split n into its integer component k and decimal component d. If k <= 1, we return the first element; if k >= N, we return the last element, otherwise we return the linear interpolation between xs[k-1] and xs[k] using a factor d. Example: >>> round(quantile([15, 20, 40, 35, 50], 0.4), 2) 26.0 @param xs: the vector itself. @param q: the quantile we are looking for. It may also be a list if you want to calculate multiple quantiles with a single call. The default value calculates the 25th, 50th and 75th percentile. @param sort: whether to sort the vector. If you know that the vector is sorted already, pass C{False} here. @return: the qth quantile, which will always be a float, even if the vector contained integers originally. If q is a list, the result will also be a list containing the quantiles for each item in the list. """ if not xs: raise ValueError("xs must not be empty") if sort: xs = sorted(xs) if hasattr(q, "__iter__"): qs = q return_single = False else: qs = [q] return_single = True result = [] for q in qs: if q < 0 or q > 1: raise ValueError("q must be between 0 and 1") n = float(q) * (len(xs) + 1) k, d = int(n), n - int(n) if k >= len(xs): result.append(xs[-1]) elif k < 1: result.append(xs[0]) else: result.append((1 - d) * xs[k - 1] + d * xs[k]) if return_single: result = result[0] return result def sd(xs): """Returns the standard deviation of an iterable. Example: >>> sd([1, 4, 7, 11]) #doctest:+ELLIPSIS 4.2720... @param xs: an iterable yielding numbers. @return: the standard deviation of the numbers provided by the iterable. @see: RunningMean() if you also need the mean """ return RunningMean(xs).sd def var(xs): """Returns the variance of an iterable. Example: >>> var([1, 4, 8, 11]) #doctest:+ELLIPSIS 19.333333... @param xs: an iterable yielding numbers. @return: the variance of the numbers provided by the iterable. @see: RunningMean() if you also need the mean """ return RunningMean(xs).var ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/summary.py0000644000175100001710000003374400000000000017726 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Summary representation of a graph.""" import sys from igraph.statistics import median from itertools import islice from math import ceil from texttable import Texttable from textwrap import TextWrapper __all__ = ("GraphSummary", "summary") class FakeWrapper: """Object whose interface is compatible with C{textwrap.TextWrapper} but does no wrapping.""" def __init__(self, *args, **kwds): pass def fill(self, text): return [text] def wrap(self, text): return [text] def _get_wrapper_for_width(width, *args, **kwds): """Returns a text wrapper that wraps text for the given width. @param width: the maximal width of each line that the text wrapper produces. C{None} means that no wrapping will be performed. """ if width is None: return FakeWrapper(*args, **kwds) return TextWrapper(width=width, *args, **kwds) class GraphSummary: """Summary representation of a graph. The summary representation includes a header line and the list of edges. The header line consists of C{IGRAPH}, followed by a four-character long code, the number of vertices, the number of edges, two dashes (C{--}) and the name of the graph (i.e. the contents of the C{name} attribute, if any). For instance, a header line may look like this:: IGRAPH U--- 4 5 -- The four-character code describes some basic properties of the graph. The first character is C{U} if the graph is undirected, C{D} if it is directed. The second letter is C{N} if the graph has a vertex attribute called C{name}, or a dash otherwise. The third letter is C{W} if the graph is weighted (i.e. it has an edge attribute called C{weight}), or a dash otherwise. The fourth letter is C{B} if the graph has a vertex attribute called C{type}; this is usually used for bipartite graphs. Edges may be presented as an ordinary edge list or an adjacency list. By default, this depends on the number of edges; however, you can control it with the appropriate constructor arguments. """ def __init__( self, graph, verbosity=0, width=78, edge_list_format="auto", max_rows=99999, print_graph_attributes=False, print_vertex_attributes=False, print_edge_attributes=False, full=False, ): """Constructs a summary representation of a graph. @param verbosity: the verbosity of the summary. If zero, only the header line will be returned. If one, the header line and the list of edges will both be returned. @param width: the maximal width of each line in the summary. C{None} means that no limit will be enforced. @param max_rows: the maximal number of rows to print in a single table (e.g., vertex attribute table or edge attribute table) @param edge_list_format: format of the edge list in the summary. Supported formats are: C{compressed}, C{adjlist}, C{edgelist}, C{auto}, which selects automatically from the other three based on some simple criteria. @param print_graph_attributes: whether to print graph attributes if there are any. @param print_vertex_attributes: whether to print vertex attributes if there are any. @param print_edge_attributes: whether to print edge attributes if there are any. @param full: False has no effect; True turns on the attribute printing for graph, vertex and edge attributes with verbosity 1. """ if full: print_graph_attributes = True print_vertex_attributes = True print_edge_attributes = True verbosity = max(verbosity, 1) self._graph = graph self.edge_list_format = edge_list_format.lower() self.max_rows = int(max_rows) self.print_graph_attributes = print_graph_attributes self.print_vertex_attributes = print_vertex_attributes self.print_edge_attributes = print_edge_attributes self.verbosity = verbosity self.width = width self.wrapper = _get_wrapper_for_width(self.width, break_on_hyphens=False) if self._graph.is_named(): self._edges_header = "+ edges (vertex names):" else: self._edges_header = "+ edges:" self._arrow = ["--", "->"][self._graph.is_directed()] self._arrow_format = "%%s%s%%s" % self._arrow def _construct_edgelist_adjlist(self): """Constructs the part in the summary that prints the edge list in an adjacency list format.""" result = [self._edges_header] if self._graph.vcount() == 0: return if self._graph.is_named(): names = self._graph.vs["name"] maxlen = max(len(str(name)) for name in names) format_str = "%%%ds %s %%s" % (maxlen, self._arrow) for v1, name in enumerate(names): neis = self._graph.successors(v1) neis = ", ".join(str(names[v2]) for v2 in neis) result.append(format_str % (name, neis)) else: maxlen = len(str(self._graph.vcount())) num_format = "%%%dd" % maxlen format_str = "%s %s %%s" % (num_format, self._arrow) for v1 in range(self._graph.vcount()): neis = self._graph.successors(v1) neis = " ".join(num_format % v2 for v2 in neis) result.append(format_str % (v1, neis)) # Try to wrap into multiple columns if that works with the given width if self.width is not None: maxlen = max(len(line) for line in result[1:]) colcount = int(self.width + 3) / int(maxlen + 3) if colcount > 1: # Rewrap to multiple columns nrows = len(result) - 1 colheight = int(ceil(nrows / float(colcount))) newrows = [[] for _ in range(colheight)] for i, row in enumerate(result[1:]): newrows[i % colheight].append(row.ljust(maxlen)) result[1:] = [" ".join(row) for row in newrows] return result def _construct_edgelist_compressed(self): """Constructs the part in the summary that prints the edge list in a compressed format suitable for graphs with mostly small degrees.""" result = [self._edges_header] arrow = self._arrow_format if self._graph.is_named(): names = self._graph.vs["name"] edges = ", ".join( arrow % (names[edge.source], names[edge.target]) for edge in self._graph.es ) else: edges = " ".join(arrow % edge.tuple for edge in self._graph.es) result.append(edges) return result def _construct_edgelist_edgelist(self): """Constructs the part in the summary that prints the edge list in a full edge list format.""" attrs = sorted(self._graph.edge_attributes()) table = self._new_table(headers=["", "edge"] + attrs) table.add_rows( islice(self._edge_attribute_iterator(attrs), 0, self.max_rows), header=False ) table.set_cols_align( ["l", "l"] + self._infer_column_alignment(edge_attrs=attrs) ) result = [self._edges_header] result.extend(table.draw().split("\n")) return result def _construct_graph_attributes(self): """Constructs the part in the summary that lists the graph attributes.""" attrs = self._graph.attributes() if not attrs: return [] result = ["+ graph attributes:"] attrs.sort() for attr in attrs: result.append("[[%s]]" % (attr,)) result.append(str(self._graph[attr])) return result def _construct_vertex_attributes(self): """Constructs the part in the summary that lists the vertex attributes.""" attrs = sorted(self._graph.vertex_attributes()) if not attrs or (len(attrs) == 1 and "name" in attrs): return [] table = self._new_table(headers=[""] + attrs) table.add_rows( islice(self._vertex_attribute_iterator(attrs), 0, self.max_rows), header=False, ) table.set_cols_align(["l"] + self._infer_column_alignment(vertex_attrs=attrs)) result = ["+ vertex attributes:"] result.extend(table.draw().split("\n")) return result def _construct_header(self): """Constructs the header part of the summary.""" graph = self._graph params = dict( directed="UD"[graph.is_directed()], named="-N"[graph.is_named()], weighted="-W"[graph.is_weighted()], typed="-T"["type" in graph.vertex_attributes()], vcount=graph.vcount(), ecount=graph.ecount(), ) if "name" in graph.attributes(): params["name"] = graph["name"] else: params["name"] = "" result = [ "IGRAPH %(directed)s%(named)s%(weighted)s%(typed)s " "%(vcount)d %(ecount)d -- %(name)s" % params ] attrs = ["%s (g)" % (name,) for name in sorted(graph.attributes())] attrs.extend("%s (v)" % (name,) for name in sorted(graph.vertex_attributes())) attrs.extend("%s (e)" % (name,) for name in sorted(graph.edge_attributes())) if attrs: result.append("+ attr: %s" % ", ".join(attrs)) if self.wrapper is not None: self.wrapper.subsequent_indent = " " result[-1:] = self.wrapper.wrap(result[-1]) self.wrapper.subsequent_indent = "" return result def _edge_attribute_iterator(self, attribute_order): """Returns an iterator that yields the rows of the edge attribute table in the summary. `attribute_order` must be a list containing the names of the attributes to be presented in this table.""" arrow = self._arrow_format if self._graph.is_named(): names = self._graph.vs["name"] for edge in self._graph.es: formatted_edge = arrow % (names[edge.source], names[edge.target]) yield ["[%d]" % edge.index, formatted_edge] + [ edge[attr] for attr in attribute_order ] else: for edge in self._graph.es: formatted_edge = arrow % edge.tuple yield ["[%d]" % edge.index, formatted_edge] + [ edge[attr] for attr in attribute_order ] def _infer_column_alignment(self, vertex_attrs=None, edge_attrs=None): """Infers the preferred alignment for the given vertex and edge attributes in the tables by peeking into the attribute values of the first 100 vertices or edges. Numeric attributes will be aligned right, everything else will be aligned left.""" values = [] if vertex_attrs is not None: vs = self._graph.vs[:100] values.extend(vs[attr] for attr in vertex_attrs) if edge_attrs is not None: es = self._graph.es[:100] values.extend(es[attr] for attr in edge_attrs) result = [] for vs in values: is_numeric = True try: [float(x) for x in vs] except ValueError: is_numeric = False if is_numeric: result.append("r") else: result.append("l") return result def _new_table(self, headers=None): """Constructs a new table to pretty-print vertex and edge attributes""" table = Texttable(max_width=0) table.set_deco(0) if headers is not None: table.header(headers) return table def _vertex_attribute_iterator(self, attribute_order): """Returns an iterator that yields the rows of the vertex attribute table in the summary. `attribute_order` must be a list containing the names of the attributes to be presented in this table.""" for vertex in self._graph.vs: yield ["[%d]" % vertex.index] + [vertex[attr] for attr in attribute_order] def __str__(self): """Returns the summary representation as a string.""" output = self._construct_header() if self.print_graph_attributes: output.extend(self._construct_graph_attributes()) if self.print_vertex_attributes: output.extend(self._construct_vertex_attributes()) if self.verbosity <= 0: return "\n".join(output) if self._graph.ecount() > 0: # Add the edge list if self.edge_list_format == "auto": if self.print_edge_attributes and self._graph.edge_attributes(): format = "edgelist" elif median(self._graph.degree(mode="out")) < 3: format = "compressed" else: format = "adjlist" else: format = self.edge_list_format method_name = "_construct_edgelist_%s" % format if hasattr(self, method_name): output.extend(getattr(self, method_name)()) if self.wrapper is not None: return "\n".join("\n".join(self.wrapper.wrap(line)) for line in output) return "\n".join(output) def summary(obj, stream=None, *args, **kwds): """Prints a summary of object o to a given stream Positional and keyword arguments not explicitly mentioned here are passed on to the underlying C{summary()} method of the object if it has any. @param obj: the object about which a human-readable summary is requested. @param stream: the stream to be used. If C{None}, the standard output will be used. """ if stream is None: stream = sys.stdout if hasattr(obj, "summary"): stream.write(obj.summary(*args, **kwds)) else: stream.write(str(obj)) stream.write("\n") ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/utils.py0000644000175100001710000002760100000000000017364 0ustar00runnerdocker00000000000000# vim:ts=4:sw=4:sts=4:et # -*- coding: utf-8 -*- """Utility functions that cannot be categorised anywhere else.""" from contextlib import contextmanager from collections.abc import MutableMapping from ctypes import c_double, sizeof from itertools import chain import os import tempfile __all__ = ( "dbl_epsilon", "multidict", "named_temporary_file", "numpy_to_contiguous_memoryview", "rescale", "safemin", "safemax", ) __docformat__ = "restructuredtext en" def _is_running_in_ipython(): """Internal function that determines whether igraph is running inside IPython or not.""" try: from IPython import get_ipython return get_ipython() is not None except ImportError: return False @contextmanager def named_temporary_file(*args, **kwds): """Context manager that creates a named temporary file and returns its name. All parameters are passed on to ``tempfile.mkstemp``, see its documentation for more info. """ handle, tmpfile = tempfile.mkstemp(*args, **kwds) os.close(handle) try: yield tmpfile finally: os.unlink(tmpfile) def numpy_to_contiguous_memoryview(obj): """Converts a NumPy array or matrix into a contiguous memoryview object that is suitable to be forwarded to the Graph constructor. This is used internally to allow us to use a NumPy array or matrix directly when constructing a Graph. """ # Deferred import to prevent a hard dependency on NumPy from numpy import float32, float64, require size = sizeof(c_double) if size == 8: dtype = float64 elif size == 4: dtype = float32 else: raise TypeError("size of C double (%d bytes) is not supported" % size) return memoryview(require(obj, dtype=dtype, requirements="AC")) def rescale(values, out_range=(0.0, 1.0), in_range=None, clamp=False, scale=None): """Rescales a list of numbers into a given range. `out_range` gives the range of the output values; by default, the minimum of the original numbers in the list will be mapped to the first element in the output range and the maximum will be mapped to the second element. Elements between the minimum and maximum values in the input list will be interpolated linearly between the first and second values of the output range. `in_range` may be used to override which numbers are mapped to the first and second values of the output range. This must also be a tuple, where the first element will be mapped to the first element of the output range and the second element to the second. If `clamp` is ``True``, elements which are outside the given `out_range` after rescaling are clamped to the output range to ensure that no number will be outside `out_range` in the result. If `scale` is not ``None``, it will be called for every element of `values` and the rescaling will take place on the results instead. This can be used, for instance, to transform the logarithm of the original values instead of the actual values. A typical use-case is to map a range of values to color identifiers on a logarithmic scale. Scaling also applies to the `in_range` parameter if present. Examples: >>> rescale(range(5), (0, 8)) [0.0, 2.0, 4.0, 6.0, 8.0] >>> rescale(range(5), (2, 10)) [2.0, 4.0, 6.0, 8.0, 10.0] >>> rescale(range(5), (0, 4), (1, 3)) [-2.0, 0.0, 2.0, 4.0, 6.0] >>> rescale(range(5), (0, 4), (1, 3), clamp=True) [0.0, 0.0, 2.0, 4.0, 4.0] >>> rescale([0]*5, (1, 3)) [2.0, 2.0, 2.0, 2.0, 2.0] >>> from math import log10 >>> rescale([1, 10, 100, 1000, 10000], (0, 8), scale=log10) [0.0, 2.0, 4.0, 6.0, 8.0] >>> rescale([1, 10, 100, 1000, 10000], (0, 4), (10, 1000), scale=log10) [-2.0, 0.0, 2.0, 4.0, 6.0] """ if scale is not None: values = [scale(value) for value in values] if in_range is None: mi, ma = min(values), max(values) else: mi, ma = in_range if scale is not None: mi, ma = scale(mi), scale(ma) ratio = float(ma - mi) if not ratio: return [(out_range[0] + out_range[1]) / 2.0] * len(values) min_out, max_out = list(map(float, out_range)) ratio = (max_out - min_out) / ratio result = [(x - mi) * ratio + min_out for x in values] if clamp: return [max(min(x, max_out), min_out) for x in result] else: return result def str_to_orientation(value, reversed_horizontal=False, reversed_vertical=False): """Tries to interpret a string as an orientation value. The following basic values are understood: ``left-right``, ``bottom-top``, ``right-left``, ``top-bottom``. Possible aliases are: - ``horizontal``, ``horiz``, ``h`` and ``lr`` for ``left-right`` - ``vertical``, ``vert``, ``v`` and ``tb`` for top-bottom. - ``lr`` for ``left-right``. - ``rl`` for ``right-left``. ``reversed_horizontal`` reverses the meaning of ``horizontal``, ``horiz`` and ``h`` to ``rl`` (instead of ``lr``); similarly, ``reversed_vertical`` reverses the meaning of ``vertical``, ``vert`` and ``v`` to ``bt`` (instead of ``tb``). Returns one of ``lr``, ``rl``, ``tb`` or ``bt``, or throws ``ValueError`` if the string cannot be interpreted as an orientation. """ aliases = { "left-right": "lr", "right-left": "rl", "top-bottom": "tb", "bottom-top": "bt", "top-down": "tb", "bottom-up": "bt", "top-bottom": "tb", "bottom-top": "bt", "td": "tb", "bu": "bt", } dir = ["lr", "rl"][reversed_horizontal] aliases.update(horizontal=dir, horiz=dir, h=dir) dir = ["tb", "bt"][reversed_vertical] aliases.update(vertical=dir, vert=dir, v=dir) result = aliases.get(value, value) if result not in ("lr", "rl", "tb", "bt"): raise ValueError("unknown orientation: %s" % result) return result def consecutive_pairs(iterable, circular=False): """Returns consecutive pairs of items from the given iterable. When `circular` is ``True``, the pair consisting of the last and first elements is also returned. Example: >>> list(consecutive_pairs(range(5))) [(0, 1), (1, 2), (2, 3), (3, 4)] >>> list(consecutive_pairs(range(5), circular=True)) [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)] >>> list(consecutive_pairs([])) [] >>> list(consecutive_pairs([], circular=True)) [] >>> list(consecutive_pairs([0])) [] >>> list(consecutive_pairs([0], circular=True)) [(0, 0)] """ it = iter(iterable) try: prev = next(it) except StopIteration: return first = prev for item in it: yield prev, item prev = item if circular: try: yield item, first except UnboundLocalError: yield first, first class multidict(MutableMapping): """A dictionary-like object that is customized to deal with multiple values for the same key. Each value in this dictionary will be a list. Methods which emulate the methods of a standard Python `dict` object will return or manipulate the first items of the lists only. Special methods are provided to deal with keys having multiple values. """ def __init__(self, *args, **kwds): self._dict = {} if len(args) > 1: raise ValueError( "%r expected at most 1 argument, got %d" % (self.__class__.__name__, len(args)) ) if args: args = args[0] self.update(args) self.update(kwds) def __contains__(self, key): """Returns whether there are any items associated to the given `key`.""" try: return len(self._dict[key]) > 0 except KeyError: return False def __delitem__(self, key): """Removes all the items associated to the given `key`.""" del self._dict[key] def __getitem__(self, key): """Returns an arbitrary item associated to the given key. Raises ``KeyError`` if no such key exists. Example: >>> d = multidict([("spam", "eggs"), ("spam", "bacon")]) >>> d["spam"] 'eggs' """ try: return self._dict[key][0] except IndexError: raise KeyError(key) def __iter__(self): """Iterates over the keys of the multidict.""" return iter(self._dict) def __len__(self): """Returns the number of distinct keys in this multidict.""" return len(self._dict) def __setitem__(self, key, value): """Sets the item associated to the given `key`. Any values associated to the key will be erased and replaced by `value`. Example: >>> d = multidict([("spam", "eggs"), ("spam", "bacon")]) >>> d["spam"] = "ham" >>> d["spam"] 'ham' """ self._dict[key] = [value] def add(self, key, value): """Adds `value` to the list of items associated to `key`. Example: >>> d = multidict() >>> d.add("spam", "ham") >>> d["spam"] 'ham' >>> d.add("spam", "eggs") >>> d.getlist("spam") ['ham', 'eggs'] """ try: self._dict[key].append(value) except KeyError: self._dict[key] = [value] def clear(self): """Removes all the items from the multidict.""" self._dict.clear() def get(self, key, default=None): """Returns an arbitrary item associated to the given `key`. If `key` does not exist or has zero associated items, `default` will be returned.""" try: items = self._dict[key] return items[0] except (KeyError, IndexError): return default def getlist(self, key): """Returns the list of values for the given `key`. An empty list will be returned if there is no such key.""" try: return self._dict[key] except KeyError: return [] def iterlists(self): """Iterates over ``(key, values)`` pairs where ``values`` is the list of values associated with ``key``.""" return iter(self._dict.items()) def lists(self): """Returns a list of ``(key, values)`` pairs where ``values`` is the list of values associated with ``key``.""" return list(self._dict.items()) def update(self, arg, **kwds): if hasattr(arg, "keys") and callable(arg.keys): for key in list(arg.keys()): self.add(key, arg[key]) else: for key, value in arg: self.add(key, value) for key, value in kwds.items(): self.add(key, value) def safemax(iterable, default=0): """Safer variant of ``max()`` that returns a default value if the iterable is empty. Example: >>> safemax([-5, 6, 4]) 6 >>> safemax([]) 0 >>> safemax((), 2) 2 """ it = iter(iterable) try: first = next(it) except StopIteration: return default else: return max(chain([first], it)) def safemin(iterable, default=0): """Safer variant of ``min()`` that returns a default value if the iterable is empty. Example: >>> safemin([-5, 6, 4]) -5 >>> safemin([]) 0 >>> safemin((), 2) 2 """ it = iter(iterable) try: first = next(it) except StopIteration: return default else: return min(chain([first], it)) def dbl_epsilon(): """Approximates the machine epsilon value for doubles.""" epsilon = 1.0 while 1.0 + epsilon / 2.0 != 1.0: epsilon /= 2 return epsilon dbl_epsilon = dbl_epsilon() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/src/igraph/version.py0000644000175100001710000000013700000000000017704 0ustar00runnerdocker00000000000000__version_info__ = (0, 9, 9) __version__ = ".".join("{0}".format(x) for x in __version_info__) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4111395 igraph-0.9.9/src/igraph.egg-info/0000755000175100001710000000000000000000000017336 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/src/igraph.egg-info/PKG-INFO0000644000175100001710000000451500000000000020440 0ustar00runnerdocker00000000000000Metadata-Version: 2.1 Name: igraph Version: 0.9.9 Summary: High performance graph data structures and algorithms Home-page: https://igraph.org/python Author: Tamas Nepusz Author-email: ntamas@gmail.com License: GNU General Public License (GPL) Project-URL: Bug Tracker, https://github.com/igraph/python-igraph/issues Project-URL: Changelog, https://github.com/igraph/python-igraph/blob/master/CHANGELOG.md Project-URL: CI, https://github.com/igraph/python-igraph/actions Project-URL: Documentation, https://igraph.org/python/doc Project-URL: Source Code, https://github.com/igraph/python-igraph Description: Python interface to the igraph high performance graph library, primarily aimed at complex network research and analysis. Graph plotting functionality is provided by the Cairo library, so make sure you install the Python bindings of Cairo if you want to generate publication-quality graph plots. You can try either `pycairo `_ or `cairocffi `_, ``cairocffi`` is recommended because there were bug reports affecting igraph graph plots in Jupyter notebooks when using ``pycairo`` (but not with ``cairocffi``). Keywords: graph,network,mathematics,math,graph theory,discrete mathematics Platform: ALL Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: Operating System :: OS Independent Classifier: Programming Language :: C Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Information Analysis Classifier: Topic :: Scientific/Engineering :: Mathematics Classifier: Topic :: Scientific/Engineering :: Physics Classifier: Topic :: Scientific/Engineering :: Bio-Informatics Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires-Python: >=3.6 Provides-Extra: plotting Provides-Extra: test Provides-Extra: doc ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/src/igraph.egg-info/SOURCES.txt0000644000175100001710000031615200000000000021232 0ustar00runnerdocker00000000000000LICENSE MANIFEST.in README.md setup.py scripts/igraph scripts/mkdoc.sh src/_igraph/arpackobject.c src/_igraph/arpackobject.h src/_igraph/attributes.c src/_igraph/attributes.h src/_igraph/bfsiter.c src/_igraph/bfsiter.h src/_igraph/common.c src/_igraph/common.h src/_igraph/convert.c src/_igraph/convert.h src/_igraph/dfsiter.c src/_igraph/dfsiter.h src/_igraph/edgeobject.c src/_igraph/edgeobject.h src/_igraph/edgeseqobject.c src/_igraph/edgeseqobject.h src/_igraph/error.c src/_igraph/error.h src/_igraph/filehandle.c src/_igraph/filehandle.h src/_igraph/force_cpp_linker.cpp src/_igraph/graphobject.c src/_igraph/graphobject.h src/_igraph/igraphmodule.c src/_igraph/igraphmodule_api.h src/_igraph/indexing.c src/_igraph/indexing.h src/_igraph/operators.c src/_igraph/operators.h src/_igraph/platform.h src/_igraph/preamble.h src/_igraph/pyhelpers.c src/_igraph/pyhelpers.h src/_igraph/random.c src/_igraph/random.h src/_igraph/vertexobject.c src/_igraph/vertexobject.h src/_igraph/vertexseqobject.c src/_igraph/vertexseqobject.h src/igraph/__init__.py src/igraph/clustering.py src/igraph/configuration.py src/igraph/cut.py src/igraph/datatypes.py src/igraph/formula.py src/igraph/layout.py src/igraph/matching.py src/igraph/operators.py src/igraph/sparse_matrix.py src/igraph/statistics.py src/igraph/summary.py src/igraph/utils.py src/igraph/version.py src/igraph.egg-info/PKG-INFO src/igraph.egg-info/SOURCES.txt src/igraph.egg-info/dependency_links.txt src/igraph.egg-info/requires.txt src/igraph.egg-info/top_level.txt src/igraph/app/__init__.py src/igraph/app/shell.py src/igraph/drawing/__init__.py src/igraph/drawing/baseclasses.py src/igraph/drawing/colors.py src/igraph/drawing/coord.py src/igraph/drawing/edge.py src/igraph/drawing/graph.py src/igraph/drawing/metamagic.py src/igraph/drawing/shapes.py src/igraph/drawing/text.py src/igraph/drawing/utils.py src/igraph/drawing/vertex.py src/igraph/remote/__init__.py src/igraph/remote/gephi.py tests/__init__.py tests/test_atlas.py tests/test_attributes.py tests/test_basic.py tests/test_bipartite.py tests/test_cliques.py tests/test_colortests.py tests/test_conversion.py tests/test_decomposition.py tests/test_edgeseq.py tests/test_flow.py tests/test_foreign.py tests/test_games.py tests/test_generators.py tests/test_homepage.py tests/test_indexing.py tests/test_isomorphism.py tests/test_iterators.py tests/test_layouts.py tests/test_matching.py tests/test_operators.py tests/test_rng.py tests/test_separators.py tests/test_spectral.py tests/test_structural.py tests/test_unicode_issues.py tests/test_vertexseq.py tests/test_walks.py tests/utils.py vendor/source/igraph/.astylerc vendor/source/igraph/.editorconfig vendor/source/igraph/.git vendor/source/igraph/.gitignore vendor/source/igraph/.pre-commit-config.yaml vendor/source/igraph/.travis.yml vendor/source/igraph/.zenodo.json vendor/source/igraph/ACKNOWLEDGEMENTS.md vendor/source/igraph/AUTHORS vendor/source/igraph/CHANGELOG.md vendor/source/igraph/CMakeLists.txt vendor/source/igraph/CODE_OF_CONDUCT.md vendor/source/igraph/CONTRIBUTING.md vendor/source/igraph/COPYING vendor/source/igraph/ChangeLog vendor/source/igraph/IGRAPH_VERSION vendor/source/igraph/INSTALL vendor/source/igraph/NEWS vendor/source/igraph/ONEWS vendor/source/igraph/README.md vendor/source/igraph/SUPPORT.md vendor/source/igraph/appveyor.yml vendor/source/igraph/azure-pipelines.yml vendor/source/igraph/codecov.yml vendor/source/igraph/igraph.pc.in vendor/source/igraph/.azure/build-win.yml vendor/source/igraph/.azure/build.yml vendor/source/igraph/.github/stale.yml vendor/source/igraph/.github/ISSUE_TEMPLATE/bug_report.md vendor/source/igraph/.github/ISSUE_TEMPLATE/config.yml vendor/source/igraph/.github/ISSUE_TEMPLATE/feature_request.md vendor/source/igraph/.github/codeql/codeql-config.yml vendor/source/igraph/.github/workflows/build-cmake.yml vendor/source/igraph/.github/workflows/codecov.yml vendor/source/igraph/.github/workflows/codeql-analysis.yml vendor/source/igraph/.github/workflows/stimulus.yml vendor/source/igraph/doc/CMakeLists.txt vendor/source/igraph/doc/adjlist.xxml vendor/source/igraph/doc/arpack.xxml vendor/source/igraph/doc/attributes.xxml vendor/source/igraph/doc/basicigraph.xxml vendor/source/igraph/doc/bibdatabase.xml vendor/source/igraph/doc/bipartite.xxml vendor/source/igraph/doc/c-docbook.re vendor/source/igraph/doc/cliques.xxml vendor/source/igraph/doc/coloring.xxml vendor/source/igraph/doc/community.xxml vendor/source/igraph/doc/cycles.xxml vendor/source/igraph/doc/docbook.outlang vendor/source/igraph/doc/doxrox.py vendor/source/igraph/doc/dqueue.xxml vendor/source/igraph/doc/embedding.xxml vendor/source/igraph/doc/error.xxml vendor/source/igraph/doc/fdl.xml vendor/source/igraph/doc/flows.xxml vendor/source/igraph/doc/foreign.xxml vendor/source/igraph/doc/generators.xxml vendor/source/igraph/doc/gpl.xml vendor/source/igraph/doc/graphlets.xxml vendor/source/igraph/doc/gtk-doc.xsl vendor/source/igraph/doc/heap.xxml vendor/source/igraph/doc/hrg.xxml vendor/source/igraph/doc/igraph-docs.xml vendor/source/igraph/doc/igraph.3 vendor/source/igraph/doc/installation.xml vendor/source/igraph/doc/introduction.xml vendor/source/igraph/doc/isomorphism.xxml vendor/source/igraph/doc/iterators.xxml vendor/source/igraph/doc/layout.xxml vendor/source/igraph/doc/licenses.xml vendor/source/igraph/doc/matrix.xxml vendor/source/igraph/doc/memory.xxml vendor/source/igraph/doc/motifs.xxml vendor/source/igraph/doc/nongraph.xxml vendor/source/igraph/doc/operators.xxml vendor/source/igraph/doc/pmt.xml vendor/source/igraph/doc/progress.xxml vendor/source/igraph/doc/psumtree.xxml vendor/source/igraph/doc/random.xxml vendor/source/igraph/doc/scg.xxml vendor/source/igraph/doc/separators.xxml vendor/source/igraph/doc/sparsemat.xxml vendor/source/igraph/doc/sparsematrix.xxml vendor/source/igraph/doc/spatialgames.xxml vendor/source/igraph/doc/stack.xxml vendor/source/igraph/doc/status.xxml vendor/source/igraph/doc/structural.xxml vendor/source/igraph/doc/strvector.xxml vendor/source/igraph/doc/threading.xxml vendor/source/igraph/doc/tutorial.xml vendor/source/igraph/doc/vector.xxml vendor/source/igraph/doc/version-greater-or-equal.xsl vendor/source/igraph/doc/visitors.xxml vendor/source/igraph/doc/html/home.png vendor/source/igraph/doc/html/left.png vendor/source/igraph/doc/html/right.png vendor/source/igraph/doc/html/style.css vendor/source/igraph/doc/html/toggle.js vendor/source/igraph/doc/html/up.png vendor/source/igraph/doc/igraphlogo/igraph-white.svg.gz vendor/source/igraph/doc/igraphlogo/igraph.svg.gz vendor/source/igraph/doc/igraphlogo/igraph2.svg.gz vendor/source/igraph/doc/licenses/Licence_CeCILL-B_V1-en.txt vendor/source/igraph/doc/licenses/Licence_CeCILL-B_V1-fr.txt vendor/source/igraph/doc/licenses/gpl-2.0.txt vendor/source/igraph/doc/licenses/gpl-3.0.txt vendor/source/igraph/doc/licenses/lgpl-2.1.txt vendor/source/igraph/doc/licenses/lgpl-3.0.txt vendor/source/igraph/etc/cmake/BuildType.cmake vendor/source/igraph/etc/cmake/CTestCustom.cmake.in vendor/source/igraph/etc/cmake/CheckTLSSupport.cmake vendor/source/igraph/etc/cmake/CodeCoverage.cmake vendor/source/igraph/etc/cmake/FindARPACK.cmake vendor/source/igraph/etc/cmake/FindCXSparse.cmake vendor/source/igraph/etc/cmake/FindGLPK.cmake vendor/source/igraph/etc/cmake/FindGMP.cmake vendor/source/igraph/etc/cmake/FindPLFIT.cmake vendor/source/igraph/etc/cmake/GetGitRevisionDescription.cmake vendor/source/igraph/etc/cmake/GetGitRevisionDescription.cmake.in vendor/source/igraph/etc/cmake/JoinPaths.cmake vendor/source/igraph/etc/cmake/PadString.cmake vendor/source/igraph/etc/cmake/PreventInSourceBuilds.cmake vendor/source/igraph/etc/cmake/UseCCacheWhenInstalled.cmake vendor/source/igraph/etc/cmake/benchmark_helpers.cmake vendor/source/igraph/etc/cmake/compilers.cmake vendor/source/igraph/etc/cmake/cpack_install_script.cmake vendor/source/igraph/etc/cmake/create_igraph_version_file.cmake vendor/source/igraph/etc/cmake/debugging.cmake vendor/source/igraph/etc/cmake/dependencies.cmake vendor/source/igraph/etc/cmake/features.cmake vendor/source/igraph/etc/cmake/generate_tags_file.cmake vendor/source/igraph/etc/cmake/helpers.cmake vendor/source/igraph/etc/cmake/igraph-config.cmake.in vendor/source/igraph/etc/cmake/lto.cmake vendor/source/igraph/etc/cmake/packaging.cmake vendor/source/igraph/etc/cmake/pkgconfig_helpers.cmake vendor/source/igraph/etc/cmake/run_legacy_test.cmake vendor/source/igraph/etc/cmake/sanitizers.cmake vendor/source/igraph/etc/cmake/summary.cmake vendor/source/igraph/etc/cmake/test_helpers.cmake vendor/source/igraph/etc/cmake/tls.cmake vendor/source/igraph/etc/cmake/version.cmake vendor/source/igraph/examples/simple/adjlist.c vendor/source/igraph/examples/simple/ak-4102.max vendor/source/igraph/examples/simple/assortativity.c vendor/source/igraph/examples/simple/assortativity.out vendor/source/igraph/examples/simple/bellman_ford.c vendor/source/igraph/examples/simple/bellman_ford.out vendor/source/igraph/examples/simple/blas.c vendor/source/igraph/examples/simple/blas.out vendor/source/igraph/examples/simple/cattributes.c vendor/source/igraph/examples/simple/cattributes.out vendor/source/igraph/examples/simple/cattributes2.c vendor/source/igraph/examples/simple/cattributes2.out vendor/source/igraph/examples/simple/cattributes3.c vendor/source/igraph/examples/simple/cattributes3.out vendor/source/igraph/examples/simple/cattributes4.c vendor/source/igraph/examples/simple/cattributes4.out vendor/source/igraph/examples/simple/celegansneural.gml vendor/source/igraph/examples/simple/centralization.c vendor/source/igraph/examples/simple/cohesive_blocks.c vendor/source/igraph/examples/simple/cohesive_blocks.out vendor/source/igraph/examples/simple/dijkstra.c vendor/source/igraph/examples/simple/dijkstra.out vendor/source/igraph/examples/simple/dominator_tree.c vendor/source/igraph/examples/simple/dominator_tree.out vendor/source/igraph/examples/simple/dot.c vendor/source/igraph/examples/simple/dot.out vendor/source/igraph/examples/simple/dqueue.c vendor/source/igraph/examples/simple/dqueue.out vendor/source/igraph/examples/simple/edgelist1.dl vendor/source/igraph/examples/simple/edgelist2.dl vendor/source/igraph/examples/simple/edgelist3.dl vendor/source/igraph/examples/simple/edgelist4.dl vendor/source/igraph/examples/simple/edgelist5.dl vendor/source/igraph/examples/simple/edgelist6.dl vendor/source/igraph/examples/simple/edgelist7.dl vendor/source/igraph/examples/simple/eigenvector_centrality.c vendor/source/igraph/examples/simple/eigenvector_centrality.out vendor/source/igraph/examples/simple/even_tarjan.c vendor/source/igraph/examples/simple/flow.c vendor/source/igraph/examples/simple/flow2.c vendor/source/igraph/examples/simple/flow2.out vendor/source/igraph/examples/simple/foreign.c vendor/source/igraph/examples/simple/foreign.out vendor/source/igraph/examples/simple/fullmatrix1.dl vendor/source/igraph/examples/simple/fullmatrix2.dl vendor/source/igraph/examples/simple/fullmatrix3.dl vendor/source/igraph/examples/simple/fullmatrix4.dl vendor/source/igraph/examples/simple/gml.c vendor/source/igraph/examples/simple/gml.out vendor/source/igraph/examples/simple/graphml-default-attrs.xml vendor/source/igraph/examples/simple/graphml-hsa05010.xml vendor/source/igraph/examples/simple/graphml-lenient.xml vendor/source/igraph/examples/simple/graphml-malformed.xml vendor/source/igraph/examples/simple/graphml-namespace.xml vendor/source/igraph/examples/simple/graphml.c vendor/source/igraph/examples/simple/graphml.out vendor/source/igraph/examples/simple/igraph_add_edges.c vendor/source/igraph/examples/simple/igraph_add_edges.out vendor/source/igraph/examples/simple/igraph_add_vertices.c vendor/source/igraph/examples/simple/igraph_adjacency.c vendor/source/igraph/examples/simple/igraph_all_st_mincuts.c vendor/source/igraph/examples/simple/igraph_all_st_mincuts.out vendor/source/igraph/examples/simple/igraph_atlas.c vendor/source/igraph/examples/simple/igraph_atlas.out vendor/source/igraph/examples/simple/igraph_average_path_length.c vendor/source/igraph/examples/simple/igraph_barabasi_game.c vendor/source/igraph/examples/simple/igraph_barabasi_game2.c vendor/source/igraph/examples/simple/igraph_bfs.c vendor/source/igraph/examples/simple/igraph_bfs.out vendor/source/igraph/examples/simple/igraph_bfs_callback.c vendor/source/igraph/examples/simple/igraph_bfs_callback.out vendor/source/igraph/examples/simple/igraph_bfs_simple.c vendor/source/igraph/examples/simple/igraph_bfs_simple.out vendor/source/igraph/examples/simple/igraph_biconnected_components.c vendor/source/igraph/examples/simple/igraph_biconnected_components.out vendor/source/igraph/examples/simple/igraph_bipartite_create.c vendor/source/igraph/examples/simple/igraph_bipartite_create.out vendor/source/igraph/examples/simple/igraph_bipartite_projection.c vendor/source/igraph/examples/simple/igraph_cliques.c vendor/source/igraph/examples/simple/igraph_cliques.out vendor/source/igraph/examples/simple/igraph_cocitation.c vendor/source/igraph/examples/simple/igraph_cocitation.out vendor/source/igraph/examples/simple/igraph_coloring.c vendor/source/igraph/examples/simple/igraph_community_edge_betweenness.c vendor/source/igraph/examples/simple/igraph_community_edge_betweenness.out vendor/source/igraph/examples/simple/igraph_community_fastgreedy.c vendor/source/igraph/examples/simple/igraph_community_fastgreedy.out vendor/source/igraph/examples/simple/igraph_community_fluid_communities.c vendor/source/igraph/examples/simple/igraph_community_fluid_communities.out vendor/source/igraph/examples/simple/igraph_community_label_propagation.c vendor/source/igraph/examples/simple/igraph_community_label_propagation.out vendor/source/igraph/examples/simple/igraph_community_leading_eigenvector.c vendor/source/igraph/examples/simple/igraph_community_leading_eigenvector.out vendor/source/igraph/examples/simple/igraph_community_leiden.c vendor/source/igraph/examples/simple/igraph_community_leiden.out vendor/source/igraph/examples/simple/igraph_community_multilevel.c vendor/source/igraph/examples/simple/igraph_community_multilevel.out vendor/source/igraph/examples/simple/igraph_community_optimal_modularity.c vendor/source/igraph/examples/simple/igraph_complementer.c vendor/source/igraph/examples/simple/igraph_complementer.out vendor/source/igraph/examples/simple/igraph_compose.c vendor/source/igraph/examples/simple/igraph_compose.out vendor/source/igraph/examples/simple/igraph_convex_hull.c vendor/source/igraph/examples/simple/igraph_convex_hull.out vendor/source/igraph/examples/simple/igraph_copy.c vendor/source/igraph/examples/simple/igraph_create.c vendor/source/igraph/examples/simple/igraph_decompose.c vendor/source/igraph/examples/simple/igraph_decompose.out vendor/source/igraph/examples/simple/igraph_degree.c vendor/source/igraph/examples/simple/igraph_degree.out vendor/source/igraph/examples/simple/igraph_degree_sequence_game.c vendor/source/igraph/examples/simple/igraph_degree_sequence_game.out vendor/source/igraph/examples/simple/igraph_delete_edges.c vendor/source/igraph/examples/simple/igraph_delete_vertices.c vendor/source/igraph/examples/simple/igraph_deterministic_optimal_imitation.c vendor/source/igraph/examples/simple/igraph_diameter.c vendor/source/igraph/examples/simple/igraph_diameter.out vendor/source/igraph/examples/simple/igraph_difference.c vendor/source/igraph/examples/simple/igraph_difference.out vendor/source/igraph/examples/simple/igraph_disjoint_union.c vendor/source/igraph/examples/simple/igraph_disjoint_union.out vendor/source/igraph/examples/simple/igraph_eccentricity.c vendor/source/igraph/examples/simple/igraph_eccentricity.out vendor/source/igraph/examples/simple/igraph_empty.c vendor/source/igraph/examples/simple/igraph_erdos_renyi_game.c vendor/source/igraph/examples/simple/igraph_es_pairs.c vendor/source/igraph/examples/simple/igraph_feedback_arc_set.c vendor/source/igraph/examples/simple/igraph_feedback_arc_set.out vendor/source/igraph/examples/simple/igraph_feedback_arc_set_ip.c vendor/source/igraph/examples/simple/igraph_feedback_arc_set_ip.out vendor/source/igraph/examples/simple/igraph_fisher_yates_shuffle.c vendor/source/igraph/examples/simple/igraph_free.c vendor/source/igraph/examples/simple/igraph_full.c vendor/source/igraph/examples/simple/igraph_full.out vendor/source/igraph/examples/simple/igraph_get_all_shortest_paths_dijkstra.c vendor/source/igraph/examples/simple/igraph_get_all_shortest_paths_dijkstra.out vendor/source/igraph/examples/simple/igraph_get_eid.c vendor/source/igraph/examples/simple/igraph_get_eid.out vendor/source/igraph/examples/simple/igraph_get_eids.c vendor/source/igraph/examples/simple/igraph_get_eids.out vendor/source/igraph/examples/simple/igraph_get_shortest_paths.c vendor/source/igraph/examples/simple/igraph_get_shortest_paths.out vendor/source/igraph/examples/simple/igraph_get_shortest_paths_dijkstra.c vendor/source/igraph/examples/simple/igraph_get_shortest_paths_dijkstra.out vendor/source/igraph/examples/simple/igraph_girth.c vendor/source/igraph/examples/simple/igraph_grg_game.c vendor/source/igraph/examples/simple/igraph_grg_game.out vendor/source/igraph/examples/simple/igraph_has_multiple.c vendor/source/igraph/examples/simple/igraph_independent_sets.c vendor/source/igraph/examples/simple/igraph_independent_sets.out vendor/source/igraph/examples/simple/igraph_intersection.c vendor/source/igraph/examples/simple/igraph_intersection.out vendor/source/igraph/examples/simple/igraph_is_directed.c vendor/source/igraph/examples/simple/igraph_is_loop.c vendor/source/igraph/examples/simple/igraph_is_loop.out vendor/source/igraph/examples/simple/igraph_is_minimal_separator.c vendor/source/igraph/examples/simple/igraph_is_multiple.c vendor/source/igraph/examples/simple/igraph_is_multiple.out vendor/source/igraph/examples/simple/igraph_is_separator.c vendor/source/igraph/examples/simple/igraph_isomorphic_vf2.c vendor/source/igraph/examples/simple/igraph_knn.c vendor/source/igraph/examples/simple/igraph_lapack_dgeev.c vendor/source/igraph/examples/simple/igraph_lapack_dgeevx.c vendor/source/igraph/examples/simple/igraph_lapack_dgesv.c vendor/source/igraph/examples/simple/igraph_lapack_dgesv.out vendor/source/igraph/examples/simple/igraph_lapack_dsyevr.c vendor/source/igraph/examples/simple/igraph_laplacian.c vendor/source/igraph/examples/simple/igraph_laplacian.out vendor/source/igraph/examples/simple/igraph_layout_reingold_tilford.c vendor/source/igraph/examples/simple/igraph_layout_reingold_tilford.in vendor/source/igraph/examples/simple/igraph_lcf.c vendor/source/igraph/examples/simple/igraph_maximal_cliques.c vendor/source/igraph/examples/simple/igraph_maximal_cliques.out vendor/source/igraph/examples/simple/igraph_maximum_bipartite_matching.c vendor/source/igraph/examples/simple/igraph_mincut.c vendor/source/igraph/examples/simple/igraph_mincut.out vendor/source/igraph/examples/simple/igraph_minimal_separators.c vendor/source/igraph/examples/simple/igraph_minimum_size_separators.c vendor/source/igraph/examples/simple/igraph_minimum_size_separators.out vendor/source/igraph/examples/simple/igraph_minimum_spanning_tree.c vendor/source/igraph/examples/simple/igraph_minimum_spanning_tree.out vendor/source/igraph/examples/simple/igraph_motifs_randesu.c vendor/source/igraph/examples/simple/igraph_motifs_randesu.out vendor/source/igraph/examples/simple/igraph_neighbors.c vendor/source/igraph/examples/simple/igraph_neighbors.out vendor/source/igraph/examples/simple/igraph_pagerank.c vendor/source/igraph/examples/simple/igraph_power_law_fit.c vendor/source/igraph/examples/simple/igraph_power_law_fit.out vendor/source/igraph/examples/simple/igraph_radius.c vendor/source/igraph/examples/simple/igraph_random_sample.c vendor/source/igraph/examples/simple/igraph_read_graph_dl.c vendor/source/igraph/examples/simple/igraph_read_graph_dl.out vendor/source/igraph/examples/simple/igraph_read_graph_graphdb.c vendor/source/igraph/examples/simple/igraph_read_graph_graphdb.out vendor/source/igraph/examples/simple/igraph_read_graph_lgl-1.lgl vendor/source/igraph/examples/simple/igraph_read_graph_lgl-2.lgl vendor/source/igraph/examples/simple/igraph_read_graph_lgl-3.lgl vendor/source/igraph/examples/simple/igraph_read_graph_lgl.c vendor/source/igraph/examples/simple/igraph_read_graph_lgl.out vendor/source/igraph/examples/simple/igraph_reciprocity.c vendor/source/igraph/examples/simple/igraph_ring.c vendor/source/igraph/examples/simple/igraph_ring.out vendor/source/igraph/examples/simple/igraph_roulette_wheel_imitation.c vendor/source/igraph/examples/simple/igraph_scg_grouping.c vendor/source/igraph/examples/simple/igraph_scg_grouping.out vendor/source/igraph/examples/simple/igraph_scg_grouping2.c vendor/source/igraph/examples/simple/igraph_scg_grouping2.out vendor/source/igraph/examples/simple/igraph_scg_grouping3.c vendor/source/igraph/examples/simple/igraph_scg_grouping3.out vendor/source/igraph/examples/simple/igraph_scg_grouping4.c vendor/source/igraph/examples/simple/igraph_scg_grouping4.out vendor/source/igraph/examples/simple/igraph_scg_semiprojectors.c vendor/source/igraph/examples/simple/igraph_scg_semiprojectors.out vendor/source/igraph/examples/simple/igraph_scg_semiprojectors2.c vendor/source/igraph/examples/simple/igraph_scg_semiprojectors2.out vendor/source/igraph/examples/simple/igraph_scg_semiprojectors3.c vendor/source/igraph/examples/simple/igraph_scg_semiprojectors3.out vendor/source/igraph/examples/simple/igraph_similarity.c vendor/source/igraph/examples/simple/igraph_similarity.out vendor/source/igraph/examples/simple/igraph_simplify.c vendor/source/igraph/examples/simple/igraph_simplify.out vendor/source/igraph/examples/simple/igraph_small.c vendor/source/igraph/examples/simple/igraph_small.out vendor/source/igraph/examples/simple/igraph_sparsemat.c vendor/source/igraph/examples/simple/igraph_sparsemat.out vendor/source/igraph/examples/simple/igraph_sparsemat3.c vendor/source/igraph/examples/simple/igraph_sparsemat3.out vendor/source/igraph/examples/simple/igraph_sparsemat4.c vendor/source/igraph/examples/simple/igraph_sparsemat4.out vendor/source/igraph/examples/simple/igraph_sparsemat6.c vendor/source/igraph/examples/simple/igraph_sparsemat7.c vendor/source/igraph/examples/simple/igraph_sparsemat8.c vendor/source/igraph/examples/simple/igraph_star.c vendor/source/igraph/examples/simple/igraph_star.out vendor/source/igraph/examples/simple/igraph_stochastic_imitation.c vendor/source/igraph/examples/simple/igraph_strvector.c vendor/source/igraph/examples/simple/igraph_strvector.out vendor/source/igraph/examples/simple/igraph_subisomorphic_lad.c vendor/source/igraph/examples/simple/igraph_subisomorphic_lad.out vendor/source/igraph/examples/simple/igraph_to_undirected.c vendor/source/igraph/examples/simple/igraph_to_undirected.out vendor/source/igraph/examples/simple/igraph_topological_sorting.c vendor/source/igraph/examples/simple/igraph_topological_sorting.out vendor/source/igraph/examples/simple/igraph_transitivity.c vendor/source/igraph/examples/simple/igraph_tree.c vendor/source/igraph/examples/simple/igraph_tree.out vendor/source/igraph/examples/simple/igraph_union.c vendor/source/igraph/examples/simple/igraph_union.out vendor/source/igraph/examples/simple/igraph_vector_ptr_sort.c vendor/source/igraph/examples/simple/igraph_version.c vendor/source/igraph/examples/simple/igraph_vs_nonadj.c vendor/source/igraph/examples/simple/igraph_vs_nonadj.out vendor/source/igraph/examples/simple/igraph_vs_seq.c vendor/source/igraph/examples/simple/igraph_vs_seq.out vendor/source/igraph/examples/simple/igraph_vs_vector.c vendor/source/igraph/examples/simple/igraph_vs_vector.out vendor/source/igraph/examples/simple/igraph_weighted_adjacency.c vendor/source/igraph/examples/simple/igraph_weighted_adjacency.out vendor/source/igraph/examples/simple/igraph_write_graph_lgl.c vendor/source/igraph/examples/simple/igraph_write_graph_lgl.out vendor/source/igraph/examples/simple/igraph_write_graph_pajek.c vendor/source/igraph/examples/simple/igraph_write_graph_pajek.out vendor/source/igraph/examples/simple/iso_b03_m1000.A00 vendor/source/igraph/examples/simple/karate.gml vendor/source/igraph/examples/simple/links.net vendor/source/igraph/examples/simple/nodelist1.dl vendor/source/igraph/examples/simple/nodelist2.dl vendor/source/igraph/examples/simple/random_seed.c vendor/source/igraph/examples/simple/scg.c vendor/source/igraph/examples/simple/scg.out vendor/source/igraph/examples/simple/test.gxl vendor/source/igraph/examples/simple/walktrap.c vendor/source/igraph/examples/simple/walktrap.out vendor/source/igraph/examples/tutorial/tutorial1.c vendor/source/igraph/examples/tutorial/tutorial2.c vendor/source/igraph/examples/tutorial/tutorial3.c vendor/source/igraph/fuzzing/README.md vendor/source/igraph/fuzzing/bliss_fuzzer.cpp vendor/source/igraph/fuzzing/build.sh vendor/source/igraph/fuzzing/edge_connectivity_fuzzer.cpp vendor/source/igraph/fuzzing/read_gml_fuzzer.cpp vendor/source/igraph/fuzzing/vertex_connectivity_fuzzer.cpp vendor/source/igraph/fuzzing/vertex_separators_fuzzer.cpp vendor/source/igraph/include/igraph.h vendor/source/igraph/include/igraph_adjlist.h vendor/source/igraph/include/igraph_arpack.h vendor/source/igraph/include/igraph_array.h vendor/source/igraph/include/igraph_array_pmt.h vendor/source/igraph/include/igraph_attributes.h vendor/source/igraph/include/igraph_bipartite.h vendor/source/igraph/include/igraph_blas.h vendor/source/igraph/include/igraph_centrality.h vendor/source/igraph/include/igraph_cliques.h vendor/source/igraph/include/igraph_cocitation.h vendor/source/igraph/include/igraph_cohesive_blocks.h vendor/source/igraph/include/igraph_coloring.h vendor/source/igraph/include/igraph_community.h vendor/source/igraph/include/igraph_complex.h vendor/source/igraph/include/igraph_components.h vendor/source/igraph/include/igraph_constants.h vendor/source/igraph/include/igraph_constructors.h vendor/source/igraph/include/igraph_conversion.h vendor/source/igraph/include/igraph_datatype.h vendor/source/igraph/include/igraph_decls.h vendor/source/igraph/include/igraph_dqueue.h vendor/source/igraph/include/igraph_dqueue_pmt.h vendor/source/igraph/include/igraph_eigen.h vendor/source/igraph/include/igraph_embedding.h vendor/source/igraph/include/igraph_epidemics.h vendor/source/igraph/include/igraph_error.h vendor/source/igraph/include/igraph_eulerian.h vendor/source/igraph/include/igraph_flow.h vendor/source/igraph/include/igraph_foreign.h vendor/source/igraph/include/igraph_games.h vendor/source/igraph/include/igraph_graphicality.h vendor/source/igraph/include/igraph_graphlets.h vendor/source/igraph/include/igraph_heap.h vendor/source/igraph/include/igraph_heap_pmt.h vendor/source/igraph/include/igraph_hrg.h vendor/source/igraph/include/igraph_interface.h vendor/source/igraph/include/igraph_interrupt.h vendor/source/igraph/include/igraph_iterators.h vendor/source/igraph/include/igraph_lapack.h vendor/source/igraph/include/igraph_layout.h vendor/source/igraph/include/igraph_lsap.h vendor/source/igraph/include/igraph_matching.h vendor/source/igraph/include/igraph_matrix.h vendor/source/igraph/include/igraph_matrix_pmt.h vendor/source/igraph/include/igraph_memory.h vendor/source/igraph/include/igraph_microscopic_update.h vendor/source/igraph/include/igraph_mixing.h vendor/source/igraph/include/igraph_motifs.h vendor/source/igraph/include/igraph_neighborhood.h vendor/source/igraph/include/igraph_nongraph.h vendor/source/igraph/include/igraph_operators.h vendor/source/igraph/include/igraph_paths.h vendor/source/igraph/include/igraph_pmt.h vendor/source/igraph/include/igraph_pmt_off.h vendor/source/igraph/include/igraph_progress.h vendor/source/igraph/include/igraph_psumtree.h vendor/source/igraph/include/igraph_qsort.h vendor/source/igraph/include/igraph_random.h vendor/source/igraph/include/igraph_scan.h vendor/source/igraph/include/igraph_scg.h vendor/source/igraph/include/igraph_separators.h vendor/source/igraph/include/igraph_sparsemat.h vendor/source/igraph/include/igraph_spmatrix.h vendor/source/igraph/include/igraph_stack.h vendor/source/igraph/include/igraph_stack_pmt.h vendor/source/igraph/include/igraph_statusbar.h vendor/source/igraph/include/igraph_structural.h vendor/source/igraph/include/igraph_strvector.h vendor/source/igraph/include/igraph_threading.h.in vendor/source/igraph/include/igraph_topology.h vendor/source/igraph/include/igraph_transitivity.h vendor/source/igraph/include/igraph_types.h vendor/source/igraph/include/igraph_vector.h vendor/source/igraph/include/igraph_vector_pmt.h vendor/source/igraph/include/igraph_vector_ptr.h vendor/source/igraph/include/igraph_vector_type.h vendor/source/igraph/include/igraph_version.h.in vendor/source/igraph/include/igraph_visitor.h vendor/source/igraph/interfaces/CMakeLists.txt vendor/source/igraph/interfaces/functions.yaml vendor/source/igraph/interfaces/types.yaml vendor/source/igraph/msvc/include/unistd.h vendor/source/igraph/src/CMakeLists.txt vendor/source/igraph/src/config.h.in vendor/source/igraph/src/f2c.h vendor/source/igraph/src/version.c vendor/source/igraph/src/centrality/betweenness.c vendor/source/igraph/src/centrality/centrality_other.c vendor/source/igraph/src/centrality/centralization.c vendor/source/igraph/src/centrality/closeness.c vendor/source/igraph/src/centrality/coreness.c vendor/source/igraph/src/centrality/prpack.cpp vendor/source/igraph/src/centrality/prpack_internal.h vendor/source/igraph/src/centrality/prpack/CMakeLists.txt vendor/source/igraph/src/centrality/prpack/prpack.h vendor/source/igraph/src/centrality/prpack/prpack_base_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_base_graph.h vendor/source/igraph/src/centrality/prpack/prpack_csc.h vendor/source/igraph/src/centrality/prpack/prpack_csr.h vendor/source/igraph/src/centrality/prpack/prpack_edge_list.h vendor/source/igraph/src/centrality/prpack/prpack_igraph_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_igraph_graph.h vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_ge_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_ge_graph.h vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_graph.h vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_gs_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_gs_graph.h vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_scc_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_scc_graph.h vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_schur_graph.cpp vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_schur_graph.h vendor/source/igraph/src/centrality/prpack/prpack_result.cpp vendor/source/igraph/src/centrality/prpack/prpack_result.h vendor/source/igraph/src/centrality/prpack/prpack_solver.cpp vendor/source/igraph/src/centrality/prpack/prpack_solver.h vendor/source/igraph/src/centrality/prpack/prpack_utils.cpp vendor/source/igraph/src/centrality/prpack/prpack_utils.h vendor/source/igraph/src/cliques/cliquer_internal.h vendor/source/igraph/src/cliques/cliquer_wrapper.c vendor/source/igraph/src/cliques/cliques.c vendor/source/igraph/src/cliques/glet.c vendor/source/igraph/src/cliques/maximal_cliques.c vendor/source/igraph/src/cliques/maximal_cliques_template.h vendor/source/igraph/src/cliques/cliquer/CMakeLists.txt vendor/source/igraph/src/cliques/cliquer/README vendor/source/igraph/src/cliques/cliquer/cliquer.c vendor/source/igraph/src/cliques/cliquer/cliquer.h vendor/source/igraph/src/cliques/cliquer/cliquer_graph.c vendor/source/igraph/src/cliques/cliquer/cliquerconf.h vendor/source/igraph/src/cliques/cliquer/graph.h vendor/source/igraph/src/cliques/cliquer/misc.h vendor/source/igraph/src/cliques/cliquer/reorder.c vendor/source/igraph/src/cliques/cliquer/reorder.h vendor/source/igraph/src/cliques/cliquer/set.h vendor/source/igraph/src/community/community_misc.c vendor/source/igraph/src/community/edge_betweenness.c vendor/source/igraph/src/community/fast_modularity.c vendor/source/igraph/src/community/fluid.c vendor/source/igraph/src/community/label_propagation.c vendor/source/igraph/src/community/leading_eigenvector.c vendor/source/igraph/src/community/leiden.c vendor/source/igraph/src/community/louvain.c vendor/source/igraph/src/community/modularity.c vendor/source/igraph/src/community/optimal_modularity.c vendor/source/igraph/src/community/infomap/infomap.cc vendor/source/igraph/src/community/infomap/infomap_FlowGraph.cc vendor/source/igraph/src/community/infomap/infomap_FlowGraph.h vendor/source/igraph/src/community/infomap/infomap_Greedy.cc vendor/source/igraph/src/community/infomap/infomap_Greedy.h vendor/source/igraph/src/community/infomap/infomap_Node.cc vendor/source/igraph/src/community/infomap/infomap_Node.h vendor/source/igraph/src/community/spinglass/NetDataTypes.cpp vendor/source/igraph/src/community/spinglass/NetDataTypes.h vendor/source/igraph/src/community/spinglass/NetRoutines.cpp vendor/source/igraph/src/community/spinglass/NetRoutines.h vendor/source/igraph/src/community/spinglass/clustertool.cpp vendor/source/igraph/src/community/spinglass/pottsmodel_2.cpp vendor/source/igraph/src/community/spinglass/pottsmodel_2.h vendor/source/igraph/src/community/walktrap/walktrap.cpp vendor/source/igraph/src/community/walktrap/walktrap_communities.cpp vendor/source/igraph/src/community/walktrap/walktrap_communities.h vendor/source/igraph/src/community/walktrap/walktrap_graph.cpp vendor/source/igraph/src/community/walktrap/walktrap_graph.h vendor/source/igraph/src/community/walktrap/walktrap_heap.cpp vendor/source/igraph/src/community/walktrap/walktrap_heap.h vendor/source/igraph/src/connectivity/cohesive_blocks.c vendor/source/igraph/src/connectivity/components.c vendor/source/igraph/src/connectivity/separators.c vendor/source/igraph/src/constructors/adjacency.c vendor/source/igraph/src/constructors/atlas-edges.h vendor/source/igraph/src/constructors/atlas.c vendor/source/igraph/src/constructors/basic_constructors.c vendor/source/igraph/src/constructors/de_bruijn.c vendor/source/igraph/src/constructors/famous.c vendor/source/igraph/src/constructors/full.c vendor/source/igraph/src/constructors/kautz.c vendor/source/igraph/src/constructors/lcf.c vendor/source/igraph/src/constructors/linegraph.c vendor/source/igraph/src/constructors/prufer.c vendor/source/igraph/src/constructors/regular.c vendor/source/igraph/src/core/array.c vendor/source/igraph/src/core/array.pmt vendor/source/igraph/src/core/buckets.c vendor/source/igraph/src/core/buckets.h vendor/source/igraph/src/core/cutheap.c vendor/source/igraph/src/core/cutheap.h vendor/source/igraph/src/core/dqueue.c vendor/source/igraph/src/core/dqueue.pmt vendor/source/igraph/src/core/error.c vendor/source/igraph/src/core/estack.c vendor/source/igraph/src/core/estack.h vendor/source/igraph/src/core/exceptions.h vendor/source/igraph/src/core/fixed_vectorlist.c vendor/source/igraph/src/core/fixed_vectorlist.h vendor/source/igraph/src/core/grid.c vendor/source/igraph/src/core/grid.h vendor/source/igraph/src/core/hashtable.c vendor/source/igraph/src/core/hashtable.h vendor/source/igraph/src/core/heap.c vendor/source/igraph/src/core/heap.pmt vendor/source/igraph/src/core/indheap.c vendor/source/igraph/src/core/indheap.h vendor/source/igraph/src/core/interruption.c vendor/source/igraph/src/core/interruption.h vendor/source/igraph/src/core/marked_queue.c vendor/source/igraph/src/core/marked_queue.h vendor/source/igraph/src/core/math.h vendor/source/igraph/src/core/matrix.c vendor/source/igraph/src/core/matrix.pmt vendor/source/igraph/src/core/memory.c vendor/source/igraph/src/core/printing.c vendor/source/igraph/src/core/progress.c vendor/source/igraph/src/core/psumtree.c vendor/source/igraph/src/core/set.c vendor/source/igraph/src/core/set.h vendor/source/igraph/src/core/sparsemat.c vendor/source/igraph/src/core/spmatrix.c vendor/source/igraph/src/core/stack.c vendor/source/igraph/src/core/stack.pmt vendor/source/igraph/src/core/statusbar.c vendor/source/igraph/src/core/strvector.c vendor/source/igraph/src/core/trie.c vendor/source/igraph/src/core/trie.h vendor/source/igraph/src/core/vector.c vendor/source/igraph/src/core/vector.pmt vendor/source/igraph/src/core/vector_ptr.c vendor/source/igraph/src/flow/flow.c vendor/source/igraph/src/flow/flow_internal.h vendor/source/igraph/src/flow/st-cuts.c vendor/source/igraph/src/games/barabasi.c vendor/source/igraph/src/games/callaway_traits.c vendor/source/igraph/src/games/citations.c vendor/source/igraph/src/games/correlated.c vendor/source/igraph/src/games/degree_sequence.c vendor/source/igraph/src/games/dotproduct.c vendor/source/igraph/src/games/erdos_renyi.c vendor/source/igraph/src/games/establishment.c vendor/source/igraph/src/games/forestfire.c vendor/source/igraph/src/games/grg.c vendor/source/igraph/src/games/growing_random.c vendor/source/igraph/src/games/islands.c vendor/source/igraph/src/games/k_regular.c vendor/source/igraph/src/games/preference.c vendor/source/igraph/src/games/recent_degree.c vendor/source/igraph/src/games/sbm.c vendor/source/igraph/src/games/static_fitness.c vendor/source/igraph/src/games/tree.c vendor/source/igraph/src/games/watts_strogatz.c vendor/source/igraph/src/games/degree_sequence_vl/gengraph_box_list.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_box_list.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_definitions.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_degree_sequence.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_degree_sequence.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_hash.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_hash.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_optimized.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_optimized.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_hash.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_header.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_mr-connected.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_powerlaw.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_powerlaw.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_qsort.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_random.cpp vendor/source/igraph/src/games/degree_sequence_vl/gengraph_random.h vendor/source/igraph/src/games/degree_sequence_vl/gengraph_vertex_cover.h vendor/source/igraph/src/graph/adjlist.c vendor/source/igraph/src/graph/attributes.c vendor/source/igraph/src/graph/attributes.h vendor/source/igraph/src/graph/basic_query.c vendor/source/igraph/src/graph/cattributes.c vendor/source/igraph/src/graph/iterators.c vendor/source/igraph/src/graph/neighbors.h vendor/source/igraph/src/graph/type_indexededgelist.c vendor/source/igraph/src/graph/visitors.c vendor/source/igraph/src/hrg/dendro.h vendor/source/igraph/src/hrg/graph.h vendor/source/igraph/src/hrg/graph_simp.h vendor/source/igraph/src/hrg/hrg.cc vendor/source/igraph/src/hrg/hrg_types.cc vendor/source/igraph/src/hrg/rbtree.h vendor/source/igraph/src/hrg/splittree_eq.h vendor/source/igraph/src/internal/glpk_support.c vendor/source/igraph/src/internal/glpk_support.h vendor/source/igraph/src/internal/gmp_internal.h vendor/source/igraph/src/internal/hacks.c vendor/source/igraph/src/internal/hacks.h vendor/source/igraph/src/internal/lsap.c vendor/source/igraph/src/internal/pstdint.h vendor/source/igraph/src/internal/qsort.c vendor/source/igraph/src/internal/qsort_r.c vendor/source/igraph/src/internal/zeroin.c vendor/source/igraph/src/io/dimacs.c vendor/source/igraph/src/io/dl-header.h vendor/source/igraph/src/io/dl-lexer.l vendor/source/igraph/src/io/dl-parser.y vendor/source/igraph/src/io/dl.c vendor/source/igraph/src/io/dot.c vendor/source/igraph/src/io/edgelist.c vendor/source/igraph/src/io/gml-header.h vendor/source/igraph/src/io/gml-lexer.l vendor/source/igraph/src/io/gml-parser.y vendor/source/igraph/src/io/gml-tree.c vendor/source/igraph/src/io/gml-tree.h vendor/source/igraph/src/io/gml.c vendor/source/igraph/src/io/graphdb.c vendor/source/igraph/src/io/graphml.c vendor/source/igraph/src/io/leda.c vendor/source/igraph/src/io/lgl-header.h vendor/source/igraph/src/io/lgl-lexer.l vendor/source/igraph/src/io/lgl-parser.y vendor/source/igraph/src/io/lgl.c vendor/source/igraph/src/io/ncol-header.h vendor/source/igraph/src/io/ncol-lexer.l vendor/source/igraph/src/io/ncol-parser.y vendor/source/igraph/src/io/ncol.c vendor/source/igraph/src/io/pajek-header.h vendor/source/igraph/src/io/pajek-lexer.l vendor/source/igraph/src/io/pajek-parser.y vendor/source/igraph/src/io/pajek.c vendor/source/igraph/src/io/parsers/dl-lexer.c vendor/source/igraph/src/io/parsers/dl-lexer.h vendor/source/igraph/src/io/parsers/dl-parser.c vendor/source/igraph/src/io/parsers/dl-parser.h vendor/source/igraph/src/io/parsers/gml-lexer.c vendor/source/igraph/src/io/parsers/gml-lexer.h vendor/source/igraph/src/io/parsers/gml-parser.c vendor/source/igraph/src/io/parsers/gml-parser.h vendor/source/igraph/src/io/parsers/lgl-lexer.c vendor/source/igraph/src/io/parsers/lgl-lexer.h vendor/source/igraph/src/io/parsers/lgl-parser.c vendor/source/igraph/src/io/parsers/lgl-parser.h vendor/source/igraph/src/io/parsers/ncol-lexer.c vendor/source/igraph/src/io/parsers/ncol-lexer.h vendor/source/igraph/src/io/parsers/ncol-parser.c vendor/source/igraph/src/io/parsers/ncol-parser.h vendor/source/igraph/src/io/parsers/pajek-lexer.c vendor/source/igraph/src/io/parsers/pajek-lexer.h vendor/source/igraph/src/io/parsers/pajek-parser.c vendor/source/igraph/src/io/parsers/pajek-parser.h vendor/source/igraph/src/isomorphism/bliss.cc vendor/source/igraph/src/isomorphism/isoclasses.c vendor/source/igraph/src/isomorphism/isoclasses.h vendor/source/igraph/src/isomorphism/isomorphism_misc.c vendor/source/igraph/src/isomorphism/lad.c vendor/source/igraph/src/isomorphism/queries.c vendor/source/igraph/src/isomorphism/vf2.c vendor/source/igraph/src/isomorphism/bliss/CMakeLists.txt vendor/source/igraph/src/isomorphism/bliss/bignum.hh vendor/source/igraph/src/isomorphism/bliss/defs.cc vendor/source/igraph/src/isomorphism/bliss/defs.hh vendor/source/igraph/src/isomorphism/bliss/graph.cc vendor/source/igraph/src/isomorphism/bliss/graph.hh vendor/source/igraph/src/isomorphism/bliss/heap.cc vendor/source/igraph/src/isomorphism/bliss/heap.hh vendor/source/igraph/src/isomorphism/bliss/igraph-changes.md vendor/source/igraph/src/isomorphism/bliss/kqueue.hh vendor/source/igraph/src/isomorphism/bliss/kstack.hh vendor/source/igraph/src/isomorphism/bliss/orbit.cc vendor/source/igraph/src/isomorphism/bliss/orbit.hh vendor/source/igraph/src/isomorphism/bliss/partition.cc vendor/source/igraph/src/isomorphism/bliss/partition.hh vendor/source/igraph/src/isomorphism/bliss/stats.hh vendor/source/igraph/src/isomorphism/bliss/uintseqhash.cc vendor/source/igraph/src/isomorphism/bliss/uintseqhash.hh vendor/source/igraph/src/isomorphism/bliss/utils.cc vendor/source/igraph/src/isomorphism/bliss/utils.hh vendor/source/igraph/src/layout/circular.c vendor/source/igraph/src/layout/davidson_harel.c vendor/source/igraph/src/layout/fruchterman_reingold.c vendor/source/igraph/src/layout/gem.c vendor/source/igraph/src/layout/graphopt.c vendor/source/igraph/src/layout/kamada_kawai.c vendor/source/igraph/src/layout/large_graph.c vendor/source/igraph/src/layout/layout_bipartite.c vendor/source/igraph/src/layout/layout_grid.c vendor/source/igraph/src/layout/layout_internal.h vendor/source/igraph/src/layout/layout_random.c vendor/source/igraph/src/layout/mds.c vendor/source/igraph/src/layout/merge_dla.c vendor/source/igraph/src/layout/merge_grid.c vendor/source/igraph/src/layout/merge_grid.h vendor/source/igraph/src/layout/reingold_tilford.c vendor/source/igraph/src/layout/sugiyama.c vendor/source/igraph/src/layout/drl/DensityGrid.cpp vendor/source/igraph/src/layout/drl/DensityGrid.h vendor/source/igraph/src/layout/drl/DensityGrid_3d.cpp vendor/source/igraph/src/layout/drl/DensityGrid_3d.h vendor/source/igraph/src/layout/drl/drl_Node.h vendor/source/igraph/src/layout/drl/drl_Node_3d.h vendor/source/igraph/src/layout/drl/drl_graph.cpp vendor/source/igraph/src/layout/drl/drl_graph.h vendor/source/igraph/src/layout/drl/drl_graph_3d.cpp vendor/source/igraph/src/layout/drl/drl_graph_3d.h vendor/source/igraph/src/layout/drl/drl_layout.cpp vendor/source/igraph/src/layout/drl/drl_layout.h vendor/source/igraph/src/layout/drl/drl_layout_3d.cpp vendor/source/igraph/src/layout/drl/drl_layout_3d.h vendor/source/igraph/src/layout/drl/drl_parse.cpp vendor/source/igraph/src/layout/drl/drl_parse.h vendor/source/igraph/src/linalg/arpack.c vendor/source/igraph/src/linalg/arpack_internal.h vendor/source/igraph/src/linalg/blas.c vendor/source/igraph/src/linalg/blas_internal.h vendor/source/igraph/src/linalg/eigen.c vendor/source/igraph/src/linalg/lapack.c vendor/source/igraph/src/linalg/lapack_internal.h vendor/source/igraph/src/math/bfgs.c vendor/source/igraph/src/math/complex.c vendor/source/igraph/src/math/utils.c vendor/source/igraph/src/misc/bipartite.c vendor/source/igraph/src/misc/chordality.c vendor/source/igraph/src/misc/cocitation.c vendor/source/igraph/src/misc/coloring.c vendor/source/igraph/src/misc/conversion.c vendor/source/igraph/src/misc/conversion_internal.h vendor/source/igraph/src/misc/degree_sequence.cpp vendor/source/igraph/src/misc/embedding.c vendor/source/igraph/src/misc/feedback_arc_set.c vendor/source/igraph/src/misc/feedback_arc_set.h vendor/source/igraph/src/misc/graphicality.c vendor/source/igraph/src/misc/matching.c vendor/source/igraph/src/misc/microscopic_update.c vendor/source/igraph/src/misc/mixing.c vendor/source/igraph/src/misc/motifs.c vendor/source/igraph/src/misc/other.c vendor/source/igraph/src/misc/scan.c vendor/source/igraph/src/misc/sir.c vendor/source/igraph/src/misc/spanning_trees.c vendor/source/igraph/src/operators/add_edge.c vendor/source/igraph/src/operators/complementer.c vendor/source/igraph/src/operators/compose.c vendor/source/igraph/src/operators/connect_neighborhood.c vendor/source/igraph/src/operators/contract.c vendor/source/igraph/src/operators/difference.c vendor/source/igraph/src/operators/disjoint_union.c vendor/source/igraph/src/operators/intersection.c vendor/source/igraph/src/operators/misc_internal.c vendor/source/igraph/src/operators/misc_internal.h vendor/source/igraph/src/operators/permute.c vendor/source/igraph/src/operators/rewire.c vendor/source/igraph/src/operators/rewire_edges.c vendor/source/igraph/src/operators/rewire_internal.h vendor/source/igraph/src/operators/simplify.c vendor/source/igraph/src/operators/subgraph.c vendor/source/igraph/src/operators/subgraph.h vendor/source/igraph/src/operators/union.c vendor/source/igraph/src/paths/all_shortest_paths.c vendor/source/igraph/src/paths/bellman_ford.c vendor/source/igraph/src/paths/dijkstra.c vendor/source/igraph/src/paths/distances.c vendor/source/igraph/src/paths/eulerian.c vendor/source/igraph/src/paths/histogram.c vendor/source/igraph/src/paths/johnson.c vendor/source/igraph/src/paths/random_walk.c vendor/source/igraph/src/paths/shortest_paths.c vendor/source/igraph/src/paths/simple_paths.c vendor/source/igraph/src/paths/unweighted.c vendor/source/igraph/src/properties/basic_properties.c vendor/source/igraph/src/properties/constraint.c vendor/source/igraph/src/properties/convergence_degree.c vendor/source/igraph/src/properties/dag.c vendor/source/igraph/src/properties/degrees.c vendor/source/igraph/src/properties/girth.c vendor/source/igraph/src/properties/loops.c vendor/source/igraph/src/properties/multiplicity.c vendor/source/igraph/src/properties/neighborhood.c vendor/source/igraph/src/properties/properties_internal.h vendor/source/igraph/src/properties/spectral.c vendor/source/igraph/src/properties/trees.c vendor/source/igraph/src/properties/triangles.c vendor/source/igraph/src/properties/triangles_template.h vendor/source/igraph/src/properties/triangles_template1.h vendor/source/igraph/src/random/random.c vendor/source/igraph/src/scg/scg.c vendor/source/igraph/src/scg/scg_approximate_methods.c vendor/source/igraph/src/scg/scg_exact_scg.c vendor/source/igraph/src/scg/scg_headers.h vendor/source/igraph/src/scg/scg_kmeans.c vendor/source/igraph/src/scg/scg_optimal_method.c vendor/source/igraph/src/scg/scg_utils.c vendor/source/igraph/tests/CMakeLists.txt vendor/source/igraph/tests/benchmarks/bench.h vendor/source/igraph/tests/benchmarks/igraph_average_path_length_unweighted.c vendor/source/igraph/tests/benchmarks/igraph_betweenness.c vendor/source/igraph/tests/benchmarks/igraph_betweenness_weighted.c vendor/source/igraph/tests/benchmarks/igraph_cliques.c vendor/source/igraph/tests/benchmarks/igraph_closeness_weighted.c vendor/source/igraph/tests/benchmarks/igraph_coloring.c vendor/source/igraph/tests/benchmarks/igraph_decompose.c vendor/source/igraph/tests/benchmarks/igraph_maximal_cliques.c vendor/source/igraph/tests/benchmarks/igraph_pagerank.c vendor/source/igraph/tests/benchmarks/igraph_pagerank_weighted.c vendor/source/igraph/tests/benchmarks/igraph_power_law_fit.c vendor/source/igraph/tests/benchmarks/igraph_random_walk.c vendor/source/igraph/tests/benchmarks/igraph_transitivity.c vendor/source/igraph/tests/regression/bug-1033045.c vendor/source/igraph/tests/regression/bug-1033045.out vendor/source/igraph/tests/regression/bug-1149658.c vendor/source/igraph/tests/regression/bug_1760.c vendor/source/igraph/tests/regression/bug_1760.out vendor/source/igraph/tests/regression/bug_1814.c vendor/source/igraph/tests/regression/bug_1814.out vendor/source/igraph/tests/regression/cattr_bool_bug.c vendor/source/igraph/tests/regression/cattr_bool_bug.graphml vendor/source/igraph/tests/regression/cattr_bool_bug2.c vendor/source/igraph/tests/regression/cattr_bool_bug2.graphml vendor/source/igraph/tests/regression/igraph_layout_kamada_kawai_3d_bug_1462.c vendor/source/igraph/tests/regression/igraph_layout_kamada_kawai_3d_bug_1462.out vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.c vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.in vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.out vendor/source/igraph/tests/regression/igraph_read_graph_gml_invalid_inputs.c vendor/source/igraph/tests/regression/igraph_read_graph_graphml_invalid_inputs.c vendor/source/igraph/tests/regression/invalid1.gml vendor/source/igraph/tests/regression/invalid1.graphml vendor/source/igraph/tests/regression/invalid2.gml vendor/source/igraph/tests/regression/invalid2.graphml vendor/source/igraph/tests/regression/invalid3.gml vendor/source/igraph/tests/regression/invalid3.graphml vendor/source/igraph/tests/regression/invalid4.gml vendor/source/igraph/tests/regression/invalid5.gml vendor/source/igraph/tests/regression/invalid6.gml vendor/source/igraph/tests/unit/2wheap.c vendor/source/igraph/tests/unit/VF2-compat.c vendor/source/igraph/tests/unit/adjlist.c vendor/source/igraph/tests/unit/adjlist.out vendor/source/igraph/tests/unit/all_shortest_paths.c vendor/source/igraph/tests/unit/all_shortest_paths.out vendor/source/igraph/tests/unit/bfs.c vendor/source/igraph/tests/unit/bfs.out vendor/source/igraph/tests/unit/bfs_simple.c vendor/source/igraph/tests/unit/bfs_simple.out vendor/source/igraph/tests/unit/bipartite.net vendor/source/igraph/tests/unit/bliss_automorphisms.c vendor/source/igraph/tests/unit/bliss_automorphisms.out vendor/source/igraph/tests/unit/cattributes5.c vendor/source/igraph/tests/unit/cattributes5.out vendor/source/igraph/tests/unit/community_label_propagation.c vendor/source/igraph/tests/unit/community_label_propagation.out vendor/source/igraph/tests/unit/community_label_propagation2.c vendor/source/igraph/tests/unit/community_label_propagation2.out vendor/source/igraph/tests/unit/community_label_propagation3.c vendor/source/igraph/tests/unit/community_leiden.c vendor/source/igraph/tests/unit/community_leiden.out vendor/source/igraph/tests/unit/cutheap.c vendor/source/igraph/tests/unit/cutheap.out vendor/source/igraph/tests/unit/d_indheap.c vendor/source/igraph/tests/unit/d_indheap.out vendor/source/igraph/tests/unit/dgemv.c vendor/source/igraph/tests/unit/dgemv.out vendor/source/igraph/tests/unit/edge_selectors.c vendor/source/igraph/tests/unit/edge_selectors.out vendor/source/igraph/tests/unit/efficiency.c vendor/source/igraph/tests/unit/efficiency.out vendor/source/igraph/tests/unit/erdos_renyi_game.c vendor/source/igraph/tests/unit/error_macros.c vendor/source/igraph/tests/unit/error_macros.out vendor/source/igraph/tests/unit/fatal_handler.c vendor/source/igraph/tests/unit/fatal_handler.out vendor/source/igraph/tests/unit/full.c vendor/source/igraph/tests/unit/full.out vendor/source/igraph/tests/unit/global_transitivity.c vendor/source/igraph/tests/unit/global_transitivity.out vendor/source/igraph/tests/unit/glpk_error.c vendor/source/igraph/tests/unit/harmonic_centrality.c vendor/source/igraph/tests/unit/harmonic_centrality.out vendor/source/igraph/tests/unit/hashtable.c vendor/source/igraph/tests/unit/hashtable.out vendor/source/igraph/tests/unit/heap.c vendor/source/igraph/tests/unit/heap.out vendor/source/igraph/tests/unit/igraph_adhesion.c vendor/source/igraph/tests/unit/igraph_adjacency_spectral_embedding.c vendor/source/igraph/tests/unit/igraph_adjacency_spectral_embedding.out vendor/source/igraph/tests/unit/igraph_adjacent_triangles.c vendor/source/igraph/tests/unit/igraph_adjacent_triangles.out vendor/source/igraph/tests/unit/igraph_all_st_cuts.c vendor/source/igraph/tests/unit/igraph_all_st_cuts.out vendor/source/igraph/tests/unit/igraph_almost_equals.c vendor/source/igraph/tests/unit/igraph_are_connected.c vendor/source/igraph/tests/unit/igraph_arpack_rnsolve.c vendor/source/igraph/tests/unit/igraph_arpack_rnsolve.out vendor/source/igraph/tests/unit/igraph_arpack_unpack_complex.c vendor/source/igraph/tests/unit/igraph_arpack_unpack_complex.out vendor/source/igraph/tests/unit/igraph_array.c vendor/source/igraph/tests/unit/igraph_array.out vendor/source/igraph/tests/unit/igraph_attribute_combination_remove.c vendor/source/igraph/tests/unit/igraph_attribute_combination_remove.out vendor/source/igraph/tests/unit/igraph_average_path_length.c vendor/source/igraph/tests/unit/igraph_average_path_length.out vendor/source/igraph/tests/unit/igraph_average_path_length_dijkstra.c vendor/source/igraph/tests/unit/igraph_average_path_length_dijkstra.out vendor/source/igraph/tests/unit/igraph_barabasi_aging_game.c vendor/source/igraph/tests/unit/igraph_barabasi_aging_game.out vendor/source/igraph/tests/unit/igraph_betweenness.c vendor/source/igraph/tests/unit/igraph_betweenness.out vendor/source/igraph/tests/unit/igraph_bipartite_game.c vendor/source/igraph/tests/unit/igraph_bridges.c vendor/source/igraph/tests/unit/igraph_bridges.out vendor/source/igraph/tests/unit/igraph_callaway_traits_game.c vendor/source/igraph/tests/unit/igraph_cited_type_game.c vendor/source/igraph/tests/unit/igraph_cited_type_game.out vendor/source/igraph/tests/unit/igraph_citing_cited_type_game.c vendor/source/igraph/tests/unit/igraph_citing_cited_type_game.out vendor/source/igraph/tests/unit/igraph_clique_size_hist.c vendor/source/igraph/tests/unit/igraph_clique_size_hist.out vendor/source/igraph/tests/unit/igraph_closeness.c vendor/source/igraph/tests/unit/igraph_closeness.out vendor/source/igraph/tests/unit/igraph_cohesion.c vendor/source/igraph/tests/unit/igraph_community_infomap.c vendor/source/igraph/tests/unit/igraph_community_infomap.out vendor/source/igraph/tests/unit/igraph_community_leading_eigenvector2.c vendor/source/igraph/tests/unit/igraph_community_leading_eigenvector2.out vendor/source/igraph/tests/unit/igraph_compare_communities.c vendor/source/igraph/tests/unit/igraph_compare_communities.out vendor/source/igraph/tests/unit/igraph_complex.c vendor/source/igraph/tests/unit/igraph_convergence_degree.c vendor/source/igraph/tests/unit/igraph_convergence_degree.out vendor/source/igraph/tests/unit/igraph_correlated_game.c vendor/source/igraph/tests/unit/igraph_count_multiple.c vendor/source/igraph/tests/unit/igraph_count_multiple.out vendor/source/igraph/tests/unit/igraph_decompose_strong.c vendor/source/igraph/tests/unit/igraph_decompose_strong.out vendor/source/igraph/tests/unit/igraph_degree_sequence_game.c vendor/source/igraph/tests/unit/igraph_density.c vendor/source/igraph/tests/unit/igraph_density.out vendor/source/igraph/tests/unit/igraph_diversity.c vendor/source/igraph/tests/unit/igraph_diversity.out vendor/source/igraph/tests/unit/igraph_dyad_census.c vendor/source/igraph/tests/unit/igraph_dyad_census.out vendor/source/igraph/tests/unit/igraph_eccentricity.c vendor/source/igraph/tests/unit/igraph_eccentricity.out vendor/source/igraph/tests/unit/igraph_edge_betweenness.c vendor/source/igraph/tests/unit/igraph_edge_betweenness.out vendor/source/igraph/tests/unit/igraph_edge_disjoint_paths.c vendor/source/igraph/tests/unit/igraph_eigen_matrix.c vendor/source/igraph/tests/unit/igraph_eigen_matrix.out vendor/source/igraph/tests/unit/igraph_eigen_matrix2.c vendor/source/igraph/tests/unit/igraph_eigen_matrix2.out vendor/source/igraph/tests/unit/igraph_eigen_matrix3.c vendor/source/igraph/tests/unit/igraph_eigen_matrix3.out vendor/source/igraph/tests/unit/igraph_eigen_matrix4.c vendor/source/igraph/tests/unit/igraph_eigen_matrix4.out vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric.c vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric.out vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric_arpack.c vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric_arpack.out vendor/source/igraph/tests/unit/igraph_es_path.c vendor/source/igraph/tests/unit/igraph_establishment_game.c vendor/source/igraph/tests/unit/igraph_eulerian_cycle.c vendor/source/igraph/tests/unit/igraph_eulerian_cycle.out vendor/source/igraph/tests/unit/igraph_eulerian_path.c vendor/source/igraph/tests/unit/igraph_eulerian_path.out vendor/source/igraph/tests/unit/igraph_extended_chordal_ring.c vendor/source/igraph/tests/unit/igraph_forest_fire_game.c vendor/source/igraph/tests/unit/igraph_forest_fire_game.out vendor/source/igraph/tests/unit/igraph_from_prufer.c vendor/source/igraph/tests/unit/igraph_from_prufer.out vendor/source/igraph/tests/unit/igraph_full_citation.c vendor/source/igraph/tests/unit/igraph_get_adjacency_sparse.c vendor/source/igraph/tests/unit/igraph_get_adjacency_sparse.out vendor/source/igraph/tests/unit/igraph_get_all_simple_paths.c vendor/source/igraph/tests/unit/igraph_get_all_simple_paths.out vendor/source/igraph/tests/unit/igraph_get_incidence.c vendor/source/igraph/tests/unit/igraph_get_incidence.out vendor/source/igraph/tests/unit/igraph_get_isomorphisms_vf2.c vendor/source/igraph/tests/unit/igraph_get_isomorphisms_vf2.out vendor/source/igraph/tests/unit/igraph_get_shortest_paths2.c vendor/source/igraph/tests/unit/igraph_get_shortest_paths2.out vendor/source/igraph/tests/unit/igraph_get_shortest_paths_bellman_ford.c vendor/source/igraph/tests/unit/igraph_get_shortest_paths_bellman_ford.out vendor/source/igraph/tests/unit/igraph_get_subisomorphisms_vf2.c vendor/source/igraph/tests/unit/igraph_get_subisomorphisms_vf2.out vendor/source/igraph/tests/unit/igraph_gomory_hu_tree.c vendor/source/igraph/tests/unit/igraph_grg_game.c vendor/source/igraph/tests/unit/igraph_growing_random_game.c vendor/source/igraph/tests/unit/igraph_hrg.c vendor/source/igraph/tests/unit/igraph_hrg2.c vendor/source/igraph/tests/unit/igraph_hrg3.c vendor/source/igraph/tests/unit/igraph_i_incident.c vendor/source/igraph/tests/unit/igraph_i_incident.out vendor/source/igraph/tests/unit/igraph_i_layout_sphere.c vendor/source/igraph/tests/unit/igraph_i_neighbors.c vendor/source/igraph/tests/unit/igraph_i_neighbors.out vendor/source/igraph/tests/unit/igraph_induced_subgraph.c vendor/source/igraph/tests/unit/igraph_induced_subgraph.out vendor/source/igraph/tests/unit/igraph_induced_subgraph_map.c vendor/source/igraph/tests/unit/igraph_intersection2.c vendor/source/igraph/tests/unit/igraph_intersection2.out vendor/source/igraph/tests/unit/igraph_is_bigraphical.c vendor/source/igraph/tests/unit/igraph_is_bigraphical.out vendor/source/igraph/tests/unit/igraph_is_bipartite.c vendor/source/igraph/tests/unit/igraph_is_chordal.c vendor/source/igraph/tests/unit/igraph_is_chordal.out vendor/source/igraph/tests/unit/igraph_is_connected.c vendor/source/igraph/tests/unit/igraph_is_eulerian.c vendor/source/igraph/tests/unit/igraph_is_eulerian.out vendor/source/igraph/tests/unit/igraph_is_graphical.c vendor/source/igraph/tests/unit/igraph_is_graphical.out vendor/source/igraph/tests/unit/igraph_is_mutual.c vendor/source/igraph/tests/unit/igraph_is_mutual.out vendor/source/igraph/tests/unit/igraph_is_same_graph.c vendor/source/igraph/tests/unit/igraph_is_tree.c vendor/source/igraph/tests/unit/igraph_isomorphic_bliss.c vendor/source/igraph/tests/unit/igraph_isomorphic_bliss.out vendor/source/igraph/tests/unit/igraph_k_regular_game.c vendor/source/igraph/tests/unit/igraph_k_regular_game.out vendor/source/igraph/tests/unit/igraph_kautz.c vendor/source/igraph/tests/unit/igraph_lapack_dgehrd.c vendor/source/igraph/tests/unit/igraph_lapack_dgehrd.out vendor/source/igraph/tests/unit/igraph_lapack_dgetrf.c vendor/source/igraph/tests/unit/igraph_lapack_dgetrf.out vendor/source/igraph/tests/unit/igraph_lapack_dgetrs.c vendor/source/igraph/tests/unit/igraph_lapack_dgetrs.out vendor/source/igraph/tests/unit/igraph_lastcit_game.c vendor/source/igraph/tests/unit/igraph_lastcit_game.out vendor/source/igraph/tests/unit/igraph_lattice.c vendor/source/igraph/tests/unit/igraph_layout_bipartite.c vendor/source/igraph/tests/unit/igraph_layout_bipartite.out vendor/source/igraph/tests/unit/igraph_layout_davidson_harel.c vendor/source/igraph/tests/unit/igraph_layout_drl.c vendor/source/igraph/tests/unit/igraph_layout_fruchterman_reingold.c vendor/source/igraph/tests/unit/igraph_layout_fruchterman_reingold.out vendor/source/igraph/tests/unit/igraph_layout_graphopt.c vendor/source/igraph/tests/unit/igraph_layout_graphopt.out vendor/source/igraph/tests/unit/igraph_layout_grid.c vendor/source/igraph/tests/unit/igraph_layout_grid.out vendor/source/igraph/tests/unit/igraph_layout_lgl.c vendor/source/igraph/tests/unit/igraph_layout_mds.c vendor/source/igraph/tests/unit/igraph_layout_mds.out vendor/source/igraph/tests/unit/igraph_layout_merge.c vendor/source/igraph/tests/unit/igraph_layout_merge2.c vendor/source/igraph/tests/unit/igraph_layout_merge2.out vendor/source/igraph/tests/unit/igraph_layout_merge3.c vendor/source/igraph/tests/unit/igraph_layout_random_3d.c vendor/source/igraph/tests/unit/igraph_layout_random_3d.out vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_circular.c vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_circular.out vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_extended.c vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_extended.in vendor/source/igraph/tests/unit/igraph_layout_star.c vendor/source/igraph/tests/unit/igraph_layout_star.out vendor/source/igraph/tests/unit/igraph_layout_sugiyama.c vendor/source/igraph/tests/unit/igraph_layout_sugiyama.out vendor/source/igraph/tests/unit/igraph_le_community_to_membership.c vendor/source/igraph/tests/unit/igraph_le_community_to_membership.out vendor/source/igraph/tests/unit/igraph_linegraph.c vendor/source/igraph/tests/unit/igraph_list_triangles.c vendor/source/igraph/tests/unit/igraph_list_triangles.out vendor/source/igraph/tests/unit/igraph_local_scan_k_ecount.c vendor/source/igraph/tests/unit/igraph_local_scan_k_ecount.out vendor/source/igraph/tests/unit/igraph_local_transitivity.c vendor/source/igraph/tests/unit/igraph_local_transitivity.out vendor/source/igraph/tests/unit/igraph_maximal_cliques2.c vendor/source/igraph/tests/unit/igraph_maximal_cliques2.out vendor/source/igraph/tests/unit/igraph_maximal_cliques3.c vendor/source/igraph/tests/unit/igraph_maximal_cliques3.out vendor/source/igraph/tests/unit/igraph_maximal_cliques4.c vendor/source/igraph/tests/unit/igraph_maximal_cliques4.out vendor/source/igraph/tests/unit/igraph_maximal_cliques_file.c vendor/source/igraph/tests/unit/igraph_maximal_cliques_file.out vendor/source/igraph/tests/unit/igraph_modularity.c vendor/source/igraph/tests/unit/igraph_modularity.out vendor/source/igraph/tests/unit/igraph_modularity_matrix.c vendor/source/igraph/tests/unit/igraph_modularity_matrix.out vendor/source/igraph/tests/unit/igraph_moran_process.c vendor/source/igraph/tests/unit/igraph_motifs_randesu.c vendor/source/igraph/tests/unit/igraph_motifs_randesu.out vendor/source/igraph/tests/unit/igraph_motifs_randesu_estimate.c vendor/source/igraph/tests/unit/igraph_motifs_randesu_estimate.out vendor/source/igraph/tests/unit/igraph_motifs_randesu_no.c vendor/source/igraph/tests/unit/igraph_motifs_randesu_no.out vendor/source/igraph/tests/unit/igraph_neighborhood.c vendor/source/igraph/tests/unit/igraph_neighborhood.out vendor/source/igraph/tests/unit/igraph_neighborhood_graphs.c vendor/source/igraph/tests/unit/igraph_neighborhood_graphs.out vendor/source/igraph/tests/unit/igraph_neighborhood_size.c vendor/source/igraph/tests/unit/igraph_neighborhood_size.out vendor/source/igraph/tests/unit/igraph_pagerank.c vendor/source/igraph/tests/unit/igraph_pagerank.out vendor/source/igraph/tests/unit/igraph_preference_game.c vendor/source/igraph/tests/unit/igraph_progress_handler_stderr.c vendor/source/igraph/tests/unit/igraph_psumtree.c vendor/source/igraph/tests/unit/igraph_qsort.c vendor/source/igraph/tests/unit/igraph_qsort.out vendor/source/igraph/tests/unit/igraph_qsort_r.c vendor/source/igraph/tests/unit/igraph_qsort_r.out vendor/source/igraph/tests/unit/igraph_random_walk.c vendor/source/igraph/tests/unit/igraph_realize_degree_sequence.c vendor/source/igraph/tests/unit/igraph_realize_degree_sequence.out vendor/source/igraph/tests/unit/igraph_recent_degree_aging_game.c vendor/source/igraph/tests/unit/igraph_recent_degree_aging_game.out vendor/source/igraph/tests/unit/igraph_recent_degree_game.c vendor/source/igraph/tests/unit/igraph_recent_degree_game.out vendor/source/igraph/tests/unit/igraph_residual_graph.c vendor/source/igraph/tests/unit/igraph_rewire.c vendor/source/igraph/tests/unit/igraph_rewire_directed_edges.c vendor/source/igraph/tests/unit/igraph_rewire_directed_edges.out vendor/source/igraph/tests/unit/igraph_rng_get_exp.c vendor/source/igraph/tests/unit/igraph_rng_get_exp.out vendor/source/igraph/tests/unit/igraph_rng_get_integer.c vendor/source/igraph/tests/unit/igraph_rng_get_integer.out vendor/source/igraph/tests/unit/igraph_running_mean.c vendor/source/igraph/tests/unit/igraph_running_mean.out vendor/source/igraph/tests/unit/igraph_sbm_game.c vendor/source/igraph/tests/unit/igraph_sbm_game.out vendor/source/igraph/tests/unit/igraph_set_progress_handler.c vendor/source/igraph/tests/unit/igraph_set_progress_handler.out vendor/source/igraph/tests/unit/igraph_shortest_paths_johnson.c vendor/source/igraph/tests/unit/igraph_shortest_paths_johnson.out vendor/source/igraph/tests/unit/igraph_simple_interconnected_islands_game.c vendor/source/igraph/tests/unit/igraph_simple_interconnected_islands_game.out vendor/source/igraph/tests/unit/igraph_sir.c vendor/source/igraph/tests/unit/igraph_sir.out vendor/source/igraph/tests/unit/igraph_solve_lsap.c vendor/source/igraph/tests/unit/igraph_solve_lsap.out vendor/source/igraph/tests/unit/igraph_sparsemat2.c vendor/source/igraph/tests/unit/igraph_sparsemat2.out vendor/source/igraph/tests/unit/igraph_sparsemat5.c vendor/source/igraph/tests/unit/igraph_sparsemat5.out vendor/source/igraph/tests/unit/igraph_sparsemat9.c vendor/source/igraph/tests/unit/igraph_sparsemat_droptol.c vendor/source/igraph/tests/unit/igraph_sparsemat_droptol.out vendor/source/igraph/tests/unit/igraph_sparsemat_fkeep.c vendor/source/igraph/tests/unit/igraph_sparsemat_fkeep.out vendor/source/igraph/tests/unit/igraph_sparsemat_getelements_sorted.c vendor/source/igraph/tests/unit/igraph_sparsemat_getelements_sorted.out vendor/source/igraph/tests/unit/igraph_sparsemat_is_symmetric.c vendor/source/igraph/tests/unit/igraph_sparsemat_iterator_idx.c vendor/source/igraph/tests/unit/igraph_sparsemat_minmax.c vendor/source/igraph/tests/unit/igraph_sparsemat_minmax.out vendor/source/igraph/tests/unit/igraph_sparsemat_nonzero_storage.c vendor/source/igraph/tests/unit/igraph_sparsemat_view.c vendor/source/igraph/tests/unit/igraph_sparsemat_view.out vendor/source/igraph/tests/unit/igraph_sparsemat_which_minmax.c vendor/source/igraph/tests/unit/igraph_sparsemat_which_minmax.out vendor/source/igraph/tests/unit/igraph_split_join_distance.c vendor/source/igraph/tests/unit/igraph_split_join_distance.out vendor/source/igraph/tests/unit/igraph_spmatrix_add_col_values.c vendor/source/igraph/tests/unit/igraph_spmatrix_add_col_values.out vendor/source/igraph/tests/unit/igraph_st_edge_connectivity.c vendor/source/igraph/tests/unit/igraph_st_mincut.c vendor/source/igraph/tests/unit/igraph_st_mincut.out vendor/source/igraph/tests/unit/igraph_st_mincut_value.c vendor/source/igraph/tests/unit/igraph_static_power_law_game.c vendor/source/igraph/tests/unit/igraph_static_power_law_game.out vendor/source/igraph/tests/unit/igraph_subcomponent.c vendor/source/igraph/tests/unit/igraph_subcomponent.out vendor/source/igraph/tests/unit/igraph_subisomorphic.c vendor/source/igraph/tests/unit/igraph_to_directed.c vendor/source/igraph/tests/unit/igraph_to_directed.out vendor/source/igraph/tests/unit/igraph_to_prufer.c vendor/source/igraph/tests/unit/igraph_transitive_closure_dag.c vendor/source/igraph/tests/unit/igraph_transitive_closure_dag.out vendor/source/igraph/tests/unit/igraph_transitivity_avglocal_undirected.c vendor/source/igraph/tests/unit/igraph_transitivity_avglocal_undirected.out vendor/source/igraph/tests/unit/igraph_transitivity_barrat.c vendor/source/igraph/tests/unit/igraph_transitivity_barrat.out vendor/source/igraph/tests/unit/igraph_vector_floor.c vendor/source/igraph/tests/unit/igraph_vector_floor.out vendor/source/igraph/tests/unit/igraph_vector_lex_cmp.c vendor/source/igraph/tests/unit/igraph_vector_lex_cmp.out vendor/source/igraph/tests/unit/igraph_vertex_disjoint_paths.c vendor/source/igraph/tests/unit/igraph_weighted_cliques.c vendor/source/igraph/tests/unit/igraph_weighted_cliques.out vendor/source/igraph/tests/unit/igraph_write_graph_dimacs.c vendor/source/igraph/tests/unit/igraph_write_graph_dimacs.out vendor/source/igraph/tests/unit/igraph_write_graph_leda.c vendor/source/igraph/tests/unit/igraph_write_graph_leda.out vendor/source/igraph/tests/unit/inclist.c vendor/source/igraph/tests/unit/inclist.out vendor/source/igraph/tests/unit/input.dl vendor/source/igraph/tests/unit/isoclasses.c vendor/source/igraph/tests/unit/isoclasses.out vendor/source/igraph/tests/unit/isoclasses2.c vendor/source/igraph/tests/unit/isomorphism_test.c vendor/source/igraph/tests/unit/isomorphism_test.out vendor/source/igraph/tests/unit/levc-stress.c vendor/source/igraph/tests/unit/lineendings.c vendor/source/igraph/tests/unit/lineendings.out vendor/source/igraph/tests/unit/marked_queue.c vendor/source/igraph/tests/unit/matrix.c vendor/source/igraph/tests/unit/matrix.out vendor/source/igraph/tests/unit/matrix2.c vendor/source/igraph/tests/unit/matrix2.out vendor/source/igraph/tests/unit/matrix3.c vendor/source/igraph/tests/unit/maximal_cliques_callback.c vendor/source/igraph/tests/unit/maximal_cliques_hist.c vendor/source/igraph/tests/unit/maximal_cliques_hist.out vendor/source/igraph/tests/unit/mt.c vendor/source/igraph/tests/unit/pajek.c vendor/source/igraph/tests/unit/pajek1.net vendor/source/igraph/tests/unit/pajek2.c vendor/source/igraph/tests/unit/pajek2.net vendor/source/igraph/tests/unit/pajek2.out vendor/source/igraph/tests/unit/pajek3.net vendor/source/igraph/tests/unit/pajek4.net vendor/source/igraph/tests/unit/pajek5.net vendor/source/igraph/tests/unit/pajek6.net vendor/source/igraph/tests/unit/pajek_bip.net vendor/source/igraph/tests/unit/pajek_bip2.net vendor/source/igraph/tests/unit/pajek_bipartite.c vendor/source/igraph/tests/unit/pajek_bipartite.out vendor/source/igraph/tests/unit/pajek_bipartite2.c vendor/source/igraph/tests/unit/pajek_bipartite2.out vendor/source/igraph/tests/unit/pajek_signed.c vendor/source/igraph/tests/unit/pajek_signed.net vendor/source/igraph/tests/unit/pajek_signed.out vendor/source/igraph/tests/unit/random_spanning_tree.c vendor/source/igraph/tests/unit/ring.c vendor/source/igraph/tests/unit/rng_init_destroy_max_min_name_set_default.c vendor/source/igraph/tests/unit/rng_init_destroy_max_min_name_set_default.out vendor/source/igraph/tests/unit/rng_reproducibility.c vendor/source/igraph/tests/unit/rng_reproducibility.out vendor/source/igraph/tests/unit/scg2.c vendor/source/igraph/tests/unit/scg2.out vendor/source/igraph/tests/unit/scg3.c vendor/source/igraph/tests/unit/scg3.out vendor/source/igraph/tests/unit/set.c vendor/source/igraph/tests/unit/set.out vendor/source/igraph/tests/unit/simplify_and_colorize.c vendor/source/igraph/tests/unit/simplify_and_colorize.out vendor/source/igraph/tests/unit/single_target_shortest_path.c vendor/source/igraph/tests/unit/single_target_shortest_path.out vendor/source/igraph/tests/unit/spinglass.c vendor/source/igraph/tests/unit/spinglass.out vendor/source/igraph/tests/unit/spmatrix.c vendor/source/igraph/tests/unit/spmatrix.out vendor/source/igraph/tests/unit/spmatrix_clear.c vendor/source/igraph/tests/unit/spmatrix_clear.out vendor/source/igraph/tests/unit/stack.c vendor/source/igraph/tests/unit/strvector_set2_remove_print.c vendor/source/igraph/tests/unit/strvector_set2_remove_print.out vendor/source/igraph/tests/unit/test_utilities.inc vendor/source/igraph/tests/unit/tls1.c vendor/source/igraph/tests/unit/tls2.c vendor/source/igraph/tests/unit/tls2.out vendor/source/igraph/tests/unit/topological_sorting.c vendor/source/igraph/tests/unit/topological_sorting.out vendor/source/igraph/tests/unit/tree.c vendor/source/igraph/tests/unit/tree.out vendor/source/igraph/tests/unit/tree_game.c vendor/source/igraph/tests/unit/triad_census.c vendor/source/igraph/tests/unit/triad_census.out vendor/source/igraph/tests/unit/trie.c vendor/source/igraph/tests/unit/trie.out vendor/source/igraph/tests/unit/vector.c vendor/source/igraph/tests/unit/vector.out vendor/source/igraph/tests/unit/vector2.c vendor/source/igraph/tests/unit/vector2.out vendor/source/igraph/tests/unit/vector3.c vendor/source/igraph/tests/unit/vector_ptr.c vendor/source/igraph/tests/unit/vertex_selectors.c vendor/source/igraph/tests/unit/vertex_selectors.out vendor/source/igraph/tests/unit/watts_strogatz_game.c vendor/source/igraph/tests/unit/wikti_en_V_syn.elist vendor/source/igraph/tests/unit/zero_allocs.c vendor/source/igraph/tools/arpack-sed.txt vendor/source/igraph/tools/bump_version.sh vendor/source/igraph/tools/removeexamples.py vendor/source/igraph/tools/isoclasses/isoclasses.m vendor/source/igraph/tools/lapack/CompletePolish vendor/source/igraph/tools/lapack/Makefile vendor/source/igraph/tools/lapack/comment.l vendor/source/igraph/tools/lapack/delete.sed vendor/source/igraph/tools/lapack/getlapack.sh vendor/source/igraph/tools/lapack/lapack.patch vendor/source/igraph/tools/lapack/lenscrub.l vendor/source/igraph/tools/lapack/mt.patch vendor/source/igraph/tools/lapack/split.sed vendor/source/igraph/tools/lapack/extra/len_trim.f vendor/source/igraph/vendor/CMakeLists.txt vendor/source/igraph/vendor/cs/CMakeLists.txt vendor/source/igraph/vendor/cs/License.txt vendor/source/igraph/vendor/cs/SuiteSparse_config.h vendor/source/igraph/vendor/cs/cs.h vendor/source/igraph/vendor/cs/cs_add.c vendor/source/igraph/vendor/cs/cs_amd.c vendor/source/igraph/vendor/cs/cs_chol.c vendor/source/igraph/vendor/cs/cs_cholsol.c vendor/source/igraph/vendor/cs/cs_compress.c vendor/source/igraph/vendor/cs/cs_counts.c vendor/source/igraph/vendor/cs/cs_cumsum.c vendor/source/igraph/vendor/cs/cs_dfs.c vendor/source/igraph/vendor/cs/cs_dmperm.c vendor/source/igraph/vendor/cs/cs_droptol.c vendor/source/igraph/vendor/cs/cs_dropzeros.c vendor/source/igraph/vendor/cs/cs_dupl.c vendor/source/igraph/vendor/cs/cs_entry.c vendor/source/igraph/vendor/cs/cs_ereach.c vendor/source/igraph/vendor/cs/cs_etree.c vendor/source/igraph/vendor/cs/cs_fkeep.c vendor/source/igraph/vendor/cs/cs_gaxpy.c vendor/source/igraph/vendor/cs/cs_happly.c vendor/source/igraph/vendor/cs/cs_house.c vendor/source/igraph/vendor/cs/cs_ipvec.c vendor/source/igraph/vendor/cs/cs_leaf.c vendor/source/igraph/vendor/cs/cs_load.c vendor/source/igraph/vendor/cs/cs_lsolve.c vendor/source/igraph/vendor/cs/cs_ltsolve.c vendor/source/igraph/vendor/cs/cs_lu.c vendor/source/igraph/vendor/cs/cs_lusol.c vendor/source/igraph/vendor/cs/cs_malloc.c vendor/source/igraph/vendor/cs/cs_maxtrans.c vendor/source/igraph/vendor/cs/cs_multiply.c vendor/source/igraph/vendor/cs/cs_norm.c vendor/source/igraph/vendor/cs/cs_permute.c vendor/source/igraph/vendor/cs/cs_pinv.c vendor/source/igraph/vendor/cs/cs_post.c vendor/source/igraph/vendor/cs/cs_print.c vendor/source/igraph/vendor/cs/cs_pvec.c vendor/source/igraph/vendor/cs/cs_qr.c vendor/source/igraph/vendor/cs/cs_qrsol.c vendor/source/igraph/vendor/cs/cs_randperm.c vendor/source/igraph/vendor/cs/cs_reach.c vendor/source/igraph/vendor/cs/cs_scatter.c vendor/source/igraph/vendor/cs/cs_scc.c vendor/source/igraph/vendor/cs/cs_schol.c vendor/source/igraph/vendor/cs/cs_spsolve.c vendor/source/igraph/vendor/cs/cs_sqr.c vendor/source/igraph/vendor/cs/cs_symperm.c vendor/source/igraph/vendor/cs/cs_tdfs.c vendor/source/igraph/vendor/cs/cs_transpose.c vendor/source/igraph/vendor/cs/cs_updown.c vendor/source/igraph/vendor/cs/cs_usolve.c vendor/source/igraph/vendor/cs/cs_util.c vendor/source/igraph/vendor/cs/cs_utsolve.c vendor/source/igraph/vendor/f2c/CMakeLists.txt vendor/source/igraph/vendor/f2c/Notice vendor/source/igraph/vendor/f2c/README vendor/source/igraph/vendor/f2c/abort_.c vendor/source/igraph/vendor/f2c/arithchk.c vendor/source/igraph/vendor/f2c/backspac.c vendor/source/igraph/vendor/f2c/c_abs.c vendor/source/igraph/vendor/f2c/c_cos.c vendor/source/igraph/vendor/f2c/c_div.c vendor/source/igraph/vendor/f2c/c_exp.c vendor/source/igraph/vendor/f2c/c_log.c vendor/source/igraph/vendor/f2c/c_sin.c vendor/source/igraph/vendor/f2c/c_sqrt.c vendor/source/igraph/vendor/f2c/cabs.c vendor/source/igraph/vendor/f2c/changes vendor/source/igraph/vendor/f2c/close.c vendor/source/igraph/vendor/f2c/comptry.bat vendor/source/igraph/vendor/f2c/ctype.c vendor/source/igraph/vendor/f2c/ctype.h vendor/source/igraph/vendor/f2c/d_abs.c vendor/source/igraph/vendor/f2c/d_acos.c vendor/source/igraph/vendor/f2c/d_asin.c vendor/source/igraph/vendor/f2c/d_atan.c vendor/source/igraph/vendor/f2c/d_atn2.c vendor/source/igraph/vendor/f2c/d_cnjg.c vendor/source/igraph/vendor/f2c/d_cos.c vendor/source/igraph/vendor/f2c/d_cosh.c vendor/source/igraph/vendor/f2c/d_dim.c vendor/source/igraph/vendor/f2c/d_exp.c vendor/source/igraph/vendor/f2c/d_imag.c vendor/source/igraph/vendor/f2c/d_int.c vendor/source/igraph/vendor/f2c/d_lg10.c vendor/source/igraph/vendor/f2c/d_log.c vendor/source/igraph/vendor/f2c/d_mod.c vendor/source/igraph/vendor/f2c/d_nint.c vendor/source/igraph/vendor/f2c/d_prod.c vendor/source/igraph/vendor/f2c/d_sign.c vendor/source/igraph/vendor/f2c/d_sin.c vendor/source/igraph/vendor/f2c/d_sinh.c vendor/source/igraph/vendor/f2c/d_sqrt.c vendor/source/igraph/vendor/f2c/d_tan.c vendor/source/igraph/vendor/f2c/d_tanh.c vendor/source/igraph/vendor/f2c/derf_.c vendor/source/igraph/vendor/f2c/derfc_.c vendor/source/igraph/vendor/f2c/dfe.c vendor/source/igraph/vendor/f2c/dolio.c vendor/source/igraph/vendor/f2c/dtime_.c vendor/source/igraph/vendor/f2c/due.c vendor/source/igraph/vendor/f2c/dummy.c vendor/source/igraph/vendor/f2c/ef1asc_.c vendor/source/igraph/vendor/f2c/ef1cmc_.c vendor/source/igraph/vendor/f2c/endfile.c vendor/source/igraph/vendor/f2c/erf_.c vendor/source/igraph/vendor/f2c/erfc_.c vendor/source/igraph/vendor/f2c/err.c vendor/source/igraph/vendor/f2c/etime_.c vendor/source/igraph/vendor/f2c/exit_.c vendor/source/igraph/vendor/f2c/f2c.h0 vendor/source/igraph/vendor/f2c/f2ch.add vendor/source/igraph/vendor/f2c/f77_aloc.c vendor/source/igraph/vendor/f2c/f77vers.c vendor/source/igraph/vendor/f2c/fio.h vendor/source/igraph/vendor/f2c/fmt.c vendor/source/igraph/vendor/f2c/fmt.h vendor/source/igraph/vendor/f2c/fmtlib.c vendor/source/igraph/vendor/f2c/fp.h vendor/source/igraph/vendor/f2c/ftell_.c vendor/source/igraph/vendor/f2c/getarg_.c vendor/source/igraph/vendor/f2c/getenv_.c vendor/source/igraph/vendor/f2c/h_abs.c vendor/source/igraph/vendor/f2c/h_dim.c vendor/source/igraph/vendor/f2c/h_dnnt.c vendor/source/igraph/vendor/f2c/h_indx.c vendor/source/igraph/vendor/f2c/h_len.c vendor/source/igraph/vendor/f2c/h_mod.c vendor/source/igraph/vendor/f2c/h_nint.c vendor/source/igraph/vendor/f2c/h_sign.c vendor/source/igraph/vendor/f2c/hl_ge.c vendor/source/igraph/vendor/f2c/hl_gt.c vendor/source/igraph/vendor/f2c/hl_le.c vendor/source/igraph/vendor/f2c/hl_lt.c vendor/source/igraph/vendor/f2c/i77vers.c vendor/source/igraph/vendor/f2c/i_abs.c vendor/source/igraph/vendor/f2c/i_dim.c vendor/source/igraph/vendor/f2c/i_dnnt.c vendor/source/igraph/vendor/f2c/i_indx.c vendor/source/igraph/vendor/f2c/i_len.c vendor/source/igraph/vendor/f2c/i_mod.c vendor/source/igraph/vendor/f2c/i_nint.c vendor/source/igraph/vendor/f2c/i_sign.c vendor/source/igraph/vendor/f2c/iargc_.c vendor/source/igraph/vendor/f2c/iio.c vendor/source/igraph/vendor/f2c/ilnw.c vendor/source/igraph/vendor/f2c/inquire.c vendor/source/igraph/vendor/f2c/l_ge.c vendor/source/igraph/vendor/f2c/l_gt.c vendor/source/igraph/vendor/f2c/l_le.c vendor/source/igraph/vendor/f2c/l_lt.c vendor/source/igraph/vendor/f2c/lbitbits.c vendor/source/igraph/vendor/f2c/lbitshft.c vendor/source/igraph/vendor/f2c/libf2c.lbc vendor/source/igraph/vendor/f2c/libf2c.sy vendor/source/igraph/vendor/f2c/lio.h vendor/source/igraph/vendor/f2c/lread.c vendor/source/igraph/vendor/f2c/lwrite.c vendor/source/igraph/vendor/f2c/main.c vendor/source/igraph/vendor/f2c/makefile.sy vendor/source/igraph/vendor/f2c/makefile.u vendor/source/igraph/vendor/f2c/makefile.vc vendor/source/igraph/vendor/f2c/makefile.wat vendor/source/igraph/vendor/f2c/math.hvc vendor/source/igraph/vendor/f2c/mkfile.plan9 vendor/source/igraph/vendor/f2c/open.c vendor/source/igraph/vendor/f2c/pow_ci.c vendor/source/igraph/vendor/f2c/pow_dd.c vendor/source/igraph/vendor/f2c/pow_di.c vendor/source/igraph/vendor/f2c/pow_hh.c vendor/source/igraph/vendor/f2c/pow_ii.c vendor/source/igraph/vendor/f2c/pow_ri.c vendor/source/igraph/vendor/f2c/pow_zi.c vendor/source/igraph/vendor/f2c/pow_zz.c vendor/source/igraph/vendor/f2c/r_abs.c vendor/source/igraph/vendor/f2c/r_acos.c vendor/source/igraph/vendor/f2c/r_asin.c vendor/source/igraph/vendor/f2c/r_atan.c vendor/source/igraph/vendor/f2c/r_atn2.c vendor/source/igraph/vendor/f2c/r_cnjg.c vendor/source/igraph/vendor/f2c/r_cos.c vendor/source/igraph/vendor/f2c/r_cosh.c vendor/source/igraph/vendor/f2c/r_dim.c vendor/source/igraph/vendor/f2c/r_exp.c vendor/source/igraph/vendor/f2c/r_imag.c vendor/source/igraph/vendor/f2c/r_int.c vendor/source/igraph/vendor/f2c/r_lg10.c vendor/source/igraph/vendor/f2c/r_log.c vendor/source/igraph/vendor/f2c/r_mod.c vendor/source/igraph/vendor/f2c/r_nint.c vendor/source/igraph/vendor/f2c/r_sign.c vendor/source/igraph/vendor/f2c/r_sin.c vendor/source/igraph/vendor/f2c/r_sinh.c vendor/source/igraph/vendor/f2c/r_sqrt.c vendor/source/igraph/vendor/f2c/r_tan.c vendor/source/igraph/vendor/f2c/r_tanh.c vendor/source/igraph/vendor/f2c/rawio.h vendor/source/igraph/vendor/f2c/rdfmt.c vendor/source/igraph/vendor/f2c/rewind.c vendor/source/igraph/vendor/f2c/rsfe.c vendor/source/igraph/vendor/f2c/rsli.c vendor/source/igraph/vendor/f2c/rsne.c vendor/source/igraph/vendor/f2c/s_cat.c vendor/source/igraph/vendor/f2c/s_cmp.c vendor/source/igraph/vendor/f2c/s_copy.c vendor/source/igraph/vendor/f2c/s_paus.c vendor/source/igraph/vendor/f2c/s_rnge.c vendor/source/igraph/vendor/f2c/s_stop.c vendor/source/igraph/vendor/f2c/scomptry.bat vendor/source/igraph/vendor/f2c/sfe.c vendor/source/igraph/vendor/f2c/sig_die.c vendor/source/igraph/vendor/f2c/signal1.h vendor/source/igraph/vendor/f2c/signal1.h0 vendor/source/igraph/vendor/f2c/signal_.c vendor/source/igraph/vendor/f2c/signbit.c vendor/source/igraph/vendor/f2c/sue.c vendor/source/igraph/vendor/f2c/sysdep1.h vendor/source/igraph/vendor/f2c/sysdep1.h0 vendor/source/igraph/vendor/f2c/system_.c vendor/source/igraph/vendor/f2c/typesize.c vendor/source/igraph/vendor/f2c/uio.c vendor/source/igraph/vendor/f2c/uninit.c vendor/source/igraph/vendor/f2c/util.c vendor/source/igraph/vendor/f2c/wref.c vendor/source/igraph/vendor/f2c/wrtfmt.c vendor/source/igraph/vendor/f2c/wsfe.c vendor/source/igraph/vendor/f2c/wsle.c vendor/source/igraph/vendor/f2c/wsne.c vendor/source/igraph/vendor/f2c/xsum0.out vendor/source/igraph/vendor/f2c/xwsne.c vendor/source/igraph/vendor/f2c/z_abs.c vendor/source/igraph/vendor/f2c/z_cos.c vendor/source/igraph/vendor/f2c/z_div.c vendor/source/igraph/vendor/f2c/z_exp.c vendor/source/igraph/vendor/f2c/z_log.c vendor/source/igraph/vendor/f2c/z_sin.c vendor/source/igraph/vendor/f2c/z_sqrt.c vendor/source/igraph/vendor/glpk/CMakeLists.txt vendor/source/igraph/vendor/glpk/COPYING vendor/source/igraph/vendor/glpk/README vendor/source/igraph/vendor/glpk/glpk.h vendor/source/igraph/vendor/glpk/glpk_tls_config.h vendor/source/igraph/vendor/glpk/amd/COPYING vendor/source/igraph/vendor/glpk/amd/README vendor/source/igraph/vendor/glpk/amd/amd.h vendor/source/igraph/vendor/glpk/amd/amd_1.c vendor/source/igraph/vendor/glpk/amd/amd_2.c vendor/source/igraph/vendor/glpk/amd/amd_aat.c vendor/source/igraph/vendor/glpk/amd/amd_control.c vendor/source/igraph/vendor/glpk/amd/amd_defaults.c vendor/source/igraph/vendor/glpk/amd/amd_dump.c vendor/source/igraph/vendor/glpk/amd/amd_info.c vendor/source/igraph/vendor/glpk/amd/amd_internal.h vendor/source/igraph/vendor/glpk/amd/amd_order.c vendor/source/igraph/vendor/glpk/amd/amd_post_tree.c vendor/source/igraph/vendor/glpk/amd/amd_postorder.c vendor/source/igraph/vendor/glpk/amd/amd_preprocess.c vendor/source/igraph/vendor/glpk/amd/amd_valid.c vendor/source/igraph/vendor/glpk/api/advbas.c vendor/source/igraph/vendor/glpk/api/asnhall.c vendor/source/igraph/vendor/glpk/api/asnlp.c vendor/source/igraph/vendor/glpk/api/asnokalg.c vendor/source/igraph/vendor/glpk/api/ckasn.c vendor/source/igraph/vendor/glpk/api/ckcnf.c vendor/source/igraph/vendor/glpk/api/cplex.c vendor/source/igraph/vendor/glpk/api/cpp.c vendor/source/igraph/vendor/glpk/api/cpxbas.c vendor/source/igraph/vendor/glpk/api/graph.c vendor/source/igraph/vendor/glpk/api/gridgen.c vendor/source/igraph/vendor/glpk/api/intfeas1.c vendor/source/igraph/vendor/glpk/api/maxffalg.c vendor/source/igraph/vendor/glpk/api/maxflp.c vendor/source/igraph/vendor/glpk/api/mcflp.c vendor/source/igraph/vendor/glpk/api/mcfokalg.c vendor/source/igraph/vendor/glpk/api/mcfrelax.c vendor/source/igraph/vendor/glpk/api/minisat1.c vendor/source/igraph/vendor/glpk/api/mpl.c vendor/source/igraph/vendor/glpk/api/mps.c vendor/source/igraph/vendor/glpk/api/netgen.c vendor/source/igraph/vendor/glpk/api/npp.c vendor/source/igraph/vendor/glpk/api/pript.c vendor/source/igraph/vendor/glpk/api/prmip.c vendor/source/igraph/vendor/glpk/api/prob.h vendor/source/igraph/vendor/glpk/api/prob1.c vendor/source/igraph/vendor/glpk/api/prob2.c vendor/source/igraph/vendor/glpk/api/prob3.c vendor/source/igraph/vendor/glpk/api/prob4.c vendor/source/igraph/vendor/glpk/api/prob5.c vendor/source/igraph/vendor/glpk/api/prrngs.c vendor/source/igraph/vendor/glpk/api/prsol.c vendor/source/igraph/vendor/glpk/api/rdasn.c vendor/source/igraph/vendor/glpk/api/rdcc.c vendor/source/igraph/vendor/glpk/api/rdcnf.c vendor/source/igraph/vendor/glpk/api/rdipt.c vendor/source/igraph/vendor/glpk/api/rdmaxf.c vendor/source/igraph/vendor/glpk/api/rdmcf.c vendor/source/igraph/vendor/glpk/api/rdmip.c vendor/source/igraph/vendor/glpk/api/rdprob.c vendor/source/igraph/vendor/glpk/api/rdsol.c vendor/source/igraph/vendor/glpk/api/rmfgen.c vendor/source/igraph/vendor/glpk/api/strong.c vendor/source/igraph/vendor/glpk/api/topsort.c vendor/source/igraph/vendor/glpk/api/wcliqex.c vendor/source/igraph/vendor/glpk/api/weak.c vendor/source/igraph/vendor/glpk/api/wrasn.c vendor/source/igraph/vendor/glpk/api/wrcc.c vendor/source/igraph/vendor/glpk/api/wrcnf.c vendor/source/igraph/vendor/glpk/api/wript.c vendor/source/igraph/vendor/glpk/api/wrmaxf.c vendor/source/igraph/vendor/glpk/api/wrmcf.c vendor/source/igraph/vendor/glpk/api/wrmip.c vendor/source/igraph/vendor/glpk/api/wrprob.c vendor/source/igraph/vendor/glpk/api/wrsol.c vendor/source/igraph/vendor/glpk/bflib/btf.c vendor/source/igraph/vendor/glpk/bflib/btf.h vendor/source/igraph/vendor/glpk/bflib/btfint.c vendor/source/igraph/vendor/glpk/bflib/btfint.h vendor/source/igraph/vendor/glpk/bflib/fhv.c vendor/source/igraph/vendor/glpk/bflib/fhv.h vendor/source/igraph/vendor/glpk/bflib/fhvint.c vendor/source/igraph/vendor/glpk/bflib/fhvint.h vendor/source/igraph/vendor/glpk/bflib/ifu.c vendor/source/igraph/vendor/glpk/bflib/ifu.h vendor/source/igraph/vendor/glpk/bflib/luf.c vendor/source/igraph/vendor/glpk/bflib/luf.h vendor/source/igraph/vendor/glpk/bflib/lufint.c vendor/source/igraph/vendor/glpk/bflib/lufint.h vendor/source/igraph/vendor/glpk/bflib/scf.c vendor/source/igraph/vendor/glpk/bflib/scf.h vendor/source/igraph/vendor/glpk/bflib/scfint.c vendor/source/igraph/vendor/glpk/bflib/scfint.h vendor/source/igraph/vendor/glpk/bflib/sgf.c vendor/source/igraph/vendor/glpk/bflib/sgf.h vendor/source/igraph/vendor/glpk/bflib/sva.c vendor/source/igraph/vendor/glpk/bflib/sva.h vendor/source/igraph/vendor/glpk/colamd/COPYING vendor/source/igraph/vendor/glpk/colamd/README vendor/source/igraph/vendor/glpk/colamd/colamd.c vendor/source/igraph/vendor/glpk/colamd/colamd.h vendor/source/igraph/vendor/glpk/draft/bfd.c vendor/source/igraph/vendor/glpk/draft/bfd.h vendor/source/igraph/vendor/glpk/draft/bfx.c vendor/source/igraph/vendor/glpk/draft/bfx.h vendor/source/igraph/vendor/glpk/draft/draft.h vendor/source/igraph/vendor/glpk/draft/glpapi06.c vendor/source/igraph/vendor/glpk/draft/glpapi07.c vendor/source/igraph/vendor/glpk/draft/glpapi08.c vendor/source/igraph/vendor/glpk/draft/glpapi09.c vendor/source/igraph/vendor/glpk/draft/glpapi10.c vendor/source/igraph/vendor/glpk/draft/glpapi12.c vendor/source/igraph/vendor/glpk/draft/glpapi13.c vendor/source/igraph/vendor/glpk/draft/glpios01.c vendor/source/igraph/vendor/glpk/draft/glpios02.c vendor/source/igraph/vendor/glpk/draft/glpios03.c vendor/source/igraph/vendor/glpk/draft/glpios07.c vendor/source/igraph/vendor/glpk/draft/glpios09.c vendor/source/igraph/vendor/glpk/draft/glpios11.c vendor/source/igraph/vendor/glpk/draft/glpios12.c vendor/source/igraph/vendor/glpk/draft/glpipm.c vendor/source/igraph/vendor/glpk/draft/glpipm.h vendor/source/igraph/vendor/glpk/draft/glpmat.c vendor/source/igraph/vendor/glpk/draft/glpmat.h vendor/source/igraph/vendor/glpk/draft/glpscl.c vendor/source/igraph/vendor/glpk/draft/glpssx.h vendor/source/igraph/vendor/glpk/draft/glpssx01.c vendor/source/igraph/vendor/glpk/draft/glpssx02.c vendor/source/igraph/vendor/glpk/draft/ios.h vendor/source/igraph/vendor/glpk/draft/lux.c vendor/source/igraph/vendor/glpk/draft/lux.h vendor/source/igraph/vendor/glpk/env/alloc.c vendor/source/igraph/vendor/glpk/env/dlsup.c vendor/source/igraph/vendor/glpk/env/env.c vendor/source/igraph/vendor/glpk/env/env.h vendor/source/igraph/vendor/glpk/env/error.c vendor/source/igraph/vendor/glpk/env/stdc.c vendor/source/igraph/vendor/glpk/env/stdc.h vendor/source/igraph/vendor/glpk/env/stdout.c vendor/source/igraph/vendor/glpk/env/stream.c vendor/source/igraph/vendor/glpk/env/time.c vendor/source/igraph/vendor/glpk/env/tls.c vendor/source/igraph/vendor/glpk/intopt/cfg.c vendor/source/igraph/vendor/glpk/intopt/cfg.h vendor/source/igraph/vendor/glpk/intopt/cfg1.c vendor/source/igraph/vendor/glpk/intopt/cfg2.c vendor/source/igraph/vendor/glpk/intopt/clqcut.c vendor/source/igraph/vendor/glpk/intopt/covgen.c vendor/source/igraph/vendor/glpk/intopt/fpump.c vendor/source/igraph/vendor/glpk/intopt/gmicut.c vendor/source/igraph/vendor/glpk/intopt/gmigen.c vendor/source/igraph/vendor/glpk/intopt/mirgen.c vendor/source/igraph/vendor/glpk/intopt/spv.c vendor/source/igraph/vendor/glpk/intopt/spv.h vendor/source/igraph/vendor/glpk/minisat/LICENSE vendor/source/igraph/vendor/glpk/minisat/README vendor/source/igraph/vendor/glpk/minisat/minisat.c vendor/source/igraph/vendor/glpk/minisat/minisat.h vendor/source/igraph/vendor/glpk/misc/avl.c vendor/source/igraph/vendor/glpk/misc/avl.h vendor/source/igraph/vendor/glpk/misc/bignum.c vendor/source/igraph/vendor/glpk/misc/bignum.h vendor/source/igraph/vendor/glpk/misc/dimacs.c vendor/source/igraph/vendor/glpk/misc/dimacs.h vendor/source/igraph/vendor/glpk/misc/dmp.c vendor/source/igraph/vendor/glpk/misc/dmp.h vendor/source/igraph/vendor/glpk/misc/ffalg.c vendor/source/igraph/vendor/glpk/misc/ffalg.h vendor/source/igraph/vendor/glpk/misc/fp2rat.c vendor/source/igraph/vendor/glpk/misc/fvs.c vendor/source/igraph/vendor/glpk/misc/fvs.h vendor/source/igraph/vendor/glpk/misc/gcd.c vendor/source/igraph/vendor/glpk/misc/hbm.c vendor/source/igraph/vendor/glpk/misc/hbm.h vendor/source/igraph/vendor/glpk/misc/jd.c vendor/source/igraph/vendor/glpk/misc/jd.h vendor/source/igraph/vendor/glpk/misc/keller.c vendor/source/igraph/vendor/glpk/misc/keller.h vendor/source/igraph/vendor/glpk/misc/ks.c vendor/source/igraph/vendor/glpk/misc/ks.h vendor/source/igraph/vendor/glpk/misc/mc13d.c vendor/source/igraph/vendor/glpk/misc/mc13d.h vendor/source/igraph/vendor/glpk/misc/mc21a.c vendor/source/igraph/vendor/glpk/misc/mc21a.h vendor/source/igraph/vendor/glpk/misc/misc.h vendor/source/igraph/vendor/glpk/misc/mt1.c vendor/source/igraph/vendor/glpk/misc/mt1.f vendor/source/igraph/vendor/glpk/misc/mt1.h vendor/source/igraph/vendor/glpk/misc/mygmp.c vendor/source/igraph/vendor/glpk/misc/mygmp.h vendor/source/igraph/vendor/glpk/misc/okalg.c vendor/source/igraph/vendor/glpk/misc/okalg.h vendor/source/igraph/vendor/glpk/misc/qmd.c vendor/source/igraph/vendor/glpk/misc/qmd.h vendor/source/igraph/vendor/glpk/misc/relax4.c vendor/source/igraph/vendor/glpk/misc/relax4.h vendor/source/igraph/vendor/glpk/misc/rgr.c vendor/source/igraph/vendor/glpk/misc/rgr.h vendor/source/igraph/vendor/glpk/misc/rng.c vendor/source/igraph/vendor/glpk/misc/rng.h vendor/source/igraph/vendor/glpk/misc/rng1.c vendor/source/igraph/vendor/glpk/misc/round2n.c vendor/source/igraph/vendor/glpk/misc/spm.c vendor/source/igraph/vendor/glpk/misc/spm.h vendor/source/igraph/vendor/glpk/misc/str2int.c vendor/source/igraph/vendor/glpk/misc/str2num.c vendor/source/igraph/vendor/glpk/misc/strspx.c vendor/source/igraph/vendor/glpk/misc/strtrim.c vendor/source/igraph/vendor/glpk/misc/triang.c vendor/source/igraph/vendor/glpk/misc/triang.h vendor/source/igraph/vendor/glpk/misc/wclique.c vendor/source/igraph/vendor/glpk/misc/wclique.h vendor/source/igraph/vendor/glpk/misc/wclique1.c vendor/source/igraph/vendor/glpk/misc/wclique1.h vendor/source/igraph/vendor/glpk/mpl/mpl.h vendor/source/igraph/vendor/glpk/mpl/mpl1.c vendor/source/igraph/vendor/glpk/mpl/mpl2.c vendor/source/igraph/vendor/glpk/mpl/mpl3.c vendor/source/igraph/vendor/glpk/mpl/mpl4.c vendor/source/igraph/vendor/glpk/mpl/mpl5.c vendor/source/igraph/vendor/glpk/mpl/mpl6.c vendor/source/igraph/vendor/glpk/mpl/mplsql.c vendor/source/igraph/vendor/glpk/mpl/mplsql.h vendor/source/igraph/vendor/glpk/npp/npp.h vendor/source/igraph/vendor/glpk/npp/npp1.c vendor/source/igraph/vendor/glpk/npp/npp2.c vendor/source/igraph/vendor/glpk/npp/npp3.c vendor/source/igraph/vendor/glpk/npp/npp4.c vendor/source/igraph/vendor/glpk/npp/npp5.c vendor/source/igraph/vendor/glpk/npp/npp6.c vendor/source/igraph/vendor/glpk/proxy/main.c vendor/source/igraph/vendor/glpk/proxy/proxy.c vendor/source/igraph/vendor/glpk/proxy/proxy.h vendor/source/igraph/vendor/glpk/proxy/proxy1.c vendor/source/igraph/vendor/glpk/simplex/simplex.h vendor/source/igraph/vendor/glpk/simplex/spxat.c vendor/source/igraph/vendor/glpk/simplex/spxat.h vendor/source/igraph/vendor/glpk/simplex/spxchuzc.c vendor/source/igraph/vendor/glpk/simplex/spxchuzc.h vendor/source/igraph/vendor/glpk/simplex/spxchuzr.c vendor/source/igraph/vendor/glpk/simplex/spxchuzr.h vendor/source/igraph/vendor/glpk/simplex/spxlp.c vendor/source/igraph/vendor/glpk/simplex/spxlp.h vendor/source/igraph/vendor/glpk/simplex/spxnt.c vendor/source/igraph/vendor/glpk/simplex/spxnt.h vendor/source/igraph/vendor/glpk/simplex/spxprim.c vendor/source/igraph/vendor/glpk/simplex/spxprob.c vendor/source/igraph/vendor/glpk/simplex/spxprob.h vendor/source/igraph/vendor/glpk/simplex/spychuzc.c vendor/source/igraph/vendor/glpk/simplex/spychuzc.h vendor/source/igraph/vendor/glpk/simplex/spychuzr.c vendor/source/igraph/vendor/glpk/simplex/spychuzr.h vendor/source/igraph/vendor/glpk/simplex/spydual.c vendor/source/igraph/vendor/lapack/CMakeLists.txt vendor/source/igraph/vendor/lapack/dasum.c vendor/source/igraph/vendor/lapack/daxpy.c vendor/source/igraph/vendor/lapack/dcopy.c vendor/source/igraph/vendor/lapack/ddot.c vendor/source/igraph/vendor/lapack/debug.h vendor/source/igraph/vendor/lapack/dgebak.c vendor/source/igraph/vendor/lapack/dgebal.c vendor/source/igraph/vendor/lapack/dgeev.c vendor/source/igraph/vendor/lapack/dgeevx.c vendor/source/igraph/vendor/lapack/dgehd2.c vendor/source/igraph/vendor/lapack/dgehrd.c vendor/source/igraph/vendor/lapack/dgemm.c vendor/source/igraph/vendor/lapack/dgemv.c vendor/source/igraph/vendor/lapack/dgeqr2.c vendor/source/igraph/vendor/lapack/dger.c vendor/source/igraph/vendor/lapack/dgesv.c vendor/source/igraph/vendor/lapack/dgetf2.c vendor/source/igraph/vendor/lapack/dgetrf.c vendor/source/igraph/vendor/lapack/dgetrs.c vendor/source/igraph/vendor/lapack/dgetv0.c vendor/source/igraph/vendor/lapack/dhseqr.c vendor/source/igraph/vendor/lapack/disnan.c vendor/source/igraph/vendor/lapack/dlabad.c vendor/source/igraph/vendor/lapack/dlacn2.c vendor/source/igraph/vendor/lapack/dlacpy.c vendor/source/igraph/vendor/lapack/dladiv.c vendor/source/igraph/vendor/lapack/dlae2.c vendor/source/igraph/vendor/lapack/dlaebz.c vendor/source/igraph/vendor/lapack/dlaev2.c vendor/source/igraph/vendor/lapack/dlaexc.c vendor/source/igraph/vendor/lapack/dlagtf.c vendor/source/igraph/vendor/lapack/dlagts.c vendor/source/igraph/vendor/lapack/dlahqr.c vendor/source/igraph/vendor/lapack/dlahr2.c vendor/source/igraph/vendor/lapack/dlaisnan.c vendor/source/igraph/vendor/lapack/dlaln2.c vendor/source/igraph/vendor/lapack/dlamch.c vendor/source/igraph/vendor/lapack/dlaneg.c vendor/source/igraph/vendor/lapack/dlange.c vendor/source/igraph/vendor/lapack/dlanhs.c vendor/source/igraph/vendor/lapack/dlanst.c vendor/source/igraph/vendor/lapack/dlansy.c vendor/source/igraph/vendor/lapack/dlanv2.c vendor/source/igraph/vendor/lapack/dlapy2.c vendor/source/igraph/vendor/lapack/dlaqr0.c vendor/source/igraph/vendor/lapack/dlaqr1.c vendor/source/igraph/vendor/lapack/dlaqr2.c vendor/source/igraph/vendor/lapack/dlaqr3.c vendor/source/igraph/vendor/lapack/dlaqr4.c vendor/source/igraph/vendor/lapack/dlaqr5.c vendor/source/igraph/vendor/lapack/dlaqrb.c vendor/source/igraph/vendor/lapack/dlaqtr.c vendor/source/igraph/vendor/lapack/dlar1v.c vendor/source/igraph/vendor/lapack/dlarf.c vendor/source/igraph/vendor/lapack/dlarfb.c vendor/source/igraph/vendor/lapack/dlarfg.c vendor/source/igraph/vendor/lapack/dlarft.c vendor/source/igraph/vendor/lapack/dlarfx.c vendor/source/igraph/vendor/lapack/dlarnv.c vendor/source/igraph/vendor/lapack/dlarra.c vendor/source/igraph/vendor/lapack/dlarrb.c vendor/source/igraph/vendor/lapack/dlarrc.c vendor/source/igraph/vendor/lapack/dlarrd.c vendor/source/igraph/vendor/lapack/dlarre.c vendor/source/igraph/vendor/lapack/dlarrf.c vendor/source/igraph/vendor/lapack/dlarrj.c vendor/source/igraph/vendor/lapack/dlarrk.c vendor/source/igraph/vendor/lapack/dlarrr.c vendor/source/igraph/vendor/lapack/dlarrv.c vendor/source/igraph/vendor/lapack/dlartg.c vendor/source/igraph/vendor/lapack/dlaruv.c vendor/source/igraph/vendor/lapack/dlascl.c vendor/source/igraph/vendor/lapack/dlaset.c vendor/source/igraph/vendor/lapack/dlasq2.c vendor/source/igraph/vendor/lapack/dlasq3.c vendor/source/igraph/vendor/lapack/dlasq4.c vendor/source/igraph/vendor/lapack/dlasq5.c vendor/source/igraph/vendor/lapack/dlasq6.c vendor/source/igraph/vendor/lapack/dlasr.c vendor/source/igraph/vendor/lapack/dlasrt.c vendor/source/igraph/vendor/lapack/dlassq.c vendor/source/igraph/vendor/lapack/dlaswp.c vendor/source/igraph/vendor/lapack/dlasy2.c vendor/source/igraph/vendor/lapack/dlatrd.c vendor/source/igraph/vendor/lapack/dmout.c vendor/source/igraph/vendor/lapack/dnaitr.c vendor/source/igraph/vendor/lapack/dnapps.c vendor/source/igraph/vendor/lapack/dnaup2.c vendor/source/igraph/vendor/lapack/dnaupd.c vendor/source/igraph/vendor/lapack/dnconv.c vendor/source/igraph/vendor/lapack/dneigh.c vendor/source/igraph/vendor/lapack/dneupd.c vendor/source/igraph/vendor/lapack/dngets.c vendor/source/igraph/vendor/lapack/dnrm2.c vendor/source/igraph/vendor/lapack/dorg2r.c vendor/source/igraph/vendor/lapack/dorghr.c vendor/source/igraph/vendor/lapack/dorgqr.c vendor/source/igraph/vendor/lapack/dorm2l.c vendor/source/igraph/vendor/lapack/dorm2r.c vendor/source/igraph/vendor/lapack/dormhr.c vendor/source/igraph/vendor/lapack/dormql.c vendor/source/igraph/vendor/lapack/dormqr.c vendor/source/igraph/vendor/lapack/dormtr.c vendor/source/igraph/vendor/lapack/dpotf2.c vendor/source/igraph/vendor/lapack/dpotrf.c vendor/source/igraph/vendor/lapack/drot.c vendor/source/igraph/vendor/lapack/dsaitr.c vendor/source/igraph/vendor/lapack/dsapps.c vendor/source/igraph/vendor/lapack/dsaup2.c vendor/source/igraph/vendor/lapack/dsaupd.c vendor/source/igraph/vendor/lapack/dscal.c vendor/source/igraph/vendor/lapack/dsconv.c vendor/source/igraph/vendor/lapack/dseigt.c vendor/source/igraph/vendor/lapack/dsesrt.c vendor/source/igraph/vendor/lapack/dseupd.c vendor/source/igraph/vendor/lapack/dsgets.c vendor/source/igraph/vendor/lapack/dsortc.c vendor/source/igraph/vendor/lapack/dsortr.c vendor/source/igraph/vendor/lapack/dstatn.c vendor/source/igraph/vendor/lapack/dstats.c vendor/source/igraph/vendor/lapack/dstebz.c vendor/source/igraph/vendor/lapack/dstein.c vendor/source/igraph/vendor/lapack/dstemr.c vendor/source/igraph/vendor/lapack/dsteqr.c vendor/source/igraph/vendor/lapack/dsterf.c vendor/source/igraph/vendor/lapack/dstqrb.c vendor/source/igraph/vendor/lapack/dswap.c vendor/source/igraph/vendor/lapack/dsyevr.c vendor/source/igraph/vendor/lapack/dsymv.c vendor/source/igraph/vendor/lapack/dsyr2.c vendor/source/igraph/vendor/lapack/dsyr2k.c vendor/source/igraph/vendor/lapack/dsyrk.c vendor/source/igraph/vendor/lapack/dsytd2.c vendor/source/igraph/vendor/lapack/dsytrd.c vendor/source/igraph/vendor/lapack/dtrevc.c vendor/source/igraph/vendor/lapack/dtrexc.c vendor/source/igraph/vendor/lapack/dtrmm.c vendor/source/igraph/vendor/lapack/dtrmv.c vendor/source/igraph/vendor/lapack/dtrsen.c vendor/source/igraph/vendor/lapack/dtrsm.c vendor/source/igraph/vendor/lapack/dtrsna.c vendor/source/igraph/vendor/lapack/dtrsv.c vendor/source/igraph/vendor/lapack/dtrsyl.c vendor/source/igraph/vendor/lapack/dvout.c vendor/source/igraph/vendor/lapack/fortran_intrinsics.c vendor/source/igraph/vendor/lapack/idamax.c vendor/source/igraph/vendor/lapack/ieeeck.c vendor/source/igraph/vendor/lapack/iladlc.c vendor/source/igraph/vendor/lapack/iladlr.c vendor/source/igraph/vendor/lapack/ilaenv.c vendor/source/igraph/vendor/lapack/iparmq.c vendor/source/igraph/vendor/lapack/ivout.c vendor/source/igraph/vendor/lapack/len_trim.c vendor/source/igraph/vendor/lapack/lsame.c vendor/source/igraph/vendor/lapack/second.c vendor/source/igraph/vendor/lapack/stat.h vendor/source/igraph/vendor/lapack/xerbla.c vendor/source/igraph/vendor/mini-gmp/CMakeLists.txt vendor/source/igraph/vendor/mini-gmp/mini-gmp.c vendor/source/igraph/vendor/mini-gmp/mini-gmp.h vendor/source/igraph/vendor/plfit/CMakeLists.txt vendor/source/igraph/vendor/plfit/arithmetic_ansi.h vendor/source/igraph/vendor/plfit/arithmetic_sse_double.h vendor/source/igraph/vendor/plfit/arithmetic_sse_float.h vendor/source/igraph/vendor/plfit/gss.c vendor/source/igraph/vendor/plfit/gss.h vendor/source/igraph/vendor/plfit/hzeta.c vendor/source/igraph/vendor/plfit/hzeta.h vendor/source/igraph/vendor/plfit/kolmogorov.c vendor/source/igraph/vendor/plfit/kolmogorov.h vendor/source/igraph/vendor/plfit/lbfgs.c vendor/source/igraph/vendor/plfit/lbfgs.h vendor/source/igraph/vendor/plfit/mt.c vendor/source/igraph/vendor/plfit/options.c vendor/source/igraph/vendor/plfit/platform.c vendor/source/igraph/vendor/plfit/platform.h vendor/source/igraph/vendor/plfit/plfit.c vendor/source/igraph/vendor/plfit/plfit.h vendor/source/igraph/vendor/plfit/plfit_error.c vendor/source/igraph/vendor/plfit/plfit_error.h vendor/source/igraph/vendor/plfit/plfit_mt.h vendor/source/igraph/vendor/plfit/plfit_sampling.h vendor/source/igraph/vendor/plfit/plfit_version.h vendor/source/igraph/vendor/plfit/rbinom.c vendor/source/igraph/vendor/plfit/sampling.c././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/src/igraph.egg-info/dependency_links.txt0000644000175100001710000000000100000000000023404 0ustar00runnerdocker00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/src/igraph.egg-info/requires.txt0000644000175100001710000000033600000000000021740 0ustar00runnerdocker00000000000000texttable>=1.6.2 [doc] Sphinx>=4.2.0 sphinxbootstrap4theme>=0.6.0 [plotting] cairocffi>=1.2.0 [test] networkx>=2.5 pytest>=6.2.5 [test:platform_python_implementation != "PyPy"] numpy>=1.19.0 pandas>=1.1.0 scipy>=1.5.0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/src/igraph.egg-info/top_level.txt0000644000175100001710000000000700000000000022065 0ustar00runnerdocker00000000000000igraph ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4151394 igraph-0.9.9/tests/0000755000175100001710000000000000000000000014745 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/__init__.py0000644000175100001710000000000000000000000017044 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_atlas.py0000644000175100001710000001346300000000000017471 0ustar00runnerdocker00000000000000import warnings import unittest from igraph import * class AtlasTestBase: def testPageRank(self): for idx, g in enumerate(self.__class__.graphs): try: pr = g.pagerank() except Exception as ex: self.assertTrue( False, msg="PageRank calculation threw exception for graph #%d: %s" % (idx, ex), ) raise if g.vcount() == 0: self.assertEqual([], pr) continue self.assertAlmostEqual( 1.0, sum(pr), places=5, msg="PageRank sum is not 1.0 for graph #%d (%r)" % (idx, pr), ) self.assertTrue( min(pr) >= 0, msg="Minimum PageRank is less than 0 for graph #%d (%r)" % (idx, pr), ) def testEigenvectorCentrality(self): # Temporarily turn off the warning handler because g.evcent() will print # a warning for DAGs warnings.simplefilter("ignore") try: for idx, g in enumerate(self.__class__.graphs): try: ec, eval = g.evcent(return_eigenvalue=True) except Exception as ex: self.assertTrue( False, msg="Eigenvector centrality threw exception for graph #%d: %s" % (idx, ex), ) raise if g.vcount() == 0: self.assertEqual([], ec) continue if not g.is_connected(): # Skip disconnected graphs; this will be fixed in igraph 0.7 continue n = g.vcount() if abs(eval) < 1e-4: self.assertTrue( min(ec) >= -1e-10, msg="Minimum eigenvector centrality is smaller than 0 for graph #%d" % idx, ) self.assertTrue( max(ec) <= 1, msg="Maximum eigenvector centrality is greater than 1 for graph #%d" % idx, ) continue self.assertAlmostEqual( max(ec), 1, places=7, msg="Maximum eigenvector centrality is %r (not 1) for graph #%d (%r)" % (max(ec), idx, ec), ) self.assertTrue( min(ec) >= 0, msg="Minimum eigenvector centrality is less than 0 for graph #%d" % idx, ) ec2 = [sum(ec[u.index] for u in v.predecessors()) for v in g.vs] for i in range(n): self.assertAlmostEqual( ec[i] * eval, ec2[i], places=7, msg="Eigenvector centrality in graph #%d seems to be invalid " "for vertex %d" % (idx, i), ) finally: # Reset the warning handler warnings.resetwarnings() def testHubScore(self): for idx, g in enumerate(self.__class__.graphs): try: sc = g.hub_score() except Exception as ex: self.assertTrue( False, msg="Hub score calculation threw exception for graph #%d: %s" % (idx, ex), ) raise if g.vcount() == 0: self.assertEqual([], sc) continue self.assertAlmostEqual( max(sc), 1, places=7, msg="Maximum authority score is not 1 for graph #%d" % idx, ) self.assertTrue( min(sc) >= 0, msg="Minimum hub score is less than 0 for graph #%d" % idx ) def testAuthorityScore(self): for idx, g in enumerate(self.__class__.graphs): try: sc = g.authority_score() except Exception as ex: self.assertTrue( False, msg="Authority score calculation threw exception for graph #%d: %s" % (idx, ex), ) raise if g.vcount() == 0: self.assertEqual([], sc) continue self.assertAlmostEqual( max(sc), 1, places=7, msg="Maximum authority score is not 1 for graph #%d" % idx, ) self.assertTrue( min(sc) >= 0, msg="Minimum authority score is less than 0 for graph #%d" % idx, ) class GraphAtlasTests(unittest.TestCase, AtlasTestBase): graphs = [Graph.Atlas(i) for i in range(1253)] # Skip some problematic graphs GraphAtlasTests.graphs = [g for idx, g in enumerate(GraphAtlasTests.graphs) if idx not in set([70, 180])] print(len(GraphAtlasTests.graphs)) class IsoclassTests(unittest.TestCase, AtlasTestBase): graphs = [Graph.Isoclass(3, i, directed=True) for i in range(16)] + [ Graph.Isoclass(4, i, directed=True) for i in range(218) ] # Skip some problematic graphs IsoclassTests.graphs = [g for idx, g in enumerate(IsoclassTests.graphs) if idx not in set([136])] def suite(): atlas_suite = unittest.makeSuite(GraphAtlasTests) isoclass_suite = unittest.makeSuite(IsoclassTests) return unittest.TestSuite([atlas_suite, isoclass_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_attributes.py0000644000175100001710000002444700000000000020557 0ustar00runnerdocker00000000000000# vim:ts=4 sw=4 sts=4: import sys import unittest from igraph import Graph class AttributeTests(unittest.TestCase): def testGraphAttributes(self): g = Graph.Full(5) g["date"] = "2005-12-17" self.assertTrue(g["date"] == "2005-12-17") del g["date"] self.assertRaises(KeyError, g.__getitem__, "date") def testVertexAttributes(self): g = Graph.Full(5) g.vs[0]["name"] = "first" self.assertTrue(g.vs[0]["name"] == "first") del g.vs["name"] self.assertRaises(KeyError, g.vs.__getitem__, "name") g.vs[0]["name"] = "second" g.vs[0]["date"] = "2007-12-17" ans = g.vs[0].attribute_names() ans.sort() self.assertTrue(ans == ["date", "name"]) attrs = g.vs[0].attributes() self.assertTrue(attrs == {"name": "second", "date": "2007-12-17"}) def testEdgeAttributes(self): g = Graph.Full(5) g.es[0]["name"] = "first" self.assertTrue(g.es[0]["name"] == "first") del g.es["name"] self.assertRaises(KeyError, g.es.__getitem__, "name") g.es[0]["name"] = "second" g.es[0]["date"] = "2007-12-17" ans = g.es[0].attribute_names() ans.sort() self.assertTrue(ans == ["date", "name"]) attrs = g.es[0].attributes() self.assertTrue(attrs == {"name": "second", "date": "2007-12-17"}) def testMassVertexAttributeAssignment(self): g = Graph.Full(5) g.vs.set_attribute_values("name", list(range(5))) self.assertTrue(g.vs.get_attribute_values("name") == list(range(5))) g.vs["name"] = list(range(5, 10)) self.assertTrue(g.vs["name"] == list(range(5, 10))) g.vs["name2"] = (1, 2, 3, 4, 6) self.assertTrue(g.vs["name2"] == [1, 2, 3, 4, 6]) g.vs.set_attribute_values("name", [2]) self.assertTrue(g.vs["name"] == [2] * 5) def testMassEdgeAttributeAssignment(self): g = Graph.Full(5) g.es.set_attribute_values("name", list(range(10))) self.assertTrue(g.es.get_attribute_values("name") == list(range(10))) g.es["name"] = list(range(10, 20)) self.assertTrue(g.es["name"] == list(range(10, 20))) g.es["name2"] = (1, 2, 3, 4, 6, 1, 2, 3, 4, 6) self.assertTrue(g.es["name2"] == [1, 2, 3, 4, 6, 1, 2, 3, 4, 6]) g.es.set_attribute_values("name", [2]) self.assertTrue(g.es["name"] == [2] * 10) def testVertexNameIndexing(self): g = Graph.Famous("bull") g.vs["name"] = ["foo", "bar", "baz", "fred", "thud"] self.assertTrue(g.degree("bar") == 3) self.assertTrue(g.degree(["bar", "fred", 0]) == [3, 1, 2]) g.vs[2]["name"] = "quack" self.assertRaises(ValueError, g.degree, "baz") self.assertTrue(g.degree("quack") == 3) self.assertTrue(g.degree("quack") == 3) self.assertTrue(g.degree(["bar", "thud", 0]) == [3, 1, 2]) del g.vs["name"] self.assertRaises(ValueError, g.degree, ["bar", "thud", 0]) def testVertexNameIndexingBytes(self): g = Graph.Famous("bull") g.vs["name"] = [b"foo", b"bar", b"baz", b"fred", b"thud"] self.assertTrue(g.degree(b"bar") == 3) self.assertTrue(g.degree([b"bar", b"fred", 0]) == [3, 1, 2]) g.vs[2]["name"] = b"quack" self.assertRaises(ValueError, g.degree, b"baz") self.assertTrue(g.degree(b"quack") == 3) del g.vs["name"] self.assertRaises(ValueError, g.degree, [b"bar", b"thud", 0]) def testUnhashableVertexNames(self): g = Graph.Famous("bull") g.vs["name"] = [str(x) for x in range(4)] value = "this is not hashable".split() g.vs[2]["name"] = value # Trigger an indexing by doing a lookup by name try: g.vs.find("3") err = None except Exception as ex: err = ex # Check the exception self.assertTrue(isinstance(err, RuntimeError)) if sys.version_info >= (3, 4): self.assertTrue(repr(value) in str(err)) def testVertexNameIndexingBug196(self): g = Graph() a, b = b"a", b"b" g.add_vertices([a, b]) g.add_edges([(a, b)]) self.assertEqual(g.ecount(), 1) self.assertTrue(g.are_connected(a, b)) def testInvalidAttributeNames(self): g = Graph.Famous("bull") for attr_name in [None, 2.654, unittest, str]: self.assertRaises(TypeError, g.vs.__setitem__, attr_name, "foo") self.assertRaises(TypeError, g.vs.__getitem__, attr_name, "foo") self.assertRaises(TypeError, g.vs[0].__setitem__, attr_name, "foo") self.assertRaises(TypeError, g.vs[0].__getitem__, attr_name, "foo") self.assertRaises(TypeError, g.es.__setitem__, attr_name, "foo") self.assertRaises(TypeError, g.es.__getitem__, attr_name, "foo") self.assertRaises(TypeError, g.es[0].__setitem__, attr_name, "foo") self.assertRaises(TypeError, g.es[0].__getitem__, attr_name, "foo") class AttributeCombinationTests(unittest.TestCase): def setUp(self): el = [(0, 1), (1, 0), (1, 2), (2, 3), (2, 3), (2, 3), (3, 3)] self.g = Graph(el) self.g.es["weight"] = [1, 2, 3, 4, 5, 6, 7] self.g.es["weight2"] = [1, 2, 3, 4, 5, 6, 7] def testCombinationMax(self): g = self.g g.simplify(combine_edges="max") self.assertTrue(g.es["weight"] == [2, 3, 6]) self.assertTrue(g.es["weight2"] == [2, 3, 6]) def testCombinationMin(self): g = self.g g.simplify(combine_edges="min") self.assertTrue(g.es["weight"] == [1, 3, 4]) self.assertTrue(g.es["weight2"] == [1, 3, 4]) def testCombinationRandom(self): g = self.g g.simplify(combine_edges="random") del g.es["weight2"] for i in range(100): self.assertTrue(g.es[0]["weight"] in (1, 2)) self.assertTrue(g.es[1]["weight"] == 3) self.assertTrue(g.es[2]["weight"] in (4, 5, 6)) def testCombinationMean(self): g = self.g g.simplify(combine_edges="mean") self.assertTrue(g.es["weight"] == [1.5, 3, 5]) self.assertTrue(g.es["weight2"] == [1.5, 3, 5]) def testCombinationMedian(self): g = self.g g.es["weight2"] = [1, 0, 2, 4, 8, 6, 7] g.simplify(combine_edges="median") self.assertTrue(g.es["weight"] == [1.5, 3, 5]) self.assertTrue(g.es["weight2"] == [0.5, 2, 6]) def testCombinationSum(self): g = self.g g.simplify(combine_edges="sum") self.assertTrue(g.es["weight"] == [3, 3, 15]) self.assertTrue(g.es["weight2"] == [3, 3, 15]) def testCombinationProd(self): g = self.g g.simplify(combine_edges="prod") self.assertTrue(g.es["weight"] == [2, 3, 120]) self.assertTrue(g.es["weight2"] == [2, 3, 120]) def testCombinationFirst(self): g = self.g g.es["weight2"] = [1, 0, 2, 6, 8, 4, 7] g.simplify(combine_edges="first") self.assertTrue(g.es["weight"] == [1, 3, 4]) self.assertTrue(g.es["weight2"] == [1, 2, 6]) def testCombinationLast(self): g = self.g g.es["weight2"] = [1, 0, 2, 6, 8, 4, 7] g.simplify(combine_edges="last") self.assertTrue(g.es["weight"] == [2, 3, 6]) self.assertTrue(g.es["weight2"] == [0, 2, 4]) def testCombinationConcat(self): g = self.g g.es["name"] = list("ABCDEFG") g.simplify(combine_edges=dict(name="concat")) self.assertFalse("weight" in g.edge_attributes()) self.assertFalse("weight2" in g.edge_attributes()) self.assertTrue(g.es["name"] == ["AB", "C", "DEF"]) def testCombinationMaxMinIgnore(self): g = self.g g.es["name"] = list("ABCDEFG") g.simplify(combine_edges={"weight": "min", "weight2": "max", "name": "ignore"}) self.assertTrue(g.es["weight"] == [1, 3, 4]) self.assertTrue(g.es["weight2"] == [2, 3, 6]) self.assertFalse("name" in g.edge_attributes()) def testCombinationIgnoreAsNone(self): g = self.g g.es["name"] = list("ABCDEFG") g.simplify(combine_edges={"weight": "min", "name": None}) self.assertTrue(g.es["weight"] == [1, 3, 4]) self.assertFalse("weight2" in g.edge_attributes()) self.assertFalse("name" in g.edge_attributes()) def testCombinationFunction(self): g = self.g def join_dash(items): return "-".join(items) g.es["name"] = list("ABCDEFG") g.simplify(combine_edges={"weight": max, "name": join_dash}) self.assertTrue(g.es["weight"] == [2, 3, 6]) self.assertFalse("weight2" in g.edge_attributes()) self.assertTrue(g.es["name"] == ["A-B", "C", "D-E-F"]) def testCombinationDefault(self): g = self.g g.simplify(combine_edges={None: "max"}) self.assertTrue(g.es["weight"] == [2, 3, 6]) self.assertTrue(g.es["weight2"] == [2, 3, 6]) def testCombinationDefaultOverride(self): g = self.g g.simplify(combine_edges={None: "max", "weight": "sum"}) self.assertTrue(g.es["weight"] == [3, 3, 15]) self.assertTrue(g.es["weight2"] == [2, 3, 6]) def testCombinationTypeMismatch(self): g = self.g g.es["weight"] = list("ABCDEFG") self.assertRaises(TypeError, g.simplify, combine_edges={"weight": "mean"}) def testCombinationNonexistentAttribute(self): g = self.g g.simplify(combine_edges={"nonexistent": max}) self.assertTrue(g.edge_attributes() == []) def testCombinationNone(self): g = self.g g.simplify() self.assertTrue(sorted(g.edge_attributes()) == []) class UnicodeAttributeTests(unittest.TestCase): def testUnicodeAttributeNameCombination(self): g = Graph.Erdos_Renyi(n=9, m=20) g.es["test"] = 1 g.contract_vertices([0, 0, 0, 1, 1, 1, 2, 2, 2]) def suite(): attribute_suite = unittest.makeSuite(AttributeTests) attribute_combination_suite = unittest.makeSuite(AttributeCombinationTests) unicode_attributes_suite = unittest.makeSuite(UnicodeAttributeTests) return unittest.TestSuite( [attribute_suite, attribute_combination_suite, unicode_attributes_suite] ) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_basic.py0000644000175100001710000007241500000000000017450 0ustar00runnerdocker00000000000000import unittest import warnings from functools import partial from igraph import ( ALL, Graph, IN, InternalError, is_degree_sequence, is_graphical, is_graphical_degree_sequence, Matrix, ) try: import numpy as np except ImportError: np = None class BasicTests(unittest.TestCase): def testGraphCreation(self): g = Graph() self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 0 and g.ecount() == 0 and not g.is_directed()) g = Graph(3, [(0, 1), (1, 2), (2, 0)]) self.assertTrue( g.vcount() == 3 and g.ecount() == 3 and not g.is_directed() and g.is_simple() ) g = Graph(2, [(0, 1), (1, 2), (2, 3)], True) self.assertTrue( g.vcount() == 4 and g.ecount() == 3 and g.is_directed() and g.is_simple() ) g = Graph([(0, 1), (1, 2), (2, 1)]) self.assertTrue( g.vcount() == 3 and g.ecount() == 3 and not g.is_directed() and not g.is_simple() ) g = Graph(((0, 1), (0, 0), (1, 2))) self.assertTrue( g.vcount() == 3 and g.ecount() == 3 and not g.is_directed() and not g.is_simple() ) g = Graph(8, None) self.assertEqual(8, g.vcount()) self.assertEqual(0, g.ecount()) self.assertFalse(g.is_directed()) g = Graph(edges=None) self.assertEqual(0, g.vcount()) self.assertEqual(0, g.ecount()) self.assertFalse(g.is_directed()) self.assertRaises(TypeError, Graph, edgelist=[(1, 2)]) @unittest.skipIf(np is None, "test case depends on NumPy") def testGraphCreationWithNumPy(self): # NumPy array with integers arr = np.array([(0, 1), (1, 2), (2, 3)]) g = Graph(arr, directed=True) self.assertTrue( g.vcount() == 4 and g.ecount() == 3 and g.is_directed() and g.is_simple() ) # Sliced NumPy array -- the sliced array is non-contiguous but we # automatically make it so arr = np.array([(0, 1), (10, 11), (1, 2), (11, 12), (2, 3), (12, 13)]) g = Graph(arr[::2, :], directed=True) self.assertTrue( g.vcount() == 4 and g.ecount() == 3 and g.is_directed() and g.is_simple() ) # 1D NumPy array -- should raise a TypeError because we need a 2D array arr = np.array([0, 1, 1, 2, 2, 3]) self.assertRaises(TypeError, Graph, arr) # 3D NumPy array -- should raise a TypeError because we need a 2D array arr = np.array([([0, 1], [10, 11]), ([1, 2], [11, 12]), ([2, 3], [12, 13])]) self.assertRaises(TypeError, Graph, arr) # NumPy array with strings -- should be a casting error arr = np.array([("a", "b"), ("c", "d"), ("e", "f")]) self.assertRaises(ValueError, Graph, arr) def testAddVertex(self): g = Graph() vertex = g.add_vertex() self.assertTrue(g.vcount() == 1 and g.ecount() == 0) self.assertEqual(0, vertex.index) self.assertFalse("name" in g.vertex_attributes()) vertex = g.add_vertex("foo") self.assertTrue(g.vcount() == 2 and g.ecount() == 0) self.assertEqual(1, vertex.index) self.assertTrue("name" in g.vertex_attributes()) self.assertEqual(g.vs["name"], [None, "foo"]) vertex = g.add_vertex(3) self.assertTrue(g.vcount() == 3 and g.ecount() == 0) self.assertEqual(2, vertex.index) self.assertTrue("name" in g.vertex_attributes()) self.assertEqual(g.vs["name"], [None, "foo", 3]) vertex = g.add_vertex(name="bar") self.assertTrue(g.vcount() == 4 and g.ecount() == 0) self.assertEqual(3, vertex.index) self.assertTrue("name" in g.vertex_attributes()) self.assertEqual(g.vs["name"], [None, "foo", 3, "bar"]) vertex = g.add_vertex(name="frob", spam="cheese", ham=42) self.assertTrue(g.vcount() == 5 and g.ecount() == 0) self.assertEqual(4, vertex.index) self.assertEqual(sorted(g.vertex_attributes()), ["ham", "name", "spam"]) self.assertEqual(g.vs["spam"], [None] * 4 + ["cheese"]) self.assertEqual(g.vs["ham"], [None] * 4 + [42]) def testAddVertices(self): g = Graph() g.add_vertices(2) self.assertTrue(g.vcount() == 2 and g.ecount() == 0) g.add_vertices("spam") self.assertTrue(g.vcount() == 3 and g.ecount() == 0) self.assertEqual(g.vs[2]["name"], "spam") g.add_vertices(["bacon", "eggs"]) self.assertTrue(g.vcount() == 5 and g.ecount() == 0) self.assertEqual(g.vs[2:]["name"], ["spam", "bacon", "eggs"]) g.add_vertices(2, attributes={"color": ["k", "b"]}) self.assertEqual(g.vs[2:]["name"], ["spam", "bacon", "eggs", None, None]) self.assertEqual(g.vs[5:]["color"], ["k", "b"]) def testDeleteVertices(self): g = Graph([(0, 1), (1, 2), (2, 3), (0, 2), (3, 4), (4, 5)]) self.assertEqual(6, g.vcount()) self.assertEqual(6, g.ecount()) # Delete a single vertex g.delete_vertices(4) self.assertEqual(5, g.vcount()) self.assertEqual(4, g.ecount()) # Delete multiple vertices g.delete_vertices([1, 3]) self.assertEqual(3, g.vcount()) self.assertEqual(1, g.ecount()) # Delete a vertex sequence g.delete_vertices(g.vs[:2]) self.assertEqual(1, g.vcount()) self.assertEqual(0, g.ecount()) # Delete a single vertex object g.vs[0].delete() self.assertEqual(0, g.vcount()) self.assertEqual(0, g.ecount()) # Delete vertices by name g = Graph.Full(4) g.vs["name"] = ["spam", "bacon", "eggs", "ham"] self.assertEqual(4, g.vcount()) g.delete_vertices("spam") self.assertEqual(3, g.vcount()) g.delete_vertices(["bacon", "ham"]) self.assertEqual(1, g.vcount()) # Deleting a nonexistent vertex self.assertRaises(ValueError, g.delete_vertices, "no-such-vertex") self.assertRaises(InternalError, g.delete_vertices, 2) # Delete all vertices g.delete_vertices() self.assertEqual(0, g.vcount()) def testAddEdge(self): g = Graph() g.add_vertices(["spam", "bacon", "eggs", "ham"]) edge = g.add_edge(0, 1) self.assertEqual(g.vcount(), 4) self.assertEqual(g.get_edgelist(), [(0, 1)]) self.assertEqual(0, edge.index) self.assertEqual((0, 1), edge.tuple) edge = g.add_edge(1, 2, foo="bar") self.assertEqual(g.vcount(), 4) self.assertEqual(g.get_edgelist(), [(0, 1), (1, 2)]) self.assertEqual(1, edge.index) self.assertEqual((1, 2), edge.tuple) self.assertEqual("bar", edge["foo"]) self.assertEqual([None, "bar"], g.es["foo"]) def testAddEdges(self): g = Graph() g.add_vertices(["spam", "bacon", "eggs", "ham"]) g.add_edges([(0, 1)]) self.assertEqual(g.vcount(), 4) self.assertEqual(g.get_edgelist(), [(0, 1)]) g.add_edges([(1, 2), (2, 3), (1, 3)]) self.assertEqual(g.vcount(), 4) self.assertEqual(g.get_edgelist(), [(0, 1), (1, 2), (2, 3), (1, 3)]) g.add_edges([("spam", "eggs"), ("spam", "ham")]) self.assertEqual(g.vcount(), 4) self.assertEqual( g.get_edgelist(), [(0, 1), (1, 2), (2, 3), (1, 3), (0, 2), (0, 3)] ) g.add_edges([(0, 0), (1, 1)], attributes={"color": ["k", "b"]}) self.assertEqual( g.get_edgelist(), [ (0, 1), (1, 2), (2, 3), (1, 3), (0, 2), (0, 3), (0, 0), (1, 1), ], ) self.assertEqual(g.es["color"], [None, None, None, None, None, None, "k", "b"]) def testDeleteEdges(self): g = Graph.Famous("petersen") g.vs["name"] = list("ABCDEFGHIJ") el = g.get_edgelist() self.assertEqual(15, g.ecount()) # Deleting single edge g.delete_edges(14) el[14:] = [] self.assertEqual(14, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting multiple edges g.delete_edges([2, 5, 7]) el[7:8] = [] el[5:6] = [] el[2:3] = [] self.assertEqual(11, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting edge object g.es[6].delete() el[6:7] = [] self.assertEqual(10, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting edge sequence object g.es[1:4].delete() el[1:4] = [] self.assertEqual(7, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting edges by IDs g.delete_edges([(2, 7), (5, 8)]) el[4:5] = [] el[1:2] = [] self.assertEqual(5, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting edges by names g.delete_edges([("D", "I"), ("G", "I")]) el[3:4] = [] el[1:2] = [] self.assertEqual(3, g.ecount()) self.assertEqual(el, g.get_edgelist()) # Deleting nonexistent edges self.assertRaises(ValueError, g.delete_edges, [(0, 2)]) self.assertRaises(ValueError, g.delete_edges, [("A", "C")]) self.assertRaises(ValueError, g.delete_edges, [(0, 15)]) # Delete all edges g.delete_edges() self.assertEqual(0, g.ecount()) def testClear(self): g = Graph.Famous("petersen") g["name"] = list("petersen") # Clearing the graph g.clear() self.assertEqual(0, g.vcount()) self.assertEqual(0, g.ecount()) self.assertEqual([], g.attributes()) def testGraphGetEid(self): g = Graph.Famous("petersen") g.vs["name"] = list("ABCDEFGHIJ") edges_to_ids = dict((v, k) for k, v in enumerate(g.get_edgelist())) for (source, target), edge_id in list(edges_to_ids.items()): source_name, target_name = g.vs[(source, target)]["name"] self.assertEqual(edge_id, g.get_eid(source, target)) self.assertEqual(edge_id, g.get_eid(source_name, target_name)) self.assertRaises(InternalError, g.get_eid, 0, 11) self.assertRaises(ValueError, g.get_eid, "A", "K") def testGraphGetEids(self): g = Graph.Famous("petersen") eids = g.get_eids(pairs=[(0, 1), (0, 5), (1, 6), (4, 9), (8, 6)]) self.assertTrue(eids == [0, 2, 4, 9, 12]) eids = g.get_eids(path=[0, 1, 2, 3, 4]) self.assertTrue(eids == [0, 3, 5, 7]) eids = g.get_eids(pairs=[(7, 9), (9, 6)], path=[7, 9, 6]) self.assertTrue(eids == [14, 13, 14, 13]) self.assertRaises(InternalError, g.get_eids, pairs=[(0, 1), (0, 2)]) def testAdjacency(self): g = Graph(4, [(0, 1), (1, 2), (2, 0), (2, 3)], directed=True) self.assertTrue(g.neighbors(2) == [0, 1, 3]) self.assertTrue(g.predecessors(2) == [1]) self.assertTrue(g.successors(2) == [0, 3]) self.assertTrue(g.get_adjlist() == [[1], [2], [0, 3], []]) self.assertTrue(g.get_adjlist(IN) == [[2], [0], [1], [2]]) self.assertTrue(g.get_adjlist(ALL) == [[1, 2], [0, 2], [0, 1, 3], [2]]) def testEdgeIncidence(self): g = Graph(4, [(0, 1), (1, 2), (2, 0), (2, 3)], directed=True) self.assertTrue(g.incident(2) == [2, 3]) self.assertTrue(g.incident(2, IN) == [1]) self.assertTrue(g.incident(2, ALL) == [2, 1, 3]) self.assertTrue(g.get_inclist() == [[0], [1], [2, 3], []]) self.assertTrue(g.get_inclist(IN) == [[2], [0], [1], [3]]) self.assertTrue(g.get_inclist(ALL) == [[0, 2], [0, 1], [2, 1, 3], [3]]) def testMultiplesLoops(self): g = Graph.Tree(7, 2) # has_multiple self.assertFalse(g.has_multiple()) g.add_vertices(1) g.add_edges([(0, 1), (7, 7), (6, 6), (6, 6), (6, 6)]) # is_loop self.assertTrue( g.is_loop() == [False, False, False, False, False, False, False, True, True, True, True] ) self.assertTrue(g.is_loop(g.ecount() - 2)) self.assertTrue(g.is_loop(list(range(6, 8))) == [False, True]) # is_multiple self.assertTrue( g.is_multiple() == [ False, False, False, False, False, False, True, False, False, True, True, ] ) # has_multiple self.assertTrue(g.has_multiple()) # count_multiple self.assertTrue(g.count_multiple() == [2, 1, 1, 1, 1, 1, 2, 1, 3, 3, 3]) self.assertTrue(g.count_multiple(g.ecount() - 1) == 3) self.assertTrue(g.count_multiple(list(range(2, 5))) == [1, 1, 1]) # check if a mutual directed edge pair is reported as multiple g = Graph(2, [(0, 1), (1, 0)], directed=True) self.assertTrue(g.is_multiple() == [False, False]) def testPickling(self): import pickle g = Graph([(0, 1), (1, 2)]) g["data"] = "abcdef" g.vs["data"] = [3, 4, 5] g.es["data"] = ["A", "B"] g.custom_data = None pickled = pickle.dumps(g) g2 = pickle.loads(pickled) self.assertTrue(g["data"] == g2["data"]) self.assertTrue(g.vs["data"] == g2.vs["data"]) self.assertTrue(g.es["data"] == g2.es["data"]) self.assertTrue(g.vcount() == g2.vcount()) self.assertTrue(g.ecount() == g2.ecount()) self.assertTrue(g.is_directed() == g2.is_directed()) self.assertTrue(g2.custom_data == g.custom_data) def testHashing(self): g = Graph([(0, 1), (1, 2)]) self.assertRaises(TypeError, hash, g) def testIteration(self): g = Graph() self.assertRaises(TypeError, iter, g) class DatatypeTests(unittest.TestCase): def testMatrix(self): m = Matrix([[1, 2, 3], [4, 5], [6, 7, 8]]) self.assertTrue(m.shape == (3, 3)) # Reading data self.assertTrue(m.data == [[1, 2, 3], [4, 5, 0], [6, 7, 8]]) self.assertTrue(m[1, 1] == 5) self.assertTrue(m[0] == [1, 2, 3]) self.assertTrue(m[0, :] == [1, 2, 3]) self.assertTrue(m[:, 0] == [1, 4, 6]) self.assertTrue(m[2, 0:2] == [6, 7]) self.assertTrue(m[:, :].data == [[1, 2, 3], [4, 5, 0], [6, 7, 8]]) self.assertTrue(m[:, 1:3].data == [[2, 3], [5, 0], [7, 8]]) # Writing data m[1, 1] = 10 self.assertTrue(m[1, 1] == 10) m[1] = (6, 5, 4) self.assertTrue(m[1] == [6, 5, 4]) m[1:3] = [[4, 5, 6], (7, 8, 9)] self.assertTrue(m[1:3].data == [[4, 5, 6], [7, 8, 9]]) # Minimums and maximums self.assertTrue(m.min() == 1) self.assertTrue(m.max() == 9) self.assertTrue(m.min(0) == [1, 2, 3]) self.assertTrue(m.max(0) == [7, 8, 9]) self.assertTrue(m.min(1) == [1, 4, 7]) self.assertTrue(m.max(1) == [3, 6, 9]) # Special constructors m = Matrix.Fill(2, (3, 3)) self.assertTrue(m.min() == 2 and m.max() == 2 and m.shape == (3, 3)) m = Matrix.Zero(5, 4) self.assertTrue(m.min() == 0 and m.max() == 0 and m.shape == (5, 4)) m = Matrix.Identity(3) self.assertTrue(m.data == [[1, 0, 0], [0, 1, 0], [0, 0, 1]]) m = Matrix.Identity(3, 2) self.assertTrue(m.data == [[1, 0], [0, 1], [0, 0]]) # Conversion to string m = Matrix.Identity(3) self.assertTrue(str(m) == "[[1, 0, 0]\n [0, 1, 0]\n [0, 0, 1]]") self.assertTrue(repr(m) == "Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])") class GraphDictListTests(unittest.TestCase): def setUp(self): self.vertices = [ {"name": "Alice", "age": 48, "gender": "F"}, {"name": "Bob", "age": 33, "gender": "M"}, {"name": "Cecil", "age": 45, "gender": "F"}, {"name": "David", "age": 34, "gender": "M"}, ] self.edges = [ {"source": "Alice", "target": "Bob", "friendship": 4, "advice": 4}, {"source": "Cecil", "target": "Bob", "friendship": 5, "advice": 5}, {"source": "Cecil", "target": "Alice", "friendship": 5, "advice": 5}, {"source": "David", "target": "Alice", "friendship": 2, "advice": 4}, {"source": "David", "target": "Bob", "friendship": 1, "advice": 2}, ] def testGraphFromDictList(self): g = Graph.DictList(self.vertices, self.edges) self.checkIfOK(g, "name") g = Graph.DictList(self.vertices, self.edges, iterative=True) self.checkIfOK(g, "name") def testGraphFromDictIterator(self): g = Graph.DictList(iter(self.vertices), iter(self.edges)) self.checkIfOK(g, "name") g = Graph.DictList(iter(self.vertices), iter(self.edges), iterative=True) self.checkIfOK(g, "name") def testGraphFromDictIteratorNoVertices(self): g = Graph.DictList(None, iter(self.edges)) self.checkIfOK(g, "name", check_vertex_attrs=False) g = Graph.DictList(None, iter(self.edges), iterative=True) self.checkIfOK(g, "name", check_vertex_attrs=False) def testGraphFromDictListExtraVertexName(self): del self.vertices[2:] # No data for "Cecil" and "David" g = Graph.DictList(self.vertices, self.edges) self.assertTrue(g.vcount() == 4 and g.ecount() == 5 and not g.is_directed()) self.assertTrue(g.vs["name"] == ["Alice", "Bob", "Cecil", "David"]) self.assertTrue(g.vs["age"] == [48, 33, None, None]) self.assertTrue(g.vs["gender"] == ["F", "M", None, None]) self.assertTrue(g.es["friendship"] == [4, 5, 5, 2, 1]) self.assertTrue(g.es["advice"] == [4, 5, 5, 4, 2]) self.assertTrue(g.get_edgelist() == [(0, 1), (1, 2), (0, 2), (0, 3), (1, 3)]) def testGraphFromDictListAlternativeName(self): for vdata in self.vertices: vdata["name_alternative"] = vdata["name"] del vdata["name"] g = Graph.DictList( self.vertices, self.edges, vertex_name_attr="name_alternative" ) self.checkIfOK(g, "name_alternative") g = Graph.DictList( self.vertices, self.edges, vertex_name_attr="name_alternative", iterative=True, ) self.checkIfOK(g, "name_alternative") def checkIfOK(self, g, name_attr, check_vertex_attrs=True): self.assertTrue(g.vcount() == 4 and g.ecount() == 5 and not g.is_directed()) self.assertTrue(g.get_edgelist() == [(0, 1), (1, 2), (0, 2), (0, 3), (1, 3)]) self.assertTrue(g.vs[name_attr] == ["Alice", "Bob", "Cecil", "David"]) if check_vertex_attrs: self.assertTrue(g.vs["age"] == [48, 33, 45, 34]) self.assertTrue(g.vs["gender"] == ["F", "M", "F", "M"]) self.assertTrue(g.es["friendship"] == [4, 5, 5, 2, 1]) self.assertTrue(g.es["advice"] == [4, 5, 5, 4, 2]) class GraphTupleListTests(unittest.TestCase): def setUp(self): self.edges = [ ("Alice", "Bob", 4, 4), ("Cecil", "Bob", 5, 5), ("Cecil", "Alice", 5, 5), ("David", "Alice", 2, 4), ("David", "Bob", 1, 2), ] def testGraphFromTupleList(self): g = Graph.TupleList(self.edges) self.checkIfOK(g, "name", ()) def testGraphFromTupleListWithEdgeAttributes(self): g = Graph.TupleList(self.edges, edge_attrs=("friendship", "advice")) self.checkIfOK(g, "name", ("friendship", "advice")) g = Graph.TupleList(self.edges, edge_attrs=("friendship",)) self.checkIfOK(g, "name", ("friendship",)) g = Graph.TupleList(self.edges, edge_attrs="friendship") self.checkIfOK(g, "name", ("friendship",)) def testGraphFromTupleListWithDifferentNameAttribute(self): g = Graph.TupleList(self.edges, vertex_name_attr="spam") self.checkIfOK(g, "spam", ()) def testGraphFromTupleListWithWeights(self): g = Graph.TupleList(self.edges, weights=True) self.checkIfOK(g, "name", ("weight",)) g = Graph.TupleList(self.edges, weights="friendship") self.checkIfOK(g, "name", ("friendship",)) g = Graph.TupleList(self.edges, weights=False) self.checkIfOK(g, "name", ()) self.assertRaises( ValueError, Graph.TupleList, [self.edges], weights=True, edge_attrs="friendship", ) def testNoneForMissingAttributes(self): g = Graph.TupleList(self.edges, edge_attrs=("friendship", "advice", "spam")) self.checkIfOK(g, "name", ("friendship", "advice", "spam")) def checkIfOK(self, g, name_attr, edge_attrs): self.assertTrue(g.vcount() == 4 and g.ecount() == 5 and not g.is_directed()) self.assertTrue(g.get_edgelist() == [(0, 1), (1, 2), (0, 2), (0, 3), (1, 3)]) self.assertTrue(g.attributes() == []) self.assertTrue(g.vertex_attributes() == [name_attr]) self.assertTrue(g.vs[name_attr] == ["Alice", "Bob", "Cecil", "David"]) if edge_attrs: self.assertTrue(sorted(g.edge_attributes()) == sorted(edge_attrs)) self.assertTrue(g.es[edge_attrs[0]] == [4, 5, 5, 2, 1]) if len(edge_attrs) > 1: self.assertTrue(g.es[edge_attrs[1]] == [4, 5, 5, 4, 2]) if len(edge_attrs) > 2: self.assertTrue(g.es[edge_attrs[2]] == [None] * 5) else: self.assertTrue(g.edge_attributes() == []) class DegreeSequenceTests(unittest.TestCase): def testIsDegreeSequence(self): # Catch and suppress warnings because is_degree_sequence() is now # deprecated with warnings.catch_warnings(): warnings.simplefilter("ignore") self.assertTrue(is_degree_sequence([])) self.assertTrue(is_degree_sequence([], [])) self.assertTrue(is_degree_sequence([0])) self.assertTrue(is_degree_sequence([0], [0])) self.assertFalse(is_degree_sequence([1])) self.assertTrue(is_degree_sequence([1], [1])) self.assertTrue(is_degree_sequence([2])) self.assertFalse(is_degree_sequence([2, 1, 1, 1])) self.assertTrue(is_degree_sequence([2, 1, 1, 1], [1, 1, 1, 2])) self.assertFalse(is_degree_sequence([2, 1, -2])) self.assertFalse(is_degree_sequence([2, 1, 1, 1], [1, 1, 1, -2])) self.assertTrue(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3])) self.assertTrue(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3], None)) self.assertFalse(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3])) self.assertTrue( is_degree_sequence( [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [4, 3, 2, 3, 4, 4, 2, 2, 4, 2] ) ) def testIsGraphicalSequence(self): # Catch and suppress warnings because is_graphical_degree_sequence() is now # deprecated with warnings.catch_warnings(): warnings.simplefilter("ignore") self.assertTrue(is_graphical_degree_sequence([])) self.assertTrue(is_graphical_degree_sequence([], [])) self.assertTrue(is_graphical_degree_sequence([0])) self.assertTrue(is_graphical_degree_sequence([0], [0])) self.assertFalse(is_graphical_degree_sequence([1])) self.assertFalse(is_graphical_degree_sequence([1], [1])) self.assertFalse(is_graphical_degree_sequence([2])) self.assertFalse(is_graphical_degree_sequence([2, 1, 1, 1])) self.assertTrue(is_graphical_degree_sequence([2, 1, 1, 1], [1, 1, 1, 2])) self.assertFalse(is_graphical_degree_sequence([2, 1, -2])) self.assertFalse(is_graphical_degree_sequence([2, 1, 1, 1], [1, 1, 1, -2])) self.assertTrue( is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3]) ) self.assertTrue( is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3], None) ) self.assertFalse( is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]) ) self.assertTrue( is_graphical_degree_sequence( [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [4, 3, 2, 3, 4, 4, 2, 2, 4, 2] ) ) self.assertTrue(is_graphical_degree_sequence([3, 3, 3, 3, 4])) def testIsGraphicalNonSimple(self): # Same as testIsDegreeSequence, but using is_graphical() is_degree_sequence = partial(is_graphical, loops=True, multiple=True) self.assertTrue(is_degree_sequence([])) self.assertTrue(is_degree_sequence([], [])) self.assertTrue(is_degree_sequence([0])) self.assertTrue(is_degree_sequence([0], [0])) self.assertFalse(is_degree_sequence([1])) self.assertTrue(is_degree_sequence([1], [1])) self.assertTrue(is_degree_sequence([2])) self.assertFalse(is_degree_sequence([2, 1, 1, 1])) self.assertTrue(is_degree_sequence([2, 1, 1, 1], [1, 1, 1, 2])) self.assertFalse(is_degree_sequence([2, 1, -2])) self.assertFalse(is_degree_sequence([2, 1, 1, 1], [1, 1, 1, -2])) self.assertTrue(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3])) self.assertTrue(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3], None)) self.assertFalse(is_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3])) self.assertTrue( is_degree_sequence( [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [4, 3, 2, 3, 4, 4, 2, 2, 4, 2] ) ) def testIsGraphicalSimple(self): # Same as testIsGraphicalDegreeSequence, but using is_graphical() is_graphical_degree_sequence = partial( is_graphical, loops=False, multiple=False ) self.assertTrue(is_graphical_degree_sequence([])) self.assertTrue(is_graphical_degree_sequence([], [])) self.assertTrue(is_graphical_degree_sequence([0])) self.assertTrue(is_graphical_degree_sequence([0], [0])) self.assertFalse(is_graphical_degree_sequence([1])) self.assertFalse(is_graphical_degree_sequence([1], [1])) self.assertFalse(is_graphical_degree_sequence([2])) self.assertFalse(is_graphical_degree_sequence([2, 1, 1, 1])) self.assertTrue(is_graphical_degree_sequence([2, 1, 1, 1], [1, 1, 1, 2])) self.assertFalse(is_graphical_degree_sequence([2, 1, -2])) self.assertFalse(is_graphical_degree_sequence([2, 1, 1, 1], [1, 1, 1, -2])) self.assertTrue(is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3])) self.assertTrue( is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3], None) ) self.assertFalse( is_graphical_degree_sequence([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]) ) self.assertTrue( is_graphical_degree_sequence( [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [4, 3, 2, 3, 4, 4, 2, 2, 4, 2] ) ) self.assertTrue(is_graphical_degree_sequence([3, 3, 3, 3, 4])) class InheritedGraph(Graph): def __init__(self, *args, **kwds): super().__init__(*args, **kwds) self.init_called = True def __new__(cls, *args, **kwds): result = Graph.__new__(cls, *args, **kwds) result.new_called = True return result @classmethod def Adjacency(cls, *args, **kwds): result = super().Adjacency(*args, **kwds) result.adjacency_called = True return result class InheritanceTests(unittest.TestCase): def testInitCalledProperly(self): g = InheritedGraph() self.assertTrue(isinstance(g, InheritedGraph)) self.assertTrue(getattr(g, "init_called", False)) def testNewCalledProperly(self): g = InheritedGraph() self.assertTrue(isinstance(g, InheritedGraph)) self.assertTrue(getattr(g, "new_called", False)) def testInitCalledProperlyWithClassMethod(self): g = InheritedGraph.Tree(3, 2) self.assertTrue(isinstance(g, InheritedGraph)) self.assertTrue(getattr(g, "init_called", False)) def testNewCalledProperlyWithClassMethod(self): g = InheritedGraph.Tree(3, 2) self.assertTrue(isinstance(g, InheritedGraph)) self.assertTrue(getattr(g, "new_called", False)) def testCallingClassMethodInSuperclass(self): g = InheritedGraph.Adjacency([[0, 1, 1], [1, 0, 0], [1, 0, 0]]) self.assertTrue(isinstance(g, InheritedGraph)) self.assertTrue(getattr(g, "adjacency_called", True)) def suite(): basic_suite = unittest.makeSuite(BasicTests) datatype_suite = unittest.makeSuite(DatatypeTests) graph_dict_list_suite = unittest.makeSuite(GraphDictListTests) graph_tuple_list_suite = unittest.makeSuite(GraphTupleListTests) degree_sequence_suite = unittest.makeSuite(DegreeSequenceTests) inheritance_suite = unittest.makeSuite(InheritanceTests) return unittest.TestSuite( [ basic_suite, datatype_suite, graph_dict_list_suite, graph_tuple_list_suite, degree_sequence_suite, inheritance_suite, ] ) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_bipartite.py0000644000175100001710000002341400000000000020345 0ustar00runnerdocker00000000000000import unittest from igraph import * class BipartiteTests(unittest.TestCase): def testCreateBipartite(self): g = Graph.Bipartite([0, 1] * 5, [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]) self.assertTrue( g.vcount() == 10 and g.ecount() == 5 and g.is_directed() is False ) self.assertTrue(g.is_bipartite()) self.assertTrue(g.vs["type"] == [False, True] * 5) def testFullBipartite(self): g = Graph.Full_Bipartite(10, 5) self.assertTrue( g.vcount() == 15 and g.ecount() == 50 and g.is_directed() is False ) expected = sorted([(i, j) for i in range(10) for j in range(10, 15)]) self.assertTrue(sorted(g.get_edgelist()) == expected) self.assertTrue(g.vs["type"] == [False] * 10 + [True] * 5) g = Graph.Full_Bipartite(10, 5, directed=True, mode=OUT) self.assertTrue( g.vcount() == 15 and g.ecount() == 50 and g.is_directed() is True ) self.assertTrue(sorted(g.get_edgelist()) == expected) self.assertTrue(g.vs["type"] == [False] * 10 + [True] * 5) g = Graph.Full_Bipartite(10, 5, directed=True, mode=IN) self.assertTrue( g.vcount() == 15 and g.ecount() == 50 and g.is_directed() is True ) self.assertTrue( sorted(g.get_edgelist()) == sorted([(i, j) for j, i in expected]) ) self.assertTrue(g.vs["type"] == [False] * 10 + [True] * 5) g = Graph.Full_Bipartite(10, 5, directed=True) self.assertTrue( g.vcount() == 15 and g.ecount() == 100 and g.is_directed() is True ) expected.extend([(j, i) for i, j in expected]) expected.sort() self.assertTrue(sorted(g.get_edgelist()) == expected) self.assertTrue(g.vs["type"] == [False] * 10 + [True] * 5) def testIncidence(self): g = Graph.Incidence([[0, 1, 1], [1, 2, 0]]) self.assertTrue(all((g.vcount() == 5, g.ecount() == 4, not g.is_directed()))) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], multiple=True) self.assertTrue(all((g.vcount() == 5, g.ecount() == 5, not g.is_directed()))) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual( sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3), (1, 3)] ) g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], directed=True) self.assertTrue(all((g.vcount() == 5, g.ecount() == 4, g.is_directed()))) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], directed=True, mode="in") self.assertTrue(all((g.vcount() == 5, g.ecount() == 4, g.is_directed()))) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(sorted(g.get_edgelist()), [(2, 1), (3, 0), (3, 1), (4, 0)]) # Create a weighted Graph g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], weighted=True) self.assertTrue( all( (g.vcount() == 5, g.ecount() == 4, not g.is_directed(), g.is_weighted()) ) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es["weight"], [1, 1, 1, 2]) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) # Graph is not weighted when weighted=`str` g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], weighted="some_attr_name") self.assertTrue( all( ( g.vcount() == 5, g.ecount() == 4, not g.is_directed(), not g.is_weighted(), ) ) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es["some_attr_name"], [1, 1, 1, 2]) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) # Graph is not weighted when weighted="" g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], weighted="") self.assertTrue( all( ( g.vcount() == 5, g.ecount() == 4, not g.is_directed(), not g.is_weighted(), ) ) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es[""], [1, 1, 1, 2]) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) # Should work when directed=True and mode=out with weighted g = Graph.Incidence([[0, 1, 1], [1, 2, 0]], directed=True, weighted=True) self.assertTrue( all((g.vcount() == 5, g.ecount() == 4, g.is_directed(), g.is_weighted())) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es["weight"], [1, 1, 1, 2]) self.assertListEqual(sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3)]) # Should work when directed=True and mode=in with weighted g = Graph.Incidence( [[0, 1, 1], [1, 2, 0]], directed=True, mode="in", weighted=True ) self.assertTrue( all((g.vcount() == 5, g.ecount() == 4, g.is_directed(), g.is_weighted())) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es["weight"], [1, 1, 1, 2]) self.assertListEqual(sorted(g.get_edgelist()), [(2, 1), (3, 0), (3, 1), (4, 0)]) # Should work when directed=True and mode=all with weighted g = Graph.Incidence( [[0, 1, 1], [1, 2, 0]], directed=True, mode="all", weighted=True ) self.assertTrue( all((g.vcount() == 5, g.ecount() == 8, g.is_directed(), g.is_weighted())) ) self.assertListEqual(g.vs["type"], [False] * 2 + [True] * 3) self.assertListEqual(g.es["weight"], [1, 1, 1, 1, 1, 1, 2, 2]) self.assertListEqual( sorted(g.get_edgelist()), [(0, 3), (0, 4), (1, 2), (1, 3), (2, 1), (3, 0), (3, 1), (4, 0)], ) def testIncidenceError(self): msg = "arguments weighted and multiple can not co-exist" with self.assertRaises(ValueError) as e: Graph.Incidence([[0, 1, 1], [1, 2, 0]], multiple=True, weighted=True) self.assertIn(msg, e.exception.args) with self.assertRaises(ValueError) as e: Graph.Incidence([[0, 1, 1], [1, 2, 0]], multiple=True, weighted="string") self.assertIn(msg, e.exception.args) with self.assertRaises(ValueError) as e: Graph.Incidence([[0, 1, 1], [1, 2, 0]], multiple=True, weighted="") self.assertIn(msg, e.exception.args) def testGetIncidence(self): mat = [[0, 1, 1], [1, 1, 0]] v1, v2 = [0, 1], [2, 3, 4] g = Graph.Incidence(mat) self.assertTrue(g.get_incidence() == (mat, v1, v2)) g.vs["type2"] = g.vs["type"] self.assertTrue(g.get_incidence("type2") == (mat, v1, v2)) self.assertTrue(g.get_incidence(g.vs["type2"]) == (mat, v1, v2)) def testBipartiteProjection(self): g = Graph.Full_Bipartite(10, 5) g1, g2 = g.bipartite_projection() self.assertTrue(g1.isomorphic(Graph.Full(10))) self.assertTrue(g2.isomorphic(Graph.Full(5))) self.assertTrue(g.bipartite_projection(which=0).isomorphic(g1)) self.assertTrue(g.bipartite_projection(which=1).isomorphic(g2)) self.assertTrue(g.bipartite_projection(which=False).isomorphic(g1)) self.assertTrue(g.bipartite_projection(which=True).isomorphic(g2)) self.assertTrue(g1.es["weight"] == [5] * 45) self.assertTrue(g2.es["weight"] == [10] * 10) self.assertTrue(g.bipartite_projection_size() == (10, 45, 5, 10)) g1, g2 = g.bipartite_projection(probe1=10) self.assertTrue(g1.isomorphic(Graph.Full(5))) self.assertTrue(g2.isomorphic(Graph.Full(10))) self.assertTrue(g.bipartite_projection(which=0).isomorphic(g2)) self.assertTrue(g.bipartite_projection(which=1).isomorphic(g1)) self.assertTrue(g.bipartite_projection(which=False).isomorphic(g2)) self.assertTrue(g.bipartite_projection(which=True).isomorphic(g1)) g1, g2 = g.bipartite_projection(multiplicity=False) self.assertTrue(g1.isomorphic(Graph.Full(10))) self.assertTrue(g2.isomorphic(Graph.Full(5))) self.assertTrue(g.bipartite_projection(which=0).isomorphic(g1)) self.assertTrue(g.bipartite_projection(which=1).isomorphic(g2)) self.assertTrue(g.bipartite_projection(which=False).isomorphic(g1)) self.assertTrue(g.bipartite_projection(which=True).isomorphic(g2)) self.assertTrue("weight" not in g1.edge_attributes()) self.assertTrue("weight" not in g2.edge_attributes()) def testIsBipartite(self): g = Graph.Star(10) self.assertTrue(g.is_bipartite() is True) self.assertTrue(g.is_bipartite(True) == (True, [False] + [True] * 9)) g = Graph.Tree(100, 3) self.assertTrue(g.is_bipartite() is True) g = Graph.Ring(9) self.assertTrue(g.is_bipartite() is False) self.assertTrue(g.is_bipartite(True) == (False, None)) g = Graph.Ring(10) self.assertTrue(g.is_bipartite() is True) g += (2, 0) self.assertTrue(g.is_bipartite(True) == (False, None)) def suite(): bipartite_suite = unittest.makeSuite(BipartiteTests) return unittest.TestSuite([bipartite_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_cliques.py0000644000175100001710000002142400000000000020026 0ustar00runnerdocker00000000000000import unittest from igraph import * from .utils import temporary_file class CliqueTests(unittest.TestCase): def setUp(self): self.g = Graph.Full(6) self.g.delete_edges([(0, 1), (0, 2), (3, 5)]) def testCliques(self): tests = { (4, -1): [[1, 2, 3, 4], [1, 2, 4, 5]], (2, 2): [ [0, 3], [0, 4], [0, 5], [1, 2], [1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [3, 4], [4, 5], ], (-1, -1): [ [0], [1], [2], [3], [4], [5], [0, 3], [0, 4], [0, 5], [1, 2], [1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [3, 4], [4, 5], [0, 3, 4], [0, 4, 5], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 4, 5], [2, 3, 4], [2, 4, 5], [1, 2, 3, 4], [1, 2, 4, 5], ], } for (lo, hi), exp in list(tests.items()): self.assertEqual(sorted(exp), sorted(map(sorted, self.g.cliques(lo, hi)))) def testLargestCliques(self): self.assertEqual( sorted(map(sorted, self.g.largest_cliques())), [[1, 2, 3, 4], [1, 2, 4, 5]] ) def testMaximalCliques(self): self.assertEqual( sorted(map(sorted, self.g.maximal_cliques())), [[0, 3, 4], [0, 4, 5], [1, 2, 3, 4], [1, 2, 4, 5]], ) self.assertEqual( sorted(map(sorted, self.g.maximal_cliques(min=4))), [[1, 2, 3, 4], [1, 2, 4, 5]], ) self.assertEqual( sorted(map(sorted, self.g.maximal_cliques(max=3))), [[0, 3, 4], [0, 4, 5]] ) def testMaximalCliquesFile(self): def read_cliques(fname): with open(fname) as fp: return sorted(sorted(int(item) for item in line.split()) for line in fp) with temporary_file() as fname: self.g.maximal_cliques(file=fname) self.assertEqual( [[0, 3, 4], [0, 4, 5], [1, 2, 3, 4], [1, 2, 4, 5]], read_cliques(fname) ) with temporary_file() as fname: self.g.maximal_cliques(min=4, file=fname) self.assertEqual([[1, 2, 3, 4], [1, 2, 4, 5]], read_cliques(fname)) with temporary_file() as fname: self.g.maximal_cliques(max=3, file=fname) self.assertEqual([[0, 3, 4], [0, 4, 5]], read_cliques(fname)) def testCliqueNumber(self): self.assertEqual(self.g.clique_number(), 4) self.assertEqual(self.g.omega(), 4) class IndependentVertexSetTests(unittest.TestCase): def setUp(self): self.g1 = Graph.Tree(5, 2, TREE_UNDIRECTED) self.g2 = Graph.Tree(10, 2, TREE_UNDIRECTED) def testIndependentVertexSets(self): tests = { (4, -1): [], (2, 2): [(0, 3), (0, 4), (1, 2), (2, 3), (2, 4), (3, 4)], (-1, -1): [ (0,), (1,), (2,), (3,), (4,), (0, 3), (0, 4), (1, 2), (2, 3), (2, 4), (3, 4), (0, 3, 4), (2, 3, 4), ], } for (lo, hi), exp in list(tests.items()): self.assertEqual(exp, self.g1.independent_vertex_sets(lo, hi)) def testLargestIndependentVertexSets(self): self.assertEqual( self.g1.largest_independent_vertex_sets(), [(0, 3, 4), (2, 3, 4)] ) def testMaximalIndependentVertexSets(self): self.assertEqual( self.g2.maximal_independent_vertex_sets(), [ (0, 3, 4, 5, 6), (0, 3, 5, 6, 9), (0, 4, 5, 6, 7, 8), (0, 5, 6, 7, 8, 9), (1, 2, 7, 8, 9), (1, 5, 6, 7, 8, 9), (2, 3, 4), (2, 3, 9), (2, 4, 7, 8), ], ) def testIndependenceNumber(self): self.assertEqual(self.g2.independence_number(), 6) self.assertEqual(self.g2.alpha(), 6) class MotifTests(unittest.TestCase): def setUp(self): self.g = Graph.Erdos_Renyi(100, 0.2, directed=True) def testDyads(self): # @note: this test is not exhaustive, it only checks whether the # L{DyadCensus} objects "understand" attribute and item accessors dc = self.g.dyad_census() accessors = ["mut", "mutual", "asym", "asymm", "asymmetric", "null"] for a in accessors: self.assertTrue(isinstance(getattr(dc, a), int)) self.assertTrue(isinstance(dc[a], int)) self.assertTrue(isinstance(list(dc), list)) self.assertTrue(isinstance(tuple(dc), tuple)) self.assertTrue(len(list(dc)) == 3) self.assertTrue(len(tuple(dc)) == 3) def testTriads(self): # @note: this test is not exhaustive, it only checks whether the # L{TriadCensus} objects "understand" attribute and item accessors tc = self.g.triad_census() accessors = ["003", "012", "021d", "030C"] for a in accessors: self.assertTrue(isinstance(getattr(tc, "t" + a), int)) self.assertTrue(isinstance(tc[a], int)) self.assertTrue(isinstance(list(tc), list)) self.assertTrue(isinstance(tuple(tc), tuple)) self.assertTrue(len(list(tc)) == 16) self.assertTrue(len(tuple(tc)) == 16) class CliqueBenchmark: """This is a benchmark, not a real test case. You can run it using: >>> from igraph.test.cliques import CliqueBenchmark >>> CliqueBenchmark().run() """ def __init__(self): from time import time import gc self.time = time self.gc_collect = gc.collect def run(self): self.printIntro() self.testRandom() self.testMoonMoser() self.testGRG() def printIntro(self): print("n = number of vertices") print("#cliques = number of maximal cliques found") print("t1 = time required to determine the clique number") print("t2 = time required to determine and save all maximal cliques") print() def timeit(self, g): start = self.time() omega = g.clique_number() mid = self.time() cl = g.maximal_cliques() end = self.time() self.gc_collect() return len(cl), mid - start, end - mid def testRandom(self): np = { 100: [0.6, 0.7], 300: [0.1, 0.2, 0.3, 0.4], 500: [0.1, 0.2, 0.3], 700: [0.1, 0.2], 1000: [0.1, 0.2], 10000: [0.001, 0.003, 0.005, 0.01, 0.02], } print() print("Erdos-Renyi random graphs") print(" n p #cliques t1 t2") for n in sorted(np.keys()): for p in np[n]: g = Graph.Erdos_Renyi(n, p) result = self.timeit(g) print("%8d %8.3f %8d %8.4fs %8.4fs" % tuple([n, p] + list(result))) def testMoonMoser(self): ns = [15, 27, 33] print() print("Moon-Moser graphs") print(" n exp_clqs #cliques t1 t2") for n in ns: n3 = n / 3 types = list(range(n3)) * 3 el = [ (i, j) for i in range(n) for j in range(i + 1, n) if types[i] != types[j] ] g = Graph(n, el) result = self.timeit(g) print( "%8d %8d %8d %8.4fs %8.4fs" % tuple([n, (3 ** (n / 3))] + list(result)) ) def testGRG(self): ns = [100, 1000, 5000, 10000, 25000, 50000] print() print("Geometric random graphs") print(" n d #cliques t1 t2") for n in ns: d = 2.0 / (n ** 0.5) g = Graph.GRG(n, d) result = self.timeit(g) print("%8d %8.3f %8d %8.4fs %8.4fs" % tuple([n, d] + list(result))) def suite(): clique_suite = unittest.makeSuite(CliqueTests) indvset_suite = unittest.makeSuite(IndependentVertexSetTests) motif_suite = unittest.makeSuite(MotifTests) return unittest.TestSuite([clique_suite, indvset_suite, motif_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_colortests.py0000644000175100001710000000744100000000000020565 0ustar00runnerdocker00000000000000import unittest from igraph import * class ColorTests(unittest.TestCase): def assertAlmostEqualMany(self, items1, items2, eps): for idx, (item1, item2) in enumerate(zip(items1, items2)): self.assertAlmostEqual( item1, item2, places=eps, msg="mismatch at index %d, %r != %r with %d digits" % (idx, items1, items2, eps), ) def setUp(self): columns = ["r", "g", "b", "h", "v", "l", "s_hsv", "s_hsl", "alpha"] # Examples taken from http://en.wikipedia.org/wiki/HSL_and_HSV values = [ (1, 1, 1, 0, 1, 1, 0, 0, 1), (0.5, 0.5, 0.5, 0, 0.5, 0.5, 0, 0, 0.5), (0, 0, 0, 0, 0, 0, 0, 0, 1), (1, 0, 0, 0, 1, 0.5, 1, 1, 0.5), (0.75, 0.75, 0, 60, 0.75, 0.375, 1, 1, 0.25), (0, 0.5, 0, 120, 0.5, 0.25, 1, 1, 0.75), (0.5, 1, 1, 180, 1, 0.75, 0.5, 1, 1), (0.5, 0.5, 1, 240, 1, 0.75, 0.5, 1, 1), (0.75, 0.25, 0.75, 300, 0.75, 0.5, 0.666666667, 0.5, 0.25), (0.211, 0.149, 0.597, 248.3, 0.597, 0.373, 0.750, 0.601, 1), (0.495, 0.493, 0.721, 240.5, 0.721, 0.607, 0.316, 0.290, 0.75), ] self.data = [dict(list(zip(columns, value))) for value in values] for row in self.data: row["h"] /= 360.0 def _testGeneric(self, method, args1, args2=("r", "g", "b")): if len(args1) == len(args2) + 1: args2 += ("alpha",) for data in self.data: vals1 = [data.get(arg, 0.0) for arg in args1] vals2 = [data.get(arg, 0.0) for arg in args2] self.assertAlmostEqualMany(method(*vals1), vals2, 2) def testHSVtoRGB(self): self._testGeneric(hsv_to_rgb, "h s_hsv v".split()) def testHSVAtoRGBA(self): self._testGeneric(hsva_to_rgba, "h s_hsv v alpha".split()) def testHSLtoRGB(self): self._testGeneric(hsl_to_rgb, "h s_hsl l".split()) def testHSLAtoRGBA(self): self._testGeneric(hsla_to_rgba, "h s_hsl l alpha".split()) def testRGBtoHSL(self): self._testGeneric(rgb_to_hsl, "r g b".split(), "h s_hsl l".split()) def testRGBAtoHSLA(self): self._testGeneric( rgba_to_hsla, "r g b alpha".split(), "h s_hsl l alpha".split() ) def testRGBtoHSV(self): self._testGeneric(rgb_to_hsv, "r g b".split(), "h s_hsv v".split()) def testRGBAtoHSVA(self): self._testGeneric( rgba_to_hsva, "r g b alpha".split(), "h s_hsv v alpha".split() ) class PaletteTests(unittest.TestCase): def testGradientPalette(self): gp = GradientPalette("red", "blue", 3) self.assertTrue(gp.get(0) == (1.0, 0.0, 0.0, 1.0)) self.assertTrue(gp.get(1) == (0.5, 0.0, 0.5, 1.0)) self.assertTrue(gp.get(2) == (0.0, 0.0, 1.0, 1.0)) def testAdvancedGradientPalette(self): agp = AdvancedGradientPalette(["red", "black", "blue"], n=9) self.assertTrue(agp.get(0) == (1.0, 0.0, 0.0, 1.0)) self.assertTrue(agp.get(2) == (0.5, 0.0, 0.0, 1.0)) self.assertTrue(agp.get(4) == (0.0, 0.0, 0.0, 1.0)) self.assertTrue(agp.get(5) == (0.0, 0.0, 0.25, 1.0)) self.assertTrue(agp.get(8) == (0.0, 0.0, 1.0, 1.0)) agp = AdvancedGradientPalette(["red", "black", "blue"], [0, 8, 2], 9) self.assertTrue(agp.get(0) == (1.0, 0.0, 0.0, 1.0)) self.assertTrue(agp.get(1) == (0.5, 0.0, 0.5, 1.0)) self.assertTrue(agp.get(5) == (0.0, 0.0, 0.5, 1.0)) def suite(): color_suite = unittest.makeSuite(ColorTests) palette_suite = unittest.makeSuite(PaletteTests) return unittest.TestSuite([color_suite, palette_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_conversion.py0000644000175100001710000001500500000000000020544 0ustar00runnerdocker00000000000000import random import unittest from igraph import Graph, Matrix class DirectedUndirectedTests(unittest.TestCase): def testToUndirected(self): graph = Graph([(0, 1), (0, 2), (1, 0)], directed=True) graph2 = graph.copy() graph2.to_undirected(mode=False) self.assertTrue(graph2.vcount() == graph.vcount()) self.assertTrue(graph2.is_directed() == False) self.assertTrue(sorted(graph2.get_edgelist()) == [(0, 1), (0, 1), (0, 2)]) graph2 = graph.copy() graph2.to_undirected() self.assertTrue(graph2.vcount() == graph.vcount()) self.assertTrue(graph2.is_directed() == False) self.assertTrue(sorted(graph2.get_edgelist()) == [(0, 1), (0, 2)]) graph2 = graph.copy() graph2.es["weight"] = [1, 2, 3] graph2.to_undirected(mode="collapse", combine_edges="sum") self.assertTrue(graph2.vcount() == graph.vcount()) self.assertTrue(graph2.is_directed() == False) self.assertTrue(sorted(graph2.get_edgelist()) == [(0, 1), (0, 2)]) self.assertTrue(graph2.es["weight"] == [4, 2]) graph = Graph([(0, 1), (1, 0), (0, 1), (1, 0), (2, 1), (1, 2)], directed=True) graph2 = graph.copy() graph2.es["weight"] = [1, 2, 3, 4, 5, 6] graph2.to_undirected(mode="mutual", combine_edges="sum") self.assertTrue(graph2.vcount() == graph.vcount()) self.assertTrue(graph2.is_directed() == False) self.assertTrue(sorted(graph2.get_edgelist()) == [(0, 1), (0, 1), (1, 2)]) self.assertTrue( graph2.es["weight"] == [7, 3, 11] or graph2.es["weight"] == [3, 7, 11] ) def testToDirectedNoModeArg(self): graph = Graph([(0, 1), (0, 2), (2, 3), (2, 4)], directed=False) graph.to_directed() self.assertTrue(graph.is_directed()) self.assertTrue(graph.vcount() == 5) self.assertTrue( sorted(graph.get_edgelist()) == [(0, 1), (0, 2), (1, 0), (2, 0), (2, 3), (2, 4), (3, 2), (4, 2)] ) def testToDirectedMutual(self): graph = Graph([(0, 1), (0, 2), (2, 3), (2, 4)], directed=False) graph.to_directed("mutual") self.assertTrue(graph.is_directed()) self.assertTrue(graph.vcount() == 5) self.assertTrue( sorted(graph.get_edgelist()) == [(0, 1), (0, 2), (1, 0), (2, 0), (2, 3), (2, 4), (3, 2), (4, 2)] ) def testToDirectedAcyclic(self): graph = Graph([(0, 1), (2, 0), (3, 0), (3, 0), (4, 2)], directed=False) graph.to_directed("acyclic") self.assertTrue(graph.is_directed()) self.assertTrue(graph.vcount() == 5) self.assertTrue( sorted(graph.get_edgelist()) == [(0, 1), (0, 2), (0, 3), (0, 3), (2, 4)] ) def testToDirectedRandom(self): random.seed(0) graph = Graph.Ring(200, directed=False) graph.to_directed("random") self.assertTrue(graph.is_directed()) self.assertTrue(graph.vcount() == 200) edgelist1 = sorted(graph.get_edgelist()) graph = Graph.Ring(200, directed=False) graph.to_directed("random") self.assertTrue(graph.is_directed()) self.assertTrue(graph.vcount() == 200) edgelist2 = sorted(graph.get_edgelist()) self.assertTrue(edgelist1 != edgelist2) def testToDirectedInvalidMode(self): graph = Graph([(0, 1), (0, 2), (2, 3), (2, 4)], directed=False) with self.assertRaises(ValueError): graph.to_directed("no-such-mode") class GraphRepresentationTests(unittest.TestCase): def testGetAdjacency(self): # Undirected case g = Graph.Tree(6, 3) g.es["weight"] = list(range(5)) self.assertTrue( g.get_adjacency() == Matrix( [ [0, 1, 1, 1, 0, 0], [1, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], ] ) ) self.assertTrue( g.get_adjacency(attribute="weight") == Matrix( [ [0, 0, 1, 2, 0, 0], [0, 0, 0, 0, 3, 4], [1, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0], [0, 3, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0], ] ) ) self.assertTrue( g.get_adjacency(eids=True) == Matrix( [ [0, 1, 2, 3, 0, 0], [1, 0, 0, 0, 4, 5], [2, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0], ] ) - 1 ) # Directed case g = Graph.Tree(6, 3, "tree_out") g.add_edges([(0, 1), (1, 0)]) self.assertTrue( g.get_adjacency() == Matrix( [ [0, 2, 1, 1, 0, 0], [1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], ] ) ) def testGetSparseAdjacency(self): try: from scipy import sparse import numpy as np except ImportError: self.skipTest("Scipy and numpy are dependencies of this test.") # Undirected case g = Graph.Tree(6, 3) g.es["weight"] = list(range(5)) self.assertTrue( np.all((g.get_adjacency_sparse() == np.array(g.get_adjacency().data))) ) self.assertTrue( np.all( ( g.get_adjacency_sparse(attribute="weight") == np.array(g.get_adjacency(attribute="weight").data) ) ) ) # Directed case g = Graph.Tree(6, 3, "tree_out") g.add_edges([(0, 1), (1, 0)]) self.assertTrue( np.all(g.get_adjacency_sparse() == np.array(g.get_adjacency().data)) ) def suite(): direction_suite = unittest.makeSuite(DirectedUndirectedTests) representation_suite = unittest.makeSuite(GraphRepresentationTests) return unittest.TestSuite([direction_suite, representation_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_decomposition.py0000644000175100001710000005134200000000000021237 0ustar00runnerdocker00000000000000import math import random import unittest from igraph import ( Clustering, CohesiveBlocks, Cover, Graph, Histogram, InternalError, UniqueIdGenerator, VertexClustering, compare_communities, split_join_distance, set_random_number_generator, ) class SubgraphTests(unittest.TestCase): def testSubgraph(self): g = Graph.Lattice([10, 10], circular=False, mutual=False) g.vs["id"] = list(range(g.vcount())) vs = [0, 1, 2, 10, 11, 12, 20, 21, 22] sg = g.subgraph(vs) self.assertTrue( sg.isomorphic(Graph.Lattice([3, 3], circular=False, mutual=False)) ) self.assertTrue(sg.vs["id"] == vs) def testSubgraphEdges(self): g = Graph.Lattice([10, 10], circular=False, mutual=False) g.es["id"] = list(range(g.ecount())) es = [0, 1, 2, 5, 20, 21, 22, 24, 38, 40] sg = g.subgraph_edges(es) exp = Graph.Lattice([3, 3], circular=False, mutual=False) exp.delete_edges([7, 8]) self.assertTrue(sg.isomorphic(exp)) self.assertTrue(sg.es["id"] == es) class DecompositionTests(unittest.TestCase): def testKCores(self): g = Graph( 11, [ (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (2, 4), (2, 5), (3, 6), (3, 7), (1, 7), (7, 8), (1, 9), (1, 10), (9, 10), ], ) self.assertTrue(g.coreness() == [3, 3, 3, 3, 1, 1, 1, 2, 1, 2, 2]) self.assertTrue(g.shell_index() == g.coreness()) edgelist = g.k_core(3).get_edgelist() edgelist.sort() self.assertTrue(edgelist == [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]) class ClusteringTests(unittest.TestCase): def setUp(self): self.cl = Clustering([0, 0, 0, 1, 1, 2, 1, 1, 4, 4]) def testClusteringIndex(self): self.assertTrue(self.cl[0] == [0, 1, 2]) self.assertTrue(self.cl[1] == [3, 4, 6, 7]) self.assertTrue(self.cl[2] == [5]) self.assertTrue(self.cl[3] == []) self.assertTrue(self.cl[4] == [8, 9]) def testClusteringLength(self): self.assertTrue(len(self.cl) == 5) def testClusteringMembership(self): self.assertTrue(self.cl.membership == [0, 0, 0, 1, 1, 2, 1, 1, 4, 4]) def testClusteringSizes(self): self.assertTrue(self.cl.sizes() == [3, 4, 1, 0, 2]) self.assertTrue(self.cl.sizes(2, 4, 1) == [1, 2, 4]) self.assertTrue(self.cl.size(2) == 1) def testClusteringHistogram(self): self.assertTrue(isinstance(self.cl.size_histogram(), Histogram)) class VertexClusteringTests(unittest.TestCase): def setUp(self): self.graph = Graph.Full(10) self.graph.vs["string"] = list("aaabbcccab") self.graph.vs["int"] = [17, 41, 23, 25, 64, 33, 3, 24, 47, 15] def testFromStringAttribute(self): cl = VertexClustering.FromAttribute(self.graph, "string") self.assertTrue(cl.membership == [0, 0, 0, 1, 1, 2, 2, 2, 0, 1]) def testFromIntAttribute(self): cl = VertexClustering.FromAttribute(self.graph, "int") self.assertTrue(cl.membership == list(range(10))) cl = VertexClustering.FromAttribute(self.graph, "int", 15) self.assertTrue(cl.membership == [0, 1, 0, 0, 2, 1, 3, 0, 4, 0]) cl = VertexClustering.FromAttribute(self.graph, "int", [10, 20, 30]) self.assertTrue(cl.membership == [0, 1, 2, 2, 1, 1, 3, 2, 1, 0]) def testClusterGraph(self): cl = VertexClustering(self.graph, [0, 0, 0, 1, 1, 1, 2, 2, 2, 2]) self.graph.delete_edges(self.graph.es.select(_between=([0, 1, 2], [3, 4, 5]))) clg = cl.cluster_graph(dict(string="concat", int=max)) self.assertTrue(sorted(clg.get_edgelist()) == [(0, 2), (1, 2)]) self.assertTrue(not clg.is_directed()) self.assertTrue(clg.vs["string"] == ["aaa", "bbc", "ccab"]) self.assertTrue(clg.vs["int"] == [41, 64, 47]) clg = cl.cluster_graph(dict(string="concat", int=max), False) self.assertTrue( sorted(clg.get_edgelist()) == [(0, 0)] * 3 + [(0, 2)] * 12 + [(1, 1)] * 3 + [(1, 2)] * 12 + [(2, 2)] * 6 ) self.assertTrue(not clg.is_directed()) self.assertTrue(clg.vs["string"] == ["aaa", "bbc", "ccab"]) self.assertTrue(clg.vs["int"] == [41, 64, 47]) class CoverTests(unittest.TestCase): def setUp(self): self.cl = Cover([(0, 1, 2, 3), (3, 4, 5, 6, 9), (), (8, 9)]) def testCoverIndex(self): self.assertTrue(self.cl[0] == [0, 1, 2, 3]) self.assertTrue(self.cl[1] == [3, 4, 5, 6, 9]) self.assertTrue(self.cl[2] == []) self.assertTrue(self.cl[3] == [8, 9]) def testCoverLength(self): self.assertTrue(len(self.cl) == 4) def testCoverSizes(self): self.assertTrue(self.cl.sizes() == [4, 5, 0, 2]) self.assertTrue(self.cl.sizes(1, 3, 0) == [5, 2, 4]) self.assertTrue(self.cl.size(1) == 5) self.assertTrue(self.cl.size(2) == 0) def testCoverHistogram(self): self.assertTrue(isinstance(self.cl.size_histogram(), Histogram)) def testCoverConstructorWithN(self): self.assertTrue(self.cl.n == 10) cl = Cover(self.cl, n=15) self.assertTrue(cl.n == 15) cl = Cover(self.cl, n=1) self.assertTrue(cl.n == 10) class CommunityTests(unittest.TestCase): def reindexMembership(self, cl): if hasattr(cl, "membership"): cl = cl.membership idgen = UniqueIdGenerator() return [idgen[i] for i in cl] def assertMembershipsEqual(self, observed, expected): if hasattr(observed, "membership"): observed = observed.membership if hasattr(expected, "membership"): expected = expected.membership self.assertEqual( self.reindexMembership(expected), self.reindexMembership(observed) ) def testClauset(self): # Two cliques of size 5 with one connecting edge g = Graph.Full(5) + Graph.Full(5) g.add_edges([(0, 5)]) cl = g.community_fastgreedy().as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) self.assertAlmostEqual(cl.q, 0.4523, places=3) # Lollipop, weighted g = Graph.Full(4) + Graph.Full(2) g.add_edges([(3, 4)]) weights = [1, 1, 1, 1, 1, 1, 10, 10] cl = g.community_fastgreedy(weights).as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 1, 1, 1]) self.assertAlmostEqual(cl.q, 0.1708, places=3) # Same graph, different weights g.es["weight"] = [3] * g.ecount() cl = g.community_fastgreedy("weight").as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 1, 1]) self.assertAlmostEqual(cl.q, 0.1796, places=3) # Disconnected graph g = Graph.Full(4) + Graph.Full(4) + Graph.Full(3) + Graph.Full(2) cl = g.community_fastgreedy().as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3]) # Empty graph g = Graph(20) cl = g.community_fastgreedy().as_clustering() self.assertMembershipsEqual(cl, list(range(g.vcount()))) def testEdgeBetweenness(self): # Full graph, no weights g = Graph.Full(5) cl = g.community_edge_betweenness().as_clustering() self.assertMembershipsEqual(cl, [0] * 5) # Full graph with weights g.es["weight"] = 1 g[0, 1] = g[1, 2] = g[2, 0] = g[3, 4] = 10 # We need to specify the desired cluster count explicitly; this is # because edge betweenness-based detection does not play well with # modularity-based cluster count selection (the edge weights have # different semantics) so we need to give igraph a hint cl = g.community_edge_betweenness(weights="weight").as_clustering(n=2) self.assertMembershipsEqual(cl, [0, 0, 0, 1, 1]) self.assertAlmostEqual(cl.q, 0.2750, places=3) def testEigenvector(self): g = Graph.Full(5) + Graph.Full(5) g.add_edges([(0, 5)]) cl = g.community_leading_eigenvector() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) self.assertAlmostEqual(cl.q, 0.4523, places=3) cl = g.community_leading_eigenvector(2) self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) self.assertAlmostEqual(cl.q, 0.4523, places=3) def testInfomap(self): g = Graph.Famous("zachary") cl = g.community_infomap() self.assertAlmostEqual(cl.codelength, 4.60605, places=3) self.assertAlmostEqual(cl.q, 0.40203, places=3) self.assertMembershipsEqual( cl, [1, 1, 1, 1, 2, 2, 2, 1, 0, 1, 2, 1, 1, 1, 0, 0, 2, 1, 0, 1, 0, 1] + [0] * 12, ) # Smoke testing with vertex and edge weights v_weights = [random.randint(1, 5) for _ in range(g.vcount())] e_weights = [random.randint(1, 5) for _ in range(g.ecount())] cl = g.community_infomap(edge_weights=e_weights) cl = g.community_infomap(vertex_weights=v_weights) cl = g.community_infomap(edge_weights=e_weights, vertex_weights=v_weights) def testLabelPropagation(self): # Nothing to test there really, since the algorithm # is pretty nondeterministic. We just do a quick smoke # test. g = Graph.GRG(100, 0.2) cl = g.community_label_propagation() g = Graph([(0, 1), (1, 2), (2, 3)]) g.es["weight"] = [2, 1, 2] g.vs["initial"] = [0, -1, -1, 1] cl = g.community_label_propagation("weight", "initial", [1, 0, 0, 1]) self.assertMembershipsEqual(cl, [0, 0, 1, 1]) cl = g.community_label_propagation(initial="initial", fixed=[1, 0, 0, 1]) self.assertTrue( cl.membership == [0, 0, 1, 1] or cl.membership == [0, 1, 1, 1] or cl.membership == [0, 0, 0, 1] ) def testMultilevel(self): # Example graph from the paper g = Graph(16) g += [ (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 4), (1, 7), (2, 4), (2, 5), (2, 6), (3, 7), (4, 10), (5, 7), (5, 11), (6, 7), (6, 11), (8, 9), (8, 10), (8, 11), (8, 14), (8, 15), (9, 12), (9, 14), (10, 11), (10, 12), (10, 13), (10, 14), (11, 13), ] cls = g.community_multilevel(return_levels=True) self.assertTrue(len(cls) == 2) self.assertMembershipsEqual( cls[0], [1, 1, 1, 0, 1, 1, 0, 0, 2, 2, 2, 3, 2, 3, 2, 2] ) self.assertMembershipsEqual( cls[1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1] ) self.assertAlmostEqual(cls[0].q, 0.346301, places=5) self.assertAlmostEqual(cls[1].q, 0.392219, places=5) def testOptimalModularity(self): try: g = Graph.Famous("bull") cl = g.community_optimal_modularity() self.assertTrue(len(cl) == 2) self.assertMembershipsEqual(cl, [0, 0, 1, 0, 1]) self.assertAlmostEqual(cl.q, 0.08, places=7) ws = [i % 5 for i in range(g.ecount())] cl = g.community_optimal_modularity(weights=ws) self.assertAlmostEqual( cl.q, g.modularity(cl.membership, weights=ws), places=7 ) g = Graph.Famous("zachary") cl = g.community_optimal_modularity() self.assertTrue(len(cl) == 4) self.assertMembershipsEqual( cl, [ 0, 0, 0, 0, 1, 1, 1, 0, 2, 2, 1, 0, 0, 0, 2, 2, 1, 0, 2, 0, 2, 0, 2, 3, 3, 3, 2, 3, 3, 2, 2, 3, 2, 2, ], ) self.assertAlmostEqual(cl.q, 0.4197896, places=7) ws = [2 + (i % 3) for i in range(g.ecount())] cl = g.community_optimal_modularity(weights=ws) self.assertAlmostEqual( cl.q, g.modularity(cl.membership, weights=ws), places=7 ) except NotImplementedError: # Well, meh pass def testSpinglass(self): g = Graph.Full(5) + Graph.Full(5) + Graph.Full(5) g += [(0, 5), (5, 10), (10, 0)] # Spinglass community detection is a bit unstable, so run it three times ok = False for i in range(3): cl = g.community_spinglass() if self.reindexMembership(cl) == [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, ]: ok = True break self.assertTrue(ok) def testWalktrap(self): g = Graph.Full(5) + Graph.Full(5) + Graph.Full(5) g += [(0, 5), (5, 10), (10, 0)] cl = g.community_walktrap().as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]) cl = g.community_walktrap(steps=3).as_clustering() self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]) def testLeiden(self): # Example from paper (Fig. C.1) high_weight = 3.0 low_weight = 3.0 / 2.0 edges = [ (0, 1, high_weight), (2, 3, high_weight), (4, 2, high_weight), (3, 4, high_weight), (5, 6, high_weight), (7, 5, high_weight), (6, 7, high_weight), (0, 2, low_weight), (0, 3, low_weight), (0, 4, low_weight), (1, 5, low_weight), (1, 6, low_weight), (1, 7, low_weight), ] G = Graph.TupleList(edges, weights=True) import random random.seed(0) set_random_number_generator(random) # We don't find the optimal partition if we are greedy cl = G.community_leiden( "CPM", resolution_parameter=1, weights="weight", beta=0, n_iterations=-1 ) self.assertMembershipsEqual(cl, [0, 0, 1, 1, 1, 2, 2, 2]) random.seed(0) set_random_number_generator(random) # We can find the optimal partition if we allow for non-decreasing moves # (The randomness is only present in the refinement, which is why we # start from all nodes in the same community: this should then be # refined). cl = G.community_leiden( "CPM", resolution_parameter=1, weights="weight", beta=5, n_iterations=-1, initial_membership=[0] * G.vcount(), ) self.assertMembershipsEqual(cl, [0, 1, 0, 0, 0, 1, 1, 1]) class CohesiveBlocksTests(unittest.TestCase): def genericTests(self, cbs): self.assertTrue(isinstance(cbs, CohesiveBlocks)) self.assertTrue( all(cbs.cohesion(i) == c for i, c in enumerate(cbs.cohesions())) ) self.assertTrue(all(cbs.parent(i) == c for i, c in enumerate(cbs.parents()))) self.assertTrue( all(cbs.max_cohesion(i) == c for i, c in enumerate(cbs.max_cohesions())) ) def testCohesiveBlocks1(self): # Taken from the igraph R manual g = Graph.Full(4) + Graph(2) + [(3, 4), (4, 5), (4, 2)] g *= 3 g += [(0, 6), (1, 7), (0, 12), (4, 0), (4, 1)] cbs = g.cohesive_blocks() self.genericTests(cbs) self.assertEqual( sorted(list(cbs)), [ list(range(0, 5)), list(range(18)), [0, 1, 2, 3, 4, 6, 7, 8, 9, 10], list(range(6, 10)), list(range(12, 16)), list(range(12, 17)), ], ) self.assertEqual(cbs.cohesions(), [1, 2, 2, 4, 3, 3]) self.assertEqual( cbs.max_cohesions(), [4, 4, 4, 4, 4, 1, 3, 3, 3, 3, 2, 1, 3, 3, 3, 3, 2, 1] ) self.assertEqual(cbs.parents(), [None, 0, 0, 1, 2, 1]) def testCohesiveBlocks2(self): # Taken from the Moody-White paper g = Graph.Formula( "1-2:3:4:5:6, 2-3:4:5:7, 3-4:6:7, 4-5:6:7, " "5-6:7:21, 6-7, 7-8:11:14:19, 8-9:11:14, 9-10, " "10-12:13, 11-12:14, 12-16, 13-16, 14-15, 15-16, " "17-18:19:20, 18-20:21, 19-20:22:23, 20-21, " "21-22:23, 22-23" ) cbs = g.cohesive_blocks() self.genericTests(cbs) expected_blocks = [ list(range(7)), list(range(23)), list(range(7)) + list(range(16, 23)), list(range(6, 16)), [6, 7, 10, 13], ] observed_blocks = sorted( sorted(int(x) - 1 for x in g.vs[bl]["name"]) for bl in cbs ) self.assertEqual(expected_blocks, observed_blocks) self.assertTrue(cbs.cohesions() == [1, 2, 2, 5, 3]) self.assertTrue(cbs.parents() == [None, 0, 0, 1, 2]) self.assertTrue( sorted(cbs.hierarchy().get_edgelist()) == [(0, 1), (0, 2), (1, 3), (2, 4)] ) def testCohesiveBlockingErrors(self): g = Graph.GRG(100, 0.2) g.to_directed() self.assertRaises(InternalError, g.cohesive_blocks) class ComparisonTests(unittest.TestCase): def setUp(self): self.clusterings = [ ([0, 0, 0, 1, 1, 1], [1, 1, 1, 0, 0, 0]), ([0, 0, 0, 1, 1, 1], [0, 0, 1, 1, 2, 2]), ([0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5]), ( [0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2], [2, 0, 1, 0, 2, 0, 2, 0, 1, 0, 3, 1], ), ] def _testMethod(self, method, expected): for clusters, result in zip(self.clusterings, expected): self.assertAlmostEqual( compare_communities(method=method, *clusters), result, places=3 ) def testCompareVI(self): expected = [0, 0.8675, math.log(6)] self._testMethod(None, expected) self._testMethod("vi", expected) def testCompareNMI(self): expected = [1, 0.5158, 0] self._testMethod("nmi", expected) def testCompareSplitJoin(self): expected = [0, 3, 5, 11] self._testMethod("split_join", expected) l1 = [1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3] l2 = [3, 1, 2, 1, 3, 1, 3, 1, 2, 1, 4, 2] self.assertEqual(split_join_distance(l1, l2), (6, 5)) def testCompareRand(self): expected = [1, 2 / 3.0, 0, 0.590909] self._testMethod("rand", expected) def testCompareAdjustedRand(self): expected = [1, 0.242424, 0, -0.04700353] self._testMethod("adjusted_rand", expected) def testRemoveNone(self): l1 = Clustering([1, 1, 1, None, None, 2, 2, 2, 2]) l2 = Clustering([1, 1, 2, 2, None, 2, 3, 3, None]) self.assertAlmostEqual( compare_communities(l1, l2, "nmi", remove_none=True), 0.5158, places=3 ) def suite(): decomposition_suite = unittest.makeSuite(DecompositionTests) clustering_suite = unittest.makeSuite(ClusteringTests) vertex_clustering_suite = unittest.makeSuite(VertexClusteringTests) cover_suite = unittest.makeSuite(CoverTests) community_suite = unittest.makeSuite(CommunityTests) cohesive_blocks_suite = unittest.makeSuite(CohesiveBlocksTests) comparison_suite = unittest.makeSuite(ComparisonTests) return unittest.TestSuite( [ decomposition_suite, clustering_suite, vertex_clustering_suite, cover_suite, community_suite, cohesive_blocks_suite, comparison_suite, ] ) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_edgeseq.py0000644000175100001710000003727700000000000020013 0ustar00runnerdocker00000000000000# vim:ts=4 sw=4 sts=4: import unittest from igraph import * from .utils import is_pypy try: import numpy as np except ImportError: np = None class EdgeTests(unittest.TestCase): def setUp(self): self.g = Graph.Full(10) def testHash(self): data = {} n = self.g.ecount() for i in range(n): code1 = hash(self.g.es[i]) code2 = hash(self.g.es[i]) self.assertEqual(code1, code2) data[self.g.es[i]] = i for i in range(n): self.assertEqual(i, data[self.g.es[i]]) def testRichCompare(self): idxs = [2, 5, 9, 13, 42] g2 = Graph.Full(10) for i in idxs: for j in idxs: self.assertEqual(i == j, self.g.es[i] == self.g.es[j]) self.assertEqual(i != j, self.g.es[i] != self.g.es[j]) self.assertEqual(i < j, self.g.es[i] < self.g.es[j]) self.assertEqual(i > j, self.g.es[i] > self.g.es[j]) self.assertEqual(i <= j, self.g.es[i] <= self.g.es[j]) self.assertEqual(i >= j, self.g.es[i] >= self.g.es[j]) self.assertFalse(self.g.es[i] == g2.es[j]) self.assertFalse(self.g.es[i] != g2.es[j]) self.assertFalse(self.g.es[i] < g2.es[j]) self.assertFalse(self.g.es[i] > g2.es[j]) self.assertFalse(self.g.es[i] <= g2.es[j]) self.assertFalse(self.g.es[i] >= g2.es[j]) self.assertFalse(self.g.es[2] == self.g.vs[2]) def testRepr(self): output = repr(self.g.es[0]) self.assertEqual(output, "igraph.Edge(%r, 0, {})" % self.g) self.g.es["weight"] = list(range(10, 0, -1)) output = repr(self.g.es[3]) self.assertEqual(output, "igraph.Edge(%r, 3, {'weight': 7})" % self.g) def testUpdateAttributes(self): e = self.g.es[0] e.update_attributes(a=2) self.assertEqual(e["a"], 2) e.update_attributes([("a", 3), ("b", 4)], c=5, d=6) self.assertEqual(e.attributes(), dict(a=3, b=4, c=5, d=6)) e.update_attributes(dict(b=44, c=55)) self.assertEqual(e.attributes(), dict(a=3, b=44, c=55, d=6)) def testPhantomEdge(self): e = self.g.es[self.g.ecount() - 1] e.delete() # v is now a phantom edge; try to freak igraph out now :) self.assertRaises(ValueError, e.update_attributes, a=2) self.assertRaises(ValueError, e.__getitem__, "a") self.assertRaises(ValueError, e.__setitem__, "a", 4) self.assertRaises(ValueError, e.__delitem__, "a") self.assertRaises(ValueError, e.attributes) self.assertRaises(ValueError, getattr, e, "source") self.assertRaises(ValueError, getattr, e, "source_vertex") self.assertRaises(ValueError, getattr, e, "target") self.assertRaises(ValueError, getattr, e, "target_vertex") self.assertRaises(ValueError, getattr, e, "tuple") self.assertRaises(ValueError, getattr, e, "vertex_tuple") @unittest.skipIf(is_pypy, "skipped on PyPy because we do not have access to docstrings") def testProxyMethods(self): g = Graph.GRG(10, 0.5) e = g.es[0] # - delete() is ignored because it mutates the graph ignore = "delete" ignore = set(ignore.split()) # Methods not listed here are expected to return an int or a float return_types = {} for name in Edge.__dict__: if name in ignore: continue func = getattr(e, name) docstr = func.__doc__ if not docstr.startswith("Proxy method"): continue result = func() self.assertEqual( getattr(g, name)(e.index), result, msg=("Edge.%s proxy method misbehaved" % name), ) return_type = return_types.get(name, (int, float)) self.assertTrue( isinstance(result, return_type), msg=("Edge.%s proxy method did not return %s" % (name, return_type)), ) class EdgeSeqTests(unittest.TestCase): def assert_edges_unique_in(self, es): pairs = sorted(e.tuple for e in es) self.assertEqual(pairs, sorted(set(pairs))) def setUp(self): self.g = Graph.Full(10) self.g.es["test"] = list(range(45)) def testCreation(self): self.assertTrue(len(EdgeSeq(self.g)) == 45) self.assertTrue(len(EdgeSeq(self.g, 2)) == 1) self.assertTrue(len(EdgeSeq(self.g, [1, 2, 3])) == 3) self.assertTrue(EdgeSeq(self.g, [1, 2, 3]).indices == [1, 2, 3]) self.assertRaises(ValueError, EdgeSeq, self.g, 112) self.assertRaises(ValueError, EdgeSeq, self.g, [112]) self.assertTrue(self.g.es.graph == self.g) def testIndexing(self): n = self.g.ecount() for i in range(n): self.assertEqual(i, self.g.es[i].index) self.assertEqual(n - i - 1, self.g.es[-i - 1].index) self.assertRaises(IndexError, self.g.es.__getitem__, n) self.assertRaises(IndexError, self.g.es.__getitem__, -n - 1) self.assertRaises(TypeError, self.g.es.__getitem__, 1.5) @unittest.skipIf(np is None, "test case depends on NumPy") def testNumPyIndexing(self): n = self.g.ecount() for i in range(n): arr = np.array([i]) self.assertEqual(i, self.g.es[arr[0]].index) arr = np.array([n]) self.assertRaises(IndexError, self.g.es.__getitem__, arr[0]) arr = np.array([-n - 1]) self.assertRaises(IndexError, self.g.es.__getitem__, arr[0]) arr = np.array([1.5]) self.assertRaises(TypeError, self.g.es.__getitem__, arr[0]) ind = [1, 3, 5, 8, 3, 2] arr = np.array(ind) self.assertEqual(ind, [edge.index for edge in self.g.es[arr.tolist()]]) self.assertEqual(ind, [edge.index for edge in self.g.es[list(arr)]]) def testPartialAttributeAssignment(self): only_even = self.g.es.select(lambda e: (e.index % 2 == 0)) only_even["test"] = [0] * len(only_even) expected = [[0, i][i % 2] for i in range(self.g.ecount())] self.assertTrue(self.g.es["test"] == expected) only_even["test2"] = list(range(23)) expected = [[i // 2, None][i % 2] for i in range(self.g.ecount())] self.assertTrue(self.g.es["test2"] == expected) def testSequenceReusing(self): if "test" in self.g.edge_attributes(): del self.g.es["test"] self.g.es["test"] = ["A", "B", "C"] self.assertTrue(self.g.es["test"] == ["A", "B", "C"] * 15) self.g.es["test"] = "ABC" self.assertTrue(self.g.es["test"] == ["ABC"] * 45) only_even = self.g.es.select(lambda e: (e.index % 2 == 0)) only_even["test"] = ["D", "E"] expected = ["D", "ABC", "E", "ABC"] * 12 expected = expected[0:45] self.assertTrue(self.g.es["test"] == expected) del self.g.es["test"] only_even["test"] = ["D", "E"] expected = ["D", None, "E", None] * 12 expected = expected[0:45] self.assertTrue(self.g.es["test"] == expected) def testAllSequence(self): self.assertTrue(len(self.g.es) == 45) self.assertTrue(self.g.es["test"] == list(range(45))) def testEmptySequence(self): empty_es = self.g.es.select(None) self.assertTrue(len(empty_es) == 0) self.assertRaises(IndexError, empty_es.__getitem__, 0) self.assertRaises(KeyError, empty_es.__getitem__, "nonexistent") self.assertTrue(empty_es["test"] == []) empty_es = self.g.es[[]] self.assertTrue(len(empty_es) == 0) empty_es = self.g.es[()] self.assertTrue(len(empty_es) == 0) def testCallableFilteringFind(self): edge = self.g.es.find(lambda e: (e.index % 2 == 1)) self.assertTrue(edge.index == 1) self.assertRaises(IndexError, self.g.es.find, lambda e: (e.index % 2 == 3)) def testCallableFilteringSelect(self): only_even = self.g.es.select(lambda e: (e.index % 2 == 0)) self.assertTrue(len(only_even) == 23) self.assertRaises(KeyError, only_even.__getitem__, "nonexistent") self.assertTrue(only_even["test"] == [i * 2 for i in range(23)]) def testChainedCallableFilteringSelect(self): only_div_six = self.g.es.select( lambda e: (e.index % 2 == 0), lambda e: (e.index % 3 == 0) ) self.assertTrue(len(only_div_six) == 8) self.assertTrue(only_div_six["test"] == [0, 6, 12, 18, 24, 30, 36, 42]) only_div_six = self.g.es.select(lambda e: (e.index % 2 == 0)).select( lambda e: (e.index % 3 == 0) ) self.assertTrue(len(only_div_six) == 8) self.assertTrue(only_div_six["test"] == [0, 6, 12, 18, 24, 30, 36, 42]) def testIntegerFilteringFind(self): self.assertEqual(self.g.es.find(3).index, 3) self.assertEqual(self.g.es.select(2, 3, 4, 2).find(3).index, 2) self.assertRaises(IndexError, self.g.es.find, 178) def testIntegerFilteringSelect(self): subset = self.g.es.select(2, 3, 4, 2) self.assertTrue(len(subset) == 4) self.assertTrue(subset["test"] == [2, 3, 4, 2]) self.assertRaises(TypeError, self.g.es.select, 2, 3, 4, 2, None) subset = self.g.es[2, 3, 4, 2] self.assertTrue(len(subset) == 4) self.assertTrue(subset["test"] == [2, 3, 4, 2]) def testIterableFilteringSelect(self): subset = self.g.es.select(list(range(5, 8))) self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [5, 6, 7]) def testSliceFilteringSelect(self): subset = self.g.es.select(slice(5, 8)) self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [5, 6, 7]) subset = self.g.es[40:56:2] self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [40, 42, 44]) def testKeywordFilteringSelect(self): g = Graph.Barabasi(1000, 2) g.es["betweenness"] = g.edge_betweenness() g.es["parity"] = [i % 2 for i in range(g.ecount())] self.assertTrue(len(g.es(betweenness_gt=10)) < 2000) self.assertTrue(len(g.es(betweenness_gt=10, parity=0)) < 2000) def testSourceTargetFiltering(self): g = Graph.Barabasi(1000, 2, directed=True) es1 = set(e.source for e in g.es.select(_target_in=[2, 4])) es2 = set(v1 for v1, v2 in g.get_edgelist() if v2 in [2, 4]) self.assertTrue(es1 == es2) def testWithinFiltering(self): g = Graph.Lattice([10, 10]) vs = [0, 1, 2, 10, 11, 12, 20, 21, 22] vs2 = (0, 1, 10, 11) es1 = g.es.select(_within=vs) es2 = g.es.select(_within=VertexSeq(g, vs)) for es in [es1, es2]: self.assertTrue(len(es) == 12) self.assertTrue(all(e.source in vs and e.target in vs for e in es)) self.assert_edges_unique_in(es) es_filtered = es.select(_within=vs2) self.assertTrue(len(es_filtered) == 4) self.assertTrue( all(e.source in vs2 and e.target in vs2 for e in es_filtered) ) self.assert_edges_unique_in(es_filtered) def testBetweenFiltering(self): g = Graph.Lattice([10, 10]) vs1, vs2 = [10, 11, 12], [20, 21, 22] es1 = g.es.select(_between=(vs1, vs2)) es2 = g.es.select(_between=(VertexSeq(g, vs1), VertexSeq(g, vs2))) for es in [es1, es2]: self.assertTrue(len(es) == 3) self.assertTrue( all( (e.source in vs1 and e.target in vs2) or (e.target in vs1 and e.source in vs2) for e in es ) ) self.assert_edges_unique_in(es) def testIncidentFiltering(self): g = Graph.Lattice([10, 10], circular=False) vs = (0, 1, 10, 11) vs2 = (11, 0, 24) vs3 = sorted(set(vs).intersection(set(vs2))) es = g.es.select(_incident=vs) self.assertEqual(8, len(es)) self.assertTrue(all((e.source in vs or e.target in vs) for e in es)) self.assert_edges_unique_in(es) es_filtered = es.select(_incident=vs2) self.assertEqual(6, len(es_filtered)) self.assertTrue(all((e.source in vs3 or e.target in vs3) for e in es_filtered)) self.assert_edges_unique_in(es_filtered) def testIncidentFilteringByNames(self): g = Graph.Lattice([10, 10], circular=False) vs = (0, 1, 10, 11) g.vs[vs]["name"] = ["A", "B", "C", "D"] vs2 = (11, 0, 24) g.vs[24]["name"] = "X" vs3 = sorted(set(vs).intersection(set(vs2))) es = g.es.select(_incident=("A", "B", "C", "D")) self.assertEqual(8, len(es)) self.assertTrue(all((e.source in vs or e.target in vs) for e in es)) self.assert_edges_unique_in(es) es_filtered = es.select(_incident=("D", "A", "X")) self.assertEqual(6, len(es_filtered)) self.assertTrue(all((e.source in vs3 or e.target in vs3) for e in es_filtered)) self.assert_edges_unique_in(es_filtered) es_filtered = es_filtered.select(_from="A") self.assertEqual(2, len(es_filtered)) self.assertTrue(all((e.source == 0 or e.target == 0) for e in es_filtered)) self.assert_edges_unique_in(es_filtered) def testSourceAndTargetFilteringForUndirectedGraphs(self): g = Graph.Lattice([10, 10], circular=False) vs = (0, 1, 10, 11) vs2 = (11, 0, 24) vs3 = sorted(set(vs).intersection(set(vs2))) es = g.es.select(_from=vs) self.assertEqual(8, len(es)) self.assertTrue(all((e.source in vs or e.target in vs) for e in es)) self.assert_edges_unique_in(es) es_filtered = es.select(_to_in=vs2) self.assertEqual(6, len(es_filtered)) self.assertTrue(all((e.source in vs3 or e.target in vs3) for e in es_filtered)) self.assert_edges_unique_in(es_filtered) es_filtered = es_filtered.select(_from_eq=0) self.assertEqual(2, len(es_filtered)) self.assertTrue(all((e.source == 0 or e.target == 0) for e in es_filtered)) self.assert_edges_unique_in(es_filtered) def testIndexOutOfBoundsSelect(self): g = Graph.Full(3) self.assertRaises(ValueError, g.es.select, 4) self.assertRaises(ValueError, g.es.select, 4, 5) self.assertRaises(ValueError, g.es.select, (4, 5)) self.assertRaises(ValueError, g.es.select, 2, -1) self.assertRaises(ValueError, g.es.select, (2, -1)) self.assertRaises(ValueError, g.es.__getitem__, (0, 1000000)) def testIndexAndKeywordFilteringFind(self): self.assertRaises(ValueError, self.g.es.find, 2, test=4) self.assertTrue(self.g.es.find(2, test=2) == self.g.es[2]) def testGraphMethodProxying(self): idxs = [1, 3, 5, 7, 9] g = Graph.Barabasi(100) es = g.es(*idxs) ebs = g.edge_betweenness() self.assertEqual([ebs[i] for i in idxs], es.edge_betweenness()) idxs = [1, 3] g = Graph([(0, 1), (1, 2), (2, 0), (1, 0)], directed=True) es = g.es(*idxs) mutual = g.is_mutual(es) self.assertEqual(mutual, es.is_mutual()) for e, m in zip(es, mutual): self.assertEqual(e.is_mutual(), m) def testIsAll(self): g = Graph.Full(5) self.assertTrue(g.es.is_all()) self.assertFalse(g.es.select(1, 2, 3).is_all()) self.assertFalse(g.es.select(_within=[1, 2, 3]).is_all()) def suite(): edge_suite = unittest.makeSuite(EdgeTests) es_suite = unittest.makeSuite(EdgeSeqTests) return unittest.TestSuite([edge_suite, es_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_flow.py0000644000175100001710000002352000000000000017327 0ustar00runnerdocker00000000000000import unittest from igraph import * from itertools import combinations from random import randint class MaxFlowTests(unittest.TestCase): def setUp(self): self.g = Graph(4, [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)]) self.capacities = [4, 2, 10, 2, 2] self.g.es["capacity"] = self.capacities def testCapacities(self): self.assertTrue(self.capacities == self.g.es.get_attribute_values("capacity")) def testEdgeConnectivity(self): self.assertTrue(self.g.edge_connectivity(0, 3) == 2) self.assertTrue(Graph.Barabasi(50).edge_connectivity() == 1) self.assertTrue(self.g.adhesion() == 2) self.assertTrue(Graph.Tree(10, 3).adhesion() == 1) self.assertTrue(Graph.Tree(10, 3, TREE_OUT).adhesion() == 0) self.assertRaises(ValueError, self.g.edge_connectivity, 0) def testVertexConnectivity(self): self.assertTrue(self.g.vertex_connectivity(0, 3) == 2) self.assertTrue(Graph.Barabasi(50).vertex_connectivity() == 1) self.assertTrue(self.g.cohesion() == 2) self.assertTrue(Graph.Tree(10, 3).cohesion() == 1) self.assertTrue(Graph.Tree(10, 3, TREE_OUT).cohesion() == 0) self.assertRaises(ValueError, self.g.vertex_connectivity, 0) self.assertRaises(InternalError, self.g.vertex_connectivity, 0, 1) self.assertTrue(self.g.vertex_connectivity(0, 1, neighbors="nodes") == 4) self.assertTrue(self.g.vertex_connectivity(0, 1, neighbors="negative") == -1) def testMaxFlowValue(self): self.assertTrue(self.g.maxflow_value(0, 3) == 2) self.assertTrue(self.g.maxflow_value(0, 3, self.capacities) == 4) self.assertTrue(self.g.maxflow_value(0, 3, "capacity") == 4) self.assertRaises(KeyError, self.g.maxflow_value, 0, 3, "unknown") def testMaxFlow(self): flow = self.g.maxflow(0, 3) self.assertEqual(flow.value, 2) self.assertEqual(flow.flow, [1, 1, 0, 1, 1]) flow = self.g.maxflow(0, 3, "capacity") self.assertEqual(flow.value, 4) self.assertEqual(flow.cut, [3, 4]) self.assertEqual([e.index for e in flow.es], [3, 4]) self.assertTrue( set(flow.partition[0]).union(flow.partition[1]) == set(range(self.g.vcount())) ) self.assertRaises(KeyError, self.g.maxflow, 0, 3, "unknown") class CutTests(unittest.TestCase): def constructSimpleGraph(self, directed=False): g = Graph(4, [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)], directed) g.es["capacity"] = [4, 2, 10, 2, 2] return g def constructLadderGraph(self, directed=False): el = list(zip(list(range(0, 5)), list(range(1, 6)))) el += list(zip(list(range(6, 11)), list(range(7, 12)))) el += list(zip(list(range(0, 6)), list(range(6, 12)))) g = Graph(el, directed=directed) return g def testMinCutValue(self): g = self.constructSimpleGraph() self.assertTrue(g.mincut_value(0, 3) == 2) self.assertTrue(g.mincut_value(0, 3, g.es["capacity"]) == 4) self.assertTrue(g.mincut_value(0, 3, "capacity") == 4) self.assertRaises(KeyError, g.mincut_value, 0, 3, "unknown") self.assertTrue(g.mincut_value() == 2) self.assertTrue(g.mincut_value(source=0) == 2) self.assertTrue(g.mincut_value(target=2) == 2) def testMinCut(self): g = self.constructSimpleGraph() mc = g.mincut() self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.value == 2) self.assertTrue( set(mc.partition[0]).union(mc.partition[1]) == set(range(g.vcount())) ) self.assertTrue(isinstance(str(mc), str)) self.assertTrue(isinstance(repr(mc), str)) self.assertTrue(isinstance(mc.es, EdgeSeq)) self.assertTrue(len(mc.es) == 2) mc = g.mincut(capacity="capacity") self.assertTrue(mc.value == 4) self.assertRaises(KeyError, g.mincut, capacity="unknown") def testMinCutWithSourceAndTarget(self): g = self.constructSimpleGraph() mc = g.mincut(0, 3, "capacity") self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [3, 4]) self.assertTrue(mc.value == 4) self.assertTrue( set(mc.partition[0]).union(mc.partition[1]) == set(range(g.vcount())) ) mc = g.mincut(0, 3) self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [3, 4]) self.assertTrue(mc.value == 2) mc = g.mincut(2, 0, "capacity") self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [0, 1]) self.assertTrue(mc.value == 6) self.assertRaises(ValueError, g.mincut, 2, capacity="capacity") def testStMinCut(self): g = self.constructSimpleGraph() mc = g.st_mincut(0, 3, "capacity") self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [3, 4]) self.assertTrue(mc.value == 4) self.assertTrue( set(mc.partition[0]).union(mc.partition[1]) == set(range(g.vcount())) ) mc = g.st_mincut(0, 3) self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [3, 4]) self.assertTrue(mc.value == 2) mc = g.st_mincut(2, 0, "capacity") self.assertTrue(isinstance(mc, Cut)) self.assertTrue(mc.cut == [0, 1]) self.assertTrue(mc.value == 6) self.assertRaises(KeyError, g.st_mincut, 2, 0, capacity="unknown") def testAllSTCuts1(self): # Simple graph with four vertices g = self.constructSimpleGraph(directed=True) partitions = [ ((0, 1, 1, 1), 2), ((0, 0, 1, 1), 3), ((0, 1, 0, 1), 2), ((0, 0, 0, 1), 2), ] values = dict(partitions) partitions = [partition for partition, _ in partitions] for cut in g.all_st_cuts(0, 3): membership = tuple(cut.membership) self.assertTrue( membership in partitions, "%r not found among expected partitions" % (membership,), ) self.assertEqual(cut.value, values[membership]) self.assertEqual(len(cut.es), values[membership]) partitions.remove(membership) self.assertTrue( partitions == [], "expected partitions not seen: %r" % (partitions,) ) def testAllSTCuts2(self): # "Ladder graph" g = self.constructLadderGraph(directed=True) cuts = g.all_st_cuts(0, 11) self.assertEqual(len(cuts), 36) self.assertEqual(len(set(tuple(cut.membership) for cut in cuts)), 36) for cut in cuts: g2 = g.copy() g2.delete_edges(cut.es) self.assertFalse( g2.is_connected(), "%r is not a real cut" % (cut.membership,) ) self.assertFalse(cut.value < 2 or cut.value > 6) def testAllSTMinCuts2(self): # "Ladder graph" g = self.constructLadderGraph() g.to_directed("mutual") cuts = g.all_st_mincuts(0, 11) self.assertEqual(len(cuts), 7) self.assertEqual(len(set(tuple(cut.membership) for cut in cuts)), 7) for cut in cuts: self.assertEqual(cut.value, 2) g2 = g.copy() g2.delete_edges(cut.es) self.assertFalse( g2.is_connected(), "%r is not a real cut" % (cut.membership,) ) g.es["capacity"] = [2, 1, 2, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1] cuts = g.all_st_mincuts(0, 11, "capacity") self.assertEqual(len(cuts), 2) self.assertEqual(cuts[0].membership, [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1]) self.assertEqual(cuts[1].membership, [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1]) self.assertEqual(cuts[0].value, 2) self.assertEqual(cuts[1].value, 2) class GomoryHuTests(unittest.TestCase): def testEmpty(self): g = Graph() t = g.gomory_hu_tree() self.assertEqual(0, t.vcount()) self.assertEqual(0, t.ecount()) def testSimpleExample(self): g = Graph( 6, [(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4), (3, 5), (4, 5)], directed=False, ) g.es["capacity"] = [1, 7, 1, 3, 2, 4, 1, 6, 2] t = g.gomory_hu_tree("capacity") self.validate_gomory_hu_tree(g, t) def testDirected(self): g = Graph( 6, [(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4), (3, 5), (4, 5)], directed=True, ) g.es["capacity"] = [1, 7, 1, 3, 2, 4, 1, 6, 2] self.assertRaises(InternalError, g.gomory_hu_tree, "capacity") def testRandomGRG(self): g = Graph.GRG(25, 0.4) self.validate_gomory_hu_tree(g, g.gomory_hu_tree()) g.es["capacity"] = [randint(0, 10) for _ in range(g.ecount())] self.validate_gomory_hu_tree(g, g.gomory_hu_tree("capacity")) def validate_gomory_hu_tree(self, g, t): n = g.vcount() self.assertEqual(n, t.vcount()) self.assertEqual(n - 1, t.ecount()) self.assertFalse(t.is_directed()) if "capacity" in g.edge_attributes(): capacities = g.es["capacity"] else: capacities = None for i, j in combinations(list(range(n)), 2): path = t.get_shortest_paths(i, j, output="epath") if path: path = path[0] expected_flow = min(t.es[path]["flow"]) observed_flow = g.maxflow_value(i, j, capacities) self.assertEqual(observed_flow, expected_flow) def suite(): flow_suite = unittest.makeSuite(MaxFlowTests) cut_suite = unittest.makeSuite(CutTests) gomory_hu_suite = unittest.makeSuite(GomoryHuTests) return unittest.TestSuite([flow_suite, cut_suite, gomory_hu_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_foreign.py0000644000175100001710000005545300000000000020023 0ustar00runnerdocker00000000000000import gzip import io import unittest import warnings from igraph import Graph, InternalError from .utils import temporary_file try: import networkx as nx except ImportError: nx = None try: import graph_tool as gt except ImportError: gt = None try: import pandas as pd except ImportError: pd = None GRAPHML_EXAMPLE_FILE = """\ a b c d e f """ class ForeignTests(unittest.TestCase): def testDIMACS(self): with temporary_file( """\ c c This is a simple example file to demonstrate the c DIMACS input file format for minimum-cost flow problems. c c problem line : p max 4 5 c c node descriptor lines : n 1 s n 4 t c c arc descriptor lines : a 1 2 4 a 1 3 2 a 2 3 2 a 2 4 3 a 3 4 5 """ ) as tmpfname: graph = Graph.Read_DIMACS(tmpfname, False) self.assertTrue(isinstance(graph, Graph)) self.assertTrue(graph.vcount() == 4 and graph.ecount() == 5) self.assertTrue(graph["source"] == 0 and graph["target"] == 3) self.assertTrue(graph.es["capacity"] == [4, 2, 2, 3, 5]) graph.write_dimacs(tmpfname) def testDL(self): with temporary_file( """\ dl n=5 format = fullmatrix labels embedded data: larry david lin pat russ Larry 0 1 1 1 0 david 1 0 0 0 1 Lin 1 0 0 1 0 Pat 1 0 1 0 1 russ 0 1 0 1 0 """ ) as tmpfname: g = Graph.Read_DL(tmpfname) self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 5 and g.ecount() == 12) self.assertTrue(g.is_directed()) self.assertTrue( sorted(g.get_edgelist()) == [ (0, 1), (0, 2), (0, 3), (1, 0), (1, 4), (2, 0), (2, 3), (3, 0), (3, 2), (3, 4), (4, 1), (4, 3), ] ) with temporary_file( """\ dl n=5 format = fullmatrix labels: barry,david lin,pat russ data: 0 1 1 1 0 1 0 0 0 1 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0 """ ) as tmpfname: g = Graph.Read_DL(tmpfname) self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 5 and g.ecount() == 12) self.assertTrue(g.is_directed()) self.assertTrue( sorted(g.get_edgelist()) == [ (0, 1), (0, 2), (0, 3), (1, 0), (1, 4), (2, 0), (2, 3), (3, 0), (3, 2), (3, 4), (4, 1), (4, 3), ] ) with temporary_file( """\ DL n=5 format = edgelist1 labels: george, sally, jim, billy, jane labels embedded: data: george sally 2 george jim 3 sally jim 4 billy george 5 jane jim 6 """ ) as tmpfname: g = Graph.Read_DL(tmpfname, False) self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 5 and g.ecount() == 5) self.assertTrue(not g.is_directed()) self.assertTrue( sorted(g.get_edgelist()) == [(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)] ) def _testNCOLOrLGL(self, func, fname, can_be_reopened=True): g = func(fname, names=False, weights=False, directed=False) self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 4 and g.ecount() == 5) self.assertTrue(not g.is_directed()) self.assertTrue( sorted(g.get_edgelist()) == [(0, 1), (0, 2), (1, 1), (1, 3), (2, 3)] ) self.assertTrue( "name" not in g.vertex_attributes() and "weight" not in g.edge_attributes() ) if not can_be_reopened: return g = func(fname, names=False, directed=False) self.assertTrue( "name" not in g.vertex_attributes() and "weight" in g.edge_attributes() ) self.assertTrue(g.es["weight"] == [1, 2, 0, 3, 0]) g = func(fname, directed=False) self.assertTrue( "name" in g.vertex_attributes() and "weight" in g.edge_attributes() ) self.assertTrue(g.vs["name"] == ["eggs", "spam", "ham", "bacon"]) self.assertTrue(g.es["weight"] == [1, 2, 0, 3, 0]) def testNCOL(self): with temporary_file( """\ eggs spam 1 ham eggs 2 ham bacon bacon spam 3 spam spam""" ) as tmpfname: self._testNCOLOrLGL(func=Graph.Read_Ncol, fname=tmpfname) with temporary_file( """\ eggs spam ham eggs ham bacon bacon spam spam spam""" ) as tmpfname: g = Graph.Read_Ncol(tmpfname) self.assertTrue( "name" in g.vertex_attributes() and "weight" not in g.edge_attributes() ) @unittest.skipIf(pd is None, "test case depends on Pandas") def testNCOLWithDataFrame(self): # Regression test for https://github.com/igraph/python-igraph/issues/446 from pandas import DataFrame df = DataFrame({'from': [1, 2], 'to': [2, 3]}) self.assertRaises(TypeError, Graph.Read_Ncol, df) def testLGL(self): with temporary_file( """\ # eggs spam 1 # ham eggs 2 bacon # bacon spam 3 # spam spam""" ) as tmpfname: self._testNCOLOrLGL(func=Graph.Read_Lgl, fname=tmpfname) with temporary_file( """\ # eggs spam # ham eggs bacon # bacon spam # spam spam""" ) as tmpfname: with warnings.catch_warnings(): warnings.simplefilter("ignore") g = Graph.Read_Lgl(tmpfname) self.assertTrue( "name" in g.vertex_attributes() and "weight" not in g.edge_attributes() ) # This is not an LGL file; we are testing error handling here with temporary_file( """\ 1 2 1 3 """ ) as tmpfname: with self.assertRaises(InternalError): Graph.Read_Lgl(tmpfname) def testLGLWithIOModule(self): with temporary_file( """\ # eggs spam 1 # ham eggs 2 bacon # bacon spam 3 # spam spam""" ) as tmpfname: with io.open(tmpfname, "r") as fp: self._testNCOLOrLGL( func=Graph.Read_Lgl, fname=fp, can_be_reopened=False ) def testAdjacency(self): with temporary_file( """\ # Test comment line 0 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 2 2 0 0 0 2 0 2 0 0 0 2 2 0 """ ) as tmpfname: g = Graph.Read_Adjacency(tmpfname) self.assertTrue(isinstance(g, Graph)) self.assertTrue( g.vcount() == 6 and g.ecount() == 18 and g.is_directed() and "weight" not in g.edge_attributes() ) g = Graph.Read_Adjacency(tmpfname, attribute="weight") self.assertTrue(isinstance(g, Graph)) self.assertTrue( g.vcount() == 6 and g.ecount() == 12 and g.is_directed() and g.es["weight"] == [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2] ) g.write_adjacency(tmpfname) def testGraphML(self): with temporary_file(GRAPHML_EXAMPLE_FILE) as tmpfname: try: g = Graph.Read_GraphML(tmpfname) except NotImplementedError as e: self.skipTest(str(e)) self.assertTrue(isinstance(g, Graph)) self.assertEqual(g.vcount(), 6) self.assertEqual(g.ecount(), 7) self.assertFalse(g.is_directed()) self.assertTrue("name" in g.vertex_attributes()) g.write_graphml(tmpfname) def testGraphMLz(self): with temporary_file(gzip.compress(GRAPHML_EXAMPLE_FILE.encode("utf-8"))) as tmpfname: try: g = Graph.Read_GraphMLz(tmpfname) except NotImplementedError as e: self.skipTest(str(e)) self.assertTrue(isinstance(g, Graph)) self.assertEqual(g.vcount(), 6) self.assertEqual(g.ecount(), 7) self.assertFalse(g.is_directed()) self.assertTrue("name" in g.vertex_attributes()) def testPickle(self): pickle = [ 128, 2, 99, 105, 103, 114, 97, 112, 104, 10, 71, 114, 97, 112, 104, 10, 113, 1, 40, 75, 3, 93, 113, 2, 75, 1, 75, 2, 134, 113, 3, 97, 137, 125, 125, 125, 116, 82, 113, 4, 125, 98, 46, ] pickle = bytes(pickle) with temporary_file(pickle, "wb", binary=True) as tmpfname: g = Graph.Read_Pickle(pickle) self.assertTrue(isinstance(g, Graph)) self.assertTrue(g.vcount() == 3 and g.ecount() == 1 and not g.is_directed()) g.write_pickle(tmpfname) @unittest.skipIf(pd is None, "test case depends on Pandas") def testVertexDataFrames(self): g = Graph([(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)]) # No vertex names, no attributes df = g.get_vertex_dataframe() self.assertEqual(df.shape, (5, 0)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) # Vertex names, no attributes g.vs["name"] = ["eggs", "spam", "ham", "bacon", "yello"] df = g.get_vertex_dataframe() self.assertEqual(df.shape, (5, 1)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(list(df["name"]), g.vs["name"]) self.assertEqual(list(df.columns), ["name"]) # Vertex names and attributes (common case) g.vs["weight"] = [0, 5, 1, 4, 42] df = g.get_vertex_dataframe() self.assertEqual(df.shape, (5, 2)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(list(df["name"]), g.vs["name"]) self.assertEqual(set(df.columns), set(["name", "weight"])) self.assertEqual(list(df["weight"]), g.vs["weight"]) # No vertex names, with attributes (common case) g = Graph([(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)]) g.vs["weight"] = [0, 5, 1, 4, 42] df = g.get_vertex_dataframe() self.assertEqual(df.shape, (5, 1)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(list(df.columns), ["weight"]) self.assertEqual(list(df["weight"]), g.vs["weight"]) @unittest.skipIf(pd is None, "test case depends on Pandas") def testEdgeDataFrames(self): g = Graph([(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)]) # No edge names, no attributes df = g.get_edge_dataframe() self.assertEqual(df.shape, (5, 2)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(list(df.columns), ["source", "target"]) # Edge names, no attributes g.es["name"] = ["my", "list", "of", "five", "edges"] df = g.get_edge_dataframe() self.assertEqual(df.shape, (5, 3)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(list(df["name"]), g.es["name"]) self.assertEqual(set(df.columns), set(["source", "target", "name"])) # No edge names, with attributes g = Graph([(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)]) g.es["weight"] = [6, -0.4, 0, 1, 3] df = g.get_edge_dataframe() self.assertEqual(df.shape, (5, 3)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual(set(df.columns), set(["source", "target", "weight"])) self.assertEqual(list(df["weight"]), g.es["weight"]) # Edge names, with weird attributes g.es["name"] = ["my", "list", "of", "five", "edges"] g.es["weight"] = [6, -0.4, 0, 1, 3] g.es["source"] = ["this", "is", "a", "little", "tricky"] df = g.get_edge_dataframe() self.assertEqual(df.shape, (5, 5)) self.assertEqual(list(df.index), [0, 1, 2, 3, 4]) self.assertEqual( set(df.columns), set(["source", "target", "name", "source", "weight"]) ) self.assertEqual(list(df["name"]), g.es["name"]) self.assertEqual(list(df["weight"]), g.es["weight"]) i = 2 + list(df.columns[2:]).index("source") self.assertEqual(list(df.iloc[:, i]), g.es["source"]) @unittest.skipIf(nx is None, "test case depends on networkx") def testGraphNetworkx(self): # Undirected g = Graph.Ring(10) g["gattr"] = "graph_attribute" g.vs["vattr"] = list(range(g.vcount())) g.es["eattr"] = list(range(len(g.es))) # Go to networkx and back g_nx = g.to_networkx() g2 = Graph.from_networkx(g_nx) self.assertFalse(g2.is_directed()) self.assertTrue(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) # Test attributes self.assertEqual(g.attributes(), g2.attributes()) self.assertEqual(sorted(["vattr", "_nx_name"]), sorted(g2.vertex_attributes())) for i, vertex in enumerate(g.vs): vertex2 = g2.vs[i] for an in vertex.attribute_names(): if an == "vattr": continue self.assertEqual(vertex.attributes()[an], vertex2.attributes()[an]) self.assertEqual(g.edge_attributes(), g2.edge_attributes()) for edge in g.es: eid = g2.get_eid(edge.source, edge.target) edge2 = g2.es[eid] for an in edge.attribute_names(): self.assertEqual(edge.attributes()[an], edge2.attributes()[an]) # Directed g = Graph.Ring(10, directed=True) # Go to networkx and back g_nx = g.to_networkx() g2 = Graph.from_networkx(g_nx) self.assertTrue(g2.is_directed()) self.assertTrue(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) @unittest.skipIf(nx is None, "test case depends on networkx") def testMultigraphNetworkx(self): # Undirected g = Graph.Ring(10) g.add_edge(0, 1) g["gattr"] = "graph_attribute" g.vs["vattr"] = list(range(g.vcount())) g.es["eattr"] = list(range(len(g.es))) # Go to networkx and back g_nx = g.to_networkx() g2 = Graph.from_networkx(g_nx) self.assertFalse(g2.is_directed()) self.assertFalse(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) # Test attributes self.assertEqual(g.attributes(), g2.attributes()) self.assertEqual(sorted(["vattr", "_nx_name"]), sorted(g2.vertex_attributes())) self.assertEqual(g.edge_attributes(), g2.edge_attributes()) # Testing parallel edges is a bit more tricky edge2_found = set() for edge in g.es: # Go through all parallel edges between these two vertices for edge2 in g2.es: if edge2 in edge2_found: continue if edge.source != edge2.source: continue if edge.target != edge2.target: continue # Check all attributes between these two for an in edge.attribute_names(): if edge.attributes()[an] != edge2.attributes()[an]: break else: # Correspondence found edge2_found.add(edge2) break else: self.assertTrue(False) # Directed g = Graph.Ring(10, directed=True) g.add_edge(0, 1) # Go to networkx and back g_nx = g.to_networkx() g2 = Graph.from_networkx(g_nx) self.assertTrue(g2.is_directed()) self.assertFalse(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) @unittest.skipIf(gt is None, "test case depends on graph-tool") def testGraphGraphTool(self): # Undirected g = Graph.Ring(10) g["gattr"] = "graph_attribute" g.vs["vattr"] = list(range(g.vcount())) g.es["eattr"] = list(range(len(g.es))) # Go to graph-tool and back g_gt = g.to_graph_tool( graph_attributes={"gattr": "object"}, vertex_attributes={"vattr": "int"}, edge_attributes={"eattr": "int"}, ) g2 = Graph.from_graph_tool(g_gt) self.assertFalse(g2.is_directed()) self.assertTrue(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) # Test attributes self.assertEqual(g.attributes(), g2.attributes()) self.assertEqual(g.vertex_attributes(), g2.vertex_attributes()) for i, vertex in enumerate(g.vs): vertex2 = g2.vs[i] for an in vertex.attribute_names(): self.assertEqual(vertex.attributes()[an], vertex2.attributes()[an]) self.assertEqual(g.edge_attributes(), g2.edge_attributes()) for edge in g.es: eid = g2.get_eid(edge.source, edge.target) edge2 = g2.es[eid] for an in edge.attribute_names(): self.assertEqual(edge.attributes()[an], edge2.attributes()[an]) # Directed g = Graph.Ring(10, directed=True) # Go to graph-tool and back g_gt = g.to_graph_tool() g2 = Graph.from_graph_tool(g_gt) self.assertTrue(g2.is_directed()) self.assertTrue(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) @unittest.skipIf(gt is None, "test case depends on graph-tool") def testMultigraphGraphTool(self): # Undirected g = Graph.Ring(10) g.add_edge(0, 1) g["gattr"] = "graph_attribute" g.vs["vattr"] = list(range(g.vcount())) g.es["eattr"] = list(range(len(g.es))) # Go to graph-tool and back g_gt = g.to_graph_tool( graph_attributes={"gattr": "object"}, vertex_attributes={"vattr": "int"}, edge_attributes={"eattr": "int"}, ) g2 = Graph.from_graph_tool(g_gt) self.assertFalse(g2.is_directed()) self.assertFalse(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) # Test attributes self.assertEqual(g.attributes(), g2.attributes()) self.assertEqual(g.vertex_attributes(), g2.vertex_attributes()) for i, vertex in enumerate(g.vs): vertex2 = g2.vs[i] for an in vertex.attribute_names(): self.assertEqual(vertex.attributes()[an], vertex2.attributes()[an]) self.assertEqual(g.edge_attributes(), g2.edge_attributes()) # Testing parallel edges is a bit more tricky edge2_found = set() for edge in g.es: # Go through all parallel edges between these two vertices for edge2 in g2.es: if edge2 in edge2_found: continue if edge.source != edge2.source: continue if edge.target != edge2.target: continue # Check all attributes between these two for an in edge.attribute_names(): if edge.attributes()[an] != edge2.attributes()[an]: break else: # Correspondence found edge2_found.add(edge2) break else: self.assertTrue(False) # Directed g = Graph.Ring(10, directed=True) g.add_edge(0, 1) # Go to graph-tool and back g_gt = g.to_graph_tool() g2 = Graph.from_graph_tool(g_gt) self.assertTrue(g2.is_directed()) self.assertFalse(g2.is_simple()) self.assertEqual(g.vcount(), g2.vcount()) self.assertEqual(sorted(g.get_edgelist()), sorted(g2.get_edgelist())) def suite(): foreign_suite = unittest.makeSuite(ForeignTests) return unittest.TestSuite([foreign_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_games.py0000644000175100001710000001653400000000000017463 0ustar00runnerdocker00000000000000import unittest from igraph import * class GameTests(unittest.TestCase): def testGRG(self): g = Graph.GRG(50, 0.2) self.assertTrue(isinstance(g, Graph)) g = Graph.GRG(50, 0.2, True) self.assertTrue(isinstance(g, Graph)) self.assertTrue("x" in g.vertex_attributes()) self.assertTrue("y" in g.vertex_attributes()) self.assertTrue(isinstance(Layout(list(zip(g.vs["x"], g.vs["y"]))), Layout)) def testForestFire(self): g = Graph.Forest_Fire(100, 0.1) self.assertTrue(isinstance(g, Graph) and g.is_directed() is False) g = Graph.Forest_Fire(100, 0.1, directed=True) self.assertTrue(isinstance(g, Graph) and g.is_directed() is True) def testRecentDegree(self): g = Graph.Recent_Degree(100, 5, 10) self.assertTrue(isinstance(g, Graph)) def testPreference(self): g = Graph.Preference(100, [1, 1], [[1, 0], [0, 1]]) self.assertTrue(isinstance(g, Graph) and len(g.clusters()) == 2) g = Graph.Preference(100, [1, 1], [[1, 0], [0, 1]], attribute="type") l = g.vs.get_attribute_values("type") self.assertTrue(min(l) == 0 and max(l) == 1) def testAsymmetricPreference(self): g = Graph.Asymmetric_Preference(100, [[0, 1], [1, 0]], [[0, 1], [1, 0]]) self.assertTrue(isinstance(g, Graph) and len(g.clusters()) == 2) g = Graph.Asymmetric_Preference( 100, [[0, 1], [1, 0]], [[1, 0], [0, 1]], attribute="type" ) l = g.vs.get_attribute_values("type") l1 = [i[0] for i in l] l2 = [i[1] for i in l] self.assertTrue(min(l1) == 0 and max(l1) == 1 and min(l2) == 0 and max(l2) == 1) g = Graph.Asymmetric_Preference(100, [[0, 1], [1, 0]], [[1, 0], [0, 1]]) self.assertTrue(isinstance(g, Graph) and len(g.clusters()) == 1) def testTreeGame(self): # Prufer algorithm g = Graph.Tree_Game(10, False, "Prufer") self.assertTrue(isinstance(g, Graph) and g.vcount() == 10) self.assertFalse(g.is_directed()) self.assertTrue(g.is_tree()) # Prufer with directed (should fail) self.assertRaises(InternalError, Graph.Tree_Game, 10, True, "Prufer") # LERW algorithm g = Graph.Tree_Game(10, False, "lerw") self.assertTrue(isinstance(g, Graph) and g.vcount() == 10) self.assertFalse(g.is_directed()) self.assertTrue(g.is_tree()) # Omitting the algorithm should default to LERW g = Graph.Tree_Game(10, directed=True) self.assertTrue(isinstance(g, Graph) and g.vcount() == 10) self.assertTrue(g.is_directed()) self.assertTrue(g.is_tree()) # Omitting the directed argument should use undirected graphs g = Graph.Tree_Game(42, method="Prufer") self.assertTrue(isinstance(g, Graph) and g.vcount() == 42) self.assertFalse(g.is_directed()) self.assertTrue(g.is_tree()) def testWattsStrogatz(self): g = Graph.Watts_Strogatz(1, 20, 1, 0.2) self.assertTrue(isinstance(g, Graph) and g.vcount() == 20 and g.ecount() == 20) def testRandomBipartiteNP(self): # Test np mode, undirected g = Graph.Random_Bipartite(10, 20, p=0.25) self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertFalse(g.is_directed()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) # Test np mode, directed, "out" g = Graph.Random_Bipartite(10, 20, p=0.25, directed=True, neimode="out") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) self.assertTrue(all(g.vs[e.tuple]["type"] == [False, True] for e in g.es)) # Test np mode, directed, "in" g = Graph.Random_Bipartite(10, 20, p=0.25, directed=True, neimode="in") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) self.assertTrue(all(g.vs[e.tuple]["type"] == [True, False] for e in g.es)) # Test np mode, directed, "all" g = Graph.Random_Bipartite(10, 20, p=0.25, directed=True, neimode="all") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) def testRandomBipartiteNM(self): # Test np mode, undirected g = Graph.Random_Bipartite(10, 20, m=50) self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertFalse(g.is_directed()) self.assertEqual(50, g.ecount()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) # Test np mode, directed, "out" g = Graph.Random_Bipartite(10, 20, m=50, directed=True, neimode="out") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual(50, g.ecount()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) self.assertTrue(all(g.vs[e.tuple]["type"] == [False, True] for e in g.es)) # Test np mode, directed, "in" g = Graph.Random_Bipartite(10, 20, m=50, directed=True, neimode="in") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual(50, g.ecount()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) self.assertTrue(all(g.vs[e.tuple]["type"] == [True, False] for e in g.es)) # Test np mode, directed, "all" g = Graph.Random_Bipartite(10, 20, m=50, directed=True, neimode="all") self.assertTrue(g.is_simple()) self.assertTrue(g.is_bipartite()) self.assertTrue(g.is_directed()) self.assertEqual(50, g.ecount()) self.assertEqual([False] * 10 + [True] * 20, g.vs["type"]) def testRewire(self): # Undirected graph g = Graph.GRG(25, 0.4) degrees = g.degree() # Rewiring without loops g.rewire(10000) self.assertEqual(degrees, g.degree()) self.assertTrue(g.is_simple()) # Rewiring with loops (1) g.rewire(10000, mode="loops") self.assertEqual(degrees, g.degree()) self.assertFalse(any(g.is_multiple())) # Rewiring with loops (2) g = Graph.Full(4) g[1, 3] = 0 degrees = g.degree() g.rewire(100, mode="loops") self.assertEqual(degrees, g.degree()) self.assertFalse(any(g.is_multiple())) # Directed graph g = Graph.GRG(25, 0.4) g.to_directed("mutual") indeg, outdeg = g.indegree(), g.outdegree() g.rewire(10000) self.assertEqual(indeg, g.indegree()) self.assertEqual(outdeg, g.outdegree()) self.assertTrue(g.is_simple()) # Directed graph with loops g.rewire(10000, mode="loops") self.assertEqual(indeg, g.indegree()) self.assertEqual(outdeg, g.outdegree()) self.assertFalse(any(g.is_multiple())) def suite(): game_suite = unittest.makeSuite(GameTests) return unittest.TestSuite([game_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_generators.py0000644000175100001710000004350700000000000020540 0ustar00runnerdocker00000000000000import unittest from igraph import Graph, InternalError try: import numpy as np except ImportError: np = None try: import scipy.sparse as sparse except ImportError: sparse = None try: import pandas as pd except ImportError: pd = None class GeneratorTests(unittest.TestCase): def testStar(self): g = Graph.Star(5, "in") el = [(1, 0), (2, 0), (3, 0), (4, 0)] self.assertTrue(g.is_directed()) self.assertTrue(g.get_edgelist() == el) g = Graph.Star(5, "out", center=2) el = [(2, 0), (2, 1), (2, 3), (2, 4)] self.assertTrue(g.is_directed()) self.assertTrue(g.get_edgelist() == el) g = Graph.Star(5, "mutual", center=2) el = [(0, 2), (1, 2), (2, 0), (2, 1), (2, 3), (2, 4), (3, 2), (4, 2)] self.assertTrue(g.is_directed()) self.assertTrue(sorted(g.get_edgelist()) == el) g = Graph.Star(5, center=3) el = [(0, 3), (1, 3), (2, 3), (3, 4)] self.assertTrue(not g.is_directed()) self.assertTrue(sorted(g.get_edgelist()) == el) def testFamous(self): g = Graph.Famous("tutte") self.assertTrue(g.vcount() == 46 and g.ecount() == 69) self.assertRaises(InternalError, Graph.Famous, "unknown") def testFormula(self): tests = [ (None, [], []), ("", [""], []), ("A", ["A"], []), ("A-B", ["A", "B"], [(0, 1)]), ("A --- B", ["A", "B"], [(0, 1)]), ( "A--B, C--D, E--F, G--H, I, J, K", ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"], [(0, 1), (2, 3), (4, 5), (6, 7)], ), ( "A:B:C:D -- A:B:C:D", ["A", "B", "C", "D"], [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)], ), ("A -> B -> C", ["A", "B", "C"], [(0, 1), (1, 2)]), ("A <- B -> C", ["A", "B", "C"], [(1, 0), (1, 2)]), ("A <- B -- C", ["A", "B", "C"], [(1, 0)]), ( "A <-> B <---> C <> D", ["A", "B", "C", "D"], [(0, 1), (1, 0), (1, 2), (2, 1), (2, 3), (3, 2)], ), ( "'this is' <- 'a silly' -> 'graph here'", ["this is", "a silly", "graph here"], [(1, 0), (1, 2)], ), ( "Alice-Bob-Cecil-Alice, Daniel-Cecil-Eugene, Cecil-Gordon", ["Alice", "Bob", "Cecil", "Daniel", "Eugene", "Gordon"], [(0, 1), (1, 2), (0, 2), (2, 3), (2, 4), (2, 5)], ), ( "Alice-Bob:Cecil:Daniel, Cecil:Daniel-Eugene:Gordon", ["Alice", "Bob", "Cecil", "Daniel", "Eugene", "Gordon"], [(0, 1), (0, 2), (0, 3), (2, 4), (2, 5), (3, 4), (3, 5)], ), ( "Alice <-> Bob --> Cecil <-- Daniel, Eugene --> Gordon:Helen", ["Alice", "Bob", "Cecil", "Daniel", "Eugene", "Gordon", "Helen"], [(0, 1), (1, 0), (1, 2), (3, 2), (4, 5), (4, 6)], ), ( "Alice -- Bob -- Daniel, Cecil:Gordon, Helen", ["Alice", "Bob", "Daniel", "Cecil", "Gordon", "Helen"], [(0, 1), (1, 2)], ), ( '"+" -- "-", "*" -- "/", "%%" -- "%/%"', ["+", "-", "*", "/", "%%", "%/%"], [(0, 1), (2, 3), (4, 5)], ), ("A-B-C\nC-D", ["A", "B", "C", "D"], [(0, 1), (1, 2), (2, 3)]), ("A-B-C\n C-D", ["A", "B", "C", "D"], [(0, 1), (1, 2), (2, 3)]), ] for formula, names, edges in tests: g = Graph.Formula(formula) self.assertEqual(g.vs["name"], names) self.assertEqual(g.get_edgelist(), sorted(edges)) def testFull(self): g = Graph.Full(20, directed=True) el = g.get_edgelist() el.sort() self.assertTrue( g.get_edgelist() == [(x, y) for x in range(20) for y in range(20) if x != y] ) def testFullCitation(self): g = Graph.Full_Citation(20) el = g.get_edgelist() el.sort() self.assertTrue(not g.is_directed()) self.assertTrue(el == [(x, y) for x in range(19) for y in range(x + 1, 20)]) g = Graph.Full_Citation(20, True) el = g.get_edgelist() el.sort() self.assertTrue(g.is_directed()) self.assertTrue(el == [(x, y) for x in range(1, 20) for y in range(x)]) self.assertRaises(InternalError, Graph.Full_Citation, -2) def testLCF(self): g1 = Graph.LCF(12, (5, -5), 6) g2 = Graph.Famous("Franklin") self.assertTrue(g1.isomorphic(g2)) self.assertRaises(InternalError, Graph.LCF, 12, (5, -5), -3) def testRealizeDegreeSequence(self): # Test case insensitivity of options too g = Graph.Realize_Degree_Sequence( [1, 1], None, "simPLE", "smallest", ) self.assertFalse(g.is_directed()) self.assertTrue(g.degree() == [1, 1]) # Not implemented, should fail self.assertRaises( NotImplementedError, Graph.Realize_Degree_Sequence, [1, 1], None, "loops", "largest" ) g = Graph.Realize_Degree_Sequence( [1, 1], None, "all", "largest", ) self.assertFalse(g.is_directed()) self.assertTrue(g.degree() == [1, 1]) g = Graph.Realize_Degree_Sequence( [1, 1], None, "multi", "index", ) self.assertFalse(g.is_directed()) self.assertTrue(g.degree() == [1, 1]) g = Graph.Realize_Degree_Sequence( [1, 1], [1, 1], "simple", "largest", ) self.assertTrue(g.is_directed()) self.assertTrue(g.indegree() == [1, 1]) self.assertTrue(g.outdegree() == [1, 1]) # Not implemented, should fail self.assertRaises( NotImplementedError, Graph.Realize_Degree_Sequence, [1, 1], [1, 1], "multi", "largest" ) self.assertRaises( ValueError, Graph.Realize_Degree_Sequence, [1, 1], [1, 1], "should_fail", "index" ) self.assertRaises( ValueError, Graph.Realize_Degree_Sequence, [1, 1], [1, 1], "multi", "should_fail" ) # Degree sequence of Zachary karate club, using optional arguments zachary = Graph.Famous("zachary") degrees = zachary.degree() g = Graph.Realize_Degree_Sequence(degrees) self.assertFalse(g.is_directed()) self.assertTrue(g.degree() == degrees) def testKautz(self): g = Graph.Kautz(2, 2) deg_in = g.degree(mode="in") deg_out = g.degree(mode="out") # This is not a proper test, but should spot most errors self.assertTrue(g.is_directed() and deg_in == [2] * 12 and deg_out == [2] * 12) def testDeBruijn(self): g = Graph.De_Bruijn(2, 3) deg_in = g.degree(mode="in", loops=True) deg_out = g.degree(mode="out", loops=True) # This is not a proper test, but should spot most errors self.assertTrue(g.is_directed() and deg_in == [2] * 8 and deg_out == [2] * 8) def testSBM(self): pref_matrix = [[0.5, 0, 0], [0, 0, 0.5], [0, 0.5, 0]] n = 60 types = [20, 20, 20] g = Graph.SBM(n, pref_matrix, types) # Simple smoke tests for the expected structure of the graph self.assertTrue(g.is_simple()) self.assertFalse(g.is_directed()) self.assertEqual([0] * 20 + [1] * 40, g.clusters().membership) g2 = g.subgraph(list(range(20, 60))) self.assertTrue(not any(e.source // 20 == e.target // 20 for e in g2.es)) # Check loops argument g = Graph.SBM(n, pref_matrix, types, loops=True) self.assertFalse(g.is_simple()) self.assertTrue(sum(g.is_loop()) > 0) # Check directedness g = Graph.SBM(n, pref_matrix, types, directed=True) self.assertTrue(g.is_directed()) self.assertTrue(sum(g.is_mutual()) < g.ecount()) self.assertTrue(sum(g.is_loop()) == 0) # Check error conditions self.assertRaises(InternalError, Graph.SBM, -1, pref_matrix, types) self.assertRaises(InternalError, Graph.SBM, 61, pref_matrix, types) pref_matrix[0][1] = 0.7 self.assertRaises(InternalError, Graph.SBM, 60, pref_matrix, types) @unittest.skipIf(np is None, "test case depends on NumPy") def testAdjacencyNumPy(self): mat = np.array( [[0, 1, 1, 0], [1, 0, 0, 0], [0, 0, 2, 0], [0, 1, 0, 0]], ) # ADJ_DIRECTED (default) g = Graph.Adjacency(mat) el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (2, 2), (2, 2), (3, 1)]) # ADJ MIN g = Graph.Adjacency(mat, mode="min") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (2, 2), (2, 2)]) # ADJ LOWER g = Graph.Adjacency(mat, mode="lower") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (2, 2), (2, 2), (1, 3)]) @unittest.skipIf( (sparse is None) or (np is None), "test case depends on NumPy/SciPy" ) def testSparseAdjacency(self): mat = sparse.coo_matrix( [[0, 1, 1, 0], [1, 0, 0, 0], [0, 0, 2, 0], [0, 1, 0, 0]], ) # ADJ_DIRECTED (default) g = Graph.Adjacency(mat) el = g.get_edgelist() self.assertTrue(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (2, 2), (2, 2), (3, 1)]) # ADJ MIN g = Graph.Adjacency(mat, mode="min") el = g.get_edgelist() self.assertFalse(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (2, 2), (2, 2)]) # ADJ LOWER g = Graph.Adjacency(mat, mode="lower") el = g.get_edgelist() self.assertFalse(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (2, 2), (2, 2), (1, 3)]) def testWeightedAdjacency(self): mat = [[0, 1, 2, 0], [2, 0, 0, 0], [0, 0, 2.5, 0], [0, 1, 0, 0]] g = Graph.Weighted_Adjacency(mat, attr="w0") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (2, 2), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 2.5, 1]) g = Graph.Weighted_Adjacency(mat, mode="plus") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 3), (2, 2)]) self.assertTrue(g.es["weight"] == [3, 2, 1, 2.5]) g = Graph.Weighted_Adjacency(mat, attr="w0", loops=False) el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 1]) @unittest.skipIf(np is None, "test case depends on NumPy") def testWeightedAdjacencyNumPy(self): mat = np.array( [[0, 1, 2, 0], [2, 0, 0, 0], [0, 0, 2.5, 0], [0, 1, 0, 0]], ) g = Graph.Weighted_Adjacency(mat, attr="w0") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (2, 2), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 2.5, 1]) g = Graph.Weighted_Adjacency(mat, mode="plus") el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 3), (2, 2)]) self.assertTrue(g.es["weight"] == [3, 2, 1, 2.5]) g = Graph.Weighted_Adjacency(mat, attr="w0", loops=False) el = g.get_edgelist() self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 1]) @unittest.skipIf( (sparse is None) or (np is None), "test case depends on NumPy/SciPy" ) def testSparseWeighedAdjacency(self): mat = sparse.coo_matrix( [[0, 1, 2, 0], [2, 0, 0, 0], [0, 0, 2.5, 0], [0, 1, 0, 0]] ) g = Graph.Weighted_Adjacency(mat, attr="w0") el = g.get_edgelist() self.assertTrue(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (2, 2), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 2.5, 1]) g = Graph.Weighted_Adjacency(mat, mode="plus") el = g.get_edgelist() self.assertFalse(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (0, 2), (2, 2), (1, 3)]) self.assertTrue(g.es["weight"] == [3, 2, 2.5, 1]) g = Graph.Weighted_Adjacency(mat, mode="min") el = g.get_edgelist() self.assertFalse(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (2, 2)]) self.assertTrue(g.es["weight"] == [1, 2.5]) g = Graph.Weighted_Adjacency(mat, attr="w0", loops=False) el = g.get_edgelist() self.assertTrue(g.is_directed()) self.assertEqual(4, g.vcount()) self.assertTrue(el == [(0, 1), (0, 2), (1, 0), (3, 1)]) self.assertTrue(g.es["w0"] == [1, 2, 2, 1]) @unittest.skipIf((np is None) or (pd is None), "test case depends on NumPy/Pandas") def testDataFrame(self): edges = pd.DataFrame( [["C", "A", 0.4], ["A", "B", 0.1]], columns=[0, 1, "weight"] ) g = Graph.DataFrame(edges, directed=False) self.assertTrue(g.es["weight"] == [0.4, 0.1]) vertices = pd.DataFrame( [["A", "blue"], ["B", "yellow"], ["C", "blue"]], columns=[0, "color"] ) g = Graph.DataFrame(edges, directed=True, vertices=vertices) self.assertTrue(g.vs["name"] == ["A", "B", "C"]) self.assertTrue(g.vs["color"] == ["blue", "yellow", "blue"]) self.assertTrue(g.es["weight"] == [0.4, 0.1]) # Issue #347 edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame( {"node": [1, 2, 3, 4, 5, 6], "label": ["1", "2", "3", "4", "5", "6"]} )[["node", "label"]] g = Graph.DataFrame( edges, directed=True, vertices=vertices ) self.assertTrue(g.vs["name"] == [1, 2, 3, 4, 5, 6]) self.assertTrue(g.vs["label"] == ["1", "2", "3", "4", "5", "6"]) # Vertex ids edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) g = Graph.DataFrame(edges) self.assertTrue(g.vcount() == 6) edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) g = Graph.DataFrame(edges, use_vids=True) self.assertTrue(g.vcount() == 7) # Graph clone g = Graph.Full(n=100, directed=True, loops=True) g.vs["name"] = [f"v{i}" for i in range(g.vcount())] g.vs["x"] = [float(i) for i in range(g.vcount())] g.es["w"] = [1.0] * g.ecount() df_edges = g.get_edge_dataframe() df_vertices = g.get_vertex_dataframe() g_clone = Graph.DataFrame(df_edges, g.is_directed(), df_vertices, True) self.assertTrue(df_edges.equals(g_clone.get_edge_dataframe())) self.assertTrue(df_vertices.equals(g_clone.get_vertex_dataframe())) # Invalid input with self.assertRaisesRegex(ValueError, "two columns"): edges = pd.DataFrame({"source": [1, 2, 3]}) Graph.DataFrame(edges) with self.assertRaisesRegex(ValueError, "one column"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) Graph.DataFrame(edges, vertices=pd.DataFrame()) with self.assertRaisesRegex(TypeError, "integers"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}).astype(str) Graph.DataFrame(edges, use_vids=True) with self.assertRaisesRegex(ValueError, "negative"): edges = -pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) Graph.DataFrame(edges, use_vids=True) with self.assertRaisesRegex(TypeError, "integers"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3]}, index=["1", "2", "3"]) Graph.DataFrame(edges, vertices=vertices, use_vids=True) with self.assertRaisesRegex(ValueError, "negative"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3]}, index=[-1, 2, 3]) Graph.DataFrame(edges, vertices=vertices, use_vids=True) with self.assertRaisesRegex(ValueError, "sequence"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3]}, index=[1, 2, 4]) Graph.DataFrame(edges, vertices=vertices, use_vids=True) with self.assertRaisesRegex(TypeError, "integers"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3]}, index=pd.MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)])) Graph.DataFrame(edges, vertices=vertices, use_vids=True) with self.assertRaisesRegex(ValueError, "unique"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 2]}) Graph.DataFrame(edges, vertices=vertices) with self.assertRaisesRegex(ValueError, "already contains"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3], "name": [1, 2, 2]}) Graph.DataFrame(edges, vertices=vertices) with self.assertRaisesRegex(ValueError, "missing from"): edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}) vertices = pd.DataFrame({0: [1, 2, 3]}, index=[0, 1, 2]) Graph.DataFrame(edges, vertices=vertices, use_vids=True) def suite(): generator_suite = unittest.makeSuite(GeneratorTests) return unittest.TestSuite([generator_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_homepage.py0000644000175100001710000000271700000000000020152 0ustar00runnerdocker00000000000000import unittest from igraph import * class HomepageExampleTests(unittest.TestCase): """Smoke tests for the Python examples found on the homepage to ensure that they do not break.""" def testErdosRenyiComponents(self): g = Graph.Erdos_Renyi(n=300, m=250) colors = ["lightgray", "cyan", "magenta", "yellow", "blue", "green", "red"] components = g.components() for component in components: color = colors[min(6, len(components) - 1)] g.vs[component]["color"] = color # No plotting here, but we calculate the FR layout fr = g.layout("fr") def testKautz(self): g = Graph.Kautz(m=3, n=2) adj = g.get_adjacency() # Plotting omitted def testMSTofGRG(self): def distance(p1, p2): return ((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) ** 0.5 g = Graph.GRG(100, 0.2) layout = Layout(list(zip(g.vs["x"], g.vs["y"]))) weights = [distance(layout[edge.source], layout[edge.target]) for edge in g.es] max_weight = max(weights) g.es["width"] = [6 - 5 * weight / max_weight for weight in weights] mst = g.spanning_tree(weights) # Plotting omitted def suite(): homepage_example_suite = unittest.makeSuite(HomepageExampleTests) return unittest.TestSuite([homepage_example_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_indexing.py0000644000175100001710000000354200000000000020167 0ustar00runnerdocker00000000000000# vim:ts=4 sw=4 sts=4: import unittest from igraph import * class GraphAdjacencyMatrixLikeIndexingTests(unittest.TestCase): def testSingleEdgeRetrieval(self): g = Graph.Famous("krackhardt_kite") for v1, v2 in g.get_edgelist(): self.assertEqual(g[v1, v2], 1) self.assertEqual(g[v2, v1], 1) for v1 in range(g.vcount()): for v2 in set(range(g.vcount())) - set(g.neighbors(v1)): self.assertEqual(g[v1, v2], 0) self.assertEqual(g[v2, v1], 0) g.add_edge(1, 1) self.assertEqual(g[1, 1], 1) def testSingleEdgeRetrievalWeights(self): g = Graph.Famous("krackhardt_kite") g.es["weight"] = list(range(g.ecount())) for idx, (v1, v2) in enumerate(g.get_edgelist()): self.assertEqual(g[v1, v2], idx) self.assertEqual(g[v2, v1], idx) for v1 in range(g.vcount()): for v2 in set(range(g.vcount())) - set(g.neighbors(v1)): self.assertEqual(g[v1, v2], 0) self.assertEqual(g[v2, v1], 0) def testSingleEdgeRetrievalAttrName(self): g = Graph.Famous("krackhardt_kite") g.es["value"] = list(range(20, g.ecount() + 20)) for idx, (v1, v2) in enumerate(g.get_edgelist()): self.assertEqual(g[v1, v2, "value"], idx + 20) self.assertEqual(g[v2, v1, "value"], idx + 20) for v1 in range(g.vcount()): for v2 in set(range(g.vcount())) - set(g.neighbors(v1)): self.assertEqual(g[v1, v2, "value"], 0) self.assertEqual(g[v2, v1, "value"], 0) def suite(): adjacency_suite = unittest.makeSuite(GraphAdjacencyMatrixLikeIndexingTests) return unittest.TestSuite([adjacency_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_isomorphism.py0000644000175100001710000003427500000000000020742 0ustar00runnerdocker00000000000000import unittest from igraph import * from itertools import permutations from random import shuffle def node_compat(g1, g2, v1, v2): """Node compatibility function for isomorphism tests""" return g1.vs[v1]["color"] == g2.vs[v2]["color"] def edge_compat(g1, g2, e1, e2): """Edge compatibility function for isomorphism tests""" return g1.es[e1]["color"] == g2.es[e2]["color"] class IsomorphismTests(unittest.TestCase): def testIsomorphic(self): g1 = Graph( 8, [ (0, 4), (0, 5), (0, 6), (1, 4), (1, 5), (1, 7), (2, 4), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), ], ) g2 = Graph( 8, [ (0, 1), (0, 3), (0, 4), (2, 3), (2, 1), (2, 6), (5, 1), (5, 4), (5, 6), (7, 3), (7, 6), (7, 4), ], ) # Test the isomorphism of g1 and g2 self.assertTrue(g1.isomorphic(g2)) self.assertTrue( g2.isomorphic_vf2(g1, return_mapping_21=True) == (True, None, [0, 2, 5, 7, 1, 3, 4, 6]) ) self.assertTrue( g2.isomorphic_bliss(g1, return_mapping_21=True, sh1="fl") == (True, None, [0, 2, 5, 7, 1, 3, 4, 6]) ) self.assertRaises(ValueError, g2.isomorphic_bliss, g1, sh2="nonexistent") # Test the automorphy of g1 self.assertTrue(g1.isomorphic()) self.assertTrue( g1.isomorphic_vf2(return_mapping_21=True) == (True, None, [0, 1, 2, 3, 4, 5, 6, 7]) ) # Test VF2 with colors self.assertTrue( g1.isomorphic_vf2( g2, color1=[0, 1, 0, 1, 0, 1, 0, 1], color2=[0, 0, 1, 1, 0, 0, 1, 1] ) ) g1.vs["color"] = [0, 1, 0, 1, 0, 1, 0, 1] g2.vs["color"] = [0, 0, 1, 1, 0, 1, 1, 0] self.assertTrue(not g1.isomorphic_vf2(g2, "color", "color")) # Test bliss with colors self.assertTrue( g1.isomorphic_bliss( g2, color1=[0, 0, 0, 0, 0, 0, 0, 0], color2=[0, 0, 0, 0, 0, 0, 0, 0] ) ) self.assertTrue( g1.isomorphic_bliss( g2, color1=[1, 0, 2, 0, 0, 0, 0, 0], color2=[1, 0, 2, 0, 0, 0, 0, 0] ) ) self.assertTrue( g1.isomorphic_bliss( g2, color1=[0, 1, 0, 1, 0, 1, 0, 1], color2=[0, 0, 1, 1, 0, 0, 1, 1] ) ) # Test VF2 with vertex and edge colors self.assertTrue( g1.isomorphic_vf2( g2, color1=[0, 1, 0, 1, 0, 1, 0, 1], color2=[0, 0, 1, 1, 0, 0, 1, 1] ) ) g1.es["color"] = list(range(12)) g2.es["color"] = [0] * 6 + [1] * 6 self.assertTrue(not g1.isomorphic_vf2(g2, "color", "color", "color", "color")) # Test VF2 with node compatibility function g2.vs["color"] = [0, 0, 1, 1, 0, 0, 1, 1] self.assertTrue(g1.isomorphic_vf2(g2, node_compat_fn=node_compat)) g2.vs["color"] = [0, 0, 1, 1, 0, 1, 1, 0] self.assertTrue(not g1.isomorphic_vf2(g2, node_compat_fn=node_compat)) # Test VF2 with node edge compatibility function g2.vs["color"] = [0, 0, 1, 1, 0, 0, 1, 1] g1.es["color"] = list(range(12)) g2.es["color"] = [0] * 6 + [1] * 6 self.assertTrue( not g1.isomorphic_vf2( g2, node_compat_fn=node_compat, edge_compat_fn=edge_compat ) ) def testIsomorphicCallback(self): maps = [] def callback(g1, g2, map1, map2): maps.append(map1) return True # Test VF2 callback g = Graph(6, [(0, 1), (2, 3), (4, 5), (0, 2), (2, 4), (1, 3), (3, 5)]) g.isomorphic_vf2(g, callback=callback) expected_maps = [ [0, 1, 2, 3, 4, 5], [1, 0, 3, 2, 5, 4], [4, 5, 2, 3, 0, 1], [5, 4, 3, 2, 1, 0], ] self.assertTrue(sorted(maps) == expected_maps) maps[:] = [] g3 = Graph.Full(4) g3.vs["color"] = [0, 1, 1, 0] g3.isomorphic_vf2(callback=callback, color1="color", color2="color") expected_maps = [[0, 1, 2, 3], [0, 2, 1, 3], [3, 1, 2, 0], [3, 2, 1, 0]] self.assertTrue(sorted(maps) == expected_maps) def testCountIsomorphisms(self): g = Graph.Full(4) self.assertTrue(g.count_automorphisms_vf2() == 24) g = Graph(6, [(0, 1), (2, 3), (4, 5), (0, 2), (2, 4), (1, 3), (3, 5)]) self.assertTrue(g.count_automorphisms_vf2() == 4) # Some more tests with colors g3 = Graph.Full(4) g3.vs["color"] = [0, 1, 1, 0] self.assertTrue(g3.count_isomorphisms_vf2() == 24) self.assertTrue(g3.count_isomorphisms_vf2(color1="color", color2="color") == 4) self.assertTrue( g3.count_isomorphisms_vf2(color1=[0, 1, 2, 0], color2=(0, 1, 2, 0)) == 2 ) self.assertTrue( g3.count_isomorphisms_vf2( edge_color1=[0, 1, 0, 0, 0, 1], edge_color2=[0, 1, 0, 0, 0, 1] ) == 2 ) # Test VF2 with node/edge compatibility function g3.vs["color"] = [0, 1, 1, 0] self.assertTrue(g3.count_isomorphisms_vf2(node_compat_fn=node_compat) == 4) g3.vs["color"] = [0, 1, 2, 0] self.assertTrue(g3.count_isomorphisms_vf2(node_compat_fn=node_compat) == 2) g3.es["color"] = [0, 1, 0, 0, 0, 1] self.assertTrue(g3.count_isomorphisms_vf2(edge_compat_fn=edge_compat) == 2) def testGetIsomorphisms(self): g = Graph(6, [(0, 1), (2, 3), (4, 5), (0, 2), (2, 4), (1, 3), (3, 5)]) maps = g.get_automorphisms_vf2() expected_maps = [ [0, 1, 2, 3, 4, 5], [1, 0, 3, 2, 5, 4], [4, 5, 2, 3, 0, 1], [5, 4, 3, 2, 1, 0], ] self.assertTrue(maps == expected_maps) g3 = Graph.Full(4) g3.vs["color"] = [0, 1, 1, 0] expected_maps = [[0, 1, 2, 3], [0, 2, 1, 3], [3, 1, 2, 0], [3, 2, 1, 0]] self.assertTrue( sorted(g3.get_automorphisms_vf2(color="color")) == expected_maps ) class SubisomorphismTests(unittest.TestCase): def testSubisomorphicLAD(self): g = Graph.Lattice([3, 3], circular=False) g2 = Graph([(0, 1), (1, 2), (1, 3)]) g3 = g + [(0, 4), (2, 4), (6, 4), (8, 4), (3, 1), (1, 5), (5, 7), (7, 3)] self.assertTrue(g.subisomorphic_lad(g2)) self.assertFalse(g2.subisomorphic_lad(g)) # Test 'induced' self.assertFalse(g3.subisomorphic_lad(g, induced=True)) self.assertTrue(g3.subisomorphic_lad(g, induced=False)) self.assertTrue(g3.subisomorphic_lad(g)) self.assertTrue(g3.subisomorphic_lad(g2, induced=True)) self.assertTrue(g3.subisomorphic_lad(g2, induced=False)) self.assertTrue(g3.subisomorphic_lad(g2)) # Test with limited vertex matching domains = [ [4], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], ] self.assertTrue(g.subisomorphic_lad(g2, domains=domains)) domains = [ [], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], ] self.assertTrue(not g.subisomorphic_lad(g2, domains=domains)) # Corner cases empty = Graph() self.assertTrue(g.subisomorphic_lad(empty)) self.assertTrue(empty.subisomorphic_lad(empty)) def testGetSubisomorphismsLAD(self): g = Graph.Lattice([3, 3], circular=False) g2 = Graph([(0, 1), (1, 2), (2, 3), (3, 0)]) g3 = g + [(0, 4), (2, 4), (6, 4), (8, 4), (3, 1), (1, 5), (5, 7), (7, 3)] all_subiso = "0143 0341 1034 1254 1430 1452 2145 2541 3014 3410 3476 \ 3674 4103 4125 4301 4367 4521 4587 4763 4785 5214 5412 5478 5874 6347 \ 6743 7436 7458 7634 7854 8547 8745" all_subiso = sorted([int(x) for x in item] for item in all_subiso.split()) self.assertEqual(all_subiso, sorted(g.get_subisomorphisms_lad(g2))) self.assertEqual([], sorted(g2.get_subisomorphisms_lad(g))) # Test 'induced' induced_subiso = "1375 1573 3751 5731 7513 7315 5137 3157" induced_subiso = sorted( [int(x) for x in item] for item in induced_subiso.split() ) all_subiso_extra = sorted(all_subiso + induced_subiso) self.assertEqual( induced_subiso, sorted(g3.get_subisomorphisms_lad(g2, induced=True)) ) self.assertEqual([], g3.get_subisomorphisms_lad(g, induced=True)) # Test with limited vertex matching limited_subiso = [iso for iso in all_subiso if iso[0] == 4] domains = [ [4], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], ] self.assertEqual( limited_subiso, sorted(g.get_subisomorphisms_lad(g2, domains=domains)) ) domains = [ [], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], [0, 1, 2, 3, 5, 6, 7, 8], ] self.assertEqual([], sorted(g.get_subisomorphisms_lad(g2, domains=domains))) # Corner cases empty = Graph() self.assertEqual([], g.get_subisomorphisms_lad(empty)) self.assertEqual([], empty.get_subisomorphisms_lad(empty)) def testSubisomorphicVF2(self): g = Graph.Lattice([3, 3], circular=False) g2 = Graph([(0, 1), (1, 2), (1, 3)]) self.assertTrue(g.subisomorphic_vf2(g2)) self.assertTrue(not g2.subisomorphic_vf2(g)) # Test with vertex colors g.vs["color"] = [0, 0, 0, 0, 1, 0, 0, 0, 0] g2.vs["color"] = [1, 0, 0, 0] self.assertTrue(g.subisomorphic_vf2(g2, node_compat_fn=node_compat)) g2.vs["color"] = [2, 0, 0, 0] self.assertTrue(not g.subisomorphic_vf2(g2, node_compat_fn=node_compat)) # Test with edge colors g.es["color"] = [1] + [0] * (g.ecount() - 1) g2.es["color"] = [1] + [0] * (g2.ecount() - 1) self.assertTrue(g.subisomorphic_vf2(g2, edge_compat_fn=edge_compat)) g2.es[0]["color"] = [2] self.assertTrue(not g.subisomorphic_vf2(g2, node_compat_fn=node_compat)) def testCountSubisomorphisms(self): g = Graph.Lattice([3, 3], circular=False) g2 = Graph.Lattice([2, 2], circular=False) self.assertTrue(g.count_subisomorphisms_vf2(g2) == 4 * 4 * 2) self.assertTrue(g2.count_subisomorphisms_vf2(g) == 0) # Test with vertex colors g.vs["color"] = [0, 0, 0, 0, 1, 0, 0, 0, 0] g2.vs["color"] = [1, 0, 0, 0] self.assertTrue(g.count_subisomorphisms_vf2(g2, "color", "color") == 4 * 2) self.assertTrue( g.count_subisomorphisms_vf2(g2, node_compat_fn=node_compat) == 4 * 2 ) # Test with edge colors g.es["color"] = [1] + [0] * (g.ecount() - 1) g2.es["color"] = [1] + [0] * (g2.ecount() - 1) self.assertTrue( g.count_subisomorphisms_vf2(g2, edge_color1="color", edge_color2="color") == 2 ) self.assertTrue( g.count_subisomorphisms_vf2(g2, edge_compat_fn=edge_compat) == 2 ) class PermutationTests(unittest.TestCase): def testCanonicalPermutation(self): # Simple case: two ring graphs g1 = Graph(4, [(0, 1), (1, 2), (2, 3), (3, 0)]) g2 = Graph(4, [(0, 1), (1, 3), (3, 2), (2, 0)]) cp = g1.canonical_permutation() g3 = g1.permute_vertices(cp) cp = g2.canonical_permutation() g4 = g2.permute_vertices(cp) self.assertTrue(g3.vcount() == g4.vcount()) self.assertTrue(sorted(g3.get_edgelist()) == sorted(g4.get_edgelist())) # Simple case with coloring cp = g1.canonical_permutation(color=[0, 0, 1, 1]) g3 = g1.permute_vertices(cp) cp = g2.canonical_permutation(color=[0, 0, 1, 1]) g4 = g2.permute_vertices(cp) self.assertTrue(g3.vcount() == g4.vcount()) self.assertTrue(sorted(g3.get_edgelist()) == sorted(g4.get_edgelist())) # More complicated one: small GRG, random permutation g = Graph.GRG(10, 0.5) perm = list(range(10)) shuffle(perm) g2 = g.permute_vertices(perm) g3 = g.permute_vertices(g.canonical_permutation()) g4 = g2.permute_vertices(g2.canonical_permutation()) self.assertTrue(g3.vcount() == g4.vcount()) self.assertTrue(sorted(g3.get_edgelist()) == sorted(g4.get_edgelist())) def testPermuteVertices(self): g1 = Graph( 8, [ (0, 4), (0, 5), (0, 6), (1, 4), (1, 5), (1, 7), (2, 4), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), ], ) g2 = Graph( 8, [ (0, 1), (0, 3), (0, 4), (2, 3), (2, 1), (2, 6), (5, 1), (5, 4), (5, 6), (7, 3), (7, 6), (7, 4), ], ) _, _, mapping = g1.isomorphic_vf2(g2, return_mapping_21=True) g3 = g2.permute_vertices(mapping) self.assertTrue(g3.vcount() == g2.vcount() and g3.ecount() == g2.ecount()) self.assertTrue(set(g3.get_edgelist()) == set(g1.get_edgelist())) def suite(): isomorphism_suite = unittest.makeSuite(IsomorphismTests) subisomorphism_suite = unittest.makeSuite(SubisomorphismTests) permutation_suite = unittest.makeSuite(PermutationTests) return unittest.TestSuite( [isomorphism_suite, subisomorphism_suite, permutation_suite] ) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_iterators.py0000644000175100001710000000367500000000000020405 0ustar00runnerdocker00000000000000import unittest from igraph import * class IteratorTests(unittest.TestCase): def testBFS(self): g = Graph.Tree(10, 2) vs, layers, ps = g.bfs(0) self.assertEqual(vs, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) self.assertEqual(ps, [0, 0, 0, 1, 1, 2, 2, 3, 3, 4]) def testBFSIter(self): g = Graph.Tree(10, 2) vs = [v.index for v in g.bfsiter(0)] self.assertEqual(vs, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) vs = [(v.index, d, p) for v, d, p in g.bfsiter(0, advanced=True)] vs = [(v, d, p.index) for v, d, p in vs if p is not None] self.assertEqual( vs, [ (1, 1, 0), (2, 1, 0), (3, 2, 1), (4, 2, 1), (5, 2, 2), (6, 2, 2), (7, 3, 3), (8, 3, 3), (9, 3, 4), ], ) def testDFS(self): g = Graph.Tree(10, 2) vs, ps = g.dfs(0) self.assertEqual(vs, [0, 2, 6, 5, 1, 4, 9, 3, 8, 7]) self.assertEqual(ps, [0, 0, 2, 2, 0, 1, 4, 1, 3, 3]) def testDFSIter(self): g = Graph.Tree(10, 2) vs = [v.index for v in g.dfsiter(0)] self.assertEqual(vs, [0, 1, 3, 7, 8, 4, 9, 2, 5, 6]) vs = [(v.index, d, p) for v, d, p in g.dfsiter(0, advanced=True)] vs = [(v, d, p.index) for v, d, p in vs if p is not None] self.assertEqual( vs, [ (1, 1, 0), (3, 2, 1), (7, 3, 3), (8, 3, 3), (4, 2, 1), (9, 3, 4), (2, 1, 0), (5, 2, 2), (6, 2, 2), ], ) def suite(): iterator_suite = unittest.makeSuite(IteratorTests) return unittest.TestSuite([iterator_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_layouts.py0000644000175100001710000002503600000000000020064 0ustar00runnerdocker00000000000000import unittest from igraph import Graph, Layout, BoundingBox class LayoutTests(unittest.TestCase): def testConstructor(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0)]) self.assertEqual(layout.dim, 3) layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0)], 3) self.assertEqual(layout.dim, 3) self.assertRaises(ValueError, Layout, [(0, 1), (1, 0)], 3) def testIndexing(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) self.assertEqual(len(layout), 4) self.assertEqual(layout[1], [0, 1, 0]) self.assertEqual(layout[3], [2, 1, 3]) row = layout[2] row[2] = 1 self.assertEqual(layout[2], [1, 0, 1]) del layout[1] self.assertEqual(len(layout), 3) def testScaling(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) layout.scale(1.5) self.assertEqual( layout.coords, [[0.0, 0.0, 1.5], [0.0, 1.5, 0.0], [1.5, 0.0, 0.0], [3.0, 1.5, 4.5]], ) layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) layout.scale(1, 1, 3) self.assertEqual(layout.coords, [[0, 0, 3], [0, 1, 0], [1, 0, 0], [2, 1, 9]]) layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) layout.scale((2, 2, 1)) self.assertEqual(layout.coords, [[0, 0, 1], [0, 2, 0], [2, 0, 0], [4, 2, 3]]) self.assertRaises(ValueError, layout.scale, 2, 3) def testTranslation(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) layout2 = layout.copy() layout.translate(1, 3, 2) self.assertEqual(layout.coords, [[1, 3, 3], [1, 4, 2], [2, 3, 2], [3, 4, 5]]) layout.translate((-1, -3, -2)) self.assertEqual(layout.coords, layout2.coords) self.assertRaises(ValueError, layout.translate, v=[3]) def testCentroid(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) centroid = layout.centroid() self.assertEqual(len(centroid), 3) self.assertAlmostEqual(centroid[0], 0.75) self.assertAlmostEqual(centroid[1], 0.5) self.assertAlmostEqual(centroid[2], 1.0) def testBoundaries(self): layout = Layout([(0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 1, 3)]) self.assertEqual(layout.boundaries(), ([0, 0, 0], [2, 1, 3])) self.assertEqual(layout.boundaries(1), ([-1, -1, -1], [3, 2, 4])) layout = Layout([]) self.assertRaises(ValueError, layout.boundaries) layout = Layout([], dim=3) self.assertRaises(ValueError, layout.boundaries) def testBoundingBox(self): layout = Layout([(0, 1), (2, 7)]) self.assertEqual(layout.bounding_box(), BoundingBox(0, 1, 2, 7)) self.assertEqual(layout.bounding_box(1), BoundingBox(-1, 0, 3, 8)) layout = Layout([]) self.assertEqual(layout.bounding_box(), BoundingBox(0, 0, 0, 0)) def testCenter(self): layout = Layout([(-2, 0), (-2, -2), (0, -2), (0, 0)]) layout.center() self.assertEqual(layout.coords, [[-1, 1], [-1, -1], [1, -1], [1, 1]]) layout.center(5, 5) self.assertEqual(layout.coords, [[4, 6], [4, 4], [6, 4], [6, 6]]) self.assertRaises(ValueError, layout.center, 3) self.assertRaises(TypeError, layout.center, p=6) def testFitInto(self): layout = Layout([(-2, 0), (-2, -2), (0, -2), (0, 0)]) layout.fit_into(BoundingBox(5, 5, 8, 10), keep_aspect_ratio=False) self.assertEqual(layout.coords, [[5, 10], [5, 5], [8, 5], [8, 10]]) layout = Layout([(-2, 0), (-2, -2), (0, -2), (0, 0)]) layout.fit_into(BoundingBox(5, 5, 8, 10)) self.assertEqual(layout.coords, [[5, 9], [5, 6], [8, 6], [8, 9]]) layout = Layout([(-1, -1, -1), (0, 0, 0), (1, 1, 1), (2, 2, 0), (3, 3, -1)]) layout.fit_into((0, 0, 0, 8, 8, 4)) self.assertEqual( layout.coords, [[0, 0, 0], [2, 2, 2], [4, 4, 4], [6, 6, 2], [8, 8, 0]] ) layout = Layout([]) layout.fit_into((6, 7, 8, 11)) self.assertEqual(layout.coords, []) def testToPolar(self): layout = Layout([(0, 0), (-1, 1), (0, 1), (1, 1)]) layout.to_radial(min_angle=180, max_angle=0, max_radius=2) exp = [[0.0, 0.0], [-2.0, 0.0], [0.0, 2.0], [2, 0.0]] for idx in range(4): self.assertAlmostEqual(layout.coords[idx][0], exp[idx][0], places=3) self.assertAlmostEqual(layout.coords[idx][1], exp[idx][1], places=3) def testTransform(self): def tr(coord, dx, dy): return coord[0] + dx, coord[1] + dy layout = Layout([(1, 2), (3, 4)]) layout.transform(tr, 2, -1) self.assertEqual(layout.coords, [[3, 1], [5, 3]]) class LayoutAlgorithmTests(unittest.TestCase): def testAuto(self): def layout_test(graph, test_with_dims=(2, 3)): lo = graph.layout("auto") self.assertTrue(isinstance(lo, Layout)) self.assertEqual(len(lo[0]), 2) for dim in test_with_dims: lo = graph.layout("auto", dim=dim) self.assertTrue(isinstance(lo, Layout)) self.assertEqual(len(lo[0]), dim) return lo g = Graph.Barabasi(10) layout_test(g) g = Graph.GRG(101, 0.2) del g.vs["x"] del g.vs["y"] layout_test(g) g = Graph.Full(10) * 2 layout_test(g) g["layout"] = "graphopt" layout_test(g, test_with_dims=()) g.vs["x"] = list(range(20)) g.vs["y"] = list(range(20, 40)) layout_test(g, test_with_dims=()) del g["layout"] lo = layout_test(g, test_with_dims=(2,)) self.assertEqual( [tuple(item) for item in lo], list(zip(list(range(20)), list(range(20, 40)))), ) g.vs["z"] = list(range(40, 60)) lo = layout_test(g) self.assertEqual( [tuple(item) for item in lo], list(zip(list(range(20)), list(range(20, 40)), list(range(40, 60)))), ) def testCircle(self): def test_is_proper_circular_layout(graph, layout): xs, ys = list(zip(*layout)) n = graph.vcount() self.assertEqual(n, len(xs)) self.assertEqual(n, len(ys)) self.assertAlmostEqual(0, sum(xs)) self.assertAlmostEqual(0, sum(ys)) for x, y in zip(xs, ys): self.assertAlmostEqual(1, x ** 2 + y ** 2) g = Graph.Ring(8) layout = g.layout("circle") test_is_proper_circular_layout(g, g.layout("circle")) order = [0, 2, 4, 6, 1, 3, 5, 7] ordered_layout = g.layout("circle", order=order) test_is_proper_circular_layout(g, g.layout("circle")) for v, w in enumerate(order): self.assertAlmostEqual(layout[v][0], ordered_layout[w][0]) self.assertAlmostEqual(layout[v][1], ordered_layout[w][1]) def testDavidsonHarel(self): # Quick smoke testing only g = Graph.Barabasi(100) lo = g.layout("dh") self.assertTrue(isinstance(lo, Layout)) def testFruchtermanReingold(self): g = Graph.Barabasi(100) lo = g.layout("fr") self.assertTrue(isinstance(lo, Layout)) lo = g.layout("fr", miny=list(range(100))) self.assertTrue(isinstance(lo, Layout)) self.assertTrue(all(lo[i][1] >= i for i in range(100))) lo = g.layout("fr", miny=list(range(100)), maxy=list(range(100))) self.assertTrue(isinstance(lo, Layout)) self.assertTrue(all(lo[i][1] == i for i in range(100))) lo = g.layout( "fr", miny=[2] * 100, maxy=[3] * 100, minx=[4] * 100, maxx=[6] * 100 ) self.assertTrue(isinstance(lo, Layout)) bbox = lo.bounding_box() self.assertTrue(bbox.top >= 2) self.assertTrue(bbox.bottom <= 3) self.assertTrue(bbox.left >= 4) self.assertTrue(bbox.right <= 6) def testFruchtermanReingoldGrid(self): g = Graph.Barabasi(100) for grid_opt in ["grid", "nogrid", "auto", True, False]: lo = g.layout("fr", miny=list(range(100)), grid=grid_opt) self.assertTrue(isinstance(lo, Layout)) self.assertTrue(all(lo[i][1] >= i for i in range(100))) def testKamadaKawai(self): g = Graph.Barabasi(100) lo = g.layout( "kk", miny=[2] * 100, maxy=[3] * 100, minx=[4] * 100, maxx=[6] * 100 ) self.assertTrue(isinstance(lo, Layout)) bbox = lo.bounding_box() self.assertTrue(bbox.top >= 2) self.assertTrue(bbox.bottom <= 3) self.assertTrue(bbox.left >= 4) self.assertTrue(bbox.right <= 6) def testMDS(self): g = Graph.Tree(10, 2) lo = g.layout("mds") self.assertTrue(isinstance(lo, Layout)) dists = g.shortest_paths() lo = g.layout("mds", dists) self.assertTrue(isinstance(lo, Layout)) g += Graph.Tree(10, 2) lo = g.layout("mds") self.assertTrue(isinstance(lo, Layout)) def testReingoldTilford(self): g = Graph.Barabasi(100) lo = g.layout("rt") ys = [coord[1] for coord in lo] root = ys.index(0.0) self.assertEqual(ys, g.shortest_paths(root)[0]) g = Graph.Barabasi(100) + Graph.Barabasi(50) lo = g.layout("rt", root=[0, 100]) self.assertEqual(lo[100][1] - lo[0][1], 0) lo = g.layout("rt", root=[0, 100], rootlevel=[2, 10]) self.assertEqual(lo[100][1] - lo[0][1], 8) def testBipartite(self): g = Graph.Full_Bipartite(3, 2) lo = g.layout("bipartite") ys = [coord[1] for coord in lo] self.assertEqual([1, 1, 1, 0, 0], ys) lo = g.layout("bipartite", vgap=3) ys = [coord[1] for coord in lo] self.assertEqual([3, 3, 3, 0, 0], ys) lo = g.layout("bipartite", hgap=5) self.assertEqual( set([0, 5, 10]), set(coord[0] for coord in lo if coord[1] == 1) ) self.assertEqual( set([2.5, 7.5]), set(coord[0] for coord in lo if coord[1] == 0) ) def testDRL(self): # Regression test for bug #1091891 g = Graph.Ring(10, circular=False) + 1 lo = g.layout("drl") self.assertTrue(isinstance(lo, Layout)) def suite(): layout_suite = unittest.makeSuite(LayoutTests) layout_algorithm_suite = unittest.makeSuite(LayoutAlgorithmTests) return unittest.TestSuite([layout_suite, layout_algorithm_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_matching.py0000644000175100001710000000555700000000000020164 0ustar00runnerdocker00000000000000import unittest from igraph import * def powerset(iterable): items_powers = [(item, 1 << i) for i, item in enumerate(iterable)] for i in range(1 << len(items_powers)): for item, power in items_powers: if i & power: yield item leda_graph = Graph( [ (0, 8), (0, 12), (0, 14), (1, 9), (1, 10), (1, 13), (2, 8), (2, 9), (3, 10), (3, 11), (3, 13), (4, 9), (4, 14), (5, 14), (6, 9), (6, 14), (7, 8), (7, 12), (7, 14), ] ) leda_graph.vs["type"] = [0] * 8 + [1] * 7 class MatchingTests(unittest.TestCase): def setUp(self): self.matching = Matching( leda_graph, [12, 10, 8, 13, -1, 14, 9, -1, 2, 6, 1, -1, 0, 3, 5], "type" ) def testIsMaximal(self): self.assertTrue(self.matching.is_maximal()) self.matching.matching[0] = -1 self.matching.matching[12] = -1 self.assertFalse(self.matching.is_maximal()) def testMatchingRetrieval(self): m = [12, 10, 8, 13, -1, 14, 9, -1, 2, 6, 1, -1, 0, 3, 5] self.assertEqual(self.matching.matching, m) for i, mate in enumerate(m): if mate == -1: self.assertFalse(self.matching.is_matched(i)) self.assertEqual(self.matching.match_of(i), None) else: self.assertTrue(self.matching.is_matched(i)) self.assertEqual(self.matching.match_of(i), mate) self.assertEqual( self.matching.match_of(leda_graph.vs[i]).index, leda_graph.vs[mate].index, ) class MaximumBipartiteMatchingTests(unittest.TestCase): def testBipartiteMatchingSimple(self): # Specifying the "type" attribute explicitly matching = leda_graph.maximum_bipartite_matching("type") self.assertEqual(len(matching), 6) self.assertTrue(matching.is_maximal()) # Using the default attribute matching = leda_graph.maximum_bipartite_matching() self.assertEqual(len(matching), 6) self.assertTrue(matching.is_maximal()) def testBipartiteMatchingErrors(self): # Type vector too short g = Graph([(0, 1), (1, 2), (2, 3)]) self.assertRaises(InternalError, g.maximum_bipartite_matching, types=[0, 1, 0]) # Graph not bipartite self.assertRaises( InternalError, g.maximum_bipartite_matching, types=[0, 1, 1, 1] ) def suite(): matching_suite = unittest.makeSuite(MatchingTests) bipartite_unweighted_suite = unittest.makeSuite(MaximumBipartiteMatchingTests) return unittest.TestSuite([matching_suite, bipartite_unweighted_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_operators.py0000644000175100001710000003732000000000000020401 0ustar00runnerdocker00000000000000import unittest from igraph import * try: import numpy as np except ImportError: np = None class OperatorTests(unittest.TestCase): def testComplementer(self): g = Graph.Full(3) g2 = g.complementer() self.assertTrue(g2.vcount() == 3 and g2.ecount() == 3) self.assertTrue(sorted(g2.get_edgelist()) == [(0, 0), (1, 1), (2, 2)]) g = Graph.Full(3) + Graph.Full(2) g2 = g.complementer(False) self.assertTrue( sorted(g2.get_edgelist()) == [(0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (2, 4)] ) g2 = g.complementer(loops=True) self.assertTrue( sorted(g2.get_edgelist()) == [ (0, 0), (0, 3), (0, 4), (1, 1), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (4, 4), ] ) def testMultiplication(self): g = Graph.Full(3) * 3 self.assertTrue( g.vcount() == 9 and g.ecount() == 9 and g.clusters().membership == [0, 0, 0, 1, 1, 1, 2, 2, 2] ) def testDifference(self): g = Graph.Tree(7, 2) - Graph.Lattice([7]) self.assertTrue(g.vcount() == 7 and g.ecount() == 5) self.assertTrue( sorted(g.get_edgelist()) == [(0, 2), (1, 3), (1, 4), (2, 5), (2, 6)] ) def testDifferenceWithSelfLoop(self): # https://github.com/igraph/igraph/issues/597# g = Graph.Ring(10) + [(0, 0)] g -= Graph.Ring(5) self.assertTrue(g.vcount() == 10 and g.ecount() == 7) self.assertTrue( sorted(g.get_edgelist()) == [(0, 0), (0, 9), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9)] ) def testIntersection(self): g = Graph.Tree(7, 2) & Graph.Lattice([7]) self.assertTrue(g.get_edgelist() == [(0, 1)]) def testIntersectionMethod(self): g = Graph.Tree(7, 2).intersection(Graph.Lattice([7])) self.assertTrue(g.get_edgelist() == [(0, 1)]) def testIntersectionNoGraphs(self): self.assertRaises(ValueError, intersection, []) def testIntersectionSingle(self): g1 = Graph.Tree(7, 2) g = intersection([g1]) self.assertTrue(g != g1) self.assertTrue(g.vcount() == g1.vcount() and g.ecount() == g1.ecount()) self.assertTrue(g.is_directed() == g1.is_directed()) self.assertTrue(g.get_edgelist() == g1.get_edgelist()) def testDisjointUnion(self): g1 = Graph.Tree(7, 2) g2 = Graph.Lattice([7]) # Method g = g1.disjoint_union(g2) self.assertTrue(g.vcount() == 14 and g.ecount() == 13) # Module function g = disjoint_union([g1, g2]) self.assertTrue(g.vcount() == 14 and g.ecount() == 13) def testDisjointUnionNoGraphs(self): self.assertRaises(ValueError, disjoint_union, []) def testDisjointUnionSingle(self): g1 = Graph.Tree(7, 2) g = disjoint_union([g1]) self.assertTrue(g != g1) self.assertTrue(g.vcount() == g1.vcount() and g.ecount() == g1.ecount()) self.assertTrue(g.is_directed() == g1.is_directed()) self.assertTrue(g.get_edgelist() == g1.get_edgelist()) def testUnion(self): g = Graph.Tree(7, 2) | Graph.Lattice([7]) self.assertTrue(g.vcount() == 7 and g.ecount() == 12) self.assertTrue( sorted(g.get_edgelist()) == [ (0, 1), (0, 2), (0, 6), (1, 2), (1, 3), (1, 4), (2, 3), (2, 5), (2, 6), (3, 4), (4, 5), (5, 6), ] ) def testUnionWithConflict(self): g1 = Graph.Tree(7, 2) g1['name'] = 'Tree' g2 = Graph.Lattice([7]) g2['name'] = 'Lattice' g = union([g1, g2]) # Issue 422 self.assertTrue( sorted(g.get_edgelist()) == [ (0, 1), (0, 2), (0, 6), (1, 2), (1, 3), (1, 4), (2, 3), (2, 5), (2, 6), (3, 4), (4, 5), (5, 6), ] ) self.assertTrue( sorted(g.attributes()), ['name_1', 'name_2'], ) def testUnionMethod(self): g = Graph.Tree(7, 2).union(Graph.Lattice([7])) self.assertTrue(g.vcount() == 7 and g.ecount() == 12) def testUnionNoGraphs(self): self.assertRaises(ValueError, union, []) def testUnionSingle(self): g1 = Graph.Tree(7, 2) g = union([g1]) self.assertTrue(g != g1) self.assertTrue(g.vcount() == g1.vcount() and g.ecount() == g1.ecount()) self.assertTrue(g.is_directed() == g1.is_directed()) self.assertTrue(g.get_edgelist() == g1.get_edgelist()) def testUnionMany(self): gs = [Graph.Tree(7, 2), Graph.Lattice([7]), Graph.Lattice([7])] g = union(gs) self.assertTrue(g.vcount() == 7 and g.ecount() == 12) def testUnionManyAttributes(self): gs = [ Graph.Formula("A-B"), Graph.Formula("A-B,C-D"), ] gs[0]["attr"] = "graph1" gs[0].vs["attr"] = ["set", "set_too"] gs[0].vs["attr2"] = ["set", "set_too"] gs[1].vs[0]["attr"] = "set" gs[1].vs[0]["attr2"] = "conflict" g = union(gs) names = g.vs["name"] self.assertTrue(g["attr"] == "graph1") self.assertTrue(g.vs[names.index("A")]["attr"] == "set") self.assertTrue(g.vs[names.index("B")]["attr"] == "set_too") self.assertTrue(g.ecount() == 2) self.assertTrue( sorted(g.vertex_attributes()) == ["attr", "attr2_1", "attr2_2", "name"] ) def testUnionManyEdgemap(self): gs = [ Graph.Formula("A-B"), Graph.Formula("C-D, A-B"), ] gs[0].es[0]["attr"] = "set" gs[1].es[0]["attr"] = "set_too" g = union(gs) for e in g.es: vnames = [g.vs[e.source]["name"], g.vs[e.target]["name"]] if set(vnames) == set(["A", "B"]): self.assertTrue(e["attr"] == "set") else: self.assertTrue(e["attr"] == "set_too") def testIntersectionNoGraphs(self): self.assertRaises(ValueError, intersection, []) def testIntersectionSingle(self): g1 = Graph.Tree(7, 2) g = intersection([g1]) self.assertTrue(g != g1) self.assertTrue(g.vcount() == g1.vcount() and g.ecount() == g1.ecount()) self.assertTrue(g.is_directed() == g1.is_directed()) self.assertTrue(g.get_edgelist() == g1.get_edgelist()) def testIntersectionMany(self): gs = [Graph.Tree(7, 2), Graph.Lattice([7])] g = intersection(gs) self.assertTrue(g.get_edgelist() == [(0, 1)]) def testIntersectionManyAttributes(self): gs = [Graph.Tree(7, 2), Graph.Lattice([7])] gs[0]["attr"] = "graph1" gs[0].vs["name"] = ["one", "two", "three", "four", "five", "six", "7"] gs[1].vs["name"] = ["one", "two", "three", "four", "five", "six", "7"] gs[0].vs[0]["attr"] = "set" gs[1].vs[5]["attr"] = "set_too" g = intersection(gs) names = g.vs["name"] self.assertTrue(g["attr"] == "graph1") self.assertTrue(g.vs[names.index("one")]["attr"] == "set") self.assertTrue(g.vs[names.index("six")]["attr"] == "set_too") self.assertTrue(g.ecount() == 1) self.assertTrue( set(g.get_edgelist()[0]) == set([names.index("one"), names.index("two")]), ) def testIntersectionManyEdgemap(self): gs = [ Graph.Formula("A-B"), Graph.Formula("A-B,C-D"), ] gs[0].es[0]["attr"] = "set" gs[1].es[1]["attr"] = "set_too" g = intersection(gs) self.assertTrue(g.es["attr"] == ["set"]) def testInPlaceAddition(self): g = Graph.Full(3) orig = g # Adding vertices g += 2 self.assertTrue( g.vcount() == 5 and g.ecount() == 3 and g.clusters().membership == [0, 0, 0, 1, 2] ) # Adding a vertex by name g += "spam" self.assertTrue( g.vcount() == 6 and g.ecount() == 3 and g.clusters().membership == [0, 0, 0, 1, 2, 3] ) # Adding a single edge g += (2, 3) self.assertTrue( g.vcount() == 6 and g.ecount() == 4 and g.clusters().membership == [0, 0, 0, 0, 1, 2] ) # Adding two edges g += [(3, 4), (2, 4), (4, 5)] self.assertTrue( g.vcount() == 6 and g.ecount() == 7 and g.clusters().membership == [0] * 6 ) # Adding two more vertices g += ["eggs", "bacon"] self.assertEqual( g.vs["name"], [None, None, None, None, None, "spam", "eggs", "bacon"] ) # Did we really use the original graph so far? # TODO: disjoint union should be modified so that this assertion # could be moved to the end self.assertTrue(id(g) == id(orig)) # Adding another graph g += Graph.Full(3) self.assertTrue( g.vcount() == 11 and g.ecount() == 10 and g.clusters().membership == [0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3] ) # Adding two graphs g += [Graph.Full(3), Graph.Full(2)] self.assertTrue( g.vcount() == 16 and g.ecount() == 14 and g.clusters().membership == [0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5] ) def testAddition(self): g0 = Graph.Full(3) # Adding vertices g = g0 + 2 self.assertTrue( g.vcount() == 5 and g.ecount() == 3 and g.clusters().membership == [0, 0, 0, 1, 2] ) g0 = g # Adding vertices by name g = g0 + "spam" self.assertTrue( g.vcount() == 6 and g.ecount() == 3 and g.clusters().membership == [0, 0, 0, 1, 2, 3] ) g0 = g # Adding a single edge g = g0 + (2, 3) self.assertTrue( g.vcount() == 6 and g.ecount() == 4 and g.clusters().membership == [0, 0, 0, 0, 1, 2] ) g0 = g # Adding two edges g = g0 + [(3, 4), (2, 4), (4, 5)] self.assertTrue( g.vcount() == 6 and g.ecount() == 7 and g.clusters().membership == [0] * 6 ) g0 = g # Adding another graph g = g0 + Graph.Full(3) self.assertTrue( g.vcount() == 9 and g.ecount() == 10 and g.clusters().membership == [0, 0, 0, 0, 0, 0, 1, 1, 1] ) def testInPlaceSubtraction(self): g = Graph.Full(8) orig = g # Deleting a vertex by vertex selector g -= 7 self.assertTrue( g.vcount() == 7 and g.ecount() == 21 and g.clusters().membership == [0, 0, 0, 0, 0, 0, 0] ) # Deleting a vertex g -= g.vs[6] self.assertTrue( g.vcount() == 6 and g.ecount() == 15 and g.clusters().membership == [0, 0, 0, 0, 0, 0] ) # Deleting two vertices g -= [4, 5] self.assertTrue( g.vcount() == 4 and g.ecount() == 6 and g.clusters().membership == [0, 0, 0, 0] ) # Deleting an edge g -= (1, 2) self.assertTrue( g.vcount() == 4 and g.ecount() == 5 and g.clusters().membership == [0, 0, 0, 0] ) # Deleting three more edges g -= [(1, 3), (0, 2), (0, 3)] self.assertTrue( g.vcount() == 4 and g.ecount() == 2 and g.clusters().membership == [0, 0, 1, 1] ) # Did we really use the original graph so far? self.assertTrue(id(g) == id(orig)) # Subtracting a graph g2 = Graph.Tree(3, 2) g -= g2 self.assertTrue( g.vcount() == 4 and g.ecount() == 1 and g.clusters().membership == [0, 1, 2, 2] ) def testNonzero(self): self.assertTrue(Graph(1)) self.assertFalse(Graph(0)) def testLength(self): self.assertRaises(TypeError, len, Graph(15)) self.assertTrue(len(Graph(15).vs) == 15) self.assertTrue(len(Graph.Full(5).es) == 10) def testSimplify(self): el = [(0, 1), (1, 0), (1, 2), (2, 3), (2, 3), (2, 3), (3, 3)] g = Graph(el) g.es["weight"] = [1, 2, 3, 4, 5, 6, 7] g2 = g.copy() g2.simplify() self.assertTrue(g2.vcount() == g.vcount()) self.assertTrue(g2.ecount() == 3) g2 = g.copy() g2.simplify(loops=False) self.assertTrue(g2.vcount() == g.vcount()) self.assertTrue(g2.ecount() == 4) g2 = g.copy() g2.simplify(multiple=False) self.assertTrue(g2.vcount() == g.vcount()) self.assertTrue(g2.ecount() == g.ecount() - 1) def testContractVertices(self): g = Graph.Full(4) + Graph.Full(4) + [(0, 5), (1, 4)] g2 = g.copy() g2.contract_vertices([0, 1, 2, 3, 1, 0, 4, 5]) self.assertEqual(g2.vcount(), 6) self.assertEqual(g2.ecount(), g.ecount()) self.assertEqual( sorted(g2.get_edgelist()), [ (0, 0), (0, 1), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (4, 5), ], ) g2 = g.copy() g2.contract_vertices([0, 1, 2, 3, 1, 0, 6, 7]) self.assertEqual(g2.vcount(), 8) self.assertEqual(g2.ecount(), g.ecount()) self.assertEqual( sorted(g2.get_edgelist()), [ (0, 0), (0, 1), (0, 1), (0, 2), (0, 3), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 6), (1, 7), (2, 3), (6, 7), ], ) g2 = Graph(10) g2.contract_vertices([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]) self.assertEqual(g2.vcount(), 5) self.assertEqual(g2.ecount(), 0) @unittest.skipIf(np is None, "test case depends on NumPy") def testContractVerticesWithNumPyIntegers(self): g = Graph.Full(4) + Graph.Full(4) + [(0, 5), (1, 4)] g2 = g.copy() g2.contract_vertices([np.int32(x) for x in [0, 1, 2, 3, 1, 0, 6, 7]]) self.assertEqual(g2.vcount(), 8) self.assertEqual(g2.ecount(), g.ecount()) self.assertEqual( sorted(g2.get_edgelist()), [ (0, 0), (0, 1), (0, 1), (0, 2), (0, 3), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 6), (1, 7), (2, 3), (6, 7), ], ) def suite(): operator_suite = unittest.makeSuite(OperatorTests) return unittest.TestSuite([operator_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_rng.py0000644000175100001710000000226600000000000017152 0ustar00runnerdocker00000000000000import random import unittest from igraph import * class FakeRNG: @staticmethod def random(): return 0.1 @staticmethod def randint(a, b): return a @staticmethod def gauss(mu, sigma): return 0.3 class InvalidRNG: pass class RandomNumberGeneratorTests(unittest.TestCase): def tearDown(self): set_random_number_generator(random) def testSetRandomNumberGenerator(self): set_random_number_generator(FakeRNG) graph = Graph.GRG(10, 0.2) self.assertEqual(graph.vs["x"], [0.1] * 10) self.assertEqual(graph.vs["y"], [0.1] * 10) self.assertRaises(AttributeError, set_random_number_generator, InvalidRNG) def testSeeding(self): state = random.getstate() g1 = Graph.Erdos_Renyi(n=1000, m=5000) random.setstate(state) g2 = Graph.Erdos_Renyi(n=1000, m=5000) self.assertTrue(g1.get_edgelist() == g2.get_edgelist()) def suite(): random_suite = unittest.makeSuite(RandomNumberGeneratorTests) return unittest.TestSuite([random_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_separators.py0000644000175100001710000000510000000000000020535 0ustar00runnerdocker00000000000000import unittest from igraph import * def powerset(iterable): items_powers = [(item, 1 << i) for i, item in enumerate(iterable)] for i in range(1 << len(items_powers)): for item, power in items_powers: if i & power: yield item class IsSeparatorTests(unittest.TestCase): def testIsSeparator(self): g = Graph.Lattice([8, 4], circular=False) self.assertTrue(g.is_separator([3, 11, 19, 27])) self.assertFalse(g.is_separator([10, 11, 18, 19])) self.assertTrue(g.is_separator([29, 20, 11, 2])) self.assertTrue(g.is_separator([16, 25, 17])) g = Graph.Lattice([8, 4], circular=True) self.assertFalse(g.is_separator([3, 11, 19, 27])) self.assertFalse(g.is_separator([29, 20, 11, 2])) self.assertFalse(g.is_separator(list(range(32)))) self.assertRaises(InternalError, g.is_separator, list(range(33))) def testIsMinimalSeparator(self): g = Graph.Lattice([8, 4], circular=False) self.assertTrue(g.is_minimal_separator([3, 11, 19, 27])) self.assertFalse(g.is_minimal_separator([3, 11, 19, 27, 28])) self.assertFalse(g.is_minimal_separator([16, 25, 17])) self.assertTrue(g.is_minimal_separator([16, 25])) self.assertFalse(g.is_minimal_separator(list(range(32)))) self.assertRaises(InternalError, g.is_minimal_separator, list(range(33))) def testAllMinimalSTSeparators(self): g = Graph.Famous("petersen") min_st_seps = set(tuple(x) for x in g.all_minimal_st_separators()) for vs in powerset(list(range(g.vcount()))): if vs in min_st_seps: self.assertTrue(g.is_minimal_separator(vs)) else: self.assertFalse(g.is_minimal_separator(vs)) def testMinimumSizeSeparators(self): g = Graph.Famous("zachary") min_st_seps = set(tuple(x) for x in g.all_minimal_st_separators()) min_size_seps = [tuple(x) for x in g.minimum_size_separators()] self.assertTrue(set(min_size_seps).issubset(min_st_seps)) self.assertTrue(len(set(min_size_seps)) == len(min_size_seps)) size = len(min_size_seps[0]) self.assertTrue(len(s) != size for s in min_size_seps) self.assertTrue( sum(1 for s in min_st_seps if len(s) == size) == len(min_size_seps) ) def suite(): is_separator_suite = unittest.makeSuite(IsSeparatorTests) return unittest.TestSuite([is_separator_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_spectral.py0000644000175100001710000000272300000000000020177 0ustar00runnerdocker00000000000000# vim:set ts=4 sw=4 sts=4 et: import unittest from igraph import * class SpectralTests(unittest.TestCase): def assertAlmostEqualMatrix(self, mat1, mat2, eps=1e-7): self.assertTrue( all(abs(obs - exp) < eps for obs, exp in zip(sum(mat1, []), sum(mat2, []))) ) def testLaplacian(self): g = Graph.Full(3) g.es["weight"] = [1, 2, 3] self.assertTrue(g.laplacian() == [[2, -1, -1], [-1, 2, -1], [-1, -1, 2]]) self.assertAlmostEqualMatrix( g.laplacian(normalized=True), [[1, -0.5, -0.5], [-0.5, 1, -0.5], [-0.5, -0.5, 1]], ) mx0 = [ [1.0, -1 / (12 ** 0.5), -2 / (15 ** 0.5)], [-1 / (12 ** 0.5), 1.0, -3 / (20 ** 0.5)], [-2 / (15 ** 0.5), -3 / (20 ** 0.5), 1.0], ] self.assertAlmostEqualMatrix(g.laplacian("weight", True), mx0) g = Graph.Tree(5, 2) g.add_vertices(1) self.assertTrue( g.laplacian() == [ [2, -1, -1, 0, 0, 0], [-1, 3, 0, -1, -1, 0], [-1, 0, 1, 0, 0, 0], [0, -1, 0, 1, 0, 0], [0, -1, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0], ] ) def suite(): spectral_suite = unittest.makeSuite(SpectralTests) return unittest.TestSuite([spectral_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_structural.py0000644000175100001710000010611400000000000020571 0ustar00runnerdocker00000000000000import math import unittest import warnings from igraph import Graph, InternalError, IN, OUT, ALL, TREE_IN from math import inf, isnan class SimplePropertiesTests(unittest.TestCase): gfull = Graph.Full(10) gempty = Graph(10) g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]) gdir = Graph( 4, [(0, 1), (0, 2), (1, 2), (2, 1), (0, 3), (1, 3), (3, 0)], directed=True ) tree = Graph.Tree(14, 3) def testDensity(self): self.assertAlmostEqual(1.0, self.gfull.density(), places=5) self.assertAlmostEqual(0.0, self.gempty.density(), places=5) self.assertAlmostEqual(5 / 6, self.g.density(), places=5) self.assertAlmostEqual(1 / 2, self.g.density(True), places=5) self.assertAlmostEqual(7 / 12, self.gdir.density(), places=5) self.assertAlmostEqual(7 / 16, self.gdir.density(True), places=5) self.assertAlmostEqual(1 / 7, self.tree.density(), places=5) def testDiameter(self): self.assertTrue(self.gfull.diameter() == 1) self.assertTrue(self.gempty.diameter(unconn=False) == inf) self.assertTrue(self.gempty.diameter(unconn=False) == inf) self.assertTrue(self.g.diameter() == 2) self.assertTrue(self.gdir.diameter(False) == 2) self.assertTrue(self.gdir.diameter() == 3) self.assertTrue(self.tree.diameter() == 5) s, t, d = self.tree.farthest_points() self.assertTrue((s == 13 or t == 13) and d == 5) self.assertTrue(self.gempty.farthest_points(unconn=False) == (None, None, inf)) d = self.tree.get_diameter() self.assertTrue(d[0] == 13 or d[-1] == 13) weights = [1, 1, 1, 5, 1, 5, 1, 1, 1, 1, 1, 1, 5] self.assertTrue(self.tree.diameter(weights=weights) == 15) d = self.tree.farthest_points(weights=weights) self.assertTrue(d == (13, 6, 15) or d == (6, 13, 15)) def testEccentricity(self): self.assertEqual(self.gfull.eccentricity(), [1] * self.gfull.vcount()) self.assertEqual(self.gempty.eccentricity(), [0] * self.gempty.vcount()) self.assertEqual(self.g.eccentricity(), [1, 1, 2, 2]) self.assertEqual(self.gdir.eccentricity(), [1, 2, 3, 2]) self.assertEqual( self.tree.eccentricity(), [3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5] ) self.assertEqual(Graph().eccentricity(), []) def testRadius(self): self.assertEqual(self.gfull.radius(), 1) self.assertEqual(self.gempty.radius(), 0) self.assertEqual(self.g.radius(), 1) self.assertEqual(self.gdir.radius(), 1) self.assertEqual(self.tree.radius(), 3) self.assertTrue(isnan(Graph().radius())) def testTransitivity(self): self.assertTrue(self.gfull.transitivity_undirected() == 1.0) self.assertTrue(self.tree.transitivity_undirected() == 0.0) self.assertTrue(self.g.transitivity_undirected() == 0.75) def testLocalTransitivity(self): self.assertTrue( self.gfull.transitivity_local_undirected() == [1.0] * self.gfull.vcount() ) self.assertTrue( self.tree.transitivity_local_undirected(mode="zero") == [0.0] * self.tree.vcount() ) transitivity = self.g.transitivity_local_undirected(mode="zero") self.assertAlmostEqual(2 / 3, transitivity[0], places=4) self.assertAlmostEqual(2 / 3, transitivity[1], places=4) self.assertEqual(1, transitivity[2]) self.assertEqual(1, transitivity[3]) g = Graph.Full(4) + 1 + [(0, 4)] g.es["weight"] = [1, 1, 1, 1, 1, 1, 5] self.assertAlmostEqual( g.transitivity_local_undirected(0, weights="weight"), 0.25, places=4 ) def testAvgLocalTransitivity(self): self.assertTrue(self.gfull.transitivity_avglocal_undirected() == 1.0) self.assertTrue(self.tree.transitivity_avglocal_undirected() == 0.0) self.assertAlmostEqual( self.g.transitivity_avglocal_undirected(), 5 / 6.0, places=4 ) def testModularity(self): g = Graph.Full(5) + Graph.Full(5) g.add_edges([(0, 5)]) cl = [0] * 5 + [1] * 5 self.assertAlmostEqual(g.modularity(cl), 0.4523, places=3) ws = [1] * 21 self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3) ws = [2] * 21 self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3) ws = [2] * 10 + [1] * 11 self.assertAlmostEqual(g.modularity(cl, ws), 0.4157, places=3) self.assertRaises(InternalError, g.modularity, cl, ws[0:20]) class DegreeTests(unittest.TestCase): gfull = Graph.Full(10) gempty = Graph(10) g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3), (0, 0)]) gdir = Graph( 4, [(0, 1), (0, 2), (1, 2), (2, 1), (0, 3), (1, 3), (3, 0)], directed=True ) tree = Graph.Tree(10, 3) def testKnn(self): knn, knnk = self.gfull.knn() self.assertTrue(knn == [9.0] * 10) self.assertAlmostEqual(knnk[8], 9.0, places=6) # knn works for simple graphs only -- self.g is not simple self.assertRaises(InternalError, self.g.knn) # Okay, simplify it and then go on g = self.g.copy() g.simplify() knn, knnk = g.knn() diff = max(abs(a - b) for a, b in zip(knn, [7 / 3.0, 7 / 3.0, 3, 3])) self.assertAlmostEqual(diff, 0.0, places=6) self.assertEqual(len(knnk), 3) self.assertAlmostEqual(knnk[1], 3, places=6) self.assertAlmostEqual(knnk[2], 7 / 3.0, places=6) def testDegree(self): self.assertTrue(self.gfull.degree() == [9] * 10) self.assertTrue(self.gempty.degree() == [0] * 10) self.assertTrue(self.g.degree(loops=False) == [3, 3, 2, 2]) self.assertTrue(self.g.degree() == [5, 3, 2, 2]) self.assertTrue(self.gdir.degree(mode=IN) == [1, 2, 2, 2]) self.assertTrue(self.gdir.degree(mode=OUT) == [3, 2, 1, 1]) self.assertTrue(self.gdir.degree(mode=ALL) == [4, 4, 3, 3]) vs = self.gdir.vs.select(0, 2) self.assertTrue(self.gdir.degree(vs, mode=ALL) == [4, 3]) self.assertTrue(self.gdir.degree(self.gdir.vs[1], mode=ALL) == 4) def testMaxDegree(self): self.assertTrue(self.gfull.maxdegree() == 9) self.assertTrue(self.gempty.maxdegree() == 0) self.assertTrue(self.g.maxdegree() == 3) self.assertTrue(self.g.maxdegree(loops=True) == 5) self.assertTrue(self.g.maxdegree([1, 2], loops=True) == 3) self.assertTrue(self.gdir.maxdegree(mode=IN) == 2) self.assertTrue(self.gdir.maxdegree(mode=OUT) == 3) self.assertTrue(self.gdir.maxdegree(mode=ALL) == 4) def testStrength(self): # Turn off warnings about calling strength without weights import warnings warnings.filterwarnings( "ignore", "No edge weights for strength calculation", RuntimeWarning ) # No weights self.assertTrue(self.gfull.strength() == [9] * 10) self.assertTrue(self.gempty.strength() == [0] * 10) self.assertTrue(self.g.degree(loops=False) == [3, 3, 2, 2]) self.assertTrue(self.g.degree() == [5, 3, 2, 2]) # With weights ws = [1, 2, 3, 4, 5, 6] self.assertTrue(self.g.strength(weights=ws, loops=False) == [7, 9, 5, 9]) self.assertTrue(self.g.strength(weights=ws) == [19, 9, 5, 9]) ws = [1, 2, 3, 4, 5, 6, 7] self.assertTrue(self.gdir.strength(mode=IN, weights=ws) == [7, 5, 5, 11]) self.assertTrue(self.gdir.strength(mode=OUT, weights=ws) == [8, 9, 4, 7]) self.assertTrue(self.gdir.strength(mode=ALL, weights=ws) == [15, 14, 9, 18]) vs = self.gdir.vs.select(0, 2) self.assertTrue(self.gdir.strength(vs, mode=ALL, weights=ws) == [15, 9]) self.assertTrue(self.gdir.strength(self.gdir.vs[1], mode=ALL, weights=ws) == 14) class LocalTransitivityTests(unittest.TestCase): def testLocalTransitivityFull(self): trans = Graph.Full(10).transitivity_local_undirected() self.assertTrue(trans == [1.0] * 10) def testLocalTransitivityTree(self): trans = Graph.Tree(10, 3).transitivity_local_undirected() self.assertTrue(trans[0:3] == [0.0, 0.0, 0.0]) def testLocalTransitivityHalf(self): g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]) trans = g.transitivity_local_undirected() trans = [round(x, 3) for x in trans] self.assertTrue(trans == [0.667, 0.667, 1.0, 1.0]) def testLocalTransitivityPartial(self): g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]) trans = g.transitivity_local_undirected([1, 2]) trans = [round(x, 3) for x in trans] self.assertTrue(trans == [0.667, 1.0]) class BiconnectedComponentTests(unittest.TestCase): g1 = Graph.Full(10) g2 = Graph(5, [(0, 1), (1, 2), (2, 3), (3, 4)]) g3 = Graph(6, [(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (2, 5), (4, 5)]) def testBiconnectedComponents(self): s = self.g1.biconnected_components() self.assertTrue(len(s) == 1 and s[0] == list(range(10))) s, ap = self.g1.biconnected_components(True) self.assertTrue(len(s) == 1 and s[0] == list(range(10))) s = self.g3.biconnected_components() self.assertTrue(len(s) == 2 and s[0] == [2, 4, 5] and s[1] == [0, 1, 2, 3]) s, ap = self.g3.biconnected_components(True) self.assertTrue( len(s) == 2 and s[0] == [2, 4, 5] and s[1] == [0, 1, 2, 3] and ap == [2] ) def testArticulationPoints(self): self.assertTrue(self.g1.articulation_points() == []) self.assertTrue(self.g2.cut_vertices() == [1, 2, 3]) self.assertTrue(self.g3.articulation_points() == [2]) class CentralityTests(unittest.TestCase): def testBetweennessCentrality(self): g = Graph.Star(5) self.assertTrue(g.betweenness() == [6.0, 0.0, 0.0, 0.0, 0.0]) g = Graph(5, [(0, 1), (0, 2), (0, 3), (1, 4)]) self.assertTrue(g.betweenness() == [5.0, 3.0, 0.0, 0.0, 0.0]) self.assertTrue(g.betweenness(cutoff=2) == [3.0, 1.0, 0.0, 0.0, 0.0]) self.assertTrue(g.betweenness(cutoff=1) == [0.0, 0.0, 0.0, 0.0, 0.0]) g = Graph.Lattice([3, 3], circular=False) self.assertTrue( g.betweenness(cutoff=2) == [0.5, 2.0, 0.5, 2.0, 4.0, 2.0, 0.5, 2.0, 0.5] ) def testEdgeBetweennessCentrality(self): g = Graph.Star(5) self.assertTrue(g.edge_betweenness() == [4.0, 4.0, 4.0, 4.0]) g = Graph(5, [(0, 1), (0, 2), (0, 3), (1, 4)]) self.assertTrue(g.edge_betweenness() == [6.0, 4.0, 4.0, 4.0]) self.assertTrue(g.edge_betweenness(cutoff=2) == [4.0, 3.0, 3.0, 2.0]) self.assertTrue(g.edge_betweenness(cutoff=1) == [1.0, 1.0, 1.0, 1.0]) g = Graph.Ring(5) self.assertTrue(g.edge_betweenness() == [3.0, 3.0, 3.0, 3.0, 3.0]) self.assertTrue( g.edge_betweenness(weights=[4, 1, 1, 1, 1]) == [0.5, 3.5, 5.5, 5.5, 3.5] ) def testClosenessCentrality(self): g = Graph.Star(5) cl = g.closeness() cl2 = [1.0, 4 / 7.0, 4 / 7.0, 4 / 7.0, 4 / 7.0] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) g = Graph.Star(5) with warnings.catch_warnings(): warnings.simplefilter("ignore") cl = g.closeness(cutoff=1.0) cl2 = [1.0, 1.0, 1.0, 1.0, 1.0] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) weights = [1] * 4 g = Graph.Star(5) cl = g.closeness(weights=weights) cl2 = [1.0, 0.57142, 0.57142, 0.57142, 0.57142] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) g = Graph.Star(5) with warnings.catch_warnings(): warnings.simplefilter("ignore") cl = g.closeness(cutoff=1.0, weights=weights) cl2 = [1.0, 1.0, 1.0, 1.0, 1.0] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) # Test for igraph/igraph:#1078 g = Graph( [ (0, 1), (0, 2), (0, 5), (0, 6), (0, 9), (1, 6), (1, 8), (2, 4), (2, 6), (2, 7), (2, 8), (3, 6), (4, 8), (5, 6), (5, 9), (6, 7), (6, 8), (7, 8), (7, 9), (8, 9), ] ) weights = [ 0.69452, 0.329886, 0.131649, 0.503269, 0.472738, 0.370933, 0.23857, 0.0354043, 0.189015, 0.355118, 0.768335, 0.893289, 0.891709, 0.494896, 0.924684, 0.432001, 0.858159, 0.246798, 0.881304, 0.64685, ] with warnings.catch_warnings(): warnings.simplefilter("ignore") cl = g.closeness(weights=weights) expected_cl = [ 1.63318, 1.52014, 2.03724, 0.760158, 1.91449, 1.43224, 1.91761, 1.60198, 1.3891, 1.12829, ] for obs, exp in zip(cl, expected_cl): self.assertAlmostEqual(obs, exp, places=4) def testHarmonicCentrality(self): g = Graph.Star(5) cl = g.harmonic_centrality() cl2 = [1.0] + [(1.0 + 1 / 2 * 3) / 4] * 4 for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) g = Graph.Star(5) with warnings.catch_warnings(): warnings.simplefilter("ignore") cl = g.harmonic_centrality(cutoff=1.0) cl2 = [1.0, 0.25, 0.25, 0.25, 0.25] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) weights = [1] * 4 g = Graph.Star(5) cl = g.harmonic_centrality(weights=weights) cl2 = [1.0] + [0.625] * 4 for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) g = Graph.Star(5) with warnings.catch_warnings(): warnings.simplefilter("ignore") cl = g.harmonic_centrality(cutoff=1.0, weights=weights) cl2 = [1.0, 0.25, 0.25, 0.25, 0.25] for idx in range(g.vcount()): self.assertAlmostEqual(cl[idx], cl2[idx], places=3) def testPageRank(self): g = Graph.Star(11) cent = g.pagerank() self.assertTrue(cent.index(max(cent)) == 0) self.assertAlmostEqual(max(cent), 0.4668, places=3) def testPersonalizedPageRank(self): g = Graph.Star(11) self.assertRaises(InternalError, g.personalized_pagerank, reset=[0] * 11) cent = g.personalized_pagerank(reset=[0, 10] + [0] * 9, damping=0.5) self.assertTrue(cent.index(max(cent)) == 1) self.assertAlmostEqual(cent[0], 0.3333, places=3) self.assertAlmostEqual(cent[1], 0.5166, places=3) self.assertAlmostEqual(cent[2], 0.0166, places=3) cent2 = g.personalized_pagerank(reset_vertices=g.vs[1], damping=0.5) self.assertTrue(max(abs(x - y) for x, y in zip(cent, cent2)) < 0.001) def testEigenvectorCentrality(self): g = Graph.Star(11) cent = g.evcent() self.assertTrue(cent.index(max(cent)) == 0) self.assertAlmostEqual(max(cent), 1.0, places=3) self.assertTrue(min(cent) >= 0) cent, ev = g.evcent(scale=False, return_eigenvalue=True) if cent[0] < 0: cent = [-x for x in cent] self.assertTrue(cent.index(max(cent)) == 0) self.assertAlmostEqual(cent[1] / cent[0], 0.3162, places=3) self.assertAlmostEqual(ev, 3.162, places=3) def testAuthorityScore(self): g = Graph.Tree(15, 2, TREE_IN) asc = g.authority_score() self.assertAlmostEqual(max(asc), 1.0, places=3) # Smoke testing g.authority_score(scale=False, return_eigenvalue=True) def testHubScore(self): g = Graph.Tree(15, 2, TREE_IN) hsc = g.hub_score() self.assertAlmostEqual(max(hsc), 1.0, places=3) # Smoke testing g.hub_score(scale=False, return_eigenvalue=True) def testCoreness(self): g = Graph.Full(4) + Graph(4) + [(0, 4), (1, 5), (2, 6), (3, 7)] self.assertEqual(g.coreness("all"), [3, 3, 3, 3, 1, 1, 1, 1]) class NeighborhoodTests(unittest.TestCase): def testNeighborhood(self): g = Graph.Ring(10, circular=False) self.assertTrue( list(map(sorted, g.neighborhood())) == [ [0, 1], [0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9], ] ) self.assertTrue( list(map(sorted, g.neighborhood(order=3))) == [ [0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7], [2, 3, 4, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8, 9], [4, 5, 6, 7, 8, 9], [5, 6, 7, 8, 9], [6, 7, 8, 9], ] ) self.assertTrue( list(map(sorted, g.neighborhood(order=3, mindist=2))) == [ [2, 3], [3, 4], [0, 4, 5], [0, 1, 5, 6], [1, 2, 6, 7], [2, 3, 7, 8], [3, 4, 8, 9], [4, 5, 9], [5, 6], [6, 7], ] ) def testNeighborhoodSize(self): g = Graph.Ring(10, circular=False) self.assertTrue(g.neighborhood_size() == [2, 3, 3, 3, 3, 3, 3, 3, 3, 2]) self.assertTrue(g.neighborhood_size(order=3) == [4, 5, 6, 7, 7, 7, 7, 6, 5, 4]) self.assertTrue( g.neighborhood_size(order=3, mindist=2) == [2, 2, 3, 4, 4, 4, 4, 3, 2, 2] ) class MiscTests(unittest.TestCase): def assert_valid_maximum_cardinality_search_result(self, graph, alpha, alpham1): visited = [] n = graph.vcount() not_visited = list(range(n)) # Check if alpham1 is a valid visiting order for vertex in reversed(alpham1): neis = graph.neighbors(vertex) visited_neis = sum(1 for v in neis if v in visited) for other_vertex in not_visited: neis = graph.neighbors(other_vertex) other_visited_neis = sum(1 for v in neis if v in visited) self.assertTrue(other_visited_neis <= visited_neis) visited.append(vertex) not_visited.remove(vertex) # Check if alpha is the inverse of alpham1 for index, vertex in enumerate(alpham1): self.assertEqual(alpha[vertex], index) def testBridges(self): g = Graph(5, [(0, 1), (1, 2), (2, 0), (0, 3), (3, 4)]) self.assertTrue(g.bridges() == [3, 4]) g = Graph(7, [(0, 1), (1, 2), (2, 0), (1, 6), (1, 3), (1, 4), (3, 5), (4, 5)]) self.assertTrue(g.bridges() == [3]) g = Graph(3, [(0, 1), (1, 2), (2, 3)]) self.assertTrue(g.bridges() == [0, 1, 2]) def testChordalCompletion(self): g = Graph() self.assertListEqual([], g.chordal_completion()) g = Graph.Full(3) self.assertListEqual([], g.chordal_completion()) g = Graph.Full(5) self.assertListEqual([], g.chordal_completion()) g = Graph.Ring(4) cc = g.chordal_completion() self.assertEqual(len(cc), 1) g += cc self.assertTrue(g.is_chordal()) self.assertListEqual([], g.chordal_completion()) g = Graph.Ring(5) cc = g.chordal_completion() self.assertEqual(len(cc), 2) g += cc self.assertListEqual([], g.chordal_completion()) def testChordalCompletionWithHints(self): g = Graph.Ring(4) alpha, _ = g.maximum_cardinality_search() cc = g.chordal_completion(alpha=alpha) self.assertEqual(len(cc), 1) g += cc self.assertTrue(g.is_chordal()) self.assertListEqual([], g.chordal_completion()) g = Graph.Ring(5) _, alpham1 = g.maximum_cardinality_search() cc = g.chordal_completion(alpham1=alpham1) self.assertEqual(len(cc), 2) g += cc self.assertListEqual([], g.chordal_completion()) def testConstraint(self): g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]) self.assertTrue(isinstance(g.constraint(), list)) # TODO check more def testTopologicalSorting(self): g = Graph(5, [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)], directed=True) self.assertTrue(g.topological_sorting() == [0, 4, 1, 2, 3]) self.assertTrue(g.topological_sorting(IN) == [3, 4, 2, 1, 0]) g.to_undirected() self.assertRaises(InternalError, g.topological_sorting) def testIsDAG(self): g = Graph(5, [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)], directed=True) self.assertTrue(g.is_dag()) g.to_undirected() self.assertFalse(g.is_dag()) g = Graph.Barabasi(1000, 2, directed=True) self.assertTrue(g.is_dag()) g = Graph.GRG(100, 0.2) self.assertFalse(g.is_dag()) g = Graph.Ring(10, directed=True, mutual=False) self.assertFalse(g.is_dag()) def testIsTree(self): g = Graph() self.assertFalse(g.is_tree()) g = Graph(directed=True) self.assertFalse(g.is_tree()) g = Graph(1) self.assertTrue(g.is_tree()) g = Graph(1, directed=True) self.assertTrue(g.is_tree() and g.is_tree("out") and g.is_tree("in") and g.is_tree("all")) g = Graph(5, [(0, 1), (1, 2), (1, 3), (3, 4)]) self.assertTrue(g.is_tree()) g = Graph(5, [(0, 1), (1, 2), (1, 3), (3, 4)], directed=True) self.assertTrue(g.is_tree()) self.assertTrue(g.is_tree("out")) self.assertFalse(g.is_tree("in")) self.assertTrue(g.is_tree("all")) g = Graph(5, [(0, 1), (1, 2), (3, 1), (3, 4)], directed=True) self.assertFalse(g.is_tree()) self.assertFalse(g.is_tree("in")) self.assertFalse(g.is_tree("out")) self.assertTrue(g.is_tree("all")) g = Graph(6, [(0, 4), (1, 5), (2, 1), (3, 1), (4, 3)], directed=True) self.assertFalse(g.is_tree()) self.assertTrue(g.is_tree("in")) self.assertFalse(g.is_tree("out")) self.assertTrue(g.is_tree("all")) g = Graph.Ring(10) self.assertFalse( g.is_tree() or g.is_tree("in") or g.is_tree("out") or g.is_tree("all") ) def testIsChordal(self): g = Graph() self.assertTrue(g.is_chordal()) g = Graph.Full(3) self.assertTrue(g.is_chordal()) g = Graph.Full(5) self.assertTrue(g.is_chordal()) g = Graph.Ring(4) self.assertFalse(g.is_chordal()) g = Graph.Ring(5) self.assertFalse(g.is_chordal()) def testIsChordalWithHint(self): g = Graph() alpha, _ = g.maximum_cardinality_search() self.assertTrue(g.is_chordal(alpha=alpha)) g = Graph.Full(3) alpha, _ = g.maximum_cardinality_search() self.assertTrue(g.is_chordal(alpha=alpha)) g = Graph.Ring(5) alpha, _ = g.maximum_cardinality_search() self.assertFalse(g.is_chordal(alpha=alpha)) g = Graph.Ring(4) _, alpham1 = g.maximum_cardinality_search() self.assertFalse(g.is_chordal(alpham1=alpham1)) g = Graph.Full(5) _, alpham1 = g.maximum_cardinality_search() self.assertTrue(g.is_chordal(alpham1=alpham1)) def testLineGraph(self): g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]) el = g.linegraph().get_edgelist() el.sort() self.assertTrue( el == [(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (2, 4), (3, 4)] ) g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)], directed=True) el = g.linegraph().get_edgelist() el.sort() self.assertTrue(el == [(0, 2), (0, 4)]) def testMaximumCardinalitySearch(self): g = Graph() alpha, alpham1 = g.maximum_cardinality_search() self.assertListEqual([], alpha) self.assertListEqual([], alpham1) g = Graph.Famous("petersen") alpha, alpham1 = g.maximum_cardinality_search() self.assert_valid_maximum_cardinality_search_result(g, alpha, alpham1) g = Graph.GRG(100, 0.2) alpha, alpham1 = g.maximum_cardinality_search() self.assert_valid_maximum_cardinality_search_result(g, alpha, alpham1) class PathTests(unittest.TestCase): def testShortestPaths(self): g = Graph( 10, [ (0, 1), (0, 2), (0, 3), (1, 2), (1, 4), (1, 5), (2, 3), (2, 6), (3, 2), (3, 6), (4, 5), (4, 7), (5, 6), (5, 8), (5, 9), (7, 5), (7, 8), (8, 9), (5, 2), (2, 1), ], directed=True, ) ws = [0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1] g.es["weight"] = ws expected = [ [0, 0, 0, 1, 5, 2, 1, 13, 3, 5], [inf, 0, 0, 1, 5, 2, 1, 13, 3, 5], [inf, 1, 0, 1, 6, 3, 1, 14, 4, 6], [inf, 1, 0, 0, 6, 3, 1, 14, 4, 6], [inf, 5, 4, 5, 0, 2, 3, 8, 3, 5], [inf, 3, 2, 3, 8, 0, 1, 16, 1, 3], [inf, inf, inf, inf, inf, inf, 0, inf, inf, inf], [inf, 4, 3, 4, 9, 1, 2, 0, 1, 4], [inf, inf, inf, inf, inf, inf, inf, inf, 0, 4], [inf, inf, inf, inf, inf, inf, inf, inf, inf, 0], ] self.assertTrue(g.shortest_paths(weights=ws) == expected) self.assertTrue(g.shortest_paths(weights="weight") == expected) self.assertTrue( g.shortest_paths(weights="weight", target=[2, 3]) == [row[2:4] for row in expected] ) def testGetShortestPaths(self): g = Graph(4, [(0, 1), (0, 2), (1, 3), (3, 2), (2, 1)], directed=True) sps = g.get_shortest_paths(0) expected = [[0], [0, 1], [0, 2], [0, 1, 3]] self.assertTrue(sps == expected) sps = g.get_shortest_paths(0, output="vpath") expected = [[0], [0, 1], [0, 2], [0, 1, 3]] self.assertTrue(sps == expected) sps = g.get_shortest_paths(0, output="epath") expected = [[], [0], [1], [0, 2]] self.assertTrue(sps == expected) self.assertRaises(ValueError, g.get_shortest_paths, 0, output="x") def testGetAllShortestPaths(self): g = Graph(4, [(0, 1), (1, 2), (1, 3), (2, 4), (3, 4), (4, 5)], directed=True) sps = sorted(g.get_all_shortest_paths(0, 0)) expected = [[0]] self.assertEqual(expected, sps) sps = sorted(g.get_all_shortest_paths(0, 5)) expected = [[0, 1, 2, 4, 5], [0, 1, 3, 4, 5]] self.assertEqual(expected, sps) sps = sorted(g.get_all_shortest_paths(1, 4)) expected = [[1, 2, 4], [1, 3, 4]] self.assertEqual(expected, sps) g = Graph.Lattice([5, 5], circular=False) sps = sorted(g.get_all_shortest_paths(0, 12)) expected = [ [0, 1, 2, 7, 12], [0, 1, 6, 7, 12], [0, 1, 6, 11, 12], [0, 5, 6, 7, 12], [0, 5, 6, 11, 12], [0, 5, 10, 11, 12], ] self.assertEqual(expected, sps) g = Graph.Lattice([100, 100], circular=False) sps = sorted(g.get_all_shortest_paths(0, 202)) expected = [ [0, 1, 2, 102, 202], [0, 1, 101, 102, 202], [0, 1, 101, 201, 202], [0, 100, 101, 102, 202], [0, 100, 101, 201, 202], [0, 100, 200, 201, 202], ] self.assertEqual(expected, sps) g = Graph.Lattice([100, 100], circular=False) sps = sorted(g.get_all_shortest_paths(0, [0, 202])) self.assertEqual([[0]] + expected, sps) g = Graph([(0, 1), (1, 2), (0, 2)]) g.es["weight"] = [0.5, 0.5, 1] sps = sorted(g.get_all_shortest_paths(0, weights="weight")) self.assertEqual([[0], [0, 1], [0, 1, 2], [0, 2]], sps) g = Graph.Lattice([4, 4], circular=False) g.es["weight"] = 1 g.es[2, 8]["weight"] = 100 sps = sorted(g.get_all_shortest_paths(0, [3, 12, 15], weights="weight")) self.assertEqual(20, len(sps)) self.assertEqual(4, sum(1 for path in sps if path[-1] == 3)) self.assertEqual(4, sum(1 for path in sps if path[-1] == 12)) self.assertEqual(12, sum(1 for path in sps if path[-1] == 15)) def testGetAllSimplePaths(self): g = Graph.Ring(20) sps = sorted(g.get_all_simple_paths(0, 10)) self.assertEqual( [ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [0, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10], ], sps, ) g = Graph.Ring(20, directed=True) sps = sorted(g.get_all_simple_paths(0, 10)) self.assertEqual([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], sps) sps = sorted(g.get_all_simple_paths(0, 10, mode="in")) self.assertEqual([[0, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10]], sps) sps = sorted(g.get_all_simple_paths(0, 10, mode="all")) self.assertEqual( [ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [0, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10], ], sps, ) g = Graph.Lattice([4, 4], circular=False) g = Graph([(min(u, v), max(u, v)) for u, v in g.get_edgelist()], directed=True) sps = sorted(g.get_all_simple_paths(0, 15)) self.assertEqual(20, len(sps)) for path in sps: self.assertEqual(0, path[0]) self.assertEqual(15, path[-1]) curr = path[0] for next in path[1:]: self.assertTrue(g.are_connected(curr, next)) curr = next def testPathLengthHist(self): g = Graph.Tree(15, 2) h = g.path_length_hist() self.assertTrue(h.unconnected == 0) self.assertTrue( [(int(value), x) for value, _, x in h.bins()] == [(1, 14), (2, 19), (3, 20), (4, 20), (5, 16), (6, 16)] ) g = Graph.Full(5) + Graph.Full(4) h = g.path_length_hist() self.assertTrue(h.unconnected == 20) g.to_directed() h = g.path_length_hist() self.assertTrue(h.unconnected == 40) h = g.path_length_hist(False) self.assertTrue(h.unconnected == 20) class DominatorTests(unittest.TestCase): def compareDomTrees(self, alist, blist): """ Required due to NaN use for isolated nodes """ if len(alist) != len(blist): return False for i, (a, b) in enumerate(zip(alist, blist)): if math.isnan(a) and math.isnan(b): continue elif a == b: continue else: return False return True def testDominators(self): # examples taken from igraph's examples/simple/dominator_tree.out # initial g = Graph( 13, [ (0, 1), (0, 7), (0, 10), (1, 2), (1, 5), (2, 3), (3, 4), (4, 3), (4, 0), (5, 3), (5, 6), (6, 3), (7, 8), (7, 10), (7, 11), (8, 9), (9, 4), (9, 8), (10, 11), (11, 12), (12, 9), ], directed=True, ) s = [-1, 0, 1, 0, 0, 1, 5, 0, 0, 0, 0, 0, 11] r = g.dominator(0) self.assertTrue(self.compareDomTrees(s, r)) # flipped edges g = Graph( 13, [ (1, 0), (2, 0), (3, 0), (4, 1), (1, 2), (4, 2), (5, 2), (6, 3), (7, 3), (12, 4), (8, 5), (9, 6), (9, 7), (10, 7), (5, 8), (11, 8), (11, 9), (9, 10), (9, 11), (0, 11), (8, 12), ], directed=True, ) s = [-1, 0, 0, 0, 0, 0, 3, 3, 0, 0, 7, 0, 4] r = g.dominator(0, mode=IN) self.assertTrue(self.compareDomTrees(s, r)) # disconnected components g = Graph( 20, [ (0, 1), (0, 2), (0, 3), (1, 4), (2, 1), (2, 4), (2, 8), (3, 9), (3, 10), (4, 15), (8, 11), (9, 12), (10, 12), (10, 13), (11, 8), (11, 14), (12, 14), (13, 12), (14, 12), (14, 0), (15, 11), ], directed=True, ) s = [ -1, 0, 0, 0, 0, float("nan"), float("nan"), float("nan"), 0, 3, 3, 0, 0, 10, 0, 4, float("nan"), float("nan"), float("nan"), float("nan"), ] r = g.dominator(0, mode=OUT) self.assertTrue(self.compareDomTrees(s, r)) def suite(): simple_suite = unittest.makeSuite(SimplePropertiesTests) degree_suite = unittest.makeSuite(DegreeTests) local_transitivity_suite = unittest.makeSuite(LocalTransitivityTests) biconnected_suite = unittest.makeSuite(BiconnectedComponentTests) centrality_suite = unittest.makeSuite(CentralityTests) neighborhood_suite = unittest.makeSuite(NeighborhoodTests) path_suite = unittest.makeSuite(PathTests) misc_suite = unittest.makeSuite(MiscTests) dominator_suite = unittest.makeSuite(DominatorTests) return unittest.TestSuite( [ simple_suite, degree_suite, local_transitivity_suite, biconnected_suite, centrality_suite, neighborhood_suite, path_suite, misc_suite, dominator_suite, ] ) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_unicode_issues.py0000644000175100001710000000123200000000000021375 0ustar00runnerdocker00000000000000import unittest from igraph import Graph class UnicodeTests(unittest.TestCase): def testBug128(self): y = [1, 4, 9] g = Graph(n=len(y), directed=True, vertex_attrs={"y": y}) self.assertEqual(3, g.vcount()) g.add_vertices(1) # Bug #128 would prevent us from reaching the next statement # because an exception would have been thrown here self.assertEqual(4, g.vcount()) def suite(): generator_suite = unittest.makeSuite(UnicodeTests) return unittest.TestSuite([generator_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_vertexseq.py0000644000175100001710000003337200000000000020414 0ustar00runnerdocker00000000000000# vim:ts=4 sw=4 sts=4: import unittest from igraph import * from .utils import is_pypy try: import numpy as np except ImportError: np = None class VertexTests(unittest.TestCase): def setUp(self): self.g = Graph.Full(10) def testHash(self): data = {} n = self.g.vcount() for i in range(n): code1 = hash(self.g.vs[i]) code2 = hash(self.g.vs[i]) self.assertEqual(code1, code2) data[self.g.vs[i]] = i for i in range(n): self.assertEqual(i, data[self.g.vs[i]]) def testRichCompare(self): g2 = Graph.Full(10) for i in range(self.g.vcount()): for j in range(self.g.vcount()): self.assertEqual(i == j, self.g.vs[i] == self.g.vs[j]) self.assertEqual(i != j, self.g.vs[i] != self.g.vs[j]) self.assertEqual(i < j, self.g.vs[i] < self.g.vs[j]) self.assertEqual(i > j, self.g.vs[i] > self.g.vs[j]) self.assertEqual(i <= j, self.g.vs[i] <= self.g.vs[j]) self.assertEqual(i >= j, self.g.vs[i] >= self.g.vs[j]) self.assertFalse(self.g.vs[i] == g2.vs[j]) self.assertFalse(self.g.vs[i] != g2.vs[j]) self.assertFalse(self.g.vs[i] < g2.vs[j]) self.assertFalse(self.g.vs[i] > g2.vs[j]) self.assertFalse(self.g.vs[i] <= g2.vs[j]) self.assertFalse(self.g.vs[i] >= g2.vs[j]) self.assertFalse(self.g.es[i] == self.g.vs[j]) def testUpdateAttributes(self): v = self.g.vs[0] v.update_attributes(a=2) self.assertEqual(v["a"], 2) v.update_attributes([("a", 3), ("b", 4)], c=5, d=6) self.assertEqual(v.attributes(), dict(a=3, b=4, c=5, d=6)) v.update_attributes(dict(b=44, c=55)) self.assertEqual(v.attributes(), dict(a=3, b=44, c=55, d=6)) def testPhantomVertex(self): v = self.g.vs[9] v.delete() # v is now a phantom vertex; try to freak igraph out now :) self.assertRaises(ValueError, v.update_attributes, a=2) self.assertRaises(ValueError, v.__getitem__, "a") self.assertRaises(ValueError, v.__setitem__, "a", 4) self.assertRaises(ValueError, v.__delitem__, "a") self.assertRaises(ValueError, v.attributes) def testIncident(self): g = Graph.Famous("petersen") g.to_directed() method_table = {"all": "all_edges", "in": "in_edges", "out": "out_edges"} for i in range(g.vcount()): vertex = g.vs[i] for mode, method_name in list(method_table.items()): method = getattr(vertex, method_name) self.assertEqual( g.incident(i, mode=mode), [edge.index for edge in vertex.incident(mode=mode)], ) self.assertEqual( g.incident(i, mode=mode), [edge.index for edge in method()] ) def testNeighbors(self): g = Graph.Famous("petersen") g.to_directed() for i in range(g.vcount()): vertex = g.vs[i] for mode in "all in out".split(): self.assertEqual( g.neighbors(i, mode=mode), [edge.index for edge in vertex.neighbors(mode=mode)], ) @unittest.skipIf(is_pypy, "skipped on PyPy because we do not have access to docstrings") def testProxyMethods(self): # We only test with connected graphs because disconnected graphs might # print a warning when shortest_paths() is invoked on them and we want # to avoid that in the test output. while True: g = Graph.GRG(10, 0.6) if g.is_connected(): break v = g.vs[0] # - neighbors(), predecessors() and succesors() are ignored because they # return vertex lists while the methods in Graph return vertex index # lists. # - incident(), all_edges(), in_edges() and out_edges() are ignored # because it returns an edge list while the methods in Graph return # edge indices. # - pagerank() and personalized_pagerank() are ignored because of numerical # inaccuracies # - delete() is ignored because it mutates the graph ignore = ( "neighbors predecessors successors pagerank personalized_pagerank" " delete incident all_edges in_edges out_edges" ) ignore = set(ignore.split()) # Methods not listed here are expected to return an int or a float return_types = {"get_shortest_paths": list, "shortest_paths": list} for name in Vertex.__dict__: if name in ignore: continue func = getattr(v, name) docstr = func.__doc__ if not docstr.startswith("Proxy method"): continue result = func() self.assertEqual( getattr(g, name)(v.index), result, msg=("Vertex.%s proxy method misbehaved" % name), ) return_type = return_types.get(name, (int, float)) self.assertTrue( isinstance(result, return_type), msg=("Vertex.%s proxy method did not return %s" % (name, return_type)), ) class VertexSeqTests(unittest.TestCase): def setUp(self): self.g = Graph.Full(10) self.g.vs["test"] = list(range(10)) self.g.vs["name"] = list("ABCDEFGHIJ") def testCreation(self): self.assertTrue(len(VertexSeq(self.g)) == 10) self.assertTrue(len(VertexSeq(self.g, 2)) == 1) self.assertTrue(len(VertexSeq(self.g, [1, 2, 3])) == 3) self.assertTrue(VertexSeq(self.g, [1, 2, 3]).indices == [1, 2, 3]) self.assertRaises(ValueError, VertexSeq, self.g, 12) self.assertRaises(ValueError, VertexSeq, self.g, [12]) self.assertTrue(self.g.vs.graph == self.g) def testIndexing(self): n = self.g.vcount() for i in range(n): self.assertEqual(i, self.g.vs[i].index) self.assertEqual(n - i - 1, self.g.vs[-i - 1].index) self.assertRaises(IndexError, self.g.vs.__getitem__, n) self.assertRaises(IndexError, self.g.vs.__getitem__, -n - 1) self.assertRaises(TypeError, self.g.vs.__getitem__, 1.5) @unittest.skipIf(np is None, "test case depends on NumPy") def testNumPyIndexing(self): n = self.g.vcount() for i in range(self.g.vcount()): arr = np.array([i]) self.assertEqual(i, self.g.vs[arr[0]].index) arr = np.array([-i - 1]) self.assertEqual(n - i - 1, self.g.vs[arr[0]].index) arr = np.array([n]) self.assertRaises(IndexError, self.g.vs.__getitem__, arr[0]) arr = np.array([-n - 1]) self.assertRaises(IndexError, self.g.vs.__getitem__, arr[0]) arr = np.array([1.5]) self.assertRaises(TypeError, self.g.vs.__getitem__, arr[0]) ind = [1, 3, 5, 8, 3, 2] arr = np.array(ind) self.assertEqual(ind, [vertex.index for vertex in self.g.vs[arr.tolist()]]) self.assertEqual(ind, [vertex.index for vertex in self.g.vs[list(arr)]]) def testPartialAttributeAssignment(self): only_even = self.g.vs.select(lambda v: (v.index % 2 == 0)) only_even["test"] = [0] * len(only_even) self.assertTrue(self.g.vs["test"] == [0, 1, 0, 3, 0, 5, 0, 7, 0, 9]) only_even["test2"] = list(range(5)) self.assertTrue( self.g.vs["test2"] == [0, None, 1, None, 2, None, 3, None, 4, None] ) def testSequenceReusing(self): if "test" in self.g.vertex_attributes(): del self.g.vs["test"] self.g.vs["test"] = ["A", "B", "C"] self.assertTrue( self.g.vs["test"] == ["A", "B", "C", "A", "B", "C", "A", "B", "C", "A"] ) self.g.vs["test"] = "ABC" self.assertTrue(self.g.vs["test"] == ["ABC"] * 10) only_even = self.g.vs.select(lambda v: (v.index % 2 == 0)) only_even["test"] = ["D", "E"] self.assertTrue( self.g.vs["test"] == ["D", "ABC", "E", "ABC", "D", "ABC", "E", "ABC", "D", "ABC"] ) del self.g.vs["test"] only_even["test"] = ["D", "E"] self.assertTrue( self.g.vs["test"] == ["D", None, "E", None, "D", None, "E", None, "D", None] ) def testAllSequence(self): self.assertTrue(len(self.g.vs) == 10) self.assertTrue(self.g.vs["test"] == list(range(10))) def testEmptySequence(self): empty_vs = self.g.vs.select(None) self.assertTrue(len(empty_vs) == 0) self.assertRaises(IndexError, empty_vs.__getitem__, 0) self.assertRaises(KeyError, empty_vs.__getitem__, "nonexistent") self.assertTrue(empty_vs["test"] == []) empty_vs = self.g.vs[[]] self.assertTrue(len(empty_vs) == 0) empty_vs = self.g.vs[()] self.assertTrue(len(empty_vs) == 0) def testCallableFilteringFind(self): vertex = self.g.vs.find(lambda v: (v.index % 2 == 1)) self.assertTrue(vertex.index == 1) self.assertRaises(IndexError, self.g.vs.find, lambda v: (v.index % 2 == 3)) def testCallableFilteringSelect(self): only_even = self.g.vs.select(lambda v: (v.index % 2 == 0)) self.assertTrue(len(only_even) == 5) self.assertRaises(KeyError, only_even.__getitem__, "nonexistent") self.assertTrue(only_even["test"] == [0, 2, 4, 6, 8]) def testChainedCallableFilteringSelect(self): only_div_six = self.g.vs.select( lambda v: (v.index % 2 == 0), lambda v: (v.index % 3 == 0) ) self.assertTrue(len(only_div_six) == 2) self.assertTrue(only_div_six["test"] == [0, 6]) only_div_six = self.g.vs.select(lambda v: (v.index % 2 == 0)).select( lambda v: (v.index % 3 == 0) ) self.assertTrue(len(only_div_six) == 2) self.assertTrue(only_div_six["test"] == [0, 6]) def testIntegerFilteringFind(self): self.assertEqual(self.g.vs.find(3).index, 3) self.assertEqual(self.g.vs.select(2, 3, 4, 2).find(3).index, 2) self.assertRaises(IndexError, self.g.vs.find, 17) def testIntegerFilteringSelect(self): subset = self.g.vs.select(2, 3, 4, 2) self.assertEqual(len(subset), 4) self.assertEqual(subset["test"], [2, 3, 4, 2]) self.assertRaises(TypeError, self.g.vs.select, 2, 3, 4, 2, None) subset = self.g.vs[2, 3, 4, 2] self.assertTrue(len(subset) == 4) self.assertTrue(subset["test"] == [2, 3, 4, 2]) def testStringFilteringFind(self): self.assertEqual(self.g.vs.find("D").index, 3) self.assertEqual(self.g.vs.select(2, 3, 4, 2).find("C").index, 2) self.assertRaises(ValueError, self.g.vs.select(2, 3, 4, 2).find, "F") self.assertRaises(ValueError, self.g.vs.find, "NoSuchName") def testIterableFilteringSelect(self): subset = self.g.vs.select(list(range(5, 8))) self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [5, 6, 7]) def testSliceFilteringSelect(self): subset = self.g.vs.select(slice(5, 8)) self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [5, 6, 7]) subset = self.g.vs[5:16:2] self.assertTrue(len(subset) == 3) self.assertTrue(subset["test"] == [5, 7, 9]) def testKeywordFilteringSelect(self): g = Graph.Barabasi(10000) g.vs["degree"] = g.degree() g.vs["parity"] = [i % 2 for i in range(g.vcount())] l = len(g.vs(degree_gt=30)) self.assertTrue(l < 1000) self.assertTrue(len(g.vs(degree_gt=30, parity=0)) <= 500) del g.vs["degree"] self.assertTrue(len(g.vs(_degree_gt=30)) == l) def testIndexAndKeywordFilteringFind(self): self.assertRaises(ValueError, self.g.vs.find, 2, name="G") self.assertRaises(ValueError, self.g.vs.find, 2, test=4) self.assertTrue(self.g.vs.find(2, name="C") == self.g.vs[2]) self.assertTrue(self.g.vs.find(2, test=2) == self.g.vs[2]) def testIndexOutOfBoundsSelect(self): g = Graph.Full(3) self.assertRaises(ValueError, g.vs.select, 4) self.assertRaises(ValueError, g.vs.select, 4, 5) self.assertRaises(ValueError, g.vs.select, (4, 5)) self.assertRaises(ValueError, g.vs.select, 2, -1) self.assertRaises(ValueError, g.vs.select, (2, -1)) self.assertRaises(ValueError, g.vs.__getitem__, (0, 1000000)) def testGraphMethodProxying(self): g = Graph.Barabasi(100) vs = g.vs(1, 3, 5, 7, 9) self.assertEqual(vs.degree(), g.degree(vs)) self.assertEqual(g.degree(vs), g.degree(vs.indices)) for v, d in zip(vs, vs.degree()): self.assertEqual(v.degree(), d) def testBug73(self): # This is a regression test for igraph/python-igraph#73 g = Graph() g.add_vertices(3) g.vs[0]["name"] = 1 g.vs[1]["name"] = "h" g.vs[2]["name"] = 17 self.assertEqual(1, g.vs.find("h").index) self.assertEqual(1, g.vs.find(1).index) self.assertEqual(0, g.vs.find(name=1).index) self.assertEqual(2, g.vs.find(name=17).index) def testBug367(self): # This is a regression test for igraph/python-igraph#367 g = Graph() g.add_vertices([1, 2, 5]) self.assertEqual([1, 2, 5], g.vs["name"]) self.assertEqual(2, g.vs.find(name=5).index) def suite(): vertex_suite = unittest.makeSuite(VertexTests) vs_suite = unittest.makeSuite(VertexSeqTests) return unittest.TestSuite([vertex_suite, vs_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/test_walks.py0000644000175100001710000000426700000000000017510 0ustar00runnerdocker00000000000000import random import unittest from igraph import Graph, InternalError class RandomWalkTests(unittest.TestCase): def validate_walk(self, g, walk, start, length, mode="out"): prev = None for vertex in walk: if prev is not None: self.assertTrue(vertex in g.neighbors(prev, mode=mode)) else: self.assertEqual(start, vertex) prev = vertex def testRandomWalkUndirected(self): g = Graph.GRG(100, 0.2) for i in range(100): start = random.randint(0, g.vcount() - 1) length = random.randint(0, 10) walk = g.random_walk(start, length) self.validate_walk(g, walk, start, length) def testRandomWalkDirectedOut(self): g = Graph.Tree(121, 3, mode="out") mode = "out" for i in range(100): start = 0 length = random.randint(0, 4) walk = g.random_walk(start, length, mode) self.validate_walk(g, walk, start, length, mode) def testRandomWalkDirectedIn(self): g = Graph.Tree(121, 3, mode="out") mode = "in" for i in range(100): start = random.randint(40, g.vcount() - 1) length = random.randint(0, 4) walk = g.random_walk(start, length, mode) self.validate_walk(g, walk, start, length, mode) def testRandomWalkDirectedAll(self): g = Graph.Tree(121, 3, mode="out") mode = "all" for i in range(100): start = random.randint(0, g.vcount() - 1) length = random.randint(0, 10) walk = g.random_walk(start, length, mode) self.validate_walk(g, walk, start, length, mode) def testRandomWalkStuck(self): g = Graph.Ring(10, circular=False, directed=True) walk = g.random_walk(5, 20) self.assertEqual([5, 6, 7, 8, 9], walk) self.assertRaises(InternalError, g.random_walk, 5, 20, stuck="error") def suite(): random_walk_suite = unittest.makeSuite(RandomWalkTests) return unittest.TestSuite([random_walk_suite]) def test(): runner = unittest.TextTestRunner() runner.run(suite()) if __name__ == "__main__": test() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822574.0 igraph-0.9.9/tests/utils.py0000644000175100001710000000174700000000000016470 0ustar00runnerdocker00000000000000"""Utility functions for unit testing.""" import os import platform import tempfile from contextlib import contextmanager from textwrap import dedent __all__ = ("temporary_file", ) @contextmanager def temporary_file(content=None, mode=None, binary=False): tmpf, tmpfname = tempfile.mkstemp() os.close(tmpf) if mode is None: if content is None: mode = "rb" else: mode = "wb" tmpf = open(tmpfname, mode) if content is not None: if hasattr(content, "encode") and not binary: tmpf.write(dedent(content).encode("utf8")) else: tmpf.write(content) tmpf.close() yield tmpfname try: os.unlink(tmpfname) except Exception: # ignore exceptions; it happens sometimes on Windows in the CI environment # that it cannot remove the temporary file because another process (?) is # using it... pass is_pypy = platform.python_implementation() == "PyPy" ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392 igraph-0.9.9/vendor/0000755000175100001710000000000000000000000015100 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392 igraph-0.9.9/vendor/source/0000755000175100001710000000000000000000000016400 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/0000755000175100001710000000000000000000000017652 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.astylerc0000644000175100001710000000140200000000000021476 0ustar00runnerdocker00000000000000# General Options: # - Only display errors # - Redirect stderr to stdout # - Enforce linux lineendings # - Preserve file modification date # - Do not create file backups, everything should be VCSed anyway --quiet --errors-to-stdout --lineend=linux --preserve-date --suffix=none # Style --style=java # Use 4 spaces --indent=spaces=4 --convert-tabs # Paddings around operators, parentheses, and a header --pad-oper --pad-header # Continuation blocks should have no extra indentation --min-conditional-indent=0 # Indent preprocessor blocks and defines --indent-preproc-block --indent-preproc-define # Add braces around single-line branches --add-braces # Keep complex statement sequences on the same line; they are that way for # a reason --keep-one-line-statements ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/.azure/0000755000175100001710000000000000000000000021056 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.azure/build-win.yml0000644000175100001710000000711400000000000023476 0ustar00runnerdocker00000000000000parameters: - name: int_blas type: boolean default: true - name: int_lapack type: boolean default: true - name: int_arpack type: boolean default: true - name: int_cxsparse type: boolean default: true - name: int_gmp type: boolean default: true - name: int_glpk type: boolean default: true - name: verify_finally type: boolean default: true - name: build_shared type: boolean default: false - name: enable_tls type: boolean default: true - name: build_type type: string default: 'RelWithDebInfo' - name: extra_cmake_args type: string default: '' - name: extra_ctest_args type: string default: '' - name: print_arith_header type: boolean default: true - name: vcpkg_target_triplet type: string default: 'x64-windows-static-md' steps: - task: Cache@2 inputs: key: >- vcpkg-installed | $(Agent.Os) | ${{ parameters.vcpkg_target_triplet }} path: $(VCPKG_INSTALLATION_ROOT)\installed cacheHitVar: VcpkgRestoredFromCache displayName: Vcpkg Cache - script: | choco install winflexbison3 ninja %VCPKG_INSTALLATION_ROOT%\vcpkg.exe integrate install %VCPKG_INSTALLATION_ROOT%\vcpkg.exe install libxml2:${{ parameters.vcpkg_target_triplet }} displayName: Install dependencies # Notes: # - We call vcvarsall.bat to make sure the compiler (cl.exe) is in the path, and so that we can select the desired MSVC version. # https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-160#vcvarsall-syntax # This is necessary when not using the Visual Studio CMake generator. # - Due to this setup, CMake must also be called in the same script instead of using the CMake task # - We must set CXX and CC so that CMake would not accidentally pick up another compiler. # - With the above, we can use the Ninja generator, which enables much faster build times than the VS one due to better parallelization. # - We need to add the bin directory to the path to be able to find the libxml2 dependency. - script: | md build cd build call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64 -vcvars_ver=14.0 set CXX=cl.exe set CC=cl.exe cmake .. -DCMAKE_PREFIX_PATH=%CONDA%\Library\lib ^ -DIGRAPH_USE_INTERNAL_BLAS=${{ parameters.int_blas }} ^ -DIGRAPH_USE_INTERNAL_LAPACK=${{ parameters.int_lapack }} ^ -DIGRAPH_USE_INTERNAL_ARPACK=${{ parameters.int_arpack }} ^ -DIGRAPH_USE_INTERNAL_GLPK=${{ parameters.int_glpk }} ^ -DIGRAPH_USE_INTERNAL_CXSPARSE=${{ parameters.int_cxsparse }} ^ -DIGRAPH_USE_INTERNAL_GMP=${{ parameters.int_gmp }} ^ -DIGRAPH_VERIFY_FINALLY_STACK=${{ parameters.verify_finally }} ^ -DBUILD_SHARED_LIBS=${{ parameters.build_shared }} ^ -DIGRAPH_ENABLE_TLS=${{ parameters.enable_tls }} ^ -DCMAKE_BUILD_TYPE=${{ parameters.build_type }} ^ -DIGRAPH_PRINT_ARITH_HEADER=${{ parameters.print_arith_header }} ^ -DVCPKG_TARGET_TRIPLET=${{ parameters.vcpkg_target_triplet }} ^ -DCMAKE_TOOLCHAIN_FILE=%VCPKG_INSTALLATION_ROOT%/scripts/buildsystems/vcpkg.cmake ^ ${{ parameters.extra_cmake_args }} cmake --build . --target build_tests displayName: Configure and build - script: cd build && ctest -j 4 --output-on-failure ${{ parameters.extra_ctest_args }} --timeout 60 displayName: Test ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.azure/build.yml0000644000175100001710000000417300000000000022705 0ustar00runnerdocker00000000000000parameters: - name: int_blas type: boolean default: true - name: int_lapack type: boolean default: true - name: int_arpack type: boolean default: true - name: int_cxsparse type: boolean default: true - name: int_gmp type: boolean default: true - name: int_glpk type: boolean default: true - name: verify_finally type: boolean default: true - name: build_shared type: boolean default: false - name: enable_tls type: boolean default: true - name: build_type type: string default: 'RelWithDebInfo' - name: extra_cmake_args type: string default: '' - name: extra_ctest_args type: string default: '' - name: use_ccache type: boolean default: true - name: print_arith_header type: boolean default: true steps: - task: CMake@1 displayName: CMake inputs: cmakeArgs: > .. -DIGRAPH_USE_INTERNAL_BLAS=${{ parameters.int_blas }} -DIGRAPH_USE_INTERNAL_LAPACK=${{ parameters.int_lapack }} -DIGRAPH_USE_INTERNAL_ARPACK=${{ parameters.int_arpack }} -DIGRAPH_USE_INTERNAL_GLPK=${{ parameters.int_glpk }} -DIGRAPH_USE_INTERNAL_CXSPARSE=${{ parameters.int_cxsparse }} -DIGRAPH_USE_INTERNAL_GMP=${{ parameters.int_gmp }} -DIGRAPH_VERIFY_FINALLY_STACK=${{ parameters.verify_finally }} -DBUILD_SHARED_LIBS=${{ parameters.build_shared }} -DIGRAPH_ENABLE_TLS=${{ parameters.enable_tls }} -DCMAKE_BUILD_TYPE=${{ parameters.build_type }} -DIGRAPH_PRINT_ARITH_HEADER=${{ parameters.print_arith_header }} ${{ parameters.extra_cmake_args }} - task: Cache@2 condition: eq('${{ parameters.use_ccache }}', true) inputs: key: 'ccache | "$(Agent.OS)"' path: $(CCACHE_DIR) displayName: Ccache - task: CMake@1 displayName: Build inputs: cmakeArgs: '--build . --target build_tests --target build_benchmarks' # TODO: use -j `nproc` on Linux , -j `sysctl -n hw.ncpu` on Darwin - script: cd build && ctest -j 4 --output-on-failure ${{ parameters.extra_ctest_args }} --timeout 60 displayName: Test ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.editorconfig0000644000175100001710000000031700000000000022330 0ustar00runnerdocker00000000000000root = true [*] charset = utf-8 end_of_line = lf insert_final_newline = true trim_trailing_whitespace = true [*.{c,cc,cpp,h,hh,hpp,pmt}] indent_style = space indent_size = 4 [Makefile] indent_style = tab ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.git0000644000175100001710000000006300000000000020435 0ustar00runnerdocker00000000000000gitdir: ../../../.git/modules/vendor/source/igraph ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/.github/0000755000175100001710000000000000000000000021212 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/.github/ISSUE_TEMPLATE/0000755000175100001710000000000000000000000023375 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/ISSUE_TEMPLATE/bug_report.md0000644000175100001710000000053500000000000026072 0ustar00runnerdocker00000000000000--- name: Bug report about: Report a problem in the igraph C library title: '' labels: '' assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **To reproduce** Steps or minimal example code to reproduce the problem. **Version information** Which version of igraph are you using and where did you obtain it? ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/ISSUE_TEMPLATE/config.yml0000644000175100001710000000020200000000000025357 0ustar00runnerdocker00000000000000contact_links: - name: igraph support url: https://igraph.discourse.group/ about: Ask and answer questions about igraph ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/ISSUE_TEMPLATE/feature_request.md0000644000175100001710000000065300000000000027126 0ustar00runnerdocker00000000000000--- name: Feature request about: Suggest an idea for igraph title: '' labels: '' assignees: '' --- **What is the feature or improvement you would like to see?** A concise but mathematically precise description of the requested feature. **Use cases for the feature** Explain when and for what purpose the feature would be useful. **References** List any relevant references (papers or books describing relevant algorithms). ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/.github/codeql/0000755000175100001710000000000000000000000022461 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/codeql/codeql-config.yml0000644000175100001710000000021700000000000025716 0ustar00runnerdocker00000000000000name: "igraph CodeQL config" # paths-ignore only influences interpreted languages so we cannot use that to # exclude parts of the source tree ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/stale.yml0000644000175100001710000000132100000000000023042 0ustar00runnerdocker00000000000000# Number of days of inactivity before an issue becomes stale daysUntilStale: 60 # Number of days of inactivity before a stale issue is closed daysUntilClose: 14 # Issues with these labels will never be considered stale exemptLabels: - pinned - security - todo - wishlist # Label to use when marking an issue as stale staleLabel: stale # Comment to post when marking an issue as stale. Set to `false` to disable markComment: > This issue has been automatically marked as stale because it has not had recent activity. It will be closed in 14 days if no further activity occurs. Thank you for your contributions. # Comment to post when closing a stale issue. Set to `false` to disable closeComment: false ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4191396 igraph-0.9.9/vendor/source/igraph/.github/workflows/0000755000175100001710000000000000000000000023247 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/workflows/build-cmake.yml0000644000175100001710000000415500000000000026154 0ustar00runnerdocker00000000000000name: MINGW # TODO: Check the BRANCHES element when merging the branch 'develop' to, say, 'master'. on: push: branches: - '**' - '!appveyor/**' - '!travis/**' pull_request: jobs: build: runs-on: windows-latest strategy: fail-fast: false matrix: arch: ['i686', 'x86_64', 'ucrt-x86_64'] shared_libs: ['shared', 'static'] include: - arch: i686 msystem: MINGW32 - arch: x86_64 msystem: MINGW64 - arch: ucrt-x86_64 msystem: UCRT64 defaults: run: shell: msys2 {0} steps: - name: Init ${{ matrix.msystem }}-System uses: msys2/setup-msys2@v2 with: msystem: ${{ matrix.msystem }} install: git base-devel mingw-w64-${{ matrix.arch }}-cmake mingw-w64-${{ matrix.arch }}-ninja mingw-w64-${{ matrix.arch }}-toolchain mingw-w64-${{ matrix.arch }}-glpk mingw-w64-${{ matrix.arch }}-gmp mingw-w64-${{ matrix.arch }}-libxml2 mingw-w64-${{ matrix.arch }}-suitesparse mingw-w64-${{ matrix.arch }}-lapack update: true - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 0 - name: Configuration run: | mkdir -p build-${{ matrix.arch }} cd build-${{ matrix.arch }} cmake .. -GNinja -DBUILD_SHARED_LIBS=${{ matrix.shared_libs == 'shared' && 'ON' || 'OFF' }} -DIGRAPH_GLPK_SUPPORT=ON -DIGRAPH_GRAPHML_SUPPORT=ON -DIGRAPH_ENABLE_TLS=ON -DIGRAPH_VERIFY_FINALLY_STACK=ON -DBLA_VENDOR=Generic -DIGRAPH_PRINT_ARITH_HEADER=ON -DIGRAPH_USE_INTERNAL_GLPK=ON - name: Build run: cmake --build . --target build_tests working-directory: build-${{ matrix.arch }} - name: Test run: ctest -j $(nproc) --output-on-failure --timeout 180 working-directory: build-${{ matrix.arch }} - name: Generate Artifacts upon Failure if: ${{ failure() }} uses: actions/upload-artifact@v2 with: name: failure path: | build-${{ matrix.arch }}/tests/* !build-${{ matrix.arch }}/tests/*.exe ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/workflows/codecov.yml0000644000175100001710000000173500000000000025422 0ustar00runnerdocker00000000000000name: Codecov.io on: [push, pull_request] env: BUILD_TYPE: Debug jobs: build: runs-on: ubuntu-latest steps: - name: Install dependencies run: sudo apt-get install lcov libglpk-dev libarpack2-dev - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 0 - name: Create build environment run: cmake -E make_directory ${{github.workspace}}/build - name: Configure shell: bash working-directory: ${{github.workspace}}/build run: cmake $GITHUB_WORKSPACE -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DIGRAPH_ENABLE_TLS=ON -DIGRAPH_ENABLE_CODE_COVERAGE=ON - name: Build working-directory: ${{github.workspace}}/build shell: bash run: cmake --build . --parallel - name: Coverage working-directory: ${{github.workspace}}/build shell: bash run: cmake --build . --target coverage --parallel - name: Codecov.io uses: codecov/codecov-action@v1.2.1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/workflows/codeql-analysis.yml0000644000175100001710000000432300000000000027064 0ustar00runnerdocker00000000000000# For most projects, this workflow file will not need changing; you simply need # to commit it to your repository. # # You may wish to alter this file to override the set of languages analyzed, # or to provide custom queries or build logic. name: "CodeQL" on: push: branches: [ master, develop ] pull_request: # The branches below must be a subset of the branches above branches: [ master, develop ] schedule: - cron: '24 13 * * 4' jobs: analyze: name: Analyze runs-on: ubuntu-latest permissions: actions: read contents: read security-events: write strategy: fail-fast: false matrix: language: [ 'cpp' ] # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ] # Learn more about CodeQL language support at https://git.io/codeql-language-support steps: - name: Install dependencies run: sudo apt-get install ninja-build cmake libarpack2-dev libglpk-dev libgmp-dev - name: Checkout repository uses: actions/checkout@v2 with: fetch-depth: 0 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v1 with: config-file: ./.github/codeql/codeql-config.yml languages: ${{ matrix.language }} # If you wish to specify custom queries, you can do so here or in a config file. # By default, queries listed here will override any specified in a config file. # Prefix the list here with "+" to use these queries and those in the config file. # queries: ./path/to/local/query, your-org/your-repo/queries@main # â„¹ï¸ Command-line programs to run using the OS shell. # 📚 https://git.io/JvXDl # âœï¸ If the Autobuild fails above, remove it and uncomment the following three lines # and modify them (or add more) to build your code if your project # uses a compiled language - run: | cmake -GNinja -B build cmake --build build # Remove temporary CMake stuff so the code analysis does not run on # them rm -rf build/CMakeFiles/CMakeTmp - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.github/workflows/stimulus.yml0000644000175100001710000000141700000000000025662 0ustar00runnerdocker00000000000000name: Stimulus on: [push, pull_request] jobs: ci: runs-on: ubuntu-latest env: STIMULUS_VERSION: "0.8.0" steps: - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 0 - name: Configure igraph run: | mkdir build && cd build cmake .. - name: Install stimulus run: | cd interfaces python3 -m venv .venv .venv/bin/pip install 'git+https://github.com/igraph/stimulus.git@${{ env.STIMULUS_VERSION }}#egg=stimulus' - name: Validate functions.yaml run: | cd interfaces .venv/bin/stimulus -f functions.yaml -t types.yaml -l ci:validate -o test.cpp c++ -std=c++14 -c test.cpp -I ../include -I ../build/include ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.gitignore0000644000175100001710000000012400000000000021637 0ustar00runnerdocker00000000000000*~ .*.swp .dirstamp .vscode/ /tags /IGRAPH_VERSION /build /build-* /tools/**/*.pyc ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.pre-commit-config.yaml0000644000175100001710000000063000000000000024132 0ustar00runnerdocker00000000000000fail_fast: true exclude: "(^vendor/|\\.patch$)" repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v3.4.0 hooks: - id: mixed-line-ending args: ["--fix=lf"] exclude: "\\.net$" - id: end-of-file-fixer exclude: "\\.out$" - id: trailing-whitespace exclude: "\\.out$" - id: check-merge-conflict - id: fix-byte-order-marker ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.travis.yml0000644000175100001710000000605600000000000021772 0ustar00runnerdocker00000000000000 language: c cache: ccache # dist: xenial os: linux # Ignore branches with names starting with certain keywords: branches: except: - /^(appveyor|github)\/.+$/ env: global: - CMAKE_GENERATOR=Ninja # build with ninja instead of make - CTEST_PARALLEL_LEVEL=2 # run tests in parallel - PATH="/snap/bin:$PATH" # needed in order to run the cmake installed with snap git: depth: 200 # to make sure we find the latest tag when building. Increase if not enough. addons: apt: packages: - ninja-build - flex - bison # - docbook2x # - xmlto # - texinfo # - source-highlight # - libxml2-utils # - xsltproc # - fop - libgmp-dev - libglpk-dev - libarpack2-dev # - libblas-dev # - liblapack-dev - libopenblas-dev - libsuitesparse-dev - libxml2-dev - git - colordiff snaps: - name: cmake confinement: classic # configuration (running cmake) is in before_script # if this phase fails, the build stops immediately before_script: - mkdir build && cd build - cmake .. -DIGRAPH_USE_INTERNAL_BLAS=ON -DIGRAPH_USE_INTERNAL_LAPACK=ON -DIGRAPH_USE_INTERNAL_ARPACK=ON -DIGRAPH_USE_INTERNAL_GLPK=ON -DIGRAPH_USE_INTERNAL_CXSPARSE=ON -DIGRAPH_USE_INTERNAL_GMP=ON -DIGRAPH_VERIFY_FINALLY_STACK=ON -DCMAKE_BUILD_TYPE=Debug -DIGRAPH_PRINT_ARITH_HEADER=ON -DUSE_SANITIZER=Address\;Undefined # building and testing is in script # use && to ensure that ctest is not run if the build failed script: - cmake --build . --target build_tests && ctest --output-on-failure after_failure: - for file in tests/*.diff; do cat "$file" | colordiff; done jobs: include: # - name: "Linux" # os: linux - name: "Linux arm64" os: linux arch: arm64-graviton2 # faster than arm64 - name: "Linux arm64 external" os: linux arch: arm64-graviton2 # faster than arm64 before_script: - mkdir build && cd build - cmake .. -DIGRAPH_USE_INTERNAL_BLAS=OFF -DIGRAPH_USE_INTERNAL_LAPACK=OFF -DIGRAPH_USE_INTERNAL_ARPACK=OFF -DIGRAPH_USE_INTERNAL_GLPK=OFF -DIGRAPH_USE_INTERNAL_CXSPARSE=OFF -DIGRAPH_USE_INTERNAL_GMP=OFF -DIGRAPH_VERIFY_FINALLY_STACK=ON -DBLA_VENDOR=OpenBLAS -DCMAKE_BUILD_TYPE=Debug -DIGRAPH_PRINT_ARITH_HEADER=ON -DUSE_SANITIZER=Address\;Undefined - name: "Linux ppc64" os: linux dist: focal # Snap fails with ppc64 on earlier Ubuntu. arch: ppc64le - name: "Linux s390x" os: linux dist: focal # Some packages are missing in earlier Ubuntu on this platform. arch: s390x # Do not enable ASan, as it leads to linking errors. # This is possibly a conflict with LTO. before_script: - mkdir build && cd build - cmake .. -DIGRAPH_USE_INTERNAL_BLAS=ON -DIGRAPH_USE_INTERNAL_LAPACK=ON -DIGRAPH_USE_INTERNAL_ARPACK=ON -DIGRAPH_USE_INTERNAL_GLPK=ON -DIGRAPH_USE_INTERNAL_CXSPARSE=ON -DIGRAPH_USE_INTERNAL_GMP=ON -DIGRAPH_VERIFY_FINALLY_STACK=ON -DCMAKE_BUILD_TYPE=Debug -DIGRAPH_ENABLE_LTO=AUTO -DIGRAPH_PRINT_ARITH_HEADER=ON notifications: email: on_success: change on_failure: always ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/.zenodo.json0000644000175100001710000000033500000000000022122 0ustar00runnerdocker00000000000000{ "title": "igraph", "upload_type": "software", "keywords": [ "graph theory", "network analysis" ], "creators": [ { "name": "The igraph Core Team" } ] } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/ACKNOWLEDGEMENTS.md0000644000175100001710000001712300000000000022532 0ustar00runnerdocker00000000000000# Acknowledgements [igraph](https://igraph.org) includes or links to code from the following sources. #### [bliss 0.75](https://users.aalto.fi/~tjunttil/bliss/) Copyright (c) 2003-2021 Tommi Junttila. License: [GNU LGPLv3][lgpl3] #### [Cliquer 1.21](https://users.aalto.fi/~pat/cliquer.html) Copyright (C) 2002 Sampo Niskanen, Patric ÖstergÃ¥rd. License: [GNU GPLv2][gpl2] or later #### [PRPACK](https://github.com/DavidKurokawa/prpack) Copyright (C) David Kurokawa, David Gleich, Chen Greif. #### [gengraph](https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html) Algorithm by Fabien Viger and Matthieu Latapy. Implementation Copyright (C) Fabien Viger. License: [GNU GPLv2][gpl2] or later #### [Walktrap 0.2](https://www-complexnetworks.lip6.fr/~latapy/PP/walktrap.html) Algorithm by Pascal Pons and Matthieu Latapy. Implementation Copyright (C) 2004-2005 Pascal Pons. License: [GNU GPLv2][gpl2] or later #### [plfit](https://github.com/ntamas/plfit) Copyright (C) 2010-2011 Tamás Nepusz. License: [GNU GPLv2][gpl2] or later #### DrL Copyright 2007 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Sandia National Laboratories nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #### [Hierarchical Random Graphs](http://tuvalu.santafe.edu/~aaronc/hierarchy/) Copyright (C) 2006-2008 Aaron Clauset. License: [GNU GPLv2][gpl2] or later #### SCGlib (Spectral Coarse Graining) Copyright (C) 2008 David Morton de Lachapelle License: [GNU GPLv2][gpl2] or later #### Spinglass community detection Copyright (C) 2004 by Joerg Reichardt. License: [GNU GPLv2][gpl2] or later #### [LAD version 1](http://liris.cnrs.fr/csolnon/LAD.html) Copyright (C) Christine Solnon. License: [CeCILL-B license](https://cecill.info/licences.en.html) #### [LAPACK 3.5.0](http://www.netlib.org/lapack/) Copyright (c) 1992-2011 The University of Tennessee and The University of Tennessee Research Foundation. All rights reserved. Copyright (c) 2000-2011 The University of California Berkeley. All rights reserved. Copyright (c) 2006-2012 The University of Colorado Denver. All rights reserved. License: [New BSD license](http://www.netlib.org/lapack/LICENSE.txt) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution. - Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. The copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #### [f2c](http://www.netlib.org/f2c/) Copyright 1990 - 1997 by AT&T, Lucent Technologies and Bellcore. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the names of AT&T, Bell Laboratories, Lucent or Bellcore or any of their entities not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. AT&T, Lucent and Bellcore disclaim all warranties with regard to this software, including all implied warranties of merchantability and fitness. In no event shall AT&T, Lucent or Bellcore be liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or profits, whether in an action of contract, negligence or other tortious action, arising out of or in connection with the use or performance of this software. #### [SuiteSparse](http://www.suitesparse.com) * CXSPARSE: a Concise Sparse Matrix package - Extended. Copyright (c) 2006-2017, Timothy A. Davis. License: [GNU LGPLv2.1][lgpl2] or later #### [GLPK (GNU Linear Programming Kit) Version 4.45](https://www.gnu.org/software/glpk/) Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Andrew Makhorin, Department for Applied Informatics, Moscow Aviation Institute, Moscow, Russia. All rights reserved. E-mail: . License: [GNU GPLv3][gpl3] or later #### [GMP (GNU Multiple Precision Arithmetic Library)](https://gmplib.org/) Copyright (C) Free Software Foundation, Inc. License: [GNU LGPLv3][lgpl3] or later; or [GNU GPLv2][gpl2] or later #### [libxml2](http://xmlsoft.org/) Copyright (C) 1998-2012 Daniel Veillard. License: [MIT license][mit] [mit]: https://opensource.org/licenses/mit-license.html [gpl2]: https://www.gnu.org/licenses/gpl-2.0.html [lgpl2]: https://www.gnu.org/licenses/lgpl-2.1.html [gpl3]: https://www.gnu.org/licenses/gpl-3.0.html [lgpl3]: https://www.gnu.org/licenses/lgpl-3.0.html ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/AUTHORS0000644000175100001710000000030000000000000020713 0ustar00runnerdocker00000000000000Gabor Csardi Tamas Nepusz Szabolcs Horvat Vincent Traag Fabio Zanini ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/CHANGELOG.md0000644000175100001710000010201700000000000021464 0ustar00runnerdocker00000000000000# igraph C library changelog ## [0.9.6] - 2022-01-05 ### Changed - Isomorphism class functions (`igraph_isoclass()`, `igraph_isoclass_subgraph()`, `igraph_isoclass_create`) and motif finder functions (`igraph_motifs_randesu()`, `igraph_motifs_randesu_estimate()`, `igraph_motifs_randesu_callback()`) now support undirected (sub)graphs of sizes 5 and 6. Previsouly only sizes 3 and 4 were supported. ### Fixed - igraph would not build with MinGW when using the vendored GLPK and enabling TLS. - Removed some uses of `abort()` from vendored libraries, which could unexpectedly shut down the host language of igraph's high-level interfaces. - `igraph_community_label_propagation()` no longer leaves any vertices unlabeled when they were not reachable from any labeled ones, i.e. the returned membership vector is guaranteed not to contain negative values (#1853). - The Kamada-Kawai layout is now interruptible. - The Fruchterman-Reingold layout is now interruptible. - Fixed a bug in `igraph_cmp_epsilon()` that resulted in incorrect results for edge betweenness calculations in certain rare cases with x87 floating point math when LTO was also enabled (#1894). - Weighted clique related functions now fall back to the unweighted variants when a null vertex weight vector is given to them. - `igraph_erdos_renyi_game_(gnm|gnp)` would not produce self-loops for the singleton graph. - Fixed a bug in `igraph_local_efficiency()` that sometimes erroneously reported zero as the local efficiency of a vertex in directed graphs. - `igraph_vector_update()` (and its type-specific variants) did not check for memory allocation failure. - Fixed a potential crash in the GraphML reader that would be triggered by some invalid GraphML files. ### Other - `igraph_is_tree()` has improved performance and memory usage. - `igraph_is_connected()` has improved performance when checking weak connectedness. - Improved error handling in `igraph_maximal_cliques()` and related functions. - The build system now checks that GLPK is of a compatible version (4.57 or later). - The vendored `plfit` package was updated to 0.9.3. - You can now build igraph with an external `plfit` instead of the vendored one. - Documentation improvements. ## [0.9.5] - 2021-11-11 ### Fixed - `igraph_reindex_membership()` does not allow negative membership indices any more. - `igraph_rewire_directed_edges()` now generates multigraphs when edge directions are ignored, to make it consistent with the directed case. - Fixed a bug in `igraph_gomory_hu_tree()` that returned only the equivalent flow tree instead of the cut tree (#1810). - Fixed a bug in the `IGRAPH_TO_UNDIRECTED_COLLAPSE` mode of `igraph_to_undirected()` that provided an incorrect merge vector to the attribute handler, leading to problems when edge attributes were merged using an attribute combination (#1814). - Fixed the behaviour of the `IGRAPH_ENABLE_LTO` option when it was set to `AUTO`; earlier versions had a bug where `AUTO` simply checked whether LTO is supported but then did not use LTO even if it was supported. - When using igraph from a CMake project, it is now checked that the project has the C++ language enabled. This is necessary for linking to igraph with CMake. ### Other - Improved the root selection method for disconnected graphs in the Reingold-Tilford layout (#1836). The new root selection method provides niceer results if the graph is not a tree, although it is still recommended to use the Sugiyama layout instead, unless the input graph is _almost_ a tree, in which case Reingold-Tilfold may still be preferred. - `igraph_decompose()` is now much faster for large graphs containing many isolates or small components (#960). - `igraph_largest_cliques()` and `igraph_clique_number()` were re-written to use `igraph_maximal_cliques_callback()` so they are much faster now (#804). - The vendored GLPK has been upgraded to GLPK 5.0. - Documentation improvements. ## [0.9.4] - 2021-05-31 ### Changed - Unweighted transitivity (i.e. clustering coefficient) calculations now ignore multi-edges and edge directions instead of rejecting multigraphs and directed graphs. - `igraph_transitivity_barrat()` now returns an error code if the input graph has multiple edges (which is not handled correctly by the implementation yet). ### Fixed - `igraph_local_scan_k_ecount()` now handles loops correctly. - `igraph_transitivity_avglocal_undirected()` is no longer slower than `igraph_transitivity_local_undirected()`. - Worked around an invalid warning issued by Clang 9.0 when compiling with OpenMP. ### Other - Documentation improvements. ## [0.9.3] - 2021-05-05 ### Added - OpenMP is now enabled and used by certain functions (notably PageRank calculation) when the compiler supports it. Set `IGRAPH_OPENMP_SUPPORT=OFF` at configuration time to disable this. ### Fixed - `igraph_get_incidence()` no longer reads and writes out of bounds when given a non-bipartite graph, but gives a warning and ignores edges within a part. - `igraph_dyad_census()` no longer reports an overflow on singleton graphs, and handles loops and multigraphs correctly. Undirected graphs are handled consistently and will no longer give a warning. - `igraph_vector_lex_cmp()` and `igraph_vector_colex_cmp()` dereferenced their arguments only once instead of twice, and therefore did not work with `igraph_vector_ptr_sort()`. - `igraph_maximal_cliques_subset()` and `igraph_transitivity_barrat()` corrupted the error handling stack ("finally stack") under some circumstances. - CMake package files did not respect `CMAKE_INSTALL_LIBDIR`. This only affected Linux distributions which install into `lib64` or other locations instead of `lib`. - The parser sources could not be generated when igraph was in a location that contained spaces in its path. - igraph no longer links to the math library (`libm`) when this is not necessary. - `_CRT_SECURE_NO_WARNINGS` is now defined during compilation to enable compatibility with UWP. - Fixed a compilation issue on MSYS / MinGW when link-time optimization was enabled and the `MSYS Makefiles` CMake generator was used. Some source files in igraph were renamed as a consequence, but these should not affect users of the library. ### Deprecated - `igraph_rng_min()` is now deprecated; assume a constant zero as its return value if you used this function in your own code. ### Other - Updated the vendored CXSparse library to version 3.2.0 ## [0.9.2] - 2021-04-14 ### Added - CMake package files are now installed with igraph. This allows `find_package(igraph)` to find igraph and detect the appropriate compilation options for projects that link to it. ### Fixed - igraph can now be used as a CMake subproject in other CMake-based projects. - The documentaton can now be built from the release tarball. - Configuration will no longer fail when the release tarball is extracted into a subdirectory of an unrelated git repository. - The generated pkg-config file was incorrect when `CMAKE_INSTALL_` variables were absolute paths. - On Unix-like systems, the library name is now `libigraph.so.0.0.0`, as it used to be for igraph 0.8 and earlier. - Fixed a return type mismatch in parser sources, and fixed some warnings with recent versions of gcc. - Fixed a bug in `igraph_get_shortest_paths_dijkstra()` and `igraph_get_shortest_paths_bellman_ford()` that returned incorrect results for unreachable vertices. ### Other - Improved installation instructions and tutorial. ## [0.9.1] - 2021-03-23 ### Added - `igraph_vector_lex_cmp()` and `igraph_vector_colex_cmp()` for lexicographic and colexicographic comparison of vectors. These functions may also be used for sorting. ### Changed - `igraph_community_multilevel()` is now randomized (PR #1696, thanks to Daniel Noom). ### Fixed - CMake settings that controlled the library installation directory name, such as `CMAKE_INSTALL_LIBDIR`, were not respected. - Under some conditions, the generated pkg-config file contained an incorrect include directory path. - The following functions were not exported from the shared library: `igraph_subcomponent()`, `igraph_stack_ptr_free_all()`, `igraph_stack_ptr_destroy_all()`, `igraph_status_handler_stderr()`, `igraph_progress_handler_stderr()`. - Built-in random number generators (`igraph_rngtype_mt19937`, `igraph_rngtype_rand`, `igraph_rngtype_glibc2`) were not exported from the shared library. - `igraph_layout_graphopt()` no longer rounds the `spring_length` parameter to an integer. - `igraph_get_all_shortest_paths_dijkstra()` no longer modifies the `res` vector's item destructor. - `igraph_get_shortest_path_bellman_ford()` did not work correctly when calculating paths to all vertices. - `igraph_arpack_rnsolve()` checks its parameters more carefully. - `igraph_community_to_membership()` does not crash anymore when `csize` is requested but `membership` is not. - `igraph_citing_cited_type_game()`: fixed memory leaks (PR #1700, thanks to Daniel Noom). - `igraph_transitivity_undirected()`, `igraph_transitivity_avglocal_undirected()` and `igraph_transitivity_barrat()` no longer trigger an assertion failure when used with the null graph (PRs #1709, #1710). - `igraph_(personalized_)pagerank()` would return incorrect results for weighted multigraphs with fewer than 128 vertices when using `IGRAPH_PAGERANK_ALGO_PRPACK`. - `igraph_diversity()` now checks its input more carefully, and throws an error when the input graph has multi-edges or is directed. - `igraph_shortest_paths_johnson()` would return incorrect results when the `to` argument differed from `from` (thanks to Daniel Noom). - `igraph_is_graphical()` would fail to set the result variable for certain special degree sequences in the undirected simple graph case. - Non-maximal clique finding functions would sometimes return incomplete results when finding more than 2147483647 (i.e. 2^31 - 1) cliques. - GLPK internal errors no longer crash igraph. - Fixed some potential memory leaks that could happen on error conditions or when certain functions were interrupted. - When testing a DLL build on Windows, the `PATH` was sometimes not set correctly, causing the tests to fail (PR #1692). - When compiling from the git repository (as opposed to the release tarball), the build would fail with recent versions of `bison` and `flex`. ### Other - Documentation improvements. - Much faster documentation builds. - Allow using a pre-generated `arith.h` header for f2c when cross-compiling; see the Installation section of the documentation. - The `IGRAPH_ENABLE_LTO` build option now supports the `AUTO` value, which uses LTO only if the compiler supports it. Warning: CMake may not always be able to detect that LTO is not fully supported. Therefore, the default setting is `OFF`. - The following functions are now interruptible: `igraph_grg_game()`, `igraph_sbm_game()`, `igraph_barabasi_game()`, `igraph_barabasi_aging_game()`. - Functions that use GLPK, such as `igraph_feedback_arc_set()` and `igraph_community_optimal_modularity()` are now interruptible. - Add support for older versions of Clang that do not recognize the `-Wno-varargs` flag. ### Acknowledgments - Big thanks to Daniel Noom for continuing to expand the test suite and discovering and fixing several bugs in the process! ## [0.9.0] - 2021-02-16 ### Added - Eulerian paths/cycles (PR #1346): * `igraph_is_eulerian()` finds out whether an Eulerian path/cycle exists. * `igraph_eulerian_path()` returns an Eulerian path. * `igraph_eulerian_cycle()` returns an Eulerian cycle. - Efficiency (PR #1344): * `igraph_global_efficiency()` computes the global efficiency of a network. * `igraph_local_efficiency()` computes the local efficiency around each vertex. * `igraph_average_local_efficiency()` computes the mean local efficiency. - Degree sequences (PR #1445): * `igraph_is_graphical()` checks if a degree sequence has a realization as a simple or multigraph, with or without self-loops. * `igraph_is_bigraphical()` checks if two degree sequences have a realization as a bipartite graph. * `igraph_realize_degree_sequence()` now supports constructing non-simple graphs as well. - There is a new fatal error handling mechanism (PR #1548): * `igraph_set_fatal_handler()` sets the fatal error handler. It is the only function in this functionality group that is relevant to end users. * The macro `IGRAPH_FATAL()` and the functions `igraph_fatal()` and `igraph_fatalf()` raise a fatal error. These are for internal use. * `IGRAPH_ASSERT()` is a replacement for the `assert()` macro. It is for internal use. * `igraph_fatal_handler_abort()` is the default fatal error handler. - The new `IGRAPH_WARNINGF`, `IGRAPH_ERRORF` and `IGRAPH_FATALF` macros provide warning/error reporting with `printf`-like syntax. (PR #1627, thanks to Daniel Noom!) - `igraph_average_path_length_dijkstra()` computes the mean shortest path length in weighted graphs (PR #1344). - `igraph_get_shortest_paths_bellman_ford()` computes the shortest paths (including the vertex and edge IDs along the paths) using the Bellman-Ford algorithm (PR #1642, thanks to Guy Rozenberg). This makes it possible to calculate the shortest paths on graphs with negative edge weights, which was not possible before with Dijkstra's algorithm. - `igraph_get_shortest_path_bellman_ford()` is a wrapper for `igraph_get_shortest_paths_bellman_ford()` for the single path case. - `igraph_is_same_graph()` cheks that two labelled graphs are the same (PR #1604). - Harmonic centrality (PR #1583): * `igraph_harmonic_centrality()` computes the harmonic centrality of vertices. * `igraph_harmonic_centrality_cutoff()` computes the range-limited harmonic centrality. - Range-limited centralities, currently equivalent to the old functions with names ending in `_estimate` (PR #1583): * `igraph_closeness_cutoff()`. * `igraph_betweenness_cutoff()`. * `igraph_edge_betweenness_cutoff()`. - `igraph_vector_is_any_nan()` checks if any elements of an `igraph_vector_t` is NaN. - `igraph_inclist_size()` returns the number of vertices in an incidence list. - `igraph_lazy_adjlist_size()` returns the number of vertices in a lazy adjacency list. - `igraph_lazy_inclist_size()` returns the number of vertices in a lazy incidence list. - `igraph_bfs_simple()` now provides a simpler interface to the breadth-first search functionality. ### Changed - igraph now uses a CMake-based build sysyem. - GMP support can no longer be disabled. When GMP is not present on the system, igraph will use an embedded copy of Mini-GMP (PR #1549). - Bliss has been updated to version 0.75. Bliss functions are now interruptible. Thanks to Tommi Junttila for making this possible! - Adjacency and incidence lists: * `igraph_adjlist_init()` and `igraph_lazy_adjlist_init()` now require the caller to specify what to do with loop and multiple edges. * `igraph_inclist_init()` and `igraph_lazy_inclist_init()` now require the caller to specify what to do with loop edges. * Adjacency and incidence lists now use `igraph_vector_int_t` consistently. - Community detection: * `igraph_community_multilevel()`: added resolution parameter. * `igraph_community_fluid_communities()`: graphs with no vertices or with one vertex only are now supported; they return a trivial partition. - Modularity: * `igraph_modularity()` and `igraph_modularity_matrix()`: added resolution parameter. * `igraph_modularity()` and `igraph_modularity_matrix()` now support the directed version of modularity. * `igraph_modularity()` returns NaN for graphs with no edges to indicate that the modularity is not well-defined for such graphs. - Centralities: * `cutoff=0` is no longer interpreted as infinity (i.e. no cutoff) in `betweenness`, `edge_betweenness` and `closeness`. If no cutoff is desired, use a negative value such as `cutoff=-1`. * The `nobigint` argument has been removed from `igraph_betweenness()`, `igraph_betweenness_estimate()` and `igraph_centralization_betweenness()`, as it is not longer needed. The current implementation is more accurate than the old one using big integers. * `igraph_closeness()` now considers only reachable vertices during the calculation (i.e. the closeness is calculated per-component in the undirected case) (PR #1630). * `igraph_closeness()` gained two additional output parameters, `reachable_count` and `all_reachable`, returning the number of reached vertices from each vertex, as well as whether all vertices were reachable. This allows for computing various generalizations of closeness for disconnected graphs (PR #1630). * `igraph_pagerank()`, `igraph_personalized_pagerank()` and `igraph_personalized_pagerank_vs()` no longer support the `IGRAPH_PAGERANK_ALGO_POWER` method. Their `options` argument now has type `igraph_arpack_options_t *` instead of `void *`. - Shortest paths (PR #1344): * `igraph_average_path_length()` now returns the number of disconnected vertex pairs in the new `unconn_pairs` output argument. * `igraph_diameter()` now return the result as an `igraph_real_t` instead of an `igraph_integer_t`. * `igraph_average_path_length()` and `igraph_diameter()` now return `IGRAPH_INFINITY` when `unconn=FALSE` and the graph is not connected. Previously they returned the number of vertices. - Trait-based random graph generators: * `igraph_callaway_traits_game()` and `igraph_establishment_game()` now have an optional output argument to retrieve the generated vertex types. * `igraph_callaway_traits_game()` and `igraph_establishment_game()` now allow omitting the type distribution vector, in which case they assume a uniform distribution. * `igraph_asymmetric_preference_game()` now accept a different number of in-types and out-types. - `igraph_subisomorphic_lad()` now supports graphs with self-loops. - `igraph_is_chordal()` and `igraph_maximum_cardinality_search()` now support non-simple graphs and directed graphs. - `igraph_realize_degree_sequence()` has an additional argument controlling whether multi-edges or self-loops are allowed. - `igraph_is_connected()` now returns false for the null graph; see https://github.com/igraph/igraph/issues/1538 for the reasoning behind this decision. - `igraph_lapack_ddot()` is renamed to `igraph_blas_ddot()`. - `igraph_to_directed()`: added RANDOM and ACYCLIC modes (PR #1511). - `igraph_topological_sorting()` now issues an error if the input graph is not acyclic. Previously it issued a warning. - `igraph_vector_(which_)(min|max|minmax)()` now handles NaN elements. - `igraph_i_set_attribute_table()` is renamed to `igraph_set_attribute_table()`. - `igraph_i_sparsemat_view()` is renamed to `igraph_sparsemat_view()`. ### Deprecated - `igraph_is_degree_sequence()` and `igraph_is_graphical_degree_sequence()` are deprecated in favour of the newly added `igraph_is_graphical()`. - `igraph_closeness_estimate()` is deprecated in favour of the newly added `igraph_closeness_cutoff()`. - `igraph_betweenness_estimate()` and `igraph_edge_betweenness_estimate()` are deprecated in favour of the newly added `igraph_betweenness_cutoff()` and `igraph_edge_betweenness_cutoff()`. - `igraph_adjlist_remove_duplicate()` and `igraph_inclist_remove_duplicate()` are now deprecated in favour of the new constructor arguments in `igraph_adjlist_init()` and `igraph_inclist_init()`. ### Removed - The following functions, all deprecated in igraph 0.6, have been removed (PR #1562): * `igraph_adjedgelist_init()`, `igraph_adjedgelist_destroy()`, `igraph_adjedgelist_get()`, `igraph_adjedgelist_print()`, `igraph_adjedgelist_remove_duplicate()`. * `igraph_lazy_adjedgelist_init()`, `igraph_lazy_adjedgelist_destroy()`, `igraph_lazy_adjedgelist_get()`, `igraph_lazy_adjedgelist_get_real()`. * `igraph_adjacent()`. * `igraph_es_adj()`. * `igraph_subgraph()`. - `igraph_pagerank_old()`, deprecated in 0.7, has been removed. - `igraph_vector_bool` and `igraph_matrix_bool` functions that relied on inequality-comparing `igraph_bool_t` values are removed. ### Fixed - Betweenness calculations are no longer at risk from integer overflow. - The actual cutoff distance used in closeness calculation was one smaller than the `cutoff` parameter. This is corrected (PR #1630). - `igraph_layout_gem()` was not interruptible; now it is. - `igraph_barabasi_aging_game()` now checks its parameters more carefully. - `igraph_callaway_traits_game()` and `igraph_establishment_game()` now check their parameters. - `igraph_lastcit_game()` checks its parameters more carefully, and no longer crashes with zero vertices (PR #1625). - `igraph_cited_type_game()` incorrectly rounded the attractivity vector entries to integers. - `igraph_residual_graph()` now returns the correct _residual_ capacities; previously it wrongly returned the original capacities (PR #1598). - `igraph_psumtree_update()` now checks for negative values and NaN. - `igraph_communities_spinglass()`: fixed several memory leaks in the `IGRAPH_SPINCOMM_IMP_NEG` implementation. - `igraph_incident()` now returns edges in the same order as `igraph_neighbors()`. - `igraph_modularity_matrix()` returned incorrect results for weighted graphs. This is now fixed. (PR #1649, thanks to Daniel Noom!) - `igraph_lapack_dgetrf()` would crash when passing `NULL` for its `ipiv` argument (thanks for the fix to Daniel Noom). - Some `igraph_matrix` functions would fail to report errors on out-of-memory conditions. - `igraph_maxdegree()` now returns 0 for the null graph or empty vector set. Previously, it did not handle this case. - `igraph_vector_bool_all_e()` now considers all nonzero (i.e. "true") values to be the same. - PageRank (PR #1640): * `igraph_(personalized_)pagerank(_vs)()` now check their parameters more carefully. * `igraph_personalized_pagerank()` no longer modifies its `reset` parameter. * `igraph_(personalized_)pagerank(_vs)`: the `IGRAPH_PAGERANK_ALGO_ARPACK` method now handles self-loops correctly. * `igraph_personalized_pagerank(_vs)()`: the result retuned for edgeless or all-zero-weight graphs with the `IGRAPH_PAGERANK_ALGO_ARPACK` ignored the personalization vector. This is now corrected. * `igraph_personalized_pagerank(_vs)()` with a non-uniform personalization vector, a disconnected graph and the `IGRAPH_PAGERANK_ALGO_PRPACK` method would return results that were inconsistent with `IGRAPH_PAGERANK_ALGO_ARPACK`. This happened because PRPACK always used a uniform reset distribution when the random walk got stuck in a sink vertex. Now it uses the user-specified reset distribution for this case as well. - Fixed crashes in several functions when passing a weighted graph with zero edges (due to `vector_min` being called on the zero-length weight vector). - Fixed problems in several functions when passing in a graph with zero vertices. - Weighted betweenness, closeness, PageRank, shortest path calculations and random walk functions now check if any weights are NaN. - Many functions now reject input arguments containing NaN values. - Compatibility with the PGI compiler. ### Other - Documentation improvements. - Improved error and warning messages. - More robust error handling. - General code cleanup to reduce the number of compiler warnings. - igraph's source files have been re-organized for better maintainability. - Debugging aid: When igraph is build with AddressSanitizer, the default error handler prints a stack trace before exiting. - igraph can now be built with an external CXSparse library. - The references to igraph source files in error and warning messages are now always relative to igraph's base directory. - When igraph is built as a shared library, only public symbols are exported even on Linux and macOS. ### Acknowledgments - Thanks to Daniel Noom for significantly expanding igraph's test coverage and exposing several issues in the process! ## [0.8.5] - 2020-12-07 ### Changed - `igraph_write_graph_pajek()`: the function now always uses the platform-native line endings (CRLF on Windows, LF on Unix and macOS). Earlier versions tried to enforce Windows line endings, but this was error-prone, and since all recent versions of Pajek support both line endings, enforcing Windows line endings is not necessary any more. ### Fixed - Fixed several compilation issues with MINGW32/64 (PR #1554) - `igraph_layout_davidson_harel()` was not interruptible; now it is. - Added a missing memory cleanup call in `igraph_i_cattribute_combine_vertices()`. - Fixed a few memory leaks in test cases. ## [0.8.4] - 2020-11-24 ### Fixed - `igraph_i_cattribute_combine_vertices()`: fixed invalid cleanup code that eventually filled up the "finally" stack when combining vertices with attributes extensively. - `igraph_hrg_sample()`: fixed incorrect function prototype - `igraph_is_posinf()` and `igraph_is_neginf()`: fixed incorrect result on platforms where the sign of the result of `isinf()` is not indicative of the sign of the input. - Fixed building with vendored LAPACK and external BLAS - Fixed building with XCode 12.2 on macOS ### Other - Documentation improvements - General code cleanup to reduce the number of compiler warnings ## [0.8.3] - 2020-10-02 ### Added - `igraph_vector_binsearch_slice()` performs binary search on a sorted slice of a vector. ### Changed - `igraph_eigenvector_centrality()` assumes the adjacency matrix of undirected graphs to have twice the number of self-loops for each vertex on the diagonal. This makes the results consistent between an undirected graph and its directed equivalent when each edge is replaced by a mutual edge pair. ### Fixed - `igraph_isomorphic()` now verifies that the input graphs have no multi-edges (PR #1464). - `igraph_difference()` was creating superfluous self loops (#597). - `igraph_count_multiple()` was giving incorrect results for self-loops in directed graph (PR #1399). - `igraph_betweenness_estimate()`: fixed incorrect results with finite cutoff (PR #1392). - `igraph_count_multiple()` was giving incorrect results for self-loops in directed graph (PR #1399). - `igraph_eigen_matrix_symmetric()`: fixed incorrect matrix multiplication (PR #1379). - Corrected several issues that could arise during an error condition (PRs #1405, #1406, #1438). - `igraph_realize_degree_sequence()` did not correctly detect some non-graphical inputs. - `igraph_is_graphical_degree_sequence()`: fixed incorrect results in undirected case (PR #1441). - `igraph_community_leiden()`: fixed incorrect result when self-loops are present (PR #1476). - `igraph_eigenvector_centrality()`: fixed incorrect value for isolated vertices in weighted graphs. - `igraph_eigenvector_centrality()`: corrected the handling of self-loops. - `igraph_layout_reingold_tilford()`: fixed an issue where branches of the tree would sometimes overlap. ### Other - `igraph_degree_sequence_game()`: improved performance with `IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM` method. - Improved the robustness of the test suite. - Documentation improvements. - Improved error and warning messages. - Improved compatibility with recent versions of Microsoft Visual C. ## [0.8.2] - 2020-04-28 ### Changed - Improved argument checking: `igraph_all_st_mincuts()` and `igraph_sir()` - Improved interruptibility: `igraph_sir()` ### Fixed - `igraph_community_leiden()`: fixed crash when interrupting - The tests are now more robust. Some incorrect test failures were fixed when running on i386 architecture, or when using different versions of external dependencies. ### Other - Improved error messages from `igraph_sir()`. - Improved compatibility with more recent versions of Microsoft Visual C. ## [0.8.1] - 2020-03-13 ### Changed - Improved interruptability: `igraph_degree_sequence_game()` - Improved argument checking: `igraph_forest_fire_game()` - Updated the plfit library to version 0.8.1 ### Fixed - `igraph_community_edge_betweenness()`: fix for graphs with no edges (PR #1312) - `igraph_bridges()` now handles multigraphs correctly (PR #1335) - `igraph_avg_nearest_neighbor_degree()`: fix for memory leak in weighted case (PR #1339) - `igraph_community_leiden()`: fix crash bug (PR #1357) ### Other - Included `ACKOWLEDGEMENTS.md` - Documentation improvements ## [0.8.0] - 2020-01-29 ### Added * Trees - `igraph_to_prufer()` and `igraph_from_prufer()` convert labelled trees to/from Prüfer sequences - `igraph_tree_game()` samples uniformly from the set of labelled trees - `igraph_is_tree()` checks if a graph is a tree - `igraph_random_spanning_tree()` picks a spanning tree of a graph uniformly at random - `igraph_random_edge_walk()` returns the indices of edges traversed by a random walk; useful for multigraphs * Community detection - `igraph_community_fluid_communities()` detects communities based on interacting fluids - `igraph_community_leiden()` detects communities with the Leiden method * Cliques - `igraph_maximal_cliques_hist()` counts maximal cliques of each size - `igraph_maximal_cliques_callback()` calls a function for each maximal clique - `igraph_clique_size_hist()` counts cliques of each size - `igraph_cliques_callback()` calls a function for each clique - `igraph_weighted_cliques()` finds weighted cliques in graphs with integer vertex weights - `igraph_weighted_clique_number()` computes the weighted clique number - `igraph_largest_weighted_cliques()` finds the largest weighted cliques * Graph generators - `igraph_hsbm_game()` for a hierarchical stochastic block model - `igraph_hsbm_list_game()` for a more general hierarchical stochastic block model - `igraph_correlated_game()` generates pairs of correlated random graphs by perturbing existing adjacency matrix - `igraph_correlated_pair_game()` generates pairs of correlated random graphs - `igraph_tree_game()` samples uniformly from the set of labelled trees - `igraph_dot_product_game()` generates a random dot product graph - `igraph_realize_degree_sequence()` creates a single graph with a given degree sequence (Havel-Hakimi algorithm) * Graph embeddings - `igraph_adjacency_spectral_embedding()` and `igraph_laplacian_spectral_embedding()` provide graph embedddings - `igraph_dim_select()` provides dimensionality selection for singular values using profile likelihood * Isomorphism - `igraph_automorphism_group()` computes the generators of the automorphism group of a simple graph - `igraph_simplify_and_colorize()` encodes edge and self-loop multiplicities into edge and vertex colors; use in conjunction with VF2 to test isomorphism of non-simple graphs * Other - `igraph_bridges()` finds edges whose removal would disconnect a graph - `igraph_vertex_coloring_greedy()` computes a vertex coloring using a greedy algorithm - `igraph_rewire_directed_edges()` randomly rewires only the starting points or only the endpoints of directed edges - Various `igraph_local_scan_*` functions provide local counts and statistics of neighborhoods - `igraph_sample_sphere_surface()` samples points uniformly from the surface of a sphere - `igraph_sample_sphere_volume()` samples points uniformly from the volume of a sphere - `igraph_sample_dirichlet()` samples points from a Dirichlet distribution - `igraph_malloc()`, to be paired with the existing `igraph_free()` ### Changed - `igraph_degree_sequence_game()`: new method added for uniform sampling: `IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM` - `igraph_modularity_matrix()`: removed `membership` argument (PR #1194) - `igraph_avg_nearest_neighbor_degree()`: added `mode` and `neighbor_degree_mode` arguments (PR #1214). - `igraph_get_all_simple_paths()`: added `cutoff` argument (PR #1232). - `igraph_unfold_tree()`: no longer preserves edge ordering of original graph - `igraph_decompose()`: support strongly connected components - `igraph_isomorphic_bliss()`, `igraph_canonical_permutation()`, `igraph_automorphisms()`: added additional arguments to support vertex colored graphs (PR #873) - `igraph_extended_chordal_ring`: added argument to support direction (PR #1096), and fixed issue #1093. ### Other - The [Bliss isomorphism library](http://www.tcs.hut.fi/Software/bliss/) was updated to version 0.73. This version adds support for vertex colored and directed graphs. - igraph now uses the high-performance [Cliquer library](https://users.aalto.fi/~pat/cliquer.html) to find (non-maximal) cliques - Provide proper support for Windows, using `__declspec(dllexport)` and `__declspec(dllimport)` for `DLL`s and static usage by using `#define IGRAPH_STATIC 1`. - Provided integer versions of `dqueue` and `stack` data types. [Unreleased]: https://github.com/igraph/igraph/compare/0.9.5..HEAD [0.9.5]: https://github.com/igraph/igraph/compare/0.9.4...0.9.5 [0.9.4]: https://github.com/igraph/igraph/compare/0.9.3...0.9.4 [0.9.3]: https://github.com/igraph/igraph/compare/0.9.2...0.9.3 [0.9.2]: https://github.com/igraph/igraph/compare/0.9.1...0.9.2 [0.9.1]: https://github.com/igraph/igraph/compare/0.9.0...0.9.1 [0.9.0]: https://github.com/igraph/igraph/compare/0.8.5...0.9.0 [0.8.5]: https://github.com/igraph/igraph/compare/0.8.4...0.8.5 [0.8.4]: https://github.com/igraph/igraph/compare/0.8.3...0.8.4 [0.8.3]: https://github.com/igraph/igraph/compare/0.8.2...0.8.3 [0.8.2]: https://github.com/igraph/igraph/compare/0.8.1...0.8.2 [0.8.1]: https://github.com/igraph/igraph/compare/0.8.0...0.8.1 [0.8.0]: https://github.com/igraph/igraph/releases/tag/0.8.0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/CMakeLists.txt0000644000175100001710000001200300000000000022406 0ustar00runnerdocker00000000000000# Minimum CMake that we require is 3.16 because we use --ignore-eol when # comparing unit test results with expected outcomes (added in 3.14) and we # also use SKIP_REGULAR_EXPRESSION to handle skipped tests properly cmake_minimum_required(VERSION 3.16) # Add etc/cmake to CMake's search path so we can put our private stuff there list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/etc/cmake) # Set a default build type if none was specified # This must precede the project() line, which would set the CMAKE_BUILD_TYPE # to 'Debug' with single-config generators on Windows. # Note that we must do this only if PROJECT_NAME is not set at this point. If # it is set, it means that igraph is being used as a subproject of another # project. if(NOT PROJECT_NAME) include(BuildType) endif() # Prevent in-source builds include(PreventInSourceBuilds) # Make use of ccache if it is present on the host system -- unless explicitly # asked to disable it include(UseCCacheWhenInstalled) # Figure out the version number from Git include(version) # Declare the project, its version number and language project( igraph VERSION ${PACKAGE_VERSION_BASE} DESCRIPTION "A library for creating and manipulating graphs" HOMEPAGE_URL https://igraph.org LANGUAGES C CXX ) # Include some compiler-related helpers and set global compiler options include(compilers) # Set default symbol visibility to hidden set(CMAKE_C_VISIBILITY_PRESET hidden) set(CMAKE_CXX_VISIBILITY_PRESET hidden) # Set C and C++ standard version set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED True) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED True) # Expose the BUILD_SHARED_LIBS option in the ccmake UI option(BUILD_SHARED_LIBS "Build shared libraries" OFF) # Add switches to use sanitizers and debugging helpers if needed include(debugging) include(sanitizers) # Add version information configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/include/igraph_version.h.in ${CMAKE_CURRENT_BINARY_DIR}/include/igraph_version.h ) # Create configuration options for optional features include(features) # Handle dependencies and dependency-related configuration options include(dependencies) find_dependencies() # Run compile-time checks, generate config.h and igraph_threading.h include(CheckSymbolExists) # First we check for some functions and symbols set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES}) if(NEED_LINKING_AGAINST_LIBM) list(APPEND CMAKE_REQUIRED_LIBRARIES m) endif() check_symbol_exists(expm1 math.h HAVE_EXPM1) check_symbol_exists(fmin math.h HAVE_FMIN) check_symbol_exists(finite math.h HAVE_FINITE) check_symbol_exists(isfinite math.h HAVE_ISFINITE) check_symbol_exists(log2 math.h HAVE_LOG2) check_symbol_exists(log1p math.h HAVE_LOG1P) check_symbol_exists(rint math.h HAVE_RINT) check_symbol_exists(rintf math.h HAVE_RINTF) check_symbol_exists(round math.h HAVE_ROUND) check_symbol_exists(stpcpy string.h HAVE_STPCPY) check_symbol_exists(strcasecmp strings.h HAVE_STRCASECMP) check_symbol_exists(strdup string.h HAVE_STRDUP) check_symbol_exists(_stricmp string.h HAVE__STRICMP) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE}) # Check for code coverage support option(IGRAPH_ENABLE_CODE_COVERAGE "Enable code coverage calculation" OFF) if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND IGRAPH_ENABLE_CODE_COVERAGE) include(CodeCoverage) append_coverage_compiler_flags() setup_target_for_coverage_lcov( NAME coverage EXECUTABLE "${CMAKE_COMMAND}" "--build" "${PROJECT_BINARY_DIR}" "--target" "check" # Generated files are excluded; apparently the CodeCoverage script has some # problems with them. Yes, the exclusion is correct, it refers to a nonexistent # directory that somehow gets into the coverage resolts. /Applications is for # macOS -- it excludes files from the macOS SDK. EXCLUDE "io/*.l" "io/parsers/*" "/Applications/Xcode*" "examples/*" "tests/*" ) endif() # Generate configuration headers configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/config.h ) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/include/igraph_threading.h.in ${CMAKE_CURRENT_BINARY_DIR}/include/igraph_threading.h ) # Enable unit tests. Behave nicely and do this only if we are not being # included as a sub-project in another CMake project if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) include(CTest) configure_file( ${PROJECT_SOURCE_DIR}/etc/cmake/CTestCustom.cmake.in ${PROJECT_BINARY_DIR}/CTestCustom.cmake ) endif() # Traverse subdirectories. vendor/ should come first because code in # src/CMakeLists.txt depends on targets in vendor/ add_subdirectory(vendor) add_subdirectory(src) add_subdirectory(interfaces) if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING) add_subdirectory(tests) endif() if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) add_subdirectory(doc) endif() # Configure packaging -- only if igraph is the top-level project and not a # subproject if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) include(packaging) endif() # Show result of configuration include(summary) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/CODE_OF_CONDUCT.md0000644000175100001710000001753500000000000022464 0ustar00runnerdocker00000000000000# igraph Code of Conduct ## Introduction This code of conduct applies to all spaces managed by the igraph project, including all public and private mailing lists, issue trackers, wikis, blogs, Twitter, and any other communication channel used by our community. Any events related to our community shall also be bound by this code of conduct or a very similar variant thereof. This code of conduct should be honored by everyone who participates in the igraph community formally or informally, or claims any affiliation with the project, in any project-related activities, and, especially, when representing the project, in any capacity. This code of conduct is neither exhaustive nor complete. It serves to distill our common understanding of a collaborative, shared environment and goals. Please try to follow this code in spirit as much as in letter, to create a friendly and productive environment that enriches the surrounding community. ## Specific guidelines We strive to: 1. Be open. We invite anyone to participate in our community. We prefer to use public methods of communication for project-related messages, unless discussing something sensitive. This applies to messages for help or project-related support, too; not only is a public-support request much more likely to result in an answer to a question, it also ensures that any inadvertent mistakes in answering are more easily detected and corrected. 2. Be empathetic, welcoming, friendly, and patient. We work together to resolve conflict, and assume good intentions. We may all experience some frustration from time to time, but we do not allow frustration to turn into a personal attack. A community where people feel uncomfortable or threatened is not a productive one. 3. Be collaborative. Our work will be used by other people, and in turn we will depend on the work of others. When we make something for the benefit of the project, we are willing to explain to others how it works, so that they can build on the work to make it even better. Any decision we make will affect users and colleagues, and we take those consequences seriously when making decisions. 4. Be inquisitive. Nobody knows everything! Asking questions early avoids many problems later, so we encourage questions, although we may direct them to the appropriate forum. We will try hard to be responsive and helpful. 5. Be careful in the words that we choose. We are careful and respectful in our communication and we take responsibility for our own words. Be kind to others. Do not insult or put down other participants. We do not tolerate harassment or other exclusionary behavior, such as: * Violent threats or language directed against another person. * Sexist, racist, or otherwise discriminatory jokes and language. * Posting sexually explicit or violent material. * Posting (or threatening to post) other people’s personally identifying information (“doxingâ€). * Sharing private content, such as emails sent privately or non-publicly, or unlogged forums, such as IRC channel history, without the sender’s consent. * Personal insults, especially those using racist or sexist terms. * Unwelcome sexual attention. * Excessive profanity. Please avoid swearwords; people differ greatly in their sensitivity to swearing. * Repeated harassment of others. In general, if someone asks you to stop, then stop. * Advocating for, or encouraging, any of the above behavior. ## Diversity statement The igraph project welcomes and encourages participation by everyone. We are committed to being a community that everyone enjoys being part of. Although we may not always be able to accommodate each individual’s preferences, we try our best to treat everyone kindly. No matter how you identify yourself or how others perceive you: we welcome you. Though no list can hope to be comprehensive, we explicitly honor diversity in: age, culture, ethnicity, genotype, gender identity or expression, language, national origin, neurotype, phenotype, political beliefs, profession, race, religion, sexual orientation, socioeconomic status, subculture and technical ability, to the extent that these do not conflict with this code of conduct. Though we welcome people fluent in all languages, igraph development is conducted in English. Standards for behavior in the igraph community are detailed in the Code of Conduct above. Participants in our community should uphold these standards in all their interactions and help others to do so as well (see next section). ## Reporting guidelines We know that it is painfully common for internet communication to start at or devolve into obvious and flagrant abuse. We also recognize that sometimes people may have a bad day, or be unaware of some of the guidelines in this Code of Conduct. Please keep this in mind when deciding on how to respond to a breach of this Code. For clearly flagrant breaches, report those to the igraph organisation (see below). For possibly unintentional breaches, you may reply to the person and point out this Code of Conduct (either in public or in private, whatever is most appropriate). If you would prefer not to do that, please feel free to report to the igraph organisation directly, or ask the organisation for advice, in confidence. You can report issues to the igraph organisation, at . Currently, the following persons will receive your report: * Gábor Csárdi * Tamás Nepusz * Szabolcs Horvát * Vincent Traag If your report involves any of the above mentioned persons, or if they feel they have a conflict of interest in handling it, they will recuse themselves from considering your report. Alternatively, if, for any reason, you feel uncomfortable making a report to the organisation directly, then you can also contact any of the above mentioned persons individually. ## Incident reporting We will investigate and respond to all complaints. The igraph organisation will protect the identity of the reporter, and treat the content of complaints as confidential (unless the reporter agrees otherwise). In case of flagrant breaches, e.g., personal threats or violent, sexist or racist language, we will immediately disconnect the originator from igraph. In particular, the organisation will 1. Immediately disconnect the originator from all igraph communication channels. 2. Revoke any granted permissions from the originator. 3. Reply to the reporter that their report has been received and that the originator has been disconnected. 4. In every case, the moderator should make a reasonable effort to contact the originator, and tell them specifically how their language or actions qualify as a “flagrant breachâ€. The moderator should also say that, if the originator believes this is unfair or they want to be reconnected to igraph, they have the right to ask for a review, as below, by the igraph organisation. 5. The igraph organisation will formally review and sign off on all cases where this mechanism has been applied to make sure it is not being used to control ordinary heated disagreement. In cases not involving flagrant breaches of this code of conduct, the process for acting on any received code of conduct violation report will be: 1. acknowledgement that the report has been received 2. reasonable discussion/feedback 3. mediation (if feedback didn’t help, and only if both reporter and reportee agree to this) The organisation will respond to any report as soon as possible, and at most within 5 working days. ## Endnotes This Code of Conduct is inspired by [the SciPy Code of Conduct](https://docs.scipy.org/doc/scipy/reference/dev/conduct/code_of_conduct.html). The current organisation of the igraph community is rudimentary. A more professional organisation may develop in the future, at which point the procedure of handling incident reports will also be further formalized. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/CONTRIBUTING.md0000644000175100001710000002574300000000000022116 0ustar00runnerdocker00000000000000# Contributing to this project Thank you for being interested in contributing to `igraph`! We need the help of volunteers to keep the package going, so every little bit is welcome. You can help out the project in several different ways. This repository only hosts the C code of the `igraph` project. Even if you are not so experienced with C, you can contribute in a number of ways: 1. Respond to user questions on our [support forum](https://igraph.discourse.group/). 2. Correct or improve our [documentation](https://igraph.org/c/html/latest/). 3. Go over [open issues](https://github.com/igraph/igraph/issues): - Are some older issues still relevant in the most recent version? If not, write a comment to the issue stating that you feel that the issue is not relevant any more. - Can you reproduce some of the bugs that are reported? If so, write a comment to the issue stating that this is still a problem in version X. - Some [issues point out problems with the documentation](https://github.com/igraph/igraph/labels/documentation); perhaps you could help correct these? - Some [issues require clarifying a mathematical problem, or some literature research](https://github.com/igraph/igraph/labels/theory), before any programming can begin. Can you contribute through your theoretical expertise? - Looking to contribute code? Take a look at some [good first issues](https://github.com/igraph/igraph/labels/good%20first%20issue). ## Using the issue tracker - The issue tracker is the preferred channel for [bug reports](#bugs), [feature requests](#features) and [submitting pull requests](#pull-requests). - Do you have a question? Please use our [igraph support forum](https://igraph.discourse.group) for support requests. - Please keep the discussion on topic and respect the opinions of others, and adhere to our [Code of Conduct](https://igraph.org/code-of-conduct.html). ## Bug reports A bug is a _demonstrable problem_ that is caused by the code in the repository. Good bug reports are extremely helpful — thank you for reporting! Guidelines for bug reports: 1. **Make sure that the bug is in the C code of igraph and not in one of the higher level interfaces** — if you are using igraph from R, Python or Mathematica, consider submitting your issue in [igraph/rigraph](https://github.com/igraph/rigraph/issues/new), [igraph/python-igraph](https://github.com/igraph/python-igraph/issues/new) or [szhorvat/IGraphM](https://github.com/szhorvat/IGraphM/issues/new) instead. If you are unsure whether your issue is in the C layer, submit a bug report in the repository of the higher level interface — we will transfer the issue here if it indeed affects the C layer. 2. **Use the GitHub issue search** — check if the issue has already been reported. 3. **Check if the issue has been fixed** — try to reproduce it using the latest `master` or development branch in the repository. 4. **Isolate the problem** — create a [short, self-contained, correct example](http://sscce.org/). Please try to be as detailed as possible in your report and provide all necessary information. What is your environment? What steps will reproduce the issue? What would you expect to be the outcome? All these details will help us to fix any potential bugs. Example: > Short and descriptive example bug report title > > A summary of the issue and the compiler/OS environment in which it occurs. If > suitable, include the steps required to reproduce the bug. > > 1. This is the first step > 2. This is the second step > 3. Further steps, etc. > > `` - a link to the reduced test case > > Any other information you want to share that is relevant to the issue being > reported. This might include the lines of code that you have identified as > causing the bug, and potential solutions (and your opinions on their > merits). ## Feature requests Feature requests are always welcome. First, take a moment to find out whether your idea fits with the scope and aims of the project. Please provide as much detail and context as possible, and where possible, references to relevant literature. Having said that, implementing new features can be quite time consuming, and as such they might not be implemented quickly. In addition, the development team might decide not to implement a certain feature. It is up to you to make a case to convince the project's developers of the merits of this feature. ## Pull requests Good pull requests - patches, improvements, new features - are a fantastic help. They should remain focused in scope and avoid containing unrelated commits. Please also take a look at our [tips on writing igraph code](#tips) before getting your hands dirty. **Please ask first** before embarking on any significant pull request (e.g. implementing features, refactoring code, porting to a different language), otherwise you risk spending a lot of time working on something that the project's developers might not want to merge into the project. Please adhere to the coding conventions used throughout a project (indentation, accurate comments, etc.) and any other requirements (such as test coverage). Follow the following steps if you would like to make a new pull request: 1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork, and configure the remotes: ```bash # Clone your fork of the repo into the current directory git clone https://github.com// # Navigate to the newly cloned directory cd # Assign the original repo to a remote called "upstream" git remote add upstream https://github.com// ``` 2. Please checkout the section on [branching](#branching) to see whether you need to branch off from the `master` branch or the `develop` branch. If you cloned a while ago, get the latest changes from upstream: ```bash git checkout git pull --rebase upstream ``` 3. Create a new topic branch (off the targeted branch, see [branching](#branching) section) to contain your feature, change, or fix: ```bash git checkout -b ``` 4. Please commit your changes in logical chunks, and try to provide clear commit messages. It helps us during the review process if we can follow your thought process during the implementation. If you hit a dead end, use `git revert` to revert your commits or just go back to an earlier commit with `git checkout` and continue your work from there. 5. We have a [checklist for new igraph functions](https://github.com/igraph/igraph/wiki/Checklist-for-new-(and-old)-functions). If you have added any new functions to igraph, please go through the checklist to ensure that your functions play nicely with the rest of the library. 6. Make sure that your PR is based off the latest code and locally merge (or rebase) the upstream development branch into your topic branch: ```bash git pull [--rebase] upstream ``` Rebasing is preferable over merging as you do not need to deal with merge conflicts; however, if you already have many commits, merging the upstream development branch may be faster. 7. WHen your topic branch is up-to-date with the upstream development branch, you can push your topic branch up to your fork: ```bash git push origin ``` 8. [Open a pull request](https://help.github.com/articles/using-pull-requests/) with a clear title and description. **IMPORTANT**: By submitting a pull request, you agree to allow the project owner to license your work under the same license as that used by the project, see also [Legal Stuff](#legal). ### Branching `igraph` is committed to [semantic versioning](https://semver.org/). We are currently still in the development release (0.x), which in principle is a mark that the public API is not yet stable. Regardless, we try to maintain semantic versioning also for the development releases. We do so as follows. Any released minor version (0.x.z) will be API backwards-compatible with any previous release of the *same* minor version (0.x.y, with y < z). This means that *if* there is an API incompatible change, we will increase the minor version. For example, release 0.8.1 is API backwards-compatible with release 0.8.0, while release 0.9.0 might be API incompatible with version 0.8.1. Note that this only concerns the *public* API, internal functions may change also within a minor version. There will always be two versions of `igraph`: the most recent released version, and the next upcoming minor release, which is by definition not yet released. The most recent release version is in the `master` branch, while the next upcoming minor release is in the `develop` branch. If you make a change that is API incompatible with the most recent release, it **must** be merged to the `develop` branch. If the change is API backwards-compatible, it **can** be merged to the `master` branch. It is possible that you build on recent improvements in the `develop` branch, in which case your change should of course target the `develop` branch. If you only add new functionality, but do not change anything of the existing API, this should be backwards-compatible, and can be merged in the `master` branch. When you make a new pull request, please specify the correct target branch. The maintainers of `igraph` may decide to retarget your pull request to the correct branch. Retargeting you pull request may result in merge conflicts, so it is always good to decide **before** starting to work on something whether you should start from the `master` branch or from the `develop` branch. In most cases, changes in the `master` branch will also be merged to the `develop` branch by the maintainers. If you are unsure about the branch to target, open an issue about your proposed feature and we can discuss the appropriate target branch in the issue before you send a PR. ## Writing igraph Code [Some tips on writing igraph code](https://github.com/igraph/igraph/wiki/Tips-on-writing-igraph-code). ## Ask Us! In general, if you are not sure about something, please ask! You can open an issue on GitHub, open a thread in our [igraph support forum](https://igraph.discourse.group), or write to [@ntamas](https://github.com/ntamas), [@vtraag](https://github.com/vtraag), [@szhorvat](https://github.com/szhorvat), [@iosonofabio](https://github.com/iosonofabio) or [@gaborcsardi](https://github.com/gaborcsardi). We prefer open communication channels, because others can then learn from it too. ## Legal Stuff This is a pain to deal with, but we can't avoid it, unfortunately. `igraph` is licensed under the "General Public License (GPL) version 2, or later". The igraph manual is licensed under the "GNU Free Documentation License". By submitting a patch or pull request, you agree to allow the project owner to license your work under the same license as that used by the project. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/COPYING0000644000175100001710000004312600000000000020713 0ustar00runnerdocker00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/ChangeLog0000644000175100001710000000007100000000000021422 0ustar00runnerdocker00000000000000See CHANGELOG.md for a list of changes between versions. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822589.0 igraph-0.9.9/vendor/source/igraph/IGRAPH_VERSION0000644000175100001710000000000500000000000021747 0ustar00runnerdocker000000000000000.9.6././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/INSTALL0000644000175100001710000000041000000000000020676 0ustar00runnerdocker00000000000000Instructions for installation are provided in Chapter 2 of the manual; see `doc/html` in the distributed tarball. An online version of the installation instructions for the most recent version can be found here: https://igraph.org/c/doc/igraph-Installation.html ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/NEWS0000644000175100001710000000032000000000000020344 0ustar00runnerdocker00000000000000News about each release of igraph from version 0.8 onwards can be found in CHANGELOG.md. Archived news items before version 0.7 are to be found in ONEWS -- these are most likely of historical interest only. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/ONEWS0000644000175100001710000017246000000000000020502 0ustar00runnerdocker00000000000000 igraph 0.6.5 ============ Released February 24, 2013 The version number is not a mistake, we jump to 0.6.5 from 0.6, for technical reasons. R: new features and bug fixes ----------------------------- - Added a vertex shape API for defining new vertex shapes, and also a couple of new vertex shapes. - Added the get.data.frame() function, opposite of graph.data.frame(). - Added bipartite support to the Pajek reader and writer, closes bug \#1042298. - `degree.sequence.game()` has a new method now: "simple_no_multiple". - Added the is.degree.sequence() and is.graphical.degree.sequence() functions. - rewire() has a new method: "loops", that can create loop edges. - Walktrap community detection now handles isolates. - layout.mds() returns a layout matrix now. - layout.mds() uses LAPACK instead of ARPACK. - Handle the '~' character in write.graph and read.graph. Bug \#1066986. - Added k.regular.game(). - Use vertex names to plot if no labels are specified in the function call or as vetex attributes. Fixes issue \#1085431. - power.law.fit() can now use a C implementation. - Fixed a bug in barabasi.game() when out.seq was an empty vector. - Fixed a bug that made functions with a progress bar fail if called from another package. - Fixed a bug when creating graphs from a weighted integer adjacency matrix via graph.adjacency(). Bug \#1019624. - Fixed overflow issues in centralization calculations. - Fixed a minimal.st.separators() bug, some vertex sets were incorrectly reported as separators. Bug \#1033045. - Fixed a bug that mishandled vertex colors in VF2 isomorphism functions. Bug \#1032819. - Pajek exporter now always quotes strings, thanks to Elena Tea Russo. - Fixed a bug with handling small edge weights in shortest paths calculation in shortest.paths() (Dijkstra's algorithm.) Thanks to Martin J Reed. - Weighted transitivity uses V(graph) as 'vids' if it is NULL. - Fixed a bug when 'pie' vertices were drawn together with other vertex shapes. - Speed up printing graphs. - Speed up attribute queries and other basic operations, by avoiding copying of the graph. Bug \#1043616. - Fixed a bug in the NCV setting for ARPACK functions. It cannot be bigger than the matrix size. - layout.merge()'s DLA mode has better defaults now. - Fixed a bug in layout.mds() that resulted vertices on top of each other. - Fixed a bug in layout.spring(), it was not working properly. - Fixed layout.svd(), which was completely defunct. - Fixed a bug in layout.graphopt() that caused warnings and on some platforms crashes. - Fixed community.to.membership(). Bug \#1022850. - Fixed a graph.incidence() crash if it was called with a non-matrix argument. - Fixed a get.shortest.paths bug, when output was set to "both". - Motif finding functions return NA for isomorphism classes that are not motifs (i.e. not connected). Fixes bug \#1050859. - Fixed get.adjacency() when attr is given, and the attribute has some complex type. Bug \#1025799. - Fixed attribute name in graph.adjacency() for dense matrices. Bug \#1066952. - Fixed erratic behavior of alpha.centrality(). - Fixed igraph indexing, when attr is given. Bug \#1073705. - Fixed a bug when calculating the largest cliques of a directed graph. Bug \#1073800. - Fixed a bug in the maximal clique search, closes \#1074402. - Warn for negative weights when calculating PageRank. - Fixed dense, unweighted graph.adjacency when diag=FALSE. Closes issue \#1077425. - Fixed a bug in eccentricity() and radius(), the results were often simply wrong. - Fixed a bug in get.all.shortest.paths() when some edges had zero weight. - graph.data.frame() is more careful when vertex names are numbers, to avoid their scientific notation. Fixes issue \#1082221. - Better check for NAs in vertex names. Fixes issue \#1087215 - Fixed some potential crashes in the DrL layout generator. - Fixed a bug in the Reingold-Tilford layout when the graph is directed and mode != ALL. - Eliminate gap between vertex and edge when plotting an edge without an arrow. Fixes \#1118448. - Fixed a bug in has.multiple() that resulted in false negatives for some undirected graphs. - Fixed a crash in weighted betweenness calculation. - R plotting: fixed a bug that caused misplaced arrows at rectangle vertex shapes. Python news and fixes --------------------- - Added bipartite support to the Pajek reader and writer, closes bug \#1042298. - Graph.Degree_Sequence() has a new method now: "no_multiple". - Added the is_degree_sequence() and is_graphical_degree_sequence() functions. - rewire() has a new mode: "loops", that can create loop edges. - Walktrap community detection now handles isolates. - Added Graph.K_Regular(). - power_law_fit() now uses a C implementation. - Added support for setting the frame (stroke) width of vertices using the frame_width attribute or the vertex_frame_width keyword argument in plot() - Improved Inkscape-friendly SVG output from Graph.write_svg(), thanks to drlog - Better handling of named vertices in Graph.delete_vertices() - Added experimental Gephi graph streaming support; see igraph.remote.gephi and igraph.drawing.graph.GephiGraphStreamingDrawer - Nicer __repr__ output for Flow and Cut instances - Arrows are now placed correctly around diamond-shaped nodes on plots - Added Graph.TupleList, a function that allows one to create graphs with edge attributes quickly from a list of tuples. - plot() now also supports .eps as an extension, not only .ps - Fixed overflow issues in centralization calculations. - Fixed a bug that mishandled vertex colors in VF2 isomorphism functions. Bug \#1032819. - Pajek exporter now always quotes strings, thanks to Elena Tea Russo. - Fixed a bug with handling small edge weights in shortest paths calculation in Graph.shortest_paths() (Dijkstra's algorithm.) Thanks to Martin J Reed. - Fixed a bug in the NCV setting for ARPACK functions. It cannot be bigger than the matrix size. - Fixed a bug in Graph.layout_mds() that resulted vertices on top of each other. - Motif finding functions return nan for isomorphism classes that are not motifs (i.e. not connected). Fixes bug \#1050859. - Fixed a bug when calculating the largest cliques of a directed graph. Bug \#1073800. - Warn for negative weights when calculating PageRank. - Fixed a bug in Graph.eccentricity() and Graph.radius(), the results were often simply wrong. - Fixed a bug in Graph.get.all.shortest.paths() when some edges had zero weight. - Fixed some potential crashes in the DrL layout generator. - Fixed a bug in the Reingold-Tilford layout when the graph is directed and mode != ALL. - Fixed a bug in Graph.layout_sugiyama() when the graph had no edges. - Fixed a bug in Graph.community_label_propagation() when initial labels contained -1 entries. Issue \#1105460. - Repaired the DescartesCoordinateSystem class (which is not used too frequently anyway) - Fixed a bug that caused segfaults when an igraph Graph was used in a thread forked from the main Python interpreter thread - Fixed a bug that affected file handles created from Python strings in the C layer - Fixed a bug in has_multiple() that resulted in false negatives for some undirected graphs. - Fixed a crash in weighted betweenness calculation. C library news and changes -------------------------- - Added bipartite support to the Pajek reader and writer, closes bug \#1042298. - igraph_layout_mds() uses LAPACK instead of ARPACK. - igraph_degree_sequence_game has a new method: IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE. - Added the igraph_is_degree_sequence() and igraph_is_graphical_degree_sequence() functions. - igraph_rewire() has a new method: IGRAPH_REWIRING_SIMPLE_LOOPS, that can create loops. - Walktrap community detection now handles isolates. - Added igraph_k_regular_game(). - Added igraph_power_law_fit. - Fixed a bug in igraph_barabasi_game when outseq was an empty vector. - Fixed overflow issues in centralization calculations. - Fixed an invalid return value of igraph_vector_ptr_pop_back. - Fixed a igraph_all_minimal_st_separators() bug, some vertex sets were incorrectly reported as separators. Bug \#1033045. - Pajek exporter now always quotes strings, thanks to Elena Tea Russo. - Fixed a bug with handling small edge weights in igraph_shortest_paths_dijkstra(), thanks to Martin J Reed. - Fixed a bug in the NCV setting for ARPACK functions. It cannot be bigger than the matrix size. - igraph_layout_merge_dla uses better default parameter values now. - Fixed a bug in igraph_layout_mds() that resulted vertices on top of each other. - Attribute handler table is not thread-local any more. - Motif finding functions return IGRAPH_NAN for isomorphism classes that are not motifs (i.e. not connected). Fixes bug \#1050859. - Fixed a bug when calculating the largest cliques of a directed graph. Bug \#1073800. - Fix a bug in degree_sequence_game(), in_seq can be an empty vector as well instead of NULL, for an undirected graph. - Fixed a bug in the maximal clique search, closes \#1074402. - Warn for negative weights when calculating PageRank. - Fixed a bug in igraph_eccentricity() (and also igraph_radius()), the results were often simply wrong. - Fixed a bug in igraph_get_all_shortest_paths_dijkstra() when edges had zero weight. - Fixed some potential crashes in the DrL layout generator. - Fixed a bug in the Reingold-Tilford layout when the graph is directed and mode != ALL. - Fixed a bug in igraph_has_multiple() that resulted in false negatives for some undirected graphs. - Fixed a crash in weighted betweenness calculation. igraph 0.6 ========== Released June 11, 2012 See also the release notes at http://igraph.sf.net/relnotes-0.6.html R: Major new features --------------------- - Vertices and edges are numbered from 1 instead of 0. Note that this makes most of the old R igraph code incompatible with igraph 0.6. If you want to use your old code, please use the igraph0 package. See more at http://igraph.sf.net/relnotes-0.6.html. - The '\[' and '\[\[' operators can now be used on igraph graphs, for '\[' the graph behaves as an adjacency matrix, for '[[' is is treated as an adjacency list. It is also much simpler to manipulate the graph structure, i.e. add/remove edges and vertices, with some new operators. See more at ?graph.structure. - In all functions that take a vector or list of vertices or edges, vertex/edge names can be given instead of the numeric ids. - New package 'igraphdata', contains a number of data sets that can be used directly in igraph. - Igraph now supports loading graphs from the Nexus online data repository, see nexus.get(), nexus.info(), nexus.list() and nexus.search(). - All the community structure finding algorithm return a 'communities' object now, which has a bunch of useful operations, see ?communities for details. - Vertex and edge attributes are handled much better now. They are kept whenever possible, and can be combined via a flexible API. See ?attribute.combination. - R now prints igraph graphs to the screen in a more structured and informative way. The output of summary() was also updated accordingly. R: Other new features --------------------- - It is possible to mark vertex groups on plots, via shading. Communities and cohesive blocks are plotted using this by default. - Some igraph demos are now available, see a list via 'demo(package="igraph")'. - igraph now tries to select the optimal layout algorithm, when plotting a graph. - Added a simple console, using Tcl/Tk. It contains a text area for status messages and also a status bar. See igraph.console(). - Reimplemented igraph options support, see igraph.options() and getIgraphOpt(). - Igraph functions can now print status messages. R: New or updated functions --------------------------- Community detection ------------------- - The multi-level modularity optimization community structure detection algorithm by Blondel et al. was added, see multilevel.community(). - Distance between two community structures: compare.communities(). - Community structure via exact modularity optimization, optimal.community(). - Hierarchical random graphs and community finding, porting the code from Aaron Clauset. See hrg.game(), hrg.fit(), etc. - Added the InfoMAP community finding method, thanks to Emmanuel Navarro for the code. See infomap.community(). Shortest paths -------------- - Eccentricity (eccentricity()), and radius (radius()) calculations. - Shortest path calculations with get.shortest.paths() can now return the edges along the shortest paths. - get.all.shortest.paths() now supports edge weights. Centrality ---------- - Centralization scores for degree, closeness, betweenness and eigenvector centrality. See centralization.scores(). - Personalized Page-Rank scores, see page.rank(). - Subgraph centrality, subgraph.centrality(). - Authority (authority.score()) and hub (hub.score()) scores support edge weights now. - Support edge weights in betweenness and closeness calculations. - bonpow(), Bonacich's power centrality and alpha.centrality(), Alpha centrality calculations now use sparse matrices by default. - Eigenvector centrality calculation, evcent() now works for directed graphs. - Betweenness calculation can now use arbitrarily large integers, this is required for some lattice-like graphs to avoid overflow. Input/output and file formats ----------------------------- - Support the DL file format in graph.read(). See http://www.analytictech.com/networks/dataentry.htm. - Support writing the LEDA file format in write.graph(). Plotting and layouts -------------------- - Star layout: layout.star(). - Layout based on multidimensional scaling, layout.mds(). - New layouts layout.grid() and layout.grid.3d(). - Sugiyama layout algorithm for layered directed acyclic graphs, layout.sugiyama(). Graph generators ---------------- - New graph generators: static.fitness.game(), static.power.law.game(). - barabasi.game() was rewritten and it supports three algorithms now, the default algorithm does not generate multiple or loop edges. The graph generation process can now start from a supplied graph. - The Watts-Strogatz graph generator, igraph_watts_strogatz() can now create graphs without loop edges. Others ------ - Added the Spectral Coarse Graining algorithm, see scg(). - The cohesive.blocks() function was rewritten in C, it is much faster now. It has a nicer API, too. See demo("cohesive"). - Added generic breadth-first and depth-first search implementations with many callbacks, graph.bfs() and graph_dfs(). - Support vertex and edge coloring in the VF2 (sub)graph isomorphism functions (graph.isomorphic.vf2(), graph.count.isomorphisms.vf2(), graph.get.isomorphisms.vf2(), graph.subisomorphic.vf2(), graph.count.subisomorphisms.vf2(), graph.get.subisomorphisms.vf2()). - Assortativity coefficient, assortativity(), assortativity.nominal() and assortativity.degree(). - Vertex operators that work by vertex names: graph.intersection.by.name(), graph.union.by.name(), graph.difference.by.name(). Thanks to Magnus Torfason for contributing his code! - Function to calculate a non-induced subraph: subgraph.edges(). - More comprehensive maximum flow and minimum cut calculation, see functions graph.maxflow(), graph.mincut(), stCuts(), stMincuts(). - Check whether a directed graph is a DAG, is.dag(). - has.multiple() to decide whether a graph has multiple edges. - Added a function to calculate a diversity score for the vertices, graph.diversity(). - Graph Laplacian calculation (graph.laplacian()) supports edge weights now. - Biconnected component calculation, biconnected.components() now returns the components themselves. - bipartite.projection() calculates multiplicity of edges. - Maximum cardinality search: maximum.cardinality.search() and chordality test: is.chordal() - Convex hull computation, convex.hull(). - Contract vertices, contract.vertices(). New in the Python interface --------------------------- TODO Major changes in the Python interface ------------------------------------- TODO New in the C layer ------------------ - Maximum cardinality search: igraph_maximum_cardinality_search() and chordality test: igraph_is_chordal(). - Support the DL file format, igraph_read_graph_dl(). See http://www.analytictech.com/networks/dataentry.htm. - Added generic breadth-first and depth-first search implementations with many callbacks (igraph_bfs(), igraph_dfs()). - Centralization scores for degree, closeness, betweenness and eigenvector centrality, see igraph_centralization(). - Added igraph_sparsemat_t, a type that implements sparse matrices based on the CXSparse library by Tim Davis. See http://www.cise.ufl.edu/research/sparse/CXSparse/. - Personalized Page-Rank scores, igraph_personalized_pagerank() and igraph_personalized_pagerank_vs(). - Assortativity coefficient, igraph_assortativity(), igraph_assortativity_nominal(), and igraph_assortativity_degree(). - The multi-level modularity optimization community structure detection algorithm by Blondel et al. was added, see igraph_community_multilevel(). - Added the igraph_version() function. - Star layout: igraph_layout_star(). - Function to calculate a non-induced subraph: igraph_subgraph_edges(). - Distance between two community structures: igraph_compare_communities(). - Community structure via exact modularity optimization, igraph_community_optimal_community(). - More comprehensive maximum flow and minimum cut calculation, see functions igraph_maxflow(), igraph_mincut(), igraph_all_st_cuts(), igraph_all_st_mincuts(). - Layout based on multidimensional scaling, igraph_layout_mds(). - It is now possible to access the random number generator(s) via an API. Multiple RNGs can be used, from external sources as well. The default RNG is MT19937. - Added igraph_get_all_shortest_paths_dijkstra, for calculating all non-negatively weighted shortest paths. - Check whether a directed graph is a DAG, igraph_is_dag(). - Cohesive blocking, a'la Moody & White, igraph_cohesive_blocks(). - Igraph functions can now print status messages, see igraph_status() and related functions. - Support writing the LEDA file format, igraph_write_graph_leda(). - Contract vertices, igraph_contract_vertices(). - The C reference manual has now a lot of example programs. - Hierarchical random graphs and community finding, porting the code from Aaron Clauset. See igraph_hrg_game(), igraph_hrg_fit(), etc. - igraph_has_multiple() to decide whether a graph has multiple edges. - New layouts igraph_layout_grid() and igraph_layout_grid_3d(). - igraph_integer_t is really an integer now, it used to be a double. - igraph_minimum_spanning_tree(), calls either the weighted or the unweighted implementation. - Eccentricity (igraph_eccentricity()), and radius (igraph_radius()) calculations. - Several game theory update rules, written by Minh Van Nguyen. See igraph_deterministic_optimal_imitation(), igraph_stochastic_imitation(), igraph_roulette_wheel_imitation(), igraph_moran_process(), - Sugiyama layout algorithm for layered directed acyclic graphs, igraph_layout_sugiyama(). - New graph generators: igraph_static_fitness_game(), igraph_static_power_law_game(). - Added the InfoMAP community finding method, thanks to Emmanuel Navarro for the code. See igraph_community_infomap(). - Added the Spectral Coarse Graining algorithm, see igraph_scg(). - Added a function to calculate a diversity score for the vertices, igraph_diversity(). Major changes in the C layer ---------------------------- - Authority (igraph_authority_score()) and hub (igraph_hub_score()) scores support edge weights now. - Graph Laplacian calculation (igraph_laplacian()) supports edge weights now. - Support edge weights in betweenness (igraph_betweenness()) and closeness (igraph_closeness()) calculations. - Support vertex and edge coloring in the VF2 graph isomorphism algorithm (igraph_isomorphic_vf2(), igraph_count_isomorphisms_vf2(), igraph_get_isomorphisms_vf2(), igraph_subisomorphic_vf2(), igraph_count_subisomorphisms_vf2(), igraph_get_subisomorphisms_vf2()). - Added print operations for the igraph_vector*_t, igraph_matrix*_t and igraph_strvector_t types. - Biconnected component calculation (igraph_biconnected_components()) can now return the components themselves. - Eigenvector centrality calculation, igraph_eigenvector_centrality() now works for directed graphs. - Shortest path calculations with get_shortest_paths() and get_shortest_paths_dijkstra() can now return the edges along the paths. - Betweenness calculation can now use arbitrarily large integers, this is required for some lattice-like graphs to avoid overflow. - igraph_bipartite_projection() calculates multiplicity of edges. - igraph_barabasi_game() was rewritten and it supports three algorithms now, the default algorithm does not generate multiple or loop edges. - The Watts-Strogatz graph generator, igraph_watts_strogatz() can now create graphs without loop edges. - igraph should be now thread-safe, on architectures that support thread-local storage (Linux and Windows: yes, Mac OSX: no). We also fixed numerous bugs, too many to include them here, sorry. You may look at our bug tracker at https://bugs.launchpad.net/igraph to check whether a bug was fixed or not. Thanks for all the people reporting bugs. Special thanks to Minh Van Nguyen for a lot of bug reports, documentation fixes and contributed code! igraph 0.5.3 ============ Released November 22, 2009 Bugs corrected in the R interface --------------------------------- - Some small changes to make 'R CMD check' clean - Fixed a bug in graph.incidence, the 'directed' and 'mode' arguments were not handled correctly - Betweenness and edge betweenness functions work for graphs with many shortest paths now (up to the limit of long long int) - When compiling the package, the configure script fails if there is no C compiler available - igraph.from.graphNEL creates the right number of loop edges now - Fixed a bug in bipartite.projection() that caused occasional crashes on some systems New in the Python interface --------------------------- - Added support for weighted diameter - get_eid() considers edge directions by default from now on - Fixed a memory leak in the attribute handler - 'NaN' and 'inf' are treated correctly now Bugs corrected in the C layer ----------------------------- - Betweenness and edge betweenness functions work for graphs with many shortest paths now (up to the limit of long long int) - The configure script fails if there is no C compiler available - Fixed a bug in igraph_community_spinglass, when csize was a NULL pointer, but membership was not - Fixed a bug in igraph_bipartite_projection that caused occasional crashes on some systems igraph 0.5.2 ============ Released April 10, 2009 See also the release notes at http://igraph.sf.net/relnotes-0.5.2.html New in the R interface ---------------------- - Added progress bar support to beweenness() and betweenness.estimate(), layout.drl() - Speeded up betweenness estimation - Speeded up are.connected() - Johnson's shortest paths algorithm added - shortest.paths() has now an 'algorithm' argument to choose from the various implementations manually - Always quote symbolic vertex names when printing graphs or edges - Average nearest neighbor degree calculation, graph.knn() - Weighted degree (also called strength) calculation, graph.strength() - Some new functions to support bipartite graphs: graph.bipartite(), is.bipartite(), get.indicence(), graph.incidence(), bipartite.projection(), bipartite.projection.size() - Support for plotting curved edges with plot.igraph() and tkplot() - Added support for weighted graphs in alpha.centrality() - Added the label propagation community detection algorithm by Raghavan et al., label.propagation.community() - cohesive.blocks() now has a 'cutsetHeuristic' argument to choose between two cutset algorithms - Added a function to "unfold" a tree, unfold.tree() - New tkplot() arguments to change the drawing area - Added a minimal GUI, invoke it with tkigraph() - The DrL layout generator, layout.drl() has a three dimensional mode now. Bugs corrected in the R interface --------------------------------- - Fixed a bug in VF2 graph isomorphism functions - Fixed a bug when a sparse adjacency matrix was requested in get.adjacency() and the graph was named - VL graph generator in degree.sequence.game() checks now that the sum of the degrees is even - Many fixes for supporting various compilers, e.g. GCC 4.4 and Sun's C compiler - Fixed memory leaks in graph.automorphisms(), Bellman-Ford shortest.paths(), independent.vertex.sets() - Fix a bug when a graph was imported from LGL and exported to NCOL format (\#289596) - cohesive.blocks() creates its temporary file in the session temporary directory - write.graph() and read.graph() now give error messages when unknown arguments are given - The GraphML reader checks the name of the attributes to avoid adding a duplicate 'id' attribute - It is possible to change the 'ncv' ARPACK parameter for leading.eigenvector.community() - Fixed a bug in path.length.hist(), 'unconnected' was wrong for unconnected and undirected graphs - Better handling of attribute assingment via iterators, this is now also clarified in the manual - Better error messages for unknown vertex shapes - Make R package unload cleanly if unloadNamespace() is used - Fixed a bug in plotting square shaped vertices (\#325244) - Fixed a bug in graph.adjacency() when the matrix is a sparse matrix of class "dgTMatrix" New in the Python interface --------------------------- - Speeded up betweenness estimation - Johnson's shortest paths algorithm added (selected automatically by Graph.shortest_paths() if needed) - Weighted degree (also called strength) calculation, Graph.strength() - Some new methods to support bipartite graphs: Graph.Bipartite(), Graph.is_bipartite(), Graph.get_indicence(), Graph.Incidence(), Graph.bipartite_projection(), Graph.bipartite_projection_size() - Added the label propagation community detection algorithm by Raghavan et al., Graph.community_label_propagation() - Added a function to "unfold" a tree, Graph.unfold_tree() - setup.py script improvements - Graph plotting now supports edge_arrow_size and edge_arrow_width - Added Graph.Formula to create small graphs from a simple notation - VertexSeq and EdgeSeq objects can now be indexed by slices New in the C layer ------------------ - Added progress bar support to igraph_betweenness() and igraph_betweenness_estimate(), igraph_layout_drl() - Speeded up igraph_betweenness_estimate(), igraph_get_eid(), igraph_are_connected(), igraph_get_eids() - Added igraph_get_eid2() - Johnson's shortest path algorithm added: igraph_shortest_paths_johnson() - Average nearest neighbor degree calculation, igraph_avg_nearest_neighbor_degree() - Weighted degree (also called strength) calculation, igraph_strength() - Some functions to support bipartite graphs: igraph_full_bipartite(), igraph_bipartite_projection(), igraph_create_bipartite(), igraph_incidence(), igraph_get_incidence(), igraph_bipartite_projection_size(), igraph_is_bipartite() - Added the label propagation community detection algorithm by Raghavan et al., igraph_community_label_propagation() - Added an example that shows how to set the random number generator's seed from C (examples/simple/random_seed.c) - Added a function to "unfold" a tree, igraph_unfold_tree() - C attribute handler updates: added functions to query many vertices/edges at once - Three dimensional DrL layout, igraph_layout_drl_3d() Bugs corrected in the C layer ----------------------------- - Fixed a bug in igraph_isomorphic_function_vf2(), affecting all VF2 graph isomorphism functions - VL graph generator in igraph_degree_sequence_game() checks now that the sum of the degrees is even - Many small corrections to make igraph compile with Microsoft Visual Studio 2003, 2005 and 2008 - Many fixes for supporting various compilers, e.g. GCC 4.4 and Sun's C compiler - Fix a bug when a graph was imported from LGL and exported to NCOL format (\#289596) - Fixed memory leaks in igraph_automorphisms(), igraph_shortest_paths_bellman_ford(), igraph_independent_vertex_sets() - The GraphML reader checks the name of the attributes to avoid adding a duplicate 'id' attribute - It is possible to change the 'ncv' ARPACK parameter for igraph_community_leading_eigenvector() - Fixed a bug in igraph_path_length_hist(), 'unconnected' was wrong for unconnected and undirected graphs. igraph 0.5.1 ============ Released July 14, 2008 See also the release notes at http://igraph.sf.net/relnotes-0.5.1.html New in the R interface ---------------------- - A new layout generator called DrL. - Uniform sampling of random connected undirected graphs with a given degree sequence. - Edge labels are plotted at 1/3 of the edge, this is better if the graph has mutual edges. - Initial and experimental vertex shape support in 'plot'. - New function, 'graph.adjlist' creates igraph graphs from adjacency lists. - Conversion to/from graphNEL graphs, from the 'graph' R package. - Fastgreedy community detection can utilize edge weights now, this was missing from the R interface. - The 'arrow.width' graphical parameter was added. - graph.data.frame has a new argument 'vertices'. - graph.adjacency and get.adjacency support sparse matrices, the 'Matrix' package is required to use this functionality. - graph.adjacency adds column/row names as 'name' attribute. - Weighted shortest paths using Dijkstra's or the Belmann-Ford algorithm. - Shortest path functions return 'Inf' for unreachable vertices. - New function 'is.mutual' to find mutual edges in a directed graph. - Added inverse log-weighted similarity measure (a.k.a. Adamic/Adar similarity). - preference.game and asymmetric.preference.game were rewritten, they are O(|V|+|E|) now, instead of O(|V|^2). - Edge weight support in function 'get.shortest.paths', it uses Dijkstra's algorithm. Bugs corrected in the R interface --------------------------------- - A bug was corrected in write.pajek.bgraph. - Several bugs were corrected in graph.adjacency. - Pajek reader bug corrected, used to segfault if '\*Vertices' was missing. - Directedness is handled correctly when writing GML files. (But note that 'correct' conflicts the standard here.) - Corrected a bug when calculating weighted, directed PageRank on an undirected graph. (Which does not make sense anyway.) - Several bugs were fixed in the Reingold-Tilford layout to avoid edge crossings. - A bug was fixed in the GraphML reader, when the value of a graph attribute was not specified. - Fixed a bug in the graph isomorphism routine for small (3-4 vertices) graphs. - Corrected the random sampling implementation (igraph_random_sample), now it always generates unique numbers. This affects the Gnm Erdos-Renyi generator, it always generates simple graphs now. - The basic igraph constructor (igraph_empty_attrs, all functions are expected to call this internally) now checks whether the number of vertices is finite. - The LGL, NCOL and Pajek graph readers handle errors properly now. - The non-symmetric ARPACK solver returns results in a consistent form now. - The fast greedy community detection routine now checks that the graph is simple. - The LGL and NCOL parsers were corrected to work with all kinds of end-of-line encodings. - Hub & authority score calculations initialize ARPACK parameters now. - Fixed a bug in the Walktrap community detection routine, when applied to unconnected graphs. - Several small memory leaks were removed, and a big one from the Spinglass community structure detection function New in the Python interface --------------------------- - A new layout generator called DrL. - Uniform sampling of random connected undirected graphs with a given degree sequence. - Methods parameters accepting igraph.IN, igraph.OUT and igraph.ALL constants now also accept these as strings ("in", "out" and "all"). Prefix matches also allowed as long as the prefix match is unique. - Graph.shortest_paths() now supports edge weights (Dijkstra's and Bellman-Ford algorithm implemented) - Graph.get_shortest_paths() also supports edge weights (only Dijkstra's algorithm yet) - Added Graph.is_mutual() to find mutual edges in a directed graph. - Added inverse log-weighted similarity measure (a.k.a. Adamic/Adar similarity). - preference.game and asymmetric.preference.game were rewritten, they are O(|V|+|E|) now, instead of O(|V|^2). - ARPACK options can now be modified from the Python interface (thanks to Kurt Jacobson) - Layout.to_radial() added -- now you can create a top-down tree layout by the Reingold-Tilford algorithm and then turn it to a radial tree layout - Added Graph.write_pajek() to save graphs in Pajek format - Some vertex and edge related methods can now also be accessed via the methods of VertexSeq and EdgeSeq, restricted to the current vertex/edge sequence of course - Visualisations now support triangle shaped vertices - Added Graph.mincut() - Added Graph.Weighted_Adjacency() to create graphs from weighted adjacency matrices - Kamada-Kawai and Fruchterman-Reingold layouts now accept initial vertex positions - Graph.Preference() and Graph.Asymmetric_Preference() were rewritten, they are O(|V|+|E|) now, instead of O(|V|^2). Bugs corrected in the Python interface -------------------------------------- - Graph.constraint() now properly returns floats instead of integers (thanks to Eytan Bakshy) - Graphs given by adjacency matrices are now finally loaded and saved properly - Graph.Preference() now accepts floats in type distributions - A small bug in Graph.community_edge_betweenness() corrected - Some bugs in numeric attribute handling resolved - VertexSeq and EdgeSeq objects can now be subsetted by lists and tuples as well - Fixed a bug when dealing with extremely small layout sizes - Eigenvector centality now always return positive values - Graph.authority_score() now really returns the authority scores instead of the hub scores (blame copypasting) - Pajek reader bug corrected, used to segfault if '\*Vertices' was missing. - Directedness is handled correctly when writing GML files. (But note that 'correct' conflicts the standard here.) - Corrected a bug when calculating weighted, directed PageRank on an undirected graph. (Which does not make sense anyway.) - Several bugs were fixed in the Reingold-Tilford layout to avoid edge crossings. - A bug was fixed in the GraphML reader, when the value of a graph attribute was not specified. - Fixed a bug in the graph isomorphism routine for small (3-4 vertices) graphs. - Corrected the random sampling implementation (igraph_random_sample), now it always generates unique numbers. This affects the Gnm Erdos-Renyi generator, it always generates simple graphs now. - The LGL, NCOL and Pajek graph readers handle errors properly now. - The non-symmetric ARPACK solver returns results in a consistent form now. - The fast greedy community detection routine now checks that the graph is simple. - The LGL and NCOL parsers were corrected to work with all kinds of end-of-line encodings. - Hub & authority score calculations initialize ARPACK parameters now. - Fixed a bug in the Walktrap community detection routine, when applied to unconnected graphs. - Several small memory leaks were removed, and a big one from the Spinglass community structure detection function New in the C layer ------------------ - A new layout generator called DrL. - Uniform sampling of random connected undirected graphs with a given degree sequence. - Some stochastic test results are ignored (for spinglass community detection, some Erdos-Renyi generator tests) - Weighted shortest paths, Dijkstra's algorithm. - The unweigthed shortest path routine returns 'Inf' for unreachable vertices. - New function, igraph_adjlist can create igraph graphs from adjacency lists. - New function, igraph_weighted_adjacency can create weighted graphs from weight matrices. - New function, igraph_is_mutual to search for mutual edges. - Added inverse log-weighted similarity measure (a.k.a. Adamic/Adar similarity). - igraph_preference_game and igraph_asymmetric_preference_game were rewritten, they are O(|V|+|E|) now, instead of O(|V|^2). - The Bellman-Ford shortest path algorithm was added. - Added weighted variant of igraph_get_shortest_paths, based on Dijkstra's algorithm. - Several small memory leaks were removed, and a big one from the Spinglass community structure detection function Bugs corrected in the C layer ----------------------------- - Several bugs were corrected in the (still experimental) C attribute handler. - Pajek reader bug corrected, used to segfault if '\*Vertices' was missing. - Directedness is handled correctly when writing GML files. (But note that 'correct' conflicts the standard here.) - Corrected a bug when calculating weighted, directed PageRank on an undirected graph. (Which does not make sense anyway.) - Some code polish to make igraph compile with GCC 4.3 - Several bugs were fixed in the Reingold-Tilford layout to avoid edge crossings. - A bug was fixed in the GraphML reader, when the value of a graph attribute was not specified. - Fixed a bug in the graph isomorphism routine for small (3-4 vertices) graphs. - Corrected the random sampling implementation (igraph_random_sample), now it always generates unique numbers. This affects the Gnm Erdos-Renyi generator, it always generates simple graphs now. - The basic igraph constructor (igraph_empty_attrs, all functions are expected to call this internally) now checks whether the number of vertices is finite. - The LGL, NCOL and Pajek graph readers handle errors properly now. - The non-symmetric ARPACK solver returns results in a consistent form now. - The fast greedy community detection routine now checks that the graph is simple. - The LGL and NCOL parsers were corrected to work with all kinds of end-of-line encodings. - Hub & authority score calculations initialize ARPACK parameters now.x - Fixed a bug in the Walktrap community detection routine, when applied to unconnected graphs. igraph 0.5 ========= Released February 14, 2008 See also the release notes at http://igraph.sf.net/relnotes-0.5.html New in the R interface ---------------------- - The 'rescale', 'asp' and 'frame' graphical parameters were added - Create graphs from a formula notation (graph.formula) - Handle graph attributes properly - Calculate the actual minimum cut for undirected graphs - Adjacency lists, get.adjlist and get.adjedgelist added - Eigenvector centrality computation is much faster now - Proper R warnings, instead of writing the warning to the terminal - R checks graphical parameters now, the unknown ones are not just ignored, but an error message is given - plot.igraph has an 'add' argument now to compose plots with multiple graphs - plot.igraph supports the 'main' and 'sub' arguments - layout.norm is public now, it can normalize a layout - It is possible to supply startup positions to layout generators - Always free memory when CTRL+C/ESC is pressed, in all operating systems - plot.igraph can plot square vertices now, see the 'shape' parameter - graph.adjacency rewritten when creating weighted graphs - We use match.arg whenever possible. This means that character scalar options can be abbreviated and they are always case insensitive - VF2 graph isomorphism routines can check subgraph isomorphism now, and they are able to return matching(s) - The BLISS graph isomorphism algorithm is included in igraph now. See canonical.permutation, graph.isomorphic.bliss - We use ARPACK for eigenvalue/eigenvector calculation. This means that the following functions were rewritten: page.rank, leading.eigenvector.community.\*, evcent. New functions based on ARPACK: hub.score, authority.score, arpack. - Edge weights for Fruchterman-Reingold layout (layout.fruchterman.reingold). - Line graph calculation (line.graph) - Kautz and de Bruijn graph generators (graph.kautz, graph.de.bruijn) - Support for writing graphs in DOT format - Jaccard and Dice similarity coefficients added (similarity.jaccard, similarity.dice) - Counting the multiplicity of edges (count.multiple) - The graphopt layout algorithm was added, layout.graphopt - Generation of "famous" graphs (graph.famous). - Create graphs from LCF notation (graph.cf). - Dyad census and triad cencus functions (dyad.census, triad.census) - Cheking for simple graphs (is.simple) - Create full citation networks (graph.full.citation) - Create a histogram of path lengths (path.length.hist) - Forest fire model added (forest.fire.game) - DIMACS reader can handle different file types now - Biconnected components and articulation points (biconnected.components, articulation.points) - Kleinberg's hub and authority scores (hub.score, authority.score) - as.undirected handles attributes now - Geometric random graph generator (grg.game) can return the coordinates of the vertices - Function added to convert leading eigenvector community structure result to a membership vector (community.le.to.membership) - Weighted fast greedy community detection - Weighted page rank calculation - Functions for estimating closeness, betweenness, edge betweenness by introducing a cutoff for path lengths (closeness.estimate, betweenness.estimate, edge.betweenness.estimate) - Weighted modularity calculation - Function for permuting vertices (permute.vertices) - Betweenness and closeness calculations are speeded up - read.graph can handle all possible line terminators now (\r, \n, \r\n, \n\r) - Error handling was rewritten for walktrap community detection, the calculation can be interrupted now - The maxflow/mincut functions allow to supply NULL pointer for edge capacities, implying unit capacities for all edges Bugs corrected in the R interface --------------------------------- - Fixed a bug in cohesive.blocks, cohesive blocks were sometimes not calculated correctly New in the Python interface --------------------------- - Added shell interface: igraph can now be invoked by calling the script called igraph from the command line. The script launches the Python interpreter and automatically imports igraph functions into the main namespace - Pickling (serialization) support for Graph objects - Plotting functionality based on the Cairo graphics library (so you need to install python-cairo if you want to use it). Currently the following objects can be plotted: graphs, adjacency matrices and dendrograms. Some crude support for plotting histograms is also implemented. Plots can be saved in PNG, SVG and PDF formats. - Unified Graph.layout method for accessing layout algorithms - Added interfaces to walktrap community detection and the BLISS isomorphism algorithm - Added dyad and triad census functionality and motif counting - VertexSeq and EdgeSeq objects can now be restricted to subsets of the whole network (e.g., you can select vertices/edges based on attributes, degree, centrality and so on) New in the C library -------------------- - Many types (stack, matrix, dqueue, etc.) are templates now They were also rewritten to provide a better organized interface - VF2 graph isomorphism routines can check subgraph isomorphism now, and they are able to return matching(s) - The BLISS graph isomorphism algorithm is included in igraph now. See igraph_canonical_permutation, igraph_isomorphic_bliss - We use ARPACK for eigenvalue/eigenvector calculation. This means that the following functions were rewritten: igraph_pagerank, igraph_community_leading_eigenvector_\*. New functions based on ARPACK: igraph_eigenvector_centrality, igraph_hub_score, igraph_authority_score, igraph_arpack_rssolve, igraph_arpack_rnsolve - Experimental C attribute interface added. I.e. it is possible to use graph/vertex/edge attributes from C code now. - Edge weights for Fruchterman-Reingold layout. - Line graph calculation. - Kautz and de Bruijn graph generators - Support for writing graphs in DOT format - Jaccard and Dice similarity coefficients added - igraph_count_multiple added - igraph_is_loop and igraph_is_multiple "return" boolean vectors - The graphopt layout algorithm was added, igraph_layout_graphopt - Generation of "famous" graphs, igraph_famous - Create graphs from LCF notation, igraph_lcf, igraph_lcf_vector - igraph_add_edge adds a single edge to the graph - Dyad census and triad cencus functions added - igraph_is_simple added - progress handlers are allowed to stop calculation - igraph_full_citation to create full citation networks - igraph_path_length_hist, create a histogram of path lengths - forest fire model added - DIMACS reader can handle different file types now - Adjacency list types made public now (igraph_adjlist_t, igraph_adjedgelist_t) - Biconnected components and articulation points can be computed - Eigenvector centrality computation - Kleinberg's hub and authority scores - igraph_to_undirected handles attributes now - Geometric random graph generator can return the coordinates of the vertices - Function added to convert leading eigenvector community structure result to a membership vector (igraph_le_community_to_membership) - Weighted fast greedy community detection - Weighted page rank calculation - Functions for estimating closeness, betweenness, edge betweenness by introducing a cutoff for path lengths - Weighted modularity calculation - igraph_permute_vertices added - Betweenness ans closeness calculations are speeded up - Startup positions can be supplied to the Kamada-Kawai layout algorithms - igraph_read_graph_\* functions can handle all possible line terminators now (\r, \n, \r\n, \n\r) - Error handling was rewritten for walktrap community detection, the calculation can be interrupted now - The maxflow/mincut functions allow to supply a null pointer for edge capacities, implying unit capacities for all edges Bugs corrected in the C library ------------------------------- - Memory leak fixed in adjacency list handling - Memory leak fixed in maximal independent vertex set calculation - Fixed a bug when rewiring undirected graphs with igraph_rewire - Fixed edge betweenness community structure detection for unconnected graphs - Make igraph compile with Sun Studio - Betweenness bug fixed, when not computing for all vertices - memory usage of clique finding reduced - Corrected bugs for motif counts when not all motifs were counted, but a 'cut' vector was used - Bugs fixed in trait games and cited type game - Accept underscore as letter in GML files - GML file directedness notation reversed, more logical this way igraph 0.4.5 ========= Released January 1, 2008 New: - Cohesive block finding in the R interface, thanks to Peter McMahan for contributing his code. See James Moody and Douglas R. White, 2003, in Structural Cohesion and Embeddedness: A Hierarchical Conception of Social Groups American Sociological Review 68(1):1-25 - Biconnected components and articulation points. - R interface: better printing of attributes. - R interface: graph attributes can be used via '$'. New in the C library: - igraph_vector_bool_t data type. Bug fixed: - Erdos-Renyi random graph generators rewritten. igraph 0.4.4 ========= Released October 3, 2007 This release should work seemlessly with the new R 2.6.0 version. Some other bugs were also fixed: - A bug was fixed in the Erdos-Renyi graph generator, which sometimes added an extra vertex. - MSVC compilation issues were fixed. - MinGW compilation fixes. igraph 0.4.3 ========= Released August 13, 2007 The next one in the sequence of bugfix releases. Thanks to many people sending bug reports. Here are the changes: - Some memory leaks removed when using attributes from R or Python. - GraphML parser: entities and character data in multiple chunks are now handled correctly. - A bug corrected in edge betweenness community structure detection, it failed if called many times from the same program/session. - Bug corrected in 'adjacent edges' edge iterator. - Python interface: edge and vertex attribute deletion bug corrected. - Edge betweeness community structure: handle unconnected graphs properly. - Fixed bug related to fast greedy community detection in unconnected graphs. - Use a different kind of parser (Push) for reading GraphML files. This is almost invisible for users but fixed a nondeterministic bug when reading in GraphML files. - R interface: plot now handles properly if called with a vector as the edge.width argument for directed graphs. - R interface: bug (typo) corrected for walktrap.community and weighted graphs. - Test suite should run correctly on Cygwin now. igraph 0.4.2 ========= Released June 7, 2007 This is another bugfix release, as there was a serious bug in the R package of the previous version: it could not read and write graphs to files in any format under MS Windows. Some other bits added: - circular Reingold-Tilford layout generator for trees - corrected a bug, Pajek files are written properly under MS Windows now. - arrow.size graphical edge parameter added in the R interface. igraph 0.4.1 ========= Released May 23, 2007 This is a minor release, it corrects a number of bugs, mostly in the R package. igraph 0.4 ========= Released May 21, 2007 The major new additions in this release is a bunch of community detection algorithms and support for the GML file format. Here is the complete list of changes: New in the C library -------------------- - internal representation changed - neighbors always returns an ordered list - igraph_is_loop and igraph_is_multiple added - topological sorting - VF2 isomorphism algorithm - support for reading the file format of the Graph Database for isomorphism - igraph_mincut cat calculate the actual minimum cut - girth calculation added, thanks to Keith Briggs - support for reading and writing GML files - Walktrap community detection algorithm added, thanks to Matthieu Latapy and Pascal Pons - edge betweenness based community detection algorithm added - fast greedy algorithm for community detection by Clauset et al. added thanks to Aaron Clauset for sharing his code - leading eigenvector community detection algorithm by Mark Newman added - igraph_community_to_membership supporting function added, creates a membership vector from a community structure merge tree - modularity calculation added New in the R interface ---------------------- - as the internal representation changed, graphs stored with 'save' with an older igraph version cannot be read back with the new version reliably. - neighbors returns ordered lists - topological sorting - VF2 isomorphism algorithm - support for reading graphs from the Graph Database for isomorphism - girth calculation added, thanks to Keith Briggs - support for reading and writing GML files - Walktrap community detection algorithm added, thanks to Matthieu Latapy and Pascal Pons - edge betweenness based community detection algorithm added - fast greedy algorithm for community detection by Clauset et al. added thanks to Aaron Clauset for sharing his code - leading eigenvector community detection algorithm by Mark Newman added - functions for creating denrdograms from the output of the community detection algorithms added - community.membership supporting function added, creates a membership vector from a community structure merge tree - modularity calculation added - graphics parameter handling is completely rewritten, uniform handling of colors and fonts, make sure you read ?igraph.plotting - new plotting parameter for edges: arrow.mode - a bug corrected when playing a nonlinear barabasi.game - better looking plotting in 3d using rglplot: edges are 3d too - rglplot layout is allowed to be two dimensional now - rglplot suspends updates while drawing, this makes it faster - loop edges are correctly plotted by all three plotting functions - better printing of attributes when printing graphs - summary of a graph prints attribute names - is.igraph rewritten to make it possible to inherit from the 'igraph' class - somewhat better looking progress meter for functions which support it Others ------ - proper support for Debian packages (re)added - many functions benefit from the new internal representation and are faster now: transitivity, reciprocity, graph operator functions like intersection and union, etc. - igraph compiles with Microsoft Visual C++ now - there were some internal changes to make igraph a real graph algorithm platform in the near future, but these are undocumented now Bugs corrected -------------- - corrected a bug when reading Pajek files: directed graphs were read as undirected Debian package repository available ================================== Debian Linux users can now install and update the C interface using the standard package manager. Just add the following two lines to /etc/apt/sources.list and install the libigraph and libigraph-dev packages. Packages for the Python interface are coming soon. deb http://cneurocvs.rmki.kfki.hu /packages/binary/ deb-src http://cneurocvs.rmki.kfki.hu /packages/source/ igraph 0.3.3 ============ Released February 28, 2007 New in the C library -------------------- * igraph_connect_neighborhood, nomen est omen * igraph_watts_strogatz_game and igraph_rewire_edges * K-core decomposition: igraph_coreness * Clique and independent vertex set related functions: igraph_cliques, igraph_independent_vertex_sets, igraph_maximal_cliques, igraph_maximal_independent_vertex_sets, igraph_independence_number, igraph_clique_number, Some of these function were ported from the very_nauty library of Keith Briggs, thanks Keith! * The GraphML file format now supports graph attributes * Transitivity calculation speeded up * Correct transitivity calculation for multigraphs (ie. non-simple graphs) New in the R interface ---------------------- * connect.neighborhood * watts.strogatz.game and rewire.edges * K-core decomposition: graph.coreness * added the 'innei' and 'outnei' shorthands for vertex sequence indexing see help(iterators) * Clique and independent vertex set related functions: cliques, largest.cliques, maximal.cliques, clique.number, independent.vertex.sets, largest.independent.vertex.sets, maximal.independent.vertex.sets, independence.number * The GraphML file format now supports graph attributes * edge.lty argument added to plot.igraph and tkplot * Transitivity calculation speeded up * Correct transitivity calculation for multigraphs (ie. non-simple graphs) * alpha.centrality added, calculates Bonacich alpha centrality, see docs. Bugs corrected -------------- * 'make install' installs the library correctly on Cygwin now * Pajek parser corrected to read files with MacOS newline characters correctly * overflow bug in transitivity calculation for large graphs corrected * an internal memcpy/memmove bug causing some segfaults removed * R interface: tkplot bug with graphs containing a 'name' attribute * R interface: attribute handling bug when adding vertices * R interface: color selection bug corrected * R interface: plot.igraph when plotting loops Python interface documentation ==================== Jan 8, 2007 The documentation of the Python interface is available. See section 'documentation' in the menu on the left. igraph 0.3.2 ========= Released Dec 19, 2006 This is a new major release, it contains many new things: Changes in the C library ------------------------ - igraph_maxdegree added, calculates the maximum degree in the graph - igraph_grg_game, geometric random graphs - igraph_density, graph density calculation - push-relabel maximum flow algorithm added, igraph_maxflow_value - minimum cut functions added based on maximum flow: igraph_st_mincut_value, igraph_mincut_value, the Stoer-Wagner algorithm is implemented for undirected graphs - vertex connectivity functions, usually based on maximum flow: igraph_st_vertex_connectivity, igraph_vertex_connectivity - edge connectivity functions, usually based on maximum flow: igraph_st_edge_connectivity, igraph_edge_connectivity - other functions based on maximum flow: igraph_edge_disjoint_paths, igraph_vertex_disjoint_paths, igraph_adhesion, igraph_cohesion - dimacs file format added - igraph_to_directed handles attributes - igraph_constraint calculation corrected, it handles weighted graphs - spinglass-based community structure detection, the Joerg Reichardt -- Stefan Bornholdt algorithm added: igraph_spinglass_community, igraph_spinglass_my_community - igraph_extended_chordal_rings, it creates extended chordal rings - 'no' argument added to igraph_clusters, it is possible to calculate the number of clusters without calculating the clusters themselves - minimum spanning tree functions keep attributes now and also the direction of the edges is kept in directed graphs - there are separate functions to calculate different types of transitivity now - igraph_delete_vertices rewritten to allocate less memory for the new graph - neighborhood related functions added: igraph_neighborhood, igraph_neighborhood_size, igraph_neighborhood_graphs - two new games added based on different node types: igraph_preference_game and igraph_asymmetric_preference_game - Laplacian of a graph can be calculated by the igraph_laplacian function Changes in the R interface -------------------------- - bonpow function ported from SNA to calculate Bonacich power centrality - get.adjacency supports attributes now, this means that it sets the colnames and rownames attributes and can return attribute values in the matrix instead of 0/1 - grg.game, geometric random graphs - graph.density, graph density calculation - edge and vertex attributes can be added easily now when added new edges with add.edges or new vertices with add.vertices - graph.data.frame creates graph from data frames, this can be used to create graphs with edge attributes easily - plot.igraph and tkplot can plot self-loop edges now - graph.edgelist to create a graph from an edge list, can also handle edge lists with symbolic names - get.edgelist has now a 'names' argument and can return symbolic vertex names instead of vertex ids, by default id uses the 'name' vertex attribute is returned - printing graphs on screen also prints symbolic symbolic names (the 'name' attribute if present) - maximum flow and minimum cut functions: graph.maxflow, graph.mincut - vertex and edge connectivity: edge.connectivity, vertex.connectivity - edge and vertex disjoint paths: edge.disjoint.paths, vertex.disjoint.paths - White's cohesion and adhesion measure: graph.adhesion, graph.cohesion - dimacs file format added - as.directed handles attributes now - constraint corrected, it handles weighted graphs as well now - weighted attribute to graph.adjacency - spinglass-based community structure detection, the Joerg Reichardt -- Stefan Bornholdt algorithm added: spinglass.community - graph.extended.chordal.ring, extended chordal ring generation - no.clusters calculates the number of clusters without calculating the clusters themselves - minimum spanning tree functions updated to keep attributes - transitivity can calculate local transitivity as well - neighborhood related functions added: neighborhood, neighborhood.size, graph.neighborhood - new graph generators based on vertex types: preference.game and asymmetric.preference.game Bugs corrected -------------- - attribute handling bug when deleting edges corrected - GraphML escaping and NaN handling corrected - bug corrected to make it possible compile the R package without the libxml2 library - a bug in Erdos-Renyi graph generation corrected: it had problems with generating large directed graphs - bug in constraint calculation corrected, it works well now - fixed memory leaks in igraph_read_graph_graphml - error handling bug corrected in igraph_read_graph_graphml - bug corrected in R version of graph.laplacian when normalized Laplacian is requested - memory leak corrected in get.all.shortest.paths in the R package igraph 0.2.1 ========= Released Aug 23, 2006 This is a bug-fix release. Bugs fixed: - igraph_reciprocity (reciprocity in R) corrected to avoid segfaults - some docs updates - various R package updated to make it conform to the CRAN rules igraph 0.2 ========= Released Aug 18, 2006 Release time at last! There are many new things in igraph 0.2, the most important ones: - reading writing Pajek and GraphML formats with attributes (not all Pajek and GraphML files are supported, see documentation for details) - iterators totally rewritten, it is much faster and cleaner now - the RANDEDU fast motif search algorithm is implemented - many new graph generators, both games and regular graphs - many new structural properties: transitivity, reciprocity, etc. - graph operators: union, intersection, difference, structural holes, etc. - conversion between directed and undirected graphs - new layout algorithms for trees and large graphs, 3D layouts and many more. New things in the R package: - support for CTRL+C - new functions: Graph Laplacian, Burt's constraint, etc. - vertex/edge sequences totally rewritten, smart indexing (see manual) - new R manual and tutorial: 'Network Analysis with igraph', still under development but useful - very basic 3D plotting using OpenGL Although this release was somewhat tested on Linux, MS Windows, Mac OSX, Solaris 8 and FreeBSD, no heavy testing was done, so it might contain bugs, and we kindly ask you to send bug reports to make igraph better. igraph mailing lists ==================== Aug 18, 2006 I've set up two igraph mailing lists: igraph-help for general igraph questions and discussion and igraph-anonunce for announcements. See http://lists.nongnu.org/mailman/listinfo/igraph-help and http://lists.nongnu.org/mailman/listinfo/igraph-announce for subscription information, archives, etc. igraph 0.1 ========= Released Jan 30, 2006 After about a year of development this is the first "official" release of the igraph library. This release should be considered as beta software, but it should be useful in general. Please send your questions and comments. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/README.md0000644000175100001710000000176600000000000021143 0ustar00runnerdocker00000000000000[![Build Status on Azure Pipelines](https://dev.azure.com/igraph-team/igraph/_apis/build/status/igraph.igraph?branchName=master)](https://dev.azure.com/igraph-team/igraph/_build/latest?definitionId=1&branchName=master) ![Build Status on Github Actions](https://github.com/igraph/igraph/workflows/MINGW/badge.svg?branch=master) [![codecov](https://codecov.io/gh/igraph/igraph/branch/master/graph/badge.svg?token=xGFabHJE2I)](https://codecov.io/gh/igraph/igraph) [![DOI](https://zenodo.org/badge/8546198.svg)](https://zenodo.org/badge/latestdoi/8546198) The igraph library ------------------ igraph is a C library for creating, manipulating and analysing graphs. It is intended to be as powerful (i.e. fast) as possible to enable working with large graphs. See https://igraph.org for installation instructions and documentation. igraph can also be used from: - R — https://github.com/igraph/rigraph - Python — https://github.com/igraph/python-igraph - Mathematica — https://github.com/szhorvat/IGraphM ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/SUPPORT.md0000644000175100001710000000227500000000000021356 0ustar00runnerdocker00000000000000# Need help with the igraph C library? _This repository is **only** about the C library of `igraph`. Do you use `igraph` from a different language? Then please see the repositories for the [R interface](https://github.com/igraph/rigraph/), the [Python interface](https://github.com/igraph/python-igraph/) or the [Mathematica interface](https://github.com/szhorvat/IGraphM)._ Having problems with igraph? - First, check our [documentation](https://igraph.org/c/html/latest/) for answers. * Problems with installing `igraph`? Please check our [installation instructions](https://igraph.org/c/html/latest/igraph-Installation.html). * Problems compiling your own code? Please check our [tutorial](https://igraph.org/c/html/latest/igraph-Tutorial.html) on writing your first `igraph` program. - Do you have a question about `igraph`? Please post your question on our [support forum](https://igraph.discourse.group/). - If you **found a bug**, please go ahead and [open a new issue](https://github.com/igraph/igraph/issues). We use the [issue tracker](https://github.com/igraph/igraph/issues) for bug reports and feature requests, and the [support forum](https://igraph.discourse.group/) for questions. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/appveyor.yml0000644000175100001710000000537700000000000022256 0ustar00runnerdocker00000000000000# Ignore branches with names starting with certain keywords: branches: except: - /^(github|travis)\/.+$/ # We always use a 64-bit machine, but can build x86 distributions platform: - x64 environment: global: VCPKG_DEFAULT_TRIPLET: x64-windows-static matrix: - job_name: Static - job_name: Dynamic cache: - C:\ProgramData\chocolatey\bin -> appveyor.yml - C:\ProgramData\chocolatey\lib -> appveyor.yml - C:\Tools\vcpkg\installed -> appveyor.yml install: # Install dependencies for MSVC build - choco install winflexbison # Choose VS 2015, https://www.appveyor.com/docs/lang/cpp/#visual-studio-2015 - call "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x64 - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x86_amd64 # Update vcpkg, as included version does not have GMP # https://www.appveyor.com/docs/lang/cpp/#vc-packaging-tool - cd C:\Tools\vcpkg # - git pull --quiet # - .\bootstrap-vcpkg.bat -disableMetrics # - vcpkg install yasm-tool:x86-windows # - vcpkg install gmp - vcpkg install libxml2 - vcpkg integrate install for: - matrix: only: - job_name: Static before_build: - cd "%APPVEYOR_BUILD_FOLDER%" - mkdir build - cd build - cmake .. -A x64 -DCMAKE_TOOLCHAIN_FILE=C:/Tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DIGRAPH_GRAPHML_SUPPORT=1 -DIGRAPH_USE_INTERNAL_BLAS=1 -DIGRAPH_USE_INTERNAL_LAPACK=1 -DIGRAPH_USE_INTERNAL_ARPACK=1 -DIGRAPH_USE_INTERNAL_GLPK=1 -DIGRAPH_USE_INTERNAL_CXSPARSE=1 -DIGRAPH_USE_INTERNAL_GMP=1 -DIGRAPH_VERIFY_FINALLY_STACK=1 - matrix: only: - job_name: Dynamic before_build: - cd "%APPVEYOR_BUILD_FOLDER%" - mkdir build - cd build - cmake .. -A x64 -DCMAKE_TOOLCHAIN_FILE=C:/Tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DBUILD_SHARED_LIBS=1 -DIGRAPH_GRAPHML_SUPPORT=1 -DIGRAPH_USE_INTERNAL_BLAS=1 -DIGRAPH_USE_INTERNAL_LAPACK=1 -DIGRAPH_USE_INTERNAL_ARPACK=1 -DIGRAPH_USE_INTERNAL_GLPK=1 -DIGRAPH_USE_INTERNAL_CXSPARSE=1 -DIGRAPH_USE_INTERNAL_GMP=1 -DIGRAPH_VERIFY_FINALLY_STACK=1 configuration: Release build: parallel: true verbosity: minimal test_script: - cd "%APPVEYOR_BUILD_FOLDER%" - cd build - ctest --output-on-failure -C Release on_failure: - echo zipping everything after a failure... - cd "%APPVEYOR_BUILD_FOLDER%" - 7z a failed_state.zip . | grep -v "Compressing" - appveyor PushArtifact failed_state.zip ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/azure-pipelines.yml0000644000175100001710000000752700000000000023524 0ustar00runnerdocker00000000000000pool: vmImage: 'ubuntu-latest' variables: CMAKE_GENERATOR: Ninja CCACHE_DIR: $(Pipeline.Workspace)/ccache jobs: - job: linux_static_vendored steps: - script: sudo apt-get install ninja-build ccache -y displayName: Install dependencies - template: .azure/build.yml parameters: build_type: Debug extra_cmake_args: '-DUSE_SANITIZER=Address\;Undefined -DCMAKE_C_FLAGS="-Og" -DCMAKE_CXX_FLAGS="-Og"' - job: linux_static_external steps: - script: sudo apt-get install ninja-build ccache libgmp-dev libglpk-dev libarpack2-dev libopenblas-dev -y displayName: Install dependencies - template: .azure/build.yml parameters: int_blas: false int_lapack: false int_arpack: false int_cxsparse: false int_gmp: false int_glpk: false extra_cmake_args: '-DBLA_VENDOR=OpenBLAS' - job: linux_shared_vendored steps: - script: sudo apt-get install ninja-build ccache -y displayName: Install dependencies - template: .azure/build.yml parameters: build_shared: true - job: linux_shared_external steps: - script: sudo apt-get install ninja-build ccache libgmp-dev libglpk-dev libarpack2-dev libopenblas-dev -y displayName: Install dependencies - template: .azure/build.yml parameters: int_blas: false int_lapack: false int_arpack: false int_cxsparse: false int_gmp: false int_glpk: false extra_cmake_args: '-DBLA_VENDOR=OpenBLAS' build_shared: true - job: linux_x87 steps: - script: sudo apt-get install ninja-build ccache -y displayName: Install dependencies - template: .azure/build.yml parameters: extra_cmake_args: '-DCMAKE_C_FLAGS="-mfpmath=387" -DCMAKE_CXX_FLAGS="-mfpmath=387"' - job: linux_alpine steps: # https://github.com/alpinelinux/alpine-chroot-install - bash: | wget https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.13.2/alpine-chroot-install && echo '60c7e0b5d82e21d1a549fc9a46ba3b36688c09dc alpine-chroot-install' | sha1sum -c || exit 1 alpine() { /alpine/enter-chroot -u "$USER" "$@"; } sudo sh alpine-chroot-install -p 'build-base linux-headers git cmake ninja bison flex gmp-dev' mkdir build && cd build alpine cmake .. -GNinja -DIGRAPH_USE_INTERNAL_BLAS=1 -DIGRAPH_USE_INTERNAL_LAPACK=1 -DIGRAPH_USE_INTERNAL_ARPACK=1 -DIGRAPH_USE_INTERNAL_GLPK=1 -DIGRAPH_USE_INTERNAL_CXSPARSE=1 -DIGRAPH_USE_INTERNAL_GMP=1 -DIGRAPH_ENABLE_TLS=1 -DIGRAPH_VERIFY_FINALLY_STACK=1 alpine cmake --build . --target build_tests alpine ctest -j `nproc` --output-on-failure - job: macos pool: vmImage: macos-latest steps: - script: | brew update brew install ninja ccache displayName: Install dependencies - template: .azure/build.yml parameters: int_blas: false int_lapack: false - job: windows_static pool: vmImage: windows-2019 steps: - template: .azure/build-win.yml - job: windows_shared pool: vmImage: windows-2019 steps: - template: .azure/build-win.yml parameters: build_shared: true vcpkg_target_triplet: x64-windows - job: documentation steps: - script: sudo apt-get update displayName: Update package registry - script: sudo apt-get install ninja-build xmlto texinfo source-highlight libxml2-utils xsltproc fop -y displayName: Install dependencies - task: CMake@1 displayName: CMake inputs: cmakeArgs: '..' - task: CMake@1 displayName: Doc build inputs: cmakeArgs: '--build . --target doc' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/codecov.yml0000644000175100001710000000072300000000000022021 0ustar00runnerdocker00000000000000# See https://docs.codecov.io/docs/codecov-yaml for documentation codecov: require_ci_to_pass: yes coverage: precision: 2 round: down range: "50...100" status: project: default: threshold: 0.01% parsers: gcov: branch_detection: conditional: yes loop: yes method: no macro: no comment: layout: "reach,diff,flags,files,footer" behavior: default require_changes: no ignore: - "tests" - "examples" ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4271395 igraph-0.9.9/vendor/source/igraph/doc/0000755000175100001710000000000000000000000020417 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/CMakeLists.txt0000644000175100001710000002176200000000000023167 0ustar00runnerdocker00000000000000# Specify the list of .xml files that are used as-is set( DOCBOOK_SOURCES fdl.xml gpl.xml igraph-docs.xml installation.xml introduction.xml licenses.xml pmt.xml tutorial.xml ) # Specify the list of .xxml files that have to be piped through doxrox to # obtain the final set of .xml files that serve as an input to DocBook set( DOXROX_SOURCES adjlist.xxml arpack.xxml attributes.xxml basicigraph.xxml bipartite.xxml cliques.xxml coloring.xxml community.xxml cycles.xxml dqueue.xxml embedding.xxml error.xxml flows.xxml foreign.xxml generators.xxml graphlets.xxml heap.xxml hrg.xxml isomorphism.xxml iterators.xxml layout.xxml matrix.xxml memory.xxml motifs.xxml nongraph.xxml operators.xxml progress.xxml psumtree.xxml random.xxml scg.xxml separators.xxml sparsemat.xxml sparsematrix.xxml spatialgames.xxml stack.xxml status.xxml structural.xxml strvector.xxml threading.xxml vector.xxml visitors.xxml ) # Specify the igraph source files that may contain documentation chunks file( GLOB_RECURSE IGRAPH_SOURCES_FOR_DOXROX LIST_DIRECTORIES FALSE ${CMAKE_SOURCE_DIR}/include/*.h ${CMAKE_SOURCE_DIR}/include/*.h.in ${CMAKE_BINARY_DIR}/include/*.h ${CMAKE_SOURCE_DIR}/src/*.c ${CMAKE_SOURCE_DIR}/src/*.cc ${CMAKE_SOURCE_DIR}/src/*.cpp ${CMAKE_SOURCE_DIR}/src/*.h ${CMAKE_SOURCE_DIR}/src/*.pmt ) # Specify the igraph source files that are used as examples in the # documentation file( GLOB DOCBOOK_EXAMPLES LIST_DIRECTORIES FALSE RELATIVE ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/examples/simple/*.c ${CMAKE_SOURCE_DIR}/examples/tutorial/*.c ) # You should not need to change anything below this line if you are simply # trying to add new files to produce documentation from # Documentation build requires Python and source-highlight find_package(Python3) find_program(SOURCE_HIGHLIGHT_COMMAND source-highlight) # HTML documentation additionally requires xmlto from DocBook find_program(XMLTO_COMMAND xmlto) # PDF documentation additionally requires xsltproc, xmllint and Apache FOP find_program(FOP_COMMAND fop) find_program(XMLLINT_COMMAND xmllint) find_program(XSLTPROC_COMMAND xsltproc) if(Python3_FOUND AND SOURCE_HIGHLIGHT_COMMAND) set(DOC_BUILD_SUPPORTED TRUE) else() set(DOC_BUILD_SUPPORTED FALSE) endif() if(DOC_BUILD_SUPPORTED AND XMLTO_COMMAND) set(HTML_DOC_BUILD_SUPPORTED TRUE) else() set(HTML_DOC_BUILD_SUPPORTED FALSE) endif() if(DOC_BUILD_SUPPORTED AND XMLLINT_COMMAND AND XSLTPROC_COMMAND AND FOP_COMMAND) set(PDF_DOC_BUILD_SUPPORTED TRUE) else() set(PDF_DOC_BUILD_SUPPORTED FALSE) endif() if(DOC_BUILD_SUPPORTED) set(DOXROX_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxrox.py) set(DOXROX_RULES ${CMAKE_CURRENT_SOURCE_DIR}/c-docbook.re) set(DOXROX_CHUNKS ${CMAKE_CURRENT_BINARY_DIR}/chunks.pickle) set(DOXROX_CACHE ${CMAKE_CURRENT_BINARY_DIR}/doxrox.cache) set(DOCBOOK_INPUTS "") set(DOCBOOK_GENERATED_INPUTS "") # Specify that each DocBook .xml file is to be copied to the build folder # TODO(ntamas): currently this works with out-of-tree builds only set(IGRAPH_VERSION ${PACKAGE_VERSION}) # for replacement in igraph-docs.xml foreach(DOCBOOK_SOURCE ${DOCBOOK_SOURCES}) set(DOCBOOK_INPUT "${CMAKE_CURRENT_BINARY_DIR}/${DOCBOOK_SOURCE}") list(APPEND DOCBOOK_INPUTS "${DOCBOOK_INPUT}") configure_file(${DOCBOOK_SOURCE} ${DOCBOOK_INPUT}) endforeach() # Specify that .xxml files should be piped through doxrox.py to get a # DocBook-compatible .xml file. This step inserts the documentation chunks # extracted from the igraph source to the DocBook sources foreach(DOXROX_SOURCE ${DOXROX_SOURCES}) string(REGEX REPLACE "[.]xxml$" ".xml" DOXROX_OUTPUT ${DOXROX_SOURCE}) set(COMMENT "Generating ${DOXROX_OUTPUT} from ${DOXROX_SOURCE}") string(PREPEND DOXROX_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/") list(APPEND DOCBOOK_INPUTS "${DOXROX_OUTPUT}") list(APPEND DOCBOOK_GENERATED_INPUTS "${DOXROX_OUTPUT}") add_custom_command( OUTPUT ${DOXROX_OUTPUT} COMMAND ${DOXROX_COMMAND} ARGS -t ${CMAKE_CURRENT_SOURCE_DIR}/${DOXROX_SOURCE} --chunks ${DOXROX_CHUNKS} -o ${DOXROX_OUTPUT} MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${DOXROX_SOURCE} DEPENDS ${DOXROX_CHUNKS} COMMENT ${COMMENT} ) endforeach() # When all .xxml and .xml files have been processed, we have to send them # through a custom Python script that extracts the ID references and produces # a ctags-compatible "tags" file. This will then be used later by # source-highlight to cross-reference the known tokens from the source code # of the examples list(JOIN DOCBOOK_GENERATED_INPUTS ";" DOCBOOK_GENERATED_INPUTS_AS_STRING) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/tags" COMMAND ${CMAKE_COMMAND} ARGS -DINPUT_FILES="${DOCBOOK_GENERATED_INPUTS_AS_STRING}" -DOUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/tags -P ${CMAKE_SOURCE_DIR}/etc/cmake/generate_tags_file.cmake DEPENDS ${DOCBOOK_GENERATED_INPUTS} COMMENT "Creating tags file from DocBook xmls" ) # Specify that each example source file is to be piped through source-higlight # to produce an .xml representation that can be used in the DocBook # documentation foreach(DOCBOOK_EXAMPLE_SOURCE ${DOCBOOK_EXAMPLES}) string(REGEX REPLACE "[.]c$" ".c.xml" DOCBOOK_EXAMPLE_OUTPUT ${DOCBOOK_EXAMPLE_SOURCE}) set(COMMENT "Highlighting source code in ${DOCBOOK_EXAMPLE_SOURCE}") set(DOCBOOK_EXAMPLE_OUTPUT "${CMAKE_BINARY_DIR}/${DOCBOOK_EXAMPLE_SOURCE}.xml") list(APPEND DOCBOOK_INPUTS "${DOCBOOK_EXAMPLE_OUTPUT}") get_filename_component(DOCBOOK_EXAMPLE_OUTPUT_DIR "${DOCBOOK_EXAMPLE_OUTPUT}" DIRECTORY) add_custom_command( OUTPUT ${DOCBOOK_EXAMPLE_OUTPUT} COMMAND ${CMAKE_COMMAND} -E make_directory ${DOCBOOK_EXAMPLE_OUTPUT_DIR} COMMAND ${SOURCE_HIGHLIGHT_COMMAND} ARGS --src-lang c --out-format docbook --input ${CMAKE_SOURCE_DIR}/${DOCBOOK_EXAMPLE_SOURCE} --output ${DOCBOOK_EXAMPLE_OUTPUT} --gen-references inline --ctags="" --outlang-def ${CMAKE_SOURCE_DIR}/doc/docbook.outlang MAIN_DEPENDENCY ${CMAKE_SOURCE_DIR}/${DOCBOOK_EXAMPLE_SOURCE} DEPENDS tags COMMENT ${COMMENT} ) endforeach() add_custom_command( OUTPUT ${DOXROX_CHUNKS} ${DOXROX_CACHE} COMMAND ${DOXROX_COMMAND} ARGS -e ${DOXROX_RULES} -o ${DOXROX_CHUNKS} --cache ${DOXROX_CACHE} ${IGRAPH_SOURCES_FOR_DOXROX} MAIN_DEPENDENCY ${DOXROX_RULES} DEPENDS ${IGRAPH_SOURCES_FOR_DOXROX} COMMENT "Parsing documentation chunks from source code" ) if(HTML_DOC_BUILD_SUPPORTED) set(HTML_STAMP ${CMAKE_CURRENT_BINARY_DIR}/html/stamp) add_custom_command( OUTPUT ${HTML_STAMP} COMMAND ${XMLTO_COMMAND} -x ${CMAKE_CURRENT_SOURCE_DIR}/gtk-doc.xsl -o html xhtml igraph-docs.xml COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/html/*.css ${CMAKE_CURRENT_BINARY_DIR}/html COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/html/*.js ${CMAKE_CURRENT_BINARY_DIR}/html COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/html/*.png ${CMAKE_CURRENT_BINARY_DIR}/html COMMAND ${CMAKE_COMMAND} -E touch ${HTML_STAMP} MAIN_DEPENDENCY igraph-docs.xml DEPENDS ${DOCBOOK_INPUTS} COMMENT "Generating HTML documentation with xmlto" ) add_custom_target(html DEPENDS ${HTML_STAMP}) set(HTML_TARGET html) endif() if(PDF_DOC_BUILD_SUPPORTED) add_custom_command( OUTPUT igraph-docs-with-resolved-includes.xml COMMAND ${XMLLINT_COMMAND} ARGS --xinclude --output igraph-docs-with-resolved-includes-tmp.xml igraph-docs.xml COMMAND ${Python3_EXECUTABLE} ARGS ${CMAKE_SOURCE_DIR}/tools/removeexamples.py igraph-docs-with-resolved-includes-tmp.xml igraph-docs-with-resolved-includes.xml COMMAND ${CMAKE_COMMAND} ARGS -E remove igraph-docs-with-resolved-includes-tmp.xml MAIN_DEPENDENCY igraph-docs.xml DEPENDS ${DOCBOOK_INPUTS} COMMENT "Resolving includes in DocBook XML source" ) add_custom_command( OUTPUT igraph-docs.fo COMMAND ${XSLTPROC_COMMAND} ARGS --output igraph-docs.fo --stringparam paper.type A4 http://docbook.sourceforge.net/release/xsl/current/fo/docbook.xsl igraph-docs-with-resolved-includes.xml MAIN_DEPENDENCY igraph-docs-with-resolved-includes.xml COMMENT "Converting DocBook XML to Apache FOP format" ) add_custom_command( OUTPUT igraph-docs.pdf COMMAND ${FOP_COMMAND} ARGS -fo igraph-docs.fo -pdf igraph-docs.pdf MAIN_DEPENDENCY igraph-docs.fo COMMENT "Generating PDF documentation with Apache FOP" ) add_custom_target(pdf DEPENDS igraph-docs.pdf) set(PDF_TARGET pdf) endif() add_custom_target(doc DEPENDS ${HTML_TARGET} ${PDF_TARGET}) endif() set(HTML_DOC_BUILD_SUPPORTED ${HTML_DOC_BUILD_SUPPORTED} PARENT_SCOPE) set(PDF_DOC_BUILD_SUPPORTED ${PDF_DOC_BUILD_SUPPORTED} PARENT_SCOPE) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/adjlist.xxml0000644000175100001710000000336000000000000022765 0ustar00runnerdocker00000000000000 ]>
Adjacency lists
Adjacent vertices
Incident edges
Lazy adjacency list for vertices
Lazy incidence list for edges
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/arpack.xxml0000644000175100001710000000350400000000000022574 0ustar00runnerdocker00000000000000 ]> Using BLAS, LAPACK and ARPACK for igraph matrices and graphs
Matrix factorization, solving linear systems
Eigenvalues and eigenvectors of matrices
Data structures
ARPACK solvers
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/attributes.xxml0000644000175100001710000001031000000000000023512 0ustar00runnerdocker00000000000000 ]> Graph, vertex and edge attributes
The Attribute Handler Interface
Handling attribute combination lists
Accessing attributes from C
Query attributes
Set attributes
Remove attributes
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/basicigraph.xxml0000644000175100001710000001145300000000000023611 0ustar00runnerdocker00000000000000 ]> About &igraph; graphs, the basic interface
The &igraph; data model The &igraph; library can handle directed and undirected graphs. The &igraph; graphs are multisets of ordered (if directed) or unordered (if undirected) labeled pairs. The labels of the pairs plus the number of vertices always starts with zero and ends with the number of edges minus one. In addition to that a table of metadata is also attached to every graph, its most important entries being the number of vertices in the graph and whether the graph is directed or undirected. Like the edges, the &igraph; vertices are also labeled by numbers between zero and the number of vertices minus one. So, to summarize, a directed graph can be imagined like this: ( vertices: 6, directed: yes, { (0,2), (2,2), (3,2), (3,3), (3,4), (3,4), (4,3), (4,1) } ) Here the edges are ordered pairs or vertex ids, and the graph is a multiset of edges plus some metadata. An undirected graph is like this: ( vertices: 6, directed: no, { (0,2), (2,2), (2,3), (3,3), (3,4), (3,4), (3,4), (1,4) } ) Here, an edge is an unordered pair of two vertex ids. A graph is a multiset of edges plus metadata, just like in the directed case. It is possible to convert between directed and undirected graphs, see the igraph_to_directed() and igraph_to_undirected() functions. &igraph; aims to robustly support multigraphs, i.e. graphs which have more than one edge between some pairs of vertices, as well as graphs with self-loops. Most functions which do not support such graphs will check their input and issue an error if it is not valid. Those rare functions which do not perform this check clearly indicate this in their documentation. To eliminate multiple edges from a graph, you can use igraph_simplify().
About &igraph; functions &igraph; has a simple and consistent interface. Most functions check their input for validity and display an informative error message when something goes wrong. In order to support this, the majority of functions return an error code. In basic usage, this code can be ignored, as the default behaviour is to abort the program immediately upon error. See the section on error handling for more information on this topic. Results are typically returned through output arguments, i.e. pointers to a data structure into which the result will be written. In almost all cases, this data structure is expected to be pre-initialized. A few simple functions communicate their result directly through their return value—these functions can never encounter an error.
The basic interface
Graph constructors and destructors
Basic query operations
Adding and deleting vertices and edges
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/bibdatabase.xml0000644000175100001710000000360100000000000023362 0ustar00runnerdocker00000000000000 Albert-László Barabási RékaAlbert Emergence of scaling in random networks Science 1999 286 509-512 LászlóZalányi GáborCsárdi TamásKiss MátéLengyel RebeccaWarner JanTobochnik PéterÉrdi Properties of a random attachment growing network Phyisical Review E 2003 68 066104 L. R.Ford Jr. D. R.Fulkerson Maximal ow through a network Canadian J. Math. 1956 8 399--404 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/bipartite.xxml0000644000175100001710000000213300000000000023313 0ustar00runnerdocker00000000000000 ]> Bipartite, i.e. two-mode graphs
Create two-mode networks
Incidence matrices
Project two-mode graphs
Other operations on bipartite graphs
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0 igraph-0.9.9/vendor/source/igraph/doc/c-docbook.re0000644000175100001710000004605300000000000022617 0ustar00runnerdocker00000000000000REPLACE ----- remove the " * " prefix first -----------------*- mode:python -*- ^[ ]\*[ ] WITH -------------------------------------------------------------------------- REPLACE ----- remove the " *" lines ------------------------------------------- ^[ ]\*\s*\n WITH -------------------------------------------------------------------------- \n REPLACE ----- for the template functions -------------------------------------- FUNCTION\( (?P[^, \)]*)\s*,\s* (?P[^\)]*) \)\s* WITH \g_\g REPLACE ----- template type --------------------------------------------------- TYPE\( (?P[^\)]*) \) WITH \g_t REPLACE ----- template base type, we cowardly assume real number -------------- BASE WITH igraph_real_t REPLACE ----- function object, extract its signature -------------------------- (?P\A.*?) # head of the comment \\function\s+ # \function keyword (?P(?P
(igraph_)|(IGRAPH_)|())(?P\w+)) # the keyword, remove igraph_ prefix
[\s]*(?P[^\n]*?)\n        # brief description
(?P.*?)\*\/               # tail of the comment
\s*
(IGRAPH_EXPORT )?                # strip IGRAPH_EXPORT from prototype
(?P.*?\))                   # function head
(?=(\s*;)|(\s*\{))               # prototype ends with ; function head with {
.*\Z                             # and the remainder

WITH --------------------------------------------------------------------------



<function>\g<name></function> — \g<brief>
\g


\g;



\g
\g




REPLACE -----  for functions (not used currently) -------------------

(?P[^<]*)\n

RUN ---------------------------------------------------------------------------

dr_params=string.split(matched.group("params"), ',')
dr_out=""
for dr_i in dr_params:
    dr_i=string.strip(dr_i)
    if dr_i=="...":
        dr_out=dr_out+""
    else:
        dr_words=re.match(r"([\w\*\&\s]+)(\b\w+)$", dr_i).groups()
        dr_out=dr_out+""+dr_words[0]+""+dr_words[1]+ \
                "\n"
actch=actch[0:matched.start()]+dr_out+actch[matched.end():]

REPLACE ----- function parameter descriptions, head ---------------------------

(?P\A.*?)               # head of the comment
\\param\b                       # first \param commant

WITH --------------------------------------------------------------------------

\g
Arguments:

\\param

REPLACE ----- function parameter descriptions, tail ---------------------------

# the end of the params is either an empty line after the last \param
# command or a \return or \sa statement (others might be added later)
# or the end of the comment

\\param\b                         # the last \param command
(?P.*?)                # the text of the \param command
(?P                      # this marks the end of the \param text
 (\\return\b)|(\\sa\b)|           # it is either a \return or \sa or
 (\n\s*?\n)|                      # (at least) one empty line or
 (\*\/))                          # the end of the comment
(?P.*?\Z)                  # remaining part

WITH

\\param\g
\g\g

REPLACE ----- function parameter descriptions ---------------------------------

\\param\b\s*                      # \param command
(?P(\w+)|(...))\s+     # name of the parameter
(?P.*?)                # text of the \param command
(?=(\\param)|()|
 (\n\s*\n))


WITH --------------------------------------------------------------------------

  \g:
  
  \g

REPLACE ----- \return command -------------------------------------------------

# a return statement ends with an empty line or the end of the comment
\\return\b\s*                     # \return command
(?P.*?)                     # the text
(?=(\n\s*?\n)|                    # empty line or
 (\*\/)|                          # the end of the comment or
 (\\sa\b))                        # \sa command

WITH ----------------------------------------------------------------------TODO

Returns:
  
  
  \g
  


REPLACE ----- variables -------------------------------------------------------

(?P\A.*?)                 # head of the comment
\\var\s+                          # \var keyword + argument
(?P(?P
(igraph_)|(IGRAPH_)|())(?P\w+))
[\s]*(?P[^\n]*?)\n         # brief description
(?P.*?)\*\/                # tail of the comment
\s*(?P[^;]*;)                # the definition of the variable
.*\Z                              # and the remainder

WITH --------------------------------------------------------------------------


<function>\g<name></function> — \g<brief>
\g


\g


\g\g




REPLACE ----- \define ---------------------------------------------------------

(?P\A.*?)                 # head of the comment
\\define\s+                       # \define command
(?P(?P
(igraph_)|(IGRAPH_)|())(?P\w+))
[\s]*(?P[^\n]*?)\n         # brief description
(?P.*?)\*\/                # tail of the comment
\s*                               # whitespace
(?P\#define\s+[\w0-9,]+\s*   # macro name
(\([\w0-9, ]+\))?)                # macro args (optional)
.*\Z                              # drop the remainder

WITH --------------------------------------------------------------------------


<function>\g<name></function> — \g<brief>
\g


\g


\g\g




REPLACE ----- \section without title ------------------------------------------

(?P\A.*?)                 # head of the comment
\\section\s+(?P\w+)\s*$     # \section + argument
(?P.*?)\*\/                # tail of the comment
.*\Z                              # and the remainder, this is dropped

WITH

\g
\g

REPLACE ----- \section with title ---------------------------------------------

(?P\A.*?)                 # head of the comment
\\section\s+(?P\w+)         # \section + argument
(?P.*?)                    # section title
\n\s*?\n                          # empty line
(?P<after>.*?)\*\/                # tail of the comment
.*\Z                              # and the remainder, this is dropped

WITH

<title>\g<title>
\g
\g

REPLACE ----- \section with title ---------------------------------------------

(?P\A.*?)                 # head of the comment
\\section\s+(?P\w+)         # \section + argument
(?P.*?)\s*\*\/             # section title
.*\Z                              # and the remainder, this is dropped

WITH

<title>\g<title>
\g

REPLACE ----- an enumeration typedef ------------------------------------------

(?P\A.*?)                 # head of the comment
\\typedef\s+                      # \typedef command
(?P(?P
(igraph_)|(IGRAPH_)|())(?P\w+))
[\s]*(?P[^\n]*?)\n         # brief description
(?P.*?)                    # tail of the comment
 \*\/\s*                          # closing the comment
(?Ptypedef\s*enum\s*\{       # typedef enum
 [^\}]*\}\s*\w+\s*;)                  # rest of the definition
.*\Z

WITH --------------------------------------------------------------------------


<function>\g<name></function> — \g<brief>
\g


\g



\g\g




REPLACE ----- enumeration value descriptions, head ----------------------------

(?P\A.*?)               # head of the comment
\\enumval\b                     # first \param commant

WITH --------------------------------------------------------------------------

\g
Values:

\\enumval

REPLACE ----- enumeration value descriptions, tail ----------------------------

\\enumval\b                       # the last \enumval command
(?P.*?)                # the text of the \enumval command
(?P                      # this marks the end of the \enumval text
 (\\return\b)|(\\sa\b)|           # it is either a \return or \sa or
 (\n\s*?\n)|                      # (at least) one empty line or
 (\*\/))                          # the end of the comment
(?P.*?\Z)                  # remaining part

WITH

\\enumval\g
\g\g

REPLACE ----- enumeration value descriptions ----------------------------------

\\enumval\b\s*                    # \enumval command
(?P(\w+)|(...))\s+     # name of the parameter
(?P.*?)                # text of the \enumval command
(?=(\\enumval)|()|
 (\n\s*\n))

WITH --------------------------------------------------------------------------

  \g:
  
  \g

REPLACE ----- \struct ---------------------------------------------------------

(?P\A.*?)                 # head of the comment
\\struct\s+                       # \struct command
(?P(?P
(igraph_)|(IGRAPH_)|())(?P[\w_]+))
[\s]*(?P[^\n]*?)(?=\n)     # brief description
(?P.*?)                    # tail of the command
\*\/\s*                           # closing the comment
(?Ptypedef \s*struct\s*\w+\s*\{
 .*\}\s*\w+\s*;)
.*\Z

WITH --------------------------------------------------------------------------


<function>\g<name></function> — \g<brief>
\g


\g



\g\g




REPLACE ----- structure member descriptions, one block ------------------------

^[\s]*\n
(?P.*?)                # empty line+text
(?P\\member\b.*?)      # member commands
(?=                             # this marks the end of the \member text
 (\\return\b)|(\\sa\b)|         # it is either a \return or \sa or
 (^[\s]*\n)|                    # (at least) one empty line or
 (\*\/))                        # the end of the comment

WITH --------------------------------------------------------------------------


\g
Values:

\g


REPLACE ----- structure member descriptions -----------------------------------

\\member\b\s*                    # \enumval command
(?P(\w+)|(...))\s+     # name of the parameter
(?P.*?)                # text of the \enumval command
(?=(\\member)|()|
 (\n\s*\n))

WITH --------------------------------------------------------------------------

  \g:
  
  \g

REPLACE ----- \typedef function -----------------------------------------------

(?P\A.*?)                   # comment head
\\typedef\s+                      # \typedef command
(?P(?P
(igraph_)|(IGRAPH_)|())(?P\w+))
[\s]*(?P[^\n]*?)\n         # brief description
(?P.*?)                    # comment tail
\*\/                              # end of comment block
\s*
(?Ptypedef\s+[^;]*;)        # the typedef definition
.*\Z

WITH --------------------------------------------------------------------------


<function>\g<name></function> — \g<brief>
\g

\g


\g\g




REPLACE ----- ignore doxygen \ingroup command ---------------------------------

\\ingroup\s+\w+

WITH --------------------------------------------------------------------------

REPLACE ----- ignore doxygen \defgroup command --------------------------------

\\defgroup\s+\w+

WITH --------------------------------------------------------------------------

REPLACE ----- add the contents of \brief to the description -------------------

\\brief\b

WITH --------------------------------------------------------------------------

REPLACE ----- \varname command ------------------------------------------------

\\varname\b\s*
(?P\w+\b)

WITH

\g

REPLACE ----- references, \ref command ----------------------------------------

\\ref\b\s*
(?P\w+)(?P([\(][\)])?)

WITH --------------------------------------------------------------------------

\g\g

REPLACE ----- \sa command -----------------------------------------------------

\\sa\b
\s*
(?P.*?)
(?=(\n\s*?\n)|(\*\/))

WITH ----------------------------------------------------------------------TODO

See also:
  
  
  \g
  


REPLACE ----- \em command -----------------------------------------------------

\\em\b
\s*
(?P[^\s]+)

WITH

\g

REPLACE ----- \emb command ----------------------------------------------------

\\emb\b

WITH



REPLACE ----- \eme command ----------------------------------------------------

\\eme\b

WITH



REPLACE ----- \verbatim -------------------------------------------------------

\\verbatim\b

WITH



REPLACE ----- \endverbatim ----------------------------------------------------

\\endverbatim\b

WITH



REPLACE ----- \clist ----------------------------------------------------------

\\clist\b

WITH



REPLACE ----- \cli ------------------------------------------------------------

\\cli\s+(?P.*?)$
(?P.*?)
(?=(\\cli)|(\\endclist))

WITH --------------------------------------------------------------------------

\g

\g


REPLACE ----- \endclist -------------------------------------------------------

\\endclist\b

WITH



REPLACE ----- \olist ----------------------------------------------------------

\\olist\b

WITH



REPLACE ----- \oli ------------------------------------------------------------

\\oli\s+(?P.*?)
(?=(\\oli)|(\\endolist))

WITH


\g


REPLACE ----- \endolist -------------------------------------------------------

\\endolist\b

WITH



REPLACE ----- \ilist ----------------------------------------------------------

\\ilist\b

WITH



REPLACE ----- \ili ------------------------------------------------------------

\\ili\s+(?P.*?)
(?=(\\ili)|(\\endilist))

WITH


\g


REPLACE ----- \endilist -------------------------------------------------------

\\endilist\b

WITH



REPLACE ----- doxygen \c command is for  ----------------------------

\\c\s+(?P[\w\-^\']+)\b

WITH

\g

REPLACE ----- doxygen \p command is for  ---------------------------

\\p\s+(?P\w+)\b

WITH

\g

REPLACE ----- doxygen \type command is for  -----------------------------

\\type\s+(?P\w+)\b

WITH

\g

REPLACE ----- doxygen \a command is for  -----------------------------

\\a\s+(?P\w+)\b

WITH

\g

REPLACE ----- doxygen \quote command is for  ---------------------------

\\quote\s+

WITH



REPLACE ----- doxygen \endquote command is for  -----------------------

\s*\\endquote\b

WITH



REPLACE ----- replace  with  -----------------------------------

<(?P/?)code>

WITH --------------------------------------------------------------------------

<\gliteral>

REPLACE ----- add http:// and https:// links ----------------------------------

(?Phttps?:\/\/[-\+=&;%@./~()'\w_]*[-\+=&;%@/~'\w_])

WITH --------------------------------------------------------------------------

\g

REPLACE ----- blockquote ------------------------------------------------------

\\blockquote

WITH --------------------------------------------------------------------------




REPLACE ----- blockquote ------------------------------------------------------

\\endblockquote

WITH --------------------------------------------------------------------------




REPLACE ----- example file  ---------------------------------------------------

\\example\b\s*
(?P[^\n]*?)\n

WITH --------------------------------------------------------------------------


   File <code>\g<filename></code>
  
  


REPLACE ----- \deprecated-by --------------------------------------------------

\\deprecated-by\b\s*
(?P[^ \n]+)\s*
(?P[^\n]+)\n

WITH --------------------------------------------------------------------------



Deprecated since version \g. Please do not use this function in new
code; use \g()
instead.



REPLACE ----- \deprecated -----------------------------------------------------

\\deprecated\b\s*
(?P[^\n]*?)\n

WITH --------------------------------------------------------------------------



Deprecated since version \g. Please do not use this function in new
code.



REPLACE ----- \experimental ---------------------------------------------------

\\experimental\b\s*\n

WITH --------------------------------------------------------------------------



This function is experimental and its signature is not considered final yet.
We reserve the right to change the function signature without changing the
major version of igraph. Use it at your own risk.


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/cliques.xxml0000644000175100001710000000304600000000000023001 0ustar00runnerdocker00000000000000
]>


Cliques and independent vertex sets


These functions calculate various graph properties related
to cliques and independent vertex sets.



Cliques
















Weighted cliques







Independent vertex sets








././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/coloring.xxml0000644000175100001710000000055500000000000023152 0ustar00runnerdocker00000000000000

]>


Graph coloring





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/community.xxml0000644000175100001710000000501300000000000023354 0ustar00runnerdocker00000000000000

]>


Detecting community structure




Community structure based on statistical mechanics






Community structure based on eigenvectors of matrices








Walktrap: Community structure based on random walks





Edge betweenness based community detection






Community structure based on the optimization of modularity







Fluid communities





Label propagation





The InfoMAP algorithm





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/cycles.xxml0000644000175100001710000000075400000000000022621 0ustar00runnerdocker00000000000000

]>


Graph cycles


Eulerian cycles and paths








././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/docbook.outlang0000644000175100001710000000141500000000000023433 0ustar00runnerdocker00000000000000# by Stuart Rackham
# http://www.methods.co.nz/asciidoc/source-highlight-filter.html

extension "xml"

bold "$text"
italics "$text"

anchor "$text"
postline_reference "$text -> $linenum"
postdoc_reference "$text -> $linenum"
reference "$text"

doctemplate
"



$title

"
"


"
end

nodoctemplate
""
"
"
end

translations
"&" "&"
"<" "<"
">" ">"
end
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/doxrox.py0000755000175100001710000003717000000000000022327 0ustar00runnerdocker00000000000000#! /usr/bin/env python3

#   IGraph library
#   Copyright (C) 2005-2021  The igraph development team
#
#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
#   02110-1301 USA
#
###################################################################

"""DocBook XML generator for igraph.

The generator parses one or more input files for documentation chunks
(embedded in the source code as Doxygen-style comments), and processes
them with a set of regex-based rules. The processed chunks are then
substituted into a template file containing 
directives.

When a template file is not provided, the generator will read the input
files, process them with the ruleset and save a dictionary mapping chunk
names to the corresponding processed chunks into a Python pickle. This
can be used to speed up the processing of multiple input files as you can
generate the chunks once and then re-use them for multiple input files.
"""

import sys
import re

from argparse import ArgumentParser
from collections import defaultdict, namedtuple
from contextlib import contextmanager
from hashlib import sha1
from operator import itemgetter
from pathlib import Path
from pickle import dump, load
from time import time

#: Constant indicating the start of a comment that doxrox.py will process
DOXHEAD = r"/\*\*"

#: Stores whether we want verbose output
verbose = False


def fatal(message, code = 1):
    """Prints an error message and exits the program with the given error code."""
    print(message, file=sys.stderr)
    sys.exit(code)


#########################################################################
# The main function
#########################################################################


def main():
    """Main entry point of the script."""

    global verbose

    # get command line arguments
    parser = create_argument_parser()
    arguments = parser.parse_args()

    outputfile = arguments.output_file
    verbose = arguments.verbose
    inputs = arguments.inputs

    if (
        arguments.template_file in inputs
        or arguments.rules_file in inputs
        or outputfile in inputs
    ):
        fatal("Special file is also used as an input file", 2)

    # open the cache file if needed
    cache = ChunkCache(arguments.cache_file) if arguments.cache_file else None

    # get all regular expressions
    if arguments.rules_file:
        with operation("Reading regular expressions...") as op:
            rules = read_regex_rules_file(arguments.rules_file)
            op("{0} rules read".format(len(rules)))
    else:
        rules = []

    # parse all input files and extract chunks, apply rules
    if arguments.chunk_file:
        with operation("Reading pickled chunks...") as op:
            try:
                with open(arguments.chunk_file, "rb") as f:
                    all_chunks = load(f)
            except IOError:
                fatal("Error reading chunk file: " + arguments.chunk_file, 9)
            op("{0} chunks read".format(len(all_chunks)))
    else:
        all_chunks = {}

    rule_timings = defaultdict(list)

    for ifile in inputs:
        with operation("Parsing input file {0}...".format(ifile)) as op:
            try:
                with open(ifile, "r") as f:
                    contents = f.read()
            except IOError:
                fatal("Error reading input file: " + ifile, 3)

            if cache:
                key = cache.key_of(contents)
                chunks = cache.get(key)
            else:
                key, chunks = None, None

            if chunks is not None:
                op("{0} chunks read from cache".format(len(chunks)))
            else:
                chunks = collect_chunks_from_input_file(contents, rules, rule_timings)
                op("{0} chunks parsed".format(len(chunks)))
                if key:
                    cache.put(key, chunks)

            for name, chunk in chunks.items():
                if name in all_chunks:
                    fatal("Multiple files provide chunks for {0!r}".format(name), code=4)
                all_chunks[name] = chunk

    if arguments.timing_stats and rule_timings:
        rule_timings = {name: sum(dts) / len(dts) for name, dts in rule_timings.items()}
        for name, dt in sorted(rule_timings.items(), key=itemgetter(1), reverse=True):
            print("{0}: {1:.3f}us".format(name, dt))
        print("======")

    if cache:
        cache.close()

    if arguments.template_file:
        # substitute the template file
        with operation("Reading template file..."):
            try:
                with open(arguments.template_file, "r") as tfile:
                    tstring = tfile.read()
            except IOError:
                fatal("Error reading the template file: " + arguments.template_file, 7)

        with operation("Substituting template file..."):
            chunk_iterator = re.finditer(
                r"", tstring
            )
            outstring = []
            last = 0
            for match in chunk_iterator:
                try:
                    chunk = all_chunks[match.group(1)]
                except KeyError:
                    fatal("Chunk not found: {0}".format(match.group(1)), code=4)
                outstring.append(tstring[last : match.start()])
                outstring.append(chunk)
                last = match.end()
            outstring.append(tstring[last:])
            outstring = "".join(outstring)

        # write output file
        with operation("Writing output file..."):
            try:
                with open(outputfile, "w") as ofile:
                    ofile.write(outstring)
            except IOError:
                fatal("Error writing output file:" + outputfile, 8)
    else:
        # no template file given so just save the chunks as a pickle into the
        # output file
        with operation("Writing output file..."):
            try:
                with open(outputfile, "wb") as ofile:
                    dump(all_chunks, ofile)
            except IOError:
                fatal("Error writing output file:" + outputfile, 5)


#########################################################################
# Argument parser
#########################################################################


def create_argument_parser():
    """Creates the command line argument parser that the script uses."""
    parser = ArgumentParser(description=sys.modules[__name__].__doc__.strip())

    parser.add_argument(
        "--cache", metavar="FILE",
        dest="cache_file",
        help="optional cache file to store chunks from already processed files"
    )
    parser.add_argument(
        "-t",
        "--template",
        metavar="FILE",
        dest="template_file",
        help="template file to process",
    )
    parser.add_argument(
        "-e",
        "--rules",
        metavar="FILE",
        dest="rules_file",
        help="file containing matching and replacement rules",
    )
    parser.add_argument(
        "-o",
        "--output",
        metavar="FILE",
        dest="output_file",
        required=True,
        help="name of the output file",
    )
    parser.add_argument(
        "-v",
        "--verbose",
        action="store_true",
        default=False,
        dest="verbose",
        help="enable verbose output",
    )
    parser.add_argument(
        "--chunks",
        dest="chunk_file",
        metavar="FILE",
        help="name of a previously saved chunk file",
    )
    parser.add_argument(
        "--timing-stats",
        dest="timing_stats",
        action="store_true",
        default=False,
        help="print the average time it takes to process regex rules from the rules file"
    )
    parser.add_argument(
        "inputs", metavar="INPUT", nargs="*", help="input files to process"
    )

    return parser


#################
# classes and functions to read the regular expression rules
#################


Rule = namedtuple("Rule", "regex replacement name type")


def read_regex_rules_file(filename):
    """Parses the file containing the regex-based rules that we use to chop
    up the input source files into chunks that can later be fed into a
    DocBook document.

    Parameters:
        filename: name of the input file

    Returns:
        the rules that were parsed from the input file
    """

    rules = []

    def parse_error(lineno):
        """Helper function to indicate a parse error at the given line."""
        fatal(
            "Parse error in regex file ({0}), line {1}".format(regexfile, lineno),
            code = 4
        )

    def store(rule, replacement, rule_name, rule_type):
        """Helper function to append the current rule to the result."""
        regex = re.compile("".join(rule), re.VERBOSE | re.MULTILINE | re.DOTALL)
        replacement = "".join(replacement)[:-1]
        rules.append(Rule(regex, replacement, rule_name, rule_type))

    mode = "empty"
    regex, replacement = [], []
    rule_name, rule_type = None, ""

    try:
        with open(filename, "r") as f:
            for lineno, line in enumerate(f, 1):
                if line.startswith("REPLACE"):
                    # a new pattern block starts
                    if mode not in ("empty", "with"):
                        parse_error(lineno)
                    else:
                        if regex:
                            store(regex, replacement, rule_name, rule_type)
                        regex.clear()
                        replacement.clear()
                        mode = "replace"

                        match = re.match(r"^REPLACE\s+-+\s+(?P.*)\s+-", line)
                        rule_name = match.group("name") if match else None

                elif line.startswith("WITH") or line.startswith("RUN"):
                    # the second half of the pattern block starts
                    if mode != "replace":
                        parse_error(lineno)
                    else:
                        mode = "with"
                    rule_type = "with" if line.startswith("WITH") else "run"

                elif re.match(r"^\s*$", line):
                    # empty line, do nothing
                    pass

                else:
                    # normal line, append
                    if mode == "replace":
                        regex.append(line)
                    elif mode == "with":
                        replacement.append(line)
                    else:
                        parse_error(lineno)

            if regex != "":
                store(regex, replacement, rule_name, rule_type)

    except IOError:
        fatal("Error reading regex file: " + regexfile, code = 4)

    return rules


#################
# parse an input file string
#################
def collect_chunks_from_input_file(strinput, rules, rule_timings):
    result = {}

    # split the file
    chunks = re.split(DOXHEAD, strinput)
    chunks = chunks[1:]

    # apply all rules to the chunks
    for chunk in chunks:
        name = None

        for index, rule in enumerate(rules):
            start = time()

            if not name and "name" in rule.regex.groupindex:
                # The regex might provide us with a chunk name so try figuring
                # out what the "name" group might match to
                matched = rule.regex.search(chunk)
                if matched:
                    try:
                        name = matched.group("name")
                    except IndexError:
                        name = ""

            if rule.type == "with":
                # This is a simple regex replacement rule
                try:
                    chunk = rule.regex.sub(rule.replacement, chunk)
                except IndexError:
                    print("Index error:" + ch[0:60] + "...")
                    print("Pattern:\n" + rule.regex.pattern)
                    print("Current state:" + chunk[0:60] + "...")
                    fatal(code=6)
            elif rule.type == "run":
                # This is a piece of Python code that has to be executed on
                # the part that matched
                matched = rule.regex.search(chunk)
                if matched:
                    exec(rule.replacement)
            else:
                fatal("Invalid rule type: {0!r}".format(rule.type), code=6)

            rule_timings[rule.name].append((time() - start) * 1000000)

        if not name:
            # print("Chunk without a name ignored:" + ch[0:60] + "...")
            continue

        result[name] = chunk.strip()

    return result


@contextmanager
def operation(message):
    """Helper function to show progress messages for a potentially long-running
    operation in verbose mode.

    Parameters:
        message (str): the message to show
    """
    global verbose

    if verbose:
        print(message, end="")

    result = [None]

    def set_result(obj):
        result[0] = obj

    success = False
    try:
        yield set_result
        success = True
    finally:
        if verbose and success:
            if result[0] is None:
                print(" done.")
            else:
                print(" done, {0}.".format(result[0]))


class ChunkCache:
    """Simple on-disk cache that stores SHA256 hashes of files along with the
    DocBook documentation chunks that were parsed from them.
    """

    def __init__(self, filename, hash=sha1):
        """Constructor.

        Parameters:
            filename: name of the file on the disk where the cache resides
            hash: the hash function to use
        """
        self._data = None
        self._dirty = False
        self._hash = hash
        self._path = Path(filename)

    def _load(self):
        """Populates the in-memory copy of the cache from the disk."""
        if self._path.exists():
            try:
                with self._path.open("rb") as fp:
                    self._data = load(fp)
            except (IOError, EOFError):
                # cache corrupted
                self._data = {}
        else:
            self._data = {}
        self._dirty = False

    def close(self):
        """Closes the cache and flushes its contents back to the disk if it
        changed recently.
        """
        if self._dirty:
            self.flush()

    def flush(self):
        """Flushes the contents of the cache back to the disk."""
        with self._path.open("wb") as fp:
            dump(self._data, fp)
        self._dirty = False

    def get(self, key):
        """Returns the chunks associated to the file with the given key, or
        `None` if the key is not in the cache.
        """
        if self._data is None:
            self._load()
        return self._data.get(key)

    def key_of(self, contents, encoding = "utf-8"):
        """Returns the hash key corresponding to the file with the given
        contents.
        """
        if not isinstance(contents, bytes):
            contents = contents.encode("utf-8")

        key = self._hash()
        key.update(contents)
        return key.hexdigest()

    def put(self, key, chunks):
        """Stores some chunks associated to the file with the given key."""
        self._data[key] = chunks
        self._dirty = True


if __name__ == "__main__":
    main()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/dqueue.xxml0000644000175100001710000000145200000000000022623 0ustar00runnerdocker00000000000000

]>



Double-ended queues
















././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/embedding.xxml0000644000175100001710000000077700000000000023262 0ustar00runnerdocker00000000000000

]>


Embedding of graphs


Spectral embedding







././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/error.xxml0000644000175100001710000000504500000000000022466 0ustar00runnerdocker00000000000000

]>


Error handling









































Advanced topics

























































././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/fdl.xml0000644000175100001710000005400200000000000021707 0ustar00runnerdocker00000000000000



  
    Version 1.2, November 2002
    200020012002
    Free Software Foundation, Inc.
      51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
    
    
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.
    
    
  

The GNU Free Documentation License


0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other
functional and useful document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.

This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense.  It
complements the GNU General Public License, which is a copyleft
license designed for free software.

We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does.  But this License is not limited to software manuals;
it can be used for any textual work, regardless of subject matter or
whether it is published as a printed book.  We recommend this License
principally for works whose purpose is instruction or reference.


1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License.  Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein.  The "Document", below,
refers to any such manual or work.  Any member of the public is a
licensee, and is addressed as "you".  You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.

A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall subject
(or to related matters) and contains nothing that could fall directly
within that overall subject.  (Thus, if the Document is in part a
textbook of mathematics, a Secondary Section may not explain any
mathematics.)  The relationship could be a matter of historical
connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding
them.

The "Invariant Sections" are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License.  If a
section does not fit the above definition of Secondary then it is not
allowed to be designated as Invariant.  The Document may contain zero
Invariant Sections.  If the Document does not identify any Invariant
Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License.  A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or
for automatic translation to a variety of formats suitable for input
to text formatters.  A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
of text.  A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
or XML using a publicly available DTD, and standard-conforming simple
HTML, PostScript or PDF designed for human modification.  Examples of
transparent image formats include PNG, XCF and JPG.  Opaque formats
include proprietary formats that can be read and edited only by
proprietary word processors, SGML or XML for which the DTD and/or
processing tools are not generally available, and the
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page.  For works in
formats which do not have any title page as such, "Title Page" means
the text near the most prominent appearance of the work's title,
preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language.  (Here XYZ stands for a
specific section name mentioned below, such as "Acknowledgements",
"Dedications", "Endorsements", or "History".)  To "Preserve the Title"
of such a section when you modify the Document means that it remains a
section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document.  These Warranty
Disclaimers are considered to be included by reference in this
License, but only as regards disclaiming warranties: any other
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.

   
2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no other
conditions whatsoever to those of this License.  You may not use
technical measures to obstruct or control the reading or further
copying of the copies you make or distribute.  However, you may accept
compensation in exchange for copies.  If you distribute a large enough
number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and
you may publicly display copies.

   
3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover.  Both covers must also clearly and legibly identify
you as the publisher of these copies.  The front cover must present
the full title with all words of the title equally prominent and
visible.  You may add other material on the covers in addition.
Copying with changes limited to the covers, as long as they preserve
the title of the Document and satisfy these conditions, can be treated
as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto adjacent
pages.

If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using
public has access to download using public-standard network protocols
a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps,
when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you distribute an
Opaque copy (directly or through your agents or retailers) of that
edition to the public.

It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to give
them a chance to provide you with an updated version of the Document.

   
4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy
of it.  In addition, you must do these things in the Modified Version:

     
     
   Use in the Title Page (and on the covers, if any) a title distinct
   from that of the Document, and from those of previous versions
   (which should, if there were any, be listed in the History section
   of the Document).  You may use the same title as a previous version
   if the original publisher of that version gives permission.
     
   List on the Title Page, as authors, one or more persons or entities
   responsible for authorship of the modifications in the Modified
   Version, together with at least five of the principal authors of the
   Document (all of its principal authors, if it has fewer than five),
   unless they release you from this requirement.
     
   State on the Title page the name of the publisher of the
   Modified Version, as the publisher.
     
   Preserve all the copyright notices of the Document.
     
   Add an appropriate copyright notice for your modifications
   adjacent to the other copyright notices.
     
   Include, immediately after the copyright notices, a license notice
   giving the public permission to use the Modified Version under the
   terms of this License, in the form shown in the Addendum below.
     
   Preserve in that license notice the full lists of Invariant Sections
   and required Cover Texts given in the Document's license notice.
     
   Include an unaltered copy of this License.
     
   Preserve the section Entitled "History", Preserve its Title, and add
   to it an item stating at least the title, year, new authors, and
   publisher of the Modified Version as given on the Title Page.  If
   there is no section Entitled "History" in the Document, create one
   stating the title, year, authors, and publisher of the Document as
   given on its Title Page, then add an item describing the Modified
   Version as stated in the previous sentence.
     
   Preserve the network location, if any, given in the Document for
   public access to a Transparent copy of the Document, and likewise
   the network locations given in the Document for previous versions
   it was based on.  These may be placed in the "History" section.
   You may omit a network location for a work that was published at
   least four years before the Document itself, or if the original
   publisher of the version it refers to gives permission.
     
   For any section Entitled "Acknowledgements" or "Dedications",
   Preserve the Title of the section, and preserve in the section all
   the substance and tone of each of the contributor acknowledgements
   and/or dedications given therein.
     
   Preserve all the Invariant Sections of the Document,
   unaltered in their text and in their titles.  Section numbers
   or the equivalent are not considered part of the section titles.
     
   Delete any section Entitled "Endorsements".  Such a section
   may not be included in the Modified Version.
     
   Do not retitle any existing section to be Entitled "Endorsements"
   or to conflict in title with any Invariant Section.
     
   Preserve any Warranty Disclaimers.
     

If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant.  To do this, add their titles to the
list of Invariant Sections in the Modified Version's license notice.
These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various
parties--for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.

You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list
of Cover Texts in the Modified Version.  Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or
through arrangements made by) any one entity.  If the Document already
includes a cover text for the same cover, previously added by you or
by arrangement made by the same entity you are acting on behalf of,
you may not add another; but you may replace the old one, on explicit
permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.

   
5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and
list them all as Invariant Sections of your combined work in its
license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single
copy.  If there are multiple Invariant Sections with the same name but
different contents, make the title of each such section unique by
adding at the end of it, in parentheses, the name of the original
author or publisher of that section if known, or else a unique number.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History"
in the various original documents, forming one section Entitled
"History"; likewise combine any sections Entitled "Acknowledgements",
and any sections Entitled "Dedications".  You must delete all sections
Entitled "Endorsements".

   
6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this
License in the various documents with a single copy that is included in
the collection, provided that you follow the rules of this License for
verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute
it individually under this License, provided you insert a copy of this
License into the extracted document, and follow this License in all
other respects regarding verbatim copying of that document.

   
7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
distribution medium, is called an "aggregate" if the copyright
resulting from the compilation is not used to limit the legal rights
of the compilation's users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
the entire aggregate, the Document's Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
aggregate.

   
8. TRANSLATION

Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include
translations of some or all Invariant Sections in addition to the
original versions of these Invariant Sections.  You may include a
translation of this License, and all the license notices in the
Document, and any Warranty Disclaimers, provided that you also include
the original English version of this License and the original versions
of those notices and disclaimers.  In case of a disagreement between
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements",
"Dedications", or "History", the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.

   
9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except
as expressly provided for under this License.  Any other attempt to
copy, modify, sublicense or distribute the Document is void, and will
automatically terminate your rights under this License.  However,
parties who have received copies, or rights, from you under this
License will not have their licenses terminated so long as such
parties remain in full compliance.

   
10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions
of the GNU Free Documentation License from time to time.  Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.  See
http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation.  If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation.

   
G.1.1 ADDENDUM: How to use this License for your documents

To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
license notices just after the title page:


    Copyright (c)  YEAR  YOUR NAME.
    Permission is granted to copy, distribute and/or modify this document
    under the terms of the GNU Free Documentation License, Version 1.2
    or any later version published by the Free Software Foundation;
    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
    A copy of the license is included in the section entitled "GNU
    Free Documentation License".


If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
replace the "with...Texts." line with this:


    with the Invariant Sections being LIST THEIR TITLES, with the
    Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.


If you have Invariant Sections without Cover Texts, or some other
combination of the three, merge those two alternatives to suit the
situation.

If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of
free software license, such as the GNU General Public License,
to permit their use in free software.





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/flows.xxml0000644000175100001710000000325200000000000022465 0ustar00runnerdocker00000000000000

]>


Maximum flows, minimum cuts and related measures


Maximum flows








Cuts and minimum cuts











Connectivity








Edge- and vertex-disjoint paths






Graph adhesion and cohesion






Cohesive blocks





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/foreign.xxml0000644000175100001710000000324500000000000022766 0ustar00runnerdocker00000000000000

]>


Reading and writing graphs from and to files




Simple edge list and similar formats












Binary formats





GraphML format






GML format






Pajek format






UCINET's DL file format





Graphviz format





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/generators.xxml0000644000175100001710000000550000000000000023502 0ustar00runnerdocker00000000000000

]>


Graph generators




Deterministic graph generators
























Games: randomized graph generators




































././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/gpl.xml0000644000175100001710000004617700000000000021742 0ustar00runnerdocker00000000000000



  
    Version 2, June 1991
    19891991
     Free Software Foundation, Inc.
       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
    
    
    Everyone is permitted to copy and distribute verbatim copies
    of this license document, but changing it is not allowed.
    
  

THE GNU GENERAL PUBLIC LICENSE

Preamble


  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.



  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.



  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.



  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.



  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.



  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.



  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.



  The precise terms and conditions for copying, distribution and
modification follow.





GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION


  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".



Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.



  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.



You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.



  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:


    You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
  
    You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
  
    If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
  


These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.



Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.



In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.



  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:



    Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)



The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.



If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.



  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.



  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.



  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.



  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.



If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.



It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.



This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.



  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.



  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.



Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.



  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.


                            NO WARRANTY



  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.



  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.



                     END OF TERMS AND CONDITIONS





How to Apply These Terms to Your New Programs


  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.



  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.



    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



Also add information on how to contact you by electronic and paper mail.



If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:



    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.



The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.



You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:



  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice



This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.






././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/graphlets.xxml0000644000175100001710000000112400000000000023320 0ustar00runnerdocker00000000000000

]>


Graphlets








Performing graphlet decomposition







././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/gtk-doc.xsl0000644000175100001710000003024200000000000022500 0ustar00runnerdocker00000000000000 


  
  
  

  
  bibdatabase.xml
  1
  0
  2
  
    book        toc
    chapter     toc
    section     toc
  

  
  
  
  
  
  
  
  
  
  
  
  

  
  

  
  

  
  
  

  
  

  
  

  
    
      
        
        1.36
      
    
    
      
FATAL-ERROR: You need the DocBook XSL Stylesheets version 1.36 or higher
to build the documentation.
Get a newer version at http://docbook.sourceforge.net/projects/xsl/
      
    
    

  

  
  

  
    
      
        
      
      
        
          
        
      
    
  

  
  

  
  

  
    
      

    
    
  

  
    
    
      
    
    
	

      
      
      
        
          
            
              
              
            
          
          
            
          
        
      
  

  
  

  
    
    
    
    

    
      

        

          
            
              
                
                  
                
              
              
              Previous
            
          
          
            
              
                
                  
                
              
              
              Up
            
          
          
            
              
                
                  
                
              
              
              Home
            
          
          
            
              
                
                  
                
              
              
              Next
            
          
        

      

    
  

  
    
    

    
      

        

          
            
              
                
                  
                    
                  
                
                
                  ← 
                  
                
              
            
          
          
            
              
                
                  
                    
                  
                
                
                  
                   →
                
              
            
          
        

      

    
  

  
  

  
  
    
      
        
        1.66
      
    
    
      
    
  

  
    
      
        
        1.66
      
    
    
      
    
  

  
    
      
         

           
 

           
         
 

         

      
      
        
      
    
  

  
    

       
    

  

  
  
    

      

        

         
           
             
               

                
                  
                
              

            
            
              

                
                  
                    
                  
                  
                    
                  
                
              

            
          
          

            
          

        		
        
           
           
           
        

       

     

  

  
    
    

      
    

  


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/heap.xxml0000644000175100001710000000122100000000000022242 0ustar00runnerdocker00000000000000

]>



Maximum and minimum heaps













././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/hrg.xxml0000644000175100001710000000234700000000000022117 0ustar00runnerdocker00000000000000

]>


Hierarchical random graphs








Representing HRGs









Fitting HRGs






HRG sampling






Conversion to and from igraph graphs






Predicting missing edges





././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4271395
igraph-0.9.9/vendor/source/igraph/doc/html/0000755000175100001710000000000000000000000021363 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/html/home.png0000644000175100001710000000121600000000000023021 0ustar00runnerdocker00000000000000‰PNG


IHDRàw=øbKGDÿÿÿ ½§“	pHYsÒÝ~ütIMEÒ1õÚKvIDATxœÕ•±kqÅ?ßrC‡ßàpÃ	~C„np¼¡CAAJ.B-\'G‡]:Ü “‚ƒCÇ
-(ˆ8´àÔ€!…fD°€…çÒ“klbRÛÁoyüxïûîËïwpðIJº<°of_®-@ÒððçRH•´ÏfÖŸtèÂü¤^¯×ÓÚÚš’$Q«ÕÒ|“ôpâ’¶€gív;X^^&Ïs¢(bww—Z­F£ÑÀ9Çææ&Þû3඙
Æ’^IRµZUE.0Z]]Uš¦
ÃPY–Mü8óHÒGIÚÙÙÑìììæeŸkqqñÒ€™!ó 
$ÛÛÛ¬¯¯3Œn
eýþ{-/seeeìÔÃŒãXóóóåO‡Í·$ý8==UÇS™—é½×ÑÑQòRR€¤'ã–9-sÚÛÛ+B^ éC·Û•sîŸÍËÂ+%À°<7³ŸWô˜¿	õâ:™2IEND®B`‚././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/html/left.png0000644000175100001710000000071300000000000023024 0ustar00runnerdocker00000000000000‰PNG


IHDRàw=øbKGDÿÿÿ ½§“	pHYsÒÝ~ütIMEÒ1&¹³[(XIDATxœµ•!OÃPEïÛ*ˆ‰ŠID%~ꊯ˜ÄÕ"pæ'öŘ`sÜ–¥rKf–´‚¤â h—mi—ÇIžz}÷ܯIû¤–.pÚö\“`xä‹ˆl‡?l·[²,H¬‡¯×k<Ï#Žcþ%\’AUx[S³7–n6ù¾¯år¹ßèõzE‰‡’s’žŒ1³ºö“²æÅj@œ—NL$ݤiª0¿5/ð}¿²\E‡Ž¤KIo¥Í“$a0üjÞdF£bŠkIê„‹æAh>ŸW¶lC'?“tk;|/t*I»ÝN«ÕÊZø^`Œy•4ë÷ûšN§r]×® çJÒÌó<«’½À“Út»Ýú€à`±Xàºî1@p´ä€¸d½÷ŽZ')høÖÚK¬	ª$V?%Å]€­+³L’sgUKà"ÿw5â3O·•ÜòIEND®B`‚././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/html/right.png0000644000175100001710000000073000000000000023206 0ustar00runnerdocker00000000000000‰PNG


IHDRàw=øbKGDÿÿÿ ½§“	pHYsÒÝ~ütIMEÒ2I%Á=eIDATxœ­”!oÂ@†Ÿ.'**M0$ÄÁ$¿?1~¢vIeEuLlÉ&–Ô4‚ä Í¶B»Ý›œ¹|÷>ï—ûî …$ݶ©oc<”´ÑA©¤×€X’ò9²|t$DÞ9nnBäíÈjµò‘BRIsIªë:HîŸ8ŽU…œùëùPÖÚN™1fc­sNÎ95M㧖ɵ¤×æŸØŒ1~¸pEòe$ïIž°€Ç	î7nrDòf!;Ã`¨çÝ'äykíÎI’øáû䲤sI_]ÿÇy—‡‘€ÅÀ^^I>O>Á¡ø­§²š?YBIEND®B`‚././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/igraph-docs.xml0000644000175100001710000001116500000000000023345 0ustar00runnerdocker00000000000000







]>



  
    &igraph; Reference Manual
    &version;
    
      GáborCsárdi
      
      Department of Statistics, Harvard University
      
1 Oxford street, Cambridge, MA, 02138 USA

      
      

      TamásNepusz
      
      Department of Biological Physics, Eötvös Loránd University
      
1/a Pázmány Péter sétány, 1117 Budapest, Hungary

      
      

      VincentTraag
      
      Centre for Science and Technology Studies, Leiden University
      
Room B5.31, Kolffpad 1, 2333 BN Leiden, Netherlands

      
      

      SzabolcsHorvát
      
      Center for Systems Biology Dresden, Max Planck Institute for Cell Biology and Genetics
      
Pfotenhauerstr. 108, 01307 Dresden, Germany

      
      

      FabioZanini
      
      Lowy Cancer Research Centre, University of New South Wales
      
Room 211, Botany and High St, Kensington, NSW, 2033, Australia

      
      
    

    
      This manual is for &igraph;, version &version;.

      
      Copyright (C) 2005-2019 Gábor Csárdi and Tamás Nepusz.
      Copyright (C) 2020-2021 igraph development team.
      Permission is granted to copy, distribute and/or modify this document
      under the terms of the GNU Free Documentation License, Version 1.2
      or any later version published by the Free Software Foundation;
      with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
      Texts. A copy of the license is included in the section entitled
      GNU Free Documentation License.
      
    
  

  

  

  

  

  

  

  
    Data structure library: vector, matrix, other data types
    
    
    
    
    
    
    
    
    
    
    
  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  

  
    Advanced igraph programming
    
    
    
  

  

  

  


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/igraph.30000644000175100001710000000322400000000000021756 0ustar00runnerdocker00000000000000.\" Hey, Emacs!  This is an -*- nroff -*- source file.
.\"
.\" Copyright (C) 2006-2021  The igraph development team
.\"
.\" This is free software; you can redistribute it and/or modify it under
.\" the terms of the GNU General Public License as published by the Free
.\" Software Foundation; either version 2, or (at your option) any later
.\" version.
.\"
.\" This is distributed in the hope that it will be useful, but WITHOUT
.\" ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
.\" FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
.\" for more details.
.\"
.\" You should have received a copy of the GNU General Public License with
.\" your Debian GNU/Linux system, in /usr/share/common-licenses/GPL, or with
.\" the dpkg source package as the file COPYING.  If not, write to the Free
.\" Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
.\"
.TH IGRAPH 3 "May 2021" "igraph library"
.SH NAME
igraph \- a library for creating and manipulating graphs
.SH DESCRIPTION
.B igraph
is a library for creating and manipulating graphs.
It is intended to be as powerful (i.e. fast) as possible to enable the
analysis of large graphs.
.SH DOCUMENTATION
The full documentation can be downloaded from the homepage of the
library:
.RI < https://igraph.org/c/doc >
.SH BUGS
If you think you have found a bug in igraph, feel free to file a bug report
in the issue tracker at:
.RI < https://github.com/igraph/igraph/issues >

.SH AUTHORS
Gabor Csardi ,
.br
Tamas Nepusz ,
.br
Vincent Traag ,
.br
Szabolcs Horvat ,
.br
Fabio Zanini 
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4271395
igraph-0.9.9/vendor/source/igraph/doc/igraphlogo/0000755000175100001710000000000000000000000022552 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/igraphlogo/igraph-white.svg.gz0000644000175100001710000001377200000000000026314 0ustar00runnerdocker00000000000000‹cõÌIigraph-white.svgí\]oÇ•}ϯ˜e^b¬Øìú®bDÈ/›,ö1“#j’CG–ä_¿çÜ[Õ]3R´ÄV2lÍœ¾·>nÝïêñë?|¼½Y|¿Ú>¬7w'fO«»ËÍÕúîúâäþú§Ó|²xØ-ï®–7›»ÕÅÉÝæä_ÿæõœž.¾Ù®–»ÕÕâÃz÷nñç»<\.ïW‹ß½ÛíîÏÏÎ>|ø0¬+8l¶×g_-NOÁùðýõo‹¦½{8¿º¼8©ô÷ï·7Bwuy¶ºYÝ®îvgf0g'3ùåL~ÉÉ×߯.7··›»á¼{ømG¼½z;Qs1œ™RÊÙhϬ=Åéç»Ýòãé>+ÖxŒÕŽãx†g3å˨Î Ï{ü;‘7`xؼß^®Þ‚o5Ü­vgü맇§ãpµ»ê†iâÜ›uOÆwËÛÕÃýòrõpÖpáÿ°¾Ú½»8ñã(_ß­Ö×ïv'¶~__]œ`ÅV¾´éÏ'­§Ú˜ý#÷¹®6—\ÅÅÉúz»¼wúáÝz·š<¦6ïw÷ïw[}Ü­ît(¬¿ÛŒ<&Û°·‘=MÝpõñ~³Ý¾]߬tþ³w›ÛÕÙåÃr{µ>ÓÅ÷w×G¹>^ÝãpÊñ!?µ‡_ãéë«ÕÛR©ÔøÍË<šï±ÊûÕ%õSI;ùì>ñ÷IžòbOÄ÷ûù.ÎÁÆÁd3|6G	?)¡æá¯ñ(Í'Éûa,ÞçÏZ—uºÙ®¯×·Kv}²ä.ŒCÊÉ°Bݾ
É™ìŒ2’O“x@W߯WfA~·|XÕ±î—×0ë›Íöâä·oåO}ðÝf{µÚ¶GQþì=Ú@õ×»O³v,×[¨þæfµ]Þ]BîÑôèýújµ÷¬>Ø|÷wlâØ“Y>Xã4Û8}þðnyµù+;|øÃfsØþðÉ%ŽÜç¡„èÝ£gÜWƒẏauïé2Oßß­wpK÷±¿ßnIp³ü´‚ø®­Ûá=¼Û| œ.NÞ.o¦c˜8?¬ï°ÓêCŒí¶R4·RJ|‚‚ýÄ#ʱ©Ìíj·¼Zî–³z4$5[ƒï>ÿï?þéëª~¯//Ïÿw³ýGÓÆÅ‚ËïàG.NN¾žà×W—çð¶·ËÝ×ë[œõ»BK§{Ä4×yPv»R·}4v]]Þ®Étö—ÝúææÏœ¤nK†<«­Û8ëöñú¬íR¾]ÈéfùÝêæâä
Ïo²»ééõvóþþvs…EÉ	ŸÌ²“ïa•~àF/Näã
BøïNc¬±6ºW§.d¸{_ÂWMÔ÷ËÝ»Éí>Ý`Š·hÒÃú‡Õ¹ñþþãïõ;ŸßQˆ7Š|¿Ü®—w»=ìƒ(Éô°Û®v—ï&r;¯–/_N«¥›ßƒtóNr·ªŸU/Ï
VQ›õÝ
29ÿîýn×c߬ïÎq8«mCçqeo—·ë›OçÚ®VYm×oÚÄ{ªë„o[¿]_"ñØÜÍd“„¬¿]‹pbH¯|4ƒóðš‹oÆ@£±¡Á	eL£šàPIC*c2‚…Pœ[¼éÑPã†êâmæDÁÙÅŠ&™ˆ¨¥¯8@Ãè—³.ª¢h¼{,员Á¨Ù—ä,¹£r(·A”Ò3Ò»Á`óÄÂœŒèÓã(Üa(¦®³Có0¦ŠbüTg:Ž¶(Ò<`É)QH‚sY¬Ù+æ°æõ­ÞúÁ»(”Ó>m̘‰Íò¨X/¹7êa:%×Cžø}ŒCÆW+óè*}„” m'+*UE•¥r»›J[p“Ÿòcµ9P°ý sõ)Í‘y»ptMˆ—&µgíópqžã‹ø¬À¹d5g5Ví¨¨jDJíÂI‡Ñ
aãŠAÛÃHî‘ѾqænBé¨QÞ"¼0Ø"@`	Z:hG}«ÜeÈ@P+6(Â2¡\†€ñyØG$oŽCh®ktÈ› ƒÙ
PÖ`d/NÖíFÆfÜ)àSžv])¹ZÌge‡qŒ‚9îZ§ÖȺwU¹‘v#‹~Àãàå!R¨Íï˘Qd6ûBpcc¦Œ£ë)¼S²ŠÁZ“rÃ2‹zG Ì‚®ëŠìh±_ühkwÀÊ †…¬X‚+·`:&ÂÀèãÓh”Ó©ó'9ñåüY$bÄÇ8GcGœö,AßpB3ÆÓð“v”yŠåYrž¼`‘”„å(*<[£@ðX¦Õ¢èDšÇiF£‘˜Ö »©˜žÔ
g¾O‰a <^0Z1#šªÜ¦E* ‰nvBI9ÂoÇŠÁËöãÄUê‘¢Y^Bœsyê¨jVAÄ«¶o\”»@W›ðd±2¬m˃œƒQÌIœ›1Ú­
FTP«Ç‰Ø¨v;Åî°Z}fdœtP-2àä’m:Ä~¬ Œ‡¹;YÆ3˜.1ë)ê‡ü$Kk Aœ)c]§e†å0#‘S@–àæleU2‡=Á¾#<42«Éb§yÈhàĺfì/Êš}m¦Ýè u"øÊÄpªô6iÂTŠÐ3ñ_eLð"Y¯¹‚_EHnøÎRÏ  ×ðô7Á[ñ‰Ð\Ø´ž5WÉ(º!{iÚÓ¡–Q{DŽ3À#qDÈ`8KÑû`s‹êÿP,'¡D&€u¥ŸõV¼>ò•=tÐ}CÈ¥
œN:8Ù7ÎÊË~ÈMÒ¼SטáÅ`û“¦4¼øYf>F³±9
õ”ùh¼úV|/çÖ\„S$	A¤Žµk.Ö³*Ñ]®œûVRŸªQ¬H,¡Œh7Q0¯+²°^;,‰|§h0S:'sG™›§C­Œ2w‹µN¹±ò–ÁâGµc¯»¢m´ä«ÞH¬
â©Â¨:dæøËh
	»Ž’:Íy¬è¶(´»j?V–šá€'N;ñŒ‚b;ˆãâɃƒÅÚSjúÛQ2›Õ@•ÅkäˆYtˆ–³j aT®–Å1ï$çÈ(æà­`VtÕÀcfÕ¡	S¿]%4S"“›Y>f4¢•G´å[	j̦̽¢$‰9¯,„Q0D!µbF#	<æhªMÐ_gå†OA¶‚ÑYÉÇ¡C‚aåšÄ8ﻬ9Áœ{ Š!l”¼Ý‰o
ºrØunž…¯Ùs†HJHˆqÈIžc̉ž§†UîQöè{JÄ&RC¼¯-F¹{èEAòþÆ=Éë`33¦µ‰¯ÙÄ>:eH3?¤;£Ô1O(šZÉ&ŒFÐÜ2Cºß¶Ÿ1ÉÚ‘&œ„lWÑXzø”¤æ¯z±«\C™w2¶ES1Äæ¬ i½Ûâ*loâ6ÌÀHI[ƒqx±Ä¢Ù50è©p¦Ü°?pP²¿­˜•L–"lquåcÕ\äkð®.Ðn’¨VÎ,B1äl^ª÷†Q…YÔÞÅŒ²B3Õ«ÍüÌÊ4.+c!=JÂxoj?¢Y7f“]j7…»$%â$¤ÝÍþ(5çÜA7¥G羉EäMé9tî¦ f!RšÚMA•Æùe{j7…61殥®~t+µ¦vS˜¨gÁJIÒM)µ?Ó0•œöMÞthßM™ùçn
±(+š»)\uf¿›B”òì»)ù[PûnŠEì5£9h×YKof””ˆÈ(í*T³-*ظ§Ó˜ÑÐâã7"Íä)#zzÆ(ð#áÚµ¾…ÐQ‚‘Ýôõ:M¤¦XˆB»§lƒ:?Yã«ÚFĹy‰\)«mÐ{ÊŽð4×LÇrÍX½—™ØMójÁEluª¤­Ì¸¿ÎoÄSd̳OÉjJ1ö;21Änã”Û
°?åf1­ÖÜE¸£Šb-B6l?Bv”8
¯û¦ÝbV´£q3oPmnyRb¦Y„Rd)ž‹4x¸G¾ðHÿ-šÏµÔBùÒR{yJl™Á褸6-TÔHŒÉ†#Ë{¶m€¡¸FIï´saš™0W1F(( äž>Ê™ý8BPÞ1‘7Ç©¬‡šÁtô"‹·dÓ!3t’03ÇÁ*¯™\“ƒëˆ'Eò6¡IÉÂÙê…NW÷Ìäl´Ú,êP(¢õÐ*J~„•Äe4Š€$˜Ã0&'í
ãlÃêŠP÷#B•ŽÒ"{B.&XlTš/²˜¢oF+25N;wEüÚ$ž(ý£²œ[
1ºæsÒâÄ8š!ÛLAV
“-d^a”»+PÎ2\’¶ûYi@Nš3âx}ãE椬0Y!桲_¸‘Ö³Hv£á¼ð7A	³ÜË8)TxBe^ŪÎ1øŠÎu”Á[1i&	g¥«Æ̶¥-lŽ¹ ”†ÁW(,ÛÈVBé1Õ‘gîFIyŠdÙÒ52¢¸}	P}ceî©IÉ]³ñ™œøk6UEBEž|=•»n»‹
Ø”RÕs¢DNK±’tbôCBU°P»U/ճƎï/8áÆQ@aÛ«"Ï5ß™QTõrµ®c6~vÞO³`£=8'ýgÕªµ×jnBë´Ú1I•2‹¹iä$ƒsȪ XrWL¸‘‡ÐX÷)½È2jFnœã€:=íÊ~f”=€jä·¦æo,(³Ì3#Xª•WDcµ]Nø¬~O(KÍê(
ä[²ÇRÎY'
h;ŒÜp4¡ìSòtåÌ8ö,V¡j)ë©QÛÖxtS\¹—Ž1H]0+ýŸ,.Žf§'1Ö~¸Ãé¹H7Å™ö 8Û X[­;”Õ‹Ý&˜rG˜ƒxHÓ	È¢ŽA.iI>E¼ƒ™"ïE¤,½Ô|4v}ÛùqÆ.m˜ìyw‰cm“b§¡ÉJ4Ü0©ãËRqÏN{n2¯†+©[‘fc·f­ùÍþyËÓnZêävY5ü©cMŽÙ‰)yŒ“ýx_c2¹™´ËÚ½öT¨ðRº"‡èã-Nî(yƒ¬¨C˼NwÆgÐXsê:Dòå=‘ýç‘{Yo™°z‡“¹®¾%´Î³…RJRKN¹GéøΘ޵¯QbF%õó˜ÊOÅ4™•31çÅú`=EzÈæä,ƒ”¥ÞpÊ:r·^·Ø³«Y ÷=ùƒÖ½Ñ\hœQ¡ä[@–uÄÇÞäÛ=/SªÓÉpý¡Öð]RÇ®d캾56Y+šhXoT+àÛ=ª³ÚÉbÞ+Öú€´¡<*·Ÿ: .Q†(`{ÊÄ«‰×pÈÊSKlÁ4«j÷±å-¤A§3ݧWLÜF®^ð›žI
;·f>§¦ãÓÌ}å5-Qú1VÎ,gcšk#ìëÐݱ§<=mG©ŽÑv}¹æ!ÔOÇV$ód UÚÍIR|Í'8w‚hÀ—‹ƒŸ°½aŸ J‘žëÅÑ›í_Gl¨æÎNšÈž98r>}­!HYä
ƒ¼—¬}nA{¾çbkз«<ßüƒw……絪ÏÂ;·Ï{tn”3¶â@ŸAçö¹gÊŠ‰„j’+²KÍÜ”×±¿…ÒJ‹Ìƒš"õê›'ž!ÛúâöDàêP§ž’é|äÔçÜŠíBµäbF÷lmâïl1£­IÑÍÔ™Õµ“ˆÒ®ÁÙèC½Ÿëë&ªíp¾#ÑÚ€Pîȡ⡵uèlW"G6Ø£µ9ºwÊs~ÍØóµƒåËšô¥*RhU>´6Ͼ¯R)vI‰”«Ï"+¯WìÐÚ&tn2}ÓñswI®='Åf•Aâ•»»êõcV.µ,‰tÎ)„ͪ©êiUL\&ìs•ºê¥uËlBbìG¼wk±[}ÜY—Ýè®ûÇ×Îä¹Pí~Dp»Üm×'y,Þ¿ñÏüíÔð•ÑH=•N«É¦|5ý cž¤Nc]™¯Ežúµv’¯ºüʲŠHð_õ¿ñèmÃÎ?Zyz–/ã»Xwо"áΧ᰾„…´5÷ÓN8Oiö¨r‡ž¸^•“ÇõlqA¢ð]ŒPD¾A¿å›Ð†/Ke¹N4ò‡ÄÆ5ß?£d˜ÉìX»YÞuA/r‚É	–³II\dƨ
¶(‚¬­2WB8À¥Éý€XmÅ”~j¬Õ”T§žÖh鉡&ý^Ø0-»Ûµb¢ì|~Œ‰½«ŽÒÊ®Žˆ㬼${à»´#‡s¡?(ø\d•(uff¢ì#˜;Ø÷L9ˆ#â@L/Hy‹’yÌžÈ-P¼UŽ†á§û||Ö”âß—uŽò牬ó·! ØƒÄÒJÈƽý3ÐùçVÏØÝñ_E<)lÊCòlÆö=¤¼ú~Þ«I5Gß“‡eƒ‘?±EÿäüãÅ"_nÖøëÜ7ìjùðn¹Ý.?íeÿ“Ÿð$°HyÒ³GB¿)¿Ä1ŒÁ¼r¼f‹c
¸›“â{y/ïÏ•"Ta	ªƒ(I¹1Äf)F-_¿³¼RÇô­‹Aš‘Çþw8å–þ_Êícø*¡å¯Ï™rã«[1ÆYšù9Á=–ê¦ûï/îÀ;1Æ&à_‡^ö“‘²–WŽ×@!¹Çì|Ëù´|™—gÉtŒ´ê(ßÂ^oâ
=k'¤¬Ï9Ìl~¤|õ°Ü>)Û.Jjog=Ú§¢ôÔâ—ËŽèæíÛ‡Õî|ü¼<›@Pc-Æ…á?¼¡L…m‰—Ñÿ‡GK9Z
¡DXG.ö
z,ÖóÕË4îøp¼Fy‡sÊ»•ˆÖ~õ”wg#Ý–´·I”¨!dÇŽ]ûÔ6É$yËèeôGÆ,”½cœ†x^)^@öB{^ag/×v½§¤•>“iÿHOù¯²á#.êŸìÚ~ª0~A‡†”øßêÐøc͈Šï3íi²j»Ž¯iñ…¬Î'¦WӧɡåÂ-å¥ôGÆ¡Csüñœ÷é•aÛÛÇì~¼?›»Rˆ7ÈZWª~;åðQÄ÷êT~9—]ˆOz¹_ƒ¤^x¶?VSþÉ^îHëgöè‘n5Ã.¿V/w¼WÉ»ŠùžãÏ‘5–/Šö³-ãç*šÉ¡ð·û5œ–ðkU´}8ýr‹®`úÉúñSÂéK2ÆgË_Q*ü„*CriŒ¼ŒáëÏ£‡õõÙuw}2™>Öò×kþ?³¾þÍÿG‹ëœ:R././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/igraphlogo/igraph.svg.gz0000644000175100001710000001372500000000000025174 0ustar00runnerdocker00000000000000‹cõÌIigraph.svgí\]oÇ•}ϯ˜¥_b¬Øìú®bDÈ/›,ö1“#j’CG–ä_¿çÜ[Õ]3Q´8V2lÍœ¾·«êÖý®¿üã‡Û›Å«íÃzswqb†ñd±º»Ü\­ï®/Nþç¯ßžæ“ÅÃnywµ¼ÙÜ­.Nî6'üæw/ÿãôtñj»ZîVW‹÷ëÝÛÅŸïþñp¹¼_-~ÿv·»??;{ÿþý°®à°Ù^Ÿ}½8=çÃ׿[,öîáüêòâ¤Òß¿ÛÞÝÕåÙêfu»ºÛ=œ™ÁœÌä—3ù%_ÿ°ºÜÜÞnî„óîá«Žx{õf¢ædÞ;!2¥”³ÑžY{
ŠÓ‡w»å‡Ó}VÌñ«ÇñÏfÊçQ?@ž÷øw"oÀð°y·½\½ßj¸[íÎþô×?MOÇájwÕ½¦‰soÔ=ß-oW÷ËËÕÃYÃ…ÿýúj÷öâÄ£|}»Z_¿Ý]œØú}}uq‚[ùÒ†?Ÿ´bœ>jïìù¸Ïuµ¹ä,.NÖ×ÛåýÛ¡IbâݼÛÝ¿Ûýmõa·ºÓ—`æÝ2ä1Ù†½%ìéèÞWî7ÛÝé›õÍJG>{»¹]]>,·Wë³:û»ë£\®î±-åø+?¶‡ßàéË«Õ›R©¼øÍË<šï1ËûÕ%5SI;Éì>rëöIîïbO¸÷ûÉ.ÎÁÆÁd3|6G	?*¡Îá¯ñ(Í'Éûa,ÞçÏ¿´Nët³]_¯!n—ì0úd=È]‡”“;`…4ºu¸3Øe$Ÿ&pƒ®~X¯ÞÏ‚ü~ù°ªïº_^ào6Û‹“¯ÞÈŸúàûÍöjµm¢üÙ{´Ò¯wgíX,®·PúÍÍj»¼»„Ü)¢éÑ»õÕjïY}°ùþïXı'³|0Çi´q8úüáíòjóöuøðÇÍæ–sô‡.±ã&…Á†Xq]b¤ä†­uÂÞÞÑYž¾»[ïàî?ÓÍòûÕÍÅÉkîßdwÓÓëíæÝýíæ
“’>™e'ßÃ*ýÀ…^œÈÇïߟÆ2Xcmt/N]Èpô¾„¯›¨ï—»·“Û}¼Áo6Ф‡õ«sãýý‡?èw>;¿£oùa¹]/ïv{Ø{Q’=èa·]í.ßNävþÕ(äËiµ´sónþÁAîVõ³êå¹Á,*p³¾[A&çß¿Ûízìï›õÝ96gµmèü^™Ç›åíúæãù·ÛÕê/«íúÍN›xOužðmë7ëK¤›»™lrõwc(Cé…fp^sñja$<úœPÆ4*!ÌÕ˜4¤2&#XŹÅë
e0Îà•@]¢Í(˜!»XÑ$µƒù
£\Î:©Šz yðîY°”GboÍ^°<gÉm•C¹ýˆ¢”~ˆ	”Þ
‹'†àä>Ái†bê<;4cª(ÞŸêHÇÑöŠ4˜2DJ’àXsöŠùì‚9D½G³·~ð.
å´N3fb³<*ÖKîu‡z˜NÉu“'~ãñÕÊ8:K!%HÛÉŒJUGe©ÜnÀ"„ÁܤħüXml?Ã\}JsdžÃ.Ü]âÃåÁŸÉEíYûüº8ñÅ|Ö`_2Œˆ‡½«vTTµ"¥va§Ãh‹°qÅ ía$÷ˆT 6îÀÜM(5ÊÃ[DX€·c[,AË@í(¢o•»hjÅæE@&”Ëð~@öÉ›ãšëÂò&è`v”5Y‹“yû„7c
3n¤0nÌÓª+%g‹ñ¬¬0ŽQ0ÇR«ñÔ™wàª*7ÒÎbd’Áx<°%©9Å«žEì*×PæŒmÑT1‡¹0+$dZﶸ
Û›¸
30RÒÖ`^,±hv
z*Ü‚)7ì”ìo+f%“%†[\ùX5ù¼«´›$ª†™3‹P9›—ê½aT!dµw1£¬ÐLõj3?³2ËÄÊXˆÁ_Ò£°^À›ÚhÖÑd•ÚMá*I‰x	i7E³?JÍ9wÐMéѹobySz
»)ˆYˆ”¦vSP¥q|DYÄžÚMa†MŒ¹k©³]ãÆL­©Ý&êY°R’tSJíÏ4L%§}“×ÚwSfþ¹›B,ÊŒæn
gDÙ殮<ûnŠEþV Ô¾›b{ÍhÚuÖÒÛ„%%"2J»ŠÕl‹Ê#6îi7f4´øøJ¤™CV“æÌ„Ø^ßxQ§9)+LVˆy¨¬n¤õÁ,’Ýh8.üMPÂ,ç2N
€‚„FW±ªs¾¢s¥GðVLšI‚ÁYé¬1²mi›c.¥aðJ#Ó6²”PzLu¤Ä™»QRž"Y¶t¼Qܾ„¨¾±2öÔ¤äªÙøLNü5›Îª"!‹"O¾žÊ]—ÝE¬J©ê9Q"'‰¥XI:±Nú!¡*X¨]‡ª—êÙGcÇûN¸±DPXvŪÈsÍwfU=Ï]ê;?;Y0ƒÑœ“~‰³jÕÚk57!ŠyZ혤J™ÅÜ4r’Á9dU,¹+&ÜÈCh¬û”^dµ#'ÎñL@žö	e=3Ê@5ò[HSó7”YÆ‹,ÕÊ‹3¢±Ú.'|%s‡ßÊR³:Jù–¬±T£sÖ‰Ú#7M(û”Ü]Ù3Ž£=‡Y¨ZÊ|jÔv†5Ýgî¥#ERÌJÿ'‹‹£ÙéNŒµî°{.ÒM±C¦=ÈÎ6ÖæCëåpæb·	¦Üæ Òt²(„cЉKZR£Oï`¦È{)K/5]ßu~œ±K&{Þ]âX[d Øih2
7LªÄø²AܳS瞛̫áJêV¤ÙÄ­OSFym{ÄJç[+´×Ê)6]™¸Ùú®ñµ0Å6N²zöÍó䜭ô½[ÿÏbÀ@wO%7Zä°˜·ÖòÜiŒfM³›»ìêL‰,BàÇ(Z/iêÈ-³t†§á¢e£Õ¼±1ÅŠ¥ Û2×vÜÚBÖ-ñNÞÊœ$ÃÛõµƒ‘À°Ò¸GÈ#4XA‘i&#s/ÌÌ©šã¦É?æÖädä9"@mê…ˆfJX0rÛ+ÈCó´+©¦çRW=ŸMqÞ¶ÄHòÔb¼éã’.—8ð^ĈL3QÓïQÂÓ£lVL;5K
Åwž*5^Q
I¹SM«ñßÁYkl×+™wk¾ùÑï!OyÚIKCœ «†?u¬É1:1å2Žq²ïkL&7“v™»×ž
5^Jgäãb<ÅÉÂ%ouh™çéà®ÃøkŽC]G€H¾¢<'ò¢ÿÜr/sâ)fï°“!×Ù·„Öyö@¢PJéBJ`É)÷(ßÓ³–â5J̨$ ~~§òS1MfåLÌy±>XO‘²9ÙË eA©'œ2O£Ü­×-ölcÅjÈuOþ uo4gT(yh²¾ñ±7ùnÏÆËÔ£ê´F2\¨5v¡¼…4èt¦óôŠ‰ÛÈÕ¾ê)‘¤°skæÒçÔt|¹¯¼¦)J?ÆÊÞðZ+öÆ4×F,Xס»cO9xzÚŽR£íúrÍC¨ŸŽ­HæÎ@«´›“¤øšwpîÑ€/?/`{Ã>A”"=׃£×Ú_Gl¨æÎNšÈž98r>½Ö¤,ò†AÞKÖ>· =¯Å¹XÄôv•çÍ?¨qWXx«ú,¼sû¼GçF9c+6ô	tnŸ{¦¬ÈC5üÐa,^2±¨)×õðòVŠ‡sGRÉÌVÞ(vx-$c±Ýu±†õr{Ý¡ž×ª…Ïüžåf±!ê8Y±QÚÍQfT¬p[éTnÌŽ·ÐJ)!”î*WÁ3ˆÑÈþÚ.@—&ÏžAªM1›ÝTuh”¤^WÉÂUGš çµ¹ÑËœœ\•LкuT;ÀŒ^•Æp+ܦ]¤éõÚ£=š=”aª&¤àn¶ž>¼'bPBjŸDÂ5ÉY¥fnÊëØ_‹Bi¥EæAM‘zõÍÏm}q{	¢pu¨…SOÉt>rj€slÅŠv¡Zr1£{¶6ñw¶Æƒ˜‰ÑÖ¤èfêÌêÚIDiÇàlô¡ÞÏõº‰j;œïˆD´6 ”;ò"T<´¶íJäñÈ{´³6G÷NyÎ׌=¯eL_椗ªH¡UùÐÚ<û¾Ji¤Ø%%RÌ>‹<¬\®Ø¡µMèÜdzÕñsuIŽ='Åf•Aâ•»;êõcV.µ,‰tÎ)„Ū©ê‰iUL\&ìs•ºê¥uËlBbìG¼wj±[}ØY—Ýè®ûÇ×Îä¹Pí~Dp»Üm×~/y,Þ¿ñÏüíÔðÊh¤žJ§ÕdS¾ž~1R‡±®ÌÇ"ŸúµV’¯ºü²ŠHð_÷¿ñè^Ú^;ÿhåÓ+°¼Œïb]AûvŠ„;ì†Ãbx	ikî‡;pÒìQä=q=2*'‡ë/
Øâ‚Dá»= ˆ¼A¿å›Ð†—¥²'¹Äa±qÍûgt,3™k7˳.èEN09Ár6)‰‹Ìxë„Aƒ-Š`k«Ì•0@irÿBÌ6„bJ?4æjJªCOs´ôÄP“~-l˜Ý­Z1Qv^§cb画´r„«oDŒqV.ÉÃx÷ƒväb.ô'Ÿ‹Ì¥®ó‚ÁÌL”Õà
fÆÖ=SÎâ±!¦¤Ü¢d³'rËOU§­aøÀ®Ç~ïõ#¥ød_„€bOH+!÷öߘÎ?·zÂîŽÿ*ⓦ<$ÏalßAÊ«Và½zR–
Fþ4ÆýtiÈ—›5þ:÷
»Z>¼]n·Ë{Iÿ$·O8¢\›ôlÐ]ÊpB0/O×â˜Â#îæ›xï™Rý¥âB`Š#àß).Ô,¥§åeû1Ë:^Ç·IEû_Ý<Wúÿ$.ö`Œá}A˃]Ÿ3ÅÅûY1ÆYˆù)y=æ'ìó×+ÓÀƒ/~ZØ[-‚GF:Z^8ñ„ä³wb-_|á#±2ÕÎ’¼é¾Q¬…íÛÄßz–CÈBŸr†ÙüD±êoþ—ÛOŠ´|xß`‹GûSïc}¾ÈˆnÞ¼yXíÎÇÏ‹±ÉÕÂV+?e·ìÎ&ãž ûÈÿEæO¥ž"ÛòmÕT²Æ>Aöñ)2Ýv÷“wáÅ4ìâ¿Ó‹éÓb\þóÆTØ`xý‘÷ÿøh*Gë”tˆÔØÜ(µc±6˜¯Ÿ§hÇ_Ç‘‘§1§<%‰HFíןrál‰Û’ö‰b3„ìØ{kŸÚ"ùS€$÷…žGäý…²·Ó+žVŠg=SÅžVØÙøÃã*­÷‹ü?VüÄœù±_üW™î‡ôOvd?W¿¾ûBNû«º/þÈ2¢RûŒûú4YµTÇëU¼HÕYÞÄôbú4¹¯<Ø0–ò\ú#ï¦ûrüÑ›÷é…a»ÚÇì~º÷š»Iˆ.È~Z7©~;åçQ|÷âT~ñ–]ˆŸôi¿I=soª¦ü“}Ú‘ÎÓ/¶çÑ!
"§ú­ú´ã­E-äÈ+sŽ¿DFX¾è×/Ö¯tä¿T¿L˜]Ž¿Uýú×ÇÌ_/oèJŸŸ­
?'f>'	|2Wü
e·Ÿð7eH.‘'%¼›<Úx5_ž]wgó—écý ½äÿÐê›ßýkHâÊÑQ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/igraphlogo/igraph2.svg.gz0000644000175100001710000000364000000000000025251 0ustar00runnerdocker00000000000000‹cõÌIigraph2.svgíXÛnÛH}ÏWp™—+Rì»›±kMÛiÇ*6ª³,:›&-»³…›­Êx·¦~O?[±¯wûú7s_›ü4	ÜùÖ¨í°^æÞ`‚ëÔ,+;ÑÉû'd£ƒ¶Ÿ~‡­íLbæd=Ú\}´ˆž›²ìΙûßîá­9‚†>Q$Ðx&“†Ç“!A*à+˜´yX¸’s?Ðœ«ÏOÚnË+Êl•&©pI9Ì™|©${4€Œü¦œ2×™7¨Í-PÍS‚Oz—™Ã€æm\™v¶]¼B¥mŠrá¾]6­â¶(SSvª°ù;SÈƬ>Iá8«ÙXlLç	· õª}–š3]«(n‡Sš!ì±_-ð'õÕ:N‹ÃÂ¥•E±µ£´ÒšãóXŸ ôTP?•äO”Ö=éS”•Èý½%3oŸg5cwÿdø¾,­Á&> Ø|ua¬ÖÅÁâµp—ñ¦G?ôåðÇëÊ›O¼n-ºŠ×Z^°°¹}AeñìRgkê8ëxH“N‚ºÂ³Fÿøðñ¦ÍÅë$‰þU”ŸºÔtkߢ¬®{Ó‹¯Ó$nãú&Û"\–Fÿ
îCÂöŠ3c[»Ã¤§iKs"ÕÉ“%M¶™4ÿ¥Î6›Ÿì"­gÍ”óv£­ó‘×óÎÑæmõªM|k6÷g¼¾{íª,ö»m‘š6¼îßY¸kdwe]¸Íãì;!›¥y”ûŠÒPŠ«êUçÿh,p*³ûw`-gzà3¼y„KŸ0MÄÌ“BúœQ¯ΈgA@úÈ\ïâz=àÜ0$\†ÚÄþÝ! 1’Ï8a¾”JqçGH•/C.{©a–µ„q_hE!¢>ÇÊ!D¡OY(”ÌÀ’!ªRé+)ˆjdJ)!Ӿ¬½LÍ8¥pOÑn
`ª5l'Än…ÐD—Æ^‰–íÒý©ö%
5û-ŠrìõIÆeãµ]GJvf‰½¤1””ÁmjÏPÈfí€1Éìh¢|gÝì’ÙØ52j6Þ`2Èù=XÙ2k‡ð‹œCŽ™h(ø(4X Þá8‚Oc=J‡ª>nïËÔVe&"œïîߟޭ.ÊmEoN’»¸Ìâ¼>“Ò:UuiêdÝËPÄÑÛ ùk^¼öˆÈ{˜ŸLôVM5m_OT¡¯dRCŠµšM–kt»¯ë±ì÷"Ë#°†);é°F³§e¼Í6ÇèciÌ/¦Ì–ï½®î½ÓžqgË,A¿ZäƒÙ˜wÎëk8”Á–­pl$É´ÖûmùÉõrLÍÁ¨ôYï[)BÅ{½ïÍË&ÃWÄ;Yã\-ËøxÚÌc”žPJMª¦ÈE“5ÚùÙ!œø\„‚̘f¨žû”q	Å3¸ýQXÇÂHèoehIÚJZ\销8ö å›„Eþ÷„¯	DCoͲ²°zÍ,5Ë®uõµ€CcóTRñ­ói\g t%tLá’‘iàôÿ.?Ù#Q¨¦eÀ­E¡¯pZ¢ùG,!
nÃ8'SäÀîœq9Úèpi·%‚Ð×nOóîå Xi±\V¦Ž‚ç€êü¥LMV˜½/ŠÊ¥’°I\*,Z¨iƒÒÎÀ}4Z”ÐIƒã´Á)†-•äLÌúEœ¿9½ù¬r‡ØAK µ¦/µŸ˜ÿa´‰ÉFžøƒ"d3‚›¤¦T«ËÉ2=:.à°D/Ñ|¡i£WO)“øLQ-Ïœèt…B×?ëŸ:gðˆÕ/µŸ˜ÿáRˆúÁ—‚ü¬ÁgÓäR¢
)ôf²¿d¼²o|ÊL_¾´&HâÊêëŸI#èë¾"H_È·‹42eÐVPUg•Ñ›Ïú§žF”OE õKí'æÿ,0{cç\ΰ8(Tìe,Òþ*¢k£3h~Þ<ô—EÍf^h[pÅD8Á-ß‘ÏÆíå‘ÿÜ~Ana¸ùãDAñ}pËôoQ”ûZ…¸ùÏЗ¶ÒÿÏ‘gsD²/™#D	ìE…ßGŽ|ÍóçÏ8kGmû«¢ûºóçùèBô]tr8@û’É Ä™A0(h8œ@×óÕéçr|]ÛðoÞü3fäêe././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/installation.xml0000644000175100001710000005315200000000000023650 0ustar00runnerdocker00000000000000

]>


Installation



  Prerequisites
  
    To build igraph from sources, you will need at least:
  
  
    
      
        CMake 3.16 or later
      
    
    
      
        C and C++ compilers
      
    
  
  
    Visual Studio 2015 and later are supported. Earlier Visual Studio
    versions may or may not work.
  
  
    Certain features also require the following libraries:
  
  
    
      
        libxml2,
        required for GraphML support
      
    
  
  
    igraph bundles a number of libraries for convenience. However, it is
    preferable to use external versions of these libraries, which may
    improve performance. These are:
  
  
    
      
        GMP (the bundled
        alternative is Mini-GMP)
      
    
    
      
        GLPK (version 4.57 or later)
      
    
    
      
        ARPACK
      
    
    
      
        CXSparse from
        SuiteSparse
      
    
    
      
        A library providing a
        BLAS API
        (available by default on macOS;
        OpenBLAS is one
        option on other systems)
      
    
    
      
        A library providing a
        LAPACK
        API (available by default on macOS;
        OpenBLAS is one
        option on other systems)
      
    
  
  
    When building the development version of igraph,
    bison, flex and
    git are also required. Released versions do not
    require these tools.
  
  
    To run the tests, diff is also required.
  





  Installation
  

    General build instructions
    
      igraph uses a
      CMake-based
      build system. To compile it,
    
    
      
        
          Enter the directory where the igraph sources are:

$ cd igraph

        
      
      
        
          Create a new directory. This is where igraph will be built:

$ mkdir build
$ cd build

        
      
      
        
          Run CMake, which will automatically configure igraph, and
          report the configuration:

$ cmake ..

          To set a non-default installation location, such as
          /opt/local, use:
          cmake .. -DCMAKE_INSTALL_PREFIX=/opt/local
        
      
      
        
          Check the output carefully, and ensure that all features you
          need are enabled. If CMake could not find certain libraries,
          some features such as GraphML support may have been
          automatically disabled.
        
      
      
        
          There are several ways to adjust the configuration:
        
        
          
            
              Run ccmake . on Unix-like systems or
              cmake-gui on Windows for a convenient
              interface.
            
          
          
            
              Simply edit the CMakeCache.txt file.
              Some of the relevant options are listed below.
            
          
        
      
      
        
          Once the configuration has been adjusted, run
          cmake .. again.
        
      
      
        
          Once igraph has been successfully configured, it can be built,
          tested and installed using:

$ cmake --build .
$ cmake --build . --target check
$ cmake --install .

        
      
    
  


  

    Specific instructions for Windows
    

      Microsoft Visual Studio
      
        With Visual Studio, the steps to build igraph are generally the
        same as above. However, since the Visual Studio CMake generator is
        a multi-configuration one, we must specify the configuration
        (typically Release or Debug) with each build command using the
        --config option:
      

mkdir build
cd build
cmake ..
cmake --build . --config Release
cmake --build . --target check --config Release

      
        When building the development version, bison
        and flex must be available on the system.
        winflexbison
        for Bison version 3.x can be useful for this purpose—make sure
        that the executables are in the system PATH.
        The easiest installation option is probably by installing
        winflexbison3 from the
        Chocolatey
        package manager.
      
      

        vcpkg
        
          Most external dependencies can be conveniently installed using
          vcpkg.
          Note that igraph bundles all dependencies
          except libxml2, which is needed for GraphML
          support.
        
        
          In order to use vcpkg integrate it in the build environment by executing
          vcpkg.exe integrate install on the command line.
          When configuring igraph, point CMake to the correct
          vcpkg.cmake file using -DCMAKE_TOOLCHAIN_FILE=...,
          as instructed.
        
        
          Additionally, it might be that you need to set the appropriate
          so-called triplet using
          -DVCPKG_TARGET_TRIPLET when running
          cmake, for exampling, setting it to
          x64-windows when using shared builds of packages or
          x64-windows-static when using static builds.
          Similarly, you also need to specify this target triplet when
          installing packages. For example, to install
          libxml2 as a shared library, use
          vcpkg.exe install libxml2:x64-windows and to
          install libxml2 as a static library, use
          vcpkg.exe install libxml2:x64-windows-static.
          In addition, there is the possibility to use a static library
          with dynamic runtime linking using the
          x64-windows-static-md triplet.
        
        
          There are some known issues with igraph when using certain external packages
          from vcpkg. When building against OpenBLAS, this results in a few differences
          in some unit tests, see issue
          #1491.
        
      

    

      

      MSYS2
      
        MSYS2 can be installed from msys2.org. After installing MSYS2,
        ensure that it is up to date by opening a terminal and running
        pacman -Syuu.
      
      
        The instructions below assume that you want to compile for a 64-bit
        target.
      
      
        Install the following packages using pacman -S.
      
      
        
          
            Minimal requirements:
            mingw-w64-x86_64-toolchain,
            mingw-w64-x86_64-cmake.
          
        
        
          
            Optional dependencies that enable certain features:
            mingw-w64-x86_64-gmp,
            mingw-w64-x86_64-libxml2
          
        
        
          
            Optional external libraries for better performance:
            mingw-w64-x86_64-openblas,
            mingw-w64-x86_64-suitesparse,
            mingw-w64-x86_64-arpack,
            mingw-w64-x86_64-glpk
          
        
        
          
            Only needed for running the tests: diffutils
          
        
        
          
            Required only when building the development version:
            git, bison,
            flex
          
        
      
      
        The following command will install of these at once:
      

pacman -S \
  mingw-w64-x86_64-toolchain mingw-w64-x86_64-cmake \
  mingw-w64-x86_64-gmp mingw-w64-x86_64-libxml2 \
  mingw-w64-x86_64-openblas mingw-w64-x86_64-suitesparse mingw-w64-x86_64-arpack mingw-w64-x86_64-glpk \
  diffutils \
  git bison flex

      
        In order to build igraph, follow the General
        build instructions above, paying attention to the
        following:
      
      
        
          
            When using MSYS2, start the MSYS2 MinGW 64-bit
            terminal, and not the MSYS2
            MSYS one.
          
        
        
          
            Be sure to install the mingw-w64-x86_64-cmake
            package and not the cmake one. The latter
            will not work.
          
        
        
          
            When running cmake, pass the option
            -G"MSYS Makefiles".
          
        
        
          
            Note that ccmake is not currently available.
            cmake-gui can be used only if the
            mingw-w64-x86_64-qt5 package is installed.
          
        
      
    

  


  

    Notable configuration options
    
      The following options may be set to ON or
      OFF. Some of them have an AUTO
      setting, which chooses a reasonable default based on what libraries
      are available on the current system.
    
    
      
        
          igraph bundles some of its dependencies for convenience. The
          IGRAPH_USE_INTERNAL_XXX flags control whether
          these should be used instead of external versions. Set them to
          ON to use the bundled
          (vendored) versions. Generally, external versions
          are preferable as they may be newer and usually provide better
          performance.
        
      
      
        
          IGRAPH_GLPK_SUPPORT: whether to make use of
          the
          GLPK
          library. Some features, such as finding a minimum feedback arc
          set or finding communities through exact modularity
          optimization, require this.
        
      
      
        
          IGRAPH_GRAPHML_SUPPORT: whether to enable
          support for reading and writing
          GraphML
          files. Requires the
          libxml2 library.
        
      
      
        
          IGRAPH_OPENMP_SUPPORT: whether to use OpenMP
          parallelization to accelerate certain functions such as PageRank
          calculation. Compiler support is required.
        
      
      
        
          IGRAPH_ENABLE_LTO: whether to build igraph
          with link-time optimization, which improves performance. Not
          supported with all compilers.
        
      
      
        
          IGRAPH_ENABLE_TLS: whether to enable
          thread-local storage. Required when using igraph from multiple
          threads.
        
      
      
        
          IGRAPH_WARNINGS_AS_ERRORS: whether to treat
          compiler warnings as errors. We strive to eliminate all compiler
          warnings during development so this switch is turned on by default.
          If your compiler prints warnings for some parts of the code that we
          did not anticipate, you can turn off this option to prevent the
          warnings from stopping the compilation.
        
      
      
        
          BUILD_SHARED_LIBS:
          whether to build a shared library instead of a static one.
        
      
      
        
          BLA_VENDOR: controls which library to use for
          BLAS
          and
          LAPACK
          functionality.
        
      
      
        
          CMAKE_INSTALL_PREFIX:
          the location where igraph will be installed.
        
      
    
  






  Building the documentation
  
    Most users will not need to build the documentation, as the release
    tarball contains pre-built HTML documentation in the doc
    directory.
  
  
    To build the documentation for the development version, simply build
    the html or pdf targets for the
    HTML and PDF versions of the documentation, respectively.
  

$ cmake --build . --target html

  
    Building the HTML documentation requires Python 3, xmlto
    and source-highlight. Building the PDF documentation
    also requires xsltproc, xmllint
    and fop.
  





  Notes for package maintainers
  
    This section is for people who package igraph for Linux distros or
    other package managers. Please read it carefully before packaging
    igraph.
  
  

    Auto-detection of dependencies
    
      igraph bundles several of its dependencies (or simplified versions
      of its dependencies). During configuration time, it checks whether
      each dependency is present on the system. If yes, it uses it.
      Otherwise, it falls back to the bundled (vendored)
      version. In order to make configuration as deterministic as
      possible, you may want to disable this auto-detection. To do so, set
      each of the IGRAPH_USE_INTERNAL_XXX option
      described above. Additionally, set BLA_VENDOR to
      use the BLAS and LAPACK implementations of your choice. This should
      be the same BLAS and LAPACK library that igraph's other dependencies,
      such as ARPACK and CXSparse are linked against.
    
    
      For example, to force igraph to use external versions of all
      dependencies, and to use OpenBLAS for BLAS/LAPACK, use
    
    

$ cmake .. \
    -DIGRAPH_USE_INTERNAL_BLAS=OFF \
    -DIGRAPH_USE_INTERNAL_LAPACK=OFF \
    -DIGRAPH_USE_INTERNAL_ARPACK=OFF \
    -DIGRAPH_USE_INTERNAL_GLPK=OFF \
    -DIGRAPH_USE_INTERNAL_CXSPARSE=OFF \
    -DIGRAPH_USE_INTERNAL_GMP=OFF \
    -DBLA_VENDOR=OpenBLAS \
    -DIGRAPH_GRAPHML_SUPPORT=ON

    
  

  

    Shared and static builds
    
      On Windows, shared and static builds should not be installed in the same
      location. If you decide to do so anyway, keep in mind the following:
      Both builds contain an igraph.lib file. The static one
      should be renamed to avoid conflict. The headers from the static build
      are incompatible with the shared library. The headers from the shared build
      may be used with the static library, but IGRAPH_STATIC
      must be defined when compiling programs that will link to igraph statically.
    
    
      These issues do not affect Unix-like systems.
    
  

  

    Cross-compiling
    
      When building igraph with an internal ARPACK, LAPACK or BLAS, it
      makes use of f2c, which compiles and runs the arithchk
      program at build time to detect the floating point characteristics of the
      current system. It writes the results into the arith.h
      header. Since running this program is not possible when cross-compiling,
      igraph's build system allows specifying a pre-generated version of this
      header file through the F2C_EXTERNAL_ARITH_HEADER
      CMake option. An example version of this header follows for the
      x86_64 and arm64 target architecures on macOS. Warning: Do not use this
      version of arith.h on other systems or architectures.
    
    

#define IEEE_8087
#define Arith_Kind_ASL 1
#define Long int
#define Intcast (int)(long)
#define Double_Align
#define X64_bit_pointers
#define NANCHECK
#define QNaN0 0x0
#define QNaN1 0x7ff80000

    
  

  

    Additional notes
    
      
        
          As of igraph 0.9, there is no tangible benefit to using an
          external GMP, as igraph does not yet use GMP in any
          performance-critical way. The bundled Mini-GMP is sufficient.
        
      
      
        
          Link-time optimization noticeably improves the performance of
          some igraph functions. To enable it, use
          -DIGRAPH_ENABLE_LTO=ON.
          The AUTO setting is also supported, and will
          enable link-time optimization only if the current compiler
          supports it. Note that this is detected by CMake, and the
          detection is not always accurate.
        
      
      
        
          We saw occasional hangs on Windows when igraph was built for a
          32-bit target with MinGW and linked to OpenBLAS. We believe this
          to be an issue with OpenBLAS, not igraph. On this platform, you
          may want to opt for a different BLAS/LAPACK or the bundled
          BLAS/LAPACK.
        
      
    
  





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/introduction.xml0000644000175100001710000001111400000000000023660 0ustar00runnerdocker00000000000000

]>


Introduction


igraph is a library for creating and manipulating graphs.
You can look at it in two ways: first, igraph contains the implementation
of quite a lot of graph algorithms. These include classic graph
algorithms like graph isomorphism, graph girth and connectivity and
also the new wave graph algorithms like transitivity, graph motifs and
community structure detection. Skim through the table of contents
or the index of this book to get an impression of what is available.


Second, igraph provides a platform for developing and/or
implementing graph algorithms. It has an efficient data structure
for representing graphs, and a number of other data structures like
flexible vectors, stacks, heaps, queues, adjacency lists that are useful for implementing graph algorithms. In fact these data structures evolved along with the
implementation of the classic and non-classic graph algorithms which
make up the major part of the igraph library. This way, they were fine-tuned
and checked for correctness several times.



Our main goal with developing igraph was to create a graph library
which is efficient on large, but not extremely large graphs. More
precisely, it is assumed that the graph(s) fit into the physical
memory of the computer. Nowadays this means graphs with
several million vertices and/or edges. Our definition of efficient is
that it runs fast, both in theory and (more importantly) in practice.



We believe that one of the big strengths of igraph is that it can be
embedded into a higher-level language or environment. Three such
embeddings (or interfaces if you look at them another way)
are currently being developed by us: an R
package, a Python extension module, and a Mathematica (Wolfram Language) package. Others are
likely to come. High level languages such as R or Python make it
possible to use graph routines with much greater comfort, without
actually writing a single line of C code. They have some, usually very
small, speed penalty compared to the C version, but add ease of use and much
flexibility. This manual, however, covers only the C library. If you
want to use Python, R or the Wolfram Language, please see the documentation written
specifically for these interfaces and come back here only if you are
interested in some detail which is not covered in those documents.



We still consider igraph as a child project. It has much room for
development and we are sure that it will improve a lot in the near
future. Any feedback we can get from the users is very important for
us, as most of the time these questions and comments guide us in what
to add and what to improve.



igraph is open source and distributed under the terms of the GNU GPL.
We strongly believe that all the algorithms used in science, let that
be graph theory or not, should have an efficient open-source
implementation allowing use and modification for anyone.



&igraph; is free software

    igraph library

    Copyright (C) 2003-2012  Gábor Csardi <csardi.gabor@gmail.com>
    334 Harvard st, Cambridge MA, 02139, USA

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA





Citing &igraph;

To cite &igraph; in publications, please use the following
reference:

Gábor Csárdi, Tamás Nepusz: The igraph software package for complex network
research. InterJournal Complex Systems, 1695, 2006.

The igraph C library is assigned the DOI 10.5281/zenodo.3630268 on Zenodo.






././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/isomorphism.xxml0000644000175100001710000000416000000000000023703 0ustar00runnerdocker00000000000000

]>


Graph isomorphism


The simple interface







The BLISS algorithm











The VF2 algorithm















The LAD algorithm






Functions for graphs with 3 or 4 vertices








Utility functions






././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/iterators.xxml0000644000175100001710000000704400000000000023352 0ustar00runnerdocker00000000000000

]>


Vertex and edge selectors and sequences, iterators








Vertex selector constructors














Generic vertex selector operations









Immediate vertex selectors









Vertex iterators













Edge selector constructors















Immediate edge selectors









Generic edge selector operations










Edge iterators
















././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/layout.xxml0000644000175100001710000000365100000000000022653 0ustar00runnerdocker00000000000000

]>


Generating layouts for graph drawing


2D layout generators








The DrL layout generator





















3D layout generators









Merging layouts





././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4271395
igraph-0.9.9/vendor/source/igraph/doc/licenses/0000755000175100001710000000000000000000000022224 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/Licence_CeCILL-B_V1-en.txt0000644000175100001710000005162100000000000026534 0ustar00runnerdocker00000000000000
CeCILL-B FREE SOFTWARE LICENSE AGREEMENT


    Notice

This Agreement is a Free Software license agreement that is the result
of discussions between its authors in order to ensure compliance with
the two main principles guiding its drafting:

    * firstly, compliance with the principles governing the distribution
      of Free Software: access to source code, broad rights granted to
      users,
    * secondly, the election of a governing law, French law, with which
      it is conformant, both as regards the law of torts and
      intellectual property law, and the protection that it offers to
      both authors and holders of the economic rights over software.

The authors of the CeCILL-B (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre])
license are:

Commissariat à l'Energie Atomique - CEA, a public scientific, technical
and industrial research establishment, having its principal place of
business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.

Centre National de la Recherche Scientifique - CNRS, a public scientific
and technological establishment, having its principal place of business
at 3 rue Michel-Ange, 75794 Paris cedex 16, France.

Institut National de Recherche en Informatique et en Automatique -
INRIA, a public scientific and technological establishment, having its
principal place of business at Domaine de Voluceau, Rocquencourt, BP
105, 78153 Le Chesnay cedex, France.


    Preamble

This Agreement is an open source software license intended to give users
significant freedom to modify and redistribute the software licensed
hereunder.

The exercising of this freedom is conditional upon a strong obligation
of giving credits for everybody that distributes a software
incorporating a software ruled by the current license so as all
contributions to be properly identified and acknowledged.

In consideration of access to the source code and the rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors only have limited liability.

In this respect, the risks associated with loading, using, modifying
and/or developing or reproducing the software by the user are brought to
the user's attention, given its Free Software status, which may make it
complicated to use, with the result that its use is reserved for
developers and experienced professionals having in-depth computer
knowledge. Users are therefore encouraged to load and test the
suitability of the software as regards their requirements in conditions
enabling the security of their systems and/or data to be ensured and,
more generally, to use and operate it in the same conditions of
security. This Agreement may be freely reproduced and published,
provided it is not altered, and that no provisions are either added or
removed herefrom.

This Agreement may apply to any or all software for which the holder of
the economic rights decides to submit the use thereof to its provisions.


    Article 1 - DEFINITIONS

For the purpose of this Agreement, when the following expressions
commence with a capital letter, they shall have the following meaning:

Agreement: means this license agreement, and its possible subsequent
versions and annexes.

Software: means the software in its Object Code and/or Source Code form
and, where applicable, its documentation, "as is" when the Licensee
accepts the Agreement.

Initial Software: means the Software in its Source Code and possibly its
Object Code form and, where applicable, its documentation, "as is" when
it is first distributed under the terms and conditions of the Agreement.

Modified Software: means the Software modified by at least one
Contribution.

Source Code: means all the Software's instructions and program lines to
which access is required so as to modify the Software.

Object Code: means the binary files originating from the compilation of
the Source Code.

Holder: means the holder(s) of the economic rights over the Initial
Software.

Licensee: means the Software user(s) having accepted the Agreement.

Contributor: means a Licensee having made at least one Contribution.

Licensor: means the Holder, or any other individual or legal entity, who
distributes the Software under the Agreement.

Contribution: means any or all modifications, corrections, translations,
adaptations and/or new functions integrated into the Software by any or
all Contributors, as well as any or all Internal Modules.

Module: means a set of sources files including their documentation that
enables supplementary functions or services in addition to those offered
by the Software.

External Module: means any or all Modules, not derived from the
Software, so that this Module and the Software run in separate address
spaces, with one calling the other when they are run.

Internal Module: means any or all Module, connected to the Software so
that they both execute in the same address space.

Parties: mean both the Licensee and the Licensor.

These expressions may be used both in singular and plural form.


    Article 2 - PURPOSE

The purpose of the Agreement is the grant by the Licensor to the
Licensee of a non-exclusive, transferable and worldwide license for the
Software as set forth in Article 5 hereinafter for the whole term of the
protection granted by the rights over said Software.


    Article 3 - ACCEPTANCE

3.1 The Licensee shall be deemed as having accepted the terms and
conditions of this Agreement upon the occurrence of the first of the
following events:

    * (i) loading the Software by any or all means, notably, by
      downloading from a remote server, or by loading from a physical
      medium;
    * (ii) the first time the Licensee exercises any of the rights
      granted hereunder.

3.2 One copy of the Agreement, containing a notice relating to the
characteristics of the Software, to the limited warranty, and to the
fact that its use is restricted to experienced users has been provided
to the Licensee prior to its acceptance as set forth in Article 3.1
hereinabove, and the Licensee hereby acknowledges that it has read and
understood it.


    Article 4 - EFFECTIVE DATE AND TERM


      4.1 EFFECTIVE DATE

The Agreement shall become effective on the date when it is accepted by
the Licensee as set forth in Article 3.1.


      4.2 TERM

The Agreement shall remain in force for the entire legal term of
protection of the economic rights over the Software.


    Article 5 - SCOPE OF RIGHTS GRANTED

The Licensor hereby grants to the Licensee, who accepts, the following
rights over the Software for any or all use, and for the term of the
Agreement, on the basis of the terms and conditions set forth hereinafter.

Besides, if the Licensor owns or comes to own one or more patents
protecting all or part of the functions of the Software or of its
components, the Licensor undertakes not to enforce the rights granted by
these patents against successive Licensees using, exploiting or
modifying the Software. If these patents are transferred, the Licensor
undertakes to have the transferees subscribe to the obligations set
forth in this paragraph.


      5.1 RIGHT OF USE

The Licensee is authorized to use the Software, without any limitation
as to its fields of application, with it being hereinafter specified
that this comprises:

   1. permanent or temporary reproduction of all or part of the Software
      by any or all means and in any or all form.

   2. loading, displaying, running, or storing the Software on any or
      all medium.

   3. entitlement to observe, study or test its operation so as to
      determine the ideas and principles behind any or all constituent
      elements of said Software. This shall apply when the Licensee
      carries out any or all loading, displaying, running, transmission
      or storage operation as regards the Software, that it is entitled
      to carry out hereunder.


      5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS

The right to make Contributions includes the right to translate, adapt,
arrange, or make any or all modifications to the Software, and the right
to reproduce the resulting software.

The Licensee is authorized to make any or all Contributions to the
Software provided that it includes an explicit notice that it is the
author of said Contribution and indicates the date of the creation thereof.


      5.3 RIGHT OF DISTRIBUTION

In particular, the right of distribution includes the right to publish,
transmit and communicate the Software to the general public on any or
all medium, and by any or all means, and the right to market, either in
consideration of a fee, or free of charge, one or more copies of the
Software by any means.

The Licensee is further authorized to distribute copies of the modified
or unmodified Software to third parties according to the terms and
conditions set forth hereinafter.


        5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION

The Licensee is authorized to distribute true copies of the Software in
Source Code or Object Code form, provided that said distribution
complies with all the provisions of the Agreement and is accompanied by:

   1. a copy of the Agreement,

   2. a notice relating to the limitation of both the Licensor's
      warranty and liability as set forth in Articles 8 and 9,

and that, in the event that only the Object Code of the Software is
redistributed, the Licensee allows effective access to the full Source
Code of the Software at a minimum during the entire period of its
distribution of the Software, it being understood that the additional
cost of acquiring the Source Code shall not exceed the cost of
transferring the data.


        5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE

If the Licensee makes any Contribution to the Software, the resulting
Modified Software may be distributed under a license agreement other
than this Agreement subject to compliance with the provisions of Article
5.3.4.


        5.3.3 DISTRIBUTION OF EXTERNAL MODULES

When the Licensee has developed an External Module, the terms and
conditions of this Agreement do not apply to said External Module, that
may be distributed under a separate license agreement.


        5.3.4 CREDITS

Any Licensee who may distribute a Modified Software hereby expressly
agrees to:

   1. indicate in the related documentation that it is based on the
      Software licensed hereunder, and reproduce the intellectual
      property notice for the Software,

   2. ensure that written indications of the Software intended use,
      intellectual property notice and license hereunder are included in
      easily accessible format from the Modified Software interface,

   3. mention, on a freely accessible website describing the Modified
      Software, at least throughout the distribution term thereof, that
      it is based on the Software licensed hereunder, and reproduce the
      Software intellectual property notice,

   4. where it is distributed to a third party that may distribute a
      Modified Software without having to make its source code
      available, make its best efforts to ensure that said third party
      agrees to comply with the obligations set forth in this Article .

If the Software, whether or not modified, is distributed with an
External Module designed for use in connection with the Software, the
Licensee shall submit said External Module to the foregoing obligations.


        5.3.5 COMPATIBILITY WITH THE CeCILL AND CeCILL-C LICENSES

Where a Modified Software contains a Contribution subject to the CeCILL
license, the provisions set forth in Article 5.3.4 shall be optional.

A Modified Software may be distributed under the CeCILL-C license. In
such a case the provisions set forth in Article 5.3.4 shall be optional.


    Article 6 - INTELLECTUAL PROPERTY


      6.1 OVER THE INITIAL SOFTWARE

The Holder owns the economic rights over the Initial Software. Any or
all use of the Initial Software is subject to compliance with the terms
and conditions under which the Holder has elected to distribute its work
and no one shall be entitled to modify the terms and conditions for the
distribution of said Initial Software.

The Holder undertakes that the Initial Software will remain ruled at
least by this Agreement, for the duration set forth in Article 4.2.


      6.2 OVER THE CONTRIBUTIONS

The Licensee who develops a Contribution is the owner of the
intellectual property rights over this Contribution as defined by
applicable law.


      6.3 OVER THE EXTERNAL MODULES

The Licensee who develops an External Module is the owner of the
intellectual property rights over this External Module as defined by
applicable law and is free to choose the type of agreement that shall
govern its distribution.


      6.4 JOINT PROVISIONS

The Licensee expressly undertakes:

   1. not to remove, or modify, in any manner, the intellectual property
      notices attached to the Software;

   2. to reproduce said notices, in an identical manner, in the copies
      of the Software modified or not.

The Licensee undertakes not to directly or indirectly infringe the
intellectual property rights of the Holder and/or Contributors on the
Software and to take, where applicable, vis-à-vis its staff, any and all
measures required to ensure respect of said intellectual property rights
of the Holder and/or Contributors.


    Article 7 - RELATED SERVICES

7.1 Under no circumstances shall the Agreement oblige the Licensor to
provide technical assistance or maintenance services for the Software.

However, the Licensor is entitled to offer this type of services. The
terms and conditions of such technical assistance, and/or such
maintenance, shall be set forth in a separate instrument. Only the
Licensor offering said maintenance and/or technical assistance services
shall incur liability therefor.

7.2 Similarly, any Licensor is entitled to offer to its licensees, under
its sole responsibility, a warranty, that shall only be binding upon
itself, for the redistribution of the Software and/or the Modified
Software, under terms and conditions that it is free to decide. Said
warranty, and the financial terms and conditions of its application,
shall be subject of a separate instrument executed between the Licensor
and the Licensee.


    Article 8 - LIABILITY

8.1 Subject to the provisions of Article 8.2, the Licensee shall be
entitled to claim compensation for any direct loss it may have suffered
from the Software as a result of a fault on the part of the relevant
Licensor, subject to providing evidence thereof.

8.2 The Licensor's liability is limited to the commitments made under
this Agreement and shall not be incurred as a result of in particular:
(i) loss due the Licensee's total or partial failure to fulfill its
obligations, (ii) direct or consequential loss that is suffered by the
Licensee due to the use or performance of the Software, and (iii) more
generally, any consequential loss. In particular the Parties expressly
agree that any or all pecuniary or business loss (i.e. loss of data,
loss of profits, operating loss, loss of customers or orders,
opportunity cost, any disturbance to business activities) or any or all
legal proceedings instituted against the Licensee by a third party,
shall constitute consequential loss and shall not provide entitlement to
any or all compensation from the Licensor.


    Article 9 - WARRANTY

9.1 The Licensee acknowledges that the scientific and technical
state-of-the-art when the Software was distributed did not enable all
possible uses to be tested and verified, nor for the presence of
possible defects to be detected. In this respect, the Licensee's
attention has been drawn to the risks associated with loading, using,
modifying and/or developing and reproducing the Software which are
reserved for experienced users.

The Licensee shall be responsible for verifying, by any or all means,
the suitability of the product for its requirements, its good working
order, and for ensuring that it shall not cause damage to either persons
or properties.

9.2 The Licensor hereby represents, in good faith, that it is entitled
to grant all the rights over the Software (including in particular the
rights set forth in Article 5).

9.3 The Licensee acknowledges that the Software is supplied "as is" by
the Licensor without any other express or tacit warranty, other than
that provided for in Article 9.2 and, in particular, without any warranty
as to its commercial value, its secured, safe, innovative or relevant
nature.

Specifically, the Licensor does not warrant that the Software is free
from any error, that it will operate without interruption, that it will
be compatible with the Licensee's own equipment and software
configuration, nor that it will meet the Licensee's requirements.

9.4 The Licensor does not either expressly or tacitly warrant that the
Software does not infringe any third party intellectual property right
relating to a patent, software or any other property right. Therefore,
the Licensor disclaims any and all liability towards the Licensee
arising out of any or all proceedings for infringement that may be
instituted in respect of the use, modification and redistribution of the
Software. Nevertheless, should such proceedings be instituted against
the Licensee, the Licensor shall provide it with technical and legal
assistance for its defense. Such technical and legal assistance shall be
decided on a case-by-case basis between the relevant Licensor and the
Licensee pursuant to a memorandum of understanding. The Licensor
disclaims any and all liability as regards the Licensee's use of the
name of the Software. No warranty is given as regards the existence of
prior rights over the name of the Software or as regards the existence
of a trademark.


    Article 10 - TERMINATION

10.1 In the event of a breach by the Licensee of its obligations
hereunder, the Licensor may automatically terminate this Agreement
thirty (30) days after notice has been sent to the Licensee and has
remained ineffective.

10.2 A Licensee whose Agreement is terminated shall no longer be
authorized to use, modify or distribute the Software. However, any
licenses that it may have granted prior to termination of the Agreement
shall remain valid subject to their having been granted in compliance
with the terms and conditions hereof.


    Article 11 - MISCELLANEOUS


      11.1 EXCUSABLE EVENTS

Neither Party shall be liable for any or all delay, or failure to
perform the Agreement, that may be attributable to an event of force
majeure, an act of God or an outside cause, such as defective
functioning or interruptions of the electricity or telecommunications
networks, network paralysis following a virus attack, intervention by
government authorities, natural disasters, water damage, earthquakes,
fire, explosions, strikes and labor unrest, war, etc.

11.2 Any failure by either Party, on one or more occasions, to invoke
one or more of the provisions hereof, shall under no circumstances be
interpreted as being a waiver by the interested Party of its right to
invoke said provision(s) subsequently.

11.3 The Agreement cancels and replaces any or all previous agreements,
whether written or oral, between the Parties and having the same
purpose, and constitutes the entirety of the agreement between said
Parties concerning said purpose. No supplement or modification to the
terms and conditions hereof shall be effective as between the Parties
unless it is made in writing and signed by their duly authorized
representatives.

11.4 In the event that one or more of the provisions hereof were to
conflict with a current or future applicable act or legislative text,
said act or legislative text shall prevail, and the Parties shall make
the necessary amendments so as to comply with said act or legislative
text. All other provisions shall remain effective. Similarly, invalidity
of a provision of the Agreement, for any reason whatsoever, shall not
cause the Agreement as a whole to be invalid.


      11.5 LANGUAGE

The Agreement is drafted in both French and English and both versions
are deemed authentic.


    Article 12 - NEW VERSIONS OF THE AGREEMENT

12.1 Any person is authorized to duplicate and distribute copies of this
Agreement.

12.2 So as to ensure coherence, the wording of this Agreement is
protected and may only be modified by the authors of the License, who
reserve the right to periodically publish updates or new versions of the
Agreement, each with a separate number. These subsequent versions may
address new issues encountered by Free Software.

12.3 Any Software distributed under a given version of the Agreement may
only be subsequently distributed under the same version of the Agreement
or a subsequent version.


    Article 13 - GOVERNING LAW AND JURISDICTION

13.1 The Agreement is governed by French law. The Parties agree to
endeavor to seek an amicable solution to any disagreements or disputes
that may arise during the performance of the Agreement.

13.2 Failing an amicable solution within two (2) months as from their
occurrence, and unless emergency proceedings are necessary, the
disagreements or disputes shall be referred to the Paris Courts having
jurisdiction, by the more diligent Party.


Version 1.0 dated 2006-09-05.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/Licence_CeCILL-B_V1-fr.txt0000644000175100001710000005357300000000000026551 0ustar00runnerdocker00000000000000
CONTRAT DE LICENCE DE LOGICIEL LIBRE CeCILL-B


    Avertissement

Ce contrat est une licence de logiciel libre issue d'une concertation
entre ses auteurs afin que le respect de deux grands principes préside à
sa rédaction:

    * d'une part, le respect des principes de diffusion des logiciels
      libres: accès au code source, droits étendus conférés aux
      utilisateurs,
    * d'autre part, la désignation d'un droit applicable, le droit
      français, auquel elle est conforme, tant au regard du droit de la
      responsabilité civile que du droit de la propriété intellectuelle
      et de la protection qu'il offre aux auteurs et titulaires des
      droits patrimoniaux sur un logiciel.

Les auteurs de la licence CeCILL-B (pour Ce[a] C[nrs] I[nria] L[ogiciel]
L[ibre]) sont:

Commissariat à l'Energie Atomique - CEA, établissement public de
recherche à caractère scientifique, technique et industriel, dont le
siège est situé 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris.

Centre National de la Recherche Scientifique - CNRS, établissement
public à caractère scientifique et technologique, dont le siège est
situé 3 rue Michel-Ange, 75794 Paris cedex 16.

Institut National de Recherche en Informatique et en Automatique -
INRIA, établissement public à caractère scientifique et technologique,
dont le siège est situé Domaine de Voluceau, Rocquencourt, BP 105, 78153
Le Chesnay cedex.


    Préambule

Ce contrat est une licence de logiciel libre dont l'objectif est de
conférer aux utilisateurs une très large liberté de modification et de
redistribution du logiciel régi par cette licence.

L'exercice de cette liberté est assorti d'une obligation forte de
citation à la charge de ceux qui distribueraient un logiciel incorporant
un logiciel régi par la présente licence afin d'assurer que les
contributions de tous soient correctement identifiées et reconnues.

L'accessibilité au code source et les droits de copie, de modification
et de redistribution qui découlent de ce contrat ont pour contrepartie
de n'offrir aux utilisateurs qu'une garantie limitée et de ne faire
peser sur l'auteur du logiciel, le titulaire des droits patrimoniaux et
les concédants successifs qu'une responsabilité restreinte.

A cet égard l'attention de l'utilisateur est attirée sur les risques
associés au chargement, à l'utilisation, à la modification et/ou au
développement et à la reproduction du logiciel par l'utilisateur étant
donné sa spécificité de logiciel libre, qui peut le rendre complexe à
manipuler et qui le réserve donc à des développeurs ou des
professionnels avertis possédant des connaissances informatiques
approfondies. Les utilisateurs sont donc invités à charger et tester
l'adéquation du logiciel à leurs besoins dans des conditions permettant
d'assurer la sécurité de leurs systèmes et/ou de leurs données et, plus
généralement, à l'utiliser et l'exploiter dans les mêmes conditions de
sécurité. Ce contrat peut être reproduit et diffusé librement, sous
réserve de le conserver en l'état, sans ajout ni suppression de clauses.

Ce contrat est susceptible de s'appliquer à tout logiciel dont le
titulaire des droits patrimoniaux décide de soumettre l'exploitation aux
dispositions qu'il contient.


    Article 1 - DEFINITIONS

Dans ce contrat, les termes suivants, lorsqu'ils seront écrits avec une
lettre capitale, auront la signification suivante:

Contrat: désigne le présent contrat de licence, ses éventuelles versions
postérieures et annexes.

Logiciel: désigne le logiciel sous sa forme de Code Objet et/ou de Code
Source et le cas échéant sa documentation, dans leur état au moment de
l'acceptation du Contrat par le Licencié.

Logiciel Initial: désigne le Logiciel sous sa forme de Code Source et
éventuellement de Code Objet et le cas échéant sa documentation, dans
leur état au moment de leur première diffusion sous les termes du Contrat.

Logiciel Modifié: désigne le Logiciel modifié par au moins une
Contribution.

Code Source: désigne l'ensemble des instructions et des lignes de
programme du Logiciel et auquel l'accès est nécessaire en vue de
modifier le Logiciel.

Code Objet: désigne les fichiers binaires issus de la compilation du
Code Source.

Titulaire: désigne le ou les détenteurs des droits patrimoniaux d'auteur
sur le Logiciel Initial.

Licencié: désigne le ou les utilisateurs du Logiciel ayant accepté le
Contrat.

Contributeur: désigne le Licencié auteur d'au moins une Contribution.

Concédant: désigne le Titulaire ou toute personne physique ou morale
distribuant le Logiciel sous le Contrat.

Contribution: désigne l'ensemble des modifications, corrections,
traductions, adaptations et/ou nouvelles fonctionnalités intégrées dans
le Logiciel par tout Contributeur, ainsi que tout Module Interne.

Module: désigne un ensemble de fichiers sources y compris leur
documentation qui permet de réaliser des fonctionnalités ou services
supplémentaires à ceux fournis par le Logiciel.

Module Externe: désigne tout Module, non dérivé du Logiciel, tel que ce
Module et le Logiciel s'exécutent dans des espaces d'adressage
différents, l'un appelant l'autre au moment de leur exécution.

Module Interne: désigne tout Module lié au Logiciel de telle sorte
qu'ils s'exécutent dans le même espace d'adressage.

Parties: désigne collectivement le Licencié et le Concédant.

Ces termes s'entendent au singulier comme au pluriel.


    Article 2 - OBJET

Le Contrat a pour objet la concession par le Concédant au Licencié d'une
licence non exclusive, cessible et mondiale du Logiciel telle que
définie ci-après à l'article 5 pour toute la durée de protection des droits
portant sur ce Logiciel.


    Article 3 - ACCEPTATION

3.1 L'acceptation par le Licencié des termes du Contrat est réputée
acquise du fait du premier des faits suivants:

    * (i) le chargement du Logiciel par tout moyen notamment par
      téléchargement à partir d'un serveur distant ou par chargement à
      partir d'un support physique;
    * (ii) le premier exercice par le Licencié de l'un quelconque des
      droits concédés par le Contrat.

3.2 Un exemplaire du Contrat, contenant notamment un avertissement
relatif aux spécificités du Logiciel, à la restriction de garantie et à
la limitation à un usage par des utilisateurs expérimentés a été mis à
disposition du Licencié préalablement à son acceptation telle que
définie à l'article 3.1 ci dessus et le Licencié reconnaît en avoir pris
connaissance.


    Article 4 - ENTREE EN VIGUEUR ET DUREE


      4.1 ENTREE EN VIGUEUR

Le Contrat entre en vigueur à la date de son acceptation par le Licencié
telle que définie en 3.1.


      4.2 DUREE

Le Contrat produira ses effets pendant toute la durée légale de
protection des droits patrimoniaux portant sur le Logiciel.


    Article 5 - ETENDUE DES DROITS CONCEDES

Le Concédant concède au Licencié, qui accepte, les droits suivants sur
le Logiciel pour toutes destinations et pour la durée du Contrat dans
les conditions ci-après détaillées.

Par ailleurs, si le Concédant détient ou venait à détenir un ou
plusieurs brevets d'invention protégeant tout ou partie des
fonctionnalités du Logiciel ou de ses composants, il s'engage à ne pas
opposer les éventuels droits conférés par ces brevets aux Licenciés
successifs qui utiliseraient, exploiteraient ou modifieraient le
Logiciel. En cas de cession de ces brevets, le Concédant s'engage à
faire reprendre les obligations du présent alinéa aux cessionnaires.


      5.1 DROIT D'UTILISATION

Le Licencié est autorisé à utiliser le Logiciel, sans restriction quant
aux domaines d'application, étant ci-après précisé que cela comporte:

   1. la reproduction permanente ou provisoire du Logiciel en tout ou
      partie par tout moyen et sous toute forme.

   2. le chargement, l'affichage, l'exécution, ou le stockage du
      Logiciel sur tout support.

   3. la possibilité d'en observer, d'en étudier, ou d'en tester le
      fonctionnement afin de déterminer les idées et principes qui sont
      à la base de n'importe quel élément de ce Logiciel; et ceci,
      lorsque le Licencié effectue toute opération de chargement,
      d'affichage, d'exécution, de transmission ou de stockage du
      Logiciel qu'il est en droit d'effectuer en vertu du Contrat.


      5.2 DROIT D'APPORTER DES CONTRIBUTIONS

Le droit d'apporter des Contributions comporte le droit de traduire,
d'adapter, d'arranger ou d'apporter toute autre modification au Logiciel
et le droit de reproduire le logiciel en résultant.

Le Licencié est autorisé à apporter toute Contribution au Logiciel sous
réserve de mentionner, de façon explicite, son nom en tant qu'auteur de
cette Contribution et la date de création de celle-ci.


      5.3 DROIT DE DISTRIBUTION

Le droit de distribution comporte notamment le droit de diffuser, de
transmettre et de communiquer le Logiciel au public sur tout support et
par tout moyen ainsi que le droit de mettre sur le marché à titre
onéreux ou gratuit, un ou des exemplaires du Logiciel par tout procédé.

Le Licencié est autorisé à distribuer des copies du Logiciel, modifié ou
non, à des tiers dans les conditions ci-après détaillées.


        5.3.1 DISTRIBUTION DU LOGICIEL SANS MODIFICATION

Le Licencié est autorisé à distribuer des copies conformes du Logiciel,
sous forme de Code Source ou de Code Objet, à condition que cette
distribution respecte les dispositions du Contrat dans leur totalité et
soit accompagnée:

   1. d'un exemplaire du Contrat,

   2. d'un avertissement relatif à la restriction de garantie et de
      responsabilité du Concédant telle que prévue aux articles 8
      et 9,

et que, dans le cas où seul le Code Objet du Logiciel est redistribué,
le Licencié permette un accès effectif au Code Source complet du
Logiciel pendant au moins toute la durée de sa distribution du Logiciel,
étant entendu que le coût additionnel d'acquisition du Code Source ne
devra pas excéder le simple coût de transfert des données.


        5.3.2 DISTRIBUTION DU LOGICIEL MODIFIE

Lorsque le Licencié apporte une Contribution au Logiciel, le Logiciel
Modifié peut être distribué sous un contrat de licence autre que le
présent Contrat sous réserve du respect des dispositions de l'article
5.3.4.


        5.3.3 DISTRIBUTION DES MODULES EXTERNES

Lorsque le Licencié a développé un Module Externe les conditions du
Contrat ne s'appliquent pas à ce Module Externe, qui peut être distribué
sous un contrat de licence différent.


        5.3.4 CITATIONS

Le Licencié qui distribue un Logiciel Modifié s'engage expressément:

   1. à indiquer dans sa documentation qu'il a été réalisé à partir du
      Logiciel régi par le Contrat, en reproduisant les mentions de
      propriété intellectuelle du Logiciel,

   2. à faire en sorte que l'utilisation du Logiciel, ses mentions de
      propriété intellectuelle et le fait qu'il est régi par le Contrat
      soient indiqués dans un texte facilement accessible depuis
      l'interface du Logiciel Modifié,

   3. à mentionner, sur un site Web librement accessible décrivant le
      Logiciel Modifié, et pendant au moins toute la durée de sa
      distribution, qu'il a été réalisé à partir du Logiciel régi par le
      Contrat, en reproduisant les mentions de propriété intellectuelle
      du Logiciel,

   4. lorsqu'il le distribue à un tiers susceptible de distribuer
      lui-même un Logiciel Modifié, sans avoir à en distribuer le code
      source, à faire ses meilleurs efforts pour que les obligations du
      présent article 5.3.4 soient reprises par le dit tiers.

Lorsque le Logiciel modifié ou non est distribué avec un Module Externe
qui a été conçu pour l'utiliser, le Licencié doit soumettre le dit
Module Externe aux obligations précédentes.


        5.3.5 COMPATIBILITE AVEC LES LICENCES CeCILL et CeCILL-C

Lorsqu'un Logiciel Modifié contient une Contribution soumise au contrat
de licence CeCILL, les stipulations prévues à l'article 5.3.4 sont
facultatives.

Un Logiciel Modifié peut être distribué sous le contrat de licence
CeCILL-C. Les stipulations prévues à l'article 5.3.4 sont alors
facultatives.


    Article 6 - PROPRIETE INTELLECTUELLE


      6.1 SUR LE LOGICIEL INITIAL

Le Titulaire est détenteur des droits patrimoniaux sur le Logiciel
Initial. Toute utilisation du Logiciel Initial est soumise au respect
des conditions dans lesquelles le Titulaire a choisi de diffuser son
oeuvre et nul autre n'a la faculté de modifier les conditions de
diffusion de ce Logiciel Initial.

Le Titulaire s'engage à ce que le Logiciel Initial reste au moins régi
par le Contrat et ce, pour la durée visée à l'article 4.2.


      6.2 SUR LES CONTRIBUTIONS

Le Licencié qui a développé une Contribution est titulaire sur celle-ci
des droits de propriété intellectuelle dans les conditions définies par
la législation applicable.


      6.3 SUR LES MODULES EXTERNES

Le Licencié qui a développé un Module Externe est titulaire sur celui-ci
des droits de propriété intellectuelle dans les conditions définies par
la législation applicable et reste libre du choix du contrat régissant
sa diffusion.


      6.4 DISPOSITIONS COMMUNES

Le Licencié s'engage expressément:

   1. à ne pas supprimer ou modifier de quelque manière que ce soit les
      mentions de propriété intellectuelle apposées sur le Logiciel;

   2. à reproduire à l'identique lesdites mentions de propriété
      intellectuelle sur les copies du Logiciel modifié ou non.

Le Licencié s'engage à ne pas porter atteinte, directement ou
indirectement, aux droits de propriété intellectuelle du Titulaire et/ou
des Contributeurs sur le Logiciel et à prendre, le cas échéant, à
l'égard de son personnel toutes les mesures nécessaires pour assurer le
respect des dits droits de propriété intellectuelle du Titulaire et/ou
des Contributeurs.


    Article 7 - SERVICES ASSOCIES

7.1 Le Contrat n'oblige en aucun cas le Concédant à la réalisation de
prestations d'assistance technique ou de maintenance du Logiciel.

Cependant le Concédant reste libre de proposer ce type de services. Les
termes et conditions d'une telle assistance technique et/ou d'une telle
maintenance seront alors déterminés dans un acte séparé. Ces actes de
maintenance et/ou assistance technique n'engageront que la seule
responsabilité du Concédant qui les propose.

7.2 De même, tout Concédant est libre de proposer, sous sa seule
responsabilité, à ses licenciés une garantie, qui n'engagera que lui,
lors de la redistribution du Logiciel et/ou du Logiciel Modifié et ce,
dans les conditions qu'il souhaite. Cette garantie et les modalités
financières de son application feront l'objet d'un acte séparé entre le
Concédant et le Licencié.


    Article 8 - RESPONSABILITE

8.1 Sous réserve des dispositions de l'article 8.2, le Licencié a la
faculté, sous réserve de prouver la faute du Concédant concerné, de
solliciter la réparation du préjudice direct qu'il subirait du fait du
Logiciel et dont il apportera la preuve.

8.2 La responsabilité du Concédant est limitée aux engagements pris en
application du Contrat et ne saurait être engagée en raison notamment:
(i) des dommages dus à l'inexécution, totale ou partielle, de ses
obligations par le Licencié, (ii) des dommages directs ou indirects
découlant de l'utilisation ou des performances du Logiciel subis par le
Licencié et (iii) plus généralement d'un quelconque dommage indirect. En
particulier, les Parties conviennent expressément que tout préjudice
financier ou commercial (par exemple perte de données, perte de
bénéfices, perte d'exploitation, perte de clientèle ou de commandes,
manque à gagner, trouble commercial quelconque) ou toute action dirigée
contre le Licencié par un tiers, constitue un dommage indirect et
n'ouvre pas droit à réparation par le Concédant.


    Article 9 - GARANTIE

9.1 Le Licencié reconnaît que l'état actuel des connaissances
scientifiques et techniques au moment de la mise en circulation du
Logiciel ne permet pas d'en tester et d'en vérifier toutes les
utilisations ni de détecter l'existence d'éventuels défauts. L'attention
du Licencié a été attirée sur ce point sur les risques associés au
chargement, à l'utilisation, la modification et/ou au développement et à
la reproduction du Logiciel qui sont réservés à des utilisateurs avertis.

Il relève de la responsabilité du Licencié de contrôler, par tous
moyens, l'adéquation du produit à ses besoins, son bon fonctionnement et
de s'assurer qu'il ne causera pas de dommages aux personnes et aux biens.

9.2 Le Concédant déclare de bonne foi être en droit de concéder
l'ensemble des droits attachés au Logiciel (comprenant notamment les
droits visés à l'article 5).

9.3 Le Licencié reconnaît que le Logiciel est fourni "en l'état" par le
Concédant sans autre garantie, expresse ou tacite, que celle prévue à
l'article 9.2 et notamment sans aucune garantie sur sa valeur commerciale,
son caractère sécurisé, innovant ou pertinent.

En particulier, le Concédant ne garantit pas que le Logiciel est exempt
d'erreur, qu'il fonctionnera sans interruption, qu'il sera compatible
avec l'équipement du Licencié et sa configuration logicielle ni qu'il
remplira les besoins du Licencié.

9.4 Le Concédant ne garantit pas, de manière expresse ou tacite, que le
Logiciel ne porte pas atteinte à un quelconque droit de propriété
intellectuelle d'un tiers portant sur un brevet, un logiciel ou sur tout
autre droit de propriété. Ainsi, le Concédant exclut toute garantie au
profit du Licencié contre les actions en contrefaçon qui pourraient être
diligentées au titre de l'utilisation, de la modification, et de la
redistribution du Logiciel. Néanmoins, si de telles actions sont
exercées contre le Licencié, le Concédant lui apportera son aide
technique et juridique pour sa défense. Cette aide technique et
juridique est déterminée au cas par cas entre le Concédant concerné et
le Licencié dans le cadre d'un protocole d'accord. Le Concédant dégage
toute responsabilité quant à l'utilisation de la dénomination du
Logiciel par le Licencié. Aucune garantie n'est apportée quant à
l'existence de droits antérieurs sur le nom du Logiciel et sur
l'existence d'une marque.


    Article 10 - RESILIATION

10.1 En cas de manquement par le Licencié aux obligations mises à sa
charge par le Contrat, le Concédant pourra résilier de plein droit le
Contrat trente (30) jours après notification adressée au Licencié et
restée sans effet.

10.2 Le Licencié dont le Contrat est résilié n'est plus autorisé à
utiliser, modifier ou distribuer le Logiciel. Cependant, toutes les
licences qu'il aura concédées antérieurement à la résiliation du Contrat
resteront valides sous réserve qu'elles aient été effectuées en
conformité avec le Contrat.


    Article 11 - DISPOSITIONS DIVERSES


      11.1 CAUSE EXTERIEURE

Aucune des Parties ne sera responsable d'un retard ou d'une défaillance
d'exécution du Contrat qui serait dû à un cas de force majeure, un cas
fortuit ou une cause extérieure, telle que, notamment, le mauvais
fonctionnement ou les interruptions du réseau électrique ou de
télécommunication, la paralysie du réseau liée à une attaque
informatique, l'intervention des autorités gouvernementales, les
catastrophes naturelles, les dégâts des eaux, les tremblements de terre,
le feu, les explosions, les grèves et les conflits sociaux, l'état de
guerre...

11.2 Le fait, par l'une ou l'autre des Parties, d'omettre en une ou
plusieurs occasions de se prévaloir d'une ou plusieurs dispositions du
Contrat, ne pourra en aucun cas impliquer renonciation par la Partie
intéressée à s'en prévaloir ultérieurement.

11.3 Le Contrat annule et remplace toute convention antérieure, écrite
ou orale, entre les Parties sur le même objet et constitue l'accord
entier entre les Parties sur cet objet. Aucune addition ou modification
aux termes du Contrat n'aura d'effet à l'égard des Parties à moins
d'être faite par écrit et signée par leurs représentants dûment habilités.

11.4 Dans l'hypothèse où une ou plusieurs des dispositions du Contrat
s'avèrerait contraire à une loi ou à un texte applicable, existants ou
futurs, cette loi ou ce texte prévaudrait, et les Parties feraient les
amendements nécessaires pour se conformer à cette loi ou à ce texte.
Toutes les autres dispositions resteront en vigueur. De même, la
nullité, pour quelque raison que ce soit, d'une des dispositions du
Contrat ne saurait entraîner la nullité de l'ensemble du Contrat.


      11.5 LANGUE

Le Contrat est rédigé en langue française et en langue anglaise, ces
deux versions faisant également foi.


    Article 12 - NOUVELLES VERSIONS DU CONTRAT

12.1 Toute personne est autorisée à copier et distribuer des copies de
ce Contrat.

12.2 Afin d'en préserver la cohérence, le texte du Contrat est protégé
et ne peut être modifié que par les auteurs de la licence, lesquels se
réservent le droit de publier périodiquement des mises à jour ou de
nouvelles versions du Contrat, qui posséderont chacune un numéro
distinct. Ces versions ultérieures seront susceptibles de prendre en
compte de nouvelles problématiques rencontrées par les logiciels libres.

12.3 Tout Logiciel diffusé sous une version donnée du Contrat ne pourra
faire l'objet d'une diffusion ultérieure que sous la même version du
Contrat ou une version postérieure.


    Article 13 - LOI APPLICABLE ET COMPETENCE TERRITORIALE

13.1 Le Contrat est régi par la loi française. Les Parties conviennent
de tenter de régler à l'amiable les différends ou litiges qui
viendraient à se produire par suite ou à l'occasion du Contrat.

13.2 A défaut d'accord amiable dans un délai de deux (2) mois à compter
de leur survenance et sauf situation relevant d'une procédure d'urgence,
les différends ou litiges seront portés par la Partie la plus diligente
devant les Tribunaux compétents de Paris.


Version 1.0 du 2006-09-05.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/gpl-2.0.txt0000644000175100001710000003556400000000000024061 0ustar00runnerdocker00000000000000                    GNU GENERAL PUBLIC LICENSE
                       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

                    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

                            NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

                     END OF TERMS AND CONDITIONS
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/gpl-3.0.txt0000644000175100001710000007733100000000000024060 0ustar00runnerdocker00000000000000                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. 
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/lgpl-2.1.txt0000644000175100001710000005763600000000000024242 0ustar00runnerdocker00000000000000                  GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999

 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

                  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.

  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

                            NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

                     END OF TERMS AND CONDITIONS
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses/lgpl-3.0.txt0000644000175100001710000001674400000000000024235 0ustar00runnerdocker00000000000000                   GNU LESSER GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. 
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.


  This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.

  0. Additional Definitions.

  As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.

  "The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.

  An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.

  A "Combined Work" is a work produced by combining or linking an
Application with the Library.  The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".

  The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.

  The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.

  1. Exception to Section 3 of the GNU GPL.

  You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.

  2. Conveying Modified Versions.

  If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:

   a) under this License, provided that you make a good faith effort to
   ensure that, in the event an Application does not supply the
   function or data, the facility still operates, and performs
   whatever part of its purpose remains meaningful, or

   b) under the GNU GPL, with none of the additional permissions of
   this License applicable to that copy.

  3. Object Code Incorporating Material from Library Header Files.

  The object code form of an Application may incorporate material from
a header file that is part of the Library.  You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:

   a) Give prominent notice with each copy of the object code that the
   Library is used in it and that the Library and its use are
   covered by this License.

   b) Accompany the object code with a copy of the GNU GPL and this license
   document.

  4. Combined Works.

  You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:

   a) Give prominent notice with each copy of the Combined Work that
   the Library is used in it and that the Library and its use are
   covered by this License.

   b) Accompany the Combined Work with a copy of the GNU GPL and this license
   document.

   c) For a Combined Work that displays copyright notices during
   execution, include the copyright notice for the Library among
   these notices, as well as a reference directing the user to the
   copies of the GNU GPL and this license document.

   d) Do one of the following:

       0) Convey the Minimal Corresponding Source under the terms of this
       License, and the Corresponding Application Code in a form
       suitable for, and under terms that permit, the user to
       recombine or relink the Application with a modified version of
       the Linked Version to produce a modified Combined Work, in the
       manner specified by section 6 of the GNU GPL for conveying
       Corresponding Source.

       1) Use a suitable shared library mechanism for linking with the
       Library.  A suitable mechanism is one that (a) uses at run time
       a copy of the Library already present on the user's computer
       system, and (b) will operate properly with a modified version
       of the Library that is interface-compatible with the Linked
       Version.

   e) Provide Installation Information, but only if you would otherwise
   be required to provide such information under section 6 of the
   GNU GPL, and only to the extent that such information is
   necessary to install and execute a modified version of the
   Combined Work produced by recombining or relinking the
   Application with a modified version of the Linked Version. (If
   you use option 4d0, the Installation Information must accompany
   the Minimal Corresponding Source and Corresponding Application
   Code. If you use option 4d1, you must provide the Installation
   Information in the manner specified by section 6 of the GNU GPL
   for conveying Corresponding Source.)

  5. Combined Libraries.

  You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:

   a) Accompany the combined library with a copy of the same work based
   on the Library, uncombined with any other library facilities,
   conveyed under the terms of this License.

   b) Give prominent notice with the combined library that part of it
   is a work based on the Library, and explaining where to find the
   accompanying uncombined form of the same work.

  6. Revised Versions of the GNU Lesser General Public License.

  The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.

  Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.

  If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/licenses.xml0000644000175100001710000000065600000000000022755 0ustar00runnerdocker00000000000000

]>


Licenses for igraph and this manual

  
  


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/matrix.xxml0000644000175100001710000001020000000000000022626 0ustar00runnerdocker00000000000000

]>



Matrices

















Initializing elements






Copying matrices

















Operations on rows and columns













Matrix operations















Matrix comparisons









Combining matrices






Finding minimum and maximum










Matrix properties












Searching for elements






Resizing operations











././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/memory.xxml0000644000175100001710000000052500000000000022643 0ustar00runnerdocker00000000000000

]>


Memory (de)allocation





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/motifs.xxml0000644000175100001710000000211000000000000022624 0ustar00runnerdocker00000000000000

]>


Graph motifs, dyad census and triad census


This section deals with functions which find small induced subgraphs in a
graph. These were first defined for subgraphs of two and three vertices
by Holland and Leinhardt, and named dyad census and triad census.






Finding triangles






Graph motifs









././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/nongraph.xxml0000644000175100001710000000253500000000000023152 0ustar00runnerdocker00000000000000

]>


Non-graph related functions 


igraph version number





Running mean of a time series





Random sampling from very long sequences





Random sampling of spatial points







Convex hull of a set of points on a plane





Fitting power-law distributions to empirical data






././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/operators.xxml0000644000175100001710000000225700000000000023355 0ustar00runnerdocker00000000000000

]>


Graph operators


Union and intersection










Other set-like operators







Miscellaneous operators










././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/pmt.xml0000644000175100001710000001023300000000000021740 0ustar00runnerdocker00000000000000

]>



About template types

Some of the container types listed in this section are defined for
many base types. This is similar to templates in C++ and generics in
Ada, but it is implemented via preprocessor macros since the C language
cannot handle it. Here is the list of template types and the all base
types they currently support:


vector
  Vector is currently defined for igraph_real_t,
  long int (long), char (char),
  igraph_bool_t (bool). The default is
  igraph_real_t.


matrix
  Matrix is currently defined for igraph_real_t,
  long int (long), char (char),
  igraph_bool_t (bool). The default is
  igraph_real_t.


array3
  Array3 is currently defined for igraph_real_t,
  long int (long), char (char),
  igraph_bool_t (bool). The default is
  igraph_real_t.


stack
  Stack is currently defined for igraph_real_t,
  long int (long), char (char),
  igraph_bool_t (bool). The default is
  igraph_real_t.


double-ended queue
  Dqueue is currently defined for igraph_real_t,
  long int (long), char (char),
  igraph_bool_t (bool). The default is
  igraph_real_t.


heap
  Heap is currently defined for igraph_real_t,
  long int (long), char (char).
  In addition both maximum and minimum heaps are available.
  The default is the igraph_real_t maximum heap.





The name of the base element (in parentheses) is added to the function
names, except for the default type.



Some examples:



  igraph_vector_t is a vector of
  igraph_real_t elements. Its functions are
  igraph_vector_init,
  igraph_vector_destroy,
  igraph_vector_sort, etc.



  igraph_vector_bool_t is a vector of
  igraph_bool_t elements, initialize it with
  igraph_vector_bool_init, destroy it with
  igraph_vector_bool_destroy, etc.



  igraph_heap_t is a maximum heap with
  igraph_real_t elements. The corresponding functions are
  igraph_heap_init,
  igraph_heap_pop, etc.



  igraph_heap_min_t is a minimum heap with
  igraph_real_t elements. The corresponding functions are
  called igraph_heap_min_init,
  igraph_heap_min_pop, etc.



  igraph_heap_long_t is a maximum heap with long
  int elements. Its function have the
  igraph_heap_long_ prefix.



  igraph_heap_min_long_t is a minimum heap containing
  long int elements. Its functions have the
  igraph_heap_min_long_ prefix.






Note that the VECTOR and the MATRIX macros can be used on all
vector and matrix types.




././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/progress.xxml0000644000175100001710000000216700000000000023203 0ustar00runnerdocker00000000000000

]>



Progress handlers








Setting up progress handlers







Invoking the progress handler


























././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/psumtree.xxml0000644000175100001710000000124600000000000023200 0ustar00runnerdocker00000000000000

]>



Partial prefix sum trees












././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/random.xxml0000644000175100001710000000337100000000000022615 0ustar00runnerdocker00000000000000

]>


Random numbers




The default random number generator






Creating random number generators










Generating random numbers











Supported random number generators

By default igraph uses the MT19937 generator. Prior to igraph version
0.6, the generator supplied by the standard C library was used. This
means the GLIBC2 generator on GNU libc 2 systems, and maybe the RAND
generator on others.










././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/scg.xxml0000644000175100001710000000130600000000000022105 0ustar00runnerdocker00000000000000

]>


Spectral coarse graining


Introduction





SCG functions










././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/separators.xxml0000644000175100001710000000102000000000000023505 0ustar00runnerdocker00000000000000

]>


Vertex separators








././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/sparsemat.xxml0000644000175100001710000001106000000000000023326 0ustar00runnerdocker00000000000000

]>



Sparse matrices, another kind








Creating sparse matrix objects











Query properties of a sparse matrix



















Operations on sparse matrices

















Operations on sparse matrix iterators












Operations that change the internal representation






Decompositions and solving linear systems


















Eigenvalues and eigenvectors






Conversion to other data types








Writing to a file, or to the screen






././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/sparsematrix.xxml0000644000175100001710000000406200000000000024055 0ustar00runnerdocker00000000000000

]>



Sparse matrices





































Matrix query operations











Matrix operations








Printing sparse matrices







././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/spatialgames.xxml0000644000175100001710000000137200000000000024006 0ustar00runnerdocker00000000000000

]>


Games on graphs


Microscopic update rules








Epidemic models







././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/stack.xxml0000644000175100001710000000117400000000000022441 0ustar00runnerdocker00000000000000

]>



Stacks













././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/status.xxml0000644000175100001710000000152400000000000022656 0ustar00runnerdocker00000000000000

]>



Status handlers








Setting up status handlers







Invoking the status handler









././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/structural.xxml0000644000175100001710000002115200000000000023542 0ustar00runnerdocker00000000000000

]>


Structural properties of graphs




Basic properties







Efficiency measures







Neighborhood of a vertex







Local scan statistics


"Us" statistics






"Them" statistics






Pre-calculated neighborhoods







Graph components












Degree sequences








Centrality measures



















Range-limited centrality measures








Centralization













Similarity measures













Trees










Transitivity or clustering coefficient








Directedness conversion






Spectral properties





Non-simple graphs: Multiple and loop edges









Mixing patterns







K-Cores





Topological sorting, directed acyclic graphs







Maximum cardinality search and chordal graphs






Matchings







Unfolding a graph into a tree





Other operations













././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/strvector.xxml0000644000175100001710000000157500000000000023374 0ustar00runnerdocker00000000000000

]>



String vectors


















././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/threading.xxml0000644000175100001710000000362600000000000023305 0ustar00runnerdocker00000000000000

]>


Using igraph in multi-threaded programs

  The igraph library is considered thread-safe if it has been compiled
  with thread-local storage enabled, i.e. the IGRAPH_ENABLE_TLS
  setting was toggled to ON and the current platform
  supports this feature. To check whether an igraph build is thread-safe, use the
  
    IGRAPH_THREAD_SAFE
  
  macro. When linking to external versions of igraph's dependencies, it is
  the responsibility of the user to check that these dependencies were also
  compiled to be thread-safe.





Thread-safe ARPACK library

Note that igraph is only thread-safe if it was built with the internal
ARPACK library, i.e. the one that comes with igraph. The standard
ARPACK library is not thread-safe.





Thread-safety of random number generators

The default random number generator that igraph uses is not
guaranteed to be thread-safe. You need to set a different random number generator
instance for every thread that you want to use igraph from. This is especially
important if you set the seed of the random number generator to ensure
reproducibility; sharing a random number generator between threads would break
reproducibility as the order in which the various threads are scheduled is
random, and therefore they would still receive random numbers in an unpredictable
order from the shared random number generator.







././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/tutorial.xml0000644000175100001710000002551000000000000023007 0ustar00runnerdocker00000000000000

]>


Tutorial


Compiling programs using igraph


The following short example program demonstrates the basic usage of
the igraph library.




This example illustrates a couple of points. First, programs
using the igraph library should include the
igraph.h header
file. Second, igraph uses the
igraph_real_t type for real numbers instead of
double. Third, igraph graph objects
are represented by the igraph_t data
type. Fourth, the igraph_erdos_renyi_game()
creates a graph and igraph_destroy()
destroys it, i.e. deallocates the memory associated to it.



For compiling this program you need a C compiler. Optionally,
CMake can be used to automate the compilation.




Compiling with CMake


It is convenient to use CMake because it can automatically discover the
necessary compilation flags on all operating systems. Many IDEs support
CMake, and can work with CMake projects directly. To create a CMake project
for this example program, create a file name CMakeLists.txt with the
following contents:


cmake_minimum_required(VERSION 3.16)
project(igraph_test)

find_package(igraph REQUIRED)

add_executable(igraph_test igraph_test.c)
target_link_libraries(igraph_test PUBLIC igraph::igraph)




To compile the project, create a new directory called build, and switch to it:

mkdir build
cd build




Run CMake to configure the project:

cmake ..




If igraph was installed at a non-standard location, specify its prefix
using the  option. The prefix must be
the same directory that was specified as the 
when compiling igraph.



If configuration has succeeded, build the program using

cmake --build .



C++ has to be enabled in igraph projects
Parts of igraph are implemented in C++; therefore, any CMake target that
depends on igraph should use the C++ linker. Furthermore, OpenMP support in
igraph works correctly only if C++ is enabled in the CMake project. The script
that finds igraph on the host machine will throw an error if C++ support is
not enabled in the CMake project.







Compiling without CMake


On most Unix-like systems, the default C compiler is called cc.
To compile the test program, you will need a command similar to the following:

cc igraph_test.c -I/usr/local/include/igraph -L/usr/local/lib -ligraph -o igraph_test




The exact form depends on where igraph was installed on your
system, whether it was compiled as a shared or static library, and the external
libraries it was linked to. The directory after the  switch
is the one containing the igraph.h file, while the one
following  should contain the library file itself, usually a
file called libigraph.a (static library on macOS and
Linux), libigraph.so (shared library on Linux),
libigraph.dylib (shared library on macOS),
igraph.lib (static library on Windows) or
igraph.dll (shared library on Windows). If
igraph was compiled as a static library, it is also
necessary to manually link to all of its dependencies.



If your system has the pkg-config utility you are
likely to get the necessary compile options by issuing the command

pkg-config --libs --cflags igraph

(if igraph was built as a shared library) or

pkg-config --static --libs --cflags igraph

(if igraph was built as a static library).







Running the program


On most systems, the executable can be run by simply typing its name like this:

./igraph_test

If you use dynamic linking and the igraph
library is not in a standard place, you may need to add its location to the
LD_LIBRARY_PATH (Linux), DYLD_LIBRARY_PATH (macOS)
or PATH (Windows) environment variables.








Creating your first graphs


The functions generating graph objects are called graph
generators. Stochastic (i.e. randomized) graph generators are called
games.



igraph can handle directed and undirected graphs. Most graph
generators are able to create both types of graphs and most other
functions are usually also capable of handling
both. E.g. igraph_shortest_paths()
which (surprisingly) calculates
shortest paths from a vertex to other vertices can calculate
directed or undirected paths.



igraph has sophisticated ways for creating graphs. The simplest
graphs are deterministic regular structures like star graphs
(igraph_star()),
ring graphs (igraph_ring()), lattices
(igraph_lattice()) or trees
(igraph_tree()).



The following example creates an undirected regular circular lattice,
adds some random edges to it and calculates the average length of
shortest paths between all pairs of vertices in the graph before and
after adding the random edges. (The message is that some random edges
can reduce path lengths a lot.)




This example illustrates some new points. igraph uses
igraph_vector_t
instead of plain C arrays. igraph_vector_t is superior to
regular arrays in almost every sense. Vectors are created by the
igraph_vector_init()
function and, like graphs, they should be destroyed if not
needed any more by calling
igraph_vector_destroy()
on them. A vector can be indexed by the
VECTOR() function
(right now it is a macro). Vectors
can be resized, e.g. most igraph functions returning the result in a
vector resize it to the size of the result.



igraph_lattice()
takes a vector argument specifying the dimensions of
the lattice. In this example we generate a 30x30 two dimensional
lattice. See the documentation of
igraph_lattice() in
the reference manual for the other arguments.



The vertices in a graph are identified by an integer number between
0 and N-1, N is the number of vertices in the graph (this can be
obtained by
igraph_vcount(),
as in the example).



The igraph_add_edges()
function simply takes a graph and a vector of
vertex ids defining the new edges. The first edge is between the first
two vertex ids in the vector, the second edge is between the second
two, etc. This way we add ten random edges to the lattice.



Note that in the example it is possible to add loop edges, edges
pointing to the same vertex and multiple edges, more than one edge
between the same pair of vertices.
igraph_t can of course
represent loops and
multiple edges, although some routines expect simple graphs,
i.e. graphs without loop and multiple edges, because for example some
structural properties are ill-defined for non-simple graphs. Loop
edges can be removed by calling
igraph_simplify().





Calculating various properties of graphs

In our next example we will calculate various centrality measures in a
friendship graph. The friendship graph is from the famous Zachary karate
club study. (Web search on 'Zachary karate' if you want to know more about
this.) Centrality measures quantify how central is the position of
individual vertices in the graph.




This example reflects some new features. First of all, it shows a
way to define a graph simply as defining a C array with its edges.
Function igraph_vector_view()
creates a view of a C
array. It does not copy any data, this also means that you should not
call igraph_vector_destroy()
on a vector created this way. This vector is then used to create the
undirected graph.



Then the degree, closeness and betweenness centrality of the vertices
is calculated and the highest values are printed. Note that the vector
(result) which returns the result from these
functions has to be initialized first, and also that the functions resize
it to be able to hold the result.



The igraph_vss_all() argument tells the functions to
calculate the property for every vertex in the graph, it is shorthand
for a vertex selector (igraph_vs_t).
Vertex selectors help to perform operations on a subset of vertices,
you can read more about them in one
of the following chapters.





././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/vector.xxml0000644000175100001710000001276200000000000022643 0ustar00runnerdocker00000000000000

]>



Vectors



















Initializing elements

















Vector views





Copying vectors








Exchanging elements







Vector operations











Vector comparisons











Finding minimum and maximum










Vector properties














Searching for elements









Resizing operations













Sorting






Set operations on sorted vectors





























././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/version-greater-or-equal.xsl0000644000175100001710000000322000000000000026003 0ustar00runnerdocker00000000000000 

 
  
  
  
    
      
        
      
      
        
      
    
  
  
    
      
        
      
      
        
      
    
  
  
    
      1
    
    
      0
    
    
      
        
          
            
            
          
	
        
	   0
	
	
	   1
	
      
    
  


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/doc/visitors.xxml0000644000175100001710000000141500000000000023214 0ustar00runnerdocker00000000000000

]>


Graph visitors






Random walks






././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392
igraph-0.9.9/vendor/source/igraph/etc/0000755000175100001710000000000000000000000020425 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4311397
igraph-0.9.9/vendor/source/igraph/etc/cmake/0000755000175100001710000000000000000000000021505 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/BuildType.cmake0000644000175100001710000000115300000000000024410 0ustar00runnerdocker00000000000000# Taken from https://blog.kitware.com/cmake-and-the-default-build-type/

# Set the default build type to "Release"
set(default_build_type "Release")

get_property(isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(NOT isMultiConfig AND NOT CMAKE_BUILD_TYPE)
  message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
  set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE STRING "Choose the type of build." FORCE)
  # Set the possible values of build type for cmake-gui
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/CTestCustom.cmake.in0000644000175100001710000000024200000000000025327 0ustar00runnerdocker00000000000000# Ask CTest to run the build_tests target before running the tests
set(CTEST_CUSTOM_PRE_TEST "@CMAKE_COMMAND@ --build @PROJECT_BINARY_DIR@ --target build_tests")
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/CheckTLSSupport.cmake0000644000175100001710000000174700000000000025515 0ustar00runnerdocker00000000000000include(CheckCSourceCompiles)

macro(check_tls_support VAR)
  if(NOT DEFINED "${VAR}")
    set(CMAKE_REQUIRED_QUIET 1)

    check_c_source_compiles("
    __thread int tls;

    int main(void) {
        return 0;
    }" HAVE_GCC_TLS)

    if(HAVE_GCC_TLS)
      message(STATUS "Thread-local storage: supported (__thread)")
      set(${VAR} "__thread" CACHE INTERNAL "Thread-local storage support keyword in compiler")
    else()
      check_c_source_compiles("
      __declspec(thread) int tls;

      int main(void) {
          return 0;
      }" HAVE_MSVC_TLS)
      if(HAVE_MSVC_TLS)
        message(STATUS "Thread-local storage: supported (__declspec(thread))")
        set(${VAR} "__declspec(thread)" CACHE INTERNAL "Thread-local storage keyword in compiler")
      else()
        message(STATUS "Thread-local storage: not supported")
        set(${VAR} "" CACHE INTERNAL "Thread-local storage keyword in compiler")
      endif()
    endif()
    set(CMAKE_REQUIRED_QUIET 0)
  endif()
endmacro()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/CodeCoverage.cmake0000644000175100001710000006660400000000000025051 0ustar00runnerdocker00000000000000# Copyright (c) 2012 - 2017, Lars Bilke
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
#    list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
#    this list of conditions and the following disclaimer in the documentation
#    and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
#    may be used to endorse or promote products derived from this software without
#    specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# CHANGES:
#
# 2012-01-31, Lars Bilke
# - Enable Code Coverage
#
# 2013-09-17, Joakim Söderberg
# - Added support for Clang.
# - Some additional usage instructions.
#
# 2016-02-03, Lars Bilke
# - Refactored functions to use named parameters
#
# 2017-06-02, Lars Bilke
# - Merged with modified version from github.com/ufz/ogs
#
# 2019-05-06, Anatolii Kurotych
# - Remove unnecessary --coverage flag
#
# 2019-12-13, FeRD (Frank Dana)
# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
# - Set lcov basedir with -b argument
# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
# - Delete output dir, .info file on 'make clean'
# - Remove Python detection, since version mismatches will break gcovr
# - Minor cleanup (lowercase function names, update examples...)
#
# 2019-12-19, FeRD (Frank Dana)
# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
#
# 2020-01-19, Bob Apthorpe
# - Added gfortran support
#
# 2020-02-17, FeRD (Frank Dana)
# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
#   in EXCLUDEs, and remove manual escaping from gcovr targets
#
# 2021-01-19, Robin Mueller
# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
#   flags to the gcovr command
#
# 2020-05-04, Mihchael Davis
#     - Add -fprofile-abs-path to make gcno files contain absolute paths
#     - Fix BASE_DIRECTORY not working when defined
#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
# USAGE:
#
# 1. Copy this file into your cmake modules path.
#
# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
#    using a CMake option() to enable it just optionally):
#      include(CodeCoverage)
#
# 3. Append necessary compiler flags:
#      append_coverage_compiler_flags()
#
# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
#
# 4. If you need to exclude additional directories from the report, specify them
#    using full paths in the COVERAGE_EXCLUDES variable before calling
#    setup_target_for_coverage_*().
#    Example:
#      set(COVERAGE_EXCLUDES
#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
#          '/path/to/my/src/dir2/*')
#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
#    Example:
#      setup_target_for_coverage_lcov(
#          NAME coverage
#          EXECUTABLE testrunner
#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
#
# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
#     Example:
#       set(COVERAGE_EXCLUDES "dir1/*")
#       setup_target_for_coverage_gcovr_html(
#           NAME coverage
#           EXECUTABLE testrunner
#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
#           EXCLUDE "dir2/*")
#
# 5. Use the functions described below to create a custom make target which
#    runs your test executable and produces a code coverage report.
#
# 6. Build a Debug build:
#      cmake -DCMAKE_BUILD_TYPE=Debug ..
#      make
#      make my_coverage_target
#

include(CMakeParseArguments)

option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)

# Check prereqs
find_program( GCOV_PATH gcov )
find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
find_program( CPPFILT_PATH NAMES c++filt )

if(NOT GCOV_PATH)
    message(FATAL_ERROR "gcov not found! Aborting...")
endif() # NOT GCOV_PATH

get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
list(GET LANGUAGES 0 LANG)

if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
    endif()
elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
    if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "[Ff]lang")
        # Do nothing; exit conditional without error if true
    elseif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
        # Do nothing; exit conditional without error if true
    else()
        message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
    endif()
endif()

set(COVERAGE_COMPILER_FLAGS "-g -fprofile-arcs -ftest-coverage"
    CACHE INTERNAL "")
if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
    include(CheckCXXCompilerFlag)
    check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path)
    if(HAVE_fprofile_abs_path)
        set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
    endif()
endif()

set(CMAKE_Fortran_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
    FORCE )
set(CMAKE_CXX_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the C++ compiler during coverage builds."
    FORCE )
set(CMAKE_C_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the C compiler during coverage builds."
    FORCE )
set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
    ""
    CACHE STRING "Flags used for linking binaries during coverage builds."
    FORCE )
set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
    ""
    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
    FORCE )
mark_as_advanced(
    CMAKE_Fortran_FLAGS_COVERAGE
    CMAKE_CXX_FLAGS_COVERAGE
    CMAKE_C_FLAGS_COVERAGE
    CMAKE_EXE_LINKER_FLAGS_COVERAGE
    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )

if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"

if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
    link_libraries(gcov)
endif()

# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
# setup_target_for_coverage_lcov(
#     NAME testrunner_coverage                    # New target name
#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
#     DEPENDENCIES testrunner                     # Dependencies to build first
#     BASE_DIRECTORY "../"                        # Base directory for report
#                                                 #  (defaults to PROJECT_SOURCE_DIR)
#     EXCLUDE "src/dir1/*" "src/dir2/*"           # Patterns to exclude (can be relative
#                                                 #  to BASE_DIRECTORY, with CMake 3.4+)
#     NO_DEMANGLE                                 # Don't demangle C++ symbols
#                                                 #  even if c++filt is found
# )
function(setup_target_for_coverage_lcov)

    set(options NO_DEMANGLE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    if(NOT LCOV_PATH)
        message(FATAL_ERROR "lcov not found! Aborting...")
    endif() # NOT LCOV_PATH

    if(NOT GENHTML_PATH)
        message(FATAL_ERROR "genhtml not found! Aborting...")
    endif() # NOT GENHTML_PATH

    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()

    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(LCOV_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND LCOV_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES LCOV_EXCLUDES)

    # Conditional arguments
    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
      set(GENHTML_EXTRA_ARGS "--demangle-cpp")
    endif()

    # Setting up commands which will be run to generate coverage data.
    # Cleanup lcov
    set(LCOV_CLEAN_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory .
        -b ${BASEDIR} --zerocounters
    )
    # Create baseline to make sure untouched files show up in the report
    set(LCOV_BASELINE_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -b
        ${BASEDIR} -o ${Coverage_NAME}.base
    )
    # Run tests
    set(LCOV_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Capturing lcov counters and generating report
    set(LCOV_CAPTURE_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . -b
        ${BASEDIR} --capture --output-file ${Coverage_NAME}.capture
    )
    # add baseline counters
    set(LCOV_BASELINE_COUNT_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base
        -a ${Coverage_NAME}.capture --output-file ${Coverage_NAME}.total
    )
    # filter collected data to final coverage report
    set(LCOV_FILTER_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove
        ${Coverage_NAME}.total ${LCOV_EXCLUDES} --output-file ${Coverage_NAME}.info
    )
    # Generate HTML output
    set(LCOV_GEN_HTML_CMD
        ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o
        ${Coverage_NAME} ${Coverage_NAME}.info
    )


    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")
        message(STATUS "Command to clean up lcov: ")
        string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}")
        message(STATUS "${LCOV_CLEAN_CMD_SPACED}")

        message(STATUS "Command to create baseline: ")
        string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}")
        message(STATUS "${LCOV_BASELINE_CMD_SPACED}")

        message(STATUS "Command to run the tests: ")
        string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}")
        message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}")

        message(STATUS "Command to capture counters and generate report: ")
        string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}")
        message(STATUS "${LCOV_CAPTURE_CMD_SPACED}")

        message(STATUS "Command to add baseline counters: ")
        string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}")
        message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}")

        message(STATUS "Command to filter collected data: ")
        string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}")
        message(STATUS "${LCOV_FILTER_CMD_SPACED}")

        message(STATUS "Command to generate lcov HTML output: ")
        string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}")
        message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}")
    endif()

    # Setup target
    add_custom_target(${Coverage_NAME}
        COMMAND ${LCOV_CLEAN_CMD}
        COMMAND ${LCOV_BASELINE_CMD}
        COMMAND ${LCOV_EXEC_TESTS_CMD}
        COMMAND ${LCOV_CAPTURE_CMD}
        COMMAND ${LCOV_BASELINE_COUNT_CMD}
        COMMAND ${LCOV_FILTER_CMD}
        COMMAND ${LCOV_GEN_HTML_CMD}

        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
            ${Coverage_NAME}.base
            ${Coverage_NAME}.capture
            ${Coverage_NAME}.total
            ${Coverage_NAME}.info
            ${Coverage_NAME}/index.html
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
    )

    # Show where to find the lcov info report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
    )

    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )

endfunction() # setup_target_for_coverage_lcov

# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
# setup_target_for_coverage_gcovr_xml(
#     NAME ctest_coverage                    # New target name
#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
#     DEPENDENCIES executable_target         # Dependencies to build first
#     BASE_DIRECTORY "../"                   # Base directory for report
#                                            #  (defaults to PROJECT_SOURCE_DIR)
#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
# )
# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
# GCVOR command.
function(setup_target_for_coverage_gcovr_xml)

    set(options NONE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    if(NOT GCOVR_PATH)
        message(FATAL_ERROR "gcovr not found! Aborting...")
    endif() # NOT GCOVR_PATH

    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()

    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(GCOVR_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)

    # Combine excludes to several -e arguments
    set(GCOVR_EXCLUDE_ARGS "")
    foreach(EXCLUDE ${GCOVR_EXCLUDES})
        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
    endforeach()

    # Set up commands which will be run to generate coverage data
    # Run tests
    set(GCOVR_XML_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Running gcovr
    set(GCOVR_XML_CMD
        ${GCOVR_PATH} --xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS} ${GCOVR_EXCLUDE_ARGS}
        --object-directory=${PROJECT_BINARY_DIR} -o ${Coverage_NAME}.xml
    )

    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")

        message(STATUS "Command to run tests: ")
        string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}")
        message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")

        message(STATUS "Command to generate gcovr XML coverage data: ")
        string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
        message(STATUS "${GCOVR_XML_CMD_SPACED}")
    endif()

    add_custom_target(${Coverage_NAME}
        COMMAND ${GCOVR_XML_EXEC_TESTS_CMD}
        COMMAND ${GCOVR_XML_CMD}

        BYPRODUCTS ${Coverage_NAME}.xml
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Running gcovr to produce Cobertura code coverage report."
    )

    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
    )
endfunction() # setup_target_for_coverage_gcovr_xml

# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
# setup_target_for_coverage_gcovr_html(
#     NAME ctest_coverage                    # New target name
#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
#     DEPENDENCIES executable_target         # Dependencies to build first
#     BASE_DIRECTORY "../"                   # Base directory for report
#                                            #  (defaults to PROJECT_SOURCE_DIR)
#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
# )
# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
# GCVOR command.
function(setup_target_for_coverage_gcovr_html)

    set(options NONE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    if(NOT GCOVR_PATH)
        message(FATAL_ERROR "gcovr not found! Aborting...")
    endif() # NOT GCOVR_PATH

    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()

    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(GCOVR_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)

    # Combine excludes to several -e arguments
    set(GCOVR_EXCLUDE_ARGS "")
    foreach(EXCLUDE ${GCOVR_EXCLUDES})
        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
    endforeach()

    # Set up commands which will be run to generate coverage data
    # Run tests
    set(GCOVR_HTML_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Create folder
    set(GCOVR_HTML_FOLDER_CMD
        ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
    )
    # Running gcovr
    set(GCOVR_HTML_CMD
        ${GCOVR_PATH} --html --html-details -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
        -o ${Coverage_NAME}/index.html
    )

    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")

        message(STATUS "Command to run tests: ")
        string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}")
        message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")

        message(STATUS "Command to create a folder: ")
        string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}")
        message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}")

        message(STATUS "Command to generate gcovr HTML coverage data: ")
        string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}")
        message(STATUS "${GCOVR_HTML_CMD_SPACED}")
    endif()

    add_custom_target(${Coverage_NAME}
        COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD}
        COMMAND ${GCOVR_HTML_FOLDER_CMD}
        COMMAND ${GCOVR_HTML_CMD}

        BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html  # report directory
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Running gcovr to produce HTML code coverage report."
    )

    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )

endfunction() # setup_target_for_coverage_gcovr_html

# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
# setup_target_for_coverage_fastcov(
#     NAME testrunner_coverage                    # New target name
#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
#     DEPENDENCIES testrunner                     # Dependencies to build first
#     BASE_DIRECTORY "../"                        # Base directory for report
#                                                 #  (defaults to PROJECT_SOURCE_DIR)
#     EXCLUDE "src/dir1/" "src/dir2/"             # Patterns to exclude.
#     NO_DEMANGLE                                 # Don't demangle C++ symbols
#                                                 #  even if c++filt is found
#     SKIP_HTML                                   # Don't create html report
# )
function(setup_target_for_coverage_fastcov)

    set(options NO_DEMANGLE SKIP_HTML)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES FASTCOV_ARGS GENHTML_ARGS)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    if(NOT FASTCOV_PATH)
        message(FATAL_ERROR "fastcov not found! Aborting...")
    endif()

    if(NOT GENHTML_PATH)
        message(FATAL_ERROR "genhtml not found! Aborting...")
    endif()

    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()

    # Collect excludes (Patterns, not paths, for fastcov)
    set(FASTCOV_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_FASTCOV_EXCLUDES})
        list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES FASTCOV_EXCLUDES)

    # Conditional arguments
    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
        set(GENHTML_EXTRA_ARGS "--demangle-cpp")
    endif()

    # Set up commands which will be run to generate coverage data
    set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})

    set(FASTCOV_CAPTURE_CMD ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
        --search-directory ${BASEDIR}
        --process-gcno
        --lcov
        --output ${Coverage_NAME}.info
        --exclude ${FASTCOV_EXCLUDES}
        --exclude ${FASTCOV_EXCLUDES}
    )

    if(Coverage_SKIP_HTML)
        set(FASTCOV_HTML_CMD ";")
    else()
        set(FASTCOV_HTML_CMD ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS}
            -o ${Coverage_NAME} ${Coverage_NAME}.info
        )
    endif()

    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):")

        message("   Running tests:")
        string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED "${FASTCOV_EXEC_TESTS_CMD}")
        message("     ${FASTCOV_EXEC_TESTS_CMD_SPACED}")

        message("   Capturing fastcov counters and generating report:")
        string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}")
        message("     ${FASTCOV_CAPTURE_CMD_SPACED}")

        if(NOT Coverage_SKIP_HTML)
            message("   Generating HTML report: ")
            string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}")
            message("     ${FASTCOV_HTML_CMD_SPACED}")
        endif()
    endif()

    # Setup target
    add_custom_target(${Coverage_NAME}

        # Cleanup fastcov
        COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
            --search-directory ${BASEDIR}
            --zerocounters

        COMMAND ${FASTCOV_EXEC_TESTS_CMD}
        COMMAND ${FASTCOV_CAPTURE_CMD}
        COMMAND ${FASTCOV_HTML_CMD}

        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
             ${Coverage_NAME}.info
             ${Coverage_NAME}/index.html  # report directory

        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report."
    )

    set(INFO_MSG "fastcov code coverage info report saved in ${Coverage_NAME}.info.")
    if(NOT Coverage_SKIP_HTML)
        string(APPEND INFO_MSG " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report.")
    endif()
    # Show where to find the fastcov info report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG}
    )

endfunction() # setup_target_for_coverage_fastcov

function(append_coverage_compiler_flags)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
endfunction() # append_coverage_compiler_flags
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/FindARPACK.cmake0000644000175100001710000000465200000000000024260 0ustar00runnerdocker00000000000000# https://raw.githubusercontent.com/dune-project/dune-istl/master/cmake/modules/FindARPACK.cmake
#
# This file is taken from:
#
# DUNE, the Distributed and Unified Numerics Environment
# GPLv2 licensed
#
# .. cmake_module::
#
#    Module that checks whether ARPACK is available and usable.
#
#    Variables used by this module which you may want to set:
#
#    :ref:`ARPACK_ROOT`
#       Path list to search for ARPACK.
#
#    Sets the following variables:
#
#    :code:`ARPACK_FOUND`
#       True if ARPACK available.
#
#    :code:`ARPACK_LIBRARIES`
#       Link against these libraries to use ARPACK.
#
# .. cmake_variable:: ARPACK_ROOT
#
#    You may set this variable to have :ref:`FindARPACK` look
#    for the ARPACK package in the given path before inspecting
#    system paths.
#

# look for library, only at positions given by the user
find_library(ARPACK_LIBRARY
  NAMES "arpack"
  PATHS ${ARPACK_PREFIX} ${ARPACK_ROOT}
  PATH_SUFFIXES "lib" "lib32" "lib64"
  NO_DEFAULT_PATH
)

# look for library files, including default paths
find_library(ARPACK_LIBRARY
  NAMES "arpack"
  PATH_SUFFIXES "lib" "lib32" "lib64"
)

# check header usability
include(CMakePushCheckState)
cmake_push_check_state()

# we need if clauses here because variable is set variable-NOTFOUND if the
# searches above were not successful; without them CMake print errors like:
# "CMake Error: The following variables are used in this project, but they
# are set to NOTFOUND. Please set them or make sure they are set and tested
# correctly in the CMake files."
if(ARPACK_LIBRARY)
  set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${ARPACK_LIBRARY})
endif()

# end of header usability check
cmake_pop_check_state()

# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
  "ARPACK"
  DEFAULT_MSG
  ARPACK_LIBRARY
)

# hide the introduced cmake cached variables in cmake GUIs
mark_as_advanced(ARPACK_LIBRARY)

# if headers are found, store results
if(ARPACK_FOUND)
  set(ARPACK_LIBRARIES ${ARPACK_LIBRARY})
  # log result
  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
    "Determing location of ARPACK succeeded:\n"
    "Libraries to link against: ${ARPACK_LIBRARIES}\n\n")
else()
  # log errornous result
  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
    "Determing location of ARPACK failed:\n"
    "Libraries to link against: ${ARPACK_LIBRARIES}\n\n")
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/FindCXSparse.cmake0000644000175100001710000000461500000000000025006 0ustar00runnerdocker00000000000000# Retrieved from https://github.com/microsoft/vcpkg/blob/3b433e5081f35a32331492d98a8b0c1c2477048e/ports/suitesparse/FindCXSparse.cmake
#
# Distributed under the OSI-approved BSD 3-Clause License.
#
#.rst:
# FindCXSparse
# --------
#
# Find the CXSparse library
#
# Result Variables
# ^^^^^^^^^^^^^^^^
#
# The following variables will be defined:
#
#  ``CXSparse_FOUND``
#    True if CXSparse found on the local system
#
#  ``CXSPARSE_FOUND``
#    True if CXSparse found on the local system
#
#  ``CXSparse_INCLUDE_DIRS``
#    Location of CXSparse header files
#
#  ``CXSPARSE_INCLUDE_DIRS``
#    Location of CXSparse header files
#
#  ``CXSparse_LIBRARIES``
#    List of the CXSparse libraries found
#
#  ``CXSPARSE_LIBRARIES``
#    List of the CXSparse libraries found
#
#

include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
include(${CMAKE_ROOT}/Modules/SelectLibraryConfigurations.cmake)

find_path(CXSPARSE_INCLUDE_DIR NAMES cs.h PATH_SUFFIXES suitesparse)

find_library(CXSPARSE_LIBRARY_RELEASE NAMES cxsparse libcxsparse)
find_library(CXSPARSE_LIBRARY_DEBUG NAMES cxsparsed libcxsparsed)
select_library_configurations(CXSPARSE)

if(CXSPARSE_INCLUDE_DIR)
  set(CXSPARSE_VERSION_FILE ${CXSPARSE_INCLUDE_DIR}/cs.h)
  file(READ ${CXSPARSE_INCLUDE_DIR}/cs.h CXSPARSE_VERSION_FILE_CONTENTS)

  string(REGEX MATCH "#define CS_VER [0-9]+"
    CXSPARSE_MAIN_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define CS_VER ([0-9]+)" "\\1"
    CXSPARSE_MAIN_VERSION "${CXSPARSE_MAIN_VERSION}")

  string(REGEX MATCH "#define CS_SUBVER [0-9]+"
    CXSPARSE_SUB_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define CS_SUBVER ([0-9]+)" "\\1"
    CXSPARSE_SUB_VERSION "${CXSPARSE_SUB_VERSION}")

  string(REGEX MATCH "#define CS_SUBSUB [0-9]+"
    CXSPARSE_SUBSUB_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define CS_SUBSUB ([0-9]+)" "\\1"
    CXSPARSE_SUBSUB_VERSION "${CXSPARSE_SUBSUB_VERSION}")

  set(CXSPARSE_VERSION "${CXSPARSE_MAIN_VERSION}.${CXSPARSE_SUB_VERSION}.${CXSPARSE_SUBSUB_VERSION}")
endif()

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(CXSparse
  REQUIRED_VARS CXSPARSE_INCLUDE_DIR CXSPARSE_LIBRARIES
  VERSION_VAR CXSPARSE_VERSION)

set(CXSPARSE_FOUND ${CXSparse_FOUND})
set(CXSPARSE_INCLUDE_DIRS ${CXSPARSE_INCLUDE_DIR})
set(CXSparse_INCLUDE_DIRS ${CXSPARSE_INCLUDE_DIR})
set(CXSparse_LIBRARIES ${CXSPARSE_LIBRARIES})
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/FindGLPK.cmake0000644000175100001710000000377600000000000024062 0ustar00runnerdocker00000000000000#[=======================================================================[.rst:
FindGLPK
--------

Finds the GLPK library.

Result Variables
^^^^^^^^^^^^^^^^

This will define the following variables:

``GLPK_FOUND``
  True if the system has the GLPK library.
``GLPK_VERSION``
  The version of the GLPK library which was found.
``GLPK_INCLUDE_DIRS``
  Include directories needed to use Foo.
``GLPK_LIBRARIES``
  Libraries needed to link to Foo.

Cache Variables
^^^^^^^^^^^^^^^

The following cache variables may also be set:

``GLPK_INCLUDE_DIR``
  The directory containing ``glpk.h``.
``GLPK_LIBRARY``
  The path to the GLPK library.

#]=======================================================================]

find_path(GLPK_INCLUDE_DIR
  NAMES glpk.h
)

find_library(GLPK_LIBRARY
  NAMES glpk
)

# parse version from header
if(GLPK_INCLUDE_DIR)
  set(GLPK_VERSION_FILE ${GLPK_INCLUDE_DIR}/glpk.h)
  file(READ ${GLPK_VERSION_FILE} GLPK_VERSION_FILE_CONTENTS)

  string(REGEX MATCH "#define[ ]+GLP_MAJOR_VERSION[ ]+[0-9]+"
    GLPK_VERSION_MAJOR "${GLPK_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define[ ]+GLP_MAJOR_VERSION[ ]+([0-9]+)" "\\1"
    GLPK_VERSION_MAJOR "${GLPK_VERSION_MAJOR}")

  string(REGEX MATCH "#define[ ]+GLP_MINOR_VERSION[ ]+[0-9]+"
    GLPK_VERSION_MINOR "${GLPK_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define[ ]+GLP_MINOR_VERSION[ ]+([0-9]+)" "\\1"
    GLPK_VERSION_MINOR "${GLPK_VERSION_MINOR}")

  set(GLPK_VERSION "${GLPK_VERSION_MAJOR}.${GLPK_VERSION_MINOR}")

  # compatibility variables
  set(GLPK_VERSION_STRING "${GLPK_VERSION}")
endif()

# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GLPK
  FOUND_VAR GLPK_FOUND
  REQUIRED_VARS
    GLPK_LIBRARY
    GLPK_INCLUDE_DIR
  VERSION_VAR GLPK_VERSION
)

# hide the introduced cmake cached variables in cmake GUIs
mark_as_advanced(
  GLPK_INCLUDE_DIR
  GLPK_LIBRARY
)

if(GLPK_FOUND)
  set(GLPK_LIBRARIES ${GLPK_LIBRARY})
  set(GLPK_INCLUDE_DIRS ${GLPK_INCLUDE_DIR})
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/FindGMP.cmake0000644000175100001710000000166400000000000023742 0ustar00runnerdocker00000000000000# Inspired by http://code.google.com/p/origin/source/browse/trunk/cmake/FindGMP.cmake

# Copyright (c) 2008-2010 Kent State University
# Copyright (c) 2011-2012 Texas A&M University
#
# This file is distributed under the MIT License. See
# http://www.opensource.org/licenses/mit-license.php for terms and conditions.
#
# Some modifications made by Tamas Nepusz to ensure that the module fits better
# with the de facto conventions of FindXXX.cmake scripts

find_path(GMP_INCLUDE_DIR 
  NAMES gmp.h
)

find_library(GMP_LIBRARY
  NAMES gmp
)

# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(
  "GMP"
  DEFAULT_MSG
  GMP_LIBRARY
  GMP_INCLUDE_DIR
)

# hide the introduced cmake cached variables in cmake GUIs
mark_as_advanced(GMP_INCLUDE_DIR)
mark_as_advanced(GMP_LIBRARY)

if(GMP_FOUND)
  set(GMP_LIBRARIES ${GMP_LIBRARY})
  set(GMP_INCLUDE_DIRS ${GMP_INCLUDE_DIR})
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/FindPLFIT.cmake0000644000175100001710000000401600000000000024167 0ustar00runnerdocker00000000000000# Inspired by http://code.google.com/p/origin/source/browse/trunk/cmake/FindGMP.cmake

# Copyright (c) 2021 Tamas Nepusz
#
# This file is distributed under the MIT License. See
# http://www.opensource.org/licenses/mit-license.php for terms and conditions.
#
# Some modifications made by Tamas Nepusz to ensure that the module fits better
# with the de facto conventions of FindXXX.cmake scripts

find_path(PLFIT_INCLUDE_DIR
  NAMES plfit.h
)

find_library(PLFIT_LIBRARY
  NAMES plfit
)

# parse version from header
if(PLFIT_INCLUDE_DIR)
  set(PLFIT_VERSION_FILE ${PLFIT_INCLUDE_DIR}/plfit_version.h)
  file(READ ${PLFIT_VERSION_FILE} PLFIT_VERSION_FILE_CONTENTS)

  string(REGEX MATCH "#define[ ]+PLFIT_VERSION_MAJOR[ ]+[0-9]+"
    PLFIT_VERSION_MAJOR "${PLFIT_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define[ ]+PLFIT_VERSION_MAJOR[ ]+([0-9]+)" "\\1"
    PLFIT_VERSION_MAJOR "${PLFIT_VERSION_MAJOR}")

  string(REGEX MATCH "#define[ ]+PLFIT_VERSION_MINOR[ ]+[0-9]+"
    PLFIT_VERSION_MINOR "${PLFIT_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define[ ]+PLFIT_VERSION_MINOR[ ]+([0-9]+)" "\\1"
    PLFIT_VERSION_MINOR "${PLFIT_VERSION_MINOR}")

  string(REGEX MATCH "#define[ ]+PLFIT_VERSION_PATCH[ ]+[0-9]+"
    PLFIT_VERSION_PATCH "${PLFIT_VERSION_FILE_CONTENTS}")
  string(REGEX REPLACE "#define[ ]+PLFIT_VERSION_PATCH[ ]+([0-9]+)" "\\1"
    PLFIT_VERSION_PATCH "${PLFIT_VERSION_PATCH}")

  set(PLFIT_VERSION "${PLFIT_VERSION_MAJOR}.${PLFIT_VERSION_MINOR}.${PLFIT_VERSION_PATCH}")

  # compatibility variables
  set(PLFIT_VERSION_STRING "${PLFIT_VERSION}")
endif()

# behave like a CMake module is supposed to behave
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PLFIT
  FOUND_VAR PLFIT_FOUND
  REQUIRED_VARS
    PLFIT_LIBRARY
    PLFIT_INCLUDE_DIR
  VERSION_VAR PLFIT_VERSION
)

# hide the introduced cmake cached variables in cmake GUIs
mark_as_advanced(PLFIT_INCLUDE_DIR)
mark_as_advanced(PLFIT_LIBRARY)

if(PLFIT_FOUND)
  set(PLFIT_LIBRARIES ${PLFIT_LIBRARY})
  set(PLFIT_INCLUDE_DIRS ${PLFIT_INCLUDE_DIR})
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/GetGitRevisionDescription.cmake0000644000175100001710000001145000000000000027616 0ustar00runnerdocker00000000000000# - Returns a version string from Git
#
# These functions force a re-configure on each git commit so that you can
# trust the values of the variables in your build system.
#
#  get_git_head_revision(  [ ...])
#
# Returns the refspec and sha hash of the current head revision
#
#  git_describe( [ ...])
#
# Returns the results of git describe on the source tree, and adjusting
# the output so that it tests false if an error occurs.
#
#  git_get_exact_tag( [ ...])
#
# Returns the results of git describe --exact-match on the source tree,
# and adjusting the output so that it tests false if there was no exact
# matching tag.
#
#  git_local_changes()
#
# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
# Uses the return code of "git diff-index --quiet HEAD --".
# Does not regard untracked files.
#
# Requires CMake 2.6 or newer (uses the 'function' command)
#
# Original Author:
# 2009-2010 Ryan Pavlik  
# http://academic.cleardefinition.com
# Iowa State University HCI Graduate Program/VRAC
#
# Copyright Iowa State University 2009-2010.
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)

if(__get_git_revision_description)
	return()
endif()
set(__get_git_revision_description YES)

# We must run the following at "include" time, not at function call time,
# to find the path to this module rather than the path to a calling list file
get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)

function(get_git_head_revision _refspecvar _hashvar)
	set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
	set(GIT_DIR "${GIT_PARENT_DIR}/.git")
	while(NOT EXISTS "${GIT_DIR}")	# .git dir not found, search parent directories
		set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
		get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
		if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
			# We have reached the root directory, we are not in git
			set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
			set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
			return()
		endif()
		set(GIT_DIR "${GIT_PARENT_DIR}/.git")
	endwhile()
	# check if this is a submodule
	if(NOT IS_DIRECTORY ${GIT_DIR})
		file(READ ${GIT_DIR} submodule)
		string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
		get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
		get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
	endif()
	set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
	if(NOT EXISTS "${GIT_DATA}")
		file(MAKE_DIRECTORY "${GIT_DATA}")
	endif()

	if(NOT EXISTS "${GIT_DIR}/HEAD")
		return()
	endif()
	set(HEAD_FILE "${GIT_DATA}/HEAD")
	configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)

	configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
		"${GIT_DATA}/grabRef.cmake"
		@ONLY)
	include("${GIT_DATA}/grabRef.cmake")

	set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
	set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
endfunction()

function(git_describe _var)
	if(NOT GIT_FOUND)
		find_package(Git QUIET)
	endif()
	get_git_head_revision(refspec hash)
	if(NOT GIT_FOUND)
		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
		return()
	endif()
	if(NOT hash)
		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
		return()
	endif()

	# TODO sanitize
	#if((${ARGN}" MATCHES "&&") OR
	#	(ARGN MATCHES "||") OR
	#	(ARGN MATCHES "\\;"))
	#	message("Please report the following error to the project!")
	#	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
	#endif()

	execute_process(COMMAND
		"${GIT_EXECUTABLE}"
		describe
		${hash}
		${ARGN}
		WORKING_DIRECTORY
		"${CMAKE_CURRENT_SOURCE_DIR}"
		RESULT_VARIABLE
		res
		OUTPUT_VARIABLE
		out
		ERROR_QUIET
		OUTPUT_STRIP_TRAILING_WHITESPACE)
	if(NOT res EQUAL 0)
		set(out "${out}-${res}-NOTFOUND")
	endif()

	set(${_var} "${out}" PARENT_SCOPE)
endfunction()

function(git_get_exact_tag _var)
	git_describe(out --exact-match ${ARGN})
	set(${_var} "${out}" PARENT_SCOPE)
endfunction()

function(git_local_changes _var)
	if(NOT GIT_FOUND)
		find_package(Git QUIET)
	endif()
	get_git_head_revision(refspec hash)
	if(NOT GIT_FOUND)
		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
		return()
	endif()
	if(NOT hash)
		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
		return()
	endif()

	execute_process(COMMAND
		"${GIT_EXECUTABLE}"
		diff-index --quiet HEAD --
		WORKING_DIRECTORY
		"${CMAKE_CURRENT_SOURCE_DIR}"
		RESULT_VARIABLE
		res
		OUTPUT_VARIABLE
		out
		ERROR_QUIET
		OUTPUT_STRIP_TRAILING_WHITESPACE)
	if(res EQUAL 0)
		set(${_var} "CLEAN" PARENT_SCOPE)
	else()
		set(${_var} "DIRTY" PARENT_SCOPE)
	endif()
endfunction()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/GetGitRevisionDescription.cmake.in0000644000175100001710000000240300000000000030221 0ustar00runnerdocker00000000000000#
# Internal file for GetGitRevisionDescription.cmake
#
# Requires CMake 2.6 or newer (uses the 'function' command)
#
# Original Author:
# 2009-2010 Ryan Pavlik  
# http://academic.cleardefinition.com
# Iowa State University HCI Graduate Program/VRAC
#
# Copyright Iowa State University 2009-2010.
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)

set(HEAD_HASH)

file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)

string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
if(HEAD_CONTENTS MATCHES "ref")
	# named branch
	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
	else()
		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
			set(HEAD_HASH "${CMAKE_MATCH_1}")
		endif()
	endif()
else()
	# detached HEAD
	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
endif()

if(NOT HEAD_HASH)
	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
	string(STRIP "${HEAD_HASH}" HEAD_HASH)
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/JoinPaths.cmake0000644000175100001710000000167700000000000024421 0ustar00runnerdocker00000000000000# This module provides function for joining paths
# known from from most languages
#
# Original license:
# SPDX-License-Identifier: (MIT OR CC0-1.0)
# Explicit permission given to distribute this module under
# the terms of the project as described in /LICENSE.rst.
# Copyright 2020 Jan Tojnar
# https://github.com/jtojnar/cmake-snips
#
# Modelled after Python’s os.path.join
# https://docs.python.org/3.7/library/os.path.html#os.path.join
# Windows not supported
function(join_paths joined_path first_path_segment)
    set(temp_path "${first_path_segment}")
    foreach(current_segment IN LISTS ARGN)
        if(NOT ("${current_segment}" STREQUAL ""))
            if(IS_ABSOLUTE "${current_segment}")
                set(temp_path "${current_segment}")
            else()
                set(temp_path "${temp_path}/${current_segment}")
            endif()
        endif()
    endforeach()
    set(${joined_path} "${temp_path}" PARENT_SCOPE)
endfunction()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/PadString.cmake0000644000175100001710000000322100000000000024400 0ustar00runnerdocker00000000000000# ------------------------------------------------------------------------------
# Macro PAD_STRING
#
# This function pads a string on the left side with a specified character to
# reach the specified length. If the string length is already long enough or
# longer, the string will not be modified.
#
# PAD_STRING(OUT_VARIABLE DESIRED_LENGTH FILL_CHAR VALUE)
#
#     OUT_VARIABLE: name of the resulting variable to create
#     DESIRED_LENGTH: desired length of the generated string
#     FILL_CHAR: character to use for padding
#     VALUE: string to pad
#
# Copyright (C) 2011 by Johannes Wienke 
#
# This program is free software; you can redistribute it
# and/or modify it under the terms of the GNU General
# Public License as published by the Free Software Foundation;
# either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# ------------------------------------------------------------------------------
FUNCTION(PAD_STRING OUT_VARIABLE DESIRED_LENGTH FILL_CHAR VALUE)
    STRING(LENGTH "${VALUE}" VALUE_LENGTH)
    MATH(EXPR REQUIRED_PADS "${DESIRED_LENGTH} - ${VALUE_LENGTH}")
    SET(PAD ${VALUE})
    IF(REQUIRED_PADS GREATER 0)
        MATH(EXPR REQUIRED_MINUS_ONE "${REQUIRED_PADS} - 1")
        FOREACH(FOO RANGE ${REQUIRED_MINUS_ONE})
            SET(PAD "${FILL_CHAR}${PAD}")
        ENDFOREACH()
    ENDIF()
    SET(${OUT_VARIABLE} "${PAD}" PARENT_SCOPE)
ENDFUNCTION()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/PreventInSourceBuilds.cmake0000644000175100001710000000274200000000000026752 0ustar00runnerdocker00000000000000# Original source of this script:
# https://raw.githubusercontent.com/InsightSoftwareConsortium/ITK/master/CMake/PreventInSourceBuilds.cmake
#
# Thanks to the ITK project!
#
# This function will prevent in-source builds
function(AssureOutOfSourceBuilds)
  # make sure the user doesn't play dirty with symlinks
  get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
  get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)

  # disallow in-source builds
  if("${srcdir}" STREQUAL "${bindir}")
    message("##########################################################################")
    message("# igraph should not be configured & built in the igraph source directory")
    message("# You must run cmake in a build directory.")
	message("#")
	message("# Example:")
    message("# mkdir build; cd build; cmake ..; make")
    message("#")
    message("# NOTE: Given that you already tried to make an in-source build")
    message("#       CMake have already created several files & directories")
	message("#       in your source tree. If you are using git, run 'git clean -dfx'")
	message("#       to start from scratch. If you don't have git, remove")
	message("#       CMakeCache.txt and the CMakeFiles/ folder from the top of")
	message("#       the source tree.")
    message("#")
    message("##########################################################################")
    message("")
    message(FATAL_ERROR "Quitting configuration")
  endif()
endfunction()

AssureOutOfSourceBuilds()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/UseCCacheWhenInstalled.cmake0000644000175100001710000000036400000000000026757 0ustar00runnerdocker00000000000000option(USE_CCACHE "Use ccache to speed up compilation if it is installed" ON)
if(USE_CCACHE)
  find_program(CCACHE_PROGRAM ccache)
  if(CCACHE_PROGRAM)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
  endif()
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/benchmark_helpers.cmake0000644000175100001710000000303700000000000026166 0ustar00runnerdocker00000000000000include(CMakeParseArguments)

function(add_benchmark NAME NAMESPACE)
  set(TARGET_NAME ${NAMESPACE}_${NAME})

  add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL ${PROJECT_SOURCE_DIR}/tests/benchmarks/${NAME}.c)
  use_all_warnings(${TARGET_NAME})
  add_dependencies(build_benchmarks ${TARGET_NAME})
  target_link_libraries(${TARGET_NAME} PRIVATE igraph)

  if (NOT BUILD_SHARED_LIBS)
    # Add a compiler definition required to compile igraph in static mode
    target_compile_definitions(${TARGET_NAME} PRIVATE IGRAPH_STATIC)
  endif()

  # Some benchmarks include plfit_sampling.h from plfit. The following ensures
  # that the correct version is included, depending on whether plfit is vendored
  target_include_directories(
    ${TARGET_NAME} PRIVATE
    $<$:$>
    $<$:${PLFIT_INCLUDE_DIR}>
  )

  if (MSVC)
    # Add MSVC-specific include path for some headers that are missing on Windows
    target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/msvc/include)
  endif()

  add_custom_command(
    TARGET benchmark
    POST_BUILD
    COMMAND ${TARGET_NAME}
    COMMENT "Running benchmark: ${NAME}"
    USES_TERMINAL
  )
endfunction()

function(add_benchmarks)
  cmake_parse_arguments(
    PARSED "" "" "NAMES;LIBRARIES" ${ARGN}
  )
  foreach(NAME ${PARSED_NAMES})
    add_benchmark(${NAME} benchmark)
    if(PARSED_LIBRARIES)
      target_link_libraries(benchmark_${NAME} PRIVATE ${PARSED_LIBRARIES})
    endif()
  endforeach()
endfunction()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/compilers.cmake0000644000175100001710000000706500000000000024514 0ustar00runnerdocker00000000000000include(CheckCCompilerFlag)

if(MSVC)
  add_compile_options(/FS)
  add_compile_definitions(_CRT_SECURE_NO_WARNINGS) # necessary to compile for UWP
endif()

if (NOT MSVC)
  check_c_compiler_flag("-Wno-varargs" COMPILER_SUPPORTS_NO_VARARGS_FLAG)
  check_c_compiler_flag("-Wno-unknown-warning-option" COMPILER_SUPPORTS_NO_UNKNOWN_WARNING_OPTION_FLAG)
endif()

set(
  IGRAPH_WARNINGS_AS_ERRORS ON CACHE BOOL
  "Treat warnings as errors with GCC-like compilers"
)

macro(use_all_warnings TARGET_NAME)
  if(MSVC)
    target_compile_options(${TARGET_NAME} PRIVATE
      /W4 # enable most warnings, then disable:
      /wd4244 # 'conversion' conversion from 'type1' to 'type2', possible loss of data
      /wd4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
      /wd4996 # deprecated functions, e.g. 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead.
      /wd4456 # declaration of 'identifier' hides previous local declaration
      /wd4800 # forcing value to 'true' or 'false' (performance warning)
      /wd4204 # nonstandard extension used: non-constant aggregate initializer
      /wd4701 # potentially uninitialized local variable
    )
  else()
    target_compile_options(${TARGET_NAME} PRIVATE
      # GCC-style compilers:
      $<$:
        $<$:-Werror>
        -Wall -Wextra -pedantic
        -Wno-unused-function -Wno-unused-parameter -Wno-sign-compare
      >
      $<$:-Wno-varargs>
      $<$:-Wno-unknown-warning-option>
      # Intel compiler:
      $<$:
        # disable #279: controlling expression is constant; affecting assert(condition && "message")
        # disable #188: enumerated type mixed with another type; affecting IGRAPH_CHECK
        # disable #592: variable "var" is used before its value is set; affecting IGRAPH_UNUSED
        -wd279 -wd188 -wd592 -diag-disable=remark
      >
    )
  endif()
endmacro()

# Helper function to add preprocesor definition of IGRAPH_FILE_BASENAME
# to pass the filename without directory path for debugging use.
#
# Example:
#
#   define_file_basename_for_sources(my_target)
#
# Will add -DIGRAPH_FILE_BASENAME="filename" for each source file depended
# on by my_target, where filename is the name of the file.
#
# Source: https://stackoverflow.com/a/27990434/156771
function(define_file_basename_for_sources targetname)
  get_target_property(source_files "${targetname}" SOURCES)
  get_target_property(source_dir "${targetname}" SOURCE_DIR)
  foreach(sourcefile ${source_files})
    # Turn relative paths into absolute
    get_filename_component(source_full_path "${sourcefile}" ABSOLUTE BASE_DIR "${source_dir}")

    # Figure out whether the relative path from the source or the build folder
    # is shorter
    file(RELATIVE_PATH source_rel_path "${PROJECT_SOURCE_DIR}" "${source_full_path}")
    file(RELATIVE_PATH binary_rel_path "${PROJECT_BINARY_DIR}" "${source_full_path}")
    string(LENGTH "${source_rel_path}" source_rel_path_length)
    string(LENGTH "${binary_rel_path}" binary_rel_path_length)
    if(binary_rel_path_length LESS source_rel_path_length)
      set(basename "${binary_rel_path}")
    else()
      set(basename "${source_rel_path}")
    endif()

    # Add the IGRAPH_FILE_BASENAME=filename compile definition to the source file
    set_property(
      SOURCE "${sourcefile}" APPEND
      PROPERTY COMPILE_DEFINITIONS "IGRAPH_FILE_BASENAME=\"${basename}\""
    )
  endforeach()
endfunction()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/cpack_install_script.cmake0000644000175100001710000000467200000000000026713 0ustar00runnerdocker00000000000000# Custom CPack install script that allows us to whitelist files to be copied
# to the tarball from the root directory, instead of copying the entire root
# directory recursively

if(CPACK_SOURCE_INSTALLED_DIRECTORIES)
    # Make sure that the parser sources are built
    execute_process(
        COMMAND "${CMAKE_COMMAND}"
        --build "${CPACK_PACKAGE_DIRECTORY}"
        --target parsersources
        RESULT_VARIABLE EXIT_CODE
    )
    if(NOT EXIT_CODE EQUAL 0)
        message(FATAL_ERROR "Failed to build the parser sources.")
    endif()

    # Generate a version file in the build folder if we don't have one in the
    # source folder
    if(EXISTS "${SOURCE_DIR}/IGRAPH_VERSION")
        set(IGRAPH_VERSION_FILE "${SOURCE_DIR}/IGRAPH_VERSION")
    else()
        execute_process(
            COMMAND "${CMAKE_COMMAND}"
            --build "${CPACK_PACKAGE_DIRECTORY}"
            --target versionfile
            RESULT_VARIABLE EXIT_CODE
        )
        if(NOT EXIT_CODE EQUAL 0)
            message(FATAL_ERROR "Failed to determine the version number of igraph that is being packaged.")
        endif()
        set(IGRAPH_VERSION_FILE "${CPACK_PACKAGE_DIRECTORY}/IGRAPH_VERSION")
    endif()

    list(GET CPACK_BUILD_SOURCE_DIRS 0 SOURCE_DIR)
    # This branch runs only if CPack generates the source package, and within
    # this branch, CMAKE_CURRENT_BINARY_DIR refers to the root of the staging
    # area where the tarball is assembled
    file(GLOB FILES_TO_COPY "${SOURCE_DIR}/*.md")
    file(
        INSTALL ${FILES_TO_COPY}
        DESTINATION "${CMAKE_CURRENT_BINARY_DIR}"
    )
    file(
        INSTALL
        "${SOURCE_DIR}/AUTHORS"
        "${SOURCE_DIR}/CMakeLists.txt"
        "${SOURCE_DIR}/COPYING"
        "${SOURCE_DIR}/ChangeLog"
        "${SOURCE_DIR}/INSTALL"
        "${SOURCE_DIR}/NEWS"
        "${SOURCE_DIR}/ONEWS"
        "${SOURCE_DIR}/igraph.pc.in"
        "${IGRAPH_VERSION_FILE}"
        DESTINATION "${CMAKE_CURRENT_BINARY_DIR}"
    )
    file(
        INSTALL
        "${SOURCE_DIR}/src/config.h.in"
        DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/src"
    )
    file(
		INSTALL
		"${CPACK_PACKAGE_DIRECTORY}/src/io/parsers"
		DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/src/io"
	)
    file(
        INSTALL
        "${SOURCE_DIR}/tools/removeexamples.py"
        DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/tools"
    )
    file(
		INSTALL
		"${CPACK_PACKAGE_DIRECTORY}/doc/html"
		DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/doc"
	)
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/create_igraph_version_file.cmake0000644000175100001710000000052000000000000030045 0ustar00runnerdocker00000000000000# CMake script that generates the IGRAPH_VERSION file in the build folder
#
# Script variables that need to be set before calling it via "cmake -P":
#
# * IGRAPH_VERSION should be set to the exact version number
# * VERSION_FILE_PATH should be set to the name of the version file

FILE(WRITE "${VERSION_FILE_PATH}" "${IGRAPH_VERSION}")
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/debugging.cmake0000644000175100001710000000025100000000000024440 0ustar00runnerdocker00000000000000set(
  IGRAPH_VERIFY_FINALLY_STACK
  ""
  CACHE
  BOOL
  "Verify that the 'finally' stack is cleaned up properly. Useful only in debugging; do not use in production."
)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/dependencies.cmake0000644000175100001710000001343500000000000025143 0ustar00runnerdocker00000000000000include(helpers)

include(CheckSymbolExists)

# The threading library is not needed for igraph itself, but might be needed
# for tests
include(FindThreads)

macro(find_dependencies)
  # Declare the list of dependencies that _may_ be vendored
  set(VENDORABLE_DEPENDENCIES BLAS CXSparse GLPK LAPACK ARPACK GMP PLFIT)

  # Declare optional dependencies associated with IGRAPH_..._SUPPORT flags
  # Note that GLPK is both vendorable and optional
  set(OPTIONAL_DEPENDENCIES GLPK OpenMP)

  # Declare configuration options for dependencies
  tristate(IGRAPH_USE_INTERNAL_GMP "Compile igraph with internal Mini-GMP" AUTO)
  tristate(IGRAPH_USE_INTERNAL_ARPACK "Compile igraph with internal ARPACK" AUTO)
  tristate(IGRAPH_USE_INTERNAL_BLAS "Compile igraph with internal BLAS" AUTO)
  tristate(IGRAPH_USE_INTERNAL_CXSPARSE "Compile igraph with internal CXSparse" AUTO)
  tristate(IGRAPH_USE_INTERNAL_GLPK "Compile igraph with internal GLPK" AUTO)
  tristate(IGRAPH_USE_INTERNAL_LAPACK "Compile igraph with internal LAPACK" AUTO)
  tristate(IGRAPH_USE_INTERNAL_PLFIT "Compile igraph with internal plfit" AUTO)

  # Declare dependencies
  set(REQUIRED_DEPENDENCIES "")
  set(OPTIONAL_DEPENDENCIES FLEX BISON OpenMP)
  set(VENDORED_DEPENDENCIES "")

  # Declare minimum supported version for some dependencies
  set(GLPK_VERSION_MIN "4.57") # 4.57 is the first version providing glp_on_error()
  set(PLFIT_VERSION_MIN "0.9.3")

  # Extend dependencies depending on whether we will be using the vendored
  # copies or not
  foreach(DEPENDENCY ${VENDORABLE_DEPENDENCIES})
    string(TOUPPER "${DEPENDENCY}" LIBNAME_UPPER)

    if(IGRAPH_USE_INTERNAL_${LIBNAME_UPPER} STREQUAL "AUTO")
      find_package(${DEPENDENCY} ${${DEPENDENCY}_VERSION_MIN} QUIET)
      if(${LIBNAME_UPPER}_FOUND)
        set(IGRAPH_USE_INTERNAL_${LIBNAME_UPPER} OFF)
      else()
        set(IGRAPH_USE_INTERNAL_${LIBNAME_UPPER} ON)
      endif()
    endif()

    if(IGRAPH_USE_INTERNAL_${LIBNAME_UPPER})
      list(APPEND VENDORED_DEPENDENCIES ${DEPENDENCY})
    else()
      list(APPEND REQUIRED_DEPENDENCIES ${DEPENDENCY})
    endif()
  endforeach()

  # For optional dependencies, figure out whether we should attempt to
  # link to them based on the value of the IGRAPH_..._SUPPORT option
  foreach(DEPENDENCY ${OPTIONAL_DEPENDENCIES})
    string(TOUPPER "${DEPENDENCY}" LIBNAME_UPPER)

    if(IGRAPH_${LIBNAME_UPPER}_SUPPORT STREQUAL "AUTO")
      find_package(${DEPENDENCY} ${${DEPENDENCY}_VERSION_MIN} QUIET)
      if(${LIBNAME_UPPER}_FOUND)
        set(IGRAPH_${LIBNAME_UPPER}_SUPPORT ON)
      else()
        set(IGRAPH_${LIBNAME_UPPER}_SUPPORT OFF)
      endif()
    endif()
  endforeach()

  # GraphML support is treated separately because the library name is different
  if(IGRAPH_GRAPHML_SUPPORT STREQUAL "AUTO")
    find_package(LibXml2 QUIET)
    if(LibXml2_FOUND)
      set(IGRAPH_GRAPHML_SUPPORT ON)
    else()
      set(IGRAPH_GRAPHML_SUPPORT OFF)
    endif()
  endif()

  if(NOT IGRAPH_GLPK_SUPPORT)
    if(IGRAPH_USE_INTERNAL_GLPK)
      list(REMOVE_ITEM VENDORED_DEPENDENCIES GLPK)
    else()
      list(REMOVE_ITEM REQUIRED_DEPENDENCIES GLPK)
    endif()
  endif()

  if(IGRAPH_GRAPHML_SUPPORT)
    list(APPEND REQUIRED_DEPENDENCIES LibXml2)
  endif()

  # Find dependencies
  foreach(DEPENDENCY ${REQUIRED_DEPENDENCIES} ${OPTIONAL_DEPENDENCIES})
    list(FIND REQUIRED_DEPENDENCIES "${DEPENDENCY}" INDEX)
    set(NEED_THIS_DEPENDENCY NO)

    if(INDEX GREATER_EQUAL 0)
      # This is a required dependency, search for it unconditionally. Do
      # not use REQUIRED; we will report errors in a single batch at the end
      # of the configuration process
      set(NEED_THIS_DEPENDENCY YES)
    else()
      # This is an optional dependency, search for it only if the user did not
      # turn it off explicitly
      string(TOUPPER "${DEPENDENCY}" LIBNAME_UPPER)
      if(NOT DEFINED IGRAPH_${LIBNAME_UPPER}_SUPPORT)
        set(NEED_THIS_DEPENDENCY YES)
      elseif(IGRAPH_${LIBNAME_UPPER}_SUPPORT)
        set(NEED_THIS_DEPENDENCY YES)
      endif()
    endif()

    if(NEED_THIS_DEPENDENCY AND NOT DEFINED ${DEPENDENCY}_FOUND)
      find_package(${DEPENDENCY} ${${DEPENDENCY}_VERSION_MIN})
    endif()
  endforeach()

  # Override libraries of vendored dependencies even if they were somehow
  # detected above
  foreach(DEPENDENCY ${VENDORED_DEPENDENCIES})
    string(TOUPPER "${DEPENDENCY}" LIBNAME_UPPER)
    string(TOLOWER "${DEPENDENCY}" LIBNAME_LOWER)
    if(IGRAPH_USE_INTERNAL_${LIBNAME_UPPER})
      set(${LIBNAME_UPPER}_LIBRARIES "")
      set(${LIBNAME_UPPER}_FOUND 1)
      set(${LIBNAME_UPPER}_IS_VENDORED 1)
      set(INTERNAL_${LIBNAME_UPPER} 1)
    endif()
  endforeach()

  # Export some aliases that will be used in config.h
  set(HAVE_GLPK ${GLPK_FOUND})
  set(HAVE_GMP ${GMP_FOUND})
  set(HAVE_LIBXML ${LIBXML2_FOUND})

  # Check whether we need to link to the math library
  if(NOT DEFINED CACHE{NEED_LINKING_AGAINST_LIBM})
    set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
    set(CMAKE_REQUIRED_QUIET ON)
    check_symbol_exists(sinh "math.h" SINH_FUNCTION_EXISTS)
    if(NOT SINH_FUNCTION_EXISTS)
      unset(SINH_FUNCTION_EXISTS CACHE)
      set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
      list(APPEND CMAKE_REQUIRED_LIBRARIES m)
      check_symbol_exists(sinh "math.h" SINH_FUNCTION_EXISTS)
      if(SINH_FUNCTION_EXISTS)
        set(NEED_LINKING_AGAINST_LIBM True CACHE BOOL "" FORCE)
      else()
        message(FATAL_ERROR "Failed to figure out how to link to the math library on this platform")
      endif()
      set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
    endif()
    unset(SINH_FUNCTION_EXISTS CACHE)
    set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
  endif()

  if(NEED_LINKING_AGAINST_LIBM)
    find_library(MATH_LIBRARY m)
  endif()

  mark_as_advanced(MATH_LIBRARY)
  mark_as_advanced(NEED_LINKING_AGAINST_LIBM)
endmacro()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/features.cmake0000644000175100001710000000040100000000000024320 0ustar00runnerdocker00000000000000include(helpers)

include(tls)
include(lto)

option(IGRAPH_GLPK_SUPPORT "Compile igraph with GLPK support" ON)
tristate(IGRAPH_GRAPHML_SUPPORT "Compile igraph with GraphML support" AUTO)
tristate(IGRAPH_OPENMP_SUPPORT "Use OpenMP for parallelization" AUTO)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/generate_tags_file.cmake0000644000175100001710000000312700000000000026321 0ustar00runnerdocker00000000000000# Creates a ctags-compatible tags file from a set of XML files by extracting
# the IDs found in the XML files.
#
# Parameters of the script:
#
# - INPUT_FILES: list of input files to process, with absolute pathnames
# - OUTPUT_FILE: the output file to write the tags into

string(REPLACE " " ";" INPUT_FILE_LIST "${INPUT_FILES}")

set(EXTRACTED_IDS "")

foreach(INPUT_FILE ${INPUT_FILE_LIST})
  file(READ "${INPUT_FILE}" CONTENTS)

  # Replace newlines with semicolons. This is a hack and we should escape
  # semicolons first if we wanted to do this properly; however, here we are
  # only interested in XML IDs and they don't have semicolons
  string(REPLACE "\n" ";" LINES "${CONTENTS}")
  foreach(_line ${LINES})
    string(REGEX MATCHALL "id=\"[^-\"]*\"" MATCH_RESULT "${_line}")
    if(MATCH_RESULT)
      foreach(MATCH ${MATCH_RESULT})
        string(REGEX REPLACE "id=\"(.*)\"" "\\1" EXTRACTED_ID "${MATCH}")
        list(APPEND EXTRACTED_IDS "${EXTRACTED_ID}")
      endforeach()
    endif()
  endforeach()
endforeach()

list(SORT EXTRACTED_IDS)
string(REPLACE ";" "\t\t\n" TAGS_OUTPUT "${EXTRACTED_IDS}")
string(APPEND TAGS_OUTPUT "\t\t\n")
string(SHA1 TAGS_OUTPUT_HASH "${TAGS_OUTPUT}")

# Update the output file only if it changed; this prevents CMake from calling
# source-highlight if there is no point in rebuilding the highlighted
# source files
if(EXISTS "${OUTPUT_FILE}")
  file(SHA1 "${OUTPUT_FILE}" OUTPUT_FILE_HASH)
  if(NOT "${OUTPUT_FILE_HASH}" STREQUAL "${TAGS_OUTPUT_HASH}")
    file(WRITE "${OUTPUT_FILE}" "${TAGS_OUTPUT}")
  endif()
else()
  file(WRITE "${OUTPUT_FILE}" "${TAGS_OUTPUT}")
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/helpers.cmake0000644000175100001710000000033600000000000024153 0ustar00runnerdocker00000000000000macro(tristate OPTION_NAME DESCRIPTION DEFAULT_VALUE)
  set(${OPTION_NAME} "${DEFAULT_VALUE}" CACHE STRING "${DESCRIPTION}")
  set_property(CACHE ${OPTION_NAME} PROPERTY STRINGS AUTO ON OFF)
endmacro()

include(PadString)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/igraph-config.cmake.in0000644000175100001710000000144600000000000025636 0ustar00runnerdocker00000000000000set(IGRAPH_VERSION "@PACKAGE_VERSION_BASE@")
@PACKAGE_INIT@

include("${CMAKE_CURRENT_LIST_DIR}/igraph-targets.cmake")

# Check whether C++ support is enabled; this is needed to ensure that programs
# that are dependent on igraph will get linked with the C++ linker and not the
# "plain" C linker
get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
if("CXX" IN_LIST LANGUAGES)
  # This is okay
else()
  message(FATAL_ERROR "Please enable C++ support in your project if you are linking to igraph.")
endif()

# Turn on CMP0012 because the following if() conditionals will use "ON" and
# "OFF" verbatim and they must be evaluated as booleans
cmake_policy(PUSH)
cmake_policy(SET CMP0012 NEW)
if(@IGRAPH_OPENMP_SUPPORT@)
  find_package(OpenMP)
endif()
cmake_policy(POP)

check_required_components(igraph)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/lto.cmake0000644000175100001710000000132300000000000023304 0ustar00runnerdocker00000000000000include(helpers)

tristate(IGRAPH_ENABLE_LTO "Enable link-time optimization" OFF)

include(CheckIPOSupported)

if(IGRAPH_ENABLE_LTO)
  # this matches both ON and AUTO
  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_NOT_SUPPORTED_REASON)
  if(IGRAPH_ENABLE_LTO STREQUAL "AUTO")
    # autodetection
    set(IGRAPH_ENABLE_LTO ${IPO_SUPPORTED})
    if(IPO_SUPPORTED)
      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
    endif()
  elseif(IPO_SUPPORTED)
    # user wanted LTO and the compiler supports it
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
  else()
    # user wanted LTO and the compiler does not support it
    message(FATAL_ERROR "Link-time optimization not supported on this compiler")
  endif()
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/packaging.cmake0000644000175100001710000000442200000000000024435 0ustar00runnerdocker00000000000000set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "igraph library")
set(CPACK_PACKAGE_HOMEPAGE_URL "https://igraph.org")
set(CPACK_PACKAGE_VENDOR "The igraph development team")

set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")

if(TARGET html)
  # Alias "dist" to "package_source"
  add_custom_target(dist
    COMMAND "${CMAKE_COMMAND}"
      --build "${CMAKE_BINARY_DIR}"
      --target package_source
    VERBATIM
    USES_TERMINAL
  )

  # We want to include the HTML docs in the source package so add a dependency
  add_dependencies(dist html)
else()
  add_custom_target(dist
    COMMAND "${CMAKE_COMMAND}" -E false
    COMMENT
      "Cannot build source tarball since the HTML documentation was not built."
    VERBATIM
    USES_TERMINAL
  )
endif()

#############################################################################
## Configuration of the source package
#############################################################################

# Set source package name and format
set(CPACK_SOURCE_PACKAGE_FILE_NAME "igraph-${CMAKE_PROJECT_VERSION}")
set(CPACK_SOURCE_GENERATOR "TGZ")

# Declare what to include in the source tarball. Unfortunately we can only
# declare full directories here, not individual files.
set(
    CPACK_SOURCE_INSTALLED_DIRECTORIES
    "${CMAKE_SOURCE_DIR}/doc;/doc"
    "${CMAKE_SOURCE_DIR}/etc/cmake;/etc/cmake"
    "${CMAKE_SOURCE_DIR}/examples;/examples"
    "${CMAKE_SOURCE_DIR}/include;/include"
    "${CMAKE_SOURCE_DIR}/interfaces;/interfaces"
    "${CMAKE_SOURCE_DIR}/msvc/include;/msvc/include"
    "${CMAKE_SOURCE_DIR}/src;/src"
    "${CMAKE_SOURCE_DIR}/tests;/tests"
    "${CMAKE_SOURCE_DIR}/vendor;/vendor"
)

# CPack is pretty dumb as it can only copy full directories (sans the ignored
# files) to the target tarball by default. In some cases it is easier to
# whitelist files to be copied; we use CPACK_INSTALL_SCRIPT for that.
set(CPACK_INSTALL_SCRIPT "${CMAKE_SOURCE_DIR}/etc/cmake/cpack_install_script.cmake")

# Ignore the build and all hidden folders
set(
    CPACK_SOURCE_IGNORE_FILES
    "\\\\..*/"
    "\\\\.l$"
    "\\\\.y$"
    "${CMAKE_SOURCE_DIR}/build"
)

#############################################################################
## Now we can include CPack
#############################################################################

include(CPack)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/pkgconfig_helpers.cmake0000644000175100001710000000554100000000000026205 0ustar00runnerdocker00000000000000# Helper functions for generating a nicely formatted igraph.pc file from
# igraph.pc.in

include(JoinPaths)
include(CheckCXXSymbolExists)

# Converts the name of a library file (or framework on macOS) into an
# appropriate linker flag (-lsomething or -framework something.framework).
# Returns the input intact if its extension does not look like a shared or
# static library extension.
function(convert_library_file_to_flags output_variable input)
  get_filename_component(input_filename ${input} NAME_WE)
  get_filename_component(input_extension ${input} LAST_EXT)
  if(input_extension STREQUAL ${CMAKE_SHARED_LIBRARY_SUFFIX} OR input_extension STREQUAL ${CMAKE_STATIC_LIBRARY_SUFFIX})
    string(REGEX REPLACE "^${CMAKE_SHARED_LIBRARY_PREFIX}" "" input_stripped ${input_filename})
    set("${output_variable}" "-l${input_stripped}" PARENT_SCOPE)
  elseif(APPLE AND input_extension STREQUAL ".framework")
    set("${output_variable}" "-framework ${input_filename}" PARENT_SCOPE)
  else()
    set("${output_variable}" "${input}" PARENT_SCOPE)
  endif()
endfunction()

if(MATH_LIBRARY)
  set(PKGCONFIG_LIBS_PRIVATE "-lm")
else()
  set(PKGCONFIG_LIBS_PRIVATE "")
endif()

if(NOT MSVC)
  check_cxx_symbol_exists(_LIBCPP_VERSION "vector" USING_LIBCXX)
  check_cxx_symbol_exists(__GLIBCXX__ "vector" USING_LIBSTDCXX)
  if(USING_LIBCXX)
    set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lc++")
  elseif(USING_LIBSTDCXX)
    set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lstdc++")
  endif()
endif()

if(IGRAPH_GRAPHML_SUPPORT)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lxml2 -lz")
endif()
if(NOT IGRAPH_USE_INTERNAL_GMP)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lgmp")
endif()
if(NOT IGRAPH_USE_INTERNAL_BLAS)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lblas")
endif()
if(NOT IGRAPH_USE_INTERNAL_CXSPARSE)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lcxsparse")
endif()
if(IGRAPH_GLPK_SUPPORT AND NOT IGRAPH_USE_INTERNAL_GLPK)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lglpk")
endif()
if(NOT IGRAPH_USE_INTERNAL_LAPACK)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -llapack")
endif()
if(NOT IGRAPH_USE_INTERNAL_ARPACK)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -larpack")
endif()
if(NOT IGRAPH_USE_INTERNAL_PLFIT)
  set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} -lplfit")
endif()
if(IGRAPH_OPENMP_SUPPORT AND OpenMP_FOUND)
  foreach(CURRENT_LIB ${OpenMP_C_LIB_NAMES})
    convert_library_file_to_flags(CURRENT_LIB "${OpenMP_${CURRENT_LIB}_LIBRARY}")
    set(PKGCONFIG_LIBS_PRIVATE "${PKGCONFIG_LIBS_PRIVATE} ${CURRENT_LIB}")
  endforeach()
endif()

join_paths(PKGCONFIG_LIBDIR "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}")
join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
configure_file(
  ${PROJECT_SOURCE_DIR}/igraph.pc.in
  ${PROJECT_BINARY_DIR}/igraph.pc
  @ONLY
)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/run_legacy_test.cmake0000644000175100001710000000610100000000000025674 0ustar00runnerdocker00000000000000# Runs a legacy autotools-based test with a file containing the expected output
#
# Parameters of the script:
#
# - TEST_EXECUTABLE: full path of the compiled test executable
# - EXPECTED_OUTPUT_FILE: full path of the file containing the expected output
# - OBSERVED_OUTPUT_FILE: full path of the file where the observed output
#   can be written
# - DIFF_FILE: full path of the file where the differences between the expectd
#   and the observed output should be written
# - DIFF_TOOL: full path to a "diff" tool on the system of the user, if present
# - FC_TOOL: full path to a "fc" tool on the system of the user, if present
# - IGRAPH_VERSION: version string of igraph that should be replaced in
#   expected outputs

function(print_file FILENAME)
  # Replacement of "cmake -E cat" for older CMake versions. cat was added in
  # CMake 3.18
  file(TO_NATIVE_PATH "${FILENAME}" FILENAME_NATIVE)
  if(UNIX OR APPLE)
    # Most likely Linux or macOS
    execute_process(COMMAND "/bin/sh" "-c" "cat ${FILENAME_NATIVE}")
  elseif(WIN32)
    # Most likely Windows
    execute_process(COMMAND "cmd" "/c" "type" "${FILENAME_NATIVE}")
  endif()
endfunction()

get_filename_component(WORK_DIR ${EXPECTED_OUTPUT_FILE} DIRECTORY)

execute_process(
  COMMAND ${TEST_EXECUTABLE}
  WORKING_DIRECTORY ${WORK_DIR}
  RESULT_VARIABLE ERROR_CODE
  OUTPUT_VARIABLE OBSERVED_OUTPUT
)

if(ERROR_CODE EQUAL 77)
  message(STATUS "Test skipped")
elseif(ERROR_CODE)
  set(MESSAGE "Test exited abnormally with error: ${ERROR_CODE}")
  file(WRITE ${OBSERVED_OUTPUT_FILE} "${MESSAGE}\n=========================================\n${OBSERVED_OUTPUT}")
  print_file("${OBSERVED_OUTPUT_FILE}")
  file(REMOVE ${DIFF_FILE})
  message(FATAL_ERROR "Exiting test.")
else()
  string(REPLACE ${IGRAPH_VERSION} "\@VERSION\@" OBSERVED_OUTPUT "${OBSERVED_OUTPUT}")
  file(WRITE ${OBSERVED_OUTPUT_FILE} "${OBSERVED_OUTPUT}")

  execute_process(
    COMMAND ${CMAKE_COMMAND} -E compare_files --ignore-eol
    ${EXPECTED_OUTPUT_FILE} ${OBSERVED_OUTPUT_FILE}
    RESULT_VARIABLE ARE_DIFFERENT
  )

  if(ARE_DIFFERENT)
    if(DIFF_TOOL)
      execute_process(
        COMMAND ${DIFF_TOOL} -u ${EXPECTED_OUTPUT_FILE} ${OBSERVED_OUTPUT_FILE}
        OUTPUT_FILE ${DIFF_FILE}
      )
    elseif(FC_TOOL)
      file(TO_NATIVE_PATH "${EXPECTED_OUTPUT_FILE}" REAL_EXPECTED_OUTPUT_FILE)
      file(TO_NATIVE_PATH "${OBSERVED_OUTPUT_FILE}" REAL_OBSERVED_OUTPUT_FILE)
      execute_process(
        COMMAND ${FC_TOOL} /A ${REAL_EXPECTED_OUTPUT_FILE} ${REAL_OBSERVED_OUTPUT_FILE}
        OUTPUT_FILE ${DIFF_FILE}
      )
    endif()

    message(STATUS "Test case output differs from the expected output")
    if(EXISTS ${DIFF_FILE})
      message(STATUS "See diff below:")
      message(STATUS "-------------------------------------------------------")
      print_file("${DIFF_FILE}")
      message(STATUS "-------------------------------------------------------")
    else()
      message(STATUS "Diff omitted; no diff tool was installed.")
    endif()
    message(FATAL_ERROR "Exiting test.")
  else()
    file(REMOVE ${DIFF_FILE})
  endif()

  file(REMOVE ${OBSERVED_OUTPUT_FILE})
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/sanitizers.cmake0000644000175100001710000000646700000000000024717 0ustar00runnerdocker00000000000000#
# Copyright (C) 2018 by George Cave - gcave@stablecoder.ca
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.

set(
  USE_SANITIZER
  ""
  CACHE
    STRING
    "Compile with a sanitizer. Options are: Address, Memory, MemoryWithOrigins, Undefined, Thread, Leak, 'Address;Undefined'"
  )

function(append value)
  foreach(variable ${ARGN})
    set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
  endforeach(variable)
endfunction()

if(USE_SANITIZER)

  if(UNIX)

    append("-fno-omit-frame-pointer" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)

    if(uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
      append("-Og" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    endif()

    if(USE_SANITIZER MATCHES "([Aa]ddress);([Uu]ndefined)"
       OR USE_SANITIZER MATCHES "([Uu]ndefined);([Aa]ddress)")
      message(STATUS "Building with Address, Undefined sanitizers")
      append("-fsanitize=address,undefined" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    elseif("${USE_SANITIZER}" MATCHES "([Aa]ddress)")
      # Optional: -fno-optimize-sibling-calls -fsanitize-address-use-after-scope
      message(STATUS "Building with Address sanitizer")
      append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    elseif(USE_SANITIZER MATCHES "([Mm]emory([Ww]ith[Oo]rigins)?)")
      # Optional: -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2
      append("-fsanitize=memory" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
      if(USE_SANITIZER MATCHES "([Mm]emory[Ww]ith[Oo]rigins)")
        message(STATUS "Building with MemoryWithOrigins sanitizer")
        append("-fsanitize-memory-track-origins" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
      else()
        message(STATUS "Building with Memory sanitizer")
      endif()
    elseif(USE_SANITIZER MATCHES "([Uu]ndefined)")
      message(STATUS "Building with Undefined sanitizer")
      append("-fsanitize=undefined" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
      if(EXISTS "${BLACKLIST_FILE}")
        append("-fsanitize-blacklist=${BLACKLIST_FILE}" CMAKE_C_FLAGS
               CMAKE_CXX_FLAGS)
      endif()
    elseif(USE_SANITIZER MATCHES "([Tt]hread)")
      message(STATUS "Building with Thread sanitizer")
      append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    elseif(USE_SANITIZER MATCHES "([Ll]eak)")
      message(STATUS "Building with Leak sanitizer")
      append("-fsanitize=leak" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    else()
      message(
        FATAL_ERROR "Unsupported value of USE_SANITIZER: ${USE_SANITIZER}")
    endif()
  elseif(MSVC)
    if(USE_SANITIZER MATCHES "([Aa]ddress)")
      message(STATUS "Building with Address sanitizer")
      append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
    else()
      message(
        FATAL_ERROR
          "This sanitizer not yet supported in the MSVC environment: ${USE_SANITIZER}"
        )
    endif()
  else()
    message(FATAL_ERROR "USE_SANITIZER is not supported on this platform.")
  endif()

endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/summary.cmake0000644000175100001710000000536300000000000024213 0ustar00runnerdocker00000000000000function(print_bool HEADING VAR)
  if(${VAR})
    set(LABEL "yes")
  else()
    set(LABEL "no")
  endif()
  print_str(${HEADING} ${LABEL})
endfunction()

function(print_str HEADING LABEL)
  string(LENGTH "${HEADING}" HEADING_LENGTH)
  math(EXPR REMAINING_WIDTH "30 - ${HEADING_LENGTH}")

  if("${LABEL}" STREQUAL "")
    pad_string(PADDED ${REMAINING_WIDTH} " " "${ARGN}")
  else()
    pad_string(PADDED ${REMAINING_WIDTH} " " "${LABEL}")
  endif()

  message(STATUS "${HEADING}: ${PADDED}")
endfunction()

#############################################################################

set(ALL_DEPENDENCIES ${REQUIRED_DEPENDENCIES} ${OPTIONAL_DEPENDENCIES} ${VENDORED_DEPENDENCIES})
list(SORT ALL_DEPENDENCIES CASE INSENSITIVE)

message(STATUS " ")
message(STATUS "-----[ Build configuration ]----")
print_str("Version" "${PACKAGE_VERSION}")
print_str("CMake build type" "${CMAKE_BUILD_TYPE}" "default")
if(BUILD_SHARED_LIBS)
  message(STATUS "Library type:             shared")
else()
  message(STATUS "Library type:             static")
endif()
if(USE_CCACHE)
  if(CCACHE_PROGRAM)
    message(STATUS "Compiler cache:           ccache")
  endif()
else()
  message(STATUS "Compiler cache:         disabled")
endif()

message(STATUS " ")
message(STATUS "----------[ Features ]----------")
print_bool("GLPK for optimization" IGRAPH_GLPK_SUPPORT)
print_bool("Reading GraphML files" IGRAPH_GRAPHML_SUPPORT)
print_bool("Thread-local storage" IGRAPH_ENABLE_TLS)
print_bool("Link-time optimization" IGRAPH_ENABLE_LTO)
message(STATUS " ")

message(STATUS "--------[ Dependencies ]--------")
foreach(DEPENDENCY ${ALL_DEPENDENCIES})
  list(FIND VENDORED_DEPENDENCIES "${DEPENDENCY}" INDEX)
  if(INDEX EQUAL -1)
    print_bool("${DEPENDENCY}" ${DEPENDENCY}_FOUND)
  else()
    print_str("${DEPENDENCY}" "vendored")
  endif()
endforeach()
message(STATUS " ")

message(STATUS "-----------[ Testing ]----------")
if(DIFF_TOOL)
  print_str("Diff tool" "diff")
elseif(FC_TOOL)
  print_str("Diff tool" "fc")
else()
  print_str("Diff tool" "not found")
endif()
print_str("Sanitizers" "${USE_SANITIZER}" "none")
print_bool("Code coverage" IGRAPH_ENABLE_CODE_COVERAGE)
print_bool("Verify 'finally' stack" IGRAPH_VERIFY_FINALLY_STACK)
message(STATUS " ")

message(STATUS "--------[ Documentation ]-------")
print_bool("HTML" HTML_DOC_BUILD_SUPPORTED)
print_bool("PDF" PDF_DOC_BUILD_SUPPORTED)
message(STATUS " ")

set(MISSING_DEPENDENCIES)
foreach(DEPENDENCY ${REQUIRED_DEPENDENCIES})
  if(NOT ${DEPENDENCY}_FOUND)
    list(APPEND MISSING_DEPENDENCIES ${DEPENDENCY})
  endif()
endforeach()

if(MISSING_DEPENDENCIES)
  list(JOIN MISSING_DEPENDENCIES ", " GLUED)
  message(FATAL_ERROR "The following dependencies are missing: ${GLUED}")
else()
  message(STATUS "igraph configured successfully.")
  message(STATUS " ")
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/test_helpers.cmake0000644000175100001710000001131500000000000025211 0ustar00runnerdocker00000000000000include(CMakeParseArguments)

find_program(DIFF_TOOL diff)
if(NOT DIFF_TOOL)
  find_program(FC_TOOL fc)
endif()

function(add_legacy_test FOLDER NAME NAMESPACE)
  set(TARGET_NAME ${NAMESPACE}_${NAME})
  set(TEST_NAME "${NAMESPACE}::${NAME}")

  add_executable(${TARGET_NAME} EXCLUDE_FROM_ALL ${PROJECT_SOURCE_DIR}/${FOLDER}/${NAME}.c)
  use_all_warnings(${TARGET_NAME})
  add_dependencies(build_tests ${TARGET_NAME})
  target_link_libraries(${TARGET_NAME} PRIVATE igraph)

  if (NOT BUILD_SHARED_LIBS)
    # Add a compiler definition required to compile igraph in static mode
    target_compile_definitions(${TARGET_NAME} PRIVATE IGRAPH_STATIC)
  endif()

  # Some tests depend on internal igraph headers so we also have to add src/
  # to the include path even though it's not part of the public API
  target_include_directories(
    ${TARGET_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/src ${CMAKE_BINARY_DIR}/src
  )

  # Some tests include cs.h from CXSparse. The following ensures that the
  # correct version is included, depending on whether CXSparse is vendored
  target_include_directories(
    ${TARGET_NAME} PRIVATE
    $<$:$>
    $<$:${CXSPARSE_INCLUDE_DIRS}>
  )

  if (MSVC)
    # Add MSVC-specific include path for some headers that are missing on Windows
    target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/msvc/include)
  endif()

  set(EXPECTED_OUTPUT_FILE ${CMAKE_SOURCE_DIR}/${FOLDER}/${NAME}.out)
  set(OBSERVED_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.out)
  set(DIFF_FILE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.diff)
  get_filename_component(WORK_DIR ${EXPECTED_OUTPUT_FILE} DIRECTORY)

  if(EXISTS ${EXPECTED_OUTPUT_FILE})
    add_test(
      NAME ${TEST_NAME}
      COMMAND ${CMAKE_COMMAND}
        -DTEST_EXECUTABLE=$
        -DEXPECTED_OUTPUT_FILE=${EXPECTED_OUTPUT_FILE}
        -DOBSERVED_OUTPUT_FILE=${OBSERVED_OUTPUT_FILE}
        -DDIFF_FILE=${DIFF_FILE}
        -DDIFF_TOOL=${DIFF_TOOL}
        -DFC_TOOL=${FC_TOOL}
        -DIGRAPH_VERSION=${PACKAGE_VERSION}
        -P ${CMAKE_SOURCE_DIR}/etc/cmake/run_legacy_test.cmake
    )
    set_property(TEST ${TEST_NAME} PROPERTY SKIP_REGULAR_EXPRESSION "Test skipped")
  else()
    add_test(
      NAME ${TEST_NAME}
      COMMAND ${TARGET_NAME}
      WORKING_DIRECTORY ${WORK_DIR}
    )
    set_property(TEST ${TEST_NAME} PROPERTY SKIP_RETURN_CODE 77)
  endif()
  if (WIN32 AND BUILD_SHARED_LIBS)
    # On Windows the built igraph.dll is not automatically found by the tests. We therefore
    # add the dir that contains the built igraph.dll to the path environment variable
    # so that igraph.dll is found when running the tests.
    SET(IGRAPH_LIBDIR $)

    # The next line is necessitated by MinGW on Windows. MinGW uses forward slashes in
    # IGRAPH_LIBDIR, but we need to supply CTest with backslashes because CTest is executed
    # in a cmd.exe shell. We therefore explicitly ensure that that path is transformed to a
    # native path.
    file(TO_NATIVE_PATH "${IGRAPH_LIBDIR}" IGRAPH_LIBDIR)

    # Semicolons are used as list separators in CMake so we need to escape them in the PATH,
    # otherwise the PATH envvar gets split by CMake before it passes the PATH on to CTest.
    # We process each path separately to ensure it is a proper path. In particular, we need
    # to ensure that a trailing backslash is not incorrectly interpreted as an escape
    # character. Presumably, with cmake 3.20, this can be changed to using TO_NATIVE_PATH_LIST.
    SET(TEST_PATHS)
    foreach (PATH $ENV{PATH})
      file(TO_NATIVE_PATH "${PATH}" CORRECT_PATH)
      # Remove trailing backslash
      STRING(REGEX REPLACE "\\$" "" CORRECT_PATH ${CORRECT_PATH})
      list(APPEND TEST_PATHS ${CORRECT_PATH})
    endforeach()

    # Join all paths in a single string, separated by an escaped semi-colon.
    string(JOIN "\;" CORRECT_PATHS ${TEST_PATHS})
    SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES ENVIRONMENT "PATH=${IGRAPH_LIBDIR}\;${CORRECT_PATHS}" )
  endif()
endfunction()

function(add_legacy_tests)
  cmake_parse_arguments(
    PARSED "" "FOLDER" "NAMES;LIBRARIES" ${ARGN}
  )
  foreach(NAME ${PARSED_NAMES})
    add_legacy_test(${PARSED_FOLDER} ${NAME} test)
    if(PARSED_LIBRARIES)
      target_link_libraries(test_${NAME} PRIVATE ${PARSED_LIBRARIES})
    endif()
  endforeach()
endfunction()

function(add_examples)
  cmake_parse_arguments(
    PARSED "" "FOLDER" "NAMES;LIBRARIES" ${ARGN}
  )
  foreach(NAME ${PARSED_NAMES})
    add_legacy_test(${PARSED_FOLDER} ${NAME} example)
    if(PARSED_LIBRARIES)
      target_link_libraries(example_${NAME} PRIVATE ${PARSED_LIBRARIES})
    endif()
  endforeach()
endfunction()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/tls.cmake0000644000175100001710000000073600000000000023317 0ustar00runnerdocker00000000000000option(IGRAPH_ENABLE_TLS "Enable thread-local storage for igraph global variables" OFF)

if(IGRAPH_ENABLE_TLS)
  include(CheckTLSSupport)
  check_tls_support(TLS_KEYWORD)

  if(NOT TLS_KEYWORD)
    message(FATAL_ERROR "Thread-local storage not supported on this compiler")
  endif()

  # TODO: we should probably set this only if we are building igraph with
  # internal-everything
  set(IGRAPH_THREAD_SAFE YES)
else()
  set(TLS_KEYWORD "")
  set(IGRAPH_THREAD_SAFE NO)
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/etc/cmake/version.cmake0000644000175100001710000000736700000000000024211 0ustar00runnerdocker00000000000000include(GetGitRevisionDescription)

# At this point, igraph is either the main CMake project or a subproject of
# another project. CMAKE_SOURCE_DIR would point to the root of the main
# project if we are a subproject so we cannot use that; we need to use
# CMAKE_CURRENT_SOURCE_DIR to get the directory containing the CMakeLists.txt
# file that version.cmake was included from, which is the top-level
# CMakeLists.txt file of igraph itself
set(VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/IGRAPH_VERSION")
set(NEXT_VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/NEXT_VERSION")

if(EXISTS "${VERSION_FILE}")
  file(READ "${VERSION_FILE}" PACKAGE_VERSION)
  string(STRIP "${PACKAGE_VERSION}" PACKAGE_VERSION)
  message(STATUS "Version number: ${PACKAGE_VERSION}")
else()
  find_package(Git QUIET)
  if(Git_FOUND)
    git_describe(PACKAGE_VERSION)
  else()
    set(PACKAGE_VERSION "NOTFOUND")
  endif()

  if(PACKAGE_VERSION)
    if(EXISTS "${NEXT_VERSION_FILE}")
      file(READ "${NEXT_VERSION_FILE}" PACKAGE_VERSION)
      string(STRIP "${PACKAGE_VERSION}" PACKAGE_VERSION)
      get_git_head_revision(GIT_REFSPEC GIT_COMMIT_HASH)
      string(SUBSTRING "${GIT_COMMIT_HASH}" 0 8 GIT_COMMIT_HASH_SHORT)
      string(APPEND PACKAGE_VERSION "-dev+${GIT_COMMIT_HASH_SHORT}")
    endif()
    message(STATUS "Version number from Git: ${PACKAGE_VERSION}")
  elseif(EXISTS "${NEXT_VERSION_FILE}")
    file(READ "${NEXT_VERSION_FILE}" PACKAGE_VERSION)
    string(STRIP "${PACKAGE_VERSION}" PACKAGE_VERSION)
    string(APPEND PACKAGE_VERSION "-dev")
    message(STATUS "Version number: ${PACKAGE_VERSION}")
  else()
    message(STATUS "Cannot find out the version number of this package; IGRAPH_VERSION is missing.")
    message(STATUS "")
    message(STATUS "The official igraph tarballs should contain this file, therefore you are")
    message(STATUS "most likely trying to compile a development version yourself. The development")
    message(STATUS "versions need Git to be able to determine the version number of igraph.")
    message(STATUS "")
    if(Git_FOUND)
      message(STATUS "It seems like you do have Git but it failed to determine the package version number.")
      message(STATUS "")
      message(STATUS "Git was found at: ${GIT_EXECUTABLE}")
      message(STATUS "The version number detection failed with: ${PACKAGE_VERSION}")
      message(STATUS "")
      message(STATUS "Most frequently this is caused by a shallow Git checkout that contains no tags in the history.")
    else()
      message(STATUS "Please install Git, make sure it is in your path, and then try again.")
    endif()
    message(STATUS "")
    message(FATAL_ERROR "Configuration failed.")
  endif()
endif()

string(REGEX MATCH "^[^-]+" PACKAGE_VERSION_BASE "${PACKAGE_VERSION}")
string(
  REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9+])" "\\1;\\2;\\3"
  PACKAGE_VERSION_PARTS "${PACKAGE_VERSION_BASE}"
)
list(GET PACKAGE_VERSION_PARTS 0 PACKAGE_VERSION_MAJOR)
list(GET PACKAGE_VERSION_PARTS 1 PACKAGE_VERSION_MINOR)
list(GET PACKAGE_VERSION_PARTS 2 PACKAGE_VERSION_PATCH)

if(PACKAGE_VERSION MATCHES "^[^-]+-")
  string(
    REGEX REPLACE "^[^-]+-([^+]*)" "\\1" PACKAGE_VERSION_PRERELEASE "${PACKAGE_VERSION}"
  )
else()
  set(PACKAGE_VERSION_PRERELEASE "cmake-experimental")
endif()

# Add a target that we can use to generate an IGRAPH_VERSION file in the build
# folder, for the sake of creating a tarball. This is needed only if igraph is
# the main project
if(NOT PROJECT_NAME)
  add_custom_target(
    versionfile
    BYPRODUCTS "${CMAKE_BINARY_DIR}/IGRAPH_VERSION"
    COMMAND "${CMAKE_COMMAND}"
      -DIGRAPH_VERSION="${PACKAGE_VERSION}"
      -DVERSION_FILE_PATH="${CMAKE_BINARY_DIR}/IGRAPH_VERSION"
      -P "${CMAKE_SOURCE_DIR}/etc/cmake/create_igraph_version_file.cmake"
    COMMENT "Generating IGRAPH_VERSION file in build folder"
  )
endif()
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392
igraph-0.9.9/vendor/source/igraph/examples/0000755000175100001710000000000000000000000021470 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4671402
igraph-0.9.9/vendor/source/igraph/examples/simple/0000755000175100001710000000000000000000000022761 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/adjlist.c0000644000175100001710000000304400000000000024560 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g, g2;
    igraph_adjlist_t adjlist;
    igraph_bool_t iso;

    /* Create a directed out-tree, convert it into an adjacency list
     * representation, then reconstruct the graph from the tree and check
     * whether the two are isomorphic (they should be) */

    igraph_tree(&g, 42, 3, IGRAPH_TREE_OUT);
    igraph_adjlist_init(&g, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    igraph_adjlist(&g2, &adjlist, IGRAPH_OUT, /* duplicate = */ 0);
    igraph_isomorphic(&g, &g2, &iso);
    if (!iso) {
        return 1;
    }
    igraph_adjlist_destroy(&adjlist);
    igraph_destroy(&g2);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/ak-4102.max0000644000175100001710000143633600000000000024467 0ustar00runnerdocker00000000000000c very bad maxflow problem
p max 16414 24619
n 1 s
n 2 t
a 3 4 4103
a 3 4106 1
a 4 5 4102
a 4 4106 1
a 5 6 4101
a 5 4106 1
a 6 7 4100
a 6 4106 1
a 7 8 4099
a 7 4106 1
a 8 9 4098
a 8 4106 1
a 9 10 4097
a 9 4106 1
a 10 11 4096
a 10 4106 1
a 11 12 4095
a 11 4106 1
a 12 13 4094
a 12 4106 1
a 13 14 4093
a 13 4106 1
a 14 15 4092
a 14 4106 1
a 15 16 4091
a 15 4106 1
a 16 17 4090
a 16 4106 1
a 17 18 4089
a 17 4106 1
a 18 19 4088
a 18 4106 1
a 19 20 4087
a 19 4106 1
a 20 21 4086
a 20 4106 1
a 21 22 4085
a 21 4106 1
a 22 23 4084
a 22 4106 1
a 23 24 4083
a 23 4106 1
a 24 25 4082
a 24 4106 1
a 25 26 4081
a 25 4106 1
a 26 27 4080
a 26 4106 1
a 27 28 4079
a 27 4106 1
a 28 29 4078
a 28 4106 1
a 29 30 4077
a 29 4106 1
a 30 31 4076
a 30 4106 1
a 31 32 4075
a 31 4106 1
a 32 33 4074
a 32 4106 1
a 33 34 4073
a 33 4106 1
a 34 35 4072
a 34 4106 1
a 35 36 4071
a 35 4106 1
a 36 37 4070
a 36 4106 1
a 37 38 4069
a 37 4106 1
a 38 39 4068
a 38 4106 1
a 39 40 4067
a 39 4106 1
a 40 41 4066
a 40 4106 1
a 41 42 4065
a 41 4106 1
a 42 43 4064
a 42 4106 1
a 43 44 4063
a 43 4106 1
a 44 45 4062
a 44 4106 1
a 45 46 4061
a 45 4106 1
a 46 47 4060
a 46 4106 1
a 47 48 4059
a 47 4106 1
a 48 49 4058
a 48 4106 1
a 49 50 4057
a 49 4106 1
a 50 51 4056
a 50 4106 1
a 51 52 4055
a 51 4106 1
a 52 53 4054
a 52 4106 1
a 53 54 4053
a 53 4106 1
a 54 55 4052
a 54 4106 1
a 55 56 4051
a 55 4106 1
a 56 57 4050
a 56 4106 1
a 57 58 4049
a 57 4106 1
a 58 59 4048
a 58 4106 1
a 59 60 4047
a 59 4106 1
a 60 61 4046
a 60 4106 1
a 61 62 4045
a 61 4106 1
a 62 63 4044
a 62 4106 1
a 63 64 4043
a 63 4106 1
a 64 65 4042
a 64 4106 1
a 65 66 4041
a 65 4106 1
a 66 67 4040
a 66 4106 1
a 67 68 4039
a 67 4106 1
a 68 69 4038
a 68 4106 1
a 69 70 4037
a 69 4106 1
a 70 71 4036
a 70 4106 1
a 71 72 4035
a 71 4106 1
a 72 73 4034
a 72 4106 1
a 73 74 4033
a 73 4106 1
a 74 75 4032
a 74 4106 1
a 75 76 4031
a 75 4106 1
a 76 77 4030
a 76 4106 1
a 77 78 4029
a 77 4106 1
a 78 79 4028
a 78 4106 1
a 79 80 4027
a 79 4106 1
a 80 81 4026
a 80 4106 1
a 81 82 4025
a 81 4106 1
a 82 83 4024
a 82 4106 1
a 83 84 4023
a 83 4106 1
a 84 85 4022
a 84 4106 1
a 85 86 4021
a 85 4106 1
a 86 87 4020
a 86 4106 1
a 87 88 4019
a 87 4106 1
a 88 89 4018
a 88 4106 1
a 89 90 4017
a 89 4106 1
a 90 91 4016
a 90 4106 1
a 91 92 4015
a 91 4106 1
a 92 93 4014
a 92 4106 1
a 93 94 4013
a 93 4106 1
a 94 95 4012
a 94 4106 1
a 95 96 4011
a 95 4106 1
a 96 97 4010
a 96 4106 1
a 97 98 4009
a 97 4106 1
a 98 99 4008
a 98 4106 1
a 99 100 4007
a 99 4106 1
a 100 101 4006
a 100 4106 1
a 101 102 4005
a 101 4106 1
a 102 103 4004
a 102 4106 1
a 103 104 4003
a 103 4106 1
a 104 105 4002
a 104 4106 1
a 105 106 4001
a 105 4106 1
a 106 107 4000
a 106 4106 1
a 107 108 3999
a 107 4106 1
a 108 109 3998
a 108 4106 1
a 109 110 3997
a 109 4106 1
a 110 111 3996
a 110 4106 1
a 111 112 3995
a 111 4106 1
a 112 113 3994
a 112 4106 1
a 113 114 3993
a 113 4106 1
a 114 115 3992
a 114 4106 1
a 115 116 3991
a 115 4106 1
a 116 117 3990
a 116 4106 1
a 117 118 3989
a 117 4106 1
a 118 119 3988
a 118 4106 1
a 119 120 3987
a 119 4106 1
a 120 121 3986
a 120 4106 1
a 121 122 3985
a 121 4106 1
a 122 123 3984
a 122 4106 1
a 123 124 3983
a 123 4106 1
a 124 125 3982
a 124 4106 1
a 125 126 3981
a 125 4106 1
a 126 127 3980
a 126 4106 1
a 127 128 3979
a 127 4106 1
a 128 129 3978
a 128 4106 1
a 129 130 3977
a 129 4106 1
a 130 131 3976
a 130 4106 1
a 131 132 3975
a 131 4106 1
a 132 133 3974
a 132 4106 1
a 133 134 3973
a 133 4106 1
a 134 135 3972
a 134 4106 1
a 135 136 3971
a 135 4106 1
a 136 137 3970
a 136 4106 1
a 137 138 3969
a 137 4106 1
a 138 139 3968
a 138 4106 1
a 139 140 3967
a 139 4106 1
a 140 141 3966
a 140 4106 1
a 141 142 3965
a 141 4106 1
a 142 143 3964
a 142 4106 1
a 143 144 3963
a 143 4106 1
a 144 145 3962
a 144 4106 1
a 145 146 3961
a 145 4106 1
a 146 147 3960
a 146 4106 1
a 147 148 3959
a 147 4106 1
a 148 149 3958
a 148 4106 1
a 149 150 3957
a 149 4106 1
a 150 151 3956
a 150 4106 1
a 151 152 3955
a 151 4106 1
a 152 153 3954
a 152 4106 1
a 153 154 3953
a 153 4106 1
a 154 155 3952
a 154 4106 1
a 155 156 3951
a 155 4106 1
a 156 157 3950
a 156 4106 1
a 157 158 3949
a 157 4106 1
a 158 159 3948
a 158 4106 1
a 159 160 3947
a 159 4106 1
a 160 161 3946
a 160 4106 1
a 161 162 3945
a 161 4106 1
a 162 163 3944
a 162 4106 1
a 163 164 3943
a 163 4106 1
a 164 165 3942
a 164 4106 1
a 165 166 3941
a 165 4106 1
a 166 167 3940
a 166 4106 1
a 167 168 3939
a 167 4106 1
a 168 169 3938
a 168 4106 1
a 169 170 3937
a 169 4106 1
a 170 171 3936
a 170 4106 1
a 171 172 3935
a 171 4106 1
a 172 173 3934
a 172 4106 1
a 173 174 3933
a 173 4106 1
a 174 175 3932
a 174 4106 1
a 175 176 3931
a 175 4106 1
a 176 177 3930
a 176 4106 1
a 177 178 3929
a 177 4106 1
a 178 179 3928
a 178 4106 1
a 179 180 3927
a 179 4106 1
a 180 181 3926
a 180 4106 1
a 181 182 3925
a 181 4106 1
a 182 183 3924
a 182 4106 1
a 183 184 3923
a 183 4106 1
a 184 185 3922
a 184 4106 1
a 185 186 3921
a 185 4106 1
a 186 187 3920
a 186 4106 1
a 187 188 3919
a 187 4106 1
a 188 189 3918
a 188 4106 1
a 189 190 3917
a 189 4106 1
a 190 191 3916
a 190 4106 1
a 191 192 3915
a 191 4106 1
a 192 193 3914
a 192 4106 1
a 193 194 3913
a 193 4106 1
a 194 195 3912
a 194 4106 1
a 195 196 3911
a 195 4106 1
a 196 197 3910
a 196 4106 1
a 197 198 3909
a 197 4106 1
a 198 199 3908
a 198 4106 1
a 199 200 3907
a 199 4106 1
a 200 201 3906
a 200 4106 1
a 201 202 3905
a 201 4106 1
a 202 203 3904
a 202 4106 1
a 203 204 3903
a 203 4106 1
a 204 205 3902
a 204 4106 1
a 205 206 3901
a 205 4106 1
a 206 207 3900
a 206 4106 1
a 207 208 3899
a 207 4106 1
a 208 209 3898
a 208 4106 1
a 209 210 3897
a 209 4106 1
a 210 211 3896
a 210 4106 1
a 211 212 3895
a 211 4106 1
a 212 213 3894
a 212 4106 1
a 213 214 3893
a 213 4106 1
a 214 215 3892
a 214 4106 1
a 215 216 3891
a 215 4106 1
a 216 217 3890
a 216 4106 1
a 217 218 3889
a 217 4106 1
a 218 219 3888
a 218 4106 1
a 219 220 3887
a 219 4106 1
a 220 221 3886
a 220 4106 1
a 221 222 3885
a 221 4106 1
a 222 223 3884
a 222 4106 1
a 223 224 3883
a 223 4106 1
a 224 225 3882
a 224 4106 1
a 225 226 3881
a 225 4106 1
a 226 227 3880
a 226 4106 1
a 227 228 3879
a 227 4106 1
a 228 229 3878
a 228 4106 1
a 229 230 3877
a 229 4106 1
a 230 231 3876
a 230 4106 1
a 231 232 3875
a 231 4106 1
a 232 233 3874
a 232 4106 1
a 233 234 3873
a 233 4106 1
a 234 235 3872
a 234 4106 1
a 235 236 3871
a 235 4106 1
a 236 237 3870
a 236 4106 1
a 237 238 3869
a 237 4106 1
a 238 239 3868
a 238 4106 1
a 239 240 3867
a 239 4106 1
a 240 241 3866
a 240 4106 1
a 241 242 3865
a 241 4106 1
a 242 243 3864
a 242 4106 1
a 243 244 3863
a 243 4106 1
a 244 245 3862
a 244 4106 1
a 245 246 3861
a 245 4106 1
a 246 247 3860
a 246 4106 1
a 247 248 3859
a 247 4106 1
a 248 249 3858
a 248 4106 1
a 249 250 3857
a 249 4106 1
a 250 251 3856
a 250 4106 1
a 251 252 3855
a 251 4106 1
a 252 253 3854
a 252 4106 1
a 253 254 3853
a 253 4106 1
a 254 255 3852
a 254 4106 1
a 255 256 3851
a 255 4106 1
a 256 257 3850
a 256 4106 1
a 257 258 3849
a 257 4106 1
a 258 259 3848
a 258 4106 1
a 259 260 3847
a 259 4106 1
a 260 261 3846
a 260 4106 1
a 261 262 3845
a 261 4106 1
a 262 263 3844
a 262 4106 1
a 263 264 3843
a 263 4106 1
a 264 265 3842
a 264 4106 1
a 265 266 3841
a 265 4106 1
a 266 267 3840
a 266 4106 1
a 267 268 3839
a 267 4106 1
a 268 269 3838
a 268 4106 1
a 269 270 3837
a 269 4106 1
a 270 271 3836
a 270 4106 1
a 271 272 3835
a 271 4106 1
a 272 273 3834
a 272 4106 1
a 273 274 3833
a 273 4106 1
a 274 275 3832
a 274 4106 1
a 275 276 3831
a 275 4106 1
a 276 277 3830
a 276 4106 1
a 277 278 3829
a 277 4106 1
a 278 279 3828
a 278 4106 1
a 279 280 3827
a 279 4106 1
a 280 281 3826
a 280 4106 1
a 281 282 3825
a 281 4106 1
a 282 283 3824
a 282 4106 1
a 283 284 3823
a 283 4106 1
a 284 285 3822
a 284 4106 1
a 285 286 3821
a 285 4106 1
a 286 287 3820
a 286 4106 1
a 287 288 3819
a 287 4106 1
a 288 289 3818
a 288 4106 1
a 289 290 3817
a 289 4106 1
a 290 291 3816
a 290 4106 1
a 291 292 3815
a 291 4106 1
a 292 293 3814
a 292 4106 1
a 293 294 3813
a 293 4106 1
a 294 295 3812
a 294 4106 1
a 295 296 3811
a 295 4106 1
a 296 297 3810
a 296 4106 1
a 297 298 3809
a 297 4106 1
a 298 299 3808
a 298 4106 1
a 299 300 3807
a 299 4106 1
a 300 301 3806
a 300 4106 1
a 301 302 3805
a 301 4106 1
a 302 303 3804
a 302 4106 1
a 303 304 3803
a 303 4106 1
a 304 305 3802
a 304 4106 1
a 305 306 3801
a 305 4106 1
a 306 307 3800
a 306 4106 1
a 307 308 3799
a 307 4106 1
a 308 309 3798
a 308 4106 1
a 309 310 3797
a 309 4106 1
a 310 311 3796
a 310 4106 1
a 311 312 3795
a 311 4106 1
a 312 313 3794
a 312 4106 1
a 313 314 3793
a 313 4106 1
a 314 315 3792
a 314 4106 1
a 315 316 3791
a 315 4106 1
a 316 317 3790
a 316 4106 1
a 317 318 3789
a 317 4106 1
a 318 319 3788
a 318 4106 1
a 319 320 3787
a 319 4106 1
a 320 321 3786
a 320 4106 1
a 321 322 3785
a 321 4106 1
a 322 323 3784
a 322 4106 1
a 323 324 3783
a 323 4106 1
a 324 325 3782
a 324 4106 1
a 325 326 3781
a 325 4106 1
a 326 327 3780
a 326 4106 1
a 327 328 3779
a 327 4106 1
a 328 329 3778
a 328 4106 1
a 329 330 3777
a 329 4106 1
a 330 331 3776
a 330 4106 1
a 331 332 3775
a 331 4106 1
a 332 333 3774
a 332 4106 1
a 333 334 3773
a 333 4106 1
a 334 335 3772
a 334 4106 1
a 335 336 3771
a 335 4106 1
a 336 337 3770
a 336 4106 1
a 337 338 3769
a 337 4106 1
a 338 339 3768
a 338 4106 1
a 339 340 3767
a 339 4106 1
a 340 341 3766
a 340 4106 1
a 341 342 3765
a 341 4106 1
a 342 343 3764
a 342 4106 1
a 343 344 3763
a 343 4106 1
a 344 345 3762
a 344 4106 1
a 345 346 3761
a 345 4106 1
a 346 347 3760
a 346 4106 1
a 347 348 3759
a 347 4106 1
a 348 349 3758
a 348 4106 1
a 349 350 3757
a 349 4106 1
a 350 351 3756
a 350 4106 1
a 351 352 3755
a 351 4106 1
a 352 353 3754
a 352 4106 1
a 353 354 3753
a 353 4106 1
a 354 355 3752
a 354 4106 1
a 355 356 3751
a 355 4106 1
a 356 357 3750
a 356 4106 1
a 357 358 3749
a 357 4106 1
a 358 359 3748
a 358 4106 1
a 359 360 3747
a 359 4106 1
a 360 361 3746
a 360 4106 1
a 361 362 3745
a 361 4106 1
a 362 363 3744
a 362 4106 1
a 363 364 3743
a 363 4106 1
a 364 365 3742
a 364 4106 1
a 365 366 3741
a 365 4106 1
a 366 367 3740
a 366 4106 1
a 367 368 3739
a 367 4106 1
a 368 369 3738
a 368 4106 1
a 369 370 3737
a 369 4106 1
a 370 371 3736
a 370 4106 1
a 371 372 3735
a 371 4106 1
a 372 373 3734
a 372 4106 1
a 373 374 3733
a 373 4106 1
a 374 375 3732
a 374 4106 1
a 375 376 3731
a 375 4106 1
a 376 377 3730
a 376 4106 1
a 377 378 3729
a 377 4106 1
a 378 379 3728
a 378 4106 1
a 379 380 3727
a 379 4106 1
a 380 381 3726
a 380 4106 1
a 381 382 3725
a 381 4106 1
a 382 383 3724
a 382 4106 1
a 383 384 3723
a 383 4106 1
a 384 385 3722
a 384 4106 1
a 385 386 3721
a 385 4106 1
a 386 387 3720
a 386 4106 1
a 387 388 3719
a 387 4106 1
a 388 389 3718
a 388 4106 1
a 389 390 3717
a 389 4106 1
a 390 391 3716
a 390 4106 1
a 391 392 3715
a 391 4106 1
a 392 393 3714
a 392 4106 1
a 393 394 3713
a 393 4106 1
a 394 395 3712
a 394 4106 1
a 395 396 3711
a 395 4106 1
a 396 397 3710
a 396 4106 1
a 397 398 3709
a 397 4106 1
a 398 399 3708
a 398 4106 1
a 399 400 3707
a 399 4106 1
a 400 401 3706
a 400 4106 1
a 401 402 3705
a 401 4106 1
a 402 403 3704
a 402 4106 1
a 403 404 3703
a 403 4106 1
a 404 405 3702
a 404 4106 1
a 405 406 3701
a 405 4106 1
a 406 407 3700
a 406 4106 1
a 407 408 3699
a 407 4106 1
a 408 409 3698
a 408 4106 1
a 409 410 3697
a 409 4106 1
a 410 411 3696
a 410 4106 1
a 411 412 3695
a 411 4106 1
a 412 413 3694
a 412 4106 1
a 413 414 3693
a 413 4106 1
a 414 415 3692
a 414 4106 1
a 415 416 3691
a 415 4106 1
a 416 417 3690
a 416 4106 1
a 417 418 3689
a 417 4106 1
a 418 419 3688
a 418 4106 1
a 419 420 3687
a 419 4106 1
a 420 421 3686
a 420 4106 1
a 421 422 3685
a 421 4106 1
a 422 423 3684
a 422 4106 1
a 423 424 3683
a 423 4106 1
a 424 425 3682
a 424 4106 1
a 425 426 3681
a 425 4106 1
a 426 427 3680
a 426 4106 1
a 427 428 3679
a 427 4106 1
a 428 429 3678
a 428 4106 1
a 429 430 3677
a 429 4106 1
a 430 431 3676
a 430 4106 1
a 431 432 3675
a 431 4106 1
a 432 433 3674
a 432 4106 1
a 433 434 3673
a 433 4106 1
a 434 435 3672
a 434 4106 1
a 435 436 3671
a 435 4106 1
a 436 437 3670
a 436 4106 1
a 437 438 3669
a 437 4106 1
a 438 439 3668
a 438 4106 1
a 439 440 3667
a 439 4106 1
a 440 441 3666
a 440 4106 1
a 441 442 3665
a 441 4106 1
a 442 443 3664
a 442 4106 1
a 443 444 3663
a 443 4106 1
a 444 445 3662
a 444 4106 1
a 445 446 3661
a 445 4106 1
a 446 447 3660
a 446 4106 1
a 447 448 3659
a 447 4106 1
a 448 449 3658
a 448 4106 1
a 449 450 3657
a 449 4106 1
a 450 451 3656
a 450 4106 1
a 451 452 3655
a 451 4106 1
a 452 453 3654
a 452 4106 1
a 453 454 3653
a 453 4106 1
a 454 455 3652
a 454 4106 1
a 455 456 3651
a 455 4106 1
a 456 457 3650
a 456 4106 1
a 457 458 3649
a 457 4106 1
a 458 459 3648
a 458 4106 1
a 459 460 3647
a 459 4106 1
a 460 461 3646
a 460 4106 1
a 461 462 3645
a 461 4106 1
a 462 463 3644
a 462 4106 1
a 463 464 3643
a 463 4106 1
a 464 465 3642
a 464 4106 1
a 465 466 3641
a 465 4106 1
a 466 467 3640
a 466 4106 1
a 467 468 3639
a 467 4106 1
a 468 469 3638
a 468 4106 1
a 469 470 3637
a 469 4106 1
a 470 471 3636
a 470 4106 1
a 471 472 3635
a 471 4106 1
a 472 473 3634
a 472 4106 1
a 473 474 3633
a 473 4106 1
a 474 475 3632
a 474 4106 1
a 475 476 3631
a 475 4106 1
a 476 477 3630
a 476 4106 1
a 477 478 3629
a 477 4106 1
a 478 479 3628
a 478 4106 1
a 479 480 3627
a 479 4106 1
a 480 481 3626
a 480 4106 1
a 481 482 3625
a 481 4106 1
a 482 483 3624
a 482 4106 1
a 483 484 3623
a 483 4106 1
a 484 485 3622
a 484 4106 1
a 485 486 3621
a 485 4106 1
a 486 487 3620
a 486 4106 1
a 487 488 3619
a 487 4106 1
a 488 489 3618
a 488 4106 1
a 489 490 3617
a 489 4106 1
a 490 491 3616
a 490 4106 1
a 491 492 3615
a 491 4106 1
a 492 493 3614
a 492 4106 1
a 493 494 3613
a 493 4106 1
a 494 495 3612
a 494 4106 1
a 495 496 3611
a 495 4106 1
a 496 497 3610
a 496 4106 1
a 497 498 3609
a 497 4106 1
a 498 499 3608
a 498 4106 1
a 499 500 3607
a 499 4106 1
a 500 501 3606
a 500 4106 1
a 501 502 3605
a 501 4106 1
a 502 503 3604
a 502 4106 1
a 503 504 3603
a 503 4106 1
a 504 505 3602
a 504 4106 1
a 505 506 3601
a 505 4106 1
a 506 507 3600
a 506 4106 1
a 507 508 3599
a 507 4106 1
a 508 509 3598
a 508 4106 1
a 509 510 3597
a 509 4106 1
a 510 511 3596
a 510 4106 1
a 511 512 3595
a 511 4106 1
a 512 513 3594
a 512 4106 1
a 513 514 3593
a 513 4106 1
a 514 515 3592
a 514 4106 1
a 515 516 3591
a 515 4106 1
a 516 517 3590
a 516 4106 1
a 517 518 3589
a 517 4106 1
a 518 519 3588
a 518 4106 1
a 519 520 3587
a 519 4106 1
a 520 521 3586
a 520 4106 1
a 521 522 3585
a 521 4106 1
a 522 523 3584
a 522 4106 1
a 523 524 3583
a 523 4106 1
a 524 525 3582
a 524 4106 1
a 525 526 3581
a 525 4106 1
a 526 527 3580
a 526 4106 1
a 527 528 3579
a 527 4106 1
a 528 529 3578
a 528 4106 1
a 529 530 3577
a 529 4106 1
a 530 531 3576
a 530 4106 1
a 531 532 3575
a 531 4106 1
a 532 533 3574
a 532 4106 1
a 533 534 3573
a 533 4106 1
a 534 535 3572
a 534 4106 1
a 535 536 3571
a 535 4106 1
a 536 537 3570
a 536 4106 1
a 537 538 3569
a 537 4106 1
a 538 539 3568
a 538 4106 1
a 539 540 3567
a 539 4106 1
a 540 541 3566
a 540 4106 1
a 541 542 3565
a 541 4106 1
a 542 543 3564
a 542 4106 1
a 543 544 3563
a 543 4106 1
a 544 545 3562
a 544 4106 1
a 545 546 3561
a 545 4106 1
a 546 547 3560
a 546 4106 1
a 547 548 3559
a 547 4106 1
a 548 549 3558
a 548 4106 1
a 549 550 3557
a 549 4106 1
a 550 551 3556
a 550 4106 1
a 551 552 3555
a 551 4106 1
a 552 553 3554
a 552 4106 1
a 553 554 3553
a 553 4106 1
a 554 555 3552
a 554 4106 1
a 555 556 3551
a 555 4106 1
a 556 557 3550
a 556 4106 1
a 557 558 3549
a 557 4106 1
a 558 559 3548
a 558 4106 1
a 559 560 3547
a 559 4106 1
a 560 561 3546
a 560 4106 1
a 561 562 3545
a 561 4106 1
a 562 563 3544
a 562 4106 1
a 563 564 3543
a 563 4106 1
a 564 565 3542
a 564 4106 1
a 565 566 3541
a 565 4106 1
a 566 567 3540
a 566 4106 1
a 567 568 3539
a 567 4106 1
a 568 569 3538
a 568 4106 1
a 569 570 3537
a 569 4106 1
a 570 571 3536
a 570 4106 1
a 571 572 3535
a 571 4106 1
a 572 573 3534
a 572 4106 1
a 573 574 3533
a 573 4106 1
a 574 575 3532
a 574 4106 1
a 575 576 3531
a 575 4106 1
a 576 577 3530
a 576 4106 1
a 577 578 3529
a 577 4106 1
a 578 579 3528
a 578 4106 1
a 579 580 3527
a 579 4106 1
a 580 581 3526
a 580 4106 1
a 581 582 3525
a 581 4106 1
a 582 583 3524
a 582 4106 1
a 583 584 3523
a 583 4106 1
a 584 585 3522
a 584 4106 1
a 585 586 3521
a 585 4106 1
a 586 587 3520
a 586 4106 1
a 587 588 3519
a 587 4106 1
a 588 589 3518
a 588 4106 1
a 589 590 3517
a 589 4106 1
a 590 591 3516
a 590 4106 1
a 591 592 3515
a 591 4106 1
a 592 593 3514
a 592 4106 1
a 593 594 3513
a 593 4106 1
a 594 595 3512
a 594 4106 1
a 595 596 3511
a 595 4106 1
a 596 597 3510
a 596 4106 1
a 597 598 3509
a 597 4106 1
a 598 599 3508
a 598 4106 1
a 599 600 3507
a 599 4106 1
a 600 601 3506
a 600 4106 1
a 601 602 3505
a 601 4106 1
a 602 603 3504
a 602 4106 1
a 603 604 3503
a 603 4106 1
a 604 605 3502
a 604 4106 1
a 605 606 3501
a 605 4106 1
a 606 607 3500
a 606 4106 1
a 607 608 3499
a 607 4106 1
a 608 609 3498
a 608 4106 1
a 609 610 3497
a 609 4106 1
a 610 611 3496
a 610 4106 1
a 611 612 3495
a 611 4106 1
a 612 613 3494
a 612 4106 1
a 613 614 3493
a 613 4106 1
a 614 615 3492
a 614 4106 1
a 615 616 3491
a 615 4106 1
a 616 617 3490
a 616 4106 1
a 617 618 3489
a 617 4106 1
a 618 619 3488
a 618 4106 1
a 619 620 3487
a 619 4106 1
a 620 621 3486
a 620 4106 1
a 621 622 3485
a 621 4106 1
a 622 623 3484
a 622 4106 1
a 623 624 3483
a 623 4106 1
a 624 625 3482
a 624 4106 1
a 625 626 3481
a 625 4106 1
a 626 627 3480
a 626 4106 1
a 627 628 3479
a 627 4106 1
a 628 629 3478
a 628 4106 1
a 629 630 3477
a 629 4106 1
a 630 631 3476
a 630 4106 1
a 631 632 3475
a 631 4106 1
a 632 633 3474
a 632 4106 1
a 633 634 3473
a 633 4106 1
a 634 635 3472
a 634 4106 1
a 635 636 3471
a 635 4106 1
a 636 637 3470
a 636 4106 1
a 637 638 3469
a 637 4106 1
a 638 639 3468
a 638 4106 1
a 639 640 3467
a 639 4106 1
a 640 641 3466
a 640 4106 1
a 641 642 3465
a 641 4106 1
a 642 643 3464
a 642 4106 1
a 643 644 3463
a 643 4106 1
a 644 645 3462
a 644 4106 1
a 645 646 3461
a 645 4106 1
a 646 647 3460
a 646 4106 1
a 647 648 3459
a 647 4106 1
a 648 649 3458
a 648 4106 1
a 649 650 3457
a 649 4106 1
a 650 651 3456
a 650 4106 1
a 651 652 3455
a 651 4106 1
a 652 653 3454
a 652 4106 1
a 653 654 3453
a 653 4106 1
a 654 655 3452
a 654 4106 1
a 655 656 3451
a 655 4106 1
a 656 657 3450
a 656 4106 1
a 657 658 3449
a 657 4106 1
a 658 659 3448
a 658 4106 1
a 659 660 3447
a 659 4106 1
a 660 661 3446
a 660 4106 1
a 661 662 3445
a 661 4106 1
a 662 663 3444
a 662 4106 1
a 663 664 3443
a 663 4106 1
a 664 665 3442
a 664 4106 1
a 665 666 3441
a 665 4106 1
a 666 667 3440
a 666 4106 1
a 667 668 3439
a 667 4106 1
a 668 669 3438
a 668 4106 1
a 669 670 3437
a 669 4106 1
a 670 671 3436
a 670 4106 1
a 671 672 3435
a 671 4106 1
a 672 673 3434
a 672 4106 1
a 673 674 3433
a 673 4106 1
a 674 675 3432
a 674 4106 1
a 675 676 3431
a 675 4106 1
a 676 677 3430
a 676 4106 1
a 677 678 3429
a 677 4106 1
a 678 679 3428
a 678 4106 1
a 679 680 3427
a 679 4106 1
a 680 681 3426
a 680 4106 1
a 681 682 3425
a 681 4106 1
a 682 683 3424
a 682 4106 1
a 683 684 3423
a 683 4106 1
a 684 685 3422
a 684 4106 1
a 685 686 3421
a 685 4106 1
a 686 687 3420
a 686 4106 1
a 687 688 3419
a 687 4106 1
a 688 689 3418
a 688 4106 1
a 689 690 3417
a 689 4106 1
a 690 691 3416
a 690 4106 1
a 691 692 3415
a 691 4106 1
a 692 693 3414
a 692 4106 1
a 693 694 3413
a 693 4106 1
a 694 695 3412
a 694 4106 1
a 695 696 3411
a 695 4106 1
a 696 697 3410
a 696 4106 1
a 697 698 3409
a 697 4106 1
a 698 699 3408
a 698 4106 1
a 699 700 3407
a 699 4106 1
a 700 701 3406
a 700 4106 1
a 701 702 3405
a 701 4106 1
a 702 703 3404
a 702 4106 1
a 703 704 3403
a 703 4106 1
a 704 705 3402
a 704 4106 1
a 705 706 3401
a 705 4106 1
a 706 707 3400
a 706 4106 1
a 707 708 3399
a 707 4106 1
a 708 709 3398
a 708 4106 1
a 709 710 3397
a 709 4106 1
a 710 711 3396
a 710 4106 1
a 711 712 3395
a 711 4106 1
a 712 713 3394
a 712 4106 1
a 713 714 3393
a 713 4106 1
a 714 715 3392
a 714 4106 1
a 715 716 3391
a 715 4106 1
a 716 717 3390
a 716 4106 1
a 717 718 3389
a 717 4106 1
a 718 719 3388
a 718 4106 1
a 719 720 3387
a 719 4106 1
a 720 721 3386
a 720 4106 1
a 721 722 3385
a 721 4106 1
a 722 723 3384
a 722 4106 1
a 723 724 3383
a 723 4106 1
a 724 725 3382
a 724 4106 1
a 725 726 3381
a 725 4106 1
a 726 727 3380
a 726 4106 1
a 727 728 3379
a 727 4106 1
a 728 729 3378
a 728 4106 1
a 729 730 3377
a 729 4106 1
a 730 731 3376
a 730 4106 1
a 731 732 3375
a 731 4106 1
a 732 733 3374
a 732 4106 1
a 733 734 3373
a 733 4106 1
a 734 735 3372
a 734 4106 1
a 735 736 3371
a 735 4106 1
a 736 737 3370
a 736 4106 1
a 737 738 3369
a 737 4106 1
a 738 739 3368
a 738 4106 1
a 739 740 3367
a 739 4106 1
a 740 741 3366
a 740 4106 1
a 741 742 3365
a 741 4106 1
a 742 743 3364
a 742 4106 1
a 743 744 3363
a 743 4106 1
a 744 745 3362
a 744 4106 1
a 745 746 3361
a 745 4106 1
a 746 747 3360
a 746 4106 1
a 747 748 3359
a 747 4106 1
a 748 749 3358
a 748 4106 1
a 749 750 3357
a 749 4106 1
a 750 751 3356
a 750 4106 1
a 751 752 3355
a 751 4106 1
a 752 753 3354
a 752 4106 1
a 753 754 3353
a 753 4106 1
a 754 755 3352
a 754 4106 1
a 755 756 3351
a 755 4106 1
a 756 757 3350
a 756 4106 1
a 757 758 3349
a 757 4106 1
a 758 759 3348
a 758 4106 1
a 759 760 3347
a 759 4106 1
a 760 761 3346
a 760 4106 1
a 761 762 3345
a 761 4106 1
a 762 763 3344
a 762 4106 1
a 763 764 3343
a 763 4106 1
a 764 765 3342
a 764 4106 1
a 765 766 3341
a 765 4106 1
a 766 767 3340
a 766 4106 1
a 767 768 3339
a 767 4106 1
a 768 769 3338
a 768 4106 1
a 769 770 3337
a 769 4106 1
a 770 771 3336
a 770 4106 1
a 771 772 3335
a 771 4106 1
a 772 773 3334
a 772 4106 1
a 773 774 3333
a 773 4106 1
a 774 775 3332
a 774 4106 1
a 775 776 3331
a 775 4106 1
a 776 777 3330
a 776 4106 1
a 777 778 3329
a 777 4106 1
a 778 779 3328
a 778 4106 1
a 779 780 3327
a 779 4106 1
a 780 781 3326
a 780 4106 1
a 781 782 3325
a 781 4106 1
a 782 783 3324
a 782 4106 1
a 783 784 3323
a 783 4106 1
a 784 785 3322
a 784 4106 1
a 785 786 3321
a 785 4106 1
a 786 787 3320
a 786 4106 1
a 787 788 3319
a 787 4106 1
a 788 789 3318
a 788 4106 1
a 789 790 3317
a 789 4106 1
a 790 791 3316
a 790 4106 1
a 791 792 3315
a 791 4106 1
a 792 793 3314
a 792 4106 1
a 793 794 3313
a 793 4106 1
a 794 795 3312
a 794 4106 1
a 795 796 3311
a 795 4106 1
a 796 797 3310
a 796 4106 1
a 797 798 3309
a 797 4106 1
a 798 799 3308
a 798 4106 1
a 799 800 3307
a 799 4106 1
a 800 801 3306
a 800 4106 1
a 801 802 3305
a 801 4106 1
a 802 803 3304
a 802 4106 1
a 803 804 3303
a 803 4106 1
a 804 805 3302
a 804 4106 1
a 805 806 3301
a 805 4106 1
a 806 807 3300
a 806 4106 1
a 807 808 3299
a 807 4106 1
a 808 809 3298
a 808 4106 1
a 809 810 3297
a 809 4106 1
a 810 811 3296
a 810 4106 1
a 811 812 3295
a 811 4106 1
a 812 813 3294
a 812 4106 1
a 813 814 3293
a 813 4106 1
a 814 815 3292
a 814 4106 1
a 815 816 3291
a 815 4106 1
a 816 817 3290
a 816 4106 1
a 817 818 3289
a 817 4106 1
a 818 819 3288
a 818 4106 1
a 819 820 3287
a 819 4106 1
a 820 821 3286
a 820 4106 1
a 821 822 3285
a 821 4106 1
a 822 823 3284
a 822 4106 1
a 823 824 3283
a 823 4106 1
a 824 825 3282
a 824 4106 1
a 825 826 3281
a 825 4106 1
a 826 827 3280
a 826 4106 1
a 827 828 3279
a 827 4106 1
a 828 829 3278
a 828 4106 1
a 829 830 3277
a 829 4106 1
a 830 831 3276
a 830 4106 1
a 831 832 3275
a 831 4106 1
a 832 833 3274
a 832 4106 1
a 833 834 3273
a 833 4106 1
a 834 835 3272
a 834 4106 1
a 835 836 3271
a 835 4106 1
a 836 837 3270
a 836 4106 1
a 837 838 3269
a 837 4106 1
a 838 839 3268
a 838 4106 1
a 839 840 3267
a 839 4106 1
a 840 841 3266
a 840 4106 1
a 841 842 3265
a 841 4106 1
a 842 843 3264
a 842 4106 1
a 843 844 3263
a 843 4106 1
a 844 845 3262
a 844 4106 1
a 845 846 3261
a 845 4106 1
a 846 847 3260
a 846 4106 1
a 847 848 3259
a 847 4106 1
a 848 849 3258
a 848 4106 1
a 849 850 3257
a 849 4106 1
a 850 851 3256
a 850 4106 1
a 851 852 3255
a 851 4106 1
a 852 853 3254
a 852 4106 1
a 853 854 3253
a 853 4106 1
a 854 855 3252
a 854 4106 1
a 855 856 3251
a 855 4106 1
a 856 857 3250
a 856 4106 1
a 857 858 3249
a 857 4106 1
a 858 859 3248
a 858 4106 1
a 859 860 3247
a 859 4106 1
a 860 861 3246
a 860 4106 1
a 861 862 3245
a 861 4106 1
a 862 863 3244
a 862 4106 1
a 863 864 3243
a 863 4106 1
a 864 865 3242
a 864 4106 1
a 865 866 3241
a 865 4106 1
a 866 867 3240
a 866 4106 1
a 867 868 3239
a 867 4106 1
a 868 869 3238
a 868 4106 1
a 869 870 3237
a 869 4106 1
a 870 871 3236
a 870 4106 1
a 871 872 3235
a 871 4106 1
a 872 873 3234
a 872 4106 1
a 873 874 3233
a 873 4106 1
a 874 875 3232
a 874 4106 1
a 875 876 3231
a 875 4106 1
a 876 877 3230
a 876 4106 1
a 877 878 3229
a 877 4106 1
a 878 879 3228
a 878 4106 1
a 879 880 3227
a 879 4106 1
a 880 881 3226
a 880 4106 1
a 881 882 3225
a 881 4106 1
a 882 883 3224
a 882 4106 1
a 883 884 3223
a 883 4106 1
a 884 885 3222
a 884 4106 1
a 885 886 3221
a 885 4106 1
a 886 887 3220
a 886 4106 1
a 887 888 3219
a 887 4106 1
a 888 889 3218
a 888 4106 1
a 889 890 3217
a 889 4106 1
a 890 891 3216
a 890 4106 1
a 891 892 3215
a 891 4106 1
a 892 893 3214
a 892 4106 1
a 893 894 3213
a 893 4106 1
a 894 895 3212
a 894 4106 1
a 895 896 3211
a 895 4106 1
a 896 897 3210
a 896 4106 1
a 897 898 3209
a 897 4106 1
a 898 899 3208
a 898 4106 1
a 899 900 3207
a 899 4106 1
a 900 901 3206
a 900 4106 1
a 901 902 3205
a 901 4106 1
a 902 903 3204
a 902 4106 1
a 903 904 3203
a 903 4106 1
a 904 905 3202
a 904 4106 1
a 905 906 3201
a 905 4106 1
a 906 907 3200
a 906 4106 1
a 907 908 3199
a 907 4106 1
a 908 909 3198
a 908 4106 1
a 909 910 3197
a 909 4106 1
a 910 911 3196
a 910 4106 1
a 911 912 3195
a 911 4106 1
a 912 913 3194
a 912 4106 1
a 913 914 3193
a 913 4106 1
a 914 915 3192
a 914 4106 1
a 915 916 3191
a 915 4106 1
a 916 917 3190
a 916 4106 1
a 917 918 3189
a 917 4106 1
a 918 919 3188
a 918 4106 1
a 919 920 3187
a 919 4106 1
a 920 921 3186
a 920 4106 1
a 921 922 3185
a 921 4106 1
a 922 923 3184
a 922 4106 1
a 923 924 3183
a 923 4106 1
a 924 925 3182
a 924 4106 1
a 925 926 3181
a 925 4106 1
a 926 927 3180
a 926 4106 1
a 927 928 3179
a 927 4106 1
a 928 929 3178
a 928 4106 1
a 929 930 3177
a 929 4106 1
a 930 931 3176
a 930 4106 1
a 931 932 3175
a 931 4106 1
a 932 933 3174
a 932 4106 1
a 933 934 3173
a 933 4106 1
a 934 935 3172
a 934 4106 1
a 935 936 3171
a 935 4106 1
a 936 937 3170
a 936 4106 1
a 937 938 3169
a 937 4106 1
a 938 939 3168
a 938 4106 1
a 939 940 3167
a 939 4106 1
a 940 941 3166
a 940 4106 1
a 941 942 3165
a 941 4106 1
a 942 943 3164
a 942 4106 1
a 943 944 3163
a 943 4106 1
a 944 945 3162
a 944 4106 1
a 945 946 3161
a 945 4106 1
a 946 947 3160
a 946 4106 1
a 947 948 3159
a 947 4106 1
a 948 949 3158
a 948 4106 1
a 949 950 3157
a 949 4106 1
a 950 951 3156
a 950 4106 1
a 951 952 3155
a 951 4106 1
a 952 953 3154
a 952 4106 1
a 953 954 3153
a 953 4106 1
a 954 955 3152
a 954 4106 1
a 955 956 3151
a 955 4106 1
a 956 957 3150
a 956 4106 1
a 957 958 3149
a 957 4106 1
a 958 959 3148
a 958 4106 1
a 959 960 3147
a 959 4106 1
a 960 961 3146
a 960 4106 1
a 961 962 3145
a 961 4106 1
a 962 963 3144
a 962 4106 1
a 963 964 3143
a 963 4106 1
a 964 965 3142
a 964 4106 1
a 965 966 3141
a 965 4106 1
a 966 967 3140
a 966 4106 1
a 967 968 3139
a 967 4106 1
a 968 969 3138
a 968 4106 1
a 969 970 3137
a 969 4106 1
a 970 971 3136
a 970 4106 1
a 971 972 3135
a 971 4106 1
a 972 973 3134
a 972 4106 1
a 973 974 3133
a 973 4106 1
a 974 975 3132
a 974 4106 1
a 975 976 3131
a 975 4106 1
a 976 977 3130
a 976 4106 1
a 977 978 3129
a 977 4106 1
a 978 979 3128
a 978 4106 1
a 979 980 3127
a 979 4106 1
a 980 981 3126
a 980 4106 1
a 981 982 3125
a 981 4106 1
a 982 983 3124
a 982 4106 1
a 983 984 3123
a 983 4106 1
a 984 985 3122
a 984 4106 1
a 985 986 3121
a 985 4106 1
a 986 987 3120
a 986 4106 1
a 987 988 3119
a 987 4106 1
a 988 989 3118
a 988 4106 1
a 989 990 3117
a 989 4106 1
a 990 991 3116
a 990 4106 1
a 991 992 3115
a 991 4106 1
a 992 993 3114
a 992 4106 1
a 993 994 3113
a 993 4106 1
a 994 995 3112
a 994 4106 1
a 995 996 3111
a 995 4106 1
a 996 997 3110
a 996 4106 1
a 997 998 3109
a 997 4106 1
a 998 999 3108
a 998 4106 1
a 999 1000 3107
a 999 4106 1
a 1000 1001 3106
a 1000 4106 1
a 1001 1002 3105
a 1001 4106 1
a 1002 1003 3104
a 1002 4106 1
a 1003 1004 3103
a 1003 4106 1
a 1004 1005 3102
a 1004 4106 1
a 1005 1006 3101
a 1005 4106 1
a 1006 1007 3100
a 1006 4106 1
a 1007 1008 3099
a 1007 4106 1
a 1008 1009 3098
a 1008 4106 1
a 1009 1010 3097
a 1009 4106 1
a 1010 1011 3096
a 1010 4106 1
a 1011 1012 3095
a 1011 4106 1
a 1012 1013 3094
a 1012 4106 1
a 1013 1014 3093
a 1013 4106 1
a 1014 1015 3092
a 1014 4106 1
a 1015 1016 3091
a 1015 4106 1
a 1016 1017 3090
a 1016 4106 1
a 1017 1018 3089
a 1017 4106 1
a 1018 1019 3088
a 1018 4106 1
a 1019 1020 3087
a 1019 4106 1
a 1020 1021 3086
a 1020 4106 1
a 1021 1022 3085
a 1021 4106 1
a 1022 1023 3084
a 1022 4106 1
a 1023 1024 3083
a 1023 4106 1
a 1024 1025 3082
a 1024 4106 1
a 1025 1026 3081
a 1025 4106 1
a 1026 1027 3080
a 1026 4106 1
a 1027 1028 3079
a 1027 4106 1
a 1028 1029 3078
a 1028 4106 1
a 1029 1030 3077
a 1029 4106 1
a 1030 1031 3076
a 1030 4106 1
a 1031 1032 3075
a 1031 4106 1
a 1032 1033 3074
a 1032 4106 1
a 1033 1034 3073
a 1033 4106 1
a 1034 1035 3072
a 1034 4106 1
a 1035 1036 3071
a 1035 4106 1
a 1036 1037 3070
a 1036 4106 1
a 1037 1038 3069
a 1037 4106 1
a 1038 1039 3068
a 1038 4106 1
a 1039 1040 3067
a 1039 4106 1
a 1040 1041 3066
a 1040 4106 1
a 1041 1042 3065
a 1041 4106 1
a 1042 1043 3064
a 1042 4106 1
a 1043 1044 3063
a 1043 4106 1
a 1044 1045 3062
a 1044 4106 1
a 1045 1046 3061
a 1045 4106 1
a 1046 1047 3060
a 1046 4106 1
a 1047 1048 3059
a 1047 4106 1
a 1048 1049 3058
a 1048 4106 1
a 1049 1050 3057
a 1049 4106 1
a 1050 1051 3056
a 1050 4106 1
a 1051 1052 3055
a 1051 4106 1
a 1052 1053 3054
a 1052 4106 1
a 1053 1054 3053
a 1053 4106 1
a 1054 1055 3052
a 1054 4106 1
a 1055 1056 3051
a 1055 4106 1
a 1056 1057 3050
a 1056 4106 1
a 1057 1058 3049
a 1057 4106 1
a 1058 1059 3048
a 1058 4106 1
a 1059 1060 3047
a 1059 4106 1
a 1060 1061 3046
a 1060 4106 1
a 1061 1062 3045
a 1061 4106 1
a 1062 1063 3044
a 1062 4106 1
a 1063 1064 3043
a 1063 4106 1
a 1064 1065 3042
a 1064 4106 1
a 1065 1066 3041
a 1065 4106 1
a 1066 1067 3040
a 1066 4106 1
a 1067 1068 3039
a 1067 4106 1
a 1068 1069 3038
a 1068 4106 1
a 1069 1070 3037
a 1069 4106 1
a 1070 1071 3036
a 1070 4106 1
a 1071 1072 3035
a 1071 4106 1
a 1072 1073 3034
a 1072 4106 1
a 1073 1074 3033
a 1073 4106 1
a 1074 1075 3032
a 1074 4106 1
a 1075 1076 3031
a 1075 4106 1
a 1076 1077 3030
a 1076 4106 1
a 1077 1078 3029
a 1077 4106 1
a 1078 1079 3028
a 1078 4106 1
a 1079 1080 3027
a 1079 4106 1
a 1080 1081 3026
a 1080 4106 1
a 1081 1082 3025
a 1081 4106 1
a 1082 1083 3024
a 1082 4106 1
a 1083 1084 3023
a 1083 4106 1
a 1084 1085 3022
a 1084 4106 1
a 1085 1086 3021
a 1085 4106 1
a 1086 1087 3020
a 1086 4106 1
a 1087 1088 3019
a 1087 4106 1
a 1088 1089 3018
a 1088 4106 1
a 1089 1090 3017
a 1089 4106 1
a 1090 1091 3016
a 1090 4106 1
a 1091 1092 3015
a 1091 4106 1
a 1092 1093 3014
a 1092 4106 1
a 1093 1094 3013
a 1093 4106 1
a 1094 1095 3012
a 1094 4106 1
a 1095 1096 3011
a 1095 4106 1
a 1096 1097 3010
a 1096 4106 1
a 1097 1098 3009
a 1097 4106 1
a 1098 1099 3008
a 1098 4106 1
a 1099 1100 3007
a 1099 4106 1
a 1100 1101 3006
a 1100 4106 1
a 1101 1102 3005
a 1101 4106 1
a 1102 1103 3004
a 1102 4106 1
a 1103 1104 3003
a 1103 4106 1
a 1104 1105 3002
a 1104 4106 1
a 1105 1106 3001
a 1105 4106 1
a 1106 1107 3000
a 1106 4106 1
a 1107 1108 2999
a 1107 4106 1
a 1108 1109 2998
a 1108 4106 1
a 1109 1110 2997
a 1109 4106 1
a 1110 1111 2996
a 1110 4106 1
a 1111 1112 2995
a 1111 4106 1
a 1112 1113 2994
a 1112 4106 1
a 1113 1114 2993
a 1113 4106 1
a 1114 1115 2992
a 1114 4106 1
a 1115 1116 2991
a 1115 4106 1
a 1116 1117 2990
a 1116 4106 1
a 1117 1118 2989
a 1117 4106 1
a 1118 1119 2988
a 1118 4106 1
a 1119 1120 2987
a 1119 4106 1
a 1120 1121 2986
a 1120 4106 1
a 1121 1122 2985
a 1121 4106 1
a 1122 1123 2984
a 1122 4106 1
a 1123 1124 2983
a 1123 4106 1
a 1124 1125 2982
a 1124 4106 1
a 1125 1126 2981
a 1125 4106 1
a 1126 1127 2980
a 1126 4106 1
a 1127 1128 2979
a 1127 4106 1
a 1128 1129 2978
a 1128 4106 1
a 1129 1130 2977
a 1129 4106 1
a 1130 1131 2976
a 1130 4106 1
a 1131 1132 2975
a 1131 4106 1
a 1132 1133 2974
a 1132 4106 1
a 1133 1134 2973
a 1133 4106 1
a 1134 1135 2972
a 1134 4106 1
a 1135 1136 2971
a 1135 4106 1
a 1136 1137 2970
a 1136 4106 1
a 1137 1138 2969
a 1137 4106 1
a 1138 1139 2968
a 1138 4106 1
a 1139 1140 2967
a 1139 4106 1
a 1140 1141 2966
a 1140 4106 1
a 1141 1142 2965
a 1141 4106 1
a 1142 1143 2964
a 1142 4106 1
a 1143 1144 2963
a 1143 4106 1
a 1144 1145 2962
a 1144 4106 1
a 1145 1146 2961
a 1145 4106 1
a 1146 1147 2960
a 1146 4106 1
a 1147 1148 2959
a 1147 4106 1
a 1148 1149 2958
a 1148 4106 1
a 1149 1150 2957
a 1149 4106 1
a 1150 1151 2956
a 1150 4106 1
a 1151 1152 2955
a 1151 4106 1
a 1152 1153 2954
a 1152 4106 1
a 1153 1154 2953
a 1153 4106 1
a 1154 1155 2952
a 1154 4106 1
a 1155 1156 2951
a 1155 4106 1
a 1156 1157 2950
a 1156 4106 1
a 1157 1158 2949
a 1157 4106 1
a 1158 1159 2948
a 1158 4106 1
a 1159 1160 2947
a 1159 4106 1
a 1160 1161 2946
a 1160 4106 1
a 1161 1162 2945
a 1161 4106 1
a 1162 1163 2944
a 1162 4106 1
a 1163 1164 2943
a 1163 4106 1
a 1164 1165 2942
a 1164 4106 1
a 1165 1166 2941
a 1165 4106 1
a 1166 1167 2940
a 1166 4106 1
a 1167 1168 2939
a 1167 4106 1
a 1168 1169 2938
a 1168 4106 1
a 1169 1170 2937
a 1169 4106 1
a 1170 1171 2936
a 1170 4106 1
a 1171 1172 2935
a 1171 4106 1
a 1172 1173 2934
a 1172 4106 1
a 1173 1174 2933
a 1173 4106 1
a 1174 1175 2932
a 1174 4106 1
a 1175 1176 2931
a 1175 4106 1
a 1176 1177 2930
a 1176 4106 1
a 1177 1178 2929
a 1177 4106 1
a 1178 1179 2928
a 1178 4106 1
a 1179 1180 2927
a 1179 4106 1
a 1180 1181 2926
a 1180 4106 1
a 1181 1182 2925
a 1181 4106 1
a 1182 1183 2924
a 1182 4106 1
a 1183 1184 2923
a 1183 4106 1
a 1184 1185 2922
a 1184 4106 1
a 1185 1186 2921
a 1185 4106 1
a 1186 1187 2920
a 1186 4106 1
a 1187 1188 2919
a 1187 4106 1
a 1188 1189 2918
a 1188 4106 1
a 1189 1190 2917
a 1189 4106 1
a 1190 1191 2916
a 1190 4106 1
a 1191 1192 2915
a 1191 4106 1
a 1192 1193 2914
a 1192 4106 1
a 1193 1194 2913
a 1193 4106 1
a 1194 1195 2912
a 1194 4106 1
a 1195 1196 2911
a 1195 4106 1
a 1196 1197 2910
a 1196 4106 1
a 1197 1198 2909
a 1197 4106 1
a 1198 1199 2908
a 1198 4106 1
a 1199 1200 2907
a 1199 4106 1
a 1200 1201 2906
a 1200 4106 1
a 1201 1202 2905
a 1201 4106 1
a 1202 1203 2904
a 1202 4106 1
a 1203 1204 2903
a 1203 4106 1
a 1204 1205 2902
a 1204 4106 1
a 1205 1206 2901
a 1205 4106 1
a 1206 1207 2900
a 1206 4106 1
a 1207 1208 2899
a 1207 4106 1
a 1208 1209 2898
a 1208 4106 1
a 1209 1210 2897
a 1209 4106 1
a 1210 1211 2896
a 1210 4106 1
a 1211 1212 2895
a 1211 4106 1
a 1212 1213 2894
a 1212 4106 1
a 1213 1214 2893
a 1213 4106 1
a 1214 1215 2892
a 1214 4106 1
a 1215 1216 2891
a 1215 4106 1
a 1216 1217 2890
a 1216 4106 1
a 1217 1218 2889
a 1217 4106 1
a 1218 1219 2888
a 1218 4106 1
a 1219 1220 2887
a 1219 4106 1
a 1220 1221 2886
a 1220 4106 1
a 1221 1222 2885
a 1221 4106 1
a 1222 1223 2884
a 1222 4106 1
a 1223 1224 2883
a 1223 4106 1
a 1224 1225 2882
a 1224 4106 1
a 1225 1226 2881
a 1225 4106 1
a 1226 1227 2880
a 1226 4106 1
a 1227 1228 2879
a 1227 4106 1
a 1228 1229 2878
a 1228 4106 1
a 1229 1230 2877
a 1229 4106 1
a 1230 1231 2876
a 1230 4106 1
a 1231 1232 2875
a 1231 4106 1
a 1232 1233 2874
a 1232 4106 1
a 1233 1234 2873
a 1233 4106 1
a 1234 1235 2872
a 1234 4106 1
a 1235 1236 2871
a 1235 4106 1
a 1236 1237 2870
a 1236 4106 1
a 1237 1238 2869
a 1237 4106 1
a 1238 1239 2868
a 1238 4106 1
a 1239 1240 2867
a 1239 4106 1
a 1240 1241 2866
a 1240 4106 1
a 1241 1242 2865
a 1241 4106 1
a 1242 1243 2864
a 1242 4106 1
a 1243 1244 2863
a 1243 4106 1
a 1244 1245 2862
a 1244 4106 1
a 1245 1246 2861
a 1245 4106 1
a 1246 1247 2860
a 1246 4106 1
a 1247 1248 2859
a 1247 4106 1
a 1248 1249 2858
a 1248 4106 1
a 1249 1250 2857
a 1249 4106 1
a 1250 1251 2856
a 1250 4106 1
a 1251 1252 2855
a 1251 4106 1
a 1252 1253 2854
a 1252 4106 1
a 1253 1254 2853
a 1253 4106 1
a 1254 1255 2852
a 1254 4106 1
a 1255 1256 2851
a 1255 4106 1
a 1256 1257 2850
a 1256 4106 1
a 1257 1258 2849
a 1257 4106 1
a 1258 1259 2848
a 1258 4106 1
a 1259 1260 2847
a 1259 4106 1
a 1260 1261 2846
a 1260 4106 1
a 1261 1262 2845
a 1261 4106 1
a 1262 1263 2844
a 1262 4106 1
a 1263 1264 2843
a 1263 4106 1
a 1264 1265 2842
a 1264 4106 1
a 1265 1266 2841
a 1265 4106 1
a 1266 1267 2840
a 1266 4106 1
a 1267 1268 2839
a 1267 4106 1
a 1268 1269 2838
a 1268 4106 1
a 1269 1270 2837
a 1269 4106 1
a 1270 1271 2836
a 1270 4106 1
a 1271 1272 2835
a 1271 4106 1
a 1272 1273 2834
a 1272 4106 1
a 1273 1274 2833
a 1273 4106 1
a 1274 1275 2832
a 1274 4106 1
a 1275 1276 2831
a 1275 4106 1
a 1276 1277 2830
a 1276 4106 1
a 1277 1278 2829
a 1277 4106 1
a 1278 1279 2828
a 1278 4106 1
a 1279 1280 2827
a 1279 4106 1
a 1280 1281 2826
a 1280 4106 1
a 1281 1282 2825
a 1281 4106 1
a 1282 1283 2824
a 1282 4106 1
a 1283 1284 2823
a 1283 4106 1
a 1284 1285 2822
a 1284 4106 1
a 1285 1286 2821
a 1285 4106 1
a 1286 1287 2820
a 1286 4106 1
a 1287 1288 2819
a 1287 4106 1
a 1288 1289 2818
a 1288 4106 1
a 1289 1290 2817
a 1289 4106 1
a 1290 1291 2816
a 1290 4106 1
a 1291 1292 2815
a 1291 4106 1
a 1292 1293 2814
a 1292 4106 1
a 1293 1294 2813
a 1293 4106 1
a 1294 1295 2812
a 1294 4106 1
a 1295 1296 2811
a 1295 4106 1
a 1296 1297 2810
a 1296 4106 1
a 1297 1298 2809
a 1297 4106 1
a 1298 1299 2808
a 1298 4106 1
a 1299 1300 2807
a 1299 4106 1
a 1300 1301 2806
a 1300 4106 1
a 1301 1302 2805
a 1301 4106 1
a 1302 1303 2804
a 1302 4106 1
a 1303 1304 2803
a 1303 4106 1
a 1304 1305 2802
a 1304 4106 1
a 1305 1306 2801
a 1305 4106 1
a 1306 1307 2800
a 1306 4106 1
a 1307 1308 2799
a 1307 4106 1
a 1308 1309 2798
a 1308 4106 1
a 1309 1310 2797
a 1309 4106 1
a 1310 1311 2796
a 1310 4106 1
a 1311 1312 2795
a 1311 4106 1
a 1312 1313 2794
a 1312 4106 1
a 1313 1314 2793
a 1313 4106 1
a 1314 1315 2792
a 1314 4106 1
a 1315 1316 2791
a 1315 4106 1
a 1316 1317 2790
a 1316 4106 1
a 1317 1318 2789
a 1317 4106 1
a 1318 1319 2788
a 1318 4106 1
a 1319 1320 2787
a 1319 4106 1
a 1320 1321 2786
a 1320 4106 1
a 1321 1322 2785
a 1321 4106 1
a 1322 1323 2784
a 1322 4106 1
a 1323 1324 2783
a 1323 4106 1
a 1324 1325 2782
a 1324 4106 1
a 1325 1326 2781
a 1325 4106 1
a 1326 1327 2780
a 1326 4106 1
a 1327 1328 2779
a 1327 4106 1
a 1328 1329 2778
a 1328 4106 1
a 1329 1330 2777
a 1329 4106 1
a 1330 1331 2776
a 1330 4106 1
a 1331 1332 2775
a 1331 4106 1
a 1332 1333 2774
a 1332 4106 1
a 1333 1334 2773
a 1333 4106 1
a 1334 1335 2772
a 1334 4106 1
a 1335 1336 2771
a 1335 4106 1
a 1336 1337 2770
a 1336 4106 1
a 1337 1338 2769
a 1337 4106 1
a 1338 1339 2768
a 1338 4106 1
a 1339 1340 2767
a 1339 4106 1
a 1340 1341 2766
a 1340 4106 1
a 1341 1342 2765
a 1341 4106 1
a 1342 1343 2764
a 1342 4106 1
a 1343 1344 2763
a 1343 4106 1
a 1344 1345 2762
a 1344 4106 1
a 1345 1346 2761
a 1345 4106 1
a 1346 1347 2760
a 1346 4106 1
a 1347 1348 2759
a 1347 4106 1
a 1348 1349 2758
a 1348 4106 1
a 1349 1350 2757
a 1349 4106 1
a 1350 1351 2756
a 1350 4106 1
a 1351 1352 2755
a 1351 4106 1
a 1352 1353 2754
a 1352 4106 1
a 1353 1354 2753
a 1353 4106 1
a 1354 1355 2752
a 1354 4106 1
a 1355 1356 2751
a 1355 4106 1
a 1356 1357 2750
a 1356 4106 1
a 1357 1358 2749
a 1357 4106 1
a 1358 1359 2748
a 1358 4106 1
a 1359 1360 2747
a 1359 4106 1
a 1360 1361 2746
a 1360 4106 1
a 1361 1362 2745
a 1361 4106 1
a 1362 1363 2744
a 1362 4106 1
a 1363 1364 2743
a 1363 4106 1
a 1364 1365 2742
a 1364 4106 1
a 1365 1366 2741
a 1365 4106 1
a 1366 1367 2740
a 1366 4106 1
a 1367 1368 2739
a 1367 4106 1
a 1368 1369 2738
a 1368 4106 1
a 1369 1370 2737
a 1369 4106 1
a 1370 1371 2736
a 1370 4106 1
a 1371 1372 2735
a 1371 4106 1
a 1372 1373 2734
a 1372 4106 1
a 1373 1374 2733
a 1373 4106 1
a 1374 1375 2732
a 1374 4106 1
a 1375 1376 2731
a 1375 4106 1
a 1376 1377 2730
a 1376 4106 1
a 1377 1378 2729
a 1377 4106 1
a 1378 1379 2728
a 1378 4106 1
a 1379 1380 2727
a 1379 4106 1
a 1380 1381 2726
a 1380 4106 1
a 1381 1382 2725
a 1381 4106 1
a 1382 1383 2724
a 1382 4106 1
a 1383 1384 2723
a 1383 4106 1
a 1384 1385 2722
a 1384 4106 1
a 1385 1386 2721
a 1385 4106 1
a 1386 1387 2720
a 1386 4106 1
a 1387 1388 2719
a 1387 4106 1
a 1388 1389 2718
a 1388 4106 1
a 1389 1390 2717
a 1389 4106 1
a 1390 1391 2716
a 1390 4106 1
a 1391 1392 2715
a 1391 4106 1
a 1392 1393 2714
a 1392 4106 1
a 1393 1394 2713
a 1393 4106 1
a 1394 1395 2712
a 1394 4106 1
a 1395 1396 2711
a 1395 4106 1
a 1396 1397 2710
a 1396 4106 1
a 1397 1398 2709
a 1397 4106 1
a 1398 1399 2708
a 1398 4106 1
a 1399 1400 2707
a 1399 4106 1
a 1400 1401 2706
a 1400 4106 1
a 1401 1402 2705
a 1401 4106 1
a 1402 1403 2704
a 1402 4106 1
a 1403 1404 2703
a 1403 4106 1
a 1404 1405 2702
a 1404 4106 1
a 1405 1406 2701
a 1405 4106 1
a 1406 1407 2700
a 1406 4106 1
a 1407 1408 2699
a 1407 4106 1
a 1408 1409 2698
a 1408 4106 1
a 1409 1410 2697
a 1409 4106 1
a 1410 1411 2696
a 1410 4106 1
a 1411 1412 2695
a 1411 4106 1
a 1412 1413 2694
a 1412 4106 1
a 1413 1414 2693
a 1413 4106 1
a 1414 1415 2692
a 1414 4106 1
a 1415 1416 2691
a 1415 4106 1
a 1416 1417 2690
a 1416 4106 1
a 1417 1418 2689
a 1417 4106 1
a 1418 1419 2688
a 1418 4106 1
a 1419 1420 2687
a 1419 4106 1
a 1420 1421 2686
a 1420 4106 1
a 1421 1422 2685
a 1421 4106 1
a 1422 1423 2684
a 1422 4106 1
a 1423 1424 2683
a 1423 4106 1
a 1424 1425 2682
a 1424 4106 1
a 1425 1426 2681
a 1425 4106 1
a 1426 1427 2680
a 1426 4106 1
a 1427 1428 2679
a 1427 4106 1
a 1428 1429 2678
a 1428 4106 1
a 1429 1430 2677
a 1429 4106 1
a 1430 1431 2676
a 1430 4106 1
a 1431 1432 2675
a 1431 4106 1
a 1432 1433 2674
a 1432 4106 1
a 1433 1434 2673
a 1433 4106 1
a 1434 1435 2672
a 1434 4106 1
a 1435 1436 2671
a 1435 4106 1
a 1436 1437 2670
a 1436 4106 1
a 1437 1438 2669
a 1437 4106 1
a 1438 1439 2668
a 1438 4106 1
a 1439 1440 2667
a 1439 4106 1
a 1440 1441 2666
a 1440 4106 1
a 1441 1442 2665
a 1441 4106 1
a 1442 1443 2664
a 1442 4106 1
a 1443 1444 2663
a 1443 4106 1
a 1444 1445 2662
a 1444 4106 1
a 1445 1446 2661
a 1445 4106 1
a 1446 1447 2660
a 1446 4106 1
a 1447 1448 2659
a 1447 4106 1
a 1448 1449 2658
a 1448 4106 1
a 1449 1450 2657
a 1449 4106 1
a 1450 1451 2656
a 1450 4106 1
a 1451 1452 2655
a 1451 4106 1
a 1452 1453 2654
a 1452 4106 1
a 1453 1454 2653
a 1453 4106 1
a 1454 1455 2652
a 1454 4106 1
a 1455 1456 2651
a 1455 4106 1
a 1456 1457 2650
a 1456 4106 1
a 1457 1458 2649
a 1457 4106 1
a 1458 1459 2648
a 1458 4106 1
a 1459 1460 2647
a 1459 4106 1
a 1460 1461 2646
a 1460 4106 1
a 1461 1462 2645
a 1461 4106 1
a 1462 1463 2644
a 1462 4106 1
a 1463 1464 2643
a 1463 4106 1
a 1464 1465 2642
a 1464 4106 1
a 1465 1466 2641
a 1465 4106 1
a 1466 1467 2640
a 1466 4106 1
a 1467 1468 2639
a 1467 4106 1
a 1468 1469 2638
a 1468 4106 1
a 1469 1470 2637
a 1469 4106 1
a 1470 1471 2636
a 1470 4106 1
a 1471 1472 2635
a 1471 4106 1
a 1472 1473 2634
a 1472 4106 1
a 1473 1474 2633
a 1473 4106 1
a 1474 1475 2632
a 1474 4106 1
a 1475 1476 2631
a 1475 4106 1
a 1476 1477 2630
a 1476 4106 1
a 1477 1478 2629
a 1477 4106 1
a 1478 1479 2628
a 1478 4106 1
a 1479 1480 2627
a 1479 4106 1
a 1480 1481 2626
a 1480 4106 1
a 1481 1482 2625
a 1481 4106 1
a 1482 1483 2624
a 1482 4106 1
a 1483 1484 2623
a 1483 4106 1
a 1484 1485 2622
a 1484 4106 1
a 1485 1486 2621
a 1485 4106 1
a 1486 1487 2620
a 1486 4106 1
a 1487 1488 2619
a 1487 4106 1
a 1488 1489 2618
a 1488 4106 1
a 1489 1490 2617
a 1489 4106 1
a 1490 1491 2616
a 1490 4106 1
a 1491 1492 2615
a 1491 4106 1
a 1492 1493 2614
a 1492 4106 1
a 1493 1494 2613
a 1493 4106 1
a 1494 1495 2612
a 1494 4106 1
a 1495 1496 2611
a 1495 4106 1
a 1496 1497 2610
a 1496 4106 1
a 1497 1498 2609
a 1497 4106 1
a 1498 1499 2608
a 1498 4106 1
a 1499 1500 2607
a 1499 4106 1
a 1500 1501 2606
a 1500 4106 1
a 1501 1502 2605
a 1501 4106 1
a 1502 1503 2604
a 1502 4106 1
a 1503 1504 2603
a 1503 4106 1
a 1504 1505 2602
a 1504 4106 1
a 1505 1506 2601
a 1505 4106 1
a 1506 1507 2600
a 1506 4106 1
a 1507 1508 2599
a 1507 4106 1
a 1508 1509 2598
a 1508 4106 1
a 1509 1510 2597
a 1509 4106 1
a 1510 1511 2596
a 1510 4106 1
a 1511 1512 2595
a 1511 4106 1
a 1512 1513 2594
a 1512 4106 1
a 1513 1514 2593
a 1513 4106 1
a 1514 1515 2592
a 1514 4106 1
a 1515 1516 2591
a 1515 4106 1
a 1516 1517 2590
a 1516 4106 1
a 1517 1518 2589
a 1517 4106 1
a 1518 1519 2588
a 1518 4106 1
a 1519 1520 2587
a 1519 4106 1
a 1520 1521 2586
a 1520 4106 1
a 1521 1522 2585
a 1521 4106 1
a 1522 1523 2584
a 1522 4106 1
a 1523 1524 2583
a 1523 4106 1
a 1524 1525 2582
a 1524 4106 1
a 1525 1526 2581
a 1525 4106 1
a 1526 1527 2580
a 1526 4106 1
a 1527 1528 2579
a 1527 4106 1
a 1528 1529 2578
a 1528 4106 1
a 1529 1530 2577
a 1529 4106 1
a 1530 1531 2576
a 1530 4106 1
a 1531 1532 2575
a 1531 4106 1
a 1532 1533 2574
a 1532 4106 1
a 1533 1534 2573
a 1533 4106 1
a 1534 1535 2572
a 1534 4106 1
a 1535 1536 2571
a 1535 4106 1
a 1536 1537 2570
a 1536 4106 1
a 1537 1538 2569
a 1537 4106 1
a 1538 1539 2568
a 1538 4106 1
a 1539 1540 2567
a 1539 4106 1
a 1540 1541 2566
a 1540 4106 1
a 1541 1542 2565
a 1541 4106 1
a 1542 1543 2564
a 1542 4106 1
a 1543 1544 2563
a 1543 4106 1
a 1544 1545 2562
a 1544 4106 1
a 1545 1546 2561
a 1545 4106 1
a 1546 1547 2560
a 1546 4106 1
a 1547 1548 2559
a 1547 4106 1
a 1548 1549 2558
a 1548 4106 1
a 1549 1550 2557
a 1549 4106 1
a 1550 1551 2556
a 1550 4106 1
a 1551 1552 2555
a 1551 4106 1
a 1552 1553 2554
a 1552 4106 1
a 1553 1554 2553
a 1553 4106 1
a 1554 1555 2552
a 1554 4106 1
a 1555 1556 2551
a 1555 4106 1
a 1556 1557 2550
a 1556 4106 1
a 1557 1558 2549
a 1557 4106 1
a 1558 1559 2548
a 1558 4106 1
a 1559 1560 2547
a 1559 4106 1
a 1560 1561 2546
a 1560 4106 1
a 1561 1562 2545
a 1561 4106 1
a 1562 1563 2544
a 1562 4106 1
a 1563 1564 2543
a 1563 4106 1
a 1564 1565 2542
a 1564 4106 1
a 1565 1566 2541
a 1565 4106 1
a 1566 1567 2540
a 1566 4106 1
a 1567 1568 2539
a 1567 4106 1
a 1568 1569 2538
a 1568 4106 1
a 1569 1570 2537
a 1569 4106 1
a 1570 1571 2536
a 1570 4106 1
a 1571 1572 2535
a 1571 4106 1
a 1572 1573 2534
a 1572 4106 1
a 1573 1574 2533
a 1573 4106 1
a 1574 1575 2532
a 1574 4106 1
a 1575 1576 2531
a 1575 4106 1
a 1576 1577 2530
a 1576 4106 1
a 1577 1578 2529
a 1577 4106 1
a 1578 1579 2528
a 1578 4106 1
a 1579 1580 2527
a 1579 4106 1
a 1580 1581 2526
a 1580 4106 1
a 1581 1582 2525
a 1581 4106 1
a 1582 1583 2524
a 1582 4106 1
a 1583 1584 2523
a 1583 4106 1
a 1584 1585 2522
a 1584 4106 1
a 1585 1586 2521
a 1585 4106 1
a 1586 1587 2520
a 1586 4106 1
a 1587 1588 2519
a 1587 4106 1
a 1588 1589 2518
a 1588 4106 1
a 1589 1590 2517
a 1589 4106 1
a 1590 1591 2516
a 1590 4106 1
a 1591 1592 2515
a 1591 4106 1
a 1592 1593 2514
a 1592 4106 1
a 1593 1594 2513
a 1593 4106 1
a 1594 1595 2512
a 1594 4106 1
a 1595 1596 2511
a 1595 4106 1
a 1596 1597 2510
a 1596 4106 1
a 1597 1598 2509
a 1597 4106 1
a 1598 1599 2508
a 1598 4106 1
a 1599 1600 2507
a 1599 4106 1
a 1600 1601 2506
a 1600 4106 1
a 1601 1602 2505
a 1601 4106 1
a 1602 1603 2504
a 1602 4106 1
a 1603 1604 2503
a 1603 4106 1
a 1604 1605 2502
a 1604 4106 1
a 1605 1606 2501
a 1605 4106 1
a 1606 1607 2500
a 1606 4106 1
a 1607 1608 2499
a 1607 4106 1
a 1608 1609 2498
a 1608 4106 1
a 1609 1610 2497
a 1609 4106 1
a 1610 1611 2496
a 1610 4106 1
a 1611 1612 2495
a 1611 4106 1
a 1612 1613 2494
a 1612 4106 1
a 1613 1614 2493
a 1613 4106 1
a 1614 1615 2492
a 1614 4106 1
a 1615 1616 2491
a 1615 4106 1
a 1616 1617 2490
a 1616 4106 1
a 1617 1618 2489
a 1617 4106 1
a 1618 1619 2488
a 1618 4106 1
a 1619 1620 2487
a 1619 4106 1
a 1620 1621 2486
a 1620 4106 1
a 1621 1622 2485
a 1621 4106 1
a 1622 1623 2484
a 1622 4106 1
a 1623 1624 2483
a 1623 4106 1
a 1624 1625 2482
a 1624 4106 1
a 1625 1626 2481
a 1625 4106 1
a 1626 1627 2480
a 1626 4106 1
a 1627 1628 2479
a 1627 4106 1
a 1628 1629 2478
a 1628 4106 1
a 1629 1630 2477
a 1629 4106 1
a 1630 1631 2476
a 1630 4106 1
a 1631 1632 2475
a 1631 4106 1
a 1632 1633 2474
a 1632 4106 1
a 1633 1634 2473
a 1633 4106 1
a 1634 1635 2472
a 1634 4106 1
a 1635 1636 2471
a 1635 4106 1
a 1636 1637 2470
a 1636 4106 1
a 1637 1638 2469
a 1637 4106 1
a 1638 1639 2468
a 1638 4106 1
a 1639 1640 2467
a 1639 4106 1
a 1640 1641 2466
a 1640 4106 1
a 1641 1642 2465
a 1641 4106 1
a 1642 1643 2464
a 1642 4106 1
a 1643 1644 2463
a 1643 4106 1
a 1644 1645 2462
a 1644 4106 1
a 1645 1646 2461
a 1645 4106 1
a 1646 1647 2460
a 1646 4106 1
a 1647 1648 2459
a 1647 4106 1
a 1648 1649 2458
a 1648 4106 1
a 1649 1650 2457
a 1649 4106 1
a 1650 1651 2456
a 1650 4106 1
a 1651 1652 2455
a 1651 4106 1
a 1652 1653 2454
a 1652 4106 1
a 1653 1654 2453
a 1653 4106 1
a 1654 1655 2452
a 1654 4106 1
a 1655 1656 2451
a 1655 4106 1
a 1656 1657 2450
a 1656 4106 1
a 1657 1658 2449
a 1657 4106 1
a 1658 1659 2448
a 1658 4106 1
a 1659 1660 2447
a 1659 4106 1
a 1660 1661 2446
a 1660 4106 1
a 1661 1662 2445
a 1661 4106 1
a 1662 1663 2444
a 1662 4106 1
a 1663 1664 2443
a 1663 4106 1
a 1664 1665 2442
a 1664 4106 1
a 1665 1666 2441
a 1665 4106 1
a 1666 1667 2440
a 1666 4106 1
a 1667 1668 2439
a 1667 4106 1
a 1668 1669 2438
a 1668 4106 1
a 1669 1670 2437
a 1669 4106 1
a 1670 1671 2436
a 1670 4106 1
a 1671 1672 2435
a 1671 4106 1
a 1672 1673 2434
a 1672 4106 1
a 1673 1674 2433
a 1673 4106 1
a 1674 1675 2432
a 1674 4106 1
a 1675 1676 2431
a 1675 4106 1
a 1676 1677 2430
a 1676 4106 1
a 1677 1678 2429
a 1677 4106 1
a 1678 1679 2428
a 1678 4106 1
a 1679 1680 2427
a 1679 4106 1
a 1680 1681 2426
a 1680 4106 1
a 1681 1682 2425
a 1681 4106 1
a 1682 1683 2424
a 1682 4106 1
a 1683 1684 2423
a 1683 4106 1
a 1684 1685 2422
a 1684 4106 1
a 1685 1686 2421
a 1685 4106 1
a 1686 1687 2420
a 1686 4106 1
a 1687 1688 2419
a 1687 4106 1
a 1688 1689 2418
a 1688 4106 1
a 1689 1690 2417
a 1689 4106 1
a 1690 1691 2416
a 1690 4106 1
a 1691 1692 2415
a 1691 4106 1
a 1692 1693 2414
a 1692 4106 1
a 1693 1694 2413
a 1693 4106 1
a 1694 1695 2412
a 1694 4106 1
a 1695 1696 2411
a 1695 4106 1
a 1696 1697 2410
a 1696 4106 1
a 1697 1698 2409
a 1697 4106 1
a 1698 1699 2408
a 1698 4106 1
a 1699 1700 2407
a 1699 4106 1
a 1700 1701 2406
a 1700 4106 1
a 1701 1702 2405
a 1701 4106 1
a 1702 1703 2404
a 1702 4106 1
a 1703 1704 2403
a 1703 4106 1
a 1704 1705 2402
a 1704 4106 1
a 1705 1706 2401
a 1705 4106 1
a 1706 1707 2400
a 1706 4106 1
a 1707 1708 2399
a 1707 4106 1
a 1708 1709 2398
a 1708 4106 1
a 1709 1710 2397
a 1709 4106 1
a 1710 1711 2396
a 1710 4106 1
a 1711 1712 2395
a 1711 4106 1
a 1712 1713 2394
a 1712 4106 1
a 1713 1714 2393
a 1713 4106 1
a 1714 1715 2392
a 1714 4106 1
a 1715 1716 2391
a 1715 4106 1
a 1716 1717 2390
a 1716 4106 1
a 1717 1718 2389
a 1717 4106 1
a 1718 1719 2388
a 1718 4106 1
a 1719 1720 2387
a 1719 4106 1
a 1720 1721 2386
a 1720 4106 1
a 1721 1722 2385
a 1721 4106 1
a 1722 1723 2384
a 1722 4106 1
a 1723 1724 2383
a 1723 4106 1
a 1724 1725 2382
a 1724 4106 1
a 1725 1726 2381
a 1725 4106 1
a 1726 1727 2380
a 1726 4106 1
a 1727 1728 2379
a 1727 4106 1
a 1728 1729 2378
a 1728 4106 1
a 1729 1730 2377
a 1729 4106 1
a 1730 1731 2376
a 1730 4106 1
a 1731 1732 2375
a 1731 4106 1
a 1732 1733 2374
a 1732 4106 1
a 1733 1734 2373
a 1733 4106 1
a 1734 1735 2372
a 1734 4106 1
a 1735 1736 2371
a 1735 4106 1
a 1736 1737 2370
a 1736 4106 1
a 1737 1738 2369
a 1737 4106 1
a 1738 1739 2368
a 1738 4106 1
a 1739 1740 2367
a 1739 4106 1
a 1740 1741 2366
a 1740 4106 1
a 1741 1742 2365
a 1741 4106 1
a 1742 1743 2364
a 1742 4106 1
a 1743 1744 2363
a 1743 4106 1
a 1744 1745 2362
a 1744 4106 1
a 1745 1746 2361
a 1745 4106 1
a 1746 1747 2360
a 1746 4106 1
a 1747 1748 2359
a 1747 4106 1
a 1748 1749 2358
a 1748 4106 1
a 1749 1750 2357
a 1749 4106 1
a 1750 1751 2356
a 1750 4106 1
a 1751 1752 2355
a 1751 4106 1
a 1752 1753 2354
a 1752 4106 1
a 1753 1754 2353
a 1753 4106 1
a 1754 1755 2352
a 1754 4106 1
a 1755 1756 2351
a 1755 4106 1
a 1756 1757 2350
a 1756 4106 1
a 1757 1758 2349
a 1757 4106 1
a 1758 1759 2348
a 1758 4106 1
a 1759 1760 2347
a 1759 4106 1
a 1760 1761 2346
a 1760 4106 1
a 1761 1762 2345
a 1761 4106 1
a 1762 1763 2344
a 1762 4106 1
a 1763 1764 2343
a 1763 4106 1
a 1764 1765 2342
a 1764 4106 1
a 1765 1766 2341
a 1765 4106 1
a 1766 1767 2340
a 1766 4106 1
a 1767 1768 2339
a 1767 4106 1
a 1768 1769 2338
a 1768 4106 1
a 1769 1770 2337
a 1769 4106 1
a 1770 1771 2336
a 1770 4106 1
a 1771 1772 2335
a 1771 4106 1
a 1772 1773 2334
a 1772 4106 1
a 1773 1774 2333
a 1773 4106 1
a 1774 1775 2332
a 1774 4106 1
a 1775 1776 2331
a 1775 4106 1
a 1776 1777 2330
a 1776 4106 1
a 1777 1778 2329
a 1777 4106 1
a 1778 1779 2328
a 1778 4106 1
a 1779 1780 2327
a 1779 4106 1
a 1780 1781 2326
a 1780 4106 1
a 1781 1782 2325
a 1781 4106 1
a 1782 1783 2324
a 1782 4106 1
a 1783 1784 2323
a 1783 4106 1
a 1784 1785 2322
a 1784 4106 1
a 1785 1786 2321
a 1785 4106 1
a 1786 1787 2320
a 1786 4106 1
a 1787 1788 2319
a 1787 4106 1
a 1788 1789 2318
a 1788 4106 1
a 1789 1790 2317
a 1789 4106 1
a 1790 1791 2316
a 1790 4106 1
a 1791 1792 2315
a 1791 4106 1
a 1792 1793 2314
a 1792 4106 1
a 1793 1794 2313
a 1793 4106 1
a 1794 1795 2312
a 1794 4106 1
a 1795 1796 2311
a 1795 4106 1
a 1796 1797 2310
a 1796 4106 1
a 1797 1798 2309
a 1797 4106 1
a 1798 1799 2308
a 1798 4106 1
a 1799 1800 2307
a 1799 4106 1
a 1800 1801 2306
a 1800 4106 1
a 1801 1802 2305
a 1801 4106 1
a 1802 1803 2304
a 1802 4106 1
a 1803 1804 2303
a 1803 4106 1
a 1804 1805 2302
a 1804 4106 1
a 1805 1806 2301
a 1805 4106 1
a 1806 1807 2300
a 1806 4106 1
a 1807 1808 2299
a 1807 4106 1
a 1808 1809 2298
a 1808 4106 1
a 1809 1810 2297
a 1809 4106 1
a 1810 1811 2296
a 1810 4106 1
a 1811 1812 2295
a 1811 4106 1
a 1812 1813 2294
a 1812 4106 1
a 1813 1814 2293
a 1813 4106 1
a 1814 1815 2292
a 1814 4106 1
a 1815 1816 2291
a 1815 4106 1
a 1816 1817 2290
a 1816 4106 1
a 1817 1818 2289
a 1817 4106 1
a 1818 1819 2288
a 1818 4106 1
a 1819 1820 2287
a 1819 4106 1
a 1820 1821 2286
a 1820 4106 1
a 1821 1822 2285
a 1821 4106 1
a 1822 1823 2284
a 1822 4106 1
a 1823 1824 2283
a 1823 4106 1
a 1824 1825 2282
a 1824 4106 1
a 1825 1826 2281
a 1825 4106 1
a 1826 1827 2280
a 1826 4106 1
a 1827 1828 2279
a 1827 4106 1
a 1828 1829 2278
a 1828 4106 1
a 1829 1830 2277
a 1829 4106 1
a 1830 1831 2276
a 1830 4106 1
a 1831 1832 2275
a 1831 4106 1
a 1832 1833 2274
a 1832 4106 1
a 1833 1834 2273
a 1833 4106 1
a 1834 1835 2272
a 1834 4106 1
a 1835 1836 2271
a 1835 4106 1
a 1836 1837 2270
a 1836 4106 1
a 1837 1838 2269
a 1837 4106 1
a 1838 1839 2268
a 1838 4106 1
a 1839 1840 2267
a 1839 4106 1
a 1840 1841 2266
a 1840 4106 1
a 1841 1842 2265
a 1841 4106 1
a 1842 1843 2264
a 1842 4106 1
a 1843 1844 2263
a 1843 4106 1
a 1844 1845 2262
a 1844 4106 1
a 1845 1846 2261
a 1845 4106 1
a 1846 1847 2260
a 1846 4106 1
a 1847 1848 2259
a 1847 4106 1
a 1848 1849 2258
a 1848 4106 1
a 1849 1850 2257
a 1849 4106 1
a 1850 1851 2256
a 1850 4106 1
a 1851 1852 2255
a 1851 4106 1
a 1852 1853 2254
a 1852 4106 1
a 1853 1854 2253
a 1853 4106 1
a 1854 1855 2252
a 1854 4106 1
a 1855 1856 2251
a 1855 4106 1
a 1856 1857 2250
a 1856 4106 1
a 1857 1858 2249
a 1857 4106 1
a 1858 1859 2248
a 1858 4106 1
a 1859 1860 2247
a 1859 4106 1
a 1860 1861 2246
a 1860 4106 1
a 1861 1862 2245
a 1861 4106 1
a 1862 1863 2244
a 1862 4106 1
a 1863 1864 2243
a 1863 4106 1
a 1864 1865 2242
a 1864 4106 1
a 1865 1866 2241
a 1865 4106 1
a 1866 1867 2240
a 1866 4106 1
a 1867 1868 2239
a 1867 4106 1
a 1868 1869 2238
a 1868 4106 1
a 1869 1870 2237
a 1869 4106 1
a 1870 1871 2236
a 1870 4106 1
a 1871 1872 2235
a 1871 4106 1
a 1872 1873 2234
a 1872 4106 1
a 1873 1874 2233
a 1873 4106 1
a 1874 1875 2232
a 1874 4106 1
a 1875 1876 2231
a 1875 4106 1
a 1876 1877 2230
a 1876 4106 1
a 1877 1878 2229
a 1877 4106 1
a 1878 1879 2228
a 1878 4106 1
a 1879 1880 2227
a 1879 4106 1
a 1880 1881 2226
a 1880 4106 1
a 1881 1882 2225
a 1881 4106 1
a 1882 1883 2224
a 1882 4106 1
a 1883 1884 2223
a 1883 4106 1
a 1884 1885 2222
a 1884 4106 1
a 1885 1886 2221
a 1885 4106 1
a 1886 1887 2220
a 1886 4106 1
a 1887 1888 2219
a 1887 4106 1
a 1888 1889 2218
a 1888 4106 1
a 1889 1890 2217
a 1889 4106 1
a 1890 1891 2216
a 1890 4106 1
a 1891 1892 2215
a 1891 4106 1
a 1892 1893 2214
a 1892 4106 1
a 1893 1894 2213
a 1893 4106 1
a 1894 1895 2212
a 1894 4106 1
a 1895 1896 2211
a 1895 4106 1
a 1896 1897 2210
a 1896 4106 1
a 1897 1898 2209
a 1897 4106 1
a 1898 1899 2208
a 1898 4106 1
a 1899 1900 2207
a 1899 4106 1
a 1900 1901 2206
a 1900 4106 1
a 1901 1902 2205
a 1901 4106 1
a 1902 1903 2204
a 1902 4106 1
a 1903 1904 2203
a 1903 4106 1
a 1904 1905 2202
a 1904 4106 1
a 1905 1906 2201
a 1905 4106 1
a 1906 1907 2200
a 1906 4106 1
a 1907 1908 2199
a 1907 4106 1
a 1908 1909 2198
a 1908 4106 1
a 1909 1910 2197
a 1909 4106 1
a 1910 1911 2196
a 1910 4106 1
a 1911 1912 2195
a 1911 4106 1
a 1912 1913 2194
a 1912 4106 1
a 1913 1914 2193
a 1913 4106 1
a 1914 1915 2192
a 1914 4106 1
a 1915 1916 2191
a 1915 4106 1
a 1916 1917 2190
a 1916 4106 1
a 1917 1918 2189
a 1917 4106 1
a 1918 1919 2188
a 1918 4106 1
a 1919 1920 2187
a 1919 4106 1
a 1920 1921 2186
a 1920 4106 1
a 1921 1922 2185
a 1921 4106 1
a 1922 1923 2184
a 1922 4106 1
a 1923 1924 2183
a 1923 4106 1
a 1924 1925 2182
a 1924 4106 1
a 1925 1926 2181
a 1925 4106 1
a 1926 1927 2180
a 1926 4106 1
a 1927 1928 2179
a 1927 4106 1
a 1928 1929 2178
a 1928 4106 1
a 1929 1930 2177
a 1929 4106 1
a 1930 1931 2176
a 1930 4106 1
a 1931 1932 2175
a 1931 4106 1
a 1932 1933 2174
a 1932 4106 1
a 1933 1934 2173
a 1933 4106 1
a 1934 1935 2172
a 1934 4106 1
a 1935 1936 2171
a 1935 4106 1
a 1936 1937 2170
a 1936 4106 1
a 1937 1938 2169
a 1937 4106 1
a 1938 1939 2168
a 1938 4106 1
a 1939 1940 2167
a 1939 4106 1
a 1940 1941 2166
a 1940 4106 1
a 1941 1942 2165
a 1941 4106 1
a 1942 1943 2164
a 1942 4106 1
a 1943 1944 2163
a 1943 4106 1
a 1944 1945 2162
a 1944 4106 1
a 1945 1946 2161
a 1945 4106 1
a 1946 1947 2160
a 1946 4106 1
a 1947 1948 2159
a 1947 4106 1
a 1948 1949 2158
a 1948 4106 1
a 1949 1950 2157
a 1949 4106 1
a 1950 1951 2156
a 1950 4106 1
a 1951 1952 2155
a 1951 4106 1
a 1952 1953 2154
a 1952 4106 1
a 1953 1954 2153
a 1953 4106 1
a 1954 1955 2152
a 1954 4106 1
a 1955 1956 2151
a 1955 4106 1
a 1956 1957 2150
a 1956 4106 1
a 1957 1958 2149
a 1957 4106 1
a 1958 1959 2148
a 1958 4106 1
a 1959 1960 2147
a 1959 4106 1
a 1960 1961 2146
a 1960 4106 1
a 1961 1962 2145
a 1961 4106 1
a 1962 1963 2144
a 1962 4106 1
a 1963 1964 2143
a 1963 4106 1
a 1964 1965 2142
a 1964 4106 1
a 1965 1966 2141
a 1965 4106 1
a 1966 1967 2140
a 1966 4106 1
a 1967 1968 2139
a 1967 4106 1
a 1968 1969 2138
a 1968 4106 1
a 1969 1970 2137
a 1969 4106 1
a 1970 1971 2136
a 1970 4106 1
a 1971 1972 2135
a 1971 4106 1
a 1972 1973 2134
a 1972 4106 1
a 1973 1974 2133
a 1973 4106 1
a 1974 1975 2132
a 1974 4106 1
a 1975 1976 2131
a 1975 4106 1
a 1976 1977 2130
a 1976 4106 1
a 1977 1978 2129
a 1977 4106 1
a 1978 1979 2128
a 1978 4106 1
a 1979 1980 2127
a 1979 4106 1
a 1980 1981 2126
a 1980 4106 1
a 1981 1982 2125
a 1981 4106 1
a 1982 1983 2124
a 1982 4106 1
a 1983 1984 2123
a 1983 4106 1
a 1984 1985 2122
a 1984 4106 1
a 1985 1986 2121
a 1985 4106 1
a 1986 1987 2120
a 1986 4106 1
a 1987 1988 2119
a 1987 4106 1
a 1988 1989 2118
a 1988 4106 1
a 1989 1990 2117
a 1989 4106 1
a 1990 1991 2116
a 1990 4106 1
a 1991 1992 2115
a 1991 4106 1
a 1992 1993 2114
a 1992 4106 1
a 1993 1994 2113
a 1993 4106 1
a 1994 1995 2112
a 1994 4106 1
a 1995 1996 2111
a 1995 4106 1
a 1996 1997 2110
a 1996 4106 1
a 1997 1998 2109
a 1997 4106 1
a 1998 1999 2108
a 1998 4106 1
a 1999 2000 2107
a 1999 4106 1
a 2000 2001 2106
a 2000 4106 1
a 2001 2002 2105
a 2001 4106 1
a 2002 2003 2104
a 2002 4106 1
a 2003 2004 2103
a 2003 4106 1
a 2004 2005 2102
a 2004 4106 1
a 2005 2006 2101
a 2005 4106 1
a 2006 2007 2100
a 2006 4106 1
a 2007 2008 2099
a 2007 4106 1
a 2008 2009 2098
a 2008 4106 1
a 2009 2010 2097
a 2009 4106 1
a 2010 2011 2096
a 2010 4106 1
a 2011 2012 2095
a 2011 4106 1
a 2012 2013 2094
a 2012 4106 1
a 2013 2014 2093
a 2013 4106 1
a 2014 2015 2092
a 2014 4106 1
a 2015 2016 2091
a 2015 4106 1
a 2016 2017 2090
a 2016 4106 1
a 2017 2018 2089
a 2017 4106 1
a 2018 2019 2088
a 2018 4106 1
a 2019 2020 2087
a 2019 4106 1
a 2020 2021 2086
a 2020 4106 1
a 2021 2022 2085
a 2021 4106 1
a 2022 2023 2084
a 2022 4106 1
a 2023 2024 2083
a 2023 4106 1
a 2024 2025 2082
a 2024 4106 1
a 2025 2026 2081
a 2025 4106 1
a 2026 2027 2080
a 2026 4106 1
a 2027 2028 2079
a 2027 4106 1
a 2028 2029 2078
a 2028 4106 1
a 2029 2030 2077
a 2029 4106 1
a 2030 2031 2076
a 2030 4106 1
a 2031 2032 2075
a 2031 4106 1
a 2032 2033 2074
a 2032 4106 1
a 2033 2034 2073
a 2033 4106 1
a 2034 2035 2072
a 2034 4106 1
a 2035 2036 2071
a 2035 4106 1
a 2036 2037 2070
a 2036 4106 1
a 2037 2038 2069
a 2037 4106 1
a 2038 2039 2068
a 2038 4106 1
a 2039 2040 2067
a 2039 4106 1
a 2040 2041 2066
a 2040 4106 1
a 2041 2042 2065
a 2041 4106 1
a 2042 2043 2064
a 2042 4106 1
a 2043 2044 2063
a 2043 4106 1
a 2044 2045 2062
a 2044 4106 1
a 2045 2046 2061
a 2045 4106 1
a 2046 2047 2060
a 2046 4106 1
a 2047 2048 2059
a 2047 4106 1
a 2048 2049 2058
a 2048 4106 1
a 2049 2050 2057
a 2049 4106 1
a 2050 2051 2056
a 2050 4106 1
a 2051 2052 2055
a 2051 4106 1
a 2052 2053 2054
a 2052 4106 1
a 2053 2054 2053
a 2053 4106 1
a 2054 2055 2052
a 2054 4106 1
a 2055 2056 2051
a 2055 4106 1
a 2056 2057 2050
a 2056 4106 1
a 2057 2058 2049
a 2057 4106 1
a 2058 2059 2048
a 2058 4106 1
a 2059 2060 2047
a 2059 4106 1
a 2060 2061 2046
a 2060 4106 1
a 2061 2062 2045
a 2061 4106 1
a 2062 2063 2044
a 2062 4106 1
a 2063 2064 2043
a 2063 4106 1
a 2064 2065 2042
a 2064 4106 1
a 2065 2066 2041
a 2065 4106 1
a 2066 2067 2040
a 2066 4106 1
a 2067 2068 2039
a 2067 4106 1
a 2068 2069 2038
a 2068 4106 1
a 2069 2070 2037
a 2069 4106 1
a 2070 2071 2036
a 2070 4106 1
a 2071 2072 2035
a 2071 4106 1
a 2072 2073 2034
a 2072 4106 1
a 2073 2074 2033
a 2073 4106 1
a 2074 2075 2032
a 2074 4106 1
a 2075 2076 2031
a 2075 4106 1
a 2076 2077 2030
a 2076 4106 1
a 2077 2078 2029
a 2077 4106 1
a 2078 2079 2028
a 2078 4106 1
a 2079 2080 2027
a 2079 4106 1
a 2080 2081 2026
a 2080 4106 1
a 2081 2082 2025
a 2081 4106 1
a 2082 2083 2024
a 2082 4106 1
a 2083 2084 2023
a 2083 4106 1
a 2084 2085 2022
a 2084 4106 1
a 2085 2086 2021
a 2085 4106 1
a 2086 2087 2020
a 2086 4106 1
a 2087 2088 2019
a 2087 4106 1
a 2088 2089 2018
a 2088 4106 1
a 2089 2090 2017
a 2089 4106 1
a 2090 2091 2016
a 2090 4106 1
a 2091 2092 2015
a 2091 4106 1
a 2092 2093 2014
a 2092 4106 1
a 2093 2094 2013
a 2093 4106 1
a 2094 2095 2012
a 2094 4106 1
a 2095 2096 2011
a 2095 4106 1
a 2096 2097 2010
a 2096 4106 1
a 2097 2098 2009
a 2097 4106 1
a 2098 2099 2008
a 2098 4106 1
a 2099 2100 2007
a 2099 4106 1
a 2100 2101 2006
a 2100 4106 1
a 2101 2102 2005
a 2101 4106 1
a 2102 2103 2004
a 2102 4106 1
a 2103 2104 2003
a 2103 4106 1
a 2104 2105 2002
a 2104 4106 1
a 2105 2106 2001
a 2105 4106 1
a 2106 2107 2000
a 2106 4106 1
a 2107 2108 1999
a 2107 4106 1
a 2108 2109 1998
a 2108 4106 1
a 2109 2110 1997
a 2109 4106 1
a 2110 2111 1996
a 2110 4106 1
a 2111 2112 1995
a 2111 4106 1
a 2112 2113 1994
a 2112 4106 1
a 2113 2114 1993
a 2113 4106 1
a 2114 2115 1992
a 2114 4106 1
a 2115 2116 1991
a 2115 4106 1
a 2116 2117 1990
a 2116 4106 1
a 2117 2118 1989
a 2117 4106 1
a 2118 2119 1988
a 2118 4106 1
a 2119 2120 1987
a 2119 4106 1
a 2120 2121 1986
a 2120 4106 1
a 2121 2122 1985
a 2121 4106 1
a 2122 2123 1984
a 2122 4106 1
a 2123 2124 1983
a 2123 4106 1
a 2124 2125 1982
a 2124 4106 1
a 2125 2126 1981
a 2125 4106 1
a 2126 2127 1980
a 2126 4106 1
a 2127 2128 1979
a 2127 4106 1
a 2128 2129 1978
a 2128 4106 1
a 2129 2130 1977
a 2129 4106 1
a 2130 2131 1976
a 2130 4106 1
a 2131 2132 1975
a 2131 4106 1
a 2132 2133 1974
a 2132 4106 1
a 2133 2134 1973
a 2133 4106 1
a 2134 2135 1972
a 2134 4106 1
a 2135 2136 1971
a 2135 4106 1
a 2136 2137 1970
a 2136 4106 1
a 2137 2138 1969
a 2137 4106 1
a 2138 2139 1968
a 2138 4106 1
a 2139 2140 1967
a 2139 4106 1
a 2140 2141 1966
a 2140 4106 1
a 2141 2142 1965
a 2141 4106 1
a 2142 2143 1964
a 2142 4106 1
a 2143 2144 1963
a 2143 4106 1
a 2144 2145 1962
a 2144 4106 1
a 2145 2146 1961
a 2145 4106 1
a 2146 2147 1960
a 2146 4106 1
a 2147 2148 1959
a 2147 4106 1
a 2148 2149 1958
a 2148 4106 1
a 2149 2150 1957
a 2149 4106 1
a 2150 2151 1956
a 2150 4106 1
a 2151 2152 1955
a 2151 4106 1
a 2152 2153 1954
a 2152 4106 1
a 2153 2154 1953
a 2153 4106 1
a 2154 2155 1952
a 2154 4106 1
a 2155 2156 1951
a 2155 4106 1
a 2156 2157 1950
a 2156 4106 1
a 2157 2158 1949
a 2157 4106 1
a 2158 2159 1948
a 2158 4106 1
a 2159 2160 1947
a 2159 4106 1
a 2160 2161 1946
a 2160 4106 1
a 2161 2162 1945
a 2161 4106 1
a 2162 2163 1944
a 2162 4106 1
a 2163 2164 1943
a 2163 4106 1
a 2164 2165 1942
a 2164 4106 1
a 2165 2166 1941
a 2165 4106 1
a 2166 2167 1940
a 2166 4106 1
a 2167 2168 1939
a 2167 4106 1
a 2168 2169 1938
a 2168 4106 1
a 2169 2170 1937
a 2169 4106 1
a 2170 2171 1936
a 2170 4106 1
a 2171 2172 1935
a 2171 4106 1
a 2172 2173 1934
a 2172 4106 1
a 2173 2174 1933
a 2173 4106 1
a 2174 2175 1932
a 2174 4106 1
a 2175 2176 1931
a 2175 4106 1
a 2176 2177 1930
a 2176 4106 1
a 2177 2178 1929
a 2177 4106 1
a 2178 2179 1928
a 2178 4106 1
a 2179 2180 1927
a 2179 4106 1
a 2180 2181 1926
a 2180 4106 1
a 2181 2182 1925
a 2181 4106 1
a 2182 2183 1924
a 2182 4106 1
a 2183 2184 1923
a 2183 4106 1
a 2184 2185 1922
a 2184 4106 1
a 2185 2186 1921
a 2185 4106 1
a 2186 2187 1920
a 2186 4106 1
a 2187 2188 1919
a 2187 4106 1
a 2188 2189 1918
a 2188 4106 1
a 2189 2190 1917
a 2189 4106 1
a 2190 2191 1916
a 2190 4106 1
a 2191 2192 1915
a 2191 4106 1
a 2192 2193 1914
a 2192 4106 1
a 2193 2194 1913
a 2193 4106 1
a 2194 2195 1912
a 2194 4106 1
a 2195 2196 1911
a 2195 4106 1
a 2196 2197 1910
a 2196 4106 1
a 2197 2198 1909
a 2197 4106 1
a 2198 2199 1908
a 2198 4106 1
a 2199 2200 1907
a 2199 4106 1
a 2200 2201 1906
a 2200 4106 1
a 2201 2202 1905
a 2201 4106 1
a 2202 2203 1904
a 2202 4106 1
a 2203 2204 1903
a 2203 4106 1
a 2204 2205 1902
a 2204 4106 1
a 2205 2206 1901
a 2205 4106 1
a 2206 2207 1900
a 2206 4106 1
a 2207 2208 1899
a 2207 4106 1
a 2208 2209 1898
a 2208 4106 1
a 2209 2210 1897
a 2209 4106 1
a 2210 2211 1896
a 2210 4106 1
a 2211 2212 1895
a 2211 4106 1
a 2212 2213 1894
a 2212 4106 1
a 2213 2214 1893
a 2213 4106 1
a 2214 2215 1892
a 2214 4106 1
a 2215 2216 1891
a 2215 4106 1
a 2216 2217 1890
a 2216 4106 1
a 2217 2218 1889
a 2217 4106 1
a 2218 2219 1888
a 2218 4106 1
a 2219 2220 1887
a 2219 4106 1
a 2220 2221 1886
a 2220 4106 1
a 2221 2222 1885
a 2221 4106 1
a 2222 2223 1884
a 2222 4106 1
a 2223 2224 1883
a 2223 4106 1
a 2224 2225 1882
a 2224 4106 1
a 2225 2226 1881
a 2225 4106 1
a 2226 2227 1880
a 2226 4106 1
a 2227 2228 1879
a 2227 4106 1
a 2228 2229 1878
a 2228 4106 1
a 2229 2230 1877
a 2229 4106 1
a 2230 2231 1876
a 2230 4106 1
a 2231 2232 1875
a 2231 4106 1
a 2232 2233 1874
a 2232 4106 1
a 2233 2234 1873
a 2233 4106 1
a 2234 2235 1872
a 2234 4106 1
a 2235 2236 1871
a 2235 4106 1
a 2236 2237 1870
a 2236 4106 1
a 2237 2238 1869
a 2237 4106 1
a 2238 2239 1868
a 2238 4106 1
a 2239 2240 1867
a 2239 4106 1
a 2240 2241 1866
a 2240 4106 1
a 2241 2242 1865
a 2241 4106 1
a 2242 2243 1864
a 2242 4106 1
a 2243 2244 1863
a 2243 4106 1
a 2244 2245 1862
a 2244 4106 1
a 2245 2246 1861
a 2245 4106 1
a 2246 2247 1860
a 2246 4106 1
a 2247 2248 1859
a 2247 4106 1
a 2248 2249 1858
a 2248 4106 1
a 2249 2250 1857
a 2249 4106 1
a 2250 2251 1856
a 2250 4106 1
a 2251 2252 1855
a 2251 4106 1
a 2252 2253 1854
a 2252 4106 1
a 2253 2254 1853
a 2253 4106 1
a 2254 2255 1852
a 2254 4106 1
a 2255 2256 1851
a 2255 4106 1
a 2256 2257 1850
a 2256 4106 1
a 2257 2258 1849
a 2257 4106 1
a 2258 2259 1848
a 2258 4106 1
a 2259 2260 1847
a 2259 4106 1
a 2260 2261 1846
a 2260 4106 1
a 2261 2262 1845
a 2261 4106 1
a 2262 2263 1844
a 2262 4106 1
a 2263 2264 1843
a 2263 4106 1
a 2264 2265 1842
a 2264 4106 1
a 2265 2266 1841
a 2265 4106 1
a 2266 2267 1840
a 2266 4106 1
a 2267 2268 1839
a 2267 4106 1
a 2268 2269 1838
a 2268 4106 1
a 2269 2270 1837
a 2269 4106 1
a 2270 2271 1836
a 2270 4106 1
a 2271 2272 1835
a 2271 4106 1
a 2272 2273 1834
a 2272 4106 1
a 2273 2274 1833
a 2273 4106 1
a 2274 2275 1832
a 2274 4106 1
a 2275 2276 1831
a 2275 4106 1
a 2276 2277 1830
a 2276 4106 1
a 2277 2278 1829
a 2277 4106 1
a 2278 2279 1828
a 2278 4106 1
a 2279 2280 1827
a 2279 4106 1
a 2280 2281 1826
a 2280 4106 1
a 2281 2282 1825
a 2281 4106 1
a 2282 2283 1824
a 2282 4106 1
a 2283 2284 1823
a 2283 4106 1
a 2284 2285 1822
a 2284 4106 1
a 2285 2286 1821
a 2285 4106 1
a 2286 2287 1820
a 2286 4106 1
a 2287 2288 1819
a 2287 4106 1
a 2288 2289 1818
a 2288 4106 1
a 2289 2290 1817
a 2289 4106 1
a 2290 2291 1816
a 2290 4106 1
a 2291 2292 1815
a 2291 4106 1
a 2292 2293 1814
a 2292 4106 1
a 2293 2294 1813
a 2293 4106 1
a 2294 2295 1812
a 2294 4106 1
a 2295 2296 1811
a 2295 4106 1
a 2296 2297 1810
a 2296 4106 1
a 2297 2298 1809
a 2297 4106 1
a 2298 2299 1808
a 2298 4106 1
a 2299 2300 1807
a 2299 4106 1
a 2300 2301 1806
a 2300 4106 1
a 2301 2302 1805
a 2301 4106 1
a 2302 2303 1804
a 2302 4106 1
a 2303 2304 1803
a 2303 4106 1
a 2304 2305 1802
a 2304 4106 1
a 2305 2306 1801
a 2305 4106 1
a 2306 2307 1800
a 2306 4106 1
a 2307 2308 1799
a 2307 4106 1
a 2308 2309 1798
a 2308 4106 1
a 2309 2310 1797
a 2309 4106 1
a 2310 2311 1796
a 2310 4106 1
a 2311 2312 1795
a 2311 4106 1
a 2312 2313 1794
a 2312 4106 1
a 2313 2314 1793
a 2313 4106 1
a 2314 2315 1792
a 2314 4106 1
a 2315 2316 1791
a 2315 4106 1
a 2316 2317 1790
a 2316 4106 1
a 2317 2318 1789
a 2317 4106 1
a 2318 2319 1788
a 2318 4106 1
a 2319 2320 1787
a 2319 4106 1
a 2320 2321 1786
a 2320 4106 1
a 2321 2322 1785
a 2321 4106 1
a 2322 2323 1784
a 2322 4106 1
a 2323 2324 1783
a 2323 4106 1
a 2324 2325 1782
a 2324 4106 1
a 2325 2326 1781
a 2325 4106 1
a 2326 2327 1780
a 2326 4106 1
a 2327 2328 1779
a 2327 4106 1
a 2328 2329 1778
a 2328 4106 1
a 2329 2330 1777
a 2329 4106 1
a 2330 2331 1776
a 2330 4106 1
a 2331 2332 1775
a 2331 4106 1
a 2332 2333 1774
a 2332 4106 1
a 2333 2334 1773
a 2333 4106 1
a 2334 2335 1772
a 2334 4106 1
a 2335 2336 1771
a 2335 4106 1
a 2336 2337 1770
a 2336 4106 1
a 2337 2338 1769
a 2337 4106 1
a 2338 2339 1768
a 2338 4106 1
a 2339 2340 1767
a 2339 4106 1
a 2340 2341 1766
a 2340 4106 1
a 2341 2342 1765
a 2341 4106 1
a 2342 2343 1764
a 2342 4106 1
a 2343 2344 1763
a 2343 4106 1
a 2344 2345 1762
a 2344 4106 1
a 2345 2346 1761
a 2345 4106 1
a 2346 2347 1760
a 2346 4106 1
a 2347 2348 1759
a 2347 4106 1
a 2348 2349 1758
a 2348 4106 1
a 2349 2350 1757
a 2349 4106 1
a 2350 2351 1756
a 2350 4106 1
a 2351 2352 1755
a 2351 4106 1
a 2352 2353 1754
a 2352 4106 1
a 2353 2354 1753
a 2353 4106 1
a 2354 2355 1752
a 2354 4106 1
a 2355 2356 1751
a 2355 4106 1
a 2356 2357 1750
a 2356 4106 1
a 2357 2358 1749
a 2357 4106 1
a 2358 2359 1748
a 2358 4106 1
a 2359 2360 1747
a 2359 4106 1
a 2360 2361 1746
a 2360 4106 1
a 2361 2362 1745
a 2361 4106 1
a 2362 2363 1744
a 2362 4106 1
a 2363 2364 1743
a 2363 4106 1
a 2364 2365 1742
a 2364 4106 1
a 2365 2366 1741
a 2365 4106 1
a 2366 2367 1740
a 2366 4106 1
a 2367 2368 1739
a 2367 4106 1
a 2368 2369 1738
a 2368 4106 1
a 2369 2370 1737
a 2369 4106 1
a 2370 2371 1736
a 2370 4106 1
a 2371 2372 1735
a 2371 4106 1
a 2372 2373 1734
a 2372 4106 1
a 2373 2374 1733
a 2373 4106 1
a 2374 2375 1732
a 2374 4106 1
a 2375 2376 1731
a 2375 4106 1
a 2376 2377 1730
a 2376 4106 1
a 2377 2378 1729
a 2377 4106 1
a 2378 2379 1728
a 2378 4106 1
a 2379 2380 1727
a 2379 4106 1
a 2380 2381 1726
a 2380 4106 1
a 2381 2382 1725
a 2381 4106 1
a 2382 2383 1724
a 2382 4106 1
a 2383 2384 1723
a 2383 4106 1
a 2384 2385 1722
a 2384 4106 1
a 2385 2386 1721
a 2385 4106 1
a 2386 2387 1720
a 2386 4106 1
a 2387 2388 1719
a 2387 4106 1
a 2388 2389 1718
a 2388 4106 1
a 2389 2390 1717
a 2389 4106 1
a 2390 2391 1716
a 2390 4106 1
a 2391 2392 1715
a 2391 4106 1
a 2392 2393 1714
a 2392 4106 1
a 2393 2394 1713
a 2393 4106 1
a 2394 2395 1712
a 2394 4106 1
a 2395 2396 1711
a 2395 4106 1
a 2396 2397 1710
a 2396 4106 1
a 2397 2398 1709
a 2397 4106 1
a 2398 2399 1708
a 2398 4106 1
a 2399 2400 1707
a 2399 4106 1
a 2400 2401 1706
a 2400 4106 1
a 2401 2402 1705
a 2401 4106 1
a 2402 2403 1704
a 2402 4106 1
a 2403 2404 1703
a 2403 4106 1
a 2404 2405 1702
a 2404 4106 1
a 2405 2406 1701
a 2405 4106 1
a 2406 2407 1700
a 2406 4106 1
a 2407 2408 1699
a 2407 4106 1
a 2408 2409 1698
a 2408 4106 1
a 2409 2410 1697
a 2409 4106 1
a 2410 2411 1696
a 2410 4106 1
a 2411 2412 1695
a 2411 4106 1
a 2412 2413 1694
a 2412 4106 1
a 2413 2414 1693
a 2413 4106 1
a 2414 2415 1692
a 2414 4106 1
a 2415 2416 1691
a 2415 4106 1
a 2416 2417 1690
a 2416 4106 1
a 2417 2418 1689
a 2417 4106 1
a 2418 2419 1688
a 2418 4106 1
a 2419 2420 1687
a 2419 4106 1
a 2420 2421 1686
a 2420 4106 1
a 2421 2422 1685
a 2421 4106 1
a 2422 2423 1684
a 2422 4106 1
a 2423 2424 1683
a 2423 4106 1
a 2424 2425 1682
a 2424 4106 1
a 2425 2426 1681
a 2425 4106 1
a 2426 2427 1680
a 2426 4106 1
a 2427 2428 1679
a 2427 4106 1
a 2428 2429 1678
a 2428 4106 1
a 2429 2430 1677
a 2429 4106 1
a 2430 2431 1676
a 2430 4106 1
a 2431 2432 1675
a 2431 4106 1
a 2432 2433 1674
a 2432 4106 1
a 2433 2434 1673
a 2433 4106 1
a 2434 2435 1672
a 2434 4106 1
a 2435 2436 1671
a 2435 4106 1
a 2436 2437 1670
a 2436 4106 1
a 2437 2438 1669
a 2437 4106 1
a 2438 2439 1668
a 2438 4106 1
a 2439 2440 1667
a 2439 4106 1
a 2440 2441 1666
a 2440 4106 1
a 2441 2442 1665
a 2441 4106 1
a 2442 2443 1664
a 2442 4106 1
a 2443 2444 1663
a 2443 4106 1
a 2444 2445 1662
a 2444 4106 1
a 2445 2446 1661
a 2445 4106 1
a 2446 2447 1660
a 2446 4106 1
a 2447 2448 1659
a 2447 4106 1
a 2448 2449 1658
a 2448 4106 1
a 2449 2450 1657
a 2449 4106 1
a 2450 2451 1656
a 2450 4106 1
a 2451 2452 1655
a 2451 4106 1
a 2452 2453 1654
a 2452 4106 1
a 2453 2454 1653
a 2453 4106 1
a 2454 2455 1652
a 2454 4106 1
a 2455 2456 1651
a 2455 4106 1
a 2456 2457 1650
a 2456 4106 1
a 2457 2458 1649
a 2457 4106 1
a 2458 2459 1648
a 2458 4106 1
a 2459 2460 1647
a 2459 4106 1
a 2460 2461 1646
a 2460 4106 1
a 2461 2462 1645
a 2461 4106 1
a 2462 2463 1644
a 2462 4106 1
a 2463 2464 1643
a 2463 4106 1
a 2464 2465 1642
a 2464 4106 1
a 2465 2466 1641
a 2465 4106 1
a 2466 2467 1640
a 2466 4106 1
a 2467 2468 1639
a 2467 4106 1
a 2468 2469 1638
a 2468 4106 1
a 2469 2470 1637
a 2469 4106 1
a 2470 2471 1636
a 2470 4106 1
a 2471 2472 1635
a 2471 4106 1
a 2472 2473 1634
a 2472 4106 1
a 2473 2474 1633
a 2473 4106 1
a 2474 2475 1632
a 2474 4106 1
a 2475 2476 1631
a 2475 4106 1
a 2476 2477 1630
a 2476 4106 1
a 2477 2478 1629
a 2477 4106 1
a 2478 2479 1628
a 2478 4106 1
a 2479 2480 1627
a 2479 4106 1
a 2480 2481 1626
a 2480 4106 1
a 2481 2482 1625
a 2481 4106 1
a 2482 2483 1624
a 2482 4106 1
a 2483 2484 1623
a 2483 4106 1
a 2484 2485 1622
a 2484 4106 1
a 2485 2486 1621
a 2485 4106 1
a 2486 2487 1620
a 2486 4106 1
a 2487 2488 1619
a 2487 4106 1
a 2488 2489 1618
a 2488 4106 1
a 2489 2490 1617
a 2489 4106 1
a 2490 2491 1616
a 2490 4106 1
a 2491 2492 1615
a 2491 4106 1
a 2492 2493 1614
a 2492 4106 1
a 2493 2494 1613
a 2493 4106 1
a 2494 2495 1612
a 2494 4106 1
a 2495 2496 1611
a 2495 4106 1
a 2496 2497 1610
a 2496 4106 1
a 2497 2498 1609
a 2497 4106 1
a 2498 2499 1608
a 2498 4106 1
a 2499 2500 1607
a 2499 4106 1
a 2500 2501 1606
a 2500 4106 1
a 2501 2502 1605
a 2501 4106 1
a 2502 2503 1604
a 2502 4106 1
a 2503 2504 1603
a 2503 4106 1
a 2504 2505 1602
a 2504 4106 1
a 2505 2506 1601
a 2505 4106 1
a 2506 2507 1600
a 2506 4106 1
a 2507 2508 1599
a 2507 4106 1
a 2508 2509 1598
a 2508 4106 1
a 2509 2510 1597
a 2509 4106 1
a 2510 2511 1596
a 2510 4106 1
a 2511 2512 1595
a 2511 4106 1
a 2512 2513 1594
a 2512 4106 1
a 2513 2514 1593
a 2513 4106 1
a 2514 2515 1592
a 2514 4106 1
a 2515 2516 1591
a 2515 4106 1
a 2516 2517 1590
a 2516 4106 1
a 2517 2518 1589
a 2517 4106 1
a 2518 2519 1588
a 2518 4106 1
a 2519 2520 1587
a 2519 4106 1
a 2520 2521 1586
a 2520 4106 1
a 2521 2522 1585
a 2521 4106 1
a 2522 2523 1584
a 2522 4106 1
a 2523 2524 1583
a 2523 4106 1
a 2524 2525 1582
a 2524 4106 1
a 2525 2526 1581
a 2525 4106 1
a 2526 2527 1580
a 2526 4106 1
a 2527 2528 1579
a 2527 4106 1
a 2528 2529 1578
a 2528 4106 1
a 2529 2530 1577
a 2529 4106 1
a 2530 2531 1576
a 2530 4106 1
a 2531 2532 1575
a 2531 4106 1
a 2532 2533 1574
a 2532 4106 1
a 2533 2534 1573
a 2533 4106 1
a 2534 2535 1572
a 2534 4106 1
a 2535 2536 1571
a 2535 4106 1
a 2536 2537 1570
a 2536 4106 1
a 2537 2538 1569
a 2537 4106 1
a 2538 2539 1568
a 2538 4106 1
a 2539 2540 1567
a 2539 4106 1
a 2540 2541 1566
a 2540 4106 1
a 2541 2542 1565
a 2541 4106 1
a 2542 2543 1564
a 2542 4106 1
a 2543 2544 1563
a 2543 4106 1
a 2544 2545 1562
a 2544 4106 1
a 2545 2546 1561
a 2545 4106 1
a 2546 2547 1560
a 2546 4106 1
a 2547 2548 1559
a 2547 4106 1
a 2548 2549 1558
a 2548 4106 1
a 2549 2550 1557
a 2549 4106 1
a 2550 2551 1556
a 2550 4106 1
a 2551 2552 1555
a 2551 4106 1
a 2552 2553 1554
a 2552 4106 1
a 2553 2554 1553
a 2553 4106 1
a 2554 2555 1552
a 2554 4106 1
a 2555 2556 1551
a 2555 4106 1
a 2556 2557 1550
a 2556 4106 1
a 2557 2558 1549
a 2557 4106 1
a 2558 2559 1548
a 2558 4106 1
a 2559 2560 1547
a 2559 4106 1
a 2560 2561 1546
a 2560 4106 1
a 2561 2562 1545
a 2561 4106 1
a 2562 2563 1544
a 2562 4106 1
a 2563 2564 1543
a 2563 4106 1
a 2564 2565 1542
a 2564 4106 1
a 2565 2566 1541
a 2565 4106 1
a 2566 2567 1540
a 2566 4106 1
a 2567 2568 1539
a 2567 4106 1
a 2568 2569 1538
a 2568 4106 1
a 2569 2570 1537
a 2569 4106 1
a 2570 2571 1536
a 2570 4106 1
a 2571 2572 1535
a 2571 4106 1
a 2572 2573 1534
a 2572 4106 1
a 2573 2574 1533
a 2573 4106 1
a 2574 2575 1532
a 2574 4106 1
a 2575 2576 1531
a 2575 4106 1
a 2576 2577 1530
a 2576 4106 1
a 2577 2578 1529
a 2577 4106 1
a 2578 2579 1528
a 2578 4106 1
a 2579 2580 1527
a 2579 4106 1
a 2580 2581 1526
a 2580 4106 1
a 2581 2582 1525
a 2581 4106 1
a 2582 2583 1524
a 2582 4106 1
a 2583 2584 1523
a 2583 4106 1
a 2584 2585 1522
a 2584 4106 1
a 2585 2586 1521
a 2585 4106 1
a 2586 2587 1520
a 2586 4106 1
a 2587 2588 1519
a 2587 4106 1
a 2588 2589 1518
a 2588 4106 1
a 2589 2590 1517
a 2589 4106 1
a 2590 2591 1516
a 2590 4106 1
a 2591 2592 1515
a 2591 4106 1
a 2592 2593 1514
a 2592 4106 1
a 2593 2594 1513
a 2593 4106 1
a 2594 2595 1512
a 2594 4106 1
a 2595 2596 1511
a 2595 4106 1
a 2596 2597 1510
a 2596 4106 1
a 2597 2598 1509
a 2597 4106 1
a 2598 2599 1508
a 2598 4106 1
a 2599 2600 1507
a 2599 4106 1
a 2600 2601 1506
a 2600 4106 1
a 2601 2602 1505
a 2601 4106 1
a 2602 2603 1504
a 2602 4106 1
a 2603 2604 1503
a 2603 4106 1
a 2604 2605 1502
a 2604 4106 1
a 2605 2606 1501
a 2605 4106 1
a 2606 2607 1500
a 2606 4106 1
a 2607 2608 1499
a 2607 4106 1
a 2608 2609 1498
a 2608 4106 1
a 2609 2610 1497
a 2609 4106 1
a 2610 2611 1496
a 2610 4106 1
a 2611 2612 1495
a 2611 4106 1
a 2612 2613 1494
a 2612 4106 1
a 2613 2614 1493
a 2613 4106 1
a 2614 2615 1492
a 2614 4106 1
a 2615 2616 1491
a 2615 4106 1
a 2616 2617 1490
a 2616 4106 1
a 2617 2618 1489
a 2617 4106 1
a 2618 2619 1488
a 2618 4106 1
a 2619 2620 1487
a 2619 4106 1
a 2620 2621 1486
a 2620 4106 1
a 2621 2622 1485
a 2621 4106 1
a 2622 2623 1484
a 2622 4106 1
a 2623 2624 1483
a 2623 4106 1
a 2624 2625 1482
a 2624 4106 1
a 2625 2626 1481
a 2625 4106 1
a 2626 2627 1480
a 2626 4106 1
a 2627 2628 1479
a 2627 4106 1
a 2628 2629 1478
a 2628 4106 1
a 2629 2630 1477
a 2629 4106 1
a 2630 2631 1476
a 2630 4106 1
a 2631 2632 1475
a 2631 4106 1
a 2632 2633 1474
a 2632 4106 1
a 2633 2634 1473
a 2633 4106 1
a 2634 2635 1472
a 2634 4106 1
a 2635 2636 1471
a 2635 4106 1
a 2636 2637 1470
a 2636 4106 1
a 2637 2638 1469
a 2637 4106 1
a 2638 2639 1468
a 2638 4106 1
a 2639 2640 1467
a 2639 4106 1
a 2640 2641 1466
a 2640 4106 1
a 2641 2642 1465
a 2641 4106 1
a 2642 2643 1464
a 2642 4106 1
a 2643 2644 1463
a 2643 4106 1
a 2644 2645 1462
a 2644 4106 1
a 2645 2646 1461
a 2645 4106 1
a 2646 2647 1460
a 2646 4106 1
a 2647 2648 1459
a 2647 4106 1
a 2648 2649 1458
a 2648 4106 1
a 2649 2650 1457
a 2649 4106 1
a 2650 2651 1456
a 2650 4106 1
a 2651 2652 1455
a 2651 4106 1
a 2652 2653 1454
a 2652 4106 1
a 2653 2654 1453
a 2653 4106 1
a 2654 2655 1452
a 2654 4106 1
a 2655 2656 1451
a 2655 4106 1
a 2656 2657 1450
a 2656 4106 1
a 2657 2658 1449
a 2657 4106 1
a 2658 2659 1448
a 2658 4106 1
a 2659 2660 1447
a 2659 4106 1
a 2660 2661 1446
a 2660 4106 1
a 2661 2662 1445
a 2661 4106 1
a 2662 2663 1444
a 2662 4106 1
a 2663 2664 1443
a 2663 4106 1
a 2664 2665 1442
a 2664 4106 1
a 2665 2666 1441
a 2665 4106 1
a 2666 2667 1440
a 2666 4106 1
a 2667 2668 1439
a 2667 4106 1
a 2668 2669 1438
a 2668 4106 1
a 2669 2670 1437
a 2669 4106 1
a 2670 2671 1436
a 2670 4106 1
a 2671 2672 1435
a 2671 4106 1
a 2672 2673 1434
a 2672 4106 1
a 2673 2674 1433
a 2673 4106 1
a 2674 2675 1432
a 2674 4106 1
a 2675 2676 1431
a 2675 4106 1
a 2676 2677 1430
a 2676 4106 1
a 2677 2678 1429
a 2677 4106 1
a 2678 2679 1428
a 2678 4106 1
a 2679 2680 1427
a 2679 4106 1
a 2680 2681 1426
a 2680 4106 1
a 2681 2682 1425
a 2681 4106 1
a 2682 2683 1424
a 2682 4106 1
a 2683 2684 1423
a 2683 4106 1
a 2684 2685 1422
a 2684 4106 1
a 2685 2686 1421
a 2685 4106 1
a 2686 2687 1420
a 2686 4106 1
a 2687 2688 1419
a 2687 4106 1
a 2688 2689 1418
a 2688 4106 1
a 2689 2690 1417
a 2689 4106 1
a 2690 2691 1416
a 2690 4106 1
a 2691 2692 1415
a 2691 4106 1
a 2692 2693 1414
a 2692 4106 1
a 2693 2694 1413
a 2693 4106 1
a 2694 2695 1412
a 2694 4106 1
a 2695 2696 1411
a 2695 4106 1
a 2696 2697 1410
a 2696 4106 1
a 2697 2698 1409
a 2697 4106 1
a 2698 2699 1408
a 2698 4106 1
a 2699 2700 1407
a 2699 4106 1
a 2700 2701 1406
a 2700 4106 1
a 2701 2702 1405
a 2701 4106 1
a 2702 2703 1404
a 2702 4106 1
a 2703 2704 1403
a 2703 4106 1
a 2704 2705 1402
a 2704 4106 1
a 2705 2706 1401
a 2705 4106 1
a 2706 2707 1400
a 2706 4106 1
a 2707 2708 1399
a 2707 4106 1
a 2708 2709 1398
a 2708 4106 1
a 2709 2710 1397
a 2709 4106 1
a 2710 2711 1396
a 2710 4106 1
a 2711 2712 1395
a 2711 4106 1
a 2712 2713 1394
a 2712 4106 1
a 2713 2714 1393
a 2713 4106 1
a 2714 2715 1392
a 2714 4106 1
a 2715 2716 1391
a 2715 4106 1
a 2716 2717 1390
a 2716 4106 1
a 2717 2718 1389
a 2717 4106 1
a 2718 2719 1388
a 2718 4106 1
a 2719 2720 1387
a 2719 4106 1
a 2720 2721 1386
a 2720 4106 1
a 2721 2722 1385
a 2721 4106 1
a 2722 2723 1384
a 2722 4106 1
a 2723 2724 1383
a 2723 4106 1
a 2724 2725 1382
a 2724 4106 1
a 2725 2726 1381
a 2725 4106 1
a 2726 2727 1380
a 2726 4106 1
a 2727 2728 1379
a 2727 4106 1
a 2728 2729 1378
a 2728 4106 1
a 2729 2730 1377
a 2729 4106 1
a 2730 2731 1376
a 2730 4106 1
a 2731 2732 1375
a 2731 4106 1
a 2732 2733 1374
a 2732 4106 1
a 2733 2734 1373
a 2733 4106 1
a 2734 2735 1372
a 2734 4106 1
a 2735 2736 1371
a 2735 4106 1
a 2736 2737 1370
a 2736 4106 1
a 2737 2738 1369
a 2737 4106 1
a 2738 2739 1368
a 2738 4106 1
a 2739 2740 1367
a 2739 4106 1
a 2740 2741 1366
a 2740 4106 1
a 2741 2742 1365
a 2741 4106 1
a 2742 2743 1364
a 2742 4106 1
a 2743 2744 1363
a 2743 4106 1
a 2744 2745 1362
a 2744 4106 1
a 2745 2746 1361
a 2745 4106 1
a 2746 2747 1360
a 2746 4106 1
a 2747 2748 1359
a 2747 4106 1
a 2748 2749 1358
a 2748 4106 1
a 2749 2750 1357
a 2749 4106 1
a 2750 2751 1356
a 2750 4106 1
a 2751 2752 1355
a 2751 4106 1
a 2752 2753 1354
a 2752 4106 1
a 2753 2754 1353
a 2753 4106 1
a 2754 2755 1352
a 2754 4106 1
a 2755 2756 1351
a 2755 4106 1
a 2756 2757 1350
a 2756 4106 1
a 2757 2758 1349
a 2757 4106 1
a 2758 2759 1348
a 2758 4106 1
a 2759 2760 1347
a 2759 4106 1
a 2760 2761 1346
a 2760 4106 1
a 2761 2762 1345
a 2761 4106 1
a 2762 2763 1344
a 2762 4106 1
a 2763 2764 1343
a 2763 4106 1
a 2764 2765 1342
a 2764 4106 1
a 2765 2766 1341
a 2765 4106 1
a 2766 2767 1340
a 2766 4106 1
a 2767 2768 1339
a 2767 4106 1
a 2768 2769 1338
a 2768 4106 1
a 2769 2770 1337
a 2769 4106 1
a 2770 2771 1336
a 2770 4106 1
a 2771 2772 1335
a 2771 4106 1
a 2772 2773 1334
a 2772 4106 1
a 2773 2774 1333
a 2773 4106 1
a 2774 2775 1332
a 2774 4106 1
a 2775 2776 1331
a 2775 4106 1
a 2776 2777 1330
a 2776 4106 1
a 2777 2778 1329
a 2777 4106 1
a 2778 2779 1328
a 2778 4106 1
a 2779 2780 1327
a 2779 4106 1
a 2780 2781 1326
a 2780 4106 1
a 2781 2782 1325
a 2781 4106 1
a 2782 2783 1324
a 2782 4106 1
a 2783 2784 1323
a 2783 4106 1
a 2784 2785 1322
a 2784 4106 1
a 2785 2786 1321
a 2785 4106 1
a 2786 2787 1320
a 2786 4106 1
a 2787 2788 1319
a 2787 4106 1
a 2788 2789 1318
a 2788 4106 1
a 2789 2790 1317
a 2789 4106 1
a 2790 2791 1316
a 2790 4106 1
a 2791 2792 1315
a 2791 4106 1
a 2792 2793 1314
a 2792 4106 1
a 2793 2794 1313
a 2793 4106 1
a 2794 2795 1312
a 2794 4106 1
a 2795 2796 1311
a 2795 4106 1
a 2796 2797 1310
a 2796 4106 1
a 2797 2798 1309
a 2797 4106 1
a 2798 2799 1308
a 2798 4106 1
a 2799 2800 1307
a 2799 4106 1
a 2800 2801 1306
a 2800 4106 1
a 2801 2802 1305
a 2801 4106 1
a 2802 2803 1304
a 2802 4106 1
a 2803 2804 1303
a 2803 4106 1
a 2804 2805 1302
a 2804 4106 1
a 2805 2806 1301
a 2805 4106 1
a 2806 2807 1300
a 2806 4106 1
a 2807 2808 1299
a 2807 4106 1
a 2808 2809 1298
a 2808 4106 1
a 2809 2810 1297
a 2809 4106 1
a 2810 2811 1296
a 2810 4106 1
a 2811 2812 1295
a 2811 4106 1
a 2812 2813 1294
a 2812 4106 1
a 2813 2814 1293
a 2813 4106 1
a 2814 2815 1292
a 2814 4106 1
a 2815 2816 1291
a 2815 4106 1
a 2816 2817 1290
a 2816 4106 1
a 2817 2818 1289
a 2817 4106 1
a 2818 2819 1288
a 2818 4106 1
a 2819 2820 1287
a 2819 4106 1
a 2820 2821 1286
a 2820 4106 1
a 2821 2822 1285
a 2821 4106 1
a 2822 2823 1284
a 2822 4106 1
a 2823 2824 1283
a 2823 4106 1
a 2824 2825 1282
a 2824 4106 1
a 2825 2826 1281
a 2825 4106 1
a 2826 2827 1280
a 2826 4106 1
a 2827 2828 1279
a 2827 4106 1
a 2828 2829 1278
a 2828 4106 1
a 2829 2830 1277
a 2829 4106 1
a 2830 2831 1276
a 2830 4106 1
a 2831 2832 1275
a 2831 4106 1
a 2832 2833 1274
a 2832 4106 1
a 2833 2834 1273
a 2833 4106 1
a 2834 2835 1272
a 2834 4106 1
a 2835 2836 1271
a 2835 4106 1
a 2836 2837 1270
a 2836 4106 1
a 2837 2838 1269
a 2837 4106 1
a 2838 2839 1268
a 2838 4106 1
a 2839 2840 1267
a 2839 4106 1
a 2840 2841 1266
a 2840 4106 1
a 2841 2842 1265
a 2841 4106 1
a 2842 2843 1264
a 2842 4106 1
a 2843 2844 1263
a 2843 4106 1
a 2844 2845 1262
a 2844 4106 1
a 2845 2846 1261
a 2845 4106 1
a 2846 2847 1260
a 2846 4106 1
a 2847 2848 1259
a 2847 4106 1
a 2848 2849 1258
a 2848 4106 1
a 2849 2850 1257
a 2849 4106 1
a 2850 2851 1256
a 2850 4106 1
a 2851 2852 1255
a 2851 4106 1
a 2852 2853 1254
a 2852 4106 1
a 2853 2854 1253
a 2853 4106 1
a 2854 2855 1252
a 2854 4106 1
a 2855 2856 1251
a 2855 4106 1
a 2856 2857 1250
a 2856 4106 1
a 2857 2858 1249
a 2857 4106 1
a 2858 2859 1248
a 2858 4106 1
a 2859 2860 1247
a 2859 4106 1
a 2860 2861 1246
a 2860 4106 1
a 2861 2862 1245
a 2861 4106 1
a 2862 2863 1244
a 2862 4106 1
a 2863 2864 1243
a 2863 4106 1
a 2864 2865 1242
a 2864 4106 1
a 2865 2866 1241
a 2865 4106 1
a 2866 2867 1240
a 2866 4106 1
a 2867 2868 1239
a 2867 4106 1
a 2868 2869 1238
a 2868 4106 1
a 2869 2870 1237
a 2869 4106 1
a 2870 2871 1236
a 2870 4106 1
a 2871 2872 1235
a 2871 4106 1
a 2872 2873 1234
a 2872 4106 1
a 2873 2874 1233
a 2873 4106 1
a 2874 2875 1232
a 2874 4106 1
a 2875 2876 1231
a 2875 4106 1
a 2876 2877 1230
a 2876 4106 1
a 2877 2878 1229
a 2877 4106 1
a 2878 2879 1228
a 2878 4106 1
a 2879 2880 1227
a 2879 4106 1
a 2880 2881 1226
a 2880 4106 1
a 2881 2882 1225
a 2881 4106 1
a 2882 2883 1224
a 2882 4106 1
a 2883 2884 1223
a 2883 4106 1
a 2884 2885 1222
a 2884 4106 1
a 2885 2886 1221
a 2885 4106 1
a 2886 2887 1220
a 2886 4106 1
a 2887 2888 1219
a 2887 4106 1
a 2888 2889 1218
a 2888 4106 1
a 2889 2890 1217
a 2889 4106 1
a 2890 2891 1216
a 2890 4106 1
a 2891 2892 1215
a 2891 4106 1
a 2892 2893 1214
a 2892 4106 1
a 2893 2894 1213
a 2893 4106 1
a 2894 2895 1212
a 2894 4106 1
a 2895 2896 1211
a 2895 4106 1
a 2896 2897 1210
a 2896 4106 1
a 2897 2898 1209
a 2897 4106 1
a 2898 2899 1208
a 2898 4106 1
a 2899 2900 1207
a 2899 4106 1
a 2900 2901 1206
a 2900 4106 1
a 2901 2902 1205
a 2901 4106 1
a 2902 2903 1204
a 2902 4106 1
a 2903 2904 1203
a 2903 4106 1
a 2904 2905 1202
a 2904 4106 1
a 2905 2906 1201
a 2905 4106 1
a 2906 2907 1200
a 2906 4106 1
a 2907 2908 1199
a 2907 4106 1
a 2908 2909 1198
a 2908 4106 1
a 2909 2910 1197
a 2909 4106 1
a 2910 2911 1196
a 2910 4106 1
a 2911 2912 1195
a 2911 4106 1
a 2912 2913 1194
a 2912 4106 1
a 2913 2914 1193
a 2913 4106 1
a 2914 2915 1192
a 2914 4106 1
a 2915 2916 1191
a 2915 4106 1
a 2916 2917 1190
a 2916 4106 1
a 2917 2918 1189
a 2917 4106 1
a 2918 2919 1188
a 2918 4106 1
a 2919 2920 1187
a 2919 4106 1
a 2920 2921 1186
a 2920 4106 1
a 2921 2922 1185
a 2921 4106 1
a 2922 2923 1184
a 2922 4106 1
a 2923 2924 1183
a 2923 4106 1
a 2924 2925 1182
a 2924 4106 1
a 2925 2926 1181
a 2925 4106 1
a 2926 2927 1180
a 2926 4106 1
a 2927 2928 1179
a 2927 4106 1
a 2928 2929 1178
a 2928 4106 1
a 2929 2930 1177
a 2929 4106 1
a 2930 2931 1176
a 2930 4106 1
a 2931 2932 1175
a 2931 4106 1
a 2932 2933 1174
a 2932 4106 1
a 2933 2934 1173
a 2933 4106 1
a 2934 2935 1172
a 2934 4106 1
a 2935 2936 1171
a 2935 4106 1
a 2936 2937 1170
a 2936 4106 1
a 2937 2938 1169
a 2937 4106 1
a 2938 2939 1168
a 2938 4106 1
a 2939 2940 1167
a 2939 4106 1
a 2940 2941 1166
a 2940 4106 1
a 2941 2942 1165
a 2941 4106 1
a 2942 2943 1164
a 2942 4106 1
a 2943 2944 1163
a 2943 4106 1
a 2944 2945 1162
a 2944 4106 1
a 2945 2946 1161
a 2945 4106 1
a 2946 2947 1160
a 2946 4106 1
a 2947 2948 1159
a 2947 4106 1
a 2948 2949 1158
a 2948 4106 1
a 2949 2950 1157
a 2949 4106 1
a 2950 2951 1156
a 2950 4106 1
a 2951 2952 1155
a 2951 4106 1
a 2952 2953 1154
a 2952 4106 1
a 2953 2954 1153
a 2953 4106 1
a 2954 2955 1152
a 2954 4106 1
a 2955 2956 1151
a 2955 4106 1
a 2956 2957 1150
a 2956 4106 1
a 2957 2958 1149
a 2957 4106 1
a 2958 2959 1148
a 2958 4106 1
a 2959 2960 1147
a 2959 4106 1
a 2960 2961 1146
a 2960 4106 1
a 2961 2962 1145
a 2961 4106 1
a 2962 2963 1144
a 2962 4106 1
a 2963 2964 1143
a 2963 4106 1
a 2964 2965 1142
a 2964 4106 1
a 2965 2966 1141
a 2965 4106 1
a 2966 2967 1140
a 2966 4106 1
a 2967 2968 1139
a 2967 4106 1
a 2968 2969 1138
a 2968 4106 1
a 2969 2970 1137
a 2969 4106 1
a 2970 2971 1136
a 2970 4106 1
a 2971 2972 1135
a 2971 4106 1
a 2972 2973 1134
a 2972 4106 1
a 2973 2974 1133
a 2973 4106 1
a 2974 2975 1132
a 2974 4106 1
a 2975 2976 1131
a 2975 4106 1
a 2976 2977 1130
a 2976 4106 1
a 2977 2978 1129
a 2977 4106 1
a 2978 2979 1128
a 2978 4106 1
a 2979 2980 1127
a 2979 4106 1
a 2980 2981 1126
a 2980 4106 1
a 2981 2982 1125
a 2981 4106 1
a 2982 2983 1124
a 2982 4106 1
a 2983 2984 1123
a 2983 4106 1
a 2984 2985 1122
a 2984 4106 1
a 2985 2986 1121
a 2985 4106 1
a 2986 2987 1120
a 2986 4106 1
a 2987 2988 1119
a 2987 4106 1
a 2988 2989 1118
a 2988 4106 1
a 2989 2990 1117
a 2989 4106 1
a 2990 2991 1116
a 2990 4106 1
a 2991 2992 1115
a 2991 4106 1
a 2992 2993 1114
a 2992 4106 1
a 2993 2994 1113
a 2993 4106 1
a 2994 2995 1112
a 2994 4106 1
a 2995 2996 1111
a 2995 4106 1
a 2996 2997 1110
a 2996 4106 1
a 2997 2998 1109
a 2997 4106 1
a 2998 2999 1108
a 2998 4106 1
a 2999 3000 1107
a 2999 4106 1
a 3000 3001 1106
a 3000 4106 1
a 3001 3002 1105
a 3001 4106 1
a 3002 3003 1104
a 3002 4106 1
a 3003 3004 1103
a 3003 4106 1
a 3004 3005 1102
a 3004 4106 1
a 3005 3006 1101
a 3005 4106 1
a 3006 3007 1100
a 3006 4106 1
a 3007 3008 1099
a 3007 4106 1
a 3008 3009 1098
a 3008 4106 1
a 3009 3010 1097
a 3009 4106 1
a 3010 3011 1096
a 3010 4106 1
a 3011 3012 1095
a 3011 4106 1
a 3012 3013 1094
a 3012 4106 1
a 3013 3014 1093
a 3013 4106 1
a 3014 3015 1092
a 3014 4106 1
a 3015 3016 1091
a 3015 4106 1
a 3016 3017 1090
a 3016 4106 1
a 3017 3018 1089
a 3017 4106 1
a 3018 3019 1088
a 3018 4106 1
a 3019 3020 1087
a 3019 4106 1
a 3020 3021 1086
a 3020 4106 1
a 3021 3022 1085
a 3021 4106 1
a 3022 3023 1084
a 3022 4106 1
a 3023 3024 1083
a 3023 4106 1
a 3024 3025 1082
a 3024 4106 1
a 3025 3026 1081
a 3025 4106 1
a 3026 3027 1080
a 3026 4106 1
a 3027 3028 1079
a 3027 4106 1
a 3028 3029 1078
a 3028 4106 1
a 3029 3030 1077
a 3029 4106 1
a 3030 3031 1076
a 3030 4106 1
a 3031 3032 1075
a 3031 4106 1
a 3032 3033 1074
a 3032 4106 1
a 3033 3034 1073
a 3033 4106 1
a 3034 3035 1072
a 3034 4106 1
a 3035 3036 1071
a 3035 4106 1
a 3036 3037 1070
a 3036 4106 1
a 3037 3038 1069
a 3037 4106 1
a 3038 3039 1068
a 3038 4106 1
a 3039 3040 1067
a 3039 4106 1
a 3040 3041 1066
a 3040 4106 1
a 3041 3042 1065
a 3041 4106 1
a 3042 3043 1064
a 3042 4106 1
a 3043 3044 1063
a 3043 4106 1
a 3044 3045 1062
a 3044 4106 1
a 3045 3046 1061
a 3045 4106 1
a 3046 3047 1060
a 3046 4106 1
a 3047 3048 1059
a 3047 4106 1
a 3048 3049 1058
a 3048 4106 1
a 3049 3050 1057
a 3049 4106 1
a 3050 3051 1056
a 3050 4106 1
a 3051 3052 1055
a 3051 4106 1
a 3052 3053 1054
a 3052 4106 1
a 3053 3054 1053
a 3053 4106 1
a 3054 3055 1052
a 3054 4106 1
a 3055 3056 1051
a 3055 4106 1
a 3056 3057 1050
a 3056 4106 1
a 3057 3058 1049
a 3057 4106 1
a 3058 3059 1048
a 3058 4106 1
a 3059 3060 1047
a 3059 4106 1
a 3060 3061 1046
a 3060 4106 1
a 3061 3062 1045
a 3061 4106 1
a 3062 3063 1044
a 3062 4106 1
a 3063 3064 1043
a 3063 4106 1
a 3064 3065 1042
a 3064 4106 1
a 3065 3066 1041
a 3065 4106 1
a 3066 3067 1040
a 3066 4106 1
a 3067 3068 1039
a 3067 4106 1
a 3068 3069 1038
a 3068 4106 1
a 3069 3070 1037
a 3069 4106 1
a 3070 3071 1036
a 3070 4106 1
a 3071 3072 1035
a 3071 4106 1
a 3072 3073 1034
a 3072 4106 1
a 3073 3074 1033
a 3073 4106 1
a 3074 3075 1032
a 3074 4106 1
a 3075 3076 1031
a 3075 4106 1
a 3076 3077 1030
a 3076 4106 1
a 3077 3078 1029
a 3077 4106 1
a 3078 3079 1028
a 3078 4106 1
a 3079 3080 1027
a 3079 4106 1
a 3080 3081 1026
a 3080 4106 1
a 3081 3082 1025
a 3081 4106 1
a 3082 3083 1024
a 3082 4106 1
a 3083 3084 1023
a 3083 4106 1
a 3084 3085 1022
a 3084 4106 1
a 3085 3086 1021
a 3085 4106 1
a 3086 3087 1020
a 3086 4106 1
a 3087 3088 1019
a 3087 4106 1
a 3088 3089 1018
a 3088 4106 1
a 3089 3090 1017
a 3089 4106 1
a 3090 3091 1016
a 3090 4106 1
a 3091 3092 1015
a 3091 4106 1
a 3092 3093 1014
a 3092 4106 1
a 3093 3094 1013
a 3093 4106 1
a 3094 3095 1012
a 3094 4106 1
a 3095 3096 1011
a 3095 4106 1
a 3096 3097 1010
a 3096 4106 1
a 3097 3098 1009
a 3097 4106 1
a 3098 3099 1008
a 3098 4106 1
a 3099 3100 1007
a 3099 4106 1
a 3100 3101 1006
a 3100 4106 1
a 3101 3102 1005
a 3101 4106 1
a 3102 3103 1004
a 3102 4106 1
a 3103 3104 1003
a 3103 4106 1
a 3104 3105 1002
a 3104 4106 1
a 3105 3106 1001
a 3105 4106 1
a 3106 3107 1000
a 3106 4106 1
a 3107 3108 999
a 3107 4106 1
a 3108 3109 998
a 3108 4106 1
a 3109 3110 997
a 3109 4106 1
a 3110 3111 996
a 3110 4106 1
a 3111 3112 995
a 3111 4106 1
a 3112 3113 994
a 3112 4106 1
a 3113 3114 993
a 3113 4106 1
a 3114 3115 992
a 3114 4106 1
a 3115 3116 991
a 3115 4106 1
a 3116 3117 990
a 3116 4106 1
a 3117 3118 989
a 3117 4106 1
a 3118 3119 988
a 3118 4106 1
a 3119 3120 987
a 3119 4106 1
a 3120 3121 986
a 3120 4106 1
a 3121 3122 985
a 3121 4106 1
a 3122 3123 984
a 3122 4106 1
a 3123 3124 983
a 3123 4106 1
a 3124 3125 982
a 3124 4106 1
a 3125 3126 981
a 3125 4106 1
a 3126 3127 980
a 3126 4106 1
a 3127 3128 979
a 3127 4106 1
a 3128 3129 978
a 3128 4106 1
a 3129 3130 977
a 3129 4106 1
a 3130 3131 976
a 3130 4106 1
a 3131 3132 975
a 3131 4106 1
a 3132 3133 974
a 3132 4106 1
a 3133 3134 973
a 3133 4106 1
a 3134 3135 972
a 3134 4106 1
a 3135 3136 971
a 3135 4106 1
a 3136 3137 970
a 3136 4106 1
a 3137 3138 969
a 3137 4106 1
a 3138 3139 968
a 3138 4106 1
a 3139 3140 967
a 3139 4106 1
a 3140 3141 966
a 3140 4106 1
a 3141 3142 965
a 3141 4106 1
a 3142 3143 964
a 3142 4106 1
a 3143 3144 963
a 3143 4106 1
a 3144 3145 962
a 3144 4106 1
a 3145 3146 961
a 3145 4106 1
a 3146 3147 960
a 3146 4106 1
a 3147 3148 959
a 3147 4106 1
a 3148 3149 958
a 3148 4106 1
a 3149 3150 957
a 3149 4106 1
a 3150 3151 956
a 3150 4106 1
a 3151 3152 955
a 3151 4106 1
a 3152 3153 954
a 3152 4106 1
a 3153 3154 953
a 3153 4106 1
a 3154 3155 952
a 3154 4106 1
a 3155 3156 951
a 3155 4106 1
a 3156 3157 950
a 3156 4106 1
a 3157 3158 949
a 3157 4106 1
a 3158 3159 948
a 3158 4106 1
a 3159 3160 947
a 3159 4106 1
a 3160 3161 946
a 3160 4106 1
a 3161 3162 945
a 3161 4106 1
a 3162 3163 944
a 3162 4106 1
a 3163 3164 943
a 3163 4106 1
a 3164 3165 942
a 3164 4106 1
a 3165 3166 941
a 3165 4106 1
a 3166 3167 940
a 3166 4106 1
a 3167 3168 939
a 3167 4106 1
a 3168 3169 938
a 3168 4106 1
a 3169 3170 937
a 3169 4106 1
a 3170 3171 936
a 3170 4106 1
a 3171 3172 935
a 3171 4106 1
a 3172 3173 934
a 3172 4106 1
a 3173 3174 933
a 3173 4106 1
a 3174 3175 932
a 3174 4106 1
a 3175 3176 931
a 3175 4106 1
a 3176 3177 930
a 3176 4106 1
a 3177 3178 929
a 3177 4106 1
a 3178 3179 928
a 3178 4106 1
a 3179 3180 927
a 3179 4106 1
a 3180 3181 926
a 3180 4106 1
a 3181 3182 925
a 3181 4106 1
a 3182 3183 924
a 3182 4106 1
a 3183 3184 923
a 3183 4106 1
a 3184 3185 922
a 3184 4106 1
a 3185 3186 921
a 3185 4106 1
a 3186 3187 920
a 3186 4106 1
a 3187 3188 919
a 3187 4106 1
a 3188 3189 918
a 3188 4106 1
a 3189 3190 917
a 3189 4106 1
a 3190 3191 916
a 3190 4106 1
a 3191 3192 915
a 3191 4106 1
a 3192 3193 914
a 3192 4106 1
a 3193 3194 913
a 3193 4106 1
a 3194 3195 912
a 3194 4106 1
a 3195 3196 911
a 3195 4106 1
a 3196 3197 910
a 3196 4106 1
a 3197 3198 909
a 3197 4106 1
a 3198 3199 908
a 3198 4106 1
a 3199 3200 907
a 3199 4106 1
a 3200 3201 906
a 3200 4106 1
a 3201 3202 905
a 3201 4106 1
a 3202 3203 904
a 3202 4106 1
a 3203 3204 903
a 3203 4106 1
a 3204 3205 902
a 3204 4106 1
a 3205 3206 901
a 3205 4106 1
a 3206 3207 900
a 3206 4106 1
a 3207 3208 899
a 3207 4106 1
a 3208 3209 898
a 3208 4106 1
a 3209 3210 897
a 3209 4106 1
a 3210 3211 896
a 3210 4106 1
a 3211 3212 895
a 3211 4106 1
a 3212 3213 894
a 3212 4106 1
a 3213 3214 893
a 3213 4106 1
a 3214 3215 892
a 3214 4106 1
a 3215 3216 891
a 3215 4106 1
a 3216 3217 890
a 3216 4106 1
a 3217 3218 889
a 3217 4106 1
a 3218 3219 888
a 3218 4106 1
a 3219 3220 887
a 3219 4106 1
a 3220 3221 886
a 3220 4106 1
a 3221 3222 885
a 3221 4106 1
a 3222 3223 884
a 3222 4106 1
a 3223 3224 883
a 3223 4106 1
a 3224 3225 882
a 3224 4106 1
a 3225 3226 881
a 3225 4106 1
a 3226 3227 880
a 3226 4106 1
a 3227 3228 879
a 3227 4106 1
a 3228 3229 878
a 3228 4106 1
a 3229 3230 877
a 3229 4106 1
a 3230 3231 876
a 3230 4106 1
a 3231 3232 875
a 3231 4106 1
a 3232 3233 874
a 3232 4106 1
a 3233 3234 873
a 3233 4106 1
a 3234 3235 872
a 3234 4106 1
a 3235 3236 871
a 3235 4106 1
a 3236 3237 870
a 3236 4106 1
a 3237 3238 869
a 3237 4106 1
a 3238 3239 868
a 3238 4106 1
a 3239 3240 867
a 3239 4106 1
a 3240 3241 866
a 3240 4106 1
a 3241 3242 865
a 3241 4106 1
a 3242 3243 864
a 3242 4106 1
a 3243 3244 863
a 3243 4106 1
a 3244 3245 862
a 3244 4106 1
a 3245 3246 861
a 3245 4106 1
a 3246 3247 860
a 3246 4106 1
a 3247 3248 859
a 3247 4106 1
a 3248 3249 858
a 3248 4106 1
a 3249 3250 857
a 3249 4106 1
a 3250 3251 856
a 3250 4106 1
a 3251 3252 855
a 3251 4106 1
a 3252 3253 854
a 3252 4106 1
a 3253 3254 853
a 3253 4106 1
a 3254 3255 852
a 3254 4106 1
a 3255 3256 851
a 3255 4106 1
a 3256 3257 850
a 3256 4106 1
a 3257 3258 849
a 3257 4106 1
a 3258 3259 848
a 3258 4106 1
a 3259 3260 847
a 3259 4106 1
a 3260 3261 846
a 3260 4106 1
a 3261 3262 845
a 3261 4106 1
a 3262 3263 844
a 3262 4106 1
a 3263 3264 843
a 3263 4106 1
a 3264 3265 842
a 3264 4106 1
a 3265 3266 841
a 3265 4106 1
a 3266 3267 840
a 3266 4106 1
a 3267 3268 839
a 3267 4106 1
a 3268 3269 838
a 3268 4106 1
a 3269 3270 837
a 3269 4106 1
a 3270 3271 836
a 3270 4106 1
a 3271 3272 835
a 3271 4106 1
a 3272 3273 834
a 3272 4106 1
a 3273 3274 833
a 3273 4106 1
a 3274 3275 832
a 3274 4106 1
a 3275 3276 831
a 3275 4106 1
a 3276 3277 830
a 3276 4106 1
a 3277 3278 829
a 3277 4106 1
a 3278 3279 828
a 3278 4106 1
a 3279 3280 827
a 3279 4106 1
a 3280 3281 826
a 3280 4106 1
a 3281 3282 825
a 3281 4106 1
a 3282 3283 824
a 3282 4106 1
a 3283 3284 823
a 3283 4106 1
a 3284 3285 822
a 3284 4106 1
a 3285 3286 821
a 3285 4106 1
a 3286 3287 820
a 3286 4106 1
a 3287 3288 819
a 3287 4106 1
a 3288 3289 818
a 3288 4106 1
a 3289 3290 817
a 3289 4106 1
a 3290 3291 816
a 3290 4106 1
a 3291 3292 815
a 3291 4106 1
a 3292 3293 814
a 3292 4106 1
a 3293 3294 813
a 3293 4106 1
a 3294 3295 812
a 3294 4106 1
a 3295 3296 811
a 3295 4106 1
a 3296 3297 810
a 3296 4106 1
a 3297 3298 809
a 3297 4106 1
a 3298 3299 808
a 3298 4106 1
a 3299 3300 807
a 3299 4106 1
a 3300 3301 806
a 3300 4106 1
a 3301 3302 805
a 3301 4106 1
a 3302 3303 804
a 3302 4106 1
a 3303 3304 803
a 3303 4106 1
a 3304 3305 802
a 3304 4106 1
a 3305 3306 801
a 3305 4106 1
a 3306 3307 800
a 3306 4106 1
a 3307 3308 799
a 3307 4106 1
a 3308 3309 798
a 3308 4106 1
a 3309 3310 797
a 3309 4106 1
a 3310 3311 796
a 3310 4106 1
a 3311 3312 795
a 3311 4106 1
a 3312 3313 794
a 3312 4106 1
a 3313 3314 793
a 3313 4106 1
a 3314 3315 792
a 3314 4106 1
a 3315 3316 791
a 3315 4106 1
a 3316 3317 790
a 3316 4106 1
a 3317 3318 789
a 3317 4106 1
a 3318 3319 788
a 3318 4106 1
a 3319 3320 787
a 3319 4106 1
a 3320 3321 786
a 3320 4106 1
a 3321 3322 785
a 3321 4106 1
a 3322 3323 784
a 3322 4106 1
a 3323 3324 783
a 3323 4106 1
a 3324 3325 782
a 3324 4106 1
a 3325 3326 781
a 3325 4106 1
a 3326 3327 780
a 3326 4106 1
a 3327 3328 779
a 3327 4106 1
a 3328 3329 778
a 3328 4106 1
a 3329 3330 777
a 3329 4106 1
a 3330 3331 776
a 3330 4106 1
a 3331 3332 775
a 3331 4106 1
a 3332 3333 774
a 3332 4106 1
a 3333 3334 773
a 3333 4106 1
a 3334 3335 772
a 3334 4106 1
a 3335 3336 771
a 3335 4106 1
a 3336 3337 770
a 3336 4106 1
a 3337 3338 769
a 3337 4106 1
a 3338 3339 768
a 3338 4106 1
a 3339 3340 767
a 3339 4106 1
a 3340 3341 766
a 3340 4106 1
a 3341 3342 765
a 3341 4106 1
a 3342 3343 764
a 3342 4106 1
a 3343 3344 763
a 3343 4106 1
a 3344 3345 762
a 3344 4106 1
a 3345 3346 761
a 3345 4106 1
a 3346 3347 760
a 3346 4106 1
a 3347 3348 759
a 3347 4106 1
a 3348 3349 758
a 3348 4106 1
a 3349 3350 757
a 3349 4106 1
a 3350 3351 756
a 3350 4106 1
a 3351 3352 755
a 3351 4106 1
a 3352 3353 754
a 3352 4106 1
a 3353 3354 753
a 3353 4106 1
a 3354 3355 752
a 3354 4106 1
a 3355 3356 751
a 3355 4106 1
a 3356 3357 750
a 3356 4106 1
a 3357 3358 749
a 3357 4106 1
a 3358 3359 748
a 3358 4106 1
a 3359 3360 747
a 3359 4106 1
a 3360 3361 746
a 3360 4106 1
a 3361 3362 745
a 3361 4106 1
a 3362 3363 744
a 3362 4106 1
a 3363 3364 743
a 3363 4106 1
a 3364 3365 742
a 3364 4106 1
a 3365 3366 741
a 3365 4106 1
a 3366 3367 740
a 3366 4106 1
a 3367 3368 739
a 3367 4106 1
a 3368 3369 738
a 3368 4106 1
a 3369 3370 737
a 3369 4106 1
a 3370 3371 736
a 3370 4106 1
a 3371 3372 735
a 3371 4106 1
a 3372 3373 734
a 3372 4106 1
a 3373 3374 733
a 3373 4106 1
a 3374 3375 732
a 3374 4106 1
a 3375 3376 731
a 3375 4106 1
a 3376 3377 730
a 3376 4106 1
a 3377 3378 729
a 3377 4106 1
a 3378 3379 728
a 3378 4106 1
a 3379 3380 727
a 3379 4106 1
a 3380 3381 726
a 3380 4106 1
a 3381 3382 725
a 3381 4106 1
a 3382 3383 724
a 3382 4106 1
a 3383 3384 723
a 3383 4106 1
a 3384 3385 722
a 3384 4106 1
a 3385 3386 721
a 3385 4106 1
a 3386 3387 720
a 3386 4106 1
a 3387 3388 719
a 3387 4106 1
a 3388 3389 718
a 3388 4106 1
a 3389 3390 717
a 3389 4106 1
a 3390 3391 716
a 3390 4106 1
a 3391 3392 715
a 3391 4106 1
a 3392 3393 714
a 3392 4106 1
a 3393 3394 713
a 3393 4106 1
a 3394 3395 712
a 3394 4106 1
a 3395 3396 711
a 3395 4106 1
a 3396 3397 710
a 3396 4106 1
a 3397 3398 709
a 3397 4106 1
a 3398 3399 708
a 3398 4106 1
a 3399 3400 707
a 3399 4106 1
a 3400 3401 706
a 3400 4106 1
a 3401 3402 705
a 3401 4106 1
a 3402 3403 704
a 3402 4106 1
a 3403 3404 703
a 3403 4106 1
a 3404 3405 702
a 3404 4106 1
a 3405 3406 701
a 3405 4106 1
a 3406 3407 700
a 3406 4106 1
a 3407 3408 699
a 3407 4106 1
a 3408 3409 698
a 3408 4106 1
a 3409 3410 697
a 3409 4106 1
a 3410 3411 696
a 3410 4106 1
a 3411 3412 695
a 3411 4106 1
a 3412 3413 694
a 3412 4106 1
a 3413 3414 693
a 3413 4106 1
a 3414 3415 692
a 3414 4106 1
a 3415 3416 691
a 3415 4106 1
a 3416 3417 690
a 3416 4106 1
a 3417 3418 689
a 3417 4106 1
a 3418 3419 688
a 3418 4106 1
a 3419 3420 687
a 3419 4106 1
a 3420 3421 686
a 3420 4106 1
a 3421 3422 685
a 3421 4106 1
a 3422 3423 684
a 3422 4106 1
a 3423 3424 683
a 3423 4106 1
a 3424 3425 682
a 3424 4106 1
a 3425 3426 681
a 3425 4106 1
a 3426 3427 680
a 3426 4106 1
a 3427 3428 679
a 3427 4106 1
a 3428 3429 678
a 3428 4106 1
a 3429 3430 677
a 3429 4106 1
a 3430 3431 676
a 3430 4106 1
a 3431 3432 675
a 3431 4106 1
a 3432 3433 674
a 3432 4106 1
a 3433 3434 673
a 3433 4106 1
a 3434 3435 672
a 3434 4106 1
a 3435 3436 671
a 3435 4106 1
a 3436 3437 670
a 3436 4106 1
a 3437 3438 669
a 3437 4106 1
a 3438 3439 668
a 3438 4106 1
a 3439 3440 667
a 3439 4106 1
a 3440 3441 666
a 3440 4106 1
a 3441 3442 665
a 3441 4106 1
a 3442 3443 664
a 3442 4106 1
a 3443 3444 663
a 3443 4106 1
a 3444 3445 662
a 3444 4106 1
a 3445 3446 661
a 3445 4106 1
a 3446 3447 660
a 3446 4106 1
a 3447 3448 659
a 3447 4106 1
a 3448 3449 658
a 3448 4106 1
a 3449 3450 657
a 3449 4106 1
a 3450 3451 656
a 3450 4106 1
a 3451 3452 655
a 3451 4106 1
a 3452 3453 654
a 3452 4106 1
a 3453 3454 653
a 3453 4106 1
a 3454 3455 652
a 3454 4106 1
a 3455 3456 651
a 3455 4106 1
a 3456 3457 650
a 3456 4106 1
a 3457 3458 649
a 3457 4106 1
a 3458 3459 648
a 3458 4106 1
a 3459 3460 647
a 3459 4106 1
a 3460 3461 646
a 3460 4106 1
a 3461 3462 645
a 3461 4106 1
a 3462 3463 644
a 3462 4106 1
a 3463 3464 643
a 3463 4106 1
a 3464 3465 642
a 3464 4106 1
a 3465 3466 641
a 3465 4106 1
a 3466 3467 640
a 3466 4106 1
a 3467 3468 639
a 3467 4106 1
a 3468 3469 638
a 3468 4106 1
a 3469 3470 637
a 3469 4106 1
a 3470 3471 636
a 3470 4106 1
a 3471 3472 635
a 3471 4106 1
a 3472 3473 634
a 3472 4106 1
a 3473 3474 633
a 3473 4106 1
a 3474 3475 632
a 3474 4106 1
a 3475 3476 631
a 3475 4106 1
a 3476 3477 630
a 3476 4106 1
a 3477 3478 629
a 3477 4106 1
a 3478 3479 628
a 3478 4106 1
a 3479 3480 627
a 3479 4106 1
a 3480 3481 626
a 3480 4106 1
a 3481 3482 625
a 3481 4106 1
a 3482 3483 624
a 3482 4106 1
a 3483 3484 623
a 3483 4106 1
a 3484 3485 622
a 3484 4106 1
a 3485 3486 621
a 3485 4106 1
a 3486 3487 620
a 3486 4106 1
a 3487 3488 619
a 3487 4106 1
a 3488 3489 618
a 3488 4106 1
a 3489 3490 617
a 3489 4106 1
a 3490 3491 616
a 3490 4106 1
a 3491 3492 615
a 3491 4106 1
a 3492 3493 614
a 3492 4106 1
a 3493 3494 613
a 3493 4106 1
a 3494 3495 612
a 3494 4106 1
a 3495 3496 611
a 3495 4106 1
a 3496 3497 610
a 3496 4106 1
a 3497 3498 609
a 3497 4106 1
a 3498 3499 608
a 3498 4106 1
a 3499 3500 607
a 3499 4106 1
a 3500 3501 606
a 3500 4106 1
a 3501 3502 605
a 3501 4106 1
a 3502 3503 604
a 3502 4106 1
a 3503 3504 603
a 3503 4106 1
a 3504 3505 602
a 3504 4106 1
a 3505 3506 601
a 3505 4106 1
a 3506 3507 600
a 3506 4106 1
a 3507 3508 599
a 3507 4106 1
a 3508 3509 598
a 3508 4106 1
a 3509 3510 597
a 3509 4106 1
a 3510 3511 596
a 3510 4106 1
a 3511 3512 595
a 3511 4106 1
a 3512 3513 594
a 3512 4106 1
a 3513 3514 593
a 3513 4106 1
a 3514 3515 592
a 3514 4106 1
a 3515 3516 591
a 3515 4106 1
a 3516 3517 590
a 3516 4106 1
a 3517 3518 589
a 3517 4106 1
a 3518 3519 588
a 3518 4106 1
a 3519 3520 587
a 3519 4106 1
a 3520 3521 586
a 3520 4106 1
a 3521 3522 585
a 3521 4106 1
a 3522 3523 584
a 3522 4106 1
a 3523 3524 583
a 3523 4106 1
a 3524 3525 582
a 3524 4106 1
a 3525 3526 581
a 3525 4106 1
a 3526 3527 580
a 3526 4106 1
a 3527 3528 579
a 3527 4106 1
a 3528 3529 578
a 3528 4106 1
a 3529 3530 577
a 3529 4106 1
a 3530 3531 576
a 3530 4106 1
a 3531 3532 575
a 3531 4106 1
a 3532 3533 574
a 3532 4106 1
a 3533 3534 573
a 3533 4106 1
a 3534 3535 572
a 3534 4106 1
a 3535 3536 571
a 3535 4106 1
a 3536 3537 570
a 3536 4106 1
a 3537 3538 569
a 3537 4106 1
a 3538 3539 568
a 3538 4106 1
a 3539 3540 567
a 3539 4106 1
a 3540 3541 566
a 3540 4106 1
a 3541 3542 565
a 3541 4106 1
a 3542 3543 564
a 3542 4106 1
a 3543 3544 563
a 3543 4106 1
a 3544 3545 562
a 3544 4106 1
a 3545 3546 561
a 3545 4106 1
a 3546 3547 560
a 3546 4106 1
a 3547 3548 559
a 3547 4106 1
a 3548 3549 558
a 3548 4106 1
a 3549 3550 557
a 3549 4106 1
a 3550 3551 556
a 3550 4106 1
a 3551 3552 555
a 3551 4106 1
a 3552 3553 554
a 3552 4106 1
a 3553 3554 553
a 3553 4106 1
a 3554 3555 552
a 3554 4106 1
a 3555 3556 551
a 3555 4106 1
a 3556 3557 550
a 3556 4106 1
a 3557 3558 549
a 3557 4106 1
a 3558 3559 548
a 3558 4106 1
a 3559 3560 547
a 3559 4106 1
a 3560 3561 546
a 3560 4106 1
a 3561 3562 545
a 3561 4106 1
a 3562 3563 544
a 3562 4106 1
a 3563 3564 543
a 3563 4106 1
a 3564 3565 542
a 3564 4106 1
a 3565 3566 541
a 3565 4106 1
a 3566 3567 540
a 3566 4106 1
a 3567 3568 539
a 3567 4106 1
a 3568 3569 538
a 3568 4106 1
a 3569 3570 537
a 3569 4106 1
a 3570 3571 536
a 3570 4106 1
a 3571 3572 535
a 3571 4106 1
a 3572 3573 534
a 3572 4106 1
a 3573 3574 533
a 3573 4106 1
a 3574 3575 532
a 3574 4106 1
a 3575 3576 531
a 3575 4106 1
a 3576 3577 530
a 3576 4106 1
a 3577 3578 529
a 3577 4106 1
a 3578 3579 528
a 3578 4106 1
a 3579 3580 527
a 3579 4106 1
a 3580 3581 526
a 3580 4106 1
a 3581 3582 525
a 3581 4106 1
a 3582 3583 524
a 3582 4106 1
a 3583 3584 523
a 3583 4106 1
a 3584 3585 522
a 3584 4106 1
a 3585 3586 521
a 3585 4106 1
a 3586 3587 520
a 3586 4106 1
a 3587 3588 519
a 3587 4106 1
a 3588 3589 518
a 3588 4106 1
a 3589 3590 517
a 3589 4106 1
a 3590 3591 516
a 3590 4106 1
a 3591 3592 515
a 3591 4106 1
a 3592 3593 514
a 3592 4106 1
a 3593 3594 513
a 3593 4106 1
a 3594 3595 512
a 3594 4106 1
a 3595 3596 511
a 3595 4106 1
a 3596 3597 510
a 3596 4106 1
a 3597 3598 509
a 3597 4106 1
a 3598 3599 508
a 3598 4106 1
a 3599 3600 507
a 3599 4106 1
a 3600 3601 506
a 3600 4106 1
a 3601 3602 505
a 3601 4106 1
a 3602 3603 504
a 3602 4106 1
a 3603 3604 503
a 3603 4106 1
a 3604 3605 502
a 3604 4106 1
a 3605 3606 501
a 3605 4106 1
a 3606 3607 500
a 3606 4106 1
a 3607 3608 499
a 3607 4106 1
a 3608 3609 498
a 3608 4106 1
a 3609 3610 497
a 3609 4106 1
a 3610 3611 496
a 3610 4106 1
a 3611 3612 495
a 3611 4106 1
a 3612 3613 494
a 3612 4106 1
a 3613 3614 493
a 3613 4106 1
a 3614 3615 492
a 3614 4106 1
a 3615 3616 491
a 3615 4106 1
a 3616 3617 490
a 3616 4106 1
a 3617 3618 489
a 3617 4106 1
a 3618 3619 488
a 3618 4106 1
a 3619 3620 487
a 3619 4106 1
a 3620 3621 486
a 3620 4106 1
a 3621 3622 485
a 3621 4106 1
a 3622 3623 484
a 3622 4106 1
a 3623 3624 483
a 3623 4106 1
a 3624 3625 482
a 3624 4106 1
a 3625 3626 481
a 3625 4106 1
a 3626 3627 480
a 3626 4106 1
a 3627 3628 479
a 3627 4106 1
a 3628 3629 478
a 3628 4106 1
a 3629 3630 477
a 3629 4106 1
a 3630 3631 476
a 3630 4106 1
a 3631 3632 475
a 3631 4106 1
a 3632 3633 474
a 3632 4106 1
a 3633 3634 473
a 3633 4106 1
a 3634 3635 472
a 3634 4106 1
a 3635 3636 471
a 3635 4106 1
a 3636 3637 470
a 3636 4106 1
a 3637 3638 469
a 3637 4106 1
a 3638 3639 468
a 3638 4106 1
a 3639 3640 467
a 3639 4106 1
a 3640 3641 466
a 3640 4106 1
a 3641 3642 465
a 3641 4106 1
a 3642 3643 464
a 3642 4106 1
a 3643 3644 463
a 3643 4106 1
a 3644 3645 462
a 3644 4106 1
a 3645 3646 461
a 3645 4106 1
a 3646 3647 460
a 3646 4106 1
a 3647 3648 459
a 3647 4106 1
a 3648 3649 458
a 3648 4106 1
a 3649 3650 457
a 3649 4106 1
a 3650 3651 456
a 3650 4106 1
a 3651 3652 455
a 3651 4106 1
a 3652 3653 454
a 3652 4106 1
a 3653 3654 453
a 3653 4106 1
a 3654 3655 452
a 3654 4106 1
a 3655 3656 451
a 3655 4106 1
a 3656 3657 450
a 3656 4106 1
a 3657 3658 449
a 3657 4106 1
a 3658 3659 448
a 3658 4106 1
a 3659 3660 447
a 3659 4106 1
a 3660 3661 446
a 3660 4106 1
a 3661 3662 445
a 3661 4106 1
a 3662 3663 444
a 3662 4106 1
a 3663 3664 443
a 3663 4106 1
a 3664 3665 442
a 3664 4106 1
a 3665 3666 441
a 3665 4106 1
a 3666 3667 440
a 3666 4106 1
a 3667 3668 439
a 3667 4106 1
a 3668 3669 438
a 3668 4106 1
a 3669 3670 437
a 3669 4106 1
a 3670 3671 436
a 3670 4106 1
a 3671 3672 435
a 3671 4106 1
a 3672 3673 434
a 3672 4106 1
a 3673 3674 433
a 3673 4106 1
a 3674 3675 432
a 3674 4106 1
a 3675 3676 431
a 3675 4106 1
a 3676 3677 430
a 3676 4106 1
a 3677 3678 429
a 3677 4106 1
a 3678 3679 428
a 3678 4106 1
a 3679 3680 427
a 3679 4106 1
a 3680 3681 426
a 3680 4106 1
a 3681 3682 425
a 3681 4106 1
a 3682 3683 424
a 3682 4106 1
a 3683 3684 423
a 3683 4106 1
a 3684 3685 422
a 3684 4106 1
a 3685 3686 421
a 3685 4106 1
a 3686 3687 420
a 3686 4106 1
a 3687 3688 419
a 3687 4106 1
a 3688 3689 418
a 3688 4106 1
a 3689 3690 417
a 3689 4106 1
a 3690 3691 416
a 3690 4106 1
a 3691 3692 415
a 3691 4106 1
a 3692 3693 414
a 3692 4106 1
a 3693 3694 413
a 3693 4106 1
a 3694 3695 412
a 3694 4106 1
a 3695 3696 411
a 3695 4106 1
a 3696 3697 410
a 3696 4106 1
a 3697 3698 409
a 3697 4106 1
a 3698 3699 408
a 3698 4106 1
a 3699 3700 407
a 3699 4106 1
a 3700 3701 406
a 3700 4106 1
a 3701 3702 405
a 3701 4106 1
a 3702 3703 404
a 3702 4106 1
a 3703 3704 403
a 3703 4106 1
a 3704 3705 402
a 3704 4106 1
a 3705 3706 401
a 3705 4106 1
a 3706 3707 400
a 3706 4106 1
a 3707 3708 399
a 3707 4106 1
a 3708 3709 398
a 3708 4106 1
a 3709 3710 397
a 3709 4106 1
a 3710 3711 396
a 3710 4106 1
a 3711 3712 395
a 3711 4106 1
a 3712 3713 394
a 3712 4106 1
a 3713 3714 393
a 3713 4106 1
a 3714 3715 392
a 3714 4106 1
a 3715 3716 391
a 3715 4106 1
a 3716 3717 390
a 3716 4106 1
a 3717 3718 389
a 3717 4106 1
a 3718 3719 388
a 3718 4106 1
a 3719 3720 387
a 3719 4106 1
a 3720 3721 386
a 3720 4106 1
a 3721 3722 385
a 3721 4106 1
a 3722 3723 384
a 3722 4106 1
a 3723 3724 383
a 3723 4106 1
a 3724 3725 382
a 3724 4106 1
a 3725 3726 381
a 3725 4106 1
a 3726 3727 380
a 3726 4106 1
a 3727 3728 379
a 3727 4106 1
a 3728 3729 378
a 3728 4106 1
a 3729 3730 377
a 3729 4106 1
a 3730 3731 376
a 3730 4106 1
a 3731 3732 375
a 3731 4106 1
a 3732 3733 374
a 3732 4106 1
a 3733 3734 373
a 3733 4106 1
a 3734 3735 372
a 3734 4106 1
a 3735 3736 371
a 3735 4106 1
a 3736 3737 370
a 3736 4106 1
a 3737 3738 369
a 3737 4106 1
a 3738 3739 368
a 3738 4106 1
a 3739 3740 367
a 3739 4106 1
a 3740 3741 366
a 3740 4106 1
a 3741 3742 365
a 3741 4106 1
a 3742 3743 364
a 3742 4106 1
a 3743 3744 363
a 3743 4106 1
a 3744 3745 362
a 3744 4106 1
a 3745 3746 361
a 3745 4106 1
a 3746 3747 360
a 3746 4106 1
a 3747 3748 359
a 3747 4106 1
a 3748 3749 358
a 3748 4106 1
a 3749 3750 357
a 3749 4106 1
a 3750 3751 356
a 3750 4106 1
a 3751 3752 355
a 3751 4106 1
a 3752 3753 354
a 3752 4106 1
a 3753 3754 353
a 3753 4106 1
a 3754 3755 352
a 3754 4106 1
a 3755 3756 351
a 3755 4106 1
a 3756 3757 350
a 3756 4106 1
a 3757 3758 349
a 3757 4106 1
a 3758 3759 348
a 3758 4106 1
a 3759 3760 347
a 3759 4106 1
a 3760 3761 346
a 3760 4106 1
a 3761 3762 345
a 3761 4106 1
a 3762 3763 344
a 3762 4106 1
a 3763 3764 343
a 3763 4106 1
a 3764 3765 342
a 3764 4106 1
a 3765 3766 341
a 3765 4106 1
a 3766 3767 340
a 3766 4106 1
a 3767 3768 339
a 3767 4106 1
a 3768 3769 338
a 3768 4106 1
a 3769 3770 337
a 3769 4106 1
a 3770 3771 336
a 3770 4106 1
a 3771 3772 335
a 3771 4106 1
a 3772 3773 334
a 3772 4106 1
a 3773 3774 333
a 3773 4106 1
a 3774 3775 332
a 3774 4106 1
a 3775 3776 331
a 3775 4106 1
a 3776 3777 330
a 3776 4106 1
a 3777 3778 329
a 3777 4106 1
a 3778 3779 328
a 3778 4106 1
a 3779 3780 327
a 3779 4106 1
a 3780 3781 326
a 3780 4106 1
a 3781 3782 325
a 3781 4106 1
a 3782 3783 324
a 3782 4106 1
a 3783 3784 323
a 3783 4106 1
a 3784 3785 322
a 3784 4106 1
a 3785 3786 321
a 3785 4106 1
a 3786 3787 320
a 3786 4106 1
a 3787 3788 319
a 3787 4106 1
a 3788 3789 318
a 3788 4106 1
a 3789 3790 317
a 3789 4106 1
a 3790 3791 316
a 3790 4106 1
a 3791 3792 315
a 3791 4106 1
a 3792 3793 314
a 3792 4106 1
a 3793 3794 313
a 3793 4106 1
a 3794 3795 312
a 3794 4106 1
a 3795 3796 311
a 3795 4106 1
a 3796 3797 310
a 3796 4106 1
a 3797 3798 309
a 3797 4106 1
a 3798 3799 308
a 3798 4106 1
a 3799 3800 307
a 3799 4106 1
a 3800 3801 306
a 3800 4106 1
a 3801 3802 305
a 3801 4106 1
a 3802 3803 304
a 3802 4106 1
a 3803 3804 303
a 3803 4106 1
a 3804 3805 302
a 3804 4106 1
a 3805 3806 301
a 3805 4106 1
a 3806 3807 300
a 3806 4106 1
a 3807 3808 299
a 3807 4106 1
a 3808 3809 298
a 3808 4106 1
a 3809 3810 297
a 3809 4106 1
a 3810 3811 296
a 3810 4106 1
a 3811 3812 295
a 3811 4106 1
a 3812 3813 294
a 3812 4106 1
a 3813 3814 293
a 3813 4106 1
a 3814 3815 292
a 3814 4106 1
a 3815 3816 291
a 3815 4106 1
a 3816 3817 290
a 3816 4106 1
a 3817 3818 289
a 3817 4106 1
a 3818 3819 288
a 3818 4106 1
a 3819 3820 287
a 3819 4106 1
a 3820 3821 286
a 3820 4106 1
a 3821 3822 285
a 3821 4106 1
a 3822 3823 284
a 3822 4106 1
a 3823 3824 283
a 3823 4106 1
a 3824 3825 282
a 3824 4106 1
a 3825 3826 281
a 3825 4106 1
a 3826 3827 280
a 3826 4106 1
a 3827 3828 279
a 3827 4106 1
a 3828 3829 278
a 3828 4106 1
a 3829 3830 277
a 3829 4106 1
a 3830 3831 276
a 3830 4106 1
a 3831 3832 275
a 3831 4106 1
a 3832 3833 274
a 3832 4106 1
a 3833 3834 273
a 3833 4106 1
a 3834 3835 272
a 3834 4106 1
a 3835 3836 271
a 3835 4106 1
a 3836 3837 270
a 3836 4106 1
a 3837 3838 269
a 3837 4106 1
a 3838 3839 268
a 3838 4106 1
a 3839 3840 267
a 3839 4106 1
a 3840 3841 266
a 3840 4106 1
a 3841 3842 265
a 3841 4106 1
a 3842 3843 264
a 3842 4106 1
a 3843 3844 263
a 3843 4106 1
a 3844 3845 262
a 3844 4106 1
a 3845 3846 261
a 3845 4106 1
a 3846 3847 260
a 3846 4106 1
a 3847 3848 259
a 3847 4106 1
a 3848 3849 258
a 3848 4106 1
a 3849 3850 257
a 3849 4106 1
a 3850 3851 256
a 3850 4106 1
a 3851 3852 255
a 3851 4106 1
a 3852 3853 254
a 3852 4106 1
a 3853 3854 253
a 3853 4106 1
a 3854 3855 252
a 3854 4106 1
a 3855 3856 251
a 3855 4106 1
a 3856 3857 250
a 3856 4106 1
a 3857 3858 249
a 3857 4106 1
a 3858 3859 248
a 3858 4106 1
a 3859 3860 247
a 3859 4106 1
a 3860 3861 246
a 3860 4106 1
a 3861 3862 245
a 3861 4106 1
a 3862 3863 244
a 3862 4106 1
a 3863 3864 243
a 3863 4106 1
a 3864 3865 242
a 3864 4106 1
a 3865 3866 241
a 3865 4106 1
a 3866 3867 240
a 3866 4106 1
a 3867 3868 239
a 3867 4106 1
a 3868 3869 238
a 3868 4106 1
a 3869 3870 237
a 3869 4106 1
a 3870 3871 236
a 3870 4106 1
a 3871 3872 235
a 3871 4106 1
a 3872 3873 234
a 3872 4106 1
a 3873 3874 233
a 3873 4106 1
a 3874 3875 232
a 3874 4106 1
a 3875 3876 231
a 3875 4106 1
a 3876 3877 230
a 3876 4106 1
a 3877 3878 229
a 3877 4106 1
a 3878 3879 228
a 3878 4106 1
a 3879 3880 227
a 3879 4106 1
a 3880 3881 226
a 3880 4106 1
a 3881 3882 225
a 3881 4106 1
a 3882 3883 224
a 3882 4106 1
a 3883 3884 223
a 3883 4106 1
a 3884 3885 222
a 3884 4106 1
a 3885 3886 221
a 3885 4106 1
a 3886 3887 220
a 3886 4106 1
a 3887 3888 219
a 3887 4106 1
a 3888 3889 218
a 3888 4106 1
a 3889 3890 217
a 3889 4106 1
a 3890 3891 216
a 3890 4106 1
a 3891 3892 215
a 3891 4106 1
a 3892 3893 214
a 3892 4106 1
a 3893 3894 213
a 3893 4106 1
a 3894 3895 212
a 3894 4106 1
a 3895 3896 211
a 3895 4106 1
a 3896 3897 210
a 3896 4106 1
a 3897 3898 209
a 3897 4106 1
a 3898 3899 208
a 3898 4106 1
a 3899 3900 207
a 3899 4106 1
a 3900 3901 206
a 3900 4106 1
a 3901 3902 205
a 3901 4106 1
a 3902 3903 204
a 3902 4106 1
a 3903 3904 203
a 3903 4106 1
a 3904 3905 202
a 3904 4106 1
a 3905 3906 201
a 3905 4106 1
a 3906 3907 200
a 3906 4106 1
a 3907 3908 199
a 3907 4106 1
a 3908 3909 198
a 3908 4106 1
a 3909 3910 197
a 3909 4106 1
a 3910 3911 196
a 3910 4106 1
a 3911 3912 195
a 3911 4106 1
a 3912 3913 194
a 3912 4106 1
a 3913 3914 193
a 3913 4106 1
a 3914 3915 192
a 3914 4106 1
a 3915 3916 191
a 3915 4106 1
a 3916 3917 190
a 3916 4106 1
a 3917 3918 189
a 3917 4106 1
a 3918 3919 188
a 3918 4106 1
a 3919 3920 187
a 3919 4106 1
a 3920 3921 186
a 3920 4106 1
a 3921 3922 185
a 3921 4106 1
a 3922 3923 184
a 3922 4106 1
a 3923 3924 183
a 3923 4106 1
a 3924 3925 182
a 3924 4106 1
a 3925 3926 181
a 3925 4106 1
a 3926 3927 180
a 3926 4106 1
a 3927 3928 179
a 3927 4106 1
a 3928 3929 178
a 3928 4106 1
a 3929 3930 177
a 3929 4106 1
a 3930 3931 176
a 3930 4106 1
a 3931 3932 175
a 3931 4106 1
a 3932 3933 174
a 3932 4106 1
a 3933 3934 173
a 3933 4106 1
a 3934 3935 172
a 3934 4106 1
a 3935 3936 171
a 3935 4106 1
a 3936 3937 170
a 3936 4106 1
a 3937 3938 169
a 3937 4106 1
a 3938 3939 168
a 3938 4106 1
a 3939 3940 167
a 3939 4106 1
a 3940 3941 166
a 3940 4106 1
a 3941 3942 165
a 3941 4106 1
a 3942 3943 164
a 3942 4106 1
a 3943 3944 163
a 3943 4106 1
a 3944 3945 162
a 3944 4106 1
a 3945 3946 161
a 3945 4106 1
a 3946 3947 160
a 3946 4106 1
a 3947 3948 159
a 3947 4106 1
a 3948 3949 158
a 3948 4106 1
a 3949 3950 157
a 3949 4106 1
a 3950 3951 156
a 3950 4106 1
a 3951 3952 155
a 3951 4106 1
a 3952 3953 154
a 3952 4106 1
a 3953 3954 153
a 3953 4106 1
a 3954 3955 152
a 3954 4106 1
a 3955 3956 151
a 3955 4106 1
a 3956 3957 150
a 3956 4106 1
a 3957 3958 149
a 3957 4106 1
a 3958 3959 148
a 3958 4106 1
a 3959 3960 147
a 3959 4106 1
a 3960 3961 146
a 3960 4106 1
a 3961 3962 145
a 3961 4106 1
a 3962 3963 144
a 3962 4106 1
a 3963 3964 143
a 3963 4106 1
a 3964 3965 142
a 3964 4106 1
a 3965 3966 141
a 3965 4106 1
a 3966 3967 140
a 3966 4106 1
a 3967 3968 139
a 3967 4106 1
a 3968 3969 138
a 3968 4106 1
a 3969 3970 137
a 3969 4106 1
a 3970 3971 136
a 3970 4106 1
a 3971 3972 135
a 3971 4106 1
a 3972 3973 134
a 3972 4106 1
a 3973 3974 133
a 3973 4106 1
a 3974 3975 132
a 3974 4106 1
a 3975 3976 131
a 3975 4106 1
a 3976 3977 130
a 3976 4106 1
a 3977 3978 129
a 3977 4106 1
a 3978 3979 128
a 3978 4106 1
a 3979 3980 127
a 3979 4106 1
a 3980 3981 126
a 3980 4106 1
a 3981 3982 125
a 3981 4106 1
a 3982 3983 124
a 3982 4106 1
a 3983 3984 123
a 3983 4106 1
a 3984 3985 122
a 3984 4106 1
a 3985 3986 121
a 3985 4106 1
a 3986 3987 120
a 3986 4106 1
a 3987 3988 119
a 3987 4106 1
a 3988 3989 118
a 3988 4106 1
a 3989 3990 117
a 3989 4106 1
a 3990 3991 116
a 3990 4106 1
a 3991 3992 115
a 3991 4106 1
a 3992 3993 114
a 3992 4106 1
a 3993 3994 113
a 3993 4106 1
a 3994 3995 112
a 3994 4106 1
a 3995 3996 111
a 3995 4106 1
a 3996 3997 110
a 3996 4106 1
a 3997 3998 109
a 3997 4106 1
a 3998 3999 108
a 3998 4106 1
a 3999 4000 107
a 3999 4106 1
a 4000 4001 106
a 4000 4106 1
a 4001 4002 105
a 4001 4106 1
a 4002 4003 104
a 4002 4106 1
a 4003 4004 103
a 4003 4106 1
a 4004 4005 102
a 4004 4106 1
a 4005 4006 101
a 4005 4106 1
a 4006 4007 100
a 4006 4106 1
a 4007 4008 99
a 4007 4106 1
a 4008 4009 98
a 4008 4106 1
a 4009 4010 97
a 4009 4106 1
a 4010 4011 96
a 4010 4106 1
a 4011 4012 95
a 4011 4106 1
a 4012 4013 94
a 4012 4106 1
a 4013 4014 93
a 4013 4106 1
a 4014 4015 92
a 4014 4106 1
a 4015 4016 91
a 4015 4106 1
a 4016 4017 90
a 4016 4106 1
a 4017 4018 89
a 4017 4106 1
a 4018 4019 88
a 4018 4106 1
a 4019 4020 87
a 4019 4106 1
a 4020 4021 86
a 4020 4106 1
a 4021 4022 85
a 4021 4106 1
a 4022 4023 84
a 4022 4106 1
a 4023 4024 83
a 4023 4106 1
a 4024 4025 82
a 4024 4106 1
a 4025 4026 81
a 4025 4106 1
a 4026 4027 80
a 4026 4106 1
a 4027 4028 79
a 4027 4106 1
a 4028 4029 78
a 4028 4106 1
a 4029 4030 77
a 4029 4106 1
a 4030 4031 76
a 4030 4106 1
a 4031 4032 75
a 4031 4106 1
a 4032 4033 74
a 4032 4106 1
a 4033 4034 73
a 4033 4106 1
a 4034 4035 72
a 4034 4106 1
a 4035 4036 71
a 4035 4106 1
a 4036 4037 70
a 4036 4106 1
a 4037 4038 69
a 4037 4106 1
a 4038 4039 68
a 4038 4106 1
a 4039 4040 67
a 4039 4106 1
a 4040 4041 66
a 4040 4106 1
a 4041 4042 65
a 4041 4106 1
a 4042 4043 64
a 4042 4106 1
a 4043 4044 63
a 4043 4106 1
a 4044 4045 62
a 4044 4106 1
a 4045 4046 61
a 4045 4106 1
a 4046 4047 60
a 4046 4106 1
a 4047 4048 59
a 4047 4106 1
a 4048 4049 58
a 4048 4106 1
a 4049 4050 57
a 4049 4106 1
a 4050 4051 56
a 4050 4106 1
a 4051 4052 55
a 4051 4106 1
a 4052 4053 54
a 4052 4106 1
a 4053 4054 53
a 4053 4106 1
a 4054 4055 52
a 4054 4106 1
a 4055 4056 51
a 4055 4106 1
a 4056 4057 50
a 4056 4106 1
a 4057 4058 49
a 4057 4106 1
a 4058 4059 48
a 4058 4106 1
a 4059 4060 47
a 4059 4106 1
a 4060 4061 46
a 4060 4106 1
a 4061 4062 45
a 4061 4106 1
a 4062 4063 44
a 4062 4106 1
a 4063 4064 43
a 4063 4106 1
a 4064 4065 42
a 4064 4106 1
a 4065 4066 41
a 4065 4106 1
a 4066 4067 40
a 4066 4106 1
a 4067 4068 39
a 4067 4106 1
a 4068 4069 38
a 4068 4106 1
a 4069 4070 37
a 4069 4106 1
a 4070 4071 36
a 4070 4106 1
a 4071 4072 35
a 4071 4106 1
a 4072 4073 34
a 4072 4106 1
a 4073 4074 33
a 4073 4106 1
a 4074 4075 32
a 4074 4106 1
a 4075 4076 31
a 4075 4106 1
a 4076 4077 30
a 4076 4106 1
a 4077 4078 29
a 4077 4106 1
a 4078 4079 28
a 4078 4106 1
a 4079 4080 27
a 4079 4106 1
a 4080 4081 26
a 4080 4106 1
a 4081 4082 25
a 4081 4106 1
a 4082 4083 24
a 4082 4106 1
a 4083 4084 23
a 4083 4106 1
a 4084 4085 22
a 4084 4106 1
a 4085 4086 21
a 4085 4106 1
a 4086 4087 20
a 4086 4106 1
a 4087 4088 19
a 4087 4106 1
a 4088 4089 18
a 4088 4106 1
a 4089 4090 17
a 4089 4106 1
a 4090 4091 16
a 4090 4106 1
a 4091 4092 15
a 4091 4106 1
a 4092 4093 14
a 4092 4106 1
a 4093 4094 13
a 4093 4106 1
a 4094 4095 12
a 4094 4106 1
a 4095 4096 11
a 4095 4106 1
a 4096 4097 10
a 4096 4106 1
a 4097 4098 9
a 4097 4106 1
a 4098 4099 8
a 4098 4106 1
a 4099 4100 7
a 4099 4106 1
a 4100 4101 6
a 4100 4106 1
a 4101 4102 5
a 4101 4106 1
a 4102 4103 4
a 4102 4106 1
a 4103 4104 3
a 4103 4106 1
a 4104 4105 2
a 4104 4106 1
a 4105 8208 1
a 4105 4106 1
a 4106 4107 4103
a 4107 4108 4103
a 4108 4109 4103
a 4109 4110 4103
a 4110 4111 4103
a 4111 4112 4103
a 4112 4113 4103
a 4113 4114 4103
a 4114 4115 4103
a 4115 4116 4103
a 4116 4117 4103
a 4117 4118 4103
a 4118 4119 4103
a 4119 4120 4103
a 4120 4121 4103
a 4121 4122 4103
a 4122 4123 4103
a 4123 4124 4103
a 4124 4125 4103
a 4125 4126 4103
a 4126 4127 4103
a 4127 4128 4103
a 4128 4129 4103
a 4129 4130 4103
a 4130 4131 4103
a 4131 4132 4103
a 4132 4133 4103
a 4133 4134 4103
a 4134 4135 4103
a 4135 4136 4103
a 4136 4137 4103
a 4137 4138 4103
a 4138 4139 4103
a 4139 4140 4103
a 4140 4141 4103
a 4141 4142 4103
a 4142 4143 4103
a 4143 4144 4103
a 4144 4145 4103
a 4145 4146 4103
a 4146 4147 4103
a 4147 4148 4103
a 4148 4149 4103
a 4149 4150 4103
a 4150 4151 4103
a 4151 4152 4103
a 4152 4153 4103
a 4153 4154 4103
a 4154 4155 4103
a 4155 4156 4103
a 4156 4157 4103
a 4157 4158 4103
a 4158 4159 4103
a 4159 4160 4103
a 4160 4161 4103
a 4161 4162 4103
a 4162 4163 4103
a 4163 4164 4103
a 4164 4165 4103
a 4165 4166 4103
a 4166 4167 4103
a 4167 4168 4103
a 4168 4169 4103
a 4169 4170 4103
a 4170 4171 4103
a 4171 4172 4103
a 4172 4173 4103
a 4173 4174 4103
a 4174 4175 4103
a 4175 4176 4103
a 4176 4177 4103
a 4177 4178 4103
a 4178 4179 4103
a 4179 4180 4103
a 4180 4181 4103
a 4181 4182 4103
a 4182 4183 4103
a 4183 4184 4103
a 4184 4185 4103
a 4185 4186 4103
a 4186 4187 4103
a 4187 4188 4103
a 4188 4189 4103
a 4189 4190 4103
a 4190 4191 4103
a 4191 4192 4103
a 4192 4193 4103
a 4193 4194 4103
a 4194 4195 4103
a 4195 4196 4103
a 4196 4197 4103
a 4197 4198 4103
a 4198 4199 4103
a 4199 4200 4103
a 4200 4201 4103
a 4201 4202 4103
a 4202 4203 4103
a 4203 4204 4103
a 4204 4205 4103
a 4205 4206 4103
a 4206 4207 4103
a 4207 4208 4103
a 4208 4209 4103
a 4209 4210 4103
a 4210 4211 4103
a 4211 4212 4103
a 4212 4213 4103
a 4213 4214 4103
a 4214 4215 4103
a 4215 4216 4103
a 4216 4217 4103
a 4217 4218 4103
a 4218 4219 4103
a 4219 4220 4103
a 4220 4221 4103
a 4221 4222 4103
a 4222 4223 4103
a 4223 4224 4103
a 4224 4225 4103
a 4225 4226 4103
a 4226 4227 4103
a 4227 4228 4103
a 4228 4229 4103
a 4229 4230 4103
a 4230 4231 4103
a 4231 4232 4103
a 4232 4233 4103
a 4233 4234 4103
a 4234 4235 4103
a 4235 4236 4103
a 4236 4237 4103
a 4237 4238 4103
a 4238 4239 4103
a 4239 4240 4103
a 4240 4241 4103
a 4241 4242 4103
a 4242 4243 4103
a 4243 4244 4103
a 4244 4245 4103
a 4245 4246 4103
a 4246 4247 4103
a 4247 4248 4103
a 4248 4249 4103
a 4249 4250 4103
a 4250 4251 4103
a 4251 4252 4103
a 4252 4253 4103
a 4253 4254 4103
a 4254 4255 4103
a 4255 4256 4103
a 4256 4257 4103
a 4257 4258 4103
a 4258 4259 4103
a 4259 4260 4103
a 4260 4261 4103
a 4261 4262 4103
a 4262 4263 4103
a 4263 4264 4103
a 4264 4265 4103
a 4265 4266 4103
a 4266 4267 4103
a 4267 4268 4103
a 4268 4269 4103
a 4269 4270 4103
a 4270 4271 4103
a 4271 4272 4103
a 4272 4273 4103
a 4273 4274 4103
a 4274 4275 4103
a 4275 4276 4103
a 4276 4277 4103
a 4277 4278 4103
a 4278 4279 4103
a 4279 4280 4103
a 4280 4281 4103
a 4281 4282 4103
a 4282 4283 4103
a 4283 4284 4103
a 4284 4285 4103
a 4285 4286 4103
a 4286 4287 4103
a 4287 4288 4103
a 4288 4289 4103
a 4289 4290 4103
a 4290 4291 4103
a 4291 4292 4103
a 4292 4293 4103
a 4293 4294 4103
a 4294 4295 4103
a 4295 4296 4103
a 4296 4297 4103
a 4297 4298 4103
a 4298 4299 4103
a 4299 4300 4103
a 4300 4301 4103
a 4301 4302 4103
a 4302 4303 4103
a 4303 4304 4103
a 4304 4305 4103
a 4305 4306 4103
a 4306 4307 4103
a 4307 4308 4103
a 4308 4309 4103
a 4309 4310 4103
a 4310 4311 4103
a 4311 4312 4103
a 4312 4313 4103
a 4313 4314 4103
a 4314 4315 4103
a 4315 4316 4103
a 4316 4317 4103
a 4317 4318 4103
a 4318 4319 4103
a 4319 4320 4103
a 4320 4321 4103
a 4321 4322 4103
a 4322 4323 4103
a 4323 4324 4103
a 4324 4325 4103
a 4325 4326 4103
a 4326 4327 4103
a 4327 4328 4103
a 4328 4329 4103
a 4329 4330 4103
a 4330 4331 4103
a 4331 4332 4103
a 4332 4333 4103
a 4333 4334 4103
a 4334 4335 4103
a 4335 4336 4103
a 4336 4337 4103
a 4337 4338 4103
a 4338 4339 4103
a 4339 4340 4103
a 4340 4341 4103
a 4341 4342 4103
a 4342 4343 4103
a 4343 4344 4103
a 4344 4345 4103
a 4345 4346 4103
a 4346 4347 4103
a 4347 4348 4103
a 4348 4349 4103
a 4349 4350 4103
a 4350 4351 4103
a 4351 4352 4103
a 4352 4353 4103
a 4353 4354 4103
a 4354 4355 4103
a 4355 4356 4103
a 4356 4357 4103
a 4357 4358 4103
a 4358 4359 4103
a 4359 4360 4103
a 4360 4361 4103
a 4361 4362 4103
a 4362 4363 4103
a 4363 4364 4103
a 4364 4365 4103
a 4365 4366 4103
a 4366 4367 4103
a 4367 4368 4103
a 4368 4369 4103
a 4369 4370 4103
a 4370 4371 4103
a 4371 4372 4103
a 4372 4373 4103
a 4373 4374 4103
a 4374 4375 4103
a 4375 4376 4103
a 4376 4377 4103
a 4377 4378 4103
a 4378 4379 4103
a 4379 4380 4103
a 4380 4381 4103
a 4381 4382 4103
a 4382 4383 4103
a 4383 4384 4103
a 4384 4385 4103
a 4385 4386 4103
a 4386 4387 4103
a 4387 4388 4103
a 4388 4389 4103
a 4389 4390 4103
a 4390 4391 4103
a 4391 4392 4103
a 4392 4393 4103
a 4393 4394 4103
a 4394 4395 4103
a 4395 4396 4103
a 4396 4397 4103
a 4397 4398 4103
a 4398 4399 4103
a 4399 4400 4103
a 4400 4401 4103
a 4401 4402 4103
a 4402 4403 4103
a 4403 4404 4103
a 4404 4405 4103
a 4405 4406 4103
a 4406 4407 4103
a 4407 4408 4103
a 4408 4409 4103
a 4409 4410 4103
a 4410 4411 4103
a 4411 4412 4103
a 4412 4413 4103
a 4413 4414 4103
a 4414 4415 4103
a 4415 4416 4103
a 4416 4417 4103
a 4417 4418 4103
a 4418 4419 4103
a 4419 4420 4103
a 4420 4421 4103
a 4421 4422 4103
a 4422 4423 4103
a 4423 4424 4103
a 4424 4425 4103
a 4425 4426 4103
a 4426 4427 4103
a 4427 4428 4103
a 4428 4429 4103
a 4429 4430 4103
a 4430 4431 4103
a 4431 4432 4103
a 4432 4433 4103
a 4433 4434 4103
a 4434 4435 4103
a 4435 4436 4103
a 4436 4437 4103
a 4437 4438 4103
a 4438 4439 4103
a 4439 4440 4103
a 4440 4441 4103
a 4441 4442 4103
a 4442 4443 4103
a 4443 4444 4103
a 4444 4445 4103
a 4445 4446 4103
a 4446 4447 4103
a 4447 4448 4103
a 4448 4449 4103
a 4449 4450 4103
a 4450 4451 4103
a 4451 4452 4103
a 4452 4453 4103
a 4453 4454 4103
a 4454 4455 4103
a 4455 4456 4103
a 4456 4457 4103
a 4457 4458 4103
a 4458 4459 4103
a 4459 4460 4103
a 4460 4461 4103
a 4461 4462 4103
a 4462 4463 4103
a 4463 4464 4103
a 4464 4465 4103
a 4465 4466 4103
a 4466 4467 4103
a 4467 4468 4103
a 4468 4469 4103
a 4469 4470 4103
a 4470 4471 4103
a 4471 4472 4103
a 4472 4473 4103
a 4473 4474 4103
a 4474 4475 4103
a 4475 4476 4103
a 4476 4477 4103
a 4477 4478 4103
a 4478 4479 4103
a 4479 4480 4103
a 4480 4481 4103
a 4481 4482 4103
a 4482 4483 4103
a 4483 4484 4103
a 4484 4485 4103
a 4485 4486 4103
a 4486 4487 4103
a 4487 4488 4103
a 4488 4489 4103
a 4489 4490 4103
a 4490 4491 4103
a 4491 4492 4103
a 4492 4493 4103
a 4493 4494 4103
a 4494 4495 4103
a 4495 4496 4103
a 4496 4497 4103
a 4497 4498 4103
a 4498 4499 4103
a 4499 4500 4103
a 4500 4501 4103
a 4501 4502 4103
a 4502 4503 4103
a 4503 4504 4103
a 4504 4505 4103
a 4505 4506 4103
a 4506 4507 4103
a 4507 4508 4103
a 4508 4509 4103
a 4509 4510 4103
a 4510 4511 4103
a 4511 4512 4103
a 4512 4513 4103
a 4513 4514 4103
a 4514 4515 4103
a 4515 4516 4103
a 4516 4517 4103
a 4517 4518 4103
a 4518 4519 4103
a 4519 4520 4103
a 4520 4521 4103
a 4521 4522 4103
a 4522 4523 4103
a 4523 4524 4103
a 4524 4525 4103
a 4525 4526 4103
a 4526 4527 4103
a 4527 4528 4103
a 4528 4529 4103
a 4529 4530 4103
a 4530 4531 4103
a 4531 4532 4103
a 4532 4533 4103
a 4533 4534 4103
a 4534 4535 4103
a 4535 4536 4103
a 4536 4537 4103
a 4537 4538 4103
a 4538 4539 4103
a 4539 4540 4103
a 4540 4541 4103
a 4541 4542 4103
a 4542 4543 4103
a 4543 4544 4103
a 4544 4545 4103
a 4545 4546 4103
a 4546 4547 4103
a 4547 4548 4103
a 4548 4549 4103
a 4549 4550 4103
a 4550 4551 4103
a 4551 4552 4103
a 4552 4553 4103
a 4553 4554 4103
a 4554 4555 4103
a 4555 4556 4103
a 4556 4557 4103
a 4557 4558 4103
a 4558 4559 4103
a 4559 4560 4103
a 4560 4561 4103
a 4561 4562 4103
a 4562 4563 4103
a 4563 4564 4103
a 4564 4565 4103
a 4565 4566 4103
a 4566 4567 4103
a 4567 4568 4103
a 4568 4569 4103
a 4569 4570 4103
a 4570 4571 4103
a 4571 4572 4103
a 4572 4573 4103
a 4573 4574 4103
a 4574 4575 4103
a 4575 4576 4103
a 4576 4577 4103
a 4577 4578 4103
a 4578 4579 4103
a 4579 4580 4103
a 4580 4581 4103
a 4581 4582 4103
a 4582 4583 4103
a 4583 4584 4103
a 4584 4585 4103
a 4585 4586 4103
a 4586 4587 4103
a 4587 4588 4103
a 4588 4589 4103
a 4589 4590 4103
a 4590 4591 4103
a 4591 4592 4103
a 4592 4593 4103
a 4593 4594 4103
a 4594 4595 4103
a 4595 4596 4103
a 4596 4597 4103
a 4597 4598 4103
a 4598 4599 4103
a 4599 4600 4103
a 4600 4601 4103
a 4601 4602 4103
a 4602 4603 4103
a 4603 4604 4103
a 4604 4605 4103
a 4605 4606 4103
a 4606 4607 4103
a 4607 4608 4103
a 4608 4609 4103
a 4609 4610 4103
a 4610 4611 4103
a 4611 4612 4103
a 4612 4613 4103
a 4613 4614 4103
a 4614 4615 4103
a 4615 4616 4103
a 4616 4617 4103
a 4617 4618 4103
a 4618 4619 4103
a 4619 4620 4103
a 4620 4621 4103
a 4621 4622 4103
a 4622 4623 4103
a 4623 4624 4103
a 4624 4625 4103
a 4625 4626 4103
a 4626 4627 4103
a 4627 4628 4103
a 4628 4629 4103
a 4629 4630 4103
a 4630 4631 4103
a 4631 4632 4103
a 4632 4633 4103
a 4633 4634 4103
a 4634 4635 4103
a 4635 4636 4103
a 4636 4637 4103
a 4637 4638 4103
a 4638 4639 4103
a 4639 4640 4103
a 4640 4641 4103
a 4641 4642 4103
a 4642 4643 4103
a 4643 4644 4103
a 4644 4645 4103
a 4645 4646 4103
a 4646 4647 4103
a 4647 4648 4103
a 4648 4649 4103
a 4649 4650 4103
a 4650 4651 4103
a 4651 4652 4103
a 4652 4653 4103
a 4653 4654 4103
a 4654 4655 4103
a 4655 4656 4103
a 4656 4657 4103
a 4657 4658 4103
a 4658 4659 4103
a 4659 4660 4103
a 4660 4661 4103
a 4661 4662 4103
a 4662 4663 4103
a 4663 4664 4103
a 4664 4665 4103
a 4665 4666 4103
a 4666 4667 4103
a 4667 4668 4103
a 4668 4669 4103
a 4669 4670 4103
a 4670 4671 4103
a 4671 4672 4103
a 4672 4673 4103
a 4673 4674 4103
a 4674 4675 4103
a 4675 4676 4103
a 4676 4677 4103
a 4677 4678 4103
a 4678 4679 4103
a 4679 4680 4103
a 4680 4681 4103
a 4681 4682 4103
a 4682 4683 4103
a 4683 4684 4103
a 4684 4685 4103
a 4685 4686 4103
a 4686 4687 4103
a 4687 4688 4103
a 4688 4689 4103
a 4689 4690 4103
a 4690 4691 4103
a 4691 4692 4103
a 4692 4693 4103
a 4693 4694 4103
a 4694 4695 4103
a 4695 4696 4103
a 4696 4697 4103
a 4697 4698 4103
a 4698 4699 4103
a 4699 4700 4103
a 4700 4701 4103
a 4701 4702 4103
a 4702 4703 4103
a 4703 4704 4103
a 4704 4705 4103
a 4705 4706 4103
a 4706 4707 4103
a 4707 4708 4103
a 4708 4709 4103
a 4709 4710 4103
a 4710 4711 4103
a 4711 4712 4103
a 4712 4713 4103
a 4713 4714 4103
a 4714 4715 4103
a 4715 4716 4103
a 4716 4717 4103
a 4717 4718 4103
a 4718 4719 4103
a 4719 4720 4103
a 4720 4721 4103
a 4721 4722 4103
a 4722 4723 4103
a 4723 4724 4103
a 4724 4725 4103
a 4725 4726 4103
a 4726 4727 4103
a 4727 4728 4103
a 4728 4729 4103
a 4729 4730 4103
a 4730 4731 4103
a 4731 4732 4103
a 4732 4733 4103
a 4733 4734 4103
a 4734 4735 4103
a 4735 4736 4103
a 4736 4737 4103
a 4737 4738 4103
a 4738 4739 4103
a 4739 4740 4103
a 4740 4741 4103
a 4741 4742 4103
a 4742 4743 4103
a 4743 4744 4103
a 4744 4745 4103
a 4745 4746 4103
a 4746 4747 4103
a 4747 4748 4103
a 4748 4749 4103
a 4749 4750 4103
a 4750 4751 4103
a 4751 4752 4103
a 4752 4753 4103
a 4753 4754 4103
a 4754 4755 4103
a 4755 4756 4103
a 4756 4757 4103
a 4757 4758 4103
a 4758 4759 4103
a 4759 4760 4103
a 4760 4761 4103
a 4761 4762 4103
a 4762 4763 4103
a 4763 4764 4103
a 4764 4765 4103
a 4765 4766 4103
a 4766 4767 4103
a 4767 4768 4103
a 4768 4769 4103
a 4769 4770 4103
a 4770 4771 4103
a 4771 4772 4103
a 4772 4773 4103
a 4773 4774 4103
a 4774 4775 4103
a 4775 4776 4103
a 4776 4777 4103
a 4777 4778 4103
a 4778 4779 4103
a 4779 4780 4103
a 4780 4781 4103
a 4781 4782 4103
a 4782 4783 4103
a 4783 4784 4103
a 4784 4785 4103
a 4785 4786 4103
a 4786 4787 4103
a 4787 4788 4103
a 4788 4789 4103
a 4789 4790 4103
a 4790 4791 4103
a 4791 4792 4103
a 4792 4793 4103
a 4793 4794 4103
a 4794 4795 4103
a 4795 4796 4103
a 4796 4797 4103
a 4797 4798 4103
a 4798 4799 4103
a 4799 4800 4103
a 4800 4801 4103
a 4801 4802 4103
a 4802 4803 4103
a 4803 4804 4103
a 4804 4805 4103
a 4805 4806 4103
a 4806 4807 4103
a 4807 4808 4103
a 4808 4809 4103
a 4809 4810 4103
a 4810 4811 4103
a 4811 4812 4103
a 4812 4813 4103
a 4813 4814 4103
a 4814 4815 4103
a 4815 4816 4103
a 4816 4817 4103
a 4817 4818 4103
a 4818 4819 4103
a 4819 4820 4103
a 4820 4821 4103
a 4821 4822 4103
a 4822 4823 4103
a 4823 4824 4103
a 4824 4825 4103
a 4825 4826 4103
a 4826 4827 4103
a 4827 4828 4103
a 4828 4829 4103
a 4829 4830 4103
a 4830 4831 4103
a 4831 4832 4103
a 4832 4833 4103
a 4833 4834 4103
a 4834 4835 4103
a 4835 4836 4103
a 4836 4837 4103
a 4837 4838 4103
a 4838 4839 4103
a 4839 4840 4103
a 4840 4841 4103
a 4841 4842 4103
a 4842 4843 4103
a 4843 4844 4103
a 4844 4845 4103
a 4845 4846 4103
a 4846 4847 4103
a 4847 4848 4103
a 4848 4849 4103
a 4849 4850 4103
a 4850 4851 4103
a 4851 4852 4103
a 4852 4853 4103
a 4853 4854 4103
a 4854 4855 4103
a 4855 4856 4103
a 4856 4857 4103
a 4857 4858 4103
a 4858 4859 4103
a 4859 4860 4103
a 4860 4861 4103
a 4861 4862 4103
a 4862 4863 4103
a 4863 4864 4103
a 4864 4865 4103
a 4865 4866 4103
a 4866 4867 4103
a 4867 4868 4103
a 4868 4869 4103
a 4869 4870 4103
a 4870 4871 4103
a 4871 4872 4103
a 4872 4873 4103
a 4873 4874 4103
a 4874 4875 4103
a 4875 4876 4103
a 4876 4877 4103
a 4877 4878 4103
a 4878 4879 4103
a 4879 4880 4103
a 4880 4881 4103
a 4881 4882 4103
a 4882 4883 4103
a 4883 4884 4103
a 4884 4885 4103
a 4885 4886 4103
a 4886 4887 4103
a 4887 4888 4103
a 4888 4889 4103
a 4889 4890 4103
a 4890 4891 4103
a 4891 4892 4103
a 4892 4893 4103
a 4893 4894 4103
a 4894 4895 4103
a 4895 4896 4103
a 4896 4897 4103
a 4897 4898 4103
a 4898 4899 4103
a 4899 4900 4103
a 4900 4901 4103
a 4901 4902 4103
a 4902 4903 4103
a 4903 4904 4103
a 4904 4905 4103
a 4905 4906 4103
a 4906 4907 4103
a 4907 4908 4103
a 4908 4909 4103
a 4909 4910 4103
a 4910 4911 4103
a 4911 4912 4103
a 4912 4913 4103
a 4913 4914 4103
a 4914 4915 4103
a 4915 4916 4103
a 4916 4917 4103
a 4917 4918 4103
a 4918 4919 4103
a 4919 4920 4103
a 4920 4921 4103
a 4921 4922 4103
a 4922 4923 4103
a 4923 4924 4103
a 4924 4925 4103
a 4925 4926 4103
a 4926 4927 4103
a 4927 4928 4103
a 4928 4929 4103
a 4929 4930 4103
a 4930 4931 4103
a 4931 4932 4103
a 4932 4933 4103
a 4933 4934 4103
a 4934 4935 4103
a 4935 4936 4103
a 4936 4937 4103
a 4937 4938 4103
a 4938 4939 4103
a 4939 4940 4103
a 4940 4941 4103
a 4941 4942 4103
a 4942 4943 4103
a 4943 4944 4103
a 4944 4945 4103
a 4945 4946 4103
a 4946 4947 4103
a 4947 4948 4103
a 4948 4949 4103
a 4949 4950 4103
a 4950 4951 4103
a 4951 4952 4103
a 4952 4953 4103
a 4953 4954 4103
a 4954 4955 4103
a 4955 4956 4103
a 4956 4957 4103
a 4957 4958 4103
a 4958 4959 4103
a 4959 4960 4103
a 4960 4961 4103
a 4961 4962 4103
a 4962 4963 4103
a 4963 4964 4103
a 4964 4965 4103
a 4965 4966 4103
a 4966 4967 4103
a 4967 4968 4103
a 4968 4969 4103
a 4969 4970 4103
a 4970 4971 4103
a 4971 4972 4103
a 4972 4973 4103
a 4973 4974 4103
a 4974 4975 4103
a 4975 4976 4103
a 4976 4977 4103
a 4977 4978 4103
a 4978 4979 4103
a 4979 4980 4103
a 4980 4981 4103
a 4981 4982 4103
a 4982 4983 4103
a 4983 4984 4103
a 4984 4985 4103
a 4985 4986 4103
a 4986 4987 4103
a 4987 4988 4103
a 4988 4989 4103
a 4989 4990 4103
a 4990 4991 4103
a 4991 4992 4103
a 4992 4993 4103
a 4993 4994 4103
a 4994 4995 4103
a 4995 4996 4103
a 4996 4997 4103
a 4997 4998 4103
a 4998 4999 4103
a 4999 5000 4103
a 5000 5001 4103
a 5001 5002 4103
a 5002 5003 4103
a 5003 5004 4103
a 5004 5005 4103
a 5005 5006 4103
a 5006 5007 4103
a 5007 5008 4103
a 5008 5009 4103
a 5009 5010 4103
a 5010 5011 4103
a 5011 5012 4103
a 5012 5013 4103
a 5013 5014 4103
a 5014 5015 4103
a 5015 5016 4103
a 5016 5017 4103
a 5017 5018 4103
a 5018 5019 4103
a 5019 5020 4103
a 5020 5021 4103
a 5021 5022 4103
a 5022 5023 4103
a 5023 5024 4103
a 5024 5025 4103
a 5025 5026 4103
a 5026 5027 4103
a 5027 5028 4103
a 5028 5029 4103
a 5029 5030 4103
a 5030 5031 4103
a 5031 5032 4103
a 5032 5033 4103
a 5033 5034 4103
a 5034 5035 4103
a 5035 5036 4103
a 5036 5037 4103
a 5037 5038 4103
a 5038 5039 4103
a 5039 5040 4103
a 5040 5041 4103
a 5041 5042 4103
a 5042 5043 4103
a 5043 5044 4103
a 5044 5045 4103
a 5045 5046 4103
a 5046 5047 4103
a 5047 5048 4103
a 5048 5049 4103
a 5049 5050 4103
a 5050 5051 4103
a 5051 5052 4103
a 5052 5053 4103
a 5053 5054 4103
a 5054 5055 4103
a 5055 5056 4103
a 5056 5057 4103
a 5057 5058 4103
a 5058 5059 4103
a 5059 5060 4103
a 5060 5061 4103
a 5061 5062 4103
a 5062 5063 4103
a 5063 5064 4103
a 5064 5065 4103
a 5065 5066 4103
a 5066 5067 4103
a 5067 5068 4103
a 5068 5069 4103
a 5069 5070 4103
a 5070 5071 4103
a 5071 5072 4103
a 5072 5073 4103
a 5073 5074 4103
a 5074 5075 4103
a 5075 5076 4103
a 5076 5077 4103
a 5077 5078 4103
a 5078 5079 4103
a 5079 5080 4103
a 5080 5081 4103
a 5081 5082 4103
a 5082 5083 4103
a 5083 5084 4103
a 5084 5085 4103
a 5085 5086 4103
a 5086 5087 4103
a 5087 5088 4103
a 5088 5089 4103
a 5089 5090 4103
a 5090 5091 4103
a 5091 5092 4103
a 5092 5093 4103
a 5093 5094 4103
a 5094 5095 4103
a 5095 5096 4103
a 5096 5097 4103
a 5097 5098 4103
a 5098 5099 4103
a 5099 5100 4103
a 5100 5101 4103
a 5101 5102 4103
a 5102 5103 4103
a 5103 5104 4103
a 5104 5105 4103
a 5105 5106 4103
a 5106 5107 4103
a 5107 5108 4103
a 5108 5109 4103
a 5109 5110 4103
a 5110 5111 4103
a 5111 5112 4103
a 5112 5113 4103
a 5113 5114 4103
a 5114 5115 4103
a 5115 5116 4103
a 5116 5117 4103
a 5117 5118 4103
a 5118 5119 4103
a 5119 5120 4103
a 5120 5121 4103
a 5121 5122 4103
a 5122 5123 4103
a 5123 5124 4103
a 5124 5125 4103
a 5125 5126 4103
a 5126 5127 4103
a 5127 5128 4103
a 5128 5129 4103
a 5129 5130 4103
a 5130 5131 4103
a 5131 5132 4103
a 5132 5133 4103
a 5133 5134 4103
a 5134 5135 4103
a 5135 5136 4103
a 5136 5137 4103
a 5137 5138 4103
a 5138 5139 4103
a 5139 5140 4103
a 5140 5141 4103
a 5141 5142 4103
a 5142 5143 4103
a 5143 5144 4103
a 5144 5145 4103
a 5145 5146 4103
a 5146 5147 4103
a 5147 5148 4103
a 5148 5149 4103
a 5149 5150 4103
a 5150 5151 4103
a 5151 5152 4103
a 5152 5153 4103
a 5153 5154 4103
a 5154 5155 4103
a 5155 5156 4103
a 5156 5157 4103
a 5157 5158 4103
a 5158 5159 4103
a 5159 5160 4103
a 5160 5161 4103
a 5161 5162 4103
a 5162 5163 4103
a 5163 5164 4103
a 5164 5165 4103
a 5165 5166 4103
a 5166 5167 4103
a 5167 5168 4103
a 5168 5169 4103
a 5169 5170 4103
a 5170 5171 4103
a 5171 5172 4103
a 5172 5173 4103
a 5173 5174 4103
a 5174 5175 4103
a 5175 5176 4103
a 5176 5177 4103
a 5177 5178 4103
a 5178 5179 4103
a 5179 5180 4103
a 5180 5181 4103
a 5181 5182 4103
a 5182 5183 4103
a 5183 5184 4103
a 5184 5185 4103
a 5185 5186 4103
a 5186 5187 4103
a 5187 5188 4103
a 5188 5189 4103
a 5189 5190 4103
a 5190 5191 4103
a 5191 5192 4103
a 5192 5193 4103
a 5193 5194 4103
a 5194 5195 4103
a 5195 5196 4103
a 5196 5197 4103
a 5197 5198 4103
a 5198 5199 4103
a 5199 5200 4103
a 5200 5201 4103
a 5201 5202 4103
a 5202 5203 4103
a 5203 5204 4103
a 5204 5205 4103
a 5205 5206 4103
a 5206 5207 4103
a 5207 5208 4103
a 5208 5209 4103
a 5209 5210 4103
a 5210 5211 4103
a 5211 5212 4103
a 5212 5213 4103
a 5213 5214 4103
a 5214 5215 4103
a 5215 5216 4103
a 5216 5217 4103
a 5217 5218 4103
a 5218 5219 4103
a 5219 5220 4103
a 5220 5221 4103
a 5221 5222 4103
a 5222 5223 4103
a 5223 5224 4103
a 5224 5225 4103
a 5225 5226 4103
a 5226 5227 4103
a 5227 5228 4103
a 5228 5229 4103
a 5229 5230 4103
a 5230 5231 4103
a 5231 5232 4103
a 5232 5233 4103
a 5233 5234 4103
a 5234 5235 4103
a 5235 5236 4103
a 5236 5237 4103
a 5237 5238 4103
a 5238 5239 4103
a 5239 5240 4103
a 5240 5241 4103
a 5241 5242 4103
a 5242 5243 4103
a 5243 5244 4103
a 5244 5245 4103
a 5245 5246 4103
a 5246 5247 4103
a 5247 5248 4103
a 5248 5249 4103
a 5249 5250 4103
a 5250 5251 4103
a 5251 5252 4103
a 5252 5253 4103
a 5253 5254 4103
a 5254 5255 4103
a 5255 5256 4103
a 5256 5257 4103
a 5257 5258 4103
a 5258 5259 4103
a 5259 5260 4103
a 5260 5261 4103
a 5261 5262 4103
a 5262 5263 4103
a 5263 5264 4103
a 5264 5265 4103
a 5265 5266 4103
a 5266 5267 4103
a 5267 5268 4103
a 5268 5269 4103
a 5269 5270 4103
a 5270 5271 4103
a 5271 5272 4103
a 5272 5273 4103
a 5273 5274 4103
a 5274 5275 4103
a 5275 5276 4103
a 5276 5277 4103
a 5277 5278 4103
a 5278 5279 4103
a 5279 5280 4103
a 5280 5281 4103
a 5281 5282 4103
a 5282 5283 4103
a 5283 5284 4103
a 5284 5285 4103
a 5285 5286 4103
a 5286 5287 4103
a 5287 5288 4103
a 5288 5289 4103
a 5289 5290 4103
a 5290 5291 4103
a 5291 5292 4103
a 5292 5293 4103
a 5293 5294 4103
a 5294 5295 4103
a 5295 5296 4103
a 5296 5297 4103
a 5297 5298 4103
a 5298 5299 4103
a 5299 5300 4103
a 5300 5301 4103
a 5301 5302 4103
a 5302 5303 4103
a 5303 5304 4103
a 5304 5305 4103
a 5305 5306 4103
a 5306 5307 4103
a 5307 5308 4103
a 5308 5309 4103
a 5309 5310 4103
a 5310 5311 4103
a 5311 5312 4103
a 5312 5313 4103
a 5313 5314 4103
a 5314 5315 4103
a 5315 5316 4103
a 5316 5317 4103
a 5317 5318 4103
a 5318 5319 4103
a 5319 5320 4103
a 5320 5321 4103
a 5321 5322 4103
a 5322 5323 4103
a 5323 5324 4103
a 5324 5325 4103
a 5325 5326 4103
a 5326 5327 4103
a 5327 5328 4103
a 5328 5329 4103
a 5329 5330 4103
a 5330 5331 4103
a 5331 5332 4103
a 5332 5333 4103
a 5333 5334 4103
a 5334 5335 4103
a 5335 5336 4103
a 5336 5337 4103
a 5337 5338 4103
a 5338 5339 4103
a 5339 5340 4103
a 5340 5341 4103
a 5341 5342 4103
a 5342 5343 4103
a 5343 5344 4103
a 5344 5345 4103
a 5345 5346 4103
a 5346 5347 4103
a 5347 5348 4103
a 5348 5349 4103
a 5349 5350 4103
a 5350 5351 4103
a 5351 5352 4103
a 5352 5353 4103
a 5353 5354 4103
a 5354 5355 4103
a 5355 5356 4103
a 5356 5357 4103
a 5357 5358 4103
a 5358 5359 4103
a 5359 5360 4103
a 5360 5361 4103
a 5361 5362 4103
a 5362 5363 4103
a 5363 5364 4103
a 5364 5365 4103
a 5365 5366 4103
a 5366 5367 4103
a 5367 5368 4103
a 5368 5369 4103
a 5369 5370 4103
a 5370 5371 4103
a 5371 5372 4103
a 5372 5373 4103
a 5373 5374 4103
a 5374 5375 4103
a 5375 5376 4103
a 5376 5377 4103
a 5377 5378 4103
a 5378 5379 4103
a 5379 5380 4103
a 5380 5381 4103
a 5381 5382 4103
a 5382 5383 4103
a 5383 5384 4103
a 5384 5385 4103
a 5385 5386 4103
a 5386 5387 4103
a 5387 5388 4103
a 5388 5389 4103
a 5389 5390 4103
a 5390 5391 4103
a 5391 5392 4103
a 5392 5393 4103
a 5393 5394 4103
a 5394 5395 4103
a 5395 5396 4103
a 5396 5397 4103
a 5397 5398 4103
a 5398 5399 4103
a 5399 5400 4103
a 5400 5401 4103
a 5401 5402 4103
a 5402 5403 4103
a 5403 5404 4103
a 5404 5405 4103
a 5405 5406 4103
a 5406 5407 4103
a 5407 5408 4103
a 5408 5409 4103
a 5409 5410 4103
a 5410 5411 4103
a 5411 5412 4103
a 5412 5413 4103
a 5413 5414 4103
a 5414 5415 4103
a 5415 5416 4103
a 5416 5417 4103
a 5417 5418 4103
a 5418 5419 4103
a 5419 5420 4103
a 5420 5421 4103
a 5421 5422 4103
a 5422 5423 4103
a 5423 5424 4103
a 5424 5425 4103
a 5425 5426 4103
a 5426 5427 4103
a 5427 5428 4103
a 5428 5429 4103
a 5429 5430 4103
a 5430 5431 4103
a 5431 5432 4103
a 5432 5433 4103
a 5433 5434 4103
a 5434 5435 4103
a 5435 5436 4103
a 5436 5437 4103
a 5437 5438 4103
a 5438 5439 4103
a 5439 5440 4103
a 5440 5441 4103
a 5441 5442 4103
a 5442 5443 4103
a 5443 5444 4103
a 5444 5445 4103
a 5445 5446 4103
a 5446 5447 4103
a 5447 5448 4103
a 5448 5449 4103
a 5449 5450 4103
a 5450 5451 4103
a 5451 5452 4103
a 5452 5453 4103
a 5453 5454 4103
a 5454 5455 4103
a 5455 5456 4103
a 5456 5457 4103
a 5457 5458 4103
a 5458 5459 4103
a 5459 5460 4103
a 5460 5461 4103
a 5461 5462 4103
a 5462 5463 4103
a 5463 5464 4103
a 5464 5465 4103
a 5465 5466 4103
a 5466 5467 4103
a 5467 5468 4103
a 5468 5469 4103
a 5469 5470 4103
a 5470 5471 4103
a 5471 5472 4103
a 5472 5473 4103
a 5473 5474 4103
a 5474 5475 4103
a 5475 5476 4103
a 5476 5477 4103
a 5477 5478 4103
a 5478 5479 4103
a 5479 5480 4103
a 5480 5481 4103
a 5481 5482 4103
a 5482 5483 4103
a 5483 5484 4103
a 5484 5485 4103
a 5485 5486 4103
a 5486 5487 4103
a 5487 5488 4103
a 5488 5489 4103
a 5489 5490 4103
a 5490 5491 4103
a 5491 5492 4103
a 5492 5493 4103
a 5493 5494 4103
a 5494 5495 4103
a 5495 5496 4103
a 5496 5497 4103
a 5497 5498 4103
a 5498 5499 4103
a 5499 5500 4103
a 5500 5501 4103
a 5501 5502 4103
a 5502 5503 4103
a 5503 5504 4103
a 5504 5505 4103
a 5505 5506 4103
a 5506 5507 4103
a 5507 5508 4103
a 5508 5509 4103
a 5509 5510 4103
a 5510 5511 4103
a 5511 5512 4103
a 5512 5513 4103
a 5513 5514 4103
a 5514 5515 4103
a 5515 5516 4103
a 5516 5517 4103
a 5517 5518 4103
a 5518 5519 4103
a 5519 5520 4103
a 5520 5521 4103
a 5521 5522 4103
a 5522 5523 4103
a 5523 5524 4103
a 5524 5525 4103
a 5525 5526 4103
a 5526 5527 4103
a 5527 5528 4103
a 5528 5529 4103
a 5529 5530 4103
a 5530 5531 4103
a 5531 5532 4103
a 5532 5533 4103
a 5533 5534 4103
a 5534 5535 4103
a 5535 5536 4103
a 5536 5537 4103
a 5537 5538 4103
a 5538 5539 4103
a 5539 5540 4103
a 5540 5541 4103
a 5541 5542 4103
a 5542 5543 4103
a 5543 5544 4103
a 5544 5545 4103
a 5545 5546 4103
a 5546 5547 4103
a 5547 5548 4103
a 5548 5549 4103
a 5549 5550 4103
a 5550 5551 4103
a 5551 5552 4103
a 5552 5553 4103
a 5553 5554 4103
a 5554 5555 4103
a 5555 5556 4103
a 5556 5557 4103
a 5557 5558 4103
a 5558 5559 4103
a 5559 5560 4103
a 5560 5561 4103
a 5561 5562 4103
a 5562 5563 4103
a 5563 5564 4103
a 5564 5565 4103
a 5565 5566 4103
a 5566 5567 4103
a 5567 5568 4103
a 5568 5569 4103
a 5569 5570 4103
a 5570 5571 4103
a 5571 5572 4103
a 5572 5573 4103
a 5573 5574 4103
a 5574 5575 4103
a 5575 5576 4103
a 5576 5577 4103
a 5577 5578 4103
a 5578 5579 4103
a 5579 5580 4103
a 5580 5581 4103
a 5581 5582 4103
a 5582 5583 4103
a 5583 5584 4103
a 5584 5585 4103
a 5585 5586 4103
a 5586 5587 4103
a 5587 5588 4103
a 5588 5589 4103
a 5589 5590 4103
a 5590 5591 4103
a 5591 5592 4103
a 5592 5593 4103
a 5593 5594 4103
a 5594 5595 4103
a 5595 5596 4103
a 5596 5597 4103
a 5597 5598 4103
a 5598 5599 4103
a 5599 5600 4103
a 5600 5601 4103
a 5601 5602 4103
a 5602 5603 4103
a 5603 5604 4103
a 5604 5605 4103
a 5605 5606 4103
a 5606 5607 4103
a 5607 5608 4103
a 5608 5609 4103
a 5609 5610 4103
a 5610 5611 4103
a 5611 5612 4103
a 5612 5613 4103
a 5613 5614 4103
a 5614 5615 4103
a 5615 5616 4103
a 5616 5617 4103
a 5617 5618 4103
a 5618 5619 4103
a 5619 5620 4103
a 5620 5621 4103
a 5621 5622 4103
a 5622 5623 4103
a 5623 5624 4103
a 5624 5625 4103
a 5625 5626 4103
a 5626 5627 4103
a 5627 5628 4103
a 5628 5629 4103
a 5629 5630 4103
a 5630 5631 4103
a 5631 5632 4103
a 5632 5633 4103
a 5633 5634 4103
a 5634 5635 4103
a 5635 5636 4103
a 5636 5637 4103
a 5637 5638 4103
a 5638 5639 4103
a 5639 5640 4103
a 5640 5641 4103
a 5641 5642 4103
a 5642 5643 4103
a 5643 5644 4103
a 5644 5645 4103
a 5645 5646 4103
a 5646 5647 4103
a 5647 5648 4103
a 5648 5649 4103
a 5649 5650 4103
a 5650 5651 4103
a 5651 5652 4103
a 5652 5653 4103
a 5653 5654 4103
a 5654 5655 4103
a 5655 5656 4103
a 5656 5657 4103
a 5657 5658 4103
a 5658 5659 4103
a 5659 5660 4103
a 5660 5661 4103
a 5661 5662 4103
a 5662 5663 4103
a 5663 5664 4103
a 5664 5665 4103
a 5665 5666 4103
a 5666 5667 4103
a 5667 5668 4103
a 5668 5669 4103
a 5669 5670 4103
a 5670 5671 4103
a 5671 5672 4103
a 5672 5673 4103
a 5673 5674 4103
a 5674 5675 4103
a 5675 5676 4103
a 5676 5677 4103
a 5677 5678 4103
a 5678 5679 4103
a 5679 5680 4103
a 5680 5681 4103
a 5681 5682 4103
a 5682 5683 4103
a 5683 5684 4103
a 5684 5685 4103
a 5685 5686 4103
a 5686 5687 4103
a 5687 5688 4103
a 5688 5689 4103
a 5689 5690 4103
a 5690 5691 4103
a 5691 5692 4103
a 5692 5693 4103
a 5693 5694 4103
a 5694 5695 4103
a 5695 5696 4103
a 5696 5697 4103
a 5697 5698 4103
a 5698 5699 4103
a 5699 5700 4103
a 5700 5701 4103
a 5701 5702 4103
a 5702 5703 4103
a 5703 5704 4103
a 5704 5705 4103
a 5705 5706 4103
a 5706 5707 4103
a 5707 5708 4103
a 5708 5709 4103
a 5709 5710 4103
a 5710 5711 4103
a 5711 5712 4103
a 5712 5713 4103
a 5713 5714 4103
a 5714 5715 4103
a 5715 5716 4103
a 5716 5717 4103
a 5717 5718 4103
a 5718 5719 4103
a 5719 5720 4103
a 5720 5721 4103
a 5721 5722 4103
a 5722 5723 4103
a 5723 5724 4103
a 5724 5725 4103
a 5725 5726 4103
a 5726 5727 4103
a 5727 5728 4103
a 5728 5729 4103
a 5729 5730 4103
a 5730 5731 4103
a 5731 5732 4103
a 5732 5733 4103
a 5733 5734 4103
a 5734 5735 4103
a 5735 5736 4103
a 5736 5737 4103
a 5737 5738 4103
a 5738 5739 4103
a 5739 5740 4103
a 5740 5741 4103
a 5741 5742 4103
a 5742 5743 4103
a 5743 5744 4103
a 5744 5745 4103
a 5745 5746 4103
a 5746 5747 4103
a 5747 5748 4103
a 5748 5749 4103
a 5749 5750 4103
a 5750 5751 4103
a 5751 5752 4103
a 5752 5753 4103
a 5753 5754 4103
a 5754 5755 4103
a 5755 5756 4103
a 5756 5757 4103
a 5757 5758 4103
a 5758 5759 4103
a 5759 5760 4103
a 5760 5761 4103
a 5761 5762 4103
a 5762 5763 4103
a 5763 5764 4103
a 5764 5765 4103
a 5765 5766 4103
a 5766 5767 4103
a 5767 5768 4103
a 5768 5769 4103
a 5769 5770 4103
a 5770 5771 4103
a 5771 5772 4103
a 5772 5773 4103
a 5773 5774 4103
a 5774 5775 4103
a 5775 5776 4103
a 5776 5777 4103
a 5777 5778 4103
a 5778 5779 4103
a 5779 5780 4103
a 5780 5781 4103
a 5781 5782 4103
a 5782 5783 4103
a 5783 5784 4103
a 5784 5785 4103
a 5785 5786 4103
a 5786 5787 4103
a 5787 5788 4103
a 5788 5789 4103
a 5789 5790 4103
a 5790 5791 4103
a 5791 5792 4103
a 5792 5793 4103
a 5793 5794 4103
a 5794 5795 4103
a 5795 5796 4103
a 5796 5797 4103
a 5797 5798 4103
a 5798 5799 4103
a 5799 5800 4103
a 5800 5801 4103
a 5801 5802 4103
a 5802 5803 4103
a 5803 5804 4103
a 5804 5805 4103
a 5805 5806 4103
a 5806 5807 4103
a 5807 5808 4103
a 5808 5809 4103
a 5809 5810 4103
a 5810 5811 4103
a 5811 5812 4103
a 5812 5813 4103
a 5813 5814 4103
a 5814 5815 4103
a 5815 5816 4103
a 5816 5817 4103
a 5817 5818 4103
a 5818 5819 4103
a 5819 5820 4103
a 5820 5821 4103
a 5821 5822 4103
a 5822 5823 4103
a 5823 5824 4103
a 5824 5825 4103
a 5825 5826 4103
a 5826 5827 4103
a 5827 5828 4103
a 5828 5829 4103
a 5829 5830 4103
a 5830 5831 4103
a 5831 5832 4103
a 5832 5833 4103
a 5833 5834 4103
a 5834 5835 4103
a 5835 5836 4103
a 5836 5837 4103
a 5837 5838 4103
a 5838 5839 4103
a 5839 5840 4103
a 5840 5841 4103
a 5841 5842 4103
a 5842 5843 4103
a 5843 5844 4103
a 5844 5845 4103
a 5845 5846 4103
a 5846 5847 4103
a 5847 5848 4103
a 5848 5849 4103
a 5849 5850 4103
a 5850 5851 4103
a 5851 5852 4103
a 5852 5853 4103
a 5853 5854 4103
a 5854 5855 4103
a 5855 5856 4103
a 5856 5857 4103
a 5857 5858 4103
a 5858 5859 4103
a 5859 5860 4103
a 5860 5861 4103
a 5861 5862 4103
a 5862 5863 4103
a 5863 5864 4103
a 5864 5865 4103
a 5865 5866 4103
a 5866 5867 4103
a 5867 5868 4103
a 5868 5869 4103
a 5869 5870 4103
a 5870 5871 4103
a 5871 5872 4103
a 5872 5873 4103
a 5873 5874 4103
a 5874 5875 4103
a 5875 5876 4103
a 5876 5877 4103
a 5877 5878 4103
a 5878 5879 4103
a 5879 5880 4103
a 5880 5881 4103
a 5881 5882 4103
a 5882 5883 4103
a 5883 5884 4103
a 5884 5885 4103
a 5885 5886 4103
a 5886 5887 4103
a 5887 5888 4103
a 5888 5889 4103
a 5889 5890 4103
a 5890 5891 4103
a 5891 5892 4103
a 5892 5893 4103
a 5893 5894 4103
a 5894 5895 4103
a 5895 5896 4103
a 5896 5897 4103
a 5897 5898 4103
a 5898 5899 4103
a 5899 5900 4103
a 5900 5901 4103
a 5901 5902 4103
a 5902 5903 4103
a 5903 5904 4103
a 5904 5905 4103
a 5905 5906 4103
a 5906 5907 4103
a 5907 5908 4103
a 5908 5909 4103
a 5909 5910 4103
a 5910 5911 4103
a 5911 5912 4103
a 5912 5913 4103
a 5913 5914 4103
a 5914 5915 4103
a 5915 5916 4103
a 5916 5917 4103
a 5917 5918 4103
a 5918 5919 4103
a 5919 5920 4103
a 5920 5921 4103
a 5921 5922 4103
a 5922 5923 4103
a 5923 5924 4103
a 5924 5925 4103
a 5925 5926 4103
a 5926 5927 4103
a 5927 5928 4103
a 5928 5929 4103
a 5929 5930 4103
a 5930 5931 4103
a 5931 5932 4103
a 5932 5933 4103
a 5933 5934 4103
a 5934 5935 4103
a 5935 5936 4103
a 5936 5937 4103
a 5937 5938 4103
a 5938 5939 4103
a 5939 5940 4103
a 5940 5941 4103
a 5941 5942 4103
a 5942 5943 4103
a 5943 5944 4103
a 5944 5945 4103
a 5945 5946 4103
a 5946 5947 4103
a 5947 5948 4103
a 5948 5949 4103
a 5949 5950 4103
a 5950 5951 4103
a 5951 5952 4103
a 5952 5953 4103
a 5953 5954 4103
a 5954 5955 4103
a 5955 5956 4103
a 5956 5957 4103
a 5957 5958 4103
a 5958 5959 4103
a 5959 5960 4103
a 5960 5961 4103
a 5961 5962 4103
a 5962 5963 4103
a 5963 5964 4103
a 5964 5965 4103
a 5965 5966 4103
a 5966 5967 4103
a 5967 5968 4103
a 5968 5969 4103
a 5969 5970 4103
a 5970 5971 4103
a 5971 5972 4103
a 5972 5973 4103
a 5973 5974 4103
a 5974 5975 4103
a 5975 5976 4103
a 5976 5977 4103
a 5977 5978 4103
a 5978 5979 4103
a 5979 5980 4103
a 5980 5981 4103
a 5981 5982 4103
a 5982 5983 4103
a 5983 5984 4103
a 5984 5985 4103
a 5985 5986 4103
a 5986 5987 4103
a 5987 5988 4103
a 5988 5989 4103
a 5989 5990 4103
a 5990 5991 4103
a 5991 5992 4103
a 5992 5993 4103
a 5993 5994 4103
a 5994 5995 4103
a 5995 5996 4103
a 5996 5997 4103
a 5997 5998 4103
a 5998 5999 4103
a 5999 6000 4103
a 6000 6001 4103
a 6001 6002 4103
a 6002 6003 4103
a 6003 6004 4103
a 6004 6005 4103
a 6005 6006 4103
a 6006 6007 4103
a 6007 6008 4103
a 6008 6009 4103
a 6009 6010 4103
a 6010 6011 4103
a 6011 6012 4103
a 6012 6013 4103
a 6013 6014 4103
a 6014 6015 4103
a 6015 6016 4103
a 6016 6017 4103
a 6017 6018 4103
a 6018 6019 4103
a 6019 6020 4103
a 6020 6021 4103
a 6021 6022 4103
a 6022 6023 4103
a 6023 6024 4103
a 6024 6025 4103
a 6025 6026 4103
a 6026 6027 4103
a 6027 6028 4103
a 6028 6029 4103
a 6029 6030 4103
a 6030 6031 4103
a 6031 6032 4103
a 6032 6033 4103
a 6033 6034 4103
a 6034 6035 4103
a 6035 6036 4103
a 6036 6037 4103
a 6037 6038 4103
a 6038 6039 4103
a 6039 6040 4103
a 6040 6041 4103
a 6041 6042 4103
a 6042 6043 4103
a 6043 6044 4103
a 6044 6045 4103
a 6045 6046 4103
a 6046 6047 4103
a 6047 6048 4103
a 6048 6049 4103
a 6049 6050 4103
a 6050 6051 4103
a 6051 6052 4103
a 6052 6053 4103
a 6053 6054 4103
a 6054 6055 4103
a 6055 6056 4103
a 6056 6057 4103
a 6057 6058 4103
a 6058 6059 4103
a 6059 6060 4103
a 6060 6061 4103
a 6061 6062 4103
a 6062 6063 4103
a 6063 6064 4103
a 6064 6065 4103
a 6065 6066 4103
a 6066 6067 4103
a 6067 6068 4103
a 6068 6069 4103
a 6069 6070 4103
a 6070 6071 4103
a 6071 6072 4103
a 6072 6073 4103
a 6073 6074 4103
a 6074 6075 4103
a 6075 6076 4103
a 6076 6077 4103
a 6077 6078 4103
a 6078 6079 4103
a 6079 6080 4103
a 6080 6081 4103
a 6081 6082 4103
a 6082 6083 4103
a 6083 6084 4103
a 6084 6085 4103
a 6085 6086 4103
a 6086 6087 4103
a 6087 6088 4103
a 6088 6089 4103
a 6089 6090 4103
a 6090 6091 4103
a 6091 6092 4103
a 6092 6093 4103
a 6093 6094 4103
a 6094 6095 4103
a 6095 6096 4103
a 6096 6097 4103
a 6097 6098 4103
a 6098 6099 4103
a 6099 6100 4103
a 6100 6101 4103
a 6101 6102 4103
a 6102 6103 4103
a 6103 6104 4103
a 6104 6105 4103
a 6105 6106 4103
a 6106 6107 4103
a 6107 6108 4103
a 6108 6109 4103
a 6109 6110 4103
a 6110 6111 4103
a 6111 6112 4103
a 6112 6113 4103
a 6113 6114 4103
a 6114 6115 4103
a 6115 6116 4103
a 6116 6117 4103
a 6117 6118 4103
a 6118 6119 4103
a 6119 6120 4103
a 6120 6121 4103
a 6121 6122 4103
a 6122 6123 4103
a 6123 6124 4103
a 6124 6125 4103
a 6125 6126 4103
a 6126 6127 4103
a 6127 6128 4103
a 6128 6129 4103
a 6129 6130 4103
a 6130 6131 4103
a 6131 6132 4103
a 6132 6133 4103
a 6133 6134 4103
a 6134 6135 4103
a 6135 6136 4103
a 6136 6137 4103
a 6137 6138 4103
a 6138 6139 4103
a 6139 6140 4103
a 6140 6141 4103
a 6141 6142 4103
a 6142 6143 4103
a 6143 6144 4103
a 6144 6145 4103
a 6145 6146 4103
a 6146 6147 4103
a 6147 6148 4103
a 6148 6149 4103
a 6149 6150 4103
a 6150 6151 4103
a 6151 6152 4103
a 6152 6153 4103
a 6153 6154 4103
a 6154 6155 4103
a 6155 6156 4103
a 6156 6157 4103
a 6157 6158 4103
a 6158 6159 4103
a 6159 6160 4103
a 6160 6161 4103
a 6161 6162 4103
a 6162 6163 4103
a 6163 6164 4103
a 6164 6165 4103
a 6165 6166 4103
a 6166 6167 4103
a 6167 6168 4103
a 6168 6169 4103
a 6169 6170 4103
a 6170 6171 4103
a 6171 6172 4103
a 6172 6173 4103
a 6173 6174 4103
a 6174 6175 4103
a 6175 6176 4103
a 6176 6177 4103
a 6177 6178 4103
a 6178 6179 4103
a 6179 6180 4103
a 6180 6181 4103
a 6181 6182 4103
a 6182 6183 4103
a 6183 6184 4103
a 6184 6185 4103
a 6185 6186 4103
a 6186 6187 4103
a 6187 6188 4103
a 6188 6189 4103
a 6189 6190 4103
a 6190 6191 4103
a 6191 6192 4103
a 6192 6193 4103
a 6193 6194 4103
a 6194 6195 4103
a 6195 6196 4103
a 6196 6197 4103
a 6197 6198 4103
a 6198 6199 4103
a 6199 6200 4103
a 6200 6201 4103
a 6201 6202 4103
a 6202 6203 4103
a 6203 6204 4103
a 6204 6205 4103
a 6205 6206 4103
a 6206 6207 4103
a 6207 6208 4103
a 6208 6209 4103
a 6209 6210 4103
a 6210 6211 4103
a 6211 6212 4103
a 6212 6213 4103
a 6213 6214 4103
a 6214 6215 4103
a 6215 6216 4103
a 6216 6217 4103
a 6217 6218 4103
a 6218 6219 4103
a 6219 6220 4103
a 6220 6221 4103
a 6221 6222 4103
a 6222 6223 4103
a 6223 6224 4103
a 6224 6225 4103
a 6225 6226 4103
a 6226 6227 4103
a 6227 6228 4103
a 6228 6229 4103
a 6229 6230 4103
a 6230 6231 4103
a 6231 6232 4103
a 6232 6233 4103
a 6233 6234 4103
a 6234 6235 4103
a 6235 6236 4103
a 6236 6237 4103
a 6237 6238 4103
a 6238 6239 4103
a 6239 6240 4103
a 6240 6241 4103
a 6241 6242 4103
a 6242 6243 4103
a 6243 6244 4103
a 6244 6245 4103
a 6245 6246 4103
a 6246 6247 4103
a 6247 6248 4103
a 6248 6249 4103
a 6249 6250 4103
a 6250 6251 4103
a 6251 6252 4103
a 6252 6253 4103
a 6253 6254 4103
a 6254 6255 4103
a 6255 6256 4103
a 6256 6257 4103
a 6257 6258 4103
a 6258 6259 4103
a 6259 6260 4103
a 6260 6261 4103
a 6261 6262 4103
a 6262 6263 4103
a 6263 6264 4103
a 6264 6265 4103
a 6265 6266 4103
a 6266 6267 4103
a 6267 6268 4103
a 6268 6269 4103
a 6269 6270 4103
a 6270 6271 4103
a 6271 6272 4103
a 6272 6273 4103
a 6273 6274 4103
a 6274 6275 4103
a 6275 6276 4103
a 6276 6277 4103
a 6277 6278 4103
a 6278 6279 4103
a 6279 6280 4103
a 6280 6281 4103
a 6281 6282 4103
a 6282 6283 4103
a 6283 6284 4103
a 6284 6285 4103
a 6285 6286 4103
a 6286 6287 4103
a 6287 6288 4103
a 6288 6289 4103
a 6289 6290 4103
a 6290 6291 4103
a 6291 6292 4103
a 6292 6293 4103
a 6293 6294 4103
a 6294 6295 4103
a 6295 6296 4103
a 6296 6297 4103
a 6297 6298 4103
a 6298 6299 4103
a 6299 6300 4103
a 6300 6301 4103
a 6301 6302 4103
a 6302 6303 4103
a 6303 6304 4103
a 6304 6305 4103
a 6305 6306 4103
a 6306 6307 4103
a 6307 6308 4103
a 6308 6309 4103
a 6309 6310 4103
a 6310 6311 4103
a 6311 6312 4103
a 6312 6313 4103
a 6313 6314 4103
a 6314 6315 4103
a 6315 6316 4103
a 6316 6317 4103
a 6317 6318 4103
a 6318 6319 4103
a 6319 6320 4103
a 6320 6321 4103
a 6321 6322 4103
a 6322 6323 4103
a 6323 6324 4103
a 6324 6325 4103
a 6325 6326 4103
a 6326 6327 4103
a 6327 6328 4103
a 6328 6329 4103
a 6329 6330 4103
a 6330 6331 4103
a 6331 6332 4103
a 6332 6333 4103
a 6333 6334 4103
a 6334 6335 4103
a 6335 6336 4103
a 6336 6337 4103
a 6337 6338 4103
a 6338 6339 4103
a 6339 6340 4103
a 6340 6341 4103
a 6341 6342 4103
a 6342 6343 4103
a 6343 6344 4103
a 6344 6345 4103
a 6345 6346 4103
a 6346 6347 4103
a 6347 6348 4103
a 6348 6349 4103
a 6349 6350 4103
a 6350 6351 4103
a 6351 6352 4103
a 6352 6353 4103
a 6353 6354 4103
a 6354 6355 4103
a 6355 6356 4103
a 6356 6357 4103
a 6357 6358 4103
a 6358 6359 4103
a 6359 6360 4103
a 6360 6361 4103
a 6361 6362 4103
a 6362 6363 4103
a 6363 6364 4103
a 6364 6365 4103
a 6365 6366 4103
a 6366 6367 4103
a 6367 6368 4103
a 6368 6369 4103
a 6369 6370 4103
a 6370 6371 4103
a 6371 6372 4103
a 6372 6373 4103
a 6373 6374 4103
a 6374 6375 4103
a 6375 6376 4103
a 6376 6377 4103
a 6377 6378 4103
a 6378 6379 4103
a 6379 6380 4103
a 6380 6381 4103
a 6381 6382 4103
a 6382 6383 4103
a 6383 6384 4103
a 6384 6385 4103
a 6385 6386 4103
a 6386 6387 4103
a 6387 6388 4103
a 6388 6389 4103
a 6389 6390 4103
a 6390 6391 4103
a 6391 6392 4103
a 6392 6393 4103
a 6393 6394 4103
a 6394 6395 4103
a 6395 6396 4103
a 6396 6397 4103
a 6397 6398 4103
a 6398 6399 4103
a 6399 6400 4103
a 6400 6401 4103
a 6401 6402 4103
a 6402 6403 4103
a 6403 6404 4103
a 6404 6405 4103
a 6405 6406 4103
a 6406 6407 4103
a 6407 6408 4103
a 6408 6409 4103
a 6409 6410 4103
a 6410 6411 4103
a 6411 6412 4103
a 6412 6413 4103
a 6413 6414 4103
a 6414 6415 4103
a 6415 6416 4103
a 6416 6417 4103
a 6417 6418 4103
a 6418 6419 4103
a 6419 6420 4103
a 6420 6421 4103
a 6421 6422 4103
a 6422 6423 4103
a 6423 6424 4103
a 6424 6425 4103
a 6425 6426 4103
a 6426 6427 4103
a 6427 6428 4103
a 6428 6429 4103
a 6429 6430 4103
a 6430 6431 4103
a 6431 6432 4103
a 6432 6433 4103
a 6433 6434 4103
a 6434 6435 4103
a 6435 6436 4103
a 6436 6437 4103
a 6437 6438 4103
a 6438 6439 4103
a 6439 6440 4103
a 6440 6441 4103
a 6441 6442 4103
a 6442 6443 4103
a 6443 6444 4103
a 6444 6445 4103
a 6445 6446 4103
a 6446 6447 4103
a 6447 6448 4103
a 6448 6449 4103
a 6449 6450 4103
a 6450 6451 4103
a 6451 6452 4103
a 6452 6453 4103
a 6453 6454 4103
a 6454 6455 4103
a 6455 6456 4103
a 6456 6457 4103
a 6457 6458 4103
a 6458 6459 4103
a 6459 6460 4103
a 6460 6461 4103
a 6461 6462 4103
a 6462 6463 4103
a 6463 6464 4103
a 6464 6465 4103
a 6465 6466 4103
a 6466 6467 4103
a 6467 6468 4103
a 6468 6469 4103
a 6469 6470 4103
a 6470 6471 4103
a 6471 6472 4103
a 6472 6473 4103
a 6473 6474 4103
a 6474 6475 4103
a 6475 6476 4103
a 6476 6477 4103
a 6477 6478 4103
a 6478 6479 4103
a 6479 6480 4103
a 6480 6481 4103
a 6481 6482 4103
a 6482 6483 4103
a 6483 6484 4103
a 6484 6485 4103
a 6485 6486 4103
a 6486 6487 4103
a 6487 6488 4103
a 6488 6489 4103
a 6489 6490 4103
a 6490 6491 4103
a 6491 6492 4103
a 6492 6493 4103
a 6493 6494 4103
a 6494 6495 4103
a 6495 6496 4103
a 6496 6497 4103
a 6497 6498 4103
a 6498 6499 4103
a 6499 6500 4103
a 6500 6501 4103
a 6501 6502 4103
a 6502 6503 4103
a 6503 6504 4103
a 6504 6505 4103
a 6505 6506 4103
a 6506 6507 4103
a 6507 6508 4103
a 6508 6509 4103
a 6509 6510 4103
a 6510 6511 4103
a 6511 6512 4103
a 6512 6513 4103
a 6513 6514 4103
a 6514 6515 4103
a 6515 6516 4103
a 6516 6517 4103
a 6517 6518 4103
a 6518 6519 4103
a 6519 6520 4103
a 6520 6521 4103
a 6521 6522 4103
a 6522 6523 4103
a 6523 6524 4103
a 6524 6525 4103
a 6525 6526 4103
a 6526 6527 4103
a 6527 6528 4103
a 6528 6529 4103
a 6529 6530 4103
a 6530 6531 4103
a 6531 6532 4103
a 6532 6533 4103
a 6533 6534 4103
a 6534 6535 4103
a 6535 6536 4103
a 6536 6537 4103
a 6537 6538 4103
a 6538 6539 4103
a 6539 6540 4103
a 6540 6541 4103
a 6541 6542 4103
a 6542 6543 4103
a 6543 6544 4103
a 6544 6545 4103
a 6545 6546 4103
a 6546 6547 4103
a 6547 6548 4103
a 6548 6549 4103
a 6549 6550 4103
a 6550 6551 4103
a 6551 6552 4103
a 6552 6553 4103
a 6553 6554 4103
a 6554 6555 4103
a 6555 6556 4103
a 6556 6557 4103
a 6557 6558 4103
a 6558 6559 4103
a 6559 6560 4103
a 6560 6561 4103
a 6561 6562 4103
a 6562 6563 4103
a 6563 6564 4103
a 6564 6565 4103
a 6565 6566 4103
a 6566 6567 4103
a 6567 6568 4103
a 6568 6569 4103
a 6569 6570 4103
a 6570 6571 4103
a 6571 6572 4103
a 6572 6573 4103
a 6573 6574 4103
a 6574 6575 4103
a 6575 6576 4103
a 6576 6577 4103
a 6577 6578 4103
a 6578 6579 4103
a 6579 6580 4103
a 6580 6581 4103
a 6581 6582 4103
a 6582 6583 4103
a 6583 6584 4103
a 6584 6585 4103
a 6585 6586 4103
a 6586 6587 4103
a 6587 6588 4103
a 6588 6589 4103
a 6589 6590 4103
a 6590 6591 4103
a 6591 6592 4103
a 6592 6593 4103
a 6593 6594 4103
a 6594 6595 4103
a 6595 6596 4103
a 6596 6597 4103
a 6597 6598 4103
a 6598 6599 4103
a 6599 6600 4103
a 6600 6601 4103
a 6601 6602 4103
a 6602 6603 4103
a 6603 6604 4103
a 6604 6605 4103
a 6605 6606 4103
a 6606 6607 4103
a 6607 6608 4103
a 6608 6609 4103
a 6609 6610 4103
a 6610 6611 4103
a 6611 6612 4103
a 6612 6613 4103
a 6613 6614 4103
a 6614 6615 4103
a 6615 6616 4103
a 6616 6617 4103
a 6617 6618 4103
a 6618 6619 4103
a 6619 6620 4103
a 6620 6621 4103
a 6621 6622 4103
a 6622 6623 4103
a 6623 6624 4103
a 6624 6625 4103
a 6625 6626 4103
a 6626 6627 4103
a 6627 6628 4103
a 6628 6629 4103
a 6629 6630 4103
a 6630 6631 4103
a 6631 6632 4103
a 6632 6633 4103
a 6633 6634 4103
a 6634 6635 4103
a 6635 6636 4103
a 6636 6637 4103
a 6637 6638 4103
a 6638 6639 4103
a 6639 6640 4103
a 6640 6641 4103
a 6641 6642 4103
a 6642 6643 4103
a 6643 6644 4103
a 6644 6645 4103
a 6645 6646 4103
a 6646 6647 4103
a 6647 6648 4103
a 6648 6649 4103
a 6649 6650 4103
a 6650 6651 4103
a 6651 6652 4103
a 6652 6653 4103
a 6653 6654 4103
a 6654 6655 4103
a 6655 6656 4103
a 6656 6657 4103
a 6657 6658 4103
a 6658 6659 4103
a 6659 6660 4103
a 6660 6661 4103
a 6661 6662 4103
a 6662 6663 4103
a 6663 6664 4103
a 6664 6665 4103
a 6665 6666 4103
a 6666 6667 4103
a 6667 6668 4103
a 6668 6669 4103
a 6669 6670 4103
a 6670 6671 4103
a 6671 6672 4103
a 6672 6673 4103
a 6673 6674 4103
a 6674 6675 4103
a 6675 6676 4103
a 6676 6677 4103
a 6677 6678 4103
a 6678 6679 4103
a 6679 6680 4103
a 6680 6681 4103
a 6681 6682 4103
a 6682 6683 4103
a 6683 6684 4103
a 6684 6685 4103
a 6685 6686 4103
a 6686 6687 4103
a 6687 6688 4103
a 6688 6689 4103
a 6689 6690 4103
a 6690 6691 4103
a 6691 6692 4103
a 6692 6693 4103
a 6693 6694 4103
a 6694 6695 4103
a 6695 6696 4103
a 6696 6697 4103
a 6697 6698 4103
a 6698 6699 4103
a 6699 6700 4103
a 6700 6701 4103
a 6701 6702 4103
a 6702 6703 4103
a 6703 6704 4103
a 6704 6705 4103
a 6705 6706 4103
a 6706 6707 4103
a 6707 6708 4103
a 6708 6709 4103
a 6709 6710 4103
a 6710 6711 4103
a 6711 6712 4103
a 6712 6713 4103
a 6713 6714 4103
a 6714 6715 4103
a 6715 6716 4103
a 6716 6717 4103
a 6717 6718 4103
a 6718 6719 4103
a 6719 6720 4103
a 6720 6721 4103
a 6721 6722 4103
a 6722 6723 4103
a 6723 6724 4103
a 6724 6725 4103
a 6725 6726 4103
a 6726 6727 4103
a 6727 6728 4103
a 6728 6729 4103
a 6729 6730 4103
a 6730 6731 4103
a 6731 6732 4103
a 6732 6733 4103
a 6733 6734 4103
a 6734 6735 4103
a 6735 6736 4103
a 6736 6737 4103
a 6737 6738 4103
a 6738 6739 4103
a 6739 6740 4103
a 6740 6741 4103
a 6741 6742 4103
a 6742 6743 4103
a 6743 6744 4103
a 6744 6745 4103
a 6745 6746 4103
a 6746 6747 4103
a 6747 6748 4103
a 6748 6749 4103
a 6749 6750 4103
a 6750 6751 4103
a 6751 6752 4103
a 6752 6753 4103
a 6753 6754 4103
a 6754 6755 4103
a 6755 6756 4103
a 6756 6757 4103
a 6757 6758 4103
a 6758 6759 4103
a 6759 6760 4103
a 6760 6761 4103
a 6761 6762 4103
a 6762 6763 4103
a 6763 6764 4103
a 6764 6765 4103
a 6765 6766 4103
a 6766 6767 4103
a 6767 6768 4103
a 6768 6769 4103
a 6769 6770 4103
a 6770 6771 4103
a 6771 6772 4103
a 6772 6773 4103
a 6773 6774 4103
a 6774 6775 4103
a 6775 6776 4103
a 6776 6777 4103
a 6777 6778 4103
a 6778 6779 4103
a 6779 6780 4103
a 6780 6781 4103
a 6781 6782 4103
a 6782 6783 4103
a 6783 6784 4103
a 6784 6785 4103
a 6785 6786 4103
a 6786 6787 4103
a 6787 6788 4103
a 6788 6789 4103
a 6789 6790 4103
a 6790 6791 4103
a 6791 6792 4103
a 6792 6793 4103
a 6793 6794 4103
a 6794 6795 4103
a 6795 6796 4103
a 6796 6797 4103
a 6797 6798 4103
a 6798 6799 4103
a 6799 6800 4103
a 6800 6801 4103
a 6801 6802 4103
a 6802 6803 4103
a 6803 6804 4103
a 6804 6805 4103
a 6805 6806 4103
a 6806 6807 4103
a 6807 6808 4103
a 6808 6809 4103
a 6809 6810 4103
a 6810 6811 4103
a 6811 6812 4103
a 6812 6813 4103
a 6813 6814 4103
a 6814 6815 4103
a 6815 6816 4103
a 6816 6817 4103
a 6817 6818 4103
a 6818 6819 4103
a 6819 6820 4103
a 6820 6821 4103
a 6821 6822 4103
a 6822 6823 4103
a 6823 6824 4103
a 6824 6825 4103
a 6825 6826 4103
a 6826 6827 4103
a 6827 6828 4103
a 6828 6829 4103
a 6829 6830 4103
a 6830 6831 4103
a 6831 6832 4103
a 6832 6833 4103
a 6833 6834 4103
a 6834 6835 4103
a 6835 6836 4103
a 6836 6837 4103
a 6837 6838 4103
a 6838 6839 4103
a 6839 6840 4103
a 6840 6841 4103
a 6841 6842 4103
a 6842 6843 4103
a 6843 6844 4103
a 6844 6845 4103
a 6845 6846 4103
a 6846 6847 4103
a 6847 6848 4103
a 6848 6849 4103
a 6849 6850 4103
a 6850 6851 4103
a 6851 6852 4103
a 6852 6853 4103
a 6853 6854 4103
a 6854 6855 4103
a 6855 6856 4103
a 6856 6857 4103
a 6857 6858 4103
a 6858 6859 4103
a 6859 6860 4103
a 6860 6861 4103
a 6861 6862 4103
a 6862 6863 4103
a 6863 6864 4103
a 6864 6865 4103
a 6865 6866 4103
a 6866 6867 4103
a 6867 6868 4103
a 6868 6869 4103
a 6869 6870 4103
a 6870 6871 4103
a 6871 6872 4103
a 6872 6873 4103
a 6873 6874 4103
a 6874 6875 4103
a 6875 6876 4103
a 6876 6877 4103
a 6877 6878 4103
a 6878 6879 4103
a 6879 6880 4103
a 6880 6881 4103
a 6881 6882 4103
a 6882 6883 4103
a 6883 6884 4103
a 6884 6885 4103
a 6885 6886 4103
a 6886 6887 4103
a 6887 6888 4103
a 6888 6889 4103
a 6889 6890 4103
a 6890 6891 4103
a 6891 6892 4103
a 6892 6893 4103
a 6893 6894 4103
a 6894 6895 4103
a 6895 6896 4103
a 6896 6897 4103
a 6897 6898 4103
a 6898 6899 4103
a 6899 6900 4103
a 6900 6901 4103
a 6901 6902 4103
a 6902 6903 4103
a 6903 6904 4103
a 6904 6905 4103
a 6905 6906 4103
a 6906 6907 4103
a 6907 6908 4103
a 6908 6909 4103
a 6909 6910 4103
a 6910 6911 4103
a 6911 6912 4103
a 6912 6913 4103
a 6913 6914 4103
a 6914 6915 4103
a 6915 6916 4103
a 6916 6917 4103
a 6917 6918 4103
a 6918 6919 4103
a 6919 6920 4103
a 6920 6921 4103
a 6921 6922 4103
a 6922 6923 4103
a 6923 6924 4103
a 6924 6925 4103
a 6925 6926 4103
a 6926 6927 4103
a 6927 6928 4103
a 6928 6929 4103
a 6929 6930 4103
a 6930 6931 4103
a 6931 6932 4103
a 6932 6933 4103
a 6933 6934 4103
a 6934 6935 4103
a 6935 6936 4103
a 6936 6937 4103
a 6937 6938 4103
a 6938 6939 4103
a 6939 6940 4103
a 6940 6941 4103
a 6941 6942 4103
a 6942 6943 4103
a 6943 6944 4103
a 6944 6945 4103
a 6945 6946 4103
a 6946 6947 4103
a 6947 6948 4103
a 6948 6949 4103
a 6949 6950 4103
a 6950 6951 4103
a 6951 6952 4103
a 6952 6953 4103
a 6953 6954 4103
a 6954 6955 4103
a 6955 6956 4103
a 6956 6957 4103
a 6957 6958 4103
a 6958 6959 4103
a 6959 6960 4103
a 6960 6961 4103
a 6961 6962 4103
a 6962 6963 4103
a 6963 6964 4103
a 6964 6965 4103
a 6965 6966 4103
a 6966 6967 4103
a 6967 6968 4103
a 6968 6969 4103
a 6969 6970 4103
a 6970 6971 4103
a 6971 6972 4103
a 6972 6973 4103
a 6973 6974 4103
a 6974 6975 4103
a 6975 6976 4103
a 6976 6977 4103
a 6977 6978 4103
a 6978 6979 4103
a 6979 6980 4103
a 6980 6981 4103
a 6981 6982 4103
a 6982 6983 4103
a 6983 6984 4103
a 6984 6985 4103
a 6985 6986 4103
a 6986 6987 4103
a 6987 6988 4103
a 6988 6989 4103
a 6989 6990 4103
a 6990 6991 4103
a 6991 6992 4103
a 6992 6993 4103
a 6993 6994 4103
a 6994 6995 4103
a 6995 6996 4103
a 6996 6997 4103
a 6997 6998 4103
a 6998 6999 4103
a 6999 7000 4103
a 7000 7001 4103
a 7001 7002 4103
a 7002 7003 4103
a 7003 7004 4103
a 7004 7005 4103
a 7005 7006 4103
a 7006 7007 4103
a 7007 7008 4103
a 7008 7009 4103
a 7009 7010 4103
a 7010 7011 4103
a 7011 7012 4103
a 7012 7013 4103
a 7013 7014 4103
a 7014 7015 4103
a 7015 7016 4103
a 7016 7017 4103
a 7017 7018 4103
a 7018 7019 4103
a 7019 7020 4103
a 7020 7021 4103
a 7021 7022 4103
a 7022 7023 4103
a 7023 7024 4103
a 7024 7025 4103
a 7025 7026 4103
a 7026 7027 4103
a 7027 7028 4103
a 7028 7029 4103
a 7029 7030 4103
a 7030 7031 4103
a 7031 7032 4103
a 7032 7033 4103
a 7033 7034 4103
a 7034 7035 4103
a 7035 7036 4103
a 7036 7037 4103
a 7037 7038 4103
a 7038 7039 4103
a 7039 7040 4103
a 7040 7041 4103
a 7041 7042 4103
a 7042 7043 4103
a 7043 7044 4103
a 7044 7045 4103
a 7045 7046 4103
a 7046 7047 4103
a 7047 7048 4103
a 7048 7049 4103
a 7049 7050 4103
a 7050 7051 4103
a 7051 7052 4103
a 7052 7053 4103
a 7053 7054 4103
a 7054 7055 4103
a 7055 7056 4103
a 7056 7057 4103
a 7057 7058 4103
a 7058 7059 4103
a 7059 7060 4103
a 7060 7061 4103
a 7061 7062 4103
a 7062 7063 4103
a 7063 7064 4103
a 7064 7065 4103
a 7065 7066 4103
a 7066 7067 4103
a 7067 7068 4103
a 7068 7069 4103
a 7069 7070 4103
a 7070 7071 4103
a 7071 7072 4103
a 7072 7073 4103
a 7073 7074 4103
a 7074 7075 4103
a 7075 7076 4103
a 7076 7077 4103
a 7077 7078 4103
a 7078 7079 4103
a 7079 7080 4103
a 7080 7081 4103
a 7081 7082 4103
a 7082 7083 4103
a 7083 7084 4103
a 7084 7085 4103
a 7085 7086 4103
a 7086 7087 4103
a 7087 7088 4103
a 7088 7089 4103
a 7089 7090 4103
a 7090 7091 4103
a 7091 7092 4103
a 7092 7093 4103
a 7093 7094 4103
a 7094 7095 4103
a 7095 7096 4103
a 7096 7097 4103
a 7097 7098 4103
a 7098 7099 4103
a 7099 7100 4103
a 7100 7101 4103
a 7101 7102 4103
a 7102 7103 4103
a 7103 7104 4103
a 7104 7105 4103
a 7105 7106 4103
a 7106 7107 4103
a 7107 7108 4103
a 7108 7109 4103
a 7109 7110 4103
a 7110 7111 4103
a 7111 7112 4103
a 7112 7113 4103
a 7113 7114 4103
a 7114 7115 4103
a 7115 7116 4103
a 7116 7117 4103
a 7117 7118 4103
a 7118 7119 4103
a 7119 7120 4103
a 7120 7121 4103
a 7121 7122 4103
a 7122 7123 4103
a 7123 7124 4103
a 7124 7125 4103
a 7125 7126 4103
a 7126 7127 4103
a 7127 7128 4103
a 7128 7129 4103
a 7129 7130 4103
a 7130 7131 4103
a 7131 7132 4103
a 7132 7133 4103
a 7133 7134 4103
a 7134 7135 4103
a 7135 7136 4103
a 7136 7137 4103
a 7137 7138 4103
a 7138 7139 4103
a 7139 7140 4103
a 7140 7141 4103
a 7141 7142 4103
a 7142 7143 4103
a 7143 7144 4103
a 7144 7145 4103
a 7145 7146 4103
a 7146 7147 4103
a 7147 7148 4103
a 7148 7149 4103
a 7149 7150 4103
a 7150 7151 4103
a 7151 7152 4103
a 7152 7153 4103
a 7153 7154 4103
a 7154 7155 4103
a 7155 7156 4103
a 7156 7157 4103
a 7157 7158 4103
a 7158 7159 4103
a 7159 7160 4103
a 7160 7161 4103
a 7161 7162 4103
a 7162 7163 4103
a 7163 7164 4103
a 7164 7165 4103
a 7165 7166 4103
a 7166 7167 4103
a 7167 7168 4103
a 7168 7169 4103
a 7169 7170 4103
a 7170 7171 4103
a 7171 7172 4103
a 7172 7173 4103
a 7173 7174 4103
a 7174 7175 4103
a 7175 7176 4103
a 7176 7177 4103
a 7177 7178 4103
a 7178 7179 4103
a 7179 7180 4103
a 7180 7181 4103
a 7181 7182 4103
a 7182 7183 4103
a 7183 7184 4103
a 7184 7185 4103
a 7185 7186 4103
a 7186 7187 4103
a 7187 7188 4103
a 7188 7189 4103
a 7189 7190 4103
a 7190 7191 4103
a 7191 7192 4103
a 7192 7193 4103
a 7193 7194 4103
a 7194 7195 4103
a 7195 7196 4103
a 7196 7197 4103
a 7197 7198 4103
a 7198 7199 4103
a 7199 7200 4103
a 7200 7201 4103
a 7201 7202 4103
a 7202 7203 4103
a 7203 7204 4103
a 7204 7205 4103
a 7205 7206 4103
a 7206 7207 4103
a 7207 7208 4103
a 7208 7209 4103
a 7209 7210 4103
a 7210 7211 4103
a 7211 7212 4103
a 7212 7213 4103
a 7213 7214 4103
a 7214 7215 4103
a 7215 7216 4103
a 7216 7217 4103
a 7217 7218 4103
a 7218 7219 4103
a 7219 7220 4103
a 7220 7221 4103
a 7221 7222 4103
a 7222 7223 4103
a 7223 7224 4103
a 7224 7225 4103
a 7225 7226 4103
a 7226 7227 4103
a 7227 7228 4103
a 7228 7229 4103
a 7229 7230 4103
a 7230 7231 4103
a 7231 7232 4103
a 7232 7233 4103
a 7233 7234 4103
a 7234 7235 4103
a 7235 7236 4103
a 7236 7237 4103
a 7237 7238 4103
a 7238 7239 4103
a 7239 7240 4103
a 7240 7241 4103
a 7241 7242 4103
a 7242 7243 4103
a 7243 7244 4103
a 7244 7245 4103
a 7245 7246 4103
a 7246 7247 4103
a 7247 7248 4103
a 7248 7249 4103
a 7249 7250 4103
a 7250 7251 4103
a 7251 7252 4103
a 7252 7253 4103
a 7253 7254 4103
a 7254 7255 4103
a 7255 7256 4103
a 7256 7257 4103
a 7257 7258 4103
a 7258 7259 4103
a 7259 7260 4103
a 7260 7261 4103
a 7261 7262 4103
a 7262 7263 4103
a 7263 7264 4103
a 7264 7265 4103
a 7265 7266 4103
a 7266 7267 4103
a 7267 7268 4103
a 7268 7269 4103
a 7269 7270 4103
a 7270 7271 4103
a 7271 7272 4103
a 7272 7273 4103
a 7273 7274 4103
a 7274 7275 4103
a 7275 7276 4103
a 7276 7277 4103
a 7277 7278 4103
a 7278 7279 4103
a 7279 7280 4103
a 7280 7281 4103
a 7281 7282 4103
a 7282 7283 4103
a 7283 7284 4103
a 7284 7285 4103
a 7285 7286 4103
a 7286 7287 4103
a 7287 7288 4103
a 7288 7289 4103
a 7289 7290 4103
a 7290 7291 4103
a 7291 7292 4103
a 7292 7293 4103
a 7293 7294 4103
a 7294 7295 4103
a 7295 7296 4103
a 7296 7297 4103
a 7297 7298 4103
a 7298 7299 4103
a 7299 7300 4103
a 7300 7301 4103
a 7301 7302 4103
a 7302 7303 4103
a 7303 7304 4103
a 7304 7305 4103
a 7305 7306 4103
a 7306 7307 4103
a 7307 7308 4103
a 7308 7309 4103
a 7309 7310 4103
a 7310 7311 4103
a 7311 7312 4103
a 7312 7313 4103
a 7313 7314 4103
a 7314 7315 4103
a 7315 7316 4103
a 7316 7317 4103
a 7317 7318 4103
a 7318 7319 4103
a 7319 7320 4103
a 7320 7321 4103
a 7321 7322 4103
a 7322 7323 4103
a 7323 7324 4103
a 7324 7325 4103
a 7325 7326 4103
a 7326 7327 4103
a 7327 7328 4103
a 7328 7329 4103
a 7329 7330 4103
a 7330 7331 4103
a 7331 7332 4103
a 7332 7333 4103
a 7333 7334 4103
a 7334 7335 4103
a 7335 7336 4103
a 7336 7337 4103
a 7337 7338 4103
a 7338 7339 4103
a 7339 7340 4103
a 7340 7341 4103
a 7341 7342 4103
a 7342 7343 4103
a 7343 7344 4103
a 7344 7345 4103
a 7345 7346 4103
a 7346 7347 4103
a 7347 7348 4103
a 7348 7349 4103
a 7349 7350 4103
a 7350 7351 4103
a 7351 7352 4103
a 7352 7353 4103
a 7353 7354 4103
a 7354 7355 4103
a 7355 7356 4103
a 7356 7357 4103
a 7357 7358 4103
a 7358 7359 4103
a 7359 7360 4103
a 7360 7361 4103
a 7361 7362 4103
a 7362 7363 4103
a 7363 7364 4103
a 7364 7365 4103
a 7365 7366 4103
a 7366 7367 4103
a 7367 7368 4103
a 7368 7369 4103
a 7369 7370 4103
a 7370 7371 4103
a 7371 7372 4103
a 7372 7373 4103
a 7373 7374 4103
a 7374 7375 4103
a 7375 7376 4103
a 7376 7377 4103
a 7377 7378 4103
a 7378 7379 4103
a 7379 7380 4103
a 7380 7381 4103
a 7381 7382 4103
a 7382 7383 4103
a 7383 7384 4103
a 7384 7385 4103
a 7385 7386 4103
a 7386 7387 4103
a 7387 7388 4103
a 7388 7389 4103
a 7389 7390 4103
a 7390 7391 4103
a 7391 7392 4103
a 7392 7393 4103
a 7393 7394 4103
a 7394 7395 4103
a 7395 7396 4103
a 7396 7397 4103
a 7397 7398 4103
a 7398 7399 4103
a 7399 7400 4103
a 7400 7401 4103
a 7401 7402 4103
a 7402 7403 4103
a 7403 7404 4103
a 7404 7405 4103
a 7405 7406 4103
a 7406 7407 4103
a 7407 7408 4103
a 7408 7409 4103
a 7409 7410 4103
a 7410 7411 4103
a 7411 7412 4103
a 7412 7413 4103
a 7413 7414 4103
a 7414 7415 4103
a 7415 7416 4103
a 7416 7417 4103
a 7417 7418 4103
a 7418 7419 4103
a 7419 7420 4103
a 7420 7421 4103
a 7421 7422 4103
a 7422 7423 4103
a 7423 7424 4103
a 7424 7425 4103
a 7425 7426 4103
a 7426 7427 4103
a 7427 7428 4103
a 7428 7429 4103
a 7429 7430 4103
a 7430 7431 4103
a 7431 7432 4103
a 7432 7433 4103
a 7433 7434 4103
a 7434 7435 4103
a 7435 7436 4103
a 7436 7437 4103
a 7437 7438 4103
a 7438 7439 4103
a 7439 7440 4103
a 7440 7441 4103
a 7441 7442 4103
a 7442 7443 4103
a 7443 7444 4103
a 7444 7445 4103
a 7445 7446 4103
a 7446 7447 4103
a 7447 7448 4103
a 7448 7449 4103
a 7449 7450 4103
a 7450 7451 4103
a 7451 7452 4103
a 7452 7453 4103
a 7453 7454 4103
a 7454 7455 4103
a 7455 7456 4103
a 7456 7457 4103
a 7457 7458 4103
a 7458 7459 4103
a 7459 7460 4103
a 7460 7461 4103
a 7461 7462 4103
a 7462 7463 4103
a 7463 7464 4103
a 7464 7465 4103
a 7465 7466 4103
a 7466 7467 4103
a 7467 7468 4103
a 7468 7469 4103
a 7469 7470 4103
a 7470 7471 4103
a 7471 7472 4103
a 7472 7473 4103
a 7473 7474 4103
a 7474 7475 4103
a 7475 7476 4103
a 7476 7477 4103
a 7477 7478 4103
a 7478 7479 4103
a 7479 7480 4103
a 7480 7481 4103
a 7481 7482 4103
a 7482 7483 4103
a 7483 7484 4103
a 7484 7485 4103
a 7485 7486 4103
a 7486 7487 4103
a 7487 7488 4103
a 7488 7489 4103
a 7489 7490 4103
a 7490 7491 4103
a 7491 7492 4103
a 7492 7493 4103
a 7493 7494 4103
a 7494 7495 4103
a 7495 7496 4103
a 7496 7497 4103
a 7497 7498 4103
a 7498 7499 4103
a 7499 7500 4103
a 7500 7501 4103
a 7501 7502 4103
a 7502 7503 4103
a 7503 7504 4103
a 7504 7505 4103
a 7505 7506 4103
a 7506 7507 4103
a 7507 7508 4103
a 7508 7509 4103
a 7509 7510 4103
a 7510 7511 4103
a 7511 7512 4103
a 7512 7513 4103
a 7513 7514 4103
a 7514 7515 4103
a 7515 7516 4103
a 7516 7517 4103
a 7517 7518 4103
a 7518 7519 4103
a 7519 7520 4103
a 7520 7521 4103
a 7521 7522 4103
a 7522 7523 4103
a 7523 7524 4103
a 7524 7525 4103
a 7525 7526 4103
a 7526 7527 4103
a 7527 7528 4103
a 7528 7529 4103
a 7529 7530 4103
a 7530 7531 4103
a 7531 7532 4103
a 7532 7533 4103
a 7533 7534 4103
a 7534 7535 4103
a 7535 7536 4103
a 7536 7537 4103
a 7537 7538 4103
a 7538 7539 4103
a 7539 7540 4103
a 7540 7541 4103
a 7541 7542 4103
a 7542 7543 4103
a 7543 7544 4103
a 7544 7545 4103
a 7545 7546 4103
a 7546 7547 4103
a 7547 7548 4103
a 7548 7549 4103
a 7549 7550 4103
a 7550 7551 4103
a 7551 7552 4103
a 7552 7553 4103
a 7553 7554 4103
a 7554 7555 4103
a 7555 7556 4103
a 7556 7557 4103
a 7557 7558 4103
a 7558 7559 4103
a 7559 7560 4103
a 7560 7561 4103
a 7561 7562 4103
a 7562 7563 4103
a 7563 7564 4103
a 7564 7565 4103
a 7565 7566 4103
a 7566 7567 4103
a 7567 7568 4103
a 7568 7569 4103
a 7569 7570 4103
a 7570 7571 4103
a 7571 7572 4103
a 7572 7573 4103
a 7573 7574 4103
a 7574 7575 4103
a 7575 7576 4103
a 7576 7577 4103
a 7577 7578 4103
a 7578 7579 4103
a 7579 7580 4103
a 7580 7581 4103
a 7581 7582 4103
a 7582 7583 4103
a 7583 7584 4103
a 7584 7585 4103
a 7585 7586 4103
a 7586 7587 4103
a 7587 7588 4103
a 7588 7589 4103
a 7589 7590 4103
a 7590 7591 4103
a 7591 7592 4103
a 7592 7593 4103
a 7593 7594 4103
a 7594 7595 4103
a 7595 7596 4103
a 7596 7597 4103
a 7597 7598 4103
a 7598 7599 4103
a 7599 7600 4103
a 7600 7601 4103
a 7601 7602 4103
a 7602 7603 4103
a 7603 7604 4103
a 7604 7605 4103
a 7605 7606 4103
a 7606 7607 4103
a 7607 7608 4103
a 7608 7609 4103
a 7609 7610 4103
a 7610 7611 4103
a 7611 7612 4103
a 7612 7613 4103
a 7613 7614 4103
a 7614 7615 4103
a 7615 7616 4103
a 7616 7617 4103
a 7617 7618 4103
a 7618 7619 4103
a 7619 7620 4103
a 7620 7621 4103
a 7621 7622 4103
a 7622 7623 4103
a 7623 7624 4103
a 7624 7625 4103
a 7625 7626 4103
a 7626 7627 4103
a 7627 7628 4103
a 7628 7629 4103
a 7629 7630 4103
a 7630 7631 4103
a 7631 7632 4103
a 7632 7633 4103
a 7633 7634 4103
a 7634 7635 4103
a 7635 7636 4103
a 7636 7637 4103
a 7637 7638 4103
a 7638 7639 4103
a 7639 7640 4103
a 7640 7641 4103
a 7641 7642 4103
a 7642 7643 4103
a 7643 7644 4103
a 7644 7645 4103
a 7645 7646 4103
a 7646 7647 4103
a 7647 7648 4103
a 7648 7649 4103
a 7649 7650 4103
a 7650 7651 4103
a 7651 7652 4103
a 7652 7653 4103
a 7653 7654 4103
a 7654 7655 4103
a 7655 7656 4103
a 7656 7657 4103
a 7657 7658 4103
a 7658 7659 4103
a 7659 7660 4103
a 7660 7661 4103
a 7661 7662 4103
a 7662 7663 4103
a 7663 7664 4103
a 7664 7665 4103
a 7665 7666 4103
a 7666 7667 4103
a 7667 7668 4103
a 7668 7669 4103
a 7669 7670 4103
a 7670 7671 4103
a 7671 7672 4103
a 7672 7673 4103
a 7673 7674 4103
a 7674 7675 4103
a 7675 7676 4103
a 7676 7677 4103
a 7677 7678 4103
a 7678 7679 4103
a 7679 7680 4103
a 7680 7681 4103
a 7681 7682 4103
a 7682 7683 4103
a 7683 7684 4103
a 7684 7685 4103
a 7685 7686 4103
a 7686 7687 4103
a 7687 7688 4103
a 7688 7689 4103
a 7689 7690 4103
a 7690 7691 4103
a 7691 7692 4103
a 7692 7693 4103
a 7693 7694 4103
a 7694 7695 4103
a 7695 7696 4103
a 7696 7697 4103
a 7697 7698 4103
a 7698 7699 4103
a 7699 7700 4103
a 7700 7701 4103
a 7701 7702 4103
a 7702 7703 4103
a 7703 7704 4103
a 7704 7705 4103
a 7705 7706 4103
a 7706 7707 4103
a 7707 7708 4103
a 7708 7709 4103
a 7709 7710 4103
a 7710 7711 4103
a 7711 7712 4103
a 7712 7713 4103
a 7713 7714 4103
a 7714 7715 4103
a 7715 7716 4103
a 7716 7717 4103
a 7717 7718 4103
a 7718 7719 4103
a 7719 7720 4103
a 7720 7721 4103
a 7721 7722 4103
a 7722 7723 4103
a 7723 7724 4103
a 7724 7725 4103
a 7725 7726 4103
a 7726 7727 4103
a 7727 7728 4103
a 7728 7729 4103
a 7729 7730 4103
a 7730 7731 4103
a 7731 7732 4103
a 7732 7733 4103
a 7733 7734 4103
a 7734 7735 4103
a 7735 7736 4103
a 7736 7737 4103
a 7737 7738 4103
a 7738 7739 4103
a 7739 7740 4103
a 7740 7741 4103
a 7741 7742 4103
a 7742 7743 4103
a 7743 7744 4103
a 7744 7745 4103
a 7745 7746 4103
a 7746 7747 4103
a 7747 7748 4103
a 7748 7749 4103
a 7749 7750 4103
a 7750 7751 4103
a 7751 7752 4103
a 7752 7753 4103
a 7753 7754 4103
a 7754 7755 4103
a 7755 7756 4103
a 7756 7757 4103
a 7757 7758 4103
a 7758 7759 4103
a 7759 7760 4103
a 7760 7761 4103
a 7761 7762 4103
a 7762 7763 4103
a 7763 7764 4103
a 7764 7765 4103
a 7765 7766 4103
a 7766 7767 4103
a 7767 7768 4103
a 7768 7769 4103
a 7769 7770 4103
a 7770 7771 4103
a 7771 7772 4103
a 7772 7773 4103
a 7773 7774 4103
a 7774 7775 4103
a 7775 7776 4103
a 7776 7777 4103
a 7777 7778 4103
a 7778 7779 4103
a 7779 7780 4103
a 7780 7781 4103
a 7781 7782 4103
a 7782 7783 4103
a 7783 7784 4103
a 7784 7785 4103
a 7785 7786 4103
a 7786 7787 4103
a 7787 7788 4103
a 7788 7789 4103
a 7789 7790 4103
a 7790 7791 4103
a 7791 7792 4103
a 7792 7793 4103
a 7793 7794 4103
a 7794 7795 4103
a 7795 7796 4103
a 7796 7797 4103
a 7797 7798 4103
a 7798 7799 4103
a 7799 7800 4103
a 7800 7801 4103
a 7801 7802 4103
a 7802 7803 4103
a 7803 7804 4103
a 7804 7805 4103
a 7805 7806 4103
a 7806 7807 4103
a 7807 7808 4103
a 7808 7809 4103
a 7809 7810 4103
a 7810 7811 4103
a 7811 7812 4103
a 7812 7813 4103
a 7813 7814 4103
a 7814 7815 4103
a 7815 7816 4103
a 7816 7817 4103
a 7817 7818 4103
a 7818 7819 4103
a 7819 7820 4103
a 7820 7821 4103
a 7821 7822 4103
a 7822 7823 4103
a 7823 7824 4103
a 7824 7825 4103
a 7825 7826 4103
a 7826 7827 4103
a 7827 7828 4103
a 7828 7829 4103
a 7829 7830 4103
a 7830 7831 4103
a 7831 7832 4103
a 7832 7833 4103
a 7833 7834 4103
a 7834 7835 4103
a 7835 7836 4103
a 7836 7837 4103
a 7837 7838 4103
a 7838 7839 4103
a 7839 7840 4103
a 7840 7841 4103
a 7841 7842 4103
a 7842 7843 4103
a 7843 7844 4103
a 7844 7845 4103
a 7845 7846 4103
a 7846 7847 4103
a 7847 7848 4103
a 7848 7849 4103
a 7849 7850 4103
a 7850 7851 4103
a 7851 7852 4103
a 7852 7853 4103
a 7853 7854 4103
a 7854 7855 4103
a 7855 7856 4103
a 7856 7857 4103
a 7857 7858 4103
a 7858 7859 4103
a 7859 7860 4103
a 7860 7861 4103
a 7861 7862 4103
a 7862 7863 4103
a 7863 7864 4103
a 7864 7865 4103
a 7865 7866 4103
a 7866 7867 4103
a 7867 7868 4103
a 7868 7869 4103
a 7869 7870 4103
a 7870 7871 4103
a 7871 7872 4103
a 7872 7873 4103
a 7873 7874 4103
a 7874 7875 4103
a 7875 7876 4103
a 7876 7877 4103
a 7877 7878 4103
a 7878 7879 4103
a 7879 7880 4103
a 7880 7881 4103
a 7881 7882 4103
a 7882 7883 4103
a 7883 7884 4103
a 7884 7885 4103
a 7885 7886 4103
a 7886 7887 4103
a 7887 7888 4103
a 7888 7889 4103
a 7889 7890 4103
a 7890 7891 4103
a 7891 7892 4103
a 7892 7893 4103
a 7893 7894 4103
a 7894 7895 4103
a 7895 7896 4103
a 7896 7897 4103
a 7897 7898 4103
a 7898 7899 4103
a 7899 7900 4103
a 7900 7901 4103
a 7901 7902 4103
a 7902 7903 4103
a 7903 7904 4103
a 7904 7905 4103
a 7905 7906 4103
a 7906 7907 4103
a 7907 7908 4103
a 7908 7909 4103
a 7909 7910 4103
a 7910 7911 4103
a 7911 7912 4103
a 7912 7913 4103
a 7913 7914 4103
a 7914 7915 4103
a 7915 7916 4103
a 7916 7917 4103
a 7917 7918 4103
a 7918 7919 4103
a 7919 7920 4103
a 7920 7921 4103
a 7921 7922 4103
a 7922 7923 4103
a 7923 7924 4103
a 7924 7925 4103
a 7925 7926 4103
a 7926 7927 4103
a 7927 7928 4103
a 7928 7929 4103
a 7929 7930 4103
a 7930 7931 4103
a 7931 7932 4103
a 7932 7933 4103
a 7933 7934 4103
a 7934 7935 4103
a 7935 7936 4103
a 7936 7937 4103
a 7937 7938 4103
a 7938 7939 4103
a 7939 7940 4103
a 7940 7941 4103
a 7941 7942 4103
a 7942 7943 4103
a 7943 7944 4103
a 7944 7945 4103
a 7945 7946 4103
a 7946 7947 4103
a 7947 7948 4103
a 7948 7949 4103
a 7949 7950 4103
a 7950 7951 4103
a 7951 7952 4103
a 7952 7953 4103
a 7953 7954 4103
a 7954 7955 4103
a 7955 7956 4103
a 7956 7957 4103
a 7957 7958 4103
a 7958 7959 4103
a 7959 7960 4103
a 7960 7961 4103
a 7961 7962 4103
a 7962 7963 4103
a 7963 7964 4103
a 7964 7965 4103
a 7965 7966 4103
a 7966 7967 4103
a 7967 7968 4103
a 7968 7969 4103
a 7969 7970 4103
a 7970 7971 4103
a 7971 7972 4103
a 7972 7973 4103
a 7973 7974 4103
a 7974 7975 4103
a 7975 7976 4103
a 7976 7977 4103
a 7977 7978 4103
a 7978 7979 4103
a 7979 7980 4103
a 7980 7981 4103
a 7981 7982 4103
a 7982 7983 4103
a 7983 7984 4103
a 7984 7985 4103
a 7985 7986 4103
a 7986 7987 4103
a 7987 7988 4103
a 7988 7989 4103
a 7989 7990 4103
a 7990 7991 4103
a 7991 7992 4103
a 7992 7993 4103
a 7993 7994 4103
a 7994 7995 4103
a 7995 7996 4103
a 7996 7997 4103
a 7997 7998 4103
a 7998 7999 4103
a 7999 8000 4103
a 8000 8001 4103
a 8001 8002 4103
a 8002 8003 4103
a 8003 8004 4103
a 8004 8005 4103
a 8005 8006 4103
a 8006 8007 4103
a 8007 8008 4103
a 8008 8009 4103
a 8009 8010 4103
a 8010 8011 4103
a 8011 8012 4103
a 8012 8013 4103
a 8013 8014 4103
a 8014 8015 4103
a 8015 8016 4103
a 8016 8017 4103
a 8017 8018 4103
a 8018 8019 4103
a 8019 8020 4103
a 8020 8021 4103
a 8021 8022 4103
a 8022 8023 4103
a 8023 8024 4103
a 8024 8025 4103
a 8025 8026 4103
a 8026 8027 4103
a 8027 8028 4103
a 8028 8029 4103
a 8029 8030 4103
a 8030 8031 4103
a 8031 8032 4103
a 8032 8033 4103
a 8033 8034 4103
a 8034 8035 4103
a 8035 8036 4103
a 8036 8037 4103
a 8037 8038 4103
a 8038 8039 4103
a 8039 8040 4103
a 8040 8041 4103
a 8041 8042 4103
a 8042 8043 4103
a 8043 8044 4103
a 8044 8045 4103
a 8045 8046 4103
a 8046 8047 4103
a 8047 8048 4103
a 8048 8049 4103
a 8049 8050 4103
a 8050 8051 4103
a 8051 8052 4103
a 8052 8053 4103
a 8053 8054 4103
a 8054 8055 4103
a 8055 8056 4103
a 8056 8057 4103
a 8057 8058 4103
a 8058 8059 4103
a 8059 8060 4103
a 8060 8061 4103
a 8061 8062 4103
a 8062 8063 4103
a 8063 8064 4103
a 8064 8065 4103
a 8065 8066 4103
a 8066 8067 4103
a 8067 8068 4103
a 8068 8069 4103
a 8069 8070 4103
a 8070 8071 4103
a 8071 8072 4103
a 8072 8073 4103
a 8073 8074 4103
a 8074 8075 4103
a 8075 8076 4103
a 8076 8077 4103
a 8077 8078 4103
a 8078 8079 4103
a 8079 8080 4103
a 8080 8081 4103
a 8081 8082 4103
a 8082 8083 4103
a 8083 8084 4103
a 8084 8085 4103
a 8085 8086 4103
a 8086 8087 4103
a 8087 8088 4103
a 8088 8089 4103
a 8089 8090 4103
a 8090 8091 4103
a 8091 8092 4103
a 8092 8093 4103
a 8093 8094 4103
a 8094 8095 4103
a 8095 8096 4103
a 8096 8097 4103
a 8097 8098 4103
a 8098 8099 4103
a 8099 8100 4103
a 8100 8101 4103
a 8101 8102 4103
a 8102 8103 4103
a 8103 8104 4103
a 8104 8105 4103
a 8105 8106 4103
a 8106 8107 4103
a 8107 8108 4103
a 8108 8109 4103
a 8109 8110 4103
a 8110 8111 4103
a 8111 8112 4103
a 8112 8113 4103
a 8113 8114 4103
a 8114 8115 4103
a 8115 8116 4103
a 8116 8117 4103
a 8117 8118 4103
a 8118 8119 4103
a 8119 8120 4103
a 8120 8121 4103
a 8121 8122 4103
a 8122 8123 4103
a 8123 8124 4103
a 8124 8125 4103
a 8125 8126 4103
a 8126 8127 4103
a 8127 8128 4103
a 8128 8129 4103
a 8129 8130 4103
a 8130 8131 4103
a 8131 8132 4103
a 8132 8133 4103
a 8133 8134 4103
a 8134 8135 4103
a 8135 8136 4103
a 8136 8137 4103
a 8137 8138 4103
a 8138 8139 4103
a 8139 8140 4103
a 8140 8141 4103
a 8141 8142 4103
a 8142 8143 4103
a 8143 8144 4103
a 8144 8145 4103
a 8145 8146 4103
a 8146 8147 4103
a 8147 8148 4103
a 8148 8149 4103
a 8149 8150 4103
a 8150 8151 4103
a 8151 8152 4103
a 8152 8153 4103
a 8153 8154 4103
a 8154 8155 4103
a 8155 8156 4103
a 8156 8157 4103
a 8157 8158 4103
a 8158 8159 4103
a 8159 8160 4103
a 8160 8161 4103
a 8161 8162 4103
a 8162 8163 4103
a 8163 8164 4103
a 8164 8165 4103
a 8165 8166 4103
a 8166 8167 4103
a 8167 8168 4103
a 8168 8169 4103
a 8169 8170 4103
a 8170 8171 4103
a 8171 8172 4103
a 8172 8173 4103
a 8173 8174 4103
a 8174 8175 4103
a 8175 8176 4103
a 8176 8177 4103
a 8177 8178 4103
a 8178 8179 4103
a 8179 8180 4103
a 8180 8181 4103
a 8181 8182 4103
a 8182 8183 4103
a 8183 8184 4103
a 8184 8185 4103
a 8185 8186 4103
a 8186 8187 4103
a 8187 8188 4103
a 8188 8189 4103
a 8189 8190 4103
a 8190 8191 4103
a 8191 8192 4103
a 8192 8193 4103
a 8193 8194 4103
a 8194 8195 4103
a 8195 8196 4103
a 8196 8197 4103
a 8197 8198 4103
a 8198 8199 4103
a 8199 8200 4103
a 8200 8201 4103
a 8201 8202 4103
a 8202 8203 4103
a 8203 8204 4103
a 8204 8205 4103
a 8205 8206 4103
a 8206 8207 4103
a 8207 8208 4103
a 8209 8210 4102
a 8210 8211 4102
a 8211 8212 4102
a 8212 8213 4102
a 8213 8214 4102
a 8214 8215 4102
a 8215 8216 4102
a 8216 8217 4102
a 8217 8218 4102
a 8218 8219 4102
a 8219 8220 4102
a 8220 8221 4102
a 8221 8222 4102
a 8222 8223 4102
a 8223 8224 4102
a 8224 8225 4102
a 8225 8226 4102
a 8226 8227 4102
a 8227 8228 4102
a 8228 8229 4102
a 8229 8230 4102
a 8230 8231 4102
a 8231 8232 4102
a 8232 8233 4102
a 8233 8234 4102
a 8234 8235 4102
a 8235 8236 4102
a 8236 8237 4102
a 8237 8238 4102
a 8238 8239 4102
a 8239 8240 4102
a 8240 8241 4102
a 8241 8242 4102
a 8242 8243 4102
a 8243 8244 4102
a 8244 8245 4102
a 8245 8246 4102
a 8246 8247 4102
a 8247 8248 4102
a 8248 8249 4102
a 8249 8250 4102
a 8250 8251 4102
a 8251 8252 4102
a 8252 8253 4102
a 8253 8254 4102
a 8254 8255 4102
a 8255 8256 4102
a 8256 8257 4102
a 8257 8258 4102
a 8258 8259 4102
a 8259 8260 4102
a 8260 8261 4102
a 8261 8262 4102
a 8262 8263 4102
a 8263 8264 4102
a 8264 8265 4102
a 8265 8266 4102
a 8266 8267 4102
a 8267 8268 4102
a 8268 8269 4102
a 8269 8270 4102
a 8270 8271 4102
a 8271 8272 4102
a 8272 8273 4102
a 8273 8274 4102
a 8274 8275 4102
a 8275 8276 4102
a 8276 8277 4102
a 8277 8278 4102
a 8278 8279 4102
a 8279 8280 4102
a 8280 8281 4102
a 8281 8282 4102
a 8282 8283 4102
a 8283 8284 4102
a 8284 8285 4102
a 8285 8286 4102
a 8286 8287 4102
a 8287 8288 4102
a 8288 8289 4102
a 8289 8290 4102
a 8290 8291 4102
a 8291 8292 4102
a 8292 8293 4102
a 8293 8294 4102
a 8294 8295 4102
a 8295 8296 4102
a 8296 8297 4102
a 8297 8298 4102
a 8298 8299 4102
a 8299 8300 4102
a 8300 8301 4102
a 8301 8302 4102
a 8302 8303 4102
a 8303 8304 4102
a 8304 8305 4102
a 8305 8306 4102
a 8306 8307 4102
a 8307 8308 4102
a 8308 8309 4102
a 8309 8310 4102
a 8310 8311 4102
a 8311 8312 4102
a 8312 8313 4102
a 8313 8314 4102
a 8314 8315 4102
a 8315 8316 4102
a 8316 8317 4102
a 8317 8318 4102
a 8318 8319 4102
a 8319 8320 4102
a 8320 8321 4102
a 8321 8322 4102
a 8322 8323 4102
a 8323 8324 4102
a 8324 8325 4102
a 8325 8326 4102
a 8326 8327 4102
a 8327 8328 4102
a 8328 8329 4102
a 8329 8330 4102
a 8330 8331 4102
a 8331 8332 4102
a 8332 8333 4102
a 8333 8334 4102
a 8334 8335 4102
a 8335 8336 4102
a 8336 8337 4102
a 8337 8338 4102
a 8338 8339 4102
a 8339 8340 4102
a 8340 8341 4102
a 8341 8342 4102
a 8342 8343 4102
a 8343 8344 4102
a 8344 8345 4102
a 8345 8346 4102
a 8346 8347 4102
a 8347 8348 4102
a 8348 8349 4102
a 8349 8350 4102
a 8350 8351 4102
a 8351 8352 4102
a 8352 8353 4102
a 8353 8354 4102
a 8354 8355 4102
a 8355 8356 4102
a 8356 8357 4102
a 8357 8358 4102
a 8358 8359 4102
a 8359 8360 4102
a 8360 8361 4102
a 8361 8362 4102
a 8362 8363 4102
a 8363 8364 4102
a 8364 8365 4102
a 8365 8366 4102
a 8366 8367 4102
a 8367 8368 4102
a 8368 8369 4102
a 8369 8370 4102
a 8370 8371 4102
a 8371 8372 4102
a 8372 8373 4102
a 8373 8374 4102
a 8374 8375 4102
a 8375 8376 4102
a 8376 8377 4102
a 8377 8378 4102
a 8378 8379 4102
a 8379 8380 4102
a 8380 8381 4102
a 8381 8382 4102
a 8382 8383 4102
a 8383 8384 4102
a 8384 8385 4102
a 8385 8386 4102
a 8386 8387 4102
a 8387 8388 4102
a 8388 8389 4102
a 8389 8390 4102
a 8390 8391 4102
a 8391 8392 4102
a 8392 8393 4102
a 8393 8394 4102
a 8394 8395 4102
a 8395 8396 4102
a 8396 8397 4102
a 8397 8398 4102
a 8398 8399 4102
a 8399 8400 4102
a 8400 8401 4102
a 8401 8402 4102
a 8402 8403 4102
a 8403 8404 4102
a 8404 8405 4102
a 8405 8406 4102
a 8406 8407 4102
a 8407 8408 4102
a 8408 8409 4102
a 8409 8410 4102
a 8410 8411 4102
a 8411 8412 4102
a 8412 8413 4102
a 8413 8414 4102
a 8414 8415 4102
a 8415 8416 4102
a 8416 8417 4102
a 8417 8418 4102
a 8418 8419 4102
a 8419 8420 4102
a 8420 8421 4102
a 8421 8422 4102
a 8422 8423 4102
a 8423 8424 4102
a 8424 8425 4102
a 8425 8426 4102
a 8426 8427 4102
a 8427 8428 4102
a 8428 8429 4102
a 8429 8430 4102
a 8430 8431 4102
a 8431 8432 4102
a 8432 8433 4102
a 8433 8434 4102
a 8434 8435 4102
a 8435 8436 4102
a 8436 8437 4102
a 8437 8438 4102
a 8438 8439 4102
a 8439 8440 4102
a 8440 8441 4102
a 8441 8442 4102
a 8442 8443 4102
a 8443 8444 4102
a 8444 8445 4102
a 8445 8446 4102
a 8446 8447 4102
a 8447 8448 4102
a 8448 8449 4102
a 8449 8450 4102
a 8450 8451 4102
a 8451 8452 4102
a 8452 8453 4102
a 8453 8454 4102
a 8454 8455 4102
a 8455 8456 4102
a 8456 8457 4102
a 8457 8458 4102
a 8458 8459 4102
a 8459 8460 4102
a 8460 8461 4102
a 8461 8462 4102
a 8462 8463 4102
a 8463 8464 4102
a 8464 8465 4102
a 8465 8466 4102
a 8466 8467 4102
a 8467 8468 4102
a 8468 8469 4102
a 8469 8470 4102
a 8470 8471 4102
a 8471 8472 4102
a 8472 8473 4102
a 8473 8474 4102
a 8474 8475 4102
a 8475 8476 4102
a 8476 8477 4102
a 8477 8478 4102
a 8478 8479 4102
a 8479 8480 4102
a 8480 8481 4102
a 8481 8482 4102
a 8482 8483 4102
a 8483 8484 4102
a 8484 8485 4102
a 8485 8486 4102
a 8486 8487 4102
a 8487 8488 4102
a 8488 8489 4102
a 8489 8490 4102
a 8490 8491 4102
a 8491 8492 4102
a 8492 8493 4102
a 8493 8494 4102
a 8494 8495 4102
a 8495 8496 4102
a 8496 8497 4102
a 8497 8498 4102
a 8498 8499 4102
a 8499 8500 4102
a 8500 8501 4102
a 8501 8502 4102
a 8502 8503 4102
a 8503 8504 4102
a 8504 8505 4102
a 8505 8506 4102
a 8506 8507 4102
a 8507 8508 4102
a 8508 8509 4102
a 8509 8510 4102
a 8510 8511 4102
a 8511 8512 4102
a 8512 8513 4102
a 8513 8514 4102
a 8514 8515 4102
a 8515 8516 4102
a 8516 8517 4102
a 8517 8518 4102
a 8518 8519 4102
a 8519 8520 4102
a 8520 8521 4102
a 8521 8522 4102
a 8522 8523 4102
a 8523 8524 4102
a 8524 8525 4102
a 8525 8526 4102
a 8526 8527 4102
a 8527 8528 4102
a 8528 8529 4102
a 8529 8530 4102
a 8530 8531 4102
a 8531 8532 4102
a 8532 8533 4102
a 8533 8534 4102
a 8534 8535 4102
a 8535 8536 4102
a 8536 8537 4102
a 8537 8538 4102
a 8538 8539 4102
a 8539 8540 4102
a 8540 8541 4102
a 8541 8542 4102
a 8542 8543 4102
a 8543 8544 4102
a 8544 8545 4102
a 8545 8546 4102
a 8546 8547 4102
a 8547 8548 4102
a 8548 8549 4102
a 8549 8550 4102
a 8550 8551 4102
a 8551 8552 4102
a 8552 8553 4102
a 8553 8554 4102
a 8554 8555 4102
a 8555 8556 4102
a 8556 8557 4102
a 8557 8558 4102
a 8558 8559 4102
a 8559 8560 4102
a 8560 8561 4102
a 8561 8562 4102
a 8562 8563 4102
a 8563 8564 4102
a 8564 8565 4102
a 8565 8566 4102
a 8566 8567 4102
a 8567 8568 4102
a 8568 8569 4102
a 8569 8570 4102
a 8570 8571 4102
a 8571 8572 4102
a 8572 8573 4102
a 8573 8574 4102
a 8574 8575 4102
a 8575 8576 4102
a 8576 8577 4102
a 8577 8578 4102
a 8578 8579 4102
a 8579 8580 4102
a 8580 8581 4102
a 8581 8582 4102
a 8582 8583 4102
a 8583 8584 4102
a 8584 8585 4102
a 8585 8586 4102
a 8586 8587 4102
a 8587 8588 4102
a 8588 8589 4102
a 8589 8590 4102
a 8590 8591 4102
a 8591 8592 4102
a 8592 8593 4102
a 8593 8594 4102
a 8594 8595 4102
a 8595 8596 4102
a 8596 8597 4102
a 8597 8598 4102
a 8598 8599 4102
a 8599 8600 4102
a 8600 8601 4102
a 8601 8602 4102
a 8602 8603 4102
a 8603 8604 4102
a 8604 8605 4102
a 8605 8606 4102
a 8606 8607 4102
a 8607 8608 4102
a 8608 8609 4102
a 8609 8610 4102
a 8610 8611 4102
a 8611 8612 4102
a 8612 8613 4102
a 8613 8614 4102
a 8614 8615 4102
a 8615 8616 4102
a 8616 8617 4102
a 8617 8618 4102
a 8618 8619 4102
a 8619 8620 4102
a 8620 8621 4102
a 8621 8622 4102
a 8622 8623 4102
a 8623 8624 4102
a 8624 8625 4102
a 8625 8626 4102
a 8626 8627 4102
a 8627 8628 4102
a 8628 8629 4102
a 8629 8630 4102
a 8630 8631 4102
a 8631 8632 4102
a 8632 8633 4102
a 8633 8634 4102
a 8634 8635 4102
a 8635 8636 4102
a 8636 8637 4102
a 8637 8638 4102
a 8638 8639 4102
a 8639 8640 4102
a 8640 8641 4102
a 8641 8642 4102
a 8642 8643 4102
a 8643 8644 4102
a 8644 8645 4102
a 8645 8646 4102
a 8646 8647 4102
a 8647 8648 4102
a 8648 8649 4102
a 8649 8650 4102
a 8650 8651 4102
a 8651 8652 4102
a 8652 8653 4102
a 8653 8654 4102
a 8654 8655 4102
a 8655 8656 4102
a 8656 8657 4102
a 8657 8658 4102
a 8658 8659 4102
a 8659 8660 4102
a 8660 8661 4102
a 8661 8662 4102
a 8662 8663 4102
a 8663 8664 4102
a 8664 8665 4102
a 8665 8666 4102
a 8666 8667 4102
a 8667 8668 4102
a 8668 8669 4102
a 8669 8670 4102
a 8670 8671 4102
a 8671 8672 4102
a 8672 8673 4102
a 8673 8674 4102
a 8674 8675 4102
a 8675 8676 4102
a 8676 8677 4102
a 8677 8678 4102
a 8678 8679 4102
a 8679 8680 4102
a 8680 8681 4102
a 8681 8682 4102
a 8682 8683 4102
a 8683 8684 4102
a 8684 8685 4102
a 8685 8686 4102
a 8686 8687 4102
a 8687 8688 4102
a 8688 8689 4102
a 8689 8690 4102
a 8690 8691 4102
a 8691 8692 4102
a 8692 8693 4102
a 8693 8694 4102
a 8694 8695 4102
a 8695 8696 4102
a 8696 8697 4102
a 8697 8698 4102
a 8698 8699 4102
a 8699 8700 4102
a 8700 8701 4102
a 8701 8702 4102
a 8702 8703 4102
a 8703 8704 4102
a 8704 8705 4102
a 8705 8706 4102
a 8706 8707 4102
a 8707 8708 4102
a 8708 8709 4102
a 8709 8710 4102
a 8710 8711 4102
a 8711 8712 4102
a 8712 8713 4102
a 8713 8714 4102
a 8714 8715 4102
a 8715 8716 4102
a 8716 8717 4102
a 8717 8718 4102
a 8718 8719 4102
a 8719 8720 4102
a 8720 8721 4102
a 8721 8722 4102
a 8722 8723 4102
a 8723 8724 4102
a 8724 8725 4102
a 8725 8726 4102
a 8726 8727 4102
a 8727 8728 4102
a 8728 8729 4102
a 8729 8730 4102
a 8730 8731 4102
a 8731 8732 4102
a 8732 8733 4102
a 8733 8734 4102
a 8734 8735 4102
a 8735 8736 4102
a 8736 8737 4102
a 8737 8738 4102
a 8738 8739 4102
a 8739 8740 4102
a 8740 8741 4102
a 8741 8742 4102
a 8742 8743 4102
a 8743 8744 4102
a 8744 8745 4102
a 8745 8746 4102
a 8746 8747 4102
a 8747 8748 4102
a 8748 8749 4102
a 8749 8750 4102
a 8750 8751 4102
a 8751 8752 4102
a 8752 8753 4102
a 8753 8754 4102
a 8754 8755 4102
a 8755 8756 4102
a 8756 8757 4102
a 8757 8758 4102
a 8758 8759 4102
a 8759 8760 4102
a 8760 8761 4102
a 8761 8762 4102
a 8762 8763 4102
a 8763 8764 4102
a 8764 8765 4102
a 8765 8766 4102
a 8766 8767 4102
a 8767 8768 4102
a 8768 8769 4102
a 8769 8770 4102
a 8770 8771 4102
a 8771 8772 4102
a 8772 8773 4102
a 8773 8774 4102
a 8774 8775 4102
a 8775 8776 4102
a 8776 8777 4102
a 8777 8778 4102
a 8778 8779 4102
a 8779 8780 4102
a 8780 8781 4102
a 8781 8782 4102
a 8782 8783 4102
a 8783 8784 4102
a 8784 8785 4102
a 8785 8786 4102
a 8786 8787 4102
a 8787 8788 4102
a 8788 8789 4102
a 8789 8790 4102
a 8790 8791 4102
a 8791 8792 4102
a 8792 8793 4102
a 8793 8794 4102
a 8794 8795 4102
a 8795 8796 4102
a 8796 8797 4102
a 8797 8798 4102
a 8798 8799 4102
a 8799 8800 4102
a 8800 8801 4102
a 8801 8802 4102
a 8802 8803 4102
a 8803 8804 4102
a 8804 8805 4102
a 8805 8806 4102
a 8806 8807 4102
a 8807 8808 4102
a 8808 8809 4102
a 8809 8810 4102
a 8810 8811 4102
a 8811 8812 4102
a 8812 8813 4102
a 8813 8814 4102
a 8814 8815 4102
a 8815 8816 4102
a 8816 8817 4102
a 8817 8818 4102
a 8818 8819 4102
a 8819 8820 4102
a 8820 8821 4102
a 8821 8822 4102
a 8822 8823 4102
a 8823 8824 4102
a 8824 8825 4102
a 8825 8826 4102
a 8826 8827 4102
a 8827 8828 4102
a 8828 8829 4102
a 8829 8830 4102
a 8830 8831 4102
a 8831 8832 4102
a 8832 8833 4102
a 8833 8834 4102
a 8834 8835 4102
a 8835 8836 4102
a 8836 8837 4102
a 8837 8838 4102
a 8838 8839 4102
a 8839 8840 4102
a 8840 8841 4102
a 8841 8842 4102
a 8842 8843 4102
a 8843 8844 4102
a 8844 8845 4102
a 8845 8846 4102
a 8846 8847 4102
a 8847 8848 4102
a 8848 8849 4102
a 8849 8850 4102
a 8850 8851 4102
a 8851 8852 4102
a 8852 8853 4102
a 8853 8854 4102
a 8854 8855 4102
a 8855 8856 4102
a 8856 8857 4102
a 8857 8858 4102
a 8858 8859 4102
a 8859 8860 4102
a 8860 8861 4102
a 8861 8862 4102
a 8862 8863 4102
a 8863 8864 4102
a 8864 8865 4102
a 8865 8866 4102
a 8866 8867 4102
a 8867 8868 4102
a 8868 8869 4102
a 8869 8870 4102
a 8870 8871 4102
a 8871 8872 4102
a 8872 8873 4102
a 8873 8874 4102
a 8874 8875 4102
a 8875 8876 4102
a 8876 8877 4102
a 8877 8878 4102
a 8878 8879 4102
a 8879 8880 4102
a 8880 8881 4102
a 8881 8882 4102
a 8882 8883 4102
a 8883 8884 4102
a 8884 8885 4102
a 8885 8886 4102
a 8886 8887 4102
a 8887 8888 4102
a 8888 8889 4102
a 8889 8890 4102
a 8890 8891 4102
a 8891 8892 4102
a 8892 8893 4102
a 8893 8894 4102
a 8894 8895 4102
a 8895 8896 4102
a 8896 8897 4102
a 8897 8898 4102
a 8898 8899 4102
a 8899 8900 4102
a 8900 8901 4102
a 8901 8902 4102
a 8902 8903 4102
a 8903 8904 4102
a 8904 8905 4102
a 8905 8906 4102
a 8906 8907 4102
a 8907 8908 4102
a 8908 8909 4102
a 8909 8910 4102
a 8910 8911 4102
a 8911 8912 4102
a 8912 8913 4102
a 8913 8914 4102
a 8914 8915 4102
a 8915 8916 4102
a 8916 8917 4102
a 8917 8918 4102
a 8918 8919 4102
a 8919 8920 4102
a 8920 8921 4102
a 8921 8922 4102
a 8922 8923 4102
a 8923 8924 4102
a 8924 8925 4102
a 8925 8926 4102
a 8926 8927 4102
a 8927 8928 4102
a 8928 8929 4102
a 8929 8930 4102
a 8930 8931 4102
a 8931 8932 4102
a 8932 8933 4102
a 8933 8934 4102
a 8934 8935 4102
a 8935 8936 4102
a 8936 8937 4102
a 8937 8938 4102
a 8938 8939 4102
a 8939 8940 4102
a 8940 8941 4102
a 8941 8942 4102
a 8942 8943 4102
a 8943 8944 4102
a 8944 8945 4102
a 8945 8946 4102
a 8946 8947 4102
a 8947 8948 4102
a 8948 8949 4102
a 8949 8950 4102
a 8950 8951 4102
a 8951 8952 4102
a 8952 8953 4102
a 8953 8954 4102
a 8954 8955 4102
a 8955 8956 4102
a 8956 8957 4102
a 8957 8958 4102
a 8958 8959 4102
a 8959 8960 4102
a 8960 8961 4102
a 8961 8962 4102
a 8962 8963 4102
a 8963 8964 4102
a 8964 8965 4102
a 8965 8966 4102
a 8966 8967 4102
a 8967 8968 4102
a 8968 8969 4102
a 8969 8970 4102
a 8970 8971 4102
a 8971 8972 4102
a 8972 8973 4102
a 8973 8974 4102
a 8974 8975 4102
a 8975 8976 4102
a 8976 8977 4102
a 8977 8978 4102
a 8978 8979 4102
a 8979 8980 4102
a 8980 8981 4102
a 8981 8982 4102
a 8982 8983 4102
a 8983 8984 4102
a 8984 8985 4102
a 8985 8986 4102
a 8986 8987 4102
a 8987 8988 4102
a 8988 8989 4102
a 8989 8990 4102
a 8990 8991 4102
a 8991 8992 4102
a 8992 8993 4102
a 8993 8994 4102
a 8994 8995 4102
a 8995 8996 4102
a 8996 8997 4102
a 8997 8998 4102
a 8998 8999 4102
a 8999 9000 4102
a 9000 9001 4102
a 9001 9002 4102
a 9002 9003 4102
a 9003 9004 4102
a 9004 9005 4102
a 9005 9006 4102
a 9006 9007 4102
a 9007 9008 4102
a 9008 9009 4102
a 9009 9010 4102
a 9010 9011 4102
a 9011 9012 4102
a 9012 9013 4102
a 9013 9014 4102
a 9014 9015 4102
a 9015 9016 4102
a 9016 9017 4102
a 9017 9018 4102
a 9018 9019 4102
a 9019 9020 4102
a 9020 9021 4102
a 9021 9022 4102
a 9022 9023 4102
a 9023 9024 4102
a 9024 9025 4102
a 9025 9026 4102
a 9026 9027 4102
a 9027 9028 4102
a 9028 9029 4102
a 9029 9030 4102
a 9030 9031 4102
a 9031 9032 4102
a 9032 9033 4102
a 9033 9034 4102
a 9034 9035 4102
a 9035 9036 4102
a 9036 9037 4102
a 9037 9038 4102
a 9038 9039 4102
a 9039 9040 4102
a 9040 9041 4102
a 9041 9042 4102
a 9042 9043 4102
a 9043 9044 4102
a 9044 9045 4102
a 9045 9046 4102
a 9046 9047 4102
a 9047 9048 4102
a 9048 9049 4102
a 9049 9050 4102
a 9050 9051 4102
a 9051 9052 4102
a 9052 9053 4102
a 9053 9054 4102
a 9054 9055 4102
a 9055 9056 4102
a 9056 9057 4102
a 9057 9058 4102
a 9058 9059 4102
a 9059 9060 4102
a 9060 9061 4102
a 9061 9062 4102
a 9062 9063 4102
a 9063 9064 4102
a 9064 9065 4102
a 9065 9066 4102
a 9066 9067 4102
a 9067 9068 4102
a 9068 9069 4102
a 9069 9070 4102
a 9070 9071 4102
a 9071 9072 4102
a 9072 9073 4102
a 9073 9074 4102
a 9074 9075 4102
a 9075 9076 4102
a 9076 9077 4102
a 9077 9078 4102
a 9078 9079 4102
a 9079 9080 4102
a 9080 9081 4102
a 9081 9082 4102
a 9082 9083 4102
a 9083 9084 4102
a 9084 9085 4102
a 9085 9086 4102
a 9086 9087 4102
a 9087 9088 4102
a 9088 9089 4102
a 9089 9090 4102
a 9090 9091 4102
a 9091 9092 4102
a 9092 9093 4102
a 9093 9094 4102
a 9094 9095 4102
a 9095 9096 4102
a 9096 9097 4102
a 9097 9098 4102
a 9098 9099 4102
a 9099 9100 4102
a 9100 9101 4102
a 9101 9102 4102
a 9102 9103 4102
a 9103 9104 4102
a 9104 9105 4102
a 9105 9106 4102
a 9106 9107 4102
a 9107 9108 4102
a 9108 9109 4102
a 9109 9110 4102
a 9110 9111 4102
a 9111 9112 4102
a 9112 9113 4102
a 9113 9114 4102
a 9114 9115 4102
a 9115 9116 4102
a 9116 9117 4102
a 9117 9118 4102
a 9118 9119 4102
a 9119 9120 4102
a 9120 9121 4102
a 9121 9122 4102
a 9122 9123 4102
a 9123 9124 4102
a 9124 9125 4102
a 9125 9126 4102
a 9126 9127 4102
a 9127 9128 4102
a 9128 9129 4102
a 9129 9130 4102
a 9130 9131 4102
a 9131 9132 4102
a 9132 9133 4102
a 9133 9134 4102
a 9134 9135 4102
a 9135 9136 4102
a 9136 9137 4102
a 9137 9138 4102
a 9138 9139 4102
a 9139 9140 4102
a 9140 9141 4102
a 9141 9142 4102
a 9142 9143 4102
a 9143 9144 4102
a 9144 9145 4102
a 9145 9146 4102
a 9146 9147 4102
a 9147 9148 4102
a 9148 9149 4102
a 9149 9150 4102
a 9150 9151 4102
a 9151 9152 4102
a 9152 9153 4102
a 9153 9154 4102
a 9154 9155 4102
a 9155 9156 4102
a 9156 9157 4102
a 9157 9158 4102
a 9158 9159 4102
a 9159 9160 4102
a 9160 9161 4102
a 9161 9162 4102
a 9162 9163 4102
a 9163 9164 4102
a 9164 9165 4102
a 9165 9166 4102
a 9166 9167 4102
a 9167 9168 4102
a 9168 9169 4102
a 9169 9170 4102
a 9170 9171 4102
a 9171 9172 4102
a 9172 9173 4102
a 9173 9174 4102
a 9174 9175 4102
a 9175 9176 4102
a 9176 9177 4102
a 9177 9178 4102
a 9178 9179 4102
a 9179 9180 4102
a 9180 9181 4102
a 9181 9182 4102
a 9182 9183 4102
a 9183 9184 4102
a 9184 9185 4102
a 9185 9186 4102
a 9186 9187 4102
a 9187 9188 4102
a 9188 9189 4102
a 9189 9190 4102
a 9190 9191 4102
a 9191 9192 4102
a 9192 9193 4102
a 9193 9194 4102
a 9194 9195 4102
a 9195 9196 4102
a 9196 9197 4102
a 9197 9198 4102
a 9198 9199 4102
a 9199 9200 4102
a 9200 9201 4102
a 9201 9202 4102
a 9202 9203 4102
a 9203 9204 4102
a 9204 9205 4102
a 9205 9206 4102
a 9206 9207 4102
a 9207 9208 4102
a 9208 9209 4102
a 9209 9210 4102
a 9210 9211 4102
a 9211 9212 4102
a 9212 9213 4102
a 9213 9214 4102
a 9214 9215 4102
a 9215 9216 4102
a 9216 9217 4102
a 9217 9218 4102
a 9218 9219 4102
a 9219 9220 4102
a 9220 9221 4102
a 9221 9222 4102
a 9222 9223 4102
a 9223 9224 4102
a 9224 9225 4102
a 9225 9226 4102
a 9226 9227 4102
a 9227 9228 4102
a 9228 9229 4102
a 9229 9230 4102
a 9230 9231 4102
a 9231 9232 4102
a 9232 9233 4102
a 9233 9234 4102
a 9234 9235 4102
a 9235 9236 4102
a 9236 9237 4102
a 9237 9238 4102
a 9238 9239 4102
a 9239 9240 4102
a 9240 9241 4102
a 9241 9242 4102
a 9242 9243 4102
a 9243 9244 4102
a 9244 9245 4102
a 9245 9246 4102
a 9246 9247 4102
a 9247 9248 4102
a 9248 9249 4102
a 9249 9250 4102
a 9250 9251 4102
a 9251 9252 4102
a 9252 9253 4102
a 9253 9254 4102
a 9254 9255 4102
a 9255 9256 4102
a 9256 9257 4102
a 9257 9258 4102
a 9258 9259 4102
a 9259 9260 4102
a 9260 9261 4102
a 9261 9262 4102
a 9262 9263 4102
a 9263 9264 4102
a 9264 9265 4102
a 9265 9266 4102
a 9266 9267 4102
a 9267 9268 4102
a 9268 9269 4102
a 9269 9270 4102
a 9270 9271 4102
a 9271 9272 4102
a 9272 9273 4102
a 9273 9274 4102
a 9274 9275 4102
a 9275 9276 4102
a 9276 9277 4102
a 9277 9278 4102
a 9278 9279 4102
a 9279 9280 4102
a 9280 9281 4102
a 9281 9282 4102
a 9282 9283 4102
a 9283 9284 4102
a 9284 9285 4102
a 9285 9286 4102
a 9286 9287 4102
a 9287 9288 4102
a 9288 9289 4102
a 9289 9290 4102
a 9290 9291 4102
a 9291 9292 4102
a 9292 9293 4102
a 9293 9294 4102
a 9294 9295 4102
a 9295 9296 4102
a 9296 9297 4102
a 9297 9298 4102
a 9298 9299 4102
a 9299 9300 4102
a 9300 9301 4102
a 9301 9302 4102
a 9302 9303 4102
a 9303 9304 4102
a 9304 9305 4102
a 9305 9306 4102
a 9306 9307 4102
a 9307 9308 4102
a 9308 9309 4102
a 9309 9310 4102
a 9310 9311 4102
a 9311 9312 4102
a 9312 9313 4102
a 9313 9314 4102
a 9314 9315 4102
a 9315 9316 4102
a 9316 9317 4102
a 9317 9318 4102
a 9318 9319 4102
a 9319 9320 4102
a 9320 9321 4102
a 9321 9322 4102
a 9322 9323 4102
a 9323 9324 4102
a 9324 9325 4102
a 9325 9326 4102
a 9326 9327 4102
a 9327 9328 4102
a 9328 9329 4102
a 9329 9330 4102
a 9330 9331 4102
a 9331 9332 4102
a 9332 9333 4102
a 9333 9334 4102
a 9334 9335 4102
a 9335 9336 4102
a 9336 9337 4102
a 9337 9338 4102
a 9338 9339 4102
a 9339 9340 4102
a 9340 9341 4102
a 9341 9342 4102
a 9342 9343 4102
a 9343 9344 4102
a 9344 9345 4102
a 9345 9346 4102
a 9346 9347 4102
a 9347 9348 4102
a 9348 9349 4102
a 9349 9350 4102
a 9350 9351 4102
a 9351 9352 4102
a 9352 9353 4102
a 9353 9354 4102
a 9354 9355 4102
a 9355 9356 4102
a 9356 9357 4102
a 9357 9358 4102
a 9358 9359 4102
a 9359 9360 4102
a 9360 9361 4102
a 9361 9362 4102
a 9362 9363 4102
a 9363 9364 4102
a 9364 9365 4102
a 9365 9366 4102
a 9366 9367 4102
a 9367 9368 4102
a 9368 9369 4102
a 9369 9370 4102
a 9370 9371 4102
a 9371 9372 4102
a 9372 9373 4102
a 9373 9374 4102
a 9374 9375 4102
a 9375 9376 4102
a 9376 9377 4102
a 9377 9378 4102
a 9378 9379 4102
a 9379 9380 4102
a 9380 9381 4102
a 9381 9382 4102
a 9382 9383 4102
a 9383 9384 4102
a 9384 9385 4102
a 9385 9386 4102
a 9386 9387 4102
a 9387 9388 4102
a 9388 9389 4102
a 9389 9390 4102
a 9390 9391 4102
a 9391 9392 4102
a 9392 9393 4102
a 9393 9394 4102
a 9394 9395 4102
a 9395 9396 4102
a 9396 9397 4102
a 9397 9398 4102
a 9398 9399 4102
a 9399 9400 4102
a 9400 9401 4102
a 9401 9402 4102
a 9402 9403 4102
a 9403 9404 4102
a 9404 9405 4102
a 9405 9406 4102
a 9406 9407 4102
a 9407 9408 4102
a 9408 9409 4102
a 9409 9410 4102
a 9410 9411 4102
a 9411 9412 4102
a 9412 9413 4102
a 9413 9414 4102
a 9414 9415 4102
a 9415 9416 4102
a 9416 9417 4102
a 9417 9418 4102
a 9418 9419 4102
a 9419 9420 4102
a 9420 9421 4102
a 9421 9422 4102
a 9422 9423 4102
a 9423 9424 4102
a 9424 9425 4102
a 9425 9426 4102
a 9426 9427 4102
a 9427 9428 4102
a 9428 9429 4102
a 9429 9430 4102
a 9430 9431 4102
a 9431 9432 4102
a 9432 9433 4102
a 9433 9434 4102
a 9434 9435 4102
a 9435 9436 4102
a 9436 9437 4102
a 9437 9438 4102
a 9438 9439 4102
a 9439 9440 4102
a 9440 9441 4102
a 9441 9442 4102
a 9442 9443 4102
a 9443 9444 4102
a 9444 9445 4102
a 9445 9446 4102
a 9446 9447 4102
a 9447 9448 4102
a 9448 9449 4102
a 9449 9450 4102
a 9450 9451 4102
a 9451 9452 4102
a 9452 9453 4102
a 9453 9454 4102
a 9454 9455 4102
a 9455 9456 4102
a 9456 9457 4102
a 9457 9458 4102
a 9458 9459 4102
a 9459 9460 4102
a 9460 9461 4102
a 9461 9462 4102
a 9462 9463 4102
a 9463 9464 4102
a 9464 9465 4102
a 9465 9466 4102
a 9466 9467 4102
a 9467 9468 4102
a 9468 9469 4102
a 9469 9470 4102
a 9470 9471 4102
a 9471 9472 4102
a 9472 9473 4102
a 9473 9474 4102
a 9474 9475 4102
a 9475 9476 4102
a 9476 9477 4102
a 9477 9478 4102
a 9478 9479 4102
a 9479 9480 4102
a 9480 9481 4102
a 9481 9482 4102
a 9482 9483 4102
a 9483 9484 4102
a 9484 9485 4102
a 9485 9486 4102
a 9486 9487 4102
a 9487 9488 4102
a 9488 9489 4102
a 9489 9490 4102
a 9490 9491 4102
a 9491 9492 4102
a 9492 9493 4102
a 9493 9494 4102
a 9494 9495 4102
a 9495 9496 4102
a 9496 9497 4102
a 9497 9498 4102
a 9498 9499 4102
a 9499 9500 4102
a 9500 9501 4102
a 9501 9502 4102
a 9502 9503 4102
a 9503 9504 4102
a 9504 9505 4102
a 9505 9506 4102
a 9506 9507 4102
a 9507 9508 4102
a 9508 9509 4102
a 9509 9510 4102
a 9510 9511 4102
a 9511 9512 4102
a 9512 9513 4102
a 9513 9514 4102
a 9514 9515 4102
a 9515 9516 4102
a 9516 9517 4102
a 9517 9518 4102
a 9518 9519 4102
a 9519 9520 4102
a 9520 9521 4102
a 9521 9522 4102
a 9522 9523 4102
a 9523 9524 4102
a 9524 9525 4102
a 9525 9526 4102
a 9526 9527 4102
a 9527 9528 4102
a 9528 9529 4102
a 9529 9530 4102
a 9530 9531 4102
a 9531 9532 4102
a 9532 9533 4102
a 9533 9534 4102
a 9534 9535 4102
a 9535 9536 4102
a 9536 9537 4102
a 9537 9538 4102
a 9538 9539 4102
a 9539 9540 4102
a 9540 9541 4102
a 9541 9542 4102
a 9542 9543 4102
a 9543 9544 4102
a 9544 9545 4102
a 9545 9546 4102
a 9546 9547 4102
a 9547 9548 4102
a 9548 9549 4102
a 9549 9550 4102
a 9550 9551 4102
a 9551 9552 4102
a 9552 9553 4102
a 9553 9554 4102
a 9554 9555 4102
a 9555 9556 4102
a 9556 9557 4102
a 9557 9558 4102
a 9558 9559 4102
a 9559 9560 4102
a 9560 9561 4102
a 9561 9562 4102
a 9562 9563 4102
a 9563 9564 4102
a 9564 9565 4102
a 9565 9566 4102
a 9566 9567 4102
a 9567 9568 4102
a 9568 9569 4102
a 9569 9570 4102
a 9570 9571 4102
a 9571 9572 4102
a 9572 9573 4102
a 9573 9574 4102
a 9574 9575 4102
a 9575 9576 4102
a 9576 9577 4102
a 9577 9578 4102
a 9578 9579 4102
a 9579 9580 4102
a 9580 9581 4102
a 9581 9582 4102
a 9582 9583 4102
a 9583 9584 4102
a 9584 9585 4102
a 9585 9586 4102
a 9586 9587 4102
a 9587 9588 4102
a 9588 9589 4102
a 9589 9590 4102
a 9590 9591 4102
a 9591 9592 4102
a 9592 9593 4102
a 9593 9594 4102
a 9594 9595 4102
a 9595 9596 4102
a 9596 9597 4102
a 9597 9598 4102
a 9598 9599 4102
a 9599 9600 4102
a 9600 9601 4102
a 9601 9602 4102
a 9602 9603 4102
a 9603 9604 4102
a 9604 9605 4102
a 9605 9606 4102
a 9606 9607 4102
a 9607 9608 4102
a 9608 9609 4102
a 9609 9610 4102
a 9610 9611 4102
a 9611 9612 4102
a 9612 9613 4102
a 9613 9614 4102
a 9614 9615 4102
a 9615 9616 4102
a 9616 9617 4102
a 9617 9618 4102
a 9618 9619 4102
a 9619 9620 4102
a 9620 9621 4102
a 9621 9622 4102
a 9622 9623 4102
a 9623 9624 4102
a 9624 9625 4102
a 9625 9626 4102
a 9626 9627 4102
a 9627 9628 4102
a 9628 9629 4102
a 9629 9630 4102
a 9630 9631 4102
a 9631 9632 4102
a 9632 9633 4102
a 9633 9634 4102
a 9634 9635 4102
a 9635 9636 4102
a 9636 9637 4102
a 9637 9638 4102
a 9638 9639 4102
a 9639 9640 4102
a 9640 9641 4102
a 9641 9642 4102
a 9642 9643 4102
a 9643 9644 4102
a 9644 9645 4102
a 9645 9646 4102
a 9646 9647 4102
a 9647 9648 4102
a 9648 9649 4102
a 9649 9650 4102
a 9650 9651 4102
a 9651 9652 4102
a 9652 9653 4102
a 9653 9654 4102
a 9654 9655 4102
a 9655 9656 4102
a 9656 9657 4102
a 9657 9658 4102
a 9658 9659 4102
a 9659 9660 4102
a 9660 9661 4102
a 9661 9662 4102
a 9662 9663 4102
a 9663 9664 4102
a 9664 9665 4102
a 9665 9666 4102
a 9666 9667 4102
a 9667 9668 4102
a 9668 9669 4102
a 9669 9670 4102
a 9670 9671 4102
a 9671 9672 4102
a 9672 9673 4102
a 9673 9674 4102
a 9674 9675 4102
a 9675 9676 4102
a 9676 9677 4102
a 9677 9678 4102
a 9678 9679 4102
a 9679 9680 4102
a 9680 9681 4102
a 9681 9682 4102
a 9682 9683 4102
a 9683 9684 4102
a 9684 9685 4102
a 9685 9686 4102
a 9686 9687 4102
a 9687 9688 4102
a 9688 9689 4102
a 9689 9690 4102
a 9690 9691 4102
a 9691 9692 4102
a 9692 9693 4102
a 9693 9694 4102
a 9694 9695 4102
a 9695 9696 4102
a 9696 9697 4102
a 9697 9698 4102
a 9698 9699 4102
a 9699 9700 4102
a 9700 9701 4102
a 9701 9702 4102
a 9702 9703 4102
a 9703 9704 4102
a 9704 9705 4102
a 9705 9706 4102
a 9706 9707 4102
a 9707 9708 4102
a 9708 9709 4102
a 9709 9710 4102
a 9710 9711 4102
a 9711 9712 4102
a 9712 9713 4102
a 9713 9714 4102
a 9714 9715 4102
a 9715 9716 4102
a 9716 9717 4102
a 9717 9718 4102
a 9718 9719 4102
a 9719 9720 4102
a 9720 9721 4102
a 9721 9722 4102
a 9722 9723 4102
a 9723 9724 4102
a 9724 9725 4102
a 9725 9726 4102
a 9726 9727 4102
a 9727 9728 4102
a 9728 9729 4102
a 9729 9730 4102
a 9730 9731 4102
a 9731 9732 4102
a 9732 9733 4102
a 9733 9734 4102
a 9734 9735 4102
a 9735 9736 4102
a 9736 9737 4102
a 9737 9738 4102
a 9738 9739 4102
a 9739 9740 4102
a 9740 9741 4102
a 9741 9742 4102
a 9742 9743 4102
a 9743 9744 4102
a 9744 9745 4102
a 9745 9746 4102
a 9746 9747 4102
a 9747 9748 4102
a 9748 9749 4102
a 9749 9750 4102
a 9750 9751 4102
a 9751 9752 4102
a 9752 9753 4102
a 9753 9754 4102
a 9754 9755 4102
a 9755 9756 4102
a 9756 9757 4102
a 9757 9758 4102
a 9758 9759 4102
a 9759 9760 4102
a 9760 9761 4102
a 9761 9762 4102
a 9762 9763 4102
a 9763 9764 4102
a 9764 9765 4102
a 9765 9766 4102
a 9766 9767 4102
a 9767 9768 4102
a 9768 9769 4102
a 9769 9770 4102
a 9770 9771 4102
a 9771 9772 4102
a 9772 9773 4102
a 9773 9774 4102
a 9774 9775 4102
a 9775 9776 4102
a 9776 9777 4102
a 9777 9778 4102
a 9778 9779 4102
a 9779 9780 4102
a 9780 9781 4102
a 9781 9782 4102
a 9782 9783 4102
a 9783 9784 4102
a 9784 9785 4102
a 9785 9786 4102
a 9786 9787 4102
a 9787 9788 4102
a 9788 9789 4102
a 9789 9790 4102
a 9790 9791 4102
a 9791 9792 4102
a 9792 9793 4102
a 9793 9794 4102
a 9794 9795 4102
a 9795 9796 4102
a 9796 9797 4102
a 9797 9798 4102
a 9798 9799 4102
a 9799 9800 4102
a 9800 9801 4102
a 9801 9802 4102
a 9802 9803 4102
a 9803 9804 4102
a 9804 9805 4102
a 9805 9806 4102
a 9806 9807 4102
a 9807 9808 4102
a 9808 9809 4102
a 9809 9810 4102
a 9810 9811 4102
a 9811 9812 4102
a 9812 9813 4102
a 9813 9814 4102
a 9814 9815 4102
a 9815 9816 4102
a 9816 9817 4102
a 9817 9818 4102
a 9818 9819 4102
a 9819 9820 4102
a 9820 9821 4102
a 9821 9822 4102
a 9822 9823 4102
a 9823 9824 4102
a 9824 9825 4102
a 9825 9826 4102
a 9826 9827 4102
a 9827 9828 4102
a 9828 9829 4102
a 9829 9830 4102
a 9830 9831 4102
a 9831 9832 4102
a 9832 9833 4102
a 9833 9834 4102
a 9834 9835 4102
a 9835 9836 4102
a 9836 9837 4102
a 9837 9838 4102
a 9838 9839 4102
a 9839 9840 4102
a 9840 9841 4102
a 9841 9842 4102
a 9842 9843 4102
a 9843 9844 4102
a 9844 9845 4102
a 9845 9846 4102
a 9846 9847 4102
a 9847 9848 4102
a 9848 9849 4102
a 9849 9850 4102
a 9850 9851 4102
a 9851 9852 4102
a 9852 9853 4102
a 9853 9854 4102
a 9854 9855 4102
a 9855 9856 4102
a 9856 9857 4102
a 9857 9858 4102
a 9858 9859 4102
a 9859 9860 4102
a 9860 9861 4102
a 9861 9862 4102
a 9862 9863 4102
a 9863 9864 4102
a 9864 9865 4102
a 9865 9866 4102
a 9866 9867 4102
a 9867 9868 4102
a 9868 9869 4102
a 9869 9870 4102
a 9870 9871 4102
a 9871 9872 4102
a 9872 9873 4102
a 9873 9874 4102
a 9874 9875 4102
a 9875 9876 4102
a 9876 9877 4102
a 9877 9878 4102
a 9878 9879 4102
a 9879 9880 4102
a 9880 9881 4102
a 9881 9882 4102
a 9882 9883 4102
a 9883 9884 4102
a 9884 9885 4102
a 9885 9886 4102
a 9886 9887 4102
a 9887 9888 4102
a 9888 9889 4102
a 9889 9890 4102
a 9890 9891 4102
a 9891 9892 4102
a 9892 9893 4102
a 9893 9894 4102
a 9894 9895 4102
a 9895 9896 4102
a 9896 9897 4102
a 9897 9898 4102
a 9898 9899 4102
a 9899 9900 4102
a 9900 9901 4102
a 9901 9902 4102
a 9902 9903 4102
a 9903 9904 4102
a 9904 9905 4102
a 9905 9906 4102
a 9906 9907 4102
a 9907 9908 4102
a 9908 9909 4102
a 9909 9910 4102
a 9910 9911 4102
a 9911 9912 4102
a 9912 9913 4102
a 9913 9914 4102
a 9914 9915 4102
a 9915 9916 4102
a 9916 9917 4102
a 9917 9918 4102
a 9918 9919 4102
a 9919 9920 4102
a 9920 9921 4102
a 9921 9922 4102
a 9922 9923 4102
a 9923 9924 4102
a 9924 9925 4102
a 9925 9926 4102
a 9926 9927 4102
a 9927 9928 4102
a 9928 9929 4102
a 9929 9930 4102
a 9930 9931 4102
a 9931 9932 4102
a 9932 9933 4102
a 9933 9934 4102
a 9934 9935 4102
a 9935 9936 4102
a 9936 9937 4102
a 9937 9938 4102
a 9938 9939 4102
a 9939 9940 4102
a 9940 9941 4102
a 9941 9942 4102
a 9942 9943 4102
a 9943 9944 4102
a 9944 9945 4102
a 9945 9946 4102
a 9946 9947 4102
a 9947 9948 4102
a 9948 9949 4102
a 9949 9950 4102
a 9950 9951 4102
a 9951 9952 4102
a 9952 9953 4102
a 9953 9954 4102
a 9954 9955 4102
a 9955 9956 4102
a 9956 9957 4102
a 9957 9958 4102
a 9958 9959 4102
a 9959 9960 4102
a 9960 9961 4102
a 9961 9962 4102
a 9962 9963 4102
a 9963 9964 4102
a 9964 9965 4102
a 9965 9966 4102
a 9966 9967 4102
a 9967 9968 4102
a 9968 9969 4102
a 9969 9970 4102
a 9970 9971 4102
a 9971 9972 4102
a 9972 9973 4102
a 9973 9974 4102
a 9974 9975 4102
a 9975 9976 4102
a 9976 9977 4102
a 9977 9978 4102
a 9978 9979 4102
a 9979 9980 4102
a 9980 9981 4102
a 9981 9982 4102
a 9982 9983 4102
a 9983 9984 4102
a 9984 9985 4102
a 9985 9986 4102
a 9986 9987 4102
a 9987 9988 4102
a 9988 9989 4102
a 9989 9990 4102
a 9990 9991 4102
a 9991 9992 4102
a 9992 9993 4102
a 9993 9994 4102
a 9994 9995 4102
a 9995 9996 4102
a 9996 9997 4102
a 9997 9998 4102
a 9998 9999 4102
a 9999 10000 4102
a 10000 10001 4102
a 10001 10002 4102
a 10002 10003 4102
a 10003 10004 4102
a 10004 10005 4102
a 10005 10006 4102
a 10006 10007 4102
a 10007 10008 4102
a 10008 10009 4102
a 10009 10010 4102
a 10010 10011 4102
a 10011 10012 4102
a 10012 10013 4102
a 10013 10014 4102
a 10014 10015 4102
a 10015 10016 4102
a 10016 10017 4102
a 10017 10018 4102
a 10018 10019 4102
a 10019 10020 4102
a 10020 10021 4102
a 10021 10022 4102
a 10022 10023 4102
a 10023 10024 4102
a 10024 10025 4102
a 10025 10026 4102
a 10026 10027 4102
a 10027 10028 4102
a 10028 10029 4102
a 10029 10030 4102
a 10030 10031 4102
a 10031 10032 4102
a 10032 10033 4102
a 10033 10034 4102
a 10034 10035 4102
a 10035 10036 4102
a 10036 10037 4102
a 10037 10038 4102
a 10038 10039 4102
a 10039 10040 4102
a 10040 10041 4102
a 10041 10042 4102
a 10042 10043 4102
a 10043 10044 4102
a 10044 10045 4102
a 10045 10046 4102
a 10046 10047 4102
a 10047 10048 4102
a 10048 10049 4102
a 10049 10050 4102
a 10050 10051 4102
a 10051 10052 4102
a 10052 10053 4102
a 10053 10054 4102
a 10054 10055 4102
a 10055 10056 4102
a 10056 10057 4102
a 10057 10058 4102
a 10058 10059 4102
a 10059 10060 4102
a 10060 10061 4102
a 10061 10062 4102
a 10062 10063 4102
a 10063 10064 4102
a 10064 10065 4102
a 10065 10066 4102
a 10066 10067 4102
a 10067 10068 4102
a 10068 10069 4102
a 10069 10070 4102
a 10070 10071 4102
a 10071 10072 4102
a 10072 10073 4102
a 10073 10074 4102
a 10074 10075 4102
a 10075 10076 4102
a 10076 10077 4102
a 10077 10078 4102
a 10078 10079 4102
a 10079 10080 4102
a 10080 10081 4102
a 10081 10082 4102
a 10082 10083 4102
a 10083 10084 4102
a 10084 10085 4102
a 10085 10086 4102
a 10086 10087 4102
a 10087 10088 4102
a 10088 10089 4102
a 10089 10090 4102
a 10090 10091 4102
a 10091 10092 4102
a 10092 10093 4102
a 10093 10094 4102
a 10094 10095 4102
a 10095 10096 4102
a 10096 10097 4102
a 10097 10098 4102
a 10098 10099 4102
a 10099 10100 4102
a 10100 10101 4102
a 10101 10102 4102
a 10102 10103 4102
a 10103 10104 4102
a 10104 10105 4102
a 10105 10106 4102
a 10106 10107 4102
a 10107 10108 4102
a 10108 10109 4102
a 10109 10110 4102
a 10110 10111 4102
a 10111 10112 4102
a 10112 10113 4102
a 10113 10114 4102
a 10114 10115 4102
a 10115 10116 4102
a 10116 10117 4102
a 10117 10118 4102
a 10118 10119 4102
a 10119 10120 4102
a 10120 10121 4102
a 10121 10122 4102
a 10122 10123 4102
a 10123 10124 4102
a 10124 10125 4102
a 10125 10126 4102
a 10126 10127 4102
a 10127 10128 4102
a 10128 10129 4102
a 10129 10130 4102
a 10130 10131 4102
a 10131 10132 4102
a 10132 10133 4102
a 10133 10134 4102
a 10134 10135 4102
a 10135 10136 4102
a 10136 10137 4102
a 10137 10138 4102
a 10138 10139 4102
a 10139 10140 4102
a 10140 10141 4102
a 10141 10142 4102
a 10142 10143 4102
a 10143 10144 4102
a 10144 10145 4102
a 10145 10146 4102
a 10146 10147 4102
a 10147 10148 4102
a 10148 10149 4102
a 10149 10150 4102
a 10150 10151 4102
a 10151 10152 4102
a 10152 10153 4102
a 10153 10154 4102
a 10154 10155 4102
a 10155 10156 4102
a 10156 10157 4102
a 10157 10158 4102
a 10158 10159 4102
a 10159 10160 4102
a 10160 10161 4102
a 10161 10162 4102
a 10162 10163 4102
a 10163 10164 4102
a 10164 10165 4102
a 10165 10166 4102
a 10166 10167 4102
a 10167 10168 4102
a 10168 10169 4102
a 10169 10170 4102
a 10170 10171 4102
a 10171 10172 4102
a 10172 10173 4102
a 10173 10174 4102
a 10174 10175 4102
a 10175 10176 4102
a 10176 10177 4102
a 10177 10178 4102
a 10178 10179 4102
a 10179 10180 4102
a 10180 10181 4102
a 10181 10182 4102
a 10182 10183 4102
a 10183 10184 4102
a 10184 10185 4102
a 10185 10186 4102
a 10186 10187 4102
a 10187 10188 4102
a 10188 10189 4102
a 10189 10190 4102
a 10190 10191 4102
a 10191 10192 4102
a 10192 10193 4102
a 10193 10194 4102
a 10194 10195 4102
a 10195 10196 4102
a 10196 10197 4102
a 10197 10198 4102
a 10198 10199 4102
a 10199 10200 4102
a 10200 10201 4102
a 10201 10202 4102
a 10202 10203 4102
a 10203 10204 4102
a 10204 10205 4102
a 10205 10206 4102
a 10206 10207 4102
a 10207 10208 4102
a 10208 10209 4102
a 10209 10210 4102
a 10210 10211 4102
a 10211 10212 4102
a 10212 10213 4102
a 10213 10214 4102
a 10214 10215 4102
a 10215 10216 4102
a 10216 10217 4102
a 10217 10218 4102
a 10218 10219 4102
a 10219 10220 4102
a 10220 10221 4102
a 10221 10222 4102
a 10222 10223 4102
a 10223 10224 4102
a 10224 10225 4102
a 10225 10226 4102
a 10226 10227 4102
a 10227 10228 4102
a 10228 10229 4102
a 10229 10230 4102
a 10230 10231 4102
a 10231 10232 4102
a 10232 10233 4102
a 10233 10234 4102
a 10234 10235 4102
a 10235 10236 4102
a 10236 10237 4102
a 10237 10238 4102
a 10238 10239 4102
a 10239 10240 4102
a 10240 10241 4102
a 10241 10242 4102
a 10242 10243 4102
a 10243 10244 4102
a 10244 10245 4102
a 10245 10246 4102
a 10246 10247 4102
a 10247 10248 4102
a 10248 10249 4102
a 10249 10250 4102
a 10250 10251 4102
a 10251 10252 4102
a 10252 10253 4102
a 10253 10254 4102
a 10254 10255 4102
a 10255 10256 4102
a 10256 10257 4102
a 10257 10258 4102
a 10258 10259 4102
a 10259 10260 4102
a 10260 10261 4102
a 10261 10262 4102
a 10262 10263 4102
a 10263 10264 4102
a 10264 10265 4102
a 10265 10266 4102
a 10266 10267 4102
a 10267 10268 4102
a 10268 10269 4102
a 10269 10270 4102
a 10270 10271 4102
a 10271 10272 4102
a 10272 10273 4102
a 10273 10274 4102
a 10274 10275 4102
a 10275 10276 4102
a 10276 10277 4102
a 10277 10278 4102
a 10278 10279 4102
a 10279 10280 4102
a 10280 10281 4102
a 10281 10282 4102
a 10282 10283 4102
a 10283 10284 4102
a 10284 10285 4102
a 10285 10286 4102
a 10286 10287 4102
a 10287 10288 4102
a 10288 10289 4102
a 10289 10290 4102
a 10290 10291 4102
a 10291 10292 4102
a 10292 10293 4102
a 10293 10294 4102
a 10294 10295 4102
a 10295 10296 4102
a 10296 10297 4102
a 10297 10298 4102
a 10298 10299 4102
a 10299 10300 4102
a 10300 10301 4102
a 10301 10302 4102
a 10302 10303 4102
a 10303 10304 4102
a 10304 10305 4102
a 10305 10306 4102
a 10306 10307 4102
a 10307 10308 4102
a 10308 10309 4102
a 10309 10310 4102
a 10310 10311 4102
a 10311 10312 4102
a 10312 10313 4102
a 10313 10314 4102
a 10314 10315 4102
a 10315 10316 4102
a 10316 10317 4102
a 10317 10318 4102
a 10318 10319 4102
a 10319 10320 4102
a 10320 10321 4102
a 10321 10322 4102
a 10322 10323 4102
a 10323 10324 4102
a 10324 10325 4102
a 10325 10326 4102
a 10326 10327 4102
a 10327 10328 4102
a 10328 10329 4102
a 10329 10330 4102
a 10330 10331 4102
a 10331 10332 4102
a 10332 10333 4102
a 10333 10334 4102
a 10334 10335 4102
a 10335 10336 4102
a 10336 10337 4102
a 10337 10338 4102
a 10338 10339 4102
a 10339 10340 4102
a 10340 10341 4102
a 10341 10342 4102
a 10342 10343 4102
a 10343 10344 4102
a 10344 10345 4102
a 10345 10346 4102
a 10346 10347 4102
a 10347 10348 4102
a 10348 10349 4102
a 10349 10350 4102
a 10350 10351 4102
a 10351 10352 4102
a 10352 10353 4102
a 10353 10354 4102
a 10354 10355 4102
a 10355 10356 4102
a 10356 10357 4102
a 10357 10358 4102
a 10358 10359 4102
a 10359 10360 4102
a 10360 10361 4102
a 10361 10362 4102
a 10362 10363 4102
a 10363 10364 4102
a 10364 10365 4102
a 10365 10366 4102
a 10366 10367 4102
a 10367 10368 4102
a 10368 10369 4102
a 10369 10370 4102
a 10370 10371 4102
a 10371 10372 4102
a 10372 10373 4102
a 10373 10374 4102
a 10374 10375 4102
a 10375 10376 4102
a 10376 10377 4102
a 10377 10378 4102
a 10378 10379 4102
a 10379 10380 4102
a 10380 10381 4102
a 10381 10382 4102
a 10382 10383 4102
a 10383 10384 4102
a 10384 10385 4102
a 10385 10386 4102
a 10386 10387 4102
a 10387 10388 4102
a 10388 10389 4102
a 10389 10390 4102
a 10390 10391 4102
a 10391 10392 4102
a 10392 10393 4102
a 10393 10394 4102
a 10394 10395 4102
a 10395 10396 4102
a 10396 10397 4102
a 10397 10398 4102
a 10398 10399 4102
a 10399 10400 4102
a 10400 10401 4102
a 10401 10402 4102
a 10402 10403 4102
a 10403 10404 4102
a 10404 10405 4102
a 10405 10406 4102
a 10406 10407 4102
a 10407 10408 4102
a 10408 10409 4102
a 10409 10410 4102
a 10410 10411 4102
a 10411 10412 4102
a 10412 10413 4102
a 10413 10414 4102
a 10414 10415 4102
a 10415 10416 4102
a 10416 10417 4102
a 10417 10418 4102
a 10418 10419 4102
a 10419 10420 4102
a 10420 10421 4102
a 10421 10422 4102
a 10422 10423 4102
a 10423 10424 4102
a 10424 10425 4102
a 10425 10426 4102
a 10426 10427 4102
a 10427 10428 4102
a 10428 10429 4102
a 10429 10430 4102
a 10430 10431 4102
a 10431 10432 4102
a 10432 10433 4102
a 10433 10434 4102
a 10434 10435 4102
a 10435 10436 4102
a 10436 10437 4102
a 10437 10438 4102
a 10438 10439 4102
a 10439 10440 4102
a 10440 10441 4102
a 10441 10442 4102
a 10442 10443 4102
a 10443 10444 4102
a 10444 10445 4102
a 10445 10446 4102
a 10446 10447 4102
a 10447 10448 4102
a 10448 10449 4102
a 10449 10450 4102
a 10450 10451 4102
a 10451 10452 4102
a 10452 10453 4102
a 10453 10454 4102
a 10454 10455 4102
a 10455 10456 4102
a 10456 10457 4102
a 10457 10458 4102
a 10458 10459 4102
a 10459 10460 4102
a 10460 10461 4102
a 10461 10462 4102
a 10462 10463 4102
a 10463 10464 4102
a 10464 10465 4102
a 10465 10466 4102
a 10466 10467 4102
a 10467 10468 4102
a 10468 10469 4102
a 10469 10470 4102
a 10470 10471 4102
a 10471 10472 4102
a 10472 10473 4102
a 10473 10474 4102
a 10474 10475 4102
a 10475 10476 4102
a 10476 10477 4102
a 10477 10478 4102
a 10478 10479 4102
a 10479 10480 4102
a 10480 10481 4102
a 10481 10482 4102
a 10482 10483 4102
a 10483 10484 4102
a 10484 10485 4102
a 10485 10486 4102
a 10486 10487 4102
a 10487 10488 4102
a 10488 10489 4102
a 10489 10490 4102
a 10490 10491 4102
a 10491 10492 4102
a 10492 10493 4102
a 10493 10494 4102
a 10494 10495 4102
a 10495 10496 4102
a 10496 10497 4102
a 10497 10498 4102
a 10498 10499 4102
a 10499 10500 4102
a 10500 10501 4102
a 10501 10502 4102
a 10502 10503 4102
a 10503 10504 4102
a 10504 10505 4102
a 10505 10506 4102
a 10506 10507 4102
a 10507 10508 4102
a 10508 10509 4102
a 10509 10510 4102
a 10510 10511 4102
a 10511 10512 4102
a 10512 10513 4102
a 10513 10514 4102
a 10514 10515 4102
a 10515 10516 4102
a 10516 10517 4102
a 10517 10518 4102
a 10518 10519 4102
a 10519 10520 4102
a 10520 10521 4102
a 10521 10522 4102
a 10522 10523 4102
a 10523 10524 4102
a 10524 10525 4102
a 10525 10526 4102
a 10526 10527 4102
a 10527 10528 4102
a 10528 10529 4102
a 10529 10530 4102
a 10530 10531 4102
a 10531 10532 4102
a 10532 10533 4102
a 10533 10534 4102
a 10534 10535 4102
a 10535 10536 4102
a 10536 10537 4102
a 10537 10538 4102
a 10538 10539 4102
a 10539 10540 4102
a 10540 10541 4102
a 10541 10542 4102
a 10542 10543 4102
a 10543 10544 4102
a 10544 10545 4102
a 10545 10546 4102
a 10546 10547 4102
a 10547 10548 4102
a 10548 10549 4102
a 10549 10550 4102
a 10550 10551 4102
a 10551 10552 4102
a 10552 10553 4102
a 10553 10554 4102
a 10554 10555 4102
a 10555 10556 4102
a 10556 10557 4102
a 10557 10558 4102
a 10558 10559 4102
a 10559 10560 4102
a 10560 10561 4102
a 10561 10562 4102
a 10562 10563 4102
a 10563 10564 4102
a 10564 10565 4102
a 10565 10566 4102
a 10566 10567 4102
a 10567 10568 4102
a 10568 10569 4102
a 10569 10570 4102
a 10570 10571 4102
a 10571 10572 4102
a 10572 10573 4102
a 10573 10574 4102
a 10574 10575 4102
a 10575 10576 4102
a 10576 10577 4102
a 10577 10578 4102
a 10578 10579 4102
a 10579 10580 4102
a 10580 10581 4102
a 10581 10582 4102
a 10582 10583 4102
a 10583 10584 4102
a 10584 10585 4102
a 10585 10586 4102
a 10586 10587 4102
a 10587 10588 4102
a 10588 10589 4102
a 10589 10590 4102
a 10590 10591 4102
a 10591 10592 4102
a 10592 10593 4102
a 10593 10594 4102
a 10594 10595 4102
a 10595 10596 4102
a 10596 10597 4102
a 10597 10598 4102
a 10598 10599 4102
a 10599 10600 4102
a 10600 10601 4102
a 10601 10602 4102
a 10602 10603 4102
a 10603 10604 4102
a 10604 10605 4102
a 10605 10606 4102
a 10606 10607 4102
a 10607 10608 4102
a 10608 10609 4102
a 10609 10610 4102
a 10610 10611 4102
a 10611 10612 4102
a 10612 10613 4102
a 10613 10614 4102
a 10614 10615 4102
a 10615 10616 4102
a 10616 10617 4102
a 10617 10618 4102
a 10618 10619 4102
a 10619 10620 4102
a 10620 10621 4102
a 10621 10622 4102
a 10622 10623 4102
a 10623 10624 4102
a 10624 10625 4102
a 10625 10626 4102
a 10626 10627 4102
a 10627 10628 4102
a 10628 10629 4102
a 10629 10630 4102
a 10630 10631 4102
a 10631 10632 4102
a 10632 10633 4102
a 10633 10634 4102
a 10634 10635 4102
a 10635 10636 4102
a 10636 10637 4102
a 10637 10638 4102
a 10638 10639 4102
a 10639 10640 4102
a 10640 10641 4102
a 10641 10642 4102
a 10642 10643 4102
a 10643 10644 4102
a 10644 10645 4102
a 10645 10646 4102
a 10646 10647 4102
a 10647 10648 4102
a 10648 10649 4102
a 10649 10650 4102
a 10650 10651 4102
a 10651 10652 4102
a 10652 10653 4102
a 10653 10654 4102
a 10654 10655 4102
a 10655 10656 4102
a 10656 10657 4102
a 10657 10658 4102
a 10658 10659 4102
a 10659 10660 4102
a 10660 10661 4102
a 10661 10662 4102
a 10662 10663 4102
a 10663 10664 4102
a 10664 10665 4102
a 10665 10666 4102
a 10666 10667 4102
a 10667 10668 4102
a 10668 10669 4102
a 10669 10670 4102
a 10670 10671 4102
a 10671 10672 4102
a 10672 10673 4102
a 10673 10674 4102
a 10674 10675 4102
a 10675 10676 4102
a 10676 10677 4102
a 10677 10678 4102
a 10678 10679 4102
a 10679 10680 4102
a 10680 10681 4102
a 10681 10682 4102
a 10682 10683 4102
a 10683 10684 4102
a 10684 10685 4102
a 10685 10686 4102
a 10686 10687 4102
a 10687 10688 4102
a 10688 10689 4102
a 10689 10690 4102
a 10690 10691 4102
a 10691 10692 4102
a 10692 10693 4102
a 10693 10694 4102
a 10694 10695 4102
a 10695 10696 4102
a 10696 10697 4102
a 10697 10698 4102
a 10698 10699 4102
a 10699 10700 4102
a 10700 10701 4102
a 10701 10702 4102
a 10702 10703 4102
a 10703 10704 4102
a 10704 10705 4102
a 10705 10706 4102
a 10706 10707 4102
a 10707 10708 4102
a 10708 10709 4102
a 10709 10710 4102
a 10710 10711 4102
a 10711 10712 4102
a 10712 10713 4102
a 10713 10714 4102
a 10714 10715 4102
a 10715 10716 4102
a 10716 10717 4102
a 10717 10718 4102
a 10718 10719 4102
a 10719 10720 4102
a 10720 10721 4102
a 10721 10722 4102
a 10722 10723 4102
a 10723 10724 4102
a 10724 10725 4102
a 10725 10726 4102
a 10726 10727 4102
a 10727 10728 4102
a 10728 10729 4102
a 10729 10730 4102
a 10730 10731 4102
a 10731 10732 4102
a 10732 10733 4102
a 10733 10734 4102
a 10734 10735 4102
a 10735 10736 4102
a 10736 10737 4102
a 10737 10738 4102
a 10738 10739 4102
a 10739 10740 4102
a 10740 10741 4102
a 10741 10742 4102
a 10742 10743 4102
a 10743 10744 4102
a 10744 10745 4102
a 10745 10746 4102
a 10746 10747 4102
a 10747 10748 4102
a 10748 10749 4102
a 10749 10750 4102
a 10750 10751 4102
a 10751 10752 4102
a 10752 10753 4102
a 10753 10754 4102
a 10754 10755 4102
a 10755 10756 4102
a 10756 10757 4102
a 10757 10758 4102
a 10758 10759 4102
a 10759 10760 4102
a 10760 10761 4102
a 10761 10762 4102
a 10762 10763 4102
a 10763 10764 4102
a 10764 10765 4102
a 10765 10766 4102
a 10766 10767 4102
a 10767 10768 4102
a 10768 10769 4102
a 10769 10770 4102
a 10770 10771 4102
a 10771 10772 4102
a 10772 10773 4102
a 10773 10774 4102
a 10774 10775 4102
a 10775 10776 4102
a 10776 10777 4102
a 10777 10778 4102
a 10778 10779 4102
a 10779 10780 4102
a 10780 10781 4102
a 10781 10782 4102
a 10782 10783 4102
a 10783 10784 4102
a 10784 10785 4102
a 10785 10786 4102
a 10786 10787 4102
a 10787 10788 4102
a 10788 10789 4102
a 10789 10790 4102
a 10790 10791 4102
a 10791 10792 4102
a 10792 10793 4102
a 10793 10794 4102
a 10794 10795 4102
a 10795 10796 4102
a 10796 10797 4102
a 10797 10798 4102
a 10798 10799 4102
a 10799 10800 4102
a 10800 10801 4102
a 10801 10802 4102
a 10802 10803 4102
a 10803 10804 4102
a 10804 10805 4102
a 10805 10806 4102
a 10806 10807 4102
a 10807 10808 4102
a 10808 10809 4102
a 10809 10810 4102
a 10810 10811 4102
a 10811 10812 4102
a 10812 10813 4102
a 10813 10814 4102
a 10814 10815 4102
a 10815 10816 4102
a 10816 10817 4102
a 10817 10818 4102
a 10818 10819 4102
a 10819 10820 4102
a 10820 10821 4102
a 10821 10822 4102
a 10822 10823 4102
a 10823 10824 4102
a 10824 10825 4102
a 10825 10826 4102
a 10826 10827 4102
a 10827 10828 4102
a 10828 10829 4102
a 10829 10830 4102
a 10830 10831 4102
a 10831 10832 4102
a 10832 10833 4102
a 10833 10834 4102
a 10834 10835 4102
a 10835 10836 4102
a 10836 10837 4102
a 10837 10838 4102
a 10838 10839 4102
a 10839 10840 4102
a 10840 10841 4102
a 10841 10842 4102
a 10842 10843 4102
a 10843 10844 4102
a 10844 10845 4102
a 10845 10846 4102
a 10846 10847 4102
a 10847 10848 4102
a 10848 10849 4102
a 10849 10850 4102
a 10850 10851 4102
a 10851 10852 4102
a 10852 10853 4102
a 10853 10854 4102
a 10854 10855 4102
a 10855 10856 4102
a 10856 10857 4102
a 10857 10858 4102
a 10858 10859 4102
a 10859 10860 4102
a 10860 10861 4102
a 10861 10862 4102
a 10862 10863 4102
a 10863 10864 4102
a 10864 10865 4102
a 10865 10866 4102
a 10866 10867 4102
a 10867 10868 4102
a 10868 10869 4102
a 10869 10870 4102
a 10870 10871 4102
a 10871 10872 4102
a 10872 10873 4102
a 10873 10874 4102
a 10874 10875 4102
a 10875 10876 4102
a 10876 10877 4102
a 10877 10878 4102
a 10878 10879 4102
a 10879 10880 4102
a 10880 10881 4102
a 10881 10882 4102
a 10882 10883 4102
a 10883 10884 4102
a 10884 10885 4102
a 10885 10886 4102
a 10886 10887 4102
a 10887 10888 4102
a 10888 10889 4102
a 10889 10890 4102
a 10890 10891 4102
a 10891 10892 4102
a 10892 10893 4102
a 10893 10894 4102
a 10894 10895 4102
a 10895 10896 4102
a 10896 10897 4102
a 10897 10898 4102
a 10898 10899 4102
a 10899 10900 4102
a 10900 10901 4102
a 10901 10902 4102
a 10902 10903 4102
a 10903 10904 4102
a 10904 10905 4102
a 10905 10906 4102
a 10906 10907 4102
a 10907 10908 4102
a 10908 10909 4102
a 10909 10910 4102
a 10910 10911 4102
a 10911 10912 4102
a 10912 10913 4102
a 10913 10914 4102
a 10914 10915 4102
a 10915 10916 4102
a 10916 10917 4102
a 10917 10918 4102
a 10918 10919 4102
a 10919 10920 4102
a 10920 10921 4102
a 10921 10922 4102
a 10922 10923 4102
a 10923 10924 4102
a 10924 10925 4102
a 10925 10926 4102
a 10926 10927 4102
a 10927 10928 4102
a 10928 10929 4102
a 10929 10930 4102
a 10930 10931 4102
a 10931 10932 4102
a 10932 10933 4102
a 10933 10934 4102
a 10934 10935 4102
a 10935 10936 4102
a 10936 10937 4102
a 10937 10938 4102
a 10938 10939 4102
a 10939 10940 4102
a 10940 10941 4102
a 10941 10942 4102
a 10942 10943 4102
a 10943 10944 4102
a 10944 10945 4102
a 10945 10946 4102
a 10946 10947 4102
a 10947 10948 4102
a 10948 10949 4102
a 10949 10950 4102
a 10950 10951 4102
a 10951 10952 4102
a 10952 10953 4102
a 10953 10954 4102
a 10954 10955 4102
a 10955 10956 4102
a 10956 10957 4102
a 10957 10958 4102
a 10958 10959 4102
a 10959 10960 4102
a 10960 10961 4102
a 10961 10962 4102
a 10962 10963 4102
a 10963 10964 4102
a 10964 10965 4102
a 10965 10966 4102
a 10966 10967 4102
a 10967 10968 4102
a 10968 10969 4102
a 10969 10970 4102
a 10970 10971 4102
a 10971 10972 4102
a 10972 10973 4102
a 10973 10974 4102
a 10974 10975 4102
a 10975 10976 4102
a 10976 10977 4102
a 10977 10978 4102
a 10978 10979 4102
a 10979 10980 4102
a 10980 10981 4102
a 10981 10982 4102
a 10982 10983 4102
a 10983 10984 4102
a 10984 10985 4102
a 10985 10986 4102
a 10986 10987 4102
a 10987 10988 4102
a 10988 10989 4102
a 10989 10990 4102
a 10990 10991 4102
a 10991 10992 4102
a 10992 10993 4102
a 10993 10994 4102
a 10994 10995 4102
a 10995 10996 4102
a 10996 10997 4102
a 10997 10998 4102
a 10998 10999 4102
a 10999 11000 4102
a 11000 11001 4102
a 11001 11002 4102
a 11002 11003 4102
a 11003 11004 4102
a 11004 11005 4102
a 11005 11006 4102
a 11006 11007 4102
a 11007 11008 4102
a 11008 11009 4102
a 11009 11010 4102
a 11010 11011 4102
a 11011 11012 4102
a 11012 11013 4102
a 11013 11014 4102
a 11014 11015 4102
a 11015 11016 4102
a 11016 11017 4102
a 11017 11018 4102
a 11018 11019 4102
a 11019 11020 4102
a 11020 11021 4102
a 11021 11022 4102
a 11022 11023 4102
a 11023 11024 4102
a 11024 11025 4102
a 11025 11026 4102
a 11026 11027 4102
a 11027 11028 4102
a 11028 11029 4102
a 11029 11030 4102
a 11030 11031 4102
a 11031 11032 4102
a 11032 11033 4102
a 11033 11034 4102
a 11034 11035 4102
a 11035 11036 4102
a 11036 11037 4102
a 11037 11038 4102
a 11038 11039 4102
a 11039 11040 4102
a 11040 11041 4102
a 11041 11042 4102
a 11042 11043 4102
a 11043 11044 4102
a 11044 11045 4102
a 11045 11046 4102
a 11046 11047 4102
a 11047 11048 4102
a 11048 11049 4102
a 11049 11050 4102
a 11050 11051 4102
a 11051 11052 4102
a 11052 11053 4102
a 11053 11054 4102
a 11054 11055 4102
a 11055 11056 4102
a 11056 11057 4102
a 11057 11058 4102
a 11058 11059 4102
a 11059 11060 4102
a 11060 11061 4102
a 11061 11062 4102
a 11062 11063 4102
a 11063 11064 4102
a 11064 11065 4102
a 11065 11066 4102
a 11066 11067 4102
a 11067 11068 4102
a 11068 11069 4102
a 11069 11070 4102
a 11070 11071 4102
a 11071 11072 4102
a 11072 11073 4102
a 11073 11074 4102
a 11074 11075 4102
a 11075 11076 4102
a 11076 11077 4102
a 11077 11078 4102
a 11078 11079 4102
a 11079 11080 4102
a 11080 11081 4102
a 11081 11082 4102
a 11082 11083 4102
a 11083 11084 4102
a 11084 11085 4102
a 11085 11086 4102
a 11086 11087 4102
a 11087 11088 4102
a 11088 11089 4102
a 11089 11090 4102
a 11090 11091 4102
a 11091 11092 4102
a 11092 11093 4102
a 11093 11094 4102
a 11094 11095 4102
a 11095 11096 4102
a 11096 11097 4102
a 11097 11098 4102
a 11098 11099 4102
a 11099 11100 4102
a 11100 11101 4102
a 11101 11102 4102
a 11102 11103 4102
a 11103 11104 4102
a 11104 11105 4102
a 11105 11106 4102
a 11106 11107 4102
a 11107 11108 4102
a 11108 11109 4102
a 11109 11110 4102
a 11110 11111 4102
a 11111 11112 4102
a 11112 11113 4102
a 11113 11114 4102
a 11114 11115 4102
a 11115 11116 4102
a 11116 11117 4102
a 11117 11118 4102
a 11118 11119 4102
a 11119 11120 4102
a 11120 11121 4102
a 11121 11122 4102
a 11122 11123 4102
a 11123 11124 4102
a 11124 11125 4102
a 11125 11126 4102
a 11126 11127 4102
a 11127 11128 4102
a 11128 11129 4102
a 11129 11130 4102
a 11130 11131 4102
a 11131 11132 4102
a 11132 11133 4102
a 11133 11134 4102
a 11134 11135 4102
a 11135 11136 4102
a 11136 11137 4102
a 11137 11138 4102
a 11138 11139 4102
a 11139 11140 4102
a 11140 11141 4102
a 11141 11142 4102
a 11142 11143 4102
a 11143 11144 4102
a 11144 11145 4102
a 11145 11146 4102
a 11146 11147 4102
a 11147 11148 4102
a 11148 11149 4102
a 11149 11150 4102
a 11150 11151 4102
a 11151 11152 4102
a 11152 11153 4102
a 11153 11154 4102
a 11154 11155 4102
a 11155 11156 4102
a 11156 11157 4102
a 11157 11158 4102
a 11158 11159 4102
a 11159 11160 4102
a 11160 11161 4102
a 11161 11162 4102
a 11162 11163 4102
a 11163 11164 4102
a 11164 11165 4102
a 11165 11166 4102
a 11166 11167 4102
a 11167 11168 4102
a 11168 11169 4102
a 11169 11170 4102
a 11170 11171 4102
a 11171 11172 4102
a 11172 11173 4102
a 11173 11174 4102
a 11174 11175 4102
a 11175 11176 4102
a 11176 11177 4102
a 11177 11178 4102
a 11178 11179 4102
a 11179 11180 4102
a 11180 11181 4102
a 11181 11182 4102
a 11182 11183 4102
a 11183 11184 4102
a 11184 11185 4102
a 11185 11186 4102
a 11186 11187 4102
a 11187 11188 4102
a 11188 11189 4102
a 11189 11190 4102
a 11190 11191 4102
a 11191 11192 4102
a 11192 11193 4102
a 11193 11194 4102
a 11194 11195 4102
a 11195 11196 4102
a 11196 11197 4102
a 11197 11198 4102
a 11198 11199 4102
a 11199 11200 4102
a 11200 11201 4102
a 11201 11202 4102
a 11202 11203 4102
a 11203 11204 4102
a 11204 11205 4102
a 11205 11206 4102
a 11206 11207 4102
a 11207 11208 4102
a 11208 11209 4102
a 11209 11210 4102
a 11210 11211 4102
a 11211 11212 4102
a 11212 11213 4102
a 11213 11214 4102
a 11214 11215 4102
a 11215 11216 4102
a 11216 11217 4102
a 11217 11218 4102
a 11218 11219 4102
a 11219 11220 4102
a 11220 11221 4102
a 11221 11222 4102
a 11222 11223 4102
a 11223 11224 4102
a 11224 11225 4102
a 11225 11226 4102
a 11226 11227 4102
a 11227 11228 4102
a 11228 11229 4102
a 11229 11230 4102
a 11230 11231 4102
a 11231 11232 4102
a 11232 11233 4102
a 11233 11234 4102
a 11234 11235 4102
a 11235 11236 4102
a 11236 11237 4102
a 11237 11238 4102
a 11238 11239 4102
a 11239 11240 4102
a 11240 11241 4102
a 11241 11242 4102
a 11242 11243 4102
a 11243 11244 4102
a 11244 11245 4102
a 11245 11246 4102
a 11246 11247 4102
a 11247 11248 4102
a 11248 11249 4102
a 11249 11250 4102
a 11250 11251 4102
a 11251 11252 4102
a 11252 11253 4102
a 11253 11254 4102
a 11254 11255 4102
a 11255 11256 4102
a 11256 11257 4102
a 11257 11258 4102
a 11258 11259 4102
a 11259 11260 4102
a 11260 11261 4102
a 11261 11262 4102
a 11262 11263 4102
a 11263 11264 4102
a 11264 11265 4102
a 11265 11266 4102
a 11266 11267 4102
a 11267 11268 4102
a 11268 11269 4102
a 11269 11270 4102
a 11270 11271 4102
a 11271 11272 4102
a 11272 11273 4102
a 11273 11274 4102
a 11274 11275 4102
a 11275 11276 4102
a 11276 11277 4102
a 11277 11278 4102
a 11278 11279 4102
a 11279 11280 4102
a 11280 11281 4102
a 11281 11282 4102
a 11282 11283 4102
a 11283 11284 4102
a 11284 11285 4102
a 11285 11286 4102
a 11286 11287 4102
a 11287 11288 4102
a 11288 11289 4102
a 11289 11290 4102
a 11290 11291 4102
a 11291 11292 4102
a 11292 11293 4102
a 11293 11294 4102
a 11294 11295 4102
a 11295 11296 4102
a 11296 11297 4102
a 11297 11298 4102
a 11298 11299 4102
a 11299 11300 4102
a 11300 11301 4102
a 11301 11302 4102
a 11302 11303 4102
a 11303 11304 4102
a 11304 11305 4102
a 11305 11306 4102
a 11306 11307 4102
a 11307 11308 4102
a 11308 11309 4102
a 11309 11310 4102
a 11310 11311 4102
a 11311 11312 4102
a 11312 11313 4102
a 11313 11314 4102
a 11314 11315 4102
a 11315 11316 4102
a 11316 11317 4102
a 11317 11318 4102
a 11318 11319 4102
a 11319 11320 4102
a 11320 11321 4102
a 11321 11322 4102
a 11322 11323 4102
a 11323 11324 4102
a 11324 11325 4102
a 11325 11326 4102
a 11326 11327 4102
a 11327 11328 4102
a 11328 11329 4102
a 11329 11330 4102
a 11330 11331 4102
a 11331 11332 4102
a 11332 11333 4102
a 11333 11334 4102
a 11334 11335 4102
a 11335 11336 4102
a 11336 11337 4102
a 11337 11338 4102
a 11338 11339 4102
a 11339 11340 4102
a 11340 11341 4102
a 11341 11342 4102
a 11342 11343 4102
a 11343 11344 4102
a 11344 11345 4102
a 11345 11346 4102
a 11346 11347 4102
a 11347 11348 4102
a 11348 11349 4102
a 11349 11350 4102
a 11350 11351 4102
a 11351 11352 4102
a 11352 11353 4102
a 11353 11354 4102
a 11354 11355 4102
a 11355 11356 4102
a 11356 11357 4102
a 11357 11358 4102
a 11358 11359 4102
a 11359 11360 4102
a 11360 11361 4102
a 11361 11362 4102
a 11362 11363 4102
a 11363 11364 4102
a 11364 11365 4102
a 11365 11366 4102
a 11366 11367 4102
a 11367 11368 4102
a 11368 11369 4102
a 11369 11370 4102
a 11370 11371 4102
a 11371 11372 4102
a 11372 11373 4102
a 11373 11374 4102
a 11374 11375 4102
a 11375 11376 4102
a 11376 11377 4102
a 11377 11378 4102
a 11378 11379 4102
a 11379 11380 4102
a 11380 11381 4102
a 11381 11382 4102
a 11382 11383 4102
a 11383 11384 4102
a 11384 11385 4102
a 11385 11386 4102
a 11386 11387 4102
a 11387 11388 4102
a 11388 11389 4102
a 11389 11390 4102
a 11390 11391 4102
a 11391 11392 4102
a 11392 11393 4102
a 11393 11394 4102
a 11394 11395 4102
a 11395 11396 4102
a 11396 11397 4102
a 11397 11398 4102
a 11398 11399 4102
a 11399 11400 4102
a 11400 11401 4102
a 11401 11402 4102
a 11402 11403 4102
a 11403 11404 4102
a 11404 11405 4102
a 11405 11406 4102
a 11406 11407 4102
a 11407 11408 4102
a 11408 11409 4102
a 11409 11410 4102
a 11410 11411 4102
a 11411 11412 4102
a 11412 11413 4102
a 11413 11414 4102
a 11414 11415 4102
a 11415 11416 4102
a 11416 11417 4102
a 11417 11418 4102
a 11418 11419 4102
a 11419 11420 4102
a 11420 11421 4102
a 11421 11422 4102
a 11422 11423 4102
a 11423 11424 4102
a 11424 11425 4102
a 11425 11426 4102
a 11426 11427 4102
a 11427 11428 4102
a 11428 11429 4102
a 11429 11430 4102
a 11430 11431 4102
a 11431 11432 4102
a 11432 11433 4102
a 11433 11434 4102
a 11434 11435 4102
a 11435 11436 4102
a 11436 11437 4102
a 11437 11438 4102
a 11438 11439 4102
a 11439 11440 4102
a 11440 11441 4102
a 11441 11442 4102
a 11442 11443 4102
a 11443 11444 4102
a 11444 11445 4102
a 11445 11446 4102
a 11446 11447 4102
a 11447 11448 4102
a 11448 11449 4102
a 11449 11450 4102
a 11450 11451 4102
a 11451 11452 4102
a 11452 11453 4102
a 11453 11454 4102
a 11454 11455 4102
a 11455 11456 4102
a 11456 11457 4102
a 11457 11458 4102
a 11458 11459 4102
a 11459 11460 4102
a 11460 11461 4102
a 11461 11462 4102
a 11462 11463 4102
a 11463 11464 4102
a 11464 11465 4102
a 11465 11466 4102
a 11466 11467 4102
a 11467 11468 4102
a 11468 11469 4102
a 11469 11470 4102
a 11470 11471 4102
a 11471 11472 4102
a 11472 11473 4102
a 11473 11474 4102
a 11474 11475 4102
a 11475 11476 4102
a 11476 11477 4102
a 11477 11478 4102
a 11478 11479 4102
a 11479 11480 4102
a 11480 11481 4102
a 11481 11482 4102
a 11482 11483 4102
a 11483 11484 4102
a 11484 11485 4102
a 11485 11486 4102
a 11486 11487 4102
a 11487 11488 4102
a 11488 11489 4102
a 11489 11490 4102
a 11490 11491 4102
a 11491 11492 4102
a 11492 11493 4102
a 11493 11494 4102
a 11494 11495 4102
a 11495 11496 4102
a 11496 11497 4102
a 11497 11498 4102
a 11498 11499 4102
a 11499 11500 4102
a 11500 11501 4102
a 11501 11502 4102
a 11502 11503 4102
a 11503 11504 4102
a 11504 11505 4102
a 11505 11506 4102
a 11506 11507 4102
a 11507 11508 4102
a 11508 11509 4102
a 11509 11510 4102
a 11510 11511 4102
a 11511 11512 4102
a 11512 11513 4102
a 11513 11514 4102
a 11514 11515 4102
a 11515 11516 4102
a 11516 11517 4102
a 11517 11518 4102
a 11518 11519 4102
a 11519 11520 4102
a 11520 11521 4102
a 11521 11522 4102
a 11522 11523 4102
a 11523 11524 4102
a 11524 11525 4102
a 11525 11526 4102
a 11526 11527 4102
a 11527 11528 4102
a 11528 11529 4102
a 11529 11530 4102
a 11530 11531 4102
a 11531 11532 4102
a 11532 11533 4102
a 11533 11534 4102
a 11534 11535 4102
a 11535 11536 4102
a 11536 11537 4102
a 11537 11538 4102
a 11538 11539 4102
a 11539 11540 4102
a 11540 11541 4102
a 11541 11542 4102
a 11542 11543 4102
a 11543 11544 4102
a 11544 11545 4102
a 11545 11546 4102
a 11546 11547 4102
a 11547 11548 4102
a 11548 11549 4102
a 11549 11550 4102
a 11550 11551 4102
a 11551 11552 4102
a 11552 11553 4102
a 11553 11554 4102
a 11554 11555 4102
a 11555 11556 4102
a 11556 11557 4102
a 11557 11558 4102
a 11558 11559 4102
a 11559 11560 4102
a 11560 11561 4102
a 11561 11562 4102
a 11562 11563 4102
a 11563 11564 4102
a 11564 11565 4102
a 11565 11566 4102
a 11566 11567 4102
a 11567 11568 4102
a 11568 11569 4102
a 11569 11570 4102
a 11570 11571 4102
a 11571 11572 4102
a 11572 11573 4102
a 11573 11574 4102
a 11574 11575 4102
a 11575 11576 4102
a 11576 11577 4102
a 11577 11578 4102
a 11578 11579 4102
a 11579 11580 4102
a 11580 11581 4102
a 11581 11582 4102
a 11582 11583 4102
a 11583 11584 4102
a 11584 11585 4102
a 11585 11586 4102
a 11586 11587 4102
a 11587 11588 4102
a 11588 11589 4102
a 11589 11590 4102
a 11590 11591 4102
a 11591 11592 4102
a 11592 11593 4102
a 11593 11594 4102
a 11594 11595 4102
a 11595 11596 4102
a 11596 11597 4102
a 11597 11598 4102
a 11598 11599 4102
a 11599 11600 4102
a 11600 11601 4102
a 11601 11602 4102
a 11602 11603 4102
a 11603 11604 4102
a 11604 11605 4102
a 11605 11606 4102
a 11606 11607 4102
a 11607 11608 4102
a 11608 11609 4102
a 11609 11610 4102
a 11610 11611 4102
a 11611 11612 4102
a 11612 11613 4102
a 11613 11614 4102
a 11614 11615 4102
a 11615 11616 4102
a 11616 11617 4102
a 11617 11618 4102
a 11618 11619 4102
a 11619 11620 4102
a 11620 11621 4102
a 11621 11622 4102
a 11622 11623 4102
a 11623 11624 4102
a 11624 11625 4102
a 11625 11626 4102
a 11626 11627 4102
a 11627 11628 4102
a 11628 11629 4102
a 11629 11630 4102
a 11630 11631 4102
a 11631 11632 4102
a 11632 11633 4102
a 11633 11634 4102
a 11634 11635 4102
a 11635 11636 4102
a 11636 11637 4102
a 11637 11638 4102
a 11638 11639 4102
a 11639 11640 4102
a 11640 11641 4102
a 11641 11642 4102
a 11642 11643 4102
a 11643 11644 4102
a 11644 11645 4102
a 11645 11646 4102
a 11646 11647 4102
a 11647 11648 4102
a 11648 11649 4102
a 11649 11650 4102
a 11650 11651 4102
a 11651 11652 4102
a 11652 11653 4102
a 11653 11654 4102
a 11654 11655 4102
a 11655 11656 4102
a 11656 11657 4102
a 11657 11658 4102
a 11658 11659 4102
a 11659 11660 4102
a 11660 11661 4102
a 11661 11662 4102
a 11662 11663 4102
a 11663 11664 4102
a 11664 11665 4102
a 11665 11666 4102
a 11666 11667 4102
a 11667 11668 4102
a 11668 11669 4102
a 11669 11670 4102
a 11670 11671 4102
a 11671 11672 4102
a 11672 11673 4102
a 11673 11674 4102
a 11674 11675 4102
a 11675 11676 4102
a 11676 11677 4102
a 11677 11678 4102
a 11678 11679 4102
a 11679 11680 4102
a 11680 11681 4102
a 11681 11682 4102
a 11682 11683 4102
a 11683 11684 4102
a 11684 11685 4102
a 11685 11686 4102
a 11686 11687 4102
a 11687 11688 4102
a 11688 11689 4102
a 11689 11690 4102
a 11690 11691 4102
a 11691 11692 4102
a 11692 11693 4102
a 11693 11694 4102
a 11694 11695 4102
a 11695 11696 4102
a 11696 11697 4102
a 11697 11698 4102
a 11698 11699 4102
a 11699 11700 4102
a 11700 11701 4102
a 11701 11702 4102
a 11702 11703 4102
a 11703 11704 4102
a 11704 11705 4102
a 11705 11706 4102
a 11706 11707 4102
a 11707 11708 4102
a 11708 11709 4102
a 11709 11710 4102
a 11710 11711 4102
a 11711 11712 4102
a 11712 11713 4102
a 11713 11714 4102
a 11714 11715 4102
a 11715 11716 4102
a 11716 11717 4102
a 11717 11718 4102
a 11718 11719 4102
a 11719 11720 4102
a 11720 11721 4102
a 11721 11722 4102
a 11722 11723 4102
a 11723 11724 4102
a 11724 11725 4102
a 11725 11726 4102
a 11726 11727 4102
a 11727 11728 4102
a 11728 11729 4102
a 11729 11730 4102
a 11730 11731 4102
a 11731 11732 4102
a 11732 11733 4102
a 11733 11734 4102
a 11734 11735 4102
a 11735 11736 4102
a 11736 11737 4102
a 11737 11738 4102
a 11738 11739 4102
a 11739 11740 4102
a 11740 11741 4102
a 11741 11742 4102
a 11742 11743 4102
a 11743 11744 4102
a 11744 11745 4102
a 11745 11746 4102
a 11746 11747 4102
a 11747 11748 4102
a 11748 11749 4102
a 11749 11750 4102
a 11750 11751 4102
a 11751 11752 4102
a 11752 11753 4102
a 11753 11754 4102
a 11754 11755 4102
a 11755 11756 4102
a 11756 11757 4102
a 11757 11758 4102
a 11758 11759 4102
a 11759 11760 4102
a 11760 11761 4102
a 11761 11762 4102
a 11762 11763 4102
a 11763 11764 4102
a 11764 11765 4102
a 11765 11766 4102
a 11766 11767 4102
a 11767 11768 4102
a 11768 11769 4102
a 11769 11770 4102
a 11770 11771 4102
a 11771 11772 4102
a 11772 11773 4102
a 11773 11774 4102
a 11774 11775 4102
a 11775 11776 4102
a 11776 11777 4102
a 11777 11778 4102
a 11778 11779 4102
a 11779 11780 4102
a 11780 11781 4102
a 11781 11782 4102
a 11782 11783 4102
a 11783 11784 4102
a 11784 11785 4102
a 11785 11786 4102
a 11786 11787 4102
a 11787 11788 4102
a 11788 11789 4102
a 11789 11790 4102
a 11790 11791 4102
a 11791 11792 4102
a 11792 11793 4102
a 11793 11794 4102
a 11794 11795 4102
a 11795 11796 4102
a 11796 11797 4102
a 11797 11798 4102
a 11798 11799 4102
a 11799 11800 4102
a 11800 11801 4102
a 11801 11802 4102
a 11802 11803 4102
a 11803 11804 4102
a 11804 11805 4102
a 11805 11806 4102
a 11806 11807 4102
a 11807 11808 4102
a 11808 11809 4102
a 11809 11810 4102
a 11810 11811 4102
a 11811 11812 4102
a 11812 11813 4102
a 11813 11814 4102
a 11814 11815 4102
a 11815 11816 4102
a 11816 11817 4102
a 11817 11818 4102
a 11818 11819 4102
a 11819 11820 4102
a 11820 11821 4102
a 11821 11822 4102
a 11822 11823 4102
a 11823 11824 4102
a 11824 11825 4102
a 11825 11826 4102
a 11826 11827 4102
a 11827 11828 4102
a 11828 11829 4102
a 11829 11830 4102
a 11830 11831 4102
a 11831 11832 4102
a 11832 11833 4102
a 11833 11834 4102
a 11834 11835 4102
a 11835 11836 4102
a 11836 11837 4102
a 11837 11838 4102
a 11838 11839 4102
a 11839 11840 4102
a 11840 11841 4102
a 11841 11842 4102
a 11842 11843 4102
a 11843 11844 4102
a 11844 11845 4102
a 11845 11846 4102
a 11846 11847 4102
a 11847 11848 4102
a 11848 11849 4102
a 11849 11850 4102
a 11850 11851 4102
a 11851 11852 4102
a 11852 11853 4102
a 11853 11854 4102
a 11854 11855 4102
a 11855 11856 4102
a 11856 11857 4102
a 11857 11858 4102
a 11858 11859 4102
a 11859 11860 4102
a 11860 11861 4102
a 11861 11862 4102
a 11862 11863 4102
a 11863 11864 4102
a 11864 11865 4102
a 11865 11866 4102
a 11866 11867 4102
a 11867 11868 4102
a 11868 11869 4102
a 11869 11870 4102
a 11870 11871 4102
a 11871 11872 4102
a 11872 11873 4102
a 11873 11874 4102
a 11874 11875 4102
a 11875 11876 4102
a 11876 11877 4102
a 11877 11878 4102
a 11878 11879 4102
a 11879 11880 4102
a 11880 11881 4102
a 11881 11882 4102
a 11882 11883 4102
a 11883 11884 4102
a 11884 11885 4102
a 11885 11886 4102
a 11886 11887 4102
a 11887 11888 4102
a 11888 11889 4102
a 11889 11890 4102
a 11890 11891 4102
a 11891 11892 4102
a 11892 11893 4102
a 11893 11894 4102
a 11894 11895 4102
a 11895 11896 4102
a 11896 11897 4102
a 11897 11898 4102
a 11898 11899 4102
a 11899 11900 4102
a 11900 11901 4102
a 11901 11902 4102
a 11902 11903 4102
a 11903 11904 4102
a 11904 11905 4102
a 11905 11906 4102
a 11906 11907 4102
a 11907 11908 4102
a 11908 11909 4102
a 11909 11910 4102
a 11910 11911 4102
a 11911 11912 4102
a 11912 11913 4102
a 11913 11914 4102
a 11914 11915 4102
a 11915 11916 4102
a 11916 11917 4102
a 11917 11918 4102
a 11918 11919 4102
a 11919 11920 4102
a 11920 11921 4102
a 11921 11922 4102
a 11922 11923 4102
a 11923 11924 4102
a 11924 11925 4102
a 11925 11926 4102
a 11926 11927 4102
a 11927 11928 4102
a 11928 11929 4102
a 11929 11930 4102
a 11930 11931 4102
a 11931 11932 4102
a 11932 11933 4102
a 11933 11934 4102
a 11934 11935 4102
a 11935 11936 4102
a 11936 11937 4102
a 11937 11938 4102
a 11938 11939 4102
a 11939 11940 4102
a 11940 11941 4102
a 11941 11942 4102
a 11942 11943 4102
a 11943 11944 4102
a 11944 11945 4102
a 11945 11946 4102
a 11946 11947 4102
a 11947 11948 4102
a 11948 11949 4102
a 11949 11950 4102
a 11950 11951 4102
a 11951 11952 4102
a 11952 11953 4102
a 11953 11954 4102
a 11954 11955 4102
a 11955 11956 4102
a 11956 11957 4102
a 11957 11958 4102
a 11958 11959 4102
a 11959 11960 4102
a 11960 11961 4102
a 11961 11962 4102
a 11962 11963 4102
a 11963 11964 4102
a 11964 11965 4102
a 11965 11966 4102
a 11966 11967 4102
a 11967 11968 4102
a 11968 11969 4102
a 11969 11970 4102
a 11970 11971 4102
a 11971 11972 4102
a 11972 11973 4102
a 11973 11974 4102
a 11974 11975 4102
a 11975 11976 4102
a 11976 11977 4102
a 11977 11978 4102
a 11978 11979 4102
a 11979 11980 4102
a 11980 11981 4102
a 11981 11982 4102
a 11982 11983 4102
a 11983 11984 4102
a 11984 11985 4102
a 11985 11986 4102
a 11986 11987 4102
a 11987 11988 4102
a 11988 11989 4102
a 11989 11990 4102
a 11990 11991 4102
a 11991 11992 4102
a 11992 11993 4102
a 11993 11994 4102
a 11994 11995 4102
a 11995 11996 4102
a 11996 11997 4102
a 11997 11998 4102
a 11998 11999 4102
a 11999 12000 4102
a 12000 12001 4102
a 12001 12002 4102
a 12002 12003 4102
a 12003 12004 4102
a 12004 12005 4102
a 12005 12006 4102
a 12006 12007 4102
a 12007 12008 4102
a 12008 12009 4102
a 12009 12010 4102
a 12010 12011 4102
a 12011 12012 4102
a 12012 12013 4102
a 12013 12014 4102
a 12014 12015 4102
a 12015 12016 4102
a 12016 12017 4102
a 12017 12018 4102
a 12018 12019 4102
a 12019 12020 4102
a 12020 12021 4102
a 12021 12022 4102
a 12022 12023 4102
a 12023 12024 4102
a 12024 12025 4102
a 12025 12026 4102
a 12026 12027 4102
a 12027 12028 4102
a 12028 12029 4102
a 12029 12030 4102
a 12030 12031 4102
a 12031 12032 4102
a 12032 12033 4102
a 12033 12034 4102
a 12034 12035 4102
a 12035 12036 4102
a 12036 12037 4102
a 12037 12038 4102
a 12038 12039 4102
a 12039 12040 4102
a 12040 12041 4102
a 12041 12042 4102
a 12042 12043 4102
a 12043 12044 4102
a 12044 12045 4102
a 12045 12046 4102
a 12046 12047 4102
a 12047 12048 4102
a 12048 12049 4102
a 12049 12050 4102
a 12050 12051 4102
a 12051 12052 4102
a 12052 12053 4102
a 12053 12054 4102
a 12054 12055 4102
a 12055 12056 4102
a 12056 12057 4102
a 12057 12058 4102
a 12058 12059 4102
a 12059 12060 4102
a 12060 12061 4102
a 12061 12062 4102
a 12062 12063 4102
a 12063 12064 4102
a 12064 12065 4102
a 12065 12066 4102
a 12066 12067 4102
a 12067 12068 4102
a 12068 12069 4102
a 12069 12070 4102
a 12070 12071 4102
a 12071 12072 4102
a 12072 12073 4102
a 12073 12074 4102
a 12074 12075 4102
a 12075 12076 4102
a 12076 12077 4102
a 12077 12078 4102
a 12078 12079 4102
a 12079 12080 4102
a 12080 12081 4102
a 12081 12082 4102
a 12082 12083 4102
a 12083 12084 4102
a 12084 12085 4102
a 12085 12086 4102
a 12086 12087 4102
a 12087 12088 4102
a 12088 12089 4102
a 12089 12090 4102
a 12090 12091 4102
a 12091 12092 4102
a 12092 12093 4102
a 12093 12094 4102
a 12094 12095 4102
a 12095 12096 4102
a 12096 12097 4102
a 12097 12098 4102
a 12098 12099 4102
a 12099 12100 4102
a 12100 12101 4102
a 12101 12102 4102
a 12102 12103 4102
a 12103 12104 4102
a 12104 12105 4102
a 12105 12106 4102
a 12106 12107 4102
a 12107 12108 4102
a 12108 12109 4102
a 12109 12110 4102
a 12110 12111 4102
a 12111 12112 4102
a 12112 12113 4102
a 12113 12114 4102
a 12114 12115 4102
a 12115 12116 4102
a 12116 12117 4102
a 12117 12118 4102
a 12118 12119 4102
a 12119 12120 4102
a 12120 12121 4102
a 12121 12122 4102
a 12122 12123 4102
a 12123 12124 4102
a 12124 12125 4102
a 12125 12126 4102
a 12126 12127 4102
a 12127 12128 4102
a 12128 12129 4102
a 12129 12130 4102
a 12130 12131 4102
a 12131 12132 4102
a 12132 12133 4102
a 12133 12134 4102
a 12134 12135 4102
a 12135 12136 4102
a 12136 12137 4102
a 12137 12138 4102
a 12138 12139 4102
a 12139 12140 4102
a 12140 12141 4102
a 12141 12142 4102
a 12142 12143 4102
a 12143 12144 4102
a 12144 12145 4102
a 12145 12146 4102
a 12146 12147 4102
a 12147 12148 4102
a 12148 12149 4102
a 12149 12150 4102
a 12150 12151 4102
a 12151 12152 4102
a 12152 12153 4102
a 12153 12154 4102
a 12154 12155 4102
a 12155 12156 4102
a 12156 12157 4102
a 12157 12158 4102
a 12158 12159 4102
a 12159 12160 4102
a 12160 12161 4102
a 12161 12162 4102
a 12162 12163 4102
a 12163 12164 4102
a 12164 12165 4102
a 12165 12166 4102
a 12166 12167 4102
a 12167 12168 4102
a 12168 12169 4102
a 12169 12170 4102
a 12170 12171 4102
a 12171 12172 4102
a 12172 12173 4102
a 12173 12174 4102
a 12174 12175 4102
a 12175 12176 4102
a 12176 12177 4102
a 12177 12178 4102
a 12178 12179 4102
a 12179 12180 4102
a 12180 12181 4102
a 12181 12182 4102
a 12182 12183 4102
a 12183 12184 4102
a 12184 12185 4102
a 12185 12186 4102
a 12186 12187 4102
a 12187 12188 4102
a 12188 12189 4102
a 12189 12190 4102
a 12190 12191 4102
a 12191 12192 4102
a 12192 12193 4102
a 12193 12194 4102
a 12194 12195 4102
a 12195 12196 4102
a 12196 12197 4102
a 12197 12198 4102
a 12198 12199 4102
a 12199 12200 4102
a 12200 12201 4102
a 12201 12202 4102
a 12202 12203 4102
a 12203 12204 4102
a 12204 12205 4102
a 12205 12206 4102
a 12206 12207 4102
a 12207 12208 4102
a 12208 12209 4102
a 12209 12210 4102
a 12210 12211 4102
a 12211 12212 4102
a 12212 12213 4102
a 12213 12214 4102
a 12214 12215 4102
a 12215 12216 4102
a 12216 12217 4102
a 12217 12218 4102
a 12218 12219 4102
a 12219 12220 4102
a 12220 12221 4102
a 12221 12222 4102
a 12222 12223 4102
a 12223 12224 4102
a 12224 12225 4102
a 12225 12226 4102
a 12226 12227 4102
a 12227 12228 4102
a 12228 12229 4102
a 12229 12230 4102
a 12230 12231 4102
a 12231 12232 4102
a 12232 12233 4102
a 12233 12234 4102
a 12234 12235 4102
a 12235 12236 4102
a 12236 12237 4102
a 12237 12238 4102
a 12238 12239 4102
a 12239 12240 4102
a 12240 12241 4102
a 12241 12242 4102
a 12242 12243 4102
a 12243 12244 4102
a 12244 12245 4102
a 12245 12246 4102
a 12246 12247 4102
a 12247 12248 4102
a 12248 12249 4102
a 12249 12250 4102
a 12250 12251 4102
a 12251 12252 4102
a 12252 12253 4102
a 12253 12254 4102
a 12254 12255 4102
a 12255 12256 4102
a 12256 12257 4102
a 12257 12258 4102
a 12258 12259 4102
a 12259 12260 4102
a 12260 12261 4102
a 12261 12262 4102
a 12262 12263 4102
a 12263 12264 4102
a 12264 12265 4102
a 12265 12266 4102
a 12266 12267 4102
a 12267 12268 4102
a 12268 12269 4102
a 12269 12270 4102
a 12270 12271 4102
a 12271 12272 4102
a 12272 12273 4102
a 12273 12274 4102
a 12274 12275 4102
a 12275 12276 4102
a 12276 12277 4102
a 12277 12278 4102
a 12278 12279 4102
a 12279 12280 4102
a 12280 12281 4102
a 12281 12282 4102
a 12282 12283 4102
a 12283 12284 4102
a 12284 12285 4102
a 12285 12286 4102
a 12286 12287 4102
a 12287 12288 4102
a 12288 12289 4102
a 12289 12290 4102
a 12290 12291 4102
a 12291 12292 4102
a 12292 12293 4102
a 12293 12294 4102
a 12294 12295 4102
a 12295 12296 4102
a 12296 12297 4102
a 12297 12298 4102
a 12298 12299 4102
a 12299 12300 4102
a 12300 12301 4102
a 12301 12302 4102
a 12302 12303 4102
a 12303 12304 4102
a 12304 12305 4102
a 12305 12306 4102
a 12306 12307 4102
a 12307 12308 4102
a 12308 12309 4102
a 12309 12310 4102
a 12310 12311 4102
a 12311 12312 4102
a 12312 12313 4102
a 12313 12314 4102
a 12314 12315 4102
a 12315 12316 4102
a 12316 12317 4102
a 12317 12318 4102
a 12318 12319 4102
a 12319 12320 4102
a 12320 12321 4102
a 12321 12322 4102
a 12322 12323 4102
a 12323 12324 4102
a 12324 12325 4102
a 12325 12326 4102
a 12326 12327 4102
a 12327 12328 4102
a 12328 12329 4102
a 12329 12330 4102
a 12330 12331 4102
a 12331 12332 4102
a 12332 12333 4102
a 12333 12334 4102
a 12334 12335 4102
a 12335 12336 4102
a 12336 12337 4102
a 12337 12338 4102
a 12338 12339 4102
a 12339 12340 4102
a 12340 12341 4102
a 12341 12342 4102
a 12342 12343 4102
a 12343 12344 4102
a 12344 12345 4102
a 12345 12346 4102
a 12346 12347 4102
a 12347 12348 4102
a 12348 12349 4102
a 12349 12350 4102
a 12350 12351 4102
a 12351 12352 4102
a 12352 12353 4102
a 12353 12354 4102
a 12354 12355 4102
a 12355 12356 4102
a 12356 12357 4102
a 12357 12358 4102
a 12358 12359 4102
a 12359 12360 4102
a 12360 12361 4102
a 12361 12362 4102
a 12362 12363 4102
a 12363 12364 4102
a 12364 12365 4102
a 12365 12366 4102
a 12366 12367 4102
a 12367 12368 4102
a 12368 12369 4102
a 12369 12370 4102
a 12370 12371 4102
a 12371 12372 4102
a 12372 12373 4102
a 12373 12374 4102
a 12374 12375 4102
a 12375 12376 4102
a 12376 12377 4102
a 12377 12378 4102
a 12378 12379 4102
a 12379 12380 4102
a 12380 12381 4102
a 12381 12382 4102
a 12382 12383 4102
a 12383 12384 4102
a 12384 12385 4102
a 12385 12386 4102
a 12386 12387 4102
a 12387 12388 4102
a 12388 12389 4102
a 12389 12390 4102
a 12390 12391 4102
a 12391 12392 4102
a 12392 12393 4102
a 12393 12394 4102
a 12394 12395 4102
a 12395 12396 4102
a 12396 12397 4102
a 12397 12398 4102
a 12398 12399 4102
a 12399 12400 4102
a 12400 12401 4102
a 12401 12402 4102
a 12402 12403 4102
a 12403 12404 4102
a 12404 12405 4102
a 12405 12406 4102
a 12406 12407 4102
a 12407 12408 4102
a 12408 12409 4102
a 12409 12410 4102
a 12410 12411 4102
a 12411 12412 4102
a 12412 12413 4102
a 12413 12414 4102
a 12414 12415 4102
a 12415 12416 4102
a 12416 12417 4102
a 12417 12418 4102
a 12418 12419 4102
a 12419 12420 4102
a 12420 12421 4102
a 12421 12422 4102
a 12422 12423 4102
a 12423 12424 4102
a 12424 12425 4102
a 12425 12426 4102
a 12426 12427 4102
a 12427 12428 4102
a 12428 12429 4102
a 12429 12430 4102
a 12430 12431 4102
a 12431 12432 4102
a 12432 12433 4102
a 12433 12434 4102
a 12434 12435 4102
a 12435 12436 4102
a 12436 12437 4102
a 12437 12438 4102
a 12438 12439 4102
a 12439 12440 4102
a 12440 12441 4102
a 12441 12442 4102
a 12442 12443 4102
a 12443 12444 4102
a 12444 12445 4102
a 12445 12446 4102
a 12446 12447 4102
a 12447 12448 4102
a 12448 12449 4102
a 12449 12450 4102
a 12450 12451 4102
a 12451 12452 4102
a 12452 12453 4102
a 12453 12454 4102
a 12454 12455 4102
a 12455 12456 4102
a 12456 12457 4102
a 12457 12458 4102
a 12458 12459 4102
a 12459 12460 4102
a 12460 12461 4102
a 12461 12462 4102
a 12462 12463 4102
a 12463 12464 4102
a 12464 12465 4102
a 12465 12466 4102
a 12466 12467 4102
a 12467 12468 4102
a 12468 12469 4102
a 12469 12470 4102
a 12470 12471 4102
a 12471 12472 4102
a 12472 12473 4102
a 12473 12474 4102
a 12474 12475 4102
a 12475 12476 4102
a 12476 12477 4102
a 12477 12478 4102
a 12478 12479 4102
a 12479 12480 4102
a 12480 12481 4102
a 12481 12482 4102
a 12482 12483 4102
a 12483 12484 4102
a 12484 12485 4102
a 12485 12486 4102
a 12486 12487 4102
a 12487 12488 4102
a 12488 12489 4102
a 12489 12490 4102
a 12490 12491 4102
a 12491 12492 4102
a 12492 12493 4102
a 12493 12494 4102
a 12494 12495 4102
a 12495 12496 4102
a 12496 12497 4102
a 12497 12498 4102
a 12498 12499 4102
a 12499 12500 4102
a 12500 12501 4102
a 12501 12502 4102
a 12502 12503 4102
a 12503 12504 4102
a 12504 12505 4102
a 12505 12506 4102
a 12506 12507 4102
a 12507 12508 4102
a 12508 12509 4102
a 12509 12510 4102
a 12510 12511 4102
a 12511 12512 4102
a 12512 12513 4102
a 12513 12514 4102
a 12514 12515 4102
a 12515 12516 4102
a 12516 12517 4102
a 12517 12518 4102
a 12518 12519 4102
a 12519 12520 4102
a 12520 12521 4102
a 12521 12522 4102
a 12522 12523 4102
a 12523 12524 4102
a 12524 12525 4102
a 12525 12526 4102
a 12526 12527 4102
a 12527 12528 4102
a 12528 12529 4102
a 12529 12530 4102
a 12530 12531 4102
a 12531 12532 4102
a 12532 12533 4102
a 12533 12534 4102
a 12534 12535 4102
a 12535 12536 4102
a 12536 12537 4102
a 12537 12538 4102
a 12538 12539 4102
a 12539 12540 4102
a 12540 12541 4102
a 12541 12542 4102
a 12542 12543 4102
a 12543 12544 4102
a 12544 12545 4102
a 12545 12546 4102
a 12546 12547 4102
a 12547 12548 4102
a 12548 12549 4102
a 12549 12550 4102
a 12550 12551 4102
a 12551 12552 4102
a 12552 12553 4102
a 12553 12554 4102
a 12554 12555 4102
a 12555 12556 4102
a 12556 12557 4102
a 12557 12558 4102
a 12558 12559 4102
a 12559 12560 4102
a 12560 12561 4102
a 12561 12562 4102
a 12562 12563 4102
a 12563 12564 4102
a 12564 12565 4102
a 12565 12566 4102
a 12566 12567 4102
a 12567 12568 4102
a 12568 12569 4102
a 12569 12570 4102
a 12570 12571 4102
a 12571 12572 4102
a 12572 12573 4102
a 12573 12574 4102
a 12574 12575 4102
a 12575 12576 4102
a 12576 12577 4102
a 12577 12578 4102
a 12578 12579 4102
a 12579 12580 4102
a 12580 12581 4102
a 12581 12582 4102
a 12582 12583 4102
a 12583 12584 4102
a 12584 12585 4102
a 12585 12586 4102
a 12586 12587 4102
a 12587 12588 4102
a 12588 12589 4102
a 12589 12590 4102
a 12590 12591 4102
a 12591 12592 4102
a 12592 12593 4102
a 12593 12594 4102
a 12594 12595 4102
a 12595 12596 4102
a 12596 12597 4102
a 12597 12598 4102
a 12598 12599 4102
a 12599 12600 4102
a 12600 12601 4102
a 12601 12602 4102
a 12602 12603 4102
a 12603 12604 4102
a 12604 12605 4102
a 12605 12606 4102
a 12606 12607 4102
a 12607 12608 4102
a 12608 12609 4102
a 12609 12610 4102
a 12610 12611 4102
a 12611 12612 4102
a 12612 12613 4102
a 12613 12614 4102
a 12614 12615 4102
a 12615 12616 4102
a 12616 12617 4102
a 12617 12618 4102
a 12618 12619 4102
a 12619 12620 4102
a 12620 12621 4102
a 12621 12622 4102
a 12622 12623 4102
a 12623 12624 4102
a 12624 12625 4102
a 12625 12626 4102
a 12626 12627 4102
a 12627 12628 4102
a 12628 12629 4102
a 12629 12630 4102
a 12630 12631 4102
a 12631 12632 4102
a 12632 12633 4102
a 12633 12634 4102
a 12634 12635 4102
a 12635 12636 4102
a 12636 12637 4102
a 12637 12638 4102
a 12638 12639 4102
a 12639 12640 4102
a 12640 12641 4102
a 12641 12642 4102
a 12642 12643 4102
a 12643 12644 4102
a 12644 12645 4102
a 12645 12646 4102
a 12646 12647 4102
a 12647 12648 4102
a 12648 12649 4102
a 12649 12650 4102
a 12650 12651 4102
a 12651 12652 4102
a 12652 12653 4102
a 12653 12654 4102
a 12654 12655 4102
a 12655 12656 4102
a 12656 12657 4102
a 12657 12658 4102
a 12658 12659 4102
a 12659 12660 4102
a 12660 12661 4102
a 12661 12662 4102
a 12662 12663 4102
a 12663 12664 4102
a 12664 12665 4102
a 12665 12666 4102
a 12666 12667 4102
a 12667 12668 4102
a 12668 12669 4102
a 12669 12670 4102
a 12670 12671 4102
a 12671 12672 4102
a 12672 12673 4102
a 12673 12674 4102
a 12674 12675 4102
a 12675 12676 4102
a 12676 12677 4102
a 12677 12678 4102
a 12678 12679 4102
a 12679 12680 4102
a 12680 12681 4102
a 12681 12682 4102
a 12682 12683 4102
a 12683 12684 4102
a 12684 12685 4102
a 12685 12686 4102
a 12686 12687 4102
a 12687 12688 4102
a 12688 12689 4102
a 12689 12690 4102
a 12690 12691 4102
a 12691 12692 4102
a 12692 12693 4102
a 12693 12694 4102
a 12694 12695 4102
a 12695 12696 4102
a 12696 12697 4102
a 12697 12698 4102
a 12698 12699 4102
a 12699 12700 4102
a 12700 12701 4102
a 12701 12702 4102
a 12702 12703 4102
a 12703 12704 4102
a 12704 12705 4102
a 12705 12706 4102
a 12706 12707 4102
a 12707 12708 4102
a 12708 12709 4102
a 12709 12710 4102
a 12710 12711 4102
a 12711 12712 4102
a 12712 12713 4102
a 12713 12714 4102
a 12714 12715 4102
a 12715 12716 4102
a 12716 12717 4102
a 12717 12718 4102
a 12718 12719 4102
a 12719 12720 4102
a 12720 12721 4102
a 12721 12722 4102
a 12722 12723 4102
a 12723 12724 4102
a 12724 12725 4102
a 12725 12726 4102
a 12726 12727 4102
a 12727 12728 4102
a 12728 12729 4102
a 12729 12730 4102
a 12730 12731 4102
a 12731 12732 4102
a 12732 12733 4102
a 12733 12734 4102
a 12734 12735 4102
a 12735 12736 4102
a 12736 12737 4102
a 12737 12738 4102
a 12738 12739 4102
a 12739 12740 4102
a 12740 12741 4102
a 12741 12742 4102
a 12742 12743 4102
a 12743 12744 4102
a 12744 12745 4102
a 12745 12746 4102
a 12746 12747 4102
a 12747 12748 4102
a 12748 12749 4102
a 12749 12750 4102
a 12750 12751 4102
a 12751 12752 4102
a 12752 12753 4102
a 12753 12754 4102
a 12754 12755 4102
a 12755 12756 4102
a 12756 12757 4102
a 12757 12758 4102
a 12758 12759 4102
a 12759 12760 4102
a 12760 12761 4102
a 12761 12762 4102
a 12762 12763 4102
a 12763 12764 4102
a 12764 12765 4102
a 12765 12766 4102
a 12766 12767 4102
a 12767 12768 4102
a 12768 12769 4102
a 12769 12770 4102
a 12770 12771 4102
a 12771 12772 4102
a 12772 12773 4102
a 12773 12774 4102
a 12774 12775 4102
a 12775 12776 4102
a 12776 12777 4102
a 12777 12778 4102
a 12778 12779 4102
a 12779 12780 4102
a 12780 12781 4102
a 12781 12782 4102
a 12782 12783 4102
a 12783 12784 4102
a 12784 12785 4102
a 12785 12786 4102
a 12786 12787 4102
a 12787 12788 4102
a 12788 12789 4102
a 12789 12790 4102
a 12790 12791 4102
a 12791 12792 4102
a 12792 12793 4102
a 12793 12794 4102
a 12794 12795 4102
a 12795 12796 4102
a 12796 12797 4102
a 12797 12798 4102
a 12798 12799 4102
a 12799 12800 4102
a 12800 12801 4102
a 12801 12802 4102
a 12802 12803 4102
a 12803 12804 4102
a 12804 12805 4102
a 12805 12806 4102
a 12806 12807 4102
a 12807 12808 4102
a 12808 12809 4102
a 12809 12810 4102
a 12810 12811 4102
a 12811 12812 4102
a 12812 12813 4102
a 12813 12814 4102
a 12814 12815 4102
a 12815 12816 4102
a 12816 12817 4102
a 12817 12818 4102
a 12818 12819 4102
a 12819 12820 4102
a 12820 12821 4102
a 12821 12822 4102
a 12822 12823 4102
a 12823 12824 4102
a 12824 12825 4102
a 12825 12826 4102
a 12826 12827 4102
a 12827 12828 4102
a 12828 12829 4102
a 12829 12830 4102
a 12830 12831 4102
a 12831 12832 4102
a 12832 12833 4102
a 12833 12834 4102
a 12834 12835 4102
a 12835 12836 4102
a 12836 12837 4102
a 12837 12838 4102
a 12838 12839 4102
a 12839 12840 4102
a 12840 12841 4102
a 12841 12842 4102
a 12842 12843 4102
a 12843 12844 4102
a 12844 12845 4102
a 12845 12846 4102
a 12846 12847 4102
a 12847 12848 4102
a 12848 12849 4102
a 12849 12850 4102
a 12850 12851 4102
a 12851 12852 4102
a 12852 12853 4102
a 12853 12854 4102
a 12854 12855 4102
a 12855 12856 4102
a 12856 12857 4102
a 12857 12858 4102
a 12858 12859 4102
a 12859 12860 4102
a 12860 12861 4102
a 12861 12862 4102
a 12862 12863 4102
a 12863 12864 4102
a 12864 12865 4102
a 12865 12866 4102
a 12866 12867 4102
a 12867 12868 4102
a 12868 12869 4102
a 12869 12870 4102
a 12870 12871 4102
a 12871 12872 4102
a 12872 12873 4102
a 12873 12874 4102
a 12874 12875 4102
a 12875 12876 4102
a 12876 12877 4102
a 12877 12878 4102
a 12878 12879 4102
a 12879 12880 4102
a 12880 12881 4102
a 12881 12882 4102
a 12882 12883 4102
a 12883 12884 4102
a 12884 12885 4102
a 12885 12886 4102
a 12886 12887 4102
a 12887 12888 4102
a 12888 12889 4102
a 12889 12890 4102
a 12890 12891 4102
a 12891 12892 4102
a 12892 12893 4102
a 12893 12894 4102
a 12894 12895 4102
a 12895 12896 4102
a 12896 12897 4102
a 12897 12898 4102
a 12898 12899 4102
a 12899 12900 4102
a 12900 12901 4102
a 12901 12902 4102
a 12902 12903 4102
a 12903 12904 4102
a 12904 12905 4102
a 12905 12906 4102
a 12906 12907 4102
a 12907 12908 4102
a 12908 12909 4102
a 12909 12910 4102
a 12910 12911 4102
a 12911 12912 4102
a 12912 12913 4102
a 12913 12914 4102
a 12914 12915 4102
a 12915 12916 4102
a 12916 12917 4102
a 12917 12918 4102
a 12918 12919 4102
a 12919 12920 4102
a 12920 12921 4102
a 12921 12922 4102
a 12922 12923 4102
a 12923 12924 4102
a 12924 12925 4102
a 12925 12926 4102
a 12926 12927 4102
a 12927 12928 4102
a 12928 12929 4102
a 12929 12930 4102
a 12930 12931 4102
a 12931 12932 4102
a 12932 12933 4102
a 12933 12934 4102
a 12934 12935 4102
a 12935 12936 4102
a 12936 12937 4102
a 12937 12938 4102
a 12938 12939 4102
a 12939 12940 4102
a 12940 12941 4102
a 12941 12942 4102
a 12942 12943 4102
a 12943 12944 4102
a 12944 12945 4102
a 12945 12946 4102
a 12946 12947 4102
a 12947 12948 4102
a 12948 12949 4102
a 12949 12950 4102
a 12950 12951 4102
a 12951 12952 4102
a 12952 12953 4102
a 12953 12954 4102
a 12954 12955 4102
a 12955 12956 4102
a 12956 12957 4102
a 12957 12958 4102
a 12958 12959 4102
a 12959 12960 4102
a 12960 12961 4102
a 12961 12962 4102
a 12962 12963 4102
a 12963 12964 4102
a 12964 12965 4102
a 12965 12966 4102
a 12966 12967 4102
a 12967 12968 4102
a 12968 12969 4102
a 12969 12970 4102
a 12970 12971 4102
a 12971 12972 4102
a 12972 12973 4102
a 12973 12974 4102
a 12974 12975 4102
a 12975 12976 4102
a 12976 12977 4102
a 12977 12978 4102
a 12978 12979 4102
a 12979 12980 4102
a 12980 12981 4102
a 12981 12982 4102
a 12982 12983 4102
a 12983 12984 4102
a 12984 12985 4102
a 12985 12986 4102
a 12986 12987 4102
a 12987 12988 4102
a 12988 12989 4102
a 12989 12990 4102
a 12990 12991 4102
a 12991 12992 4102
a 12992 12993 4102
a 12993 12994 4102
a 12994 12995 4102
a 12995 12996 4102
a 12996 12997 4102
a 12997 12998 4102
a 12998 12999 4102
a 12999 13000 4102
a 13000 13001 4102
a 13001 13002 4102
a 13002 13003 4102
a 13003 13004 4102
a 13004 13005 4102
a 13005 13006 4102
a 13006 13007 4102
a 13007 13008 4102
a 13008 13009 4102
a 13009 13010 4102
a 13010 13011 4102
a 13011 13012 4102
a 13012 13013 4102
a 13013 13014 4102
a 13014 13015 4102
a 13015 13016 4102
a 13016 13017 4102
a 13017 13018 4102
a 13018 13019 4102
a 13019 13020 4102
a 13020 13021 4102
a 13021 13022 4102
a 13022 13023 4102
a 13023 13024 4102
a 13024 13025 4102
a 13025 13026 4102
a 13026 13027 4102
a 13027 13028 4102
a 13028 13029 4102
a 13029 13030 4102
a 13030 13031 4102
a 13031 13032 4102
a 13032 13033 4102
a 13033 13034 4102
a 13034 13035 4102
a 13035 13036 4102
a 13036 13037 4102
a 13037 13038 4102
a 13038 13039 4102
a 13039 13040 4102
a 13040 13041 4102
a 13041 13042 4102
a 13042 13043 4102
a 13043 13044 4102
a 13044 13045 4102
a 13045 13046 4102
a 13046 13047 4102
a 13047 13048 4102
a 13048 13049 4102
a 13049 13050 4102
a 13050 13051 4102
a 13051 13052 4102
a 13052 13053 4102
a 13053 13054 4102
a 13054 13055 4102
a 13055 13056 4102
a 13056 13057 4102
a 13057 13058 4102
a 13058 13059 4102
a 13059 13060 4102
a 13060 13061 4102
a 13061 13062 4102
a 13062 13063 4102
a 13063 13064 4102
a 13064 13065 4102
a 13065 13066 4102
a 13066 13067 4102
a 13067 13068 4102
a 13068 13069 4102
a 13069 13070 4102
a 13070 13071 4102
a 13071 13072 4102
a 13072 13073 4102
a 13073 13074 4102
a 13074 13075 4102
a 13075 13076 4102
a 13076 13077 4102
a 13077 13078 4102
a 13078 13079 4102
a 13079 13080 4102
a 13080 13081 4102
a 13081 13082 4102
a 13082 13083 4102
a 13083 13084 4102
a 13084 13085 4102
a 13085 13086 4102
a 13086 13087 4102
a 13087 13088 4102
a 13088 13089 4102
a 13089 13090 4102
a 13090 13091 4102
a 13091 13092 4102
a 13092 13093 4102
a 13093 13094 4102
a 13094 13095 4102
a 13095 13096 4102
a 13096 13097 4102
a 13097 13098 4102
a 13098 13099 4102
a 13099 13100 4102
a 13100 13101 4102
a 13101 13102 4102
a 13102 13103 4102
a 13103 13104 4102
a 13104 13105 4102
a 13105 13106 4102
a 13106 13107 4102
a 13107 13108 4102
a 13108 13109 4102
a 13109 13110 4102
a 13110 13111 4102
a 13111 13112 4102
a 13112 13113 4102
a 13113 13114 4102
a 13114 13115 4102
a 13115 13116 4102
a 13116 13117 4102
a 13117 13118 4102
a 13118 13119 4102
a 13119 13120 4102
a 13120 13121 4102
a 13121 13122 4102
a 13122 13123 4102
a 13123 13124 4102
a 13124 13125 4102
a 13125 13126 4102
a 13126 13127 4102
a 13127 13128 4102
a 13128 13129 4102
a 13129 13130 4102
a 13130 13131 4102
a 13131 13132 4102
a 13132 13133 4102
a 13133 13134 4102
a 13134 13135 4102
a 13135 13136 4102
a 13136 13137 4102
a 13137 13138 4102
a 13138 13139 4102
a 13139 13140 4102
a 13140 13141 4102
a 13141 13142 4102
a 13142 13143 4102
a 13143 13144 4102
a 13144 13145 4102
a 13145 13146 4102
a 13146 13147 4102
a 13147 13148 4102
a 13148 13149 4102
a 13149 13150 4102
a 13150 13151 4102
a 13151 13152 4102
a 13152 13153 4102
a 13153 13154 4102
a 13154 13155 4102
a 13155 13156 4102
a 13156 13157 4102
a 13157 13158 4102
a 13158 13159 4102
a 13159 13160 4102
a 13160 13161 4102
a 13161 13162 4102
a 13162 13163 4102
a 13163 13164 4102
a 13164 13165 4102
a 13165 13166 4102
a 13166 13167 4102
a 13167 13168 4102
a 13168 13169 4102
a 13169 13170 4102
a 13170 13171 4102
a 13171 13172 4102
a 13172 13173 4102
a 13173 13174 4102
a 13174 13175 4102
a 13175 13176 4102
a 13176 13177 4102
a 13177 13178 4102
a 13178 13179 4102
a 13179 13180 4102
a 13180 13181 4102
a 13181 13182 4102
a 13182 13183 4102
a 13183 13184 4102
a 13184 13185 4102
a 13185 13186 4102
a 13186 13187 4102
a 13187 13188 4102
a 13188 13189 4102
a 13189 13190 4102
a 13190 13191 4102
a 13191 13192 4102
a 13192 13193 4102
a 13193 13194 4102
a 13194 13195 4102
a 13195 13196 4102
a 13196 13197 4102
a 13197 13198 4102
a 13198 13199 4102
a 13199 13200 4102
a 13200 13201 4102
a 13201 13202 4102
a 13202 13203 4102
a 13203 13204 4102
a 13204 13205 4102
a 13205 13206 4102
a 13206 13207 4102
a 13207 13208 4102
a 13208 13209 4102
a 13209 13210 4102
a 13210 13211 4102
a 13211 13212 4102
a 13212 13213 4102
a 13213 13214 4102
a 13214 13215 4102
a 13215 13216 4102
a 13216 13217 4102
a 13217 13218 4102
a 13218 13219 4102
a 13219 13220 4102
a 13220 13221 4102
a 13221 13222 4102
a 13222 13223 4102
a 13223 13224 4102
a 13224 13225 4102
a 13225 13226 4102
a 13226 13227 4102
a 13227 13228 4102
a 13228 13229 4102
a 13229 13230 4102
a 13230 13231 4102
a 13231 13232 4102
a 13232 13233 4102
a 13233 13234 4102
a 13234 13235 4102
a 13235 13236 4102
a 13236 13237 4102
a 13237 13238 4102
a 13238 13239 4102
a 13239 13240 4102
a 13240 13241 4102
a 13241 13242 4102
a 13242 13243 4102
a 13243 13244 4102
a 13244 13245 4102
a 13245 13246 4102
a 13246 13247 4102
a 13247 13248 4102
a 13248 13249 4102
a 13249 13250 4102
a 13250 13251 4102
a 13251 13252 4102
a 13252 13253 4102
a 13253 13254 4102
a 13254 13255 4102
a 13255 13256 4102
a 13256 13257 4102
a 13257 13258 4102
a 13258 13259 4102
a 13259 13260 4102
a 13260 13261 4102
a 13261 13262 4102
a 13262 13263 4102
a 13263 13264 4102
a 13264 13265 4102
a 13265 13266 4102
a 13266 13267 4102
a 13267 13268 4102
a 13268 13269 4102
a 13269 13270 4102
a 13270 13271 4102
a 13271 13272 4102
a 13272 13273 4102
a 13273 13274 4102
a 13274 13275 4102
a 13275 13276 4102
a 13276 13277 4102
a 13277 13278 4102
a 13278 13279 4102
a 13279 13280 4102
a 13280 13281 4102
a 13281 13282 4102
a 13282 13283 4102
a 13283 13284 4102
a 13284 13285 4102
a 13285 13286 4102
a 13286 13287 4102
a 13287 13288 4102
a 13288 13289 4102
a 13289 13290 4102
a 13290 13291 4102
a 13291 13292 4102
a 13292 13293 4102
a 13293 13294 4102
a 13294 13295 4102
a 13295 13296 4102
a 13296 13297 4102
a 13297 13298 4102
a 13298 13299 4102
a 13299 13300 4102
a 13300 13301 4102
a 13301 13302 4102
a 13302 13303 4102
a 13303 13304 4102
a 13304 13305 4102
a 13305 13306 4102
a 13306 13307 4102
a 13307 13308 4102
a 13308 13309 4102
a 13309 13310 4102
a 13310 13311 4102
a 13311 13312 4102
a 13312 13313 4102
a 13313 13314 4102
a 13314 13315 4102
a 13315 13316 4102
a 13316 13317 4102
a 13317 13318 4102
a 13318 13319 4102
a 13319 13320 4102
a 13320 13321 4102
a 13321 13322 4102
a 13322 13323 4102
a 13323 13324 4102
a 13324 13325 4102
a 13325 13326 4102
a 13326 13327 4102
a 13327 13328 4102
a 13328 13329 4102
a 13329 13330 4102
a 13330 13331 4102
a 13331 13332 4102
a 13332 13333 4102
a 13333 13334 4102
a 13334 13335 4102
a 13335 13336 4102
a 13336 13337 4102
a 13337 13338 4102
a 13338 13339 4102
a 13339 13340 4102
a 13340 13341 4102
a 13341 13342 4102
a 13342 13343 4102
a 13343 13344 4102
a 13344 13345 4102
a 13345 13346 4102
a 13346 13347 4102
a 13347 13348 4102
a 13348 13349 4102
a 13349 13350 4102
a 13350 13351 4102
a 13351 13352 4102
a 13352 13353 4102
a 13353 13354 4102
a 13354 13355 4102
a 13355 13356 4102
a 13356 13357 4102
a 13357 13358 4102
a 13358 13359 4102
a 13359 13360 4102
a 13360 13361 4102
a 13361 13362 4102
a 13362 13363 4102
a 13363 13364 4102
a 13364 13365 4102
a 13365 13366 4102
a 13366 13367 4102
a 13367 13368 4102
a 13368 13369 4102
a 13369 13370 4102
a 13370 13371 4102
a 13371 13372 4102
a 13372 13373 4102
a 13373 13374 4102
a 13374 13375 4102
a 13375 13376 4102
a 13376 13377 4102
a 13377 13378 4102
a 13378 13379 4102
a 13379 13380 4102
a 13380 13381 4102
a 13381 13382 4102
a 13382 13383 4102
a 13383 13384 4102
a 13384 13385 4102
a 13385 13386 4102
a 13386 13387 4102
a 13387 13388 4102
a 13388 13389 4102
a 13389 13390 4102
a 13390 13391 4102
a 13391 13392 4102
a 13392 13393 4102
a 13393 13394 4102
a 13394 13395 4102
a 13395 13396 4102
a 13396 13397 4102
a 13397 13398 4102
a 13398 13399 4102
a 13399 13400 4102
a 13400 13401 4102
a 13401 13402 4102
a 13402 13403 4102
a 13403 13404 4102
a 13404 13405 4102
a 13405 13406 4102
a 13406 13407 4102
a 13407 13408 4102
a 13408 13409 4102
a 13409 13410 4102
a 13410 13411 4102
a 13411 13412 4102
a 13412 13413 4102
a 13413 13414 4102
a 13414 13415 4102
a 13415 13416 4102
a 13416 13417 4102
a 13417 13418 4102
a 13418 13419 4102
a 13419 13420 4102
a 13420 13421 4102
a 13421 13422 4102
a 13422 13423 4102
a 13423 13424 4102
a 13424 13425 4102
a 13425 13426 4102
a 13426 13427 4102
a 13427 13428 4102
a 13428 13429 4102
a 13429 13430 4102
a 13430 13431 4102
a 13431 13432 4102
a 13432 13433 4102
a 13433 13434 4102
a 13434 13435 4102
a 13435 13436 4102
a 13436 13437 4102
a 13437 13438 4102
a 13438 13439 4102
a 13439 13440 4102
a 13440 13441 4102
a 13441 13442 4102
a 13442 13443 4102
a 13443 13444 4102
a 13444 13445 4102
a 13445 13446 4102
a 13446 13447 4102
a 13447 13448 4102
a 13448 13449 4102
a 13449 13450 4102
a 13450 13451 4102
a 13451 13452 4102
a 13452 13453 4102
a 13453 13454 4102
a 13454 13455 4102
a 13455 13456 4102
a 13456 13457 4102
a 13457 13458 4102
a 13458 13459 4102
a 13459 13460 4102
a 13460 13461 4102
a 13461 13462 4102
a 13462 13463 4102
a 13463 13464 4102
a 13464 13465 4102
a 13465 13466 4102
a 13466 13467 4102
a 13467 13468 4102
a 13468 13469 4102
a 13469 13470 4102
a 13470 13471 4102
a 13471 13472 4102
a 13472 13473 4102
a 13473 13474 4102
a 13474 13475 4102
a 13475 13476 4102
a 13476 13477 4102
a 13477 13478 4102
a 13478 13479 4102
a 13479 13480 4102
a 13480 13481 4102
a 13481 13482 4102
a 13482 13483 4102
a 13483 13484 4102
a 13484 13485 4102
a 13485 13486 4102
a 13486 13487 4102
a 13487 13488 4102
a 13488 13489 4102
a 13489 13490 4102
a 13490 13491 4102
a 13491 13492 4102
a 13492 13493 4102
a 13493 13494 4102
a 13494 13495 4102
a 13495 13496 4102
a 13496 13497 4102
a 13497 13498 4102
a 13498 13499 4102
a 13499 13500 4102
a 13500 13501 4102
a 13501 13502 4102
a 13502 13503 4102
a 13503 13504 4102
a 13504 13505 4102
a 13505 13506 4102
a 13506 13507 4102
a 13507 13508 4102
a 13508 13509 4102
a 13509 13510 4102
a 13510 13511 4102
a 13511 13512 4102
a 13512 13513 4102
a 13513 13514 4102
a 13514 13515 4102
a 13515 13516 4102
a 13516 13517 4102
a 13517 13518 4102
a 13518 13519 4102
a 13519 13520 4102
a 13520 13521 4102
a 13521 13522 4102
a 13522 13523 4102
a 13523 13524 4102
a 13524 13525 4102
a 13525 13526 4102
a 13526 13527 4102
a 13527 13528 4102
a 13528 13529 4102
a 13529 13530 4102
a 13530 13531 4102
a 13531 13532 4102
a 13532 13533 4102
a 13533 13534 4102
a 13534 13535 4102
a 13535 13536 4102
a 13536 13537 4102
a 13537 13538 4102
a 13538 13539 4102
a 13539 13540 4102
a 13540 13541 4102
a 13541 13542 4102
a 13542 13543 4102
a 13543 13544 4102
a 13544 13545 4102
a 13545 13546 4102
a 13546 13547 4102
a 13547 13548 4102
a 13548 13549 4102
a 13549 13550 4102
a 13550 13551 4102
a 13551 13552 4102
a 13552 13553 4102
a 13553 13554 4102
a 13554 13555 4102
a 13555 13556 4102
a 13556 13557 4102
a 13557 13558 4102
a 13558 13559 4102
a 13559 13560 4102
a 13560 13561 4102
a 13561 13562 4102
a 13562 13563 4102
a 13563 13564 4102
a 13564 13565 4102
a 13565 13566 4102
a 13566 13567 4102
a 13567 13568 4102
a 13568 13569 4102
a 13569 13570 4102
a 13570 13571 4102
a 13571 13572 4102
a 13572 13573 4102
a 13573 13574 4102
a 13574 13575 4102
a 13575 13576 4102
a 13576 13577 4102
a 13577 13578 4102
a 13578 13579 4102
a 13579 13580 4102
a 13580 13581 4102
a 13581 13582 4102
a 13582 13583 4102
a 13583 13584 4102
a 13584 13585 4102
a 13585 13586 4102
a 13586 13587 4102
a 13587 13588 4102
a 13588 13589 4102
a 13589 13590 4102
a 13590 13591 4102
a 13591 13592 4102
a 13592 13593 4102
a 13593 13594 4102
a 13594 13595 4102
a 13595 13596 4102
a 13596 13597 4102
a 13597 13598 4102
a 13598 13599 4102
a 13599 13600 4102
a 13600 13601 4102
a 13601 13602 4102
a 13602 13603 4102
a 13603 13604 4102
a 13604 13605 4102
a 13605 13606 4102
a 13606 13607 4102
a 13607 13608 4102
a 13608 13609 4102
a 13609 13610 4102
a 13610 13611 4102
a 13611 13612 4102
a 13612 13613 4102
a 13613 13614 4102
a 13614 13615 4102
a 13615 13616 4102
a 13616 13617 4102
a 13617 13618 4102
a 13618 13619 4102
a 13619 13620 4102
a 13620 13621 4102
a 13621 13622 4102
a 13622 13623 4102
a 13623 13624 4102
a 13624 13625 4102
a 13625 13626 4102
a 13626 13627 4102
a 13627 13628 4102
a 13628 13629 4102
a 13629 13630 4102
a 13630 13631 4102
a 13631 13632 4102
a 13632 13633 4102
a 13633 13634 4102
a 13634 13635 4102
a 13635 13636 4102
a 13636 13637 4102
a 13637 13638 4102
a 13638 13639 4102
a 13639 13640 4102
a 13640 13641 4102
a 13641 13642 4102
a 13642 13643 4102
a 13643 13644 4102
a 13644 13645 4102
a 13645 13646 4102
a 13646 13647 4102
a 13647 13648 4102
a 13648 13649 4102
a 13649 13650 4102
a 13650 13651 4102
a 13651 13652 4102
a 13652 13653 4102
a 13653 13654 4102
a 13654 13655 4102
a 13655 13656 4102
a 13656 13657 4102
a 13657 13658 4102
a 13658 13659 4102
a 13659 13660 4102
a 13660 13661 4102
a 13661 13662 4102
a 13662 13663 4102
a 13663 13664 4102
a 13664 13665 4102
a 13665 13666 4102
a 13666 13667 4102
a 13667 13668 4102
a 13668 13669 4102
a 13669 13670 4102
a 13670 13671 4102
a 13671 13672 4102
a 13672 13673 4102
a 13673 13674 4102
a 13674 13675 4102
a 13675 13676 4102
a 13676 13677 4102
a 13677 13678 4102
a 13678 13679 4102
a 13679 13680 4102
a 13680 13681 4102
a 13681 13682 4102
a 13682 13683 4102
a 13683 13684 4102
a 13684 13685 4102
a 13685 13686 4102
a 13686 13687 4102
a 13687 13688 4102
a 13688 13689 4102
a 13689 13690 4102
a 13690 13691 4102
a 13691 13692 4102
a 13692 13693 4102
a 13693 13694 4102
a 13694 13695 4102
a 13695 13696 4102
a 13696 13697 4102
a 13697 13698 4102
a 13698 13699 4102
a 13699 13700 4102
a 13700 13701 4102
a 13701 13702 4102
a 13702 13703 4102
a 13703 13704 4102
a 13704 13705 4102
a 13705 13706 4102
a 13706 13707 4102
a 13707 13708 4102
a 13708 13709 4102
a 13709 13710 4102
a 13710 13711 4102
a 13711 13712 4102
a 13712 13713 4102
a 13713 13714 4102
a 13714 13715 4102
a 13715 13716 4102
a 13716 13717 4102
a 13717 13718 4102
a 13718 13719 4102
a 13719 13720 4102
a 13720 13721 4102
a 13721 13722 4102
a 13722 13723 4102
a 13723 13724 4102
a 13724 13725 4102
a 13725 13726 4102
a 13726 13727 4102
a 13727 13728 4102
a 13728 13729 4102
a 13729 13730 4102
a 13730 13731 4102
a 13731 13732 4102
a 13732 13733 4102
a 13733 13734 4102
a 13734 13735 4102
a 13735 13736 4102
a 13736 13737 4102
a 13737 13738 4102
a 13738 13739 4102
a 13739 13740 4102
a 13740 13741 4102
a 13741 13742 4102
a 13742 13743 4102
a 13743 13744 4102
a 13744 13745 4102
a 13745 13746 4102
a 13746 13747 4102
a 13747 13748 4102
a 13748 13749 4102
a 13749 13750 4102
a 13750 13751 4102
a 13751 13752 4102
a 13752 13753 4102
a 13753 13754 4102
a 13754 13755 4102
a 13755 13756 4102
a 13756 13757 4102
a 13757 13758 4102
a 13758 13759 4102
a 13759 13760 4102
a 13760 13761 4102
a 13761 13762 4102
a 13762 13763 4102
a 13763 13764 4102
a 13764 13765 4102
a 13765 13766 4102
a 13766 13767 4102
a 13767 13768 4102
a 13768 13769 4102
a 13769 13770 4102
a 13770 13771 4102
a 13771 13772 4102
a 13772 13773 4102
a 13773 13774 4102
a 13774 13775 4102
a 13775 13776 4102
a 13776 13777 4102
a 13777 13778 4102
a 13778 13779 4102
a 13779 13780 4102
a 13780 13781 4102
a 13781 13782 4102
a 13782 13783 4102
a 13783 13784 4102
a 13784 13785 4102
a 13785 13786 4102
a 13786 13787 4102
a 13787 13788 4102
a 13788 13789 4102
a 13789 13790 4102
a 13790 13791 4102
a 13791 13792 4102
a 13792 13793 4102
a 13793 13794 4102
a 13794 13795 4102
a 13795 13796 4102
a 13796 13797 4102
a 13797 13798 4102
a 13798 13799 4102
a 13799 13800 4102
a 13800 13801 4102
a 13801 13802 4102
a 13802 13803 4102
a 13803 13804 4102
a 13804 13805 4102
a 13805 13806 4102
a 13806 13807 4102
a 13807 13808 4102
a 13808 13809 4102
a 13809 13810 4102
a 13810 13811 4102
a 13811 13812 4102
a 13812 13813 4102
a 13813 13814 4102
a 13814 13815 4102
a 13815 13816 4102
a 13816 13817 4102
a 13817 13818 4102
a 13818 13819 4102
a 13819 13820 4102
a 13820 13821 4102
a 13821 13822 4102
a 13822 13823 4102
a 13823 13824 4102
a 13824 13825 4102
a 13825 13826 4102
a 13826 13827 4102
a 13827 13828 4102
a 13828 13829 4102
a 13829 13830 4102
a 13830 13831 4102
a 13831 13832 4102
a 13832 13833 4102
a 13833 13834 4102
a 13834 13835 4102
a 13835 13836 4102
a 13836 13837 4102
a 13837 13838 4102
a 13838 13839 4102
a 13839 13840 4102
a 13840 13841 4102
a 13841 13842 4102
a 13842 13843 4102
a 13843 13844 4102
a 13844 13845 4102
a 13845 13846 4102
a 13846 13847 4102
a 13847 13848 4102
a 13848 13849 4102
a 13849 13850 4102
a 13850 13851 4102
a 13851 13852 4102
a 13852 13853 4102
a 13853 13854 4102
a 13854 13855 4102
a 13855 13856 4102
a 13856 13857 4102
a 13857 13858 4102
a 13858 13859 4102
a 13859 13860 4102
a 13860 13861 4102
a 13861 13862 4102
a 13862 13863 4102
a 13863 13864 4102
a 13864 13865 4102
a 13865 13866 4102
a 13866 13867 4102
a 13867 13868 4102
a 13868 13869 4102
a 13869 13870 4102
a 13870 13871 4102
a 13871 13872 4102
a 13872 13873 4102
a 13873 13874 4102
a 13874 13875 4102
a 13875 13876 4102
a 13876 13877 4102
a 13877 13878 4102
a 13878 13879 4102
a 13879 13880 4102
a 13880 13881 4102
a 13881 13882 4102
a 13882 13883 4102
a 13883 13884 4102
a 13884 13885 4102
a 13885 13886 4102
a 13886 13887 4102
a 13887 13888 4102
a 13888 13889 4102
a 13889 13890 4102
a 13890 13891 4102
a 13891 13892 4102
a 13892 13893 4102
a 13893 13894 4102
a 13894 13895 4102
a 13895 13896 4102
a 13896 13897 4102
a 13897 13898 4102
a 13898 13899 4102
a 13899 13900 4102
a 13900 13901 4102
a 13901 13902 4102
a 13902 13903 4102
a 13903 13904 4102
a 13904 13905 4102
a 13905 13906 4102
a 13906 13907 4102
a 13907 13908 4102
a 13908 13909 4102
a 13909 13910 4102
a 13910 13911 4102
a 13911 13912 4102
a 13912 13913 4102
a 13913 13914 4102
a 13914 13915 4102
a 13915 13916 4102
a 13916 13917 4102
a 13917 13918 4102
a 13918 13919 4102
a 13919 13920 4102
a 13920 13921 4102
a 13921 13922 4102
a 13922 13923 4102
a 13923 13924 4102
a 13924 13925 4102
a 13925 13926 4102
a 13926 13927 4102
a 13927 13928 4102
a 13928 13929 4102
a 13929 13930 4102
a 13930 13931 4102
a 13931 13932 4102
a 13932 13933 4102
a 13933 13934 4102
a 13934 13935 4102
a 13935 13936 4102
a 13936 13937 4102
a 13937 13938 4102
a 13938 13939 4102
a 13939 13940 4102
a 13940 13941 4102
a 13941 13942 4102
a 13942 13943 4102
a 13943 13944 4102
a 13944 13945 4102
a 13945 13946 4102
a 13946 13947 4102
a 13947 13948 4102
a 13948 13949 4102
a 13949 13950 4102
a 13950 13951 4102
a 13951 13952 4102
a 13952 13953 4102
a 13953 13954 4102
a 13954 13955 4102
a 13955 13956 4102
a 13956 13957 4102
a 13957 13958 4102
a 13958 13959 4102
a 13959 13960 4102
a 13960 13961 4102
a 13961 13962 4102
a 13962 13963 4102
a 13963 13964 4102
a 13964 13965 4102
a 13965 13966 4102
a 13966 13967 4102
a 13967 13968 4102
a 13968 13969 4102
a 13969 13970 4102
a 13970 13971 4102
a 13971 13972 4102
a 13972 13973 4102
a 13973 13974 4102
a 13974 13975 4102
a 13975 13976 4102
a 13976 13977 4102
a 13977 13978 4102
a 13978 13979 4102
a 13979 13980 4102
a 13980 13981 4102
a 13981 13982 4102
a 13982 13983 4102
a 13983 13984 4102
a 13984 13985 4102
a 13985 13986 4102
a 13986 13987 4102
a 13987 13988 4102
a 13988 13989 4102
a 13989 13990 4102
a 13990 13991 4102
a 13991 13992 4102
a 13992 13993 4102
a 13993 13994 4102
a 13994 13995 4102
a 13995 13996 4102
a 13996 13997 4102
a 13997 13998 4102
a 13998 13999 4102
a 13999 14000 4102
a 14000 14001 4102
a 14001 14002 4102
a 14002 14003 4102
a 14003 14004 4102
a 14004 14005 4102
a 14005 14006 4102
a 14006 14007 4102
a 14007 14008 4102
a 14008 14009 4102
a 14009 14010 4102
a 14010 14011 4102
a 14011 14012 4102
a 14012 14013 4102
a 14013 14014 4102
a 14014 14015 4102
a 14015 14016 4102
a 14016 14017 4102
a 14017 14018 4102
a 14018 14019 4102
a 14019 14020 4102
a 14020 14021 4102
a 14021 14022 4102
a 14022 14023 4102
a 14023 14024 4102
a 14024 14025 4102
a 14025 14026 4102
a 14026 14027 4102
a 14027 14028 4102
a 14028 14029 4102
a 14029 14030 4102
a 14030 14031 4102
a 14031 14032 4102
a 14032 14033 4102
a 14033 14034 4102
a 14034 14035 4102
a 14035 14036 4102
a 14036 14037 4102
a 14037 14038 4102
a 14038 14039 4102
a 14039 14040 4102
a 14040 14041 4102
a 14041 14042 4102
a 14042 14043 4102
a 14043 14044 4102
a 14044 14045 4102
a 14045 14046 4102
a 14046 14047 4102
a 14047 14048 4102
a 14048 14049 4102
a 14049 14050 4102
a 14050 14051 4102
a 14051 14052 4102
a 14052 14053 4102
a 14053 14054 4102
a 14054 14055 4102
a 14055 14056 4102
a 14056 14057 4102
a 14057 14058 4102
a 14058 14059 4102
a 14059 14060 4102
a 14060 14061 4102
a 14061 14062 4102
a 14062 14063 4102
a 14063 14064 4102
a 14064 14065 4102
a 14065 14066 4102
a 14066 14067 4102
a 14067 14068 4102
a 14068 14069 4102
a 14069 14070 4102
a 14070 14071 4102
a 14071 14072 4102
a 14072 14073 4102
a 14073 14074 4102
a 14074 14075 4102
a 14075 14076 4102
a 14076 14077 4102
a 14077 14078 4102
a 14078 14079 4102
a 14079 14080 4102
a 14080 14081 4102
a 14081 14082 4102
a 14082 14083 4102
a 14083 14084 4102
a 14084 14085 4102
a 14085 14086 4102
a 14086 14087 4102
a 14087 14088 4102
a 14088 14089 4102
a 14089 14090 4102
a 14090 14091 4102
a 14091 14092 4102
a 14092 14093 4102
a 14093 14094 4102
a 14094 14095 4102
a 14095 14096 4102
a 14096 14097 4102
a 14097 14098 4102
a 14098 14099 4102
a 14099 14100 4102
a 14100 14101 4102
a 14101 14102 4102
a 14102 14103 4102
a 14103 14104 4102
a 14104 14105 4102
a 14105 14106 4102
a 14106 14107 4102
a 14107 14108 4102
a 14108 14109 4102
a 14109 14110 4102
a 14110 14111 4102
a 14111 14112 4102
a 14112 14113 4102
a 14113 14114 4102
a 14114 14115 4102
a 14115 14116 4102
a 14116 14117 4102
a 14117 14118 4102
a 14118 14119 4102
a 14119 14120 4102
a 14120 14121 4102
a 14121 14122 4102
a 14122 14123 4102
a 14123 14124 4102
a 14124 14125 4102
a 14125 14126 4102
a 14126 14127 4102
a 14127 14128 4102
a 14128 14129 4102
a 14129 14130 4102
a 14130 14131 4102
a 14131 14132 4102
a 14132 14133 4102
a 14133 14134 4102
a 14134 14135 4102
a 14135 14136 4102
a 14136 14137 4102
a 14137 14138 4102
a 14138 14139 4102
a 14139 14140 4102
a 14140 14141 4102
a 14141 14142 4102
a 14142 14143 4102
a 14143 14144 4102
a 14144 14145 4102
a 14145 14146 4102
a 14146 14147 4102
a 14147 14148 4102
a 14148 14149 4102
a 14149 14150 4102
a 14150 14151 4102
a 14151 14152 4102
a 14152 14153 4102
a 14153 14154 4102
a 14154 14155 4102
a 14155 14156 4102
a 14156 14157 4102
a 14157 14158 4102
a 14158 14159 4102
a 14159 14160 4102
a 14160 14161 4102
a 14161 14162 4102
a 14162 14163 4102
a 14163 14164 4102
a 14164 14165 4102
a 14165 14166 4102
a 14166 14167 4102
a 14167 14168 4102
a 14168 14169 4102
a 14169 14170 4102
a 14170 14171 4102
a 14171 14172 4102
a 14172 14173 4102
a 14173 14174 4102
a 14174 14175 4102
a 14175 14176 4102
a 14176 14177 4102
a 14177 14178 4102
a 14178 14179 4102
a 14179 14180 4102
a 14180 14181 4102
a 14181 14182 4102
a 14182 14183 4102
a 14183 14184 4102
a 14184 14185 4102
a 14185 14186 4102
a 14186 14187 4102
a 14187 14188 4102
a 14188 14189 4102
a 14189 14190 4102
a 14190 14191 4102
a 14191 14192 4102
a 14192 14193 4102
a 14193 14194 4102
a 14194 14195 4102
a 14195 14196 4102
a 14196 14197 4102
a 14197 14198 4102
a 14198 14199 4102
a 14199 14200 4102
a 14200 14201 4102
a 14201 14202 4102
a 14202 14203 4102
a 14203 14204 4102
a 14204 14205 4102
a 14205 14206 4102
a 14206 14207 4102
a 14207 14208 4102
a 14208 14209 4102
a 14209 14210 4102
a 14210 14211 4102
a 14211 14212 4102
a 14212 14213 4102
a 14213 14214 4102
a 14214 14215 4102
a 14215 14216 4102
a 14216 14217 4102
a 14217 14218 4102
a 14218 14219 4102
a 14219 14220 4102
a 14220 14221 4102
a 14221 14222 4102
a 14222 14223 4102
a 14223 14224 4102
a 14224 14225 4102
a 14225 14226 4102
a 14226 14227 4102
a 14227 14228 4102
a 14228 14229 4102
a 14229 14230 4102
a 14230 14231 4102
a 14231 14232 4102
a 14232 14233 4102
a 14233 14234 4102
a 14234 14235 4102
a 14235 14236 4102
a 14236 14237 4102
a 14237 14238 4102
a 14238 14239 4102
a 14239 14240 4102
a 14240 14241 4102
a 14241 14242 4102
a 14242 14243 4102
a 14243 14244 4102
a 14244 14245 4102
a 14245 14246 4102
a 14246 14247 4102
a 14247 14248 4102
a 14248 14249 4102
a 14249 14250 4102
a 14250 14251 4102
a 14251 14252 4102
a 14252 14253 4102
a 14253 14254 4102
a 14254 14255 4102
a 14255 14256 4102
a 14256 14257 4102
a 14257 14258 4102
a 14258 14259 4102
a 14259 14260 4102
a 14260 14261 4102
a 14261 14262 4102
a 14262 14263 4102
a 14263 14264 4102
a 14264 14265 4102
a 14265 14266 4102
a 14266 14267 4102
a 14267 14268 4102
a 14268 14269 4102
a 14269 14270 4102
a 14270 14271 4102
a 14271 14272 4102
a 14272 14273 4102
a 14273 14274 4102
a 14274 14275 4102
a 14275 14276 4102
a 14276 14277 4102
a 14277 14278 4102
a 14278 14279 4102
a 14279 14280 4102
a 14280 14281 4102
a 14281 14282 4102
a 14282 14283 4102
a 14283 14284 4102
a 14284 14285 4102
a 14285 14286 4102
a 14286 14287 4102
a 14287 14288 4102
a 14288 14289 4102
a 14289 14290 4102
a 14290 14291 4102
a 14291 14292 4102
a 14292 14293 4102
a 14293 14294 4102
a 14294 14295 4102
a 14295 14296 4102
a 14296 14297 4102
a 14297 14298 4102
a 14298 14299 4102
a 14299 14300 4102
a 14300 14301 4102
a 14301 14302 4102
a 14302 14303 4102
a 14303 14304 4102
a 14304 14305 4102
a 14305 14306 4102
a 14306 14307 4102
a 14307 14308 4102
a 14308 14309 4102
a 14309 14310 4102
a 14310 14311 4102
a 14311 14312 4102
a 14312 14313 4102
a 14313 14314 4102
a 14314 14315 4102
a 14315 14316 4102
a 14316 14317 4102
a 14317 14318 4102
a 14318 14319 4102
a 14319 14320 4102
a 14320 14321 4102
a 14321 14322 4102
a 14322 14323 4102
a 14323 14324 4102
a 14324 14325 4102
a 14325 14326 4102
a 14326 14327 4102
a 14327 14328 4102
a 14328 14329 4102
a 14329 14330 4102
a 14330 14331 4102
a 14331 14332 4102
a 14332 14333 4102
a 14333 14334 4102
a 14334 14335 4102
a 14335 14336 4102
a 14336 14337 4102
a 14337 14338 4102
a 14338 14339 4102
a 14339 14340 4102
a 14340 14341 4102
a 14341 14342 4102
a 14342 14343 4102
a 14343 14344 4102
a 14344 14345 4102
a 14345 14346 4102
a 14346 14347 4102
a 14347 14348 4102
a 14348 14349 4102
a 14349 14350 4102
a 14350 14351 4102
a 14351 14352 4102
a 14352 14353 4102
a 14353 14354 4102
a 14354 14355 4102
a 14355 14356 4102
a 14356 14357 4102
a 14357 14358 4102
a 14358 14359 4102
a 14359 14360 4102
a 14360 14361 4102
a 14361 14362 4102
a 14362 14363 4102
a 14363 14364 4102
a 14364 14365 4102
a 14365 14366 4102
a 14366 14367 4102
a 14367 14368 4102
a 14368 14369 4102
a 14369 14370 4102
a 14370 14371 4102
a 14371 14372 4102
a 14372 14373 4102
a 14373 14374 4102
a 14374 14375 4102
a 14375 14376 4102
a 14376 14377 4102
a 14377 14378 4102
a 14378 14379 4102
a 14379 14380 4102
a 14380 14381 4102
a 14381 14382 4102
a 14382 14383 4102
a 14383 14384 4102
a 14384 14385 4102
a 14385 14386 4102
a 14386 14387 4102
a 14387 14388 4102
a 14388 14389 4102
a 14389 14390 4102
a 14390 14391 4102
a 14391 14392 4102
a 14392 14393 4102
a 14393 14394 4102
a 14394 14395 4102
a 14395 14396 4102
a 14396 14397 4102
a 14397 14398 4102
a 14398 14399 4102
a 14399 14400 4102
a 14400 14401 4102
a 14401 14402 4102
a 14402 14403 4102
a 14403 14404 4102
a 14404 14405 4102
a 14405 14406 4102
a 14406 14407 4102
a 14407 14408 4102
a 14408 14409 4102
a 14409 14410 4102
a 14410 14411 4102
a 14411 14412 4102
a 14412 14413 4102
a 14413 14414 4102
a 14414 14415 4102
a 14415 14416 4102
a 14416 14417 4102
a 14417 14418 4102
a 14418 14419 4102
a 14419 14420 4102
a 14420 14421 4102
a 14421 14422 4102
a 14422 14423 4102
a 14423 14424 4102
a 14424 14425 4102
a 14425 14426 4102
a 14426 14427 4102
a 14427 14428 4102
a 14428 14429 4102
a 14429 14430 4102
a 14430 14431 4102
a 14431 14432 4102
a 14432 14433 4102
a 14433 14434 4102
a 14434 14435 4102
a 14435 14436 4102
a 14436 14437 4102
a 14437 14438 4102
a 14438 14439 4102
a 14439 14440 4102
a 14440 14441 4102
a 14441 14442 4102
a 14442 14443 4102
a 14443 14444 4102
a 14444 14445 4102
a 14445 14446 4102
a 14446 14447 4102
a 14447 14448 4102
a 14448 14449 4102
a 14449 14450 4102
a 14450 14451 4102
a 14451 14452 4102
a 14452 14453 4102
a 14453 14454 4102
a 14454 14455 4102
a 14455 14456 4102
a 14456 14457 4102
a 14457 14458 4102
a 14458 14459 4102
a 14459 14460 4102
a 14460 14461 4102
a 14461 14462 4102
a 14462 14463 4102
a 14463 14464 4102
a 14464 14465 4102
a 14465 14466 4102
a 14466 14467 4102
a 14467 14468 4102
a 14468 14469 4102
a 14469 14470 4102
a 14470 14471 4102
a 14471 14472 4102
a 14472 14473 4102
a 14473 14474 4102
a 14474 14475 4102
a 14475 14476 4102
a 14476 14477 4102
a 14477 14478 4102
a 14478 14479 4102
a 14479 14480 4102
a 14480 14481 4102
a 14481 14482 4102
a 14482 14483 4102
a 14483 14484 4102
a 14484 14485 4102
a 14485 14486 4102
a 14486 14487 4102
a 14487 14488 4102
a 14488 14489 4102
a 14489 14490 4102
a 14490 14491 4102
a 14491 14492 4102
a 14492 14493 4102
a 14493 14494 4102
a 14494 14495 4102
a 14495 14496 4102
a 14496 14497 4102
a 14497 14498 4102
a 14498 14499 4102
a 14499 14500 4102
a 14500 14501 4102
a 14501 14502 4102
a 14502 14503 4102
a 14503 14504 4102
a 14504 14505 4102
a 14505 14506 4102
a 14506 14507 4102
a 14507 14508 4102
a 14508 14509 4102
a 14509 14510 4102
a 14510 14511 4102
a 14511 14512 4102
a 14512 14513 4102
a 14513 14514 4102
a 14514 14515 4102
a 14515 14516 4102
a 14516 14517 4102
a 14517 14518 4102
a 14518 14519 4102
a 14519 14520 4102
a 14520 14521 4102
a 14521 14522 4102
a 14522 14523 4102
a 14523 14524 4102
a 14524 14525 4102
a 14525 14526 4102
a 14526 14527 4102
a 14527 14528 4102
a 14528 14529 4102
a 14529 14530 4102
a 14530 14531 4102
a 14531 14532 4102
a 14532 14533 4102
a 14533 14534 4102
a 14534 14535 4102
a 14535 14536 4102
a 14536 14537 4102
a 14537 14538 4102
a 14538 14539 4102
a 14539 14540 4102
a 14540 14541 4102
a 14541 14542 4102
a 14542 14543 4102
a 14543 14544 4102
a 14544 14545 4102
a 14545 14546 4102
a 14546 14547 4102
a 14547 14548 4102
a 14548 14549 4102
a 14549 14550 4102
a 14550 14551 4102
a 14551 14552 4102
a 14552 14553 4102
a 14553 14554 4102
a 14554 14555 4102
a 14555 14556 4102
a 14556 14557 4102
a 14557 14558 4102
a 14558 14559 4102
a 14559 14560 4102
a 14560 14561 4102
a 14561 14562 4102
a 14562 14563 4102
a 14563 14564 4102
a 14564 14565 4102
a 14565 14566 4102
a 14566 14567 4102
a 14567 14568 4102
a 14568 14569 4102
a 14569 14570 4102
a 14570 14571 4102
a 14571 14572 4102
a 14572 14573 4102
a 14573 14574 4102
a 14574 14575 4102
a 14575 14576 4102
a 14576 14577 4102
a 14577 14578 4102
a 14578 14579 4102
a 14579 14580 4102
a 14580 14581 4102
a 14581 14582 4102
a 14582 14583 4102
a 14583 14584 4102
a 14584 14585 4102
a 14585 14586 4102
a 14586 14587 4102
a 14587 14588 4102
a 14588 14589 4102
a 14589 14590 4102
a 14590 14591 4102
a 14591 14592 4102
a 14592 14593 4102
a 14593 14594 4102
a 14594 14595 4102
a 14595 14596 4102
a 14596 14597 4102
a 14597 14598 4102
a 14598 14599 4102
a 14599 14600 4102
a 14600 14601 4102
a 14601 14602 4102
a 14602 14603 4102
a 14603 14604 4102
a 14604 14605 4102
a 14605 14606 4102
a 14606 14607 4102
a 14607 14608 4102
a 14608 14609 4102
a 14609 14610 4102
a 14610 14611 4102
a 14611 14612 4102
a 14612 14613 4102
a 14613 14614 4102
a 14614 14615 4102
a 14615 14616 4102
a 14616 14617 4102
a 14617 14618 4102
a 14618 14619 4102
a 14619 14620 4102
a 14620 14621 4102
a 14621 14622 4102
a 14622 14623 4102
a 14623 14624 4102
a 14624 14625 4102
a 14625 14626 4102
a 14626 14627 4102
a 14627 14628 4102
a 14628 14629 4102
a 14629 14630 4102
a 14630 14631 4102
a 14631 14632 4102
a 14632 14633 4102
a 14633 14634 4102
a 14634 14635 4102
a 14635 14636 4102
a 14636 14637 4102
a 14637 14638 4102
a 14638 14639 4102
a 14639 14640 4102
a 14640 14641 4102
a 14641 14642 4102
a 14642 14643 4102
a 14643 14644 4102
a 14644 14645 4102
a 14645 14646 4102
a 14646 14647 4102
a 14647 14648 4102
a 14648 14649 4102
a 14649 14650 4102
a 14650 14651 4102
a 14651 14652 4102
a 14652 14653 4102
a 14653 14654 4102
a 14654 14655 4102
a 14655 14656 4102
a 14656 14657 4102
a 14657 14658 4102
a 14658 14659 4102
a 14659 14660 4102
a 14660 14661 4102
a 14661 14662 4102
a 14662 14663 4102
a 14663 14664 4102
a 14664 14665 4102
a 14665 14666 4102
a 14666 14667 4102
a 14667 14668 4102
a 14668 14669 4102
a 14669 14670 4102
a 14670 14671 4102
a 14671 14672 4102
a 14672 14673 4102
a 14673 14674 4102
a 14674 14675 4102
a 14675 14676 4102
a 14676 14677 4102
a 14677 14678 4102
a 14678 14679 4102
a 14679 14680 4102
a 14680 14681 4102
a 14681 14682 4102
a 14682 14683 4102
a 14683 14684 4102
a 14684 14685 4102
a 14685 14686 4102
a 14686 14687 4102
a 14687 14688 4102
a 14688 14689 4102
a 14689 14690 4102
a 14690 14691 4102
a 14691 14692 4102
a 14692 14693 4102
a 14693 14694 4102
a 14694 14695 4102
a 14695 14696 4102
a 14696 14697 4102
a 14697 14698 4102
a 14698 14699 4102
a 14699 14700 4102
a 14700 14701 4102
a 14701 14702 4102
a 14702 14703 4102
a 14703 14704 4102
a 14704 14705 4102
a 14705 14706 4102
a 14706 14707 4102
a 14707 14708 4102
a 14708 14709 4102
a 14709 14710 4102
a 14710 14711 4102
a 14711 14712 4102
a 14712 14713 4102
a 14713 14714 4102
a 14714 14715 4102
a 14715 14716 4102
a 14716 14717 4102
a 14717 14718 4102
a 14718 14719 4102
a 14719 14720 4102
a 14720 14721 4102
a 14721 14722 4102
a 14722 14723 4102
a 14723 14724 4102
a 14724 14725 4102
a 14725 14726 4102
a 14726 14727 4102
a 14727 14728 4102
a 14728 14729 4102
a 14729 14730 4102
a 14730 14731 4102
a 14731 14732 4102
a 14732 14733 4102
a 14733 14734 4102
a 14734 14735 4102
a 14735 14736 4102
a 14736 14737 4102
a 14737 14738 4102
a 14738 14739 4102
a 14739 14740 4102
a 14740 14741 4102
a 14741 14742 4102
a 14742 14743 4102
a 14743 14744 4102
a 14744 14745 4102
a 14745 14746 4102
a 14746 14747 4102
a 14747 14748 4102
a 14748 14749 4102
a 14749 14750 4102
a 14750 14751 4102
a 14751 14752 4102
a 14752 14753 4102
a 14753 14754 4102
a 14754 14755 4102
a 14755 14756 4102
a 14756 14757 4102
a 14757 14758 4102
a 14758 14759 4102
a 14759 14760 4102
a 14760 14761 4102
a 14761 14762 4102
a 14762 14763 4102
a 14763 14764 4102
a 14764 14765 4102
a 14765 14766 4102
a 14766 14767 4102
a 14767 14768 4102
a 14768 14769 4102
a 14769 14770 4102
a 14770 14771 4102
a 14771 14772 4102
a 14772 14773 4102
a 14773 14774 4102
a 14774 14775 4102
a 14775 14776 4102
a 14776 14777 4102
a 14777 14778 4102
a 14778 14779 4102
a 14779 14780 4102
a 14780 14781 4102
a 14781 14782 4102
a 14782 14783 4102
a 14783 14784 4102
a 14784 14785 4102
a 14785 14786 4102
a 14786 14787 4102
a 14787 14788 4102
a 14788 14789 4102
a 14789 14790 4102
a 14790 14791 4102
a 14791 14792 4102
a 14792 14793 4102
a 14793 14794 4102
a 14794 14795 4102
a 14795 14796 4102
a 14796 14797 4102
a 14797 14798 4102
a 14798 14799 4102
a 14799 14800 4102
a 14800 14801 4102
a 14801 14802 4102
a 14802 14803 4102
a 14803 14804 4102
a 14804 14805 4102
a 14805 14806 4102
a 14806 14807 4102
a 14807 14808 4102
a 14808 14809 4102
a 14809 14810 4102
a 14810 14811 4102
a 14811 14812 4102
a 14812 14813 4102
a 14813 14814 4102
a 14814 14815 4102
a 14815 14816 4102
a 14816 14817 4102
a 14817 14818 4102
a 14818 14819 4102
a 14819 14820 4102
a 14820 14821 4102
a 14821 14822 4102
a 14822 14823 4102
a 14823 14824 4102
a 14824 14825 4102
a 14825 14826 4102
a 14826 14827 4102
a 14827 14828 4102
a 14828 14829 4102
a 14829 14830 4102
a 14830 14831 4102
a 14831 14832 4102
a 14832 14833 4102
a 14833 14834 4102
a 14834 14835 4102
a 14835 14836 4102
a 14836 14837 4102
a 14837 14838 4102
a 14838 14839 4102
a 14839 14840 4102
a 14840 14841 4102
a 14841 14842 4102
a 14842 14843 4102
a 14843 14844 4102
a 14844 14845 4102
a 14845 14846 4102
a 14846 14847 4102
a 14847 14848 4102
a 14848 14849 4102
a 14849 14850 4102
a 14850 14851 4102
a 14851 14852 4102
a 14852 14853 4102
a 14853 14854 4102
a 14854 14855 4102
a 14855 14856 4102
a 14856 14857 4102
a 14857 14858 4102
a 14858 14859 4102
a 14859 14860 4102
a 14860 14861 4102
a 14861 14862 4102
a 14862 14863 4102
a 14863 14864 4102
a 14864 14865 4102
a 14865 14866 4102
a 14866 14867 4102
a 14867 14868 4102
a 14868 14869 4102
a 14869 14870 4102
a 14870 14871 4102
a 14871 14872 4102
a 14872 14873 4102
a 14873 14874 4102
a 14874 14875 4102
a 14875 14876 4102
a 14876 14877 4102
a 14877 14878 4102
a 14878 14879 4102
a 14879 14880 4102
a 14880 14881 4102
a 14881 14882 4102
a 14882 14883 4102
a 14883 14884 4102
a 14884 14885 4102
a 14885 14886 4102
a 14886 14887 4102
a 14887 14888 4102
a 14888 14889 4102
a 14889 14890 4102
a 14890 14891 4102
a 14891 14892 4102
a 14892 14893 4102
a 14893 14894 4102
a 14894 14895 4102
a 14895 14896 4102
a 14896 14897 4102
a 14897 14898 4102
a 14898 14899 4102
a 14899 14900 4102
a 14900 14901 4102
a 14901 14902 4102
a 14902 14903 4102
a 14903 14904 4102
a 14904 14905 4102
a 14905 14906 4102
a 14906 14907 4102
a 14907 14908 4102
a 14908 14909 4102
a 14909 14910 4102
a 14910 14911 4102
a 14911 14912 4102
a 14912 14913 4102
a 14913 14914 4102
a 14914 14915 4102
a 14915 14916 4102
a 14916 14917 4102
a 14917 14918 4102
a 14918 14919 4102
a 14919 14920 4102
a 14920 14921 4102
a 14921 14922 4102
a 14922 14923 4102
a 14923 14924 4102
a 14924 14925 4102
a 14925 14926 4102
a 14926 14927 4102
a 14927 14928 4102
a 14928 14929 4102
a 14929 14930 4102
a 14930 14931 4102
a 14931 14932 4102
a 14932 14933 4102
a 14933 14934 4102
a 14934 14935 4102
a 14935 14936 4102
a 14936 14937 4102
a 14937 14938 4102
a 14938 14939 4102
a 14939 14940 4102
a 14940 14941 4102
a 14941 14942 4102
a 14942 14943 4102
a 14943 14944 4102
a 14944 14945 4102
a 14945 14946 4102
a 14946 14947 4102
a 14947 14948 4102
a 14948 14949 4102
a 14949 14950 4102
a 14950 14951 4102
a 14951 14952 4102
a 14952 14953 4102
a 14953 14954 4102
a 14954 14955 4102
a 14955 14956 4102
a 14956 14957 4102
a 14957 14958 4102
a 14958 14959 4102
a 14959 14960 4102
a 14960 14961 4102
a 14961 14962 4102
a 14962 14963 4102
a 14963 14964 4102
a 14964 14965 4102
a 14965 14966 4102
a 14966 14967 4102
a 14967 14968 4102
a 14968 14969 4102
a 14969 14970 4102
a 14970 14971 4102
a 14971 14972 4102
a 14972 14973 4102
a 14973 14974 4102
a 14974 14975 4102
a 14975 14976 4102
a 14976 14977 4102
a 14977 14978 4102
a 14978 14979 4102
a 14979 14980 4102
a 14980 14981 4102
a 14981 14982 4102
a 14982 14983 4102
a 14983 14984 4102
a 14984 14985 4102
a 14985 14986 4102
a 14986 14987 4102
a 14987 14988 4102
a 14988 14989 4102
a 14989 14990 4102
a 14990 14991 4102
a 14991 14992 4102
a 14992 14993 4102
a 14993 14994 4102
a 14994 14995 4102
a 14995 14996 4102
a 14996 14997 4102
a 14997 14998 4102
a 14998 14999 4102
a 14999 15000 4102
a 15000 15001 4102
a 15001 15002 4102
a 15002 15003 4102
a 15003 15004 4102
a 15004 15005 4102
a 15005 15006 4102
a 15006 15007 4102
a 15007 15008 4102
a 15008 15009 4102
a 15009 15010 4102
a 15010 15011 4102
a 15011 15012 4102
a 15012 15013 4102
a 15013 15014 4102
a 15014 15015 4102
a 15015 15016 4102
a 15016 15017 4102
a 15017 15018 4102
a 15018 15019 4102
a 15019 15020 4102
a 15020 15021 4102
a 15021 15022 4102
a 15022 15023 4102
a 15023 15024 4102
a 15024 15025 4102
a 15025 15026 4102
a 15026 15027 4102
a 15027 15028 4102
a 15028 15029 4102
a 15029 15030 4102
a 15030 15031 4102
a 15031 15032 4102
a 15032 15033 4102
a 15033 15034 4102
a 15034 15035 4102
a 15035 15036 4102
a 15036 15037 4102
a 15037 15038 4102
a 15038 15039 4102
a 15039 15040 4102
a 15040 15041 4102
a 15041 15042 4102
a 15042 15043 4102
a 15043 15044 4102
a 15044 15045 4102
a 15045 15046 4102
a 15046 15047 4102
a 15047 15048 4102
a 15048 15049 4102
a 15049 15050 4102
a 15050 15051 4102
a 15051 15052 4102
a 15052 15053 4102
a 15053 15054 4102
a 15054 15055 4102
a 15055 15056 4102
a 15056 15057 4102
a 15057 15058 4102
a 15058 15059 4102
a 15059 15060 4102
a 15060 15061 4102
a 15061 15062 4102
a 15062 15063 4102
a 15063 15064 4102
a 15064 15065 4102
a 15065 15066 4102
a 15066 15067 4102
a 15067 15068 4102
a 15068 15069 4102
a 15069 15070 4102
a 15070 15071 4102
a 15071 15072 4102
a 15072 15073 4102
a 15073 15074 4102
a 15074 15075 4102
a 15075 15076 4102
a 15076 15077 4102
a 15077 15078 4102
a 15078 15079 4102
a 15079 15080 4102
a 15080 15081 4102
a 15081 15082 4102
a 15082 15083 4102
a 15083 15084 4102
a 15084 15085 4102
a 15085 15086 4102
a 15086 15087 4102
a 15087 15088 4102
a 15088 15089 4102
a 15089 15090 4102
a 15090 15091 4102
a 15091 15092 4102
a 15092 15093 4102
a 15093 15094 4102
a 15094 15095 4102
a 15095 15096 4102
a 15096 15097 4102
a 15097 15098 4102
a 15098 15099 4102
a 15099 15100 4102
a 15100 15101 4102
a 15101 15102 4102
a 15102 15103 4102
a 15103 15104 4102
a 15104 15105 4102
a 15105 15106 4102
a 15106 15107 4102
a 15107 15108 4102
a 15108 15109 4102
a 15109 15110 4102
a 15110 15111 4102
a 15111 15112 4102
a 15112 15113 4102
a 15113 15114 4102
a 15114 15115 4102
a 15115 15116 4102
a 15116 15117 4102
a 15117 15118 4102
a 15118 15119 4102
a 15119 15120 4102
a 15120 15121 4102
a 15121 15122 4102
a 15122 15123 4102
a 15123 15124 4102
a 15124 15125 4102
a 15125 15126 4102
a 15126 15127 4102
a 15127 15128 4102
a 15128 15129 4102
a 15129 15130 4102
a 15130 15131 4102
a 15131 15132 4102
a 15132 15133 4102
a 15133 15134 4102
a 15134 15135 4102
a 15135 15136 4102
a 15136 15137 4102
a 15137 15138 4102
a 15138 15139 4102
a 15139 15140 4102
a 15140 15141 4102
a 15141 15142 4102
a 15142 15143 4102
a 15143 15144 4102
a 15144 15145 4102
a 15145 15146 4102
a 15146 15147 4102
a 15147 15148 4102
a 15148 15149 4102
a 15149 15150 4102
a 15150 15151 4102
a 15151 15152 4102
a 15152 15153 4102
a 15153 15154 4102
a 15154 15155 4102
a 15155 15156 4102
a 15156 15157 4102
a 15157 15158 4102
a 15158 15159 4102
a 15159 15160 4102
a 15160 15161 4102
a 15161 15162 4102
a 15162 15163 4102
a 15163 15164 4102
a 15164 15165 4102
a 15165 15166 4102
a 15166 15167 4102
a 15167 15168 4102
a 15168 15169 4102
a 15169 15170 4102
a 15170 15171 4102
a 15171 15172 4102
a 15172 15173 4102
a 15173 15174 4102
a 15174 15175 4102
a 15175 15176 4102
a 15176 15177 4102
a 15177 15178 4102
a 15178 15179 4102
a 15179 15180 4102
a 15180 15181 4102
a 15181 15182 4102
a 15182 15183 4102
a 15183 15184 4102
a 15184 15185 4102
a 15185 15186 4102
a 15186 15187 4102
a 15187 15188 4102
a 15188 15189 4102
a 15189 15190 4102
a 15190 15191 4102
a 15191 15192 4102
a 15192 15193 4102
a 15193 15194 4102
a 15194 15195 4102
a 15195 15196 4102
a 15196 15197 4102
a 15197 15198 4102
a 15198 15199 4102
a 15199 15200 4102
a 15200 15201 4102
a 15201 15202 4102
a 15202 15203 4102
a 15203 15204 4102
a 15204 15205 4102
a 15205 15206 4102
a 15206 15207 4102
a 15207 15208 4102
a 15208 15209 4102
a 15209 15210 4102
a 15210 15211 4102
a 15211 15212 4102
a 15212 15213 4102
a 15213 15214 4102
a 15214 15215 4102
a 15215 15216 4102
a 15216 15217 4102
a 15217 15218 4102
a 15218 15219 4102
a 15219 15220 4102
a 15220 15221 4102
a 15221 15222 4102
a 15222 15223 4102
a 15223 15224 4102
a 15224 15225 4102
a 15225 15226 4102
a 15226 15227 4102
a 15227 15228 4102
a 15228 15229 4102
a 15229 15230 4102
a 15230 15231 4102
a 15231 15232 4102
a 15232 15233 4102
a 15233 15234 4102
a 15234 15235 4102
a 15235 15236 4102
a 15236 15237 4102
a 15237 15238 4102
a 15238 15239 4102
a 15239 15240 4102
a 15240 15241 4102
a 15241 15242 4102
a 15242 15243 4102
a 15243 15244 4102
a 15244 15245 4102
a 15245 15246 4102
a 15246 15247 4102
a 15247 15248 4102
a 15248 15249 4102
a 15249 15250 4102
a 15250 15251 4102
a 15251 15252 4102
a 15252 15253 4102
a 15253 15254 4102
a 15254 15255 4102
a 15255 15256 4102
a 15256 15257 4102
a 15257 15258 4102
a 15258 15259 4102
a 15259 15260 4102
a 15260 15261 4102
a 15261 15262 4102
a 15262 15263 4102
a 15263 15264 4102
a 15264 15265 4102
a 15265 15266 4102
a 15266 15267 4102
a 15267 15268 4102
a 15268 15269 4102
a 15269 15270 4102
a 15270 15271 4102
a 15271 15272 4102
a 15272 15273 4102
a 15273 15274 4102
a 15274 15275 4102
a 15275 15276 4102
a 15276 15277 4102
a 15277 15278 4102
a 15278 15279 4102
a 15279 15280 4102
a 15280 15281 4102
a 15281 15282 4102
a 15282 15283 4102
a 15283 15284 4102
a 15284 15285 4102
a 15285 15286 4102
a 15286 15287 4102
a 15287 15288 4102
a 15288 15289 4102
a 15289 15290 4102
a 15290 15291 4102
a 15291 15292 4102
a 15292 15293 4102
a 15293 15294 4102
a 15294 15295 4102
a 15295 15296 4102
a 15296 15297 4102
a 15297 15298 4102
a 15298 15299 4102
a 15299 15300 4102
a 15300 15301 4102
a 15301 15302 4102
a 15302 15303 4102
a 15303 15304 4102
a 15304 15305 4102
a 15305 15306 4102
a 15306 15307 4102
a 15307 15308 4102
a 15308 15309 4102
a 15309 15310 4102
a 15310 15311 4102
a 15311 15312 4102
a 15312 15313 4102
a 15313 15314 4102
a 15314 15315 4102
a 15315 15316 4102
a 15316 15317 4102
a 15317 15318 4102
a 15318 15319 4102
a 15319 15320 4102
a 15320 15321 4102
a 15321 15322 4102
a 15322 15323 4102
a 15323 15324 4102
a 15324 15325 4102
a 15325 15326 4102
a 15326 15327 4102
a 15327 15328 4102
a 15328 15329 4102
a 15329 15330 4102
a 15330 15331 4102
a 15331 15332 4102
a 15332 15333 4102
a 15333 15334 4102
a 15334 15335 4102
a 15335 15336 4102
a 15336 15337 4102
a 15337 15338 4102
a 15338 15339 4102
a 15339 15340 4102
a 15340 15341 4102
a 15341 15342 4102
a 15342 15343 4102
a 15343 15344 4102
a 15344 15345 4102
a 15345 15346 4102
a 15346 15347 4102
a 15347 15348 4102
a 15348 15349 4102
a 15349 15350 4102
a 15350 15351 4102
a 15351 15352 4102
a 15352 15353 4102
a 15353 15354 4102
a 15354 15355 4102
a 15355 15356 4102
a 15356 15357 4102
a 15357 15358 4102
a 15358 15359 4102
a 15359 15360 4102
a 15360 15361 4102
a 15361 15362 4102
a 15362 15363 4102
a 15363 15364 4102
a 15364 15365 4102
a 15365 15366 4102
a 15366 15367 4102
a 15367 15368 4102
a 15368 15369 4102
a 15369 15370 4102
a 15370 15371 4102
a 15371 15372 4102
a 15372 15373 4102
a 15373 15374 4102
a 15374 15375 4102
a 15375 15376 4102
a 15376 15377 4102
a 15377 15378 4102
a 15378 15379 4102
a 15379 15380 4102
a 15380 15381 4102
a 15381 15382 4102
a 15382 15383 4102
a 15383 15384 4102
a 15384 15385 4102
a 15385 15386 4102
a 15386 15387 4102
a 15387 15388 4102
a 15388 15389 4102
a 15389 15390 4102
a 15390 15391 4102
a 15391 15392 4102
a 15392 15393 4102
a 15393 15394 4102
a 15394 15395 4102
a 15395 15396 4102
a 15396 15397 4102
a 15397 15398 4102
a 15398 15399 4102
a 15399 15400 4102
a 15400 15401 4102
a 15401 15402 4102
a 15402 15403 4102
a 15403 15404 4102
a 15404 15405 4102
a 15405 15406 4102
a 15406 15407 4102
a 15407 15408 4102
a 15408 15409 4102
a 15409 15410 4102
a 15410 15411 4102
a 15411 15412 4102
a 15412 15413 4102
a 15413 15414 4102
a 15414 15415 4102
a 15415 15416 4102
a 15416 15417 4102
a 15417 15418 4102
a 15418 15419 4102
a 15419 15420 4102
a 15420 15421 4102
a 15421 15422 4102
a 15422 15423 4102
a 15423 15424 4102
a 15424 15425 4102
a 15425 15426 4102
a 15426 15427 4102
a 15427 15428 4102
a 15428 15429 4102
a 15429 15430 4102
a 15430 15431 4102
a 15431 15432 4102
a 15432 15433 4102
a 15433 15434 4102
a 15434 15435 4102
a 15435 15436 4102
a 15436 15437 4102
a 15437 15438 4102
a 15438 15439 4102
a 15439 15440 4102
a 15440 15441 4102
a 15441 15442 4102
a 15442 15443 4102
a 15443 15444 4102
a 15444 15445 4102
a 15445 15446 4102
a 15446 15447 4102
a 15447 15448 4102
a 15448 15449 4102
a 15449 15450 4102
a 15450 15451 4102
a 15451 15452 4102
a 15452 15453 4102
a 15453 15454 4102
a 15454 15455 4102
a 15455 15456 4102
a 15456 15457 4102
a 15457 15458 4102
a 15458 15459 4102
a 15459 15460 4102
a 15460 15461 4102
a 15461 15462 4102
a 15462 15463 4102
a 15463 15464 4102
a 15464 15465 4102
a 15465 15466 4102
a 15466 15467 4102
a 15467 15468 4102
a 15468 15469 4102
a 15469 15470 4102
a 15470 15471 4102
a 15471 15472 4102
a 15472 15473 4102
a 15473 15474 4102
a 15474 15475 4102
a 15475 15476 4102
a 15476 15477 4102
a 15477 15478 4102
a 15478 15479 4102
a 15479 15480 4102
a 15480 15481 4102
a 15481 15482 4102
a 15482 15483 4102
a 15483 15484 4102
a 15484 15485 4102
a 15485 15486 4102
a 15486 15487 4102
a 15487 15488 4102
a 15488 15489 4102
a 15489 15490 4102
a 15490 15491 4102
a 15491 15492 4102
a 15492 15493 4102
a 15493 15494 4102
a 15494 15495 4102
a 15495 15496 4102
a 15496 15497 4102
a 15497 15498 4102
a 15498 15499 4102
a 15499 15500 4102
a 15500 15501 4102
a 15501 15502 4102
a 15502 15503 4102
a 15503 15504 4102
a 15504 15505 4102
a 15505 15506 4102
a 15506 15507 4102
a 15507 15508 4102
a 15508 15509 4102
a 15509 15510 4102
a 15510 15511 4102
a 15511 15512 4102
a 15512 15513 4102
a 15513 15514 4102
a 15514 15515 4102
a 15515 15516 4102
a 15516 15517 4102
a 15517 15518 4102
a 15518 15519 4102
a 15519 15520 4102
a 15520 15521 4102
a 15521 15522 4102
a 15522 15523 4102
a 15523 15524 4102
a 15524 15525 4102
a 15525 15526 4102
a 15526 15527 4102
a 15527 15528 4102
a 15528 15529 4102
a 15529 15530 4102
a 15530 15531 4102
a 15531 15532 4102
a 15532 15533 4102
a 15533 15534 4102
a 15534 15535 4102
a 15535 15536 4102
a 15536 15537 4102
a 15537 15538 4102
a 15538 15539 4102
a 15539 15540 4102
a 15540 15541 4102
a 15541 15542 4102
a 15542 15543 4102
a 15543 15544 4102
a 15544 15545 4102
a 15545 15546 4102
a 15546 15547 4102
a 15547 15548 4102
a 15548 15549 4102
a 15549 15550 4102
a 15550 15551 4102
a 15551 15552 4102
a 15552 15553 4102
a 15553 15554 4102
a 15554 15555 4102
a 15555 15556 4102
a 15556 15557 4102
a 15557 15558 4102
a 15558 15559 4102
a 15559 15560 4102
a 15560 15561 4102
a 15561 15562 4102
a 15562 15563 4102
a 15563 15564 4102
a 15564 15565 4102
a 15565 15566 4102
a 15566 15567 4102
a 15567 15568 4102
a 15568 15569 4102
a 15569 15570 4102
a 15570 15571 4102
a 15571 15572 4102
a 15572 15573 4102
a 15573 15574 4102
a 15574 15575 4102
a 15575 15576 4102
a 15576 15577 4102
a 15577 15578 4102
a 15578 15579 4102
a 15579 15580 4102
a 15580 15581 4102
a 15581 15582 4102
a 15582 15583 4102
a 15583 15584 4102
a 15584 15585 4102
a 15585 15586 4102
a 15586 15587 4102
a 15587 15588 4102
a 15588 15589 4102
a 15589 15590 4102
a 15590 15591 4102
a 15591 15592 4102
a 15592 15593 4102
a 15593 15594 4102
a 15594 15595 4102
a 15595 15596 4102
a 15596 15597 4102
a 15597 15598 4102
a 15598 15599 4102
a 15599 15600 4102
a 15600 15601 4102
a 15601 15602 4102
a 15602 15603 4102
a 15603 15604 4102
a 15604 15605 4102
a 15605 15606 4102
a 15606 15607 4102
a 15607 15608 4102
a 15608 15609 4102
a 15609 15610 4102
a 15610 15611 4102
a 15611 15612 4102
a 15612 15613 4102
a 15613 15614 4102
a 15614 15615 4102
a 15615 15616 4102
a 15616 15617 4102
a 15617 15618 4102
a 15618 15619 4102
a 15619 15620 4102
a 15620 15621 4102
a 15621 15622 4102
a 15622 15623 4102
a 15623 15624 4102
a 15624 15625 4102
a 15625 15626 4102
a 15626 15627 4102
a 15627 15628 4102
a 15628 15629 4102
a 15629 15630 4102
a 15630 15631 4102
a 15631 15632 4102
a 15632 15633 4102
a 15633 15634 4102
a 15634 15635 4102
a 15635 15636 4102
a 15636 15637 4102
a 15637 15638 4102
a 15638 15639 4102
a 15639 15640 4102
a 15640 15641 4102
a 15641 15642 4102
a 15642 15643 4102
a 15643 15644 4102
a 15644 15645 4102
a 15645 15646 4102
a 15646 15647 4102
a 15647 15648 4102
a 15648 15649 4102
a 15649 15650 4102
a 15650 15651 4102
a 15651 15652 4102
a 15652 15653 4102
a 15653 15654 4102
a 15654 15655 4102
a 15655 15656 4102
a 15656 15657 4102
a 15657 15658 4102
a 15658 15659 4102
a 15659 15660 4102
a 15660 15661 4102
a 15661 15662 4102
a 15662 15663 4102
a 15663 15664 4102
a 15664 15665 4102
a 15665 15666 4102
a 15666 15667 4102
a 15667 15668 4102
a 15668 15669 4102
a 15669 15670 4102
a 15670 15671 4102
a 15671 15672 4102
a 15672 15673 4102
a 15673 15674 4102
a 15674 15675 4102
a 15675 15676 4102
a 15676 15677 4102
a 15677 15678 4102
a 15678 15679 4102
a 15679 15680 4102
a 15680 15681 4102
a 15681 15682 4102
a 15682 15683 4102
a 15683 15684 4102
a 15684 15685 4102
a 15685 15686 4102
a 15686 15687 4102
a 15687 15688 4102
a 15688 15689 4102
a 15689 15690 4102
a 15690 15691 4102
a 15691 15692 4102
a 15692 15693 4102
a 15693 15694 4102
a 15694 15695 4102
a 15695 15696 4102
a 15696 15697 4102
a 15697 15698 4102
a 15698 15699 4102
a 15699 15700 4102
a 15700 15701 4102
a 15701 15702 4102
a 15702 15703 4102
a 15703 15704 4102
a 15704 15705 4102
a 15705 15706 4102
a 15706 15707 4102
a 15707 15708 4102
a 15708 15709 4102
a 15709 15710 4102
a 15710 15711 4102
a 15711 15712 4102
a 15712 15713 4102
a 15713 15714 4102
a 15714 15715 4102
a 15715 15716 4102
a 15716 15717 4102
a 15717 15718 4102
a 15718 15719 4102
a 15719 15720 4102
a 15720 15721 4102
a 15721 15722 4102
a 15722 15723 4102
a 15723 15724 4102
a 15724 15725 4102
a 15725 15726 4102
a 15726 15727 4102
a 15727 15728 4102
a 15728 15729 4102
a 15729 15730 4102
a 15730 15731 4102
a 15731 15732 4102
a 15732 15733 4102
a 15733 15734 4102
a 15734 15735 4102
a 15735 15736 4102
a 15736 15737 4102
a 15737 15738 4102
a 15738 15739 4102
a 15739 15740 4102
a 15740 15741 4102
a 15741 15742 4102
a 15742 15743 4102
a 15743 15744 4102
a 15744 15745 4102
a 15745 15746 4102
a 15746 15747 4102
a 15747 15748 4102
a 15748 15749 4102
a 15749 15750 4102
a 15750 15751 4102
a 15751 15752 4102
a 15752 15753 4102
a 15753 15754 4102
a 15754 15755 4102
a 15755 15756 4102
a 15756 15757 4102
a 15757 15758 4102
a 15758 15759 4102
a 15759 15760 4102
a 15760 15761 4102
a 15761 15762 4102
a 15762 15763 4102
a 15763 15764 4102
a 15764 15765 4102
a 15765 15766 4102
a 15766 15767 4102
a 15767 15768 4102
a 15768 15769 4102
a 15769 15770 4102
a 15770 15771 4102
a 15771 15772 4102
a 15772 15773 4102
a 15773 15774 4102
a 15774 15775 4102
a 15775 15776 4102
a 15776 15777 4102
a 15777 15778 4102
a 15778 15779 4102
a 15779 15780 4102
a 15780 15781 4102
a 15781 15782 4102
a 15782 15783 4102
a 15783 15784 4102
a 15784 15785 4102
a 15785 15786 4102
a 15786 15787 4102
a 15787 15788 4102
a 15788 15789 4102
a 15789 15790 4102
a 15790 15791 4102
a 15791 15792 4102
a 15792 15793 4102
a 15793 15794 4102
a 15794 15795 4102
a 15795 15796 4102
a 15796 15797 4102
a 15797 15798 4102
a 15798 15799 4102
a 15799 15800 4102
a 15800 15801 4102
a 15801 15802 4102
a 15802 15803 4102
a 15803 15804 4102
a 15804 15805 4102
a 15805 15806 4102
a 15806 15807 4102
a 15807 15808 4102
a 15808 15809 4102
a 15809 15810 4102
a 15810 15811 4102
a 15811 15812 4102
a 15812 15813 4102
a 15813 15814 4102
a 15814 15815 4102
a 15815 15816 4102
a 15816 15817 4102
a 15817 15818 4102
a 15818 15819 4102
a 15819 15820 4102
a 15820 15821 4102
a 15821 15822 4102
a 15822 15823 4102
a 15823 15824 4102
a 15824 15825 4102
a 15825 15826 4102
a 15826 15827 4102
a 15827 15828 4102
a 15828 15829 4102
a 15829 15830 4102
a 15830 15831 4102
a 15831 15832 4102
a 15832 15833 4102
a 15833 15834 4102
a 15834 15835 4102
a 15835 15836 4102
a 15836 15837 4102
a 15837 15838 4102
a 15838 15839 4102
a 15839 15840 4102
a 15840 15841 4102
a 15841 15842 4102
a 15842 15843 4102
a 15843 15844 4102
a 15844 15845 4102
a 15845 15846 4102
a 15846 15847 4102
a 15847 15848 4102
a 15848 15849 4102
a 15849 15850 4102
a 15850 15851 4102
a 15851 15852 4102
a 15852 15853 4102
a 15853 15854 4102
a 15854 15855 4102
a 15855 15856 4102
a 15856 15857 4102
a 15857 15858 4102
a 15858 15859 4102
a 15859 15860 4102
a 15860 15861 4102
a 15861 15862 4102
a 15862 15863 4102
a 15863 15864 4102
a 15864 15865 4102
a 15865 15866 4102
a 15866 15867 4102
a 15867 15868 4102
a 15868 15869 4102
a 15869 15870 4102
a 15870 15871 4102
a 15871 15872 4102
a 15872 15873 4102
a 15873 15874 4102
a 15874 15875 4102
a 15875 15876 4102
a 15876 15877 4102
a 15877 15878 4102
a 15878 15879 4102
a 15879 15880 4102
a 15880 15881 4102
a 15881 15882 4102
a 15882 15883 4102
a 15883 15884 4102
a 15884 15885 4102
a 15885 15886 4102
a 15886 15887 4102
a 15887 15888 4102
a 15888 15889 4102
a 15889 15890 4102
a 15890 15891 4102
a 15891 15892 4102
a 15892 15893 4102
a 15893 15894 4102
a 15894 15895 4102
a 15895 15896 4102
a 15896 15897 4102
a 15897 15898 4102
a 15898 15899 4102
a 15899 15900 4102
a 15900 15901 4102
a 15901 15902 4102
a 15902 15903 4102
a 15903 15904 4102
a 15904 15905 4102
a 15905 15906 4102
a 15906 15907 4102
a 15907 15908 4102
a 15908 15909 4102
a 15909 15910 4102
a 15910 15911 4102
a 15911 15912 4102
a 15912 15913 4102
a 15913 15914 4102
a 15914 15915 4102
a 15915 15916 4102
a 15916 15917 4102
a 15917 15918 4102
a 15918 15919 4102
a 15919 15920 4102
a 15920 15921 4102
a 15921 15922 4102
a 15922 15923 4102
a 15923 15924 4102
a 15924 15925 4102
a 15925 15926 4102
a 15926 15927 4102
a 15927 15928 4102
a 15928 15929 4102
a 15929 15930 4102
a 15930 15931 4102
a 15931 15932 4102
a 15932 15933 4102
a 15933 15934 4102
a 15934 15935 4102
a 15935 15936 4102
a 15936 15937 4102
a 15937 15938 4102
a 15938 15939 4102
a 15939 15940 4102
a 15940 15941 4102
a 15941 15942 4102
a 15942 15943 4102
a 15943 15944 4102
a 15944 15945 4102
a 15945 15946 4102
a 15946 15947 4102
a 15947 15948 4102
a 15948 15949 4102
a 15949 15950 4102
a 15950 15951 4102
a 15951 15952 4102
a 15952 15953 4102
a 15953 15954 4102
a 15954 15955 4102
a 15955 15956 4102
a 15956 15957 4102
a 15957 15958 4102
a 15958 15959 4102
a 15959 15960 4102
a 15960 15961 4102
a 15961 15962 4102
a 15962 15963 4102
a 15963 15964 4102
a 15964 15965 4102
a 15965 15966 4102
a 15966 15967 4102
a 15967 15968 4102
a 15968 15969 4102
a 15969 15970 4102
a 15970 15971 4102
a 15971 15972 4102
a 15972 15973 4102
a 15973 15974 4102
a 15974 15975 4102
a 15975 15976 4102
a 15976 15977 4102
a 15977 15978 4102
a 15978 15979 4102
a 15979 15980 4102
a 15980 15981 4102
a 15981 15982 4102
a 15982 15983 4102
a 15983 15984 4102
a 15984 15985 4102
a 15985 15986 4102
a 15986 15987 4102
a 15987 15988 4102
a 15988 15989 4102
a 15989 15990 4102
a 15990 15991 4102
a 15991 15992 4102
a 15992 15993 4102
a 15993 15994 4102
a 15994 15995 4102
a 15995 15996 4102
a 15996 15997 4102
a 15997 15998 4102
a 15998 15999 4102
a 15999 16000 4102
a 16000 16001 4102
a 16001 16002 4102
a 16002 16003 4102
a 16003 16004 4102
a 16004 16005 4102
a 16005 16006 4102
a 16006 16007 4102
a 16007 16008 4102
a 16008 16009 4102
a 16009 16010 4102
a 16010 16011 4102
a 16011 16012 4102
a 16012 16013 4102
a 16013 16014 4102
a 16014 16015 4102
a 16015 16016 4102
a 16016 16017 4102
a 16017 16018 4102
a 16018 16019 4102
a 16019 16020 4102
a 16020 16021 4102
a 16021 16022 4102
a 16022 16023 4102
a 16023 16024 4102
a 16024 16025 4102
a 16025 16026 4102
a 16026 16027 4102
a 16027 16028 4102
a 16028 16029 4102
a 16029 16030 4102
a 16030 16031 4102
a 16031 16032 4102
a 16032 16033 4102
a 16033 16034 4102
a 16034 16035 4102
a 16035 16036 4102
a 16036 16037 4102
a 16037 16038 4102
a 16038 16039 4102
a 16039 16040 4102
a 16040 16041 4102
a 16041 16042 4102
a 16042 16043 4102
a 16043 16044 4102
a 16044 16045 4102
a 16045 16046 4102
a 16046 16047 4102
a 16047 16048 4102
a 16048 16049 4102
a 16049 16050 4102
a 16050 16051 4102
a 16051 16052 4102
a 16052 16053 4102
a 16053 16054 4102
a 16054 16055 4102
a 16055 16056 4102
a 16056 16057 4102
a 16057 16058 4102
a 16058 16059 4102
a 16059 16060 4102
a 16060 16061 4102
a 16061 16062 4102
a 16062 16063 4102
a 16063 16064 4102
a 16064 16065 4102
a 16065 16066 4102
a 16066 16067 4102
a 16067 16068 4102
a 16068 16069 4102
a 16069 16070 4102
a 16070 16071 4102
a 16071 16072 4102
a 16072 16073 4102
a 16073 16074 4102
a 16074 16075 4102
a 16075 16076 4102
a 16076 16077 4102
a 16077 16078 4102
a 16078 16079 4102
a 16079 16080 4102
a 16080 16081 4102
a 16081 16082 4102
a 16082 16083 4102
a 16083 16084 4102
a 16084 16085 4102
a 16085 16086 4102
a 16086 16087 4102
a 16087 16088 4102
a 16088 16089 4102
a 16089 16090 4102
a 16090 16091 4102
a 16091 16092 4102
a 16092 16093 4102
a 16093 16094 4102
a 16094 16095 4102
a 16095 16096 4102
a 16096 16097 4102
a 16097 16098 4102
a 16098 16099 4102
a 16099 16100 4102
a 16100 16101 4102
a 16101 16102 4102
a 16102 16103 4102
a 16103 16104 4102
a 16104 16105 4102
a 16105 16106 4102
a 16106 16107 4102
a 16107 16108 4102
a 16108 16109 4102
a 16109 16110 4102
a 16110 16111 4102
a 16111 16112 4102
a 16112 16113 4102
a 16113 16114 4102
a 16114 16115 4102
a 16115 16116 4102
a 16116 16117 4102
a 16117 16118 4102
a 16118 16119 4102
a 16119 16120 4102
a 16120 16121 4102
a 16121 16122 4102
a 16122 16123 4102
a 16123 16124 4102
a 16124 16125 4102
a 16125 16126 4102
a 16126 16127 4102
a 16127 16128 4102
a 16128 16129 4102
a 16129 16130 4102
a 16130 16131 4102
a 16131 16132 4102
a 16132 16133 4102
a 16133 16134 4102
a 16134 16135 4102
a 16135 16136 4102
a 16136 16137 4102
a 16137 16138 4102
a 16138 16139 4102
a 16139 16140 4102
a 16140 16141 4102
a 16141 16142 4102
a 16142 16143 4102
a 16143 16144 4102
a 16144 16145 4102
a 16145 16146 4102
a 16146 16147 4102
a 16147 16148 4102
a 16148 16149 4102
a 16149 16150 4102
a 16150 16151 4102
a 16151 16152 4102
a 16152 16153 4102
a 16153 16154 4102
a 16154 16155 4102
a 16155 16156 4102
a 16156 16157 4102
a 16157 16158 4102
a 16158 16159 4102
a 16159 16160 4102
a 16160 16161 4102
a 16161 16162 4102
a 16162 16163 4102
a 16163 16164 4102
a 16164 16165 4102
a 16165 16166 4102
a 16166 16167 4102
a 16167 16168 4102
a 16168 16169 4102
a 16169 16170 4102
a 16170 16171 4102
a 16171 16172 4102
a 16172 16173 4102
a 16173 16174 4102
a 16174 16175 4102
a 16175 16176 4102
a 16176 16177 4102
a 16177 16178 4102
a 16178 16179 4102
a 16179 16180 4102
a 16180 16181 4102
a 16181 16182 4102
a 16182 16183 4102
a 16183 16184 4102
a 16184 16185 4102
a 16185 16186 4102
a 16186 16187 4102
a 16187 16188 4102
a 16188 16189 4102
a 16189 16190 4102
a 16190 16191 4102
a 16191 16192 4102
a 16192 16193 4102
a 16193 16194 4102
a 16194 16195 4102
a 16195 16196 4102
a 16196 16197 4102
a 16197 16198 4102
a 16198 16199 4102
a 16199 16200 4102
a 16200 16201 4102
a 16201 16202 4102
a 16202 16203 4102
a 16203 16204 4102
a 16204 16205 4102
a 16205 16206 4102
a 16206 16207 4102
a 16207 16208 4102
a 16208 16209 4102
a 16209 16210 4102
a 16210 16211 4102
a 16211 16212 4102
a 16212 16213 4102
a 16213 16214 4102
a 16214 16215 4102
a 16215 16216 4102
a 16216 16217 4102
a 16217 16218 4102
a 16218 16219 4102
a 16219 16220 4102
a 16220 16221 4102
a 16221 16222 4102
a 16222 16223 4102
a 16223 16224 4102
a 16224 16225 4102
a 16225 16226 4102
a 16226 16227 4102
a 16227 16228 4102
a 16228 16229 4102
a 16229 16230 4102
a 16230 16231 4102
a 16231 16232 4102
a 16232 16233 4102
a 16233 16234 4102
a 16234 16235 4102
a 16235 16236 4102
a 16236 16237 4102
a 16237 16238 4102
a 16238 16239 4102
a 16239 16240 4102
a 16240 16241 4102
a 16241 16242 4102
a 16242 16243 4102
a 16243 16244 4102
a 16244 16245 4102
a 16245 16246 4102
a 16246 16247 4102
a 16247 16248 4102
a 16248 16249 4102
a 16249 16250 4102
a 16250 16251 4102
a 16251 16252 4102
a 16252 16253 4102
a 16253 16254 4102
a 16254 16255 4102
a 16255 16256 4102
a 16256 16257 4102
a 16257 16258 4102
a 16258 16259 4102
a 16259 16260 4102
a 16260 16261 4102
a 16261 16262 4102
a 16262 16263 4102
a 16263 16264 4102
a 16264 16265 4102
a 16265 16266 4102
a 16266 16267 4102
a 16267 16268 4102
a 16268 16269 4102
a 16269 16270 4102
a 16270 16271 4102
a 16271 16272 4102
a 16272 16273 4102
a 16273 16274 4102
a 16274 16275 4102
a 16275 16276 4102
a 16276 16277 4102
a 16277 16278 4102
a 16278 16279 4102
a 16279 16280 4102
a 16280 16281 4102
a 16281 16282 4102
a 16282 16283 4102
a 16283 16284 4102
a 16284 16285 4102
a 16285 16286 4102
a 16286 16287 4102
a 16287 16288 4102
a 16288 16289 4102
a 16289 16290 4102
a 16290 16291 4102
a 16291 16292 4102
a 16292 16293 4102
a 16293 16294 4102
a 16294 16295 4102
a 16295 16296 4102
a 16296 16297 4102
a 16297 16298 4102
a 16298 16299 4102
a 16299 16300 4102
a 16300 16301 4102
a 16301 16302 4102
a 16302 16303 4102
a 16303 16304 4102
a 16304 16305 4102
a 16305 16306 4102
a 16306 16307 4102
a 16307 16308 4102
a 16308 16309 4102
a 16309 16310 4102
a 16310 16311 4102
a 16311 16312 4102
a 16312 16313 4102
a 16313 16314 4102
a 16314 16315 4102
a 16315 16316 4102
a 16316 16317 4102
a 16317 16318 4102
a 16318 16319 4102
a 16319 16320 4102
a 16320 16321 4102
a 16321 16322 4102
a 16322 16323 4102
a 16323 16324 4102
a 16324 16325 4102
a 16325 16326 4102
a 16326 16327 4102
a 16327 16328 4102
a 16328 16329 4102
a 16329 16330 4102
a 16330 16331 4102
a 16331 16332 4102
a 16332 16333 4102
a 16333 16334 4102
a 16334 16335 4102
a 16335 16336 4102
a 16336 16337 4102
a 16337 16338 4102
a 16338 16339 4102
a 16339 16340 4102
a 16340 16341 4102
a 16341 16342 4102
a 16342 16343 4102
a 16343 16344 4102
a 16344 16345 4102
a 16345 16346 4102
a 16346 16347 4102
a 16347 16348 4102
a 16348 16349 4102
a 16349 16350 4102
a 16350 16351 4102
a 16351 16352 4102
a 16352 16353 4102
a 16353 16354 4102
a 16354 16355 4102
a 16355 16356 4102
a 16356 16357 4102
a 16357 16358 4102
a 16358 16359 4102
a 16359 16360 4102
a 16360 16361 4102
a 16361 16362 4102
a 16362 16363 4102
a 16363 16364 4102
a 16364 16365 4102
a 16365 16366 4102
a 16366 16367 4102
a 16367 16368 4102
a 16368 16369 4102
a 16369 16370 4102
a 16370 16371 4102
a 16371 16372 4102
a 16372 16373 4102
a 16373 16374 4102
a 16374 16375 4102
a 16375 16376 4102
a 16376 16377 4102
a 16377 16378 4102
a 16378 16379 4102
a 16379 16380 4102
a 16380 16381 4102
a 16381 16382 4102
a 16382 16383 4102
a 16383 16384 4102
a 16384 16385 4102
a 16385 16386 4102
a 16386 16387 4102
a 16387 16388 4102
a 16388 16389 4102
a 16389 16390 4102
a 16390 16391 4102
a 16391 16392 4102
a 16392 16393 4102
a 16393 16394 4102
a 16394 16395 4102
a 16395 16396 4102
a 16396 16397 4102
a 16397 16398 4102
a 16398 16399 4102
a 16399 16400 4102
a 16400 16401 4102
a 16401 16402 4102
a 16402 16403 4102
a 16403 16404 4102
a 16404 16405 4102
a 16405 16406 4102
a 16406 16407 4102
a 16407 16408 4102
a 16408 16409 4102
a 16409 16410 4102
a 16410 16411 4102
a 16411 16412 4102
a 16412 16413 4102
a 16413 16414 4102
a 8209 16414 1
a 8210 16413 1
a 8211 16412 1
a 8212 16411 1
a 8213 16410 1
a 8214 16409 1
a 8215 16408 1
a 8216 16407 1
a 8217 16406 1
a 8218 16405 1
a 8219 16404 1
a 8220 16403 1
a 8221 16402 1
a 8222 16401 1
a 8223 16400 1
a 8224 16399 1
a 8225 16398 1
a 8226 16397 1
a 8227 16396 1
a 8228 16395 1
a 8229 16394 1
a 8230 16393 1
a 8231 16392 1
a 8232 16391 1
a 8233 16390 1
a 8234 16389 1
a 8235 16388 1
a 8236 16387 1
a 8237 16386 1
a 8238 16385 1
a 8239 16384 1
a 8240 16383 1
a 8241 16382 1
a 8242 16381 1
a 8243 16380 1
a 8244 16379 1
a 8245 16378 1
a 8246 16377 1
a 8247 16376 1
a 8248 16375 1
a 8249 16374 1
a 8250 16373 1
a 8251 16372 1
a 8252 16371 1
a 8253 16370 1
a 8254 16369 1
a 8255 16368 1
a 8256 16367 1
a 8257 16366 1
a 8258 16365 1
a 8259 16364 1
a 8260 16363 1
a 8261 16362 1
a 8262 16361 1
a 8263 16360 1
a 8264 16359 1
a 8265 16358 1
a 8266 16357 1
a 8267 16356 1
a 8268 16355 1
a 8269 16354 1
a 8270 16353 1
a 8271 16352 1
a 8272 16351 1
a 8273 16350 1
a 8274 16349 1
a 8275 16348 1
a 8276 16347 1
a 8277 16346 1
a 8278 16345 1
a 8279 16344 1
a 8280 16343 1
a 8281 16342 1
a 8282 16341 1
a 8283 16340 1
a 8284 16339 1
a 8285 16338 1
a 8286 16337 1
a 8287 16336 1
a 8288 16335 1
a 8289 16334 1
a 8290 16333 1
a 8291 16332 1
a 8292 16331 1
a 8293 16330 1
a 8294 16329 1
a 8295 16328 1
a 8296 16327 1
a 8297 16326 1
a 8298 16325 1
a 8299 16324 1
a 8300 16323 1
a 8301 16322 1
a 8302 16321 1
a 8303 16320 1
a 8304 16319 1
a 8305 16318 1
a 8306 16317 1
a 8307 16316 1
a 8308 16315 1
a 8309 16314 1
a 8310 16313 1
a 8311 16312 1
a 8312 16311 1
a 8313 16310 1
a 8314 16309 1
a 8315 16308 1
a 8316 16307 1
a 8317 16306 1
a 8318 16305 1
a 8319 16304 1
a 8320 16303 1
a 8321 16302 1
a 8322 16301 1
a 8323 16300 1
a 8324 16299 1
a 8325 16298 1
a 8326 16297 1
a 8327 16296 1
a 8328 16295 1
a 8329 16294 1
a 8330 16293 1
a 8331 16292 1
a 8332 16291 1
a 8333 16290 1
a 8334 16289 1
a 8335 16288 1
a 8336 16287 1
a 8337 16286 1
a 8338 16285 1
a 8339 16284 1
a 8340 16283 1
a 8341 16282 1
a 8342 16281 1
a 8343 16280 1
a 8344 16279 1
a 8345 16278 1
a 8346 16277 1
a 8347 16276 1
a 8348 16275 1
a 8349 16274 1
a 8350 16273 1
a 8351 16272 1
a 8352 16271 1
a 8353 16270 1
a 8354 16269 1
a 8355 16268 1
a 8356 16267 1
a 8357 16266 1
a 8358 16265 1
a 8359 16264 1
a 8360 16263 1
a 8361 16262 1
a 8362 16261 1
a 8363 16260 1
a 8364 16259 1
a 8365 16258 1
a 8366 16257 1
a 8367 16256 1
a 8368 16255 1
a 8369 16254 1
a 8370 16253 1
a 8371 16252 1
a 8372 16251 1
a 8373 16250 1
a 8374 16249 1
a 8375 16248 1
a 8376 16247 1
a 8377 16246 1
a 8378 16245 1
a 8379 16244 1
a 8380 16243 1
a 8381 16242 1
a 8382 16241 1
a 8383 16240 1
a 8384 16239 1
a 8385 16238 1
a 8386 16237 1
a 8387 16236 1
a 8388 16235 1
a 8389 16234 1
a 8390 16233 1
a 8391 16232 1
a 8392 16231 1
a 8393 16230 1
a 8394 16229 1
a 8395 16228 1
a 8396 16227 1
a 8397 16226 1
a 8398 16225 1
a 8399 16224 1
a 8400 16223 1
a 8401 16222 1
a 8402 16221 1
a 8403 16220 1
a 8404 16219 1
a 8405 16218 1
a 8406 16217 1
a 8407 16216 1
a 8408 16215 1
a 8409 16214 1
a 8410 16213 1
a 8411 16212 1
a 8412 16211 1
a 8413 16210 1
a 8414 16209 1
a 8415 16208 1
a 8416 16207 1
a 8417 16206 1
a 8418 16205 1
a 8419 16204 1
a 8420 16203 1
a 8421 16202 1
a 8422 16201 1
a 8423 16200 1
a 8424 16199 1
a 8425 16198 1
a 8426 16197 1
a 8427 16196 1
a 8428 16195 1
a 8429 16194 1
a 8430 16193 1
a 8431 16192 1
a 8432 16191 1
a 8433 16190 1
a 8434 16189 1
a 8435 16188 1
a 8436 16187 1
a 8437 16186 1
a 8438 16185 1
a 8439 16184 1
a 8440 16183 1
a 8441 16182 1
a 8442 16181 1
a 8443 16180 1
a 8444 16179 1
a 8445 16178 1
a 8446 16177 1
a 8447 16176 1
a 8448 16175 1
a 8449 16174 1
a 8450 16173 1
a 8451 16172 1
a 8452 16171 1
a 8453 16170 1
a 8454 16169 1
a 8455 16168 1
a 8456 16167 1
a 8457 16166 1
a 8458 16165 1
a 8459 16164 1
a 8460 16163 1
a 8461 16162 1
a 8462 16161 1
a 8463 16160 1
a 8464 16159 1
a 8465 16158 1
a 8466 16157 1
a 8467 16156 1
a 8468 16155 1
a 8469 16154 1
a 8470 16153 1
a 8471 16152 1
a 8472 16151 1
a 8473 16150 1
a 8474 16149 1
a 8475 16148 1
a 8476 16147 1
a 8477 16146 1
a 8478 16145 1
a 8479 16144 1
a 8480 16143 1
a 8481 16142 1
a 8482 16141 1
a 8483 16140 1
a 8484 16139 1
a 8485 16138 1
a 8486 16137 1
a 8487 16136 1
a 8488 16135 1
a 8489 16134 1
a 8490 16133 1
a 8491 16132 1
a 8492 16131 1
a 8493 16130 1
a 8494 16129 1
a 8495 16128 1
a 8496 16127 1
a 8497 16126 1
a 8498 16125 1
a 8499 16124 1
a 8500 16123 1
a 8501 16122 1
a 8502 16121 1
a 8503 16120 1
a 8504 16119 1
a 8505 16118 1
a 8506 16117 1
a 8507 16116 1
a 8508 16115 1
a 8509 16114 1
a 8510 16113 1
a 8511 16112 1
a 8512 16111 1
a 8513 16110 1
a 8514 16109 1
a 8515 16108 1
a 8516 16107 1
a 8517 16106 1
a 8518 16105 1
a 8519 16104 1
a 8520 16103 1
a 8521 16102 1
a 8522 16101 1
a 8523 16100 1
a 8524 16099 1
a 8525 16098 1
a 8526 16097 1
a 8527 16096 1
a 8528 16095 1
a 8529 16094 1
a 8530 16093 1
a 8531 16092 1
a 8532 16091 1
a 8533 16090 1
a 8534 16089 1
a 8535 16088 1
a 8536 16087 1
a 8537 16086 1
a 8538 16085 1
a 8539 16084 1
a 8540 16083 1
a 8541 16082 1
a 8542 16081 1
a 8543 16080 1
a 8544 16079 1
a 8545 16078 1
a 8546 16077 1
a 8547 16076 1
a 8548 16075 1
a 8549 16074 1
a 8550 16073 1
a 8551 16072 1
a 8552 16071 1
a 8553 16070 1
a 8554 16069 1
a 8555 16068 1
a 8556 16067 1
a 8557 16066 1
a 8558 16065 1
a 8559 16064 1
a 8560 16063 1
a 8561 16062 1
a 8562 16061 1
a 8563 16060 1
a 8564 16059 1
a 8565 16058 1
a 8566 16057 1
a 8567 16056 1
a 8568 16055 1
a 8569 16054 1
a 8570 16053 1
a 8571 16052 1
a 8572 16051 1
a 8573 16050 1
a 8574 16049 1
a 8575 16048 1
a 8576 16047 1
a 8577 16046 1
a 8578 16045 1
a 8579 16044 1
a 8580 16043 1
a 8581 16042 1
a 8582 16041 1
a 8583 16040 1
a 8584 16039 1
a 8585 16038 1
a 8586 16037 1
a 8587 16036 1
a 8588 16035 1
a 8589 16034 1
a 8590 16033 1
a 8591 16032 1
a 8592 16031 1
a 8593 16030 1
a 8594 16029 1
a 8595 16028 1
a 8596 16027 1
a 8597 16026 1
a 8598 16025 1
a 8599 16024 1
a 8600 16023 1
a 8601 16022 1
a 8602 16021 1
a 8603 16020 1
a 8604 16019 1
a 8605 16018 1
a 8606 16017 1
a 8607 16016 1
a 8608 16015 1
a 8609 16014 1
a 8610 16013 1
a 8611 16012 1
a 8612 16011 1
a 8613 16010 1
a 8614 16009 1
a 8615 16008 1
a 8616 16007 1
a 8617 16006 1
a 8618 16005 1
a 8619 16004 1
a 8620 16003 1
a 8621 16002 1
a 8622 16001 1
a 8623 16000 1
a 8624 15999 1
a 8625 15998 1
a 8626 15997 1
a 8627 15996 1
a 8628 15995 1
a 8629 15994 1
a 8630 15993 1
a 8631 15992 1
a 8632 15991 1
a 8633 15990 1
a 8634 15989 1
a 8635 15988 1
a 8636 15987 1
a 8637 15986 1
a 8638 15985 1
a 8639 15984 1
a 8640 15983 1
a 8641 15982 1
a 8642 15981 1
a 8643 15980 1
a 8644 15979 1
a 8645 15978 1
a 8646 15977 1
a 8647 15976 1
a 8648 15975 1
a 8649 15974 1
a 8650 15973 1
a 8651 15972 1
a 8652 15971 1
a 8653 15970 1
a 8654 15969 1
a 8655 15968 1
a 8656 15967 1
a 8657 15966 1
a 8658 15965 1
a 8659 15964 1
a 8660 15963 1
a 8661 15962 1
a 8662 15961 1
a 8663 15960 1
a 8664 15959 1
a 8665 15958 1
a 8666 15957 1
a 8667 15956 1
a 8668 15955 1
a 8669 15954 1
a 8670 15953 1
a 8671 15952 1
a 8672 15951 1
a 8673 15950 1
a 8674 15949 1
a 8675 15948 1
a 8676 15947 1
a 8677 15946 1
a 8678 15945 1
a 8679 15944 1
a 8680 15943 1
a 8681 15942 1
a 8682 15941 1
a 8683 15940 1
a 8684 15939 1
a 8685 15938 1
a 8686 15937 1
a 8687 15936 1
a 8688 15935 1
a 8689 15934 1
a 8690 15933 1
a 8691 15932 1
a 8692 15931 1
a 8693 15930 1
a 8694 15929 1
a 8695 15928 1
a 8696 15927 1
a 8697 15926 1
a 8698 15925 1
a 8699 15924 1
a 8700 15923 1
a 8701 15922 1
a 8702 15921 1
a 8703 15920 1
a 8704 15919 1
a 8705 15918 1
a 8706 15917 1
a 8707 15916 1
a 8708 15915 1
a 8709 15914 1
a 8710 15913 1
a 8711 15912 1
a 8712 15911 1
a 8713 15910 1
a 8714 15909 1
a 8715 15908 1
a 8716 15907 1
a 8717 15906 1
a 8718 15905 1
a 8719 15904 1
a 8720 15903 1
a 8721 15902 1
a 8722 15901 1
a 8723 15900 1
a 8724 15899 1
a 8725 15898 1
a 8726 15897 1
a 8727 15896 1
a 8728 15895 1
a 8729 15894 1
a 8730 15893 1
a 8731 15892 1
a 8732 15891 1
a 8733 15890 1
a 8734 15889 1
a 8735 15888 1
a 8736 15887 1
a 8737 15886 1
a 8738 15885 1
a 8739 15884 1
a 8740 15883 1
a 8741 15882 1
a 8742 15881 1
a 8743 15880 1
a 8744 15879 1
a 8745 15878 1
a 8746 15877 1
a 8747 15876 1
a 8748 15875 1
a 8749 15874 1
a 8750 15873 1
a 8751 15872 1
a 8752 15871 1
a 8753 15870 1
a 8754 15869 1
a 8755 15868 1
a 8756 15867 1
a 8757 15866 1
a 8758 15865 1
a 8759 15864 1
a 8760 15863 1
a 8761 15862 1
a 8762 15861 1
a 8763 15860 1
a 8764 15859 1
a 8765 15858 1
a 8766 15857 1
a 8767 15856 1
a 8768 15855 1
a 8769 15854 1
a 8770 15853 1
a 8771 15852 1
a 8772 15851 1
a 8773 15850 1
a 8774 15849 1
a 8775 15848 1
a 8776 15847 1
a 8777 15846 1
a 8778 15845 1
a 8779 15844 1
a 8780 15843 1
a 8781 15842 1
a 8782 15841 1
a 8783 15840 1
a 8784 15839 1
a 8785 15838 1
a 8786 15837 1
a 8787 15836 1
a 8788 15835 1
a 8789 15834 1
a 8790 15833 1
a 8791 15832 1
a 8792 15831 1
a 8793 15830 1
a 8794 15829 1
a 8795 15828 1
a 8796 15827 1
a 8797 15826 1
a 8798 15825 1
a 8799 15824 1
a 8800 15823 1
a 8801 15822 1
a 8802 15821 1
a 8803 15820 1
a 8804 15819 1
a 8805 15818 1
a 8806 15817 1
a 8807 15816 1
a 8808 15815 1
a 8809 15814 1
a 8810 15813 1
a 8811 15812 1
a 8812 15811 1
a 8813 15810 1
a 8814 15809 1
a 8815 15808 1
a 8816 15807 1
a 8817 15806 1
a 8818 15805 1
a 8819 15804 1
a 8820 15803 1
a 8821 15802 1
a 8822 15801 1
a 8823 15800 1
a 8824 15799 1
a 8825 15798 1
a 8826 15797 1
a 8827 15796 1
a 8828 15795 1
a 8829 15794 1
a 8830 15793 1
a 8831 15792 1
a 8832 15791 1
a 8833 15790 1
a 8834 15789 1
a 8835 15788 1
a 8836 15787 1
a 8837 15786 1
a 8838 15785 1
a 8839 15784 1
a 8840 15783 1
a 8841 15782 1
a 8842 15781 1
a 8843 15780 1
a 8844 15779 1
a 8845 15778 1
a 8846 15777 1
a 8847 15776 1
a 8848 15775 1
a 8849 15774 1
a 8850 15773 1
a 8851 15772 1
a 8852 15771 1
a 8853 15770 1
a 8854 15769 1
a 8855 15768 1
a 8856 15767 1
a 8857 15766 1
a 8858 15765 1
a 8859 15764 1
a 8860 15763 1
a 8861 15762 1
a 8862 15761 1
a 8863 15760 1
a 8864 15759 1
a 8865 15758 1
a 8866 15757 1
a 8867 15756 1
a 8868 15755 1
a 8869 15754 1
a 8870 15753 1
a 8871 15752 1
a 8872 15751 1
a 8873 15750 1
a 8874 15749 1
a 8875 15748 1
a 8876 15747 1
a 8877 15746 1
a 8878 15745 1
a 8879 15744 1
a 8880 15743 1
a 8881 15742 1
a 8882 15741 1
a 8883 15740 1
a 8884 15739 1
a 8885 15738 1
a 8886 15737 1
a 8887 15736 1
a 8888 15735 1
a 8889 15734 1
a 8890 15733 1
a 8891 15732 1
a 8892 15731 1
a 8893 15730 1
a 8894 15729 1
a 8895 15728 1
a 8896 15727 1
a 8897 15726 1
a 8898 15725 1
a 8899 15724 1
a 8900 15723 1
a 8901 15722 1
a 8902 15721 1
a 8903 15720 1
a 8904 15719 1
a 8905 15718 1
a 8906 15717 1
a 8907 15716 1
a 8908 15715 1
a 8909 15714 1
a 8910 15713 1
a 8911 15712 1
a 8912 15711 1
a 8913 15710 1
a 8914 15709 1
a 8915 15708 1
a 8916 15707 1
a 8917 15706 1
a 8918 15705 1
a 8919 15704 1
a 8920 15703 1
a 8921 15702 1
a 8922 15701 1
a 8923 15700 1
a 8924 15699 1
a 8925 15698 1
a 8926 15697 1
a 8927 15696 1
a 8928 15695 1
a 8929 15694 1
a 8930 15693 1
a 8931 15692 1
a 8932 15691 1
a 8933 15690 1
a 8934 15689 1
a 8935 15688 1
a 8936 15687 1
a 8937 15686 1
a 8938 15685 1
a 8939 15684 1
a 8940 15683 1
a 8941 15682 1
a 8942 15681 1
a 8943 15680 1
a 8944 15679 1
a 8945 15678 1
a 8946 15677 1
a 8947 15676 1
a 8948 15675 1
a 8949 15674 1
a 8950 15673 1
a 8951 15672 1
a 8952 15671 1
a 8953 15670 1
a 8954 15669 1
a 8955 15668 1
a 8956 15667 1
a 8957 15666 1
a 8958 15665 1
a 8959 15664 1
a 8960 15663 1
a 8961 15662 1
a 8962 15661 1
a 8963 15660 1
a 8964 15659 1
a 8965 15658 1
a 8966 15657 1
a 8967 15656 1
a 8968 15655 1
a 8969 15654 1
a 8970 15653 1
a 8971 15652 1
a 8972 15651 1
a 8973 15650 1
a 8974 15649 1
a 8975 15648 1
a 8976 15647 1
a 8977 15646 1
a 8978 15645 1
a 8979 15644 1
a 8980 15643 1
a 8981 15642 1
a 8982 15641 1
a 8983 15640 1
a 8984 15639 1
a 8985 15638 1
a 8986 15637 1
a 8987 15636 1
a 8988 15635 1
a 8989 15634 1
a 8990 15633 1
a 8991 15632 1
a 8992 15631 1
a 8993 15630 1
a 8994 15629 1
a 8995 15628 1
a 8996 15627 1
a 8997 15626 1
a 8998 15625 1
a 8999 15624 1
a 9000 15623 1
a 9001 15622 1
a 9002 15621 1
a 9003 15620 1
a 9004 15619 1
a 9005 15618 1
a 9006 15617 1
a 9007 15616 1
a 9008 15615 1
a 9009 15614 1
a 9010 15613 1
a 9011 15612 1
a 9012 15611 1
a 9013 15610 1
a 9014 15609 1
a 9015 15608 1
a 9016 15607 1
a 9017 15606 1
a 9018 15605 1
a 9019 15604 1
a 9020 15603 1
a 9021 15602 1
a 9022 15601 1
a 9023 15600 1
a 9024 15599 1
a 9025 15598 1
a 9026 15597 1
a 9027 15596 1
a 9028 15595 1
a 9029 15594 1
a 9030 15593 1
a 9031 15592 1
a 9032 15591 1
a 9033 15590 1
a 9034 15589 1
a 9035 15588 1
a 9036 15587 1
a 9037 15586 1
a 9038 15585 1
a 9039 15584 1
a 9040 15583 1
a 9041 15582 1
a 9042 15581 1
a 9043 15580 1
a 9044 15579 1
a 9045 15578 1
a 9046 15577 1
a 9047 15576 1
a 9048 15575 1
a 9049 15574 1
a 9050 15573 1
a 9051 15572 1
a 9052 15571 1
a 9053 15570 1
a 9054 15569 1
a 9055 15568 1
a 9056 15567 1
a 9057 15566 1
a 9058 15565 1
a 9059 15564 1
a 9060 15563 1
a 9061 15562 1
a 9062 15561 1
a 9063 15560 1
a 9064 15559 1
a 9065 15558 1
a 9066 15557 1
a 9067 15556 1
a 9068 15555 1
a 9069 15554 1
a 9070 15553 1
a 9071 15552 1
a 9072 15551 1
a 9073 15550 1
a 9074 15549 1
a 9075 15548 1
a 9076 15547 1
a 9077 15546 1
a 9078 15545 1
a 9079 15544 1
a 9080 15543 1
a 9081 15542 1
a 9082 15541 1
a 9083 15540 1
a 9084 15539 1
a 9085 15538 1
a 9086 15537 1
a 9087 15536 1
a 9088 15535 1
a 9089 15534 1
a 9090 15533 1
a 9091 15532 1
a 9092 15531 1
a 9093 15530 1
a 9094 15529 1
a 9095 15528 1
a 9096 15527 1
a 9097 15526 1
a 9098 15525 1
a 9099 15524 1
a 9100 15523 1
a 9101 15522 1
a 9102 15521 1
a 9103 15520 1
a 9104 15519 1
a 9105 15518 1
a 9106 15517 1
a 9107 15516 1
a 9108 15515 1
a 9109 15514 1
a 9110 15513 1
a 9111 15512 1
a 9112 15511 1
a 9113 15510 1
a 9114 15509 1
a 9115 15508 1
a 9116 15507 1
a 9117 15506 1
a 9118 15505 1
a 9119 15504 1
a 9120 15503 1
a 9121 15502 1
a 9122 15501 1
a 9123 15500 1
a 9124 15499 1
a 9125 15498 1
a 9126 15497 1
a 9127 15496 1
a 9128 15495 1
a 9129 15494 1
a 9130 15493 1
a 9131 15492 1
a 9132 15491 1
a 9133 15490 1
a 9134 15489 1
a 9135 15488 1
a 9136 15487 1
a 9137 15486 1
a 9138 15485 1
a 9139 15484 1
a 9140 15483 1
a 9141 15482 1
a 9142 15481 1
a 9143 15480 1
a 9144 15479 1
a 9145 15478 1
a 9146 15477 1
a 9147 15476 1
a 9148 15475 1
a 9149 15474 1
a 9150 15473 1
a 9151 15472 1
a 9152 15471 1
a 9153 15470 1
a 9154 15469 1
a 9155 15468 1
a 9156 15467 1
a 9157 15466 1
a 9158 15465 1
a 9159 15464 1
a 9160 15463 1
a 9161 15462 1
a 9162 15461 1
a 9163 15460 1
a 9164 15459 1
a 9165 15458 1
a 9166 15457 1
a 9167 15456 1
a 9168 15455 1
a 9169 15454 1
a 9170 15453 1
a 9171 15452 1
a 9172 15451 1
a 9173 15450 1
a 9174 15449 1
a 9175 15448 1
a 9176 15447 1
a 9177 15446 1
a 9178 15445 1
a 9179 15444 1
a 9180 15443 1
a 9181 15442 1
a 9182 15441 1
a 9183 15440 1
a 9184 15439 1
a 9185 15438 1
a 9186 15437 1
a 9187 15436 1
a 9188 15435 1
a 9189 15434 1
a 9190 15433 1
a 9191 15432 1
a 9192 15431 1
a 9193 15430 1
a 9194 15429 1
a 9195 15428 1
a 9196 15427 1
a 9197 15426 1
a 9198 15425 1
a 9199 15424 1
a 9200 15423 1
a 9201 15422 1
a 9202 15421 1
a 9203 15420 1
a 9204 15419 1
a 9205 15418 1
a 9206 15417 1
a 9207 15416 1
a 9208 15415 1
a 9209 15414 1
a 9210 15413 1
a 9211 15412 1
a 9212 15411 1
a 9213 15410 1
a 9214 15409 1
a 9215 15408 1
a 9216 15407 1
a 9217 15406 1
a 9218 15405 1
a 9219 15404 1
a 9220 15403 1
a 9221 15402 1
a 9222 15401 1
a 9223 15400 1
a 9224 15399 1
a 9225 15398 1
a 9226 15397 1
a 9227 15396 1
a 9228 15395 1
a 9229 15394 1
a 9230 15393 1
a 9231 15392 1
a 9232 15391 1
a 9233 15390 1
a 9234 15389 1
a 9235 15388 1
a 9236 15387 1
a 9237 15386 1
a 9238 15385 1
a 9239 15384 1
a 9240 15383 1
a 9241 15382 1
a 9242 15381 1
a 9243 15380 1
a 9244 15379 1
a 9245 15378 1
a 9246 15377 1
a 9247 15376 1
a 9248 15375 1
a 9249 15374 1
a 9250 15373 1
a 9251 15372 1
a 9252 15371 1
a 9253 15370 1
a 9254 15369 1
a 9255 15368 1
a 9256 15367 1
a 9257 15366 1
a 9258 15365 1
a 9259 15364 1
a 9260 15363 1
a 9261 15362 1
a 9262 15361 1
a 9263 15360 1
a 9264 15359 1
a 9265 15358 1
a 9266 15357 1
a 9267 15356 1
a 9268 15355 1
a 9269 15354 1
a 9270 15353 1
a 9271 15352 1
a 9272 15351 1
a 9273 15350 1
a 9274 15349 1
a 9275 15348 1
a 9276 15347 1
a 9277 15346 1
a 9278 15345 1
a 9279 15344 1
a 9280 15343 1
a 9281 15342 1
a 9282 15341 1
a 9283 15340 1
a 9284 15339 1
a 9285 15338 1
a 9286 15337 1
a 9287 15336 1
a 9288 15335 1
a 9289 15334 1
a 9290 15333 1
a 9291 15332 1
a 9292 15331 1
a 9293 15330 1
a 9294 15329 1
a 9295 15328 1
a 9296 15327 1
a 9297 15326 1
a 9298 15325 1
a 9299 15324 1
a 9300 15323 1
a 9301 15322 1
a 9302 15321 1
a 9303 15320 1
a 9304 15319 1
a 9305 15318 1
a 9306 15317 1
a 9307 15316 1
a 9308 15315 1
a 9309 15314 1
a 9310 15313 1
a 9311 15312 1
a 9312 15311 1
a 9313 15310 1
a 9314 15309 1
a 9315 15308 1
a 9316 15307 1
a 9317 15306 1
a 9318 15305 1
a 9319 15304 1
a 9320 15303 1
a 9321 15302 1
a 9322 15301 1
a 9323 15300 1
a 9324 15299 1
a 9325 15298 1
a 9326 15297 1
a 9327 15296 1
a 9328 15295 1
a 9329 15294 1
a 9330 15293 1
a 9331 15292 1
a 9332 15291 1
a 9333 15290 1
a 9334 15289 1
a 9335 15288 1
a 9336 15287 1
a 9337 15286 1
a 9338 15285 1
a 9339 15284 1
a 9340 15283 1
a 9341 15282 1
a 9342 15281 1
a 9343 15280 1
a 9344 15279 1
a 9345 15278 1
a 9346 15277 1
a 9347 15276 1
a 9348 15275 1
a 9349 15274 1
a 9350 15273 1
a 9351 15272 1
a 9352 15271 1
a 9353 15270 1
a 9354 15269 1
a 9355 15268 1
a 9356 15267 1
a 9357 15266 1
a 9358 15265 1
a 9359 15264 1
a 9360 15263 1
a 9361 15262 1
a 9362 15261 1
a 9363 15260 1
a 9364 15259 1
a 9365 15258 1
a 9366 15257 1
a 9367 15256 1
a 9368 15255 1
a 9369 15254 1
a 9370 15253 1
a 9371 15252 1
a 9372 15251 1
a 9373 15250 1
a 9374 15249 1
a 9375 15248 1
a 9376 15247 1
a 9377 15246 1
a 9378 15245 1
a 9379 15244 1
a 9380 15243 1
a 9381 15242 1
a 9382 15241 1
a 9383 15240 1
a 9384 15239 1
a 9385 15238 1
a 9386 15237 1
a 9387 15236 1
a 9388 15235 1
a 9389 15234 1
a 9390 15233 1
a 9391 15232 1
a 9392 15231 1
a 9393 15230 1
a 9394 15229 1
a 9395 15228 1
a 9396 15227 1
a 9397 15226 1
a 9398 15225 1
a 9399 15224 1
a 9400 15223 1
a 9401 15222 1
a 9402 15221 1
a 9403 15220 1
a 9404 15219 1
a 9405 15218 1
a 9406 15217 1
a 9407 15216 1
a 9408 15215 1
a 9409 15214 1
a 9410 15213 1
a 9411 15212 1
a 9412 15211 1
a 9413 15210 1
a 9414 15209 1
a 9415 15208 1
a 9416 15207 1
a 9417 15206 1
a 9418 15205 1
a 9419 15204 1
a 9420 15203 1
a 9421 15202 1
a 9422 15201 1
a 9423 15200 1
a 9424 15199 1
a 9425 15198 1
a 9426 15197 1
a 9427 15196 1
a 9428 15195 1
a 9429 15194 1
a 9430 15193 1
a 9431 15192 1
a 9432 15191 1
a 9433 15190 1
a 9434 15189 1
a 9435 15188 1
a 9436 15187 1
a 9437 15186 1
a 9438 15185 1
a 9439 15184 1
a 9440 15183 1
a 9441 15182 1
a 9442 15181 1
a 9443 15180 1
a 9444 15179 1
a 9445 15178 1
a 9446 15177 1
a 9447 15176 1
a 9448 15175 1
a 9449 15174 1
a 9450 15173 1
a 9451 15172 1
a 9452 15171 1
a 9453 15170 1
a 9454 15169 1
a 9455 15168 1
a 9456 15167 1
a 9457 15166 1
a 9458 15165 1
a 9459 15164 1
a 9460 15163 1
a 9461 15162 1
a 9462 15161 1
a 9463 15160 1
a 9464 15159 1
a 9465 15158 1
a 9466 15157 1
a 9467 15156 1
a 9468 15155 1
a 9469 15154 1
a 9470 15153 1
a 9471 15152 1
a 9472 15151 1
a 9473 15150 1
a 9474 15149 1
a 9475 15148 1
a 9476 15147 1
a 9477 15146 1
a 9478 15145 1
a 9479 15144 1
a 9480 15143 1
a 9481 15142 1
a 9482 15141 1
a 9483 15140 1
a 9484 15139 1
a 9485 15138 1
a 9486 15137 1
a 9487 15136 1
a 9488 15135 1
a 9489 15134 1
a 9490 15133 1
a 9491 15132 1
a 9492 15131 1
a 9493 15130 1
a 9494 15129 1
a 9495 15128 1
a 9496 15127 1
a 9497 15126 1
a 9498 15125 1
a 9499 15124 1
a 9500 15123 1
a 9501 15122 1
a 9502 15121 1
a 9503 15120 1
a 9504 15119 1
a 9505 15118 1
a 9506 15117 1
a 9507 15116 1
a 9508 15115 1
a 9509 15114 1
a 9510 15113 1
a 9511 15112 1
a 9512 15111 1
a 9513 15110 1
a 9514 15109 1
a 9515 15108 1
a 9516 15107 1
a 9517 15106 1
a 9518 15105 1
a 9519 15104 1
a 9520 15103 1
a 9521 15102 1
a 9522 15101 1
a 9523 15100 1
a 9524 15099 1
a 9525 15098 1
a 9526 15097 1
a 9527 15096 1
a 9528 15095 1
a 9529 15094 1
a 9530 15093 1
a 9531 15092 1
a 9532 15091 1
a 9533 15090 1
a 9534 15089 1
a 9535 15088 1
a 9536 15087 1
a 9537 15086 1
a 9538 15085 1
a 9539 15084 1
a 9540 15083 1
a 9541 15082 1
a 9542 15081 1
a 9543 15080 1
a 9544 15079 1
a 9545 15078 1
a 9546 15077 1
a 9547 15076 1
a 9548 15075 1
a 9549 15074 1
a 9550 15073 1
a 9551 15072 1
a 9552 15071 1
a 9553 15070 1
a 9554 15069 1
a 9555 15068 1
a 9556 15067 1
a 9557 15066 1
a 9558 15065 1
a 9559 15064 1
a 9560 15063 1
a 9561 15062 1
a 9562 15061 1
a 9563 15060 1
a 9564 15059 1
a 9565 15058 1
a 9566 15057 1
a 9567 15056 1
a 9568 15055 1
a 9569 15054 1
a 9570 15053 1
a 9571 15052 1
a 9572 15051 1
a 9573 15050 1
a 9574 15049 1
a 9575 15048 1
a 9576 15047 1
a 9577 15046 1
a 9578 15045 1
a 9579 15044 1
a 9580 15043 1
a 9581 15042 1
a 9582 15041 1
a 9583 15040 1
a 9584 15039 1
a 9585 15038 1
a 9586 15037 1
a 9587 15036 1
a 9588 15035 1
a 9589 15034 1
a 9590 15033 1
a 9591 15032 1
a 9592 15031 1
a 9593 15030 1
a 9594 15029 1
a 9595 15028 1
a 9596 15027 1
a 9597 15026 1
a 9598 15025 1
a 9599 15024 1
a 9600 15023 1
a 9601 15022 1
a 9602 15021 1
a 9603 15020 1
a 9604 15019 1
a 9605 15018 1
a 9606 15017 1
a 9607 15016 1
a 9608 15015 1
a 9609 15014 1
a 9610 15013 1
a 9611 15012 1
a 9612 15011 1
a 9613 15010 1
a 9614 15009 1
a 9615 15008 1
a 9616 15007 1
a 9617 15006 1
a 9618 15005 1
a 9619 15004 1
a 9620 15003 1
a 9621 15002 1
a 9622 15001 1
a 9623 15000 1
a 9624 14999 1
a 9625 14998 1
a 9626 14997 1
a 9627 14996 1
a 9628 14995 1
a 9629 14994 1
a 9630 14993 1
a 9631 14992 1
a 9632 14991 1
a 9633 14990 1
a 9634 14989 1
a 9635 14988 1
a 9636 14987 1
a 9637 14986 1
a 9638 14985 1
a 9639 14984 1
a 9640 14983 1
a 9641 14982 1
a 9642 14981 1
a 9643 14980 1
a 9644 14979 1
a 9645 14978 1
a 9646 14977 1
a 9647 14976 1
a 9648 14975 1
a 9649 14974 1
a 9650 14973 1
a 9651 14972 1
a 9652 14971 1
a 9653 14970 1
a 9654 14969 1
a 9655 14968 1
a 9656 14967 1
a 9657 14966 1
a 9658 14965 1
a 9659 14964 1
a 9660 14963 1
a 9661 14962 1
a 9662 14961 1
a 9663 14960 1
a 9664 14959 1
a 9665 14958 1
a 9666 14957 1
a 9667 14956 1
a 9668 14955 1
a 9669 14954 1
a 9670 14953 1
a 9671 14952 1
a 9672 14951 1
a 9673 14950 1
a 9674 14949 1
a 9675 14948 1
a 9676 14947 1
a 9677 14946 1
a 9678 14945 1
a 9679 14944 1
a 9680 14943 1
a 9681 14942 1
a 9682 14941 1
a 9683 14940 1
a 9684 14939 1
a 9685 14938 1
a 9686 14937 1
a 9687 14936 1
a 9688 14935 1
a 9689 14934 1
a 9690 14933 1
a 9691 14932 1
a 9692 14931 1
a 9693 14930 1
a 9694 14929 1
a 9695 14928 1
a 9696 14927 1
a 9697 14926 1
a 9698 14925 1
a 9699 14924 1
a 9700 14923 1
a 9701 14922 1
a 9702 14921 1
a 9703 14920 1
a 9704 14919 1
a 9705 14918 1
a 9706 14917 1
a 9707 14916 1
a 9708 14915 1
a 9709 14914 1
a 9710 14913 1
a 9711 14912 1
a 9712 14911 1
a 9713 14910 1
a 9714 14909 1
a 9715 14908 1
a 9716 14907 1
a 9717 14906 1
a 9718 14905 1
a 9719 14904 1
a 9720 14903 1
a 9721 14902 1
a 9722 14901 1
a 9723 14900 1
a 9724 14899 1
a 9725 14898 1
a 9726 14897 1
a 9727 14896 1
a 9728 14895 1
a 9729 14894 1
a 9730 14893 1
a 9731 14892 1
a 9732 14891 1
a 9733 14890 1
a 9734 14889 1
a 9735 14888 1
a 9736 14887 1
a 9737 14886 1
a 9738 14885 1
a 9739 14884 1
a 9740 14883 1
a 9741 14882 1
a 9742 14881 1
a 9743 14880 1
a 9744 14879 1
a 9745 14878 1
a 9746 14877 1
a 9747 14876 1
a 9748 14875 1
a 9749 14874 1
a 9750 14873 1
a 9751 14872 1
a 9752 14871 1
a 9753 14870 1
a 9754 14869 1
a 9755 14868 1
a 9756 14867 1
a 9757 14866 1
a 9758 14865 1
a 9759 14864 1
a 9760 14863 1
a 9761 14862 1
a 9762 14861 1
a 9763 14860 1
a 9764 14859 1
a 9765 14858 1
a 9766 14857 1
a 9767 14856 1
a 9768 14855 1
a 9769 14854 1
a 9770 14853 1
a 9771 14852 1
a 9772 14851 1
a 9773 14850 1
a 9774 14849 1
a 9775 14848 1
a 9776 14847 1
a 9777 14846 1
a 9778 14845 1
a 9779 14844 1
a 9780 14843 1
a 9781 14842 1
a 9782 14841 1
a 9783 14840 1
a 9784 14839 1
a 9785 14838 1
a 9786 14837 1
a 9787 14836 1
a 9788 14835 1
a 9789 14834 1
a 9790 14833 1
a 9791 14832 1
a 9792 14831 1
a 9793 14830 1
a 9794 14829 1
a 9795 14828 1
a 9796 14827 1
a 9797 14826 1
a 9798 14825 1
a 9799 14824 1
a 9800 14823 1
a 9801 14822 1
a 9802 14821 1
a 9803 14820 1
a 9804 14819 1
a 9805 14818 1
a 9806 14817 1
a 9807 14816 1
a 9808 14815 1
a 9809 14814 1
a 9810 14813 1
a 9811 14812 1
a 9812 14811 1
a 9813 14810 1
a 9814 14809 1
a 9815 14808 1
a 9816 14807 1
a 9817 14806 1
a 9818 14805 1
a 9819 14804 1
a 9820 14803 1
a 9821 14802 1
a 9822 14801 1
a 9823 14800 1
a 9824 14799 1
a 9825 14798 1
a 9826 14797 1
a 9827 14796 1
a 9828 14795 1
a 9829 14794 1
a 9830 14793 1
a 9831 14792 1
a 9832 14791 1
a 9833 14790 1
a 9834 14789 1
a 9835 14788 1
a 9836 14787 1
a 9837 14786 1
a 9838 14785 1
a 9839 14784 1
a 9840 14783 1
a 9841 14782 1
a 9842 14781 1
a 9843 14780 1
a 9844 14779 1
a 9845 14778 1
a 9846 14777 1
a 9847 14776 1
a 9848 14775 1
a 9849 14774 1
a 9850 14773 1
a 9851 14772 1
a 9852 14771 1
a 9853 14770 1
a 9854 14769 1
a 9855 14768 1
a 9856 14767 1
a 9857 14766 1
a 9858 14765 1
a 9859 14764 1
a 9860 14763 1
a 9861 14762 1
a 9862 14761 1
a 9863 14760 1
a 9864 14759 1
a 9865 14758 1
a 9866 14757 1
a 9867 14756 1
a 9868 14755 1
a 9869 14754 1
a 9870 14753 1
a 9871 14752 1
a 9872 14751 1
a 9873 14750 1
a 9874 14749 1
a 9875 14748 1
a 9876 14747 1
a 9877 14746 1
a 9878 14745 1
a 9879 14744 1
a 9880 14743 1
a 9881 14742 1
a 9882 14741 1
a 9883 14740 1
a 9884 14739 1
a 9885 14738 1
a 9886 14737 1
a 9887 14736 1
a 9888 14735 1
a 9889 14734 1
a 9890 14733 1
a 9891 14732 1
a 9892 14731 1
a 9893 14730 1
a 9894 14729 1
a 9895 14728 1
a 9896 14727 1
a 9897 14726 1
a 9898 14725 1
a 9899 14724 1
a 9900 14723 1
a 9901 14722 1
a 9902 14721 1
a 9903 14720 1
a 9904 14719 1
a 9905 14718 1
a 9906 14717 1
a 9907 14716 1
a 9908 14715 1
a 9909 14714 1
a 9910 14713 1
a 9911 14712 1
a 9912 14711 1
a 9913 14710 1
a 9914 14709 1
a 9915 14708 1
a 9916 14707 1
a 9917 14706 1
a 9918 14705 1
a 9919 14704 1
a 9920 14703 1
a 9921 14702 1
a 9922 14701 1
a 9923 14700 1
a 9924 14699 1
a 9925 14698 1
a 9926 14697 1
a 9927 14696 1
a 9928 14695 1
a 9929 14694 1
a 9930 14693 1
a 9931 14692 1
a 9932 14691 1
a 9933 14690 1
a 9934 14689 1
a 9935 14688 1
a 9936 14687 1
a 9937 14686 1
a 9938 14685 1
a 9939 14684 1
a 9940 14683 1
a 9941 14682 1
a 9942 14681 1
a 9943 14680 1
a 9944 14679 1
a 9945 14678 1
a 9946 14677 1
a 9947 14676 1
a 9948 14675 1
a 9949 14674 1
a 9950 14673 1
a 9951 14672 1
a 9952 14671 1
a 9953 14670 1
a 9954 14669 1
a 9955 14668 1
a 9956 14667 1
a 9957 14666 1
a 9958 14665 1
a 9959 14664 1
a 9960 14663 1
a 9961 14662 1
a 9962 14661 1
a 9963 14660 1
a 9964 14659 1
a 9965 14658 1
a 9966 14657 1
a 9967 14656 1
a 9968 14655 1
a 9969 14654 1
a 9970 14653 1
a 9971 14652 1
a 9972 14651 1
a 9973 14650 1
a 9974 14649 1
a 9975 14648 1
a 9976 14647 1
a 9977 14646 1
a 9978 14645 1
a 9979 14644 1
a 9980 14643 1
a 9981 14642 1
a 9982 14641 1
a 9983 14640 1
a 9984 14639 1
a 9985 14638 1
a 9986 14637 1
a 9987 14636 1
a 9988 14635 1
a 9989 14634 1
a 9990 14633 1
a 9991 14632 1
a 9992 14631 1
a 9993 14630 1
a 9994 14629 1
a 9995 14628 1
a 9996 14627 1
a 9997 14626 1
a 9998 14625 1
a 9999 14624 1
a 10000 14623 1
a 10001 14622 1
a 10002 14621 1
a 10003 14620 1
a 10004 14619 1
a 10005 14618 1
a 10006 14617 1
a 10007 14616 1
a 10008 14615 1
a 10009 14614 1
a 10010 14613 1
a 10011 14612 1
a 10012 14611 1
a 10013 14610 1
a 10014 14609 1
a 10015 14608 1
a 10016 14607 1
a 10017 14606 1
a 10018 14605 1
a 10019 14604 1
a 10020 14603 1
a 10021 14602 1
a 10022 14601 1
a 10023 14600 1
a 10024 14599 1
a 10025 14598 1
a 10026 14597 1
a 10027 14596 1
a 10028 14595 1
a 10029 14594 1
a 10030 14593 1
a 10031 14592 1
a 10032 14591 1
a 10033 14590 1
a 10034 14589 1
a 10035 14588 1
a 10036 14587 1
a 10037 14586 1
a 10038 14585 1
a 10039 14584 1
a 10040 14583 1
a 10041 14582 1
a 10042 14581 1
a 10043 14580 1
a 10044 14579 1
a 10045 14578 1
a 10046 14577 1
a 10047 14576 1
a 10048 14575 1
a 10049 14574 1
a 10050 14573 1
a 10051 14572 1
a 10052 14571 1
a 10053 14570 1
a 10054 14569 1
a 10055 14568 1
a 10056 14567 1
a 10057 14566 1
a 10058 14565 1
a 10059 14564 1
a 10060 14563 1
a 10061 14562 1
a 10062 14561 1
a 10063 14560 1
a 10064 14559 1
a 10065 14558 1
a 10066 14557 1
a 10067 14556 1
a 10068 14555 1
a 10069 14554 1
a 10070 14553 1
a 10071 14552 1
a 10072 14551 1
a 10073 14550 1
a 10074 14549 1
a 10075 14548 1
a 10076 14547 1
a 10077 14546 1
a 10078 14545 1
a 10079 14544 1
a 10080 14543 1
a 10081 14542 1
a 10082 14541 1
a 10083 14540 1
a 10084 14539 1
a 10085 14538 1
a 10086 14537 1
a 10087 14536 1
a 10088 14535 1
a 10089 14534 1
a 10090 14533 1
a 10091 14532 1
a 10092 14531 1
a 10093 14530 1
a 10094 14529 1
a 10095 14528 1
a 10096 14527 1
a 10097 14526 1
a 10098 14525 1
a 10099 14524 1
a 10100 14523 1
a 10101 14522 1
a 10102 14521 1
a 10103 14520 1
a 10104 14519 1
a 10105 14518 1
a 10106 14517 1
a 10107 14516 1
a 10108 14515 1
a 10109 14514 1
a 10110 14513 1
a 10111 14512 1
a 10112 14511 1
a 10113 14510 1
a 10114 14509 1
a 10115 14508 1
a 10116 14507 1
a 10117 14506 1
a 10118 14505 1
a 10119 14504 1
a 10120 14503 1
a 10121 14502 1
a 10122 14501 1
a 10123 14500 1
a 10124 14499 1
a 10125 14498 1
a 10126 14497 1
a 10127 14496 1
a 10128 14495 1
a 10129 14494 1
a 10130 14493 1
a 10131 14492 1
a 10132 14491 1
a 10133 14490 1
a 10134 14489 1
a 10135 14488 1
a 10136 14487 1
a 10137 14486 1
a 10138 14485 1
a 10139 14484 1
a 10140 14483 1
a 10141 14482 1
a 10142 14481 1
a 10143 14480 1
a 10144 14479 1
a 10145 14478 1
a 10146 14477 1
a 10147 14476 1
a 10148 14475 1
a 10149 14474 1
a 10150 14473 1
a 10151 14472 1
a 10152 14471 1
a 10153 14470 1
a 10154 14469 1
a 10155 14468 1
a 10156 14467 1
a 10157 14466 1
a 10158 14465 1
a 10159 14464 1
a 10160 14463 1
a 10161 14462 1
a 10162 14461 1
a 10163 14460 1
a 10164 14459 1
a 10165 14458 1
a 10166 14457 1
a 10167 14456 1
a 10168 14455 1
a 10169 14454 1
a 10170 14453 1
a 10171 14452 1
a 10172 14451 1
a 10173 14450 1
a 10174 14449 1
a 10175 14448 1
a 10176 14447 1
a 10177 14446 1
a 10178 14445 1
a 10179 14444 1
a 10180 14443 1
a 10181 14442 1
a 10182 14441 1
a 10183 14440 1
a 10184 14439 1
a 10185 14438 1
a 10186 14437 1
a 10187 14436 1
a 10188 14435 1
a 10189 14434 1
a 10190 14433 1
a 10191 14432 1
a 10192 14431 1
a 10193 14430 1
a 10194 14429 1
a 10195 14428 1
a 10196 14427 1
a 10197 14426 1
a 10198 14425 1
a 10199 14424 1
a 10200 14423 1
a 10201 14422 1
a 10202 14421 1
a 10203 14420 1
a 10204 14419 1
a 10205 14418 1
a 10206 14417 1
a 10207 14416 1
a 10208 14415 1
a 10209 14414 1
a 10210 14413 1
a 10211 14412 1
a 10212 14411 1
a 10213 14410 1
a 10214 14409 1
a 10215 14408 1
a 10216 14407 1
a 10217 14406 1
a 10218 14405 1
a 10219 14404 1
a 10220 14403 1
a 10221 14402 1
a 10222 14401 1
a 10223 14400 1
a 10224 14399 1
a 10225 14398 1
a 10226 14397 1
a 10227 14396 1
a 10228 14395 1
a 10229 14394 1
a 10230 14393 1
a 10231 14392 1
a 10232 14391 1
a 10233 14390 1
a 10234 14389 1
a 10235 14388 1
a 10236 14387 1
a 10237 14386 1
a 10238 14385 1
a 10239 14384 1
a 10240 14383 1
a 10241 14382 1
a 10242 14381 1
a 10243 14380 1
a 10244 14379 1
a 10245 14378 1
a 10246 14377 1
a 10247 14376 1
a 10248 14375 1
a 10249 14374 1
a 10250 14373 1
a 10251 14372 1
a 10252 14371 1
a 10253 14370 1
a 10254 14369 1
a 10255 14368 1
a 10256 14367 1
a 10257 14366 1
a 10258 14365 1
a 10259 14364 1
a 10260 14363 1
a 10261 14362 1
a 10262 14361 1
a 10263 14360 1
a 10264 14359 1
a 10265 14358 1
a 10266 14357 1
a 10267 14356 1
a 10268 14355 1
a 10269 14354 1
a 10270 14353 1
a 10271 14352 1
a 10272 14351 1
a 10273 14350 1
a 10274 14349 1
a 10275 14348 1
a 10276 14347 1
a 10277 14346 1
a 10278 14345 1
a 10279 14344 1
a 10280 14343 1
a 10281 14342 1
a 10282 14341 1
a 10283 14340 1
a 10284 14339 1
a 10285 14338 1
a 10286 14337 1
a 10287 14336 1
a 10288 14335 1
a 10289 14334 1
a 10290 14333 1
a 10291 14332 1
a 10292 14331 1
a 10293 14330 1
a 10294 14329 1
a 10295 14328 1
a 10296 14327 1
a 10297 14326 1
a 10298 14325 1
a 10299 14324 1
a 10300 14323 1
a 10301 14322 1
a 10302 14321 1
a 10303 14320 1
a 10304 14319 1
a 10305 14318 1
a 10306 14317 1
a 10307 14316 1
a 10308 14315 1
a 10309 14314 1
a 10310 14313 1
a 10311 14312 1
a 10312 14311 1
a 10313 14310 1
a 10314 14309 1
a 10315 14308 1
a 10316 14307 1
a 10317 14306 1
a 10318 14305 1
a 10319 14304 1
a 10320 14303 1
a 10321 14302 1
a 10322 14301 1
a 10323 14300 1
a 10324 14299 1
a 10325 14298 1
a 10326 14297 1
a 10327 14296 1
a 10328 14295 1
a 10329 14294 1
a 10330 14293 1
a 10331 14292 1
a 10332 14291 1
a 10333 14290 1
a 10334 14289 1
a 10335 14288 1
a 10336 14287 1
a 10337 14286 1
a 10338 14285 1
a 10339 14284 1
a 10340 14283 1
a 10341 14282 1
a 10342 14281 1
a 10343 14280 1
a 10344 14279 1
a 10345 14278 1
a 10346 14277 1
a 10347 14276 1
a 10348 14275 1
a 10349 14274 1
a 10350 14273 1
a 10351 14272 1
a 10352 14271 1
a 10353 14270 1
a 10354 14269 1
a 10355 14268 1
a 10356 14267 1
a 10357 14266 1
a 10358 14265 1
a 10359 14264 1
a 10360 14263 1
a 10361 14262 1
a 10362 14261 1
a 10363 14260 1
a 10364 14259 1
a 10365 14258 1
a 10366 14257 1
a 10367 14256 1
a 10368 14255 1
a 10369 14254 1
a 10370 14253 1
a 10371 14252 1
a 10372 14251 1
a 10373 14250 1
a 10374 14249 1
a 10375 14248 1
a 10376 14247 1
a 10377 14246 1
a 10378 14245 1
a 10379 14244 1
a 10380 14243 1
a 10381 14242 1
a 10382 14241 1
a 10383 14240 1
a 10384 14239 1
a 10385 14238 1
a 10386 14237 1
a 10387 14236 1
a 10388 14235 1
a 10389 14234 1
a 10390 14233 1
a 10391 14232 1
a 10392 14231 1
a 10393 14230 1
a 10394 14229 1
a 10395 14228 1
a 10396 14227 1
a 10397 14226 1
a 10398 14225 1
a 10399 14224 1
a 10400 14223 1
a 10401 14222 1
a 10402 14221 1
a 10403 14220 1
a 10404 14219 1
a 10405 14218 1
a 10406 14217 1
a 10407 14216 1
a 10408 14215 1
a 10409 14214 1
a 10410 14213 1
a 10411 14212 1
a 10412 14211 1
a 10413 14210 1
a 10414 14209 1
a 10415 14208 1
a 10416 14207 1
a 10417 14206 1
a 10418 14205 1
a 10419 14204 1
a 10420 14203 1
a 10421 14202 1
a 10422 14201 1
a 10423 14200 1
a 10424 14199 1
a 10425 14198 1
a 10426 14197 1
a 10427 14196 1
a 10428 14195 1
a 10429 14194 1
a 10430 14193 1
a 10431 14192 1
a 10432 14191 1
a 10433 14190 1
a 10434 14189 1
a 10435 14188 1
a 10436 14187 1
a 10437 14186 1
a 10438 14185 1
a 10439 14184 1
a 10440 14183 1
a 10441 14182 1
a 10442 14181 1
a 10443 14180 1
a 10444 14179 1
a 10445 14178 1
a 10446 14177 1
a 10447 14176 1
a 10448 14175 1
a 10449 14174 1
a 10450 14173 1
a 10451 14172 1
a 10452 14171 1
a 10453 14170 1
a 10454 14169 1
a 10455 14168 1
a 10456 14167 1
a 10457 14166 1
a 10458 14165 1
a 10459 14164 1
a 10460 14163 1
a 10461 14162 1
a 10462 14161 1
a 10463 14160 1
a 10464 14159 1
a 10465 14158 1
a 10466 14157 1
a 10467 14156 1
a 10468 14155 1
a 10469 14154 1
a 10470 14153 1
a 10471 14152 1
a 10472 14151 1
a 10473 14150 1
a 10474 14149 1
a 10475 14148 1
a 10476 14147 1
a 10477 14146 1
a 10478 14145 1
a 10479 14144 1
a 10480 14143 1
a 10481 14142 1
a 10482 14141 1
a 10483 14140 1
a 10484 14139 1
a 10485 14138 1
a 10486 14137 1
a 10487 14136 1
a 10488 14135 1
a 10489 14134 1
a 10490 14133 1
a 10491 14132 1
a 10492 14131 1
a 10493 14130 1
a 10494 14129 1
a 10495 14128 1
a 10496 14127 1
a 10497 14126 1
a 10498 14125 1
a 10499 14124 1
a 10500 14123 1
a 10501 14122 1
a 10502 14121 1
a 10503 14120 1
a 10504 14119 1
a 10505 14118 1
a 10506 14117 1
a 10507 14116 1
a 10508 14115 1
a 10509 14114 1
a 10510 14113 1
a 10511 14112 1
a 10512 14111 1
a 10513 14110 1
a 10514 14109 1
a 10515 14108 1
a 10516 14107 1
a 10517 14106 1
a 10518 14105 1
a 10519 14104 1
a 10520 14103 1
a 10521 14102 1
a 10522 14101 1
a 10523 14100 1
a 10524 14099 1
a 10525 14098 1
a 10526 14097 1
a 10527 14096 1
a 10528 14095 1
a 10529 14094 1
a 10530 14093 1
a 10531 14092 1
a 10532 14091 1
a 10533 14090 1
a 10534 14089 1
a 10535 14088 1
a 10536 14087 1
a 10537 14086 1
a 10538 14085 1
a 10539 14084 1
a 10540 14083 1
a 10541 14082 1
a 10542 14081 1
a 10543 14080 1
a 10544 14079 1
a 10545 14078 1
a 10546 14077 1
a 10547 14076 1
a 10548 14075 1
a 10549 14074 1
a 10550 14073 1
a 10551 14072 1
a 10552 14071 1
a 10553 14070 1
a 10554 14069 1
a 10555 14068 1
a 10556 14067 1
a 10557 14066 1
a 10558 14065 1
a 10559 14064 1
a 10560 14063 1
a 10561 14062 1
a 10562 14061 1
a 10563 14060 1
a 10564 14059 1
a 10565 14058 1
a 10566 14057 1
a 10567 14056 1
a 10568 14055 1
a 10569 14054 1
a 10570 14053 1
a 10571 14052 1
a 10572 14051 1
a 10573 14050 1
a 10574 14049 1
a 10575 14048 1
a 10576 14047 1
a 10577 14046 1
a 10578 14045 1
a 10579 14044 1
a 10580 14043 1
a 10581 14042 1
a 10582 14041 1
a 10583 14040 1
a 10584 14039 1
a 10585 14038 1
a 10586 14037 1
a 10587 14036 1
a 10588 14035 1
a 10589 14034 1
a 10590 14033 1
a 10591 14032 1
a 10592 14031 1
a 10593 14030 1
a 10594 14029 1
a 10595 14028 1
a 10596 14027 1
a 10597 14026 1
a 10598 14025 1
a 10599 14024 1
a 10600 14023 1
a 10601 14022 1
a 10602 14021 1
a 10603 14020 1
a 10604 14019 1
a 10605 14018 1
a 10606 14017 1
a 10607 14016 1
a 10608 14015 1
a 10609 14014 1
a 10610 14013 1
a 10611 14012 1
a 10612 14011 1
a 10613 14010 1
a 10614 14009 1
a 10615 14008 1
a 10616 14007 1
a 10617 14006 1
a 10618 14005 1
a 10619 14004 1
a 10620 14003 1
a 10621 14002 1
a 10622 14001 1
a 10623 14000 1
a 10624 13999 1
a 10625 13998 1
a 10626 13997 1
a 10627 13996 1
a 10628 13995 1
a 10629 13994 1
a 10630 13993 1
a 10631 13992 1
a 10632 13991 1
a 10633 13990 1
a 10634 13989 1
a 10635 13988 1
a 10636 13987 1
a 10637 13986 1
a 10638 13985 1
a 10639 13984 1
a 10640 13983 1
a 10641 13982 1
a 10642 13981 1
a 10643 13980 1
a 10644 13979 1
a 10645 13978 1
a 10646 13977 1
a 10647 13976 1
a 10648 13975 1
a 10649 13974 1
a 10650 13973 1
a 10651 13972 1
a 10652 13971 1
a 10653 13970 1
a 10654 13969 1
a 10655 13968 1
a 10656 13967 1
a 10657 13966 1
a 10658 13965 1
a 10659 13964 1
a 10660 13963 1
a 10661 13962 1
a 10662 13961 1
a 10663 13960 1
a 10664 13959 1
a 10665 13958 1
a 10666 13957 1
a 10667 13956 1
a 10668 13955 1
a 10669 13954 1
a 10670 13953 1
a 10671 13952 1
a 10672 13951 1
a 10673 13950 1
a 10674 13949 1
a 10675 13948 1
a 10676 13947 1
a 10677 13946 1
a 10678 13945 1
a 10679 13944 1
a 10680 13943 1
a 10681 13942 1
a 10682 13941 1
a 10683 13940 1
a 10684 13939 1
a 10685 13938 1
a 10686 13937 1
a 10687 13936 1
a 10688 13935 1
a 10689 13934 1
a 10690 13933 1
a 10691 13932 1
a 10692 13931 1
a 10693 13930 1
a 10694 13929 1
a 10695 13928 1
a 10696 13927 1
a 10697 13926 1
a 10698 13925 1
a 10699 13924 1
a 10700 13923 1
a 10701 13922 1
a 10702 13921 1
a 10703 13920 1
a 10704 13919 1
a 10705 13918 1
a 10706 13917 1
a 10707 13916 1
a 10708 13915 1
a 10709 13914 1
a 10710 13913 1
a 10711 13912 1
a 10712 13911 1
a 10713 13910 1
a 10714 13909 1
a 10715 13908 1
a 10716 13907 1
a 10717 13906 1
a 10718 13905 1
a 10719 13904 1
a 10720 13903 1
a 10721 13902 1
a 10722 13901 1
a 10723 13900 1
a 10724 13899 1
a 10725 13898 1
a 10726 13897 1
a 10727 13896 1
a 10728 13895 1
a 10729 13894 1
a 10730 13893 1
a 10731 13892 1
a 10732 13891 1
a 10733 13890 1
a 10734 13889 1
a 10735 13888 1
a 10736 13887 1
a 10737 13886 1
a 10738 13885 1
a 10739 13884 1
a 10740 13883 1
a 10741 13882 1
a 10742 13881 1
a 10743 13880 1
a 10744 13879 1
a 10745 13878 1
a 10746 13877 1
a 10747 13876 1
a 10748 13875 1
a 10749 13874 1
a 10750 13873 1
a 10751 13872 1
a 10752 13871 1
a 10753 13870 1
a 10754 13869 1
a 10755 13868 1
a 10756 13867 1
a 10757 13866 1
a 10758 13865 1
a 10759 13864 1
a 10760 13863 1
a 10761 13862 1
a 10762 13861 1
a 10763 13860 1
a 10764 13859 1
a 10765 13858 1
a 10766 13857 1
a 10767 13856 1
a 10768 13855 1
a 10769 13854 1
a 10770 13853 1
a 10771 13852 1
a 10772 13851 1
a 10773 13850 1
a 10774 13849 1
a 10775 13848 1
a 10776 13847 1
a 10777 13846 1
a 10778 13845 1
a 10779 13844 1
a 10780 13843 1
a 10781 13842 1
a 10782 13841 1
a 10783 13840 1
a 10784 13839 1
a 10785 13838 1
a 10786 13837 1
a 10787 13836 1
a 10788 13835 1
a 10789 13834 1
a 10790 13833 1
a 10791 13832 1
a 10792 13831 1
a 10793 13830 1
a 10794 13829 1
a 10795 13828 1
a 10796 13827 1
a 10797 13826 1
a 10798 13825 1
a 10799 13824 1
a 10800 13823 1
a 10801 13822 1
a 10802 13821 1
a 10803 13820 1
a 10804 13819 1
a 10805 13818 1
a 10806 13817 1
a 10807 13816 1
a 10808 13815 1
a 10809 13814 1
a 10810 13813 1
a 10811 13812 1
a 10812 13811 1
a 10813 13810 1
a 10814 13809 1
a 10815 13808 1
a 10816 13807 1
a 10817 13806 1
a 10818 13805 1
a 10819 13804 1
a 10820 13803 1
a 10821 13802 1
a 10822 13801 1
a 10823 13800 1
a 10824 13799 1
a 10825 13798 1
a 10826 13797 1
a 10827 13796 1
a 10828 13795 1
a 10829 13794 1
a 10830 13793 1
a 10831 13792 1
a 10832 13791 1
a 10833 13790 1
a 10834 13789 1
a 10835 13788 1
a 10836 13787 1
a 10837 13786 1
a 10838 13785 1
a 10839 13784 1
a 10840 13783 1
a 10841 13782 1
a 10842 13781 1
a 10843 13780 1
a 10844 13779 1
a 10845 13778 1
a 10846 13777 1
a 10847 13776 1
a 10848 13775 1
a 10849 13774 1
a 10850 13773 1
a 10851 13772 1
a 10852 13771 1
a 10853 13770 1
a 10854 13769 1
a 10855 13768 1
a 10856 13767 1
a 10857 13766 1
a 10858 13765 1
a 10859 13764 1
a 10860 13763 1
a 10861 13762 1
a 10862 13761 1
a 10863 13760 1
a 10864 13759 1
a 10865 13758 1
a 10866 13757 1
a 10867 13756 1
a 10868 13755 1
a 10869 13754 1
a 10870 13753 1
a 10871 13752 1
a 10872 13751 1
a 10873 13750 1
a 10874 13749 1
a 10875 13748 1
a 10876 13747 1
a 10877 13746 1
a 10878 13745 1
a 10879 13744 1
a 10880 13743 1
a 10881 13742 1
a 10882 13741 1
a 10883 13740 1
a 10884 13739 1
a 10885 13738 1
a 10886 13737 1
a 10887 13736 1
a 10888 13735 1
a 10889 13734 1
a 10890 13733 1
a 10891 13732 1
a 10892 13731 1
a 10893 13730 1
a 10894 13729 1
a 10895 13728 1
a 10896 13727 1
a 10897 13726 1
a 10898 13725 1
a 10899 13724 1
a 10900 13723 1
a 10901 13722 1
a 10902 13721 1
a 10903 13720 1
a 10904 13719 1
a 10905 13718 1
a 10906 13717 1
a 10907 13716 1
a 10908 13715 1
a 10909 13714 1
a 10910 13713 1
a 10911 13712 1
a 10912 13711 1
a 10913 13710 1
a 10914 13709 1
a 10915 13708 1
a 10916 13707 1
a 10917 13706 1
a 10918 13705 1
a 10919 13704 1
a 10920 13703 1
a 10921 13702 1
a 10922 13701 1
a 10923 13700 1
a 10924 13699 1
a 10925 13698 1
a 10926 13697 1
a 10927 13696 1
a 10928 13695 1
a 10929 13694 1
a 10930 13693 1
a 10931 13692 1
a 10932 13691 1
a 10933 13690 1
a 10934 13689 1
a 10935 13688 1
a 10936 13687 1
a 10937 13686 1
a 10938 13685 1
a 10939 13684 1
a 10940 13683 1
a 10941 13682 1
a 10942 13681 1
a 10943 13680 1
a 10944 13679 1
a 10945 13678 1
a 10946 13677 1
a 10947 13676 1
a 10948 13675 1
a 10949 13674 1
a 10950 13673 1
a 10951 13672 1
a 10952 13671 1
a 10953 13670 1
a 10954 13669 1
a 10955 13668 1
a 10956 13667 1
a 10957 13666 1
a 10958 13665 1
a 10959 13664 1
a 10960 13663 1
a 10961 13662 1
a 10962 13661 1
a 10963 13660 1
a 10964 13659 1
a 10965 13658 1
a 10966 13657 1
a 10967 13656 1
a 10968 13655 1
a 10969 13654 1
a 10970 13653 1
a 10971 13652 1
a 10972 13651 1
a 10973 13650 1
a 10974 13649 1
a 10975 13648 1
a 10976 13647 1
a 10977 13646 1
a 10978 13645 1
a 10979 13644 1
a 10980 13643 1
a 10981 13642 1
a 10982 13641 1
a 10983 13640 1
a 10984 13639 1
a 10985 13638 1
a 10986 13637 1
a 10987 13636 1
a 10988 13635 1
a 10989 13634 1
a 10990 13633 1
a 10991 13632 1
a 10992 13631 1
a 10993 13630 1
a 10994 13629 1
a 10995 13628 1
a 10996 13627 1
a 10997 13626 1
a 10998 13625 1
a 10999 13624 1
a 11000 13623 1
a 11001 13622 1
a 11002 13621 1
a 11003 13620 1
a 11004 13619 1
a 11005 13618 1
a 11006 13617 1
a 11007 13616 1
a 11008 13615 1
a 11009 13614 1
a 11010 13613 1
a 11011 13612 1
a 11012 13611 1
a 11013 13610 1
a 11014 13609 1
a 11015 13608 1
a 11016 13607 1
a 11017 13606 1
a 11018 13605 1
a 11019 13604 1
a 11020 13603 1
a 11021 13602 1
a 11022 13601 1
a 11023 13600 1
a 11024 13599 1
a 11025 13598 1
a 11026 13597 1
a 11027 13596 1
a 11028 13595 1
a 11029 13594 1
a 11030 13593 1
a 11031 13592 1
a 11032 13591 1
a 11033 13590 1
a 11034 13589 1
a 11035 13588 1
a 11036 13587 1
a 11037 13586 1
a 11038 13585 1
a 11039 13584 1
a 11040 13583 1
a 11041 13582 1
a 11042 13581 1
a 11043 13580 1
a 11044 13579 1
a 11045 13578 1
a 11046 13577 1
a 11047 13576 1
a 11048 13575 1
a 11049 13574 1
a 11050 13573 1
a 11051 13572 1
a 11052 13571 1
a 11053 13570 1
a 11054 13569 1
a 11055 13568 1
a 11056 13567 1
a 11057 13566 1
a 11058 13565 1
a 11059 13564 1
a 11060 13563 1
a 11061 13562 1
a 11062 13561 1
a 11063 13560 1
a 11064 13559 1
a 11065 13558 1
a 11066 13557 1
a 11067 13556 1
a 11068 13555 1
a 11069 13554 1
a 11070 13553 1
a 11071 13552 1
a 11072 13551 1
a 11073 13550 1
a 11074 13549 1
a 11075 13548 1
a 11076 13547 1
a 11077 13546 1
a 11078 13545 1
a 11079 13544 1
a 11080 13543 1
a 11081 13542 1
a 11082 13541 1
a 11083 13540 1
a 11084 13539 1
a 11085 13538 1
a 11086 13537 1
a 11087 13536 1
a 11088 13535 1
a 11089 13534 1
a 11090 13533 1
a 11091 13532 1
a 11092 13531 1
a 11093 13530 1
a 11094 13529 1
a 11095 13528 1
a 11096 13527 1
a 11097 13526 1
a 11098 13525 1
a 11099 13524 1
a 11100 13523 1
a 11101 13522 1
a 11102 13521 1
a 11103 13520 1
a 11104 13519 1
a 11105 13518 1
a 11106 13517 1
a 11107 13516 1
a 11108 13515 1
a 11109 13514 1
a 11110 13513 1
a 11111 13512 1
a 11112 13511 1
a 11113 13510 1
a 11114 13509 1
a 11115 13508 1
a 11116 13507 1
a 11117 13506 1
a 11118 13505 1
a 11119 13504 1
a 11120 13503 1
a 11121 13502 1
a 11122 13501 1
a 11123 13500 1
a 11124 13499 1
a 11125 13498 1
a 11126 13497 1
a 11127 13496 1
a 11128 13495 1
a 11129 13494 1
a 11130 13493 1
a 11131 13492 1
a 11132 13491 1
a 11133 13490 1
a 11134 13489 1
a 11135 13488 1
a 11136 13487 1
a 11137 13486 1
a 11138 13485 1
a 11139 13484 1
a 11140 13483 1
a 11141 13482 1
a 11142 13481 1
a 11143 13480 1
a 11144 13479 1
a 11145 13478 1
a 11146 13477 1
a 11147 13476 1
a 11148 13475 1
a 11149 13474 1
a 11150 13473 1
a 11151 13472 1
a 11152 13471 1
a 11153 13470 1
a 11154 13469 1
a 11155 13468 1
a 11156 13467 1
a 11157 13466 1
a 11158 13465 1
a 11159 13464 1
a 11160 13463 1
a 11161 13462 1
a 11162 13461 1
a 11163 13460 1
a 11164 13459 1
a 11165 13458 1
a 11166 13457 1
a 11167 13456 1
a 11168 13455 1
a 11169 13454 1
a 11170 13453 1
a 11171 13452 1
a 11172 13451 1
a 11173 13450 1
a 11174 13449 1
a 11175 13448 1
a 11176 13447 1
a 11177 13446 1
a 11178 13445 1
a 11179 13444 1
a 11180 13443 1
a 11181 13442 1
a 11182 13441 1
a 11183 13440 1
a 11184 13439 1
a 11185 13438 1
a 11186 13437 1
a 11187 13436 1
a 11188 13435 1
a 11189 13434 1
a 11190 13433 1
a 11191 13432 1
a 11192 13431 1
a 11193 13430 1
a 11194 13429 1
a 11195 13428 1
a 11196 13427 1
a 11197 13426 1
a 11198 13425 1
a 11199 13424 1
a 11200 13423 1
a 11201 13422 1
a 11202 13421 1
a 11203 13420 1
a 11204 13419 1
a 11205 13418 1
a 11206 13417 1
a 11207 13416 1
a 11208 13415 1
a 11209 13414 1
a 11210 13413 1
a 11211 13412 1
a 11212 13411 1
a 11213 13410 1
a 11214 13409 1
a 11215 13408 1
a 11216 13407 1
a 11217 13406 1
a 11218 13405 1
a 11219 13404 1
a 11220 13403 1
a 11221 13402 1
a 11222 13401 1
a 11223 13400 1
a 11224 13399 1
a 11225 13398 1
a 11226 13397 1
a 11227 13396 1
a 11228 13395 1
a 11229 13394 1
a 11230 13393 1
a 11231 13392 1
a 11232 13391 1
a 11233 13390 1
a 11234 13389 1
a 11235 13388 1
a 11236 13387 1
a 11237 13386 1
a 11238 13385 1
a 11239 13384 1
a 11240 13383 1
a 11241 13382 1
a 11242 13381 1
a 11243 13380 1
a 11244 13379 1
a 11245 13378 1
a 11246 13377 1
a 11247 13376 1
a 11248 13375 1
a 11249 13374 1
a 11250 13373 1
a 11251 13372 1
a 11252 13371 1
a 11253 13370 1
a 11254 13369 1
a 11255 13368 1
a 11256 13367 1
a 11257 13366 1
a 11258 13365 1
a 11259 13364 1
a 11260 13363 1
a 11261 13362 1
a 11262 13361 1
a 11263 13360 1
a 11264 13359 1
a 11265 13358 1
a 11266 13357 1
a 11267 13356 1
a 11268 13355 1
a 11269 13354 1
a 11270 13353 1
a 11271 13352 1
a 11272 13351 1
a 11273 13350 1
a 11274 13349 1
a 11275 13348 1
a 11276 13347 1
a 11277 13346 1
a 11278 13345 1
a 11279 13344 1
a 11280 13343 1
a 11281 13342 1
a 11282 13341 1
a 11283 13340 1
a 11284 13339 1
a 11285 13338 1
a 11286 13337 1
a 11287 13336 1
a 11288 13335 1
a 11289 13334 1
a 11290 13333 1
a 11291 13332 1
a 11292 13331 1
a 11293 13330 1
a 11294 13329 1
a 11295 13328 1
a 11296 13327 1
a 11297 13326 1
a 11298 13325 1
a 11299 13324 1
a 11300 13323 1
a 11301 13322 1
a 11302 13321 1
a 11303 13320 1
a 11304 13319 1
a 11305 13318 1
a 11306 13317 1
a 11307 13316 1
a 11308 13315 1
a 11309 13314 1
a 11310 13313 1
a 11311 13312 1
a 11312 13311 1
a 11313 13310 1
a 11314 13309 1
a 11315 13308 1
a 11316 13307 1
a 11317 13306 1
a 11318 13305 1
a 11319 13304 1
a 11320 13303 1
a 11321 13302 1
a 11322 13301 1
a 11323 13300 1
a 11324 13299 1
a 11325 13298 1
a 11326 13297 1
a 11327 13296 1
a 11328 13295 1
a 11329 13294 1
a 11330 13293 1
a 11331 13292 1
a 11332 13291 1
a 11333 13290 1
a 11334 13289 1
a 11335 13288 1
a 11336 13287 1
a 11337 13286 1
a 11338 13285 1
a 11339 13284 1
a 11340 13283 1
a 11341 13282 1
a 11342 13281 1
a 11343 13280 1
a 11344 13279 1
a 11345 13278 1
a 11346 13277 1
a 11347 13276 1
a 11348 13275 1
a 11349 13274 1
a 11350 13273 1
a 11351 13272 1
a 11352 13271 1
a 11353 13270 1
a 11354 13269 1
a 11355 13268 1
a 11356 13267 1
a 11357 13266 1
a 11358 13265 1
a 11359 13264 1
a 11360 13263 1
a 11361 13262 1
a 11362 13261 1
a 11363 13260 1
a 11364 13259 1
a 11365 13258 1
a 11366 13257 1
a 11367 13256 1
a 11368 13255 1
a 11369 13254 1
a 11370 13253 1
a 11371 13252 1
a 11372 13251 1
a 11373 13250 1
a 11374 13249 1
a 11375 13248 1
a 11376 13247 1
a 11377 13246 1
a 11378 13245 1
a 11379 13244 1
a 11380 13243 1
a 11381 13242 1
a 11382 13241 1
a 11383 13240 1
a 11384 13239 1
a 11385 13238 1
a 11386 13237 1
a 11387 13236 1
a 11388 13235 1
a 11389 13234 1
a 11390 13233 1
a 11391 13232 1
a 11392 13231 1
a 11393 13230 1
a 11394 13229 1
a 11395 13228 1
a 11396 13227 1
a 11397 13226 1
a 11398 13225 1
a 11399 13224 1
a 11400 13223 1
a 11401 13222 1
a 11402 13221 1
a 11403 13220 1
a 11404 13219 1
a 11405 13218 1
a 11406 13217 1
a 11407 13216 1
a 11408 13215 1
a 11409 13214 1
a 11410 13213 1
a 11411 13212 1
a 11412 13211 1
a 11413 13210 1
a 11414 13209 1
a 11415 13208 1
a 11416 13207 1
a 11417 13206 1
a 11418 13205 1
a 11419 13204 1
a 11420 13203 1
a 11421 13202 1
a 11422 13201 1
a 11423 13200 1
a 11424 13199 1
a 11425 13198 1
a 11426 13197 1
a 11427 13196 1
a 11428 13195 1
a 11429 13194 1
a 11430 13193 1
a 11431 13192 1
a 11432 13191 1
a 11433 13190 1
a 11434 13189 1
a 11435 13188 1
a 11436 13187 1
a 11437 13186 1
a 11438 13185 1
a 11439 13184 1
a 11440 13183 1
a 11441 13182 1
a 11442 13181 1
a 11443 13180 1
a 11444 13179 1
a 11445 13178 1
a 11446 13177 1
a 11447 13176 1
a 11448 13175 1
a 11449 13174 1
a 11450 13173 1
a 11451 13172 1
a 11452 13171 1
a 11453 13170 1
a 11454 13169 1
a 11455 13168 1
a 11456 13167 1
a 11457 13166 1
a 11458 13165 1
a 11459 13164 1
a 11460 13163 1
a 11461 13162 1
a 11462 13161 1
a 11463 13160 1
a 11464 13159 1
a 11465 13158 1
a 11466 13157 1
a 11467 13156 1
a 11468 13155 1
a 11469 13154 1
a 11470 13153 1
a 11471 13152 1
a 11472 13151 1
a 11473 13150 1
a 11474 13149 1
a 11475 13148 1
a 11476 13147 1
a 11477 13146 1
a 11478 13145 1
a 11479 13144 1
a 11480 13143 1
a 11481 13142 1
a 11482 13141 1
a 11483 13140 1
a 11484 13139 1
a 11485 13138 1
a 11486 13137 1
a 11487 13136 1
a 11488 13135 1
a 11489 13134 1
a 11490 13133 1
a 11491 13132 1
a 11492 13131 1
a 11493 13130 1
a 11494 13129 1
a 11495 13128 1
a 11496 13127 1
a 11497 13126 1
a 11498 13125 1
a 11499 13124 1
a 11500 13123 1
a 11501 13122 1
a 11502 13121 1
a 11503 13120 1
a 11504 13119 1
a 11505 13118 1
a 11506 13117 1
a 11507 13116 1
a 11508 13115 1
a 11509 13114 1
a 11510 13113 1
a 11511 13112 1
a 11512 13111 1
a 11513 13110 1
a 11514 13109 1
a 11515 13108 1
a 11516 13107 1
a 11517 13106 1
a 11518 13105 1
a 11519 13104 1
a 11520 13103 1
a 11521 13102 1
a 11522 13101 1
a 11523 13100 1
a 11524 13099 1
a 11525 13098 1
a 11526 13097 1
a 11527 13096 1
a 11528 13095 1
a 11529 13094 1
a 11530 13093 1
a 11531 13092 1
a 11532 13091 1
a 11533 13090 1
a 11534 13089 1
a 11535 13088 1
a 11536 13087 1
a 11537 13086 1
a 11538 13085 1
a 11539 13084 1
a 11540 13083 1
a 11541 13082 1
a 11542 13081 1
a 11543 13080 1
a 11544 13079 1
a 11545 13078 1
a 11546 13077 1
a 11547 13076 1
a 11548 13075 1
a 11549 13074 1
a 11550 13073 1
a 11551 13072 1
a 11552 13071 1
a 11553 13070 1
a 11554 13069 1
a 11555 13068 1
a 11556 13067 1
a 11557 13066 1
a 11558 13065 1
a 11559 13064 1
a 11560 13063 1
a 11561 13062 1
a 11562 13061 1
a 11563 13060 1
a 11564 13059 1
a 11565 13058 1
a 11566 13057 1
a 11567 13056 1
a 11568 13055 1
a 11569 13054 1
a 11570 13053 1
a 11571 13052 1
a 11572 13051 1
a 11573 13050 1
a 11574 13049 1
a 11575 13048 1
a 11576 13047 1
a 11577 13046 1
a 11578 13045 1
a 11579 13044 1
a 11580 13043 1
a 11581 13042 1
a 11582 13041 1
a 11583 13040 1
a 11584 13039 1
a 11585 13038 1
a 11586 13037 1
a 11587 13036 1
a 11588 13035 1
a 11589 13034 1
a 11590 13033 1
a 11591 13032 1
a 11592 13031 1
a 11593 13030 1
a 11594 13029 1
a 11595 13028 1
a 11596 13027 1
a 11597 13026 1
a 11598 13025 1
a 11599 13024 1
a 11600 13023 1
a 11601 13022 1
a 11602 13021 1
a 11603 13020 1
a 11604 13019 1
a 11605 13018 1
a 11606 13017 1
a 11607 13016 1
a 11608 13015 1
a 11609 13014 1
a 11610 13013 1
a 11611 13012 1
a 11612 13011 1
a 11613 13010 1
a 11614 13009 1
a 11615 13008 1
a 11616 13007 1
a 11617 13006 1
a 11618 13005 1
a 11619 13004 1
a 11620 13003 1
a 11621 13002 1
a 11622 13001 1
a 11623 13000 1
a 11624 12999 1
a 11625 12998 1
a 11626 12997 1
a 11627 12996 1
a 11628 12995 1
a 11629 12994 1
a 11630 12993 1
a 11631 12992 1
a 11632 12991 1
a 11633 12990 1
a 11634 12989 1
a 11635 12988 1
a 11636 12987 1
a 11637 12986 1
a 11638 12985 1
a 11639 12984 1
a 11640 12983 1
a 11641 12982 1
a 11642 12981 1
a 11643 12980 1
a 11644 12979 1
a 11645 12978 1
a 11646 12977 1
a 11647 12976 1
a 11648 12975 1
a 11649 12974 1
a 11650 12973 1
a 11651 12972 1
a 11652 12971 1
a 11653 12970 1
a 11654 12969 1
a 11655 12968 1
a 11656 12967 1
a 11657 12966 1
a 11658 12965 1
a 11659 12964 1
a 11660 12963 1
a 11661 12962 1
a 11662 12961 1
a 11663 12960 1
a 11664 12959 1
a 11665 12958 1
a 11666 12957 1
a 11667 12956 1
a 11668 12955 1
a 11669 12954 1
a 11670 12953 1
a 11671 12952 1
a 11672 12951 1
a 11673 12950 1
a 11674 12949 1
a 11675 12948 1
a 11676 12947 1
a 11677 12946 1
a 11678 12945 1
a 11679 12944 1
a 11680 12943 1
a 11681 12942 1
a 11682 12941 1
a 11683 12940 1
a 11684 12939 1
a 11685 12938 1
a 11686 12937 1
a 11687 12936 1
a 11688 12935 1
a 11689 12934 1
a 11690 12933 1
a 11691 12932 1
a 11692 12931 1
a 11693 12930 1
a 11694 12929 1
a 11695 12928 1
a 11696 12927 1
a 11697 12926 1
a 11698 12925 1
a 11699 12924 1
a 11700 12923 1
a 11701 12922 1
a 11702 12921 1
a 11703 12920 1
a 11704 12919 1
a 11705 12918 1
a 11706 12917 1
a 11707 12916 1
a 11708 12915 1
a 11709 12914 1
a 11710 12913 1
a 11711 12912 1
a 11712 12911 1
a 11713 12910 1
a 11714 12909 1
a 11715 12908 1
a 11716 12907 1
a 11717 12906 1
a 11718 12905 1
a 11719 12904 1
a 11720 12903 1
a 11721 12902 1
a 11722 12901 1
a 11723 12900 1
a 11724 12899 1
a 11725 12898 1
a 11726 12897 1
a 11727 12896 1
a 11728 12895 1
a 11729 12894 1
a 11730 12893 1
a 11731 12892 1
a 11732 12891 1
a 11733 12890 1
a 11734 12889 1
a 11735 12888 1
a 11736 12887 1
a 11737 12886 1
a 11738 12885 1
a 11739 12884 1
a 11740 12883 1
a 11741 12882 1
a 11742 12881 1
a 11743 12880 1
a 11744 12879 1
a 11745 12878 1
a 11746 12877 1
a 11747 12876 1
a 11748 12875 1
a 11749 12874 1
a 11750 12873 1
a 11751 12872 1
a 11752 12871 1
a 11753 12870 1
a 11754 12869 1
a 11755 12868 1
a 11756 12867 1
a 11757 12866 1
a 11758 12865 1
a 11759 12864 1
a 11760 12863 1
a 11761 12862 1
a 11762 12861 1
a 11763 12860 1
a 11764 12859 1
a 11765 12858 1
a 11766 12857 1
a 11767 12856 1
a 11768 12855 1
a 11769 12854 1
a 11770 12853 1
a 11771 12852 1
a 11772 12851 1
a 11773 12850 1
a 11774 12849 1
a 11775 12848 1
a 11776 12847 1
a 11777 12846 1
a 11778 12845 1
a 11779 12844 1
a 11780 12843 1
a 11781 12842 1
a 11782 12841 1
a 11783 12840 1
a 11784 12839 1
a 11785 12838 1
a 11786 12837 1
a 11787 12836 1
a 11788 12835 1
a 11789 12834 1
a 11790 12833 1
a 11791 12832 1
a 11792 12831 1
a 11793 12830 1
a 11794 12829 1
a 11795 12828 1
a 11796 12827 1
a 11797 12826 1
a 11798 12825 1
a 11799 12824 1
a 11800 12823 1
a 11801 12822 1
a 11802 12821 1
a 11803 12820 1
a 11804 12819 1
a 11805 12818 1
a 11806 12817 1
a 11807 12816 1
a 11808 12815 1
a 11809 12814 1
a 11810 12813 1
a 11811 12812 1
a 11812 12811 1
a 11813 12810 1
a 11814 12809 1
a 11815 12808 1
a 11816 12807 1
a 11817 12806 1
a 11818 12805 1
a 11819 12804 1
a 11820 12803 1
a 11821 12802 1
a 11822 12801 1
a 11823 12800 1
a 11824 12799 1
a 11825 12798 1
a 11826 12797 1
a 11827 12796 1
a 11828 12795 1
a 11829 12794 1
a 11830 12793 1
a 11831 12792 1
a 11832 12791 1
a 11833 12790 1
a 11834 12789 1
a 11835 12788 1
a 11836 12787 1
a 11837 12786 1
a 11838 12785 1
a 11839 12784 1
a 11840 12783 1
a 11841 12782 1
a 11842 12781 1
a 11843 12780 1
a 11844 12779 1
a 11845 12778 1
a 11846 12777 1
a 11847 12776 1
a 11848 12775 1
a 11849 12774 1
a 11850 12773 1
a 11851 12772 1
a 11852 12771 1
a 11853 12770 1
a 11854 12769 1
a 11855 12768 1
a 11856 12767 1
a 11857 12766 1
a 11858 12765 1
a 11859 12764 1
a 11860 12763 1
a 11861 12762 1
a 11862 12761 1
a 11863 12760 1
a 11864 12759 1
a 11865 12758 1
a 11866 12757 1
a 11867 12756 1
a 11868 12755 1
a 11869 12754 1
a 11870 12753 1
a 11871 12752 1
a 11872 12751 1
a 11873 12750 1
a 11874 12749 1
a 11875 12748 1
a 11876 12747 1
a 11877 12746 1
a 11878 12745 1
a 11879 12744 1
a 11880 12743 1
a 11881 12742 1
a 11882 12741 1
a 11883 12740 1
a 11884 12739 1
a 11885 12738 1
a 11886 12737 1
a 11887 12736 1
a 11888 12735 1
a 11889 12734 1
a 11890 12733 1
a 11891 12732 1
a 11892 12731 1
a 11893 12730 1
a 11894 12729 1
a 11895 12728 1
a 11896 12727 1
a 11897 12726 1
a 11898 12725 1
a 11899 12724 1
a 11900 12723 1
a 11901 12722 1
a 11902 12721 1
a 11903 12720 1
a 11904 12719 1
a 11905 12718 1
a 11906 12717 1
a 11907 12716 1
a 11908 12715 1
a 11909 12714 1
a 11910 12713 1
a 11911 12712 1
a 11912 12711 1
a 11913 12710 1
a 11914 12709 1
a 11915 12708 1
a 11916 12707 1
a 11917 12706 1
a 11918 12705 1
a 11919 12704 1
a 11920 12703 1
a 11921 12702 1
a 11922 12701 1
a 11923 12700 1
a 11924 12699 1
a 11925 12698 1
a 11926 12697 1
a 11927 12696 1
a 11928 12695 1
a 11929 12694 1
a 11930 12693 1
a 11931 12692 1
a 11932 12691 1
a 11933 12690 1
a 11934 12689 1
a 11935 12688 1
a 11936 12687 1
a 11937 12686 1
a 11938 12685 1
a 11939 12684 1
a 11940 12683 1
a 11941 12682 1
a 11942 12681 1
a 11943 12680 1
a 11944 12679 1
a 11945 12678 1
a 11946 12677 1
a 11947 12676 1
a 11948 12675 1
a 11949 12674 1
a 11950 12673 1
a 11951 12672 1
a 11952 12671 1
a 11953 12670 1
a 11954 12669 1
a 11955 12668 1
a 11956 12667 1
a 11957 12666 1
a 11958 12665 1
a 11959 12664 1
a 11960 12663 1
a 11961 12662 1
a 11962 12661 1
a 11963 12660 1
a 11964 12659 1
a 11965 12658 1
a 11966 12657 1
a 11967 12656 1
a 11968 12655 1
a 11969 12654 1
a 11970 12653 1
a 11971 12652 1
a 11972 12651 1
a 11973 12650 1
a 11974 12649 1
a 11975 12648 1
a 11976 12647 1
a 11977 12646 1
a 11978 12645 1
a 11979 12644 1
a 11980 12643 1
a 11981 12642 1
a 11982 12641 1
a 11983 12640 1
a 11984 12639 1
a 11985 12638 1
a 11986 12637 1
a 11987 12636 1
a 11988 12635 1
a 11989 12634 1
a 11990 12633 1
a 11991 12632 1
a 11992 12631 1
a 11993 12630 1
a 11994 12629 1
a 11995 12628 1
a 11996 12627 1
a 11997 12626 1
a 11998 12625 1
a 11999 12624 1
a 12000 12623 1
a 12001 12622 1
a 12002 12621 1
a 12003 12620 1
a 12004 12619 1
a 12005 12618 1
a 12006 12617 1
a 12007 12616 1
a 12008 12615 1
a 12009 12614 1
a 12010 12613 1
a 12011 12612 1
a 12012 12611 1
a 12013 12610 1
a 12014 12609 1
a 12015 12608 1
a 12016 12607 1
a 12017 12606 1
a 12018 12605 1
a 12019 12604 1
a 12020 12603 1
a 12021 12602 1
a 12022 12601 1
a 12023 12600 1
a 12024 12599 1
a 12025 12598 1
a 12026 12597 1
a 12027 12596 1
a 12028 12595 1
a 12029 12594 1
a 12030 12593 1
a 12031 12592 1
a 12032 12591 1
a 12033 12590 1
a 12034 12589 1
a 12035 12588 1
a 12036 12587 1
a 12037 12586 1
a 12038 12585 1
a 12039 12584 1
a 12040 12583 1
a 12041 12582 1
a 12042 12581 1
a 12043 12580 1
a 12044 12579 1
a 12045 12578 1
a 12046 12577 1
a 12047 12576 1
a 12048 12575 1
a 12049 12574 1
a 12050 12573 1
a 12051 12572 1
a 12052 12571 1
a 12053 12570 1
a 12054 12569 1
a 12055 12568 1
a 12056 12567 1
a 12057 12566 1
a 12058 12565 1
a 12059 12564 1
a 12060 12563 1
a 12061 12562 1
a 12062 12561 1
a 12063 12560 1
a 12064 12559 1
a 12065 12558 1
a 12066 12557 1
a 12067 12556 1
a 12068 12555 1
a 12069 12554 1
a 12070 12553 1
a 12071 12552 1
a 12072 12551 1
a 12073 12550 1
a 12074 12549 1
a 12075 12548 1
a 12076 12547 1
a 12077 12546 1
a 12078 12545 1
a 12079 12544 1
a 12080 12543 1
a 12081 12542 1
a 12082 12541 1
a 12083 12540 1
a 12084 12539 1
a 12085 12538 1
a 12086 12537 1
a 12087 12536 1
a 12088 12535 1
a 12089 12534 1
a 12090 12533 1
a 12091 12532 1
a 12092 12531 1
a 12093 12530 1
a 12094 12529 1
a 12095 12528 1
a 12096 12527 1
a 12097 12526 1
a 12098 12525 1
a 12099 12524 1
a 12100 12523 1
a 12101 12522 1
a 12102 12521 1
a 12103 12520 1
a 12104 12519 1
a 12105 12518 1
a 12106 12517 1
a 12107 12516 1
a 12108 12515 1
a 12109 12514 1
a 12110 12513 1
a 12111 12512 1
a 12112 12511 1
a 12113 12510 1
a 12114 12509 1
a 12115 12508 1
a 12116 12507 1
a 12117 12506 1
a 12118 12505 1
a 12119 12504 1
a 12120 12503 1
a 12121 12502 1
a 12122 12501 1
a 12123 12500 1
a 12124 12499 1
a 12125 12498 1
a 12126 12497 1
a 12127 12496 1
a 12128 12495 1
a 12129 12494 1
a 12130 12493 1
a 12131 12492 1
a 12132 12491 1
a 12133 12490 1
a 12134 12489 1
a 12135 12488 1
a 12136 12487 1
a 12137 12486 1
a 12138 12485 1
a 12139 12484 1
a 12140 12483 1
a 12141 12482 1
a 12142 12481 1
a 12143 12480 1
a 12144 12479 1
a 12145 12478 1
a 12146 12477 1
a 12147 12476 1
a 12148 12475 1
a 12149 12474 1
a 12150 12473 1
a 12151 12472 1
a 12152 12471 1
a 12153 12470 1
a 12154 12469 1
a 12155 12468 1
a 12156 12467 1
a 12157 12466 1
a 12158 12465 1
a 12159 12464 1
a 12160 12463 1
a 12161 12462 1
a 12162 12461 1
a 12163 12460 1
a 12164 12459 1
a 12165 12458 1
a 12166 12457 1
a 12167 12456 1
a 12168 12455 1
a 12169 12454 1
a 12170 12453 1
a 12171 12452 1
a 12172 12451 1
a 12173 12450 1
a 12174 12449 1
a 12175 12448 1
a 12176 12447 1
a 12177 12446 1
a 12178 12445 1
a 12179 12444 1
a 12180 12443 1
a 12181 12442 1
a 12182 12441 1
a 12183 12440 1
a 12184 12439 1
a 12185 12438 1
a 12186 12437 1
a 12187 12436 1
a 12188 12435 1
a 12189 12434 1
a 12190 12433 1
a 12191 12432 1
a 12192 12431 1
a 12193 12430 1
a 12194 12429 1
a 12195 12428 1
a 12196 12427 1
a 12197 12426 1
a 12198 12425 1
a 12199 12424 1
a 12200 12423 1
a 12201 12422 1
a 12202 12421 1
a 12203 12420 1
a 12204 12419 1
a 12205 12418 1
a 12206 12417 1
a 12207 12416 1
a 12208 12415 1
a 12209 12414 1
a 12210 12413 1
a 12211 12412 1
a 12212 12411 1
a 12213 12410 1
a 12214 12409 1
a 12215 12408 1
a 12216 12407 1
a 12217 12406 1
a 12218 12405 1
a 12219 12404 1
a 12220 12403 1
a 12221 12402 1
a 12222 12401 1
a 12223 12400 1
a 12224 12399 1
a 12225 12398 1
a 12226 12397 1
a 12227 12396 1
a 12228 12395 1
a 12229 12394 1
a 12230 12393 1
a 12231 12392 1
a 12232 12391 1
a 12233 12390 1
a 12234 12389 1
a 12235 12388 1
a 12236 12387 1
a 12237 12386 1
a 12238 12385 1
a 12239 12384 1
a 12240 12383 1
a 12241 12382 1
a 12242 12381 1
a 12243 12380 1
a 12244 12379 1
a 12245 12378 1
a 12246 12377 1
a 12247 12376 1
a 12248 12375 1
a 12249 12374 1
a 12250 12373 1
a 12251 12372 1
a 12252 12371 1
a 12253 12370 1
a 12254 12369 1
a 12255 12368 1
a 12256 12367 1
a 12257 12366 1
a 12258 12365 1
a 12259 12364 1
a 12260 12363 1
a 12261 12362 1
a 12262 12361 1
a 12263 12360 1
a 12264 12359 1
a 12265 12358 1
a 12266 12357 1
a 12267 12356 1
a 12268 12355 1
a 12269 12354 1
a 12270 12353 1
a 12271 12352 1
a 12272 12351 1
a 12273 12350 1
a 12274 12349 1
a 12275 12348 1
a 12276 12347 1
a 12277 12346 1
a 12278 12345 1
a 12279 12344 1
a 12280 12343 1
a 12281 12342 1
a 12282 12341 1
a 12283 12340 1
a 12284 12339 1
a 12285 12338 1
a 12286 12337 1
a 12287 12336 1
a 12288 12335 1
a 12289 12334 1
a 12290 12333 1
a 12291 12332 1
a 12292 12331 1
a 12293 12330 1
a 12294 12329 1
a 12295 12328 1
a 12296 12327 1
a 12297 12326 1
a 12298 12325 1
a 12299 12324 1
a 12300 12323 1
a 12301 12322 1
a 12302 12321 1
a 12303 12320 1
a 12304 12319 1
a 12305 12318 1
a 12306 12317 1
a 12307 12316 1
a 12308 12315 1
a 12309 12314 1
a 12310 12313 1
a 1 3 1000000
a 1 8209 1000000
a 8208 2 1000000
a 16414 2 1000000
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/assortativity.c0000644000175100001710000002465400000000000026065 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g;
    FILE *karate, *neural;
    igraph_real_t res;
    igraph_vector_t types;
    igraph_vector_t degree, outdegree, indegree;

    igraph_real_t football_types[] = {
        7, 0, 2, 3, 7, 3, 2, 8, 8, 7, 3, 10, 6, 2, 6, 2, 7, 9, 6, 1, 9, 8, 8, 7, 10, 0, 6, 9,
        11, 1, 1, 6, 2, 0, 6, 1, 5, 0, 6, 2, 3, 7, 5, 6, 4, 0, 11, 2, 4, 11, 10, 8, 3, 11, 6,
        1, 9, 4, 11, 10, 2, 6, 9, 10, 2, 9, 4, 11, 8, 10, 9, 6, 3, 11, 3, 4, 9, 8, 8, 1, 5, 3,
        5, 11, 3, 6, 4, 9, 11, 0, 5, 4, 4, 7, 1, 9, 9, 10, 3, 6, 2, 1, 3, 0, 7, 0, 2, 3, 8, 0,
        4, 8, 4, 9, 11
    };

    karate = fopen("karate.gml", "r");
    igraph_read_graph_gml(&g, karate);
    fclose(karate);

    igraph_vector_init(&types, 0);
    igraph_degree(&g, &types, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1);

    igraph_assortativity_nominal(&g, &types, &res, /*directed=*/ 0);
    printf("%.5f\n", res);

    igraph_destroy(&g);

    /*---------------------*/

    neural = fopen("celegansneural.gml", "r");
    igraph_read_graph_gml(&g, neural);
    fclose(neural);

    igraph_degree(&g, &types, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1);

    igraph_assortativity_nominal(&g, &types, &res, /*directed=*/ 1);
    printf("%.5f\n", res);
    igraph_assortativity_nominal(&g, &types, &res, /*directed=*/ 0);
    printf("%.5f\n", res);

    igraph_destroy(&g);
    igraph_vector_destroy(&types);

    /*---------------------*/

    karate = fopen("karate.gml", "r");
    igraph_read_graph_gml(&g, karate);
    fclose(karate);

    igraph_vector_init(°ree, 0);
    igraph_degree(&g, °ree, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1);
    igraph_vector_add_constant(°ree, -1);

    igraph_assortativity(&g, °ree, 0, &res, /*directed=*/ 0);
    printf("%.5f\n", res);

    igraph_destroy(&g);

    /*---------------------*/

    neural = fopen("celegansneural.gml", "r");
    igraph_read_graph_gml(&g, neural);
    fclose(neural);

    igraph_degree(&g, °ree, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1);
    igraph_vector_add_constant(°ree, -1);

    igraph_assortativity(&g, °ree, 0, &res, /*directed=*/ 1);
    printf("%.5f\n", res);
    igraph_assortativity(&g, °ree, 0, &res, /*directed=*/ 0);
    printf("%.5f\n", res);

    igraph_vector_destroy(°ree);

    /*---------------------*/

    igraph_vector_init(&indegree, 0);
    igraph_vector_init(&outdegree, 0);
    igraph_degree(&g, &indegree, igraph_vss_all(), IGRAPH_IN, /*loops=*/ 1);
    igraph_degree(&g, &outdegree, igraph_vss_all(), IGRAPH_OUT, /*loops=*/ 1);
    igraph_vector_add_constant(&indegree, -1);
    igraph_vector_add_constant(&outdegree, -1);

    igraph_assortativity(&g, &outdegree, &indegree, &res, /*directed=*/ 1);
    printf("%.5f\n", res);

    igraph_vector_destroy(&indegree);
    igraph_vector_destroy(&outdegree);

    /*---------------------*/

    igraph_assortativity_degree(&g, &res, /*directed=*/ 1);
    printf("%.5f\n", res);

    igraph_destroy(&g);

    /*---------------------*/

    karate = fopen("karate.gml", "r");
    igraph_read_graph_gml(&g, karate);
    fclose(karate);

    igraph_assortativity_degree(&g, &res, /*directed=*/ 1);
    printf("%.5f\n", res);

    igraph_destroy(&g);

    /*---------------------*/

    igraph_small(&g, sizeof(football_types) / sizeof(igraph_real_t),
                 IGRAPH_UNDIRECTED,
                 0, 1, 2, 3, 0, 4, 4, 5, 3, 5, 2, 6, 6, 7, 7, 8, 8, 9, 0, 9, 4, 9, 5, 10, 10, 11, 5, 11,
                 3, 11, 12, 13, 2, 13, 2, 14, 12, 14, 14, 15, 13, 15, 2, 15, 4, 16, 9, 16, 0, 16,
                 16, 17, 12, 17, 12, 18, 18, 19, 17, 20, 20, 21, 8, 21, 7, 21, 9, 22, 7, 22, 21,
                 22, 8, 22, 22, 23, 9, 23, 4, 23, 16, 23, 0, 23, 11, 24, 24, 25, 1, 25, 3, 26, 12,
                 26, 14, 26, 26, 27, 17, 27, 1, 27, 17, 27, 4, 28, 11, 28, 24, 28, 19, 29, 29,
                 30, 19, 30, 18, 31, 31, 32, 21, 32, 15, 32, 13, 32, 6, 32, 0, 33, 1, 33, 25, 33,
                 19, 33, 31, 34, 26, 34, 12, 34, 18, 34, 34, 35, 0, 35, 29, 35, 19, 35, 30, 35,
                 18, 36, 12, 36, 20, 36, 19, 36, 36, 37, 1, 37, 25, 37, 33, 37, 18, 38, 16, 38,
                 28, 38, 26, 38, 14, 38, 12, 38, 38, 39, 6, 39, 32, 39, 13, 39, 15, 39, 7, 40, 3,
                 40, 40, 41, 8, 41, 4, 41, 23, 41, 9, 41, 0, 41, 16, 41, 34, 42, 29, 42, 18, 42,
                 26, 42, 42, 43, 36, 43, 26, 43, 31, 43, 38, 43, 12, 43, 14, 43, 19, 44, 35, 44,
                 30, 44, 44, 45, 13, 45, 33, 45, 1, 45, 37, 45, 25, 45, 21, 46, 46, 47, 22, 47,
                 6, 47, 15, 47, 2, 47, 39, 47, 32, 47, 44, 48, 48, 49, 32, 49, 46, 49, 30, 50,
                 24, 50, 11, 50, 28, 50, 50, 51, 40, 51, 8, 51, 22, 51, 21, 51, 3, 52, 40, 52, 5,
                 52, 52, 53, 25, 53, 48, 53, 49, 53, 46, 53, 39, 54, 31, 54, 38, 54, 14, 54, 34,
                 54, 18, 54, 54, 55, 31, 55, 6, 55, 35, 55, 29, 55, 19, 55, 30, 55, 27, 56, 56,
                 57, 1, 57, 42, 57, 44, 57, 48, 57, 3, 58, 6, 58, 17, 58, 36, 58, 36, 59, 58, 59,
                 59, 60, 10, 60, 39, 60, 6, 60, 47, 60, 13, 60, 15, 60, 2, 60, 43, 61, 47, 61,
                 54, 61, 18, 61, 26, 61, 31, 61, 34, 61, 61, 62, 20, 62, 45, 62, 17, 62, 27, 62,
                 56, 62, 27, 63, 58, 63, 59, 63, 42, 63, 63, 64, 9, 64, 32, 64, 60, 64, 2, 64, 6,
                 64, 47, 64, 13, 64, 0, 65, 27, 65, 17, 65, 63, 65, 56, 65, 20, 65, 65, 66, 59,
                 66, 24, 66, 44, 66, 48, 66, 16, 67, 41, 67, 46, 67, 53, 67, 49, 67, 67, 68, 15,
                 68, 50, 68, 21, 68, 51, 68, 7, 68, 22, 68, 8, 68, 4, 69, 24, 69, 28, 69, 50, 69,
                 11, 69, 69, 70, 43, 70, 65, 70, 20, 70, 56, 70, 62, 70, 27, 70, 60, 71, 18, 71,
                 14, 71, 34, 71, 54, 71, 38, 71, 61, 71, 31, 71, 71, 72, 2, 72, 10, 72, 3, 72,
                 40, 72, 52, 72, 7, 73, 49, 73, 53, 73, 67, 73, 46, 73, 73, 74, 2, 74, 72, 74, 5,
                 74, 10, 74, 52, 74, 3, 74, 40, 74, 20, 75, 66, 75, 48, 75, 57, 75, 44, 75, 75,
                 76, 27, 76, 59, 76, 20, 76, 70, 76, 66, 76, 56, 76, 62, 76, 73, 77, 22, 77, 7,
                 77, 51, 77, 21, 77, 8, 77, 77, 78, 23, 78, 50, 78, 28, 78, 22, 78, 8, 78, 68,
                 78, 7, 78, 51, 78, 31, 79, 43, 79, 30, 79, 19, 79, 29, 79, 35, 79, 55, 79, 79,
                 80, 37, 80, 29, 80, 16, 81, 5, 81, 40, 81, 10, 81, 72, 81, 3, 81, 81, 82, 74,
                 82, 39, 82, 77, 82, 80, 82, 30, 82, 29, 82, 7, 82, 53, 83, 81, 83, 69, 83, 73,
                 83, 46, 83, 67, 83, 49, 83, 83, 84, 24, 84, 49, 84, 52, 84, 3, 84, 74, 84, 10,
                 84, 81, 84, 5, 84, 3, 84, 6, 85, 14, 85, 38, 85, 43, 85, 80, 85, 12, 85, 26, 85,
                 31, 85, 44, 86, 53, 86, 75, 86, 57, 86, 48, 86, 80, 86, 66, 86, 86, 87, 17, 87,
                 62, 87, 56, 87, 24, 87, 20, 87, 65, 87, 49, 88, 58, 88, 83, 88, 69, 88, 46, 88,
                 53, 88, 73, 88, 67, 88, 88, 89, 1, 89, 37, 89, 25, 89, 33, 89, 55, 89, 45, 89,
                 5, 90, 8, 90, 23, 90, 0, 90, 11, 90, 50, 90, 24, 90, 69, 90, 28, 90, 29, 91, 48,
                 91, 66, 91, 69, 91, 44, 91, 86, 91, 57, 91, 80, 91, 91, 92, 35, 92, 15, 92, 86,
                 92, 48, 92, 57, 92, 61, 92, 66, 92, 75, 92, 0, 93, 23, 93, 80, 93, 16, 93, 4,
                 93, 82, 93, 91, 93, 41, 93, 9, 93, 34, 94, 19, 94, 55, 94, 79, 94, 80, 94, 29,
                 94, 30, 94, 82, 94, 35, 94, 70, 95, 69, 95, 76, 95, 62, 95, 56, 95, 27, 95, 17,
                 95, 87, 95, 37, 95, 48, 96, 17, 96, 76, 96, 27, 96, 56, 96, 65, 96, 20, 96, 87,
                 96, 5, 97, 86, 97, 58, 97, 11, 97, 59, 97, 63, 97, 97, 98, 77, 98, 48, 98, 84,
                 98, 40, 98, 10, 98, 5, 98, 52, 98, 81, 98, 89, 99, 34, 99, 14, 99, 85, 99, 54,
                 99, 18, 99, 31, 99, 61, 99, 71, 99, 14, 99, 99, 100, 82, 100, 13, 100, 2, 100,
                 15, 100, 32, 100, 64, 100, 47, 100, 39, 100, 6, 100, 51, 101, 30, 101, 94,
                 101, 1, 101, 79, 101, 58, 101, 19, 101, 55, 101, 35, 101, 29, 101, 100, 102,
                 74, 102, 52, 102, 98, 102, 72, 102, 40, 102, 10, 102, 3, 102, 102, 103, 33,
                 103, 45, 103, 25, 103, 89, 103, 37, 103, 1, 103, 70, 103, 72, 104, 11, 104,
                 0, 104, 93, 104, 67, 104, 41, 104, 16, 104, 87, 104, 23, 104, 4, 104, 9, 104,
                 89, 105, 103, 105, 33, 105, 62, 105, 37, 105, 45, 105, 1, 105, 80, 105, 25,
                 105, 25, 106, 56, 106, 92, 106, 2, 106, 13, 106, 32, 106, 60, 106, 6, 106,
                 64, 106, 15, 106, 39, 106, 88, 107, 75, 107, 98, 107, 102, 107, 72, 107, 40,
                 107, 81, 107, 5, 107, 10, 107, 84, 107, 4, 108, 9, 108, 7, 108, 51, 108, 77,
                 108, 21, 108, 78, 108, 22, 108, 68, 108, 79, 109, 30, 109, 63, 109, 1, 109,
                 33, 109, 103, 109, 105, 109, 45, 109, 25, 109, 89, 109, 37, 109, 67, 110,
                 13, 110, 24, 110, 80, 110, 88, 110, 49, 110, 73, 110, 46, 110, 83, 110, 53,
                 110, 23, 111, 64, 111, 46, 111, 78, 111, 8, 111, 21, 111, 51, 111, 7, 111,
                 108, 111, 68, 111, 77, 111, 52, 112, 96, 112, 97, 112, 57, 112, 66, 112, 63,
                 112, 44, 112, 92, 112, 75, 112, 91, 112, 28, 113, 20, 113, 95, 113, 59, 113,
                 70, 113, 17, 113, 87, 113, 76, 113, 65, 113, 96, 113, 83, 114, 88, 114, 110,
                 114, 53, 114, 49, 114, 73, 114, 46, 114, 67, 114, 58, 114, 15, 114, 104, 114,
                 -1);
    igraph_simplify(&g, /*multiple=*/ 1, /*loops=*/ 1, /*edge_comb=*/ 0);
    igraph_vector_view(&types, football_types,
                       sizeof(football_types) / sizeof(igraph_real_t));
    igraph_assortativity_nominal(&g, &types, &res, /*directed=*/ 0);
    printf("%.5f\n", res);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/assortativity.out0000644000175100001710000000012700000000000026437 0ustar00runnerdocker00000000000000-0.07775
0.00303
0.00147
-0.47561
-0.15328
-0.14996
-0.22580
-0.22580
-0.47561
0.60794
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/bellman_ford.c0000644000175100001710000000732200000000000025555 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_matrix(const igraph_matrix_t *m) {
    long int nrow = igraph_matrix_nrow(m);
    long int ncol = igraph_matrix_ncol(m);
    long int i, j;
    igraph_real_t val;

    for (i = 0; i < nrow; i++) {
        printf("%li:", i);
        for (j = 0; j < ncol; j++) {
            val = MATRIX(*m, i, j);
            if (igraph_is_inf(val)) {
                if (val < 0) {
                    printf("-inf");
                } else {
                    printf(" inf");
                }
            } else {
                printf(" %3.0f", val);
            }
        }
        printf("\n");
    }
    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_t weights;
    igraph_real_t weights_data_0[] = { 0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1 };
    igraph_real_t weights_data_1[] = { 6, 7, 8, -4, -2, -3, 9, 2, 7 };
    igraph_real_t weights_data_2[] = { 6, 7, 2, -4, -2, -3, 9, 2, 7 };
    igraph_matrix_t res;

    /* Graph with only positive weights */
    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 0, 3,    1, 2, 1, 4, 1, 5,
                 2, 3, 2, 6,         3, 2, 3, 6,
                 4, 5, 4, 7,         5, 6, 5, 8, 5, 9,
                 7, 5, 7, 8,         8, 9,
                 5, 2,
                 2, 1,
                 -1);

    igraph_vector_view(&weights, weights_data_0,
                       sizeof(weights_data_0) / sizeof(igraph_real_t));

    igraph_matrix_init(&res, 0, 0);
    igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(), igraph_vss_all(),
                                       &weights, IGRAPH_OUT);
    print_matrix(&res);

    igraph_matrix_destroy(&res);
    igraph_destroy(&g);

    printf("\n");

    /***************************************/

    /* Graph with negative weights */
    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 0, 3, 1, 3, 1, 4, 2, 1, 3, 2, 3, 4, 4, 0, 4, 2, -1);

    igraph_vector_view(&weights, weights_data_1,
                       sizeof(weights_data_1) / sizeof(igraph_real_t));

    igraph_matrix_init(&res, 0, 0);
    igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(),
                                       igraph_vss_all(), &weights, IGRAPH_OUT);
    print_matrix(&res);

    /***************************************/

    /* Same graph with negative loop */
    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_view(&weights, weights_data_2,
                       sizeof(weights_data_2) / sizeof(igraph_real_t));
    if (igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(),
                                           igraph_vss_all(),
                                           &weights, IGRAPH_OUT) != IGRAPH_ENEGLOOP) {
        return 1;
    }

    igraph_matrix_destroy(&res);
    igraph_destroy(&g);

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/bellman_ford.out0000644000175100001710000000104200000000000026133 0ustar00runnerdocker000000000000000:   0   0   0   1   5   2   1  13   3   5
1: inf   0   0   1   5   2   1  13   3   5
2: inf   1   0   1   6   3   1  14   4   6
3: inf   1   0   0   6   3   1  14   4   6
4: inf   5   4   5   0   2   3   8   3   5
5: inf   3   2   3   8   0   1  16   1   3
6: inf inf inf inf inf inf   0 inf inf inf
7: inf   4   3   4   9   1   2   0   1   4
8: inf inf inf inf inf inf inf inf   0   4
9: inf inf inf inf inf inf inf inf inf   0

0:   0   2   4   7  -2
1:  -2   0   2   5  -4
2:  -4  -2   0   3  -6
3:  -7  -5  -3   0  -9
4:   2   4   6   9   0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/blas.c0000644000175100001710000000212600000000000024047 0ustar00runnerdocker00000000000000
#include 

int main() {
    igraph_matrix_t m;
    igraph_vector_t x, y, z;
    igraph_real_t xz, xx;

    igraph_vector_init_real(&x, 3, 1.0, 2.0, 3.0);
    igraph_vector_init_real(&y, 4, 4.0, 5.0, 6.0, 7.0);
    igraph_vector_init_real(&z, 3, -1.0, 0.0, 0.5);

    igraph_matrix_init(&m, 4, 3);
    MATRIX(m, 0, 0) = 1;
    MATRIX(m, 0, 1) = 2;
    MATRIX(m, 0, 2) = 3;
    MATRIX(m, 1, 0) = 2;
    MATRIX(m, 1, 1) = 3;
    MATRIX(m, 1, 2) = 4;
    MATRIX(m, 2, 0) = 3;
    MATRIX(m, 2, 1) = 4;
    MATRIX(m, 2, 2) = 5;
    MATRIX(m, 3, 0) = 4;
    MATRIX(m, 3, 1) = 5;
    MATRIX(m, 3, 2) = 6;

    /* Compute 2 m.x + 3 y and store it in y. */
    igraph_blas_dgemv(/* transpose= */ 0, /* alpha= */ 2, &m, &x, /* beta= */ 3, &y);
    igraph_vector_print(&y);

    /* Compute the squared norm of x, as well as the dor product of x and z. */
    igraph_blas_ddot(&x, &x, &xx);
    igraph_blas_ddot(&x, &z, &xz);
    printf("x.x = %g, x.z = %g\n", xx, xz);

    igraph_matrix_destroy(&m);
    igraph_vector_destroy(&z);
    igraph_vector_destroy(&y);
    igraph_vector_destroy(&x);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/blas.out0000644000175100001710000000004000000000000024425 0ustar00runnerdocker0000000000000040 55 70 85
x.x = 14, x.z = 0.5
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes.c0000644000175100001710000003177000000000000025466 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

int print_attributes(const igraph_t *g) {

    igraph_vector_t gtypes, vtypes, etypes;
    igraph_strvector_t gnames, vnames, enames;
    long int i;

    igraph_vector_t vec;
    igraph_strvector_t svec;
    long int j;

    igraph_vector_init(>ypes, 0);
    igraph_vector_init(&vtypes, 0);
    igraph_vector_init(&etypes, 0);
    igraph_strvector_init(&gnames, 0);
    igraph_strvector_init(&vnames, 0);
    igraph_strvector_init(&enames, 0);

    igraph_cattribute_list(g, &gnames, >ypes, &vnames, &vtypes,
                           &enames, &etypes);

    /* Graph attributes */
    for (i = 0; i < igraph_strvector_size(&gnames); i++) {
        printf("%s=", STR(gnames, i));
        if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_real_printf(GAN(g, STR(gnames, i)));
            putchar(' ');
        } else {
            printf("\"%s\" ", GAS(g, STR(gnames, i)));
        }
    }
    printf("\n");

    for (i = 0; i < igraph_vcount(g); i++) {
        long int j;
        printf("Vertex %li: ", i);
        for (j = 0; j < igraph_strvector_size(&vnames); j++) {
            printf("%s=", STR(vnames, j));
            if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(VAN(g, STR(vnames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", VAS(g, STR(vnames, j), i));
            }
        }
        printf("\n");
    }

    for (i = 0; i < igraph_ecount(g); i++) {
        long int j;
        printf("Edge %li (%i-%i): ", i, (int)IGRAPH_FROM(g, i), (int)IGRAPH_TO(g, i));
        for (j = 0; j < igraph_strvector_size(&enames); j++) {
            printf("%s=", STR(enames, j));
            if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(EAN(g, STR(enames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", EAS(g, STR(enames, j), i));
            }
        }
        printf("\n");
    }

    /* Check vector-based query functions */
    igraph_vector_init(&vec, 0);
    igraph_strvector_init(&svec, 0);

    for (j = 0; j < igraph_strvector_size(&vnames); j++) {
        if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_cattribute_VANV(g, STR(vnames, j), igraph_vss_all(), &vec);
            for (i = 0; i < igraph_vcount(g); i++) {
                igraph_real_t num = VAN(g, STR(vnames, j), i);
                if (num != VECTOR(vec)[i] &&
                    (!isnan(num) || !isnan(VECTOR(vec)[i]))) {
                    exit(51);
                }
            }
        } else {
            igraph_cattribute_VASV(g, STR(vnames, j), igraph_vss_all(), &svec);
            for (i = 0; i < igraph_vcount(g); i++) {
                const char *str = VAS(g, STR(vnames, j), i);
                if (strcmp(str, STR(svec, i))) {
                    exit(52);
                }
            }
        }
    }

    for (j = 0; j < igraph_strvector_size(&enames); j++) {
        if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_cattribute_EANV(g, STR(enames, j),
                                   igraph_ess_all(IGRAPH_EDGEORDER_ID), &vec);
            for (i = 0; i < igraph_ecount(g); i++) {
                igraph_real_t num = EAN(g, STR(enames, j), i);
                if (num != VECTOR(vec)[i] &&
                    (!isnan(num) || !isnan(VECTOR(vec)[i]))) {
                    exit(53);
                }
            }
        } else {
            igraph_cattribute_EASV(g, STR(enames, j),
                                   igraph_ess_all(IGRAPH_EDGEORDER_ID), &svec);
            for (i = 0; i < igraph_ecount(g); i++) {
                const char *str = EAS(g, STR(enames, j), i);
                if (strcmp(str, STR(svec, i))) {
                    exit(54);
                }
            }
        }
    }

    igraph_strvector_destroy(&svec);
    igraph_vector_destroy(&vec);

    igraph_strvector_destroy(&enames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&gnames);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(>ypes);

    return 0;
}

int main() {

    igraph_t g, g2;
    FILE *ifile;
    igraph_vector_t gtypes, vtypes, etypes;
    igraph_strvector_t gnames, vnames, enames;
    long int i;
    igraph_vector_t y;
    igraph_strvector_t id;
    igraph_vector_bool_t type;
    char str[21];

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    ifile = fopen("links.net", "r");
    if (ifile == 0) {
        return 10;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);

    igraph_vector_init(>ypes, 0);
    igraph_vector_init(&vtypes, 0);
    igraph_vector_init(&etypes, 0);
    igraph_strvector_init(&gnames, 0);
    igraph_strvector_init(&vnames, 0);
    igraph_strvector_init(&enames, 0);

    igraph_cattribute_list(&g, &gnames, >ypes, &vnames, &vtypes,
                           &enames, &etypes);

    /* List attribute names and types */
    printf("Graph attributes: ");
    for (i = 0; i < igraph_strvector_size(&gnames); i++) {
        printf("%s (%i) ", STR(gnames, i), (int)VECTOR(gtypes)[i]);
    }
    printf("\n");
    printf("Vertex attributes: ");
    for (i = 0; i < igraph_strvector_size(&vnames); i++) {
        printf("%s (%i) ", STR(vnames, i), (int)VECTOR(vtypes)[i]);
    }
    printf("\n");
    printf("Edge attributes: ");
    for (i = 0; i < igraph_strvector_size(&enames); i++) {
        printf("%s (%i) ", STR(enames, i), (int)VECTOR(etypes)[i]);
    }
    printf("\n");

    print_attributes(&g);

    /* Copying a graph */
    igraph_copy(&g2, &g);
    print_attributes(&g2);
    igraph_destroy(&g2);

    /* Adding vertices */
    igraph_add_vertices(&g, 3, 0);
    print_attributes(&g);

    /* Adding edges */
    igraph_add_edge(&g, 1, 1);
    igraph_add_edge(&g, 2, 5);
    igraph_add_edge(&g, 3, 6);
    print_attributes(&g);

    /* Deleting vertices */
    igraph_delete_vertices(&g, igraph_vss_1(1));
    igraph_delete_vertices(&g, igraph_vss_1(4));
    print_attributes(&g);

    /* Deleting edges */
    igraph_delete_edges(&g, igraph_ess_1(igraph_ecount(&g) - 1));
    igraph_delete_edges(&g, igraph_ess_1(0));
    print_attributes(&g);

    /* Set graph attributes */
    SETGAN(&g, "id", 10);
    if (GAN(&g, "id") != 10) {
        return 11;
    }
    SETGAS(&g, "name", "toy");
    if (strcmp(GAS(&g, "name"), "toy")) {
        return 12;
    }
    SETGAB(&g, "is_regular", 0);
    if (GAB(&g, "is_regular") != 0) {
        return 13;
    }

    /* Delete graph attributes */
    DELGA(&g, "id");
    DELGA(&g, "name");
    DELGA(&g, "is_regular");
    igraph_cattribute_list(&g, &gnames, 0, 0, 0, 0, 0);
    if (igraph_strvector_size(&gnames) != 0) {
        return 14;
    }

    /* Delete vertex attributes */
    DELVA(&g, "x");
    DELVA(&g, "shape");
    DELVA(&g, "xfact");
    DELVA(&g, "yfact");
    igraph_cattribute_list(&g, 0, 0, &vnames, 0, 0, 0);
    if (igraph_strvector_size(&vnames) != 3) {
        return 15;
    }

    /* Delete edge attributes */
    igraph_cattribute_list(&g, 0, 0, 0, 0, &enames, 0);
    i = igraph_strvector_size(&enames);
    DELEA(&g, "hook1");
    DELEA(&g, "hook2");
    DELEA(&g, "label");
    igraph_cattribute_list(&g, 0, 0, 0, 0, &enames, 0);
    if (igraph_strvector_size(&enames) != i - 3) {
        return 16;
    }

    /* Set vertex attributes */
    SETVAN(&g, "y", 0, -1);
    SETVAN(&g, "y", 1, 2.1);
    if (VAN(&g, "y", 0) != -1 ||
        VAN(&g, "y", 1) != 2.1) {
        return 17;
    }
    SETVAS(&g, "id", 0, "foo");
    SETVAS(&g, "id", 1, "bar");
    if (strcmp(VAS(&g, "id", 0), "foo") ||
        strcmp(VAS(&g, "id", 1), "bar")) {
        return 18;
    }
    SETVAB(&g, "type", 0, 1);
    SETVAB(&g, "type", 1, 0);
    if (!VAB(&g, "type", 0) || VAB(&g, "type", 1)) {
        return 26;
    }

    /* Set edge attributes */
    SETEAN(&g, "weight", 2, 100.0);
    SETEAN(&g, "weight", 0, -100.1);
    if (EAN(&g, "weight", 2) != 100.0 ||
        EAN(&g, "weight", 0) != -100.1) {
        return 19;
    }
    SETEAS(&g, "color", 2, "RED");
    SETEAS(&g, "color", 0, "Blue");
    if (strcmp(EAS(&g, "color", 2), "RED") ||
        strcmp(EAS(&g, "color", 0), "Blue")) {
        return 20;
    }
    SETEAB(&g, "type", 0, 1);
    SETEAB(&g, "type", 2, 0);
    if (!EAB(&g, "type", 0) || EAB(&g, "type", 2)) {
        return 27;
    }

    /* Set vertex attributes as vector */
    igraph_vector_init(&y, igraph_vcount(&g));
    igraph_vector_fill(&y, 1.23);
    SETVANV(&g, "y", &y);
    igraph_vector_destroy(&y);
    for (i = 0; i < igraph_vcount(&g); i++) {
        if (VAN(&g, "y", i) != 1.23) {
            return 21;
        }
    }
    igraph_vector_init_seq(&y, 0, igraph_vcount(&g) - 1);
    SETVANV(&g, "foobar", &y);
    igraph_vector_destroy(&y);
    for (i = 0; i < igraph_vcount(&g); i++) {
        if (VAN(&g, "foobar", i) != i) {
            return 22;
        }
    }

    igraph_vector_bool_init(&type, igraph_vcount(&g));
    for (i = 0; i < igraph_vcount(&g); i++) {
        VECTOR(type)[i] = (i % 2 == 1);
    }
    SETVABV(&g, "type", &type);
    igraph_vector_bool_destroy(&type);
    for (i = 0; i < igraph_vcount(&g); i++) {
        if (VAB(&g, "type", i) != (i % 2 == 1)) {
            return 28;
        }
    }

    igraph_strvector_init(&id, igraph_vcount(&g));
    for (i = 0; i < igraph_vcount(&g); i++) {
        snprintf(str, sizeof(str) - 1, "%li", i);
        igraph_strvector_set(&id, i, str);
    }
    SETVASV(&g, "foo", &id);
    igraph_strvector_destroy(&id);
    for (i = 0; i < igraph_vcount(&g); i++) {
        printf("%s ", VAS(&g, "foo", i));
    }
    printf("\n");
    igraph_strvector_init(&id, igraph_vcount(&g));
    for (i = 0; i < igraph_vcount(&g); i++) {
        snprintf(str, sizeof(str) - 1, "%li", i);
        igraph_strvector_set(&id, i, str);
    }
    SETVASV(&g, "id", &id);
    igraph_strvector_destroy(&id);
    for (i = 0; i < igraph_vcount(&g); i++) {
        printf("%s ", VAS(&g, "id", i));
    }
    printf("\n");

    /* Set edge attributes as vector */
    igraph_vector_init(&y, igraph_ecount(&g));
    igraph_vector_fill(&y, 12.3);
    SETEANV(&g, "weight", &y);
    igraph_vector_destroy(&y);
    for (i = 0; i < igraph_ecount(&g); i++) {
        if (EAN(&g, "weight", i) != 12.3) {
            return 23;
        }
    }
    igraph_vector_init_seq(&y, 0, igraph_ecount(&g) - 1);
    SETEANV(&g, "foobar", &y);
    igraph_vector_destroy(&y);
    for (i = 0; i < igraph_ecount(&g); i++) {
        if (VAN(&g, "foobar", i) != i) {
            return 24;
        }
    }

    igraph_vector_bool_init(&type, igraph_ecount(&g));
    for (i = 0; i < igraph_ecount(&g); i++) {
        VECTOR(type)[i] = (i % 2 == 1);
    }
    SETEABV(&g, "type", &type);
    igraph_vector_bool_destroy(&type);
    for (i = 0; i < igraph_ecount(&g); i++) {
        if (EAB(&g, "type", i) != (i % 2 == 1)) {
            return 29;
        }
    }

    igraph_strvector_init(&id, igraph_ecount(&g));
    for (i = 0; i < igraph_ecount(&g); i++) {
        snprintf(str, sizeof(str) - 1, "%li", i);
        igraph_strvector_set(&id, i, str);
    }
    SETEASV(&g, "foo", &id);
    igraph_strvector_destroy(&id);
    for (i = 0; i < igraph_ecount(&g); i++) {
        printf("%s ", EAS(&g, "foo", i));
    }
    printf("\n");
    igraph_strvector_init(&id, igraph_ecount(&g));
    for (i = 0; i < igraph_ecount(&g); i++) {
        snprintf(str, sizeof(str) - 1, "%li", i);
        igraph_strvector_set(&id, i, str);
    }
    SETEASV(&g, "color", &id);
    igraph_strvector_destroy(&id);
    for (i = 0; i < igraph_ecount(&g); i++) {
        printf("%s ", EAS(&g, "color", i));
    }
    printf("\n");

    /* Delete all remaining attributes */
    DELALL(&g);
    igraph_cattribute_list(&g, &gnames, >ypes, &vnames, &vtypes, &enames, &etypes);
    if (igraph_strvector_size(&gnames) != 0 ||
        igraph_strvector_size(&vnames) != 0 ||
        igraph_strvector_size(&enames) != 0) {
        return 25;
    }

    /* Destroy */
    igraph_vector_destroy(>ypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(&etypes);
    igraph_strvector_destroy(&gnames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&enames);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes.out0000644000175100001710000003173100000000000026050 0ustar00runnerdocker00000000000000Graph attributes: 
Vertex attributes: id (2) name (2) x (1) y (1) shape (2) xfact (1) yfact (1) 
Edge attributes: weight (1) hook2 (1) edgewidth (1) color (2) arrowsize (1) angle1 (1) velocity1 (1) angle2 (1) velocity2 (1) arrowpos (1) label (2) labelcolor (2) fontsize (1) labelangle (1) labelpos (1) labeldegree (1) labelangle2 (1) linepattern (2) hook1 (1) 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="2" name="2" x=0.8188 y=0.2458 shape="ellipse" xfact=1 yfact=1 
Vertex 2: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Edge 0 (0-0): weight=1 hook2=0 edgewidth=3 color="Blue" arrowsize=3 angle1=-130 velocity1=0.6 angle2=-130 velocity2=0.6 arrowpos=0.5 label="Bezier loop" labelcolor="BlueViolet" fontsize=20 labelangle=58 labelpos=0.3 labeldegree=360 labelangle2=0 linepattern="" hook1=0 
Edge 1 (1-0): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=120 velocity1=1.3 angle2=-120 velocity2=0.3 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=19 labelpos=0.5 labeldegree=180 labelangle2=270 linepattern="" hook1=0 
Edge 2 (0-1): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=40 velocity1=2.8 angle2=30 velocity2=0.8 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=NaN labelpos=0.65 labeldegree=0 labelangle2=90 linepattern="" hook1=0 
Edge 3 (3-1): weight=-1 hook2=0 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=250 arrowpos=25 label="Circular arc" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=0 
Edge 4 (2-3): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 5 (0-2): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 6 (2-2): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="2" name="2" x=0.8188 y=0.2458 shape="ellipse" xfact=1 yfact=1 
Vertex 2: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Edge 0 (0-0): weight=1 hook2=0 edgewidth=3 color="Blue" arrowsize=3 angle1=-130 velocity1=0.6 angle2=-130 velocity2=0.6 arrowpos=0.5 label="Bezier loop" labelcolor="BlueViolet" fontsize=20 labelangle=58 labelpos=0.3 labeldegree=360 labelangle2=0 linepattern="" hook1=0 
Edge 1 (1-0): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=120 velocity1=1.3 angle2=-120 velocity2=0.3 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=19 labelpos=0.5 labeldegree=180 labelangle2=270 linepattern="" hook1=0 
Edge 2 (0-1): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=40 velocity1=2.8 angle2=30 velocity2=0.8 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=NaN labelpos=0.65 labeldegree=0 labelangle2=90 linepattern="" hook1=0 
Edge 3 (3-1): weight=-1 hook2=0 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=250 arrowpos=25 label="Circular arc" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=0 
Edge 4 (2-3): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 5 (0-2): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 6 (2-2): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="2" name="2" x=0.8188 y=0.2458 shape="ellipse" xfact=1 yfact=1 
Vertex 2: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Vertex 4: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 5: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 6: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Edge 0 (0-0): weight=1 hook2=0 edgewidth=3 color="Blue" arrowsize=3 angle1=-130 velocity1=0.6 angle2=-130 velocity2=0.6 arrowpos=0.5 label="Bezier loop" labelcolor="BlueViolet" fontsize=20 labelangle=58 labelpos=0.3 labeldegree=360 labelangle2=0 linepattern="" hook1=0 
Edge 1 (1-0): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=120 velocity1=1.3 angle2=-120 velocity2=0.3 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=19 labelpos=0.5 labeldegree=180 labelangle2=270 linepattern="" hook1=0 
Edge 2 (0-1): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=40 velocity1=2.8 angle2=30 velocity2=0.8 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=NaN labelpos=0.65 labeldegree=0 labelangle2=90 linepattern="" hook1=0 
Edge 3 (3-1): weight=-1 hook2=0 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=250 arrowpos=25 label="Circular arc" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=0 
Edge 4 (2-3): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 5 (0-2): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 6 (2-2): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="2" name="2" x=0.8188 y=0.2458 shape="ellipse" xfact=1 yfact=1 
Vertex 2: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Vertex 4: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 5: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 6: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Edge 0 (0-0): weight=1 hook2=0 edgewidth=3 color="Blue" arrowsize=3 angle1=-130 velocity1=0.6 angle2=-130 velocity2=0.6 arrowpos=0.5 label="Bezier loop" labelcolor="BlueViolet" fontsize=20 labelangle=58 labelpos=0.3 labeldegree=360 labelangle2=0 linepattern="" hook1=0 
Edge 1 (1-0): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=120 velocity1=1.3 angle2=-120 velocity2=0.3 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=19 labelpos=0.5 labeldegree=180 labelangle2=270 linepattern="" hook1=0 
Edge 2 (0-1): weight=1 hook2=0 edgewidth=NaN color="" arrowsize=NaN angle1=40 velocity1=2.8 angle2=30 velocity2=0.8 arrowpos=25 label="Bezier arc" labelcolor="" fontsize=NaN labelangle=NaN labelpos=0.65 labeldegree=0 labelangle2=90 linepattern="" hook1=0 
Edge 3 (3-1): weight=-1 hook2=0 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=250 arrowpos=25 label="Circular arc" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=0 
Edge 4 (2-3): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 5 (0-2): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 6 (2-2): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 
Edge 7 (1-1): weight=NaN hook2=NaN edgewidth=NaN color="" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=NaN label="" labelcolor="" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=NaN 
Edge 8 (2-5): weight=NaN hook2=NaN edgewidth=NaN color="" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=NaN label="" labelcolor="" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=NaN 
Edge 9 (3-6): weight=NaN hook2=NaN edgewidth=NaN color="" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=NaN label="" labelcolor="" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=NaN 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 2: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 4: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Edge 0 (0-0): weight=1 hook2=0 edgewidth=3 color="Blue" arrowsize=3 angle1=-130 velocity1=0.6 angle2=-130 velocity2=0.6 arrowpos=0.5 label="Bezier loop" labelcolor="BlueViolet" fontsize=20 labelangle=58 labelpos=0.3 labeldegree=360 labelangle2=0 linepattern="" hook1=0 
Edge 1 (1-2): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 2 (0-1): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 3 (1-1): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 
Edge 4 (2-4): weight=NaN hook2=NaN edgewidth=NaN color="" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=NaN label="" labelcolor="" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="" hook1=NaN 

Vertex 0: id="1" name="1" x=0.0938 y=0.0896 shape="ellipse" xfact=1 yfact=1 
Vertex 1: id="3" name="3" x=0.3688 y=0.7792 shape="ellipse" xfact=1 yfact=0 
Vertex 2: id="4" name="4" x=0.9583 y=0.8563 shape="ellipse" xfact=1 yfact=0 
Vertex 3: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Vertex 4: id="" name="" x=NaN y=NaN shape="" xfact=NaN yfact=NaN 
Edge 0 (1-2): weight=1 hook2=0 edgewidth=2 color="OliveGreen" arrowsize=NaN angle1=NaN velocity1=NaN angle2=NaN velocity2=NaN arrowpos=25 label="Straight arc" labelcolor="PineGreen" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 1 (0-1): weight=1 hook2=0 edgewidth=5 color="Brown" arrowsize=NaN angle1=NaN velocity1=-1 angle2=NaN velocity2=-20 arrowpos=25 label="Oval arc" labelcolor="Black" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=NaN labelangle2=NaN linepattern="Dashed" hook1=0 
Edge 2 (1-1): weight=-1 hook2=12 edgewidth=1 color="Red" arrowsize=NaN angle1=NaN velocity1=-2 angle2=NaN velocity2=-15 arrowpos=0.5 label="Circular loop" labelcolor="OrangeRed" fontsize=NaN labelangle=NaN labelpos=NaN labeldegree=180 labelangle2=270 linepattern="" hook1=6 
0 1 2 3 4 
0 1 2 3 4 
0 1 2 
0 1 2 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes2.c0000644000175100001710000000457400000000000025552 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void null_warning_handler (const char *reason, const char *file,
                           int line, int igraph_errno) {
}

int main() {

    igraph_t g;
    igraph_vector_t y;
    igraph_warning_handler_t* oldwarnhandler;

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    /* Create a graph, add some attributes and save it as a GraphML file */
    igraph_famous(&g, "Petersen");
    SETGAS(&g, "name", "Petersen's graph");
    SETGAN(&g, "vertices", igraph_vcount(&g));
    SETGAN(&g, "edges", igraph_ecount(&g));
    SETGAB(&g, "famous", 1);

    igraph_vector_init_seq(&y, 1, igraph_vcount(&g));
    SETVANV(&g, "id", &y);
    igraph_vector_destroy(&y);

    SETVAS(&g, "name", 0, "foo");
    SETVAS(&g, "name", 1, "foobar");

    SETVAB(&g, "is_first", 0, 1);

    igraph_vector_init_seq(&y, 1, igraph_ecount(&g));
    SETEANV(&g, "id", &y);
    igraph_vector_destroy(&y);

    SETEAS(&g, "name", 0, "FOO");
    SETEAS(&g, "name", 1, "FOOBAR");

    SETEAB(&g, "is_first", 0, 1);

    /* Turn off the warning handler temporarily because the GML writer will
     * print warnings about boolean attributes being converted to numbers, and
     * we don't care about these */
    oldwarnhandler = igraph_set_warning_handler(null_warning_handler);
    igraph_write_graph_gml(&g, stdout, 0, "");
    igraph_set_warning_handler(oldwarnhandler);

    /* Back to business */
    igraph_write_graph_graphml(&g, stdout, /*prefixattr=*/ 1);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes2.out0000644000175100001710000001515100000000000026130 0ustar00runnerdocker00000000000000Creator "igraph version @VERSION@ "
Version 1
graph
[
  directed 0
  name "Petersen's graph"
  vertices 10
  edges 15
  famous 1
  node
  [
    id 1
    name "foo"
    isfirst 1
  ]
  node
  [
    id 2
    name "foobar"
    isfirst 0
  ]
  node
  [
    id 3
    name ""
    isfirst 0
  ]
  node
  [
    id 4
    name ""
    isfirst 0
  ]
  node
  [
    id 5
    name ""
    isfirst 0
  ]
  node
  [
    id 6
    name ""
    isfirst 0
  ]
  node
  [
    id 7
    name ""
    isfirst 0
  ]
  node
  [
    id 8
    name ""
    isfirst 0
  ]
  node
  [
    id 9
    name ""
    isfirst 0
  ]
  node
  [
    id 10
    name ""
    isfirst 0
  ]
  edge
  [
    source 2
    target 1
    id 1
    name "FOO"
    isfirst 1
  ]
  edge
  [
    source 5
    target 1
    id 2
    name "FOOBAR"
    isfirst 0
  ]
  edge
  [
    source 6
    target 1
    id 3
    name ""
    isfirst 0
  ]
  edge
  [
    source 3
    target 2
    id 4
    name ""
    isfirst 0
  ]
  edge
  [
    source 7
    target 2
    id 5
    name ""
    isfirst 0
  ]
  edge
  [
    source 4
    target 3
    id 6
    name ""
    isfirst 0
  ]
  edge
  [
    source 8
    target 3
    id 7
    name ""
    isfirst 0
  ]
  edge
  [
    source 5
    target 4
    id 8
    name ""
    isfirst 0
  ]
  edge
  [
    source 9
    target 4
    id 9
    name ""
    isfirst 0
  ]
  edge
  [
    source 10
    target 5
    id 10
    name ""
    isfirst 0
  ]
  edge
  [
    source 8
    target 6
    id 11
    name ""
    isfirst 0
  ]
  edge
  [
    source 9
    target 6
    id 12
    name ""
    isfirst 0
  ]
  edge
  [
    source 9
    target 7
    id 13
    name ""
    isfirst 0
  ]
  edge
  [
    source 10
    target 7
    id 14
    name ""
    isfirst 0
  ]
  edge
  [
    source 10
    target 8
    id 15
    name ""
    isfirst 0
  ]
]



  
  
  
  
  
  
  
  
  
  
  
    Petersen's graph
    10
    15
    true
    
      1
      foo
      true
    
    
      2
      foobar
      false
    
    
      3
      
      false
    
    
      4
      
      false
    
    
      5
      
      false
    
    
      6
      
      false
    
    
      7
      
      false
    
    
      8
      
      false
    
    
      9
      
      false
    
    
      10
      
      false
    
    
      1
      FOO
      true
    
    
      2
      FOOBAR
      false
    
    
      3
      
      false
    
    
      4
      
      false
    
    
      5
      
      false
    
    
      6
      
      false
    
    
      7
      
      false
    
    
      8
      
      false
    
    
      9
      
      false
    
    
      10
      
      false
    
    
      11
      
      false
    
    
      12
      
      false
    
    
      13
      
      false
    
    
      14
      
      false
    
    
      15
      
      false
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes3.c0000644000175100001710000001534300000000000025547 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int mf(const igraph_vector_t *input, igraph_real_t *output) {
    *output = 0.0;
    return 0;
}

int main() {

    igraph_t g, g2;
    igraph_vector_t weight;
    igraph_attribute_combination_t comb;

    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 0, 1, 0, 1, 0, 1,
                 1, 2, 2, 3,
                 -1);

    igraph_vector_init_seq(&weight, 1, igraph_ecount(&g));
    SETEANV(&g, "weight", &weight);
    igraph_vector_destroy(&weight);

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_PROD,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_MIN,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_MAX,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_FIRST,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_LAST,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_MEAN,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_FUNCTION, mf,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_MEAN,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes3.out0000644000175100001710000001635700000000000026142 0ustar00runnerdocker00000000000000


  
  
    
    
    
    
    
    
    
    
    
      6
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      6
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      1
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      3
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      1
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      3
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      2
    
    
      4
    
    
      5
    
  




  
  
    
    
    
    
    
    
    
    
    
      0
    
    
      0
    
    
      0
    
  




  
  
    
    
    
    
    
    
    
    
    
      2
    
    
      4
    
    
      5
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes4.c0000644000175100001710000000613100000000000025543 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g, g2;
    igraph_attribute_combination_t comb;

    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 0, 1, 0, 1, 0, 1,
                 1, 2, 2, 3,
                 -1);

    SETEAS(&g, "color", 0, "green");
    SETEAS(&g, "color", 1, "red");
    SETEAS(&g, "color", 2, "blue");
    SETEAS(&g, "color", 3, "white");
    SETEAS(&g, "color", 4, "black");

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 "color",  IGRAPH_ATTRIBUTE_COMBINE_FIRST,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_LAST,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "color",  IGRAPH_ATTRIBUTE_COMBINE_CONCAT,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cattributes4.out0000644000175100001710000000470000000000000026130 0ustar00runnerdocker00000000000000


  
  
    
    
    
    
    
    
    
    
    
      green
    
    
      white
    
    
      black
    
  




  
  
    
    
    
    
    
    
    
    
    
      blue
    
    
      white
    
    
      black
    
  




  
  
    
    
    
    
    
    
    
    
    
      greenredblue
    
    
      green
    
    
      green
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/celegansneural.gml0000644000175100001710000043241400000000000026462 0ustar00runnerdocker00000000000000Creator "Mark Newman on Thu Aug 31 12:59:09 2006"
graph
[
  directed 1
  node
  [
    id 0
    label "1"
  ]
  node
  [
    id 1
    label "51"
  ]
  node
  [
    id 2
    label "72"
  ]
  node
  [
    id 3
    label "77"
  ]
  node
  [
    id 4
    label "78"
  ]
  node
  [
    id 5
    label "2"
  ]
  node
  [
    id 6
    label "90"
  ]
  node
  [
    id 7
    label "92"
  ]
  node
  [
    id 8
    label "158"
  ]
  node
  [
    id 9
    label "159"
  ]
  node
  [
    id 10
    label "113"
  ]
  node
  [
    id 11
    label "69"
  ]
  node
  [
    id 12
    label "71"
  ]
  node
  [
    id 13
    label "89"
  ]
  node
  [
    id 14
    label "91"
  ]
  node
  [
    id 15
    label "3"
  ]
  node
  [
    id 16
    label "47"
  ]
  node
  [
    id 17
    label "9"
  ]
  node
  [
    id 18
    label "17"
  ]
  node
  [
    id 19
    label "21"
  ]
  node
  [
    id 20
    label "93"
  ]
  node
  [
    id 21
    label "94"
  ]
  node
  [
    id 22
    label "23"
  ]
  node
  [
    id 23
    label "121"
  ]
  node
  [
    id 24
    label "125"
  ]
  node
  [
    id 25
    label "131"
  ]
  node
  [
    id 26
    label "31"
  ]
  node
  [
    id 27
    label "4"
  ]
  node
  [
    id 28
    label "60"
  ]
  node
  [
    id 29
    label "10"
  ]
  node
  [
    id 30
    label "16"
  ]
  node
  [
    id 31
    label "18"
  ]
  node
  [
    id 32
    label "22"
  ]
  node
  [
    id 33
    label "24"
  ]
  node
  [
    id 34
    label "97"
  ]
  node
  [
    id 35
    label "122"
  ]
  node
  [
    id 36
    label "126"
  ]
  node
  [
    id 37
    label "132"
  ]
  node
  [
    id 38
    label "32"
  ]
  node
  [
    id 39
    label "303"
  ]
  node
  [
    id 40
    label "5"
  ]
  node
  [
    id 41
    label "7"
  ]
  node
  [
    id 42
    label "222"
  ]
  node
  [
    id 43
    label "101"
  ]
  node
  [
    id 44
    label "305"
  ]
  node
  [
    id 45
    label "6"
  ]
  node
  [
    id 46
    label "102"
  ]
  node
  [
    id 47
    label "99"
  ]
  node
  [
    id 48
    label "100"
  ]
  node
  [
    id 49
    label "27"
  ]
  node
  [
    id 50
    label "8"
  ]
  node
  [
    id 51
    label "26"
  ]
  node
  [
    id 52
    label "44"
  ]
  node
  [
    id 53
    label "37"
  ]
  node
  [
    id 54
    label "11"
  ]
  node
  [
    id 55
    label "19"
  ]
  node
  [
    id 56
    label "29"
  ]
  node
  [
    id 57
    label "12"
  ]
  node
  [
    id 58
    label "41"
  ]
  node
  [
    id 59
    label "118"
  ]
  node
  [
    id 60
    label "25"
  ]
  node
  [
    id 61
    label "30"
  ]
  node
  [
    id 62
    label "13"
  ]
  node
  [
    id 63
    label "143"
  ]
  node
  [
    id 64
    label "28"
  ]
  node
  [
    id 65
    label "43"
  ]
  node
  [
    id 66
    label "14"
  ]
  node
  [
    id 67
    label "144"
  ]
  node
  [
    id 68
    label "20"
  ]
  node
  [
    id 69
    label "34"
  ]
  node
  [
    id 70
    label "15"
  ]
  node
  [
    id 71
    label "40"
  ]
  node
  [
    id 72
    label "128"
  ]
  node
  [
    id 73
    label "139"
  ]
  node
  [
    id 74
    label "140"
  ]
  node
  [
    id 75
    label "108"
  ]
  node
  [
    id 76
    label "35"
  ]
  node
  [
    id 77
    label "107"
  ]
  node
  [
    id 78
    label "133"
  ]
  node
  [
    id 79
    label "134"
  ]
  node
  [
    id 80
    label "105"
  ]
  node
  [
    id 81
    label "106"
  ]
  node
  [
    id 82
    label "36"
  ]
  node
  [
    id 83
    label "33"
  ]
  node
  [
    id 84
    label "73"
  ]
  node
  [
    id 85
    label "136"
  ]
  node
  [
    id 86
    label "74"
  ]
  node
  [
    id 87
    label "161"
  ]
  node
  [
    id 88
    label "129"
  ]
  node
  [
    id 89
    label "135"
  ]
  node
  [
    id 90
    label "120"
  ]
  node
  [
    id 91
    label "38"
  ]
  node
  [
    id 92
    label "39"
  ]
  node
  [
    id 93
    label "160"
  ]
  node
  [
    id 94
    label "130"
  ]
  node
  [
    id 95
    label "174"
  ]
  node
  [
    id 96
    label "42"
  ]
  node
  [
    id 97
    label "189"
  ]
  node
  [
    id 98
    label "82"
  ]
  node
  [
    id 99
    label "70"
  ]
  node
  [
    id 100
    label "45"
  ]
  node
  [
    id 101
    label "141"
  ]
  node
  [
    id 102
    label "55"
  ]
  node
  [
    id 103
    label "119"
  ]
  node
  [
    id 104
    label "137"
  ]
  node
  [
    id 105
    label "46"
  ]
  node
  [
    id 106
    label "142"
  ]
  node
  [
    id 107
    label "114"
  ]
  node
  [
    id 108
    label "56"
  ]
  node
  [
    id 109
    label "62"
  ]
  node
  [
    id 110
    label "86"
  ]
  node
  [
    id 111
    label "193"
  ]
  node
  [
    id 112
    label "138"
  ]
  node
  [
    id 113
    label "109"
  ]
  node
  [
    id 114
    label "52"
  ]
  node
  [
    id 115
    label "58"
  ]
  node
  [
    id 116
    label "61"
  ]
  node
  [
    id 117
    label "75"
  ]
  node
  [
    id 118
    label "76"
  ]
  node
  [
    id 119
    label "81"
  ]
  node
  [
    id 120
    label "85"
  ]
  node
  [
    id 121
    label "48"
  ]
  node
  [
    id 122
    label "110"
  ]
  node
  [
    id 123
    label "80"
  ]
  node
  [
    id 124
    label "88"
  ]
  node
  [
    id 125
    label "216"
  ]
  node
  [
    id 126
    label "49"
  ]
  node
  [
    id 127
    label "54"
  ]
  node
  [
    id 128
    label "50"
  ]
  node
  [
    id 129
    label "154"
  ]
  node
  [
    id 130
    label "96"
  ]
  node
  [
    id 131
    label "127"
  ]
  node
  [
    id 132
    label "95"
  ]
  node
  [
    id 133
    label "166"
  ]
  node
  [
    id 134
    label "53"
  ]
  node
  [
    id 135
    label "57"
  ]
  node
  [
    id 136
    label "63"
  ]
  node
  [
    id 137
    label "198"
  ]
  node
  [
    id 138
    label "87"
  ]
  node
  [
    id 139
    label "84"
  ]
  node
  [
    id 140
    label "59"
  ]
  node
  [
    id 141
    label "67"
  ]
  node
  [
    id 142
    label "178"
  ]
  node
  [
    id 143
    label "64"
  ]
  node
  [
    id 144
    label "65"
  ]
  node
  [
    id 145
    label "220"
  ]
  node
  [
    id 146
    label "66"
  ]
  node
  [
    id 147
    label "68"
  ]
  node
  [
    id 148
    label "221"
  ]
  node
  [
    id 149
    label "111"
  ]
  node
  [
    id 150
    label "112"
  ]
  node
  [
    id 151
    label "146"
  ]
  node
  [
    id 152
    label "225"
  ]
  node
  [
    id 153
    label "186"
  ]
  node
  [
    id 154
    label "226"
  ]
  node
  [
    id 155
    label "227"
  ]
  node
  [
    id 156
    label "228"
  ]
  node
  [
    id 157
    label "229"
  ]
  node
  [
    id 158
    label "230"
  ]
  node
  [
    id 159
    label "150"
  ]
  node
  [
    id 160
    label "234"
  ]
  node
  [
    id 161
    label "235"
  ]
  node
  [
    id 162
    label "236"
  ]
  node
  [
    id 163
    label "237"
  ]
  node
  [
    id 164
    label "238"
  ]
  node
  [
    id 165
    label "239"
  ]
  node
  [
    id 166
    label "187"
  ]
  node
  [
    id 167
    label "188"
  ]
  node
  [
    id 168
    label "240"
  ]
  node
  [
    id 169
    label "242"
  ]
  node
  [
    id 170
    label "203"
  ]
  node
  [
    id 171
    label "179"
  ]
  node
  [
    id 172
    label "217"
  ]
  node
  [
    id 173
    label "162"
  ]
  node
  [
    id 174
    label "164"
  ]
  node
  [
    id 175
    label "249"
  ]
  node
  [
    id 176
    label "250"
  ]
  node
  [
    id 177
    label "195"
  ]
  node
  [
    id 178
    label "251"
  ]
  node
  [
    id 179
    label "252"
  ]
  node
  [
    id 180
    label "253"
  ]
  node
  [
    id 181
    label "254"
  ]
  node
  [
    id 182
    label "255"
  ]
  node
  [
    id 183
    label "197"
  ]
  node
  [
    id 184
    label "204"
  ]
  node
  [
    id 185
    label "180"
  ]
  node
  [
    id 186
    label "163"
  ]
  node
  [
    id 187
    label "117"
  ]
  node
  [
    id 188
    label "256"
  ]
  node
  [
    id 189
    label "276"
  ]
  node
  [
    id 190
    label "306"
  ]
  node
  [
    id 191
    label "177"
  ]
  node
  [
    id 192
    label "241"
  ]
  node
  [
    id 193
    label "200"
  ]
  node
  [
    id 194
    label "215"
  ]
  node
  [
    id 195
    label "199"
  ]
  node
  [
    id 196
    label "165"
  ]
  node
  [
    id 197
    label "169"
  ]
  node
  [
    id 198
    label "79"
  ]
  node
  [
    id 199
    label "148"
  ]
  node
  [
    id 200
    label "168"
  ]
  node
  [
    id 201
    label "145"
  ]
  node
  [
    id 202
    label "147"
  ]
  node
  [
    id 203
    label "192"
  ]
  node
  [
    id 204
    label "219"
  ]
  node
  [
    id 205
    label "157"
  ]
  node
  [
    id 206
    label "172"
  ]
  node
  [
    id 207
    label "218"
  ]
  node
  [
    id 208
    label "83"
  ]
  node
  [
    id 209
    label "98"
  ]
  node
  [
    id 210
    label "124"
  ]
  node
  [
    id 211
    label "103"
  ]
  node
  [
    id 212
    label "104"
  ]
  node
  [
    id 213
    label "115"
  ]
  node
  [
    id 214
    label "123"
  ]
  node
  [
    id 215
    label "156"
  ]
  node
  [
    id 216
    label "170"
  ]
  node
  [
    id 217
    label "183"
  ]
  node
  [
    id 218
    label "116"
  ]
  node
  [
    id 219
    label "153"
  ]
  node
  [
    id 220
    label "224"
  ]
  node
  [
    id 221
    label "196"
  ]
  node
  [
    id 222
    label "214"
  ]
  node
  [
    id 223
    label "213"
  ]
  node
  [
    id 224
    label "155"
  ]
  node
  [
    id 225
    label "173"
  ]
  node
  [
    id 226
    label "149"
  ]
  node
  [
    id 227
    label "275"
  ]
  node
  [
    id 228
    label "205"
  ]
  node
  [
    id 229
    label "206"
  ]
  node
  [
    id 230
    label "151"
  ]
  node
  [
    id 231
    label "277"
  ]
  node
  [
    id 232
    label "152"
  ]
  node
  [
    id 233
    label "245"
  ]
  node
  [
    id 234
    label "278"
  ]
  node
  [
    id 235
    label "201"
  ]
  node
  [
    id 236
    label "202"
  ]
  node
  [
    id 237
    label "167"
  ]
  node
  [
    id 238
    label "269"
  ]
  node
  [
    id 239
    label "184"
  ]
  node
  [
    id 240
    label "171"
  ]
  node
  [
    id 241
    label "185"
  ]
  node
  [
    id 242
    label "175"
  ]
  node
  [
    id 243
    label "176"
  ]
  node
  [
    id 244
    label "272"
  ]
  node
  [
    id 245
    label "270"
  ]
  node
  [
    id 246
    label "258"
  ]
  node
  [
    id 247
    label "181"
  ]
  node
  [
    id 248
    label "182"
  ]
  node
  [
    id 249
    label "274"
  ]
  node
  [
    id 250
    label "190"
  ]
  node
  [
    id 251
    label "191"
  ]
  node
  [
    id 252
    label "194"
  ]
  node
  [
    id 253
    label "244"
  ]
  node
  [
    id 254
    label "260"
  ]
  node
  [
    id 255
    label "207"
  ]
  node
  [
    id 256
    label "223"
  ]
  node
  [
    id 257
    label "208"
  ]
  node
  [
    id 258
    label "209"
  ]
  node
  [
    id 259
    label "210"
  ]
  node
  [
    id 260
    label "211"
  ]
  node
  [
    id 261
    label "212"
  ]
  node
  [
    id 262
    label "261"
  ]
  node
  [
    id 263
    label "262"
  ]
  node
  [
    id 264
    label "263"
  ]
  node
  [
    id 265
    label "264"
  ]
  node
  [
    id 266
    label "265"
  ]
  node
  [
    id 267
    label "266"
  ]
  node
  [
    id 268
    label "282"
  ]
  node
  [
    id 269
    label "279"
  ]
  node
  [
    id 270
    label "231"
  ]
  node
  [
    id 271
    label "280"
  ]
  node
  [
    id 272
    label "232"
  ]
  node
  [
    id 273
    label "281"
  ]
  node
  [
    id 274
    label "233"
  ]
  node
  [
    id 275
    label "246"
  ]
  node
  [
    id 276
    label "247"
  ]
  node
  [
    id 277
    label "248"
  ]
  node
  [
    id 278
    label "243"
  ]
  node
  [
    id 279
    label "257"
  ]
  node
  [
    id 280
    label "259"
  ]
  node
  [
    id 281
    label "267"
  ]
  node
  [
    id 282
    label "268"
  ]
  node
  [
    id 283
    label "271"
  ]
  node
  [
    id 284
    label "273"
  ]
  node
  [
    id 285
    label "291"
  ]
  node
  [
    id 286
    label "292"
  ]
  node
  [
    id 287
    label "293"
  ]
  node
  [
    id 288
    label "294"
  ]
  node
  [
    id 289
    label "295"
  ]
  node
  [
    id 290
    label "296"
  ]
  node
  [
    id 291
    label "297"
  ]
  node
  [
    id 292
    label "298"
  ]
  node
  [
    id 293
    label "299"
  ]
  node
  [
    id 294
    label "300"
  ]
  node
  [
    id 295
    label "301"
  ]
  node
  [
    id 296
    label "302"
  ]
  edge
  [
    source 0
    target 1
    value 1
  ]
  edge
  [
    source 0
    target 2
    value 2
  ]
  edge
  [
    source 0
    target 3
    value 1
  ]
  edge
  [
    source 0
    target 4
    value 2
  ]
  edge
  [
    source 0
    target 5
    value 1
  ]
  edge
  [
    source 0
    target 6
    value 6
  ]
  edge
  [
    source 0
    target 7
    value 6
  ]
  edge
  [
    source 0
    target 8
    value 1
  ]
  edge
  [
    source 0
    target 9
    value 4
  ]
  edge
  [
    source 1
    target 10
    value 1
  ]
  edge
  [
    source 1
    target 115
    value 1
  ]
  edge
  [
    source 1
    target 12
    value 2
  ]
  edge
  [
    source 1
    target 84
    value 3
  ]
  edge
  [
    source 1
    target 129
    value 1
  ]
  edge
  [
    source 1
    target 7
    value 2
  ]
  edge
  [
    source 1
    target 130
    value 12
  ]
  edge
  [
    source 1
    target 131
    value 1
  ]
  edge
  [
    source 1
    target 72
    value 2
  ]
  edge
  [
    source 1
    target 74
    value 1
  ]
  edge
  [
    source 2
    target 67
    value 1
  ]
  edge
  [
    source 2
    target 151
    value 1
  ]
  edge
  [
    source 2
    target 152
    value 4
  ]
  edge
  [
    source 2
    target 153
    value 9
  ]
  edge
  [
    source 2
    target 154
    value 3
  ]
  edge
  [
    source 2
    target 155
    value 2
  ]
  edge
  [
    source 2
    target 156
    value 2
  ]
  edge
  [
    source 2
    target 157
    value 4
  ]
  edge
  [
    source 2
    target 158
    value 2
  ]
  edge
  [
    source 2
    target 12
    value 3
  ]
  edge
  [
    source 2
    target 86
    value 2
  ]
  edge
  [
    source 2
    target 118
    value 2
  ]
  edge
  [
    source 2
    target 4
    value 4
  ]
  edge
  [
    source 2
    target 159
    value 4
  ]
  edge
  [
    source 2
    target 160
    value 4
  ]
  edge
  [
    source 2
    target 161
    value 9
  ]
  edge
  [
    source 2
    target 162
    value 12
  ]
  edge
  [
    source 2
    target 163
    value 9
  ]
  edge
  [
    source 2
    target 164
    value 2
  ]
  edge
  [
    source 2
    target 165
    value 7
  ]
  edge
  [
    source 2
    target 166
    value 14
  ]
  edge
  [
    source 2
    target 167
    value 5
  ]
  edge
  [
    source 2
    target 168
    value 2
  ]
  edge
  [
    source 2
    target 169
    value 2
  ]
  edge
  [
    source 2
    target 184
    value 5
  ]
  edge
  [
    source 2
    target 185
    value 2
  ]
  edge
  [
    source 2
    target 125
    value 28
  ]
  edge
  [
    source 2
    target 8
    value 1
  ]
  edge
  [
    source 2
    target 173
    value 1
  ]
  edge
  [
    source 2
    target 186
    value 2
  ]
  edge
  [
    source 2
    target 175
    value 10
  ]
  edge
  [
    source 2
    target 176
    value 14
  ]
  edge
  [
    source 2
    target 177
    value 2
  ]
  edge
  [
    source 2
    target 178
    value 3
  ]
  edge
  [
    source 2
    target 179
    value 4
  ]
  edge
  [
    source 2
    target 180
    value 4
  ]
  edge
  [
    source 2
    target 181
    value 6
  ]
  edge
  [
    source 2
    target 182
    value 4
  ]
  edge
  [
    source 2
    target 183
    value 2
  ]
  edge
  [
    source 3
    target 151
    value 5
  ]
  edge
  [
    source 3
    target 154
    value 2
  ]
  edge
  [
    source 3
    target 155
    value 1
  ]
  edge
  [
    source 3
    target 12
    value 44
  ]
  edge
  [
    source 3
    target 117
    value 1
  ]
  edge
  [
    source 3
    target 159
    value 12
  ]
  edge
  [
    source 3
    target 160
    value 6
  ]
  edge
  [
    source 3
    target 161
    value 4
  ]
  edge
  [
    source 3
    target 162
    value 1
  ]
  edge
  [
    source 3
    target 168
    value 2
  ]
  edge
  [
    source 3
    target 195
    value 1
  ]
  edge
  [
    source 3
    target 125
    value 1
  ]
  edge
  [
    source 3
    target 173
    value 8
  ]
  edge
  [
    source 3
    target 186
    value 17
  ]
  edge
  [
    source 3
    target 196
    value 6
  ]
  edge
  [
    source 3
    target 178
    value 2
  ]
  edge
  [
    source 3
    target 179
    value 5
  ]
  edge
  [
    source 3
    target 180
    value 1
  ]
  edge
  [
    source 3
    target 182
    value 1
  ]
  edge
  [
    source 3
    target 197
    value 1
  ]
  edge
  [
    source 3
    target 189
    value 1
  ]
  edge
  [
    source 4
    target 151
    value 5
  ]
  edge
  [
    source 4
    target 154
    value 2
  ]
  edge
  [
    source 4
    target 155
    value 1
  ]
  edge
  [
    source 4
    target 2
    value 44
  ]
  edge
  [
    source 4
    target 118
    value 1
  ]
  edge
  [
    source 4
    target 159
    value 12
  ]
  edge
  [
    source 4
    target 160
    value 6
  ]
  edge
  [
    source 4
    target 161
    value 4
  ]
  edge
  [
    source 4
    target 162
    value 1
  ]
  edge
  [
    source 4
    target 168
    value 2
  ]
  edge
  [
    source 4
    target 195
    value 1
  ]
  edge
  [
    source 4
    target 172
    value 1
  ]
  edge
  [
    source 4
    target 173
    value 8
  ]
  edge
  [
    source 4
    target 174
    value 17
  ]
  edge
  [
    source 4
    target 196
    value 6
  ]
  edge
  [
    source 4
    target 178
    value 2
  ]
  edge
  [
    source 4
    target 179
    value 5
  ]
  edge
  [
    source 4
    target 180
    value 1
  ]
  edge
  [
    source 4
    target 182
    value 1
  ]
  edge
  [
    source 4
    target 197
    value 1
  ]
  edge
  [
    source 4
    target 189
    value 1
  ]
  edge
  [
    source 5
    target 10
    value 1
  ]
  edge
  [
    source 5
    target 11
    value 1
  ]
  edge
  [
    source 5
    target 12
    value 3
  ]
  edge
  [
    source 5
    target 3
    value 4
  ]
  edge
  [
    source 5
    target 13
    value 4
  ]
  edge
  [
    source 5
    target 14
    value 4
  ]
  edge
  [
    source 5
    target 8
    value 7
  ]
  edge
  [
    source 6
    target 27
    value 1
  ]
  edge
  [
    source 6
    target 50
    value 1
  ]
  edge
  [
    source 6
    target 34
    value 2
  ]
  edge
  [
    source 6
    target 23
    value 12
  ]
  edge
  [
    source 6
    target 35
    value 8
  ]
  edge
  [
    source 6
    target 47
    value 5
  ]
  edge
  [
    source 6
    target 48
    value 7
  ]
  edge
  [
    source 6
    target 43
    value 4
  ]
  edge
  [
    source 6
    target 46
    value 9
  ]
  edge
  [
    source 6
    target 72
    value 1
  ]
  edge
  [
    source 6
    target 88
    value 1
  ]
  edge
  [
    source 6
    target 94
    value 1
  ]
  edge
  [
    source 6
    target 25
    value 1
  ]
  edge
  [
    source 6
    target 73
    value 6
  ]
  edge
  [
    source 6
    target 74
    value 10
  ]
  edge
  [
    source 6
    target 77
    value 13
  ]
  edge
  [
    source 6
    target 75
    value 7
  ]
  edge
  [
    source 7
    target 1
    value 1
  ]
  edge
  [
    source 7
    target 2
    value 2
  ]
  edge
  [
    source 7
    target 3
    value 4
  ]
  edge
  [
    source 7
    target 6
    value 2
  ]
  edge
  [
    source 7
    target 59
    value 1
  ]
  edge
  [
    source 7
    target 73
    value 1
  ]
  edge
  [
    source 8
    target 102
    value 2
  ]
  edge
  [
    source 8
    target 108
    value 1
  ]
  edge
  [
    source 8
    target 235
    value 1
  ]
  edge
  [
    source 8
    target 3
    value 1
  ]
  edge
  [
    source 8
    target 4
    value 2
  ]
  edge
  [
    source 8
    target 213
    value 1
  ]
  edge
  [
    source 8
    target 5
    value 2
  ]
  edge
  [
    source 8
    target 193
    value 1
  ]
  edge
  [
    source 8
    target 14
    value 1
  ]
  edge
  [
    source 8
    target 103
    value 2
  ]
  edge
  [
    source 8
    target 214
    value 1
  ]
  edge
  [
    source 8
    target 36
    value 3
  ]
  edge
  [
    source 9
    target 108
    value 2
  ]
  edge
  [
    source 9
    target 236
    value 1
  ]
  edge
  [
    source 9
    target 4
    value 2
  ]
  edge
  [
    source 9
    target 213
    value 4
  ]
  edge
  [
    source 9
    target 218
    value 1
  ]
  edge
  [
    source 9
    target 5
    value 1
  ]
  edge
  [
    source 9
    target 7
    value 1
  ]
  edge
  [
    source 9
    target 103
    value 1
  ]
  edge
  [
    source 9
    target 24
    value 4
  ]
  edge
  [
    source 10
    target 102
    value 13
  ]
  edge
  [
    source 10
    target 208
    value 3
  ]
  edge
  [
    source 10
    target 138
    value 1
  ]
  edge
  [
    source 10
    target 124
    value 1
  ]
  edge
  [
    source 10
    target 142
    value 1
  ]
  edge
  [
    source 10
    target 13
    value 5
  ]
  edge
  [
    source 10
    target 14
    value 5
  ]
  edge
  [
    source 11
    target 12
    value 2
  ]
  edge
  [
    source 11
    target 118
    value 1
  ]
  edge
  [
    source 11
    target 3
    value 4
  ]
  edge
  [
    source 11
    target 13
    value 6
  ]
  edge
  [
    source 11
    target 14
    value 9
  ]
  edge
  [
    source 12
    target 16
    value 1
  ]
  edge
  [
    source 12
    target 151
    value 1
  ]
  edge
  [
    source 12
    target 152
    value 4
  ]
  edge
  [
    source 12
    target 153
    value 9
  ]
  edge
  [
    source 12
    target 154
    value 3
  ]
  edge
  [
    source 12
    target 155
    value 2
  ]
  edge
  [
    source 12
    target 156
    value 2
  ]
  edge
  [
    source 12
    target 157
    value 4
  ]
  edge
  [
    source 12
    target 158
    value 2
  ]
  edge
  [
    source 12
    target 2
    value 3
  ]
  edge
  [
    source 12
    target 84
    value 2
  ]
  edge
  [
    source 12
    target 117
    value 2
  ]
  edge
  [
    source 12
    target 3
    value 4
  ]
  edge
  [
    source 12
    target 159
    value 4
  ]
  edge
  [
    source 12
    target 160
    value 4
  ]
  edge
  [
    source 12
    target 161
    value 9
  ]
  edge
  [
    source 12
    target 162
    value 12
  ]
  edge
  [
    source 12
    target 163
    value 9
  ]
  edge
  [
    source 12
    target 164
    value 2
  ]
  edge
  [
    source 12
    target 165
    value 7
  ]
  edge
  [
    source 12
    target 166
    value 14
  ]
  edge
  [
    source 12
    target 167
    value 5
  ]
  edge
  [
    source 12
    target 168
    value 1
  ]
  edge
  [
    source 12
    target 168
    value 2
  ]
  edge
  [
    source 12
    target 169
    value 2
  ]
  edge
  [
    source 12
    target 170
    value 5
  ]
  edge
  [
    source 12
    target 171
    value 2
  ]
  edge
  [
    source 12
    target 172
    value 28
  ]
  edge
  [
    source 12
    target 173
    value 1
  ]
  edge
  [
    source 12
    target 174
    value 2
  ]
  edge
  [
    source 12
    target 175
    value 10
  ]
  edge
  [
    source 12
    target 176
    value 14
  ]
  edge
  [
    source 12
    target 177
    value 2
  ]
  edge
  [
    source 12
    target 178
    value 3
  ]
  edge
  [
    source 12
    target 179
    value 4
  ]
  edge
  [
    source 12
    target 180
    value 4
  ]
  edge
  [
    source 12
    target 181
    value 6
  ]
  edge
  [
    source 12
    target 182
    value 4
  ]
  edge
  [
    source 12
    target 183
    value 2
  ]
  edge
  [
    source 13
    target 6
    value 1
  ]
  edge
  [
    source 13
    target 34
    value 2
  ]
  edge
  [
    source 13
    target 209
    value 3
  ]
  edge
  [
    source 13
    target 23
    value 10
  ]
  edge
  [
    source 13
    target 35
    value 6
  ]
  edge
  [
    source 13
    target 47
    value 6
  ]
  edge
  [
    source 13
    target 48
    value 5
  ]
  edge
  [
    source 13
    target 43
    value 7
  ]
  edge
  [
    source 13
    target 46
    value 10
  ]
  edge
  [
    source 13
    target 88
    value 1
  ]
  edge
  [
    source 13
    target 73
    value 9
  ]
  edge
  [
    source 13
    target 74
    value 8
  ]
  edge
  [
    source 13
    target 77
    value 3
  ]
  edge
  [
    source 13
    target 75
    value 12
  ]
  edge
  [
    source 14
    target 114
    value 1
  ]
  edge
  [
    source 14
    target 11
    value 1
  ]
  edge
  [
    source 14
    target 12
    value 1
  ]
  edge
  [
    source 14
    target 86
    value 1
  ]
  edge
  [
    source 14
    target 118
    value 1
  ]
  edge
  [
    source 14
    target 3
    value 2
  ]
  edge
  [
    source 14
    target 4
    value 5
  ]
  edge
  [
    source 14
    target 13
    value 3
  ]
  edge
  [
    source 14
    target 75
    value 2
  ]
  edge
  [
    source 15
    target 16
    value 1
  ]
  edge
  [
    source 15
    target 4
    value 3
  ]
  edge
  [
    source 15
    target 17
    value 2
  ]
  edge
  [
    source 15
    target 18
    value 4
  ]
  edge
  [
    source 15
    target 19
    value 5
  ]
  edge
  [
    source 15
    target 20
    value 6
  ]
  edge
  [
    source 15
    target 21
    value 4
  ]
  edge
  [
    source 15
    target 22
    value 1
  ]
  edge
  [
    source 15
    target 23
    value 3
  ]
  edge
  [
    source 15
    target 24
    value 1
  ]
  edge
  [
    source 15
    target 25
    value 2
  ]
  edge
  [
    source 15
    target 26
    value 2
  ]
  edge
  [
    source 16
    target 113
    value 5
  ]
  edge
  [
    source 16
    target 1
    value 6
  ]
  edge
  [
    source 16
    target 114
    value 1
  ]
  edge
  [
    source 16
    target 92
    value 1
  ]
  edge
  [
    source 16
    target 115
    value 3
  ]
  edge
  [
    source 16
    target 116
    value 2
  ]
  edge
  [
    source 16
    target 12
    value 2
  ]
  edge
  [
    source 16
    target 2
    value 4
  ]
  edge
  [
    source 16
    target 84
    value 1
  ]
  edge
  [
    source 16
    target 117
    value 1
  ]
  edge
  [
    source 16
    target 118
    value 4
  ]
  edge
  [
    source 16
    target 119
    value 1
  ]
  edge
  [
    source 16
    target 98
    value 2
  ]
  edge
  [
    source 16
    target 120
    value 2
  ]
  edge
  [
    source 16
    target 19
    value 1
  ]
  edge
  [
    source 16
    target 22
    value 1
  ]
  edge
  [
    source 16
    target 73
    value 2
  ]
  edge
  [
    source 17
    target 41
    value 1
  ]
  edge
  [
    source 17
    target 22
    value 7
  ]
  edge
  [
    source 17
    target 23
    value 11
  ]
  edge
  [
    source 17
    target 53
    value 1
  ]
  edge
  [
    source 17
    target 44
    value 10
  ]
  edge
  [
    source 18
    target 4
    value 19
  ]
  edge
  [
    source 18
    target 71
    value 2
  ]
  edge
  [
    source 18
    target 15
    value 2
  ]
  edge
  [
    source 18
    target 17
    value 1
  ]
  edge
  [
    source 18
    target 14
    value 7
  ]
  edge
  [
    source 18
    target 23
    value 7
  ]
  edge
  [
    source 18
    target 35
    value 1
  ]
  edge
  [
    source 18
    target 47
    value 2
  ]
  edge
  [
    source 18
    target 43
    value 1
  ]
  edge
  [
    source 18
    target 51
    value 2
  ]
  edge
  [
    source 18
    target 72
    value 1
  ]
  edge
  [
    source 18
    target 73
    value 3
  ]
  edge
  [
    source 18
    target 74
    value 4
  ]
  edge
  [
    source 18
    target 75
    value 4
  ]
  edge
  [
    source 18
    target 76
    value 1
  ]
  edge
  [
    source 19
    target 17
    value 2
  ]
  edge
  [
    source 19
    target 70
    value 1
  ]
  edge
  [
    source 19
    target 20
    value 1
  ]
  edge
  [
    source 19
    target 59
    value 2
  ]
  edge
  [
    source 19
    target 22
    value 2
  ]
  edge
  [
    source 19
    target 46
    value 4
  ]
  edge
  [
    source 19
    target 80
    value 3
  ]
  edge
  [
    source 20
    target 12
    value 5
  ]
  edge
  [
    source 20
    target 2
    value 6
  ]
  edge
  [
    source 20
    target 132
    value 1
  ]
  edge
  [
    source 20
    target 130
    value 2
  ]
  edge
  [
    source 20
    target 209
    value 1
  ]
  edge
  [
    source 20
    target 210
    value 1
  ]
  edge
  [
    source 20
    target 89
    value 2
  ]
  edge
  [
    source 20
    target 73
    value 3
  ]
  edge
  [
    source 20
    target 74
    value 4
  ]
  edge
  [
    source 20
    target 75
    value 1
  ]
  edge
  [
    source 21
    target 106
    value 1
  ]
  edge
  [
    source 21
    target 12
    value 5
  ]
  edge
  [
    source 21
    target 2
    value 3
  ]
  edge
  [
    source 21
    target 85
    value 1
  ]
  edge
  [
    source 21
    target 73
    value 2
  ]
  edge
  [
    source 21
    target 74
    value 3
  ]
  edge
  [
    source 21
    target 77
    value 2
  ]
  edge
  [
    source 21
    target 75
    value 1
  ]
  edge
  [
    source 22
    target 55
    value 2
  ]
  edge
  [
    source 23
    target 46
    value 7
  ]
  edge
  [
    source 23
    target 44
    value 8
  ]
  edge
  [
    source 24
    target 48
    value 1
  ]
  edge
  [
    source 24
    target 44
    value 8
  ]
  edge
  [
    source 25
    target 190
    value 1
  ]
  edge
  [
    source 26
    target 22
    value 3
  ]
  edge
  [
    source 26
    target 51
    value 1
  ]
  edge
  [
    source 26
    target 49
    value 1
  ]
  edge
  [
    source 26
    target 64
    value 2
  ]
  edge
  [
    source 26
    target 44
    value 9
  ]
  edge
  [
    source 27
    target 28
    value 1
  ]
  edge
  [
    source 27
    target 3
    value 4
  ]
  edge
  [
    source 27
    target 29
    value 2
  ]
  edge
  [
    source 27
    target 30
    value 1
  ]
  edge
  [
    source 27
    target 31
    value 5
  ]
  edge
  [
    source 27
    target 32
    value 3
  ]
  edge
  [
    source 27
    target 20
    value 2
  ]
  edge
  [
    source 27
    target 21
    value 4
  ]
  edge
  [
    source 27
    target 33
    value 1
  ]
  edge
  [
    source 27
    target 34
    value 1
  ]
  edge
  [
    source 27
    target 35
    value 2
  ]
  edge
  [
    source 27
    target 36
    value 2
  ]
  edge
  [
    source 27
    target 37
    value 2
  ]
  edge
  [
    source 27
    target 38
    value 1
  ]
  edge
  [
    source 27
    target 39
    value 1
  ]
  edge
  [
    source 28
    target 122
    value 10
  ]
  edge
  [
    source 28
    target 114
    value 2
  ]
  edge
  [
    source 29
    target 50
    value 1
  ]
  edge
  [
    source 29
    target 30
    value 1
  ]
  edge
  [
    source 29
    target 33
    value 8
  ]
  edge
  [
    source 29
    target 35
    value 11
  ]
  edge
  [
    source 29
    target 44
    value 10
  ]
  edge
  [
    source 30
    target 29
    value 5
  ]
  edge
  [
    source 30
    target 32
    value 2
  ]
  edge
  [
    source 30
    target 6
    value 2
  ]
  edge
  [
    source 30
    target 59
    value 4
  ]
  edge
  [
    source 30
    target 33
    value 14
  ]
  edge
  [
    source 30
    target 51
    value 3
  ]
  edge
  [
    source 30
    target 49
    value 2
  ]
  edge
  [
    source 30
    target 64
    value 3
  ]
  edge
  [
    source 30
    target 38
    value 3
  ]
  edge
  [
    source 30
    target 52
    value 1
  ]
  edge
  [
    source 31
    target 3
    value 14
  ]
  edge
  [
    source 31
    target 4
    value 1
  ]
  edge
  [
    source 31
    target 58
    value 2
  ]
  edge
  [
    source 31
    target 27
    value 6
  ]
  edge
  [
    source 31
    target 45
    value 3
  ]
  edge
  [
    source 31
    target 29
    value 1
  ]
  edge
  [
    source 31
    target 66
    value 1
  ]
  edge
  [
    source 31
    target 7
    value 10
  ]
  edge
  [
    source 31
    target 35
    value 10
  ]
  edge
  [
    source 31
    target 47
    value 2
  ]
  edge
  [
    source 31
    target 48
    value 1
  ]
  edge
  [
    source 31
    target 46
    value 3
  ]
  edge
  [
    source 31
    target 49
    value 2
  ]
  edge
  [
    source 31
    target 73
    value 1
  ]
  edge
  [
    source 31
    target 74
    value 1
  ]
  edge
  [
    source 31
    target 77
    value 3
  ]
  edge
  [
    source 31
    target 75
    value 3
  ]
  edge
  [
    source 32
    target 29
    value 1
  ]
  edge
  [
    source 32
    target 30
    value 1
  ]
  edge
  [
    source 32
    target 21
    value 1
  ]
  edge
  [
    source 32
    target 59
    value 1
  ]
  edge
  [
    source 32
    target 33
    value 1
  ]
  edge
  [
    source 32
    target 43
    value 3
  ]
  edge
  [
    source 32
    target 49
    value 1
  ]
  edge
  [
    source 32
    target 81
    value 3
  ]
  edge
  [
    source 33
    target 68
    value 2
  ]
  edge
  [
    source 34
    target 13
    value 1
  ]
  edge
  [
    source 34
    target 6
    value 1
  ]
  edge
  [
    source 34
    target 47
    value 2
  ]
  edge
  [
    source 34
    target 43
    value 1
  ]
  edge
  [
    source 34
    target 72
    value 3
  ]
  edge
  [
    source 34
    target 37
    value 3
  ]
  edge
  [
    source 34
    target 112
    value 1
  ]
  edge
  [
    source 34
    target 74
    value 1
  ]
  edge
  [
    source 34
    target 44
    value 4
  ]
  edge
  [
    source 35
    target 43
    value 10
  ]
  edge
  [
    source 35
    target 44
    value 10
  ]
  edge
  [
    source 36
    target 49
    value 1
  ]
  edge
  [
    source 36
    target 93
    value 1
  ]
  edge
  [
    source 36
    target 44
    value 7
  ]
  edge
  [
    source 37
    target 190
    value 1
  ]
  edge
  [
    source 38
    target 50
    value 1
  ]
  edge
  [
    source 38
    target 33
    value 4
  ]
  edge
  [
    source 38
    target 43
    value 1
  ]
  edge
  [
    source 38
    target 49
    value 2
  ]
  edge
  [
    source 38
    target 64
    value 2
  ]
  edge
  [
    source 38
    target 44
    value 9
  ]
  edge
  [
    source 40
    target 41
    value 1
  ]
  edge
  [
    source 40
    target 42
    value 1
  ]
  edge
  [
    source 40
    target 22
    value 3
  ]
  edge
  [
    source 40
    target 43
    value 6
  ]
  edge
  [
    source 40
    target 44
    value 4
  ]
  edge
  [
    source 41
    target 4
    value 2
  ]
  edge
  [
    source 41
    target 40
    value 1
  ]
  edge
  [
    source 41
    target 23
    value 3
  ]
  edge
  [
    source 41
    target 47
    value 1
  ]
  edge
  [
    source 41
    target 48
    value 3
  ]
  edge
  [
    source 41
    target 43
    value 4
  ]
  edge
  [
    source 41
    target 46
    value 2
  ]
  edge
  [
    source 41
    target 49
    value 1
  ]
  edge
  [
    source 41
    target 44
    value 10
  ]
  edge
  [
    source 42
    target 84
    value 4
  ]
  edge
  [
    source 42
    target 86
    value 3
  ]
  edge
  [
    source 42
    target 119
    value 2
  ]
  edge
  [
    source 42
    target 98
    value 2
  ]
  edge
  [
    source 42
    target 218
    value 1
  ]
  edge
  [
    source 42
    target 167
    value 1
  ]
  edge
  [
    source 42
    target 232
    value 1
  ]
  edge
  [
    source 42
    target 168
    value 1
  ]
  edge
  [
    source 42
    target 137
    value 1
  ]
  edge
  [
    source 42
    target 40
    value 1
  ]
  edge
  [
    source 42
    target 45
    value 1
  ]
  edge
  [
    source 42
    target 17
    value 1
  ]
  edge
  [
    source 42
    target 29
    value 1
  ]
  edge
  [
    source 42
    target 185
    value 1
  ]
  edge
  [
    source 42
    target 172
    value 1
  ]
  edge
  [
    source 42
    target 22
    value 4
  ]
  edge
  [
    source 42
    target 33
    value 3
  ]
  edge
  [
    source 42
    target 173
    value 1
  ]
  edge
  [
    source 43
    target 6
    value 1
  ]
  edge
  [
    source 43
    target 23
    value 1
  ]
  edge
  [
    source 43
    target 35
    value 6
  ]
  edge
  [
    source 43
    target 44
    value 7
  ]
  edge
  [
    source 45
    target 33
    value 7
  ]
  edge
  [
    source 45
    target 46
    value 8
  ]
  edge
  [
    source 45
    target 44
    value 8
  ]
  edge
  [
    source 46
    target 23
    value 10
  ]
  edge
  [
    source 46
    target 79
    value 1
  ]
  edge
  [
    source 46
    target 44
    value 9
  ]
  edge
  [
    source 47
    target 31
    value 1
  ]
  edge
  [
    source 47
    target 13
    value 5
  ]
  edge
  [
    source 47
    target 6
    value 3
  ]
  edge
  [
    source 47
    target 35
    value 1
  ]
  edge
  [
    source 47
    target 48
    value 2
  ]
  edge
  [
    source 47
    target 214
    value 1
  ]
  edge
  [
    source 47
    target 44
    value 11
  ]
  edge
  [
    source 48
    target 213
    value 1
  ]
  edge
  [
    source 48
    target 13
    value 5
  ]
  edge
  [
    source 48
    target 6
    value 7
  ]
  edge
  [
    source 48
    target 23
    value 1
  ]
  edge
  [
    source 48
    target 47
    value 1
  ]
  edge
  [
    source 48
    target 44
    value 4
  ]
  edge
  [
    source 49
    target 44
    value 14
  ]
  edge
  [
    source 50
    target 3
    value 1
  ]
  edge
  [
    source 50
    target 45
    value 1
  ]
  edge
  [
    source 50
    target 23
    value 3
  ]
  edge
  [
    source 50
    target 35
    value 4
  ]
  edge
  [
    source 50
    target 47
    value 4
  ]
  edge
  [
    source 50
    target 48
    value 1
  ]
  edge
  [
    source 50
    target 43
    value 1
  ]
  edge
  [
    source 50
    target 46
    value 4
  ]
  edge
  [
    source 50
    target 51
    value 2
  ]
  edge
  [
    source 50
    target 52
    value 1
  ]
  edge
  [
    source 50
    target 44
    value 12
  ]
  edge
  [
    source 51
    target 44
    value 11
  ]
  edge
  [
    source 52
    target 99
    value 4
  ]
  edge
  [
    source 52
    target 84
    value 1
  ]
  edge
  [
    source 52
    target 86
    value 1
  ]
  edge
  [
    source 52
    target 4
    value 1
  ]
  edge
  [
    source 52
    target 32
    value 1
  ]
  edge
  [
    source 52
    target 6
    value 4
  ]
  edge
  [
    source 52
    target 21
    value 1
  ]
  edge
  [
    source 52
    target 9
    value 2
  ]
  edge
  [
    source 52
    target 33
    value 3
  ]
  edge
  [
    source 52
    target 48
    value 1
  ]
  edge
  [
    source 52
    target 37
    value 1
  ]
  edge
  [
    source 53
    target 86
    value 1
  ]
  edge
  [
    source 53
    target 4
    value 5
  ]
  edge
  [
    source 53
    target 17
    value 1
  ]
  edge
  [
    source 53
    target 13
    value 1
  ]
  edge
  [
    source 53
    target 14
    value 2
  ]
  edge
  [
    source 53
    target 59
    value 1
  ]
  edge
  [
    source 53
    target 90
    value 1
  ]
  edge
  [
    source 53
    target 23
    value 4
  ]
  edge
  [
    source 53
    target 46
    value 2
  ]
  edge
  [
    source 53
    target 78
    value 1
  ]
  edge
  [
    source 53
    target 75
    value 4
  ]
  edge
  [
    source 54
    target 11
    value 1
  ]
  edge
  [
    source 54
    target 40
    value 7
  ]
  edge
  [
    source 54
    target 55
    value 2
  ]
  edge
  [
    source 54
    target 14
    value 1
  ]
  edge
  [
    source 54
    target 22
    value 9
  ]
  edge
  [
    source 54
    target 51
    value 4
  ]
  edge
  [
    source 54
    target 49
    value 4
  ]
  edge
  [
    source 54
    target 56
    value 3
  ]
  edge
  [
    source 55
    target 21
    value 1
  ]
  edge
  [
    source 55
    target 35
    value 4
  ]
  edge
  [
    source 55
    target 78
    value 3
  ]
  edge
  [
    source 56
    target 40
    value 2
  ]
  edge
  [
    source 56
    target 22
    value 3
  ]
  edge
  [
    source 56
    target 35
    value 1
  ]
  edge
  [
    source 56
    target 51
    value 1
  ]
  edge
  [
    source 56
    target 44
    value 6
  ]
  edge
  [
    source 57
    target 58
    value 1
  ]
  edge
  [
    source 57
    target 45
    value 7
  ]
  edge
  [
    source 57
    target 21
    value 1
  ]
  edge
  [
    source 57
    target 59
    value 1
  ]
  edge
  [
    source 57
    target 33
    value 12
  ]
  edge
  [
    source 57
    target 60
    value 1
  ]
  edge
  [
    source 57
    target 51
    value 3
  ]
  edge
  [
    source 57
    target 49
    value 2
  ]
  edge
  [
    source 57
    target 61
    value 3
  ]
  edge
  [
    source 58
    target 3
    value 5
  ]
  edge
  [
    source 58
    target 95
    value 1
  ]
  edge
  [
    source 58
    target 45
    value 5
  ]
  edge
  [
    source 58
    target 50
    value 1
  ]
  edge
  [
    source 58
    target 31
    value 6
  ]
  edge
  [
    source 58
    target 68
    value 5
  ]
  edge
  [
    source 58
    target 7
    value 1
  ]
  edge
  [
    source 58
    target 20
    value 4
  ]
  edge
  [
    source 58
    target 21
    value 2
  ]
  edge
  [
    source 58
    target 23
    value 1
  ]
  edge
  [
    source 58
    target 46
    value 2
  ]
  edge
  [
    source 58
    target 87
    value 1
  ]
  edge
  [
    source 58
    target 24
    value 4
  ]
  edge
  [
    source 58
    target 88
    value 1
  ]
  edge
  [
    source 58
    target 85
    value 1
  ]
  edge
  [
    source 58
    target 61
    value 1
  ]
  edge
  [
    source 58
    target 69
    value 2
  ]
  edge
  [
    source 58
    target 82
    value 1
  ]
  edge
  [
    source 59
    target 105
    value 1
  ]
  edge
  [
    source 59
    target 102
    value 5
  ]
  edge
  [
    source 59
    target 108
    value 4
  ]
  edge
  [
    source 59
    target 99
    value 1
  ]
  edge
  [
    source 59
    target 5
    value 1
  ]
  edge
  [
    source 59
    target 71
    value 1
  ]
  edge
  [
    source 59
    target 58
    value 1
  ]
  edge
  [
    source 59
    target 15
    value 1
  ]
  edge
  [
    source 59
    target 27
    value 2
  ]
  edge
  [
    source 59
    target 66
    value 1
  ]
  edge
  [
    source 59
    target 55
    value 3
  ]
  edge
  [
    source 59
    target 68
    value 3
  ]
  edge
  [
    source 59
    target 19
    value 3
  ]
  edge
  [
    source 59
    target 32
    value 7
  ]
  edge
  [
    source 59
    target 13
    value 12
  ]
  edge
  [
    source 59
    target 6
    value 9
  ]
  edge
  [
    source 59
    target 14
    value 5
  ]
  edge
  [
    source 59
    target 7
    value 4
  ]
  edge
  [
    source 59
    target 22
    value 5
  ]
  edge
  [
    source 59
    target 33
    value 5
  ]
  edge
  [
    source 59
    target 49
    value 1
  ]
  edge
  [
    source 59
    target 64
    value 1
  ]
  edge
  [
    source 59
    target 91
    value 1
  ]
  edge
  [
    source 59
    target 39
    value 1
  ]
  edge
  [
    source 60
    target 14
    value 1
  ]
  edge
  [
    source 60
    target 7
    value 1
  ]
  edge
  [
    source 60
    target 44
    value 10
  ]
  edge
  [
    source 61
    target 33
    value 3
  ]
  edge
  [
    source 61
    target 46
    value 1
  ]
  edge
  [
    source 61
    target 60
    value 1
  ]
  edge
  [
    source 61
    target 49
    value 1
  ]
  edge
  [
    source 61
    target 82
    value 1
  ]
  edge
  [
    source 61
    target 44
    value 6
  ]
  edge
  [
    source 62
    target 63
    value 2
  ]
  edge
  [
    source 62
    target 3
    value 1
  ]
  edge
  [
    source 62
    target 41
    value 1
  ]
  edge
  [
    source 62
    target 55
    value 6
  ]
  edge
  [
    source 62
    target 19
    value 8
  ]
  edge
  [
    source 62
    target 20
    value 1
  ]
  edge
  [
    source 62
    target 59
    value 9
  ]
  edge
  [
    source 62
    target 47
    value 3
  ]
  edge
  [
    source 62
    target 48
    value 1
  ]
  edge
  [
    source 62
    target 49
    value 2
  ]
  edge
  [
    source 62
    target 64
    value 2
  ]
  edge
  [
    source 62
    target 65
    value 2
  ]
  edge
  [
    source 63
    target 101
    value 1
  ]
  edge
  [
    source 63
    target 12
    value 2
  ]
  edge
  [
    source 63
    target 2
    value 3
  ]
  edge
  [
    source 63
    target 3
    value 1
  ]
  edge
  [
    source 63
    target 225
    value 1
  ]
  edge
  [
    source 63
    target 71
    value 1
  ]
  edge
  [
    source 63
    target 129
    value 2
  ]
  edge
  [
    source 63
    target 41
    value 1
  ]
  edge
  [
    source 63
    target 62
    value 2
  ]
  edge
  [
    source 63
    target 18
    value 2
  ]
  edge
  [
    source 63
    target 13
    value 1
  ]
  edge
  [
    source 63
    target 215
    value 1
  ]
  edge
  [
    source 63
    target 8
    value 5
  ]
  edge
  [
    source 63
    target 9
    value 6
  ]
  edge
  [
    source 63
    target 59
    value 2
  ]
  edge
  [
    source 63
    target 34
    value 1
  ]
  edge
  [
    source 63
    target 209
    value 1
  ]
  edge
  [
    source 63
    target 47
    value 2
  ]
  edge
  [
    source 63
    target 93
    value 3
  ]
  edge
  [
    source 63
    target 24
    value 1
  ]
  edge
  [
    source 63
    target 94
    value 1
  ]
  edge
  [
    source 63
    target 81
    value 1
  ]
  edge
  [
    source 63
    target 85
    value 1
  ]
  edge
  [
    source 63
    target 83
    value 1
  ]
  edge
  [
    source 64
    target 74
    value 1
  ]
  edge
  [
    source 64
    target 44
    value 5
  ]
  edge
  [
    source 65
    target 11
    value 7
  ]
  edge
  [
    source 65
    target 84
    value 2
  ]
  edge
  [
    source 65
    target 3
    value 3
  ]
  edge
  [
    source 65
    target 98
    value 2
  ]
  edge
  [
    source 65
    target 13
    value 8
  ]
  edge
  [
    source 65
    target 20
    value 1
  ]
  edge
  [
    source 65
    target 8
    value 2
  ]
  edge
  [
    source 66
    target 67
    value 2
  ]
  edge
  [
    source 66
    target 50
    value 1
  ]
  edge
  [
    source 66
    target 31
    value 2
  ]
  edge
  [
    source 66
    target 68
    value 1
  ]
  edge
  [
    source 66
    target 32
    value 7
  ]
  edge
  [
    source 66
    target 59
    value 5
  ]
  edge
  [
    source 66
    target 47
    value 1
  ]
  edge
  [
    source 66
    target 51
    value 2
  ]
  edge
  [
    source 66
    target 64
    value 1
  ]
  edge
  [
    source 66
    target 38
    value 1
  ]
  edge
  [
    source 66
    target 69
    value 1
  ]
  edge
  [
    source 67
    target 106
    value 1
  ]
  edge
  [
    source 67
    target 63
    value 2
  ]
  edge
  [
    source 67
    target 12
    value 5
  ]
  edge
  [
    source 67
    target 2
    value 1
  ]
  edge
  [
    source 67
    target 118
    value 1
  ]
  edge
  [
    source 67
    target 4
    value 1
  ]
  edge
  [
    source 67
    target 98
    value 1
  ]
  edge
  [
    source 67
    target 218
    value 1
  ]
  edge
  [
    source 67
    target 58
    value 1
  ]
  edge
  [
    source 67
    target 129
    value 1
  ]
  edge
  [
    source 67
    target 224
    value 2
  ]
  edge
  [
    source 67
    target 31
    value 2
  ]
  edge
  [
    source 67
    target 8
    value 7
  ]
  edge
  [
    source 67
    target 9
    value 4
  ]
  edge
  [
    source 67
    target 59
    value 1
  ]
  edge
  [
    source 67
    target 48
    value 2
  ]
  edge
  [
    source 67
    target 87
    value 2
  ]
  edge
  [
    source 67
    target 212
    value 1
  ]
  edge
  [
    source 68
    target 20
    value 1
  ]
  edge
  [
    source 68
    target 21
    value 1
  ]
  edge
  [
    source 68
    target 23
    value 3
  ]
  edge
  [
    source 68
    target 36
    value 1
  ]
  edge
  [
    source 68
    target 79
    value 2
  ]
  edge
  [
    source 69
    target 86
    value 1
  ]
  edge
  [
    source 69
    target 58
    value 1
  ]
  edge
  [
    source 69
    target 50
    value 3
  ]
  edge
  [
    source 69
    target 66
    value 1
  ]
  edge
  [
    source 69
    target 21
    value 1
  ]
  edge
  [
    source 69
    target 47
    value 1
  ]
  edge
  [
    source 69
    target 48
    value 1
  ]
  edge
  [
    source 69
    target 87
    value 1
  ]
  edge
  [
    source 69
    target 88
    value 1
  ]
  edge
  [
    source 69
    target 37
    value 1
  ]
  edge
  [
    source 69
    target 89
    value 1
  ]
  edge
  [
    source 69
    target 52
    value 7
  ]
  edge
  [
    source 70
    target 5
    value 1
  ]
  edge
  [
    source 70
    target 17
    value 6
  ]
  edge
  [
    source 70
    target 19
    value 1
  ]
  edge
  [
    source 70
    target 13
    value 1
  ]
  edge
  [
    source 70
    target 59
    value 2
  ]
  edge
  [
    source 70
    target 22
    value 11
  ]
  edge
  [
    source 70
    target 51
    value 2
  ]
  edge
  [
    source 70
    target 49
    value 5
  ]
  edge
  [
    source 70
    target 64
    value 1
  ]
  edge
  [
    source 70
    target 26
    value 4
  ]
  edge
  [
    source 71
    target 4
    value 5
  ]
  edge
  [
    source 71
    target 40
    value 4
  ]
  edge
  [
    source 71
    target 41
    value 1
  ]
  edge
  [
    source 71
    target 18
    value 2
  ]
  edge
  [
    source 71
    target 55
    value 6
  ]
  edge
  [
    source 71
    target 14
    value 2
  ]
  edge
  [
    source 71
    target 20
    value 1
  ]
  edge
  [
    source 71
    target 21
    value 3
  ]
  edge
  [
    source 71
    target 22
    value 2
  ]
  edge
  [
    source 71
    target 90
    value 1
  ]
  edge
  [
    source 71
    target 43
    value 3
  ]
  edge
  [
    source 71
    target 93
    value 3
  ]
  edge
  [
    source 71
    target 36
    value 4
  ]
  edge
  [
    source 71
    target 94
    value 1
  ]
  edge
  [
    source 71
    target 89
    value 1
  ]
  edge
  [
    source 71
    target 56
    value 2
  ]
  edge
  [
    source 71
    target 83
    value 2
  ]
  edge
  [
    source 71
    target 76
    value 2
  ]
  edge
  [
    source 72
    target 114
    value 1
  ]
  edge
  [
    source 72
    target 2
    value 3
  ]
  edge
  [
    source 72
    target 18
    value 1
  ]
  edge
  [
    source 72
    target 132
    value 4
  ]
  edge
  [
    source 72
    target 130
    value 5
  ]
  edge
  [
    source 72
    target 214
    value 1
  ]
  edge
  [
    source 72
    target 93
    value 1
  ]
  edge
  [
    source 73
    target 13
    value 1
  ]
  edge
  [
    source 73
    target 6
    value 1
  ]
  edge
  [
    source 73
    target 75
    value 1
  ]
  edge
  [
    source 73
    target 44
    value 3
  ]
  edge
  [
    source 74
    target 13
    value 2
  ]
  edge
  [
    source 74
    target 6
    value 1
  ]
  edge
  [
    source 74
    target 44
    value 3
  ]
  edge
  [
    source 75
    target 13
    value 8
  ]
  edge
  [
    source 75
    target 6
    value 4
  ]
  edge
  [
    source 75
    target 209
    value 1
  ]
  edge
  [
    source 75
    target 23
    value 2
  ]
  edge
  [
    source 75
    target 73
    value 2
  ]
  edge
  [
    source 75
    target 44
    value 3
  ]
  edge
  [
    source 76
    target 4
    value 3
  ]
  edge
  [
    source 76
    target 14
    value 1
  ]
  edge
  [
    source 76
    target 35
    value 4
  ]
  edge
  [
    source 76
    target 43
    value 5
  ]
  edge
  [
    source 76
    target 73
    value 1
  ]
  edge
  [
    source 76
    target 74
    value 2
  ]
  edge
  [
    source 77
    target 42
    value 1
  ]
  edge
  [
    source 77
    target 13
    value 3
  ]
  edge
  [
    source 77
    target 6
    value 7
  ]
  edge
  [
    source 77
    target 34
    value 1
  ]
  edge
  [
    source 77
    target 35
    value 1
  ]
  edge
  [
    source 77
    target 74
    value 4
  ]
  edge
  [
    source 77
    target 44
    value 2
  ]
  edge
  [
    source 78
    target 190
    value 1
  ]
  edge
  [
    source 79
    target 190
    value 1
  ]
  edge
  [
    source 80
    target 190
    value 1
  ]
  edge
  [
    source 81
    target 190
    value 1
  ]
  edge
  [
    source 82
    target 3
    value 2
  ]
  edge
  [
    source 82
    target 4
    value 2
  ]
  edge
  [
    source 82
    target 7
    value 1
  ]
  edge
  [
    source 82
    target 23
    value 2
  ]
  edge
  [
    source 82
    target 46
    value 4
  ]
  edge
  [
    source 82
    target 73
    value 4
  ]
  edge
  [
    source 82
    target 74
    value 1
  ]
  edge
  [
    source 83
    target 84
    value 1
  ]
  edge
  [
    source 83
    target 71
    value 1
  ]
  edge
  [
    source 83
    target 41
    value 1
  ]
  edge
  [
    source 83
    target 21
    value 1
  ]
  edge
  [
    source 83
    target 35
    value 1
  ]
  edge
  [
    source 83
    target 25
    value 1
  ]
  edge
  [
    source 83
    target 85
    value 1
  ]
  edge
  [
    source 83
    target 65
    value 4
  ]
  edge
  [
    source 84
    target 151
    value 1
  ]
  edge
  [
    source 84
    target 152
    value 2
  ]
  edge
  [
    source 84
    target 155
    value 2
  ]
  edge
  [
    source 84
    target 156
    value 2
  ]
  edge
  [
    source 84
    target 157
    value 1
  ]
  edge
  [
    source 84
    target 158
    value 2
  ]
  edge
  [
    source 84
    target 2
    value 25
  ]
  edge
  [
    source 84
    target 86
    value 2
  ]
  edge
  [
    source 84
    target 118
    value 3
  ]
  edge
  [
    source 84
    target 4
    value 3
  ]
  edge
  [
    source 84
    target 187
    value 1
  ]
  edge
  [
    source 84
    target 163
    value 1
  ]
  edge
  [
    source 84
    target 142
    value 1
  ]
  edge
  [
    source 84
    target 175
    value 1
  ]
  edge
  [
    source 84
    target 180
    value 1
  ]
  edge
  [
    source 84
    target 188
    value 1
  ]
  edge
  [
    source 84
    target 189
    value 1
  ]
  edge
  [
    source 84
    target 190
    value 6
  ]
  edge
  [
    source 85
    target 12
    value 1
  ]
  edge
  [
    source 85
    target 60
    value 3
  ]
  edge
  [
    source 85
    target 211
    value 2
  ]
  edge
  [
    source 85
    target 44
    value 9
  ]
  edge
  [
    source 86
    target 151
    value 1
  ]
  edge
  [
    source 86
    target 152
    value 2
  ]
  edge
  [
    source 86
    target 155
    value 2
  ]
  edge
  [
    source 86
    target 156
    value 2
  ]
  edge
  [
    source 86
    target 157
    value 1
  ]
  edge
  [
    source 86
    target 158
    value 2
  ]
  edge
  [
    source 86
    target 12
    value 25
  ]
  edge
  [
    source 86
    target 84
    value 2
  ]
  edge
  [
    source 86
    target 117
    value 3
  ]
  edge
  [
    source 86
    target 3
    value 3
  ]
  edge
  [
    source 86
    target 187
    value 1
  ]
  edge
  [
    source 86
    target 163
    value 1
  ]
  edge
  [
    source 86
    target 191
    value 1
  ]
  edge
  [
    source 86
    target 175
    value 1
  ]
  edge
  [
    source 86
    target 180
    value 1
  ]
  edge
  [
    source 86
    target 188
    value 1
  ]
  edge
  [
    source 86
    target 189
    value 1
  ]
  edge
  [
    source 86
    target 190
    value 6
  ]
  edge
  [
    source 87
    target 106
    value 1
  ]
  edge
  [
    source 87
    target 236
    value 1
  ]
  edge
  [
    source 87
    target 109
    value 1
  ]
  edge
  [
    source 87
    target 2
    value 1
  ]
  edge
  [
    source 87
    target 86
    value 1
  ]
  edge
  [
    source 87
    target 117
    value 1
  ]
  edge
  [
    source 87
    target 4
    value 3
  ]
  edge
  [
    source 87
    target 119
    value 1
  ]
  edge
  [
    source 87
    target 103
    value 1
  ]
  edge
  [
    source 87
    target 47
    value 3
  ]
  edge
  [
    source 87
    target 48
    value 3
  ]
  edge
  [
    source 87
    target 43
    value 1
  ]
  edge
  [
    source 87
    target 46
    value 4
  ]
  edge
  [
    source 87
    target 52
    value 1
  ]
  edge
  [
    source 87
    target 44
    value 3
  ]
  edge
  [
    source 88
    target 190
    value 1
  ]
  edge
  [
    source 89
    target 2
    value 1
  ]
  edge
  [
    source 89
    target 60
    value 4
  ]
  edge
  [
    source 89
    target 212
    value 2
  ]
  edge
  [
    source 89
    target 44
    value 9
  ]
  edge
  [
    source 90
    target 3
    value 8
  ]
  edge
  [
    source 90
    target 4
    value 6
  ]
  edge
  [
    source 90
    target 213
    value 1
  ]
  edge
  [
    source 90
    target 218
    value 3
  ]
  edge
  [
    source 90
    target 187
    value 2
  ]
  edge
  [
    source 90
    target 71
    value 1
  ]
  edge
  [
    source 90
    target 58
    value 2
  ]
  edge
  [
    source 90
    target 15
    value 2
  ]
  edge
  [
    source 90
    target 27
    value 1
  ]
  edge
  [
    source 90
    target 31
    value 1
  ]
  edge
  [
    source 90
    target 14
    value 3
  ]
  edge
  [
    source 90
    target 7
    value 6
  ]
  edge
  [
    source 90
    target 132
    value 2
  ]
  edge
  [
    source 90
    target 130
    value 4
  ]
  edge
  [
    source 90
    target 23
    value 1
  ]
  edge
  [
    source 90
    target 47
    value 2
  ]
  edge
  [
    source 90
    target 48
    value 5
  ]
  edge
  [
    source 90
    target 73
    value 1
  ]
  edge
  [
    source 90
    target 74
    value 1
  ]
  edge
  [
    source 90
    target 77
    value 1
  ]
  edge
  [
    source 90
    target 75
    value 1
  ]
  edge
  [
    source 90
    target 91
    value 1
  ]
  edge
  [
    source 91
    target 12
    value 1
  ]
  edge
  [
    source 91
    target 3
    value 6
  ]
  edge
  [
    source 91
    target 29
    value 1
  ]
  edge
  [
    source 91
    target 6
    value 1
  ]
  edge
  [
    source 91
    target 7
    value 1
  ]
  edge
  [
    source 91
    target 23
    value 1
  ]
  edge
  [
    source 91
    target 35
    value 4
  ]
  edge
  [
    source 91
    target 43
    value 3
  ]
  edge
  [
    source 91
    target 78
    value 1
  ]
  edge
  [
    source 91
    target 79
    value 1
  ]
  edge
  [
    source 91
    target 77
    value 3
  ]
  edge
  [
    source 92
    target 3
    value 2
  ]
  edge
  [
    source 92
    target 4
    value 2
  ]
  edge
  [
    source 92
    target 48
    value 1
  ]
  edge
  [
    source 92
    target 39
    value 1
  ]
  edge
  [
    source 92
    target 39
    value 2
  ]
  edge
  [
    source 93
    target 101
    value 1
  ]
  edge
  [
    source 93
    target 114
    value 1
  ]
  edge
  [
    source 93
    target 216
    value 1
  ]
  edge
  [
    source 93
    target 235
    value 1
  ]
  edge
  [
    source 93
    target 141
    value 1
  ]
  edge
  [
    source 93
    target 12
    value 1
  ]
  edge
  [
    source 93
    target 86
    value 2
  ]
  edge
  [
    source 93
    target 3
    value 2
  ]
  edge
  [
    source 93
    target 71
    value 1
  ]
  edge
  [
    source 93
    target 47
    value 1
  ]
  edge
  [
    source 93
    target 48
    value 3
  ]
  edge
  [
    source 93
    target 43
    value 4
  ]
  edge
  [
    source 93
    target 36
    value 1
  ]
  edge
  [
    source 93
    target 25
    value 1
  ]
  edge
  [
    source 93
    target 78
    value 2
  ]
  edge
  [
    source 93
    target 104
    value 2
  ]
  edge
  [
    source 93
    target 65
    value 1
  ]
  edge
  [
    source 93
    target 44
    value 5
  ]
  edge
  [
    source 94
    target 190
    value 1
  ]
  edge
  [
    source 95
    target 63
    value 1
  ]
  edge
  [
    source 95
    target 67
    value 1
  ]
  edge
  [
    source 95
    target 240
    value 1
  ]
  edge
  [
    source 95
    target 12
    value 5
  ]
  edge
  [
    source 95
    target 198
    value 1
  ]
  edge
  [
    source 95
    target 119
    value 2
  ]
  edge
  [
    source 95
    target 142
    value 7
  ]
  edge
  [
    source 95
    target 125
    value 2
  ]
  edge
  [
    source 95
    target 172
    value 2
  ]
  edge
  [
    source 95
    target 207
    value 4
  ]
  edge
  [
    source 95
    target 204
    value 1
  ]
  edge
  [
    source 95
    target 72
    value 1
  ]
  edge
  [
    source 95
    target 241
    value 1
  ]
  edge
  [
    source 95
    target 61
    value 1
  ]
  edge
  [
    source 96
    target 97
    value 1
  ]
  edge
  [
    source 96
    target 60
    value 1
  ]
  edge
  [
    source 96
    target 44
    value 1
  ]
  edge
  [
    source 97
    target 166
    value 2
  ]
  edge
  [
    source 97
    target 227
    value 1
  ]
  edge
  [
    source 97
    target 221
    value 1
  ]
  edge
  [
    source 97
    target 44
    value 29
  ]
  edge
  [
    source 98
    target 2
    value 2
  ]
  edge
  [
    source 98
    target 84
    value 4
  ]
  edge
  [
    source 98
    target 86
    value 1
  ]
  edge
  [
    source 98
    target 118
    value 4
  ]
  edge
  [
    source 98
    target 3
    value 4
  ]
  edge
  [
    source 98
    target 202
    value 1
  ]
  edge
  [
    source 98
    target 198
    value 1
  ]
  edge
  [
    source 98
    target 119
    value 1
  ]
  edge
  [
    source 98
    target 206
    value 1
  ]
  edge
  [
    source 98
    target 191
    value 1
  ]
  edge
  [
    source 98
    target 125
    value 2
  ]
  edge
  [
    source 98
    target 172
    value 4
  ]
  edge
  [
    source 98
    target 207
    value 1
  ]
  edge
  [
    source 98
    target 145
    value 1
  ]
  edge
  [
    source 98
    target 186
    value 1
  ]
  edge
  [
    source 99
    target 107
    value 1
  ]
  edge
  [
    source 99
    target 2
    value 1
  ]
  edge
  [
    source 99
    target 4
    value 3
  ]
  edge
  [
    source 99
    target 6
    value 10
  ]
  edge
  [
    source 99
    target 7
    value 12
  ]
  edge
  [
    source 99
    target 52
    value 1
  ]
  edge
  [
    source 100
    target 101
    value 1
  ]
  edge
  [
    source 100
    target 102
    value 11
  ]
  edge
  [
    source 100
    target 11
    value 3
  ]
  edge
  [
    source 100
    target 19
    value 1
  ]
  edge
  [
    source 100
    target 13
    value 12
  ]
  edge
  [
    source 100
    target 103
    value 2
  ]
  edge
  [
    source 100
    target 104
    value 2
  ]
  edge
  [
    source 101
    target 1
    value 1
  ]
  edge
  [
    source 101
    target 114
    value 2
  ]
  edge
  [
    source 101
    target 2
    value 1
  ]
  edge
  [
    source 101
    target 84
    value 4
  ]
  edge
  [
    source 101
    target 86
    value 5
  ]
  edge
  [
    source 101
    target 3
    value 1
  ]
  edge
  [
    source 101
    target 98
    value 4
  ]
  edge
  [
    source 101
    target 224
    value 1
  ]
  edge
  [
    source 101
    target 132
    value 3
  ]
  edge
  [
    source 101
    target 22
    value 1
  ]
  edge
  [
    source 101
    target 22
    value 1
  ]
  edge
  [
    source 101
    target 77
    value 2
  ]
  edge
  [
    source 102
    target 100
    value 2
  ]
  edge
  [
    source 102
    target 113
    value 2
  ]
  edge
  [
    source 102
    target 1
    value 4
  ]
  edge
  [
    source 102
    target 114
    value 7
  ]
  edge
  [
    source 102
    target 135
    value 1
  ]
  edge
  [
    source 102
    target 136
    value 1
  ]
  edge
  [
    source 102
    target 4
    value 4
  ]
  edge
  [
    source 102
    target 137
    value 1
  ]
  edge
  [
    source 102
    target 13
    value 7
  ]
  edge
  [
    source 102
    target 59
    value 1
  ]
  edge
  [
    source 102
    target 132
    value 3
  ]
  edge
  [
    source 102
    target 89
    value 4
  ]
  edge
  [
    source 102
    target 104
    value 7
  ]
  edge
  [
    source 103
    target 102
    value 6
  ]
  edge
  [
    source 103
    target 108
    value 5
  ]
  edge
  [
    source 103
    target 201
    value 1
  ]
  edge
  [
    source 103
    target 11
    value 1
  ]
  edge
  [
    source 103
    target 5
    value 1
  ]
  edge
  [
    source 103
    target 137
    value 3
  ]
  edge
  [
    source 103
    target 191
    value 1
  ]
  edge
  [
    source 103
    target 13
    value 6
  ]
  edge
  [
    source 103
    target 6
    value 1
  ]
  edge
  [
    source 103
    target 65
    value 5
  ]
  edge
  [
    source 103
    target 52
    value 2
  ]
  edge
  [
    source 104
    target 222
    value 1
  ]
  edge
  [
    source 104
    target 64
    value 5
  ]
  edge
  [
    source 104
    target 131
    value 3
  ]
  edge
  [
    source 104
    target 44
    value 4
  ]
  edge
  [
    source 105
    target 106
    value 1
  ]
  edge
  [
    source 105
    target 107
    value 1
  ]
  edge
  [
    source 105
    target 108
    value 8
  ]
  edge
  [
    source 105
    target 109
    value 1
  ]
  edge
  [
    source 105
    target 99
    value 3
  ]
  edge
  [
    source 105
    target 110
    value 2
  ]
  edge
  [
    source 105
    target 111
    value 1
  ]
  edge
  [
    source 105
    target 6
    value 12
  ]
  edge
  [
    source 105
    target 9
    value 2
  ]
  edge
  [
    source 105
    target 103
    value 3
  ]
  edge
  [
    source 105
    target 89
    value 1
  ]
  edge
  [
    source 105
    target 112
    value 2
  ]
  edge
  [
    source 105
    target 52
    value 1
  ]
  edge
  [
    source 106
    target 84
    value 3
  ]
  edge
  [
    source 106
    target 86
    value 4
  ]
  edge
  [
    source 106
    target 3
    value 1
  ]
  edge
  [
    source 106
    target 119
    value 3
  ]
  edge
  [
    source 106
    target 130
    value 4
  ]
  edge
  [
    source 106
    target 33
    value 1
  ]
  edge
  [
    source 106
    target 209
    value 1
  ]
  edge
  [
    source 106
    target 75
    value 2
  ]
  edge
  [
    source 107
    target 105
    value 1
  ]
  edge
  [
    source 107
    target 108
    value 6
  ]
  edge
  [
    source 107
    target 139
    value 1
  ]
  edge
  [
    source 107
    target 191
    value 1
  ]
  edge
  [
    source 107
    target 6
    value 4
  ]
  edge
  [
    source 107
    target 7
    value 4
  ]
  edge
  [
    source 108
    target 122
    value 1
  ]
  edge
  [
    source 108
    target 1
    value 9
  ]
  edge
  [
    source 108
    target 114
    value 1
  ]
  edge
  [
    source 108
    target 3
    value 4
  ]
  edge
  [
    source 108
    target 4
    value 1
  ]
  edge
  [
    source 108
    target 137
    value 2
  ]
  edge
  [
    source 108
    target 6
    value 7
  ]
  edge
  [
    source 108
    target 130
    value 4
  ]
  edge
  [
    source 108
    target 85
    value 5
  ]
  edge
  [
    source 108
    target 112
    value 3
  ]
  edge
  [
    source 109
    target 106
    value 1
  ]
  edge
  [
    source 109
    target 105
    value 2
  ]
  edge
  [
    source 109
    target 122
    value 9
  ]
  edge
  [
    source 109
    target 114
    value 3
  ]
  edge
  [
    source 109
    target 2
    value 5
  ]
  edge
  [
    source 109
    target 86
    value 3
  ]
  edge
  [
    source 109
    target 117
    value 5
  ]
  edge
  [
    source 109
    target 118
    value 1
  ]
  edge
  [
    source 109
    target 4
    value 2
  ]
  edge
  [
    source 109
    target 142
    value 1
  ]
  edge
  [
    source 109
    target 111
    value 1
  ]
  edge
  [
    source 109
    target 6
    value 2
  ]
  edge
  [
    source 109
    target 87
    value 2
  ]
  edge
  [
    source 110
    target 105
    value 4
  ]
  edge
  [
    source 110
    target 108
    value 4
  ]
  edge
  [
    source 110
    target 28
    value 1
  ]
  edge
  [
    source 110
    target 86
    value 2
  ]
  edge
  [
    source 110
    target 6
    value 1
  ]
  edge
  [
    source 110
    target 103
    value 2
  ]
  edge
  [
    source 110
    target 112
    value 1
  ]
  edge
  [
    source 111
    target 105
    value 1
  ]
  edge
  [
    source 111
    target 201
    value 1
  ]
  edge
  [
    source 111
    target 12
    value 1
  ]
  edge
  [
    source 111
    target 2
    value 2
  ]
  edge
  [
    source 111
    target 84
    value 3
  ]
  edge
  [
    source 111
    target 86
    value 7
  ]
  edge
  [
    source 111
    target 3
    value 1
  ]
  edge
  [
    source 111
    target 198
    value 3
  ]
  edge
  [
    source 111
    target 187
    value 4
  ]
  edge
  [
    source 111
    target 233
    value 1
  ]
  edge
  [
    source 111
    target 193
    value 2
  ]
  edge
  [
    source 111
    target 125
    value 5
  ]
  edge
  [
    source 111
    target 172
    value 7
  ]
  edge
  [
    source 111
    target 145
    value 1
  ]
  edge
  [
    source 111
    target 6
    value 2
  ]
  edge
  [
    source 111
    target 9
    value 1
  ]
  edge
  [
    source 111
    target 130
    value 1
  ]
  edge
  [
    source 111
    target 190
    value 3
  ]
  edge
  [
    source 112
    target 223
    value 3
  ]
  edge
  [
    source 112
    target 64
    value 3
  ]
  edge
  [
    source 112
    target 72
    value 4
  ]
  edge
  [
    source 112
    target 44
    value 4
  ]
  edge
  [
    source 113
    target 101
    value 1
  ]
  edge
  [
    source 113
    target 1
    value 11
  ]
  edge
  [
    source 113
    target 149
    value 2
  ]
  edge
  [
    source 113
    target 102
    value 2
  ]
  edge
  [
    source 113
    target 115
    value 2
  ]
  edge
  [
    source 113
    target 140
    value 1
  ]
  edge
  [
    source 113
    target 141
    value 3
  ]
  edge
  [
    source 113
    target 124
    value 1
  ]
  edge
  [
    source 113
    target 191
    value 1
  ]
  edge
  [
    source 113
    target 215
    value 1
  ]
  edge
  [
    source 114
    target 2
    value 1
  ]
  edge
  [
    source 114
    target 86
    value 3
  ]
  edge
  [
    source 114
    target 3
    value 1
  ]
  edge
  [
    source 114
    target 13
    value 1
  ]
  edge
  [
    source 114
    target 14
    value 4
  ]
  edge
  [
    source 114
    target 132
    value 14
  ]
  edge
  [
    source 114
    target 130
    value 1
  ]
  edge
  [
    source 114
    target 131
    value 1
  ]
  edge
  [
    source 114
    target 73
    value 3
  ]
  edge
  [
    source 114
    target 133
    value 1
  ]
  edge
  [
    source 115
    target 126
    value 3
  ]
  edge
  [
    source 115
    target 128
    value 1
  ]
  edge
  [
    source 115
    target 113
    value 4
  ]
  edge
  [
    source 115
    target 122
    value 3
  ]
  edge
  [
    source 115
    target 1
    value 1
  ]
  edge
  [
    source 115
    target 114
    value 7
  ]
  edge
  [
    source 115
    target 10
    value 4
  ]
  edge
  [
    source 115
    target 107
    value 12
  ]
  edge
  [
    source 115
    target 139
    value 1
  ]
  edge
  [
    source 115
    target 138
    value 1
  ]
  edge
  [
    source 115
    target 124
    value 2
  ]
  edge
  [
    source 116
    target 100
    value 3
  ]
  edge
  [
    source 116
    target 113
    value 7
  ]
  edge
  [
    source 116
    target 1
    value 5
  ]
  edge
  [
    source 116
    target 141
    value 1
  ]
  edge
  [
    source 116
    target 12
    value 2
  ]
  edge
  [
    source 116
    target 84
    value 6
  ]
  edge
  [
    source 116
    target 117
    value 2
  ]
  edge
  [
    source 116
    target 118
    value 4
  ]
  edge
  [
    source 116
    target 13
    value 4
  ]
  edge
  [
    source 116
    target 132
    value 1
  ]
  edge
  [
    source 116
    target 22
    value 1
  ]
  edge
  [
    source 116
    target 103
    value 1
  ]
  edge
  [
    source 117
    target 151
    value 1
  ]
  edge
  [
    source 117
    target 152
    value 2
  ]
  edge
  [
    source 117
    target 153
    value 2
  ]
  edge
  [
    source 117
    target 156
    value 1
  ]
  edge
  [
    source 117
    target 157
    value 1
  ]
  edge
  [
    source 117
    target 12
    value 70
  ]
  edge
  [
    source 117
    target 84
    value 1
  ]
  edge
  [
    source 117
    target 118
    value 2
  ]
  edge
  [
    source 117
    target 159
    value 3
  ]
  edge
  [
    source 117
    target 160
    value 2
  ]
  edge
  [
    source 117
    target 161
    value 6
  ]
  edge
  [
    source 117
    target 162
    value 4
  ]
  edge
  [
    source 117
    target 163
    value 3
  ]
  edge
  [
    source 117
    target 166
    value 1
  ]
  edge
  [
    source 117
    target 167
    value 1
  ]
  edge
  [
    source 117
    target 192
    value 1
  ]
  edge
  [
    source 117
    target 193
    value 1
  ]
  edge
  [
    source 117
    target 170
    value 3
  ]
  edge
  [
    source 117
    target 194
    value 1
  ]
  edge
  [
    source 117
    target 125
    value 1
  ]
  edge
  [
    source 117
    target 173
    value 3
  ]
  edge
  [
    source 117
    target 186
    value 6
  ]
  edge
  [
    source 117
    target 176
    value 1
  ]
  edge
  [
    source 117
    target 178
    value 1
  ]
  edge
  [
    source 117
    target 179
    value 3
  ]
  edge
  [
    source 117
    target 181
    value 1
  ]
  edge
  [
    source 117
    target 182
    value 2
  ]
  edge
  [
    source 118
    target 151
    value 1
  ]
  edge
  [
    source 118
    target 152
    value 2
  ]
  edge
  [
    source 118
    target 153
    value 2
  ]
  edge
  [
    source 118
    target 156
    value 1
  ]
  edge
  [
    source 118
    target 157
    value 1
  ]
  edge
  [
    source 118
    target 2
    value 70
  ]
  edge
  [
    source 118
    target 86
    value 1
  ]
  edge
  [
    source 118
    target 117
    value 2
  ]
  edge
  [
    source 118
    target 159
    value 3
  ]
  edge
  [
    source 118
    target 160
    value 2
  ]
  edge
  [
    source 118
    target 161
    value 6
  ]
  edge
  [
    source 118
    target 162
    value 4
  ]
  edge
  [
    source 118
    target 163
    value 3
  ]
  edge
  [
    source 118
    target 166
    value 1
  ]
  edge
  [
    source 118
    target 167
    value 1
  ]
  edge
  [
    source 118
    target 192
    value 1
  ]
  edge
  [
    source 118
    target 193
    value 1
  ]
  edge
  [
    source 118
    target 184
    value 3
  ]
  edge
  [
    source 118
    target 194
    value 1
  ]
  edge
  [
    source 118
    target 172
    value 1
  ]
  edge
  [
    source 118
    target 173
    value 3
  ]
  edge
  [
    source 118
    target 174
    value 6
  ]
  edge
  [
    source 118
    target 176
    value 1
  ]
  edge
  [
    source 118
    target 178
    value 1
  ]
  edge
  [
    source 118
    target 179
    value 3
  ]
  edge
  [
    source 118
    target 181
    value 1
  ]
  edge
  [
    source 118
    target 182
    value 2
  ]
  edge
  [
    source 119
    target 12
    value 2
  ]
  edge
  [
    source 119
    target 84
    value 1
  ]
  edge
  [
    source 119
    target 86
    value 5
  ]
  edge
  [
    source 119
    target 117
    value 3
  ]
  edge
  [
    source 119
    target 4
    value 4
  ]
  edge
  [
    source 119
    target 199
    value 1
  ]
  edge
  [
    source 119
    target 123
    value 1
  ]
  edge
  [
    source 119
    target 142
    value 1
  ]
  edge
  [
    source 119
    target 125
    value 1
  ]
  edge
  [
    source 119
    target 172
    value 3
  ]
  edge
  [
    source 119
    target 204
    value 2
  ]
  edge
  [
    source 119
    target 148
    value 1
  ]
  edge
  [
    source 119
    target 205
    value 1
  ]
  edge
  [
    source 119
    target 90
    value 2
  ]
  edge
  [
    source 119
    target 174
    value 1
  ]
  edge
  [
    source 120
    target 100
    value 8
  ]
  edge
  [
    source 120
    target 114
    value 1
  ]
  edge
  [
    source 120
    target 102
    value 7
  ]
  edge
  [
    source 120
    target 84
    value 1
  ]
  edge
  [
    source 120
    target 13
    value 3
  ]
  edge
  [
    source 120
    target 85
    value 1
  ]
  edge
  [
    source 121
    target 122
    value 10
  ]
  edge
  [
    source 121
    target 114
    value 11
  ]
  edge
  [
    source 121
    target 115
    value 1
  ]
  edge
  [
    source 121
    target 109
    value 3
  ]
  edge
  [
    source 121
    target 2
    value 2
  ]
  edge
  [
    source 121
    target 84
    value 1
  ]
  edge
  [
    source 121
    target 86
    value 2
  ]
  edge
  [
    source 121
    target 117
    value 5
  ]
  edge
  [
    source 121
    target 118
    value 2
  ]
  edge
  [
    source 121
    target 123
    value 1
  ]
  edge
  [
    source 121
    target 98
    value 2
  ]
  edge
  [
    source 121
    target 124
    value 3
  ]
  edge
  [
    source 121
    target 31
    value 1
  ]
  edge
  [
    source 121
    target 125
    value 2
  ]
  edge
  [
    source 121
    target 20
    value 1
  ]
  edge
  [
    source 121
    target 21
    value 1
  ]
  edge
  [
    source 122
    target 106
    value 1
  ]
  edge
  [
    source 122
    target 121
    value 1
  ]
  edge
  [
    source 122
    target 114
    value 12
  ]
  edge
  [
    source 122
    target 108
    value 1
  ]
  edge
  [
    source 122
    target 115
    value 1
  ]
  edge
  [
    source 122
    target 139
    value 1
  ]
  edge
  [
    source 122
    target 124
    value 1
  ]
  edge
  [
    source 122
    target 205
    value 2
  ]
  edge
  [
    source 123
    target 121
    value 2
  ]
  edge
  [
    source 123
    target 201
    value 1
  ]
  edge
  [
    source 123
    target 84
    value 1
  ]
  edge
  [
    source 123
    target 118
    value 1
  ]
  edge
  [
    source 123
    target 202
    value 5
  ]
  edge
  [
    source 123
    target 198
    value 2
  ]
  edge
  [
    source 123
    target 119
    value 1
  ]
  edge
  [
    source 123
    target 98
    value 2
  ]
  edge
  [
    source 123
    target 203
    value 4
  ]
  edge
  [
    source 123
    target 145
    value 2
  ]
  edge
  [
    source 123
    target 8
    value 1
  ]
  edge
  [
    source 123
    target 103
    value 3
  ]
  edge
  [
    source 123
    target 89
    value 1
  ]
  edge
  [
    source 123
    target 104
    value 1
  ]
  edge
  [
    source 123
    target 200
    value 1
  ]
  edge
  [
    source 124
    target 121
    value 1
  ]
  edge
  [
    source 124
    target 122
    value 2
  ]
  edge
  [
    source 124
    target 1
    value 1
  ]
  edge
  [
    source 124
    target 114
    value 3
  ]
  edge
  [
    source 124
    target 10
    value 4
  ]
  edge
  [
    source 124
    target 107
    value 9
  ]
  edge
  [
    source 124
    target 138
    value 2
  ]
  edge
  [
    source 125
    target 151
    value 1
  ]
  edge
  [
    source 125
    target 154
    value 2
  ]
  edge
  [
    source 125
    target 12
    value 7
  ]
  edge
  [
    source 125
    target 2
    value 9
  ]
  edge
  [
    source 125
    target 84
    value 4
  ]
  edge
  [
    source 125
    target 86
    value 16
  ]
  edge
  [
    source 125
    target 117
    value 3
  ]
  edge
  [
    source 125
    target 118
    value 6
  ]
  edge
  [
    source 125
    target 3
    value 2
  ]
  edge
  [
    source 125
    target 4
    value 1
  ]
  edge
  [
    source 125
    target 119
    value 3
  ]
  edge
  [
    source 125
    target 187
    value 1
  ]
  edge
  [
    source 125
    target 160
    value 1
  ]
  edge
  [
    source 125
    target 232
    value 4
  ]
  edge
  [
    source 125
    target 168
    value 5
  ]
  edge
  [
    source 125
    target 192
    value 7
  ]
  edge
  [
    source 125
    target 169
    value 3
  ]
  edge
  [
    source 125
    target 253
    value 4
  ]
  edge
  [
    source 125
    target 137
    value 4
  ]
  edge
  [
    source 125
    target 184
    value 1
  ]
  edge
  [
    source 125
    target 171
    value 1
  ]
  edge
  [
    source 125
    target 172
    value 3
  ]
  edge
  [
    source 125
    target 42
    value 1
  ]
  edge
  [
    source 125
    target 256
    value 1
  ]
  edge
  [
    source 125
    target 96
    value 5
  ]
  edge
  [
    source 125
    target 90
    value 2
  ]
  edge
  [
    source 125
    target 78
    value 2
  ]
  edge
  [
    source 125
    target 254
    value 1
  ]
  edge
  [
    source 125
    target 262
    value 1
  ]
  edge
  [
    source 125
    target 263
    value 4
  ]
  edge
  [
    source 125
    target 264
    value 1
  ]
  edge
  [
    source 125
    target 265
    value 5
  ]
  edge
  [
    source 125
    target 266
    value 3
  ]
  edge
  [
    source 125
    target 267
    value 2
  ]
  edge
  [
    source 126
    target 127
    value 1
  ]
  edge
  [
    source 126
    target 10
    value 7
  ]
  edge
  [
    source 127
    target 126
    value 5
  ]
  edge
  [
    source 127
    target 113
    value 2
  ]
  edge
  [
    source 127
    target 1
    value 2
  ]
  edge
  [
    source 127
    target 115
    value 3
  ]
  edge
  [
    source 127
    target 5
    value 3
  ]
  edge
  [
    source 127
    target 14
    value 1
  ]
  edge
  [
    source 127
    target 96
    value 1
  ]
  edge
  [
    source 127
    target 39
    value 1
  ]
  edge
  [
    source 128
    target 107
    value 11
  ]
  edge
  [
    source 128
    target 115
    value 1
  ]
  edge
  [
    source 129
    target 63
    value 1
  ]
  edge
  [
    source 129
    target 67
    value 2
  ]
  edge
  [
    source 129
    target 1
    value 1
  ]
  edge
  [
    source 129
    target 114
    value 2
  ]
  edge
  [
    source 129
    target 12
    value 13
  ]
  edge
  [
    source 129
    target 2
    value 18
  ]
  edge
  [
    source 129
    target 84
    value 4
  ]
  edge
  [
    source 129
    target 86
    value 5
  ]
  edge
  [
    source 129
    target 117
    value 6
  ]
  edge
  [
    source 129
    target 118
    value 14
  ]
  edge
  [
    source 129
    target 137
    value 1
  ]
  edge
  [
    source 129
    target 224
    value 1
  ]
  edge
  [
    source 130
    target 106
    value 1
  ]
  edge
  [
    source 130
    target 1
    value 4
  ]
  edge
  [
    source 130
    target 12
    value 2
  ]
  edge
  [
    source 130
    target 84
    value 2
  ]
  edge
  [
    source 130
    target 86
    value 5
  ]
  edge
  [
    source 130
    target 119
    value 1
  ]
  edge
  [
    source 130
    target 213
    value 1
  ]
  edge
  [
    source 130
    target 7
    value 1
  ]
  edge
  [
    source 130
    target 90
    value 1
  ]
  edge
  [
    source 130
    target 47
    value 2
  ]
  edge
  [
    source 130
    target 48
    value 1
  ]
  edge
  [
    source 130
    target 210
    value 2
  ]
  edge
  [
    source 130
    target 211
    value 3
  ]
  edge
  [
    source 130
    target 212
    value 3
  ]
  edge
  [
    source 130
    target 73
    value 2
  ]
  edge
  [
    source 130
    target 74
    value 3
  ]
  edge
  [
    source 130
    target 44
    value 4
  ]
  edge
  [
    source 131
    target 1
    value 1
  ]
  edge
  [
    source 131
    target 12
    value 5
  ]
  edge
  [
    source 131
    target 132
    value 3
  ]
  edge
  [
    source 131
    target 130
    value 5
  ]
  edge
  [
    source 131
    target 93
    value 1
  ]
  edge
  [
    source 132
    target 12
    value 1
  ]
  edge
  [
    source 132
    target 84
    value 2
  ]
  edge
  [
    source 132
    target 86
    value 3
  ]
  edge
  [
    source 132
    target 14
    value 1
  ]
  edge
  [
    source 132
    target 90
    value 1
  ]
  edge
  [
    source 132
    target 47
    value 1
  ]
  edge
  [
    source 132
    target 48
    value 3
  ]
  edge
  [
    source 132
    target 210
    value 1
  ]
  edge
  [
    source 132
    target 72
    value 1
  ]
  edge
  [
    source 132
    target 211
    value 3
  ]
  edge
  [
    source 132
    target 212
    value 2
  ]
  edge
  [
    source 132
    target 74
    value 5
  ]
  edge
  [
    source 132
    target 77
    value 1
  ]
  edge
  [
    source 132
    target 44
    value 4
  ]
  edge
  [
    source 133
    target 114
    value 1
  ]
  edge
  [
    source 133
    target 219
    value 1
  ]
  edge
  [
    source 133
    target 132
    value 1
  ]
  edge
  [
    source 133
    target 214
    value 2
  ]
  edge
  [
    source 133
    target 131
    value 9
  ]
  edge
  [
    source 133
    target 72
    value 4
  ]
  edge
  [
    source 133
    target 173
    value 1
  ]
  edge
  [
    source 133
    target 196
    value 3
  ]
  edge
  [
    source 133
    target 178
    value 1
  ]
  edge
  [
    source 133
    target 179
    value 1
  ]
  edge
  [
    source 133
    target 200
    value 2
  ]
  edge
  [
    source 133
    target 197
    value 1
  ]
  edge
  [
    source 133
    target 44
    value 5
  ]
  edge
  [
    source 134
    target 128
    value 5
  ]
  edge
  [
    source 134
    target 135
    value 2
  ]
  edge
  [
    source 134
    target 28
    value 1
  ]
  edge
  [
    source 134
    target 99
    value 1
  ]
  edge
  [
    source 134
    target 0
    value 3
  ]
  edge
  [
    source 134
    target 14
    value 1
  ]
  edge
  [
    source 134
    target 7
    value 2
  ]
  edge
  [
    source 134
    target 39
    value 1
  ]
  edge
  [
    source 135
    target 105
    value 1
  ]
  edge
  [
    source 135
    target 113
    value 4
  ]
  edge
  [
    source 135
    target 1
    value 7
  ]
  edge
  [
    source 135
    target 114
    value 3
  ]
  edge
  [
    source 135
    target 10
    value 12
  ]
  edge
  [
    source 135
    target 107
    value 6
  ]
  edge
  [
    source 135
    target 138
    value 4
  ]
  edge
  [
    source 135
    target 124
    value 2
  ]
  edge
  [
    source 135
    target 6
    value 1
  ]
  edge
  [
    source 136
    target 1
    value 1
  ]
  edge
  [
    source 136
    target 10
    value 2
  ]
  edge
  [
    source 136
    target 102
    value 1
  ]
  edge
  [
    source 136
    target 135
    value 1
  ]
  edge
  [
    source 136
    target 115
    value 1
  ]
  edge
  [
    source 136
    target 141
    value 2
  ]
  edge
  [
    source 136
    target 138
    value 2
  ]
  edge
  [
    source 136
    target 124
    value 2
  ]
  edge
  [
    source 137
    target 102
    value 3
  ]
  edge
  [
    source 137
    target 201
    value 3
  ]
  edge
  [
    source 137
    target 11
    value 1
  ]
  edge
  [
    source 137
    target 99
    value 1
  ]
  edge
  [
    source 137
    target 12
    value 3
  ]
  edge
  [
    source 137
    target 84
    value 1
  ]
  edge
  [
    source 137
    target 3
    value 8
  ]
  edge
  [
    source 137
    target 4
    value 6
  ]
  edge
  [
    source 137
    target 232
    value 1
  ]
  edge
  [
    source 137
    target 168
    value 3
  ]
  edge
  [
    source 137
    target 192
    value 1
  ]
  edge
  [
    source 137
    target 169
    value 1
  ]
  edge
  [
    source 137
    target 253
    value 2
  ]
  edge
  [
    source 137
    target 185
    value 2
  ]
  edge
  [
    source 137
    target 125
    value 5
  ]
  edge
  [
    source 137
    target 42
    value 2
  ]
  edge
  [
    source 137
    target 13
    value 1
  ]
  edge
  [
    source 137
    target 6
    value 2
  ]
  edge
  [
    source 137
    target 130
    value 1
  ]
  edge
  [
    source 137
    target 103
    value 1
  ]
  edge
  [
    source 137
    target 72
    value 1
  ]
  edge
  [
    source 137
    target 211
    value 1
  ]
  edge
  [
    source 137
    target 212
    value 1
  ]
  edge
  [
    source 137
    target 89
    value 3
  ]
  edge
  [
    source 137
    target 85
    value 2
  ]
  edge
  [
    source 137
    target 104
    value 3
  ]
  edge
  [
    source 137
    target 112
    value 2
  ]
  edge
  [
    source 137
    target 177
    value 1
  ]
  edge
  [
    source 137
    target 133
    value 1
  ]
  edge
  [
    source 137
    target 254
    value 2
  ]
  edge
  [
    source 138
    target 113
    value 2
  ]
  edge
  [
    source 138
    target 122
    value 4
  ]
  edge
  [
    source 138
    target 1
    value 1
  ]
  edge
  [
    source 138
    target 114
    value 1
  ]
  edge
  [
    source 138
    target 10
    value 13
  ]
  edge
  [
    source 138
    target 12
    value 1
  ]
  edge
  [
    source 138
    target 13
    value 2
  ]
  edge
  [
    source 139
    target 105
    value 3
  ]
  edge
  [
    source 139
    target 128
    value 9
  ]
  edge
  [
    source 139
    target 107
    value 2
  ]
  edge
  [
    source 139
    target 108
    value 7
  ]
  edge
  [
    source 139
    target 135
    value 1
  ]
  edge
  [
    source 139
    target 115
    value 2
  ]
  edge
  [
    source 139
    target 110
    value 2
  ]
  edge
  [
    source 139
    target 205
    value 2
  ]
  edge
  [
    source 139
    target 103
    value 1
  ]
  edge
  [
    source 140
    target 113
    value 9
  ]
  edge
  [
    source 140
    target 1
    value 3
  ]
  edge
  [
    source 140
    target 127
    value 1
  ]
  edge
  [
    source 140
    target 141
    value 1
  ]
  edge
  [
    source 141
    target 113
    value 11
  ]
  edge
  [
    source 141
    target 1
    value 3
  ]
  edge
  [
    source 141
    target 149
    value 2
  ]
  edge
  [
    source 141
    target 144
    value 1
  ]
  edge
  [
    source 142
    target 1
    value 1
  ]
  edge
  [
    source 142
    target 114
    value 1
  ]
  edge
  [
    source 142
    target 102
    value 1
  ]
  edge
  [
    source 142
    target 108
    value 1
  ]
  edge
  [
    source 142
    target 157
    value 1
  ]
  edge
  [
    source 142
    target 116
    value 2
  ]
  edge
  [
    source 142
    target 117
    value 3
  ]
  edge
  [
    source 142
    target 202
    value 2
  ]
  edge
  [
    source 142
    target 119
    value 1
  ]
  edge
  [
    source 142
    target 120
    value 1
  ]
  edge
  [
    source 142
    target 95
    value 2
  ]
  edge
  [
    source 142
    target 163
    value 2
  ]
  edge
  [
    source 142
    target 164
    value 1
  ]
  edge
  [
    source 142
    target 169
    value 1
  ]
  edge
  [
    source 142
    target 191
    value 1
  ]
  edge
  [
    source 142
    target 204
    value 2
  ]
  edge
  [
    source 142
    target 148
    value 1
  ]
  edge
  [
    source 142
    target 205
    value 3
  ]
  edge
  [
    source 142
    target 130
    value 1
  ]
  edge
  [
    source 142
    target 87
    value 1
  ]
  edge
  [
    source 142
    target 173
    value 1
  ]
  edge
  [
    source 142
    target 186
    value 3
  ]
  edge
  [
    source 142
    target 181
    value 1
  ]
  edge
  [
    source 142
    target 182
    value 1
  ]
  edge
  [
    source 142
    target 238
    value 4
  ]
  edge
  [
    source 142
    target 245
    value 2
  ]
  edge
  [
    source 142
    target 244
    value 5
  ]
  edge
  [
    source 142
    target 44
    value 3
  ]
  edge
  [
    source 142
    target 44
    value 21
  ]
  edge
  [
    source 143
    target 122
    value 3
  ]
  edge
  [
    source 143
    target 135
    value 2
  ]
  edge
  [
    source 143
    target 109
    value 1
  ]
  edge
  [
    source 143
    target 138
    value 1
  ]
  edge
  [
    source 143
    target 124
    value 2
  ]
  edge
  [
    source 144
    target 141
    value 4
  ]
  edge
  [
    source 144
    target 145
    value 13
  ]
  edge
  [
    source 145
    target 113
    value 6
  ]
  edge
  [
    source 145
    target 144
    value 1
  ]
  edge
  [
    source 145
    target 141
    value 4
  ]
  edge
  [
    source 145
    target 187
    value 1
  ]
  edge
  [
    source 145
    target 219
    value 1
  ]
  edge
  [
    source 145
    target 195
    value 1
  ]
  edge
  [
    source 145
    target 193
    value 1
  ]
  edge
  [
    source 145
    target 191
    value 3
  ]
  edge
  [
    source 145
    target 93
    value 1
  ]
  edge
  [
    source 145
    target 200
    value 1
  ]
  edge
  [
    source 145
    target 39
    value 1
  ]
  edge
  [
    source 146
    target 147
    value 4
  ]
  edge
  [
    source 146
    target 142
    value 1
  ]
  edge
  [
    source 146
    target 148
    value 13
  ]
  edge
  [
    source 147
    target 122
    value 11
  ]
  edge
  [
    source 147
    target 114
    value 1
  ]
  edge
  [
    source 147
    target 150
    value 1
  ]
  edge
  [
    source 147
    target 139
    value 1
  ]
  edge
  [
    source 148
    target 122
    value 7
  ]
  edge
  [
    source 148
    target 147
    value 4
  ]
  edge
  [
    source 148
    target 199
    value 1
  ]
  edge
  [
    source 148
    target 187
    value 1
  ]
  edge
  [
    source 148
    target 219
    value 1
  ]
  edge
  [
    source 148
    target 195
    value 1
  ]
  edge
  [
    source 148
    target 193
    value 1
  ]
  edge
  [
    source 148
    target 142
    value 1
  ]
  edge
  [
    source 148
    target 205
    value 1
  ]
  edge
  [
    source 148
    target 200
    value 1
  ]
  edge
  [
    source 148
    target 39
    value 1
  ]
  edge
  [
    source 149
    target 113
    value 5
  ]
  edge
  [
    source 149
    target 216
    value 1
  ]
  edge
  [
    source 149
    target 140
    value 2
  ]
  edge
  [
    source 149
    target 141
    value 2
  ]
  edge
  [
    source 149
    target 86
    value 2
  ]
  edge
  [
    source 149
    target 117
    value 1
  ]
  edge
  [
    source 149
    target 118
    value 1
  ]
  edge
  [
    source 149
    target 4
    value 1
  ]
  edge
  [
    source 149
    target 202
    value 4
  ]
  edge
  [
    source 149
    target 199
    value 1
  ]
  edge
  [
    source 149
    target 198
    value 1
  ]
  edge
  [
    source 149
    target 123
    value 2
  ]
  edge
  [
    source 149
    target 119
    value 1
  ]
  edge
  [
    source 149
    target 145
    value 1
  ]
  edge
  [
    source 149
    target 215
    value 1
  ]
  edge
  [
    source 149
    target 104
    value 1
  ]
  edge
  [
    source 149
    target 39
    value 1
  ]
  edge
  [
    source 149
    target 39
    value 1
  ]
  edge
  [
    source 150
    target 122
    value 4
  ]
  edge
  [
    source 150
    target 28
    value 2
  ]
  edge
  [
    source 150
    target 146
    value 2
  ]
  edge
  [
    source 150
    target 147
    value 2
  ]
  edge
  [
    source 150
    target 118
    value 1
  ]
  edge
  [
    source 150
    target 202
    value 3
  ]
  edge
  [
    source 150
    target 199
    value 2
  ]
  edge
  [
    source 150
    target 98
    value 1
  ]
  edge
  [
    source 150
    target 191
    value 1
  ]
  edge
  [
    source 150
    target 142
    value 2
  ]
  edge
  [
    source 150
    target 205
    value 1
  ]
  edge
  [
    source 150
    target 87
    value 2
  ]
  edge
  [
    source 150
    target 39
    value 1
  ]
  edge
  [
    source 151
    target 159
    value 1
  ]
  edge
  [
    source 151
    target 200
    value 1
  ]
  edge
  [
    source 151
    target 44
    value 1
  ]
  edge
  [
    source 152
    target 165
    value 1
  ]
  edge
  [
    source 152
    target 249
    value 16
  ]
  edge
  [
    source 152
    target 268
    value 2
  ]
  edge
  [
    source 152
    target 44
    value 15
  ]
  edge
  [
    source 153
    target 161
    value 1
  ]
  edge
  [
    source 153
    target 166
    value 1
  ]
  edge
  [
    source 153
    target 167
    value 1
  ]
  edge
  [
    source 153
    target 249
    value 2
  ]
  edge
  [
    source 153
    target 227
    value 16
  ]
  edge
  [
    source 153
    target 44
    value 15
  ]
  edge
  [
    source 154
    target 160
    value 1
  ]
  edge
  [
    source 154
    target 197
    value 1
  ]
  edge
  [
    source 154
    target 44
    value 15
  ]
  edge
  [
    source 155
    target 161
    value 1
  ]
  edge
  [
    source 155
    target 197
    value 2
  ]
  edge
  [
    source 155
    target 189
    value 16
  ]
  edge
  [
    source 155
    target 44
    value 15
  ]
  edge
  [
    source 156
    target 189
    value 2
  ]
  edge
  [
    source 156
    target 231
    value 16
  ]
  edge
  [
    source 156
    target 44
    value 15
  ]
  edge
  [
    source 157
    target 162
    value 1
  ]
  edge
  [
    source 157
    target 231
    value 2
  ]
  edge
  [
    source 157
    target 234
    value 16
  ]
  edge
  [
    source 157
    target 44
    value 15
  ]
  edge
  [
    source 158
    target 163
    value 1
  ]
  edge
  [
    source 158
    target 234
    value 2
  ]
  edge
  [
    source 158
    target 269
    value 16
  ]
  edge
  [
    source 158
    target 44
    value 15
  ]
  edge
  [
    source 159
    target 200
    value 1
  ]
  edge
  [
    source 159
    target 197
    value 1
  ]
  edge
  [
    source 159
    target 44
    value 10
  ]
  edge
  [
    source 160
    target 219
    value 1
  ]
  edge
  [
    source 160
    target 200
    value 1
  ]
  edge
  [
    source 160
    target 197
    value 23
  ]
  edge
  [
    source 160
    target 189
    value 6
  ]
  edge
  [
    source 160
    target 44
    value 29
  ]
  edge
  [
    source 161
    target 162
    value 1
  ]
  edge
  [
    source 161
    target 233
    value 1
  ]
  edge
  [
    source 161
    target 189
    value 23
  ]
  edge
  [
    source 161
    target 231
    value 6
  ]
  edge
  [
    source 161
    target 44
    value 29
  ]
  edge
  [
    source 162
    target 163
    value 1
  ]
  edge
  [
    source 162
    target 275
    value 1
  ]
  edge
  [
    source 162
    target 231
    value 23
  ]
  edge
  [
    source 162
    target 234
    value 6
  ]
  edge
  [
    source 162
    target 269
    value 1
  ]
  edge
  [
    source 162
    target 44
    value 29
  ]
  edge
  [
    source 163
    target 164
    value 1
  ]
  edge
  [
    source 163
    target 276
    value 1
  ]
  edge
  [
    source 163
    target 269
    value 23
  ]
  edge
  [
    source 163
    target 271
    value 1
  ]
  edge
  [
    source 163
    target 44
    value 29
  ]
  edge
  [
    source 164
    target 165
    value 1
  ]
  edge
  [
    source 164
    target 276
    value 1
  ]
  edge
  [
    source 164
    target 273
    value 23
  ]
  edge
  [
    source 164
    target 268
    value 1
  ]
  edge
  [
    source 164
    target 44
    value 29
  ]
  edge
  [
    source 165
    target 166
    value 1
  ]
  edge
  [
    source 165
    target 97
    value 1
  ]
  edge
  [
    source 165
    target 249
    value 23
  ]
  edge
  [
    source 165
    target 227
    value 1
  ]
  edge
  [
    source 165
    target 44
    value 29
  ]
  edge
  [
    source 166
    target 167
    value 1
  ]
  edge
  [
    source 166
    target 97
    value 1
  ]
  edge
  [
    source 166
    target 227
    value 23
  ]
  edge
  [
    source 166
    target 221
    value 1
  ]
  edge
  [
    source 166
    target 44
    value 29
  ]
  edge
  [
    source 167
    target 97
    value 1
  ]
  edge
  [
    source 167
    target 227
    value 23
  ]
  edge
  [
    source 167
    target 221
    value 1
  ]
  edge
  [
    source 167
    target 44
    value 29
  ]
  edge
  [
    source 168
    target 156
    value 1
  ]
  edge
  [
    source 168
    target 233
    value 4
  ]
  edge
  [
    source 168
    target 275
    value 9
  ]
  edge
  [
    source 168
    target 189
    value 1
  ]
  edge
  [
    source 168
    target 231
    value 9
  ]
  edge
  [
    source 168
    target 234
    value 22
  ]
  edge
  [
    source 168
    target 269
    value 7
  ]
  edge
  [
    source 168
    target 44
    value 22
  ]
  edge
  [
    source 169
    target 270
    value 1
  ]
  edge
  [
    source 169
    target 272
    value 1
  ]
  edge
  [
    source 169
    target 276
    value 4
  ]
  edge
  [
    source 169
    target 277
    value 9
  ]
  edge
  [
    source 169
    target 234
    value 1
  ]
  edge
  [
    source 169
    target 269
    value 9
  ]
  edge
  [
    source 169
    target 271
    value 22
  ]
  edge
  [
    source 169
    target 273
    value 7
  ]
  edge
  [
    source 169
    target 44
    value 22
  ]
  edge
  [
    source 170
    target 12
    value 5
  ]
  edge
  [
    source 170
    target 2
    value 4
  ]
  edge
  [
    source 170
    target 117
    value 4
  ]
  edge
  [
    source 170
    target 118
    value 2
  ]
  edge
  [
    source 170
    target 119
    value 1
  ]
  edge
  [
    source 170
    target 255
    value 1
  ]
  edge
  [
    source 170
    target 207
    value 1
  ]
  edge
  [
    source 170
    target 256
    value 1
  ]
  edge
  [
    source 171
    target 213
    value 22
  ]
  edge
  [
    source 171
    target 137
    value 61
  ]
  edge
  [
    source 171
    target 185
    value 1
  ]
  edge
  [
    source 171
    target 125
    value 2
  ]
  edge
  [
    source 171
    target 217
    value 1
  ]
  edge
  [
    source 171
    target 42
    value 2
  ]
  edge
  [
    source 171
    target 246
    value 1
  ]
  edge
  [
    source 171
    target 190
    value 4
  ]
  edge
  [
    source 172
    target 201
    value 1
  ]
  edge
  [
    source 172
    target 151
    value 1
  ]
  edge
  [
    source 172
    target 154
    value 2
  ]
  edge
  [
    source 172
    target 12
    value 8
  ]
  edge
  [
    source 172
    target 2
    value 10
  ]
  edge
  [
    source 172
    target 84
    value 9
  ]
  edge
  [
    source 172
    target 86
    value 6
  ]
  edge
  [
    source 172
    target 117
    value 6
  ]
  edge
  [
    source 172
    target 118
    value 1
  ]
  edge
  [
    source 172
    target 3
    value 3
  ]
  edge
  [
    source 172
    target 4
    value 1
  ]
  edge
  [
    source 172
    target 187
    value 1
  ]
  edge
  [
    source 172
    target 160
    value 1
  ]
  edge
  [
    source 172
    target 232
    value 4
  ]
  edge
  [
    source 172
    target 168
    value 5
  ]
  edge
  [
    source 172
    target 192
    value 7
  ]
  edge
  [
    source 172
    target 169
    value 3
  ]
  edge
  [
    source 172
    target 253
    value 4
  ]
  edge
  [
    source 172
    target 137
    value 4
  ]
  edge
  [
    source 172
    target 129
    value 1
  ]
  edge
  [
    source 172
    target 170
    value 1
  ]
  edge
  [
    source 172
    target 185
    value 1
  ]
  edge
  [
    source 172
    target 125
    value 1
  ]
  edge
  [
    source 172
    target 42
    value 1
  ]
  edge
  [
    source 172
    target 220
    value 1
  ]
  edge
  [
    source 172
    target 96
    value 4
  ]
  edge
  [
    source 172
    target 79
    value 1
  ]
  edge
  [
    source 172
    target 254
    value 1
  ]
  edge
  [
    source 172
    target 262
    value 1
  ]
  edge
  [
    source 172
    target 263
    value 4
  ]
  edge
  [
    source 172
    target 264
    value 1
  ]
  edge
  [
    source 172
    target 265
    value 5
  ]
  edge
  [
    source 172
    target 266
    value 3
  ]
  edge
  [
    source 172
    target 267
    value 2
  ]
  edge
  [
    source 173
    target 178
    value 1
  ]
  edge
  [
    source 174
    target 190
    value 1
  ]
  edge
  [
    source 175
    target 277
    value 8
  ]
  edge
  [
    source 175
    target 176
    value 1
  ]
  edge
  [
    source 175
    target 44
    value 10
  ]
  edge
  [
    source 176
    target 97
    value 8
  ]
  edge
  [
    source 176
    target 177
    value 1
  ]
  edge
  [
    source 176
    target 249
    value 3
  ]
  edge
  [
    source 176
    target 227
    value 2
  ]
  edge
  [
    source 176
    target 44
    value 10
  ]
  edge
  [
    source 177
    target 153
    value 2
  ]
  edge
  [
    source 177
    target 166
    value 3
  ]
  edge
  [
    source 177
    target 167
    value 5
  ]
  edge
  [
    source 177
    target 253
    value 4
  ]
  edge
  [
    source 177
    target 97
    value 2
  ]
  edge
  [
    source 177
    target 170
    value 2
  ]
  edge
  [
    source 177
    target 125
    value 2
  ]
  edge
  [
    source 177
    target 172
    value 3
  ]
  edge
  [
    source 177
    target 176
    value 1
  ]
  edge
  [
    source 177
    target 221
    value 2
  ]
  edge
  [
    source 177
    target 183
    value 11
  ]
  edge
  [
    source 177
    target 44
    value 14
  ]
  edge
  [
    source 178
    target 219
    value 8
  ]
  edge
  [
    source 178
    target 179
    value 1
  ]
  edge
  [
    source 178
    target 200
    value 1
  ]
  edge
  [
    source 178
    target 197
    value 3
  ]
  edge
  [
    source 178
    target 44
    value 10
  ]
  edge
  [
    source 179
    target 219
    value 18
  ]
  edge
  [
    source 179
    target 233
    value 11
  ]
  edge
  [
    source 179
    target 180
    value 1
  ]
  edge
  [
    source 179
    target 197
    value 3
  ]
  edge
  [
    source 179
    target 189
    value 2
  ]
  edge
  [
    source 179
    target 44
    value 31
  ]
  edge
  [
    source 180
    target 233
    value 8
  ]
  edge
  [
    source 180
    target 181
    value 1
  ]
  edge
  [
    source 180
    target 231
    value 1
  ]
  edge
  [
    source 180
    target 44
    value 10
  ]
  edge
  [
    source 181
    target 275
    value 8
  ]
  edge
  [
    source 181
    target 182
    value 1
  ]
  edge
  [
    source 181
    target 231
    value 3
  ]
  edge
  [
    source 181
    target 234
    value 2
  ]
  edge
  [
    source 181
    target 44
    value 10
  ]
  edge
  [
    source 182
    target 275
    value 8
  ]
  edge
  [
    source 182
    target 188
    value 1
  ]
  edge
  [
    source 182
    target 44
    value 10
  ]
  edge
  [
    source 183
    target 177
    value 1
  ]
  edge
  [
    source 183
    target 44
    value 8
  ]
  edge
  [
    source 184
    target 12
    value 3
  ]
  edge
  [
    source 184
    target 2
    value 7
  ]
  edge
  [
    source 184
    target 117
    value 1
  ]
  edge
  [
    source 184
    target 118
    value 3
  ]
  edge
  [
    source 184
    target 98
    value 1
  ]
  edge
  [
    source 184
    target 194
    value 1
  ]
  edge
  [
    source 184
    target 172
    value 3
  ]
  edge
  [
    source 184
    target 42
    value 1
  ]
  edge
  [
    source 184
    target 256
    value 1
  ]
  edge
  [
    source 185
    target 218
    value 22
  ]
  edge
  [
    source 185
    target 137
    value 61
  ]
  edge
  [
    source 185
    target 171
    value 1
  ]
  edge
  [
    source 185
    target 172
    value 2
  ]
  edge
  [
    source 185
    target 217
    value 1
  ]
  edge
  [
    source 185
    target 42
    value 2
  ]
  edge
  [
    source 185
    target 246
    value 1
  ]
  edge
  [
    source 185
    target 190
    value 4
  ]
  edge
  [
    source 186
    target 190
    value 1
  ]
  edge
  [
    source 187
    target 151
    value 1
  ]
  edge
  [
    source 187
    target 4
    value 1
  ]
  edge
  [
    source 187
    target 199
    value 1
  ]
  edge
  [
    source 187
    target 160
    value 1
  ]
  edge
  [
    source 187
    target 219
    value 1
  ]
  edge
  [
    source 187
    target 97
    value 2
  ]
  edge
  [
    source 187
    target 111
    value 1
  ]
  edge
  [
    source 187
    target 220
    value 1
  ]
  edge
  [
    source 187
    target 173
    value 5
  ]
  edge
  [
    source 187
    target 174
    value 7
  ]
  edge
  [
    source 187
    target 221
    value 3
  ]
  edge
  [
    source 187
    target 44
    value 6
  ]
  edge
  [
    source 188
    target 276
    value 8
  ]
  edge
  [
    source 188
    target 279
    value 1
  ]
  edge
  [
    source 188
    target 269
    value 3
  ]
  edge
  [
    source 188
    target 271
    value 2
  ]
  edge
  [
    source 188
    target 44
    value 10
  ]
  edge
  [
    source 189
    target 155
    value 2
  ]
  edge
  [
    source 189
    target 237
    value 2
  ]
  edge
  [
    source 189
    target 44
    value 25
  ]
  edge
  [
    source 191
    target 113
    value 2
  ]
  edge
  [
    source 191
    target 102
    value 2
  ]
  edge
  [
    source 191
    target 108
    value 1
  ]
  edge
  [
    source 191
    target 157
    value 1
  ]
  edge
  [
    source 191
    target 116
    value 1
  ]
  edge
  [
    source 191
    target 109
    value 2
  ]
  edge
  [
    source 191
    target 146
    value 1
  ]
  edge
  [
    source 191
    target 141
    value 1
  ]
  edge
  [
    source 191
    target 117
    value 3
  ]
  edge
  [
    source 191
    target 202
    value 6
  ]
  edge
  [
    source 191
    target 119
    value 2
  ]
  edge
  [
    source 191
    target 120
    value 2
  ]
  edge
  [
    source 191
    target 110
    value 2
  ]
  edge
  [
    source 191
    target 163
    value 1
  ]
  edge
  [
    source 191
    target 142
    value 3
  ]
  edge
  [
    source 191
    target 215
    value 3
  ]
  edge
  [
    source 191
    target 132
    value 2
  ]
  edge
  [
    source 191
    target 173
    value 1
  ]
  edge
  [
    source 191
    target 186
    value 3
  ]
  edge
  [
    source 191
    target 182
    value 1
  ]
  edge
  [
    source 191
    target 238
    value 2
  ]
  edge
  [
    source 191
    target 244
    value 10
  ]
  edge
  [
    source 191
    target 44
    value 3
  ]
  edge
  [
    source 191
    target 44
    value 22
  ]
  edge
  [
    source 192
    target 157
    value 1
  ]
  edge
  [
    source 192
    target 158
    value 1
  ]
  edge
  [
    source 192
    target 275
    value 4
  ]
  edge
  [
    source 192
    target 276
    value 9
  ]
  edge
  [
    source 192
    target 231
    value 1
  ]
  edge
  [
    source 192
    target 234
    value 9
  ]
  edge
  [
    source 192
    target 269
    value 22
  ]
  edge
  [
    source 192
    target 271
    value 7
  ]
  edge
  [
    source 192
    target 44
    value 22
  ]
  edge
  [
    source 193
    target 1
    value 1
  ]
  edge
  [
    source 193
    target 114
    value 3
  ]
  edge
  [
    source 193
    target 12
    value 5
  ]
  edge
  [
    source 193
    target 2
    value 7
  ]
  edge
  [
    source 193
    target 84
    value 1
  ]
  edge
  [
    source 193
    target 213
    value 2
  ]
  edge
  [
    source 193
    target 218
    value 1
  ]
  edge
  [
    source 193
    target 195
    value 1
  ]
  edge
  [
    source 193
    target 14
    value 1
  ]
  edge
  [
    source 193
    target 8
    value 5
  ]
  edge
  [
    source 193
    target 9
    value 5
  ]
  edge
  [
    source 193
    target 214
    value 2
  ]
  edge
  [
    source 193
    target 210
    value 4
  ]
  edge
  [
    source 194
    target 12
    value 7
  ]
  edge
  [
    source 194
    target 2
    value 7
  ]
  edge
  [
    source 194
    target 118
    value 23
  ]
  edge
  [
    source 194
    target 226
    value 1
  ]
  edge
  [
    source 194
    target 170
    value 1
  ]
  edge
  [
    source 194
    target 204
    value 1
  ]
  edge
  [
    source 195
    target 1
    value 2
  ]
  edge
  [
    source 195
    target 114
    value 5
  ]
  edge
  [
    source 195
    target 213
    value 7
  ]
  edge
  [
    source 195
    target 218
    value 7
  ]
  edge
  [
    source 195
    target 187
    value 2
  ]
  edge
  [
    source 195
    target 166
    value 2
  ]
  edge
  [
    source 195
    target 97
    value 1
  ]
  edge
  [
    source 195
    target 97
    value 3
  ]
  edge
  [
    source 195
    target 193
    value 5
  ]
  edge
  [
    source 195
    target 250
    value 1
  ]
  edge
  [
    source 195
    target 111
    value 2
  ]
  edge
  [
    source 195
    target 8
    value 2
  ]
  edge
  [
    source 195
    target 9
    value 3
  ]
  edge
  [
    source 195
    target 59
    value 1
  ]
  edge
  [
    source 195
    target 64
    value 1
  ]
  edge
  [
    source 195
    target 214
    value 2
  ]
  edge
  [
    source 195
    target 210
    value 4
  ]
  edge
  [
    source 195
    target 85
    value 1
  ]
  edge
  [
    source 195
    target 44
    value 5
  ]
  edge
  [
    source 195
    target 190
    value 5
  ]
  edge
  [
    source 196
    target 219
    value 8
  ]
  edge
  [
    source 196
    target 178
    value 1
  ]
  edge
  [
    source 196
    target 133
    value 1
  ]
  edge
  [
    source 196
    target 200
    value 3
  ]
  edge
  [
    source 196
    target 44
    value 10
  ]
  edge
  [
    source 197
    target 155
    value 2
  ]
  edge
  [
    source 197
    target 237
    value 2
  ]
  edge
  [
    source 197
    target 44
    value 8
  ]
  edge
  [
    source 198
    target 105
    value 3
  ]
  edge
  [
    source 198
    target 86
    value 2
  ]
  edge
  [
    source 198
    target 117
    value 1
  ]
  edge
  [
    source 198
    target 199
    value 5
  ]
  edge
  [
    source 198
    target 123
    value 2
  ]
  edge
  [
    source 198
    target 119
    value 4
  ]
  edge
  [
    source 198
    target 98
    value 1
  ]
  edge
  [
    source 198
    target 110
    value 1
  ]
  edge
  [
    source 198
    target 111
    value 1
  ]
  edge
  [
    source 198
    target 148
    value 2
  ]
  edge
  [
    source 198
    target 130
    value 1
  ]
  edge
  [
    source 198
    target 103
    value 3
  ]
  edge
  [
    source 198
    target 85
    value 2
  ]
  edge
  [
    source 198
    target 112
    value 2
  ]
  edge
  [
    source 198
    target 200
    value 1
  ]
  edge
  [
    source 199
    target 84
    value 1
  ]
  edge
  [
    source 199
    target 86
    value 8
  ]
  edge
  [
    source 199
    target 202
    value 4
  ]
  edge
  [
    source 199
    target 226
    value 2
  ]
  edge
  [
    source 199
    target 123
    value 5
  ]
  edge
  [
    source 199
    target 119
    value 4
  ]
  edge
  [
    source 199
    target 187
    value 1
  ]
  edge
  [
    source 199
    target 142
    value 2
  ]
  edge
  [
    source 199
    target 185
    value 1
  ]
  edge
  [
    source 199
    target 145
    value 1
  ]
  edge
  [
    source 199
    target 227
    value 1
  ]
  edge
  [
    source 199
    target 44
    value 2
  ]
  edge
  [
    source 200
    target 219
    value 1
  ]
  edge
  [
    source 200
    target 196
    value 2
  ]
  edge
  [
    source 200
    target 44
    value 8
  ]
  edge
  [
    source 201
    target 12
    value 5
  ]
  edge
  [
    source 201
    target 2
    value 3
  ]
  edge
  [
    source 201
    target 84
    value 4
  ]
  edge
  [
    source 201
    target 86
    value 5
  ]
  edge
  [
    source 201
    target 117
    value 1
  ]
  edge
  [
    source 201
    target 118
    value 1
  ]
  edge
  [
    source 201
    target 119
    value 1
  ]
  edge
  [
    source 201
    target 0
    value 2
  ]
  edge
  [
    source 201
    target 5
    value 2
  ]
  edge
  [
    source 201
    target 137
    value 1
  ]
  edge
  [
    source 201
    target 125
    value 1
  ]
  edge
  [
    source 201
    target 172
    value 2
  ]
  edge
  [
    source 201
    target 203
    value 1
  ]
  edge
  [
    source 201
    target 13
    value 3
  ]
  edge
  [
    source 201
    target 6
    value 2
  ]
  edge
  [
    source 201
    target 65
    value 1
  ]
  edge
  [
    source 202
    target 84
    value 5
  ]
  edge
  [
    source 202
    target 199
    value 5
  ]
  edge
  [
    source 202
    target 226
    value 2
  ]
  edge
  [
    source 202
    target 123
    value 6
  ]
  edge
  [
    source 202
    target 98
    value 4
  ]
  edge
  [
    source 202
    target 187
    value 1
  ]
  edge
  [
    source 202
    target 191
    value 1
  ]
  edge
  [
    source 202
    target 171
    value 1
  ]
  edge
  [
    source 202
    target 145
    value 2
  ]
  edge
  [
    source 202
    target 133
    value 1
  ]
  edge
  [
    source 202
    target 227
    value 1
  ]
  edge
  [
    source 202
    target 44
    value 2
  ]
  edge
  [
    source 203
    target 101
    value 1
  ]
  edge
  [
    source 203
    target 201
    value 1
  ]
  edge
  [
    source 203
    target 12
    value 2
  ]
  edge
  [
    source 203
    target 2
    value 2
  ]
  edge
  [
    source 203
    target 84
    value 5
  ]
  edge
  [
    source 203
    target 86
    value 6
  ]
  edge
  [
    source 203
    target 118
    value 2
  ]
  edge
  [
    source 203
    target 4
    value 1
  ]
  edge
  [
    source 203
    target 123
    value 2
  ]
  edge
  [
    source 203
    target 187
    value 4
  ]
  edge
  [
    source 203
    target 233
    value 1
  ]
  edge
  [
    source 203
    target 193
    value 2
  ]
  edge
  [
    source 203
    target 172
    value 4
  ]
  edge
  [
    source 203
    target 148
    value 1
  ]
  edge
  [
    source 203
    target 8
    value 2
  ]
  edge
  [
    source 203
    target 190
    value 3
  ]
  edge
  [
    source 204
    target 2
    value 6
  ]
  edge
  [
    source 204
    target 86
    value 3
  ]
  edge
  [
    source 204
    target 118
    value 6
  ]
  edge
  [
    source 204
    target 4
    value 3
  ]
  edge
  [
    source 204
    target 199
    value 1
  ]
  edge
  [
    source 204
    target 226
    value 1
  ]
  edge
  [
    source 204
    target 119
    value 2
  ]
  edge
  [
    source 204
    target 98
    value 7
  ]
  edge
  [
    source 204
    target 187
    value 4
  ]
  edge
  [
    source 204
    target 225
    value 2
  ]
  edge
  [
    source 204
    target 95
    value 3
  ]
  edge
  [
    source 204
    target 219
    value 2
  ]
  edge
  [
    source 204
    target 233
    value 1
  ]
  edge
  [
    source 204
    target 194
    value 3
  ]
  edge
  [
    source 204
    target 172
    value 2
  ]
  edge
  [
    source 204
    target 207
    value 5
  ]
  edge
  [
    source 204
    target 252
    value 2
  ]
  edge
  [
    source 204
    target 220
    value 3
  ]
  edge
  [
    source 204
    target 205
    value 1
  ]
  edge
  [
    source 204
    target 238
    value 2
  ]
  edge
  [
    source 204
    target 245
    value 1
  ]
  edge
  [
    source 204
    target 221
    value 1
  ]
  edge
  [
    source 204
    target 189
    value 2
  ]
  edge
  [
    source 204
    target 231
    value 4
  ]
  edge
  [
    source 204
    target 44
    value 7
  ]
  edge
  [
    source 204
    target 190
    value 2
  ]
  edge
  [
    source 205
    target 109
    value 2
  ]
  edge
  [
    source 205
    target 84
    value 1
  ]
  edge
  [
    source 205
    target 86
    value 16
  ]
  edge
  [
    source 205
    target 202
    value 1
  ]
  edge
  [
    source 205
    target 198
    value 1
  ]
  edge
  [
    source 205
    target 119
    value 1
  ]
  edge
  [
    source 205
    target 98
    value 2
  ]
  edge
  [
    source 205
    target 142
    value 1
  ]
  edge
  [
    source 205
    target 125
    value 1
  ]
  edge
  [
    source 205
    target 172
    value 1
  ]
  edge
  [
    source 205
    target 111
    value 4
  ]
  edge
  [
    source 205
    target 130
    value 4
  ]
  edge
  [
    source 205
    target 33
    value 1
  ]
  edge
  [
    source 206
    target 67
    value 3
  ]
  edge
  [
    source 206
    target 84
    value 6
  ]
  edge
  [
    source 206
    target 86
    value 5
  ]
  edge
  [
    source 206
    target 98
    value 1
  ]
  edge
  [
    source 206
    target 225
    value 3
  ]
  edge
  [
    source 206
    target 95
    value 4
  ]
  edge
  [
    source 206
    target 159
    value 1
  ]
  edge
  [
    source 206
    target 159
    value 1
  ]
  edge
  [
    source 206
    target 125
    value 4
  ]
  edge
  [
    source 206
    target 172
    value 6
  ]
  edge
  [
    source 206
    target 42
    value 3
  ]
  edge
  [
    source 206
    target 96
    value 1
  ]
  edge
  [
    source 206
    target 78
    value 1
  ]
  edge
  [
    source 207
    target 2
    value 6
  ]
  edge
  [
    source 207
    target 86
    value 3
  ]
  edge
  [
    source 207
    target 118
    value 6
  ]
  edge
  [
    source 207
    target 4
    value 3
  ]
  edge
  [
    source 207
    target 199
    value 1
  ]
  edge
  [
    source 207
    target 226
    value 1
  ]
  edge
  [
    source 207
    target 119
    value 3
  ]
  edge
  [
    source 207
    target 98
    value 7
  ]
  edge
  [
    source 207
    target 187
    value 4
  ]
  edge
  [
    source 207
    target 95
    value 3
  ]
  edge
  [
    source 207
    target 219
    value 2
  ]
  edge
  [
    source 207
    target 233
    value 1
  ]
  edge
  [
    source 207
    target 194
    value 3
  ]
  edge
  [
    source 207
    target 172
    value 2
  ]
  edge
  [
    source 207
    target 204
    value 4
  ]
  edge
  [
    source 207
    target 252
    value 2
  ]
  edge
  [
    source 207
    target 256
    value 3
  ]
  edge
  [
    source 207
    target 205
    value 1
  ]
  edge
  [
    source 207
    target 238
    value 2
  ]
  edge
  [
    source 207
    target 245
    value 1
  ]
  edge
  [
    source 207
    target 221
    value 1
  ]
  edge
  [
    source 207
    target 189
    value 2
  ]
  edge
  [
    source 207
    target 231
    value 4
  ]
  edge
  [
    source 207
    target 44
    value 7
  ]
  edge
  [
    source 207
    target 190
    value 2
  ]
  edge
  [
    source 208
    target 101
    value 1
  ]
  edge
  [
    source 208
    target 126
    value 5
  ]
  edge
  [
    source 208
    target 10
    value 1
  ]
  edge
  [
    source 208
    target 102
    value 10
  ]
  edge
  [
    source 208
    target 135
    value 4
  ]
  edge
  [
    source 208
    target 140
    value 1
  ]
  edge
  [
    source 208
    target 120
    value 1
  ]
  edge
  [
    source 209
    target 13
    value 2
  ]
  edge
  [
    source 209
    target 6
    value 2
  ]
  edge
  [
    source 209
    target 23
    value 1
  ]
  edge
  [
    source 209
    target 48
    value 1
  ]
  edge
  [
    source 209
    target 46
    value 1
  ]
  edge
  [
    source 209
    target 64
    value 1
  ]
  edge
  [
    source 209
    target 131
    value 2
  ]
  edge
  [
    source 209
    target 25
    value 2
  ]
  edge
  [
    source 209
    target 73
    value 2
  ]
  edge
  [
    source 209
    target 75
    value 2
  ]
  edge
  [
    source 209
    target 44
    value 5
  ]
  edge
  [
    source 210
    target 114
    value 1
  ]
  edge
  [
    source 210
    target 213
    value 1
  ]
  edge
  [
    source 210
    target 218
    value 3
  ]
  edge
  [
    source 210
    target 48
    value 2
  ]
  edge
  [
    source 210
    target 44
    value 4
  ]
  edge
  [
    source 211
    target 12
    value 15
  ]
  edge
  [
    source 211
    target 31
    value 1
  ]
  edge
  [
    source 211
    target 132
    value 2
  ]
  edge
  [
    source 211
    target 130
    value 9
  ]
  edge
  [
    source 211
    target 210
    value 2
  ]
  edge
  [
    source 211
    target 74
    value 6
  ]
  edge
  [
    source 212
    target 2
    value 11
  ]
  edge
  [
    source 212
    target 132
    value 4
  ]
  edge
  [
    source 212
    target 130
    value 1
  ]
  edge
  [
    source 212
    target 73
    value 6
  ]
  edge
  [
    source 213
    target 84
    value 1
  ]
  edge
  [
    source 213
    target 3
    value 2
  ]
  edge
  [
    source 213
    target 4
    value 1
  ]
  edge
  [
    source 213
    target 206
    value 1
  ]
  edge
  [
    source 213
    target 137
    value 1
  ]
  edge
  [
    source 213
    target 185
    value 4
  ]
  edge
  [
    source 213
    target 217
    value 1
  ]
  edge
  [
    source 213
    target 148
    value 1
  ]
  edge
  [
    source 213
    target 132
    value 2
  ]
  edge
  [
    source 213
    target 130
    value 1
  ]
  edge
  [
    source 213
    target 72
    value 1
  ]
  edge
  [
    source 213
    target 37
    value 1
  ]
  edge
  [
    source 213
    target 190
    value 5
  ]
  edge
  [
    source 214
    target 1
    value 1
  ]
  edge
  [
    source 214
    target 213
    value 1
  ]
  edge
  [
    source 214
    target 218
    value 4
  ]
  edge
  [
    source 214
    target 47
    value 5
  ]
  edge
  [
    source 214
    target 48
    value 1
  ]
  edge
  [
    source 214
    target 87
    value 1
  ]
  edge
  [
    source 214
    target 44
    value 5
  ]
  edge
  [
    source 215
    target 216
    value 2
  ]
  edge
  [
    source 215
    target 84
    value 10
  ]
  edge
  [
    source 215
    target 86
    value 1
  ]
  edge
  [
    source 215
    target 123
    value 1
  ]
  edge
  [
    source 215
    target 98
    value 2
  ]
  edge
  [
    source 215
    target 203
    value 3
  ]
  edge
  [
    source 215
    target 132
    value 2
  ]
  edge
  [
    source 215
    target 130
    value 1
  ]
  edge
  [
    source 216
    target 118
    value 1
  ]
  edge
  [
    source 216
    target 3
    value 1
  ]
  edge
  [
    source 216
    target 225
    value 5
  ]
  edge
  [
    source 216
    target 71
    value 3
  ]
  edge
  [
    source 216
    target 15
    value 1
  ]
  edge
  [
    source 216
    target 125
    value 4
  ]
  edge
  [
    source 216
    target 172
    value 2
  ]
  edge
  [
    source 216
    target 35
    value 1
  ]
  edge
  [
    source 216
    target 93
    value 1
  ]
  edge
  [
    source 216
    target 239
    value 1
  ]
  edge
  [
    source 217
    target 213
    value 11
  ]
  edge
  [
    source 217
    target 206
    value 1
  ]
  edge
  [
    source 217
    target 137
    value 3
  ]
  edge
  [
    source 217
    target 171
    value 10
  ]
  edge
  [
    source 217
    target 125
    value 2
  ]
  edge
  [
    source 217
    target 42
    value 2
  ]
  edge
  [
    source 217
    target 190
    value 1
  ]
  edge
  [
    source 218
    target 137
    value 1
  ]
  edge
  [
    source 218
    target 171
    value 4
  ]
  edge
  [
    source 218
    target 217
    value 1
  ]
  edge
  [
    source 218
    target 203
    value 1
  ]
  edge
  [
    source 218
    target 145
    value 1
  ]
  edge
  [
    source 218
    target 132
    value 3
  ]
  edge
  [
    source 218
    target 130
    value 3
  ]
  edge
  [
    source 218
    target 131
    value 1
  ]
  edge
  [
    source 218
    target 85
    value 1
  ]
  edge
  [
    source 218
    target 73
    value 1
  ]
  edge
  [
    source 218
    target 74
    value 2
  ]
  edge
  [
    source 218
    target 75
    value 1
  ]
  edge
  [
    source 218
    target 190
    value 5
  ]
  edge
  [
    source 219
    target 159
    value 2
  ]
  edge
  [
    source 219
    target 200
    value 1
  ]
  edge
  [
    source 219
    target 197
    value 1
  ]
  edge
  [
    source 219
    target 44
    value 29
  ]
  edge
  [
    source 220
    target 2
    value 1
  ]
  edge
  [
    source 220
    target 118
    value 1
  ]
  edge
  [
    source 220
    target 119
    value 1
  ]
  edge
  [
    source 220
    target 172
    value 1
  ]
  edge
  [
    source 220
    target 252
    value 3
  ]
  edge
  [
    source 220
    target 256
    value 1
  ]
  edge
  [
    source 220
    target 177
    value 1
  ]
  edge
  [
    source 221
    target 177
    value 1
  ]
  edge
  [
    source 221
    target 44
    value 8
  ]
  edge
  [
    source 222
    target 72
    value 3
  ]
  edge
  [
    source 222
    target 112
    value 5
  ]
  edge
  [
    source 223
    target 131
    value 5
  ]
  edge
  [
    source 223
    target 104
    value 6
  ]
  edge
  [
    source 224
    target 67
    value 2
  ]
  edge
  [
    source 224
    target 114
    value 1
  ]
  edge
  [
    source 224
    target 12
    value 10
  ]
  edge
  [
    source 224
    target 2
    value 4
  ]
  edge
  [
    source 224
    target 84
    value 4
  ]
  edge
  [
    source 224
    target 86
    value 2
  ]
  edge
  [
    source 224
    target 117
    value 10
  ]
  edge
  [
    source 224
    target 118
    value 2
  ]
  edge
  [
    source 224
    target 3
    value 3
  ]
  edge
  [
    source 224
    target 4
    value 2
  ]
  edge
  [
    source 224
    target 137
    value 1
  ]
  edge
  [
    source 224
    target 129
    value 1
  ]
  edge
  [
    source 224
    target 125
    value 2
  ]
  edge
  [
    source 224
    target 133
    value 1
  ]
  edge
  [
    source 224
    target 190
    value 3
  ]
  edge
  [
    source 225
    target 63
    value 4
  ]
  edge
  [
    source 225
    target 2
    value 2
  ]
  edge
  [
    source 225
    target 198
    value 1
  ]
  edge
  [
    source 225
    target 98
    value 1
  ]
  edge
  [
    source 225
    target 191
    value 4
  ]
  edge
  [
    source 225
    target 125
    value 2
  ]
  edge
  [
    source 225
    target 207
    value 1
  ]
  edge
  [
    source 225
    target 204
    value 2
  ]
  edge
  [
    source 225
    target 131
    value 2
  ]
  edge
  [
    source 225
    target 56
    value 1
  ]
  edge
  [
    source 225
    target 39
    value 1
  ]
  edge
  [
    source 226
    target 12
    value 3
  ]
  edge
  [
    source 226
    target 2
    value 1
  ]
  edge
  [
    source 226
    target 84
    value 4
  ]
  edge
  [
    source 226
    target 117
    value 1
  ]
  edge
  [
    source 226
    target 118
    value 1
  ]
  edge
  [
    source 226
    target 4
    value 1
  ]
  edge
  [
    source 226
    target 202
    value 1
  ]
  edge
  [
    source 226
    target 98
    value 1
  ]
  edge
  [
    source 226
    target 166
    value 1
  ]
  edge
  [
    source 226
    target 166
    value 1
  ]
  edge
  [
    source 226
    target 195
    value 1
  ]
  edge
  [
    source 226
    target 228
    value 2
  ]
  edge
  [
    source 226
    target 229
    value 1
  ]
  edge
  [
    source 226
    target 125
    value 1
  ]
  edge
  [
    source 226
    target 172
    value 1
  ]
  edge
  [
    source 226
    target 207
    value 2
  ]
  edge
  [
    source 226
    target 204
    value 2
  ]
  edge
  [
    source 226
    target 203
    value 1
  ]
  edge
  [
    source 226
    target 111
    value 1
  ]
  edge
  [
    source 226
    target 145
    value 1
  ]
  edge
  [
    source 226
    target 148
    value 1
  ]
  edge
  [
    source 226
    target 176
    value 1
  ]
  edge
  [
    source 226
    target 176
    value 1
  ]
  edge
  [
    source 226
    target 190
    value 1
  ]
  edge
  [
    source 226
    target 190
    value 1
  ]
  edge
  [
    source 227
    target 44
    value 8
  ]
  edge
  [
    source 228
    target 118
    value 1
  ]
  edge
  [
    source 228
    target 202
    value 3
  ]
  edge
  [
    source 228
    target 226
    value 5
  ]
  edge
  [
    source 228
    target 198
    value 1
  ]
  edge
  [
    source 228
    target 123
    value 1
  ]
  edge
  [
    source 228
    target 166
    value 1
  ]
  edge
  [
    source 228
    target 137
    value 2
  ]
  edge
  [
    source 228
    target 229
    value 5
  ]
  edge
  [
    source 228
    target 255
    value 5
  ]
  edge
  [
    source 228
    target 257
    value 4
  ]
  edge
  [
    source 228
    target 145
    value 2
  ]
  edge
  [
    source 229
    target 226
    value 3
  ]
  edge
  [
    source 229
    target 123
    value 1
  ]
  edge
  [
    source 229
    target 137
    value 2
  ]
  edge
  [
    source 229
    target 228
    value 6
  ]
  edge
  [
    source 229
    target 255
    value 1
  ]
  edge
  [
    source 229
    target 257
    value 5
  ]
  edge
  [
    source 229
    target 145
    value 2
  ]
  edge
  [
    source 230
    target 151
    value 1
  ]
  edge
  [
    source 230
    target 154
    value 1
  ]
  edge
  [
    source 230
    target 219
    value 4
  ]
  edge
  [
    source 230
    target 200
    value 1
  ]
  edge
  [
    source 230
    target 197
    value 9
  ]
  edge
  [
    source 230
    target 189
    value 22
  ]
  edge
  [
    source 230
    target 231
    value 7
  ]
  edge
  [
    source 230
    target 44
    value 22
  ]
  edge
  [
    source 231
    target 44
    value 25
  ]
  edge
  [
    source 232
    target 155
    value 1
  ]
  edge
  [
    source 232
    target 219
    value 1
  ]
  edge
  [
    source 232
    target 233
    value 4
  ]
  edge
  [
    source 232
    target 197
    value 1
  ]
  edge
  [
    source 232
    target 189
    value 9
  ]
  edge
  [
    source 232
    target 231
    value 22
  ]
  edge
  [
    source 232
    target 234
    value 7
  ]
  edge
  [
    source 232
    target 44
    value 22
  ]
  edge
  [
    source 233
    target 161
    value 2
  ]
  edge
  [
    source 233
    target 189
    value 1
  ]
  edge
  [
    source 233
    target 231
    value 1
  ]
  edge
  [
    source 233
    target 44
    value 29
  ]
  edge
  [
    source 234
    target 44
    value 25
  ]
  edge
  [
    source 235
    target 211
    value 3
  ]
  edge
  [
    source 235
    target 85
    value 2
  ]
  edge
  [
    source 235
    target 77
    value 1
  ]
  edge
  [
    source 236
    target 36
    value 1
  ]
  edge
  [
    source 236
    target 212
    value 3
  ]
  edge
  [
    source 236
    target 89
    value 1
  ]
  edge
  [
    source 236
    target 74
    value 1
  ]
  edge
  [
    source 236
    target 77
    value 1
  ]
  edge
  [
    source 237
    target 219
    value 19
  ]
  edge
  [
    source 237
    target 233
    value 1
  ]
  edge
  [
    source 237
    target 178
    value 1
  ]
  edge
  [
    source 237
    target 238
    value 1
  ]
  edge
  [
    source 237
    target 197
    value 6
  ]
  edge
  [
    source 237
    target 189
    value 4
  ]
  edge
  [
    source 237
    target 44
    value 23
  ]
  edge
  [
    source 238
    target 233
    value 4
  ]
  edge
  [
    source 238
    target 142
    value 1
  ]
  edge
  [
    source 238
    target 200
    value 1
  ]
  edge
  [
    source 238
    target 231
    value 2
  ]
  edge
  [
    source 238
    target 44
    value 2
  ]
  edge
  [
    source 238
    target 44
    value 8
  ]
  edge
  [
    source 239
    target 114
    value 1
  ]
  edge
  [
    source 239
    target 216
    value 1
  ]
  edge
  [
    source 239
    target 12
    value 2
  ]
  edge
  [
    source 239
    target 2
    value 3
  ]
  edge
  [
    source 239
    target 3
    value 1
  ]
  edge
  [
    source 239
    target 129
    value 1
  ]
  edge
  [
    source 239
    target 21
    value 1
  ]
  edge
  [
    source 239
    target 90
    value 2
  ]
  edge
  [
    source 239
    target 214
    value 1
  ]
  edge
  [
    source 240
    target 95
    value 5
  ]
  edge
  [
    source 240
    target 58
    value 1
  ]
  edge
  [
    source 240
    target 27
    value 1
  ]
  edge
  [
    source 240
    target 172
    value 2
  ]
  edge
  [
    source 240
    target 23
    value 1
  ]
  edge
  [
    source 240
    target 88
    value 1
  ]
  edge
  [
    source 241
    target 16
    value 1
  ]
  edge
  [
    source 241
    target 1
    value 2
  ]
  edge
  [
    source 241
    target 12
    value 2
  ]
  edge
  [
    source 241
    target 84
    value 5
  ]
  edge
  [
    source 241
    target 86
    value 4
  ]
  edge
  [
    source 241
    target 137
    value 3
  ]
  edge
  [
    source 241
    target 24
    value 2
  ]
  edge
  [
    source 241
    target 36
    value 1
  ]
  edge
  [
    source 242
    target 190
    value 1
  ]
  edge
  [
    source 243
    target 190
    value 1
  ]
  edge
  [
    source 244
    target 202
    value 1
  ]
  edge
  [
    source 244
    target 199
    value 1
  ]
  edge
  [
    source 244
    target 195
    value 1
  ]
  edge
  [
    source 244
    target 193
    value 2
  ]
  edge
  [
    source 244
    target 245
    value 1
  ]
  edge
  [
    source 244
    target 283
    value 1
  ]
  edge
  [
    source 244
    target 44
    value 10
  ]
  edge
  [
    source 245
    target 187
    value 1
  ]
  edge
  [
    source 245
    target 219
    value 2
  ]
  edge
  [
    source 245
    target 233
    value 4
  ]
  edge
  [
    source 245
    target 275
    value 4
  ]
  edge
  [
    source 245
    target 276
    value 10
  ]
  edge
  [
    source 245
    target 142
    value 1
  ]
  edge
  [
    source 245
    target 148
    value 3
  ]
  edge
  [
    source 245
    target 252
    value 1
  ]
  edge
  [
    source 245
    target 282
    value 2
  ]
  edge
  [
    source 245
    target 238
    value 1
  ]
  edge
  [
    source 245
    target 283
    value 1
  ]
  edge
  [
    source 245
    target 200
    value 1
  ]
  edge
  [
    source 245
    target 197
    value 1
  ]
  edge
  [
    source 245
    target 189
    value 1
  ]
  edge
  [
    source 245
    target 231
    value 2
  ]
  edge
  [
    source 245
    target 234
    value 4
  ]
  edge
  [
    source 245
    target 269
    value 3
  ]
  edge
  [
    source 245
    target 271
    value 5
  ]
  edge
  [
    source 245
    target 44
    value 8
  ]
  edge
  [
    source 246
    target 277
    value 8
  ]
  edge
  [
    source 246
    target 175
    value 1
  ]
  edge
  [
    source 246
    target 273
    value 3
  ]
  edge
  [
    source 246
    target 268
    value 2
  ]
  edge
  [
    source 246
    target 44
    value 30
  ]
  edge
  [
    source 247
    target 12
    value 27
  ]
  edge
  [
    source 247
    target 137
    value 3
  ]
  edge
  [
    source 247
    target 172
    value 28
  ]
  edge
  [
    source 247
    target 248
    value 1
  ]
  edge
  [
    source 247
    target 190
    value 1
  ]
  edge
  [
    source 248
    target 2
    value 27
  ]
  edge
  [
    source 248
    target 137
    value 3
  ]
  edge
  [
    source 248
    target 125
    value 28
  ]
  edge
  [
    source 248
    target 247
    value 1
  ]
  edge
  [
    source 248
    target 190
    value 1
  ]
  edge
  [
    source 249
    target 44
    value 8
  ]
  edge
  [
    source 250
    target 167
    value 1
  ]
  edge
  [
    source 250
    target 97
    value 1
  ]
  edge
  [
    source 250
    target 204
    value 1
  ]
  edge
  [
    source 250
    target 44
    value 1
  ]
  edge
  [
    source 251
    target 97
    value 1
  ]
  edge
  [
    source 251
    target 44
    value 1
  ]
  edge
  [
    source 252
    target 190
    value 1
  ]
  edge
  [
    source 253
    target 152
    value 1
  ]
  edge
  [
    source 253
    target 153
    value 1
  ]
  edge
  [
    source 253
    target 97
    value 4
  ]
  edge
  [
    source 253
    target 249
    value 22
  ]
  edge
  [
    source 253
    target 227
    value 7
  ]
  edge
  [
    source 253
    target 273
    value 1
  ]
  edge
  [
    source 253
    target 268
    value 9
  ]
  edge
  [
    source 253
    target 44
    value 22
  ]
  edge
  [
    source 254
    target 97
    value 15
  ]
  edge
  [
    source 254
    target 177
    value 1
  ]
  edge
  [
    source 254
    target 44
    value 18
  ]
  edge
  [
    source 255
    target 12
    value 9
  ]
  edge
  [
    source 255
    target 2
    value 6
  ]
  edge
  [
    source 255
    target 117
    value 1
  ]
  edge
  [
    source 255
    target 257
    value 1
  ]
  edge
  [
    source 255
    target 125
    value 13
  ]
  edge
  [
    source 255
    target 177
    value 2
  ]
  edge
  [
    source 256
    target 12
    value 1
  ]
  edge
  [
    source 256
    target 117
    value 1
  ]
  edge
  [
    source 256
    target 98
    value 1
  ]
  edge
  [
    source 256
    target 125
    value 1
  ]
  edge
  [
    source 256
    target 252
    value 3
  ]
  edge
  [
    source 256
    target 220
    value 1
  ]
  edge
  [
    source 256
    target 177
    value 1
  ]
  edge
  [
    source 257
    target 12
    value 7
  ]
  edge
  [
    source 257
    target 2
    value 7
  ]
  edge
  [
    source 257
    target 117
    value 1
  ]
  edge
  [
    source 257
    target 118
    value 1
  ]
  edge
  [
    source 257
    target 255
    value 1
  ]
  edge
  [
    source 257
    target 125
    value 6
  ]
  edge
  [
    source 257
    target 172
    value 3
  ]
  edge
  [
    source 257
    target 177
    value 1
  ]
  edge
  [
    source 258
    target 12
    value 1
  ]
  edge
  [
    source 258
    target 137
    value 5
  ]
  edge
  [
    source 258
    target 170
    value 1
  ]
  edge
  [
    source 258
    target 125
    value 2
  ]
  edge
  [
    source 258
    target 177
    value 1
  ]
  edge
  [
    source 259
    target 123
    value 1
  ]
  edge
  [
    source 259
    target 167
    value 6
  ]
  edge
  [
    source 259
    target 137
    value 7
  ]
  edge
  [
    source 259
    target 184
    value 1
  ]
  edge
  [
    source 259
    target 258
    value 1
  ]
  edge
  [
    source 259
    target 172
    value 8
  ]
  edge
  [
    source 259
    target 177
    value 1
  ]
  edge
  [
    source 260
    target 191
    value 2
  ]
  edge
  [
    source 261
    target 12
    value 5
  ]
  edge
  [
    source 261
    target 117
    value 4
  ]
  edge
  [
    source 261
    target 137
    value 5
  ]
  edge
  [
    source 261
    target 142
    value 2
  ]
  edge
  [
    source 261
    target 185
    value 5
  ]
  edge
  [
    source 261
    target 172
    value 1
  ]
  edge
  [
    source 262
    target 233
    value 15
  ]
  edge
  [
    source 262
    target 44
    value 18
  ]
  edge
  [
    source 263
    target 233
    value 6
  ]
  edge
  [
    source 263
    target 275
    value 15
  ]
  edge
  [
    source 263
    target 44
    value 18
  ]
  edge
  [
    source 264
    target 275
    value 15
  ]
  edge
  [
    source 264
    target 44
    value 18
  ]
  edge
  [
    source 265
    target 275
    value 6
  ]
  edge
  [
    source 265
    target 276
    value 15
  ]
  edge
  [
    source 265
    target 44
    value 18
  ]
  edge
  [
    source 266
    target 276
    value 15
  ]
  edge
  [
    source 266
    target 44
    value 18
  ]
  edge
  [
    source 267
    target 276
    value 6
  ]
  edge
  [
    source 267
    target 277
    value 15
  ]
  edge
  [
    source 267
    target 44
    value 18
  ]
  edge
  [
    source 268
    target 44
    value 25
  ]
  edge
  [
    source 269
    target 44
    value 25
  ]
  edge
  [
    source 270
    target 269
    value 2
  ]
  edge
  [
    source 270
    target 271
    value 16
  ]
  edge
  [
    source 270
    target 44
    value 15
  ]
  edge
  [
    source 271
    target 44
    value 25
  ]
  edge
  [
    source 272
    target 164
    value 1
  ]
  edge
  [
    source 272
    target 271
    value 2
  ]
  edge
  [
    source 272
    target 273
    value 16
  ]
  edge
  [
    source 272
    target 44
    value 15
  ]
  edge
  [
    source 273
    target 44
    value 25
  ]
  edge
  [
    source 274
    target 273
    value 2
  ]
  edge
  [
    source 274
    target 268
    value 16
  ]
  edge
  [
    source 274
    target 44
    value 15
  ]
  edge
  [
    source 275
    target 162
    value 2
  ]
  edge
  [
    source 275
    target 234
    value 1
  ]
  edge
  [
    source 275
    target 269
    value 1
  ]
  edge
  [
    source 275
    target 44
    value 29
  ]
  edge
  [
    source 276
    target 164
    value 2
  ]
  edge
  [
    source 276
    target 271
    value 1
  ]
  edge
  [
    source 276
    target 273
    value 1
  ]
  edge
  [
    source 276
    target 44
    value 29
  ]
  edge
  [
    source 277
    target 165
    value 2
  ]
  edge
  [
    source 277
    target 249
    value 1
  ]
  edge
  [
    source 277
    target 268
    value 1
  ]
  edge
  [
    source 277
    target 44
    value 29
  ]
  edge
  [
    source 278
    target 274
    value 1
  ]
  edge
  [
    source 278
    target 277
    value 4
  ]
  edge
  [
    source 278
    target 97
    value 9
  ]
  edge
  [
    source 278
    target 269
    value 1
  ]
  edge
  [
    source 278
    target 271
    value 9
  ]
  edge
  [
    source 278
    target 273
    value 22
  ]
  edge
  [
    source 278
    target 268
    value 7
  ]
  edge
  [
    source 278
    target 44
    value 22
  ]
  edge
  [
    source 279
    target 276
    value 8
  ]
  edge
  [
    source 279
    target 246
    value 1
  ]
  edge
  [
    source 279
    target 44
    value 10
  ]
  edge
  [
    source 280
    target 277
    value 6
  ]
  edge
  [
    source 280
    target 97
    value 15
  ]
  edge
  [
    source 280
    target 44
    value 18
  ]
  edge
  [
    source 281
    target 277
    value 15
  ]
  edge
  [
    source 281
    target 44
    value 18
  ]
  edge
  [
    source 282
    target 219
    value 1
  ]
  edge
  [
    source 282
    target 142
    value 1
  ]
  edge
  [
    source 282
    target 238
    value 1
  ]
  edge
  [
    source 282
    target 200
    value 1
  ]
  edge
  [
    source 282
    target 44
    value 2
  ]
  edge
  [
    source 282
    target 44
    value 2
  ]
  edge
  [
    source 283
    target 202
    value 1
  ]
  edge
  [
    source 283
    target 199
    value 1
  ]
  edge
  [
    source 283
    target 276
    value 2
  ]
  edge
  [
    source 283
    target 195
    value 2
  ]
  edge
  [
    source 283
    target 193
    value 2
  ]
  edge
  [
    source 283
    target 244
    value 2
  ]
  edge
  [
    source 283
    target 44
    value 8
  ]
  edge
  [
    source 284
    target 187
    value 1
  ]
  edge
  [
    source 284
    target 233
    value 1
  ]
  edge
  [
    source 284
    target 275
    value 1
  ]
  edge
  [
    source 284
    target 276
    value 1
  ]
  edge
  [
    source 284
    target 277
    value 1
  ]
  edge
  [
    source 284
    target 142
    value 1
  ]
  edge
  [
    source 284
    target 145
    value 1
  ]
  edge
  [
    source 284
    target 244
    value 1
  ]
  edge
  [
    source 284
    target 249
    value 1
  ]
  edge
  [
    source 284
    target 227
    value 1
  ]
  edge
  [
    source 284
    target 221
    value 1
  ]
  edge
  [
    source 284
    target 183
    value 1
  ]
  edge
  [
    source 284
    target 271
    value 1
  ]
  edge
  [
    source 284
    target 273
    value 1
  ]
  edge
  [
    source 284
    target 268
    value 1
  ]
  edge
  [
    source 284
    target 44
    value 1
  ]
  edge
  [
    source 284
    target 44
    value 10
  ]
  edge
  [
    source 285
    target 44
    value 1
  ]
  edge
  [
    source 286
    target 44
    value 1
  ]
  edge
  [
    source 287
    target 44
    value 1
  ]
  edge
  [
    source 288
    target 44
    value 1
  ]
  edge
  [
    source 289
    target 44
    value 1
  ]
  edge
  [
    source 290
    target 44
    value 1
  ]
  edge
  [
    source 291
    target 44
    value 1
  ]
  edge
  [
    source 292
    target 44
    value 1
  ]
  edge
  [
    source 293
    target 44
    value 1
  ]
  edge
  [
    source 294
    target 44
    value 1
  ]
  edge
  [
    source 295
    target 190
    value 1
  ]
  edge
  [
    source 296
    target 190
    value 1
  ]
]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/centralization.c0000644000175100001710000001203400000000000026153 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define ALMOST_EQUALS(a, b) (fabs((a)-(b)) < 1e-8)

int main() {

    igraph_t g;
    igraph_real_t cent;
    igraph_arpack_options_t arpack_options;

    /****************************/
    /* in-star */
    igraph_star(&g, 10, IGRAPH_STAR_IN, /*center=*/ 0);

    igraph_centralization_degree(&g, /*res=*/ 0,
                                 /*mode=*/ IGRAPH_IN, IGRAPH_NO_LOOPS,
                                 ¢, /*theoretical_max=*/ 0,
                                 /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "in-star, degree: %g\n", cent);
        return 1;
    }

    igraph_centralization_betweenness(&g, /*res=*/ 0,
                                      IGRAPH_UNDIRECTED, ¢,
                                      /*theoretical_max=*/ 0,
                                      /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "in-star, betweenness: %g\n", cent);
        return 2;
    }

    /* Skip closeness, as it is not well-defined for disconnected graphs such as an in-star. */

    igraph_destroy(&g);

    /****************************/
    /* out-star */
    igraph_star(&g, 10, IGRAPH_STAR_OUT, /*center=*/ 0);

    igraph_centralization_degree(&g, /*res=*/ 0,
                                 /*mode=*/ IGRAPH_OUT, IGRAPH_NO_LOOPS,
                                 ¢, /*theoretical_max=*/ 0,
                                 /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "out-star, degree: %g\n", cent);
        return 11;
    }

    igraph_centralization_betweenness(&g, /*res=*/ 0,
                                      IGRAPH_UNDIRECTED, ¢,
                                      /*theoretical_max=*/ 0,
                                      /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "out-star, betweenness: %g\n", cent);
        return 12;
    }

    /* Skip closeness, as it is not well-defined for disconnected graphs such as an out-star. */

    igraph_destroy(&g);

    /****************************/
    /* undirected star */
    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, /*center=*/ 0);

    igraph_centralization_degree(&g, /*res=*/ 0,
                                 /*mode=*/ IGRAPH_ALL, IGRAPH_NO_LOOPS,
                                 ¢, /*theoretical_max=*/ 0,
                                 /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "undirected star, degree: %g\n", cent);
        return 21;
    }

    igraph_centralization_betweenness(&g, /*res=*/ 0,
                                      IGRAPH_UNDIRECTED, ¢,
                                      /*theoretical_max=*/ 0,
                                      /*normalized=*/ 1);
    if (cent != 1.0) {
        fprintf(stderr, "undirected star, betweenness: %g\n", cent);
        return 22;
    }

    igraph_centralization_closeness(&g, /*res=*/ 0,
                                    IGRAPH_ALL, ¢,
                                    /*theoretical_max=*/ 0,
                                    /*normalization=*/ 1);

    if (!ALMOST_EQUALS(cent, 1.0)) {
        fprintf(stderr, "undirected star, closeness: %g\n", cent);
        return 23;
    }

    igraph_destroy(&g);

    /****************************/
    /* single dyad */

    igraph_small(&g, /*n=*/ 10, /*directed=*/ 0,
                 0, 1, -1);

    igraph_arpack_options_init(&arpack_options);
    igraph_centralization_eigenvector_centrality(&g, /*vector=*/ 0,
            /*value=*/ 0,
            /*directed=*/ 1,
            /*scale=*/ 1,
            &arpack_options, ¢,
            /*theoretical_max=*/ 0,
            /*normalization=*/ 1);

    if (!ALMOST_EQUALS(cent, 1.0)) {
        fprintf(stderr, "dyad, eigenvector centrality: %g\n", cent);
        return 24;
    }

    igraph_centralization_eigenvector_centrality(&g, /*vector=*/ 0,
            /*value=*/ 0,
            /*directed=*/ 1,
            /*scale=*/ 0,
            &arpack_options, ¢,
            /*theoretical_max=*/ 0,
            /*normalization=*/ 1);

    if (!ALMOST_EQUALS(cent, 1.0)) {
        fprintf(stderr, "dyad, eigenvector centrality, not scaled: %g\n", cent);
        return 25;
    }

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cohesive_blocks.c0000644000175100001710000001307500000000000026275 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int doit(igraph_t *g) {

    igraph_vector_ptr_t blocks;
    igraph_vector_t cohesion;
    igraph_vector_t parent;
    igraph_t block_tree;
    long int i;

    igraph_vector_ptr_init(&blocks, 0);
    igraph_vector_init(&cohesion, 0);
    igraph_vector_init(&parent, 0);

    igraph_cohesive_blocks(g, &blocks, &cohesion, &parent,
                           &block_tree);

    printf("Blocks:\n");
    for (i = 0; i < igraph_vector_ptr_size(&blocks); i++) {
        igraph_vector_t *sg = VECTOR(blocks)[i];
        printf("  ");
        igraph_vector_print(sg);
        igraph_vector_destroy(sg);
        igraph_free(sg);
    }
    printf("Cohesion:\n  ");
    igraph_vector_print(&cohesion);
    printf("Parents:\n  ");
    igraph_vector_print(&parent);
    printf("Block graph:\n");
    igraph_write_graph_edgelist(&block_tree, stdout);

    igraph_vector_ptr_destroy(&blocks);
    igraph_vector_destroy(&cohesion);
    igraph_vector_destroy(&parent);
    igraph_destroy(&block_tree);

    return 0;
}

int main() {

    igraph_t g;
    int ret;

    /* --------------------------------------------------------*/
    /* The graph from the Moody-White paper                    */

    igraph_small(&g, 23, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 0, 5,
                 1, 2, 1, 3, 1, 4, 1, 6,
                 2, 3, 2, 5, 2, 6,
                 3, 4, 3, 5, 3, 6,
                 4, 5, 4, 6, 4, 20,
                 5, 6,
                 6, 7, 6, 10, 6, 13, 6, 18,
                 7, 8, 7, 10, 7, 13,
                 8, 9,
                 9, 11, 9, 12,
                 10, 11, 10, 13,
                 11, 15,
                 12, 15,
                 13, 14,
                 14, 15,
                 16, 17, 16, 18, 16, 19,
                 17, 19, 17, 20,
                 18, 19, 18, 21, 18, 22,
                 19, 20,
                 20, 21, 20, 22,
                 21, 22,
                 -1);

    if ( (ret = doit(&g)) ) {
        return ret;
    }
    igraph_destroy(&g);
    printf("--\n");

    /* --------------------------------------------------------*/
    /* A tricky graph, where the separators themselves         */
    /* form a block. But recently we don't include this        */
    /* block in the results.                                   */

    igraph_small(&g, 8, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 0, 5, 1, 2, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 2, 7,
                 3, 6, 3, 7, 4, 5, 5, 6, 6, 7,
                 -1);

    if ( (ret = doit(&g)) ) {
        return ret;
    }
    igraph_destroy(&g);
    printf("--\n");

    /* --------------------------------------------------------*/
    /* The science camp graph from http://intersci.ss.uci.edu/ */
    /* wiki/index.php/Cohesive_blocking                        */

    igraph_small(&g, 18, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3,
                 1, 2, 1, 3, 1, 16, 1, 17,
                 2, 3,
                 3, 17,
                 4, 5, 4, 6, 4, 7, 4, 8,
                 5, 6, 5, 7,
                 6, 7, 6, 8,
                 7, 8, 7, 16,
                 8, 9, 8, 10,
                 9, 11, 9, 12, 9, 13, 9, 14,
                 10, 11, 10, 12, 10, 13,
                 11, 14,
                 12, 13, 12, 14, 12, 15,
                 15, 16, 15, 17,
                 16, 17,
                 -1);

    if ( (ret = doit(&g)) ) {
        return ret;
    }
    igraph_destroy(&g);
    printf("--\n");

    /* --------------------------------------------------------*/
    /* Zachary karate-club                                     */

    igraph_small(&g, 34, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 10, 0, 11, 0, 12, 0, 13,
                 0, 17, 0, 19, 0, 21, 0, 31,
                 1, 2, 1, 3, 1, 7, 1, 13, 1, 17, 1, 19, 1, 21, 1, 30,
                 2, 3, 2, 7, 2, 27, 2, 28, 2, 32, 2, 9, 2, 8, 2, 13,
                 3, 7, 3, 12, 3, 13,
                 4, 6, 4, 10,
                 5, 6, 5, 10, 5, 16,
                 6, 16,
                 8, 30, 8, 32, 8, 33,
                 9, 33,
                 13, 33,
                 14, 32, 14, 33,
                 15, 32, 15, 33,
                 18, 32, 18, 33,
                 19, 33,
                 20, 32, 20, 33,
                 22, 32, 22, 33,
                 23, 25, 23, 27, 23, 32, 23, 33, 23, 29,
                 24, 25, 24, 27, 24, 31,
                 25, 31,
                 26, 29, 26, 33,
                 27, 33,
                 28, 31, 28, 33,
                 29, 32, 29, 33,
                 30, 32, 30, 33,
                 31, 32, 31, 33,
                 32, 33,
                 -1);

    if ( (ret = doit(&g)) ) {
        return ret;
    }
    igraph_destroy(&g);
    printf("--\n");

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/cohesive_blocks.out0000644000175100001710000000161600000000000026660 0ustar00runnerdocker00000000000000Blocks:
  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
  0 1 2 3 4 5 6 16 17 18 19 20 21 22
  6 7 8 9 10 11 12 13 14 15
  0 1 2 3 4 5 6
  6 7 10 13
Cohesion:
  1 2 2 5 3
Parents:
  -1 0 0 1 2
Block graph:
0 1
0 2
1 3
2 4
--
Blocks:
  0 1 2 3 4 5 6 7
  0 1 4 5
  2 3 6 7
  1 2 5 6
Cohesion:
  2 3 3 3
Parents:
  -1 0 0 0
Block graph:
0 1
0 2
0 3
--
Blocks:
  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
  0 1 2 3
  4 5 6 7 8
  9 10 11 12 13 14
Cohesion:
  2 3 3 3
Parents:
  -1 0 0 0
Block graph:
0 1
0 2
0 3
--
Blocks:
  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
  0 1 2 3 7 8 9 12 13 14 15 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
  0 4 5 6 10 16
  0 1 2 3 7
  0 1 2 8 30 32 33
  0 4 5 6 10
  0 1 2 3 13
  2 23 24 25 27 28 29 31 32 33
Cohesion:
  1 2 2 4 3 3 4 3
Parents:
  -1 0 0 1 1 2 1 1
Block graph:
0 1
0 2
1 3
1 4
1 6
1 7
2 5
--
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dijkstra.c0000644000175100001710000000455200000000000024746 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_matrix(const igraph_matrix_t *m) {
    long int nrow = igraph_matrix_nrow(m);
    long int ncol = igraph_matrix_ncol(m);
    long int i, j;
    igraph_real_t val;

    for (i = 0; i < nrow; i++) {
        printf("%li:", i);
        for (j = 0; j < ncol; j++) {
            val = MATRIX(*m, i, j);
            if (igraph_is_inf(val)) {
                if (val < 0) {
                    printf("-inf");
                } else {
                    printf(" inf");
                }
            } else {
                printf(" %3.0f", val);
            }
        }
        printf("\n");
    }
    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_t weights;
    igraph_real_t weights_data[] = { 0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1 };
    igraph_matrix_t res;

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 0, 3,    1, 2, 1, 4, 1, 5,
                 2, 3, 2, 6,         3, 2, 3, 6,
                 4, 5, 4, 7,         5, 6, 5, 8, 5, 9,
                 7, 5, 7, 8,         8, 9,
                 5, 2,
                 2, 1,
                 -1);

    igraph_vector_view(&weights, weights_data,
                       sizeof(weights_data) / sizeof(igraph_real_t));

    igraph_matrix_init(&res, 0, 0);
    igraph_shortest_paths_dijkstra(&g, &res, igraph_vss_all(), igraph_vss_all(),
                                   &weights, IGRAPH_OUT);
    print_matrix(&res);

    igraph_matrix_destroy(&res);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dijkstra.out0000644000175100001710000000065600000000000025334 0ustar00runnerdocker000000000000000:   0   0   0   1   5   2   1  13   3   5
1: inf   0   0   1   5   2   1  13   3   5
2: inf   1   0   1   6   3   1  14   4   6
3: inf   1   0   0   6   3   1  14   4   6
4: inf   5   4   5   0   2   3   8   3   5
5: inf   3   2   3   8   0   1  16   1   3
6: inf inf inf inf inf inf   0 inf inf inf
7: inf   4   3   4   9   1   2   0   1   4
8: inf inf inf inf inf inf inf inf   0   4
9: inf inf inf inf inf inf inf inf inf   0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dominator_tree.c0000644000175100001710000001201100000000000026133 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g, domtree;
    igraph_vector_t dom, leftout;

    igraph_vector_init(&dom, 0);
    igraph_small(&g, 13, IGRAPH_DIRECTED,
                 0, 1, 0, 7, 0, 10,
                 1, 2, 1, 5,
                 2, 3,
                 3, 4,
                 4, 3, 4, 0,
                 5, 3, 5, 6,
                 6, 3,
                 7, 8, 7, 10, 7, 11,
                 8, 9,
                 9, 4, 9, 8,
                 10, 11,
                 11, 12,
                 12, 9,
                 -1);

    /* Check NULL vector arguments */
    igraph_dominator_tree(&g, /*root=*/ 0, /*dom=*/ 0, /*domtree=*/ 0,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_OUT);

    /* Proper calculation */
    igraph_dominator_tree(&g, /*root=*/ 0, &dom, /*domtree=*/ 0,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_OUT);
    igraph_vector_print(&dom);

    /* Tree calculation */
    igraph_dominator_tree(&g, /*root=*/ 0, /*dom=*/ 0, /*domtree=*/ &domtree,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_OUT);
    igraph_write_graph_edgelist(&domtree, stdout);

    igraph_vector_destroy(&dom);
    igraph_destroy(&domtree);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------*/

    igraph_vector_init(&dom, 0);
    igraph_small(&g, 13, IGRAPH_DIRECTED,
                 1, 0, 2, 0, 3, 0,
                 4, 1,
                 1, 2, 4, 2, 5, 2,
                 6, 3, 7, 3,
                 12, 4,
                 8, 5,
                 9, 6,
                 9, 7, 10, 7,
                 5, 8, 11, 8,
                 11, 9,
                 9, 10,
                 9, 11, 0, 11,
                 8, 12,
                 -1);

    /* Check NULL vector arguments */
    igraph_dominator_tree(&g, /*root=*/ 0, /*dom=*/ 0, /*domtree=*/ 0,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_IN);

    /* Proper calculation */
    igraph_dominator_tree(&g, /*root=*/ 0, &dom, /*domtree=*/ 0,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_IN);
    igraph_vector_print(&dom);

    /* Tree calculation */
    igraph_dominator_tree(&g, /*root=*/ 0, /*dom=*/ 0, /*domtree=*/ &domtree,
                          /*leftout=*/ 0, /*mode=*/ IGRAPH_IN);
    igraph_write_graph_edgelist(&domtree, stdout);

    igraph_vector_destroy(&dom);
    igraph_destroy(&domtree);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------*/

    igraph_vector_init(&dom, 0);
    igraph_vector_init(&leftout, 0);

    /* Check a graph with more components */
    igraph_small(&g, 20, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 0, 3,
                 1, 4,
                 2, 1, 2, 4, 2, 8,
                 3, 9, 3, 10,
                 4, 15,
                 8, 11,
                 9, 12,
                 10, 12, 10, 13,
                 11, 8, 11, 14,
                 12, 14,
                 13, 12,
                 14, 12, 14, 0,
                 15, 11,
                 -1);

    igraph_dominator_tree(&g, /*root=*/ 0, &dom, &domtree,
                          &leftout, /*mode=*/ IGRAPH_OUT);
    igraph_vector_print(&dom);
    igraph_vector_print(&leftout);
    igraph_write_graph_edgelist(&domtree, stdout);

    igraph_vector_destroy(&dom);
    igraph_vector_destroy(&leftout);
    igraph_destroy(&domtree);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------*/

    igraph_vector_init(&dom, 0);
    igraph_vector_init(&leftout, 0);

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 9,
                 1, 0, 1, 2,
                 2, 3, 2, 7,
                 3, 1,
                 4, 1, 4, 3,
                 5, 2, 5, 3, 5, 4, 5, 8,
                 6, 5, 6, 9,
                 8, 7,
                 -1);

    igraph_dominator_tree(&g, /*root=*/ 9, &dom, &domtree,
                          &leftout, /*mode=*/ IGRAPH_IN);
    igraph_vector_print(&dom);
    igraph_vector_print(&leftout);
    igraph_write_graph_edgelist(&domtree, stdout);

    igraph_vector_destroy(&dom);
    igraph_vector_destroy(&leftout);
    igraph_destroy(&domtree);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dominator_tree.out0000644000175100001710000000053000000000000026523 0ustar00runnerdocker00000000000000-1 0 1 0 0 1 5 0 0 0 0 0 11
0 1
0 3
0 4
0 7
0 8
0 9
0 10
0 11
1 2
1 5
5 6
11 12
-1 0 0 0 0 0 3 3 0 0 7 0 4
1 0
2 0
3 0
4 0
5 0
6 3
7 3
8 0
9 0
10 7
11 0
12 4
-1 0 0 0 0 NaN NaN NaN 0 3 3 0 0 10 0 4 NaN NaN NaN NaN
5 6 7 16 17 18 19
0 1
0 2
0 3
0 4
0 8
0 11
0 12
0 14
3 9
3 10
4 15
10 13
9 0 3 1 1 1 9 NaN NaN -1
7 8
0 9
1 0
2 3
3 1
4 1
5 1
6 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dot.c0000644000175100001710000000255500000000000023722 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g;
    FILE *ifile;

    ifile = fopen("karate.gml", "r");
    if (ifile == 0) {
        return 10;
    }

    igraph_read_graph_gml(&g, ifile);
    fclose(ifile);

    if (igraph_is_directed(&g)) {
        printf("directed\n");
    } else {
        printf("undirected\n");
    }

    igraph_write_graph_edgelist(&g, stdout);
    printf("-----------------\n");
    igraph_write_graph_dot(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dot.out0000644000175100001710000000301200000000000024274 0ustar00runnerdocker00000000000000undirected
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 10
0 11
0 12
0 13
0 17
0 19
0 21
0 31
1 2
1 3
1 7
1 13
1 17
1 19
1 21
1 30
2 3
2 7
2 8
2 9
2 13
2 27
2 28
2 32
3 7
3 12
3 13
4 6
4 10
5 6
5 10
5 16
6 16
8 30
8 32
8 33
9 33
13 33
14 32
14 33
15 32
15 33
18 32
18 33
19 33
20 32
20 33
22 32
22 33
23 25
23 27
23 29
23 32
23 33
24 25
24 27
24 31
25 31
26 29
26 33
27 33
28 31
28 33
29 32
29 33
30 32
30 33
31 32
31 33
32 33
-----------------
/* Created by igraph @VERSION@ */
graph {
  0;
  1;
  2;
  3;
  4;
  5;
  6;
  7;
  8;
  9;
  10;
  11;
  12;
  13;
  14;
  15;
  16;
  17;
  18;
  19;
  20;
  21;
  22;
  23;
  24;
  25;
  26;
  27;
  28;
  29;
  30;
  31;
  32;
  33;

  1 -- 0;
  2 -- 0;
  2 -- 1;
  3 -- 0;
  3 -- 1;
  3 -- 2;
  4 -- 0;
  5 -- 0;
  6 -- 0;
  6 -- 4;
  6 -- 5;
  7 -- 0;
  7 -- 1;
  7 -- 2;
  7 -- 3;
  8 -- 0;
  8 -- 2;
  9 -- 2;
  10 -- 0;
  10 -- 4;
  10 -- 5;
  11 -- 0;
  12 -- 0;
  12 -- 3;
  13 -- 0;
  13 -- 1;
  13 -- 2;
  13 -- 3;
  16 -- 5;
  16 -- 6;
  17 -- 0;
  17 -- 1;
  19 -- 0;
  19 -- 1;
  21 -- 0;
  21 -- 1;
  25 -- 23;
  25 -- 24;
  27 -- 2;
  27 -- 23;
  27 -- 24;
  28 -- 2;
  29 -- 23;
  29 -- 26;
  30 -- 1;
  30 -- 8;
  31 -- 0;
  31 -- 24;
  31 -- 25;
  31 -- 28;
  32 -- 2;
  32 -- 8;
  32 -- 14;
  32 -- 15;
  32 -- 18;
  32 -- 20;
  32 -- 22;
  32 -- 23;
  32 -- 29;
  32 -- 30;
  32 -- 31;
  33 -- 8;
  33 -- 9;
  33 -- 13;
  33 -- 14;
  33 -- 15;
  33 -- 18;
  33 -- 19;
  33 -- 20;
  33 -- 22;
  33 -- 23;
  33 -- 26;
  33 -- 27;
  33 -- 28;
  33 -- 29;
  33 -- 30;
  33 -- 31;
  33 -- 32;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dqueue.c0000644000175100001710000000600300000000000024414 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_dqueue_t q;
    int i;

    /* igraph_dqueue_init, igraph_dqueue_destroy, igraph_dqueue_empty */
    igraph_dqueue_init(&q, 5);
    if (!igraph_dqueue_empty(&q)) {
        return 1;
    }
    igraph_dqueue_destroy(&q);

    /* igraph_dqueue_push, igraph_dqueue_pop */
    igraph_dqueue_init(&q, 4);
    igraph_dqueue_push(&q, 1);
    igraph_dqueue_push(&q, 2);
    igraph_dqueue_push(&q, 3);
    igraph_dqueue_push(&q, 4);
    if (igraph_dqueue_pop(&q) != 1) {
        return 2;
    }
    if (igraph_dqueue_pop(&q) != 2) {
        return 3;
    }
    if (igraph_dqueue_pop(&q) != 3) {
        return 4;
    }
    if (igraph_dqueue_pop(&q) != 4) {
        return 5;
    }
    igraph_dqueue_destroy(&q);

    /* igraph_dqueue_clear, igraph_dqueue_size */
    igraph_dqueue_init(&q, 0);
    if (igraph_dqueue_size(&q) != 0) {
        return 6;
    }
    igraph_dqueue_clear(&q);
    if (igraph_dqueue_size(&q) != 0) {
        return 7;
    }
    for (i = 0; i < 10; i++) {
        igraph_dqueue_push(&q, i);
    }
    igraph_dqueue_clear(&q);
    if (igraph_dqueue_size(&q) != 0) {
        return 8;
    }
    igraph_dqueue_destroy(&q);

    /* TODO: igraph_dqueue_full */

    /* igraph_dqueue_head, igraph_dqueue_back, igraph_dqueue_pop_back */
    igraph_dqueue_init(&q, 0);
    for (i = 0; i < 10; i++) {
        igraph_dqueue_push(&q, i);
    }
    for (i = 0; i < 10; i++) {
        if (igraph_dqueue_head(&q) != 0) {
            return 9;
        }
        if (igraph_dqueue_back(&q) != 9 - i) {
            return 10;
        }
        if (igraph_dqueue_pop_back(&q) != 9 - i) {
            return 11;
        }
    }
    igraph_dqueue_destroy(&q);

    /* print */
    igraph_dqueue_init(&q, 4);
    igraph_dqueue_push(&q, 1);
    igraph_dqueue_push(&q, 2);
    igraph_dqueue_push(&q, 3);
    igraph_dqueue_push(&q, 4);
    igraph_dqueue_pop(&q);
    igraph_dqueue_pop(&q);
    igraph_dqueue_push(&q, 5);
    igraph_dqueue_push(&q, 6);
    igraph_dqueue_print(&q);

    igraph_dqueue_clear(&q);
    igraph_dqueue_print(&q);

    igraph_dqueue_destroy(&q);

    if (IGRAPH_FINALLY_STACK_SIZE() != 0) {
        return 12;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/dqueue.out0000644000175100001710000000001100000000000024772 0ustar00runnerdocker000000000000003 4 5 6

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist1.dl0000644000175100001710000000013400000000000025161 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels:
george, sally, jim, billy, jane
data:
1 2
1 3
2 3
3 1
4 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist2.dl0000644000175100001710000000015100000000000025161 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels embedded:
data:
george sally
george jim
sally jim
billy george
jane jim
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist3.dl0000644000175100001710000000022100000000000025160 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels:
george, sally, jim, billy, jane
labels embedded:
data:
george sally
george jim
sally jim
billy george
jane jim
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist4.dl0000644000175100001710000000014200000000000025163 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels:
george, sally, jim, billy, jane
data:
1 2
1 3 -1
2 3
3 1 -1
4 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist5.dl0000644000175100001710000000020100000000000025160 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels embedded:
data:
george sally     0.1
george jim       0.5
sally jim
billy george     1
jane jim
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist6.dl0000644000175100001710000000025400000000000025171 0ustar00runnerdocker00000000000000DL n=5
format = edgelist1
labels:
george, sally, jim, billy, jane
labels embedded:
data:
george sally
george jim       2
sally jim
billy george     1
jane jim         1e-5
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/edgelist7.dl0000644000175100001710000000005400000000000025170 0ustar00runnerdocker00000000000000DL n=4
format = edgelist1
data:
1 2
2 3
2 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/eigenvector_centrality.c0000644000175100001710000000456600000000000027710 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph.h"

#include 

int main() {

    igraph_t g;
    igraph_vector_t v, weights;
    long int i;
    igraph_real_t value;
    igraph_arpack_options_t options;

    igraph_star(&g, 100, IGRAPH_STAR_UNDIRECTED, 0);

    igraph_arpack_options_init(&options);
    igraph_vector_init(&v, 0);
    igraph_eigenvector_centrality(&g, &v, &value, /*directed=*/ 0,
                                  /*scale=*/1, /*weights=*/0,
                                  &options);

    if (options.info != 0) {
        return 1;
    }

    for (i = 0; i < igraph_vector_size(&v); i++) {
        printf(" %.4f", fabs(VECTOR(v)[i]));
    }
    printf("\n");

    igraph_destroy(&g);

    /* Special cases: check for empty graph */
    igraph_empty(&g, 10, 0);
    igraph_eigenvector_centrality(&g, &v, &value, 0, 0, 0, &options);
    if (value != 0.0) {
        return 1;
    }
    for (i = 0; i < igraph_vector_size(&v); i++) {
        printf(" %.2f", fabs(VECTOR(v)[i]));
    }
    printf("\n");
    igraph_destroy(&g);

    /* Special cases: check for full graph, zero weights */
    igraph_full(&g, 10, 0, 0);
    igraph_vector_init(&weights, 45);
    igraph_vector_fill(&weights, 0);
    igraph_eigenvector_centrality(&g, &v, &value, 0, 0, &weights, &options);
    igraph_vector_destroy(&weights);
    if (value != 0.0) {
        return 2;
    }
    for (i = 0; i < igraph_vector_size(&v); i++) {
        printf(" %.2f", fabs(VECTOR(v)[i]));
    }
    printf("\n");
    igraph_destroy(&g);

    igraph_vector_destroy(&v);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/eigenvector_centrality.out0000644000175100001710000000144300000000000030264 0ustar00runnerdocker00000000000000 1.0000 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005 0.1005
 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/even_tarjan.c0000644000175100001710000000403500000000000025423 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g, gbar;
    igraph_integer_t k1, k2 = (igraph_integer_t) INT_MAX;
    igraph_real_t tmpk;
    long int i, j, n;
    igraph_maxflow_stats_t stats;

    /* --------------------------------------------------- */

    igraph_famous(&g, "meredith");
    igraph_even_tarjan_reduction(&g, &gbar, /*capacity=*/ 0);

    igraph_vertex_connectivity(&g, &k1, /* checks= */ 0);

    n = igraph_vcount(&g);
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            igraph_bool_t conn;
            igraph_are_connected(&g, i, j, &conn);
            if (conn) {
                continue;
            }
            igraph_maxflow_value(&gbar, &tmpk,
                                 /* source= */ i + n,
                                 /* target= */ j,
                                 /* capacity= */ 0,
                                 &stats);
            if (tmpk < k2) {
                k2 = tmpk;
            }
        }
    }

    igraph_destroy(&gbar);
    igraph_destroy(&g);

    if (k1 != k2) {
        printf("k1 = %ld while k2 = %ld\n", (long int) k1, (long int) k2);
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/flow.c0000644000175100001710000000661500000000000024104 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_real_t flow;
    igraph_vector_t capacity;
    igraph_integer_t source, target;
    FILE *infile;
    igraph_maxflow_stats_t stats;

    igraph_vector_init(&capacity, 0);

    /***************/
    infile = fopen("ak-4102.max", "r");
    igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity,
                             IGRAPH_DIRECTED);
    fclose(infile);

    igraph_maxflow_value(&g, &flow, source, target, &capacity, &stats);

    if (flow != 8207) {
        return 1;
    }
    igraph_destroy(&g);
    /***************/

    /*   /\***************\/ */
    /*   infile=fopen("ak-8198.max", "r"); */
    /*   igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity, */
    /*             IGRAPH_DIRECTED); */
    /*   fclose(infile); */

    /*   t=timer(); */
    /*   igraph_maxflow_value(&g, &flow, source, target, &capacity, &stats); */
    /*   t=timer()-t; */
    /*   printf("8198: %g (time %.10f)\n", flow, t); */
    /*   igraph_destroy(&g); */
    /*   /\***************\/ */

    /*   /\***************\/ */
    /*   infile=fopen("ak-16390.max", "r"); */
    /*   igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity, */
    /*             IGRAPH_DIRECTED); */
    /*   fclose(infile); */

    /*   t=timer(); */
    /*   igraph_maxflow_value(&g, &flow, source, target, &capacity, &stats); */
    /*   t=timer()-t; */
    /*   printf("16390: %g (time %.10f)\n", flow, t); */
    /*   igraph_destroy(&g); */
    /*   /\***************\/ */

    /*   /\***************\/ */
    /*   infile=fopen("ak-32774.max", "r"); */
    /*   igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity, */
    /*             IGRAPH_DIRECTED); */
    /*   fclose(infile); */

    /*   t=timer(); */
    /*   igraph_maxflow_value(&g, &flow, source, target, &capacity, &stats); */
    /*   t=timer()-t; */
    /*   printf("32774: %g (time %.10f)\n", flow, t); */
    /*   igraph_destroy(&g); */
    /*   /\***************\/ */

    /*   /\***************\/ */
    /*   infile=fopen("ak-65542.max", "r"); */
    /*   igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity, */
    /*             IGRAPH_DIRECTED); */
    /*   fclose(infile); */

    /*   t=timer(); */
    /*   igraph_maxflow_value(&g, &flow, source, target, &capacity, &stats); */
    /*   t=timer()-t; */
    /*   printf("65542: %g (time %.10f)\n", flow, t); */
    /*   igraph_destroy(&g); */
    /*   /\***************\/ */

    igraph_vector_destroy(&capacity);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/flow2.c0000644000175100001710000002023200000000000024155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int check_flow(int errorinc,
               const igraph_t *graph, igraph_real_t flow_value,
               const igraph_vector_t *flow, const igraph_vector_t *cut,
               const igraph_vector_t *partition,
               const igraph_vector_t *partition2,
               long int source, long int target,
               const igraph_vector_t *capacity,
               igraph_bool_t print) {

    long int i, n = igraph_vcount(graph), m = igraph_ecount(graph);
    long int nc = igraph_vector_size(cut);
    igraph_vector_t inedges, outedges;
    igraph_bool_t directed = igraph_is_directed(graph);
    igraph_real_t cutsize;
    igraph_t graph_copy;
    igraph_matrix_t sp;

    if (print) {
        printf("flow value: %g\n", (double) flow_value);
        printf("flow: ");
        igraph_vector_print(flow);
        printf("first partition:  ");
        igraph_vector_print(partition);
        printf("second partition: ");
        igraph_vector_print(partition2);
        printf("edges in the cut: ");
        for (i = 0; i < nc; i++) {
            long int edge = VECTOR(*cut)[i];
            long int from = IGRAPH_FROM(graph, edge);
            long int to  = IGRAPH_TO  (graph, edge);
            if (!directed && from > to) {
                igraph_integer_t tmp = from;
                from = to;
                to = tmp;
            }
            printf("%li-%li (%g), ", from, to, VECTOR(*capacity)[edge]);
        }
        printf("\n");
    }
    fflush(stdout);

    /* Always less than the capacity */
    for (i = 0; i < m; i++) {
        if (VECTOR(*flow)[i] > VECTOR(*capacity)[i]) {
            return errorinc + 3;
        }
    }

    /* What comes in goes out, but only in directed graphs,
       there is no in and out in undirected ones...
     */
    if (igraph_is_directed(graph)) {
        igraph_vector_init(&inedges, 0);
        igraph_vector_init(&outedges, 0);

        for (i = 0; i < n; i++) {
            long int n1, n2, j;
            igraph_real_t in_flow = 0.0, out_flow = 0.0;
            igraph_incident(graph, &inedges,  i, IGRAPH_IN);
            igraph_incident(graph, &outedges, i, IGRAPH_OUT);
            n1 = igraph_vector_size(&inedges);
            n2 = igraph_vector_size(&outedges);
            for (j = 0; j < n1; j++) {
                long int e = VECTOR(inedges)[j];
                in_flow += VECTOR(*flow)[e];
            }
            for (j = 0; j < n2; j++) {
                long int e = VECTOR(outedges)[j];
                out_flow += VECTOR(*flow)[e];
            }
            if (i == source) {
                if (in_flow > 0) {
                    return errorinc + 4;
                }
                if (out_flow != flow_value) {
                    return errorinc + 5;
                }
            } else if (i == target) {
                if (out_flow > 0) {
                    return errorinc + 6;
                }
                if (in_flow != flow_value) {
                    return errorinc + 7;
                }

            } else {
                if (in_flow != out_flow) {
                    return errorinc + 8;
                }
            }
        }

        igraph_vector_destroy(&inedges);
        igraph_vector_destroy(&outedges);
    }

    /* Check the minimum cut size*/
    for (i = 0, cutsize = 0.0; i < nc; i++) {
        long int edge = VECTOR(*cut)[i];
        cutsize += VECTOR(*capacity)[edge];
    }
    if (fabs(cutsize - flow_value) > 1e-14) {
        return errorinc + 9;
    }

    /* Check that the cut indeed cuts */
    igraph_copy(&graph_copy, graph);
    igraph_delete_edges(&graph_copy, igraph_ess_vector(cut));
    igraph_matrix_init(&sp, 1, 1);
    igraph_shortest_paths(&graph_copy, &sp, /*from=*/ igraph_vss_1(source),
                          /*to=*/ igraph_vss_1(target), IGRAPH_OUT);
    if (MATRIX(sp, 0, 0) != IGRAPH_INFINITY) {
        return errorinc + 10;
    }
    igraph_matrix_destroy(&sp);
    igraph_destroy(&graph_copy);

    return 0;
}

int main() {

    igraph_t g;
    igraph_real_t flow_value;
    igraph_vector_t cut;
    igraph_vector_t capacity;
    igraph_vector_t partition, partition2;
    igraph_vector_t flow;
    long int i, n;
    igraph_integer_t source, target;
    FILE *infile;
    igraph_real_t flow_value2 = 0.0;
    int check;
    igraph_maxflow_stats_t stats;

    igraph_vector_init(&capacity, 0);

    /***************/
    infile = fopen("ak-4102.max", "r");
    igraph_read_graph_dimacs(&g, infile, 0, 0, &source, &target, &capacity,
                             IGRAPH_DIRECTED);
    fclose(infile);

    igraph_vector_init(&cut, 0);
    igraph_vector_init(&partition, 0);
    igraph_vector_init(&partition2, 0);
    igraph_vector_init(&flow, 0);

    igraph_maxflow(&g, &flow_value, &flow, &cut, &partition,
                   &partition2, source, target, &capacity, &stats);

    if (flow_value != 8207) {
        return 1;
    }

    n = igraph_vector_size(&cut);
    for (i = 0; i < n; i++) {
        long int e = VECTOR(cut)[i];
        flow_value2 += VECTOR(capacity)[e];
    }
    if (flow_value != flow_value2) {
        return 2;
    }

    /* Check the flow */
    if ( (check = check_flow(0, &g, flow_value, &flow, &cut, &partition,
                             &partition2, source, target, &capacity,
                             /*print=*/ 0))) {
        return check;
    }

    igraph_destroy(&g);
    igraph_vector_destroy(&capacity);
    igraph_vector_destroy(&cut);
    igraph_vector_destroy(&partition);
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&flow);

    /* ------------------------------------- */

    igraph_small(&g, 4, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 3, -1);
    igraph_vector_init_int_end(&capacity, -1, 4, 2, 10, 2, 2, -1);
    igraph_vector_init(&cut, 0);
    igraph_vector_init(&partition, 0);
    igraph_vector_init(&partition2, 0);
    igraph_vector_init(&flow, 0);

    igraph_maxflow(&g, &flow_value, &flow, &cut, &partition, &partition2,
                   /*source=*/ 0, /*target=*/ 3, &capacity, &stats);

    if ( (check = check_flow(20, &g, flow_value, &flow, &cut, &partition,
                             &partition2, 0, 3, &capacity,
                             /*print=*/ 1))) {
        return check;
    }

    igraph_vector_destroy(&cut);
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&partition);
    igraph_vector_destroy(&capacity);
    igraph_vector_destroy(&flow);
    igraph_destroy(&g);

    /* ------------------------------------- */

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 0, 5, 5, 4, 4, 3, 3, 0, -1);
    igraph_vector_init_int_end(&capacity, -1, 3, 1, 2, 10, 1, 3, 2, -1);
    igraph_vector_init(&cut, 0);
    igraph_vector_init(&partition, 0);
    igraph_vector_init(&partition2, 0);
    igraph_vector_init(&flow, 0);

    igraph_maxflow(&g, &flow_value, &flow, &cut, &partition, &partition2,
                   /*source=*/ 0, /*target=*/ 2, &capacity, &stats);

    if ( (check = check_flow(40, &g, flow_value, &flow, &cut, &partition,
                             &partition2, 0, 2, &capacity,
                             /*print=*/ 1))) {
        return check;
    }

    igraph_vector_destroy(&cut);
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&partition);
    igraph_vector_destroy(&capacity);
    igraph_vector_destroy(&flow);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/flow2.out0000644000175100001710000000033500000000000024544 0ustar00runnerdocker00000000000000flow value: 4
flow: 4 0 2 2 2
first partition:  0 1 2
second partition: 3
edges in the cut: 1-3 (2), 2-3 (2), 
flow value: 1
flow: 1 1 0 0 0 0 0
first partition:  0 1 3 4 5
second partition: 2
edges in the cut: 1-2 (1), 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/foreign.c0000644000175100001710000000261300000000000024560 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {
    igraph_t g;
    FILE *ifile;

    /* PAJEK */
    ifile = fopen("links.net", "r");
    if (ifile == 0) {
        return 10;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    printf("The graph:\n");
    printf("Vertices: %li\n", (long int) igraph_vcount(&g));
    printf("Edges: %li\n", (long int) igraph_ecount(&g));
    printf("Directed: %i\n", (int) igraph_is_directed(&g));
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/foreign.out0000644000175100001710000000011000000000000025133 0ustar00runnerdocker00000000000000The graph:
Vertices: 4
Edges: 7
Directed: 1
0 0
0 1
0 2
1 0
2 2
2 3
3 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/fullmatrix1.dl0000644000175100001710000000010100000000000025542 0ustar00runnerdocker00000000000000DL N = 5
Data:
0 1 1 1 1
1 0 1 0 0
1 1 0 0 1
1 0 0 0 0
1 0 1 0 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/fullmatrix2.dl0000644000175100001710000000016400000000000025554 0ustar00runnerdocker00000000000000dl n=5
format = fullmatrix
labels:
barry,david,lin,pat,russ
data:
0 1 1 1 0
1 0 0 0 1
1 0 0 1 0
1 0 1 0 1
0 1 0 1 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/fullmatrix3.dl0000644000175100001710000000016400000000000025555 0ustar00runnerdocker00000000000000dl n=5
format = fullmatrix
labels:
barry,david
lin,pat
russ
data:
0 1 1 1 0
1 0 0 0 1
1 0 0 1 0
1 0 1 0 1
0 1 0 1 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/fullmatrix4.dl0000644000175100001710000000022500000000000025554 0ustar00runnerdocker00000000000000dl n=5
format = fullmatrix
labels embedded
data:
larry david lin pat russ
Larry 0 1 1 1 0
david 1 0 0 0 1
Lin 1 0 0 1 0
Pat 1 0 1 0 1
Russ 0 1 0 1 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/gml.c0000644000175100001710000000257500000000000023715 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {
    igraph_t g;
    FILE *ifile;

    ifile = fopen("karate.gml", "r");
    if (ifile == 0) {
        return 10;
    }

    igraph_read_graph_gml(&g, ifile);
    fclose(ifile);

    if (igraph_is_directed(&g)) {
        printf("directed\n");
    } else {
        printf("undirected\n");
    }

    igraph_write_graph_edgelist(&g, stdout);
    printf("-----------------\n");
    igraph_write_graph_gml(&g, stdout, 0, "test suite");
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/gml.out0000644000175100001710000001104400000000000024271 0ustar00runnerdocker00000000000000undirected
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 10
0 11
0 12
0 13
0 17
0 19
0 21
0 31
1 2
1 3
1 7
1 13
1 17
1 19
1 21
1 30
2 3
2 7
2 8
2 9
2 13
2 27
2 28
2 32
3 7
3 12
3 13
4 6
4 10
5 6
5 10
5 16
6 16
8 30
8 32
8 33
9 33
13 33
14 32
14 33
15 32
15 33
18 32
18 33
19 33
20 32
20 33
22 32
22 33
23 25
23 27
23 29
23 32
23 33
24 25
24 27
24 31
25 31
26 29
26 33
27 33
28 31
28 33
29 32
29 33
30 32
30 33
31 32
31 33
32 33
-----------------
Creator "igraph version @VERSION@ test suite"
Version 1
graph
[
  directed 0
  node
  [
    id 0
  ]
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  node
  [
    id 4
  ]
  node
  [
    id 5
  ]
  node
  [
    id 6
  ]
  node
  [
    id 7
  ]
  node
  [
    id 8
  ]
  node
  [
    id 9
  ]
  node
  [
    id 10
  ]
  node
  [
    id 11
  ]
  node
  [
    id 12
  ]
  node
  [
    id 13
  ]
  node
  [
    id 14
  ]
  node
  [
    id 15
  ]
  node
  [
    id 16
  ]
  node
  [
    id 17
  ]
  node
  [
    id 18
  ]
  node
  [
    id 19
  ]
  node
  [
    id 20
  ]
  node
  [
    id 21
  ]
  node
  [
    id 22
  ]
  node
  [
    id 23
  ]
  node
  [
    id 24
  ]
  node
  [
    id 25
  ]
  node
  [
    id 26
  ]
  node
  [
    id 27
  ]
  node
  [
    id 28
  ]
  node
  [
    id 29
  ]
  node
  [
    id 30
  ]
  node
  [
    id 31
  ]
  node
  [
    id 32
  ]
  node
  [
    id 33
  ]
  edge
  [
    source 1
    target 0
  ]
  edge
  [
    source 2
    target 0
  ]
  edge
  [
    source 2
    target 1
  ]
  edge
  [
    source 3
    target 0
  ]
  edge
  [
    source 3
    target 1
  ]
  edge
  [
    source 3
    target 2
  ]
  edge
  [
    source 4
    target 0
  ]
  edge
  [
    source 5
    target 0
  ]
  edge
  [
    source 6
    target 0
  ]
  edge
  [
    source 6
    target 4
  ]
  edge
  [
    source 6
    target 5
  ]
  edge
  [
    source 7
    target 0
  ]
  edge
  [
    source 7
    target 1
  ]
  edge
  [
    source 7
    target 2
  ]
  edge
  [
    source 7
    target 3
  ]
  edge
  [
    source 8
    target 0
  ]
  edge
  [
    source 8
    target 2
  ]
  edge
  [
    source 9
    target 2
  ]
  edge
  [
    source 10
    target 0
  ]
  edge
  [
    source 10
    target 4
  ]
  edge
  [
    source 10
    target 5
  ]
  edge
  [
    source 11
    target 0
  ]
  edge
  [
    source 12
    target 0
  ]
  edge
  [
    source 12
    target 3
  ]
  edge
  [
    source 13
    target 0
  ]
  edge
  [
    source 13
    target 1
  ]
  edge
  [
    source 13
    target 2
  ]
  edge
  [
    source 13
    target 3
  ]
  edge
  [
    source 16
    target 5
  ]
  edge
  [
    source 16
    target 6
  ]
  edge
  [
    source 17
    target 0
  ]
  edge
  [
    source 17
    target 1
  ]
  edge
  [
    source 19
    target 0
  ]
  edge
  [
    source 19
    target 1
  ]
  edge
  [
    source 21
    target 0
  ]
  edge
  [
    source 21
    target 1
  ]
  edge
  [
    source 25
    target 23
  ]
  edge
  [
    source 25
    target 24
  ]
  edge
  [
    source 27
    target 2
  ]
  edge
  [
    source 27
    target 23
  ]
  edge
  [
    source 27
    target 24
  ]
  edge
  [
    source 28
    target 2
  ]
  edge
  [
    source 29
    target 23
  ]
  edge
  [
    source 29
    target 26
  ]
  edge
  [
    source 30
    target 1
  ]
  edge
  [
    source 30
    target 8
  ]
  edge
  [
    source 31
    target 0
  ]
  edge
  [
    source 31
    target 24
  ]
  edge
  [
    source 31
    target 25
  ]
  edge
  [
    source 31
    target 28
  ]
  edge
  [
    source 32
    target 2
  ]
  edge
  [
    source 32
    target 8
  ]
  edge
  [
    source 32
    target 14
  ]
  edge
  [
    source 32
    target 15
  ]
  edge
  [
    source 32
    target 18
  ]
  edge
  [
    source 32
    target 20
  ]
  edge
  [
    source 32
    target 22
  ]
  edge
  [
    source 32
    target 23
  ]
  edge
  [
    source 32
    target 29
  ]
  edge
  [
    source 32
    target 30
  ]
  edge
  [
    source 32
    target 31
  ]
  edge
  [
    source 33
    target 8
  ]
  edge
  [
    source 33
    target 9
  ]
  edge
  [
    source 33
    target 13
  ]
  edge
  [
    source 33
    target 14
  ]
  edge
  [
    source 33
    target 15
  ]
  edge
  [
    source 33
    target 18
  ]
  edge
  [
    source 33
    target 19
  ]
  edge
  [
    source 33
    target 20
  ]
  edge
  [
    source 33
    target 22
  ]
  edge
  [
    source 33
    target 23
  ]
  edge
  [
    source 33
    target 26
  ]
  edge
  [
    source 33
    target 27
  ]
  edge
  [
    source 33
    target 28
  ]
  edge
  [
    source 33
    target 29
  ]
  edge
  [
    source 33
    target 30
  ]
  edge
  [
    source 33
    target 31
  ]
  edge
  [
    source 33
    target 32
  ]
]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml-default-attrs.xml0000644000175100001710000000200500000000000027707 0ustar00runnerdocker00000000000000

  
    TRUE
  
  
    male
  
  
    20
  
  
    FALSE
  
  
    FALSE30
    female
    
    
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml-hsa05010.xml0000644000175100001710000003711000000000000026276 0ustar00runnerdocker00000000000000


  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
    hsa
    05010
    
      compound
      1
      cpd:C00027
      C00027
      
      
      
    
    
      compound
      2
      cpd:C00070
      C00070...
      
      
      
    
    
      compound
      2
      cpd:C14818
      C00070...
      
      
      
    
    
      gene
      4
      hsa:51107
      APH1A
      Q96BI3
      APH1A
      GO:0005515,GO:0016021,GO:0016485,GO:0043085
    
    
      gene
      6
      hsa:4311
      MME
      P08473
      MME
      GO:0004245,GO:0016021,GO:0016787,GO:0008237,GO:0007267,GO:0006508,GO:0005887,GO:0005886,GO:0016020
    
    
      gene
      7
      hsa:2932
      GSK3B
      P49841
      GSK3B
      GO:0016301,GO:0016740,GO:0005977,GO:0004696,GO:0005524,GO:0004674,GO:0006468,GO:0004672
    
    
      gene
      8
      hsa:4137
      MAPT
      
      
      
    
    
      gene
      9
      hsa:836
      CASP3
      P42574
      CASP3
      GO:0016787,GO:0008233,GO:0006917,GO:0030693,GO:0008234,GO:0006915,GO:0006508
    
    
      gene
      11
      hsa:840
      CASP7
      P55210
      CASP7
      GO:0008233,GO:0016787,GO:0008632,GO:0008234,GO:0006915,GO:0005737,GO:0006508
    
    
      gene
      12
      hsa:55851
      PSENEN
      Q9NZ42
      PEN2
      
    
    
      gene
      13
      hsa:6622
      SNCA
      P37840
      SNCA
      GO:0005737,GO:0007417,GO:0006916
    
    
      gene
      14
      hsa:5663
      PSEN1...
      P49768
      
      GO:0016021,GO:0007059,GO:0007001,GO:0006916,GO:0000776,GO:0000775,GO:0005639,GO:0005624,GO:0005783,GO:0007242
    
    
      gene
      14
      hsa:5664
      PSEN1...
      P49810
      PSEN2
      GO:0016021,GO:0008632,GO:0007059,GO:0007001,GO:0000776,GO:0005639,GO:0005783,GO:0007242
    
    
      gene
      15
      hsa:836
      CASP3
      P42574
      CASP3
      GO:0016787,GO:0008233,GO:0006917,GO:0030693,GO:0008234,GO:0006915,GO:0006508
    
    
      gene
      16
      hsa:23385
      NCSTN
      Q92542
      NCSTN
      GO:0016021,GO:0016485,GO:0006508
    
    
      gene
      17
      hsa:2
      A2M
      P01023
      A2M
      GO:0017114,GO:0004866,GO:0051260,GO:0019899,GO:0008320,GO:0006886,GO:0004867
    
    
      gene
      18
      hsa:3416
      IDE
      P14735
      IDE
      GO:0004231,GO:0016787,GO:0008237,GO:0007548,GO:0007267,GO:0007165,GO:0006508,GO:0005777,GO:0005625,GO:0005615,GO:0004871,GO:0003824,GO:0004222
    
    
      gene
      19
      hsa:8883
      APPBP1
      Q13564
      APPBP1
      GO:0007165,GO:0005737,GO:0003824
    
    
      gene
      20
      hsa:23621
      BACE1...
      P56817
      BACE1
      GO:0004190,GO:0008233,GO:0009049,GO:0016021,GO:0016787,GO:0050435,GO:0005768,GO:0006508,GO:0005794,GO:0006509,GO:0008798,GO:0005887,GO:0004194
    
    
      gene
      20
      hsa:25825
      BACE1...
      Q9Y5Z0
      
      GO:0004190,GO:0009049,GO:0016021,GO:0016787,GO:0009306,GO:0006464,GO:0005624,GO:0006508,GO:0004194
    
    
      gene
      22
      hsa:351
      APP, AD1
      P05067
      APP
      GO:0008201,GO:0007155,GO:0006915,GO:0005905,GO:0006897,GO:0016021,GO:0005515,GO:0005887,GO:0005576,GO:0004867
    
    
      gene
      23
      hsa:2597
      GAPDH, GAPD
      P04406
      
      
    
    
      gene
      24
      hsa:348
      APOE, AD2
      P02649
      APOE
      GO:0001540,GO:0008015,GO:0007271,GO:0005737,GO:0005319,GO:0008201,GO:0006869,GO:0008289
    
    
      gene
      25
      hsa:322
      APBB1, RIR
      O00213
      APBB1
      GO:0007165,GO:0001540,GO:0008134,GO:0045449,GO:0050821,GO:0005634,GO:0030308,GO:0045749,GO:0035035,GO:0007050,GO:0030048,GO:0045202,GO:0030027,GO:0030426,GO:0007409,GO:0050760
    
    
      gene
      26
      hsa:4023
      LPL
      P06858
      LPL
      GO:0005319,GO:0004465,GO:0016787,GO:0016042,GO:0008201,GO:0008015,GO:0006631,GO:0005576,GO:0006629,GO:0003824
    
    
      gene
      27
      hsa:4035
      LRP1, APR, A2MR
      Q07954
      LRP1
      GO:0016021,GO:0004872,GO:0016020,GO:0008283,GO:0008034,GO:0006629,GO:0005887,GO:0005624,GO:0005509,GO:0005319,GO:0006897,GO:0005905
    
    
      4.95265
      0.693152
      0.185704
      0.670769
      0.145403
      0.05698
      0.172033
      0.00546283
      2.93737
      0.556617
      0.176068
      0.483953
    
    
      0.50493
      0.112413
      0.111437
      0.033196
      0.145403
      0.0605613
      0.181454
      0.00580618
      -0
      -0
      0.171988
      -0
    
    
      7.8977
      1
      1
      0.995807
      9.64739
      1
      1
      0.998753
      2.93737
      0.400174
      0.136512
      0.347932
    
    
      3.5307
      0.498171
      0.123255
      0.455066
      4.0529
      0.366988
      0.0822633
      0.344877
    
    
      5.41325
      1
      1
      0.976533
      -0
      -0
      0.151863
      -0
      9.56439
      1
      1
      0.998679
    
    
      3.20433
      0.383125
      0.0883496
      0.341558
      0.145403
      0.0605613
      0.181454
      0.00580618
      10.0077
      1
      1
      0.999029
    
    
    
    
      0.50493
      0.0888891
      0.0880977
      0.0262494
      5.53428
      1
      1
      0.978422
      -0
      -0
      0.137908
      -0
    
    
      3.17114
      0.346041
      0.0972198
      0.307624
      2.60224
      1
      1
      0.835317
      -0
      -0
      0.137908
      -0
    
    
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml-lenient.xml0000644000175100001710000000043200000000000026570 0ustar00runnerdocker00000000000000

	
		
		
		
		
		
	

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml-malformed.xml0000644000175100001710000000211400000000000027077 0ustar00runnerdocker00000000000000


  yellYw
  
  
  
  1
   ta>
       green
  
  true
    
    
    
  blue
  0  
  red "w"
    
          false
    
    
  t
  
 i 
  
  
  
  

	
		
		
		
		
		
	

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml.c0000644000175100001710000001277100000000000024567 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/
#include 
#include 
#include      /* unlink */

void custom_warning_handler (const char *reason, const char *file,
                             int line, int igraph_errno) {
    printf("Warning: %s\n", reason);
}

void dump_graph(const char* header, const igraph_t* g) {
    fputs(header, stdout);
    printf("Vertices: %li\n", (long int) igraph_vcount(g));
    printf("Edges: %li\n", (long int) igraph_ecount(g));
    printf("Directed: %i\n", (int) igraph_is_directed(g));
    igraph_write_graph_edgelist(g, stdout);
}

void dump_vertex_attribute_bool(const char* name, const igraph_t* g) {
    long int i, n = igraph_vcount(g);

    printf("Vertex attribute '%s':", name);
    for (i = 0; i < n; i++) {
        printf(" %s", VAB(g, name, i) ? "true" : "false");
    }
    printf("\n");
}

void dump_vertex_attribute_numeric(const char* name, const igraph_t* g) {
    long int i, n = igraph_vcount(g);

    printf("Vertex attribute '%s':", name);
    for (i = 0; i < n; i++) {
        printf(" %g", (float)VAN(g, name, i));
    }
    printf("\n");
}

void dump_vertex_attribute_string(const char* name, const igraph_t* g) {
    long int i, n = igraph_vcount(g);

    printf("Vertex attribute '%s':", name);
    for (i = 0; i < n; i++) {
        printf(" %s", VAS(g, name, i));
    }
    printf("\n");
}

int main() {
    igraph_t g;
    igraph_error_handler_t* oldhandler;
    igraph_warning_handler_t* oldwarnhandler;
    int result;
    FILE *ifile, *ofile;

    igraph_set_attribute_table(&igraph_cattribute_table);

    /* GraphML */
    ifile = fopen("test.gxl", "r");
    if (ifile == 0) {
        return 10;
    }

    oldhandler = igraph_set_error_handler(igraph_error_handler_ignore);
    oldwarnhandler = igraph_set_warning_handler(custom_warning_handler);
    if ((result = igraph_read_graph_graphml(&g, ifile, 0))) {
        /* maybe it is simply disabled at compile-time */
        if (result == IGRAPH_UNIMPLEMENTED) {
            return 77;
        }
        return 1;
    }
    igraph_set_error_handler(oldhandler);

    fclose(ifile);

    /* Write it back */
    ofile = fopen("test2.gxl", "w");
    /* If we can't create the test file, just skip the test */
    if (ofile) {
        if ((result = igraph_write_graph_graphml(&g, ofile, /*prefixattr=*/ 1))) {
            return 1;
        }
        fclose(ofile);
        unlink("test2.gxl");
    }
    dump_graph("The directed graph:\n", &g);
    igraph_destroy(&g);

    /* The same with undirected graph */
    ifile = fopen("test.gxl", "r");
    if ((result = igraph_read_graph_graphml(&g, ifile, 0))) {
        return 1;
    }
    fclose(ifile);
    dump_graph("The undirected graph:\n", &g);
    igraph_destroy(&g);

    /* Test a GraphML file with default attributes */
    ifile = fopen("graphml-default-attrs.xml", "r");
    if ((result = igraph_read_graph_graphml(&g, ifile, 0))) {
        return 1;
    }
    fclose(ifile);
    dump_graph("The directed graph:\n", &g);
    dump_vertex_attribute_bool("type", &g);
    dump_vertex_attribute_string("gender", &g);
    dump_vertex_attribute_numeric("age", &g);
    dump_vertex_attribute_bool("retired", &g);
    igraph_destroy(&g);

    /* Test a GraphML file with namespaces */
    ifile = fopen("graphml-namespace.xml", "r");
    if ((result = igraph_read_graph_graphml(&g, ifile, 0))) {
        return 1;
    }
    fclose(ifile);
    dump_graph("The undirected graph:\n", &g);
    igraph_destroy(&g);

    /* Test a not-really-valid GraphML file as it has no namespace information */
    ifile = fopen("graphml-lenient.xml", "r");
    if ((result = igraph_read_graph_graphml(&g, ifile, 0))) {
        return 1;
    }
    fclose(ifile);
    dump_graph("The undirected graph:\n", &g);
    igraph_destroy(&g);

    /* Test a completely malformed GraphML file */
    ifile = fopen("graphml-malformed.xml", "r");
    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_set_warning_handler(igraph_warning_handler_ignore);
    result = igraph_read_graph_graphml(&g, ifile, 0);
    if (result != IGRAPH_PARSEERROR) {
        return 1;
    }
    fclose(ifile);
    igraph_destroy(&g);

    /* Restore the old error handler */
    igraph_set_error_handler(igraph_error_handler_abort);

    /* Restore the old warning handler */
    igraph_set_warning_handler(oldwarnhandler);

    /* There were sometimes problems with this file */
    /* Only if called from R though, and only on random occasions, once in every
       ten reads. Do testing here doesn't make much sense, but if we have the file
       then let's do it anyway. */
    ifile = fopen("graphml-hsa05010.xml", "r");
    igraph_read_graph_graphml(&g, ifile, 0);
    fclose(ifile);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/graphml.out0000644000175100001710000000122300000000000025142 0ustar00runnerdocker00000000000000Warning: unknown attribute key 'd3' in a  tag, ignoring attribute
The directed graph:
Vertices: 6
Edges: 7
Directed: 0
0 1
0 2
1 3
2 3
2 4
3 5
4 5
Warning: unknown attribute key 'd3' in a  tag, ignoring attribute
The undirected graph:
Vertices: 6
Edges: 7
Directed: 0
0 1
0 2
1 3
2 3
2 4
3 5
4 5
The directed graph:
Vertices: 3
Edges: 2
Directed: 1
0 1
0 2
Vertex attribute 'type': false true true
Vertex attribute 'gender': male female male
Vertex attribute 'age': 30 20 20
Vertex attribute 'retired': false false false
The undirected graph:
Vertices: 3
Edges: 2
Directed: 0
0 1
1 2
The undirected graph:
Vertices: 3
Edges: 2
Directed: 0
0 1
1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_add_edges.c0000644000175100001710000000501100000000000026353 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        fprintf(f, " %li", (long int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t g;
    igraph_vector_t v;
    int ret;

    /* Create graph */
    igraph_vector_init(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, 1);

    /* Add edges */
    igraph_vector_resize(&v, 4);
    VECTOR(v)[0] = 2;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 3;
    VECTOR(v)[3] = 3;
    igraph_add_edges(&g, &v, 0);

    /* Check result */
    igraph_get_edgelist(&g, &v, 0);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    /* Error, vector length */
    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_resize(&v, 3);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 2;
    ret = igraph_add_edges(&g, &v, 0);
    if (ret != IGRAPH_EINVEVECTOR) {
        return 1;
    }

    /* Check result */
    igraph_get_edgelist(&g, &v, 0);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    /* Error, vector ids */
    igraph_vector_resize(&v, 4);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 2;
    VECTOR(v)[3] = 4;
    ret = igraph_add_edges(&g, &v, 0);
    if (ret != IGRAPH_EINVVID) {
        return 2;
    }

    /* Check result */
    igraph_get_edgelist(&g, &v, 0);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    igraph_vector_destroy(&v);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_add_edges.out0000644000175100001710000000011300000000000026736 0ustar00runnerdocker00000000000000 0 1 1 1 2 2 2 2 2 3 3 3
 0 1 1 1 2 2 2 2 2 3 3 3
 0 1 1 1 2 2 2 2 2 3 3 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_add_vertices.c0000644000175100001710000000332300000000000027114 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g1;
    igraph_vector_t v1;
    int ret;

    /* Create a graph */
    igraph_vector_init(&v1, 8);
    VECTOR(v1)[0] = 0;
    VECTOR(v1)[1] = 1;
    VECTOR(v1)[2] = 1;
    VECTOR(v1)[3] = 2;
    VECTOR(v1)[4] = 2;
    VECTOR(v1)[5] = 3;
    VECTOR(v1)[6] = 2;
    VECTOR(v1)[7] = 2;
    igraph_create(&g1, &v1, 0, 0);
    igraph_vector_destroy(&v1);

    /* Add more vertices */
    igraph_add_vertices(&g1, 10, 0);
    if (igraph_vcount(&g1) != 14) {
        return 1;
    }

    /* Add more vertices */
    igraph_add_vertices(&g1, 0, 0);
    if (igraph_vcount(&g1) != 14) {
        return 2;
    }

    /* Error */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_add_vertices(&g1, -1, 0);
    if (ret != IGRAPH_EINVAL) {
        return 3;
    }

    igraph_destroy(&g1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_adjacency.c0000644000175100001710000000164300000000000026404 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_all_st_mincuts.c0000644000175100001710000001322000000000000027475 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_and_destroy(igraph_t *g,
                      igraph_real_t value,
                      igraph_vector_ptr_t *partitions,
                      igraph_vector_ptr_t *cuts) {
    long int i, e, m, n = igraph_vector_ptr_size(partitions);
    printf("Found %li cuts, value: %g\n", n, value);
    for (i = 0; i < n; i++) {
        igraph_vector_t *vec = VECTOR(*partitions)[i];
        igraph_vector_t *vec2 = cuts ? VECTOR(*cuts)[i] : 0;
        printf("Partition %li: ", i);
        igraph_vector_print(vec);
        if (vec2) {
            printf("Cut %li:\n", i);
            m = igraph_vector_size(vec2);
            for (e = 0; e < m; e++) {
                igraph_integer_t from, to;
                igraph_edge(g, VECTOR(*vec2)[e], &from, &to);
                if (igraph_is_directed(g)) {
                    printf("  %" IGRAPH_PRId " -> %" IGRAPH_PRId "\n", from, to);
                } else {
                    printf("  %" IGRAPH_PRId " -- %" IGRAPH_PRId "\n", from, to);
                }
            }
        }

        igraph_vector_destroy(vec);
        if (vec2) {
            igraph_vector_destroy(vec2);
        }
        igraph_free(vec);
        if (vec2) {
            igraph_free(vec2);
        }
    }
    igraph_vector_ptr_destroy(partitions);
    if (cuts) {
        igraph_vector_ptr_destroy(cuts);
    }
    printf("\n");

    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t partitions;
    igraph_vector_ptr_t cuts;
    igraph_real_t value;

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4,
                 -1);

    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 0, /*target=*/ 4,
                          /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */

    igraph_small(&g, 6, IGRAPH_DIRECTED, 0, 1, 1, 2, 1, 3, 2, 4, 3, 4, 4, 5, -1);
    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 0, /*target=*/ 5, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */

    igraph_small(&g, 6, IGRAPH_DIRECTED, 0, 1, 1, 2, 1, 3, 2, 4, 3, 4, 4, 5, -1);
    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 0, /*target=*/ 4, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */

    igraph_small(&g, 9, IGRAPH_DIRECTED, 0, 1, 0, 2, 1, 3, 2, 3,
                 1, 4, 4, 2, 1, 5, 5, 2, 1, 6, 6, 2, 1, 7, 7, 2, 1, 8, 8, 2,
                 -1);
    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 0, /*target=*/ 3, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */
    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 1, 0, 2, 0, 2, 1, 3, 2,
                 -1);

    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 2, /*target=*/ 0, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */
    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 1, 0, 2, 0, 2, 1, 2, 3,
                 -1);

    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 2, /*target=*/ 0, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    /* ---------------------------------------------------------------- */
    igraph_small(&g, 9, IGRAPH_DIRECTED,
                 0, 4,  0, 7,  1, 6,  2, 1,  3, 8,  4, 0,  4, 2,
                 4, 5,  5, 0,  5, 3,  6, 7,  7, 8,
                 -1);

    igraph_vector_ptr_init(&partitions, 0);
    igraph_vector_ptr_init(&cuts, 0);
    igraph_all_st_mincuts(&g, &value, &cuts, &partitions,
                          /*source=*/ 0, /*target=*/ 8, /*capacity=*/ 0);

    print_and_destroy(&g, value, &partitions, &cuts);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_all_st_mincuts.out0000644000175100001710000000217500000000000030071 0ustar00runnerdocker00000000000000Found 4 cuts, value: 1
Partition 0: 0
Cut 0:
  0 -> 1
Partition 1: 0 1
Cut 1:
  1 -> 2
Partition 2: 0 1 2
Cut 2:
  2 -> 3
Partition 3: 0 1 2 3
Cut 3:
  3 -> 4

Found 2 cuts, value: 1
Partition 0: 0
Cut 0:
  0 -> 1
Partition 1: 0 4 3 2 1
Cut 1:
  4 -> 5

Found 1 cuts, value: 1
Partition 0: 0
Cut 0:
  0 -> 1

Found 4 cuts, value: 2
Partition 0: 0
Cut 0:
  0 -> 1
  0 -> 2
Partition 1: 0 1 8 7 6 5 4
Cut 1:
  0 -> 2
  1 -> 3
Partition 2: 0 2
Cut 2:
  0 -> 1
  2 -> 3
Partition 3: 0 2 1 8 7 6 5 4
Cut 3:
  1 -> 3
  2 -> 3

Found 2 cuts, value: 2
Partition 0: 2
Cut 0:
  2 -> 0
  2 -> 1
Partition 1: 2 1
Cut 1:
  1 -> 0
  2 -> 0

Found 2 cuts, value: 2
Partition 0: 2 3
Cut 0:
  2 -> 0
  2 -> 1
Partition 1: 2 3 1
Cut 1:
  1 -> 0
  2 -> 0

Found 8 cuts, value: 2
Partition 0: 0
Cut 0:
  0 -> 4
  0 -> 7
Partition 1: 0 4 2 1 6
Cut 1:
  0 -> 7
  4 -> 5
Partition 2: 0 4 2 1 6 5
Cut 2:
  0 -> 7
  5 -> 3
Partition 3: 0 4 2 1 6 5 3
Cut 3:
  0 -> 7
  3 -> 8
Partition 4: 0 7
Cut 4:
  0 -> 4
  7 -> 8
Partition 5: 0 7 4 2 1 6
Cut 5:
  4 -> 5
  7 -> 8
Partition 6: 0 7 4 2 1 6 5
Cut 6:
  5 -> 3
  7 -> 8
Partition 7: 0 7 4 2 1 6 5 3
Cut 7:
  3 -> 8
  7 -> 8

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_atlas.c0000644000175100001710000000300700000000000025563 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    int ret;

    igraph_atlas(&g, 45);
    igraph_write_graph_edgelist(&g, stdout);
    printf("\n");
    igraph_destroy(&g);

    igraph_atlas(&g, 0);
    igraph_write_graph_edgelist(&g, stdout);
    printf("\n");
    igraph_destroy(&g);

    igraph_atlas(&g, 1252);
    igraph_write_graph_edgelist(&g, stdout);
    printf("\n");
    igraph_destroy(&g);

    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_atlas(&g, -1);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }

    ret = igraph_atlas(&g, 1253);
    if (ret != IGRAPH_EINVAL) {
        return 2;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_atlas.out0000644000175100001710000000016300000000000026150 0ustar00runnerdocker000000000000000 4
1 2
1 3
1 4
2 3
2 4
3 4


0 1
0 2
0 3
0 4
0 5
0 6
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
4 5
4 6
5 6

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_average_path_length.c0000644000175100001710000000114200000000000030444 0ustar00runnerdocker00000000000000
#include 

int main() {
    igraph_t graph;
    igraph_real_t result;

    /* Create a random preferential attachment graph. */
    igraph_barabasi_game(&graph, 30, /*power=*/ 1, 30, 0, 0, /*A=*/ 1,
                         IGRAPH_DIRECTED, IGRAPH_BARABASI_BAG,
                         /*start_from=*/ 0);

    /* Compute the average shortest path length. */
    igraph_average_path_length(&graph, &result, NULL, IGRAPH_UNDIRECTED, 1);
    printf("Average length of all-pairs shortest paths: %g\n", result);

    /* Destroy no-longer-needed objects. */
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_barabasi_game.c0000644000175100001710000000726000000000000027221 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t v, v2;
    int i, ret;

    igraph_barabasi_game(&g, 10, /*power=*/ 1, 2, 0, 0, /*A=*/ 1, 1,
                         IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    if (igraph_ecount(&g) != 18) {
        return 1;
    }
    if (igraph_vcount(&g) != 10) {
        return 2;
    }
    if (!igraph_is_directed(&g)) {
        return 3;
    }

    igraph_vector_init(&v, 0);
    igraph_get_edgelist(&g, &v, 0);
    for (i = 0; i < igraph_ecount(&g); i++) {
        if (VECTOR(v)[2 * i] <= VECTOR(v)[2 * i + 1]) {
            return 4;
        }
    }
    igraph_destroy(&g);

    /* out-degree sequence */
    igraph_vector_resize(&v, 10);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 3;
    VECTOR(v)[3] = 3;
    VECTOR(v)[4] = 4;
    VECTOR(v)[5] = 5;
    VECTOR(v)[6] = 6;
    VECTOR(v)[7] = 7;
    VECTOR(v)[8] = 8;
    VECTOR(v)[9] = 9;

    igraph_barabasi_game(&g, 10, /*power=*/ 1, 0, &v, 0, /*A=*/ 1, 1,
                         IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    if (igraph_ecount(&g) != igraph_vector_sum(&v)) {
        return 5;
    }
    igraph_vector_init(&v2, 0);
    igraph_degree(&g, &v2, igraph_vss_all(), IGRAPH_OUT, 1);
    for (i = 0; i < igraph_vcount(&g); i++) {
        if (VECTOR(v)[i] != VECTOR(v2)[i]) {
            igraph_vector_print(&v);
            printf("\n");
            igraph_vector_print(&v2);
            return 6;
        }
    }
    igraph_vector_destroy(&v);
    igraph_vector_destroy(&v2);
    igraph_destroy(&g);

    /* outpref, we cannot really test this quantitatively,
       would need to set random seed */
    igraph_barabasi_game(&g, 10, /*power=*/ 1, 2, 0, 1, /*A=*/ 1, 1,
                         IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    igraph_vector_init(&v, 0);
    igraph_get_edgelist(&g, &v, 0);
    for (i = 0; i < igraph_ecount(&g); i++) {
        if (VECTOR(v)[2 * i] <= VECTOR(v)[2 * i + 1]) {
            return 7;
        }
    }
    if (!igraph_is_directed(&g)) {
        return 8;
    }
    igraph_vector_destroy(&v);
    igraph_destroy(&g);

    /* Error tests */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_barabasi_game(&g, -10, /*power=*/ 1, 1, 0, 0, /*A=*/ 1, 0,
                               IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    if (ret != IGRAPH_EINVAL) {
        return 9;
    }
    ret = igraph_barabasi_game(&g, 10, /*power=*/ 1, -2, 0, 0, /*A=*/ 1, 0,
                               IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    if (ret != IGRAPH_EINVAL) {
        return 10;
    }
    igraph_vector_init(&v, 9);
    ret = igraph_barabasi_game(&g, 10, /*power=*/ 1, 0, &v, 0, /*A=*/ 1, 0,
                               IGRAPH_BARABASI_BAG, /*start_from=*/ 0);
    if (ret != IGRAPH_EINVAL) {
        return 11;
    }
    igraph_vector_destroy(&v);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_barabasi_game2.c0000644000175100001710000000707700000000000027311 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g;
    igraph_bool_t simple;

    igraph_barabasi_game(/* graph=    */ &g,
                                         /* n=        */ 100,
                                         /* power=    */ 1.0,
                                         /* m=        */ 2,
                                         /* outseq=   */ 0,
                                         /* outpref=  */ 0,
                                         /* A=        */ 1.0,
                                         /* directed= */ IGRAPH_DIRECTED,
                                         /* algo=     */ IGRAPH_BARABASI_PSUMTREE,
                                         /* start_from= */ 0);

    if (igraph_ecount(&g) != 197) {
        return 1;
    }
    if (igraph_vcount(&g) != 100) {
        return 2;
    }
    igraph_is_simple(&g, &simple);
    if (!simple) {
        return 3;
    }

    igraph_destroy(&g);

    /* ============================== */

    igraph_barabasi_game(/* graph=    */ &g,
                                         /* n=        */ 100,
                                         /* power=    */ 1.0,
                                         /* m=        */ 2,
                                         /* outseq=   */ 0,
                                         /* outpref=  */ 0,
                                         /* A=        */ 1.0,
                                         /* directed= */ IGRAPH_DIRECTED,
                                         /* algo=     */ IGRAPH_BARABASI_PSUMTREE_MULTIPLE,
                                         /* start_from= */ 0);

    if (igraph_ecount(&g) != 198) {
        return 4;
    }
    if (igraph_vcount(&g) != 100) {
        return 5;
    }
    igraph_is_simple(&g, &simple);
    if (simple) {
        return 6;
    }

    igraph_destroy(&g);

    /* ============================== */

    igraph_barabasi_game(/* graph=    */ &g,
                                         /* n=        */ 100,
                                         /* power=    */ 1.0,
                                         /* m=        */ 2,
                                         /* outseq=   */ 0,
                                         /* outpref=  */ 0,
                                         /* A=        */ 1.0,
                                         /* directed= */ IGRAPH_DIRECTED,
                                         /* algo=     */ IGRAPH_BARABASI_BAG,
                                         /* start_from= */ 0);

    if (igraph_ecount(&g) != 198) {
        return 7;
    }
    if (igraph_vcount(&g) != 100) {
        return 8;
    }
    igraph_is_simple(&g, &simple);
    if (simple) {
        return 9;
    }

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs.c0000644000175100001710000000521200000000000025231 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

igraph_bool_t bfs_callback(const igraph_t *graph,
                           igraph_integer_t vid,
                           igraph_integer_t pred,
                           igraph_integer_t succ,
                           igraph_integer_t rank,
                           igraph_integer_t dist,
                           void *extra) {
    printf(" %li", (long int) vid);
    return 0;
}

int main() {

    igraph_t graph, ring;
    igraph_vector_t order, rank, father, pred, succ, dist;

    /* Create a disjoint union of two rings */
    igraph_ring(&ring, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_disjoint_union(&graph, &ring, &ring);
    igraph_destroy(&ring);

    /* Initialize the vectors where the result will be stored. Any of these
     * can be omitted and replaced with a null pointer when calling
     * igraph_bfs() */
    igraph_vector_init(&order, 0);
    igraph_vector_init(&rank, 0);
    igraph_vector_init(&father, 0);
    igraph_vector_init(&pred, 0);
    igraph_vector_init(&succ, 0);
    igraph_vector_init(&dist, 0);

    /* Now call the BFS function */
    igraph_bfs(&graph, /*root=*/0, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, /*restricted=*/ 0,
               &order, &rank, &father, &pred, &succ, &dist,
               /*callback=*/ 0, /*extra=*/ 0);

    /* Print the results */
    igraph_vector_print(&order);
    igraph_vector_print(&rank);
    igraph_vector_print(&father);
    igraph_vector_print(&pred);
    igraph_vector_print(&succ);
    igraph_vector_print(&dist);

    /* Cleam up after ourselves */
    igraph_vector_destroy(&order);
    igraph_vector_destroy(&rank);
    igraph_vector_destroy(&father);
    igraph_vector_destroy(&pred);
    igraph_vector_destroy(&succ);
    igraph_vector_destroy(&dist);

    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs.out0000644000175100001710000000044500000000000025621 0ustar00runnerdocker000000000000000 1 9 2 8 3 7 4 6 5 10 11 19 12 18 13 17 14 16 15
0 1 3 5 7 9 8 6 4 2 10 11 13 15 17 19 18 16 14 12
-1 0 1 2 3 4 7 8 9 0 -1 10 11 12 13 14 17 18 19 10
-1 0 9 8 7 6 4 3 2 1 -1 10 19 18 17 16 14 13 12 11
1 9 8 7 6 -1 5 4 3 2 11 19 18 17 16 -1 15 14 13 12
0 1 2 3 4 5 4 3 2 1 0 1 2 3 4 5 4 3 2 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs_callback.c0000644000175100001710000000361200000000000027047 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

igraph_bool_t bfs_callback(const igraph_t *graph,
                           igraph_integer_t vid,
                           igraph_integer_t pred,
                           igraph_integer_t succ,
                           igraph_integer_t rank,
                           igraph_integer_t dist,
                           void *extra) {
    printf(" %li", (long int) vid);
    return 0;
}

int main() {
    igraph_t graph, ring;

    /* Create a disjoint union of two rings */
    igraph_ring(&ring, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_disjoint_union(&graph, &ring, &ring);
    igraph_destroy(&ring);

    /* Now call the BFS function */
    printf("(");
    igraph_bfs(&graph, /*root=*/0, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, /*restricted=*/ 0,
               /*order=*/ 0, /*rank=*/ 0, /*father=*/ 0, /*pred=*/ 0,
               /*succ=*/ 0, /*dist=*/ 0,
               /*callback=*/ bfs_callback, /*extra=*/ 0);
    printf(" )\n");

    /* Cleam up after ourselves */
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs_callback.out0000644000175100001710000000006600000000000027434 0ustar00runnerdocker00000000000000( 0 1 9 2 8 3 7 4 6 5 10 11 19 12 18 13 17 14 16 15 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs_simple.c0000644000175100001710000000302700000000000026604 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void vector_print(igraph_vector_t *v) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int main() {

    igraph_t g;
    igraph_vector_t vids, layers, parents;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 0);

    igraph_vector_init(&vids, 0);
    igraph_vector_init(&layers, 0);
    igraph_vector_init(&parents, 0);

    igraph_bfs_simple(&g, 0, IGRAPH_ALL, &vids, &layers, &parents);

    vector_print(&vids);
    vector_print(&layers);
    vector_print(&parents);

    igraph_destroy(&g);

    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&layers);
    igraph_vector_destroy(&parents);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bfs_simple.out0000644000175100001710000000010200000000000027160 0ustar00runnerdocker00000000000000 0 1 2 3 4 5 6 7 8 9
 0 1 2 3 4 5 6 7 8 9 10
 0 0 1 2 3 4 5 6 7 8
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_biconnected_components.c0000644000175100001710000000524600000000000031210 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

void sort_and_print_vector(igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    igraph_vector_sort(v);
    for (i = 0; i < n; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

void warning_handler_ignore(const char* reason, const char* file, int line, int e) {
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t result;
    igraph_integer_t no;
    long int i;

    igraph_set_warning_handler(warning_handler_ignore);

    igraph_vector_ptr_init(&result, 0);
    igraph_small(&g, 7, 0, 0, 1, 1, 2, 2, 3, 3, 0, 2, 4, 4, 5, 2, 5, -1);

    igraph_biconnected_components(&g, &no, 0, 0, &result, 0);
    if (no != 2 || no != igraph_vector_ptr_size(&result)) {
        return 1;
    }
    for (i = 0; i < no; i++) {
        sort_and_print_vector((igraph_vector_t*)VECTOR(result)[i]);
        igraph_vector_destroy((igraph_vector_t*)VECTOR(result)[i]);
        igraph_free((igraph_vector_t*)VECTOR(result)[i]);
    }

    igraph_biconnected_components(&g, &no, 0, &result, 0, 0);
    if (no != 2 || no != igraph_vector_ptr_size(&result)) {
        return 2;
    }
    for (i = 0; i < no; i++) {
        sort_and_print_vector((igraph_vector_t*)VECTOR(result)[i]);
        igraph_vector_destroy((igraph_vector_t*)VECTOR(result)[i]);
        igraph_free((igraph_vector_t*)VECTOR(result)[i]);
    }

    igraph_biconnected_components(&g, &no, &result, 0, 0, 0);
    if (no != 2 || no != igraph_vector_ptr_size(&result)) {
        return 3;
    }
    for (i = 0; i < no; i++) {
        sort_and_print_vector((igraph_vector_t*)VECTOR(result)[i]);
        igraph_vector_destroy((igraph_vector_t*)VECTOR(result)[i]);
        igraph_free((igraph_vector_t*)VECTOR(result)[i]);
    }

    igraph_vector_ptr_destroy(&result);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_biconnected_components.out0000644000175100001710000000005400000000000031565 0ustar00runnerdocker00000000000000 2 4 5
 0 1 2 3
 4 5 6
 0 1 2 3
 4 5
 0 1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bipartite_create.c0000644000175100001710000000414100000000000027765 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_real_t edges2[] = {0, 1, 1, 2, 3, 4, 5, 6, 6, 5, 1, 4, 1, 6, 0, 3 };
    igraph_real_t edges3[] = {0, 1, 1, 2, 3, 4, 5, 6, 6, 5, 2, 4, 1, 6, 0, 3 };
    igraph_t g;
    igraph_vector_bool_t types;
    igraph_vector_t edges;
    long int i;
    int ret;

    igraph_vector_view(&edges, edges2, sizeof(edges2) / sizeof(igraph_real_t));
    igraph_vector_bool_init(&types, igraph_vector_max(&edges) + 1);
    for (i = 0; i < igraph_vector_bool_size(&types); i++) {
        VECTOR(types)[i] = i % 2;
    }
    igraph_create_bipartite(&g, &types, &edges, /*directed=*/ 1);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_vector_bool_destroy(&types);
    igraph_destroy(&g);

    /* Error handling */
    igraph_set_error_handler(igraph_error_handler_ignore);

    igraph_vector_view(&edges, edges3, sizeof(edges3) / sizeof(igraph_real_t));
    igraph_vector_bool_init(&types, igraph_vector_max(&edges) + 1);
    for (i = 0; i < igraph_vector_bool_size(&types); i++) {
        VECTOR(types)[i] = i % 2;
    }
    ret = igraph_create_bipartite(&g, &types, &edges, /*directed=*/ 1);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }
    igraph_vector_bool_destroy(&types);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bipartite_create.out0000644000175100001710000000004000000000000030344 0ustar00runnerdocker000000000000000 1
0 3
1 2
1 4
1 6
3 4
5 6
6 5
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_bipartite_projection.c0000644000175100001710000001314200000000000030677 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int check_projection(const igraph_t *graph,
                     const igraph_vector_bool_t *types,
                     const igraph_t *proj1,
                     const igraph_t *proj2) {
    igraph_integer_t vcount1, ecount1, vcount2, ecount2;
    igraph_bipartite_projection_size(graph, types, &vcount1, &ecount1,
                                     &vcount2, &ecount2);
    if (proj1 && igraph_vcount(proj1) != vcount1) {
        exit(10);
    }
    if (proj1 && igraph_ecount(proj1) != ecount1) {
        exit(11);
    }
    if (proj2 && igraph_vcount(proj2) != vcount2) {
        exit(12);
    }
    if (proj2 && igraph_ecount(proj2) != ecount2) {
        exit(13);
    }
    return 0;
}

int main() {

    igraph_t g, p1, p2, full, ring;
    igraph_vector_bool_t types;
    igraph_bool_t iso;
    long int i, m2 = 0, w, f, t;
    igraph_vector_t mult1, mult2;

    /*******************************************************/
    /* Full bipartite graph -> full graphs                 */
    /*******************************************************/

    igraph_vector_bool_init(&types, 0);
    igraph_full_bipartite(&g, &types, 5, 3, /*directed=*/ 0,
                          /*mode=*/ IGRAPH_ALL);

    /* Get both projections */
    igraph_bipartite_projection(&g, &types, &p1, &p2, 0, 0, /*probe1=*/ -1);
    check_projection(&g, &types, &p1, &p2);

    /* Check first projection */
    igraph_full(&full, igraph_vcount(&p1), /*directed=*/0, /*loops=*/0);
    igraph_isomorphic_bliss(&p1, &full, 0, 0, &iso, 0, 0,
                            IGRAPH_BLISS_FM, 0, 0);
    if (!iso) {
        return 1;
    }
    igraph_destroy(&full);

    /* Check second projection */
    igraph_full(&full, igraph_vcount(&p2), /*directed=*/0, /*loops=*/0);
    igraph_isomorphic_bliss(&p2, &full, 0, 0, &iso, 0, 0,
                            IGRAPH_BLISS_FM, 0, 0);
    if (!iso) {
        return 2;
    }
    igraph_destroy(&full);

    igraph_destroy(&p1);
    igraph_destroy(&p2);
    igraph_destroy(&g);
    igraph_vector_bool_destroy(&types);

    /*******************************************************/
    /* More sophisticated test                             */
    /*******************************************************/

    igraph_ring(&g, 100, /*directed=*/ 1, /*mutual=*/ 1,
                /*circular=*/ 1);
    igraph_vector_bool_init(&types, igraph_vcount(&g));
    for (i = 0; i < igraph_vector_bool_size(&types); i++) {
        VECTOR(types)[i] = i % 2 ? 0 : 1;
    }

    /* Get both projections */
    igraph_bipartite_projection(&g, &types, &p1, &p2, 0, 0, /*probe1=*/ -1);
    check_projection(&g, &types, &p1, &p2);

    /* Check first projection */
    igraph_ring(&ring, igraph_vcount(&g) / 2, /*directed=*/ 0,
                /*mutual=*/ 0, /*circular=*/ 1);
    igraph_isomorphic_bliss(&p1, &ring, 0, 0, &iso, 0, 0,
                            IGRAPH_BLISS_FM, 0, 0);
    if (!iso) {
        return 1;
    }

    /* Check second projection */
    igraph_isomorphic_bliss(&p2, &ring, 0, 0, &iso, 0, 0,
                            IGRAPH_BLISS_FM, 0, 0);
    if (!iso) {
        return 2;
    }
    igraph_destroy(&ring);

    igraph_destroy(&p1);
    igraph_destroy(&p2);
    igraph_destroy(&g);
    igraph_vector_bool_destroy(&types);

    /*******************************************************/
    /* Multiplicity test                                   */
    /*******************************************************/

    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 8, 1, 8, 2, 8, 3, 8, 4, 8, 4, 9, 5, 9, 6, 9, 7, 9, 0, 9,
                 -1);
    igraph_vector_bool_init(&types, igraph_vcount(&g));
    igraph_vector_bool_fill(&types, 1);
    VECTOR(types)[8] = VECTOR(types)[9] = 0;

    igraph_vector_init(&mult1, 0);
    igraph_vector_init(&mult2, 0);
    igraph_bipartite_projection(&g, &types, &p1, &p2, &mult1, &mult2,
                                /*probe=*/ -1);
    check_projection(&g, &types, &p1, &p2);

    if (igraph_vector_size(&mult1) != igraph_ecount(&p1)) {
        return 21;
    }
    if (igraph_vector_size(&mult2) != igraph_ecount(&p2)) {
        return 22;
    }
    if (VECTOR(mult1)[0] != 2) {
        return 23;
    }
    for (i = 0; i < igraph_vector_size(&mult2); i++) {
        if (VECTOR(mult2)[i] != 1 && VECTOR(mult2)[i] != 2) {
            return 24;
        }
        if (VECTOR(mult2)[i] == 2) {
            m2++;
            w = i;
        }
    }
    if (m2 != 1) {
        return 25;
    }
    f = IGRAPH_FROM(&p2, w);
    t = IGRAPH_TO(&p2, w);
    if (fmin(f, t) != 0 || fmax(f, t) != 4) {
        return 26;
    }

    igraph_vector_destroy(&mult1);
    igraph_vector_destroy(&mult2);
    igraph_destroy(&p1);
    igraph_destroy(&p2);
    igraph_destroy(&g);
    igraph_vector_bool_destroy(&types);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_cliques.c0000644000175100001710000001056700000000000026135 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int compare_vectors(const void *p1, const void *p2) {
    igraph_vector_t *v1, *v2;
    long s1, s2, i;

    v1 = *((igraph_vector_t **) p1);
    v2 = *((igraph_vector_t **) p2);
    s1 = igraph_vector_size(v1);
    s2 = igraph_vector_size(v2);
    if (s1 < s2) {
        return -1;
    }
    if (s1 > s2) {
        return 1;
    }
    for (i = 0; i < s1; ++i) {
        if (VECTOR(*v1)[i] < VECTOR(*v2)[i]) {
            return -1;
        }
        if (VECTOR(*v1)[i] > VECTOR(*v2)[i]) {
            return 1;
        }
    }
    return 0;
}

/* Takes a pointer vector of vectors. Sorts each vector, then sorts the pointer vector */
void canonicalize_list(igraph_vector_ptr_t *list) {
    long i, len;
    len = igraph_vector_ptr_size(list);
    for (i = 0; i < len; ++i) {
        igraph_vector_sort((igraph_vector_t *) VECTOR(*list)[i]);
    }
    qsort(&(VECTOR(*list)[0]), len, sizeof(void *), &compare_vectors);
}

void print_vector(igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    for (i = 0; i < n; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

void warning_handler_ignore(const char* reason, const char* file, int line, int e) {
}


struct userdata {
    int i;
    igraph_vector_ptr_t *list;
};

igraph_bool_t handler(igraph_vector_t *clique, void *arg) {
    struct userdata *ud;
    igraph_bool_t cont;

    ud = (struct userdata *) arg;
    cont = 1; /* true */

    if (compare_vectors(&clique, &(VECTOR(*(ud->list))[ud->i])) != 0) {
        printf("igraph_cliques() and igraph_cliques_callback() give different results.\n");
        cont = 0; /* false */
    }

    igraph_vector_destroy(clique);
    igraph_free(clique);

    ud->i += 1;

    return cont;
}

void test_callback(const igraph_t *graph) {
    igraph_vector_ptr_t list;
    struct userdata ud;

    igraph_vector_ptr_init(&list, 0);
    igraph_cliques(graph, &list, 0, 0);

    ud.i = 0;
    ud.list = &list;

    igraph_cliques_callback(graph, 0, 0, &handler, (void *) &ud);

    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&list, igraph_vector_destroy);
    igraph_vector_ptr_destroy_all(&list);
}


int main() {

    igraph_t g;
    igraph_vector_ptr_t result;
    igraph_es_t es;
    igraph_integer_t omega;
    long int i, j, n;
    const int params[] = {4, -1, 2, 2, 0, 0, -1, -1};

    igraph_set_warning_handler(warning_handler_ignore);

    igraph_vector_ptr_init(&result, 0);
    igraph_full(&g, 6, 0, 0);
    igraph_es_pairs_small(&es, 0, 0, 1, 0, 2, 3, 5, -1);
    igraph_delete_edges(&g, es);
    igraph_es_destroy(&es);

    for (j = 0; j < sizeof(params) / (2 * sizeof(params[0])); j++) {
        if (params[2 * j + 1] != 0) {
            igraph_cliques(&g, &result, params[2 * j], params[2 * j + 1]);
        } else {
            igraph_largest_cliques(&g, &result);
        }
        n = igraph_vector_ptr_size(&result);
        printf("%ld cliques found\n", (long)n);
        canonicalize_list(&result);
        for (i = 0; i < n; i++) {
            igraph_vector_t* v = (igraph_vector_t*) igraph_vector_ptr_e(&result, i);
            print_vector(v);
            igraph_vector_destroy(v);
            igraph_free(v);
        }
    }

    igraph_clique_number(&g, &omega);
    printf("omega=%ld\n", (long)omega);

    test_callback(&g);

    igraph_destroy(&g);

    igraph_tree(&g, 5, 2, IGRAPH_TREE_OUT);
    igraph_cliques(&g, &result, 5, 5);
    if (igraph_vector_ptr_size(&result) != 0) {
        return 1;
    }

    igraph_destroy(&g);
    igraph_vector_ptr_destroy(&result);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_cliques.out0000644000175100001710000000051100000000000026506 0ustar00runnerdocker000000000000002 cliques found
 1 2 3 4
 1 2 4 5
12 cliques found
 0 3
 0 4
 0 5
 1 2
 1 3
 1 4
 1 5
 2 3
 2 4
 2 5
 3 4
 4 5
2 cliques found
 1 2 3 4
 1 2 4 5
29 cliques found
 0
 1
 2
 3
 4
 5
 0 3
 0 4
 0 5
 1 2
 1 3
 1 4
 1 5
 2 3
 2 4
 2 5
 3 4
 4 5
 0 3 4
 0 4 5
 1 2 3
 1 2 4
 1 2 5
 1 3 4
 1 4 5
 2 3 4
 2 4 5
 1 2 3 4
 1 2 4 5
omega=4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_cocitation.c0000644000175100001710000000311100000000000026607 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;
    igraph_matrix_t matrix;

    /* Create a small test graph. */
    igraph_small(&graph, 0, IGRAPH_DIRECTED,
                 0, 1, 2, 1, 2, 0, 3, 0,
                 -1);

    /* As usual with igraph functions, the data structure in which the result
       will be returned must be initialized in advance. */
    igraph_matrix_init(&matrix, 0, 0);
    igraph_bibcoupling(&graph, &matrix, igraph_vss_all());
    printf("Bibliographic coupling matrix:\n");
    igraph_matrix_print(&matrix);

    igraph_cocitation(&graph, &matrix, igraph_vss_all());
    printf("\nCocitation matrix:\n");
    igraph_matrix_print(&matrix);

    /* Destroy data structures when we are done with them. */
    igraph_matrix_destroy(&matrix);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_cocitation.out0000644000175100001710000000016300000000000027200 0ustar00runnerdocker00000000000000Bibliographic coupling matrix:
0 0 1 0
0 0 0 0
1 0 0 1
0 0 1 0

Cocitation matrix:
0 1 0 0
1 0 0 0
0 0 0 0
0 0 0 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_coloring.c0000644000175100001710000000276100000000000026301 0ustar00runnerdocker00000000000000
#include 

int main() {
    igraph_t graph;
    igraph_vector_int_t colors;

    /* Setting a seed makes the result of erdos_renyi_game deterministic. */
    igraph_rng_seed(igraph_rng_default(), 42);

    /* IGRAPH_UNDIRECTED and IGRAPH_NO_LOOPS are both equivalent to 0/FALSE, but
       communicate intent better in this context. */
    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 1000, 10000, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    /* As with all igraph functions, the vector in which the result is returned must
       be initialized in advance. */
    igraph_vector_int_init(&colors, 0);
    igraph_vertex_coloring_greedy(&graph, &colors, IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS);

    /* Verify that the colouring is valid, i.e. no two adjacent vertices have the same colour. */
    {
        long int i;
        /* Store the edge count to avoid the overhead from igraph_ecount in the for loop. */
        long int no_of_edges = igraph_ecount(&graph);
        for (i = 0; i < no_of_edges; ++i) {
            if ( VECTOR(colors)[ IGRAPH_FROM(&graph, i) ] == VECTOR(colors)[ IGRAPH_TO(&graph, i) ]  ) {
                printf("Inconsistent coloring! Vertices %ld and %ld are adjacent but have the same color.\n",
                       (long) IGRAPH_FROM(&graph, i), (long) IGRAPH_TO(&graph, i));
                abort();
            }
        }
    }

    /* Destroy data structure when we are done. */
    igraph_vector_int_destroy(&colors);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_edge_betweenness.c0000644000175100001710000001603700000000000032100 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int igraph_vector_between(const igraph_vector_t* v, const igraph_vector_t* lo,
                          const igraph_vector_t* hi) {
    return igraph_vector_all_le(lo, v) && igraph_vector_all_ge(hi, v);
}

void test_unweighted() {
    igraph_t g;
    igraph_vector_t edges, eb;
    long int i;
    long int no_of_edges;

    /* Zachary Karate club */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_vector_init(&edges, 0);
    igraph_vector_init(&eb, 0);
    igraph_community_edge_betweenness(&g, &edges, &eb, 0 /*merges */,
                                      0 /*bridges */, /*modularity=*/ 0,
                                      /*membership=*/ 0,
                                      IGRAPH_UNDIRECTED,
                                      /*weights=*/ 0);

    no_of_edges = igraph_ecount(&g);
    for (i = 0; i < no_of_edges; i++) {
        printf("%li ", (long int)VECTOR(edges)[i]);
    }
    printf("\n");

    for (i = 0; i < no_of_edges; i++) {
        printf("%.2f ", VECTOR(eb)[i]);
    }
    printf("\n");

    /* Try it once again without storage space for edges */
    igraph_community_edge_betweenness(&g, 0, &eb, 0 /*merges */,
                                      0 /*bridges */, /*modularity=*/ 0,
                                      /*membership=*/ 0,
                                      IGRAPH_UNDIRECTED,
                                      /*weights=*/ 0);
    for (i = 0; i < no_of_edges; i++) {
        printf("%.2f ", VECTOR(eb)[i]);
    }
    printf("\n");

    igraph_vector_destroy(&eb);
    igraph_vector_destroy(&edges);
    igraph_destroy(&g);
}

#define EPS 1e-4

void test_weighted() {
    igraph_t g;
    igraph_vector_t edges, eb, weights;
    igraph_real_t weights_array[] = { 4, 1, 3, 2, 5, 8, 6, 7 };

    igraph_real_t edges_array1[] = { 2, 3, 0, 1, 4, 7, 5, 6 };
    igraph_real_t edges_array2[] = { 2, 3, 6, 5, 0, 1, 4, 7 };
    igraph_real_t eb_array1_lo[] = { 4, 5, 3 + 1 / 3.0 - EPS, 4, 2.5, 4, 1, 1 };
    igraph_real_t eb_array1_hi[] = { 4, 5, 3 + 1 / 3.0 + EPS, 4, 2.5, 4, 1, 1 };
    igraph_real_t eb_array2_lo[] = { 4, 5, 3 + 1 / 3.0 - EPS, 6, 1.5, 2, 1, 1 };
    igraph_real_t eb_array2_hi[] = { 4, 5, 3 + 1 / 3.0 + EPS, 6, 1.5, 2, 1, 1 };

    igraph_vector_t edges_sol1, edges_sol2, eb_sol1_lo, eb_sol1_hi, eb_sol2_lo, eb_sol2_hi;

    igraph_vector_view(&edges_sol1, edges_array1,
                       sizeof(edges_array1) / sizeof(double));
    igraph_vector_view(&edges_sol2, edges_array2,
                       sizeof(edges_array2) / sizeof(double));
    igraph_vector_view(&eb_sol1_lo, eb_array1_lo, sizeof(eb_array1_lo) / sizeof(double));
    igraph_vector_view(&eb_sol2_lo, eb_array2_lo, sizeof(eb_array2_lo) / sizeof(double));
    igraph_vector_view(&eb_sol1_hi, eb_array1_hi, sizeof(eb_array1_hi) / sizeof(double));
    igraph_vector_view(&eb_sol2_hi, eb_array2_hi, sizeof(eb_array2_hi) / sizeof(double));

    /* Small graph as follows: A--B--C--A, A--D--E--A, B--D, C--E */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 2, 4, 3, 4, -1);
    igraph_vector_view(&weights, weights_array, igraph_ecount(&g));

    igraph_vector_init(&edges, 0);
    igraph_vector_init(&eb, 0);
    igraph_community_edge_betweenness(&g, &edges, &eb, 0 /*merges */,
                                      0 /*bridges */, /*modularity=*/ 0,
                                      /*membership=*/ 0,
                                      IGRAPH_UNDIRECTED,
                                      &weights);

    if (!igraph_vector_all_e(&edges_sol1, &edges) &&
        !igraph_vector_all_e(&edges_sol2, &edges)) {
        printf("Error, edges vector was: \n");
        igraph_vector_print(&edges);
        exit(2);
    }
    if (!igraph_vector_between(&eb, &eb_sol1_lo, &eb_sol1_hi) &&
        !igraph_vector_between(&eb, &eb_sol2_lo, &eb_sol2_hi)) {
        printf("Error, eb vector was: \n");
        igraph_vector_print(&eb);
        exit(2);
    }

    /* Try it once again without storage space for edges */
    igraph_community_edge_betweenness(&g, 0, &eb, 0 /*merges */,
                                      0 /*bridges */, /*modularity=*/ 0,
                                      /*membership=*/ 0,
                                      IGRAPH_UNDIRECTED,
                                      &weights);

    if (!igraph_vector_between(&eb, &eb_sol1_lo, &eb_sol1_hi) &&
        !igraph_vector_between(&eb, &eb_sol2_lo, &eb_sol2_hi)) {
        printf("Error, eb vector was: \n");
        igraph_vector_print(&eb);
        exit(2);
    }

    igraph_vector_destroy(&eb);
    igraph_vector_destroy(&edges);
    igraph_destroy(&g);
}

void test_zero_edge_graph() {
    igraph_t g;
    igraph_vector_t eb;
    igraph_vector_t res;

    igraph_full(&g, 1, 0, 0);
    igraph_vector_init(&res, igraph_ecount(&g));
    igraph_vector_init(&eb, igraph_ecount(&g));

    igraph_community_edge_betweenness(&g,
        &res, // result
        &eb, // edge_betweenness result
        NULL, // merges result
        NULL, // bridges
        NULL, // modularity
        NULL, // membership
        IGRAPH_UNDIRECTED, // directed
        NULL // weights
        );

    igraph_vector_destroy(&eb);
    printf("No crash\n");
    igraph_vector_destroy(&res);
    igraph_destroy(&g);
}

int main() {
    test_unweighted();
    test_weighted();
    test_zero_edge_graph();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_edge_betweenness.out0000644000175100001710000000207200000000000032457 0ustar00runnerdocker0000000000000015 1 7 45 52 31 23 16 24 25 28 44 68 27 4 5 3 8 76 75 70 57 58 26 9 67 66 10 33 46 47 48 49 63 69 50 51 12 20 53 54 13 21 35 38 55 56 14 22 29 42 43 41 73 74 6 18 32 0 2 11 17 19 30 34 36 37 39 40 59 60 61 62 64 65 71 72 77 
71.39 66.90 77.32 82.00 123.23 100.21 143.63 109.25 107.67 142.75 285.00 16.83 18.18 18.00 15.33 25.33 25.00 50.00 14.50 22.37 25.62 29.65 40.67 72.00 9.00 9.00 11.00 5.50 8.00 5.00 10.00 4.50 9.00 4.50 9.00 4.00 8.00 3.50 7.00 3.50 7.00 3.00 6.00 3.00 6.00 3.00 6.00 2.50 5.00 2.00 2.00 3.50 5.00 2.00 4.00 1.33 2.00 4.00 1.00 1.50 3.00 1.00 2.00 1.00 1.00 1.00 1.00 2.00 1.00 1.00 1.50 3.00 1.00 2.00 1.00 1.00 2.00 1.00 
71.39 66.90 77.32 82.00 123.23 100.21 143.63 109.25 107.67 142.75 285.00 16.83 18.18 18.00 15.33 25.33 25.00 50.00 14.50 22.37 25.62 29.65 40.67 72.00 9.00 9.00 11.00 5.50 8.00 5.00 10.00 4.50 9.00 4.50 9.00 4.00 8.00 3.50 7.00 3.50 7.00 3.00 6.00 3.00 6.00 3.00 6.00 2.50 5.00 2.00 2.00 3.50 5.00 2.00 4.00 1.33 2.00 4.00 1.00 1.50 3.00 1.00 2.00 1.00 1.00 1.00 1.00 2.00 1.00 1.00 1.50 3.00 1.00 2.00 1.00 1.00 2.00 1.00 
No crash
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_fastgreedy.c0000644000175100001710000001673000000000000030727 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void show_results(igraph_t *g, igraph_vector_t *mod, igraph_matrix_t *merges,
                  igraph_vector_t *membership, FILE* f) {
    long int i = 0;
    igraph_vector_t our_membership;

    igraph_vector_init(&our_membership, 0);

    if (mod != 0) {
        i = igraph_vector_which_max(mod);
        fprintf(f, "Modularity:  %f\n", VECTOR(*mod)[i]);
    } else {
        fprintf(f, "Modularity:  ---\n");
    }

    if (membership != 0) {
        igraph_vector_update(&our_membership, membership);
    } else if (merges != 0) {
        igraph_community_to_membership(merges, igraph_vcount(g), i, &our_membership, 0);
    }

    printf("Membership: ");
    for (i = 0; i < igraph_vector_size(&our_membership); i++) {
        printf("%li ", (long int)VECTOR(our_membership)[i]);
    }
    printf("\n");

    igraph_vector_destroy(&our_membership);
}

int main() {
    igraph_t g;
    igraph_vector_t modularity, weights, membership;
    igraph_matrix_t merges;

    igraph_vector_init(&modularity, 0);
    igraph_matrix_init(&merges, 0, 0);
    igraph_vector_init(&weights, 0);
    igraph_vector_init(&membership, 0);

    /* Simple unweighted graph */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);

    /* Same simple graph, with uniform edge weights */
    igraph_vector_resize(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 2);
    igraph_community_fastgreedy(&g, &weights, &merges, &modularity,
                                /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Simple nonuniform weighted graph, with and without weights */
    igraph_small(&g, 6, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5, -1);
    igraph_vector_resize(&weights, 8);
    igraph_vector_fill(&weights, 1);
    VECTOR(weights)[0] = 10;
    VECTOR(weights)[1] = 10;
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_community_fastgreedy(&g, &weights, &merges, &modularity,
                                /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Zachary Karate club */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity,
                                /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Simple disconnected graph with isolates */
    igraph_small(&g, 9, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  1,  2,  1,  3,  2,  3,
                 4,  5,  4,  6,  4,  7,  5,  6,  5,  7,  6,  7,
                 -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Disjoint union of two rings */
    igraph_small(&g, 20, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 0, 9,
                 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 10, 19, -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Completely empty graph */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED, -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Ring graph with loop edges */
    igraph_small(&g, 6, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 2, 2, -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Regression test -- graph with two vertices and two edges */
    igraph_small(&g, 2, IGRAPH_UNDIRECTED, 0, 0, 1, 1, -1);
    igraph_community_fastgreedy(&g, 0, &merges, &modularity, /*membership=*/ 0);
    show_results(&g, &modularity, &merges, 0, stdout);
    igraph_destroy(&g);

    /* Regression test -- asking for optimal membership vector but not
     * providing a modularity vector */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);
    igraph_community_fastgreedy(&g, 0, &merges, 0, &membership);
    show_results(&g, 0, &merges, &membership, stdout);
    igraph_destroy(&g);

    /* Regression test -- asking for optimal membership vector but not
     * providing a merge matrix */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);
    igraph_community_fastgreedy(&g, 0, 0, &modularity, &membership);
    show_results(&g, &modularity, 0, &membership, stdout);

    /* Regression test -- asking for optimal membership vector but not
     * providing a merge matrix or a modularity vector */
    igraph_community_fastgreedy(&g, 0, 0, 0, &membership);
    show_results(&g, 0, 0, &membership, stdout);
    igraph_destroy(&g);

    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&modularity);
    igraph_vector_destroy(&weights);
    igraph_matrix_destroy(&merges);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_fastgreedy.out0000644000175100001710000000133300000000000031305 0ustar00runnerdocker00000000000000Modularity:  0.452381
Membership: 1 1 1 1 1 0 0 0 0 0 
Modularity:  0.452381
Membership: 1 1 1 1 1 0 0 0 0 0 
Modularity:  0.179688
Membership: 1 1 0 0 0 0 
Modularity:  0.170858
Membership: 1 1 1 0 0 0 
Modularity:  0.380671
Membership: 0 2 2 2 0 0 0 2 1 2 0 0 2 2 1 1 0 2 1 0 1 2 1 1 1 1 1 1 1 1 1 1 1 1 
Modularity:  0.500000
Membership: 1 1 1 1 0 0 0 0 2 
Modularity:  0.540000
Membership: 1 1 1 1 3 3 3 3 1 1 0 0 0 0 0 0 2 2 2 2 
Modularity:  0.000000
Membership: 0 1 2 3 4 5 6 7 8 9 
Modularity:  0.281250
Membership: 0 1 1 2 2 0 
Modularity:  0.500000
Membership: 0 1 
Modularity:  ---
Membership: 1 1 1 1 1 0 0 0 0 0 
Modularity:  0.452381
Membership: 1 1 1 1 1 0 0 0 0 0 
Modularity:  ---
Membership: 1 1 1 1 1 0 0 0 0 0 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_fluid_communities.c0000644000175100001710000000663200000000000032311 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "../../tests/unit/test_utilities.inc"

int main() {
    igraph_t g;
    igraph_integer_t k;
    igraph_vector_t membership;
    igraph_real_t modularity;

    igraph_rng_seed(igraph_rng_default(), 247);

    /* Empty graph */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED, -1);
    igraph_vector_init(&membership, 0);
    igraph_vector_push_back(&membership, 1);
    igraph_community_fluid_communities(&g, 2, &membership, &modularity);
    if (!igraph_is_nan(modularity) || igraph_vector_size(&membership) != 0) {
        return 2;
    }
    igraph_vector_destroy(&membership);
    igraph_destroy(&g);

    /* Graph with one vertex only */
    igraph_small(&g, 1, IGRAPH_UNDIRECTED, -1);
    igraph_vector_init(&membership, 0);
    igraph_community_fluid_communities(&g, 2, &membership, &modularity);
    if (!igraph_is_nan(modularity) || igraph_vector_size(&membership) != 1 || VECTOR(membership)[0] != 0) {
        return 3;
    }
    igraph_vector_destroy(&membership);
    igraph_destroy(&g);

    /* Zachary Karate club -- this is just a quick smoke test */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_vector_init(&membership, 0);
    k = 2;
    igraph_community_fluid_communities(&g, k, &membership,
                                       /*modularity=*/ 0);
    if (!igraph_vector_contains(&membership, 0) || !igraph_vector_contains(&membership, 1)) {
        printf("Resulting graph does not have exactly 2 communities as expected.\n");
        igraph_vector_print(&membership);
        return 1;
    }

    igraph_destroy(&g);
    igraph_vector_destroy(&membership);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_fluid_communities.out0000644000175100001710000000000000000000000032655 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_label_propagation.c0000644000175100001710000000341100000000000032244 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;
    igraph_vector_t membership;
    igraph_real_t modularity;

    igraph_famous(&graph, "Zachary"); /* We use Zachary's karate club network. */

    /* Label propagation is a stochastic method; the result will depend on the random seed. */
    igraph_rng_seed(igraph_rng_default(), 123);

    /* All igraph functions that returns their result in an igraph_vector_t must be given
       an already initialized vector. */
    igraph_vector_init(&membership, 0);
    igraph_community_label_propagation(
                &graph, &membership,
                /* weights= */ NULL, /* initial= */ NULL, /* fixed= */ NULL,
                &modularity);

    printf("%ld communities found; modularity score is %g.\n",
           (long int) (igraph_vector_max(&membership) + 1),
           modularity);

    /* Destroy data structures at the end. */
    igraph_vector_destroy(&membership);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_label_propagation.out0000644000175100001710000000006200000000000032630 0ustar00runnerdocker000000000000003 communities found; modularity score is 0.39908.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_leading_eigenvector.c0000644000175100001710000001002000000000000032551 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_vector(const igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    for (i = 0; i < n; i++) {
        printf("%.2g", (double)VECTOR(*v)[i]);
        if (i != n - 1) {
            printf(" ");
        }
    }
    printf("\n");
    return 0;
}

int print_matrix(const igraph_matrix_t *m) {
    long int i, j, nrow = igraph_matrix_nrow(m), ncol = igraph_matrix_ncol(m);
    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            printf("%.2g", (double)MATRIX(*m, i, j));
            if (j != ncol - 1) {
                printf(" ");
            }
        }
        printf("\n");
    }
    return 0;
}

int main() {

    igraph_t g;
    igraph_matrix_t merges;
    igraph_vector_t membership;
    igraph_vector_t x;
    igraph_arpack_options_t options;

    /* Zachary Karate club */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_matrix_init(&merges, 0, 0);
    igraph_vector_init(&membership, 0);
    igraph_vector_init(&x, 0);
    igraph_arpack_options_init(&options);

    igraph_community_leading_eigenvector(&g, /*weights=*/ 0, &merges,
                                         &membership, 1,
                                         &options, /*modularity=*/ 0,
                                         /*start=*/ 0, /*eigenvalues=*/ 0,
                                         /*eigenvectors=*/ 0, /*history=*/ 0,
                                         /*callback=*/ 0,
                                         /*callback_extra=*/ 0);

    print_matrix(&merges);
    print_vector(&membership);

    printf("\n");

    /* Make all the steps */
    igraph_community_leading_eigenvector(&g, /*weights=*/ 0, &merges,
                                         &membership, igraph_vcount(&g),
                                         &options, /*modularity=*/ 0,
                                         /*start=*/ 0, /*eigenvalues=*/ 0,
                                         /*eigenvectors=*/ 0, /*history=*/ 0,
                                         /*callback=*/ 0,
                                         /*callback_extra=*/ 0);

    print_matrix(&merges);
    print_vector(&membership);

    igraph_vector_destroy(&x);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_leading_eigenvector.out0000644000175100001710000000023100000000000033141 0ustar00runnerdocker000000000000000 1
0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1

1 3
0 2
5 4
0 2 2 2 0 0 0 2 1 1 0 0 2 2 1 1 0 2 1 2 1 2 1 3 3 3 1 3 3 1 1 3 1 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_leiden.c0000644000175100001710000000547500000000000030036 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_t graph;
    igraph_vector_t membership, degree;
    igraph_integer_t nb_clusters;
    igraph_real_t quality;

    /* Set default seed to get reproducible results */
    igraph_rng_seed(igraph_rng_default(), 0);

    /* Simple unweighted graph */
    igraph_small(&graph, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);

    /* Perform Leiden algorithm using CPM */
    igraph_vector_init(&membership, igraph_vcount(&graph));
    igraph_community_leiden(&graph, NULL, NULL, 0.05, 0.01, 0, &membership, &nb_clusters, &quality);

    printf("Leiden found %" IGRAPH_PRId " clusters using CPM (resolution parameter 0.05), quality is %.4f.\n", nb_clusters, quality);
    printf("Membership: ");
    igraph_vector_print(&membership);
    printf("\n");

    /* Start from existing membership to improve it further */
    igraph_community_leiden(&graph, NULL, NULL, 0.05, 0.01, 1, &membership, &nb_clusters, &quality);

    printf("Iterated Leiden, using CPM (resolution parameter 0.05), quality is %.4f.\n", quality);
    printf("Membership: ");
    igraph_vector_print(&membership);
    printf("\n");

    /* Initialize degree vector to use for optimizing modularity */
    igraph_vector_init(°ree, igraph_vcount(&graph));
    igraph_degree(&graph, °ree, igraph_vss_all(), IGRAPH_ALL, 1);

    /* Perform Leiden algorithm using modularity */
    igraph_community_leiden(&graph, NULL, °ree, 1.0 / (2 * igraph_ecount(&graph)), 0.01, 0, &membership, &nb_clusters, &quality);

    printf("Leiden found %" IGRAPH_PRId " clusters using modularity, quality is %.4f.\n", nb_clusters, quality);
    printf("Membership: ");
    igraph_vector_print(&membership);
    printf("\n");

    igraph_vector_destroy(°ree);
    igraph_vector_destroy(&membership);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_leiden.out0000644000175100001710000000047500000000000030416 0ustar00runnerdocker00000000000000Leiden found 2 clusters using CPM (resolution parameter 0.05), quality is 0.8929.
Membership: 0 0 0 0 0 1 1 1 1 1

Iterated Leiden, using CPM (resolution parameter 0.05), quality is 0.8929.
Membership: 0 0 0 0 0 1 1 1 1 1

Leiden found 2 clusters using modularity, quality is 0.4524.
Membership: 0 0 0 0 0 1 1 1 1 1

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_multilevel.c0000644000175100001710000000730700000000000030754 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sts=4 sw=4 et: */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void show_results(igraph_t *g, igraph_vector_t *membership, igraph_matrix_t *memberships, igraph_vector_t *modularity, FILE* f) {
    long int i, j, no_of_nodes = igraph_vcount(g);

    j = igraph_vector_which_max(modularity);
    for (i = 0; i < igraph_vector_size(membership); i++) {
        if (VECTOR(*membership)[i] != MATRIX(*memberships, j, i)) {
            fprintf(f, "WARNING: best membership vector element %li does not match the best one in the membership matrix\n", i);
        }
    }

    fprintf(f, "Modularities:\n");
    igraph_vector_print(modularity);

    for (i = 0; i < igraph_matrix_nrow(memberships); i++) {
        for (j = 0; j < no_of_nodes; j++) {
            fprintf(f, "%ld ", (long int)MATRIX(*memberships, i, j));
        }
        fprintf(f, "\n");
    }

    fprintf(f, "\n");
}

int main() {
    igraph_t g;
    igraph_vector_t modularity, membership, edges;
    igraph_matrix_t memberships;
    int i, j, k;

    igraph_vector_init(&modularity, 0);
    igraph_vector_init(&membership, 0);
    igraph_matrix_init(&memberships, 0, 0);

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Unweighted test graph from the paper of Blondel et al */
    igraph_small(&g, 16, IGRAPH_UNDIRECTED,
                 0, 2, 0, 3, 0, 4, 0, 5,
                 1, 2, 1, 4, 1, 7,
                 2, 4, 2, 5, 2, 6,
                 3, 7,
                 4, 10,
                 5, 7, 5, 11,
                 6, 7, 6, 11,
                 8, 9, 8, 10, 8, 11, 8, 14, 8, 15,
                 9, 12, 9, 14,
                 10, 11, 10, 12, 10, 13, 10, 14,
                 11, 13,
                 -1);
    igraph_community_multilevel(&g, 0, 1, &membership, &memberships, &modularity);
    show_results(&g, &membership, &memberships, &modularity, stdout);

    /* Higher resolution */
    igraph_community_multilevel(&g, 0, 1.5, &membership, &memberships, &modularity);
    show_results(&g, &membership, &memberships, &modularity, stdout);

    igraph_destroy(&g);

    /* Ring of 30 cliques */
    igraph_vector_init(&edges, 0);
    for (i = 0; i < 30; i++) {
        for (j = 0; j < 5; j++) {
            for (k = j + 1; k < 5; k++) {
                igraph_vector_push_back(&edges, i * 5 + j);
                igraph_vector_push_back(&edges, i * 5 + k);
            }
        }
    }
    for (i = 0; i < 30; i++) {
        igraph_vector_push_back(&edges, i * 5 % 150);
        igraph_vector_push_back(&edges, (i * 5 + 6) % 150);
    }
    igraph_create(&g, &edges, 150, 0);
    igraph_community_multilevel(&g, 0, 1, &membership, &memberships, &modularity);
    show_results(&g, &membership, &memberships, &modularity, stdout);
    igraph_destroy(&g);

    igraph_vector_destroy(&modularity);
    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&edges);
    igraph_matrix_destroy(&memberships);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_multilevel.out0000644000175100001710000000167400000000000031342 0ustar00runnerdocker00000000000000Modularities:
0.346301 0.392219
0 0 0 1 0 0 1 1 2 2 2 3 2 3 2 2 
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 

Modularities:
0.202487
0 0 0 1 0 0 1 1 2 2 3 3 2 3 2 2 

Modularities:
0.875758 0.886263
0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 6 6 6 6 6 7 7 7 7 7 8 8 8 8 8 9 9 9 9 9 10 10 10 10 10 11 11 11 11 11 12 12 12 12 12 13 13 13 13 13 14 14 14 14 14 15 15 15 15 15 16 16 16 16 16 17 17 17 17 17 18 18 18 18 18 19 19 19 19 19 20 20 20 20 20 21 21 21 21 21 22 22 22 22 22 23 23 23 23 23 24 24 24 24 24 25 25 25 25 25 26 26 26 26 26 27 27 27 27 27 28 28 28 28 28 29 29 29 29 29 
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 14 14 14 14 14 15 15 15 15 15 15 15 15 15 15 16 16 16 16 16 16 16 16 16 16 

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_community_optimal_modularity.c0000644000175100001710000000757700000000000032521 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void prepare_weights_vector(igraph_vector_t* weights, const igraph_t* graph) {
    int i, n = igraph_ecount(graph);
    igraph_vector_resize(weights, n);
    for (i = 0; i < n; i++) {
        VECTOR(*weights)[i] = i % 5;
    }
}

int main() {
    igraph_t graph;

    igraph_vector_t v;
    igraph_real_t edges[] = { 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
                              0, 10, 0, 11, 0, 12, 0, 13, 0, 17, 0, 19, 0, 21, 0, 31,
                              1, 2, 1, 3, 1, 7, 1, 13, 1, 17, 1, 19, 1, 21, 1, 30,
                              2, 3, 2, 7, 2, 27, 2, 28, 2, 32, 2, 9, 2, 8, 2, 13,
                              3, 7, 3, 12, 3, 13, 4, 6, 4, 10, 5, 6, 5, 10, 5, 16,
                              6, 16, 8, 30, 8, 32, 8, 33, 9, 33, 13, 33, 14, 32, 14, 33,
                              15, 32, 15, 33, 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                              22, 32, 22, 33, 23, 25, 23, 27, 23, 32, 23, 33, 23, 29,
                              24, 25, 24, 27, 24, 31, 25, 31, 26, 29, 26, 33, 27, 33,
                              28, 31, 28, 33, 29, 32, 29, 33, 30, 32, 30, 33, 31, 32, 31, 33,
                              32, 33
                            };

    igraph_vector_t membership;
    igraph_vector_t weights;
    igraph_real_t modularity;
    igraph_bool_t simple;
    int retval;

    igraph_vector_view(&v, edges, sizeof(edges) / sizeof(double));
    igraph_create(&graph, &v, 0, IGRAPH_UNDIRECTED);

    igraph_vector_init(&weights, 0);

    igraph_is_simple(&graph, &simple);
    if (!simple) {
        return 1;
    }

    igraph_vector_init(&membership, 0);

    igraph_set_error_handler(&igraph_error_handler_printignore);

    /* Zachary karate club, unweighted */
    retval = igraph_community_optimal_modularity(&graph, &modularity,
             &membership, 0);
    if (retval == IGRAPH_UNIMPLEMENTED) {
        return 77;
    }
    if (fabs(modularity - 0.4197896) > 0.0000001) {
        return 2;
    }
    /* Zachary karate club, weighted */
    prepare_weights_vector(&weights, &graph);
    igraph_community_optimal_modularity(&graph, &modularity,
                                        &membership, &weights);
    if (fabs(modularity - 0.5115767) > 0.0000001) {
        return 4;
    }
    igraph_destroy(&graph);

    /* simple graph with loop edges, unweighted */
    igraph_small(&graph, 6, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 2, 2, -1);
    igraph_community_optimal_modularity(&graph, &modularity,
                                        &membership, 0);
    if (fabs(modularity - 0.28125) > 0.00001) {
        return 3;
    }
    /* simple graph with loop edges, weighted */
    prepare_weights_vector(&weights, &graph);
    igraph_community_optimal_modularity(&graph, &modularity,
                                        &membership, &weights);
    if (fabs(modularity - 0.36686) > 0.00001) {
        return 5;
    }
    igraph_destroy(&graph);

    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&weights);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_complementer.c0000644000175100001710000000607400000000000027160 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g1, g2;

    /* complementer of the empty graph */
    igraph_empty(&g1, 5, IGRAPH_DIRECTED);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* the same without loops */
    igraph_empty(&g1, 5, IGRAPH_DIRECTED);
    igraph_complementer(&g2, &g1, IGRAPH_NO_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* complementer of the full graph */
    igraph_full(&g1, 5, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    if (igraph_ecount(&g2) != 0) {
        return 1;
    }
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* complementer of the full graph, results loops only */
    igraph_full(&g1, 5, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /**************
     * undirected *
     *************/

    /* complementer of the empty graph */
    igraph_empty(&g1, 5, IGRAPH_UNDIRECTED);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* the same without loops */
    igraph_empty(&g1, 5, IGRAPH_UNDIRECTED);
    igraph_complementer(&g2, &g1, IGRAPH_NO_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* complementer of the full graph */
    igraph_full(&g1, 5, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    if (igraph_ecount(&g2) != 0) {
        return 1;
    }
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("---\n");

    /* complementer of the full graph, results loops only */
    igraph_full(&g1, 5, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_complementer(&g2, &g1, IGRAPH_LOOPS);
    igraph_write_graph_edgelist(&g2, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_complementer.out0000644000175100001710000000053400000000000027540 0ustar00runnerdocker000000000000000 0
0 1
0 2
0 3
0 4
1 0
1 1
1 2
1 3
1 4
2 0
2 1
2 2
2 3
2 4
3 0
3 1
3 2
3 3
3 4
4 0
4 1
4 2
4 3
4 4
---
0 1
0 2
0 3
0 4
1 0
1 2
1 3
1 4
2 0
2 1
2 3
2 4
3 0
3 1
3 2
3 4
4 0
4 1
4 2
4 3
---
---
0 0
1 1
2 2
3 3
4 4
---
0 0
0 1
0 2
0 3
0 4
1 1
1 2
1 3
1 4
2 2
2 3
2 4
3 3
3 4
4 4
---
0 1
0 2
0 3
0 4
1 2
1 3
1 4
2 3
2 4
3 4
---
---
0 0
1 1
2 2
3 3
4 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_compose.c0000644000175100001710000000700500000000000026126 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g1, g2, res;
    igraph_vector_t v;
    igraph_vector_t map1, map2;

    igraph_vector_init(&map1, 0);
    igraph_vector_init(&map2, 0);

    /* composition with the empty graph */
    igraph_empty(&g1, 5, IGRAPH_DIRECTED);
    igraph_full(&g2, 5, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    igraph_compose(&res, &g1, &g2, &map1, &map2);
    if (igraph_ecount(&res) != 0) {
        return 1;
    }
    if (igraph_vector_size(&map1) != 0 || igraph_vector_size(&map2) != 0) {
        return 11;
    }
    igraph_destroy(&res);
    igraph_compose(&res, &g2, &g1, &map1, &map2);
    if (igraph_ecount(&res) != 0) {
        return 2;
    }
    if (igraph_vector_size(&map1) != 0 || igraph_vector_size(&map2) != 0) {
        return 12;
    }
    igraph_destroy(&res);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    /* same but undirected */
    igraph_empty(&g1, 5, IGRAPH_UNDIRECTED);
    igraph_full(&g2, 5, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_compose(&res, &g1, &g2, &map1, &map2);
    if (igraph_ecount(&res) != 0) {
        return 1;
    }
    if (igraph_vector_size(&map1) != 0 || igraph_vector_size(&map2) != 0) {
        return 11;
    }
    igraph_destroy(&res);
    igraph_compose(&res, &g2, &g1, &map1, &map2);
    if (igraph_ecount(&res) != 0) {
        return 2;
    }
    if (igraph_vector_size(&map1) != 0 || igraph_vector_size(&map2) != 0) {
        return 12;
    }
    igraph_destroy(&res);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    /* proper directed graph */
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 5, 6, -1);
    igraph_create(&g1, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 2, 4, 5, 6, -1);
    igraph_create(&g2, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_compose(&res, &g1, &g2, &map1, &map2);
    igraph_write_graph_edgelist(&res, stdout);
    igraph_vector_print(&map1);
    igraph_vector_print(&map2);
    igraph_destroy(&res);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    /* undirected graph */
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 5, 6, -1);
    igraph_create(&g1, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 0, 4, 5, 6, -1);
    igraph_create(&g2, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_compose(&res, &g1, &g2, &map1, &map2);
    igraph_write_graph_edgelist(&res, stdout);
    igraph_vector_print(&map1);
    igraph_vector_print(&map2);
    igraph_destroy(&res);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    igraph_vector_destroy(&map2);
    igraph_vector_destroy(&map1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_compose.out0000644000175100001710000000007000000000000026506 0ustar00runnerdocker000000000000001 4
1
1
0 0
0 2
1 1
1 4
5 5
6 6
0 0 0 1 2 2
0 1 0 0 2 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_convex_hull.c0000644000175100001710000001255000000000000027010 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int check_convex_hull(igraph_matrix_t* coords) {
    igraph_vector_t result;
    igraph_matrix_t resmat;
    long int i;

    /* Testing with index output mode */
    igraph_vector_init(&result, 1);
    if (igraph_convex_hull(coords, &result, 0)) {
        return 1;
    }

    for (i = 0; i < igraph_vector_size(&result); i++) {
        printf("%ld ", (long)VECTOR(result)[i]);
    }
    printf("\n");
    igraph_vector_destroy(&result);

    /* Testing with coordinate output mode */
    igraph_matrix_init(&resmat, 0, 0);
    if (igraph_convex_hull(coords, 0, &resmat)) {
        return 1;
    }

    for (i = 0; i < igraph_matrix_nrow(&resmat); i++) {
        printf("%.3f %.3f ", MATRIX(resmat, i, 0), MATRIX(resmat, i, 1));
    }
    printf("\n");

    igraph_matrix_destroy(&resmat);

    return 0;
}

int test_simple() {
    igraph_real_t coords_array[][2] = {
        {3, 2}, {5, 1}, {4, 4}, {6, 4}, {4, 3},
        {2, 5}, {1, 3}, {2, 4}, {6, 3}, {9, 2}
    };
    igraph_matrix_t coords;
    int i, result;

    printf("test_simple\n");

    igraph_matrix_init(&coords, 10, 2);
    for (i = 0; i < 20; i++) {
        MATRIX(coords, i / 2, i % 2) = coords_array[i / 2][i % 2];
    }
    result = check_convex_hull(&coords);
    igraph_matrix_destroy(&coords);
    return result;
}

int test_collinear() {
    igraph_real_t coords_array[][2] =
    {{3, 2}, {5, 1}, {7, 0}, {9, -1}, {11, -2}};
    igraph_matrix_t coords;
    int i, result;

    printf("test_collinear\n");

    igraph_matrix_init(&coords, 5, 2);
    for (i = 0; i < 10; i++) {
        MATRIX(coords, i / 2, i % 2) = coords_array[i / 2][i % 2];
    }
    result = check_convex_hull(&coords);
    igraph_matrix_destroy(&coords);
    return result;
}

int test_degenerate() {
    igraph_matrix_t coords;
    int result;

    printf("test_degenerate\n");

    igraph_matrix_init(&coords, 2, 2);
    MATRIX(coords, 0, 0) = 3;
    MATRIX(coords, 0, 1) = 2;
    MATRIX(coords, 1, 0) = 5;
    MATRIX(coords, 1, 1) = 1;
    result = check_convex_hull(&coords);

    igraph_matrix_resize(&coords, 1, 2);
    MATRIX(coords, 0, 0) = 3;
    MATRIX(coords, 0, 1) = 2;
    result = check_convex_hull(&coords);

    igraph_matrix_resize(&coords, 0, 2);
    result = check_convex_hull(&coords);

    igraph_matrix_destroy(&coords);
    return result;
}

int test_bug_805() {
    igraph_real_t coords_array[][2] = {
        {0, 0}, {1, 0}, {0.707, 0.707}, {0, 1}, {-0.707, 0.707}, {-1, 0},
        {-0.707, -0.707}, {0, -1}, {0.707, -0.707}, {2, 0}, {1.414, 1.414}, {0, 2},
        {-1.414, 1.414}, {-2, 0}, {-1.414, -1.414}, {0, -2}, {1.414, -1.414}, {3, 0},
        {2.121, 2.121}, {0, 3}, {-2.121, 2.121}, {-3, 0}, {-2.121, -2.121}, {0, -3},
        {2.121, -2.121}, {4, 0}, {2.828, 2.828}, {0, 4}, {-2.828, 2.828}, {-4, 0},
        {-2.828, -2.828}, {0, -4}, {2.828, -2.828}
    };
    igraph_matrix_t coords;
    int i, result;

    printf("test_bug_805\n");

    igraph_matrix_init(&coords, 33, 2);
    for (i = 0; i < 66; i++) {
        MATRIX(coords, i / 2, i % 2) = coords_array[i / 2][i % 2];
    }
    result = check_convex_hull(&coords);
    igraph_matrix_destroy(&coords);
    return result;
}

int test_bug_1115() {
    igraph_real_t coords_array[][2] = {
        {37, 52}, {49, 49}, {52, 64}, {20, 26}, {40, 30}, {21, 47}, {17, 63}, {31, 62},
        {52, 33}, {51, 21}, {42, 41}, {31, 32}, {5, 25}, {12, 42}, {36, 16}, {52, 41},
        {27, 23}, {17, 33}, {13, 13}, {57, 58}, {62, 42}, {42, 57}, {16, 57}, {8, 52},
        {7, 38}, {27, 68}, {30, 48}, {43, 67}, {58, 48}, {58, 27}, {37, 69}, {38, 46},
        {46, 10}, {61, 33}, {62, 63}, {63, 69}, {32, 22}, {45, 35}, {59, 15}, {5, 6},
        {10, 17}, {21, 10}, {5, 64}, {30, 15}, {39, 10}, {32, 39}, {25, 32}, {25, 55},
        {48, 28}, {56, 37}, {30, 40}
    };
    igraph_matrix_t coords;
    int i, result;

    printf("test_bug_1115\n");

    igraph_matrix_init(&coords, 51, 2);
    for (i = 0; i < 102; i++) {
        MATRIX(coords, i / 2, i % 2) = coords_array[i / 2][i % 2];
    }
    result = check_convex_hull(&coords);
    igraph_matrix_destroy(&coords);
    return result;
}

int main() {
    int result;

    result = test_simple();
    if (result != 0) {
        return result;
    }

    result = test_collinear();
    if (result != 0) {
        return result;
    }

    result = test_degenerate();
    if (result != 0) {
        return result;
    }

    result = test_bug_805();
    if (result != 0) {
        return result;
    }

    result = test_bug_1115();
    if (result != 0) {
        return result;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_convex_hull.out0000644000175100001710000000074500000000000027400 0ustar00runnerdocker00000000000000test_simple
1 6 5 3 9 
5.000 1.000 1.000 3.000 2.000 5.000 6.000 4.000 9.000 2.000 
test_collinear
4 0 
11.000 -2.000 3.000 2.000 
test_degenerate
1 0 
5.000 1.000 3.000 2.000 
0 
3.000 2.000 


test_bug_805
31 30 29 28 27 26 25 32 
0.000 -4.000 -2.828 -2.828 -4.000 0.000 -2.828 2.828 0.000 4.000 2.828 2.828 4.000 0.000 2.828 -2.828 
test_bug_1115
39 42 25 30 35 20 38 32 
5.000 6.000 5.000 64.000 27.000 68.000 37.000 69.000 63.000 69.000 62.000 42.000 59.000 15.000 46.000 10.000 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_copy.c0000644000175100001710000000275100000000000025436 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g1, g2;
    igraph_vector_t v1, v2;

    igraph_vector_init(&v1, 8);
    VECTOR(v1)[0] = 0;
    VECTOR(v1)[1] = 1;
    VECTOR(v1)[2] = 1;
    VECTOR(v1)[3] = 2;
    VECTOR(v1)[4] = 2;
    VECTOR(v1)[5] = 3;
    VECTOR(v1)[6] = 2;
    VECTOR(v1)[7] = 2;

    igraph_create(&g1, &v1, 0, 0);
    igraph_copy(&g2, &g1);

    igraph_vector_init(&v2, 0);
    igraph_get_edgelist(&g2, &v2, 0);
    if (!igraph_vector_all_e(&v1, &v2)) {
        return 1;
    }

    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_create.c0000644000175100001710000000446700000000000025735 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t v1, v2;
    int ret;

    /* simple use */
    igraph_vector_init(&v1, 8);
    VECTOR(v1)[0] = 0;
    VECTOR(v1)[1] = 1;
    VECTOR(v1)[2] = 1;
    VECTOR(v1)[3] = 2;
    VECTOR(v1)[4] = 2;
    VECTOR(v1)[5] = 3;
    VECTOR(v1)[6] = 2;
    VECTOR(v1)[7] = 2;
    igraph_create(&g, &v1, 0, 0);
    if (igraph_vcount(&g) != 4) {
        return 1;
    }
    igraph_vector_init(&v2, 0);
    igraph_get_edgelist(&g, &v2, 0);
    igraph_vector_sort(&v1);
    igraph_vector_sort(&v2);
    if (!igraph_vector_all_e(&v1, &v2)) {
        return 2;
    }
    igraph_destroy(&g);

    /* higher number of vertices */
    igraph_create(&g, &v1, 10, 0);
    if (igraph_vcount(&g) != 10) {
        return 1;
    }
    igraph_get_edgelist(&g, &v2, 0);
    igraph_vector_sort(&v1);
    igraph_vector_sort(&v2);
    if (!igraph_vector_all_e(&v1, &v2)) {
        return 3;
    }
    igraph_destroy(&g);

    /* error: IGRAPH_EINVEVECTOR */
    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_resize(&v1, 9);
    VECTOR(v1)[8] = 0;
    ret = igraph_create(&g, &v1, 0, 0);
    if (ret != IGRAPH_EINVEVECTOR) {
        return 4;
    }

    /* error: IGRAPH_EINVVID */
    igraph_vector_resize(&v1, 8);
    VECTOR(v1)[7] = -1;
    ret = igraph_create(&g, &v1, 10, 1);
    if (ret != IGRAPH_EINVVID) {
        return 5;
    }
    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_decompose.c0000644000175100001710000000332500000000000026440 0ustar00runnerdocker00000000000000
#include 
#include 

void free_complist(igraph_vector_ptr_t *complist) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(complist); i++) {
        igraph_destroy(VECTOR(*complist)[i]);
        igraph_free(VECTOR(*complist)[i]);
    }
}

int main() {

    igraph_t ring, g;
    igraph_vector_ptr_t complist;
    long int i;
    igraph_real_t edges[] = { 0, 1, 1, 2, 2, 0,
                              3, 4, 4, 5, 5, 6,
                              8, 9, 9, 10
                            };
    igraph_vector_t v;

    /* A ring, a single component */
    igraph_ring(&ring, 10, IGRAPH_UNDIRECTED, 0, 1);

    igraph_vector_ptr_init(&complist, 0);
    igraph_decompose(&ring, &complist, IGRAPH_WEAK, -1, 0);
    igraph_write_graph_edgelist(VECTOR(complist)[0], stdout);
    free_complist(&complist);
    igraph_destroy(&ring);

    /* Random graph with a giant component */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100, 4.0 / 100,
                            IGRAPH_UNDIRECTED, 0);
    igraph_decompose(&g, &complist, IGRAPH_WEAK, -1, 20);
    if (igraph_vector_ptr_size(&complist) != 1) {
        return 1;
    }
    free_complist(&complist);
    igraph_destroy(&g);

    /* A toy graph, three components maximum, with at least 2 vertices each */
    igraph_create(&g,
                  igraph_vector_view(&v, edges, sizeof(edges) / sizeof(igraph_real_t)),
                  0, IGRAPH_DIRECTED);
    igraph_decompose(&g, &complist, IGRAPH_WEAK, 3, 2);
    for (i = 0; i < igraph_vector_ptr_size(&complist); i++) {
        igraph_write_graph_edgelist(VECTOR(complist)[i], stdout);
    }
    free_complist(&complist);
    igraph_destroy(&g);

    igraph_vector_ptr_destroy(&complist);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_decompose.out0000644000175100001710000000011000000000000027012 0ustar00runnerdocker000000000000000 1
0 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
0 1
1 2
2 0
0 1
1 2
2 3
0 1
1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_degree.c0000644000175100001710000001457300000000000025724 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        fprintf(f, " %li", (long int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t g;
    igraph_vector_t v, seq;
    int ret;
    igraph_integer_t mdeg, nedges;
    long int i;
    long int ndeg;

    /* Create graph */
    igraph_vector_init(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, IGRAPH_DIRECTED);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_IN, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    igraph_set_error_handler(igraph_error_handler_ignore);

    /* Consistency check of the handshaking lemma. */
    /* If d is the sum of all vertex degrees, then d = 2|E|. */
    ndeg = 0;
    nedges = igraph_ecount(&g);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        ndeg += (long int) VECTOR(v)[i];
    }
    if (ndeg != 2 * nedges) {
        return 1;
    }

    igraph_destroy(&g);

    igraph_vector_resize(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, IGRAPH_UNDIRECTED);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_IN, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_NO_LOOPS);
    print_vector(&v, stdout);

    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    /* Consistency check of the handshaking lemma. */
    /* If d is the sum of all vertex degrees, then d = 2|E|. */
    ndeg = 0;
    nedges = igraph_ecount(&g);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        ndeg += (long int) VECTOR(v)[i];
    }
    if (ndeg != 2 * nedges) {
        return 2;
    }

    /* Degree of the same vertex multiple times */

    igraph_vector_init(&seq, 3);
    VECTOR(seq)[0] = 2;
    VECTOR(seq)[1] = 0;
    VECTOR(seq)[2] = 2;
    igraph_degree(&g, &v, igraph_vss_vector(&seq), IGRAPH_ALL, IGRAPH_LOOPS);
    print_vector(&v, stdout);

    /* Errors */
    ret = igraph_degree(&g, &v, igraph_vss_vector(&seq), (igraph_neimode_t)0,
                        IGRAPH_LOOPS);
    if (ret != IGRAPH_EINVMODE) {
        return 3;
    }

    VECTOR(seq)[0] = 4;
    ret = igraph_degree(&g, &v, igraph_vss_vector(&seq), IGRAPH_ALL, IGRAPH_LOOPS);
    if (ret != IGRAPH_EINVVID) {
        return 4;
    }

    igraph_destroy(&g);
    igraph_vector_destroy(&seq);

    /* Maximum degree */

    igraph_ring(&g, 10, 0 /*undirected*/, 0 /*undirected*/, 0/*uncircular*/);
    igraph_maxdegree(&g, &mdeg, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    if (mdeg != 2) {
        return 5;
    }
    /* Consistency check of the handshaking lemma. */
    /* If d is the sum of all vertex degrees, then d = 2|E|. */
    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    ndeg = 0;
    nedges = igraph_ecount(&g);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        ndeg += (long int) VECTOR(v)[i];
    }
    if (ndeg != 2 * nedges) {
        return 6;
    }
    igraph_destroy(&g);

    igraph_full(&g, 10, 0 /*undirected*/, 0/*no loops*/);
    igraph_maxdegree(&g, &mdeg, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    if (mdeg != 9) {
        return 7;
    }
    /* Consistency check of the handshaking lemma. */
    /* If d is the sum of all vertex degrees, then d = 2|E|. */
    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    ndeg = 0;
    nedges = igraph_ecount(&g);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        ndeg += (long int) VECTOR(v)[i];
    }
    if (ndeg != 2 * nedges) {
        return 8;
    }
    igraph_destroy(&g);

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_maxdegree(&g, &mdeg, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    if (mdeg != 9) {
        return 9;
    }
    igraph_maxdegree(&g, &mdeg, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    if (mdeg != 1) {
        return 10;
    }
    igraph_maxdegree(&g, &mdeg, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    if (mdeg != 9) {
        return 11;
    }
    /* Consistency check of the handshaking lemma. */
    /* If d is the sum of all vertex degrees, then d = 2|E|. */
    igraph_degree(&g, &v, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    ndeg = 0;
    nedges = igraph_ecount(&g);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        ndeg += (long int) VECTOR(v)[i];
    }
    if (ndeg != 2 * nedges) {
        return 12;
    }
    igraph_destroy(&g);

    igraph_vector_destroy(&v);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_degree.out0000644000175100001710000000016300000000000026277 0ustar00runnerdocker00000000000000 1 1 1 0
 1 1 2 0
 0 1 1 1
 0 1 2 1
 1 2 2 1
 1 2 4 1
 1 2 2 1
 1 2 4 1
 1 2 2 1
 1 2 4 1
 1 2 2 1
 1 2 4 1
 4 1 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_degree_sequence_game.c0000644000175100001710000000553100000000000030577 0ustar00runnerdocker00000000000000
#include 

int main() {
    igraph_t g;
    igraph_vector_t outdeg, indeg, vec;
    igraph_bool_t is_simple;

    /* Set random seed for reproducibility */
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init_real(&outdeg, 10, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0);
    igraph_vector_init_real(&indeg, 10, 4.0, 4.0, 2.0, 2.0, 4.0, 4.0, 2.0, 2.0, 3.0, 3.0);
    igraph_vector_init(&vec, 0);

    /* checking the simple method, undirected graphs */
    igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_SIMPLE);
    if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) {
        return 1;
    }
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, 1)) {
        return 2;
    }
    igraph_vector_print(&vec);
    igraph_destroy(&g);

    /* checking the Viger-Latapy method, undirected graphs */
    igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_VL);
    if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) {
        return 3;
    }
    if (igraph_is_simple(&g, &is_simple) || !is_simple) {
        return 4;
    }
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, 0)) {
        return 5;
    }
    igraph_vector_print(&vec);
    igraph_destroy(&g);

    /* checking the simple method, directed graphs */
    igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_SIMPLE);
    if (!igraph_is_directed(&g) || igraph_vcount(&g) != 10) {
        return 6;
    }
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, 1)) {
        return 7;
    }
    igraph_vector_print(&vec);
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_IN, 1)) {
        return 8;
    }
    igraph_vector_print(&vec);
    igraph_destroy(&g);

    /* checking the no multiple edges method, undirected graphs */
    igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);
    if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) {
        return 9;
    }
    if (igraph_is_simple(&g, &is_simple) || !is_simple) {
        return 10;
    }
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, 1)) {
        return 11;
    }
    igraph_vector_print(&vec);
    igraph_destroy(&g);

    /* checking the no multiple edges method, directed graphs */
    igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);
    if (!igraph_is_directed(&g) || igraph_vcount(&g) != 10) {
        return 12;
    }
    if (igraph_is_simple(&g, &is_simple) || !is_simple) {
        return 13;
    }
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, 1)) {
        return 14;
    }
    igraph_vector_print(&vec);
    if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_IN, 1)) {
        return 15;
    }
    igraph_vector_print(&vec);
    igraph_destroy(&g);

    igraph_vector_destroy(&vec);
    igraph_vector_destroy(&outdeg);
    igraph_vector_destroy(&indeg);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_degree_sequence_game.out0000644000175100001710000000021400000000000031155 0ustar00runnerdocker000000000000003 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3
4 4 2 2 4 4 2 2 3 3
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3
4 4 2 2 4 4 2 2 3 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_delete_edges.c0000644000175100001710000000445500000000000027100 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t v;
    int ret;
    igraph_es_t es;

    igraph_vector_init(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, 0);

    igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 3, 2, -1);
    igraph_delete_edges(&g, es);
    if (igraph_ecount(&g) != 3) {
        return 1;
    }

    /* error test, no such edge to delete */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_delete_edges(&g, es);
    if (ret != IGRAPH_EINVAL) {
        printf("Error code: %i\n", ret);
        return 2;
    }
    if (igraph_ecount(&g) != 3) {
        return 3;
    }

    /* error test, invalid vertex id */
    igraph_es_destroy(&es);
    igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 10, 2, -1);
    ret = igraph_delete_edges(&g, es);
    if (ret != IGRAPH_EINVVID) {
        return 4;
    }
    if (igraph_ecount(&g) != 3) {
        return 5;
    }

    /* error test, invalid (odd) length */
    igraph_es_destroy(&es);
    igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 0, 1, 2, -1);
    ret = igraph_delete_edges(&g, es);
    if (ret != IGRAPH_EINVAL) {
        return 6;
    }
    if (igraph_ecount(&g) != 3) {
        return 7;
    }

    igraph_es_destroy(&es);
    igraph_vector_destroy(&v);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_delete_vertices.c0000644000175100001710000000402000000000000027621 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t v;
    int ret;

    /* without edges */
    igraph_empty(&g, 5, IGRAPH_DIRECTED);
    igraph_add_vertices(&g, 2, 0);
    igraph_add_vertices(&g, 3, 0);
    igraph_add_vertices(&g, 1, 0);
    igraph_add_vertices(&g, 4, 0);
    if (igraph_vcount(&g) != 15)  {
        return 1;
    }
    igraph_delete_vertices(&g, igraph_vss_1(2));
    if (igraph_vcount(&g) != 14)  {
        return 2;
    }
    igraph_destroy(&g);

    igraph_vector_init(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, 0);
    igraph_vector_destroy(&v);

    /* resize vector */
    igraph_delete_vertices(&g, igraph_vss_1(2));
    if (igraph_vcount(&g) != 3) {
        return 3;
    }
    if (igraph_ecount(&g) != 1) {
        return 4;
    }

    /* error test */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_delete_vertices(&g, igraph_vss_1(3));
    if (ret != IGRAPH_EINVVID) {
        return 5;
    }

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_deterministic_optimal_imitation.c0000644000175100001710000002336400000000000033134 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for deterministic optimal imitation.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 
#include 

/* test parameters structure */
typedef struct {
    igraph_t *graph;
    igraph_integer_t vertex;
    igraph_optimal_t optimality;
    igraph_vector_t *quantities;
    igraph_vector_t *strategies;
    igraph_neimode_t mode;
    int retval;
} strategy_test_t;

/* Error tests. That is, we expect error codes to be returned from such tests.
 */
int error_tests() {
    igraph_t g, h;
    igraph_vector_t quant, strat;
    int i, n, ret;
    strategy_test_t *test;

    /* nonempty graph */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    igraph_empty(&h, 0, 0);         /* empty graph */
    igraph_vector_init(&quant, 1);  /* quantities vector */
    igraph_vector_init(&strat, 2);  /* strategies vector */

    {
        /* test parameters */
        /*--graph--vertex--optimality--quantities--strategies--mode--retval--*/
        /* null pointer for graph */
        strategy_test_t null_graph = { NULL, 0, 0, NULL, NULL, IGRAPH_ALL,
                                       IGRAPH_EINVAL
                                     };
        /* null pointer for quantities vector */
        strategy_test_t null_quant = { &g, 0, 0, NULL, NULL, IGRAPH_ALL,
                                       IGRAPH_EINVAL
                                     };
        /* null pointer for strategies vector */
        strategy_test_t null_strat = { &g, 0, 0, &quant, NULL, IGRAPH_ALL,
                                       IGRAPH_EINVAL
                                     };
        /* empty graph */
        strategy_test_t empty_graph = {&h, 0, 0, &quant, &strat, IGRAPH_ALL,
                                       IGRAPH_EINVAL
                                      };
        /* length of quantities vector different from number of vertices */
        strategy_test_t qdiff_length = {&g, 0, 0, &quant, &strat, IGRAPH_ALL,
                                        IGRAPH_EINVAL
                                       };
        /* length of strategies vector different from number of vertices */
        strategy_test_t sdiff_length = {&g, 0, 0, &quant, &strat, IGRAPH_ALL,
                                        IGRAPH_EINVAL
                                       };
        strategy_test_t *all_checks[] = {/* 1 */ &null_graph,
                                                 /* 2 */ &null_quant,
                                                 /* 3 */ &null_strat,
                                                 /* 4 */ &empty_graph,
                                                 /* 5 */ &qdiff_length,
                                                 /* 6 */ &sdiff_length
                                        };
        n = 6;
        /* Run the error tests. We expect an error to be raised for each test. */
        igraph_set_error_handler(igraph_error_handler_ignore);
        i = 0;
        while (i < n) {
            test = all_checks[i];
            ret = igraph_deterministic_optimal_imitation(test->graph,
                    test->vertex,
                    test->optimality,
                    test->quantities,
                    test->strategies,
                    test->mode);
            if (ret != test->retval) {
                printf("Error test no. %d failed.\n", (int)(i + 1));
                return IGRAPH_FAILURE;
            }
            i++;
        }
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_destroy(&h);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);

    return IGRAPH_SUCCESS;
}

/* Updating the strategy of an isolated vertex. In this case, the strategies
 * vector should not change at all.
 */
int isolated_vertex_test() {
    igraph_t g;
    igraph_vector_t quant, strat, v;
    int i, ret;

    /* graph with one isolated vertex */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    igraph_add_vertices(&g, 1, 0);  /* new vertex 3 is isolated */
    /* quantities vector: all vertices have the same fitness */
    igraph_vector_init_real(&quant, 4, 0.25, 0.25, 0.25, 0.25);
    /* strategies vector: 0 means aggressive strategy; 1 means passive */
    igraph_vector_init_real(&strat, 4, 1., 0., 1., 0.);
    /* make a copy of the original strategies vector for comparison later on */
    igraph_vector_copy(&v, &strat);
    /* Now update strategy of vertex 3. Since this vertex is isolated, no */
    /* strategy update would take place. The resulting strategies vector */
    /* would be the same as it was originally. */
    ret = igraph_deterministic_optimal_imitation(/*graph*/ &g,
            /*vertex*/ 3,
            /*optimality*/ IGRAPH_MAXIMUM,
            /*quantities*/ &quant,
            /*strategies*/ &strat,
            /*mode*/ IGRAPH_ALL);
    if (ret) {
        printf("Isolated vertex test failed.\n");
        return IGRAPH_FAILURE;
    }
    for (i = 0; i < igraph_vector_size(&strat); i++) {
        if (VECTOR(strat)[i] != VECTOR(v)[i]) {
            printf("Isolated vertex test failed.\n");
            return IGRAPH_FAILURE;
        }
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&v);

    return IGRAPH_SUCCESS;
}

/* A game on the Petersen graph. This graph has 10 vertices and 15 edges.
 * The Petersen graph is initialized with a default quantities vector and a
 * default strategies vector. For each vertex v in the graph, we update the
 * strategy of v via deterministic optimal imitation. The resulting updated
 * strategies vector is compared with the known result vector. A mismatch would
 * raise an error code. If the updated strategies vector matches the known
 * result vector, we reset the strategies vector to its default state and
 * repeat the game with another vertex.
 */
int petersen_game_test() {
    igraph_t g;
    igraph_vector_t known_max_v, known_min_v, quant, strat, stratcopy;
    int i, nvert;

    /* the Petersen graph */
    igraph_small(&g, /*n=*/ 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 0, 5, 1, 2, 1, 6, 2, 3, 2, 7, 3, 4, 3, 8, 4, 9,
                 5, 7, 5, 8, 6, 8, 6, 9, 7, 9, -1);
    nvert = igraph_vcount(&g);
    /* Strategies vector, one strategy for each vertex. Thus vec[i] is the */
    /* strategy of vertex i. The strategy space is: {0, 1, 2, 3}. */
    igraph_vector_init_real(&strat, nvert,
                            1., 1., 2., 2., 0.,
                            0., 0., 1., 2., 3.);
    /* Quantities vector, one quantity per vertex. Thus vec[i] is the */
    /* quantity for vertex i. */
    igraph_vector_init_real(&quant, nvert,
                            0.3, 1.1, 0.5, 1.0, 0.9,
                            0.8, 0.4, 0.1, 0.7, 0.7);
    /* Known strategies that would be adopted. Thus vec[i] means that in */
    /* game i where we revise the strategy of vertex i, the strategy */
    /* vec[i] would be adopted by i. */
    /*maximum deterministic imitation*/
    igraph_vector_init_real(&known_max_v, nvert,
                            1., 1., 1., 2., 2.,
                            0., 1., 0., 2., 0.);
    /*minimum deterministic imitation*/
    igraph_vector_init_real(&known_min_v, nvert,
                            1., 1., 1., 2., 1.,
                            1., 0., 1., 0., 1.);
    /* play game and compare resulting updated strategies */
    for (i = 0; i < nvert; i++) {
        /* maximum deterministic imitation */
        igraph_vector_copy(&stratcopy, &strat);
        igraph_deterministic_optimal_imitation(/*graph*/ &g,
                /*vertex*/ (igraph_integer_t)i,
                /*optimality*/ IGRAPH_MAXIMUM,
                /*quantities*/ &quant,
                /*strategies*/ &stratcopy,
                /*neighbours*/ IGRAPH_ALL);
        if (VECTOR(stratcopy)[i] != VECTOR(known_max_v)[i]) {
            printf("Maximum deterministic imitation failed for vertex %d.\n", i);
            return IGRAPH_FAILURE;
        }
        igraph_vector_destroy(&stratcopy);
        /* minimum deterministic imitation */
        igraph_vector_copy(&stratcopy, &strat);
        igraph_deterministic_optimal_imitation(/*graph*/ &g,
                /*vertex*/ (igraph_integer_t)i,
                /*optimality*/ IGRAPH_MINIMUM,
                /*quantities*/ &quant,
                /*strategies*/ &stratcopy,
                /*neighbours*/ IGRAPH_ALL);
        if (VECTOR(stratcopy)[i] != VECTOR(known_min_v)[i]) {
            printf("Minimum deterministic imitation failed for vertex %d.\n", i);
            return IGRAPH_FAILURE;
        }
        igraph_vector_destroy(&stratcopy);
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_vector_destroy(&known_max_v);
    igraph_vector_destroy(&known_min_v);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);

    return IGRAPH_SUCCESS;
}

int main() {
    int ret;

    igraph_rng_seed(igraph_rng_default(), 648);

    ret = error_tests();
    if (ret) {
        return ret;
    }
    ret = isolated_vertex_test();
    if (ret) {
        return ret;
    }
    ret = petersen_game_test();
    if (ret) {
        return ret;
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_diameter.c0000644000175100001710000000355000000000000026254 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    for (i = 0; i < n; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int main() {

    igraph_t g;
    igraph_real_t result;
    igraph_integer_t from, to;
    igraph_vector_t path;

    igraph_barabasi_game(&g, 30, /*power=*/ 1, 30, 0, 0, /*A=*/ 1,
                         IGRAPH_DIRECTED, IGRAPH_BARABASI_BAG,
                         /*start_from=*/ 0);
    igraph_diameter(&g, &result, 0, 0, 0, IGRAPH_UNDIRECTED, 1);

    /*   printf("Diameter: %li\n", (long int) result); */

    igraph_destroy(&g);

    igraph_ring(&g, 10, IGRAPH_DIRECTED, 0, 0);
    igraph_vector_init(&path, 0);
    igraph_diameter(&g, &result, &from, &to, &path, IGRAPH_DIRECTED, 1);
    printf("diameter: %li, from %li to %li\n", (long int) result,
           (long int) from, (long int) to);
    print_vector(&path);

    igraph_vector_destroy(&path);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_diameter.out0000644000175100001710000000005600000000000026637 0ustar00runnerdocker00000000000000diameter: 9, from 0 to 9
 0 1 2 3 4 5 6 7 8 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_difference.c0000644000175100001710000001057600000000000026562 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t orig, sub, diff;
    igraph_vector_t v;

    /* Subtract from itself */
    printf("subtract itself\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 1, 4, 5, -1);
    igraph_create(&orig, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_difference(&diff, &orig, &orig);
    igraph_write_graph_edgelist(&diff, stdout);
    if (igraph_ecount(&diff) != 0 ||
        igraph_vcount(&diff) != igraph_vcount(&orig)) {
        return 1;
    }

    igraph_destroy(&orig);
    igraph_destroy(&diff);

    /* Same for undirected graph */
    printf("subtract itself, undirected\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 1, 4, 5, -1);
    igraph_create(&orig, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 1, 0, 1, 2, 2, 1, 4, 5, -1);
    igraph_create(&sub, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_difference(&diff, &orig, &sub);
    igraph_write_graph_edgelist(&diff, stdout);
    if (igraph_ecount(&diff) != 0 ||
        igraph_vcount(&diff) != igraph_vcount(&orig)) {
        return 2;
    }

    igraph_destroy(&orig);
    igraph_destroy(&sub);
    igraph_destroy(&diff);

    /* Subtract the empty graph */
    printf("subtract empty\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 1, 4, 5, -1);
    igraph_create(&orig, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_empty(&sub, 3, IGRAPH_DIRECTED);
    igraph_difference(&diff, &orig, &sub);
    igraph_write_graph_edgelist(&diff, stdout);
    if (igraph_ecount(&diff) != igraph_ecount(&orig) ||
        igraph_vcount(&diff) != igraph_vcount(&orig)) {
        return 3;
    }

    igraph_destroy(&orig);
    igraph_destroy(&sub);
    igraph_destroy(&diff);

    /* A `real' example */
    printf("real example\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 1, 4, 5, 8, 9, -1);
    igraph_create(&orig, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 5, 4, 2, 1, 6, 7, -1);
    igraph_create(&sub, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_difference(&diff, &orig, &sub);
    igraph_write_graph_edgelist(&diff, stdout);

    igraph_destroy(&diff);
    igraph_destroy(&orig);
    igraph_destroy(&sub);

    /* undirected version */
    printf("real example, undirected\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 1, 4, 5, 8, 9, 8, 10, 8, 13, 8, 11, 8, 12, -1);
    igraph_create(&orig, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 5, 4, 2, 1, 6, 7, 8, 10, 8, 13, -1);
    igraph_create(&sub, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_difference(&diff, &orig, &sub);
    igraph_write_graph_edgelist(&diff, stdout);

    igraph_destroy(&diff);
    igraph_destroy(&orig);
    igraph_destroy(&sub);

    /* undirected version with loop edge, tests Github issue #597 */
    printf("Github issue #597, undirected\n");
    igraph_vector_init_int_end(&v, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0, -1);
    igraph_create(&orig, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, -1);
    igraph_create(&sub, &v, 0, IGRAPH_UNDIRECTED);
    igraph_vector_destroy(&v);

    igraph_difference(&diff, &orig, &sub);
    igraph_write_graph_edgelist(&diff, stdout);

    igraph_destroy(&diff);
    igraph_destroy(&orig);
    igraph_destroy(&sub);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_difference.out0000644000175100001710000000031100000000000027131 0ustar00runnerdocker00000000000000subtract itself
subtract itself, undirected
subtract empty
0 1
1 2
2 1
4 5
real example
1 2
4 5
8 9
real example, undirected
1 2
8 9
8 11
8 12
Github issue #597, undirected
0 0
0 9
4 5
5 6
6 7
7 8
8 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_disjoint_union.c0000644000175100001710000000434600000000000027521 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t left, right, uni;
    igraph_vector_ptr_t glist;
    long int i, n;

    igraph_small(&left, 4, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,2, 2,3, -1);
    igraph_small(&right, 5, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,2, 2,4, -1);

    igraph_disjoint_union(&uni, &left, &right);
    igraph_write_graph_edgelist(&uni, stdout);
    printf("\n");

    igraph_destroy(&left);
    igraph_destroy(&right);
    igraph_destroy(&uni);

    /* Empty graph list; the result is the directed null graph. */
    igraph_vector_ptr_init(&glist, 0);
    igraph_disjoint_union_many(&uni, &glist);
    if (!igraph_is_directed(&uni) || igraph_vcount(&uni) != 0) {
        return 1;
    }
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    /* Non-empty graph list. */
    igraph_vector_ptr_init(&glist, 10);
    n = igraph_vector_ptr_size(&glist);
    for (i = 0; i < n; i++) {
        VECTOR(glist)[i] = calloc(1, sizeof(igraph_t));
        igraph_small(VECTOR(glist)[i], 2, IGRAPH_DIRECTED, 0,1, 1,0, -1);
    }
    if (!igraph_is_directed(&uni)) {
        return 2;
    }

    igraph_disjoint_union_many(&uni, &glist);
    igraph_write_graph_edgelist(&uni, stdout);
    printf("\n");

    /* Destroy and free the graph list. */
    n = igraph_vector_ptr_size(&glist);
    for (i = 0; i < n; i++) {
        igraph_destroy(VECTOR(glist)[i]);
        free(VECTOR(glist)[i]);
    }
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_disjoint_union.out0000644000175100001710000000020600000000000030075 0ustar00runnerdocker000000000000000 1
1 2
2 2
2 3
4 5
5 6
6 6
6 8

0 1
1 0
2 3
3 2
4 5
5 4
6 7
7 6
8 9
9 8
10 11
11 10
12 13
13 12
14 15
15 14
16 17
17 16
18 19
19 18

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_eccentricity.c0000644000175100001710000000123300000000000027143 0ustar00runnerdocker00000000000000
#include 

int main() {

    igraph_t g;
    igraph_vector_t ecc;

    igraph_vector_init(&ecc, 0);

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    igraph_vector_print(&ecc);
    igraph_destroy(&g);

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_ALL);
    igraph_vector_print(&ecc);
    igraph_destroy(&g);

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    igraph_vector_print(&ecc);
    igraph_destroy(&g);

    igraph_vector_destroy(&ecc);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_eccentricity.out0000644000175100001710000000007400000000000027532 0ustar00runnerdocker000000000000001 2 2 2 2 2 2 2 2 2
1 2 2 2 2 2 2 2 2 2
1 0 0 0 0 0 0 0 0 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_empty.c0000644000175100001710000000374100000000000025622 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    int ret;

    /* empty directed graph, zero vertices */
    igraph_empty(&g, 0, 1);
    if (igraph_vcount(&g) != 0) {
        return 1;
    }
    if (igraph_ecount(&g) != 0) {
        return 2;
    }
    igraph_destroy(&g);

    /* empty undirected graph, zero vertices */
    igraph_empty(&g, 0, 0);
    if (igraph_vcount(&g) != 0) {
        return 3;
    }
    if (igraph_ecount(&g) != 0) {
        return 4;
    }
    igraph_destroy(&g);

    /* empty directed graph, 20 vertices */
    igraph_empty(&g, 20, 1);
    if (igraph_vcount(&g) != 20) {
        return 5;
    }
    if (igraph_ecount(&g) != 0) {
        return 6;
    }
    igraph_destroy(&g);

    /* empty undirected graph, 30 vertices */
    igraph_empty(&g, 30, 0);
    if (igraph_vcount(&g) != 30) {
        return 7;
    }
    if (igraph_ecount(&g) != 0) {
        return 8;
    }
    igraph_destroy(&g);

    /* error: negative number of vertices */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_empty(&g, -1, 0);
    if (ret != IGRAPH_EINVAL) {
        return 9;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_erdos_renyi_game.c0000644000175100001710000000161000000000000027770 0ustar00runnerdocker00000000000000
#include 

int main() {
    igraph_t graph;
    igraph_vector_t component_sizes;

    igraph_rng_seed(igraph_rng_default(), 42); /* make program deterministic */

    /* Sample a graph from the Erdős-Rényi G(n,m) model */

    igraph_erdos_renyi_game(
                &graph, IGRAPH_ERDOS_RENYI_GNM,
                /* n= */ 100, /* m= */ 100,
                IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    /* Compute the fraction of vertices contained within the largest connected component */

    igraph_vector_init(&component_sizes, 0);
    igraph_clusters(&graph, NULL, &component_sizes, NULL, IGRAPH_STRONG);

    printf("Fraction of vertices in giant component: %g\n", (double) igraph_vector_max(&component_sizes) / igraph_vcount(&graph));

    /* Clean up data structures when no longer needed */

    igraph_vector_destroy(&component_sizes);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_es_pairs.c0000644000175100001710000000431300000000000026265 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    long int i;
    igraph_integer_t size;

    /* DIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 0, 2, 0, 5, 0, 2, 0, 3, 0, 4, 0, 7, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        igraph_es_size(&g, &es, &size);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
            size--;
        }
        if (size != 0) {
            return 1;
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    /* UNDIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 2, 0, 5, 0, 0, 2, 3, 0, 0, 4, 7, 0, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_feedback_arc_set.c0000644000175100001710000000516300000000000027710 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {
    igraph_t g;
    igraph_vector_t weights, result;
    igraph_bool_t dag;

    igraph_vector_init(&result, 0);

    /***********************************************************************/
    /* Approximation with Eades' method                                    */
    /***********************************************************************/

    /* Simple unweighted graph */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, -1);
    igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_APPROX_EADES);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 1;
    }
    igraph_destroy(&g);

    /* Simple weighted graph */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, -1);
    igraph_vector_init_int_end(&weights, -1, 1, 1, 3, 1, 1, 1, 1, 1, 1, -1);
    igraph_feedback_arc_set(&g, &result, &weights, IGRAPH_FAS_APPROX_EADES);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 2;
    }
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* Simple unweighted graph with loops */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, 1, 1, 4, 4, -1);
    igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_APPROX_EADES);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 3;
    }
    igraph_destroy(&g);

    igraph_vector_destroy(&result);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_feedback_arc_set.out0000644000175100001710000000001300000000000030262 0ustar00runnerdocker000000000000002
1
2 9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_feedback_arc_set_ip.c0000644000175100001710000000720200000000000030374 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {
    igraph_t g;
    igraph_vector_t weights, result;
    igraph_bool_t dag;
    int retval;

    igraph_vector_init(&result, 0);

    igraph_set_error_handler(&igraph_error_handler_printignore);

    /***********************************************************************/
    /* Exact solution with integer programming                             */
    /***********************************************************************/

    /* Simple unweighted graph */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, -1);
    retval = igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP);
    if (retval == IGRAPH_UNIMPLEMENTED) {
        return 77;
    }
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 1;
    }
    igraph_destroy(&g);

    /* Simple weighted graph */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, -1);
    igraph_vector_init_int_end(&weights, -1, 1, 1, 3, 1, 1, 1, 1, 1, 1, -1);
    igraph_feedback_arc_set(&g, &result, &weights, IGRAPH_FAS_EXACT_IP);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 2;
    }
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* Simple unweighted graph with loops */
    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 0, 2, 3, 2, 4, 0, 4, 4, 3, 5, 0, 6, 5, 1, 1, 4, 4, -1);
    igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 3;
    }
    igraph_destroy(&g);

    /* Disjoint union of two almost identical graphs */
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 0, 2, 3,  2, 4,  0, 4,  4, 3,    5, 0,  6, 5, 1, 1, 4, 4,
                 7, 8, 8, 9, 9, 7, 9, 10, 9, 11, 7, 11, 11, 10, 12, 7, 13, 12,
                 -1);
    igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 4;
    }
    igraph_destroy(&g);

    /* Graph with lots of isolated vertices */
    igraph_small(&g, 10000, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP);
    igraph_vector_print(&result);
    igraph_delete_edges(&g, igraph_ess_vector(&result));
    igraph_is_dag(&g, &dag);
    if (!dag) {
        return 5;
    }
    igraph_destroy(&g);

    igraph_vector_destroy(&result);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_feedback_arc_set_ip.out0000644000175100001710000000002600000000000030756 0ustar00runnerdocker000000000000001
1
1 9 10
1 9 10 12

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_fisher_yates_shuffle.c0000644000175100001710000000673100000000000030667 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for the Fisher-Yates shuffle.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 

#define R_INTEGER(a,b) (igraph_rng_get_integer(igraph_rng_default(), (a), (b)))
#define R_UNIF(a,b) (igraph_rng_get_unif(igraph_rng_default(), (a), (b)))

int main() {
    igraph_real_t d;
    igraph_vector_t u, v;
    int ret;
    long int i, k, n;

    /********************************
     * Example usage
     ********************************/

    /* Sequences with one element. Such sequences are trivially permuted.
     * The result of any Fisher-Yates shuffle on a sequence with one element
     * must be the original sequence itself.
     */
    n = 1;
    igraph_vector_init(&v, n);
    igraph_rng_seed(igraph_rng_default(), 42); /* make tests deterministic */
    k = R_INTEGER(-1000, 1000);
    VECTOR(v)[0] = k;
    igraph_vector_shuffle(&v);
    if (VECTOR(v)[0] != k) {
        return 1;
    }
    d = R_UNIF(-1000.0, 1000.0);

    VECTOR(v)[0] = d;
    igraph_vector_shuffle(&v);
    if (VECTOR(v)[0] != d) {
        return 2;
    }
    igraph_vector_destroy(&v);

    /* Sequences with multiple elements. A Fisher-Yates shuffle of a sequence S
     * is a random permutation \pi(S) of S. Thus \pi(S) must have the same
     * length and elements as the original sequence S. A major difference between
     * S and its random permutation \pi(S) is that the order in which elements
     * appear in \pi(S) is probably different from how elements are ordered in S.
     * If S has length n = 1, then both \pi(S) and S are equivalent sequences in
     * that \pi(S) is merely S and no permutation has taken place. If S has
     * length n > 1, then there are n! possible permutations of S. Assume that
     * each such permutation is equally likely to appear as a result of the
     * Fisher-Yates shuffle. As n increases, the probability that S is different
     * from \pi(S) also increases. We have a probability of 1 / n! that S and
     * \pi(S) are equivalent sequences.
     */
    n = 100;
    igraph_vector_init(&u, n);
    igraph_vector_init(&v, n);

    for (i = 0; i < n; i++) {
        k = R_INTEGER(-1000, 1000);
        VECTOR(u)[i] = k;
        VECTOR(v)[i] = k;
    }

    igraph_vector_shuffle(&v);
    /* must have same length */
    if (igraph_vector_size(&v) != n) {
        return 3;
    }
    if (igraph_vector_size(&u) != igraph_vector_size(&v)) {
        return 4;
    }
    /* must have same elements */
    igraph_vector_sort(&u);
    igraph_vector_sort(&v);
    if (!igraph_vector_all_e(&u, &v)) {
        return 5;
    }
    igraph_vector_destroy(&u);
    igraph_vector_destroy(&v);

    /* empty sequence */
    igraph_vector_init(&v, 0);
    ret = igraph_vector_shuffle(&v);
    igraph_vector_destroy(&v);

    return ret == 0 ? 0 : 6;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_free.c0000644000175100001710000000074500000000000025406 0ustar00runnerdocker00000000000000#include 

int main(void)
{
   igraph_t graph;
   igraph_vector_ptr_t seps;
   long int i;

   igraph_famous(&graph, "tutte");
   igraph_vector_ptr_init(&seps, 0);
   igraph_minimum_size_separators(&graph, &seps);

   for (i=0; i

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;
    long int n_vertices = 10;

    /* Create an undirected complete graph. */
    /* Use IGRAPH_UNDIRECTED and IGRAPH_NO_LOOPS instead of 1/TRUE and 0/FALSE for better readability. */
    igraph_full(&graph, n_vertices, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    printf("The undirected complete graph on %ld vertices has %ld edges.\n",
           (long int) igraph_vcount(&graph), (long int) igraph_ecount(&graph));

    /* Remember to destroy the object at the end. */
    igraph_destroy(&graph);

    /* Create a directed complete graph. */
    igraph_full(&graph, n_vertices, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    printf("The directed complete graph on %ld vertices has %ld edges.\n",
           (long int) igraph_vcount(&graph), (long int) igraph_ecount(&graph));

    igraph_destroy(&graph);

    /* Create an undirected complete graph with self-loops. */
    igraph_full(&graph, n_vertices, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    printf("The undirected complete graph on %ld vertices with self-loops has %ld edges.\n",
           (long int) igraph_vcount(&graph), (long int) igraph_ecount(&graph));

    igraph_destroy(&graph);

    /* Create a directed graph with self-loops. */
    igraph_full(&graph, n_vertices, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    printf("The directed complete graph on %ld vertices with self-loops has %ld edges.\n",
           (long int) igraph_vcount(&graph), (long int) igraph_ecount(&graph));

    igraph_destroy(&graph);

    return 0;

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_full.out0000644000175100001710000000041100000000000026002 0ustar00runnerdocker00000000000000The undirected complete graph on 10 vertices has 45 edges.
The directed complete graph on 10 vertices has 90 edges.
The undirected complete graph on 10 vertices with self-loops has 55 edges.
The directed complete graph on 10 vertices with self-loops has 100 edges.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_all_shortest_paths_dijkstra.c0000644000175100001710000001566100000000000033124 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

/* Compares two paths based on their last elements. If they are equal, proceeds
 * with the ones preceding these elements, until we find a difference. If one
 * of the vectors is a suffix of the other, the shorter vector gets ordered
 * first.
 */
int vector_tail_cmp(const void *path1, const void *path2) {
    const igraph_vector_t *vec1 = *(const igraph_vector_t**)path1;
    const igraph_vector_t *vec2 = *(const igraph_vector_t**)path2;
    size_t length1 = igraph_vector_size(vec1);
    size_t length2 = igraph_vector_size(vec2);
    int diff;

    while (length1 > 0 && length2 > 0) {
        length1--;
        length2--;
        diff = VECTOR(*vec1)[length1] - VECTOR(*vec2)[length2];
        if (diff != 0) {
            return diff;
        }
    }

    if (length1 == 0 && length2 == 0) {
        return 0;
    } else if (length1 == 0) {
        return -1;
    } else {
        return 1;
    }
}

void check_nrgeo(const igraph_t *graph, igraph_vs_t vs,
                 const igraph_vector_ptr_t *paths,
                 const igraph_vector_t *nrgeo) {
    long int i, n;
    igraph_vector_t nrgeo2, *path;
    igraph_vit_t vit;

    n = igraph_vcount(graph);
    igraph_vector_init(&nrgeo2, n);
    if (igraph_vector_size(nrgeo) != n) {
        printf("nrgeo vector length must be %ld, was %ld", n, igraph_vector_size(nrgeo));
        return;
    }

    n = igraph_vector_ptr_size(paths);
    for (i = 0; i < n; i++) {
        path = VECTOR(*paths)[i];
        if (path == 0) {
            printf("Null path found in result vector at index %ld\n", i);
            return;
        }
        if (igraph_vector_size(path) == 0) {
            printf("Empty path found in result vector at index %ld\n", i);
            return;
        }
        VECTOR(nrgeo2)[(long int)igraph_vector_tail(path)] += 1;
    }

    igraph_vit_create(graph, vs, &vit);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        long int node = IGRAPH_VIT_GET(vit);
        if (VECTOR(*nrgeo)[node] - VECTOR(nrgeo2)[node]) {
            printf("nrgeo[%ld] invalid, observed = %ld, expected = %ld\n",
                   node, (long int)VECTOR(*nrgeo)[node], (long int)VECTOR(nrgeo2)[node]);
        }
    }
    igraph_vit_destroy(&vit);

    igraph_vector_destroy(&nrgeo2);
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t res;
    long int i;

    igraph_real_t weights[] = { 1, 2, 3, 4, 5, 1, 1, 1, 1, 1 };
    igraph_real_t weights2[] = { 0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1 };
    igraph_real_t dim[] = { 4, 4 };

    igraph_vector_t weights_vec, dim_vec, nrgeo;
    igraph_vs_t vs;

    igraph_vector_init(&nrgeo, 0);

    /* Simple ring graph without weights */

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);

    igraph_vector_ptr_init(&res, 5);
    igraph_vs_vector_small(&vs, 1, 3, 4, 5, 2, 1,  -1);

    igraph_get_all_shortest_paths_dijkstra(
                &g,
                /*res=*/ &res, /*nrgeo=*/ &nrgeo,
                /*from=*/ 0, /*to=*/ vs,
                /*weights=*/ NULL, /*mode=*/ IGRAPH_OUT);
    check_nrgeo(&g, vs, &res, &nrgeo);

    for (i = 0; i < igraph_vector_ptr_size(&res); i++) {
        igraph_vector_print(VECTOR(res)[i]);
        igraph_vector_destroy(VECTOR(res)[i]);
        igraph_free(VECTOR(res)[i]);
        VECTOR(res)[i] = 0;
    }

    /* Same ring, but with weights */

    igraph_vector_view(&weights_vec, weights, sizeof(weights) / sizeof(igraph_real_t));
    igraph_get_all_shortest_paths_dijkstra(
                &g,
                /*res=*/ &res, /*nrgeo=*/ &nrgeo,
                /*from=*/ 0, /*to=*/ vs,
                /*weights=*/ &weights_vec, /*mode=*/ IGRAPH_OUT);
    check_nrgeo(&g, vs, &res, &nrgeo);

    for (i = 0; i < igraph_vector_ptr_size(&res); i++) {
        igraph_vector_print(VECTOR(res)[i]);
        igraph_vector_destroy(VECTOR(res)[i]);
        igraph_free(VECTOR(res)[i]);
        VECTOR(res)[i] = 0;
    }

    igraph_destroy(&g);

    /* More complicated example */

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 0, 3,   1, 2, 1, 4, 1, 5,
                 2, 3, 2, 6,         3, 2, 3, 6,
                 4, 5, 4, 7,         5, 6, 5, 8, 5, 9,
                 7, 5, 7, 8,         8, 9,
                 5, 2,
                 2, 1,
                 -1);

    igraph_vector_view(&weights_vec, weights2, sizeof(weights2) / sizeof(igraph_real_t));
    igraph_get_all_shortest_paths_dijkstra(
                &g,
                /*res=*/ &res, /*nrgeo=*/ &nrgeo,
                /*from=*/ 0, /*to=*/ vs,
                /*weights=*/ &weights_vec, /*mode=*/ IGRAPH_OUT);

    check_nrgeo(&g, vs, &res, &nrgeo);

    /* Sort the paths in a deterministic manner to avoid problems with
     * different qsort() implementations on different platforms */
    igraph_vector_ptr_sort(&res, vector_tail_cmp);

    for (i = 0; i < igraph_vector_ptr_size(&res); i++) {
        igraph_vector_print(VECTOR(res)[i]);
        igraph_vector_destroy(VECTOR(res)[i]);
        igraph_free(VECTOR(res)[i]);
        VECTOR(res)[i] = 0;
    }

    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    /* Regular lattice with some heavyweight edges */
    igraph_vector_view(&dim_vec, dim, sizeof(dim) / sizeof(igraph_real_t));
    igraph_lattice(&g, &dim_vec, 1, 0, 0, 0);
    igraph_vs_vector_small(&vs, 3, 12, 15, -1);
    igraph_vector_init(&weights_vec, 24);
    igraph_vector_fill(&weights_vec, 1);
    VECTOR(weights_vec)[2] = 100;
    VECTOR(weights_vec)[8] = 100; /* 1-->2, 4-->8 */
    igraph_get_all_shortest_paths_dijkstra(
                &g,
                /*res=*/ 0, /*nrgeo=*/ &nrgeo,
                /*from=*/ 0, /*to=*/ vs,
                /*weights=*/ &weights_vec, /*mode=*/ IGRAPH_OUT);
    igraph_vector_destroy(&weights_vec);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    printf("%ld ", (long int)VECTOR(nrgeo)[3]);
    printf("%ld ", (long int)VECTOR(nrgeo)[12]);
    printf("%ld\n", (long int)VECTOR(nrgeo)[15]);

    igraph_vector_ptr_destroy(&res);
    igraph_vector_destroy(&nrgeo);

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_all_shortest_paths_dijkstra.out0000644000175100001710000000022300000000000033475 0ustar00runnerdocker000000000000000 1
0 1 2
0 1 2 3
0 1 2 3 4
0 9 8 7 6 5
0 1 2 3 4 5
0 1
0 1 2
0 1 2 3
0 9 8 7 6 5 4
0 1 2 3 4
0 9 8 7 6 5
0 1
0 1 2
0 3
0 1 2 3
0 1 4
0 1 5
4 4 12
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_eid.c0000644000175100001710000001064300000000000026063 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        fprintf(f, " %li", (long int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {
    igraph_t g;
    igraph_integer_t eid;
    igraph_vector_t hist;
    long int i;
    int ret;

    /* DIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);

    igraph_vector_init(&hist, 9);

    for (i = 1; i < 10; i++) {
        igraph_get_eid(&g, &eid, 0, i, IGRAPH_DIRECTED, /*error=*/ 1);
        VECTOR(hist)[ (long int) eid ] = 1;
    }
    print_vector(&hist, stdout);

    igraph_vector_destroy(&hist);
    igraph_destroy(&g);

    /* UNDIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);

    igraph_vector_init(&hist, 9);

    for (i = 1; i < 10; i++) {
        igraph_get_eid(&g, &eid, 0, i, IGRAPH_UNDIRECTED, /*error=*/ 1);
        VECTOR(hist)[ (long int) eid ] += 1;
        igraph_get_eid(&g, &eid, i, 0, IGRAPH_DIRECTED, /*error=*/ 1);
        VECTOR(hist)[ (long int) eid ] += 1;
    }
    print_vector(&hist, stdout);

    igraph_vector_destroy(&hist);
    igraph_destroy(&g);

    /* NON-EXISTANT EDGE */

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);

    igraph_set_error_handler(igraph_error_handler_ignore);

    ret = igraph_get_eid(&g, &eid, 5, 6, IGRAPH_UNDIRECTED, /*error=*/ 1);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }

    igraph_destroy(&g);

    return 0;
}

/* Stress test */

/* int main() { */

/*   igraph_t g; */
/*   long int i, n; */
/*   igraph_integer_t from, to, eid; */

/*   igraph_barabasi_game(&g, 10000, 100, 0, 0, 1); */
/*   n=igraph_ecount(&g); */
/*   for (i=0; i
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

void print_vector(igraph_vector_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        fprintf(f, " %li", (long int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int check_simple() {

    igraph_t g;
    long int nodes = 100;
    long int edges = 1000;
    igraph_real_t p = 3.0 / nodes;
    long int runs = 10;
    long int r, e, ecount;
    igraph_vector_t eids, pairs, path;

    igraph_rng_seed(igraph_rng_default(), 42); /* make tests deterministic */

    igraph_vector_init(&pairs, edges * 2);
    igraph_vector_init(&path, 0);
    igraph_vector_init(&eids, 0);

    for (r = 0; r < runs; r++) {
        igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, nodes, p,
                                /*directed=*/ 0, /*loops=*/ 0);
        ecount = igraph_ecount(&g);
        for (e = 0; e < edges; e++) {
            long int edge = RNG_INTEGER(0, ecount - 1);
            VECTOR(pairs)[2 * e] = IGRAPH_FROM(&g, edge);
            VECTOR(pairs)[2 * e + 1] = IGRAPH_TO(&g, edge);
        }
        igraph_get_eids(&g, &eids, &pairs, /*path=*/ 0, 0, /*error=*/ 1);
        for (e = 0; e < edges; e++) {
            long int edge = VECTOR(eids)[e];
            long int from1 = VECTOR(pairs)[2 * e];
            long int to1 = VECTOR(pairs)[2 * e + 1];
            long int from2 = IGRAPH_FROM(&g, edge);
            long int to2 = IGRAPH_TO(&g, edge);
            long int min1 = from1 < to1 ? from1 : to1;
            long int max1 = from1 < to1 ? to1 : from1;
            long int min2 = from2 < to2 ? from2 : to2;
            long int max2 = from2 < to2 ? to2 : from2;
            if (min1 != min2 || max1 != max2) {
                return 11;
            }
        }

        igraph_diameter(&g, /*res=*/ 0, /*from=*/ 0, /*to=*/ 0, &path,
                        IGRAPH_UNDIRECTED, /*unconn=*/ 1);
        igraph_get_eids(&g, &eids, /*pairs=*/ 0, &path, 0, /*error=*/ 1);
        for (e = 0; e < igraph_vector_size(&path) - 1; e++) {
            long int edge = VECTOR(eids)[e];
            long int from1 = VECTOR(path)[e];
            long int to1 = VECTOR(path)[e + 1];
            long int from2 = IGRAPH_FROM(&g, edge);
            long int to2 = IGRAPH_TO(&g, edge);
            long int min1 = from1 < to1 ? from1 : to1;
            long int max1 = from1 < to1 ? to1 : from1;
            long int min2 = from2 < to2 ? from2 : to2;
            long int max2 = from2 < to2 ? to2 : from2;
            if (min1 != min2 || max1 != max2) {
                return 12;
            }
        }

        igraph_destroy(&g);
    }

    igraph_vector_destroy(&path);
    igraph_vector_destroy(&pairs);
    igraph_vector_destroy(&eids);

    return 0;
}

int check_multi() {

    igraph_t g;
    igraph_vector_t vec;
    igraph_vector_t eids, eids2;
    int ret;
    long int i;

    igraph_real_t q1[] = { 0, 1, 0, 1 };
    igraph_real_t q2[] = { 0, 1, 0, 1, 0, 1 };
    igraph_real_t q3[] = { 1, 0, 3, 4, 1, 0, 0, 1, 3, 4, 0, 1 };

    igraph_vector_init(&eids, 0);

    /*********************************/
    igraph_small(&g, /*n=*/ 10, /*directed=*/ 1,
                 0, 1, 0, 1, 1, 0, 1, 2, 3, 4, 3, 4, 3, 4, 3, 5, 3, 7,
                 9, 8,
                 -1);

    igraph_vector_view(&vec, q1, sizeof(q1) / sizeof(igraph_real_t));
    igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 1, /*error=*/ 1);
    igraph_vector_sort(&eids);
    print_vector(&eids, stdout);

    igraph_vector_view(&vec, q2, sizeof(q2) / sizeof(igraph_real_t));
    igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 0, /*error=*/ 1);
    igraph_vector_sort(&eids);
    print_vector(&eids, stdout);

    igraph_vector_view(&vec, q2, sizeof(q2) / sizeof(igraph_real_t));
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 1, /*error=*/1);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }
    igraph_set_error_handler(igraph_error_handler_abort);

    igraph_destroy(&g);
    /*********************************/

    /*********************************/
    igraph_small(&g, /*n=*/10, /*directed=*/0,
                 0, 1, 1, 0, 0, 1, 3, 4, 3, 4, 5, 4, 9, 8,
                 -1);

    igraph_vector_view(&vec, q1, sizeof(q1) / sizeof(igraph_real_t));
    igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/1, /*error=*/ 1);
    igraph_vector_sort(&eids);
    print_vector(&eids, stdout);

    igraph_vector_view(&vec, q3, sizeof(q3) / sizeof(igraph_real_t));
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/0, /*error=*/ 1);
    if (ret != IGRAPH_EINVAL) {
        return 2;
    }
    igraph_set_error_handler(igraph_error_handler_abort);

    igraph_destroy(&g);

    /*********************************/

    igraph_vector_destroy(&eids);

    /*********************************/
    /* Speed tests */

#define NODES 10000
    igraph_barabasi_game(&g, /*n=*/ NODES, /*power=*/ 1.0, /*m=*/ 3,
                         /*outseq=*/ 0, /*outpref=*/ 0, /*A=*/ 1,
                         /*directed=*/ 1, IGRAPH_BARABASI_BAG,
                         /*start_from=*/ 0);
    igraph_simplify(&g, /*multiple=*/ 1, /*loops=*/ 0, /*edge_comb=*/ 0);

    igraph_vector_init(&eids, NODES / 2);
    igraph_random_sample(&eids, 0, igraph_ecount(&g) - 1, NODES / 2);
    igraph_vector_init(&vec, NODES);
    for (i = 0; i < NODES / 2; i++) {
        VECTOR(vec)[2 * i]   = IGRAPH_FROM(&g, VECTOR(eids)[i]);
        VECTOR(vec)[2 * i + 1] = IGRAPH_TO(&g, VECTOR(eids)[i]);
    }
    igraph_vector_init(&eids2, 0);
    igraph_get_eids_multi(&g, &eids2, &vec, 0, /*directed=*/ 1, /*error=*/ 1);
    if (!igraph_vector_all_e(&eids, &eids2)) {
        return 3;
    }

    /**/

    for (i = 0; i < NODES / 2; i++) {
        VECTOR(vec)[2 * i]   = IGRAPH_TO(&g, VECTOR(eids)[i]);
        VECTOR(vec)[2 * i + 1] = IGRAPH_FROM(&g, VECTOR(eids)[i]);
    }
    igraph_get_eids_multi(&g, &eids2, &vec, 0, /*directed=*/ 0, /*error=*/ 1);
    if (!igraph_vector_all_e(&eids, &eids2)) {
        return 4;
    }

    igraph_vector_destroy(&eids);
    igraph_vector_destroy(&eids2);
    igraph_vector_destroy(&vec);
    igraph_destroy(&g);

    /*********************************/

    return 0;
}

int main() {
    int ret;

    if ( (ret = check_simple()) != 0) {
        return ret;
    }
    if ( (ret = check_multi()) != 0)  {
        return ret;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_eids.out0000644000175100001710000000002100000000000026620 0ustar00runnerdocker00000000000000 0 1
 0 1 2
 1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_shortest_paths.c0000644000175100001710000001006500000000000030372 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include 

void print_vector(igraph_vector_t *v) {
    long int i, l = igraph_vector_size(v);
    for (i = 0; i < l; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int check_evecs(const igraph_t *graph, const igraph_vector_ptr_t *vecs,
                const igraph_vector_ptr_t *evecs, int error_code) {

    igraph_bool_t directed = igraph_is_directed(graph);
    long int i, n = igraph_vector_ptr_size(vecs);
    if (igraph_vector_ptr_size(evecs) != n) {
        exit(error_code + 1);
    }

    for (i = 0; i < n; i++) {
        igraph_vector_t *vvec = VECTOR(*vecs)[i];
        igraph_vector_t *evec = VECTOR(*evecs)[i];
        long int j, n2 = igraph_vector_size(evec);
        if (igraph_vector_size(vvec) == 0 && n2 == 0) {
            continue;
        }
        if (igraph_vector_size(vvec) != n2 + 1) {
            exit(error_code + 2);
        }
        for (j = 0; j < n2; j++) {
            long int edge = VECTOR(*evec)[j];
            long int from = VECTOR(*vvec)[j];
            long int to = VECTOR(*vvec)[j + 1];
            if (directed) {
                if (from != IGRAPH_FROM(graph, edge) ||
                    to   != IGRAPH_TO  (graph, edge)) {
                    exit(error_code);
                }
            } else {
                long int from2 = IGRAPH_FROM(graph, edge);
                long int to2 = IGRAPH_TO(graph, edge);
                long int min1 = from < to ? from : to;
                long int max1 = from < to ? to : from;
                long int min2 = from2 < to2 ? from2 : to2;
                long int max2 = from2 < to2 ? to2 : from2;
                if (min1 != min2 || max1 != max2) {
                    exit(error_code + 3);
                }
            }
        }
    }

    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t vecs, evecs;
    igraph_vector_long_t pred, inbound;
    long int i;
    igraph_vs_t vs;

    igraph_ring(&g, 10, IGRAPH_DIRECTED, 0, 1);

    igraph_vector_ptr_init(&vecs, 5);
    igraph_vector_ptr_init(&evecs, 5);
    igraph_vector_long_init(&pred, 0);
    igraph_vector_long_init(&inbound, 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(vecs)[i], 0);
        VECTOR(evecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(evecs)[i], 0);
    }
    igraph_vs_vector_small(&vs, 1, 3, 5, 2, 1,  -1);

    igraph_get_shortest_paths(&g, &vecs, &evecs, 0, vs, IGRAPH_OUT, &pred, &inbound);

    check_evecs(&g, &vecs, &evecs, 10);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(vecs)[i]);
        free(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(evecs)[i]);
        free(VECTOR(evecs)[i]);
    }

    igraph_vector_long_print(&pred);
    igraph_vector_long_print(&inbound);

    igraph_vector_ptr_destroy(&vecs);
    igraph_vector_ptr_destroy(&evecs);
    igraph_vector_long_destroy(&pred);
    igraph_vector_long_destroy(&inbound);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_shortest_paths.out0000644000175100001710000000013000000000000030747 0ustar00runnerdocker00000000000000 0 1
 0 1 2 3
 0 1 2 3 4 5
 0 1 2
 0 1
0 0 1 2 3 4 -1 -1 -1 -1
-1 0 1 2 3 4 -1 -1 -1 -1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_shortest_paths_dijkstra.c0000644000175100001710000001700600000000000032267 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include 

void print_vector(igraph_vector_t *v) {
    long int i, l = igraph_vector_size(v);
    for (i = 0; i < l; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int check_evecs(const igraph_t *graph, const igraph_vector_ptr_t *vecs,
                const igraph_vector_ptr_t *evecs, int error_code) {

    igraph_bool_t directed = igraph_is_directed(graph);
    long int i, n = igraph_vector_ptr_size(vecs);
    if (igraph_vector_ptr_size(evecs) != n) {
        exit(error_code + 1);
    }

    for (i = 0; i < n; i++) {
        igraph_vector_t *vvec = VECTOR(*vecs)[i];
        igraph_vector_t *evec = VECTOR(*evecs)[i];
        long int j, n2 = igraph_vector_size(evec);
        if (igraph_vector_size(vvec) == 0 && n2 == 0) {
            continue;
        }
        if (igraph_vector_size(vvec) != n2 + 1) {
            exit(error_code + 2);
        }
        for (j = 0; j < n2; j++) {
            long int edge = VECTOR(*evec)[j];
            long int from = VECTOR(*vvec)[j];
            long int to = VECTOR(*vvec)[j + 1];
            if (directed) {
                if (from != IGRAPH_FROM(graph, edge) ||
                    to   != IGRAPH_TO  (graph, edge)) {
                    exit(error_code);
                }
            } else {
                long int from2 = IGRAPH_FROM(graph, edge);
                long int to2 = IGRAPH_TO(graph, edge);
                long int min1 = from < to ? from : to;
                long int max1 = from < to ? to : from;
                long int min2 = from2 < to2 ? from2 : to2;
                long int max2 = from2 < to2 ? to2 : from2;
                if (min1 != min2 || max1 != max2) {
                    exit(error_code + 3);
                }
            }
        }
    }

    return 0;
}

int check_pred_inbound(const igraph_t* graph, const igraph_vector_long_t* pred,
                       const igraph_vector_long_t* inbound, int start, int error_code) {
    long int i, n = igraph_vcount(graph);

    if (igraph_vector_long_size(pred) != n ||
        igraph_vector_long_size(inbound) != n) {
        exit(error_code);
    }

    if (VECTOR(*pred)[start] != start || VECTOR(*inbound)[start] != -1) {
        exit(error_code + 1);
    }

    for (i = 0; i < n; i++) {
        if (VECTOR(*pred)[i] == -1) {
            if (VECTOR(*inbound)[i] != -1) {
                exit(error_code + 2);
            }
        } else if (VECTOR(*pred)[i] == i) {
            if (i != start) {
                exit(error_code + 3);
            }
            if (VECTOR(*inbound)[i] != -1) {
                exit(error_code + 4);
            }
        } else {
            long int eid = VECTOR(*inbound)[i];
            long int u = IGRAPH_FROM(graph, eid), v = IGRAPH_TO(graph, eid);
            if (v != i && !igraph_is_directed(graph)) {
                long int dummy = u;
                u = v;
                v = dummy;
            }
            if (v != i) {
                exit(error_code + 5);
            } else if (u != VECTOR(*pred)[i]) {
                exit(error_code + 6);
            }
        }
    }

    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t vecs, evecs;
    igraph_vector_long_t pred, inbound;
    long int i;
    igraph_real_t weights[] = { 1, 2, 3, 4, 5, 1, 1, 1, 1, 1 };
    igraph_real_t weights2[] = { 0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1 };
    igraph_vector_t weights_vec;
    igraph_vs_t vs;

    /* Simple ring graph without weights */

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);

    igraph_vector_ptr_init(&vecs, 6);
    igraph_vector_ptr_init(&evecs, 6);
    igraph_vector_long_init(&pred, 0);
    igraph_vector_long_init(&inbound, 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(vecs)[i], 0);
        VECTOR(evecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(evecs)[i], 0);
    }
    igraph_vs_vector_small(&vs, 0, 1, 3, 5, 2, 1,  -1);

    igraph_get_shortest_paths_dijkstra(&g, /*vertices=*/ &vecs,
                                       /*edges=*/ &evecs, /*from=*/ 0, /*to=*/ vs,
                                       /*weights=*/ 0, /*mode=*/ IGRAPH_OUT,
                                       /*predecessors=*/ &pred,
                                       /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs, 10);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0, 40);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector(VECTOR(vecs)[i]);
    }

    /* Same ring, but with weights */

    igraph_vector_view(&weights_vec, weights, sizeof(weights) / sizeof(igraph_real_t));
    igraph_get_shortest_paths_dijkstra(&g, /*vertices=*/ &vecs,
                                       /*edges=*/ &evecs, /*from=*/ 0, /*to=*/ vs,
                                       &weights_vec, IGRAPH_OUT,
                                       /*predecessors=*/ &pred,
                                       /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs, 20);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0, 50);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector(VECTOR(vecs)[i]);
    }

    igraph_destroy(&g);

    /* More complicated example */

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 0, 3,    1, 2, 1, 4, 1, 5,
                 2, 3, 2, 6,         3, 2, 3, 6,
                 4, 5, 4, 7,         5, 6, 5, 8, 5, 9,
                 7, 5, 7, 8,         8, 9,
                 5, 2,
                 2, 1,
                 -1);

    igraph_vector_view(&weights_vec, weights2, sizeof(weights2) / sizeof(igraph_real_t));
    igraph_get_shortest_paths_dijkstra(&g, /*vertices=*/ &vecs,
                                       /*edges=*/ &evecs, /*from=*/ 0, /*to=*/ vs,
                                       &weights_vec, IGRAPH_OUT,
                                       /*predecessors=*/ &pred,
                                       /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs, 30);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0, 60);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(vecs)[i]);
        free(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(evecs)[i]);
        free(VECTOR(evecs)[i]);
    }

    igraph_vector_ptr_destroy(&vecs);
    igraph_vector_ptr_destroy(&evecs);
    igraph_vector_long_destroy(&pred);
    igraph_vector_long_destroy(&inbound);

    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_get_shortest_paths_dijkstra.out0000644000175100001710000000016400000000000032651 0ustar00runnerdocker00000000000000 0
 0 1
 0 1 2 3
 0 1 2 3 4 5
 0 1 2
 0 1
 0
 0 1
 0 1 2 3
 0 9 8 7 6 5
 0 1 2
 0 1
 0
 0 1
 0 3
 0 1 5
 0 1 2
 0 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_girth.c0000644000175100001710000000322600000000000025577 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_t g;
    igraph_integer_t girth;
    igraph_vector_t v;
    igraph_vector_t circle;
    igraph_real_t chord[] = { 0, 50 };

    igraph_ring(&g, 100, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vector_view(&v, chord, sizeof(chord) / sizeof(igraph_real_t));
    igraph_add_edges(&g, &v, 0);
    igraph_girth(&g, &girth, 0);
    if (girth != 51) {
        return 1;
    }

    igraph_destroy(&g);

    /* Special case: null graph */
    igraph_ring(&g, 0, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vector_init(&circle, 1);
    VECTOR(circle)[0] = 2;
    igraph_girth(&g, &girth, &circle);
    if (girth != 0) {
        return 2;
    }
    if (igraph_vector_size(&circle) != 0) {
        return 3;
    }
    igraph_vector_destroy(&circle);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_grg_game.c0000644000175100001710000000260200000000000026227 0ustar00runnerdocker00000000000000
#include 
#include 

int main() {
    igraph_t graph;
    igraph_vector_t x, y;
    igraph_vector_t weights;
    igraph_eit_t eit;
    igraph_real_t avg_dist;

    /* Set random seed for reproducible results */

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Create a random geometric graph and retrieve vertex coordinates */

    igraph_vector_init(&x, 0);
    igraph_vector_init(&y, 0);

    igraph_grg_game(&graph, 200, 0.1, /* torus */ 0, &x, &y);

    /* Compute edge weights as geometric distance */

    igraph_vector_init(&weights, igraph_ecount(&graph));
    igraph_eit_create(&graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit);
    for (; ! IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        long int e = IGRAPH_EIT_GET(eit);
        long int u = IGRAPH_FROM(&graph, e);
        long int v = IGRAPH_TO(&graph, e);

        VECTOR(weights)[e] = hypot(VECTOR(x)[u] - VECTOR(x)[v], VECTOR(y)[u] - VECTOR(y)[v]);
    }
    igraph_eit_destroy(&eit);

    /* Compute average path length */

    igraph_average_path_length_dijkstra(&graph, &avg_dist, NULL, &weights, IGRAPH_UNDIRECTED, /* unconn */ 1);

    printf("Average distance in the geometric graph: %g.\n", avg_dist);

    /* Destroy data structures when no longer needed */

    igraph_vector_destroy(&weights);
    igraph_destroy(&graph);
    igraph_vector_destroy(&x);
    igraph_vector_destroy(&y);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_grg_game.out0000644000175100001710000000006300000000000026613 0ustar00runnerdocker00000000000000Average distance in the geometric graph: 0.690546.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_has_multiple.c0000644000175100001710000000514500000000000027152 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_bool_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_bool_size(v); i++) {
        fprintf(f, " %i", (int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t graph;
    igraph_bool_t res;

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 1, 0, 1, 1, 0, 3, 4, 11, 10, -1);
    igraph_has_multiple(&graph, &res);
    if (!res) {
        return 1;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0, 0, 1, 2, 1, 1, 2, 2, 2, 1, 2, 3, 2, 4,
                 2, 5, 2, 6, 2, 2, 3, 2, 0, 0, 6, 2, 2, 2, 0, 0, -1);
    igraph_has_multiple(&graph, &res);
    if (!res) {
        return 2;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 1, 1, 0, 3, 4, 11, 10, -1);
    igraph_has_multiple(&graph, &res);
    if (res) {
        return 3;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0, 0, 1, 2, 1, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 2, -1);
    igraph_has_multiple(&graph, &res);
    if (!res) {
        return 4;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0, 0, 1, 2, 1, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, -1);
    igraph_has_multiple(&graph, &res);
    if (res) {
        return 5;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, 0, 1, 1, 2, -1);
    igraph_has_multiple(&graph, &res);
    if (!res) {
        return 6;
    }
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 0, 0, 0, -1);
    igraph_has_multiple(&graph, &res);
    if (!res) {
        return 7;
    }
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_independent_sets.c0000644000175100001710000000527100000000000030017 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

void print_vector(igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    for (i = 0; i < n; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

void warning_handler_ignore(const char* reason, const char* file, int line, int e) {
}

int main() {

    igraph_t g;
    igraph_vector_ptr_t result;
    long int i, j, n;
    igraph_integer_t alpha;
    const int params[] = {4, -1, 2, 2, 0, 0, -1, -1};

    igraph_set_warning_handler(warning_handler_ignore);
    igraph_vector_ptr_init(&result, 0);

    igraph_tree(&g, 5, 2, IGRAPH_TREE_OUT);
    for (j = 0; j < sizeof(params) / (2 * sizeof(params[0])); j++) {
        if (params[2 * j + 1] != 0) {
            igraph_independent_vertex_sets(&g, &result, params[2 * j], params[2 * j + 1]);
        } else {
            igraph_largest_independent_vertex_sets(&g, &result);
        }
        n = igraph_vector_ptr_size(&result);
        printf("%ld independent sets found\n", (long)n);
        for (i = 0; i < n; i++) {
            igraph_vector_t* v;
            v = igraph_vector_ptr_e(&result, i);
            print_vector((igraph_vector_t*)v);
            igraph_vector_destroy(v);
            igraph_free(v);
        }
    }
    igraph_destroy(&g);

    igraph_tree(&g, 10, 2, IGRAPH_TREE_OUT);
    igraph_maximal_independent_vertex_sets(&g, &result);
    n = igraph_vector_ptr_size(&result);
    printf("%ld maximal independent sets found\n", (long)n);
    for (i = 0; i < n; i++) {
        igraph_vector_t* v;
        v = igraph_vector_ptr_e(&result, i);
        print_vector((igraph_vector_t*)v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
    igraph_vector_ptr_destroy(&result);

    igraph_independence_number(&g, &alpha);
    printf("alpha=%ld\n", (long)alpha);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_independent_sets.out0000644000175100001710000000052400000000000030400 0ustar00runnerdocker000000000000000 independent sets found
6 independent sets found
 0 3
 0 4
 1 2
 2 3
 2 4
 3 4
2 independent sets found
 0 3 4
 2 3 4
13 independent sets found
 0
 1
 2
 3
 4
 0 3
 0 4
 1 2
 2 3
 2 4
 3 4
 0 3 4
 2 3 4
9 maximal independent sets found
 0 3 4 5 6
 0 3 5 6 9
 0 4 5 6 7 8
 0 5 6 7 8 9
 1 2 7 8 9
 1 5 6 7 8 9
 2 3 4
 2 3 9
 2 4 7 8
alpha=6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_intersection.c0000644000175100001710000000764300000000000027177 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v) {
    long int i, l = igraph_vector_size(v);
    for (i = 0; i < l; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int main() {

    igraph_t left, right, isec;
    igraph_vector_t v;
    igraph_vector_ptr_t glist;
    igraph_t g1, g2, g3;
    igraph_vector_t edge_map1, edge_map2;

    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, -1);
    igraph_create(&left, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 1, 0, 5, 4, 1, 2, 3, 2, -1);
    igraph_create(&right, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init(&edge_map1, 0);
    igraph_vector_init(&edge_map2, 0);

    igraph_intersection(&isec, &left, &right, &edge_map1, &edge_map2);
    igraph_vector_init(&v, 0);
    igraph_get_edgelist(&isec, &v, 0);
    printf("---\n");
    print_vector(&v);
    print_vector(&edge_map1);
    print_vector(&edge_map2);
    printf("---\n");
    igraph_vector_destroy(&v);
    igraph_destroy(&left);
    igraph_destroy(&right);
    igraph_destroy(&isec);
    igraph_vector_destroy(&edge_map1);
    igraph_vector_destroy(&edge_map2);

    /* empty graph list */
    igraph_vector_ptr_init(&glist, 0);
    igraph_intersection_many(&isec, &glist, 0);
    if (igraph_vcount(&isec) != 0 || !igraph_is_directed(&isec)) {
        return 1;
    }
    igraph_destroy(&isec);
    igraph_vector_ptr_destroy(&glist);

    /* graph list with an empty graph */
    igraph_vector_ptr_init(&glist, 3);
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, -1);
    igraph_create(&g1, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, -1);
    igraph_create(&g2, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);
    igraph_empty(&g3, 10, IGRAPH_DIRECTED);

    VECTOR(glist)[0] = &g1;
    VECTOR(glist)[1] = &g2;
    VECTOR(glist)[2] = &g3;
    igraph_intersection_many(&isec, &glist, 0);
    if (igraph_ecount(&isec) != 0 || igraph_vcount(&isec) != 10) {
        return 2;
    }
    igraph_destroy(&g1);
    igraph_destroy(&g2);
    igraph_destroy(&g3);
    igraph_destroy(&isec);
    igraph_vector_ptr_destroy(&glist);

    /* "proper" graph list */
    igraph_vector_ptr_init(&glist, 3);
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, -1);
    igraph_create(&g1, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);
    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 3, 3, 2, 4, 5, 6, 5, -1);
    igraph_create(&g2, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);
    igraph_vector_init_int_end(&v, -1, 2, 3, 1, 0, 1, 2, 3, 2, 4, 5, 6, 5, 2, 3, -1);
    igraph_create(&g3, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    VECTOR(glist)[0] = &g1;
    VECTOR(glist)[1] = &g2;
    VECTOR(glist)[2] = &g3;
    igraph_intersection_many(&isec, &glist, 0);
    igraph_write_graph_edgelist(&isec, stdout);
    igraph_destroy(&g1);
    igraph_destroy(&g2);
    igraph_destroy(&g3);
    igraph_destroy(&isec);
    igraph_vector_ptr_destroy(&glist);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_intersection.out0000644000175100001710000000003300000000000027546 0ustar00runnerdocker00000000000000---
 1 2
 1
 2
---
1 2
2 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_directed.c0000644000175100001710000000221700000000000026737 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;

    igraph_empty(&g, 0, 0);
    if (igraph_is_directed(&g)) {
        return 1;
    }
    igraph_destroy(&g);

    igraph_empty(&g, 0, 1);
    if (!igraph_is_directed(&g)) {
        return 2;
    }
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_loop.c0000644000175100001710000000327700000000000026134 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_bool_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_bool_size(v); i++) {
        fprintf(f, " %i", (int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t graph;
    igraph_vector_bool_t v;

    igraph_vector_bool_init(&v, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 1, 0, 1, 1, 0, 3, 4, 11, 10, -1);
    igraph_is_loop(&graph, &v, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector(&v, stdout);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0, 0, 1, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 2, 0, 0, -1);
    igraph_is_loop(&graph, &v, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector(&v, stdout);
    igraph_destroy(&graph);

    igraph_vector_bool_destroy(&v);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_loop.out0000644000175100001710000000004200000000000026504 0ustar00runnerdocker00000000000000 0 0 0 0 0 0 0
 1 1 1 0 0 0 0 1 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_minimal_separator.c0000644000175100001710000000431300000000000030661 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define FAIL(msg, error) do { printf(msg "\n") ; return error; } while (0)

int main() {

    igraph_t graph;
    igraph_vector_t sep;
    igraph_bool_t result;

    /* Simple star graph, remove the center */
    igraph_star(&graph, 10, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_is_minimal_separator(&graph, igraph_vss_1(0), &result);
    if (!result) {
        FAIL("Center of star graph failed.", 1);
    }

    /* Same graph, but another vertex */
    igraph_is_minimal_separator(&graph, igraph_vss_1(6), &result);
    if (result) {
        FAIL("Non-center of star graph failed.", 2);
    }
    igraph_destroy(&graph);

    /* Karate club */
    igraph_famous(&graph, "zachary");
    igraph_vector_init(&sep, 0);
    igraph_vector_push_back(&sep, 32);
    igraph_vector_push_back(&sep, 33);
    igraph_is_minimal_separator(&graph, igraph_vss_vector(&sep), &result);
    if (!result) {
        FAIL("Karate network (32,33) failed", 3);
    }

    igraph_vector_resize(&sep, 5);
    VECTOR(sep)[0] = 8;
    VECTOR(sep)[1] = 9;
    VECTOR(sep)[2] = 19;
    VECTOR(sep)[3] = 30;
    VECTOR(sep)[4] = 31;
    igraph_is_minimal_separator(&graph, igraph_vss_vector(&sep), &result);
    if (result) {
        FAIL("Karate network (8,9,19,30,31) failed", 4);
    }

    igraph_destroy(&graph);
    igraph_vector_destroy(&sep);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_multiple.c0000644000175100001710000000337400000000000027014 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_bool_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_bool_size(v); i++) {
        fprintf(f, " %i", (int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t graph;
    igraph_vector_bool_t v;

    igraph_vector_bool_init(&v, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 1, 0, 1, 1, 0, 3, 4, 11, 10, -1);
    igraph_is_multiple(&graph, &v, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector(&v, stdout);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0, 0, 1, 2, 1, 1, 2, 2, 2, 1, 2, 3, 2, 4,
                 2, 5, 2, 6, 2, 2, 3, 2, 0, 0, 6, 2, 2, 2, 0, 0, -1);
    igraph_is_multiple(&graph, &v, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector(&v, stdout);
    igraph_destroy(&graph);

    igraph_vector_bool_destroy(&v);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_multiple.out0000644000175100001710000000005600000000000027373 0ustar00runnerdocker00000000000000 0 0 0 1 0 0 0
 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_is_separator.c0000644000175100001710000000511000000000000027147 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define FAIL(msg, error) do { printf(msg "\n") ; return error; } while (0)

int main() {

    igraph_t graph;
    igraph_vector_t sep;
    igraph_bool_t result;

    /* Simple star graph, remove the center */
    igraph_star(&graph, 10, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_is_separator(&graph, igraph_vss_1(0), &result);
    if (!result) {
        FAIL("Center of star graph failed.", 1);
    }

    /* Same graph, but another vertex */
    igraph_is_separator(&graph, igraph_vss_1(6), &result);
    if (result) {
        FAIL("Non-center of star graph failed.", 2);
    }

    /* Same graph, all vertices but the center */
    igraph_is_separator(&graph, igraph_vss_seq(1, 9), &result);
    if (result) {
        FAIL("All non-central vertices of star graph failed.", 5);
    }
    igraph_destroy(&graph);

    /* Same graph, all vertices */
    igraph_is_separator(&graph, igraph_vss_seq(0, 9), &result);
    if (result) {
        FAIL("All vertices of star graph failed.", 6);
    }
    igraph_destroy(&graph);

    /* Karate club */
    igraph_famous(&graph, "zachary");
    igraph_vector_init(&sep, 0);
    igraph_vector_push_back(&sep, 32);
    igraph_vector_push_back(&sep, 33);
    igraph_is_separator(&graph, igraph_vss_vector(&sep), &result);
    if (!result) {
        FAIL("Karate network (32,33) failed", 3);
    }

    igraph_vector_resize(&sep, 5);
    VECTOR(sep)[0] = 8;
    VECTOR(sep)[1] = 9;
    VECTOR(sep)[2] = 19;
    VECTOR(sep)[3] = 30;
    VECTOR(sep)[4] = 31;
    igraph_is_separator(&graph, igraph_vss_vector(&sep), &result);
    if (result) {
        FAIL("Karate network (8,9,19,30,31) failed", 4);
    }

    igraph_destroy(&graph);
    igraph_vector_destroy(&sep);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_isomorphic_vf2.c0000644000175100001710000002340500000000000027414 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

int main() {

    igraph_t ring1, ring2;
    igraph_vector_int_t color1, color2;
    igraph_vector_t perm;
    igraph_bool_t iso;
    igraph_integer_t count;
    long int i;

    igraph_rng_seed(igraph_rng_default(), 12345);

    igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/1);
    igraph_vector_init_seq(&perm, 0, igraph_vcount(&ring1) - 1);
    igraph_vector_shuffle(&perm);
    igraph_permute_vertices(&ring1, &ring2, &perm);

    /* Without colors */
    igraph_isomorphic(&ring1, &ring2, &iso);
    if (!iso) {
        fprintf(stderr, "Without color failed.\n");
        return 1;
    }

    /* Without colors, number of isomorphisms */
    igraph_count_isomorphisms_vf2(&ring1, &ring2, 0, 0, 0, 0, &count, 0, 0, 0);
    if (count != 200) {
        fprintf(stderr, "Count without colors failed, expected %li, got %li.\n",
                (long int) 200, (long int) count);
        return 2;
    }

    /* Everything has the same colors */
    igraph_vector_int_init(&color1, igraph_vcount(&ring1));
    igraph_vector_int_init(&color2, igraph_vcount(&ring2));
    igraph_isomorphic_vf2(&ring1, &ring2, &color1, &color2, 0, 0, &iso, 0, 0, 0, 0, 0);
    if (!iso) {
        fprintf(stderr, "Single color failed.\n");
        return 3;
    }

    /* Two colors, just counting */
    for (i = 0; i < igraph_vector_int_size(&color1); i += 2) {
        VECTOR(color1)[i] = VECTOR(color2)[(long int)VECTOR(perm)[i]] = 1;
    }
    igraph_count_isomorphisms_vf2(&ring1, &ring2, &color1, &color2, 0, 0, &count, 0, 0, 0);
    if (count != 100) {
        fprintf(stderr, "Count with two colors failed, expected %li, got %li.\n",
                (long int) 100, (long int) count);
        return 4;
    }

    /* Separate colors for each vertex */
    for (i = 0; i < igraph_vector_int_size(&color1); i++) {
        VECTOR(color1)[i] = VECTOR(color2)[(long int)VECTOR(perm)[i]] = i;
    }
    igraph_count_isomorphisms_vf2(&ring1, &ring2, &color1, &color2, 0, 0, &count, 0, 0, 0);
    if (count != 1) {
        fprintf(stderr, "Count with separate colors failed, expected %li, got %li.\n",
                (long int) 1, (long int) count);
        return 5;
    }

    /* Try a negative result */
    igraph_vector_int_fill(&color1, 0);
    igraph_vector_int_fill(&color2, 0);
    VECTOR(color1)[0] = 1;
    igraph_isomorphic_vf2(&ring1, &ring2, &color1, &color2, 0, 0, &iso, 0, 0, 0, 0, 0);
    if (iso) {
        fprintf(stderr, "Negative test failed.\n");
        return 6;
    }

    /* Another negative, same color distribution, different topology */
    igraph_vector_int_fill(&color1, 0);
    igraph_vector_int_fill(&color2, 0);
    VECTOR(color1)[0] = 1;
    VECTOR(color1)[1] = 1;
    VECTOR(color2)[0] = 1;
    VECTOR(color2)[((long int)VECTOR(perm)[1] + 1) % igraph_vcount(&ring2)] = 1;
    igraph_isomorphic_vf2(&ring1, &ring2, &color1, &color2, 0, 0, &iso, 0, 0, 0, 0, 0);
    if (iso) {
        fprintf(stderr, "Second negative test failed.\n");
        return 7;
    }

    igraph_vector_int_destroy(&color1);
    igraph_vector_int_destroy(&color2);

    igraph_vector_destroy(&perm);
    igraph_destroy(&ring2);
    igraph_destroy(&ring1);

    /* ---------------------------------------------------------------- */
    /* SUBGRAPH ISOMORPHISM                                             */
    /* ---------------------------------------------------------------- */

    igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/0);
    igraph_ring(&ring2, 80, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/0);

    /* One color */
    igraph_vector_int_init(&color1, igraph_vcount(&ring1));
    igraph_vector_int_init(&color2, igraph_vcount(&ring2));
    igraph_count_subisomorphisms_vf2(&ring1, &ring2, &color1, &color2, 0, 0,
                                     &count, 0, 0, 0);
    if (count != 42) {
        fprintf(stderr, "Count with one color failed, expected %li, got %li.\n",
                (long int) 42, (long int) count);
        return 31;
    }

    /* Two colors */
    for (i = 0; i < igraph_vector_int_size(&color1); i += 2) {
        VECTOR(color1)[i]   = 0;
        VECTOR(color1)[i + 1] = 1;
    }
    for (i = 0; i < igraph_vector_int_size(&color2); i += 2) {
        VECTOR(color2)[i]   = 0;
        VECTOR(color2)[i + 1] = 1;
    }
    igraph_count_subisomorphisms_vf2(&ring1, &ring2, &color1, &color2, 0, 0,
                                     &count, 0, 0, 0);
    if (count != 21) {
        fprintf(stderr, "Count with two colors failed, expected %li, got %li.\n",
                (long int) 21, (long int) count);
        return 32;
    }

    igraph_vector_int_destroy(&color1);
    igraph_vector_int_destroy(&color2);

    igraph_destroy(&ring1);
    igraph_destroy(&ring2);

    /* ---------------------------------------------------------------- */
    /* EDGE COLORING, GRAPH ISOMORPHISM                                 */
    /* ---------------------------------------------------------------- */

    igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_vector_init_seq(&perm, 0, igraph_ecount(&ring1) - 1);
    igraph_vector_shuffle(&perm);
    igraph_permute_vertices(&ring1, &ring2, &perm);
    igraph_vector_destroy(&perm);

    /* Everything has the same color */
    igraph_vector_int_init(&color1, igraph_ecount(&ring1));
    igraph_vector_int_init(&color2, igraph_ecount(&ring2));
    igraph_isomorphic_vf2(&ring1, &ring2, 0, 0, &color1, &color2, &iso, 0, 0, 0, 0, 0);
    if (!iso) {
        fprintf(stderr, "Single edge-color failed.\n");
        return 41;
    }

    /* Two colors, just counting */
    for (i = 0; i < igraph_vector_int_size(&color1); i += 2) {
        VECTOR(color1)[i]   = VECTOR(color2)[i] = 0;
        VECTOR(color1)[i + 1] = VECTOR(color2)[i] = 1;
    }
    igraph_count_isomorphisms_vf2(&ring1, &ring2, 0, 0, &color1, &color2, &count, 0, 0, 0);
    if (count != 100) {
        fprintf(stderr, "Count with two edge colors failed, expected %li, got %li.\n",
                (long int) 100, (long int) count);
        return 42;
    }

    /* Separate colors for each edge */
    for (i = 0; i < igraph_vector_int_size(&color1); i++) {
        VECTOR(color1)[i]   = VECTOR(color2)[i] = i;
    }
    igraph_count_isomorphisms_vf2(&ring1, &ring2, 0, 0, &color1, &color2, &count, 0, 0, 0);
    if (count != 1) {
        fprintf(stderr, "Count with separate edge colors failed, expected %li, got %li.\n",
                (long int) 1, (long int) count);
        return 43;
    }

    /* Try a negative result */
    igraph_vector_int_fill(&color1, 0);
    igraph_vector_int_fill(&color2, 0);
    VECTOR(color1)[0] = 1;
    igraph_isomorphic_vf2(&ring1, &ring2, 0, 0, &color1, &color2, &iso, 0, 0, 0, 0, 0);
    if (iso) {
        fprintf(stderr, "Negative edge test failed.\n");
        return 44;
    }

    /* Another negative, same color distribution, different topology */
    igraph_vector_int_fill(&color1, 0);
    igraph_vector_int_fill(&color2, 0);
    VECTOR(color1)[0] = 1;
    VECTOR(color1)[1] = 1;
    VECTOR(color2)[0] = 1;
    VECTOR(color2)[2] = 1;
    igraph_isomorphic_vf2(&ring1, &ring2, 0, 0, &color1, &color2, &iso, 0, 0, 0, 0, 0);
    if (iso) {
        fprintf(stderr, "Second negative edge test failed.\n");
        return 45;
    }

    igraph_vector_int_destroy(&color1);
    igraph_vector_int_destroy(&color2);

    igraph_destroy(&ring1);
    igraph_destroy(&ring2);

    /* ---------------------------------------------------------------- */
    /* EDGE COLORED SUBGRAPH ISOMORPHISM                                */
    /* ---------------------------------------------------------------- */

    igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/0);
    igraph_ring(&ring2, 80, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/0);

    /* One color */
    igraph_vector_int_init(&color1, igraph_ecount(&ring1));
    igraph_vector_int_init(&color2, igraph_ecount(&ring2));
    igraph_count_subisomorphisms_vf2(&ring1, &ring2, 0, 0, &color1, &color2,
                                     &count, 0, 0, 0);
    if (count != 42) {
        fprintf(stderr, "Count with one edge color failed, expected %li, got %li.\n",
                (long int) 42, (long int) count);
        return 51;
    }

    /* Two colors */
    for (i = 0; i < igraph_vector_int_size(&color1) - 1; i += 2) {
        VECTOR(color1)[i]   = 0;
        VECTOR(color1)[i + 1] = 1;
    }
    for (i = 0; i < igraph_vector_int_size(&color2) - 1; i += 2) {
        VECTOR(color2)[i]   = 0;
        VECTOR(color2)[i + 1] = 1;
    }
    igraph_count_subisomorphisms_vf2(&ring1, &ring2, 0, 0, &color1, &color2,
                                     &count, 0, 0, 0);
    if (count != 22) {
        fprintf(stderr, "Count with two edge colors failed, expected %li, got %li.\n",
                (long int) 22, (long int) count);
        return 52;
    }

    igraph_vector_int_destroy(&color1);
    igraph_vector_int_destroy(&color2);

    igraph_destroy(&ring1);
    igraph_destroy(&ring2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_knn.c0000644000175100001710000000430400000000000025246 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_t g;
    igraph_vector_t v, v2;
    igraph_vector_t v_weighted, v2_weighted;
    igraph_integer_t n;
    igraph_neimode_t mode, neighbour_degree_mode;

    mode = IGRAPH_IN;
    neighbour_degree_mode = IGRAPH_OUT;

    igraph_ring(&g, 10, /*directed=*/ 1, /*mutual=*/ 0, /*circular=*/ 1);
    n = igraph_vcount(&g);
    igraph_vector_init(&v, (long int)n);
    igraph_vector_init(&v2, (long int)n);
    igraph_avg_nearest_neighbor_degree(&g, igraph_vss_all(),
                                       mode, neighbour_degree_mode,
                                       &v, &v2, /*weights=*/ 0);

    igraph_vector_t weights;
    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 2.0);

    igraph_vector_init(&v_weighted, (long int)n);
    igraph_vector_init(&v2_weighted, (long int)n);
    igraph_avg_nearest_neighbor_degree(&g, igraph_vss_all(),
                                       mode, neighbour_degree_mode,
                                       &v_weighted, &v2_weighted, &weights);

    if (!igraph_vector_all_e(&v, &v_weighted)) {
        return 1;
    }

    igraph_vector_destroy(&v_weighted);
    igraph_vector_destroy(&v2_weighted);

    igraph_vector_destroy(&weights);

    igraph_vector_destroy(&v);
    igraph_vector_destroy(&v2);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_lapack_dgeev.c0000644000175100001710000001755600000000000027102 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define DIM 10

int real_cplx_mult(const igraph_matrix_t *A,
                   const igraph_vector_t *v_real,
                   const igraph_vector_t *v_imag,
                   igraph_vector_t *res_real,
                   igraph_vector_t *res_imag) {

    int n = igraph_vector_size(v_real);
    int r, c;

    if (igraph_matrix_nrow(A) != n ||
        igraph_matrix_ncol(A) != n ||
        igraph_vector_size(v_imag) != n) {
        printf("Wrong matrix or vector size");
        return 1;
    }

    igraph_vector_resize(res_real, n);
    igraph_vector_resize(res_imag, n);

    for (r = 0; r < n; r++) {
        igraph_real_t s_real = 0.0;
        igraph_real_t s_imag = 0.0;
        for (c = 0; c < n; c++) {
            s_real += MATRIX(*A, r, c) * VECTOR(*v_real)[c];
            s_imag += MATRIX(*A, r, c) * VECTOR(*v_imag)[c];
        }
        VECTOR(*res_real)[r] = s_real;
        VECTOR(*res_imag)[r] = s_imag;
    }

    return 0;
}

int sc_cplx_cplx_mult(igraph_real_t lambda_real,
                      igraph_real_t lambda_imag,
                      const igraph_vector_t *v_real,
                      const igraph_vector_t *v_imag,
                      igraph_vector_t *res_real,
                      igraph_vector_t *res_imag) {

    int r;
    int n = igraph_vector_size(v_real);

    if (igraph_vector_size(v_imag) != n) {
        printf("Wrong vector sizes");
        return 1;
    }

    igraph_vector_resize(res_real, n);
    igraph_vector_resize(res_imag, n);

    for (r = 0; r < n; r++) {
        VECTOR(*res_real)[r] = (lambda_real * VECTOR(*v_real)[r] -
                                lambda_imag * VECTOR(*v_imag)[r]);
        VECTOR(*res_imag)[r] = (lambda_imag * VECTOR(*v_real)[r] +
                                lambda_real * VECTOR(*v_imag)[r]);
    }

    return 0;
}

igraph_bool_t check_ev(const igraph_matrix_t *A,
                       const igraph_vector_t *values_real,
                       const igraph_vector_t *values_imag,
                       const igraph_matrix_t *vectors_left,
                       const igraph_matrix_t *vectors_right,
                       igraph_real_t tol) {

    int i, n = igraph_matrix_nrow(A);
    igraph_vector_t v_real, v_imag;
    igraph_vector_t AV_real, AV_imag, lv_real, lv_imag;
    igraph_vector_t null;

    if (igraph_matrix_ncol(A)             != n) {
        return 1;
    }
    if (igraph_vector_size(values_real)   != n) {
        return 1;
    }
    if (igraph_vector_size(values_imag)   != n) {
        return 1;
    }
    if (igraph_matrix_nrow(vectors_left)  != n) {
        return 1;
    }
    if (igraph_matrix_ncol(vectors_left)  != n) {
        return 1;
    }
    if (igraph_matrix_nrow(vectors_right) != n) {
        return 1;
    }
    if (igraph_matrix_ncol(vectors_right) != n) {
        return 1;
    }

    igraph_vector_init(&AV_real, n);
    igraph_vector_init(&AV_imag, n);
    igraph_vector_init(&lv_real, n);
    igraph_vector_init(&lv_imag, n);
    igraph_vector_init(&null, n);
    igraph_vector_null(&null);

    for (i = 0; i < n; i++) {
        if (VECTOR(*values_imag)[i] == 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_view(&v_imag, VECTOR(null), n);
        } else if (VECTOR(*values_imag)[i] > 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i + 1), n);
        } else if (VECTOR(*values_imag)[i] < 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i - 1), n);
            igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_scale(&v_imag, -1.0);
        }
        real_cplx_mult(A, &v_real, &v_imag, &AV_real, &AV_imag);
        sc_cplx_cplx_mult(VECTOR(*values_real)[i], VECTOR(*values_imag)[i],
                          &v_real, &v_imag, &lv_real, &lv_imag);

        if (igraph_vector_maxdifference(&AV_real, &lv_real) > tol ||
            igraph_vector_maxdifference(&AV_imag, &lv_imag) > tol) {
            printf("ERROR:\n");
            igraph_vector_print(&AV_real);
            igraph_vector_print(&AV_imag);
            igraph_vector_print(&lv_real);
            igraph_vector_print(&lv_imag);
            return 1;
        }
    }

    igraph_vector_destroy(&null);
    igraph_vector_destroy(&AV_imag);
    igraph_vector_destroy(&AV_real);
    igraph_vector_destroy(&lv_imag);
    igraph_vector_destroy(&lv_real);

    return 0;
}

int main() {

    igraph_matrix_t A;
    igraph_matrix_t vectors_left, vectors_right;
    igraph_vector_t values_real, values_imag;
    int i, j;
    int info = 1;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&vectors_left, 0, 0);
    igraph_matrix_init(&vectors_right, 0, 0);
    igraph_vector_init(&values_real, 0);
    igraph_vector_init(&values_imag, 0);

    for (i = 0; i < DIM; i++) {
        for (j = 0; j < DIM; j++) {
            MATRIX(A, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    igraph_lapack_dgeev(&A, &values_real, &values_imag,
                        &vectors_left, &vectors_right, &info);

    if (check_ev(&A, &values_real, &values_imag,
                 &vectors_left, &vectors_right, /*tol=*/ 1e-8)) {
        return 1;
    }

    /* ------------------------------------------------------- */

    /* igraph_matrix_resize(&A, 10, 10); */
    /* igraph_matrix_null(&A); */
    /* for (i=0; i<10; i++) { MATRIX(A, i, i) = 1.0; }  */
    /* MATRIX(A,0,1) = 1.0; */

    /* igraph_lapack_dgeev(&A, &values_real, &values_imag,  */
    /*              &vectors_left, &vectors_right, &info);   */

    /* if (check_ev(&A, &values_real, &values_imag, */
    /*           &vectors_left, &vectors_right, /\*tol=*\/ 1e-8)) { */
    /*   return 2; */
    /* } */

    /* ------------------------------------------------------- */

    igraph_matrix_resize(&A, 10, 10);
    igraph_matrix_null(&A);
    MATRIX(A, 0, 1) = MATRIX(A, 0, 2) = MATRIX(A, 0, 3) = 1 / 3.0;
    MATRIX(A, 1, 0) = MATRIX(A, 1, 4) = MATRIX(A, 1, 5) = MATRIX(A, 1, 6) = 1 / 4.0;
    MATRIX(A, 2, 0) = MATRIX(A, 2, 7) = MATRIX(A, 2, 8) = MATRIX(A, 2, 9) = 1 / 4.0;
    MATRIX(A, 3, 0) = 1.0;
    MATRIX(A, 4, 1) = 1.0;
    MATRIX(A, 5, 1) = 1.0;
    MATRIX(A, 6, 1) = 1.0;
    MATRIX(A, 7, 2) = 1.0;
    MATRIX(A, 8, 2) = 1.0;
    MATRIX(A, 9, 2) = 1.0;

    info = 0;
    igraph_lapack_dgeev(&A, &values_real, &values_imag,
                        &vectors_left, &vectors_right, &info);

    /* igraph_matrix_print(&A); */
    /* printf("---\n"); */
    /* igraph_vector_print(&values_real); */
    /* igraph_vector_print(&values_imag); */
    /* igraph_matrix_print(&vectors_left); */

    if (check_ev(&A, &values_real, &values_imag,
                 &vectors_left, &vectors_right, /*tol=*/ 1e-8)) {
        return 3;
    }

    igraph_vector_destroy(&values_imag);
    igraph_vector_destroy(&values_real);
    igraph_matrix_destroy(&vectors_right);
    igraph_matrix_destroy(&vectors_left);
    igraph_matrix_destroy(&A);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_lapack_dgeevx.c0000644000175100001710000001536600000000000027267 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define DIM 10

int real_cplx_mult(const igraph_matrix_t *A,
                   const igraph_vector_t *v_real,
                   const igraph_vector_t *v_imag,
                   igraph_vector_t *res_real,
                   igraph_vector_t *res_imag) {

    int n = igraph_vector_size(v_real);
    int r, c;

    if (igraph_matrix_nrow(A) != n ||
        igraph_matrix_ncol(A) != n ||
        igraph_vector_size(v_imag) != n) {
        printf("Wrong matrix or vector size");
        return 1;
    }

    igraph_vector_resize(res_real, n);
    igraph_vector_resize(res_imag, n);

    for (r = 0; r < n; r++) {
        igraph_real_t s_real = 0.0;
        igraph_real_t s_imag = 0.0;
        for (c = 0; c < n; c++) {
            s_real += MATRIX(*A, r, c) * VECTOR(*v_real)[c];
            s_imag += MATRIX(*A, r, c) * VECTOR(*v_imag)[c];
        }
        VECTOR(*res_real)[r] = s_real;
        VECTOR(*res_imag)[r] = s_imag;
    }

    return 0;
}

int sc_cplx_cplx_mult(igraph_real_t lambda_real,
                      igraph_real_t lambda_imag,
                      const igraph_vector_t *v_real,
                      const igraph_vector_t *v_imag,
                      igraph_vector_t *res_real,
                      igraph_vector_t *res_imag) {

    int r;
    int n = igraph_vector_size(v_real);

    if (igraph_vector_size(v_imag) != n) {
        printf("Wrong vector sizes");
        return 1;
    }

    igraph_vector_resize(res_real, n);
    igraph_vector_resize(res_imag, n);

    for (r = 0; r < n; r++) {
        VECTOR(*res_real)[r] = (lambda_real * VECTOR(*v_real)[r] -
                                lambda_imag * VECTOR(*v_imag)[r]);
        VECTOR(*res_imag)[r] = (lambda_imag * VECTOR(*v_real)[r] +
                                lambda_real * VECTOR(*v_imag)[r]);
    }

    return 0;
}

igraph_bool_t check_ev(const igraph_matrix_t *A,
                       const igraph_vector_t *values_real,
                       const igraph_vector_t *values_imag,
                       const igraph_matrix_t *vectors_left,
                       const igraph_matrix_t *vectors_right,
                       igraph_real_t tol) {

    int n = igraph_matrix_nrow(A);
    igraph_vector_t v_real, v_imag;
    igraph_vector_t AV_real, AV_imag, lv_real, lv_imag;
    igraph_vector_t null;
    int i;

    if (igraph_matrix_ncol(A)             != n) {
        return 1;
    }
    if (igraph_vector_size(values_real)   != n) {
        return 1;
    }
    if (igraph_vector_size(values_imag)   != n) {
        return 1;
    }
    if (igraph_matrix_nrow(vectors_left)  != n) {
        return 1;
    }
    if (igraph_matrix_ncol(vectors_left)  != n) {
        return 1;
    }
    if (igraph_matrix_nrow(vectors_right) != n) {
        return 1;
    }
    if (igraph_matrix_ncol(vectors_right) != n) {
        return 1;
    }

    igraph_vector_init(&AV_real, n);
    igraph_vector_init(&AV_imag, n);
    igraph_vector_init(&lv_real, n);
    igraph_vector_init(&lv_imag, n);
    igraph_vector_init(&null, n);
    igraph_vector_null(&null);

    for (i = 0; i < n; i++) {
        if (VECTOR(*values_imag)[i] == 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_view(&v_imag, VECTOR(null), n);
        } else if (VECTOR(*values_imag)[i] > 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i + 1), n);
        } else if (VECTOR(*values_imag)[i] < 0.0) {
            igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i - 1), n);
            igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i), n);
            igraph_vector_scale(&v_imag, -1.0);
        }
        real_cplx_mult(A, &v_real, &v_imag, &AV_real, &AV_imag);
        sc_cplx_cplx_mult(VECTOR(*values_real)[i], VECTOR(*values_imag)[i],
                          &v_real, &v_imag, &lv_real, &lv_imag);

        if (igraph_vector_maxdifference(&AV_real, &lv_real) > tol ||
            igraph_vector_maxdifference(&AV_imag, &lv_imag) > tol) {
            igraph_vector_print(&AV_real);
            igraph_vector_print(&AV_imag);
            igraph_vector_print(&lv_real);
            igraph_vector_print(&lv_imag);
            return 1;
        }
    }

    igraph_vector_destroy(&null);
    igraph_vector_destroy(&AV_imag);
    igraph_vector_destroy(&AV_real);
    igraph_vector_destroy(&lv_imag);
    igraph_vector_destroy(&lv_real);

    return 0;
}

int main() {

    igraph_matrix_t A;
    igraph_matrix_t vectors_left, vectors_right;
    igraph_vector_t values_real, values_imag;
    int i, j;
    int info = 1;
    int ilo, ihi;
    igraph_real_t abnrm;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&vectors_left, 0, 0);
    igraph_matrix_init(&vectors_right, 0, 0);
    igraph_vector_init(&values_real, 0);
    igraph_vector_init(&values_imag, 0);

    for (i = 0; i < DIM; i++) {
        for (j = 0; j < DIM; j++) {
            MATRIX(A, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    igraph_lapack_dgeevx(IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH,
                         &A, &values_real, &values_imag,
                         &vectors_left, &vectors_right, &ilo, &ihi,
                         /*scale=*/ 0, &abnrm, /*rconde=*/ 0,
                         /*rcondv=*/ 0, &info);

    if (check_ev(&A, &values_real, &values_imag,
                 &vectors_left, &vectors_right, /*tol=*/ 1e-8)) {
        return 1;
    }

    /* igraph_matrix_print(&A); */
    /* igraph_vector_print(&values_real); */
    /* igraph_vector_print(&values_imag); */
    /* igraph_matrix_print(&vectors_left); */
    /* igraph_matrix_print(&vectors_right); */

    igraph_vector_destroy(&values_imag);
    igraph_vector_destroy(&values_real);
    igraph_matrix_destroy(&vectors_right);
    igraph_matrix_destroy(&vectors_left);
    igraph_matrix_destroy(&A);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_lapack_dgesv.c0000644000175100001710000001014200000000000027100 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#define DIM 10

void igraph_print_warning(const char *reason, const char *file,
                          int line, int igraph_errno) {
    printf("Warning: %s\n", reason);
}

int main() {

    igraph_matrix_t A, B, RHS;
    int info;
    int i, j;

    /* Identity matrix, you have to start somewhere */

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&B, DIM, 1);
    for (i = 0; i < DIM; i++) {
        MATRIX(A, i, i) = 1.0;
        MATRIX(B, i, 0) = i + 1;
    }

    igraph_matrix_copy(&RHS, &B);
    igraph_lapack_dgesv(&A, /*ipiv=*/ 0, &RHS, &info);

    if (info != 0) {
        return 1;
    }
    if (!igraph_matrix_all_e(&B, &RHS)) {
        return 2;
    }

    igraph_matrix_destroy(&A);
    igraph_matrix_destroy(&B);
    igraph_matrix_destroy(&RHS);

    /* Diagonal matrix */

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&RHS, DIM, 1);
    for (i = 0; i < DIM; i++) {
        MATRIX(A, i, i) = i + 1;
        MATRIX(RHS, i, 0) = i + 1;
    }

    igraph_lapack_dgesv(&A, /*ipiv=*/ 0, &RHS, &info);

    if (info != 0) {
        return 3;
    }
    for (i = 0; i < DIM; i++) {
        if (MATRIX(RHS, i, 0) != 1.0) {
            return 4;
        }
    }

    igraph_matrix_destroy(&A);
    igraph_matrix_destroy(&RHS);

    /* A general matrix */

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&B, DIM, 1);
    igraph_matrix_init(&RHS, DIM, 1);
    for (i = 0; i < DIM; i++) {
        int j;
        MATRIX(B, i, 0) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        for (j = 0; j < DIM; j++) {
            MATRIX(A, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }
    igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0, /*a=*/ &A,
                                           /*x-*/ &MATRIX(B, 0, 0), /*beta=*/ 0,
                                           /*y=*/ &MATRIX(RHS, 0, 0));

    igraph_lapack_dgesv(&A, /*ipiv=*/ 0, &RHS, &info);
    if (info != 0) {
        return 5;
    }
    for (i = 0; i < DIM; i++) {
        if (fabs(MATRIX(B, i, 0) - MATRIX(RHS, i, 0)) > 1e-13) {
            return 6;
        }
    }

    igraph_matrix_destroy(&A);
    igraph_matrix_destroy(&B);
    igraph_matrix_destroy(&RHS);

    /* A singular matrix */

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&B, DIM, 1);
    igraph_matrix_init(&RHS, DIM, 1);
    for (i = 0; i < DIM; i++) {
        MATRIX(B, i, 0) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        for (j = 0; j < DIM; j++) {
            MATRIX(A, i, j) = i == j ? 1 : 0;
        }
    }
    for (i = 0; i < DIM; i++) {
        MATRIX(A, DIM - 1, i) = MATRIX(A, 0, i);
    }

    igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0, /*a=*/ &A,
                                           /*x-*/ &MATRIX(B, 0, 0), /*beta=*/ 0,
                                           /*y=*/ &MATRIX(RHS, 0, 0));

    igraph_set_warning_handler(igraph_print_warning);
    igraph_lapack_dgesv(&A, /*ipiv=*/ 0, &RHS, &info);
    if (info != 10) {
        printf("LAPACK returned info = %d, should have been 10", info);
        return 7;
    }

    igraph_matrix_destroy(&A);
    igraph_matrix_destroy(&B);
    igraph_matrix_destroy(&RHS);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_lapack_dgesv.out0000644000175100001710000000005100000000000027463 0ustar00runnerdocker00000000000000Warning: LU: factor is exactly singular.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_lapack_dsyevr.c0000644000175100001710000001465600000000000027322 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#define DIM 10

igraph_bool_t check_ev(const igraph_matrix_t *A,
                       const igraph_vector_t *values,
                       const igraph_matrix_t *vectors, igraph_real_t tol) {
    igraph_vector_t v, y;
    int i, j;
    int m = igraph_matrix_ncol(vectors);
    int n = igraph_matrix_nrow(A);

    if (igraph_matrix_ncol(A) != n)       {
        return 1;
    }
    if (igraph_vector_size(values) != m)  {
        return 1;
    }
    if (igraph_matrix_nrow(vectors) != n) {
        return 1;
    }

    igraph_vector_init(&y, n);

    for (i = 0; i < m; i++) {
        igraph_vector_view(&v, &MATRIX(*vectors, 0, i), n);
        igraph_vector_update(&y, &v);
        igraph_blas_dgemv(/*transpose=*/ 0, /*alpha=*/ 1.0, A, &v,
                                         /*beta=*/ -VECTOR(*values)[i], &y);
        for (j = 0; j < n; j++) {
            if (fabs(VECTOR(y)[i]) > tol) {
                printf("Matrix:\n");
                igraph_matrix_print(A);
                printf("lambda= %g\n", VECTOR(*values)[i]);
                printf("v= ");
                igraph_vector_print(&v);
                printf("residual: ");
                igraph_vector_print(&y);
                return 1;
            }
        }
    }

    igraph_vector_destroy(&y);
    return 0;
}

int main() {

    igraph_matrix_t A;
    igraph_matrix_t vectors, vectors2;
    igraph_vector_t values, values2;
    int i, j;
    int il, iu;
    igraph_real_t vl, vu;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&vectors, 0, 0);
    igraph_vector_init(&values, 0);

    /* All eigenvalues and eigenvectors */

    for (i = 0; i < DIM; i++) {
        for (j = i; j < DIM; j++) {
            MATRIX(A, i, j) = MATRIX(A, j, i) =
                                  igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    igraph_lapack_dsyevr(&A, IGRAPH_LAPACK_DSYEV_ALL, /*vl=*/ 0, /*vu=*/ 0,
                         /*vestimate=*/ 0, /*il=*/ 0, /*iu=*/ 0,
                         /*abstol=*/ 1e-10, &values, &vectors, /*support=*/ 0);

    if (igraph_vector_size(&values) != DIM) {
        return 1;
    }
    if (igraph_matrix_nrow(&vectors) != DIM ||
        igraph_matrix_ncol(&vectors) != DIM) {
        return 2;
    }
    if (check_ev(&A, &values, &vectors, /*tol=*/ 1e-8)) {
        return 3;
    }

    /* Only a subset */

    igraph_matrix_init(&vectors2, 0, 0);
    igraph_vector_init(&values2, 0);

    il = 2;
    iu = 5;
    igraph_lapack_dsyevr(&A, IGRAPH_LAPACK_DSYEV_SELECT, /*vl=*/ 0, /*vu=*/ 0,
                         /*vestimate=*/ 0, /*il=*/ il, /*iu=*/ iu,
                         /*abstol=*/ 1e-10, &values2, &vectors2,
                         /*support=*/ 0);

    if (igraph_vector_size(&values2) != iu - il + 1) {
        return 4;
    }
    if (igraph_matrix_nrow(&vectors2) != DIM ||
        igraph_matrix_ncol(&vectors2) != iu - il + 1) {
        return 5;
    }
    for (i = 0; i < iu - il + 1; i++) {
        igraph_real_t m1 = 1.0;

        if (fabs(VECTOR(values)[il + i - 1] - VECTOR(values2)[i]) > 1e-8) {
            printf("Full:   ");
            igraph_vector_print(&values);
            printf("Subset: ");
            igraph_vector_print(&values2);
            return 6;
        }

        if (MATRIX(vectors, 0, il + i - 1) * MATRIX(vectors2, 0, i) < 0) {
            m1 = -1.0;
        } else {
            m1 = 1.0;
        }

        for (j = 0; j < DIM; j++) {
            if (fabs(MATRIX(vectors, j, il + i - 1) -
                     m1 * MATRIX(vectors2, j, i)) > 1e-8) {
                printf("Full:\n");
                igraph_matrix_print(&vectors);
                printf("Subset:\n");
                igraph_matrix_print(&vectors2);
                return 7;
            }
        }
    }

    igraph_vector_destroy(&values2);
    igraph_matrix_destroy(&vectors2);

    /* Subset based on an interval */

    igraph_matrix_init(&vectors2, 0, 0);
    igraph_vector_init(&values2, 0);

    il = 2;
    iu = 5;
    vl = (VECTOR(values)[il - 1] + VECTOR(values)[il - 2]) / 2.0;
    vu = (VECTOR(values)[iu] + VECTOR(values)[iu - 1]) / 2.0;

    igraph_lapack_dsyevr(&A, IGRAPH_LAPACK_DSYEV_INTERVAL, vl, vu,
                         /*vestimate=*/ iu - il + 1, /*il=*/ 0, /*iu=*/ 0,
                         /*abstol=*/ 1e-10, &values2, &vectors2,
                         /*support=*/ 0);

    if (igraph_vector_size(&values2) != iu - il + 1) {
        return 4;
    }
    if (igraph_matrix_nrow(&vectors2) != DIM ||
        igraph_matrix_ncol(&vectors2) != iu - il + 1) {
        return 5;
    }
    for (i = 0; i < iu - il + 1; i++) {
        igraph_real_t m1 = 1.0;

        if (fabs(VECTOR(values)[il + i - 1] - VECTOR(values2)[i]) > 1e-8) {
            printf("Full:   ");
            igraph_vector_print(&values);
            printf("Subset: ");
            igraph_vector_print(&values2);
            return 6;
        }

        if (MATRIX(vectors, 0, il + i - 1) * MATRIX(vectors2, 0, i) < 0) {
            m1 = -1.0;
        } else {
            m1 = 1.0;
        }

        for (j = 0; j < DIM; j++) {
            if (fabs(MATRIX(vectors, j, il + i - 1) -
                     m1 * MATRIX(vectors2, j, i)) > 1e-8) {
                printf("Full:\n");
                igraph_matrix_print(&vectors);
                printf("Subset:\n");
                igraph_matrix_print(&vectors2);
                return 7;
            }
        }
    }

    igraph_vector_destroy(&values2);
    igraph_matrix_destroy(&vectors2);

    igraph_vector_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&A);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_laplacian.c0000644000175100001710000001533600000000000026413 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

igraph_bool_t check_laplacian(igraph_t* graph, const igraph_matrix_t* matrix, const igraph_vector_t* w) {
    igraph_vector_t vec, res;
    long int i, j;

    igraph_vector_init(&vec, 0);
    igraph_vector_init(&res, igraph_vcount(graph));

    if (w) {
        igraph_strength(graph, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS, w);
    } else {
        igraph_degree(graph, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS);
    }

    for (i = 0; i < igraph_vcount(graph); i++) {
        VECTOR(vec)[i] = sqrt(VECTOR(vec)[i]);
    }

    for (i = 0; i < igraph_vcount(graph); i++) {
        for (j = 0; j < igraph_vcount(graph); j++) {
            VECTOR(res)[i] += MATRIX(*matrix, i, j) * VECTOR(vec)[j];
        }
    }

    if (igraph_vector_min(&res) > 1e-7) {
        printf("Invalid Laplacian matrix:\n");
        igraph_matrix_print(matrix);
        return 0;
    }

    igraph_vector_destroy(&vec);
    igraph_vector_destroy(&res);

    return 1;
}

int test_unnormalized_laplacian(const igraph_vector_t* w, igraph_bool_t dir) {
    igraph_t g;
    igraph_matrix_t m, m2;
    igraph_sparsemat_t sm;
    igraph_vector_t vec, *weights = NULL;
    igraph_matrix_init(&m, 1, 1);
    igraph_sparsemat_init(&sm, 0, 0, 0);

    if (w) {
        weights = (igraph_vector_t*)calloc(1, sizeof(igraph_vector_t));
        igraph_vector_copy(weights, w);
    }

    /* No loop or multiple edges */
    igraph_ring(&g, 5, dir, 0, 1);
    igraph_laplacian(&g, &m, &sm, 0, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 41;
    }
    igraph_matrix_destroy(&m2);
    igraph_matrix_print(&m);
    printf("===\n");

    /* Add some loop edges */
    igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
    igraph_add_edges(&g, &vec, 0);
    igraph_vector_destroy(&vec);
    if (weights) {
        igraph_vector_push_back(weights, 2);
        igraph_vector_push_back(weights, 2);
    }

    igraph_laplacian(&g, &m, &sm, 0, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 42;
    }
    igraph_matrix_destroy(&m2);
    igraph_matrix_print(&m);
    printf("===\n");

    /* Duplicate some edges */
    igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
    igraph_add_edges(&g, &vec, 0);
    igraph_vector_destroy(&vec);
    if (weights) {
        igraph_vector_push_back(weights, 3);
        igraph_vector_push_back(weights, 3);
    }

    igraph_laplacian(&g, &m, &sm, 0, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 43;
    }
    igraph_matrix_destroy(&m2);
    igraph_matrix_print(&m);

    igraph_destroy(&g);

    igraph_matrix_destroy(&m);
    if (weights) {
        igraph_vector_destroy(weights);
        free(weights);
    }

    igraph_sparsemat_destroy(&sm);

    return 0;
}

int test_normalized_laplacian(const igraph_vector_t *w, igraph_bool_t dir) {
    igraph_t g;
    igraph_matrix_t m, m2;
    igraph_sparsemat_t sm;
    igraph_vector_t vec, *weights = 0;
    igraph_bool_t ok = 1;
    igraph_matrix_init(&m, 1, 1);
    igraph_sparsemat_init(&sm, 0, 0, 0);

    if (w) {
        weights = (igraph_vector_t*) calloc(1, sizeof(igraph_vector_t));
        igraph_vector_copy(weights, w);
    }

    /* Undirected graph, no loop or multiple edges */
    igraph_ring(&g, 5, dir, 0, 1);
    igraph_laplacian(&g, &m, &sm, 1, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 44;
    }
    igraph_matrix_destroy(&m2);
    ok = ok && check_laplacian(&g, &m, weights);

    /* Add some loop edges */
    igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
    igraph_add_edges(&g, &vec, 0);
    igraph_vector_destroy(&vec);
    if (weights) {
        igraph_vector_push_back(weights, 2);
        igraph_vector_push_back(weights, 2);
    }

    igraph_laplacian(&g, &m, &sm, 1, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 45;
    }
    igraph_matrix_destroy(&m2);
    ok = ok && check_laplacian(&g, &m, weights);

    /* Duplicate some edges */
    igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
    igraph_add_edges(&g, &vec, 0);
    igraph_vector_destroy(&vec);
    if (weights) {
        igraph_vector_push_back(weights, 3);
        igraph_vector_push_back(weights, 3);
    }

    igraph_laplacian(&g, &m, &sm, 1, weights);
    igraph_matrix_init(&m2, 0, 0);
    igraph_sparsemat_as_matrix(&m2, &sm);
    if (!igraph_matrix_all_e_tol(&m, &m2, 0)) {
        return 46;
    }
    igraph_matrix_destroy(&m2);
    ok = ok && check_laplacian(&g, &m, weights);

    igraph_destroy(&g);

    igraph_matrix_destroy(&m);
    if (weights) {
        igraph_vector_destroy(weights);
        free(weights);
    }

    if (ok) {
        printf("OK\n");
    }

    igraph_sparsemat_destroy(&sm);

    return !ok;
}

int main() {
    int res;
    int i;
    igraph_vector_t weights;

    igraph_vector_init_real(&weights, 5, 1.0, 2.0, 3.0, 4.0, 5.0);

    for (i = 0; i < 8; i++) {
        igraph_bool_t is_normalized = i / 4;
        igraph_vector_t* v = ((i & 2) / 2 ? &weights : 0);
        igraph_bool_t dir = (i % 2 ? IGRAPH_DIRECTED : IGRAPH_UNDIRECTED);

        printf("=== %sormalized, %sweighted, %sdirected\n",
               (is_normalized ? "N" : "Unn"),
               (v != 0 ? "" : "un"),
               (dir == IGRAPH_DIRECTED ? "" : "un")
              );

        if (is_normalized) {
            res = test_normalized_laplacian(v, dir);
        } else {
            res = test_unnormalized_laplacian(v, dir);
        }

        if (res) {
            return i + 1;
        }
    }

    igraph_vector_destroy(&weights);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_laplacian.out0000644000175100001710000000202000000000000026762 0ustar00runnerdocker00000000000000=== Unnormalized, unweighted, undirected
2 -1 0 0 -1
-1 2 -1 0 0
0 -1 2 -1 0
0 0 -1 2 -1
-1 0 0 -1 2
===
2 -1 0 0 -1
-1 2 -1 0 0
0 -1 2 -1 0
0 0 -1 2 -1
-1 0 0 -1 2
===
2 -1 0 0 -1
-1 3 -2 0 0
0 -2 3 -1 0
0 0 -1 3 -2
-1 0 0 -2 3
=== Unnormalized, unweighted, directed
1 -1 0 0 0
0 1 -1 0 0
0 0 1 -1 0
0 0 0 1 -1
-1 0 0 0 1
===
1 -1 0 0 0
0 1 -1 0 0
0 0 1 -1 0
0 0 0 1 -1
-1 0 0 0 1
===
1 -1 0 0 0
0 2 -2 0 0
0 0 1 -1 0
0 0 0 2 -2
-1 0 0 0 1
=== Unnormalized, weighted, undirected
6 -1 0 0 -5
-1 3 -2 0 0
0 -2 5 -3 0
0 0 -3 7 -4
-5 0 0 -4 9
===
6 -1 0 0 -5
-1 3 -2 0 0
0 -2 5 -3 0
0 0 -3 7 -4
-5 0 0 -4 9
===
6 -1 0 0 -5
-1 6 -5 0 0
0 -5 8 -3 0
0 0 -3 10 -7
-5 0 0 -7 12
=== Unnormalized, weighted, directed
1 -1 0 0 0
0 2 -2 0 0
0 0 3 -3 0
0 0 0 4 -4
-5 0 0 0 5
===
1 -1 0 0 0
0 2 -2 0 0
0 0 3 -3 0
0 0 0 4 -4
-5 0 0 0 5
===
1 -1 0 0 0
0 5 -5 0 0
0 0 3 -3 0
0 0 0 7 -7
-5 0 0 0 5
=== Normalized, unweighted, undirected
OK
=== Normalized, unweighted, directed
OK
=== Normalized, weighted, undirected
OK
=== Normalized, weighted, directed
OK
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_layout_reingold_tilford.c0000644000175100001710000000263100000000000031404 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g;
    FILE *f;
    igraph_matrix_t coords;
    /* long int i, n; */

    f = fopen("igraph_layout_reingold_tilford.in", "r");
    igraph_read_graph_edgelist(&g, f, 0, 1);
    igraph_matrix_init(&coords, 0, 0);
    igraph_layout_reingold_tilford(&g, &coords, IGRAPH_IN, 0, 0);

    /*n=igraph_vcount(&g);
    for (i=0; i
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g, g2;
    igraph_bool_t iso;

    // Franklin graph
    igraph_lcf(&g, 12, 5, -5, 6, 0);
    igraph_famous(&g2, "franklin");

    igraph_isomorphic_vf2(&g, &g2,
                          /*vertex.color1=*/ 0, /*vertex.color2=*/ 0,
                          /*edge.color1=*/ 0, /*edge.color2=*/ 0,
                          &iso, 0, 0, 0, 0, 0);
    if (!iso) {
        printf("Failure: Franklin\n");
        return 1;
    }

    igraph_destroy(&g);
    igraph_destroy(&g2);

    // [3, -2]^4, n=8
    igraph_lcf(&g, 8, 3, -2, 4, 0);

    if (igraph_ecount(&g) != 16) {
        printf("Failure: [3, -2]^4, n=8\n");
        return 1;
    }

    igraph_destroy(&g);

    // [2, -2]^2, n=2
    igraph_lcf(&g, 2, 2, -2, 2, 0);

    if (igraph_ecount(&g) != 1) {
        printf("Failure: [2, -2]^2, n=2\n");
        return 1;
    }

    igraph_destroy(&g);

    // [2]^2, n=2
    igraph_lcf(&g, 2, 2, 2, 0);

    if (igraph_ecount(&g) != 1) {
        printf("Failure: [2]^2, n=2\n");
        return 1;
    }

    igraph_destroy(&g);

    // Regression test for bug #996
    igraph_lcf(&g, 0, 0);
    if (igraph_vcount(&g) != 0 || igraph_ecount(&g) != 0) {
        printf("Failure: regression test for #996\n");
        return 1;
    }

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_maximal_cliques.c0000644000175100001710000001114400000000000027635 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#define NODES 1000
#define CLIQUE_SIZE 10
#define NO_CLIQUES 10
#define INT(a) (igraph_rng_get_integer(igraph_rng_default(), 0, (a)))

int permutation(igraph_vector_t *vec) {
    int i, r, tmp;
    for (i = 0; i < CLIQUE_SIZE; i++) {
        r = INT(NODES - 1);
        tmp = VECTOR(*vec)[i];
        VECTOR(*vec)[i] = VECTOR(*vec)[r];
        VECTOR(*vec)[r] = tmp;
    }
    return 0;
}

int sort_cmp(const void *a, const void *b) {
    const igraph_vector_t **da = (const igraph_vector_t **) a;
    const igraph_vector_t **db = (const igraph_vector_t **) b;
    int i, alen = igraph_vector_size(*da), blen = igraph_vector_size(*db);
    if (alen != blen) {
        return (alen < blen) - (alen > blen);
    }
    for (i = 0; i < alen; i++) {
        int ea = VECTOR(**da)[i], eb = VECTOR(**db)[i];
        if (ea != eb) {
            return (ea > eb) - (ea < eb);
        }
    }
    return 0;
}

void sort_cliques(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_sort(v);
    }
    igraph_qsort(VECTOR(*cliques), (size_t) n,
                 sizeof(igraph_vector_t *), sort_cmp);
}

void print_and_destroy_cliques(igraph_vector_ptr_t *cliques) {
    int i;
    sort_cliques(cliques);
    for (i = 0; i < igraph_vector_ptr_size(cliques); i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
}

int main() {

    igraph_t g, g2, cli;
    igraph_vector_t perm;
    igraph_vector_ptr_t cliques;
    igraph_integer_t no;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Create a graph that has a random component, plus a number of
       relatively small cliques */

    igraph_vector_init_seq(&perm, 0, NODES - 1);
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, NODES, NODES,
                            /*directed=*/ 0, /*loops=*/ 0);
    igraph_full(&cli, CLIQUE_SIZE, /*directed=*/ 0, /*loops=*/ 0);

    for (i = 0; i < NO_CLIQUES; i++) {
        /* Permute vertices of g */
        permutation(&perm);
        igraph_permute_vertices(&g, &g2, &perm);
        igraph_destroy(&g);
        g = g2;

        /* Add a clique */
        igraph_union(&g2, &g, &cli, /*edge_map1=*/ 0, /*edge_map2=*/ 0);
        igraph_destroy(&g);
        g = g2;
    }
    igraph_simplify(&g, /*multiple=*/ 1, /*loop=*/ 0, /*edge_comb=*/ 0);

    igraph_vector_destroy(&perm);
    igraph_destroy(&cli);

    /* Find the maximal cliques */

    igraph_vector_ptr_init(&cliques, 0);
    igraph_maximal_cliques(&g, &cliques, /*min_size=*/ 3,
                           /*max_size=*/ 0 /*no limit*/);
    igraph_maximal_cliques_count(&g, &no, /*min_size=*/ 3,
                                 /*max_size=*/ 0 /*no limit*/);

    if (no != igraph_vector_ptr_size(&cliques)) {
        return 1;
    }

    /* Print and destroy them */

    print_and_destroy_cliques(&cliques);

    /* Clean up */

    igraph_vector_ptr_destroy(&cliques);
    igraph_destroy(&g);

    /* Build a triangle with a loop (thanks to Emmanuel Navarro) */

    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, 0, 0, -1);

    /* Find the maximal cliques */

    igraph_vector_ptr_init(&cliques, 0);
    igraph_maximal_cliques(&g, &cliques, /*min_size=*/ 3,
                           /*max_size=*/ 0 /*no limit*/);
    igraph_maximal_cliques_count(&g, &no, /*min_size=*/ 3,
                                 /*max_size=*/ 0 /*no limit*/);

    if (no != igraph_vector_ptr_size(&cliques)) {
        return 2;
    }

    /* Print and destroy them */

    print_and_destroy_cliques(&cliques);

    /* Clean up */

    igraph_vector_ptr_destroy(&cliques);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_maximal_cliques.out0000644000175100001710000000102000000000000030212 0ustar00runnerdocker000000000000000 1 2 3 4 5 6 7 8 9
0 1 3 4 5 7 270 279 534 606
0 1 3 4 5 7 270 534 606 919
9 164 307 416 613 725 749 822 940 949
13 56 75 273 498 534 691 812 864 999
13 82 150 392 418 594 691 810 985 987
13 150 380 418 480 594 749 810 985 987
22 307 450 476 498 520 671 772 831 852
129 205 228 241 247 251 274 377 606 954
129 205 228 247 377 380 392 831 940 954
13 150 380 392 418 594 810 985 987
129 205 228 241 247 377 380 940 954
1 534 999
9 749 987
107 609 835
137 273 691
193 594 691
295 307 450
307 831 940
338 610 840
380 749 940
0 1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_maximum_bipartite_matching.c0000644000175100001710000002343100000000000032054 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2012  Tamas Nepusz 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int test_graph_from_leda_tutorial() {
    /* Test graph from the LEDA tutorial:
     * http://www.leda-tutorial.org/en/unofficial/ch05s03s05.html
     */
    igraph_t graph;
    igraph_vector_bool_t types;
    igraph_vector_long_t matching;
    igraph_integer_t matching_size;
    igraph_real_t matching_weight;
    igraph_bool_t is_matching;
    int i;

    igraph_small(&graph, 0, 0,
                 0, 8, 0, 12, 0, 14,
                 1, 9, 1, 10, 1, 13,
                 2, 8, 2, 9,
                 3, 10, 3, 11, 3, 13,
                 4, 9, 4, 14,
                 5, 14,
                 6, 9, 6, 14,
                 7, 8, 7, 12, 7, 14
                 , -1);
    igraph_vector_bool_init(&types, 15);
    for (i = 0; i < 15; i++) {
        VECTOR(types)[i] = (i >= 8);
    }
    igraph_vector_long_init(&matching, 0);

    igraph_maximum_bipartite_matching(&graph, &types, &matching_size,
                                      &matching_weight, &matching, 0, 0);
    if (matching_size != 6) {
        printf("matching_size is %ld, expected: 6\n", (long)matching_size);
        return 1;
    }
    if (matching_weight != 6) {
        printf("matching_weight is %ld, expected: 6\n", (long)matching_weight);
        return 2;
    }
    igraph_is_maximal_matching(&graph, &types, &matching, &is_matching);
    if (!is_matching) {
        printf("not a matching: ");
        igraph_vector_long_print(&matching);
        return 3;
    }

    igraph_vector_long_destroy(&matching);
    igraph_vector_bool_destroy(&types);
    igraph_destroy(&graph);

    return 0;
}

int test_weighted_graph_from_mit_notes() {
    /* Test graph from the following lecture notes:
     * http://math.mit.edu/~goemans/18433S07/matching-notes.pdf
     */
    igraph_t graph;
    igraph_vector_bool_t types;
    igraph_vector_long_t matching;
    igraph_vector_t weights;
    igraph_integer_t matching_size;
    igraph_real_t matching_weight;
    igraph_bool_t is_matching;
    igraph_real_t weight_array[] = { 2, 7, 2, 3,
                                     1, 3, 9, 3, 3,
                                     1, 3, 3, 1, 2,
                                     4, 1, 2,
                                     3
                                   };
    int i;

    igraph_small(&graph, 0, 0,
                 0, 6, 0, 7, 0, 8, 0, 9,
                 1, 5, 1, 6, 1, 7, 1, 8, 1, 9,
                 2, 5, 2, 6, 2, 7, 2, 8, 2, 9,
                 3, 5, 3, 7, 3, 9,
                 4, 7, -1);
    igraph_vector_bool_init(&types, 10);
    for (i = 0; i < 10; i++) {
        VECTOR(types)[i] = (i >= 5);
    }
    igraph_vector_long_init(&matching, 0);
    igraph_vector_init_copy(&weights, weight_array,
                            sizeof(weight_array) / sizeof(weight_array[0]));

    igraph_maximum_bipartite_matching(&graph, &types, &matching_size,
                                      &matching_weight, &matching, &weights, 0);
    if (matching_size != 4) {
        printf("matching_size is %ld, expected: 4\n", (long)matching_size);
        return 1;
    }
    if (matching_weight != 19) {
        printf("matching_weight is %ld, expected: 19\n", (long)matching_weight);
        return 2;
    }
    igraph_is_maximal_matching(&graph, &types, &matching, &is_matching);
    if (!is_matching) {
        printf("not a matching: ");
        igraph_vector_long_print(&matching);
        return 3;
    }

    igraph_vector_destroy(&weights);
    igraph_vector_long_destroy(&matching);
    igraph_vector_bool_destroy(&types);
    igraph_destroy(&graph);

    return 0;
}

int test_weighted_graph_generated() {
    /* Several randomly generated small test graphs */
    igraph_t graph;
    igraph_vector_bool_t types;
    igraph_vector_long_t matching;
    igraph_vector_t weights;
    igraph_integer_t matching_size;
    igraph_real_t matching_weight;
    igraph_real_t weight_array_1[] = { 8, 5, 9, 18, 20, 13 };
    igraph_real_t weight_array_2[] = { 20, 4, 20, 3, 13, 1 };
    int i;

    igraph_vector_bool_init(&types, 10);
    for (i = 0; i < 10; i++) {
        VECTOR(types)[i] = (i >= 5);
    }
    igraph_vector_long_init(&matching, 0);

    /* Case 1 */

    igraph_small(&graph, 0, 0, 0, 8, 2, 7, 3, 7, 3, 8, 4, 5, 4, 9, -1);
    igraph_vector_init_copy(&weights, weight_array_1,
                            sizeof(weight_array_1) / sizeof(weight_array_1[0]));
    igraph_maximum_bipartite_matching(&graph, &types, &matching_size,
                                      &matching_weight, &matching, &weights, 0);
    if (matching_weight != 43) {
        printf("matching_weight is %ld, expected: 43\n", (long)matching_weight);
        return 2;
    }
    igraph_vector_destroy(&weights);
    igraph_destroy(&graph);

    /* Case 2 */

    igraph_small(&graph, 0, 0, 0, 5, 0, 6, 1, 7, 2, 5, 3, 5, 3, 9, -1);
    igraph_vector_init_copy(&weights, weight_array_2,
                            sizeof(weight_array_2) / sizeof(weight_array_2[0]));
    igraph_maximum_bipartite_matching(&graph, &types, &matching_size,
                                      &matching_weight, &matching, &weights, 0);
    if (matching_weight != 41) {
        printf("matching_weight is %ld, expected: 41\n", (long)matching_weight);
        return 2;
    }
    igraph_vector_destroy(&weights);
    igraph_destroy(&graph);

    igraph_vector_long_destroy(&matching);
    igraph_vector_bool_destroy(&types);

    return 0;
}

int test_weighted_graph_from_file(const char* fname, int type1_count, long exp_weight) {
    igraph_t graph;
    igraph_vector_bool_t types;
    igraph_vector_long_t matching;
    igraph_vector_t weights;
    igraph_real_t matching_weight;
    FILE* f;
    int i, n;

    f = fopen(fname, "r");
    if (!f) {
        fprintf(stderr, "No such file: %s\n", fname);
        return 1;
    }
    igraph_read_graph_ncol(&graph, f, 0, 1, IGRAPH_ADD_WEIGHTS_YES, 0);
    fclose(f);

    n = igraph_vcount(&graph);
    igraph_vector_bool_init(&types, n);
    for (i = 0; i < n; i++) {
        VECTOR(types)[i] = (i >= type1_count);
    }

    igraph_vector_long_init(&matching, 0);

    igraph_vector_init(&weights, 0);
    EANV(&graph, "weight", &weights);
    igraph_maximum_bipartite_matching(&graph, &types, 0, &matching_weight,
                                      &matching, &weights, 0);
    igraph_vector_destroy(&weights);

    igraph_vector_long_print(&matching);
    if (matching_weight != exp_weight) {
        printf("matching_weight is %ld, expected: %ld\n", (long)matching_weight,
               (long)exp_weight);
        return 2;
    }

    igraph_vector_destroy(&weights);
    igraph_vector_long_destroy(&matching);
    igraph_vector_bool_destroy(&types);
    igraph_destroy(&graph);

    return 0;
}

// This test addresses issue #1110, where an incorrect
// types vector (i.e. that doesn't correspond to a bipartite
// labelling of the graph) would cause a possible infinite loop.
int test_incorrect_types() {
    igraph_t g;
    igraph_vector_bool_t types;
    igraph_vector_t weights;

    igraph_integer_t matching_size;
    igraph_real_t weighted_size;

    igraph_vector_long_t matching;

    igraph_error_type_t err;


    igraph_small(&g, 4, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3,
                 -1);

    igraph_vector_bool_init(&types, 4);
    VECTOR(types)[0] = 0;
    VECTOR(types)[1] = 1;
    VECTOR(types)[2] = 0;
    VECTOR(types)[3] = 1;

    igraph_vector_long_init(&matching, 0);

    igraph_vector_init(&weights, igraph_vcount(&g));
    igraph_vector_fill(&weights, 1.0);

    igraph_set_error_handler(&igraph_error_handler_ignore);

    // Test incorrect types
    err = igraph_maximum_bipartite_matching(&g, &types, &matching_size, NULL, &matching, NULL, 0);
    if (err != IGRAPH_EINVAL) {
        return 3;
    }

    // Test correct types
    VECTOR(types)[2] = 1;
    err = igraph_maximum_bipartite_matching(&g, &types, &matching_size, NULL, &matching, NULL, 0);
    if (err == IGRAPH_EINVAL) {
        return 4;
    }

    // Test incorrect types for weighted graph
    VECTOR(types)[2] = 0;
    err = igraph_maximum_bipartite_matching(&g, &types, &matching_size, &weighted_size, &matching, &weights, 0);
    if (err != IGRAPH_EINVAL) {
        return 5;
    }

    // Test correct types for weighted graph
    VECTOR(types)[2] = 1;
    err = igraph_maximum_bipartite_matching(&g, &types, &matching_size, &weighted_size, &matching, &weights, 0);
    if (err == IGRAPH_EINVAL) {
        return 6;
    }

    igraph_vector_destroy(&weights);
    igraph_vector_long_destroy(&matching);

    igraph_vector_bool_destroy(&types);
    igraph_destroy(&g);

    return 0;
}

int main() {
    igraph_set_attribute_table(&igraph_cattribute_table);

    if (test_graph_from_leda_tutorial()) {
        return 1;
    }

    if (test_weighted_graph_from_mit_notes()) {
        return 2;
    }

    if (test_weighted_graph_generated()) {
        return 3;
    }

    if (test_incorrect_types()) {
        return 4;
    }

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        printf("Finally stack still has %d elements.\n", IGRAPH_FINALLY_STACK_SIZE());
        return 5;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_mincut.c0000644000175100001710000000714200000000000025762 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_mincut(const igraph_t *graph, igraph_real_t value,
                 const igraph_vector_t *partition,
                 const igraph_vector_t *partition2,
                 const igraph_vector_t *cut,
                 const igraph_vector_t *capacity) {

    long int i, nc = igraph_vector_size(cut);
    igraph_bool_t directed = igraph_is_directed(graph);

    printf("mincut value: %g\n", (double) value);
    printf("first partition:  ");
    igraph_vector_print(partition);
    printf("second partition: ");
    igraph_vector_print(partition2);
    printf("edges in the cut: ");
    for (i = 0; i < nc; i++) {
        long int edge = VECTOR(*cut)[i];
        long int from = IGRAPH_FROM(graph, edge);
        long int to  = IGRAPH_TO  (graph, edge);
        if (!directed && from > to) {
            igraph_integer_t tmp = from;
            from = to;
            to = tmp;
        }
        printf("%li-%li (%g), ", from, to, VECTOR(*capacity)[edge]);
    }
    printf("\n");

    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_t weights, partition, partition2, cut;
    igraph_real_t value;

    igraph_vector_init(&partition, 0);
    igraph_vector_init(&partition2, 0);
    igraph_vector_init(&cut, 0);

    /* -------------------------------------------- */

    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 1, 2, 1, 4, 1, 5, 2, 3, 2, 6, 3, 6, 3, 7, 4, 5, 5, 6, 6, 7,
                 -1);
    igraph_vector_init_int_end(&weights, -1, 2, 3, 3, 2, 2, 4, 2, 2, 2, 3, 1, 3, -1);

    igraph_mincut(&g, &value, &partition, &partition2, &cut, &weights);
    print_mincut(&g, value, &partition, &partition2, &cut, &weights);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* -------------------------------------------- */

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 0, 5, 5, 4, 4, 3, 3, 0, -1);
    igraph_vector_init_int_end(&weights, -1, 3, 1, 2, 10, 1, 3, 2, -1);

    igraph_mincut(&g, &value, &partition, &partition2, &cut, &weights);
    print_mincut(&g, value, &partition, &partition2, &cut, &weights);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* -------------------------------------------- */

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 4, 3, 3, 2, 2, 1, 1, 0,
                 -1);
    igraph_vector_init_int_end(&weights, -1, 1, 1, 1, 1, -1);
    igraph_mincut(&g, &value, &partition, &partition2, &cut, &weights);
    print_mincut(&g, value, &partition, &partition2, &cut, &weights);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* -------------------------------------------- */

    igraph_vector_destroy(&cut);
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&partition);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_mincut.out0000644000175100001710000000042600000000000026345 0ustar00runnerdocker00000000000000mincut value: 4
first partition:  2 3 6 7
second partition: 0 1 4 5
edges in the cut: 1-2 (3), 5-6 (1), 
mincut value: 1
first partition:  1
second partition: 0 2 3 4 5
edges in the cut: 1-2 (1), 
mincut value: 0
first partition:  0
second partition: 1 2 3 4
edges in the cut: 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_minimal_separators.c0000644000175100001710000000334500000000000030355 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t graph;
    igraph_vector_ptr_t separators;
    long int i, n;

    igraph_famous(&graph, "zachary");
    igraph_vector_ptr_init(&separators, 0);
    igraph_all_minimal_st_separators(&graph, &separators);

    n = igraph_vector_ptr_size(&separators);
    for (i = 0; i < n; i++) {
        igraph_bool_t res;
        igraph_vector_t *sep = VECTOR(separators)[i];
        igraph_is_separator(&graph, igraph_vss_vector(sep), &res);
        if (!res) {
            printf("Vertex set %li is not a separator!\n", i);
            igraph_vector_print(sep);
            return 1;
        }
    }

    igraph_destroy(&graph);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(separators)[i];
        igraph_vector_destroy(v);
        IGRAPH_FREE(v);
    }
    igraph_vector_ptr_destroy(&separators);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_minimum_size_separators.c0000644000175100001710000001264500000000000031437 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int print_and_destroy(igraph_vector_ptr_t *ptr) {
    long int i, n = igraph_vector_ptr_size(ptr);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*ptr)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
    igraph_vector_ptr_destroy(ptr);
    return 0;
}

int main() {
    igraph_t g, g2;
    igraph_vector_ptr_t sep;
    igraph_vs_t vs;

    igraph_small(&g, 7, IGRAPH_UNDIRECTED,
                 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0,
                 -1);
    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    print_and_destroy(&sep);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 5, IGRAPH_UNDIRECTED,
                 0, 3, 1, 3, 2, 3,
                 0, 4, 1, 4, 2, 4,
                 -1);
    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    print_and_destroy(&sep);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 5, IGRAPH_UNDIRECTED,
                 2, 0, 3, 0, 4, 0,
                 2, 1, 3, 1, 4, 1,
                 -1);
    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    print_and_destroy(&sep);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 2, 0, 3, 1, 2, 1, 3, 5, 2, 5, 3, 6, 2, 6, 3,
                 7, 2, 7, 3, 8, 2, 8, 3, 9, 2, 9, 3,
                 2, 4, 4, 3,
                 -1);
    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    print_and_destroy(&sep);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_full(&g, 4, IGRAPH_UNDIRECTED, /*loops=*/ 0);
    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    print_and_destroy(&sep);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 23, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 0, 5,
                 1, 2, 1, 3, 1, 4, 1, 6,
                 2, 3, 2, 5, 2, 6,
                 3, 4, 3, 5, 3, 6,
                 4, 5, 4, 6, 4, 20,
                 5, 6,
                 6, 7, 6, 10, 6, 13, 6, 18,
                 7, 8, 7, 10, 7, 13,
                 8, 9,
                 9, 11, 9, 12,
                 10, 11, 10, 13,
                 11, 15,
                 12, 15,
                 13, 14,
                 14, 15,
                 16, 17, 16, 18, 16, 19,
                 17, 19, 17, 20,
                 18, 19, 18, 21, 18, 22,
                 19, 20,
                 20, 21, 20, 22,
                 21, 22,
                 -1);

    igraph_vector_ptr_init(&sep, 0);
    igraph_minimum_size_separators(&g, &sep);
    printf("Orig:\n");
    print_and_destroy(&sep);

    igraph_vector_ptr_init(&sep, 0);
    igraph_vs_vector_small(&vs, 0, 1, 2, 3, 4, 5, 6, 16, 17, 18, 19, 20, 21, 22, -1);
    igraph_induced_subgraph(&g, &g2, vs, IGRAPH_SUBGRAPH_AUTO);
    igraph_minimum_size_separators(&g2, &sep);
    printf("1-7,17-23:\n");
    print_and_destroy(&sep);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g2);

    igraph_vector_ptr_init(&sep, 0);
    igraph_vs_vector_small(&vs, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, -1);
    igraph_induced_subgraph(&g, &g2, vs, IGRAPH_SUBGRAPH_AUTO);
    igraph_minimum_size_separators(&g2, &sep);
    printf("7-16:\n");
    print_and_destroy(&sep);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g2);

    igraph_vector_ptr_init(&sep, 0);
    igraph_vs_vector_small(&vs, 16, 17, 18, 19, 20, 21, 22, -1);
    igraph_induced_subgraph(&g, &g2, vs, IGRAPH_SUBGRAPH_AUTO);
    igraph_minimum_size_separators(&g2, &sep);
    printf("17-23:\n");
    print_and_destroy(&sep);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g2);

    igraph_vector_ptr_init(&sep, 0);
    igraph_vs_vector_small(&vs, 6, 7, 10, 13, -1);
    igraph_induced_subgraph(&g, &g2, vs, IGRAPH_SUBGRAPH_AUTO);
    igraph_minimum_size_separators(&g2, &sep);
    printf("7,8,11,14:\n");
    print_and_destroy(&sep);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g2);

    igraph_vector_ptr_init(&sep, 0);
    igraph_vs_vector_small(&vs, 0, 1, 2, 3, 4, 5, 6, -1);
    igraph_induced_subgraph(&g, &g2, vs, IGRAPH_SUBGRAPH_AUTO);
    igraph_minimum_size_separators(&g2, &sep);
    printf("1-7:\n");
    print_and_destroy(&sep);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g2);

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_minimum_size_separators.out0000644000175100001710000000025600000000000032017 0ustar00runnerdocker000000000000000
3 4
0 1
2 3
1 2 3
0 2 3
0 1 3
0 1 2
Orig:
6
1-7,17-23:
4 6
6 11
4 9
9 11
7-16:
3 9
7 9
1 3
17-23:
2 4
7,8,11,14:
1 2 3
0 2 3
0 1 3
0 1 2
1-7:
1 2 3 4 5
0 2 3 4 6
0 1 3 5 6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_minimum_spanning_tree.c0000644000175100001710000000472100000000000031052 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g, tree;
    igraph_vector_t eb, edges;
    long int i;

    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_vector_init(&eb, igraph_ecount(&g));
    igraph_edge_betweenness(&g, &eb, IGRAPH_UNDIRECTED, /*weights=*/ 0);
    for (i = 0; i < igraph_vector_size(&eb); i++) {
        VECTOR(eb)[i] = -VECTOR(eb)[i];
    }

    igraph_minimum_spanning_tree_prim(&g, &tree, &eb);
    igraph_write_graph_edgelist(&tree, stdout);

    igraph_vector_init(&edges, 0);
    igraph_minimum_spanning_tree(&g, &edges, &eb);
    igraph_vector_print(&edges);
    igraph_vector_destroy(&edges);

    igraph_destroy(&tree);
    igraph_destroy(&g);
    igraph_vector_destroy(&eb);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_minimum_spanning_tree.out0000644000175100001710000000041000000000000031426 0ustar00runnerdocker000000000000000 2
0 4
0 5
0 6
0 8
0 10
0 11
0 12
0 17
0 21
0 31
1 30
2 3
2 7
2 9
2 27
2 32
6 16
13 33
14 33
15 33
18 33
19 33
20 33
22 33
23 33
24 31
25 31
26 33
28 33
29 33
30 33
31 33
15 5 4 1 7 31 9 76 45 52 67 8 3 10 65 29 12 14 64 49 47 51 56 54 61 27 72 40 74 23 25 70 24
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_motifs_randesu.c0000644000175100001710000000332000000000000027477 0ustar00runnerdocker00000000000000
#include 

/* This is a callback function suitable for use with igraph_motifs_randesu_callback().
 * It prints each motif it is calld with. */
igraph_bool_t print_motif(const igraph_t *graph, igraph_vector_t *vids,
                          int isoclass, void* extra) {
    printf("Found isoclass %2d:  ", isoclass);
    igraph_vector_print(vids);
    return 0; /* Return 'false': do not interrupt the search. */
}

int main() {

    igraph_t graph;
    igraph_vector_t hist;
    igraph_real_t zeros[] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
    igraph_vector_t cut_prob;

    /* Compute the 4-motif distritbuion in Zachary's karate club network. */

    igraph_famous(&graph, "Zachary");
    igraph_vector_init(&hist, 0);

    igraph_motifs_randesu(&graph, &hist, 4, igraph_vector_view(&cut_prob, zeros, 4));

    /* Compute the total number of motifs (connected 4-vertex subgraphs)
     * so that we can print the normalized distribution. */
    igraph_real_t sum = 0.0;
    igraph_integer_t n = igraph_vector_size(&hist);
    for (igraph_integer_t i=0; i < n; i++) {
        if (!igraph_is_nan(VECTOR(hist)[i])) {
            sum += VECTOR(hist)[i];
        }
    }
    printf("4-motif distribution:\n");
    for (igraph_integer_t i=0; i < n; i++) {
        /* Print NaN values in a platform-independent manner: */
        igraph_real_printf(VECTOR(hist)[i] / sum);
        printf(" ");
    }
    printf("\n\n");

    igraph_vector_destroy(&hist);
    igraph_destroy(&graph);

    /* Identify the vertices of each three-motif in a small Kautz graph. */

    igraph_kautz(&graph, 2, 1);
    igraph_motifs_randesu_callback(&graph, 3, igraph_vector_view(&cut_prob, zeros, 3), &print_motif, NULL);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_motifs_randesu.out0000644000175100001710000000072100000000000030066 0ustar00runnerdocker000000000000004-motif distribution:
NaN NaN NaN NaN 0.464664 NaN 0.288193 0.191282 0.0152349 0.0359712 0.0046551 

Found isoclass  5:  0 4 2
Found isoclass 11:  0 4 3
Found isoclass  9:  0 4 1
Found isoclass  9:  0 3 2
Found isoclass  5:  0 3 5
Found isoclass  9:  0 2 1
Found isoclass  5:  0 2 5
Found isoclass 11:  1 5 2
Found isoclass  9:  1 5 4
Found isoclass  5:  1 5 3
Found isoclass  5:  1 4 2
Found isoclass  5:  1 4 3
Found isoclass  9:  2 5 3
Found isoclass  9:  3 5 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_neighbors.c0000644000175100001710000000407600000000000026446 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_vector(igraph_vector_t *v, FILE *f) {
    long int i;
    for (i = 0; i < igraph_vector_size(v); i++) {
        fprintf(f, " %li", (long int) VECTOR(*v)[i]);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_t g;
    igraph_vector_t v;
    int ret;

    igraph_vector_init(&v, 8);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 2;
    VECTOR(v)[4] = 2;
    VECTOR(v)[5] = 3;
    VECTOR(v)[6] = 2;
    VECTOR(v)[7] = 2;
    igraph_create(&g, &v, 0, 1);

    igraph_neighbors(&g, &v, 2, IGRAPH_OUT);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    igraph_neighbors(&g, &v, 2, IGRAPH_IN);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    igraph_neighbors(&g, &v, 2, IGRAPH_ALL);
    igraph_vector_sort(&v);
    print_vector(&v, stdout);

    /* Errors */
    igraph_set_error_handler(igraph_error_handler_ignore);
    ret = igraph_neighbors(&g, &v, 2, (igraph_neimode_t)0); /* conv for c++ */
    if (ret != IGRAPH_EINVMODE) {
        return 1;
    }

    ret = igraph_neighbors(&g, &v, 4, IGRAPH_ALL);
    if (ret != IGRAPH_EINVVID) {
        return 2;
    }

    igraph_vector_destroy(&v);
    igraph_destroy(&g);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_neighbors.out0000644000175100001710000000002300000000000027017 0ustar00runnerdocker00000000000000 2 3
 1 2
 1 2 2 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_pagerank.c0000644000175100001710000000170400000000000026251 0ustar00runnerdocker00000000000000
#include 
#include 

int main() {
    igraph_t graph;
    igraph_vector_t pagerank;
    igraph_real_t value;

    /* Create a directed graph */
    igraph_kautz(&graph, 2, 3);

    /* Initialize the vector where the results will be stored */
    igraph_vector_init(&pagerank, 0);

    igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK,
                    &pagerank, &value,
                    igraph_vss_all(), IGRAPH_DIRECTED,
                    /* damping */ 0.85, /* weights */ NULL,
                    NULL /* not needed with PRPACK method */);

    /* Check that the eigenvalue is 1, as expected. */
    if (fabs(value - 1.0) > 32*DBL_EPSILON) {
        fprintf(stderr, "PageRank failed to converge.\n");
        return 1;
    }

    /* Output the result */
    igraph_vector_print(&pagerank);

    /* Destroy data structure when no longer needed */
    igraph_vector_destroy(&pagerank);
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_power_law_fit.c0000644000175100001710000005350500000000000027330 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_result(const igraph_plfit_result_t* result) {
    printf("continuous = %s\n", result->continuous ? "true" : "false");
    printf("alpha = %.5f\n", result->alpha);
    printf("xmin = %.5f\n", result->xmin);
    printf("L = %.5f\n", result->L);
    printf("D = %.5f\n", result->D);
    printf("p = %.5f\n", result->p);
    printf("====================\n");
}

int test_continuous() {
    igraph_plfit_result_t result;
    igraph_vector_t vector;
    double data[] = { 1.52219974, 6.80675663, 1.02798042, 1.31180733, 3.97473174,
                      1.17209342, 1.64889191, 2.47764721, 1.32939375, 3.03762554, 1.62638327,
                      6.08405495, 1.70890382, 1.05294973, 1.17408407, 4.48945532, 1.16777371,
                      2.52502391, 1.09755984, 1.63838051, 1.03811206, 1.47224168, 1.57161431,
                      1.60163451, 2.08280263, 1.04678340, 1.33317526, 1.58588741, 1.26484666,
                      1.02367503, 1.57045702, 3.42374138, 1.23190611, 1.09378228, 1.04959505,
                      1.05818408, 1.43879491, 2.22750459, 1.41027204, 1.81964745, 2.80239939,
                      1.25399323, 1.07479219, 3.94616077, 1.26367914, 1.87367507, 1.35741026,
                      1.14867526, 7.33024762, 1.87957274, 2.79258534, 1.21682159, 1.61194300,
                      2.81885973, 1.21514746, 1.12850917, 51.85245035, 1.21883209, 1.04861029,
                      1.69215609, 2.18429429, 1.59752172, 1.41909984, 3.14393355, 1.18298455,
                      1.67063821, 1.88568524, 1.07445906, 1.45007973, 1.12568920, 1.56806310,
                      1.36996101, 1.19440982, 6.57296980, 1.35860725, 1.06552137, 1.16950701,
                      1.34750790, 1.66977492, 1.22658722, 1.62247444, 1.23458784, 8.55843760,
                      1.70020162, 4.76368831, 1.04846170, 1.13689661, 1.94449567, 1.10584812,
                      1.32525767, 1.26640912, 1.91372972, 1.56185373, 2.37829675, 1.04616674,
                      2.43549177, 1.14961092, 1.82106455, 1.25818298, 1.64763037, 1.43019402,
                      1.50439978, 1.90281251, 1.34827040, 1.57935671, 1.77260751, 1.06976614,
                      1.12236012, 2.19770254, 1.51825533, 1.19027804, 1.08307524, 1.57912902,
                      3.33313888, 2.14005088, 1.38341873, 1.20088138, 1.25870539, 1.03811620,
                      1.86622820, 2.99310953, 1.55615055, 2.12364873, 4.49081000, 1.01274439,
                      1.22373389, 3.79059729, 3.10099275, 2.70218546, 1.03609624, 2.20776919,
                      1.00651347, 1.87344592, 1.04903307, 1.24899747, 1.20377911, 1.12706494,
                      1.01706713, 7.01069306, 1.05363146, 2.50105512, 1.11168552, 1.71133998,
                      1.17714528, 1.37986755, 2.20981534, 1.18179277, 2.07982010, 4.04967099,
                      1.00680257, 1.62850069, 2.58816230, 1.35079027, 1.03382890, 4.54326500,
                      1.62489905, 1.36102570, 1.52349738, 1.06606346, 7.80558026, 1.02602538,
                      1.43330925, 1.36040920, 9.29692547, 15.27015690, 1.75966437, 1.02635409,
                      1.40421505, 2.87296958, 1.46232202, 1.87065204, 3.37278803, 1.82589564,
                      1.06488044, 1.72568108, 1.21062115, 4.39311214, 1.12636227, 2.20820528,
                      1.09826903, 2.58989998, 1.34944949, 1.08654244, 2.38021951, 3.96308780,
                      1.37494639, 1.18245279, 3.72506217, 3.79775023, 1.19018356, 2.86924476,
                      3.40015888, 1.92317855, 1.55203754, 1.34985008, 1.31480190, 1.65899877,
                      4.77446435, 1.41073246, 1.35555456, 2.40543613, 2.72162935, 1.34475982,
                      1.41342115, 5.15278473, 1.69654436, 3.21081899, 1.18822397, 1.40394863,
                      1.06793574, 1.67085563, 1.08125975, 1.11765459, 1.17245045, 1.15711479,
                      1.18656910, 1.61296203, 1.71427634, 1.24017302, 2.05291524, 2.52658791,
                      2.04645295, 34.07541626, 1.32670899, 1.03893757, 1.08957199, 5.55332328,
                      1.17276097, 1.60389480, 2.02098430, 2.92934928, 1.00558653, 1.05830070,
                      1.81440889, 3.85044779, 1.12317456, 1.39547640, 2.93105179, 1.95048788,
                      1.05602445, 1.96855429, 1.60432293, 3.28820202, 1.50117325, 1.19775674,
                      1.28280841, 1.08318646, 1.02098264, 1.24861938, 1.06511473, 1.07549717,
                      3.57739126, 1.07265409, 1.06312441, 1.16296512, 3.83654484, 2.02366951,
                      1.73168875, 1.60443228, 2.30779766, 1.50531775, 1.31925607, 1.87926179,
                      1.86249354, 2.14768716, 2.31583955, 2.15651148, 1.29677318, 1.10110071,
                      1.03383916, 1.50665009, 1.16502917, 1.40055008, 2.80847193, 1.29824634,
                      2.76239920, 1.73123621, 1.15286577, 1.89493526, 1.63112634, 1.17828846,
                      1.01293513, 1.84834048, 4.19026736, 1.82684815, 3.51812301, 1.33499862,
                      2.03087497, 1.32419883, 1.34126954, 1.98250684, 1.00025697, 1.59416883,
                      6.38249787, 2.79055559, 1.57750678, 1.36953983, 1.37513919, 3.63573178,
                      1.15637432, 9.28386344, 1.16947695, 1.54995742, 1.44018755, 1.29332881,
                      1.81274872, 1.14900153, 1.07117403, 1.17035915, 1.39229249, 1.96645872,
                      1.09147706, 1.25211993, 1.07092474, 1.85394206, 1.29807741, 3.41499510,
                      1.22444449, 1.00913782, 3.87431854, 1.01072376, 1.01186727, 3.00175639,
                      2.52183377, 1.23992099, 1.69819010, 1.36850400, 1.14577814, 1.06035078,
                      1.08414298, 1.55920217, 5.07059630, 1.15434572, 1.41873305, 1.24712256,
                      1.10478618, 1.30707247, 1.85719110, 1.89873207, 1.72629431, 1.65171651,
                      7.10864875, 2.31945709, 1.06722361, 1.26696259, 2.23845503, 1.38674196,
                      1.91015397, 1.29590323, 1.10448028, 4.52757499, 2.00258408, 1.38299092,
                      1.01431427, 1.54039270, 1.34880396, 1.08784083, 1.35553378, 1.37307373,
                      1.32320467, 1.50261683, 6.91050685, 1.06083157, 1.20841351, 2.92719840,
                      2.82178183, 2.05765813, 1.84621661, 1.04677388, 2.13801850, 1.39654855,
                      1.13037727, 1.37887598, 1.03221650, 1.15981176, 1.09896163, 1.88624084,
                      1.43459062, 1.54587662, 1.48604380, 2.06197392, 1.97079675, 4.31388672,
                      2.94376994, 3.48708489, 1.09674551, 2.46926816, 1.23705940, 1.57512843,
                      1.15595205, 1.18432818, 1.54298936, 1.60600489, 1.07361787, 1.38666771,
                      1.45533003, 1.78940830, 1.33799752, 1.12955889, 4.59400278, 1.15170228,
                      1.39346636, 1.61408789, 2.21293753, 5.33166143, 1.18147947, 1.54426891,
                      1.32496426, 1.25037632, 3.31244261, 1.36211171, 1.82239599, 1.75235087,
                      1.67044831, 1.24802350, 1.34776327, 1.34740665, 1.30664120, 1.06852680,
                      1.22513631, 1.25310923, 1.36394926, 1.07796356, 3.10823551, 1.46770227,
                      1.40264883, 1.08787681, 1.26460358, 1.10348946, 2.03168839, 1.09435135,
                      1.66991715, 1.19738540, 1.28922229, 2.85704149, 1.33952521, 1.73497688,
                      2.90052876, 5.34596348, 1.36399078, 3.38399264, 1.06089658, 1.09370142,
                      1.37523679, 3.01964907, 1.40684792, 1.11312672, 2.44666372, 1.73953904,
                      1.65569280, 1.05813000, 2.02893022, 1.72877601, 1.55758690, 1.83904301,
                      1.14316984, 1.17792251, 1.44106281, 9.67126482, 1.93207441, 1.08242887,
                      2.87271135, 2.19095115, 2.13195479, 1.02355472, 1.18218470, 1.30907724,
                      1.13291587, 2.85659336, 12.62726889, 1.18818589, 1.02852443, 1.12838670,
                      1.36349361, 1.34817100, 1.30535737, 3.22225028, 1.28680350, 1.83979657,
                      1.11088952, 1.43866586, 8.52587567, 3.73988696, 2.65816056, 1.17373111,
                      2.61567111, 3.24024082, 2.96798864, 1.05335616, 1.31159271, 1.36485918,
                      1.24988767, 7.80609746, 1.54892174, 1.10682809, 1.21728827, 1.20429971,
                      1.72719055, 1.78534831, 1.04414979, 1.25646988, 1.19788383, 1.08854812,
                      1.04859628, 1.04676064, 5.07295341, 3.83595341, 1.61079632, 1.10528426,
                      1.15050241, 2.78129736, 1.25494119, 1.28692155, 1.06812292, 3.29393761,
                      1.37542463, 1.67241953, 1.21698665, 10.57727604, 8.63598976, 1.18886984,
                      1.30609583, 9.47777457, 1.69612900, 2.23002585, 1.58461615, 1.04110023,
                      3.08140806, 1.39599251, 1.06575789, 1.29741002, 1.75253864, 1.82594258,
                      1.15111702, 1.17370053, 1.15254396, 1.94401179, 5.36344596, 4.66322185,
                      1.15073993, 3.21478159, 1.39843306, 1.03961906, 5.72845289, 1.72454161,
                      1.04610704, 1.38975310, 1.77732797, 1.10139931, 2.23656355, 1.89952669,
                      1.72136921, 1.15798212, 1.59545971, 1.08789161, 1.93272206, 2.57480708,
                      1.04977784, 2.00874078, 3.40065861, 1.00978603, 3.97804652, 1.54762586,
                      1.01015493, 1.15148220, 1.15246483, 19.67426012, 1.33290993, 2.33137522,
                      1.12841749, 1.73407057, 2.00469493, 1.27418995, 1.49814918, 1.10398785,
                      1.20063760, 1.05536150, 1.87616599, 1.49305736, 1.60241346, 1.16666060,
                      1.05013736, 1.77929210, 1.00206028, 3.41096863, 1.47499925, 1.14071240,
                      1.65361002, 1.76466424, 8.49298111, 1.41069285, 2.11681605, 4.90260842,
                      1.13029658, 1.20802818, 1.42525579, 1.00310774, 1.08082363, 9.95194247,
                      2.82773946, 2.77420002, 1.82543685, 1.28557906, 1.97711769, 1.19001264,
                      1.95712650, 1.54230291, 1.31625757, 2.36364128, 1.11523099, 1.00343756,
                      1.71299382, 1.44667100, 2.38154868, 1.41174217, 1.80660493, 1.51020853,
                      1.16761479, 1.25898190, 1.18150781, 1.58465451, 2.03560597, 3.48531184,
                      1.21187672, 1.35111036, 1.02954922, 1.90892663, 3.99078548, 5.67385199,
                      4.38055264, 1.17446048, 13.41617858, 1.60241740, 1.14811206, 4.68120263,
                      3.83763710, 2.66095263, 1.83338503, 4.75973082, 1.08982301, 4.04104276,
                      1.34220189, 1.06135891, 2.71185882, 1.46085873, 1.09915614, 10.35178646,
                      2.54402271, 2.65696704, 1.31388649, 1.02942408, 1.57780748, 1.01552697,
                      2.24860361, 2.22011778, 1.13595134, 1.11492512, 2.11966788, 1.20420149,
                      1.11112428, 3.09324603, 2.87240762, 1.50486558, 1.92227231, 4.12480449,
                      1.58244751, 1.69922308, 6.28134904, 2.91944178, 1.85386792, 1.41799519,
                      1.64636127, 2.05837832, 1.07153521, 2.05376943, 2.60053549, 1.09773382,
                      1.54671309, 1.68007415, 3.43941489, 1.41601033, 2.00237256, 1.20830978,
                      1.25582363, 1.10830461, 1.24850906, 1.88035202, 1.70557719, 1.04191110,
                      1.33501003, 1.33554804, 1.36935735, 4.79153510, 1.06566392, 1.14495966,
                      1.90020028, 1.08266994, 1.20588153, 1.40730214, 4.34320304, 1.71762330,
                      1.06620797, 1.39695239, 1.03024563, 3.94971225, 5.02945862, 1.06145571,
                      1.42511911, 2.13889169, 1.04986044, 1.91400616, 5.50708156, 1.52870464,
                      1.11303137, 1.05282759, 1.83793940, 3.05244089, 2.64499634, 1.51688076,
                      2.63350152, 1.31014486, 1.69462474, 1.67792130, 1.34236945, 1.02358460,
                      1.04593509, 1.04007620, 1.87990081, 1.28585413, 1.01636283, 3.55338495,
                      1.19542700, 1.23630628, 1.32321942, 4.03762786, 1.25379147, 1.12330233,
                      1.24966418, 1.26323243, 1.14779989, 1.20378343, 1.01531796, 1.44500318,
                      1.72723672, 15.68799957, 1.37641063, 7.00788166, 3.89674130, 1.68303382,
                      1.10089816, 1.72831362, 2.70479861, 1.75821836, 2.32404215, 2.64165162,
                      1.42441301, 1.83256456, 1.12548819, 4.81273800, 2.52840227, 2.68430190,
                      1.00928919, 1.02438446, 1.33909276, 2.32261242, 1.01299124, 1.07614975,
                      1.66823898, 1.97172786, 1.01707292, 1.68325092, 1.76834032, 1.08952069,
                      1.02265517, 1.96843176, 1.83351706, 1.92704772, 18.44811035, 1.00178046,
                      2.70555953, 1.35839004, 1.04834633, 1.26649072, 2.87152600, 4.12536409,
                      1.25200853, 1.71199647, 1.61175739, 1.26313274, 1.75224120, 2.70412800,
                      1.33998630, 1.61271556, 2.65784769, 10.38771107, 1.33121364, 1.01207979,
                      2.00238212, 2.50195600, 1.96917548, 1.71618169, 1.37050585, 10.11861690,
                      1.18339112, 1.80083386, 2.88582103, 1.21935761, 2.37900131, 1.49449487,
                      4.75106319, 2.33977804, 2.87963540, 1.01807103, 3.74847411, 1.71981276,
                      1.50726964, 1.20723219, 1.37904840, 1.04565533, 1.59877004, 1.11481349,
                      2.17320556, 2.07108468, 1.23274077, 1.75180110, 1.27558910, 1.63240839,
                      1.58760550, 1.01266256, 1.30395323, 1.14618521, 1.02385023, 2.24198100,
                      1.26765471, 1.15855534, 1.83936251, 1.32970987, 1.25844192, 1.31133485,
                      4.74300303, 6.19325623, 1.31832913, 3.97645560, 1.00545340, 1.24431862,
                      1.25855820, 1.15514241, 1.35986865, 1.72446070, 1.13069572, 2.45890932,
                      1.00394684, 1.03533631, 1.87698184, 2.34576160, 1.03997887, 1.02694456,
                      2.52227100, 2.66278467, 1.17002905, 3.42239624, 2.46753038, 1.17103623,
                      1.07832850, 1.42782632, 1.29110546, 1.03435772, 1.33512109, 1.14337058,
                      1.34103634, 1.15155161, 2.59805360, 2.09650343, 1.53399143, 1.02319185,
                      1.32210667, 1.05720671, 1.20882651, 2.34881662, 1.05163662, 3.26219380,
                      10.58124156, 1.07283644, 1.02105339, 1.23268679, 1.81469813, 1.49393533,
                      1.29760853, 5.37676625, 1.02529938, 1.86815537, 1.57961476, 3.77408176,
                      2.79405589, 3.25246617, 1.63913824, 3.12133428, 1.03787574, 4.17232960,
                      1.33406468, 1.57119541, 1.13675102, 3.42874720, 1.13066210, 1.33896458,
                      1.23883935, 1.35272696, 1.15172654, 2.18633755, 1.23251881, 1.59742606,
                      1.08718410, 1.06168544, 1.19926517, 1.00214807, 1.29121086, 3.44575916,
                      1.26524744, 1.16718301, 4.11789988, 1.25375574, 1.35753968, 1.69247751,
                      1.28473150, 2.20669768, 1.53213883, 2.30598771, 1.68420243, 1.37320685,
                      2.08619411, 1.26990265, 1.82215898, 1.10656122, 1.40229835, 1.11896817,
                      1.00127366, 2.88218857, 2.79105702, 1.28699225, 1.15929737, 1.07928363,
                      10.54130128, 8.79261793, 1.15699405, 1.69050500, 2.76586152, 1.22802809,
                      1.38014655, 2.19208585, 1.64409370, 1.46918371, 2.99582898, 1.37759923,
                      1.29776632, 1.82884215, 2.67317357, 1.37063041, 1.26884340, 1.07874723,
                      1.48172681, 1.01771849, 2.40642202, 1.37115433, 1.05954574, 2.12998246,
                      2.34178079, 1.54515623, 1.00179963, 2.12228030, 1.46007334, 1.20664530,
                      1.31417158, 1.03322353, 1.95420119, 1.30541569, 1.15016102, 2.17036908,
                      2.81707947, 1.16173181, 2.01742565, 1.02478594, 1.57428560, 1.21209176,
                      2.20735202, 1.12935761, 2.08850147, 1.05353378, 1.02324910, 1.49636415,
                      1.48061026, 2.25651770, 3.04296168, 1.24380806, 1.07707360, 2.00284318,
                      10.02810932, 3.38695326, 6.82841534, 2.13556915, 1.19152238
                    };

    igraph_vector_view(&vector, data, sizeof(data) / sizeof(data[0]));

    /* determining xmin and alpha */
    if (igraph_power_law_fit(&vector, &result, -1, 0)) {
        return 1;
    }
    print_result(&result);

    /* determining alpha only */
    if (igraph_power_law_fit(&vector, &result, 2, 0)) {
        return 2;
    }
    print_result(&result);

    return 0;
}

int test_discrete() {
    igraph_plfit_result_t result;
    igraph_vector_t vector;
    double data[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
                      2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 4, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 2, 5, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1,
                      1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1,
                      1, 1, 1, 1, 1, 1, 6, 1, 1, 5, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 4, 1, 1, 1,
                      1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1,
                      1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1,
                      1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1,
                      1, 2, 1, 4, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 4, 1, 1, 14, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 2,
                      1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1,
                      1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 4, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 4, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 2, 5, 1, 1, 5, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 2, 1, 3, 1, 1,
                      2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1,
                      2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1, 1,
                      1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 2, 1, 2,
                      1, 1, 1, 1, 2, 11, 1, 33, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2,
                      2, 1, 1, 1, 2, 2, 1, 1, 1, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1, 1, 1, 2, 1, 1, 3, 1, 1, 2, 1, 1, 1, 1, 1,
                      1, 1, 2, 1, 2, 1, 1, 12, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1,
                      3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 2, 1, 4, 1, 1, 1, 1, 1,
                      1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,
                      1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                      1, 2, 2, 2, 2, 1, 1, 1, 4, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
                      3, 2, 1, 1, 1, 2
                    };

    igraph_vector_view(&vector, data, sizeof(data) / sizeof(data[0]));

    /* determining xmin and alpha */
    if (igraph_power_law_fit(&vector, &result, -1, 0)) {
        return 3;
    }
    print_result(&result);

    /* determining alpha only */
    if (igraph_power_law_fit(&vector, &result, 2, 0)) {
        return 4;
    }
    print_result(&result);

    /* forcing continuous fitting */
    if (igraph_power_law_fit(&vector, &result, -1, 1)) {
        return 5;
    }
    print_result(&result);

    /* forcing continuous fitting, xmin given */
    if (igraph_power_law_fit(&vector, &result, 2, 1)) {
        return 6;
    }
    print_result(&result);

    return 0;
}

int main() {
    int retval;

    retval = test_continuous();
    if (retval) {
        return retval;
    }

    retval = test_discrete();
    if (retval) {
        return retval;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_power_law_fit.out0000644000175100001710000000121700000000000027706 0ustar00runnerdocker00000000000000continuous = true
alpha = 2.81976
xmin = 1.00979
L = -946.14703
D = 0.01454
p = 0.98534
====================
continuous = true
alpha = 2.81157
xmin = 2.00000
L = -463.92064
D = 0.05091
p = 0.46011
====================
continuous = false
alpha = 3.11405
xmin = 1.00000
L = -622.60933
D = 0.00941
p = 0.99999
====================
continuous = false
alpha = 3.27157
xmin = 2.00000
L = -185.83215
D = 0.04504
p = 0.90572
====================
continuous = true
alpha = 3.77550
xmin = 11.00000
L = -13.68681
D = 0.15260
p = 0.99982
====================
continuous = true
alpha = 5.26868
xmin = 2.00000
L = -75.22503
D = 0.70253
p = 0.00000
====================
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_radius.c0000644000175100001710000000273100000000000025751 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sts=4 sw=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_real_t radius;

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_radius(&g, &radius, IGRAPH_OUT);
    if (radius != 1) {
        return 1;
    }
    igraph_destroy(&g);

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_radius(&g, &radius, IGRAPH_ALL);
    if (radius != 1) {
        return 2;
    }
    igraph_destroy(&g);

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_radius(&g, &radius, IGRAPH_OUT);
    if (radius != 0) {
        return 3;
    }
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_random_sample.c0000644000175100001710000001424100000000000027302 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for random sampling.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 
#include 
#include 

#define R_INTEGER(a,b) (igraph_rng_get_integer(igraph_rng_default(), (a), (b)))

/* test parameters */
typedef struct {
    igraph_integer_t low;
    igraph_integer_t high;
    igraph_integer_t length;
    int retval;
} sampling_test_t;

/* Error tests. Don't be afraid to crash the library function.
 */
int error_test() {
    igraph_vector_t V;
    int i, n, ret;
    sampling_test_t *test;

    igraph_rng_seed(igraph_rng_default(), 42); /* make tests deterministic */
    igraph_vector_init(&V, /*size*/ 0);

    /* test parameters */
    /*----------low----high----length----retval----------*/
    /* lower limit is greater than upper limit */
    sampling_test_t lower_bigger = {300, 200, 10, IGRAPH_EINVAL};
    /* sample size is greater than size of candidate pool */
    sampling_test_t sample_size_bigger = {200, 300, 500, IGRAPH_EINVAL};

    sampling_test_t *all_checks[] = {/* 1 */ &lower_bigger,
                                     /* 2 */ &sample_size_bigger};

    /* failure is the mother of success */
    igraph_set_error_handler(igraph_error_handler_ignore);
    n = 2;
    for (i = 0; i < n; i++) {
        test = all_checks[i];
        ret = igraph_random_sample(&V, test->low, test->high, test->length);
        if (ret != test->retval) {
            printf("Error test no. %d failed.\n", (int)(i + 1));
            return IGRAPH_FAILURE;
        }
    }
    igraph_set_error_handler(igraph_error_handler_abort);

    igraph_vector_destroy(&V);

    return IGRAPH_SUCCESS;
}

/* Get a few random samples and test their properties.
 */
int random_sample_test() {
    const igraph_integer_t min = -1000;
    const igraph_integer_t max = 1000;
    igraph_integer_t low;       /* lower limit */
    igraph_integer_t high;      /* upper limit */
    igraph_integer_t length;    /* sample size */
    igraph_integer_t poolsize;  /* size of candidate pool */
    igraph_real_t sP;           /* population total sum */
    igraph_real_t ss;           /* sample total sum */
    igraph_vector_t V;
    int i;

    igraph_rng_seed(igraph_rng_default(), 57); /* make tests deterministic */

    /* The generated sequence of numbers must be in increasing order. */
    igraph_vector_init(&V, /*size*/ 0);
    do {
        high = (igraph_integer_t)R_INTEGER(min, max);
    } while (high == min);
    do {
        low = (igraph_integer_t)R_INTEGER(min, max);
    } while (low >= high);
    poolsize = (igraph_integer_t)fabs((double)high - (double)low);
    do {
        length = (igraph_integer_t)R_INTEGER(1, max);
    } while (length > poolsize);
    igraph_random_sample(&V, low, high, length);
    if (length != igraph_vector_size(&V)) {
        printf("Requested vector length and resulting length mismatch.\n");
        return IGRAPH_FAILURE;
    }
    for (i = 0; i < length - 1; i++) {
        if (VECTOR(V)[i] >= VECTOR(V)[i + 1]) {
            printf("Sample not in increasing order.\n");
            return IGRAPH_FAILURE;
        }
    }
    igraph_vector_destroy(&V);

    /* Let P be a candidate pool of positive integers with total sum s_P. */
    /* Let S be a random sample from P and having total sum s_S. Then we */
    /* have the bound s_s <= s_P. */
    igraph_vector_init(&V, /*size*/ 0);
    low = 1;
    do {
        high = (igraph_integer_t)R_INTEGER(low, max);
    } while (high == low);
    poolsize = (igraph_integer_t)fabs((double)high - (double)low);
    do {
        length = (igraph_integer_t)R_INTEGER(low, max);
    } while (length > poolsize);
    igraph_random_sample(&V, low, high, length);
    /* Use Gauss' formula to sum all consecutive positive integers from 1 */
    /* up to and including an upper limit. In LaTeX, Gauss' formula is */
    /* \sum_{i=1}^n i = \frac{n(n+1)}{2} where n is the upper limit. */
    sP = (high * (high + 1)) / 2;
    ss = igraph_vector_sum(&V);
    if (ss > sP) {
        printf("Sum of sampled sequence exceeds sum of whole population.\n");
        return IGRAPH_FAILURE;
    }
    igraph_vector_destroy(&V);

    return IGRAPH_SUCCESS;
}

int equal_test() {
    igraph_vector_t V;
    int i;

    igraph_vector_init(&V, 0);

    igraph_random_sample(&V, 0, 0, 1);
    if (igraph_vector_size(&V) != 1) {
        return 1;
    }
    if (VECTOR(V)[0] != 0) {
        return 2;
    }

    igraph_random_sample(&V, 10, 10, 1);
    if (igraph_vector_size(&V) != 1) {
        return 3;
    }
    if (VECTOR(V)[0] != 10) {
        return 4;
    }

    igraph_random_sample(&V, 2, 12, 11);
    if (igraph_vector_size(&V) != 11) {
        return 5;
    }
    for (i = 0; i < 11; i++)
        if (VECTOR(V)[i] != i + 2) {
            return 6;
        }

    igraph_vector_destroy(&V);
    return 0;
}

int rare_test() {
    igraph_vector_t V;

    igraph_vector_init(&V, 0);

    igraph_random_sample(&V, 0, 0, 1);
    if (igraph_vector_size(&V) != 1) {
        return 1;
    }
    if (VECTOR(V)[0] != 0) {
        return 2;
    }

    igraph_random_sample(&V, 10, 10, 1);
    if (igraph_vector_size(&V) != 1) {
        return 3;
    }
    if (VECTOR(V)[0] != 10) {
        return 4;
    }

    igraph_vector_destroy(&V);
    return 0;
}

int main() {
    int ret;

    ret = error_test();
    if (ret) {
        return 1;
    }
    ret = random_sample_test();
    if (ret) {
        return 2;
    }
    ret = equal_test();
    if (ret) {
        return 3;
    }
    ret = rare_test();
    if (ret) {
        return 4;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_dl.c0000644000175100001710000000377200000000000027243 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

int main() {

    const char *files[] = { "fullmatrix1.dl", "fullmatrix2.dl",
                            "fullmatrix3.dl", "fullmatrix4.dl",
                            "edgelist1.dl", "edgelist2.dl", "edgelist3.dl",
                            "edgelist4.dl", "edgelist5.dl", "edgelist6.dl",
                            "edgelist7.dl", "nodelist1.dl", "nodelist2.dl"
                          };
    int no_files = sizeof(files) / sizeof(const char*);
    int i, ret;
    igraph_t g;
    FILE *infile;

    for (i = 0; i < no_files; i++) {
        printf("Doing %s\n", files[i]);
        infile = fopen(files[i], "r");
        if (!infile) {
            printf("Cannot open file: %s\n", files[i]);
            exit(1 + i);
        }
        igraph_read_graph_dl(&g, infile, /*directed=*/ 1);
        ret = fclose(infile);
        if (ret) {
            printf("Cannot close file: %s\n", files[i]);
            exit(101 + i);
        }
        igraph_write_graph_edgelist(&g, stdout);
        igraph_destroy(&g);
    }

    if (IGRAPH_FINALLY_STACK_SIZE() != 0) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_dl.out0000644000175100001710000000115300000000000027617 0ustar00runnerdocker00000000000000Doing fullmatrix1.dl
0 1
0 2
0 3
0 4
1 0
1 2
2 0
2 1
2 4
3 0
4 0
4 2
Doing fullmatrix2.dl
0 1
0 2
0 3
1 0
1 4
2 0
2 3
3 0
3 2
3 4
4 1
4 3
Doing fullmatrix3.dl
0 1
0 2
0 3
1 0
1 4
2 0
2 3
3 0
3 2
3 4
4 1
4 3
Doing fullmatrix4.dl
0 1
0 2
0 3
1 0
1 4
2 0
2 3
3 0
3 2
3 4
4 1
4 3
Doing edgelist1.dl
0 1
0 2
1 2
2 0
3 2
Doing edgelist2.dl
0 1
0 2
1 2
3 0
4 2
Doing edgelist3.dl
0 1
0 2
1 2
3 0
4 2
Doing edgelist4.dl
0 1
0 2
1 2
2 0
3 2
Doing edgelist5.dl
0 1
0 2
1 2
3 0
4 2
Doing edgelist6.dl
0 1
0 2
1 2
3 0
4 2
Doing edgelist7.dl
0 1
1 2
1 3
Doing nodelist1.dl
0 1
0 2
1 2
2 0
3 2
Doing nodelist2.dl
0 1
0 2
1 2
3 0
4 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_graphdb.c0000644000175100001710000000225500000000000030246 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    FILE *input;

    input = fopen("iso_b03_m1000.A00", "rb");
    if (!input) {
        return 1;
    }
    igraph_read_graph_graphdb(&g, input, IGRAPH_DIRECTED);
    fclose(input);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_graphdb.out0000644000175100001710000002662600000000000030643 0ustar00runnerdocker000000000000000 723
1 37
1 951
3 310
3 439
4 64
4 873
6 875
7 617
8 0
8 429
9 711
10 181
10 184
11 257
11 262
11 365
12 400
12 781
13 61
13 482
13 963
15 68
15 567
16 649
17 93
17 355
18 32
18 503
19 53
19 360
19 646
20 71
20 220
21 900
21 909
22 552
22 778
25 623
25 731
27 232
28 293
28 378
29 179
30 542
30 713
31 535
32 312
33 246
33 828
33 868
34 230
35 382
35 519
36 321
37 767
38 216
38 658
39 400
39 889
40 352
40 941
41 60
41 540
42 680
44 280
44 734
45 520
46 302
46 940
46 959
47 928
49 149
50 29
50 216
50 658
52 758
53 455
53 514
54 500
55 51
55 506
56 647
57 352
57 821
58 945
58 953
59 320
59 393
60 157
62 200
62 669
64 886
65 69
65 638
66 390
66 537
67 981
69 42
70 7
70 759
70 991
71 244
72 137
72 450
72 932
73 980
74 819
75 508
75 973
76 295
76 573
76 838
78 778
79 290
79 627
80 981
81 712
82 907
83 17
83 109
83 125
85 97
86 239
86 390
86 850
87 185
87 260
87 652
88 24
88 522
88 614
89 682
90 302
92 164
95 465
95 601
96 23
96 822
97 895
98 195
98 241
98 899
99 367
99 392
99 749
101 811
102 696
103 423
104 55
104 147
104 879
105 68
105 161
105 931
106 318
106 379
107 20
107 816
108 240
108 718
108 883
109 355
110 130
110 337
111 89
111 499
112 91
112 236
112 835
113 217
113 668
113 675
114 199
114 453
114 830
115 607
116 854
117 651
117 710
118 100
118 511
119 347
119 812
120 490
121 521
121 632
121 982
122 16
122 130
124 251
124 644
124 986
126 26
126 727
126 918
127 437
128 194
128 327
129 595
129 639
131 488
131 708
132 60
132 538
133 5
133 203
134 179
134 258
134 913
135 271
135 842
136 696
136 858
136 937
137 273
138 930
139 432
139 654
139 959
140 329
141 627
141 923
144 715
144 939
145 513
145 967
147 2
147 51
148 704
148 746
150 944
151 358
151 611
152 460
154 77
155 190
155 953
156 441
156 962
156 997
157 833
158 508
158 973
159 4
159 423
162 495
162 995
163 173
164 146
165 142
165 187
165 928
166 676
166 804
167 177
167 377
168 175
168 410
170 917
171 473
172 898
173 880
174 177
175 579
175 779
176 243
176 500
178 24
178 84
180 201
180 341
180 813
181 876
182 106
183 202
185 417
185 894
187 47
188 263
188 275
188 786
189 460
189 683
190 58
190 576
191 116
191 324
192 424
192 464
192 670
193 614
193 697
194 829
195 370
196 132
196 952
197 49
197 511
198 506
198 633
200 158
200 775
201 433
201 780
202 394
202 632
203 267
203 855
204 214
204 805
205 990
206 577
206 806
207 705
208 804
209 700
210 764
211 210
212 560
212 575
212 899
213 817
214 110
215 62
215 556
216 664
217 471
219 381
219 645
219 653
221 103
221 409
221 873
222 123
222 420
223 838
224 371
225 479
225 840
226 513
226 761
226 967
228 128
228 346
228 489
229 218
229 459
230 218
230 459
231 135
231 845
232 943
233 391
233 446
234 275
234 786
235 384
235 993
236 635
236 882
237 163
237 824
238 138
238 808
240 259
241 350
241 543
242 238
242 272
243 54
243 319
244 220
244 761
245 628
245 872
246 341
247 273
248 263
248 691
249 752
250 161
251 227
252 565
253 97
253 251
253 414
254 225
254 789
255 407
255 451
256 183
257 457
259 590
260 672
260 894
261 623
262 390
263 527
264 684
265 821
266 507
266 815
267 5
267 307
268 111
268 856
269 616
270 261
270 693
270 742
271 845
272 808
272 935
274 45
274 998
276 16
276 130
277 224
278 572
279 608
279 630
281 207
282 440
283 34
283 117
285 674
286 952
287 73
287 358
288 737
289 933
290 174
291 758
292 283
293 434
293 655
294 38
296 300
297 322
297 892
298 154
299 515
299 864
300 960
301 222
303 127
303 288
303 978
304 314
304 557
305 936
306 9
306 94
307 301
307 420
309 997
310 856
311 634
312 921
313 865
314 450
315 186
315 249
316 199
317 659
318 28
318 434
319 578
319 849
321 205
322 142
322 187
323 618
323 774
324 211
325 699
325 753
325 758
326 399
327 489
328 170
328 597
329 621
330 887
331 64
331 167
332 240
332 883
333 122
333 155
333 649
334 329
335 561
335 608
335 985
336 825
337 276
338 51
338 506
338 891
339 446
339 536
340 107
340 630
342 48
342 61
343 84
343 406
343 533
344 696
345 936
346 920
348 502
348 985
350 575
351 559
351 799
352 265
353 677
353 948
354 718
356 653
356 655
357 661
359 138
359 242
360 455
362 82
362 486
363 285
363 345
363 925
364 289
364 686
364 898
366 504
366 866
366 885
368 92
369 211
370 628
370 897
371 868
372 6
372 993
373 357
373 799
374 68
374 161
375 213
375 636
376 977
377 620
378 653
379 277
380 24
380 84
380 533
382 186
382 320
383 341
383 813
384 372
384 875
385 626
386 127
386 288
386 621
387 103
387 409
388 481
388 870
389 153
389 388
391 339
393 151
393 287
394 481
395 280
396 208
396 890
397 408
398 0
398 846
399 264
399 974
401 74
402 898
403 229
404 160
404 412
405 404
405 915
406 321
407 869
407 948
411 518
411 541
411 994
412 818
413 63
414 85
414 227
415 143
415 580
415 764
416 96
416 385
417 347
417 812
418 77
418 298
418 619
419 266
420 5
421 143
422 514
424 633
426 171
426 785
427 40
427 52
427 265
430 512
431 474
431 881
432 90
434 182
435 249
435 487
436 129
436 751
437 334
437 621
438 444
439 466
439 983
440 120
440 146
441 295
441 309
442 419
442 507
442 867
443 848
444 381
444 572
445 324
445 369
445 954
447 397
447 798
448 182
448 224
448 379
449 170
450 273
452 629
452 656
452 933
453 488
453 708
454 80
454 472
454 765
455 730
456 56
457 89
457 499
458 22
458 78
459 839
461 360
461 730
462 137
462 247
463 101
463 368
464 528
465 747
466 391
466 531
467 304
467 693
468 181
468 184
468 826
469 6
469 498
470 523
470 878
471 675
471 995
472 776
472 919
473 740
474 347
474 666
475 397
475 798
476 401
476 518
477 532
477 981
478 172
478 402
480 754
481 153
482 342
482 610
483 152
483 612
483 741
484 18
484 724
484 796
485 892
485 938
486 323
486 907
487 315
490 282
491 61
491 902
492 421
492 550
493 330
493 701
494 827
495 996
496 750
496 904
497 745
497 950
500 629
501 493
501 871
502 239
503 724
503 905
504 308
504 430
505 346
505 489
507 725
508 775
509 331
509 377
509 886
510 91
510 150
511 149
512 308
512 549
514 646
515 94
515 801
516 465
516 601
517 271
517 361
518 906
519 320
521 256
522 193
523 37
524 769
524 809
524 969
525 969
526 23
526 416
527 275
527 691
528 424
529 100
529 428
529 494
530 389
531 233
531 983
532 67
532 485
533 984
534 21
534 460
534 683
536 462
537 262
537 365
538 157
539 27
540 145
540 662
541 866
542 714
543 195
544 220
544 967
545 35
545 186
545 487
546 635
546 732
547 387
547 681
547 900
548 141
548 988
549 359
549 930
550 39
551 208
551 890
552 823
552 939
553 269
554 362
554 478
555 464
555 667
556 928
557 693
558 565
560 349
560 525
561 279
562 298
562 974
563 559
563 799
564 517
565 859
566 648
567 759
568 539
568 660
569 566
569 602
569 659
570 120
570 146
571 7
571 398
572 877
573 223
574 9
575 525
576 848
578 654
579 410
579 908
580 421
581 741
582 739
582 943
583 305
584 539
584 660
584 726
585 206
586 610
587 204
587 687
588 376
588 480
588 859
589 282
589 425
589 690
590 354
591 78
591 330
592 947
593 578
593 849
593 926
594 1
594 523
595 422
595 646
597 449
597 687
598 210
598 369
599 194
599 367
600 231
600 305
601 688
602 317
603 618
604 596
604 927
605 168
605 694
605 745
606 43
606 344
607 698
607 737
608 348
609 336
610 48
611 59
611 519
612 581
612 862
613 173
613 237
613 609
614 178
615 577
615 851
616 306
616 574
617 863
619 562
619 684
620 177
620 290
622 590
622 732
624 902
624 963
624 988
625 82
625 172
625 554
626 596
627 174
628 965
629 976
630 782
631 559
631 837
632 256
633 670
634 827
635 622
637 692
638 42
639 422
640 313
640 832
640 982
641 280
641 505
642 456
642 637
642 647
643 522
644 227
644 698
645 356
648 45
648 966
649 953
650 73
650 250
651 34
651 218
652 443
652 672
655 378
656 289
656 976
657 302
657 395
659 840
660 643
661 910
662 513
663 469
663 875
663 884
664 26
664 294
665 133
665 603
666 119
666 881
667 435
667 752
668 413
668 802
669 47
669 556
670 891
671 470
671 637
673 255
673 677
673 948
674 209
674 345
675 413
676 14
676 831
678 392
678 749
679 311
679 964
681 409
682 268
682 310
685 376
685 480
685 795
686 402
687 695
688 837
689 535
689 847
690 490
690 716
691 75
692 456
692 946
694 410
694 497
695 328
697 568
697 643
699 140
699 334
700 123
700 285
701 591
702 91
702 150
702 835
703 101
704 615
704 999
705 433
705 780
706 400
706 550
706 781
707 10
707 869
707 888
708 797
709 30
709 43
710 292
710 729
711 94
711 299
712 277
712 371
713 43
714 743
715 821
715 922
716 403
716 425
717 553
718 259
719 26
719 294
719 727
720 154
720 510
721 902
721 988
722 340
722 782
722 816
723 429
723 832
724 968
725 647
725 815
726 27
726 793
727 284
728 164
728 570
728 958
729 581
729 862
730 235
731 261
731 742
732 354
733 169
733 281
733 803
734 395
735 171
735 596
735 785
736 118
736 149
736 844
737 978
738 528
738 555
739 196
739 538
740 426
740 746
742 557
743 357
744 542
744 709
744 792
745 160
747 592
748 760
748 784
748 990
749 599
750 586
751 153
751 530
752 738
753 140
753 291
754 677
754 795
755 636
755 678
755 756
756 375
756 392
757 179
757 258
759 617
760 36
760 205
761 544
762 246
762 383
763 566
763 602
763 966
765 23
766 14
766 717
766 971
769 361
769 564
770 63
770 463
770 703
771 214
771 337
772 269
772 574
772 971
773 548
773 721
774 603
774 855
775 215
776 80
776 477
777 317
777 479
778 701
779 197
780 281
781 431
782 561
783 25
783 258
783 913
784 85
784 895
785 604
787 143
787 598
787 764
788 199
788 638
788 957
789 2
789 479
790 606
790 713
791 381
791 438
791 645
792 714
792 910
793 232
793 286
794 223
794 872
795 353
796 968
797 234
798 326
800 473
800 746
801 274
802 63
802 703
803 207
803 871
804 831
805 771
805 807
807 587
807 695
808 125
809 349
809 361
810 131
810 786
810 797
811 368
811 958
813 433
814 152
814 189
814 741
815 56
816 71
817 74
817 906
818 93
818 405
819 213
819 636
820 296
820 975
822 385
822 927
823 144
823 922
824 296
824 975
825 768
826 102
827 934
828 81
828 762
829 327
829 367
830 316
830 488
831 396
832 865
833 41
833 662
834 29
834 658
834 757
835 882
836 31
836 585
836 806
837 95
839 403
839 425
840 777
841 313
841 521
842 583
842 600
843 428
843 494
843 634
844 100
844 428
845 564
846 8
847 332
847 857
848 672
849 54
850 66
850 502
851 148
851 800
852 516
852 747
852 947
853 336
853 768
854 284
854 954
855 665
856 942
857 535
858 102
860 419
860 750
861 408
861 475
861 592
862 292
863 571
863 846
864 801
864 998
865 429
866 994
867 496
867 860
868 81
869 451
870 183
870 394
871 169
872 965
873 423
874 31
874 689
874 806
876 826
876 858
877 438
877 929
878 594
879 2
879 254
880 609
880 825
881 12
882 546
883 857
884 498
885 430
885 541
886 159
887 169
887 501
888 184
888 451
889 492
889 580
890 278
891 198
892 67
893 768
893 956
893 979
894 812
896 257
896 365
896 499
897 543
899 350
901 14
901 166
901 717
903 247
903 446
903 536
904 48
904 586
905 32
906 401
907 618
908 49
908 779
909 683
909 912
910 743
911 123
911 209
911 301
912 681
912 900
913 623
914 162
914 498
915 93
915 355
916 245
916 794
916 838
917 968
918 116
918 284
919 526
919 765
920 44
920 641
921 300
921 820
922 57
923 79
923 773
924 351
924 631
924 688
925 583
925 936
926 432
926 654
927 626
929 278
929 551
930 308
931 15
931 991
932 314
932 467
933 686
934 311
934 964
935 109
935 125
937 344
937 790
938 142
938 297
939 458
940 657
940 734
941 52
941 291
942 3
943 286
944 77
944 720
945 443
945 576
946 671
946 878
947 408
949 217
949 495
950 160
950 412
951 309
951 767
952 582
954 191
955 650
956 252
956 558
957 65
957 316
958 92
959 90
960 312
960 905
961 264
961 326
961 447
962 295
962 573
963 491
964 680
965 897
966 520
969 349
970 69
970 679
970 680
971 553
972 436
972 530
972 639
973 248
974 684
975 163
976 176
977 252
977 859
978 115
979 558
979 853
980 358
980 955
982 841
983 942
984 36
984 406
985 239
986 115
986 698
987 449
987 796
987 917
989 250
989 374
989 955
990 895
991 567
992 373
992 563
992 661
993 461
994 476
995 949
996 884
996 914
997 767
998 520
999 577
999 585
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_lgl-1.lgl0000644000175100001710000000005200000000000030100 0ustar00runnerdocker00000000000000# foo
bar
foobar 5
# foobar
bat
tab
# tab
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_lgl-2.lgl0000644000175100001710000000005700000000000030106 0ustar00runnerdocker00000000000000# foo
bar 1
foobar 2
# foobar
bat 10
tab
# tab
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_lgl-3.lgl0000644000175100001710000000001200000000000030076 0ustar00runnerdocker00000000000000#
1
# 1
2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_lgl.c0000644000175100001710000000443100000000000027413 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R package.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    FILE *input;

    /* Without names and weights */
    input = fopen("igraph_read_graph_lgl-1.lgl", "r");
    if (!input) {
        return 1;
    }
    igraph_read_graph_lgl(&g, input, 0, IGRAPH_ADD_WEIGHTS_NO, 1);
    fclose(input);
    if (!igraph_is_directed(&g)) {
        return 2;
    }
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    /* With names and weights */
    input = fopen("igraph_read_graph_lgl-2.lgl", "r");
    if (!input) {
        return 3;
    }
    igraph_read_graph_lgl(&g, input, 0, IGRAPH_ADD_WEIGHTS_NO, 1);
    fclose(input);
    if (!igraph_is_directed(&g)) {
        return 4;
    }
    igraph_write_graph_ncol(&g, stdout, 0, 0);
    igraph_destroy(&g);

    /* Same graph, but forcing undirected mode */
    input = fopen("igraph_read_graph_lgl-2.lgl", "r");
    igraph_read_graph_lgl(&g, input, 0, IGRAPH_ADD_WEIGHTS_NO, 0);
    fclose(input);
    if (igraph_is_directed(&g)) {
        return 5;
    }
    igraph_write_graph_ncol(&g, stdout, 0, 0);
    igraph_destroy(&g);

    /* Erroneous LGL file (empty vertex name) */
    input = fopen("igraph_read_graph_lgl-3.lgl", "r");
    if (!input) {
        return 6;
    }
    igraph_set_error_handler(igraph_error_handler_ignore);
    if (igraph_read_graph_lgl(&g, input, 0, IGRAPH_ADD_WEIGHTS_NO, 1) !=
        IGRAPH_PARSEERROR) {
        return 7;
    }
    fclose(input);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_read_graph_lgl.out0000644000175100001710000000006000000000000027772 0ustar00runnerdocker000000000000000 1
0 2
2 3
2 4
0 1
0 2
2 3
2 4
0 1
0 2
2 3
2 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_reciprocity.c0000644000175100001710000000340200000000000027012 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    igraph_t g;
    igraph_real_t res;

    /* Trivial cases */

    igraph_ring(&g, 100, IGRAPH_UNDIRECTED, 0, 0);
    igraph_reciprocity(&g, &res, 0, IGRAPH_RECIPROCITY_DEFAULT);
    igraph_destroy(&g);

    if (res != 1) {
        return 1;
    }

    /* Small test graph */

    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0,  1,  0,  2,  0,  3,  1,  0,  2,  3,  3,  2, -1);

    igraph_reciprocity(&g, &res, 0, IGRAPH_RECIPROCITY_RATIO);
    igraph_destroy(&g);

    if (res != 0.5) {
        fprintf(stderr, "%f != %f\n", res, 0.5);
        return 2;
    }

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 1, -1);
    igraph_reciprocity(&g, &res, 0, IGRAPH_RECIPROCITY_DEFAULT);
    igraph_destroy(&g);

    if (fabs(res - 2.0 / 3.0) > 1e-15) {
        fprintf(stderr, "%f != %f\n", res, 2.0 / 3.0);
        return 3;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_ring.c0000644000175100001710000000266300000000000025425 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;

    /* Create a directed path graph on 10 vertices. */
    igraph_ring(&graph, 10, IGRAPH_DIRECTED, /* mutual= */ 0, /* circular= */ 0);

    /* Output the edge list of the graph. */
    printf("10-path graph:\n");
    igraph_write_graph_edgelist(&graph, stdout);

    /* Destroy the graph. */
    igraph_destroy(&graph);

    /* Create a 4-cycle graph. */
    igraph_ring(&graph, 4, IGRAPH_UNDIRECTED, /* mutual= */ 0, /* circular= */ 1);

    /* Output the edge list of the graph. */
    printf("\n4-cycle graph:\n");
    igraph_write_graph_edgelist(&graph, stdout);

    /* Destroy the graph. */
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_ring.out0000644000175100001710000000012300000000000025777 0ustar00runnerdocker0000000000000010-path graph:
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9

4-cycle graph:
0 1
0 3
1 2
2 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_roulette_wheel_imitation.c0000644000175100001710000002670400000000000031574 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for stochastic imitation via roulette wheel selection.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 
#include 

#define R_INTEGER(a,b) (igraph_rng_get_integer(igraph_rng_default(), (a), (b)))

/* test parameters structure */
typedef struct {
    igraph_t *graph;
    igraph_integer_t vertex;
    igraph_bool_t islocal;
    igraph_vector_t *quantities;
    igraph_vector_t *strategies;
    igraph_vector_t *known_strats;
    igraph_neimode_t mode;
    int retval;
} strategy_test_t;

/* Error tests. That is, we expect error codes to be returned from such tests.
 */
int error_tests() {
    igraph_t g, gzero, h;
    igraph_vector_t quant, quantzero, strat, stratzero;
    int i, n, nvert, ret;
    strategy_test_t *test;

    /* nonempty graph */
    igraph_small(&g, /*nvert=*/ 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    igraph_empty(&h, 0, 0);         /* empty graph */
    igraph_vector_init(&quant, 1);  /* quantities vector */
    igraph_vector_init(&strat, 2);  /* strategies vector */
    igraph_small(&gzero, /*nvert=*/ 0, IGRAPH_UNDIRECTED,
                 0, 3, 0, 4, 1, 2, 1, 4, 1, 5, 2, 3, 2, 4, 3, 4, -1);
    nvert = igraph_vcount(&gzero);
    igraph_vector_init_real(&stratzero, nvert, 1.0, 0.0, 1.0, 2.0, 0.0, 3.0);
    igraph_vector_init(&quantzero, nvert);  /* vector of zeros */

    /* test parameters */
    /*graph--vert--islocal--quantities--strategies--known_strats--mode--retval*/
    /* null pointer for graph */
    strategy_test_t null_graph = {NULL, 0, 1, NULL, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for quantities vector */
    strategy_test_t null_quant = {&g, 0, 1, NULL, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for strategies vector */
    strategy_test_t null_strat = {&g, 0, 1, &quant, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* empty graph */
    strategy_test_t empty_graph = {&h, 0, 1, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of quantities vector different from number of vertices */
    strategy_test_t qdiff_length = {&g, 0, 1, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of strategies vector different from number of vertices */
    strategy_test_t sdiff_length = {&g, 0, 1, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* quantities vector contains all zeros */
    strategy_test_t zero_quant = {&gzero, 4, 1, &quantzero, &stratzero, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    strategy_test_t *all_checks[] = {/* 1 */ &null_graph,
                                             /* 2 */ &null_quant,
                                             /* 3 */ &null_strat,
                                             /* 4 */ &empty_graph,
                                             /* 5 */ &qdiff_length,
                                             /* 6 */ &sdiff_length,
                                             /* 7 */ &zero_quant
                                    };

    /* Run the error tests. We expect error to be raised for each test. */
    igraph_set_error_handler(igraph_error_handler_ignore);
    n = 7;
    i = 0;
    while (i < n) {
        test = all_checks[i];
        ret = igraph_roulette_wheel_imitation(test->graph, test->vertex,
                                              test->islocal, test->quantities,
                                              test->strategies, test->mode);
        if (ret != test->retval) {
            printf("Error test no. %d failed.\n", (int)(i + 1));
            return IGRAPH_FAILURE;
        }
        i++;
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_destroy(&gzero);
    igraph_destroy(&h);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&quantzero);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&stratzero);

    return IGRAPH_SUCCESS;
}

/* A game on a graph with 5 vertices and 7 edges. Use roulette wheel selection
 * to update strategies. This example also illustrates how a choice of
 * perspective (whether local or global) could affect the range of
 * possible strategies a vertex could adopt.
 */
int roulette_test() {
    igraph_t g;
    igraph_bool_t success;
    igraph_vector_t *known, quant, strat, stratcopy;
    igraph_vector_t known0, known1, known2, known3, known4, known5;
    int i, k, n, nvert, ret;;
    strategy_test_t *test;

    /* the game network */
    igraph_small(&g, /*nvert=*/ 0, IGRAPH_UNDIRECTED,
                 0, 3, 0, 4, 1, 2, 1, 4, 1, 5, 2, 3, 2, 4, 3, 4, -1);
    nvert = igraph_vcount(&g);
    /* strategies vector; the strategy space is {0, 1, 2, 3} */
    /* V[i] is strategy of vertex i */
    igraph_vector_init_real(&strat, nvert, 1.0, 0.0, 1.0, 2.0, 0.0, 3.0);
    /* quantities vector; V[i] is quantity of vertex i */
    igraph_vector_init_real(&quant, nvert, 0.56, 0.13, 0.26, 0.73, 0.67, 0.82);
    /* possible strategies each vertex can adopt */
    igraph_vector_init_real(&known0, /*n=*/ 3, 0.0, 1.0, 2.0);       /* local */
    igraph_vector_init_real(&known1, /*n=*/ 3, 0.0, 1.0, 3.0);       /* local */
    igraph_vector_init_real(&known2, /*n=*/ 3, 0.0, 1.0, 2.0);       /* local */
    igraph_vector_init_real(&known3, /*n=*/ 3, 0.0, 1.0, 2.0);       /* local */
    igraph_vector_init_real(&known4, /*n=*/ 3, 0.0, 1.0, 2.0);       /* local */
    igraph_vector_init_real(&known5, /*n=*/ 4, 0.0, 1.0, 2.0, 3.0);  /* global */

    /* test parameters */
    /*graph--vert--islocal--quantities--strategies--known_strats--mode-retval*/
    strategy_test_t game0 = {&g, 0, 1, &quant, NULL, &known0, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t game1 = {&g, 1, 1, &quant, NULL, &known1, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t game2 = {&g, 2, 1, &quant, NULL, &known2, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t game3 = {&g, 3, 1, &quant, NULL, &known3, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t game4 = {&g, 4, 1, &quant, NULL, &known4, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t game5 = {&g, 5, 0, &quant, NULL, &known5, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t *all_checks[] = {/* 1 */ &game0,
                                             /* 2 */ &game1,
                                             /* 3 */ &game2,
                                             /* 4 */ &game3,
                                             /* 5 */ &game4,
                                             /* 6 */ &game5
                                    };

    /* play game */
    n = 6;
    i = 0;
    while (i < n) {
        test = all_checks[i];
        igraph_vector_copy(&stratcopy, &strat);
        ret = igraph_roulette_wheel_imitation(test->graph, test->vertex,
                                              test->islocal, test->quantities,
                                              &stratcopy, test->mode);
        if (ret != test->retval) {
            printf("Test no. %d failed.\n", i + 1);
            return IGRAPH_FAILURE;
        }
        /* If the revised strategy s matches one of the candidate strategies, */
        /* then success. If s doesn't match any of the possible strategies, then */
        /* failure. Default to failure. */
        success = 0;
        known = test->known_strats;
        for (k = 0; k < igraph_vector_size(known); k++) {
            if (VECTOR(*known)[k] == VECTOR(stratcopy)[test->vertex]) {
                success = 1;
                break;
            }
        }
        if (!success) {
            printf("Roulette wheel imitation failed for vertex %d.\n",
                   (int)test->vertex);
            return IGRAPH_FAILURE;
        }
        igraph_vector_destroy(&stratcopy);
        i++;
    }
    /* game finished; pack up */
    igraph_destroy(&g);
    igraph_vector_destroy(&known0);
    igraph_vector_destroy(&known1);
    igraph_vector_destroy(&known2);
    igraph_vector_destroy(&known3);
    igraph_vector_destroy(&known4);
    igraph_vector_destroy(&known5);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);

    return IGRAPH_SUCCESS;
}

/* It is possible for a vertex to retain its current strategy. This can
 * happen both in the local and global perspectives.
 */
int retain_strategy_test() {
    igraph_t g;
    igraph_integer_t max, min, v;
    igraph_vector_t quant, strat, stratcp;
    int i, ntry, nvert;

    /* the game network */
    igraph_small(&g, /*nvert=*/ 0, IGRAPH_UNDIRECTED,
                 0, 3, 0, 4, 1, 2, 1, 4, 1, 5, 2, 3, 2, 4, 3, 4, -1);
    nvert = igraph_vcount(&g);
    /* strategies vector; the strategy space is {0, 1, 2, 3} */
    /* V[i] is strategy of vertex i */
    igraph_vector_init_real(&strat, nvert, 1.0, 0.0, 1.0, 2.0, 0.0, 3.0);
    /* quantities vector; V[i] is quantity of vertex i */
    igraph_vector_init_real(&quant, nvert, 0.56, 0.13, 0.26, 0.73, 0.67, 0.82);

    /* random vertex */
    min = 0;
    max = 5;
    igraph_rng_seed(igraph_rng_default(), 42); /* make tests deterministic */
    v = R_INTEGER(min, max);  /* min <= v <= max */
    /* Ensure that it is possible for v to retain its current strategy. We */
    /* will try to do this at most ntry times. As there are at most 6 vertices */
    /* to choose from, it shouldn't take long before we encounter a strategy */
    /* revision round where v retains its current strategy. */
    /* With local perspective. */
    i = 0;
    ntry = 100;
    igraph_vector_init(&stratcp, 0);
    do {
        i++;
        if (i > ntry) {
            return IGRAPH_FAILURE;    /* ideally this should never happen */
        }
        igraph_vector_destroy(&stratcp);
        igraph_vector_copy(&stratcp, &strat);
        igraph_roulette_wheel_imitation(&g, v, /*is local?*/ 1, &quant, &stratcp,
                                        IGRAPH_ALL);
    } while (VECTOR(stratcp)[v] != VECTOR(strat)[v]);
    /* If we get to this point, we know that there was an update round */
    /* i <= ntry as a result of which v retains its current strategy. */
    /* Now try again, but this time with the global perspective. */
    i = 0;
    do {
        i++;
        if (i > ntry) {
            return IGRAPH_FAILURE;    /* ideally this should never happen */
        }
        igraph_vector_destroy(&stratcp);
        igraph_vector_copy(&stratcp, &strat);
        igraph_roulette_wheel_imitation(&g, v, /*is local?*/ 0, &quant, &stratcp,
                                        IGRAPH_ALL);
    } while (VECTOR(stratcp)[v] != VECTOR(strat)[v]);
    /* nothing further to do, but housekeeping */
    igraph_destroy(&g);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&stratcp);

    return IGRAPH_SUCCESS;
}

int main() {
    int ret;

    igraph_rng_seed(igraph_rng_default(), 3241);

    ret = error_tests();
    if (ret) {
        return IGRAPH_FAILURE;
    }
    ret = roulette_test();
    if (ret) {
        return IGRAPH_FAILURE;
    }
    ret = retain_strategy_test();
    if (ret) {
        return IGRAPH_FAILURE;
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping.c0000644000175100001710000000503700000000000027152 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#define SIZE (1000)

int main() {

    igraph_matrix_t M, M2;
    igraph_vector_t lambda;
    igraph_matrix_t V;
    igraph_vector_t groups;
    igraph_vector_t ivec;
    int i, j;
    int n;

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Symmetric matrix, exponentially distributed elements */

    igraph_matrix_init(&M, SIZE, SIZE);
    n = igraph_matrix_nrow(&M);
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            MATRIX(M, i, j) = igraph_rng_get_exp(igraph_rng_default(), 1);
        }
    }
    igraph_matrix_init(&M2, n, n);
    igraph_matrix_update(&M2, &M);
    igraph_matrix_transpose(&M2);
    igraph_matrix_add(&M, &M2);
    igraph_matrix_scale(&M, 0.5);
    igraph_matrix_destroy(&M2);

    /* Get first (most positive) two eigenvectors */

    igraph_vector_init(&lambda, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_lapack_dsyevr(&M, IGRAPH_LAPACK_DSYEV_SELECT, /*vl=*/ 0, /*vu=*/ 0,
                         /*vestimate=*/ 0, /*il=*/ n - 1, /*iu=*/ n,
                         /*abstol=*/ 0.0, /*values=*/ &lambda, /*vectors=*/ &V,
                         /*support=*/ 0);

    /* Grouping */

    igraph_vector_init(&groups, 0);
    igraph_vector_init(&ivec, 2);
    VECTOR(ivec)[0] = 2;
    VECTOR(ivec)[1] = 3;
    igraph_scg_grouping(&V, &groups, /*invervals=*/ 0,
                        /*intervals_vector=*/ &ivec, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_OPTIMUM, /*p=*/ 0, /*maxiter=*/ 100);

    igraph_vector_print(&groups);

    igraph_vector_destroy(&ivec);
    igraph_vector_destroy(&groups);
    igraph_vector_destroy(&lambda);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&M);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping.out0000644000175100001710000000372000000000000027534 0ustar00runnerdocker000000000000000 1 2 3 4 4 2 5 2 2 5 0 2 0 5 1 1 0 0 4 0 4 4 1 4 4 5 0 4 0 1 1 1 0 4 5 5 2 1 5 2 5 1 4 1 4 5 1 2 0 4 4 4 5 5 4 5 1 0 1 1 4 5 3 3 3 0 1 1 4 4 5 3 4 4 2 1 0 4 3 4 1 3 1 2 0 3 1 4 4 2 3 4 5 1 5 2 4 0 5 4 1 4 0 2 4 0 0 3 4 3 5 1 0 1 2 4 3 1 3 2 5 3 3 5 3 4 4 4 0 1 4 3 2 0 4 4 1 5 4 5 3 2 4 4 4 4 4 4 4 1 2 3 0 4 1 0 4 1 0 4 1 0 5 5 1 4 2 3 4 5 3 3 1 4 0 3 2 4 1 4 0 0 1 3 5 3 1 4 0 0 1 1 5 5 3 3 3 4 3 1 0 1 5 3 3 0 1 2 4 1 5 1 3 5 3 4 3 0 1 0 1 5 4 0 4 0 4 1 4 1 5 1 5 3 4 5 0 4 0 2 4 1 4 1 5 0 4 4 3 5 3 1 2 1 1 4 1 0 1 3 2 1 5 4 4 1 1 5 1 2 5 1 4 1 1 1 0 1 5 0 0 1 3 4 0 4 2 0 5 0 4 3 4 2 4 5 0 5 5 3 1 3 4 1 3 3 1 5 4 0 3 5 5 2 1 5 5 0 0 4 5 2 5 1 1 5 2 2 2 2 4 3 2 3 0 1 1 1 4 5 4 4 1 1 1 3 3 3 2 2 4 5 3 1 3 2 4 1 0 1 1 0 0 2 5 4 1 3 2 2 1 1 4 4 1 3 4 0 3 1 4 4 4 2 4 4 2 2 4 4 4 2 1 2 3 4 3 1 2 2 4 2 1 4 5 4 4 2 0 0 4 5 5 0 1 5 1 1 2 4 4 4 1 4 2 0 3 3 2 5 2 3 1 2 4 1 4 1 4 4 1 0 4 2 3 1 0 5 1 1 4 3 3 2 0 3 4 3 1 3 1 1 4 3 2 5 5 4 1 5 4 4 4 5 0 1 2 2 3 1 4 1 1 5 3 3 3 5 3 3 4 0 3 3 1 2 0 5 5 5 4 0 4 0 4 0 3 1 0 2 2 3 1 1 4 3 5 1 2 3 1 4 4 2 1 5 1 3 3 2 1 0 5 0 5 2 4 4 1 4 1 1 5 4 1 0 5 3 4 4 1 2 4 1 4 5 5 1 3 1 4 4 5 2 5 5 0 5 3 1 4 5 0 4 4 3 1 3 5 4 1 1 5 5 1 3 2 3 1 1 3 4 0 5 5 5 0 4 2 3 4 1 4 5 5 3 2 1 4 1 5 4 1 2 1 3 1 1 4 2 4 1 5 1 5 5 4 3 3 5 1 5 1 1 0 3 5 4 4 3 1 1 4 4 4 5 3 2 0 1 0 4 3 4 1 1 4 4 2 3 0 2 3 3 1 4 2 3 0 4 4 2 0 4 1 3 0 1 4 1 4 1 0 2 3 2 2 1 3 1 4 3 3 2 0 0 4 4 1 1 4 0 5 3 4 4 5 1 3 4 3 3 5 2 4 1 3 2 4 3 0 1 4 5 1 0 4 5 1 1 4 0 5 4 4 0 3 0 4 2 1 3 0 5 5 1 1 0 2 4 5 4 5 1 4 3 1 4 4 2 1 3 4 3 5 0 3 3 4 2 5 4 2 0 0 1 3 1 1 5 1 1 5 0 1 2 4 1 3 4 5 1 1 0 3 4 1 5 4 1 5 1 3 2 0 4 1 4 4 4 5 4 1 0 5 5 5 5 1 5 4 5 2 4 1 3 1 4 3 2 5 5 5 5 5 3 4 0 4 1 1 0 1 5 5 4 4 0 4 5 0 1 1 2 5 3 4 2 0 1 0 2 4 1 4 4 4 1 1 1 1 1 5 5 0 1 3 2 2 5 2 5 4 3 5 3 5 2 1 4 3 4 1 1 4 1 4 4 0 2 1 2 2 3 4 2 2 2 5 2 0 3 1 2 5 4 3 5 2 5 1 4 0 4 0 5 3 4 1 1 2 1 0 4 1 2 4 3 4 2 4 1 4 1 0 0 0 5 4 2 4 1 2 3 2 0 4 4 2 2 0 2 4 0 4 5 1 2 4 1 3 0 3 2 2 4 3 4 2 1 4 1 1 1 1 4 4 3 3 1 1 1 4 0 1 1 1 1 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping2.c0000644000175100001710000000530300000000000027230 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_matrix_t adj, V;
    igraph_vector_t groups;
    igraph_eigen_which_t which;

    igraph_matrix_init(&adj, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_vector_init(&groups, 0);

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_get_adjacency(&g, &adj, IGRAPH_GET_ADJACENCY_BOTH, /*eids=*/ 0);

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 1;
    igraph_eigen_matrix_symmetric(&adj, /*sparsemat=*/ 0, /*fun=*/ 0,
                                  igraph_vcount(&g), /*extra=*/ 0,
                                  /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                  &which, /*options=*/ 0, /*storage=*/ 0,
                                  /*values=*/ 0, &V);

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_OPTIMUM, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_INTERV_KM, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_INTERV, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_EXACT, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);


    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&adj);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping2.out0000644000175100001710000000012000000000000027605 0ustar00runnerdocker000000000000000 1 1 2 2 2 2 2 2 2
0 0 0 1 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1 1
0 1 1 2 3 3 3 3 3 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping3.c0000644000175100001710000000712500000000000027235 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    const int nodes = 10;
    igraph_t g;
    igraph_matrix_t V, V3;
    igraph_matrix_complex_t V2;
    igraph_sparsemat_t stochastic;
    igraph_vector_t groups;
    igraph_eigen_which_t which;
    igraph_vector_t p, selcol;

    /* This is a 10-node tree with no non-trivial automorphisms. */
    igraph_small(&g, nodes, IGRAPH_UNDIRECTED,
                 3, 5, 4, 5, 4, 9, 8, 9, 0, 9, 0, 6, 1, 6, 1, 2, 7, 8,
                 -1);

    igraph_matrix_complex_init(&V2, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_matrix_init(&V3, 0, 0);
    igraph_vector_init(&groups, 0);
    igraph_vector_init(&p, 0);
    igraph_vector_init(&selcol, 1);

    igraph_get_stochastic_sparsemat(&g, &stochastic, /*column-wise=*/ 0);

    /* p is always the eigenvector corresponding to the 1-eigenvalue.
     * Since the graph is undirected, p is proportional to the degree vector. */
    igraph_degree(&g, &p, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);

    which.pos = IGRAPH_EIGEN_LR;
    which.howmany = 3;
    igraph_eigen_matrix(/*matrix=*/ 0, &stochastic, /*fun=*/ 0, nodes,
                                    /*extra=*/ 0, /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                    &which, /*options=*/ 0, /*storage=*/ 0,
                                    /*values=*/ 0, &V2);
    igraph_matrix_complex_real(&V2, &V3);
    VECTOR(selcol)[0] = 2;
    igraph_matrix_select_cols(&V3, &V, &selcol);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_OPTIMUM, &p, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_INTERV_KM, &p, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_INTERV, &p, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_EXACT, &p, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_vector_destroy(&p);
    igraph_vector_destroy(&selcol);
    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&V3);
    igraph_matrix_complex_destroy(&V2);
    igraph_sparsemat_destroy(&stochastic);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping3.out0000644000175100001710000000012000000000000027606 0ustar00runnerdocker000000000000000 0 0 1 0 1 0 2 2 2
0 1 1 1 1 1 0 2 2 0
0 1 1 1 1 1 0 2 2 0
0 1 2 3 4 5 6 7 8 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping4.c0000644000175100001710000000604500000000000027236 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    const int nodes = 10;
    igraph_t g;
    igraph_matrix_t V;
    igraph_matrix_complex_t V2;
    igraph_sparsemat_t laplacian;
    igraph_vector_t groups;
    igraph_eigen_which_t which;

    igraph_tree(&g, nodes, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_matrix_complex_init(&V2, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_vector_init(&groups, 0);

    igraph_sparsemat_init(&laplacian, 0, 0, 0);
    igraph_laplacian(&g, /*res=*/ 0, /*sparseres=*/ &laplacian,
                     /*normalized=*/ 0, /*weights=*/ 0);

    which.pos = IGRAPH_EIGEN_LR;
    which.howmany = 1;

    igraph_eigen_matrix(/*matrix=*/ 0, &laplacian, /*fun=*/ 0, nodes,
                                    /*extra=*/ 0, /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                    &which, /*options=*/ 0, /*storage=*/ 0,
                                    /*values=*/ 0, &V2);
    igraph_matrix_complex_real(&V2, &V);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_OPTIMUM, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_INTERV_KM, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_INTERV, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_EXACT, /*p=*/ 0, /*maxiter=*/ 10000);
    igraph_vector_print(&groups);

    /* ------------ */

    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&V);
    igraph_matrix_complex_destroy(&V2);
    igraph_sparsemat_destroy(&laplacian);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_grouping4.out0000644000175100001710000000012000000000000027607 0ustar00runnerdocker000000000000000 1 1 2 2 2 2 2 2 2
0 1 1 2 2 2 2 2 2 2
0 1 1 2 2 2 2 2 2 2
0 1 1 2 3 3 3 3 3 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors.c0000644000175100001710000000732200000000000030367 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_matrix_t adj, V;
    igraph_vector_t groups;
    igraph_eigen_which_t which;

    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&adj, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_vector_init(&groups, 0);

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_get_adjacency(&g, &adj, IGRAPH_GET_ADJACENCY_BOTH, /*eids=*/ 0);

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 1;
    igraph_eigen_matrix_symmetric(&adj, /*sparsemat=*/ 0, /*fun=*/ 0,
                                  igraph_vcount(&g), /*extra=*/ 0,
                                  /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                  &which, /*options=*/ 0, /*storage=*/ 0,
                                  /*values=*/ 0, &V);

#define SEMI()                              \
    do {                                  \
        igraph_scg_semiprojectors(&groups, IGRAPH_SCG_SYMMETRIC, &L, &R,    \
                                  &Lsparse, &Rsparse, /*p=*/ 0,     \
                                  IGRAPH_SCG_NORM_ROW);         \
    } while(0)

#define PRINTRES()              \
    do {                      \
        printf("----------------------\n");     \
        igraph_matrix_print(&L);            \
        printf("---\n");                \
        igraph_matrix_print(&R);            \
        printf("---\n");                \
        igraph_sparsemat_destroy(&Lsparse);         \
        igraph_sparsemat_destroy(&Rsparse);         \
    } while (0)

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_OPTIMUM, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 2,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_INTERV_KM, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 2,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_INTERV, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_SYMMETRIC,
                        IGRAPH_SCG_EXACT, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&adj);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors.out0000644000175100001710000000205600000000000030753 0ustar00runnerdocker00000000000000----------------------
1 0 0 0 0 0 0 0 0 0
0 0.707107 0.707107 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
1 0 0 0 0 0 0 0 0 0
0 0.707107 0.707107 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
----------------------
0.57735 0.57735 0.57735 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
0.57735 0.57735 0.57735 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
----------------------
0.57735 0.57735 0.57735 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
0.57735 0.57735 0.57735 0 0 0 0 0 0 0
0 0 0 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964 0.377964
---
----------------------
1 0 0 0 0 0 0 0 0 0
0 0.707107 0.707107 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 0.408248 0.408248 0.408248 0.408248 0.408248 0.408248
---
1 0 0 0 0 0 0 0 0 0
0 0.707107 0.707107 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 0.408248 0.408248 0.408248 0.408248 0.408248 0.408248
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors2.c0000644000175100001710000001071600000000000030452 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_matrix_t V, V3;
    igraph_matrix_complex_t V2;
    igraph_sparsemat_t stochastic;
    igraph_vector_t groups;
    igraph_eigen_which_t which;
    igraph_vector_t p, selcol;

    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_matrix_init(&V3, 0, 0);
    igraph_vector_init(&groups, 0);
    igraph_vector_init(&selcol, 1);

    /* This is a 10-node tree with no non-trivial automorphisms. */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 3, 5, 4, 5, 4, 9, 8, 9, 0, 9, 0, 6, 1, 6, 1, 2, 7, 8,
                 -1);

    igraph_matrix_complex_init(&V2, 0, 0);
    igraph_vector_init(&p, 0);

    igraph_get_stochastic_sparsemat(&g, &stochastic, /*column-wise=*/ 0);

    /* p is always the eigenvector corresponding to the 1-eigenvalue.
     * Since the graph is undirected, p is proportional to the degree vector. */
    igraph_degree(&g, &p, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);

    which.pos = IGRAPH_EIGEN_LR;
    which.howmany = 3;
    igraph_eigen_matrix(/*matrix=*/ 0, &stochastic, /*fun=*/ 0, 10,
                                    /*extra=*/ 0, /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                    &which, /*options=*/ 0, /*storage=*/ 0,
                                    /*values=*/ 0, &V2);
    igraph_matrix_complex_real(&V2, &V3);
    VECTOR(selcol)[0] = 2;
    igraph_matrix_select_cols(&V3, &V, &selcol);

#define SEMI()                              \
    do {                                  \
        igraph_scg_semiprojectors(&groups, IGRAPH_SCG_STOCHASTIC, &L, &R,   \
                                  &Lsparse, &Rsparse, &p,           \
                                  IGRAPH_SCG_NORM_ROW);         \
    } while(0)

#define PRINTRES()              \
    do {                      \
        printf("----------------------\n");     \
        igraph_matrix_print(&L);            \
        printf("---\n");                \
        igraph_matrix_print(&R);            \
        printf("---\n");                \
        igraph_sparsemat_destroy(&Lsparse);         \
        igraph_sparsemat_destroy(&Rsparse);         \
    } while (0)

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_OPTIMUM, &p, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_INTERV_KM, &p, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_INTERV, &p, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_STOCHASTIC,
                        IGRAPH_SCG_EXACT, &p, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_vector_destroy(&p);
    igraph_vector_destroy(&selcol);
    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&V3);
    igraph_matrix_complex_destroy(&V2);
    igraph_sparsemat_destroy(&stochastic);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors2.out0000644000175100001710000000203500000000000031032 0ustar00runnerdocker00000000000000----------------------
0.222222 0.222222 0.111111 0 0.222222 0 0.222222 0 0 0
0 0 0 0.333333 0 0.666667 0 0 0 0
0 0 0 0 0 0 0 0.166667 0.333333 0.5
---
1 1 1 0 1 0 1 0 0 0
0 0 0 1 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1
---
----------------------
0.285714 0 0 0 0 0 0.285714 0 0 0.428571
0 0.25 0.125 0.125 0.25 0.25 0 0 0 0
0 0 0 0 0 0 0 0.333333 0.666667 0
---
1 0 0 0 0 0 1 0 0 1
0 1 1 1 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0
---
----------------------
0.285714 0 0 0 0 0 0.285714 0 0 0.428571
0 0.25 0.125 0.125 0.25 0.25 0 0 0 0
0 0 0 0 0 0 0 0.333333 0.666667 0
---
1 0 0 0 0 0 1 0 0 1
0 1 1 1 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0
---
----------------------
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1
---
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors3.c0000644000175100001710000000771600000000000030461 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    int nodes = 10;
    igraph_t g;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_matrix_t V;
    igraph_matrix_complex_t V2;
    igraph_sparsemat_t laplacian;
    igraph_vector_t groups;
    igraph_eigen_which_t which;

    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_matrix_complex_init(&V2, 0, 0);
    igraph_vector_init(&groups, 0);

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_sparsemat_init(&laplacian, nodes, nodes, igraph_ecount(&g) * 2);

    igraph_laplacian(&g, /*res=*/ 0, /*sparseres=*/ &laplacian,
                     /*normalized=*/ 0, /*weights=*/ 0);

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 1;

    igraph_eigen_matrix(/*matrix=*/ 0, &laplacian, /*fun=*/ 0, 10,
                                    /*extra=*/ 0, /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                                    &which, /*options=*/ 0, /*storage=*/ 0,
                                    /*values=*/ 0, &V2);
    igraph_matrix_complex_real(&V2, &V);

#define SEMI()                              \
    do {                                  \
        igraph_scg_semiprojectors(&groups, IGRAPH_SCG_LAPLACIAN, &L, &R,    \
                                  &Lsparse, &Rsparse, /*p=*/ 0,     \
                                  IGRAPH_SCG_NORM_ROW);         \
    } while(0)

#define PRINTRES()              \
    do {                      \
        printf("----------------------\n");     \
        igraph_matrix_print(&L);            \
        printf("---\n");                \
        igraph_matrix_print(&R);            \
        printf("---\n");                \
        igraph_sparsemat_destroy(&Lsparse);         \
        igraph_sparsemat_destroy(&Rsparse);         \
    } while (0)

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 3,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_OPTIMUM, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 2,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_INTERV_KM, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*intervals=*/ 2,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_INTERV, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_scg_grouping(&V, &groups, /*(ignored) intervals=*/ 0,
                        /*intervals_vector=*/ 0, IGRAPH_SCG_LAPLACIAN,
                        IGRAPH_SCG_EXACT, /*p=*/ 0, /*maxiter=*/ 10000);
    SEMI();
    PRINTRES();

    /* -------------- */

    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_matrix_destroy(&V);
    igraph_matrix_complex_destroy(&V2);
    igraph_vector_destroy(&groups);
    igraph_sparsemat_destroy(&laplacian);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_scg_semiprojectors3.out0000644000175100001710000000140100000000000031027 0ustar00runnerdocker00000000000000----------------------
1 0 0 0 0 0 0 0 0 0
0 0.5 0.5 0 0 0 0 0 0 0
0 0 0 0.142857 0.142857 0.142857 0.142857 0.142857 0.142857 0.142857
---
1 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0
0 0 0 1 1 1 1 1 1 1
---
----------------------
0.125 0 0 0.125 0.125 0.125 0.125 0.125 0.125 0.125
0 0.5 0.5 0 0 0 0 0 0 0
---
1 0 0 1 1 1 1 1 1 1
0 1 1 0 0 0 0 0 0 0
---
----------------------
0.142857 0 0 0 0.142857 0.142857 0.142857 0.142857 0.142857 0.142857
0 0.333333 0.333333 0.333333 0 0 0 0 0 0
---
1 0 0 0 1 1 1 1 1 1
0 1 1 1 0 0 0 0 0 0
---
----------------------
1 0 0 0 0 0 0 0 0 0
0 0.5 0.5 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 0.166667 0.166667 0.166667 0.166667 0.166667 0.166667
---
1 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 1 1 1 1 1
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_similarity.c0000644000175100001710000001526100000000000026652 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void print_matrix(igraph_matrix_t *m, FILE *f) {
    long int i, j;
    for (i = 0; i < igraph_matrix_nrow(m); i++) {
        for (j = 0; j < igraph_matrix_ncol(m); j++) {
            fprintf(f, " %.2f", MATRIX(*m, i, j));
        }
        fprintf(f, "\n");
    }
    fprintf(f, "==========\n");
}

int check_jaccard_all(const igraph_t* g, igraph_matrix_t* m,
                      igraph_neimode_t mode, igraph_bool_t loops) {
    igraph_vector_t pairs, res;
    long int i, j, k, n;
    igraph_eit_t eit;

    igraph_vector_init(&res, 0);

    /* First, query the similarities for all the vertices to a matrix */
    igraph_similarity_jaccard(g, m, igraph_vss_all(), mode, loops);

    /* Second, query the similarities for all pairs using a pair vector */
    n = igraph_vcount(g);
    igraph_vector_init(&pairs, 0);
    for (i = 0; i < n; i++) {
        for (j = n - 1; j >= 0; j--) {
            igraph_vector_push_back(&pairs, i);
            igraph_vector_push_back(&pairs, j);
        }
    }
    igraph_similarity_jaccard_pairs(g, &res, &pairs, mode, loops);
    for (i = 0, k = 0; i < n; i++) {
        for (j = n - 1; j >= 0; j--, k++) {
            if (fabs(VECTOR(res)[k] - MATRIX(*m, i, j)) > 1e-6) {
                fprintf(stderr, "Jaccard similarity calculation for vertex pair %ld-%ld "
                        "does not match the value in the full matrix (%.6f vs %.6f)\n",
                        i, j, VECTOR(res)[k], MATRIX(*m, i, j));
                return 1;
            }
        }
    }
    igraph_vector_destroy(&pairs);

    /* Third, query the similarities for all edges */
    igraph_similarity_jaccard_es(g, &res, igraph_ess_all(IGRAPH_EDGEORDER_FROM), mode, loops);
    igraph_eit_create(g, igraph_ess_all(IGRAPH_EDGEORDER_FROM), &eit);
    k = 0;
    while (!IGRAPH_EIT_END(eit)) {
        long int eid = IGRAPH_EIT_GET(eit);
        i = IGRAPH_FROM(g, eid);
        j = IGRAPH_TO(g, eid);
        if (fabs(VECTOR(res)[k] - MATRIX(*m, i, j)) > 1e-6) {
            fprintf(stderr, "Jaccard similarity calculation for edge %ld-%ld (ID=%ld) "
                    "does not match the value in the full matrix (%.6f vs %.6f)\n",
                    i, j, eid, VECTOR(res)[k], MATRIX(*m, i, j));
            return 1;
        }
        IGRAPH_EIT_NEXT(eit);
        k++;
    }

    igraph_eit_destroy(&eit);

    igraph_vector_destroy(&res);

    return 0;
}

int check_dice_all(const igraph_t* g, igraph_matrix_t* m,
                   igraph_neimode_t mode, igraph_bool_t loops) {
    igraph_vector_t pairs, res;
    long int i, j, k, n;
    igraph_eit_t eit;

    igraph_vector_init(&res, 0);

    /* First, query the similarities for all the vertices to a matrix */
    igraph_similarity_dice(g, m, igraph_vss_all(), mode, loops);

    /* Second, query the similarities for all pairs using a pair vector */
    n = igraph_vcount(g);
    igraph_vector_init(&pairs, 0);
    for (i = 0; i < n; i++) {
        for (j = n - 1; j >= 0; j--) {
            igraph_vector_push_back(&pairs, i);
            igraph_vector_push_back(&pairs, j);
        }
    }
    igraph_similarity_dice_pairs(g, &res, &pairs, mode, loops);
    for (i = 0, k = 0; i < n; i++) {
        for (j = n - 1; j >= 0; j--, k++) {
            if (fabs(VECTOR(res)[k] - MATRIX(*m, i, j)) > 1e-6) {
                fprintf(stderr, "Dice similarity calculation for vertex pair %ld-%ld "
                        "does not match the value in the full matrix (%.6f vs %.6f)\n",
                        i, j, VECTOR(res)[k], MATRIX(*m, i, j));
                return 1;
            }
        }
    }
    igraph_vector_destroy(&pairs);

    /* Third, query the similarities for all edges */
    igraph_similarity_dice_es(g, &res, igraph_ess_all(IGRAPH_EDGEORDER_FROM), mode, loops);
    igraph_eit_create(g, igraph_ess_all(IGRAPH_EDGEORDER_FROM), &eit);
    k = 0;
    while (!IGRAPH_EIT_END(eit)) {
        long int eid = IGRAPH_EIT_GET(eit);
        i = IGRAPH_FROM(g, eid);
        j = IGRAPH_TO(g, eid);
        if (fabs(VECTOR(res)[k] - MATRIX(*m, i, j)) > 1e-6) {
            fprintf(stderr, "Dice similarity calculation for edge %ld-%ld (ID=%ld) "
                    "does not match the value in the full matrix (%.6f vs %.6f)\n",
                    i, j, eid, VECTOR(res)[k], MATRIX(*m, i, j));
            return 1;
        }
        IGRAPH_EIT_NEXT(eit);
        k++;
    }

    igraph_eit_destroy(&eit);

    igraph_vector_destroy(&res);

    return 0;
}

int main() {

    igraph_t g;
    igraph_matrix_t m;
    int ret;

    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0, 1, 2, 1, 2, 0, 3, 0,
                 -1);

    igraph_matrix_init(&m, 0, 0);

    ret = check_jaccard_all(&g, &m, IGRAPH_ALL, 1);
    print_matrix(&m, stdout);
    if (ret) {
        return 1;
    }

    igraph_similarity_jaccard(&g, &m, igraph_vss_seq(1, 2), IGRAPH_ALL, 0);
    print_matrix(&m, stdout);

    ret = check_jaccard_all(&g, &m, IGRAPH_OUT, 1);
    print_matrix(&m, stdout);
    if (ret) {
        return 3;
    }

    ret = check_jaccard_all(&g, &m, IGRAPH_IN, 0);
    print_matrix(&m, stdout);
    if (ret) {
        return 4;
    }

    ret = check_dice_all(&g, &m, IGRAPH_ALL, 1);
    print_matrix(&m, stdout);
    if (ret) {
        return 5;
    }

    ret = check_dice_all(&g, &m, IGRAPH_OUT, 1);
    print_matrix(&m, stdout);
    if (ret) {
        return 6;
    }

    ret = check_dice_all(&g, &m, IGRAPH_IN, 0);
    print_matrix(&m, stdout);
    if (ret) {
        return 7;
    }

    igraph_similarity_inverse_log_weighted(&g, &m, igraph_vss_all(), IGRAPH_ALL);
    print_matrix(&m, stdout);

    igraph_similarity_inverse_log_weighted(&g, &m, igraph_vss_all(), IGRAPH_OUT);
    print_matrix(&m, stdout);

    igraph_similarity_inverse_log_weighted(&g, &m, igraph_vss_all(), IGRAPH_IN);
    print_matrix(&m, stdout);

    igraph_matrix_destroy(&m);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_similarity.out0000644000175100001710000000157000000000000027235 0ustar00runnerdocker00000000000000 1.00 0.75 0.75 0.50
 0.75 1.00 1.00 0.25
 0.75 1.00 1.00 0.25
 0.50 0.25 0.25 1.00
==========
 1.00 0.33
 0.33 1.00
==========
 1.00 0.50 0.67 0.33
 0.50 1.00 0.33 0.00
 0.67 0.33 1.00 0.25
 0.33 0.00 0.25 1.00
==========
 1.00 0.33 0.00 0.00
 0.33 1.00 0.00 0.00
 0.00 0.00 1.00 0.00
 0.00 0.00 0.00 1.00
==========
 1.00 0.86 0.86 0.67
 0.86 1.00 1.00 0.40
 0.86 1.00 1.00 0.40
 0.67 0.40 0.40 1.00
==========
 1.00 0.67 0.80 0.50
 0.67 1.00 0.50 0.00
 0.80 0.50 1.00 0.40
 0.50 0.00 0.40 1.00
==========
 1.00 0.50 0.00 0.00
 0.50 1.00 0.00 0.00
 0.00 0.00 1.00 0.00
 0.00 0.00 0.00 1.00
==========
 0.00 1.44 1.44 0.00
 1.44 0.00 0.91 0.91
 1.44 0.91 0.00 0.91
 0.00 0.91 0.91 0.00
==========
 0.00 0.00 1.44 0.00
 0.00 0.00 0.00 0.00
 1.44 0.00 0.00 1.44
 0.00 0.00 1.44 0.00
==========
 0.00 1.44 0.00 0.00
 1.44 0.00 0.00 0.00
 0.00 0.00 0.00 0.00
 0.00 0.00 0.00 0.00
==========
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_simplify.c0000644000175100001710000000611500000000000026316 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;

    /* Multiple edges */

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    if (igraph_ecount(&g) != 1) {
        return 1;
    }
    igraph_destroy(&g);

    /* Loop edges*/

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 0, 1, 1, 2, 2, 1, 2, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 0, 0, 1, 1, 2, 2, 1, 2, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    /* Loop & multiple edges */

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, -1);
    igraph_simplify(&g, 1 /* multiple */, 0 /* loop */, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, -1);
    igraph_simplify(&g, 1 /* multiple */, 0 /* loop */, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_DIRECTED, 2, 2, 2, 2, 2, 2, 3, 2, -1);
    igraph_simplify(&g, 0 /* multiple */, 1 /* loop */, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 3, 3, 3, 3, 3, 4, -1);
    igraph_simplify(&g, 0 /* multiple */, 1 /* loop */, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_DIRECTED, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 3, 2, 3, 2, 3, 2, -1);
    igraph_simplify(&g, 1, 1, /*edge_comb=*/ 0);
    if (igraph_ecount(&g) != 1) {
        return 2;
    }
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_simplify.out0000644000175100001710000000005000000000000026673 0ustar00runnerdocker000000000000000 1
1 2
1 2
0 0
1 2
1 1
2 3
3 2
3 4
3 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_small.c0000644000175100001710000000210200000000000025562 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 3, 3, 4, 6, 1, -1);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_small.out0000644000175100001710000000002400000000000026150 0ustar00runnerdocker000000000000000 1
1 2
2 3
3 4
6 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat.c0000644000175100001710000001254600000000000026466 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_sparsemat_t A, B, C, D;
    igraph_t G, H;
    igraph_vector_t vect;
    long int i;

    /* Create, compress, destroy */
    igraph_sparsemat_init(&A, 100, 20, 50);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_destroy(&A);

    /* Convert a ring graph to a matrix, print it, compress, print again */
#define VC 10
    igraph_ring(&G, VC, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_get_sparsemat(&G, &A);
    igraph_destroy(&G);

    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_print(&B, stdout);

    /* Basic query, nrow, ncol, type, is_triplet, is_cc */
    if (igraph_sparsemat_nrow(&A) != VC ||
        igraph_sparsemat_ncol(&A) != VC ||
        igraph_sparsemat_nrow(&B) != VC ||
        igraph_sparsemat_ncol(&B) != VC) {
        return 1;
    }
    if (!igraph_sparsemat_is_triplet(&A)) {
        return 2;
    }
    if (!igraph_sparsemat_is_cc(&B))      {
        return 3;
    }
    if (igraph_sparsemat_type(&A) != IGRAPH_SPARSEMAT_TRIPLET) {
        return 4;
    }
    if (igraph_sparsemat_type(&B) != IGRAPH_SPARSEMAT_CC)      {
        return 5;
    }

    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);
#undef VC

    printf("------------------------\n");

    /* Create unit matrices */
    igraph_sparsemat_eye(&A, /*n=*/ 5, /*nzmax=*/ 5, /*value=*/ 1.0,
                         /*compress=*/ 0);
    igraph_sparsemat_eye(&B, /*n=*/ 5, /*nzmax=*/ 5, /*value=*/ 1.0,
                         /*compress=*/ 1);
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);

    printf("------------------------\n");

    /* Create diagonal matrices */
    igraph_vector_init(&vect, 5);
    for (i = 0; i < 5; i++) {
        VECTOR(vect)[i] = i;
    }
    igraph_sparsemat_diag(&A, /*nzmax=*/ 5, /*values=*/ &vect, /*compress=*/ 0);
    igraph_sparsemat_diag(&B, /*nzmax=*/ 5, /*values=*/ &vect, /*compress=*/ 1);
    igraph_vector_destroy(&vect);
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);

    printf("------------------------\n");

    /* Transpose matrices */
    igraph_tree(&G, 10, /*children=*/ 2, IGRAPH_TREE_OUT);
    igraph_get_sparsemat(&G, &A);
    igraph_destroy(&G);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_transpose(&B, &C, /*values=*/ 1);
    igraph_sparsemat_print(&C, stdout);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_destroy(&C);

    printf("------------------------\n");

    /* Add duplicate elements */
    igraph_sparsemat_init(&A, 10, 10, /*nzmax=*/ 20);
    for (i = 1; i < 10; i++) {
        igraph_sparsemat_entry(&A, 0, i, 1.0);
    }
    for (i = 1; i < 10; i++) {
        igraph_sparsemat_entry(&A, 0, i, 1.0);
    }
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_dupl(&B);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);

    printf("------------------------\n");

    /* Drop zero elements */
    igraph_sparsemat_init(&A, 10, 10, /*nzmax=*/ 20);
    igraph_sparsemat_entry(&A, 7, 3, 0.0);
    for (i = 1; i < 10; i++) {
        igraph_sparsemat_entry(&A, 0, i, 1.0);
        igraph_sparsemat_entry(&A, 0, i, 0.0);
    }
    igraph_sparsemat_entry(&A, 0, 0, 0.0);
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_dropzeros(&B);
    igraph_sparsemat_print(&B, stdout);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);

    printf("------------------------\n");

    /* Add two matrices */

    igraph_star(&G, 10, IGRAPH_STAR_OUT, /*center=*/ 0);
    igraph_ring(&H, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_get_sparsemat(&G, &A);
    igraph_get_sparsemat(&H, &B);
    igraph_destroy(&G);
    igraph_destroy(&H);
    igraph_sparsemat_compress(&A, &C);
    igraph_sparsemat_compress(&B, &D);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_add(&C, &D, /*alpha=*/ 1.0, /*beta=*/ 2.0, &A);
    igraph_sparsemat_destroy(&C);
    igraph_sparsemat_destroy(&D);
    igraph_sparsemat_print(&A, stdout);
    igraph_sparsemat_destroy(&A);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat.out0000644000175100001710000000714400000000000027051 0ustar00runnerdocker000000000000001 0 : 1
0 1 : 1
2 1 : 1
1 2 : 1
3 2 : 1
2 3 : 1
4 3 : 1
3 4 : 1
5 4 : 1
4 5 : 1
6 5 : 1
5 6 : 1
7 6 : 1
6 7 : 1
8 7 : 1
7 8 : 1
9 8 : 1
8 9 : 1
9 0 : 1
0 9 : 1
col 0: locations 0 to 1
1 : 1
9 : 1
col 1: locations 2 to 3
0 : 1
2 : 1
col 2: locations 4 to 5
1 : 1
3 : 1
col 3: locations 6 to 7
2 : 1
4 : 1
col 4: locations 8 to 9
3 : 1
5 : 1
col 5: locations 10 to 11
4 : 1
6 : 1
col 6: locations 12 to 13
5 : 1
7 : 1
col 7: locations 14 to 15
6 : 1
8 : 1
col 8: locations 16 to 17
7 : 1
9 : 1
col 9: locations 18 to 19
8 : 1
0 : 1
------------------------
0 0 : 1
1 1 : 1
2 2 : 1
3 3 : 1
4 4 : 1
col 0: locations 0 to 0
0 : 1
col 1: locations 1 to 1
1 : 1
col 2: locations 2 to 2
2 : 1
col 3: locations 3 to 3
3 : 1
col 4: locations 4 to 4
4 : 1
------------------------
0 0 : 0
1 1 : 1
2 2 : 2
3 3 : 3
4 4 : 4
col 0: locations 0 to 0
0 : 0
col 1: locations 1 to 1
1 : 1
col 2: locations 2 to 2
2 : 2
col 3: locations 3 to 3
3 : 3
col 4: locations 4 to 4
4 : 4
------------------------
col 0: locations 0 to -1
col 1: locations 0 to 0
0 : 1
col 2: locations 1 to 1
0 : 1
col 3: locations 2 to 2
1 : 1
col 4: locations 3 to 3
1 : 1
col 5: locations 4 to 4
2 : 1
col 6: locations 5 to 5
2 : 1
col 7: locations 6 to 6
3 : 1
col 8: locations 7 to 7
3 : 1
col 9: locations 8 to 8
4 : 1
col 0: locations 0 to 1
1 : 1
2 : 1
col 1: locations 2 to 3
3 : 1
4 : 1
col 2: locations 4 to 5
5 : 1
6 : 1
col 3: locations 6 to 7
7 : 1
8 : 1
col 4: locations 8 to 8
9 : 1
col 5: locations 9 to 8
col 6: locations 9 to 8
col 7: locations 9 to 8
col 8: locations 9 to 8
col 9: locations 9 to 8
------------------------
0 1 : 1
0 2 : 1
0 3 : 1
0 4 : 1
0 5 : 1
0 6 : 1
0 7 : 1
0 8 : 1
0 9 : 1
0 1 : 1
0 2 : 1
0 3 : 1
0 4 : 1
0 5 : 1
0 6 : 1
0 7 : 1
0 8 : 1
0 9 : 1
col 0: locations 0 to -1
col 1: locations 0 to 1
0 : 1
0 : 1
col 2: locations 2 to 3
0 : 1
0 : 1
col 3: locations 4 to 5
0 : 1
0 : 1
col 4: locations 6 to 7
0 : 1
0 : 1
col 5: locations 8 to 9
0 : 1
0 : 1
col 6: locations 10 to 11
0 : 1
0 : 1
col 7: locations 12 to 13
0 : 1
0 : 1
col 8: locations 14 to 15
0 : 1
0 : 1
col 9: locations 16 to 17
0 : 1
0 : 1
col 0: locations 0 to -1
col 1: locations 0 to 0
0 : 2
col 2: locations 1 to 1
0 : 2
col 3: locations 2 to 2
0 : 2
col 4: locations 3 to 3
0 : 2
col 5: locations 4 to 4
0 : 2
col 6: locations 5 to 5
0 : 2
col 7: locations 6 to 6
0 : 2
col 8: locations 7 to 7
0 : 2
col 9: locations 8 to 8
0 : 2
------------------------
7 3 : 0
0 1 : 1
0 1 : 0
0 2 : 1
0 2 : 0
0 3 : 1
0 3 : 0
0 4 : 1
0 4 : 0
0 5 : 1
0 5 : 0
0 6 : 1
0 6 : 0
0 7 : 1
0 7 : 0
0 8 : 1
0 8 : 0
0 9 : 1
0 9 : 0
0 0 : 0
col 0: locations 0 to 0
0 : 0
col 1: locations 1 to 2
0 : 1
0 : 0
col 2: locations 3 to 4
0 : 1
0 : 0
col 3: locations 5 to 7
7 : 0
0 : 1
0 : 0
col 4: locations 8 to 9
0 : 1
0 : 0
col 5: locations 10 to 11
0 : 1
0 : 0
col 6: locations 12 to 13
0 : 1
0 : 0
col 7: locations 14 to 15
0 : 1
0 : 0
col 8: locations 16 to 17
0 : 1
0 : 0
col 9: locations 18 to 19
0 : 1
0 : 0
col 0: locations 0 to -1
col 1: locations 0 to 0
0 : 1
col 2: locations 1 to 1
0 : 1
col 3: locations 2 to 2
0 : 1
col 4: locations 3 to 3
0 : 1
col 5: locations 4 to 4
0 : 1
col 6: locations 5 to 5
0 : 1
col 7: locations 6 to 6
0 : 1
col 8: locations 7 to 7
0 : 1
col 9: locations 8 to 8
0 : 1
------------------------
col 0: locations 0 to 1
1 : 2
9 : 2
col 1: locations 2 to 3
0 : 3
2 : 2
col 2: locations 4 to 6
0 : 1
1 : 2
3 : 2
col 3: locations 7 to 9
0 : 1
2 : 2
4 : 2
col 4: locations 10 to 12
0 : 1
3 : 2
5 : 2
col 5: locations 13 to 15
0 : 1
4 : 2
6 : 2
col 6: locations 16 to 18
0 : 1
5 : 2
7 : 2
col 7: locations 19 to 21
0 : 1
6 : 2
8 : 2
col 8: locations 22 to 24
0 : 1
7 : 2
9 : 2
col 9: locations 25 to 26
0 : 3
8 : 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat3.c0000644000175100001710000002051700000000000026546 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#define NCOMPLEX  /* to make it compile with MSVC on Windows */

#include 
#include 

int permute(const igraph_matrix_t *M,
            const igraph_vector_int_t *p,
            const igraph_vector_int_t *q,
            igraph_matrix_t *res) {

    long int nrow = igraph_vector_int_size(p);
    long int ncol = igraph_vector_int_size(q);
    long int i, j;

    igraph_matrix_resize(res, nrow, ncol);

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            int ii = VECTOR(*p)[i];
            int jj = VECTOR(*q)[j];
            MATRIX(*res, i, j) = MATRIX(*M, ii, jj);
        }
    }

    return 0;
}

int permute_rows(const igraph_matrix_t *M,
                 const igraph_vector_int_t *p,
                 igraph_matrix_t *res) {

    long int nrow = igraph_vector_int_size(p);
    long int ncol = igraph_matrix_ncol(M);
    long int i, j;

    igraph_matrix_resize(res, nrow, ncol);

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            int ii = VECTOR(*p)[i];
            MATRIX(*res, i, j) = MATRIX(*M, ii, j);
        }
    }

    return 0;
}

int permute_cols(const igraph_matrix_t *M,
                 const igraph_vector_int_t *q,
                 igraph_matrix_t *res) {

    long int nrow = igraph_matrix_nrow(M);
    long int ncol = igraph_vector_int_size(q);
    long int i, j;

    igraph_matrix_resize(res, nrow, ncol);

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            int jj = VECTOR(*q)[j];
            MATRIX(*res, i, j) = MATRIX(*M, i, jj);
        }
    }

    return 0;
}

int random_permutation(igraph_vector_int_t *vec) {
    /* We just do size(vec) * 2 swaps */
    long int one, two, i, n = igraph_vector_int_size(vec);
    int tmp;
    for (i = 0; i < 2 * n; i++) {
        one = RNG_INTEGER(0, n - 1);
        two = RNG_INTEGER(0, n - 1);
        tmp = VECTOR(*vec)[one];
        VECTOR(*vec)[one] = VECTOR(*vec)[two];
        VECTOR(*vec)[two] = tmp;
    }
    return 0;
}

igraph_bool_t check_same(const igraph_sparsemat_t *A,
                         const igraph_matrix_t *M) {

    long int nrow = igraph_sparsemat_nrow(A);
    long int ncol = igraph_sparsemat_ncol(A);
    long int j, p, nzero = 0;

    if (nrow != igraph_matrix_nrow(M) ||
        ncol != igraph_matrix_ncol(M)) {
        return 0;
    }

    for (j = 0; j < A->cs->n; j++) {
        for (p = A->cs->p[j]; p < A->cs->p[j + 1]; p++) {
            long int to = A->cs->i[p];
            igraph_real_t value = A->cs->x[p];
            if (value != MATRIX(*M, to, j)) {
                return 0;
            }
            nzero += 1;
        }
    }

    for (j = 0; j < nrow; j++) {
        for (p = 0; p < ncol; p++) {
            if (MATRIX(*M, j, p) != 0) {
                nzero -= 1;
            }
        }
    }

    return nzero == 0;
}

int main() {

    igraph_sparsemat_t A, B;
    igraph_matrix_t M, N;
    igraph_vector_int_t p, q;
    long int i;

    /* Permutation of a matrix */

#define NROW 10
#define NCOL 5
#define EDGES NROW*NCOL/3
    igraph_matrix_init(&M, NROW, NCOL);
    igraph_sparsemat_init(&A, NROW, NCOL, EDGES);
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, NROW - 1);
        long int c = RNG_INTEGER(0, NCOL - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(M, r, c) = MATRIX(M, r, c) + value;
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_int_init_seq(&p, 0, NROW - 1);
    igraph_vector_int_init_seq(&q, 0, NCOL - 1);

    /* Identity */

    igraph_matrix_init(&N, 0, 0);
    permute(&M, &p, &q, &N);

    igraph_sparsemat_permute(&B, &p, &q, &A);
    igraph_sparsemat_dupl(&A);

    if (! check_same(&A, &N)) {
        return 1;
    }

    /* Random permutation */
    random_permutation(&p);
    random_permutation(&q);

    permute(&M, &p, &q, &N);

    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_permute(&B, &p, &q, &A);
    igraph_sparsemat_dupl(&A);

    if (! check_same(&A, &N)) {
        return 2;
    }

    igraph_vector_int_destroy(&p);
    igraph_vector_int_destroy(&q);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);
    igraph_matrix_destroy(&M);
    igraph_matrix_destroy(&N);

#undef NROW
#undef NCOL
#undef EDGES

    /* Indexing */

#define NROW 10
#define NCOL 5
#define EDGES NROW*NCOL/3
#define I_NROW 6
#define I_NCOL 3
    igraph_matrix_init(&M, NROW, NCOL);
    igraph_sparsemat_init(&A, NROW, NCOL, EDGES);
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, NROW - 1);
        long int c = RNG_INTEGER(0, NCOL - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(M, r, c) = MATRIX(M, r, c) + value;
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_int_init(&p, I_NROW);
    igraph_vector_int_init(&q, I_NCOL);

    for (i = 0; i < I_NROW; i++) {
        VECTOR(p)[i] = RNG_INTEGER(0, I_NROW - 1);
    }
    for (i = 0; i < I_NCOL; i++) {
        VECTOR(p)[i] = RNG_INTEGER(0, I_NCOL - 1);
    }

    igraph_matrix_init(&N, 0, 0);
    permute(&M, &p, &q, &N);

    igraph_sparsemat_index(&B, &p, &q, &A, 0);

    if (! check_same(&A, &N)) {
        return 3;
    }

    /* A single element */

    igraph_vector_int_resize(&p, 1);
    igraph_vector_int_resize(&q, 1);

    for (i = 0; i < 100; i++) {
        igraph_real_t value;
        VECTOR(p)[0] = RNG_INTEGER(0, NROW - 1);
        VECTOR(q)[0] = RNG_INTEGER(0, NCOL - 1);
        igraph_sparsemat_index(&B, &p, &q, /*res=*/ 0, &value);
        if (value != MATRIX(M, VECTOR(p)[0], VECTOR(q)[0])) {
            return 4;
        }
    }

    igraph_sparsemat_destroy(&A);

    for (i = 0; i < 100; i++) {
        igraph_real_t value;
        VECTOR(p)[0] = RNG_INTEGER(0, NROW - 1);
        VECTOR(q)[0] = RNG_INTEGER(0, NCOL - 1);
        igraph_sparsemat_index(&B, &p, &q, /*res=*/ &A, &value);
        igraph_sparsemat_destroy(&A);
        if (value != MATRIX(M, VECTOR(p)[0], VECTOR(q)[0])) {
            return 4;
        }
    }

    igraph_vector_int_destroy(&p);
    igraph_vector_int_destroy(&q);
    igraph_sparsemat_destroy(&B);
    igraph_matrix_destroy(&M);
    igraph_matrix_destroy(&N);

    /* Indexing only the rows or the columns */

    igraph_matrix_init(&M, NROW, NCOL);
    igraph_sparsemat_init(&A, NROW, NCOL, EDGES);
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, NROW - 1);
        long int c = RNG_INTEGER(0, NCOL - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(M, r, c) = MATRIX(M, r, c) + value;
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_int_init(&p, I_NROW);
    igraph_vector_int_init(&q, I_NCOL);

    for (i = 0; i < I_NROW; i++) {
        VECTOR(p)[i] = RNG_INTEGER(0, I_NROW - 1);
    }
    for (i = 0; i < I_NCOL; i++) {
        VECTOR(p)[i] = RNG_INTEGER(0, I_NCOL - 1);
    }

    igraph_matrix_init(&N, 0, 0);
    permute_rows(&M, &p, &N);

    igraph_sparsemat_index(&B, &p, 0, &A, 0);

    if (! check_same(&A, &N)) {
        return 5;
    }

    permute_cols(&M, &q, &N);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_index(&B, 0, &q, &A, 0);

    if (! check_same(&A, &N)) {
        return 6;
    }

    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);
    igraph_vector_int_destroy(&p);
    igraph_vector_int_destroy(&q);
    igraph_matrix_destroy(&M);
    igraph_matrix_destroy(&N);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat3.out0000644000175100001710000000000000000000000027114 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat4.c0000644000175100001710000001755100000000000026553 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#define NCOMPLEX  /* to make it compile with MSVC on Windows */

#include 
#include 

igraph_bool_t check_solution(const igraph_sparsemat_t *A,
                             const igraph_vector_t *x,
                             const igraph_vector_t *b) {

    long int dim = igraph_vector_size(x);
    igraph_vector_t res;
    int j, p;
    igraph_real_t min, max;

    igraph_vector_copy(&res, b);

    for (j = 0; j < dim; j++) {
        for (p = A->cs->p[j]; p < A->cs->p[j + 1]; p++) {
            long int from = A->cs->i[p];
            igraph_real_t value = A->cs->x[p];
            VECTOR(res)[from] -= VECTOR(*x)[j] * value;
        }
    }

    igraph_vector_minmax(&res, &min, &max);
    igraph_vector_destroy(&res);

    return fabs(min) < 1e-15 && fabs(max) < 1e-15;
}

int main() {

    igraph_sparsemat_t A, B, C;
    igraph_vector_t b, x;
    long int i;

    /* lsolve */

#define DIM 10
#define EDGES (DIM*DIM/6)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, DIM - 1);
        long int c = RNG_INTEGER(0, r);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_lsolve(&B, &b, &x);

    if (! check_solution(&B, &x, &b)) {
        return 1;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&B);

#undef DIM
#undef EDGES

    /* ltsolve */

#define DIM 10
#define EDGES (DIM*DIM/6)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, DIM - 1);
        long int c = RNG_INTEGER(0, r);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_ltsolve(&B, &b, &x);

    igraph_sparsemat_transpose(&B, &A, /*values=*/ 1);
    if (! check_solution(&A, &x, &b)) {
        return 2;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_destroy(&A);

#undef DIM
#undef EDGES

    /* usolve */

#define DIM 10
#define EDGES (DIM*DIM/6)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, DIM - 1);
        long int c = RNG_INTEGER(0, r);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);
    igraph_sparsemat_transpose(&B, &A, /*values=*/ 1);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_usolve(&A, &b, &x);

    if (! check_solution(&A, &x, &b)) {
        return 3;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_destroy(&A);

#undef DIM
#undef EDGES

    /* utsolve */

#define DIM 10
#define EDGES (DIM*DIM/6)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, DIM - 1);
        long int c = RNG_INTEGER(0, r);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);
    igraph_sparsemat_transpose(&B, &A, /*values=*/ 1);
    igraph_sparsemat_destroy(&B);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_utsolve(&A, &b, &x);

    igraph_sparsemat_transpose(&A, &B, /*values=*/ 1);
    if (! check_solution(&B, &x, &b)) {
        return 4;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&B);
    igraph_sparsemat_destroy(&A);

#undef DIM
#undef EDGES

    /* cholsol */
    /* We need a positive definite matrix, so we create a full-rank
       matrix first and then calculate A'A, which will be positive
       definite. */

#define DIM 10
#define EDGES (DIM*DIM/6)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int from = RNG_INTEGER(0, DIM - 1);
        long int to = RNG_INTEGER(0, DIM - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, from, to, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);
    igraph_sparsemat_transpose(&B, &A, /*values=*/ 1);
    igraph_sparsemat_multiply(&A, &B, &C);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&B);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_cholsol(&C, &b, &x, /*order=*/ 0);

    if (! check_solution(&C, &x, &b)) {
        return 5;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&C);

#undef DIM
#undef EDGES

    /* lusol */

#define DIM 10
#define EDGES (DIM*DIM/4)
    igraph_sparsemat_init(&A, DIM, DIM, EDGES + DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, RNG_INTEGER(1, 3));
    }
    for (i = 0; i < EDGES; i++) {
        long int from = RNG_INTEGER(0, DIM - 1);
        long int to = RNG_INTEGER(0, DIM - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        igraph_sparsemat_entry(&A, from, to, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_dupl(&B);

    igraph_vector_init(&b, DIM);
    for (i = 0; i < DIM; i++) {
        VECTOR(b)[i] = RNG_INTEGER(1, 10);
    }

    igraph_vector_init(&x, DIM);
    igraph_sparsemat_lusol(&B, &b, &x, /*order=*/ 0, /*tol=*/ 1e-10);

    if (! check_solution(&B, &x, &b)) {
        return 6;
    }

    igraph_vector_destroy(&b);
    igraph_vector_destroy(&x);
    igraph_sparsemat_destroy(&B);

#undef DIM
#undef EDGES

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat4.out0000644000175100001710000000000000000000000027115 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat6.c0000644000175100001710000000402400000000000026544 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_matrix_t mat, mat2, mat3;
    igraph_sparsemat_t spmat, spmat2;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);

#define NROW 10
#define NCOL 7
#define NUM_NONZEROS 15

    igraph_matrix_init(&mat, NROW, NCOL);
    for (i = 0; i < NUM_NONZEROS; i++) {
        int r = igraph_rng_get_integer(igraph_rng_default(), 0, NROW - 1);
        int c = igraph_rng_get_integer(igraph_rng_default(), 0, NCOL - 1);
        igraph_real_t val = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        MATRIX(mat, r, c) = val;
    }

    igraph_matrix_as_sparsemat(&spmat, &mat, /*tol=*/ 1e-14);
    igraph_matrix_init(&mat2, 0, 0);
    igraph_sparsemat_as_matrix(&mat2, &spmat);
    if (!igraph_matrix_all_e(&mat, &mat2)) {
        return 1;
    }

    igraph_sparsemat_compress(&spmat, &spmat2);
    igraph_matrix_init(&mat3, 0, 0);
    igraph_sparsemat_as_matrix(&mat3, &spmat2);
    if (!igraph_matrix_all_e(&mat, &mat3)) {
        return 2;
    }

    igraph_matrix_destroy(&mat);
    igraph_matrix_destroy(&mat2);
    igraph_matrix_destroy(&mat3);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat7.c0000644000175100001710000000432500000000000026551 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#define DIM1 10
#define DIM2 5

#define INT(a) (igraph_rng_get_integer(igraph_rng_default(), 0, (a)))

int main() {
    igraph_matrix_t mat;
    igraph_sparsemat_t spmat, spmat2;
    int i;
    igraph_real_t m1, m2;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    igraph_sparsemat_entry(&spmat, 1, 2, -1.0);
    igraph_sparsemat_entry(&spmat, 3, 2, 10.0);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_entry(&spmat, 1, 2, -1.0);
    igraph_sparsemat_entry(&spmat, 3, 2, 10.0);

    igraph_sparsemat_compress(&spmat, &spmat2);
    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat2);
    m1 = igraph_sparsemat_min(&spmat2);
    m2 = igraph_matrix_min(&mat);
    if (m1 != m2) {
        printf("%f %f\n", m1, m2);
        return 1;
    }
    m1 = igraph_sparsemat_max(&spmat2);
    m2 = igraph_matrix_max(&mat);
    if (m1 != m2) {
        printf("%f %f\n", m1, m2);
        return 2;
    }

    igraph_sparsemat_minmax(&spmat2, &m1, &m2);
    if (m1 != igraph_matrix_min(&mat)) {
        return 3;
    }
    if (m2 != igraph_matrix_max(&mat)) {
        return 4;
    }

    igraph_matrix_destroy(&mat);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_sparsemat8.c0000644000175100001710000001405000000000000026546 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#define DIM1 10
#define DIM2 5

#define INT(a) (igraph_rng_get_integer(igraph_rng_default(), 0, (a)))

int main() {
    igraph_matrix_t mat, mat2;
    igraph_sparsemat_t spmat, spmat2;
    int i, j, nz1, nz2;
    igraph_vector_t sums1, sums2;


    igraph_rng_seed(igraph_rng_default(), 42);

    /* COPY */

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_copy(&spmat2, &spmat);

    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    igraph_matrix_init(&mat2, 0, 0);
    igraph_sparsemat_as_matrix(&mat2, &spmat2);
    if (!igraph_matrix_all_e(&mat, &mat2)) {
        return 1;
    }

    igraph_matrix_destroy(&mat2);
    igraph_sparsemat_destroy(&spmat2);

    igraph_sparsemat_compress(&spmat, &spmat2);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_copy(&spmat, &spmat2);

    igraph_matrix_init(&mat2, 0, 0);
    igraph_sparsemat_as_matrix(&mat2, &spmat);
    if (!igraph_matrix_all_e(&mat, &mat2)) {
        return 2;
    }

    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);
    igraph_matrix_destroy(&mat);
    igraph_matrix_destroy(&mat2);

    /* COLSUMS, ROWSUMS */

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_compress(&spmat, &spmat2);

    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    igraph_vector_init(&sums1, 0);
    igraph_vector_init(&sums2, 0);
    igraph_sparsemat_colsums(&spmat, &sums1);
    igraph_matrix_colsum(&mat, &sums2);
    if (!igraph_vector_all_e(&sums1, &sums2)) {
        return 3;
    }
    igraph_sparsemat_colsums(&spmat2, &sums1);
    if (!igraph_vector_all_e(&sums1, &sums2)) {
        return 4;
    }

    igraph_sparsemat_rowsums(&spmat, &sums1);
    igraph_matrix_rowsum(&mat, &sums2);
    if (!igraph_vector_all_e(&sums1, &sums2)) {
        return 5;
    }
    igraph_sparsemat_rowsums(&spmat2, &sums1);
    if (!igraph_vector_all_e(&sums1, &sums2)) {
        return 6;
    }

    igraph_matrix_destroy(&mat);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);
    igraph_vector_destroy(&sums1);
    igraph_vector_destroy(&sums2);

    /* COUNT_NONZERO, COUNT_NONZEROTOL */

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    igraph_sparsemat_entry(&spmat, 1, 2, 1.0);
    igraph_sparsemat_entry(&spmat, 1, 2, 1.0);
    igraph_sparsemat_entry(&spmat, 1, 3, 1e-12);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_compress(&spmat, &spmat2);

    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat2);

    nz1 = igraph_sparsemat_count_nonzero(&spmat2);
    for (nz2 = 0, i = 0; i < igraph_matrix_nrow(&mat); i++) {
        for (j = 0; j < igraph_matrix_ncol(&mat); j++) {
            if (MATRIX(mat, i, j) != 0) {
                nz2++;
            }
        }
    }
    if (nz1 != nz2) {
        printf("%i %i\n", nz1, nz2);
        return 7;
    }

    nz1 = igraph_sparsemat_count_nonzerotol(&spmat2, 1e-10);
    for (nz2 = 0, i = 0; i < igraph_matrix_nrow(&mat); i++) {
        for (j = 0; j < igraph_matrix_ncol(&mat); j++) {
            if (fabs(MATRIX(mat, i, j)) >= 1e-10) {
                nz2++;
            }
        }
    }
    if (nz1 != nz2) {
        printf("%i %i\n", nz1, nz2);
        return 8;
    }

    igraph_matrix_destroy(&mat);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);

    /* SCALE */

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_compress(&spmat, &spmat2);

    igraph_sparsemat_scale(&spmat, 2.0);
    igraph_sparsemat_scale(&spmat2, 2.0);
    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    igraph_matrix_init(&mat2, 0, 0);
    igraph_sparsemat_as_matrix(&mat2, &spmat2);
    igraph_matrix_scale(&mat, 1.0 / 2.0);
    igraph_matrix_scale(&mat2, 1.0 / 2.0);
    if (!igraph_matrix_all_e(&mat, &mat2)) {
        return 9;
    }

    igraph_matrix_destroy(&mat);
    igraph_matrix_destroy(&mat2);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);

    /* ADDROWS, ADDCOLS */

    igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&spmat, INT(DIM1 - 1), INT(DIM2 - 1), 1.0);
    }
    igraph_sparsemat_compress(&spmat, &spmat2);

    igraph_sparsemat_add_rows(&spmat, 3);
    igraph_sparsemat_add_cols(&spmat, 2);

    igraph_sparsemat_add_rows(&spmat2, 3);
    igraph_sparsemat_add_cols(&spmat2, 2);

    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    igraph_matrix_init(&mat2, 0, 0);
    igraph_sparsemat_as_matrix(&mat2, &spmat2);
    if (!igraph_matrix_all_e(&mat, &mat2)) {
        return 10;
    }

    igraph_matrix_destroy(&mat);
    igraph_matrix_destroy(&mat2);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_star.c0000644000175100001710000000216200000000000025431 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;

    /* Create an undirected 6-star, with the 0th node as the centre. */
    igraph_star(&graph, 7, IGRAPH_STAR_UNDIRECTED, 0);

    /* Output the edge list of the graph. */
    igraph_write_graph_edgelist(&graph, stdout);

    /* Destroy the graph when we are done using it. */
    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_star.out0000644000175100001710000000003000000000000026006 0ustar00runnerdocker000000000000000 1
0 2
0 3
0 4
0 5
0 6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_stochastic_imitation.c0000644000175100001710000002305400000000000030704 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for stochastic imitation via uniform selection.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 
#include 

/* test parameters structure */
typedef struct {
    igraph_t *graph;
    igraph_integer_t vertex;
    igraph_imitate_algorithm_t algo;
    igraph_vector_t *quantities;
    igraph_vector_t *strategies;
    igraph_vector_t *known_strats;
    igraph_neimode_t mode;
    int retval;
} strategy_test_t;

/* Error tests. That is, we expect error codes to be returned from such tests.
 */
int error_tests() {
    igraph_t g, h;
    igraph_vector_t quant, strat;
    int i, n, ret;
    strategy_test_t *test;

    /* nonempty graph */
    igraph_small(&g, /*n vertices*/ 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    igraph_empty(&h, 0, 0);         /* empty graph */
    igraph_vector_init(&quant, 1);  /* quantities vector */
    igraph_vector_init(&strat, 2);  /* strategies vector */

    /* test parameters */
    /*graph--vertex--algo--quantities--strategies--known_strats--mode--retval*/
    /* null pointer for graph */
    strategy_test_t null_graph = {NULL, 0, IGRAPH_IMITATE_BLIND, NULL, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for quantities vector */
    strategy_test_t null_quant = {&g, 0, IGRAPH_IMITATE_BLIND, NULL, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for strategies vector */
    strategy_test_t null_strat = {&g, 0, IGRAPH_IMITATE_BLIND, &quant, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* empty graph */
    strategy_test_t empty_graph = {&h, 0, IGRAPH_IMITATE_BLIND, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of quantities vector different from number of vertices */
    strategy_test_t qdiff_length = {&g, 0, IGRAPH_IMITATE_BLIND, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of strategies vector different from number of vertices */
    strategy_test_t sdiff_length = {&g, 0, IGRAPH_IMITATE_BLIND, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    strategy_test_t unknown_algo = {&g, 0, -1, &quant, &strat, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    strategy_test_t *all_checks[] = {/* 1 */ &null_graph,
                                             /* 2 */ &null_quant,
                                             /* 3 */ &null_strat,
                                             /* 4 */ &empty_graph,
                                             /* 5 */ &qdiff_length,
                                             /* 6 */ &sdiff_length,
                                             /* 7 */ &unknown_algo
                                    };
    /* Run the error tests. We expect error to be raised for each test. */
    igraph_set_error_handler(igraph_error_handler_ignore);
    n = 7;
    i = 0;
    while (i < n) {
        test = all_checks[i];
        ret = igraph_stochastic_imitation(test->graph, test->vertex, test->algo,
                                          test->quantities, test->strategies,
                                          test->mode);
        if (ret != test->retval) {
            printf("Error test no. %d failed.\n", (int)(i + 1));
            return IGRAPH_FAILURE;
        }
        i++;
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_destroy(&h);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);

    return IGRAPH_SUCCESS;
}

/* Updating the strategy of an isolated vertex. In this case, the strategies
 * vector should not change at all.
 */
int isolated_vertex_test() {
    igraph_t g;
    igraph_vector_t quant, strat, v;
    int i, ret;

    /* graph with one isolated vertex */
    igraph_small(&g, /*n vertices*/ 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    igraph_add_vertices(&g, 1, 0);  /* new vertex 3 is isolated */
    /* quantities vector: all vertices have the same fitness */
    igraph_vector_init_real(&quant, 4, 0.25, 0.25, 0.25, 0.25);
    /* strategies vector: 0 means aggressive strategy; 1 means passive */
    igraph_vector_init_real(&strat, 4, 1.0, 0.0, 1.0, 0.0);
    /* make a copy of the original strategies vector for comparison later on */
    igraph_vector_copy(&v, &strat);
    /* Now update strategy of vertex 3. Since this vertex is isolated, no */
    /* strategy update would take place. The resulting strategies vector */
    /* would be the same as it was originally. */
    ret = igraph_stochastic_imitation(/*graph*/ &g,
            /*vertex*/ 3,
            /*algorithm*/ IGRAPH_IMITATE_BLIND,
            /*quantities*/ &quant,
            /*strategies*/ &strat,
            /*mode*/ IGRAPH_ALL);
    if (ret) {
        printf("Isolated vertex test failed.\n");
        return IGRAPH_FAILURE;
    }
    for (i = 0; i < igraph_vector_size(&strat); i++) {
        if (VECTOR(strat)[i] != VECTOR(v)[i]) {
            printf("Isolated vertex test failed.\n");
            return IGRAPH_FAILURE;
        }
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&v);

    return IGRAPH_SUCCESS;
}

/* A game on the Petersen graph. This graph has 10 vertices and 15 edges. The
 * Petersen graph is initialized with a default quantities vector and a
 * default strategies vector. Some vertices are chosen for strategy revision,
 * each one via a different stochastic imitation rule.
 */
int petersen_game_test() {
    igraph_t g;
    igraph_bool_t success;
    igraph_vector_t quant, strat, stratcopy, *knownstrats;
    igraph_vector_t known0, known2, known4;
    int i, k, n, nvert, ret;
    strategy_test_t *test;

    /* the Petersen graph */
    igraph_small(&g, /*n vertices*/ 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 0, 5, 1, 2, 1, 6, 2, 3, 2, 7, 3, 4, 3, 8, 4, 9,
                 5, 7, 5, 8, 6, 8, 6, 9, 7, 9, -1);
    nvert = igraph_vcount(&g);
    /* Strategies vector, one strategy for each vertex. Thus vec[i] is the */
    /* strategy of vertex i. The strategy space is: {0, 1, 2, 3}. */
    /* Each strategy should be an integer. */
    igraph_vector_init_real(&strat, nvert,
                            1.0, 1.0, 2.0, 2.0, 0.0,
                            0.0, 0.0, 1.0, 2.0, 3.0);
    /* Quantities vector, one quantity per vertex. Thus vec[i] is the */
    /* quantity for vertex i. */
    igraph_vector_init_real(&quant, nvert,
                            0.3, 1.1, 0.5, 1.0, 0.9,
                            0.8, 0.4, 0.1, 0.7, 0.7);
    /* parameter settings and known results */
    igraph_vector_init_real(&known0, 2, 0.0, 1.0);
    igraph_vector_init_real(&known2, 2, 1.0, 2.0);
    igraph_vector_init_real(&known4, 2, 0.0, 2.0);
    /*graph--vertex--algo--quantities--strategies--known_strats--mode--retval*/
    strategy_test_t blind0 = {&g, 0, IGRAPH_IMITATE_BLIND, &quant, NULL, &known0, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t augmented4 = {&g, 4, IGRAPH_IMITATE_AUGMENTED, &quant, NULL, &known4, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t contracted2 = {&g, 2, IGRAPH_IMITATE_CONTRACTED, &quant, NULL, &known2, IGRAPH_ALL, IGRAPH_SUCCESS};
    strategy_test_t *all_checks[] = {/* 1 */ &blind0,
                                             /* 2 */ &augmented4,
                                             /* 3 */ &contracted2
                                    };
    /* run the tests */
    n = 3;
    i = 0;
    while (i < n) {
        test = all_checks[i];
        igraph_vector_copy(&stratcopy, &strat);
        ret = igraph_stochastic_imitation(test->graph, test->vertex, test->algo,
                                          test->quantities, &stratcopy,
                                          test->mode);
        if (ret) {
            printf("Stochastic imitation failed for vertex %d.\n",
                   (int)test->vertex);
            return IGRAPH_FAILURE;
        }
        /* If the updated strategy for the vertex matches one of the known */
        /* strategies, then success. Default to failure. */
        success = 0;
        knownstrats = test->known_strats;
        for (k = 0; k < igraph_vector_size(knownstrats); k++) {
            if (VECTOR(*knownstrats)[k] == VECTOR(stratcopy)[test->vertex]) {
                success = 1;
                break;
            }
        }
        if (!success) {
            printf("Stochastic imitation failed for vertex %d.\n",
                   (int)test->vertex);
            return IGRAPH_FAILURE;
        }
        igraph_vector_destroy(&stratcopy);
        i++;
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_vector_destroy(&known0);
    igraph_vector_destroy(&known2);
    igraph_vector_destroy(&known4);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&strat);

    return IGRAPH_SUCCESS;
}

int main() {
    int ret;

    igraph_rng_seed(igraph_rng_default(), 547612);

    ret = error_tests();
    if (ret) {
        return ret;
    }
    ret = isolated_vertex_test();
    if (ret) {
        return ret;
    }
    ret = petersen_game_test();
    if (ret) {
        return ret;
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_strvector.c0000644000175100001710000001363500000000000026522 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

void strvector_print(const igraph_strvector_t *sv) {
    long int i, s = igraph_strvector_size(sv);
    for (i = 0; i < s; i++) {
        printf("---%s---\n", STR(*sv, i));
    }
}

int main() {

    igraph_strvector_t sv1, sv2;
    char *str1;
    int i;

    /* igraph_strvector_init, igraph_strvector_destroy */
    igraph_strvector_init(&sv1, 10);
    igraph_strvector_destroy(&sv1);
    igraph_strvector_init(&sv1, 0);
    igraph_strvector_destroy(&sv1);

    /* igraph_strvector_get, igraph_strvector_set */
    igraph_strvector_init(&sv1, 5);
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }
    igraph_strvector_set(&sv1, 0, "zero");
    igraph_strvector_set(&sv1, 1, "one");
    igraph_strvector_set(&sv1, 2, "two");
    igraph_strvector_set(&sv1, 3, "three");
    igraph_strvector_set(&sv1, 4, "four");
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }

    /* igraph_strvector_remove_section, igraph_strvector_remove,
       igraph_strvector_resize, igraph_strvector_size */
    igraph_strvector_remove_section(&sv1, 0, 5);
    if (igraph_strvector_size(&sv1) != 0) {
        return 1;
    }
    igraph_strvector_resize(&sv1, 10);
    igraph_strvector_set(&sv1, 0, "zero");
    igraph_strvector_set(&sv1, 1, "one");
    igraph_strvector_set(&sv1, 2, "two");
    igraph_strvector_set(&sv1, 3, "three");
    igraph_strvector_set(&sv1, 4, "four");
    igraph_strvector_resize(&sv1, 5);
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }
    igraph_strvector_resize(&sv1, 0);
    if (igraph_strvector_size(&sv1) != 0) {
        return 1;
    }
    igraph_strvector_resize(&sv1, 10);
    igraph_strvector_set(&sv1, 0, "zero");
    igraph_strvector_set(&sv1, 1, "one");
    igraph_strvector_set(&sv1, 2, "two");
    igraph_strvector_set(&sv1, 3, "three");
    igraph_strvector_set(&sv1, 4, "four");
    igraph_strvector_resize(&sv1, 5);
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }

    /* igraph_strvector_move_interval */
    igraph_strvector_move_interval(&sv1, 3, 5, 0);
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }

    /* igraph_strvector_copy */
    igraph_strvector_copy(&sv2, &sv1);
    for (i = 0; i < igraph_strvector_size(&sv2); i++) {
        igraph_strvector_get(&sv2, i, &str1);
        printf("---%s---\n", str1);
    }
    igraph_strvector_resize(&sv1, 0);
    igraph_strvector_destroy(&sv2);
    igraph_strvector_copy(&sv2, &sv1);
    if (igraph_strvector_size(&sv2) != 0) {
        return 2;
    }
    igraph_strvector_destroy(&sv2);

    /* igraph_strvector_add */
    igraph_strvector_add(&sv1, "zeroth");
    igraph_strvector_add(&sv1, "first");
    igraph_strvector_add(&sv1, "second");
    igraph_strvector_add(&sv1, "third");
    igraph_strvector_add(&sv1, "fourth");
    for (i = 0; i < igraph_strvector_size(&sv1); i++) {
        igraph_strvector_get(&sv1, i, &str1);
        printf("---%s---\n", str1);
    }

    /* TODO: igraph_strvector_permdelete */
    /* TODO: igraph_strvector_remove_negidx */

    igraph_strvector_destroy(&sv1);

    /* append */
    printf("---\n");
    igraph_strvector_init(&sv1, 0);
    igraph_strvector_init(&sv2, 0);
    igraph_strvector_append(&sv1, &sv2);
    strvector_print(&sv1);
    printf("---\n");

    igraph_strvector_resize(&sv1, 3);
    igraph_strvector_append(&sv1, &sv2);
    strvector_print(&sv1);
    printf("---\n");

    igraph_strvector_append(&sv2, &sv1);
    strvector_print(&sv2);
    printf("---\n");

    igraph_strvector_set(&sv1, 0, "0");
    igraph_strvector_set(&sv1, 1, "1");
    igraph_strvector_set(&sv1, 2, "2");
    igraph_strvector_set(&sv2, 0, "3");
    igraph_strvector_set(&sv2, 1, "4");
    igraph_strvector_set(&sv2, 2, "5");
    igraph_strvector_append(&sv1, &sv2);
    strvector_print(&sv1);

    igraph_strvector_destroy(&sv1);
    igraph_strvector_destroy(&sv2);

    /* clear */
    igraph_strvector_init(&sv1, 3);
    igraph_strvector_set(&sv1, 0, "0");
    igraph_strvector_set(&sv1, 1, "1");
    igraph_strvector_set(&sv1, 2, "2");
    igraph_strvector_clear(&sv1);
    if (igraph_strvector_size(&sv1) != 0) {
        return 3;
    }
    igraph_strvector_resize(&sv1, 4);
    strvector_print(&sv1);
    igraph_strvector_set(&sv1, 0, "one");
    igraph_strvector_set(&sv1, 2, "two");
    strvector_print(&sv1);
    igraph_strvector_destroy(&sv1);

    /* STR */

    igraph_strvector_init(&sv1, 5);
    igraph_strvector_set(&sv1, 0, "one");
    igraph_strvector_set(&sv1, 1, "two");
    igraph_strvector_set(&sv1, 2, "three");
    igraph_strvector_set(&sv1, 3, "four");
    igraph_strvector_set(&sv1, 4, "five");
    strvector_print(&sv1);
    igraph_strvector_destroy(&sv1);

    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        return 4;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_strvector.out0000644000175100001710000000112200000000000027073 0ustar00runnerdocker00000000000000------
------
------
------
------
---zero---
---one---
---two---
---three---
---four---
---zero---
---one---
---two---
---three---
---four---
---zero---
---one---
---two---
---three---
---four---
---three---
---four---
---two---
---three---
---four---
---three---
---four---
---two---
---three---
---four---
---zeroth---
---first---
---second---
---third---
---fourth---
---
---
------
------
------
---
------
------
------
---
---0---
---1---
---2---
---3---
---4---
---5---
------
------
------
------
---one---
------
---two---
------
---one---
---two---
---three---
---four---
---five---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_subisomorphic_lad.c0000644000175100001710000002233000000000000030165 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

/* This test counts motifs using LAD and compares the results with
 * the RANDESU motif finder */
void test_k_motifs(const igraph_t *graph, const int k, const int class_count, igraph_bool_t directed) {
    igraph_vector_t randesu_counts, lad_counts;
    igraph_vector_t cut_prob;
    igraph_bool_t equal;
    int i, n;
    igraph_integer_t vcount;
    igraph_real_t expected_count;

    vcount = igraph_vcount(graph);

    n = class_count;

    igraph_vector_init(&lad_counts, n);

    for (i = 0; i < n; i++) {
        igraph_t pattern;
        igraph_vector_ptr_t maps;
        igraph_integer_t nAutomorphisms;

        igraph_isoclass_create(&pattern, k, i, directed);
        igraph_vector_ptr_init(&maps, 0);

        igraph_subisomorphic_lad(&pattern, graph, NULL, NULL, NULL, &maps, /* induced = */ 1, 0);

        igraph_count_subisomorphisms_vf2(&pattern, &pattern, NULL, NULL, NULL, NULL, &nAutomorphisms, NULL, NULL, NULL);

        VECTOR(lad_counts)[i] = igraph_vector_ptr_size(&maps) / nAutomorphisms;

        IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&maps, igraph_vector_destroy);
        igraph_vector_ptr_destroy_all(&maps);

        igraph_destroy(&pattern);
    }

    igraph_vector_init(&cut_prob, k);
    igraph_vector_init(&randesu_counts, 0);
    igraph_motifs_randesu(graph, &randesu_counts, k, &cut_prob);

    equal = 1 /* true */;
    for (i = 0; i < n; i++) {
        if (igraph_is_nan(VECTOR(randesu_counts)[i])) {
            continue;
        }
        if (VECTOR(randesu_counts)[i] != VECTOR(lad_counts)[i]) {
            equal = 0;
            break;
        }
    }

    if (! equal) {
        printf("LAD %s %d-motif count does not agree with RANDESU.\n", directed ? "directed" : "undirected", k);
    }

    expected_count = 1;
    for (i = 0; i < k; i++) {
        expected_count *= (vcount - i);
    }
    for (i = 0; i < k; i++) {
        expected_count /= (i + 1);
    }
    if (igraph_vector_sum(&lad_counts) != expected_count) {
        printf("Total %d-vertex %s subgraph count is incorrect.\n", k, directed ? "directed" : "undirected");
    }

    igraph_vector_destroy(&randesu_counts);
    igraph_vector_destroy(&lad_counts);
    igraph_vector_destroy(&cut_prob);
}

void test_motifs() {
    igraph_t graph;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_erdos_renyi_game_gnm(&graph, 30, 400, /* directed = */ 1, /* loops = */ 0);

    test_k_motifs(&graph, 3, 16, /* directed= */ 1); /* there are 16 size-3 directed graphs */
    test_k_motifs(&graph, 4, 218, /* directed= */ 1); /* there are 218 size-4 directed graphs */

    igraph_destroy(&graph);
}

void test_motifs_undirected() {
    igraph_t graph;

    igraph_rng_seed(igraph_rng_default(), 137);

    igraph_erdos_renyi_game_gnm(&graph, 18, 100, /* directed = */ 0, /* loops = */ 0);

    test_k_motifs(&graph, 3, 4,   /* directed= */ 0);  /* there are 4   size-3 undirected graphs */
    test_k_motifs(&graph, 4, 11,  /* directed= */ 0);  /* there are 11  size-4 undirected graphs */

    igraph_destroy(&graph);

    /* Use a smaller graph so that the test would not take too long. */
    igraph_erdos_renyi_game_gnm(&graph, 9, 36, /* directed = */ 0, /* loops = */ 0);

    test_k_motifs(&graph, 5, 34,  /* directed= */ 0);  /* there are 34  size-5 undirected graphs */
    test_k_motifs(&graph, 6, 156, /* directed= */ 0);  /* there are 156 size-6 undirected graphs */

    igraph_destroy(&graph);
}


int main() {
    igraph_t target, pattern;
    igraph_bool_t iso;
    igraph_vector_t map;
    igraph_vector_ptr_t maps;
    int i, n, result;
    int domainsvec[] = { 0, 2, 8, -1,
                         4, 5, 6, 7, -1,
                         1, 3, 5, 6, 7, 8, -1,
                         0, 2, 8, -1,
                         1, 3, 7, 8, -1, -2
                       };
    igraph_vector_ptr_t domains;
    igraph_vector_t *v = 0;

    igraph_small(&target, 9, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 0, 6,
                 1, 0, 1, 4, 1, 2,
                 2, 1, 2, 3,
                 3, 2, 3, 4, 3, 5, 3, 7, 3, 8,
                 4, 0, 4, 1, 4, 3, 4, 5, 4, 6,
                 5, 6, 5, 4, 5, 3, 5, 8,
                 6, 0, 6, 4, 6, 5,
                 7, 3, 7, 8,
                 8, 5, 8, 3, 8, 7,
                 -1);
    igraph_simplify(&target, /*multiple=*/ 1, /*loops=*/ 0, /*edge_comb=*/ 0);

    igraph_small(&pattern, 5, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4,
                 1, 0, 1, 4, 1, 2,
                 2, 1, 2, 3,
                 3, 2, 3, 4,
                 4, 3, 4, 1, 4, 0,
                 -1);
    igraph_simplify(&pattern, /*multiple=*/ 1, /*loops=*/ 0, /*edge_comb=*/ 0);

    igraph_vector_init(&map, 0);
    igraph_vector_ptr_init(&maps, 0);

    igraph_subisomorphic_lad(&pattern, &target, /*domains=*/ 0, &iso, &map,
                             &maps, /*induced=*/ 0, /*time_limit=*/ 0);

    if (!iso) {
        return 1;
    }
    igraph_vector_print(&map);
    n = igraph_vector_ptr_size(&maps);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(maps)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    printf("---------\n");

    igraph_subisomorphic_lad(&pattern, &target, /*domains=*/ 0, &iso, &map,
                             &maps, /*induced=*/ 1, /*time_limit=*/ 0);

    if (!iso) {
        return 2;
    }
    igraph_vector_print(&map);
    n = igraph_vector_ptr_size(&maps);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(maps)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    printf("---------\n");

    igraph_vector_ptr_init(&domains, 0);
    i = 0;
    while (1) {
        if (domainsvec[i] == -2) {
            break;
        } else if (domainsvec[i] == -1) {
            igraph_vector_ptr_push_back(&domains, v);
            v = 0;
        } else {
            if (!v) {
                v = (igraph_vector_t *) malloc(sizeof(igraph_vector_t));
                igraph_vector_init(v, 0);
            }
            igraph_vector_push_back(v, domainsvec[i]);
        }
        i++;
    }

    igraph_subisomorphic_lad(&pattern, &target, &domains, &iso, &map, &maps,
                             /*induced=*/ 0, /*time_limit=*/ 0);

    if (!iso) {
        return 3;
    }
    igraph_vector_print(&map);
    n = igraph_vector_ptr_size(&maps);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(maps)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    n = igraph_vector_ptr_size(&domains);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(domains)[i];
        igraph_vector_destroy(v);
        free(v);
    }

    igraph_vector_ptr_destroy(&domains);
    igraph_vector_destroy(&map);
    igraph_vector_ptr_destroy(&maps);

    igraph_destroy(&pattern);
    igraph_destroy(&target);

    printf("---------\n");

    igraph_vector_init(&map, 0);
    igraph_vector_ptr_init(&maps, 0);

    igraph_small(&target, 9, IGRAPH_UNDIRECTED,
                 0, 1, 0, 4, 0, 6,
                 1, 0, 1, 4, 1, 2,
                 2, 1, 2, 3,
                 3, 2, 3, 4, 3, 5, 3, 7, 3, 8,
                 4, 0, 4, 1, 4, 3, 4, 5, 4, 6,
                 5, 6, 5, 4, 5, 3, 5, 8,
                 6, 0, 6, 4, 6, 5,
                 7, 3, 7, 8,
                 8, 5, 8, 3, 8, 7,
                 -1);
    igraph_simplify(&target, /*multiple=*/ 1, /*loops=*/ 0, /*edge_comb=*/ 0);

    igraph_small(&pattern, 0, IGRAPH_DIRECTED, -1);
    igraph_set_error_handler(igraph_error_handler_ignore);
    result = igraph_subisomorphic_lad(&pattern, &target, /*domains=*/ 0,
                                      &iso, &map, &maps, /*induced=*/ 0,
                                      /*time_limit=*/ 0);
    igraph_set_error_handler(igraph_error_handler_abort);
    if (result != IGRAPH_EINVAL) {
        return 4;
    }
    igraph_destroy(&pattern);

    igraph_small(&pattern, 0, IGRAPH_UNDIRECTED, -1);
    igraph_subisomorphic_lad(&pattern, &target, /*domains=*/ 0, &iso, &map, &maps,
                             /*induced=*/ 0, /*time_limit=*/ 0);
    if (!iso) {
        return 5;
    }
    if (igraph_vector_size(&map) != 0) {
        return 6;
    }
    if (igraph_vector_ptr_size(&maps) != 0) {
        return 7;
    }

    igraph_destroy(&pattern);
    igraph_destroy(&target);

    igraph_vector_destroy(&map);
    igraph_vector_ptr_destroy(&maps);

    test_motifs();
    test_motifs_undirected();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_subisomorphic_lad.out0000644000175100001710000000046600000000000030560 0ustar00runnerdocker000000000000001 0 6 5 4
1 0 6 5 4
0 1 2 3 4
5 3 2 1 4
7 3 4 5 8
4 3 7 8 5
8 3 4 6 5
0 4 3 5 6
0 4 3 2 1
3 4 0 6 5
6 4 3 8 5
5 4 1 2 3
5 4 1 0 6
1 4 5 6 0
8 5 6 4 3
4 5 8 7 3
3 5 6 0 4
6 5 8 3 4
0 6 5 3 4
5 6 0 1 4
7 8 5 4 3
---------
0 1 2 3 4
0 1 2 3 4
5 3 2 1 4
5 4 1 2 3
0 4 3 2 1
---------
0 4 3 2 1
0 4 3 2 1
---------
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_to_undirected.c0000644000175100001710000000323400000000000027311 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_vector_t v;
    igraph_t g;

    igraph_vector_init_int(&v, 2, 5, 5);
    igraph_lattice(&g, &v, 1, IGRAPH_DIRECTED, 1 /*mutual*/, 0 /*circular*/);
    igraph_to_undirected(&g, IGRAPH_TO_UNDIRECTED_COLLAPSE,
                         /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);

    igraph_destroy(&g);
    igraph_vector_destroy(&v);

    printf("---\n");

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                 0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3,
                 5, 6, 6, 5, 6, 7, 6, 7, 7, 6, 7, 8, 7, 8, 8, 7, 8, 7, 8, 8, 9, 9, 9, 9,
                 -1);
    igraph_to_undirected(&g, IGRAPH_TO_UNDIRECTED_MUTUAL,
                         /*edge_comb=*/ 0);
    igraph_write_graph_edgelist(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_to_undirected.out0000644000175100001710000000036100000000000027674 0ustar00runnerdocker000000000000000 1
0 5
1 2
1 6
2 3
2 7
3 4
3 8
4 9
5 6
5 10
6 7
6 11
7 8
7 12
8 9
8 13
9 14
10 11
10 15
11 12
11 16
12 13
12 17
13 14
13 18
14 19
15 16
15 20
16 17
16 21
17 18
17 22
18 19
18 23
19 24
20 21
21 22
22 23
23 24
---
5 6
6 7
7 8
7 8
8 8
9 9
9 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_topological_sorting.c0000644000175100001710000000304700000000000030544 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

int main() {
    igraph_t graph;
    igraph_vector_t res;

    /* Test graph taken from http://en.wikipedia.org/wiki/Topological_sorting
     * @ 05.03.2006 */
    igraph_small(&graph, 8, IGRAPH_DIRECTED,
                 0, 3, 0, 4, 1, 3, 2, 4, 2, 7, 3, 5, 3, 6, 3, 7, 4, 6,
                 -1);

    igraph_vector_init(&res, 0);

    /* Sort the vertices in "increasing" order. */
    igraph_topological_sorting(&graph, &res, IGRAPH_OUT);
    igraph_vector_print(&res);
    printf("\n");

    /* Sort the vertices in "decreasing" order. */
    igraph_topological_sorting(&graph, &res, IGRAPH_IN);
    igraph_vector_print(&res);

    /* Destroy data structures when done using them. */
    igraph_destroy(&graph);
    igraph_vector_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_topological_sorting.out0000644000175100001710000000004100000000000031120 0ustar00runnerdocker000000000000000 1 2 3 4 5 7 6

5 6 7 4 3 2 0 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_transitivity.c0000644000175100001710000000602500000000000027233 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_real_t res;

    /* Trivial cases */

    igraph_ring(&g, 100, IGRAPH_UNDIRECTED, 0, 0);
    igraph_transitivity_undirected(&g, &res, IGRAPH_TRANSITIVITY_NAN);
    igraph_destroy(&g);

    if (res != 0) {
        return 1;
    }

    igraph_full(&g, 20, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_transitivity_undirected(&g, &res, IGRAPH_TRANSITIVITY_NAN);
    igraph_destroy(&g);

    if (res != 1) {
        return 2;
    }

    /* Degenerate cases */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  2,  3,  4,  5, -1);
    igraph_transitivity_undirected(&g, &res, IGRAPH_TRANSITIVITY_NAN);
    /* res should be NaN here, any comparison must return false */
    if (res == 0 || res > 0 || res < 0) {
        return 4;
    }
    igraph_transitivity_undirected(&g, &res, IGRAPH_TRANSITIVITY_ZERO);
    /* res should be zero here */
    if (res) {
        return 5;
    }
    igraph_destroy(&g);

    /* Zachary Karate club */

    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_transitivity_undirected(&g, &res, IGRAPH_TRANSITIVITY_NAN);
    igraph_destroy(&g);

    if (res != 0.2556818181818181767717) {
        fprintf(stderr, "%f != %f\n", res, 0.2556818181818181767717);
        return 3;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_tree.c0000644000175100001710000000253000000000000025416 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_t graph;
    igraph_bool_t res;

    /* Create a directed binary tree on 15 nodes,
       with edges pointing towards the root. */
    igraph_tree(&graph, 15, 2, IGRAPH_TREE_IN);

    igraph_is_tree(&graph, &res, NULL, IGRAPH_IN);
    printf("Is it an in-tree? %s\n", res ? "Yes" : "No");

    igraph_is_tree(&graph, &res, NULL, IGRAPH_OUT);
    printf("Is it an out-tree? %s\n", res ? "Yes" : "No");

    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_tree.out0000644000175100001710000000005400000000000026002 0ustar00runnerdocker00000000000000Is it an in-tree? Yes
Is it an out-tree? No
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_union.c0000644000175100001710000001137300000000000025614 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include 
#include 

void print_vector(igraph_vector_t *v) {
    long int i, l = igraph_vector_size(v);
    for (i = 0; i < l; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int print_free_vector_ptr(igraph_vector_ptr_t *v) {
    long int i, l = igraph_vector_ptr_size(v);
    printf("---\n");
    for (i = 0; i < l; i++) {
        print_vector(VECTOR(*v)[i]);
        igraph_vector_destroy(VECTOR(*v)[i]);
        IGRAPH_FREE(VECTOR(*v)[i]);
    }
    printf("===\n");
    return 0;
}

int main() {

    igraph_t left, right, uni;
    igraph_vector_t v;
    igraph_vector_ptr_t glist;
    igraph_vector_t edge_map1, edge_map2;
    igraph_vector_ptr_t edgemaps;
    long int i;

    igraph_vector_init(&edge_map1, 0);
    igraph_vector_init(&edge_map2, 0);

    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 2, 2, 3, -1);
    igraph_create(&left, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_vector_init_int_end(&v, -1, 0, 1, 1, 2, 2, 2, 2, 4, -1);
    igraph_create(&right, &v, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&v);

    igraph_union(&uni, &left, &right, &edge_map1, &edge_map2);
    igraph_write_graph_edgelist(&uni, stdout);
    igraph_vector_print(&edge_map1);
    igraph_vector_print(&edge_map2);

    igraph_destroy(&uni);
    igraph_destroy(&left);
    igraph_destroy(&right);
    igraph_vector_destroy(&edge_map1);
    igraph_vector_destroy(&edge_map2);

    /* Empty graph list */
    igraph_vector_ptr_init(&glist, 0);
    igraph_vector_ptr_init(&edgemaps, 0);
    igraph_union_many(&uni, &glist, &edgemaps);
    if (!igraph_is_directed(&uni) || igraph_vcount(&uni) != 0) {
        return 1;
    }
    print_free_vector_ptr(&edgemaps);
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    /* Non-empty graph list */
    igraph_vector_ptr_init(&glist, 10);
    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        VECTOR(glist)[i] = calloc(1, sizeof(igraph_t));
        igraph_vector_init_int_end(&v, -1, 0, 1, 1, 0, -1);
        igraph_create(VECTOR(glist)[i], &v, 0, IGRAPH_DIRECTED);
        igraph_vector_destroy(&v);
    }

    igraph_union_many(&uni, &glist, &edgemaps);
    igraph_write_graph_edgelist(&uni, stdout);

    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        igraph_destroy(VECTOR(glist)[i]);
        free(VECTOR(glist)[i]);
    }
    print_free_vector_ptr(&edgemaps);
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    /* Another non-empty graph list */
    igraph_vector_ptr_init(&glist, 10);
    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        VECTOR(glist)[i] = calloc(1, sizeof(igraph_t));
        igraph_vector_init_int_end(&v, -1, i, i + 1, 1, 0, -1);
        igraph_create(VECTOR(glist)[i], &v, 0, IGRAPH_DIRECTED);
        igraph_vector_destroy(&v);
    }

    igraph_union_many(&uni, &glist, &edgemaps);
    igraph_write_graph_edgelist(&uni, stdout);

    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        igraph_destroy(VECTOR(glist)[i]);
        free(VECTOR(glist)[i]);
    }
    print_free_vector_ptr(&edgemaps);
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    /* Undirected graph list*/
    igraph_vector_ptr_init(&glist, 10);
    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        VECTOR(glist)[i] = calloc(1, sizeof(igraph_t));
        igraph_vector_init_int_end(&v, -1, i, i + 1, 1, 0, -1);
        igraph_create(VECTOR(glist)[i], &v, 0, IGRAPH_UNDIRECTED);
        igraph_vector_destroy(&v);
    }

    igraph_union_many(&uni, &glist, &edgemaps);
    igraph_write_graph_edgelist(&uni, stdout);

    for (i = 0; i < igraph_vector_ptr_size(&glist); i++) {
        igraph_destroy(VECTOR(glist)[i]);
        free(VECTOR(glist)[i]);
    }
    print_free_vector_ptr(&edgemaps);
    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&uni);

    igraph_vector_ptr_destroy(&edgemaps);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_union.out0000644000175100001710000000047600000000000026203 0ustar00runnerdocker000000000000000 1
1 2
2 2
2 3
2 4
0 1 2 3
0 1 2 4
---
===
0 1
1 0
---
 1 0
 1 0
 1 0
 1 0
 1 0
 1 0
 1 0
 1 0
 1 0
 1 0
===
0 1
1 0
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
---
 10 9
 8 9
 7 9
 6 9
 5 9
 4 9
 3 9
 2 9
 1 9
 0 9
===
0 1
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
---
 10 9
 8 9
 7 9
 6 9
 5 9
 4 9
 3 9
 2 9
 1 9
 0 9
===
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vector_ptr_sort.c0000644000175100001710000000257000000000000027721 0ustar00runnerdocker00000000000000
#include 
#include 

int main() {
    igraph_t graph;
    igraph_vector_ptr_t cliques;
    long int i, n;

    /* Set a random seed to make the program deterministic */
    igraph_rng_seed(igraph_rng_default(), 31415);

    /* Create a random graph with a given number of vertices and edges */
    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 15, 80, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    /* Find all maximal cliques in the graph */
    igraph_vector_ptr_init(&cliques, 0);
    igraph_maximal_cliques(&graph, &cliques, -1, -1);

    /* Print the cliques in lexicographical order */
    printf("Maximal cliques in lexicographical order:\n");
    igraph_vector_ptr_sort(&cliques, igraph_vector_lex_cmp);
    n = igraph_vector_ptr_size(&cliques);
    for (i=0; i < n; ++i) {
        igraph_vector_print(VECTOR(cliques)[i]);
    }

    /* Print the cliques in colexicographical order */
    printf("\nMaximal cliques in colexicographical order:\n");
    igraph_vector_ptr_sort(&cliques, igraph_vector_colex_cmp);
    n = igraph_vector_ptr_size(&cliques);
    for (i=0; i < n; ++i) {
        igraph_vector_print(VECTOR(cliques)[i]);
    }

    /* Destroy data structures when we no longer need them */

    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&cliques, igraph_vector_destroy);
    igraph_vector_ptr_destroy_all(&cliques);

    igraph_destroy(&graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_version.c0000644000175100001710000000226400000000000026150 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    char tmp[100];
    const char *string;
    int major, minor, subminor;

    igraph_version(&string, &major, &minor, &subminor);
    sprintf(tmp, "%i.%i.%i", major, minor, subminor);

    if (strncmp(string, tmp, strlen(tmp))) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_nonadj.c0000644000175100001710000000352300000000000026443 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main () {

    igraph_t g;
    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_integer_t size;

    /* empty graph, all vertices */
    igraph_empty(&g, 10, IGRAPH_DIRECTED);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vs_size(&g, &vs, &size);
    printf("%li ", (long int) size);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%li ", (long int) IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    /* full graph, no vertices */
    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%li ", (long int) IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);


    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_nonadj.out0000644000175100001710000000003100000000000027017 0ustar00runnerdocker0000000000000010 0 1 2 3 4 5 6 7 8 9 

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_seq.c0000644000175100001710000000262700000000000025766 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_t g;
    igraph_integer_t size;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vs_seq(&vs, 0, 9);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%li", (long int) size);

    while (!IGRAPH_VIT_END(vit)) {
        printf(" %li", (long int)IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_seq.out0000644000175100001710000000002700000000000026343 0ustar00runnerdocker0000000000000010 0 1 2 3 4 5 6 7 8 9
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_vector.c0000644000175100001710000000442400000000000026475 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t v = IGRAPH_VECTOR_NULL;
    igraph_real_t edges[] = { 0, 1, 1, 2, 2, 2, 2, 3, 2, 4, 3, 4 };
    igraph_vector_t v2;
    long int i;
    igraph_vit_t vit;
    igraph_vs_t vs;
    igraph_integer_t size;

    igraph_vector_view(&v, edges, sizeof(edges) / sizeof(igraph_real_t));
    igraph_create(&g, &v, 0, IGRAPH_DIRECTED);

    /* Create iterator based on a vector (view) */
    igraph_vector_init(&v2, 6);
    VECTOR(v2)[0] = 0;
    VECTOR(v2)[1] = 2;
    VECTOR(v2)[2] = 4;
    VECTOR(v2)[3] = 0;
    VECTOR(v2)[4] = 2;
    VECTOR(v2)[5] = 4;

    igraph_vit_create(&g, igraph_vss_vector(&v2), &vit);

    i = 0;
    while (!IGRAPH_VIT_END(vit)) {
        if (IGRAPH_VIT_GET(vit) != VECTOR(v2)[i]) {
            return 1;
        }
        IGRAPH_VIT_NEXT(vit);
        i++;
    }
    if (i != igraph_vector_size(&v2)) {
        return 2;
    }

    igraph_vit_destroy(&vit);
    igraph_vector_destroy(&v2);

    /* Create small vector iterator */

    igraph_vs_vector_small(&vs, 0, 2, 4, 0, 2, 4, 2, -1);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%li ", (long int) size);
    for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        printf("%li ", (long int) IGRAPH_VIT_GET(vit));
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);

    /* Clean up */

    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_vs_vector.out0000644000175100001710000000002100000000000027047 0ustar00runnerdocker000000000000007 0 2 4 0 2 4 2 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_weighted_adjacency.c0000644000175100001710000000571100000000000030264 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

void print(igraph_t *g) {
    igraph_vector_t el;
    long int i, j, n;
    char ch = igraph_is_directed(g) ? '>' : '-';

    igraph_vector_init(&el, 0);
    igraph_get_edgelist(g, &el, 0);
    n = igraph_ecount(g);

    for (i = 0, j = 0; i < n; i++, j += 2) {
        printf("%ld --%c %ld: %ld\n",
               (long)VECTOR(el)[j], ch, (long)VECTOR(el)[j + 1], (long)EAN(g, "weight", i));
    }
    printf("\n");

    igraph_vector_destroy(&el);
}

int main() {
    igraph_t g;
    igraph_matrix_t mat;
    int m[4][4] = { { 0, 1, 2, 0 }, { 2, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 1, 0, 0 } };
    long int i, j;

    igraph_matrix_init(&mat, 4, 4);
    for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
            MATRIX(mat, i, j) = m[i][j];
        }
    igraph_set_attribute_table(&igraph_cattribute_table);

    /* [ 0 1 2 0 ]
       [ 2 0 0 1 ]
       [ 0 0 1 0 ]
       [ 0 1 0 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_DIRECTED, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    /* [ 0 1 2 0 ]
       [ - 0 0 1 ]
       [ - - 1 0 ]
       [ - - - 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_UPPER, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    /* [ 0 - - - ]
       [ 2 0 - - ]
       [ 0 0 1 - ]
       [ 0 1 0 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_LOWER, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    /* [ 0 1 0 0 ]
       [ 1 0 0 1 ]
       [ 0 0 1 0 ]
       [ 0 1 0 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_MIN, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    /* [ 0 2 2 0 ]
       [ 2 0 0 1 ]
       [ 2 0 1 0 ]
       [ 0 1 0 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_MAX, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    /* [ 0 3 2 0 ]
       [ 3 0 0 2 ]
       [ 2 0 1 0 ]
       [ 0 2 0 0 ] */
    igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_PLUS, 0, /*loops=*/ 1);
    print(&g);
    igraph_destroy(&g);

    igraph_matrix_destroy(&mat);

    if (IGRAPH_FINALLY_STACK_SIZE() != 0) {
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_weighted_adjacency.out0000644000175100001710000000041600000000000030646 0ustar00runnerdocker000000000000000 --> 1: 1
0 --> 2: 2
1 --> 0: 2
1 --> 3: 1
2 --> 2: 1
3 --> 1: 1

0 --- 1: 1
0 --- 2: 2
1 --- 3: 1
2 --- 2: 1

0 --- 1: 2
2 --- 2: 1
1 --- 3: 1

0 --- 1: 1
1 --- 3: 1
2 --- 2: 1

0 --- 1: 2
0 --- 2: 2
1 --- 3: 1
2 --- 2: 1

0 --- 1: 3
0 --- 2: 2
1 --- 3: 2
2 --- 2: 1

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_write_graph_lgl.c0000644000175100001710000000217700000000000027637 0ustar00runnerdocker00000000000000#include 

int main() {

    igraph_t g;
    igraph_strvector_t names, weights;
    int i;
    char str[2] = " ";
    igraph_set_attribute_table(&igraph_cattribute_table);
    igraph_small(&g, 7, IGRAPH_UNDIRECTED, 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, -1);


    printf("Output without isolates:\n");
    igraph_write_graph_lgl(&g, stdout, /*names*/ NULL, /*weights*/ NULL, /*isolates*/ 0);


    printf("\nOutput with isolates:\n");
    igraph_write_graph_lgl(&g, stdout, /*names*/ NULL, /*weights*/ NULL, /*isolates*/ 1);


    printf("\nOutput vertex and edge labels:\n");
    igraph_strvector_init(&names, 7);
    for (i = 0; i < 7; i++) {
        str[0] = 'A' + i;
        igraph_strvector_set(&names, i, str);
    }
    SETVASV(&g, "names", &names);

    igraph_strvector_init(&weights, 6);
    for (i = 0; i < 6; i++) {
        str[0] = '3' + i;
        igraph_strvector_set(&weights, i, str);
    }
    SETEASV(&g, "weights", &weights);

    igraph_write_graph_lgl(&g, stdout, "names", "weights", /*isolates*/ 0);

    igraph_strvector_destroy(&names);
    igraph_strvector_destroy(&weights);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_write_graph_lgl.out0000644000175100001710000000027000000000000030214 0ustar00runnerdocker00000000000000Output without isolates:
# 0
1
2
# 1
2
3
# 2
4
# 3
4

Output with isolates:
# 0
1
2
# 1
2
3
# 2
4
# 3
4
# 5
# 6

Output vertex and edge labels:
# A
B 3
C 4
# B
C 5
D 6
# C
E 7
# D
E 8
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_write_graph_pajek.c0000644000175100001710000000475300000000000030155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_strvector_t names;

    igraph_set_attribute_table(&igraph_cattribute_table);

    /* save a simple ring graph */
    igraph_ring(&g, 10, IGRAPH_DIRECTED, 0 /* mutual */, 1 /* circular */);
    igraph_write_graph_pajek(&g, stdout);

    /* add some vertex attributes */
    igraph_strvector_init(&names, 0);
    igraph_strvector_add(&names, "A");
    igraph_strvector_add(&names, "B");
    igraph_strvector_add(&names, "C");
    igraph_strvector_add(&names, "D");
    igraph_strvector_add(&names, "E");
    igraph_strvector_add(&names, "F");
    igraph_strvector_add(&names, "G");
    igraph_strvector_add(&names, "H");
    igraph_strvector_add(&names, "I");
    igraph_strvector_add(&names, "J");
    SETVASV(&g, "id", &names);
    igraph_strvector_destroy(&names);

    /* save the graph with vertex names */
    igraph_write_graph_pajek(&g, stdout);

    igraph_strvector_init(&names, 0);
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "escaping spaces");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "escaping \\backslashes\\");
    igraph_strvector_add(&names, "square");
    igraph_strvector_add(&names, "escaping \"quotes\"");
    SETVASV(&g, "shape", &names);
    igraph_strvector_destroy(&names);

    /* save the graph with escaped shapes */
    igraph_write_graph_pajek(&g, stdout);

    /* destroy the graph */
    igraph_destroy(&g);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/igraph_write_graph_pajek.out0000644000175100001710000000066300000000000030536 0ustar00runnerdocker00000000000000*Vertices 10
*Arcs
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 1
*Vertices 10
1 "A"
2 "B"
3 "C"
4 "D"
5 "E"
6 "F"
7 "G"
8 "H"
9 "I"
10 "J"
*Arcs
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 1
*Vertices 10
1 "A" "square"
2 "B" "square"
3 "C" "square"
4 "D" "square"
5 "E" "escaping spaces"
6 "F" "square"
7 "G" "square"
8 "H" "escaping \\backslashes\\"
9 "I" "square"
10 "J" "escaping \"quotes\""
*Arcs
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/iso_b03_m1000.A000000644000175100001710000001161200000000000025277 0ustar00runnerdocker00000000000000èÓ%·6·@iki­Çµ¸m
=âÃD7‰]c ÷5h†GÜ„(
oÛè%z³É8ö<dæ~AÿØ’y`­<¨Þ.¬¿ •Ø’öÇô3ú‡`5±¹@‰ÈvE~†Õ*÷ßô‰Â¤Ô3üÍ'=F
"sÕÈ‹m}aï†R¹Œ
fª.¤ÑY6Ãñƒoˆí+¸§7“oD¡£>{0ðÎsc‚QYó[ìCÙœ£ÇÅ>_V‹Ædÿ[,ê	xÖ‚û„Ú×–µÂGSèÄ<˳‘J¸Z©¢°Ž¿Is›Ë«Ç3Àê°fcÌM¾¹¹ÂåAüͧïã­’Ž» ¤$±y¯š•Ù‚p±CóôTÉU-ljÊ¡~/Ì«:@tD¨Ðžf¹=r„¸1ÿúyž±ŠxWÖ%ÞA&Á$¼üÒ0?ƒ1n>,˜×}…g™i{¤FsßHùÇ€ZéÚËÚˇM¯‡¾€á{r£8Š(^î6?ÜùthU³ð¡ã5aûžá—÷ÉN ~o†¬5û/3oXhµæM(§-æ‚à<`vϸ"u¢¸If᥮ö²&,B|š`ÀÞ Ò:-¨	^-¤åXz™aºùÇ“²BQÍŽ»jÓ»ñöéªUmw@§ðsz›‰I1`Ù93ú{¾kv0=T–¸¨˜öÙ?/	¥´Î•ŠòÇRæY!®‚øbu\ÓtdáeD¡Õ|ÑlTº@U-tkr mg™áf™„S—áÐz˜NÎJ‚å œ”“Ae´â2?UãDü`[,M*k
y«(4	ÚqZ¶ùçïNm¼Ò×x’'5£ûcP}<Dqº¶à{ªu¥èÄPØýÚ8YóNGhÚ‰÷epë‡0µµ¸:òn£ã—ä[š‘Õ¬’ò™Vb˜dåÔ|ªC‹;=†¥&J½;äîˆé¶uígïÔ‰4®ZéÕKyv[–•4%†^!ÑYiŠ@Á%)ÉÉ ³¨d¬î…é×CåØÌ«Îm‘–bÊÃÜÇ#ºç{܃©„Üg¢'Ðz7«
jÞЛ µ5]
*Î/[ˆ÷”6Z“x’Žmß	
PŽšŒ¥åã¯1”ÖÎb̯xà[©²bNJ³BQž¦†Á¯ÒqÂoç1°=jTŸ¨¶é+Xºá\P0;E^­ía²AS2>_2¬±"N܆ÃÜR¬*T®ÅÐ/Ež;n´*¦9@ÖùÈ}‡
ãºd-ƹIú"Ú» z!Ð.‹HƒŽÕkt&…[wq³ð"/,{Ö}ÿ¥´ÑY?ˆí7Ä™6xà’·EOêÌKȲšñH8ƒŒN{O[–Cegç±&

ex+$Ù^+s+ç5š“©)&ךþ†ÜT0­@ȇ/¤:¾E^ëæb©#‹«Tv•LÒ+Īê-eÅ PøÞWJ™âŒ#¥|¦ôwˆ³i$Í ö6ZÆÍËi4?Ï¿ÖQ
>Ë$Ñ[W×PÝ=߽ů1‘U\VüÇ~½ß^É}¶…ÊŽèßhaÈêFÙê?¿Ïg?'K·}]iƒp¾±˜½å8GJŠ]•Õ|(ÏŸš(Ïf¦QúGo<èŒa)–’õrI&_“©	9	GX¬îzd¬4LY 6Bö” ë³Pº™®f£î˜ÛP$;N!æ­âð\Q÷Š©Å§±&:Z¶¡Rþa9"Yò®Ÿ©õ¸ÃìDÆC¼Ó,mó^¦Í÷¾0J ‘j1«ç{Ñ-©„o¢ò]cõFÈtý,,49O_w°G¨°Žr'4ß:Ó®7Äm}XŽ)Ê‘Þ4#Mл@Ÿn˜Ùï œ5ÿF¿Šü.A<\Z8‰F¿'=ë¨]E§¨)´ø¬£°ü[s.Uf»I®$–ïsºÁ•úv»7u3•Íܵt’ÿAI././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/karate.gml0000644000175100001710000001014200000000000024727 0ustar00runnerdocker00000000000000Creator "Mark Newman on Fri Jul 21 12:39:27 2006"
graph
[
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  node
  [
    id 4
  ]
  node
  [
    id 5
  ]
  node
  [
    id 6
  ]
  node
  [
    id 7
  ]
  node
  [
    id 8
  ]
  node
  [
    id 9
  ]
  node
  [
    id 10
  ]
  node
  [
    id 11
  ]
  node
  [
    id 12
  ]
  node
  [
    id 13
  ]
  node
  [
    id 14
  ]
  node
  [
    id 15
  ]
  node
  [
    id 16
  ]
  node
  [
    id 17
  ]
  node
  [
    id 18
  ]
  node
  [
    id 19
  ]
  node
  [
    id 20
  ]
  node
  [
    id 21
  ]
  node
  [
    id 22
  ]
  node
  [
    id 23
  ]
  node
  [
    id 24
  ]
  node
  [
    id 25
  ]
  node
  [
    id 26
  ]
  node
  [
    id 27
  ]
  node
  [
    id 28
  ]
  node
  [
    id 29
  ]
  node
  [
    id 30
  ]
  node
  [
    id 31
  ]
  node
  [
    id 32
  ]
  node
  [
    id 33
  ]
  node
  [
    id 34
  ]
  edge
  [
    source 2
    target 1
  ]
  edge
  [
    source 3
    target 1
  ]
  edge
  [
    source 3
    target 2
  ]
  edge
  [
    source 4
    target 1
  ]
  edge
  [
    source 4
    target 2
  ]
  edge
  [
    source 4
    target 3
  ]
  edge
  [
    source 5
    target 1
  ]
  edge
  [
    source 6
    target 1
  ]
  edge
  [
    source 7
    target 1
  ]
  edge
  [
    source 7
    target 5
  ]
  edge
  [
    source 7
    target 6
  ]
  edge
  [
    source 8
    target 1
  ]
  edge
  [
    source 8
    target 2
  ]
  edge
  [
    source 8
    target 3
  ]
  edge
  [
    source 8
    target 4
  ]
  edge
  [
    source 9
    target 1
  ]
  edge
  [
    source 9
    target 3
  ]
  edge
  [
    source 10
    target 3
  ]
  edge
  [
    source 11
    target 1
  ]
  edge
  [
    source 11
    target 5
  ]
  edge
  [
    source 11
    target 6
  ]
  edge
  [
    source 12
    target 1
  ]
  edge
  [
    source 13
    target 1
  ]
  edge
  [
    source 13
    target 4
  ]
  edge
  [
    source 14
    target 1
  ]
  edge
  [
    source 14
    target 2
  ]
  edge
  [
    source 14
    target 3
  ]
  edge
  [
    source 14
    target 4
  ]
  edge
  [
    source 17
    target 6
  ]
  edge
  [
    source 17
    target 7
  ]
  edge
  [
    source 18
    target 1
  ]
  edge
  [
    source 18
    target 2
  ]
  edge
  [
    source 20
    target 1
  ]
  edge
  [
    source 20
    target 2
  ]
  edge
  [
    source 22
    target 1
  ]
  edge
  [
    source 22
    target 2
  ]
  edge
  [
    source 26
    target 24
  ]
  edge
  [
    source 26
    target 25
  ]
  edge
  [
    source 28
    target 3
  ]
  edge
  [
    source 28
    target 24
  ]
  edge
  [
    source 28
    target 25
  ]
  edge
  [
    source 29
    target 3
  ]
  edge
  [
    source 30
    target 24
  ]
  edge
  [
    source 30
    target 27
  ]
  edge
  [
    source 31
    target 2
  ]
  edge
  [
    source 31
    target 9
  ]
  edge
  [
    source 32
    target 1
  ]
  edge
  [
    source 32
    target 25
  ]
  edge
  [
    source 32
    target 26
  ]
  edge
  [
    source 32
    target 29
  ]
  edge
  [
    source 33
    target 3
  ]
  edge
  [
    source 33
    target 9
  ]
  edge
  [
    source 33
    target 15
  ]
  edge
  [
    source 33
    target 16
  ]
  edge
  [
    source 33
    target 19
  ]
  edge
  [
    source 33
    target 21
  ]
  edge
  [
    source 33
    target 23
  ]
  edge
  [
    source 33
    target 24
  ]
  edge
  [
    source 33
    target 30
  ]
  edge
  [
    source 33
    target 31
  ]
  edge
  [
    source 33
    target 32
  ]
  edge
  [
    source 34
    target 9
  ]
  edge
  [
    source 34
    target 10
  ]
  edge
  [
    source 34
    target 14
  ]
  edge
  [
    source 34
    target 15
  ]
  edge
  [
    source 34
    target 16
  ]
  edge
  [
    source 34
    target 19
  ]
  edge
  [
    source 34
    target 20
  ]
  edge
  [
    source 34
    target 21
  ]
  edge
  [
    source 34
    target 23
  ]
  edge
  [
    source 34
    target 24
  ]
  edge
  [
    source 34
    target 27
  ]
  edge
  [
    source 34
    target 28
  ]
  edge
  [
    source 34
    target 29
  ]
  edge
  [
    source 34
    target 30
  ]
  edge
  [
    source 34
    target 31
  ]
  edge
  [
    source 34
    target 32
  ]
  edge
  [
    source 34
    target 33
  ]
]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/links.net0000644000175100001710000000176300000000000024620 0ustar00runnerdocker00000000000000*Network TRALALA
*vertices 4
   1 "1"                                           0.0938 0.0896   ellipse x_fact 1 y_fact 1
   2 "2"                                           0.8188 0.2458   ellipse x_fact 1 y_fact 1
   3 "3"                                           0.3688 0.7792   ellipse x_fact 1
   4 "4"                                           0.9583 0.8563   ellipse x_fact 1
*arcs
1 1 1  h2 0 w 3 c Blue s 3 a1 -130 k1 0.6 a2 -130 k2 0.6 ap 0.5 l "Bezier loop" lc BlueViolet fos 20 lr 58 lp 0.3 la 360
2 1 1  h2 0 a1 120 k1 1.3 a2 -120 k2 0.3 ap 25 l "Bezier arc" lphi 270 la 180 lr 19 lp 0.5
1 2 1  h2 0 a1 40 k1 2.8 a2 30 k2 0.8 ap 25 l "Bezier arc" lphi 90 la 0 lp 0.65
4 2 -1  h2 0 w 1 k1 -2 k2 250 ap 25 l "Circular arc" c Red lc OrangeRed
3 4 1  p Dashed h2 0 w 2 c OliveGreen ap 25 l "Straight arc" lc PineGreen
1 3 1  p Dashed h2 0 w 5 k1 -1 k2 -20 ap 25 l "Oval arc" c Brown lc Black
3 3 -1  h1 6 w 1 h2 12 k1 -2 k2 -15 ap 0.5 l "Circular loop" c Red lc OrangeRed lphi 270 la 180
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/nodelist1.dl0000644000175100001710000000013200000000000025200 0ustar00runnerdocker00000000000000DL n=5
format = nodelist1
labels:
george, sally, jim, billy, jane
data:
1 2 3
2 3
3 1
4 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/nodelist2.dl0000644000175100001710000000014200000000000025202 0ustar00runnerdocker00000000000000DL n=5
format = nodelist1
labels embedded:
data:
george sally jim
sally jim
billy george
jane jim
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/random_seed.c0000644000175100001710000000156100000000000025410 0ustar00runnerdocker00000000000000
#include 

int main() {

    igraph_t g1, g2;
    igraph_bool_t iso;

    /* Seed the default random number generator and create a random graph. */

    igraph_rng_seed(igraph_rng_default(), 1122);

    igraph_erdos_renyi_game(&g1, IGRAPH_ERDOS_RENYI_GNP,
                            100, 3.0 / 100, /*directed=*/ 0, /*loops=*/ 0);

    /* Seed the generator with the same seed again,
     * and create a graph with the same method. */

    igraph_rng_seed(igraph_rng_default(), 1122);

    igraph_erdos_renyi_game(&g2, IGRAPH_ERDOS_RENYI_GNP,
                            100, 3.0 / 100, /*directed=*/ 0, /*loops=*/ 0);

    /* The two graphs will be identical. */

    igraph_is_same_graph(&g1, &g2, &iso);

    if (!iso) {
        return 1;
    }

    /* Destroy no longer needed data structures. */

    igraph_destroy(&g2);
    igraph_destroy(&g1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/scg.c0000644000175100001710000001356600000000000023714 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    igraph_vector_t ev;
    igraph_t scg_graph;
    igraph_matrix_t scg_matrix;
    igraph_sparsemat_t scg_sparsemat;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_matrix_t input_matrix;
    igraph_vector_t groups;
    igraph_vector_t eval;
    igraph_matrix_t evec;

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_vector_init(&ev, 1);
    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&scg_matrix, 0, 0);
    igraph_vector_init(&groups, 0);
    igraph_vector_init(&eval, 0);
    igraph_matrix_init(&evec, 0, 0);

#define CALLSYM(algo) do {                      \
        igraph_vector_clear(&eval);                     \
        igraph_matrix_resize(&evec, 0, 0);                  \
        igraph_scg_adjacency(&g, /*matrix=*/ 0, /*sparsemat=*/ 0, &ev,  \
                             /* intervals= */ 3, /* intervals_vector= */ 0, \
                             /* algorithm= */ algo, &eval, &evec,       \
                             /* groups= */ &groups, /* use_arpack= */ 0,    \
                             /* maxiter= */ 0, &scg_graph, &scg_matrix, \
                             &scg_sparsemat, &L, &R,            \
                             &Lsparse, &Rsparse); } while(0)


#define PRINTRES()                      \
    do {                              \
        printf("------------------------------------\n");       \
        igraph_write_graph_edgelist(&scg_graph, stdout);        \
        printf("---\n");                        \
        igraph_vector_print(&groups);               \
        printf("---\n");                        \
        igraph_vector_print(&eval);                 \
        igraph_matrix_print(&evec);                 \
        printf("---\n");                        \
        igraph_sparsemat_print(&scg_sparsemat, stdout);     \
        printf("---\n");                        \
        igraph_sparsemat_print(&Lsparse, stdout);           \
        printf("---\n");                        \
        igraph_sparsemat_print(&Rsparse, stdout);           \
        printf("---\n");                        \
    } while (0)

    VECTOR(ev)[0] = 1;
    CALLSYM(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    VECTOR(ev)[0] = 3;
    CALLSYM(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_vector_resize(&ev, 2);
    VECTOR(ev)[0] = 1;
    VECTOR(ev)[1] = 3;
    CALLSYM(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

#define CALLSYM2(algo) do {                     \
        igraph_vector_clear(&eval);                     \
        igraph_matrix_resize(&evec, 0, 0);                  \
        igraph_scg_adjacency(/* graph=*/ 0, &input_matrix, /*sparsemat=*/ 0, \
                                         &ev, /* intervals= */ 3,           \
                                         /* intervals_vector= */ 0,         \
                                         /* algorithm= */ algo, &eval, &evec,       \
                                         /* groups= */ &groups, /* use_arpack= */ 0,    \
                                         /* maxiter= */ 0, &scg_graph, &scg_matrix, \
                                         &scg_sparsemat, &L, &R,            \
                                         &Lsparse, &Rsparse); } while (0)

    igraph_matrix_init(&input_matrix, 0, 0);
    igraph_get_adjacency(&g, &input_matrix, IGRAPH_GET_ADJACENCY_BOTH,
                         /* eids= */ 0);

    igraph_vector_resize(&ev, 1);
    VECTOR(ev)[0] = 1;
    CALLSYM2(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    VECTOR(ev)[0] = 3;
    CALLSYM2(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_vector_resize(&ev, 2);
    VECTOR(ev)[0] = 1;
    VECTOR(ev)[1] = 3;
    CALLSYM2(IGRAPH_SCG_EXACT);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_matrix_destroy(&evec);
    igraph_vector_destroy(&eval);
    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&input_matrix);
    igraph_matrix_destroy(&scg_matrix);
    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_vector_destroy(&ev);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------- */

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/scg.out0000644000175100001710000000714600000000000024276 0ustar00runnerdocker00000000000000------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
2.33441
-0.5
-0.47651
-0.47651
-0.214186
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
---
col 0: locations 0 to 1
1 : 1.41421
2 : 1
col 1: locations 2 to 3
0 : 1.41421
3 : 1.73205
col 2: locations 4 to 4
0 : 1
col 3: locations 5 to 5
1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
0.741964
0.5
-0.151453
-0.151453
0.673887
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
---
col 0: locations 0 to 1
1 : 1.41421
2 : 1
col 1: locations 2 to 3
0 : 1.41421
3 : 1.73205
col 2: locations 4 to 4
0 : 1
col 3: locations 5 to 5
1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
2.33441 0.741964
-0.5 0.5
-0.47651 -0.151453
-0.47651 -0.151453
-0.214186 0.673887
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
---
col 0: locations 0 to 1
1 : 1.41421
2 : 1
col 1: locations 2 to 3
0 : 1.41421
3 : 1.73205
col 2: locations 4 to 4
0 : 1
col 3: locations 5 to 5
1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
2.33441
-0.5
-0.47651
-0.47651
-0.214186
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
---
0 1 : 1.41421
0 2 : 1
1 0 : 1.41421
1 3 : 1.73205
2 0 : 1
3 1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
0.741964
0.5
-0.151453
-0.151453
0.673887
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
-0.204124
---
0 1 : 1.41421
0 2 : 1
1 0 : 1.41421
1 3 : 1.73205
2 0 : 1
3 1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
------------------------------------
0 1
0 2
1 3
---
0 1 1 2 3 3 3 3 3 3
---
2.33441 0.741964
-0.5 0.5
-0.47651 -0.151453
-0.47651 -0.151453
-0.214186 0.673887
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
-0.204124 -0.204124
---
0 1 : 1.41421
0 2 : 1
1 0 : 1.41421
1 3 : 1.73205
2 0 : 1
3 1 : 1.73205
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
0 0 : 1
1 1 : 0.707107
1 2 : 0.707107
2 3 : 1
3 4 : 0.408248
3 5 : 0.408248
3 6 : 0.408248
3 7 : 0.408248
3 8 : 0.408248
3 9 : 0.408248
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/test.gxl0000644000175100001710000000362000000000000024455 0ustar00runnerdocker00000000000000


  
    yellow
  
  
  
  
  
    1
  
  
    2006-11-12
    
      green
      incorrect
      
      true
    
    
    
      blue
      0
    
    
      red "with entities"
    
    
      
      false
    
    
      turquoise
      fAlSe
    
    
      1.0
    
    
      1.0
    
    
      2.0
    
    
    
    
    
      1.1
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/walktrap.c0000644000175100001710000000457700000000000024767 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    igraph_t g;
    igraph_matrix_t merges;
    igraph_vector_t modularity;
    long int no_of_nodes;
    long int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&g, 5, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9, 0, 5, -1);
    igraph_vector_init(&modularity, 0);
    igraph_matrix_init(&merges, 0, 0);

    igraph_community_walktrap(&g, 0 /* no weights */,
                              4 /* steps */,
                              &merges, &modularity,
                              /* membership=*/ 0);

    no_of_nodes = igraph_vcount(&g);
    printf("Merges:\n");
    for (i = 0; i < igraph_matrix_nrow(&merges); i++) {
        printf("%2.1li + %2.li -> %2.li (modularity %4.2f)\n",
               (long int)MATRIX(merges, i, 0),
               (long int)MATRIX(merges, i, 1),
               no_of_nodes + i,
               VECTOR(modularity)[i]);
    }

    igraph_destroy(&g);

    /* isolated vertices */
    igraph_small(&g, 5, IGRAPH_UNDIRECTED, -1);
    if (igraph_community_walktrap(&g, 0 /* no weights */, 4 /* steps */, &merges,
                                  &modularity, /* membership = */ 0)) {
        return 1;
    }
    if (igraph_vector_min(&modularity) != 0 || igraph_vector_max(&modularity) != 0) {
        return 2;
    }
    igraph_destroy(&g);

    igraph_matrix_destroy(&merges);
    igraph_vector_destroy(&modularity);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/simple/walktrap.out0000644000175100001710000000045200000000000025340 0ustar00runnerdocker00000000000000Merges:
 6 +  7 -> 10 (modularity 0.00)
 2 +  4 -> 11 (modularity -0.07)
 8 + 10 -> 12 (modularity -0.04)
 3 + 11 -> 13 (modularity 0.02)
 9 + 12 -> 14 (modularity 0.08)
 1 + 13 -> 15 (modularity 0.16)
 0 + 15 -> 16 (modularity 0.25)
 5 + 14 -> 17 (modularity 0.35)
16 + 17 -> 18 (modularity 0.45)
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4671402
igraph-0.9.9/vendor/source/igraph/examples/tutorial/0000755000175100001710000000000000000000000023333 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/tutorial/tutorial1.c0000644000175100001710000000102300000000000025417 0ustar00runnerdocker00000000000000#include 

int main() {
  igraph_real_t diameter;
  igraph_t graph;

  igraph_rng_seed(igraph_rng_default(), 42);

  igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 1000, 3000,
                          IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

  igraph_diameter(&graph, &diameter, 0, 0, 0, IGRAPH_UNDIRECTED, 1);
  printf("Diameter of a random graph with average degree %g: %g\n",
          2.0 * igraph_ecount(&graph) / igraph_vcount(&graph),
          (double) diameter);

  igraph_destroy(&graph);

  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/tutorial/tutorial2.c0000644000175100001710000000173100000000000025426 0ustar00runnerdocker00000000000000#include 

int main() {
  igraph_t graph;
  igraph_vector_t dimvector;
  igraph_vector_t edges;
  igraph_real_t avg_path_len;
  int i;

  igraph_vector_init(&dimvector, 2);
  VECTOR(dimvector)[0]=30;
  VECTOR(dimvector)[1]=30;
  igraph_lattice(&graph, &dimvector, 0, IGRAPH_UNDIRECTED, 0, 1);

  igraph_average_path_length(&graph, &avg_path_len, NULL, IGRAPH_UNDIRECTED, 1);
  printf("Average path length (lattice):            %g\n", (double) avg_path_len);

  igraph_rng_seed(igraph_rng_default(), 42);
  igraph_vector_init(&edges, 20);
  for (i=0; i < igraph_vector_size(&edges); i++) {
    VECTOR(edges)[i] = RNG_INTEGER(0, igraph_vcount(&graph) - 1);
  }

  igraph_add_edges(&graph, &edges, 0);
  igraph_average_path_length(&graph, &avg_path_len, NULL, IGRAPH_UNDIRECTED, 1);
  printf("Average path length (randomized lattice): %g\n", (double) avg_path_len);

  igraph_vector_destroy(&dimvector);
  igraph_vector_destroy(&edges);
  igraph_destroy(&graph);

  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/examples/tutorial/tutorial3.c0000644000175100001710000000351100000000000025425 0ustar00runnerdocker00000000000000#include 

int main() {
  igraph_t graph;
  igraph_vector_t v;
  igraph_vector_t result;
  igraph_real_t edges[] = { 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
                            0,10, 0,11, 0,12, 0,13, 0,17, 0,19, 0,21, 0,31,
                            1, 2, 1, 3, 1, 7, 1,13, 1,17, 1,19, 1,21, 1,30,
                            2, 3, 2, 7, 2,27, 2,28, 2,32, 2, 9, 2, 8, 2,13,
                            3, 7, 3,12, 3,13, 4, 6, 4,10, 5, 6, 5,10, 5,16,
                            6,16, 8,30, 8,32, 8,33, 9,33,13,33,14,32,14,33,
                           15,32,15,33,18,32,18,33,19,33,20,32,20,33,
                           22,32,22,33,23,25,23,27,23,32,23,33,23,29,
                           24,25,24,27,24,31,25,31,26,29,26,33,27,33,
                           28,31,28,33,29,32,29,33,30,32,30,33,31,32,31,33,
                           32,33
  };

  igraph_vector_view(&v, edges, sizeof(edges) / sizeof(double));
  igraph_create(&graph, &v, 0, IGRAPH_UNDIRECTED);

  igraph_vector_init(&result, 0);

  igraph_degree(&graph, &result, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
  printf("Maximum degree is      %10i, vertex %2i.\n",
         (int) igraph_vector_max(&result), (int) igraph_vector_which_max(&result));

  igraph_closeness(&graph, &result, NULL, NULL, igraph_vss_all(), IGRAPH_ALL,
                   /*weights=*/ NULL, /*normalized=*/ 0);
  printf("Maximum closeness is   %10g, vertex %2i.\n",
          (double) igraph_vector_max(&result), (int) igraph_vector_which_max(&result));

  igraph_betweenness(&graph, &result, igraph_vss_all(),
                     IGRAPH_UNDIRECTED, /*weights=*/ NULL);
  printf("Maximum betweenness is %10g, vertex %2i.\n",
          (double) igraph_vector_max(&result), (int) igraph_vector_which_max(&result));

  igraph_vector_destroy(&result);
  igraph_destroy(&graph);

  return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4671402
igraph-0.9.9/vendor/source/igraph/fuzzing/0000755000175100001710000000000000000000000021346 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/README.md0000644000175100001710000000031200000000000022621 0ustar00runnerdocker00000000000000The fuzzing infrastructure of igraph is located in this directory.

The fuzzers are run continuously through OSS-fuzz.

The `build.sh` script is used by OSS-fuzz to build the fuzzers on their platform.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/bliss_fuzzer.cpp0000644000175100001710000000377000000000000024602 0ustar00runnerdocker00000000000000
#include 
#include 

inline void check_err(int err) {
    if (err)
        abort();
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    igraph_t graph;
    igraph_vector_t edges;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    if (Size % 2 == 1 || Size > 512) {
        return 0;
    }

    check_err(igraph_vector_init(&edges, Size));
    for (size_t i=0; i < Size; ++i) {
        VECTOR(edges)[i] = Data[i];
    }

    /* Undirected */
    if (! igraph_create(&graph, &edges, 0, IGRAPH_UNDIRECTED)) {
        igraph_bool_t multi;

        check_err(igraph_has_multiple(&graph, &multi));

        /* Bliss does not support multigraphs and the input is currently not checked */
        if (! multi) {
            igraph_bliss_info_t info;
            igraph_vector_ptr_t generators;
            check_err(igraph_vector_ptr_init(&generators, 0));
            check_err(igraph_automorphism_group(&graph, nullptr, &generators, IGRAPH_BLISS_FS, &info));
            IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&generators, igraph_vector_destroy);
            igraph_vector_ptr_destroy_all(&generators);
        }

        igraph_destroy(&graph);
    }

    /* Directed */
    if (! igraph_create(&graph, &edges, 0, IGRAPH_DIRECTED)) {
        igraph_bool_t multi;

        check_err(igraph_has_multiple(&graph, &multi));

        /* Bliss does not support multigraphs and the input is currently not checked */
        if (! multi) {
            igraph_bliss_info_t info;
            igraph_vector_ptr_t generators;
            check_err(igraph_vector_ptr_init(&generators, 0));
            check_err(igraph_automorphism_group(&graph, nullptr, &generators, IGRAPH_BLISS_FS, &info));
            IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&generators, igraph_vector_destroy);
            igraph_vector_ptr_destroy_all(&generators);
        }

        igraph_destroy(&graph);
    }

    igraph_vector_destroy(&edges);

    return 0;  // Non-zero return values are reserved for future use.
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/build.sh0000755000175100001710000000104300000000000023002 0ustar00runnerdocker00000000000000#!/bin/bash -eu

mkdir build && cd build
cmake .. -DIGRAPH_WARNINGS_AS_ERRORS=OFF
make -j$(nproc)

# Create seed corpus
zip $OUT/read_gml_fuzzer_seed_corpus.zip \
        $SRC/igraph/examples/simple/karate.gml

cd $SRC/igraph

for TARGET in read_gml_fuzzer bliss_fuzzer vertex_connectivity_fuzzer edge_connectivity_fuzzer vertex_separators_fuzzer
do
  $CXX $CXXFLAGS -I$SRC/igraph/build/include -I$SRC/igraph/include -o $TARGET.o -c ./fuzzing/$TARGET.cpp
  $CXX $CXXFLAGS $LIB_FUZZING_ENGINE $TARGET.o -o $OUT/$TARGET ./build/src/libigraph.a
done
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/edge_connectivity_fuzzer.cpp0000644000175100001710000000166000000000000027164 0ustar00runnerdocker00000000000000
#include 
#include 

inline void check_err(int err) {
    if (err)
        abort();
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    igraph_t graph;
    igraph_vector_t edges;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    if (Size % 2 == 1 || Size > 65280) {
        return 0;
    }

    check_err(igraph_vector_init(&edges, Size));
    for (size_t i=0; i < Size; ++i) {
        VECTOR(edges)[i] = Data[i];
    }

    if (! igraph_create(&graph, &edges, 0, IGRAPH_DIRECTED)) {
        igraph_integer_t conn;

        check_err(igraph_edge_connectivity(&graph, &conn, 0));
        check_err(igraph_to_undirected(&graph, IGRAPH_TO_UNDIRECTED_COLLAPSE, nullptr));
        check_err(igraph_edge_connectivity(&graph, &conn, 0));

        igraph_destroy(&graph);
    }

    igraph_vector_destroy(&edges);

    return 0;  // Non-zero return values are reserved for future use.
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/read_gml_fuzzer.cpp0000644000175100001710000000335400000000000025236 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include "igraph.h"
#include 
#include 
#include 
#include 

extern "C"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    if (size < 5) return 0;

    igraph_set_error_handler(igraph_error_handler_ignore);

    // Create input file
    char filename[256];
    sprintf(filename, "/tmp/libfuzzer.gml");
    FILE *fp = fopen(filename, "wb");
    if (!fp) return 0;
    fwrite(data, size, 1, fp);
    fclose(fp);

    // Read input file
    FILE *ifile;
    ifile = fopen("/tmp/libfuzzer.gml", "r");
    if(ifile == 0){
        remove(filename);
        return 0;
    }

    // Do the fuzzing
    igraph_t g;
    if (igraph_read_graph_gml(&g, ifile) == IGRAPH_SUCCESS) {
        // Clean up
        igraph_destroy(&g);
    }

    // no need to call igraph_destroy() if igraph_read_graph_gml() returns an
    // error code as we don't have a valid graph object in that case

    fclose(ifile);
    remove(filename);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/vertex_connectivity_fuzzer.cpp0000644000175100001710000000166400000000000027601 0ustar00runnerdocker00000000000000
#include 
#include 

inline void check_err(int err) {
    if (err)
        abort();
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    igraph_t graph;
    igraph_vector_t edges;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    if (Size % 2 == 1 || Size > 65280) {
        return 0;
    }

    check_err(igraph_vector_init(&edges, Size));
    for (size_t i=0; i < Size; ++i) {
        VECTOR(edges)[i] = Data[i];
    }

    if (! igraph_create(&graph, &edges, 0, IGRAPH_DIRECTED)) {
        igraph_integer_t conn;

        check_err(igraph_vertex_connectivity(&graph, &conn, 0));
        check_err(igraph_to_undirected(&graph, IGRAPH_TO_UNDIRECTED_COLLAPSE, nullptr));
        check_err(igraph_vertex_connectivity(&graph, &conn, 0));

        igraph_destroy(&graph);
    }

    igraph_vector_destroy(&edges);

    return 0;  // Non-zero return values are reserved for future use.
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/fuzzing/vertex_separators_fuzzer.cpp0000644000175100001710000000256200000000000027244 0ustar00runnerdocker00000000000000
#include 
#include 

inline void check_err(int err) {
    if (err)
        abort();
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    igraph_t graph;
    igraph_vector_t edges;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    if (Size % 2 == 1 || Size > 32640) {
        return 0;
    }

    check_err(igraph_vector_init(&edges, Size));
    for (size_t i=0; i < Size; ++i) {
        VECTOR(edges)[i] = Data[i];
    }

    if (! igraph_create(&graph, &edges, 0, IGRAPH_UNDIRECTED)) {
        {
            igraph_vector_ptr_t separators;
            check_err(igraph_vector_ptr_init(&separators, 0));
            check_err(igraph_all_minimal_st_separators(&graph, &separators));
            IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&separators, igraph_vector_destroy);
            igraph_vector_ptr_destroy_all(&separators);
        }

        {
            igraph_vector_ptr_t separators;
            check_err(igraph_vector_ptr_init(&separators, 0));
            check_err(igraph_minimum_size_separators(&graph, &separators));
            IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&separators, igraph_vector_destroy);
            igraph_vector_ptr_destroy_all(&separators);
        }

        igraph_destroy(&graph);
    }

    igraph_vector_destroy(&edges);

    return 0;  // Non-zero return values are reserved for future use.
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/igraph.pc.in0000644000175100001710000000051100000000000022052 0ustar00runnerdocker00000000000000prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=@CMAKE_INSTALL_PREFIX@
libdir=@PKGCONFIG_LIBDIR@
includedir=@PKGCONFIG_INCLUDEDIR@

Name: libigraph
Description: @PROJECT_DESCRIPTION@
Version: @PROJECT_VERSION@
URL: @PROJECT_HOMEPAGE_URL@
Libs: -L${libdir} -ligraph
Libs.private: @PKGCONFIG_LIBS_PRIVATE@
Cflags: -I${includedir}/igraph
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4791403
igraph-0.9.9/vendor/source/igraph/include/0000755000175100001710000000000000000000000021275 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph.h0000644000175100001710000000556600000000000022734 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_H
#define IGRAPH_H

#ifndef _GNU_SOURCE
    #define _GNU_SOURCE 1
#endif

#include "igraph_version.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "igraph_random.h"
#include "igraph_progress.h"
#include "igraph_statusbar.h"

#include "igraph_types.h"
#include "igraph_complex.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"
#include "igraph_array.h"
#include "igraph_dqueue.h"
#include "igraph_stack.h"
#include "igraph_heap.h"
#include "igraph_psumtree.h"
#include "igraph_strvector.h"
#include "igraph_vector_ptr.h"
#include "igraph_spmatrix.h"
#include "igraph_sparsemat.h"
#include "igraph_qsort.h"

#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"
#include "igraph_interface.h"
#include "igraph_constructors.h"
#include "igraph_games.h"
#include "igraph_microscopic_update.h"
#include "igraph_centrality.h"
#include "igraph_paths.h"
#include "igraph_components.h"
#include "igraph_structural.h"
#include "igraph_transitivity.h"
#include "igraph_neighborhood.h"
#include "igraph_topology.h"
#include "igraph_bipartite.h"
#include "igraph_cliques.h"
#include "igraph_layout.h"
#include "igraph_visitor.h"
#include "igraph_community.h"
#include "igraph_conversion.h"
#include "igraph_foreign.h"
#include "igraph_motifs.h"
#include "igraph_operators.h"
#include "igraph_flow.h"
#include "igraph_nongraph.h"
#include "igraph_cocitation.h"
#include "igraph_adjlist.h"
#include "igraph_attributes.h"
#include "igraph_blas.h"
#include "igraph_lapack.h"
#include "igraph_arpack.h"
#include "igraph_mixing.h"
#include "igraph_separators.h"
#include "igraph_cohesive_blocks.h"
#include "igraph_eigen.h"
#include "igraph_hrg.h"
#include "igraph_threading.h"
#include "igraph_interrupt.h"
#include "igraph_scg.h"
#include "igraph_matching.h"
#include "igraph_embedding.h"
#include "igraph_scan.h"
#include "igraph_graphlets.h"
#include "igraph_epidemics.h"
#include "igraph_lsap.h"
#include "igraph_coloring.h"
#include "igraph_eulerian.h"
#include "igraph_graphicality.h"

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_adjlist.h0000644000175100001710000002022500000000000024433 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ADJLIST_H
#define IGRAPH_ADJLIST_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

typedef struct igraph_adjlist_t {
    igraph_integer_t length;
    igraph_vector_int_t *adjs;
} igraph_adjlist_t;

IGRAPH_EXPORT int igraph_adjlist_init(const igraph_t *graph, igraph_adjlist_t *al,
                                      igraph_neimode_t mode, igraph_loops_t loops,
                                      igraph_multiple_t multiple);
IGRAPH_EXPORT int igraph_adjlist_init_empty(igraph_adjlist_t *al, igraph_integer_t no_of_nodes);
IGRAPH_EXPORT igraph_integer_t igraph_adjlist_size(const igraph_adjlist_t *al);
IGRAPH_EXPORT int igraph_adjlist_init_complementer(const igraph_t *graph,
                                                   igraph_adjlist_t *al,
                                                   igraph_neimode_t mode,
                                                   igraph_bool_t loops);
IGRAPH_EXPORT void igraph_adjlist_destroy(igraph_adjlist_t *al);
IGRAPH_EXPORT void igraph_adjlist_clear(igraph_adjlist_t *al);
IGRAPH_EXPORT void igraph_adjlist_sort(igraph_adjlist_t *al);
IGRAPH_EXPORT int igraph_adjlist_simplify(igraph_adjlist_t *al);
IGRAPH_DEPRECATED IGRAPH_EXPORT int igraph_adjlist_remove_duplicate(const igraph_t *graph,
                                                                    igraph_adjlist_t *al);
IGRAPH_EXPORT int igraph_adjlist_print(const igraph_adjlist_t *al);
IGRAPH_EXPORT int igraph_adjlist_fprint(const igraph_adjlist_t *al, FILE *outfile);
IGRAPH_EXPORT igraph_bool_t igraph_adjlist_has_edge(igraph_adjlist_t* al, igraph_integer_t from, igraph_integer_t to, igraph_bool_t directed);
IGRAPH_EXPORT int igraph_adjlist_replace_edge(igraph_adjlist_t* al, igraph_integer_t from, igraph_integer_t oldto, igraph_integer_t newto, igraph_bool_t directed);

/**
 * \define igraph_adjlist_get
 * \brief Query a vector in an adjacency list.
 *
 * Returns a pointer to an igraph_vector_int_t object from an
 * adjacency list. The vector can be modified as desired.
 * \param al The adjacency list object.
 * \param no The vertex whose adjacent vertices will be returned.
 * \return Pointer to the igraph_vector_int_t object.
 *
 * Time complexity: O(1).
 */
#define igraph_adjlist_get(al,no) (&(al)->adjs[(long int)(no)])

IGRAPH_EXPORT int igraph_adjlist(igraph_t *graph, const igraph_adjlist_t *adjlist,
                                 igraph_neimode_t mode, igraph_bool_t duplicate);

typedef struct igraph_inclist_t {
    igraph_integer_t length;
    igraph_vector_int_t *incs;
} igraph_inclist_t;

IGRAPH_EXPORT int igraph_inclist_init(const igraph_t *graph,
                                      igraph_inclist_t *il,
                                      igraph_neimode_t mode,
                                      igraph_loops_t loops);
IGRAPH_EXPORT int igraph_inclist_init_empty(igraph_inclist_t *il, igraph_integer_t n);
IGRAPH_EXPORT igraph_integer_t igraph_inclist_size(const igraph_inclist_t *al);
IGRAPH_EXPORT void igraph_inclist_destroy(igraph_inclist_t *il);
IGRAPH_EXPORT void igraph_inclist_clear(igraph_inclist_t *il);
IGRAPH_DEPRECATED IGRAPH_EXPORT int igraph_inclist_remove_duplicate(const igraph_t *graph,
                                                                    igraph_inclist_t *il);
IGRAPH_EXPORT int igraph_inclist_print(const igraph_inclist_t *il);
IGRAPH_EXPORT int igraph_inclist_fprint(const igraph_inclist_t *il, FILE *outfile);

/**
 * \define igraph_inclist_get
 * \brief Query a vector in an incidence list.
 *
 * Returns a pointer to an igraph_vector_int_t object from an
 * incidence list containing edge ids. The vector can be modified,
 * resized, etc. as desired.
 * \param il Pointer to the incidence list.
 * \param no The vertex for which the incident edges are returned.
 * \return Pointer to an igraph_vector_int_t object.
 *
 * Time complexity: O(1).
 */
#define igraph_inclist_get(il,no) (&(il)->incs[(long int)(no)])

typedef struct igraph_lazy_adjlist_t {
    const igraph_t *graph;
    igraph_integer_t length;
    igraph_vector_int_t **adjs;
    igraph_neimode_t mode;
    igraph_loops_t loops;
    igraph_multiple_t multiple;
    igraph_vector_t dummy;
} igraph_lazy_adjlist_t;

IGRAPH_EXPORT int igraph_lazy_adjlist_init(const igraph_t *graph,
                                           igraph_lazy_adjlist_t *al,
                                           igraph_neimode_t mode,
                                           igraph_loops_t loops,
                                           igraph_multiple_t multiple);
IGRAPH_EXPORT void igraph_lazy_adjlist_destroy(igraph_lazy_adjlist_t *al);
IGRAPH_EXPORT void igraph_lazy_adjlist_clear(igraph_lazy_adjlist_t *al);
IGRAPH_EXPORT igraph_integer_t igraph_lazy_adjlist_size(const igraph_lazy_adjlist_t *al);

/**
 * \define igraph_lazy_adjlist_get
 * \brief Query neighbor vertices.
 *
 * If the function is called for the first time for a vertex then the
 * result is stored in the adjacency list and no further query
 * operations are needed when the neighbors of the same vertex are
 * queried again.
 * \param al The lazy adjacency list.
 * \param no The vertex ID to query.
 * \return Pointer to a vector. It is allowed to modify it and
 *   modification does not affect the original graph.
 *
 * Time complexity: O(d), the number of neighbor vertices for the
 * first time, O(1) for subsequent calls.
 */
#define igraph_lazy_adjlist_get(al,no) \
    ((al)->adjs[(long int)(no)] != 0 ? ((al)->adjs[(long int)(no)]) : \
     (igraph_i_lazy_adjlist_get_real(al, no)))
IGRAPH_EXPORT igraph_vector_int_t *igraph_i_lazy_adjlist_get_real(igraph_lazy_adjlist_t *al, igraph_integer_t no);

typedef struct igraph_lazy_inclist_t {
    const igraph_t *graph;
    igraph_integer_t length;
    igraph_vector_int_t **incs;
    igraph_neimode_t mode;
    igraph_vector_t dummy;
    igraph_loops_t loops;
} igraph_lazy_inclist_t;

IGRAPH_EXPORT int igraph_lazy_inclist_init(const igraph_t *graph,
                                           igraph_lazy_inclist_t *il,
                                           igraph_neimode_t mode,
                                           igraph_loops_t loops);
IGRAPH_EXPORT void igraph_lazy_inclist_destroy(igraph_lazy_inclist_t *il);
IGRAPH_EXPORT void igraph_lazy_inclist_clear(igraph_lazy_inclist_t *il);
IGRAPH_EXPORT igraph_integer_t igraph_lazy_inclist_size(const igraph_lazy_inclist_t *il);

/**
 * \define igraph_lazy_inclist_get
 * \brief Query incident edges.
 *
 * If the function is called for the first time for a vertex, then the
 * result is stored in the incidence list and no further query
 * operations are needed when the incident edges of the same vertex are
 * queried again.
 * \param al The lazy incidence list object.
 * \param no The vertex id to query.
 * \return Pointer to a vector. It is allowed to modify it and
 *   modification does not affect the original graph.
 *
 * Time complexity: O(d), the number of incident edges for the first
 * time, O(1) for subsequent calls with the same \p no argument.
 */
#define igraph_lazy_inclist_get(al,no) \
    ((al)->incs[(long int)(no)] != 0 ? ((al)->incs[(long int)(no)]) : \
     (igraph_i_lazy_inclist_get_real(al, no)))
IGRAPH_EXPORT igraph_vector_int_t *igraph_i_lazy_inclist_get_real(igraph_lazy_inclist_t *al, igraph_integer_t no);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_arpack.h0000644000175100001710000003414200000000000024245 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ARPACK_H
#define IGRAPH_ARPACK_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"

__BEGIN_DECLS

/**
 * \section about_arpack ARPACK interface in igraph
 *
 * 
 * ARPACK is a library for solving large scale eigenvalue problems.
 * The package is designed to compute a few eigenvalues and corresponding
 * eigenvectors of a general \c n by \c n matrix \c A. It is
 * most appropriate for large sparse or structured matrices \c A where
 * structured means that a matrix-vector product w <- Av requires
 * order \c n rather than the usual order n^2 floating point
 * operations. Please see
 * http://www.caam.rice.edu/software/ARPACK/ for details.
 * 
 *
 * 
 * The eigenvalue calculation in ARPACK (in the simplest
 * case) involves the calculation of the \c Av product where \c A
 * is the matrix we work with and \c v is an arbitrary vector. A
 * user-defined function of type \ref igraph_arpack_function_t
 * is expected to perform this product. If the product can be done
 * efficiently, e.g. if the matrix is sparse, then ARPACK is usually
 * able to calculate the eigenvalues very quickly.
 * 
 *
 * In igraph, eigenvalue/eigenvector calculations usually
 * involve the following steps:
 * \olist
 *   \oli Initialization of an \ref igraph_arpack_options_t data
 *        structure using \ref igraph_arpack_options_init.
 *   \oli Setting some options in the initialized \ref
 *        igraph_arpack_options_t object.
 *   \oli Defining a function of type \ref igraph_arpack_function_t.
 *        The input of this function is a vector, and the output
 *        should be the output matrix multiplied by the input vector.
 *   \oli Calling \ref igraph_arpack_rssolve() (is the matrix is
 *        symmetric), or \ref igraph_arpack_rnsolve().
 * \endolist
 * The \ref igraph_arpack_options_t object can be used multiple
 * times.
 * 
 *
 * 
 * If we have many eigenvalue problems to solve, then it might worth
 * to create an \ref igraph_arpack_storage_t object, and initialize it
 * via \ref igraph_arpack_storage_init(). This structure contains all
 * memory needed for ARPACK (with the given upper limit regerding to
 * the size of the eigenvalue problem). Then many problems can be
 * solved using the same \ref igraph_arpack_storage_t object, without
 * always reallocating the required memory.
 * The \ref igraph_arpack_storage_t object needs to be destroyed by
 * calling \ref igraph_arpack_storage_destroy() on it, when it is not
 * needed any more.
 * 
 *
 * 
 * igraph does not contain all
 * ARPACK routines, only the ones dealing with symmetric and
 * non-symmetric eigenvalue problems using double precision real
 * numbers.
 * 
 *
 */

/**
 * \struct igraph_arpack_options_t
 * \brief Options for ARPACK
 *
 * This data structure contains the options of thee ARPACK eigenvalue
 * solver routines. It must be initialized by calling \ref
 * igraph_arpack_options_init() on it. Then it can be used for
 * multiple ARPACK calls, as the ARPACK solvers do not modify it.
 *
 * Input options:
 * \member bmat Character. Whether to solve a standard ('I') ot a
 *    generalized problem ('B').
 * \member n Dimension of the eigenproblem.
 * \member which Specifies which eigenvalues/vectors to
 *    compute. Possible values for symmetric matrices:
 *    \clist \cli LA
 *                Compute \c nev largest (algebraic) eigenvalues.
 *           \cli SA
 *                Compute \c nev smallest (algebraic) eigenvalues.
 *           \cli LM
 *                Compute \c nev largest (in magnitude) eigenvalues.
 *           \cli SM
 *                Compute \c nev smallest (in magnitude) eigenvalues.
 *           \cli BE
 *                Compute \c nev eigenvalues, half from each end of
 *                   the spectrum. When \c nev is odd, compute one
 *                   more from the high en than from the low
 *                   end. \endclist
 *    Possible values for non-symmetric matrices:
 *    \clist \cli LM
 *                Compute \c nev largest (in magnitude) eigenvalues.
 *           \cli SM
 *                Compute \c nev smallest (in magnitude) eigenvalues.
 *           \cli LR
 *                Compute \c nev eigenvalues of largest real part.
 *           \cli SR
 *                Compute \c nev eigenvalues of smallest real part.
 *           \cli LI
 *                Compute \c nev eigenvalues of largest imaginary part.
 *           \cli SI
 *                Compute \c nev eigenvalues of smallest imaginary
 *                    part. \endclist
 * \member nev The number of eigenvalues to be computed.
 * \member tol Stopping criterion: the relative accuracy
 *    of the Ritz value is considered acceptable if its error is less
 *    than \c tol times its estimated value. If this is set to zero
 *    then machine precision is used.
 * \member ncv Number of Lanczos vectors to be generated. Setting this
 *    to zero means that \ref igraph_arpack_rssolve and \ref igraph_arpack_rnsolve
 *    will determine a suitable value for \c ncv automatically.
 * \member ldv Numberic scalar. It should be set to
 *    zero in the current igraph implementation.
 * \member ishift Either zero or one. If zero then the shifts are
 *    provided by the user via reverse communication. If one then exact
 *    shifts with respect to the reduced tridiagonal matrix \c T.
 *    Please always set this to one.
 * \member mxiter Maximum number of Arnoldi update iterations allowed.
 * \member nb Blocksize to be used in the recurrence. Please always
 *    leave this on the default value, one.
 * \member mode The type of the eigenproblem to be solved.
 *    Possible values if the input matrix is symmetric:
 *    \olist
 *      \oli A*x=lambda*x, A is symmetric.
 *      \oli A*x=lambda*M*x, A is
 *       symmetric, M is symmetric positive definite.
 *      \oli K*x=lambda*M*x, K is
 *        symmetric, M is symmetric positive semi-definite.
 *      \oli K*x=lambda*KG*x, K is
 *       symmetric positive semi-definite, KG is symmetric
 *       indefinite.
 *     \oli A*x=lambda*M*x, A is
 *       symmetric, M is symmetric positive
 *       semi-definite. (Cayley transformed mode.) \endolist
 *    Please note that only \c mode ==1 was tested and other values
 *    might not work properly.
 *    Possible values if the input matrix is not symmetric:
 *    \olist
 *     \oli A*x=lambda*x.
 *     \oli A*x=lambda*M*x, M is
 *       symmetric positive definite.
 *     \oli A*x=lambda*M*x, M is
 *       symmetric semi-definite.
 *     \oli A*x=lambda*M*x, M is
 *           symmetric semi-definite. \endolist
 *     Please note that only \c mode == 1 was tested and other values
 *     might not work properly.
 * \member start Whether to use the supplied starting vector (1), or
 *    use a random starting vector (0). The starting vector must be
 *    supplied in the first column of the \c vectors argument of the
 *    \ref igraph_arpack_rssolve() of \ref igraph_arpack_rnsolve() call.
 *
 * Output options:
 * \member info Error flag of ARPACK. Possible values:
 *    \clist \cli 0
 *                Normal exit.
 *           \cli 1
 *                Maximum number of iterations taken.
 *           \cli 3
 *                No shifts could be applied during a cycle of the
 *         Implicitly restarted Arnoldi iteration. One possibility
 *         is to increase the size of \c ncv relative to \c
 *           nev. \endclist
 *    ARPACK can return other error flags as well, but these are
 *    converted to igraph errors, see \ref igraph_error_type_t.
 * \member ierr Error flag of the second ARPACK call (one eigenvalue
 *     computation usually involves two calls to ARPACK). This is
 *     always zero, as other error codes are converted to igraph errors.
 * \member noiter Number of Arnoldi iterations taken.
 * \member nconv Number of converged Ritz values. This
 *     represents the number of Ritz values that satisfy the
 *     convergence critetion.
 * \member numop Total number of matrix-vector multiplications.
 * \member numopb Not used currently.
 * \member numreo Total number of steps of re-orthogonalization.
 *
 * Internal options:
 * \member lworkl Do not modify this option.
 * \member sigma The shift for the shift-invert mode.
 * \member sigmai The imaginary part of the shift, for the
 *    non-symmetric or complex shift-invert mode.
 * \member iparam Do not modify this option.
 * \member ipntr Do not modify this option.
 *
 */

typedef struct igraph_arpack_options_t {
    /* INPUT */
    char bmat[1];          /* I-standard problem, G-generalized */
    int n;                 /* Dimension of the eigenproblem */
    char which[2];         /* LA, SA, LM, SM, BE */
    int nev;               /* Number of eigenvalues to be computed */
    igraph_real_t tol;     /* Stopping criterion */
    int ncv;               /* Number of columns in V */
    int ldv;               /* Leading dimension of V */
    int ishift;            /* 0-reverse comm., 1-exact with tridiagonal */
    int mxiter;            /* Maximum number of update iterations to take */
    int nb;                /* Block size on the recurrence, only 1 works */
    int mode;              /* The kind of problem to be solved (1-5)
                               1: A*x=l*x, A symmetric
                               2: A*x=l*M*x, A symm. M pos. def.
                               3: K*x = l*M*x, K symm., M pos. semidef.
                               4: K*x = l*KG*x, K s. pos. semidef. KG s. indef.
                               5: A*x = l*M*x, A symm., M symm. pos. semidef. */
    int start;             /* 0: random, 1: use the supplied vector */
    int lworkl;            /* Size of temporary storage, default is fine */
    igraph_real_t sigma;   /* The shift for modes 3,4,5 */
    igraph_real_t sigmai;  /* The imaginary part of shift for rnsolve */
    /* OUTPUT */
    int info;              /* What happened, see docs */
    int ierr;              /* What happened  in the dseupd call */
    int noiter;            /* The number of iterations taken */
    int nconv;
    int numop;             /* Number of OP*x operations */
    int numopb;            /* Number of B*x operations if BMAT='G' */
    int numreo;            /* Number of steps of re-orthogonalizations */
    /* INTERNAL */
    int iparam[11];
    int ipntr[14];
} igraph_arpack_options_t;

/**
 * \struct igraph_arpack_storage_t
 * \brief Storage for ARPACK
 *
 * Public members, do not modify them directly, these are considered
 * to be read-only.
 * \member maxn Maximum rank of matrix.
 * \member maxncv Maximum NCV.
 * \member maxldv Maximum LDV.
 *
 * These members are considered to be private:
 * \member workl Working memory.
 * \member workd Working memory.
 * \member d Memory for eigenvalues.
 * \member resid Memory for residuals.
 * \member ax Working memory.
 * \member select Working memory.
 * \member di Memory for eigenvalues, non-symmetric case only.
 * \member workev Working memory, non-symmetric case only.
 */

typedef struct igraph_arpack_storage_t {
    int maxn, maxncv, maxldv;
    igraph_real_t *v;
    igraph_real_t *workl;
    igraph_real_t *workd;
    igraph_real_t *d;
    igraph_real_t *resid;
    igraph_real_t *ax;
    int *select;
    igraph_real_t *di;        /* These two only for non-symmetric problems */
    igraph_real_t *workev;
} igraph_arpack_storage_t;

IGRAPH_EXPORT void igraph_arpack_options_init(igraph_arpack_options_t *o);

IGRAPH_EXPORT int igraph_arpack_storage_init(igraph_arpack_storage_t *s, long int maxn,
                                             long int maxncv, long int maxldv, igraph_bool_t symm);
IGRAPH_EXPORT void igraph_arpack_storage_destroy(igraph_arpack_storage_t *s);

/**
 * \typedef igraph_arpack_function_t
 * Type of the ARPACK callback function
 *
 * \param to Pointer to an \c igraph_real_t, the result of the
 *    matrix-vector product is expected to be stored here.
 * \param from Pointer to an \c igraph_real_t, the input matrix should
 *    be multiplied by the vector stored here.
 * \param n The length of the vector (which is the same as the order
 *    of the input matrix).
 * \param extra Extra argument to the matrix-vector calculation
 *    function. This is coming from the \ref igraph_arpack_rssolve()
 *    or \ref igraph_arpack_rnsolve() function.
 * \return Error code, if not zero, then the ARPACK solver considers
 *    this as an error, stops and calls the igraph error handler.
 */

typedef int igraph_arpack_function_t(igraph_real_t *to, const igraph_real_t *from,
                                     int n, void *extra);

IGRAPH_EXPORT int igraph_arpack_rssolve(igraph_arpack_function_t *fun, void *extra,
                                        igraph_arpack_options_t *options,
                                        igraph_arpack_storage_t *storage,
                                        igraph_vector_t *values, igraph_matrix_t *vectors);

IGRAPH_EXPORT int igraph_arpack_rnsolve(igraph_arpack_function_t *fun, void *extra,
                                        igraph_arpack_options_t *options,
                                        igraph_arpack_storage_t *storage,
                                        igraph_matrix_t *values, igraph_matrix_t *vectors);

IGRAPH_EXPORT int igraph_arpack_unpack_complex(igraph_matrix_t *vectors, igraph_matrix_t *values,
                                               long int nev);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_array.h0000644000175100001710000000315700000000000024124 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ARRAY_H
#define IGRAPH_ARRAY_H

#include "igraph_decls.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* 3D array                                           */
/* -------------------------------------------------- */

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_array_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_array_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_array_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_array_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_array_pmt.h0000644000175100001710000000451300000000000025001 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

typedef struct TYPE(igraph_array3) {
    TYPE(igraph_vector) data;
    long int n1, n2, n3, n1n2;
} TYPE(igraph_array3);

#ifndef IGRAPH_ARRAY3_INIT_FINALLY
#define IGRAPH_ARRAY3_INIT_FINALLY(a, n1, n2, n3) \
    do { IGRAPH_CHECK(igraph_array3_init(a, n1, n2, n3)); \
        IGRAPH_FINALLY(igraph_array3_destroy, a); } while (0)
#endif

#ifndef ARRAY3
    #define ARRAY3(m,i,j,k) ((m).data.stor_begin[(m).n1n2*(k)+(m).n1*(j)+(i)])
#endif

IGRAPH_EXPORT int FUNCTION(igraph_array3, init)(TYPE(igraph_array3) *a, long int n1, long int n2,
                                                long int n3);
IGRAPH_EXPORT void FUNCTION(igraph_array3, destroy)(TYPE(igraph_array3) *a);
IGRAPH_EXPORT long int FUNCTION(igraph_array3, size)(const TYPE(igraph_array3) *a);
IGRAPH_EXPORT long int FUNCTION(igraph_array3, n)(const TYPE(igraph_array3) *a, long int idx);
IGRAPH_EXPORT int FUNCTION(igraph_array3, resize)(TYPE(igraph_array3) *a, long int n1, long int n2,
                                                  long int n3);
IGRAPH_EXPORT void FUNCTION(igraph_array3, null)(TYPE(igraph_array3) *a);
IGRAPH_EXPORT BASE FUNCTION(igraph_array3, sum)(const TYPE(igraph_array3) *a);
IGRAPH_EXPORT void FUNCTION(igraph_array3, scale)(TYPE(igraph_array3) *a, BASE by);
IGRAPH_EXPORT void FUNCTION(igraph_array3, fill)(TYPE(igraph_array3) *a, BASE e);
IGRAPH_EXPORT int FUNCTION(igraph_array3, update)(TYPE(igraph_array3) *to,
                                                  const TYPE(igraph_array3) *from);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_attributes.h0000644000175100001710000010506200000000000025172 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ATTRIBUTES_H
#define IGRAPH_ATTRIBUTES_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_strvector.h"
#include "igraph_vector_ptr.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Attributes                                         */
/* -------------------------------------------------- */

/**
 * \section about_attributes
 *
 * Attributes are numbers or strings (or basically any kind
 * of data) associated with the vertices or edges of a graph, or
 * with the graph itself. Eg. you may label vertices with symbolic names
 * or attach numeric weights to the edges of a graph. 
 *
 * igraph attributes are designed to be flexible and extensible.
 * In igraph attributes are implemented via an interface abstraction:
 * any type implementing the functions in the interface, can be used
 * for storing vertex, edge and graph attributes. This means that
 * different attribute implementations can be used together with
 * igraph. This is reasonable: if igraph is used from Python attributes can be
 * of any Python type, from GNU R all R types are allowed. There is an
 * experimental attribute implementation to be used when programming
 * in C, but by default it is currently turned off.
 *
 * First we briefly look over how attribute handlers can be
 * implemented. This is not something a user does every day. It is
 * rather typically the job of the high level interface writers. (But
 * it is possible to write an interface without implementing
 * attributes.) Then we show the experimental C attribute handler.
 */

/**
 * \section about_attribute_table
 * It is possible to attach an attribute handling
 * interface to \a igraph. This is simply a table of functions, of
 * type \ref igraph_attribute_table_t. These functions are invoked to
 * notify the attribute handling code about the structural changes in
 * a graph. See the documentation of this type for details.
 *
 * By default there is no attribute interface attached to \a igraph,
 * to attach one, call \ref igraph_set_attribute_table with your new
 * table. 
 *
 */

/**
 * \section about_attribute_combination
 *
 * Several graph operations may collapse multiple vertices or edges into
 * a single one. Attribute combination lists are used to indicate to the attribute
 * handler how to combine the attributes of the original vertices or edges and
 * how to derive the final attribute value that is to be assigned to the collapsed
 * vertex or edge. For example, \ref igraph_simplify() removes loops and combines
 * multiple edges into a single one; in case of a graph with an edge attribute
 * named \c weight the attribute combination list can tell the attribute handler
 * whether the weight of a collapsed edge should be the sum, the mean or some other
 * function of the weights of the original edges that were collapsed into one.
 *
 * One attribute combination list may contain several attribute combination
 * records, one for each vertex or edge attribute that is to be handled during the
 * operation.
 */

/**
 * \typedef igraph_attribute_type_t
 * The possible types of the attributes.
 *
 * Note that this is only the
 * type communicated by the attribute interface towards igraph
 * functions. Eg. in the GNU R attribute handler, it is safe to say
 * that all complex R object attributes are strings, as long as this
 * interface is able to serialize them into strings. See also \ref
 * igraph_attribute_table_t.
 * \enumval IGRAPH_ATTRIBUTE_DEFAULT Currently not used for anything.
 * \enumval IGRAPH_ATTRIBUTE_NUMERIC Numeric attribute.
 * \enumval IGRAPH_ATTRIBUTE_BOOLEAN Logical values, true or false.
 * \enumval IGRAPH_ATTRIBUTE_STRING Attribute that can be converted to
 *   a string.
 * \enumval IGRAPH_ATTRIBUTE_R_OBJECT An R object. This is usually
 *   ignored by the igraph functions.
 * \enumval IGRAPH_ATTRIBUTE_PY_OBJECT A Python object. Usually
 *   ignored by the igraph functions.
 *
 */
typedef enum { IGRAPH_ATTRIBUTE_DEFAULT = 0,
               IGRAPH_ATTRIBUTE_NUMERIC = 1,
               IGRAPH_ATTRIBUTE_BOOLEAN = 5,
               IGRAPH_ATTRIBUTE_STRING = 2,
               IGRAPH_ATTRIBUTE_R_OBJECT = 3,
               IGRAPH_ATTRIBUTE_PY_OBJECT = 4
             } igraph_attribute_type_t;

typedef struct igraph_attribute_record_t {
    const char *name;
    igraph_attribute_type_t type;
    const void *value;
} igraph_attribute_record_t;

typedef enum { IGRAPH_ATTRIBUTE_GRAPH = 0,
               IGRAPH_ATTRIBUTE_VERTEX,
               IGRAPH_ATTRIBUTE_EDGE
             } igraph_attribute_elemtype_t;

/**
 * \typedef igraph_attribute_combination_type_t
 * The possible types of attribute combinations.
 *
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_IGNORE   Ignore old attributes, use an empty value.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_DEFAULT  Use the default way to combine attributes (decided by the attribute handler implementation).
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_FUNCTION Supply your own function to combine
 *                                            attributes.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_SUM      Take the sum of the attributes.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_PROD     Take the product of the attributes.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_MIN      Take the minimum attribute.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_MAX      Take the maximum attribute.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_RANDOM   Take a random attribute.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_FIRST    Take the first attribute.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_LAST     Take the last attribute.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_MEAN     Take the mean of the attributes.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_MEDIAN   Take the median of the attributes.
 * \enumval IGRAPH_ATTRIBUTE_COMBINE_CONCAT   Concatenate the attributes.
 */
typedef enum {
    IGRAPH_ATTRIBUTE_COMBINE_IGNORE = 0,
    IGRAPH_ATTRIBUTE_COMBINE_DEFAULT = 1,
    IGRAPH_ATTRIBUTE_COMBINE_FUNCTION = 2,
    IGRAPH_ATTRIBUTE_COMBINE_SUM = 3,
    IGRAPH_ATTRIBUTE_COMBINE_PROD = 4,
    IGRAPH_ATTRIBUTE_COMBINE_MIN = 5,
    IGRAPH_ATTRIBUTE_COMBINE_MAX = 6,
    IGRAPH_ATTRIBUTE_COMBINE_RANDOM = 7,
    IGRAPH_ATTRIBUTE_COMBINE_FIRST = 8,
    IGRAPH_ATTRIBUTE_COMBINE_LAST = 9,
    IGRAPH_ATTRIBUTE_COMBINE_MEAN = 10,
    IGRAPH_ATTRIBUTE_COMBINE_MEDIAN = 11,
    IGRAPH_ATTRIBUTE_COMBINE_CONCAT = 12
} igraph_attribute_combination_type_t;

typedef void (*igraph_function_pointer_t)(void);

typedef struct igraph_attribute_combination_record_t {
    const char *name;     /* can be NULL, meaning: the rest */
    igraph_attribute_combination_type_t type;
    igraph_function_pointer_t func;
} igraph_attribute_combination_record_t;

typedef struct igraph_attribute_combination_t {
    igraph_vector_ptr_t list;
} igraph_attribute_combination_t;

#define IGRAPH_NO_MORE_ATTRIBUTES ((const char*)0)

IGRAPH_EXPORT int igraph_attribute_combination_init(igraph_attribute_combination_t *comb);
IGRAPH_EXPORT int igraph_attribute_combination(igraph_attribute_combination_t *comb, ...);
IGRAPH_EXPORT void igraph_attribute_combination_destroy(igraph_attribute_combination_t *comb);
IGRAPH_EXPORT int igraph_attribute_combination_add(igraph_attribute_combination_t *comb,
                                                   const char *name,
                                                   igraph_attribute_combination_type_t type,
                                                   igraph_function_pointer_t func);
IGRAPH_EXPORT int igraph_attribute_combination_remove(igraph_attribute_combination_t *comb,
                                                      const char *name);
IGRAPH_EXPORT int igraph_attribute_combination_query(const igraph_attribute_combination_t *comb,
                                                     const char *name,
                                                     igraph_attribute_combination_type_t *type,
                                                     igraph_function_pointer_t *func);

/**
 * \struct igraph_attribute_table_t
 * \brief Table of functions to perform operations on attributes
 *
 * This type collects the functions defining an attribute handler.
 * It has the following members:
 * \member init This function is called whenever a new graph object is
 *    created, right after it is created but before any vertices or
 *    edges are added. It is supposed to set the \c attr member of the \c
 *    igraph_t object. It is expected to return an error code.
 * \member destroy This function is called whenever the graph object
 *    is destroyed, right before freeing the allocated memory.
 * \member copy This function is called when copying a graph with \ref
 *    igraph_copy, after the structure of the graph has been already
 *    copied. It is expected to return an error code.
 * \member add_vertices Called when vertices are added to a
 *    graph, before adding the vertices themselves.
 *    The number of vertices to add is supplied as an
 *    argument. Expected to return an error code.
 * \member permute_vertices Typically called when a new graph is
 *    created based on an existing one, e.g. if vertices are removed
 *    from a graph. The supplied index vector defines which old vertex
 *    a new vertex corresponds to. Its length must be the same as the
 *    number of vertices in the new graph.
 * \member combine_vertices This function is called when the creation
 *    of a new graph involves a merge (contraction, etc.) of vertices
 *    from another graph. The function is after the new graph was created.
 *    An argument specifies how several vertices from the old graph map to a
 *    single vertex in the new graph.
 * \member add_edges Called when new edges have been added. The number
 *    of new edges are supplied as well. It is expected to return an
 *    error code.
 * \member permute_edges Typically called when a new graph is created and
 *    some of the new edges should carry the attributes of some of the
 *    old edges. The idx vector shows the mapping between the old edges and
 *    the new ones. Its length is the same as the number of edges in the new
 *    graph, and for each edge it gives the id of the old edge (the edge in
 *    the old graph).
 * \member combine_edges This function is called when the creation
 *    of a new graph involves a merge (contraction, etc.) of edges
 *    from another graph. The function is after the new graph was created.
 *    An argument specifies how several edges from the old graph map to a
 *    single edge in the new graph.
 * \member get_info Query the attributes of a graph, the names and
 *    types should be returned.
 * \member has_attr Check whether a graph has the named
 *    graph/vertex/edge attribute.
 * \member gettype Query the type of a graph/vertex/edge attribute.
 * \member get_numeric_graph_attr Query a numeric graph attribute. The
 *    value should be placed as the first element of the \p value
 *    vector.
 * \member get_string_graph_attr Query a string graph attribute. The
 *    value should be placed as the first element of the \p value
 *    string vector.
 * \member get_bool_graph_attr Query a boolean graph attribute. The
 *    value should be placed as the first element of the \p value
 *    boolean vector.
 * \member get_numeric_vertex_attr Query a numeric vertex attribute,
 *    for the vertices included in \p vs.
 * \member get_string_vertex_attr Query a string vertex attribute,
 *    for the vertices included in \p vs.
 * \member get_bool_vertex_attr Query a boolean vertex attribute,
 *    for the vertices included in \p vs.
 * \member get_numeric_edge_attr Query a numeric edge attribute, for
 *    the edges included in \p es.
 * \member get_string_edge_attr Query a string edge attribute, for the
 *    edges included in \p es.
 * \member get_bool_edge_attr Query a boolean edge attribute, for the
 *    edges included in \p es.
 *
 * Note that the get_*_*_attr are allowed to
 * convert the attributes to numeric or string. E.g. if a vertex attribute
 * is a GNU R complex data type, then
 * get_string_vertex_attribute may serialize it
 * into a string, but this probably makes sense only if
 * add_vertices is able to deserialize it.
 */

typedef struct igraph_attribute_table_t {
    int (*init)(igraph_t *graph, igraph_vector_ptr_t *attr);
    void (*destroy)(igraph_t *graph);
    int (*copy)(igraph_t *to, const igraph_t *from, igraph_bool_t ga,
                igraph_bool_t va, igraph_bool_t ea);
    int (*add_vertices)(igraph_t *graph, long int nv, igraph_vector_ptr_t *attr);
    int (*permute_vertices)(const igraph_t *graph,
                            igraph_t *newgraph,
                            const igraph_vector_t *idx);
    int (*combine_vertices)(const igraph_t *graph,
                            igraph_t *newgraph,
                            const igraph_vector_ptr_t *merges,
                            const igraph_attribute_combination_t *comb);
    int (*add_edges)(igraph_t *graph, const igraph_vector_t *edges,
                     igraph_vector_ptr_t *attr);
    int (*permute_edges)(const igraph_t *graph,
                         igraph_t *newgraph, const igraph_vector_t *idx);
    int (*combine_edges)(const igraph_t *graph,
                         igraph_t *newgraph,
                         const igraph_vector_ptr_t *merges,
                         const igraph_attribute_combination_t *comb);
    int (*get_info)(const igraph_t *graph,
                    igraph_strvector_t *gnames, igraph_vector_t *gtypes,
                    igraph_strvector_t *vnames, igraph_vector_t *vtypes,
                    igraph_strvector_t *enames, igraph_vector_t *etypes);
    igraph_bool_t (*has_attr)(const igraph_t *graph, igraph_attribute_elemtype_t type,
                              const char *name);
    int (*gettype)(const igraph_t *graph, igraph_attribute_type_t *type,
                   igraph_attribute_elemtype_t elemtype, const char *name);
    int (*get_numeric_graph_attr)(const igraph_t *graph, const char *name,
                                  igraph_vector_t *value);
    int (*get_string_graph_attr)(const igraph_t *graph, const char *name,
                                 igraph_strvector_t *value);
    int (*get_bool_graph_attr)(const igraph_t *igraph, const char *name,
                               igraph_vector_bool_t *value);
    int (*get_numeric_vertex_attr)(const igraph_t *graph, const char *name,
                                   igraph_vs_t vs,
                                   igraph_vector_t *value);
    int (*get_string_vertex_attr)(const igraph_t *graph, const char *name,
                                  igraph_vs_t vs,
                                  igraph_strvector_t *value);
    int (*get_bool_vertex_attr)(const igraph_t *graph, const char *name,
                                igraph_vs_t vs,
                                igraph_vector_bool_t *value);
    int (*get_numeric_edge_attr)(const igraph_t *graph, const char *name,
                                 igraph_es_t es,
                                 igraph_vector_t *value);
    int (*get_string_edge_attr)(const igraph_t *graph, const char *name,
                                igraph_es_t es,
                                igraph_strvector_t *value);
    int (*get_bool_edge_attr)(const igraph_t *graph, const char *name,
                              igraph_es_t es,
                              igraph_vector_bool_t *value);
} igraph_attribute_table_t;

IGRAPH_EXPORT IGRAPH_DEPRECATED igraph_attribute_table_t * igraph_i_set_attribute_table(const igraph_attribute_table_t * table);
IGRAPH_EXPORT igraph_attribute_table_t * igraph_set_attribute_table(const igraph_attribute_table_t * table);

IGRAPH_EXPORT igraph_bool_t igraph_has_attribute_table(void);

/* Experimental attribute handler in C */

IGRAPH_EXPORT extern const igraph_attribute_table_t igraph_cattribute_table;

IGRAPH_EXPORT igraph_real_t igraph_cattribute_GAN(const igraph_t *graph, const char *name);
IGRAPH_EXPORT igraph_bool_t igraph_cattribute_GAB(const igraph_t *graph, const char *name);
IGRAPH_EXPORT const char* igraph_cattribute_GAS(const igraph_t *graph, const char *name);
IGRAPH_EXPORT igraph_real_t igraph_cattribute_VAN(const igraph_t *graph, const char *name,
                                                  igraph_integer_t vid);
IGRAPH_EXPORT igraph_bool_t igraph_cattribute_VAB(const igraph_t *graph, const char *name,
                                                  igraph_integer_t vid);
IGRAPH_EXPORT const char* igraph_cattribute_VAS(const igraph_t *graph, const char *name,
                                                igraph_integer_t vid);
IGRAPH_EXPORT igraph_real_t igraph_cattribute_EAN(const igraph_t *graph, const char *name,
                                                  igraph_integer_t eid);
IGRAPH_EXPORT igraph_bool_t igraph_cattribute_EAB(const igraph_t *graph, const char *name,
                                                  igraph_integer_t eid);
IGRAPH_EXPORT const char* igraph_cattribute_EAS(const igraph_t *graph, const char *name,
                                                igraph_integer_t eid);

IGRAPH_EXPORT int igraph_cattribute_VANV(const igraph_t *graph, const char *name,
                                         igraph_vs_t vids, igraph_vector_t *result);
IGRAPH_EXPORT int igraph_cattribute_EANV(const igraph_t *graph, const char *name,
                                         igraph_es_t eids, igraph_vector_t *result);
IGRAPH_EXPORT int igraph_cattribute_VASV(const igraph_t *graph, const char *name,
                                         igraph_vs_t vids, igraph_strvector_t *result);
IGRAPH_EXPORT int igraph_cattribute_EASV(const igraph_t *graph, const char *name,
                                         igraph_es_t eids, igraph_strvector_t *result);
IGRAPH_EXPORT int igraph_cattribute_VABV(const igraph_t *graph, const char *name,
                                         igraph_vs_t vids, igraph_vector_bool_t *result);
IGRAPH_EXPORT int igraph_cattribute_EABV(const igraph_t *graph, const char *name,
                                         igraph_es_t eids, igraph_vector_bool_t *result);

IGRAPH_EXPORT int igraph_cattribute_list(const igraph_t *graph,
                                         igraph_strvector_t *gnames, igraph_vector_t *gtypes,
                                         igraph_strvector_t *vnames, igraph_vector_t *vtypes,
                                         igraph_strvector_t *enames, igraph_vector_t *etypes);
IGRAPH_EXPORT igraph_bool_t igraph_cattribute_has_attr(const igraph_t *graph,
                                                       igraph_attribute_elemtype_t type,
                                                       const char *name);

IGRAPH_EXPORT int igraph_cattribute_GAN_set(igraph_t *graph, const char *name,
                                            igraph_real_t value);
IGRAPH_EXPORT int igraph_cattribute_GAB_set(igraph_t *graph, const char *name,
                                            igraph_bool_t value);
IGRAPH_EXPORT int igraph_cattribute_GAS_set(igraph_t *graph, const char *name,
                                            const char *value);
IGRAPH_EXPORT int igraph_cattribute_VAN_set(igraph_t *graph, const char *name,
                                            igraph_integer_t vid, igraph_real_t value);
IGRAPH_EXPORT int igraph_cattribute_VAB_set(igraph_t *graph, const char *name,
                                            igraph_integer_t vid, igraph_bool_t value);
IGRAPH_EXPORT int igraph_cattribute_VAS_set(igraph_t *graph, const char *name,
                                            igraph_integer_t vid, const char *value);
IGRAPH_EXPORT int igraph_cattribute_EAN_set(igraph_t *graph, const char *name,
                                            igraph_integer_t eid, igraph_real_t value);
IGRAPH_EXPORT int igraph_cattribute_EAB_set(igraph_t *graph, const char *name,
                                            igraph_integer_t eid, igraph_bool_t value);
IGRAPH_EXPORT int igraph_cattribute_EAS_set(igraph_t *graph, const char *name,
                                            igraph_integer_t eid, const char *value);

IGRAPH_EXPORT int igraph_cattribute_VAN_setv(igraph_t *graph, const char *name,
                                             const igraph_vector_t *v);
IGRAPH_EXPORT int igraph_cattribute_VAB_setv(igraph_t *graph, const char *name,
                                             const igraph_vector_bool_t *v);
IGRAPH_EXPORT int igraph_cattribute_VAS_setv(igraph_t *graph, const char *name,
                                             const igraph_strvector_t *sv);
IGRAPH_EXPORT int igraph_cattribute_EAN_setv(igraph_t *graph, const char *name,
                                             const igraph_vector_t *v);
IGRAPH_EXPORT int igraph_cattribute_EAB_setv(igraph_t *graph, const char *name,
                                             const igraph_vector_bool_t *v);
IGRAPH_EXPORT int igraph_cattribute_EAS_setv(igraph_t *graph, const char *name,
                                             const igraph_strvector_t *sv);

IGRAPH_EXPORT void igraph_cattribute_remove_g(igraph_t *graph, const char *name);
IGRAPH_EXPORT void igraph_cattribute_remove_v(igraph_t *graph, const char *name);
IGRAPH_EXPORT void igraph_cattribute_remove_e(igraph_t *graph, const char *name);
IGRAPH_EXPORT void igraph_cattribute_remove_all(igraph_t *graph, igraph_bool_t g,
                                                igraph_bool_t v, igraph_bool_t e);

/**
 * \define GAN
 * Query a numeric graph attribute.
 *
 * This is shorthand for \ref igraph_cattribute_GAN().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \return The value of the attribute.
 */
#define GAN(graph,n) (igraph_cattribute_GAN((graph), (n)))
/**
 * \define GAB
 * Query a boolean graph attribute.
 *
 * This is shorthand for \ref igraph_cattribute_GAB().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \return The value of the attribute.
 */
#define GAB(graph,n) (igraph_cattribute_GAB((graph), (n)))
/**
 * \define GAS
 * Query a string graph attribute.
 *
 * This is shorthand for \ref igraph_cattribute_GAS().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \return The value of the attribute.
 */
#define GAS(graph,n) (igraph_cattribute_GAS((graph), (n)))
/**
 * \define VAN
 * Query a numeric vertex attribute.
 *
 * This is shorthand for \ref igraph_cattribute_VAN().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v The id of the vertex.
 * \return The value of the attribute.
 */
#define VAN(graph,n,v) (igraph_cattribute_VAN((graph), (n), (v)))
/**
 * \define VAB
 * Query a boolean vertex attribute.
 *
 * This is shorthand for \ref igraph_cattribute_VAB().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v The id of the vertex.
 * \return The value of the attribute.
 */
#define VAB(graph,n,v) (igraph_cattribute_VAB((graph), (n), (v)))
/**
 * \define VAS
 * Query a string vertex attribute.
 *
 * This is shorthand for \ref igraph_cattribute_VAS().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v The id of the vertex.
 * \return The value of the attribute.
 */
#define VAS(graph,n,v) (igraph_cattribute_VAS((graph), (n), (v)))
/**
 * \define VANV
 * Query a numeric vertex attribute for all vertices.
 *
 * This is a shorthand for \ref igraph_cattribute_VANV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define VANV(graph,n,vec) (igraph_cattribute_VANV((graph),(n), \
                           igraph_vss_all(), (vec)))
/**
 * \define VABV
 * Query a boolean vertex attribute for all vertices.
 *
 * This is a shorthand for \ref igraph_cattribute_VABV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized boolean vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define VABV(graph,n,vec) (igraph_cattribute_VABV((graph),(n), \
                           igraph_vss_all(), (vec)))
/**
 * \define VASV
 * Query a string vertex attribute for all vertices.
 *
 * This is a shorthand for \ref igraph_cattribute_VASV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized string vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define VASV(graph,n,vec) (igraph_cattribute_VASV((graph),(n), \
                           igraph_vss_all(), (vec)))
/**
 * \define EAN
 * Query a numeric edge attribute.
 *
 * This is shorthand for \ref igraph_cattribute_EAN().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param e The id of the edge.
 * \return The value of the attribute.
 */
#define EAN(graph,n,e) (igraph_cattribute_EAN((graph), (n), (e)))
/**
 * \define EAB
 * Query a boolean edge attribute.
 *
 * This is shorthand for \ref igraph_cattribute_EAB().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param e The id of the edge.
 * \return The value of the attribute.
 */
#define EAB(graph,n,e) (igraph_cattribute_EAB((graph), (n), (e)))
/**
 * \define EAS
 * Query a string edge attribute.
 *
 * This is shorthand for \ref igraph_cattribute_EAS().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param e The id of the edge.
 * \return The value of the attribute.
 */
#define EAS(graph,n,e) (igraph_cattribute_EAS((graph), (n), (e)))
/**
 * \define EANV
 * Query a numeric edge attribute for all edges.
 *
 * This is a shorthand for \ref igraph_cattribute_EANV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define EANV(graph,n,vec) (igraph_cattribute_EANV((graph),(n), \
                           igraph_ess_all(IGRAPH_EDGEORDER_ID), (vec)))
/**
 * \define EABV
 * Query a boolean edge attribute for all edges.
 *
 * This is a shorthand for \ref igraph_cattribute_EABV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define EABV(graph,n,vec) (igraph_cattribute_EABV((graph),(n), \
                           igraph_ess_all(IGRAPH_EDGEORDER_ID), (vec)))

/**
 * \define EASV
 * Query a string edge attribute for all edges.
 *
 * This is a shorthand for \ref igraph_cattribute_EASV().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vec Pointer to an initialized string vector, the result is
 *        stored here. It will be resized, if needed.
 * \return Error code.
 */
#define EASV(graph,n,vec) (igraph_cattribute_EASV((graph),(n), \
                           igraph_ess_all(IGRAPH_EDGEORDER_ID), (vec)))
/**
 * \define SETGAN
 * Set a numeric graph attribute
 *
 * This is a shorthand for \ref igraph_cattribute_GAN_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETGAN(graph,n,value) (igraph_cattribute_GAN_set((graph),(n),(value)))
/**
 * \define SETGAB
 * Set a boolean graph attribute
 *
 * This is a shorthand for \ref igraph_cattribute_GAB_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETGAB(graph,n,value) (igraph_cattribute_GAB_set((graph),(n),(value)))
/**
 * \define SETGAS
 * Set a string graph attribute
 *
 * This is a shorthand for \ref igraph_cattribute_GAS_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETGAS(graph,n,value) (igraph_cattribute_GAS_set((graph),(n),(value)))
/**
 * \define SETVAN
 * Set a numeric vertex attribute
 *
 * This is a shorthand for \ref igraph_cattribute_VAN_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vid Ids of the vertices to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETVAN(graph,n,vid,value) (igraph_cattribute_VAN_set((graph),(n),(vid),(value)))
/**
 * \define SETVAB
 * Set a boolean vertex attribute
 *
 * This is a shorthand for \ref igraph_cattribute_VAB_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vid Ids of the vertices to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETVAB(graph,n,vid,value) (igraph_cattribute_VAB_set((graph),(n),(vid),(value)))
/**
 * \define SETVAS
 * Set a string vertex attribute
 *
 * This is a shorthand for \ref igraph_cattribute_VAS_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param vid Ids of the vertices to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETVAS(graph,n,vid,value) (igraph_cattribute_VAS_set((graph),(n),(vid),(value)))
/**
 * \define SETEAN
 * Set a numeric edge attribute
 *
 * This is a shorthand for \ref igraph_cattribute_EAN_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param eid Ids of the edges to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETEAN(graph,n,eid,value) (igraph_cattribute_EAN_set((graph),(n),(eid),(value)))
/**
 * \define SETEAB
 * Set a boolean edge attribute
 *
 * This is a shorthand for \ref igraph_cattribute_EAB_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param eid Ids of the edges to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETEAB(graph,n,eid,value) (igraph_cattribute_EAB_set((graph),(n),(eid),(value)))
/**
 * \define SETEAS
 * Set a string edge attribute
 *
 * This is a shorthand for \ref igraph_cattribute_EAS_set().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param eid Ids of the edges to set.
 * \param value The new value of the attribute.
 * \return Error code.
 */
#define SETEAS(graph,n,eid,value) (igraph_cattribute_EAS_set((graph),(n),(eid),(value)))

/**
 * \define SETVANV
 *  Set a numeric vertex attribute for all vertices
 *
 * This is a shorthand for \ref igraph_cattribute_VAN_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 * \return Error code.
 */
#define SETVANV(graph,n,v) (igraph_cattribute_VAN_setv((graph),(n),(v)))
/**
 * \define SETVABV
 *  Set a boolean vertex attribute for all vertices
 *
 * This is a shorthand for \ref igraph_cattribute_VAB_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 * \return Error code.
 */
#define SETVABV(graph,n,v) (igraph_cattribute_VAB_setv((graph),(n),(v)))
/**
 * \define SETVASV
 *  Set a string vertex attribute for all vertices
 *
 * This is a shorthand for \ref igraph_cattribute_VAS_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 * \return Error code.
 */
#define SETVASV(graph,n,v) (igraph_cattribute_VAS_setv((graph),(n),(v)))
/**
 * \define SETEANV
 *  Set a numeric edge attribute for all edges
 *
 * This is a shorthand for \ref igraph_cattribute_EAN_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 */
#define SETEANV(graph,n,v) (igraph_cattribute_EAN_setv((graph),(n),(v)))
/**
 * \define SETEABV
 *  Set a boolean edge attribute for all edges
 *
 * This is a shorthand for \ref igraph_cattribute_EAB_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 */
#define SETEABV(graph,n,v) (igraph_cattribute_EAB_setv((graph),(n),(v)))
/**
 * \define SETEASV
 *  Set a string edge attribute for all edges
 *
 * This is a shorthand for \ref igraph_cattribute_EAS_setv().
 * \param graph The graph.
 * \param n The name of the attribute.
 * \param v Vector containing the new values of the attributes.
 */
#define SETEASV(graph,n,v) (igraph_cattribute_EAS_setv((graph),(n),(v)))

/**
 * \define DELGA
 * Remove a graph attribute.
 *
 * A shorthand for \ref igraph_cattribute_remove_g().
 * \param graph The graph.
 * \param n The name of the attribute to remove.
 */
#define DELGA(graph,n) (igraph_cattribute_remove_g((graph),(n)))
/**
 * \define DELVA
 * Remove a vertex attribute.
 *
 * A shorthand for \ref igraph_cattribute_remove_v().
 * \param graph The graph.
 * \param n The name of the attribute to remove.
 */
#define DELVA(graph,n) (igraph_cattribute_remove_v((graph),(n)))
/**
 * \define DELEA
 * Remove an edge attribute.
 *
 * A shorthand for \ref igraph_cattribute_remove_e().
 * \param graph The graph.
 * \param n The name of the attribute to remove.
 */
#define DELEA(graph,n) (igraph_cattribute_remove_e((graph),(n)))
/**
 * \define DELGAS
 * Remove all graph attributes.
 *
 * Calls \ref igraph_cattribute_remove_all().
 * \param graph The graph.
 */
#define DELGAS(graph) (igraph_cattribute_remove_all((graph),1,0,0))
/**
 * \define DELVAS
 * Remove all vertex attributes.
 *
 * Calls \ref igraph_cattribute_remove_all().
 * \param graph The graph.
 */
#define DELVAS(graph) (igraph_cattribute_remove_all((graph),0,1,0))
/**
 * \define DELEAS
 * Remove all edge attributes.
 *
 * Calls \ref igraph_cattribute_remove_all().
 * \param graph The graph.
 */
#define DELEAS(graph) (igraph_cattribute_remove_all((graph),0,0,1))
/**
 * \define DELALL
 * Remove all attributes.
 *
 * All graph, vertex and edges attributes will be removed.
 * Calls \ref igraph_cattribute_remove_all().
 * \param graph The graph.
 */
#define DELALL(graph) (igraph_cattribute_remove_all((graph),1,1,1))

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_bipartite.h0000644000175100001710000001112500000000000024763 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_BIPARTITE_H
#define IGRAPH_BIPARTITE_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Bipartite networks                                 */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_full_bipartite(igraph_t *graph,
                                        igraph_vector_bool_t *types,
                                        igraph_integer_t n1, igraph_integer_t n2,
                                        igraph_bool_t directed,
                                        igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_create_bipartite(igraph_t *g, const igraph_vector_bool_t *types,
                                          const igraph_vector_t *edges,
                                          igraph_bool_t directed);

IGRAPH_EXPORT int igraph_bipartite_projection_size(const igraph_t *graph,
                                                   const igraph_vector_bool_t *types,
                                                   igraph_integer_t *vcount1,
                                                   igraph_integer_t *ecount1,
                                                   igraph_integer_t *vcount2,
                                                   igraph_integer_t *ecount2);

IGRAPH_EXPORT int igraph_bipartite_projection(const igraph_t *graph,
                                              const igraph_vector_bool_t *types,
                                              igraph_t *proj1,
                                              igraph_t *proj2,
                                              igraph_vector_t *multiplicity1,
                                              igraph_vector_t *multiplicity2,
                                              igraph_integer_t probe1);

IGRAPH_EXPORT int igraph_incidence(igraph_t *graph, igraph_vector_bool_t *types,
                                   const igraph_matrix_t *incidence, igraph_bool_t directed,
                                   igraph_neimode_t mode, igraph_bool_t multiple);

IGRAPH_EXPORT int igraph_get_incidence(const igraph_t *graph,
                                       const igraph_vector_bool_t *types,
                                       igraph_matrix_t *res,
                                       igraph_vector_t *row_ids,
                                       igraph_vector_t *col_ids);

IGRAPH_EXPORT int igraph_is_bipartite(const igraph_t *graph,
                                      igraph_bool_t *res,
                                      igraph_vector_bool_t *types);

IGRAPH_EXPORT int igraph_bipartite_game(igraph_t *graph, igraph_vector_bool_t *types,
                                        igraph_erdos_renyi_t type,
                                        igraph_integer_t n1, igraph_integer_t n2,
                                        igraph_real_t p, igraph_integer_t m,
                                        igraph_bool_t directed, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_bipartite_game_gnp(igraph_t *graph, igraph_vector_bool_t *types,
                                            igraph_integer_t n1, igraph_integer_t n2,
                                            igraph_real_t p, igraph_bool_t directed,
                                            igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_bipartite_game_gnm(igraph_t *graph, igraph_vector_bool_t *types,
                                            igraph_integer_t n1, igraph_integer_t n2,
                                            igraph_integer_t m, igraph_bool_t directed,
                                            igraph_neimode_t mode);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_blas.h0000644000175100001710000000530700000000000023726 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_BLAS_H
#define IGRAPH_BLAS_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"

__BEGIN_DECLS

/**
 * \section about_blas BLAS interface in igraph
 *
 * 
 * BLAS is a highly optimized library for basic linear algebra operations
 * such as vector-vector, matrix-vector and matrix-matrix product.
 * Please see http://www.netlib.org/blas/ for details and a reference
 * implementation in Fortran. igraph contains some wrapper functions
 * that can be used to call BLAS routines in a somewhat more
 * user-friendly way. Not all BLAS routines are included in igraph,
 * and even those which are included might not have wrappers;
 * the extension of the set of wrapped functions will probably be driven
 * by igraph's internal requirements. The wrapper functions usually
 * substitute double-precision floating point arrays used by BLAS with
 * \type igraph_vector_t and \type igraph_matrix_t instances and also
 * remove those parameters (such as the number of rows/columns) that
 * can be inferred from the passed arguments directly.
 * 
 */

IGRAPH_EXPORT void igraph_blas_dgemv(igraph_bool_t transpose, igraph_real_t alpha,
                                     const igraph_matrix_t* a, const igraph_vector_t* x,
                                     igraph_real_t beta, igraph_vector_t* y);
IGRAPH_EXPORT void igraph_blas_dgemv_array(igraph_bool_t transpose, igraph_real_t alpha,
                                           const igraph_matrix_t* a, const igraph_real_t* x,
                                           igraph_real_t beta, igraph_real_t* y);

IGRAPH_EXPORT igraph_real_t igraph_blas_dnrm2(const igraph_vector_t *v);

IGRAPH_EXPORT int igraph_blas_ddot(const igraph_vector_t *v1, const igraph_vector_t *v2,
                                   igraph_real_t *res);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_centrality.h0000644000175100001710000002674300000000000025172 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CENTRALITY_H
#define IGRAPH_CENTRALITY_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"
#include "igraph_arpack.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Centrality                                         */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_closeness(const igraph_t *graph, igraph_vector_t *res,
                                   igraph_vector_t *reachable_count, igraph_bool_t *all_reachable,
                                   const igraph_vs_t vids, igraph_neimode_t mode,
                                   const igraph_vector_t *weights, igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_closeness_cutoff(const igraph_t *graph, igraph_vector_t *res,
                                          igraph_vector_t *reachable_count, igraph_bool_t *all_reachable,
                                          const igraph_vs_t vids, igraph_neimode_t mode,
                                          const igraph_vector_t *weights,
                                          igraph_bool_t normalized,
                                          igraph_real_t cutoff);

IGRAPH_EXPORT int igraph_harmonic_centrality(const igraph_t *graph, igraph_vector_t *res,
                                             const igraph_vs_t vids, igraph_neimode_t mode,
                                             const igraph_vector_t *weights,
                                             igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_harmonic_centrality_cutoff(const igraph_t *graph, igraph_vector_t *res,
                                                    const igraph_vs_t vids, igraph_neimode_t mode,
                                                    const igraph_vector_t *weights,
                                                    igraph_bool_t normalized,
                                                    igraph_real_t cutoff);

IGRAPH_EXPORT int igraph_betweenness(const igraph_t *graph, igraph_vector_t *res,
                                     const igraph_vs_t vids, igraph_bool_t directed,
                                     const igraph_vector_t *weights);
IGRAPH_EXPORT int igraph_betweenness_cutoff(const igraph_t *graph, igraph_vector_t *res,
                                            const igraph_vs_t vids, igraph_bool_t directed,
                                            const igraph_vector_t *weights, igraph_real_t cutoff);
IGRAPH_EXPORT int igraph_edge_betweenness(const igraph_t *graph, igraph_vector_t *result,
                                          igraph_bool_t directed,
                                          const igraph_vector_t *weigths);
IGRAPH_EXPORT int igraph_edge_betweenness_cutoff(const igraph_t *graph, igraph_vector_t *result,
                                                 igraph_bool_t directed,
                                                 const igraph_vector_t *weights, igraph_real_t cutoff);

/**
 * \typedef igraph_pagerank_algo_t
 * \brief PageRank algorithm implementation
 *
 * Algorithms to calculate PageRank.
 * \enumval IGRAPH_PAGERANK_ALGO_ARPACK Use the ARPACK library, this
 *   was the PageRank implementation in igraph from version 0.5, until
 *   version 0.7.
 * \enumval IGRAPH_PAGERANK_ALGO_PRPACK Use the PRPACK
 *   library. Currently this implementation is recommended.
 */

typedef enum {
    IGRAPH_PAGERANK_ALGO_ARPACK = 1,
    IGRAPH_PAGERANK_ALGO_PRPACK = 2
} igraph_pagerank_algo_t;

IGRAPH_EXPORT int igraph_pagerank(const igraph_t *graph, igraph_pagerank_algo_t algo,
                                  igraph_vector_t *vector,
                                  igraph_real_t *value, const igraph_vs_t vids,
                                  igraph_bool_t directed, igraph_real_t damping,
                                  const igraph_vector_t *weights, igraph_arpack_options_t *options);
IGRAPH_EXPORT int igraph_personalized_pagerank(const igraph_t *graph,
                                               igraph_pagerank_algo_t algo, igraph_vector_t *vector,
                                               igraph_real_t *value, const igraph_vs_t vids,
                                               igraph_bool_t directed, igraph_real_t damping,
                                               const igraph_vector_t *reset,
                                               const igraph_vector_t *weights, igraph_arpack_options_t *options);
IGRAPH_EXPORT int igraph_personalized_pagerank_vs(const igraph_t *graph,
                                                  igraph_pagerank_algo_t algo,
                                                  igraph_vector_t *vector,
                                                  igraph_real_t *value, const igraph_vs_t vids,
                                                  igraph_bool_t directed, igraph_real_t damping,
                                                  igraph_vs_t reset_vids,
                                                  const igraph_vector_t *weights, igraph_arpack_options_t *options);

IGRAPH_EXPORT int igraph_eigenvector_centrality(const igraph_t *graph, igraph_vector_t *vector,
                                                igraph_real_t *value,
                                                igraph_bool_t directed, igraph_bool_t scale,
                                                const igraph_vector_t *weights,
                                                igraph_arpack_options_t *options);

IGRAPH_EXPORT int igraph_hub_score(const igraph_t *graph, igraph_vector_t *vector,
                                   igraph_real_t *value, igraph_bool_t scale,
                                   const igraph_vector_t *weights,
                                   igraph_arpack_options_t *options);
IGRAPH_EXPORT int igraph_authority_score(const igraph_t *graph, igraph_vector_t *vector,
                                         igraph_real_t *value, igraph_bool_t scale,
                                         const igraph_vector_t *weights,
                                         igraph_arpack_options_t *options);

IGRAPH_EXPORT int igraph_constraint(const igraph_t *graph, igraph_vector_t *res,
                                    igraph_vs_t vids, const igraph_vector_t *weights);

IGRAPH_EXPORT int igraph_convergence_degree(const igraph_t *graph, igraph_vector_t *result,
                                            igraph_vector_t *ins, igraph_vector_t *outs);

IGRAPH_EXPORT igraph_real_t igraph_centralization(const igraph_vector_t *scores,
                                                  igraph_real_t theoretical_max,
                                                  igraph_bool_t normalized);

IGRAPH_EXPORT int igraph_centralization_degree(const igraph_t *graph, igraph_vector_t *res,
                                               igraph_neimode_t mode, igraph_bool_t loops,
                                               igraph_real_t *centralization,
                                               igraph_real_t *theoretical_max,
                                               igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_centralization_degree_tmax(const igraph_t *graph,
                                                    igraph_integer_t nodes,
                                                    igraph_neimode_t mode,
                                                    igraph_bool_t loops,
                                                    igraph_real_t *res);

IGRAPH_EXPORT int igraph_centralization_betweenness(const igraph_t *graph,
                                                    igraph_vector_t *res,
                                                    igraph_bool_t directed,
                                                    igraph_real_t *centralization,
                                                    igraph_real_t *theoretical_max,
                                                    igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_centralization_betweenness_tmax(const igraph_t *graph,
                                                         igraph_integer_t nodes,
                                                         igraph_bool_t directed,
                                                         igraph_real_t *res);

IGRAPH_EXPORT int igraph_centralization_closeness(const igraph_t *graph,
                                                  igraph_vector_t *res,
                                                  igraph_neimode_t mode,
                                                  igraph_real_t *centralization,
                                                  igraph_real_t *theoretical_max,
                                                  igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_centralization_closeness_tmax(const igraph_t *graph,
                                                       igraph_integer_t nodes,
                                                       igraph_neimode_t mode,
                                                       igraph_real_t *res);

IGRAPH_EXPORT int igraph_centralization_eigenvector_centrality(
    const igraph_t *graph,
    igraph_vector_t *vector,
    igraph_real_t *value,
    igraph_bool_t directed,
    igraph_bool_t scale,
    igraph_arpack_options_t *options,
    igraph_real_t *centralization,
    igraph_real_t *theoretical_max,
    igraph_bool_t normalized);
IGRAPH_EXPORT int igraph_centralization_eigenvector_centrality_tmax(
    const igraph_t *graph,
    igraph_integer_t nodes,
    igraph_bool_t directed,
    igraph_bool_t scale,
    igraph_real_t *res);


/* Deprecated functions: */

IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_closeness_estimate(const igraph_t *graph, igraph_vector_t *res,
                                                              const igraph_vs_t vids, igraph_neimode_t mode,
                                                              igraph_real_t cutoff,
                                                              const igraph_vector_t *weights,
                                                              igraph_bool_t normalized);

IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_betweenness_estimate(const igraph_t *graph, igraph_vector_t *res,
                                                                const igraph_vs_t vids, igraph_bool_t directed,
                                                                igraph_real_t cutoff, const igraph_vector_t *weights);

IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_edge_betweenness_estimate(const igraph_t *graph, igraph_vector_t *result,
                                                                     igraph_bool_t directed, igraph_real_t cutoff,
                                                                     const igraph_vector_t *weights);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_cliques.h0000644000175100001710000001347100000000000024453 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CLIQUES_H
#define IGRAPH_CLIQUES_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Cliques, maximal independent vertex sets           */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_maximal_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
                                         igraph_integer_t min_size, igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_maximal_cliques_file(const igraph_t *graph,
                                              FILE *outfile,
                                              igraph_integer_t min_size,
                                              igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_maximal_cliques_count(const igraph_t *graph,
                                               igraph_integer_t *res,
                                               igraph_integer_t min_size,
                                               igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_maximal_cliques_subset(const igraph_t *graph,
                                                igraph_vector_int_t *subset,
                                                igraph_vector_ptr_t *res,
                                                igraph_integer_t *no,
                                                FILE *outfile,
                                                igraph_integer_t min_size,
                                                igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_maximal_cliques_hist(const igraph_t *graph,
                                              igraph_vector_t *hist,
                                              igraph_integer_t min_size,
                                              igraph_integer_t max_size);

IGRAPH_EXPORT int igraph_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
                                 igraph_integer_t min_size, igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_clique_size_hist(const igraph_t *graph, igraph_vector_t *hist,
                                          igraph_integer_t min_size, igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_largest_cliques(const igraph_t *graph,
                                         igraph_vector_ptr_t *cliques);
IGRAPH_EXPORT int igraph_clique_number(const igraph_t *graph, igraph_integer_t *no);
IGRAPH_EXPORT int igraph_weighted_cliques(const igraph_t *graph,
                                          const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res,
                                          igraph_real_t min_weight, igraph_real_t max_weight, igraph_bool_t maximal);
IGRAPH_EXPORT int igraph_largest_weighted_cliques(const igraph_t *graph,
                                                  const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res);
IGRAPH_EXPORT int igraph_weighted_clique_number(const igraph_t *graph,
                                                const igraph_vector_t *vertex_weights, igraph_real_t *res);
IGRAPH_EXPORT int igraph_independent_vertex_sets(const igraph_t *graph,
                                                 igraph_vector_ptr_t *res,
                                                 igraph_integer_t min_size,
                                                 igraph_integer_t max_size);
IGRAPH_EXPORT int igraph_largest_independent_vertex_sets(const igraph_t *graph,
                                                         igraph_vector_ptr_t *res);
IGRAPH_EXPORT int igraph_maximal_independent_vertex_sets(const igraph_t *graph,
                                                         igraph_vector_ptr_t *res);
IGRAPH_EXPORT int igraph_independence_number(const igraph_t *graph, igraph_integer_t *no);

/**
 * \typedef igraph_clique_handler_t
 * \brief Type of clique handler functions.
 *
 * Callback type, called when a clique was found.
 *
 * See the details at the documentation of \ref
 * igraph_cliques_callback().
 *
 * \param clique The current clique. Destroying and freeing
 *   this vector is left to the user.
 *   Use \ref igraph_vector_destroy() and \ref igraph_free()
 *   to do this.
 * \param arg This extra argument was passed to \ref
 *   igraph_cliques_callback() when it was called.
 * \return Boolean, whether to continue with the clique search.
 */
typedef igraph_bool_t igraph_clique_handler_t(igraph_vector_t *clique, void *arg);

IGRAPH_EXPORT int igraph_cliques_callback(const igraph_t *graph,
                                          igraph_integer_t min_size, igraph_integer_t max_size,
                                          igraph_clique_handler_t *cliquehandler_fn, void *arg);

IGRAPH_EXPORT int igraph_maximal_cliques_callback(const igraph_t *graph,
                                                  igraph_clique_handler_t *cliquehandler_fn, void *arg,
                                                  igraph_integer_t min_size, igraph_integer_t max_size);


__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_cocitation.h0000644000175100001710000000613000000000000025134 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_COCITATION_H
#define IGRAPH_COCITATION_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_matrix.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Cocitation and other similarity measures           */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_cocitation(const igraph_t *graph, igraph_matrix_t *res,
                                    const igraph_vs_t vids);
IGRAPH_EXPORT int igraph_bibcoupling(const igraph_t *graph, igraph_matrix_t *res,
                                     const igraph_vs_t vids);

IGRAPH_EXPORT int igraph_similarity_jaccard(const igraph_t *graph, igraph_matrix_t *res,
                                            const igraph_vs_t vids, igraph_neimode_t mode,
                                            igraph_bool_t loops);
IGRAPH_EXPORT int igraph_similarity_jaccard_pairs(const igraph_t *graph, igraph_vector_t *res,
                                                  const igraph_vector_t *pairs, igraph_neimode_t mode, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_similarity_jaccard_es(const igraph_t *graph, igraph_vector_t *res,
                                               const igraph_es_t es, igraph_neimode_t mode, igraph_bool_t loops);

IGRAPH_EXPORT int igraph_similarity_dice(const igraph_t *graph, igraph_matrix_t *res,
                                         const igraph_vs_t vids, igraph_neimode_t mode,
                                         igraph_bool_t loops);
IGRAPH_EXPORT int igraph_similarity_dice_pairs(const igraph_t *graph, igraph_vector_t *res,
                                               const igraph_vector_t *pairs, igraph_neimode_t mode, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_similarity_dice_es(const igraph_t *graph, igraph_vector_t *res,
                                            const igraph_es_t es, igraph_neimode_t mode, igraph_bool_t loops);

IGRAPH_EXPORT int igraph_similarity_inverse_log_weighted(const igraph_t *graph,
                                                         igraph_matrix_t *res, const igraph_vs_t vids,
                                                         igraph_neimode_t mode);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_cohesive_blocks.h0000644000175100001710000000262400000000000026146 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_COHESIVE_BLOCKS_H
#define IGRAPH_COHESIVE_BLOCKS_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_cohesive_blocks(const igraph_t *graph,
                                         igraph_vector_ptr_t *blocks,
                                         igraph_vector_t *cohesion,
                                         igraph_vector_t *parent,
                                         igraph_t *block_tree);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_coloring.h0000644000175100001710000000273500000000000024623 0ustar00runnerdocker00000000000000/*
  Heuristic graph coloring algorithms.
  Copyright (C) 2017 Szabolcs Horvat 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#ifndef IGRAPH_COLORING_H
#define IGRAPH_COLORING_H

#include "igraph_decls.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/**
 * \typedef igraph_coloring_greedy_t
 * \brief Ordering heuristics for greedy graph coloring.
 *
 * Ordering heuristics for \ref igraph_vertex_coloring_greedy().
 *
 * \enumval IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS  Choose vertex with largest number of already colored neighbors.
 *
 */
typedef enum {
    IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS = 0
} igraph_coloring_greedy_t;

IGRAPH_EXPORT int igraph_vertex_coloring_greedy(const igraph_t *graph, igraph_vector_int_t *colors, igraph_coloring_greedy_t heuristic);

__END_DECLS

#endif /* IGRAPH_COLORING_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_community.h0000644000175100001710000003361200000000000025031 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_COMMUNITY_H
#define IGRAPH_COMMUNITY_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_arpack.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* K-Cores                                            */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_coreness(const igraph_t *graph, igraph_vector_t *cores,
                                  igraph_neimode_t mode);

/* -------------------------------------------------- */
/* Community Structure                                */
/* -------------------------------------------------- */

/* TODO: cut.community */
/* TODO: edge.type.matrix */
/* TODO:  */

IGRAPH_EXPORT int igraph_community_optimal_modularity(const igraph_t *graph,
                                                      igraph_real_t *modularity,
                                                      igraph_vector_t *membership,
                                                      const igraph_vector_t *weights);

IGRAPH_EXPORT int igraph_community_spinglass(const igraph_t *graph,
                                             const igraph_vector_t *weights,
                                             igraph_real_t *modularity,
                                             igraph_real_t *temperature,
                                             igraph_vector_t *membership,
                                             igraph_vector_t *csize,
                                             igraph_integer_t spins,
                                             igraph_bool_t parupdate,
                                             igraph_real_t starttemp,
                                             igraph_real_t stoptemp,
                                             igraph_real_t coolfact,
                                             igraph_spincomm_update_t update_rule,
                                             igraph_real_t gamma,
                                       /* the rest is for the NegSpin implementation */
                                       igraph_spinglass_implementation_t implementation,
                                       /*                    igraph_matrix_t *adhesion, */
                                       /*                    igraph_matrix_t *normalised_adhesion, */
                                       /*                    igraph_real_t *polarization, */
                                       igraph_real_t lambda);

IGRAPH_EXPORT int igraph_community_spinglass_single(const igraph_t *graph,
                                                    const igraph_vector_t *weights,
                                                    igraph_integer_t vertex,
                                                    igraph_vector_t *community,
                                                    igraph_real_t *cohesion,
                                                    igraph_real_t *adhesion,
                                                    igraph_integer_t *inner_links,
                                                    igraph_integer_t *outer_links,
                                                    igraph_integer_t spins,
                                                    igraph_spincomm_update_t update_rule,
                                                    igraph_real_t gamma);

IGRAPH_EXPORT int igraph_community_walktrap(const igraph_t *graph,
                                            const igraph_vector_t *weights,
                                            int steps,
                                            igraph_matrix_t *merges,
                                            igraph_vector_t *modularity,
                                            igraph_vector_t *membership);

IGRAPH_EXPORT int igraph_community_infomap(const igraph_t * graph,
                                           const igraph_vector_t *e_weights,
                                           const igraph_vector_t *v_weights,
                                           int nb_trials,
                                           igraph_vector_t *membership,
                                           igraph_real_t *codelength);

IGRAPH_EXPORT int igraph_community_edge_betweenness(const igraph_t *graph,
                                                    igraph_vector_t *result,
                                                    igraph_vector_t *edge_betweenness,
                                                    igraph_matrix_t *merges,
                                                    igraph_vector_t *bridges,
                                                    igraph_vector_t *modularity,
                                                    igraph_vector_t *membership,
                                                    igraph_bool_t directed,
                                                    const igraph_vector_t *weights);
IGRAPH_EXPORT int igraph_community_eb_get_merges(const igraph_t *graph,
                                                 const igraph_bool_t directed,
                                                 const igraph_vector_t *edges,
                                                 const igraph_vector_t *weights,
                                                 igraph_matrix_t *merges,
                                                 igraph_vector_t *bridges,
                                                 igraph_vector_t *modularity,
                                                 igraph_vector_t *membership);

IGRAPH_EXPORT int igraph_community_fastgreedy(const igraph_t *graph,
                                              const igraph_vector_t *weights,
                                              igraph_matrix_t *merges,
                                              igraph_vector_t *modularity,
                                              igraph_vector_t *membership);

IGRAPH_EXPORT int igraph_community_to_membership(const igraph_matrix_t *merges,
                                                 igraph_integer_t nodes,
                                                 igraph_integer_t steps,
                                                 igraph_vector_t *membership,
                                                 igraph_vector_t *csize);
IGRAPH_EXPORT int igraph_le_community_to_membership(const igraph_matrix_t *merges,
                                                    igraph_integer_t steps,
                                                    igraph_vector_t *membership,
                                                    igraph_vector_t *csize);

IGRAPH_EXPORT int igraph_modularity(const igraph_t *graph,
                                    const igraph_vector_t *membership,
                                    const igraph_vector_t *weights,
                                    const igraph_real_t resolution,
                                    const igraph_bool_t directed,
                                    igraph_real_t *modularity);

IGRAPH_EXPORT int igraph_modularity_matrix(const igraph_t *graph,
                                           const igraph_vector_t *weights,
                                           const igraph_real_t resolution,
                                           igraph_matrix_t *modmat,
                                           igraph_bool_t directed);

IGRAPH_EXPORT int igraph_reindex_membership(igraph_vector_t *membership,
                                            igraph_vector_t *new_to_old,
                                            igraph_integer_t *nb_clusters);

typedef enum { IGRAPH_LEVC_HIST_SPLIT = 1,
               IGRAPH_LEVC_HIST_FAILED,
               IGRAPH_LEVC_HIST_START_FULL,
               IGRAPH_LEVC_HIST_START_GIVEN
             } igraph_leading_eigenvector_community_history_t;

/**
 * \typedef igraph_community_leading_eigenvector_callback_t
 * Callback for the leading eigenvector community finding method.
 *
 * The leading eigenvector community finding implementation in igraph
 * is able to call a callback function, after each eigenvalue
 * calculation. This callback function must be of \c
 * igraph_community_leading_eigenvector_callback_t type.
 * The following arguments are passed to the callback:
 * \param membership The actual membership vector, before recording
 *    the potential change implied by the newly found eigenvalue.
 * \param comm The id of the community that the algorithm tried to
 *    split in the last iteration. The community ids are indexed from
 *    zero here!
 * \param eigenvalue The eigenvalue the algorithm has just found.
 * \param eigenvector The eigenvector corresponding to the eigenvalue
 *    the algorithm just found.
 * \param arpack_multiplier A function that was passed to \ref
 *    igraph_arpack_rssolve() to solve the last eigenproblem.
 * \param arpack_extra The extra argument that was passed to the
 *    ARPACK solver.
 * \param extra Extra argument that as passed to \ref
 *    igraph_community_leading_eigenvector().
 *
 * \sa \ref igraph_community_leading_eigenvector(), \ref
 * igraph_arpack_function_t, \ref igraph_arpack_rssolve().
 */

typedef int igraph_community_leading_eigenvector_callback_t(
    const igraph_vector_t *membership,
    long int comm,
    igraph_real_t eigenvalue,
    const igraph_vector_t *eigenvector,
    igraph_arpack_function_t *arpack_multiplier,
    void *arpack_extra,
    void *extra);

IGRAPH_EXPORT int igraph_community_leading_eigenvector(const igraph_t *graph,
                                                       const igraph_vector_t *weights,
                                                       igraph_matrix_t *merges,
                                                       igraph_vector_t *membership,
                                                       igraph_integer_t steps,
                                                       igraph_arpack_options_t *options,
                                                       igraph_real_t *modularity,
                                                       igraph_bool_t start,
                                                       igraph_vector_t *eigenvalues,
                                                       igraph_vector_ptr_t *eigenvectors,
                                                       igraph_vector_t *history,
                                                       igraph_community_leading_eigenvector_callback_t *callback,
                                                       void *callback_extra);

IGRAPH_EXPORT int igraph_community_fluid_communities(const igraph_t *graph,
                                                     igraph_integer_t no_of_communities,
                                                     igraph_vector_t *membership,
                                                     igraph_real_t *modularity);

IGRAPH_EXPORT int igraph_community_label_propagation(const igraph_t *graph,
                                                     igraph_vector_t *membership,
                                                     const igraph_vector_t *weights,
                                                     const igraph_vector_t *initial,
                                                     const igraph_vector_bool_t *fixed,
                                                     igraph_real_t *modularity);

IGRAPH_EXPORT int igraph_community_multilevel(const igraph_t *graph,
                                              const igraph_vector_t *weights,
                                              const igraph_real_t resolution,
                                              igraph_vector_t *membership,
                                              igraph_matrix_t *memberships,
                                              igraph_vector_t *modularity);

IGRAPH_EXPORT int igraph_community_leiden(const igraph_t *graph,
                                          const igraph_vector_t *edge_weights,
                                          const igraph_vector_t *node_weights,
                                          const igraph_real_t resolution_parameter,
                                          const igraph_real_t beta,
                                          const igraph_bool_t start,
                                          igraph_vector_t *membership,
                                          igraph_integer_t *nb_clusters,
                                          igraph_real_t *quality);
/* -------------------------------------------------- */
/* Community Structure Comparison                     */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_compare_communities(const igraph_vector_t *comm1,
                                             const igraph_vector_t *comm2,
                                             igraph_real_t* result,
                                             igraph_community_comparison_t method);
IGRAPH_EXPORT int igraph_split_join_distance(const igraph_vector_t *comm1,
                                             const igraph_vector_t *comm2,
                                             igraph_integer_t* distance12,
                                             igraph_integer_t* distance21);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_complex.h0000644000175100001710000001177300000000000024460 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_COMPLEX_H
#define IGRAPH_COMPLEX_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

typedef struct igraph_complex_t {
    igraph_real_t dat[2];
} igraph_complex_t;

#define IGRAPH_REAL(x) ((x).dat[0])
#define IGRAPH_IMAG(x) ((x).dat[1])
#define IGRAPH_COMPLEX_EQ(x,y) ((x).dat[0]==(y).dat[0] && (x).dat[1]==(y).dat[1])

IGRAPH_EXPORT igraph_complex_t igraph_complex(igraph_real_t x, igraph_real_t y);
IGRAPH_EXPORT igraph_complex_t igraph_complex_polar(igraph_real_t r, igraph_real_t theta);

IGRAPH_EXPORT igraph_bool_t igraph_complex_eq_tol(igraph_complex_t z1,
                                                  igraph_complex_t z2,
                                                  igraph_real_t tol);

IGRAPH_EXPORT igraph_real_t igraph_complex_mod(igraph_complex_t z);
IGRAPH_EXPORT igraph_real_t igraph_complex_arg(igraph_complex_t z);

IGRAPH_EXPORT igraph_real_t igraph_complex_abs(igraph_complex_t z);
IGRAPH_EXPORT igraph_real_t igraph_complex_logabs(igraph_complex_t z);

IGRAPH_EXPORT igraph_complex_t igraph_complex_add(igraph_complex_t z1,
                                                  igraph_complex_t z2);
IGRAPH_EXPORT igraph_complex_t igraph_complex_sub(igraph_complex_t z1,
                                                  igraph_complex_t z2);
IGRAPH_EXPORT igraph_complex_t igraph_complex_mul(igraph_complex_t z1,
                                                  igraph_complex_t z2);
IGRAPH_EXPORT igraph_complex_t igraph_complex_div(igraph_complex_t z1,
                                                  igraph_complex_t z2);

IGRAPH_EXPORT igraph_complex_t igraph_complex_add_real(igraph_complex_t z,
                                                       igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_add_imag(igraph_complex_t z,
                                                       igraph_real_t y);
IGRAPH_EXPORT igraph_complex_t igraph_complex_sub_real(igraph_complex_t z,
                                                       igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_sub_imag(igraph_complex_t z,
                                                       igraph_real_t y);
IGRAPH_EXPORT igraph_complex_t igraph_complex_mul_real(igraph_complex_t z,
                                                       igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_mul_imag(igraph_complex_t z,
                                                       igraph_real_t y);
IGRAPH_EXPORT igraph_complex_t igraph_complex_div_real(igraph_complex_t z,
                                                       igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_div_imag(igraph_complex_t z,
                                                       igraph_real_t y);

IGRAPH_EXPORT igraph_complex_t igraph_complex_conj(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_neg(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_inv(igraph_complex_t z);

IGRAPH_EXPORT igraph_complex_t igraph_complex_sqrt(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_sqrt_real(igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_exp(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_pow(igraph_complex_t z1,
                                                  igraph_complex_t z2);
IGRAPH_EXPORT igraph_complex_t igraph_complex_pow_real(igraph_complex_t z,
                                                       igraph_real_t x);
IGRAPH_EXPORT igraph_complex_t igraph_complex_log(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_log10(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_log_b(igraph_complex_t z,
                                                    igraph_complex_t b);

IGRAPH_EXPORT igraph_complex_t igraph_complex_sin(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_cos(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_tan(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_sec(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_csc(igraph_complex_t z);
IGRAPH_EXPORT igraph_complex_t igraph_complex_cot(igraph_complex_t z);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_components.h0000644000175100001710000000521200000000000025165 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_COMPONENTS_H
#define IGRAPH_COMPONENTS_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Components                                         */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_clusters(const igraph_t *graph, igraph_vector_t *membership,
                                  igraph_vector_t *csize, igraph_integer_t *no,
                                  igraph_connectedness_t mode);
IGRAPH_EXPORT int igraph_is_connected(const igraph_t *graph, igraph_bool_t *res,
                                      igraph_connectedness_t mode);
IGRAPH_EXPORT void igraph_decompose_destroy(igraph_vector_ptr_t *complist);
IGRAPH_EXPORT int igraph_decompose(const igraph_t *graph, igraph_vector_ptr_t *components,
                                   igraph_connectedness_t mode,
                                   long int maxcompno, long int minelements);
IGRAPH_EXPORT int igraph_articulation_points(const igraph_t *graph,
                                             igraph_vector_t *res);
IGRAPH_EXPORT int igraph_biconnected_components(const igraph_t *graph,
                                                igraph_integer_t *no,
                                                igraph_vector_ptr_t *tree_edges,
                                                igraph_vector_ptr_t *component_edges,
                                                igraph_vector_ptr_t *components,
                                                igraph_vector_t *articulation_points);
IGRAPH_EXPORT int igraph_bridges(const igraph_t *graph, igraph_vector_t *bridges);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_constants.h0000644000175100001710000001567400000000000025031 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CONSTANTS_H
#define IGRAPH_CONSTANTS_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Constants                                          */
/* -------------------------------------------------- */

typedef enum { IGRAPH_UNDIRECTED = 0, IGRAPH_DIRECTED = 1 } igraph_i_directed_t;

/* Note for the enum below: yes, IGRAPH_LOOPS_TWICE is 1, and IGRAPH_LOOPS_ONCE
 * is 2. This is intentional, for the sake of backwards compatibility with
 * earlier versions where we only had IGRAPH_LOOPS and it meant
 * IGRAPH_LOOPS_TWICE */
typedef enum { IGRAPH_NO_LOOPS = 0, IGRAPH_LOOPS = 1, IGRAPH_LOOPS_TWICE = 1, IGRAPH_LOOPS_ONCE = 2 } igraph_loops_t;

typedef enum { IGRAPH_NO_MULTIPLE = 0, IGRAPH_MULTIPLE = 1 } igraph_multiple_t;

typedef enum { IGRAPH_ASCENDING = 0, IGRAPH_DESCENDING = 1 } igraph_order_t;

typedef enum { IGRAPH_MINIMUM = 0, IGRAPH_MAXIMUM = 1 } igraph_optimal_t;

typedef enum { IGRAPH_OUT = 1, IGRAPH_IN = 2, IGRAPH_ALL = 3,
               IGRAPH_TOTAL = 3
             } igraph_neimode_t;

/* Reverse IGRAPH_OUT to IGRAPH_IN and vice versa. Leave other values alone. */
#define IGRAPH_REVERSE_MODE(mode) \
    ((mode) == IGRAPH_IN ? IGRAPH_OUT : ((mode) == IGRAPH_OUT ? IGRAPH_IN : (mode)))

typedef enum { IGRAPH_WEAK = 1, IGRAPH_STRONG = 2 } igraph_connectedness_t;

typedef enum { IGRAPH_RECIPROCITY_DEFAULT = 0,
               IGRAPH_RECIPROCITY_RATIO = 1
             } igraph_reciprocity_t;

typedef enum { IGRAPH_ADJ_DIRECTED = 0,
               IGRAPH_ADJ_UNDIRECTED = 1, IGRAPH_ADJ_MAX = 1,
               IGRAPH_ADJ_UPPER, IGRAPH_ADJ_LOWER, IGRAPH_ADJ_MIN,
               IGRAPH_ADJ_PLUS
             } igraph_adjacency_t;

typedef enum { IGRAPH_STAR_OUT = 0, IGRAPH_STAR_IN,
               IGRAPH_STAR_UNDIRECTED,
               IGRAPH_STAR_MUTUAL
             } igraph_star_mode_t;

typedef enum { IGRAPH_TREE_OUT = 0, IGRAPH_TREE_IN,
               IGRAPH_TREE_UNDIRECTED
             } igraph_tree_mode_t;

typedef enum { IGRAPH_ERDOS_RENYI_GNP = 0,
               IGRAPH_ERDOS_RENYI_GNM
             } igraph_erdos_renyi_t;

typedef enum { IGRAPH_GET_ADJACENCY_UPPER = 0,
               IGRAPH_GET_ADJACENCY_LOWER,
               IGRAPH_GET_ADJACENCY_BOTH
             } igraph_get_adjacency_t;

typedef enum { IGRAPH_DEGSEQ_SIMPLE = 0,
               IGRAPH_DEGSEQ_VL,
               IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE,
               IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM
             } igraph_degseq_t;

typedef enum { IGRAPH_REALIZE_DEGSEQ_SMALLEST = 0,
               IGRAPH_REALIZE_DEGSEQ_LARGEST,
               IGRAPH_REALIZE_DEGSEQ_INDEX
             } igraph_realize_degseq_t;

typedef enum { IGRAPH_RANDOM_TREE_PRUFER = 0,
               IGRAPH_RANDOM_TREE_LERW
             } igraph_random_tree_t;

typedef enum { IGRAPH_FILEFORMAT_EDGELIST = 0,
               IGRAPH_FILEFORMAT_NCOL,
               IGRAPH_FILEFORMAT_PAJEK,
               IGRAPH_FILEFORMAT_LGL,
               IGRAPH_FILEFORMAT_GRAPHML
             } igraph_fileformat_type_t;

typedef enum { IGRAPH_REWIRING_SIMPLE = 0,
               IGRAPH_REWIRING_SIMPLE_LOOPS
             } igraph_rewiring_t;

typedef enum { IGRAPH_EDGEORDER_ID = 0,
               IGRAPH_EDGEORDER_FROM,
               IGRAPH_EDGEORDER_TO
             } igraph_edgeorder_type_t;

typedef enum { IGRAPH_TO_DIRECTED_ARBITRARY = 0,
               IGRAPH_TO_DIRECTED_MUTUAL,
               IGRAPH_TO_DIRECTED_RANDOM,
               IGRAPH_TO_DIRECTED_ACYCLIC
             } igraph_to_directed_t;

typedef enum { IGRAPH_TO_UNDIRECTED_EACH = 0,
               IGRAPH_TO_UNDIRECTED_COLLAPSE,
               IGRAPH_TO_UNDIRECTED_MUTUAL
             } igraph_to_undirected_t;

typedef enum { IGRAPH_VCONN_NEI_ERROR = 0,
               IGRAPH_VCONN_NEI_NUMBER_OF_NODES,
               IGRAPH_VCONN_NEI_IGNORE,
               IGRAPH_VCONN_NEI_NEGATIVE
             } igraph_vconn_nei_t;

typedef enum { IGRAPH_SPINCOMM_UPDATE_SIMPLE = 0,
               IGRAPH_SPINCOMM_UPDATE_CONFIG
             } igraph_spincomm_update_t;

typedef enum { IGRAPH_DONT_SIMPLIFY = 0,
               IGRAPH_SIMPLIFY
             } igraph_lazy_adlist_simplify_t;

typedef enum { IGRAPH_TRANSITIVITY_NAN = 0,
               IGRAPH_TRANSITIVITY_ZERO
             } igraph_transitivity_mode_t;

typedef enum { IGRAPH_SPINCOMM_IMP_ORIG = 0,
               IGRAPH_SPINCOMM_IMP_NEG
             } igraph_spinglass_implementation_t;

typedef enum { IGRAPH_COMMCMP_VI = 0,
               IGRAPH_COMMCMP_NMI,
               IGRAPH_COMMCMP_SPLIT_JOIN,
               IGRAPH_COMMCMP_RAND,
               IGRAPH_COMMCMP_ADJUSTED_RAND
             } igraph_community_comparison_t;

typedef enum { IGRAPH_ADD_WEIGHTS_NO = 0,
               IGRAPH_ADD_WEIGHTS_YES,
               IGRAPH_ADD_WEIGHTS_IF_PRESENT
             } igraph_add_weights_t;

typedef enum { IGRAPH_BARABASI_BAG = 0,
               IGRAPH_BARABASI_PSUMTREE,
               IGRAPH_BARABASI_PSUMTREE_MULTIPLE
             } igraph_barabasi_algorithm_t;

typedef enum { IGRAPH_FAS_EXACT_IP = 0,
               IGRAPH_FAS_APPROX_EADES
             } igraph_fas_algorithm_t;

typedef enum { IGRAPH_SUBGRAPH_AUTO = 0,
               IGRAPH_SUBGRAPH_COPY_AND_DELETE,
               IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH
             } igraph_subgraph_implementation_t;

typedef enum { IGRAPH_IMITATE_AUGMENTED = 0,
               IGRAPH_IMITATE_BLIND,
               IGRAPH_IMITATE_CONTRACTED
             } igraph_imitate_algorithm_t;

typedef igraph_real_t  igraph_scalar_function_t(const igraph_vector_t *var,
        const igraph_vector_t *par,
        void* extra);
typedef void igraph_vector_function_t(const igraph_vector_t *var,
                                      const igraph_vector_t *par,
                                      igraph_vector_t* res, void* extra);

typedef enum { IGRAPH_LAYOUT_GRID = 0,
               IGRAPH_LAYOUT_NOGRID,
               IGRAPH_LAYOUT_AUTOGRID
             } igraph_layout_grid_t;

typedef enum { IGRAPH_RANDOM_WALK_STUCK_ERROR = 0,
               IGRAPH_RANDOM_WALK_STUCK_RETURN
             } igraph_random_walk_stuck_t;


__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_constructors.h0000644000175100001710000001017600000000000025555 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CONSTRUCTORS_H
#define IGRAPH_CONSTRUCTORS_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_matrix.h"
#include "igraph_datatype.h"
#include "igraph_graphicality.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Constructors, deterministic                        */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_create(igraph_t *graph, const igraph_vector_t *edges, igraph_integer_t n,
                                igraph_bool_t directed);
IGRAPH_EXPORT int igraph_small(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                               ...);
IGRAPH_EXPORT int igraph_adjacency(igraph_t *graph, const igraph_matrix_t *adjmatrix,
                                   igraph_adjacency_t mode);
IGRAPH_EXPORT int igraph_weighted_adjacency(igraph_t *graph, const igraph_matrix_t *adjmatrix,
                                            igraph_adjacency_t mode, const char* attr,
                                            igraph_bool_t loops);
IGRAPH_EXPORT int igraph_star(igraph_t *graph, igraph_integer_t n, igraph_star_mode_t mode,
                              igraph_integer_t center);
IGRAPH_EXPORT int igraph_lattice(igraph_t *graph, const igraph_vector_t *dimvector, igraph_integer_t nei,
                                 igraph_bool_t directed, igraph_bool_t mutual, igraph_bool_t circular);
IGRAPH_EXPORT int igraph_ring(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                              igraph_bool_t mutual, igraph_bool_t circular);
IGRAPH_EXPORT int igraph_tree(igraph_t *graph, igraph_integer_t n, igraph_integer_t children,
                              igraph_tree_mode_t type);
IGRAPH_EXPORT int igraph_from_prufer(igraph_t *graph, const igraph_vector_int_t *prufer);
IGRAPH_EXPORT int igraph_full(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_full_citation(igraph_t *graph, igraph_integer_t n,
                                       igraph_bool_t directed);
IGRAPH_EXPORT int igraph_atlas(igraph_t *graph, int number);
IGRAPH_EXPORT int igraph_extended_chordal_ring(igraph_t *graph, igraph_integer_t nodes,
                                               const igraph_matrix_t *W, igraph_bool_t directed);
IGRAPH_EXPORT int igraph_linegraph(const igraph_t *graph, igraph_t *linegraph);

IGRAPH_EXPORT int igraph_de_bruijn(igraph_t *graph, igraph_integer_t m, igraph_integer_t n);
IGRAPH_EXPORT int igraph_kautz(igraph_t *graph, igraph_integer_t m, igraph_integer_t n);
IGRAPH_EXPORT int igraph_famous(igraph_t *graph, const char *name);
IGRAPH_EXPORT int igraph_lcf_vector(igraph_t *graph, igraph_integer_t n,
                                    const igraph_vector_t *shifts,
                                    igraph_integer_t repeats);
IGRAPH_EXPORT int igraph_lcf(igraph_t *graph, igraph_integer_t n, ...);
IGRAPH_EXPORT int igraph_realize_degree_sequence(igraph_t *graph,
                                                 const igraph_vector_t *outdeg, const igraph_vector_t *indeg,
                                                 igraph_edge_type_sw_t allowed_edge_types,
                                                 igraph_realize_degseq_t method);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_conversion.h0000644000175100001710000000516200000000000025171 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CONVERSION_H
#define IGRAPH_CONVERSION_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_spmatrix.h"
#include "igraph_matrix.h"
#include "igraph_sparsemat.h"
#include "igraph_attributes.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Conversion                                         */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_get_adjacency(const igraph_t *graph, igraph_matrix_t *res,
                                       igraph_get_adjacency_t type, igraph_bool_t eids);
IGRAPH_EXPORT int igraph_get_adjacency_sparse(const igraph_t *graph, igraph_spmatrix_t *res,
                                              igraph_get_adjacency_t type);

IGRAPH_EXPORT int igraph_get_stochastic(const igraph_t *graph,
                                        igraph_matrix_t *matrix,
                                        igraph_bool_t column_wise);

IGRAPH_EXPORT int igraph_get_stochastic_sparsemat(const igraph_t *graph,
                                                  igraph_sparsemat_t *sparsemat,
                                                  igraph_bool_t column_wise);

IGRAPH_EXPORT int igraph_get_edgelist(const igraph_t *graph, igraph_vector_t *res, igraph_bool_t bycol);

IGRAPH_EXPORT int igraph_to_directed(igraph_t *graph,
                                     igraph_to_directed_t flags);
IGRAPH_EXPORT int igraph_to_undirected(igraph_t *graph,
                                       igraph_to_undirected_t mode,
                                       const igraph_attribute_combination_t *edge_comb);
IGRAPH_EXPORT int igraph_to_prufer(const igraph_t *graph, igraph_vector_int_t *prufer);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_datatype.h0000644000175100001710000000627300000000000024623 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_DATATYPE_H
#define IGRAPH_DATATYPE_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/**
 * \ingroup internal
 * \struct igraph_t
 * \brief The internal data structure for storing graphs.
 *
 * It is simple and efficient. It has the following members:
 * - n The number of vertices, redundant.
 * - directed Whether the graph is directed.
 * - from The first column of the edge list.
 * - to The second column of the edge list.
 * - oi The index of the edge list by the first column. Thus
 *   the first edge according to this order goes from
 *   \c from[oi[0]] to \c to[oi[0]]. The length of
 *   this vector is the same as the number of edges in the graph.
 * - ii The index of the edge list by the second column.
 *   The length of this vector is the same as the number of edges.
 * - os Contains pointers to the edgelist (\c from
 *   and \c to for every vertex. The first edge \em from
 *   vertex \c v is edge no. \c from[oi[os[v]]] if
 *   \c os[v]is This is basically the same as os, but this time
 *   for the incoming edges.
 *
 * For undirected graphs, the same edge list is stored, i.e. an
 * undirected edge is stored only once. Currently, undirected edges
 * are canonicalized so that the index of the 'from' vertex is not greater
 * than the index of the 'to' vertex. Thus, if v1 <= v2, only the edge (v1, v2)
 * needs to be searched for, not (v2, v1), to determine if v1 and v2 are connected.
 * However, this fact is NOT guaranteed by the documented public API,
 * and should not be relied upon by the implementation of any functions,
 * except those belonging to the minimal API in type_indexededgelist.c.
 *
 * The storage requirements for a graph with \c |V| vertices
 * and \c |E| edges is \c O(|E|+|V|).
 */
typedef struct igraph_s {
    igraph_integer_t n;
    igraph_bool_t directed;
    igraph_vector_t from;
    igraph_vector_t to;
    igraph_vector_t oi;
    igraph_vector_t ii;
    igraph_vector_t os;
    igraph_vector_t is;
    void *attr;
} igraph_t;

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_decls.h0000644000175100001710000000106700000000000024076 0ustar00runnerdocker00000000000000#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
    #define __BEGIN_DECLS extern "C" {
    #define __END_DECLS }
#else
    #define __BEGIN_DECLS /* empty */
    #define __END_DECLS /* empty */
#endif

/* This is to eliminate gcc warnings about unused parameters */
#define IGRAPH_UNUSED(x) (void)(x)

/* Include the definition of macros controlling symbol visibility */
#include "igraph_export.h"

/* Used instead of IGRAPH_EXPORT with functions that need to be tested,
 * but are not part of the public API. */
#define IGRAPH_PRIVATE_EXPORT IGRAPH_EXPORT
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_dqueue.h0000644000175100001710000000371600000000000024277 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_DQUEUE_H
#define IGRAPH_DQUEUE_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* double ended queue, very useful                    */
/* -------------------------------------------------- */

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_dqueue_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_dqueue_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_dqueue_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_dqueue_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_INT
#include "igraph_pmt.h"
#include "igraph_dqueue_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define IGRAPH_DQUEUE_NULL { 0,0,0,0 }
#define IGRAPH_DQUEUE_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_dqueue_init(v, size)); \
        IGRAPH_FINALLY(igraph_dqueue_destroy, v); } while (0)

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_dqueue_pmt.h0000644000175100001710000000433600000000000025156 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/**
 * Double ended queue data type.
 * \ingroup internal
 */

typedef struct TYPE(igraph_dqueue) {
    BASE *begin;
    BASE *end;
    BASE *stor_begin;
    BASE *stor_end;
} TYPE(igraph_dqueue);

IGRAPH_EXPORT int FUNCTION(igraph_dqueue, init)    (TYPE(igraph_dqueue)* q, long int size);
IGRAPH_EXPORT void FUNCTION(igraph_dqueue, destroy) (TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_dqueue, empty)   (const TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT void FUNCTION(igraph_dqueue, clear)   (TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_dqueue, full)    (TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT long int FUNCTION(igraph_dqueue, size)    (const TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT BASE FUNCTION(igraph_dqueue, pop)     (TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT BASE FUNCTION(igraph_dqueue, pop_back)(TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT BASE FUNCTION(igraph_dqueue, head)    (const TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT BASE FUNCTION(igraph_dqueue, back)    (const TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT int FUNCTION(igraph_dqueue, push)    (TYPE(igraph_dqueue)* q, BASE elem);
IGRAPH_EXPORT int FUNCTION(igraph_dqueue, print)(const TYPE(igraph_dqueue)* q);
IGRAPH_EXPORT int FUNCTION(igraph_dqueue, fprint)(const TYPE(igraph_dqueue)* q, FILE *file);
IGRAPH_EXPORT BASE FUNCTION(igraph_dqueue, e)(const TYPE(igraph_dqueue) *q, long int idx);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_eigen.h0000644000175100001710000001144500000000000024074 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_EIGEN_H
#define IGRAPH_EIGEN_H

#include "igraph_decls.h"
#include "igraph_arpack.h"
#include "igraph_lapack.h"
#include "igraph_sparsemat.h"

__BEGIN_DECLS

typedef enum { IGRAPH_EIGEN_AUTO = 0,
               IGRAPH_EIGEN_LAPACK,
               IGRAPH_EIGEN_ARPACK,
               IGRAPH_EIGEN_COMP_AUTO,
               IGRAPH_EIGEN_COMP_LAPACK,
               IGRAPH_EIGEN_COMP_ARPACK
             } igraph_eigen_algorithm_t;

typedef enum { IGRAPH_EIGEN_LM = 0,
               IGRAPH_EIGEN_SM, /* 1 */
               IGRAPH_EIGEN_LA, /* 2 */
               IGRAPH_EIGEN_SA, /* 3 */
               IGRAPH_EIGEN_BE, /* 4 */
               IGRAPH_EIGEN_LR, /* 5 */
               IGRAPH_EIGEN_SR, /* 6 */
               IGRAPH_EIGEN_LI, /* 7 */
               IGRAPH_EIGEN_SI, /* 8 */
               IGRAPH_EIGEN_ALL, /* 9 */
               IGRAPH_EIGEN_INTERVAL, /* 10 */
               IGRAPH_EIGEN_SELECT
             }  /* 11 */
igraph_eigen_which_position_t;

typedef struct igraph_eigen_which_t {
    igraph_eigen_which_position_t pos;
    int howmany;
    int il, iu;
    igraph_real_t vl, vu;
    int vestimate;
    igraph_lapack_dgeevx_balance_t balance;
} igraph_eigen_which_t;

IGRAPH_EXPORT int igraph_eigen_matrix_symmetric(const igraph_matrix_t *A,
                                                const igraph_sparsemat_t *sA,
                                                igraph_arpack_function_t *fun, int n,
                                                void *extra,
                                                igraph_eigen_algorithm_t algorithm,
                                                const igraph_eigen_which_t *which,
                                                igraph_arpack_options_t *options,
                                                igraph_arpack_storage_t *storage,
                                                igraph_vector_t *values,
                                                igraph_matrix_t *vectors);

IGRAPH_EXPORT int igraph_eigen_matrix(const igraph_matrix_t *A,
                                      const igraph_sparsemat_t *sA,
                                      igraph_arpack_function_t *fun, int n,
                                      void *extra,
                                      igraph_eigen_algorithm_t algorithm,
                                      const igraph_eigen_which_t *which,
                                      igraph_arpack_options_t *options,
                                      igraph_arpack_storage_t *storage,
                                      igraph_vector_complex_t *values,
                                      igraph_matrix_complex_t *vectors);

IGRAPH_EXPORT int igraph_eigen_adjacency(const igraph_t *graph,
                                         igraph_eigen_algorithm_t algorithm,
                                         const igraph_eigen_which_t *which,
                                         igraph_arpack_options_t *options,
                                         igraph_arpack_storage_t *storage,
                                         igraph_vector_t *values,
                                         igraph_matrix_t *vectors,
                                         igraph_vector_complex_t *cmplxvalues,
                                         igraph_matrix_complex_t *cmplxvectors);

IGRAPH_EXPORT int igraph_eigen_laplacian(const igraph_t *graph,
                                         igraph_eigen_algorithm_t algorithm,
                                         const igraph_eigen_which_t *which,
                                         igraph_arpack_options_t *options,
                                         igraph_arpack_storage_t *storage,
                                         igraph_vector_t *values,
                                         igraph_matrix_t *vectors,
                                         igraph_vector_complex_t *cmplxvalues,
                                         igraph_matrix_complex_t *cmplxvectors);


__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_embedding.h0000644000175100001710000000564700000000000024732 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_EMBEDDING_H
#define IGRAPH_EMBEDDING_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_arpack.h"
#include "igraph_eigen.h"
#include "igraph_constants.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_adjacency_spectral_embedding(const igraph_t *graph,
                                                      igraph_integer_t no,
                                                      const igraph_vector_t *weights,
                                                      igraph_eigen_which_position_t which,
                                                      igraph_bool_t scaled,
                                                      igraph_matrix_t *X,
                                                      igraph_matrix_t *Y,
                                                      igraph_vector_t *D,
                                                      const igraph_vector_t *cvec,
                                                      igraph_arpack_options_t *options);

typedef enum {
    IGRAPH_EMBEDDING_D_A = 0,
    IGRAPH_EMBEDDING_I_DAD,
    IGRAPH_EMBEDDING_DAD,
    IGRAPH_EMBEDDING_OAP
} igraph_laplacian_spectral_embedding_type_t;

IGRAPH_EXPORT int igraph_laplacian_spectral_embedding(const igraph_t *graph,
                                                      igraph_integer_t no,
                                                      const igraph_vector_t *weights,
                                                      igraph_eigen_which_position_t which,
                                                      igraph_laplacian_spectral_embedding_type_t type,
                                                      igraph_bool_t scaled,
                                                      igraph_matrix_t *X,
                                                      igraph_matrix_t *Y,
                                                      igraph_vector_t *D,
                                                      igraph_arpack_options_t *options);

IGRAPH_EXPORT int igraph_dim_select(const igraph_vector_t *sv, igraph_integer_t *dim);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_epidemics.h0000644000175100001710000000432300000000000024744 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_EPIDEMICS_H
#define IGRAPH_EPIDEMICS_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/**
 * \struct igraph_sir_t
 * \brief The result of one SIR model simulation.
 *
 * Data structure to store the results of one simulation
 * of the SIR (susceptible-infected-recovered) model on a graph.
 *
 * It has the following members. They are all (real or integer)
 * vectors, and they are of the same length.
 *
 * \member times A vector, the times of the events are stored here.
 * \member no_s An integer vector, the number of susceptibles in
 *              each time step is stored here.
 * \member no_i An integer vector, the number of infected individuals
 *              at each time step, is stored here.
 * \member no_r An integer vector, the number of recovered individuals
 *              is stored here at each time step.
 */

typedef struct igraph_sir_t {
    igraph_vector_t times;
    igraph_vector_int_t no_s, no_i, no_r;
} igraph_sir_t;

IGRAPH_EXPORT int igraph_sir_init(igraph_sir_t *sir);
IGRAPH_EXPORT void igraph_sir_destroy(igraph_sir_t *sir);

IGRAPH_EXPORT int igraph_sir(const igraph_t *graph, igraph_real_t beta,
                             igraph_real_t gamma, igraph_integer_t no_sim,
                             igraph_vector_ptr_t *result);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_error.h0000644000175100001710000011277500000000000024146 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ERROR_H
#define IGRAPH_ERROR_H

#include "igraph_decls.h"

#include 

__BEGIN_DECLS

/* This file contains the igraph error handling.
 * Most bits are taken literally from the GSL library (with the GSL_
 * prefix renamed to IGRAPH_), as I couldn't find a better way to do
 * them. */

/* IGRAPH_NORETURN indicates to the compiler that a function does not return.
 * There are standard facilities for this, namely _Noreturn in C11 and [[noreturn]] in C++11.
 * However, since igraph is currently compiled with older standards, and since
 * the standard 'noreturn' specification would need to be diferent between C and C++,
 * we do not use these facilities.
 */
#if defined(__GNUC__)
/* Compilers that support the GNU C syntax. Use __noreturn__ instead of 'noreturn' as the latter is a macro in C11. */
#define IGRAPH_NORETURN __attribute__((__noreturn__))
#elif defined(_MSC_VER)
/* Compilers that support the MSVC syntax. */
#define IGRAPH_NORETURN __declspec(noreturn)
#else
#define IGRAPH_NORETURN
#endif

/**
 * \section error_handling_basics Error handling basics
 *
 * \a igraph functions can run into various problems preventing them
 * from normal operation. The user might have supplied invalid arguments,
 * e.g. a non-square matrix when a square-matrix was expected, or the program
 * has run out of memory while some more memory allocation is required, etc.
 * 
 *
 * By default \a igraph aborts the program when it runs into an
 * error. While this behavior might be good enough for smaller programs,
 * it is without doubt avoidable in larger projects. Please read further
 * if your project requires more sophisticated error handling. You can
 * safely skip the rest of this chapter otherwise.
 * 
 */

/**
 * \section error_handlers Error handlers
 *
 * 
 * If \a igraph runs into an error - an invalid argument was supplied
 * to a function, or we've ran out of memory - the control is
 * transferred to the \emb error handler \eme function.
 * 
 * The default error handler is \ref igraph_error_handler_abort which
 * prints an error message and aborts the program.
 * 
 * 
 * The \ref igraph_set_error_handler() function can be used to set a new
 * error handler function of type \ref igraph_error_handler_t; see the
 * documentation of this type for details.
 * 
 * 
 * There are two other predefined error handler functions,
 * \ref igraph_error_handler_ignore and \ref igraph_error_handler_printignore.
 * These deallocate the temporarily allocated memory (more about this
 * later) and return with the error code. The latter also prints an
 * error message. If you use these error handlers you need to take
 * care about possible errors yourself by checking the return value of
 * (almost) every non-void \a igraph function.
 * 
 * Independently of the error handler installed, all functions in the
 * library do their best to leave their arguments
 * \em semantically unchanged if an error
 * happens. By semantically we mean that the implementation of an
 * object supplied as an argument might change, but its
 * \quote meaning \endquote in most cases does not. The rare occasions
 * when this rule is violated are documented in this manual.
 * 
 */

/**
 * \section error_codes Error codes
 *
 * Every \a igraph function which can fail return a
 * single integer error code. Some functions are very simple and
 * cannot run into any error, these may return other types, or
 * \type void as well. The error codes are defined by the
 * \ref igraph_error_type_t enumeration.
 * 
 */

/**
 * \section writing_error_handlers Writing error handlers
 *
 * 
 * The contents of the rest of this chapter might be useful only
 * for those who want to create an interface to \a igraph from another
 * language. Most readers can safely skip to the next chapter.
 * 
 *
 * 
 * You can write and install error handlers simply by defining a
 * function of type \ref igraph_error_handler_t and calling
 * \ref igraph_set_error_handler(). This feature is useful for interface
 * writers, as \a igraph will have the chance to
 * signal errors the appropriate way, e.g. the R interface defines an
 * error handler which calls the error()
 * function, as required by R, while the Python interface has an error
 * handler which raises an exception according to the Python way.
 * 
 * 
 * If you want to write an error handler, your error handler should
 * call \ref IGRAPH_FINALLY_FREE() to deallocate all temporary memory to
 * prevent memory leaks. Note that this may invalidate the error message
 * buffer \p reason passed to the error handler. Do not access it after
 * having called \ref IGRAPH_FINALLY_FREE().
 * 
 */

/**
 * \section error_handling_internals Error handling internals
 *
 * 
 * If an error happens, the functions in the library call the
 * \ref IGRAPH_ERROR() macro with a textual description of the error and an
 * \a igraph error code. This macro calls (through the \ref
 * igraph_error() function) the installed error handler. Another useful
 * macro is \ref IGRAPH_CHECK(). This checks the return value of its
 * argument, which is normally a function call, and calls \ref
 * IGRAPH_ERROR() if it is not \c IGRAPH_SUCCESS.
 * 
 */

/**
 * \section deallocating_memory Deallocating memory
 *
 * 
 * If a function runs into an error (and the program is not aborted)
 * the error handler should deallocate all temporary memory. This is
 * done by storing the address and the destroy function of all temporary
 * objects in a stack. The \ref IGRAPH_FINALLY function declares an object as
 * temporary by placing its address in the stack. If an \a igraph function returns
 * with success it calls \ref IGRAPH_FINALLY_CLEAN() with the
 * number of objects to remove from the stack. If an error happens
 * however, the error handler should call \ref IGRAPH_FINALLY_FREE() to
 * deallocate each object added to the stack. This means that the
 * temporary objects allocated in the calling function (and etc.) will
 * be freed as well.
 * 
 */

/**
 * \section writing_functions_error_handling Writing \a igraph functions with
 * proper error handling
 *
 * 
 * There are some simple rules to keep in order to have functions
 * behaving well in erroneous situations. First, check the arguments
 * of the functions and call \ref IGRAPH_ERROR() if they are invalid. Second,
 * call \ref IGRAPH_FINALLY on each dynamically allocated object and call
 * \ref IGRAPH_FINALLY_CLEAN() with the proper argument before returning. Third, use
 * \ref IGRAPH_CHECK on all \a igraph function calls which can generate errors.
 * 
 * 
 * The size of the stack used for this bookkeeping is fixed, and
 * small. If you want to allocate several objects, write a destroy
 * function which can deallocate all of these. See the
 * adjlist.c file in the
 * \a igraph source for an example.
 * 
 * 
 * For some functions these mechanisms are simply not flexible
 * enough. These functions should define their own error handlers and
 * restore the error handler before they return.
 * 
 */

/**
 * \section error_handling_threads Error handling and threads
 *
 * 
 * It is likely that the \a igraph error handling
 * method is \em not thread-safe, mainly because of
 * the static global stack which is used to store the address of the
 * temporarily allocated objects. This issue might be addressed in a
 * later version of \a igraph.
 * 
 */

/**
 * \typedef igraph_error_handler_t
 * \brief The type of error handler functions.
 *
 * This is the type of the error handler functions.
 * \param reason Textual description of the error.
 * \param file The source file in which the error is noticed.
 * \param line The number of the line in the source file which triggered
 *   the error
 * \param igraph_errno The \a igraph error code.
 */

typedef void igraph_error_handler_t (const char *reason, const char *file,
                                     int line, int igraph_errno);

/**
 * \var igraph_error_handler_abort
 * \brief Abort program in case of error.
 *
 * The default error handler, prints an error message and aborts the
 * program.
 */

IGRAPH_EXPORT igraph_error_handler_t igraph_error_handler_abort;

/**
 * \var igraph_error_handler_ignore
 * \brief Ignore errors.
 *
 * This error handler frees the temporarily allocated memory and returns
 * with the error code.
 */

IGRAPH_EXPORT igraph_error_handler_t igraph_error_handler_ignore;

/**
 * \var igraph_error_handler_printignore
 * \brief Print and ignore errors.
 *
 * Frees temporarily allocated memory, prints an error message to the
 * standard error and returns with the error code.
 */

IGRAPH_EXPORT igraph_error_handler_t igraph_error_handler_printignore;

/**
 * \function igraph_set_error_handler
 * \brief Sets a new error handler.
 *
 * Installs a new error handler. If called with 0, it installs the
 * default error handler (which is currently
 * \ref igraph_error_handler_abort).
 * \param new_handler The error handler function to install.
 * \return The old error handler function. This should be saved and
 *   restored if \p new_handler is not needed any
 *   more.
 */

IGRAPH_EXPORT igraph_error_handler_t* igraph_set_error_handler(igraph_error_handler_t* new_handler);

/**
 * \typedef igraph_error_type_t
 * \brief Error code type.
 * These are the possible values returned by \a igraph functions.
 * Note that these are interesting only if you defined an error handler
 * with \ref igraph_set_error_handler(). Otherwise the program is aborted
 * and the function causing the error never returns.
 *
 * \enumval IGRAPH_SUCCESS The function successfully completed its task.
 * \enumval IGRAPH_FAILURE Something went wrong. You'll almost never
 *    meet this error as normally more specific error codes are used.
 * \enumval IGRAPH_ENOMEM There wasn't enough memory to allocate
 *    on the heap.
 * \enumval IGRAPH_PARSEERROR A parse error was found in a file.
 * \enumval IGRAPH_EINVAL A parameter's value is invalid. E.g. negative
 *    number was specified as the number of vertices.
 * \enumval IGRAPH_EXISTS A graph/vertex/edge attribute is already
 *    installed with the given name.
 * \enumval IGRAPH_EINVEVECTOR Invalid vector of vertex ids. A vertex id
 *    is either negative or bigger than the number of vertices minus one.
 * \enumval IGRAPH_EINVVID Invalid vertex id, negative or too big.
 * \enumval IGRAPH_NONSQUARE A non-square matrix was received while a
 *    square matrix was expected.
 * \enumval IGRAPH_EINVMODE Invalid mode parameter.
 * \enumval IGRAPH_EFILE A file operation failed. E.g. a file doesn't exist,
 *   or the user has no rights to open it.
 * \enumval IGRAPH_UNIMPLEMENTED Attempted to call an unimplemented or
 *   disabled (at compile-time) function.
 * \enumval IGRAPH_DIVERGED A numeric algorithm failed to converge.
 * \enumval IGRAPH_ARPACK_PROD Matrix-vector product failed.
 * \enumval IGRAPH_ARPACK_NPOS N must be positive.
 * \enumval IGRAPH_ARPACK_NEVNPOS NEV must be positive.
 * \enumval IGRAPH_ARPACK_NCVSMALL NCV must be bigger.
 * \enumval IGRAPH_ARPACK_NONPOSI Maximum number of iterations should be positive.
 * \enumval IGRAPH_ARPACK_WHICHINV Invalid WHICH parameter.
 * \enumval IGRAPH_ARPACK_BMATINV Invalid BMAT parameter.
 * \enumval IGRAPH_ARPACK_WORKLSMALL WORKL is too small.
 * \enumval IGRAPH_ARPACK_TRIDERR LAPACK error in tridiagonal eigenvalue calculation.
 * \enumval IGRAPH_ARPACK_ZEROSTART Starting vector is zero.
 * \enumval IGRAPH_ARPACK_MODEINV MODE is invalid.
 * \enumval IGRAPH_ARPACK_MODEBMAT MODE and BMAT are not compatible.
 * \enumval IGRAPH_ARPACK_ISHIFT ISHIFT must be 0 or 1.
 * \enumval IGRAPH_ARPACK_NEVBE NEV and WHICH='BE' are incompatible.
 * \enumval IGRAPH_ARPACK_NOFACT Could not build an Arnoldi factorization.
 * \enumval IGRAPH_ARPACK_FAILED No eigenvalues to sufficient accuracy.
 * \enumval IGRAPH_ARPACK_HOWMNY HOWMNY is invalid.
 * \enumval IGRAPH_ARPACK_HOWMNYS HOWMNY='S' is not implemented.
 * \enumval IGRAPH_ARPACK_EVDIFF Different number of converged Ritz values.
 * \enumval IGRAPH_ARPACK_SHUR Error from calculation of a real Schur form.
 * \enumval IGRAPH_ARPACK_LAPACK LAPACK (dtrevc) error for calculating eigenvectors.
 * \enumval IGRAPH_ARPACK_UNKNOWN Unknown ARPACK error.
 * \enumval IGRAPH_ENEGLOOP Negative loop detected while calculating shortest paths.
 * \enumval IGRAPH_EINTERNAL Internal error, likely a bug in igraph.
 * \enumval IGRAPH_EDIVZERO Big integer division by zero.
 * \enumval IGRAPH_GLP_EBOUND GLPK error (GLP_EBOUND).
 * \enumval IGRAPH_GLP_EROOT GLPK error (GLP_EROOT).
 * \enumval IGRAPH_GLP_ENOPFS GLPK error (GLP_ENOPFS).
 * \enumval IGRAPH_GLP_ENODFS GLPK error (GLP_ENODFS).
 * \enumval IGRAPH_GLP_EFAIL GLPK error (GLP_EFAIL).
 * \enumval IGRAPH_GLP_EMIPGAP GLPK error (GLP_EMIPGAP).
 * \enumval IGRAPH_GLP_ETMLIM GLPK error (GLP_ETMLIM).
 * \enumval IGRAPH_GLP_ESTOP GLPK error (GLP_ESTOP).
 * \enumval IGRAPH_EATTRIBUTES Attribute handler error. The user is not
 *   expected to find this; it is signalled if some igraph function is
 *   not using the attribute handler interface properly.
 * \enumval IGRAPH_EATTRCOMBINE Unimplemented attribute combination
 *   method for the given attribute type.
 * \enumval IGRAPH_ELAPACK A LAPACK call resulted in an error.
 * \enumval IGRAPH_EDRL Internal error in the DrL layout generator.
 * \enumval IGRAPH_EOVERFLOW Integer or double overflow.
 * \enumval IGRAPH_EGLP Internal GLPK error.
 * \enumval IGRAPH_CPUTIME CPU time exceeded.
 * \enumval IGRAPH_EUNDERFLOW Integer or double underflow.
 * \enumval IGRAPH_ERWSTUCK Random walk got stuck.
 */

typedef enum {
    IGRAPH_SUCCESS           = 0,
    IGRAPH_FAILURE           = 1,
    IGRAPH_ENOMEM            = 2,
    IGRAPH_PARSEERROR        = 3,
    IGRAPH_EINVAL            = 4,
    IGRAPH_EXISTS            = 5,
    IGRAPH_EINVEVECTOR       = 6,
    IGRAPH_EINVVID           = 7,
    IGRAPH_NONSQUARE         = 8,
    IGRAPH_EINVMODE          = 9,
    IGRAPH_EFILE             = 10,
    IGRAPH_UNIMPLEMENTED     = 12,
    IGRAPH_INTERRUPTED       = 13,
    IGRAPH_DIVERGED          = 14,
    IGRAPH_ARPACK_PROD       = 15,
    IGRAPH_ARPACK_NPOS       = 16,
    IGRAPH_ARPACK_NEVNPOS    = 17,
    IGRAPH_ARPACK_NCVSMALL   = 18,
    IGRAPH_ARPACK_NONPOSI    = 19,
    IGRAPH_ARPACK_WHICHINV   = 20,
    IGRAPH_ARPACK_BMATINV    = 21,
    IGRAPH_ARPACK_WORKLSMALL = 22,
    IGRAPH_ARPACK_TRIDERR    = 23,
    IGRAPH_ARPACK_ZEROSTART  = 24,
    IGRAPH_ARPACK_MODEINV    = 25,
    IGRAPH_ARPACK_MODEBMAT   = 26,
    IGRAPH_ARPACK_ISHIFT     = 27,
    IGRAPH_ARPACK_NEVBE      = 28,
    IGRAPH_ARPACK_NOFACT     = 29,
    IGRAPH_ARPACK_FAILED     = 30,
    IGRAPH_ARPACK_HOWMNY     = 31,
    IGRAPH_ARPACK_HOWMNYS    = 32,
    IGRAPH_ARPACK_EVDIFF     = 33,
    IGRAPH_ARPACK_SHUR       = 34,
    IGRAPH_ARPACK_LAPACK     = 35,
    IGRAPH_ARPACK_UNKNOWN    = 36,
    IGRAPH_ENEGLOOP          = 37,
    IGRAPH_EINTERNAL         = 38,
    IGRAPH_ARPACK_MAXIT      = 39,
    IGRAPH_ARPACK_NOSHIFT    = 40,
    IGRAPH_ARPACK_REORDER    = 41,
    IGRAPH_EDIVZERO          = 42,
    IGRAPH_GLP_EBOUND        = 43,
    IGRAPH_GLP_EROOT         = 44,
    IGRAPH_GLP_ENOPFS        = 45,
    IGRAPH_GLP_ENODFS        = 46,
    IGRAPH_GLP_EFAIL         = 47,
    IGRAPH_GLP_EMIPGAP       = 48,
    IGRAPH_GLP_ETMLIM        = 49,
    IGRAPH_GLP_ESTOP         = 50,
    IGRAPH_EATTRIBUTES       = 51,
    IGRAPH_EATTRCOMBINE      = 52,
    IGRAPH_ELAPACK           = 53,
    IGRAPH_EDRL              = 54,
    IGRAPH_EOVERFLOW         = 55,
    IGRAPH_EGLP              = 56,
    IGRAPH_CPUTIME           = 57,
    IGRAPH_EUNDERFLOW        = 58,
    IGRAPH_ERWSTUCK          = 59,
    IGRAPH_STOP              = 60  /* undocumented, used internally */
} igraph_error_type_t;
/* Each enum value above must have a corresponding error string in
 * igraph_i_error_strings[] in igraph_error.c
 *
 * Information on undocumented codes:
 *  - IGRAPH_STOP signals a request to stop in functions like igraph_i_maximal_cliques_bk()
 */

/* We use IGRAPH_FILE_BASENAME instead of __FILE__ to ensure that full
 * paths don't leak into the library code. IGRAPH_FILE_BASENAME is set up
 * by the build system when compiling the individual files. However, when
 * including igraph_error.h in user code, this macro is not defined so we
 * fall back to __FILE__ here
 */
#ifndef IGRAPH_FILE_BASENAME
#  define IGRAPH_FILE_BASENAME __FILE__
#endif

/**
 * \define IGRAPH_ERROR
 * \brief Trigger an error.
 *
 * \a igraph functions usually use this macro when they notice an error.
 * It calls
 * \ref igraph_error() with the proper parameters and if that returns
 * the macro returns the "calling" function as well, with the error
 * code. If for some (suspicious) reason you want to call the error
 * handler without returning from the current function, call
 * \ref igraph_error() directly.
 * \param reason Textual description of the error. This should be
 *   something more descriptive than the text associated with the error
 *   code. E.g. if the error code is \c IGRAPH_EINVAL,
 *   its associated text (see  \ref igraph_strerror()) is "Invalid
 *   value" and this string should explain which parameter was invalid
 *   and maybe why.
 * \param igraph_errno The \a igraph error code.
 */

#define IGRAPH_ERROR(reason, igraph_errno) \
    do { \
        igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
        return igraph_errno ; \
    } while (0)

#define IGRAPH_ERROR_NO_RETURN(reason, igraph_errno) \
    do { \
        igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \
    } while (0)

/**
 * \function igraph_error
 * \brief Triggers an error.
 *
 * \a igraph functions usually call this function (most often via the
 * \ref IGRAPH_ERROR macro) if they notice an error.
 * It calls the currently installed error handler function with the
 * supplied arguments.
 *
 * \param reason Textual description of the error.
 * \param file The source file in which the error was noticed.
 * \param line The number of line in the source file which triggered the
 *   error.
 * \param igraph_errno The \a igraph error code.
 * \return the error code (if it returns)
 *
 * \sa igraph_errorf().
 */

IGRAPH_EXPORT int igraph_error(const char *reason, const char *file, int line,
                               int igraph_errno);

/**
 * \define IGRAPH_ERRORF
 * \brief Triggers an error, with printf-like syntax.
 *
 * \a igraph functions can use this macro when they notice an error and
 * want to pass on extra information to the user about what went wrong.
 * It calls \ref igraph_errorf() with the proper parameters and if that
 * returns the macro returns the "calling" function as well, with the
 * error code. If for some (suspicious) reason you want to call the
 * error handler without returning from the current function, call
 * \ref igraph_errorf() directly.
 * \param reason Textual description of the error, a template string
 *   with the same syntax as the standard printf C library function.
 *   This should be something more descriptive than the text associated
 *   with the error code. E.g. if the error code is \c IGRAPH_EINVAL,
 *   its associated text (see  \ref igraph_strerror()) is "Invalid
 *   value" and this string should explain which parameter was invalid
 *   and maybe what was expected and what was recieved.
 * \param igraph_errno The \a igraph error code.
 * \param ... The additional arguments to be substituted into the
 *   template string.
 */

#define IGRAPH_ERRORF(reason, igraph_errno, ...) \
    do { \
        igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
                      igraph_errno, __VA_ARGS__) ; \
        return igraph_errno; \
    } while (0)

/**
 * \function igraph_errorf
 * \brief Triggers an error, printf-like version.
 *
 * \param reason Textual description of the error, interpreted as
 *               a \c printf format string.
 * \param file The source file in which the error was noticed.
 * \param line The line in the source file which triggered the error.
 * \param igraph_errno The \a igraph error code.
 * \param ... Additional parameters, the values to substitute into the
 *            format string.
 *
 * \sa igraph_error().
 */

IGRAPH_EXPORT int igraph_errorf(const char *reason, const char *file, int line,
                                int igraph_errno, ...);

IGRAPH_EXPORT int igraph_errorvf(const char *reason, const char *file, int line,
                                 int igraph_errno, va_list ap);

/**
 * \function igraph_strerror
 * \brief Textual description of an error.
 *
 * This is a simple utility function, it gives a short general textual
 * description for an \a igraph error code.
 *
 * \param igraph_errno The \a igraph error code.
 * \return pointer to the textual description of the error code.
 */

IGRAPH_EXPORT const char* igraph_strerror(const int igraph_errno);

#define IGRAPH_ERROR_SELECT_2(a,b)       ((a) != IGRAPH_SUCCESS ? (a) : ((b) != IGRAPH_SUCCESS ? (b) : IGRAPH_SUCCESS))
#define IGRAPH_ERROR_SELECT_3(a,b,c)     ((a) != IGRAPH_SUCCESS ? (a) : IGRAPH_ERROR_SELECT_2(b,c))
#define IGRAPH_ERROR_SELECT_4(a,b,c,d)   ((a) != IGRAPH_SUCCESS ? (a) : IGRAPH_ERROR_SELECT_3(b,c,d))
#define IGRAPH_ERROR_SELECT_5(a,b,c,d,e) ((a) != IGRAPH_SUCCESS ? (a) : IGRAPH_ERROR_SELECT_4(b,c,d,e))

/* Now comes the more convenient error handling macro arsenal.
 * Ideas taken from exception.{h,c} by Laurent Deniau see
 * http://cern.ch/Laurent.Deniau/html/oopc/oopc.html#Exceptions for more
 * information. We don't use the exception handling code though.  */

struct igraph_i_protectedPtr {
    int all;
    void *ptr;
    void (*func)(void*);
};

typedef void igraph_finally_func_t (void*);

IGRAPH_EXPORT void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr);

/**
 * \function IGRAPH_FINALLY_CLEAN
 * \brief Signals clean deallocation of objects.
 *
 * Removes the specified number of objects from the stack of
 * temporarily allocated objects. Most often this is called just
 * before returning from a function.
 * \param num The number of objects to remove from the bookkeeping
 *   stack.
 */

IGRAPH_EXPORT void IGRAPH_FINALLY_CLEAN(int num);

/**
 * \function IGRAPH_FINALLY_FREE
 * \brief Deallocates all registered objects.
 *
 * Calls the destroy function for all objects in the stack of
 * temporarily allocated objects. This is usually called only from an
 * error handler. It is \em not appropriate to use it
 * instead of destroying each unneeded object of a function, as it
 * destroys the temporary objects of the caller function (and so on)
 * as well.
 */

IGRAPH_EXPORT void IGRAPH_FINALLY_FREE(void);

/**
 * \function IGRAPH_FINALLY_STACK_SIZE
 * \brief The number of registered objects.
 *
 * Returns the number of objects in the stack of temporarily allocated
 * objects. This function is handy if you write an own igraph routine and
 * you want to make sure it handles errors properly. A properly written
 * igraph routine should not leave pointers to temporarily allocated objects
 * in the finally stack, because otherwise an \ref IGRAPH_FINALLY_FREE call
 * in another igraph function would result in freeing these objects as well
 * (and this is really hard to debug, since the error will be not in that
 * function that shows erroneous behaviour). Therefore, it is advised to
 * write your own test cases and examine \ref IGRAPH_FINALLY_STACK_SIZE
 * before and after your test cases - the numbers should be equal.
 */
IGRAPH_EXPORT int IGRAPH_FINALLY_STACK_SIZE(void);

/**
 * \define IGRAPH_FINALLY_STACK_EMPTY
 * \brief Returns true if there are no registered objects, false otherwise.
 *
 * This is just a shorthand notation for checking that
 * \ref IGRAPH_FINALLY_STACK_SIZE() is zero.
 */
#define IGRAPH_FINALLY_STACK_EMPTY (IGRAPH_FINALLY_STACK_SIZE() == 0)

/**
 * \define IGRAPH_FINALLY
 * \brief Registers an object for deallocation.
 * \param func The address of the function which is normally called to
 *   destroy the object.
 * \param ptr Pointer to the object itself.
 *
 * This macro places the address of an object, together with the
 * address of its destructor in a stack. This stack is used if an
 * error happens to deallocate temporarily allocated objects to
 * prevent memory leaks.
 */

#define IGRAPH_FINALLY(func, ptr) \
    do { \
        /* the following branch makes the compiler check the compatibility of \
         * func and ptr to detect cases when we are accidentally invoking an \
         * incorrect destructor function with the pointer */ \
        if (0) { func(ptr); } \
        IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \
    } while (0)

#if !defined(GCC_VERSION_MAJOR) && defined(__GNUC__)
    #define GCC_VERSION_MAJOR  __GNUC__
#endif

#if defined(GCC_VERSION_MAJOR) && (GCC_VERSION_MAJOR >= 3)
    #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0)
    #define IGRAPH_LIKELY(a)   __builtin_expect((a), 1)
#else
    #define IGRAPH_UNLIKELY(a) a
    #define IGRAPH_LIKELY(a)   a
#endif

#if IGRAPH_VERIFY_FINALLY_STACK == 1
#define IGRAPH_CHECK(a) \
        do { \
            int enter_stack_size = IGRAPH_FINALLY_STACK_SIZE(); \
            int igraph_i_ret=(a); \
            if (IGRAPH_UNLIKELY(igraph_i_ret != 0)) {\
                IGRAPH_ERROR("", igraph_i_ret); \
            } \
            if (IGRAPH_UNLIKELY(enter_stack_size != IGRAPH_FINALLY_STACK_SIZE())) { \
                IGRAPH_ERROR("Non-matching number of IGRAPH_FINALLY and IGRAPH_FINALLY_CLEAN", IGRAPH_FAILURE); \
            } \
        } while (0)
#else
/**
 * \define IGRAPH_CHECK
 * \brief Checks the return value of a function call.
 *
 * \param a An expression, usually a function call.
 *
 * Executes the expression and checks its value. If this is not
 * \c IGRAPH_SUCCESS, it calls \ref IGRAPH_ERROR with
 * the value as the error code. Here is an example usage:
 * \verbatim IGRAPH_CHECK(vector_push_back(&v, 100)); \endverbatim
 *
 * There is only one reason to use this macro when writing
 * \a igraph functions. If the user installs an error handler which
 * returns to the auxiliary calling code (like \ref
 * igraph_error_handler_ignore and \ref
 * igraph_error_handler_printignore), and the \a igraph function
 * signalling the error is called from another \a igraph function
 * then we need to make sure that the error is propagated back to
 * the auxiliary (i.e. non-igraph) calling function. This is achieved
 * by using IGRAPH_CHECK on every \a igraph
 * call which can return an error code.
 */
#define IGRAPH_CHECK(a) do { \
        int igraph_i_ret=(a); \
        if (IGRAPH_UNLIKELY(igraph_i_ret != 0)) {\
            IGRAPH_ERROR("", igraph_i_ret); \
        } } while (0)
#endif



/**
 * \section about_igraph_warnings Warning messages
 *
 * 
 * \a igraph also supports warning messages in addition to error
 * messages. Warning messages typically do not terminate the
 * program, but they are usually crucial to the user.
 * 
 *
 * 
 * \a igraph warnings are handled similarly to errors. There is a
 * separate warning handler function that is called whenever
 * an \a igraph function triggers a warning. This handler can be
 * set by the \ref igraph_set_warning_handler() function. There are
 * two predefined simple warning handlers,
 * \ref igraph_warning_handler_ignore() and
 * \ref igraph_warning_handler_print(), the latter being the default.
 * 
 *
 * 
 * To trigger a warning, \a igraph functions typically use the
 * \ref IGRAPH_WARNING() macro, the \ref igraph_warning() function,
 * or if more flexibility is needed, \ref igraph_warningf().
 * 
 */

/**
 * \typedef igraph_warning_handler_t
 * \brief The type of igraph warning handler functions.
 *
 * Currently it is defined to have the same type as
 * \ref igraph_error_handler_t, although the last (error code)
 * argument is not used.
 */

typedef igraph_error_handler_t igraph_warning_handler_t;

/**
 * \function igraph_set_warning_handler
 * \brief Installs a warning handler.
 *
 * Install the supplied warning handler function.
 * \param new_handler The new warning handler function to install.
 *        Supply a null pointer here to uninstall the current
 *        warning handler, without installing a new one.
 * \return The current warning handler function.
 */

IGRAPH_EXPORT igraph_warning_handler_t* igraph_set_warning_handler(igraph_warning_handler_t* new_handler);

IGRAPH_EXPORT extern igraph_warning_handler_t igraph_warning_handler_ignore;
IGRAPH_EXPORT extern igraph_warning_handler_t igraph_warning_handler_print;

/**
 * \function igraph_warning
 * \brief Triggers a warning.
 *
 * Call this function if you want to trigger a warning from within
 * a function that uses \a igraph.
 * \param reason Textual description of the warning.
 * \param file The source file in which the warning was noticed.
 * \param line The number of line in the source file which triggered the
 *         warning.
 * \param igraph_errno Warnings could have potentially error codes as well,
 *        but this is currently not used in igraph.
 * \return The supplied error code.
 */

IGRAPH_EXPORT int igraph_warning(const char *reason, const char *file, int line,
                                 int igraph_errno);

/**
 * \define IGRAPH_WARNINGF
 * \brief Triggers a warning, with printf-like syntax.
 *
 * \a igraph functions can use this macro when they notice a warning and
 * want to pass on extra information to the user about what went wrong.
 * It calls \ref igraph_warningf() with the proper parameters and no
 * error code.
 * \param reason Textual description of the warning, a template string
 *        with the same syntax as the standard printf C library function.
 * \param ... The additional arguments to be substituted into the
 *        template string.
 */

#define IGRAPH_WARNINGF(reason, ...) \
    do { \
        igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
                        -1, __VA_ARGS__); \
    } while (0)



/**
 * \function igraph_warningf
 * \brief Triggers a warning, printf-like version.
 *
 * This function is similar to \ref igraph_warning(), but
 * uses a printf-like syntax. It substitutes the additional arguments
 * into the \p reason template string and calls \ref igraph_warning().
 * \param reason Textual description of the warning, a template string
 *        with the same syntax as the standard printf C library function.
 * \param file The source file in which the warning was noticed.
 * \param line The number of line in the source file which triggered the
 *         warning.
 * \param igraph_errno Warnings could have potentially error codes as well,
 *        but this is currently not used in igraph.
 * \param ... The additional arguments to be substituted into the
 *        template string.
 * \return The supplied error code.
 */

IGRAPH_EXPORT int igraph_warningf(const char *reason, const char *file, int line,
                                  int igraph_errno, ...);

/**
 * \define IGRAPH_WARNING
 * \brief Triggers a warning.
 *
 * This is the usual way of triggering a warning from an igraph
 * function. It calls \ref igraph_warning().
 * \param reason The warning message.
 */

#define IGRAPH_WARNING(reason) \
    do { \
        igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__, -1); \
    } while (0)


/**
 * \section fatal_error_handlers Fatal errors
 *
 * 
 * In some rare situations, \a igraph may encounter an internal error
 * that cannot be fully handled. In this case, it will call the
 * current fatal error handler. The default fatal error handler
 * simply prints the error and aborts the program.
 * 
 *
 * 
 * Fatal error handlers do not return. Typically, they might abort the
 * the program immediately, or in the case of the high-level \a igraph
 * interfaces, they might return to the top level using a
 * longjmp(). The fatal error handler is only called when
 * a serious error has occurred, and as a result igraph may be in an
 * inconsistent state. The purpose of returning to the top level is to
 * give the user a chance to save their work instead of aborting immediately.
 * However, the program session should be restarted as soon as possible.
 * 
 *
 * 
 * Most projects that use \a igraph will use the default fatal error
 * handler.
 * 
 */

/**
 * \typedef igraph_fatal_handler_t
 * \brief The type of igraph fatal error handler functions.
 *
 * Functions of this type \em must not return. Typically they
 * call abort() or do a longjmp().
 *
 * \param reason Textual description of the error.
 * \param file The source file in which the error is noticed.
 * \param line The number of the line in the source file which triggered the error
 */

typedef void igraph_fatal_handler_t (const char *reason, const char *file, int line);

/**
 * \function igraph_set_fatal_handler
 * \brief Installs a fatal error handler.
 *
 * Installs the supplied fatal error handler function.
 *
 * 
 * Fatal error handler functions \em must not return. Typically, the fatal
 * error handler would either call abort() or longjmp().
 *
 * \param new_handler The new fatal error handler function to install.
 *        Supply a null pointer here to uninstall the current
 *        fatal error handler, without installing a new one.
 * \return The current fatal error handler function.
 */

IGRAPH_EXPORT igraph_fatal_handler_t* igraph_set_fatal_handler(igraph_fatal_handler_t* new_handler);

/**
 * \var igraph_fatal_handler_abort
 * \brief Abort program in case of fatal error.
 *
 * The default fatal error handler, prints an error message and aborts the program.
 */

IGRAPH_EXPORT igraph_fatal_handler_t igraph_fatal_handler_abort;

/**
 * \function igraph_fatal
 * \brief Triggers a fatal error.
 *
 * This function triggers a fatal error. Typically it is called indirectly through
 * \ref IGRAPH_FATAL() or \ref IGRAPH_ASSERT().
 *
 * \param reason Textual description of the error.
 * \param file The source file in which the error was noticed.
 * \param line The number of line in the source file which triggered the error.
 */

IGRAPH_EXPORT IGRAPH_NORETURN void igraph_fatal(const char *reason, const char *file, int line);

/**
 * \function igraph_fatalf
 * \brief Triggers a fatal error, printf-like syntax.
 *
 * This function is similar to \ref igraph_fatal(), but
 * uses a printf-like syntax. It substitutes the additional arguments
 * into the \p reason template string and calls \ref igraph_fatal().
 *
 * \param reason Textual description of the error.
 * \param file The source file in which the error was noticed.
 * \param line The number of line in the source file which triggered the error.
 * \param ... The additional arguments to be substituted into the template string.
 */

IGRAPH_EXPORT IGRAPH_NORETURN void igraph_fatalf(const char *reason, const char *file, int line, ...);

/**
 * \define IGRAPH_FATALF
 * \brief Triggers a fatal error, with printf-like syntax.
 *
 * \a igraph functions can use this macro when a fatal error occurs and
 * want to pass on extra information to the user about what went wrong.
 * It calls \ref igraph_fatalf() with the proper parameters.
 * \param reason Textual description of the error, a template string
 *        with the same syntax as the standard printf C library function.
 * \param ... The additional arguments to be substituted into the
 *        template string.
 */

#define IGRAPH_FATALF(reason, ...) \
    do { \
        igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \
                      __VA_ARGS__); \
    } while (0)

/**
 * \define IGRAPH_FATAL
 * \brief Triggers a fatal error.
 *
 * This is the usual way of triggering a fatal error from an igraph
 * function. It calls \ref igraph_fatal().
 *
 * 
 * Use this macro only in situations where the error cannot be handled.
 * The normal way to handle errors is \ref IGRAPH_ERROR().
 *
 * \param reason The error message.
 */

#define IGRAPH_FATAL(reason) \
    do { \
        igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \
    } while (0)

/**
 * \define IGRAPH_ASSERT
 * \brief igraph-specific replacement for assert().
 *
 * This macro is like the standard assert(), but instead of
 * calling abort(), it calls \ref igraph_fatal(). This allows for returning
 * the control to the calling program, e.g. returning to the top level in a high-level
 * \a igraph interface.
 *
 * 
 * Unlike assert(), IGRAPH_ASSERT() is not disabled
 * when the \c NDEBUG macro is defined.
 *
 * 
 * This macro is meant for internal use by \a igraph.
 *
 * 
 * Since a typial fatal error handler does a longjmp(), avoid using this
 * macro in C++ code. With most compilers, destructor will not be called when
 * longjmp() leaves the current scope.
 *
 * \param condition The condition to be checked.
 */

#define IGRAPH_ASSERT(condition) \
    do { \
        if (!(condition)) { \
            igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \
        } \
    } while (0)

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_eulerian.h0000644000175100001710000000254000000000000024605 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_EULERIAN_H
#define IGRAPH_EULERIAN_H

#include "igraph_decls.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_is_eulerian(const igraph_t *graph, igraph_bool_t *has_path, igraph_bool_t *has_cycle);
IGRAPH_EXPORT int igraph_eulerian_path(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res);
IGRAPH_EXPORT int igraph_eulerian_cycle(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_flow.h0000644000175100001710000001731000000000000023751 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_FLOW_H
#define IGRAPH_FLOW_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Maximum flows, minimum cuts & such                 */
/* -------------------------------------------------- */

/**
 * \typedef igraph_maxflow_stats_t
 * A simple data type to return some statistics from the
 * push-relabel maximum flow solver.
 *
 * \param nopush The number of push operations performed.
 * \param norelabel The number of relabel operarions performed.
 * \param nogap The number of times the gap heuristics was used.
 * \param nogapnodes The total number of vertices that were
 *        omitted form further calculations because of the gap
 *        heuristics.
 * \param nobfs The number of times the reverse BFS was run to
 *        assign good values to the height function. This includes
 *        an initial run before the whole algorithm, so it is always
 *        at least one.
 */

typedef struct {
    int nopush, norelabel, nogap, nogapnodes, nobfs;
} igraph_maxflow_stats_t;

IGRAPH_EXPORT int igraph_maxflow(const igraph_t *graph, igraph_real_t *value,
                                 igraph_vector_t *flow, igraph_vector_t *cut,
                                 igraph_vector_t *partition, igraph_vector_t *partition2,
                                 igraph_integer_t source, igraph_integer_t target,
                                 const igraph_vector_t *capacity,
                                 igraph_maxflow_stats_t *stats);
IGRAPH_EXPORT int igraph_maxflow_value(const igraph_t *graph, igraph_real_t *value,
                                       igraph_integer_t source, igraph_integer_t target,
                                       const igraph_vector_t *capacity,
                                       igraph_maxflow_stats_t *stats);

IGRAPH_EXPORT int igraph_st_mincut(const igraph_t *graph, igraph_real_t *value,
                                   igraph_vector_t *cut, igraph_vector_t *partition,
                                   igraph_vector_t *partition2,
                                   igraph_integer_t source, igraph_integer_t target,
                                   const igraph_vector_t *capacity);
IGRAPH_EXPORT int igraph_st_mincut_value(const igraph_t *graph, igraph_real_t *res,
                                         igraph_integer_t source, igraph_integer_t target,
                                         const igraph_vector_t *capacity);

IGRAPH_EXPORT int igraph_mincut_value(const igraph_t *graph, igraph_real_t *res,
                                      const igraph_vector_t *capacity);
IGRAPH_EXPORT int igraph_mincut(const igraph_t *graph,
                                igraph_real_t *value,
                                igraph_vector_t *partition,
                                igraph_vector_t *partition2,
                                igraph_vector_t *cut,
                                const igraph_vector_t *capacity);

IGRAPH_EXPORT int igraph_st_vertex_connectivity(const igraph_t *graph,
                                                igraph_integer_t *res,
                                                igraph_integer_t source,
                                                igraph_integer_t target,
                                                igraph_vconn_nei_t neighbors);
IGRAPH_EXPORT int igraph_vertex_connectivity(const igraph_t *graph, igraph_integer_t *res,
                                             igraph_bool_t checks);

IGRAPH_EXPORT int igraph_st_edge_connectivity(const igraph_t *graph, igraph_integer_t *res,
                                              igraph_integer_t source,
                                              igraph_integer_t target);
IGRAPH_EXPORT int igraph_edge_connectivity(const igraph_t *graph, igraph_integer_t *res,
                                           igraph_bool_t checks);

IGRAPH_EXPORT int igraph_edge_disjoint_paths(const igraph_t *graph, igraph_integer_t *res,
                                             igraph_integer_t source,
                                             igraph_integer_t target);
IGRAPH_EXPORT int igraph_vertex_disjoint_paths(const igraph_t *graph, igraph_integer_t *res,
                                               igraph_integer_t source,
                                               igraph_integer_t target);

IGRAPH_EXPORT int igraph_adhesion(const igraph_t *graph, igraph_integer_t *res,
                                  igraph_bool_t checks);
IGRAPH_EXPORT int igraph_cohesion(const igraph_t *graph, igraph_integer_t *res,
                                  igraph_bool_t checks);

/* s-t cut listing related stuff */

IGRAPH_EXPORT int igraph_even_tarjan_reduction(const igraph_t *graph, igraph_t *graphbar,
                                               igraph_vector_t *capacity);

IGRAPH_EXPORT int igraph_residual_graph(const igraph_t *graph,
                                        const igraph_vector_t *capacity,
                                        igraph_t *residual,
                                        igraph_vector_t *residual_capacity,
                                        const igraph_vector_t *flow);

IGRAPH_EXPORT int igraph_reverse_residual_graph(const igraph_t *graph,
                                                const igraph_vector_t *capacity,
                                                igraph_t *residual,
                                                const igraph_vector_t *flow);

IGRAPH_EXPORT int igraph_dominator_tree(const igraph_t *graph,
                                        igraph_integer_t root,
                                        igraph_vector_t *dom,
                                        igraph_t *domtree,
                                        igraph_vector_t *leftout,
                                        igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_all_st_cuts(const igraph_t *graph,
                                     igraph_vector_ptr_t *cuts,
                                     igraph_vector_ptr_t *partition1s,
                                     igraph_integer_t source,
                                     igraph_integer_t target);

IGRAPH_EXPORT int igraph_all_st_mincuts(const igraph_t *graph, igraph_real_t *value,
                                        igraph_vector_ptr_t *cuts,
                                        igraph_vector_ptr_t *partition1s,
                                        igraph_integer_t source,
                                        igraph_integer_t target,
                                        const igraph_vector_t *capacity);

IGRAPH_EXPORT int igraph_gomory_hu_tree(const igraph_t *graph,
                                        igraph_t *tree,
                                        igraph_vector_t *flows,
                                        const igraph_vector_t *capacity);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_foreign.h0000644000175100001710000001050700000000000024434 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_FOREIGN_H
#define IGRAPH_FOREIGN_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_strvector.h"

#include 

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Read and write foreign formats                     */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_read_graph_edgelist(igraph_t *graph, FILE *instream,
                                             igraph_integer_t n, igraph_bool_t directed);
IGRAPH_EXPORT int igraph_read_graph_ncol(igraph_t *graph, FILE *instream,
                                         const igraph_strvector_t *predefnames, igraph_bool_t names,
                                         igraph_add_weights_t weights, igraph_bool_t directed);
IGRAPH_EXPORT int igraph_read_graph_lgl(igraph_t *graph, FILE *instream,
                                        igraph_bool_t names, igraph_add_weights_t weights,
                                        igraph_bool_t directed);
IGRAPH_EXPORT int igraph_read_graph_pajek(igraph_t *graph, FILE *instream);
IGRAPH_EXPORT int igraph_read_graph_graphml(igraph_t *graph, FILE *instream,
                                            int index);
IGRAPH_EXPORT int igraph_read_graph_dimacs(igraph_t *graph, FILE *instream,
                                           igraph_strvector_t *problem,
                                           igraph_vector_t *label,
                                           igraph_integer_t *source,
                                           igraph_integer_t *target,
                                           igraph_vector_t *capacity,
                                           igraph_bool_t directed);
IGRAPH_EXPORT int igraph_read_graph_graphdb(igraph_t *graph, FILE *instream,
                                            igraph_bool_t directed);
IGRAPH_EXPORT int igraph_read_graph_gml(igraph_t *graph, FILE *instream);
IGRAPH_EXPORT int igraph_read_graph_dl(igraph_t *graph, FILE *instream,
                                       igraph_bool_t directed);

IGRAPH_EXPORT int igraph_write_graph_edgelist(const igraph_t *graph, FILE *outstream);
IGRAPH_EXPORT int igraph_write_graph_ncol(const igraph_t *graph, FILE *outstream,
                                          const char *names, const char *weights);
IGRAPH_EXPORT int igraph_write_graph_lgl(const igraph_t *graph, FILE *outstream,
                                         const char *names, const char *weights,
                                         igraph_bool_t isolates);
IGRAPH_EXPORT int igraph_write_graph_graphml(const igraph_t *graph, FILE *outstream,
                                             igraph_bool_t prefixattr);
IGRAPH_EXPORT int igraph_write_graph_pajek(const igraph_t *graph, FILE *outstream);
IGRAPH_EXPORT int igraph_write_graph_dimacs(const igraph_t *graph, FILE *outstream,
                                            long int source, long int target,
                                            const igraph_vector_t *capacity);
IGRAPH_EXPORT int igraph_write_graph_gml(const igraph_t *graph, FILE *outstream,
                                         const igraph_vector_t *id, const char *creator);
IGRAPH_EXPORT int igraph_write_graph_dot(const igraph_t *graph, FILE *outstream);
IGRAPH_EXPORT int igraph_write_graph_leda(const igraph_t *graph, FILE *outstream,
                                          const char* vertex_attr_name, const char* edge_attr_name);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_games.h0000644000175100001710000003221700000000000024101 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_GAMES_H
#define IGRAPH_GAMES_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_matrix.h"
#include "igraph_vector.h"
#include "igraph_datatype.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Constructors, games (=stochastic)                  */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_barabasi_game(igraph_t *graph, igraph_integer_t n,
                                       igraph_real_t power,
                                       igraph_integer_t m,
                                       const igraph_vector_t *outseq,
                                       igraph_bool_t outpref,
                                       igraph_real_t A,
                                       igraph_bool_t directed,
                                       igraph_barabasi_algorithm_t algo,
                                       const igraph_t *start_from);
IGRAPH_EXPORT int igraph_erdos_renyi_game(igraph_t *graph, igraph_erdos_renyi_t type,
                                          igraph_integer_t n, igraph_real_t p_or_m,
                                          igraph_bool_t directed, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_erdos_renyi_game_gnp(igraph_t *graph, igraph_integer_t n, igraph_real_t p,
                                              igraph_bool_t directed, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_erdos_renyi_game_gnm(igraph_t *graph, igraph_integer_t n, igraph_real_t m,
                                              igraph_bool_t directed, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_degree_sequence_game(igraph_t *graph, const igraph_vector_t *out_deg,
                                              const igraph_vector_t *in_deg,
                                              igraph_degseq_t method);
IGRAPH_EXPORT int igraph_growing_random_game(igraph_t *graph, igraph_integer_t n,
                                             igraph_integer_t m, igraph_bool_t directed, igraph_bool_t citation);
IGRAPH_EXPORT int igraph_barabasi_aging_game(igraph_t *graph,
                                             igraph_integer_t nodes,
                                             igraph_integer_t m,
                                             const igraph_vector_t *outseq,
                                             igraph_bool_t outpref,
                                             igraph_real_t pa_exp,
                                             igraph_real_t aging_exp,
                                             igraph_integer_t aging_bin,
                                             igraph_real_t zero_deg_appeal,
                                             igraph_real_t zero_age_appeal,
                                             igraph_real_t deg_coef,
                                             igraph_real_t age_coef,
                                             igraph_bool_t directed);
IGRAPH_EXPORT int igraph_recent_degree_game(igraph_t *graph, igraph_integer_t n,
                                            igraph_real_t power,
                                            igraph_integer_t window,
                                            igraph_integer_t m,
                                            const igraph_vector_t *outseq,
                                            igraph_bool_t outpref,
                                            igraph_real_t zero_appeal,
                                            igraph_bool_t directed);
IGRAPH_EXPORT int igraph_recent_degree_aging_game(igraph_t *graph,
                                                  igraph_integer_t nodes,
                                                  igraph_integer_t m,
                                                  const igraph_vector_t *outseq,
                                                  igraph_bool_t outpref,
                                                  igraph_real_t pa_exp,
                                                  igraph_real_t aging_exp,
                                                  igraph_integer_t aging_bin,
                                                  igraph_integer_t window,
                                                  igraph_real_t zero_appeal,
                                                  igraph_bool_t directed);
IGRAPH_EXPORT int igraph_callaway_traits_game(igraph_t *graph, igraph_integer_t nodes,
                                              igraph_integer_t types, igraph_integer_t edges_per_step,
                                              const igraph_vector_t *type_dist,
                                              const igraph_matrix_t *pref_matrix,
                                              igraph_bool_t directed,
                                              igraph_vector_t *node_type_vec);
IGRAPH_EXPORT int igraph_establishment_game(igraph_t *graph, igraph_integer_t nodes,
                                            igraph_integer_t types, igraph_integer_t k,
                                            const igraph_vector_t *type_dist,
                                            const igraph_matrix_t *pref_matrix,
                                            igraph_bool_t directed,
                                            igraph_vector_t *node_type_vec);
IGRAPH_EXPORT int igraph_grg_game(igraph_t *graph, igraph_integer_t nodes,
                                  igraph_real_t radius, igraph_bool_t torus,
                                  igraph_vector_t *x, igraph_vector_t *y);
IGRAPH_EXPORT int igraph_preference_game(igraph_t *graph, igraph_integer_t nodes,
                                         igraph_integer_t types,
                                         const igraph_vector_t *type_dist,
                                         igraph_bool_t fixed_sizes,
                                         const igraph_matrix_t *pref_matrix,
                                         igraph_vector_t *node_type_vec,
                                         igraph_bool_t directed, igraph_bool_t loops);
IGRAPH_EXPORT int igraph_asymmetric_preference_game(igraph_t *graph, igraph_integer_t nodes,
                                                    igraph_integer_t out_types,
                                                    igraph_integer_t in_types,
                                                    const igraph_matrix_t *type_dist_matrix,
                                                    const igraph_matrix_t *pref_matrix,
                                                    igraph_vector_t *node_type_out_vec,
                                                    igraph_vector_t *node_type_in_vec,
                                                    igraph_bool_t loops);

IGRAPH_EXPORT int igraph_rewire_edges(igraph_t *graph, igraph_real_t prob,
                                      igraph_bool_t loops, igraph_bool_t multiple);
IGRAPH_EXPORT int igraph_rewire_directed_edges(igraph_t *graph, igraph_real_t prob,
                                               igraph_bool_t loops, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_watts_strogatz_game(igraph_t *graph, igraph_integer_t dim,
                                             igraph_integer_t size, igraph_integer_t nei,
                                             igraph_real_t p, igraph_bool_t loops,
                                             igraph_bool_t multiple);

IGRAPH_EXPORT int igraph_lastcit_game(igraph_t *graph,
                                      igraph_integer_t nodes, igraph_integer_t edges_per_node,
                                      igraph_integer_t agebins,
                                      const igraph_vector_t *preference, igraph_bool_t directed);

IGRAPH_EXPORT int igraph_cited_type_game(igraph_t *graph, igraph_integer_t nodes,
                                         const igraph_vector_t *types,
                                         const igraph_vector_t *pref,
                                         igraph_integer_t edges_per_step,
                                         igraph_bool_t directed);

IGRAPH_EXPORT int igraph_citing_cited_type_game(igraph_t *graph, igraph_integer_t nodes,
                                                const igraph_vector_t *types,
                                                const igraph_matrix_t *pref,
                                                igraph_integer_t edges_per_step,
                                                igraph_bool_t directed);

IGRAPH_EXPORT int igraph_forest_fire_game(igraph_t *graph, igraph_integer_t nodes,
                                          igraph_real_t fw_prob, igraph_real_t bw_factor,
                                          igraph_integer_t ambs, igraph_bool_t directed);


IGRAPH_EXPORT int igraph_simple_interconnected_islands_game(
    igraph_t *graph,
    igraph_integer_t islands_n,
    igraph_integer_t islands_size,
    igraph_real_t islands_pin,
    igraph_integer_t n_inter);

IGRAPH_EXPORT int igraph_static_fitness_game(igraph_t *graph, igraph_integer_t no_of_edges,
                                             const igraph_vector_t *fitness_out, const igraph_vector_t *fitness_in,
                                             igraph_bool_t loops, igraph_bool_t multiple);

IGRAPH_EXPORT int igraph_static_power_law_game(igraph_t *graph,
                                               igraph_integer_t no_of_nodes, igraph_integer_t no_of_edges,
                                               igraph_real_t exponent_out, igraph_real_t exponent_in,
                                               igraph_bool_t loops, igraph_bool_t multiple,
                                               igraph_bool_t finite_size_correction);

IGRAPH_EXPORT int igraph_k_regular_game(igraph_t *graph,
                                        igraph_integer_t no_of_nodes, igraph_integer_t k,
                                        igraph_bool_t directed, igraph_bool_t multiple);

IGRAPH_EXPORT int igraph_sbm_game(igraph_t *graph, igraph_integer_t n,
                                  const igraph_matrix_t *pref_matrix,
                                  const igraph_vector_int_t *block_sizes,
                                  igraph_bool_t directed, igraph_bool_t loops);

IGRAPH_EXPORT int igraph_hsbm_game(igraph_t *graph, igraph_integer_t n,
                                   igraph_integer_t m, const igraph_vector_t *rho,
                                   const igraph_matrix_t *C, igraph_real_t p);

IGRAPH_EXPORT int igraph_hsbm_list_game(igraph_t *graph, igraph_integer_t n,
                                        const igraph_vector_int_t *mlist,
                                        const igraph_vector_ptr_t *rholist,
                                        const igraph_vector_ptr_t *Clist,
                                        igraph_real_t p);

IGRAPH_EXPORT int igraph_correlated_game(const igraph_t *old_graph, igraph_t *new_graph,
                                         igraph_real_t corr, igraph_real_t p,
                                         const igraph_vector_t *permutation);

IGRAPH_EXPORT int igraph_correlated_pair_game(igraph_t *graph1, igraph_t *graph2,
                                              igraph_integer_t n, igraph_real_t corr, igraph_real_t p,
                                              igraph_bool_t directed,
                                              const igraph_vector_t *permutation);

IGRAPH_EXPORT int igraph_tree_game(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                                   igraph_random_tree_t method);

IGRAPH_EXPORT int igraph_dot_product_game(igraph_t *graph, const igraph_matrix_t *vecs,
                                          igraph_bool_t directed);

IGRAPH_EXPORT int igraph_sample_sphere_surface(igraph_integer_t dim, igraph_integer_t n,
                                               igraph_real_t radius,
                                               igraph_bool_t positive,
                                               igraph_matrix_t *res);

IGRAPH_EXPORT int igraph_sample_sphere_volume(igraph_integer_t dim, igraph_integer_t n,
                                              igraph_real_t radius,
                                              igraph_bool_t positive,
                                              igraph_matrix_t *res);

IGRAPH_EXPORT int igraph_sample_dirichlet(igraph_integer_t n, const igraph_vector_t *alpha,
                                          igraph_matrix_t *res);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_graphicality.h0000644000175100001710000000473100000000000025465 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2009-2020  Gabor Csardi 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_GRAPHICALITY_H
#define IGRAPH_GRAPHICALITY_H

#include "igraph_decls.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

typedef unsigned char igraph_edge_type_sw_t;

/*
 * bit 0: self-loops alowed?
 * bit 1: more than one edge allowed between distinct vertices?
 * bit 2: more than one self-loop allowed (assuming bit 0 is set)?
 */
enum {
  IGRAPH_SIMPLE_SW = 0x00, /* 000 */
  IGRAPH_LOOPS_SW  = 0x01, /* 001 */
  IGRAPH_MULTI_SW  = 0x06  /* 110 */
};

IGRAPH_EXPORT int igraph_is_graphical(const igraph_vector_t *out_degrees,
                                      const igraph_vector_t *in_degrees,
                                      const igraph_edge_type_sw_t allowed_edge_types,
                                      igraph_bool_t *res);

IGRAPH_EXPORT int igraph_is_bigraphical(const igraph_vector_t *degrees1,
                                        const igraph_vector_t *degrees2,
                                        const igraph_edge_type_sw_t allowed_edge_types,
                                        igraph_bool_t *res);


/* Legacy functions (deprecated): */

IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_is_degree_sequence(const igraph_vector_t *out_degrees,
                                                              const igraph_vector_t *in_degrees,
                                                              igraph_bool_t *res);

IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_is_graphical_degree_sequence(const igraph_vector_t *out_degrees,
                                                                        const igraph_vector_t *in_degrees,
                                                                        igraph_bool_t *res);

__END_DECLS

#endif // IGRAPH_GRAPHICALITY_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_graphlets.h0000644000175100001710000000374700000000000025004 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_GRAPHLETS_H
#define IGRAPH_GRAPHLETS_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_vector_ptr.h"
#include "igraph_interface.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_graphlets_candidate_basis(const igraph_t *graph,
                                                   const igraph_vector_t *weights,
                                                   igraph_vector_ptr_t *cliques,
                                                   igraph_vector_t *thresholds);

IGRAPH_EXPORT int igraph_graphlets_project(const igraph_t *graph,
                                           const igraph_vector_t *weights,
                                           const igraph_vector_ptr_t *cliques,
                                           igraph_vector_t *Mu, igraph_bool_t startMu,
                                           int niter);

IGRAPH_EXPORT int igraph_graphlets(const igraph_t *graph,
                                   const igraph_vector_t *weights,
                                   igraph_vector_ptr_t *cliques,
                                   igraph_vector_t *Mu, int niter);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_heap.h0000644000175100001710000000407600000000000023724 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_HEAP_H
#define IGRAPH_HEAP_H

#include "igraph_decls.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Heap                                               */
/* -------------------------------------------------- */

/**
 * Heap data type.
 * \ingroup internal
 */

#define BASE_IGRAPH_REAL
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_LONG

#define BASE_CHAR
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "igraph_heap_pmt.h"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_CHAR

#define IGRAPH_HEAP_NULL { 0,0,0 }

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_heap_pmt.h0000644000175100001710000000330700000000000024600 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

typedef struct TYPE(igraph_heap) {
    BASE* stor_begin;
    BASE* stor_end;
    BASE* end;
    int destroy;
} TYPE(igraph_heap);

IGRAPH_EXPORT int FUNCTION(igraph_heap, init)(TYPE(igraph_heap)* h, long int size);
IGRAPH_EXPORT int FUNCTION(igraph_heap, init_array)(TYPE(igraph_heap) *t, BASE* data, long int len);
IGRAPH_EXPORT void FUNCTION(igraph_heap, destroy)(TYPE(igraph_heap)* h);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_heap, empty)(TYPE(igraph_heap)* h);
IGRAPH_EXPORT int FUNCTION(igraph_heap, push)(TYPE(igraph_heap)* h, BASE elem);
IGRAPH_EXPORT BASE FUNCTION(igraph_heap, top)(TYPE(igraph_heap)* h);
IGRAPH_EXPORT BASE FUNCTION(igraph_heap, delete_top)(TYPE(igraph_heap)* h);
IGRAPH_EXPORT long int FUNCTION(igraph_heap, size)(TYPE(igraph_heap)* h);
IGRAPH_EXPORT int FUNCTION(igraph_heap, reserve)(TYPE(igraph_heap)* h, long int size);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_hrg.h0000644000175100001710000001106200000000000023560 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_HRG_H
#define IGRAPH_HRG_H

#include "igraph_decls.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/**
 * \struct igraph_hrg_t
 * Data structure to store a hierarchical random graph
 *
 * A hierarchical random graph (HRG) can be given as a binary tree,
 * where the internal vertices are labeled with real numbers.
 *
 * Note that you don't necessarily have to know this
 * internal representation for using the HRG functions, just pass the
 * HRG objects created by one igraph function, to another igraph
 * function.
 *
 * 
 * It has the following members:
 * \member left Vector that contains the left children of the internal
 *    tree vertices. The first vertex is always the root vertex, so
 *    the first element of the vector is the left child of the root
 *    vertex. Internal vertices are denoted with negative numbers,
 *    starting from -1 and going down, i.e. the root vertex is
 *    -1. Leaf vertices are denoted by non-negative number, starting
 *    from zero and up.
 * \member right Vector that contains the right children of the
 *    vertices, with the same encoding as the \c left vector.
 * \member prob The connection probabilities attached to the internal
 *    vertices, the first number belongs to the root vertex
 *    (i.e. internal vertex -1), the second to internal vertex -2,
 *    etc.
 * \member edges The number of edges in the subtree below the given
 *    internal vertex.
 * \member vertices The number of vertices in the subtree below the
 *    given internal vertex, including itself.
 */

typedef struct igraph_hrg_t {
    igraph_vector_t left, right, prob, edges, vertices;
} igraph_hrg_t;

IGRAPH_EXPORT int igraph_hrg_init(igraph_hrg_t *hrg, int n);
IGRAPH_EXPORT void igraph_hrg_destroy(igraph_hrg_t *hrg);
IGRAPH_EXPORT int igraph_hrg_size(const igraph_hrg_t *hrg);
IGRAPH_EXPORT int igraph_hrg_resize(igraph_hrg_t *hrg, int newsize);

IGRAPH_EXPORT int igraph_hrg_fit(const igraph_t *graph,
                                 igraph_hrg_t *hrg,
                                 igraph_bool_t start,
                                 int steps);

IGRAPH_EXPORT int igraph_hrg_sample(const igraph_t *graph,
                                    igraph_t *sample,
                                    igraph_vector_ptr_t *samples,
                                    igraph_integer_t no_samples,
                                    igraph_hrg_t *hrg,
                                    igraph_bool_t start);

IGRAPH_EXPORT int igraph_hrg_game(igraph_t *graph,
                                  const igraph_hrg_t *hrg);

IGRAPH_EXPORT int igraph_hrg_dendrogram(igraph_t *graph,
                                        const igraph_hrg_t *hrg);

IGRAPH_EXPORT int igraph_hrg_consensus(const igraph_t *graph,
                                       igraph_vector_t *parents,
                                       igraph_vector_t *weights,
                                       igraph_hrg_t *hrg,
                                       igraph_bool_t start,
                                       int num_samples);

IGRAPH_EXPORT int igraph_hrg_predict(const igraph_t *graph,
                                     igraph_vector_t *edges,
                                     igraph_vector_t *prob,
                                     igraph_hrg_t *hrg,
                                     igraph_bool_t start,
                                     int num_samples,
                                     int num_bins);

IGRAPH_EXPORT int igraph_hrg_create(igraph_hrg_t *hrg,
                                    const igraph_t *graph,
                                    const igraph_vector_t *prob);

__END_DECLS

#endif  /* IGRAPH_HRG_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_interface.h0000644000175100001710000001313100000000000024737 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_INTERFACE_H
#define IGRAPH_INTERFACE_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Interface                                          */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_empty(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed);
IGRAPH_EXPORT int igraph_empty_attrs(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, void *attr);
IGRAPH_EXPORT void igraph_destroy(igraph_t *graph);
IGRAPH_EXPORT int igraph_copy(igraph_t *to, const igraph_t *from);
IGRAPH_EXPORT int igraph_add_edges(igraph_t *graph, const igraph_vector_t *edges,
                                   void *attr);
IGRAPH_EXPORT int igraph_add_vertices(igraph_t *graph, igraph_integer_t nv,
                                      void *attr);
IGRAPH_EXPORT int igraph_delete_edges(igraph_t *graph, igraph_es_t edges);
IGRAPH_EXPORT int igraph_delete_vertices(igraph_t *graph, const igraph_vs_t vertices);
IGRAPH_EXPORT int igraph_delete_vertices_idx(igraph_t *graph, const igraph_vs_t vertices,
                                             igraph_vector_t *idx,
                                             igraph_vector_t *invidx);
IGRAPH_EXPORT igraph_integer_t igraph_vcount(const igraph_t *graph);
IGRAPH_EXPORT igraph_integer_t igraph_ecount(const igraph_t *graph);
IGRAPH_EXPORT int igraph_neighbors(const igraph_t *graph, igraph_vector_t *neis, igraph_integer_t vid,
                                   igraph_neimode_t mode);
IGRAPH_EXPORT igraph_bool_t igraph_is_directed(const igraph_t *graph);
IGRAPH_EXPORT int igraph_degree(const igraph_t *graph, igraph_vector_t *res,
                                const igraph_vs_t vids, igraph_neimode_t mode,
                                igraph_bool_t loops);
IGRAPH_EXPORT int igraph_edge(const igraph_t *graph, igraph_integer_t eid,
                              igraph_integer_t *from, igraph_integer_t *to);
IGRAPH_EXPORT int igraph_edges(const igraph_t *graph, igraph_es_t eids,
                               igraph_vector_t *edges);
IGRAPH_EXPORT int igraph_get_eid(const igraph_t *graph, igraph_integer_t *eid,
                                 igraph_integer_t from, igraph_integer_t to,
                                 igraph_bool_t directed, igraph_bool_t error);
IGRAPH_EXPORT int igraph_get_eids(const igraph_t *graph, igraph_vector_t *eids,
                                  const igraph_vector_t *pairs,
                                  const igraph_vector_t *path,
                                  igraph_bool_t directed, igraph_bool_t error);
IGRAPH_EXPORT int igraph_get_eids_multi(const igraph_t *graph, igraph_vector_t *eids,
                                        const igraph_vector_t *pairs,
                                        const igraph_vector_t *path,
                                        igraph_bool_t directed, igraph_bool_t error);
IGRAPH_EXPORT int igraph_incident(const igraph_t *graph, igraph_vector_t *eids, igraph_integer_t vid,
                                  igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_is_same_graph(const igraph_t *graph1, const igraph_t *igraph2, igraph_bool_t *res);

/**
 * \define IGRAPH_FROM
 * \brief The source vertex of an edge.
 *
 * Faster than \ref igraph_edge(), but no error checking is done: \p eid is assumed to be valid.
 *
 * \param graph The graph.
 * \param eid   The edge ID.
 * \return The source vertex of the edge.
 * \sa \ref igraph_edge() if error checking is desired.
 */
#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(long int)(eid)]))

/**
 * \define IGRAPH_TO
 * \brief The target vertex of an edge.
 *
 * Faster than \ref igraph_edge(), but no error checking is done: \p eid is assumed to be valid.
 *
 * \param graph The graph object.
 * \param eid   The edge ID.
 * \return The target vertex of the edge.
 * \sa \ref igraph_edge() if error checking is desired.
 */
#define IGRAPH_TO(graph,eid)   ((igraph_integer_t)(VECTOR((graph)->to)  [(long int)(eid)]))

/**
 * \define IGRAPH_OTHER
 * \brief The other endpoint of an edge.
 *
 * Typically used with undirected edges when one endpoint of the edge is known,
 * and the other endpoint is needed. No error checking is done:
 * \p eid and \p vid are assumed to be valid.
 *
 * \param graph The graph object.
 * \param eid   The edge ID.
 * \param vid   The vertex ID of one endpoint of an edge.
 * \return The other endpoint of the edge.
 * \sa \ref IGRAPH_TO() and \ref IGRAPH_FROM() to get the source and target
 *     of directed edges.
 */
#define IGRAPH_OTHER(graph,eid,vid) \
    ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid))))

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_interrupt.h0000644000175100001710000001144500000000000025041 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_INTERRUPT_H
#define IGRAPH_INTERRUPT_H

#include "igraph_decls.h"
#include "igraph_error.h"

__BEGIN_DECLS

/* This file contains the igraph interruption handling. */

/**
 * \section interrupthandlers Interruption handlers
 *
 * 
 * \a igraph is designed to be embeddable into several higher level
 * languages (R and Python interfaces are included in the original
 * package). Since most higher level languages consider internal \a igraph
 * calls as atomic, interruption requests (like Ctrl-C in Python) must
 * be handled differently depending on the environment \a igraph embeds
 * into.
 * 
 * An \emb interruption handler \eme is a function which is called regularly
 * by \a igraph during long calculations. A typical usage of the interruption
 * handler is to check whether the user tried to interrupt the calculation
 * and return an appropriate value to signal this condition. For example,
 * in R, one must call an internal R function regularly to check for
 * interruption requests, and the \a igraph interruption handler is the
 * perfect place to do that.
 * 
 * If you are using the plain C interface of \a igraph or if you are
 * allowed to replace the operating system's interruption handler (like
 * SIGINT in Un*x systems), these calls are not of much use to you.
 * 
 * The default interruption handler is empty.
 * The \ref igraph_set_interruption_handler() function can be used to set a
 * new interruption handler function of type
 * \ref igraph_interruption_handler_t, see the
 * documentation of this type for details.
 * 
 */

/**
 * \section writing_interruption_handlers Writing interruption handlers
 *
 * 
 * You can write and install interruption handlers simply by defining a
 * function of type \ref igraph_interruption_handler_t and calling
 * \ref igraph_set_interruption_handler(). This feature is useful for
 * interface writers, because usually this is the only way to allow handling
 * of Ctrl-C and similar keypresses properly.
 * 
 * 
 * Your interruption handler will be called regularly during long operations
 * (so it is not guaranteed to be called during operations which tend to be
 * short, like adding single edges). An interruption handler accepts no
 * parameters and must return \c IGRAPH_SUCCESS if the calculation should go on. All
 * other return values are considered to be a request for interruption,
 * and the caller function would return a special error code, \c IGRAPH_INTERRUPTED.
 * It is up to your error handler function to handle this error properly.
 * 
 */

/**
 * \section writing_functions_interruption_handling Writing \a igraph functions with
 * proper interruption handling
 *
 * 
 * There is practically a simple rule that should be obeyed when writing
 * \a igraph functions. If the calculation is expected to take a long time
 * in large graphs (a simple rule of thumb is to assume this for every
 * function with a time complexity of at least O(n^2)), call
 * \ref IGRAPH_ALLOW_INTERRUPTION in regular intervals like every 10th
 * iteration or so.
 * 
 */

/**
 * \typedef igraph_interruption_handler_t
 *
 * This is the type of the interruption handler functions.
 *
 * \param data reserved for possible future use
 * \return \c IGRAPH_SUCCESS if the calculation should go on, anything else otherwise.
 */

typedef int igraph_interruption_handler_t (void* data);

/**
 * \function igraph_allow_interruption
 *
 * This is the function which is called (usually via the
 * \ref IGRAPH_ALLOW_INTERRUPTION macro) if \a igraph is checking for interruption
 * requests.
 *
 * \param data reserved for possible future use, now it is always \c NULL
 * \return \c IGRAPH_SUCCESS if the calculation should go on, anything else otherwise.
 */

IGRAPH_EXPORT int igraph_allow_interruption(void* data);

IGRAPH_EXPORT igraph_interruption_handler_t * igraph_set_interruption_handler (igraph_interruption_handler_t * new_handler);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_iterators.h0000644000175100001710000003166100000000000025023 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ITERATORS_H
#define IGRAPH_ITERATORS_H

#include "igraph_decls.h"
#include "igraph_constants.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Vertex selectors                                   */
/* -------------------------------------------------- */

#define IGRAPH_VS_ALL       0
#define IGRAPH_VS_ADJ       1
#define IGRAPH_VS_NONE      2
#define IGRAPH_VS_1         3
#define IGRAPH_VS_VECTORPTR 4
#define IGRAPH_VS_VECTOR    5
#define IGRAPH_VS_SEQ       6
#define IGRAPH_VS_NONADJ    7

typedef struct igraph_vs_t {
    int type;
    union {
        igraph_integer_t vid;               /* single vertex  */
        const igraph_vector_t *vecptr;      /* vector of vertices  */
        struct {
            igraph_integer_t vid;
            igraph_neimode_t mode;
        } adj;                  /* adjacent vertices  */
        struct {
            igraph_integer_t from;
            igraph_integer_t to;
        } seq;                              /* sequence of vertices from:to */
    } data;
} igraph_vs_t;

IGRAPH_EXPORT int igraph_vs_all(igraph_vs_t *vs);
IGRAPH_EXPORT igraph_vs_t igraph_vss_all(void);

IGRAPH_EXPORT int igraph_vs_adj(igraph_vs_t *vs,
                                igraph_integer_t vid, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_vs_nonadj(igraph_vs_t *vs, igraph_integer_t vid,
                                   igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_vs_none(igraph_vs_t *vs);
IGRAPH_EXPORT igraph_vs_t igraph_vss_none(void);

IGRAPH_EXPORT int igraph_vs_1(igraph_vs_t *vs, igraph_integer_t vid);
IGRAPH_EXPORT igraph_vs_t igraph_vss_1(igraph_integer_t vid);

IGRAPH_EXPORT int igraph_vs_vector(igraph_vs_t *vs,
                                   const igraph_vector_t *v);
IGRAPH_EXPORT igraph_vs_t igraph_vss_vector(const igraph_vector_t *v);

IGRAPH_EXPORT int igraph_vs_vector_small(igraph_vs_t *vs, ...);

IGRAPH_EXPORT int igraph_vs_vector_copy(igraph_vs_t *vs,
                                        const igraph_vector_t *v);

IGRAPH_EXPORT int igraph_vs_seq(igraph_vs_t *vs, igraph_integer_t from, igraph_integer_t to);
IGRAPH_EXPORT igraph_vs_t igraph_vss_seq(igraph_integer_t from, igraph_integer_t to);

IGRAPH_EXPORT void igraph_vs_destroy(igraph_vs_t *vs);

IGRAPH_EXPORT igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs);

IGRAPH_EXPORT int igraph_vs_copy(igraph_vs_t* dest, const igraph_vs_t* src);

IGRAPH_EXPORT int igraph_vs_as_vector(const igraph_t *graph, igraph_vs_t vs,
                                      igraph_vector_t *v);
IGRAPH_EXPORT int igraph_vs_size(const igraph_t *graph, const igraph_vs_t *vs,
                                 igraph_integer_t *result);
IGRAPH_EXPORT int igraph_vs_type(const igraph_vs_t *vs);

/* -------------------------------------------------- */
/* Vertex iterators                                   */
/* -------------------------------------------------- */

#define IGRAPH_VIT_SEQ       0
#define IGRAPH_VIT_VECTOR    1
#define IGRAPH_VIT_VECTORPTR 2

typedef struct igraph_vit_t {
    int type;
    long int pos;
    long int start;
    long int end;
    const igraph_vector_t *vec;
} igraph_vit_t;

/**
 * \section IGRAPH_VIT Stepping over the vertices
 *
 * After creating an iterator with \ref igraph_vit_create(), it
 * points to the first vertex in the vertex determined by the vertex
 * selector (if there is any). The \ref IGRAPH_VIT_NEXT() macro steps
 * to the next vertex, \ref IGRAPH_VIT_END() checks whether there are
 * more vertices to visit, \ref IGRAPH_VIT_SIZE() gives the total size
 * of the vertices visited so far and to be visited. \ref
 * IGRAPH_VIT_RESET() resets the iterator, it will point to the first
 * vertex again. Finally \ref IGRAPH_VIT_GET() gives the current vertex
 * pointed to by the iterator (call this only if \ref IGRAPH_VIT_END()
 * is false).
 * 
 * 
 * Here is an example on how to step over the neighbors of vertex 0:
 * 
 * igraph_vs_t vs;
 * igraph_vit_t vit;
 * ...
 * igraph_vs_adj(&vs, 0, IGRAPH_ALL);
 * igraph_vit_create(&graph, vs, &vit);
 * while (!IGRAPH_VIT_END(vit)) {
 *   printf(" %li", (long int) IGRAPH_VIT_GET(vit));
 *   IGRAPH_VIT_NEXT(vit);
 * }
 * printf("\n");
 * ...
 * igraph_vit_destroy(&vit);
 * igraph_vs_destroy(&vs);
 * 
 * 
 */

/**
 * \define IGRAPH_VIT_NEXT
 * \brief Next vertex.
 *
 * Steps the iterator to the next vertex. Only call this function if
 * \ref IGRAPH_VIT_END() returns false.
 * \param vit The vertex iterator to step.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_VIT_NEXT(vit)  (++((vit).pos))
/**
 * \define IGRAPH_VIT_END
 * \brief Are we at the end?
 *
 * Checks whether there are more vertices to step to.
 * \param vit The vertex iterator to check.
 * \return Logical value, if true there are no more vertices to step
 * to.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_VIT_END(vit)   ((vit).pos >= (vit).end)
/**
 * \define IGRAPH_VIT_SIZE
 * \brief Size of a vertex iterator.
 *
 * Gives the number of vertices in a vertex iterator.
 * \param vit The vertex iterator.
 * \return The number of vertices.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_VIT_SIZE(vit)  ((vit).end - (vit).start)
/**
 * \define IGRAPH_VIT_RESET
 * \brief Reset a vertex iterator.
 *
 * Resets a vertex iterator. After calling this macro the iterator
 * will point to the first vertex.
 * \param vit The vertex iterator.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start)
/**
 * \define IGRAPH_VIT_GET
 * \brief Query the current position.
 *
 * Gives the vertex id of the current vertex pointed to by the
 * iterator.
 * \param vit The vertex iterator.
 * \return The vertex id of the current vertex.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_VIT_GET(vit)  \
    ((igraph_integer_t)(((vit).type == IGRAPH_VIT_SEQ) ? (vit).pos : \
                        VECTOR(*(vit).vec)[(vit).pos]))

IGRAPH_EXPORT int igraph_vit_create(const igraph_t *graph,
                                    igraph_vs_t vs, igraph_vit_t *vit);
IGRAPH_EXPORT void igraph_vit_destroy(const igraph_vit_t *vit);

IGRAPH_EXPORT int igraph_vit_as_vector(const igraph_vit_t *vit, igraph_vector_t *v);

/* -------------------------------------------------- */
/* Edge Selectors                                     */
/* -------------------------------------------------- */

#define IGRAPH_ES_ALL       0
#define IGRAPH_ES_ALLFROM   1
#define IGRAPH_ES_ALLTO     2
#define IGRAPH_ES_INCIDENT  3
#define IGRAPH_ES_NONE      4
#define IGRAPH_ES_1         5
#define IGRAPH_ES_VECTORPTR 6
#define IGRAPH_ES_VECTOR    7
#define IGRAPH_ES_SEQ       8
#define IGRAPH_ES_PAIRS     9
#define IGRAPH_ES_PATH      10
#define IGRAPH_ES_MULTIPAIRS 11

typedef struct igraph_es_t {
    int type;
    union {
        igraph_integer_t vid;
        igraph_integer_t eid;
        const igraph_vector_t *vecptr;
        struct {
            igraph_integer_t vid;
            igraph_neimode_t mode;
        } incident;
        struct {
            igraph_integer_t from;
            igraph_integer_t to;
        } seq;
        struct {
            const igraph_vector_t *ptr;
            igraph_bool_t mode;
        } path;
    } data;
} igraph_es_t;

IGRAPH_EXPORT int igraph_es_all(igraph_es_t *es,
                                igraph_edgeorder_type_t order);
IGRAPH_EXPORT igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order);

IGRAPH_EXPORT int igraph_es_incident(igraph_es_t *es,
                                     igraph_integer_t vid, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_es_none(igraph_es_t *es);
IGRAPH_EXPORT igraph_es_t igraph_ess_none(void);

IGRAPH_EXPORT int igraph_es_1(igraph_es_t *es, igraph_integer_t eid);
IGRAPH_EXPORT igraph_es_t igraph_ess_1(igraph_integer_t eid);

IGRAPH_EXPORT int igraph_es_vector(igraph_es_t *es,
                                   const igraph_vector_t *v);
IGRAPH_EXPORT igraph_es_t igraph_ess_vector(const igraph_vector_t *v);

IGRAPH_EXPORT int igraph_es_fromto(igraph_es_t *es,
                                   igraph_vs_t from, igraph_vs_t to);

IGRAPH_EXPORT int igraph_es_seq(igraph_es_t *es, igraph_integer_t from, igraph_integer_t to);
IGRAPH_EXPORT igraph_es_t igraph_ess_seq(igraph_integer_t from, igraph_integer_t to);

IGRAPH_EXPORT int igraph_es_vector_copy(igraph_es_t *es, const igraph_vector_t *v);

IGRAPH_EXPORT int igraph_es_pairs(igraph_es_t *es, const igraph_vector_t *v,
                                  igraph_bool_t directed);
IGRAPH_EXPORT int igraph_es_pairs_small(igraph_es_t *es, igraph_bool_t directed, ...);

IGRAPH_EXPORT int igraph_es_multipairs(igraph_es_t *es, const igraph_vector_t *v,
                                       igraph_bool_t directed);

IGRAPH_EXPORT int igraph_es_path(igraph_es_t *es, const igraph_vector_t *v,
                                 igraph_bool_t directed);
IGRAPH_EXPORT int igraph_es_path_small(igraph_es_t *es, igraph_bool_t directed, ...);

IGRAPH_EXPORT void igraph_es_destroy(igraph_es_t *es);

IGRAPH_EXPORT igraph_bool_t igraph_es_is_all(const igraph_es_t *es);

IGRAPH_EXPORT int igraph_es_copy(igraph_es_t* dest, const igraph_es_t* src);

IGRAPH_EXPORT int igraph_es_as_vector(const igraph_t *graph, igraph_es_t es,
                                      igraph_vector_t *v);
IGRAPH_EXPORT int igraph_es_size(const igraph_t *graph, const igraph_es_t *es,
                                 igraph_integer_t *result);
IGRAPH_EXPORT int igraph_es_type(const igraph_es_t *es);


/* -------------------------------------------------- */
/* Edge Iterators                                     */
/* -------------------------------------------------- */

#define IGRAPH_EIT_SEQ       0
#define IGRAPH_EIT_VECTOR    1
#define IGRAPH_EIT_VECTORPTR 2

typedef struct igraph_eit_t {
    int type;
    long int pos;
    long int start;
    long int end;
    const igraph_vector_t *vec;
} igraph_eit_t;

/**
 * \section IGRAPH_EIT Stepping over the edges
 *
 * Just like for vertex iterators, macros are provided for
 * stepping over a sequence of edges: \ref IGRAPH_EIT_NEXT() goes to
 * the next edge, \ref IGRAPH_EIT_END() checks whether there are more
 * edges to visit, \ref IGRAPH_EIT_SIZE() gives the number of edges in
 * the edge sequence, \ref IGRAPH_EIT_RESET() resets the iterator to
 * the first edge and \ref IGRAPH_EIT_GET() returns the id of the
 * current edge.
 */

/**
 * \define IGRAPH_EIT_NEXT
 * \brief Next edge.
 *
 * Steps the iterator to the next edge. Call this function only if
 * \ref IGRAPH_EIT_END() returns false.
 * \param eit The edge iterator to step.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_EIT_NEXT(eit) (++((eit).pos))
/**
 * \define IGRAPH_EIT_END
 * \brief Are we at the end?
 *
 * Checks whether there are more edges to step to.
 * \param wit The edge iterator to check.
 * \return Logical value, if true there are no more edges
 * to step to.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_EIT_END(eit)   ((eit).pos >= (eit).end)
/**
 * \define IGRAPH_EIT_SIZE
 * \brief Number of edges in the iterator.
 *
 * Gives the number of edges in an edge iterator.
 * \param eit The edge iterator.
 * \return The number of edges.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_EIT_SIZE(eit)  ((eit).end - (eit).start)
/**
 * \define IGRAPH_EIT_RESET
 * \brief Reset an edge iterator.
 *
 * Resets an edge iterator. After calling this macro the iterator will
 * point to the first edge.
 * \param eit The edge iterator.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_EIT_RESET(eit) ((eit).pos = (eit).start)
/**
 * \define IGRAPH_EIT_GET
 * \brief Query an edge iterator.
 *
 * Gives the edge id of the current edge pointed to by an iterator.
 * \param eit The edge iterator.
 * \return The id of the current edge.
 *
 * Time complexity: O(1).
 */
#define IGRAPH_EIT_GET(eit)  \
    (igraph_integer_t)((((eit).type == IGRAPH_EIT_SEQ) ? (eit).pos : \
                        VECTOR(*(eit).vec)[(eit).pos]))

IGRAPH_EXPORT int igraph_eit_create(const igraph_t *graph,
                                    igraph_es_t es, igraph_eit_t *eit);
IGRAPH_EXPORT void igraph_eit_destroy(const igraph_eit_t *eit);

IGRAPH_EXPORT int igraph_eit_as_vector(const igraph_eit_t *eit, igraph_vector_t *v);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_lapack.h0000644000175100001710000001113400000000000024233 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_LAPACK_H
#define IGRAPH_LAPACK_H

#include "igraph_decls.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"

__BEGIN_DECLS

/**
 * \section about_lapack LAPACK interface in igraph
 *
 * 
 * LAPACK is written in Fortran90 and provides routines for solving
 * systems of simultaneous linear equations, least-squares solutions
 * of linear systems of equations, eigenvalue problems, and singular
 * value problems. The associated matrix factorizations (LU, Cholesky,
 * QR, SVD, Schur, generalized Schur) are also provided, as are
 * related computations such as reordering of the Schur factorizations
 * and estimating condition numbers. Dense and banded matrices are
 * handled, but not general sparse matrices. In all areas, similar
 * functionality is provided for real and complex matrices, in both
 * single and double precision.
 * 
 *
 * 
 * igraph provides an interface to a very limited set of LAPACK
 * functions, using the regular igraph data structures.
 * 
 *
 * 
 * See more about LAPACK at http://www.netlib.org/lapack/
 * 
 */

IGRAPH_EXPORT int igraph_lapack_dgetrf(igraph_matrix_t *a, igraph_vector_int_t *ipiv,
                                       int *info);
IGRAPH_EXPORT int igraph_lapack_dgetrs(igraph_bool_t transpose, const igraph_matrix_t *a,
                                       const igraph_vector_int_t *ipiv, igraph_matrix_t *b);
IGRAPH_EXPORT int igraph_lapack_dgesv(igraph_matrix_t *a, igraph_vector_int_t *ipiv,
                                      igraph_matrix_t *b, int *info);

typedef enum { IGRAPH_LAPACK_DSYEV_ALL,
               IGRAPH_LAPACK_DSYEV_INTERVAL,
               IGRAPH_LAPACK_DSYEV_SELECT
             } igraph_lapack_dsyev_which_t;

IGRAPH_EXPORT int igraph_lapack_dsyevr(const igraph_matrix_t *A,
                                       igraph_lapack_dsyev_which_t which,
                                       igraph_real_t vl, igraph_real_t vu, int vestimate,
                                       int il, int iu, igraph_real_t abstol,
                                       igraph_vector_t *values, igraph_matrix_t *vectors,
                                       igraph_vector_int_t *support);

/* TODO: should we use complex vectors/matrices? */

IGRAPH_EXPORT int igraph_lapack_dgeev(const igraph_matrix_t *A,
                                      igraph_vector_t *valuesreal,
                                      igraph_vector_t *valuesimag,
                                      igraph_matrix_t *vectorsleft,
                                      igraph_matrix_t *vectorsright, int *info);

typedef enum { IGRAPH_LAPACK_DGEEVX_BALANCE_NONE = 0,
               IGRAPH_LAPACK_DGEEVX_BALANCE_PERM,
               IGRAPH_LAPACK_DGEEVX_BALANCE_SCALE,
               IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH
             }
igraph_lapack_dgeevx_balance_t;

IGRAPH_EXPORT int igraph_lapack_dgeevx(igraph_lapack_dgeevx_balance_t balance,
                                       const igraph_matrix_t *A,
                                       igraph_vector_t *valuesreal,
                                       igraph_vector_t *valuesimag,
                                       igraph_matrix_t *vectorsleft,
                                       igraph_matrix_t *vectorsright,
                                       int *ilo, int *ihi, igraph_vector_t *scale,
                                       igraph_real_t *abnrm,
                                       igraph_vector_t *rconde,
                                       igraph_vector_t *rcondv,
                                       int *info);

IGRAPH_EXPORT int igraph_lapack_dgehrd(const igraph_matrix_t *A,
                                       int ilo, int ihi,
                                       igraph_matrix_t *result);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_layout.h0000644000175100001710000003422200000000000024320 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_LAYOUT_H
#define IGRAPH_LAYOUT_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_matrix.h"
#include "igraph_datatype.h"
#include "igraph_arpack.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

/**
 * \section about_layouts
 *
 * Layout generator functions (or at least most of them) try to place the
 * vertices and edges of a graph on a 2D plane or in 3D space in a way
 * which visually pleases the human eye.
 *
 * They take a graph object and a number of parameters as arguments
 * and return an \type igraph_matrix_t, in which each row gives the
 * coordinates of a vertex.
 */

/* -------------------------------------------------- */
/* Layouts                                            */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_layout_random(const igraph_t *graph, igraph_matrix_t *res);
IGRAPH_EXPORT int igraph_layout_circle(const igraph_t *graph, igraph_matrix_t *res,
                                       igraph_vs_t order);
IGRAPH_EXPORT int igraph_layout_star(const igraph_t *graph, igraph_matrix_t *res,
                                     igraph_integer_t center, const igraph_vector_t *order);
IGRAPH_EXPORT int igraph_layout_grid(const igraph_t *graph, igraph_matrix_t *res, long int width);
IGRAPH_EXPORT int igraph_layout_fruchterman_reingold(const igraph_t *graph,
                                                     igraph_matrix_t *res,
                                                     igraph_bool_t use_seed,
                                                     igraph_integer_t niter,
                                                     igraph_real_t start_temp,
                                                     igraph_layout_grid_t grid,
                                                     const igraph_vector_t *weight,
                                                     const igraph_vector_t *minx,
                                                     const igraph_vector_t *maxx,
                                                     const igraph_vector_t *miny,
                                                     const igraph_vector_t *maxy);

IGRAPH_EXPORT int igraph_layout_kamada_kawai(const igraph_t *graph, igraph_matrix_t *res,
                                             igraph_bool_t use_seed, igraph_integer_t maxiter,
                                             igraph_real_t epsilon, igraph_real_t kkconst,
                                             const igraph_vector_t *weights,
                                             const igraph_vector_t *minx, const igraph_vector_t *maxx,
                                             const igraph_vector_t *miny, const igraph_vector_t *maxy);

IGRAPH_EXPORT int igraph_layout_lgl(const igraph_t *graph, igraph_matrix_t *res,
                                    igraph_integer_t maxiter, igraph_real_t maxdelta,
                                    igraph_real_t area, igraph_real_t coolexp,
                                    igraph_real_t repulserad, igraph_real_t cellsize, igraph_integer_t root);
IGRAPH_EXPORT int igraph_layout_reingold_tilford(const igraph_t *graph, igraph_matrix_t *res,
                                                 igraph_neimode_t mode,
                                                 const igraph_vector_t *roots,
                                                 const igraph_vector_t *rootlevel);
IGRAPH_EXPORT int igraph_layout_reingold_tilford_circular(const igraph_t *graph,
                                                          igraph_matrix_t *res,
                                                          igraph_neimode_t mode,
                                                          const igraph_vector_t *roots,
                                                          const igraph_vector_t *rootlevel);
IGRAPH_EXPORT int igraph_layout_sugiyama(const igraph_t *graph, igraph_matrix_t *res,
                                         igraph_t *extd_graph, igraph_vector_t *extd_to_orig_eids,
                                         const igraph_vector_t* layers, igraph_real_t hgap,
                                         igraph_real_t vgap, long int maxiter, const igraph_vector_t *weights);

IGRAPH_EXPORT int igraph_layout_random_3d(const igraph_t *graph, igraph_matrix_t *res);
IGRAPH_EXPORT int igraph_layout_sphere(const igraph_t *graph, igraph_matrix_t *res);
IGRAPH_EXPORT int igraph_layout_grid_3d(const igraph_t *graph, igraph_matrix_t *res,
                                        long int width, long int height);
IGRAPH_EXPORT int igraph_layout_fruchterman_reingold_3d(const igraph_t *graph,
                                                        igraph_matrix_t *res,
                                                        igraph_bool_t use_seed,
                                                        igraph_integer_t niter,
                                                        igraph_real_t start_temp,
                                                        const igraph_vector_t *weight,
                                                        const igraph_vector_t *minx,
                                                        const igraph_vector_t *maxx,
                                                        const igraph_vector_t *miny,
                                                        const igraph_vector_t *maxy,
                                                        const igraph_vector_t *minz,
                                                        const igraph_vector_t *maxz);

IGRAPH_EXPORT int igraph_layout_kamada_kawai_3d(const igraph_t *graph, igraph_matrix_t *res,
                                                igraph_bool_t use_seed, igraph_integer_t maxiter,
                                                igraph_real_t epsilon, igraph_real_t kkconst,
                                                const igraph_vector_t *weights,
                                                const igraph_vector_t *minx, const igraph_vector_t *maxx,
                                                const igraph_vector_t *miny, const igraph_vector_t *maxy,
                                                const igraph_vector_t *minz, const igraph_vector_t *maxz);

IGRAPH_EXPORT int igraph_layout_graphopt(const igraph_t *graph,
                                         igraph_matrix_t *res, igraph_integer_t niter,
                                         igraph_real_t node_charge, igraph_real_t node_mass,
                                         igraph_real_t spring_length,
                                         igraph_real_t spring_constant,
                                         igraph_real_t max_sa_movement,
                                         igraph_bool_t use_seed);

IGRAPH_EXPORT int igraph_layout_mds(const igraph_t *graph, igraph_matrix_t *res,
                                    const igraph_matrix_t *dist, long int dim);

IGRAPH_EXPORT int igraph_layout_bipartite(const igraph_t *graph,
                                          const igraph_vector_bool_t *types,
                                          igraph_matrix_t *res, igraph_real_t hgap,
                                          igraph_real_t vgap, long int maxiter);

/**
 * \struct igraph_layout_drl_options_t
 * Parameters for the DrL layout generator
 *
 * \member edge_cut The edge cutting parameter.
 *    Edge cutting is done in the late stages of the
 *    algorithm in order to achieve less dense layouts.  Edges are cut
 *    if there is a lot of stress on them (a large value in the
 *    objective function sum).  The edge cutting parameter is a value
 *    between 0 and 1 with 0 representing no edge cutting and 1
 *    representing maximal edge cutting. The default value is 32/40.
 * \member init_iterations Number of iterations, initial phase.
 * \member init_temperature Start temperature, initial phase.
 * \member init_attraction Attraction, initial phase.
 * \member init_damping_mult Damping factor, initial phase.
 * \member liquid_iterations Number of iterations in the liquid phase.
 * \member liquid_temperature Start temperature in the liquid phase.
 * \member liquid_attraction Attraction in the liquid phase.
 * \member liquid_damping_mult Multiplicatie damping factor, liquid phase.
 * \member expansion_iterations Number of iterations in the expansion phase.
 * \member expansion_temperature Start temperature in the expansion phase.
 * \member expansion_attraction Attraction, expansion phase.
 * \member expansion_damping_mult Damping factor, expansion phase.
 * \member cooldown_iterations Number of iterations in the cooldown phase.
 * \member cooldown_temperature Start temperature in the cooldown phase.
 * \member cooldown_attraction Attraction in the cooldown phase.
 * \member cooldown_damping_mult Damping fact int the cooldown phase.
 * \member crunch_iterations Number of iterations in the crunch phase.
 * \member crunch_temperature Start temperature in the crunch phase.
 * \member crunch_attraction Attraction in the crunch phase.
 * \member crunch_damping_mult Damping factor in the crunch phase.
 * \member simmer_iterations Number of iterations in the simmer phase.
 * \member simmer_temperature Start temperature in te simmer phase.
 * \member simmer_attraction Attraction in the simmer phase.
 * \member simmer_damping_mult Multiplicative damping factor in the simmer phase.
 */

typedef struct igraph_layout_drl_options_t {
    igraph_real_t    edge_cut;
    igraph_integer_t init_iterations;
    igraph_real_t    init_temperature;
    igraph_real_t    init_attraction;
    igraph_real_t    init_damping_mult;
    igraph_integer_t liquid_iterations;
    igraph_real_t    liquid_temperature;
    igraph_real_t    liquid_attraction;
    igraph_real_t    liquid_damping_mult;
    igraph_integer_t expansion_iterations;
    igraph_real_t    expansion_temperature;
    igraph_real_t    expansion_attraction;
    igraph_real_t    expansion_damping_mult;
    igraph_integer_t cooldown_iterations;
    igraph_real_t    cooldown_temperature;
    igraph_real_t    cooldown_attraction;
    igraph_real_t    cooldown_damping_mult;
    igraph_integer_t crunch_iterations;
    igraph_real_t    crunch_temperature;
    igraph_real_t    crunch_attraction;
    igraph_real_t    crunch_damping_mult;
    igraph_integer_t simmer_iterations;
    igraph_real_t    simmer_temperature;
    igraph_real_t    simmer_attraction;
    igraph_real_t    simmer_damping_mult;
} igraph_layout_drl_options_t;

/**
 * \typedef igraph_layout_drl_default_t
 * Predefined parameter templates for the DrL layout generator
 *
 * These constants can be used to initialize a set of DrL parameters.
 * These can then be modified according to the user's needs.
 * \enumval IGRAPH_LAYOUT_DRL_DEFAULT The deafult parameters.
 * \enumval IGRAPH_LAYOUT_DRL_COARSEN Slightly modified parameters to
 *      get a coarser layout.
 * \enumval IGRAPH_LAYOUT_DRL_COARSEST An even coarser layout.
 * \enumval IGRAPH_LAYOUT_DRL_REFINE Refine an already calculated layout.
 * \enumval IGRAPH_LAYOUT_DRL_FINAL Finalize an already refined layout.
 */

typedef enum { IGRAPH_LAYOUT_DRL_DEFAULT = 0,
               IGRAPH_LAYOUT_DRL_COARSEN,
               IGRAPH_LAYOUT_DRL_COARSEST,
               IGRAPH_LAYOUT_DRL_REFINE,
               IGRAPH_LAYOUT_DRL_FINAL
             } igraph_layout_drl_default_t;

IGRAPH_EXPORT int igraph_layout_drl_options_init(igraph_layout_drl_options_t *options,
                                                 igraph_layout_drl_default_t templ);
IGRAPH_EXPORT int igraph_layout_drl(const igraph_t *graph, igraph_matrix_t *res,
                                    igraph_bool_t use_seed,
                                    const igraph_layout_drl_options_t *options,
                                    const igraph_vector_t *weights,
                                    const igraph_vector_bool_t *fixed);

IGRAPH_EXPORT int igraph_layout_drl_3d(const igraph_t *graph, igraph_matrix_t *res,
                                       igraph_bool_t use_seed,
                                       const igraph_layout_drl_options_t *options,
                                       const igraph_vector_t *weights,
                                       const igraph_vector_bool_t *fixed);

IGRAPH_EXPORT int igraph_layout_merge_dla(const igraph_vector_ptr_t *graphs,
                                          const igraph_vector_ptr_t *coords,
                                          igraph_matrix_t *res);

IGRAPH_EXPORT int igraph_layout_gem(const igraph_t *graph, igraph_matrix_t *res,
                                    igraph_bool_t use_seed, igraph_integer_t maxiter,
                                    igraph_real_t temp_max, igraph_real_t temp_min,
                                    igraph_real_t temp_init);

IGRAPH_EXPORT int igraph_layout_davidson_harel(const igraph_t *graph, igraph_matrix_t *res,
                                               igraph_bool_t use_seed, igraph_integer_t maxiter,
                                               igraph_integer_t fineiter, igraph_real_t cool_fact,
                                               igraph_real_t weight_node_dist, igraph_real_t weight_border,
                                               igraph_real_t weight_edge_lengths,
                                               igraph_real_t weight_edge_crossings,
                                               igraph_real_t weight_node_edge_dist);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_lsap.h0000644000175100001710000000047000000000000023740 0ustar00runnerdocker00000000000000
#ifndef IGRAPH_LSAP_H
#define IGRAPH_LSAP_H

#include "igraph_decls.h"
#include "igraph_matrix.h"
#include "igraph_vector.h"
#include "igraph_types.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_solve_lsap(igraph_matrix_t *c, igraph_integer_t n,
                      igraph_vector_int_t *p);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_matching.h0000644000175100001710000000454400000000000024601 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Tamas Nepusz 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MATCHING_H
#define IGRAPH_MATCHING_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Matchings in graphs                                */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_is_matching(const igraph_t* graph,
                                     const igraph_vector_bool_t* types, const igraph_vector_long_t* matching,
                                     igraph_bool_t* result);
IGRAPH_EXPORT int igraph_is_maximal_matching(const igraph_t* graph,
                                             const igraph_vector_bool_t* types, const igraph_vector_long_t* matching,
                                             igraph_bool_t* result);

IGRAPH_EXPORT int igraph_maximum_bipartite_matching(const igraph_t* graph,
                                                    const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
                                                    igraph_real_t* matching_weight, igraph_vector_long_t* matching,
                                                    const igraph_vector_t* weights, igraph_real_t eps);

IGRAPH_EXPORT int igraph_maximum_matching(const igraph_t* graph, igraph_integer_t* matching_size,
                                          igraph_real_t* matching_weight, igraph_vector_long_t* matching,
                                          const igraph_vector_t* weights);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_matrix.h0000644000175100001710000000553100000000000024310 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MATRIX_H
#define IGRAPH_MATRIX_H

#include "igraph_decls.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Matrix, very similar to vector                     */
/* -------------------------------------------------- */

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_INT
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_COMPLEX
#include "igraph_pmt.h"
#include "igraph_matrix_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_COMPLEX

#define IGRAPH_MATRIX_NULL { IGRAPH_VECTOR_NULL, 0, 0 }
#define IGRAPH_MATRIX_INIT_FINALLY(m, nr, nc) \
    do { IGRAPH_CHECK(igraph_matrix_init(m, nr, nc)); \
        IGRAPH_FINALLY(igraph_matrix_destroy, m); } while (0)

/**
 * \ingroup matrix
 * \define MATRIX
 * \brief Accessing an element of a matrix.
 *
 * Note that there are no range checks right now.
 * This functionality might be redefined as a proper function later.
 * \param m The matrix object.
 * \param i The index of the row, starting with zero.
 * \param j The index of the column, starting with zero.
 *
 * Time complexity: O(1).
 */
#define MATRIX(m,i,j) ((m).data.stor_begin[(m).nrow*(j)+(i)])

IGRAPH_EXPORT igraph_bool_t igraph_matrix_all_e_tol(const igraph_matrix_t *lhs,
                                                    const igraph_matrix_t *rhs,
                                                    igraph_real_t tol);

IGRAPH_EXPORT int igraph_matrix_zapsmall(igraph_matrix_t *m, igraph_real_t tol);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_matrix_pmt.h0000644000175100001710000003216700000000000025175 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

typedef struct TYPE(igraph_matrix) {
    TYPE(igraph_vector) data;
    long int nrow, ncol;
} TYPE(igraph_matrix);

/*---------------*/
/* Allocation    */
/*---------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, init)(TYPE(igraph_matrix) *m,
                                                long int nrow, long int ncol);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, copy)(TYPE(igraph_matrix) *to,
                                                const TYPE(igraph_matrix) *from);
IGRAPH_EXPORT void FUNCTION(igraph_matrix, destroy)(TYPE(igraph_matrix) *m);
IGRAPH_EXPORT long int FUNCTION(igraph_matrix, capacity)(const TYPE(igraph_matrix) *m);

/*--------------------*/
/* Accessing elements */
/*--------------------*/

/* MATRIX */
IGRAPH_EXPORT BASE FUNCTION(igraph_matrix, e)(const TYPE(igraph_matrix) *m,
                                              long int row, long int col);
IGRAPH_EXPORT BASE* FUNCTION(igraph_matrix, e_ptr)(const TYPE(igraph_matrix) *m,
                                                   long int row, long int col);
IGRAPH_EXPORT void FUNCTION(igraph_matrix, set)(TYPE(igraph_matrix)* m, long int row, long int col,
                                                BASE value);

/*------------------------------*/
/* Initializing matrix elements */
/*------------------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_matrix, null)(TYPE(igraph_matrix) *m);
IGRAPH_EXPORT void FUNCTION(igraph_matrix, fill)(TYPE(igraph_matrix) *m, BASE e);

/*-----------------------*/
/* Matrix views          */
/*-----------------------*/

IGRAPH_EXPORT const TYPE(igraph_matrix) *FUNCTION(igraph_matrix, view)(const TYPE(igraph_matrix) *m,
                                                                       const BASE *data,
                                                                       long int nrow,
                                                                       long int ncol);

/*------------------*/
/* Copying matrices */
/*------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_matrix, copy_to)(const TYPE(igraph_matrix) *m, BASE *to);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, update)(TYPE(igraph_matrix) *to,
                                                  const TYPE(igraph_matrix) *from);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, rbind)(TYPE(igraph_matrix) *to,
                                                 const TYPE(igraph_matrix) *from);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, cbind)(TYPE(igraph_matrix) *to,
                                                 const TYPE(igraph_matrix) *from);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, swap)(TYPE(igraph_matrix) *m1, TYPE(igraph_matrix) *m2);

/*--------------------------*/
/* Copying rows and columns */
/*--------------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, get_row)(const TYPE(igraph_matrix) *m,
                                                   TYPE(igraph_vector) *res, long int index);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, get_col)(const TYPE(igraph_matrix) *m,
                                                   TYPE(igraph_vector) *res, long int index);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, set_row)(TYPE(igraph_matrix) *m,
                                                   const TYPE(igraph_vector) *v, long int index);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, set_col)(TYPE(igraph_matrix) *m,
                                                   const TYPE(igraph_vector) *v, long int index);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, select_rows)(const TYPE(igraph_matrix) *m,
                                                       TYPE(igraph_matrix) *res,
                                                       const igraph_vector_t *rows);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, select_cols)(const TYPE(igraph_matrix) *m,
                                                       TYPE(igraph_matrix) *res,
                                                       const igraph_vector_t *cols);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, select_rows_cols)(const TYPE(igraph_matrix) *m,
                                                            TYPE(igraph_matrix) *res,
                                                            const igraph_vector_t *rows,
                                                            const igraph_vector_t *cols);

/*-----------------------------*/
/* Exchanging rows and columns */
/*-----------------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, swap_rows)(TYPE(igraph_matrix) *m,
                                                     long int i, long int j);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, swap_cols)(TYPE(igraph_matrix) *m,
                                                     long int i, long int j);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, swap_rowcol)(TYPE(igraph_matrix) *m,
                                                       long int i, long int j);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, transpose)(TYPE(igraph_matrix) *m);

/*-----------------------------*/
/* Matrix operations           */
/*-----------------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, add)(TYPE(igraph_matrix) *m1,
                                               const TYPE(igraph_matrix) *m2);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, sub)(TYPE(igraph_matrix) *m1,
                                               const TYPE(igraph_matrix) *m2);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, mul_elements)(TYPE(igraph_matrix) *m1,
                                                        const TYPE(igraph_matrix) *m2);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, div_elements)(TYPE(igraph_matrix) *m1,
                                                        const TYPE(igraph_matrix) *m2);
IGRAPH_EXPORT void FUNCTION(igraph_matrix, scale)(TYPE(igraph_matrix) *m, BASE by);
IGRAPH_EXPORT void FUNCTION(igraph_matrix, add_constant)(TYPE(igraph_matrix) *m, BASE plus);

/*-----------------------------*/
/* Finding minimum and maximum */
/*-----------------------------*/

#ifndef NOTORDERED
IGRAPH_EXPORT igraph_real_t FUNCTION(igraph_matrix, min)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT igraph_real_t FUNCTION(igraph_matrix, max)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, which_min)(const TYPE(igraph_matrix) *m,
                                                     long int *i, long int *j);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, which_max)(const TYPE(igraph_matrix) *m,
                                                     long int *i, long int *j);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, minmax)(const TYPE(igraph_matrix) *m,
                                                  BASE *min, BASE *max);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, which_minmax)(const TYPE(igraph_matrix) *m,
                                                        long int *imin, long int *jmin,
                                                        long int *imax, long int *jmax);
#endif

/*------------------------------*/
/* Comparison                   */
/*------------------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, all_e)(const TYPE(igraph_matrix) *lhs,
                                                           const TYPE(igraph_matrix) *rhs);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, all_l)(const TYPE(igraph_matrix) *lhs,
                                                           const TYPE(igraph_matrix) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, all_g)(const TYPE(igraph_matrix) *lhs,
                                                           const TYPE(igraph_matrix) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, all_le)(const TYPE(igraph_matrix) *lhs,
                                                            const TYPE(igraph_matrix) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, all_ge)(const TYPE(igraph_matrix) *lhs,
                                                            const TYPE(igraph_matrix) *rhs);
#endif

/*-------------------*/
/* Matrix properties */
/*-------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, isnull)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, empty)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT long int FUNCTION(igraph_matrix, size)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT long int FUNCTION(igraph_matrix, nrow)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT long int FUNCTION(igraph_matrix, ncol)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, is_symmetric)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT BASE FUNCTION(igraph_matrix, sum)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT BASE FUNCTION(igraph_matrix, prod)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, rowsum)(const TYPE(igraph_matrix) *m,
                                                  TYPE(igraph_vector) *res);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, colsum)(const TYPE(igraph_matrix) *m,
                                                  TYPE(igraph_vector) *res);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, is_equal)(const TYPE(igraph_matrix) *m1,
                                                              const TYPE(igraph_matrix) *m2);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_real_t FUNCTION(igraph_matrix, maxdifference)(const TYPE(igraph_matrix) *m1,
                                                                   const TYPE(igraph_matrix) *m2);
#endif

/*------------------------*/
/* Searching for elements */
/*------------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, contains)(const TYPE(igraph_matrix) *m,
                                                              BASE e);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_matrix, search)(const TYPE(igraph_matrix) *m,
                                                            long int from, BASE what,
                                                            long int *pos,
                                                            long int *row, long int *col);

/*------------------------*/
/* Resizing operations    */
/*------------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, resize)(TYPE(igraph_matrix) *m,
                                                  long int nrow, long int ncol);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, resize_min)(TYPE(igraph_matrix) *m);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, add_cols)(TYPE(igraph_matrix) *m, long int n);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, add_rows)(TYPE(igraph_matrix) *m, long int n);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, remove_col)(TYPE(igraph_matrix) *m, long int col);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, remove_row)(TYPE(igraph_matrix) *m, long int row);

/*------------------------*/
/* Print as text          */
/*------------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_matrix, print)(const TYPE(igraph_matrix) *m);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, printf)(const TYPE(igraph_matrix) *m,
                                                  const char *format);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, fprint)(const TYPE(igraph_matrix) *m,
                                                  FILE *file);

#ifdef BASE_COMPLEX

IGRAPH_EXPORT int igraph_matrix_complex_real(const igraph_matrix_complex_t *v,
                               igraph_matrix_t *real);
IGRAPH_EXPORT int igraph_matrix_complex_imag(const igraph_matrix_complex_t *v,
                               igraph_matrix_t *imag);
IGRAPH_EXPORT int igraph_matrix_complex_realimag(const igraph_matrix_complex_t *v,
                                   igraph_matrix_t *real,
                                   igraph_matrix_t *imag);
IGRAPH_EXPORT int igraph_matrix_complex_create(igraph_matrix_complex_t *v,
                                 const igraph_matrix_t *real,
                                 const igraph_matrix_t *imag);
IGRAPH_EXPORT int igraph_matrix_complex_create_polar(igraph_matrix_complex_t *v,
                                       const igraph_matrix_t *r,
                                       const igraph_matrix_t *theta);

#endif

IGRAPH_EXPORT int FUNCTION(igraph_matrix, permdelete_rows)(TYPE(igraph_matrix) *m,
                                                           long int *index, long int nremove);
IGRAPH_EXPORT int FUNCTION(igraph_matrix, delete_rows_neg)(TYPE(igraph_matrix) *m,
                                                           const igraph_vector_t *neg,
                                                           long int nremove);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_memory.h0000644000175100001710000000266600000000000024322 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MEMORY_H
#define IGRAPH_MEMORY_H

#include 
#include "igraph_decls.h"

__BEGIN_DECLS

#define IGRAPH_CALLOC(n,t)    (t*) calloc( (n) > 0 ? (size_t)(n) : (size_t)1, sizeof(t) )
#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1)
#define IGRAPH_FREE(p)        (free( (void *)(p) ), (p) = NULL)

#define igraph_Calloc IGRAPH_CALLOC
#define igraph_Realloc IGRAPH_REALLOC
#define igraph_Free IGRAPH_FREE

IGRAPH_EXPORT void igraph_free(void *p);
IGRAPH_EXPORT void *igraph_malloc(size_t n);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_microscopic_update.h0000644000175100001710000000550300000000000026657 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Microscopic update rules for dealing with agent-level strategy revision.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#ifndef IGRAPH_MICROSCOPIC_UPDATE_H
#define IGRAPH_MICROSCOPIC_UPDATE_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"
#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_deterministic_optimal_imitation(const igraph_t *graph,
                                                         igraph_integer_t vid,
                                                         igraph_optimal_t optimality,
                                                         const igraph_vector_t *quantities,
                                                         igraph_vector_t *strategies,
                                                         igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_moran_process(const igraph_t *graph,
                                       const igraph_vector_t *weights,
                                       igraph_vector_t *quantities,
                                       igraph_vector_t *strategies,
                                       igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_roulette_wheel_imitation(const igraph_t *graph,
                                                  igraph_integer_t vid,
                                                  igraph_bool_t islocal,
                                                  const igraph_vector_t *quantities,
                                                  igraph_vector_t *strategies,
                                                  igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_stochastic_imitation(const igraph_t *graph,
                                              igraph_integer_t vid,
                                              igraph_imitate_algorithm_t algo,
                                              const igraph_vector_t *quantities,
                                              igraph_vector_t *strategies,
                                              igraph_neimode_t mode);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_mixing.h0000644000175100001710000000354500000000000024302 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MIXING_H
#define IGRAPH_MIXING_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_vector.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_assortativity_nominal(const igraph_t *graph,
                                               const igraph_vector_t *types,
                                               igraph_real_t *res,
                                               igraph_bool_t directed);

IGRAPH_EXPORT int igraph_assortativity(const igraph_t *graph,
                                       const igraph_vector_t *types1,
                                       const igraph_vector_t *types2,
                                       igraph_real_t *res,
                                       igraph_bool_t directed);

IGRAPH_EXPORT int igraph_assortativity_degree(const igraph_t *graph,
                                              igraph_real_t *res,
                                              igraph_bool_t directed);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_motifs.h0000644000175100001710000001027700000000000024310 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MOTIFS_H
#define IGRAPH_MOTIFS_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Graph motifs                                       */
/* -------------------------------------------------- */

/**
 * \typedef igraph_motifs_handler_t
 * Callback type for \c igraph_motifs_randesu_callback
 *
 * \ref igraph_motifs_randesu_callback() calls a specified callback
 * function whenever a new motif is found during a motif search. This
 * callback function must be of type \c igraph_motifs_handler_t. It has
 * the following arguments:
 * \param graph The graph that that algorithm is working on. Of course
 *   this must not be modified.
 * \param vids The IDs of the vertices in the motif that has just been
 *   found. This vector is owned by the motif search algorithm, so do not
 *   modify or destroy it; make a copy of it if you need it later.
 * \param isoclass The isomorphism class of the motif that has just been
 *   found. Use \ref igraph_isoclass or \ref igraph_isoclass_subgraph to find
 *   out which isomorphism class belongs to a given motif.
 * \param extra The extra argument that was passed to \ref
 *   igraph_motifs_randesu_callback().
 * \return A logical value, if TRUE (=non-zero), that is interpreted
 *    as a request to stop the motif search and return to the caller.
 *
 * \sa \ref igraph_motifs_randesu_callback()
 */

typedef igraph_bool_t igraph_motifs_handler_t(const igraph_t *graph,
        igraph_vector_t *vids,
        int isoclass,
        void* extra);

IGRAPH_EXPORT int igraph_motifs_randesu(const igraph_t *graph, igraph_vector_t *hist,
                                        int size, const igraph_vector_t *cut_prob);

IGRAPH_EXPORT int igraph_motifs_randesu_callback(const igraph_t *graph, int size,
                                                 const igraph_vector_t *cut_prob,
                                                 igraph_motifs_handler_t *callback,
                                                 void* extra);

IGRAPH_EXPORT int igraph_motifs_randesu_estimate(const igraph_t *graph, igraph_integer_t *est,
                                                 int size, const igraph_vector_t *cut_prob,
                                                 igraph_integer_t sample_size,
                                                 const igraph_vector_t *sample);
IGRAPH_EXPORT int igraph_motifs_randesu_no(const igraph_t *graph, igraph_integer_t *no,
                                           int size, const igraph_vector_t *cut_prob);

IGRAPH_EXPORT int igraph_dyad_census(const igraph_t *graph, igraph_integer_t *mut,
                                     igraph_integer_t *asym, igraph_integer_t *null);
IGRAPH_EXPORT int igraph_triad_census(const igraph_t *igraph, igraph_vector_t *res);
IGRAPH_EXPORT int igraph_triad_census_24(const igraph_t *graph, igraph_real_t *res2,
                                         igraph_real_t *res4);

IGRAPH_EXPORT int igraph_adjacent_triangles(const igraph_t *graph,
                                            igraph_vector_t *res,
                                            const igraph_vs_t vids);

IGRAPH_EXPORT int igraph_list_triangles(const igraph_t *graph,
                                        igraph_vector_int_t *res);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_neighborhood.h0000644000175100001710000000362000000000000025450 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_NEIGHBORHOOD_H
#define IGRAPH_NEIGHBORHOOD_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_neighborhood_size(const igraph_t *graph, igraph_vector_t *res,
                                           igraph_vs_t vids, igraph_integer_t order,
                                           igraph_neimode_t mode, igraph_integer_t mindist);
IGRAPH_EXPORT int igraph_neighborhood(const igraph_t *graph, igraph_vector_ptr_t *res,
                                      igraph_vs_t vids, igraph_integer_t order,
                                      igraph_neimode_t mode, igraph_integer_t mindist);
IGRAPH_EXPORT int igraph_neighborhood_graphs(const igraph_t *graph, igraph_vector_ptr_t *res,
                                             igraph_vs_t vids, igraph_integer_t order,
                                             igraph_neimode_t mode,
                                             igraph_integer_t mindist);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_nongraph.h0000644000175100001710000001001500000000000024611 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_NONGRAPH_H
#define IGRAPH_NONGRAPH_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_matrix.h"
#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Other, not graph related                           */
/* -------------------------------------------------- */

/**
 * \struct igraph_plfit_result_t
 * \brief Result of fitting a power-law distribution to a vector
 *
 * This data structure contains the result of \ref igraph_power_law_fit(),
 * which tries to fit a power-law distribution to a vector of numbers. The
 * structure contains the following members:
 *
 * \member continuous Whether the fitted power-law distribution was continuous
 *                    or discrete.
 * \member alpha The exponent of the fitted power-law distribution.
 * \member xmin  The minimum value from which the power-law distribution was
 *               fitted. In other words, only the values larger than \c xmin
 *               were used from the input vector.
 * \member L     The log-likelihood of the fitted parameters; in other words,
 *               the probability of observing the input vector given the
 *               parameters.
 * \member D     The test statistic of a Kolmogorov-Smirnov test that compares
 *               the fitted distribution with the input vector. Smaller scores
 *               denote better fit.
 * \member p     The p-value of the Kolmogorov-Smirnov test. Small p-values
 *               (less than 0.05) indicate that the test rejected the hypothesis
 *               that the original data could have been drawn from the fitted
 *               power-law distribution.
 */
typedef struct igraph_plfit_result_t {
    igraph_bool_t continuous;
    double alpha;
    double xmin;
    double L;
    double D;
    double p;
} igraph_plfit_result_t;

IGRAPH_EXPORT int igraph_running_mean(const igraph_vector_t *data, igraph_vector_t *res,
                                      igraph_integer_t binwidth);
IGRAPH_EXPORT int igraph_random_sample(igraph_vector_t *res, igraph_real_t l, igraph_real_t h,
                                       igraph_integer_t length);
IGRAPH_EXPORT int igraph_convex_hull(const igraph_matrix_t *data, igraph_vector_t *resverts,
                                     igraph_matrix_t *rescoords);
IGRAPH_EXPORT int igraph_zeroin(igraph_real_t *ax, igraph_real_t *bx,
                                igraph_real_t (*f)(igraph_real_t x, void *info),
                                void *info, igraph_real_t *Tol, int *Maxit, igraph_real_t *res);
IGRAPH_EXPORT int igraph_bfgs(igraph_vector_t *b, igraph_real_t *Fmin,
                              igraph_scalar_function_t fminfn, igraph_vector_function_t fmingr,
                              int maxit, int trace,
                              igraph_real_t abstol, igraph_real_t reltol, int nREPORT, void *ex,
                              igraph_integer_t *fncount, igraph_integer_t *grcount);
IGRAPH_EXPORT int igraph_power_law_fit(const igraph_vector_t* vector, igraph_plfit_result_t* result,
                                       igraph_real_t xmin, igraph_bool_t force_continuous);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_operators.h0000644000175100001710000001100700000000000025015 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_OPERATORS_H
#define IGRAPH_OPERATORS_H

#include "igraph_decls.h"
#include "igraph_attributes.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Graph operators                                    */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_add_edge(igraph_t *graph, igraph_integer_t from, igraph_integer_t to);
IGRAPH_EXPORT int igraph_disjoint_union(igraph_t *res,
                                        const igraph_t *left, const igraph_t *right);
IGRAPH_EXPORT int igraph_disjoint_union_many(igraph_t *res,
                                             const igraph_vector_ptr_t *graphs);
IGRAPH_EXPORT int igraph_union(igraph_t *res, const igraph_t *left, const igraph_t *right,
                               igraph_vector_t *edge_map1, igraph_vector_t *edge_map2);
IGRAPH_EXPORT int igraph_union_many(igraph_t *res, const igraph_vector_ptr_t *graphs,
                                    igraph_vector_ptr_t *edgemaps);
IGRAPH_EXPORT int igraph_intersection(igraph_t *res,
                                      const igraph_t *left, const igraph_t *right,
                                      igraph_vector_t *edge_map1,
                                      igraph_vector_t *edge_map2);
IGRAPH_EXPORT int igraph_intersection_many(igraph_t *res,
                                           const igraph_vector_ptr_t *graphs,
                                           igraph_vector_ptr_t *edgemaps);
IGRAPH_EXPORT int igraph_difference(igraph_t *res,
                                    const igraph_t *orig, const igraph_t *sub);
IGRAPH_EXPORT int igraph_complementer(igraph_t *res, const igraph_t *graph,
                                      igraph_bool_t loops);
IGRAPH_EXPORT int igraph_compose(igraph_t *res, const igraph_t *g1, const igraph_t *g2,
                                 igraph_vector_t *edge_map1, igraph_vector_t *edge_map2);
IGRAPH_EXPORT int igraph_contract_vertices(igraph_t *graph,
                                           const igraph_vector_t *mapping,
                                           const igraph_attribute_combination_t
                                     *vertex_comb);
IGRAPH_EXPORT int igraph_permute_vertices(const igraph_t *graph, igraph_t *res,
                                          const igraph_vector_t *permutation);
IGRAPH_EXPORT int igraph_connect_neighborhood(igraph_t *graph, igraph_integer_t order,
                                              igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_rewire(igraph_t *graph,
                                igraph_integer_t n, igraph_rewiring_t mode);
IGRAPH_EXPORT int igraph_simplify(igraph_t *graph, igraph_bool_t multiple,
                                  igraph_bool_t loops,
                                  const igraph_attribute_combination_t *edge_comb);
IGRAPH_EXPORT int igraph_induced_subgraph_map(const igraph_t *graph, igraph_t *res,
                                              const igraph_vs_t vids,
                                              igraph_subgraph_implementation_t impl,
                                              igraph_vector_t *map,
                                              igraph_vector_t *invmap);
IGRAPH_EXPORT int igraph_induced_subgraph(const igraph_t *graph, igraph_t *res,
                                          const igraph_vs_t vids, igraph_subgraph_implementation_t impl);
IGRAPH_EXPORT int igraph_subgraph_edges(const igraph_t *graph, igraph_t *res,
                                        const igraph_es_t eids, igraph_bool_t delete_vertices);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_paths.h0000644000175100001710000002536600000000000024133 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#ifndef IGRAPH_PATHS_H
#define IGRAPH_PATHS_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_matrix.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_diameter(const igraph_t *graph, igraph_real_t *res,
                                  igraph_integer_t *from, igraph_integer_t *to,
                                  igraph_vector_t *path,
                                  igraph_bool_t directed, igraph_bool_t unconn);
IGRAPH_EXPORT int igraph_diameter_dijkstra(const igraph_t *graph,
                                           const igraph_vector_t *weights,
                                           igraph_real_t *pres,
                                           igraph_integer_t *pfrom,
                                           igraph_integer_t *pto,
                                           igraph_vector_t *path,
                                           igraph_bool_t directed,
                                           igraph_bool_t unconn);

IGRAPH_EXPORT int igraph_shortest_paths(const igraph_t *graph, igraph_matrix_t *res,
                                        const igraph_vs_t from, const igraph_vs_t to,
                                        igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_get_shortest_paths(const igraph_t *graph,
                                            igraph_vector_ptr_t *vertices,
                                            igraph_vector_ptr_t *edges,
                                            igraph_integer_t from, const igraph_vs_t to,
                                            igraph_neimode_t mode,
                                            igraph_vector_long_t *predecessors,
                                            igraph_vector_long_t *inbound_edges);
IGRAPH_EXPORT int igraph_get_shortest_path(const igraph_t *graph,
                                           igraph_vector_t *vertices,
                                           igraph_vector_t *edges,
                                           igraph_integer_t from,
                                           igraph_integer_t to,
                                           igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_get_all_shortest_paths(const igraph_t *graph,
                                                igraph_vector_ptr_t *res,
                                                igraph_vector_t *nrgeo,
                                                igraph_integer_t from, const igraph_vs_t to,
                                                igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_shortest_paths_dijkstra(const igraph_t *graph,
                                                 igraph_matrix_t *res,
                                                 const igraph_vs_t from,
                                                 const igraph_vs_t to,
                                                 const igraph_vector_t *weights,
                                                 igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_shortest_paths_bellman_ford(const igraph_t *graph,
                                                     igraph_matrix_t *res,
                                                     const igraph_vs_t from,
                                                     const igraph_vs_t to,
                                                     const igraph_vector_t *weights,
                                                     igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_get_shortest_path_bellman_ford(const igraph_t *graph,
                                                        igraph_vector_t *vertices,
                                                        igraph_vector_t *edges,
                                                        igraph_integer_t from,
                                                        igraph_integer_t to,
                                                        const igraph_vector_t *weights,
                                                        igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_get_shortest_paths_dijkstra(const igraph_t *graph,
                                                     igraph_vector_ptr_t *vertices,
                                                     igraph_vector_ptr_t *edges,
                                                     igraph_integer_t from,
                                                     igraph_vs_t to,
                                                     const igraph_vector_t *weights,
                                                     igraph_neimode_t mode,
                                                     igraph_vector_long_t *predecessors,
                                                     igraph_vector_long_t *inbound_edges);
IGRAPH_EXPORT int igraph_get_shortest_paths_bellman_ford(const igraph_t *graph,
                                                      igraph_vector_ptr_t *vertices,
                                                      igraph_vector_ptr_t *edges,
                                                      igraph_integer_t from,
                                                      igraph_vs_t to,
                                                      const igraph_vector_t *weights,
                                                      igraph_neimode_t mode,
                                                      igraph_vector_long_t *predecessors,
                                                      igraph_vector_long_t *inbound_edges);
IGRAPH_EXPORT int igraph_get_shortest_path_dijkstra(const igraph_t *graph,
                                                    igraph_vector_t *vertices,
                                                    igraph_vector_t *edges,
                                                    igraph_integer_t from,
                                                    igraph_integer_t to,
                                                    const igraph_vector_t *weights,
                                                    igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_get_all_shortest_paths_dijkstra(const igraph_t *graph,
                                                         igraph_vector_ptr_t *res,
                                                         igraph_vector_t *nrgeo,
                                                         igraph_integer_t from, igraph_vs_t to,
                                                         const igraph_vector_t *weights,
                                                         igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_shortest_paths_johnson(const igraph_t *graph,
                                                igraph_matrix_t *res,
                                                const igraph_vs_t from,
                                                const igraph_vs_t to,
                                                const igraph_vector_t *weights);

IGRAPH_EXPORT int igraph_average_path_length(const igraph_t *graph,
                                             igraph_real_t *res, igraph_real_t *unconn_pairs,
                                             igraph_bool_t directed, igraph_bool_t unconn);
IGRAPH_EXPORT int igraph_average_path_length_dijkstra(const igraph_t *graph,
                                                      igraph_real_t *res, igraph_real_t *unconn_pairs,
                                                      const igraph_vector_t *weights,
                                                      igraph_bool_t directed, igraph_bool_t unconn);
IGRAPH_EXPORT int igraph_path_length_hist(const igraph_t *graph, igraph_vector_t *res,
                                          igraph_real_t *unconnected, igraph_bool_t directed);

IGRAPH_EXPORT int igraph_global_efficiency(const igraph_t *graph, igraph_real_t *res,
                                           const igraph_vector_t *weights,
                                           igraph_bool_t directed);
IGRAPH_EXPORT int igraph_local_efficiency(const igraph_t *graph, igraph_vector_t *res,
                                          const igraph_vs_t vids,
                                          const igraph_vector_t *weights,
                                          igraph_bool_t directed, igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_average_local_efficiency(const igraph_t *graph, igraph_real_t *res,
                                                  const igraph_vector_t *weights,
                                                  igraph_bool_t directed, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_eccentricity(const igraph_t *graph,
                                      igraph_vector_t *res,
                                      igraph_vs_t vids,
                                      igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_radius(const igraph_t *graph, igraph_real_t *radius,
                                igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_get_all_simple_paths(const igraph_t *graph,
                                              igraph_vector_int_t *res,
                                              igraph_integer_t from,
                                              const igraph_vs_t to,
                                              igraph_integer_t cutoff,
                                              igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_random_walk(const igraph_t *graph, igraph_vector_t *walk,
                                     igraph_integer_t start, igraph_neimode_t mode,
                                     igraph_integer_t steps,
                                     igraph_random_walk_stuck_t stuck);

IGRAPH_EXPORT int igraph_random_edge_walk(const igraph_t *graph,
                                          const igraph_vector_t *weights,
                                          igraph_vector_t *edgewalk,
                                          igraph_integer_t start, igraph_neimode_t mode,
                                          igraph_integer_t steps,
                                          igraph_random_walk_stuck_t stuck);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_pmt.h0000644000175100001710000001004200000000000023575 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#define CONCAT2x(a,b) a ## _ ## b
#define CONCAT2(a,b) CONCAT2x(a,b)
#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c
#define CONCAT3(a,b,c) CONCAT3x(a,b,c)
#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d
#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d)

#if defined(BASE_IGRAPH_REAL)
    #define BASE igraph_real_t
    #define SHORT
    #define OUT_FORMAT "%G"
    #define PRINTFUNC(val) igraph_real_printf(val)
    #define FPRINTFUNC(file, val) igraph_real_fprintf(file, val)
    #define ZERO 0.0
    #define ONE 1.0
    #define MULTIPLICITY 1

#elif defined(BASE_FLOAT)
    #define BASE float
    #define SHORT float
    #define OUT_FORMAT "%f"
    #define ZERO 0.0F
    #define ONE 1.0F
    #define MULTIPLICITY 1

#elif defined(BASE_LONG)
    #define BASE long
    #define SHORT long
    #define OUT_FORMAT "%ld"
    #define ZERO 0L
    #define ONE 1L
    #define MULTIPLICITY 1

#elif defined(BASE_CHAR)
    #define BASE char
    #define SHORT char
    #define OUT_FORMAT "%d"
    #define ZERO 0
    #define ONE 1
    #define MULTIPLICITY 1

#elif defined(BASE_BOOL)
    #define BASE igraph_bool_t
    #define SHORT bool
    #define OUT_FORMAT "%d"
    #define ZERO 0
    #define ONE 1
    #define MULTIPLICITY 1
    #define NOTORDERED 1
    #define NOABS 1
    #define EQ(a,b) ((a && b) || (!a && !b))

#elif defined(BASE_INT)
    #define BASE igraph_integer_t
    #define SHORT int
    #define OUT_FORMAT "%" IGRAPH_PRId
    #define ZERO 0
    #define ONE 1
    #define MULTIPLICITY 1

#elif defined(BASE_PTR)
    #define BASE void*
    #define SHORT ptr
    #define ZERO 0
    #define MULTIPLICITY 1

#elif defined(BASE_COMPLEX)
    #undef complex
    #define BASE igraph_complex_t
    #define SHORT complex
    #define ZERO igraph_complex(0,0)
    #define ONE {{1.0,0.0}}
    #define MULTIPLICITY 2
    #define NOTORDERED 1
    #define NOABS 1
    #define SUM(a,b,c) ((a) = igraph_complex_add((b),(c)))
    #define DIFF(a,b,c) ((a) = igraph_complex_sub((b),(c)))
    #define PROD(a,b,c) ((a) = igraph_complex_mul((b),(c)))
    #define DIV(a,b,c) ((a) = igraph_complex_div((b),(c)))
    #define EQ(a,b) IGRAPH_COMPLEX_EQ((a),(b))
    #define SQ(a) IGRAPH_REAL(igraph_complex_mul((a),(a)))

#else
    #error unknown BASE_ directive
#endif

#if defined(BASE_IGRAPH_REAL)
    #define FUNCTION(dir,name) CONCAT2(dir,name)
    #define TYPE(dir) CONCAT2(dir,t)
#elif defined(BASE_BOOL)
    /* Special case because stdbool.h defines bool as a macro to _Bool which would
    * screw things up */
    #define FUNCTION(a,c) CONCAT3x(a,bool,c)
    #define TYPE(dir) CONCAT3x(dir,bool,t)
#else
    #define FUNCTION(a,c) CONCAT3(a,SHORT,c)
    #define TYPE(dir) CONCAT3(dir,SHORT,t)
#endif

#if defined(HEAP_TYPE_MIN)
    #define HEAPMORE <
    #define HEAPMOREEQ <=
    #define HEAPLESS >
    #define HEAPLESSEQ >=
    #undef FUNCTION
    #undef TYPE
    #if defined(BASE_IGRAPH_REAL)
        #define FUNCTION(dir,name) CONCAT3(dir,min,name)
        #define TYPE(dir) CONCAT3(dir,min,t)
    #else
        #define FUNCTION(a,c) CONCAT4(a,min,SHORT,c)
        #define TYPE(dir) CONCAT4(dir,min,SHORT,t)
    #endif
#endif

#if defined(HEAP_TYPE_MAX)
    #define HEAPMORE >
    #define HEAPMOREEQ >=
    #define HEAPLESS <
    #define HEAPLESSEQ <=
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_pmt_off.h0000644000175100001710000000436000000000000024435 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifdef ATOMIC
    #undef ATOMIC
#endif

#ifdef ATOMIC_IO
    #undef ATOMIC_IO
#endif

#ifdef BASE
    #undef BASE
#endif

#ifdef BASE_EPSILON
    #undef BASE_EPSILON
#endif

#ifdef CONCAT2
    #undef CONCAT2
#endif

#ifdef CONCAT2x
    #undef CONCAT2x
#endif

#ifdef CONCAT3
    #undef CONCAT3
#endif

#ifdef CONCAT3x
    #undef CONCAT3x
#endif

#ifdef CONCAT4
    #undef CONCAT4
#endif

#ifdef CONCAT4x
    #undef CONCAT4x
#endif

#ifdef FP
    #undef FP
#endif

#ifdef FUNCTION
    #undef FUNCTION
#endif

#ifdef IN_FORMAT
    #undef IN_FORMAT
#endif

#ifdef MULTIPLICITY
    #undef MULTIPLICITY
#endif

#ifdef ONE
    #undef ONE
#endif

#ifdef OUT_FORMAT
    #undef OUT_FORMAT
#endif

#ifdef SHORT
    #undef SHORT
#endif

#ifdef TYPE
    #undef TYPE
#endif

#ifdef ZERO
    #undef ZERO
#endif

#ifdef HEAPMORE
    #undef HEAPMORE
#endif

#ifdef HEAPLESS
    #undef HEAPLESS
#endif

#ifdef HEAPMOREEQ
    #undef HEAPMOREEQ
#endif

#ifdef HEAPLESSEQ
    #undef HEAPLESSEQ
#endif

#ifdef SUM
    #undef SUM
#endif

#ifdef SQ
    #undef SQ
#endif

#ifdef PROD
    #undef PROD
#endif

#ifdef NOTORDERED
    #undef NOTORDERED
#endif

#ifdef EQ
    #undef EQ
#endif

#ifdef DIFF
    #undef DIFF
#endif

#ifdef DIV
    #undef DIV
#endif

#ifdef NOABS
    #undef NOABS
#endif

#ifdef PRINTFUNC
    #undef PRINTFUNC
#endif

#ifdef FPRINTFUNC
    #undef PRINTFUNC
#endif

#ifdef UNSIGNED
    #undef UNSIGNED
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_progress.h0000644000175100001710000001541600000000000024653 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_PROGRESS_H
#define IGRAPH_PROGRESS_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

/**
 * \section about_progress_handlers About progress handlers
 *
 * It is often useful to report the progress of some long
 * calculation, to allow the user to follow the computation and
 * guess the total running time. A couple of igraph functions
 * support this at the time of writing, hopefully more will support it
 * in the future.
 * 
 *
 * 
 * To see the progress of a computation, the user has to install a
 * progress handler, as there is none installed by default.
 * If an igraph function supports progress reporting, then it
 * calls the installed progress handler periodically, and passes a
 * percentage value to it, the percentage of computation already
 * performed. To install a progress handler, you need to call
 * \ref igraph_set_progress_handler(). Currently there is a single
 * pre-defined progress handler, called \ref
 * igraph_progress_handler_stderr().
 * 
 */

/**
 * \section writing_progress_handlers Writing progress handlers
 *
 * 
 * To write a new progress handler, one needs to create a function of
 * type \ref igraph_progress_handler_t. The new progress handler
 * can then be installed with the \ref igraph_set_progress_handler()
 * function.
 * 
 *
 * 
 * One can assume that the first progress handler call from a
 * calculation will be call with zero as the \p percentage argument,
 * and the last call from a function will have 100 as the \p
 * percentage argument. Note, however, that if an error happens in the
 * middle of a computation, then the 100 percent call might be
 * omitted.
 * 
 */

/**
 * \section igraph_functions_with_progress Writing igraph functions with progress reporting
 *
 * 
 * If you want to write a function that uses igraph and supports
 * progress reporting, you need to include \ref igraph_progress()
 * calls in your function, usually via the \ref IGRAPH_PROGRESS()
 * macro.
 * 
 *
 * 
 * It is good practice to always include a call to \ref
 * igraph_progress() with a zero \p percentage argument, before the
 * computation; and another call with 100 \p percentage value
 * after the computation is completed.
 * 
 *
 * 
 * It is also good practice \em not to call \ref igraph_progress() too
 * often, as this would slow down the computation. It might not be
 * worth to support progress reporting in functions with linear or
 * log-linear time complexity, as these are fast, even with a large
 * amount of data. For functions with quadratic or higher time
 * complexity make sure that the time complexity of the progress
 * reporting is constant or at least linear. In practice this means
 * having at most O(n) progress checks and at most 100
 * \ref igraph_progress() calls.
 * 
 */

/**
 * \section progress_and_threads Multi-threaded programs
 *
 * 
 * In multi-threaded programs, each thread has its own progress
 * handler, if thread-local storage is supported and igraph is
 * thread-safe. See the \ref IGRAPH_THREAD_SAFE macro for checking
 * whether an igraph build is thread-safe.
 * 
 */

/* -------------------------------------------------- */
/* Progress handlers                                  */
/* -------------------------------------------------- */

/**
 * \typedef igraph_progress_handler_t
 * \brief Type of progress handler functions
 *
 * This is the type of the igraph progress handler functions.
 * There is currently one such predefined function,
 * \ref igraph_progress_handler_stderr(), but the user can
 * write and set up more sophisticated ones.
 * \param message A string describing the function or algorithm
 *     that is reporting the progress. Current igraph functions
 *     always use the name \p message argument if reporting from the
 *     same function.
 * \param percent Numeric, the percentage that was completed by the
 *     algorithm or function.
 * \param data User-defined data. Current igraph functions that
 *     report progress pass a null pointer here. Users can
 *     write their own progress handlers and functions with progress
 *     reporting, and then pass some meaningfull context here.
 * \return If the return value of the progress handler is not
 *     \c IGRAPH_SUCCESS, then \ref igraph_progress() returns the
 *     error code \c IGRAPH_INTERRUPTED. The \ref IGRAPH_PROGRESS()
 *     macro frees all memory and finishes the igraph function with
 *     error code \c IGRAPH_INTERRUPTED in this case.
 */

typedef int igraph_progress_handler_t(const char *message, igraph_real_t percent,
                                      void *data);

IGRAPH_EXPORT extern igraph_progress_handler_t igraph_progress_handler_stderr;

IGRAPH_EXPORT igraph_progress_handler_t * igraph_set_progress_handler(igraph_progress_handler_t new_handler);

IGRAPH_EXPORT int igraph_progress(const char *message, igraph_real_t percent, void *data);

IGRAPH_EXPORT int igraph_progressf(const char *message, igraph_real_t percent, void *data,
                                   ...);

/**
 * \define IGRAPH_PROGRESS
 * \brief Report progress.
 *
 * The standard way to report progress from an igraph function
 * \param message A string, a textual message that references the
 *    calculation under progress.
 * \param percent Numeric scalar, the percentage that is complete.
 * \param data User-defined data, this can be used in user-defined
 *    progress handler functions, from user-written igraph functions.
 * \return If the progress handler returns with \c IGRAPH_INTERRUPTED,
 *    then this macro frees up the igraph allocated memory for
 *    temporary data and returns to the caller with \c
 *    IGRAPH_INTERRUPTED.
 */

#define IGRAPH_PROGRESS(message, percent, data) \
    do { \
        if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \
            IGRAPH_FINALLY_FREE(); \
            return IGRAPH_INTERRUPTED; \
        } \
    } while (0)

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_psumtree.h0000644000175100001710000000350700000000000024651 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_PSUMTREE_H
#define IGRAPH_PSUMTREE_H

#include "igraph_decls.h"
#include "igraph_vector.h"

__BEGIN_DECLS

typedef struct {
    igraph_vector_t v;
    long int size;
    long int offset;
} igraph_psumtree_t;

IGRAPH_EXPORT int igraph_psumtree_init(igraph_psumtree_t *t, long int size);
IGRAPH_EXPORT void igraph_psumtree_reset(igraph_psumtree_t *t);
IGRAPH_EXPORT void igraph_psumtree_destroy(igraph_psumtree_t *t);
IGRAPH_EXPORT igraph_real_t igraph_psumtree_get(const igraph_psumtree_t *t, long int idx);
IGRAPH_EXPORT long int igraph_psumtree_size(const igraph_psumtree_t *t);
IGRAPH_EXPORT int igraph_psumtree_search(const igraph_psumtree_t *t, long int *idx,
                                         igraph_real_t elem);
IGRAPH_EXPORT int igraph_psumtree_update(igraph_psumtree_t *t, long int idx,
                                         igraph_real_t new_value);
IGRAPH_EXPORT igraph_real_t igraph_psumtree_sum(const igraph_psumtree_t *t);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_qsort.h0000644000175100001710000000245400000000000024155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA 02139, USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_QSORT_H
#define IGRAPH_QSORT_H

#include "igraph_decls.h"

#include 

__BEGIN_DECLS

IGRAPH_EXPORT void igraph_qsort(void *base, size_t nel, size_t width,
                                int (*compar)(const void *, const void *));
IGRAPH_EXPORT void igraph_qsort_r(void *base, size_t nel, size_t width, void *thunk,
                                  int (*compar)(void *, const void *, const void *));

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_random.h0000644000175100001710000001215200000000000024261 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_RANDOM_H
#define IGRAPH_RANDOM_H

#include "igraph_decls.h"

__BEGIN_DECLS

#include 
#include 

#include "igraph_types.h"
#include "igraph_vector.h"

/* The new RNG interface is (somewhat) modelled based on the GSL */

typedef struct igraph_rng_type_t {
    const char *name;
    unsigned long int min; /* 'min' must always be set to 0 */
    unsigned long int max;
    int (*init)(void **state);
    void (*destroy)(void *state);
    int (*seed)(void *state, unsigned long int seed);
    unsigned long int (*get)(void *state);
    igraph_real_t (*get_real)(void *state);
    igraph_real_t (*get_norm)(void *state);
    igraph_real_t (*get_geom)(void *state, igraph_real_t p);
    igraph_real_t (*get_binom)(void *state, long int n, igraph_real_t p);
    igraph_real_t (*get_exp)(void *state, igraph_real_t rate);
    igraph_real_t (*get_gamma)(void *state, igraph_real_t shape,
                               igraph_real_t scale);
} igraph_rng_type_t;

typedef struct igraph_rng_t {
    const igraph_rng_type_t *type;
    void *state;
    int def;
} igraph_rng_t;

/* --------------------------------- */

IGRAPH_EXPORT int igraph_rng_init(igraph_rng_t *rng, const igraph_rng_type_t *type);
IGRAPH_EXPORT void igraph_rng_destroy(igraph_rng_t *rng);

IGRAPH_EXPORT int igraph_rng_seed(igraph_rng_t *rng, unsigned long int seed);
IGRAPH_EXPORT unsigned long int igraph_rng_max(igraph_rng_t *rng);
IGRAPH_EXPORT IGRAPH_DEPRECATED unsigned long int igraph_rng_min(igraph_rng_t *rng);
IGRAPH_EXPORT const char *igraph_rng_name(igraph_rng_t *rng);

IGRAPH_EXPORT long int igraph_rng_get_integer(igraph_rng_t *rng,
                                              long int l, long int h);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_normal(igraph_rng_t *rng,
                                                  igraph_real_t m, igraph_real_t s);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_unif(igraph_rng_t *rng,
                                                igraph_real_t l, igraph_real_t h);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_unif01(igraph_rng_t *rng);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_geom(igraph_rng_t *rng, igraph_real_t p);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_binom(igraph_rng_t *rng, long int n,
                                                 igraph_real_t p);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_exp(igraph_rng_t *rng, igraph_real_t rate);
IGRAPH_EXPORT unsigned long int igraph_rng_get_int31(igraph_rng_t *rng);
IGRAPH_EXPORT igraph_real_t igraph_rng_get_gamma(igraph_rng_t *rng, igraph_real_t shape,
                                                 igraph_real_t scale);
IGRAPH_EXPORT int igraph_rng_get_dirichlet(igraph_rng_t *rng,
                                           const igraph_vector_t *alpha,
                                           igraph_vector_t *result);

/* --------------------------------- */

IGRAPH_EXPORT extern const igraph_rng_type_t igraph_rngtype_glibc2;
IGRAPH_EXPORT extern const igraph_rng_type_t igraph_rngtype_rand;
IGRAPH_EXPORT extern const igraph_rng_type_t igraph_rngtype_mt19937;

IGRAPH_EXPORT igraph_rng_t *igraph_rng_default(void);
IGRAPH_EXPORT void igraph_rng_set_default(igraph_rng_t *rng);

/* --------------------------------- */

#ifdef USING_R

void GetRNGstate(void);
void PutRNGstate(void);
#define RNG_BEGIN()    GetRNGstate()
#define RNG_END()      PutRNGstate()

double Rf_dnorm4(double x, double mu, double sigma, int give_log);
#define igraph_dnorm Rf_dnorm4

#else

#define RNG_BEGIN() \
    if (igraph_rng_default()->def == 1) { \
        igraph_rng_seed(igraph_rng_default(), time(0)); \
        igraph_rng_default()->def=2; \
    }
#define RNG_END()       /* do nothing */

IGRAPH_EXPORT double igraph_dnorm(double x, double mu, double sigma, int give_log);

#endif

#define RNG_INTEGER(l,h) (igraph_rng_get_integer(igraph_rng_default(),(l),(h)))
#define RNG_NORMAL(m,s)  (igraph_rng_get_normal(igraph_rng_default(),(m),(s)))
#define RNG_UNIF(l,h)    (igraph_rng_get_unif(igraph_rng_default(),(l),(h)))
#define RNG_UNIF01()     (igraph_rng_get_unif01(igraph_rng_default()))
#define RNG_GEOM(p)      (igraph_rng_get_geom(igraph_rng_default(),(p)))
#define RNG_BINOM(n,p)   (igraph_rng_get_binom(igraph_rng_default(),(n),(p)))
#define RNG_INT31()      (igraph_rng_get_int31(igraph_rng_default()))

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_scan.h0000644000175100001710000000603400000000000023727 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_SCAN_H
#define IGRAPH_SCAN_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_arpack.h"
#include "igraph_constants.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_local_scan_0(const igraph_t *graph, igraph_vector_t *res,
                                      const igraph_vector_t *weights, igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_0_them(const igraph_t *us, const igraph_t *them,
                                           igraph_vector_t *res,
                                           const igraph_vector_t *weigths_them,
                                           igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_1_ecount(const igraph_t *graph, igraph_vector_t *res,
                                             const igraph_vector_t *weights,
                                             igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_1_ecount_them(const igraph_t *us, const igraph_t *them,
                                                  igraph_vector_t *res,
                                                  const igraph_vector_t *weights,
                                                  igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_k_ecount(const igraph_t *graph, int k,
                                             igraph_vector_t *res,
                                             const igraph_vector_t *weights,
                                             igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_k_ecount_them(const igraph_t *us, const igraph_t *them,
                                                  int k, igraph_vector_t *res,
                                                  const igraph_vector_t *weights_them,
                                                  igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_local_scan_neighborhood_ecount(const igraph_t *graph,
                                                        igraph_vector_t *res,
                                                        const igraph_vector_t *weights,
                                                        const igraph_vector_ptr_t *neighborhoods);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_scg.h0000644000175100001710000001604000000000000023555 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_SCG_H
#define IGRAPH_SCG_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"
#include "igraph_sparsemat.h"

__BEGIN_DECLS

typedef enum { IGRAPH_SCG_SYMMETRIC = 1, IGRAPH_SCG_LAPLACIAN = 2,
               IGRAPH_SCG_STOCHASTIC = 3
             } igraph_scg_matrix_t;

typedef enum { IGRAPH_SCG_OPTIMUM = 1, IGRAPH_SCG_INTERV_KM = 2,
               IGRAPH_SCG_INTERV = 3, IGRAPH_SCG_EXACT = 4
             }
igraph_scg_algorithm_t;

typedef enum { IGRAPH_SCG_NORM_ROW = 1, IGRAPH_SCG_NORM_COL = 2 }
igraph_scg_norm_t;

typedef enum { IGRAPH_SCG_DIRECTION_DEFAULT = 1,
               IGRAPH_SCG_DIRECTION_LEFT = 2,
               IGRAPH_SCG_DIRECTION_RIGHT = 3
             } igraph_scg_direction_t;

IGRAPH_EXPORT int igraph_scg_grouping(const igraph_matrix_t *V,
                                      igraph_vector_t *groups,
                                      igraph_integer_t nt,
                                      const igraph_vector_t *nt_vec,
                                      igraph_scg_matrix_t mtype,
                                      igraph_scg_algorithm_t algo,
                                      const igraph_vector_t *p,
                                      igraph_integer_t maxiter);

IGRAPH_EXPORT int igraph_scg_semiprojectors(const igraph_vector_t *groups,
                                            igraph_scg_matrix_t mtype,
                                            igraph_matrix_t *L,
                                            igraph_matrix_t *R,
                                            igraph_sparsemat_t *Lsparse,
                                            igraph_sparsemat_t *Rsparse,
                                            const igraph_vector_t *p,
                                            igraph_scg_norm_t norm);

IGRAPH_EXPORT int igraph_scg_norm_eps(const igraph_matrix_t *V,
                                      const igraph_vector_t *groups,
                                      igraph_vector_t *eps,
                                      igraph_scg_matrix_t mtype,
                                      const igraph_vector_t *p,
                                      igraph_scg_norm_t norm);

IGRAPH_EXPORT int igraph_scg_adjacency(const igraph_t *graph,
                                       const igraph_matrix_t *matrix,
                                       const igraph_sparsemat_t *sparsemat,
                                       const igraph_vector_t *ev,
                                       igraph_integer_t nt,
                                       const igraph_vector_t *nt_vec,
                                       igraph_scg_algorithm_t algo,
                                       igraph_vector_t *values,
                                       igraph_matrix_t *vectors,
                                       igraph_vector_t *groups,
                                       igraph_bool_t use_arpack,
                                       igraph_integer_t maxiter,
                                       igraph_t *scg_graph,
                                       igraph_matrix_t *scg_matrix,
                                       igraph_sparsemat_t *scg_sparsemat,
                                       igraph_matrix_t *L,
                                       igraph_matrix_t *R,
                                       igraph_sparsemat_t *Lsparse,
                                       igraph_sparsemat_t *Rsparse);

IGRAPH_EXPORT int igraph_scg_stochastic(const igraph_t *graph,
                                        const igraph_matrix_t *matrix,
                                        const igraph_sparsemat_t *sparsemat,
                                        const igraph_vector_t *ev,
                                        igraph_integer_t nt,
                                        const igraph_vector_t *nt_vec,
                                        igraph_scg_algorithm_t algo,
                                        igraph_scg_norm_t norm,
                                        igraph_vector_complex_t *values,
                                        igraph_matrix_complex_t *vectors,
                                        igraph_vector_t *groups,
                                        igraph_vector_t *p,
                                        igraph_bool_t use_arpack,
                                        igraph_integer_t maxiter,
                                        igraph_t *scg_graph,
                                        igraph_matrix_t *scg_matrix,
                                        igraph_sparsemat_t *scg_sparsemat,
                                        igraph_matrix_t *L,
                                        igraph_matrix_t *R,
                                        igraph_sparsemat_t *Lsparse,
                                        igraph_sparsemat_t *Rsparse);

IGRAPH_EXPORT int igraph_scg_laplacian(const igraph_t *graph,
                                       const igraph_matrix_t *matrix,
                                       const igraph_sparsemat_t *sparsemat,
                                       const igraph_vector_t *ev,
                                       igraph_integer_t nt,
                                       const igraph_vector_t *nt_vec,
                                       igraph_scg_algorithm_t algo,
                                       igraph_scg_norm_t norm,
                                       igraph_scg_direction_t direction,
                                       igraph_vector_complex_t *values,
                                       igraph_matrix_complex_t *vectors,
                                       igraph_vector_t *groups,
                                       igraph_bool_t use_arpack,
                                       igraph_integer_t maxiter,
                                       igraph_t *scg_graph,
                                       igraph_matrix_t *scg_matrix,
                                       igraph_sparsemat_t *scg_sparsemat,
                                       igraph_matrix_t *L,
                                       igraph_matrix_t *R,
                                       igraph_sparsemat_t *Lsparse,
                                       igraph_sparsemat_t *Rsparse);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_separators.h0000644000175100001710000000354000000000000025165 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_SEPARATORS_H
#define IGRAPH_SEPARATORS_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_is_separator(const igraph_t *graph,
                                      const igraph_vs_t candidate,
                                      igraph_bool_t *res);

IGRAPH_EXPORT int igraph_all_minimal_st_separators(const igraph_t *graph,
                                                   igraph_vector_ptr_t *separators);

IGRAPH_EXPORT int igraph_is_minimal_separator(const igraph_t *graph,
                                              const igraph_vs_t candidate,
                                              igraph_bool_t *res);

IGRAPH_EXPORT int igraph_minimum_size_separators(const igraph_t *graph,
                                                 igraph_vector_ptr_t *separators);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_sparsemat.h0000644000175100001710000003553600000000000025013 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_SPARSEMAT_H
#define IGRAPH_SPARSEMAT_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_datatype.h"
#include "igraph_arpack.h"

#include 

__BEGIN_DECLS

struct cs_di_sparse;
struct cs_di_symbolic;
struct cs_di_numeric;

typedef struct {
    struct cs_di_sparse *cs;
} igraph_sparsemat_t;

typedef struct {
    struct cs_di_symbolic *symbolic;
} igraph_sparsemat_symbolic_t;

typedef struct {
    struct cs_di_numeric *numeric;
} igraph_sparsemat_numeric_t;

typedef enum { IGRAPH_SPARSEMAT_TRIPLET,
               IGRAPH_SPARSEMAT_CC
             } igraph_sparsemat_type_t;

typedef struct {
    igraph_sparsemat_t *mat;
    int pos;
    int col;
} igraph_sparsemat_iterator_t;

IGRAPH_EXPORT int igraph_sparsemat_init(igraph_sparsemat_t *A, int rows, int cols, int nzmax);
IGRAPH_EXPORT int igraph_sparsemat_copy(igraph_sparsemat_t *to,
                                        const igraph_sparsemat_t *from);
IGRAPH_EXPORT void igraph_sparsemat_destroy(igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_realloc(igraph_sparsemat_t *A, int nzmax);

IGRAPH_EXPORT long int igraph_sparsemat_nrow(const igraph_sparsemat_t *A);
IGRAPH_EXPORT long int igraph_sparsemat_ncol(const igraph_sparsemat_t *B);
IGRAPH_EXPORT igraph_sparsemat_type_t igraph_sparsemat_type(const igraph_sparsemat_t *A);
IGRAPH_EXPORT igraph_bool_t igraph_sparsemat_is_triplet(const igraph_sparsemat_t *A);
IGRAPH_EXPORT igraph_bool_t igraph_sparsemat_is_cc(const igraph_sparsemat_t *A);

IGRAPH_EXPORT int igraph_sparsemat_permute(const igraph_sparsemat_t *A,
                                           const igraph_vector_int_t *p,
                                           const igraph_vector_int_t *q,
                                           igraph_sparsemat_t *res);

IGRAPH_EXPORT int igraph_sparsemat_index(const igraph_sparsemat_t *A,
                                         const igraph_vector_int_t *p,
                                         const igraph_vector_int_t *q,
                                         igraph_sparsemat_t *res,
                                         igraph_real_t *constres);

IGRAPH_EXPORT int igraph_sparsemat_entry(igraph_sparsemat_t *A, int row, int col,
                                         igraph_real_t elem);
IGRAPH_EXPORT int igraph_sparsemat_compress(const igraph_sparsemat_t *A,
                                            igraph_sparsemat_t *res);
IGRAPH_EXPORT int igraph_sparsemat_transpose(const igraph_sparsemat_t *A,
                                             igraph_sparsemat_t *res, int values);
IGRAPH_EXPORT igraph_bool_t igraph_sparsemat_is_symmetric(const igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_dupl(igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_fkeep(igraph_sparsemat_t *A,
                                         igraph_integer_t (*fkeep)(igraph_integer_t, igraph_integer_t, igraph_real_t, void*),
                                         void *other);
IGRAPH_EXPORT int igraph_sparsemat_dropzeros(igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_droptol(igraph_sparsemat_t *A, igraph_real_t tol);
IGRAPH_EXPORT int igraph_sparsemat_multiply(const igraph_sparsemat_t *A,
                                            const igraph_sparsemat_t *B,
                                            igraph_sparsemat_t *res);
IGRAPH_EXPORT int igraph_sparsemat_add(const igraph_sparsemat_t *A,
                                       const igraph_sparsemat_t *B,
                                       igraph_real_t alpha,
                                       igraph_real_t beta,
                                       igraph_sparsemat_t *res);
IGRAPH_EXPORT int igraph_sparsemat_gaxpy(const igraph_sparsemat_t *A,
                                         const igraph_vector_t *x,
                                         igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_lsolve(const igraph_sparsemat_t *A,
                                          const igraph_vector_t *b,
                                          igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_ltsolve(const igraph_sparsemat_t *A,
                                           const igraph_vector_t *b,
                                           igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_usolve(const igraph_sparsemat_t *A,
                                          const igraph_vector_t *b,
                                          igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_utsolve(const igraph_sparsemat_t *A,
                                           const igraph_vector_t *b,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_cholsol(const igraph_sparsemat_t *A,
                                           const igraph_vector_t *b,
                                           igraph_vector_t *res,
                                           int order);

IGRAPH_EXPORT int igraph_sparsemat_lusol(const igraph_sparsemat_t *A,
                                         const igraph_vector_t *b,
                                         igraph_vector_t *res,
                                         int order,
                                         igraph_real_t tol);

IGRAPH_EXPORT int igraph_sparsemat_print(const igraph_sparsemat_t *A,
                                         FILE *outstream);

IGRAPH_EXPORT int igraph_sparsemat_eye(igraph_sparsemat_t *A, int n, int nzmax,
                                       igraph_real_t value,
                                       igraph_bool_t compress);

IGRAPH_EXPORT int igraph_sparsemat_diag(igraph_sparsemat_t *A, int nzmax,
                                        const igraph_vector_t *values,
                                        igraph_bool_t compress);

IGRAPH_EXPORT int igraph_sparsemat(igraph_t *graph, const igraph_sparsemat_t *A,
                                   igraph_bool_t directed);

IGRAPH_EXPORT int igraph_weighted_sparsemat(igraph_t *graph, const igraph_sparsemat_t *A,
                                            igraph_bool_t directed, const char *attr,
                                            igraph_bool_t loops);

IGRAPH_EXPORT int igraph_get_sparsemat(const igraph_t *graph, igraph_sparsemat_t *res);

IGRAPH_EXPORT int igraph_matrix_as_sparsemat(igraph_sparsemat_t *res,
                                             const igraph_matrix_t *mat,
                                             igraph_real_t tol);

IGRAPH_EXPORT int igraph_sparsemat_as_matrix(igraph_matrix_t *res,
                                             const igraph_sparsemat_t *spmat);

typedef enum { IGRAPH_SPARSEMAT_SOLVE_LU,
               IGRAPH_SPARSEMAT_SOLVE_QR
             } igraph_sparsemat_solve_t;

IGRAPH_EXPORT int igraph_sparsemat_arpack_rssolve(const igraph_sparsemat_t *A,
                                                  igraph_arpack_options_t *options,
                                                  igraph_arpack_storage_t *storage,
                                                  igraph_vector_t *values,
                                                  igraph_matrix_t *vectors,
                                                  igraph_sparsemat_solve_t solvemethod);

IGRAPH_EXPORT int igraph_sparsemat_arpack_rnsolve(const igraph_sparsemat_t *A,
                                                  igraph_arpack_options_t *options,
                                                  igraph_arpack_storage_t *storage,
                                                  igraph_matrix_t *values,
                                                  igraph_matrix_t *vectors);

IGRAPH_EXPORT int igraph_sparsemat_lu(const igraph_sparsemat_t *A,
                                      const igraph_sparsemat_symbolic_t *dis,
                                      igraph_sparsemat_numeric_t *din, double tol);

IGRAPH_EXPORT int igraph_sparsemat_qr(const igraph_sparsemat_t *A,
                                      const igraph_sparsemat_symbolic_t *dis,
                                      igraph_sparsemat_numeric_t *din);

IGRAPH_EXPORT int igraph_sparsemat_luresol(const igraph_sparsemat_symbolic_t *dis,
                                           const igraph_sparsemat_numeric_t *din,
                                           const igraph_vector_t *b,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_qrresol(const igraph_sparsemat_symbolic_t *dis,
                                           const igraph_sparsemat_numeric_t *din,
                                           const igraph_vector_t *b,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_symbqr(long int order, const igraph_sparsemat_t *A,
                                          igraph_sparsemat_symbolic_t *dis);

IGRAPH_EXPORT int igraph_sparsemat_symblu(long int order, const igraph_sparsemat_t *A,
                                          igraph_sparsemat_symbolic_t *dis);


IGRAPH_EXPORT void igraph_sparsemat_symbolic_destroy(igraph_sparsemat_symbolic_t *dis);
IGRAPH_EXPORT void igraph_sparsemat_numeric_destroy(igraph_sparsemat_numeric_t *din);

IGRAPH_EXPORT igraph_real_t igraph_sparsemat_max(igraph_sparsemat_t *A);
IGRAPH_EXPORT igraph_real_t igraph_sparsemat_min(igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_minmax(igraph_sparsemat_t *A,
                                          igraph_real_t *min, igraph_real_t *max);

IGRAPH_EXPORT long int igraph_sparsemat_count_nonzero(igraph_sparsemat_t *A);
IGRAPH_EXPORT long int igraph_sparsemat_count_nonzerotol(igraph_sparsemat_t *A,
                                                         igraph_real_t tol);
IGRAPH_EXPORT int igraph_sparsemat_rowsums(const igraph_sparsemat_t *A,
                                           igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_colsums(const igraph_sparsemat_t *A,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_rowmins(igraph_sparsemat_t *A,
                                           igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_colmins(igraph_sparsemat_t *A,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_rowmaxs(igraph_sparsemat_t *A,
                                           igraph_vector_t *res);
IGRAPH_EXPORT int igraph_sparsemat_colmaxs(igraph_sparsemat_t *A,
                                           igraph_vector_t *res);

IGRAPH_EXPORT int igraph_sparsemat_which_min_rows(igraph_sparsemat_t *A,
                                                  igraph_vector_t *res,
                                                  igraph_vector_int_t *pos);
IGRAPH_EXPORT int igraph_sparsemat_which_min_cols(igraph_sparsemat_t *A,
                                                  igraph_vector_t *res,
                                                  igraph_vector_int_t *pos);

IGRAPH_EXPORT int igraph_sparsemat_scale(igraph_sparsemat_t *A, igraph_real_t by);


IGRAPH_EXPORT int igraph_sparsemat_add_rows(igraph_sparsemat_t *A, long int n);
IGRAPH_EXPORT int igraph_sparsemat_add_cols(igraph_sparsemat_t *A, long int n);
IGRAPH_EXPORT int igraph_sparsemat_resize(igraph_sparsemat_t *A, long int nrow,
                                          long int ncol, int nzmax);
IGRAPH_EXPORT int igraph_sparsemat_nonzero_storage(const igraph_sparsemat_t *A);
IGRAPH_EXPORT int igraph_sparsemat_getelements(const igraph_sparsemat_t *A,
                                               igraph_vector_int_t *i,
                                               igraph_vector_int_t *j,
                                               igraph_vector_t *x);
IGRAPH_EXPORT int igraph_sparsemat_getelements_sorted(const igraph_sparsemat_t *A,
                                                      igraph_vector_int_t *i,
                                                      igraph_vector_int_t *j,
                                                      igraph_vector_t *x);
IGRAPH_EXPORT int igraph_sparsemat_scale_rows(igraph_sparsemat_t *A,
                                              const igraph_vector_t *fact);
IGRAPH_EXPORT int igraph_sparsemat_scale_cols(igraph_sparsemat_t *A,
                                              const igraph_vector_t *fact);
IGRAPH_EXPORT int igraph_sparsemat_multiply_by_dense(const igraph_sparsemat_t *A,
                                                     const igraph_matrix_t *B,
                                                     igraph_matrix_t *res);
IGRAPH_EXPORT int igraph_sparsemat_dense_multiply(const igraph_matrix_t *A,
                                                  const igraph_sparsemat_t *B,
                                                  igraph_matrix_t *res);

IGRAPH_EXPORT int igraph_sparsemat_view(igraph_sparsemat_t *A, int nzmax, int m, int n,
                                        int *p, int *i, double *x, int nz);
IGRAPH_EXPORT IGRAPH_DEPRECATED int igraph_i_sparsemat_view(igraph_sparsemat_t *A, int nzmax, int m, int n,
                                                            int *p, int *i, double *x, int nz);

IGRAPH_EXPORT int igraph_sparsemat_sort(const igraph_sparsemat_t *A,
                                        igraph_sparsemat_t *sorted);

IGRAPH_EXPORT int igraph_sparsemat_nzmax(const igraph_sparsemat_t *A);

IGRAPH_EXPORT int igraph_sparsemat_neg(igraph_sparsemat_t *A);

IGRAPH_EXPORT int igraph_sparsemat_iterator_init(igraph_sparsemat_iterator_t *it,
                                                 igraph_sparsemat_t *sparsemat);
IGRAPH_EXPORT int igraph_sparsemat_iterator_reset(igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT igraph_bool_t igraph_sparsemat_iterator_end(const igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT int igraph_sparsemat_iterator_row(const igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT int igraph_sparsemat_iterator_col(const igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT int igraph_sparsemat_iterator_idx(const igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT igraph_real_t igraph_sparsemat_iterator_get(const igraph_sparsemat_iterator_t *it);
IGRAPH_EXPORT int igraph_sparsemat_iterator_next(igraph_sparsemat_iterator_t *it);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_spmatrix.h0000644000175100001710000001260500000000000024653 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_SPMATRIX_H
#define IGRAPH_SPMATRIX_H

#include "igraph_decls.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Sparse matrix                                      */
/* -------------------------------------------------- */

/**
 * \section about_igraph_spmatrix_t_objects About \type igraph_spmatrix_t objects
 *
 * The \type igraph_spmatrix_t type stores a sparse matrix with the
 * assumption that the number of nonzero elements in the matrix scales
 * linearly with the row or column count of the matrix (so most of the
 * elements are zero). Of course it can store an arbitrary real matrix,
 * but if most of the elements are nonzero, one should use \type igraph_matrix_t
 * instead.
 *
 * The elements are stored in column compressed format, so the elements
 * in the same column are stored adjacent in the computer's memory. The storage
 * requirement for a sparse matrix is O(n) where n is the number of nonzero
 * elements. Actually it can be a bit larger, see the documentation of
 * the vector type for an explanation.
 */
typedef struct s_spmatrix {
    igraph_vector_t ridx, cidx, data;
    long int nrow, ncol;
} igraph_spmatrix_t;

#define IGRAPH_SPMATRIX_INIT_FINALLY(m, nr, nc) \
    do { IGRAPH_CHECK(igraph_spmatrix_init(m, nr, nc)); \
        IGRAPH_FINALLY(igraph_spmatrix_destroy, m); } while (0)

IGRAPH_EXPORT int igraph_spmatrix_init(igraph_spmatrix_t *m, long int nrow, long int ncol);
IGRAPH_EXPORT void igraph_spmatrix_destroy(igraph_spmatrix_t *m);
IGRAPH_EXPORT int igraph_spmatrix_resize(igraph_spmatrix_t *m, long int nrow, long int ncol);
IGRAPH_EXPORT igraph_real_t igraph_spmatrix_e(const igraph_spmatrix_t *m, long int row, long int col);
IGRAPH_EXPORT int igraph_spmatrix_set(igraph_spmatrix_t *m, long int row, long int col,
                                      igraph_real_t value);
IGRAPH_EXPORT int igraph_spmatrix_add_e(igraph_spmatrix_t *m, long int row, long int col,
                                        igraph_real_t value);
IGRAPH_EXPORT int igraph_spmatrix_add_col_values(igraph_spmatrix_t *m, long int to, long int from);
IGRAPH_EXPORT long int igraph_spmatrix_count_nonzero(const igraph_spmatrix_t *m);
IGRAPH_EXPORT long int igraph_spmatrix_size(const igraph_spmatrix_t *m);
IGRAPH_EXPORT long int igraph_spmatrix_nrow(const igraph_spmatrix_t *m);
IGRAPH_EXPORT long int igraph_spmatrix_ncol(const igraph_spmatrix_t *m);
IGRAPH_EXPORT int igraph_spmatrix_copy_to(const igraph_spmatrix_t *m, igraph_real_t *to);
IGRAPH_EXPORT int igraph_spmatrix_null(igraph_spmatrix_t *m);
IGRAPH_EXPORT int igraph_spmatrix_add_cols(igraph_spmatrix_t *m, long int n);
IGRAPH_EXPORT int igraph_spmatrix_add_rows(igraph_spmatrix_t *m, long int n);
IGRAPH_EXPORT int igraph_spmatrix_clear_col(igraph_spmatrix_t *m, long int col);
IGRAPH_EXPORT int igraph_spmatrix_clear_row(igraph_spmatrix_t *m, long int row);
IGRAPH_EXPORT int igraph_spmatrix_copy(igraph_spmatrix_t *to, const igraph_spmatrix_t *from);
IGRAPH_EXPORT igraph_real_t igraph_spmatrix_max_nonzero(const igraph_spmatrix_t *m,
                                                        igraph_real_t *ridx, igraph_real_t *cidx);
IGRAPH_EXPORT igraph_real_t igraph_spmatrix_max(const igraph_spmatrix_t *m,
                                                igraph_real_t *ridx, igraph_real_t *cidx);
IGRAPH_EXPORT void igraph_spmatrix_scale(igraph_spmatrix_t *m, igraph_real_t by);
IGRAPH_EXPORT int igraph_spmatrix_colsums(const igraph_spmatrix_t *m, igraph_vector_t *res);
IGRAPH_EXPORT int igraph_spmatrix_rowsums(const igraph_spmatrix_t *m, igraph_vector_t *res);

IGRAPH_EXPORT int igraph_spmatrix_print(const igraph_spmatrix_t *matrix);
IGRAPH_EXPORT int igraph_spmatrix_fprint(const igraph_spmatrix_t *matrix, FILE* file);


typedef struct s_spmatrix_iter {
    const igraph_spmatrix_t *m; /* pointer to the matrix we are iterating over */
    long int pos;               /* internal index into the data vector */
    long int ri;                /* row index */
    long int ci;                /* column index */
    igraph_real_t value;        /* value at the given cell */
} igraph_spmatrix_iter_t;

IGRAPH_EXPORT int igraph_spmatrix_iter_create(igraph_spmatrix_iter_t *mit, const igraph_spmatrix_t *m);
IGRAPH_EXPORT int igraph_spmatrix_iter_reset(igraph_spmatrix_iter_t *mit);
IGRAPH_EXPORT int igraph_spmatrix_iter_next(igraph_spmatrix_iter_t *mit);
IGRAPH_EXPORT igraph_bool_t igraph_spmatrix_iter_end(igraph_spmatrix_iter_t *mit);
IGRAPH_EXPORT void igraph_spmatrix_iter_destroy(igraph_spmatrix_iter_t *mit);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_stack.h0000644000175100001710000000404400000000000024107 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_STACK_H
#define IGRAPH_STACK_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Plain stack                                        */
/* -------------------------------------------------- */

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_INT
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_PTR
#include "igraph_pmt.h"
#include "igraph_stack_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_PTR

#define IGRAPH_STACK_NULL { 0,0,0 }

IGRAPH_EXPORT void igraph_stack_ptr_free_all(igraph_stack_ptr_t* s);
IGRAPH_EXPORT void igraph_stack_ptr_destroy_all(igraph_stack_ptr_t* s);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_stack_pmt.h0000644000175100001710000000364000000000000024770 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

/**
 * Stack data type.
 * \ingroup internal
 */

typedef struct TYPE(igraph_stack) {
    BASE* stor_begin;
    BASE* stor_end;
    BASE* end;
} TYPE(igraph_stack);

IGRAPH_EXPORT int FUNCTION(igraph_stack, init)(TYPE(igraph_stack)* s, long int size);
IGRAPH_EXPORT void FUNCTION(igraph_stack, destroy)(TYPE(igraph_stack)* s);
IGRAPH_EXPORT int FUNCTION(igraph_stack, reserve)(TYPE(igraph_stack)* s, long int size);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_stack, empty)(TYPE(igraph_stack)* s);
IGRAPH_EXPORT long int FUNCTION(igraph_stack, size)(const TYPE(igraph_stack)* s);
IGRAPH_EXPORT void FUNCTION(igraph_stack, clear)(TYPE(igraph_stack)* s);
IGRAPH_EXPORT int FUNCTION(igraph_stack, push)(TYPE(igraph_stack)* s, BASE elem);
IGRAPH_EXPORT BASE FUNCTION(igraph_stack, pop)(TYPE(igraph_stack)* s);
IGRAPH_EXPORT BASE FUNCTION(igraph_stack, top)(const TYPE(igraph_stack)* s);
IGRAPH_EXPORT int FUNCTION(igraph_stack, print)(const TYPE(igraph_stack)* s);
IGRAPH_EXPORT int FUNCTION(igraph_stack, fprint)(const TYPE(igraph_stack)* s, FILE *file);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_statusbar.h0000644000175100001710000001027500000000000025015 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_STATUSBAR_H
#define IGRAPH_STATUSBAR_H

#include "igraph_decls.h"

__BEGIN_DECLS

/**
 * \section about_status_handlers Status reporting
 *
 * 
 * In addition to the possibility of reporting the progress of an
 * igraph computation via \ref igraph_progress(), it is also possible
 * to report simple status messages from within igraph functions,
 * without having to judge how much of the computation was performed
 * already. For this one needs to install a status handler function.
 * 
 *
 * 
 * Status handler functions must be of type \ref igraph_status_handler_t
 * and they can be install by a call to \ref igraph_set_status_handler().
 * Currently there is a simple predefined status handler function,
 * called \ref igraph_status_handler_stderr(), but the user can define
 * new ones.
 * 
 *
 * 
 * igraph functions report their status via a call to the
 * \ref IGRAPH_STATUS() or the \ref IGRAPH_STATUSF() macro.
 * 
 */

/**
 * \typedef igraph_status_handler_t
 *
 * The type of the igraph status handler functions
 * \param message The status message.
 * \param data Additional context, with user-defined semantics.
 *        Existing igraph functions pass a null pointer here.
 */

typedef int igraph_status_handler_t(const char *message, void *data);

IGRAPH_EXPORT extern igraph_status_handler_t igraph_status_handler_stderr;

IGRAPH_EXPORT igraph_status_handler_t * igraph_set_status_handler(igraph_status_handler_t new_handler);

IGRAPH_EXPORT int igraph_status(const char *message, void *data);

/**
 * \define IGRAPH_STATUS
 * Report the status of an igraph function.
 *
 * Typically this function is called only a handful of times from
 * an igraph function. E.g. if an algorithm has three major
 * steps, then it is logical to call it three times, to
 * signal the three major steps.
 * \param message The status message.
 * \param data Additional context, with user-defined semantics.
 *        Existing igraph functions pass a null pointer here.
 * \return If the status handler returns with a value other than
 *        \c IGRAPH_SUCCESS, then the function that called this
 *        macro returns as well, with error code
 *        \c IGRAPH_INTERRUPTED.
 */

#define IGRAPH_STATUS(message, data) \
    do { \
        if (igraph_status((message), (data)) != IGRAPH_SUCCESS) { \
            IGRAPH_FINALLY_FREE(); \
            return IGRAPH_INTERRUPTED; \
        } \
    } while (0)

IGRAPH_EXPORT int igraph_statusf(const char *message, void *data, ...);

/**
 * \define IGRAPH_STATUSF
 * Report the status from an igraph function
 *
 * This is the more flexible version of \ref IGRAPH_STATUS(),
 * having a printf-like syntax. As this macro takes variable
 * number of arguments, they must be all supplied as a single
 * argument, enclosed in parentheses. Then \ref igraph_statusf()
 * is called with the given arguments.
 * \param args The arguments to pass to \ref igraph_statusf().
 * \return If the status handler returns with a value other than
 *        \c IGRAPH_SUCCESS, then the function that called this
 *        macro returns as well, with error code
 *        \c IGRAPH_INTERRUPTED.
 */

#define IGRAPH_STATUSF(args) \
    do { \
        if (igraph_statusf args != IGRAPH_SUCCESS) { \
            IGRAPH_FINALLY_FREE(); \
            return IGRAPH_INTERRUPTED; \
        } \
    } while (0)

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_structural.h0000644000175100001710000001556600000000000025225 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_STRUCTURAL_H
#define IGRAPH_STRUCTURAL_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"
#include "igraph_attributes.h"
#include "igraph_sparsemat.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Basic query functions                              */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_are_connected(const igraph_t *graph, igraph_integer_t v1, igraph_integer_t v2, igraph_bool_t *res);
IGRAPH_EXPORT int igraph_count_multiple(const igraph_t *graph, igraph_vector_t *res, igraph_es_t es);
IGRAPH_EXPORT int igraph_density(const igraph_t *graph, igraph_real_t *res,
                                 igraph_bool_t loops);
IGRAPH_EXPORT int igraph_diversity(const igraph_t *graph, const igraph_vector_t *weights,
                                   igraph_vector_t *res, const igraph_vs_t vs);
IGRAPH_EXPORT int igraph_girth(const igraph_t *graph, igraph_integer_t *girth,
                               igraph_vector_t *circle);
IGRAPH_EXPORT int igraph_has_loop(const igraph_t *graph, igraph_bool_t *res);
IGRAPH_EXPORT int igraph_has_multiple(const igraph_t *graph, igraph_bool_t *res);
IGRAPH_EXPORT int igraph_is_loop(const igraph_t *graph, igraph_vector_bool_t *res,
                                 igraph_es_t es);
IGRAPH_EXPORT int igraph_is_multiple(const igraph_t *graph, igraph_vector_bool_t *res,
                                     igraph_es_t es);
IGRAPH_EXPORT int igraph_is_mutual(const igraph_t *graph, igraph_vector_bool_t *res, igraph_es_t es);
IGRAPH_EXPORT int igraph_is_simple(const igraph_t *graph, igraph_bool_t *res);
IGRAPH_EXPORT int igraph_is_tree(const igraph_t *graph, igraph_bool_t *res, igraph_integer_t *root, igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_maxdegree(const igraph_t *graph, igraph_integer_t *res,
                                   igraph_vs_t vids, igraph_neimode_t mode,
                                   igraph_bool_t loops);
IGRAPH_EXPORT int igraph_reciprocity(const igraph_t *graph, igraph_real_t *res,
                                     igraph_bool_t ignore_loops,
                                     igraph_reciprocity_t mode);
IGRAPH_EXPORT int igraph_strength(const igraph_t *graph, igraph_vector_t *res,
                                  const igraph_vs_t vids, igraph_neimode_t mode,
                                  igraph_bool_t loops, const igraph_vector_t *weights);
IGRAPH_EXPORT int igraph_sort_vertex_ids_by_degree(const igraph_t *graph,
                                                   igraph_vector_t *outvids,
                                                   igraph_vs_t vids,
                                                   igraph_neimode_t mode,
                                                   igraph_bool_t loops,
                                                   igraph_order_t order,
                                                   igraph_bool_t only_indices);

/* -------------------------------------------------- */
/* Structural properties                              */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_minimum_spanning_tree(const igraph_t *graph, igraph_vector_t *res,
                                               const igraph_vector_t *weights);
IGRAPH_EXPORT int igraph_minimum_spanning_tree_unweighted(const igraph_t *graph,
                                                          igraph_t *mst);
IGRAPH_EXPORT int igraph_minimum_spanning_tree_prim(const igraph_t *graph, igraph_t *mst,
                                                    const igraph_vector_t *weights);
IGRAPH_EXPORT int igraph_random_spanning_tree(const igraph_t *graph, igraph_vector_t *res,
                                              igraph_integer_t vid);

IGRAPH_EXPORT int igraph_subcomponent(const igraph_t *graph, igraph_vector_t *res, igraph_real_t vid,
                                      igraph_neimode_t mode);

IGRAPH_EXPORT int igraph_unfold_tree(const igraph_t *graph, igraph_t *tree,
                                     igraph_neimode_t mode, const igraph_vector_t *roots,
                                     igraph_vector_t *vertex_index);

IGRAPH_EXPORT int igraph_maximum_cardinality_search(const igraph_t *graph,
                                                    igraph_vector_t *alpha,
                                                    igraph_vector_t *alpham1);
IGRAPH_EXPORT int igraph_is_chordal(const igraph_t *graph,
                                    const igraph_vector_t *alpha,
                                    const igraph_vector_t *alpham1,
                                    igraph_bool_t *chordal,
                                    igraph_vector_t *fill_in,
                                    igraph_t *newgraph);
IGRAPH_EXPORT int igraph_avg_nearest_neighbor_degree(const igraph_t *graph,
                                                     igraph_vs_t vids,
                                                     igraph_neimode_t mode,
                                                     igraph_neimode_t neighbor_degree_mode,
                                                     igraph_vector_t *knn,
                                                     igraph_vector_t *knnk,
                                                     const igraph_vector_t *weights);

IGRAPH_EXPORT int igraph_feedback_arc_set(const igraph_t *graph, igraph_vector_t *result,
                                          const igraph_vector_t *weights, igraph_fas_algorithm_t algo);

/* -------------------------------------------------- */
/* Spectral Properties                                */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_laplacian(const igraph_t *graph, igraph_matrix_t *res,
                                   igraph_sparsemat_t *sparseres,
                                   igraph_bool_t normalized,
                                   const igraph_vector_t *weights);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_strvector.h0000644000175100001710000000777700000000000025055 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_STRVECTOR_H
#define IGRAPH_STRVECTOR_H

#include "igraph_decls.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/**
 * Vector of strings
 * \ingroup internal
 */

typedef struct s_igraph_strvector {
    char **data;
    long int len;
} igraph_strvector_t;

/**
 * \define STR
 * Indexing string vectors
 *
 * This is a macro which allows to query the elements of a string vector in
 * simpler way than \ref igraph_strvector_get(). Note this macro cannot be
 * used to set an element, for that use \ref igraph_strvector_set().
 * \param sv The string vector
 * \param i The the index of the element.
 * \return The element at position \p i.
 *
 * Time complexity: O(1).
 */
#define STR(sv,i) ((const char *)((sv).data[(i)]))

#define IGRAPH_STRVECTOR_NULL { 0,0 }
#define IGRAPH_STRVECTOR_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_strvector_init(v, size)); \
        IGRAPH_FINALLY( igraph_strvector_destroy, v); } while (0)

IGRAPH_EXPORT int igraph_strvector_init(igraph_strvector_t *sv, long int len);
IGRAPH_EXPORT void igraph_strvector_destroy(igraph_strvector_t *sv);
IGRAPH_EXPORT long int igraph_strvector_size(const igraph_strvector_t *sv);
IGRAPH_EXPORT void igraph_strvector_get(const igraph_strvector_t *sv,
                                        long int idx, char **value);
IGRAPH_EXPORT int igraph_strvector_set(igraph_strvector_t *sv, long int idx,
                                       const char *value);
IGRAPH_EXPORT int igraph_strvector_set2(igraph_strvector_t *sv, long int idx,
                                        const char *value, int len);
IGRAPH_EXPORT void igraph_strvector_clear(igraph_strvector_t *sv);
IGRAPH_EXPORT void igraph_strvector_remove_section(igraph_strvector_t *v, long int from,
                                                   long int to);
IGRAPH_EXPORT void igraph_strvector_remove(igraph_strvector_t *v, long int elem);
IGRAPH_EXPORT void igraph_strvector_move_interval(igraph_strvector_t *v, long int begin,
                                                  long int end, long int to);
IGRAPH_EXPORT int igraph_strvector_copy(igraph_strvector_t *to,
                                        const igraph_strvector_t *from);
IGRAPH_EXPORT int igraph_strvector_append(igraph_strvector_t *to,
                                          const igraph_strvector_t *from);
IGRAPH_EXPORT int igraph_strvector_resize(igraph_strvector_t* v, long int newsize);
IGRAPH_EXPORT int igraph_strvector_add(igraph_strvector_t *v, const char *value);
IGRAPH_EXPORT void igraph_strvector_permdelete(igraph_strvector_t *v, const igraph_vector_t *index,
                                               long int nremove);
IGRAPH_EXPORT void igraph_strvector_remove_negidx(igraph_strvector_t *v, const igraph_vector_t *neg,
                                                  long int nremove);
IGRAPH_EXPORT int igraph_strvector_print(const igraph_strvector_t *v, FILE *file,
                                         const char *sep);

IGRAPH_EXPORT int igraph_strvector_index(const igraph_strvector_t *v,
                                         igraph_strvector_t *newv,
                                         const igraph_vector_t *idx);


__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_threading.h.in0000644000175100001710000000267700000000000025366 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_THREADING_H
#define IGRAPH_THREADING_H

#include "igraph_decls.h"

__BEGIN_DECLS

/**
 * \define IGRAPH_THREAD_SAFE
 *
 * Specifies whether igraph was built in thread-safe mode.
 *
 * This macro is defined to 1 if the current build of the igraph library is
 * built in thread-safe mode, and 0 if it is not. A thread-safe igraph library
 * attempts to use thread-local data structures instead of global ones, but
 * note that this is not (and can not) be guaranteed for third-party libraries
 * that igraph links to.
 */

#cmakedefine01 IGRAPH_THREAD_SAFE

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_topology.h0000644000175100001710000003577300000000000024673 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_TOPOLOGY_H
#define IGRAPH_TOPOLOGY_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Directed acyclic graphs                            */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_topological_sorting(const igraph_t *graph, igraph_vector_t *res,
                                             igraph_neimode_t mode);
IGRAPH_EXPORT int igraph_is_dag(const igraph_t *graph, igraph_bool_t *res);
IGRAPH_EXPORT int igraph_transitive_closure_dag(const igraph_t *graph,
                                                igraph_t *closure);

/* -------------------------------------------------- */
/* Graph isomorphisms                                 */
/* -------------------------------------------------- */

/* Common functions */
IGRAPH_EXPORT int igraph_simplify_and_colorize(
    const igraph_t *graph, igraph_t *res,
    igraph_vector_int_t *vertex_color, igraph_vector_int_t *edge_color);

/* Generic interface */
IGRAPH_EXPORT int igraph_isomorphic(const igraph_t *graph1, const igraph_t *graph2,
                                    igraph_bool_t *iso);
IGRAPH_EXPORT int igraph_subisomorphic(const igraph_t *graph1, const igraph_t *graph2,
                                       igraph_bool_t *iso);

/* LAD */
IGRAPH_EXPORT int igraph_subisomorphic_lad(const igraph_t *pattern, const igraph_t *target,
                                           const igraph_vector_ptr_t *domains,
                                           igraph_bool_t *iso, igraph_vector_t *map,
                                           igraph_vector_ptr_t *maps,
                                           igraph_bool_t induced, int time_limit);

/* VF2 family*/
/**
 * \typedef igraph_isohandler_t
 * Callback type, called when an isomorphism was found
 *
 * See the details at the documentation of \ref
 * igraph_isomorphic_function_vf2().
 * \param map12 The mapping from the first graph to the second.
 * \param map21 The mapping from the second graph to the first, the
 *   inverse of \p map12 basically.
 * \param arg This extra argument was passed to \ref
 *   igraph_isomorphic_function_vf2() when it was called.
 * \return Boolean, whether to continue with the isomorphism search.
 */


typedef igraph_bool_t igraph_isohandler_t(const igraph_vector_t *map12,
        const igraph_vector_t *map21, void *arg);

/**
 * \typedef igraph_isocompat_t
 * Callback type, called to check whether two vertices or edges are compatible
 *
 * VF2 (subgraph) isomorphism functions can be restricted by defining
 * relations on the vertices and/or edges of the graphs, and then checking
 * whether the vertices (edges) match according to these relations.
 *
 * This feature is implemented by two callbacks, one for
 * vertices, one for edges. Every time igraph tries to match a vertex (edge)
 * of the first (sub)graph to a vertex of the second graph, the vertex
 * (edge) compatibility callback is called. The callback returns a
 * logical value, giving whether the two vertices match.
 *
 * Both callback functions are of type \c igraph_isocompat_t.
 * \param graph1 The first graph.
 * \param graph2 The second graph.
 * \param g1_num The id of a vertex or edge in the first graph.
 * \param g2_num The id of a vertex or edge in the second graph.
 * \param arg Extra argument to pass to the callback functions.
 * \return Logical scalar, whether vertex (or edge) \p g1_num in \p graph1
 *    is compatible with vertex (or edge) \p g2_num in \p graph2.
 */

typedef igraph_bool_t igraph_isocompat_t(const igraph_t *graph1,
        const igraph_t *graph2,
        const igraph_integer_t g1_num,
        const igraph_integer_t g2_num,
        void *arg);

IGRAPH_EXPORT int igraph_isomorphic_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                        const igraph_vector_int_t *vertex_color1,
                                        const igraph_vector_int_t *vertex_color2,
                                        const igraph_vector_int_t *edge_color1,
                                        const igraph_vector_int_t *edge_color2,
                                        igraph_bool_t *iso,
                                        igraph_vector_t *map12,
                                        igraph_vector_t *map21,
                                        igraph_isocompat_t *node_compat_fn,
                                        igraph_isocompat_t *edge_compat_fn,
                                        void *arg);
IGRAPH_EXPORT int igraph_isomorphic_function_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                                 const igraph_vector_int_t *vertex_color1,
                                                 const igraph_vector_int_t *vertex_color2,
                                                 const igraph_vector_int_t *edge_color1,
                                                 const igraph_vector_int_t *edge_color2,
                                                 igraph_vector_t *map12, igraph_vector_t *map21,
                                                 igraph_isohandler_t *isohandler_fn,
                                                 igraph_isocompat_t *node_compat_fn,
                                                 igraph_isocompat_t *edge_compat_fn,
                                                 void *arg);
IGRAPH_EXPORT int igraph_count_isomorphisms_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                                const igraph_vector_int_t *vertex_color1,
                                                const igraph_vector_int_t *vertex_color2,
                                                const igraph_vector_int_t *edge_color1,
                                                const igraph_vector_int_t *edge_color2,
                                                igraph_integer_t *count,
                                                igraph_isocompat_t *node_compat_fn,
                                                igraph_isocompat_t *edge_compat_fn,
                                                void *arg);
IGRAPH_EXPORT int igraph_get_isomorphisms_vf2(const igraph_t *graph1,
                                              const igraph_t *graph2,
                                              const igraph_vector_int_t *vertex_color1,
                                              const igraph_vector_int_t *vertex_color2,
                                              const igraph_vector_int_t *edge_color1,
                                              const igraph_vector_int_t *edge_color2,
                                              igraph_vector_ptr_t *maps,
                                              igraph_isocompat_t *node_compat_fn,
                                              igraph_isocompat_t *edge_compat_fn,
                                              void *arg);

IGRAPH_EXPORT int igraph_subisomorphic_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                           const igraph_vector_int_t *vertex_color1,
                                           const igraph_vector_int_t *vertex_color2,
                                           const igraph_vector_int_t *edge_color1,
                                           const igraph_vector_int_t *edge_color2,
                                           igraph_bool_t *iso,
                                           igraph_vector_t *map12,
                                           igraph_vector_t *map21,
                                           igraph_isocompat_t *node_compat_fn,
                                           igraph_isocompat_t *edge_compat_fn,
                                           void *arg);
IGRAPH_EXPORT int igraph_subisomorphic_function_vf2(const igraph_t *graph1,
                                                    const igraph_t *graph2,
                                                    const igraph_vector_int_t *vertex_color1,
                                                    const igraph_vector_int_t *vertex_color2,
                                                    const igraph_vector_int_t *edge_color1,
                                                    const igraph_vector_int_t *edge_color2,
                                                    igraph_vector_t *map12,
                                                    igraph_vector_t *map21,
                                                    igraph_isohandler_t *isohandler_fn,
                                                    igraph_isocompat_t *node_compat_fn,
                                                    igraph_isocompat_t *edge_compat_fn,
                                                    void *arg);
IGRAPH_EXPORT int igraph_count_subisomorphisms_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                                   const igraph_vector_int_t *vertex_color1,
                                                   const igraph_vector_int_t *vertex_color2,
                                                   const igraph_vector_int_t *edge_color1,
                                                   const igraph_vector_int_t *edge_color2,
                                                   igraph_integer_t *count,
                                                   igraph_isocompat_t *node_compat_fn,
                                                   igraph_isocompat_t *edge_compat_fn,
                                                   void *arg);
IGRAPH_EXPORT int igraph_get_subisomorphisms_vf2(const igraph_t *graph1,
                                                 const igraph_t *graph2,
                                                 const igraph_vector_int_t *vertex_color1,
                                                 const igraph_vector_int_t *vertex_color2,
                                                 const igraph_vector_int_t *edge_color1,
                                                 const igraph_vector_int_t *edge_color2,
                                                 igraph_vector_ptr_t *maps,
                                                 igraph_isocompat_t *node_compat_fn,
                                                 igraph_isocompat_t *edge_compat_fn,
                                                 void *arg);

/* BLISS family */
/**
 * \struct igraph_bliss_info_t
 * Information about a BLISS run
 *
 * Some secondary information found by the BLISS algorithm is stored
 * here. It is useful if you wany to study the internal working of the
 * algorithm.
 * \member nof_nodes The number of nodes in the search tree.
 * \member nof_leaf_nodes The number of leaf nodes in the search tree.
 * \member nof_bad_nodes Number of bad nodes.
 * \member nof_canupdates Number of canrep updates.
 * \member nof_generators Number of generators of the automorphism group.
 * \member max_level Maximum level.
 * \member group_size The size of the automorphism group of the graph,
 *    given as a string. It should be deallocated via
 *    \ref igraph_free() if not needed any more.
 *
 * See http://www.tcs.hut.fi/Software/bliss/index.html
 * for details about the algorithm and these parameters.
 */
typedef struct igraph_bliss_info_t {
    unsigned long nof_nodes;
    unsigned long nof_leaf_nodes;
    unsigned long nof_bad_nodes;
    unsigned long nof_canupdates;
    unsigned long nof_generators;
    unsigned long max_level;
    char *group_size;
} igraph_bliss_info_t;

/**
 * \typedef igraph_bliss_sh_t
 * \brief Splitting heuristics for Bliss.
 *
 * \c IGRAPH_BLISS_FL provides good performance for many graphs, and is a reasonable
 * default choice. \c IGRAPH_BLISS_FSM is recommended for graphs that have some
 * combinatorial structure, and is the default of the Bliss library's command
 * line tool.
 *
 * \enumval IGRAPH_BLISS_F First non-singleton cell.
 * \enumval IGRAPH_BLISS_FL First largest non-singleton cell.
 * \enumval IGRAPH_BLISS_FS First smallest non-singleton cell.
 * \enumval IGRAPH_BLISS_FM First maximally non-trivially connected
 *      non-singleton cell.
 * \enumval IGRAPH_BLISS_FLM Largest maximally non-trivially connected
 *      non-singleton cell.
 * \enumval IGRAPH_BLISS_FSM Smallest maximally non-trivially
 *      connected non-singletion cell.
 */

typedef enum { IGRAPH_BLISS_F = 0, IGRAPH_BLISS_FL,
               IGRAPH_BLISS_FS, IGRAPH_BLISS_FM,
               IGRAPH_BLISS_FLM, IGRAPH_BLISS_FSM
             } igraph_bliss_sh_t;

IGRAPH_EXPORT int igraph_canonical_permutation(const igraph_t *graph, const igraph_vector_int_t *colors, igraph_vector_t *labeling,
                                               igraph_bliss_sh_t sh, igraph_bliss_info_t *info);
IGRAPH_EXPORT int igraph_isomorphic_bliss(const igraph_t *graph1, const igraph_t *graph2,
                                          const igraph_vector_int_t *colors1, const igraph_vector_int_t *colors2,
                                          igraph_bool_t *iso, igraph_vector_t *map12,
                                          igraph_vector_t *map21,
                                          igraph_bliss_sh_t sh,
                                          igraph_bliss_info_t *info1, igraph_bliss_info_t *info2);

IGRAPH_EXPORT int igraph_automorphisms(const igraph_t *graph, const igraph_vector_int_t *colors,
                                       igraph_bliss_sh_t sh, igraph_bliss_info_t *info);

IGRAPH_EXPORT int igraph_automorphism_group(const igraph_t *graph, const igraph_vector_int_t *colors, igraph_vector_ptr_t *generators,
                                            igraph_bliss_sh_t sh, igraph_bliss_info_t *info);

/* Functions for 3-4 graphs */
IGRAPH_EXPORT int igraph_isomorphic_34(const igraph_t *graph1, const igraph_t *graph2,
                                       igraph_bool_t *iso);
IGRAPH_EXPORT int igraph_isoclass(const igraph_t *graph, igraph_integer_t *isoclass);
IGRAPH_EXPORT int igraph_isoclass_subgraph(const igraph_t *graph, const igraph_vector_t *vids,
                                           igraph_integer_t *isoclass);
IGRAPH_EXPORT int igraph_isoclass_create(igraph_t *graph, igraph_integer_t size,
                                         igraph_integer_t number, igraph_bool_t directed);




__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_transitivity.h0000644000175100001710000000612600000000000025556 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_TRANSITIVITY_H
#define IGRAPH_TRANSITIVITY_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_constants.h"
#include "igraph_iterators.h"

__BEGIN_DECLS

IGRAPH_EXPORT int igraph_transitivity_undirected(const igraph_t *graph,
                                                 igraph_real_t *res,
                                                 igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_local_undirected(const igraph_t *graph,
                                                       igraph_vector_t *res,
                                                       const igraph_vs_t vids,
                                                       igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_local_undirected1(const igraph_t *graph,
                                                        igraph_vector_t *res,
                                                        const igraph_vs_t vids,
                                                        igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_local_undirected2(const igraph_t *graph,
                                                        igraph_vector_t *res,
                                                        const igraph_vs_t vids,
                                                        igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_local_undirected4(const igraph_t *graph,
                                                        igraph_vector_t *res,
                                                        igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_avglocal_undirected(const igraph_t *graph,
                                                          igraph_real_t *res,
                                                          igraph_transitivity_mode_t mode);
IGRAPH_EXPORT int igraph_transitivity_barrat(const igraph_t *graph,
                                             igraph_vector_t *res,
                                             const igraph_vs_t vids,
                                             const igraph_vector_t *weights,
                                             const igraph_transitivity_mode_t mode);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_types.h0000644000175100001710000000454700000000000024156 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_TYPES_H
#define IGRAPH_TYPES_H

#include "igraph_decls.h"

__BEGIN_DECLS

#ifndef _GNU_SOURCE
    #define _GNU_SOURCE 1
#endif

#include "igraph_error.h"
#include 
#include 
#include 

typedef int    igraph_integer_t;
typedef double igraph_real_t;
typedef int    igraph_bool_t;

/* printf format specifier for igraph_integer_t */
#define IGRAPH_PRId "d"

/* Replacements for printf that print doubles in the same way on all platforms
 * (even for NaN and infinities) */
IGRAPH_EXPORT int igraph_real_printf(igraph_real_t val);
IGRAPH_EXPORT int igraph_real_fprintf(FILE *file, igraph_real_t val);
IGRAPH_EXPORT int igraph_real_snprintf(char* str, size_t size, igraph_real_t val);

/* Replacements for printf that print doubles in the same way on all platforms
 * (even for NaN and infinities) with the largest possible precision */
IGRAPH_EXPORT int igraph_real_printf_precise(igraph_real_t val);
IGRAPH_EXPORT int igraph_real_fprintf_precise(FILE *file, igraph_real_t val);
IGRAPH_EXPORT int igraph_real_snprintf_precise(char* str, size_t size, igraph_real_t val);

#define IGRAPH_INFINITY INFINITY
#define IGRAPH_POSINFINITY INFINITY
#define IGRAPH_NEGINFINITY (-INFINITY)

IGRAPH_EXPORT int igraph_finite(double x);
#define IGRAPH_FINITE(x) igraph_finite(x)

IGRAPH_EXPORT int igraph_is_nan(double x);
IGRAPH_EXPORT int igraph_is_inf(double x);
IGRAPH_EXPORT int igraph_is_posinf(double x);
IGRAPH_EXPORT int igraph_is_neginf(double x);

#define IGRAPH_NAN NAN

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_vector.h0000644000175100001710000001330600000000000024305 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_VECTOR_H
#define IGRAPH_VECTOR_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_complex.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Flexible vector                                    */
/* -------------------------------------------------- */

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_FLOAT
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_FLOAT

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_INT
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_COMPLEX
#include "igraph_pmt.h"
#include "igraph_vector_type.h"
#include "igraph_pmt_off.h"
#undef BASE_COMPLEX

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_FLOAT
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_FLOAT

#define BASE_LONG
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_INT
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_COMPLEX
#include "igraph_pmt.h"
#include "igraph_vector_pmt.h"
#include "igraph_pmt_off.h"
#undef BASE_COMPLEX

/* -------------------------------------------------- */
/* Helper macros                                      */
/* -------------------------------------------------- */

#ifndef IGRAPH_VECTOR_NULL
    #define IGRAPH_VECTOR_NULL { 0,0,0 }
#endif

#ifndef IGRAPH_VECTOR_INIT_FINALLY
#define IGRAPH_VECTOR_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_vector_init(v, size)); \
        IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0)
#endif
#ifndef IGRAPH_VECTOR_BOOL_INIT_FINALLY
#define IGRAPH_VECTOR_BOOL_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \
        IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0)
#endif
#ifndef IGRAPH_VECTOR_CHAR_INIT_FINALLY
#define IGRAPH_VECTOR_CHAR_INIT_FINALLY(v, size) \
  do { IGRAPH_CHECK(igraph_vector_char_init(v, size)); \
  IGRAPH_FINALLY(igraph_vector_char_destroy, v); } while (0)
#endif
#ifndef IGRAPH_VECTOR_INT_INIT_FINALLY
#define IGRAPH_VECTOR_INT_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \
        IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0)
#endif
#ifndef IGRAPH_VECTOR_LONG_INIT_FINALLY
#define IGRAPH_VECTOR_LONG_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_vector_long_init(v, size)); \
        IGRAPH_FINALLY(igraph_vector_long_destroy, v); } while (0)
#endif

/* -------------------------------------------------- */
/* Type-specific vector functions                     */
/* -------------------------------------------------- */

IGRAPH_EXPORT int igraph_vector_floor(const igraph_vector_t *from, igraph_vector_long_t *to);
IGRAPH_EXPORT int igraph_vector_round(const igraph_vector_t *from, igraph_vector_long_t *to);

IGRAPH_EXPORT igraph_bool_t igraph_vector_e_tol(const igraph_vector_t *lhs,
                                                const igraph_vector_t *rhs,
                                                igraph_real_t tol);

IGRAPH_EXPORT int igraph_vector_zapsmall(igraph_vector_t *v, igraph_real_t tol);

IGRAPH_EXPORT int igraph_vector_order(const igraph_vector_t* v, const igraph_vector_t *v2,
                                      igraph_vector_t* res, igraph_real_t maxval);
IGRAPH_EXPORT int igraph_vector_order1(const igraph_vector_t* v,
                                       igraph_vector_t* res, igraph_real_t maxval);
IGRAPH_EXPORT int igraph_vector_order1_int(const igraph_vector_t* v,
                                           igraph_vector_int_t* res, igraph_real_t maxval);
IGRAPH_EXPORT int igraph_vector_order2(igraph_vector_t *v);
IGRAPH_EXPORT int igraph_vector_rank(const igraph_vector_t *v, igraph_vector_t *res,
                                     long int nodes);
IGRAPH_EXPORT int igraph_vector_is_nan(const igraph_vector_t *v,
                                       igraph_vector_bool_t *is_nan);
IGRAPH_EXPORT igraph_bool_t igraph_vector_is_any_nan(const igraph_vector_t *v);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_vector_pmt.h0000644000175100001710000003463300000000000025173 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*--------------------*/
/* Allocation         */
/*--------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, long int size);
IGRAPH_EXPORT int FUNCTION(igraph_vector, init_copy)(TYPE(igraph_vector)* v,
                                                     const BASE* data, long int length);

#ifndef NOTORDERED
IGRAPH_EXPORT int FUNCTION(igraph_vector, init_seq)(TYPE(igraph_vector)*v, BASE from, BASE to);
#endif

IGRAPH_EXPORT int FUNCTION(igraph_vector, copy)(TYPE(igraph_vector) *to,
                                                const TYPE(igraph_vector) *from);
IGRAPH_EXPORT void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector)* v);

IGRAPH_EXPORT long int FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v);

/*--------------------*/
/* Accessing elements */
/*--------------------*/

#ifndef VECTOR
/**
 * \ingroup vector
 * \define VECTOR
 * \brief Accessing an element of a vector.
 *
 * Usage:
 * \verbatim VECTOR(v)[0] \endverbatim
 * to access the first element of the vector, you can also use this in
 * assignments, like:
 * \verbatim VECTOR(v)[10]=5; \endverbatim
 *
 * Note that there are no range checks right now.
 * This functionality might be redefined later as a real function
 * instead of a #define.
 * \param v The vector object.
 *
 * Time complexity: O(1).
 */
#define VECTOR(v) ((v).stor_begin)
#endif

IGRAPH_EXPORT BASE FUNCTION(igraph_vector, e)(const TYPE(igraph_vector)* v, long int pos);
IGRAPH_EXPORT BASE* FUNCTION(igraph_vector, e_ptr)(const TYPE(igraph_vector)* v, long int pos);
IGRAPH_EXPORT void FUNCTION(igraph_vector, set)(TYPE(igraph_vector)* v, long int pos, BASE value);
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, tail)(const TYPE(igraph_vector) *v);

/*-----------------------*/
/* Initializing elements */
/*-----------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_vector, null)(TYPE(igraph_vector)* v);
IGRAPH_EXPORT void FUNCTION(igraph_vector, fill)(TYPE(igraph_vector)* v, BASE e);

/*-----------------------*/
/* Vector views          */
/*-----------------------*/

IGRAPH_EXPORT const TYPE(igraph_vector) *FUNCTION(igraph_vector, view)(const TYPE(igraph_vector) *v,
                                                                       const BASE *data,
                                                                       long int length);

/*-----------------------*/
/* Copying vectors       */
/*-----------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_vector, copy_to)(const TYPE(igraph_vector) *v, BASE* to);
IGRAPH_EXPORT int FUNCTION(igraph_vector, update)(TYPE(igraph_vector) *to,
                                                  const TYPE(igraph_vector) *from);
IGRAPH_EXPORT int FUNCTION(igraph_vector, append)(TYPE(igraph_vector) *to,
                                                  const TYPE(igraph_vector) *from);
IGRAPH_EXPORT int FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2);

/*-----------------------*/
/* Exchanging elements   */
/*-----------------------*/

IGRAPH_EXPORT int FUNCTION(igraph_vector, swap_elements)(TYPE(igraph_vector) *v,
                                                         long int i, long int j);
IGRAPH_EXPORT int FUNCTION(igraph_vector, reverse)(TYPE(igraph_vector) *v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, shuffle)(TYPE(igraph_vector) *v);

/*-----------------------*/
/* Vector operations     */
/*-----------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_vector, add_constant)(TYPE(igraph_vector) *v, BASE plus);
IGRAPH_EXPORT void FUNCTION(igraph_vector, scale)(TYPE(igraph_vector) *v, BASE by);
IGRAPH_EXPORT int FUNCTION(igraph_vector, add)(TYPE(igraph_vector) *v1,
                                               const TYPE(igraph_vector) *v2);
IGRAPH_EXPORT int FUNCTION(igraph_vector, sub)(TYPE(igraph_vector) *v1,
                                               const TYPE(igraph_vector) *v2);
IGRAPH_EXPORT int FUNCTION(igraph_vector, mul)(TYPE(igraph_vector) *v1,
                                               const TYPE(igraph_vector) *v2);
IGRAPH_EXPORT int FUNCTION(igraph_vector, div)(TYPE(igraph_vector) *v1,
                                               const TYPE(igraph_vector) *v2);
IGRAPH_EXPORT int FUNCTION(igraph_vector, cumsum)(TYPE(igraph_vector) *to,
                                                  const TYPE(igraph_vector) *from);

#ifndef NOABS
    IGRAPH_EXPORT int FUNCTION(igraph_vector, abs)(TYPE(igraph_vector) *v);
#endif

/*------------------------------*/
/* Comparison                   */
/*------------------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, all_e)(const TYPE(igraph_vector) *lhs,
                                                           const TYPE(igraph_vector) *rhs);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, all_l)(const TYPE(igraph_vector) *lhs,
                                                           const TYPE(igraph_vector) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, all_g)(const TYPE(igraph_vector) *lhs,
                                                           const TYPE(igraph_vector) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, all_le)(const TYPE(igraph_vector) *lhs,
                                                            const TYPE(igraph_vector) *rhs);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, all_ge)(const TYPE(igraph_vector) *lhs,
                                                            const TYPE(igraph_vector) *rhs);
IGRAPH_EXPORT int FUNCTION(igraph_vector, lex_cmp)(const void *lhs,
                                                   const void *rhs);
IGRAPH_EXPORT int FUNCTION(igraph_vector, colex_cmp)(const void *lhs,
                                                       const void *rhs);
#endif

/*------------------------------*/
/* Finding minimum and maximum  */
/*------------------------------*/

#ifndef NOTORDERED
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, min)(const TYPE(igraph_vector)* v);
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector)* v);
IGRAPH_EXPORT long int FUNCTION(igraph_vector, which_min)(const TYPE(igraph_vector)* v);
IGRAPH_EXPORT long int FUNCTION(igraph_vector, which_max)(const TYPE(igraph_vector)* v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, minmax)(const TYPE(igraph_vector) *v,
                                                  BASE *min, BASE *max);
IGRAPH_EXPORT int FUNCTION(igraph_vector, which_minmax)(const TYPE(igraph_vector) *v,
                                                        long int *which_min, long int *which_max);
#endif

/*-------------------*/
/* Vector properties */
/*-------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, empty)     (const TYPE(igraph_vector)* v);
IGRAPH_EXPORT long int FUNCTION(igraph_vector, size)      (const TYPE(igraph_vector)* v);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, isnull)(const TYPE(igraph_vector) *v);
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, sum)(const TYPE(igraph_vector) *v);
IGRAPH_EXPORT igraph_real_t FUNCTION(igraph_vector, sumsq)(const TYPE(igraph_vector) *v);
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, prod)(const TYPE(igraph_vector) *v);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, isininterval)(const TYPE(igraph_vector) *v,
                                                                  BASE low, BASE high);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, any_smaller)(const TYPE(igraph_vector) *v,
                                                                 BASE limit);
#endif
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, is_equal)(const TYPE(igraph_vector) *lhs,
                                                              const TYPE(igraph_vector) *rhs);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_real_t FUNCTION(igraph_vector, maxdifference)(const TYPE(igraph_vector) *m1,
                                                                   const TYPE(igraph_vector) *m2);
#endif

/*------------------------*/
/* Searching for elements */
/*------------------------*/

IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, contains)(const TYPE(igraph_vector) *v, BASE e);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, search)(const TYPE(igraph_vector) *v,
                                                            long int from, BASE what,
                                                            long int *pos);
#ifndef NOTORDERED
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, binsearch_slice)(const TYPE(igraph_vector) *v,
                                                                     BASE what, long int *pos,
                                                                     long int start, long int end);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, binsearch)(const TYPE(igraph_vector) *v,
                                                               BASE what, long int *pos);
IGRAPH_EXPORT igraph_bool_t FUNCTION(igraph_vector, binsearch2)(const TYPE(igraph_vector) *v,
                                                                BASE what);
#endif

/*------------------------*/
/* Resizing operations    */
/*------------------------*/

IGRAPH_EXPORT void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, long int newsize);
IGRAPH_EXPORT int FUNCTION(igraph_vector, resize_min)(TYPE(igraph_vector)*v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector)* v, long int size);
IGRAPH_EXPORT int FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector)* v, BASE e);
IGRAPH_EXPORT BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector)* v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, insert)(TYPE(igraph_vector) *v, long int pos, BASE value);
IGRAPH_EXPORT void FUNCTION(igraph_vector, remove)(TYPE(igraph_vector) *v, long int elem);
IGRAPH_EXPORT void FUNCTION(igraph_vector, remove_section)(TYPE(igraph_vector) *v,
                                                           long int from, long int to);

/*-----------*/
/* Sorting   */
/*-----------*/

#ifndef NOTORDERED

IGRAPH_EXPORT void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v);
IGRAPH_EXPORT void FUNCTION(igraph_vector, reverse_sort)(TYPE(igraph_vector) *v);
IGRAPH_EXPORT long int FUNCTION(igraph_vector, qsort_ind)(TYPE(igraph_vector) *v,
                                                          igraph_vector_t *inds, igraph_bool_t descending);

#endif

/*-----------*/
/* Printing  */
/*-----------*/

IGRAPH_EXPORT int FUNCTION(igraph_vector, print)(const TYPE(igraph_vector) *v);
IGRAPH_EXPORT int FUNCTION(igraph_vector, printf)(const TYPE(igraph_vector) *v,
                                                  const char *format);
IGRAPH_EXPORT int FUNCTION(igraph_vector, fprint)(const TYPE(igraph_vector) *v, FILE *file);

#ifdef BASE_COMPLEX

IGRAPH_EXPORT int igraph_vector_complex_real(const igraph_vector_complex_t *v,
                                       igraph_vector_t *real);
IGRAPH_EXPORT int igraph_vector_complex_imag(const igraph_vector_complex_t *v,
                                       igraph_vector_t *imag);
IGRAPH_EXPORT int igraph_vector_complex_realimag(const igraph_vector_complex_t *v,
        igraph_vector_t *real,
        igraph_vector_t *imag);
IGRAPH_EXPORT int igraph_vector_complex_create(igraph_vector_complex_t *v,
        const igraph_vector_t *real,
        const igraph_vector_t *imag);
IGRAPH_EXPORT int igraph_vector_complex_create_polar(igraph_vector_complex_t *v,
        const igraph_vector_t *r,
        const igraph_vector_t *theta);

#endif

IGRAPH_EXPORT int FUNCTION(igraph_vector, init_real)(TYPE(igraph_vector)*v, int no, ...);
IGRAPH_EXPORT int FUNCTION(igraph_vector, init_int)(TYPE(igraph_vector)*v, int no, ...);
IGRAPH_EXPORT int FUNCTION(igraph_vector, init_real_end)(TYPE(igraph_vector)*v, double endmark, ...);
IGRAPH_EXPORT int FUNCTION(igraph_vector, init_int_end)(TYPE(igraph_vector)*v, int endmark, ...);

IGRAPH_EXPORT int FUNCTION(igraph_vector, move_interval)(TYPE(igraph_vector) *v,
                                                         long int begin, long int end, long int to);
IGRAPH_EXPORT int FUNCTION(igraph_vector, move_interval2)(TYPE(igraph_vector) *v,
                                                          long int begin, long int end, long int to);
IGRAPH_EXPORT void FUNCTION(igraph_vector, permdelete)(TYPE(igraph_vector) *v,
                                                       const igraph_vector_t *index,
                                                       long int nremove);
#ifndef NOTORDERED
IGRAPH_EXPORT int FUNCTION(igraph_vector, filter_smaller)(TYPE(igraph_vector) *v, BASE elem);
#endif
IGRAPH_EXPORT int FUNCTION(igraph_vector, get_interval)(const TYPE(igraph_vector) *v,
                                                        TYPE(igraph_vector) *res,
                                                        long int from, long int to);
#ifndef NOTORDERED
IGRAPH_EXPORT int FUNCTION(igraph_vector, difference_sorted)(const TYPE(igraph_vector) *v1,
                                                             const TYPE(igraph_vector) *v2, TYPE(igraph_vector) *result);
IGRAPH_EXPORT int FUNCTION(igraph_vector, intersect_sorted)(const TYPE(igraph_vector) *v1,
                                                            const TYPE(igraph_vector) *v2, TYPE(igraph_vector) *result);
#endif
IGRAPH_EXPORT int FUNCTION(igraph_vector, index)(const TYPE(igraph_vector) *v,
                                                 TYPE(igraph_vector) *newv,
                                                 const igraph_vector_t *idx);

IGRAPH_EXPORT int FUNCTION(igraph_vector, index_int)(TYPE(igraph_vector) *v,
                                                     const igraph_vector_int_t *idx);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_vector_ptr.h0000644000175100001710000001136200000000000025172 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_VECTOR_PTR_H
#define IGRAPH_VECTOR_PTR_H

#include "igraph_decls.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Flexible vector, storing pointers                  */
/* -------------------------------------------------- */

/**
 * Vector, storing pointers efficiently
 * \ingroup internal
 *
 */
typedef struct s_vector_ptr {
    void** stor_begin;
    void** stor_end;
    void** end;
    igraph_finally_func_t* item_destructor;
} igraph_vector_ptr_t;

#define IGRAPH_VECTOR_PTR_NULL { 0,0,0,0 }
#define IGRAPH_VECTOR_PTR_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0)

IGRAPH_EXPORT int igraph_vector_ptr_init      (igraph_vector_ptr_t* v, long int size);
IGRAPH_EXPORT int igraph_vector_ptr_init_copy (igraph_vector_ptr_t* v, void** data, long int length);
IGRAPH_EXPORT const igraph_vector_ptr_t *igraph_vector_ptr_view (const igraph_vector_ptr_t *v,
                                                                 void *const *data, long int length);
IGRAPH_EXPORT void igraph_vector_ptr_destroy   (igraph_vector_ptr_t* v);
IGRAPH_EXPORT void igraph_vector_ptr_free_all   (igraph_vector_ptr_t* v);
IGRAPH_EXPORT void igraph_vector_ptr_destroy_all   (igraph_vector_ptr_t* v);
IGRAPH_EXPORT int igraph_vector_ptr_reserve   (igraph_vector_ptr_t* v, long int size);
IGRAPH_EXPORT igraph_bool_t igraph_vector_ptr_empty     (const igraph_vector_ptr_t* v);
IGRAPH_EXPORT long int igraph_vector_ptr_size      (const igraph_vector_ptr_t* v);
IGRAPH_EXPORT void igraph_vector_ptr_clear     (igraph_vector_ptr_t* v);
IGRAPH_EXPORT void igraph_vector_ptr_null      (igraph_vector_ptr_t* v);
IGRAPH_EXPORT int igraph_vector_ptr_push_back (igraph_vector_ptr_t* v, void* e);
IGRAPH_EXPORT int igraph_vector_ptr_append    (igraph_vector_ptr_t *to,
                                               const igraph_vector_ptr_t *from);
IGRAPH_EXPORT void *igraph_vector_ptr_pop_back (igraph_vector_ptr_t *v);
IGRAPH_EXPORT int igraph_vector_ptr_insert(igraph_vector_ptr_t *v, long int pos, void* e);
IGRAPH_EXPORT void* igraph_vector_ptr_e         (const igraph_vector_ptr_t* v, long int pos);
IGRAPH_EXPORT void igraph_vector_ptr_set       (igraph_vector_ptr_t* v, long int pos, void* value);
IGRAPH_EXPORT int igraph_vector_ptr_resize(igraph_vector_ptr_t* v, long int newsize);
IGRAPH_EXPORT void igraph_vector_ptr_copy_to(const igraph_vector_ptr_t *v, void** to);
IGRAPH_EXPORT int igraph_vector_ptr_copy(igraph_vector_ptr_t *to, const igraph_vector_ptr_t *from);
IGRAPH_EXPORT void igraph_vector_ptr_remove(igraph_vector_ptr_t *v, long int pos);
IGRAPH_EXPORT void igraph_vector_ptr_sort(igraph_vector_ptr_t *v, int(*compar)(const void*, const void*));
IGRAPH_EXPORT int igraph_vector_ptr_index_int(igraph_vector_ptr_t *v,
                                              const igraph_vector_int_t *idx);

IGRAPH_EXPORT igraph_finally_func_t* igraph_vector_ptr_get_item_destructor(const igraph_vector_ptr_t *v);
IGRAPH_EXPORT igraph_finally_func_t* igraph_vector_ptr_set_item_destructor(igraph_vector_ptr_t *v,
                                                                           igraph_finally_func_t *func);

/**
 * \define IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR
 * \brief Sets the item destructor for this pointer vector (macro version).
 *
 * This macro is expanded to \ref igraph_vector_ptr_set_item_destructor(), the
 * only difference is that the second argument is automatically cast to an
 * \c igraph_finally_func_t*. The cast is necessary in most cases as the
 * destructor functions we use (such as \ref igraph_vector_destroy()) take a
 * pointer to some concrete igraph data type, while \c igraph_finally_func_t
 * expects \c void*
 */
#define IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(v, func) \
    igraph_vector_ptr_set_item_destructor((v), (igraph_finally_func_t*)(func))

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_vector_type.h0000644000175100001710000000204700000000000025346 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/**
 * Vector, dealing with arrays efficiently.
 * \ingroup types
 */

typedef struct TYPE(igraph_vector) {
    BASE* stor_begin;
    BASE* stor_end;
    BASE* end;
} TYPE(igraph_vector);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_version.h.in0000644000175100001710000000266700000000000025105 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_VERSION_H
#define IGRAPH_VERSION_H

#include "igraph_decls.h"

__BEGIN_DECLS

#define IGRAPH_VERSION "@PACKAGE_VERSION@"
#define IGRAPH_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@
#define IGRAPH_VERSION_MINOR @PACKAGE_VERSION_MINOR@
#define IGRAPH_VERSION_PATCH @PACKAGE_VERSION_PATCH@
#define IGRAPH_VERSION_PRERELEASE "@PACKAGE_VERSION_PRERELEASE@"

IGRAPH_EXPORT int igraph_version(const char **version_string,
                                 int *major,
                                 int *minor,
                                 int *subminor);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/include/igraph_visitor.h0000644000175100001710000001243400000000000024503 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_VISITOR_H
#define IGRAPH_VISITOR_H

#include "igraph_decls.h"
#include "igraph_constants.h"
#include "igraph_types.h"
#include "igraph_datatype.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Visitor-like functions                             */
/* -------------------------------------------------- */

/**
 * \typedef igraph_bfshandler_t
 * Callback type for BFS function
 *
 * \ref igraph_bfs() is able to call a callback function, whenever a
 * new vertex is found, while doing the breadth-first search. This
 * callback function must be of type \c igraph_bfshandler_t. It has
 * the following arguments:
 * \param graph The graph that that algorithm is working on. Of course
 *   this must not be modified.
 * \param vid The id of the vertex just found by the breadth-first
 *   search.
 * \param pred The id of the previous vertex visited. It is -1 if
 *   there is no previous vertex, because the current vertex is the root
 *   is a search tree.
 * \param succ The id of the next vertex that will be visited. It is
 *   -1 if there is no next vertex, because the current vertex is the
 *   last one in a search tree.
 * \param rank The rank of the current vertex, it starts with zero.
 * \param dist The distance (number of hops) of the current vertex
 *   from the root of the current search tree.
 * \param extra The extra argument that was passed to \ref
 *   igraph_bfs().
 * \return A logical value, if TRUE (=non-zero), that is interpreted
 *    as a request to stop the BFS and return to the caller. If a BFS
 *    is terminated like this, then all elements of the result vectors
 *    that were not yet calculated at the point of the termination
 *    contain NaN.
 *
 * \sa \ref igraph_bfs()
 */

typedef igraph_bool_t igraph_bfshandler_t(const igraph_t *graph,
        igraph_integer_t vid,
        igraph_integer_t pred,
        igraph_integer_t succ,
        igraph_integer_t rank,
        igraph_integer_t dist,
        void *extra);

IGRAPH_EXPORT int igraph_bfs(const igraph_t *graph,
                             igraph_integer_t root, const igraph_vector_t *roots,
                             igraph_neimode_t mode, igraph_bool_t unreachable,
                             const igraph_vector_t *restricted,
                             igraph_vector_t *order, igraph_vector_t *rank,
                             igraph_vector_t *father,
                             igraph_vector_t *pred, igraph_vector_t *succ,
                             igraph_vector_t *dist, igraph_bfshandler_t *callback,
                             void *extra);

IGRAPH_EXPORT int igraph_bfs_simple(igraph_t *graph, igraph_integer_t vid, igraph_neimode_t mode,
                                    igraph_vector_t *vids, igraph_vector_t *layers,
                                    igraph_vector_t *parents);

/**
 * \function igraph_dfshandler_t
 * Callback type for the DFS function
 *
 * \ref igraph_dfs() is able to call a callback function, whenever a
 * new vertex is discovered, and/or whenever a subtree is
 * completed. These callbacks must be of type \c
 * igraph_dfshandler_t. They have the following arguments:
 * \param graph The graph that that algorithm is working on. Of course
 *   this must not be modified.
 * \param vid The id of the vertex just found by the depth-first
 *   search.
 * \param dist The distance (number of hops) of the current vertex
 *   from the root of the current search tree.
 * \param extra The extra argument that was passed to \ref
 *   igraph_dfs().
 * \return A logical value, if TRUE (=non-zero), that is interpreted
 *    as a request to stop the DFS and return to the caller. If a DFS
 *    is terminated like this, then all elements of the result vectors
 *    that were not yet calculated at the point of the termination
 *    contain NaN.
 *
 * \sa \ref igraph_dfs()
 */

typedef igraph_bool_t igraph_dfshandler_t(const igraph_t *graph,
        igraph_integer_t vid,
        igraph_integer_t dist,
        void *extra);

IGRAPH_EXPORT int igraph_dfs(const igraph_t *graph, igraph_integer_t root,
                             igraph_neimode_t mode, igraph_bool_t unreachable,
                             igraph_vector_t *order,
                             igraph_vector_t *order_out, igraph_vector_t *father,
                             igraph_vector_t *dist, igraph_dfshandler_t *in_callback,
                             igraph_dfshandler_t *out_callback,
                             void *extra);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4791403
igraph-0.9.9/vendor/source/igraph/interfaces/0000755000175100001710000000000000000000000021775 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/interfaces/CMakeLists.txt0000644000175100001710000000212200000000000024532 0ustar00runnerdocker00000000000000# Check whether the user has Stimulus on its PATH
find_program(STIMULUS_COMMAND stimulus)

# Add a custom targer that checks functions.yaml and types.yaml
if(STIMULUS_COMMAND)
    add_custom_command(
        OUTPUT test_stimulus_specifications.cpp
        COMMAND ${STIMULUS_COMMAND}
            -l ci:validate
            -f ${CMAKE_CURRENT_SOURCE_DIR}/functions.yaml
            -t ${CMAKE_CURRENT_SOURCE_DIR}/types.yaml
            -o test_stimulus_specifications.cpp
        DEPENDS
            ${CMAKE_CURRENT_SOURCE_DIR}/functions.yaml
            ${CMAKE_CURRENT_SOURCE_DIR}/types.yaml
        COMMENT "Generating C++ checker for Stimulus function and type specifications..."
        USES_TERMINAL
    )
    add_executable(test_stimulus test_stimulus_specifications.cpp)
    target_include_directories(test_stimulus PRIVATE ${CMAKE_SOURCE_DIR}/include ${CMAKE_BINARY_DIR}/include)

    add_custom_target(
        check_stimulus
		COMMAND test_stimulus
        DEPENDS test_stimulus
        COMMENT "Running C++ checker for Stimulus function and type specifications..."
    )
endif(STIMULUS_COMMAND)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/interfaces/functions.yaml0000644000175100001710000020367300000000000024704 0ustar00runnerdocker00000000000000# vim:set ts=4 sw=4 sts=4 et:
#
# This file is a YAML representation of the signatures of most igraph
# functions. They are currently used by some of the higher level interfaces to
# generate code using our internal tool called Stimulus
#
# See https://github.com/igraph/stimulus for more information

#######################################
# The basic interface
#######################################

igraph_empty:
    PARAMS: OUT GRAPH graph, INTEGER n=0, BOOLEAN directed=True

igraph_add_edges:
    PARAMS: INOUT GRAPH graph, VECTOR edges, ATTRIBUTES attr

igraph_add_vertices:
    PARAMS: INOUT GRAPH graph, INTEGER nv, ATTRIBUTES attr

igraph_delete_edges:
    PARAMS: INOUT GRAPH graph, EDGESET edges
    DEPS: edges ON graph

igraph_delete_vertices:
    PARAMS: INOUT GRAPH graph, VERTEXSET vertices
    DEPS: vertices ON graph

igraph_vcount:
    PARAMS: GRAPH graph
    RETURN: INTEGER

igraph_ecount:
    PARAMS: GRAPH graph
    RETURN: INTEGER

igraph_neighbors:
    PARAMS: GRAPH graph, OUT VECTOR neis, INTEGER vid, NEIMODE mode=ALL

igraph_is_directed:
    PARAMS: GRAPH graph
    RETURN: BOOLEAN

igraph_degree:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, VERTEXSET vids=ALL, NEIMODE mode=ALL,
        BOOLEAN loops
    DEPS: vids ON graph

igraph_edge:
    PARAMS: GRAPH graph, INTEGER eid, OUT INTEGER from, OUT INTEGER to

igraph_edges:
    PARAMS: GRAPH graph, EDGESET eids, OUT VECTOR edges
    DEPS: eids ON graph

igraph_get_eid:
    PARAMS: |-
        GRAPH graph, OUT INTEGER eid, INTEGER from,
        INTEGER to, BOOLEAN directed=True, BOOLEAN error=True

igraph_get_eids:
    PARAMS: |-
        GRAPH graph, OUT VECTOR eids, OPTIONAL VECTOR pairs,
        OPTIONAL VECTOR path, BOOLEAN directed=True, BOOLEAN error=True

igraph_incident:
    PARAMS: GRAPH graph, OUT VECTOR eids, INTEGER vid, NEIMODE mode=ALL

igraph_is_same_graph:
    PARAMS: GRAPH graph1, GRAPH graph2, OUT BOOLEAN res

#######################################
# Constructors, deterministic
#######################################

igraph_create:
    PARAMS: OUT GRAPH graph, VECTOR edges, INTEGER n=0, BOOLEAN directed=True

igraph_adjacency:
    PARAMS: OUT GRAPH graph, MATRIX adjmatrix, ADJACENCYMODE mode=DIRECTED

igraph_weighted_adjacency:
    PARAMS: |-
        OUT GRAPH graph, MATRIX adjmatrix,
        ADJACENCYMODE mode=DIRECTED, CSTRING attr="weight",
        BOOLEAN loops

igraph_star:
    PARAMS: OUT GRAPH graph, INTEGER n, STARMODE mode=OUT, INTEGER center=0

igraph_lattice:
    PARAMS: |-
        OUT GRAPH graph, VECTOR dimvector, INTEGER nei=1,
        BOOLEAN directed=False, BOOLEAN mutual=False, BOOLEAN circular=False

igraph_ring:
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, BOOLEAN directed=False, BOOLEAN mutual=False,
        BOOLEAN circular=True

igraph_tree:
    PARAMS: OUT GRAPH graph, INTEGER n, INTEGER children=2, TREEMODE type=OUT

igraph_full:
    PARAMS: OUT GRAPH graph, INTEGER n, BOOLEAN directed=False, BOOLEAN loops=False

igraph_full_citation:
    PARAMS: OUT GRAPH graph, INTEGER n, BOOLEAN directed=True

igraph_atlas:
    PARAMS: OUT GRAPH graph, INT number=0

igraph_extended_chordal_ring:
    PARAMS: OUT GRAPH graph, INTEGER nodes, MATRIX W, BOOLEAN directed=False

igraph_connect_neighborhood:
    PARAMS: INOUT GRAPH graph, INTEGER order=2, NEIMODE mode=ALL

igraph_linegraph:
    PARAMS: GRAPH graph, OUT GRAPH linegraph

igraph_de_bruijn:
    PARAMS: OUT GRAPH graph, INTEGER m, INTEGER n

igraph_kautz:
    PARAMS: OUT GRAPH graph, INTEGER m, INTEGER n

igraph_famous:
    PARAMS: OUT GRAPH graph, CSTRING name=""

igraph_lcf_vector:
    PARAMS: OUT GRAPH graph, INTEGER n, VECTOR shifts, INTEGER repeats=1

igraph_adjlist:
    PARAMS: |-
        OUT GRAPH graph, ADJLIST adjlist, NEIMODE mode=OUT,
        BOOLEAN duplicate=True

igraph_full_bipartite:
    PARAMS: |-
        OUT GRAPH graph, OUT VECTOR_BOOL_OR_0 types, INTEGER n1,
        INTEGER n2, BOOLEAN directed=False, NEIMODE mode=ALL

igraph_realize_degree_sequence:
    PARAMS: |-
        OUT GRAPH graph, VECTOR out_deg, VECTOR_OR_0 in_deg=NULL,
        EDGE_TYPE_SW allowed_edge_types=SIMPLE, REALIZE_DEGSEQ_METHOD method=SMALLEST

#######################################
# Constructors, games
#######################################

igraph_barabasi_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, REAL power=1.0, INTEGER m=1,
        VECTOR_OR_0 outseq, BOOLEAN outpref=False, REAL A=1.0,
        BOOLEAN directed=True, BARABASI_ALGORITHM algo=BAG,
        GRAPH_OR_0 start_from=0

igraph_erdos_renyi_game_gnp:
    PARAMS: OUT GRAPH graph, INTEGER n, REAL p, BOOLEAN directed=False, BOOLEAN loops=False

igraph_erdos_renyi_game_gnm:
    PARAMS: OUT GRAPH graph, INTEGER n, REAL m, BOOLEAN directed=False, BOOLEAN loops=False

igraph_degree_sequence_game:
    PARAMS: |-
        OUT GRAPH graph, VECTOR out_deg, VECTOR_OR_0 in_deg,
        DEGSEQMODE method=SIMPLE

igraph_growing_random_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, INTEGER m=1, BOOLEAN directed=False,
        BOOLEAN citation=False

igraph_barabasi_aging_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER m=1, VECTOR_OR_0 outseq,
        BOOLEAN outpref=False, REAL pa_exp=1.0, REAL aging_exp=0.0, INTEGER aging_bin=1,
        REAL zero_deg_appeal=1.0, REAL zero_age_appeal=0.0, REAL deg_coef=1.0,
        REAL age_coef=1.0, BOOLEAN directed=True

igraph_recent_degree_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, REAL power=1.0, INTEGER window=1,
        INTEGER m=1, VECTOR_OR_0 outseq, BOOLEAN outpref=False,
        REAL zero_appeal=1.0, BOOLEAN directed=True

igraph_recent_degree_aging_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER m=1, VECTOR_OR_0 outseq,
        BOOLEAN outpref=False, REAL pa_exp=1.0, REAL aging_exp=0.0, INTEGER aging_bin=1,
        INTEGER window=1, REAL zero_appeal=1.0, BOOLEAN directed=True

igraph_callaway_traits_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER types,
        INTEGER edges_per_step=1, VECTOR type_dist, MATRIX pref_matrix,
        BOOLEAN directed=False, OPTIONAL OUT VECTOR node_type_vec

igraph_establishment_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER types, INTEGER k=1,
        VECTOR type_dist, MATRIX pref_matrix, BOOLEAN directed=True,
        OPTIONAL OUT VECTOR node_type_vec

igraph_grg_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, REAL radius, BOOLEAN torus=False,
        OPTIONAL OUT VECTOR x, OPTIONAL OUT VECTOR y

igraph_preference_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER types,
        VECTOR type_dist, BOOLEAN fixed_sizes=False,
        MATRIX pref_matrix, OUT VECTOR node_type_vec,
        BOOLEAN directed=False, BOOLEAN loops=False

igraph_asymmetric_preference_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER out_types, INTEGER in_types,
        MATRIX type_dist_matrix, MATRIX pref_matrix,
        OUT VECTOR node_type_in_vec, OUT VECTOR node_type_out_vec,
        BOOLEAN loops=False

igraph_rewire_edges:
    PARAMS: |-
        INOUT GRAPH graph, REAL prob, BOOLEAN loops=False,
        BOOLEAN multiple=False

igraph_rewire_directed_edges:
    PARAMS: |-
        INOUT GRAPH graph, REAL prob, BOOLEAN loops=False,
        NEIMODE mode=OUT

igraph_watts_strogatz_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER dim, INTEGER size, INTEGER nei,
        REAL p, BOOLEAN loops=False, BOOLEAN multiple=False

igraph_lastcit_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, INTEGER edges_per_node=1,
        INTEGER agebins=1, VECTOR preference, BOOLEAN directed=True

igraph_cited_type_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, VECTOR types, VECTOR pref,
        INTEGER edges_per_step=1, BOOLEAN directed=True

igraph_citing_cited_type_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, VECTOR types, MATRIX pref,
        INTEGER edges_per_step=1, BOOLEAN directed=True

igraph_forest_fire_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER nodes, REAL fw_prob, REAL bw_factor=1,
        INTEGER ambs=1, BOOLEAN directed=True

igraph_simple_interconnected_islands_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER islands_n, INTEGER islands_size,
        REAL islands_pin, INTEGER n_inter

igraph_static_fitness_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER no_of_edges, VECTOR fitness_out,
        VECTOR_OR_0 fitness_in=NULL, BOOLEAN loops=False,
        BOOLEAN multiple=False

igraph_static_power_law_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER no_of_nodes, INTEGER no_of_edges,
        REAL exponent_out, REAL exponent_in=-1,
        BOOLEAN loops=False, BOOLEAN multiple=False,
        BOOLEAN finite_size_correction=True

igraph_k_regular_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER no_of_nodes, INTEGER k,
        BOOLEAN directed=False, BOOLEAN multiple=False

igraph_sbm_game:
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, MATRIX pref_matrix,
        VECTOR_INT block_sizes, BOOLEAN directed=False,
        BOOLEAN loops=False

igraph_hsbm_game:
    INTERNAL: true
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, INTEGER m,
        VECTOR rho, MATRIX C, REAL p

igraph_hsbm_list_game:
    INTERNAL: true
    PARAMS: |-
        OUT GRAPH graph, INTEGER n, VECTOR_INT mlist,
        VECTORLIST rholist, MATRIXLIST Clist, REAL p

igraph_correlated_game:
    PARAMS: |-
        GRAPH old_graph, OUT GRAPH new_graph,
        REAL corr, REAL p=old.graph$p, VECTORM1_OR_0 permutation=NULL

igraph_correlated_pair_game:
    PARAMS: |-
        OUT GRAPH graph1, OUT GRAPH graph2, INTEGER n, REAL corr,
        REAL p, BOOLEAN directed=False,
        VECTORM1_OR_0 permutation=NULL

igraph_dot_product_game:
    PARAMS: OUT GRAPH graph, MATRIX vecs, BOOLEAN directed=False

igraph_sample_sphere_surface:
    PARAMS: |-
        INTEGER dim, INTEGER n=1, REAL radius=1,
        BOOLEAN positive=True, OUT MATRIX res

igraph_sample_sphere_volume:
    PARAMS: |-
        INTEGER dim, INTEGER n=1, REAL radius=1,
        BOOLEAN positive=True, OUT MATRIX res

igraph_sample_dirichlet:
    PARAMS: INTEGER n, VECTOR alpha, OUT MATRIX res

#######################################
# Basic query functions
#######################################

igraph_are_connected:
    PARAMS: GRAPH graph, INTEGER v1, INTEGER v2, OUT BOOLEAN res

#######################################
# Structural properties
#######################################

igraph_diameter:
    PARAMS: |-
        GRAPH graph, OUT REAL res, OUT INTEGER from,
        OUT INTEGER to, OUT VECTOR_OR_0 path, BOOLEAN directed=True,
        BOOLEAN unconnected=True

igraph_diameter_dijkstra:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        OUT REAL res, OUT INTEGER from,
        OUT INTEGER to, OUT VECTOR_OR_0 path, BOOLEAN directed=True,
        BOOLEAN unconnected=True
    DEPS: weights ON graph

igraph_closeness:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res,
        OUT VECTOR_OR_0 reachable_count,
        OPTIONAL OUT BOOLEAN all_reachable,
        VERTEXSET vids=ALL,
        NEIMODE mode=OUT, EDGEWEIGHTS weights=NULL,
        BOOLEAN normalized=False
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_closeness_cutoff:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res,
        OUT VECTOR_OR_0 reachable_count,
        OPTIONAL OUT BOOLEAN all_reachable,
        VERTEXSET vids=ALL,
        NEIMODE mode=OUT, EDGEWEIGHTS weights=NULL,
        BOOLEAN normalized=False, REAL cutoff=-1
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_shortest_paths:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET from=ALL,
        VERTEXSET to=ALL, NEIMODE mode=OUT
    DEPS: from ON graph, to ON graph

igraph_get_shortest_paths:
    PARAMS: |-
        GRAPH graph,
        OPTIONAL OUT VERTEXSETLIST vertices, OPTIONAL OUT EDGESETLIST edges,
        VERTEX from, VERTEXSET to=ALL, NEIMODE mode=OUT,
        OPTIONAL OUT VECTOR_LONG predecessors,
        OPTIONAL OUT VECTOR_LONG inbound_edges
    DEPS: edges ON graph, from ON graph, to ON graph

igraph_get_all_shortest_paths:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST res, OUT VECTOR nrgeo,
        VERTEX from, VERTEXSET to, NEIMODE mode=OUT
    DEPS: res ON graph, from ON graph, to ON graph

igraph_shortest_paths_dijkstra:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET from=ALL,
        VERTEXSET to=ALL, EDGEWEIGHTS weights, NEIMODE mode=OUT
    DEPS: from ON graph, to ON graph, weights ON graph

igraph_get_shortest_paths_dijkstra:
    PARAMS: |-
        GRAPH graph, OPTIONAL OUT VERTEXSETLIST vertices,
        OPTIONAL OUT EDGESETLIST edges, VERTEX from, VERTEXSET to=ALL,
        EDGEWEIGHTS weights=NULL, NEIMODE mode=OUT,
        OPTIONAL OUT VECTOR_LONG predecessors=0,
        OPTIONAL OUT VECTOR_LONG inbound_edges=0
    DEPS: |-
        vertices ON graph, edges ON graph, from ON graph, to ON graph,
        weights ON graph

igraph_get_shortest_paths_bellman_ford:
    PARAMS: |-
        GRAPH graph, OPTIONAL OUT VERTEXSETLIST vertices,
        OPTIONAL OUT EDGESETLIST edges, VERTEX from, VERTEXSET to=ALL,
        EDGEWEIGHTS weights=NULL, NEIMODE mode=OUT,
        OPTIONAL OUT VECTOR_LONG predecessors=0,
        OPTIONAL OUT VECTOR_LONG inbound_edges=0
    DEPS: |-
        vertices ON graph, edges ON graph, from ON graph, to ON graph,
        weights ON graph

igraph_get_all_shortest_paths_dijkstra:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST res, OUT VECTOR nrgeo,
        VERTEX from, VERTEXSET to=ALL, EDGEWEIGHTS weights,
        NEIMODE mode=OUT
    DEPS: weights ON graph, to ON graph, res ON graph, from ON graph

igraph_shortest_paths_bellman_ford:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET from=ALL,
        VERTEXSET to=ALL, EDGEWEIGHTS weights, NEIMODE mode=OUT
    DEPS: from ON graph, to ON graph, weights ON graph

igraph_shortest_paths_johnson:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET from=ALL,
        VERTEXSET to=ALL, EDGEWEIGHTS weights
    DEPS: from ON graph, to ON graph, weights ON graph

igraph_get_all_simple_paths:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSET_INT res, VERTEX from,
        VERTEXSET to=ALL, INTEGER cutoff=-1, NEIMODE mode=OUT
    DEPS: from ON graph, to ON graph, res ON graph

igraph_subcomponent:
    # TODO(ntamas): vid is a double; this is correct but this is actually
    # a mistake in 0.9.x. This should be fixed in 0.10.
    PARAMS: GRAPH graph, OUT VERTEXSET res, REAL vid, NEIMODE mode=ALL
    DEPS: vid ON graph, res ON graph

igraph_betweenness:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        BOOLEAN directed=True, EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph, vids ON graph, res ON graph vids

igraph_betweenness_cutoff:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        BOOLEAN directed=True, EDGEWEIGHTS weights=NULL,
        REAL cutoff=-1
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_edge_betweenness:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, BOOLEAN directed=True,
        EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

igraph_edge_betweenness_cutoff:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, BOOLEAN directed=True,
        EDGEWEIGHTS weights=NULL, REAL cutoff=-1
    DEPS: weights ON graph

igraph_harmonic_centrality:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        NEIMODE mode=OUT, EDGEWEIGHTS weights=NULL, BOOLEAN normalized=False
    DEPS: weights ON graph, vids ON graph, res ON graph vids

igraph_harmonic_centrality_cutoff:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        NEIMODE mode=OUT, EDGEWEIGHTS weights=NULL, BOOLEAN normalized=False,
        REAL cutoff=-1
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_pagerank:
    PARAMS: |-
        GRAPH graph, PAGERANKALGO algo=PRPACK,
        OUT VERTEXINDEX vector, OUT REAL value,
        VERTEXSET vids=ALL, BOOLEAN directed=True,
        REAL damping=0.85, EDGEWEIGHTS weights=NULL,
        INOUT PAGERANKOPT options=NULL
    DEPS: |-
        vids ON graph, weights ON graph, vector ON graph vids,
        options ON algo

igraph_personalized_pagerank:
    PARAMS: |-
        GRAPH graph, PAGERANKALGO algo=PRPACK,
        OUT VERTEXINDEX vector, OUT REAL value,
        VERTEXSET vids=ALL, BOOLEAN directed=True,
        REAL damping=0.85, VECTOR_OR_0 personalized=NULL,
        EDGEWEIGHTS weights=NULL,
        INOUT PAGERANKOPT options=NULL
    DEPS: |-
        vids ON graph, weights ON graph, vector ON graph vids,
        options ON algo

igraph_rewire:
    PARAMS: INOUT GRAPH rewire, INTEGER n, REWIRINGMODE mode=SIMPLE

igraph_induced_subgraph:
    PARAMS: GRAPH graph, OUT GRAPH res, VERTEXSET vids, SUBGRAPH_IMPL impl=AUTO
    DEPS: vids ON graph

igraph_subgraph_edges:
    PARAMS: GRAPH graph, OUT GRAPH res, EDGESET eids, BOOLEAN delete_vertices=True
    DEPS: eids ON graph

igraph_average_path_length:
    PARAMS: GRAPH graph, PRIMARY OUT REAL res, OUT REAL unconn_pairs=NULL,
        BOOLEAN directed=True, BOOLEAN unconn=True

igraph_average_path_length_dijkstra:
    PARAMS: GRAPH graph, PRIMARY OUT REAL res, OUT REAL unconn_pairs=NULL,
        EDGEWEIGHTS weights=NULL, BOOLEAN directed=True, BOOLEAN unconn=True
    DEPS: weights ON graph

igraph_path_length_hist:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, OUT REAL unconnected,
        BOOLEAN directed=True

igraph_simplify:
    PARAMS: |-
        INOUT GRAPH graph, BOOLEAN remove_multiple=True,
        BOOLEAN remove_loops=True,
        EDGE_ATTRIBUTE_COMBINATION edge_attr_comb=Default

igraph_transitivity_undirected:
    PARAMS: GRAPH graph, OUT REAL res, TRANSITIVITYMODE mode=NAN

igraph_transitivity_local_undirected:
    PARAMS: GRAPH graph, OUT VECTOR res, VERTEXSET vids=ALL, TRANSITIVITYMODE mode=NAN

igraph_transitivity_avglocal_undirected:
    PARAMS: GRAPH graph, OUT REAL res, TRANSITIVITYMODE mode=NAN

igraph_transitivity_barrat:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, VERTEXSET vids=ALL,
        EDGEWEIGHTS weights=NULL, TRANSITIVITYMODE mode=NAN
    DEPS: res ON graph, vids ON graph, weights ON graph

igraph_reciprocity:
    PARAMS: |-
        GRAPH graph, OUT REAL res, BOOLEAN ignore_loops=True,
        RECIP mode=Default

igraph_constraint:
    PARAMS: GRAPH graph, OUT VECTOR res, VERTEXSET vids=ALL, VECTOR_OR_0 weights
    DEPS: vids ON graph

igraph_maxdegree:
    PARAMS: |-
        GRAPH graph, OUT INTEGER res, VERTEXSET vids=ALL, NEIMODE mode=ALL,
        BOOLEAN loops=True
    DEPS: vids ON graph

igraph_density:
    PARAMS: GRAPH graph, OUT REAL res, BOOLEAN loops=False

igraph_neighborhood_size:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, VERTEXSET vids, INTEGER order,
        NEIMODE mode=ALL, INTEGER mindist=0
    DEPS: vids ON graph

igraph_neighborhood:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST res,
        VERTEXSET vids, INTEGER order,
        NEIMODE mode=ALL, INTEGER mindist=0
    DEPS: res ON graph, vids ON graph

igraph_neighborhood_graphs:
    PARAMS: |-
        GRAPH graph, OUT GRAPHLIST res, VERTEXSET vids,
        INTEGER order,
        NEIMODE mode=ALL, INTEGER mindist=0
    DEPS: vids ON graph

igraph_topological_sorting:
    PARAMS: GRAPH graph, OUT VECTOR res, NEIMODE mode=OUT

igraph_is_loop:
    PARAMS: GRAPH graph, OUT VECTOR_BOOL res, EDGESET es=ALL
    DEPS: es ON graph

igraph_is_dag:
    PARAMS: GRAPH graph, OUT BOOLEAN res

igraph_is_simple:
    PARAMS: GRAPH graph, OUT BOOLEAN res

igraph_is_multiple:
    PARAMS: GRAPH graph, OUT VECTOR_BOOL res, EDGESET es=ALL
    DEPS: es ON graph

igraph_has_multiple:
    PARAMS: GRAPH graph, OUT BOOLEAN res

igraph_count_multiple:
    PARAMS: GRAPH graph, OUT VECTOR res, EDGESET es=ALL
    DEPS: es ON graph

igraph_girth:
    PARAMS: GRAPH graph, OUT INTEGER girth, OUT VERTEXSET circle
    DEPS: circle ON graph

igraph_add_edge:
    PARAMS: INOUT GRAPH graph, INTEGER from, INTEGER to

igraph_eigenvector_centrality:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX vector, OUT REAL value,
        BOOLEAN directed=False, BOOLEAN scale=True,
        EDGEWEIGHTS weights=NULL,
        INOUT ARPACKOPT options=arpack_defaults
    DEPS: weights ON graph, vector ON graph

igraph_hub_score:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX vector, OUT REAL value,
        BOOLEAN scale=True, EDGEWEIGHTS weights=NULL,
        INOUT ARPACKOPT options=arpack_defaults
    DEPS: weights ON graph, vector ON graph

igraph_authority_score:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX vector, OUT REAL value,
        BOOLEAN scale=True, EDGEWEIGHTS weights=NULL,
        INOUT ARPACKOPT options=arpack_defaults
    DEPS: weights ON graph, vector ON graph

igraph_arpack_rssolve:
    # TODO(ntamas): this should probably not be exposed to higher-level
    # interfaces; igraph's goal is not to provide an ARPACK wrapper
    PARAMS: |-
        ARPACKFUNC fun, EXTRA extra, INOUT ARPACKOPT options=arpack_defaults,
        INOUT ARPACKSTORAGE storage, OPTIONAL OUT VECTOR values, OPTIONAL OUT MATRIX vectors

igraph_arpack_rnsolve:
    # TODO(ntamas): this should probably not be exposed to higher-level
    # interfaces; igraph's goal is not to provide an ARPACK wrapper
    PARAMS: |-
        ARPACKFUNC fun, EXTRA extra, INOUT ARPACKOPT options=arpack_defaults,
        INOUT ARPACKSTORAGE storage, OPTIONAL OUT MATRIX values, OPTIONAL OUT MATRIX vectors

igraph_arpack_unpack_complex:
    # TODO(ntamas): this should probably not be exposed to higher-level
    # interfaces; igraph's goal is not to provide an ARPACK wrapper
    PARAMS: INOUT MATRIX vectors, INOUT MATRIX values, LONGINT nev

igraph_unfold_tree:
    PARAMS: |-
        GRAPH graph, OUT GRAPH tree, NEIMODE mode=ALL, VECTOR roots,
        OUT VECTORM1_OR_0 vertex_index

igraph_is_mutual:
    PARAMS: GRAPH graph, OUT VECTOR_BOOL res, EDGESET es=ALL
    DEPS: es ON graph

igraph_maximum_cardinality_search:
    PARAMS: GRAPH graph, OUT VERTEXSET alpha, OUT VECTORM1_OR_0 alpham1
    DEPS: alpha ON graph, alpham1 ON graph

igraph_is_chordal:
    PARAMS: |-
        GRAPH graph, VECTORM1_OR_0 alpha=NULL, VECTORM1_OR_0 alpham1=NULL,
        OPTIONAL OUT BOOLEAN chordal, OUT VECTORM1_OR_0 fillin,
        OUT GRAPH_OR_0 newgraph

igraph_avg_nearest_neighbor_degree:
    PARAMS: |-
        GRAPH graph, VERTEXSET vids=ALL,
        NEIMODE mode=ALL, NEIMODE neighbor_degree_mode=ALL,
        OPTIONAL OUT VERTEXINDEX knn, OUT VECTOR_OR_0 knnk,
        EDGEWEIGHTS weights=NULL
    DEPS: vids ON graph, weights ON graph, knn ON graph vids

igraph_strength:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        NEIMODE mode=ALL, BOOLEAN loops=True, EDGEWEIGHTS weights=NULL
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_centralization:
    PARAMS: VECTOR scores, REAL theoretical_max=0, BOOLEAN normalized=True
    RETURN: REAL

igraph_centralization_degree:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res,
        NEIMODE mode=ALL, BOOLEAN loops=True,
        OUT REAL centralization, OUT REAL theoretical_max,
        BOOLEAN normalized=True

igraph_centralization_degree_tmax:
    PARAMS: |-
        GRAPH_OR_0 graph=NULL, INTEGER nodes=0, NEIMODE mode=ALL,
        BOOLEAN loops=False, OUT REAL res

igraph_centralization_betweenness:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res,
        BOOLEAN directed=True,
        OUT REAL centralization,
        OUT REAL theoretical_max,
        BOOLEAN normalized=True

igraph_centralization_betweenness_tmax:
    PARAMS: |-
        GRAPH_OR_0 graph=NULL, INTEGER nodes=0,
        BOOLEAN directed=True, OUT REAL res

igraph_centralization_closeness:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res,
        NEIMODE mode=OUT, OUT REAL centralization,
        OUT REAL theoretical_max,
        BOOLEAN normalized=True

igraph_centralization_closeness_tmax:
    PARAMS: |-
        GRAPH_OR_0 graph=NULL, INTEGER nodes=0,
        NEIMODE mode=OUT, OUT REAL res

igraph_centralization_eigenvector_centrality:
    PARAMS: |-
        GRAPH graph, OUT VECTOR vector, OUT REAL value,
        BOOLEAN directed=False, BOOLEAN scale=True,
        INOUT ARPACKOPT options=arpack_defaults,
        OUT REAL centralization, OUT REAL theoretical_max,
        BOOLEAN normalized=True

igraph_centralization_eigenvector_centrality_tmax:
    PARAMS: |-
        GRAPH_OR_0 graph=NULL, INTEGER nodes=0,
        BOOLEAN directed=False, BOOLEAN scale=True,
        OUT REAL res

igraph_assortativity_nominal:
    PARAMS: |-
        GRAPH graph, VECTORM1 types, OUT REAL res,
        BOOLEAN directed=True

igraph_assortativity:
    PARAMS: |-
        GRAPH graph, VECTOR types1, VECTOR_OR_0 types2=NULL,
        OUT REAL res, BOOLEAN directed=True

igraph_assortativity_degree:
    PARAMS: GRAPH graph, OUT REAL res, BOOLEAN directed=True

igraph_contract_vertices:
    PARAMS: |-
        INOUT GRAPH graph, VECTORM1 mapping,
        VERTEX_ATTRIBUTE_COMBINATION vertex_attr_comb=Default

igraph_eccentricity:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        NEIMODE mode=ALL
    DEPS: vids ON graph, res ON graph vids

igraph_radius:
    PARAMS: GRAPH graph, OUT REAL radius, NEIMODE mode=ALL

igraph_diversity:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL, OUT VERTEXINDEX res,
        VERTEXSET vids=ALL
    DEPS: weights ON graph, vids ON graph, res ON graph vids

igraph_random_walk:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSET walk, VERTEX start, NEIMODE mode=OUT,
        INTEGER steps, RWSTUCK stuck=RETURN
    DEPS: start ON graph, walk ON graph

igraph_random_edge_walk:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL, OUT EDGESET edgewalk,
        VERTEX start, NEIMODE mode=OUT, INTEGER steps, RWSTUCK stuck=RETURN
    DEPS: start ON graph, weights ON graph, edgewalk ON graph

igraph_global_efficiency:
    PARAMS: GRAPH graph, OUT REAL res, VERTEXWEIGHTS weights=NULL, BOOLEAN directed=True
    DEPS: weights ON graph

igraph_local_efficiency:
    PARAMS: |-
        GRAPH graph, OUT VERTEXINDEX res, VERTEXSET vids=ALL,
        VERTEXWEIGHTS weights=NULL, BOOLEAN directed=True, NEIMODE mode=ALL
    DEPS: vids ON graph, weights ON graph, res ON graph vids

igraph_average_local_efficiency:
    PARAMS: |-
        GRAPH graph, OUT REAL res, VERTEXWEIGHTS weights=NULL,
        BOOLEAN directed=True, NEIMODE mode=ALL
    DEPS: weights ON graph

#######################################
# Degree sequences
#######################################

igraph_is_bigraphical:
    PARAMS: |-
        VECTOR degrees1, VECTOR degrees2,
        EDGE_TYPE_SW allowed_edge_types=SIMPLE, OUT BOOLEAN res

igraph_is_degree_sequence:
    PARAMS: VECTOR out_deg, VECTOR_OR_0 in_deg=NULL, OUT BOOLEAN res
    FLAGS: DEPRECATED

igraph_is_graphical:
    PARAMS: |-
        VECTOR out_deg, VECTOR_OR_0 in_deg=NULL,
        EDGE_TYPE_SW allowed_edge_types=SIMPLE, OUT BOOLEAN res

igraph_is_graphical_degree_sequence:
    PARAMS: VECTOR out_deg, VECTOR_OR_0 in_deg=NULL, OUT BOOLEAN res
    FLAGS: DEPRECATED

#######################################
# Visitors
#######################################

igraph_bfs:
    PARAMS: |-
        GRAPH graph, INTEGER root, VECTOR_OR_0 roots,
        NEIMODE mode=OUT, BOOLEAN unreachable,
        VECTOR_OR_0 restricted,
        OUT VECTOR_OR_0 order, OUT VECTOR_OR_0 rank,
        OUT VECTOR_OR_0 father,
        OUT VECTOR_OR_0 pred, OUT VECTOR_OR_0 succ,
        OUT VECTOR_OR_0 dist, BFS_FUNC callback, EXTRA extra

igraph_dfs:
    PARAMS: |-
        GRAPH graph, INTEGER root, NEIMODE mode=OUT, BOOLEAN unreachable,
        OUT VECTOR_OR_0 order, OUT VECTOR_OR_0 order_out,
        OUT VECTOR_OR_0 father, OUT VECTOR_OR_0 dist,
        DFS_FUNC in_callback, DFS_FUNC out_callback, EXTRA extra

#######################################
# Bipartite graphs
#######################################

igraph_bipartite_projection_size:
    PARAMS: |-
        GRAPH graph, BIPARTITE_TYPES types=NULL,
        OUT INTEGER vcount1, OUT INTEGER ecount1,
        OUT INTEGER vcount2, OUT INTEGER ecount2
    DEPS: types ON graph

igraph_bipartite_projection:
    PARAMS: |-
        GRAPH graph, BIPARTITE_TYPES types=NULL,
        OUT GRAPH proj1, OUT GRAPH proj2,
        OUT VECTOR_OR_0 multiplicity1,
        OUT VECTOR_OR_0 multiplicity2, INTEGER probe1=-1
    DEPS: types ON graph

igraph_create_bipartite:
    PARAMS: |-
        OUT GRAPH graph, IN VECTOR_BOOL types,
        VECTORM1 edges, BOOLEAN directed=False

igraph_incidence:
    PARAMS: |-
        OUT GRAPH graph, OUT VECTOR_BOOL types, MATRIX incidence,
        BOOLEAN directed=False, NEIMODE mode=ALL,
        BOOLEAN multiple=False

igraph_get_incidence:
    PARAMS: |-
        GRAPH graph, BIPARTITE_TYPES types=NULL, OUT MATRIX res,
        OUT VECTOR_OR_0 row_ids, OUT VECTOR_OR_0 col_ids
    DEPS: types ON graph

igraph_is_bipartite:
    PARAMS: GRAPH graph, OUT BOOLEAN res, OUT VECTOR_BOOL_OR_0 type

igraph_bipartite_game_gnp:
    PARAMS: |-
        OUT GRAPH graph, OUT VECTOR_BOOL_OR_0 types,
        INTEGER n1, INTEGER n2, REAL p, BOOLEAN directed,
        NEIMODE mode

igraph_bipartite_game_gnm:
    PARAMS: |-
        OUT GRAPH graph, OUT VECTOR_BOOL_OR_0 types,
        INTEGER n1, INTEGER n2, INTEGER m, BOOLEAN directed,
        NEIMODE mode

#######################################
# Spectral properties
#######################################

igraph_laplacian:
    PARAMS: |-
        GRAPH graph, OUT MATRIX_OR_0 res,
        OUT SPARSEMAT_OR_0 sparseres, BOOLEAN normalized=False,
        EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

#######################################
# Components
#######################################

igraph_clusters:
    PARAMS: |-
        GRAPH graph, OUT VECTOR membership, OUT VECTOR csize,
        OUT INTEGER no, CONNECTEDNESS mode=WEAK

igraph_is_connected:
    PARAMS: GRAPH graph, OUT BOOLEAN res, CONNECTEDNESS mode=WEAK

igraph_decompose:
    PARAMS: |-
        GRAPH graph, OUT GRAPHLIST components, CONNECTEDNESS mode=WEAK,
        LONGINT maxcompno=-1, LONGINT minelements=1

igraph_articulation_points:
    PARAMS: GRAPH graph, OUT VERTEXSET res
    DEPS: res ON graph

igraph_biconnected_components:
    PARAMS: |-
        GRAPH graph, OUT INTEGER no,
        OPTIONAL OUT EDGESETLIST tree_edges,
        OPTIONAL OUT EDGESETLIST component_edges,
        OPTIONAL OUT VERTEXSETLIST components,
        OUT VERTEXSET articulation_points
    DEPS: |-
        tree_edges ON graph, component_edges ON graph,
        components ON graph, articulation_points ON graph

igraph_bridges:
    PARAMS: GRAPH graph, OUT EDGESET res
    DEPS: res ON graph

#######################################
# Cliques
#######################################

igraph_cliques:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST res, INTEGER min_size=0,
        INTEGER max_size=0
    DEPS: res ON graph

igraph_cliques_callback:
    PARAMS: |-
        GRAPH graph, INTEGER min_size=0, INTEGER max_size=0,
        CLIQUE_FUNC cliquehandler_fn, EXTRA arg

igraph_clique_size_hist:
    PARAMS: |-
        GRAPH graph, OUT VECTOR hist, INTEGER min_size=0, INTEGER max_size=0

igraph_largest_cliques:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST res
    DEPS: res ON graph

igraph_maximal_cliques:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST res, INTEGER min_size=0, INTEGER max_size=0
    DEPS: res ON graph

igraph_maximal_cliques_callback:
    PARAMS: |-
        GRAPH graph, CLIQUE_FUNC cliquehandler_fn, EXTRA arg,
        INTEGER min_size=0, INTEGER max_size=0

igraph_maximal_cliques_count:
    PARAMS: |-
        GRAPH graph, OUT INTEGER no, INTEGER min_size=0, INTEGER max_size=0

igraph_maximal_cliques_file:
    PARAMS: |-
        GRAPH graph, OUTFILE res, INTEGER min_size=0, INTEGER max_size=0

igraph_maximal_cliques_hist:
    PARAMS: |-
        GRAPH graph, OUT VECTOR hist, INTEGER min_size=0, INTEGER max_size=0

igraph_clique_number:
    PARAMS: GRAPH graph, OUT INTEGER no

igraph_weighted_cliques:
    PARAMS: |-
        GRAPH graph, VERTEXWEIGHTS vertex_weights=NULL, OUT VERTEXSETLIST res,
        REAL min_weight=0, REAL max_weight=0, BOOLEAN maximal=False
    DEPS: vertex_weights ON graph, res ON graph

igraph_largest_weighted_cliques:
    PARAMS: |-
        GRAPH graph, VERTEXWEIGHTS vertex_weights=NULL, OUT VERTEXSETLIST res
    DEPS: vertex_weights ON graph, res ON graph

igraph_weighted_clique_number:
    PARAMS: GRAPH graph, VERTEXWEIGHTS vertex_weights=NULL, OUT REAL res
    DEPS: vertex_weights ON graph

igraph_independent_vertex_sets:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST res, INTEGER min_size=0,
        INTEGER max_size=0
    DEPS: res ON graph

igraph_largest_independent_vertex_sets:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST res
    DEPS: res ON graph

igraph_maximal_independent_vertex_sets:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST res
    DEPS: res ON graph

igraph_independence_number:
    PARAMS: GRAPH graph, OUT INTEGER no

#######################################
# Layouts
#######################################

igraph_layout_random:
    PARAMS: GRAPH graph, OUT MATRIX res

igraph_layout_circle:
    PARAMS: GRAPH graph, OUT MATRIX res, VERTEXSET order=ALL
    DEPS: order ON graph

igraph_layout_star:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEX center=V(graph)[1],
        VECTORM1_OR_0 order=NULL
    DEPS: center ON graph

igraph_layout_grid:
    PARAMS: GRAPH graph, OUT MATRIX res, LONGINT width=0

igraph_layout_grid_3d:
    PARAMS: GRAPH graph, OUT MATRIX res, LONGINT width=0, LONGINT height=0

igraph_layout_fruchterman_reingold:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX coords=NULL,
        BOOLEAN use_seed=False, INTEGER niter=500,
        REAL start_temp=sqrt(vcount(graph)),
        LAYOUT_GRID grid=AUTO, EDGEWEIGHTS weights=NULL,
        VECTOR_OR_0 minx=NULL, VECTOR_OR_0 maxx=NULL,
        VECTOR_OR_0 miny=NULL, VECTOR_OR_0 maxy=NULL,
        DEPRECATED coolexp, DEPRECATED maxdelta, DEPRECATED area,
        DEPRECATED repulserad
    DEPS: weights ON graph

igraph_layout_kamada_kawai:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX coords, BOOLEAN use_seed=False,
        INTEGER maxiter=500, REAL epsilon=0.0,
        REAL kkconst=vcount(graph), EDGEWEIGHTS weights=NULL,
        VECTOR_OR_0 minx=NULL, VECTOR_OR_0 maxx=NULL,
        VECTOR_OR_0 miny=NULL, VECTOR_OR_0 maxy=NULL
    DEPS: weights ON graph

igraph_layout_lgl:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, INTEGER maxiter=150, REAL maxdelta=VCOUNT(graph),
        REAL area=VCOUNT(graph)^2, REAL coolexp=1.5, REAL repulserad=VCOUNT(graph)^3, REAL cellsize=VCOUNT(graph),
        INTEGER root=-1

igraph_layout_reingold_tilford:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, NEIMODE mode=OUT,
        OPTIONAL VECTOR roots, OPTIONAL VECTOR rootlevel

igraph_layout_reingold_tilford_circular:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, NEIMODE mode=OUT,
        OPTIONAL VECTOR roots, OPTIONAL VECTOR rootlevel

igraph_layout_random_3d:
    PARAMS: GRAPH graph, OUT MATRIX res

igraph_layout_sphere:
    PARAMS: GRAPH graph, OUT MATRIX res

igraph_layout_fruchterman_reingold_3d:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX coords=NULL,
        BOOLEAN use_seed=False, INTEGER niter=500,
        REAL start_temp=sqrt(vcount(graph)),
        EDGEWEIGHTS weights=NULL,
        VECTOR_OR_0 minx=NULL, VECTOR_OR_0 maxx=NULL,
        VECTOR_OR_0 miny=NULL, VECTOR_OR_0 maxy=NULL,
        VECTOR_OR_0 minz=NULL, VECTOR_OR_0 maxz=NULL,
        DEPRECATED coolexp, DEPRECATED maxdelta, DEPRECATED area,
        DEPRECATED repulserad
    DEPS: weights ON graph

igraph_layout_kamada_kawai_3d:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX coords, BOOLEAN use_seed=False,
        INTEGER maxiter=500, REAL epsilon=0.0,
        REAL kkconst=vcount(graph), EDGEWEIGHTS weights=NULL,
        VECTOR_OR_0 minx=NULL, VECTOR_OR_0 maxx=NULL,
        VECTOR_OR_0 miny=NULL, VECTOR_OR_0 maxy=NULL,
        VECTOR_OR_0 minz=NULL, VECTOR_OR_0 maxz=NULL
    DEPS: weights ON graph

igraph_layout_graphopt:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX res, INTEGER niter=500,
        REAL node_charge=0.001, REAL node_mass=30,
        REAL spring_length=0, REAL spring_constant=1,
        REAL max_sa_movement=5, BOOLEAN use_seed=False

igraph_layout_drl:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX res, BOOLEAN use_seed=False,
        DRL_OPTIONS options=drl_defaults$default, VECTOR_OR_0 weights=NULL,
        VECTOR_BOOL_OR_0 fixed=NULL

igraph_layout_drl_3d:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX res, BOOLEAN use_seed=False,
        DRL_OPTIONS options=drl_defaults$default, VECTOR_OR_0 weights=NULL,
        VECTOR_BOOL_OR_0 fixed=NULL

igraph_layout_merge_dla:
    PARAMS: GRAPHLIST graphs, MATRIXLIST coords, OUT MATRIX res

igraph_layout_sugiyama:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, OUT GRAPH_OR_0 extd_graph,
        OUT VECTORM1_OR_0 extd_to_orig_eids,
        VECTORM1_OR_0 layers=NULL,
        REAL hgap=1, REAL vgap=1, LONGINT maxiter=100,
        EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

igraph_layout_mds:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, MATRIX_OR_0 dist=NULL, LONGINT dim=2

igraph_layout_bipartite:
    PARAMS: |-
        GRAPH graph, BIPARTITE_TYPES types=NULL, OUT MATRIX res,
        REAL hgap=1, REAL vgap=1, LONGINT maxiter=100
    DEPS: types ON graph

igraph_layout_gem:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX res=matrix(),
        BOOLEAN use_seed=False,
        INTEGER maxiter=40*vcount(graph)^2,
        REAL temp_max=vcount(graph),
        REAL temp_min=1/10, REAL temp_init=sqrt(vcount(graph))

igraph_layout_davidson_harel:
    PARAMS: |-
        GRAPH graph, INOUT MATRIX res=matrix(),
        BOOLEAN use_seed=False, INTEGER maxiter=10,
        INTEGER fineiter=FINEITER, REAL cool_fact=0.75,
        REAL weight_node_dist=1.0, REAL weight_border=0.0,
        REAL weight_edge_lengths=ELENW,
        REAL weight_edge_crossings=ECROSSW,
        REAL weight_node_edge_dist=NEDISTW

#######################################
# Cocitation and other similarity measures
#######################################

igraph_cocitation:
    PARAMS: GRAPH graph, OUT MATRIX res, VERTEXSET vids=ALL
    DEPS: vids ON graph

igraph_bibcoupling:
    PARAMS: GRAPH graph, OUT MATRIX res, VERTEXSET vids=ALL
    DEPS: vids ON graph

igraph_similarity_jaccard:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET vids=ALL, NEIMODE mode=ALL,
        BOOLEAN loops=False
    DEPS: vids ON graph res, mode ON vids

igraph_similarity_dice:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, VERTEXSET vids=ALL, NEIMODE mode=ALL,
        BOOLEAN loops=False
    DEPS: vids ON graph

igraph_similarity_inverse_log_weighted:
    PARAMS: GRAPH graph, OUT MATRIX res, VERTEXSET vids=ALL, NEIMODE mode=ALL
    DEPS: vids ON graph

#######################################
# Community structure
#######################################

igraph_compare_communities:
    PARAMS: |-
        VECTOR comm1, VECTOR comm2, OUT REAL res, COMMCMP method=VI

igraph_community_spinglass:
    PARAMS: |-
        GRAPH graph, VECTOR_OR_0 weights, OUT REAL modularity,
        OUT REAL temperature, OUT VECTOR membership, OUT VECTOR csize,
        INTEGER spins=25, BOOLEAN parupdate=False, REAL starttemp=1, REAL stoptemp=0.01,
        REAL coolfact=0.99, SPINCOMMUPDATE update_rule=CONFIG, REAL gamma=1.0,
        SPINGLASS_IMPLEMENTATION implementation=ORIG, REAL lambda=1.0

igraph_community_spinglass_single:
    PARAMS: |-
        GRAPH graph, VECTOR_OR_0 weights, INTEGER vertex, OUT VECTOR community,
        OUT REAL cohesion, OUT REAL adhesion,
        OUT INTEGER inner_links, OUT INTEGER outer_links,
        INTEGER spins=25, SPINCOMMUPDATE update_rule=CONFIG, REAL gamma=1.0

igraph_community_walktrap:
    PARAMS: |-
        GRAPH graph, VECTOR weights, INT steps=4, OUT MATRIX merges,
        OUT VECTOR modularity, OUT VECTOR membership

igraph_community_edge_betweenness:
    PARAMS: |-
        GRAPH graph, OUT VECTOR result, OUT VECTOR edge_betweenness,
        OUT MATRIX merges, OUT VECTOR bridges,
        OUT VECTOR_OR_0 modularity, OUT VECTOR_OR_0 membership,
        BOOLEAN directed=True, EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

igraph_community_eb_get_merges:
    PARAMS: |-
        GRAPH graph, BOOLEAN directed, VECTOR edges, EDGEWEIGHTS weights=NULL,
        OUT MATRIX merges, OUT VECTOR bridges,
        OUT VECTOR_OR_0 modularity, OUT VECTOR_OR_0 membership
    DEPS: weights ON graph

igraph_community_fastgreedy:
    PARAMS: |-
        GRAPH graph, VECTOR_OR_0 weights, OUT MATRIX merges, OUT VECTOR modularity,
        OUT VECTOR_OR_0 membership

igraph_community_to_membership:
    PARAMS: |-
        MATRIX merges, INTEGER nodes, INTEGER steps,
        OUT VECTOR membership, OUT VECTOR csize

igraph_le_community_to_membership:
    PARAMS: |-
        MATRIX merges, INTEGER steps, INOUT VECTOR membership,
        OUT VECTOR_OR_0 csize

igraph_modularity:
    PARAMS: |-
        GRAPH graph, VECTOR membership, IN VECTOR_OR_0 weights=NULL,
        REAL resolution=1.0, BOOLEAN directed=True, OUT REAL modularity

igraph_modularity_matrix:
    PARAMS: |-
        GRAPH graph,
        EDGEWEIGHTS weights=NULL,
        REAL resolution=1.0,
        OUT MATRIX modmat,
        BOOLEAN directed=True
    DEPS: weights ON graph

igraph_reindex_membership:
    PARAMS: |-
        INOUT VECTOR membership, OUT VECTOR_OR_0 new_to_old,
        OUT INTEGER nb_clusters

igraph_community_leading_eigenvector:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        OUT MATRIX merges, OUT VECTOR membership,
        INTEGER steps=-1,
        INOUT ARPACKOPT options=arpack_defaults,
        OUT REAL modularity, BOOLEAN start=False,
        OUT VECTOR_OR_0 eigenvalues,
        OPTIONAL OUT VECTORLIST eigenvectors,
        OUT VECTOR_OR_0 history,
        LEVCFUNC callback, EXTRA callback_extra

igraph_community_fluid_communities:
    PARAMS: |-
        GRAPH graph, INTEGER no_of_communities,
        OUT VECTOR membership, OUT REAL modularity

igraph_community_label_propagation:
    PARAMS: |-
        GRAPH graph, OUT VECTOR membership, EDGEWEIGHTS weights=NULL,
        VECTOR_OR_0 initial=NULL, VECTOR_BOOL_OR_0 fixed=NULL,
        OUT REAL modularity
    DEPS: weights ON graph

igraph_community_multilevel:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        REAL resolution=1.0,
        OUT VECTOR membership,
        OUT MATRIX_OR_0 memberships, OUT VECTOR_OR_0 modularity
    DEPS: weights ON graph

igraph_community_optimal_modularity:
    PARAMS: |-
        GRAPH graph, OUT REAL modularity,
        OUT VECTOR_OR_0 membership,
        EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

igraph_community_leiden:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        VERTEXWEIGHTS vertex_weights=NULL,
        REAL resolution_parameter, REAL beta,
        BOOLEAN start, INOUT VECTOR_OR_0 membership,
        OUT INTEGER nb_clusters, OUT REAL quality
    DEPS: weights ON graph, vertex_weights ON graph

igraph_split_join_distance:
    PARAMS: |-
        VECTOR comm1, VECTOR comm2, OUT INTEGER distance12,
        OUT INTEGER distance21

igraph_hrg_fit:
    PARAMS: |-
        GRAPH graph, INOUT HRG hrg=Default, BOOLEAN start=False,
        INT steps=0

igraph_hrg_game:
    PARAMS: OUT GRAPH graph, HRG hrg

igraph_hrg_dendrogram:
    PARAMS: OUT GRAPH graph, HRG hrg

igraph_hrg_consensus:
    PARAMS: |-
        GRAPH graph, OUT VECTOR parents, OUT VECTOR weights,
        INOUT HRG hrg=Default, BOOLEAN start=False,
        INT num_samples=10000

igraph_hrg_predict:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSET edges, OUT VECTOR prob,
        INOUT HRG hrg=Default, BOOLEAN start=False,
        INT num_samples=10000, INT num_bins=25
    DEPS: edges ON graph

igraph_hrg_create:
    PARAMS: OUT HRG hrg, GRAPH graph, VECTOR prob
    DEPS: prob ON graph

igraph_community_infomap:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS e_weights=NULL,
        VERTEXWEIGHTS v_weights=NULL, INT nb_trials=10,
        OUT VECTOR membership, OUT REAL codelength
    DEPS: e_weights ON graph, v_weights ON graph

igraph_graphlets:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        OUT VERTEXSETLIST cliques, OUT VECTOR Mu, INT niter=1000
    DEPS: weights ON graph, cliques ON graph

igraph_graphlets_candidate_basis:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        OUT VERTEXSETLIST cliques, OUT VECTOR thresholds
    DEPS: weights ON graph, cliques ON graph

igraph_graphlets_project:
    PARAMS: |-
        GRAPH graph, EDGEWEIGHTS weights=NULL,
        VERTEXSETLIST cliques, INOUT VECTOR Muc,
        BOOLEAN startMu=False, INT niter=1000
    DEPS: weights ON graph

#######################################
# Conversion
#######################################

igraph_get_adjacency:
    PARAMS: |-
        GRAPH graph, OUT MATRIX res, GETADJACENCY type=BOTH,
        BOOLEAN eids=False

igraph_get_edgelist:
    PARAMS: GRAPH graph, OUT VECTOR res, BOOLEAN bycol=False

igraph_to_directed:
    PARAMS: INOUT GRAPH graph, TODIRECTED flags=MUTUAL

igraph_to_undirected:
    PARAMS: |-
        INOUT GRAPH graph, TOUNDIRECTED mode=COLLAPSE,
        EDGE_ATTRIBUTE_COMBINATION edge_attr_comb=Default

igraph_get_stochastic:
    PARAMS: GRAPH graph, OUT MATRIX res, BOOLEAN column_wise=False

igraph_get_stochastic_sparsemat:
    PARAMS: |-
        GRAPH graph, OUT SPARSEMATPTR sparsemat,
        BOOLEAN column_wise=False

#######################################
# Read and write foreign formats
#######################################

igraph_read_graph_edgelist:
    PARAMS: OUT GRAPH graph, INFILE instream, INTEGER n=0, BOOLEAN directed=True

igraph_read_graph_ncol:
    PARAMS: |-
        OUT GRAPH graph, INFILE instream, OPTIONAL STRVECTOR predefnames,
        BOOLEAN names=True, ADD_WEIGHTS weights=True, BOOLEAN directed=True

igraph_read_graph_lgl:
    PARAMS: |-
        OUT GRAPH graph, INFILE instream, BOOLEAN names=True,
        ADD_WEIGHTS weights=True, BOOLEAN directed=True

igraph_read_graph_pajek:
    PARAMS: OUT GRAPH graph, INFILE instream

igraph_read_graph_graphml:
    PARAMS: OUT GRAPH graph, INFILE instream, INT index=0

igraph_read_graph_dimacs:
    PARAMS: |-
        OUT GRAPH graph, INFILE instream,
        OPTIONAL OUT STRVECTOR problem, OPTIONAL OUT VECTOR label,
        OPTIONAL OUT INTEGER source, OPTIONAL OUT INTEGER target,
        OPTIONAL OUT VECTOR capacity, BOOLEAN directed=True

igraph_read_graph_graphdb:
    PARAMS: OUT GRAPH graph, INFILE instream, BOOLEAN directed=False

igraph_read_graph_gml:
    PARAMS: OUT GRAPH graph, INFILE instream

igraph_read_graph_dl:
    PARAMS: OUT GRAPH graph, INFILE instream, BOOLEAN directed=True

igraph_write_graph_edgelist:
    PARAMS: GRAPH graph, OUTFILE outstream

igraph_write_graph_ncol:
    PARAMS: GRAPH graph, OUTFILE outstream, CSTRING names="name", CSTRING weights="weight"

igraph_write_graph_lgl:
    PARAMS: |-
        GRAPH graph, OUTFILE outstream, CSTRING names="name", CSTRING weights="weight",
        BOOLEAN isolates=True

igraph_write_graph_leda:
    PARAMS: GRAPH graph, OUTFILE outstream, CSTRING names="name", CSTRING weights="weight"

igraph_write_graph_graphml:
    PARAMS: GRAPH graph, OUTFILE outstream, BOOLEAN prefixattr=True

igraph_write_graph_pajek:
    PARAMS: GRAPH graph, OUTFILE outstream

igraph_write_graph_dimacs:
    PARAMS: |-
        GRAPH graph, OUTFILE outstream, LONGINT source=0, LONGINT target=0,
        VECTOR capacity

igraph_write_graph_gml:
    PARAMS: GRAPH graph, OUTFILE outstream, VECTOR id, CSTRING creator="igraph"

igraph_write_graph_dot:
    PARAMS: GRAPH graph, OUTFILE outstream

#######################################
# Motifs
#######################################

igraph_motifs_randesu:
    PARAMS: GRAPH graph, OUT VECTOR hist, INT size=3, VECTOR cut_prob

igraph_motifs_randesu_estimate:
    PARAMS: |-
        GRAPH graph, OUT INTEGER est, INT size=3, VECTOR cut_prob,
        INTEGER sample_size, VECTOR_OR_0 sample

igraph_motifs_randesu_no:
    PARAMS: GRAPH graph, OUT INTEGER no, INT size=3, VECTOR cut_prob

igraph_dyad_census:
    PARAMS: GRAPH graph, OUT INTEGER mut, OUT INTEGER asym, OUT INTEGER null
    RETURN: ERROR

igraph_triad_census:
    PARAMS: GRAPH graph, OUT VECTOR res
    RETURN: ERROR

igraph_adjacent_triangles:
    PARAMS: GRAPH graph, OUT VECTOR res, VERTEXSET vids=ALL
    DEPS: vids ON graph

igraph_local_scan_0:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, EDGEWEIGHTS weights=NULL,
        NEIMODE mode=OUT
    DEPS: weights ON graph

igraph_local_scan_0_them:
    PARAMS: |-
        GRAPH us, GRAPH them, OUT VECTOR res,
        EDGEWEIGHTS weights_them=NULL, NEIMODE mode=OUT
    DEPS: weights_them ON them

igraph_local_scan_1_ecount:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, EDGEWEIGHTS weights=NULL,
        NEIMODE mode=OUT
    DEPS: weights ON graph

igraph_local_scan_1_ecount_them:
    PARAMS: |-
        GRAPH us, GRAPH them, OUT VECTOR res,
        EDGEWEIGHTS weights_them=NULL, NEIMODE mode=OUT
    DEPS: weights_them ON them

igraph_local_scan_k_ecount:
    PARAMS: |-
        GRAPH graph, INT k, OUT VECTOR res, EDGEWEIGHTS weights=NULL,
        NEIMODE mode=OUT
    DEPS: weights ON graph

igraph_local_scan_k_ecount_them:
    PARAMS: |-
        GRAPH us, GRAPH them, INT k, OUT VECTOR res,
        EDGEWEIGHTS weights_them=NULL, NEIMODE mode=OUT
    DEPS: weights_them ON them

igraph_local_scan_neighborhood_ecount:
    PARAMS: |-
        GRAPH graph, OUT VECTOR res, EDGEWEIGHTS weights=NULL,
        VERTEXSETLIST_INT neighborhoods
    DEPS: weights ON graph

igraph_list_triangles:
    PARAMS: GRAPH graph, OUT VERTEXSET_INT res
    DEPS: res ON graph

#######################################
# Graph operators
#######################################

igraph_disjoint_union:
    PARAMS: OUT GRAPH res, GRAPH left, GRAPH right

igraph_disjoint_union_many:
    PARAMS: OUT GRAPH res, GRAPHLIST graphs

igraph_union:
    PARAMS: |-
        OUT GRAPH res, GRAPH left, GRAPH right,
        OUT VECTORM1 edge_map_left, OUT VECTORM1 edge_map_right
    DEPS: edge_map_left ON left, edge_map_right ON right

igraph_union_many:
    PARAMS: OUT GRAPH res, GRAPHLIST graphs, OUT VECTORLIST edgemaps

igraph_intersection:
    PARAMS: |-
        OUT GRAPH res, GRAPH left, GRAPH right,
        OUT VECTORM1 edge_map_left, OUT VECTORM1 edge_map_right
    DEPS: edge_map_left ON left, edge_map_right ON right

igraph_intersection_many:
    PARAMS: OUT GRAPH res, GRAPHLIST graphs, OUT VECTORLIST edgemaps

igraph_difference:
    PARAMS: OUT GRAPH res, GRAPH orig, GRAPH sub

igraph_complementer:
    PARAMS: OUT GRAPH res, GRAPH graph, BOOLEAN loops=False

igraph_compose:
    PARAMS: |-
        OUT GRAPH res, GRAPH g1, GRAPH g2,
        OUT VECTORM1 edge_map1, OUT VECTORM1 edge_map2
    DEPS: edge_map1 ON g1, edge_map2 ON g2

#######################################
# Maximum flows, minimum cuts
#######################################

igraph_maxflow:
    PARAMS: |-
        GRAPH graph, OUT REAL value, OUT VECTOR_OR_0 flow,
        OUT VECTORM1_OR_0 cut, OPTIONAL OUT VERTEXSET partition1,
        OPTIONAL OUT VERTEXSET partition2, VERTEX source, VERTEX target,
        EDGECAPACITY capacity=NULL, OUT MAXFLOW_STATS stats
    DEPS: |-
        capacity ON graph, source ON graph, target ON graph,
        partition1 ON graph, partition2 ON graph, flow ON graph,
        cut ON graph

igraph_maxflow_value:
    PARAMS: |-
        GRAPH graph, OUT REAL value, VERTEX source, VERTEX target,
        VECTOR_OR_0 capacity, OUT MAXFLOW_STATS stats
    DEPS: source ON graph, target ON graph

igraph_mincut_value:
    PARAMS: GRAPH graph, OUT REAL res, VECTOR_OR_0 capacity

igraph_st_mincut_value:
    PARAMS: |-
        GRAPH graph, OUT REAL res, VERTEX source, VERTEX target,
        VECTOR_OR_0 capacity
    DEPS: source ON graph, target ON graph

igraph_mincut:
    PARAMS: |-
        GRAPH graph, OUT REAL value, OUT VECTORM1 partition1,
        OUT VECTORM1 partition2, OUT VECTORM1 cut, VECTOR_OR_0 capacity

igraph_st_vertex_connectivity:
    PARAMS: |-
        GRAPH graph, OUT INTEGER res, VERTEX source, VERTEX target,
        VCONNNEI neighbors=NUMBER_OF_NODES
    DEPS: source ON graph, target ON graph

igraph_vertex_connectivity:
    PARAMS: GRAPH graph, OUT INTEGER res, BOOLEAN checks=True

igraph_st_edge_connectivity:
    PARAMS: GRAPH graph, OUT INTEGER res, VERTEX source, VERTEX target
    DEPS: source ON graph, target ON graph

igraph_edge_connectivity:
    PARAMS: GRAPH graph, OUT INTEGER res, BOOLEAN checks=True

igraph_edge_disjoint_paths:
    PARAMS: GRAPH graph, OUT INTEGER res, VERTEX source, VERTEX target
    DEPS: source ON graph, target ON graph

igraph_vertex_disjoint_paths:
    PARAMS: GRAPH graph, OUT INTEGER res, VERTEX source, VERTEX target
    DEPS: source ON graph, target ON graph

igraph_adhesion:
    PARAMS: GRAPH graph, OUT INTEGER res, BOOLEAN checks=True

igraph_cohesion:
    PARAMS: GRAPH graph, OUT INTEGER res, BOOLEAN checks=True

#######################################
# Listing s-t cuts, separators
#######################################

igraph_dominator_tree:
    PARAMS: |-
        GRAPH graph, VERTEX root, OUT VERTEXSET dom,
        OUT GRAPH_OR_0 domtree, OUT VERTEXSET leftout,
        NEIMODE mode=OUT
    DEPS: root ON graph, dom ON graph, leftout ON graph

igraph_all_st_cuts:
    PARAMS: |-
        GRAPH graph, OPTIONAL OUT EDGESETLIST cuts,
        OPTIONAL OUT VERTEXSETLIST partition1s,
        VERTEX source, VERTEX target
    DEPS: |-
        source ON graph, target ON graph, cuts ON graph,
        partition1s ON graph

igraph_all_st_mincuts:
    PARAMS: |-
        GRAPH graph, OUT REAL value,
        OPTIONAL OUT EDGESETLIST cuts,
        OPTIONAL OUT VERTEXSETLIST partition1s,
        VERTEX source, VERTEX target, EDGEWEIGHTS capacity=NULL
    DEPS: |-
        capacity ON graph, source ON graph, target ON graph,
        cuts ON graph, partition1s ON graph

igraph_is_separator:
    PARAMS: GRAPH graph, VERTEXSET candidate, OUT BOOLEAN res
    DEPS: candidate ON graph

igraph_is_minimal_separator:
    PARAMS: GRAPH graph, VERTEXSET candidate, OUT BOOLEAN res
    DEPS: candidate ON graph

igraph_all_minimal_st_separators:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST separators
    DEPS: separators ON graph

igraph_minimum_size_separators:
    PARAMS: GRAPH graph, OUT VERTEXSETLIST separators
    DEPS: separators ON graph

igraph_cohesive_blocks:
    PARAMS: |-
        GRAPH graph, OUT VERTEXSETLIST blocks,
        OUT VECTOR cohesion, OUT VECTORM1 parent,
        OUT GRAPH blockTree
    DEPS: blocks ON graph

#######################################
# K-Cores
#######################################

igraph_coreness:
    PARAMS: GRAPH graph, OUT VECTOR cores, NEIMODE mode=ALL

#######################################
# Graph isomorphism
#######################################

igraph_isoclass:
    PARAMS: GRAPH graph, OUT INTEGER isoclass

igraph_isomorphic:
    PARAMS: GRAPH graph1, GRAPH graph2, OUT BOOLEAN iso

igraph_isoclass_subgraph:
    PARAMS: GRAPH graph, VECTOR vids, OUT INTEGER isoclass
    DEPS: vids ON graph

igraph_isoclass_create:
    PARAMS: OUT GRAPH graph, INTEGER size, INTEGER number, BOOLEAN directed=True

igraph_isomorphic_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        OPTIONAL VERTEX_COLOR vertex_color1,
        OPTIONAL VERTEX_COLOR vertex_color2,
        OPTIONAL EDGE_COLOR edge_color1,
        OPTIONAL EDGE_COLOR edge_color2,
        OUT BOOLEAN iso,
        OUT VECTORM1_OR_0 map12, OUT VECTORM1_OR_0 map21,
        OPTIONAL ISOCOMPAT_FUNC node_compat_fn,
        OPTIONAL ISOCOMPAT_FUNC edge_compat_fn,
        EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_count_isomorphisms_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        VERTEX_COLOR vertex_color1, VERTEX_COLOR vertex_color2,
        EDGE_COLOR edge_color1, EDGE_COLOR edge_color2,
        OUT INTEGER count, ISOCOMPAT_FUNC node_compat_fn,
        ISOCOMPAT_FUNC edge_compat_fn, EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_get_isomorphisms_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        VERTEX_COLOR vertex_color1, VERTEX_COLOR vertex_color2,
        EDGE_COLOR edge_color1, EDGE_COLOR edge_color2,
        OUT VECTORLIST maps, ISOCOMPAT_FUNC node_compat_fn,
        ISOCOMPAT_FUNC edge_compat_fn, EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_subisomorphic_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        VERTEX_COLOR vertex_color1, VERTEX_COLOR vertex_color2,
        EDGE_COLOR edge_color1, EDGE_COLOR edge_color2,
        OUT BOOLEAN iso,
        OUT VECTORM1_OR_0 map12, OUT VECTORM1_OR_0 map21,
        ISOCOMPAT_FUNC node_compat_fn, ISOCOMPAT_FUNC edge_compat_fn,
        EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_count_subisomorphisms_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        VERTEX_COLOR vertex_color1, VERTEX_COLOR vertex_color2,
        EDGE_COLOR edge_color1, EDGE_COLOR edge_color2,
        OUT INTEGER count, ISOCOMPAT_FUNC node_compat_fn,
        ISOCOMPAT_FUNC edge_compat_fn, EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_get_subisomorphisms_vf2:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        VERTEX_COLOR vertex_color1, VERTEX_COLOR vertex_color2,
        EDGE_COLOR edge_color1, EDGE_COLOR edge_color2,
        OUT VECTORLIST maps, ISOCOMPAT_FUNC node_compat_fn,
        ISOCOMPAT_FUNC edge_compat_fn, EXTRA extra
    DEPS: |-
        vertex_color1 ON graph1, vertex_color2 ON graph2,
        edge_color1 ON graph1, edge_color2 ON graph2

igraph_isomorphic_34:
    PARAMS: GRAPH graph1, GRAPH graph2, OUT BOOLEAN iso

igraph_canonical_permutation:
    PARAMS: |-
        GRAPH graph, OPTIONAL VERTEX_COLOR colors,
        OUT VECTORM1 labeling, BLISSSH sh="fm", OUT BLISSINFO info
    DEPS: colors ON graph

igraph_permute_vertices:
    PARAMS: GRAPH graph, OUT GRAPH res, VECTORM1 permutation

igraph_isomorphic_bliss:
    PARAMS: |-
        GRAPH graph1, GRAPH graph2,
        OPTIONAL VERTEX_COLOR colors1, OPTIONAL VERTEX_COLOR colors2,
        OUT BOOLEAN iso, OUT VECTORM1_OR_0 map12,
        OUT VECTORM1_OR_0 map21, BLISSSH sh="fm",
        OUT BLISSINFO info1, OUT BLISSINFO info2
    DEPS: colors1 ON graph1, colors2 ON graph2

igraph_automorphisms:
    PARAMS: |-
        GRAPH graph, OPTIONAL VERTEX_COLOR colors, BLISSSH sh="fm", OUT BLISSINFO info
    DEPS: colors ON graph

igraph_automorphism_group:
    PARAMS: |-
        GRAPH graph, OPTIONAL VERTEX_COLOR colors, PRIMARY OUT VERTEXSETLIST generators,
        BLISSSH sh="fm", OUT BLISSINFO info
    DEPS: colors ON graph, generators ON graph

igraph_subisomorphic_lad:
    PARAMS: |-
        GRAPH pattern, GRAPH target, OPTIONAL VERTEXSETLIST domains,
        OPTIONAL OUT BOOLEAN iso, OUT VECTOR_OR_0 map,
        OPTIONAL OUT VECTORLIST maps, BOOLEAN induced, INT time_limit

igraph_simplify_and_colorize:
    # Despite their names, vertex_color and edge_color are not really colors
    # but _multiplicities_, so we simply use VECTOR_INT there
    PARAMS: |-
        GRAPH graph, OUT GRAPH res, OUT VECTOR_INT vertex_color, OUT VECTOR_INT edge_color
    DEPS: vertex_color ON graph, edge_color ON graph

#######################################
# SCG
#######################################

igraph_scg_grouping:
    PARAMS: |-
        MATRIX V, OUT VECTORM1 groups, INTEGER nt,
        VECTOR_OR_0 nt_vec, SCGMAT mtype=Default,
        SCGALGO algo=Default, VECTOR_OR_0 p=NULL,
        INTEGER maxiter=100

igraph_scg_semiprojectors:
    PARAMS: |-
        VECTORM1 groups, SCGMAT mtype=Default,
        OUT MATRIX_OR_0 L, OUT MATRIX_OR_0 R,
        OPTIONAL OUT SPARSEMATPTR Lsparse, OPTIONAL OUT SPARSEMATPTR Rsparse,
        VECTOR_OR_0 p=NULL, SCGNORM norm=Default

igraph_scg_norm_eps:
    PARAMS: |-
        MATRIX V, VECTORM1 groups, OUT VECTOR eps,
        SCGMAT mtype=Default, VECTOR_OR_0 p=NULL,
        SCGNORM norm=Default

igraph_scg_adjacency:
    PARAMS: |-
        GRAPH_OR_0 graph, MATRIX_OR_0 matrix,
        SPARSEMAT_OR_0 sparsemat, VECTOR ev,
        INTEGER nt, VECTOR_OR_0 ntvec,
        SCGALGO algo, INOUT VECTOR_OR_0 values,
        INOUT MATRIX_OR_0 vectors, INOUT VECTORM1_OR_0 groups,
        BOOLEAN use_arpack=False, INTEGER maxiter,
        OUT GRAPH_OR_0 scg_graph, OUT MATRIX_OR_0 scg_matrix,
        OUT SPARSEMAT_OR_0 scg_sparsemat, OUT MATRIX_OR_0 L,
        OUT MATRIX_OR_0 R, OPTIONAL OUT SPARSEMATPTR Lsparse,
        OPTIONAL OUT SPARSEMATPTR Rsparse

igraph_scg_stochastic:
    PARAMS: |-
        GRAPH_OR_0 graph, MATRIX_OR_0 matrix,
        SPARSEMAT_OR_0 sparsemat, VECTOR ev,
        INTEGER nt, VECTOR_OR_0 nt_vec,
        SCGALGO algo, SCGNORM norm=Default,
        OPTIONAL INOUT VECTOR_COMPLEX values,
        OPTIONAL INOUT MATRIX_COMPLEX vectors,
        INOUT VECTORM1_OR_0 groups, INOUT VECTOR_OR_0 p,
        BOOLEAN use_arpack=False, INTEGER maxiter,
        OUT GRAPH_OR_0 scg_graph, OUT MATRIX_OR_0 scg_matrix,
        OUT SPARSEMAT_OR_0 scg_sparsemat, OUT MATRIX_OR_0 L,
        OUT MATRIX_OR_0 R, OPTIONAL OUT SPARSEMATPTR Lsparse,
        OPTIONAL OUT SPARSEMATPTR Rsparse

igraph_scg_laplacian:
    PARAMS: |-
        GRAPH_OR_0 graph, MATRIX_OR_0 matrix,
        SPARSEMAT_OR_0 sparsemat, VECTOR ev,
        INTEGER nt, VECTOR_OR_0 nt_vec,
        SCGALGO algo, SCGNORM norm=Default,
        SCGDIR direction=Default,
        OPTIONAL INOUT VECTOR_COMPLEX values,
        OPTIONAL INOUT MATRIX_COMPLEX vectors,
        INOUT VECTORM1_OR_0 groups,
        BOOLEAN use_arpack=False, INTEGER maxiter,
        OUT GRAPH_OR_0 scg_graph, OUT MATRIX_OR_0 scg_matrix,
        OUT SPARSEMAT_OR_0 scg_sparsemat, OUT MATRIX_OR_0 L,
        OUT MATRIX_OR_0 R, OPTIONAL OUT SPARSEMATPTR Lsparse,
        OPTIONAL OUT SPARSEMATPTR Rsparse

#######################################
# Matching
#######################################

igraph_is_matching:
    PARAMS: |-
        GRAPH graph, OPTIONAL BIPARTITE_TYPES types=NULL,
        VECTOR_LONG_M1 matching, OUT BOOLEAN res
    DEPS: types ON graph, matching ON graph

igraph_is_maximal_matching:
    PARAMS: |-
        GRAPH graph, OPTIONAL BIPARTITE_TYPES types=NULL,
        VECTOR_LONG_M1 matching, OUT BOOLEAN res
    DEPS: types ON graph

igraph_maximum_bipartite_matching:
    PARAMS: |-
        GRAPH graph, OPTIONAL BIPARTITE_TYPES types=NULL,
        OPTIONAL OUT INTEGER matching_size,
        OPTIONAL OUT REAL matching_weight,
        OUT VECTOR_LONG_M1 matching,
        EDGEWEIGHTS weights=NULL, REAL eps=.Machine$double.eps
    DEPS: types ON graph, weights ON graph

#######################################
# Embedding
#######################################

igraph_adjacency_spectral_embedding:
    PARAMS: |-
        GRAPH graph, INTEGER no, EDGEWEIGHTS weights=NULL,
        EIGENWHICHPOS which=ASE, BOOLEAN scaled=True, OUT MATRIX X,
        OUT MATRIX_OR_0 Y, OUT VECTOR_OR_0 D,
        VECTOR cvec=AsmDefaultCvec,
        INOUT ARPACKOPT options=igraph.arpack.default
    DEPS: weights ON graph, cvec ON graph

igraph_laplacian_spectral_embedding:
    PARAMS: |-
        GRAPH graph, INTEGER no, EDGEWEIGHTS weights=NULL,
        EIGENWHICHPOS which=ASE,
        LSETYPE type=Default, BOOLEAN scaled=True, OUT MATRIX X,
        OUT MATRIX_OR_0 Y, OUT VECTOR_OR_0 D,
        INOUT ARPACKOPT options=igraph.arpack.default
    DEPS: weights ON graph, type ON graph

#######################################
# Eigensolvers
#######################################

igraph_eigen_adjacency:
    PARAMS: |-
        GRAPH graph, EIGENALGO algorithm=ARPACK,
        EIGENWHICH which=Default,
        INOUT ARPACKOPT options=arpack_defaults,
        INOUT ARPACKSTORAGE storage, OUT VECTOR values, OUT MATRIX vectors,
        OUT VECTOR_COMPLEX cmplxvalues, OUT MATRIX_COMPLEX cmplxvectors

#######################################
# Fitting power laws
#######################################

igraph_power_law_fit:
    PARAMS: |-
        VECTOR data, OUT PLFIT res, REAL xmin=-1,
        BOOLEAN force_continuous=False

#######################################
# Dynamics, on networks
#######################################

igraph_sir:
    PARAMS: |-
        GRAPH graph, REAL beta, REAL gamma, INTEGER no_sim=100,
        OUT SIRLIST res

#######################################
# Other, not graph related
#######################################

igraph_running_mean:
    PARAMS: VECTOR data, OUT VECTOR res, INTEGER binwidth

igraph_random_sample:
    PARAMS: OUT VECTOR res, REAL l, REAL h, INTEGER length

igraph_convex_hull:
    PARAMS: MATRIX data, OUT VECTOR resverts, OUT MATRIX rescoords

igraph_dim_select:
    PARAMS: VECTOR sv, OUT INTEGER dim

#######################################
# Eulerian functions
#######################################

igraph_is_eulerian:
    PARAMS: GRAPH graph, OUT BOOLEAN has_path, OUT BOOLEAN has_cycle

igraph_eulerian_path:
    PARAMS: GRAPH graph, OPTIONAL OUT EDGESET edge_res, OPTIONAL OUT VERTEXSET vertex_res
    DEPS: edge_res ON graph, vertex_res ON graph

igraph_eulerian_cycle:
    PARAMS: GRAPH graph, OPTIONAL OUT EDGESET edge_res, OPTIONAL OUT VERTEXSET vertex_res
    DEPS: edge_res ON graph, vertex_res ON graph

#######################################
# Trees
#######################################

igraph_is_tree:
    PARAMS: GRAPH graph, PRIMARY OUT BOOLEAN res, OPTIONAL OUT VERTEX root, NEIMODE mode=OUT
    DEPS: root ON graph

igraph_from_prufer:
    PARAMS: OUT GRAPH graph, INDEX_VECTOR prufer

igraph_to_prufer:
    PARAMS: GRAPH graph, OUT INDEX_VECTOR prufer

igraph_minimum_spanning_tree:
    PARAMS: GRAPH graph, OUT VECTOR res, EDGEWEIGHTS weights=NULL
    DEPS: weights ON graph

igraph_minimum_spanning_tree_unweighted:
    PARAMS: GRAPH graph, OUT GRAPH mst

igraph_minimum_spanning_tree_prim:
    PARAMS: GRAPH graph, OUT GRAPH mst, VECTOR weights

igraph_random_spanning_tree:
    PARAMS: GRAPH graph, OUT EDGESET res, OPTIONAL VERTEX vid=-1
    DEPS: res ON graph, vid ON graph

igraph_tree_game:
    PARAMS: OUT GRAPH graph, INTEGER n, BOOLEAN directed=False, RANDOM_TREE_METHOD method=LERW

#######################################
# Coloring
#######################################

igraph_vertex_coloring_greedy:
    PARAMS: GRAPH graph, OUT VERTEX_COLOR colors, GREEDY_COLORING_HEURISTIC heuristic=NEIGHBORS
    DEPS: colors ON graph

#######################################
# Other, (yet) undocumented functions
#######################################

igraph_convergence_degree:
    PARAMS: GRAPH graph, OUT VECTOR result, OUT VECTOR in, OUT VECTOR out
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/interfaces/types.yaml0000644000175100001710000004475000000000000024037 0ustar00runnerdocker00000000000000# vim:set ts=4 sw=4 sts=4 et:
#
# This file is a YAML representation of the types used in the functions.yaml
# function specification file. It provides the meaning of each type in comments
# and also specifies the C types correspnding to each abstract type.
#
# See https://github.com/igraph/stimulus for more information

###############################################################################
## Core igraph data types
###############################################################################

INTEGER:
    # An ordinary igraph integer
    CTYPE: igraph_integer_t

REAL:
    # An ordinary igraph floating-point number
    CTYPE: igraph_real_t

BOOLEAN:
    # An ordinary igraph Boolean value
    CTYPE: igraph_bool_t

COMPLEX:
    # An ordinary igraph complex number
    CTYPE: igraph_complex_t

ERROR:
    # An igraph error code
    CTYPE: int

###############################################################################
## C data types
###############################################################################

INT:
    # A C integer
    CTYPE: int

LONGINT:
    # A C long integer
    CTYPE: long int

CSTRING:
    # A null-terminated immutable C string
    CTYPE: const char*

INFILE:
    # A file, already open for reading
    CTYPE: FILE*

OUTFILE:
    # A file, already open for writing
    CTYPE: FILE*

###############################################################################
# Vectors, matrices and other template types
###############################################################################

INDEX_VECTOR:
    # A vector of integer indices that should adapt to the conventions of the
    # host language (i.e. 1-based for R, Mathematica, Octave etc, 0-based for
    # Python and similar).
    CTYPE: igraph_vector_int_t
    FLAGS: BY_REF

VECTOR:
    # A vector of floating-point numbers
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

VECTOR_INT:
    # A vector of igraph integers
    CTYPE: igraph_vector_int_t
    FLAGS: BY_REF

VECTOR_LONG:
    # A vector of C long integers. Deprecated, will be removed in 0.10.
    CTYPE: igraph_vector_long_t
    FLAGS: BY_REF

VECTOR_BOOL:
    # A vector of Boolean values
    CTYPE: igraph_vector_bool_t
    FLAGS: BY_REF

VECTOR_COMPLEX:
    # A vector of igraph complex numbers
    CTYPE: igraph_vector_complex_t

STRVECTOR:
    # A vector of strings
    # TODO(ntamas): maybe rename this to igraph_vector_str_t and VECTOR_STR
    # for consistency?
    CTYPE: igraph_strvector_t
    FLAGS: BY_REF

VECTORLIST:
    # A vector containing pointers to vectors of floating-point numbers
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

VECTORM1:
    # A vector of integer indices that should adapt to the conventions of the
    # host language (i.e. 1-based for R, Mathematica, Octave etc, 0-based for
    # Python and similar).
    # TODO(ntamas): should be replaced with INDEX_VECTOR
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

MATRIX:
    # A matrix of floating-point numbers
    CTYPE: igraph_matrix_t
    FLAGS: BY_REF

MATRIX_COMPLEX:
    # A matrix of igraph complex numbers
    CTYPE: igraph_matrix_complex_t

MATRIXLIST:
    # A vector containing pointers to matrices of floating-point numbers
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

SPARSEMAT:
    # A sparse matrix of floating-point numbers
    CTYPE: igraph_sparsemat_t
    FLAGS: BY_REF

SPARSEMATPTR:
    # A sparse matrix of floating-point numbers. The specialty of this type
    # is that it is uninitialized upon calling the function that uses it; the
    # function will initialize it instead.
    # TODO(ntamas): check whether we could merge this with SPARSEMAT in 0.10
    CTYPE: igraph_sparsemat_t
    FLAGS: BY_REF

# SOMETHING_OR_0 variants -- these will be phased out in favour of the
# OPTIONAL modifier

VECTOR_OR_0:
    # A vector of floating-point numbers values where a null pointer is also a valid value
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

VECTOR_BOOL_OR_0:
    # A vector of Boolean values where a null pointer is also a valid value
    CTYPE: igraph_vector_bool_t
    FLAGS: BY_REF

VECTORM1_OR_0:
    # A vector of integer indices that should adapt to the conventions of the
    # host language (i.e. 1-based for R, Mathematica, Octave etc, 0-based for
    # Python and similar). A null pointer is also a valid value here.
    # TODO(ntamas): should be replaced with INDEX_VECTOR
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

VECTOR_LONG_M1:
    # A vector of integer indices (as C long ints) that should adapt to the
    # conventions of the host language (i.e. 1-based for R, Mathematica, Octave
    # etc, 0-based for Python and similar). Deprecated, will be removed in 0.10.
    #
    # TODO(ntamas): should be replaced with INDEX_VECTOR
    CTYPE: igraph_vector_long_t
    FLAGS: BY_REF

MATRIX_OR_0:
    # A matrix of floating-point numbers values where a null pointer is also a valid value
    CTYPE: igraph_matrix_t
    FLAGS: BY_REF

SPARSEMAT_OR_0:
    # A sparse matrix of floating-point numbers where a null pointer is also a valid value
    CTYPE: igraph_sparsemat_t
    FLAGS: BY_REF

###############################################################################
# Vertices, edges, vertex and edge sequences
###############################################################################

EDGE:
    # A single edge index
    CTYPE: igraph_integer_t

EDGESET:
    # An igraph edge sequence. This is an ugly hybrid type; when it is an
    # IN argument in generated code, it is an igraph_es_t, but when it is an
    # OUT argument, it is an igraph_vector_t. This should be fixed for 0.10.
    CTYPE:
        IN: igraph_es_t
        OUT: igraph_vector_t

VERTEX:
    # A single vertex index
    CTYPE: igraph_integer_t

VERTEXSET:
    # An igraph vertex sequence. This is an ugly hybrid type; when it is an
    # IN argument in generated code, it is an igraph_vs_t, but when it is an
    # OUT argument, it is an igraph_vector_t. This should be fixed for 0.10.
    CTYPE:
        IN: igraph_vs_t
        OUT: igraph_vector_t

VERTEXSET_INT:
    # An igraph vertex sequence where each vertex is represented as an integer,
    # hence the entire vector is an igraph_vector_int_t.
    CTYPE: igraph_vector_int_t

###############################################################################
# Specialized vectors with semantic meaning
###############################################################################

BIPARTITE_TYPES:
    # A vector containing Booleans that define the two partitions of a
    # bipartite graph
    CTYPE: igraph_vector_bool_t
    FLAGS: BY_REF

EDGECAPACITY:
    # A vector containing edge capacities (typically for max-flow algorithms)
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

EDGE_COLOR:
    # A vector containing edge colors
    CTYPE: igraph_vector_int_t
    FLAGS: BY_REF

EDGEWEIGHTS:
    # A vector containing edge weights
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

EDGESETLIST:
    # A vector containing vectors of floating-point numbers where each such
    # vector represents a sequence of edge indices.
    #
    # TODO(ntamas): the name is slightly inconsistent because EDGESET is
    # the abstract type for igraph_es_t, but an EDGESETLIST is _not_ a
    # vector of igraph_es_t objects
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

GRAPHLIST:
    # A vector containing pointers to graph objects
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

VERTEXINDEX:
    # A vector of floating-point numbers where each entry corresponds to
    # one of the vertices in a graph. Higher-level interfaces may use this
    # type to provide a "named vector" such that each entry can be indexed
    # either by the vertex index or by the vertex name.
    #
    # TODO(ntamas): this is a misleading name; we should find a better name
    # for this type
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

SIRLIST:
    # A vector containing pointers to igraph_sir_t objects
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

VERTEXSETLIST:
    # A vector containing vectors of floating-point numbers where each such
    # vector represents a sequence of vertex indices.
    #
    # TODO(ntamas): the name is slightly inconsistent because VERTEXSET is
    # the abstract type for igraph_vs_t, but a VERTEXSETLIST is _not_ a
    # vector of igraph_vs_t objects
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

VERTEXSETLIST_INT:
    # A vector containing vectors of igraph integers where each such vector
    # represents a sequence of vertex indices.
    #
    # TODO(ntamas): the name is slightly inconsistent because VERTEXSET is
    # the abstract type for igraph_vs_t, but a VERTEXSETLIST is _not_ a
    # vector of igraph_vs_t objects
    CTYPE: igraph_vector_ptr_t
    FLAGS: BY_REF

VERTEX_COLOR:
    # A vector containing vertex colors
    CTYPE: igraph_vector_int_t
    FLAGS: BY_REF

VERTEXWEIGHTS:
    # A vector containing vertex weights
    CTYPE: igraph_vector_t
    FLAGS: BY_REF

###############################################################################
# Graph representations
###############################################################################

GRAPH:
    # An igraph graph
    CTYPE: igraph_t
    FLAGS: BY_REF

ADJLIST:
    # A graph represented as an adjacency list
    CTYPE: igraph_adjlist_t
    FLAGS: BY_REF

INCLIST:
    # A graph represented as an incidence list
    CTYPE: igraph_inclist_t
    FLAGS: BY_REF

# SOMETHING_OR_0 variants -- these will be phased out in favour of the
# OPTIONAL modifier

GRAPH_OR_0:
    # An igraph graph where a null pointer is also a valid value
    CTYPE: igraph_t
    FLAGS: BY_REF

###############################################################################
# Enums
###############################################################################

ADD_WEIGHTS:
    # Whether to add the weights of the edges read from a file to the graph
    # being created
    CTYPE: igraph_add_weights_t
    FLAGS: ENUM

ADJACENCYMODE:
    # Enum that describes how an adjacency matrix should be constructed
    CTYPE: igraph_adjacency_t
    FLAGS: ENUM

BARABASI_ALGORITHM:
    # Enum that describes the various implementations of the Barabasi model
    # that igraph supports
    CTYPE: igraph_barabasi_algorithm_t
    FLAGS: ENUM

BLISSSH:
    # Enum containing splitting heuristics for the Bliss algorithm
    CTYPE: igraph_bliss_sh_t
    FLAGS: ENUM

COMMCMP:
    # Enum containing identifiers for community comparison methods
    CTYPE: igraph_community_comparison_t
    FLAGS: ENUM

CONNECTEDNESS:
    # Enum that selects between weak and strong connectivity
    CTYPE: igraph_connectedness_t
    FLAGS: ENUM

DEGSEQMODE:
    # Enum that describes the various implementations of generating a graph
    # with an arbitrary degree sequence
    CTYPE: igraph_degseq_t
    FLAGS: ENUM

EIGENALGO:
    # Enum used for selecting an algorithm that determines the eigenvalues
    # and eigenvectors of some input
    CTYPE: igraph_eigen_algorithm_t
    FLAGS: ENUM

EIGENWHICHPOS:
    # Enum representing which eigenvalues to use in the spectral embedding
    # algorithm
    CTYPE: igraph_eigen_which_position_t
    FLAGS: ENUM

GETADJACENCY:
    # Enum storing how to retrieve the adjacency matrix from a graph
    CTYPE: igraph_get_adjacency_t
    FLAGS: ENUM

GREEDY_COLORING_HEURISTIC:
    # Enum representing different heuristics for a greedy vertex coloring
    CTYPE: igraph_coloring_greedy_t
    FLAGS: ENUM

LAYOUT_GRID:
    # Whether to use the fast (but less accurate) grid-based version of a
    # layout algorithm that supports it (typically the Fruchterman-Reingold
    # layout)
    CTYPE: igraph_layout_grid_t
    FLAGS: ENUM

LSETYPE:
    # Enum storing the possible types (definitions) of the Laplacian matrix
    # to use in the Laplacian spectral embedding algorithms
    CTYPE: igraph_laplacian_spectral_embedding_type_t
    FLAGS: ENUM

NEIMODE:
    # Enum that describes how a particular function should take into account
    # the neighbors of vertices
    CTYPE: igraph_neimode_t
    FLAGS: ENUM

PAGERANKALGO:
    # Enum that describes the various implementations of the PageRank algorithm
    CTYPE: igraph_pagerank_algo_t
    FLAGS: ENUM

RANDOM_TREE_METHOD:
    # Enum that describes the various implementation of the uniform random tree
    # sampling method
    CTYPE: igraph_random_tree_t
    FLAGS: ENUM

REALIZE_DEGSEQ_METHOD:
    # Enum that describes the various methods for realizing a graph with an
    # arbitrary degree sequence
    CTYPE: igraph_realize_degseq_t
    FLAGS: ENUM

RECIP:
    # Enum that describes how the reciprocity of a graph should be calculated
    CTYPE: igraph_reciprocity_t
    FLAGS: ENUM

REWIRINGMODE:
    # Enum for the rewiring modes of igraph_rewire()
    CTYPE: igraph_rewiring_t
    FLAGS: ENUM

RWSTUCK:
    # Enum that describes what igraph should do when a random walk gets stuck
    # in a sink vertex
    CTYPE: igraph_random_walk_stuck_t
    FLAGS: ENUM

SCGALGO:
    # Enum representing the algorithms that may be used for spectral coarse
    # graining of graphs
    CTYPE: igraph_scg_algorithm_t
    FLAGS: ENUM

SCGDIR:
    # Enum storing whether the spectral coarse graining algorithm should work
    # with left or right eigenvectors
    CTYPE: igraph_scg_direction_t
    FLAGS: ENUM

SCGMAT:
    # Enum representing the possible types of semiprojections used in the
    # spectral coarse graining algorithm
    CTYPE: igraph_scg_matrix_t
    FLAGS: ENUM

SCGNORM:
    CTYPE: igraph_scg_norm_t
    FLAGS: ENUM

SPINCOMMUPDATE:
    # Enum containing update modes for the spinglass community detection
    # algorithm
    CTYPE: igraph_spincomm_update_t
    FLAGS: ENUM

SPINGLASS_IMPLEMENTATION:
    # Enum that describes the various implementations of the spinglass community
    # detection algorithm
    CTYPE: igraph_spinglass_implementation_t
    FLAGS: ENUM

STARMODE:
    # Enum that describes how a star graph should be constructed
    CTYPE: igraph_star_mode_t
    FLAGS: ENUM

SUBGRAPH_IMPL:
    # Enum that describes how igraph should create an induced subgraph of a
    # graph
    CTYPE: igraph_subgraph_implementation_t
    FLAGS: ENUM

TODIRECTED:
    # Enum representing the possible ways to convert an undirected graph to a
    # directed one
    CTYPE: igraph_to_directed_t
    FLAGS: ENUM

TOUNDIRECTED:
    # Enum representing the possible ways to convert a directed graph to an
    # undirected one
    CTYPE: igraph_to_undirected_t
    FLAGS: ENUM

TRANSITIVITYMODE:
    # Enum that specifies how isolated vertices should be handled in transitivity
    # calcuations
    CTYPE: igraph_transitivity_mode_t
    FLAGS: ENUM

TREEMODE:
    # Enum that describes how a tree graph should be constructed
    CTYPE: igraph_tree_mode_t
    FLAGS: ENUM

###############################################################################
# Switches / flags / bits
###############################################################################

EDGE_TYPE_SW:
    # Flag bitfield that specifies what sort of edges are allowed in an
    # algorithm
    CTYPE: igraph_edge_type_sw_t
    FLAGS: BITS

###############################################################################
# Callbacks
###############################################################################

ARPACKFUNC:
    # ARPACK matrix multiplication function.
    CTYPE: igraph_arpack_function_t

CLIQUE_FUNC:
    # Callback function for igraph_cliques_callback(). called with every clique
    # that was found by the function.
    CTYPE: igraph_clique_handler_t

BFS_FUNC:
    # Callback function for igraph_bfs(). Called with every vertex that was
    # visited during the BFS traversal.
    CTYPE: igraph_bfshandler_t

DFS_FUNC:
    # Callback function for igraph_dfs(). Called with every vertex that was
    # visited during the DFS traversal.
    CTYPE: igraph_dfshandler_t

ISOCOMPAT_FUNC:
    # Callback function for isomorphism algorithms that determines whether two
    # vertices are compatible or not.
    CTYPE: igraph_isocompat_t

ISOMORPHISM_FUNC:
    # Callback function that is called by isomorphism functions when an
    # isomorphism is found
    CTYPE: igraph_isohandler_t

LEVCFUNC:
    # Callback function for igraph_leading_eigenvector_community(). Called
    # after each eigenvalue / eigenvector calculation.
    CTYPE: igraph_community_leading_eigenvector_callback_t

###############################################################################
# Miscellaneous
###############################################################################

ARPACKFUNC:
    # ARPACK matrix multiplication function.
    CTYPE: igraph_arpack_function_t

ARPACKOPT:
    # Structure that contains the options of the ARPACK eigensolver.
    CTYPE: igraph_arpack_options_t
    FLAGS: BY_REF

ARPACKSTORAGE:
    # Pointer to a general-purpose memory block that ARPACK-based algorithms
    # may use as a working area.
    CTYPE: igraph_arpack_storage_t
    FLAGS: BY_REF

ATTRIBUTES:
    # An opaque data structure that a high-level interface may use to pass
    # information about graph/vertex/edge attributes to a low-level igraph
    # C function
    CTYPE: void
    FLAGS: BY_REF

BLISSINFO:
    # Struct holding information about the internal statistics of a single
    # run of the Bliss algorithm
    CTYPE: igraph_bliss_info_t

DRL_OPTIONS:
    # Structure containing the options of the DrL layout algorithm
    CTYPE: igraph_layout_drl_options_t
    FLAGS: BY_REF

EDGE_ATTRIBUTE_COMBINATION:
    # Structure specifying how the attributes of edges should be combined
    # during graph operations that may merge multiple edges into a single one
    CTYPE: igraph_attribute_combination_t
    FLAGS: BY_REF

EIGENWHICH:
    # Structure representing which eigenvalue(s) to use in the spectral embedding
    # algorithm
    CTYPE: igraph_eigen_which_t
    FLAGS: BY_REF

EXTRA:
    # Thunk argument that usually accompanies callback functions and can be used
    # to provide user-specific data or context to the callback function
    CTYPE: void
    FLAGS: BY_REF

HRG:
    # Structure storing a fitted hierarchical random graph model
    CTYPE: igraph_hrg_t
    FLAGS: BY_REF

MAXFLOW_STATS:
    # Structure storing statistics about a single run of a max-flow algorithm
    CTYPE: igraph_maxflow_stats_t
    FLAGS: BY_REF

PAGERANKOPT:
    # Enum that describes the PageRank options pointer, which is used only if
    # the PageRank implementation uses ARPACK
    CTYPE: igraph_arpack_options_t
    FLAGS: BY_REF

PLFIT:
    # Structure representing the result of a power-law fitting algorithms
    CTYPE: igraph_plfit_result_t
    FLAGS: BY_REF

VCONNNEI:
    CTYPE: igraph_vconn_nei_t

VERTEX_ATTRIBUTE_COMBINATION:
    # Structure specifying how the attributes of vertices should be combined
    # during graph operations that may merge multiple vertices into a single one
    CTYPE: igraph_attribute_combination_t
    FLAGS: BY_REF
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.3951392
igraph-0.9.9/vendor/source/igraph/msvc/0000755000175100001710000000000000000000000020622 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4791403
igraph-0.9.9/vendor/source/igraph/msvc/include/0000755000175100001710000000000000000000000022245 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/msvc/include/unistd.h0000644000175100001710000000033600000000000023726 0ustar00runnerdocker00000000000000
/*
 * unistd.h replacement for MSVC
 *
 * Provide the minimum that igraph needs.
 * At presents this is:
 *  - isatty() for f2c and flex-generated sources
 *  - unlink() for examples/simple/graphml.c
 */

#include 
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4791403
igraph-0.9.9/vendor/source/igraph/src/0000755000175100001710000000000000000000000020441 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/CMakeLists.txt0000644000175100001710000003077700000000000023217 0ustar00runnerdocker00000000000000
# Traverse subdirectories
add_subdirectory(centrality/prpack)
add_subdirectory(cliques/cliquer)
add_subdirectory(isomorphism/bliss)

# Generate lexers and parsers
set(PARSER_SOURCES)
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/io/parsers)
foreach(FORMAT dl gml lgl ncol pajek)
  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/io/parsers/${FORMAT}-parser.c)
    list(APPEND PARSER_SOURCES
      ${CMAKE_CURRENT_SOURCE_DIR}/io/parsers/${FORMAT}-lexer.c
      ${CMAKE_CURRENT_SOURCE_DIR}/io/parsers/${FORMAT}-parser.c
    )
  else()
    if (BISON_VERSION VERSION_GREATER_EQUAL 3)
      set(bison_no_deprecated -Wno-deprecated)
    endif()
    bison_target(
      ${FORMAT}_parser io/${FORMAT}-parser.y ${CMAKE_CURRENT_BINARY_DIR}/io/parsers/${FORMAT}-parser.c
      COMPILE_FLAGS "--no-lines ${bison_no_deprecated}"
    )
    flex_target(
      ${FORMAT}_lexer io/${FORMAT}-lexer.l ${CMAKE_CURRENT_BINARY_DIR}/io/parsers/${FORMAT}-lexer.c
      COMPILE_FLAGS "--noline"
      DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/io/parsers/${FORMAT}-lexer.h
    )
    add_flex_bison_dependency(${FORMAT}_lexer ${FORMAT}_parser)
    list(APPEND PARSER_SOURCES ${BISON_${FORMAT}_parser_OUTPUTS} ${FLEX_${FORMAT}_lexer_OUTPUTS})
  endif()
endforeach()
add_custom_target(parsersources SOURCES ${PARSER_SOURCES})

# Declare the files needed to compile the igraph library
add_library(
  igraph
  core/array.c
  core/buckets.c
  core/cutheap.c
  core/dqueue.c
  core/error.c
  core/estack.c
  core/fixed_vectorlist.c
  core/grid.c
  core/hashtable.c
  core/heap.c
  core/indheap.c
  core/interruption.c
  core/marked_queue.c
  core/matrix.c
  core/memory.c
  core/printing.c
  core/progress.c
  core/psumtree.c
  core/set.c
  core/sparsemat.c
  core/spmatrix.c
  core/stack.c
  core/statusbar.c
  core/strvector.c
  core/trie.c
  core/vector_ptr.c
  core/vector.c

  math/bfgs.c
  math/complex.c
  math/utils.c

  linalg/arpack.c
  linalg/blas.c
  linalg/eigen.c
  linalg/lapack.c

  random/random.c

  graph/adjlist.c
  graph/attributes.c
  graph/basic_query.c
  graph/cattributes.c
  graph/iterators.c
  graph/type_indexededgelist.c
  graph/visitors.c

  constructors/adjacency.c
  constructors/atlas.c
  constructors/basic_constructors.c
  constructors/de_bruijn.c
  constructors/famous.c
  constructors/full.c
  constructors/kautz.c
  constructors/lcf.c
  constructors/linegraph.c
  constructors/prufer.c
  constructors/regular.c

  games/barabasi.c
  games/callaway_traits.c
  games/citations.c
  games/correlated.c
  games/degree_sequence_vl/gengraph_box_list.cpp
  games/degree_sequence_vl/gengraph_degree_sequence.cpp
  games/degree_sequence_vl/gengraph_graph_molloy_hash.cpp
  games/degree_sequence_vl/gengraph_graph_molloy_optimized.cpp
  games/degree_sequence_vl/gengraph_mr-connected.cpp
  games/degree_sequence_vl/gengraph_powerlaw.cpp
  games/degree_sequence.c
  games/dotproduct.c
  games/erdos_renyi.c
  games/establishment.c
  games/forestfire.c
  games/grg.c
  games/growing_random.c
  games/islands.c
  games/k_regular.c
  games/preference.c
  games/recent_degree.c
  games/sbm.c
  games/static_fitness.c
  games/tree.c
  games/watts_strogatz.c

  centrality/betweenness.c
  centrality/centrality_other.c
  centrality/centralization.c
  centrality/closeness.c
  centrality/coreness.c
  centrality/prpack.cpp

  cliques/cliquer_wrapper.c
  cliques/cliques.c
  cliques/maximal_cliques.c
  cliques/glet.c

  community/community_misc.c
  community/edge_betweenness.c
  community/fast_modularity.c
  community/fluid.c
  community/infomap/infomap_FlowGraph.cc
  community/infomap/infomap_Greedy.cc
  community/infomap/infomap_Node.cc
  community/infomap/infomap.cc
  community/label_propagation.c
  community/leading_eigenvector.c
  community/leiden.c
  community/louvain.c
  community/modularity.c
  community/optimal_modularity.c
  community/spinglass/clustertool.cpp
  community/spinglass/NetDataTypes.cpp
  community/spinglass/NetRoutines.cpp
  community/spinglass/pottsmodel_2.cpp
  community/walktrap/walktrap_communities.cpp
  community/walktrap/walktrap_graph.cpp
  community/walktrap/walktrap_heap.cpp
  community/walktrap/walktrap.cpp

  connectivity/cohesive_blocks.c
  connectivity/components.c
  connectivity/separators.c

  flow/flow.c
  flow/st-cuts.c

  hrg/hrg_types.cc
  hrg/hrg.cc

  io/dimacs.c
  io/dl.c
  io/dot.c
  io/edgelist.c
  io/graphml.c
  io/gml-tree.c
  io/gml.c
  io/graphdb.c
  io/leda.c
  io/lgl.c
  io/ncol.c
  io/pajek.c
  ${PARSER_SOURCES}

  layout/circular.c
  layout/davidson_harel.c
  layout/drl/DensityGrid.cpp
  layout/drl/DensityGrid_3d.cpp
  layout/drl/drl_graph.cpp
  layout/drl/drl_graph_3d.cpp
  layout/drl/drl_layout.cpp
  layout/drl/drl_layout_3d.cpp
  layout/fruchterman_reingold.c
  layout/gem.c
  layout/graphopt.c
  layout/kamada_kawai.c
  layout/large_graph.c
  layout/layout_bipartite.c
  layout/layout_grid.c
  layout/layout_random.c
  layout/mds.c
  layout/merge_dla.c
  layout/merge_grid.c
  layout/reingold_tilford.c
  layout/sugiyama.c

  operators/add_edge.c
  operators/complementer.c
  operators/compose.c
  operators/connect_neighborhood.c
  operators/contract.c
  operators/difference.c
  operators/disjoint_union.c
  operators/intersection.c
  operators/misc_internal.c
  operators/permute.c
  operators/rewire.c
  operators/rewire_edges.c
  operators/simplify.c
  operators/subgraph.c
  operators/union.c

  paths/all_shortest_paths.c
  paths/bellman_ford.c
  paths/dijkstra.c
  paths/distances.c
  paths/eulerian.c
  paths/histogram.c
  paths/johnson.c
  paths/random_walk.c
  paths/shortest_paths.c
  paths/simple_paths.c
  paths/unweighted.c

  properties/basic_properties.c
  properties/constraint.c
  properties/convergence_degree.c
  properties/dag.c
  properties/degrees.c
  properties/girth.c
  properties/loops.c
  properties/multiplicity.c
  properties/neighborhood.c
  properties/spectral.c
  properties/trees.c
  properties/triangles.c

  scg/scg_approximate_methods.c
  scg/scg_exact_scg.c
  scg/scg_kmeans.c
  scg/scg_optimal_method.c
  scg/scg_utils.c
  scg/scg.c

  isomorphism/bliss.cc
  isomorphism/isoclasses.c
  isomorphism/lad.c
  isomorphism/isomorphism_misc.c
  isomorphism/queries.c
  isomorphism/vf2.c

  misc/bipartite.c
  misc/chordality.c
  misc/cocitation.c
  misc/coloring.c
  misc/conversion.c
  misc/degree_sequence.cpp
  misc/embedding.c
  misc/feedback_arc_set.c
  misc/graphicality.c
  misc/matching.c
  misc/microscopic_update.c
  misc/mixing.c
  misc/motifs.c
  misc/other.c
  misc/scan.c
  misc/sir.c
  misc/spanning_trees.c

  internal/glpk_support.c
  internal/hacks.c
  internal/lsap.c
  internal/qsort_r.c
  internal/qsort.c
  internal/zeroin.c

  version.c

  # Vendored library sources. Yes, this is horrible.
  $,$,$>,$,>
  $,$,>
  $,$,>
  $,$,>
  $,$,>
  $,$,>
  $,$,>
  $,$,>
)

# Set soname for the library
set_target_properties(igraph PROPERTIES VERSION "0.0.0")
set_target_properties(igraph PROPERTIES SOVERSION 0)

# Add extra compiler definitions if needed
target_compile_definitions(
  igraph
  PRIVATE
  IGRAPH_VERIFY_FINALLY_STACK=$,1,0>
)

# Make sure that a macro named IGRAPH_FILE_BASENAME is provided in every
# compiler call so we can use these in debug messages without revealing the
# full path of the file on the machine where it was compiled
define_file_basename_for_sources(igraph)

# Add include path. Includes are in ../include but they get installed to
# /include/igraph, hence the two options. We also have some private
# includes that are generated at compile time but are not part of the public
# interface.
target_include_directories(
  igraph
  PUBLIC
  $
  $
  $
  PRIVATE
  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${PROJECT_SOURCE_DIR}/vendor

  # Vendored library include paths
  $<$:$>
  $<$:$>
  $<$:$>

  # Include paths for dependencies
  $<$:${CXSPARSE_INCLUDE_DIRS}>
  $<$:${GLPK_INCLUDE_DIR}>
  $<$:${GMP_INCLUDE_DIR}>
  $<$:${LIBXML2_INCLUDE_DIRS}>
  $<$:${PLFIT_INCLUDE_DIRS}>
)

if(MATH_LIBRARY)
  target_link_libraries(igraph PUBLIC ${MATH_LIBRARY})
endif()

if(ARPACK_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${ARPACK_LIBRARIES})
endif()

if(BLAS_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${BLAS_LIBRARIES})
endif()

if(CXSPARSE_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${CXSPARSE_LIBRARIES})
endif()

if(GLPK_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${GLPK_LIBRARIES})
endif()

if(GMP_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${GMP_LIBRARIES})
endif()

if(LAPACK_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${LAPACK_LIBRARIES})
endif()

if(LIBXML2_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${LIBXML2_LIBRARIES})
endif()

if(PLFIT_LIBRARIES)
  target_link_libraries(igraph PUBLIC ${PLFIT_LIBRARIES})
endif()

# Link igraph statically to some of the libraries from the subdirectories
target_link_libraries(
  igraph
  PRIVATE
  bliss cliquer prpack
)

# Disable complex number support for CXSparse because:
#   - It is necessary to compile with MSVC
#   - igraph does not need complex number support from CXSparse on any platform
# This is needed here (in addition to the cxsparse_vendored target) because
# igraph may be compiled with an external CXSparse.
target_compile_definitions(igraph PRIVATE NCOMPLEX)

if (NOT BUILD_SHARED_LIBS)
  target_compile_definitions(igraph PRIVATE IGRAPH_STATIC)
else()
  target_compile_definitions(igraph PRIVATE igraph_EXPORTS)
endif()

if(MSVC)
  # Add MSVC-specific include path for some headers that are missing on Windows
  target_include_directories(igraph PRIVATE ${PROJECT_SOURCE_DIR}/msvc/include)
endif()

# Turn on all warnings for GCC, clang and MSVC
use_all_warnings(igraph)

# GNUInstallDirs be included before generating the pkgconfig file, as it defines
# CMAKE_INSTALL_LIBDIR and CMAKE_INSTALL_INCLUDEDIR variables.
include(GNUInstallDirs)

# Generate pkgconfig file
include(pkgconfig_helpers)

include(GenerateExportHeader)
generate_export_header(igraph
  STATIC_DEFINE IGRAPH_STATIC
  EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/include/igraph_export.h
)

# Provide an igraph-config.cmake file in the installation directory so
# users can find the installed igraph library with FIND_PACKAGE(igraph)
# from their CMakeLists.txt files
include(CMakePackageConfigHelpers)
configure_package_config_file(
  ${PROJECT_SOURCE_DIR}/etc/cmake/igraph-config.cmake.in
  ${PROJECT_BINARY_DIR}/igraph-config.cmake
  # Install destination selected according to https://wiki.debian.org/CMake
  # and by looking at how eigen3 does it in Ubuntu
  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/igraph
)
write_basic_package_version_file(
  ${PROJECT_BINARY_DIR}/igraph-config-version.cmake
  VERSION ${PACKAGE_VERSION_BASE}
  COMPATIBILITY SameMinorVersion
)

# Define how to install the library
install(
  TARGETS igraph bliss cliquer prpack
  EXPORT igraph_targets
  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
install(
  DIRECTORY ${PROJECT_SOURCE_DIR}/include/
  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/igraph
  FILES_MATCHING PATTERN "*.h"
)
install(
  DIRECTORY ${PROJECT_BINARY_DIR}/include/
  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/igraph
  FILES_MATCHING PATTERN "*.h"
)
install(
  FILES ${PROJECT_BINARY_DIR}/igraph.pc
  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
)
install(
  FILES ${PROJECT_BINARY_DIR}/igraph-config.cmake
        ${PROJECT_BINARY_DIR}/igraph-config-version.cmake
  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/igraph
)
install(
  EXPORT igraph_targets
  FILE igraph-targets.cmake
  NAMESPACE igraph::
  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/igraph
)
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4791403
igraph-0.9.9/vendor/source/igraph/src/centrality/0000755000175100001710000000000000000000000022617 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/betweenness.c0000644000175100001710000012112300000000000025305 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see .
*/

#include "igraph_centrality.h"

#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_stack.h"
#include "igraph_dqueue.h"

#include "core/indheap.h"
#include "core/interruption.h"
#include "core/math.h"

/***** Vertex betweenness *****/

/**
 * \ingroup structural
 * \function igraph_betweenness
 * \brief Betweenness centrality of some vertices.
 *
 * The betweenness centrality of a vertex is the number of geodesics
 * going through it. If there are more than one geodesic between two
 * vertices, the value of these geodesics are weighted by one over the
 * number of geodesics.
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        betweenness scores for the specified vertices.
 * \param vids The vertices of which the betweenness centrality scores
 *        will be calculated.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param weights An optional vector containing edge weights for
 *        calculating weighted betweenness. No edge weight may be NaN.
 *        Supply a null pointer here for unweighted betweenness.
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *        \c IGRAPH_EINVVID, invalid vertex id passed in
 *        \p vids.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 * Note that the time complexity is independent of the number of
 * vertices for which the score is calculated.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
 *     See \ref igraph_edge_betweenness() for calculating the betweenness score
 *     of the edges in a graph. See \ref igraph_betweenness_cutoff() to
 *     calculate the range-limited betweenness of the vertices in a graph.
 */
int igraph_betweenness(const igraph_t *graph, igraph_vector_t *res,
                       const igraph_vs_t vids, igraph_bool_t directed,
                       const igraph_vector_t* weights) {
    return igraph_betweenness_cutoff(graph, res, vids, directed, weights, -1);
}

static int igraph_i_betweenness_cutoff_weighted(
        const igraph_t *graph,
        igraph_vector_t *res,
        const igraph_vs_t vids,
        igraph_bool_t directed,
        igraph_real_t cutoff,
        const igraph_vector_t *weights) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_integer_t no_of_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_2wheap_t Q;
    igraph_inclist_t inclist;
    igraph_adjlist_t fathers;
    long int source, j;
    igraph_stack_t S;
    igraph_neimode_t mode = directed ? IGRAPH_OUT : IGRAPH_ALL;
    igraph_vector_t dist, nrgeo, tmpscore;
    igraph_vector_t v_tmpres, *tmpres = &v_tmpres;
    igraph_vit_t vit;
    int cmp_result;
    const double eps = IGRAPH_SHORTEST_PATH_EPSILON;

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length must agree with number of edges.", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0) {
        igraph_real_t minweight = igraph_vector_min(weights);
        if (minweight <= 0) {
            IGRAPH_ERROR("Weight vector must be positive.", IGRAPH_EINVAL);
        } else if (igraph_is_nan(minweight)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        } else if (minweight <= eps) {
            IGRAPH_WARNING("Some weights are smaller than epsilon, calculations may suffer from numerical precision.");
        }
    }

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
    IGRAPH_CHECK(igraph_adjlist_init_empty(&fathers, no_of_nodes));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &fathers);

    IGRAPH_CHECK(igraph_stack_init(&S, no_of_nodes));
    IGRAPH_FINALLY(igraph_stack_destroy, &S);
    IGRAPH_VECTOR_INIT_FINALLY(&dist, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&tmpscore, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&nrgeo, no_of_nodes);

    if (igraph_vs_is_all(&vids)) {
        IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
        igraph_vector_null(res);
        tmpres = res;
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(tmpres, no_of_nodes);
    }

    for (source = 0; source < no_of_nodes; source++) {
        IGRAPH_PROGRESS("Betweenness centrality: ", 100.0 * source / no_of_nodes, 0);
        IGRAPH_ALLOW_INTERRUPTION();

        igraph_2wheap_push_with_index(&Q, source, -1.0);
        VECTOR(dist)[source] = 1.0;
        VECTOR(nrgeo)[source] = 1;

        while (!igraph_2wheap_empty(&Q)) {
            long int minnei = igraph_2wheap_max_index(&Q);
            igraph_real_t mindist = -igraph_2wheap_delete_max(&Q);
            igraph_vector_int_t *neis;
            long int nlen;

            /* Ignore vertices that are more distant than the cutoff */
            if (cutoff >= 0 && mindist > cutoff + 1.0) {
                /* Reset variables if node is too distant */
                VECTOR(tmpscore)[minnei] = 0;
                VECTOR(dist)[minnei] = 0;
                VECTOR(nrgeo)[minnei] = 0;
                igraph_vector_int_clear(igraph_adjlist_get(&fathers, minnei));
                continue;
            }

            igraph_stack_push(&S, minnei);

            /* Now check all neighbors of 'minnei' for a shorter path */
            neis = igraph_inclist_get(&inclist, minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int to = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_real_t curdist = VECTOR(dist)[to];

                if (curdist == 0) {
                    /* this means curdist is infinity */
                    cmp_result = -1;
                } else {
                    cmp_result = igraph_cmp_epsilon(altdist, curdist, eps);
                }

                if (curdist == 0) {
                    /* This is the first non-infinite distance */
                    igraph_vector_int_t *v = igraph_adjlist_get(&fathers, to);
                    igraph_vector_int_resize(v, 1);
                    VECTOR(*v)[0] = minnei;
                    VECTOR(nrgeo)[to] = VECTOR(nrgeo)[minnei];

                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, to, -altdist));
                } else if (cmp_result < 0) {
                    /* This is a shorter path */
                    igraph_vector_int_t *v = igraph_adjlist_get(&fathers, to);
                    igraph_vector_int_resize(v, 1);
                    VECTOR(*v)[0] = minnei;
                    VECTOR(nrgeo)[to] = VECTOR(nrgeo)[minnei];

                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, to, -altdist));
                } else if (cmp_result == 0 &&
                    (altdist <= cutoff + 1.0 || cutoff < 0)) {
                    /* Only add if the node is not more distant than the cutoff */
                    igraph_vector_int_t *v = igraph_adjlist_get(&fathers, to);
                    igraph_vector_int_push_back(v, minnei);
                    VECTOR(nrgeo)[to] += VECTOR(nrgeo)[minnei];
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

        while (!igraph_stack_empty(&S)) {
            long int w = (long int) igraph_stack_pop(&S);
            igraph_vector_int_t *fatv = igraph_adjlist_get(&fathers, w);
            long int fatv_len = igraph_vector_int_size(fatv);
            for (j = 0; j < fatv_len; j++) {
                long int f = (long int) VECTOR(*fatv)[j];
                VECTOR(tmpscore)[f] += VECTOR(nrgeo)[f] / VECTOR(nrgeo)[w] * (1 + VECTOR(tmpscore)[w]);
            }
            if (w != source) {
                VECTOR(*tmpres)[w] += VECTOR(tmpscore)[w];
            }

            /* Reset variables */
            VECTOR(tmpscore)[w] = 0;
            VECTOR(dist)[w] = 0;
            VECTOR(nrgeo)[w] = 0;
            igraph_vector_int_clear(igraph_adjlist_get(&fathers, w));
        }

    } /* source < no_of_nodes */

    if (!igraph_vs_is_all(&vids)) {
        IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);
        IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));

        for (j = 0, IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), j++) {
            long int node = IGRAPH_VIT_GET(vit);
            VECTOR(*res)[j] = VECTOR(*tmpres)[node];
        }

        no_of_nodes = (igraph_integer_t) j;

        igraph_vit_destroy(&vit);
        igraph_vector_destroy(tmpres);
        IGRAPH_FINALLY_CLEAN(2);
    }

    if (!directed || !igraph_is_directed(graph)) {
        for (j = 0; j < no_of_nodes; j++) {
            VECTOR(*res)[j] /= 2.0;
        }
    }

    IGRAPH_PROGRESS("Betweenness centrality: ", 100.0, 0);

    igraph_vector_destroy(&nrgeo);
    igraph_vector_destroy(&tmpscore);
    igraph_vector_destroy(&dist);
    igraph_stack_destroy(&S);
    igraph_adjlist_destroy(&fathers);
    igraph_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(7);

    return 0;
}


/**
 * \ingroup structural
 * \function igraph_betweenness_cutoff
 * \brief Range-limited betweenness centrality.
 *
 * This function computes a range-limited version of betweenness centrality
 * by considering only those shortest paths whose length is no greater
 * then the given cutoff value.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        range-limited betweenness scores for the specified vertices.
 * \param vids The vertices for which the range-limited betweenness centrality
 *        scores will be computed.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param weights An optional vector containing edge weights for
 *        calculating weighted betweenness. No edge weight may be NaN.
 *        Supply a null pointer here for unweighted betweenness.
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact betweenness will be calculated, and
 *        there will be no upper limit on path lengths.
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *        \c IGRAPH_EINVVID, invalid vertex id passed in
 *        \p vids.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 * Note that the time complexity is independent of the number of
 * vertices for which the score is calculated.
 *
 * \sa \ref igraph_betweenness() to calculate the exact betweenness and
 * \ref igraph_edge_betweenness_cutoff() to calculate the range-limited
 * edge betweenness.
 */
int igraph_betweenness_cutoff(const igraph_t *graph, igraph_vector_t *res,
                              const igraph_vs_t vids, igraph_bool_t directed,
                              const igraph_vector_t *weights, igraph_real_t cutoff) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    long int *distance;
    /* Note: nrgeo holds the number of shortest paths, which may be very large in some cases,
     * e.g. in a grid graph. If using an integer type, this results in overflow.
     * With a 'long long int', overflow already affects the result for a grid as small as 36*36.
     * Therefore, we use a 'double' instead. While a 'double' holds fewer digits than a 'long long int',
     * i.e. its precision is lower, it is effectively immune to overflow. The impact on the precision
     * of the final result is negligible. The max betweenness is correct to 14 decimal digits,
     * i.e. the precision limit of 'double', even for a 101*101 grid graph. */
    double *nrgeo = 0;
    double *tmpscore;
    igraph_stack_t stack = IGRAPH_STACK_NULL;
    long int source;
    long int j, k, nneis;
    igraph_vector_int_t *neis;
    igraph_vector_t v_tmpres, *tmpres = &v_tmpres;
    igraph_vit_t vit;

    igraph_adjlist_t adjlist_out, adjlist_in;
    igraph_adjlist_t *adjlist_out_p, *adjlist_in_p;

    if (weights) {
        return igraph_i_betweenness_cutoff_weighted(graph, res, vids, directed,
                                                    cutoff, weights);
    }

    if (!igraph_vs_is_all(&vids)) {
        /* subset */
        IGRAPH_VECTOR_INIT_FINALLY(tmpres, no_of_nodes);
    } else {
        /* only  */
        IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
        igraph_vector_null(res);
        tmpres = res;
    }

    directed = directed && igraph_is_directed(graph);
    if (directed) {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_in, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_in);
        adjlist_out_p = &adjlist_out;
        adjlist_in_p = &adjlist_in;
    } else {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_in, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_in);
        adjlist_out_p = &adjlist_out;
        adjlist_in_p = &adjlist_in;
    }
    for (j = 0; j < no_of_nodes; j++) {
        igraph_vector_int_clear(igraph_adjlist_get(adjlist_in_p, j));
    }

    distance = IGRAPH_CALLOC(no_of_nodes, long int);
    if (distance == 0) {
        IGRAPH_ERROR("Insufficient memory for betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, distance);
    nrgeo = IGRAPH_CALLOC(no_of_nodes, double);
    if (nrgeo == 0) {
        IGRAPH_ERROR("Insufficient memory for betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, nrgeo);
    tmpscore = IGRAPH_CALLOC(no_of_nodes, double);
    if (tmpscore == 0) {
        IGRAPH_ERROR("Insufficient memory for betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmpscore);

    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    igraph_stack_init(&stack, no_of_nodes);
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);

    /* here we go */

    for (source = 0; source < no_of_nodes; source++) {
        IGRAPH_PROGRESS("Betweenness centrality: ", 100.0 * source / no_of_nodes, 0);
        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_dqueue_push(&q, source));
        nrgeo[source] = 1;
        distance[source] = 1;

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);

            /* Ignore vertices that are more distant than the cutoff */
            if (cutoff >= 0 && distance[actnode] > cutoff + 1) {
                /* Reset variables if node is too distant */
                distance[actnode] = 0;
                nrgeo[actnode] = 0;
                tmpscore[actnode] = 0;
                igraph_vector_int_clear(igraph_adjlist_get(adjlist_in_p, actnode));
                continue;
            }

            IGRAPH_CHECK(igraph_stack_push(&stack, actnode));
            neis = igraph_adjlist_get(adjlist_out_p, actnode);
            nneis = igraph_vector_int_size(neis);
            for (j = 0; j < nneis; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (distance[neighbor] == 0) {
                    distance[neighbor] = distance[actnode] + 1;
                    IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                }
                if (distance[neighbor] == distance[actnode] + 1 &&
                    (distance[neighbor] <= cutoff + 1 || cutoff < 0)) {
                    /* Only add if the node is not more distant than the cutoff */
                    igraph_vector_int_t *v = igraph_adjlist_get(adjlist_in_p,
                                             neighbor);
                    igraph_vector_int_push_back(v, actnode);
                    nrgeo[neighbor] += nrgeo[actnode];
                }
            }
        } /* while !igraph_dqueue_empty */

        /* Ok, we've the distance of each node and also the number of
           shortest paths to them. Now we do an inverse search, starting
           with the farthest nodes. */
        while (!igraph_stack_empty(&stack)) {
            long int actnode = (long int) igraph_stack_pop(&stack);
            neis = igraph_adjlist_get(adjlist_in_p, actnode);
            nneis = igraph_vector_int_size(neis);
            for (j = 0; j < nneis; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                tmpscore[neighbor] +=  (tmpscore[actnode] + 1) * nrgeo[neighbor] / nrgeo[actnode];
            }

            if (actnode != source) {
                VECTOR(*tmpres)[actnode] += tmpscore[actnode];
            }

            /* Reset variables */
            distance[actnode] = 0;
            nrgeo[actnode] = 0;
            tmpscore[actnode] = 0;
            igraph_vector_int_clear(igraph_adjlist_get(adjlist_in_p, actnode));
        }

    } /* for source < no_of_nodes */

    IGRAPH_PROGRESS("Betweenness centrality: ", 100.0, 0);

    /* clean  */
    IGRAPH_FREE(distance);
    IGRAPH_FREE(nrgeo);
    IGRAPH_FREE(tmpscore);

    igraph_dqueue_destroy(&q);
    igraph_stack_destroy(&stack);
    IGRAPH_FINALLY_CLEAN(5);

    /* Keep only the requested vertices */
    if (!igraph_vs_is_all(&vids)) {
        IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);
        IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));

        for (k = 0, IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), k++) {
            long int node = IGRAPH_VIT_GET(vit);
            VECTOR(*res)[k] = VECTOR(*tmpres)[node];
        }

        igraph_vit_destroy(&vit);
        igraph_vector_destroy(tmpres);
        IGRAPH_FINALLY_CLEAN(2);
    }

    /* divide by 2 for undirected graph */
    if (!directed) {
        nneis = igraph_vector_size(res);
        for (j = 0; j < nneis; j++) {
            VECTOR(*res)[j] /= 2.0;
        }
    }

    igraph_adjlist_destroy(&adjlist_out);
    igraph_adjlist_destroy(&adjlist_in);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}


/**
 * \ingroup structural
 * \function igraph_betweenness_estimate
 * \brief Estimated betweenness centrality of some vertices.
 *
 * \deprecated-by igraph_betweenness_cutoff 0.9
 *
 * 
 * The betweenness centrality of a vertex is the number of geodesics
 * going through it. If there are more than one geodesic between two
 * vertices, the value of these geodesics are weighted by one over the
 * number of geodesics. When estimating betweenness centrality, igraph
 * takes into consideration only those paths that are shorter than or
 * equal to a prescribed length. Note that the estimated centrality
 * will always be less than the real one.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        estimated betweenness scores for the specified vertices.
 * \param vids The vertices of which the betweenness centrality scores
 *        will be estimated.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact betweenness will be calculated, and
 *        there will be no upper limit on path lengths.
 * \param weights An optional vector containing edge weights for
 *        calculating weighted betweenness. No edge weight may be NaN.
 *        Supply a null pointer here for unweighted betweenness.
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *        \c IGRAPH_EINVVID, invalid vertex id passed in
 *        \p vids.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 * Note that the time complexity is independent of the number of
 * vertices for which the score is calculated.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
 *     See \ref igraph_edge_betweenness() for calculating the betweenness score
 *     of the edges in a graph.
 */

int igraph_betweenness_estimate(const igraph_t *graph, igraph_vector_t *res,
                                const igraph_vs_t vids, igraph_bool_t directed,
                                igraph_real_t cutoff, const igraph_vector_t *weights) {
    IGRAPH_WARNING("igraph_betweenness_estimate is deprecated, use igraph_betweenness_cutoff.");
    return igraph_betweenness_cutoff(graph, res, vids, directed, weights, cutoff);
}

/***** Edge betweenness *****/

static int igraph_i_edge_betweenness_cutoff_weighted(
        const igraph_t *graph,
        igraph_vector_t *result,
        igraph_bool_t directed,
        igraph_real_t cutoff,
        const igraph_vector_t *weights) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_integer_t no_of_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_2wheap_t Q;
    igraph_inclist_t inclist;
    igraph_inclist_t fathers;
    igraph_neimode_t mode = directed ? IGRAPH_OUT : IGRAPH_ALL;
    igraph_vector_t distance, tmpscore;
    igraph_vector_long_t nrgeo;
    long int source, j;
    int cmp_result;
    const double eps = IGRAPH_SHORTEST_PATH_EPSILON;
    igraph_stack_t S;

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length must match number of edges.", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0) {
        igraph_real_t minweight = igraph_vector_min(weights);
        if (minweight <= 0) {
            IGRAPH_ERROR("Weight vector must be positive.", IGRAPH_EINVAL);
        } else if (igraph_is_nan(minweight)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        } else if (minweight <= eps) {
            IGRAPH_WARNING("Some weights are smaller than epsilon, calculations may suffer from numerical precision.");
        }
    }

    IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
    IGRAPH_CHECK(igraph_inclist_init_empty(&fathers, no_of_nodes));
    IGRAPH_FINALLY(igraph_inclist_destroy, &fathers);

    IGRAPH_VECTOR_INIT_FINALLY(&distance, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&tmpscore, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_long_init(&nrgeo, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &nrgeo);

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_stack_init(&S, no_of_nodes));
    IGRAPH_FINALLY(igraph_stack_destroy, &S);

    IGRAPH_CHECK(igraph_vector_resize(result, no_of_edges));
    igraph_vector_null(result);

    for (source = 0; source < no_of_nodes; source++) {
        IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0 * source / no_of_nodes, 0);
        IGRAPH_ALLOW_INTERRUPTION();

        /*     printf("source: %li\n", source); */

        igraph_2wheap_push_with_index(&Q, source, -1.0);
        VECTOR(distance)[source] = 1.0;
        VECTOR(nrgeo)[source] = 1;

        while (!igraph_2wheap_empty(&Q)) {
            long int minnei = igraph_2wheap_max_index(&Q);
            igraph_real_t mindist = -igraph_2wheap_delete_max(&Q);
            igraph_vector_int_t *neis;
            long int nlen;

            /* printf("SP to %li is final, dist: %g, nrgeo: %li\n", minnei, */
            /* VECTOR(distance)[minnei]-1.0, VECTOR(nrgeo)[minnei]); */

            /* Ignore vertices that are more distant than the cutoff */
            if (cutoff >= 0 && VECTOR(distance)[minnei] > cutoff + 1.0) {
                /* Reset variables if node is too distant */
                VECTOR(tmpscore)[minnei] = 0;
                VECTOR(distance)[minnei] = 0;
                VECTOR(nrgeo)[minnei] = 0;
                igraph_vector_int_clear(igraph_inclist_get(&fathers, minnei));
                continue;
            }

            igraph_stack_push(&S, minnei);

            neis = igraph_inclist_get(&inclist, minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int to = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_real_t curdist = VECTOR(distance)[to];

                if (curdist == 0) {
                    /* this means curdist is infinity */
                    cmp_result = -1;
                } else {
                    cmp_result = igraph_cmp_epsilon(altdist, curdist, eps);
                }

                /* printf("to=%ld, altdist = %lg, curdist = %lg, cmp = %d\n",
                  to, altdist, curdist-1, cmp_result); */
                if (curdist == 0) {
                    /* This is the first finite distance to 'to' */
                    igraph_vector_int_t *v = igraph_inclist_get(&fathers, to);
                    /* printf("Found first path to %li (from %li)\n", to, minnei); */
                    igraph_vector_int_resize(v, 1);
                    VECTOR(*v)[0] = edge;
                    VECTOR(nrgeo)[to] = VECTOR(nrgeo)[minnei];
                    VECTOR(distance)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, to, -altdist));
                } else if (cmp_result < 0) {
                    /* This is a shorter path */
                    igraph_vector_int_t *v = igraph_inclist_get(&fathers, to);
                    /* printf("Found a shorter path to %li (from %li)\n", to, minnei); */
                    igraph_vector_int_resize(v, 1);
                    VECTOR(*v)[0] = edge;
                    VECTOR(nrgeo)[to] = VECTOR(nrgeo)[minnei];
                    VECTOR(distance)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, to, -altdist));
                } else if (cmp_result == 0 &&
                    (altdist <= cutoff + 1.0 || cutoff < 0)) {
                    /* Only add if the edge is not more distant than the cutoff */
                    igraph_vector_int_t *v = igraph_inclist_get(&fathers, to);
                    /* printf("Found a second SP to %li (from %li)\n", to, minnei); */
                    IGRAPH_CHECK(igraph_vector_int_push_back(v, edge));
                    VECTOR(nrgeo)[to] += VECTOR(nrgeo)[minnei];
                }
            }

        } /* igraph_2wheap_empty(&Q) */

        while (!igraph_stack_empty(&S)) {
            long int w = (long int) igraph_stack_pop(&S);
            igraph_vector_int_t *fatv = igraph_inclist_get(&fathers, w);
            long int fatv_len = igraph_vector_int_size(fatv);
            /* printf("Popping %li.\n", w); */
            for (j = 0; j < fatv_len; j++) {
                long int fedge = (long int) VECTOR(*fatv)[j];
                long int neighbor = IGRAPH_OTHER(graph, fedge, w);
                VECTOR(tmpscore)[neighbor] += ((double)VECTOR(nrgeo)[neighbor]) /
                                              VECTOR(nrgeo)[w] * (1.0 + VECTOR(tmpscore)[w]);
                /* printf("Scoring %li (edge %li)\n", neighbor, fedge); */
                VECTOR(*result)[fedge] +=
                    ((VECTOR(tmpscore)[w] + 1) * VECTOR(nrgeo)[neighbor]) /
                    VECTOR(nrgeo)[w];
            }

            /* Reset variables */
            VECTOR(tmpscore)[w] = 0;
            VECTOR(distance)[w] = 0;
            VECTOR(nrgeo)[w] = 0;
            igraph_vector_int_clear(fatv);
        }

    } /* source < no_of_nodes */

    if (!directed || !igraph_is_directed(graph)) {
        for (j = 0; j < no_of_edges; j++) {
            VECTOR(*result)[j] /= 2.0;
        }
    }

    IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0, 0);

    igraph_stack_destroy(&S);
    igraph_2wheap_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(2);

    igraph_inclist_destroy(&inclist);
    igraph_inclist_destroy(&fathers);
    igraph_vector_destroy(&distance);
    igraph_vector_destroy(&tmpscore);
    igraph_vector_long_destroy(&nrgeo);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_edge_betweenness
 * \brief Betweenness centrality of the edges.
 *
 * The betweenness centrality of an edge is the number of geodesics
 * going through it. If there are more than one geodesics between two
 * vertices, the value of these geodesics are weighted by one over the
 * number of geodesics.
 *
 * \param graph The graph object.
 * \param result The result of the computation, vector containing the
 *        betweenness scores for the edges.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param weights An optional weight vector for weighted edge
 *        betweenness. No edge weight may be NaN. Supply a null
 *        pointer here for the unweighted version.
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
 *     See \ref igraph_edge_betweenness() for calculating the betweenness score
 *     of the edges in a graph. See \ref igraph_edge_betweenness_cutoff() to
 *     compute the range-limited betweenness score of the edges in a graph.
 */
int igraph_edge_betweenness(const igraph_t *graph, igraph_vector_t *result,
                            igraph_bool_t directed,
                            const igraph_vector_t *weights) {
    return igraph_edge_betweenness_cutoff(graph, result, directed,
                                          weights, -1);
}

/**
 * \ingroup structural
 * \function igraph_edge_betweenness_cutoff
 * \brief Range-limited betweenness centrality of the edges.
 *
 * This function computes a range-limited version of edge betweenness centrality
 * by considering only those shortest paths whose length is no greater
 * then the given cutoff value.
 *
 * \param graph The graph object.
 * \param result The result of the computation, vector containing the
 *        betweenness scores for the edges.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param weights An optional weight vector for weighted
 *        betweenness. No edge weight may be NaN. Supply a null
 *        pointer here for unweighted betweenness.
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact betweenness will be calculated (no
 *        upper limit on path lengths).
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 *
 * \sa \ref igraph_edge_betweenness() to compute the exact edge betweenness and
 * \ref igraph_betweenness_cutoff() to compute the range-limited vertex betweenness.
 */
int igraph_edge_betweenness_cutoff(const igraph_t *graph, igraph_vector_t *result,
                                   igraph_bool_t directed,
                                   const igraph_vector_t *weights, igraph_real_t cutoff) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    long int *distance;
    double *nrgeo;
    double *tmpscore;
    igraph_stack_t stack = IGRAPH_STACK_NULL;
    long int source;
    long int j;

    igraph_inclist_t elist_out, elist_in;
    igraph_inclist_t *elist_out_p, *elist_in_p;
    igraph_vector_int_t *neip;
    long int neino;
    long int i;

    if (weights) {
        return igraph_i_edge_betweenness_cutoff_weighted(graph, result,
                                                         directed, cutoff, weights);
    }

    directed = directed && igraph_is_directed(graph);
    if (directed) {
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_out, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_out);
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_in, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_in);
        elist_out_p = &elist_out;
        elist_in_p = &elist_in;
    } else {
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_out, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_out);
        elist_out_p = elist_in_p = &elist_out;
    }

    distance = IGRAPH_CALLOC(no_of_nodes, long int);
    if (distance == 0) {
        IGRAPH_ERROR("Insufficient memory for edge betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, distance);
    nrgeo = IGRAPH_CALLOC(no_of_nodes, double);
    if (nrgeo == 0) {
        IGRAPH_ERROR("Insufficient memory for edge betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, nrgeo);
    tmpscore = IGRAPH_CALLOC(no_of_nodes, double);
    if (tmpscore == 0) {
        IGRAPH_ERROR("Insufficient memory for edge betweenness calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmpscore);

    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_stack_init(&stack, no_of_nodes));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);

    IGRAPH_CHECK(igraph_vector_resize(result, no_of_edges));

    igraph_vector_null(result);

    /* here we go */

    for (source = 0; source < no_of_nodes; source++) {
        IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0 * source / no_of_nodes, 0);
        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_dqueue_push(&q, source));

        nrgeo[source] = 1;
        distance[source] = 0;

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);

            if (cutoff >= 0 && distance[actnode] > cutoff ) {
                /* Reset variables if node is too distant */
                distance[actnode] = 0;
                tmpscore[actnode] = 0;
                nrgeo[actnode] = 0;
                continue;
            }

            IGRAPH_CHECK(igraph_stack_push(&stack, actnode));

            /* check the neighbors and add to them to the queue if unseen before */
            neip = igraph_inclist_get(elist_out_p, actnode);
            neino = igraph_vector_int_size(neip);
            for (i = 0; i < neino; i++) {
                igraph_integer_t edge = (igraph_integer_t) VECTOR(*neip)[i];
                long int neighbor = (long int) IGRAPH_OTHER(graph, edge, actnode);
                if (nrgeo[neighbor] != 0) {
                    /* we've already seen this node, another shortest path? */
                    if (distance[neighbor] == distance[actnode] + 1) {
                        nrgeo[neighbor] += nrgeo[actnode];
                    }
                } else if (distance[actnode] + 1 <= cutoff || cutoff < 0) {
                    /* we haven't seen this node yet, but we only consider
                     * it if it is not more distant than the cutoff. */
                    nrgeo[neighbor] += nrgeo[actnode];
                    distance[neighbor] = distance[actnode] + 1;
                    IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                }
            }
        } /* while !igraph_dqueue_empty */

        /* Ok, we've the distance of each node and also the number of
           shortest paths to them. Now we do an inverse search, starting
           with the farthest nodes. */
        while (!igraph_stack_empty(&stack)) {
            long int actnode = (long int) igraph_stack_pop(&stack);
            if (distance[actnode] < 1) {
                distance[actnode] = 0;
                tmpscore[actnode] = 0;
                nrgeo[actnode] = 0;
                continue;    /* skip source node */
            }
            /* set the temporary score of the friends */
            neip = igraph_inclist_get(elist_in_p, actnode);
            neino = igraph_vector_int_size(neip);
            for (i = 0; i < neino; i++) {
                igraph_integer_t edgeno = (igraph_integer_t) VECTOR(*neip)[i];
                long int neighbor = (long int) IGRAPH_OTHER(graph, edgeno, actnode);
                if (distance[neighbor] == distance[actnode] - 1 &&
                    nrgeo[neighbor] != 0) {
                    tmpscore[neighbor] +=
                        (tmpscore[actnode] + 1) * nrgeo[neighbor] / nrgeo[actnode];
                    VECTOR(*result)[edgeno] +=
                        (tmpscore[actnode] + 1) * nrgeo[neighbor] / nrgeo[actnode];
                }
            }
            /* Reset variables */
            distance[actnode] = 0;
            tmpscore[actnode] = 0;
            nrgeo[actnode] = 0;
        }
        /* Ok, we've the scores for this source */
    } /* for source <= no_of_nodes */
    IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0, 0);

    /* clean and return */
    IGRAPH_FREE(distance);
    IGRAPH_FREE(nrgeo);
    IGRAPH_FREE(tmpscore);
    igraph_dqueue_destroy(&q);
    igraph_stack_destroy(&stack);
    IGRAPH_FINALLY_CLEAN(5);

    if (directed) {
        igraph_inclist_destroy(&elist_out);
        igraph_inclist_destroy(&elist_in);
        IGRAPH_FINALLY_CLEAN(2);
    } else {
        igraph_inclist_destroy(&elist_out);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* divide by 2 for undirected graph */
    if (!directed || !igraph_is_directed(graph)) {
        for (j = 0; j < igraph_vector_size(result); j++) {
            VECTOR(*result)[j] /= 2.0;
        }
    }

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_edge_betweenness_estimate
 * \brief Estimated betweenness centrality of the edges.
 *
 * \deprecated-by igraph_edge_betweenness_cutoff 0.9
 *
 * 
 * The betweenness centrality of an edge is the number of geodesics
 * going through it. If there are more than one geodesics between two
 * vertices, the value of these geodesics are weighted by one over the
 * number of geodesics. When estimating betweenness centrality, igraph
 * takes into consideration only those paths that are shorter than or
 * equal to a prescribed length. Note that the estimated centrality
 * will always be less than the real one.
 *
 * \param graph The graph object.
 * \param result The result of the computation, vector containing the
 *        betweenness scores for the edges.
 * \param directed Logical, if true directed paths will be considered
 *        for directed graphs. It is ignored for undirected graphs.
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact betweenness will be calculated (no
 *        upper limit on path lengths).
 * \param weights An optional weight vector for weighted betweenness.
 *        No edge weight may be NaN. Supply a null pointer here for
 *        unweighted betweenness.
 * \return Error code:
 *        \c IGRAPH_ENOMEM, not enough memory for
 *        temporary data.
 *
 * Time complexity: O(|V||E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
 *     See \ref igraph_betweenness() for calculating the betweenness score
 *     of the vertices in a graph.
 */
int igraph_edge_betweenness_estimate(const igraph_t *graph, igraph_vector_t *result,
                                   igraph_bool_t directed, igraph_real_t cutoff,
                                   const igraph_vector_t *weights) {
    IGRAPH_WARNING("igraph_edge_betweenness_estimate is deprecated, use igraph_edge_betweenness_cutoff.");
    return igraph_edge_betweenness_cutoff(graph, result, directed, weights, cutoff);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/centrality_other.c0000644000175100001710000016673700000000000026366 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see .
*/

#include "igraph_centrality.h"

#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_structural.h"
#include "igraph_topology.h"
#include "igraph_stack.h"
#include "igraph_dqueue.h"

#include "centrality/prpack_internal.h"
#include "core/indheap.h"
#include "core/interruption.h"
#include "core/math.h"

#include "config.h"

#include 
#include     /* memset */

static int igraph_i_personalized_pagerank_arpack(const igraph_t *graph,
                                                 igraph_vector_t *vector,
                                                 igraph_real_t *value, const igraph_vs_t vids,
                                                 igraph_bool_t directed, igraph_real_t damping,
                                                 const igraph_vector_t *reset,
                                                 const igraph_vector_t *weights,
                                                 igraph_arpack_options_t *options);

static igraph_bool_t igraph_i_vector_mostly_negative(const igraph_vector_t *vector) {
    /* Many of the centrality measures correspond to the eigenvector of some
     * matrix. When v is an eigenvector, c*v is also an eigenvector, therefore
     * it may happen that all the scores in the eigenvector are negative, in which
     * case we want to negate them since the centrality scores should be positive.
     * However, since ARPACK is not always stable, sometimes it happens that
     * *some* of the centrality scores are small negative numbers. This function
     * helps distinguish between the two cases; it should return true if most of
     * the values are relatively large negative numbers, in which case we should
     * negate the eigenvector.
     */
    long int n = igraph_vector_size(vector);
    igraph_real_t mi, ma;

    if (n == 0) {
        return 0;
    }

    igraph_vector_minmax(vector, &mi, &ma);

    if (mi >= 0) {
        return 0;
    }
    if (ma <= 0) {
        return 1;
    }

    /* is the most negative value larger in magnitude than the most positive? */
    return (-mi/ma > 1);
}

static int igraph_i_eigenvector_centrality(igraph_real_t *to, const igraph_real_t *from,
                                           int n, void *extra) {
    igraph_adjlist_t *adjlist = extra;
    igraph_vector_int_t *neis;
    long int i, j, nlen;

    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(adjlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += from[nei];
        }
    }


    return 0;
}

typedef struct igraph_i_eigenvector_centrality_t {
    const igraph_t *graph;
    const igraph_inclist_t *inclist;
    const igraph_vector_t *weights;
} igraph_i_eigenvector_centrality_t;

static int igraph_i_eigenvector_centrality2(igraph_real_t *to, const igraph_real_t *from,
                                            int n, void *extra) {

    igraph_i_eigenvector_centrality_t *data = extra;
    const igraph_t *graph = data->graph;
    const igraph_inclist_t *inclist = data->inclist;
    const igraph_vector_t *weights = data->weights;
    igraph_vector_int_t *edges;
    long int i, j, nlen;

    for (i = 0; i < n; i++) {
        edges = igraph_inclist_get(inclist, i);
        nlen = igraph_vector_int_size(edges);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*edges)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] += w * from[nei];
        }
    }

    return IGRAPH_SUCCESS;
}

static int igraph_i_eigenvector_centrality_undirected(const igraph_t *graph, igraph_vector_t *vector,
                                                      igraph_real_t *value, igraph_bool_t scale,
                                                      const igraph_vector_t *weights,
                                                      igraph_arpack_options_t *options) {

    igraph_vector_t values;
    igraph_matrix_t vectors;
    igraph_vector_t degree;
    long int i;

    options->n = igraph_vcount(graph);
    options->start = 1;   /* no random start vector */

    if (igraph_ecount(graph) == 0) {
        /* special case: empty graph */
        if (value) {
            *value = 0;
        }
        if (vector) {
            igraph_vector_resize(vector, igraph_vcount(graph));
            igraph_vector_fill(vector, 1);
        }
        return IGRAPH_SUCCESS;
    }

    if (weights) {
        igraph_real_t min, max;

        if (igraph_vector_size(weights) != igraph_ecount(graph)) {
            IGRAPH_ERROR("Invalid length of weights vector when calculating "
                         "eigenvector centrality", IGRAPH_EINVAL);
        }
        /* Safe to call minmax, ecount == 0 case was caught earlier */
        IGRAPH_CHECK(igraph_vector_minmax(weights, &min, &max));
        if (min == 0 && max == 0) {
            /* special case: all weights are zeros */
            if (value) {
                *value = 0;
            }
            if (vector) {
                igraph_vector_resize(vector, igraph_vcount(graph));
                igraph_vector_fill(vector, 1);
            }
            return IGRAPH_SUCCESS;
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&values, 0);
    IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);

    IGRAPH_VECTOR_INIT_FINALLY(°ree, options->n);
    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                               IGRAPH_ALL, /*loops=*/ 0));
    RNG_BEGIN();
    for (i = 0; i < options->n; i++) {
        if (VECTOR(degree)[i]) {
            MATRIX(vectors, i, 0) = VECTOR(degree)[i] + RNG_UNIF(-1e-4, 1e-4);
        } else {
            MATRIX(vectors, i, 0) = 1.0;
        }
    }
    RNG_END();
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(1);

    options->n = igraph_vcount(graph);
    options->nev = 1;
    options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rssolve */
    options->which[0] = 'L'; options->which[1] = 'A';
    options->start = 1;   /* no random start vector */

    if (!weights) {

        igraph_adjlist_t adjlist;

        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigenvector_centrality,
                                           &adjlist, options, 0, &values, &vectors));

        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FINALLY_CLEAN(1);

    } else {

        igraph_inclist_t inclist;
        igraph_i_eigenvector_centrality_t data;

        data.graph = graph;
        data.inclist = &inclist;
        data.weights = weights;

        IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);

        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigenvector_centrality2,
                                           &data, options, 0, &values, &vectors));

        igraph_inclist_destroy(&inclist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (value) {
        *value = VECTOR(values)[0];
    }

    if (vector) {
        igraph_real_t amax = 0;
        long int which = 0;
        long int i;
        IGRAPH_CHECK(igraph_vector_resize(vector, options->n));

        if (VECTOR(values)[0] <= 0) {
            /* Pathological case: largest eigenvalue is zero, therefore all the
             * scores can also be zeros, this will be a valid eigenvector.
             * This usually happens with graphs that have lots of sinks and
             * sources only. */
            igraph_vector_fill(vector, 0);
        } else {
            for (i = 0; i < options->n; i++) {
                igraph_real_t tmp;
                VECTOR(*vector)[i] = MATRIX(vectors, i, 0);
                tmp = fabs(VECTOR(*vector)[i]);
                if (tmp > amax) {
                    amax = tmp;
                    which = i;
                }
            }
            if (scale && amax != 0) {
                igraph_vector_scale(vector, 1 / VECTOR(*vector)[which]);
            } else if (igraph_i_vector_mostly_negative(vector)) {
                igraph_vector_scale(vector, -1.0);
            }

            /* Correction for numeric inaccuracies (eliminating -0.0) */
            for (i = 0; i < options->n; i++) {
                if (VECTOR(*vector)[i] < 0) {
                    VECTOR(*vector)[i] = 0;
                }
            }
        }
    }

    if (options->info) {
        IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
    }

    igraph_matrix_destroy(&vectors);
    igraph_vector_destroy(&values);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/* int igraph_i_evcent_dir(igraph_real_t *to, const igraph_real_t *from, */
/*          long int n, void *extra) { */
/*   /\* TODO *\/ */
/*   return 0; */
/* } */

/* int igraph_i_evcent_dir2(igraph_real_t *to, const igraph_real_t *from, */
/*           long int n, void *extra) { */
/*   /\* TODO *\/ */
/*   return 0; */
/* } */

static int igraph_i_eigenvector_centrality_directed(const igraph_t *graph, igraph_vector_t *vector,
                                                    igraph_real_t *value, igraph_bool_t scale,
                                                    const igraph_vector_t *weights,
                                                    igraph_arpack_options_t *options) {

    igraph_matrix_t values;
    igraph_matrix_t vectors;
    igraph_vector_t indegree;
    igraph_bool_t dag;
    long int i;

    if (igraph_ecount(graph) == 0) {
        /* special case: empty graph */
        if (value) {
            *value = 0;
        }
        if (vector) {
            igraph_vector_resize(vector, igraph_vcount(graph));
            igraph_vector_fill(vector, 1);
        }
        return IGRAPH_SUCCESS;
    }

    /* Quick check: if the graph is a DAG, all the eigenvector centralities are
     * zeros, and so is the eigenvalue */
    IGRAPH_CHECK(igraph_is_dag(graph, &dag));
    if (dag) {
        /* special case: graph is a DAG */
        IGRAPH_WARNING("graph is directed and acyclic; eigenvector centralities "
                       "will be zeros");
        if (value) {
            *value = 0;
        }
        if (vector) {
            igraph_vector_resize(vector, igraph_vcount(graph));
            igraph_vector_fill(vector, 0);
        }
        return IGRAPH_SUCCESS;
    }

    if (weights) {
        igraph_real_t min, max;

        if (igraph_vector_size(weights) != igraph_ecount(graph)) {
            IGRAPH_ERROR("Invalid length of weights vector when calculating "
                         "eigenvector centrality", IGRAPH_EINVAL);
        }
        if (igraph_is_directed(graph)) {
            IGRAPH_WARNING("Weighted directed graph in eigenvector centrality");
        }

        /* Safe to call minmax, ecount == 0 case was caught earlier */
        IGRAPH_CHECK(igraph_vector_minmax(weights, &min, &max));

        if (min < 0.0) {
            IGRAPH_WARNING("Negative weights, eigenpair might be complex");
        }
        if (min == 0.0 && max == 0.0) {
            /* special case: all weights are zeros */
            if (value) {
                *value = 0;
            }
            if (vector) {
                igraph_vector_resize(vector, igraph_vcount(graph));
                igraph_vector_fill(vector, 1);
            }
            return IGRAPH_SUCCESS;
        }
    }

    options->n = igraph_vcount(graph);
    options->start = 1;
    options->nev = 1;
    options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rnsolve */
    /* LM mode is not OK here because +1 and -1 can be eigenvalues at the
     * same time, e.g.: a -> b -> a, c -> a */
    options->which[0] = 'L' ; options->which[1] = 'R';

    IGRAPH_MATRIX_INIT_FINALLY(&values, 0, 0);
    IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);

    IGRAPH_VECTOR_INIT_FINALLY(&indegree, options->n);
    IGRAPH_CHECK(igraph_strength(graph, &indegree, igraph_vss_all(),
                                 IGRAPH_IN, /*loops=*/ 1, weights));
    RNG_BEGIN();
    for (i = 0; i < options->n; i++) {
        if (VECTOR(indegree)[i]) {
            MATRIX(vectors, i, 0) = VECTOR(indegree)[i] + RNG_UNIF(-1e-4, 1e-4);
        } else {
            MATRIX(vectors, i, 0) = 1.0;
        }
    }
    RNG_END();
    igraph_vector_destroy(&indegree);
    IGRAPH_FINALLY_CLEAN(1);

    if (!weights) {
        igraph_adjlist_t adjlist;

        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

        IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_eigenvector_centrality,
                                           &adjlist, options, 0, &values,
                                           &vectors));

        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        igraph_inclist_t inclist;
        igraph_i_eigenvector_centrality_t data;

        data.graph = graph;
        data.inclist = &inclist;
        data.weights = weights;

        IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);

        IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_eigenvector_centrality2,
                                           &data, options, 0, &values, &vectors));

        igraph_inclist_destroy(&inclist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (value) {
        *value = MATRIX(values, 0, 0);
    }

    if (vector) {
        igraph_real_t amax = 0;
        long int which = 0;
        long int i;
        IGRAPH_CHECK(igraph_vector_resize(vector, options->n));

        if (MATRIX(values, 0, 0) <= 0) {
            /* Pathological case: largest eigenvalue is zero, therefore all the
             * scores can also be zeros, this will be a valid eigenvector.
             * This usually happens with graphs that have lots of sinks and
             * sources only. */
            igraph_vector_fill(vector, 0);
            MATRIX(values, 0, 0) = 0;
        } else {
            for (i = 0; i < options->n; i++) {
                igraph_real_t tmp;
                VECTOR(*vector)[i] = MATRIX(vectors, i, 0);
                tmp = fabs(VECTOR(*vector)[i]);
                if (tmp > amax) {
                    amax = tmp;
                    which = i;
                }
            }
            if (scale && amax != 0) {
                igraph_vector_scale(vector, 1 / VECTOR(*vector)[which]);
            } else if (igraph_i_vector_mostly_negative(vector)) {
                igraph_vector_scale(vector, -1.0);
            }
        }

        /* Correction for numeric inaccuracies (eliminating -0.0) */
        for (i = 0; i < options->n; i++) {
            if (VECTOR(*vector)[i] < 0) {
                VECTOR(*vector)[i] = 0;
            }
        }
    }

    if (options->info) {
        IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
    }

    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&values);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_eigenvector_centrality
 * Eigenvector centrality of the vertices
 *
 * Eigenvector centrality is a measure of the importance of a node in a
 * network. It assigns relative scores to all nodes in the network based
 * on the principle that connections from high-scoring nodes contribute
 * more to the score of the node in question than equal connections from
 * low-scoring nodes. Specifically, the eigenvector centrality of each
 * vertex is proportional to the sum of eigenvector centralities of its
 * neighbors. In practice, the centralities are determined by calculating the
 * eigenvector corresponding to the largest positive eigenvalue of the
 * adjacency matrix. In the undirected case, this function considers
 * the diagonal entries of the adjacency matrix to be \em twice the number of
 * self-loops on the corresponding vertex.
 *
 * 
 * In the weighted case, the eigenvector centrality of a vertex is proportional
 * to the weighted sum of centralities of its neighbours, i.e.
 * c_i = sum_j w_ij c_j, where w_ij is the weight
 * of the edge connecting vertices \c i and \c j. The weights of parallel edges
 * are added up.
 *
 * 
 * The centrality scores returned by igraph can be normalized
 * (using the \p scale parameter) such that the largest eigenvector centrality
 * score is 1 (with one exception, see below).
 *
 * 
 * In the directed case, the left eigenvector of the adjacency matrix is
 * calculated. In other words, the centrality of a vertex is proportional
 * to the sum of centralities of vertices pointing to it.
 *
 * 
 * Eigenvector centrality is meaningful only for connected graphs.
 * Graphs that are not connected should be decomposed into connected
 * components, and the eigenvector centrality calculated for each separately.
 * This function does not verify that the graph is connected. If it is not,
 * in the undirected case the scores of all but one component will be zeros.
 *
 * 
 * Also note that the adjacency matrix of a directed acyclic graph or the
 * adjacency matrix of an empty graph does not possess positive eigenvalues,
 * therefore the eigenvector centrality is not defined for these graphs.
 * igraph will return an eigenvalue of zero in such cases. The eigenvector
 * centralities will all be equal for an empty graph and will all be zeros
 * for a directed acyclic graph. Such pathological cases can be detected
 * by asking igraph to calculate the eigenvalue as well (using the \p value
 * parameter, see below) and checking whether the eigenvalue is very close
 * to zero.
 *
 * \param graph The input graph. It may be directed.
 * \param vector Pointer to an initialized vector, it will be resized
 *     as needed. The result of the computation is stored here. It can
 *     be a null pointer, then it is ignored.
 * \param value If not a null pointer, then the eigenvalue
 *     corresponding to the found eigenvector is stored here.
 * \param directed Boolean scalar, whether to consider edge directions
 *     in a directed graph. It is ignored for undirected graphs.
 * \param scale If not zero then the result will be scaled such that
 *     the absolute value of the maximum centrality is one.
 * \param weights A null pointer (= no edge weights), or a vector
 *     giving the weights of the edges. The algorithm might produce
 *     complex numbers when some weights are negative. In this case only
 *     the real part is reported.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the
 *    n (number of vertices) parameter and
 *    it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code.
 *
 * Time complexity: depends on the input graph, usually it is O(|V|+|E|).
 *
 * \sa \ref igraph_pagerank and \ref igraph_personalized_pagerank for
 *   modifications of eigenvector centrality.
 *
 * \example examples/simple/eigenvector_centrality.c
 */

int igraph_eigenvector_centrality(const igraph_t *graph,
                                  igraph_vector_t *vector,
                                  igraph_real_t *value,
                                  igraph_bool_t directed, igraph_bool_t scale,
                                  const igraph_vector_t *weights,
                                  igraph_arpack_options_t *options) {

    if (directed && igraph_is_directed(graph)) {
        return igraph_i_eigenvector_centrality_directed(graph, vector, value,
                scale, weights, options);
    } else {
        return igraph_i_eigenvector_centrality_undirected(graph, vector, value,
                scale, weights, options);
    }
}

/* struct for the unweighted variant of the HITS algorithm */
typedef struct igraph_i_kleinberg_data_t {
    igraph_adjlist_t *in;
    igraph_adjlist_t *out;
    igraph_vector_t *tmp;
} igraph_i_kleinberg_data_t;

/* struct for the weighted variant of the HITS algorithm */
typedef struct igraph_i_kleinberg_data2_t {
    const igraph_t *graph;
    igraph_inclist_t *in;
    igraph_inclist_t *out;
    igraph_vector_t *tmp;
    const igraph_vector_t *weights;
} igraph_i_kleinberg_data2_t;

/* ARPACK auxiliary routine for the unweighted HITS algorithm */
static int igraph_i_kleinberg_unweighted(igraph_real_t *to,
                                         const igraph_real_t *from,
                                         int n, void *extra) {
    igraph_i_kleinberg_data_t *data = (igraph_i_kleinberg_data_t*)extra;
    igraph_adjlist_t *in = data->in;
    igraph_adjlist_t *out = data->out;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    long int i, j, nlen;

    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(in, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            VECTOR(*tmp)[i] += from[nei];
        }
    }

    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(out, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += VECTOR(*tmp)[nei];
        }
    }

    return 0;
}

/* ARPACK auxiliary routine for the weighted HITS algorithm */
static int igraph_i_kleinberg_weighted(igraph_real_t *to,
                                       const igraph_real_t *from,
                                       int n, void *extra) {

    igraph_i_kleinberg_data2_t *data = (igraph_i_kleinberg_data2_t*)extra;
    igraph_inclist_t *in = data->in;
    igraph_inclist_t *out = data->out;
    igraph_vector_t *tmp = data->tmp;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *g = data->graph;
    igraph_vector_int_t *neis;
    long int i, j, nlen;

    for (i = 0; i < n; i++) {
        neis = igraph_inclist_get(in, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei_edge = (long int) VECTOR(*neis)[j];
            long int nei = IGRAPH_OTHER(g, nei_edge, i);
            VECTOR(*tmp)[i] += from[nei] * VECTOR(*weights)[nei_edge];
        }
    }

    for (i = 0; i < n; i++) {
        neis = igraph_inclist_get(out, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei_edge = (long int) VECTOR(*neis)[j];
            long int nei = IGRAPH_OTHER(g, nei_edge, i);
            to[i] += VECTOR(*tmp)[nei] * VECTOR(*weights)[nei_edge];
        }
    }

    return 0;
}

static int igraph_i_kleinberg(const igraph_t *graph, igraph_vector_t *vector,
                              igraph_real_t *value, igraph_bool_t scale,
                              const igraph_vector_t *weights,
                              igraph_arpack_options_t *options, int inout) {

    igraph_adjlist_t myinadjlist, myoutadjlist;
    igraph_inclist_t myininclist, myoutinclist;
    igraph_adjlist_t *inadjlist, *outadjlist;
    igraph_inclist_t *ininclist, *outinclist;
    igraph_vector_t tmp;
    igraph_vector_t values;
    igraph_matrix_t vectors;
    igraph_i_kleinberg_data_t extra;
    igraph_i_kleinberg_data2_t extra2;
    long int i;

    if (igraph_ecount(graph) == 0 || igraph_vcount(graph) == 1) {
        /* special case: empty graph or single vertex */
        if (value) {
            *value = igraph_ecount(graph) ? 1.0 : IGRAPH_NAN;
        }
        if (vector) {
            igraph_vector_resize(vector, igraph_vcount(graph));
            igraph_vector_fill(vector, 1);
        }
        return IGRAPH_SUCCESS;
    }

    if (weights) {
        igraph_real_t min, max;

        if (igraph_vector_size(weights) != igraph_ecount(graph)) {
            IGRAPH_ERROR("Invalid length of weights vector when calculating "
                         "hub or authority scores", IGRAPH_EINVAL);
        }
        /* Safe to call minmax, ecount == 0 case was caught earlier */
        IGRAPH_CHECK(igraph_vector_minmax(weights, &min, &max));
        if (min == 0 && max == 0) {
            /* special case: all weights are zeros */
            if (value) {
                *value = IGRAPH_NAN;
            }
            if (vector) {
                igraph_vector_resize(vector, igraph_vcount(graph));
                igraph_vector_fill(vector, 1);
            }
            return IGRAPH_SUCCESS;
        }
    }

    options->n = igraph_vcount(graph);
    options->start = 1;   /* no random start vector */

    IGRAPH_VECTOR_INIT_FINALLY(&values, 0);
    IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, options->n);

    if (inout == 0) {
        inadjlist = &myinadjlist;
        outadjlist = &myoutadjlist;
        ininclist = &myininclist;
        outinclist = &myoutinclist;
    } else if (inout == 1) {
        inadjlist = &myoutadjlist;
        outadjlist = &myinadjlist;
        ininclist = &myoutinclist;
        outinclist = &myininclist;
    } else {
        /* This should not happen */
        IGRAPH_ERROR("Invalid 'inout' argument, please do not call "
                     "this function directly", IGRAPH_FAILURE);
    }

    if (weights == 0) {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &myinadjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &myinadjlist);
        IGRAPH_CHECK(igraph_adjlist_init(graph, &myoutadjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &myoutadjlist);
    } else {
        IGRAPH_CHECK(igraph_inclist_init(graph, &myininclist, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &myininclist);
        IGRAPH_CHECK(igraph_inclist_init(graph, &myoutinclist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &myoutinclist);
    }

    IGRAPH_CHECK(igraph_degree(graph, &tmp, igraph_vss_all(), IGRAPH_ALL, 0));
    for (i = 0; i < options->n; i++) {
        if (VECTOR(tmp)[i] != 0) {
            MATRIX(vectors, i, 0) = VECTOR(tmp)[i];
        } else {
            MATRIX(vectors, i, 0) = 1.0;
        }
    }

    extra.in = inadjlist; extra.out = outadjlist; extra.tmp = &tmp;
    extra2.in = ininclist; extra2.out = outinclist; extra2.tmp = &tmp;
    extra2.graph = graph; extra2.weights = weights;

    options->nev = 1;
    options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rssolve */
    options->which[0] = 'L'; options->which[1] = 'M';

    if (weights == 0) {
        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_kleinberg_unweighted, &extra,
                                           options, 0, &values, &vectors));
        igraph_adjlist_destroy(&myoutadjlist);
        igraph_adjlist_destroy(&myinadjlist);
        IGRAPH_FINALLY_CLEAN(2);
    } else {
        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_kleinberg_weighted, &extra2,
                                           options, 0, &values, &vectors));
        igraph_inclist_destroy(&myoutinclist);
        igraph_inclist_destroy(&myininclist);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    if (value) {
        *value = VECTOR(values)[0];
    }

    if (vector) {
        igraph_real_t amax = 0;
        long int which = 0;
        long int i;
        IGRAPH_CHECK(igraph_vector_resize(vector, options->n));
        for (i = 0; i < options->n; i++) {
            igraph_real_t tmp;
            VECTOR(*vector)[i] = MATRIX(vectors, i, 0);
            tmp = fabs(VECTOR(*vector)[i]);
            if (tmp > amax) {
                amax = tmp;
                which = i;
            }
        }
        if (scale && amax != 0) {
            igraph_vector_scale(vector, 1 / VECTOR(*vector)[which]);
        } else if (igraph_i_vector_mostly_negative(vector)) {
            igraph_vector_scale(vector, -1.0);
        }

        /* Correction for numeric inaccuracies (eliminating -0.0) */
        for (i = 0; i < options->n; i++) {
            if (VECTOR(*vector)[i] < 0) {
                VECTOR(*vector)[i] = 0;
            }
        }
    }

    if (options->info) {
        IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
    }
    igraph_matrix_destroy(&vectors);
    igraph_vector_destroy(&values);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_hub_score
 * \brief Kleinberg's hub scores.
 *
 * The hub scores of the vertices are defined as the principal
 * eigenvector of A*A^T, where A is the adjacency
 * matrix of the graph, A^T is its transposed.
 * 
 * See the following reference on the meaning of this score:
 * J. Kleinberg. Authoritative sources in a hyperlinked
 * environment. \emb Proc. 9th ACM-SIAM Symposium on Discrete
 * Algorithms, \eme 1998. Extended version in \emb Journal of the
 * ACM \eme 46(1999). Also appears as IBM Research Report RJ 10076, May
 * 1997.
 * \param graph The input graph. Can be directed and undirected.
 * \param vector Pointer to an initialized vector, the result is
 *    stored here. If a null pointer then it is ignored.
 * \param value If not a null pointer then the eigenvalue
 *    corresponding to the calculated eigenvector is stored here.
 * \param scale If not zero then the result will be scaled such that
 *     the absolute value of the maximum centrality is one.
 * \param weights A null pointer (=no edge weights), or a vector
 *     giving the weights of the edges.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the
 *    n (number of vertices) parameter and
 *    it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code.
 *
 * Time complexity: depends on the input graph, usually it is O(|V|),
 * the number of vertices.
 *
 * \sa \ref igraph_authority_score() for the companion measure,
 * \ref igraph_pagerank(), \ref igraph_personalized_pagerank(),
 * \ref igraph_eigenvector_centrality() for similar measures.
 */

int igraph_hub_score(const igraph_t *graph, igraph_vector_t *vector,
                     igraph_real_t *value, igraph_bool_t scale,
                     const igraph_vector_t *weights,
                     igraph_arpack_options_t *options) {

    return igraph_i_kleinberg(graph, vector, value, scale, weights, options, 0);
}

/**
 * \function igraph_authority_score
 * \brief Kleinerg's authority scores.
 *
 * The authority scores of the vertices are defined as the principal
 * eigenvector of A^T*A, where A is the adjacency
 * matrix of the graph, A^T is its transposed.
 * 
 * See the following reference on the meaning of this score:
 * J. Kleinberg. Authoritative sources in a hyperlinked
 * environment. \emb Proc. 9th ACM-SIAM Symposium on Discrete
 * Algorithms, \eme 1998. Extended version in \emb Journal of the
 * ACM \eme 46(1999). Also appears as IBM Research Report RJ 10076, May
 * 1997.
 * \param graph The input graph. Can be directed and undirected.
 * \param vector Pointer to an initialized vector, the result is
 *    stored here. If a null pointer then it is ignored.
 * \param value If not a null pointer then the eigenvalue
 *    corresponding to the calculated eigenvector is stored here.
 * \param scale If not zero then the result will be scaled such that
 *     the absolute value of the maximum centrality is one.
 * \param weights A null pointer (=no edge weights), or a vector
 *     giving the weights of the edges.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the
 *    n (number of vertices) parameter and
 *    it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code.
 *
 * Time complexity: depends on the input graph, usually it is O(|V|),
 * the number of vertices.
 *
 * \sa \ref igraph_hub_score() for the companion measure,
 * \ref igraph_pagerank(), \ref igraph_personalized_pagerank(),
 * \ref igraph_eigenvector_centrality() for similar measures.
 */

int igraph_authority_score(const igraph_t *graph, igraph_vector_t *vector,
                           igraph_real_t *value, igraph_bool_t scale,
                           const igraph_vector_t *weights,
                           igraph_arpack_options_t *options) {

    return igraph_i_kleinberg(graph, vector, value, scale, weights, options, 1);
}

typedef struct igraph_i_pagerank_data_t {
    const igraph_t *graph;
    igraph_adjlist_t *adjlist;
    igraph_real_t damping;
    igraph_vector_t *outdegree;
    igraph_vector_t *tmp;
    igraph_vector_t *reset;
} igraph_i_pagerank_data_t;

typedef struct igraph_i_pagerank_data2_t {
    const igraph_t *graph;
    igraph_inclist_t *inclist;
    const igraph_vector_t *weights;
    igraph_real_t damping;
    igraph_vector_t *outdegree;
    igraph_vector_t *tmp;
    igraph_vector_t *reset;
} igraph_i_pagerank_data2_t;

static int igraph_i_pagerank(igraph_real_t *to, const igraph_real_t *from,
                             int n, void *extra) {

    igraph_i_pagerank_data_t *data = extra;
    igraph_adjlist_t *adjlist = data->adjlist;
    igraph_vector_t *outdegree = data->outdegree;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_t *reset = data->reset;
    igraph_vector_int_t *neis;
    long int i, j, nlen;
    igraph_real_t sumfrom = 0.0;
    igraph_real_t fact = 1 - data->damping;

    /* Calculate p(x) / outdegree(x) in advance for all the vertices.
     * Note that we may divide by zero here; this is intentional since
     * we won't use those values and we save a comparison this way.
     * At the same time, we calculate the global probability of a
     * random jump in `sumfrom`. For vertices with no outgoing edges,
     * we will surely jump from there if we are there, hence those
     * vertices contribute p(x) to the teleportation probability.
     * For vertices with some outgoing edges, we jump from there with
     * probability `fact` if we are there, hence they contribute
     * p(x)*fact */
    for (i = 0; i < n; i++) {
        sumfrom += VECTOR(*outdegree)[i] != 0 ? from[i] * fact : from[i];
        VECTOR(*tmp)[i] = from[i] / VECTOR(*outdegree)[i];
    }

    /* Here we calculate the part of the `to` vector that results from
     * moving along links (and not from teleportation) */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(adjlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += VECTOR(*tmp)[nei];
        }
        to[i] *= data->damping;
    }

    /* Now we add the contribution from random jumps. `reset` is a vector
     * that defines the probability of ending up in vertex i after a jump.
     * `sumfrom` is the global probability of jumping as mentioned above. */
    /* printf("sumfrom = %.6f\n", (float)sumfrom); */

    if (reset) {
        /* Running personalized PageRank */
        for (i = 0; i < n; i++) {
            to[i] += sumfrom * VECTOR(*reset)[i];
        }
    } else {
        /* Traditional PageRank with uniform reset vector */
        sumfrom /= n;
        for (i = 0; i < n; i++) {
            to[i] += sumfrom;
        }
    }

    return 0;
}

static int igraph_i_pagerank2(igraph_real_t *to, const igraph_real_t *from,
                              int n, void *extra) {

    igraph_i_pagerank_data2_t *data = extra;
    const igraph_t *graph = data->graph;
    igraph_inclist_t *inclist = data->inclist;
    const igraph_vector_t *weights = data->weights;
    igraph_vector_t *outdegree = data->outdegree;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_t *reset = data->reset;
    long int i, j, nlen;
    igraph_real_t sumfrom = 0.0;
    igraph_vector_int_t *neis;
    igraph_real_t fact = 1 - data->damping;

    /*
    printf("PageRank weighted: multiplying vector: ");
    for (i=0; idamping;
    }

    /* printf("sumfrom = %.6f\n", (float)sumfrom); */

    if (reset) {
        /* Running personalized PageRank */
        for (i = 0; i < n; i++) {
            to[i] += sumfrom * VECTOR(*reset)[i];
        }
    } else {
        /* Traditional PageRank with uniform reset vector */
        sumfrom /= n;
        for (i = 0; i < n; i++) {
            to[i] += sumfrom;
        }
    }

    /*
    printf("PageRank weighted: multiplied vector: ");
    for (i=0; i1 - damping.
 * If the random walker gets stuck in a sink vertex, it will also restart
 * from a random vertex.
 *
 * 
 * The PageRank centrality is mainly useful for directed graphs. In undirected
 * graphs it converges to trivial values proportional to degrees as the damping
 * factor approaches 1.
 *
 * 
 * Starting from version 0.9, igraph has two PageRank implementations,
 * and the user can choose between them. The first implementation is
 * \c IGRAPH_PAGERANK_ALGO_ARPACK, based on the ARPACK library. This
 * was the default before igraph version 0.7. The second and recommended
 * implementation is \c IGRAPH_PAGERANK_ALGO_PRPACK. This is using the
 * PRPACK package, see https://github.com/dgleich/prpack .
 *
 * 
 * Note that the PageRank of a given vertex depends on the PageRank
 * of all other vertices, so even if you want to calculate the PageRank for
 * only some of the vertices, all of them must be calculated. Requesting
 * the PageRank for only some of the vertices does not result in any
 * performance increase at all.
 *
 * 
 * References:
 *
 * 
 * Sergey Brin and Larry Page: The Anatomy of a Large-Scale Hypertextual
 * Web Search Engine. Proceedings of the 7th World-Wide Web Conference,
 * Brisbane, Australia, April 1998.
 *
 * \param graph The graph object.
 * \param algo The PageRank implementation to use. Possible values:
 *    \c IGRAPH_PAGERANK_ALGO_ARPACK, \c IGRAPH_PAGERANK_ALGO_PRPACK.
 * \param vector Pointer to an initialized vector, the result is
 *    stored here. It is resized as needed.
 * \param value Pointer to a real variable, the eigenvalue
 *    corresponding to the PageRank vector is stored here. It should
 *    be always exactly one.
 * \param vids The vertex ids for which the PageRank is returned.
 * \param directed Boolean, whether to consider the directedness of
 *    the edges. This is ignored for undirected graphs.
 * \param damping The damping factor ("d" in the original paper).
 *    Must be a probability in the range [0, 1]. A commonly used value is 0.85.
 * \param weights Optional edge weights. May be a \c NULL pointer,
 *    meaning unweighted edges, or a vector of non-negative values
 *    of the same length as the number of edges.
 * \param options Options for the ARPACK method. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the n (number
 *    of vertices), nev (1), ncv (3) and which
 *    (LM) parameters and it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for temporary data.
 *         \c IGRAPH_EINVVID, invalid vertex id in \p vids.
 *
 * Time complexity: depends on the input graph, usually it is O(|E|),
 * the number of edges.
 *
 * \sa \ref igraph_personalized_pagerank() and \ref igraph_personalized_pagerank_vs()
 * for the personalized PageRank measure. See \ref igraph_arpack_rssolve() and
 * \ref igraph_arpack_rnsolve() for the underlying machinery used by
 * \c IGRAPH_PAGERANK_ALGO_ARPACK.
 *
 * \example examples/simple/igraph_pagerank.c
 */

int igraph_pagerank(const igraph_t *graph, igraph_pagerank_algo_t algo,
                    igraph_vector_t *vector,
                    igraph_real_t *value, const igraph_vs_t vids,
                    igraph_bool_t directed, igraph_real_t damping,
                    const igraph_vector_t *weights, igraph_arpack_options_t *options) {
    return igraph_personalized_pagerank(graph, algo, vector, value, vids,
                                        directed, damping, NULL, weights,
                                        options);
}

/**
 * \function igraph_personalized_pagerank_vs
 * \brief Calculates the personalized Google PageRank for the specified vertices.
 *
 * The personalized PageRank is similar to the original PageRank measure, but
 * when the random walk is restarted, a new starting vertex is chosen according to
 * a specified distribution.
 * This distribution is used both when restarting randomly with probability
 * 1 - damping, and when the walker is forced to restart due to being
 * stuck in a sink vertex (a vertex with no outgoing edges).
 *
 * 
 * This simplified interface takes a vertex sequence and resets the random walk to
 * one of the vertices in the specified vertex sequence, chosen uniformly. A typical
 * application of personalized PageRank is when the random walk is reset to the same
 * vertex every time - this can easily be achieved using \ref igraph_vss_1() which
 * generates a vertex sequence containing only a single vertex.
 *
 * 
 * Note that the personalized PageRank of a given vertex depends on the
 * personalized PageRank of all other vertices, so even if you want to calculate
 * the personalized PageRank for only some of the vertices, all of them must be
 * calculated. Requesting the personalized PageRank for only some of the vertices
 * does not result in any performance increase at all.
 * 
 *
 * 
 * \param graph The graph object.
 * \param algo The PageRank implementation to use. Possible values:
 *    \c IGRAPH_PAGERANK_ALGO_ARPACK, \c IGRAPH_PAGERANK_ALGO_PRPACK.
 * \param vector Pointer to an initialized vector, the result is
 *    stored here. It is resized as needed.
 * \param value Pointer to a real variable, the eigenvalue
 *    corresponding to the PageRank vector is stored here. It should
 *    be always exactly one.
 * \param vids The vertex ids for which the PageRank is returned.
 * \param directed Boolean, whether to consider the directedness of
 *    the edges. This is ignored for undirected graphs.
 * \param damping The damping factor ("d" in the original paper).
 *    Must be a probability in the range [0, 1]. A commonly used value is 0.85.
 * \param reset_vids IDs of the vertices used when resetting the random walk.
 * \param weights Optional edge weights, it is either a null pointer,
 *    then the edges are not weighted, or a vector of the same length
 *    as the number of edges.
 * \param options Options for the ARPACK method. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the n (number
 *    of vertices), nev (1), ncv (3) and which
 *    (LM) parameters and it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *         \c IGRAPH_EINVVID, invalid vertex id in
 *         \p vids or an empty reset vertex sequence in
 *         \p vids_reset.
 *
 * Time complexity: depends on the input graph, usually it is O(|E|),
 * the number of edges.
 *
 * \sa \ref igraph_pagerank() for the non-personalized implementation.
 */

int igraph_personalized_pagerank_vs(const igraph_t *graph,
                                    igraph_pagerank_algo_t algo, igraph_vector_t *vector,
                                    igraph_real_t *value, const igraph_vs_t vids,
                                    igraph_bool_t directed, igraph_real_t damping,
                                    igraph_vs_t reset_vids,
                                    const igraph_vector_t *weights,
                                    igraph_arpack_options_t *options) {
    igraph_vector_t reset;
    igraph_vit_t vit;

    IGRAPH_VECTOR_INIT_FINALLY(&reset, igraph_vcount(graph));
    IGRAPH_CHECK(igraph_vit_create(graph, reset_vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    while (!IGRAPH_VIT_END(vit)) {
        VECTOR(reset)[(long int)IGRAPH_VIT_GET(vit)]++;
        IGRAPH_VIT_NEXT(vit);
    }
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_personalized_pagerank(graph, algo, vector,
                 value, vids, directed,
                 damping, &reset, weights,
                 options));

    igraph_vector_destroy(&reset);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_personalized_pagerank
 * \brief Calculates the personalized Google PageRank for the specified vertices.
 *
 * The personalized PageRank is similar to the original PageRank measure, but
 * when the random walk is restarted, a new starting vertex is chosen non-uniformly,
 * according to the distribution specified in \p reset
 * (instead of the uniform distribution in the original PageRank measure).
 * The \p reset distribution is used both when restarting randomly with probability
 * 1 - damping, and when the walker is forced to restart due to being
 * stuck in a sink vertex (a vertex with no outgoing edges).
 *
 * 
 * Note that the personalized PageRank of a given vertex depends on the
 * personalized PageRank of all other vertices, so even if you want to calculate
 * the personalized PageRank for only some of the vertices, all of them must be
 * calculated. Requesting the personalized PageRank for only some of the vertices
 * does not result in any performance increase at all.
 * 
 *
 * 
 * \param graph The graph object.
 * \param algo The PageRank implementation to use. Possible values:
 *    \c IGRAPH_PAGERANK_ALGO_ARPACK, \c IGRAPH_PAGERANK_ALGO_PRPACK.
 * \param vector Pointer to an initialized vector, the result is
 *    stored here. It is resized as needed.
 * \param value Pointer to a real variable, the eigenvalue
 *    corresponding to the PageRank vector is stored here. It should
 *    be always exactly one.
 * \param vids The vertex ids for which the PageRank is returned.
 * \param directed Boolean, whether to consider the directedness of
 *    the edges. This is ignored for undirected graphs.
 * \param damping The damping factor ("d" in the original paper).
 *    Must be a probability in the range [0, 1]. A commonly used value is 0.85.
 * \param reset The probability distribution over the vertices used when
 *    resetting the random walk. It is either a \c NULL pointer (denoting
 *    a uniform choice that results in the original PageRank measure)
 *    or a vector of the same length as the number of vertices.
 * \param weights Optional edge weights. May be a \c NULL pointer,
 *    meaning unweighted edges, or a vector of non-negative values
 *    of the same length as the number of edges.
 * \param options Options for the ARPACK method. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the n (number
 *    of vertices), nev (1), ncv (3) and which
 *    (LM) parameters and it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *         \c IGRAPH_EINVVID, invalid vertex id in
 *         \p vids or an invalid reset vector in \p reset.
 *
 * Time complexity: depends on the input graph, usually it is O(|E|),
 * the number of edges.
 *
 * \sa \ref igraph_pagerank() for the non-personalized implementation,
 * \ref igraph_personalized_pagerank_vs() for a personalized implementation
 * with resetting to specific vertices.
 */
int igraph_personalized_pagerank(const igraph_t *graph,
                                 igraph_pagerank_algo_t algo, igraph_vector_t *vector,
                                 igraph_real_t *value, const igraph_vs_t vids,
                                 igraph_bool_t directed, igraph_real_t damping,
                                 const igraph_vector_t *reset,
                                 const igraph_vector_t *weights,
                                 igraph_arpack_options_t *options) {

    if (damping < 0.0 || damping > 1.0) {
        IGRAPH_ERROR("The PageRank damping factor must be in the range [0,1].", IGRAPH_EINVAL);
    }

    if (algo == IGRAPH_PAGERANK_ALGO_ARPACK) {
        return igraph_i_personalized_pagerank_arpack(graph, vector, value, vids,
                directed, damping, reset,
                weights, options);
    } else if (algo == IGRAPH_PAGERANK_ALGO_PRPACK) {
        return igraph_i_personalized_pagerank_prpack(graph, vector, value, vids,
                directed, damping, reset,
                weights);
    }

    IGRAPH_ERROR("Unknown PageRank algorithm", IGRAPH_EINVAL);
}

/*
 * ARPACK-based implementation of \c igraph_personalized_pagerank.
 *
 * See \c igraph_personalized_pagerank for the documentation of the parameters.
 */
static int igraph_i_personalized_pagerank_arpack(const igraph_t *graph, igraph_vector_t *vector,
                                                 igraph_real_t *value, const igraph_vs_t vids,
                                                 igraph_bool_t directed, igraph_real_t damping,
                                                 const igraph_vector_t *reset,
                                                 const igraph_vector_t *weights,
                                                 igraph_arpack_options_t *options) {
    igraph_matrix_t values;
    igraph_matrix_t vectors;
    igraph_neimode_t dirmode;
    igraph_vector_t outdegree;
    igraph_vector_t indegree;
    igraph_vector_t tmp;
    igraph_vector_t normalized_reset;

    long int i;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);

    if (reset && igraph_vector_size(reset) != no_of_nodes) {
        IGRAPH_ERROR("Invalid length of reset vector when calculating personalized PageRank scores.", IGRAPH_EINVAL);
    }

    if (no_of_edges == 0) {
        /* Special case: graph with no edges. Result is the same as the personalization vector. */
        if (value) {
            *value = 1.0;
        }
        if (vector) {
            IGRAPH_CHECK(igraph_vector_resize(vector, no_of_nodes));
            if (reset && no_of_nodes > 0) {
                for (i=0; i < no_of_nodes; ++i) {
                    VECTOR(*vector)[i] = VECTOR(*reset)[i];
                }
                igraph_vector_scale(vector, 1.0 / igraph_vector_sum(vector));
            } else {
                igraph_vector_fill(vector, 1.0 / no_of_nodes);
            }
        }
        return IGRAPH_SUCCESS;
    }

    options->n = (int) no_of_nodes;
    options->nev = 1;
    options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rnsolve */
    options->which[0] = 'L'; options->which[1] = 'M';
    options->start = 1;       /* no random start vector */

    directed = directed && igraph_is_directed(graph);

    if (weights) {
        igraph_real_t min, max;

        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Invalid length of weights vector when calculating PageRank scores.", IGRAPH_EINVAL);
        }

        /* Safe to call minmax, ecount == 0 case was caught earlier */
        IGRAPH_CHECK(igraph_vector_minmax(weights, &min, &max));
        if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        }
        if (min == 0 && max == 0) {
            /* Special case: all weights are zeros. Result is the same as the personalization vector. */
            if (value) {
                *value = 1.0;
            }
            if (vector) {
                IGRAPH_CHECK(igraph_vector_resize(vector, no_of_nodes));
                if (reset) {
                    for (i=0; i < no_of_nodes; ++i) {
                        VECTOR(*vector)[i] = VECTOR(*reset)[i];
                    }
                    igraph_vector_scale(vector, 1.0 / igraph_vector_sum(vector));
                } else {
                    igraph_vector_fill(vector, 1.0 / no_of_nodes);
                }
            }
            return IGRAPH_SUCCESS;
        }
    }

    IGRAPH_MATRIX_INIT_FINALLY(&values, 0, 0);
    IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);

    if (directed) {
        dirmode = IGRAPH_IN;
    } else {
        dirmode = IGRAPH_ALL;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&indegree, options->n);
    IGRAPH_VECTOR_INIT_FINALLY(&outdegree, options->n);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, options->n);

    RNG_BEGIN();

    if (reset) {
        /* Normalize reset vector so the sum is 1 */
        double reset_sum, reset_min;
        reset_min = igraph_vector_min(reset);
        if (reset_min < 0) {
            IGRAPH_ERROR("The reset vector must not contain negative elements.", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(reset_min)) {
            IGRAPH_ERROR("The reset vector must not contain NaN values.", IGRAPH_EINVAL);
        }
        reset_sum = igraph_vector_sum(reset);
        if (reset_sum == 0) {
            IGRAPH_ERROR("The sum of the elements in the reset vector must not be zero.", IGRAPH_EINVAL);
        }

        IGRAPH_CHECK(igraph_vector_copy(&normalized_reset, reset));
        IGRAPH_FINALLY(igraph_vector_destroy, &normalized_reset);

        igraph_vector_scale(&normalized_reset, 1.0 / reset_sum);
    }

    if (!weights) {

        igraph_adjlist_t adjlist;
        igraph_i_pagerank_data_t data;

        data.graph = graph;
        data.adjlist = &adjlist;
        data.damping = damping;
        data.outdegree = &outdegree;
        data.tmp = &tmp;
        data.reset = reset ? &normalized_reset : NULL;

        IGRAPH_CHECK(igraph_degree(graph, &outdegree, igraph_vss_all(),
                                   directed ? IGRAPH_OUT : IGRAPH_ALL, IGRAPH_LOOPS));
        IGRAPH_CHECK(igraph_degree(graph, &indegree, igraph_vss_all(),
                                   directed ? IGRAPH_IN : IGRAPH_ALL, IGRAPH_LOOPS));
        /* Set up an appropriate starting vector. We start from the in-degrees
         * plus some small random noise to avoid convergence problems */
        for (i = 0; i < options->n; i++) {
            if (VECTOR(indegree)[i]) {
                MATRIX(vectors, i, 0) = VECTOR(indegree)[i] + RNG_UNIF(-1e-4, 1e-4);
            } else {
                MATRIX(vectors, i, 0) = 1;
            }
        }

        IGRAPH_CHECK(igraph_adjlist_init(
            graph, &adjlist, dirmode, IGRAPH_LOOPS, IGRAPH_MULTIPLE
        ));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

        IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_pagerank,
                                           &data, options, 0, &values, &vectors));

        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FINALLY_CLEAN(1);

    } else {

        igraph_inclist_t inclist;
        igraph_bool_t negative_weight_warned = 0;
        igraph_i_pagerank_data2_t data;

        data.graph = graph;
        data.inclist = &inclist;
        data.weights = weights;
        data.damping = damping;
        data.outdegree = &outdegree;
        data.tmp = &tmp;
        data.reset = reset ? &normalized_reset : NULL;

        IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, dirmode, IGRAPH_LOOPS));
        IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);

        /* Weighted degree */
        for (i = 0; i < no_of_edges; i++) {
            long int from = IGRAPH_FROM(graph, i);
            long int to = IGRAPH_TO(graph, i);
            igraph_real_t weight = VECTOR(*weights)[i];
            if (weight < 0 && !negative_weight_warned) {
                IGRAPH_WARNING("Replacing negative weights with zeros during PageRank calculation.");
                weight = 0;
                negative_weight_warned = 1;
            }
            VECTOR(outdegree)[from] += weight;
            VECTOR(indegree) [to]   += weight;
            if (!directed) {
                VECTOR(outdegree)[to]   += weight;
                VECTOR(indegree) [from] += weight;
            }
        }
        /* Set up an appropriate starting vector. We start from the in-degrees
         * plus some small random noise to avoid convergence problems */
        for (i = 0; i < options->n; i++) {
            if (VECTOR(indegree)[i]) {
                MATRIX(vectors, i, 0) = VECTOR(indegree)[i] + RNG_UNIF(-1e-4, 1e-4);
            } else {
                MATRIX(vectors, i, 0) = 1;
            }
        }

        IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_pagerank2,
                                           &data, options, 0, &values, &vectors));

        igraph_inclist_destroy(&inclist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    RNG_END();

    if (reset) {
        igraph_vector_destroy(&normalized_reset);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&tmp);
    igraph_vector_destroy(&outdegree);
    igraph_vector_destroy(&indegree);
    IGRAPH_FINALLY_CLEAN(3);

    if (value) {
        *value = MATRIX(values, 0, 0);
    }

    if (vector) {
        long int i;
        igraph_vit_t vit;
        long int nodes_to_calc;
        igraph_real_t sum = 0;

        for (i = 0; i < no_of_nodes; i++) {
            sum += MATRIX(vectors, i, 0);
        }

        IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);
        nodes_to_calc = IGRAPH_VIT_SIZE(vit);

        IGRAPH_CHECK(igraph_vector_resize(vector, nodes_to_calc));
        for (IGRAPH_VIT_RESET(vit), i = 0; !IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), i++) {
            VECTOR(*vector)[i] = MATRIX(vectors, (long int)IGRAPH_VIT_GET(vit), 0);
            VECTOR(*vector)[i] /= sum;
        }

        igraph_vit_destroy(&vit);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (options->info) {
        IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
    }

    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&values);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/centralization.c0000644000175100001710000005566700000000000026034 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see .
*/

#include "igraph_centrality.h"

#include "igraph_interface.h"
#include "igraph_vector.h"

#include "core/math.h"

/**
 * \function igraph_centralization
 * Calculate the centralization score from the node level scores
 *
 * For a centrality score defined on the vertices of a graph, it is
 * possible to define a graph level centralization index, by
 * calculating the sum of the deviation from the maximum centrality
 * score. Consequently, the higher the centralization index of the
 * graph, the more centralized the structure is.
 *
 * In order to make graphs of different sizes comparable,
 * the centralization index is usually normalized to a number between
 * zero and one, by dividing the (unnormalized) centralization score
 * of the most centralized structure with the same number of vertices.
 *
 * For most centrality indices the most centralized
 * structure is the star graph, a single center connected to all other
 * nodes in the network. There are some variation depending on whether
 * the graph is directed or not, whether loop edges are allowed, etc.
 *
 * 
 * This function simply calculates the graph level index, if the node
 * level scores and the theoretical maximum are given. It is called by
 * all the measure-specific centralization functions.
 *
 * \param scores A vector containing the node-level centrality
 *     scores.
 * \param theoretical_max The graph level centrality score of the most
 *     centralized graph with the same number of vertices. Only used
 *     if \c normalized set to true.
 * \param normalized Boolean, whether to normalize the centralization
 *     by dividing the supplied theoretical maximum.
 * \return The graph level index.
 *
 * \sa \ref igraph_centralization_degree(), \ref
 * igraph_centralization_betweenness(), \ref
 * igraph_centralization_closeness(), and \ref
 * igraph_centralization_eigenvector_centrality() for specific
 * centralization functions.
 *
 * Time complexity: O(n), the length of the score vector.
 *
 * \example examples/simple/centralization.c
 */

igraph_real_t igraph_centralization(const igraph_vector_t *scores,
                                    igraph_real_t theoretical_max,
                                    igraph_bool_t normalized) {

    long int no_of_nodes = igraph_vector_size(scores);
    igraph_real_t maxscore = 0.0;
    igraph_real_t cent = 0.0;

    if (no_of_nodes != 0) {
        maxscore = igraph_vector_max(scores);
        cent = no_of_nodes * maxscore - igraph_vector_sum(scores);
        if (normalized) {
            cent = cent / theoretical_max;
        }
    } else {
        cent = IGRAPH_NAN;
    }

    return cent;
}

/**
 * \function igraph_centralization_degree
 * Calculate vertex degree and graph centralization
 *
 * This function calculates the degree of the vertices by passing its
 * arguments to \ref igraph_degree(); and it calculates the graph
 * level centralization index based on the results by calling \ref
 * igraph_centralization().
 * \param graph The input graph.
 * \param res A vector if you need the node-level degree scores, or a
 *     null pointer otherwise.
 * \param mode Constant the specifies the type of degree for directed
 *     graphs. Possible values: \c IGRAPH_IN, \c IGRAPH_OUT and \c
 *     IGRAPH_ALL. This argument is ignored for undirected graphs.
 * \param loops Boolean, whether to consider loop edges when
 *     calculating the degree (and the centralization).
 * \param centralization Pointer to a real number, the centralization
 *     score is placed here.
 * \param theoretical_max Pointer to real number or a null pointer. If
 *     not a null pointer, then the theoretical maximum graph
 *     centrality score for a graph with the same number vertices is
 *     stored here.
 * \param normalized Boolean, whether to calculate a normalized
 *     centralization score. See \ref igraph_centralization() for how
 *     the normalization is done.
 * \return Error code.
 *
 * \sa \ref igraph_centralization(), \ref igraph_degree().
 *
 * Time complexity: the complexity of \ref igraph_degree() plus O(n),
 * the number of vertices queried, for calculating the centralization
 * score.
 */

int igraph_centralization_degree(const igraph_t *graph, igraph_vector_t *res,
                                 igraph_neimode_t mode, igraph_bool_t loops,
                                 igraph_real_t *centralization,
                                 igraph_real_t *theoretical_max,
                                 igraph_bool_t normalized) {

    igraph_vector_t myscores;
    igraph_vector_t *scores = res;
    igraph_real_t *tmax = theoretical_max, mytmax;

    if (!tmax) {
        tmax = &mytmax;
    }

    if (!res) {
        scores = &myscores;
        IGRAPH_VECTOR_INIT_FINALLY(scores, 0);
    }

    IGRAPH_CHECK(igraph_degree(graph, scores, igraph_vss_all(), mode, loops));

    IGRAPH_CHECK(igraph_centralization_degree_tmax(graph, 0, mode, loops,
                 tmax));

    *centralization = igraph_centralization(scores, *tmax, normalized);

    if (!res) {
        igraph_vector_destroy(scores);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_centralization_degree_tmax
 * Theoretical maximum for graph centralization based on degree
 *
 * This function returns the theoretical maximum graph centrality
 * based on vertex degree.
 *
 * 
 * There are two ways to call this function, the first is to supply a
 * graph as the graph argument, and then the number of
 * vertices is taken from this object, and its directedness is
 * considered as well. The nodes argument is ignored in
 * this case. The mode argument is also ignored if the
 * supplied graph is undirected.
 *
 * 
 * The other way is to supply a null pointer as the graph
 * argument. In this case the nodes and mode
 * arguments are considered.
 *
 * 
 * The most centralized structure is the star. More specifically, for
 * undirected graphs it is the star, for directed graphs it is the
 * in-star or the out-star.
 * \param graph A graph object or a null pointer, see the description
 *     above.
 * \param nodes The number of nodes. This is ignored if the
 *     graph argument is not a null pointer.
 * \param mode Constant, whether the calculation is based on in-degree
 *     (IGRAPH_IN), out-degree (IGRAPH_OUT)
 *     or total degree (IGRAPH_ALL). This is ignored if
 *     the graph argument is not a null pointer and the
 *     given graph is undirected.
 * \param loops Boolean scalar, whether to consider loop edges in the
 *     calculation.
 * \param res Pointer to a real variable, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(1).
 *
 * \sa \ref igraph_centralization_degree() and \ref
 * igraph_centralization().
 */

int igraph_centralization_degree_tmax(const igraph_t *graph,
                                      igraph_integer_t nodes,
                                      igraph_neimode_t mode,
                                      igraph_bool_t loops,
                                      igraph_real_t *res) {

    igraph_bool_t directed = mode != IGRAPH_ALL;
    igraph_real_t real_nodes;

    if (graph) {
        directed = igraph_is_directed(graph);
        nodes = igraph_vcount(graph);
    }

    real_nodes = nodes;    /* implicit cast to igraph_real_t */

    if (directed) {
        switch (mode) {
        case IGRAPH_IN:
        case IGRAPH_OUT:
            if (!loops) {
                *res = (real_nodes - 1) * (real_nodes - 1);
            } else {
                *res = (real_nodes - 1) * real_nodes;
            }
            break;
        case IGRAPH_ALL:
            if (!loops) {
                *res = 2 * (real_nodes - 1) * (real_nodes - 2);
            } else {
                *res = 2 * (real_nodes - 1) * (real_nodes - 1);
            }
            break;
        }
    } else {
        if (!loops) {
            *res = (real_nodes - 1) * (real_nodes - 2);
        } else {
            *res = (real_nodes - 1) * real_nodes;
        }
    }

    return 0;
}

/**
 * \function igraph_centralization_betweenness
 * Calculate vertex betweenness and graph centralization
 *
 * This function calculates the betweenness centrality of the vertices
 * by passing its arguments to \ref igraph_betweenness(); and it
 * calculates the graph level centralization index based on the
 * results by calling \ref igraph_centralization().
 * \param graph The input graph.
 * \param res A vector if you need the node-level betweenness scores, or a
 *     null pointer otherwise.
 * \param directed Boolean, whether to consider directed paths when
 *     calculating betweenness.
 * \param centralization Pointer to a real number, the centralization
 *     score is placed here.
 * \param theoretical_max Pointer to real number or a null pointer. If
 *     not a null pointer, then the theoretical maximum graph
 *     centrality score for a graph with the same number vertices is
 *     stored here.
 * \param normalized Boolean, whether to calculate a normalized
 *     centralization score. See \ref igraph_centralization() for how
 *     the normalization is done.
 * \return Error code.
 *
 * \sa \ref igraph_centralization(), \ref igraph_betweenness().
 *
 * Time complexity: the complexity of \ref igraph_betweenness() plus
 * O(n), the number of vertices queried, for calculating the
 * centralization score.
 */

int igraph_centralization_betweenness(const igraph_t *graph,
                                      igraph_vector_t *res,
                                      igraph_bool_t directed,
                                      igraph_real_t *centralization,
                                      igraph_real_t *theoretical_max,
                                      igraph_bool_t normalized) {

    igraph_vector_t myscores;
    igraph_vector_t *scores = res;
    igraph_real_t *tmax = theoretical_max, mytmax;

    if (!tmax) {
        tmax = &mytmax;
    }

    if (!res) {
        scores = &myscores;
        IGRAPH_VECTOR_INIT_FINALLY(scores, 0);
    }

    IGRAPH_CHECK(igraph_betweenness(graph, scores, igraph_vss_all(), directed, /*weights=*/ 0));

    IGRAPH_CHECK(igraph_centralization_betweenness_tmax(graph, 0, directed, tmax));

    *centralization = igraph_centralization(scores, *tmax, normalized);

    if (!res) {
        igraph_vector_destroy(scores);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_centralization_betweenness_tmax
 * Theoretical maximum for graph centralization based on betweenness
 *
 * This function returns the theoretical maximum graph centrality
 * based on vertex betweenness.
 *
 * 
 * There are two ways to call this function, the first is to supply a
 * graph as the graph argument, and then the number of
 * vertices is taken from this object, and its directedness is
 * considered as well. The nodes argument is ignored in
 * this case. The directed argument is also ignored if the
 * supplied graph is undirected.
 *
 * 
 * The other way is to supply a null pointer as the graph
 * argument. In this case the nodes and directed
 * arguments are considered.
 *
 * 
 * The most centralized structure is the star.
 * \param graph A graph object or a null pointer, see the description
 *     above.
 * \param nodes The number of nodes. This is ignored if the
 *     graph argument is not a null pointer.
 * \param directed Boolean scalar, whether to use directed paths in
 *     the betweenness calculation. This argument is ignored if
 *     graph is not a null pointer and it is undirected.
 * \param res Pointer to a real variable, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(1).
 *
 * \sa \ref igraph_centralization_betweenness() and \ref
 * igraph_centralization().
 */

int igraph_centralization_betweenness_tmax(const igraph_t *graph,
        igraph_integer_t nodes,
        igraph_bool_t directed,
        igraph_real_t *res) {
    igraph_real_t real_nodes;

    if (graph) {
        directed = directed && igraph_is_directed(graph);
        nodes = igraph_vcount(graph);
    }

    real_nodes = nodes;    /* implicit cast to igraph_real_t */

    if (directed) {
        *res = (real_nodes - 1) * (real_nodes - 1) * (real_nodes - 2);
    } else {
        *res = (real_nodes - 1) * (real_nodes - 1) * (real_nodes - 2) / 2.0;
    }

    return 0;
}

/**
 * \function igraph_centralization_closeness
 * Calculate vertex closeness and graph centralization
 *
 * This function calculates the closeness centrality of the vertices
 * by passing its arguments to \ref igraph_closeness(); and it
 * calculates the graph level centralization index based on the
 * results by calling \ref igraph_centralization().
 * \param graph The input graph.
 * \param res A vector if you need the node-level closeness scores, or a
 *     null pointer otherwise.
 * \param mode Constant the specifies the type of closeness for directed
 *     graphs. Possible values: \c IGRAPH_IN, \c IGRAPH_OUT and \c
 *     IGRAPH_ALL. This argument is ignored for undirected graphs. See
 *     \ref igraph_closeness() argument with the same name for more.
 * \param centralization Pointer to a real number, the centralization
 *     score is placed here.
 * \param theoretical_max Pointer to real number or a null pointer. If
 *     not a null pointer, then the theoretical maximum graph
 *     centrality score for a graph with the same number vertices is
 *     stored here.
 * \param normalized Boolean, whether to calculate a normalized
 *     centralization score. See \ref igraph_centralization() for how
 *     the normalization is done.
 * \return Error code.
 *
 * \sa \ref igraph_centralization(), \ref igraph_closeness().
 *
 * Time complexity: the complexity of \ref igraph_closeness() plus
 * O(n), the number of vertices queried, for calculating the
 * centralization score.
 */

int igraph_centralization_closeness(const igraph_t *graph,
                                    igraph_vector_t *res,
                                    igraph_neimode_t mode,
                                    igraph_real_t *centralization,
                                    igraph_real_t *theoretical_max,
                                    igraph_bool_t normalized) {

    igraph_vector_t myscores;
    igraph_vector_t *scores = res;
    igraph_real_t *tmax = theoretical_max, mytmax;

    if (!tmax) {
        tmax = &mytmax;
    }

    if (!res) {
        scores = &myscores;
        IGRAPH_VECTOR_INIT_FINALLY(scores, 0);
    }

    IGRAPH_CHECK(igraph_closeness(graph, scores, NULL, NULL, igraph_vss_all(), mode,
                                  /*weights=*/ 0, /*normalize=*/ 1));

    IGRAPH_CHECK(igraph_centralization_closeness_tmax(graph, 0, mode,
                 tmax));

    *centralization = igraph_centralization(scores, *tmax, normalized);

    if (!res) {
        igraph_vector_destroy(scores);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_centralization_closeness_tmax
 * Theoretical maximum for graph centralization based on closeness
 *
 * This function returns the theoretical maximum graph centrality
 * based on vertex closeness.
 *
 * 
 * There are two ways to call this function, the first is to supply a
 * graph as the graph argument, and then the number of
 * vertices is taken from this object, and its directedness is
 * considered as well. The nodes argument is ignored in
 * this case. The mode argument is also ignored if the
 * supplied graph is undirected.
 *
 * 
 * The other way is to supply a null pointer as the graph
 * argument. In this case the nodes and mode
 * arguments are considered.
 *
 * 
 * The most centralized structure is the star.
 * \param graph A graph object or a null pointer, see the description
 *     above.
 * \param nodes The number of nodes. This is ignored if the
 *     graph argument is not a null pointer.
 * \param mode Constant, specifies what kinf of distances to consider
 *     to calculate closeness. See the mode argument of
 *     \ref igraph_closeness() for details. This argument is ignored
 *     if graph is not a null pointer and it is
 *     undirected.
 * \param res Pointer to a real variable, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(1).
 *
 * \sa \ref igraph_centralization_closeness() and \ref
 * igraph_centralization().
 */

int igraph_centralization_closeness_tmax(const igraph_t *graph,
        igraph_integer_t nodes,
        igraph_neimode_t mode,
        igraph_real_t *res) {
    igraph_real_t real_nodes;

    if (graph) {
        nodes = igraph_vcount(graph);
        if (!igraph_is_directed(graph)) {
            mode = IGRAPH_ALL;
        }
    }

    real_nodes = nodes;    /* implicit cast to igraph_real_t */

    if (mode != IGRAPH_ALL) {
        *res = (real_nodes - 1) * (1.0 - 1.0 / real_nodes);
    } else {
        *res = (real_nodes - 1) * (real_nodes - 2) / (2.0 * real_nodes - 3);
    }

    return 0;
}

/**
 * \function igraph_centralization_eigenvector_centrality
 * Calculate eigenvector centrality scores and graph centralization
 *
 * This function calculates the eigenvector centrality of the vertices
 * by passing its arguments to \ref igraph_eigenvector_centrality);
 * and it calculates the graph level centralization index based on the
 * results by calling \ref igraph_centralization().
 * \param graph The input graph.
 * \param vector A vector if you need the node-level eigenvector
 *      centrality scores, or a null pointer otherwise.
 * \param value If not a null pointer, then the leading eigenvalue is
 *      stored here.
 * \param scale If not zero then the result will be scaled, such that
 *     the absolute value of the maximum centrality is one.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *    for details. Note that the function overwrites the
 *    n (number of vertices) parameter and
 *    it always starts the calculation from a non-random vector
 *    calculated based on the degree of the vertices.
 * \param centralization Pointer to a real number, the centralization
 *     score is placed here.
 * \param theoretical_max Pointer to real number or a null pointer. If
 *     not a null pointer, then the theoretical maximum graph
 *     centrality score for a graph with the same number vertices is
 *     stored here.
 * \param normalized Boolean, whether to calculate a normalized
 *     centralization score. See \ref igraph_centralization() for how
 *     the normalization is done.
 * \return Error code.
 *
 * \sa \ref igraph_centralization(), \ref igraph_eigenvector_centrality().
 *
 * Time complexity: the complexity of \ref
 * igraph_eigenvector_centrality() plus O(|V|), the number of vertices
 * for the calculating the centralization.
 */

int igraph_centralization_eigenvector_centrality(
    const igraph_t *graph,
    igraph_vector_t *vector,
    igraph_real_t *value,
    igraph_bool_t directed,
    igraph_bool_t scale,
    igraph_arpack_options_t *options,
    igraph_real_t *centralization,
    igraph_real_t *theoretical_max,
    igraph_bool_t normalized) {

    igraph_vector_t myscores;
    igraph_vector_t *scores = vector;
    igraph_real_t realvalue, *myvalue = value;
    igraph_real_t *tmax = theoretical_max, mytmax;

    if (!tmax) {
        tmax = &mytmax;
    }

    if (!vector) {
        scores = &myscores;
        IGRAPH_VECTOR_INIT_FINALLY(scores, 0);
    }
    if (!value) {
        myvalue = &realvalue;
    }

    IGRAPH_CHECK(igraph_eigenvector_centrality(graph, scores, myvalue, directed,
                 scale, /*weights=*/ 0,
                 options));

    IGRAPH_CHECK(igraph_centralization_eigenvector_centrality_tmax(
                     graph, 0, directed,
                     scale,
                     tmax));

    *centralization = igraph_centralization(scores, *tmax, normalized);

    if (!vector) {
        igraph_vector_destroy(scores);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_centralization_eigenvector_centrality_tmax
 * Theoretical maximum centralization for eigenvector centrality
 *
 * This function returns the theoretical maximum graph centrality
 * based on vertex eigenvector centrality.
 *
 * 
 * There are two ways to call this function, the first is to supply a
 * graph as the graph argument, and then the number of
 * vertices is taken from this object, and its directedness is
 * considered as well. The nodes argument is ignored in
 * this case. The directed argument is also ignored if the
 * supplied graph is undirected.
 *
 * 
 * The other way is to supply a null pointer as the graph
 * argument. In this case the nodes and directed
 * arguments are considered.
 *
 * 
 * The most centralized directed structure is the in-star. The most
 * centralized undirected structure is the graph with a single edge.
 * \param graph A graph object or a null pointer, see the description
 *     above.
 * \param nodes The number of nodes. This is ignored if the
 *     graph argument is not a null pointer.
 * \param directed Boolean scalar, whether to consider edge
 *     directions. This argument is ignored if
 *     graph is not a null pointer and it is undirected.
 * \param scale Whether to rescale the node-level centrality scores to
 *     have a maximum of one.
 * \param res Pointer to a real variable, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(1).
 *
 * \sa \ref igraph_centralization_closeness() and \ref
 * igraph_centralization().
 */

int igraph_centralization_eigenvector_centrality_tmax(
    const igraph_t *graph,
    igraph_integer_t nodes,
    igraph_bool_t directed,
    igraph_bool_t scale,
    igraph_real_t *res) {

    if (graph) {
        nodes = igraph_vcount(graph);
        directed = directed && igraph_is_directed(graph);
    }

    if (directed) {
        *res = nodes - 1;
    } else {
        if (scale) {
            *res = nodes - 2;
        } else {
            *res = (nodes - 2.0) / M_SQRT2;
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/closeness.c0000644000175100001710000010302400000000000024761 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see .
*/

#include "igraph_centrality.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_dqueue.h"

#include "core/indheap.h"
#include "core/interruption.h"
#include "core/math.h"

/***** Closeness centrality *****/

/**
 * \ingroup structural
 * \function igraph_closeness
 * \brief Closeness centrality calculations for some vertices.
 *
 * The closeness centrality of a vertex measures how easily other
 * vertices can be reached from it (or the other way: how easily it
 * can be reached from the other vertices). It is defined as
 * the inverse of the mean distance to (or from) all other vertices.
 *
 * 
 * Closeness centrality is meaningful only for connected graphs.
 * If the graph is not connected, igraph computes the inverse of the
 * mean distance to (or from) all \em reachable vertices. In undirected
 * graphs, this is equivalent to computing the closeness separately in
 * each connected component. The optional \p all_reachable output
 * parameter is provided to help detect when the graph is disconnected.
 *
 * 
 * While there is no universally adopted definition of closeness centrality
 * for disconnected graphs, there have been some attempts for generalizing
 * the concept to the disconnected case. One type of approach considers the mean distance
 * only to reachable vertices, then re-scales the obtained certrality score
 * by a factor that depends on the number of reachable vertices
 * (i.e. the size of the component in the undirected case).
 * To facilitate computing these generalizations of closeness centrality,
 * the number of reachable vertices (not including the starting vertex)
 * is returned in \p reachable_count.
 *
 * 
 * In disconnected graphs, consider using the harmonic centrality,
 * computable using \ref igraph_harmonic_centrality().
 *
 * 
 * For isolated vertices, i.e. those having no associated paths, NaN is returned.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        closeness centrality scores for the given vertices.
 * \param reachable_count If not \c NULL, this vector will contain the number of
 *        vertices reachable from each vertex for which the closeness is calculated
 *        (not including that vertex).
 * \param all_reachable Pointer to a Boolean. If not \c NULL, it indicates if all
 *        vertices of the graph were reachable from each vertex in \p vids.
 *        If false, the graph is non-connected. If true, and the graph is undirected,
 *        or if the graph is directed and \p vids contains all vertices, then the
 *        graph is connected.
 * \param vids The vertices for which the closeness centrality will be computed.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param weights An optional vector containing edge weights for
 *        weighted closeness. No edge weight may be NaN. Supply a null
 *        pointer here for traditional, unweighted closeness.
 * \param normalized If true, the inverse of the mean distance to reachable
 *        vetices is returned. If false, the inverse of the sum of distances
 *        is returned.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n|E|),
 * n is the number
 * of vertices for which the calculation is done and
 * |E| is the number
 * of edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_betweenness(),
 *   \ref igraph_harmonic_centrality().
 *   See \ref igraph_closeness_cutoff() for the range-limited closeness centrality.
 */
int igraph_closeness(const igraph_t *graph, igraph_vector_t *res,
                     igraph_vector_t *reachable_count, igraph_bool_t *all_reachable,
                     const igraph_vs_t vids, igraph_neimode_t mode,
                     const igraph_vector_t *weights,
                     igraph_bool_t normalized) {
    return igraph_closeness_cutoff(graph, res, reachable_count, all_reachable, vids, mode, weights, normalized, -1);
}

static int igraph_i_closeness_cutoff_weighted(const igraph_t *graph,
                                                igraph_vector_t *res,
                                                igraph_vector_t *reachable_count,
                                                igraph_bool_t *all_reachable,
                                                const igraph_vs_t vids,
                                                igraph_neimode_t mode,
                                                igraph_real_t cutoff,
                                                const igraph_vector_t *weights,
                                                igraph_bool_t normalized) {

    /* See igraph_shortest_paths_dijkstra() for the implementation
       details and the dirty tricks. */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);

    igraph_2wheap_t Q;
    igraph_vit_t vit;
    long int nodes_to_calc;

    igraph_lazy_inclist_t inclist;
    long int i, j;

    igraph_vector_t dist;
    igraph_vector_long_t which;
    long int nodes_reached;

    igraph_real_t mindist = 0;

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid weight vector length.", IGRAPH_EINVAL);
    }

    if (no_of_edges > 0) {
        igraph_real_t minweight = igraph_vector_min(weights);
        if (minweight <= 0) {
            IGRAPH_ERROR("Weight vector must be positive.", IGRAPH_EINVAL);
        } else if (igraph_is_nan(minweight)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    if (reachable_count) {
        igraph_vector_resize(reachable_count, nodes_to_calc);
    }

    if (all_reachable) {
        *all_reachable = 1; /* be optimistic */
    }

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_VECTOR_INIT_FINALLY(&dist, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_long_init(&which, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &which);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {

        long int source = IGRAPH_VIT_GET(vit);
        igraph_2wheap_clear(&Q);
        igraph_2wheap_push_with_index(&Q, source, -1.0);
        VECTOR(which)[source] = i + 1;
        VECTOR(dist)[source] = 1.0;     /* actual distance is zero but we need to store distance + 1 */
        nodes_reached = 0;

        while (!igraph_2wheap_empty(&Q)) {
            igraph_integer_t minnei = (igraph_integer_t) igraph_2wheap_max_index(&Q);
            /* Now check all neighbors of minnei for a shorter path */
            igraph_vector_int_t *neis = igraph_lazy_inclist_get(&inclist, minnei);
            long int nlen = igraph_vector_int_size(neis);

            mindist = -igraph_2wheap_delete_max(&Q);

            if (cutoff >= 0 && (mindist - 1.0) > cutoff) {
                continue;    /* NOT break!!! */
            }

            VECTOR(*res)[i] += (mindist - 1.0);
            nodes_reached++;

            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int to = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_real_t curdist = VECTOR(dist)[to];

                if (VECTOR(which)[to] != i + 1) {
                    /* First non-infinite distance */
                    VECTOR(which)[to] = i + 1;
                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, to, -altdist));
                } else if (curdist == 0 /* this means curdist is infinity */ || altdist < curdist) {
                    /* This is a shorter path */
                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, to, -altdist));
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

        if (reachable_count) {
            VECTOR(*reachable_count)[i] = nodes_reached - 1;
        }

        if (normalized) {
            /* compute the inverse of the average distance, considering only reachable nodes */
            VECTOR(*res)[i] = VECTOR(*res)[i] == 0 ? IGRAPH_NAN : ((igraph_real_t) (nodes_reached-1)) / VECTOR(*res)[i];
        } else {
            /* compute the inverse of the sum of distances */
            VECTOR(*res)[i] = VECTOR(*res)[i] == 0 ? IGRAPH_NAN : 1.0 / VECTOR(*res)[i];
        }

        if (all_reachable) {
            if (nodes_reached < no_of_nodes) {
                *all_reachable = 0 /* false */;
            }
        }
    } /* !IGRAPH_VIT_END(vit) */

    igraph_vector_long_destroy(&which);
    igraph_vector_destroy(&dist);
    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_closeness_estimate
 * \brief Closeness centrality estimations for some vertices.
 *
 * \deprecated-by igraph_closeness_cutoff 0.9
 *
 * 
 * The closeness centrality of a vertex measures how easily other
 * vertices can be reached from it (or the other way: how easily it
 * can be reached from the other vertices). It is defined as
 * the number of vertices minus one divided by the sum of the
 * lengths of all geodesics from/to the given vertex. When estimating
 * closeness centrality, igraph considers paths having a length less than
 * or equal to a prescribed cutoff value.
 *
 * 
 * If the graph is not connected, and there is no such path between two
 * vertices, the number of vertices is used instead the length of the
 * geodesic. This is always longer than the longest possible geodesic.
 *
 * 
 * Since the estimation considers vertex pairs with a distance greater than
 * the given value as disconnected, the resulting estimation will always be
 * lower than the actual closeness centrality.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        closeness centrality scores for the given vertices.
 * \param vids The vertices for which the closeness centrality will be estimated.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact closeness will be calculated (no upper
 *        limit on path lengths).
 * \param weights An optional vector containing edge weights for
 *        weighted closeness. No edge weight may be NaN. Supply a
 *        null pointer here for traditional, unweighted closeness.
 * \param normalized Boolean, whether to normalize results by multiplying
 *        by the number of vertices minus one.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n|E|),
 * n is the number
 * of vertices for which the calculation is done and
 * |E| is the number
 * of edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_degree(), \ref igraph_betweenness().
 */

int igraph_closeness_estimate(const igraph_t *graph, igraph_vector_t *res,
                              const igraph_vs_t vids, igraph_neimode_t mode,
                              igraph_real_t cutoff,
                              const igraph_vector_t *weights,
                              igraph_bool_t normalized) {
    IGRAPH_WARNING("igraph_closeness_estimate is deprecated, use igraph_closeness_cutoff.");
    return igraph_closeness_cutoff(graph, res, NULL, NULL, vids, mode, weights, normalized, cutoff);
}


/**
 * \ingroup structural
 * \function igraph_closeness_cutoff
 * \brief Range limited closeness centrality.
 *
 * This function computes a range-limited version of closeness centrality
 * by considering only those shortest paths whose length is no greater
 * then the given cutoff value.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        range-limited closeness centrality scores for the given vertices.
 * \param reachable_count If not \c NULL, this vector will contain the number of
 *        vertices reachable within the cutoff distance from each vertex for which
 *        the range-limited closeness is calculated (not including that vertex).
 * \param all_reachable Pointer to a Boolean. If not \c NULL, it indicates if all
 *        vertices of the graph were reachable from each vertex in \p vids within
 *        the given cutoff distance.
 * \param vids The vertices for which the range limited closeness centrality
 *             will be computed.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param weights An optional vector containing edge weights for
 *        weighted closeness. No edge weight may be NaN. Supply a null
 *        pointer here for traditional, unweighted closeness.
 * \param normalized If true, the inverse of the mean distance to vertices
 *        reachable within the cutoff is returned. If false, the inverse
 *        of the sum of distances is returned.
 * \param cutoff The maximal length of paths that will be considered.
 *        If negative, the exact closeness will be calculated (no upper
 *        limit on path lengths).
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n|E|),
 * n is the number
 * of vertices for which the calculation is done and
 * |E| is the number
 * of edges in the graph.
 *
 * \sa \ref igraph_closeness() to calculate the exact closeness centrality.
 */

int igraph_closeness_cutoff(const igraph_t *graph, igraph_vector_t *res,
                            igraph_vector_t *reachable_count, igraph_bool_t *all_reachable,
                            const igraph_vs_t vids, igraph_neimode_t mode,
                            const igraph_vector_t *weights,
                            igraph_bool_t normalized,
                            igraph_real_t cutoff) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t already_counted;
    igraph_vector_int_t *neis;
    long int i, j;
    long int nodes_reached;
    igraph_adjlist_t allneis;

    long int actdist = 0;

    igraph_dqueue_t q;

    long int nodes_to_calc;
    igraph_vit_t vit;

    if (weights) {
        return igraph_i_closeness_cutoff_weighted(graph, res, reachable_count, all_reachable, vids, mode, cutoff,
                weights, normalized);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    if (reachable_count) {
        igraph_vector_resize(reachable_count, nodes_to_calc);
    }

    if (all_reachable) {
        *all_reachable = 1; /* be optimistic */
    }

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode for closeness.", IGRAPH_EINVMODE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&already_counted, no_of_nodes);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    for (IGRAPH_VIT_RESET(vit), i = 0;
         !IGRAPH_VIT_END(vit);
         IGRAPH_VIT_NEXT(vit), i++) {
        nodes_reached = 0;

        igraph_dqueue_clear(&q);
        IGRAPH_CHECK(igraph_dqueue_push(&q, IGRAPH_VIT_GET(vit)));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        VECTOR(already_counted)[(long int)IGRAPH_VIT_GET(vit)] = i + 1;

        IGRAPH_PROGRESS("Closeness: ", 100.0 * i / nodes_to_calc, NULL);
        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int act = (long int) igraph_dqueue_pop(&q);
            actdist = (long int) igraph_dqueue_pop(&q);

            if (cutoff >= 0 && actdist > cutoff) {
                continue;    /* NOT break!!! */
            }

            VECTOR(*res)[i] += actdist;
            nodes_reached++;

            /* check the neighbors */
            neis = igraph_adjlist_get(&allneis, act);
            for (j = 0; j < igraph_vector_int_size(neis); j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (VECTOR(already_counted)[neighbor] == i + 1) {
                    continue;
                }
                VECTOR(already_counted)[neighbor] = i + 1;
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        }

        if (reachable_count) {
            VECTOR(*reachable_count)[i] = nodes_reached - 1;
        }

        if (normalized) {
            /* compute the inverse of the average distance, considering only reachable nodes */
            VECTOR(*res)[i] = VECTOR(*res)[i] == 0 ? IGRAPH_NAN : ((igraph_real_t) (nodes_reached-1)) / VECTOR(*res)[i];
        } else {
            /* compute the inverse of the sum of distances */
            VECTOR(*res)[i] = VECTOR(*res)[i] == 0 ? IGRAPH_NAN : 1.0 / VECTOR(*res)[i];
        }

        if (all_reachable) {
            if (nodes_reached < no_of_nodes) {
                *all_reachable = 0 /* false */;
            }
        }
    }

    IGRAPH_PROGRESS("Closeness: ", 100.0, NULL);

    /* Clean */
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&already_counted);
    igraph_vit_destroy(&vit);
    igraph_adjlist_destroy(&allneis);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}


/***** Harmonic centrality *****/

static int igraph_i_harmonic_centrality_unweighted(const igraph_t *graph, igraph_vector_t *res,
                                                   const igraph_vs_t vids, igraph_neimode_t mode,
                                                   igraph_bool_t normalized,
                                                   igraph_real_t cutoff) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t already_counted;
    igraph_vector_int_t *neis;
    long int i, j;
    igraph_adjlist_t allneis;

    long int actdist = 0;

    igraph_dqueue_t q;

    long int nodes_to_calc;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode for harmonic centrality.", IGRAPH_EINVMODE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&already_counted, no_of_nodes);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    for (IGRAPH_VIT_RESET(vit), i = 0;
         !IGRAPH_VIT_END(vit);
         IGRAPH_VIT_NEXT(vit), i++)
    {
        long int source = IGRAPH_VIT_GET(vit);

        igraph_dqueue_clear(&q);
        IGRAPH_CHECK(igraph_dqueue_push(&q, source));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        VECTOR(already_counted)[source] = i + 1;

        IGRAPH_PROGRESS("Harmonic centrality: ", 100.0 * i / nodes_to_calc, NULL);
        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int act = (long int) igraph_dqueue_pop(&q);
            actdist = (long int) igraph_dqueue_pop(&q);

            if (cutoff >= 0 && actdist > cutoff) {
                continue;    /* NOT break!!! */
            }

            /* Exclude self-distance, which is zero. */
            if (source != act) {
                VECTOR(*res)[i] += 1.0/actdist;
            }

            /* check the neighbors */
            neis = igraph_adjlist_get(&allneis, act);
            for (j = 0; j < igraph_vector_int_size(neis); j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (VECTOR(already_counted)[neighbor] == i + 1) {
                    continue;
                }
                VECTOR(already_counted)[neighbor] = i + 1;
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        }
    }

    if (normalized && no_of_nodes > 1 /* not a null graph or singleton graph */) {
        igraph_vector_scale(res, 1.0 / (no_of_nodes - 1));
    }

    IGRAPH_PROGRESS("Harmonic centrality: ", 100.0, NULL);

    /* Clean */
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&already_counted);
    igraph_vit_destroy(&vit);
    igraph_adjlist_destroy(&allneis);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}


static int igraph_i_harmonic_centrality_weighted(const igraph_t *graph,
                                                 igraph_vector_t *res,
                                                 const igraph_vs_t vids,
                                                 igraph_neimode_t mode,
                                                 const igraph_vector_t *weights,
                                                 igraph_bool_t normalized,
                                                 igraph_real_t cutoff) {

    /* See igraph_shortest_paths_dijkstra() for the implementation
       details and the dirty tricks. */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);

    igraph_2wheap_t Q;
    igraph_vit_t vit;
    long int nodes_to_calc;

    igraph_lazy_inclist_t inclist;
    long int i, j;

    igraph_vector_t dist;
    igraph_vector_long_t which;

    igraph_real_t mindist = 0;

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid weight vector length.", IGRAPH_EINVAL);
    }

    if (no_of_edges > 0) {
        igraph_real_t minweight = igraph_vector_min(weights);
        if (minweight <= 0) {
            IGRAPH_ERROR("Weight vector must be positive.", IGRAPH_EINVAL);
        } else if (igraph_is_nan(minweight)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_VECTOR_INIT_FINALLY(&dist, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_long_init(&which, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &which);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {

        long int source = IGRAPH_VIT_GET(vit);
        igraph_2wheap_clear(&Q);
        igraph_2wheap_push_with_index(&Q, source, -1.0);
        VECTOR(which)[source] = i + 1;
        VECTOR(dist)[source] = 1.0;     /* actual distance is zero but we need to store distance + 1 */

        while (!igraph_2wheap_empty(&Q)) {
            igraph_integer_t minnei = (igraph_integer_t) igraph_2wheap_max_index(&Q);
            /* Now check all neighbors of minnei for a shorter path */
            igraph_vector_int_t *neis = igraph_lazy_inclist_get(&inclist, minnei);
            long int nlen = igraph_vector_int_size(neis);

            mindist = -igraph_2wheap_delete_max(&Q);

            if (cutoff >= 0 && (mindist - 1.0) > cutoff) {
                continue;    /* NOT break!!! */
            }

            /* Exclude self-distance, which is zero. */
            if (source != minnei) {
                VECTOR(*res)[i] += 1.0 / (mindist - 1.0);
            }

            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int to = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_real_t curdist = VECTOR(dist)[to];

                if (VECTOR(which)[to] != i + 1) {
                    /* First non-infinite distance */
                    VECTOR(which)[to] = i + 1;
                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, to, -altdist));
                } else if (curdist == 0 /* this means curdist is infinity */ || altdist < curdist) {
                    /* This is a shorter path */
                    VECTOR(dist)[to] = altdist;
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, to, -altdist));
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

    } /* !IGRAPH_VIT_END(vit) */

    if (normalized && no_of_nodes > 1 /* not a null graph or singleton graph */) {
        igraph_vector_scale(res, 1.0 / (no_of_nodes - 1));
    }

    igraph_vector_long_destroy(&which);
    igraph_vector_destroy(&dist);
    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup structural
 * \function igraph_harmonic_centrality_cutoff
 * \brief Range limited harmonic centrality.
 *
 * This function computes the range limited version of harmonic centrality:
 * only those shortest paths are considered whose length is not above the given cutoff.
 * The inverse distance to vertices not reachable within the cutoff is considered
 * to be zero.
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        range limited harmonic centrality scores for the given vertices.
 * \param vids The vertices for which the harmonic centrality will be computed.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param weights An optional vector containing edge weights for
 *        weighted harmonic centrality. No edge weight may be NaN.
 *        If \c NULL, all weights are considered to be one.
 * \param normalized Boolean, whether to normalize the result. If true,
 *        the result is the mean inverse path length to other vertices.
 *        i.e. it is normalized by the number of vertices minus one.
 *        If false, the result is the sum of inverse path lengths to other
 *        vertices.
 * \param cutoff The maximal length of paths that will be considered.
 *        The inverse distance to vertices that are not reachable within
 *        the cutoff path length is considered to be zero.
 *        Supply a negative value to compute the exact harmonic centrality,
 *        without any upper limit on the length of paths.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n|E|), where
 * n is the number of vertices for which the calculation is done and
 * |E| is the number of edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_closeness(), \ref igraph_betweenness().
 */

int igraph_harmonic_centrality_cutoff(const igraph_t *graph, igraph_vector_t *res,
                                      const igraph_vs_t vids, igraph_neimode_t mode,
                                      const igraph_vector_t *weights,
                                      igraph_bool_t normalized,
                                      igraph_real_t cutoff) {
    if (weights) {
        return igraph_i_harmonic_centrality_weighted(graph, res, vids, mode, weights, normalized, cutoff);
    } else {
        return igraph_i_harmonic_centrality_unweighted(graph, res, vids, mode, normalized, cutoff);
    }
}


/**
 * \ingroup structural
 * \function igraph_harmonic_centrality
 * \brief Harmonic centrality for some vertices.
 *
 * The harmonic centrality of a vertex is the mean inverse distance to
 * all other vertices. The inverse distance to an unreachable vertex
 * is considered to be zero.
 *
 * 
 * References:
 *
 * 
 * M. Marchiori and V. Latora, Harmony in the small-world, Physica A 285, pp. 539-546 (2000).
 * https://doi.org/10.1016/S0378-4371%2800%2900311-3
 *
 * 
 * Y. Rochat, Closeness Centrality Extended to Unconnected Graphs: the Harmonic Centrality Index, ASNA 2009.
 * https://infoscience.epfl.ch/record/200525
 *
 * 
 * S. Vigna and P. Boldi, Axioms for Centrality, Internet Mathematics 10, (2014).
 * https://doi.org/10.1080/15427951.2013.865686
 *
 * \param graph The graph object.
 * \param res The result of the computation, a vector containing the
 *        harmonic centrality scores for the given vertices.
 * \param vids The vertices for which the harmonic centrality will be computed.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param weights An optional vector containing edge weights for
 *        weighted harmonic centrality. No edge weight may be NaN.
 *        If \c NULL, all weights are considered to be one.
 * \param normalized Boolean, whether to normalize the result. If true,
 *        the result is the mean inverse path length to other vertices,
 *        i.e. it is normalized by the number of vertices minus one.
 *        If false, the result is the sum of inverse path lengths to other
 *        vertices.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n|E|), where
 * n is the numberof vertices for which the calculation is done and
 * |E| is the number of edges in the graph.
 *
 * \sa Other centrality types: \ref igraph_closeness(), \ref igraph_degree(), \ref igraph_betweenness().
 */

int igraph_harmonic_centrality(const igraph_t *graph, igraph_vector_t *res,
                               const igraph_vs_t vids, igraph_neimode_t mode,
                               const igraph_vector_t *weights,
                               igraph_bool_t normalized) {
    return igraph_harmonic_centrality_cutoff(graph, res, vids, mode, weights, normalized, /* cutoff= */ -1);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/coreness.c0000644000175100001710000001223000000000000024602 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_memory.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"

/**
 * \function igraph_coreness
 * \brief Finding the coreness of the vertices in a network.
 *
 * The k-core of a graph is a maximal subgraph in which each vertex
 * has at least degree k. (Degree here means the degree in the
 * subgraph of course.). The coreness of a vertex is the highest order
 * of a k-core containing the vertex.
 *
 * 
 * This function implements the algorithm presented in Vladimir
 * Batagelj, Matjaz Zaversnik: An O(m) Algorithm for Cores
 * Decomposition of Networks.
 * \param graph The input graph.
 * \param cores Pointer to an initialized vector, the result of the
 *        computation will be stored here. It will be resized as
 *        needed. For each vertex it contains the highest order of a
 *        core containing the vertex.
 * \param mode For directed graph it specifies whether to calculate
 *        in-cores, out-cores or the undirected version. It is ignored
 *        for undirected graphs. Possible values: \c IGRAPH_ALL
 *        undirected version, \c IGRAPH_IN in-cores, \c IGRAPH_OUT
 *        out-cores.
 * \return Error code.
 *
 * Time complexity: O(|E|), the number of edges.
 */

int igraph_coreness(const igraph_t *graph, igraph_vector_t *cores,
                    igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    long int *bin, *vert, *pos;
    long int maxdeg;
    long int i, j = 0;
    igraph_vector_t neis;
    igraph_neimode_t omode;

    if (mode != IGRAPH_ALL && mode != IGRAPH_OUT && mode != IGRAPH_IN) {
        IGRAPH_ERROR("Invalid mode in k-cores", IGRAPH_EINVAL);
    }
    if (!igraph_is_directed(graph) || mode == IGRAPH_ALL) {
        mode = omode = IGRAPH_ALL;
    } else if (mode == IGRAPH_IN) {
        omode = IGRAPH_OUT;
    } else {
        omode = IGRAPH_IN;
    }

    if (no_of_nodes == 0) {
        igraph_vector_clear(cores);
        return IGRAPH_SUCCESS;
    }

    vert = IGRAPH_CALLOC(no_of_nodes, long int);
    if (vert == 0) {
        IGRAPH_ERROR("Cannot calculate k-cores", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, vert);
    pos = IGRAPH_CALLOC(no_of_nodes, long int);
    if (pos == 0) {
        IGRAPH_ERROR("Cannot calculate k-cores", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, pos);

    /* maximum degree + degree of vertices */
    IGRAPH_CHECK(igraph_degree(graph, cores, igraph_vss_all(), mode,
                               IGRAPH_LOOPS));
    maxdeg = (long int) igraph_vector_max(cores);

    bin = IGRAPH_CALLOC(maxdeg + 1, long int);
    if (bin == 0) {
        IGRAPH_ERROR("Cannot calculate k-cores", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, bin);

    /* degree histogram */
    for (i = 0; i < no_of_nodes; i++) {
        bin[ (long int)VECTOR(*cores)[i] ] += 1;
    }

    /* start pointers */
    j = 0;
    for (i = 0; i <= maxdeg; i++) {
        long int k = bin[i];
        bin[i] = j;
        j += k;
    }

    /* sort in vert (and corrupt bin) */
    for (i = 0; i < no_of_nodes; i++) {
        pos[i] = bin[(long int)VECTOR(*cores)[i]];
        vert[pos[i]] = i;
        bin[(long int)VECTOR(*cores)[i]] += 1;
    }

    /* correct bin */
    for (i = maxdeg; i > 0; i--) {
        bin[i] = bin[i - 1];
    }
    bin[0] = 0;

    /* this is the main algorithm */
    IGRAPH_VECTOR_INIT_FINALLY(&neis, maxdeg);
    for (i = 0; i < no_of_nodes; i++) {
        long int v = vert[i];
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v, omode));
        for (j = 0; j < igraph_vector_size(&neis); j++) {
            long int u = (long int) VECTOR(neis)[j];
            if (VECTOR(*cores)[u] > VECTOR(*cores)[v]) {
                long int du = (long int) VECTOR(*cores)[u];
                long int pu = pos[u];
                long int pw = bin[du];
                long int w = vert[pw];
                if (u != w) {
                    pos[u] = pw;
                    pos[w] = pu;
                    vert[pu] = w;
                    vert[pw] = u;
                }
                bin[du] += 1;
                VECTOR(*cores)[u] -= 1;
            }
        }
    }

    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_free(bin);
    igraph_free(pos);
    igraph_free(vert);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4831405
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/0000755000175100001710000000000000000000000024077 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/CMakeLists.txt0000644000175100001710000000207700000000000026645 0ustar00runnerdocker00000000000000# Declare the files needed to compile the PRPACK-related stuff
add_library(
  prpack
  OBJECT
  prpack_base_graph.cpp
  prpack_igraph_graph.cpp
  prpack_preprocessed_ge_graph.cpp
  prpack_preprocessed_gs_graph.cpp
  prpack_preprocessed_scc_graph.cpp
  prpack_preprocessed_schur_graph.cpp
  prpack_result.cpp
  prpack_solver.cpp
  prpack_utils.cpp
)

target_compile_definitions(
  prpack
  PUBLIC
  PRPACK_IGRAPH_SUPPORT=1
)

target_include_directories(
  prpack
  PRIVATE
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET prpack PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Since these are included as object files, they should call the
# function as is (without visibility specification)
target_compile_definitions(prpack PRIVATE IGRAPH_STATIC)

# PRPACK attempts to use OpenMP pragmas, so check whether we need any extra
# compiler flags to support it
if(IGRAPH_OPENMP_SUPPORT)
  target_link_libraries(prpack PRIVATE OpenMP::OpenMP_CXX)
endif()

# Turn on all warnings for GCC, clang and MSVC
use_all_warnings(prpack)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack.h0000644000175100001710000000031200000000000025524 0ustar00runnerdocker00000000000000#ifndef PRPACK
#define PRPACK

#include "prpack_csc.h"
#include "prpack_csr.h"
#include "prpack_edge_list.h"
#include "prpack_base_graph.h"
#include "prpack_solver.h"
#include "prpack_result.h"

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_base_graph.cpp0000644000175100001710000002345400000000000030246 0ustar00runnerdocker00000000000000#include "prpack_base_graph.h"
#include "prpack_utils.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace prpack;
using namespace std;

void prpack_base_graph::initialize() {
    heads = NULL;
    tails = NULL;
    vals = NULL;
}

prpack_base_graph::prpack_base_graph() {
    initialize();
    num_vs = num_es = 0;
}

prpack_base_graph::prpack_base_graph(const prpack_csc* g) {
    initialize();
    num_vs = g->num_vs;
    num_es = g->num_es;
    // fill in heads and tails
    num_self_es = 0;
    int* hs = g->heads;
    int* ts = g->tails;
    tails = new int[num_vs];
    memset(tails, 0, num_vs*sizeof(tails[0]));
    for (int h = 0; h < num_vs; ++h) {
        const int start_ti = hs[h];
        const int end_ti = (h + 1 != num_vs) ? hs[h + 1] : num_es;
        for (int ti = start_ti; ti < end_ti; ++ti) {
            const int t = ts[ti];
            ++tails[t];
            if (h == t)
                ++num_self_es;
        }
    }
    for (int i = 0, sum = 0; i < num_vs; ++i) {
        const int temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }
    heads = new int[num_es];
    int* osets = new int[num_vs];
    memset(osets, 0, num_vs*sizeof(osets[0]));
    for (int h = 0; h < num_vs; ++h) {
        const int start_ti = hs[h];
        const int end_ti = (h + 1 != num_vs) ? hs[h + 1] : num_es;
        for (int ti = start_ti; ti < end_ti; ++ti) {
            const int t = ts[ti];
            heads[tails[t] + osets[t]++] = h;
        }
    }
    // clean up
    delete[] osets;
}

prpack_base_graph::prpack_base_graph(const prpack_int64_csc* g) {
    initialize();
    // TODO remove the assert and add better behavior
    assert(num_vs <= std::numeric_limits::max());
    num_vs = (int)g->num_vs;
    num_es = (int)g->num_es;
    // fill in heads and tails
    num_self_es = 0;
    int64_t* hs = g->heads;
    int64_t* ts = g->tails;
    tails = new int[num_vs];
    memset(tails, 0, num_vs*sizeof(tails[0]));
    for (int h = 0; h < num_vs; ++h) {
        const int start_ti = (int)hs[h];
        const int end_ti = (h + 1 != num_vs) ? (int)hs[h + 1] : num_es;
        for (int ti = start_ti; ti < end_ti; ++ti) {
            const int t = (int)ts[ti];
            ++tails[t];
            if (h == t)
                ++num_self_es;
        }
    }
    for (int i = 0, sum = 0; i < num_vs; ++i) {
        const int temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }
    heads = new int[num_es];
    int* osets = new int[num_vs];
    memset(osets, 0, num_vs*sizeof(osets[0]));
    for (int h = 0; h < num_vs; ++h) {
        const int start_ti = (int)hs[h];
        const int end_ti = (h + 1 != num_vs) ? (int)hs[h + 1] : num_es;
        for (int ti = start_ti; ti < end_ti; ++ti) {
            const int t = (int)ts[ti];
            heads[tails[t] + osets[t]++] = h;
        }
    }
    // clean up
    delete[] osets;
}

prpack_base_graph::prpack_base_graph(const prpack_csr* g) {
    (void)g; // to silence an unused argument warning
    initialize();
    throw std::runtime_error("not implemented yet");
}

prpack_base_graph::prpack_base_graph(const prpack_edge_list* g) {
    initialize();
    num_vs = g->num_vs;
    num_es = g->num_es;
    // fill in heads and tails
    num_self_es = 0;
    int* hs = g->heads;
    int* ts = g->tails;
    tails = new int[num_vs];
    memset(tails, 0, num_vs*sizeof(tails[0]));
    for (int i = 0; i < num_es; ++i) {
        ++tails[ts[i]];
        if (hs[i] == ts[i])
            ++num_self_es;
    }
    for (int i = 0, sum = 0; i < num_vs; ++i) {
        const int temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }
    heads = new int[num_es];
    int* osets = new int[num_vs];
    memset(osets, 0, num_vs*sizeof(osets[0]));
    for (int i = 0; i < num_es; ++i)
        heads[tails[ts[i]] + osets[ts[i]]++] = hs[i];
    // clean up
    delete[] osets;
}

prpack_base_graph::prpack_base_graph(const char* filename, const char* format, const bool weighted) {
    initialize();
    FILE* f = fopen(filename, "r");
    const string s(filename);
    const string t(format);
    const string ext = (t == "") ? s.substr(s.rfind('.') + 1) : t;
    if (ext == "smat") {
        read_smat(f, weighted);
    } else {
        prpack_utils::validate(!weighted,
            "Error: graph format is not compatible with weighted option.");
        if (ext == "edges" || ext == "eg2") {
            read_edges(f);
        } else if (ext == "graph-txt") {
            read_ascii(f);
        } else {
            prpack_utils::validate(false, "Error: invalid graph format.");
        }
    }
    fclose(f);
}

prpack_base_graph::~prpack_base_graph() {
    delete[] heads;
    delete[] tails;
    delete[] vals;
}

void prpack_base_graph::read_smat(FILE* f, const bool weighted) {
    // read in header
    double ignore = 0.0;
    int retval = fscanf(f, "%d %lf %d", &num_vs, &ignore, &num_es);
    if (retval != 3) {
        throw std::runtime_error("error while parsing smat file");
    }
    // fill in heads and tails
    num_self_es = 0;
    int* hs = new int[num_es];
    int* ts = new int[num_es];
    heads = new int[num_es];
    tails = new int[num_vs];
    double* vs = NULL;
    if (weighted) {
        vs = new double[num_es];
        vals = new double[num_es];
    }
    memset(tails, 0, num_vs*sizeof(tails[0]));
    for (int i = 0; i < num_es; ++i) {
        retval = fscanf(f, "%d %d %lf", &hs[i], &ts[i], &((weighted) ? vs[i] : ignore));
        if (retval != 3) {
            throw std::runtime_error("error while parsing smat file");
        }
        ++tails[ts[i]];
        if (hs[i] == ts[i])
            ++num_self_es;
    }
    for (int i = 0, sum = 0; i < num_vs; ++i) {
        const int temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }
    int* osets = new int[num_vs];
    memset(osets, 0, num_vs*sizeof(osets[0]));
    for (int i = 0; i < num_es; ++i) {
        const int idx = tails[ts[i]] + osets[ts[i]]++;
        heads[idx] = hs[i];
        if (weighted)
            vals[idx] = vs[i];
    }
    // clean up
    delete[] hs;
    delete[] ts;
    delete[] vs;
    delete[] osets;
}

void prpack_base_graph::read_edges(FILE* f) {
    vector > al;
    int h, t;
    num_es = num_self_es = 0;
    while (fscanf(f, "%d %d", &h, &t) == 2) {
        const int m = (h < t) ? t : h;
        if ((int) al.size() < m + 1)
            al.resize(m + 1);
        al[t].push_back(h);
        ++num_es;
        if (h == t)
            ++num_self_es;
    }
    num_vs = al.size();
    heads = new int[num_es];
    tails = new int[num_vs];
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        tails[tails_i] = heads_i;
        for (int j = 0; j < (int) al[tails_i].size(); ++j)
            heads[heads_i++] = al[tails_i][j];
    }
}

void prpack_base_graph::read_ascii(FILE* f) {
    int retval = fscanf(f, "%d", &num_vs);
    if (retval != 1) {
        throw std::runtime_error("error while parsing ascii file");
    }
    while (getc(f) != '\n');
    vector* al = new vector[num_vs];
    num_es = num_self_es = 0;
    char s[32];
    for (int h = 0; h < num_vs; ++h) {
        bool line_ended = false;
        while (!line_ended) {
            for (int i = 0; ; ++i) {
                s[i] = getc(f);
                if ('9' < s[i] || s[i] < '0') {
                    line_ended = s[i] == '\n';
                    if (i != 0) {
                        s[i] = '\0';
                        const int t = atoi(s);
                        al[t].push_back(h);
                        ++num_es;
                        if (h == t)
                            ++num_self_es;
                    }
                    break;
                }
            }
        }
    }
    heads = new int[num_es];
    tails = new int[num_vs];
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        tails[tails_i] = heads_i;
        for (int j = 0; j < (int) al[tails_i].size(); ++j)
            heads[heads_i++] = al[tails_i][j];
    }
    delete[] al;
}

prpack_base_graph::prpack_base_graph(int nverts, int nedges,
        std::pair* edges) {
    initialize();
    num_vs = nverts;
    num_es = nedges;

    // fill in heads and tails
    num_self_es = 0;
    int* hs = new int[num_es];
    int* ts = new int[num_es];
    tails = new int[num_vs];
    memset(tails, 0, num_vs*sizeof(tails[0]));
    for (int i = 0; i < num_es; ++i) {
        assert(edges[i].first >= 0 && edges[i].first < num_vs);
        assert(edges[i].second >= 0 && edges[i].second < num_vs);
        hs[i] = edges[i].first;
        ts[i] = edges[i].second;
        ++tails[ts[i]];
        if (hs[i] == ts[i])
            ++num_self_es;
    }
    for (int i = 0, sum = 0; i < num_vs; ++i) {
        int temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }
    heads = new int[num_es];
    int* osets = new int[num_vs];
    memset(osets, 0, num_vs*sizeof(osets[0]));
    for (int i = 0; i < num_es; ++i)
        heads[tails[ts[i]] + osets[ts[i]]++] = hs[i];
    // clean up
    delete[] hs;
    delete[] ts;
    delete[] osets;
}

/** Normalize the edge weights to sum to one.
 */
void prpack_base_graph::normalize_weights() {
    if (!vals) {
        // skip normalizing weights if not using values
        return;
    }
    std::vector rowsums(num_vs,0.);
    // the graph is in a compressed in-edge list.
    for (int i=0; i
#include 

namespace prpack {

    class prpack_base_graph {
        private:
            // helper methods
            void initialize();
            void read_smat(std::FILE* f, const bool weighted);
            void read_edges(std::FILE* f);
            void read_ascii(std::FILE* f);
        public:
            // instance variables
            int num_vs;
            int num_es;
            int num_self_es;
            int* heads;
            int* tails;
            double* vals;
            // constructors
            prpack_base_graph();    // only to support inheritance
            prpack_base_graph(const prpack_csc* g);
            prpack_base_graph(const prpack_int64_csc* g);
            prpack_base_graph(const prpack_csr* g);
            prpack_base_graph(const prpack_edge_list* g);
            prpack_base_graph(const char* filename, const char* format, const bool weighted);
            prpack_base_graph(int nverts, int nedges, std::pair* edges);
            // destructor
            ~prpack_base_graph();
            // operations
            void normalize_weights();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_csc.h0000644000175100001710000000102500000000000026356 0ustar00runnerdocker00000000000000#ifndef PRPACK_CSC
#define PRPACK_CSC

#if !defined(_MSC_VER) && !defined (__MINGW32__) && !defined (__MINGW64__)
#  include 
#else
#  include 
typedef __int64 int64_t;
#endif

namespace prpack {

    class prpack_csc {
        public:
            int num_vs;
            int num_es;
            int* heads;
            int* tails;
    };

    class prpack_int64_csc {
        public:
            int64_t num_vs;
            int64_t num_es;
            int64_t* heads;
            int64_t* tails;
    };
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_csr.h0000644000175100001710000000032400000000000026376 0ustar00runnerdocker00000000000000#ifndef PRPACK_CSR
#define PRPACK_CSR

namespace prpack {

    class prpack_csr {
        public:
            int num_vs;
            int num_es;
            int* heads;
            int* tails;
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_edge_list.h0000644000175100001710000000034600000000000027552 0ustar00runnerdocker00000000000000#ifndef PRPACK_EDGE_LIST
#define PRPACK_EDGE_LIST

namespace prpack {

    class prpack_edge_list {
        public:
            int num_vs;
            int num_es;
            int* heads;
            int* tails;
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_igraph_graph.cpp0000644000175100001710000000770300000000000030605 0ustar00runnerdocker00000000000000#include "prpack_igraph_graph.h"
#include 
#include 

#include "igraph_interface.h"

using namespace prpack;
using namespace std;

#ifdef PRPACK_IGRAPH_SUPPORT

prpack_igraph_graph::prpack_igraph_graph(const igraph_t* g, const igraph_vector_t* weights,
        bool directed) {
    const igraph_bool_t treat_as_directed = igraph_is_directed(g) && directed;
    igraph_es_t es;
    igraph_eit_t eit;
    igraph_vector_t neis;
    long int i, j, eid, sum, temp, num_ignored_es;
    int *p_head, *p_head_copy;
    double* p_weight = 0;

    // Get the number of vertices and edges. For undirected graphs, we add
    // an edge in both directions.
    num_vs = igraph_vcount(g);
    num_es = igraph_ecount(g);
    num_self_es = 0;
    if (!treat_as_directed) {
        num_es *= 2;
    }

    // Allocate memory for heads and tails
    p_head = heads = new int[num_es];
    tails = new int[num_vs];
    memset(tails, 0, num_vs * sizeof(tails[0]));

    // Allocate memory for weights if needed
    if (weights != 0) {
        p_weight = vals = new double[num_es];
    }

    // Count the number of ignored edges (those with negative or zero weight)
    num_ignored_es = 0;

    if (treat_as_directed) {
        // Select all the edges and iterate over them by the source vertices
        es = igraph_ess_all(IGRAPH_EDGEORDER_TO);

        // Add the edges
        igraph_eit_create(g, es, &eit);
        while (!IGRAPH_EIT_END(eit)) {
            eid = IGRAPH_EIT_GET(eit);
            IGRAPH_EIT_NEXT(eit);

            // Handle the weight
            if (weights != 0) {
                // Does this edge have zero or negative weight?
                if (VECTOR(*weights)[eid] <= 0) {
                    // Ignore it.
                    num_ignored_es++;
                    continue;
                }

                *p_weight = VECTOR(*weights)[eid];
                ++p_weight;
            }

            *p_head = IGRAPH_FROM(g, eid);
            ++p_head;
            ++tails[IGRAPH_TO(g, eid)];

            if (IGRAPH_FROM(g, eid) == IGRAPH_TO(g, eid)) {
                ++num_self_es;
            }
        }
        igraph_eit_destroy(&eit);
    } else {
        // Select all the edges and iterate over them by the target vertices
        igraph_vector_init(&neis, 0);

        for (i = 0; i < num_vs; i++) {
            igraph_incident(g, &neis, i, IGRAPH_ALL);
            temp = igraph_vector_size(&neis);

            // TODO: should loop edges be added in both directions?
            p_head_copy = p_head;
            for (j = 0; j < temp; j++) {
                if (weights != 0) {
                    if (VECTOR(*weights)[(long int)VECTOR(neis)[j]] <= 0) {
                        // Ignore
                        num_ignored_es++;
                        continue;
                    }

                    *p_weight = VECTOR(*weights)[(long int)VECTOR(neis)[j]];
                    ++p_weight;
                }

                *p_head = IGRAPH_OTHER(g, VECTOR(neis)[j], i);
                if (i == *p_head) {
                    num_self_es++;
                }
                ++p_head;
            }
            tails[i] = p_head - p_head_copy;
        }

        igraph_vector_destroy(&neis);
    }

    // Decrease num_es by the number of ignored edges
    num_es -= num_ignored_es;

    // Finalize the tails vector
    for (i = 0, sum = 0; i < num_vs; ++i) {
        temp = sum;
        sum += tails[i];
        tails[i] = temp;
    }

    // Normalize the weights
    normalize_weights();

    // Debug
    /*
    printf("Heads:");
    for (i = 0; i < num_es; ++i) {
        printf(" %d", heads[i]);
    }
    printf("\n");
    printf("Tails:");
    for (i = 0; i < num_vs; ++i) {
        printf(" %d", tails[i]);
    }
    printf("\n");
    if (vals) {
        printf("Vals:");
        for (i = 0; i < num_es; ++i) {
            printf(" %.4f", vals[i]);
        }
        printf("\n");
    }
    printf("===========================\n");
    */
}

// PRPACK_IGRAPH_SUPPORT
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_igraph_graph.h0000644000175100001710000000076600000000000030254 0ustar00runnerdocker00000000000000#ifndef PRPACK_IGRAPH_GRAPH
#define PRPACK_IGRAPH_GRAPH

#ifdef PRPACK_IGRAPH_SUPPORT

#include "prpack_base_graph.h"

struct igraph_s;
struct igraph_vector_t;

namespace prpack {

    class prpack_igraph_graph : public prpack_base_graph {

        public:
            // constructors
            explicit prpack_igraph_graph(const struct igraph_s* g,
					const struct igraph_vector_t* weights = 0,
					bool directed = true);
    };

}

// PRPACK_IGRAPH_SUPPORT
#endif

// PRPACK_IGRAPH_GRAPH
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_ge_graph.cpp0000644000175100001710000000402600000000000032477 0ustar00runnerdocker00000000000000#include "prpack_preprocessed_ge_graph.h"
#include 
using namespace prpack;
using namespace std;

void prpack_preprocessed_ge_graph::initialize() {
    matrix = NULL;
    d = NULL;
}

void prpack_preprocessed_ge_graph::initialize_weighted(const prpack_base_graph* bg) {
    // initialize d
    fill(d, d + num_vs, 1);
    // fill in the matrix
    for (int i = 0, inum_vs = 0; i < num_vs; ++i, inum_vs += num_vs) {
        const int start_j = bg->tails[i];
        const int end_j = (i + 1 != num_vs) ? bg->tails[i + 1] : bg->num_es;
        for (int j = start_j; j < end_j; ++j) {
            matrix[inum_vs + bg->heads[j]] += bg->vals[j];
            d[bg->heads[j]] -= bg->vals[j];
        }
    }
}

void prpack_preprocessed_ge_graph::initialize_unweighted(const prpack_base_graph* bg) {
    // fill in the matrix
    for (int i = 0, inum_vs = 0; i < num_vs; ++i, inum_vs += num_vs) {
        const int start_j = bg->tails[i];
        const int end_j = (i + 1 != num_vs) ? bg->tails[i + 1] : bg->num_es;
        for (int j = start_j; j < end_j; ++j)
            ++matrix[inum_vs + bg->heads[j]];
    }
    // normalize the columns
    for (int j = 0; j < num_vs; ++j) {
        double sum = 0;
        for (int inum_vs = 0; inum_vs < num_vs*num_vs; inum_vs += num_vs)
            sum += matrix[inum_vs + j];
        if (sum > 0) {
            d[j] = 0;
            const double coeff = 1/sum;
            for (int inum_vs = 0; inum_vs < num_vs*num_vs; inum_vs += num_vs)
                matrix[inum_vs + j] *= coeff;
        } else {
            d[j] = 1;
        }
    }
}

prpack_preprocessed_ge_graph::prpack_preprocessed_ge_graph(const prpack_base_graph* bg) {
    initialize();
    num_vs = bg->num_vs;
    num_es = bg->num_es;
    matrix = new double[num_vs*num_vs];
    d = new double[num_vs];
    fill(matrix, matrix + num_vs*num_vs, 0);
    if (bg->vals != NULL)
        initialize_weighted(bg);
    else
        initialize_unweighted(bg);
}

prpack_preprocessed_ge_graph::~prpack_preprocessed_ge_graph() {
    delete[] matrix;
    delete[] d;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_ge_graph.h0000644000175100001710000000136200000000000032144 0ustar00runnerdocker00000000000000#ifndef PRPACK_PREPROCESSED_GE_GRAPH
#define PRPACK_PREPROCESSED_GE_GRAPH
#include "prpack_preprocessed_graph.h"
#include "prpack_base_graph.h"

namespace prpack {

    // Pre-processed graph class
    class prpack_preprocessed_ge_graph : public prpack_preprocessed_graph {
        private:
            // helper methods
            void initialize();
            void initialize_weighted(const prpack_base_graph* bg);
            void initialize_unweighted(const prpack_base_graph* bg);
        public:
            // instance variables
            double* matrix;
            // constructors
            prpack_preprocessed_ge_graph(const prpack_base_graph* bg);
            // destructor
            ~prpack_preprocessed_ge_graph();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_graph.h0000644000175100001710000000051500000000000031470 0ustar00runnerdocker00000000000000#ifndef PRPACK_PREPROCESSED_GRAPH
#define PRPACK_PREPROCESSED_GRAPH

namespace prpack {

    // TODO: this class should not be seeable by the users of the library.
    // Super graph class.
    class prpack_preprocessed_graph {
        public:
            int num_vs;
            int num_es;
            double* d;
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_gs_graph.cpp0000644000175100001710000000461500000000000032521 0ustar00runnerdocker00000000000000#include "prpack_preprocessed_gs_graph.h"
#include 
using namespace prpack;
using namespace std;

void prpack_preprocessed_gs_graph::initialize() {
    heads = NULL;
    tails = NULL;
    vals = NULL;
    ii = NULL;
    d = NULL;
    num_outlinks = NULL;
}

void prpack_preprocessed_gs_graph::initialize_weighted(const prpack_base_graph* bg) {
    vals = new double[num_es];
    d = new double[num_vs];
    fill(d, d + num_vs, 1);
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        tails[tails_i] = heads_i;
        ii[tails_i] = 0;
        const int start_j = bg->tails[tails_i];
        const int end_j = (tails_i + 1 != num_vs) ? bg->tails[tails_i + 1]: bg->num_es;
        for (int j = start_j; j < end_j; ++j) {
            if (tails_i == bg->heads[j])
                ii[tails_i] += bg->vals[j];
            else {
                heads[heads_i] = bg->heads[j];
                vals[heads_i] = bg->vals[j];
                ++heads_i;
            }
            d[bg->heads[j]] -= bg->vals[j];
        }
    }
}

void prpack_preprocessed_gs_graph::initialize_unweighted(const prpack_base_graph* bg) {
    num_outlinks = new double[num_vs];
    fill(num_outlinks, num_outlinks + num_vs, 0);
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        tails[tails_i] = heads_i;
        ii[tails_i] = 0;
        const int start_j = bg->tails[tails_i];
        const int end_j = (tails_i + 1 != num_vs) ? bg->tails[tails_i + 1]: bg->num_es;
        for (int j = start_j; j < end_j; ++j) {
            if (tails_i == bg->heads[j])
                ++ii[tails_i];
            else
                heads[heads_i++] = bg->heads[j];
            ++num_outlinks[bg->heads[j]];
        }
    }
    for (int i = 0; i < num_vs; ++i) {
        if (num_outlinks[i] == 0)
            num_outlinks[i] = -1;
        ii[i] /= num_outlinks[i];
    }
}

prpack_preprocessed_gs_graph::prpack_preprocessed_gs_graph(const prpack_base_graph* bg) {
    initialize();
    num_vs = bg->num_vs;
    num_es = bg->num_es - bg->num_self_es;
    heads = new int[num_es];
    tails = new int[num_vs];
    ii = new double[num_vs];
    if (bg->vals != NULL)
        initialize_weighted(bg);
    else
        initialize_unweighted(bg);
}

prpack_preprocessed_gs_graph::~prpack_preprocessed_gs_graph() {
    delete[] heads;
    delete[] tails;
    delete[] vals;
    delete[] ii;
    delete[] d;
    delete[] num_outlinks;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_gs_graph.h0000644000175100001710000000153200000000000032161 0ustar00runnerdocker00000000000000#ifndef PRPACK_PREPROCESSED_GS_GRAPH
#define PRPACK_PREPROCESSED_GS_GRAPH
#include "prpack_preprocessed_graph.h"
#include "prpack_base_graph.h"

namespace prpack {

    // Pre-processed graph class
    class prpack_preprocessed_gs_graph : public prpack_preprocessed_graph {
        private:
            // helper methods
            void initialize();
            void initialize_weighted(const prpack_base_graph* bg);
            void initialize_unweighted(const prpack_base_graph* bg);
        public:
            // instance variables
            int* heads;
            int* tails;
            double* vals;
            double* ii;
            double* num_outlinks;
            // constructors
            prpack_preprocessed_gs_graph(const prpack_base_graph* bg);
            // destructor
            ~prpack_preprocessed_gs_graph();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_scc_graph.cpp0000644000175100001710000001600000000000000032647 0ustar00runnerdocker00000000000000#include "prpack_preprocessed_scc_graph.h"
#include 
#include 
#include 
using namespace prpack;
using namespace std;

void prpack_preprocessed_scc_graph::initialize() {
    heads_inside = NULL;
    tails_inside = NULL;
    vals_inside = NULL;
    heads_outside = NULL;
    tails_outside = NULL;
    vals_outside = NULL;
    ii = NULL;
    d = NULL;
    num_outlinks = NULL;
    divisions = NULL;
    encoding = NULL;
    decoding = NULL;
}

void prpack_preprocessed_scc_graph::initialize_weighted(const prpack_base_graph* bg) {
    vals_inside = new double[num_es];
    vals_outside = new double[num_es];
    d = new double[num_vs];
    fill(d, d + num_vs, 1);
    for (int comp_i = 0; comp_i < num_comps; ++comp_i) {
        const int start_i = divisions[comp_i];
        const int end_i = (comp_i + 1 != num_comps) ? divisions[comp_i + 1] : num_vs;
        for (int i = start_i; i < end_i; ++i) {
            ii[i] = 0;
            const int decoded = decoding[i];
            const int start_j = bg->tails[decoded];
            const int end_j = (decoded + 1 != num_vs) ? bg->tails[decoded + 1] : bg->num_es;
            tails_inside[i] = num_es_inside;
            tails_outside[i] = num_es_outside;
            for (int j = start_j; j < end_j; ++j) {
                const int h = encoding[bg->heads[j]];
                if (h == i) {
                    ii[i] += bg->vals[j];
                } else {
                    if (start_i <= h && h < end_i) {
                        heads_inside[num_es_inside] = h;
                        vals_inside[num_es_inside] = bg->vals[j];
                        ++num_es_inside;
                    } else {
                        heads_outside[num_es_outside] = h;
                        vals_outside[num_es_outside] = bg->vals[j];
                        ++num_es_outside;
                    }
                }
                d[h] -= bg->vals[j];
            }
        }
    }
}

void prpack_preprocessed_scc_graph::initialize_unweighted(const prpack_base_graph* bg) {
    num_outlinks = new double[num_vs];
    fill(num_outlinks, num_outlinks + num_vs, 0);
    for (int comp_i = 0; comp_i < num_comps; ++comp_i) {
        const int start_i = divisions[comp_i];
        const int end_i = (comp_i + 1 != num_comps) ? divisions[comp_i + 1] : num_vs;
        for (int i = start_i; i < end_i; ++i) {
            ii[i] = 0;
            const int decoded = decoding[i];
            const int start_j = bg->tails[decoded];
            const int end_j = (decoded + 1 != num_vs) ? bg->tails[decoded + 1] : bg->num_es;
            tails_inside[i] = num_es_inside;
            tails_outside[i] = num_es_outside;
            for (int j = start_j; j < end_j; ++j) {
                const int h = encoding[bg->heads[j]];
                if (h == i) {
                    ++ii[i];
                } else {
                    if (start_i <= h && h < end_i)
                        heads_inside[num_es_inside++] = h;
                    else
                        heads_outside[num_es_outside++] = h;
                }
                ++num_outlinks[h];
            }
        }
    }
    for (int i = 0; i < num_vs; ++i) {
        if (num_outlinks[i] == 0)
            num_outlinks[i] = -1;
        ii[i] /= num_outlinks[i];
    }
}

prpack_preprocessed_scc_graph::prpack_preprocessed_scc_graph(const prpack_base_graph* bg) {
    initialize();
    // initialize instance variables
    num_vs = bg->num_vs;
    num_es = bg->num_es - bg->num_self_es;
    // initialize Tarjan's algorithm variables
    num_comps = 0;
    int mn = 0;                 // the number of vertices seen so far
    int sz = 0;                 // size of st
    int decoding_i = 0;         // size of decoding currently filled in
    decoding = new int[num_vs];
    int* scc = new int[num_vs]; // the strongly connected component this vertex is in
    int* low = new int[num_vs]; // the lowest index this vertex can reach
    int* num = new int[num_vs]; // the index of this vertex in the dfs traversal
    int* st = new int[num_vs];  // a stack for the dfs
    memset(num, -1, num_vs*sizeof(num[0]));
    memset(scc, -1, num_vs*sizeof(scc[0]));
    int* cs1 = new int[num_vs]; // call stack variable for dfs
    int* cs2 = new int[num_vs]; // call stack variable for dfs
    // run iterative Tarjan's algorithm
    for (int root = 0; root < num_vs; ++root) {
        if (num[root] != -1)
            continue;
        int csz = 1;
        cs1[0] = root;
        cs2[0] = bg->tails[root];
        // dfs
        while (csz) {
            const int p = cs1[csz - 1]; // node we're dfs-ing on
            int& it = cs2[csz - 1]; // iteration of the for loop
            if (it == bg->tails[p]) {
                low[p] = num[p] = mn++;
                st[sz++] = p;
            } else {
                low[p] = min(low[p], low[bg->heads[it - 1]]);
            }
            bool done = false;
            int end_it = (p + 1 != num_vs) ? bg->tails[p + 1] : bg->num_es;
            for (; it < end_it; ++it) {
                int h = bg->heads[it];
                if (scc[h] == -1) {
                    if (num[h] == -1) {
                        // dfs(h, p);
                        cs1[csz] = h;
                        cs2[csz++] = bg->tails[h];
                        ++it;
                        done = true;
                        break;
                    }
                    low[p] = min(low[p], low[h]);
                }
            }
            if (done)
                continue;
            // if p is the first explored vertex of a scc
            if (low[p] == num[p]) {
                cs1[num_vs - 1 - num_comps] = decoding_i;
                while (scc[p] != num_comps) {
                    scc[st[--sz]] = num_comps;
                    decoding[decoding_i++] = st[sz];
                }
                ++num_comps;
            }
            --csz;
        }
    }
    // set up other instance variables
    divisions = new int[num_comps];
    divisions[0] = 0;
    for (int i = 1; i < num_comps; ++i)
        divisions[i] = cs1[num_vs - 1 - i];
    encoding = num;
    for (int i = 0; i < num_vs; ++i)
        encoding[decoding[i]] = i;
    // fill in inside and outside instance variables
    ii = new double[num_vs];
    tails_inside = cs1;
    heads_inside = new int[num_es];
    tails_outside = cs2;
    heads_outside = new int[num_es];
    num_es_inside = num_es_outside = 0;
    // continue initialization based off of weightedness
    if (bg->vals != NULL)
        initialize_weighted(bg);
    else
        initialize_unweighted(bg);
    // free memory
    // do not free num <==> encoding
    // do not free cs1 <==> tails_inside
    // do not free cs2 <==> tails_outside
    delete[] scc;
    delete[] low;
    delete[] st;
}

prpack_preprocessed_scc_graph::~prpack_preprocessed_scc_graph() {
    delete[] heads_inside;
    delete[] tails_inside;
    delete[] vals_inside;
    delete[] heads_outside;
    delete[] tails_outside;
    delete[] vals_outside;
    delete[] ii;
    delete[] d;
    delete[] num_outlinks;
    delete[] divisions;
    delete[] encoding;
    delete[] decoding;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_scc_graph.h0000644000175100001710000000220200000000000032313 0ustar00runnerdocker00000000000000#ifndef PRPACK_PREPROCESSED_SCC_GRAPH
#define PRPACK_PREPROCESSED_SCC_GRAPH
#include "prpack_preprocessed_graph.h"
#include "prpack_base_graph.h"

namespace prpack {

    // Pre-processed graph class
    class prpack_preprocessed_scc_graph : public prpack_preprocessed_graph {
        private:
            // helper methods
            void initialize();
            void initialize_weighted(const prpack_base_graph* bg);
            void initialize_unweighted(const prpack_base_graph* bg);
        public:
            // instance variables
            int num_es_inside;
            int* heads_inside;
            int* tails_inside;
            double* vals_inside;
            int num_es_outside;
            int* heads_outside;
            int* tails_outside;
            double* vals_outside;
            double* ii;
            double* num_outlinks;
            int num_comps;
            int* divisions;
            int* encoding;
            int* decoding;
            // constructors
            prpack_preprocessed_scc_graph(const prpack_base_graph* bg);
            // destructor
            ~prpack_preprocessed_scc_graph();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_schur_graph.cpp0000644000175100001710000001001400000000000033222 0ustar00runnerdocker00000000000000#include "prpack_preprocessed_schur_graph.h"
#include 
#include 
using namespace prpack;
using namespace std;

void prpack_preprocessed_schur_graph::initialize() {
    heads = NULL;
    tails = NULL;
    vals = NULL;
    ii = NULL;
    d = NULL;
    num_outlinks = NULL;
    encoding = NULL;
    decoding = NULL;
}

void prpack_preprocessed_schur_graph::initialize_weighted(const prpack_base_graph* bg) {
    // permute d
    ii = d;
    d = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        d[encoding[i]] = ii[i];
    // convert bg to head/tail format
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        ii[tails_i] = 0;
        tails[tails_i] = heads_i;
        const int decoded = decoding[tails_i];
        const int start_i = bg->tails[decoded];
        const int end_i = (decoded + 1 != num_vs) ? bg->tails[decoded + 1] : bg->num_es;
        for (int i = start_i; i < end_i; ++i) {
            if (decoded == bg->heads[i])
                ii[tails_i] += bg->vals[i];
            else {
                heads[heads_i] = encoding[bg->heads[i]];
                vals[heads_i] = bg->vals[i];
                ++heads_i;
            }
        }
    }
}

void prpack_preprocessed_schur_graph::initialize_unweighted(const prpack_base_graph* bg) {
    // permute num_outlinks
    ii = num_outlinks;
    num_outlinks = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        num_outlinks[encoding[i]] = (ii[i] == 0) ? -1 : ii[i];
    // convert bg to head/tail format
    for (int tails_i = 0, heads_i = 0; tails_i < num_vs; ++tails_i) {
        ii[tails_i] = 0;
        tails[tails_i] = heads_i;
        const int decoded = decoding[tails_i];
        const int start_i = bg->tails[decoded];
        const int end_i = (decoded + 1 != num_vs) ? bg->tails[decoded + 1] : bg->num_es;
        for (int i = start_i; i < end_i; ++i) {
            if (decoded == bg->heads[i])
                ++ii[tails_i];
            else
                heads[heads_i++] = encoding[bg->heads[i]];
        }
        if (ii[tails_i] > 0)
            ii[tails_i] /= num_outlinks[tails_i];
    }
}

prpack_preprocessed_schur_graph::prpack_preprocessed_schur_graph(const prpack_base_graph* bg) {
    initialize();
    // initialize instance variables
    num_vs = bg->num_vs;
    num_es = bg->num_es - bg->num_self_es;
    tails = new int[num_vs];
    heads = new int[num_es];
    const bool weighted = bg->vals != NULL;
    if (weighted) {
        vals = new double[num_vs];
        d = new double[num_vs];
        fill(d, d + num_vs, 1);
        for (int i = 0; i < bg->num_es; ++i)
            d[bg->heads[i]] -= bg->vals[i];
    } else {
        num_outlinks = new double[num_vs];
        fill(num_outlinks, num_outlinks + num_vs, 0);
        for (int i = 0; i < bg->num_es; ++i)
            ++num_outlinks[bg->heads[i]];
    }
    // permute no-inlink vertices to the beginning, and no-outlink vertices to the end
    encoding = new int[num_vs];
    decoding = new int[num_vs];
    num_no_in_vs = num_no_out_vs = 0;
    for (int i = 0; i < num_vs; ++i) {
        if (bg->tails[i] == ((i + 1 != num_vs) ? bg->tails[i + 1] : bg->num_es)) {
            decoding[encoding[i] = num_no_in_vs] = i;
            ++num_no_in_vs;
        } else if ((weighted) ? (d[i] == 1) : (num_outlinks[i] == 0)) {
            decoding[encoding[i] = num_vs - 1 - num_no_out_vs] = i;
            ++num_no_out_vs;
        }
    }
    // permute everything else
    for (int i = 0, p = num_no_in_vs; i < num_vs; ++i)
        if (bg->tails[i] < ((i + 1 != num_vs) ? bg->tails[i + 1] : bg->num_es) && ((weighted) ? (d[i] < 1) : (num_outlinks[i] > 0)))
            decoding[encoding[i] = p++] = i;
    // continue initialization based off of weightedness
    if (weighted)
        initialize_weighted(bg);
    else
        initialize_unweighted(bg);
}

prpack_preprocessed_schur_graph::~prpack_preprocessed_schur_graph() {
    delete[] heads;
    delete[] tails;
    delete[] vals;
    delete[] ii;
    delete[] d;
    delete[] num_outlinks;
    delete[] encoding;
    delete[] decoding;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_preprocessed_schur_graph.h0000644000175100001710000000167300000000000032702 0ustar00runnerdocker00000000000000#ifndef PRPACK_PREPROCESSED_SCHUR_GRAPH
#define PRPACK_PREPROCESSED_SCHUR_GRAPH
#include "prpack_preprocessed_graph.h"
#include "prpack_base_graph.h"

namespace prpack {

    class prpack_preprocessed_schur_graph : public prpack_preprocessed_graph {
        private:
            // helper methods
            void initialize();
            void initialize_weighted(const prpack_base_graph* bg);
            void initialize_unweighted(const prpack_base_graph* bg);
        public:
            // instance variables
            int num_no_in_vs;
            int num_no_out_vs;
            int* heads;
            int* tails;
            double* vals;
            double* ii;
            double* num_outlinks;
            int* encoding;
            int* decoding;
            // constructors
            prpack_preprocessed_schur_graph(const prpack_base_graph* bg);
            // destructor
            ~prpack_preprocessed_schur_graph();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_result.cpp0000644000175100001710000000025500000000000027463 0ustar00runnerdocker00000000000000#include "prpack_result.h"
#include 
using namespace prpack;

prpack_result::prpack_result() {
    x = NULL;
}

prpack_result::~prpack_result() {
    delete[] x;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_result.h0000644000175100001710000000107500000000000027131 0ustar00runnerdocker00000000000000#ifndef PRPACK_RESULT
#define PRPACK_RESULT

#include 

namespace prpack {

    // Result class.
    class prpack_result {
        public:
            // instance variables
            int num_vs;
            int num_es;
            double* x;
            double read_time;
            double preprocess_time;
            double compute_time;
            long num_es_touched;
            std::string method;
            int converged;
            // constructor
            prpack_result();
            // destructor
            ~prpack_result();
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_solver.cpp0000644000175100001710000007310500000000000027463 0ustar00runnerdocker00000000000000#include "prpack_solver.h"
#include "prpack_utils.h"
#include 
#include 
#include 
#include 
#include 
using namespace prpack;
using namespace std;

void prpack_solver::initialize() {
    geg = NULL;
    gsg = NULL;
    sg = NULL;
    sccg = NULL;
	owns_bg = true;
}

prpack_solver::prpack_solver(const prpack_csc* g) {
    initialize();
    TIME(read_time, bg = new prpack_base_graph(g));
}

prpack_solver::prpack_solver(const prpack_int64_csc* g) {
    initialize();
    TIME(read_time, bg = new prpack_base_graph(g));
}

prpack_solver::prpack_solver(const prpack_csr* g) {
    initialize();
    TIME(read_time, bg = new prpack_base_graph(g));
}

prpack_solver::prpack_solver(const prpack_edge_list* g) {
    initialize();
    TIME(read_time, bg = new prpack_base_graph(g));
}

prpack_solver::prpack_solver(prpack_base_graph* g, bool owns_bg) {
    initialize();
	this->owns_bg = owns_bg;
    TIME(read_time, bg = g);
}

prpack_solver::prpack_solver(const char* filename, const char* format, const bool weighted) {
    initialize();
    TIME(read_time, bg = new prpack_base_graph(filename, format, weighted));
}

prpack_solver::~prpack_solver() {
	if (owns_bg) {
		delete bg;
	}
    delete geg;
    delete gsg;
    delete sg;
    delete sccg;
}

int prpack_solver::get_num_vs() {
    return bg->num_vs;
}

prpack_result* prpack_solver::solve(const double alpha, const double tol, const char* method) {
    return solve(alpha, tol, NULL, NULL, method);
}

prpack_result* prpack_solver::solve(
        const double alpha,
        const double tol,
        const double* u,
        const double* v,
        const char* method) {
    double preprocess_time = 0;
    double compute_time = 0;
    prpack_result* ret = NULL;
    // decide which method to run
    string m;
    if (strcmp(method, "") != 0)
        m = string(method);
    else {
        if (bg->num_vs < 128)
            m = "ge";
        else if (sccg != NULL)
            m = "sccgs";
        else if (sg != NULL)
            m = "sg";
        else
            m = "sccgs";
        if (u != v)
            m += "_uv";
    }
    // run the appropriate method
    if (m == "ge") {
        if (geg == NULL) {
            TIME(preprocess_time, geg = new prpack_preprocessed_ge_graph(bg));
        }
        TIME(compute_time, ret = solve_via_ge(
                alpha,
                tol,
                geg->num_vs,
                geg->matrix,
                u));
    } else if (m == "ge_uv") {
        if (geg == NULL) {
            TIME(preprocess_time, geg = new prpack_preprocessed_ge_graph(bg));
        }
        TIME(compute_time, ret = solve_via_ge_uv(
                alpha,
                tol,
                geg->num_vs,
                geg->matrix,
                geg->d,
                u,
                v));
    } else if (m == "gs") {
        if (gsg == NULL) {
            TIME(preprocess_time, gsg = new prpack_preprocessed_gs_graph(bg));
        }
        TIME(compute_time, ret = solve_via_gs(
                alpha,
                tol,
                gsg->num_vs,
                gsg->num_es,
                gsg->heads,
                gsg->tails,
                gsg->vals,
                gsg->ii,
                gsg->d,
                gsg->num_outlinks,
                u,
                v));
    } else if (m == "gserr") {
        if (gsg == NULL) {
            TIME(preprocess_time, gsg = new prpack_preprocessed_gs_graph(bg));
        }
        TIME(compute_time, ret = solve_via_gs_err(
                alpha,
                tol,
                gsg->num_vs,
                gsg->num_es,
                gsg->heads,
                gsg->tails,
                gsg->ii,
                gsg->num_outlinks,
                u,
                v));
    } else if (m == "sgs") {
        if (sg == NULL) {
            TIME(preprocess_time, sg = new prpack_preprocessed_schur_graph(bg));
        }
        TIME(compute_time, ret = solve_via_schur_gs(
                alpha,
                tol,
                sg->num_vs,
                sg->num_no_in_vs,
                sg->num_no_out_vs,
                sg->num_es,
                sg->heads,
                sg->tails,
                sg->vals,
                sg->ii,
                sg->d,
                sg->num_outlinks,
                u,
                sg->encoding,
                sg->decoding));
    } else if (m == "sgs_uv") {
        if (sg == NULL) {
            TIME(preprocess_time, sg = new prpack_preprocessed_schur_graph(bg));
        }
        TIME(compute_time, ret = solve_via_schur_gs_uv(
                alpha,
                tol,
                sg->num_vs,
                sg->num_no_in_vs,
                sg->num_no_out_vs,
                sg->num_es,
                sg->heads,
                sg->tails,
                sg->vals,
                sg->ii,
                sg->d,
                sg->num_outlinks,
                u,
                v,
                sg->encoding,
                sg->decoding));
    } else if (m == "sccgs") {
        if (sccg == NULL) {
            TIME(preprocess_time, sccg = new prpack_preprocessed_scc_graph(bg));
        }
        TIME(compute_time, ret = solve_via_scc_gs(
                alpha,
                tol,
                sccg->num_vs,
                sccg->num_es_inside,
                sccg->heads_inside,
                sccg->tails_inside,
                sccg->vals_inside,
                sccg->num_es_outside,
                sccg->heads_outside,
                sccg->tails_outside,
                sccg->vals_outside,
                sccg->ii,
                sccg->d,
                sccg->num_outlinks,
                u,
                sccg->num_comps,
                sccg->divisions,
                sccg->encoding,
                sccg->decoding));
    } else if (m == "sccgs_uv") {
        if (sccg == NULL) {
            TIME(preprocess_time, sccg = new prpack_preprocessed_scc_graph(bg));
        }
        TIME(compute_time, ret = solve_via_scc_gs_uv(
                alpha,
                tol,
                sccg->num_vs,
                sccg->num_es_inside,
                sccg->heads_inside,
                sccg->tails_inside,
                sccg->vals_inside,
                sccg->num_es_outside,
                sccg->heads_outside,
                sccg->tails_outside,
                sccg->vals_outside,
                sccg->ii,
                sccg->d,
                sccg->num_outlinks,
                u,
                v,
                sccg->num_comps,
                sccg->divisions,
                sccg->encoding,
                sccg->decoding));
    } else {
        throw invalid_argument("Unknown method specified for PRPACK: '" + m + "'.");
    }
    ret->method = m;
    ret->read_time = read_time;
    ret->preprocess_time = preprocess_time;
    ret->compute_time = compute_time;
    ret->num_vs = bg->num_vs;
    ret->num_es = bg->num_es;
    return ret;
}

// VARIOUS SOLVING METHODS ////////////////////////////////////////////////////////////////////////

prpack_result* prpack_solver::solve_via_ge(
        const double alpha,
        const double tol,
        const int num_vs,
        const double* matrix,
        const double* uv) {
    prpack_result* ret = new prpack_result();
    // initialize uv values
    const double uv_const = 1.0/num_vs;
    const int uv_exists = (uv) ? 1 : 0;
    uv = (uv) ? uv : &uv_const;
    // create matrix A
    double* A = new double[num_vs*num_vs];
    for (int i = 0; i < num_vs*num_vs; ++i)
        A[i] = -alpha*matrix[i];
    for (int i = 0; i < num_vs*num_vs; i += num_vs + 1)
        ++A[i];
    // create vector b
    double* b = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        b[i] = uv[uv_exists*i];
    // solve and normalize
    ge(num_vs, A, b);
    normalize(num_vs, b);
    // clean up and return
    delete[] A;
    ret->num_es_touched = -1;
    ret->x = b;
    return ret;
}

prpack_result* prpack_solver::solve_via_ge_uv(
        const double alpha,
        const double tol,
        const int num_vs,
        const double* matrix,
        const double* d,
        const double* u,
        const double* v) {
    prpack_result* ret = new prpack_result();
    // initialize u and v values
    const double u_const = 1.0/num_vs;
    const double v_const = 1.0/num_vs;
    const int u_exists = (u) ? 1 : 0;
    const int v_exists = (v) ? 1 : 0;
    u = (u) ? u : &u_const;
    v = (v) ? v : &v_const;
    // create matrix A
    double* A = new double[num_vs*num_vs];
    for (int i = 0; i < num_vs*num_vs; ++i)
        A[i] = -alpha*matrix[i];
    for (int i = 0, inum_vs = 0; i < num_vs; ++i, inum_vs += num_vs)
        for (int j = 0; j < num_vs; ++j)
            A[inum_vs + j] -= alpha*u[u_exists*i]*d[j];
    for (int i = 0; i < num_vs*num_vs; i += num_vs + 1)
        ++A[i];
    // create vector b
    double* b = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        b[i] = (1 - alpha)*v[v_exists*i];
    // solve
    ge(num_vs, A, b);
    // clean up and return
    delete[] A;
    ret->num_es_touched = -1;
    ret->x = b;
    return ret;
}

// Vanilla Gauss-Seidel.
prpack_result* prpack_solver::solve_via_gs(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_es,
        const int* heads,
        const int* tails,
        const double* vals,
        const double* ii,
        const double* d,
        const double* num_outlinks,
        const double* u,
        const double* v) {
    prpack_result* ret = new prpack_result();
    const bool weighted = vals != NULL;
    // initialize u and v values
    const double u_const = 1.0/num_vs;
    const double v_const = 1.0/num_vs;
    const int u_exists = (u) ? 1 : 0;
    const int v_exists = (v) ? 1 : 0;
    u = (u) ? u : &u_const;
    v = (v) ? v : &v_const;
    // initialize the eigenvector (and use personalization vector)
    double* x = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        x[i] = 0;
    // initialize delta
    double delta = 0;
    // run Gauss-Seidel
    ret->num_es_touched = 0;
    double err = 1, c = 0;
    do {
        if (weighted) {
            for (int i = 0; i < num_vs; ++i) {
                double new_val = 0;
                const int start_j = tails[i];
                const int end_j = (i + 1 != num_vs) ? tails[i + 1] : num_es;
                for (int j = start_j; j < end_j; ++j)
                    // TODO: might want to use compensation summation for large: end_j - start_j
                    new_val += x[heads[j]]*vals[j];
                new_val = alpha*new_val + (1 - alpha)*v[v_exists*i];
                delta -= alpha*x[i]*d[i];
                new_val += delta*u[u_exists*i];
                new_val /= 1 - alpha*(d[i]*u[u_exists*i] + (1 - d[i])*ii[i]);
                delta += alpha*new_val*d[i];
                COMPENSATED_SUM(err, x[i] - new_val, c);
                x[i] = new_val;
            }
        } else {
            for (int i = 0; i < num_vs; ++i) {
                const double old_val = x[i]*num_outlinks[i];
                double new_val = 0;
                const int start_j = tails[i];
                const int end_j = (i + 1 != num_vs) ? tails[i + 1] : num_es;
                for (int j = start_j; j < end_j; ++j)
                    // TODO: might want to use compensation summation for large: end_j - start_j
                    new_val += x[heads[j]];
                new_val = alpha*new_val + (1 - alpha)*v[v_exists*i];
                if (num_outlinks[i] < 0) {
                    delta -= alpha*old_val;
                    new_val += delta*u[u_exists*i];
                    new_val /= 1 - alpha*u[u_exists*i];
                    delta += alpha*new_val;
                } else {
                    new_val += delta*u[u_exists*i];
                    new_val /= 1 - alpha*ii[i];
                }
                COMPENSATED_SUM(err, old_val - new_val, c);
                x[i] = new_val/num_outlinks[i];
            }
        }
        // update iteration index
        ret->num_es_touched += num_es;
    } while (err >= tol);
    // undo num_outlinks transformation
    if (!weighted)
        for (int i = 0; i < num_vs; ++i)
            x[i] *= num_outlinks[i];
    // return results
    ret->x = x;
    return ret;
}

// Implement a gauss-seidel-like process with a strict error bound
// we return a solution with 1-norm error less than tol.
prpack_result* prpack_solver::solve_via_gs_err(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_es,
        const int* heads,
        const int* tails,
        const double* ii,
        const double* num_outlinks,
        const double* u,
        const double* v) {
    prpack_result* ret = new prpack_result();
    // initialize u and v values
    const double u_const = 1.0/num_vs;
    const double v_const = 1.0/num_vs;
    const int u_exists = (u) ? 1 : 0;
    const int v_exists = (v) ? 1 : 0;
    u = (u) ? u : &u_const;
    v = (v) ? v : &v_const;
    // Note to Dave, we can't rescale v because we could be running this
    // same routine from multiple threads.
    // initialize the eigenvector (and use personalization vector)
    double* x = new double[num_vs];
    for (int i = 0; i < num_vs; ++i) {
        x[i] = 0.;
    }
    // initialize delta
    double delta = 0.;
    // run Gauss-Seidel, note that we store x/deg[i] throughout this
    // iteration.
    int64_t maxedges = (int64_t)((double)num_es*std::min(
                            log(tol)/log(alpha),
                            (double)PRPACK_SOLVER_MAX_ITERS));
    ret->num_es_touched = 0;
    double err=1., c = 0.;
    do {
        // iterate through vertices
        for (int i = 0; i < num_vs; ++i) {
            double old_val = x[i]*num_outlinks[i]; // adjust back to the "true" value.
            double new_val = 0.;
            int start_j = tails[i], end_j = (i + 1 != num_vs) ? tails[i + 1] : num_es;
            for (int j = start_j; j < end_j; ++j) {
                // TODO: might want to use compensation summation for large: end_j - start_j
                new_val += x[heads[j]];
            }
            new_val = alpha*new_val + alpha*ii[i]*old_val + (1.0-alpha)*v[v_exists*i];
            new_val += delta*u[u_exists*i]; // add the dangling node adjustment
            if (num_outlinks[i] < 0) {
                delta += alpha*(new_val - old_val);
            }
            // note that new_val > old_val, but the fabs is just for
            COMPENSATED_SUM(err, -(new_val - old_val), c);
            x[i] = new_val/num_outlinks[i];
        }
        // update iteration index
        ret->num_es_touched += num_es;
    } while (err >= tol && ret->num_es_touched < maxedges);
    if (err >= tol) {
        ret->converged = 0;
    } else {
        ret->converged = 1;
    }
    // undo num_outlinks transformation
    for (int i = 0; i < num_vs; ++i)
        x[i] *= num_outlinks[i];
    // return results
    ret->x = x;
    return ret;
}

// Gauss-Seidel using the Schur complement to separate dangling nodes.
prpack_result* prpack_solver::solve_via_schur_gs(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_no_in_vs,
        const int num_no_out_vs,
        const int num_es,
        const int* heads,
        const int* tails,
        const double* vals,
        const double* ii,
        const double* d,
        const double* num_outlinks,
        const double* uv,
        const int* encoding,
        const int* decoding,
        const bool should_normalize) {
    prpack_result* ret = new prpack_result();
    const bool weighted = vals != NULL;
    // initialize uv values
    const double uv_const = 1.0/num_vs;
    const int uv_exists = (uv) ? 1 : 0;
    uv = (uv) ? prpack_utils::permute(num_vs, uv, encoding) : &uv_const;
    // initialize the eigenvector (and use personalization vector)
    double* x = new double[num_vs];
    for (int i = 0; i < num_vs - num_no_out_vs; ++i)
        x[i] = uv[uv_exists*i]/(1 - alpha*ii[i])/((weighted) ? 1 : num_outlinks[i]);
    // run Gauss-Seidel for the top left part of (I - alpha*P)*x = uv
    ret->num_es_touched = 0;
    double err, c;
    do {
        // iterate through vertices
        int num_es_touched = 0;
        err = c = 0;
#ifdef _OPENMP
        #pragma omp parallel for firstprivate(c) reduction(+:err, num_es_touched) schedule(dynamic, 64)
#endif
        for (int i = num_no_in_vs; i < num_vs - num_no_out_vs; ++i) {
            double new_val = 0;
            const int start_j = tails[i];
            const int end_j = (i + 1 != num_vs) ? tails[i + 1] : num_es;
            if (weighted) {
                for (int j = start_j; j < end_j; ++j)
                    // TODO: might want to use compensation summation for large: end_j - start_j
                    new_val += x[heads[j]]*vals[j];
                COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]), c);
                new_val = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i]);
                x[i] = new_val;
            } else {
                for (int j = start_j; j < end_j; ++j)
                    // TODO: might want to use compensation summation for large: end_j - start_j
                    new_val += x[heads[j]];
                COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]*num_outlinks[i]), c);
                new_val = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i]);
                x[i] = new_val/num_outlinks[i];
            }
            num_es_touched += end_j - start_j;
        }
        // update iteration index
        ret->num_es_touched += num_es_touched;
    } while (err/(1 - alpha) >= tol);
    // solve for the dangling nodes
    int num_es_touched = 0;
#ifdef _OPENMP
    #pragma omp parallel for reduction(+:num_es_touched) schedule(dynamic, 64)
#endif
    for (int i = num_vs - num_no_out_vs; i < num_vs; ++i) {
        x[i] = 0;
        const int start_j = tails[i];
        const int end_j = (i + 1 != num_vs) ? tails[i + 1] : num_es;
        for (int j = start_j; j < end_j; ++j)
            x[i] += x[heads[j]]*((weighted) ? vals[j] : 1);
        x[i] = (alpha*x[i] + uv[uv_exists*i])/(1 - alpha*ii[i]);
        num_es_touched += end_j - start_j;
    }
    ret->num_es_touched += num_es_touched;
    // undo num_outlinks transformation
    if (!weighted)
        for (int i = 0; i < num_vs - num_no_out_vs; ++i)
            x[i] *= num_outlinks[i];
    // normalize x to get the solution for: (I - alpha*P - alpha*u*d')*x = (1 - alpha)*v
    if (should_normalize)
        normalize(num_vs, x);
    // return results
    ret->x = prpack_utils::permute(num_vs, x, decoding);
    delete[] x;
    if (uv_exists)
        delete[] uv;
    return ret;
}

prpack_result* prpack_solver::solve_via_schur_gs_uv(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_no_in_vs,
        const int num_no_out_vs,
        const int num_es,
        const int* heads,
        const int* tails,
        const double* vals,
        const double* ii,
        const double* d,
        const double* num_outlinks,
        const double* u,
        const double* v,
        const int* encoding,
        const int* decoding) {
    // solve uv = u
    prpack_result* ret_u = solve_via_schur_gs(
            alpha,
            tol,
            num_vs,
            num_no_in_vs,
            num_no_out_vs,
            num_es,
            heads,
            tails,
            vals,
            ii,
            d,
            num_outlinks,
            u,
            encoding,
            decoding,
            false);
    // solve uv = v
    prpack_result* ret_v = solve_via_schur_gs(
            alpha,
            tol,
            num_vs,
            num_no_in_vs,
            num_no_out_vs,
            num_es,
            heads,
            tails,
            vals,
            ii,
            d,
            num_outlinks,
            v,
            encoding,
            decoding,
            false);
    // combine the u and v cases
    return combine_uv(num_vs, d, num_outlinks, encoding, alpha, ret_u, ret_v);
}

/** Gauss-Seidel using strongly connected components.
 * Notes:
 *   If not weighted, then we store x[i] = "x[i]/outdegree" to
 *   avoid additional arithmetic.  We don't do this for the weighted
 *   case because the adjustment may not be constant.
 */
prpack_result* prpack_solver::solve_via_scc_gs(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_es_inside,
        const int* heads_inside,
        const int* tails_inside,
        const double* vals_inside,
        const int num_es_outside,
        const int* heads_outside,
        const int* tails_outside,
        const double* vals_outside,
        const double* ii,
        const double* d,
        const double* num_outlinks,
        const double* uv,
        const int num_comps,
        const int* divisions,
        const int* encoding,
        const int* decoding,
        const bool should_normalize) {
    prpack_result* ret = new prpack_result();
    const bool weighted = vals_inside != NULL;
    // initialize uv values
    const double uv_const = 1.0/num_vs;
    const int uv_exists = (uv) ? 1 : 0;
    uv = (uv) ? prpack_utils::permute(num_vs, uv, encoding) : &uv_const;
    // CHECK initialize the solution with one iteration of GS from x=0.
    double* x = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        x[i] = uv[uv_exists*i]/(1 - alpha*ii[i])/((weighted) ? 1 : num_outlinks[i]);
    // create x_outside
    double* x_outside = new double[num_vs];
    // run Gauss-Seidel for (I - alpha*P)*x = uv
    ret->num_es_touched = 0;
    for (int comp_i = 0; comp_i < num_comps; ++comp_i) {
        const int start_comp = divisions[comp_i];
        const int end_comp = (comp_i + 1 != num_comps) ? divisions[comp_i + 1] : num_vs;
        const bool parallelize = end_comp - start_comp > 512;
        // initialize relevant x_outside values
        for (int i = start_comp; i < end_comp; ++i) {
            x_outside[i] = 0;
            const int start_j = tails_outside[i];
            const int end_j = (i + 1 != num_vs) ? tails_outside[i + 1] : num_es_outside;
            for (int j = start_j; j < end_j; ++j)
                x_outside[i] += x[heads_outside[j]]*((weighted) ? vals_outside[j] : 1.);
            ret->num_es_touched += end_j - start_j;
        }
        double err, c;
        do {
            int num_es_touched = 0;
            err = c = 0;
            if (parallelize) {
                // iterate through vertices
#ifdef _OPENMP
                #pragma omp parallel for firstprivate(c) reduction(+:err, num_es_touched) schedule(dynamic, 64)
#endif
                for (int i = start_comp; i < end_comp; ++i) {
                    double new_val = x_outside[i];
                    const int start_j = tails_inside[i];
                    const int end_j = (i + 1 != num_vs) ? tails_inside[i + 1] : num_es_inside;
                    if (weighted) {
                        for (int j = start_j; j < end_j; ++j) {
                            // TODO: might want to use compensation summation for large: end_j - start_j
                            new_val += x[heads_inside[j]]*vals_inside[j];
                        }
                        COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]), c);
                        x[i] = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i]);
                    } else {
                        for (int j = start_j; j < end_j; ++j) {
                            // TODO: might want to use compensation summation for large: end_j - start_j
                            new_val += x[heads_inside[j]];
                        }
                        COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]*num_outlinks[i]), c);
                        x[i] = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i])/num_outlinks[i];
                    }
                    num_es_touched += end_j - start_j;
                }
            } else {
                for (int i = start_comp; i < end_comp; ++i) {
                    double new_val = x_outside[i];
                    const int start_j = tails_inside[i];
                    const int end_j = (i + 1 != num_vs) ? tails_inside[i + 1] : num_es_inside;
                    if (weighted) {
                        for (int j = start_j; j < end_j; ++j) {
                            // TODO: might want to use compensation summation for large: end_j - start_j
                            new_val += x[heads_inside[j]]*vals_inside[j];
                        }
                        COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]), c);
                        x[i] = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i]);
                    } else {
                        for (int j = start_j; j < end_j; ++j) {
                            // TODO: might want to use compensation summation for large: end_j - start_j
                            new_val += x[heads_inside[j]];
                        }
                        COMPENSATED_SUM(err, fabs(uv[uv_exists*i] + alpha*new_val - (1 - alpha*ii[i])*x[i]*num_outlinks[i]), c);
                        x[i] = (alpha*new_val + uv[uv_exists*i])/(1 - alpha*ii[i])/num_outlinks[i];
                    }
                    num_es_touched += end_j - start_j;
                }
            }
            // update iteration index
            ret->num_es_touched += num_es_touched;
        } while (err/(1 - alpha) >= tol*(end_comp - start_comp)/num_vs);
    }
    // undo num_outlinks transformation
    if (!weighted)
        for (int i = 0; i < num_vs; ++i)
            x[i] *= num_outlinks[i];
    // normalize x to get the solution for: (I - alpha*P - alpha*u*d')*x = (1 - alpha)*v
    if (should_normalize)
        normalize(num_vs, x);
    // return results
    ret->x = prpack_utils::permute(num_vs, x, decoding);
    delete[] x;
    delete[] x_outside;
    if (uv_exists)
        delete[] uv;
    return ret;
}

prpack_result* prpack_solver::solve_via_scc_gs_uv(
        const double alpha,
        const double tol,
        const int num_vs,
        const int num_es_inside,
        const int* heads_inside,
        const int* tails_inside,
        const double* vals_inside,
        const int num_es_outside,
        const int* heads_outside,
        const int* tails_outside,
        const double* vals_outside,
        const double* ii,
        const double* d,
        const double* num_outlinks,
        const double* u,
        const double* v,
        const int num_comps,
        const int* divisions,
        const int* encoding,
        const int* decoding) {
    // solve uv = u
    prpack_result* ret_u = solve_via_scc_gs(
            alpha,
            tol,
            num_vs,
            num_es_inside,
            heads_inside,
            tails_inside,
            vals_inside,
            num_es_outside,
            heads_outside,
            tails_outside,
            vals_outside,
            ii,
            d,
            num_outlinks,
            u,
            num_comps,
            divisions,
            encoding,
            decoding,
            false);
    // solve uv = v
    prpack_result* ret_v = solve_via_scc_gs(
            alpha,
            tol,
            num_vs,
            num_es_inside,
            heads_inside,
            tails_inside,
            vals_inside,
            num_es_outside,
            heads_outside,
            tails_outside,
            vals_outside,
            ii,
            d,
            num_outlinks,
            v,
            num_comps,
            divisions,
            encoding,
            decoding,
            false);
    // combine u and v
    return combine_uv(num_vs, d, num_outlinks, encoding, alpha, ret_u, ret_v);
}

// VARIOUS HELPER METHODS /////////////////////////////////////////////////////////////////////////

// Run Gaussian-Elimination (note: this changes A and returns the solution in b)
void prpack_solver::ge(const int sz, double* A, double* b) {
    // put into triangular form
    for (int i = 0, isz = 0; i < sz; ++i, isz += sz)
        for (int k = 0, ksz = 0; k < i; ++k, ksz += sz)
            if (A[isz + k] != 0) {
                const double coeff = A[isz + k]/A[ksz + k];
                A[isz + k] = 0;
                for (int j = k + 1; j < sz; ++j)
                    A[isz + j] -= coeff*A[ksz + j];
                b[i] -= coeff*b[k];
            }
    // backwards substitution
    for (int i = sz - 1, isz = (sz - 1)*sz; i >= 0; --i, isz -= sz) {
        for (int j = i + 1; j < sz; ++j)
            b[i] -= A[isz + j]*b[j];
        b[i] /= A[isz + i];
    }
}

// Normalize a vector to sum to 1.
void prpack_solver::normalize(const int length, double* x) {
    double norm = 0, c = 0;
    for (int i = 0; i < length; ++i) {
        COMPENSATED_SUM(norm, x[i], c);
    }
    norm = 1/norm;
    for (int i = 0; i < length; ++i)
        x[i] *= norm;
}

// Combine u and v results.
prpack_result* prpack_solver::combine_uv(
        const int num_vs,
        const double* d,
        const double* num_outlinks,
        const int* encoding,
        const double alpha,
        const prpack_result* ret_u,
        const prpack_result* ret_v) {
    prpack_result* ret = new prpack_result();
    const bool weighted = d != NULL;
    double delta_u = 0;
    double delta_v = 0;
    for (int i = 0; i < num_vs; ++i) {
        if ((weighted) ? (d[encoding[i]] == 1) : (num_outlinks[encoding[i]] < 0)) {
            delta_u += ret_u->x[i];
            delta_v += ret_v->x[i];
        }
    }
    const double s = ((1 - alpha)*alpha*delta_v)/(1 - alpha*delta_u);
    const double t = 1 - alpha;
    ret->x = new double[num_vs];
    for (int i = 0; i < num_vs; ++i)
        ret->x[i] = s*ret_u->x[i] + t*ret_v->x[i];
    ret->num_es_touched = ret_u->num_es_touched + ret_v->num_es_touched;
    // clean up and return
    delete ret_u;
    delete ret_v;
    return ret;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_solver.h0000644000175100001710000001547100000000000027132 0ustar00runnerdocker00000000000000#ifndef PRPACK_SOLVER
#define PRPACK_SOLVER
#include "prpack_base_graph.h"
#include "prpack_csc.h"
#include "prpack_csr.h"
#include "prpack_edge_list.h"
#include "prpack_preprocessed_ge_graph.h"
#include "prpack_preprocessed_gs_graph.h"
#include "prpack_preprocessed_scc_graph.h"
#include "prpack_preprocessed_schur_graph.h"
#include "prpack_result.h"

// TODO Make this a user configurable variable
#define PRPACK_SOLVER_MAX_ITERS 1000000

namespace prpack {

    // Solver class.
    class prpack_solver {
        private:
            // instance variables
            double read_time;
            prpack_base_graph* bg;
            prpack_preprocessed_ge_graph* geg;
            prpack_preprocessed_gs_graph* gsg;
            prpack_preprocessed_schur_graph* sg;
            prpack_preprocessed_scc_graph* sccg;
			bool owns_bg;
            // methods
            void initialize();
            static prpack_result* solve_via_ge(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const double* matrix,
                    const double* uv);
            static prpack_result* solve_via_ge_uv(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const double* matrix,
                    const double* d,
                    const double* u,
                    const double* v);
            static prpack_result* solve_via_gs(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_es,
                    const int* heads,
                    const int* tails,
                    const double* vals,
                    const double* ii,
                    const double* d,
                    const double* num_outlinks,
                    const double* u,
                    const double* v);
            static prpack_result* solve_via_gs_err(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_es,
                    const int* heads,
                    const int* tails,
                    const double* ii,
                    const double* num_outlinks,
                    const double* u,
                    const double* v);
            static prpack_result* solve_via_schur_gs(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_no_in_vs,
                    const int num_no_out_vs,
                    const int num_es,
                    const int* heads,
                    const int* tails,
                    const double* vals,
                    const double* ii,
                    const double* d,
                    const double* num_outlinks,
                    const double* uv,
                    const int* encoding,
                    const int* decoding,
                    const bool should_normalize = true);
            static prpack_result* solve_via_schur_gs_uv(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_no_in_vs,
                    const int num_no_out_vs,
                    const int num_es,
                    const int* heads,
                    const int* tails,
                    const double* vals,
                    const double* ii,
                    const double* d,
                    const double* num_outlinks,
                    const double* u,
                    const double* v,
                    const int* encoding,
                    const int* decoding);
            static prpack_result* solve_via_scc_gs(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_es_inside,
                    const int* heads_inside,
                    const int* tails_inside,
                    const double* vals_inside,
                    const int num_es_outside,
                    const int* heads_outside,
                    const int* tails_outside,
                    const double* vals_outside,
                    const double* ii,
                    const double* d,
                    const double* num_outlinks,
                    const double* uv,
                    const int num_comps,
                    const int* divisions,
                    const int* encoding,
                    const int* decoding,
                    const bool should_normalize = true);
            static prpack_result* solve_via_scc_gs_uv(
                    const double alpha,
                    const double tol,
                    const int num_vs,
                    const int num_es_inside,
                    const int* heads_inside,
                    const int* tails_inside,
                    const double* vals_inside,
                    const int num_es_outside,
                    const int* heads_outside,
                    const int* tails_outside,
                    const double* vals_outside,
                    const double* ii,
                    const double* d,
                    const double* num_outlinks,
                    const double* u,
                    const double* v,
                    const int num_comps,
                    const int* divisions,
                    const int* encoding,
                    const int* decoding);
            static void ge(const int sz, double* A, double* b);
            static void normalize(const int length, double* x);
            static prpack_result* combine_uv(
                    const int num_vs,
                    const double* d,
                    const double* num_outlinks,
                    const int* encoding,
                    const double alpha,
                    const prpack_result* ret_u,
                    const prpack_result* ret_v);
        public:
            // constructors
            prpack_solver(const prpack_csc* g);
            prpack_solver(const prpack_int64_csc* g);
            prpack_solver(const prpack_csr* g);
            prpack_solver(const prpack_edge_list* g);
            prpack_solver(prpack_base_graph* g, bool owns_bg=true);
            prpack_solver(const char* filename, const char* format, const bool weighted);
            // destructor
            ~prpack_solver();
            // methods
            int get_num_vs();
            prpack_result* solve(const double alpha, const double tol, const char* method);
            prpack_result* solve(
                    const double alpha,
                    const double tol,
                    const double* u,
                    const double* v,
                    const char* method);
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_utils.cpp0000644000175100001710000000261500000000000027307 0ustar00runnerdocker00000000000000/**
 * @file prpack_utils.cpp
 * An assortment of utility functions for reporting errors, checking time,
 * and working with vectors.
 */

#include 
#include "prpack_utils.h"
#include 
#include 
#include 
using namespace prpack;
using namespace std;

#ifdef PRPACK_IGRAPH_SUPPORT
#include "igraph_error.h"
#endif

#if defined(_WIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#include 
#endif
double prpack_utils::get_time() {
    LARGE_INTEGER t, freq;
    QueryPerformanceCounter(&t);
    QueryPerformanceFrequency(&freq);
    return double(t.QuadPart)/double(freq.QuadPart);
}
#else
#include 
#include 
double prpack_utils::get_time() {
    struct timeval t;
    gettimeofday(&t, 0);
    return (t.tv_sec*1.0 + t.tv_usec/1000000.0);
}
#endif

// Fails and outputs 'msg' if 'condition' is false.
void prpack_utils::validate(const bool condition, const string& msg) {
    if (!condition) {
#ifdef PRPACK_IGRAPH_SUPPORT
        igraph_error("Internal error in PRPACK", IGRAPH_FILE_BASENAME, __LINE__,
	             IGRAPH_EINTERNAL);
#else
        cerr << msg << endl;
        exit(-1);
#endif
    }
}

// Permute a vector.
double* prpack_utils::permute(const int length, const double* a, const int* coding) {
    double* ret = new double[length];
    for (int i = 0; i < length; ++i)
        ret[coding[i]] = a[i];
    return ret;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack/prpack_utils.h0000644000175100001710000000171400000000000026753 0ustar00runnerdocker00000000000000#ifndef PRPACK_UTILS
#define PRPACK_UTILS
#ifdef MATLAB_MEX_FILE
#include "mex.h"
#endif
#include 

// Computes the time taken to do X and stores it in T.
#define TIME(T, X)                  \
    (T) = prpack_utils::get_time(); \
    (X);                            \
    (T) = prpack_utils::get_time() - (T)

// Computes S += A using C as a carry-over.
// This is a macro over a function as it is faster this way.
#define COMPENSATED_SUM(S, A, C)                        \
    double compensated_sum_y = (A) - (C);               \
    double compensated_sum_t = (S) + compensated_sum_y; \
    (C) = compensated_sum_t - (S) - compensated_sum_y;  \
    (S) = compensated_sum_t

namespace prpack {

    class prpack_utils {
        public:
            static double get_time();
            static void validate(const bool condition, const std::string& msg);
            static double* permute(const int length, const double* a, const int* coding);
    };

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack.cpp0000644000175100001710000001124000000000000024601 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_error.h"

#include "centrality/prpack_internal.h"
#include "centrality/prpack/prpack_igraph_graph.h"
#include "centrality/prpack/prpack_solver.h"
#include "core/exceptions.h"

using namespace prpack;
using namespace std;

/*
 * PRPACK-based implementation of \c igraph_personalized_pagerank.
 *
 * See \c igraph_personalized_pagerank for the documentation of the parameters.
 */
int igraph_i_personalized_pagerank_prpack(const igraph_t *graph, igraph_vector_t *vector,
                                          igraph_real_t *value, const igraph_vs_t vids,
                                          igraph_bool_t directed, igraph_real_t damping,
                                          const igraph_vector_t *reset,
                                          const igraph_vector_t *weights) {
    long int i, no_of_nodes = igraph_vcount(graph), nodes_to_calc;
    igraph_vit_t vit;
    double *u = nullptr;
    double *v = nullptr;
    const prpack_result *res;

    IGRAPH_HANDLE_EXCEPTIONS(
        if (reset) {
            if (igraph_vector_size(reset) != no_of_nodes) {
                IGRAPH_ERROR("Invalid length of reset vector when calculating personalized PageRank scores.", IGRAPH_EINVAL);
            }

            /* Normalize reset vector so the sum is 1 */
            double reset_min = igraph_vector_min(reset);
            if (reset_min < 0) {
                IGRAPH_ERROR("The reset vector must not contain negative elements.", IGRAPH_EINVAL);
            }
            if (igraph_is_nan(reset_min)) {
                IGRAPH_ERROR("The reset vector must not contain NaN values.", IGRAPH_EINVAL);
            }

            double reset_sum = igraph_vector_sum(reset);
            if (reset_sum == 0) {
                IGRAPH_ERROR("The sum of the elements in the reset vector must not be zero.", IGRAPH_EINVAL);
            }

            // Construct the personalization vector
            v = new double[no_of_nodes];
            for (i = 0; i < no_of_nodes; i++) {
                v[i] = VECTOR(*reset)[i] / reset_sum;
            }

            // u is the distribution used when restarting the walk due to being stuck in a sink
            // v is the distribution used when restarting due to damping
            // Here we use the same distribution for both
            u = v;
        }

        // Since PRPACK uses the algebraic method to solve PageRank, damping factors very close to 1.0
        // may lead to numerical instability, the apperance of non-finite values, or the iteration
        // never terminating.
        if (damping > 0.999) {
            IGRAPH_WARNINGF(
                    "Damping factor is %g. "
                    "Damping values close to 1 may lead to numerical instability when using PRPACK.",
                    damping);
        }

        // Construct and run the solver
        prpack_igraph_graph prpack_graph(graph, weights, directed);
        prpack_solver solver(&prpack_graph, false);
        res = solver.solve(damping, 1e-10, u, v, "");

        // Delete the personalization vector
        delete [] v;
    );

    // Check whether the solver converged
    // TODO: this is commented out because some of the solvers do not implement it yet
    /*
    if (!res->converged) {
        IGRAPH_WARNING("PRPACK solver failed to converge. Results may be inaccurate.");
    }
    */

    // Fill the result vector
    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    nodes_to_calc = IGRAPH_VIT_SIZE(vit);
    IGRAPH_CHECK(igraph_vector_resize(vector, nodes_to_calc));
    for (IGRAPH_VIT_RESET(vit), i = 0; !IGRAPH_VIT_END(vit);
         IGRAPH_VIT_NEXT(vit), i++) {
        VECTOR(*vector)[i] = res->x[(long int)IGRAPH_VIT_GET(vit)];
    }
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    // TODO: can we get the eigenvalue? We'll just fake it until we can.
    if (value) {
        *value = 1.0;
    }
    delete res;

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/centrality/prpack_internal.h0000644000175100001710000000275500000000000026155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_PRPACK
#define IGRAPH_PRPACK

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_datatype.h"
#include "igraph_iterators.h"

#include "igraph_interface.h"

__BEGIN_DECLS

int igraph_i_personalized_pagerank_prpack(const igraph_t *graph, igraph_vector_t *vector,
                                          igraph_real_t *value, const igraph_vs_t vids,
                                          igraph_bool_t directed, igraph_real_t damping,
                                          const igraph_vector_t *reset,
                                          const igraph_vector_t *weights);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4831405
igraph-0.9.9/vendor/source/igraph/src/cliques/0000755000175100001710000000000000000000000022106 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4871404
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/0000755000175100001710000000000000000000000023552 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/CMakeLists.txt0000644000175100001710000000120400000000000026307 0ustar00runnerdocker00000000000000# Declare the files needed to compile Cliquer
add_library(
  cliquer
  OBJECT
  EXCLUDE_FROM_ALL
  cliquer.c
  cliquer_graph.c
  reorder.c
)

target_include_directories(
  cliquer
  PRIVATE
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
  ${PROJECT_BINARY_DIR}/src
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET cliquer PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Since these are included as object files, they should call the
# function as is (without visibility specification)
target_compile_definitions(cliquer PRIVATE IGRAPH_STATIC)

# TODO(ntamas): make sure that this works for Cliquer
# use_all_warnings(cliquer)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/README0000644000175100001710000000377200000000000024443 0ustar00runnerdocker00000000000000
Cliquer - routines for clique searching
---------------------------------------


Cliquer is a set of C routines for finding cliques in an arbitrary
weighted graph. It uses an exact branch-and-bound algorithm recently
developed by Patric Ostergard. It is designed with the aim of being
efficient while still being flexible and easy to use.

Cliquer was developed on Linux, and it should compile without
modification on most modern UNIX systems. Other operating systems may
require minor changes to the source code.

Features:

  * support for both weighted and unweighted graphs (faster routines
    for unweighted graphs)
  * search for maximum clique / maximum-weight clique
  * search for clique with size / weight within a given range
  * restrict search to maximal cliques
  * store found cliques in memory
  * call a user-defined function for every clique found
  * Cliquer is re-entrant, so you can use the clique-searching
    functions from within the callback function

The full documentation can be obtained via the www page of
Cliquer .


License

Cliquer is Copyright (C) 2002 Sampo Niskanen, Patric Ostergard.

Cliquer is licensed under the GNU General Public License as published
by the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. The full license is included in
the file LICENSE.

Basically, you can use Cliquer for any purpose, provided that any
programs or modifications you make and distribute are also licensed
under the GNU GPL.

ABSOLUTELY NO GUARANTEES OR WARRANTIES are made concerning the
suitability, correctness, or any other aspect of these routines.


Contact

Cliquer was mainly written by Sampo Niskanen .

For bug-fixes, feedback, and, in particular, for putting your
name on the mailing list for important information regarding Cliquer,
please contact:

Patric Ostergard
Department of Communications and Networking
Aalto University
P.O. Box 13000, 00076 Aalto
FINLAND

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/cliquer.c0000644000175100001710000013141700000000000025371 0ustar00runnerdocker00000000000000
/*
 * This file contains the clique searching routines.
 *
 * Copyright (C) 2002 Sampo Niskanen, Patric Östergård.
 * Licensed under the GNU GPL, read the file LICENSE for details.
 */

#include 
#include 
#include 
/*
#include 
#include 
#include 
*/

#include "cliquer.h"

#include "config.h"

/* Default cliquer options */
IGRAPH_THREAD_LOCAL clique_options clique_default_options = {
    reorder_by_default, NULL, /*clique_print_time*/ NULL, NULL, NULL, NULL, NULL, 0
};


/* Calculate d/q, rounding result upwards/downwards. */
#define DIV_UP(d,q) (((d)+(q)-1)/(q))
#define DIV_DOWN(d,q) ((int)((d)/(q)))


/* Global variables used: */
/* These must be saved and restored in re-entrance. */
static IGRAPH_THREAD_LOCAL int *clique_size;      /* c[i] == max. clique size in {0,1,...,i-1} */
static IGRAPH_THREAD_LOCAL set_t current_clique;  /* Current clique being searched. */
static IGRAPH_THREAD_LOCAL set_t best_clique;     /* Largest/heaviest clique found so far. */
/*static struct tms cputimer;*/      /* Timer for opts->time_function() */
/*static struct timeval realtimer;*/ /* Timer for opts->time_function() */
static IGRAPH_THREAD_LOCAL int clique_list_count=0;  /* No. of cliques in opts->clique_list[] */
static IGRAPH_THREAD_LOCAL int weight_multiplier=1;  /* Weights multiplied by this when passing
				  * to time_function(). */

/* List cache (contains memory blocks of size g->n * sizeof(int)) */
static IGRAPH_THREAD_LOCAL int **temp_list=NULL;
static IGRAPH_THREAD_LOCAL int temp_count=0;


/*
 * Macros for re-entrance.  ENTRANCE_SAVE() must be called immediately
 * after variable definitions, ENTRANCE_RESTORE() restores global
 * variables to original values.  entrance_level should be increased
 * and decreased accordingly.
 */
static IGRAPH_THREAD_LOCAL int entrance_level=0;  /* How many levels for entrance have occurred? */

#define ENTRANCE_SAVE() \
int *old_clique_size = clique_size;                     \
set_t old_current_clique = current_clique;              \
set_t old_best_clique = best_clique;                    \
int old_clique_list_count = clique_list_count;          \
int old_weight_multiplier = weight_multiplier;          \
int **old_temp_list = temp_list;                        \
int old_temp_count = temp_count;                        \
/*struct tms old_cputimer;                                \
struct timeval old_realtimer;                           \
memcpy(&old_cputimer,&cputimer,sizeof(struct tms));       \
memcpy(&old_realtimer,&realtimer,sizeof(struct timeval));*/

#define ENTRANCE_RESTORE() \
clique_size = old_clique_size;                          \
current_clique = old_current_clique;                    \
best_clique = old_best_clique;                          \
clique_list_count = old_clique_list_count;              \
weight_multiplier = old_weight_multiplier;              \
temp_list = old_temp_list;                              \
temp_count = old_temp_count;                            \
/*memcpy(&cputimer,&old_cputimer,sizeof(struct tms));       \
memcpy(&realtimer,&old_realtimer,sizeof(struct timeval));*/


/* Number of clock ticks per second (as returned by sysconf(_SC_CLK_TCK)) */
/*static int clocks_per_sec=0;*/




/* Recursion and helper functions */
static boolean sub_unweighted_single(int *table, int size, int min_size,
				     graph_t *g);
static CLIQUER_LARGE_INT sub_unweighted_all(int *table, int size, int min_size, int max_size,
                                            boolean maximal, graph_t *g,
                                            clique_options *opts);
static int sub_weighted_all(int *table, int size, int weight,
			    int current_weight, int prune_low, int prune_high,
			    int min_weight, int max_weight, boolean maximal,
			    graph_t *g, clique_options *opts);


static boolean store_clique(set_t clique, graph_t *g, clique_options *opts);
static boolean is_maximal(set_t clique, graph_t *g);
static boolean false_function(set_t clique,graph_t *g,clique_options *opts);





/*****  Unweighted searches  *****/
/*
 * Unweighted searches are done separately from weighted searches because
 * some effective pruning methods can be used when the vertex weights
 * are all 1.  Single and all clique finding routines are separated,
 * because the single clique finding routine can store the found clique
 * while it is returning from the recursion, thus requiring no implicit
 * storing of the current clique.  When searching for all cliques the
 * current clique must be stored.
 */


/*
 * unweighted_clique_search_single()
 *
 * Searches for a single clique of size min_size.  Stores maximum clique
 * sizes into clique_size[].
 *
 *   table    - the order of the vertices in g to use
 *   min_size - minimum size of clique to search for.  If min_size==0,
 *              searches for a maximum clique.
 *   g        - the graph
 *   opts     - time printing options
 *
 * opts->time_function is called after each base-level recursion, if
 * non-NULL.
 *
 * Returns the size of the clique found, or 0 if min_size>0 and a clique
 * of that size was not found (or if time_function aborted the search).
 * The largest clique found is stored in current_clique.
 *
 * Note: Does NOT use opts->user_function of opts->clique_list.
 */
static int unweighted_clique_search_single(int *table, int min_size,
					   graph_t *g, clique_options *opts) {
    /*
    struct tms tms;
	struct timeval timeval;
    */
	int i,j;
	int v,w;
	int *newtable;
	int newsize;

	v=table[0];
	clique_size[v]=1;
	set_empty(current_clique);
	SET_ADD_ELEMENT(current_clique,v);
	if (min_size==1)
		return 1;

	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}
	for (i=1; i < g->n; i++) {
		w=v;
		v=table[i];

		newsize=0;
		for (j=0; jtime_function) {
			gettimeofday(&timeval,NULL);
			times(&tms);
			if (!opts->time_function(entrance_level,
						 i+1,g->n,clique_size[v] *
						 weight_multiplier,
						 (double)(tms.tms_utime-
							  cputimer.tms_utime)/
						 clocks_per_sec,
						 timeval.tv_sec-
						 realtimer.tv_sec+
						 (double)(timeval.tv_usec-
							  realtimer.tv_usec)/
						 1000000,opts)) {
				temp_list[temp_count++]=newtable;
				return 0;
			}
		}
        */

		if (min_size) {
			if (clique_size[v]>=min_size) {
				temp_list[temp_count++]=newtable;
				return clique_size[v];
			}
			if (clique_size[v]+g->n-i-1 < min_size) {
				temp_list[temp_count++]=newtable;
				return 0;
			}
		}
	}

	temp_list[temp_count++]=newtable;

	if (min_size)
		return 0;
	return clique_size[v];
}

/*
 * sub_unweighted_single()
 *
 * Recursion function for searching for a single clique of size min_size.
 *
 *    table    - subset of the vertices in graph
 *    size     - size of table
 *    min_size - size of clique to look for within the subgraph
 *               (decreased with every recursion)
 *    g        - the graph
 *
 * Returns TRUE if a clique of size min_size is found, FALSE otherwise.
 * If a clique of size min_size is found, it is stored in current_clique.
 *
 * clique_size[] for all values in table must be defined and correct,
 * otherwise inaccurate results may occur.
 */
static boolean sub_unweighted_single(int *table, int size, int min_size,
				     graph_t *g) {
	int i;
	int v;
	int *newtable;
	int *p1, *p2;

	/* Zero or one vertices needed anymore. */
	if (min_size <= 1) {
		if (size>0 && min_size==1) {
			set_empty(current_clique);
			SET_ADD_ELEMENT(current_clique,table[0]);
			return TRUE;
		}
		if (min_size==0) {
			set_empty(current_clique);
			return TRUE;
		}
		return FALSE;
	}
	if (size < min_size)
		return FALSE;

	/* Dynamic memory allocation with cache */
	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	for (i = size-1; i >= 0; i--) {
		v = table[i];

		if (clique_size[v] < min_size)
			break;
		/* This is faster when compiling with gcc than placing
		 * this in the for-loop condition. */
		if (i+1 < min_size)
			break;

		/* Very ugly code, but works faster than "for (i=...)" */
		p1 = newtable;
		for (p2=table; p2 < table+i; p2++) {
			int w = *p2;
			if (GRAPH_IS_EDGE(g, v, w)) {
				*p1 = w;
				p1++;
			}
		}

		/* Avoid unneccessary loops (next size == p1-newtable) */
		if (p1-newtable < min_size-1)
			continue;
		/* Now p1-newtable >= min_size-1 >= 2-1 == 1, so we can use
		 * p1-newtable-1 safely. */
		if (clique_size[newtable[p1-newtable-1]] < min_size-1)
			continue;

		if (sub_unweighted_single(newtable,p1-newtable,
					  min_size-1,g)) {
			/* Clique found. */
			SET_ADD_ELEMENT(current_clique,v);
			temp_list[temp_count++]=newtable;
			return TRUE;
		}
	}
	temp_list[temp_count++]=newtable;
	return FALSE;
}


/*
 * unweighted_clique_search_all()
 *
 * Searches for all cliques with size at least min_size and at most
 * max_size.  Stores the cliques as opts declares.
 *
 *   table    - the order of the vertices in g to search
 *   start    - first index where the subgraph table[0], ..., table[start]
 *              might include a requested kind of clique
 *   min_size - minimum size of clique to search for.  min_size > 0 !
 *   max_size - maximum size of clique to search for.  If no upper limit
 *              is desired, use eg. INT_MAX
 *   maximal  - requires cliques to be maximal
 *   g        - the graph
 *   opts     - time printing and clique storage options
 *
 * Cliques found are stored as defined by opts->user_function and
 * opts->clique_list.  opts->time_function is called after each
 * base-level recursion, if non-NULL.
 *
 * clique_size[] must be defined and correct for all values of
 * table[0], ..., table[start-1].
 *
 * Returns the number of cliques stored (not neccessarily number of cliques
 * in graph, if user/time_function aborts).
 */
static CLIQUER_LARGE_INT unweighted_clique_search_all(int *table, int start,
                                                      int min_size, int max_size,
                                                      boolean maximal, graph_t *g,
                                                      clique_options *opts) {
    /*
	struct timeval timeval;
	struct tms tms;
    */
        int i, j;
	int v;
	int *newtable;
	int newsize;
        CLIQUER_LARGE_INT r;
        CLIQUER_LARGE_INT count=0;

	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	clique_list_count=0;
	set_empty(current_clique);
	for (i=start; i < g->n; i++) {
		v=table[i];
		clique_size[v]=min_size;  /* Do not prune here. */

		newsize=0;
		for (j=0; jtime_function) {
			gettimeofday(&timeval,NULL);
			times(&tms);
			if (!opts->time_function(entrance_level,
						 i+1,g->n,min_size *
						 weight_multiplier,
						 (double)(tms.tms_utime-
							  cputimer.tms_utime)/
						 clocks_per_sec,
						 timeval.tv_sec-
						 realtimer.tv_sec+
						 (double)(timeval.tv_usec-
							  realtimer.tv_usec)/
						 1000000,opts)) {
				/* Abort. */
				break;
			}
		}
#endif
	}
	temp_list[temp_count++]=newtable;
	return count;
}

/*
 * sub_unweighted_all()
 *
 * Recursion function for searching for all cliques of given size.
 *
 *   table    - subset of vertices of graph g
 *   size     - size of table
 *   min_size - minimum size of cliques to search for (decreased with
 *              every recursion)
 *   max_size - maximum size of cliques to search for (decreased with
 *              every recursion).  If no upper limit is desired, use
 *              eg. INT_MAX
 *   maximal  - require cliques to be maximal (passed through)
 *   g        - the graph
 *   opts     - storage options
 *
 * All cliques of suitable size found are stored according to opts.
 *
 * Returns the number of cliques found.  If user_function returns FALSE,
 * then the number of cliques is returned negative.
 *
 * Uses current_clique to store the currently-being-searched clique.
 * clique_size[] for all values in table must be defined and correct,
 * otherwise inaccurate results may occur.
 */
static CLIQUER_LARGE_INT sub_unweighted_all(int *table, int size, int min_size, int max_size,
                                            boolean maximal, graph_t *g,
                                            clique_options *opts) {
	int i;
	int v;
	int *newtable;
	int *p1, *p2;
        CLIQUER_LARGE_INT n;
        CLIQUER_LARGE_INT count=0;     /* Amount of cliques found */

	if (min_size <= 0) {
		if ((!maximal) || is_maximal(current_clique,g)) {
			/* We've found one.  Store it. */
			count++;
			if (!store_clique(current_clique,g,opts)) {
				return -count;
			}
		}
		if (max_size <= 0) {
			/* If we add another element, size will be too big. */
			return count;
		}
	}

	if (size < min_size) {
		return count;
	}

	/* Dynamic memory allocation with cache */
	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	for (i=size-1; i>=0; i--) {
		v = table[i];
		if (clique_size[v] < min_size) {
			break;
		}
		if (i+1 < min_size) {
			break;
		}

		/* Very ugly code, but works faster than "for (i=...)" */
		p1 = newtable;
		for (p2=table; p2 < table+i; p2++) {
			int w = *p2;
			if (GRAPH_IS_EDGE(g, v, w)) {
				*p1 = w;
				p1++;
			}
		}

		/* Avoid unneccessary loops (next size == p1-newtable) */
		if (p1-newtable < min_size-1) {
			continue;
		}

		SET_ADD_ELEMENT(current_clique,v);
		n=sub_unweighted_all(newtable,p1-newtable,
				     min_size-1,max_size-1,maximal,g,opts);
		SET_DEL_ELEMENT(current_clique,v);
		if (n < 0) {
			/* Abort. */
			count -= n;
			count = -count;
			break;
		}
		count+=n;
	}
	temp_list[temp_count++]=newtable;
	return count;
}




/***** Weighted clique searches *****/
/*
 * Weighted clique searches can use the same recursive routine, because
 * in both cases (single/all) they have to search through all potential
 * permutations searching for heavier cliques.
 */


/*
 * weighted_clique_search_single()
 *
 * Searches for a single clique of weight at least min_weight, and at
 * most max_weight.  Stores maximum clique sizes into clique_size[]
 * (or min_weight-1, whichever is smaller).
 *
 *   table      - the order of the vertices in g to use
 *   min_weight - minimum weight of clique to search for.  If min_weight==0,
 *                then searches for a maximum weight clique
 *   max_weight - maximum weight of clique to search for.  If no upper limit
 *                is desired, use eg. INT_MAX
 *   g          - the graph
 *   opts       - time printing options
 *
 * opts->time_function is called after each base-level recursion, if
 * non-NULL.
 *
 * Returns 0 if a clique of requested weight was not found (also if
 * time_function requested an abort), otherwise returns >= 1.
 * If min_weight==0 (search for maximum-weight clique), then the return
 * value is the weight of the clique found.  The found clique is stored
 * in best_clique.
 *
 * Note: Does NOT use opts->user_function of opts->clique_list.
 */
static int weighted_clique_search_single(int *table, int min_weight,
					 int max_weight, graph_t *g,
					 clique_options *opts) {
    /*
	struct timeval timeval;
	struct tms tms;
    */
	int i,j;
	int v;
	int *newtable;
	int newsize;
	int newweight;
	int search_weight;
	int min_w;
	clique_options localopts;

	if (min_weight==0)
		min_w=INT_MAX;
	else
		min_w=min_weight;


	if (min_weight==1) {
		/* min_weight==1 may cause trouble in the routine, and
		 * it's trivial to check as it's own case.
		 * We write nothing to clique_size[]. */
		for (i=0; i < g->n; i++) {
			if (g->weights[table[i]] <= max_weight) {
				set_empty(best_clique);
				SET_ADD_ELEMENT(best_clique,table[i]);
				return g->weights[table[i]];
			}
		}
		return 0;
	}

	localopts.time_function=NULL;
	localopts.reorder_function=NULL;
	localopts.reorder_map=NULL;
	localopts.user_function=false_function;
	localopts.user_data=NULL;
	localopts.clique_list=&best_clique;
	localopts.clique_list_length=1;
	clique_list_count=0;

	v=table[0];
	set_empty(best_clique);
	SET_ADD_ELEMENT(best_clique,v);
	search_weight=g->weights[v];
	if (min_weight && (search_weight >= min_weight)) {
		if (search_weight <= max_weight) {
			/* Found suitable clique. */
			return search_weight;
		}
		search_weight=min_weight-1;
	}
	clique_size[v]=search_weight;
	set_empty(current_clique);

	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	for (i = 1; i < g->n; i++) {
		v=table[i];

		newsize=0;
		newweight=0;
		for (j=0; jweights[table[j]];
				newtable[newsize]=table[j];
				newsize++;
			}
		}


		SET_ADD_ELEMENT(current_clique,v);
		search_weight=sub_weighted_all(newtable,newsize,newweight,
					       g->weights[v],search_weight,
					       clique_size[table[i-1]] +
					       g->weights[v],
					       min_w,max_weight,FALSE,
					       g,&localopts);
		SET_DEL_ELEMENT(current_clique,v);
		if (search_weight < 0) {
			break;
		}

		clique_size[v]=search_weight;

        /*
		if (opts->time_function) {
			gettimeofday(&timeval,NULL);
			times(&tms);
			if (!opts->time_function(entrance_level,
						 i+1,g->n,clique_size[v] *
						 weight_multiplier,
						 (double)(tms.tms_utime-
							  cputimer.tms_utime)/
						 clocks_per_sec,
						 timeval.tv_sec-
						 realtimer.tv_sec+
						 (double)(timeval.tv_usec-
							  realtimer.tv_usec)/
						 1000000,opts)) {
				set_free(current_clique);
				current_clique=NULL;
				break;
			}
		}
        */
	}
	temp_list[temp_count++]=newtable;
	if (min_weight && (search_weight > 0)) {
		/* Requested clique has not been found. */
		return 0;
	}
	return clique_size[table[i-1]];
}


/*
 * weighted_clique_search_all()
 *
 * Searches for all cliques with weight at least min_weight and at most
 * max_weight.  Stores the cliques as opts declares.
 *
 *   table      - the order of the vertices in g to search
 *   start      - first index where the subgraph table[0], ..., table[start]
 *                might include a requested kind of clique
 *   min_weight - minimum weight of clique to search for.  min_weight > 0 !
 *   max_weight - maximum weight of clique to search for.  If no upper limit
 *                is desired, use eg. INT_MAX
 *   maximal    - search only for maximal cliques
 *   g          - the graph
 *   opts       - time printing and clique storage options
 *
 * Cliques found are stored as defined by opts->user_function and
 * opts->clique_list.  opts->time_function is called after each
 * base-level recursion, if non-NULL.
 *
 * clique_size[] must be defined and correct for all values of
 * table[0], ..., table[start-1].
 *
 * Returns the number of cliques stored (not neccessarily number of cliques
 * in graph, if user/time_function aborts).
 */
static int weighted_clique_search_all(int *table, int start,
				      int min_weight, int max_weight,
				      boolean maximal, graph_t *g,
				      clique_options *opts) {
    /*
	struct timeval timeval;
	struct tms tms;
    */
	int i,j;
	int v;
	int *newtable;
	int newsize;
	int newweight;

	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	clique_list_count=0;
	set_empty(current_clique);
	for (i=start; i < g->n; i++) {
		v=table[i];
		clique_size[v]=min_weight;   /* Do not prune here. */

		newsize=0;
		newweight=0;
		for (j=0; jweights[table[j]];
				newsize++;
			}
		}

		SET_ADD_ELEMENT(current_clique,v);
		j=sub_weighted_all(newtable,newsize,newweight,
				   g->weights[v],min_weight-1,INT_MAX,
				   min_weight,max_weight,maximal,g,opts);
		SET_DEL_ELEMENT(current_clique,v);

		if (j<0) {
			/* Abort. */
			break;
		}

        /*
		if (opts->time_function) {
			gettimeofday(&timeval,NULL);
			times(&tms);
			if (!opts->time_function(entrance_level,
						 i+1,g->n,clique_size[v] *
						 weight_multiplier,
						 (double)(tms.tms_utime-
							  cputimer.tms_utime)/
						 clocks_per_sec,
						 timeval.tv_sec-
						 realtimer.tv_sec+
						 (double)(timeval.tv_usec-
							  realtimer.tv_usec)/
						 1000000,opts)) {
				set_free(current_clique);
				current_clique=NULL;
				break;
			}
		}
        */
	}
	temp_list[temp_count++]=newtable;

	return clique_list_count;
}

/*
 * sub_weighted_all()
 *
 * Recursion function for searching for all cliques of given weight.
 *
 *   table      - subset of vertices of graph g
 *   size       - size of table
 *   weight     - total weight of vertices in table
 *   current_weight - weight of clique found so far
 *   prune_low  - ignore all cliques with weight less or equal to this value
 *                (often heaviest clique found so far)  (passed through)
 *   prune_high - maximum weight possible for clique in this subgraph
 *                (passed through)
 *   min_size   - minimum weight of cliques to search for (passed through)
 *                Must be greater than 0.
 *   max_size   - maximum weight of cliques to search for (passed through)
 *                If no upper limit is desired, use eg. INT_MAX
 *   maximal    - search only for maximal cliques
 *   g          - the graph
 *   opts       - storage options
 *
 * All cliques of suitable weight found are stored according to opts.
 *
 * Returns weight of heaviest clique found (prune_low if a heavier clique
 * hasn't been found);  if a clique with weight at least min_size is found
 * then min_size-1 is returned.  If clique storage failed, -1 is returned.
 *
 * The largest clique found smaller than max_weight is stored in
 * best_clique, if non-NULL.
 *
 * Uses current_clique to store the currently-being-searched clique.
 * clique_size[] for all values in table must be defined and correct,
 * otherwise inaccurate results may occur.
 *
 * To search for a single maximum clique, use min_weight==max_weight==INT_MAX,
 * with best_clique non-NULL.  To search for a single given-weight clique,
 * use opts->clique_list and opts->user_function=false_function.  When
 * searching for all cliques, min_weight should be given the minimum weight
 * desired.
 */
static int sub_weighted_all(int *table, int size, int weight,
			    int current_weight, int prune_low, int prune_high,
			    int min_weight, int max_weight, boolean maximal,
			    graph_t *g, clique_options *opts) {
	int i;
	int v,w;
	int *newtable;
	int *p1, *p2;
	int newweight;

	if (current_weight >= min_weight) {
		if ((current_weight <= max_weight) &&
		    ((!maximal) || is_maximal(current_clique,g))) {
			/* We've found one.  Store it. */
			if (!store_clique(current_clique,g,opts)) {
				return -1;
			}
		}
		if (current_weight >= max_weight) {
			/* Clique too heavy. */
			return min_weight-1;
		}
	}
	if (size <= 0) {
		/* current_weight < min_weight, prune_low < min_weight,
		 * so return value is always < min_weight. */
		if (current_weight>prune_low) {
			if (best_clique) {
				best_clique = set_copy(best_clique,current_clique);
			}
			if (current_weight < min_weight)
				return current_weight;
			else
				return min_weight-1;
		} else {
			return prune_low;
		}
	}

	/* Dynamic memory allocation with cache */
	if (temp_count) {
		temp_count--;
		newtable=temp_list[temp_count];
	} else {
		newtable=malloc(g->n * sizeof(int));
	}

	for (i = size-1; i >= 0; i--) {
		v = table[i];
		if (current_weight+clique_size[v] <= prune_low) {
			/* Dealing with subset without heavy enough clique. */
			break;
		}
		if (current_weight+weight <= prune_low) {
			/* Even if all elements are added, won't do. */
			break;
		}

		/* Very ugly code, but works faster than "for (i=...)" */
		p1 = newtable;
		newweight = 0;
		for (p2=table; p2 < table+i; p2++) {
			w = *p2;
			if (GRAPH_IS_EDGE(g, v, w)) {
				*p1 = w;
				newweight += g->weights[w];
				p1++;
			}
		}

		w=g->weights[v];
		weight-=w;
		/* Avoid a few unneccessary loops */
		if (current_weight+w+newweight <= prune_low) {
			continue;
		}

		SET_ADD_ELEMENT(current_clique,v);
		prune_low=sub_weighted_all(newtable,p1-newtable,
					   newweight,
					   current_weight+w,
					   prune_low,prune_high,
					   min_weight,max_weight,maximal,
					   g,opts);
		SET_DEL_ELEMENT(current_clique,v);
		if ((prune_low<0) || (prune_low>=prune_high)) {
			/* Impossible to find larger clique. */
			break;
		}
	}
	temp_list[temp_count++]=newtable;
	return prune_low;
}




/***** Helper functions *****/


/*
 * store_clique()
 *
 * Stores a clique according to given user options.
 *
 *   clique - the clique to store
 *   opts   - storage options
 *
 * Returns FALSE if opts->user_function() returned FALSE; otherwise
 * returns TRUE.
 */
static boolean store_clique(set_t clique, graph_t *g, clique_options *opts) {

	clique_list_count++;

	/* clique_list[] */
	if (opts->clique_list) {
		/*
		 * This has been a major source of bugs:
		 * Has clique_list_count been set to 0 before calling
		 * the recursions?
		 */
		if (clique_list_count <= 0) {
			IGRAPH_FATAL("CLIQUER INTERNAL ERROR: clique_list_count has negative value! Please report as a bug.");
		}
		if (clique_list_count <= opts->clique_list_length)
			opts->clique_list[clique_list_count-1] =
				set_copy(opts->clique_list[clique_list_count-1], clique);
	}

	/* user_function() */
	if (opts->user_function) {
		if (!opts->user_function(clique,g,opts)) {
			/* User function requested abort. */
			return FALSE;
		}
	}

	return TRUE;
}

/*
 * maximalize_clique()
 *
 * Adds greedily all possible vertices in g to set s to make it a maximal
 * clique.
 *
 *   s - clique of vertices to make maximal
 *   g - graph
 *
 * Note: Not very optimized (uses a simple O(n^2) routine), but is called
 *       at maximum once per clique_xxx() call, so it shouldn't matter.
 */
static void maximalize_clique(set_t s,graph_t *g) {
	int i,j;
	boolean add;

	for (i=0; i < g->n; i++) {
		add=TRUE;
		for (j=0; j < g->n; j++) {
			if (SET_CONTAINS_FAST(s,j) && !GRAPH_IS_EDGE(g,i,j)) {
				add=FALSE;
				break;
			}
		}
		if (add) {
			SET_ADD_ELEMENT(s,i);
		}
	}
	return;
}


/*
 * is_maximal()
 *
 * Check whether a clique is maximal or not.
 *
 *   clique - set of vertices in clique
 *   g      - graph
 *
 * Returns TRUE is clique is a maximal clique of g, otherwise FALSE.
 */
static boolean is_maximal(set_t clique, graph_t *g) {
	int i,j;
	int *table;
	int len;
	boolean addable;

	if (temp_count) {
		temp_count--;
		table=temp_list[temp_count];
	} else {
		table=malloc(g->n * sizeof(int));
	}

	len=0;
	for (i=0; i < g->n; i++)
		if (SET_CONTAINS_FAST(clique,i))
			table[len++]=i;

	for (i=0; i < g->n; i++) {
		addable=TRUE;
		for (j=0; jtime_function() requests abort).
 *
 * The returned clique is newly allocated and can be freed by set_free().
 *
 * Note: Does NOT use opts->user_function() or opts->clique_list[].
 */
set_t clique_unweighted_find_single(graph_t *g,int min_size,int max_size,
				    boolean maximal, clique_options *opts) {
	int i;
	int *table;
	set_t s;

	ENTRANCE_SAVE();
	entrance_level++;

	if (opts==NULL)
		opts=&clique_default_options;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);
	ASSERT(min_size>=0);
	ASSERT(max_size>=0);
	ASSERT((max_size==0) || (min_size <= max_size));
	ASSERT(!((min_size==0) && (max_size>0)));
	ASSERT((opts->reorder_function==NULL) || (opts->reorder_map==NULL));

	if ((max_size>0) && (min_size>max_size)) {
		/* state was not changed */
		entrance_level--;
		return NULL;
	}

    /*
	if (clocks_per_sec==0)
		clocks_per_sec=sysconf(_SC_CLK_TCK);
	ASSERT(clocks_per_sec>0);
    */

	/* Dynamic allocation */
	current_clique=set_new(g->n);
	clique_size=malloc(g->n * sizeof(int));
	/* table allocated later */
	temp_list=malloc((g->n+2)*sizeof(int *));
	temp_count=0;

	/* "start clock" */
    /*
	gettimeofday(&realtimer,NULL);
	times(&cputimer);
    */

	/* reorder */
	if (opts->reorder_function) {
		table=opts->reorder_function(g,FALSE);
	} else if (opts->reorder_map) {
		table=reorder_duplicate(opts->reorder_map,g->n);
	} else {
		table=reorder_ident(g->n);
	}
	ASSERT(reorder_is_bijection(table,g->n));


	if (unweighted_clique_search_single(table,min_size,g,opts)==0) {
		set_free(current_clique);
		current_clique=NULL;
		goto cleanreturn;
	}
	if (maximal && (min_size>0)) {
		maximalize_clique(current_clique,g);

		if ((max_size > 0) && (set_size(current_clique) > max_size)) {
			clique_options localopts;

			s = set_new(g->n);
			localopts.time_function = opts->time_function;
			localopts.output = opts->output;
			localopts.user_function = false_function;
			localopts.clique_list = &s;
			localopts.clique_list_length = 1;

			for (i=0; i < g->n-1; i++)
				if (clique_size[table[i]]>=min_size)
					break;
			if (unweighted_clique_search_all(table,i,min_size,
							 max_size,maximal,
							 g,&localopts)) {
				set_free(current_clique);
				current_clique=s;
			} else {
				set_free(current_clique);
				current_clique=NULL;
			}
		}
	}

    cleanreturn:
	s=current_clique;

	/* Free resources */
	for (i=0; i < temp_count; i++)
		free(temp_list[i]);
	free(temp_list);
	free(table);
	free(clique_size);

	ENTRANCE_RESTORE();
	entrance_level--;

	return s;
}


/*
 * clique_unweighted_find_all()
 *
 * Find all cliques with size at least min_size and at most max_size.
 *
 *   g        - the graph
 *   min_size - minimum size of cliques to search for.  If min_size==0,
 *              searches for maximum cliques.
 *   max_size - maximum size of cliques to search for.  If max_size==0, no
 *              upper limit is used.  If min_size==0, this must also be 0.
 *   maximal  - require cliques to be maximal cliques
 *   opts     - time printing and clique storage options
 *
 * Returns the number of cliques found.  This can be less than the number
 * of cliques in the graph iff opts->time_function() or opts->user_function()
 * returns FALSE (request abort).
 *
 * The cliques found are stored in opts->clique_list[] and
 * opts->user_function() is called with them (if non-NULL).  The cliques
 * stored in opts->clique_list[] are newly allocated, and can be freed
 * by set_free().
 */
CLIQUER_LARGE_INT clique_unweighted_find_all(graph_t *g, int min_size, int max_size,
                                             boolean maximal, clique_options *opts) {
	int i;
	int *table;
        CLIQUER_LARGE_INT count;

	ENTRANCE_SAVE();
	entrance_level++;

	if (opts==NULL)
		opts=&clique_default_options;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);
	ASSERT(min_size>=0);
	ASSERT(max_size>=0);
	ASSERT((max_size==0) || (min_size <= max_size));
	ASSERT(!((min_size==0) && (max_size>0)));
	ASSERT((opts->reorder_function==NULL) || (opts->reorder_map==NULL));

	if ((max_size>0) && (min_size>max_size)) {
		/* state was not changed */
		entrance_level--;
		return 0;
	}

    /*
	if (clocks_per_sec==0)
		clocks_per_sec=sysconf(_SC_CLK_TCK);
	ASSERT(clocks_per_sec>0);
    */

	/* Dynamic allocation */
	current_clique=set_new(g->n);
	clique_size=malloc(g->n * sizeof(int));
	/* table allocated later */
	temp_list=malloc((g->n+2)*sizeof(int *));
	temp_count=0;

	clique_list_count=0;
	memset(clique_size,0,g->n * sizeof(int));

	/* "start clock" */
    /*
	gettimeofday(&realtimer,NULL);
	times(&cputimer);
    */

	/* reorder */
	if (opts->reorder_function) {
		table=opts->reorder_function(g,FALSE);
	} else if (opts->reorder_map) {
		table=reorder_duplicate(opts->reorder_map,g->n);
	} else {
		table=reorder_ident(g->n);
	}
	ASSERT(reorder_is_bijection(table,g->n));


	/* Search as normal until there is a chance to find a suitable
	 * clique. */
	if (unweighted_clique_search_single(table,min_size,g,opts)==0) {
		count=0;
		goto cleanreturn;
	}

	if (min_size==0 && max_size==0) {
		min_size=max_size=clique_size[table[g->n-1]];
		maximal=FALSE;  /* No need to test, since we're searching
				 * for maximum cliques. */
	}
	if (max_size==0) {
		max_size=INT_MAX;
	}

	for (i=0; i < g->n-1; i++)
		if (clique_size[table[i]] >= min_size)
			break;
	count=unweighted_clique_search_all(table,i,min_size,max_size,
					   maximal,g,opts);

  cleanreturn:
	/* Free resources */
	for (i=0; itime_function() requests abort).
 *
 * The returned clique is newly allocated and can be freed by set_free().
 *
 * Note: Does NOT use opts->user_function() or opts->clique_list[].
 * Note: Automatically uses clique_unweighted_find_single if all vertex
 *       weights are the same.
 */
set_t clique_find_single(graph_t *g,int min_weight,int max_weight,
			 boolean maximal, clique_options *opts) {
	int i;
	int *table;
	set_t s;

	ENTRANCE_SAVE();
	entrance_level++;

	if (opts==NULL)
		opts=&clique_default_options;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);
	ASSERT(min_weight>=0);
	ASSERT(max_weight>=0);
	ASSERT((max_weight==0) || (min_weight <= max_weight));
	ASSERT(!((min_weight==0) && (max_weight>0)));
	ASSERT((opts->reorder_function==NULL) || (opts->reorder_map==NULL));

	if ((max_weight>0) && (min_weight>max_weight)) {
		/* state was not changed */
		entrance_level--;
		return NULL;
	}

    /*
	if (clocks_per_sec==0)
		clocks_per_sec=sysconf(_SC_CLK_TCK);
	ASSERT(clocks_per_sec>0);
    */

	/* Check whether we can use unweighted routines. */
	if (!graph_weighted(g)) {
		min_weight=DIV_UP(min_weight,g->weights[0]);
		if (max_weight) {
			max_weight=DIV_DOWN(max_weight,g->weights[0]);
			if (max_weight < min_weight) {
				/* state was not changed */
				entrance_level--;
				return NULL;
			}
		}

		weight_multiplier = g->weights[0];
		entrance_level--;
		s=clique_unweighted_find_single(g,min_weight,max_weight,
						maximal,opts);
		ENTRANCE_RESTORE();
		return s;
	}

	/* Dynamic allocation */
	current_clique=set_new(g->n);
	best_clique=set_new(g->n);
	clique_size=malloc(g->n * sizeof(int));
	memset(clique_size, 0, g->n * sizeof(int));
	/* table allocated later */
	temp_list=malloc((g->n+2)*sizeof(int *));
	temp_count=0;

	clique_list_count=0;

	/* "start clock" */
    /*
	gettimeofday(&realtimer,NULL);
	times(&cputimer);
    */

	/* reorder */
	if (opts->reorder_function) {
		table=opts->reorder_function(g,TRUE);
	} else if (opts->reorder_map) {
		table=reorder_duplicate(opts->reorder_map,g->n);
	} else {
		table=reorder_ident(g->n);
	}
	ASSERT(reorder_is_bijection(table,g->n));

	if (max_weight==0)
		max_weight=INT_MAX;

	if (weighted_clique_search_single(table,min_weight,max_weight,
					  g,opts)==0) {
		/* Requested clique has not been found. */
		set_free(best_clique);
		best_clique=NULL;
		goto cleanreturn;
	}
	if (maximal && (min_weight>0)) {
		maximalize_clique(best_clique,g);
		if (graph_subgraph_weight(g,best_clique) > max_weight) {
			clique_options localopts;

			localopts.time_function = opts->time_function;
			localopts.output = opts->output;
			localopts.user_function = false_function;
			localopts.clique_list = &best_clique;
			localopts.clique_list_length = 1;

			for (i=0; i < g->n-1; i++)
				if ((clique_size[table[i]] >= min_weight) ||
				    (clique_size[table[i]] == 0))
					break;
			if (!weighted_clique_search_all(table,i,min_weight,
							max_weight,maximal,
							g,&localopts)) {
				set_free(best_clique);
				best_clique=NULL;
			}
		}
	}

 cleanreturn:
	s=best_clique;

	/* Free resources */
	for (i=0; i < temp_count; i++)
		free(temp_list[i]);
	free(temp_list);
	temp_list=NULL;
	temp_count=0;
	free(table);
	set_free(current_clique);
	current_clique=NULL;
	free(clique_size);
	clique_size=NULL;

	ENTRANCE_RESTORE();
	entrance_level--;

	return s;
}





/*
 * clique_find_all()
 *
 * Find all cliques with weight at least min_weight and at most max_weight.
 *
 *   g          - the graph
 *   min_weight - minimum weight of cliques to search for.  If min_weight==0,
 *                searches for maximum weight cliques.
 *   max_weight - maximum weight of cliques to search for.  If max_weight==0,
 *                no upper limit is used.  If min_weight==0, max_weight must
 *                also be 0.
 *   maximal    - require cliques to be maximal cliques
 *   opts       - time printing and clique storage options
 *
 * Returns the number of cliques found.  This can be less than the number
 * of cliques in the graph iff opts->time_function() or opts->user_function()
 * returns FALSE (request abort).
 *
 * The cliques found are stored in opts->clique_list[] and
 * opts->user_function() is called with them (if non-NULL).  The cliques
 * stored in opts->clique_list[] are newly allocated, and can be freed
 * by set_free().
 *
 * Note: Automatically uses clique_unweighted_find_all if all vertex
 *       weights are the same.
 */
int clique_find_all(graph_t *g, int min_weight, int max_weight,
		    boolean maximal, clique_options *opts) {
        int i,n;
	int *table;
        CLIQUER_LARGE_INT r;

	ENTRANCE_SAVE();
	entrance_level++;

	if (opts==NULL)
		opts=&clique_default_options;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);
	ASSERT(min_weight>=0);
	ASSERT(max_weight>=0);
	ASSERT((max_weight==0) || (min_weight <= max_weight));
	ASSERT(!((min_weight==0) && (max_weight>0)));
	ASSERT((opts->reorder_function==NULL) || (opts->reorder_map==NULL));

	if ((max_weight>0) && (min_weight>max_weight)) {
		/* state was not changed */
		entrance_level--;
		return 0;
	}

    /*
	if (clocks_per_sec==0)
		clocks_per_sec=sysconf(_SC_CLK_TCK);
	ASSERT(clocks_per_sec>0);
    */

	if (!graph_weighted(g)) {
		min_weight=DIV_UP(min_weight,g->weights[0]);
		if (max_weight) {
			max_weight=DIV_DOWN(max_weight,g->weights[0]);
			if (max_weight < min_weight) {
				/* state was not changed */
				entrance_level--;
				return 0;
			}
		}

		weight_multiplier = g->weights[0];
		entrance_level--;
                r=clique_unweighted_find_all(g,min_weight,max_weight,maximal,
					     opts);
		ENTRANCE_RESTORE();
                return r;
	}

	/* Dynamic allocation */
	current_clique=set_new(g->n);
	best_clique=set_new(g->n);
	clique_size=malloc(g->n * sizeof(int));
	memset(clique_size, 0, g->n * sizeof(int));
	/* table allocated later */
	temp_list=malloc((g->n+2)*sizeof(int *));
	temp_count=0;

	/* "start clock" */
    /*
	gettimeofday(&realtimer,NULL);
	times(&cputimer);
    */

	/* reorder */
	if (opts->reorder_function) {
		table=opts->reorder_function(g,TRUE);
	} else if (opts->reorder_map) {
		table=reorder_duplicate(opts->reorder_map,g->n);
	} else {
		table=reorder_ident(g->n);
	}
	ASSERT(reorder_is_bijection(table,g->n));

	/* First phase */
	n=weighted_clique_search_single(table,min_weight,INT_MAX,g,opts);
	if (n==0) {
		/* Requested clique has not been found. */
		goto cleanreturn;
	}

	if (min_weight==0) {
		min_weight=n;
		max_weight=n;
		maximal=FALSE;  /* They're maximum cliques already. */
	}
	if (max_weight==0)
		max_weight=INT_MAX;

	for (i=0; i < g->n; i++)
		if ((clique_size[table[i]] >= min_weight) ||
		    (clique_size[table[i]] == 0))
			break;

	/* Second phase */
	n=weighted_clique_search_all(table,i,min_weight,max_weight,maximal,
				     g,opts);

      cleanreturn:
	/* Free resources */
	for (i=0; i < temp_count; i++)
		free(temp_list[i]);
	free(temp_list);
	free(table);
	set_free(current_clique);
	set_free(best_clique);
	free(clique_size);

	ENTRANCE_RESTORE();
	entrance_level--;

	return n;
}
















#if 0
/*
 * clique_print_time()
 *
 * Reports current running information every 0.1 seconds or when values
 * change.
 *
 *   level    - re-entrance level
 *   i        - current recursion level
 *   n        - maximum recursion level
 *   max      - weight of heaviest clique found
 *   cputime  - CPU time used in algorithm so far
 *   realtime - real time used in algorithm so far
 *   opts     - prints information to (FILE *)opts->output (or stdout if NULL)
 *
 * Returns always TRUE  (ie. never requests abort).
 */
boolean clique_print_time(int level, int i, int n, int max,
			  double cputime, double realtime,
			  clique_options *opts) {
	static float prev_time=100;
	static int prev_i=100;
	static int prev_max=100;
	static int prev_level=0;
	FILE *fp=opts->output;
	int j;

	if (fp==NULL)
		fp=stdout;

	if (ABS(prev_time-realtime)>0.1 || i==n || ioutput (or stdout if NULL)
 *
 * Returns always TRUE  (ie. never requests abort).
 */
boolean clique_print_time_always(int level, int i, int n, int max,
				 double cputime, double realtime,
				 clique_options *opts) {
	static float prev_time=100;
	static int prev_i=100;
	FILE *fp=opts->output;
	int j;

	if (fp==NULL)
		fp=stdout;

	for (j=1; j

/* This is an igraph-specific modification to cliquer.
 * We use a 64-bit CLIQUER_LARGE_INT (even on 32-bit systems) in places
 * which are prone to overflow. Since cliquer indicates interruption by
 * returning -1 times the clique count, the effect of overflow is that
 * it returns a partial (i.e. incorrect) result without warning. */
#include 
#ifndef CLIQUER_LARGE_INT
#define CLIQUER_LARGE_INT int64_t
#endif

#include "set.h"
#include "graph.h"
#include "reorder.h"

typedef struct _clique_options clique_options;
struct _clique_options {
	int *(*reorder_function)(graph_t *, boolean);
	int *reorder_map;

	/* arguments:  level, n, max, user_time, system_time, opts */
	boolean (*time_function)(int,int,int,int,double,double,
				 clique_options *);
	FILE *output;

	boolean (*user_function)(set_t,graph_t *,clique_options *);
	void *user_data;
	set_t *clique_list;
	int clique_list_length;
};

/* Weighted clique functions */
extern int clique_max_weight(graph_t *g,clique_options *opts);
extern set_t clique_find_single(graph_t *g,int min_weight,int max_weight,
				boolean maximal, clique_options *opts);
extern int clique_find_all(graph_t *g, int req_weight, boolean exact,
			   boolean maximal, clique_options *opts);

/* Unweighted clique functions */
#define clique_unweighted_max_size clique_unweighted_max_weight
extern int clique_unweighted_max_weight(graph_t *g, clique_options *opts);
extern set_t clique_unweighted_find_single(graph_t *g,int min_size,
					   int max_size,boolean maximal,
					   clique_options *opts);
extern CLIQUER_LARGE_INT clique_unweighted_find_all(graph_t *g, int min_size, int max_size,
                                                    boolean maximal, clique_options *opts);

/* Time printing functions */
/*
extern boolean clique_print_time(int level, int i, int n, int max,
				 double cputime, double realtime,
				 clique_options *opts);
extern boolean clique_print_time_always(int level, int i, int n, int max,
					double cputime, double realtime,
					clique_options *opts);
*/

/* Alternate spelling (let's be a little forgiving): */
#define cliquer_options clique_options
#define cliquer_default_options clique_default_options

#endif /* !CLIQUER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/cliquer_graph.c0000644000175100001710000003777300000000000026564 0ustar00runnerdocker00000000000000
/*
 * This file contains the graph handling routines.
 *
 * Copyright (C) 2002 Sampo Niskanen, Patric Östergård.
 * Licensed under the GNU GPL, read the file LICENSE for details.
 */


#include 
#include 
#include 
#include "graph.h"


/*
static graph_t *graph_read_dimacs_binary(FILE *fp,char *firstline);
static graph_t *graph_read_dimacs_ascii(FILE *fp,char *firstline);
*/


/*
 * graph_new()
 *
 * Returns a newly allocated graph with n vertices all with weight 1,
 * and no edges.
 */
graph_t *graph_new(int n) {
	graph_t *g;
	int i;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(n>0);

	g=malloc(sizeof(graph_t));
	g->n=n;
	g->edges=malloc(g->n * sizeof(set_t));
	g->weights=malloc(g->n * sizeof(int));
	for (i=0; i < g->n; i++) {
		g->edges[i]=set_new(n);
		g->weights[i]=1;
	}
	return g;
}

/*
 * graph_free()
 *
 * Frees the memory associated with the graph g.
 */
void graph_free(graph_t *g) {
	int i;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);
	ASSERT(g->n > 0);

	for (i=0; i < g->n; i++) {
		set_free(g->edges[i]);
	}
	free(g->weights);
	free(g->edges);
	free(g);
	return;
}


/*
 * graph_resize()
 *
 * Resizes graph g to given size.  If size > g->n, the new vertices are
 * not connected to any others and their weights are set to 1.
 * If size < g->n, the last g->n - size vertices are removed.
 */
void graph_resize(graph_t *g, int size) {
	int i;

	ASSERT(g!=NULL);
	ASSERT(g->n > 0);
	ASSERT(size > 0);

	if (g->n == size)
		return;

	/* Free/alloc extra edge-sets */
	for (i=size; i < g->n; i++)
		set_free(g->edges[i]);
	g->edges=realloc(g->edges, size * sizeof(set_t));
	for (i=g->n; i < size; i++)
		g->edges[i]=set_new(size);

	/* Resize original sets */
	for (i=0; i < MIN(g->n,size); i++) {
		g->edges[i]=set_resize(g->edges[i],size);
	}

	/* Weights */
	g->weights=realloc(g->weights,size * sizeof(int));
	for (i=g->n; iweights[i]=1;

	g->n=size;
	return;
}

/*
 * graph_crop()
 *
 * Resizes the graph so as to remove all highest-valued isolated vertices.
 */
void graph_crop(graph_t *g) {
	int i;

	for (i=g->n-1; i>=1; i--)
		if (set_size(g->edges[i])>0)
			break;
	graph_resize(g,i+1);
	return;
}


/*
 * graph_weighted()
 *
 * Returns TRUE if all vertex weights of graph g are all the same.
 *
 * Note: Does NOT require weights to be 1.
 */
boolean graph_weighted(graph_t *g) {
	int i,w;

	w=g->weights[0];
	for (i=1; i < g->n; i++)
		if (g->weights[i] != w)
			return TRUE;
	return FALSE;
}

/*
 * graph_edge_count()
 *
 * Returns the number of edges in graph g.
 */
int graph_edge_count(graph_t *g) {
	int i;
	int count=0;

	for (i=0; i < g->n; i++) {
		count += set_size(g->edges[i]);
	}
	return count/2;
}


#if 0
/*
 * graph_write_dimacs_ascii_file()
 *
 * Writes an ASCII dimacs-format file of graph g, with comment, to
 * given file.
 *
 * Returns TRUE if successful, FALSE if an error occurred.
 */
boolean graph_write_dimacs_ascii_file(graph_t *g, char *comment, char *file) {
	FILE *fp;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(file!=NULL);

	if ((fp=fopen(file,"wb"))==NULL)
		return FALSE;
	if (!graph_write_dimacs_ascii(g,comment,fp)) {
		fclose(fp);
		return FALSE;
	}
	fclose(fp);
	return TRUE;
}

/*
 * graph_write_dimacs_ascii()
 *
 * Writes an ASCII dimacs-format file of graph g, with comment, to the
 * file stream fp.
 *
 * Returns TRUE if successful, FALSE if an error occurred.
 */
boolean graph_write_dimacs_ascii(graph_t *g, char *comment, FILE *fp) {
	int i,j;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(graph_test(g,NULL));
	ASSERT(fp!=NULL);

	if (comment)
		fprintf(fp,"c %s\n",comment);
	fprintf(fp,"p edge %d %d\n",g->n,graph_edge_count(g));
	for (i=0; i < g->n; i++)
		if (g->weights[i]!=1)
			fprintf(fp,"n %d %d\n",i+1,g->weights[i]);
	for (i=0; i < g->n; i++)
		for (j=0; j= headersize) {  \
	headersize+=1024;                    \
	header=realloc(header,headersize);   \
}                                            \
strncat(header,s,1000);                      \
headerlength+=strlen(s);

boolean graph_write_dimacs_binary(graph_t *g, char *comment,FILE *fp) {
	char *buf;
	char *header=NULL;
	int headersize=0;
	int headerlength=0;
	int i,j;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(graph_test(g,NULL));
	ASSERT(fp!=NULL);

	buf=malloc(MAX(1024,g->n/8+1));
	header=malloc(1024);
	header[0]=0;
	headersize=1024;
	if (comment) {
		strcpy(buf,"c ");
		strncat(buf,comment,1000);
		strcat(buf,"\n");
		STR_APPEND(buf);
	}
	sprintf(buf,"p edge %d %d\n",g->n,graph_edge_count(g));
	STR_APPEND(buf);
	for (i=0; i < g->n; i++) {
		if (g->weights[i]!=1) {
			sprintf(buf,"n %d %d\n",i+1,g->weights[i]);
			STR_APPEND(buf);
		}
	}

	fprintf(fp,"%d\n",(int)strlen(header));
	fprintf(fp,"%s",header);
	free(header);

	for (i=0; i < g->n; i++) {
		memset(buf,0,i/8+1);
		for (j=0; j=strlen(str))  /* blank line */
		return TRUE;
	if (str[i+1]!=0 && !isspace(str[i+1]))  /* not 1-char field */
		return FALSE;

	switch (str[i]) {
	case 'c':
		return TRUE;
	case 'p':
		if (g->n != 0)
			return FALSE;
		if (sscanf(str," p %15s %d %d %2s",tmp,&(g->n),&i,tmp)!=3)
			return FALSE;
		if (g->n <= 0)
			return FALSE;
		g->edges=calloc(g->n,sizeof(set_t));
		for (i=0; in; i++)
			g->edges[i]=set_new(g->n);
		g->weights=calloc(g->n,sizeof(int));
		for (i=0; in; i++)
			g->weights[i]=1;
		return TRUE;
	case 'n':
		if ((g->n <= 0) || (g->weights == NULL))
			return FALSE;
		if (sscanf(str," n %d %d %2s",&i,&w,tmp)!=2)
			return FALSE;
		if (i<1 || i>g->n)
			return FALSE;
		if (w<=0)
			return FALSE;
		g->weights[i-1]=w;
		return TRUE;
	case 'e':
		if ((g->n <= 0) || (g->edges == NULL))
			return FALSE;
		if (sscanf(str," e %d %d %2s",&i,&j,tmp)!=2)
			return FALSE;
		if (i<1 || j<1 || i>g->n || j>g->n)
			return FALSE;
		if (i==j)   /* We want antireflexive graphs. */
			return TRUE;
		GRAPH_ADD_EDGE(g,i-1,j-1);
		return TRUE;
	case 'd':
	case 'v':
	case 'x':
		return TRUE;
	default:
		fprintf(stderr,"Warning: ignoring field '%c' in "
			"input.\n",str[i]);
		return TRUE;
	}
}


/*
 * graph_read_dimacs_binary()
 *
 * Reads a dimacs-format binary file from file stream fp with the first
 * line being firstline.
 *
 * Returns the newly-allocated graph or NULL if an error occurred.
 *
 * TODO: This function leaks memory when reading erroneous files.
 */
static graph_t *graph_read_dimacs_binary(FILE *fp,char *firstline) {
	int length=0;
	graph_t *g;
	int i,j;
	char *buffer;
	char *start;
	char *end;
	char **buf;
	char tmp[10];

	if (sscanf(firstline," %d %2s",&length,tmp)!=1)
		return NULL;
	if (length<=0) {
		fprintf(stderr,"Malformed preamble: preamble size < 0.\n");
		return NULL;
	}
	buffer=malloc(length+2);
	if (fread(buffer,1,length,fp)n <= 0) {
		fprintf(stderr,"Malformed preamble: number of "
			"vertices <= 0\n");
		free(g);
		return NULL;
	}

	/* Binary part. */
	buf=calloc(g->n,sizeof(char*));
	for (i=0; i < g->n; i++) {
		buf[i]=calloc(g->n,1);
		if (fread(buf[i],1,i/8+1,fp) < (i/8+1)) {
			fprintf(stderr,"Unexpected end of file when "
				"reading graph.\n");
			return NULL;
		}
	}

	for (i=0; i < g->n; i++) {
		for (j=0; jn <= 0) {
		free(g);
		fprintf(stderr,"Unexpected end of file when reading graph.\n");
		return NULL;
	}

	return g;
}
#endif


#if 0
/*
 * graph_print()
 *
 * Prints a representation of the graph g to stdout (along with any errors
 * noticed).  Mainly useful for debugging purposes and trivial output.
 *
 * The output consists of a first line describing the dimensions and then
 * one line per vertex containing the vertex number (numbered 0,...,n-1),
 * the vertex weight (if the graph is weighted), "->" and then a list
 * of all vertices it is adjacent to.
 */
void graph_print(graph_t *g) {
	int i,j;
	int asymm=0;
	int refl=0;
	int nonpos=0;
	int extra=0;
	unsigned int weight=0;
	boolean weighted;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);

	if (g==NULL) {
		printf("   WARNING: Graph pointer is NULL!\n");
		return;
	}
	if (g->n <= 0) {
		printf("   WARNING: Graph has %d vertices "
		       "(should be positive)!\n",g->n);
		return;
	}

	weighted=graph_weighted(g);

	printf("%s graph has %d vertices, %d edges (density %.2f).\n",
	       weighted?"Weighted":((g->weights[0]==1)?
				    "Unweighted":"Semi-weighted"),
	       g->n,graph_edge_count(g),
	       (float)graph_edge_count(g)/((float)(g->n - 1)*(g->n)/2));

	for (i=0; i < g->n; i++) {
		printf("%2d",i);
		if (weighted) {
			printf(" w=%d",g->weights[i]);
			if (g->weights[i] <= 0) {
				printf("*NON-POSITIVE*");
				nonpos++;
			}
		}
		if (weight < INT_MAX)
			weight+=g->weights[i];
		printf(" ->");
		for (j=0; j < g->n; j++) {
			if (SET_CONTAINS_FAST(g->edges[i],j)) {
				printf(" %d",j);
				if (i==j) {
					printf("*REFLEXIVE*");
					refl++;
				}
				if (!SET_CONTAINS_FAST(g->edges[j],i)) {
					printf("*ASYMMERTIC*");
					asymm++;
				}
			}
		}
		for (j=g->n; j < SET_ARRAY_LENGTH(g->edges[i])*ELEMENTSIZE;
		     j++) {
			if (SET_CONTAINS_FAST(g->edges[i],j)) {
				printf(" %d*NON-EXISTENT*",j);
				extra++;
			}
		}
		printf("\n");
	}

	if (asymm)
		printf("   WARNING: Graph contained %d asymmetric edges!\n",
		       asymm);
	if (refl)
		printf("   WARNING: Graph contained %d reflexive edges!\n",
		       refl);
	if (nonpos)
		printf("   WARNING: Graph contained %d non-positive vertex "
		       "weights!\n",nonpos);
	if (extra)
		printf("   WARNING: Graph contained %d edges to "
		       "non-existent vertices!\n",extra);
	if (weight>=INT_MAX)
		printf("   WARNING: Total graph weight >= INT_MAX!\n");
	return;
}


/*
 * graph_test()
 *
 * Tests graph g to be valid.  Checks that g is non-NULL, the edges are
 * symmetric and anti-reflexive, and that all vertex weights are positive.
 * If output is non-NULL, prints a few lines telling the status of the graph
 * to file descriptor output.
 *
 * Returns TRUE if the graph is valid, FALSE otherwise.
 */
boolean graph_test(graph_t *g,FILE *output) {
	int i,j;
	int edges=0;
	int asymm=0;
	int nonpos=0;
	int refl=0;
	int extra=0;
	unsigned int weight=0;
	boolean weighted;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);

	if (g==NULL) {
		if (output)
			fprintf(output,"   WARNING: Graph pointer is NULL!\n");
		return FALSE;
	}

	weighted=graph_weighted(g);

	for (i=0; i < g->n; i++) {
		if (g->edges[i]==NULL) {
			if (output)
				fprintf(output,"   WARNING: Graph edge set "
					"NULL!\n"
					"   (further warning suppressed)\n");
			return FALSE;
		}
		if (SET_MAX_SIZE(g->edges[i]) < g->n) {
			if (output)
				fprintf(output,"   WARNING: Graph edge set "
					"too small!\n"
					"   (further warnings suppressed)\n");
			return FALSE;
		}
		for (j=0; j < g->n; j++) {
			if (SET_CONTAINS_FAST(g->edges[i],j)) {
				edges++;
				if (i==j) {
					refl++;
				}
				if (!SET_CONTAINS_FAST(g->edges[j],i)) {
					asymm++;
				}
			}
		}
		for (j=g->n; j < SET_ARRAY_LENGTH(g->edges[i])*ELEMENTSIZE;
		     j++) {
			if (SET_CONTAINS_FAST(g->edges[i],j))
				extra++;
		}
		if (g->weights[i] <= 0)
			nonpos++;
		if (weightweights[i];
	}

	edges/=2;  /* Each is counted twice. */

	if (output) {
		/* Semi-weighted means all weights are equal, but not 1. */
		fprintf(output,"%s graph has %d vertices, %d edges "
			"(density %.2f).\n",
			weighted?"Weighted":
			((g->weights[0]==1)?"Unweighted":"Semi-weighted"),
			g->n,edges,(float)edges/((float)(g->n - 1)*(g->n)/2));

		if (asymm)
			fprintf(output,"   WARNING: Graph contained %d "
				"asymmetric edges!\n",asymm);
		if (refl)
			fprintf(output,"   WARNING: Graph contained %d "
				"reflexive edges!\n",refl);
		if (nonpos)
			fprintf(output,"   WARNING: Graph contained %d "
				"non-positive vertex weights!\n",nonpos);
		if (extra)
			fprintf(output,"   WARNING: Graph contained %d edges "
				"to non-existent vertices!\n",extra);
		if (weight>=INT_MAX)
			fprintf(output,"   WARNING: Total graph weight >= "
				"INT_MAX!\n");
		if (asymm==0 && refl==0 && nonpos==0 && extra==0 &&
		    weight=INT_MAX)
		return FALSE;

	return TRUE;
}


/*
 * graph_test_regular()
 *
 * Returns the vertex degree for regular graphs, or -1 if the graph is
 * not regular.
 */
int graph_test_regular(graph_t *g) {
	int i,n;

	n=set_size(g->edges[0]);

	for (i=1; i < g->n; i++) {
		if (set_size(g->edges[i]) != n)
			return -1;
	}
	return n;
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/cliquerconf.h0000644000175100001710000000361200000000000026237 0ustar00runnerdocker00000000000000
#ifndef CLIQUERCONF_H
#define CLIQUERCONF_H

/*
 * setelement is the basic memory type used in sets.  It is often fastest
 * to be as large as can fit into the CPU registers.
 *
 * ELEMENTSIZE is the size of one setelement, measured in bits.  It must
 * be either 16, 32 or 64  (otherwise additional changes must be made to
 * the source).
 *
 * The default is to use "unsigned long int" and attempt to guess the
 * size using , which should work pretty well.  Check functioning
 * with "make test".
 */

/* typedef unsigned long int setelement; */
/* #define ELEMENTSIZE 64 */


/*
 * INLINE is a command prepended to function declarations to instruct the
 * compiler to inline the function.  If inlining is not desired, define blank.
 *
 * The default is to use "inline", which is recognized by most compilers.
 */

/* #define INLINE */
/* #define INLINE __inline__ */
#if __STDC_VERSION__ >= 199901L
 #define INLINE inline
#else
 #if defined(_MSC_VER)
  #define INLINE __inline
 #elif defined(__GNUC__)
  #define INLINE __inline__
 #else
  #define INLINE
 #endif
#endif


/*
 * Set handling functions are defined as static functions in set.h for
 * performance reasons.  This may cause unnecessary warnings from the
 * compiler.  Some compilers (such as GCC) have the possibility to turn
 * off the warnings on a per-function basis using a flag prepended to
 * the function declaration.
 *
 * The default is to use the correct attribute when compiling with GCC,
 * or no flag otherwise.
 */

/* #define UNUSED_FUNCTION __attribute__((unused)) */
/* #define UNUSED_FUNCTION */


/*
 * Uncommenting the following will disable all assertions  (checks that
 * function arguments and other variables are correct).  This is highly
 * discouraged, as it allows bugs to go unnoticed easier.  The assertions
 * are set so that they do not slow down programs notably.
 */

/* #define ASSERT(x) */

#endif /* !CLIQUERCONF_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/graph.h0000644000175100001710000000377300000000000025036 0ustar00runnerdocker00000000000000
#ifndef CLIQUER_GRAPH_H
#define CLIQUER_GRAPH_H

#include "set.h"

typedef struct _graph_t graph_t;
struct _graph_t {
	int n;             /* Vertices numbered 0...n-1 */
	set_t *edges;      /* A list of n sets (the edges). */
	int *weights;      /* A list of n vertex weights. */
};


#define GRAPH_IS_EDGE_FAST(g,i,j)  (SET_CONTAINS_FAST((g)->edges[(i)],(j)))
#define GRAPH_IS_EDGE(g,i,j) (((i)<((g)->n))?SET_CONTAINS((g)->edges[(i)], \
							  (j)):FALSE)
#define GRAPH_ADD_EDGE(g,i,j) do {            \
	SET_ADD_ELEMENT((g)->edges[(i)],(j)); \
	SET_ADD_ELEMENT((g)->edges[(j)],(i)); \
} while (FALSE)
#define GRAPH_DEL_EDGE(g,i,j) do {            \
	SET_DEL_ELEMENT((g)->edges[(i)],(j)); \
	SET_DEL_ELEMENT((g)->edges[(j)],(i)); \
} while (FALSE)


extern graph_t *graph_new(int n);
extern void graph_free(graph_t *g);
extern void graph_resize(graph_t *g, int size);
extern void graph_crop(graph_t *g);

extern boolean graph_weighted(graph_t *g);
extern int graph_edge_count(graph_t *g);

/*
extern graph_t *graph_read_dimacs(FILE *fp);
extern graph_t *graph_read_dimacs_file(char *file);
extern boolean graph_write_dimacs_ascii(graph_t *g, char *comment,FILE *fp);
extern boolean graph_write_dimacs_ascii_file(graph_t *g,char *comment,
					     char *file);
extern boolean graph_write_dimacs_binary(graph_t *g, char *comment,FILE *fp);
extern boolean graph_write_dimacs_binary_file(graph_t *g, char *comment,
					      char *file);

extern void graph_print(graph_t *g);
extern boolean graph_test(graph_t *g, FILE *output);
extern int graph_test_regular(graph_t *g);
*/

UNUSED_FUNCTION INLINE
static int graph_subgraph_weight(graph_t *g,set_t s) {
	unsigned int i,j;
	int count=0;
	setelement e;

	for (i=0; iweights[i*ELEMENTSIZE+j];
				e = e>>1;
			}
		}
	}
	return count;
}

UNUSED_FUNCTION INLINE
static int graph_vertex_degree(graph_t *g, int v) {
	return set_size(g->edges[v]);
}

#endif /* !CLIQUER_GRAPH_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/misc.h0000644000175100001710000000174300000000000024663 0ustar00runnerdocker00000000000000
#ifndef CLIQUER_MISC_H
#define CLIQUER_MISC_H

#include "igraph_error.h"
#include "cliquerconf.h"

/*
 * We #define boolean instead of using a typedef because nauty.h uses it
 * also.  AFAIK, there is no way to check for an existing typedef, and
 * re-typedefing is illegal (even when using exactly the same datatype!).
 */
#ifndef boolean
#define boolean int
#endif


/*
 * The original cliquer source has some functions incorrectly marked as unused,
 * thus leave this undefined.
 */
#define UNUSED_FUNCTION


/*
 * Default inlining directive:  "inline"
 */
#ifndef INLINE
#define INLINE inline
#endif


#include 
#include 

#ifndef ASSERT
#define ASSERT IGRAPH_ASSERT
#endif /* !ASSERT */


#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (!FALSE)
#endif


#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
#ifndef MAX
#define MAX(a,b) (((a)>(b))?(a):(b))
#endif
#ifndef ABS
#define ABS(v)  (((v)<0)?(-(v)):(v))
#endif

#endif /* !CLIQUER_MISC_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/reorder.c0000644000175100001710000002140500000000000025362 0ustar00runnerdocker00000000000000
/*
 * This file contains the vertex reordering routines.
 *
 * Copyright (C) 2002 Sampo Niskanen, Patric Östergård.
 * Licensed under the GNU GPL, read the file LICENSE for details.
 */

#include "reorder.h"

#include 

#include 

#include 


/*
 * reorder_set()
 *
 * Reorders the set s with a function  i -> order[i].
 *
 * Note: Assumes that order is the same size as SET_MAX_SIZE(s).
 */
void reorder_set(set_t s,int *order) {
        set_t tmp;
        int i,j;
        setelement e;

        ASSERT(reorder_is_bijection(order,SET_MAX_SIZE(s)));

        tmp=set_new(SET_MAX_SIZE(s));

        for (i=0; i<(SET_MAX_SIZE(s)/ELEMENTSIZE); i++) {
                e=s[i];
                if (e==0)
                        continue;
                for (j=0; j>1;
                }
        }
        if (SET_MAX_SIZE(s)%ELEMENTSIZE) {
                e=s[i];
                for (j=0; j<(SET_MAX_SIZE(s)%ELEMENTSIZE); j++) {
                        if (e&1) {
                                SET_ADD_ELEMENT(tmp,order[i*ELEMENTSIZE+j]);
                        }
                        e = e>>1;
                }
        }
        set_copy(s,tmp);
        set_free(tmp);
        return;
}


/*
 * reorder_graph()
 *
 * Reorders the vertices in the graph with function  i -> order[i].
 *
 * Note: Assumes that order is of size g->n.
 */
void reorder_graph(graph_t *g, int *order) {
        int i;
        set_t *tmp_e;
        int *tmp_w;

        ASSERT(reorder_is_bijection(order,g->n));

        tmp_e=malloc(g->n * sizeof(set_t));
        tmp_w=malloc(g->n * sizeof(int));
        for (i=0; in; i++) {
                reorder_set(g->edges[i],order);
                tmp_e[order[i]]=g->edges[i];
                tmp_w[order[i]]=g->weights[i];
        }
        for (i=0; in; i++) {
                g->edges[i]=tmp_e[i];
                g->weights[i]=tmp_w[i];
        }
        free(tmp_e);
        free(tmp_w);
        return;
}



/*
 * reorder_duplicate()
 *
 * Returns a newly allocated duplicate of the given ordering.
 */
int *reorder_duplicate(int *order,int n) {
	int *new;

	new=malloc(n*sizeof(int));
	memcpy(new,order,n*sizeof(int));
	return new;
}

/*
 * reorder_invert()
 *
 * Inverts the given ordering so that new[old[i]]==i.
 *
 * Note: Asserts that order is a bijection.
 */
void reorder_invert(int *order,int n) {
	int *new;
	int i;

	ASSERT(reorder_is_bijection(order,n));

	new=malloc(n*sizeof(int));
	for (i=0; i {0,...,n-1}.
 *
 * Returns TRUE if it is a bijection, FALSE otherwise.
 */
boolean reorder_is_bijection(int *order,int n) {
	boolean *used;
	int i;

	used=calloc(n,sizeof(boolean));
	for (i=0; i=n) {
			free(used);
			return FALSE;
		}
		if (used[order[i]]) {
			free(used);
			return FALSE;
		}
		used[order[i]]=TRUE;
	}
	for (i=0; in);
}

/*
 * reorder_by_reverse()
 *
 * Returns a reverse identity ordering.
 */
int *reorder_by_reverse(graph_t *g,boolean weighted) {
	int i;
	int *order;

	order=malloc(g->n * sizeof(int));
	for (i=0; i < g->n; i++)
		order[i]=g->n-i-1;
	return order;
}

/*
 * reorder_by_greedy_coloring()
 *
 * Equivalent to reorder_by_weighted_greedy_coloring or
 * reorder_by_unweighted_greedy_coloring according to the value of weighted.
 */
int *reorder_by_greedy_coloring(graph_t *g,boolean weighted) {
	if (weighted)
		return reorder_by_weighted_greedy_coloring(g,weighted);
	else
		return reorder_by_unweighted_greedy_coloring(g,weighted);
}


/*
 * reorder_by_unweighted_greedy_coloring()
 *
 * Returns an ordering for the graph g by coloring the clique one
 * color at a time, always adding the vertex of largest degree within
 * the uncolored graph, and numbering these vertices 0, 1, ...
 *
 * Experimentally efficient for use with unweighted graphs.
 */
int *reorder_by_unweighted_greedy_coloring(graph_t *g,boolean weighted) {
	int i,j,v;
	boolean *tmp_used;
	int *degree;   /* -1 for used vertices */
	int *order;
	int maxdegree,maxvertex=0;
	boolean samecolor;

	tmp_used=calloc(g->n,sizeof(boolean));
	degree=calloc(g->n,sizeof(int));
	order=calloc(g->n,sizeof(int));

	for (i=0; i < g->n; i++) {
		for (j=0; j < g->n; j++) {
			ASSERT(!((i==j) && GRAPH_IS_EDGE(g,i,j)));
			if (GRAPH_IS_EDGE(g,i,j))
				degree[i]++;
		}
	}

	v=0;
	while (v < g->n) {
		/* Reset tmp_used. */
		memset(tmp_used,0,g->n * sizeof(boolean));

		do {
			/* Find vertex to be colored. */
			maxdegree=0;
			samecolor=FALSE;
			for (i=0; i < g->n; i++) {
				if (!tmp_used[i] && degree[i] >= maxdegree) {
					maxvertex=i;
					maxdegree=degree[i];
					samecolor=TRUE;
				}
			}
			if (samecolor) {
				order[v]=maxvertex;
				degree[maxvertex]=-1;
				v++;

				/* Mark neighbors not to color with same
				 * color and update neighbor degrees. */
				for (i=0; i < g->n; i++) {
					if (GRAPH_IS_EDGE(g,maxvertex,i)) {
						tmp_used[i]=TRUE;
						degree[i]--;
					}
				}
			}
		} while (samecolor);
	}

	free(tmp_used);
	free(degree);
	return order;
}

/*
 * reorder_by_weighted_greedy_coloring()
 *
 * Returns an ordering for the graph g by coloring the clique one
 * color at a time, always adding the vertex that (in order of importance):
 *  1. has the minimum weight in the remaining graph
 *  2. has the largest sum of weights surrounding the vertex
 *
 * Experimentally efficient for use with weighted graphs.
 */
int *reorder_by_weighted_greedy_coloring(graph_t *g, boolean weighted) {
	int i,j,p=0;
	int cnt;
	int *nwt;    /* Sum of surrounding vertices' weights */
	int min_wt,max_nwt;
	boolean *used;
	int *order;

	nwt=malloc(g->n * sizeof(int));
	order=malloc(g->n * sizeof(int));
	used=calloc(g->n,sizeof(boolean));

	for (i=0; i < g->n; i++) {
		nwt[i]=0;
		for (j=0; j < g->n; j++)
			if (GRAPH_IS_EDGE(g, i, j))
				nwt[i] += g->weights[j];
	}

	for (cnt=0; cnt < g->n; cnt++) {
		min_wt=INT_MAX;
		max_nwt=-1;
		for (i=g->n-1; i>=0; i--)
			if ((!used[i]) && (g->weights[i] < min_wt))
				min_wt=g->weights[i];
		for (i=g->n-1; i>=0; i--) {
			if (used[i] || (g->weights[i] > min_wt))
				continue;
			if (nwt[i] > max_nwt) {
				max_nwt=nwt[i];
				p=i;
			}
		}
		order[cnt]=p;
		used[p]=TRUE;
		for (j=0; j < g->n; j++)
			if ((!used[j]) && (GRAPH_IS_EDGE(g, p, j)))
				nwt[j] -= g->weights[p];
	}

	free(nwt);
	free(used);

	ASSERT(reorder_is_bijection(order,g->n));

	return order;
}

/*
 * reorder_by_degree()
 *
 * Returns a reordering of the graph g so that the vertices with largest
 * degrees (most neighbors) are first.
 */
int *reorder_by_degree(graph_t *g, boolean weighted) {
	int i,j,v;
	int *degree;
	int *order;
	int maxdegree,maxvertex=0;

	degree=calloc(g->n,sizeof(int));
	order=calloc(g->n,sizeof(int));

	for (i=0; i < g->n; i++) {
		for (j=0; j < g->n; j++) {
			ASSERT(!((i==j) && GRAPH_IS_EDGE(g,i,j)));
			if (GRAPH_IS_EDGE(g,i,j))
				degree[i]++;
		}
	}

	for (v=0; v < g->n; v++) {
		maxdegree=0;
		for (i=0; i < g->n; i++) {
			if (degree[i] >= maxdegree) {
				maxvertex=i;
				maxdegree=degree[i];
			}
		}
		order[v]=maxvertex;
		degree[maxvertex]=-1;  /* used */
/*** Max. degree withing unselected graph:
		for (i=0; i < g->n; i++) {
			if (GRAPH_IS_EDGE(g,maxvertex,i))
				degree[i]--;
		}
***/
	}

	free(degree);
	return order;
}

/*
 * reorder_by_random()
 *
 * Returns a random reordering for graph g.
 * Note: Used the functions rand() and srand() to generate the random
 *       numbers.  srand() is re-initialized every time reorder_by_random()
 *       is called using the system time.
 */
int *reorder_by_random(graph_t *g, boolean weighted) {
	int i,r;
	int *new;
	boolean *used;

	new=calloc(g->n, sizeof(int));
	used=calloc(g->n, sizeof(boolean));
	for (i=0; i < g->n; i++) {
		do {
            r = igraph_rng_get_integer(igraph_rng_default(), 0, g->n - 1);
		} while (used[r]);
		new[i]=r;
		used[r]=TRUE;
	}
	free(used);
	return new;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/reorder.h0000644000175100001710000000172400000000000025371 0ustar00runnerdocker00000000000000
#ifndef CLIQUER_REORDER_H
#define CLIQUER_REORDER_H

#include "set.h"
#include "graph.h"

extern void reorder_set(set_t s,int *order);
extern void reorder_graph(graph_t *g, int *order);
extern int *reorder_duplicate(int *order,int n);
extern void reorder_invert(int *order,int n);
extern void reorder_reverse(int *order,int n);
extern int *reorder_ident(int n);
extern boolean reorder_is_bijection(int *order,int n);


#define reorder_by_default reorder_by_greedy_coloring
extern int *reorder_by_greedy_coloring(graph_t *g, boolean weighted);
extern int *reorder_by_weighted_greedy_coloring(graph_t *g, boolean weighted);
extern int *reorder_by_unweighted_greedy_coloring(graph_t *g,boolean weighted);
extern int *reorder_by_degree(graph_t *g, boolean weighted);
extern int *reorder_by_random(graph_t *g, boolean weighted);
extern int *reorder_by_ident(graph_t *g, boolean weighted);
extern int *reorder_by_reverse(graph_t *g, boolean weighted);

#endif /* !CLIQUER_REORDER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliquer/set.h0000644000175100001710000002226400000000000024524 0ustar00runnerdocker00000000000000
/*
 * This file contains the set handling routines.
 *
 * Copyright (C) 2002 Sampo Niskanen, Patric Östergård.
 * Licensed under the GNU GPL, read the file LICENSE for details.
 */

#ifndef CLIQUER_SET_H
#define CLIQUER_SET_H

#include 
#include 
#include 
#include 
#include "misc.h"

/*
 * Sets are arrays of setelement's (typically unsigned long int's) with
 * representative bits for each value they can contain.  The values
 * are numbered 0,...,n-1.
 */


/*** Variable types and constants. ***/


/*
 * If setelement hasn't been declared:
 *   - use "unsigned long int" as setelement
 *   - try to deduce size from ULONG_MAX
 */

#ifndef ELEMENTSIZE
typedef unsigned long int setelement;
# if (ULONG_MAX == 65535)
#  define ELEMENTSIZE 16
# elif (ULONG_MAX == 4294967295)
#  define ELEMENTSIZE 32
# else
#  define ELEMENTSIZE 64
# endif
#endif  /* !ELEMENTSIZE */

typedef setelement * set_t;


/*** Counting amount of 1 bits in a setelement ***/

/* Array for amount of 1 bits in a byte. */
static int set_bit_count[256] = {
	0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
	4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8 };

/* The following macros assume that all higher bits are 0.
 * They may in some cases be useful also on with other ELEMENTSIZE's,
 * so we define them all.  */
#define SET_ELEMENT_BIT_COUNT_8(a)  (set_bit_count[(a)])
#define SET_ELEMENT_BIT_COUNT_16(a) (set_bit_count[(a)>>8] + \
				     set_bit_count[(a)&0xFF])
#define SET_ELEMENT_BIT_COUNT_32(a) (set_bit_count[(a)>>24] + \
				     set_bit_count[((a)>>16)&0xFF] + \
				     set_bit_count[((a)>>8)&0xFF] + \
				     set_bit_count[(a)&0xFF])
#define SET_ELEMENT_BIT_COUNT_64(a) (set_bit_count[(a)>>56] + \
				     set_bit_count[((a)>>48)&0xFF] + \
				     set_bit_count[((a)>>40)&0xFF] + \
				     set_bit_count[((a)>>32)&0xFF] + \
				     set_bit_count[((a)>>24)&0xFF] + \
				     set_bit_count[((a)>>16)&0xFF] + \
				     set_bit_count[((a)>>8)&0xFF] + \
				     set_bit_count[(a)&0xFF])
#if (ELEMENTSIZE==64)
# define SET_ELEMENT_BIT_COUNT(a) SET_ELEMENT_BIT_COUNT_64(a)
# define FULL_ELEMENT ((setelement)0xFFFFFFFFFFFFFFFF)
#elif (ELEMENTSIZE==32)
# define SET_ELEMENT_BIT_COUNT(a) SET_ELEMENT_BIT_COUNT_32(a)
# define FULL_ELEMENT ((setelement)0xFFFFFFFF)
#elif (ELEMENTSIZE==16)
# define SET_ELEMENT_BIT_COUNT(a) SET_ELEMENT_BIT_COUNT_16(a)
# define FULL_ELEMENT ((setelement)0xFFFF)
#else
# error "SET_ELEMENT_BIT_COUNT(a) not defined for current ELEMENTSIZE"
#endif



/*** Macros and functions ***/

/*
 * Gives a value with bit x (counting from lsb up) set.
 *
 * Making this as a table might speed up things on some machines
 * (though on most modern machines it's faster to shift instead of
 * using memory).  Making it a macro makes it easy to change.
 */
#define SET_BIT_MASK(x) ((setelement)1<<(x))



/* Set element handling macros */

#define SET_ELEMENT_INTERSECT(a,b)  ((a)&(b))
#define SET_ELEMENT_UNION(a,b)      ((a)|(b))
#define SET_ELEMENT_DIFFERENCE(a,b) ((a)&(~(b)))
#define SET_ELEMENT_CONTAINS(e,v)   ((e)&SET_BIT_MASK(v))


/* Set handling macros */

#define SET_ADD_ELEMENT(s,a) \
                       ((s)[(a)/ELEMENTSIZE] |= SET_BIT_MASK((a)%ELEMENTSIZE))
#define SET_DEL_ELEMENT(s,a) \
                       ((s)[(a)/ELEMENTSIZE] &= ~SET_BIT_MASK((a)%ELEMENTSIZE))
#define SET_CONTAINS_FAST(s,a) (SET_ELEMENT_CONTAINS((s)[(a)/ELEMENTSIZE], \
						      (a)%ELEMENTSIZE))
#define SET_CONTAINS(s,a) (((a)0);

	n=(size/ELEMENTSIZE+1)+1;
	s=calloc(n,sizeof(setelement));
	s[0]=size;

	return &(s[1]);
}

/*
 * set_free()
 *
 * Free the memory associated with set s.
 */
UNUSED_FUNCTION INLINE
static void set_free(set_t s) {
	ASSERT(s!=NULL);
	free(&(s[-1]));
}

/*
 * set_resize()
 *
 * Resizes set s to given size.  If the size is less than SET_MAX_SIZE(s),
 * the last elements are dropped.
 *
 * Returns a pointer to the new set.
 */
UNUSED_FUNCTION INLINE
static set_t set_resize(set_t s, unsigned int size) {
	unsigned int n;

	ASSERT(size>0);

	n=(size/ELEMENTSIZE+1);
	s=((setelement *)realloc(s-1,(n+1)*sizeof(setelement)))+1;

	if (n>SET_ARRAY_LENGTH(s))
		memset(s+SET_ARRAY_LENGTH(s),0,
		       (n-SET_ARRAY_LENGTH(s))*sizeof(setelement));
	if (size < SET_MAX_SIZE(s))
		s[(size-1)/ELEMENTSIZE] &= (FULL_ELEMENT >>
					    (ELEMENTSIZE-size%ELEMENTSIZE));
	s[-1]=size;

	return s;
}

/*
 * set_size()
 *
 * Returns the number of elements in set s.
 */
UNUSED_FUNCTION INLINE
static int set_size(set_t s) {
	int count=0;
	setelement *c;

	for (c=s; c < s+SET_ARRAY_LENGTH(s); c++)
		count+=SET_ELEMENT_BIT_COUNT(*c);
	return count;
}

/*
 * set_duplicate()
 *
 * Returns a newly allocated duplicate of set s.
 */
UNUSED_FUNCTION INLINE
static set_t set_duplicate(set_t s) {
	set_t new;

	new=set_new(SET_MAX_SIZE(s));
	memcpy(new,s,SET_ARRAY_LENGTH(s)*sizeof(setelement));
	return new;
}

/*
 * set_copy()
 *
 * Copies set src to dest.  If dest is NULL, is equal to set_duplicate.
 * If dest smaller than src, it is freed and a new set of the same size as
 * src is returned.
 */
UNUSED_FUNCTION INLINE
static set_t set_copy(set_t dest,set_t src) {
	if (dest==NULL)
		return set_duplicate(src);
	if (SET_MAX_SIZE(dest)=0) {
 *         // i is in set s
 * }
 */
UNUSED_FUNCTION INLINE
static int set_return_next(set_t s, unsigned int n) {
	n++;
	if (n >= SET_MAX_SIZE(s))
		return -1;

	while (n%ELEMENTSIZE) {
		if (SET_CONTAINS(s,n))
			return n;
		n++;
		if (n >= SET_MAX_SIZE(s))
			return -1;
	}

	while (s[n/ELEMENTSIZE]==0) {
		n+=ELEMENTSIZE;
		if (n >= SET_MAX_SIZE(s))
			return -1;
	}
	while (!SET_CONTAINS(s,n)) {
		n++;
		if (n >= SET_MAX_SIZE(s))
			return -1;
	}
	return n;
}


/*
 * set_print()
 *
 * Prints the size and contents of set s to stdout.
 * Mainly useful for debugging purposes and trivial output.
 */
/*
UNUSED_FUNCTION
static void set_print(set_t s) {
	int i;
	printf("size=%d(max %d)",set_size(s),(int)SET_MAX_SIZE(s));
	for (i=0; in) {
        IGRAPH_ERROR("Invalid vertex weight vector length", IGRAPH_EINVAL);
    }

    for (i = 0; i < g->n; ++i) {
        g->weights[i] = VECTOR(*vertex_weights)[i];
        if (g->weights[i] != VECTOR(*vertex_weights)[i]) {
            IGRAPH_WARNING("Only integer vertex weights are supported; weights will be truncated to their integer parts");
        }
        if (g->weights[i] <= 0) {
            IGRAPH_ERROR("Vertex weights must be positive", IGRAPH_EINVAL);
        }
    }

    return IGRAPH_SUCCESS;
}


/* Find all cliques. */

static boolean collect_cliques_callback(set_t s, graph_t *g, clique_options *opt) {
    igraph_vector_ptr_t *list;
    igraph_vector_t *clique;
    int i, j;

    IGRAPH_UNUSED(g);

    CLIQUER_ALLOW_INTERRUPTION();

    list = (igraph_vector_ptr_t *) opt->user_data;
    clique = (igraph_vector_t *) malloc(sizeof(igraph_vector_t));
    igraph_vector_init(clique, set_size(s));

    i = -1; j = 0;
    while ((i = set_return_next(s, i)) >= 0) {
        VECTOR(*clique)[j++] = i;
    }

    igraph_vector_ptr_push_back(list, clique);

    return TRUE;
}

int igraph_i_cliquer_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
                             igraph_integer_t min_size, igraph_integer_t max_size) {
    graph_t *g;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        igraph_vector_ptr_clear(res);
        return IGRAPH_SUCCESS;
    }

    if (min_size <= 0) {
        min_size = 1;
    }
    if (max_size <= 0) {
        max_size = 0;
    }

    if (max_size > 0 && max_size < min_size) {
        IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    igraph_vector_ptr_clear(res);
    igraph_cliquer_opt.user_data = res;
    igraph_cliquer_opt.user_function = &collect_cliques_callback;

    IGRAPH_FINALLY(free_clique_list, res);
    CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));
    IGRAPH_FINALLY_CLEAN(1);

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Count cliques of each size. */

static boolean count_cliques_callback(set_t s, graph_t *g, clique_options *opt) {
    igraph_vector_t *hist;

    IGRAPH_UNUSED(g);

    CLIQUER_ALLOW_INTERRUPTION();

    hist = (igraph_vector_t *) opt->user_data;
    VECTOR(*hist)[set_size(s) - 1] += 1;

    return TRUE;
}

int igraph_i_cliquer_histogram(const igraph_t *graph, igraph_vector_t *hist,
                               igraph_integer_t min_size, igraph_integer_t max_size) {
    graph_t *g;
    int i;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        igraph_vector_clear(hist);
        return IGRAPH_SUCCESS;
    }

    if (min_size <= 0) {
        min_size = 1;
    }
    if (max_size <= 0) {
        max_size = vcount;    /* also used for initial hist vector size, do not set to zero */
    }

    if (max_size < min_size) {
        IGRAPH_ERRORF("Maximum clique size (%" IGRAPH_PRId ") must not be "
                      "smaller than minimum clique size (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, max_size, min_size);
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    igraph_vector_resize(hist, max_size);
    igraph_vector_null(hist);
    igraph_cliquer_opt.user_data = hist;
    igraph_cliquer_opt.user_function = &count_cliques_callback;

    CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));

    for (i = max_size; i > 0; --i)
        if (VECTOR(*hist)[i - 1] > 0) {
            break;
        }
    igraph_vector_resize(hist, i);
    igraph_vector_resize_min(hist);

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Call function for each clique. */

struct callback_data {
    igraph_clique_handler_t *handler;
    void *arg;
};

static boolean callback_callback(set_t s, graph_t *g, clique_options *opt) {
    igraph_vector_t *clique;
    struct callback_data *cd;
    int i, j;

    IGRAPH_UNUSED(g);

    CLIQUER_ALLOW_INTERRUPTION();

    cd = (struct callback_data *) opt->user_data;

    clique = (igraph_vector_t *) malloc(sizeof(igraph_vector_t));
    igraph_vector_init(clique, set_size(s));

    i = -1; j = 0;
    while ((i = set_return_next(s, i)) >= 0) {
        VECTOR(*clique)[j++] = i;
    }

    return (*(cd->handler))(clique, cd->arg);
}

int igraph_i_cliquer_callback(const igraph_t *graph,
                              igraph_integer_t min_size, igraph_integer_t max_size,
                              igraph_clique_handler_t *cliquehandler_fn, void *arg) {
    graph_t *g;
    struct callback_data cd;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        return IGRAPH_SUCCESS;
    }

    if (min_size <= 0) {
        min_size = 1;
    }
    if (max_size <= 0) {
        max_size = 0;
    }

    if (max_size > 0 && max_size < min_size) {
        IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    cd.handler = cliquehandler_fn;
    cd.arg = arg;
    igraph_cliquer_opt.user_data = &cd;
    igraph_cliquer_opt.user_function = &callback_callback;

    CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Find weighted cliques in given weight range. */

int igraph_i_weighted_cliques(const igraph_t *graph,
                              const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res,
                              igraph_real_t min_weight, igraph_real_t max_weight, igraph_bool_t maximal) {
    graph_t *g;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        igraph_vector_ptr_clear(res);
        return IGRAPH_SUCCESS;
    }

    if (min_weight != (int) min_weight) {
        IGRAPH_WARNING("Only integer vertex weights are supported; the minimum weight will be truncated to its integer part");
        min_weight  = (int) min_weight;
    }

    if (max_weight != (int) max_weight) {
        IGRAPH_WARNING("Only integer vertex weights are supported; the maximum weight will be truncated to its integer part");
        max_weight = (int) max_weight;
    }

    if (min_weight <= 0) {
        min_weight = 1;
    }
    if (max_weight <= 0) {
        max_weight = 0;
    }

    if (max_weight > 0 && max_weight < min_weight) {
        IGRAPH_ERROR("max_weight must not be smaller than min_weight", IGRAPH_EINVAL);
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    IGRAPH_CHECK(set_weights(vertex_weights, g));

    igraph_vector_ptr_clear(res);
    igraph_cliquer_opt.user_data = res;
    igraph_cliquer_opt.user_function = &collect_cliques_callback;

    IGRAPH_FINALLY(free_clique_list, res);
    CLIQUER_INTERRUPTABLE(clique_find_all(g, min_weight, max_weight, maximal, &igraph_cliquer_opt));
    IGRAPH_FINALLY_CLEAN(1);

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Find largest weighted cliques. */

int igraph_i_largest_weighted_cliques(const igraph_t *graph,
                                      const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res) {
    graph_t *g;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        igraph_vector_ptr_clear(res);
        return IGRAPH_SUCCESS;
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    IGRAPH_CHECK(set_weights(vertex_weights, g));

    igraph_vector_ptr_clear(res);
    igraph_cliquer_opt.user_data = res;
    igraph_cliquer_opt.user_function = &collect_cliques_callback;

    IGRAPH_FINALLY(free_clique_list, res);
    CLIQUER_INTERRUPTABLE(clique_find_all(g, 0, 0, FALSE, &igraph_cliquer_opt));
    IGRAPH_FINALLY_CLEAN(1);

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Find weight of largest weight clique. */

int igraph_i_weighted_clique_number(const igraph_t *graph,
                                    const igraph_vector_t *vertex_weights, igraph_real_t *res) {
    graph_t *g;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vcount == 0) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    igraph_to_cliquer(graph, &g);
    IGRAPH_FINALLY(graph_free, g);

    IGRAPH_CHECK(set_weights(vertex_weights, g));

    igraph_cliquer_opt.user_function = NULL;

    /* we are not using a callback function, thus this is not interruptable */
    *res = clique_max_weight(g, &igraph_cliquer_opt);

    graph_free(g);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/cliques.c0000644000175100001710000012414400000000000023725 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_cliques.h"

#include "igraph_error.h"
#include "igraph_memory.h"
#include "igraph_constants.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_stack.h"

#include "cliques/cliquer_internal.h"
#include "core/interruption.h"
#include "core/set.h"

#include     /* memset */

static void igraph_i_cliques_free_res(igraph_vector_ptr_t *res) {
    long i, n;

    n = igraph_vector_ptr_size(res);
    for (i = 0; i < n; i++) {
        if (VECTOR(*res)[i] != 0) {
            igraph_vector_destroy(VECTOR(*res)[i]);
            igraph_free(VECTOR(*res)[i]);
        }
    }
    igraph_vector_ptr_clear(res);
}

static int igraph_i_find_k_cliques(
        const igraph_t *graph,
        long int size,
        const igraph_real_t *member_storage,
        igraph_real_t **new_member_storage,
        long int old_clique_count,
        long int *clique_count,
        igraph_vector_t *neis,
        igraph_bool_t independent_vertices) {

    long int j, k, l, m, n, new_member_storage_size;
    const igraph_real_t *c1, *c2;
    igraph_real_t v1, v2;
    igraph_bool_t ok;

    /* Allocate the storage */
    *new_member_storage = IGRAPH_REALLOC(*new_member_storage,
                                         (size_t) (size * old_clique_count),
                                         igraph_real_t);
    if (*new_member_storage == 0) {
        IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
    }
    new_member_storage_size = size * old_clique_count;
    IGRAPH_FINALLY(igraph_free, *new_member_storage);

    m = n = 0;

    /* Now consider all pairs of i-1-cliques and see if they can be merged */
    for (j = 0; j < old_clique_count; j++) {
        for (k = j + 1; k < old_clique_count; k++) {
            IGRAPH_ALLOW_INTERRUPTION();

            /* Since cliques are represented by their vertex indices in increasing
             * order, two cliques can be merged iff they have exactly the same
             * indices excluding one AND there is an edge between the two different
             * vertices */
            c1 = member_storage + j * (size - 1);
            c2 = member_storage + k * (size - 1);
            /* Find the longest prefixes of c1 and c2 that are equal */
            for (l = 0; l < size - 1 && c1[l] == c2[l]; l++) {
                (*new_member_storage)[m++] = c1[l];
            }
            /* Now, if l == size-1, the two vectors are totally equal.
            This is a bug */
            if (l == size - 1) {
                IGRAPH_WARNING("possible bug in igraph_cliques");
                m = n;
            } else {
                /* Assuming that j (*new_member_storage)[m - 1]) {
                            (*new_member_storage)[m++] = v2;
                            n = m;
                        } else {
                            m = n;
                        }
                    } else {
                        m = n;
                    }
                }
                /* See if new_member_storage is full. If so, reallocate */
                if (m == new_member_storage_size) {
                    IGRAPH_FINALLY_CLEAN(1);
                    *new_member_storage = IGRAPH_REALLOC(*new_member_storage,
                                                         (size_t) new_member_storage_size * 2,
                                                         igraph_real_t);
                    if (*new_member_storage == 0) {
                        IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
                    }
                    new_member_storage_size *= 2;
                    IGRAPH_FINALLY(igraph_free, *new_member_storage);
                }
            }
        }
    }

    /* Calculate how many cliques we have found */
    *clique_count = n / size;

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/* Internal function for calculating cliques or independent vertex sets.
 * They are practically the same except that the complementer of the graph
 * should be used in the latter case.
 */
static int igraph_i_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
                            igraph_integer_t min_size, igraph_integer_t max_size,
                            igraph_bool_t independent_vertices) {

    igraph_integer_t no_of_nodes;
    igraph_vector_t neis;
    igraph_real_t *member_storage = 0, *new_member_storage, *c1;
    long int i, j, k, clique_count, old_clique_count;

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
    }

    no_of_nodes = igraph_vcount(graph);

    if (min_size < 0) {
        min_size = 0;
    }
    if (max_size > no_of_nodes || max_size <= 0) {
        max_size = no_of_nodes;
    }

    igraph_vector_ptr_clear(res);

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_FINALLY(igraph_i_cliques_free_res, res);

    /* Will be resized later, if needed. */
    member_storage = IGRAPH_CALLOC(1, igraph_real_t);
    if (member_storage == 0) {
        IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, member_storage);

    /* Find all 1-cliques: every vertex will be a clique */
    new_member_storage = IGRAPH_CALLOC(no_of_nodes, igraph_real_t);
    if (new_member_storage == 0) {
        IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, new_member_storage);

    for (i = 0; i < no_of_nodes; i++) {
        new_member_storage[i] = i;
    }
    clique_count = no_of_nodes;
    old_clique_count = 0;

    /* Add size 1 cliques if requested */
    if (min_size <= 1) {
        IGRAPH_CHECK(igraph_vector_ptr_resize(res, no_of_nodes));
        igraph_vector_ptr_null(res);
        for (i = 0; i < no_of_nodes; i++) {
            igraph_vector_t *p = IGRAPH_CALLOC(1, igraph_vector_t);
            if (p == 0) {
                IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, p);
            IGRAPH_CHECK(igraph_vector_init(p, 1));
            VECTOR(*p)[0] = i;
            VECTOR(*res)[i] = p;
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    for (i = 2; i <= max_size && clique_count > 1; i++) {

        /* Here new_member_storage contains the cliques found in the previous
           iteration. Save this into member_storage, might be needed later  */

        c1 = member_storage;
        member_storage = new_member_storage;
        new_member_storage = c1;
        old_clique_count = clique_count;

        IGRAPH_ALLOW_INTERRUPTION();

        /* Calculate the cliques */

        IGRAPH_FINALLY_CLEAN(2);
        IGRAPH_CHECK(igraph_i_find_k_cliques(graph, i, member_storage,
                                             &new_member_storage,
                                             old_clique_count,
                                             &clique_count,
                                             &neis,
                                             independent_vertices));
        IGRAPH_FINALLY(igraph_free, member_storage);
        IGRAPH_FINALLY(igraph_free, new_member_storage);

        /* Add the cliques just found to the result if requested */
        if (i >= min_size && i <= max_size) {
            for (j = 0, k = 0; j < clique_count; j++, k += i) {
                igraph_vector_t *p = IGRAPH_CALLOC(1, igraph_vector_t);
                if (p == 0) {
                    IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, p);
                IGRAPH_CHECK(igraph_vector_init_copy(p, &new_member_storage[k], i));
                IGRAPH_FINALLY(igraph_vector_destroy, p);
                IGRAPH_CHECK(igraph_vector_ptr_push_back(res, p));
                IGRAPH_FINALLY_CLEAN(2);
            }
        }

    } /* i <= max_size && clique_count != 0 */

    igraph_free(member_storage);
    igraph_free(new_member_storage);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(4); /* 3 here, +1 is igraph_i_cliques_free_res */

    return 0;
}

/**
 * \function igraph_cliques
 * \brief Finds all or some cliques in a graph.
 *
 * 
 * Cliques are fully connected subgraphs of a graph.
 *
 * 
 * If you are only interested in the size of the largest clique in the graph,
 * use \ref igraph_clique_number() instead.
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in a clique.
 *   The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_largest_cliques() and \ref igraph_clique_number().
 *
 * Time complexity: Exponential
 *
 * \example examples/simple/igraph_cliques.c
 */
int igraph_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
                   igraph_integer_t min_size, igraph_integer_t max_size) {
    return igraph_i_cliquer_cliques(graph, res, min_size, max_size);
}


/**
 * \function igraph_clique_size_hist
 * \brief Counts cliques of each size in the graph.
 *
 * 
 * Cliques are fully connected subgraphs of a graph.
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * \param graph The input graph.
 * \param hist Pointer to an initialized vector. The result will be stored
 * here. The first element will store the number of size-1 cliques, the second
 * element the number of size-2 cliques, etc.  For cliques smaller than \p min_size,
 * zero counts will be returned.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_cliques() and \ref igraph_cliques_callback()
 *
 * Time complexity: Exponential
 *
 */
int igraph_clique_size_hist(const igraph_t *graph, igraph_vector_t *hist,
                            igraph_integer_t min_size, igraph_integer_t max_size) {
    return igraph_i_cliquer_histogram(graph, hist, min_size, max_size);
}


/**
 * \function igraph_cliques_callback
 * \brief Calls a function for each clique in the graph.
 *
 * 
 * Cliques are fully connected subgraphs of a graph. This function
 * enumerates all cliques within the given size range and calls
 * \p cliquehandler_fn for each of them. The cliques are passed to the
 * callback function as a pointer to an \ref igraph_vector_t.  Destroying and
 * freeing this vector is left up to the user.  Use \ref igraph_vector_destroy()
 * to destroy it first, then free it using \ref igraph_free().
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * \param graph The input graph.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \param cliquehandler_fn Callback function to be called for each clique.
 * See also \ref igraph_clique_handler_t.
 * \param arg Extra argument to supply to \p cliquehandler_fn.
 * \return Error code.
 *
 * \sa \ref igraph_cliques()
 *
 * Time complexity: Exponential
 *
 */
int igraph_cliques_callback(const igraph_t *graph,
                            igraph_integer_t min_size, igraph_integer_t max_size,
                            igraph_clique_handler_t *cliquehandler_fn, void *arg) {
    return igraph_i_cliquer_callback(graph, min_size, max_size, cliquehandler_fn, arg);
}


/**
 * \function igraph_weighted_cliques
 * \brief Finds all cliques in a given weight range in a vertex weighted graph.
 *
 * 
 * Cliques are fully connected subgraphs of a graph.
 * The weight of a clique is the sum of the weights
 * of individual vertices within the clique.
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * Only positive integer vertex weights are supported.
 *
 * \param graph The input graph.
 * \param vertex_weights A vector of vertex weights. The current implementation
 *   will truncate all weights to their integer parts. You may pass \c NULL
 *   here to make each vertex have a weight of 1.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in a clique.
 *   The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \param min_weight Integer giving the minimum weight of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_weight Integer giving the maximum weight of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \param maximal If true, only maximal cliques will be returned
 * \return Error code.
 *
 * \sa \ref igraph_cliques(), \ref igraph_maximal_cliques()
 *
 * Time complexity: Exponential
 *
 */
int igraph_weighted_cliques(const igraph_t *graph,
                            const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res,
                            igraph_real_t min_weight, igraph_real_t max_weight, igraph_bool_t maximal) {
    if (vertex_weights) {
        return igraph_i_weighted_cliques(graph, vertex_weights, res, min_weight, max_weight, maximal);
    } else if (maximal) {
        return igraph_maximal_cliques(graph, res, min_weight, max_weight);
    } else {
        return igraph_cliques(graph, res, min_weight, max_weight);
    }
}


/**
 * \function igraph_largest_weighted_cliques
 * \brief Finds the largest weight clique(s) in a graph.
 *
 * 
 * Finds the clique(s) having the largest weight in the graph.
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * Only positive integer vertex weights are supported.
 *
 * \param graph The input graph.
 * \param vertex_weights A vector of vertex weights. The current implementation
 *   will truncate all weights to their integer parts. You may pass \c NULL
 *   here to make each vertex have a weight of 1.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in a clique.
 *   The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \return Error code.
 *
 * \sa \ref igraph_weighted_cliques(), \ref igraph_weighted_clique_number(), \ref igraph_largest_cliques()
 *
 * Time complexity: TODO
 */
int igraph_largest_weighted_cliques(const igraph_t *graph,
                                    const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res) {
    if (vertex_weights) {
        return igraph_i_largest_weighted_cliques(graph, vertex_weights, res);
    } else {
        return igraph_largest_cliques(graph, res);
    }
}


/**
 * \function igraph_weighted_clique_number
 * \brief Finds the weight of the largest weight clique in the graph.
 *
 * The current implementation of this function
 * uses version 1.21 of the Cliquer library by Sampo Niskanen and
 * Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html
 *
 * Only positive integer vertex weights are supported.
 *
 * \param graph The input graph.
 * \param vertex_weights A vector of vertex weights. The current implementation
 *   will truncate all weights to their integer parts. You may pass \c NULL
 *   here to make each vertex have a weight of 1.
 * \param res The largest weight will be returned to the \c igraph_real_t
 *   pointed to by this variable.
 * \return Error code.
 *
 * \sa \ref igraph_weighted_cliques(), \ref igraph_largest_weighted_cliques(), \ref igraph_clique_number()
 *
 * Time complexity: TODO
 *
 */
int igraph_weighted_clique_number(const igraph_t *graph,
                                  const igraph_vector_t *vertex_weights, igraph_real_t *res) {
    if (vertex_weights) {
        return igraph_i_weighted_clique_number(graph, vertex_weights, res);
    } else {
        igraph_integer_t res_int;
        IGRAPH_CHECK(igraph_clique_number(graph, &res_int));
        if (res) {
            *res = res_int;
        }
        return IGRAPH_SUCCESS;
    }
}

typedef int(*igraph_i_maximal_clique_func_t)(const igraph_vector_t*, void*, igraph_bool_t*);
typedef struct {
    igraph_vector_ptr_t* result;
    igraph_integer_t min_size;
    igraph_integer_t max_size;
} igraph_i_maximal_clique_data_t;

static int igraph_i_maximal_or_largest_cliques_or_indsets(
        const igraph_t *graph,
        igraph_vector_ptr_t *res,
        igraph_integer_t *clique_number,
        igraph_bool_t keep_only_largest,
        igraph_bool_t complementer);

/**
 * \function igraph_independent_vertex_sets
 * \brief Finds all independent vertex sets in a graph.
 *
 * 
 * A vertex set is considered independent if there are no edges between
 * them.
 *
 * 
 * If you are interested in the size of the largest independent vertex set,
 * use \ref igraph_independence_number() instead.
 *
 * 
 * The current implementation was ported to igraph from the Very Nauty Graph
 * Library by Keith Briggs and uses the algorithm from the paper
 * S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm
 * for generating all the maximal independent sets. SIAM J Computing,
 * 6:505--517, 1977.
 *
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in an independent
 *   vertex set. The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \param min_size Integer giving the minimum size of the sets to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the sets to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_largest_independent_vertex_sets(),
 * \ref igraph_independence_number().
 *
 * Time complexity: TODO
 *
 * \example examples/simple/igraph_independent_sets.c
 */
int igraph_independent_vertex_sets(const igraph_t *graph,
                                   igraph_vector_ptr_t *res,
                                   igraph_integer_t min_size,
                                   igraph_integer_t max_size) {
    return igraph_i_cliques(graph, res, min_size, max_size, 1);
}

/**
 * \function igraph_largest_independent_vertex_sets
 * \brief Finds the largest independent vertex set(s) in a graph.
 *
 * 
 * An independent vertex set is largest if there is no other
 * independent vertex set with more vertices in the graph.
 *
 * 
 * The current implementation was ported to igraph from the Very Nauty Graph
 * Library by Keith Briggs and uses the algorithm from the paper
 * S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm
 * for generating all the maximal independent sets. SIAM J Computing,
 * 6:505--517, 1977.
 *
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *     here. It will be resized as needed.
 * \return Error code.
 *
 * \sa \ref igraph_independent_vertex_sets(), \ref
 * igraph_maximal_independent_vertex_sets().
 *
 * Time complexity: TODO
 */

int igraph_largest_independent_vertex_sets(const igraph_t *graph,
        igraph_vector_ptr_t *res) {
    return igraph_i_maximal_or_largest_cliques_or_indsets(graph, res, 0, 1, 0);
}

typedef struct igraph_i_max_ind_vsets_data_t {
    igraph_integer_t matrix_size;
    igraph_adjlist_t adj_list;         /* Adjacency list of the graph */
    igraph_vector_t deg;                 /* Degrees of individual nodes */
    igraph_set_t* buckets;               /* Bucket array */
    /* The IS value for each node. Still to be explained :) */
    igraph_integer_t* IS;
    igraph_integer_t largest_set_size;   /* Size of the largest set encountered */
    igraph_bool_t keep_only_largest;     /* True if we keep only the largest sets */
} igraph_i_max_ind_vsets_data_t;

static int igraph_i_maximal_independent_vertex_sets_backtrack(
        const igraph_t *graph,
        igraph_vector_ptr_t *res,
        igraph_i_max_ind_vsets_data_t *clqdata,
        igraph_integer_t level) {
    long int v1, v2, v3, c, j, k;
    igraph_vector_int_t *neis1, *neis2;
    igraph_bool_t f;
    igraph_integer_t j1;
    long int it_state;

    IGRAPH_ALLOW_INTERRUPTION();

    if (level >= clqdata->matrix_size - 1) {
        igraph_integer_t size = 0;
        if (res) {
            igraph_vector_t *vec;
            vec = IGRAPH_CALLOC(1, igraph_vector_t);
            if (vec == 0) {
                IGRAPH_ERROR("igraph_i_maximal_independent_vertex_sets failed", IGRAPH_ENOMEM);
            }
            IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
            for (v1 = 0; v1 < clqdata->matrix_size; v1++)
                if (clqdata->IS[v1] == 0) {
                    IGRAPH_CHECK(igraph_vector_push_back(vec, v1));
                }
            size = (igraph_integer_t) igraph_vector_size(vec);
            if (!clqdata->keep_only_largest) {
                IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
            } else {
                if (size > clqdata->largest_set_size) {
                    /* We are keeping only the largest sets, and we've found one that's
                     * larger than all previous sets, so we have to clear the list */
                    j = igraph_vector_ptr_size(res);
                    for (v1 = 0; v1 < j; v1++) {
                        igraph_vector_destroy(VECTOR(*res)[v1]);
                        free(VECTOR(*res)[v1]);
                    }
                    igraph_vector_ptr_clear(res);
                    IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
                } else if (size == clqdata->largest_set_size) {
                    IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
                } else {
                    igraph_vector_destroy(vec);
                    free(vec);
                }
            }
            IGRAPH_FINALLY_CLEAN(1);
        } else {
            for (v1 = 0, size = 0; v1 < clqdata->matrix_size; v1++)
                if (clqdata->IS[v1] == 0) {
                    size++;
                }
        }
        if (size > clqdata->largest_set_size) {
            clqdata->largest_set_size = size;
        }
    } else {
        v1 = level + 1;
        /* Count the number of vertices with an index less than v1 that have
         * an IS value of zero */
        neis1 = igraph_adjlist_get(&clqdata->adj_list, v1);
        c = 0;
        j = 0;
        while (j < VECTOR(clqdata->deg)[v1] &&
               (v2 = (long int) VECTOR(*neis1)[j]) <= level) {
            if (clqdata->IS[v2] == 0) {
                c++;
            }
            j++;
        }

        if (c == 0) {
            /* If there are no such nodes... */
            j = 0;
            while (j < VECTOR(clqdata->deg)[v1] &&
                   (v2 = (long int) VECTOR(*neis1)[j]) <= level) {
                clqdata->IS[v2]++;
                j++;
            }
            IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, clqdata, (igraph_integer_t) v1));
            j = 0;
            while (j < VECTOR(clqdata->deg)[v1] &&
                   (v2 = (long int) VECTOR(*neis1)[j]) <= level) {
                clqdata->IS[v2]--;
                j++;
            }
        } else {
            /* If there are such nodes, store the count in the IS value of v1 */
            clqdata->IS[v1] = (igraph_integer_t) c;
            IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, clqdata, (igraph_integer_t) v1));
            clqdata->IS[v1] = 0;

            f = 1;
            j = 0;
            while (j < VECTOR(clqdata->deg)[v1] &&
                   (v2 = (long int) VECTOR(*neis1)[j]) <= level) {
                if (clqdata->IS[v2] == 0) {
                    IGRAPH_CHECK(igraph_set_add(&clqdata->buckets[v1],
                                                (igraph_integer_t) j));
                    neis2 = igraph_adjlist_get(&clqdata->adj_list, v2);
                    k = 0;
                    while (k < VECTOR(clqdata->deg)[v2] &&
                           (v3 = (long int) VECTOR(*neis2)[k]) <= level) {
                        clqdata->IS[v3]--;
                        if (clqdata->IS[v3] == 0) {
                            f = 0;
                        }
                        k++;
                    }
                }
                clqdata->IS[v2]++;
                j++;
            }

            if (f) {
                IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, clqdata, (igraph_integer_t) v1));
            }

            j = 0;
            while (j < VECTOR(clqdata->deg)[v1] &&
                   (v2 = (long int) VECTOR(*neis1)[j]) <= level) {
                clqdata->IS[v2]--;
                j++;
            }

            it_state = 0;
            while (igraph_set_iterate(&clqdata->buckets[v1], &it_state, &j1)) {
                j = (long)j1;
                v2 = (long int) VECTOR(*neis1)[j];
                neis2 = igraph_adjlist_get(&clqdata->adj_list, v2);
                k = 0;
                while (k < VECTOR(clqdata->deg)[v2] &&
                       (v3 = (long int) VECTOR(*neis2)[k]) <= level) {
                    clqdata->IS[v3]++;
                    k++;
                }
            }
            igraph_set_clear(&clqdata->buckets[v1]);
        }
    }

    return 0;
}

static void igraph_i_free_set_array(igraph_set_t* array) {
    long int i = 0;
    while (igraph_set_inited(array + i)) {
        igraph_set_destroy(array + i);
        i++;
    }
    IGRAPH_FREE(array);
}

/**
 * \function igraph_maximal_independent_vertex_sets
 * \brief Finds all maximal independent vertex sets of a graph.
 *
 * 
 * A maximal independent vertex set is an independent vertex set which
 * can't be extended any more by adding a new vertex to it.
 *
 * 
 * The algorithm used here is based on the following paper:
 * S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for
 * generating all the maximal independent sets. SIAM J Computing,
 * 6:505--517, 1977.
 *
 * 
 * The implementation was originally written by Kevin O'Neill and modified
 * by K M Briggs in the Very Nauty Graph Library. I simply re-wrote it to
 * use igraph's data structures.
 *
 * 
 * If you are interested in the size of the largest independent vertex set,
 * use \ref igraph_independence_number() instead.
 *
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in an independent
 *   vertex set. The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques(), \ref
 * igraph_independence_number()
 *
 * Time complexity: TODO.
 */
int igraph_maximal_independent_vertex_sets(const igraph_t *graph,
        igraph_vector_ptr_t *res) {
    igraph_i_max_ind_vsets_data_t clqdata;
    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph), i;

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
    }

    clqdata.matrix_size = no_of_nodes;
    clqdata.keep_only_largest = 0;

    IGRAPH_CHECK(igraph_adjlist_init(
        graph, &clqdata.adj_list, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE
    ));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &clqdata.adj_list);

    clqdata.IS = IGRAPH_CALLOC(no_of_nodes, igraph_integer_t);
    if (clqdata.IS == 0) {
        IGRAPH_ERROR("igraph_maximal_independent_vertex_sets failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, clqdata.IS);

    IGRAPH_VECTOR_INIT_FINALLY(&clqdata.deg, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(clqdata.deg)[i] = igraph_vector_int_size(igraph_adjlist_get(&clqdata.adj_list, i));
    }

    clqdata.buckets = IGRAPH_CALLOC(no_of_nodes + 1, igraph_set_t);
    if (clqdata.buckets == 0) {
        IGRAPH_ERROR("igraph_maximal_independent_vertex_sets failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_i_free_set_array, clqdata.buckets);

    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_set_init(&clqdata.buckets[i], 0));
    }

    igraph_vector_ptr_clear(res);

    /* Do the show */
    clqdata.largest_set_size = 0;
    IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, &clqdata, 0));

    /* Cleanup */
    for (i = 0; i < no_of_nodes; i++) {
        igraph_set_destroy(&clqdata.buckets[i]);
    }
    igraph_adjlist_destroy(&clqdata.adj_list);
    igraph_vector_destroy(&clqdata.deg);
    igraph_free(clqdata.IS);
    igraph_free(clqdata.buckets);
    IGRAPH_FINALLY_CLEAN(4);
    return 0;
}

/**
 * \function igraph_independence_number
 * \brief Finds the independence number of the graph.
 *
 * 
 * The independence number of a graph is the cardinality of the largest
 * independent vertex set.
 *
 * 
 * The current implementation was ported to igraph from the Very Nauty Graph
 * Library by Keith Briggs and uses the algorithm from the paper
 * S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm
 * for generating all the maximal independent sets. SIAM J Computing,
 * 6:505--517, 1977.
 *
 * \param graph The input graph.
 * \param no The independence number will be returned to the \c
 *   igraph_integer_t pointed by this variable.
 * \return Error code.
 *
 * \sa \ref igraph_independent_vertex_sets().
 *
 * Time complexity: TODO.
 */
int igraph_independence_number(const igraph_t *graph, igraph_integer_t *no) {
    igraph_i_max_ind_vsets_data_t clqdata;
    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph), i;

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
    }

    clqdata.matrix_size = no_of_nodes;
    clqdata.keep_only_largest = 0;

    IGRAPH_CHECK(igraph_adjlist_init(
        graph, &clqdata.adj_list, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE
    ));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &clqdata.adj_list);

    clqdata.IS = IGRAPH_CALLOC(no_of_nodes, igraph_integer_t);
    if (clqdata.IS == 0) {
        IGRAPH_ERROR("igraph_independence_number failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, clqdata.IS);

    IGRAPH_VECTOR_INIT_FINALLY(&clqdata.deg, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(clqdata.deg)[i] = igraph_vector_int_size(igraph_adjlist_get(&clqdata.adj_list, i));
    }

    clqdata.buckets = IGRAPH_CALLOC(no_of_nodes + 1, igraph_set_t);
    if (clqdata.buckets == 0) {
        IGRAPH_ERROR("igraph_independence_number failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_i_free_set_array, clqdata.buckets);

    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_set_init(&clqdata.buckets[i], 0));
    }

    /* Do the show */
    clqdata.largest_set_size = 0;
    IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, 0, &clqdata, 0));
    *no = clqdata.largest_set_size;

    /* Cleanup */
    for (i = 0; i < no_of_nodes; i++) {
        igraph_set_destroy(&clqdata.buckets[i]);
    }
    igraph_adjlist_destroy(&clqdata.adj_list);
    igraph_vector_destroy(&clqdata.deg);
    igraph_free(clqdata.IS);
    igraph_free(clqdata.buckets);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/*************************************************************************/
/* MAXIMAL CLIQUES, LARGEST CLIQUES                                      */
/*************************************************************************/

static igraph_bool_t igraph_i_maximal_cliques_store_max_size(igraph_vector_t* clique, void* data) {
    igraph_integer_t* result = (igraph_integer_t*)data;
    if (*result < igraph_vector_size(clique)) {
        *result = (igraph_integer_t) igraph_vector_size(clique);
    }
    igraph_vector_destroy(clique);
    igraph_Free(clique);
    return 1;
}

static igraph_bool_t igraph_i_largest_cliques_store(igraph_vector_t* clique, void* data) {
    igraph_vector_ptr_t* result = (igraph_vector_ptr_t*)data;
    long int i, n;

    /* Is the current clique at least as large as the others that we have found? */
    if (!igraph_vector_ptr_empty(result)) {
        n = igraph_vector_size(clique);
        if (n < igraph_vector_size(VECTOR(*result)[0])) {
            igraph_vector_destroy(clique);
            igraph_Free(clique);
            return 1;
        }

        if (n > igraph_vector_size(VECTOR(*result)[0])) {
            for (i = 0; i < igraph_vector_ptr_size(result); i++) {
                igraph_vector_destroy(VECTOR(*result)[i]);
            }
            igraph_vector_ptr_free_all(result);
            igraph_vector_ptr_resize(result, 0);
        }
    }

    IGRAPH_CHECK(igraph_vector_ptr_push_back(result, clique));

    return 1;
}

/**
 * \function igraph_largest_cliques
 * \brief Finds the largest clique(s) in a graph.
 *
 * 
 * A clique is largest (quite intuitively) if there is no other clique
 * in the graph which contains more vertices.
 *
 * 
 * Note that this is not necessarily the same as a maximal clique,
 * i.e. the largest cliques are always maximal but a maximal clique is
 * not always largest.
 *
 * The current implementation of this function searches
 * for maximal cliques using \ref igraph_maximal_cliques_callback() and drops
 * those that are not the largest.
 *
 * The implementation of this function changed between
 * igraph 0.5 and 0.6, so the order of the cliques and the order of
 * vertices within the cliques will almost surely be different between
 * these two versions.
 *
 * \param graph The input graph.
 * \param res Pointer to an initialized pointer vector, the result
 *        will be stored here. It will be resized as needed. Note that
 *        vertices of a clique may be returned in arbitrary order.
 * \return Error code.
 *
 * \sa \ref igraph_cliques(), \ref igraph_maximal_cliques()
 *
 * Time complexity: O(3^(|V|/3)) worst case.
 */

int igraph_largest_cliques(const igraph_t *graph, igraph_vector_ptr_t *res) {
    igraph_vector_ptr_clear(res);
    IGRAPH_FINALLY(igraph_i_cliques_free_res, res);
    IGRAPH_CHECK(igraph_maximal_cliques_callback(graph, &igraph_i_largest_cliques_store, (void*)res, 0, 0));
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_clique_number
 * \brief Finds the clique number of the graph.
 *
 * 
 * The clique number of a graph is the size of the largest clique.
 *
 * The current implementation of this function searches
 * for maximal cliques using \ref igraph_maximal_cliques_callback() and keeps
 * track of the size of the largest clique that was found.
 *
 * \param graph The input graph.
 * \param no The clique number will be returned to the \c igraph_integer_t
 *   pointed by this variable.
 * \return Error code.
 *
 * \sa \ref igraph_cliques(), \ref igraph_largest_cliques().
 *
 * Time complexity: O(3^(|V|/3)) worst case.
 */
int igraph_clique_number(const igraph_t *graph, igraph_integer_t *no) {
    *no = 0;
    return igraph_maximal_cliques_callback(graph, &igraph_i_maximal_cliques_store_max_size, (void*)no, 0, 0);
}

static int igraph_i_maximal_or_largest_cliques_or_indsets(const igraph_t *graph,
        igraph_vector_ptr_t *res,
        igraph_integer_t *clique_number,
        igraph_bool_t keep_only_largest,
        igraph_bool_t complementer) {
    igraph_i_max_ind_vsets_data_t clqdata;
    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph), i;

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
    }

    clqdata.matrix_size = no_of_nodes;
    clqdata.keep_only_largest = keep_only_largest;

    if (complementer) {
        IGRAPH_CHECK(igraph_adjlist_init_complementer(graph, &clqdata.adj_list, IGRAPH_ALL, 0));
    } else {
        IGRAPH_CHECK(igraph_adjlist_init(
            graph, &clqdata.adj_list, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE
        ));
    }
    IGRAPH_FINALLY(igraph_adjlist_destroy, &clqdata.adj_list);

    clqdata.IS = IGRAPH_CALLOC(no_of_nodes, igraph_integer_t);
    if (clqdata.IS == 0) {
        IGRAPH_ERROR("igraph_i_maximal_or_largest_cliques_or_indsets failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, clqdata.IS);

    IGRAPH_VECTOR_INIT_FINALLY(&clqdata.deg, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(clqdata.deg)[i] = igraph_vector_int_size(igraph_adjlist_get(&clqdata.adj_list, i));
    }

    clqdata.buckets = IGRAPH_CALLOC(no_of_nodes + 1, igraph_set_t);
    if (clqdata.buckets == 0) {
        IGRAPH_ERROR("igraph_maximal_or_largest_cliques_or_indsets failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_i_free_set_array, clqdata.buckets);

    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_set_init(&clqdata.buckets[i], 0));
    }

    if (res) {
        igraph_vector_ptr_clear(res);
    }

    /* Do the show */
    clqdata.largest_set_size = 0;
    IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, &clqdata, 0));

    /* Cleanup */
    for (i = 0; i < no_of_nodes; i++) {
        igraph_set_destroy(&clqdata.buckets[i]);
    }
    igraph_adjlist_destroy(&clqdata.adj_list);
    igraph_vector_destroy(&clqdata.deg);
    igraph_free(clqdata.IS);
    igraph_free(clqdata.buckets);
    IGRAPH_FINALLY_CLEAN(4);

    if (clique_number) {
        *clique_number = clqdata.largest_set_size;
    }
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/glet.c0000644000175100001710000007555200000000000023223 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_graphlets.h"

#include "igraph_conversion.h"
#include "igraph_constructors.h"
#include "igraph_cliques.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_qsort.h"
#include "igraph_structural.h"

/**
 * \section graphlets_intro Introduction
 *
 * 
 * Graphlet decomposition models a weighted undirected graph
 * via the union of potentially overlapping dense social groups.
 * This is done by a two-step algorithm. In the first step, a candidate
 * set of groups (a candidate basis) is created by finding cliques
 * in the thresholded input graph. In the second step,
 * the graph is projected onto the candidate basis, resulting in a
 * weight coefficient for each clique in the candidate basis.
 * 
 *
 * 
 * For more information on graphlet decomposition, see
 * Hossein Azari Soufiani and Edoardo M Airoldi: "Graphlet decomposition of a weighted network",
 * https://arxiv.org/abs/1203.2821 and http://proceedings.mlr.press/v22/azari12/azari12.pdf
 * 
 *
 * 
 * igraph contains three functions for performing the graphlet
 * decomponsition of a graph. The first is \ref igraph_graphlets(), which
 * performs both steps of the method and returns a list of subgraphs
 * with their corresponding weights. The other two functions
 * correspond to the first and second steps of the algorithm, and they are
 * useful if the user wishes to perform them individually:
 * \ref igraph_graphlets_candidate_basis() and
 * \ref igraph_graphlets_project().
 * 
 *
 * 
 * 
 * Note: The term "graphlet" is used for several unrelated concepts
 * in the literature. If you are looking to count induced subgraphs, see
 * \ref igraph_motifs_randesu() and \ref igraph_subisomorphic_lad().
 * 
 * 
 */

typedef struct {
    igraph_vector_int_t *resultids;
    igraph_t *result;
    igraph_vector_t *resultweights;
    int nc;
} igraph_i_subclique_next_free_t;

static void igraph_i_subclique_next_free(void *ptr) {
    igraph_i_subclique_next_free_t *data = ptr;
    int i;
    if (data->resultids) {
        for (i = 0; i < data->nc; i++) {
            if (data->resultids + i) {
                igraph_vector_int_destroy(data->resultids + i);
            }
        }
        IGRAPH_FREE(data->resultids);
    }
    if (data->result) {
        for (i = 0; i < data->nc; i++) {
            if (data->result + i) {
                igraph_destroy(data->result + i);
            }
        }
        IGRAPH_FREE(data->result);
    }
    if (data->resultweights) {
        for (i = 0; i < data->nc; i++) {
            if (data->resultweights + i) {
                igraph_vector_destroy(data->resultweights + i);
            }
        }
        IGRAPH_FREE(data->resultweights);
    }
}

/**
 * \function igraph_i_subclique_next
 * Calculate subcliques of the cliques found at the previous level
 *
 * \param graph Input graph.
 * \param weight Edge weights.
 * \param ids The ids of the vertices in the input graph.
 * \param cliques A list of vectors, vertex ids for cliques.
 * \param result The result is stored here, a list of graphs is stored
 *        here.
 * \param resultids The ids of the vertices in the result graphs is
 *        stored here.
 * \param clique_thr The thresholds for the cliques are stored here,
 *        if not a null pointer.
 * \param next_thr The next thresholds for the cliques are stored
 *        here, if not a null pointer.
 *
 */

static int igraph_i_subclique_next(const igraph_t *graph,
                                   const igraph_vector_t *weights,
                                   const igraph_vector_int_t *ids,
                                   const igraph_vector_ptr_t *cliques,
                                   igraph_t **result,
                                   igraph_vector_t **resultweights,
                                   igraph_vector_int_t **resultids,
                                   igraph_vector_t *clique_thr,
                                   igraph_vector_t *next_thr) {

    /* The input is a set of cliques, that were found at a previous level.
       For each clique, we calculate the next threshold, drop the isolate
       vertices, and create a new graph from them. */

    igraph_vector_int_t mark, map;
    igraph_vector_int_t edges;
    igraph_vector_t neis, newedges;
    igraph_integer_t c, nc = igraph_vector_ptr_size(cliques);
    igraph_integer_t no_of_nodes = igraph_vcount(graph);
    igraph_integer_t no_of_edges = igraph_ecount(graph);
    igraph_i_subclique_next_free_t freedata = { 0, 0, 0, nc };

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid length of weight vector", IGRAPH_EINVAL);
    }

    if (igraph_vector_int_size(ids) != no_of_nodes) {
        IGRAPH_ERROR("Invalid length of ID vector", IGRAPH_EINVAL);
    }

    IGRAPH_FINALLY(igraph_i_subclique_next_free, &freedata);
    *resultids = IGRAPH_CALLOC(nc, igraph_vector_int_t);
    if (!*resultids) {
        IGRAPH_ERROR("Cannot calculate next cliques", IGRAPH_ENOMEM);
    }
    freedata.resultids = *resultids;
    *resultweights = IGRAPH_CALLOC(nc, igraph_vector_t);
    if (!*resultweights) {
        IGRAPH_ERROR("Cannot calculate next cliques", IGRAPH_ENOMEM);
    }
    freedata.resultweights = *resultweights;
    *result = IGRAPH_CALLOC(nc, igraph_t);
    if (!*result) {
        IGRAPH_ERROR("Cannot calculate next cliques", IGRAPH_ENOMEM);
    }
    freedata.result = *result;

    igraph_vector_init(&newedges, 100);
    IGRAPH_FINALLY(igraph_vector_destroy, &newedges);
    igraph_vector_int_init(&mark, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &mark);
    igraph_vector_int_init(&map, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &map);
    igraph_vector_int_init(&edges, 100);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &edges);
    igraph_vector_init(&neis, 10);
    IGRAPH_FINALLY(igraph_vector_destroy, &neis);

    if (clique_thr) {
        igraph_vector_resize(clique_thr, nc);
    }
    if (next_thr)   {
        igraph_vector_resize(next_thr,   nc);
    }

    /* Iterate over all cliques. We will create graphs for all
       subgraphs defined by the cliques. */

    for (c = 0; c < nc; c++) {
        igraph_vector_t *clique = VECTOR(*cliques)[c];
        igraph_real_t minweight = IGRAPH_INFINITY, nextweight = IGRAPH_INFINITY;
        igraph_integer_t e, v, clsize = igraph_vector_size(clique);
        igraph_integer_t noe, nov = 0;
        igraph_vector_int_t *newids = (*resultids) + c;
        igraph_vector_t *neww = (*resultweights) + c;
        igraph_t *newgraph = (*result) + c;
        igraph_vector_int_clear(&edges);
        igraph_vector_clear(&newedges);

        /* --------------------------------------------------- */

        /* Iterate over the vertices of a clique and find the
           edges within the clique, put them in a list.
           At the same time, search for the minimum edge weight within
           the clique and the next edge weight if any. */

        for (v = 0; v < clsize; v++) {
            igraph_integer_t i, neilen, node = VECTOR(*clique)[v];
            igraph_incident(graph, &neis, node, IGRAPH_ALL);
            neilen = igraph_vector_size(&neis);
            VECTOR(mark)[node] = c + 1;
            for (i = 0; i < neilen; i++) {
                igraph_integer_t edge = VECTOR(neis)[i];
                igraph_integer_t nei = IGRAPH_OTHER(graph, edge, node);
                if (VECTOR(mark)[nei] == c + 1) {
                    igraph_real_t w = VECTOR(*weights)[edge];
                    igraph_vector_int_push_back(&edges, edge);
                    if (w < minweight) {
                        nextweight = minweight;
                        minweight = w;
                    } else if (w > minweight && w < nextweight) {
                        nextweight = w;
                    }
                }
            }
        } /* v < clsize */

        /* --------------------------------------------------- */

        /* OK, we have stored the edges and found the weight of
           the clique and the next weight to consider */

        if (clique_thr) {
            VECTOR(*clique_thr)[c] = minweight;
        }
        if (next_thr)   {
            VECTOR(*next_thr  )[c] = nextweight;
        }

        /* --------------------------------------------------- */

        /* Now we create the subgraph from the edges above the next
           threshold, and their incident vertices. */

        igraph_vector_int_init(newids, 0);
        igraph_vector_init(neww, 0);

        /* We use mark[] to denote the vertices already mapped to
           the new graph. If this is -(c+1), then the vertex was
           mapped, otherwise it was not. The mapping itself is in
           map[]. */

        noe = igraph_vector_int_size(&edges);
        for (e = 0; e < noe; e++) {
            igraph_integer_t edge = VECTOR(edges)[e];
            igraph_integer_t from, to;
            igraph_real_t w = VECTOR(*weights)[edge];
            igraph_edge(graph, edge, &from, &to);
            if (w >= nextweight) {
                if (VECTOR(mark)[from] == c + 1) {
                    VECTOR(map)[from] = nov++;
                    VECTOR(mark)[from] = -(c + 1);
                    igraph_vector_int_push_back(newids, VECTOR(*ids)[from]);
                }
                if (VECTOR(mark)[to] == c + 1) {
                    VECTOR(map)[to] = nov++;
                    VECTOR(mark)[to] = -(c + 1);
                    igraph_vector_int_push_back(newids, VECTOR(*ids)[to]);
                }
                igraph_vector_push_back(neww, w);
                igraph_vector_push_back(&newedges, VECTOR(map)[from]);
                igraph_vector_push_back(&newedges, VECTOR(map)[to]);
            }
        }

        igraph_create(newgraph, &newedges, nov, IGRAPH_UNDIRECTED);

        /* --------------------------------------------------- */

    } /* c < nc */

    igraph_vector_destroy(&neis);
    igraph_vector_int_destroy(&edges);
    igraph_vector_int_destroy(&mark);
    igraph_vector_int_destroy(&map);
    igraph_vector_destroy(&newedges);
    IGRAPH_FINALLY_CLEAN(6);  /* + freedata */

    return 0;
}

static void igraph_i_graphlets_destroy_vectorlist(igraph_vector_ptr_t *vl) {
    int i, n = igraph_vector_ptr_size(vl);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = (igraph_vector_t*) VECTOR(*vl)[i];
        if (v) {
            igraph_vector_destroy(v);
        }
    }
    igraph_vector_ptr_destroy(vl);
}

static int igraph_i_graphlets(const igraph_t *graph,
                              const igraph_vector_t *weights,
                              igraph_vector_ptr_t *cliques,
                              igraph_vector_t *thresholds,
                              const igraph_vector_int_t *ids,
                              igraph_real_t startthr) {

    /* This version is different from the main function, and is
       appropriate to use in recursive calls, because it _adds_ the
       results to 'cliques' and 'thresholds' and uses the supplied
       'startthr' */

    igraph_vector_ptr_t mycliques;
    int no_of_edges = igraph_ecount(graph);
    igraph_vector_t subv;
    igraph_t subg;
    int i, nographs, nocliques;
    igraph_t *newgraphs = 0;
    igraph_vector_t *newweights = 0;
    igraph_vector_int_t *newids = 0;
    igraph_vector_t clique_thr, next_thr;
    igraph_i_subclique_next_free_t freedata = { 0, 0, 0, 0 };

    IGRAPH_CHECK(igraph_vector_ptr_init(&mycliques, 0));
    IGRAPH_FINALLY(igraph_i_graphlets_destroy_vectorlist, &mycliques);
    IGRAPH_VECTOR_INIT_FINALLY(&subv, 0);

    /* We start by finding cliques at the lowest threshold */
    for (i = 0; i < no_of_edges; i++) {
        if (VECTOR(*weights)[i] >= startthr) {
            IGRAPH_CHECK(igraph_vector_push_back(&subv, i));
        }
    }
    igraph_subgraph_edges(graph, &subg, igraph_ess_vector(&subv),
                          /*delete_vertices=*/ 0);
    IGRAPH_FINALLY(igraph_destroy, &subg);
    igraph_maximal_cliques(&subg, &mycliques, /*min_size=*/ 0, /*max_size=*/ 0);
    igraph_destroy(&subg);
    IGRAPH_FINALLY_CLEAN(1);
    nocliques = igraph_vector_ptr_size(&mycliques);

    igraph_vector_destroy(&subv);
    IGRAPH_FINALLY_CLEAN(1);

    /* Get the next cliques and thresholds */
    IGRAPH_VECTOR_INIT_FINALLY(&next_thr, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&clique_thr, 0);

    igraph_i_subclique_next(graph, weights, ids, &mycliques,
                            &newgraphs, &newweights, &newids,
                            &clique_thr, &next_thr);

    freedata.result = newgraphs;
    freedata.resultids = newids;
    freedata.resultweights = newweights;
    freedata.nc = nocliques;
    IGRAPH_FINALLY(igraph_i_subclique_next_free, &freedata);

    /* Store cliques at the current level */
    igraph_vector_append(thresholds, &clique_thr);
    for (i = 0; i < nocliques; i++) {
        igraph_vector_t *cl = (igraph_vector_t*) VECTOR(mycliques)[i];
        int j, n = igraph_vector_size(cl);
        for (j = 0; j < n; j++) {
            int node = VECTOR(*cl)[j];
            VECTOR(*cl)[j] = VECTOR(*ids)[node];
        }
        igraph_vector_sort(cl);
    }
    igraph_vector_ptr_append(cliques, &mycliques);

    /* Recursive calls for cliques found */
    nographs = igraph_vector_ptr_size(&mycliques);
    for (i = 0; i < nographs; i++) {
        igraph_t *g = newgraphs + i;
        if (igraph_vcount(g) > 1) {
            igraph_vector_t *w_sub = newweights + i;
            igraph_vector_int_t *ids_sub = newids + i;
            igraph_i_graphlets(g, w_sub, cliques, thresholds, ids_sub, VECTOR(next_thr)[i]);
        }
    }

    igraph_vector_destroy(&clique_thr);
    igraph_vector_destroy(&next_thr);
    igraph_i_subclique_next_free(&freedata);
    igraph_vector_ptr_destroy(&mycliques); /* contents was copied over */
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

typedef struct {
    const igraph_vector_ptr_t *cliques;
    const igraph_vector_t *thresholds;
} igraph_i_graphlets_filter_t;

static int igraph_i_graphlets_filter_cmp(void *data, const void *a, const void *b) {
    igraph_i_graphlets_filter_t *ddata = (igraph_i_graphlets_filter_t *) data;
    int *aa = (int*) a;
    int *bb = (int*) b;
    igraph_real_t t_a = VECTOR(*ddata->thresholds)[*aa];
    igraph_real_t t_b = VECTOR(*ddata->thresholds)[*bb];
    igraph_vector_t *v_a, *v_b;
    int s_a, s_b;

    if (t_a < t_b) {
        return -1;
    } else if (t_a > t_b) {
        return 1;
    }

    v_a = (igraph_vector_t*) VECTOR(*ddata->cliques)[*aa];
    v_b = (igraph_vector_t*) VECTOR(*ddata->cliques)[*bb];
    s_a = igraph_vector_size(v_a);
    s_b = igraph_vector_size(v_b);

    if (s_a < s_b) {
        return -1;
    } else if (s_a > s_b) {
        return 1;
    } else {
        return 0;
    }
}

static int igraph_i_graphlets_filter(igraph_vector_ptr_t *cliques,
                                     igraph_vector_t *thresholds) {

    /* Filter out non-maximal cliques. Every non-maximal clique is
       part of a maximal clique, at the same threshold.

       First we order the cliques, according to their threshold, and
       then according to their size. So when we look for a candidate
       superset, we only need to check the cliques next in the list,
       until their threshold is different. */

    int i, iptr, nocliques = igraph_vector_ptr_size(cliques);
    igraph_vector_int_t order;
    igraph_i_graphlets_filter_t sortdata = { cliques, thresholds };

    igraph_vector_int_init(&order, nocliques);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &order);
    for (i = 0; i < nocliques; i++) {
        VECTOR(order)[i] = i;
    }

    igraph_qsort_r(VECTOR(order), nocliques, sizeof(int), &sortdata,
                   igraph_i_graphlets_filter_cmp);

    for (i = 0; i < nocliques - 1; i++) {
        int ri = VECTOR(order)[i];
        igraph_vector_t *needle = VECTOR(*cliques)[ri];
        igraph_real_t thr_i = VECTOR(*thresholds)[ri];
        int n_i = igraph_vector_size(needle);
        int j = i + 1;

        for (j = i + 1; j < nocliques; j++) {
            int rj = VECTOR(order)[j];
            igraph_real_t thr_j = VECTOR(*thresholds)[rj];
            igraph_vector_t *hay;
            int n_j, pi = 0, pj = 0;

            /* Done, not found */
            if (thr_j != thr_i) {
                break;
            }

            /* Check size of hay */
            hay = VECTOR(*cliques)[rj];
            n_j = igraph_vector_size(hay);
            if (n_i > n_j) {
                continue;
            }

            /* Check if hay is a superset */
            while (pi < n_i && pj < n_j && n_i - pi <= n_j - pj) {
                int ei = VECTOR(*needle)[pi];
                int ej = VECTOR(*hay)[pj];
                if (ei < ej) {
                    break;
                } else if (ei > ej) {
                    pj++;
                } else {
                    pi++; pj++;
                }
            }
            if (pi == n_i) {
                /* Found, delete immediately */
                igraph_vector_destroy(needle);
                igraph_free(needle);
                VECTOR(*cliques)[ri] = 0;
                break;
            }
        }
    }

    /* Remove null pointers from the list of cliques */
    for (i = 0, iptr = 0; i < nocliques; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        if (v) {
            VECTOR(*cliques)[iptr] = v;
            VECTOR(*thresholds)[iptr] = VECTOR(*thresholds)[i];
            iptr++;
        }
    }
    igraph_vector_ptr_resize(cliques, iptr);
    igraph_vector_resize(thresholds, iptr);

    igraph_vector_int_destroy(&order);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_graphlets_candidate_basis
 * Calculate a candidate graphlets basis
 *
 * \param graph The input graph, it must be a simple graph, edge directions are
 *        ignored.
 * \param weights Weights of the edges, a vector.
 * \param cliques An initialized vector of pointers.
 *        The graphlet basis is stored here. Each element of the pointer
 *        vector will be a vector of vertex ids. Each elements must be
 *        destroyed using \ref igraph_vector_destroy() and \ref igraph_free().
 * \param thresholds An initialized vector, the (highest possible)
 *        weight thresholds for finding the basis subgraphs are stored
 *        here.
 * \return Error code.
 *
 * See also: \ref igraph_graphlets() and \ref igraph_graphlets_project().
 */

int igraph_graphlets_candidate_basis(const igraph_t *graph,
                                     const igraph_vector_t *weights,
                                     igraph_vector_ptr_t *cliques,
                                     igraph_vector_t *thresholds) {

    int no_of_nodes = igraph_vcount(graph);
    int no_of_edges = igraph_ecount(graph);
    igraph_real_t minthr;
    igraph_vector_int_t ids;
    igraph_bool_t simple;
    int i;

    /* Some checks */
    if (weights == NULL) {
        IGRAPH_ERROR("Graphlet functions require weighted graphs", IGRAPH_EINVAL);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_is_simple(graph, &simple));
    if (!simple) {
        IGRAPH_ERROR("Graphlets work on simple graphs only", IGRAPH_EINVAL);
    }

    minthr = igraph_vector_min(weights);
    igraph_vector_ptr_clear(cliques);
    igraph_vector_clear(thresholds);
    igraph_vector_int_init(&ids, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &ids);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(ids)[i] = i;
    }

    igraph_i_graphlets(graph, weights, cliques, thresholds, &ids, minthr);

    igraph_vector_int_destroy(&ids);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_i_graphlets_filter(cliques, thresholds);

    return 0;
}

/* TODO: not made static because it is used by the R interface */
int igraph_i_graphlets_project(const igraph_t *graph,
                               const igraph_vector_t *weights,
                               const igraph_vector_ptr_t *cliques,
                               igraph_vector_t *Mu, igraph_bool_t startMu,
                               int niter, int vid1) {

    int no_of_nodes = igraph_vcount(graph);
    int no_of_edges = igraph_ecount(graph);
    int no_cliques = igraph_vector_ptr_size(cliques);
    igraph_vector_int_t vcl, vclidx, ecl, eclidx, cel, celidx;
    igraph_vector_t edgelist, newweights, normfact;
    int i, total_vertices, e, ptr, total_edges;
    igraph_bool_t simple;

    /* Check arguments */
    if (weights == NULL) {
        IGRAPH_ERROR("Graphlet functions require weighted graphs", IGRAPH_EINVAL);
    }
    if (no_of_edges != igraph_vector_size(weights)) {
        IGRAPH_ERROR("Invalid weight vector size", IGRAPH_EINVAL);
    }
    if (startMu && igraph_vector_size(Mu) != no_cliques) {
        IGRAPH_ERROR("Invalid start coefficient vector size", IGRAPH_EINVAL);
    }
    if (niter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negative", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(igraph_is_simple(graph, &simple));
    if (!simple) {
        IGRAPH_ERROR("Graphlets work on simple graphs only", IGRAPH_EINVAL);
    }

    if (!startMu) {
        igraph_vector_resize(Mu, no_cliques);
        igraph_vector_fill(Mu, 1);
    }

    /* Count # cliques per vertex. Also, create an index
       for the edges per clique. */
    IGRAPH_CHECK(igraph_vector_int_init(&vclidx, no_of_nodes + 2));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &vclidx);
    IGRAPH_CHECK(igraph_vector_int_init(&celidx, no_cliques + 3));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &celidx);
    for (i = 0, total_vertices = 0, total_edges = 0; i < no_cliques; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        int j, n = igraph_vector_size(v);
        total_vertices += n;
        total_edges += n * (n - 1) / 2;
        VECTOR(celidx)[i + 2] = total_edges;
        for (j = 0; j < n; j++) {
            int vv = VECTOR(*v)[j] - vid1;
            VECTOR(vclidx)[vv + 2] += 1;
        }
    }
    VECTOR(celidx)[i + 2] = total_edges;

    /* Finalize index vector */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(vclidx)[i + 2] += VECTOR(vclidx)[i + 1];
    }

    /* Create vertex-clique list, the cliques for each vertex. */
    IGRAPH_CHECK(igraph_vector_int_init(&vcl, total_vertices));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &vcl);
    for (i = 0; i < no_cliques; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        int j, n = igraph_vector_size(v);
        for (j = 0; j < n; j++) {
            int vv = VECTOR(*v)[j] - vid1;
            int p = VECTOR(vclidx)[vv + 1];
            VECTOR(vcl)[p] = i;
            VECTOR(vclidx)[vv + 1] += 1;
        }
    }

    /* Create an edge-clique list, the cliques of each edge */
    IGRAPH_CHECK(igraph_vector_int_init(&ecl, total_edges));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &ecl);
    IGRAPH_CHECK(igraph_vector_int_init(&eclidx, no_of_edges + 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &eclidx);
    IGRAPH_CHECK(igraph_vector_init(&edgelist, no_of_edges * 2));
    IGRAPH_FINALLY(igraph_vector_destroy, &edgelist);
    IGRAPH_CHECK(igraph_get_edgelist(graph, &edgelist, /*by_col=*/ 0));
    for (i = 0, e = 0, ptr = 0; e < no_of_edges; e++) {
        int from = VECTOR(edgelist)[i++];
        int to = VECTOR(edgelist)[i++];
        int from_s = VECTOR(vclidx)[from];
        int from_e = VECTOR(vclidx)[from + 1];
        int to_s = VECTOR(vclidx)[to];
        int to_e = VECTOR(vclidx)[to + 1];
        VECTOR(eclidx)[e] = ptr;
        while (from_s < from_e && to_s < to_e) {
            int from_v = VECTOR(vcl)[from_s];
            int to_v = VECTOR(vcl)[to_s];
            if (from_v == to_v) {
                VECTOR(ecl)[ptr++] = from_v;
                from_s++; to_s++;
            } else if (from_v < to_v) {
                from_s++;
            } else {
                to_s++;
            }
        }
    }
    VECTOR(eclidx)[e] = ptr;

    igraph_vector_destroy(&edgelist);
    IGRAPH_FINALLY_CLEAN(1);

    /* Convert the edge-clique list to a clique-edge list */
    IGRAPH_CHECK(igraph_vector_int_init(&cel, total_edges));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &cel);
    for (i = 0; i < no_of_edges; i++) {
        int ecl_s = VECTOR(eclidx)[i], ecl_e = VECTOR(eclidx)[i + 1], j;
        for (j = ecl_s; j < ecl_e; j++) {
            int cl = VECTOR(ecl)[j];
            int epos = VECTOR(celidx)[cl + 1];
            VECTOR(cel)[epos] = i;
            VECTOR(celidx)[cl + 1] += 1;
        }
    }

    /* Normalizing factors for the iteration */
    IGRAPH_CHECK(igraph_vector_init(&normfact, no_cliques));
    IGRAPH_FINALLY(igraph_vector_destroy, &normfact);
    for (i = 0; i < no_cliques; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        int n = igraph_vector_size(v);
        VECTOR(normfact)[i] = n * (n + 1) / 2;
    }

    /* We have the clique-edge list, so do the projection now */
    IGRAPH_CHECK(igraph_vector_init(&newweights, no_of_edges));
    IGRAPH_FINALLY(igraph_vector_destroy, &newweights);
    for (i = 0; i < niter; i++) {
        for (e = 0; e < no_of_edges; e++) {
            int start = VECTOR(eclidx)[e];
            int end = VECTOR(eclidx)[e + 1];
            VECTOR(newweights)[e] = 0.0001;
            while (start < end) {
                int clique = VECTOR(ecl)[start++];
                VECTOR(newweights)[e] += VECTOR(*Mu)[clique];
            }
        }
        for (e = 0; e < no_cliques; e++) {
            igraph_real_t sumratio = 0;
            int start = VECTOR(celidx)[e];
            int end = VECTOR(celidx)[e + 1];
            while (start < end) {
                int edge = VECTOR(cel)[start++];
                sumratio += VECTOR(*weights)[edge] / VECTOR(newweights)[edge];
            }
            VECTOR(*Mu)[e] *= sumratio / VECTOR(normfact)[e];
        }
    }

    igraph_vector_destroy(&newweights);
    igraph_vector_destroy(&normfact);
    igraph_vector_int_destroy(&cel);
    igraph_vector_int_destroy(&eclidx);
    igraph_vector_int_destroy(&ecl);
    igraph_vector_int_destroy(&vcl);
    igraph_vector_int_destroy(&celidx);
    igraph_vector_int_destroy(&vclidx);
    IGRAPH_FINALLY_CLEAN(8);

    return 0;
}

/**
 * \function igraph_graphlets_project
 * Project a graph on a graphlets basis
 *
 * Note that the graph projected does not have to be the same that
 * was used to calculate the graphlet basis, but it is assumed that
 * it has the same number of vertices, and the vertex ids of the two
 * graphs match.
 * \param graph The input graph, it must be a simple graph, edge directions are
 *        ignored.
 * \param weights Weights of the edges in the input graph, a vector.
 * \param cliques The graphlet basis, a pointer vector, in which each
 *        element is a vector of vertex ids.
 * \param Mu An initialized vector, the weights of the graphlets will
 *        be stored here. This vector is also used to initialize the
 *        the weight vector for the iterative algorithm, if the
 *        \c startMu argument is true (non-zero).
 * \param startMu If true (non-zero), then the supplied Mu vector is
 *        used as the starting point of the iteration. Otherwise a
 *        constant 1 vector is used.
 * \param niter Integer scalar, the number of iterations to perform.
 * \return Error code.
 *
 * See also: \ref igraph_graphlets() and
 * \ref igraph_graphlets_candidate_basis().
 */

int igraph_graphlets_project(const igraph_t *graph,
                             const igraph_vector_t *weights,
                             const igraph_vector_ptr_t *cliques,
                             igraph_vector_t *Mu, igraph_bool_t startMu,
                             int niter) {

    return igraph_i_graphlets_project(graph, weights, cliques, Mu, startMu,
                                      niter, /*vid1=*/ 0);
}

typedef struct igraph_i_graphlets_order_t {
    const igraph_vector_ptr_t *cliques;
    const igraph_vector_t *Mu;
} igraph_i_graphlets_order_t;

static int igraph_i_graphlets_order_cmp(void *data, const void *a, const void *b) {
    igraph_i_graphlets_order_t *ddata = (igraph_i_graphlets_order_t*) data;
    int *aa = (int*) a;
    int *bb = (int*) b;
    igraph_real_t Mu_a = VECTOR(*ddata->Mu)[*aa];
    igraph_real_t Mu_b = VECTOR(*ddata->Mu)[*bb];

    if (Mu_a < Mu_b) {
        return 1;
    } else if (Mu_a > Mu_b) {
        return -1;
    } else {
        return 0;
    }
}

/**
 * \function igraph_graphlets
 * Calculate graphlets basis and project the graph on it
 *
 * This function simply calls \ref igraph_graphlets_candidate_basis()
 * and \ref igraph_graphlets_project(), and then orders the graphlets
 * according to decreasing weights.
 * \param graph The input graph, it must be a simple graph, edge directions are
 *        ignored.
 * \param weights Weights of the edges, a vector.
 * \param cliques An initialized vector of pointers.
 *        The graphlet basis is stored here. Each element of the pointer
 *        vector will be a vector of vertex ids.
 * \param Mu An initialized vector, the weights of the graphlets will
 *        be stored here.
 * \param niter Integer scalar, the number of iterations to perform
 *        for the projection step.
 * \return Error code.
 *
 * See also: \ref igraph_graphlets_candidate_basis() and
 * \ref igraph_graphlets_project().
 */

int igraph_graphlets(const igraph_t *graph,
                     const igraph_vector_t *weights,
                     igraph_vector_ptr_t *cliques,
                     igraph_vector_t *Mu, int niter) {

    int i, nocliques;
    igraph_vector_t thresholds;
    igraph_vector_int_t order;
    igraph_i_graphlets_order_t sortdata = { cliques, Mu };

    igraph_vector_init(&thresholds, 0);
    IGRAPH_FINALLY(igraph_vector_destroy, &thresholds);
    igraph_graphlets_candidate_basis(graph, weights, cliques, &thresholds);
    igraph_vector_destroy(&thresholds);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_graphlets_project(graph, weights, cliques, Mu, /*startMu=*/ 0, niter);

    nocliques = igraph_vector_ptr_size(cliques);
    igraph_vector_int_init(&order, nocliques);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &order);
    for (i = 0; i < nocliques; i++) {
        VECTOR(order)[i] = i;
    }
    igraph_qsort_r(VECTOR(order), nocliques, sizeof(int), &sortdata,
                   igraph_i_graphlets_order_cmp);

    igraph_vector_ptr_index_int(cliques, &order);
    igraph_vector_index_int(Mu, &order);

    igraph_vector_int_destroy(&order);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/maximal_cliques.c0000644000175100001710000004741500000000000025442 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_cliques.h"

#include "igraph_adjlist.h"
#include "igraph_constants.h"
#include "igraph_community.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_progress.h"

#include "core/interruption.h"

#define CONCAT2x(a,b) a ## b
#define CONCAT2(a,b) CONCAT2x(a,b)
#define FUNCTION(name,sfx) CONCAT2(name,sfx)

static int igraph_i_maximal_cliques_reorder_adjlists(
        const igraph_vector_int_t *PX,
        int PS, int PE, int XS, int XE,
        const igraph_vector_int_t *pos,
        igraph_adjlist_t *adjlist);

static int igraph_i_maximal_cliques_select_pivot(
        const igraph_vector_int_t *PX,
        int PS, int PE, int XS, int XE,
        const igraph_vector_int_t *pos,
        const igraph_adjlist_t *adjlist,
        int *pivot,
        igraph_vector_int_t *nextv,
        int oldPS, int oldXE);

static int igraph_i_maximal_cliques_down(
        igraph_vector_int_t *PX,
        int PS, int PE, int XS, int XE,
        igraph_vector_int_t *pos,
        igraph_adjlist_t *adjlist, int mynextv,
        igraph_vector_int_t *R,
        int *newPS, int *newXE);

static int igraph_i_maximal_cliques_PX(
        igraph_vector_int_t *PX, int PS, int *PE,
        int *XS, int XE, igraph_vector_int_t *pos,
        igraph_adjlist_t *adjlist, int v,
        igraph_vector_int_t *H);

static int igraph_i_maximal_cliques_up(
        igraph_vector_int_t *PX, int PS, int PE,
        int XS, int XE, igraph_vector_int_t *pos,
        igraph_adjlist_t *adjlist,
        igraph_vector_int_t *R,
        igraph_vector_int_t *H);

#define PRINT_PX do {                              \
        int j;                                 \
        printf("PX=");                             \
        for (j=0; j= sPS && avneipos <= sPE) {
                if (pp != avnei) {
                    int tmp = *avnei;
                    *avnei = *pp;
                    *pp = tmp;
                }
                pp++;
            }
        }
    }

    return IGRAPH_SUCCESS;
}

static int igraph_i_maximal_cliques_select_pivot(
        const igraph_vector_int_t *PX,
        int PS, int PE, int XS, int XE,
        const igraph_vector_int_t *pos,
        const igraph_adjlist_t *adjlist,
        int *pivot,
        igraph_vector_int_t *nextv,
        int oldPS, int oldXE) {
    igraph_vector_int_t *pivotvectneis;
    int i, pivotvectlen, j, usize = -1;
    int soldPS = oldPS + 1, soldXE = oldXE + 1, sPS = PS + 1, sPE = PE + 1;

    IGRAPH_UNUSED(XS);

    /* Choose a pivotvect, and bring up P vertices at the same time */
    for (i = PS; i <= XE; i++) {
        int av = VECTOR(*PX)[i];
        igraph_vector_int_t *avneis = igraph_adjlist_get(adjlist, av);
        int *avp = VECTOR(*avneis);
        int avlen = igraph_vector_int_size(avneis);
        int *ave = avp + avlen;
        int *avnei = avp, *pp = avp;

        for (; avnei < ave; avnei++) {
            int avneipos = VECTOR(*pos)[(int)(*avnei)];
            if (avneipos < soldPS || avneipos > soldXE) {
                break;
            }
            if (avneipos >= sPS && avneipos <= sPE) {
                if (pp != avnei) {
                    int tmp = *avnei;
                    *avnei = *pp;
                    *pp = tmp;
                }
                pp++;
            }
        }
        if ((j = pp - avp) > usize) {
            *pivot = av;
            usize = j;
        }
    }

    IGRAPH_CHECK(igraph_vector_int_push_back(nextv, -1));
    pivotvectneis = igraph_adjlist_get(adjlist, *pivot);
    pivotvectlen = igraph_vector_int_size(pivotvectneis);

    for (j = PS; j <= PE; j++) {
        int vcand = VECTOR(*PX)[j];
        igraph_bool_t nei = 0;
        int k = 0;
        for (k = 0; k < pivotvectlen; k++) {
            int unv = VECTOR(*pivotvectneis)[k];
            int unvpos = VECTOR(*pos)[unv];
            if (unvpos < sPS || unvpos > sPE) {
                break;
            }
            if (unv == vcand) {
                nei = 1;
                break;
            }
        }
        if (!nei) {
            IGRAPH_CHECK(igraph_vector_int_push_back(nextv, vcand));
        }
    }

    return IGRAPH_SUCCESS;
}

#define SWAP(p1,p2) do {            \
        int v1=VECTOR(*PX)[p1];         \
        int v2=VECTOR(*PX)[p2];         \
        VECTOR(*PX)[p1] = v2;           \
        VECTOR(*PX)[p2] = v1;           \
        VECTOR(*pos)[v1] = (p2)+1;          \
        VECTOR(*pos)[v2] = (p1)+1;          \
    } while (0)

static int igraph_i_maximal_cliques_down(igraph_vector_int_t *PX,
                                         int PS, int PE, int XS, int XE,
                                         igraph_vector_int_t *pos,
                                         igraph_adjlist_t *adjlist, int mynextv,
                                         igraph_vector_int_t *R,
                                         int *newPS, int *newXE) {

    igraph_vector_int_t *vneis = igraph_adjlist_get(adjlist, mynextv);
    int j, vneislen = igraph_vector_int_size(vneis);
    int sPS = PS + 1, sPE = PE + 1, sXS = XS + 1, sXE = XE + 1;

    *newPS = PE + 1; *newXE = XS - 1;
    for (j = 0; j < vneislen; j++) {
        int vnei = VECTOR(*vneis)[j];
        int vneipos = VECTOR(*pos)[vnei];
        if (vneipos >= sPS && vneipos <= sPE) {
            (*newPS)--;
            SWAP(vneipos - 1, *newPS);
        } else if (vneipos >= sXS && vneipos <= sXE) {
            (*newXE)++;
            SWAP(vneipos - 1, *newXE);
        }
    }

    IGRAPH_CHECK(igraph_vector_int_push_back(R, mynextv));

    return IGRAPH_SUCCESS;
}

#undef SWAP

static int igraph_i_maximal_cliques_PX(igraph_vector_int_t *PX, int PS, int *PE,
                                       int *XS, int XE, igraph_vector_int_t *pos,
                                       igraph_adjlist_t *adjlist, int v,
                                       igraph_vector_int_t *H) {

    int vpos = VECTOR(*pos)[v] - 1;
    int tmp = VECTOR(*PX)[*PE];

    IGRAPH_UNUSED(PS);
    IGRAPH_UNUSED(XE);
    IGRAPH_UNUSED(adjlist);

    VECTOR(*PX)[vpos] = tmp;
    VECTOR(*PX)[*PE] = v;
    VECTOR(*pos)[v] = (*PE) + 1;
    VECTOR(*pos)[tmp] = vpos + 1;
    (*PE)--; (*XS)--;
    IGRAPH_CHECK(igraph_vector_int_push_back(H, v));

    return IGRAPH_SUCCESS;
}

static int igraph_i_maximal_cliques_up(igraph_vector_int_t *PX, int PS, int PE,
                                       int XS, int XE, igraph_vector_int_t *pos,
                                       igraph_adjlist_t *adjlist,
                                       igraph_vector_int_t *R,
                                       igraph_vector_int_t *H) {
    int vv;

    IGRAPH_UNUSED(PS);
    IGRAPH_UNUSED(XE);
    IGRAPH_UNUSED(adjlist);

    igraph_vector_int_pop_back(R);

    while ((vv = igraph_vector_int_pop_back(H)) != -1) {
        int vvpos = VECTOR(*pos)[vv];
        int tmp = VECTOR(*PX)[XS];
        VECTOR(*PX)[XS] = vv;
        VECTOR(*PX)[vvpos - 1] = tmp;
        VECTOR(*pos)[vv] = XS + 1;
        VECTOR(*pos)[tmp] = vvpos;
        PE++; XS++;
    }

    return 0;
}

/**
 * \function igraph_maximal_cliques
 * \brief Finds all maximal cliques in a graph.
 *
 * 
 * A maximal clique is a clique which can't be extended any more by
 * adding a new vertex to it.
 *
 * 
 * If you are only interested in the size of the largest clique in the
 * graph, use \ref igraph_clique_number() instead.
 *
 * 
 * The current implementation uses a modified Bron-Kerbosch
 * algorithm to find the maximal cliques, see: David Eppstein,
 * Maarten Löffler, Darren Strash: Listing All Maximal Cliques in
 * Sparse Graphs in Near-Optimal Time. Algorithms and Computation,
 * Lecture Notes in Computer Science Volume 6506, 2010, pp 403-414.
 *
 * The implementation of this function changed between
 * igraph 0.5 and 0.6 and also between 0.6 and 0.7, so the order of
 * the cliques and the order of vertices within the cliques will
 * almost surely be different between these three versions.
 *
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, i.e. \p res will contain pointers to \ref igraph_vector_t
 *   objects which contain the indices of vertices involved in a clique.
 *   The pointer vector will be resized if needed but note that the
 *   objects in the pointer vector will not be freed. Note that vertices
 *   of a clique may be returned in arbitrary order.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_independent_vertex_sets(), \ref
 * igraph_clique_number()
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.
 *
 * \example examples/simple/igraph_maximal_cliques.c
 */

int igraph_maximal_cliques(const igraph_t *graph,
                           igraph_vector_ptr_t *res,
                           igraph_integer_t min_size,
                           igraph_integer_t max_size);

#define IGRAPH_MC_ORIG
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_ORIG

/**
 * \function igraph_maximal_cliques_count
 * Count the number of maximal cliques in a graph
 *
 * 
 * The current implementation uses a modified Bron-Kerbosch
 * algorithm to find the maximal cliques, see: David Eppstein,
 * Maarten Löffler, Darren Strash: Listing All Maximal Cliques in
 * Sparse Graphs in Near-Optimal Time. Algorithms and Computation,
 * Lecture Notes in Computer Science Volume 6506, 2010, pp 403-414.
 *
 * \param graph The input graph.
 * \param res Pointer to an \c igraph_integer_t; the number of maximal
 *   cliques will be stored here.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques().
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.
 *
 * \example examples/simple/igraph_maximal_cliques.c
 */

int igraph_maximal_cliques_count(const igraph_t *graph,
                                 igraph_integer_t *res,
                                 igraph_integer_t min_size,
                                 igraph_integer_t max_size);

#define IGRAPH_MC_COUNT
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_COUNT

/**
 * \function igraph_maximal_cliques_file
 * \brief Find maximal cliques and write them to a file.
 *
 * This function enumerates all maximal cliques and writes them to file.
 *
 * 
 *
 * Edge directions are ignored.
 *
 * 
 *
 * \param graph The input graph.
 * \param outfile Pointer to the output file, it should be writable.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques().
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.*
 *
 */

int igraph_maximal_cliques_file(const igraph_t *graph,
                                FILE *outfile,
                                igraph_integer_t min_size,
                                igraph_integer_t max_size);

#define IGRAPH_MC_FILE
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_FILE

/**
 * \function igraph_maximal_cliques_subset
 * Maximal cliques for a subset of initial vertices
 *
 * This function enumerates all maximal cliques for a subset of initial
 * vertices and writes them to file.
 *
 * 
 *
 * Edge directions are ignored.
 *
 * 
 *
 * \param graph The input graph.
 * \param subset Pointer to an \c  igraph_vector_int_t containing the
 *   subset of initial vertices
 * \param res Pointer to an \c igraph_ptr_t; the cliques will be
 *   stored here
 * \param no Pointer to an \c igraph_integer_t; the number of maximal
 *   cliques will be stored here.
 * \param outfile Pointer to an output file or \c NULL.
 *   When not \c NULL, the file should be writable.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques().
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.
 *
 */

int igraph_maximal_cliques_subset(const igraph_t *graph,
                                  igraph_vector_int_t *subset,
                                  igraph_vector_ptr_t *res,
                                  igraph_integer_t *no,
                                  FILE *outfile,
                                  igraph_integer_t min_size,
                                  igraph_integer_t max_size);

#define IGRAPH_MC_FULL
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_FULL


/**
 * \function igraph_maximal_cliques_callback
 * \brief Finds maximal cliques in a graph and calls a function for each one.
 *
 * This function enumerates all maximal cliques within the given size range
 * and calls \p cliquehandler_fn for each of them. The cliques are passed to the
 * callback function as a pointer to an \ref igraph_vector_t.  Destroying and
 * freeing this vector is left up to the user.  Use \ref igraph_vector_destroy()
 * to destroy it first, then free it using \ref igraph_free().
 *
 * 
 *
 * Edge directions are ignored.
 *
 * 
 *
 * \param graph The input graph.
 * \param cliquehandler_fn Callback function to be called for each clique.
 * See also \ref igraph_clique_handler_t.
 * \param arg Extra argument to supply to \p cliquehandler_fn.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques().
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.
 *
 */

int igraph_maximal_cliques_callback(const igraph_t *graph,
                                    igraph_clique_handler_t *cliquehandler_fn, void *arg,
                                    igraph_integer_t min_size, igraph_integer_t max_size);

#define IGRAPH_MC_CALLBACK
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_CALLBACK


/**
 * \function igraph_maximal_cliques_hist
 * \brief Counts the number of maximal cliques of each size in a graph.
 *
 * This function counts how many maximal cliques of each size are present in
 * the graph. Size-1 maximal cliques are simply isolated vertices.
 *
 * 
 *
 * Edge directions are ignored.
 *
 * 
 *
 * \param graph The input graph.
 * \param hist Pointer to an initialized vector. The result will be stored
 * here. The first element will store the number of size-1 maximal cliques,
 * the second element the number of size-2 maximal cliques, etc.
 * For cliques smaller than \p min_size, zero counts will be returned.
 * \param min_size Integer giving the minimum size of the cliques to be
 *   returned. If negative or zero, no lower bound will be used.
 * \param max_size Integer giving the maximum size of the cliques to be
 *   returned. If negative or zero, no upper bound will be used.
 * \return Error code.
 *
 * \sa \ref igraph_maximal_cliques().
 *
 * Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy
 * of the graph, this is typically small for sparse graphs.
 *
 */

int igraph_maximal_cliques_hist(const igraph_t *graph,
                                igraph_vector_t *hist,
                                igraph_integer_t min_size,
                                igraph_integer_t max_size);

#define IGRAPH_MC_HIST
#include "maximal_cliques_template.h"
#undef IGRAPH_MC_HIST
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/cliques/maximal_cliques_template.h0000644000175100001710000003425700000000000027342 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifdef IGRAPH_MC_ORIG
#define RESTYPE igraph_vector_ptr_t *res
#define RESNAME res
#define SUFFIX
#define RECORD do {                         \
        igraph_vector_t *cl=IGRAPH_CALLOC(1, igraph_vector_t);      \
        int j;                              \
        if (!cl) {                              \
            IGRAPH_ERROR("Cannot list maximal cliques", IGRAPH_ENOMEM);   \
        }                                   \
        IGRAPH_CHECK(igraph_vector_ptr_push_back(res, cl));             \
        IGRAPH_CHECK(igraph_vector_init(cl, clsize));                   \
        for (j=0; j hsize) { \
            long hcapacity = igraph_vector_capacity(hist); \
            long j; \
            int err; \
            if (hcapacity < clsize && clsize < 2*hcapacity) \
                err = igraph_vector_reserve(hist, 2*hcapacity); \
            err = igraph_vector_resize(hist, clsize); \
            if (err != IGRAPH_SUCCESS) \
                IGRAPH_ERROR("Cannot count maximal cliques", IGRAPH_ENOMEM); \
            for (j=hsize; j < clsize; j++) \
                VECTOR(*hist)[j] = 0; \
        } \
        VECTOR(*hist)[clsize-1] += 1; \
    } while (0)
#define FINALLY \
    igraph_vector_clear(hist); \
    igraph_vector_reserve(hist, 50); /* initially reserve space for 50 elements */
#define CLEANUP
#define FOR_LOOP_OVER_VERTICES for (i=0; i PE && XS > XE) {
        /* Found a maximum clique, report it */
        int clsize = igraph_vector_int_size(R);
        if (min_size <= clsize && (clsize <= max_size || max_size <= 0)) {
            RECORD;
        }
    } else if (PS <= PE) {
        /* Select a pivot element */
        int pivot, mynextv;
        IGRAPH_CHECK(igraph_i_maximal_cliques_select_pivot(
            PX, PS, PE, XS, XE, pos, adjlist, &pivot, nextv, oldPS, oldXE
        ));
        while ((mynextv = igraph_vector_int_pop_back(nextv)) != -1) {
            int newPS, newXE;

            /* Going down, prepare */
            IGRAPH_CHECK(igraph_i_maximal_cliques_down(
                PX, PS, PE, XS, XE, pos, adjlist, mynextv, R, &newPS, &newXE
            ));
            /* Recursive call */
            err = FUNCTION(igraph_i_maximal_cliques_bk, SUFFIX)(
                      PX, newPS, PE, XS, newXE, PS, XE, R,
                      pos, adjlist, RESNAME, nextv, H,
                      min_size, max_size);

            if (err == IGRAPH_STOP) {
                return err;
            } else {
                IGRAPH_CHECK(err);
            }
            /* Putting v from P to X */
            if (igraph_vector_int_tail(nextv) != -1) {
                IGRAPH_CHECK(igraph_i_maximal_cliques_PX(
                    PX, PS, &PE, &XS, XE, pos, adjlist, mynextv, H
                ));
            }
        }
    }

    /* Putting back vertices from X to P, see notes in H */
    IGRAPH_CHECK(igraph_i_maximal_cliques_up(PX, PS, PE, XS, XE, pos, adjlist, R, H));

    return 0;
}

int FUNCTION(igraph_maximal_cliques, SUFFIX)(
    const igraph_t *graph,
    RESTYPE,
    igraph_integer_t min_size,
    igraph_integer_t max_size) {

    /* Implementation details. TODO */

    igraph_vector_int_t PX, R, H, pos, nextv;
    igraph_vector_t coreness, order;
    igraph_vector_int_t rank; /* TODO: this is not needed */
    int i, ii, nn, no_of_nodes = igraph_vcount(graph);
    igraph_adjlist_t adjlist, fulladjlist;
    igraph_real_t pgreset = round(no_of_nodes / 100.0), pg = pgreset, pgc = 0;
    int err;
    IGRAPH_UNUSED(nn);

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("Edge directions are ignored for maximal clique "
                       "calculation");
    }

    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&rank, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&coreness, no_of_nodes);
    IGRAPH_CHECK(igraph_coreness(graph, &coreness, /*mode=*/ IGRAPH_ALL));
    IGRAPH_CHECK(igraph_vector_qsort_ind(&coreness, &order, /*descending=*/ 0));
    for (ii = 0; ii < no_of_nodes; ii++) {
        int v = VECTOR(order)[ii];
        VECTOR(rank)[v] = ii;
    }

    igraph_vector_destroy(&coreness);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    igraph_adjlist_init(graph, &fulladjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    IGRAPH_FINALLY(igraph_adjlist_destroy, &fulladjlist);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&PX, 20);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&R,  20);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&H, 100);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&pos, no_of_nodes);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&nextv, 100);

    FINALLY;

    FOR_LOOP_OVER_VERTICES {
        int v;
        int vrank;
        igraph_vector_int_t *vneis;
        int vdeg;
        int Pptr, Xptr, PS, PE, XS, XE;
        int j;

        FOR_LOOP_OVER_VERTICES_PREPARE;

        v = VECTOR(order)[i];
        vrank = VECTOR(rank)[v];
        vneis = igraph_adjlist_get(&fulladjlist, v);
        vdeg = igraph_vector_int_size(vneis);
        Pptr = 0; Xptr = vdeg - 1; PS = 0; XE = vdeg - 1;

        pg--;
        if (pg <= 0) {
            IGRAPH_PROGRESS("Maximal cliques: ", pgc++, NULL);
            pg = pgreset;
        }

        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_vector_int_resize(&PX, vdeg));
        IGRAPH_CHECK(igraph_vector_int_resize(&R, 1));
        IGRAPH_CHECK(igraph_vector_int_resize(&H, 1));
        igraph_vector_int_null(&pos); /* TODO: makes it quadratic? */
        IGRAPH_CHECK(igraph_vector_int_resize(&nextv, 1));

        VECTOR(H)[0] = -1;      /* marks the end of the recursion */
        VECTOR(nextv)[0] = -1;

        /* ================================================================*/
        /* P <- G(v[i]) intersect { v[i+1], ..., v[n-1] }
           X <- G(v[i]) intersect { v[0], ..., v[i-1] } */

        VECTOR(R)[0] = v;
        for (j = 0; j < vdeg; j++) {
            int vx = VECTOR(*vneis)[j];
            if (VECTOR(rank)[vx] > vrank) {
                VECTOR(PX)[Pptr] = vx;
                VECTOR(pos)[vx] = Pptr + 1;
                Pptr++;
            } else if (VECTOR(rank)[vx] < vrank) {
                VECTOR(PX)[Xptr] = vx;
                VECTOR(pos)[vx] = Xptr + 1;
                Xptr--;
            }
        }

        PE = Pptr - 1; XS = Xptr + 1; /* end of P, start of X in PX */

        /* Create an adjacency list that is specific to the
           v vertex. It only contains 'v' and its neighbors. Moreover, we
           only deal with the vertices in P and X (and R). */
        IGRAPH_CHECK(igraph_vector_int_update(
            igraph_adjlist_get(&adjlist, v),
            igraph_adjlist_get(&fulladjlist, v)
        ));
        for (j = 0; j <= vdeg - 1; j++) {
            int vv = VECTOR(PX)[j];
            igraph_vector_int_t *fadj = igraph_adjlist_get(&fulladjlist, vv);
            igraph_vector_int_t *radj = igraph_adjlist_get(&adjlist, vv);
            int k, fn = igraph_vector_int_size(fadj);
            igraph_vector_int_clear(radj);
            for (k = 0; k < fn; k++) {
                int nei = VECTOR(*fadj)[k];
                int neipos = VECTOR(pos)[nei] - 1;
                if (neipos >= PS && neipos <= XE) {
                    IGRAPH_CHECK(igraph_vector_int_push_back(radj, nei));
                }
            }
        }

        /* Reorder the adjacency lists, according to P and X. */
        IGRAPH_CHECK(igraph_i_maximal_cliques_reorder_adjlists(
            &PX, PS, PE, XS, XE, &pos, &adjlist
        ));

        err = FUNCTION(igraph_i_maximal_cliques_bk, SUFFIX)(
                &PX, PS, PE, XS, XE, PS, XE, &R, &pos,
                &adjlist, RESNAME, &nextv, &H, min_size,
                max_size);
        if (err == IGRAPH_STOP) {
            break;
        } else {
            IGRAPH_CHECK(err);
        }
    }

    IGRAPH_PROGRESS("Maximal cliques: ", 100.0, NULL);

    CLEANUP;

    igraph_vector_int_destroy(&nextv);
    igraph_vector_int_destroy(&pos);
    igraph_vector_int_destroy(&H);
    igraph_vector_int_destroy(&R);
    igraph_vector_int_destroy(&PX);
    igraph_adjlist_destroy(&fulladjlist);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_int_destroy(&rank);
    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

#undef RESTYPE
#undef RESNAME
#undef SUFFIX
#undef RECORD
#undef FINALLY
#undef CLEANUP
#undef FOR_LOOP_OVER_VERTICES
#undef FOR_LOOP_OVER_VERTICES_PREPARE
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4871404
igraph-0.9.9/vendor/source/igraph/src/community/0000755000175100001710000000000000000000000022465 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/community_misc.c0000644000175100001710000007472200000000000025704 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"
#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_arpack.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_progress.h"
#include "igraph_stack.h"
#include "igraph_spmatrix.h"
#include "igraph_statusbar.h"
#include "igraph_conversion.h"
#include "igraph_centrality.h"
#include "igraph_structural.h"

#include "core/indheap.h"
#include "core/interruption.h"

#include "config.h"

#include 
#include 

#ifdef USING_R
    #include 
#endif

/**
 * \function igraph_community_to_membership
 * \brief Create membership vector from community structure dendrogram
 *
 * This function creates a membership vector from a community
 * structure dendrogram. A membership vector contains for each vertex
 * the id of its graph component, the graph components are numbered
 * from zero, see the same argument of \ref igraph_clusters() for an
 * example of a membership vector.
 *
 * 
 * Many community detection algorithms return with a \em merges
 * matrix, \ref igraph_community_walktrap() and \ref
 * igraph_community_edge_betweenness() are two examples. The matrix
 * contains the merge operations performed while mapping the
 * hierarchical structure of a network. If the matrix has \c n-1 rows,
 * where \c n is the number of vertices in the graph, then it contains
 * the hierarchical structure of the whole network and it is called a
 * dendrogram.
 *
 * 
 * This function performs \p steps merge operations as prescribed by
 * the \p merges matrix and returns the current state of the network.
 *
 * 
 * If \p merges is not a complete dendrogram, it is possible to
 * take \p steps steps if \p steps is not bigger than the number
 * lines in \p merges.
 * \param merges The two-column matrix containing the merge
 *    operations. See \ref igraph_community_walktrap() for the
 *    detailed syntax.
 * \param nodes The number of leaf nodes in the dendrogram.
 * \param steps Integer constant, the number of steps to take.
 * \param membership Pointer to an initialized vector, the membership
 *    results will be stored here, if not NULL. The vector will be
 *    resized as needed.
 * \param csize Pointer to an initialized vector, or NULL. If not NULL
 *    then the sizes of the components will be stored here, the vector
 *    will be resized as needed.
 *
 * \sa \ref igraph_community_walktrap(), \ref
 * igraph_community_edge_betweenness(), \ref
 * igraph_community_fastgreedy() for community structure detection
 * algorithms.
 *
 * Time complexity: O(|V|), the number of vertices in the graph.
 */
int igraph_community_to_membership(const igraph_matrix_t *merges,
                                   igraph_integer_t nodes,
                                   igraph_integer_t steps,
                                   igraph_vector_t *membership,
                                   igraph_vector_t *csize) {

    long int no_of_nodes = nodes;
    long int components = no_of_nodes - steps;
    long int i, found = 0;
    igraph_vector_t tmp;
    igraph_vector_bool_t already_merged;
    igraph_vector_t own_membership;
    igraph_bool_t using_own_membership = 0;

    if (steps > igraph_matrix_nrow(merges)) {
        IGRAPH_ERRORF("Number of steps is greater than number of rows in merges matrix: found %"
                      IGRAPH_PRId " steps, %ld rows.", IGRAPH_EINVAL, steps, igraph_matrix_nrow(merges));
    }

    if (igraph_matrix_ncol(merges) != 2) {
        IGRAPH_ERRORF("The merges matrix should have two columns, but has %ld.",
                      IGRAPH_EINVAL, igraph_matrix_ncol(merges));
    }
    if (steps < 0) {
        IGRAPH_ERRORF("Number of steps should be non-negative, found %" IGRAPH_PRId ".", IGRAPH_EINVAL, steps);
    }

    if (csize != 0 && membership == 0) {
        /* we need a membership vector to calculate 'csize' but the user did
         * not provide one; let's allocate one ourselves */
        IGRAPH_VECTOR_INIT_FINALLY(&own_membership, no_of_nodes);
        using_own_membership = 1;
        membership = &own_membership;
    }

    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
        igraph_vector_null(membership);
    }
    if (csize) {
        IGRAPH_CHECK(igraph_vector_resize(csize, components));
        igraph_vector_null(csize);
    }

    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&already_merged, steps + no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, steps);

    for (i = steps - 1; i >= 0; i--) {
        long int c1 = (long int) MATRIX(*merges, i, 0);
        long int c2 = (long int) MATRIX(*merges, i, 1);

        if (VECTOR(already_merged)[c1] == 0) {
            VECTOR(already_merged)[c1] = 1;
        } else {
            IGRAPH_ERRORF("Merges matrix contains multiple merges of cluster %ld.", IGRAPH_EINVAL, c1);
        }
        if (VECTOR(already_merged)[c2] == 0) {
            VECTOR(already_merged)[c2] = 1;
        } else {
            IGRAPH_ERRORF("Merges matrix contains multiple merges of cluster %ld.", IGRAPH_EINVAL, c2);
        }

        /* new component? */
        if (VECTOR(tmp)[i] == 0) {
            found++;
            VECTOR(tmp)[i] = found;
        }

        if (c1 < no_of_nodes) {
            long int cid = (long int) VECTOR(tmp)[i] - 1;
            if (membership) {
                VECTOR(*membership)[c1] = cid + 1;
            }
            if (csize) {
                VECTOR(*csize)[cid] += 1;
            }
        } else {
            VECTOR(tmp)[c1 - no_of_nodes] = VECTOR(tmp)[i];
        }

        if (c2 < no_of_nodes) {
            long int cid = (long int) VECTOR(tmp)[i] - 1;
            if (membership) {
                VECTOR(*membership)[c2] = cid + 1;
            }
            if (csize) {
                VECTOR(*csize)[cid] += 1;
            }
        } else {
            VECTOR(tmp)[c2 - no_of_nodes] = VECTOR(tmp)[i];
        }

    }

    if (membership || csize) {
        /* it can never happen that csize != 0 and membership == 0; we have
         * handled that case above */
        for (i = 0; i < no_of_nodes; i++) {
            long int tmp = (long int) VECTOR(*membership)[i];
            if (tmp != 0) {
                if (membership) {
                    VECTOR(*membership)[i] = tmp - 1;
                }
            } else {
                if (csize) {
                    VECTOR(*csize)[found] += 1;
                }
                if (membership) {
                    VECTOR(*membership)[i] = found;
                }
                found++;
            }
        }
    }

    igraph_vector_destroy(&tmp);
    igraph_vector_bool_destroy(&already_merged);
    IGRAPH_FINALLY_CLEAN(2);

    if (using_own_membership) {
        igraph_vector_destroy(&own_membership);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_reindex_membership
 * \brief Makes the IDs in a membership vector continuous
 *
 * This function reindexes component IDs in a membership vector
 * in a way that the new IDs start from zero and go up to C-1,
 * where C is the number of unique component IDs in the original
 * vector. The supplied membership is expected to fall in the
 * range 0, ..., n - 1.
 *
 * \param  membership  Numeric vector which gives the type of each
 *                     vertex, i.e. the component to which it belongs.
 *                     The vector will be altered in-place.
 * \param  new_to_old  Pointer to a vector which will contain the
 *                     old component ID for each new one, or NULL,
 *                     in which case it is not returned. The vector
 *                     will be resized as needed.
 * \param  nb_clusters Pointer to an integer for the number of
 *                     distinct clusters. If not NULL, this will be
 *                     updated to reflect the number of distinct
 *                     clusters found in membership.
 *
 * Time complexity: should be O(n) for n elements.
 */
int igraph_reindex_membership(igraph_vector_t *membership,
                              igraph_vector_t *new_to_old,
                              igraph_integer_t *nb_clusters) {

    long int i, n = igraph_vector_size(membership);
    igraph_vector_t new_cluster;
    igraph_integer_t i_nb_clusters;

    /* We allow original cluster indices in the range 0, ..., n - 1 */
    IGRAPH_CHECK(igraph_vector_init(&new_cluster, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &new_cluster);

    if (new_to_old) {
        igraph_vector_clear(new_to_old);
    }

    /* Clean clusters. We will store the new cluster + 1 so that membership == 0
     * indicates that no cluster was assigned yet. */
    i_nb_clusters = 1;
    for (i = 0; i < n; i++) {
        long int c = (long int)VECTOR(*membership)[i];

        if (c < 0) {
            IGRAPH_ERRORF("Membership indices should be non-negative. "
            "Found member of cluster %ld.", IGRAPH_EINVAL, c);
        }

        if (c >= n) {
            IGRAPH_ERRORF("Membership indices should be less than total number of vertices. "
            "Found member of cluster %ld, but only %ld vertices.", IGRAPH_EINVAL, c, n);
        }

        if (VECTOR(new_cluster)[c] == 0) {
            VECTOR(new_cluster)[c] = (igraph_real_t)i_nb_clusters;
            i_nb_clusters += 1;
            if (new_to_old) {
                IGRAPH_CHECK(igraph_vector_push_back(new_to_old, c));
            }
        }
    }

    /* Assign new membership */
    for (i = 0; i < n; i++) {
        long int c = (long int)VECTOR(*membership)[i];
        VECTOR(*membership)[i] = VECTOR(new_cluster)[c] - 1;
    }
    if (nb_clusters) {
        /* We used the cluster + 1, so correct */
        *nb_clusters = i_nb_clusters - 1;
    }

    igraph_vector_destroy(&new_cluster);

    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

static int igraph_i_compare_communities_vi(const igraph_vector_t *v1,
                                           const igraph_vector_t *v2, igraph_real_t* result);
static int igraph_i_compare_communities_nmi(const igraph_vector_t *v1,
                                            const igraph_vector_t *v2, igraph_real_t* result);
static int igraph_i_compare_communities_rand(const igraph_vector_t *v1,
                                             const igraph_vector_t *v2, igraph_real_t* result, igraph_bool_t adjust);
static int igraph_i_split_join_distance(const igraph_vector_t *v1,
                                        const igraph_vector_t *v2, igraph_integer_t* distance12,
                                        igraph_integer_t* distance21);

/**
 * \ingroup communities
 * \function igraph_compare_communities
 * \brief Compares community structures using various metrics
 *
 * This function assesses the distance between two community structures
 * using the variation of information (VI) metric of Meila (2003), the
 * normalized mutual information (NMI) of Danon et al (2005), the
 * split-join distance of van Dongen (2000), the Rand index of Rand (1971)
 * or the adjusted Rand index of Hubert and Arabie (1985).
 *
 * 
 * References:
 *
 * 
 * Meila M: Comparing clusterings by the variation of information.
 * In: Schölkopf B, Warmuth MK (eds.). Learning Theory and Kernel Machines:
 * 16th Annual Conference on Computational Learning Theory and 7th Kernel
 * Workshop, COLT/Kernel 2003, Washington, DC, USA. Lecture Notes in Computer
 * Science, vol. 2777, Springer, 2003. ISBN: 978-3-540-40720-1.
 *
 * 
 * Danon L, Diaz-Guilera A, Duch J, Arenas A: Comparing community structure
 * identification. J Stat Mech P09008, 2005.
 *
 * 
 * van Dongen S: Performance criteria for graph clustering and Markov cluster
 * experiments. Technical Report INS-R0012, National Research Institute for
 * Mathematics and Computer Science in the Netherlands, Amsterdam, May 2000.
 *
 * 
 * Rand WM: Objective criteria for the evaluation of clustering methods.
 * J Am Stat Assoc 66(336):846-850, 1971.
 *
 * 
 * Hubert L and Arabie P: Comparing partitions. Journal of Classification
 * 2:193-218, 1985.
 *
 * \param  comm1   the membership vector of the first community structure
 * \param  comm2   the membership vector of the second community structure
 * \param  result  the result is stored here.
 * \param  method  the comparison method to use. \c IGRAPH_COMMCMP_VI
 *                 selects the variation of information (VI) metric of
 *                 Meila (2003), \c IGRAPH_COMMCMP_NMI selects the
 *                 normalized mutual information measure proposed by
 *                 Danon et al (2005), \c IGRAPH_COMMCMP_SPLIT_JOIN
 *                 selects the split-join distance of van Dongen (2000),
 *                 \c IGRAPH_COMMCMP_RAND selects the unadjusted Rand
 *                 index (1971) and \c IGRAPH_COMMCMP_ADJUSTED_RAND
 *                 selects the adjusted Rand index.
 *
 * \return  Error code.
 *
 * Time complexity: O(n log(n)).
 */
int igraph_compare_communities(const igraph_vector_t *comm1,
                               const igraph_vector_t *comm2, igraph_real_t* result,
                               igraph_community_comparison_t method) {
    igraph_vector_t c1, c2;

    if (igraph_vector_size(comm1) != igraph_vector_size(comm2)) {
        IGRAPH_ERROR("community membership vectors have different lengths", IGRAPH_EINVAL);
    }

    /* Copy and reindex membership vectors to make sure they are continuous */
    IGRAPH_CHECK(igraph_vector_copy(&c1, comm1));
    IGRAPH_FINALLY(igraph_vector_destroy, &c1);

    IGRAPH_CHECK(igraph_vector_copy(&c2, comm2));
    IGRAPH_FINALLY(igraph_vector_destroy, &c2);

    IGRAPH_CHECK(igraph_reindex_membership(&c1, 0, NULL));
    IGRAPH_CHECK(igraph_reindex_membership(&c2, 0, NULL));

    switch (method) {
    case IGRAPH_COMMCMP_VI:
        IGRAPH_CHECK(igraph_i_compare_communities_vi(&c1, &c2, result));
        break;

    case IGRAPH_COMMCMP_NMI:
        IGRAPH_CHECK(igraph_i_compare_communities_nmi(&c1, &c2, result));
        break;

    case IGRAPH_COMMCMP_SPLIT_JOIN: {
        igraph_integer_t d12, d21;
        IGRAPH_CHECK(igraph_i_split_join_distance(&c1, &c2, &d12, &d21));
        *result = d12 + d21;
    }
    break;

    case IGRAPH_COMMCMP_RAND:
    case IGRAPH_COMMCMP_ADJUSTED_RAND:
        IGRAPH_CHECK(igraph_i_compare_communities_rand(&c1, &c2, result,
                     method == IGRAPH_COMMCMP_ADJUSTED_RAND));
        break;

    default:
        IGRAPH_ERROR("unknown community comparison method", IGRAPH_EINVAL);
    }

    /* Clean up everything */
    igraph_vector_destroy(&c1);
    igraph_vector_destroy(&c2);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \ingroup communities
 * \function igraph_split_join_distance
 * \brief Calculates the split-join distance of two community structures
 *
 * The split-join distance between partitions A and B is the sum of the
 * projection distance of A from B and the projection distance of B from
 * A. The projection distance is an asymmetric measure and it is defined
 * as follows:
 *
 * 
 * First, each set in partition A is evaluated against all sets in partition
 * B. For each set in partition A, the best matching set in partition B is
 * found and the overlap size is calculated. (Matching is quantified by the
 * size of the overlap between the two sets). Then, the maximal overlap sizes
 * for each set in A are summed together and subtracted from the number of
 * elements in A.
 *
 * 
 * The split-join distance will be returned in two arguments, \c distance12
 * will contain the projection distance of the first partition from the
 * second, while \c distance21 will be the projection distance of the second
 * partition from the first. This makes it easier to detect whether a
 * partition is a subpartition of the other, since in this case, the
 * corresponding distance will be zero.
 *
 * 
 * Reference:
 *
 * 
 * van Dongen S: Performance criteria for graph clustering and Markov cluster
 * experiments. Technical Report INS-R0012, National Research Institute for
 * Mathematics and Computer Science in the Netherlands, Amsterdam, May 2000.
 *
 * \param  comm1       the membership vector of the first community structure
 * \param  comm2       the membership vector of the second community structure
 * \param  distance12  pointer to an \c igraph_integer_t, the projection distance
 *                     of the first community structure from the second one will be
 *                     returned here.
 * \param  distance21  pointer to an \c igraph_integer_t, the projection distance
 *                     of the second community structure from the first one will be
 *                     returned here.
 * \return  Error code.
 *
 * \see \ref igraph_compare_communities() with the \c IGRAPH_COMMCMP_SPLIT_JOIN
 * method if you are not interested in the individual distances but only the sum
 * of them.
 *
 * Time complexity: O(n log(n)).
 */
int igraph_split_join_distance(const igraph_vector_t *comm1,
                               const igraph_vector_t *comm2, igraph_integer_t *distance12,
                               igraph_integer_t *distance21) {
    igraph_vector_t c1, c2;

    if (igraph_vector_size(comm1) != igraph_vector_size(comm2)) {
        IGRAPH_ERRORF("Community membership vectors have different lengths: %ld and %ld.",
                      IGRAPH_EINVAL, igraph_vector_size(comm1), igraph_vector_size(comm2));
    }

    /* Copy and reindex membership vectors to make sure they are continuous */
    IGRAPH_CHECK(igraph_vector_copy(&c1, comm1));
    IGRAPH_FINALLY(igraph_vector_destroy, &c1);

    IGRAPH_CHECK(igraph_vector_copy(&c2, comm2));
    IGRAPH_FINALLY(igraph_vector_destroy, &c2);

    IGRAPH_CHECK(igraph_reindex_membership(&c1, 0, NULL));
    IGRAPH_CHECK(igraph_reindex_membership(&c2, 0, NULL));

    IGRAPH_CHECK(igraph_i_split_join_distance(&c1, &c2, distance12, distance21));

    /* Clean up everything */
    igraph_vector_destroy(&c1);
    igraph_vector_destroy(&c2);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * Calculates the entropy and the mutual information for two reindexed community
 * membership vectors v1 and v2. This is needed by both Meila's and Danon's
 * community comparison measure.
 */
static int igraph_i_entropy_and_mutual_information(const igraph_vector_t* v1,
        const igraph_vector_t* v2, double* h1, double* h2, double* mut_inf) {
    long int i, n;
    long int k1;
    long int k2;
    double *p1, *p2;
    igraph_spmatrix_t m;
    igraph_spmatrix_iter_t mit;

    n = igraph_vector_size(v1);
    if (n == 0) {
        *h1 = 0;
        *h2 = 0;
        *mut_inf = 0;
        return IGRAPH_SUCCESS;
    }
    k1 = (long int)igraph_vector_max(v1) + 1;
    k2 = (long int)igraph_vector_max(v2) + 1;
    p1 = IGRAPH_CALLOC(k1, double);
    if (p1 == 0) {
        IGRAPH_ERROR("igraph_i_entropy_and_mutual_information failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, p1);
    p2 = IGRAPH_CALLOC(k2, double);
    if (p2 == 0) {
        IGRAPH_ERROR("igraph_i_entropy_and_mutual_information failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, p2);

    /* Calculate the entropy of v1 */
    *h1 = 0.0;
    for (i = 0; i < n; i++) {
        p1[(long int)VECTOR(*v1)[i]]++;
    }
    for (i = 0; i < k1; i++) {
        p1[i] /= n;
        *h1 -= p1[i] * log(p1[i]);
    }

    /* Calculate the entropy of v2 */
    *h2 = 0.0;
    for (i = 0; i < n; i++) {
        p2[(long int)VECTOR(*v2)[i]]++;
    }
    for (i = 0; i < k2; i++) {
        p2[i] /= n;
        *h2 -= p2[i] * log(p2[i]);
    }

    /* We will only need the logs of p1 and p2 from now on */
    for (i = 0; i < k1; i++) {
        p1[i] = log(p1[i]);
    }
    for (i = 0; i < k2; i++) {
        p2[i] = log(p2[i]);
    }

    /* Calculate the mutual information of v1 and v2 */
    *mut_inf = 0.0;
    IGRAPH_CHECK(igraph_spmatrix_init(&m, k1, k2));
    IGRAPH_FINALLY(igraph_spmatrix_destroy, &m);
    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_spmatrix_add_e(&m,
                                           (int)VECTOR(*v1)[i], (int)VECTOR(*v2)[i], 1));
    }
    IGRAPH_CHECK(igraph_spmatrix_iter_create(&mit, &m));
    IGRAPH_FINALLY(igraph_spmatrix_iter_destroy, &mit);
    while (!igraph_spmatrix_iter_end(&mit)) {
        double p = mit.value / n;
        *mut_inf += p * (log(p) - p1[mit.ri] - p2[mit.ci]);
        igraph_spmatrix_iter_next(&mit);
    }

    igraph_spmatrix_iter_destroy(&mit);
    igraph_spmatrix_destroy(&m);
    IGRAPH_FREE(p1); IGRAPH_FREE(p2);

    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/**
 * Implementation of the normalized mutual information (NMI) measure of
 * Danon et al. This function assumes that the community membership
 * vectors have already been normalized using igraph_reindex_communities().
 *
 * 
 * Reference: Danon L, Diaz-Guilera A, Duch J, Arenas A: Comparing community
 * structure identification. J Stat Mech P09008, 2005.
 *
 * 
 * Time complexity: O(n log(n))
 */
static int igraph_i_compare_communities_nmi(const igraph_vector_t *v1, const igraph_vector_t *v2,
                                     igraph_real_t* result) {
    double h1, h2, mut_inf;

    IGRAPH_CHECK(igraph_i_entropy_and_mutual_information(v1, v2, &h1, &h2, &mut_inf));

    if (h1 == 0 && h2 == 0) {
        *result = 1;
    } else {
        *result = 2 * mut_inf / (h1 + h2);
    }

    return IGRAPH_SUCCESS;
}

/**
 * Implementation of the variation of information metric (VI) of
 * Meila et al. This function assumes that the community membership
 * vectors have already been normalized using igraph_reindex_communities().
 *
 * 
 * Reference: Meila M: Comparing clusterings by the variation of information.
 * In: Schölkopf B, Warmuth MK (eds.). Learning Theory and Kernel Machines:
 * 16th Annual Conference on Computational Learning Theory and 7th Kernel
 * Workshop, COLT/Kernel 2003, Washington, DC, USA. Lecture Notes in Computer
 * Science, vol. 2777, Springer, 2003. ISBN: 978-3-540-40720-1.
 *
 * 
 * Time complexity: O(n log(n))
 */
static int igraph_i_compare_communities_vi(const igraph_vector_t *v1, const igraph_vector_t *v2,
                                    igraph_real_t* result) {
    double h1, h2, mut_inf;

    IGRAPH_CHECK(igraph_i_entropy_and_mutual_information(v1, v2, &h1, &h2, &mut_inf));
    *result = h1 + h2 - 2 * mut_inf;

    return IGRAPH_SUCCESS;
}

/**
 * \brief Calculates the confusion matrix for two clusterings.
 *
 * 
 * This function assumes that the community membership vectors have already
 * been normalized using igraph_reindex_communities().
 *
 * 
 * Time complexity: O(n log(max(k1, k2))), where n is the number of vertices, k1
 * and k2 are the number of clusters in each of the clusterings.
 */
static int igraph_i_confusion_matrix(const igraph_vector_t *v1, const igraph_vector_t *v2,
                              igraph_spmatrix_t *m) {
    long int k1;
    long int k2;
    long int i, n;

    n = igraph_vector_size(v1);
    if (n == 0 ) {
        IGRAPH_CHECK(igraph_spmatrix_resize(m, 0, 0));
        return IGRAPH_SUCCESS;
    }
    k1 = (long int)igraph_vector_max(v1) + 1;
    k2 = (long int)igraph_vector_max(v2) + 1;
    IGRAPH_CHECK(igraph_spmatrix_resize(m, k1, k2));
    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_spmatrix_add_e(m,
                                           (int)VECTOR(*v1)[i], (int)VECTOR(*v2)[i], 1));
    }

    return IGRAPH_SUCCESS;
}

/**
 * Implementation of the split-join distance of van Dongen.
 *
 * 
 * This function assumes that the community membership vectors have already
 * been normalized using igraph_reindex_communities().
 *
 * 
 * Reference: van Dongen S: Performance criteria for graph clustering and Markov
 * cluster experiments. Technical Report INS-R0012, National Research Institute
 * for Mathematics and Computer Science in the Netherlands, Amsterdam, May 2000.
 *
 * 
 * Time complexity: O(n log(max(k1, k2))), where n is the number of vertices, k1
 * and k2 are the number of clusters in each of the clusterings.
 */
static int igraph_i_split_join_distance(const igraph_vector_t *v1, const igraph_vector_t *v2,
                                 igraph_integer_t* distance12, igraph_integer_t* distance21) {
    long int n = igraph_vector_size(v1);
    igraph_vector_t rowmax, colmax;
    igraph_spmatrix_t m;
    igraph_spmatrix_iter_t mit;

    if (n == 0) {
        *distance12 = 0;
        *distance21 = 0;
        return IGRAPH_SUCCESS;
    }
    /* Calculate the confusion matrix */
    IGRAPH_CHECK(igraph_spmatrix_init(&m, 1, 1));
    IGRAPH_FINALLY(igraph_spmatrix_destroy, &m);
    IGRAPH_CHECK(igraph_i_confusion_matrix(v1, v2, &m));

    /* Initialize vectors that will store the row/columnwise maxima */
    IGRAPH_VECTOR_INIT_FINALLY(&rowmax, igraph_spmatrix_nrow(&m));
    IGRAPH_VECTOR_INIT_FINALLY(&colmax, igraph_spmatrix_ncol(&m));

    /* Find the row/columnwise maxima */
    IGRAPH_CHECK(igraph_spmatrix_iter_create(&mit, &m));
    IGRAPH_FINALLY(igraph_spmatrix_iter_destroy, &mit);
    while (!igraph_spmatrix_iter_end(&mit)) {
        if (mit.value > VECTOR(rowmax)[mit.ri]) {
            VECTOR(rowmax)[mit.ri] = mit.value;
        }
        if (mit.value > VECTOR(colmax)[mit.ci]) {
            VECTOR(colmax)[mit.ci] = mit.value;
        }
        igraph_spmatrix_iter_next(&mit);
    }
    igraph_spmatrix_iter_destroy(&mit);
    IGRAPH_FINALLY_CLEAN(1);

    /* Calculate the distances */
    *distance12 = (igraph_integer_t) (n - igraph_vector_sum(&rowmax));
    *distance21 = (igraph_integer_t) (n - igraph_vector_sum(&colmax));

    igraph_vector_destroy(&rowmax);
    igraph_vector_destroy(&colmax);
    igraph_spmatrix_destroy(&m);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/**
 * Implementation of the adjusted and unadjusted Rand indices.
 *
 * 
 * This function assumes that the community membership vectors have already
 * been normalized using igraph_reindex_communities().
 *
 * 
 * References:
 *
 * 
 * Rand WM: Objective criteria for the evaluation of clustering methods. J Am
 * Stat Assoc 66(336):846-850, 1971.
 *
 * 
 * Hubert L and Arabie P: Comparing partitions. Journal of Classification
 * 2:193-218, 1985.
 *
 * 
 * Time complexity: O(n log(max(k1, k2))), where n is the number of vertices, k1
 * and k2 are the number of clusters in each of the clusterings.
 */
static int igraph_i_compare_communities_rand(
        const igraph_vector_t *v1, const igraph_vector_t *v2,
        igraph_real_t *result, igraph_bool_t adjust) {
    igraph_spmatrix_t m;
    igraph_spmatrix_iter_t mit;
    igraph_vector_t rowsums, colsums;
    long int i, nrow, ncol;
    double rand, n;
    double frac_pairs_in_1, frac_pairs_in_2;

    if (igraph_vector_size(v1) <= 1) {
        IGRAPH_ERRORF("Rand indices not defined for only zero or one vertices. "
        "Found membership vector of size %ld", IGRAPH_EINVAL, igraph_vector_size(v1));
    }

    /* Calculate the confusion matrix */
    IGRAPH_CHECK(igraph_spmatrix_init(&m, 1, 1));
    IGRAPH_FINALLY(igraph_spmatrix_destroy, &m);
    IGRAPH_CHECK(igraph_i_confusion_matrix(v1, v2, &m));

    /* The unadjusted Rand index is defined as (a+d) / (a+b+c+d), where:
     *
     * - a is the number of pairs in the same cluster both in v1 and v2. This
     *   equals the sum of n(i,j) choose 2 for all i and j.
     *
     * - b is the number of pairs in the same cluster in v1 and in different
     *   clusters in v2. This is sum n(i,*) choose 2 for all i minus a.
     *   n(i,*) is the number of elements in cluster i in v1.
     *
     * - c is the number of pairs in the same cluster in v2 and in different
     *   clusters in v1. This is sum n(*,j) choose 2 for all j minus a.
     *   n(*,j) is the number of elements in cluster j in v2.
     *
     * - d is (n choose 2) - a - b - c.
     *
     * Therefore, a+d = (n choose 2) - b - c
     *                = (n choose 2) - sum (n(i,*) choose 2)
     *                               - sum (n(*,j) choose 2)
     *                               + 2 * sum (n(i,j) choose 2).
     *
     * Since a+b+c+d = (n choose 2) and this goes in the denominator, we can
     * just as well start dividing each term in a+d by (n choose 2), which
     * yields:
     *
     * 1 - sum( n(i,*)/n * (n(i,*)-1)/(n-1) )
     *   - sum( n(*,i)/n * (n(*,i)-1)/(n-1) )
     *   + sum( n(i,j)/n * (n(i,j)-1)/(n-1) ) * 2
     */

    /* Calculate row and column sums */
    nrow = igraph_spmatrix_nrow(&m);
    ncol = igraph_spmatrix_ncol(&m);
    n = igraph_vector_size(v1) + 0.0;
    IGRAPH_VECTOR_INIT_FINALLY(&rowsums, nrow);
    IGRAPH_VECTOR_INIT_FINALLY(&colsums, ncol);
    IGRAPH_CHECK(igraph_spmatrix_rowsums(&m, &rowsums));
    IGRAPH_CHECK(igraph_spmatrix_colsums(&m, &colsums));

    /* Start calculating the unadjusted Rand index */
    rand = 0.0;
    IGRAPH_CHECK(igraph_spmatrix_iter_create(&mit, &m));
    IGRAPH_FINALLY(igraph_spmatrix_iter_destroy, &mit);
    while (!igraph_spmatrix_iter_end(&mit)) {
        rand += (mit.value / n) * (mit.value - 1) / (n - 1);
        igraph_spmatrix_iter_next(&mit);
    }
    igraph_spmatrix_iter_destroy(&mit);
    IGRAPH_FINALLY_CLEAN(1);

    frac_pairs_in_1 = frac_pairs_in_2 = 0.0;
    for (i = 0; i < nrow; i++) {
        frac_pairs_in_1 += (VECTOR(rowsums)[i] / n) * (VECTOR(rowsums)[i] - 1) / (n - 1);
    }
    for (i = 0; i < ncol; i++) {
        frac_pairs_in_2 += (VECTOR(colsums)[i] / n) * (VECTOR(colsums)[i] - 1) / (n - 1);
    }

    rand = 1.0 + 2 * rand - frac_pairs_in_1 - frac_pairs_in_2;

    if (adjust) {
        double expected = frac_pairs_in_1 * frac_pairs_in_2 +
                          (1 - frac_pairs_in_1) * (1 - frac_pairs_in_2);
        rand = (rand - expected) / (1 - expected);
    }

    igraph_vector_destroy(&rowsums);
    igraph_vector_destroy(&colsums);
    igraph_spmatrix_destroy(&m);
    IGRAPH_FINALLY_CLEAN(3);

    *result = rand;

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/edge_betweenness.c0000644000175100001710000007272600000000000026155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_progress.h"
#include "igraph_stack.h"

#include "core/indheap.h"
#include "core/interruption.h"

#include 

static int igraph_i_rewrite_membership_vector(igraph_vector_t *membership) {
    long int no = (long int) igraph_vector_max(membership) + 1;
    igraph_vector_t idx;
    long int realno = 0;
    long int i;
    long int len = igraph_vector_size(membership);

    IGRAPH_VECTOR_INIT_FINALLY(&idx, no);
    for (i = 0; i < len; i++) {
        long int t = (long int) VECTOR(*membership)[i];
        if (VECTOR(idx)[t]) {
            VECTOR(*membership)[i] = VECTOR(idx)[t] - 1;
        } else {
            VECTOR(idx)[t] = ++realno;
            VECTOR(*membership)[i] = VECTOR(idx)[t] - 1;
        }
    }
    igraph_vector_destroy(&idx);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_community_eb_get_merges2(const igraph_t *graph,
                                             const igraph_bool_t directed,
                                             const igraph_vector_t *edges,
                                             const igraph_vector_t *weights,
                                             igraph_matrix_t *res,
                                             igraph_vector_t *bridges,
                                             igraph_vector_t *modularity,
                                             igraph_vector_t *membership) {

    igraph_vector_t mymembership;
    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    igraph_real_t maxmod = -1;
    long int midx = 0;
    igraph_integer_t no_comps;
    igraph_bool_t use_directed = directed && igraph_is_directed(graph);

    IGRAPH_VECTOR_INIT_FINALLY(&mymembership, no_of_nodes);

    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
    }

    if (modularity || res || bridges) {
        IGRAPH_CHECK(igraph_clusters(graph, 0, 0, &no_comps,
                                     IGRAPH_WEAK));

        if (modularity) {
            IGRAPH_CHECK(igraph_vector_resize(modularity,
                                              no_of_nodes - no_comps + 1));
        }
        if (res) {
            IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes - no_comps,
                                              2));
        }
        if (bridges) {
            IGRAPH_CHECK(igraph_vector_resize(bridges,
                                              no_of_nodes - no_comps));
        }
    }

    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(mymembership)[i] = i;
    }
    if (membership) {
        igraph_vector_update(membership, &mymembership);
    }

    IGRAPH_CHECK(igraph_modularity(graph, &mymembership, weights,
                                   /* resolution */ 1,
                                   use_directed, &maxmod));
    if (modularity) {
        VECTOR(*modularity)[0] = maxmod;
    }

    for (i = igraph_vector_size(edges) - 1; i >= 0; i--) {
        long int edge = (long int) VECTOR(*edges)[i];
        long int from = IGRAPH_FROM(graph, (igraph_integer_t) edge);
        long int to = IGRAPH_TO(graph, (igraph_integer_t) edge);
        long int c1 = (long int) VECTOR(mymembership)[from];
        long int c2 = (long int) VECTOR(mymembership)[to];
        igraph_real_t actmod;
        long int j;
        if (c1 != c2) {     /* this is a merge */
            if (res) {
                MATRIX(*res, midx, 0) = c1;
                MATRIX(*res, midx, 1) = c2;
            }
            if (bridges) {
                VECTOR(*bridges)[midx] = i + 1;
            }

            /* The new cluster has id no_of_nodes+midx+1 */
            for (j = 0; j < no_of_nodes; j++) {
                if (VECTOR(mymembership)[j] == c1 ||
                    VECTOR(mymembership)[j] == c2) {
                    VECTOR(mymembership)[j] = no_of_nodes + midx;
                }
            }

            IGRAPH_CHECK(igraph_modularity(graph, &mymembership, weights,
                                           /* resolution */ 1,
                                           use_directed, &actmod));
            if (modularity) {
                VECTOR(*modularity)[midx + 1] = actmod;
                if (actmod > maxmod) {
                    maxmod = actmod;
                    if (membership) {
                        igraph_vector_update(membership, &mymembership);
                    }
                }
            }

            midx++;
        }
    }

    if (membership) {
        IGRAPH_CHECK(igraph_i_rewrite_membership_vector(membership));
    }

    igraph_vector_destroy(&mymembership);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}


/**
 * \function igraph_community_eb_get_merges
 * \brief Calculating the merges, i.e. the dendrogram for an edge betweenness community structure.
 *
 * 
 * This function is handy if you have a sequence of edges which are
 * gradually removed from the network and you would like to know how
 * the network falls apart into separate components. The edge sequence
 * may come from the \ref igraph_community_edge_betweenness()
 * function, but this is not necessary. Note that \ref
 * igraph_community_edge_betweenness() can also calculate the
 * dendrogram, via its \p merges argument.
 *
 * \param graph The input graph.
 * \param edges Vector containing the edges to be removed from the
 *    network, all edges are expected to appear exactly once in the
 *    vector.
 * \param directed Whether to use the directed or undirected version
 *    of modularity. Will be ignored for undirected graphs.
 * \param weights An optional vector containing edge weights. If null,
 *     the unweighted modularity scores will be calculated. If not null,
 *     the weighted modularity scores will be calculated. Ignored if both
 *     \p modularity and \p membership are \c NULL pointers.
 * \param res Pointer to an initialized matrix, if not \c NULL then the
 *    dendrogram will be stored here, in the same form as for the \ref
 *    igraph_community_walktrap() function: the matrix has two columns
 *    and each line is a merge given by the ids of the merged
 *    components. The component ids are numbered from zero and
 *    component ids smaller than the number of vertices in the graph
 *    belong to individual vertices. The non-trivial components
 *    containing at least two vertices are numbered from \c n, where \c n is
 *    the number of vertices in the graph. So if the first line
 *    contains \c a and \c b that means that components \c a and \c b
 *    are merged into component \c n, the second line creates
 *    component \c n+1, etc. The matrix will be resized as needed.
 * \param bridges Pointer to an initialized vector or \c NULL. If not
 *    null then the index of the edge removals which split the network
 *    will be stored here. The vector will be resized as needed.
 * \param modularity If not a null pointer, then the modularity values
 *    for the different divisions, corresponding to the merges matrix,
 *    will be stored here.
 * \param membership If not a null pointer, then the membership vector
 *    for the best division (in terms of modularity) will be stored
 *    here.
 * \return Error code.
 *
 * \sa \ref igraph_community_edge_betweenness().
 *
 * Time complexity: O(|E|+|V|log|V|), |V| is the number of vertices,
 * |E| is the number of edges.
 */
int igraph_community_eb_get_merges(const igraph_t *graph,
                                   const igraph_bool_t directed,
                                   const igraph_vector_t *edges,
                                   const igraph_vector_t *weights,
                                   igraph_matrix_t *res,
                                   igraph_vector_t *bridges,
                                   igraph_vector_t *modularity,
                                   igraph_vector_t *membership) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t ptr;
    long int i, midx = 0;
    igraph_integer_t no_comps;

    /* catch null graph early */
    if (no_of_nodes == 0) {
        if (res) {
            igraph_matrix_resize(res, 0, 2);
        }
        if (bridges) {
            igraph_vector_clear(bridges);
        }
        if (modularity) {
            igraph_vector_clear(modularity);
        }
        if (membership) {
            igraph_vector_clear(membership);
        }
        return IGRAPH_SUCCESS;
    }

    if (membership || modularity) {
        return igraph_i_community_eb_get_merges2(graph,
                directed && igraph_is_directed(graph),
                edges, weights,
                res, bridges, modularity, membership);
    }

    IGRAPH_CHECK(igraph_clusters(graph, 0, 0, &no_comps, IGRAPH_WEAK));

    IGRAPH_VECTOR_INIT_FINALLY(&ptr, no_of_nodes * 2 - 1);
    if (res) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes - no_comps, 2));
    }
    if (bridges) {
        IGRAPH_CHECK(igraph_vector_resize(bridges, no_of_nodes - no_comps));
    }

    for (i = igraph_vector_size(edges) - 1; i >= 0; i--) {
        igraph_integer_t edge = (igraph_integer_t) VECTOR(*edges)[i];
        igraph_integer_t from, to, c1, c2, idx;
        igraph_edge(graph, edge, &from, &to);
        idx = from + 1;
        while (VECTOR(ptr)[idx - 1] != 0) {
            idx = (igraph_integer_t) VECTOR(ptr)[idx - 1];
        }
        c1 = idx - 1;
        idx = to + 1;
        while (VECTOR(ptr)[idx - 1] != 0) {
            idx = (igraph_integer_t) VECTOR(ptr)[idx - 1];
        }
        c2 = idx - 1;
        if (c1 != c2) {     /* this is a merge */
            if (res) {
                MATRIX(*res, midx, 0) = c1;
                MATRIX(*res, midx, 1) = c2;
            }
            if (bridges) {
                VECTOR(*bridges)[midx] = i + 1;
            }

            VECTOR(ptr)[c1] = no_of_nodes + midx + 1;
            VECTOR(ptr)[c2] = no_of_nodes + midx + 1;
            VECTOR(ptr)[from] = no_of_nodes + midx + 1;
            VECTOR(ptr)[to] = no_of_nodes + midx + 1;

            midx++;
        }
    }

    igraph_vector_destroy(&ptr);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* Find the smallest active element in the vector */
static long int igraph_i_vector_which_max_not_null(const igraph_vector_t *v,
                                                   const char *passive) {
    long int which, i = 0, size = igraph_vector_size(v);
    igraph_real_t max;
    while (passive[i]) {
        i++;
    }
    which = i;
    max = VECTOR(*v)[which];
    for (i++; i < size; i++) {
        igraph_real_t elem = VECTOR(*v)[i];
        if (!passive[i] && elem > max) {
            max = elem;
            which = i;
        }
    }

    return which;
}

/**
 * \function igraph_community_edge_betweenness
 * \brief Community finding based on edge betweenness.
 *
 * Community structure detection based on the betweenness of the edges
 * in the network. The algorithm was invented by M. Girvan and
 * M. Newman, see: M. Girvan and M. E. J. Newman: Community structure in
 * social and biological networks, Proc. Nat. Acad. Sci. USA 99, 7821-7826
 * (2002).
 *
 * 
 * The idea is that the betweenness of the edges connecting two
 * communities is typically high, as many of the shortest paths
 * between nodes in separate communities go through them. So we
 * gradually remove the edge with highest betweenness from the
 * network, and recalculate edge betweenness after every removal.
 * This way sooner or later the network falls off to two components,
 * then after a while one of these components falls off to two smaller
 * components, etc. until all edges are removed. This is a divisive
 * hierarchical approach, the result is a dendrogram.
 * \param graph The input graph.
 * \param result Pointer to an initialized vector, the result will be
 *     stored here, the ids of the removed edges in the order of their
 *     removal. It will be resized as needed. It may be \c NULL if
 *     the edge IDs are not needed by the caller.
 * \param edge_betweenness Pointer to an initialized vector or
 *     \c NULL. In the former case the edge betweenness of the removed
 *     edge is stored here. The vector will be resized as needed.
 * \param merges Pointer to an initialized matrix or \c NULL. If not \c NULL
 *     then merges performed by the algorithm are stored here. Even if
 *     this is a divisive algorithm, we can replay it backwards and
 *     note which two clusters were merged. Clusters are numbered from
 *     zero, see the \p merges argument of \ref
 *     igraph_community_walktrap() for details. The matrix will be
 *     resized as needed.
 * \param bridges Pointer to an initialized vector of \c NULL. If not
 *     NULL then all edge removals which separated the network into
 *     more components are marked here.
 * \param modularity If not a null pointer, then the modularity values
 *     of the different divisions are stored here, in the order
 *     corresponding to the merge matrix. The modularity values will
 *     take weights into account if \p weights is not null.
 * \param membership If not a null pointer, then the membership vector,
 *     corresponding to the highest modularity value, is stored here.
 * \param directed Logical constant, whether to calculate directed
 *    betweenness (i.e. directed paths) for directed graphs. It is
 *    ignored for undirected graphs.
 * \param weights An optional vector containing edge weights. If null,
 *     the unweighted edge betweenness scores will be calculated and
 *     used. If not null, the weighted edge betweenness scores will be
 *     calculated and used.
 * \return Error code.
 *
 * \sa \ref igraph_community_eb_get_merges(), \ref
 * igraph_community_spinglass(), \ref igraph_community_walktrap().
 *
 * Time complexity: O(|V||E|^2), as the betweenness calculation requires
 * O(|V||E|) and we do it |E|-1 times.
 *
 * \example examples/simple/igraph_community_edge_betweenness.c
 */
int igraph_community_edge_betweenness(const igraph_t *graph,
                                      igraph_vector_t *result,
                                      igraph_vector_t *edge_betweenness,
                                      igraph_matrix_t *merges,
                                      igraph_vector_t *bridges,
                                      igraph_vector_t *modularity,
                                      igraph_vector_t *membership,
                                      igraph_bool_t directed,
                                      const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    double *distance, *tmpscore;
    double *nrgeo;
    long int source, i, e;

    igraph_inclist_t elist_out, elist_in, fathers;
    igraph_inclist_t *elist_out_p, *elist_in_p;
    igraph_vector_int_t *neip;
    long int neino;
    igraph_vector_t eb;
    long int maxedge, pos;
    igraph_integer_t from, to;
    igraph_bool_t result_owned = 0;
    igraph_stack_t stack = IGRAPH_STACK_NULL;
    igraph_real_t steps, steps_done;

    char *passive;

    /* Needed only for the unweighted case */
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    /* Needed only for the weighted case */
    igraph_2wheap_t heap;

    if (result == 0) {
        result = IGRAPH_CALLOC(1, igraph_vector_t);
        if (result == 0) {
            IGRAPH_ERROR("Edge betweenness community structure failed.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, result);
        IGRAPH_VECTOR_INIT_FINALLY(result, 0);
        result_owned = 1;
    }

    directed = directed && igraph_is_directed(graph);
    if (directed) {
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_out, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_out);
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_in, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_in);
        elist_out_p = &elist_out;
        elist_in_p = &elist_in;
    } else {
        IGRAPH_CHECK(igraph_inclist_init(graph, &elist_out, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &elist_out);
        elist_out_p = elist_in_p = &elist_out;
    }

    distance = IGRAPH_CALLOC(no_of_nodes, double);
    if (distance == 0) {
        IGRAPH_ERROR("Edge betweenness community structure failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, distance);
    nrgeo = IGRAPH_CALLOC(no_of_nodes, double);
    if (nrgeo == 0) {
        IGRAPH_ERROR("Edge betweenness community structure failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, nrgeo);
    tmpscore = IGRAPH_CALLOC(no_of_nodes, double);
    if (tmpscore == 0) {
        IGRAPH_ERROR("Edge betweenness community structure failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmpscore);

    if (weights == 0) {
        IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    } else {
        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Weight vector length must agree with number of edges.", IGRAPH_EINVAL);
        }

        if (no_of_edges > 0) {
            /* Must not call vector_min on empty vector */
            igraph_real_t minweight = igraph_vector_min(weights);
            if (minweight <= 0) {
                IGRAPH_ERROR("Weights must be strictly positive.", IGRAPH_EINVAL);
            }

            if (igraph_is_nan(minweight)) {
                IGRAPH_ERROR("Weights must not be NaN.", IGRAPH_EINVAL);
            }
        }

        if (membership != 0) {
            IGRAPH_WARNING("Membership vector will be selected based on the lowest "
                           "modularity score.");
        }

        if (modularity != 0 || membership != 0) {
            IGRAPH_WARNING("Modularity calculation with weighted edge betweenness "
                           "community detection might not make sense -- modularity treats edge "
                           "weights as similarities while edge betwenness treats them as "
                           "distances.");
        }

        IGRAPH_CHECK(igraph_2wheap_init(&heap, no_of_nodes));
        IGRAPH_FINALLY(igraph_2wheap_destroy, &heap);
        IGRAPH_CHECK(igraph_inclist_init_empty(&fathers,
                                               (igraph_integer_t) no_of_nodes));
        IGRAPH_FINALLY(igraph_inclist_destroy, &fathers);
    }

    IGRAPH_CHECK(igraph_stack_init(&stack, no_of_nodes));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);

    IGRAPH_CHECK(igraph_vector_resize(result, no_of_edges));
    if (edge_betweenness) {
        IGRAPH_CHECK(igraph_vector_resize(edge_betweenness, no_of_edges));
        if (no_of_edges > 0) {
            VECTOR(*edge_betweenness)[no_of_edges - 1] = 0;
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&eb, no_of_edges);

    passive = IGRAPH_CALLOC(no_of_edges, char);
    if (!passive) {
        IGRAPH_ERROR("Edge betweenness community structure failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, passive);

    /* Estimate the number of steps to be taken.
     * It is assumed that one iteration is O(|E||V|), but |V| is constant
     * anyway, so we will have approximately |E|^2 / 2 steps, and one
     * iteration of the outer loop advances the step counter by the number
     * of remaining edges at that iteration.
     */
    steps = no_of_edges / 2.0 * (no_of_edges + 1);
    steps_done = 0;

    for (e = 0; e < no_of_edges; steps_done += no_of_edges - e, e++) {
        IGRAPH_PROGRESS("Edge betweenness community detection: ",
                        100.0 * steps_done / steps, NULL);

        igraph_vector_null(&eb);

        if (weights == 0) {
            /* Unweighted variant follows */

            /* The following for loop is copied almost intact from
             * igraph_edge_betweenness_cutoff */
            for (source = 0; source < no_of_nodes; source++) {

                IGRAPH_ALLOW_INTERRUPTION();

                memset(distance, 0, (size_t) no_of_nodes * sizeof(double));
                memset(nrgeo, 0, (size_t) no_of_nodes * sizeof(double));
                memset(tmpscore, 0, (size_t) no_of_nodes * sizeof(double));
                igraph_stack_clear(&stack); /* it should be empty anyway... */

                IGRAPH_CHECK(igraph_dqueue_push(&q, source));

                nrgeo[source] = 1;
                distance[source] = 0;

                while (!igraph_dqueue_empty(&q)) {
                    long int actnode = (long int) igraph_dqueue_pop(&q);

                    neip = igraph_inclist_get(elist_out_p, actnode);
                    neino = igraph_vector_int_size(neip);
                    for (i = 0; i < neino; i++) {
                        igraph_integer_t edge = (igraph_integer_t) VECTOR(*neip)[i];
                        long int neighbor= (long int) IGRAPH_OTHER(graph, edge, actnode);
                        if (nrgeo[neighbor] != 0) {
                            /* we've already seen this node, another shortest path? */
                            if (distance[neighbor] == distance[actnode] + 1) {
                                nrgeo[neighbor] += nrgeo[actnode];
                            }
                        } else {
                            /* we haven't seen this node yet */
                            nrgeo[neighbor] += nrgeo[actnode];
                            distance[neighbor] = distance[actnode] + 1;
                            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                            IGRAPH_CHECK(igraph_stack_push(&stack, neighbor));
                        }
                    }
                } /* while !igraph_dqueue_empty */

                /* Ok, we've the distance of each node and also the number of
                   shortest paths to them. Now we do an inverse search, starting
                   with the farthest nodes. */
                while (!igraph_stack_empty(&stack)) {
                    long int actnode = (long int) igraph_stack_pop(&stack);
                    if (distance[actnode] < 1) {
                        continue;    /* skip source node */
                    }

                    /* set the temporary score of the friends */
                    neip = igraph_inclist_get(elist_in_p, actnode);
                    neino = igraph_vector_int_size(neip);
                    for (i = 0; i < neino; i++) {
                        long int edge = (long int) VECTOR(*neip)[i];
                        long int neighbor = IGRAPH_OTHER(graph, edge, actnode);
                        if (distance[neighbor] == distance[actnode] - 1 &&
                            nrgeo[neighbor] != 0) {
                            tmpscore[neighbor] +=
                                (tmpscore[actnode] + 1) * nrgeo[neighbor] / nrgeo[actnode];
                            VECTOR(eb)[edge] +=
                                (tmpscore[actnode] + 1) * nrgeo[neighbor] / nrgeo[actnode];
                        }
                    }
                }
                /* Ok, we've the scores for this source */
            } /* for source <= no_of_nodes */
        } else {
            /* Weighted variant follows */

            /* The following for loop is copied almost intact from
             * igraph_i_edge_betweenness_cutoff_weighted */
            for (source = 0; source < no_of_nodes; source++) {
                /* This will contain the edge betweenness in the current step */
                IGRAPH_ALLOW_INTERRUPTION();

                memset(distance, 0, (size_t) no_of_nodes * sizeof(double));
                memset(nrgeo, 0, (size_t) no_of_nodes * sizeof(double));
                memset(tmpscore, 0, (size_t) no_of_nodes * sizeof(double));

                igraph_2wheap_push_with_index(&heap, source, 0);
                distance[source] = 1.0;
                nrgeo[source] = 1;

                while (!igraph_2wheap_empty(&heap)) {
                    long int minnei = igraph_2wheap_max_index(&heap);
                    igraph_real_t mindist = -igraph_2wheap_delete_max(&heap);

                    igraph_stack_push(&stack, minnei);

                    neip = igraph_inclist_get(elist_out_p, minnei);
                    neino = igraph_vector_int_size(neip);

                    for (i = 0; i < neino; i++) {
                        long int edge = VECTOR(*neip)[i];
                        long int to = IGRAPH_OTHER(graph, edge, minnei);
                        igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                        igraph_real_t curdist = distance[to];
                        igraph_vector_int_t *v;

                        if (curdist == 0) {
                            /* This is the first finite distance to 'to' */
                            v = igraph_inclist_get(&fathers, to);
                            igraph_vector_int_resize(v, 1);
                            VECTOR(*v)[0] = edge;
                            nrgeo[to] = nrgeo[minnei];
                            distance[to] = altdist + 1.0;
                            IGRAPH_CHECK(igraph_2wheap_push_with_index(&heap, to, -altdist));
                        } else if (altdist < curdist - 1) {
                            /* This is a shorter path */
                            v = igraph_inclist_get(&fathers, to);
                            igraph_vector_int_resize(v, 1);
                            VECTOR(*v)[0] = edge;
                            nrgeo[to] = nrgeo[minnei];
                            distance[to] = altdist + 1.0;
                            IGRAPH_CHECK(igraph_2wheap_modify(&heap, to, -altdist));
                        } else if (altdist == curdist - 1) {
                            /* Another path with the same length */
                            v = igraph_inclist_get(&fathers, to);
                            igraph_vector_int_push_back(v, edge);
                            nrgeo[to] += nrgeo[minnei];
                        }
                    }
                } /* igraph_2wheap_empty(&Q) */

                while (!igraph_stack_empty(&stack)) {
                    long int w = (long int) igraph_stack_pop(&stack);
                    igraph_vector_int_t *fatv = igraph_inclist_get(&fathers, w);
                    long int fatv_len = igraph_vector_int_size(fatv);

                    for (i = 0; i < fatv_len; i++) {
                        long int fedge = (long int) VECTOR(*fatv)[i];
                        long int neighbor = IGRAPH_OTHER(graph, fedge, w);
                        tmpscore[neighbor] += (tmpscore[w] + 1) * nrgeo[neighbor] / nrgeo[w];
                        VECTOR(eb)[fedge] += (tmpscore[w] + 1) * nrgeo[neighbor] / nrgeo[w];
                    }

                    tmpscore[w] = 0;
                    distance[w] = 0;
                    nrgeo[w] = 0;
                    igraph_vector_int_clear(fatv);
                }
            } /* source < no_of_nodes */
        }

        /* Now look for the smallest edge betweenness */
        /* and eliminate that edge from the network */
        maxedge = igraph_i_vector_which_max_not_null(&eb, passive);
        VECTOR(*result)[e] = maxedge;
        if (edge_betweenness) {
            VECTOR(*edge_betweenness)[e] = VECTOR(eb)[maxedge];
            if (!directed) {
                VECTOR(*edge_betweenness)[e] /= 2.0;
            }
        }
        passive[maxedge] = 1;
        igraph_edge(graph, (igraph_integer_t) maxedge, &from, &to);

        neip = igraph_inclist_get(elist_in_p, to);
        neino = igraph_vector_int_size(neip);
        igraph_vector_int_search(neip, 0, maxedge, &pos);
        VECTOR(*neip)[pos] = VECTOR(*neip)[neino - 1];
        igraph_vector_int_pop_back(neip);

        neip = igraph_inclist_get(elist_out_p, from);
        neino = igraph_vector_int_size(neip);
        igraph_vector_int_search(neip, 0, maxedge, &pos);
        VECTOR(*neip)[pos] = VECTOR(*neip)[neino - 1];
        igraph_vector_int_pop_back(neip);
    }

    IGRAPH_PROGRESS("Edge betweenness community detection: ", 100.0, NULL);

    igraph_free(passive);
    igraph_vector_destroy(&eb);
    igraph_stack_destroy(&stack);
    IGRAPH_FINALLY_CLEAN(3);

    if (weights == 0) {
        igraph_dqueue_destroy(&q);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        igraph_2wheap_destroy(&heap);
        igraph_inclist_destroy(&fathers);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_free(tmpscore);
    igraph_free(nrgeo);
    igraph_free(distance);
    IGRAPH_FINALLY_CLEAN(3);

    if (directed) {
        igraph_inclist_destroy(&elist_out);
        igraph_inclist_destroy(&elist_in);
        IGRAPH_FINALLY_CLEAN(2);
    } else {
        igraph_inclist_destroy(&elist_out);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (merges || bridges || modularity || membership) {
        IGRAPH_CHECK(igraph_community_eb_get_merges(graph, directed, result, weights, merges,
                     bridges, modularity,
                     membership));
    }

    if (result_owned) {
        igraph_vector_destroy(result);
        IGRAPH_FREE(result);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/fast_modularity.c0000644000175100001710000012762400000000000026053 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_memory.h"
#include "igraph_iterators.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_structural.h"
#include "igraph_vector_ptr.h"

#include "core/interruption.h"

/* #define IGRAPH_FASTCOMM_DEBUG */

#ifdef _MSC_VER
/* MSVC does not support variadic macros */
#include 
void debug(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
#ifdef IGRAPH_FASTCOMM_DEBUG
    vfprintf(stderr, fmt, args);
#endif
    va_end(args);
}
#else
#ifdef IGRAPH_FASTCOMM_DEBUG
    #define debug(...) fprintf(stderr, __VA_ARGS__)
#else
    #define debug(...)
#endif
#endif

/*
 * Implementation of the community structure algorithm originally published
 * by Clauset et al in:
 *
 * A. Clauset, M.E.J. Newman and C. Moore, "Finding community structure in
 * very large networks.". Phys. Rev. E 70, 066111 (2004).
 *
 * The data structures being used are slightly different and they are described
 * most closely in:
 *
 * K. Wakita, T. Tsurumi, "Finding community structure in mega-scale social
 * networks.". arXiv:cs/0702048v1.
 *
 * We maintain a vector of communities, each of which containing a list of
 * pointers to their neighboring communities along with the increase in the
 * modularity score that could be achieved by joining the two communities.
 * Each community has a pointer to one of its neighbors - the one which would
 * result in the highest increase in modularity after a join. The local
 * (community-level) maximums are also stored in an indexed max-heap. The
 * max-heap itself stores its elements in an array which satisfies the heap
 * property, but to allow us to access any of the elements in the array based
 * on the community index (and not based on the array index - which depends on
 * the element's actual position in the heap), we also maintain an index
 * vector in the heap: the ith element of the index vector contains the
 * position of community i in the array of the max-heap. When we perform
 * sifting operations on the heap to restore the heap property, we also maintain
 * the index vector.
 */

/* Structure storing a pair of communities along with their dQ values */
typedef struct s_igraph_i_fastgreedy_commpair {
    long int first;       /* first member of the community pair */
    long int second;      /* second member of the community pair */
    igraph_real_t *dq;    /* pointer to a member of the dq vector storing the */
    /* increase in modularity achieved when joining */
    struct s_igraph_i_fastgreedy_commpair *opposite;
} igraph_i_fastgreedy_commpair;

/* Structure storing a community */
typedef struct {
    igraph_integer_t id;      /* Identifier of the community (for merges matrix) */
    igraph_integer_t size;    /* Size of the community */
    igraph_vector_ptr_t neis; /* references to neighboring communities */
    igraph_i_fastgreedy_commpair* maxdq; /* community pair with maximal dq */
} igraph_i_fastgreedy_community;

/* Global community list structure */
typedef struct {
    long int no_of_communities, n;  /* number of communities, number of vertices */
    igraph_i_fastgreedy_community* e;     /* list of communities */
    igraph_i_fastgreedy_community** heap; /* heap of communities */
    igraph_integer_t *heapindex; /* heap index to speed up lookup by community idx */
} igraph_i_fastgreedy_community_list;

/* Scans the community neighborhood list for the new maximal dq value.
 * Returns 1 if the maximum is different from the previous one,
 * 0 otherwise. */
static int igraph_i_fastgreedy_community_rescan_max(
        igraph_i_fastgreedy_community* comm) {
    long int i, n;
    igraph_i_fastgreedy_commpair *p, *best;
    igraph_real_t bestdq, currdq;

    n = igraph_vector_ptr_size(&comm->neis);
    if (n == 0) {
        comm->maxdq = 0;
        return 1;
    }

    best = (igraph_i_fastgreedy_commpair*)VECTOR(comm->neis)[0];
    bestdq = *best->dq;
    for (i = 1; i < n; i++) {
        p = (igraph_i_fastgreedy_commpair*)VECTOR(comm->neis)[i];
        currdq = *p->dq;
        if (currdq > bestdq) {
            best = p;
            bestdq = currdq;
        }
    }

    if (best != comm->maxdq) {
        comm->maxdq = best;
        return 1;
    } else {
        return 0;
    }
}

/* Destroys the global community list object */
static void igraph_i_fastgreedy_community_list_destroy(
        igraph_i_fastgreedy_community_list* list) {
    long int i;
    for (i = 0; i < list->n; i++) {
        igraph_vector_ptr_destroy(&list->e[i].neis);
    }
    IGRAPH_FREE(list->e);
    if (list->heapindex != 0) {
        IGRAPH_FREE(list->heapindex);
    }
    if (list->heap != 0) {
        IGRAPH_FREE(list->heap);
    }
}

/* Community list heap maintenance: sift down */
static void igraph_i_fastgreedy_community_list_sift_down(
        igraph_i_fastgreedy_community_list* list, long int idx) {
    long int root, child, c1, c2;
    igraph_i_fastgreedy_community* dummy;
    igraph_integer_t dummy2;
    igraph_i_fastgreedy_community** heap = list->heap;
    igraph_integer_t* heapindex = list->heapindex;

    root = idx;
    while (root * 2 + 1 < list->no_of_communities) {
        child = root * 2 + 1;
        if (child + 1 < list->no_of_communities &&
            *heap[child]->maxdq->dq < *heap[child + 1]->maxdq->dq) {
            child++;
        }
        if (*heap[root]->maxdq->dq < *heap[child]->maxdq->dq) {
            c1 = heap[root]->maxdq->first;
            c2 = heap[child]->maxdq->first;

            dummy = heap[root];
            heap[root] = heap[child];
            heap[child] = dummy;

            dummy2 = heapindex[c1];
            heapindex[c1] = heapindex[c2];
            heapindex[c2] = dummy2;

            root = child;
        } else {
            break;
        }
    }
}

/* Community list heap maintenance: sift up */
static void igraph_i_fastgreedy_community_list_sift_up(
        igraph_i_fastgreedy_community_list* list, long int idx) {
    long int root, parent, c1, c2;
    igraph_i_fastgreedy_community* dummy;
    igraph_integer_t dummy2;
    igraph_i_fastgreedy_community** heap = list->heap;
    igraph_integer_t* heapindex = list->heapindex;

    root = idx;
    while (root > 0) {
        parent = (root - 1) / 2;
        if (*heap[parent]->maxdq->dq < *heap[root]->maxdq->dq) {
            c1 = heap[root]->maxdq->first;
            c2 = heap[parent]->maxdq->first;

            dummy = heap[parent];
            heap[parent] = heap[root];
            heap[root] = dummy;

            dummy2 = heapindex[c1];
            heapindex[c1] = heapindex[c2];
            heapindex[c2] = dummy2;

            root = parent;
        } else {
            break;
        }
    }
}

/* Builds the community heap for the first time */
static void igraph_i_fastgreedy_community_list_build_heap(
        igraph_i_fastgreedy_community_list* list) {
    long int i;
    for (i = list->no_of_communities / 2 - 1; i >= 0; i--) {
        igraph_i_fastgreedy_community_list_sift_down(list, i);
    }
}

/* Finds the element belonging to a given community in the heap and return its
 * index in the heap array */
#define igraph_i_fastgreedy_community_list_find_in_heap(list, idx) (list)->heapindex[idx]

/* Dumps the heap - for debugging purposes */
/*
static void igraph_i_fastgreedy_community_list_dump_heap(
        igraph_i_fastgreedy_community_list* list) {
    long int i;
    debug("Heap:\n");
    for (i = 0; i < list->no_of_communities; i++) {
        debug("(%ld, %p, %p)", i, list->heap[i],
              list->heap[i]->maxdq);
        if (list->heap[i]->maxdq) {
            debug(" (%ld, %ld, %.7f)", list->heap[i]->maxdq->first,
                  list->heap[i]->maxdq->second, *list->heap[i]->maxdq->dq);
        }
        debug("\n");
    }
    debug("Heap index:\n");
    for (i = 0; i < list->no_of_communities; i++) {
        debug("%ld ", (long)list->heapindex[i]);
    }
    debug("\nEND\n");
}
*/

/* Checks if the community heap satisfies the heap property.
 * Only useful for debugging. */
/*
static void igraph_i_fastgreedy_community_list_check_heap(
        igraph_i_fastgreedy_community_list* list) {
    long int i;
    for (i = 0; i < list->no_of_communities / 2; i++) {
        if ((2 * i + 1 < list->no_of_communities && *list->heap[i]->maxdq->dq < *list->heap[2 * i + 1]->maxdq->dq) ||
            (2 * i + 2 < list->no_of_communities && *list->heap[i]->maxdq->dq < *list->heap[2 * i + 2]->maxdq->dq)) {
            IGRAPH_WARNING("Heap property violated");
            debug("Position: %ld, %ld and %ld\n", i, 2 * i + 1, 2 * i + 2);
            igraph_i_fastgreedy_community_list_dump_heap(list);
        }
    }
}
*/

/* Removes a given element from the heap */
static void igraph_i_fastgreedy_community_list_remove(
        igraph_i_fastgreedy_community_list* list, long int idx) {
    igraph_real_t old;
    long int commidx;

    /* First adjust the index */
    commidx = list->heap[list->no_of_communities - 1]->maxdq->first;
    list->heapindex[commidx] = (igraph_integer_t) idx;
    commidx = list->heap[idx]->maxdq->first;
    list->heapindex[commidx] = -1;

    /* Now remove the element */
    old = *list->heap[idx]->maxdq->dq;
    list->heap[idx] = list->heap[list->no_of_communities - 1];
    list->no_of_communities--;

    /* Recover heap property */
    if (old > *list->heap[idx]->maxdq->dq) {
        igraph_i_fastgreedy_community_list_sift_down(list, idx);
    } else {
        igraph_i_fastgreedy_community_list_sift_up(list, idx);
    }
}

/* Removes a given element from the heap when there are no more neighbors
 * for it (comm->maxdq is NULL) */
static void igraph_i_fastgreedy_community_list_remove2(
        igraph_i_fastgreedy_community_list* list, long int idx, long int comm) {
    long int i;

    if (idx == list->no_of_communities - 1) {
        /* We removed the rightmost element on the bottom level, no problem,
         * there's nothing to be done */
        list->heapindex[comm] = -1;
        list->no_of_communities--;
        return;
    }

    /* First adjust the index */
    i = list->heap[list->no_of_communities - 1]->maxdq->first;
    list->heapindex[i] = (igraph_integer_t) idx;
    list->heapindex[comm] = -1;

    /* Now remove the element */
    list->heap[idx] = list->heap[list->no_of_communities - 1];
    list->no_of_communities--;

    /* Recover heap property */
    for (i = list->no_of_communities / 2 - 1; i >= 0; i--) {
        igraph_i_fastgreedy_community_list_sift_down(list, i);
    }
}

/* Removes the pair belonging to community k from the neighborhood list
 * of community c (that is, clist[c]) and recalculates maxdq */
static void igraph_i_fastgreedy_community_remove_nei(
        igraph_i_fastgreedy_community_list* list, long int c, long int k) {
    long int i, n;
    igraph_bool_t rescan = 0;
    igraph_i_fastgreedy_commpair *p;
    igraph_i_fastgreedy_community *comm;
    igraph_real_t olddq;

    comm = &list->e[c];
    n = igraph_vector_ptr_size(&comm->neis);
    for (i = 0; i < n; i++) {
        p = (igraph_i_fastgreedy_commpair*)VECTOR(comm->neis)[i];
        if (p->second == k) {
            /* Check current maxdq */
            if (comm->maxdq == p) {
                rescan = 1;
            }
            break;
        }
    }
    if (i < n) {
        olddq = *comm->maxdq->dq;
        igraph_vector_ptr_remove(&comm->neis, i);
        if (rescan) {
            igraph_i_fastgreedy_community_rescan_max(comm);
            i = igraph_i_fastgreedy_community_list_find_in_heap(list, c);
            if (comm->maxdq) {
                if (*comm->maxdq->dq > olddq) {
                    igraph_i_fastgreedy_community_list_sift_up(list, i);
                } else {
                    igraph_i_fastgreedy_community_list_sift_down(list, i);
                }
            } else {
                /* no more neighbors for this community. we should remove this
                 * community from the heap and restore the heap property */
                debug("REMOVING (NO MORE NEIS): %ld\n", i);
                igraph_i_fastgreedy_community_list_remove2(list, i, c);
            }
        }
    }
}

/* Auxiliary function to sort a community pair list with respect to the
 * `second` field */
static int igraph_i_fastgreedy_commpair_cmp(const void* p1, const void* p2) {
    igraph_i_fastgreedy_commpair *cp1, *cp2;
    cp1 = *(igraph_i_fastgreedy_commpair**)p1;
    cp2 = *(igraph_i_fastgreedy_commpair**)p2;
    return (int) (cp1->second - cp2->second);
}

/* Sorts the neighbor list of the community with the given index, optionally
 * optimizing the process if we know that the list is nearly sorted and only
 * a given pair is in the wrong place. */
static void igraph_i_fastgreedy_community_sort_neighbors_of(
        igraph_i_fastgreedy_community_list* list, long int index,
        igraph_i_fastgreedy_commpair* changed_pair) {
    igraph_vector_ptr_t* vec;
    long int i, n;
    igraph_bool_t can_skip_sort = 0;
    igraph_i_fastgreedy_commpair *other_pair;

    vec = &list->e[index].neis;
    if (changed_pair != 0) {
        /* Optimized sorting */

        /* First we look for changed_pair in vec */
        n = igraph_vector_ptr_size(vec);
        for (i = 0; i < n; i++) {
            if (VECTOR(*vec)[i] == changed_pair) {
                break;
            }
        }

        /* Did we find it? We should have -- otherwise it's a bug */
        if (i >= n) {
            IGRAPH_WARNING("changed_pair not found in neighbor vector while re-sorting "
                           "the neighbors of a community; this is probably a bug. Falling back to "
                           "full sort instead."
                          );
        } else {
            /* Okay, the pair that changed is at index i. We need to figure out where
             * its new place should be. We can simply try moving the item all the way
             * to the left as long as the comparison function tells so (since the
             * rest of the vector is sorted), and then move all the way to the right
             * as long as the comparison function tells so, and we will be okay. */

            /* Shifting to the left */
            while (i > 0) {
                other_pair = VECTOR(*vec)[i - 1];
                if (other_pair->second > changed_pair->second) {
                    VECTOR(*vec)[i] = other_pair;
                    i--;
                } else {
                    break;
                }
            }
            VECTOR(*vec)[i] = changed_pair;

            /* Shifting to the right */
            while (i < n - 1) {
                other_pair = VECTOR(*vec)[i + 1];
                if (other_pair->second < changed_pair->second) {
                    VECTOR(*vec)[i] = other_pair;
                    i++;
                } else {
                    break;
                }
            }
            VECTOR(*vec)[i] = changed_pair;

            /* Mark that we don't need a full sort */
            can_skip_sort = 1;
        }
    }

    if (!can_skip_sort) {
        /* Fallback to full sorting */
        igraph_vector_ptr_sort(vec, igraph_i_fastgreedy_commpair_cmp);
    }
}

/* Updates the dq value of community pair p in the community with index p->first
 * of the community list clist to newdq and restores the heap property
 * in community c if necessary. Returns 1 if the maximum in the row had
 * to be updated, zero otherwise */
static int igraph_i_fastgreedy_community_update_dq(
        igraph_i_fastgreedy_community_list* list,
        igraph_i_fastgreedy_commpair* p, igraph_real_t newdq) {
    long int i, j, to, from;
    igraph_real_t olddq;
    igraph_i_fastgreedy_community *comm_to, *comm_from;
    to = p->first; from = p->second;
    comm_to = &list->e[to];
    comm_from = &list->e[from];
    if (comm_to->maxdq == p && newdq >= *p->dq) {
        /* If we are adjusting the current maximum and it is increased, we don't
         * have to re-scan for the new maximum */
        *p->dq = newdq;
        /* The maximum was increased, so perform a sift-up in the heap */
        i = igraph_i_fastgreedy_community_list_find_in_heap(list, to);
        igraph_i_fastgreedy_community_list_sift_up(list, i);
        /* Let's check the opposite side. If the pair was not the maximal in
         * the opposite side (the other community list)... */
        if (comm_from->maxdq != p->opposite) {
            if (*comm_from->maxdq->dq < newdq) {
                /* ...and it will become the maximal, we need to adjust and sift up */
                comm_from->maxdq = p->opposite;
                j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                igraph_i_fastgreedy_community_list_sift_up(list, j);
            } else {
                /* The pair was not the maximal in the opposite side and it will
                 * NOT become the maximal, there's nothing to do there */
            }
        } else {
            /* The pair was maximal in the opposite side, so we need to sift it up
             * with the new value */
            j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
            igraph_i_fastgreedy_community_list_sift_up(list, j);
        }
        return 1;
    } else if (comm_to->maxdq != p && (newdq <= *comm_to->maxdq->dq)) {
        /* If we are modifying an item which is not the current maximum, and the
         * new value is less than the current maximum, we don't
         * have to re-scan for the new maximum */
        olddq = *p->dq;
        *p->dq = newdq;
        /* However, if the item was the maximum on the opposite side, we'd better
         * re-scan it */
        if (comm_from->maxdq == p->opposite) {
            if (olddq > newdq) {
                /* Decreased the maximum on the other side, we have to re-scan for the
                 * new maximum */
                igraph_i_fastgreedy_community_rescan_max(comm_from);
                j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                igraph_i_fastgreedy_community_list_sift_down(list, j);
            } else {
                /* Increased the maximum on the other side, we don't have to re-scan
                 * but we might have to sift up */
                j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                igraph_i_fastgreedy_community_list_sift_up(list, j);
            }
        }
        return 0;
    } else {
        /* We got here in two cases:
         (1) the pair we are modifying right now is the maximum in the given
             community and we are decreasing it
         (2) the pair we are modifying right now is NOT the maximum in the
             given community, but we increase it so much that it will become
             the new maximum
         */
        *p->dq = newdq;
        if (comm_to->maxdq != p) {
            /* case (2) */
            comm_to->maxdq = p;
            /* The maximum was increased, so perform a sift-up in the heap */
            i = igraph_i_fastgreedy_community_list_find_in_heap(list, to);
            igraph_i_fastgreedy_community_list_sift_up(list, i);
            /* Opposite side. Chances are that the new value became the maximum
             * in the opposite side, but check it first */
            if (comm_from->maxdq != p->opposite) {
                if (*comm_from->maxdq->dq < newdq) {
                    /* Yes, it will become the new maximum */
                    comm_from->maxdq = p->opposite;
                    j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                    igraph_i_fastgreedy_community_list_sift_up(list, j);
                } else {
                    /* No, nothing to do there */
                }
            } else {
                /* Already increased the maximum on the opposite side, so sift it up */
                j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                igraph_i_fastgreedy_community_list_sift_up(list, j);
            }
        } else {
            /* case (1) */
            /* This is the worst, we have to re-scan the whole community to find
             * the new maximum and update the global maximum as well if necessary */
            igraph_i_fastgreedy_community_rescan_max(comm_to);
            /* The maximum was decreased, so perform a sift-down in the heap */
            i = igraph_i_fastgreedy_community_list_find_in_heap(list, to);
            igraph_i_fastgreedy_community_list_sift_down(list, i);
            if (comm_from->maxdq != p->opposite) {
                /* The one that we decreased on the opposite side is not the
                 * maximal one. Nothing to do. */
            } else {
                /* We decreased the maximal on the opposite side as well. Re-scan
                 * and sift down */
                igraph_i_fastgreedy_community_rescan_max(comm_from);
                j = igraph_i_fastgreedy_community_list_find_in_heap(list, from);
                igraph_i_fastgreedy_community_list_sift_down(list, j);
            }
        }
    }
    return 1;
}

/**
 * \function igraph_community_fastgreedy
 * \brief Finding community structure by greedy optimization of modularity.
 *
 * This function implements the fast greedy modularity optimization
 * algorithm for finding community structure, see
 * A Clauset, MEJ Newman, C Moore: Finding community structure in very
 * large networks, http://www.arxiv.org/abs/cond-mat/0408187 for the
 * details.
 *
 * 
 * Some improvements proposed in K Wakita, T Tsurumi: Finding community
 * structure in mega-scale social networks,
 * http://www.arxiv.org/abs/cs.CY/0702048v1 have also been implemented.
 *
 * \param graph The input graph. It must be a graph without multiple edges.
 *    This is checked and an error message is given for graphs with multiple
 *    edges.
 * \param weights Potentially a numeric vector containing edge
 *    weights. Supply a null pointer here for unweighted graphs. The
 *    weights are expected to be non-negative.
 * \param merges Pointer to an initialized matrix or \c NULL, the result of the
 *    computation is stored here. The matrix has two columns and each
 *    merge corresponds to one merge, the ids of the two merged
 *    components are stored. The component ids are numbered from zero and
 *    the first \c n components are the individual vertices, \c n is
 *    the number of vertices in the graph. Component \c n is created
 *    in the first merge, component n+1 in the second merge, etc.
 *    The matrix will be resized as needed. If this argument is \c NULL
 *    then it is ignored completely.
 * \param modularity Pointer to an initialized vector or \c NULL pointer,
 *    in the former case the modularity scores along the stages of the
 *    computation are recorded here. The vector will be resized as
 *    needed.
 * \param membership Pointer to a vector. If not a null pointer, then
 *    the membership vector corresponding to the best split (in terms
 *    of modularity) is stored here.
 * \return Error code.
 *
 * \sa \ref igraph_community_walktrap(), \ref
 * igraph_community_edge_betweenness() for other community detection
 * algorithms, \ref igraph_community_to_membership() to convert the
 * dendrogram to a membership vector.
 *
 * Time complexity: O(|E||V|log|V|) in the worst case,
 * O(|E|+|V|log^2|V|) typically, |V| is the number of vertices, |E| is
 * the number of edges.
 *
 * \example examples/simple/igraph_community_fastgreedy.c
 */
int igraph_community_fastgreedy(const igraph_t *graph,
                                const igraph_vector_t *weights,
                                igraph_matrix_t *merges,
                                igraph_vector_t *modularity,
                                igraph_vector_t *membership) {
    long int no_of_edges, no_of_nodes, no_of_joins, total_joins;
    long int i, j, k, n, m, from, to, dummy, best_no_of_joins;
    igraph_integer_t ffrom, fto;
    igraph_eit_t edgeit;
    igraph_i_fastgreedy_commpair *pairs, *p1, *p2;
    igraph_i_fastgreedy_community_list communities;
    igraph_vector_t a;
    igraph_real_t q, *dq, bestq, weight_sum, loop_weight_sum;
    igraph_bool_t has_multiple;
    igraph_matrix_t merges_local;

    /*long int join_order[] = { 16,5, 5,6, 6,0, 4,0, 10,0, 26,29, 29,33, 23,33, 27,33, 25,24, 24,31, 12,3, 21,1, 30,8, 8,32, 9,2, 17,1, 11,0, 7,3, 3,2, 13,2, 1,2, 28,31, 31,33, 22,32, 18,32, 20,32, 32,33, 15,33, 14,33, 0,19, 19,2, -1,-1 };*/
    /*long int join_order[] = { 43,42, 42,41, 44,41, 41,36, 35,36, 37,36, 36,29, 38,29, 34,29, 39,29, 33,29, 40,29, 32,29, 14,29, 30,29, 31,29, 6,18, 18,4, 23,4, 21,4, 19,4, 27,4, 20,4, 22,4, 26,4, 25,4, 24,4, 17,4, 0,13, 13,2, 1,2, 11,2, 8,2, 5,2, 3,2, 10,2, 9,2, 7,2, 2,28, 28,15, 12,15, 29,16, 4,15, -1,-1 };*/

    no_of_nodes = igraph_vcount(graph);
    no_of_edges = igraph_ecount(graph);

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Fast greedy community detection works on undirected graphs only.", IGRAPH_UNIMPLEMENTED);
    }

    total_joins = no_of_nodes > 0 ? no_of_nodes - 1 : 0;

    if (weights != 0) {
        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Length of weight vector must agree with number of edges.", IGRAPH_EINVAL);
        }
        if (no_of_edges > 0) {
            igraph_real_t minweight = igraph_vector_min(weights);
            if (minweight < 0) {
                IGRAPH_ERROR("Weights must not be negative.", IGRAPH_EINVAL);
            }
            if (igraph_is_nan(minweight)) {
                IGRAPH_ERROR("Weights must not be NaN.", IGRAPH_EINVAL);
            }
        }
        weight_sum = igraph_vector_sum(weights);
    } else {
        weight_sum = no_of_edges;
    }

    IGRAPH_CHECK(igraph_has_multiple(graph, &has_multiple));
    if (has_multiple) {
        IGRAPH_ERROR("Fast greedy community detection works only on graphs without multi-edges.", IGRAPH_EINVAL);
    }

    if (membership != 0 && merges == 0) {
        /* We need the merge matrix because the user wants the membership
         * vector, so we allocate one on our own */
        IGRAPH_CHECK(igraph_matrix_init(&merges_local, total_joins, 2));
        IGRAPH_FINALLY(igraph_matrix_destroy, &merges_local);
        merges = &merges_local;
    }

    if (merges != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(merges, total_joins, 2));
        igraph_matrix_null(merges);
    }

    if (modularity != 0) {
        IGRAPH_CHECK(igraph_vector_resize(modularity, total_joins + 1));
    }

    /* Create degree vector */
    IGRAPH_VECTOR_INIT_FINALLY(&a, no_of_nodes);
    if (weights) {
        debug("Calculating weighted degrees\n");
        for (i = 0; i < no_of_edges; i++) {
            VECTOR(a)[(long int)IGRAPH_FROM(graph, i)] += VECTOR(*weights)[i];
            VECTOR(a)[(long int)IGRAPH_TO(graph, i)] += VECTOR(*weights)[i];
        }
    } else {
        debug("Calculating degrees\n");
        IGRAPH_CHECK(igraph_degree(graph, &a, igraph_vss_all(), IGRAPH_ALL, 1));
    }

    /* Create list of communities */
    debug("Creating community list\n");
    communities.n = no_of_nodes;
    communities.no_of_communities = no_of_nodes;
    communities.e = (igraph_i_fastgreedy_community*)calloc((size_t) no_of_nodes, sizeof(igraph_i_fastgreedy_community));
    if (communities.e == 0) {
        IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, communities.e);
    communities.heap = (igraph_i_fastgreedy_community**)calloc((size_t) no_of_nodes, sizeof(igraph_i_fastgreedy_community*));
    if (communities.heap == 0) {
        IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, communities.heap);
    communities.heapindex = (igraph_integer_t*)calloc((size_t)no_of_nodes, sizeof(igraph_integer_t));
    if (communities.heapindex == 0) {
        IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY_CLEAN(2);
    IGRAPH_FINALLY(igraph_i_fastgreedy_community_list_destroy, &communities);
    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_ptr_init(&communities.e[i].neis, 0);
        communities.e[i].id = (igraph_integer_t) i;
        communities.e[i].size = 1;
    }

    /* Create list of community pairs from edges */
    debug("Allocating dq vector\n");
    dq = (igraph_real_t*)calloc((size_t) no_of_edges, sizeof(igraph_real_t));
    if (dq == 0) {
        IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, dq);
    debug("Creating community pair list\n");
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);
    pairs = (igraph_i_fastgreedy_commpair*)calloc(2 * (size_t) no_of_edges, sizeof(igraph_i_fastgreedy_commpair));
    if (pairs == 0) {
        IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, pairs);
    loop_weight_sum = 0;
    for (i = 0, j = 0; !IGRAPH_EIT_END(edgeit); i += 2, j++, IGRAPH_EIT_NEXT(edgeit)) {
        long int eidx = IGRAPH_EIT_GET(edgeit);
        igraph_edge(graph, (igraph_integer_t) eidx, &ffrom, &fto);

        /* Create the pairs themselves */
        from = (long int)ffrom; to = (long int)fto;
        if (from == to) {
            loop_weight_sum += weights ? 2 * VECTOR(*weights)[eidx] : 2;
            continue;
        }

        if (from > to) {
            dummy = from; from = to; to = dummy;
        }
        if (weights) {
            dq[j] = 2 * (VECTOR(*weights)[eidx] / (weight_sum * 2.0) - VECTOR(a)[from] * VECTOR(a)[to] / (4.0 * weight_sum * weight_sum));
        } else {
            dq[j] = 2 * (1.0 / (no_of_edges * 2.0) - VECTOR(a)[from] * VECTOR(a)[to] / (4.0 * no_of_edges * no_of_edges));
        }
        pairs[i].first = from;
        pairs[i].second = to;
        pairs[i].dq = &dq[j];
        pairs[i].opposite = &pairs[i + 1];
        pairs[i + 1].first = to;
        pairs[i + 1].second = from;
        pairs[i + 1].dq = pairs[i].dq;
        pairs[i + 1].opposite = &pairs[i];
        /* Link the pair to the communities */
        igraph_vector_ptr_push_back(&communities.e[from].neis, &pairs[i]);
        igraph_vector_ptr_push_back(&communities.e[to].neis, &pairs[i + 1]);
        /* Update maximums */
        if (communities.e[from].maxdq == 0 || *communities.e[from].maxdq->dq < *pairs[i].dq) {
            communities.e[from].maxdq = &pairs[i];
        }
        if (communities.e[to].maxdq == 0 || *communities.e[to].maxdq->dq < *pairs[i + 1].dq) {
            communities.e[to].maxdq = &pairs[i + 1];
        }
    }
    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(1);

    /* Sorting community neighbor lists by community IDs */
    debug("Sorting community neighbor lists\n");
    for (i = 0, j = 0; i < no_of_nodes; i++) {
        igraph_i_fastgreedy_community_sort_neighbors_of(&communities, i, 0);
        /* Isolated vertices and vertices with loop edges only won't be stored in
         * the heap (to avoid maxdq == 0) */
        if (communities.e[i].maxdq != 0) {
            communities.heap[j] = &communities.e[i];
            communities.heapindex[i] = (igraph_integer_t) j;
            j++;
        } else {
            communities.heapindex[i] = -1;
        }
    }
    communities.no_of_communities = j;

    /* Calculate proper vector a (see paper) and initial modularity */
    q = 2.0 * (weights ? weight_sum : no_of_edges);
    if (q == 0) {
        /* All the weights are zero */
    } else {
        igraph_vector_scale(&a, 1.0 / q);
        q = loop_weight_sum / q;
        for (i = 0; i < no_of_nodes; i++) {
            q -= VECTOR(a)[i] * VECTOR(a)[i];
        }
    }

    /* Initialize "best modularity" value and best merge counter */
    bestq = q;
    best_no_of_joins = 0;

    /* Initializing community heap */
    debug("Initializing community heap\n");
    igraph_i_fastgreedy_community_list_build_heap(&communities);

    debug("Initial modularity: %.4f\n", q);

    /* Let's rock ;) */
    no_of_joins = 0;
    while (no_of_joins < total_joins) {
        IGRAPH_ALLOW_INTERRUPTION();
        IGRAPH_PROGRESS("Fast greedy community detection", no_of_joins * 100.0 / total_joins, 0);

        /* Store the modularity */
        if (modularity) {
            VECTOR(*modularity)[no_of_joins] = q;
        }

        /* Update best modularity if needed */
        if (q >= bestq) {
            bestq = q;
            best_no_of_joins = no_of_joins;
        }

        /* Some debug info if needed */
        /* igraph_i_fastgreedy_community_list_check_heap(&communities); */
#ifdef IGRAPH_FASTCOMM_DEBUG
        debug("===========================================\n");
        for (i = 0; i < communities.n; i++) {
            if (communities.e[i].maxdq == 0) {
                debug("Community #%ld: PASSIVE\n", i);
                continue;
            }
            debug("Community #%ld\n ", i);
            for (j = 0; j < igraph_vector_ptr_size(&communities.e[i].neis); j++) {
                p1 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[i].neis)[j];
                debug(" (%ld,%ld,%.4f)", p1->first, p1->second, *p1->dq);
            }
            p1 = communities.e[i].maxdq;
            debug("\n  Maxdq: (%ld,%ld,%.4f)\n", p1->first, p1->second, *p1->dq);
        }
        debug("Global maxdq is: (%ld,%ld,%.4f)\n", communities.heap[0]->maxdq->first,
              communities.heap[0]->maxdq->second, *communities.heap[0]->maxdq->dq);
        for (i = 0; i < communities.no_of_communities; i++) {
            debug("(%ld,%ld,%.4f) ", communities.heap[i]->maxdq->first, communities.heap[i]->maxdq->second, *communities.heap[0]->maxdq->dq);
        }
        debug("\n");
#endif
        if (communities.heap[0] == 0) {
            break;    /* no more communities */
        }
        if (communities.heap[0]->maxdq == 0) {
            break;    /* there are only isolated comms */
        }
        to = communities.heap[0]->maxdq->second;
        from = communities.heap[0]->maxdq->first;

        debug("Q[%ld] = %.7f\tdQ = %.7f\t |H| = %ld\n",
              no_of_joins, q, *communities.heap[0]->maxdq->dq, no_of_nodes - no_of_joins - 1);

        /* IGRAPH_FASTCOMM_DEBUG */
        /* from=join_order[no_of_joins*2]; to=join_order[no_of_joins*2+1];
        if (to == -1) break;
        for (i=0; isecond == from) communities.maxdq = p1;
        } */

        n = igraph_vector_ptr_size(&communities.e[to].neis);
        m = igraph_vector_ptr_size(&communities.e[from].neis);
        /*if (n>m) {
          dummy=n; n=m; m=dummy;
          dummy=to; to=from; from=dummy;
        }*/
        debug("  joining: %ld <- %ld\n", to, from);
        q += *communities.heap[0]->maxdq->dq;

        /* Merge the second community into the first */
        i = j = 0;
        while (i < n && j < m) {
            p1 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[to].neis)[i];
            p2 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[from].neis)[j];
            debug("Pairs: %ld-%ld and %ld-%ld\n", p1->first, p1->second,
                  p2->first, p2->second);
            if (p1->second < p2->second) {
                /* Considering p1 from now on */
                debug("    Considering: %ld-%ld\n", p1->first, p1->second);
                if (p1->second == from) {
                    debug("    WILL REMOVE: %ld-%ld\n", to, from);
                } else {
                    /* chain, case 1 */
                    debug("    CHAIN(1): %ld-%ld %ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
                          to, p1->second, from, *p1->dq, -2 * VECTOR(a)[from]*VECTOR(a)[p1->second], p1->first, p1->second, *p1->dq - 2 * VECTOR(a)[from]*VECTOR(a)[p1->second]);
                    igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq - 2 * VECTOR(a)[from]*VECTOR(a)[p1->second]);
                }
                i++;
            } else if (p1->second == p2->second) {
                /* p1->first, p1->second and p2->first form a triangle */
                debug("    Considering: %ld-%ld and %ld-%ld\n", p1->first, p1->second,
                      p2->first, p2->second);
                /* Update dq value */
                debug("    TRIANGLE: %ld-%ld-%ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
                      to, p1->second, from, *p1->dq, *p2->dq, p1->first, p1->second, *p1->dq + *p2->dq);
                igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq + *p2->dq);
                igraph_i_fastgreedy_community_remove_nei(&communities, p1->second, from);
                i++;
                j++;
            } else {
                debug("    Considering: %ld-%ld\n", p2->first, p2->second);
                if (p2->second == to) {
                    debug("    WILL REMOVE: %ld-%ld\n", p2->second, p2->first);
                } else {
                    /* chain, case 2 */
                    debug("    CHAIN(2): %ld %ld-%ld, newdq(%ld,%ld)=%.7f\n",
                          to, p2->second, from, to, p2->second, *p2->dq - 2 * VECTOR(a)[to]*VECTOR(a)[p2->second]);
                    p2->opposite->second = to;
                    /* p2->opposite->second changed, so it means that
                     * communities.e[p2->second].neis (which contains p2->opposite) is
                     * not sorted any more. We have to find the index of p2->opposite in
                     * this vector and move it to the correct place. Moving should be an
                     * O(n) operation; re-sorting would be O(n*logn) or even worse,
                     * depending on the pivoting strategy used by qsort() since the
                     * vector is nearly sorted */
                    igraph_i_fastgreedy_community_sort_neighbors_of(
                        &communities, p2->second, p2->opposite);
                    /* link from.neis[j] to the current place in to.neis if
                     * from.neis[j] != to */
                    p2->first = to;
                    IGRAPH_CHECK(igraph_vector_ptr_insert(&communities.e[to].neis, i, p2));
                    n++; i++;
                    if (*p2->dq > *communities.e[to].maxdq->dq) {
                        communities.e[to].maxdq = p2;
                        k = igraph_i_fastgreedy_community_list_find_in_heap(&communities, to);
                        igraph_i_fastgreedy_community_list_sift_up(&communities, k);
                    }
                    igraph_i_fastgreedy_community_update_dq(&communities, p2, *p2->dq - 2 * VECTOR(a)[to]*VECTOR(a)[p2->second]);
                }
                j++;
            }
        }

        p1 = 0;
        while (i < n) {
            p1 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[to].neis)[i];
            if (p1->second == from) {
                debug("    WILL REMOVE: %ld-%ld\n", p1->first, from);
            } else {
                /* chain, case 1 */
                debug("    CHAIN(1): %ld-%ld %ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
                      to, p1->second, from, *p1->dq, -2 * VECTOR(a)[from]*VECTOR(a)[p1->second], p1->first, p1->second, *p1->dq - 2 * VECTOR(a)[from]*VECTOR(a)[p1->second]);
                igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq - 2 * VECTOR(a)[from]*VECTOR(a)[p1->second]);
            }
            i++;
        }
        while (j < m) {
            p2 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[from].neis)[j];
            if (to == p2->second) {
                j++;
                continue;
            }
            /* chain, case 2 */
            debug("    CHAIN(2): %ld %ld-%ld, newdq(%ld,%ld)=%.7f\n",
                  to, p2->second, from, p1 ? p1->first : -1, p2->second, *p2->dq - 2 * VECTOR(a)[to]*VECTOR(a)[p2->second]);
            p2->opposite->second = to;
            /* need to re-sort community nei list `p2->second` */
            igraph_i_fastgreedy_community_sort_neighbors_of(&communities, p2->second, p2->opposite);
            /* link from.neis[j] to the current place in to.neis if
             * from.neis[j] != to */
            p2->first = to;
            IGRAPH_CHECK(igraph_vector_ptr_push_back(&communities.e[to].neis, p2));
            if (*p2->dq > *communities.e[to].maxdq->dq) {
                communities.e[to].maxdq = p2;
                k = igraph_i_fastgreedy_community_list_find_in_heap(&communities, to);
                igraph_i_fastgreedy_community_list_sift_up(&communities, k);
            }
            igraph_i_fastgreedy_community_update_dq(&communities, p2, *p2->dq - 2 * VECTOR(a)[to]*VECTOR(a)[p2->second]);
            j++;
        }

        /* Now, remove community `from` from the neighbors of community `to` */
        if (communities.no_of_communities > 2) {
            debug("    REMOVING: %ld-%ld\n", to, from);
            igraph_i_fastgreedy_community_remove_nei(&communities, to, from);
            i = igraph_i_fastgreedy_community_list_find_in_heap(&communities, from);
            igraph_i_fastgreedy_community_list_remove(&communities, i);
        }
        communities.e[from].maxdq = 0;

        /* Update community sizes */
        communities.e[to].size += communities.e[from].size;
        communities.e[from].size = 0;

        /* record what has been merged */
        /* igraph_vector_ptr_clear is not enough here as it won't free
         * the memory consumed by communities.e[from].neis. Thanks
         * to Tom Gregorovic for pointing that out. */
        igraph_vector_ptr_destroy(&communities.e[from].neis);
        if (merges) {
            MATRIX(*merges, no_of_joins, 0) = communities.e[to].id;
            MATRIX(*merges, no_of_joins, 1) = communities.e[from].id;
            communities.e[to].id = (igraph_integer_t) (no_of_nodes + no_of_joins);
        }

        /* Update vector a */
        VECTOR(a)[to] += VECTOR(a)[from];
        VECTOR(a)[from] = 0.0;

        no_of_joins++;
    }
    /* TODO: continue merging when some isolated communities remained. Always
     * joining the communities with the least number of nodes results in the
     * smallest decrease in modularity every step. Now we're simply deleting
     * the excess rows from the merge matrix */
    if (no_of_joins < total_joins) {
        long int *ivec;
        long int merges_nrow = igraph_matrix_nrow(merges);
        ivec = IGRAPH_CALLOC(merges_nrow, long int);
        if (ivec == 0) {
            IGRAPH_ERROR("Insufficient memory for fast greedy community detection.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, ivec);
        for (i = 0; i < no_of_joins; i++) {
            ivec[i] = i + 1;
        }
        igraph_matrix_permdelete_rows(merges, ivec, total_joins - no_of_joins);
        IGRAPH_FREE(ivec);
        IGRAPH_FINALLY_CLEAN(1);
    }
    IGRAPH_PROGRESS("Fast greedy community detection", 100.0, 0);

    if (modularity) {
        VECTOR(*modularity)[no_of_joins] = q;
        igraph_vector_resize(modularity, no_of_joins + 1);
    }

    debug("Freeing memory\n");
    IGRAPH_FREE(pairs);
    IGRAPH_FREE(dq);
    igraph_i_fastgreedy_community_list_destroy(&communities);
    igraph_vector_destroy(&a);
    IGRAPH_FINALLY_CLEAN(4);

    if (membership) {
        IGRAPH_CHECK(igraph_community_to_membership(merges,
                     (igraph_integer_t) no_of_nodes,
                     /*steps=*/ (igraph_integer_t) best_no_of_joins,
                     membership,
                     /*csize=*/ 0));
    }

    if (merges == &merges_local) {
        igraph_matrix_destroy(&merges_local);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

#ifdef IGRAPH_FASTCOMM_DEBUG
    #undef IGRAPH_FASTCOMM_DEBUG
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/fluid.c0000644000175100001710000002655300000000000023747 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_interface.h"
#include "igraph_random.h"
#include "igraph_structural.h"

/**
 * \ingroup communities
 * \function igraph_community_fluid_communities
 * \brief Community detection based on fluids interacting on the graph.
 *
 * The algorithm is based on the simple idea of
 * several fluids interacting in a non-homogeneous environment
 * (the graph topology), expanding and contracting based on their
 * interaction and density.
 *
 * This function implements the community detection method described in:
 * Parés F, Gasulla DG, et. al. (2018) Fluid Communities: A Competitive,
 * Scalable and Diverse Community Detection Algorithm. In: Complex Networks
 * & Their Applications VI: Proceedings of Complex Networks 2017 (The Sixth
 * International Conference on Complex Networks and Their Applications),
 * Springer, vol 689, p 229.
 *
 * \param graph The input graph. The graph must be simple and connected.
 *   Empty graphs are not supported as well as single vertex graphs.
 *   Edge directions are ignored. Weights are not considered.
 * \param no_of_communities The number of communities to be found. Must be
 *   greater than 0 and fewer than number of vertices in the graph.
 * \param membership The result vector mapping vertices to the communities
 * they are assigned to.
 * \param modularity If not a null pointer, then it must be a pointer
 *   to a real number. The modularity score of the detected community
 *   structure is stored here.
 * \return Error code.
 *
 * Time complexity: O(|E|)
 *
 * \example examples/simple/igraph_community_fluid_communities.c
 */
int igraph_community_fluid_communities(const igraph_t *graph,
                                       igraph_integer_t no_of_communities,
                                       igraph_vector_t *membership,
                                       igraph_real_t *modularity) {
    /* Declaration of variables */
    long int no_of_nodes, i, j, k, kv1;
    igraph_adjlist_t al;
    double max_density;
    igraph_bool_t res, running;
    igraph_vector_t node_order, density, label_counters, dominant_labels, nonzero_labels;
    igraph_vector_int_t com_to_numvertices;

    /* Initialization of variables needed for initial checking */
    no_of_nodes = igraph_vcount(graph);

    /* Checking input values */
    if (no_of_nodes < 2) {
        if (membership) {
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 0);
        }
        if (modularity) {
            IGRAPH_CHECK(igraph_modularity(graph, membership, 0, 1, igraph_is_directed(graph), modularity));
        }
        return IGRAPH_SUCCESS;
    }
    if ((long int) no_of_communities < 1) {
        IGRAPH_ERROR("Number of requested communities must be greater than zero.", IGRAPH_EINVAL);
    }
    if ((long int) no_of_communities > no_of_nodes) {
        IGRAPH_ERROR("Number of requested communities must not be greater than the number of nodes.",
                     IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(igraph_is_simple(graph, &res));
    if (!res) {
        IGRAPH_ERROR("Fluid community detection supports only simple graphs.", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(igraph_is_connected(graph, &res, IGRAPH_WEAK));
    if (!res) {
        IGRAPH_ERROR("Fluid community detection supports only connected graphs.", IGRAPH_EINVAL);
    }
    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("Edge directions are ignored by fluid community detection.");
    }

    /* Internal variables initialization */
    max_density = 1.0;

    /* Resize membership vector (number of nodes) */
    IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));

    /* Initialize density and com_to_numvertices vectors */
    IGRAPH_CHECK(igraph_vector_init(&density, (long int) no_of_communities));
    IGRAPH_FINALLY(igraph_vector_destroy, &density);
    IGRAPH_CHECK(igraph_vector_int_init(&com_to_numvertices, (long int) no_of_communities));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &com_to_numvertices);

    /* Initialize node ordering vector */
    IGRAPH_CHECK(igraph_vector_init_seq(&node_order, 0, no_of_nodes - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &node_order);

    /* Initialize the membership vector with 0 values */
    igraph_vector_null(membership);
    /* Initialize densities to max_density */
    igraph_vector_fill(&density, max_density);

    /* Initialize com_to_numvertices and initialize communities into membership vector */
    IGRAPH_CHECK(igraph_vector_shuffle(&node_order));
    for (i = 0; i < no_of_communities; i++) {
        /* Initialize membership at initial nodes for each community
         * where 0 refers to have no label*/
        VECTOR(*membership)[(long int)VECTOR(node_order)[i]] = i + 1.0;
        /* Initialize com_to_numvertices list: Number of vertices for each community */
        VECTOR(com_to_numvertices)[i] = 1;
    }

    /* Create an adjacency list representation for efficiency. */
    IGRAPH_CHECK(igraph_adjlist_init(graph, &al, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &al);

    /* Create storage space for counting distinct labels and dominant ones */
    IGRAPH_VECTOR_INIT_FINALLY(&dominant_labels, (long int) no_of_communities);
    IGRAPH_VECTOR_INIT_FINALLY(&nonzero_labels, (long int) no_of_communities);

    IGRAPH_CHECK(igraph_vector_init(&label_counters, (long int) no_of_communities));
    IGRAPH_FINALLY(igraph_vector_destroy, &label_counters);

    /* running is the convergence boolean variable */
    running = 1;
    while (running) {
        /* Declarations of varibales used inside main loop */
        long int v1, size, rand_idx;
        igraph_real_t max_count, label_counter_diff;
        igraph_vector_int_t *neis;
        igraph_bool_t same_label_in_dominant;

        running = 0;

        /* Shuffle the node ordering vector */
        IGRAPH_CHECK(igraph_vector_shuffle(&node_order));
        /* In the prescribed order, loop over the vertices and reassign labels */
        for (i = 0; i < no_of_nodes; i++) {
            /* Clear dominant_labels and nonzero_labels vectors */
            igraph_vector_clear(&dominant_labels);
            igraph_vector_null(&label_counters);

            /* Obtain actual node index */
            v1 = (long int) VECTOR(node_order)[i];
            /* Take into account same label in updating rule */
            kv1 = (long int) VECTOR(*membership)[v1];
            max_count = 0.0;
            if (kv1 != 0) {
                VECTOR(label_counters)[kv1 - 1] += VECTOR(density)[kv1 - 1];
                /* Set up max_count */
                max_count = VECTOR(density)[kv1 - 1];
                /* Initialize dominant_labels */
                IGRAPH_CHECK(igraph_vector_resize(&dominant_labels, 1));
                VECTOR(dominant_labels)[0] = kv1;
            }

            /* Count the weights corresponding to different labels */
            neis = igraph_adjlist_get(&al, v1);
            size = igraph_vector_int_size(neis);
            for (j = 0; j < size; j++) {
                k = (long int) VECTOR(*membership)[(long)VECTOR(*neis)[j]];
                /* skip if it has no label yet */
                if (k == 0) {
                    continue;
                }
                /* Update label counter and evaluate diff against max_count*/
                VECTOR(label_counters)[k - 1] += VECTOR(density)[k - 1];
                label_counter_diff = VECTOR(label_counters)[k - 1] - max_count;
                /* Check if this label must be included in dominant_labels vector */
                if (label_counter_diff > 0.0001) {
                    max_count = VECTOR(label_counters)[k - 1];
                    IGRAPH_CHECK(igraph_vector_resize(&dominant_labels, 1));
                    VECTOR(dominant_labels)[0] = k;
                } else if (-0.0001 < label_counter_diff && label_counter_diff < 0.0001) {
                    IGRAPH_CHECK(igraph_vector_push_back(&dominant_labels, k));
                }
            }

            RNG_BEGIN();
            if (!igraph_vector_empty(&dominant_labels)) {
                /* Maintain same label if it exists in dominant_labels */
                same_label_in_dominant = igraph_vector_contains(&dominant_labels, kv1);

                if (!same_label_in_dominant) {
                    /* We need at least one more iteration */
                    running = 1;

                    /* Select randomly from the dominant labels */
                    rand_idx = RNG_INTEGER(0, igraph_vector_size(&dominant_labels) - 1);
                    k = (long int) VECTOR(dominant_labels)[rand_idx];

                    if (kv1 != 0) {
                        /* Subtract 1 vertex from corresponding community in com_to_numvertices */
                        VECTOR(com_to_numvertices)[kv1 - 1] -= 1;
                        /* Re-calculate density for community kv1 */
                        VECTOR(density)[kv1 - 1] = max_density / VECTOR(com_to_numvertices)[kv1 - 1];
                    }

                    /* Update vertex new label */
                    VECTOR(*membership)[v1] = k;

                    /* Add 1 vertex to corresponding new community in com_to_numvertices */
                    VECTOR(com_to_numvertices)[k - 1] += 1;
                    /* Re-calculate density for new community k */
                    VECTOR(density)[k - 1] = max_density / VECTOR(com_to_numvertices)[k - 1];
                }
            }
            RNG_END();
        }
    }


    /* Shift back the membership vector */
    /* There must be no 0 labels in membership vector at this point */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(*membership)[i] -= 1;
        /* Something went wrong: At least one vertex has no community assigned */
        if (VECTOR(*membership)[i] < 0) {
            IGRAPH_ERROR("Something went wrong during execution. One or more vertices got "
                         "no community assigned at algorithm convergence.", IGRAPH_EINTERNAL);
        }
    }

    igraph_adjlist_destroy(&al);
    IGRAPH_FINALLY_CLEAN(1);

    if (modularity) {
      IGRAPH_CHECK(igraph_modularity(graph, membership, NULL,
                                     /* resolution */ 1,
                                     /* only undirected */ 0, modularity));
    }

    igraph_vector_destroy(&node_order);
    igraph_vector_destroy(&density);
    igraph_vector_int_destroy(&com_to_numvertices);
    igraph_vector_destroy(&label_counters);
    igraph_vector_destroy(&dominant_labels);
    igraph_vector_destroy(&nonzero_labels);
    IGRAPH_FINALLY_CLEAN(6);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4871404
igraph-0.9.9/vendor/source/igraph/src/community/infomap/0000755000175100001710000000000000000000000024116 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap.cc0000644000175100001710000002743400000000000026070 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

   ----
   The original version of this file was written by Martin Rosvall
   email: martin.rosvall@physics.umu.se
   homePage: http://www.tp.umu.se/~rosvall/

   It was integrated in igraph by Emmanuel Navarro
   email: navarro@irit.fr
   homePage: http://www.irit.fr/~Emmanuel.Navarro/
*/

#include 
#include "igraph_interface.h"
#include "igraph_community.h"
#include "core/interruption.h"


#include "infomap_Node.h"
#include "infomap_Greedy.h"

/****************************************************************************/
int infomap_partition(FlowGraph * fgraph, bool rcall) {
    Greedy * greedy;

    // save the original graph
    FlowGraph * cpy_fgraph = new FlowGraph(fgraph);
    IGRAPH_FINALLY(delete_FlowGraph, cpy_fgraph);

    int Nnode = cpy_fgraph->Nnode;
    // "real" number of vertex, ie. number of vertex of the graph

    int iteration = 0;
    double outer_oldCodeLength, newCodeLength;

    int *initial_move = NULL;
    bool initial_move_done = true;

    do { // Main loop
        outer_oldCodeLength = fgraph->codeLength;

        if (iteration > 0) {
            /**********************************************************************/
            //  FIRST PART: re-split the network (if need)
            // ===========================================

            // intial_move indicate current clustering
            initial_move = new int[Nnode];
            // new_cluster_id --> old_cluster_id (save curent clustering state)

            IGRAPH_FINALLY(operator delete [], initial_move);
            initial_move_done = false;

            int *subMoveTo = NULL; // enventual new partitionment of original graph

            if ((iteration % 2 == 0) && (fgraph->Nnode > 1)) {
                // 0/ Submodule movements : partition each module of the
                // current partition (rec. call)

                subMoveTo = new int[Nnode];
                // vid_cpy_fgraph  --> new_cluster_id (new partition)

                IGRAPH_FINALLY(operator delete [], subMoveTo);

                int subModIndex = 0;

                for (int i = 0 ; i < fgraph->Nnode ; i++) {
                    // partition each non trivial module
                    int sub_Nnode = fgraph->node[i]->members.size();
                    if (sub_Nnode > 1) { // If the module is not trivial
                        int *sub_members  = new int[sub_Nnode];      // id_sub --> id
                        IGRAPH_FINALLY(operator delete [], sub_members);

                        for (int j = 0 ; j < sub_Nnode ; j++) {
                            sub_members[j] = fgraph->node[i]->members[j];
                        }

                        // extraction of the subgraph
                        FlowGraph *sub_fgraph = new FlowGraph(cpy_fgraph, sub_Nnode,
                                                              sub_members);
                        IGRAPH_FINALLY(delete_FlowGraph, sub_fgraph);
                        sub_fgraph->initiate();

                        // recursif call of partitionment on the subgraph
                        infomap_partition(sub_fgraph, true);

                        // Record membership changes
                        for (int j = 0; j < sub_fgraph->Nnode; j++) {
                            int Nmembers = sub_fgraph->node[j]->members.size();
                            for (int k = 0; k < Nmembers; k++) {
                                subMoveTo[sub_members[sub_fgraph->node[j]->members[k]]] =
                                    subModIndex;
                            }
                            initial_move[subModIndex] = i;
                            subModIndex++;
                        }

                        delete sub_fgraph;
                        IGRAPH_FINALLY_CLEAN(1);
                        delete [] sub_members;
                        IGRAPH_FINALLY_CLEAN(1);
                    } else {
                        subMoveTo[fgraph->node[i]->members[0]] = subModIndex;
                        initial_move[subModIndex] = i;
                        subModIndex++;
                    }
                }
            } else {
                // 1/ Single-node movements : allows each node to move (again)
                // save current modules
                for (int i = 0; i < fgraph->Nnode; i++) { // for each module
                    int Nmembers = fgraph->node[i]->members.size(); // Module size
                    for (int j = 0; j < Nmembers; j++) { // for each vertex (of the module)
                        initial_move[fgraph->node[i]->members[j]] = i;
                    }
                }
            }

            fgraph->back_to(cpy_fgraph);
            if (subMoveTo) {
                Greedy *cpy_greedy = new Greedy(fgraph);
                IGRAPH_FINALLY(delete_Greedy, cpy_greedy);

                cpy_greedy->setMove(subMoveTo);
                cpy_greedy->apply(false);

                delete_Greedy(cpy_greedy);
                IGRAPH_FINALLY_CLEAN(1);
                delete [] subMoveTo;
                IGRAPH_FINALLY_CLEAN(1);
            }
        }
        /**********************************************************************/
        //  SECOND PART: greedy optimizing it self
        // ===========================================
        double oldCodeLength;

        do {
            // greedy optimizing object creation
            greedy = new Greedy(fgraph);
            IGRAPH_FINALLY(delete_Greedy, greedy);

            // Initial move to apply ?
            if (!initial_move_done && initial_move) {
                initial_move_done = true;
                greedy->setMove(initial_move);
            }

            oldCodeLength = greedy->codeLength;
            bool moved = true;
            int Nloops = 0;
            //int count = 0;
            double inner_oldCodeLength = 1000;

            while (moved) { // main greedy optimizing loop
                inner_oldCodeLength = greedy->codeLength;
                moved = greedy->optimize();

                Nloops++;
                //count++;

                if (fabs(greedy->codeLength - inner_oldCodeLength) < 1.0e-10)
                    // if the move does'n reduce the codelenght -> exit !
                {
                    moved = false;
                }

                //if (count == 10) {
                //  greedy->tune();
                //  count = 0;
                //}
            }

            // transform the network to network of modules:
            greedy->apply(true);
            newCodeLength = greedy->codeLength;

            // destroy greedy object
            delete greedy;
            IGRAPH_FINALLY_CLEAN(1);

        } while (oldCodeLength - newCodeLength >  1.0e-10);
        // while there is some improvement

        if (iteration > 0) {
            delete [] initial_move;
            IGRAPH_FINALLY_CLEAN(1);
        }

        iteration++;
        if (!rcall) {
            IGRAPH_ALLOW_INTERRUPTION();
        }
    } while (outer_oldCodeLength - newCodeLength > 1.0e-10);

    delete cpy_fgraph;
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}


/**
 * \function igraph_community_infomap
 * \brief Find community structure that minimizes the expected
 * description length of a random walker trajectory.
 *
 * Implementation of the InfoMap community detection algorithm.of
 * Martin Rosvall and Carl T. Bergstrom.
 *
 * See :
 * Visualization of the math and the map generator: www.mapequation.org
 * [2] The original paper: M. Rosvall and C. T. Bergstrom, Maps of
 * information flow reveal community structure in complex networks, PNAS
 * 105, 1118 (2008) [http://dx.doi.org/10.1073/pnas.0706851105 ,
 * http://arxiv.org/abs/0707.0609 ]
 * [3] A more detailed paper: M. Rosvall, D. Axelsson, and C. T. Bergstrom,
 * The map equation, Eur. Phys. J. Special Topics 178, 13 (2009).
 * [http://dx.doi.org/10.1140/epjst/e2010-01179-1 ,
 * http://arxiv.org/abs/0906.1405 ]

 * 
 * The original C++ implementation of Martin Rosvall is used,
 * see http://www.tp.umu.se/~rosvall/downloads/infomap_undir.tgz .
 * Intergation in igraph has be done by Emmanuel Navarro (who is grateful to
  * Martin Rosvall and Carl T. Bergstrom for providing this source code.)
 *
 * 
 * Note that the graph must not contain isolated vertices.
 *
 * 
 * If you want to specify a random seed (as in original
 * implementation) you can use \ref igraph_rng_seed().
 *
 * \param graph The input graph.
 * \param e_weights Numeric vector giving the weights of the edges.
 *     If it is a NULL pointer then all edges will have equal
 *     weights. The weights are expected to be positive.
 * \param v_weights Numeric vector giving the weights of the vertices.
 *     If it is a NULL pointer then all vertices will have equal
 *     weights. The weights are expected to be positive.
 * \param nb_trials The number of attempts to partition the network
 *     (can be any integer value equal or larger than 1).
 * \param membership Pointer to a vector. The membership vector is
 *    stored here.
 * \param codelength Pointer to a real. If not NULL the code length of the
 *     partition is stored here.
 * \return Error code.
 *
 * \sa \ref igraph_community_spinglass(), \ref
 * igraph_community_edge_betweenness(), \ref igraph_community_walktrap().
 *
 * Time complexity: TODO.
 */
int igraph_community_infomap(const igraph_t * graph,
                             const igraph_vector_t *e_weights,
                             const igraph_vector_t *v_weights,
                             int nb_trials,
                             igraph_vector_t *membership,
                             igraph_real_t *codelength) {

    FlowGraph * fgraph = new FlowGraph(graph, e_weights, v_weights);
    IGRAPH_FINALLY(delete_FlowGraph, fgraph);

    // compute stationary distribution
    fgraph->initiate();

    FlowGraph * cpy_fgraph ;
    double shortestCodeLength = 1000.0;

    // create membership vector
    int Nnode = fgraph->Nnode;
    IGRAPH_CHECK(igraph_vector_resize(membership, Nnode));

    for (int trial = 0; trial < nb_trials; trial++) {
        cpy_fgraph = new FlowGraph(fgraph);
        IGRAPH_FINALLY(delete_FlowGraph, cpy_fgraph);

        //partition the network
        IGRAPH_CHECK(infomap_partition(cpy_fgraph, false));

        // if better than the better...
        if (cpy_fgraph->codeLength < shortestCodeLength) {
            shortestCodeLength = cpy_fgraph->codeLength;
            // ... store the partition
            for (int i = 0 ; i < cpy_fgraph->Nnode ; i++) {
                int Nmembers = cpy_fgraph->node[i]->members.size();
                for (int k = 0; k < Nmembers; k++) {
                    //cluster[ cpy_fgraph->node[i]->members[k] ] = i;
                    VECTOR(*membership)[cpy_fgraph->node[i]->members[k]] = i;
                }
            }
        }

        delete_FlowGraph(cpy_fgraph);
        IGRAPH_FINALLY_CLEAN(1);
    }

    *codelength = (igraph_real_t) shortestCodeLength / log(2.0);

    delete fgraph;
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_reindex_membership(membership, 0, 0));

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_FlowGraph.cc0000644000175100001710000003122700000000000030034 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "infomap_FlowGraph.h"

#define plogp( x ) ( (x) > 0.0 ? (x)*log(x) : 0.0 )

using namespace std;

void FlowGraph::init(int n, const igraph_vector_t *v_weights) {
    alpha = 0.15;
    beta  = 1.0 - alpha;
    Nnode = n;
    node = new Node*[Nnode];
    if (v_weights) {
        for (int i = 0; i < Nnode; i++) {
            node[i] = new Node(i, (double)VECTOR(*v_weights)[i]);
        }
    } else {
        for (int i = 0; i < Nnode; i++) {
            node[i] = new Node(i, 1.0);
        }
    }
}

FlowGraph::FlowGraph(int n) {
    init(n, NULL);
}

FlowGraph::FlowGraph(int n, const igraph_vector_t *v_weights) {
    init(n, v_weights);
}

/* Build the graph from igraph_t object
 */
FlowGraph::FlowGraph(const igraph_t * graph,
                     const igraph_vector_t *e_weights,
                     const igraph_vector_t *v_weights) {

    int n = (int)igraph_vcount(graph);
    init(n, v_weights);

    int directed = (int) igraph_is_directed(graph);

    double linkWeight = 1.0;
    igraph_integer_t from, to;

    long int Nlinks = (long int) igraph_ecount(graph);
    if (!directed) {
        Nlinks = Nlinks * 2 ;
    }
    for (int i = 0; i < Nlinks; i++) {
        if (!directed) { // not directed
            if (i % 2 == 0) {
                linkWeight = e_weights ? (double)VECTOR(*e_weights)[i / 2] : 1.0;
                igraph_edge(graph, i / 2, &from, &to);
            } else {
                igraph_edge(graph, (i - 1) / 2, &to,   &from);
            }
        } else {         // directed
            linkWeight = e_weights ? (double)VECTOR(*e_weights)[i] : 1.0;
            igraph_edge(graph, i, &from, &to);
        }

        // Populate node from igraph_graph
        if (linkWeight > 0.0) {
            if (from != to) {
                node[(int) from]->outLinks.push_back(make_pair((int)to, linkWeight));
                node[(int) to]->inLinks.push_back(make_pair((int) from, linkWeight));
            }
        }
    }
}

FlowGraph::FlowGraph(FlowGraph * fgraph) {
    int n = fgraph->Nnode;
    init(n, NULL);
    for (int i = 0; i < n; i++) {
        cpyNode(node[i], fgraph->node[i]);
    }

    //XXX: quid de danglings et Ndanglings?

    alpha = fgraph->alpha ;
    beta  = fgraph->beta ;

    exit = fgraph->exit;
    exitFlow = fgraph->exitFlow;
    exit_log_exit = fgraph->exit_log_exit;
    size_log_size = fgraph->size_log_size ;
    nodeSize_log_nodeSize = fgraph->nodeSize_log_nodeSize;

    codeLength = fgraph->codeLength;
}

/** construct a graph by extracting a subgraph from the given graph
 */
FlowGraph::FlowGraph(FlowGraph * fgraph, int sub_Nnode, int * sub_members) {
    init(sub_Nnode, NULL);

    //XXX: use set of integer to ensure that elements are sorted
    set sub_mem;
    for (int j = 0 ; j < sub_Nnode ; j++) {
        sub_mem.insert(sub_members[j]);
    }
    set::iterator it_mem = sub_mem.begin();

    vector sub_renumber = vector(fgraph->Nnode);
    // id --> sub_id

    for (int j = 0; j < fgraph->Nnode; j++) {
        sub_renumber[j] = -1;
    }


    for (int j = 0; j < sub_Nnode; j++) {
        //int orig_nr = sub_members[j];
        int orig_nr = (*it_mem);

        node[j]->teleportWeight = fgraph->node[orig_nr]->teleportWeight;
        node[j]->selfLink       = fgraph->node[orig_nr]->selfLink;
        // Take care of self-link

        int orig_NoutLinks = fgraph->node[orig_nr]->outLinks.size();
        int orig_NinLinks  = fgraph->node[orig_nr]->inLinks.size();

        sub_renumber[orig_nr] = j;

        for (int k = 0; k < orig_NoutLinks; k++) {
            int to = fgraph->node[orig_nr]->outLinks[k].first;
            int to_newnr = sub_renumber[to];
            double link_weight = fgraph->node[orig_nr]->outLinks[k].second;

            if (to < orig_nr) {
                // we add links if the destination (to) has already be seen
                // (ie. smaller than current id) => orig

                if (sub_mem.find(to) != sub_mem.end()) {
                    // printf("%2d | %4d to %4d\n", j, orig_nr, to);
                    // printf("from %4d (%4d:%1.5f) to %4d (%4d)\n", j, orig_nr,
                    //        node[j]->selfLink, to_newnr, to);
                    node[j]->outLinks.push_back(make_pair(to_newnr, link_weight));
                    node[to_newnr]->inLinks.push_back(make_pair(j, link_weight));
                }
            }
        }

        for (int k = 0; k < orig_NinLinks; k++) {
            int to = fgraph->node[orig_nr]->inLinks[k].first;
            int to_newnr = sub_renumber[to];
            double link_weight = fgraph->node[orig_nr]->inLinks[k].second;
            if (to < orig_nr) {
                if (sub_mem.find(to) != sub_mem.end()) {
                    node[j]->inLinks.push_back(make_pair(to_newnr, link_weight));
                    node[to_newnr]->outLinks.push_back(make_pair(j, link_weight));
                }
            }
        }
        it_mem++;
    }
}


FlowGraph::~FlowGraph() {
    //printf("delete FlowGraph !\n");
    for (int i = 0; i < Nnode; i++) {
        delete node[i];
    }
    delete [] node;
}

void delete_FlowGraph(FlowGraph *fgraph) {
    delete fgraph;
}


/** Swap the graph with the one given
    the graph is "re" calibrate
    but NOT the given one.
 */
void FlowGraph::swap(FlowGraph * fgraph) {
    Node ** node_tmp = fgraph->node;
    int Nnode_tmp    = fgraph->Nnode;

    fgraph->node = node;
    fgraph->Nnode = Nnode;

    node = node_tmp;
    Nnode = Nnode_tmp;

    calibrate();
}

/** Initialisation of the graph, compute the flow inside the graph
 *   - count danglings nodes
 *   - normalized edge weights
 *   - Call eigenvector() to compute steady state distribution
 *   - call calibrate to compute codelenght
 */
void FlowGraph::initiate() {
    // Take care of dangling nodes, normalize outLinks, and calculate
    // total teleport weight
    Ndanglings = 0;
    double totTeleportWeight = 0.0;
    for (int i = 0; i < Nnode; i++) {
        totTeleportWeight += node[i]->teleportWeight;
    }

    for (int i = 0; i < Nnode; i++) {
        node[i]->teleportWeight /= totTeleportWeight;
        // normalize teleportation weight

        if (node[i]->outLinks.empty() && (node[i]->selfLink <= 0.0)) {
            danglings.push_back(i);
            Ndanglings++;
        } else { // Normalize the weights
            int NoutLinks = node[i]->outLinks.size();
            double sum = node[i]->selfLink; // Take care of self-links
            for (int j = 0; j < NoutLinks; j++) {
                sum += node[i]->outLinks[j].second;
            }
            node[i]->selfLink /= sum;
            for (int j = 0; j < NoutLinks; j++) {
                node[i]->outLinks[j].second /= sum;
            }
        }
    }

    // Calculate steady state matrix
    eigenvector();

    // Update links to represent flow
    for (int i = 0; i < Nnode; i++) {
        node[i]->selfLink = beta * node[i]->size * node[i]->selfLink;
        //            (1 - \tau) *     \pi_i     *      P_{ii}

        if (!node[i]->outLinks.empty()) {
            int NoutLinks = node[i]->outLinks.size();
            for (int j = 0; j < NoutLinks; j++) {
                node[i]->outLinks[j].second = beta * node[i]->size *
                                              node[i]->outLinks[j].second;
                //                      (1 - \tau) *     \pi_i     *          P_{ij}
            }

            // Update values for corresponding inlink
            for (int j = 0; j < NoutLinks; j++) {
                int NinLinks = node[node[i]->outLinks[j].first]->inLinks.size();
                for (int k = 0; k < NinLinks; k++) {
                    if (node[node[i]->outLinks[j].first]->inLinks[k].first == i) {
                        node[node[i]->outLinks[j].first]->inLinks[k].second =
                            node[i]->outLinks[j].second;
                        k = NinLinks;
                    }
                }
            }
        }
    }

    // To be able to handle dangling nodes efficiently
    for (int i = 0; i < Nnode; i++)
        if (node[i]->outLinks.empty() && (node[i]->selfLink <= 0.0)) {
            node[i]->danglingSize = node[i]->size;
        } else {
            node[i]->danglingSize = 0.0;
        }

    nodeSize_log_nodeSize = 0.0 ;
    // The exit flow from each node at initiation
    for (int i = 0; i < Nnode; i++) {
        node[i]->exit = node[i]->size // Proba to be on i
                        - (alpha * node[i]->size + beta * node[i]->danglingSize) *
                        node[i]->teleportWeight // Proba teleport back to i
                        - node[i]->selfLink;  // Proba stay on i

        // node[i]->exit == q_{i\exit}
        nodeSize_log_nodeSize += plogp(node[i]->size);
    }

    calibrate();
}


/* Compute steady state distribution (ie. PageRank) over the network
 * (for all i update node[i]->size)
 */
void FlowGraph::eigenvector() {
    vector size_tmp = vector(Nnode, 1.0 / Nnode);

    int Niterations = 0;
    double danglingSize;

    double sqdiff = 1.0;
    double sqdiff_old;
    double sum;
    do {
        // Calculate dangling size
        danglingSize = 0.0;
        for (int i = 0; i < Ndanglings; i++) {
            danglingSize += size_tmp[danglings[i]];
        }

        // Flow from teleportation
        for (int i = 0; i < Nnode; i++) {
            node[i]->size = (alpha + beta * danglingSize) * node[i]->teleportWeight;
        }

        // Flow from network steps
        for (int i = 0; i < Nnode; i++) {
            node[i]->size += beta * node[i]->selfLink * size_tmp[i];
            int Nlinks = node[i]->outLinks.size();
            for (int j = 0; j < Nlinks; j++)
                node[node[i]->outLinks[j].first]->size += beta *
                        node[i]->outLinks[j].second * size_tmp[i];
        }

        // Normalize
        sum = 0.0;
        for (int i = 0; i < Nnode; i++) {
            sum += node[i]->size;
        }
        sqdiff_old = sqdiff;
        sqdiff = 0.0;
        for (int i = 0; i < Nnode; i++) {
            node[i]->size /= sum;
            sqdiff += fabs(node[i]->size - size_tmp[i]);
            size_tmp[i] = node[i]->size;
        }
        Niterations++;

        if (sqdiff == sqdiff_old) {
            alpha += 1.0e-10;
            beta = 1.0 - alpha;
        }

    } while ((Niterations < 200) && (sqdiff > 1.0e-15 || Niterations < 50));

    danglingSize = 0.0;
    for (int i = 0; i < Ndanglings; i++) {
        danglingSize += size_tmp[danglings[i]];
    }
    // cout << "done! (the error is " << sqdiff << " after " << Niterations
    //      << " iterations)" << endl;
}


/* Compute the codeLength of the given network
 * note: (in **node, one node == one module)
 */
void FlowGraph::calibrate() {
    exit_log_exit = 0.0;
    exitFlow = 0.0;
    size_log_size = 0.0;

    for (int i = 0; i < Nnode; i++) { // For each module
        // own node/module codebook
        size_log_size         += plogp(node[i]->exit + node[i]->size);

        // use of index codebook
        exitFlow      += node[i]->exit;
        exit_log_exit += plogp(node[i]->exit);
    }

    exit = plogp(exitFlow);

    codeLength = exit - 2.0 * exit_log_exit + size_log_size -
                 nodeSize_log_nodeSize;
}


/* Restore the data from the given FlowGraph object
 */
void FlowGraph::back_to(FlowGraph * fgraph) {
    // delete current nodes
    for (int i = 0 ; i < Nnode ; i++) {
        delete node[i];
    }
    delete [] node;

    Nnode = fgraph->Nnode;

    // copy original ones
    node = new Node*[Nnode];
    for (int i = 0; i < Nnode; i++) {
        node[i] = new Node();
        cpyNode(node[i], fgraph->node[i]);
    }

    // restore atributs
    alpha = fgraph->alpha ;
    beta  = fgraph->beta ;

    exit = fgraph->exit;
    exitFlow = fgraph->exitFlow;
    exit_log_exit = fgraph->exit_log_exit;
    size_log_size = fgraph->size_log_size ;
    nodeSize_log_nodeSize = fgraph->nodeSize_log_nodeSize;

    codeLength = fgraph->codeLength;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_FlowGraph.h0000644000175100001710000000407700000000000027701 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef FLOWGRAPH_H
#define FLOWGRAPH_H

#include 
#include 

#include "igraph_interface.h"

#include "infomap_Node.h"

class FlowGraph {
private:
    void init(int n, const igraph_vector_t *nodeWeights);

public:
    FlowGraph(int n);
    FlowGraph(int n, const igraph_vector_t *nodeWeights);
    FlowGraph(FlowGraph * fgraph);
    FlowGraph(FlowGraph * fgraph, int sub_Nnode, int * sub_members);

    FlowGraph(const igraph_t * graph, const igraph_vector_t *e_weights,
              const igraph_vector_t *v_weights);

    ~FlowGraph();

    void swap(FlowGraph * fgraph);

    void initiate();
    void eigenvector();
    void calibrate();

    void back_to(FlowGraph * fgraph);

    /*************************************************************************/
    Node **node;
    int  Nnode;

    double alpha, beta;

    int Ndanglings;
    std::vector danglings; // id of dangling nodes

    double exit;                  //
    double exitFlow;              //
    double exit_log_exit;         //
    double size_log_size;         //
    double nodeSize_log_nodeSize; // \sum_{v in V} p log(p)

    double codeLength;
};

void delete_FlowGraph(FlowGraph *fgraph);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_Greedy.cc0000644000175100001710000005442700000000000027371 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "infomap_Greedy.h"
#include 
#define plogp( x ) ( (x) > 0.0 ? (x)*log(x) : 0.0 )

using namespace std;

Greedy::Greedy(FlowGraph * fgraph) {
    graph = fgraph;
    Nnode = graph->Nnode;

    alpha = graph->alpha;// teleportation probability
    beta = 1.0 - alpha;  // probability to take normal step

    Nempty = 0;
    vector(Nnode).swap(mod_empty);

    vector(Nnode).swap(node_index);
    vector(Nnode).swap(mod_exit);
    vector(Nnode).swap(mod_size);
    vector(Nnode).swap(mod_danglingSize);
    vector(Nnode).swap(mod_teleportWeight);
    vector(Nnode).swap(mod_members);

    nodeSize_log_nodeSize = graph->nodeSize_log_nodeSize;
    exit_log_exit         = graph->exit_log_exit;
    size_log_size         = graph->size_log_size;
    exitFlow              = graph->exitFlow;

    Node ** node = graph->node;
    for (int i = 0; i < Nnode; i++) { // For each module
        node_index[i]         = i;
        mod_exit[i]           = node[i]->exit;
        mod_size[i]           = node[i]->size;

        mod_danglingSize[i]   = node[i]->danglingSize;
        mod_teleportWeight[i] = node[i]->teleportWeight;
        mod_members[i]        = node[i]->members.size();
    }

    exit = plogp(exitFlow);

    codeLength = exit - 2.0 * exit_log_exit + size_log_size -
                 nodeSize_log_nodeSize;
}

Greedy::~Greedy() {
}

void delete_Greedy(Greedy *greedy) {
    delete greedy;
}


/** Greedy optimizing (as in Blodel and Al.) :
 * for each vertex (selected in a random order) compute the best possible move within neighborhood
 */
bool Greedy::optimize() {
    bool moved = false;
    Node ** node = graph->node;

    RNG_BEGIN();

    // Generate random enumeration of nodes
    vector randomOrder(Nnode);
    for (int i = 0; i < Nnode; i++) {
        randomOrder[i] = i;
    }

    for (int i = 0; i < Nnode - 1; i++) {
        //int randPos = i ; //XXX
        int randPos = RNG_INTEGER(i, Nnode - 1);
        // swap i & randPos
        int tmp              = randomOrder[i];
        randomOrder[i]       = randomOrder[randPos];
        randomOrder[randPos] = tmp;
    }

    unsigned int offset = 1;
    vector redirect(Nnode, 0);
    vector > > flowNtoM(Nnode);

    for (int k = 0; k < Nnode; k++) {

        // Pick nodes in random order
        int flip = randomOrder[k];
        int oldM = node_index[flip];

        // Reset offset when int overflows
        if (offset > INT_MAX) {
            for (int j = 0; j < Nnode; j++) {
                redirect[j] = 0;
            }
            offset = 1;
        }
        // Size of vector with module links
        int NmodLinks = 0;
        // For all outLinks
        int NoutLinks = node[flip]->outLinks.size();
        if (NoutLinks == 0) { //dangling node, add node to calculate flow below
            redirect[oldM] = offset + NmodLinks;
            flowNtoM[NmodLinks].first = oldM;
            flowNtoM[NmodLinks].second.first = 0.0;
            flowNtoM[NmodLinks].second.second = 0.0;
            NmodLinks++;
        } else {
            for (int j = 0; j < NoutLinks; j++) {
                int nb_M       = node_index[node[flip]->outLinks[j].first];
                // index destination du lien
                double nb_flow = node[flip]->outLinks[j].second;
                // wgt du lien
                if (redirect[nb_M] >= offset) {
                    flowNtoM[redirect[nb_M] - offset].second.first += nb_flow;
                } else {
                    redirect[nb_M] = offset + NmodLinks;
                    flowNtoM[NmodLinks].first = nb_M;
                    flowNtoM[NmodLinks].second.first = nb_flow;
                    flowNtoM[NmodLinks].second.second = 0.0;
                    NmodLinks++;
                }
            }
        }
        // For all inLinks
        int NinLinks = node[flip]->inLinks.size();
        for (int j = 0; j < NinLinks; j++) {
            int nb_M = node_index[node[flip]->inLinks[j].first];
            double nb_flow = node[flip]->inLinks[j].second;

            if (redirect[nb_M] >= offset) {
                flowNtoM[redirect[nb_M] - offset].second.second += nb_flow;
            } else {
                redirect[nb_M] = offset + NmodLinks;
                flowNtoM[NmodLinks].first = nb_M;
                flowNtoM[NmodLinks].second.first = 0.0;
                flowNtoM[NmodLinks].second.second = nb_flow;
                NmodLinks++;
            }
        }

        // For teleportation and dangling nodes
        for (int j = 0; j < NmodLinks; j++) {
            int newM = flowNtoM[j].first;
            if (newM == oldM) {
                flowNtoM[j].second.first  +=
                    (alpha * node[flip]->size + beta * node[flip]->danglingSize) *
                    (mod_teleportWeight[oldM] - node[flip]->teleportWeight);
                flowNtoM[j].second.second +=
                    (alpha * (mod_size[oldM] - node[flip]->size) +
                     beta * (mod_danglingSize[oldM] - node[flip]->danglingSize)) *
                    node[flip]->teleportWeight;
            } else {
                flowNtoM[j].second.first  +=
                    (alpha * node[flip]->size + beta * node[flip]->danglingSize) *
                    mod_teleportWeight[newM];
                flowNtoM[j].second.second +=
                    (alpha * mod_size[newM]   + beta * mod_danglingSize[newM]  ) *
                    node[flip]->teleportWeight;
            }
        }

        // Calculate flow to/from own module (default value if no link to
        // own module)
        double outFlowOldM =
            (alpha * node[flip]->size + beta * node[flip]->danglingSize) *
            (mod_teleportWeight[oldM] - node[flip]->teleportWeight) ;
        double inFlowOldM  =
            (alpha * (mod_size[oldM] - node[flip]->size) +
             beta * (mod_danglingSize[oldM] - node[flip]->danglingSize)) *
            node[flip]->teleportWeight;
        if (redirect[oldM] >= offset) {
            outFlowOldM = flowNtoM[redirect[oldM] - offset].second.first;
            inFlowOldM  = flowNtoM[redirect[oldM] - offset].second.second;
        }

        // Option to move to empty module (if node not already alone)
        if (mod_members[oldM] > static_cast(node[flip]->members.size())) {
            if (Nempty > 0) {
                flowNtoM[NmodLinks].first = mod_empty[Nempty - 1];
                flowNtoM[NmodLinks].second.first = 0.0;
                flowNtoM[NmodLinks].second.second = 0.0;
                NmodLinks++;
            }
        }

        // Randomize link order for optimized search
        for (int j = 0; j < NmodLinks - 1; j++) {
            //int randPos = j ; // XXX
            int randPos = RNG_INTEGER(j, NmodLinks - 1);
            int tmp_M = flowNtoM[j].first;
            double tmp_outFlow = flowNtoM[j].second.first;
            double tmp_inFlow = flowNtoM[j].second.second;
            flowNtoM[j].first = flowNtoM[randPos].first;
            flowNtoM[j].second.first = flowNtoM[randPos].second.first;
            flowNtoM[j].second.second = flowNtoM[randPos].second.second;
            flowNtoM[randPos].first = tmp_M;
            flowNtoM[randPos].second.first = tmp_outFlow;
            flowNtoM[randPos].second.second = tmp_inFlow;
        }

        int bestM = oldM;
        double best_outFlow = 0.0;
        double best_inFlow = 0.0;
        double best_delta = 0.0;

        // Find the move that minimizes the description length
        for (int j = 0; j < NmodLinks; j++) {

            int newM = flowNtoM[j].first;
            double outFlowNewM = flowNtoM[j].second.first;
            double inFlowNewM  = flowNtoM[j].second.second;

            if (newM != oldM) {

                double delta_exit = plogp(exitFlow + outFlowOldM + inFlowOldM -
                                          outFlowNewM - inFlowNewM) - exit;

                double delta_exit_log_exit = - plogp(mod_exit[oldM]) -
                                             plogp(mod_exit[newM]) +
                                             plogp(mod_exit[oldM] - node[flip]->exit + outFlowOldM + inFlowOldM)
                                             + plogp(mod_exit[newM] + node[flip]->exit - outFlowNewM -
                                                     inFlowNewM);

                double delta_size_log_size = - plogp(mod_exit[oldM] + mod_size[oldM])
                                             - plogp(mod_exit[newM] + mod_size[newM])
                                             + plogp(mod_exit[oldM] + mod_size[oldM] - node[flip]->exit -
                                                     node[flip]->size + outFlowOldM + inFlowOldM)
                                             + plogp(mod_exit[newM] + mod_size[newM] + node[flip]->exit +
                                                     node[flip]->size - outFlowNewM - inFlowNewM);

                double deltaL = delta_exit - 2.0 * delta_exit_log_exit +
                                delta_size_log_size;

                if (deltaL - best_delta < -1e-10) {
                    bestM = newM;
                    best_outFlow = outFlowNewM;
                    best_inFlow = inFlowNewM;
                    best_delta = deltaL;
                }
            }
        }

        // Make best possible move
        if (bestM != oldM) {
            //Update empty module vector
            if (mod_members[bestM] == 0) {
                Nempty--;
            }
            if (mod_members[oldM] == static_cast(node[flip]->members.size())) {
                mod_empty[Nempty] = oldM;
                Nempty++;
            }

            exitFlow -= mod_exit[oldM] + mod_exit[bestM];

            exit_log_exit -= plogp(mod_exit[oldM]) + plogp(mod_exit[bestM]);
            size_log_size -= plogp(mod_exit[oldM] + mod_size[oldM]) +
                             plogp(mod_exit[bestM] + mod_size[bestM]);

            mod_exit[oldM]            -= node[flip]->exit - outFlowOldM -
                                         inFlowOldM;
            mod_size[oldM]            -= node[flip]->size;
            mod_danglingSize[oldM]    -= node[flip]->danglingSize;
            mod_teleportWeight[oldM]  -= node[flip]->teleportWeight;
            mod_members[oldM]         -= node[flip]->members.size();

            mod_exit[bestM]           += node[flip]->exit - best_outFlow -
                                         best_inFlow;
            mod_size[bestM]           += node[flip]->size;
            mod_danglingSize[bestM]   += node[flip]->danglingSize;
            mod_teleportWeight[bestM] += node[flip]->teleportWeight;
            mod_members[bestM]        += node[flip]->members.size();

            exitFlow += mod_exit[oldM] + mod_exit[bestM];

            // Update terms in map equation

            exit_log_exit += plogp(mod_exit[oldM]) + plogp(mod_exit[bestM]);
            size_log_size += plogp(mod_exit[oldM] + mod_size[oldM]) +
                             plogp(mod_exit[bestM] + mod_size[bestM]);
            exit = plogp(exitFlow);

            // Update code length

            codeLength = exit - 2.0 * exit_log_exit + size_log_size -
                         nodeSize_log_nodeSize;

            node_index[flip] = bestM;
            moved = true;
        }
        offset += Nnode;
    }

    RNG_END();

    return moved;
}

/** Apply the move to the given network
 */
void Greedy::apply(bool sort) {
//void Greedy::level(Node ***node_tmp, bool sort) {

    //old fct prepare(sort)
    vector modSnode;  // will give ids of no-empty modules (nodes)
    int Nmod = 0;
    if (sort) {
        multimap Msize;
        for (int i = 0; i < Nnode; i++) {
            if (mod_members[i] > 0) {
                Nmod++;
                Msize.insert(pair(mod_size[i], i));
            }
        }
        for (multimap::reverse_iterator it = Msize.rbegin();
             it != Msize.rend(); it++) {
            modSnode.push_back(it->second);
        }
    } else {
        for (int i = 0; i < Nnode; i++) {
            if (mod_members[i] > 0) {
                Nmod++;
                modSnode.push_back(i);
            }
        }
    }
    //modSnode[id_when_no_empty_node] = id_in_mod_tbl

    // Create the new graph
    FlowGraph * tmp_fgraph = new FlowGraph(Nmod);
    IGRAPH_FINALLY(delete_FlowGraph, tmp_fgraph);
    Node ** node_tmp = tmp_fgraph->node ;

    Node ** node = graph->node;

    vector nodeInMod = vector(Nnode);

    // creation of new nodes
    for (int i = 0; i < Nmod; i++) {
        //node_tmp[i] = new Node();
        vector().swap(node_tmp[i]->members); // clear membership
        node_tmp[i]->exit           =           mod_exit[modSnode[i]];
        node_tmp[i]->size           =           mod_size[modSnode[i]];
        node_tmp[i]->danglingSize   =   mod_danglingSize[modSnode[i]];
        node_tmp[i]->teleportWeight = mod_teleportWeight[modSnode[i]];

        nodeInMod[modSnode[i]]      = i;
    }
    //nodeInMode[id_in_mod_tbl] = id_when_no_empty_node

    // Calculate outflow of links to different modules
    vector > outFlowNtoM(Nmod);
    map::iterator it_M;

    for (int i = 0; i < Nnode; i++) {
        int i_M = nodeInMod[node_index[i]]; //final id of the module of the node i
        // add node members to the module
        copy( node[i]->members.begin(), node[i]->members.end(),
              back_inserter( node_tmp[i_M]->members ) );

        int NoutLinks = node[i]->outLinks.size();
        for (int j = 0; j < NoutLinks; j++) {
            int nb         = node[i]->outLinks[j].first;
            int nb_M       = nodeInMod[node_index[nb]];
            double nb_flow = node[i]->outLinks[j].second;
            if (nb != i) {
                it_M = outFlowNtoM[i_M].find(nb_M);
                if (it_M != outFlowNtoM[i_M].end()) {
                    it_M->second += nb_flow;
                } else {
                    outFlowNtoM[i_M].insert(make_pair(nb_M, nb_flow));
                }
            }
        }
    }

    // Create outLinks at new level
    for (int i = 0; i < Nmod; i++) {
        for (it_M = outFlowNtoM[i].begin(); it_M != outFlowNtoM[i].end(); it_M++) {
            if (it_M->first != i) {
                node_tmp[i]->outLinks.push_back(make_pair(it_M->first, it_M->second));
            }
        }
    }

    // Calculate inflow of links from different modules
    vector > inFlowNtoM(Nmod);

    for (int i = 0; i < Nnode; i++) {
        int i_M = nodeInMod[node_index[i]];
        int NinLinks = node[i]->inLinks.size();
        for (int j = 0; j < NinLinks; j++) {
            int nb         = node[i]->inLinks[j].first;
            int nb_M       = nodeInMod[node_index[nb]];
            double nb_flow = node[i]->inLinks[j].second;
            if (nb != i) {
                it_M = inFlowNtoM[i_M].find(nb_M);
                if (it_M != inFlowNtoM[i_M].end()) {
                    it_M->second += nb_flow;
                } else {
                    inFlowNtoM[i_M].insert(make_pair(nb_M, nb_flow));
                }
            }
        }
    }

    // Create inLinks at new level
    for (int i = 0; i < Nmod; i++) {
        for (it_M = inFlowNtoM[i].begin(); it_M != inFlowNtoM[i].end(); it_M++) {
            if (it_M->first != i) {
                node_tmp[i]->inLinks.push_back(make_pair(it_M->first, it_M->second));
            }
        }
    }

    // Option to move to empty module
    vector().swap(mod_empty);
    Nempty = 0;

    //swap node between tmp_graph and graph, then destroy tmp_fgraph
    graph->swap(tmp_fgraph);
    Nnode = Nmod;

    delete tmp_fgraph;
    IGRAPH_FINALLY_CLEAN(1);
}


/**
 * RAZ et recalcul :
 *  - mod_exit
 *  - mod_size
 *  - mod_danglingSize
 *  - mod_teleportWeight
 *  - mod_members
 *  and
 *  - exit_log_exit
 *  - size_log_size
 *  - exitFlow
 *  - exit
 *  - codeLength
 * according to **node / node[i]->index
 */
void Greedy::tune(void) {

    exit_log_exit = 0.0;
    size_log_size = 0.0;
    exitFlow = 0.0;

    for (int i = 0; i < Nnode; i++) {
        mod_exit[i] = 0.0;
        mod_size[i] = 0.0;
        mod_danglingSize[i] = 0.0;
        mod_teleportWeight[i] = 0.0;
        mod_members[i] = 0;
    }

    Node ** node = graph->node;
    // Update all values except contribution from teleportation
    for (int i = 0; i < Nnode; i++) {
        int i_M = node_index[i]; // module id of node i
        int Nlinks = node[i]->outLinks.size();

        mod_size[i_M]           += node[i]->size;
        mod_danglingSize[i_M]   += node[i]->danglingSize;
        mod_teleportWeight[i_M] += node[i]->teleportWeight;
        mod_members[i_M]++;

        for (int j = 0; j < Nlinks; j++) {
            int neighbor      = node[i]->outLinks[j].first;
            double neighbor_w = node[i]->outLinks[j].second;
            int neighbor_M    = node_index[neighbor];
            if (i_M != neighbor_M) { // neighbor in an other module
                mod_exit[i_M] += neighbor_w;
            }
        }
    }

    // Update contribution from teleportation
    for (int i = 0; i < Nnode; i++) {
        mod_exit[i] += (alpha * mod_size[i] + beta * mod_danglingSize[i]) *
                       (1.0 - mod_teleportWeight[i]);
    }

    for (int i = 0; i < Nnode; i++) {
        exit_log_exit += plogp(mod_exit[i]);
        size_log_size += plogp(mod_exit[i] + mod_size[i]);
        exitFlow += mod_exit[i];
    }
    exit = plogp(exitFlow);

    codeLength = exit - 2.0 * exit_log_exit + size_log_size -
                 nodeSize_log_nodeSize;
}


/* Compute the new CodeSize if modules are merged as indicated by moveTo
 */
void Greedy::setMove(int *moveTo) {
    //void Greedy::determMove(int *moveTo) {
    Node ** node = graph->node;
    //printf("setMove nNode:%d \n", Nnode);
    for (int i = 0 ; i < Nnode ; i++) { // pour chaque module
        int oldM = i;
        int newM = moveTo[i];
        //printf("old -> new : %d -> %d \n", oldM, newM);
        if (newM != oldM) {

            // Si je comprend bien :
            // outFlow... : c'est le "flow" de i-> autre sommet du meme module
            // inFlow... : c'est le "flow" depuis un autre sommet du meme module --> i
            double outFlowOldM = (alpha * node[i]->size + beta * node[i]->danglingSize) *
                                 (mod_teleportWeight[oldM] - node[i]->teleportWeight);
            double inFlowOldM  = (alpha * (mod_size[oldM] - node[i]->size) +
                                  beta * (mod_danglingSize[oldM] -
                                          node[i]->danglingSize)) *
                                 node[i]->teleportWeight;
            double outFlowNewM = (alpha * node[i]->size + beta * node[i]->danglingSize)
                                 * mod_teleportWeight[newM];
            double inFlowNewM  = (alpha * mod_size[newM] +
                                  beta * mod_danglingSize[newM]) *
                                 node[i]->teleportWeight;

            // For all outLinks
            int NoutLinks = node[i]->outLinks.size();
            for (int j = 0; j < NoutLinks; j++) {
                int nb_M = node_index[node[i]->outLinks[j].first];
                double nb_flow = node[i]->outLinks[j].second;
                if (nb_M == oldM) {
                    outFlowOldM += nb_flow;
                } else if (nb_M == newM) {
                    outFlowNewM += nb_flow;
                }
            }

            // For all inLinks
            int NinLinks = node[i]->inLinks.size();
            for (int j = 0; j < NinLinks; j++) {
                int nb_M = node_index[node[i]->inLinks[j].first];
                double nb_flow = node[i]->inLinks[j].second;
                if (nb_M == oldM) {
                    inFlowOldM += nb_flow;
                } else if (nb_M == newM) {
                    inFlowNewM += nb_flow;
                }
            }

            // Update empty module vector
            // RAZ de mod_empty et Nempty ds calibrate()
            if (mod_members[newM] == 0) {
                // si le nouveau etait vide, on a un vide de moins...
                Nempty--;
            }
            if (mod_members[oldM] == static_cast(node[i]->members.size())) {
                // si l'ancien avait la taille de celui qui bouge, un vide de plus
                mod_empty[Nempty] = oldM;
                Nempty++;
            }

            exitFlow -= mod_exit[oldM] + mod_exit[newM];
            exit_log_exit -= plogp(mod_exit[oldM]) + plogp(mod_exit[newM]);
            size_log_size -= plogp(mod_exit[oldM] + mod_size[oldM]) +
                             plogp(mod_exit[newM] + mod_size[newM]);

            mod_exit[oldM] -= node[i]->exit - outFlowOldM - inFlowOldM;
            mod_size[oldM] -= node[i]->size;
            mod_danglingSize[oldM] -= node[i]->danglingSize;
            mod_teleportWeight[oldM] -= node[i]->teleportWeight;
            mod_members[oldM] -= node[i]->members.size();
            mod_exit[newM] += node[i]->exit - outFlowNewM - inFlowNewM;
            mod_size[newM] += node[i]->size;
            mod_danglingSize[newM] += node[i]->danglingSize;
            mod_teleportWeight[newM] += node[i]->teleportWeight;
            mod_members[newM] += node[i]->members.size();

            exitFlow += mod_exit[oldM] + mod_exit[newM];
            exit_log_exit += plogp(mod_exit[oldM]) + plogp(mod_exit[newM]);
            size_log_size += plogp(mod_exit[oldM] + mod_size[oldM]) +
                             plogp(mod_exit[newM] + mod_size[newM]);
            exit = plogp(exitFlow);

            codeLength = exit - 2.0 * exit_log_exit + size_log_size -
                         nodeSize_log_nodeSize;

            node_index[i] = newM;

        }

    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_Greedy.h0000644000175100001710000000423700000000000027225 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef GREEDY_H
#define GREEDY_H

#include 
#include 
#include 
#include 

#include "igraph_random.h"

#include "infomap_Node.h"
#include "infomap_FlowGraph.h"

class Greedy {
public:
    Greedy(FlowGraph * fgraph);
    // initialise les attributs par rapport au graph

    ~Greedy();

    void setMove(int *moveTo);
    //virtual void determMove(int *moveTo);

    bool optimize();
    //virtual void move(bool &moved);

    void apply(bool sort);
    //virtual void level(Node ***, bool sort);

    void tune(void);

    /**************************************************************************/

    FlowGraph * graph;
    int Nnode;

    double exit;
    double exitFlow;
    double exit_log_exit;
    double size_log_size;
    double nodeSize_log_nodeSize;

    double codeLength;

    double alpha, beta;
    // local copy of fgraph alpha, beta (=alpha -  Nnode = graph->Nnode;1)

    std::vector node_index;  // module number of each node

    int Nempty;
    std::vector mod_empty;

    std::vector mod_exit;  // version tmp de node
    std::vector mod_size;
    std::vector mod_danglingSize;
    std::vector mod_teleportWeight;
    std::vector mod_members;
};

void delete_Greedy(Greedy *greedy);
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_Node.cc0000644000175100001710000000430300000000000027023 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "infomap_Node.h"

using namespace std;

Node::Node() {
    exit = 0.0;
    size = 0.0;
    selfLink = 0.0;
}

Node::Node(int nodenr, double tpweight) {
    teleportWeight = tpweight;
    exit = 0.0;
    size = 0.0;
    selfLink = 0.0;
    members.push_back(nodenr); // members = [nodenr]
}

void cpyNode(Node *newNode, Node *oldNode) {
    newNode->exit = oldNode->exit;
    newNode->size = oldNode->size;
    newNode->teleportWeight = oldNode->teleportWeight;
    newNode->danglingSize   = oldNode->danglingSize;

    int Nmembers = oldNode->members.size();
    newNode->members = vector(Nmembers);
    for (int i = 0; i < Nmembers; i++) {
        newNode->members[i] = oldNode->members[i];
    }

    newNode->selfLink = oldNode->selfLink;

    int NoutLinks = oldNode->outLinks.size();
    newNode->outLinks = vector >(NoutLinks);
    for (int i = 0; i < NoutLinks; i++) {
        newNode->outLinks[i].first = oldNode->outLinks[i].first;
        newNode->outLinks[i].second = oldNode->outLinks[i].second;
    }

    int NinLinks = oldNode->inLinks.size();
    newNode->inLinks = vector >(NinLinks);
    for (int i = 0; i < NinLinks; i++) {
        newNode->inLinks[i].first = oldNode->inLinks[i].first;
        newNode->inLinks[i].second = oldNode->inLinks[i].second;
    }

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/infomap/infomap_Node.h0000644000175100001710000000255200000000000026671 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef NODE_H
#define NODE_H

#include 
#include 

#include "igraph_interface.h"

class Node {
public:

    Node();
    Node(int modulenr, double tpweight);

    std::vector members;
    std::vector< std::pair > inLinks;
    std::vector< std::pair > outLinks;
    double selfLink;

    double teleportWeight;
    double danglingSize;
    double exit;
    double size;
};

void cpyNode(Node *newNode, Node *oldNode);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/label_propagation.c0000644000175100001710000004220500000000000026316 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_random.h"

/**
 * \ingroup communities
 * \function igraph_community_label_propagation
 * \brief Community detection based on label propagation.
 *
 * This function implements the label propagation-based community detection
 * algorithm described by Raghavan, Albert and Kumara. This version extends
 * the original method by the ability to take edge weights into consideration
 * and also by allowing some labels to be fixed.
 *
 * 
 * Weights are taken into account as follows: when the new label of node
 * \c i is determined, the algorithm iterates over all edges incident on
 * node \c i and calculate the total weight of edges leading to other
 * nodes with label 0, 1, 2, ..., \c k - 1 (where \c k is the number of possible
 * labels). The new label of node \c i will then be the label whose edges
 * (among the ones incident on node \c i) have the highest total weight.
 *
 * 
 * Reference:
 *
 * 
 * Raghavan, U.N. and Albert, R. and Kumara, S.:
 * Near linear time algorithm to detect community structures in large-scale networks.
 * Phys Rev E 76, 036106. (2007).
 * https://doi.org/10.1103/PhysRevE.76.036106
 *
 * \param graph The input graph, should be undirected to make sense.
 * \param membership The membership vector, the result is returned here.
 *    For each vertex it gives the ID of its community (label).
 * \param weights The weight vector, it should contain a positive
 *    weight for all the edges.
 * \param initial The initial state. If \c NULL, every vertex will have
 *   a different label at the beginning. Otherwise it must be a vector
 *   with an entry for each vertex. Non-negative values denote different
 *   labels, negative entries denote vertices without labels. Unlabeled
 *   vertices which are not reachable from any labeled ones will remain
 *   unlabeled at the end of the label propagation process, and will be
 *   labeled in an additional step to avoid returning negative values in
 *   \p membership. In undirected graphs, this happens when entire connected
 *   components are unlabeled. Then, each unlabeled component will receive
 *   its own separate label. In directed graphs, the outcome of the
 *   additional labeling should be considered undefined and may change
 *   in the future; please do not rely on it.
 * \param fixed Boolean vector denoting which labels are fixed. Of course
 *   this makes sense only if you provided an initial state, otherwise
 *   this element will be ignored. Also note that vertices without labels
 *   cannot be fixed. If they are, this vector will be modified to
 *   make it consistent with \p initial.
 * \param modularity If not a null pointer, then it must be a pointer
 *   to a real number. The modularity score of the detected community
 *   structure is stored here.
 * \return Error code.
 *
 * Time complexity: O(m+n)
 *
 * \example examples/simple/igraph_community_label_propagation.c
 */
int igraph_community_label_propagation(const igraph_t *graph,
                                       igraph_vector_t *membership,
                                       const igraph_vector_t *weights,
                                       const igraph_vector_t *initial,
                                       const igraph_vector_bool_t *fixed,
                                       igraph_real_t *modularity) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_not_fixed_nodes = no_of_nodes;
    long int i, j, k;
    igraph_adjlist_t al;
    igraph_inclist_t il;
    igraph_bool_t running;
    igraph_bool_t unlabelled_left;

    igraph_vector_t label_counters, dominant_labels, nonzero_labels, node_order;

    /* We make a copy of 'fixed' as a pointer into 'fixed_copy' after casting
     * away the constness, and promise ourselves that we will make a proper
     * copy of 'fixed' into 'fixed_copy' as soon as we start mutating it */
    igraph_vector_bool_t* fixed_copy = (igraph_vector_bool_t*) fixed;

    /* The implementation uses a trick to avoid negative array indexing:
     * elements of the membership vector are increased by 1 at the start
     * of the algorithm; this to allow us to denote unlabeled vertices
     * (if any) by zeroes. The membership vector is shifted back in the end
     */

    /* Do some initial checks */
    if (fixed && igraph_vector_bool_size(fixed) != no_of_nodes) {
        IGRAPH_ERROR("Fixed labeling vector length must agree with number of nodes.", IGRAPH_EINVAL);
    }
    if (weights) {
        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Length of weight vector must agree with number of edges.", IGRAPH_EINVAL);
        }
        if (no_of_edges > 0) {
            igraph_real_t minweight = igraph_vector_min(weights);
            if (minweight < 0) {
                IGRAPH_ERROR("Weights must not be negative.", IGRAPH_EINVAL);
            }
            if (igraph_is_nan(minweight)) {
                IGRAPH_ERROR("Weights must not be NaN.", IGRAPH_EINVAL);
            }
        }
    }
    if (fixed && !initial) {
        IGRAPH_WARNING("Ignoring fixed vertices as no initial labeling given.");
    }

    IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));

    if (initial) {
        if (igraph_vector_size(initial) != no_of_nodes) {
            IGRAPH_ERROR("Initial labeling vector length must agree with number of nodes.", IGRAPH_EINVAL);
        }
        /* Check if the labels used are valid, initialize membership vector */
        for (i = 0; i < no_of_nodes; i++) {
            if (VECTOR(*initial)[i] < 0) {
                VECTOR(*membership)[i] = 0;
            } else {
                VECTOR(*membership)[i] = floor(VECTOR(*initial)[i]) + 1;
            }
        }
        if (fixed) {
            for (i = 0; i < no_of_nodes; i++) {
                if (VECTOR(*fixed)[i]) {
                    if (VECTOR(*membership)[i] == 0) {
                        IGRAPH_WARNING("Fixed nodes cannot be unlabeled, ignoring them.");

                        /* We cannot modify 'fixed' because it is const, so we make a copy and
                         * modify 'fixed_copy' instead */
                        if (fixed_copy == fixed) {
                            fixed_copy = igraph_Calloc(1, igraph_vector_bool_t);
                            if (fixed_copy == 0) {
                                IGRAPH_ERROR("Failed to copy 'fixed' vector.", IGRAPH_ENOMEM);
                            }

                            IGRAPH_FINALLY(igraph_free, fixed_copy);
                            IGRAPH_CHECK(igraph_vector_bool_copy(fixed_copy, fixed));
                            IGRAPH_FINALLY(igraph_vector_bool_destroy, fixed_copy);
                        }

                        VECTOR(*fixed_copy)[i] = 0;
                    } else {
                        no_of_not_fixed_nodes--;
                    }
                }
            }
        }

        i = (long int) igraph_vector_max(membership);
        if (i > no_of_nodes) {
            IGRAPH_ERROR("Elements of the initial labeling vector must be between 0 and |V|-1.", IGRAPH_EINVAL);
        }
    } else {
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*membership)[i] = i + 1;
        }
    }

    /* From this point onwards we use 'fixed_copy' instead of 'fixed' */

    /* Create an adjacency/incidence list representation for efficiency.
     * For the unweighted case, the adjacency list is enough. For the
     * weighted case, we need the incidence list */
    if (weights) {
        IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &il);
    } else {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &al, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &al);
    }

    /* Create storage space for counting distinct labels and dominant ones */
    IGRAPH_VECTOR_INIT_FINALLY(&label_counters, no_of_nodes + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&dominant_labels, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&nonzero_labels, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&dominant_labels, 2));

    /* Initialize node ordering vector with only the not fixed nodes */
    if (fixed_copy) {
        IGRAPH_VECTOR_INIT_FINALLY(&node_order, no_of_not_fixed_nodes);
        for (i = 0, j = 0; i < no_of_nodes; i++) {
            if (!VECTOR(*fixed_copy)[i]) {
                VECTOR(node_order)[j] = i;
                j++;
            }
        }
    } else {
        IGRAPH_CHECK(igraph_vector_init_seq(&node_order, 0, no_of_nodes - 1));
        IGRAPH_FINALLY(igraph_vector_destroy, &node_order);
    }

    running = 1;
    while (running) {
        long int v1, num_neis;
        igraph_real_t max_count;
        igraph_vector_int_t *neis;
        igraph_vector_int_t *ineis;
        igraph_bool_t was_zero;

        running = 0;

        /* Shuffle the node ordering vector */
        IGRAPH_CHECK(igraph_vector_shuffle(&node_order));

        RNG_BEGIN();
        /* In the prescribed order, loop over the vertices and reassign labels */
        for (i = 0; i < no_of_not_fixed_nodes; i++) {
            v1 = (long int) VECTOR(node_order)[i];

            /* Count the weights corresponding to different labels */
            igraph_vector_clear(&dominant_labels);
            igraph_vector_clear(&nonzero_labels);
            max_count = 0.0;
            if (weights) {
                ineis = igraph_inclist_get(&il, v1);
                num_neis = igraph_vector_int_size(ineis);
                for (j = 0; j < num_neis; j++) {
                    k = (long int) VECTOR(*membership)[
                    (long)IGRAPH_OTHER(graph, VECTOR(*ineis)[j], v1) ];
                    if (k == 0) {
                        continue;    /* skip if it has no label yet */
                    }
                    was_zero = (VECTOR(label_counters)[k] == 0);
                    VECTOR(label_counters)[k] += VECTOR(*weights)[(long)VECTOR(*ineis)[j]];
                    if (was_zero && VECTOR(label_counters)[k] != 0) {
                        /* counter just became nonzero */
                        IGRAPH_CHECK(igraph_vector_push_back(&nonzero_labels, k));
                    }
                    if (max_count < VECTOR(label_counters)[k]) {
                        max_count = VECTOR(label_counters)[k];
                        IGRAPH_CHECK(igraph_vector_resize(&dominant_labels, 1));
                        VECTOR(dominant_labels)[0] = k;
                    } else if (max_count == VECTOR(label_counters)[k]) {
                        IGRAPH_CHECK(igraph_vector_push_back(&dominant_labels, k));
                    }
                }
            } else {
                neis = igraph_adjlist_get(&al, v1);
                num_neis = igraph_vector_int_size(neis);
                for (j = 0; j < num_neis; j++) {
                    k = (long int) VECTOR(*membership)[(long)VECTOR(*neis)[j]];
                    if (k == 0) {
                        continue;    /* skip if it has no label yet */
                    }
                    VECTOR(label_counters)[k]++;
                    if (VECTOR(label_counters)[k] == 1) {
                        /* counter just became nonzero */
                        IGRAPH_CHECK(igraph_vector_push_back(&nonzero_labels, k));
                    }
                    if (max_count < VECTOR(label_counters)[k]) {
                        max_count = VECTOR(label_counters)[k];
                        IGRAPH_CHECK(igraph_vector_resize(&dominant_labels, 1));
                        VECTOR(dominant_labels)[0] = k;
                    } else if (max_count == VECTOR(label_counters)[k]) {
                        IGRAPH_CHECK(igraph_vector_push_back(&dominant_labels, k));
                    }
                }
            }

            if (igraph_vector_size(&dominant_labels) > 0) {
                /* Select randomly from the dominant labels */
                k = RNG_INTEGER(0, igraph_vector_size(&dominant_labels) - 1);
                k = (long int) VECTOR(dominant_labels)[k];
                /* Check if the _current_ label of the node is also dominant */
                if (VECTOR(label_counters)[(long)VECTOR(*membership)[v1]] != max_count) {
                    /* Nope, we need at least one more iteration */
                    running = 1;
                }
                VECTOR(*membership)[v1] = k;
            }

            /* Clear the nonzero elements in label_counters */
            num_neis = igraph_vector_size(&nonzero_labels);
            for (j = 0; j < num_neis; j++) {
                VECTOR(label_counters)[(long int)VECTOR(nonzero_labels)[j]] = 0;
            }
        }
        RNG_END();
    }

    if (weights) {
        igraph_inclist_destroy(&il);
    } else {
        igraph_adjlist_destroy(&al);
    }
    IGRAPH_FINALLY_CLEAN(1);

    /* Shift back the membership vector, permute labels in increasing order */
    /* We recycle label_counters here :) */
    igraph_vector_fill(&label_counters, -1);
    j = 0;
    unlabelled_left = 0;
    for (i = 0; i < no_of_nodes; i++) {
        k = (long)VECTOR(*membership)[i] - 1;
        if (k >= 0) {
            if (VECTOR(label_counters)[k] == -1) {
                /* We have seen this label for the first time */
                VECTOR(label_counters)[k] = j;
                k = j;
                j++;
            } else {
                k = (long int) VECTOR(label_counters)[k];
            }
        } else {
            /* This is an unlabeled vertex */
            unlabelled_left = 1;
        }
        VECTOR(*membership)[i] = k;
    }

    /* From this point on, unlabelled nodes are represented with -1 (no longer 0). */
#define IS_UNLABELLED(x) (VECTOR(*membership)[x] < 0)

    /* If any nodes are left unlabelled, we assign the remaining labels to them,
     * as well as to all unlabelled nodes reachable from them.
     *
     * Note that only those nodes could remain unlabelled which were unreachable
     * from any labelled ones. Thus, in the undirected case, fully unlabelled
     * connected components remain unlabelled. Here we label each such component
     * with the same label.
     */
    if (unlabelled_left) {
        igraph_dqueue_t q;
        igraph_vector_t neis;

        /* In the directed case, the outcome depends on the node ordering, thus we
         * shuffle nodes one more time. */
        IGRAPH_CHECK(igraph_vector_shuffle(&node_order));

        IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

        IGRAPH_CHECK(igraph_dqueue_init(&q, 0));
        IGRAPH_FINALLY(igraph_dqueue_destroy, &q);

        for (i=0; i < no_of_nodes; ++i) {
            long int v = VECTOR(node_order)[i];

            /* Is this node unlabelled? */
            if (IS_UNLABELLED(v)) {
                /* If yes, we label it, and do a BFS to apply the same label
                 * to all other unlabelled nodes reachable from it */
                igraph_dqueue_push(&q, v);
                VECTOR(*membership)[v] = j;
                while (!igraph_dqueue_empty(&q)) {
                    long int ni, num_neis;
                    long int actnode = igraph_dqueue_pop(&q);

                    IGRAPH_CHECK(igraph_neighbors(graph, &neis, actnode, IGRAPH_OUT));
                    num_neis = igraph_vector_size(&neis);

                    for (ni = 0; ni < num_neis; ++ni) {
                        long int neighbor = VECTOR(neis)[ni];
                        if (IS_UNLABELLED(neighbor)) {
                            VECTOR(*membership)[neighbor] = j;
                            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                        }
                    }
                }
                j++;
            }
        }

        igraph_vector_destroy(&neis);
        igraph_dqueue_destroy(&q);
        IGRAPH_FINALLY_CLEAN(2);
    }

    if (modularity) {
      IGRAPH_CHECK(igraph_modularity(graph, membership, weights,
                                     /* resolution */ 1,
                                     /* directed */ 1, modularity));
    }

    igraph_vector_destroy(&node_order);
    igraph_vector_destroy(&label_counters);
    igraph_vector_destroy(&dominant_labels);
    igraph_vector_destroy(&nonzero_labels);
    IGRAPH_FINALLY_CLEAN(4);

    if (fixed != fixed_copy) {
        igraph_vector_bool_destroy(fixed_copy);
        igraph_Free(fixed_copy);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/leading_eigenvector.c0000644000175100001710000011736500000000000026643 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"
#include "igraph_memory.h"
#include "igraph_statusbar.h"
#include "igraph_structural.h"

#include "core/interruption.h"

/**
 * \section about_leading_eigenvector_methods
 *
 * 
 * The function documented in these section implements the
 * leading eigenvector method developed by Mark Newman and
 * published in MEJ Newman: Finding community structure using the
 * eigenvectors of matrices, Phys Rev E 74:036104 (2006).
 *
 * 
 * The heart of the method is the definition of the modularity matrix,
 * B, which is B=A-P, A being the adjacency matrix of the (undirected)
 * network, and P contains the probability that certain edges are
 * present according to the configuration model In
 * other words, a Pij element of P is the probability that there is an
 * edge between vertices i and j in a random network in which the
 * degrees of all vertices are the same as in the input graph.
 *
 * 
 * The leading eigenvector method works by calculating the eigenvector
 * of the modularity matrix for the largest positive eigenvalue and
 * then separating vertices into two community based on the sign of
 * the corresponding element in the eigenvector. If all elements in
 * the eigenvector are of the same sign that means that the network
 * has no underlying community structure.
 * Check Newman's paper to understand why this is a good method for
 * detecting community structure. 
 *
 * 
 * The leading eigenvector community structure detection method is
 * implemented in \ref igraph_community_leading_eigenvector(). After
 * the initial split, the following splits are done in a way to
 * optimize modularity regarding to the original network. Note that
 * any further refinement, for example using Kernighan-Lin, as
 * proposed in Section V.A of Newman (2006), is not implemented here.
 * 
 *
 * 
 * \example examples/simple/igraph_community_leading_eigenvector.c
 * 
 */

typedef struct igraph_i_community_leading_eigenvector_data_t {
    igraph_vector_t *idx;
    igraph_vector_t *idx2;
    igraph_adjlist_t *adjlist;
    igraph_inclist_t *inclist;
    igraph_vector_t *tmp;
    long int no_of_edges;
    igraph_vector_t *mymembership;
    long int comm;
    const igraph_vector_t *weights;
    const igraph_t *graph;
    igraph_vector_t *strength;
    igraph_real_t sumweights;
} igraph_i_community_leading_eigenvector_data_t;

static int igraph_i_community_leading_eigenvector(igraph_real_t *to,
                                                  const igraph_real_t *from,
                                                  int n, void *extra) {

    igraph_i_community_leading_eigenvector_data_t *data = extra;
    long int j, k, nlen, size = n;
    igraph_vector_t *idx = data->idx;
    igraph_vector_t *idx2 = data->idx2;
    igraph_vector_t *tmp = data->tmp;
    igraph_adjlist_t *adjlist = data->adjlist;
    igraph_real_t ktx, ktx2;
    long int no_of_edges = data->no_of_edges;
    igraph_vector_t *mymembership = data->mymembership;
    long int comm = data->comm;

    /* Ax */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        nlen = igraph_vector_int_size(neis);
        to[j] = 0.0;
        VECTOR(*tmp)[j] = 0.0;
        for (k = 0; k < nlen; k++) {
            long int nei = (long int) VECTOR(*neis)[k];
            long int neimemb = (long int) VECTOR(*mymembership)[nei];
            if (neimemb == comm) {
                to[j] += from[ (long int) VECTOR(*idx2)[nei] ];
                VECTOR(*tmp)[j] += 1;
            }
        }
    }

    /* Now calculate k^Tx/2m */
    ktx = 0.0; ktx2 = 0.0;
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        long int degree = igraph_vector_int_size(neis);
        ktx += from[j] * degree;
        ktx2 += degree;
    }
    ktx = ktx / no_of_edges / 2.0;
    ktx2 = ktx2 / no_of_edges / 2.0;

    /* Now calculate Bx */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        igraph_real_t degree = igraph_vector_int_size(neis);
        to[j] = to[j] - ktx * degree;
        VECTOR(*tmp)[j] = VECTOR(*tmp)[j] - ktx2 * degree;
    }

    /* -d_ij summa l in G B_il */
    for (j = 0; j < size; j++) {
        to[j] -= VECTOR(*tmp)[j] * from[j];
    }

    return 0;
}

static int igraph_i_community_leading_eigenvector2(igraph_real_t *to,
                                                   const igraph_real_t *from,
                                                   int n, void *extra) {

    igraph_i_community_leading_eigenvector_data_t *data = extra;
    long int j, k, nlen, size = n;
    igraph_vector_t *idx = data->idx;
    igraph_vector_t *idx2 = data->idx2;
    igraph_vector_t *tmp = data->tmp;
    igraph_adjlist_t *adjlist = data->adjlist;
    igraph_real_t ktx, ktx2;
    long int no_of_edges = data->no_of_edges;
    igraph_vector_t *mymembership = data->mymembership;
    long int comm = data->comm;

    /* Ax */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        nlen = igraph_vector_int_size(neis);
        to[j] = 0.0;
        VECTOR(*tmp)[j] = 0.0;
        for (k = 0; k < nlen; k++) {
            long int nei = (long int) VECTOR(*neis)[k];
            long int neimemb = (long int) VECTOR(*mymembership)[nei];
            if (neimemb == comm) {
                long int fi = (long int) VECTOR(*idx2)[nei];
                if (fi < size) {
                    to[j] += from[fi];
                }
                VECTOR(*tmp)[j] += 1;
            }
        }
    }

    /* Now calculate k^Tx/2m */
    ktx = 0.0; ktx2 = 0.0;
    for (j = 0; j < size + 1; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        long int degree = igraph_vector_int_size(neis);
        if (j < size) {
            ktx += from[j] * degree;
        }
        ktx2 += degree;
    }
    ktx = ktx / no_of_edges / 2.0;
    ktx2 = ktx2 / no_of_edges / 2.0;

    /* Now calculate Bx */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, oldid);
        igraph_real_t degree = igraph_vector_int_size(neis);
        to[j] = to[j] - ktx * degree;
        VECTOR(*tmp)[j] = VECTOR(*tmp)[j] - ktx2 * degree;
    }

    /* -d_ij summa l in G B_il */
    for (j = 0; j < size; j++) {
        to[j] -= VECTOR(*tmp)[j] * from[j];
    }

    return 0;
}

static int igraph_i_community_leading_eigenvector_weighted(igraph_real_t *to,
                                                           const igraph_real_t *from,
                                                           int n, void *extra) {

    igraph_i_community_leading_eigenvector_data_t *data = extra;
    long int j, k, nlen, size = n;
    igraph_vector_t *idx = data->idx;
    igraph_vector_t *idx2 = data->idx2;
    igraph_vector_t *tmp = data->tmp;
    igraph_inclist_t *inclist = data->inclist;
    igraph_real_t ktx, ktx2;
    igraph_vector_t *mymembership = data->mymembership;
    long int comm = data->comm;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *strength = data->strength;
    igraph_real_t sw = data->sumweights;

    /* Ax */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *inc = igraph_inclist_get(inclist, oldid);
        nlen = igraph_vector_int_size(inc);
        to[j] = 0.0;
        VECTOR(*tmp)[j] = 0.0;
        for (k = 0; k < nlen; k++) {
            long int edge = (long int) VECTOR(*inc)[k];
            igraph_real_t w = VECTOR(*weights)[edge];
            long int nei = IGRAPH_OTHER(graph, edge, oldid);
            long int neimemb = (long int) VECTOR(*mymembership)[nei];
            if (neimemb == comm) {
                to[j] += from[ (long int) VECTOR(*idx2)[nei] ] * w;
                VECTOR(*tmp)[j] += w;
            }
        }
    }

    /* k^Tx/2m */
    ktx = 0.0; ktx2 = 0.0;
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_real_t str = VECTOR(*strength)[oldid];
        ktx += from[j] * str;
        ktx2 += str;
    }
    ktx = ktx / sw / 2.0;
    ktx2 = ktx2 / sw / 2.0;

    /* Bx */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_real_t str = VECTOR(*strength)[oldid];
        to[j] = to[j] - ktx * str;
        VECTOR(*tmp)[j] = VECTOR(*tmp)[j] - ktx2 * str;
    }

    /* -d_ij summa l in G B_il */
    for (j = 0; j < size; j++) {
        to[j] -= VECTOR(*tmp)[j] * from[j];
    }

    return 0;
}

static int igraph_i_community_leading_eigenvector2_weighted(igraph_real_t *to,
                                                            const igraph_real_t *from,
                                                            int n, void *extra) {

    igraph_i_community_leading_eigenvector_data_t *data = extra;
    long int j, k, nlen, size = n;
    igraph_vector_t *idx = data->idx;
    igraph_vector_t *idx2 = data->idx2;
    igraph_vector_t *tmp = data->tmp;
    igraph_inclist_t *inclist = data->inclist;
    igraph_real_t ktx, ktx2;
    igraph_vector_t *mymembership = data->mymembership;
    long int comm = data->comm;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *strength = data->strength;
    igraph_real_t sw = data->sumweights;

    /* Ax */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_vector_int_t *inc = igraph_inclist_get(inclist, oldid);
        nlen = igraph_vector_int_size(inc);
        to[j] = 0.0;
        VECTOR(*tmp)[j] = 0.0;
        for (k = 0; k < nlen; k++) {
            long int edge = (long int) VECTOR(*inc)[k];
            igraph_real_t w = VECTOR(*weights)[edge];
            long int nei = IGRAPH_OTHER(graph, edge, oldid);
            long int neimemb = (long int) VECTOR(*mymembership)[nei];
            if (neimemb == comm) {
                long int fi = (long int) VECTOR(*idx2)[nei];
                if (fi < size) {
                    to[j] += from[fi] * w;
                }
                VECTOR(*tmp)[j] += w;
            }
        }
    }

    /* k^Tx/2m */
    ktx = 0.0; ktx2 = 0.0;
    for (j = 0; j < size + 1; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_real_t str = VECTOR(*strength)[oldid];
        if (j < size) {
            ktx += from[j] * str;
        }
        ktx2 += str;
    }
    ktx = ktx / sw / 2.0;
    ktx2 = ktx2 / sw / 2.0;

    /* Bx */
    for (j = 0; j < size; j++) {
        long int oldid = (long int) VECTOR(*idx)[j];
        igraph_real_t str = VECTOR(*strength)[oldid];
        to[j] = to[j] - ktx * str;
        VECTOR(*tmp)[j] = VECTOR(*tmp)[j] - ktx2 * str;
    }

    /* -d_ij summa l in G B_il */
    for (j = 0; j < size; j++) {
        to[j] -= VECTOR(*tmp)[j] * from[j];
    }

    return 0;
}

static void igraph_i_levc_free(igraph_vector_ptr_t *ptr) {
    long int i, n = igraph_vector_ptr_size(ptr);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*ptr)[i];
        if (v) {
            igraph_vector_destroy(v);
            igraph_free(v);
        }
    }
}

static void igraph_i_error_handler_none(const char *reason, const char *file,
                                        int line, int igraph_errno) {
    IGRAPH_UNUSED(reason);
    IGRAPH_UNUSED(file);
    IGRAPH_UNUSED(line);
    IGRAPH_UNUSED(igraph_errno);
    /* do nothing */
}


/**
 * \ingroup communities
 * \function igraph_community_leading_eigenvector
 * \brief Leading eigenvector community finding (proper version).
 *
 * Newman's leading eigenvector method for detecting community
 * structure. This is the proper implementation of the recursive,
 * divisive algorithm: each split is done by maximizing the modularity
 * regarding the original network, see MEJ Newman: Finding community
 * structure in networks using the eigenvectors of matrices,
 * Phys Rev E 74:036104 (2006).
 *
 * \param graph The undirected input graph.
 * \param weights The weights of the edges, or a null pointer for
 *    unweighted graphs.
 * \param merges The result of the algorithm, a matrix containing the
 *    information about the splits performed. The matrix is built in
 *    the opposite way however, it is like the result of an
 *    agglomerative algorithm. If at the end of the algorithm (after
 *    \p steps steps was done) there are p communities,
 *    then these are numbered from zero to p-1. The
 *    first line of the matrix contains the first merge
 *    (which is in reality the last split) of two communities into
 *    community p, the merge in the second line forms
 *    community p+1, etc. The matrix should be
 *    initialized before calling and will be resized as needed.
 *    This argument is ignored of it is \c NULL.
 * \param membership The membership of the vertices after all the
 *    splits were performed will be stored here. The vector must be
 *    initialized  before calling and will be resized as needed.
 *    This argument is ignored if it is \c NULL. This argument can
 *    also be used to supply a starting configuration for the community
 *    finding, in the format of a membership vector. In this case the
 *    \p start argument must be set to 1.
 * \param steps The maximum number of steps to perform. It might
 *    happen that some component (or the whole network) has no
 *    underlying community structure and no further steps can be
 *    done. If you want as many steps as possible then supply the
 *    number of vertices in the network here.
 * \param options The options for ARPACK. \c n is always
 *    overwritten. \c ncv is set to at least 4.
 * \param modularity If not a null pointer, then it must be a pointer
 *    to a real number and the modularity score of the final division
 *    is stored here.
 * \param start Boolean, whether to use the community structure given
 *    in the \p membership argument as a starting point.
 * \param eigenvalues Pointer to an initialized vector or a null
 *    pointer. If not a null pointer, then the eigenvalues calculated
 *    along the community structure detection are stored here. The
 *    non-positive eigenvalues, that do not result a split, are stored
 *    as well.
 * \param eigenvectors If not a null pointer, then the eigenvectors
 *    that are calculated in each step of the algorithm, are stored here,
 *    in a pointer vector. Each eigenvector is stored in an
 *    \ref igraph_vector_t object. The user is responsible of
 *    deallocating the memory that belongs to the individual vectors,
 *    by calling first \ref igraph_vector_destroy(), and then
 *    \ref igraph_free() on them.
 * \param history Pointer to an initialized vector or a null pointer.
 *    If not a null pointer, then a trace of the algorithm is stored
 *    here, encoded numerically. The various operations:
 *    \clist
 *    \cli IGRAPH_LEVC_HIST_START_FULL
 *      Start the algorithm from an initial state where each connected
 *      component is a separate community.
 *    \cli IGRAPH_LEVC_HIST_START_GIVEN
 *      Start the algorithm from a given community structure. The next
 *      value in the vector contains the initial number of
 *      communities.
 *    \cli IGRAPH_LEVC_HIST_SPLIT
 *      Split a community into two communities. The id of the splitted
 *      community is given in the next element of the history vector.
 *      The id of the first new community is the same as the id of the
 *      splitted community. The id of the second community equals to
 *      the number of communities before the split.
 *    \cli IGRAPH_LEVC_HIST_FAILED
 *      Tried to split a community, but it was not worth it, as it
 *      does not result in a bigger modularity value. The id of the
 *      community is given in the next element of the vector.
 *    \endclist
 * \param callback A null pointer or a function of type \ref
 *    igraph_community_leading_eigenvector_callback_t. If given, this
 *    callback function is called after each eigenvector/eigenvalue
 *    calculation. If the callback returns a non-zero value, then the
 *    community finding algorithm stops. See the arguments passed to
 *    the callback at the documentation of \ref
 *    igraph_community_leading_eigenvector_callback_t.
 * \param callback_extra Extra argument to pass to the callback
 *    function.
 * \return Error code.
 *
 * \sa \ref igraph_community_walktrap() and \ref
 * igraph_community_spinglass() for other community structure
 * detection methods.
 *
 * Time complexity: O(|E|+|V|^2*steps), |V| is the number of vertices,
 * |E| the number of edges, steps the number of splits
 * performed.
 */
int igraph_community_leading_eigenvector(const igraph_t *graph,
        const igraph_vector_t *weights,
        igraph_matrix_t *merges,
        igraph_vector_t *membership,
        igraph_integer_t steps,
        igraph_arpack_options_t *options,
        igraph_real_t *modularity,
        igraph_bool_t start,
        igraph_vector_t *eigenvalues,
        igraph_vector_ptr_t *eigenvectors,
        igraph_vector_t *history,
        igraph_community_leading_eigenvector_callback_t *callback,
        void *callback_extra) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_dqueue_t tosplit;
    igraph_vector_t idx, idx2, mymerges;
    igraph_vector_t strength, tmp;
    long int staken = 0;
    igraph_adjlist_t adjlist;
    igraph_inclist_t inclist;
    long int i, j, k, l;
    long int communities;
    igraph_vector_t vmembership, *mymembership = membership;
    igraph_i_community_leading_eigenvector_data_t extra;
    igraph_arpack_storage_t storage;
    igraph_real_t mod = 0;
    igraph_arpack_function_t *arpcb1 =
        weights ? igraph_i_community_leading_eigenvector_weighted :
        igraph_i_community_leading_eigenvector;
    igraph_arpack_function_t *arpcb2 =
        weights ? igraph_i_community_leading_eigenvector2_weighted :
        igraph_i_community_leading_eigenvector2;
    igraph_real_t sumweights = 0.0;

    if (weights && no_of_edges != igraph_vector_size(weights)) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    if (start && !membership) {
        IGRAPH_ERROR("Cannot start from given configuration if memberships "
                     "missing", IGRAPH_EINVAL);
    }

    if (start && membership &&
        igraph_vector_size(membership) != no_of_nodes) {
        IGRAPH_ERROR("Wrong length for vector of predefined memberships",
                     IGRAPH_EINVAL);
    }

    if (start && membership && igraph_vector_max(membership) >= no_of_nodes) {
        IGRAPH_WARNING("Too many communities in membership start vector");
    }

    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("This method was developed for undirected graphs");
    }

    if (steps < 0 || steps > no_of_nodes - 1) {
        steps = (igraph_integer_t) no_of_nodes - 1;
    }

    if (!membership) {
        mymembership = &vmembership;
        IGRAPH_VECTOR_INIT_FINALLY(mymembership, 0);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&mymerges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&mymerges, steps * 2));
    IGRAPH_VECTOR_INIT_FINALLY(&idx, 0);
    if (eigenvalues)  {
        igraph_vector_clear(eigenvalues);
    }
    if (eigenvectors) {
        igraph_vector_ptr_clear(eigenvectors);
        IGRAPH_FINALLY(igraph_i_levc_free, eigenvectors);
    }

    IGRAPH_STATUS("Starting leading eigenvector method.\n", 0);

    if (!start) {
        /* Calculate the weakly connected components in the graph and use them as
         * an initial split */
        IGRAPH_CHECK(igraph_clusters(graph, mymembership, &idx, 0, IGRAPH_WEAK));
        communities = igraph_vector_size(&idx);
        IGRAPH_STATUSF(("Starting from %li component(s).\n", 0, communities));
        if (history) {
            IGRAPH_CHECK(igraph_vector_push_back(history,
                                                 IGRAPH_LEVC_HIST_START_FULL));
        }
    } else {
        /* Just create the idx vector for the given membership vector */
        communities = (long int) igraph_vector_max(mymembership) + 1;
        IGRAPH_STATUSF(("Starting from given membership vector with %li "
                        "communities.\n", 0, communities));
        if (history) {
            IGRAPH_CHECK(igraph_vector_push_back(history,
                                                 IGRAPH_LEVC_HIST_START_GIVEN));
            IGRAPH_CHECK(igraph_vector_push_back(history, communities));
        }
        IGRAPH_CHECK(igraph_vector_resize(&idx, communities));
        igraph_vector_null(&idx);
        for (i = 0; i < no_of_nodes; i++) {
            int t = (int) VECTOR(*mymembership)[i];
            VECTOR(idx)[t] += 1;
        }
    }

    IGRAPH_DQUEUE_INIT_FINALLY(&tosplit, 100);
    for (i = 0; i < communities; i++) {
        if (VECTOR(idx)[i] > 2) {
            igraph_dqueue_push(&tosplit, i);
        }
    }
    for (i = 1; i < communities; i++) {
        /* Record merge */
        IGRAPH_CHECK(igraph_vector_push_back(&mymerges, i - 1));
        IGRAPH_CHECK(igraph_vector_push_back(&mymerges, i));
        if (eigenvalues) {
            IGRAPH_CHECK(igraph_vector_push_back(eigenvalues, IGRAPH_NAN));
        }
        if (eigenvectors) {
            igraph_vector_t *v = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!v) {
                IGRAPH_ERROR("Cannot do leading eigenvector community detection",
                             IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, v);
            IGRAPH_VECTOR_INIT_FINALLY(v, 0);
            IGRAPH_CHECK(igraph_vector_ptr_push_back(eigenvectors, v));
            IGRAPH_FINALLY_CLEAN(2);
        }
        if (history) {
            IGRAPH_CHECK(igraph_vector_push_back(history, IGRAPH_LEVC_HIST_SPLIT));
            IGRAPH_CHECK(igraph_vector_push_back(history, i - 1));
        }
    }
    staken = communities - 1;

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_resize(&idx, no_of_nodes));
    igraph_vector_null(&idx);
    IGRAPH_VECTOR_INIT_FINALLY(&idx2, no_of_nodes);
    if (!weights) {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
    } else {
        IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
        IGRAPH_VECTOR_INIT_FINALLY(&strength, no_of_nodes);
        IGRAPH_CHECK(igraph_strength(graph, &strength, igraph_vss_all(),
                                     IGRAPH_ALL, IGRAPH_LOOPS, weights));
        sumweights = igraph_vector_sum(weights);
    }

    options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rssolve */
    options->start = 0;
    options->which[0] = 'L'; options->which[1] = 'A';

    /* Memory for ARPACK */
    /* We are allocating memory for 20 eigenvectors since options->ncv won't be
     * larger than 20 when using automatic mode in igraph_arpack_rssolve */
    IGRAPH_CHECK(igraph_arpack_storage_init(&storage, (int) no_of_nodes, 20,
                                            (int) no_of_nodes, 1));
    IGRAPH_FINALLY(igraph_arpack_storage_destroy, &storage);
    extra.idx = &idx;
    extra.idx2 = &idx2;
    extra.tmp = &tmp;
    extra.adjlist = &adjlist;
    extra.inclist = &inclist;
    extra.weights = weights;
    extra.sumweights = sumweights;
    extra.graph = graph;
    extra.strength = &strength;
    extra.no_of_edges = no_of_edges;
    extra.mymembership = mymembership;

    while (!igraph_dqueue_empty(&tosplit) && staken < steps) {
        long int comm = (long int) igraph_dqueue_pop_back(&tosplit);
        /* depth first search */
        long int size = 0;
        igraph_real_t tmpev;

        IGRAPH_STATUSF(("Trying to split community %li... ", 0, comm));
        IGRAPH_ALLOW_INTERRUPTION();

        for (i = 0; i < no_of_nodes; i++) {
            if (VECTOR(*mymembership)[i] == comm) {
                VECTOR(idx)[size] = i;
                VECTOR(idx2)[i] = size++;
            }
        }

        staken++;
        if (size <= 2) {
            continue;
        }

        /* We solve two eigenproblems, one for the original modularity
           matrix, and one for the modularity matrix after deleting the
           last row and last column from it. This is a trick to find
           multiple leading eigenvalues, because ARPACK is sometimes
           unstable when the first two eigenvalues are requested, but it
           does much better for the single principal eigenvalue. */

        /* We start with the smaller eigenproblem. */

        options->n = (int) size - 1;
        options->info = 0;
        options->nev = 1;
        options->ldv = 0;
        options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rssolve */
        options->nconv = 0;
        options->lworkl = 0;        /* we surely have enough space */
        extra.comm = comm;

        /* We try calling the solver twice, once from a random starting
           point, once from a fixed one. This is because for some hard
           cases it tends to fail. We need to suppress error handling for
           the first call. */
        {
            int i;
            igraph_error_handler_t *errh =
                igraph_set_error_handler(igraph_i_error_handler_none);
            igraph_warning_handler_t *warnh =
                igraph_set_warning_handler(igraph_warning_handler_ignore);
            igraph_arpack_rssolve(arpcb2, &extra, options, &storage,
                                  /*values=*/ 0, /*vectors=*/ 0);
            igraph_set_error_handler(errh);
            igraph_set_warning_handler(warnh);
            if (options->nconv < 1) {
                /* Call again from a fixed starting point. Note that we cannot use a
                 * fixed all-1 starting vector as sometimes ARPACK would return a
                 * 'starting vector is zero' error -- this is of course not true but
                 * it's a result of ARPACK >= 3.6.3 trying to force the starting vector
                 * into the range of OP (i.e. the matrix being solved). The initial
                 * vector we use here seems to work, but I have no theoretical argument
                 * for its usage; it just happens to work. */
                options->start = 1;
                options->info = 0;
                options->ncv = 0;
                options->lworkl = 0;    /* we surely have enough space */
                for (i = 0; i < options->n ; i++) {
                    storage.resid[i] = i % 2 ? 1 : -1;
                }
                IGRAPH_CHECK(igraph_arpack_rssolve(arpcb2, &extra, options, &storage,
                                                   /*values=*/ 0, /*vectors=*/ 0));
                options->start = 0;
            }
        }

        if (options->nconv < 1) {
            IGRAPH_ERROR("ARPACK did not converge", IGRAPH_ARPACK_FAILED);
        }

        tmpev = storage.d[0];

        /* Now we do the original eigenproblem, again, twice if needed */

        options->n = (int) size;
        options->info = 0;
        options->nev = 1;
        options->ldv = 0;
        options->nconv = 0;
        options->lworkl = 0;    /* we surely have enough space */
        options->ncv = 0;   /* 0 means "automatic" in igraph_arpack_rssolve */

        {
            int i;
            igraph_error_handler_t *errh =
                igraph_set_error_handler(igraph_i_error_handler_none);
            igraph_arpack_rssolve(arpcb1, &extra, options, &storage,
                                  /*values=*/ 0, /*vectors=*/ 0);
            igraph_set_error_handler(errh);
            if (options->nconv < 1) {
                /* Call again from a fixed starting point. See the comment a few lines
                 * above about the exact choice of this starting vector */
                options->start = 1;
                options->info = 0;
                options->ncv = 0;
                options->lworkl = 0;    /* we surely have enough space */
                for (i = 0; i < options->n; i++) {
                    storage.resid[i] = i % 2 ? 1 : -1;
                }
                IGRAPH_CHECK(igraph_arpack_rssolve(arpcb1, &extra, options, &storage,
                                                   /*values=*/ 0, /*vectors=*/ 0));
                options->start = 0;
            }
        }

        if (options->nconv < 1) {
            IGRAPH_ERROR("ARPACK did not converge", IGRAPH_ARPACK_FAILED);
        }

        /* Ok, we have the leading eigenvector of the modularity matrix*/

        /* ---------------------------------------------------------------*/
        /* To avoid numeric errors */
        if (fabs(storage.d[0]) < 1e-8) {
            storage.d[0] = 0;
        }

        /* We replace very small (in absolute value) elements of the
           leading eigenvector with zero, to get the same result,
           consistently.*/
        for (i = 0; i < size; i++) {
            if (fabs(storage.v[i]) < 1e-8) {
                storage.v[i] = 0;
            }
        }

        /* Just to have the always the same result, we multiply by -1
           if the first (nonzero) element is not positive. */
        for (i = 0; i < size; i++) {
            if (storage.v[i] != 0) {
                break;
            }
        }
        if (i < size && storage.v[i] < 0) {
            for (i = 0; i < size; i++) {
                storage.v[i] = - storage.v[i];
            }
        }
        /* ---------------------------------------------------------------*/

        if (callback) {
            igraph_vector_t vv;
            int ret;
            igraph_vector_view(&vv, storage.v, size);
            ret = callback(mymembership, comm, storage.d[0], &vv,
                           arpcb1, &extra, callback_extra);
            if (ret) {
                break;
            }
        }

        if (eigenvalues) {
            IGRAPH_CHECK(igraph_vector_push_back(eigenvalues, storage.d[0]));
        }

        if (eigenvectors) {
            igraph_vector_t *v = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!v) {
                IGRAPH_ERROR("Cannot do leading eigenvector community detection",
                             IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, v);
            IGRAPH_VECTOR_INIT_FINALLY(v, size);
            for (i = 0; i < size; i++) {
                VECTOR(*v)[i] = storage.v[i];
            }
            IGRAPH_CHECK(igraph_vector_ptr_push_back(eigenvectors, v));
            IGRAPH_FINALLY_CLEAN(2);
        }

        if (storage.d[0] <= 0) {
            IGRAPH_STATUS("no split.\n", 0);
            if (history) {
                IGRAPH_CHECK(igraph_vector_push_back(history,
                                                     IGRAPH_LEVC_HIST_FAILED));
                IGRAPH_CHECK(igraph_vector_push_back(history, comm));
            }
            continue;
        }

        /* Check for multiple leading eigenvalues */

        if (fabs(storage.d[0] - tmpev) < 1e-8) {
            IGRAPH_STATUS("multiple principal eigenvalue, no split.\n", 0);
            if (history) {
                IGRAPH_CHECK(igraph_vector_push_back(history,
                                                     IGRAPH_LEVC_HIST_FAILED));
                IGRAPH_CHECK(igraph_vector_push_back(history, comm));
            }
            continue;
        }

        /* Count the number of vertices in each community after the split */
        l = 0;
        for (j = 0; j < size; j++) {
            if (storage.v[j] < 0) {
                storage.v[j] = -1;
                l++;
            } else {
                storage.v[j] = 1;
            }
        }
        if (l == 0 || l == size) {
            IGRAPH_STATUS("no split.\n", 0);
            if (history) {
                IGRAPH_CHECK(igraph_vector_push_back(history,
                                                     IGRAPH_LEVC_HIST_FAILED));
                IGRAPH_CHECK(igraph_vector_push_back(history, comm));
            }
            continue;
        }

        /* Check that Q increases with our choice of split */
        arpcb1(storage.v + size, storage.v, (int) size, &extra);
        mod = 0;
        for (i = 0; i < size; i++) {
            mod += storage.v[size + i] * storage.v[i];
        }
        if (mod <= 1e-8) {
            IGRAPH_STATUS("no modularity increase, no split.\n", 0);
            if (history) {
                IGRAPH_CHECK(igraph_vector_push_back(history,
                                                     IGRAPH_LEVC_HIST_FAILED));
                IGRAPH_CHECK(igraph_vector_push_back(history, comm));
            }
            continue;
        }

        communities++;
        IGRAPH_STATUS("split.\n", 0);

        /* Rewrite the mymembership vector */
        for (j = 0; j < size; j++) {
            if (storage.v[j] < 0) {
                long int oldid = (long int) VECTOR(idx)[j];
                VECTOR(*mymembership)[oldid] = communities - 1;
            }
        }

        /* Record merge */
        IGRAPH_CHECK(igraph_vector_push_back(&mymerges, comm));
        IGRAPH_CHECK(igraph_vector_push_back(&mymerges, communities - 1));
        if (history) {
            IGRAPH_CHECK(igraph_vector_push_back(history, IGRAPH_LEVC_HIST_SPLIT));
            IGRAPH_CHECK(igraph_vector_push_back(history, comm));
        }

        /* Store the resulting communities in the queue if needed */
        if (l > 1) {
            IGRAPH_CHECK(igraph_dqueue_push(&tosplit, communities - 1));
        }
        if (size - l > 1) {
            IGRAPH_CHECK(igraph_dqueue_push(&tosplit, comm));
        }

    }

    igraph_arpack_storage_destroy(&storage);
    IGRAPH_FINALLY_CLEAN(1);
    if (!weights) {
        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        igraph_inclist_destroy(&inclist);
        igraph_vector_destroy(&strength);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_dqueue_destroy(&tosplit);
    igraph_vector_destroy(&tmp);
    igraph_vector_destroy(&idx2);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_STATUS("Done.\n", 0);

    /* reform the mymerges vector */
    if (merges) {
        igraph_vector_null(&idx);
        l = igraph_vector_size(&mymerges);
        k = communities;
        j = 0;
        IGRAPH_CHECK(igraph_matrix_resize(merges, l / 2, 2));
        for (i = l; i > 0; i -= 2) {
            long int from = (long int) VECTOR(mymerges)[i - 1];
            long int to = (long int) VECTOR(mymerges)[i - 2];
            MATRIX(*merges, j, 0) = VECTOR(mymerges)[i - 2];
            MATRIX(*merges, j, 1) = VECTOR(mymerges)[i - 1];
            if (VECTOR(idx)[from] != 0) {
                MATRIX(*merges, j, 1) = VECTOR(idx)[from] - 1;
            }
            if (VECTOR(idx)[to] != 0) {
                MATRIX(*merges, j, 0) = VECTOR(idx)[to] - 1;
            }
            VECTOR(idx)[to] = ++k;
            j++;
        }
    }

    if (eigenvectors) {
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_destroy(&idx);
    igraph_vector_destroy(&mymerges);
    IGRAPH_FINALLY_CLEAN(2);

    if (modularity) {
      IGRAPH_CHECK(igraph_modularity(graph, mymembership, weights,
                                    /* resolution */ 1,
                                    /* only undirected */ 0, modularity));
    }

    if (!membership) {
        igraph_vector_destroy(mymembership);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_le_community_to_membership
 * Vertex membership from the leading eigenvector community structure
 *
 * This function creates a membership vector from the
 * result of \ref igraph_community_leading_eigenvector(),
 * It takes \c membership
 * and performs \c steps merges, according to the supplied
 * \c merges matrix.
 * \param merges The two-column matrix containing the merge
 *    operations. See \ref igraph_community_walktrap() for the
 *    detailed syntax. This is usually from the output of the
 *    leading eigenvector community structure detection routines.
 * \param steps The number of steps to make according to \c merges.
 * \param membership Initially the starting membership vector,
 *     on output the resulting membership vector, after performing \c steps merges.
 * \param csize Optionally the sizes of the communities is stored here,
 *     if this is not a null pointer, but an initialized vector.
 * \return Error code.
 *
 * Time complexity: O(|V|), the number of vertices.
 */
int igraph_le_community_to_membership(const igraph_matrix_t *merges,
                                      igraph_integer_t steps,
                                      igraph_vector_t *membership,
                                      igraph_vector_t *csize) {

    long int no_of_nodes = igraph_vector_size(membership);
    igraph_vector_t fake_memb;
    long int components, i;

    if (no_of_nodes > 0) {
        components = (long int) igraph_vector_max(membership) + 1;
    } else {
        components = 0;
    }
    if (components > no_of_nodes) {
        IGRAPH_ERRORF("Invalid membership vector: number of components (%ld) must "
         "not be greater than the number of nodes (%ld).", IGRAPH_EINVAL, components, no_of_nodes);
    }
    if (steps >= components) {
        IGRAPH_ERRORF("Number of steps (%" IGRAPH_PRId ") must be smaller than number of components (%ld).",
                      IGRAPH_EINVAL, steps, components);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&fake_memb, components);

    /* Check membership vector */
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*membership)[i] < 0) {
            IGRAPH_ERRORF("Invalid membership vector, negative ID found: %g.", IGRAPH_EINVAL, VECTOR(*membership)[i]);
        }
        VECTOR(fake_memb)[ (long int) VECTOR(*membership)[i] ] += 1;
    }
    for (i = 0; i < components; i++) {
        if (VECTOR(fake_memb)[i] == 0) {
            /* Ideally the empty cluster's index would be reported.
               However, doing so would be confusing as some high-level interfaces
               use 1-based indexing, some 0-based. */
            IGRAPH_ERROR("Invalid membership vector, empty cluster found.", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_community_to_membership(merges, (igraph_integer_t)
                 components, steps,
                 &fake_memb, 0));

    /* Ok, now we have the membership of the initial components,
       rewrite the original membership vector. */

    if (csize) {
        IGRAPH_CHECK(igraph_vector_resize(csize, components - steps));
        igraph_vector_null(csize);
    }

    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(*membership)[i] = VECTOR(fake_memb)[ (long int) VECTOR(*membership)[i] ];
        if (csize) {
            VECTOR(*csize)[ (long int) VECTOR(*membership)[i] ] += 1;
        }
    }

    igraph_vector_destroy(&fake_memb);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/leiden.c0000644000175100001710000013226600000000000024103 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_stack.h"
#include "igraph_vector.h"
#include "igraph_constructors.h"

#include "core/interruption.h"

/* Move nodes in order to improve the quality of a partition.
 *
 * This function considers each node and greedily moves it to a neighboring
 * community that maximizes the improvement in the quality of a partition.
 *
 * The nodes are examined in a queue, and initially all nodes are put in the
 * queue in a random order. Nodes are popped from the queue when they are
 * examined, and only neighbors of nodes that are moved (which are not part of
 * the cluster the node was moved to) are pushed to the queue again.
 *
 * The \c membership vector is used as the starting point to move around nodes,
 * and is updated in-place.
 *
 */
static int igraph_i_community_leiden_fastmovenodes(
        const igraph_t *graph,
        const igraph_inclist_t *edges_per_node,
        const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
        const igraph_real_t resolution_parameter,
        igraph_integer_t *nb_clusters,
        igraph_vector_t *membership) {

    igraph_dqueue_t unstable_nodes;
    igraph_real_t max_diff = 0.0, diff = 0.0;
    igraph_integer_t n = igraph_vcount(graph);
    igraph_vector_bool_t neighbor_cluster_added, node_is_stable;
    igraph_vector_t node_order, cluster_weights, edge_weights_per_cluster, neighbor_clusters;
    igraph_vector_int_t nb_nodes_per_cluster;
    igraph_stack_t empty_clusters;
    long int i, j, c, nb_neigh_clusters;

    /* Initialize queue of unstable nodes and whether node is stable. Only
     * unstable nodes are in the queue. */
    IGRAPH_CHECK(igraph_vector_bool_init(&node_is_stable, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &node_is_stable);

    IGRAPH_CHECK(igraph_dqueue_init(&unstable_nodes, n));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &unstable_nodes);

    /* Shuffle nodes */
    IGRAPH_CHECK(igraph_vector_init_seq(&node_order, 0, n - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &node_order);
    IGRAPH_CHECK(igraph_vector_shuffle(&node_order));

    /* Add to the queue */
    for (i = 0; i < n; i++) {
        igraph_dqueue_push(&unstable_nodes, (long int)VECTOR(node_order)[i]);
    }

    /* Initialize cluster weights and nb nodes */
    IGRAPH_CHECK(igraph_vector_init(&cluster_weights, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &cluster_weights);
    IGRAPH_CHECK(igraph_vector_int_init(&nb_nodes_per_cluster, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &nb_nodes_per_cluster);
    for (i = 0; i < n; i++) {
        c = (long int)VECTOR(*membership)[i];
        VECTOR(cluster_weights)[c] += VECTOR(*node_weights)[i];
        VECTOR(nb_nodes_per_cluster)[c] += 1;
    }

    /* Initialize empty clusters */
    IGRAPH_CHECK(igraph_stack_init(&empty_clusters, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &empty_clusters);
    for (c = 0; c < n; c++)
        if (VECTOR(nb_nodes_per_cluster)[c] == 0) {
            igraph_stack_push(&empty_clusters, c);
        }

    /* Initialize vectors to be used in calculating differences */
    IGRAPH_CHECK(igraph_vector_init(&edge_weights_per_cluster, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &edge_weights_per_cluster);

    /* Initialize neighboring cluster */
    IGRAPH_CHECK(igraph_vector_bool_init(&neighbor_cluster_added, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &neighbor_cluster_added);
    IGRAPH_CHECK(igraph_vector_init(&neighbor_clusters, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &neighbor_clusters);

    /* Iterate while the queue is not empty */
    j = 0;
    while (!igraph_dqueue_empty(&unstable_nodes)) {
        long int v = (long int) igraph_dqueue_pop(&unstable_nodes);
        long int best_cluster, current_cluster = VECTOR(*membership)[v];
        long int degree, i;
        igraph_vector_int_t *edges;

        /* Remove node from current cluster */
        VECTOR(cluster_weights)[current_cluster] -= VECTOR(*node_weights)[v];
        VECTOR(nb_nodes_per_cluster)[current_cluster]--;
        if (VECTOR(nb_nodes_per_cluster)[current_cluster] == 0) {
            IGRAPH_CHECK(igraph_stack_push(&empty_clusters, current_cluster));
        }

        /* Find out neighboring clusters */
        c = (long int) igraph_stack_top(&empty_clusters);
        VECTOR(neighbor_clusters)[0] = c;
        VECTOR(neighbor_cluster_added)[c] = 1;
        nb_neigh_clusters = 1;

        /* Determine the edge weight to each neighboring cluster */
        edges = igraph_inclist_get(edges_per_node, v);
        degree = igraph_vector_int_size(edges);
        for (i = 0; i < degree; i++) {
            long int e = VECTOR(*edges)[i];
            long int u = (long int)IGRAPH_OTHER(graph, e, v);
            if (u != v) {
                c = VECTOR(*membership)[u];
                if (!VECTOR(neighbor_cluster_added)[c]) {
                    VECTOR(neighbor_cluster_added)[c] = 1;
                    VECTOR(neighbor_clusters)[nb_neigh_clusters++] = c;
                }
                VECTOR(edge_weights_per_cluster)[c] += VECTOR(*edge_weights)[e];
            }
        }

        /* Calculate maximum diff */
        best_cluster = current_cluster;
        max_diff = VECTOR(edge_weights_per_cluster)[current_cluster] - VECTOR(*node_weights)[v] * VECTOR(cluster_weights)[current_cluster] * resolution_parameter;
        for (i = 0; i < nb_neigh_clusters; i++) {
            c = VECTOR(neighbor_clusters)[i];
            diff = VECTOR(edge_weights_per_cluster)[c] - VECTOR(*node_weights)[v] * VECTOR(cluster_weights)[c] * resolution_parameter;
            if (diff > max_diff) {
                best_cluster = c;
                max_diff = diff;
            }
            VECTOR(edge_weights_per_cluster)[c] = 0.0;
            VECTOR(neighbor_cluster_added)[c] = 0;
        }

        /* Move node to best cluster */
        VECTOR(cluster_weights)[best_cluster] += VECTOR(*node_weights)[v];
        VECTOR(nb_nodes_per_cluster)[best_cluster]++;
        if (best_cluster == igraph_stack_top(&empty_clusters)) {
            igraph_stack_pop(&empty_clusters);
        }

        /* Mark node as stable */
        VECTOR(node_is_stable)[v] = 1;

        /* Add stable neighbours that are not part of the new cluster to the queue */
        if (best_cluster != current_cluster) {
            VECTOR(*membership)[v] = best_cluster;

            for (i = 0; i < degree; i++) {
                long int e = VECTOR(*edges)[i];
                long int u = (long int) IGRAPH_OTHER(graph, e, v);
                if (VECTOR(node_is_stable)[u] && VECTOR(*membership)[u] != best_cluster) {
                    IGRAPH_CHECK(igraph_dqueue_push(&unstable_nodes, u));
                    VECTOR(node_is_stable)[u] = 0;
                }
            }
        }

        j++;
        if (j > 10000) {
            IGRAPH_ALLOW_INTERRUPTION();
            j = 0;
        }
    }

    IGRAPH_CHECK(igraph_reindex_membership(membership, NULL, nb_clusters));

    igraph_vector_destroy(&neighbor_clusters);
    igraph_vector_bool_destroy(&neighbor_cluster_added);
    igraph_vector_destroy(&edge_weights_per_cluster);
    igraph_stack_destroy(&empty_clusters);
    igraph_vector_int_destroy(&nb_nodes_per_cluster);
    igraph_vector_destroy(&cluster_weights);
    igraph_vector_destroy(&node_order);
    igraph_dqueue_destroy(&unstable_nodes);
    igraph_vector_bool_destroy(&node_is_stable);

    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

/* Clean a refined membership vector.
 *
 * This function examines all nodes in \c node_subset and updates \c
 * refined_membership to ensure that the clusters are numbered consecutively,
 * starting from \c nb_refined_clusters. The \c nb_refined_clusters is also
 * updated itself. If C is the initial \c nb_refined_clusters and C' the
 * resulting \c nb_refined_clusters, then nodes in \c node_subset are numbered
 * C, C + 1, ..., C' - 1.
 */
static int igraph_i_community_leiden_clean_refined_membership(
        const igraph_vector_t* node_subset,
        igraph_vector_t *refined_membership,
        igraph_integer_t* nb_refined_clusters) {
    long int i, n = igraph_vector_size(node_subset);
    igraph_vector_t new_cluster;

    IGRAPH_CHECK(igraph_vector_init(&new_cluster, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &new_cluster);

    /* Clean clusters. We will store the new cluster + 1 so that cluster == 0
     * indicates that no membership was assigned yet. */
    *nb_refined_clusters += 1;
    for (i = 0; i < n; i++) {
        long int v = (long int) VECTOR(*node_subset)[i];
        long int c = (long int) VECTOR(*refined_membership)[v];
        if (VECTOR(new_cluster)[c] == 0) {
            VECTOR(new_cluster)[c] = (igraph_real_t)(*nb_refined_clusters);
            *nb_refined_clusters += 1;
        }
    }

    /* Assign new cluster */
    for (i = 0; i < n; i++) {
        long int v = (long int) VECTOR(*node_subset)[i];
        long int c = (long int) VECTOR(*refined_membership)[v];
        VECTOR(*refined_membership)[v] = VECTOR(new_cluster)[c] - 1;
    }
    /* We used the cluster + 1, so correct */
    *nb_refined_clusters -= 1;

    igraph_vector_destroy(&new_cluster);

    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* Merge nodes for a subset of the nodes. This is used to refine a partition.
 *
 * The nodes included in \c node_subset are assumed to be the nodes i for which
 * membership[i] = cluster_subset.
 *
 * All nodes in \c node_subset are initialized to a singleton partition in \c
 * refined_membership. Only singleton clusters can be merged if they are
 * sufficiently well connected to the current subgraph induced by \c
 * node_subset.
 *
 * We only examine each node once. Instead of greedily choosing the maximum
 * possible cluster to merge with, the cluster is chosen randomly among all
 * possibilities that do not decrease the quality of the partition. The
 * probability of choosing a certain cluster is proportional to exp(diff/beta).
 * For beta to 0 this converges to selecting a cluster with the maximum
 * improvement. For beta to infinity this converges to a uniform distribution
 * among all eligible clusters.
 *
 * The \c refined_membership is updated for node in \c node_subset. The number
 * of refined clusters, \c nb_refined_clusters is used to set the actual refined
 * cluster membership and is updated after this routine. Within each cluster
 * (i.e. for a given \c node_subset), the refined membership is initially simply
 * set to 0, ..., n - 1 (for n nodes in \c node_subset). However, for each \c
 * node_subset the refined membership should of course be unique. Hence, after
 * merging, the refined membership starts with \c nb_refined_clusters, which is
 * also updated to ensure that the resulting \c nb_refined_clusters counts all
 * refined clusters that have already been processed. See
 * igraph_i_community_leiden_clean_refined_membership for more information about
 * this aspect.
 */
static int igraph_i_community_leiden_mergenodes(
        const igraph_t *graph,
        const igraph_inclist_t *edges_per_node,
        const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
        const igraph_vector_t *node_subset,
        const igraph_vector_t *membership,
        const igraph_integer_t cluster_subset,
        const igraph_real_t resolution_parameter,
        const igraph_real_t beta,
        igraph_integer_t *nb_refined_clusters,
        igraph_vector_t *refined_membership) {
    igraph_vector_t node_order;
    igraph_vector_bool_t non_singleton_cluster, neighbor_cluster_added;
    igraph_real_t max_diff, total_cum_trans_diff, diff = 0.0, total_node_weight = 0.0;
    igraph_integer_t n = igraph_vector_size(node_subset);
    igraph_vector_t cluster_weights, cum_trans_diff, edge_weights_per_cluster, external_edge_weight_per_cluster_in_subset, neighbor_clusters;
    igraph_vector_int_t *edges, nb_nodes_per_cluster;
    long int i, j, degree, nb_neigh_clusters;

    /* Initialize cluster weights */
    IGRAPH_CHECK(igraph_vector_init(&cluster_weights, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &cluster_weights);

    /* Initialize number of nodes per cluster */
    IGRAPH_CHECK(igraph_vector_int_init(&nb_nodes_per_cluster, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &nb_nodes_per_cluster);

    /* Initialize external edge weight per cluster in subset */
    IGRAPH_CHECK(igraph_vector_init(&external_edge_weight_per_cluster_in_subset, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &external_edge_weight_per_cluster_in_subset);

    /* Initialize administration for a singleton partition */
    for (i = 0; i < n; i++) {
        long int v = (long int) VECTOR(*node_subset)[i];
        VECTOR(*refined_membership)[v] = i;
        VECTOR(cluster_weights)[i] += VECTOR(*node_weights)[v];
        VECTOR(nb_nodes_per_cluster)[i] += 1;
        total_node_weight += VECTOR(*node_weights)[v];

        /* Find out neighboring clusters */
        edges = igraph_inclist_get(edges_per_node, v);
        degree = igraph_vector_int_size(edges);
        for (j = 0; j < degree; j++) {
            long int e = VECTOR(*edges)[j];
            long int u = (long int)IGRAPH_OTHER(graph, e, v);
            if (u != v && VECTOR(*membership)[u] == cluster_subset) {
                VECTOR(external_edge_weight_per_cluster_in_subset)[i] += VECTOR(*edge_weights)[e];
            }
        }
    }

    /* Shuffle nodes */
    IGRAPH_CHECK(igraph_vector_copy(&node_order, node_subset));
    IGRAPH_FINALLY(igraph_vector_destroy, &node_order);
    IGRAPH_CHECK(igraph_vector_shuffle(&node_order));

    /* Initialize non singleton clusters */
    IGRAPH_CHECK(igraph_vector_bool_init(&non_singleton_cluster, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &non_singleton_cluster);

    /* Initialize vectors to be used in calculating differences */
    IGRAPH_CHECK(igraph_vector_init(&edge_weights_per_cluster, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &edge_weights_per_cluster);

    /* Initialize neighboring cluster */
    IGRAPH_CHECK(igraph_vector_bool_init(&neighbor_cluster_added, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &neighbor_cluster_added);
    IGRAPH_CHECK(igraph_vector_init(&neighbor_clusters, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &neighbor_clusters);

    /* Initialize cumulative transformed difference */
    IGRAPH_CHECK(igraph_vector_init(&cum_trans_diff, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &cum_trans_diff);

    RNG_BEGIN();

    for (i = 0; i < n; i++) {
        long int v = (long int) VECTOR(node_order)[i];
        long int chosen_cluster, best_cluster, current_cluster = (long int) VECTOR(*refined_membership)[v];

        if (!VECTOR(non_singleton_cluster)[current_cluster] &&
            (VECTOR(external_edge_weight_per_cluster_in_subset)[current_cluster] >=
             VECTOR(cluster_weights)[current_cluster] * (total_node_weight - VECTOR(cluster_weights)[current_cluster]) * resolution_parameter)) {
            /* Remove node from current cluster, which is then a singleton by
             * definition. */
            VECTOR(cluster_weights)[current_cluster] = 0.0;
            VECTOR(nb_nodes_per_cluster)[current_cluster] = 0;

            /* Find out neighboring clusters */
            edges = igraph_inclist_get(edges_per_node, v);
            degree = igraph_vector_int_size(edges);

            /* Also add current cluster to ensure it can be chosen. */
            VECTOR(neighbor_clusters)[0] = current_cluster;
            VECTOR(neighbor_cluster_added)[current_cluster] = 1;
            nb_neigh_clusters = 1;
            for (j = 0; j < degree; j++) {
                long int e = (long int)VECTOR(*edges)[j];
                long int u = (long int)IGRAPH_OTHER(graph, e, v);
                if (u != v && VECTOR(*membership)[u] == cluster_subset) {
                    long int c = VECTOR(*refined_membership)[u];
                    if (!VECTOR(neighbor_cluster_added)[c]) {
                        VECTOR(neighbor_cluster_added)[c] = 1;
                        VECTOR(neighbor_clusters)[nb_neigh_clusters++] = c;
                    }
                    VECTOR(edge_weights_per_cluster)[c] += VECTOR(*edge_weights)[e];
                }
            }

            /* Calculate diffs */
            best_cluster = current_cluster;
            max_diff = 0.0;
            total_cum_trans_diff = 0.0;
            for (j = 0; j < nb_neigh_clusters; j++) {
                long int c = (long int) VECTOR(neighbor_clusters)[j];
                if (VECTOR(external_edge_weight_per_cluster_in_subset)[c] >= VECTOR(cluster_weights)[c] * (total_node_weight - VECTOR(cluster_weights)[c]) * resolution_parameter) {
                    diff = VECTOR(edge_weights_per_cluster)[c] - VECTOR(*node_weights)[v] * VECTOR(cluster_weights)[c] * resolution_parameter;

                    if (diff > max_diff) {
                        best_cluster = c;
                        max_diff = diff;
                    }

                    /* Calculate the transformed difference for sampling */
                    if (diff >= 0) {
                        total_cum_trans_diff += exp(diff / beta);
                    }

                }

                VECTOR(cum_trans_diff)[j] = total_cum_trans_diff;
                VECTOR(edge_weights_per_cluster)[c] = 0.0;
                VECTOR(neighbor_cluster_added)[c] = 0;
            }

            /* Determine the neighboring cluster to which the currently selected node
             * will be moved.
             */
            if (total_cum_trans_diff < IGRAPH_INFINITY) {
                igraph_real_t r = RNG_UNIF(0, total_cum_trans_diff);
                long int chosen_idx;
                igraph_vector_binsearch_slice(&cum_trans_diff, r, &chosen_idx, 0, nb_neigh_clusters);
                chosen_cluster = VECTOR(neighbor_clusters)[chosen_idx];
            } else {
                chosen_cluster = best_cluster;
            }

            /* Move node to randomly chosen cluster */
            VECTOR(cluster_weights)[chosen_cluster] += VECTOR(*node_weights)[v];
            VECTOR(nb_nodes_per_cluster)[chosen_cluster]++;

            for (j = 0; j < degree; j++) {
                long int e = (long int) VECTOR(*edges)[j];
                long int u = (long int) IGRAPH_OTHER(graph, e, v);
                if (VECTOR(*membership)[u] == cluster_subset) {
                    if (VECTOR(*refined_membership)[u] == chosen_cluster) {
                        VECTOR(external_edge_weight_per_cluster_in_subset)[chosen_cluster] -= VECTOR(*edge_weights)[e];
                    } else {
                        VECTOR(external_edge_weight_per_cluster_in_subset)[chosen_cluster] += VECTOR(*edge_weights)[e];
                    }
                }
            }

            /* Set cluster  */
            if (chosen_cluster != current_cluster) {
                VECTOR(*refined_membership)[v] = chosen_cluster;

                VECTOR(non_singleton_cluster)[chosen_cluster] = 1;
            }
        } /* end if singleton and may be merged */
    }

    RNG_END();

    IGRAPH_CHECK(igraph_i_community_leiden_clean_refined_membership(node_subset, refined_membership, nb_refined_clusters));

    igraph_vector_destroy(&cum_trans_diff);
    igraph_vector_destroy(&neighbor_clusters);
    igraph_vector_bool_destroy(&neighbor_cluster_added);
    igraph_vector_destroy(&edge_weights_per_cluster);
    igraph_vector_bool_destroy(&non_singleton_cluster);
    igraph_vector_destroy(&node_order);
    igraph_vector_destroy(&external_edge_weight_per_cluster_in_subset);
    igraph_vector_int_destroy(&nb_nodes_per_cluster);
    igraph_vector_destroy(&cluster_weights);

    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

/* Create clusters out of a membership vector.
 *
 * The cluster pointer vector should be initialized for all entries of the
 * membership vector, no range checking is performed. If a vector for a cluster
 * does not yet exist it will be created and initialized. If a vector for a
 * cluster already does exist it will not be emptied on first use. Hence, it
 * should be ensured that all clusters are always properly empty (or
 * non-existing) before calling this function.
 */
static int igraph_i_community_get_clusters(const igraph_vector_t *membership, igraph_vector_ptr_t *clusters) {
    long int i, c, n = igraph_vector_size(membership);
    igraph_vector_t *cluster;
    for (i = 0; i < n; i++) {
        /* Get cluster for node i */
        c = VECTOR(*membership)[i];
        cluster = (igraph_vector_t*)VECTOR(*clusters)[c];

        /* No cluster vector exists yet, so we create a new one */
        if (!cluster) {
            cluster = IGRAPH_CALLOC(1, igraph_vector_t);
            if (cluster == 0) {
                IGRAPH_ERROR("Cannot allocate memory for assigning cluster", IGRAPH_ENOMEM);
            }
            IGRAPH_CHECK(igraph_vector_init(cluster, 0));
            VECTOR(*clusters)[c] = cluster;
        }

        /* Add node i to cluster vector */
        IGRAPH_CHECK(igraph_vector_push_back(cluster, i));
    }

    return IGRAPH_SUCCESS;
}

/* Aggregate the graph based on the \c refined membership while setting the
 * membership of each aggregated node according to the \c membership.
 *
 * Technically speaking we have that
 * aggregated_membership[refined_membership[v]] = membership[v] for each node v.
 *
 * The new aggregated graph is returned in \c aggregated_graph. This graph
 * object should not yet be initialized, `igraph_create` is called on it, and
 * responsibility for destroying the object lies with the calling method
 *
 * The remaining results, aggregated_edge_weights, aggregate_node_weights and
 * aggregated_membership are all expected to be initialized.
 *
 */
static int igraph_i_community_leiden_aggregate(
    const igraph_t *graph, const igraph_inclist_t *edges_per_node, const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
    const igraph_vector_t *membership, const igraph_vector_t *refined_membership, const igraph_integer_t nb_refined_clusters,
    igraph_t *aggregated_graph, igraph_vector_t *aggregated_edge_weights, igraph_vector_t *aggregated_node_weights, igraph_vector_t *aggregated_membership) {
    igraph_vector_t aggregated_edges, edge_weight_to_cluster;
    igraph_vector_ptr_t refined_clusters;
    igraph_vector_int_t *incident_edges;
    igraph_vector_t neighbor_clusters;
    igraph_vector_bool_t neighbor_cluster_added;
    long int i, j, c, degree, nb_neigh_clusters;

    /* Get refined clusters */
    IGRAPH_CHECK(igraph_vector_ptr_init(&refined_clusters, nb_refined_clusters));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&refined_clusters, igraph_vector_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &refined_clusters);
    IGRAPH_CHECK(igraph_i_community_get_clusters(refined_membership, &refined_clusters));

    /* Initialize new edges */
    IGRAPH_CHECK(igraph_vector_init(&aggregated_edges, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &aggregated_edges);

    /* We clear the aggregated edge weights, we will push each new edge weight */
    igraph_vector_clear(aggregated_edge_weights);
    /* Simply resize the aggregated node weights and membership, they can be set
     * directly */
    IGRAPH_CHECK(igraph_vector_resize(aggregated_node_weights, nb_refined_clusters));
    IGRAPH_CHECK(igraph_vector_resize(aggregated_membership, nb_refined_clusters));

    IGRAPH_CHECK(igraph_vector_init(&edge_weight_to_cluster, nb_refined_clusters));
    IGRAPH_FINALLY(igraph_vector_destroy, &edge_weight_to_cluster);

    /* Initialize neighboring cluster */
    IGRAPH_CHECK(igraph_vector_bool_init(&neighbor_cluster_added, nb_refined_clusters));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &neighbor_cluster_added);
    IGRAPH_CHECK(igraph_vector_init(&neighbor_clusters, nb_refined_clusters));
    IGRAPH_FINALLY(igraph_vector_destroy, &neighbor_clusters);

    /* Check per cluster */
    for (c = 0; c < nb_refined_clusters; c++) {
        igraph_vector_t* refined_cluster = (igraph_vector_t*)VECTOR(refined_clusters)[c];
        long int n_c = igraph_vector_size(refined_cluster);
        long int v = -1;

        /* Calculate the total edge weight to other clusters */
        VECTOR(*aggregated_node_weights)[c] = 0.0;
        nb_neigh_clusters = 0;
        for (i = 0; i < n_c; i++) {
            v = (long int) VECTOR(*refined_cluster)[i];
            incident_edges = igraph_inclist_get(edges_per_node, v);
            degree = igraph_vector_int_size(incident_edges);

            for (j = 0; j < degree; j++) {
                long int e = VECTOR(*incident_edges)[j];
                long int u = (long int) IGRAPH_OTHER(graph, e, v);
                long int c2 = VECTOR(*refined_membership)[u];

                if (c2 > c) {
                    if (!VECTOR(neighbor_cluster_added)[c2]) {
                        VECTOR(neighbor_cluster_added)[c2] = 1;
                        VECTOR(neighbor_clusters)[nb_neigh_clusters++] = c2;
                    }
                    VECTOR(edge_weight_to_cluster)[c2] += VECTOR(*edge_weights)[e];
                }
            }

            VECTOR(*aggregated_node_weights)[c] += VECTOR(*node_weights)[v];
        }

        /* Add actual edges from this cluster to the other clusters */
        for (i = 0; i < nb_neigh_clusters; i++) {
            long int c2 = VECTOR(neighbor_clusters)[i];

            /* Add edge */
            IGRAPH_CHECK(igraph_vector_push_back(&aggregated_edges, c));
            IGRAPH_CHECK(igraph_vector_push_back(&aggregated_edges, c2));

            /* Add edge weight */
            IGRAPH_CHECK(igraph_vector_push_back(aggregated_edge_weights, VECTOR(edge_weight_to_cluster)[c2]));

            VECTOR(edge_weight_to_cluster)[c2] = 0.0;
            VECTOR(neighbor_cluster_added)[c2] = 0;
        }

        VECTOR(*aggregated_membership)[c] = VECTOR(*membership)[v];

    }

    igraph_vector_destroy(&neighbor_clusters);
    igraph_vector_bool_destroy(&neighbor_cluster_added);
    igraph_vector_destroy(&edge_weight_to_cluster);
    igraph_vector_ptr_destroy_all(&refined_clusters);

    IGRAPH_FINALLY_CLEAN(4);

    igraph_destroy(aggregated_graph);
    IGRAPH_CHECK(igraph_create(aggregated_graph, &aggregated_edges, nb_refined_clusters,
                               IGRAPH_UNDIRECTED));

    igraph_vector_destroy(&aggregated_edges);

    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* Calculate the quality of the partition.
 *
 * The quality is defined as
 *
 * 1 / 2m sum_ij (A_ij - gamma n_i n_j)d(s_i, s_j)
 *
 * where m is the total edge weight, A_ij is the weight of edge (i, j), gamma is
 * the so-called resolution parameter, n_i is the node weight of node i, s_i is
 * the cluster of node i and d(x, y) = 1 if and only if x = y and 0 otherwise.
 *
 * Note that by setting n_i = k_i the degree of node i and dividing gamma by 2m,
 * we effectively optimize modularity. By setting n_i = 1 we optimize the
 * Constant Potts Model.
 *
 * This can be represented as a sum over clusters as
 *
 * 1 / 2m sum_c (e_c - gamma N_c^2)
 *
 * where e_c = sum_ij A_ij d(s_i, c)d(s_j, c) is (twice) the internal edge
 * weight in cluster c and N_c = sum_i n_i d(s_i, c) is the sum of the node
 * weights inside cluster c. This is how the quality is calculated in practice.
 *
 */
static int igraph_i_community_leiden_quality(
        const igraph_t *graph, const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
        const igraph_vector_t *membership, const igraph_integer_t nb_comms, const igraph_real_t resolution_parameter,
        igraph_real_t *quality) {
    igraph_vector_t cluster_weights;
    igraph_real_t total_edge_weight = 0.0;
    igraph_eit_t eit;
    long int i, c, n = igraph_vcount(graph);;

    *quality = 0.0;

    /* Create the edgelist */
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    while (!IGRAPH_EIT_END(eit)) {
        igraph_integer_t e = IGRAPH_EIT_GET(eit), from, to;
        IGRAPH_CHECK(igraph_edge(graph, e, &from, &to));
        total_edge_weight += VECTOR(*edge_weights)[e];
        /* We add the internal edge weights */
        if (VECTOR(*membership)[(long int) from] == VECTOR(*membership)[(long int) to]) {
            *quality += 2 * VECTOR(*edge_weights)[e];
        }
        IGRAPH_EIT_NEXT(eit);
    }
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    /* Initialize cluster weights and nb nodes */
    IGRAPH_CHECK(igraph_vector_init(&cluster_weights, n));
    IGRAPH_FINALLY(igraph_vector_destroy, &cluster_weights);
    for (i = 0; i < n; i++) {
        c = VECTOR(*membership)[i];
        VECTOR(cluster_weights)[c] += VECTOR(*node_weights)[i];
    }

    /* We subtract gamma * N_c^2 */
    for (c = 0; c < nb_comms; c++) {
        *quality -= resolution_parameter * VECTOR(cluster_weights)[c] * VECTOR(cluster_weights)[c];
    }

    igraph_vector_destroy(&cluster_weights);
    IGRAPH_FINALLY_CLEAN(1);

    /* We normalise by 2m */
    *quality /= (2.0 * total_edge_weight);

    return IGRAPH_SUCCESS;
}

/* This is the core of the Leiden algorithm and relies on subroutines to
 * perform the three different phases: (1) local moving of nodes, (2)
 * refinement of the partition and (3) aggregation of the network based on the
 * refined partition, using the non-refined partition to create an initial
 * partition for the aggregate network.
 */
static int igraph_i_community_leiden(
        const igraph_t *graph,
        igraph_vector_t *edge_weights, igraph_vector_t *node_weights,
        const igraph_real_t resolution_parameter, const igraph_real_t beta,
        igraph_vector_t *membership, igraph_integer_t *nb_clusters, igraph_real_t *quality) {
    igraph_integer_t nb_refined_clusters;
    long int i, c, n = igraph_vcount(graph);
    igraph_t aggregated_graph, *i_graph;
    igraph_vector_t aggregated_edge_weights, aggregated_node_weights, aggregated_membership;
    igraph_vector_t *i_edge_weights, *i_node_weights, *i_membership;
    igraph_vector_t tmp_edge_weights, tmp_node_weights, tmp_membership;
    igraph_vector_t refined_membership;
    igraph_vector_int_t aggregate_node;
    igraph_vector_ptr_t clusters;
    igraph_inclist_t edges_per_node;
    igraph_bool_t continue_clustering;
    igraph_integer_t level = 0;

    /* Initialize temporary weights and membership to be used in aggregation */
    IGRAPH_CHECK(igraph_vector_init(&tmp_edge_weights, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp_edge_weights);
    IGRAPH_CHECK(igraph_vector_init(&tmp_node_weights, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp_node_weights);
    IGRAPH_CHECK(igraph_vector_init(&tmp_membership, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp_membership);

    /* Initialize clusters */
    IGRAPH_CHECK(igraph_vector_ptr_init(&clusters, n));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&clusters, igraph_vector_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &clusters);

    /* Initialize aggregate nodes, which initially is identical to simply the
     * nodes in the graph. */
    IGRAPH_CHECK(igraph_vector_int_init(&aggregate_node, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &aggregate_node);
    for (i = 0; i < n; i++) {
        VECTOR(aggregate_node)[i] = i;
    }

    /* Initialize refined membership */
    IGRAPH_CHECK(igraph_vector_init(&refined_membership, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &refined_membership);

    /* Initialize aggregated graph */
    IGRAPH_CHECK(igraph_empty(&aggregated_graph, 0, IGRAPH_UNDIRECTED));
    IGRAPH_FINALLY(igraph_destroy, &aggregated_graph);

    /* Initialize aggregated edge weights */
    IGRAPH_CHECK(igraph_vector_init(&aggregated_edge_weights, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &aggregated_edge_weights);

    /* Initialize aggregated node weights */
    IGRAPH_CHECK(igraph_vector_init(&aggregated_node_weights, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &aggregated_node_weights);

    /* Initialize aggregated membership */
    IGRAPH_CHECK(igraph_vector_init(&aggregated_membership, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &aggregated_membership);

    /* Set actual graph, weights and membership to be used. */
    i_graph = (igraph_t*)graph;
    i_edge_weights = edge_weights;
    i_node_weights = node_weights;
    i_membership = membership;

    /* Clean membership and count number of *clusters */

    IGRAPH_CHECK(igraph_reindex_membership(i_membership, NULL, nb_clusters));

    if (*nb_clusters > n) {
        IGRAPH_ERROR("Too many communities in membership vector", IGRAPH_EINVAL);
    }

    do {

        /* Get incidence list for fast iteration */
        IGRAPH_CHECK(igraph_inclist_init( i_graph, &edges_per_node, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &edges_per_node);

        /* Move around the nodes in order to increase the quality */
        IGRAPH_CHECK(igraph_i_community_leiden_fastmovenodes(i_graph,
                     &edges_per_node,
                     i_edge_weights, i_node_weights,
                     resolution_parameter,
                     nb_clusters,
                     i_membership));

        /* We only continue clustering if not all clusters are represented by a
         * single node yet
         */
        continue_clustering = (*nb_clusters < igraph_vcount(i_graph));

        if (continue_clustering) {
            /* Set original membership */
            if (level > 0) {
                for (i = 0; i < n; i++) {
                    long int v_aggregate = VECTOR(aggregate_node)[i];
                    VECTOR(*membership)[i] = VECTOR(*i_membership)[v_aggregate];
                }
            }

            /* Get node sets for each cluster. */
            IGRAPH_CHECK(igraph_i_community_get_clusters(i_membership, &clusters));

            /* Ensure refined membership is correct size */
            IGRAPH_CHECK(igraph_vector_resize(&refined_membership, igraph_vcount(i_graph)));

            /* Refine each cluster */
            nb_refined_clusters = 0;
            for (c = 0; c < *nb_clusters; c++) {
                igraph_vector_t* cluster = (igraph_vector_t*)VECTOR(clusters)[c];
                IGRAPH_CHECK(igraph_i_community_leiden_mergenodes(i_graph,
                             &edges_per_node,
                             i_edge_weights, i_node_weights,
                             cluster, i_membership, c,
                             resolution_parameter, beta,
                             &nb_refined_clusters, &refined_membership));
                /* Empty cluster */
                igraph_vector_clear(cluster);
            }

            /* If refinement didn't aggregate anything, we aggregate on the basis of
             * the actual clustering */
            if (nb_refined_clusters >= igraph_vcount(i_graph)) {
                igraph_vector_update(&refined_membership, i_membership);
                nb_refined_clusters = *nb_clusters;
            }

            /* Keep track of aggregate node. */
            for (i = 0; i < n; i++) {
                /* Current aggregate node */
                igraph_integer_t v_aggregate = VECTOR(aggregate_node)[i];
                /* New aggregate node */
                VECTOR(aggregate_node)[i] = (igraph_integer_t)VECTOR(refined_membership)[v_aggregate];
            }

            IGRAPH_CHECK(igraph_i_community_leiden_aggregate(
                             i_graph, &edges_per_node, i_edge_weights, i_node_weights,
                             i_membership, &refined_membership, nb_refined_clusters,
                             &aggregated_graph, &tmp_edge_weights, &tmp_node_weights, &tmp_membership));

            /* On the lowest level, the actual graph and node and edge weights and
             * membership are used. On higher levels, we will use the aggregated graph
             * and associated vectors.
             */
            if (level == 0) {
                /* Set actual graph, weights and membership to be used. */
                i_graph = &aggregated_graph;
                i_edge_weights = &aggregated_edge_weights;
                i_node_weights = &aggregated_node_weights;
                i_membership = &aggregated_membership;
            }

            /* Update the aggregated administration. */
            IGRAPH_CHECK(igraph_vector_update(i_edge_weights, &tmp_edge_weights));
            IGRAPH_CHECK(igraph_vector_update(i_node_weights, &tmp_node_weights));
            IGRAPH_CHECK(igraph_vector_update(i_membership, &tmp_membership));

            level += 1;
        }

        /* We are done iterating, so we destroy the incidence list */
        igraph_inclist_destroy(&edges_per_node);
        IGRAPH_FINALLY_CLEAN(1);
    } while (continue_clustering);

    /* Free aggregated graph and associated vectors */
    igraph_vector_destroy(&aggregated_membership);
    igraph_vector_destroy(&aggregated_node_weights);
    igraph_vector_destroy(&aggregated_edge_weights);
    igraph_destroy(&aggregated_graph);
    IGRAPH_FINALLY_CLEAN(4);

    /* Free remaining memory */
    igraph_vector_destroy(&refined_membership);
    igraph_vector_int_destroy(&aggregate_node);
    igraph_vector_ptr_destroy_all(&clusters);
    igraph_vector_destroy(&tmp_membership);
    igraph_vector_destroy(&tmp_node_weights);
    igraph_vector_destroy(&tmp_edge_weights);
    IGRAPH_FINALLY_CLEAN(6);

    /* Calculate quality */
    if (quality) {
        IGRAPH_CHECK(igraph_i_community_leiden_quality(graph, edge_weights, node_weights, membership, *nb_clusters, resolution_parameter, quality));
    }

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup communities
 * \function igraph_community_leiden
 * \brief Finding community structure using the Leiden algorithm.
 *
 * This function implements the Leiden algorithm for finding community
 * structure, see Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From
 * Louvain to Leiden: guaranteeing well-connected communities. Scientific
 * reports, 9(1), 5233. http://dx.doi.org/10.1038/s41598-019-41695-z
 *
 * 
 * It is similar to the multilevel algorithm, often called the Louvain
 * algorithm, but it is faster and yields higher quality solutions. It can
 * optimize both modularity and the Constant Potts Model, which does not suffer
 * from the resolution-limit (see preprint http://arxiv.org/abs/1104.3083).
 *
 * 
 * The Leiden algorithm consists of three phases: (1) local moving of nodes,
 * (2) refinement of the partition and (3) aggregation of the network based on
 * the refined partition, using the non-refined partition to create an initial
 * partition for the aggregate network. In the local move procedure in the
 * Leiden algorithm, only nodes whose neighborhood has changed are visited. The
 * refinement is done by restarting from a singleton partition within each
 * cluster and gradually merging the subclusters. When aggregating, a single
 * cluster may then be represented by several nodes (which are the subclusters
 * identified in the refinement).
 *
 * 
 * The Leiden algorithm provides several guarantees. The Leiden algorithm is
 * typically iterated: the output of one iteration is used as the input for the
 * next iteration. At each iteration all clusters are guaranteed to be
 * connected and well-separated. After an iteration in which nothing has
 * changed, all nodes and some parts are guaranteed to be locally optimally
 * assigned. Finally, asymptotically, all subsets of all clusters are
 * guaranteed to be locally optimally assigned. For more details, please see
 * Traag, Waltman & van Eck (2019).
 *
 * 
 * The objective function being optimized is
 *
 * 
 * 1 / 2m sum_ij (A_ij - gamma n_i n_j)d(s_i, s_j)
 *
 * 
 * where m is the total edge weight, A_ij is the weight of edge (i, j), gamma is
 * the so-called resolution parameter, n_i is the node weight of node i, s_i is
 * the cluster of node i and d(x, y) = 1 if and only if x = y and 0 otherwise.
 * By setting n_i = k_i, the degree of node i, and dividing gamma by 2m, you
 * effectively obtain an expression for modularity. Hence, the standard
 * modularity will be optimized when you supply the degrees as \c node_weights
 * and by supplying as a resolution parameter 1.0/(2*m), with m the number of
 * edges.
 *
 * \param graph The input graph. It must be an undirected graph.
 * \param edge_weights Numeric vector containing edge weights. If \c NULL, every edge
 *    has equal weight of 1. The weights need not be non-negative.
 * \param node_weights Numeric vector containing node weights.
 * \param resolution_parameter The resolution parameter used, which is
 *    represented by gamma in the objective function mentioned in the
 *    documentation.
 * \param beta The randomness used in the refinement step when merging. A small
 *    amount of randomness (\c beta = 0.01) typically works well.
 * \param start Start from membership vector. If this is true, the optimization
 *    will start from the provided membership vector. If this is false, the
 *    optimization will start from a singleton partition.
 * \param membership The membership vector. This is both used as the initial
 *    membership from which optimisation starts and is updated in place. It
 *    must hence be properly initialized. When finding clusters from scratch it
 *    is typically started using a singleton clustering. This can be achieved
 *    using \c igraph_vector_init_seq.
 * \param nb_clusters The number of clusters contained in \c membership. Must
 *    not be a \c NULL pointer.
 * \param quality The quality of the partition, in terms of the objective
 *    function as included in the documentation. If \c NULL the quality will
 *    not be calculated.
 * \return Error code.
 *
 * Time complexity: near linear on sparse graphs.
 *
 * \example examples/simple/igraph_community_leiden.c
 */
int igraph_community_leiden(const igraph_t *graph,
                            const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
                            const igraph_real_t resolution_parameter, const igraph_real_t beta, const igraph_bool_t start,
                            igraph_vector_t *membership, igraph_integer_t *nb_clusters, igraph_real_t *quality) {
    igraph_vector_t *i_edge_weights, *i_node_weights;
    igraph_integer_t n = igraph_vcount(graph);

    if (start) {
        if (!membership) {
            IGRAPH_ERROR("Cannot start optimization if membership is missing", IGRAPH_EINVAL);
        }

        if (igraph_vector_size(membership) != n) {
            IGRAPH_ERROR("Initial membership length does not equal the number of vertices", IGRAPH_EINVAL);
        }
    } else {
        int i;
        if (!membership)
            IGRAPH_ERROR("Membership vector should be supplied and initialized, "
                         "even when not starting optimization from it", IGRAPH_EINVAL);

        igraph_vector_resize(membership, n);
        for (i = 0; i < n; i++) {
            VECTOR(*membership)[i] = i;
        }
    }


    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Leiden algorithm is only implemented for undirected graphs", IGRAPH_EINVAL);
    }

    /* Check edge weights to possibly use default */
    if (!edge_weights) {
        i_edge_weights = IGRAPH_CALLOC(1, igraph_vector_t);
        if (i_edge_weights == 0) {
            IGRAPH_ERROR("Leiden algorithm failed, could not allocate memory for edge weights", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, i_edge_weights);
        IGRAPH_CHECK(igraph_vector_init(i_edge_weights, igraph_ecount(graph)));
        IGRAPH_FINALLY(igraph_vector_destroy, i_edge_weights);
        igraph_vector_fill(i_edge_weights, 1);
    } else {
        i_edge_weights = (igraph_vector_t*)edge_weights;
    }

    /* Check edge weights to possibly use default */
    if (!node_weights) {
        i_node_weights = IGRAPH_CALLOC(1, igraph_vector_t);
        if (i_node_weights == 0) {
            IGRAPH_ERROR("Leiden algorithm failed, could not allocate memory for node weights", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, i_node_weights);
        IGRAPH_CHECK(igraph_vector_init(i_node_weights, n));
        IGRAPH_FINALLY(igraph_vector_destroy, i_node_weights);
        igraph_vector_fill(i_node_weights, 1);
    } else {
        i_node_weights = (igraph_vector_t*)node_weights;
    }

    /* Perform actual Leiden algorithm */
    IGRAPH_CHECK(igraph_i_community_leiden(graph, i_edge_weights, i_node_weights,
                                           resolution_parameter, beta,
                                           membership, nb_clusters, quality));

    if (!edge_weights) {
        igraph_vector_destroy(i_edge_weights);
        IGRAPH_FREE(i_edge_weights);
        IGRAPH_FINALLY_CLEAN(2);
    }

    if (!node_weights) {
        igraph_vector_destroy(i_node_weights);
        IGRAPH_FREE(i_node_weights);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/louvain.c0000644000175100001710000006721500000000000024321 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_qsort.h"
#include "igraph_random.h"

#include "core/interruption.h"

/* Structure storing a community */
typedef struct {
    igraph_integer_t size;           /* Size of the community */
    igraph_real_t weight_inside;     /* Sum of edge weights inside community */
    igraph_real_t weight_all;        /* Sum of edge weights starting/ending
                                      in the community */
} igraph_i_multilevel_community;

/* Global community list structure */
typedef struct {
    long int communities_no, vertices_no;  /* Number of communities, number of vertices */
    igraph_real_t weight_sum;              /* Sum of edges weight in the whole graph */
    igraph_i_multilevel_community *item;   /* List of communities */
    igraph_vector_t *membership;           /* Community IDs */
    igraph_vector_t *weights;        /* Graph edge weights */
} igraph_i_multilevel_community_list;

/* Computes the modularity of a community partitioning */
static igraph_real_t igraph_i_multilevel_community_modularity(
                                                              const igraph_i_multilevel_community_list *communities,
                                                              const igraph_real_t resolution) {
    igraph_real_t result = 0;
    long int i;
    igraph_real_t m = communities->weight_sum;

    for (i = 0; i < communities->vertices_no; i++) {
        if (communities->item[i].size > 0) {
            result += (communities->item[i].weight_inside - resolution * communities->item[i].weight_all * communities->item[i].weight_all / m) / m;
        }
    }

    return result;
}

typedef struct {
    long int from;
    long int to;
    long int id;
} igraph_i_multilevel_link;

static int igraph_i_multilevel_link_cmp(const void *a, const void *b) {
    long int r = (((igraph_i_multilevel_link*)a)->from -
                  ((igraph_i_multilevel_link*)b)->from);
    if (r != 0) {
        return (int) r;
    }

    return (int) (((igraph_i_multilevel_link*)a)->to -
                  ((igraph_i_multilevel_link*)b)->to);
}

/* removes multiple edges and returns new edge id's for each edge in |E|log|E| */
static int igraph_i_multilevel_simplify_multiple(igraph_t *graph, igraph_vector_t *eids) {
    long int ecount = igraph_ecount(graph);
    long int i, l = -1, last_from = -1, last_to = -1;
    igraph_bool_t directed = igraph_is_directed(graph);
    igraph_vector_t edges;
    igraph_i_multilevel_link *links;

    /* Make sure there's enough space in eids to store the new edge IDs */
    IGRAPH_CHECK(igraph_vector_resize(eids, ecount));

    links = IGRAPH_CALLOC(ecount, igraph_i_multilevel_link);
    if (links == 0) {
        IGRAPH_ERROR("multi-level community structure detection failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, links);

    for (i = 0; i < ecount; i++) {
        igraph_integer_t from, to;
        igraph_edge(graph, (igraph_integer_t) i, &from, &to);
        links[i].from = from;
        links[i].to = to;
        links[i].id = i;
    }

    igraph_qsort((void*)links, (size_t) ecount, sizeof(igraph_i_multilevel_link),
                 igraph_i_multilevel_link_cmp);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    for (i = 0; i < ecount; i++) {
        if (links[i].from == last_from && links[i].to == last_to) {
            VECTOR(*eids)[links[i].id] = l;
            continue;
        }

        last_from = links[i].from;
        last_to = links[i].to;

        igraph_vector_push_back(&edges, last_from);
        igraph_vector_push_back(&edges, last_to);

        l++;

        VECTOR(*eids)[links[i].id] = l;
    }

    IGRAPH_FREE(links);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_destroy(graph);
    IGRAPH_CHECK(igraph_create(graph, &edges, igraph_vcount(graph), directed));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

typedef struct {
    long int community;
    igraph_real_t weight;
} igraph_i_multilevel_community_link;

static int igraph_i_multilevel_community_link_cmp(const void *a, const void *b) {
    return (int) (((igraph_i_multilevel_community_link*)a)->community -
                  ((igraph_i_multilevel_community_link*)b)->community);
}

/**
 * Given a graph, a community structure and a vertex ID, this method
 * calculates:
 *
 * - edges: the list of edge IDs that are incident on the vertex
 * - weight_all: the total weight of these edges
 * - weight_inside: the total weight of edges that stay within the same
 *   community where the given vertex is right now, excluding loop edges
 * - weight_loop: the total weight of loop edges
 * - links_community and links_weight: together these two vectors list the
 *   communities incident on this vertex and the total weight of edges
 *   pointing to these communities
 */
static int igraph_i_multilevel_community_links(
        const igraph_t *graph,
        const igraph_i_multilevel_community_list *communities,
        igraph_integer_t vertex, igraph_vector_t *edges,
        igraph_real_t *weight_all, igraph_real_t *weight_inside, igraph_real_t *weight_loop,
        igraph_vector_t *links_community, igraph_vector_t *links_weight) {

    long int i, n, last = -1, c = -1;
    igraph_real_t weight = 1;
    long int to, to_community;
    long int community = (long int) VECTOR(*(communities->membership))[(long int)vertex];
    igraph_i_multilevel_community_link *links;

    *weight_all = *weight_inside = *weight_loop = 0;

    igraph_vector_clear(links_community);
    igraph_vector_clear(links_weight);

    /* Get the list of incident edges */
    igraph_incident(graph, edges, vertex, IGRAPH_ALL);

    n = igraph_vector_size(edges);
    links = IGRAPH_CALLOC(n, igraph_i_multilevel_community_link);
    if (links == 0) {
        IGRAPH_ERROR("multi-level community structure detection failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, links);

    for (i = 0; i < n; i++) {
        long int eidx = (long int) VECTOR(*edges)[i];
        weight = VECTOR(*communities->weights)[eidx];

        to = IGRAPH_OTHER(graph, eidx, vertex);

        *weight_all += weight;
        if (to == vertex) {
            *weight_loop += weight;

            links[i].community = community;
            links[i].weight = 0;
            continue;
        }

        to_community = (long int)VECTOR(*(communities->membership))[to];
        if (community == to_community) {
            *weight_inside += weight;
        }

        /* debug("Link %ld (C: %ld) <-> %ld (C: %ld)\n", vertex, community, to, to_community); */

        links[i].community = to_community;
        links[i].weight = weight;
    }

    /* Sort links by community ID and merge the same */
    igraph_qsort((void*)links, (size_t) n, sizeof(igraph_i_multilevel_community_link),
                 igraph_i_multilevel_community_link_cmp);
    for (i = 0; i < n; i++) {
        to_community = links[i].community;
        if (to_community != last) {
            igraph_vector_push_back(links_community, to_community);
            igraph_vector_push_back(links_weight, links[i].weight);
            last = to_community;
            c++;
        } else {
            VECTOR(*links_weight)[c] += links[i].weight;
        }
    }

    igraph_free(links);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static igraph_real_t igraph_i_multilevel_community_modularity_gain(
                                                                   const igraph_i_multilevel_community_list *communities,
                                                                   igraph_integer_t community, igraph_integer_t vertex,
                                                                   igraph_real_t weight_all, igraph_real_t weight_inside,
                                                                   const igraph_real_t resolution) {
    IGRAPH_UNUSED(vertex);
    return weight_inside -
           resolution * communities->item[(long int)community].weight_all * weight_all / communities->weight_sum;
}

/* Shrinks communities into single vertices, keeping all the edges.
 * This method is internal because it destroys the graph in-place and
 * creates a new one -- this is fine for the multilevel community
 * detection where a copy of the original graph is used anyway.
 * The membership vector will also be rewritten by the underlying
 * igraph_membership_reindex call */
static int igraph_i_multilevel_shrink(igraph_t *graph, igraph_vector_t *membership) {
    igraph_vector_t edges;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);

    long int i;
    igraph_eit_t eit;

    if (no_of_nodes == 0) {
        return 0;
    }

    if (igraph_vector_size(membership) < no_of_nodes) {
        IGRAPH_ERROR("cannot shrink graph, membership vector too short",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    IGRAPH_CHECK(igraph_reindex_membership(membership, 0, NULL));

    /* Create the new edgelist */
    igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit);
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);
    i = 0;
    while (!IGRAPH_EIT_END(eit)) {
        igraph_integer_t from, to;
        IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(eit), &from, &to));
        VECTOR(edges)[i++] = VECTOR(*membership)[(long int) from];
        VECTOR(edges)[i++] = VECTOR(*membership)[(long int) to];
        IGRAPH_EIT_NEXT(eit);
    }
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    /* Create the new graph */
    igraph_destroy(graph);
    no_of_nodes = (long int) igraph_vector_max(membership) + 1;
    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup communities
 * \function igraph_i_community_multilevel_step
 * \brief Performs a single step of the multi-level modularity optimization method
 *
 * This function implements a single step of the multi-level modularity optimization
 * algorithm for finding community structure, see VD Blondel, J-L Guillaume,
 * R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large
 * networks, http://arxiv.org/abs/0803.0476 for the details.
 *
 * This function was contributed by Tom Gregorovic.
 *
 * \param graph      The input graph. It must be an undirected graph.
 * \param weights    Numeric vector containing edge weights. If \c NULL,
 *                   every edge has equal weight. The weights are expected
 *                   to be non-negative.
 * \param membership The membership vector, the result is returned here.
 *                   For each vertex it gives the ID of its community.
 * \param modularity The modularity of the partition is returned here.
 *                   \c NULL means that the modularity is not needed.
 * \param resolution  Resolution parameter. Must be greater than or equal to 0.
 *                   Default is 1. Lower values favor fewer, larger communities;
 *                   higher values favor more, smaller communities.
 * \return Error code.
 *
 * Time complexity: in average near linear on sparse graphs.
 */
static int igraph_i_community_multilevel_step(
        igraph_t *graph,
        igraph_vector_t *weights,
        igraph_vector_t *membership,
        igraph_real_t *modularity,
        const igraph_real_t resolution) {

    long int i, j;
    long int vcount = igraph_vcount(graph);
    long int ecount = igraph_ecount(graph);
    igraph_real_t q, pass_q;
    int pass;
    igraph_bool_t changed = 0;
    igraph_vector_t links_community;
    igraph_vector_t links_weight;
    igraph_vector_t edges;
    igraph_vector_t temp_membership;
    igraph_i_multilevel_community_list communities;
    igraph_vector_t node_order;

    /* Initial sanity checks on the input parameters */
    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("multi-level community detection works for undirected graphs only",
                     IGRAPH_UNIMPLEMENTED);
    }
    if (igraph_vector_size(weights) < igraph_ecount(graph)) {
        IGRAPH_ERROR("multi-level community detection: weight vector too short", IGRAPH_EINVAL);
    }
    if (igraph_vector_any_smaller(weights, 0)) {
        IGRAPH_ERROR("weights must be positive", IGRAPH_EINVAL);
    }
    if (resolution < 0.0) {
      IGRAPH_ERROR("The resolution parameter must be non-negative", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_init_seq(&node_order, 0, vcount - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &node_order);
    IGRAPH_CHECK(igraph_vector_shuffle(&node_order));

    /* Initialize data structures */
    IGRAPH_VECTOR_INIT_FINALLY(&links_community, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&links_weight, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&temp_membership, vcount);
    IGRAPH_CHECK(igraph_vector_resize(membership, vcount));

    /* Initialize list of communities from graph vertices */
    communities.vertices_no = vcount;
    communities.communities_no = vcount;
    communities.weights = weights;
    communities.weight_sum = 2 * igraph_vector_sum(weights);
    communities.membership = membership;
    communities.item = IGRAPH_CALLOC(vcount, igraph_i_multilevel_community);
    if (communities.item == 0) {
        IGRAPH_ERROR("multi-level community structure detection failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, communities.item);

    /* Still initializing the communities data structure */
    for (i = 0; i < vcount; i++) {
        VECTOR(*communities.membership)[i] = i;
        communities.item[i].size = 1;
        communities.item[i].weight_inside = 0;
        communities.item[i].weight_all = 0;
    }

    /* Some more initialization :) */
    for (i = 0; i < ecount; i++) {
        igraph_integer_t ffrom, fto;
        igraph_real_t weight = 1;
        igraph_edge(graph, (igraph_integer_t) i, &ffrom, &fto);

        weight = VECTOR(*weights)[i];
        communities.item[(long int) ffrom].weight_all += weight;
        communities.item[(long int) fto].weight_all += weight;
        if (ffrom == fto) {
            communities.item[(long int) ffrom].weight_inside += 2 * weight;
        }
    }

    q = igraph_i_multilevel_community_modularity(&communities, resolution);
    pass = 1;

    do { /* Pass begin */
        long int temp_communities_no = communities.communities_no;

        pass_q = q;
        changed = 0;

        /* Save the current membership, it will be restored in case of worse result */
        IGRAPH_CHECK(igraph_vector_update(&temp_membership, communities.membership));

        for (i = 0; i < vcount; i++) {
            /* Exclude vertex from its current community */
            igraph_real_t weight_all = 0;
            igraph_real_t weight_inside = 0;
            igraph_real_t weight_loop = 0;
            igraph_real_t max_q_gain = 0;
            igraph_real_t max_weight;
            long int old_id, new_id, n, ni;

            ni = VECTOR(node_order)[i];

            igraph_i_multilevel_community_links(graph, &communities,
                                                (igraph_integer_t) ni, &edges,
                                                &weight_all, &weight_inside,
                                                &weight_loop, &links_community,
                                                &links_weight);

            old_id = (long int)VECTOR(*(communities.membership))[ni];
            new_id = old_id;

            /* Update old community */
            igraph_vector_set(communities.membership, ni, -1);
            communities.item[old_id].size--;
            if (communities.item[old_id].size == 0) {
                communities.communities_no--;
            }
            communities.item[old_id].weight_all -= weight_all;
            communities.item[old_id].weight_inside -= 2 * weight_inside + weight_loop;

            /* debug("Remove %ld all: %lf Inside: %lf\n", ni, -weight_all, -2*weight_inside + weight_loop); */

            /* Find new community to join with the best modification gain */
            max_q_gain = 0;
            max_weight = weight_inside;
            n = igraph_vector_size(&links_community);

            for (j = 0; j < n; j++) {
                long int c = (long int) VECTOR(links_community)[j];
                igraph_real_t w = VECTOR(links_weight)[j];

                igraph_real_t q_gain =
                    igraph_i_multilevel_community_modularity_gain(&communities,
                                                                  (igraph_integer_t) c,
                                                                  (igraph_integer_t) ni,
                                                                  weight_all, w, resolution);
                /* debug("Link %ld -> %ld weight: %lf gain: %lf\n", ni, c, (double) w, (double) q_gain); */
                if (q_gain > max_q_gain) {
                    new_id = c;
                    max_q_gain = q_gain;
                    max_weight = w;
                }
            }

            /* debug("Added vertex %ld to community %ld (gain %lf).\n", ni, new_id, (double) max_q_gain); */

            /* Add vertex to "new" community and update it */
            igraph_vector_set(communities.membership, ni, new_id);
            if (communities.item[new_id].size == 0) {
                communities.communities_no++;
            }
            communities.item[new_id].size++;
            communities.item[new_id].weight_all += weight_all;
            communities.item[new_id].weight_inside += 2 * max_weight + weight_loop;

            if (new_id != old_id) {
                changed++;
            }
        }

        q = igraph_i_multilevel_community_modularity(&communities, resolution);

        if (changed && (q > pass_q)) {
            /* debug("Pass %d (changed: %d) Communities: %ld Modularity from %lf to %lf\n",
              pass, changed, communities.communities_no, (double) pass_q, (double) q); */
            pass++;
        } else {
            /* No changes or the modularity became worse, restore last membership */
            IGRAPH_CHECK(igraph_vector_update(communities.membership, &temp_membership));
            communities.communities_no = temp_communities_no;
            break;
        }

        IGRAPH_ALLOW_INTERRUPTION();
    } while (changed && (q > pass_q)); /* Pass end */

    if (modularity) {
        *modularity = q;
    }

    /* debug("Result Communities: %ld Modularity: %lf\n",
      communities.communities_no, (double) q); */

    IGRAPH_CHECK(igraph_reindex_membership(membership, 0, NULL));

    /* Shrink the nodes of the graph according to the present community structure
     * and simplify the resulting graph */

    /* TODO: check if we really need to copy temp_membership */
    IGRAPH_CHECK(igraph_vector_update(&temp_membership, membership));
    IGRAPH_CHECK(igraph_i_multilevel_shrink(graph, &temp_membership));
    igraph_vector_destroy(&temp_membership);
    IGRAPH_FINALLY_CLEAN(1);

    /* Update edge weights after shrinking and simplification */
    /* Here we reuse the edges vector as we don't need the previous contents anymore */
    /* TODO: can we use igraph_simplify here? */
    IGRAPH_CHECK(igraph_i_multilevel_simplify_multiple(graph, &edges));

    /* We reuse the links_weight vector to store the old edge weights */
    IGRAPH_CHECK(igraph_vector_update(&links_weight, weights));
    igraph_vector_fill(weights, 0);

    for (i = 0; i < ecount; i++) {
        VECTOR(*weights)[(long int)VECTOR(edges)[i]] += VECTOR(links_weight)[i];
    }

    igraph_free(communities.item);
    igraph_vector_destroy(&links_community);
    igraph_vector_destroy(&links_weight);
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&node_order);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup communities
 * \function igraph_community_multilevel
 * \brief Finding community structure by multi-level optimization of modularity.
 *
 * This function implements the multi-level modularity optimization
 * algorithm for finding community structure, see
 * Blondel, V. D., Guillaume, J.-L., Lambiotte, R., & Lefebvre, E. (2008). Fast
 * unfolding of communities in large networks. Journal of Statistical Mechanics:
 * Theory and Experiment, 10008(10), 6.
 * https://doi.org/10.1088/1742-5468/2008/10/P10008 for the details (preprint:
 * http://arxiv.org/abs/0803.0476). The algorithm is sometimes known as the
 * "Louvain" algorithm.
 *
 * 
 * The algorithm is based on the modularity measure and a hierarchical approach.
 * Initially, each vertex is assigned to a community on its own. In every step,
 * vertices are re-assigned to communities in a local, greedy way: in a random
 * order, each vertex is moved to the community with which it achieves the highest
 * contribution to modularity. When no vertices can be reassigned, each community
 * is considered a vertex on its own, and the process starts again with the merged
 * communities. The process stops when there is only a single vertex left or when
 * the modularity cannot be increased any more in a step.
 *
 * 
 * The resolution parameter \c gamma allows finding communities at different
 * resolutions. Higher values of the resolution parameter typically result in
 * more, smaller communities. Lower values typically result in fewer, larger
 * communities. The original definition of modularity is retrieved when setting
 * gamma=1. Note that the returned modularity value is calculated using
 * the indicated resolution parameter. See \ref igraph_modularity() for more details.
 *
 * This function was contributed by Tom Gregorovic.
 *
 * \param graph       The input graph. It must be an undirected graph.
 * \param weights     Numeric vector containing edge weights. If \c NULL, every edge
 *                    has equal weight. The weights are expected to be non-negative.
 * \param resolution  Resolution parameter. Must be greater than or equal to 0.
 *                    Lower values favor fewer, larger communities;
 *                    higher values favor more, smaller communities.
 *                    Set it to 1 to use the classical definition of modularity.
 * \param membership  The membership vector, the result is returned here.
 *                    For each vertex it gives the ID of its community. The vector
 *                    must be initialized and it will be resized accordingly.
 * \param memberships Numeric matrix that will contain the membership vector after
 *                    each level, if not \c NULL. It must be initialized and
 *                    it will be resized accordingly.
 * \param modularity  Numeric vector that will contain the modularity score
 *                    after each level, if not \c NULL. It must be initialized
 *                    and it will be resized accordingly.
 * \return Error code.
 *
 * Time complexity: in average near linear on sparse graphs.
 *
 * \example examples/simple/igraph_community_multilevel.c
 */

int igraph_community_multilevel(const igraph_t *graph,
                                const igraph_vector_t *weights,
                                const igraph_real_t resolution,
                                igraph_vector_t *membership,
                                igraph_matrix_t *memberships, igraph_vector_t *modularity) {

    igraph_t g;
    igraph_vector_t w, m, level_membership;
    igraph_real_t prev_q = -1, q = -1;
    int i, level = 1;
    long int vcount = igraph_vcount(graph);

    /* Make a copy of the original graph, we will do the merges on the copy */
    IGRAPH_CHECK(igraph_copy(&g, graph));
    IGRAPH_FINALLY(igraph_destroy, &g);

    if (weights) {
        IGRAPH_CHECK(igraph_vector_copy(&w, weights));
        IGRAPH_FINALLY(igraph_vector_destroy, &w);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&w, igraph_ecount(&g));
        igraph_vector_fill(&w, 1);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&m, vcount);
    IGRAPH_VECTOR_INIT_FINALLY(&level_membership, vcount);

    if (memberships || membership) {
        /* Put each vertex in its own community */
        for (i = 0; i < vcount; i++) {
            VECTOR(level_membership)[i] = i;
        }
    }
    if (memberships) {
        /* Resize the membership matrix to have vcount columns and no rows */
        IGRAPH_CHECK(igraph_matrix_resize(memberships, 0, vcount));
    }
    if (modularity) {
        /* Clear the modularity vector */
        igraph_vector_clear(modularity);
    }

    while (1) {
        /* Remember the previous modularity and vertex count, do a single step */
        igraph_integer_t step_vcount = igraph_vcount(&g);

        prev_q = q;
        IGRAPH_CHECK(igraph_i_community_multilevel_step(&g, &w, &m, &q, resolution));

        /* Were there any merges? If not, we have to stop the process */
        if (igraph_vcount(&g) == step_vcount || q < prev_q) {
            break;
        }

        if (memberships || membership) {
            for (i = 0; i < vcount; i++) {
                /* Readjust the membership vector */
                VECTOR(level_membership)[i] = VECTOR(m)[(long int) VECTOR(level_membership)[i]];
            }
        }

        if (modularity) {
            /* If we have to return the modularity scores, add it to the modularity vector */
            IGRAPH_CHECK(igraph_vector_push_back(modularity, q));
        }

        if (memberships) {
            /* If we have to return the membership vectors at each level, store the new
             * membership vector */
            IGRAPH_CHECK(igraph_matrix_add_rows(memberships, 1));
            IGRAPH_CHECK(igraph_matrix_set_row(memberships, &level_membership, level - 1));
        }

        /* debug("Level: %d Communities: %ld Modularity: %f\n", level, (long int) igraph_vcount(&g),
          (double) q); */

        /* Increase the level counter */
        level++;
    }

    /* It might happen that there are no merges, so every vertex is in its
       own community. We still might want the modularity score for that. */
    if (modularity && igraph_vector_size(modularity) == 0) {
        igraph_vector_t tmp;
        igraph_real_t mod;
        int i;
        IGRAPH_VECTOR_INIT_FINALLY(&tmp, vcount);
        for (i = 0; i < vcount; i++) {
            VECTOR(tmp)[i] = i;
        }
        IGRAPH_CHECK(igraph_modularity(graph, &tmp, weights, resolution,
                                       /* only undirected */ 0, &mod));
        igraph_vector_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_CHECK(igraph_vector_resize(modularity, 1));
        VECTOR(*modularity)[0] = mod;
    }

    /* If we need the final membership vector, copy it to the output */
    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, vcount));
        for (i = 0; i < vcount; i++) {
            VECTOR(*membership)[i] = VECTOR(level_membership)[i];
        }
    }

    /* Destroy the copy of the graph */
    igraph_destroy(&g);

    /* Destroy the temporary vectors */
    igraph_vector_destroy(&m);
    igraph_vector_destroy(&w);
    igraph_vector_destroy(&level_membership);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/modularity.c0000644000175100001710000003521500000000000025030 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_structural.h"

/**
 * \function igraph_modularity
 * \brief Calculate the modularity of a graph with respect to some clusters or vertex types.
 *
 * The modularity of a graph with respect to some clustering of the vertices
 * (or assignment of vertex types)
 * measures how strongly separated the different clusters are from each
 * other compared to a random null model. It is defined as
 *
 * 
 * Q = 1/(2m) sum_ij (A_ij - gamma * k_i * k_j / (2m)) * d(c_i,c_j),
 *
 * 
 * where \c m is the number of edges, A_ij is the adjacency matrix,
 * \c k_i is the degree of vertex \c i, \c c_i is the cluster that vertex \c i belongs to
 * (or its vertex type), d(i,j)=1 if i=j and 0 otherwise,
 * and the sum goes over all i, j pairs of vertices.
 *
 * 
 * The resolution parameter \c gamma allows weighting the random null model, which
 * might be useful when finding partitions with a high modularity. Maximizing modularity
 * with higher values of the resolution parameter typically results in more, smaller clusters
 * when finding partitions with a high modularity. Lower values typically results in
 * fewer, larger clusters. The original definition of modularity is retrieved
 * when setting gamma=1.
 *
 * 
 * Modularity can also be calculated on directed graphs. This only requires a relatively
 * modest change
 *
 * 
 * Q = 1/(m) sum_ij (A_ij - gamma * k^out_i * k^in_j / m) * d(c_i,c_j),
 *
 * 
 * where \c k^out_i is the out-degree of node \c i and \c k^in_j is the in-degree of node \c j.
 *
 * 
 * Modularity on weighted graphs is also meaningful. When taking
 * edge weights into account, \c A_ij equals the weight of the corresponding edge
 * (or 0 if there is no edge), \c k_i is the strength (i.e. the weighted degree) of
 * vertex \c i, with similar counterparts for a directed graph, and \c m is the total
 * weight of all edges.
 *
 * 
 * Note that the modularity is not well-defined for graphs with no edges.
 * igraph returns \c NaN for graphs with no edges; see
 * https://github.com/igraph/igraph/issues/1539 for
 * a detailed discussion.
 *
 * 
 * For the original definition of modularity, see Newman, M. E. J., and Girvan, M.
 * (2004). Finding and evaluating community structure in networks.
 * Physical Review E 69, 026113. https://doi.org/10.1103/PhysRevE.69.026113
 *
 * 
 * For the directed definition of modularity, see Leicht, E. A., and Newman, M. E.
 * J. (2008). Community Structure in Directed Networks. Physical Review Letters 100,
 * 118703. https://doi.org/10.1103/PhysRevLett.100.118703
 *
 * 
 * For the introduction of the resolution parameter, see Reichardt, J., and
 * Bornholdt, S. (2006). Statistical mechanics of community detection. Physical
 * Review E 74, 016110. https://doi.org/10.1103/PhysRevE.74.016110
 *
 * \param graph      The input graph.
 * \param membership Numeric vector of integer values which gives the type of each
 *                   vertex, i.e. the cluster to which it belongs.
 *                   It does not have to be consecutive, i.e. empty communities
 *                   are allowed.
 * \param weights    Weight vector or \c NULL if no weights are specified.
 * \param resolution Resolution parameter. Must be greater than or equal to 0.
 *                   Set it to 1 to use the classical definition of modularity.
 * \param directed   Whether to use the directed or undirected version of modularity.
 *                   Ignored for undirected graphs.
 * \param modularity Pointer to a real number, the result will be
 *                   stored here.
 * \return Error code.
 *
 * \sa \ref igraph_modularity_matrix()
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 */
int igraph_modularity(const igraph_t *graph,
                      const igraph_vector_t *membership,
                      const igraph_vector_t *weights,
                      const igraph_real_t resolution,
                      const igraph_bool_t directed,
                      igraph_real_t *modularity) {

    igraph_vector_t e, k_out, k_in;
    long int types;
    long int no_of_edges = igraph_ecount(graph);
    long int i;
    igraph_real_t m;
    long int c1, c2;
    /* Only consider the graph as directed if it actually is directed */
    igraph_bool_t use_directed = directed && igraph_is_directed(graph);
    igraph_real_t directed_multiplier = (use_directed ? 1 : 2);

    if (igraph_vector_size(membership) != igraph_vcount(graph)) {
        IGRAPH_ERROR("Membership vector size differs from number of vertices.",
                     IGRAPH_EINVAL);
    }
    if (resolution < 0.0) {
      IGRAPH_ERROR("The resolution parameter must be non-negative.", IGRAPH_EINVAL);
    }

    if (no_of_edges == 0) {
        /* Special case: the modularity of graphs with no edges is not
         * well-defined */
        if (modularity) {
            *modularity = IGRAPH_NAN;
        }
        return IGRAPH_SUCCESS;
    }

    /* At this point, the 'membership' vector does not have length zero,
       thus it is safe to call igraph_vector_max() and min(). */

    types = (long int) igraph_vector_max(membership) + 1;

    if (igraph_vector_min(membership) < 0) {
        IGRAPH_ERROR("Invalid membership vector: negative entry.", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&e, types);
    IGRAPH_VECTOR_INIT_FINALLY(&k_out, types);
    IGRAPH_VECTOR_INIT_FINALLY(&k_in, types);

    if (weights) {
        if (igraph_vector_size(weights) != no_of_edges)
            IGRAPH_ERROR("Vector size differs from number of edges.",
                         IGRAPH_EINVAL);
        m = 0.0;
        for (i = 0; i < no_of_edges; i++) {
            igraph_real_t w = VECTOR(*weights)[i];
            if (w < 0) {
                IGRAPH_ERROR("Negative weight in weight vector.", IGRAPH_EINVAL);
            }
            c1 = (long int) VECTOR(*membership)[ IGRAPH_FROM(graph, i) ];
            c2 = (long int) VECTOR(*membership)[ IGRAPH_TO(graph, i) ];
            if (c1 == c2) {
                VECTOR(e)[c1] += directed_multiplier * w;
            }
            VECTOR(k_out)[c1] += w;
            VECTOR(k_in)[c2]  += w;
            m += w;
        }
    } else {
        m = no_of_edges;
        for (i = 0; i < no_of_edges; i++) {
            c1 = (long int) VECTOR(*membership)[ IGRAPH_FROM(graph, i) ];
            c2 = (long int) VECTOR(*membership)[ IGRAPH_TO(graph, i) ];
            if (c1 == c2) {
                VECTOR(e)[c1] += directed_multiplier;
            }
            VECTOR(k_out)[c1] += 1;
            VECTOR(k_in)[c2]  += 1;
        }
    }

    if (!use_directed) {
        /* Graph is undirected, simply add vectors */
        igraph_vector_add(&k_out, &k_in);
        igraph_vector_update(&k_in, &k_out);
    }

    /* Divide all vectors by total weight. */
    igraph_vector_scale(&k_out, 1.0/( directed_multiplier * m ) );
    igraph_vector_scale(&k_in, 1.0/( directed_multiplier * m ) );
    igraph_vector_scale(&e, 1.0/( directed_multiplier * m ) );

    *modularity = 0.0;
    if (m > 0) {
        for (i = 0; i < types; i++) {
            *modularity += VECTOR(e)[i];
            *modularity -= resolution * VECTOR(k_out)[i] * VECTOR(k_in)[i];
        }
    }

    igraph_vector_destroy(&e);
    igraph_vector_destroy(&k_out);
    igraph_vector_destroy(&k_in);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

static int igraph_i_modularity_matrix_get_adjacency(
           const igraph_t *graph, igraph_matrix_t *res,
           const igraph_vector_t *weights, igraph_bool_t directed) {
    /* Specifically used to handle weights and/or ignore direction */
    igraph_eit_t edgeit;
    long int no_of_nodes = igraph_vcount(graph);
    igraph_integer_t from, to;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, no_of_nodes));
    igraph_matrix_null(res);
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    if (weights) {
        for (; !IGRAPH_EIT_END(edgeit); IGRAPH_EIT_NEXT(edgeit)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(edgeit);
            from = IGRAPH_FROM(graph, edge);
            to = IGRAPH_TO(graph, edge);
            MATRIX(*res, from, to) += VECTOR(*weights)[edge];
            if (!directed) {
                MATRIX(*res, to, from) += VECTOR(*weights)[edge];
            }
        }
    } else {
        for (; !IGRAPH_EIT_END(edgeit); IGRAPH_EIT_NEXT(edgeit)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(edgeit);
            igraph_edge(graph, edge, &from, &to);
            MATRIX(*res, from, to) += 1;
            if (!directed) {
                MATRIX(*res, to, from) += 1;
            }
        }
    }

    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_modularity_matrix
 * \brief Calculate the modularity matrix
 *
 * This function returns the modularity matrix defined as
 *
 * 
 * B_ij = A_ij - gamma * k_i * k_j / (2m)
 *
 * 
 * for undirected graphs, where \c A_ij is the adjacency matrix, \c gamma is the
 * resolution parameter, \c k_i is the degree of vertex \c i, and \c m is the
 * number of edges in the graph. When there are no edges, or the weights add up
 * to zero, the result is undefined.
 *
 * 
 * For directed graphs the modularity matrix is changed to
 *
 * 
 * B_ij = A_ij - gamma * k^out_i * k^in_j / m
 * where k^out_i is the out-degree of node \c i and k^in_j is the
 * in-degree of node \c j.
 *
 * 
 * Note that self-loops in undirected graphs are multiplied by 2 in this
 * implementation. If weights are specified, the weighted counterparts are used.
 *
 * \param graph      The input graph.
 * \param weights    Edge weights, pointer to a vector. If this is a null pointer
 *                   then every edge is assumed to have a weight of 1.
 * \param resolution Resolution parameter. Must be greater than or equal to 0.
 *                   Default is 1. Lower values favor fewer, larger communities;
 *                   higher values favor more, smaller communities.
 * \param modmat     Pointer to an initialized matrix in which the modularity
 *                   matrix is stored.
 * \param directed   For directed graphs: if the edges should be treated as
 *                   undirected.
 *                   For undirected graphs this is ignored.
 *
 * \sa \ref igraph_modularity()
 */
int igraph_modularity_matrix(const igraph_t *graph,
                             const igraph_vector_t *weights,
                             const igraph_real_t resolution,
                             igraph_matrix_t *modmat,
                             igraph_bool_t directed) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_real_t sw = weights ? igraph_vector_sum(weights) : no_of_edges;
    igraph_vector_t deg, deg_unscaled, in_deg, out_deg;
    long int i, j;
    igraph_real_t scaling_factor;
    if (weights && igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid weight vector length.", IGRAPH_EINVAL);
    }

    if (resolution < 0.0) {
        IGRAPH_ERROR("The resolution parameter must be non-negative.", IGRAPH_EINVAL);
    }

    if (!igraph_is_directed(graph)) {
        directed = 0;
    }
    IGRAPH_CHECK(igraph_i_modularity_matrix_get_adjacency(graph, modmat, weights, directed));

    if (directed) {
        IGRAPH_VECTOR_INIT_FINALLY(&in_deg, no_of_nodes);
        IGRAPH_VECTOR_INIT_FINALLY(&out_deg, no_of_nodes);
        if (!weights) {
            IGRAPH_CHECK(igraph_degree(graph, &in_deg, igraph_vss_all(), IGRAPH_IN,
                                       IGRAPH_LOOPS));
            IGRAPH_CHECK(igraph_degree(graph, &out_deg, igraph_vss_all(), IGRAPH_OUT,
                                       IGRAPH_LOOPS));
        } else {
            IGRAPH_CHECK(igraph_strength(graph, &in_deg, igraph_vss_all(), IGRAPH_IN,
                                         IGRAPH_LOOPS, weights));
            IGRAPH_CHECK(igraph_strength(graph, &out_deg, igraph_vss_all(), IGRAPH_OUT,
                                         IGRAPH_LOOPS, weights));
        }
        /* Scaling one degree factor so every element gets scaled. */
        scaling_factor = resolution / sw;
        igraph_vector_scale(&out_deg, scaling_factor);

        for (j = 0; j < no_of_nodes; j++) {
            for (i = 0; i < no_of_nodes; i++) {
                MATRIX(*modmat, i, j) -= VECTOR(out_deg)[i] * VECTOR(in_deg)[j];
            }
        }
        igraph_vector_destroy(&in_deg);
        igraph_vector_destroy(&out_deg);
        IGRAPH_FINALLY_CLEAN(2);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(°, no_of_nodes);
        if (!weights) {
            IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(), IGRAPH_ALL,
                                       IGRAPH_LOOPS));
        } else {
            IGRAPH_CHECK(igraph_strength(graph, °, igraph_vss_all(), IGRAPH_ALL,
                                         IGRAPH_LOOPS, weights));
        }

        /* Scaling one degree factor so every element gets scaled. */
        igraph_vector_copy(°_unscaled, °);
        IGRAPH_FINALLY(igraph_vector_destroy, °_unscaled);
        scaling_factor = resolution / 2.0 / sw;
        igraph_vector_scale(°, scaling_factor);
        for (i = 0; i < no_of_nodes; i++) {
            for (j = 0; j < no_of_nodes; j++) {
                MATRIX(*modmat, i, j) -= VECTOR(deg)[i] * VECTOR(deg_unscaled)[j];
            }
        }
        igraph_vector_destroy(°);
        igraph_vector_destroy(°_unscaled);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/optimal_modularity.c0000644000175100001710000002262100000000000026552 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_community.h"

#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_structural.h"

#include "core/interruption.h"
#include "internal/glpk_support.h"

#include "config.h"

#ifdef HAVE_GLPK
    #include 
#endif

/**
 * \function igraph_community_optimal_modularity
 * Calculate the community structure with the highest modularity value
 *
 * This function calculates the optimal community structure for a
 * graph, in terms of maximal modularity score.
 *
 * 
 * The calculation is done by transforming the modularity maximization
 * into an integer programming problem, and then calling the GLPK
 * library to solve that. Please see Ulrik Brandes et al.: On
 * Modularity Clustering, IEEE Transactions on Knowledge and Data
 * Engineering 20(2):172-188, 2008.
 *
 * 
 * Note that modularity optimization is an NP-complete problem, and
 * all known algorithms for it have exponential time complexity. This
 * means that you probably don't want to run this function on larger
 * graphs. Graphs with up to fifty vertices should be fine, graphs
 * with a couple of hundred vertices might be possible.
 *
 * \param graph The input graph. It is always treated as undirected.
 * \param modularity Pointer to a real number, or a null pointer.
 *        If it is not a null pointer, then a optimal modularity value
 *        is returned here.
 * \param membership Pointer to a vector, or a null pointer. If not a
 *        null pointer, then the membership vector of the optimal
 *        community structure is stored here.
 * \param weights Vector giving the weights of the edges. If it is
 *        \c NULL then each edge is supposed to have the same weight.
 * \return Error code.
 *
 * \sa \ref igraph_modularity(), \ref igraph_community_fastgreedy()
 * for an algorithm that finds a local optimum in a greedy way.
 *
 * Time complexity: exponential in the number of vertices.
 *
 * \example examples/simple/igraph_community_optimal_modularity.c
 */

int igraph_community_optimal_modularity(const igraph_t *graph,
                                        igraph_real_t *modularity,
                                        igraph_vector_t *membership,
                                        const igraph_vector_t *weights) {

#ifndef HAVE_GLPK
    IGRAPH_ERROR("GLPK is not available",
                 IGRAPH_UNIMPLEMENTED);
#else

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_integer_t no_of_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    int no_of_variables = no_of_nodes * (no_of_nodes + 1) / 2;
    int i, j, k, l, st;
    int idx[] = { 0, 0, 0, 0 };
    double coef[] = { 0.0, 1.0, 1.0, -2.0 };
    igraph_real_t total_weight;
    igraph_vector_t indegree;
    igraph_vector_t outdegree;

    glp_prob *ip;
    glp_iocp parm;

    if (weights) {
        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Weight vector length must agree with number of edges.", IGRAPH_EINVAL);
        }
        if (no_of_edges > 0) {
            /* Must not call vector_min on empty vector */
            igraph_real_t minweight = igraph_vector_min(weights);
            if (minweight < 0) {
                IGRAPH_ERROR("Negative weights are not allowed in weight vector.", IGRAPH_EINVAL);
            }
            if (igraph_is_nan(minweight)) {
                IGRAPH_ERROR("Weights must not be NaN.", IGRAPH_EINVAL);
            }
        }
    }

    /* Avoid problems with the null graph */
    if (no_of_nodes < 2) {
        if (membership) {
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 0);
        }
        if (modularity) {
            IGRAPH_CHECK(igraph_modularity(graph, membership, 0, 1, igraph_is_directed(graph), modularity));
        }
        return IGRAPH_SUCCESS;
    }

    if (weights) {
        total_weight = igraph_vector_sum(weights);
    } else {
        total_weight = no_of_edges;
    }
    if (!directed) {
        total_weight *= 2;
    }

    /* Special case */
    if (no_of_edges == 0 || total_weight == 0) {
        if (modularity) {
            *modularity = IGRAPH_NAN;
        }
        if (membership) {
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_null(membership);
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&indegree, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&outdegree, no_of_nodes);
    IGRAPH_CHECK(igraph_strength(graph, &indegree, igraph_vss_all(),
                                 IGRAPH_IN, IGRAPH_LOOPS, weights));
    IGRAPH_CHECK(igraph_strength(graph, &outdegree, igraph_vss_all(),
                                 IGRAPH_OUT, IGRAPH_LOOPS, weights));

    IGRAPH_GLPK_SETUP();

    ip = glp_create_prob();
    IGRAPH_FINALLY(igraph_i_glp_delete_prob, ip);

    glp_set_obj_dir(ip, GLP_MAX);
    st = glp_add_cols(ip, no_of_variables);

    /* variables are binary */
    for (i = 0; i < no_of_variables; i++) {
        glp_set_col_kind(ip, (st + i), GLP_BV);
    }

#define IDX(a,b) ((b)*((b)+1)/2+(a))

    /* reflexivity */
    for (i = 0; i < no_of_nodes; i++) {
        glp_set_col_bnds(ip, (st + IDX(i, i)), GLP_FX, 1.0, 1.0);
    }

    /* transitivity */
    for (i = 0; i < no_of_nodes; i++) {
        for (j = i + 1; j < no_of_nodes; j++) {

            IGRAPH_ALLOW_INTERRUPTION();

            for (k = j + 1; k < no_of_nodes; k++) {
                int newrow = glp_add_rows(ip, 3);

                glp_set_row_bnds(ip, newrow, GLP_UP, 0.0, 1.0);
                idx[1] = (st + IDX(i, j)); idx[2] = (st + IDX(j, k));
                idx[3] = (st + IDX(i, k));
                glp_set_mat_row(ip, newrow, 3, idx, coef);

                glp_set_row_bnds(ip, newrow + 1, GLP_UP, 0.0, 1.0);
                idx[1] = st + IDX(i, j); idx[2] = st + IDX(i, k); idx[3] = st + IDX(j, k);
                glp_set_mat_row(ip, newrow + 1, 3, idx, coef);

                glp_set_row_bnds(ip, newrow + 2, GLP_UP, 0.0, 1.0);
                idx[1] = st + IDX(i, k); idx[2] = st + IDX(j, k); idx[3] = st + IDX(i, j);
                glp_set_mat_row(ip, newrow + 2, 3, idx, coef);

            }
        }
    }

    /* objective function */
    {
        igraph_real_t c;

        /* first part: -strength(i)*strength(j)/total_weight for every node pair */
        for (i = 0; i < no_of_nodes; i++) {
            for (j = i + 1; j < no_of_nodes; j++) {
                c = -VECTOR(indegree)[i] * VECTOR(outdegree)[j] / total_weight \
                    -VECTOR(outdegree)[i] * VECTOR(indegree)[j] / total_weight;
                glp_set_obj_coef(ip, st + IDX(i, j), c);
            }
            /* special case for (i,i) */
            c = -VECTOR(indegree)[i] * VECTOR(outdegree)[i] / total_weight;
            glp_set_obj_coef(ip, st + IDX(i, i), c);
        }

        /* second part: add the weighted adjacency matrix to the coefficient matrix */
        for (k = 0; k < no_of_edges; k++) {
            i = IGRAPH_FROM(graph, k);
            j = IGRAPH_TO(graph, k);
            if (i > j) {
                l = i; i = j; j = l;
            }
            c = weights ? VECTOR(*weights)[k] : 1.0;
            if (!directed || i == j) {
                c *= 2.0;
            }
            glp_set_obj_coef(ip, st + IDX(i, j), c + glp_get_obj_coef(ip, st + IDX(i, j)));
        }
    }

    /* solve it */
    glp_init_iocp(&parm);
    parm.br_tech = GLP_BR_DTH;
    parm.bt_tech = GLP_BT_BLB;
    parm.presolve = GLP_ON;
    parm.binarize = GLP_ON;
    parm.cb_func = igraph_i_glpk_interruption_hook;
    IGRAPH_GLPK_CHECK(glp_intopt(ip, &parm), "Modularity optimization failed");

    /* store the results */
    if (modularity) {
        *modularity = glp_mip_obj_val(ip) / total_weight;
    }

    if (membership) {
        long int comm = 0;   /* id of the last community that was found */
        IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {

            IGRAPH_ALLOW_INTERRUPTION();

            for (j = 0; j < i; j++) {
                int val = (int) glp_mip_col_val(ip, st + IDX(j, i));
                if (val == 1) {
                    VECTOR(*membership)[i] = VECTOR(*membership)[j];
                    break;
                }
            }
            if (j == i) {     /* new community */
                VECTOR(*membership)[i] = comm++;
            }
        }
    }

#undef IDX

    igraph_vector_destroy(&indegree);
    igraph_vector_destroy(&outdegree);
    glp_delete_prob(ip);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;

#endif

}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4911406
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/0000755000175100001710000000000000000000000024470 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/NetDataTypes.cpp0000644000175100001710000001545500000000000027553 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   The original copyright notice follows here */

/***************************************************************************
                          NetDataTypes.cpp  -  description
                             -------------------
    begin                : Mon Oct 6 2003
    copyright            : (C) 2003 by Joerg Reichardt
    email                : reichardt@mitte
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "NetDataTypes.h"
#include 

//#################################################################################
//###############################################################################
//Constructor
NNode::NNode(unsigned long ind, unsigned long c_ind, DLList *ll, const char *n, int states) {
    index = ind;
    cluster_index = c_ind;
    neighbours = new DLList();
    n_links = new DLList();
    global_link_list = ll;
    strcpy(name, n);
    color.red = 0;
    color.green = 0;
    color.blue = 0;
    strcpy(color.pajek_c, "Green");
    clustering = 0.0;
    marker = 0;
    affiliations = 0;
    weight = 0.0;
    affinity = 0.0;
    distance = 0;
    max_states = states;
    state_history = new unsigned long[states + 1];
}

//Destructor
NNode::~NNode() {
    Disconnect_From_All();
    delete neighbours;
    delete n_links;
    delete [] state_history;
    neighbours = NULL;
    n_links = NULL;
    state_history = NULL;
}

void NNode::Add_StateHistory(unsigned int state) {
    if (max_states >= state) {
        state_history[state]++;
    }
}

void NNode::Set_Color(RGBcolor c) {
    color.red = c.red; color.blue = c.blue; color.green = c.green;
    strcpy(color.pajek_c, c.pajek_c);
}

int NNode::Connect_To(NNode* neighbour, double weight_) {
    NLink *link;
    //sollen doppelte Links erlaubt sein??  NEIN
    if (!neighbour) {
        return 0;
    }
    if (!(neighbours->Is_In_List(neighbour)) && (neighbour != this)) {
        neighbours->Push(neighbour);        // nachbar hier eintragen
        neighbour->neighbours->Push(this); // diesen knoten beim nachbarn eintragen

        link = new NLink(this, neighbour, weight_);     //link erzeugen
        global_link_list->Push(link);                        // in globaler liste eintragen
        n_links->Push(link);                                   // bei diesem Knoten eintragen
        neighbour->n_links->Push(link);                  // beim nachbarn eintragen

        return (1);
    }
    return (0);
}

NLink *NNode::Get_LinkToNeighbour(NNode* neighbour) {
    DLList_Iter iter;
    NLink *l_cur, *link = NULL;
    bool found = false;
    // finde einen bestimmten Link aus der Liste der links eines Knotens
    l_cur = iter.First(n_links);
    while (!iter.End() && !found) {
        if (((l_cur->Get_Start() == this) && (l_cur->Get_End() == neighbour)) || ((l_cur->Get_End() == this) && (l_cur->Get_Start() == neighbour))) {
            found = true;
            link = l_cur;
        }
        l_cur = iter.Next();
    }
    if (found) {
        return link;
    } else {
        return NULL;
    }
}

int NNode::Disconnect_From(NNode* neighbour) {
    //sollen doppelte Links erlaubt sein??  s.o.
    if (!neighbours) {
        return 0;
    }
    neighbours->fDelete(neighbour);
    n_links->fDelete(Get_LinkToNeighbour(neighbour));
    neighbour->n_links->fDelete(neighbour->Get_LinkToNeighbour(this));
    neighbour->neighbours->fDelete(this);
    return 1;
}

int NNode::Disconnect_From_All() {
    int number_of_neighbours = 0;
    while (neighbours->Size()) {
        Disconnect_From(neighbours->Pop());
        number_of_neighbours++;
    }
    return (number_of_neighbours) ;
}

/*
int NNode::Disconnect_From_All_Grandchildren()
{
 int n_l=links->Size();
 unsigned long pos=0;
 while ((n_l--)>1) {  //alle bis auf das erste loeschen
      pos=(links->Get(n_l+1))->links->Is_In_List(this);
     // printf("%d %d\n",n_l,pos);
      (links->Get(n_l+1))->links->Delete(pos);
  }
 return(pos) ;
}
*/

double NNode::Get_Links_Among_Neigbours() {
//  long neighbours1, neighbours2;
    double lam = 0;
    DLList_Iter iter1, iter2;
//  neighbours1=neighbours->Size();        //so viele Nachbarn hat die Betrachtete Node
    NNode *step1, *step2;
    step1 = iter1.First(neighbours);
    while (!iter1.End()) { //  for (int n1=1;n1<=neighbours1; n1++)
        //step1=neighbours->Get(n1);
        //neighbours2=step1->neighbours->Size();  //so viele Nachbarn hat der n1-ste Nachbar
        step2 = iter2.First(step1->Get_Neighbours());
        while (!iter2.End()) { //for (int n2=1;n2<=neighbours2; n2++)
            //step2=step1->neighbours->Get(n2);
            if (step2->Get_Neighbours()->Is_In_List(this)) {
                lam++;
            }
            step2 = iter2.Next();
        }
        step1 = iter1.Next();
    }
    return (lam / 2.0);
}


double NNode::Get_Clustering() {
    double c;
    unsigned long k;
    k = neighbours->Size();
    if (k <= 1) {
        return (0);
    }
    c = 2.0 * Get_Links_Among_Neigbours() / double(k * k - k);
    return (c);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++

//Constructor
NLink::NLink(NNode *s, NNode *e, double w) {
    start = s;
    end = e;
    weight = w;
    old_weight = 0;
    marker = 0;
}

//Destructor
NLink::~NLink() {
    if (start && end) {
        start->Disconnect_From(end);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/NetDataTypes.h0000644000175100001710000006057500000000000027223 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   The original copyright notice follows here */

/***************************************************************************
                          NetDataTypes.h  -  description
                             -------------------
    begin                : Mon Oct 6 2003
    copyright            : (C) 2003 by Joerg Reichardt
    email                : reichardt@mitte
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef NETDATATYPES_H
#define NETDATATYPES_H

#include 

//###########################################################################################

struct HUGE_INDEX {
    unsigned int field_index;
    unsigned long in_field_index;
};

template  class HugeArray {
private:
    unsigned long int size;
    unsigned int highest_field_index;
    unsigned long max_bit_left;
    unsigned long max_index;
    DATA *data;
    DATA *fields[32];
public:
    HUGE_INDEX get_huge_index(unsigned long);
    DATA &Set(unsigned long);
    DATA Get(unsigned long);
    HugeArray();
    ~HugeArray();
    DATA &operator[](unsigned long);
    unsigned long Size() {
        return max_index;
    }
} ;
//###############################################################################################
template  class DLList;
template  class DL_Indexed_List;
template  class ClusterList;
template  class DLList_Iter;

template 
class DLItem {
    friend class DLList ;
    friend class DL_Indexed_List;
    friend class DLList_Iter;
private:
    L_DATA  item;
    unsigned long index;
    DLItem *previous;
    DLItem *next;
    DLItem(L_DATA i, unsigned long ind);
    DLItem(L_DATA i, unsigned long ind, DLItem *p, DLItem *n);
    ~DLItem();
public:
    void del() {
        delete item;
    }
};

template 
class DLList {
    friend class DLList_Iter;
protected:
    DLItem  *head;
    DLItem  *tail;
    unsigned long number_of_items;
    DLItem *pInsert(L_DATA, DLItem*);
    L_DATA pDelete(DLItem*);
public:
    DLList();
    ~DLList();
    unsigned long Size() {
        return number_of_items;
    }
    int Insert(L_DATA, unsigned long);
    int Delete(unsigned long);
    int fDelete(L_DATA);
    L_DATA Push(L_DATA);
    L_DATA Pop();
    L_DATA Get(unsigned long);
    int Enqueue(L_DATA);
    L_DATA Dequeue();
    unsigned long Is_In_List(L_DATA);
    void delete_items();
};

template 
class DL_Indexed_List : virtual public DLList {
    friend class DLList_Iter;
private:
    DLItem *pInsert(L_DATA, DLItem*);
    L_DATA pDelete(DLItem*);
    HugeArray*> array;
    unsigned long last_index;
public:
    DL_Indexed_List();
    ~DL_Indexed_List();
    L_DATA Push(L_DATA);
    L_DATA Pop();
    L_DATA Get(unsigned long);
};

//#####################################################################################################

template  class DLList_Iter {
private:
    DLList  *list;
    DLItem *current;
    bool end_reached;
public:
    DLList_Iter();
    ~DLList_Iter() {
        end_reached = true;
    };
    L_DATA Next();
    L_DATA Previous();
    L_DATA First(DLList *l);
    L_DATA Last(DLList *l);
    bool End() {
        return end_reached;
    }
    DLItem *Get_Current() {
        return current;
    }
    L_DATA Get_Current_Item() {
        return current->item;
    }
    void Set_Current(DLItem *c) {
        current = c;
    }
    void Set_Status(bool s) {
        end_reached = s;
    }
    bool Swap(DLList_Iter);  //swapt die beiden Elemente, wenn sie in der gleichen Liste stehen!!

};

//#####################################################################################################
struct RGBcolor {
    unsigned int red;
    unsigned int green;
    unsigned int blue;
    char pajek_c[20];
};
//-------------------------------------------------------------------------------

class NLink;

class NNode {
    friend class NLink;
private :
    unsigned long index;
    unsigned long cluster_index;
    unsigned long marker, affiliations;
    unsigned long *state_history;
    unsigned int max_states;
    long distance;
    double clustering;
    double weight;
    double affinity;
//    double old_weight;

    DLList *neighbours;    //list with pointers to neighbours
    DLList *n_links;
    DLList *global_link_list;
    char name[255];
    RGBcolor color;
public :
    NNode(unsigned long, unsigned long, DLList*, const char*, int);
    ~NNode();
    unsigned long Get_Index()  {
        return (index);
    }
    unsigned long Get_ClusterIndex() {
        return (cluster_index);
    }
    unsigned long Get_Marker() {
        return marker;
    }
    void Set_Marker(unsigned long m) {
        marker = m;
    }
    unsigned long Get_Affiliations() {
        return affiliations;
    }
    void Set_Affiliations(unsigned long m) {
        affiliations = m;
    }
    void Set_ClusterIndex(unsigned long ci) {
        cluster_index = ci;
    }
    void Set_Index(unsigned long i) {
        index = i;
    }
    unsigned long Get_Degree() {
        return (neighbours->Size());
    }
    char *Get_Name() {
        return name;
    }
    void Set_Name(char* n) {
        strcpy(name, n);
    }
    double Get_Links_Among_Neigbours();
    double Get_Clustering();
    double Get_Weight() {
        return weight;
    }
    double Get_Affinity() {
        return affinity;
    }
    unsigned long *Get_StateHistory() {
        return state_history;
    }
    void Add_StateHistory(unsigned int q);
    //  double Get_OldWeight() {return old_weight;}
    void Set_Weight(double w) {
        weight = w;
    }
    void Set_Affinity(double w) {
        affinity = w;
    }

    //  void Set_OldWeight(double w) {old_weight=w;}
    long Get_Distance() {
        return distance;
    }
    void Set_Distance(long d) {
        distance = d;
    }
    int  Connect_To(NNode*, double);
    DLList *Get_Neighbours() {
        return neighbours;
    }
    DLList *Get_Links() {
        return n_links;
    }
    int  Disconnect_From(NNode*);
    int  Disconnect_From_All();
    bool Is_Linked_To(NNode*);
    RGBcolor Get_Color() {
        return color;
    }
    void Set_Color(RGBcolor c);
    NLink *Get_LinkToNeighbour(NNode *neighbour);
};

//#####################################################################################################

class NLink {
    friend class NNode;
private :
    NNode *start;
    NNode *end;
    double weight;
    double old_weight;
    unsigned long index;
    unsigned long marker;
public :
    NLink( NNode*, NNode*, double);
    ~NLink();
    unsigned long Get_Start_Index()  {
        return (start->Get_Index());
    }
    unsigned long Get_End_Index()    {
        return (end->Get_Index());
    }
    NNode *Get_Start() {
        return (start);
    }
    NNode *Get_End() {
        return (end);
    }
    double Get_Weight() {
        return weight;
    }
    void Set_Weight(double w) {
        weight = w;
    }
    double Get_OldWeight() {
        return old_weight;
    }
    void Set_OldWeight(double w) {
        old_weight = w;
    }
    unsigned long Get_Marker() {
        return marker;
    }
    void Set_Marker(unsigned long m) {
        marker = m;
    }
    unsigned long Get_Index() {
        return index;
    }
    void Set_Index(unsigned long i) {
        index = i;
    }
};

//#####################################################################################################

template   class ClusterList : public DLList {
    friend class DLList_Iter;
private:
    long links_out_of_cluster;
    unsigned long links_inside_cluster;
    unsigned long frequency;
    double cluster_energy;
    DLList *candidates;
    long marker;
public:
    ClusterList();
    ~ClusterList();
    long Get_Links_OOC() {
        return (links_out_of_cluster);
    }
    void Set_Links_OOC(long looc) {
        links_out_of_cluster = looc;
    }
    unsigned long Get_Links_IC() {
        return (links_inside_cluster);
    }
    unsigned long Get_Frequency() {
        return (frequency);
    }
    void IncreaseFrequency() {
        frequency++;
    }
    void Set_Links_IC(unsigned long lic) {
        links_inside_cluster = lic;
    }
    double Get_Energy() {
        return (cluster_energy);
    }
    void Set_Energy(double e) {
        cluster_energy = e;
    }
    DLList *Get_Candidates() {
        return candidates;
    }
    bool operator<(ClusterList &b);
    bool operator==(ClusterList  &b);
    long Get_Marker() {
        return marker;
    }
    void Set_Marker(long m) {
        marker = m;
    }
};
//#####################################################################################################
template 
class DL_Node_List : virtual public DL_Indexed_List {
    friend class DLList_Iter;
private:
    DLItem *pInsert(NNode*, DLItem*);
    NNode* pDelete(DLItem*);
    HugeArray*> array;
    unsigned long last_index;
public:
    DL_Node_List();
    ~DL_Node_List();
    NNode* Push(NNode*);
    NNode* Pop();
    NNode* Get(unsigned long);
    int Delete(unsigned long);

};
//#####################################################################################################



struct cluster_join_move {
    ClusterList *c1;
    ClusterList *c2;
    double joint_energy;
    long joint_looc;
    unsigned long joint_lic;
} ;

struct network {
    DL_Indexed_List *node_list;
    DL_Indexed_List *link_list;
    DL_Indexed_List*> *cluster_list;
    // DL_Indexed_List *moveset;
    unsigned long max_k;
    unsigned long min_k;
    unsigned long diameter;
    double av_weight;
    double max_weight;
    double min_weight;
    double sum_weights;
    double av_k;
    double av_bids;
    unsigned long max_bids;
    unsigned long min_bids;
    unsigned long sum_bids;

    network() {
        node_list   = new DL_Indexed_List();
        link_list   = new DL_Indexed_List();
        cluster_list = new DL_Indexed_List*>();
    }

    ~network() {
        ClusterList *cl_cur;

        while (link_list->Size()) {
            delete link_list->Pop();
        }
        while (node_list->Size()) {
            delete node_list->Pop();
        }
        while (cluster_list->Size()) {
            cl_cur = cluster_list->Pop();
            while (cl_cur->Size()) {
                cl_cur->Pop();
            }
            delete cl_cur;
        }
        delete link_list;
        delete node_list;
        delete cluster_list;
    }
};

/*
struct network
{
  DLList *node_list;
  DLList *link_list;
  DLList*> *cluster_list;
  DLList *moveset;
} ;
*/

template 
HugeArray::HugeArray() {
    max_bit_left = 1UL << 31; //wir setzen das 31. Bit auf 1
    size = 2;
    max_index = 0;
    highest_field_index = 0;
    data = new DATA[2]; //ein extra Platz fuer das Nullelement
    data[0] = 0;
    data[1] = 0;
    for (int i = 0; i < 32; i++) {
        fields[i] = NULL;
    }
    fields[highest_field_index] = data;
}

template  HugeArray::~HugeArray() {
    for (unsigned int i = 0; i <= highest_field_index; i++) {
        data = fields[i];
        delete [] data;
    }
}

template 
HUGE_INDEX HugeArray::get_huge_index(unsigned long index) {
    HUGE_INDEX h_index;
    unsigned int shift_index = 0;
    unsigned long help_index;
    help_index = index;
    if (index < 2) {
        h_index.field_index = 0;
        h_index.in_field_index = index;
        return h_index;
    }
    // wie oft muessen wir help_index nach links shiften, damit das 31. Bit gesetzt ist??
    while (!(max_bit_left & help_index)) {
        help_index <<= 1;
        shift_index++;
    }
    h_index.field_index = 31 - shift_index;   // das hoechste  besetzte Bit im Index
    help_index = 1UL << h_index.field_index;  // in help_index wird das hoechste besetzte Bit von Index gesetzt
    h_index.in_field_index = (index ^ help_index); // index XOR help_index, womit alle bits unter dem hoechsten erhalten bleiben
    return h_index;
}

template 
DATA &HugeArray::Set(unsigned long int index) {
    HUGE_INDEX h_index;
    unsigned long data_size;
    while (size < index + 1) {
        highest_field_index++;
        data_size = 1UL << highest_field_index;
        data = new DATA[data_size];
        for (unsigned long i = 0; i < data_size; i++) {
            data[i] = 0;
        }
        size = size + data_size; //overflow noch abfangen
        //printf("Vergroesserung auf: %u bei index %u\n",size,index);
        fields[highest_field_index] = data;
    }
    h_index = get_huge_index(index);
//printf("index %lu = %lu . %lu\n",index,h_index.field_index,h_index.in_field_index);
    data = fields[h_index.field_index];
    if (max_index < index) {
        max_index = index;
    }
    return (data[h_index.in_field_index]);
}

template 
DATA HugeArray::Get(unsigned long index) {
    return (Set(index));
}


template 
DATA &HugeArray::operator[](unsigned long index) {
    return (Set(index));
}


//###############################################################################
template 
DLItem::DLItem(L_DATA i, unsigned long ind) : item(i), index(ind), previous(0), next(0) {
}

template 
DLItem::DLItem(L_DATA i, unsigned long ind, DLItem *p, DLItem *n) : item(i), index(ind), previous(p), next(n) {
}

template 
DLItem::~DLItem() {
//delete item;      //eigentlich muessten wir pruefen, ob item ueberhaupt ein Pointer ist...
//previous=NULL;
//next=NULL;
}


//######################################################################################################################
template 
DLList::DLList() {
    head = tail = NULL;
    number_of_items = 0;
    head = new DLItem(NULL, 0); //fuer head und Tail gibt es das gleiche Array-Element!! Vorsicht!!
    tail = new DLItem(NULL, 0);
    if ( !head || !tail ) {
        if (head) {
            delete (head);
        }
        if (tail) {
            delete (tail);
        }
        return;
    }  else {
        head->next = tail;
        tail->previous = head;
    }
}

template 
DLList::~DLList() {
    DLItem *cur = head, *next;
    while (cur) {
        next = cur->next;
        delete (cur);
        cur = next;
    }
    number_of_items = 0;
    //  printf("Liste Zerstoert!\n");
}

template 
void DLList::delete_items() {
    DLItem *cur, *next;
    cur = this->head;
    while (cur) {
        next = cur->next;
        cur->del();
        cur = next;
    }
    this->number_of_items = 0;
}

//privates Insert
template 
DLItem *DLList::pInsert(L_DATA data, DLItem *pos) {
    DLItem *i = new DLItem(data, number_of_items + 1, pos->previous, pos);
    if (i) {
        pos->previous->next = i;
        pos->previous = i;
        number_of_items++;
        return (i);
    } else {
        return (0);
    }
}
//privates delete
template 
L_DATA DLList::pDelete(DLItem *i) {
    L_DATA data = i->item;
    i->previous->next = i->next;
    i->next->previous = i->previous;
//  array[i->index]=0;
    delete (i);
    number_of_items--;
    return (data);
}
//oeffentliches Insert
template 
int DLList::Insert(L_DATA data, unsigned long pos) {
    if ((pos < 0) || (pos > (number_of_items))) {
        return (0);
    }
    DLItem *cur = head;
    while (pos--) {
        cur = cur->next;
    }
    return (pInsert(data, cur) != 0);
}
//oeffentliche Delete
template 
int DLList::Delete(unsigned long pos) {
    if ((pos < 0) || (pos > (number_of_items))) {
        return (0);
    }
    DLItem *cur = head;
    while (pos--) {
        cur = cur->next;
    }
    return (pDelete(cur) != 0);
}

//oeffentliche Delete
template 
int DLList::fDelete(L_DATA data) {
    if ((number_of_items == 0) || (!data)) {
        return (0);
    }
    DLItem *cur;
    cur = head->next;
    while ((cur != tail) && (cur->item != data)) {
        cur = cur->next;
    }
    if (cur != tail) {
        return (pDelete(cur) != 0);
    }
    return (0);
}

template 
L_DATA DLList::Push(L_DATA data) {
    DLItem *tmp;
    tmp = pInsert(data, tail);
    if (tmp) {
        return (tmp->item);
    }
    return (0);
}

template 
L_DATA DLList::Pop() {
    return (pDelete(tail->previous));
}


template 
L_DATA DLList::Get(unsigned long pos) {
    if ((pos < 1) || (pos > (number_of_items + 1))) {
        return (0);
    }
//  return(array[pos]->item);
    DLItem *cur = head;
    while (pos--) {
        cur = cur->next;
    }
    return (cur->item);
}


template 
int DLList::Enqueue(L_DATA data) {
    return (pInsert(data, tail) != 0);
}

template 
L_DATA DLList::Dequeue() {
    return (pDelete(head->next));
}

//gibt Index des gesuchte Listenelement zurueck, besser waere eigentlich zeiger
template 
unsigned long DLList::Is_In_List(L_DATA data) {
    DLItem *cur = head, *next;
    unsigned long pos = 0;
    while (cur) {
        next = cur->next;
        if (cur->item == data) {
            return (pos) ;
        }
        cur = next;
        pos++;
    }
    return (0);
}

//######################################################################################################################
template 
DL_Indexed_List::DL_Indexed_List() : DLList() {
    last_index = 0;
}

template 
DL_Indexed_List::~DL_Indexed_List() {
    /* This is already done by the DLList destructor */
    /*   DLItem *cur, *next; */
    /*   cur=this->head; */
    /*   while (cur) */
    /*     { */
    /*       next=cur->next; */
    /*       delete(cur); */
    /*       cur=next; */
    /*     } */
    /*     this->number_of_items=0; */
    //  printf("Liste Zerstoert!\n");
}

//privates Insert
template 
DLItem *DL_Indexed_List::pInsert(L_DATA data, DLItem *pos) {
    DLItem *i = new DLItem(data, last_index, pos->previous, pos);
    if (i) {
        pos->previous->next = i;
        pos->previous = i;
        this->number_of_items++;
        array[last_index] = i;
        last_index++;
        return (i);
    } else {
        return (0);
    }
}
//privates delete
template 
L_DATA DL_Indexed_List::pDelete(DLItem *i) {
    L_DATA data = i->item;
    i->previous->next = i->next;
    i->next->previous = i->previous;
    array[i->index] = 0;
    last_index = i->index;
    delete (i);
    this->number_of_items--;
    return (data);
}
template 
L_DATA DL_Indexed_List::Push(L_DATA data) {
    DLItem *tmp;
    tmp = pInsert(data, this->tail);
    if (tmp) {
        return (tmp->item);
    }
    return (0);
}

template 
L_DATA DL_Indexed_List::Pop() {
    return (pDelete(this->tail->previous));
}

template 
L_DATA DL_Indexed_List::Get(unsigned long pos) {
    if (pos > this->number_of_items - 1) {
        return (0);
    }
    return (array[pos]->item);
}

//#######################################################################################

//************************************************************************************************************
template 
ClusterList::ClusterList() : DLList() {
    links_out_of_cluster = 0;
    links_inside_cluster = 0;
    frequency = 1;
    cluster_energy = 1e30;
    candidates = new DLList();
    marker = 0;
}

template 
ClusterList::~ClusterList() {
    while (candidates->Size()) {
        candidates->Pop();
    }
    delete candidates;
}


template 
bool ClusterList::operator==(ClusterList &b) {
    bool found = false;
    L_DATA n_cur, n_cur_b;
    DLList_Iter a_iter, b_iter;

    if (this->Size() != b.Size()) {
        return false;
    }

    n_cur = a_iter.First(this);
    while (!(a_iter.End())) {
        found = false;
        n_cur_b = b_iter.First(&b);
        while (!(b_iter.End()) && !found) {
            if (n_cur == n_cur_b) {
                found = true;
            }
            n_cur_b = b_iter.Next();
        }
        if (!found) {
            return false;
        }
        n_cur = a_iter.Next();
    }
    return (found);
}
//A
bool ClusterList::operator<(ClusterList &b) {
    bool found = false;
    L_DATA n_cur, n_cur_b;
    DLList_Iter a_iter, b_iter;

    if (this->Size() >= b.Size()) {
        return false;
    }
    n_cur = a_iter.First(this);
    while (!(a_iter.End())) {
        found = false;
        n_cur_b = b_iter.First(&b);
        while (!(b_iter.End()) && !found) {
            if (n_cur == n_cur_b) {
                found = true;
            }
            n_cur_b = b_iter.Next();
        }
        if (!found) {
            return false;
        }
        n_cur = a_iter.Next();
    }
    return (found);
}

//#####################################################################################
template 
DLList_Iter::DLList_Iter() {
    list = NULL;
    current = NULL;
    end_reached = true;
}

template 
L_DATA DLList_Iter::Next() {
    current = current->next;
    if (current == (list->tail)) {
        end_reached = true;
    }
    return (current->item);
}

template 
L_DATA DLList_Iter::Previous() {
    current = current->previous;
    if (current == (list->head)) {
        end_reached = true;
    }
    return (current->item);
}

template 
L_DATA DLList_Iter::First(DLList *l) {
    list = l;
    current = list->head->next;
    if (current == (list->tail)) {
        end_reached = true;
    } else {
        end_reached = false;
    }
    return (current->item);
}

template 
L_DATA DLList_Iter::Last(DLList *l) {
    list = l;
    current = list->tail->previous;
    if (current == (list->head)) {
        end_reached = true;    // falls die List leer ist
    } else {
        end_reached = false;
    }
    return (current->item);
}

template 
bool DLList_Iter::Swap(DLList_Iter b) {
    L_DATA h;
    if (list != b.list) {
        return false;    //elemeten muessen aus der gleichen List stammen
    }
    if (end_reached || b.end_reached) {
        return false;
    }
    h = current->item; current->item = b.current->item; b.current->item = h;
    return true;
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/NetRoutines.cpp0000644000175100001710000002324100000000000027455 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   The original copyright notice follows here */

/***************************************************************************
                          NetRoutines.cpp  -  description
                             -------------------
    begin                : Tue Oct 28 2003
    copyright            : (C) 2003 by Joerg Reichardt
    email                : reichardt@mitte
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "NetRoutines.h"
#include "NetDataTypes.h"

#include "igraph_types.h"
#include "igraph_interface.h"
#include "igraph_conversion.h"

int igraph_i_read_network(const igraph_t *graph,
                          const igraph_vector_t *weights,
                          network *net, igraph_bool_t use_weights,
                          unsigned int states) {

    double av_k = 0.0, sum_weight = 0.0, min_weight = 1e60, max_weight = -1e60;
    unsigned long min_k = 999999999, max_k = 0;
    char name[255];
    NNode *node1, *node2;
    DLList_Iter iter;
    igraph_vector_t edgelist;
    long int no_of_nodes = (long int) igraph_vcount(graph);
    long int no_of_edges = (long int) igraph_ecount(graph);
    long int ii;
    const char *empty = "";

    IGRAPH_VECTOR_INIT_FINALLY(&edgelist, no_of_edges * 2);
    IGRAPH_CHECK(igraph_get_edgelist(graph, &edgelist, 0 /* rowwise */));

    for (ii = 0; ii < no_of_nodes; ii++) {
        net->node_list->Push(new NNode(ii, 0, net->link_list, empty, states));
    }

    for (ii = 0; ii < no_of_edges; ii++) {
        long int i1 = (long int)VECTOR(edgelist)[2 * ii];
        long int i2 = (long int)VECTOR(edgelist)[2 * ii + 1];
        igraph_real_t Links;
        if (use_weights) {
            Links = VECTOR(*weights)[ii];
        } else {
            Links = 1.0;
        }

        node1 = net->node_list->Get(i1);
        sprintf(name, "%li", i1+1);
        node1->Set_Name(name);

        node2 = net->node_list->Get(i2);
        sprintf(name, "%li", i2+1);
        node2->Set_Name(name);

        node1->Connect_To(node2, Links);

        if (Links < min_weight) {
            min_weight = Links;
        }
        if (Links > max_weight) {
            max_weight = Links;
        }
        sum_weight += Links;
    }

    IGRAPH_FINALLY_CLEAN(1);
    igraph_vector_destroy(&edgelist);

    node1 = iter.First(net->node_list);
    while (!iter.End()) {
        if (node1->Get_Degree() > max_k) {
            max_k = node1->Get_Degree();
        }
        if (node1->Get_Degree() < min_k) {
            min_k = node1->Get_Degree();
        }
        av_k += node1->Get_Degree();
        node1 = iter.Next();
    }
    net->av_k = av_k / double(net->node_list->Size());
    net->sum_weights = sum_weight;
    net->av_weight = sum_weight / double(net->link_list->Size());
    net->min_k = min_k;
    net->max_k = max_k;
    net->min_weight = min_weight;
    net->max_weight = max_weight;
    net->sum_bids = 0;
    net->min_bids = 0;
    net->max_bids = 0;

    return IGRAPH_SUCCESS;
}

//###############################################################################################################
void reduce_cliques(DLList*> *global_cluster_list, FILE *file) {
    unsigned long size;
    ClusterList *c_cur, *largest_c = NULL;
    DLList*> *subsets;
    DLList_Iter*> c_iter, sub_iter;
    DLList_Iter iter;
    NNode *n_cur;

    if (!(global_cluster_list->Size())) {
        return;
    }
    //wir suchen den groessten Cluster

    c_cur = c_iter.First(global_cluster_list);
    size = 0;
    while (!(c_iter.End())) {
        if (c_cur->Size() > size) {
            size = c_cur->Size();
            largest_c = c_cur;
        }
        c_cur = c_iter.Next();
    }
// printf("Groesster Cluster hat %u Elemente.\n",largest_c->Size());

    //Schauen, ob es Teilmengen gibt, die ebenfalls gefunden wurden
    subsets = new DLList*>();
    c_cur = c_iter.First(global_cluster_list);
    while (!(c_iter.End())) {
        if ((*c_cur < *largest_c || *c_cur == *largest_c) && c_cur != largest_c) { //alle echten Teilcluster von largest_c und die doppelten
            subsets->Push(c_cur);
        }
        c_cur = c_iter.Next();
    }
    // die gefundenen Subsets werden aus der cluster_liste geloescht
    while (subsets->Size()) {
        global_cluster_list->fDelete(subsets->Pop());
    }
    delete subsets;
    // Dann schreiben wir den groessten Cluster in das File
    fprintf(file, "Energie: %1.12f   Nodes:%3lu    -   ", largest_c->Get_Energy(), largest_c->Size());

    n_cur = iter.First(largest_c);
    while (!(iter.End())) {
        fprintf(file, "%s", n_cur->Get_Name());
        n_cur = iter.Next();
        if (n_cur) {
            fprintf(file, ", ");
        }
    }
    fprintf(file, "\n");


    //Schliesslich schmeissen wir noch den eben gefundenen groessten Cluster raus
    global_cluster_list->fDelete(largest_c);
    //und dann geht es von vorn mit der Reduzierten ClusterListe los
    reduce_cliques(global_cluster_list, file);

}
//##################################################################################
void reduce_cliques2(network *net, bool only_double, long marker) {
    unsigned long size;
    ClusterList *c_cur, *largest_c = NULL;
    DLList_Iter*> c_iter;
    do {
        //wir suchen den groessten, nicht markierten Cluster
        size = 0;
        c_cur = c_iter.First(net->cluster_list);
        while (!(c_iter.End())) {
            if ((c_cur->Size() > size) && (c_cur->Get_Marker() != marker)) {
                size = c_cur->Size();
                largest_c = c_cur;
            }
            c_cur = c_iter.Next();
        }
        // printf("Groesster Cluster hat %u Elemente.\n",largest_c->Size());
        //Schauen, ob es Teilmengen gibt, die ebenfalls gefunden wurden
        c_cur = c_iter.First(net->cluster_list);
        while (!(c_iter.End())) {
            if (((!only_double && (*c_cur < *largest_c)) || (*c_cur == *largest_c)) && (c_cur != largest_c)) { //alle echten Teilcluster von largest_c und die doppelten
                net->cluster_list->fDelete(c_cur);
                while (c_cur->Get_Candidates()->Size()) {
                    c_cur->Get_Candidates()->Pop();
                }
                while (c_cur->Size()) {
                    c_cur->Pop();    // die knoten aber nicht loeschen!!
                }
                delete c_cur;    // nicht vergessen, die global geloeschte Clusterliste zu loeschen
            }
            c_cur = c_iter.Next();
        }
        //Schliesslich markieren wir noch den eben gefundenen groessten Cluster
        largest_c->Set_Marker(marker);
    } while (size);
}

//##################################################################################################
unsigned long iterate_nsf_hierarchy(NNode *parent, unsigned long depth, FILE *file) {
    NNode* next_node;
    unsigned long newdepth, maxdepth;
    bool first = true;
    DLList_Iter *iter;
    maxdepth = newdepth = depth;
    iter = new DLList_Iter;
    next_node = iter->First(parent->Get_Neighbours());
    while (!(iter->End())) {
        if (next_node->Get_Marker() > parent->Get_Marker()) { // wir gehen nach unten
            if (first) {
                fprintf(file, ",(");    // eine Neue Klammer auf
            }
            if (first) {
                fprintf(file, "%s", next_node->Get_Name());    // nur vor dem ersten kein Komma
            } else {
                fprintf(file, ",%s", next_node->Get_Name());    // sonst immer mit Komma
            }
            first = false;
            newdepth = iterate_nsf_hierarchy(next_node, depth + 1, file);
            if (maxdepth < newdepth) {
                maxdepth = newdepth;
            }
        }
        next_node = iter->Next();
    }
    if (!first) {
        fprintf(file, ")");    //hat es ueberhaupt einen gegeben?
    }
    //dann klamer zu!
    delete iter;
    return maxdepth;
}

//################################################################
void clear_all_markers(network *net) {
    DLList_Iter iter;
    NNode *n_cur;
    n_cur = iter.First(net->node_list);
    while (!iter.End()) {
        n_cur->Set_Marker(0);
        n_cur = iter.Next();
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/NetRoutines.h0000644000175100001710000000473300000000000027127 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   The original copyright notice follows here */

/***************************************************************************
                          NetRoutines.h  -  description
                             -------------------
    begin                : Tue Oct 28 2003
    copyright            : (C) 2003 by Joerg Reichardt
    email                : reichardt@mitte
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef NETROUTINES_H
#define NETROUTINES_H

#include "NetDataTypes.h"
#include "igraph_types.h"
#include "igraph_datatype.h"

int igraph_i_read_network(const igraph_t *graph,
                          const igraph_vector_t *weights,
                          network *net, igraph_bool_t use_weights,
                          unsigned int states);

void reduce_cliques(DLList*>*, FILE *file);
void reduce_cliques2(network*, bool,  long );
void clear_all_markers(network *net);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/clustertool.cpp0000644000175100001710000006257000000000000027565 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Joerg Reichardt
   The original copyright notice follows here */

/***************************************************************************
                          main.cpp  -  description
                             -------------------
    begin                : Tue Jul 13 11:26:47 CEST 2004
    copyright            : (C) 2004 by
    email                :
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "NetDataTypes.h"
#include "NetRoutines.h"
#include "pottsmodel_2.h"

#include "igraph_community.h"
#include "igraph_error.h"
#include "igraph_random.h"
#include "core/math.h"
#include "igraph_interface.h"
#include "igraph_components.h"
#include "core/interruption.h"
#include "core/exceptions.h"

static int igraph_i_community_spinglass_orig(
        const igraph_t *graph,
        const igraph_vector_t *weights,
        igraph_real_t *modularity,
        igraph_real_t *temperature,
        igraph_vector_t *membership,
        igraph_vector_t *csize,
        igraph_integer_t spins,
        igraph_bool_t parupdate,
        igraph_real_t starttemp,
        igraph_real_t stoptemp,
        igraph_real_t coolfact,
        igraph_spincomm_update_t update_rule,
        igraph_real_t gamma);

static int igraph_i_community_spinglass_negative(
        const igraph_t *graph,
        const igraph_vector_t *weights,
        igraph_real_t *modularity,
        igraph_real_t *temperature,
        igraph_vector_t *membership,
        igraph_vector_t *csize,
        igraph_integer_t spins,
        igraph_bool_t parupdate,
        igraph_real_t starttemp,
        igraph_real_t stoptemp,
        igraph_real_t coolfact,
        igraph_spincomm_update_t update_rule,
        igraph_real_t gamma,
        /* igraph_matrix_t *adhesion, */
        /* igraph_matrix_t *normalised_adhesion, */
        /* igraph_real_t *polarization, */
        igraph_real_t gamma_minus);

/**
 * \function igraph_community_spinglass
 * \brief Community detection based on statistical mechanics
 *
 * This function implements the community structure detection
 * algorithm proposed by Joerg Reichardt and Stefan Bornholdt.
 * The algorithm is described in their paper: Statistical Mechanics of
 * Community Detection, http://arxiv.org/abs/cond-mat/0603718 .
 *
 * 
 * From version 0.6, igraph also supports an extension to
 * the algorithm that allows negative edge weights. This is described
 * in  V. A. Traag and Jeroen Bruggeman: Community detection in networks
 * with positive and negative links, http://arxiv.org/abs/0811.2329 .
 *
 * \param graph The input graph, it may be directed but the direction
 *     of the edges is not used in the algorithm.
 * \param weights The vector giving the edge weights, it may be \c NULL,
 *     in which case all edges are weighted equally. The edge weights
 *     must be positive unless using the \c IGRAPH_SPINCOMM_IMP_NEG
 *     implementation. This condition is not verified by the function.
 * \param modularity Pointer to a real number, if not \c NULL then the
 *     modularity score of the solution will be stored here. This is the
 *     gereralized modularity that simplifies to the one defined in
 *     M. E. J. Newman and M. Girvan, Phys. Rev. E 69, 026113 (2004),
 *     if the gamma parameter is one.
 * \param temperature Pointer to a real number, if not \c NULL then
 *     the temperature at the end of the algorithm will be stored
 *     here.
 * \param membership Pointer to an initialized vector or \c NULL. If
 *     not \c NULL then the result of the clustering will be stored
 *     here. For each vertex, the number of its cluster is given, with the
 *     first cluster numbered zero. The vector will be resized as
 *     needed.
 * \param csize Pointer to an initialized vector or \c NULL. If not \c
 *     NULL then the sizes of the clusters will stored here in cluster
 *     number order. The vector will be resized as needed.
 * \param spins Integer giving the number of spins, i.e. the maximum
 *     number of clusters. Usually it is not a program to give a high
 *     number here, the default was 25 in the original code. Even if
 *     the number of spins is high the number of clusters in the
 *     result might be small.
 * \param parupdate A logical constant, whether to update all spins in
 *     parallel. The default for this argument was \c FALSE (i.e. 0) in
 *     the original code. It is not implemented in the \c
 *     IGRAPH_SPINCOMM_INP_NEG implementation.
 * \param starttemp Real number, the temperature at the start. The
 *     value of this argument was 1.0 in the original code.
 * \param stoptemp Real number, the algorithm stops at this
 *     temperature. The default was 0.01 in the original code.
 * \param coolfact Real number, the cooling factor for the simulated
 *     annealing. The default was 0.99 in the original code.
 * \param update_rule The type of the update rule. Possible values: \c
 *     IGRAPH_SPINCOMM_UPDATE_SIMPLE and \c
 *     IGRAPH_SPINCOMM_UPDATE_CONFIG. Basically this parameter defines
 *     the null model based on which the actual clustering is done. If
 *     this is \c IGRAPH_SPINCOMM_UPDATE_SIMPLE then the random graph
 *     (i.e. G(n,p)), if it is \c IGRAPH_SPINCOMM_UPDATE then the
 *     configuration model is used. The configuration means that the
 *     baseline for the clustering is a random graph with the same
 *     degree distribution as the input graph.
 * \param gamma Real number. The gamma parameter of the
 *     algorithm. This defines the weight of the missing and existing
 *     links in the quality function for the clustering. The default
 *     value in the original code was 1.0, which is equal weight to
 *     missing and existing edges. Smaller values make the existing
 *     links contibute more to the energy function which is minimized
 *     in the algorithm. Bigger values make the missing links more
 *     important. (If my understanding is correct.)
 * \param implementation Constant, chooses between the two
 *     implementations of the spin-glass algorithm that are included
 *     in igraph. \c IGRAPH_SPINCOMM_IMP_ORIG selects the original
 *     implementation, this is faster, \c IGRAPH_SPINCOMM_INP_NEG selects
 *     a new implementation by Vincent Traag that allows negative edge
 *     weights.
 * \param gamma_minus Real number. Parameter for the \c
 *     IGRAPH_SPINCOMM_IMP_NEG implementation. This
 *     specifies the balance between the importance of present and
 *     non-present negative weighted edges in a community. Smaller values of
 *     \p gamma_minus lead to communities with lesser
 *     negative intra-connectivity.
 *     If this argument is set to zero, the algorithm reduces to a graph
 *     coloring algorithm, using the number of spins as the number of
 *     colors.
 * \return Error code.
 *
 * \sa igraph_community_spinglass_single() for calculating the community
 * of a single vertex.
 *
 * Time complexity: TODO.
 *
 */

int igraph_community_spinglass(const igraph_t *graph,
                               const igraph_vector_t *weights,
                               igraph_real_t *modularity,
                               igraph_real_t *temperature,
                               igraph_vector_t *membership,
                               igraph_vector_t *csize,
                               igraph_integer_t spins,
                               igraph_bool_t parupdate,
                               igraph_real_t starttemp,
                               igraph_real_t stoptemp,
                               igraph_real_t coolfact,
                               igraph_spincomm_update_t update_rule,
                               igraph_real_t gamma,
                               /* the rest is for the NegSpin implementation */
                               igraph_spinglass_implementation_t implementation,
                               /*                 igraph_matrix_t *adhesion, */
                               /*                 igraph_matrix_t *normalised_adhesion, */
                               /*                 igraph_real_t *polarization, */
                               igraph_real_t gamma_minus) {

    IGRAPH_HANDLE_EXCEPTIONS(
        switch (implementation) {
        case IGRAPH_SPINCOMM_IMP_ORIG:
            return igraph_i_community_spinglass_orig(graph, weights, modularity,
                    temperature, membership, csize,
                    spins, parupdate, starttemp,
                    stoptemp, coolfact, update_rule,
                    gamma);
            break;
        case IGRAPH_SPINCOMM_IMP_NEG:
            return igraph_i_community_spinglass_negative(graph, weights, modularity,
                    temperature, membership, csize,
                    spins, parupdate, starttemp,
                    stoptemp, coolfact,
                    update_rule, gamma,
                    /*                       adhesion, normalised_adhesion, */
                    /*                       polarization, */
                    gamma_minus);
            break;
        default:
            IGRAPH_ERROR("Unknown `implementation' in spinglass community finding",
                         IGRAPH_EINVAL);
        }
    );
}

static int igraph_i_community_spinglass_orig(
        const igraph_t *graph,
        const igraph_vector_t *weights,
        igraph_real_t *modularity,
        igraph_real_t *temperature,
        igraph_vector_t *membership,
        igraph_vector_t *csize,
        igraph_integer_t spins,
        igraph_bool_t parupdate,
        igraph_real_t starttemp,
        igraph_real_t stoptemp,
        igraph_real_t coolfact,
        igraph_spincomm_update_t update_rule,
        igraph_real_t gamma) {

    long int no_of_nodes = igraph_vcount(graph);
    unsigned long changes, runs;
    igraph_bool_t use_weights = 0;
    bool zeroT;
    double kT, acc, prob;

    /* Check arguments */

    if (spins < 2) {
        IGRAPH_ERROR("Number of spins must be at least 2", IGRAPH_EINVAL);
    }
    if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
        update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
        IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
    }
    if (weights) {
        if (igraph_vector_size(weights) != igraph_ecount(graph)) {
            IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
        }
        use_weights = 1;
    }
    if (coolfact < 0 || coolfact >= 1.0) {
        IGRAPH_ERROR("Invalid cooling factor", IGRAPH_EINVAL);
    }
    if (gamma < 0.0) {
        IGRAPH_ERROR("Invalid gamma value", IGRAPH_EINVAL);
    }
    if (starttemp / stoptemp < 1.0) {
        IGRAPH_ERROR("starttemp should be larger in absolute value than stoptemp",
                     IGRAPH_EINVAL);
    }

    /* The spinglass algorithm does not handle the trivial cases of the
       null and singleton graphs, so we catch them here. */
    if (no_of_nodes < 2) {
        if (membership) {
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 0);
        }
        if (modularity) {
            IGRAPH_CHECK(igraph_modularity(graph, membership, 0, 1, igraph_is_directed(graph), modularity));
        }
        if (temperature) {
            *temperature = stoptemp;
        }
        if (csize) {
            /* 0 clusters for 0 nodes, 1 cluster for 1 node */
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 1);
        }
        return IGRAPH_SUCCESS;
    }

    /* Check whether we have a single component */
    igraph_bool_t conn;
    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
    if (!conn) {
        IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
    }

    network net;

    /* Transform the igraph_t */
    IGRAPH_CHECK(igraph_i_read_network(graph, weights,
                                       &net, use_weights, 0));

    prob = 2.0 * net.sum_weights / double(net.node_list->Size())
           / double(net.node_list->Size() - 1);

    PottsModel pm(&net, (unsigned int)spins, update_rule);

    /* initialize the random number generator */
    RNG_BEGIN();

    if ((stoptemp == 0.0) && (starttemp == 0.0)) {
        zeroT = true;
    } else {
        zeroT = false;
    }
    if (!zeroT) {
        kT = pm.FindStartTemp(gamma, prob, starttemp);
    } else {
        kT = stoptemp;
    }
    /* assign random initial configuration */
    pm.assign_initial_conf(-1);
    runs = 0;
    changes = 1;

    while (changes > 0 && (kT / stoptemp > 1.0 || (zeroT && runs < 150))) {

        IGRAPH_ALLOW_INTERRUPTION();

        runs++;
        if (!zeroT) {
            kT *= coolfact;
            if (parupdate) {
                changes = pm.HeatBathParallelLookup(gamma, prob, kT, 50);
            } else {
                acc = pm.HeatBathLookup(gamma, prob, kT, 50);
                if (acc < (1.0 - 1.0 / double(spins)) * 0.01) {
                    changes = 0;
                } else {
                    changes = 1;
                }
            }
        } else {
            if (parupdate) {
                changes = pm.HeatBathParallelLookupZeroTemp(gamma, prob, 50);
            } else {
                acc = pm.HeatBathLookupZeroTemp(gamma, prob, 50);
                /* less than 1 percent acceptance ratio */
                if (acc < (1.0 - 1.0 / double(spins)) * 0.01) {
                    changes = 0;
                } else {
                    changes = 1;
                }
            }
        }
    } /* while loop */

    pm.WriteClusters(modularity, temperature, csize, membership, kT, gamma);

    RNG_END();

    return 0;
}

/**
 * \function igraph_community_spinglass_single
 * \brief Community of a single node based on statistical mechanics
 *
 * This function implements the community structure detection
 * algorithm proposed by Joerg Reichardt and Stefan Bornholdt. It is
 * described in their paper: Statistical Mechanics of
 * Community Detection, http://arxiv.org/abs/cond-mat/0603718 .
 *
 * 
 * This function calculates the community of a single vertex without
 * calculating all the communities in the graph.
 *
 * \param graph The input graph, it may be directed but the direction
 *    of the edges is not used in the algorithm.
 * \param weights Pointer to a vector with the weights of the edges.
 *    Alternatively \c NULL can be supplied to have the same weight
 *    for every edge.
 * \param vertex The vertex id of the vertex of which ths community is
 *    calculated.
 * \param community Pointer to an initialized vector, the result, the
 *    ids of the vertices in the community of the input vertex will be
 *    stored here. The vector will be resized as needed.
 * \param cohesion Pointer to a real variable, if not \c NULL the
 *     cohesion index of the community will be stored here.
 * \param adhesion Pointer to a real variable, if not \c NULL the
 *     adhesion index of the community will be stored here.
 * \param inner_links Pointer to an integer, if not \c NULL the
 *     number of edges within the community is stored here.
 * \param outer_links Pointer to an integer, if not \c NULL the
 *     number of edges between the community and the rest of the graph
 *     will be stored here.
 * \param spins The number of spins to use, this can be higher than
 *    the actual number of clusters in the network, in which case some
 *    clusters will contain zero vertices.
 * \param update_rule The type of the update rule. Possible values: \c
 *     IGRAPH_SPINCOMM_UPDATE_SIMPLE and \c
 *     IGRAPH_SPINCOMM_UPDATE_CONFIG. Basically this parameter defined
 *     the null model based on which the actual clustering is done. If
 *     this is \c IGRAPH_SPINCOMM_UPDATE_SIMPLE then the random graph
 *     (ie. G(n,p)), if it is \c IGRAPH_SPINCOMM_UPDATE then the
 *     configuration model is used. The configuration means that the
 *     baseline for the clustering is a random graph with the same
 *     degree distribution as the input graph.
 * \param gamma Real number. The gamma parameter of the
 *     algorithm. This defined the weight of the missing and existing
 *     links in the quality function for the clustering. The default
 *     value in the original code was 1.0, which is equal weight to
 *     missing and existing edges. Smaller values make the existing
 *     links contibute more to the energy function which is minimized
 *     in the algorithm. Bigger values make the missing links more
 *     important. (If my understanding is correct.)
 * \return Error code.
 *
 * \sa igraph_community_spinglass() for the traditional version of the
 * algorithm.
 *
 * Time complexity: TODO.
 */

int igraph_community_spinglass_single(const igraph_t *graph,
                                      const igraph_vector_t *weights,
                                      igraph_integer_t vertex,
                                      igraph_vector_t *community,
                                      igraph_real_t *cohesion,
                                      igraph_real_t *adhesion,
                                      igraph_integer_t *inner_links,
                                      igraph_integer_t *outer_links,
                                      igraph_integer_t spins,
                                      igraph_spincomm_update_t update_rule,
                                      igraph_real_t gamma) {
    IGRAPH_HANDLE_EXCEPTIONS(
        igraph_bool_t use_weights = 0;
        double prob;
        char startnode[255];

        /* Check arguments */

        if (spins < 2) {
            IGRAPH_ERROR("Number of spins must be at least 2", IGRAPH_EINVAL);
        }
        if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
            update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
            IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
        }
        if (weights) {
            if (igraph_vector_size(weights) != igraph_ecount(graph)) {
                IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
            }
            use_weights = 1;
        }
        if (gamma < 0.0) {
            IGRAPH_ERROR("Invalid gamme value", IGRAPH_EINVAL);
        }
        if (vertex < 0 || vertex > igraph_vcount(graph)) {
            IGRAPH_ERROR("Invalid vertex id", IGRAPH_EINVAL);
        }

        /* Check whether we have a single component */
        igraph_bool_t conn;
        IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
        if (!conn) {
            IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
        }

        network net;

        /* Transform the igraph_t */
        IGRAPH_CHECK(igraph_i_read_network(graph, weights,
                                           &net, use_weights, 0));

        prob = 2.0 * net.sum_weights / double(net.node_list->Size())
               / double(net.node_list->Size() - 1);

        PottsModel pm(&net, (unsigned int)spins, update_rule);

        /* initialize the random number generator */
        RNG_BEGIN();

        /* to be exected, if we want to find the community around a particular node*/
        /* the initial conf is needed, because otherwise,
           the degree of the nodes is not in the weight property, stupid!!! */
        pm.assign_initial_conf(-1);
        snprintf(startnode, 255, "%li", (long int)vertex + 1);
        pm.FindCommunityFromStart(gamma, prob, startnode, community,
                                   cohesion, adhesion, inner_links, outer_links);

        RNG_END();
    );

    return 0;
}

static int igraph_i_community_spinglass_negative(
        const igraph_t *graph,
        const igraph_vector_t *weights,
        igraph_real_t *modularity,
        igraph_real_t *temperature,
        igraph_vector_t *membership,
        igraph_vector_t *csize,
        igraph_integer_t spins,
        igraph_bool_t parupdate,
        igraph_real_t starttemp,
        igraph_real_t stoptemp,
        igraph_real_t coolfact,
        igraph_spincomm_update_t update_rule,
        igraph_real_t gamma,
        /* igraph_matrix_t *adhesion, */
        /* igraph_matrix_t *normalised_adhesion, */
        /* igraph_real_t *polarization, */
        igraph_real_t gamma_minus) {

    long int no_of_nodes = igraph_vcount(graph);
    unsigned long changes, runs;
    igraph_bool_t use_weights = 0;
    bool zeroT;
    double kT, acc;
    igraph_real_t d_n;
    igraph_real_t d_p;

    /* Check arguments */

    if (parupdate) {
        IGRAPH_ERROR("Parallel spin update not implemented with "
                     "negative gamma", IGRAPH_UNIMPLEMENTED);
    }

    if (spins < 2) {
        IGRAPH_ERROR("Number of spins must be at least 2", IGRAPH_EINVAL);
    }
    if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
        update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
        IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
    }
    if (weights) {
        if (igraph_vector_size(weights) != igraph_ecount(graph)) {
            IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
        }
        use_weights = 1;
    }
    if (coolfact < 0 || coolfact >= 1.0) {
        IGRAPH_ERROR("Invalid cooling factor", IGRAPH_EINVAL);
    }
    if (gamma < 0.0) {
        IGRAPH_ERROR("Invalid gamma value", IGRAPH_EINVAL);
    }
    if (starttemp / stoptemp < 1.0) {
        IGRAPH_ERROR("starttemp should be larger in absolute value than stoptemp",
                     IGRAPH_EINVAL);
    }

    /* The spinglass algorithm does not handle the trivial cases of the
       null and singleton graphs, so we catch them here. */
    if (no_of_nodes < 2) {
        if (membership) {
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 0);
        }
        if (modularity) {
            IGRAPH_CHECK(igraph_modularity(graph, membership, 0, 1, igraph_is_directed(graph), modularity));
        }
        if (temperature) {
            *temperature = stoptemp;
        }
        if (csize) {
            /* 0 clusters for 0 nodes, 1 cluster for 1 node */
            IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
            igraph_vector_fill(membership, 1);
        }
        return IGRAPH_SUCCESS;
    }

    /* Check whether we have a single component */
    igraph_bool_t conn;
    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
    if (!conn) {
        IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
    }

    if (weights) {
        igraph_vector_minmax(weights, &d_n, &d_p);
    } else {
        d_n = d_p = 1;
    }

    if (d_n > 0) {
        d_n = 0;
    }
    if (d_p < 0) {
        d_p = 0;
    }
    d_n = -d_n;

    network net;

    /* Transform the igraph_t */
    IGRAPH_CHECK(igraph_i_read_network(graph, weights,
                                       &net, use_weights, 0));

    bool directed = igraph_is_directed(graph);

    PottsModelN pm(&net, (unsigned int)spins, directed);

    /* initialize the random number generator */
    RNG_BEGIN();

    if ((stoptemp == 0.0) && (starttemp == 0.0)) {
        zeroT = true;
    } else {
        zeroT = false;
    }

    //Begin at a high enough temperature
    kT = pm.FindStartTemp(gamma, gamma_minus, starttemp);

    /* assign random initial configuration */
    pm.assign_initial_conf(true);

    runs = 0;
    changes = 1;
    acc = 0;
    while (changes > 0 && (kT / stoptemp > 1.0 || (zeroT && runs < 150))) {

        IGRAPH_ALLOW_INTERRUPTION();

        runs++;
        kT = kT * coolfact;
        acc = pm.HeatBathLookup(gamma, gamma_minus, kT, 50);
        if (acc < (1.0 - 1.0 / double(spins)) * 0.001) {
            changes = 0;
        } else {
            changes = 1;
        }

    } /* while loop */

    /* These are needed, otherwise 'modularity' is not calculated */
    igraph_matrix_t adhesion, normalized_adhesion;
    igraph_real_t polarization;
    IGRAPH_MATRIX_INIT_FINALLY(&adhesion, 0, 0);
    IGRAPH_MATRIX_INIT_FINALLY(&normalized_adhesion, 0, 0);
    pm.WriteClusters(modularity, temperature, csize, membership,
                      &adhesion, &normalized_adhesion, &polarization,
                      kT, d_p, d_n, gamma, gamma_minus);
    igraph_matrix_destroy(&normalized_adhesion);
    igraph_matrix_destroy(&adhesion);
    IGRAPH_FINALLY_CLEAN(2);

    RNG_END();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/pottsmodel_2.cpp0000644000175100001710000024740300000000000027621 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   This file was modified by Vincent Traag
   The original copyright notice follows here */

/***************************************************************************
                          pottsmodel.cpp  -  description
                             -------------------
    begin                : Fri May 28 2004
    copyright            : (C) 2004 by
    email                :
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "pottsmodel_2.h"
#include "NetRoutines.h"

#include "igraph_random.h"
#include "core/interruption.h"

#include 
#include 

using namespace std;

//#################################################################################################
PottsModel::PottsModel(network *n, unsigned int qvalue, int m) : Qmatrix(qvalue+1), acceptance(0)
{
    DLList_Iter iter;
    NNode *n_cur;
    unsigned int *i_ptr;
    net = n;
    q = qvalue;
    operation_mode = m;
    k_max = 0;
    //needed in calculating modularity
    Qa     = new double[q + 1];
    //weights for each spin state needed in Monte Carlo process
    weights = new double[q + 1];
    //bookkeeping of occupation numbers of spin states or the number of links in community
    color_field = new double[q + 1];
    neighbours = new double[q + 1];

    num_of_nodes = net->node_list->Size();
    num_of_links = net->link_list->Size();

    n_cur = iter.First(net->node_list);
    //these lists are needed to keep track of spin states for parallel update mode
    new_spins = new DL_Indexed_List();
    previous_spins = new DL_Indexed_List();
    while (!iter.End()) {
        if (k_max < n_cur->Get_Degree()) {
            k_max = n_cur->Get_Degree();
        }
        i_ptr = new unsigned int;
        *i_ptr = 0;
        new_spins->Push(i_ptr);
        i_ptr = new unsigned int;
        *i_ptr = 0;
        previous_spins->Push(i_ptr);
        n_cur = iter.Next();
    }
}
//#######################################################
//Destructor of PottsModel
//########################################################
PottsModel::~PottsModel() {
    /* The DLItem destructor does not delete its item currently,
       because of some bad design. As a workaround, we delete them here
       by hand */
    new_spins->delete_items();
    previous_spins->delete_items();
    delete new_spins;
    delete previous_spins;
    delete [] Qa;
    delete [] weights;
    delete [] color_field;
    delete [] neighbours;
}
//#####################################################
//Assing an initial random configuration of spins to nodes
//if called with negative argument or the spin used as argument
//when called with positve one.
//This may be handy, if you want to warm up the network.
//####################################################
unsigned long PottsModel::assign_initial_conf(int spin) {
    int s;
    DLList_Iter iter;
    DLList_Iter l_iter;
    NNode *n_cur;
    NLink *l_cur;
    double sum_weight;
    double av_k_squared = 0.0;
    double av_k = 0.0;
    IGRAPH_UNUSED(av_k_squared); /* We mark it as unused to prevent warnings about unused-but-set-variables. */
    IGRAPH_UNUSED(av_k);         /* We mark it as unused to prevent warnings about unused-but-set-variables. */

//   printf("Assigning initial configuration...\n");
    // initialize colorfield
    for (unsigned int i = 0; i <= q; i++) {
        color_field[i] = 0.0;
    }
    //
    total_degree_sum = 0.0;
    n_cur = iter.First(net->node_list);
    while (!iter.End()) {
        if (spin < 0) {
            s = RNG_INTEGER(1, q);
        } else {
            s = spin;
        }
        n_cur->Set_ClusterIndex(s);
        l_cur = l_iter.First(n_cur->Get_Links());
        sum_weight = 0;
        while (!l_iter.End()) {
            sum_weight += l_cur->Get_Weight(); //weight should be one, in case we are not using it.
            l_cur = l_iter.Next();
        }
        // we set the sum of the weights or the degree as the weight of the node, this way
        // we do not have to calculate it again.
        n_cur->Set_Weight(sum_weight);
        av_k_squared += sum_weight * sum_weight;
        av_k += sum_weight;

        // in case we want all links to be contribute equally - parameter gamm=fixed
        if (operation_mode == 0) {
            color_field[s]++;
        } else {
            color_field[s] += sum_weight;
        }
        // or in case we want to use a weight of each link that is proportional to k_i\times k_j
        total_degree_sum += sum_weight;
        n_cur = iter.Next();
    }
    av_k_squared /= double(net->node_list->Size());
    av_k /= double(net->node_list->Size());
    // total_degree_sum-=av_k_squared/av_k;
//   printf("Total Degree Sum=2M=%f\n",total_degree_sum);
    return net->node_list->Size();
}
//#####################################################################
//If I ever manage to write a decent LookUp function, it will be here
//#####################################################################
unsigned long PottsModel::initialize_lookup(double kT, double gamma) {
    IGRAPH_UNUSED(kT);
    IGRAPH_UNUSED(gamma);
    /*
    double beta;
    // the look-up table contains all entries of exp(-beta(-neighbours+gamma*h))
    // as needed in the HeatBath algorithm
    beta=1.0/kT;
    for (long w=0; w<=k_max+num_of_nodes; w++)
    {
       neg_lookup[w]=exp(-beta*-w
    }
    delta_ij[0]=1.0;
    for (long w=-num_of_nodes-k_max; w<=k_max+num_of_nodes; w++)
    {

    }

    // wenn wir spaeter exp(-1/kT*gamma*(nk+1-nj) fuer eine spin-flip von j nach k benoetigen schauen wir nur noch hier nach
    for (unsigned long n=1; n<=num_of_nodes; n++)
    {
      gamma_term[n]=exp(-double(n)/kT*gamma);
    }
    gamma_term[0]=1.0;
    */
    return 1;
}
//#####################################################################
// Q denotes the modularity of the network
// This function calculates it initially
// In the event of a spin changing its state, it only needs updating
// Note that Qmatrix and Qa are only counting! The normalization
// by num_of_links is done later
//####################################################################
double PottsModel::initialize_Qmatrix() {
    DLList_Iter l_iter;
    NLink *l_cur;
    unsigned int i, j;
    //initialize with zeros
    num_of_links = net->link_list->Size();
    for (i = 0; i <= q; i++) {
        Qa[i] = 0.0;
        for (j = i; j <= q; j++) {
            Qmatrix[i][j] = 0.0;
            Qmatrix[j][i] = 0.0;
        }
    }
    //go over all links and make corresponding entries in Q matrix
    //An edge connecting state i wiht state j will get an entry in Qij and Qji
    l_cur = l_iter.First(net->link_list);
    while (!l_iter.End()) {
        i = l_cur->Get_Start()->Get_ClusterIndex();
        j = l_cur->Get_End()->Get_ClusterIndex();
        //printf("%d %d\n",i,j);
        Qmatrix[i][j] += l_cur->Get_Weight();
        Qmatrix[j][i] += l_cur->Get_Weight();

        l_cur = l_iter.Next();
    }
    //Finally, calculate sum over rows and keep in Qa
    for (i = 0; i <= q; i++) {
        for (j = 0; j <= q; j++) {
            Qa[i] += Qmatrix[i][j];
        }
    }
    return calculate_Q();
}
//####################################################################
// This function does the actual calculation of Q from the matrix
// The normalization by num_of_links is done here
//####################################################################
double PottsModel::calculate_Q() {
    double Q = 0.0;
    for (unsigned int i = 0; i <= q; i++) {
        Q += Qmatrix[i][i] - Qa[i] * Qa[i] / double(2.0 * net->sum_weights);
        if ((Qa[i] < 0.0) || Qmatrix[i][i] < 0.0) {
//         printf("Negatives Qa oder Qii\n\n\n");
            //printf("Press any key to continue\n\n");
            //cin >> Q;
        }
    }
    Q /= double(2.0 * net->sum_weights);
    return Q;
}
double PottsModel::calculate_genQ(double gamma) {
    double Q = 0.0;
    for (unsigned int i = 0; i <= q; i++) {
        Q += Qmatrix[i][i] - gamma * Qa[i] * Qa[i] / double(2.0 * net->sum_weights);
        if ((Qa[i] < 0.0) || Qmatrix[i][i] < 0.0) {
//         printf("Negatives Qa oder Qii\n\n\n");
            //printf("Press any key to continue\n\n");
            //cin >> Q;
        }
    }
    Q /= double(2.0 * net->sum_weights);
    return Q;
}
//#######################################################################
// This function calculates the Energy for the standard Hamiltonian
// given a particular value of gamma and the current spin states
// #####################################################################
double PottsModel::calculate_energy(double gamma) {
    double e = 0.0;
    DLList_Iter l_iter;
    NLink *l_cur;
    l_cur = l_iter.First(net->link_list);
    //every in-cluster edge contributes -1
    while (!l_iter.End()) {
        if (l_cur->Get_Start()->Get_ClusterIndex() == l_cur->Get_End()->Get_ClusterIndex()) {
            e--;
        }
        l_cur = l_iter.Next();
    }
    //and the penalty term contributes according to cluster sizes
    for (unsigned int i = 1; i <= q; i++) {
        e += gamma * 0.5 * double(color_field[i]) * double((color_field[i] - 1));
    }
    energy = e;
    return e;
}
//##########################################################################
// We would like to start from a temperature with at least 95 of all proposed
// spin changes accepted in 50 sweeps over the network
// The function returns the Temperature found
//#########################################################################
double PottsModel::FindStartTemp(double gamma, double prob, double ts) {
    double kT;
    kT = ts;
    //assing random initial condition
    assign_initial_conf(-1);
    //initialize Modularity matrix, from now on, it will be updated at every spin change
    initialize_Qmatrix();
    // the factor 1-1/q is important, since even, at infinite temperature,
    // only 1-1/q of all spins do change their state, since a randomly chooses new
    // state is with prob. 1/q the old state.
    while (acceptance < (1.0 - 1.0 / double(q)) * 0.95) { //want 95% acceptance
        kT = kT * 1.1;
        // if I ever have a lookup table, it will need initialization for every kT
        //initialize_lookup(kT,k_max,net->node_list->Size());
        HeatBathParallelLookup(gamma, prob, kT, 50);
//        printf("kT=%f acceptance=%f\n", kT, acceptance);
    }
    kT *= 1.1; // just to be sure...
//   printf("Starting with acceptance ratio: %1.6f bei kT=%2.4f\n",acceptance,kT);
    return kT;
}

//##############################################################
//This function does a parallel update at zero T
//Hence, it is really fast on easy problems
//max sweeps is the maximum number of sweeps it should perform,
//if it does not converge earlier
//##############################################################
long PottsModel::HeatBathParallelLookupZeroTemp(double gamma, double prob, unsigned int max_sweeps) {
    DLList_Iter iter, net_iter;
    DLList_Iter l_iter;
    DLList_Iter i_iter, i_iter2;
    NNode *node, *n_cur;
    NLink *l_cur;
    unsigned int *SPIN, *P_SPIN, new_spin, spin_opt, old_spin, spin, sweep;
    // long h; // degree;
    unsigned long changes;
    double h, delta = 0, deltaE, deltaEmin, w, degree;
    //HugeArray neighbours;
    bool cyclic = false;

    sweep = 0;
    changes = 1;
    while (sweep < max_sweeps && changes) {
        cyclic = true;
        sweep++;
        changes = 0;
        //Loop over all nodes
        node = net_iter.First(net->node_list);
        SPIN = i_iter.First(new_spins);
        while (!net_iter.End()) {
            // How many neigbors of each type?
            // set them all zero
            for (unsigned int i = 0; i <= q; i++) {
                neighbours[i] = 0;
            }
            degree = node->Get_Weight();
            //Loop over all links (=neighbours)
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                //printf("%s %s\n",node->Get_Name(),n_cur->Get_Name());
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                neighbours[n_cur->Get_ClusterIndex()] += w;
                l_cur = l_iter.Next();
            }
            //Search optimal Spin
            old_spin = node->Get_ClusterIndex();
            //degree=node->Get_Degree();
            switch (operation_mode) {
            case 0: {
                delta = 1.0;
                break;
            }
            case 1: { //newman modularity
                prob = degree / total_degree_sum;
                delta = degree;
                break;
            }
            }


            spin_opt = old_spin;
            deltaEmin = 0.0;
            for (spin = 1; spin <= q; spin++) { // all possible spin states
                if (spin != old_spin) {
                    h = color_field[spin] + delta - color_field[old_spin];
                    deltaE = double(neighbours[old_spin] - neighbours[spin]) + gamma * prob * double(h);
                    if (deltaE < deltaEmin) {
                        spin_opt = spin;
                        deltaEmin = deltaE;
                    }
                }
            } // for spin

            //Put optimal spin on list for later update
            *SPIN = spin_opt;
            node = net_iter.Next();
            SPIN = i_iter.Next();
        } // while !net_iter.End()

        //-------------------------------
        //Now set all spins to new values
        node = net_iter.First(net->node_list);
        SPIN = i_iter.First(new_spins);
        P_SPIN = i_iter2.First(previous_spins);
        while (!net_iter.End()) {
            old_spin = node->Get_ClusterIndex();
            new_spin = *SPIN;
            if (new_spin != old_spin) { // Do we really have a change??
                changes++;
                node->Set_ClusterIndex(new_spin);
                //this is important!!
                //In Parallel update, there occur cyclic attractors of size two
                //which then make the program run for ever
                if (new_spin != *P_SPIN) {
                    cyclic = false;
                }
                *P_SPIN = old_spin;
                color_field[old_spin]--;
                color_field[new_spin]++;

                //Qmatrix update
                //iteration over all neighbours
                l_cur = l_iter.First(node->Get_Links());
                while (!l_iter.End()) {
                    w = l_cur->Get_Weight();
                    if (node == l_cur->Get_Start()) {
                        n_cur = l_cur->Get_End();
                    } else {
                        n_cur = l_cur->Get_Start();
                    }
                    Qmatrix[old_spin][n_cur->Get_ClusterIndex()] -= w;
                    Qmatrix[new_spin][n_cur->Get_ClusterIndex()] += w;
                    Qmatrix[n_cur->Get_ClusterIndex()][old_spin] -= w;
                    Qmatrix[n_cur->Get_ClusterIndex()][new_spin] += w;
                    Qa[old_spin] -= w;
                    Qa[new_spin] += w;
                    l_cur = l_iter.Next();
                }  // while l_iter
            }
            node = net_iter.Next();
            SPIN = i_iter.Next();
            P_SPIN = i_iter2.Next();
        } // while (!net_iter.End())
    }  // while markov

    // In case of a cyclic attractor, we want to interrupt
    if (cyclic)  {
//       printf("Cyclic attractor!\n");
        acceptance = 0.0;
        return 0;
    } else {
        acceptance = double(changes) / double(num_of_nodes);
        return changes;
    }
}
//###################################################################################
//The same function as before, but rather than parallel update, it pics the nodes to update
//randomly
//###################################################################################
double PottsModel::HeatBathLookupZeroTemp(double gamma, double prob, unsigned int max_sweeps) {
    DLList_Iter iter;
    DLList_Iter l_iter;
    DLList_Iter i_iter, i_iter2;
    NNode *node, *n_cur;
    NLink *l_cur;
    unsigned int new_spin, spin_opt, old_spin, spin, sweep;
    long r;// degree;
    unsigned long changes;
    double delta = 0, h, deltaE, deltaEmin, w, degree;
    //HugeArray neighbours;

    sweep = 0;
    changes = 0;
    while (sweep < max_sweeps) {
        sweep++;
        //ueber alle Knoten im Netz
        for (unsigned long n = 0; n < num_of_nodes; n++) {
            r = -1;
            while ((r < 0) || (r > (long)num_of_nodes - 1)) {
                r = RNG_INTEGER(0, num_of_nodes - 1);
            }
            /* r=long(double(num_of_nodes*double(rand())/double(RAND_MAX+1.0)));*/
            node = net->node_list->Get(r);
            // Wir zaehlen, wieviele Nachbarn von jedem spin vorhanden sind
            // erst mal alles Null setzen
            for (unsigned int i = 0; i <= q; i++) {
                neighbours[i] = 0;
            }
            degree = node->Get_Weight();
            //Loop over all links (=neighbours)
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                //printf("%s %s\n",node->Get_Name(),n_cur->Get_Name());
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                neighbours[n_cur->Get_ClusterIndex()] += w;
                l_cur = l_iter.Next();
            }
            //Search optimal Spin
            old_spin = node->Get_ClusterIndex();
            //degree=node->Get_Degree();
            switch (operation_mode) {
            case 0: {
                delta = 1.0;
                break;
            }
            case 1: { //newman modularity
                prob = degree / total_degree_sum;
                delta = degree;
                break;
            }
            }


            spin_opt = old_spin;
            deltaEmin = 0.0;
            for (spin = 1; spin <= q; spin++) { // alle moeglichen Spins
                if (spin != old_spin) {
                    h = color_field[spin] + delta - color_field[old_spin];
                    deltaE = double(neighbours[old_spin] - neighbours[spin]) + gamma * prob * double(h);
                    if (deltaE < deltaEmin) {
                        spin_opt = spin;
                        deltaEmin = deltaE;
                    }
                }
            } // for spin

            //-------------------------------
            //Now update the spins
            new_spin = spin_opt;
            if (new_spin != old_spin) { // Did we really change something??
                changes++;
                node->Set_ClusterIndex(new_spin);
                color_field[old_spin] -= delta;
                color_field[new_spin] += delta;

                //Qmatrix update
                //iteration over all neighbours
                l_cur = l_iter.First(node->Get_Links());
                while (!l_iter.End()) {
                    w = l_cur->Get_Weight();
                    if (node == l_cur->Get_Start()) {
                        n_cur = l_cur->Get_End();
                    } else {
                        n_cur = l_cur->Get_Start();
                    }
                    Qmatrix[old_spin][n_cur->Get_ClusterIndex()] -= w;
                    Qmatrix[new_spin][n_cur->Get_ClusterIndex()] += w;
                    Qmatrix[n_cur->Get_ClusterIndex()][old_spin] -= w;
                    Qmatrix[n_cur->Get_ClusterIndex()][new_spin] += w;
                    Qa[old_spin] -= w;
                    Qa[new_spin] += w;
                    l_cur = l_iter.Next();
                }  // while l_iter
            }
        } // for n
    }  // while markov

    acceptance = double(changes) / double(num_of_nodes) / double(sweep);
    return acceptance;
}
//#####################################################################################
//This function performs a parallel update at Terperature T
//#####################################################################################
long PottsModel::HeatBathParallelLookup(double gamma, double prob, double kT, unsigned int max_sweeps) {
    DLList_Iter iter, net_iter;
    DLList_Iter l_iter;
    DLList_Iter i_iter, i_iter2;
    NNode *node, *n_cur;
    NLink *l_cur;
    unsigned int new_spin, spin_opt, old_spin;
    unsigned int *SPIN, *P_SPIN;
    unsigned int sweep;
    long max_q;
    unsigned long changes, /*degree,*/ problemcount;
    //HugeArray neighbours;
    double h, delta = 0, norm, r, beta, minweight, prefac = 0, w, degree;
    bool cyclic = false, found;
    unsigned long number_of_nodes;

    sweep = 0;
    changes = 1;
    number_of_nodes = net->node_list->Size();
    while (sweep < max_sweeps && changes) {
        cyclic = true;
        sweep++;
        changes = 0;
        //Loop over all nodes
        node = net_iter.First(net->node_list);
        SPIN = i_iter.First(new_spins);
        while (!net_iter.End()) {
            // Initialize neighbours and weights
            problemcount = 0;
            for (unsigned int i = 0; i <= q; i++) {
                neighbours[i] = 0;
                weights[i] = 0;
            }
            norm = 0.0;
            degree = node->Get_Weight();
            //Loop over all links (=neighbours)
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                //printf("%s %s\n",node->Get_Name(),n_cur->Get_Name());
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                neighbours[n_cur->Get_ClusterIndex()] += w;
                l_cur = l_iter.Next();
            }
            //Search optimal Spin
            old_spin = node->Get_ClusterIndex();
            //degree=node->Get_Degree();
            switch (operation_mode) {
            case 0: {
                prefac = 1.0;
                delta = 1.0;
                break;
            }
            case 1: { //newman modularity
                prefac = 1.0;
                prob = degree / total_degree_sum;
                delta = degree;
                break;
            }
            }
            spin_opt = old_spin;
            beta = 1.0 / kT * prefac;
            minweight = 0.0;
            weights[old_spin] = 0.0;
            for (unsigned spin = 1; spin <= q; spin++) { // loop over all possible new spins
                if (spin != old_spin) { // only if we have a different than old spin!
                    h = color_field[spin] + delta - color_field[old_spin];
                    weights[spin] = double(neighbours[old_spin] - neighbours[spin]) + gamma * prob * double(h);
                    if (weights[spin] < minweight) {
                        minweight = weights[spin];
                    }
                }
            }   // for spin
            for (unsigned spin = 1; spin <= q; spin++) { // loop over all possibe spins
                weights[spin] -= minweight;       // subtract minweight
                // to avoid numerical problems with large exponents
                weights[spin] = exp(-beta * weights[spin]);
                norm += weights[spin];
            }   // for spin

            //now choose a new spin
            r = RNG_UNIF(0, norm);
            /* norm*double(rand())/double(RAND_MAX + 1.0); */
            new_spin = 1;
            found = false;
            while (!found && new_spin <= q) {
                if (r <= weights[new_spin]) {
                    spin_opt = new_spin;
                    found = true;
                    break;
                } else {
                    r -= weights[new_spin];
                }
                new_spin++;
            }
            if (!found) {
//         printf(".");
                problemcount++;
            }
            //Put new spin on list
            *SPIN = spin_opt;

            node = net_iter.Next();
            SPIN = i_iter.Next();
        } // while !net_iter.End()

        //-------------------------------
        //now update all spins
        node = net_iter.First(net->node_list);
        SPIN = i_iter.First(new_spins);
        P_SPIN = i_iter2.First(previous_spins);
        while (!net_iter.End()) {
            old_spin = node->Get_ClusterIndex();
            new_spin = *SPIN;
            if (new_spin != old_spin) { // Did we really change something??
                changes++;
                node->Set_ClusterIndex(new_spin);
                if (new_spin != *P_SPIN) {
                    cyclic = false;
                }
                *P_SPIN = old_spin;
                color_field[old_spin] -= delta;
                color_field[new_spin] += delta;

                //Qmatrix update
                //iteration over all neighbours
                l_cur = l_iter.First(node->Get_Links());
                while (!l_iter.End()) {
                    w = l_cur->Get_Weight();
                    if (node == l_cur->Get_Start()) {
                        n_cur = l_cur->Get_End();
                    } else {
                        n_cur = l_cur->Get_Start();
                    }
                    Qmatrix[old_spin][n_cur->Get_ClusterIndex()] -= w;
                    Qmatrix[new_spin][n_cur->Get_ClusterIndex()] += w;
                    Qmatrix[n_cur->Get_ClusterIndex()][old_spin] -= w;
                    Qmatrix[n_cur->Get_ClusterIndex()][new_spin] += w;
                    Qa[old_spin] -= w;
                    Qa[new_spin] += w;
                    l_cur = l_iter.Next();
                }  // while l_iter
            }
            node = net_iter.Next();
            SPIN = i_iter.Next();
            P_SPIN = i_iter2.Next();
        } // while (!net_iter.End())

    }  // while markov
    max_q = 0;
    for (unsigned int i = 1; i <= q; i++) if (color_field[i] > max_q) {
            max_q = long(color_field[i]);
        }

    //again, we would not like to end up in cyclic attractors
    if (cyclic && changes)  {
//       printf("Cyclic attractor!\n");
        acceptance = double(changes) / double(number_of_nodes);
        return 0;
    } else {
        acceptance = double(changes) / double(number_of_nodes);
        return changes;
    }
}
//##############################################################
// This is the function generally used for optimisation,
// as the parallel update has its flaws, due to the cyclic attractors
//##############################################################
double PottsModel::HeatBathLookup(double gamma, double prob, double kT, unsigned int max_sweeps) {
    DLList_Iter iter;
    DLList_Iter l_iter;
    DLList_Iter i_iter, i_iter2;
    NNode *node, *n_cur;
    NLink *l_cur;
    unsigned int new_spin, spin_opt, old_spin;
    unsigned int sweep;
    long max_q, rn;
    unsigned long changes, /*degree,*/ problemcount;
    double degree, w, delta = 0, h;
    //HugeArray neighbours;
    double norm, r, beta, minweight, prefac = 0;
    bool found;
    long int number_of_nodes;
    sweep = 0;
    changes = 0;
    number_of_nodes = net->node_list->Size();
    while (sweep < max_sweeps) {
        sweep++;
        //loop over all nodes in network
        for (int n = 0; n < number_of_nodes; n++) {
            rn = -1;
            while ((rn < 0) || (rn > number_of_nodes - 1)) {
                rn = RNG_INTEGER(0, number_of_nodes - 1);
            }
            /* rn=long(double(number_of_nodes*double(rand())/double(RAND_MAX+1.0))); */

            node = net->node_list->Get(rn);
            // initialize the neighbours and the weights
            problemcount = 0;
            for (unsigned int i = 0; i <= q; i++) {
                neighbours[i] = 0.0;
                weights[i] = 0.0;
            }
            norm = 0.0;
            degree = node->Get_Weight();
            //Loop over all links (=neighbours)
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                //printf("%s %s\n",node->Get_Name(),n_cur->Get_Name());
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                neighbours[n_cur->Get_ClusterIndex()] += w;
                l_cur = l_iter.Next();
            }

            //Look for optimal spin

            old_spin = node->Get_ClusterIndex();
            //degree=node->Get_Degree();
            switch (operation_mode) {
            case 0: {
                prefac = 1.0;
                delta = 1.0;
                break;
            }
            case 1:  {//newman modularity
                prefac = 1.0;
                prob = degree / total_degree_sum;
                delta = degree;
                break;
            }
            }
            spin_opt = old_spin;
            beta = 1.0 / kT * prefac;
            minweight = 0.0;
            weights[old_spin] = 0.0;
            for (unsigned spin = 1; spin <= q; spin++) { // all possible new spins
                if (spin != old_spin) { // except the old one!
                    h = color_field[spin] - (color_field[old_spin] - delta);
                    weights[spin] = neighbours[old_spin] - neighbours[spin] + gamma * prob * h;
                    if (weights[spin] < minweight) {
                        minweight = weights[spin];
                    }
                }
            }   // for spin
            for (unsigned spin = 1; spin <= q; spin++) { // all possible new spins
                weights[spin] -= minweight;       // subtract minweigt
                // for numerical stability
                weights[spin] = exp(-beta * weights[spin]);
                norm += weights[spin];
            }   // for spin


            //choose a new spin
            /*      r = norm*double(rand())/double(RAND_MAX + 1.0); */
            r = RNG_UNIF(0, norm);
            new_spin = 1;
            found = false;
            while (!found && new_spin <= q) {
                if (r <= weights[new_spin]) {
                    spin_opt = new_spin;
                    found = true;
                    break;
                } else {
                    r -= weights[new_spin];
                }
                new_spin++;
            }
            if (!found) {
//         printf(".");
                problemcount++;
            }
            //-------------------------------
            //now set the new spin
            new_spin = spin_opt;
            if (new_spin != old_spin) { // Did we really change something??
                changes++;
                node->Set_ClusterIndex(new_spin);
                color_field[old_spin] -= delta;
                color_field[new_spin] += delta;

                //Qmatrix update
                //iteration over all neighbours
                l_cur = l_iter.First(node->Get_Links());
                while (!l_iter.End()) {
                    w = l_cur->Get_Weight();
                    if (node == l_cur->Get_Start()) {
                        n_cur = l_cur->Get_End();
                    } else {
                        n_cur = l_cur->Get_Start();
                    }
                    Qmatrix[old_spin][n_cur->Get_ClusterIndex()] -= w;
                    Qmatrix[new_spin][n_cur->Get_ClusterIndex()] += w;
                    Qmatrix[n_cur->Get_ClusterIndex()][old_spin] -= w;
                    Qmatrix[n_cur->Get_ClusterIndex()][new_spin] += w;
                    Qa[old_spin] -= w;
                    Qa[new_spin] += w;
                    l_cur = l_iter.Next();
                }  // while l_iter
            }
        } // for n
    }  // while markov
    max_q = 0;

    for (unsigned int i = 1; i <= q; i++) if (color_field[i] > max_q) {
            max_q = long(color_field[i] + 0.5);
        }

    acceptance = double(changes) / double(number_of_nodes) / double(sweep);
    return acceptance;
}

//###############################################################################################
//# Here we try to minimize the affinity to the rest of the network
//###############################################################################################
double PottsModel::FindCommunityFromStart(double gamma, double prob,
        char *nodename,
        igraph_vector_t *result,
        igraph_real_t *cohesion,
        igraph_real_t *adhesion,
        igraph_integer_t *my_inner_links,
        igraph_integer_t *my_outer_links) {
    DLList_Iter iter, iter2;
    DLList_Iter l_iter;
    DLList* to_do;
    DLList* community;
    NNode *start_node = NULL, *n_cur, *neighbor, *max_aff_node, *node;
    NLink *l_cur;
    bool found = false, add = false, remove = false;
    double degree, delta_aff_add, delta_aff_rem, max_delta_aff, Ks = 0.0, Kr = 0, kis, kir, w;
    long community_marker = 5;
    long to_do_marker = 10;
    double inner_links = 0, outer_links = 0, aff_r, aff_s;

    IGRAPH_UNUSED(prob);

    to_do = new DLList;
    community = new DLList;

    // find the node in the network
    n_cur = iter.First(net->node_list);
    while (!found && !iter.End()) {
        if (0 == strcmp(n_cur->Get_Name(), nodename)) {
            start_node = n_cur;
            found = true;
            start_node->Set_Affinity(0.0);
            community->Push(start_node);
            start_node->Set_Marker(community_marker);
            Ks = start_node->Get_Weight();
            Kr = total_degree_sum - start_node->Get_Weight();
        }
        n_cur = iter.Next();
    }
    if (!found) {
//      printf("%s not found found. Aborting.\n",nodename);
//      fprintf(file,"%s not found found. Aborting.\n",nodename);
        delete to_do;
        delete community;
        return -1;
    }
    //#############################
    // initialize the to_do list and community with the neighbours of start node
    //#############################
    neighbor = iter.First(start_node->Get_Neighbours());
    while (!iter.End()) {
//     printf("Adding node %s to comunity.\n",neighbor->Get_Name());
        community->Push(neighbor);
        neighbor->Set_Marker(community_marker);
        Ks += neighbor->Get_Weight();
        Kr -= neighbor->Get_Weight();
        neighbor = iter.Next();
    }
    node = iter.First(community);
    while (!iter.End()) {
        //now add at the second neighbors to the to_do list
        neighbor = iter2.First(node->Get_Neighbours());
        while (!iter2.End()) {
            if ((long)neighbor->Get_Marker() != community_marker && (long)neighbor->Get_Marker() != to_do_marker) {
                to_do->Push(neighbor);
                neighbor->Set_Marker(to_do_marker);
//  printf("Adding node %s to to_do list.\n",neighbor->Get_Name());
            }
            neighbor = iter2.Next();
        }
        node = iter.Next();
    }

    //#############
    //repeat, as long as we are still adding nodes to the communtiy
    //#############
    add = true;
    remove = true;
    while (add || remove) {
        //#############################
        //calculate the affinity changes of all nodes for adding every node in the to_do list to the community
        //##############################

        IGRAPH_ALLOW_INTERRUPTION(); /* This is not clean.... */

        max_delta_aff = 0.0;
        max_aff_node = NULL;
        add = false;
        node = iter.First(to_do);
        while (!iter.End()) {
            //printf("Checking Links of %s\n",node->Get_Name());
            degree = node->Get_Weight();
            kis = 0.0;
            kir = 0.0;
            // For every of the neighbors, check, count the links to the community
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                if ((long)n_cur->Get_Marker() == community_marker) {
                    kis += w; //the weight/number of links to the community
                } else {
                    kir += w; //the weight/number of links to the rest of the network
                }
                l_cur = l_iter.Next();
            }
            aff_r = kir - gamma / total_degree_sum * (Kr - degree) * degree;
            aff_s = kis - gamma / total_degree_sum * Ks * degree;
            delta_aff_add = aff_r - aff_s;
            //  if (aff_s>=aff_r && delta_aff_add<=max_delta_aff) {
            if (delta_aff_add <= max_delta_aff) {
                node->Set_Affinity(aff_s);
                max_delta_aff = delta_aff_add;
                max_aff_node = node;
                add = true;
            }
            //printf("%s in to_do list with affinity %f\n",node->Get_Name(),node->Get_Affinity());
            node = iter.Next();
        }
        //################
        //calculate the affinity changes for removing every single node from the community
        //################
        inner_links = 0;
        outer_links = 0;
        remove = false;
        node = iter.First(community);
        while (!iter.End()) {
            //printf("Checking Links of %s\n",node->Get_Name());
            degree = node->Get_Weight();
            kis = 0.0;
            kir = 0.0;
            // For every of the neighbors, check, count the links to the community
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                if ((long)n_cur->Get_Marker() == community_marker) {
                    kis += w;
                    inner_links += w; //summing all w gives twice the number of inner links(weights)
                } else {
                    kir += w;
                    outer_links += w;
                }
                l_cur = l_iter.Next();
            }
//  if (kir+kis!=degree) {  printf("error kir=%f\tkis=%f\tk=%f\n",kir,kis,degree); }
            aff_r = kir - gamma / total_degree_sum * Kr * degree;
            aff_s = kis - gamma / total_degree_sum * (Ks - degree) * degree;
            delta_aff_rem = aff_s - aff_r;
            node->Set_Affinity(aff_s);
            // we should not remove the nodes, we have just added
            if (delta_aff_rem < max_delta_aff) {
                max_delta_aff = delta_aff_rem ;
                max_aff_node = node;
                remove = true;
                add = false;
            }
            //printf("%s in to_do list with affinity %f\n",node->Get_Name(),node->Get_Affinity());
            node = iter.Next();
        }
        inner_links = inner_links * 0.5;
        //################
        // Now check, whether we want to remove or add a node
        //################
        if (add) {
            //################
            //add the node of maximum affinity to the community
            //###############
            community->Push(max_aff_node);
            max_aff_node->Set_Marker(community_marker);
            //delete node from to_do
            to_do->fDelete(max_aff_node);
            //update the sum of degrees in the community
            Ks += max_aff_node->Get_Weight();
            Kr -= max_aff_node->Get_Weight();
//  printf("Adding node %s to community with affinity of %f delta_aff: %f.\n",max_aff_node->Get_Name(), max_aff_node->Get_Affinity(),max_delta_aff);
            //now add all neighbors of this node, that are not already
            //in the to_do list or in the community
            neighbor = iter.First(max_aff_node->Get_Neighbours());
            while (!iter.End()) {
                if ((long)neighbor->Get_Marker() != community_marker && (long)neighbor->Get_Marker() != to_do_marker) {
                    to_do->Push(neighbor);
                    neighbor->Set_Marker(to_do_marker);
                    //printf("Adding node %s to to_do list.\n",neighbor->Get_Name());
                }
                neighbor = iter.Next();
            }
        }
        if (remove) {
            //################
            //remove those with negative affinities
            //################
            community->fDelete(max_aff_node);
            max_aff_node->Set_Marker(to_do_marker);
            //update the sum of degrees in the community
            Ks -= max_aff_node->Get_Weight();
            Kr += max_aff_node->Get_Weight();
            //add the node to to_do again
            to_do->Push(max_aff_node);
//  printf("Removing node %s from community with affinity of %f delta_aff: %f.\n",max_aff_node->Get_Name(), max_aff_node->Get_Affinity(),max_delta_aff);
        }
        IGRAPH_ALLOW_INTERRUPTION(); /* This is not clean.... */
    }
    //###################
    //write the node in the community to a file
    //###################
    // TODO return this instead of writing it
//   fprintf(file,"Number_of_nodes:\t%d\n",community->Size());
//   fprintf(file,"Inner_Links:\t%f\n",inner_links);
//   fprintf(file,"Outer_Links:\t%f\n",Ks-2*inner_links);
//   fprintf(file,"Cohesion:\t%f\n",inner_links-gamma/total_degree_sum*Ks*Ks*0.5);
//   fprintf(file,"Adhesion:\t%f\n",outer_links-gamma/total_degree_sum*Ks*Kr);
//   fprintf(file,"\n");
    if (cohesion) {
        *cohesion = inner_links - gamma / total_degree_sum * Ks * Ks * 0.5;
    }
    if (adhesion) {
        *adhesion = outer_links - gamma / total_degree_sum * Ks * Kr;
    }
    if (my_inner_links) {
        *my_inner_links = inner_links;
    }
    if (my_outer_links) {
        *my_outer_links = outer_links;
    }
    if (result) {
        node = iter.First(community);
        igraph_vector_resize(result, 0);
        while (!iter.End()) {
            // printf("%s in community.\n",node->Get_Name());
            // fprintf(file,"%s\t%f\n",node->Get_Name(),node->Get_Affinity());
            IGRAPH_CHECK(igraph_vector_push_back(result, node->Get_Index()));
            node = iter.Next();
        }
    }
//   printf("%d nodes in community around %s\n",community->Size(),start_node->Get_Name());
//   fclose(file);
    unsigned int size = community->Size();
    delete to_do;
    delete community;
    return size;
}

//################################################################################################
// this Function writes the clusters to disk
//################################################################################################
long PottsModel::WriteClusters(igraph_real_t *modularity,
                               igraph_real_t *temperature,
                               igraph_vector_t *csize,
                               igraph_vector_t *membership,
                               double kT, double gamma) {
    NNode *n_cur, *n_cur2;
    /*
    double a1,a2,a3,p,p1,p2;
    long n,N,lin,lout;
    */
    DLList_Iter iter, iter2;
    HugeArray inner_links;
    HugeArray outer_links;
    HugeArray nodes;

    //den Header schreiben
//   p=2.0*double(num_of_links)/double(num_of_nodes)/double(num_of_nodes-1);
//   fprintf(file,"      Nodes=\t%lu\n",num_of_nodes);
//   fprintf(file,"      Links=\t%lu\n",num_of_links);
//   fprintf(file,"          q=\t%d\n",q);
//   fprintf(file,"          p=\t%f\n",p);
//   fprintf(file," Modularity=\t%f\n",calculate_Q());
//   fprintf(file,"Temperature=\t%f\n", kT);
//   fprintf(file,"Cluster\tNodes\tInnerLinks\tOuterLinks\tp_in\tp_out\t\n");

    if (temperature) {
        *temperature = kT;
    }

    if (csize || membership || modularity) {
        // TODO: count the number of clusters
        for (unsigned int spin = 1; spin <= q; spin++) {
            inner_links[spin] = 0;
            outer_links[spin] = 0;
            nodes[spin] = 0;
            n_cur = iter.First(net->node_list);
            while (!iter.End()) {
                if (n_cur->Get_ClusterIndex() == spin) {
                    nodes[spin]++;
                    n_cur2 = iter2.First(n_cur->Get_Neighbours());
                    while (!iter2.End()) {
                        if (n_cur2->Get_ClusterIndex() == spin) {
                            inner_links[spin]++;
                        } else {
                            outer_links[spin]++;
                        }
                        n_cur2 = iter2.Next();
                    }
                }
                n_cur = iter.Next();
            }
        }
    }
    if (modularity) {
        *modularity = 0.0;
        for (unsigned int spin = 1; spin <= q; spin++) {
            if (nodes[spin] > 0) {
                double t1 = inner_links[spin] / net->sum_weights / 2.0;
                double t2 = (inner_links[spin] + outer_links[spin]) /
                            net->sum_weights / 2.0;
                *modularity += t1;
                *modularity -= gamma * t2 * t2;
            }
        }
    }
    if (csize) {
        igraph_vector_resize(csize, 0);
        for (unsigned int spin = 1; spin <= q; spin++) {
            if (nodes[spin] > 0) {
                inner_links[spin] /= 2;
                //    fprintf(file,"Cluster\tNodes\tInnerLinks\tOuterLinks\tp_in\tp_out\n");
                /*
                N=num_of_nodes;
                n=nodes[spin];
                lin=inner_links[spin];
                lout=outer_links[spin];
                a1=N*log((double)N)-n*log((double)n)*(N-n)*log((double)N-n);
                if ((lin==long(n*(n-1)*0.5+0.5)) || (n==1)) a2=0.0;
                else a2=(n*(n-1)*0.5    )*log((double)n*(n-1)*0.5    )-(n*(n-1)*0.5    )-
                   (n*(n-1)*0.5-lin)*log((double)n*(n-1)*0.5-lin)+(n*(n-1)*0.5-lin)-
                   lin*log((double)lin            )+lin;
                */

                /*
                if ((lout==n*(N-n)) || n==N) a3=0.0;
                else a3=(n*(N-n)     )*log((double)n*(N-n)     )-(n*(N-n))-
                   (n*(N-n)-lout)*log((double)n*(N-n)-lout)+(n*(N-n)-lout)-
                   lout*log((double)lout        )+lout;
                */

                /*
                p1=(lin+lout)*log((double)p);
                p2=(0.5*n*(n-1)-lin + n*(N-n)-lout)*log((double)1.0-p);
                */
                //       fprintf(file,"%d\t%d\t%d\t%d\t%f\t%f\t%f\n",spin,nodes[spin], inner_links[spin], outer_links[spin], p_in, p_out,log_num_exp);
                IGRAPH_CHECK(igraph_vector_push_back(csize, nodes[spin]));
            }
        }
        //   fprintf(file,"\n");
    }

    //die Elemente der Cluster
    if (membership) {
        long int no = -1;
        IGRAPH_CHECK(igraph_vector_resize(membership, num_of_nodes));
        for (unsigned int spin = 1; spin <= q; spin++) {
            if (nodes[spin] > 0) {
                no++;
            }
            n_cur = iter.First(net->node_list);
            while (!iter.End()) {
                if (n_cur->Get_ClusterIndex() == spin) {
                    //         fprintf(file,"%d\t%s\n",spin,n_cur->Get_Name());
                    VECTOR(*membership)[ n_cur->Get_Index() ] = no;
                }
                n_cur = iter.Next();
            }
        }
    }

    return num_of_nodes;
}
//################################################################################################
//This function writes the soft clusters after a gamma sweep
//that is, it groups every node together that was found in
// more than threshold percent together with the other node
// in the same cluster
//################################################################################################
// Does not work at the moment !!!
//################################################################################################
// long PottsModel::WriteSoftClusters(char *filename, double threshold)
// {
//   FILE *file;
//   NNode *n_cur, *n_cur2;
//   DLList_Iter iter, iter2;
//   DL_Indexed_List*> *cl_list, *old_clusterlist;
//   ClusterList *cl_cur;

//   double max;

//   file=fopen(filename,"w");
//   if (!file) {
//     printf("Could not open %s for writing.\n",filename);
//     return -1;
//   }

//   max=correlation[0]->Get(0);
//   //printf("max=%f\n",max);
//   cl_list=new DL_Indexed_List*>();

//   n_cur=iter.First(net->node_list);
//   while (!iter.End())
//   {
//     cl_cur=new ClusterList();
//     cl_list->Push(cl_cur);
//     n_cur2=iter2.First(net->node_list);
//     while (!iter2.End())
//     {
//       if (double(correlation[n_cur->Get_Index()]->Get(n_cur2->Get_Index()))/max>threshold)
//         cl_cur->Push(n_cur2);
//       n_cur2=iter2.Next();
//     }
//     n_cur=iter.Next();
//   }
//   old_clusterlist=net->cluster_list;
//   net->cluster_list=cl_list;
//   clear_all_markers(net);
//   //printf("Es gibt %d Cluster\n",cl_list->Size());
//   reduce_cliques2(net, false, 15);
//   //printf("Davon bleiben %d Cluster uebrig\n",cl_list->Size());
//   clear_all_markers(net);
//   while (net->cluster_list->Size()){
//     cl_cur=net->cluster_list->Pop();
//     while (cl_cur->Size())
//     {
//       n_cur=cl_cur->Pop();
//       fprintf(file,"%s\n",n_cur->Get_Name());
//       //printf("%s\n",n_cur->Get_Name());
//     }
//     fprintf(file,"\n");
//   }
//   net->cluster_list=old_clusterlist;
//   fclose(file);

//   return 1;
// }
//#############################################################################
// Performs a gamma sweep
//#############################################################################
double PottsModel::GammaSweep(double gamma_start, double gamma_stop, double prob, unsigned int steps, bool non_parallel, int repetitions) {
    double stepsize;
    double kT = 0.5, kT_start;
    long changes;
    double gamma, acc;
    NNode *n_cur, *n_cur2;
    DLList_Iter iter, iter2;

    stepsize = (gamma_stop - gamma_start) / double(steps);

    n_cur = iter.First(net->node_list);
    while (!iter.End()) {
        correlation[n_cur->Get_Index()] = new HugeArray();
        n_cur2 = iter2.First(net->node_list);
        while (!iter2.End()) {
            correlation[n_cur->Get_Index()]->Set(n_cur->Get_Index()) = 0.0;
            n_cur2 = iter2.Next();
        }
        n_cur = iter.Next();
    }

    for (unsigned int n = 0; n <= steps; n++) {
        assign_initial_conf(-1);
        initialize_Qmatrix();
        gamma = gamma_start + stepsize * n;
        kT = 0.5;
        acceptance = 0.5;
        while (acceptance < (1.0 - 1.0 / double(q)) * 0.95) { //wollen 95% Acceptance
            kT *= 1.1;
            //initialize_lookup(kT,kmax,net->node_list->Size());
            if (!non_parallel) {
                HeatBathParallelLookup(gamma, prob, kT, 25);
            } else {
                HeatBathLookup(gamma, prob, kT, 25);
            }
            // printf("kT=%f acceptance=%f\n", kT, acceptance);
        }
        // printf("Starting with gamma=%f\n", gamma);
        kT_start = kT;

        for (int i = 0; i < repetitions; i++) {
            changes = 1;
            kT = kT_start;
            assign_initial_conf(-1);
            initialize_Qmatrix();
            while ((changes > 0) && (kT > 0.01)) {
                kT = kT * 0.99;
                //initialize_lookup(kT,kmax,net->node_list->Size());
                if (!non_parallel) {
                    changes = HeatBathParallelLookup(gamma, prob, kT, 50);
                    // printf("kT: %f   \t Changes %li\n",kT, changes);
                } else {
                    acc = HeatBathLookup(gamma, prob, kT, 50);
                    if (acc > (1.0 - 1.0 / double(q)) * 0.01) {
                        changes = 1;
                    } else {
                        changes = 0;
                    }
                    // printf("kT: %f   Acceptance: %f\n",kT, acc);
                }
            }
            // printf("Finisched with acceptance: %1.6f bei kT=%2.4f und gamma=%2.4f\n",acceptance,kT, gamma);
//      fprintf(file,"%f\t%f\n",gamma_,acceptance);
//      fprintf(file2,"%f\t%f\n",gamma_,kT);
            //   fprintf(file3,"%f\t%d\n",gamma_,count_clusters(5));

            //Die Correlation berechnen
            n_cur = iter.First(net->node_list);
            while (!iter.End()) {
                n_cur2 = iter2.First(net->node_list);
                while (!iter2.End()) {
                    if (n_cur->Get_ClusterIndex() == n_cur2->Get_ClusterIndex()) {
                        correlation[n_cur->Get_Index()]->Set(n_cur2->Get_Index()) += 0.5;
                    }
                    n_cur2 = iter2.Next();
                }
                n_cur = iter.Next();
            }
        } // for i
    } //for n
    return kT;
}
//#############################################################################
//Performs a Gamma sweep at zero T
//#############################################################################
double PottsModel::GammaSweepZeroTemp(double gamma_start, double gamma_stop, double prob, unsigned int steps, bool non_parallel, int repetitions) {
    double stepsize;
    long changes;
    double gamma = gamma_start, acc;
    long runs;
    NNode *n_cur, *n_cur2;
    DLList_Iter iter, iter2;

    stepsize = (gamma_stop - gamma_start) / double(steps);

    n_cur = iter.First(net->node_list);
    while (!iter.End()) {
        correlation[n_cur->Get_Index()] = new HugeArray();
        n_cur2 = iter2.First(net->node_list);
        while (!iter2.End()) {
            correlation[n_cur->Get_Index()]->Set(n_cur->Get_Index()) = 0.0;
            n_cur2 = iter2.Next();
        }
        n_cur = iter.Next();
    }

    for (unsigned int n = 0; n <= steps; n++) {
        assign_initial_conf(-1);
        initialize_Qmatrix();
        gamma = gamma_start + stepsize * n;
        // printf("Starting with gamma=%f\n", gamma);
        for (int i = 0; i < repetitions; i++) {
            changes = 1;
            assign_initial_conf(-1);
            initialize_Qmatrix();
            runs = 0;
            while (changes > 0 && runs < 250) {
                //initialize_lookup(kT,kmax,net->node_list->Size());
                if (!non_parallel) {
                    changes = HeatBathParallelLookupZeroTemp(gamma, prob, 1);
                    // printf("Changes %li\n", changes);
                } else {
                    acc = HeatBathLookupZeroTemp(gamma, prob, 1);
                    if (acc > (1.0 - 1.0 / double(q)) * 0.01) {
                        changes = 1;
                    } else {
                        changes = 0;
                    }
                    // printf("Acceptance: %f\n", acc);
                }
                runs++;
            }
            // printf("Finisched with Modularity: %1.6f bei Gamma=%1.6f\n",calculate_Q(), gamma);
//      fprintf(file,"%f\t%f\n",gamma_,acceptance);
//      fprintf(file2,"%f\t%f\n",gamma_,kT);
            //   fprintf(file3,"%f\t%d\n",gamma_,count_clusters(5));

            //Die Correlation berechnen
            n_cur = iter.First(net->node_list);
            while (!iter.End()) {
                n_cur2 = iter2.First(net->node_list);
                while (!iter2.End()) {
                    if (n_cur->Get_ClusterIndex() == n_cur2->Get_ClusterIndex()) {
                        correlation[n_cur->Get_Index()]->Set(n_cur2->Get_Index()) += 0.5;
                        correlation[n_cur2->Get_Index()]->Set(n_cur->Get_Index()) += 0.5;
                    }
                    n_cur2 = iter2.Next();
                }
                n_cur = iter.Next();
            }
        } // for i
    } //for n
    return gamma;
}
//#######################################################################
//-----------------------------------------------------------------------
//#######################################################################
// This function writes the Correlation Matrix that results from a
// Gamma-Sweep, this matrix is used to make ps files of it.
// ######################################################################
// long PottsModel::WriteCorrelationMatrix(char *filename)
// {
//   FILE *file, *file2;
//   char filename2[255];
//   NNode *n_cur, *n_cur2;
//   DLList_Iter iter, iter2;

//   sprintf(filename2,"%s.mat",filename);
//   file=fopen(filename,"w");
//   if (!file) {
//     printf("Could not open %s for writing.\n",filename);
//     return -1;
//   }
//   file2=fopen(filename2,"w");
//   if (!file2) {
//     printf("Could not open %s for writing.\n",filename2);
//     return -1;
//   }
//   //write the header in one line
//   n_cur=iter.First(net->node_list);
//   while (!iter.End())
//   {
//       fprintf(file, "\t%s",n_cur->Get_Name());
//       n_cur=iter.Next();
//   }
//   fprintf(file, "\n");

//   //fprintf(file, "%d\t%d\n",net->node_list->Size(),net->node_list->Size());

//   long r=0,c=0;
//   n_cur=iter.First(net->node_list);
//   while (!iter.End())
//   {
//     fprintf(file, "%s",n_cur->Get_Name());
//     r++;
//     n_cur2=iter2.First(net->node_list);
//     while (!iter2.End())
//     {
//       c++;
//       fprintf(file,"\t%f",correlation[n_cur->Get_Index()]->Get(n_cur2->Get_Index()));
//       fprintf(file2,"%li\t%li\t%f\n",r,c,correlation[n_cur->Get_Index()]->Get(n_cur2->Get_Index()));
//       n_cur2=iter2.Next();
//     }
//     fprintf(file,"\n");
//     n_cur=iter.Next();
//   }
//   fclose(file);
//   fclose(file2);
//   return 1;
// }
//##############################################################################

//#################################################################################################
PottsModelN::PottsModelN(network *n, unsigned int num_communities, bool directed) :
    degree_pos_in(NULL), degree_neg_in(NULL),
    degree_pos_out(NULL), degree_neg_out(NULL),
    degree_community_pos_in(NULL), degree_community_neg_in(NULL),
    degree_community_pos_out(NULL), degree_community_neg_out(NULL),
    csize(NULL), spin(NULL), neighbours(NULL), weights(NULL)
{
    //Set internal variable
    net = n;
    q   = num_communities;

    is_directed = directed;

    is_init = false;

    num_nodes   = net->node_list->Size();
}
//#######################################################
//Destructor of PottsModel
//########################################################
PottsModelN::~PottsModelN() {
    delete [] degree_pos_in;
    delete [] degree_neg_in;
    delete [] degree_pos_out;
    delete [] degree_neg_out;

    delete [] degree_community_pos_in;
    delete [] degree_community_neg_in;
    delete [] degree_community_pos_out;
    delete [] degree_community_neg_out;

    delete [] weights;
    delete [] neighbours;
    delete [] csize;

    delete [] spin;
}

void PottsModelN::assign_initial_conf(bool init_spins) {
#ifdef SPINGLASS_DEBUG
    printf("Start assigning.\n");
#endif
    unsigned int s;
    DLList_Iter iter;
    DLList_Iter l_iter;
    NNode *n_cur;
    NLink *l_cur;


    if (init_spins) {
#ifdef SPINGLASS_DEBUG
        printf("Initializing spin.\n");
#endif
        // Free the arrays before (re-)allocating them
        // These arrays are initialized to NULL, so it is safe to delete even before allocation
        delete [] degree_pos_in;
        delete [] degree_neg_in;
        delete [] degree_pos_out;
        delete [] degree_neg_out;

        delete [] spin;

        //Bookkeeping of the various degrees (positive/negative) and (in/out)
        degree_pos_in   = new double[num_nodes]; //Postive indegree of the nodes (or sum of weights)
        degree_neg_in   = new double[num_nodes]; //Negative indegree of the nodes (or sum of weights)
        degree_pos_out  = new double[num_nodes]; //Postive outdegree of the nodes (or sum of weights)
        degree_neg_out  = new double[num_nodes]; //Negative outdegree of the nodes (or sum of weights)

        spin            = new unsigned int[num_nodes]; //The spin state of each node
    }

    if (is_init) {
        delete [] degree_community_pos_in;
        delete [] degree_community_neg_in;
        delete [] degree_community_pos_out;
        delete [] degree_community_neg_out;

        delete [] weights;
        delete [] neighbours;
        delete [] csize;
    }

    is_init = true;

    //Bookkeep of occupation numbers of spin states or the number of links in community...
    degree_community_pos_in     = new double[q + 1]; //Positive sum of indegree for communities
    degree_community_neg_in     = new double[q + 1]; //Negative sum of indegree for communities
    degree_community_pos_out    = new double[q + 1]; //Positive sum of outegree for communities
    degree_community_neg_out    = new double[q + 1]; //Negative sum of outdegree for communities

    //...and of weights and neighbours for in the HeathBathLookup
    weights                     = new double[q + 1]; //The weights for changing to another spin state
    neighbours                  = new double[q + 1]; //The number of neighbours (or weights) in different spin states
    csize                       = new unsigned int[q + 1]; //The number of nodes in each community


    //Initialize communities
    for (unsigned int i = 0; i <= q; i++) {
        degree_community_pos_in[i]  = 0.0;
        degree_community_neg_in[i]  = 0.0;
        degree_community_pos_out[i] = 0.0;
        degree_community_neg_out[i] = 0.0;

        csize[i]                    = 0;
    }

    //Initialize vectors
    if (init_spins) {
        for (unsigned int i = 0; i < num_nodes; i++) {
            degree_pos_in[i]    = 0.0;
            degree_neg_in[i]    = 0.0;
            degree_pos_out[i]   = 0.0;
            degree_neg_out[i]   = 0.0;

#ifdef SPINGLASS_DEBUG
            printf("Initializing spin %d", i);
#endif
            spin[i] = 0;
        }
    }
    m_p = 0.0;
    m_n = 0.0;
    //Set community for each node, and
    //correctly store it in the bookkeeping

    double sum_weight_pos_in, sum_weight_pos_out, sum_weight_neg_in, sum_weight_neg_out;
    //double av_w = 0.0, av_k=0.0;
    //int l = 0;
#ifdef SPINGLASS_DEBUG
    printf("Visiting each node.\n");
#endif
    for (unsigned int v = 0; v < num_nodes; v++) {
        if (init_spins) {
            s = RNG_INTEGER(1, q);  //The new spin s
            spin[v] = (unsigned int)s;
        } else {
            s = spin[v];
        }

#ifdef SPINGLASS_DEBUG
        printf("Spin %d assigned to node %d.\n", s, v);
#endif

        n_cur               =  net->node_list->Get(v);

        l_cur               = l_iter.First(n_cur->Get_Links());

        sum_weight_pos_in   = 0.0;
        sum_weight_pos_out  = 0.0;
        sum_weight_neg_in   = 0.0;
        sum_weight_neg_out  = 0.0;

        while (!l_iter.End()) {
            double w = l_cur->Get_Weight();
            //av_w = (av_w*l + w)/(l+1); //Average weight
            //l++;
            if (l_cur->Get_Start() == n_cur) //From this to other, so outgoing link
                if (w > 0) {
                    sum_weight_pos_out += w;    //Increase positive outgoing weight
                } else {
                    sum_weight_neg_out -= w;    //Increase negative outgoing weight
                } else if (w > 0) {
                sum_weight_pos_in += w;    //Increase positive incoming weight
            } else {
                sum_weight_neg_in -= w;    //Increase negative incoming weight
            }

            l_cur = l_iter.Next();
        }

        if (!is_directed) {
            double sum_weight_pos       = sum_weight_pos_out + sum_weight_pos_in;
            sum_weight_pos_out   = sum_weight_pos;
            sum_weight_pos_in    = sum_weight_pos;
            double sum_weight_neg = sum_weight_neg_out + sum_weight_neg_in;
            sum_weight_neg_out   = sum_weight_neg;
            sum_weight_neg_in    = sum_weight_neg;
        }

        //av_k = (av_k*l + sum_weight_pos_in)/(l+1); //Average k

        if (init_spins) {
            //Set the degrees correctly
            degree_pos_in[v]    = sum_weight_pos_in;
            degree_neg_in[v]    = sum_weight_neg_in;
            degree_pos_out[v]   = sum_weight_pos_out;
            degree_neg_out[v]   = sum_weight_neg_out;
        }

        //Correct the community bookkeeping
        degree_community_pos_in[s]  += sum_weight_pos_in;
        degree_community_neg_in[s]  += sum_weight_neg_in;
        degree_community_pos_out[s] += sum_weight_pos_out;
        degree_community_neg_out[s] += sum_weight_neg_out;

        //Community just increased
        csize[s]++;

        //Sum the weights (notice that sum of indegrees equals sum of outdegrees)
        m_p += sum_weight_pos_in;
        m_n += sum_weight_neg_in;
    }

#ifdef SPINGLASS_DEBUG
    printf("Done assigning.\n");
#endif
}
//##############################################################
// This is the function generally used for optimisation,
// as the parallel update has its flaws, due to the cyclic attractors
//##############################################################
double PottsModelN::HeatBathLookup(double gamma, double lambda, double t, unsigned int max_sweeps) {
#ifdef SPINGLASS_DEBUG
    printf("Starting sweep at temperature %f.\n", t);
#endif
    DLList_Iter iter;
    DLList_Iter l_iter;
    DLList_Iter i_iter, i_iter2;
    NNode *node, *n_cur;
    NLink *l_cur;
    /* The new_spin contains the spin to which we will update,
     * the spin_opt is the optional spin we will consider and
     * the old_spin is the spin of the node we are currently
     * changing.
     */
    unsigned int new_spin, spin_opt, old_spin;
    unsigned int sweep; //current sweep
    unsigned long changes, problemcount; //Number of changes and number of problems encountered

    double exp_old_spin; //The expectation value for the old spin
    double exp_spin; //The expectation value for the other spin(s)
    int v; //The node we will be investigating

    //The variables required for the calculations
    double delta_pos_out, delta_pos_in, delta_neg_out, delta_neg_in;
    double k_v_pos_out, k_v_pos_in, k_v_neg_out, k_v_neg_in;

    //weight of edge
    double w;

    double beta = 1 / t; //Weight for probabilities
    double r = 0.0; //random number used for assigning new spin

    double maxweight = 0.0;
    double sum_weights = 0.0; //sum_weights for normalizing the probabilities

    sweep = 0;
    changes = 0;
    double m_pt = m_p;
    double m_nt = m_n;

    if (m_pt < 0.001) {
        m_pt = 1;
    }

    if (m_nt < 0.001) {
        m_nt = 1;
    }

    while (sweep < max_sweeps) {
        sweep++;
        //loop over all nodes in network
        for (unsigned int n = 0; n < num_nodes; n++) {
            //Look for a random node
            v = RNG_INTEGER(0, num_nodes - 1);
            //We will be investigating node v

            node = net->node_list->Get(v);

            /*******************************************/
            // initialize the neighbours and the weights
            problemcount = 0;
            for (unsigned int i = 0; i <= q; i++) {
                neighbours[i] = 0.0;
                weights[i] = 0.0;
            }

            //Loop over all links (=neighbours)
            l_cur = l_iter.First(node->Get_Links());
            while (!l_iter.End()) {
                w = l_cur->Get_Weight();
                if (node == l_cur->Get_Start()) {
                    n_cur = l_cur->Get_End();
                } else {
                    n_cur = l_cur->Get_Start();
                }
                //Add the link to the correct cluster
                neighbours[spin[n_cur->Get_Index()]] += w;
                l_cur = l_iter.Next();
            }
            //We now have the weight of the (in and out) neighbours
            //in each cluster available to us.
            /*******************************************/
            old_spin = spin[v];

            //Look for optimal spin

            //Set the appropriate variable
            delta_pos_out   = degree_pos_out[v];
            delta_pos_in    = degree_pos_in[v];
            delta_neg_out   = degree_neg_out[v];
            delta_neg_in    = degree_neg_in[v];

            k_v_pos_out     = gamma * delta_pos_out / m_pt;
            k_v_pos_in      = gamma * delta_pos_in / m_pt;
            k_v_neg_out     = lambda * delta_neg_out / m_nt;
            k_v_neg_in      = lambda * delta_neg_in / m_nt;

            //The expectation value for the old spin
            if (is_directed)
                exp_old_spin = (k_v_pos_out * (degree_community_pos_in[old_spin] - delta_pos_in) -
                                k_v_neg_out * (degree_community_neg_in[old_spin] - delta_neg_in)) +
                               (k_v_pos_in * (degree_community_pos_out[old_spin] - delta_pos_out) -
                                k_v_neg_in * (degree_community_neg_out[old_spin] - delta_neg_out));
            else
                exp_old_spin = (k_v_pos_out * (degree_community_pos_in[old_spin] - delta_pos_in) -
                                k_v_neg_out * (degree_community_neg_in[old_spin] - delta_neg_in));

            /*******************************************/
            //Calculating probabilities for each transition to another
            //community.

            maxweight = 0.0;
            weights[old_spin] = 0.0;

            for (spin_opt = 1; spin_opt <= q; spin_opt++) { // all possible new spins
                if (spin_opt != old_spin) { // except the old one!
                    if (is_directed)
                        exp_spin = (k_v_pos_out * degree_community_pos_in[spin_opt] - k_v_neg_out * degree_community_neg_in[spin_opt]) +
                                   (k_v_pos_in * degree_community_pos_out[spin_opt] - k_v_neg_in * degree_community_neg_out[spin_opt]);
                    else {
                        exp_spin = (k_v_pos_out * degree_community_pos_in[spin_opt] - k_v_neg_out * degree_community_neg_in[spin_opt]);
                    }

                    weights[spin_opt] = (neighbours[spin_opt] - exp_spin) - (neighbours[old_spin] - exp_old_spin);

                    if (weights[spin_opt] > maxweight) {
                        maxweight = weights[spin_opt];
                    }
                }
            }   // for spin

            //Calculate exp. prob. an
            sum_weights = 0.0;
            for (spin_opt = 1; spin_opt <= q; spin_opt++) { // all possible new spins
                weights[spin_opt] -= maxweight;  //subtract maxweight for numerical stability (otherwise overflow).
                weights[spin_opt]  = exp((double)(beta * weights[spin_opt]));
                sum_weights   += weights[spin_opt];
            }   // for spin
            /*******************************************/


            /*******************************************/
            //Choose a new spin dependent on the calculated probabilities
            r = RNG_UNIF(0, sum_weights);
            new_spin = 1;

            bool found = false;
            while (!found && new_spin <= q) {
                if (r <= weights[new_spin]) {
                    spin_opt = new_spin; //We have found are new spin
                    found = true;
                    break;
                } else {
                    r -= weights[new_spin];    //Perhaps the next spin is the one we want
                }

                new_spin++;
            }

            //Some weird thing happened. We haven't found a new spin
            //while that shouldn't be the case. Numerical problems?
            if (!found) {
                problemcount++;
            }

            new_spin = spin_opt;
            //If there wasn't a problem we should have found
            //our new spin.
            /*******************************************/


            /*******************************************/
            //The new spin is available to us, so change
            //all the appropriate counters.
            if (new_spin != old_spin) { // Did we really change something??
                changes++;
                spin[v] = new_spin;

                //The new spin increase by one, and the old spin decreases by one
                csize[new_spin]++; csize[old_spin]--;

                //Change the sums of degree for the old spin...
                degree_community_pos_in[old_spin]   -= delta_pos_in;
                degree_community_neg_in[old_spin]   -= delta_neg_in;
                degree_community_pos_out[old_spin]  -= delta_pos_out;
                degree_community_neg_out[old_spin]  -= delta_neg_out;

                //...and for the new spin
                degree_community_pos_in[new_spin]   += delta_pos_in;
                degree_community_neg_in[new_spin]   += delta_neg_in;
                degree_community_pos_out[new_spin]  += delta_pos_out;
                degree_community_neg_out[new_spin]  += delta_neg_out;
            }

            //We have no change a node from old_spin to new_spin
            /*******************************************/

        } // for n
    }  // while sweep
#ifdef SPINGLASS_DEBUG
    printf("Done %d sweeps.\n", max_sweeps);
    printf("%ld changes made for %d nodes.\n", changes, num_nodes);
    printf("Last node is %d and last random number is %f with sum of weights %f with spin %d.\n", v, r, sum_weights, old_spin);
#endif

    return (double(changes) / double(num_nodes) / double(sweep));
}

//We need to begin at a suitable temperature. That is, a temperature at which
//enough nodes may change their initially assigned communties
double PottsModelN::FindStartTemp(double gamma, double lambda, double ts) {
    double kT;
    kT = ts;
    //assing random initial condition
    assign_initial_conf(true);
    // the factor 1-1/q is important, since even, at infinite temperature,
    // only 1-1/q of all spins do change their state, since a randomly chooses new
    // state is with prob. 1/q the old state.
    double acceptance = 0.0;
    while (acceptance < (1.0 - 1.0 / double(q)) * 0.95) { //want 95% acceptance
        kT = kT * 1.1;
        acceptance = HeatBathLookup(gamma, lambda, kT, 50);
    }
    kT *= 1.1; // just to be sure...
    return kT;
}

long PottsModelN::WriteClusters(igraph_real_t *modularity,
                                igraph_real_t *temperature,
                                igraph_vector_t *community_size,
                                igraph_vector_t *membership,
                                igraph_matrix_t *adhesion,
                                igraph_matrix_t *normalised_adhesion,
                                igraph_real_t *polarization,
                                double t,
                                double d_p,
                                double d_n,
                                double gamma,
                                double lambda) {
    IGRAPH_UNUSED(gamma);
    IGRAPH_UNUSED(lambda);
#ifdef SPINGLASS_DEBUG
    printf("Start writing clusters.\n");
#endif
    //Reassign each community so that we retrieve a community assignment 1 through num_communities
    unsigned int *cluster_assign = new unsigned int[q + 1];
    for (unsigned int i = 0; i <= q; i++) {
        cluster_assign[i] = 0;
    }

    int num_clusters = 0;

    //Find out what the new communities will be
    for (unsigned int i = 0; i < num_nodes; i++) {
        unsigned int s = spin[i];
        if (cluster_assign[s] == 0) {
            num_clusters++;
            cluster_assign[s] = num_clusters;
#ifdef SPINGLASS_DEBUG
            printf("Setting cluster %d to %d.\n", s, num_clusters);
#endif
        }
    }


    /*
    DLList_Iter iter;
    NNode *n_cur=iter.First(net->node_list);
    n_cur = iter.First(net->node_list);
    */

    //And now assign each node to its new community
    q = num_clusters;
    for (unsigned int i = 0; i < num_nodes; i++) {
#ifdef SPINGLASS_DEBUG
        printf("Setting node %d to %d.\n", i, cluster_assign[spin[i]]);
#endif
        unsigned int s = cluster_assign[spin[i]];
        spin[i] = s;
#ifdef SPINGLASS_DEBUG
        printf("Have set node %d to %d.\n", i, s);
#endif
    }
    assign_initial_conf(false);

    delete[] cluster_assign;

    if (temperature) {
        *temperature = t;
    }

    if (community_size) {
        //Initialize the vector
        IGRAPH_CHECK(igraph_vector_resize(community_size, q));
        for (unsigned int spin_opt = 1; spin_opt <= q; spin_opt++) {
            //Set the community size
            VECTOR(*community_size)[spin_opt - 1] = csize[spin_opt];
        }
    }

    //Set the membership
    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, num_nodes));
        for (unsigned int i = 0; i < num_nodes; i++) {
            VECTOR(*membership)[ i ] = spin[i] - 1;
        }
    }

    double Q = 0.0; //Modularity
    if (adhesion) {
        IGRAPH_CHECK(igraph_matrix_resize(adhesion, q, q));
        IGRAPH_CHECK(igraph_matrix_resize(normalised_adhesion, q, q));

        double **num_links_pos = NULL;
        double **num_links_neg = NULL;
        //memory allocated for elements of rows.
        num_links_pos = new double *[q + 1] ;
        num_links_neg = new double *[q + 1] ;

        //memory allocated for  elements of each column.
        for ( unsigned int i = 0 ; i < q + 1 ; i++) {
            num_links_pos[i] = new double[q + 1];
            num_links_neg[i] = new double[q + 1];
        }



        //Init num_links
        for (unsigned int i = 0; i <= q; i++) {
            for (unsigned int j = 0; j <= q; j++) {
                num_links_pos[i][j] = 0.0;
                num_links_neg[i][j] = 0.0;
            }
        }

        DLList_Iter iter_l;
        NLink *l_cur = iter_l.First(net->link_list);

        double w = 0.0;

        while (!iter_l.End()) {
            w = l_cur->Get_Weight();
            unsigned int a = spin[l_cur->Get_Start()->Get_Index()];
            unsigned int b =  spin[l_cur->Get_End()->Get_Index()];
            if (w > 0) {
                num_links_pos[a][b] += w;
                if (!is_directed && a != b) { //Only one edge is defined in case it is undirected
                    num_links_pos[b][a] += w;
                }
            } else {
                num_links_neg[a][b] -= w;
                if (!is_directed && a != b) { //Only one edge is defined in case it is undirected
                    num_links_neg[b][a] -= w;
                }
            }

            l_cur = iter_l.Next();
        } //while links

#ifdef SPINGLASS_DEBUG
        printf("d_p: %f\n", d_p);
        printf("d_n: %f\n", d_n);
#endif

        double expected = 0.0;
        double a = 0.0;
        double normal_a = 0.0;

        double delta, u_p, u_n;
        double max_expected, max_a;

        //We don't take into account the lambda or gamma for
        //computing the modularity and adhesion, since they
        //are then incomparable to other definitions.
        for (unsigned int i = 1; i <= q; i++) {
            for (unsigned int j = 1; j <= q; j++) {
                if (!is_directed && i == j)
                    expected    = degree_community_pos_out[i] * degree_community_pos_in[j] / (m_p == 0 ? 1 : 2 * m_p)
                                  - degree_community_neg_out[i] * degree_community_neg_in[j] / (m_n == 0 ? 1 : 2 * m_n);
                else
                    expected    = degree_community_pos_out[i] * degree_community_pos_in[j] / (m_p == 0 ? 1 : m_p)
                                  - degree_community_neg_out[i] * degree_community_neg_in[j] / (m_n == 0 ? 1 : m_n);

                a           = (num_links_pos[i][j] - num_links_neg[i][j]) - expected;

                if (i == j) { //cohesion
                    if (is_directed) {
                        delta = d_p * csize[i] * (csize[i] - 1);    //Maximum amount
                    } else {
                        delta = d_p * csize[i] * (csize[i] - 1) / 2;    //Maximum amount
                    }

                    u_p     = delta - num_links_pos[i][i]; //Add as many positive links we can
                    u_n     = -num_links_neg[i][i]; //Delete as many negative links we can
                    Q      += a;
                } else { //adhesion
                    if (is_directed) {
                        delta = d_n * csize[i] * csize[j] * 2;    //Maximum amount
                    } else {
                        delta = d_n * csize[i] * csize[j];    //Maximum amount
                    }

                    u_p     = -num_links_pos[i][j]; //Delete as many positive links we can
                    u_n     = delta - num_links_neg[i][j]; //Add as many negative links we can
                }

                if (!is_directed && i == j)
                    max_expected    = (degree_community_pos_out[i] + u_p) * (degree_community_pos_in[j] + u_p) / ((m_p + u_p) == 0 ? 1 : 2 * (m_p + u_p))
                                      - (degree_community_neg_out[i] - u_n) * (degree_community_neg_in[j] + u_n) / ((m_n + u_n) == 0 ? 1 : 2 * (m_n + u_n));
                else
                    max_expected    = (degree_community_pos_out[i] + u_p) * (degree_community_pos_in[j] + u_p) / ((m_p + u_p) == 0 ? 1 : m_p + u_p)
                                      - (degree_community_neg_out[i] - u_n) * (degree_community_neg_in[j] + u_n) / ((m_n + u_n) == 0 ? 1 : m_n + u_n);
                //printf("%f/%f %d/%d\t", num_links_pos[i][j], num_links_neg[i][j], csize[i], csize[j]);
                //printf("%f/%f - %f(%f)\t", u_p, u_n, expected, max_expected);
                max_a           = ((num_links_pos[i][j] + u_p) - (num_links_neg[i][j] + u_n)) - max_expected;


                //In cases where we haven't actually found a ground state
                //the adhesion/cohesion *might* not be negative/positive,
                //hence the maximum adhesion and cohesion might behave quite
                //strangely. In order to prevent that, we limit them to 1 in
                //absolute value, and prevent from dividing by zero (even if
                //chuck norris would).
                if (i == j) {
                    normal_a = a / (max_a == 0 ? a : max_a);
                } else {
                    normal_a = -a / (max_a == 0 ? a : max_a);
                }

                if (normal_a > 1) {
                    normal_a = 1;
                } else if (normal_a < -1) {
                    normal_a = -1;
                }

                MATRIX(*adhesion, i - 1, j - 1) = a;
                MATRIX(*normalised_adhesion, i - 1, j - 1) = normal_a;
            } //for j
            //printf("\n");
        } //for i

        //free the allocated memory
        for ( unsigned int i = 0 ; i < q + 1 ; i++ ) {
            delete [] num_links_pos[i] ;
            delete [] num_links_neg[i];
        }
        delete [] num_links_pos ;
        delete [] num_links_neg ;

    } //adhesion

    if (modularity) {
        if (is_directed) {
            *modularity = Q / (m_p + m_n);
        } else {
            *modularity = 2 * Q / (m_p + m_n);    //Correction for the way m_p and m_n are counted. Modularity is 1/m, not 1/2m
        }
    }

    if (polarization) {
        double sum_ad = 0.0;
        for (unsigned int i = 0; i < q; i++) {
            for (unsigned int j = 0; j < q; j++) {
                if (i != j) {
                    sum_ad -= MATRIX(*normalised_adhesion, i, j);
                }
            }
        }
        *polarization = sum_ad / (q * q - q);
    }
#ifdef SPINGLASS_DEBUG
    printf("Finished writing cluster.\n");
#endif
    return num_nodes;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/spinglass/pottsmodel_2.h0000644000175100001710000001704300000000000027261 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Jörg Reichardt
   This file was modified by Vincent Traag
   The original copyright notice follows here */

/***************************************************************************
                          pottsmodel.h  -  description
                             -------------------
    begin                : Fri May 28 2004
    copyright            : (C) 2004 by
    email                :
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef POTTSMODEL_H
#define POTTSMODEL_H

#include "NetDataTypes.h"

#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"

// Simple matrix class with heap allocation, allowing mat[i][j] indexing.
class SimpleMatrix {
    double *data;
    size_t n;

public:
    explicit SimpleMatrix(size_t n_) : n(n_) { data = new double[n*n]; }
    ~SimpleMatrix() { delete [] data; }

    // Return a pointer to the i'th column, which can be indexed into using a second [] operator.
    // We assume column-major storage.
    double *operator [] (size_t i) { return &(data[n*i]); }
};

class PottsModel {
private:
    //  HugeArray neg_gammalookup;
    //  HugeArray pos_gammalookup;
    DL_Indexed_List *new_spins;
    DL_Indexed_List *previous_spins;
    HugeArray*> correlation;
    network *net;
    unsigned int q;
    unsigned int operation_mode;
    // FILE *Qfile, *Magfile;
    SimpleMatrix Qmatrix;
    double* Qa;
    double* weights;
    double total_degree_sum;
    unsigned long num_of_nodes;
    unsigned long num_of_links;
    unsigned long k_max;
    double energy;
    double acceptance;
    double *neighbours;
public:
    PottsModel(network *net, unsigned int q, int norm_by_degree);
    ~PottsModel();
    double* color_field;
    unsigned long assign_initial_conf(int spin);
    unsigned long initialize_lookup(double kT, double gamma);
    double initialize_Qmatrix();
    double calculate_Q();
    double calculate_genQ(double gamma);
    double FindStartTemp(double gamma, double prob,  double ts);
    long   HeatBathParallelLookupZeroTemp(double gamma, double prob, unsigned int max_sweeps);
    double HeatBathLookupZeroTemp(double gamma, double prob, unsigned int max_sweeps);
    long   HeatBathParallelLookup(double gamma, double prob, double kT, unsigned int max_sweeps);
    double HeatBathLookup(double gamma, double prob, double kT, unsigned int max_sweeps);
    double GammaSweep(double gamma_start, double gamma_stop, double prob, unsigned int steps, bool non_parallel = true, int repetitions = 1);
    double GammaSweepZeroTemp(double gamma_start, double gamma_stop, double prob, unsigned int steps, bool non_parallel = true, int repetitions = 1);
    // long   WriteCorrelationMatrix(char *filename);
    double calculate_energy(double gamma);
    long   WriteClusters(igraph_real_t *modularity,
                         igraph_real_t *temperature,
                         igraph_vector_t *csize, igraph_vector_t *membership,
                         double kT, double gamma);
    // long   WriteSoftClusters(char *filename, double threshold);
    double Get_Energy() const {
        return energy;
    }
    double FindCommunityFromStart(double gamma, double prob, char *nodename,
                                  igraph_vector_t *result,
                                  igraph_real_t *cohesion,
                                  igraph_real_t *adhesion,
                                  igraph_integer_t *inner_links,
                                  igraph_integer_t *outer_links);
};


class PottsModelN {
private:
    //  HugeArray neg_gammalookup;
    //  HugeArray pos_gammalookup;
    // DL_Indexed_List *new_spins;
    // DL_Indexed_List *previous_spins;
    HugeArray*> correlation;
    network *net;

    unsigned int q; //number of communities
    double m_p; //number of positive ties (or sum of degrees), this equals the number of edges only if it is undirected and each edge has a weight of 1
    double m_n; //number of negative ties (or sum of degrees)
    unsigned int num_nodes; //number of nodes
    bool is_directed;

    bool is_init;

    double *degree_pos_in; //Postive indegree of the nodes (or sum of weights)
    double *degree_neg_in; //Negative indegree of the nodes (or sum of weights)
    double *degree_pos_out; //Postive outdegree of the nodes (or sum of weights)
    double *degree_neg_out; //Negative outdegree of the nodes (or sum of weights)

    double *degree_community_pos_in; //Positive sum of indegree for communities
    double *degree_community_neg_in; //Negative sum of indegree for communities
    double *degree_community_pos_out; //Positive sum of outegree for communities
    double *degree_community_neg_out; //Negative sum of outdegree for communities

    unsigned int *csize; //The number of nodes in each community
    unsigned int *spin; //The membership of each node

    double *neighbours; //Array of neighbours of a vertex in each community
    double *weights; //Weights of all possible transitions to another community

public:
    PottsModelN(network *n, unsigned int num_communities, bool directed);
    ~PottsModelN();
    void assign_initial_conf(bool init_spins);
    double FindStartTemp(double gamma, double lambda, double ts);
    double HeatBathLookup(double gamma, double lambda, double t, unsigned int max_sweeps);
    // double HeatBathJoin(double gamma, double lambda);
    // double HeatBathLookupZeroTemp(double gamma, double lambda, unsigned int max_sweeps);
    long WriteClusters(igraph_real_t *modularity,
                       igraph_real_t *temperature,
                       igraph_vector_t *community_size,
                       igraph_vector_t *membership,
                       igraph_matrix_t *adhesion,
                       igraph_matrix_t *normalised_adhesion,
                       igraph_real_t *polarization,
                       double t,
                       double d_p,
                       double d_n,
                       double gamma,
                       double lambda);
};

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4911406
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/0000755000175100001710000000000000000000000024312 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap.cpp0000644000175100001710000001512700000000000026651 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: walktrap.cpp
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

#include "walktrap_graph.h"
#include "walktrap_communities.h"

#include "igraph_community.h"
#include "igraph_components.h"
#include "igraph_interface.h"
#include "core/interruption.h"

using namespace igraph::walktrap;

/**
 * \function igraph_community_walktrap
 *
 * This function is the implementation of the Walktrap community
 * finding algorithm, see Pascal Pons, Matthieu Latapy: Computing
 * communities in large networks using random walks,
 * https://arxiv.org/abs/physics/0512106
 *
 * 
 * Currently the original C++ implementation is used in igraph,
 * see https://www-complexnetworks.lip6.fr/~latapy/PP/walktrap.html
 * We are grateful to Matthieu Latapy and Pascal Pons for providing this
 * source code.
 *
 * 
 * In contrast to the original implementation, isolated vertices are allowed
 * in the graph and they are assumed to have a single incident loop edge with
 * weight 1.
 *
 * \param graph The input graph, edge directions are ignored.
 * \param weights Numeric vector giving the weights of the edges.
 *     If it is a NULL pointer then all edges will have equal
 *     weights. The weights are expected to be positive.
 * \param steps Integer constant, the length of the random walks.
 * \param merges Pointer to a matrix, the merges performed by the
 *     algorithm will be stored here (if not NULL). Each merge is a
 *     row in a two-column matrix and contains the ids of the merged
 *     clusters. Clusters are numbered from zero and cluster numbers
 *     smaller than the number of nodes in the network belong to the
 *     individual vertices as singleton clusters. In each step a new
 *     cluster is created from two other clusters and its id will be
 *     one larger than the largest cluster id so far. This means that
 *     before the first merge we have \c n clusters (the number of
 *     vertices in the graph) numbered from zero to \c n-1. The first
 *     merge creates cluster \c n, the second cluster \c n+1, etc.
 * \param modularity Pointer to a vector. If not NULL then the
 *     modularity score of the current clustering is stored here after
 *     each merge operation.
 * \param membership Pointer to a vector. If not a NULL pointer, then
 *     the membership vector corresponding to the maximal modularity
 *     score is stored here. If it is not a NULL pointer, then neither
 *     \p modularity nor \p merges may be NULL.
 * \return Error code.
 *
 * \sa \ref igraph_community_spinglass(), \ref
 * igraph_community_edge_betweenness().
 *
 * Time complexity: O(|E||V|^2) in the worst case, O(|V|^2 log|V|) typically,
 * |V| is the number of vertices, |E| is the number of edges.
 *
 * \example examples/simple/walktrap.c
 */

int igraph_community_walktrap(const igraph_t *graph,
                              const igraph_vector_t *weights,
                              int steps,
                              igraph_matrix_t *merges,
                              igraph_vector_t *modularity,
                              igraph_vector_t *membership) {

    long int no_of_nodes = (long int)igraph_vcount(graph);
    int length = steps;
    long max_memory = -1;

    if (membership && !(modularity && merges)) {
        IGRAPH_ERROR("Cannot calculate membership without modularity or merges",
                     IGRAPH_EINVAL);
    }

    Graph G;
    if (G.convert_from_igraph(graph, weights)) {
        IGRAPH_ERROR("Cannot convert igraph graph into walktrap format", IGRAPH_EINVAL);
    }

    if (merges) {
        igraph_integer_t no;
        IGRAPH_CHECK(igraph_clusters(graph, /*membership=*/ 0, /*csize=*/ 0,
                                     &no, IGRAPH_WEAK));
        IGRAPH_CHECK(igraph_matrix_resize(merges, no_of_nodes - no, 2));
    }
    if (modularity) {
        IGRAPH_CHECK(igraph_vector_resize(modularity, no_of_nodes));
        igraph_vector_null(modularity);
    }
    Communities C(&G, length, max_memory, merges, modularity);

    while (!C.H->is_empty()) {
        IGRAPH_ALLOW_INTERRUPTION();
        C.merge_nearest_communities();
    }

    if (membership) {
        long int m;
        m = no_of_nodes > 0 ? igraph_vector_which_max(modularity) : 0;
        IGRAPH_CHECK(igraph_community_to_membership(merges, no_of_nodes,
                     /*steps=*/ m,
                     membership,
                     /*csize=*/ NULL));
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_communities.cpp0000644000175100001710000010131000000000000031253 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: communities.cpp
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

#include "walktrap_communities.h"
#include "config.h"
#include 
#include 

using namespace std;

namespace igraph {

namespace walktrap {

IGRAPH_THREAD_LOCAL int Probabilities::length = 0;
IGRAPH_THREAD_LOCAL Communities* Probabilities::C = 0;
IGRAPH_THREAD_LOCAL float* Probabilities::tmp_vector1 = 0;
IGRAPH_THREAD_LOCAL float* Probabilities::tmp_vector2 = 0;
IGRAPH_THREAD_LOCAL int* Probabilities::id = 0;
IGRAPH_THREAD_LOCAL int* Probabilities::vertices1 = 0;
IGRAPH_THREAD_LOCAL int* Probabilities::vertices2 = 0;
IGRAPH_THREAD_LOCAL int Probabilities::current_id = 0;


Neighbor::Neighbor() {
    next_community1 = 0;
    previous_community1 = 0;
    next_community2 = 0;
    previous_community2 = 0;
    heap_index = -1;
}

Probabilities::~Probabilities() {
    C->memory_used -= memory();
    if (P) {
        delete[] P;
    }
    if (vertices) {
        delete[] vertices;
    }
}

Probabilities::Probabilities(int community) {
    Graph* G = C->G;
    int nb_vertices1 = 0;
    int nb_vertices2 = 0;

    float initial_proba = 1. / float(C->communities[community].size);
    int last =  C->members[C->communities[community].last_member];
    for (int m = C->communities[community].first_member; m != last; m = C->members[m]) {
        tmp_vector1[m] = initial_proba;
        vertices1[nb_vertices1++] = m;
    }

    for (int t = 0; t < length; t++) {
        current_id++;
        if (nb_vertices1 > (G->nb_vertices / 2)) {
            nb_vertices2 = G->nb_vertices;
            for (int i = 0; i < G->nb_vertices; i++) {
                tmp_vector2[i] = 0.;
            }
            if (nb_vertices1 == G->nb_vertices) {
                for (int i = 0; i < G->nb_vertices; i++) {
                    float proba = tmp_vector1[i] / G->vertices[i].total_weight;
                    for (int j = 0; j < G->vertices[i].degree; j++) {
                        tmp_vector2[G->vertices[i].edges[j].neighbor] += proba * G->vertices[i].edges[j].weight;
                    }
                }
            } else {
                for (int i = 0; i < nb_vertices1; i++) {
                    int v1 = vertices1[i];
                    float proba = tmp_vector1[v1] / G->vertices[v1].total_weight;
                    for (int j = 0; j < G->vertices[v1].degree; j++) {
                        tmp_vector2[G->vertices[v1].edges[j].neighbor] += proba * G->vertices[v1].edges[j].weight;
                    }
                }
            }
        } else {
            nb_vertices2 = 0;
            for (int i = 0; i < nb_vertices1; i++) {
                int v1 = vertices1[i];
                float proba = tmp_vector1[v1] / G->vertices[v1].total_weight;
                for (int j = 0; j < G->vertices[v1].degree; j++) {
                    int v2 = G->vertices[v1].edges[j].neighbor;
                    if (id[v2] == current_id) {
                        tmp_vector2[v2] += proba * G->vertices[v1].edges[j].weight;
                    } else {
                        tmp_vector2[v2] = proba * G->vertices[v1].edges[j].weight;
                        id[v2] = current_id;
                        vertices2[nb_vertices2++] = v2;
                    }
                }
            }
        }
        float* tmp = tmp_vector2;
        tmp_vector2 = tmp_vector1;
        tmp_vector1 = tmp;

        int* tmp2 = vertices2;
        vertices2 = vertices1;
        vertices1 = tmp2;

        nb_vertices1 = nb_vertices2;
    }

    if (nb_vertices1 > (G->nb_vertices / 2)) {
        P = new float[G->nb_vertices];
        size = G->nb_vertices;
        vertices = 0;
        if (nb_vertices1 == G->nb_vertices) {
            for (int i = 0; i < G->nb_vertices; i++) {
                P[i] = tmp_vector1[i] / sqrt(G->vertices[i].total_weight);
            }
        } else {
            for (int i = 0; i < G->nb_vertices; i++) {
                P[i] = 0.;
            }
            for (int i = 0; i < nb_vertices1; i++) {
                P[vertices1[i]] = tmp_vector1[vertices1[i]] / sqrt(G->vertices[vertices1[i]].total_weight);
            }
        }
    } else {
        P = new float[nb_vertices1];
        size = nb_vertices1;
        vertices = new int[nb_vertices1];
        int j = 0;
        for (int i = 0; i < G->nb_vertices; i++) {
            if (id[i] == current_id) {
                P[j] = tmp_vector1[i] / sqrt(G->vertices[i].total_weight);
                vertices[j] = i;
                j++;
            }
        }
    }
    C->memory_used += memory();
}

Probabilities::Probabilities(int community1, int community2) {
    // The two following probability vectors must exist.
    // Do not call this function if it is not the case.
    Probabilities* P1 = C->communities[community1].P;
    Probabilities* P2 = C->communities[community2].P;

    float w1 = float(C->communities[community1].size) / float(C->communities[community1].size + C->communities[community2].size);
    float w2 = float(C->communities[community2].size) / float(C->communities[community1].size + C->communities[community2].size);


    if (P1->size == C->G->nb_vertices) {
        P = new float[C->G->nb_vertices];
        size = C->G->nb_vertices;
        vertices = 0;

        if (P2->size == C->G->nb_vertices) { // two full vectors
            for (int i = 0; i < C->G->nb_vertices; i++) {
                P[i] = P1->P[i] * w1 + P2->P[i] * w2;
            }
        } else { // P1 full vector, P2 partial vector
            int j = 0;
            for (int i = 0; i < P2->size; i++) {
                for (; j < P2->vertices[i]; j++) {
                    P[j] = P1->P[j] * w1;
                }
                P[j] = P1->P[j] * w1 + P2->P[i] * w2;
                j++;
            }
            for (; j < C->G->nb_vertices; j++) {
                P[j] = P1->P[j] * w1;
            }
        }
    } else {
        if (P2->size == C->G->nb_vertices) { // P1 partial vector, P2 full vector
            P = new float[C->G->nb_vertices];
            size = C->G->nb_vertices;
            vertices = 0;

            int j = 0;
            for (int i = 0; i < P1->size; i++) {
                for (; j < P1->vertices[i]; j++) {
                    P[j] = P2->P[j] * w2;
                }
                P[j] = P1->P[i] * w1 + P2->P[j] * w2;
                j++;
            }
            for (; j < C->G->nb_vertices; j++) {
                P[j] = P2->P[j] * w2;
            }
        } else { // two partial vectors
            int i = 0;
            int j = 0;
            int nb_vertices1 = 0;
            while ((i < P1->size) && (j < P2->size)) {
                if (P1->vertices[i] < P2->vertices[j]) {
                    tmp_vector1[P1->vertices[i]] = P1->P[i] * w1;
                    vertices1[nb_vertices1++] = P1->vertices[i];
                    i++;
                    continue;
                }
                if (P1->vertices[i] > P2->vertices[j]) {
                    tmp_vector1[P2->vertices[j]] = P2->P[j] * w2;
                    vertices1[nb_vertices1++] = P2->vertices[j];
                    j++;
                    continue;
                }
                tmp_vector1[P1->vertices[i]] = P1->P[i] * w1 + P2->P[j] * w2;
                vertices1[nb_vertices1++] = P1->vertices[i];
                i++;
                j++;
            }
            if (i == P1->size) {
                for (; j < P2->size; j++) {
                    tmp_vector1[P2->vertices[j]] = P2->P[j] * w2;
                    vertices1[nb_vertices1++] = P2->vertices[j];
                }
            } else {
                for (; i < P1->size; i++) {
                    tmp_vector1[P1->vertices[i]] = P1->P[i] * w1;
                    vertices1[nb_vertices1++] = P1->vertices[i];
                }
            }

            if (nb_vertices1 > (C->G->nb_vertices / 2)) {
                P = new float[C->G->nb_vertices];
                size = C->G->nb_vertices;
                vertices = 0;
                for (int i = 0; i < C->G->nb_vertices; i++) {
                    P[i] = 0.;
                }
                for (int i = 0; i < nb_vertices1; i++) {
                    P[vertices1[i]] = tmp_vector1[vertices1[i]];
                }
            } else {
                P = new float[nb_vertices1];
                size = nb_vertices1;
                vertices = new int[nb_vertices1];
                for (int i = 0; i < nb_vertices1; i++) {
                    vertices[i] = vertices1[i];
                    P[i] = tmp_vector1[vertices1[i]];
                }
            }
        }
    }

    C->memory_used += memory();
}

double Probabilities::compute_distance(const Probabilities* P2) const {
    double r = 0.;
    if (vertices) {
        if (P2->vertices) { // two partial vectors
            int i = 0;
            int j = 0;
            while ((i < size) && (j < P2->size)) {
                if (vertices[i] < P2->vertices[j]) {
                    r += P[i] * P[i];
                    i++;
                    continue;
                }
                if (vertices[i] > P2->vertices[j]) {
                    r += P2->P[j] * P2->P[j];
                    j++;
                    continue;
                }
                r += (P[i] - P2->P[j]) * (P[i] - P2->P[j]);
                i++;
                j++;
            }
            if (i == size) {
                for (; j < P2->size; j++) {
                    r += P2->P[j] * P2->P[j];
                }
            } else {
                for (; i < size; i++) {
                    r += P[i] * P[i];
                }
            }
        } else { // P1 partial vector, P2 full vector

            int i = 0;
            for (int j = 0; j < size; j++) {
                for (; i < vertices[j]; i++) {
                    r += P2->P[i] * P2->P[i];
                }
                r += (P[j] - P2->P[i]) * (P[j] - P2->P[i]);
                i++;
            }
            for (; i < P2->size; i++) {
                r += P2->P[i] * P2->P[i];
            }
        }
    } else {
        if (P2->vertices) { // P1 full vector, P2 partial vector
            int i = 0;
            for (int j = 0; j < P2->size; j++) {
                for (; i < P2->vertices[j]; i++) {
                    r += P[i] * P[i];
                }
                r += (P[i] - P2->P[j]) * (P[i] - P2->P[j]);
                i++;
            }
            for (; i < size; i++) {
                r += P[i] * P[i];
            }
        } else { // two full vectors
            for (int i = 0; i < size; i++) {
                r += (P[i] - P2->P[i]) * (P[i] - P2->P[i]);
            }
        }
    }
    return r;
}

long Probabilities::memory() {
    if (vertices) {
        return (sizeof(Probabilities) + long(size) * (sizeof(float) + sizeof(int)));
    } else {
        return (sizeof(Probabilities) + long(size) * sizeof(float));
    }
}

Community::Community() {
    P = 0;
    first_neighbor = 0;
    last_neighbor = 0;
    sub_community_of = -1;
    sub_communities[0] = -1;
    sub_communities[1] = -1;
    sigma = 0.;
    internal_weight = 0.;
    total_weight = 0.;
}

Community::~Community() {
    if (P) {
        delete P;
    }
}


Communities::Communities(Graph* graph, int random_walks_length,
                         long m, igraph_matrix_t *pmerges,
                         igraph_vector_t *pmodularity) {
    max_memory = m;
    memory_used = 0;
    G = graph;
    merges = pmerges;
    mergeidx = 0;
    modularity = pmodularity;

    Probabilities::C = this;
    Probabilities::length = random_walks_length;
    Probabilities::tmp_vector1 = new float[G->nb_vertices];
    Probabilities::tmp_vector2 = new float[G->nb_vertices];
    Probabilities::id = new int[G->nb_vertices];
    for (int i = 0; i < G->nb_vertices; i++) {
        Probabilities::id[i] = 0;
    }
    Probabilities::vertices1 = new int[G->nb_vertices];
    Probabilities::vertices2 = new int[G->nb_vertices];
    Probabilities::current_id = 0;


    members = new int[G->nb_vertices];
    for (int i = 0; i < G->nb_vertices; i++) {
        members[i] = -1;
    }

    H = new Neighbor_heap(G->nb_edges);
    communities = new Community[2 * G->nb_vertices];

// init the n single vertex communities

    if (max_memory != -1) {
        min_delta_sigma = new Min_delta_sigma_heap(G->nb_vertices * 2);
    } else {
        min_delta_sigma = 0;
    }

    for (int i = 0; i < G->nb_vertices; i++) {
        communities[i].this_community = i;
        communities[i].first_member = i;
        communities[i].last_member = i;
        communities[i].size = 1;
        communities[i].sub_community_of = 0;
    }

    nb_communities = G->nb_vertices;
    nb_active_communities = G->nb_vertices;

    for (int i = 0; i < G->nb_vertices; i++)
        for (int j = 0; j < G->vertices[i].degree; j++)
            if (i < G->vertices[i].edges[j].neighbor) {
                communities[i].total_weight += G->vertices[i].edges[j].weight / 2.;
                communities[G->vertices[i].edges[j].neighbor].total_weight += G->vertices[i].edges[j].weight / 2.;
                Neighbor* N = new Neighbor;
                N->community1 = i;
                N->community2 = G->vertices[i].edges[j].neighbor;
                N->delta_sigma = -1. / double(min(G->vertices[i].degree,  G->vertices[G->vertices[i].edges[j].neighbor].degree));
                N->weight = G->vertices[i].edges[j].weight;
                N->exact = false;
                add_neighbor(N);
            }

    if (max_memory != -1) {
        memory_used += min_delta_sigma->memory();
        memory_used += 2 * long(G->nb_vertices) * sizeof(Community);
        memory_used += long(G->nb_vertices) * (2 * sizeof(float) + 3 * sizeof(int)); // the static data of Probabilities class
        memory_used += H->memory() + long(G->nb_edges) * sizeof(Neighbor);
        memory_used += G->memory();
    }

    /*   int c = 0; */
    Neighbor* N = H->get_first();
    if (N == 0) {
        return;    /* this can happen if there are no edges */
    }
    while (!N->exact) {
        update_neighbor(N, compute_delta_sigma(N->community1, N->community2));
        N->exact = true;
        N = H->get_first();
        if (max_memory != -1) {
            manage_memory();
        }
        /* TODO: this could use igraph_progress */
        /*     if(!silent) { */
        /*       c++; */
        /*       for(int k = (500*(c-1))/G->nb_edges + 1; k <= (500*c)/G->nb_edges; k++) { */
        /*  if(k % 50 == 1) {cerr.width(2); cerr << endl << k/ 5 << "% ";} */
        /*  cerr << "."; */
        /*       } */
        /*     } */
    }

}

Communities::~Communities() {
    delete[] members;
    delete[] communities;
    delete H;
    if (min_delta_sigma) {
        delete min_delta_sigma;
    }

    delete[] Probabilities::tmp_vector1;
    delete[] Probabilities::tmp_vector2;
    delete[] Probabilities::id;
    delete[] Probabilities::vertices1;
    delete[] Probabilities::vertices2;
}

float Community::min_delta_sigma() {
    float r = 1.;
    for (Neighbor* N = first_neighbor; N != 0;) {
        if (N->delta_sigma < r) {
            r = N->delta_sigma;
        }
        if (N->community1 == this_community) {
            N = N->next_community1;
        } else {
            N = N->next_community2;
        }
    }
    return r;
}


void Community::add_neighbor(Neighbor* N) { // add a new neighbor at the end of the list
    if (last_neighbor) {
        if (last_neighbor->community1 == this_community) {
            last_neighbor->next_community1 = N;
        } else {
            last_neighbor->next_community2 = N;
        }

        if (N->community1 == this_community) {
            N->previous_community1 = last_neighbor;
        } else {
            N->previous_community2 = last_neighbor;
        }
    } else {
        first_neighbor = N;
        if (N->community1 == this_community) {
            N->previous_community1 = 0;
        } else {
            N->previous_community2 = 0;
        }
    }
    last_neighbor = N;
}

void Community::remove_neighbor(Neighbor* N) {  // remove a neighbor from the list
    if (N->community1 == this_community) {
        if (N->next_community1) {
//      if (N->next_community1->community1 == this_community)
            N->next_community1->previous_community1 = N->previous_community1;
//      else
//  N->next_community1->previous_community2 = N->previous_community1;
        } else {
            last_neighbor = N->previous_community1;
        }
        if (N->previous_community1) {
            if (N->previous_community1->community1 == this_community) {
                N->previous_community1->next_community1 = N->next_community1;
            } else {
                N->previous_community1->next_community2 = N->next_community1;
            }
        } else {
            first_neighbor = N->next_community1;
        }
    } else {
        if (N->next_community2) {
            if (N->next_community2->community1 == this_community) {
                N->next_community2->previous_community1 = N->previous_community2;
            } else {
                N->next_community2->previous_community2 = N->previous_community2;
            }
        } else {
            last_neighbor = N->previous_community2;
        }
        if (N->previous_community2) {
//      if (N->previous_community2->community1 == this_community)
//  N->previous_community2->next_community1 = N->next_community2;
//      else
            N->previous_community2->next_community2 = N->next_community2;
        } else {
            first_neighbor = N->next_community2;
        }
    }
}

void Communities::remove_neighbor(Neighbor* N) {
    communities[N->community1].remove_neighbor(N);
    communities[N->community2].remove_neighbor(N);
    H->remove(N);

    if (max_memory != -1) {
        if (N->delta_sigma == min_delta_sigma->delta_sigma[N->community1]) {
            min_delta_sigma->delta_sigma[N->community1] = communities[N->community1].min_delta_sigma();
            if (communities[N->community1].P) {
                min_delta_sigma->update(N->community1);
            }
        }

        if (N->delta_sigma == min_delta_sigma->delta_sigma[N->community2]) {
            min_delta_sigma->delta_sigma[N->community2] = communities[N->community2].min_delta_sigma();
            if (communities[N->community2].P) {
                min_delta_sigma->update(N->community2);
            }
        }
    }
}

void Communities::add_neighbor(Neighbor* N) {
    communities[N->community1].add_neighbor(N);
    communities[N->community2].add_neighbor(N);
    H->add(N);

    if (max_memory != -1) {
        if (N->delta_sigma < min_delta_sigma->delta_sigma[N->community1]) {
            min_delta_sigma->delta_sigma[N->community1] = N->delta_sigma;
            if (communities[N->community1].P) {
                min_delta_sigma->update(N->community1);
            }
        }

        if (N->delta_sigma < min_delta_sigma->delta_sigma[N->community2]) {
            min_delta_sigma->delta_sigma[N->community2] = N->delta_sigma;
            if (communities[N->community2].P) {
                min_delta_sigma->update(N->community2);
            }
        }
    }
}

void Communities::update_neighbor(Neighbor* N, float new_delta_sigma) {
    if (max_memory != -1) {
        if (new_delta_sigma < min_delta_sigma->delta_sigma[N->community1]) {
            min_delta_sigma->delta_sigma[N->community1] = new_delta_sigma;
            if (communities[N->community1].P) {
                min_delta_sigma->update(N->community1);
            }
        }

        if (new_delta_sigma < min_delta_sigma->delta_sigma[N->community2]) {
            min_delta_sigma->delta_sigma[N->community2] = new_delta_sigma;
            if (communities[N->community2].P) {
                min_delta_sigma->update(N->community2);
            }
        }

        float old_delta_sigma = N->delta_sigma;
        N->delta_sigma = new_delta_sigma;
        H->update(N);

        if (old_delta_sigma == min_delta_sigma->delta_sigma[N->community1]) {
            min_delta_sigma->delta_sigma[N->community1] = communities[N->community1].min_delta_sigma();
            if (communities[N->community1].P) {
                min_delta_sigma->update(N->community1);
            }
        }

        if (old_delta_sigma == min_delta_sigma->delta_sigma[N->community2]) {
            min_delta_sigma->delta_sigma[N->community2] = communities[N->community2].min_delta_sigma();
            if (communities[N->community2].P) {
                min_delta_sigma->update(N->community2);
            }
        }
    } else {
        N->delta_sigma = new_delta_sigma;
        H->update(N);
    }
}

void Communities::manage_memory() {
    while ((memory_used > max_memory) && !min_delta_sigma->is_empty()) {
        int c = min_delta_sigma->get_max_community();
        delete communities[c].P;
        communities[c].P = 0;
        min_delta_sigma->remove_community(c);
    }
}



void Communities::merge_communities(Neighbor* merge_N) {
    int c1 = merge_N->community1;
    int c2 = merge_N->community2;

    communities[nb_communities].first_member = communities[c1].first_member;  // merge the
    communities[nb_communities].last_member = communities[c2].last_member;    // two lists
    members[communities[c1].last_member] = communities[c2].first_member;      // of members

    communities[nb_communities].size = communities[c1].size + communities[c2].size;
    communities[nb_communities].this_community = nb_communities;
    communities[nb_communities].sub_community_of = 0;
    communities[nb_communities].sub_communities[0] = c1;
    communities[nb_communities].sub_communities[1] = c2;
    communities[nb_communities].total_weight = communities[c1].total_weight + communities[c2].total_weight;
    communities[nb_communities].internal_weight = communities[c1].internal_weight + communities[c2].internal_weight + merge_N->weight;
    communities[nb_communities].sigma = communities[c1].sigma + communities[c2].sigma + merge_N->delta_sigma;

    communities[c1].sub_community_of = nb_communities;
    communities[c2].sub_community_of = nb_communities;

// update the new probability vector...

    if (communities[c1].P && communities[c2].P) {
        communities[nb_communities].P = new Probabilities(c1, c2);
    }

    if (communities[c1].P) {
        delete communities[c1].P;
        communities[c1].P = 0;
        if (max_memory != -1) {
            min_delta_sigma->remove_community(c1);
        }
    }
    if (communities[c2].P) {
        delete communities[c2].P;
        communities[c2].P = 0;
        if (max_memory != -1) {
            min_delta_sigma->remove_community(c2);
        }
    }

    if (max_memory != -1) {
        min_delta_sigma->delta_sigma[c1] = -1.;         // to avoid to update the min_delta_sigma for these communities
        min_delta_sigma->delta_sigma[c2] = -1.;         //
        min_delta_sigma->delta_sigma[nb_communities] = -1.;
    }

// update the new neighbors
// by enumerating all the neighbors of c1 and c2

    Neighbor* N1 = communities[c1].first_neighbor;
    Neighbor* N2 = communities[c2].first_neighbor;

    while (N1 && N2) {
        int neighbor_community1;
        int neighbor_community2;

        if (N1->community1 == c1) {
            neighbor_community1 = N1->community2;
        } else {
            neighbor_community1 = N1->community1;
        }
        if (N2->community1 == c2) {
            neighbor_community2 = N2->community2;
        } else {
            neighbor_community2 = N2->community1;
        }

        if (neighbor_community1 < neighbor_community2) {
            Neighbor* tmp = N1;
            if (N1->community1 == c1) {
                N1 = N1->next_community1;
            } else {
                N1 = N1->next_community2;
            }
            remove_neighbor(tmp);
            Neighbor* N = new Neighbor;
            N->weight = tmp->weight;
            N->community1 = neighbor_community1;
            N->community2 = nb_communities;
            N->delta_sigma = (double(communities[c1].size + communities[neighbor_community1].size) * tmp->delta_sigma + double(communities[c2].size) * merge_N->delta_sigma) / (double(communities[c1].size + communities[c2].size + communities[neighbor_community1].size)); //compute_delta_sigma(neighbor_community1, nb_communities);
            N->exact = false;
            delete tmp;
            add_neighbor(N);
        }

        if (neighbor_community2 < neighbor_community1) {
            Neighbor* tmp = N2;
            if (N2->community1 == c2) {
                N2 = N2->next_community1;
            } else {
                N2 = N2->next_community2;
            }
            remove_neighbor(tmp);
            Neighbor* N = new Neighbor;
            N->weight = tmp->weight;
            N->community1 = neighbor_community2;
            N->community2 = nb_communities;
            N->delta_sigma = (double(communities[c1].size) * merge_N->delta_sigma + double(communities[c2].size + communities[neighbor_community2].size) * tmp->delta_sigma) / (double(communities[c1].size + communities[c2].size + communities[neighbor_community2].size)); //compute_delta_sigma(neighbor_community2, nb_communities);
            N->exact = false;
            delete tmp;
            add_neighbor(N);
        }

        if (neighbor_community1 == neighbor_community2) {
            Neighbor* tmp1 = N1;
            Neighbor* tmp2 = N2;
            bool exact = N1->exact && N2->exact;
            if (N1->community1 == c1) {
                N1 = N1->next_community1;
            } else {
                N1 = N1->next_community2;
            }
            if (N2->community1 == c2) {
                N2 = N2->next_community1;
            } else {
                N2 = N2->next_community2;
            }
            remove_neighbor(tmp1);
            remove_neighbor(tmp2);
            Neighbor* N = new Neighbor;
            N->weight = tmp1->weight + tmp2->weight;
            N->community1 = neighbor_community1;
            N->community2 = nb_communities;
            N->delta_sigma = (double(communities[c1].size + communities[neighbor_community1].size) * tmp1->delta_sigma + double(communities[c2].size + communities[neighbor_community1].size) * tmp2->delta_sigma - double(communities[neighbor_community1].size) * merge_N->delta_sigma) / (double(communities[c1].size + communities[c2].size + communities[neighbor_community1].size));
            N->exact = exact;
            delete tmp1;
            delete tmp2;
            add_neighbor(N);
        }
    }


    if (!N1) {
        while (N2) {
//      double delta_sigma2 = N2->delta_sigma;
            int neighbor_community;
            if (N2->community1 == c2) {
                neighbor_community = N2->community2;
            } else {
                neighbor_community = N2->community1;
            }
            Neighbor* tmp = N2;
            if (N2->community1 == c2) {
                N2 = N2->next_community1;
            } else {
                N2 = N2->next_community2;
            }
            remove_neighbor(tmp);
            Neighbor* N = new Neighbor;
            N->weight = tmp->weight;
            N->community1 = neighbor_community;
            N->community2 = nb_communities;
            N->delta_sigma = (double(communities[c1].size) * merge_N->delta_sigma + double(communities[c2].size + communities[neighbor_community].size) * tmp->delta_sigma) / (double(communities[c1].size + communities[c2].size + communities[neighbor_community].size)); //compute_delta_sigma(neighbor_community, nb_communities);
            N->exact = false;
            delete tmp;
            add_neighbor(N);
        }
    }
    if (!N2) {
        while (N1) {
//      double delta_sigma1 = N1->delta_sigma;
            int neighbor_community;
            if (N1->community1 == c1) {
                neighbor_community = N1->community2;
            } else {
                neighbor_community = N1->community1;
            }
            Neighbor* tmp = N1;
            if (N1->community1 == c1) {
                N1 = N1->next_community1;
            } else {
                N1 = N1->next_community2;
            }
            remove_neighbor(tmp);
            Neighbor* N = new Neighbor;
            N->weight = tmp->weight;
            N->community1 = neighbor_community;
            N->community2 = nb_communities;
            N->delta_sigma = (double(communities[c1].size + communities[neighbor_community].size) * tmp->delta_sigma + double(communities[c2].size) * merge_N->delta_sigma) / (double(communities[c1].size + communities[c2].size + communities[neighbor_community].size)); //compute_delta_sigma(neighbor_community, nb_communities);
            N->exact = false;
            delete tmp;
            add_neighbor(N);
        }
    }

    if (max_memory != -1) {
        min_delta_sigma->delta_sigma[nb_communities] = communities[nb_communities].min_delta_sigma();
        min_delta_sigma->update(nb_communities);
    }

    nb_communities++;
    nb_active_communities--;
}

double Communities::merge_nearest_communities() {
    Neighbor* N = H->get_first();
    while (!N->exact) {
        update_neighbor(N, compute_delta_sigma(N->community1, N->community2));
        N->exact = true;
        N = H->get_first();
        if (max_memory != -1) {
            manage_memory();
        }
    }

    double d = N->delta_sigma;
    remove_neighbor(N);

    merge_communities(N);
    if (max_memory != -1) {
        manage_memory();
    }

    if (merges) {
        MATRIX(*merges, mergeidx, 0) = N->community1;
        MATRIX(*merges, mergeidx, 1) = N->community2;
        mergeidx++;
    }

    if (modularity) {
        float Q = 0.;
        for (int i = 0; i < nb_communities; i++) {
            if (communities[i].sub_community_of == 0) {
                Q += (communities[i].internal_weight - communities[i].total_weight * communities[i].total_weight / G->total_weight) / G->total_weight;
            }
        }
        VECTOR(*modularity)[mergeidx] = Q;
    }

    delete N;

    /* This could use igraph_progress */
    /*   if(!silent) { */
    /*     for(int k = (500*(G->nb_vertices - nb_active_communities - 1))/(G->nb_vertices-1) + 1; k <= (500*(G->nb_vertices - nb_active_communities))/(G->nb_vertices-1); k++) { */
    /*       if(k % 50 == 1) {cerr.width(2); cerr << endl << k/ 5 << "% ";} */
    /*       cerr << "."; */
    /*     } */
    /*   } */
    return d;
}

double Communities::compute_delta_sigma(int community1, int community2) {
    if (!communities[community1].P) {
        communities[community1].P = new Probabilities(community1);
        if (max_memory != -1) {
            min_delta_sigma->update(community1);
        }
    }
    if (!communities[community2].P) {
        communities[community2].P = new Probabilities(community2);
        if (max_memory != -1) {
            min_delta_sigma->update(community2);
        }
    }

    return communities[community1].P->compute_distance(communities[community2].P) * double(communities[community1].size) * double(communities[community2].size) / double(communities[community1].size + communities[community2].size);
}

}
}    /* end of namespaces */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_communities.h0000644000175100001710000001561000000000000030727 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: communities.h
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details


#ifndef WALKTRAP_COMMUNITIES_H
#define WALKTRAP_COMMUNITIES_H

#include "walktrap_graph.h"
#include "walktrap_heap.h"
#include "igraph_community.h"
#include "config.h"

namespace igraph {

namespace walktrap {

class Communities;
class Probabilities {
public:
    static IGRAPH_THREAD_LOCAL float* tmp_vector1;    //
    static IGRAPH_THREAD_LOCAL float* tmp_vector2;    //
    static IGRAPH_THREAD_LOCAL int* id;       //
    static IGRAPH_THREAD_LOCAL int* vertices1;    //
    static IGRAPH_THREAD_LOCAL int* vertices2;    //
    static IGRAPH_THREAD_LOCAL int current_id;    //

    static IGRAPH_THREAD_LOCAL Communities* C;                    // pointer to all the communities
    static IGRAPH_THREAD_LOCAL int length;                        // length of the random walks


    int size;                         // number of probabilities stored
    int* vertices;                        // the vertices corresponding to the stored probabilities, 0 if all the probabilities are stored
    float* P;                         // the probabilities

    long memory();                        // the memory (in Bytes) used by the object
    double compute_distance(const Probabilities* P2) const;   // compute the squared distance r^2 between this probability vector and P2
    Probabilities(int community);                 // compute the probability vector of a community
    Probabilities(int community1, int community2);        // merge the probability vectors of two communities in a new one
    // the two communities must have their probability vectors stored

    ~Probabilities();                     // destructor
};

class Community {
public:

    Neighbor* first_neighbor; // first item of the list of adjacent communities
    Neighbor* last_neighbor;  // last item of the list of adjacent communities

    int this_community;       // number of this community
    int first_member;     // number of the first vertex of the community
    int last_member;      // number of the last vertex of the community
    int size;         // number of members of the community

    Probabilities* P;     // the probability vector, 0 if not stored.


    float sigma;          // sigma(C) of the community
    float internal_weight;    // sum of the weight of the internal edges
    float total_weight;       // sum of the weight of all the edges of the community (an edge between two communities is a half-edge for each community)

    int sub_communities[2];   // the two sub sommunities, -1 if no sub communities;
    int sub_community_of;     // number of the community in which this community has been merged
    // 0 if the community is active
    // -1 if the community is not used

    void merge(Community &C1, Community &C2); // create a new community by merging C1 an C2
    void add_neighbor(Neighbor* N);
    void remove_neighbor(Neighbor* N);
    float min_delta_sigma();          // compute the minimal delta sigma among all the neighbors of this community

    Community();          // create an empty community
    ~Community();         // destructor
};

class Communities {
private:
    long max_memory;  // size in Byte of maximal memory usage, -1 for no limit
    igraph_matrix_t *merges;
    long int mergeidx;
    igraph_vector_t *modularity;

public:

    long memory_used;                 // in bytes
    Min_delta_sigma_heap* min_delta_sigma;            // the min delta_sigma of the community with a saved probability vector (for memory management)

    Graph* G;         // the graph
    int* members;         // the members of each community represented as a chained list.
    // a community points to the first_member the array which contains
    // the next member (-1 = end of the community)
    Neighbor_heap* H;     // the distances between adjacent communities.


    Community* communities;   // array of the communities

    int nb_communities;       // number of valid communities
    int nb_active_communities;    // number of active communities

    Communities(Graph* G, int random_walks_length = 3,
                long max_memory = -1, igraph_matrix_t *merges = 0,
                igraph_vector_t *modularity = 0);  // Constructor
    ~Communities();                   // Destructor


    void merge_communities(Neighbor* N);          // create a community by merging two existing communities
    double merge_nearest_communities();


    double compute_delta_sigma(int c1, int c2);       // compute delta_sigma(c1,c2)

    void remove_neighbor(Neighbor* N);
    void add_neighbor(Neighbor* N);
    void update_neighbor(Neighbor* N, float new_delta_sigma);

    void manage_memory();

};

}
}       /* end of namespaces */

#endif // WALKTRAP_COMMUNITIES_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_graph.cpp0000644000175100001710000001521600000000000030031 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: graph.cpp
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

#include "walktrap_graph.h"
#include "igraph_interface.h"
#include 
#include       // strlen

using namespace std;

namespace igraph {

namespace walktrap {

bool operator<(const Edge& E1, const Edge& E2) {
    return (E1.neighbor < E2.neighbor);
}


Vertex::Vertex() {
    degree = 0;
    edges = 0;
    total_weight = 0.;
}

Vertex::~Vertex() {
    if (edges) {
        delete[] edges;
    }
}

Graph::Graph() {
    nb_vertices = 0;
    nb_edges = 0;
    vertices = 0;
    index = 0;
    total_weight = 0.;
}

Graph::~Graph () {
    if (vertices) {
        delete[] vertices;
    }
}

class Edge_list {
public:
    int* V1;
    int* V2;
    float* W;

    int size;
    int size_max;

    void add(int v1, int v2, float w);
    Edge_list() {
        size = 0;
        size_max = 1024;
        V1 = new int[1024];
        V2 = new int[1024];
        W = new float[1024];
    }
    ~Edge_list() {
        if (V1) {
            delete[] V1;
        }
        if (V2) {
            delete[] V2;
        }
        if (W) {
            delete[] W;
        }
    }
};

void Edge_list::add(int v1, int v2, float w) {
    if (size == size_max) {
        int* tmp1 = new int[2 * size_max];
        int* tmp2 = new int[2 * size_max];
        float* tmp3 = new float[2 * size_max];
        for (int i = 0; i < size_max; i++) {
            tmp1[i] = V1[i];
            tmp2[i] = V2[i];
            tmp3[i] = W[i];
        }
        delete[] V1;
        delete[] V2;
        delete[] W;
        V1 = tmp1;
        V2 = tmp2;
        W = tmp3;
        size_max *= 2;
    }
    V1[size] = v1;
    V2[size] = v2;
    W[size] = w;
    size++;
}

int Graph::convert_from_igraph(const igraph_t *graph,
                               const igraph_vector_t *weights) {
    Graph &G = *this;

    int max_vertex = (int)igraph_vcount(graph) - 1;
    long int no_of_edges = (long int)igraph_ecount(graph);
    long int i;
    long int deg;
    double w;

    Edge_list EL;

    for (i = 0; i < no_of_edges; i++) {
        igraph_integer_t from, to;
        int v1, v2;
        w = weights ? VECTOR(*weights)[i] : 1.0;
        igraph_edge(graph, i, &from, &to);
        v1 = (int)from; v2 = (int)to;
        EL.add(v1, v2, w);
    }

    G.nb_vertices = max_vertex + 1;
    G.vertices = new Vertex[G.nb_vertices];
    G.nb_edges = 0;
    G.total_weight = 0.0;

    for (int i = 0; i < EL.size; i++) {
        G.vertices[EL.V1[i]].degree++;
        G.vertices[EL.V2[i]].degree++;
        G.vertices[EL.V1[i]].total_weight += EL.W[i];
        G.vertices[EL.V2[i]].total_weight += EL.W[i];
        G.nb_edges++;
        G.total_weight += EL.W[i];
    }

    for (int i = 0; i < G.nb_vertices; i++) {
        deg = G.vertices[i].degree;
        w = (deg == 0) ? 1.0 : (G.vertices[i].total_weight / double(deg));
        G.vertices[i].edges = new Edge[deg + 1];
        G.vertices[i].edges[0].neighbor = i;
        G.vertices[i].edges[0].weight = w;
        G.vertices[i].total_weight += w;
        G.vertices[i].degree = 1;
    }

    for (int i = 0; i < EL.size; i++) {
        G.vertices[EL.V1[i]].edges[G.vertices[EL.V1[i]].degree].neighbor = EL.V2[i];
        G.vertices[EL.V1[i]].edges[G.vertices[EL.V1[i]].degree].weight = EL.W[i];
        G.vertices[EL.V1[i]].degree++;
        G.vertices[EL.V2[i]].edges[G.vertices[EL.V2[i]].degree].neighbor = EL.V1[i];
        G.vertices[EL.V2[i]].edges[G.vertices[EL.V2[i]].degree].weight = EL.W[i];
        G.vertices[EL.V2[i]].degree++;
    }

    for (int i = 0; i < G.nb_vertices; i++) {
        sort(G.vertices[i].edges, G.vertices[i].edges + G.vertices[i].degree);
    }

    for (int i = 0; i < G.nb_vertices; i++) { // merge multi edges
        int a = 0;
        for (int b = 1; b < G.vertices[i].degree; b++) {
            if (G.vertices[i].edges[b].neighbor == G.vertices[i].edges[a].neighbor) {
                G.vertices[i].edges[a].weight += G.vertices[i].edges[b].weight;
            } else {
                G.vertices[i].edges[++a] = G.vertices[i].edges[b];
            }
        }
        G.vertices[i].degree = a + 1;
    }

    return 0;
}

long Graph::memory() {
    size_t m = 0;
    m += size_t(nb_vertices) * sizeof(Vertex);
    m += 2 * size_t(nb_edges) * sizeof(Edge);
    m += sizeof(Graph);
    if (index != 0) {
        m += size_t(nb_vertices) * sizeof(char*);
        for (int i = 0; i < nb_vertices; i++) {
            m += strlen(index[i]) + 1;
        }
    }
    return m;
}

}
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_graph.h0000644000175100001710000000703000000000000027471 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here */

// File: graph.h
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

/* FSF address above was fixed by Tamas Nepusz */


#ifndef WALKTRAP_GRAPH_H
#define WALKTRAP_GRAPH_H

#include "igraph_community.h"

namespace igraph {

namespace walktrap {

class Edge {            // code an edge of a given vertex
public:
    int neighbor;         // the number of the neighbor vertex
    float weight;         // the weight of the edge
};
bool operator<(const Edge& E1, const Edge& E2);


class Vertex {
public:
    Edge* edges;          // the edges of the vertex
    int degree;           // number of neighbors
    float total_weight;       // the total weight of the vertex

    Vertex();         // creates empty vertex
    ~Vertex();            // destructor
};

class Graph {
public:
    int nb_vertices;      // number of vertices
    int nb_edges;         // number of edges
    float total_weight;       // total weight of the edges
    Vertex* vertices;     // array of the vertices

    long memory();            // the total memory used in Bytes
    Graph();          // create an empty graph
    ~Graph();         // destructor
    char** index;         // to keep the real name of the vertices

    int convert_from_igraph(const igraph_t * igraph,
                            const igraph_vector_t *weights);
};

}
}        /* end of namespaces */

#endif // WALKTRAP_GRAPH_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_heap.cpp0000644000175100001710000001512500000000000027644 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: heap.cpp
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pascal.pons@gmail.com
// Web page : http://www-rp.lip6.fr/~latapy/PP/walktrap.html
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

#include "walktrap_heap.h"

using namespace igraph::walktrap;

void Neighbor_heap::move_up(int index) {
    while (H[index / 2]->delta_sigma > H[index]->delta_sigma) {
        Neighbor* tmp = H[index / 2];
        H[index]->heap_index = index / 2;
        H[index / 2] = H[index];
        tmp->heap_index = index;
        H[index] = tmp;
        index = index / 2;
    }
}

void Neighbor_heap::move_down(int index) {
    while (true) {
        int min = index;
        if ((2 * index < size) && (H[2 * index]->delta_sigma < H[min]->delta_sigma)) {
            min = 2 * index;
        }
        if (2 * index + 1 < size && H[2 * index + 1]->delta_sigma < H[min]->delta_sigma) {
            min = 2 * index + 1;
        }
        if (min != index) {
            Neighbor* tmp = H[min];
            H[index]->heap_index = min;
            H[min] = H[index];
            tmp->heap_index = index;
            H[index] = tmp;
            index = min;
        } else {
            break;
        }
    }
}

Neighbor* Neighbor_heap::get_first() {
    if (size == 0) {
        return 0;
    } else {
        return H[0];
    }
}

void Neighbor_heap::remove(Neighbor* N) {
    if (N->heap_index == -1 || size == 0) {
        return;
    }
    Neighbor* last_N = H[--size];
    H[N->heap_index] = last_N;
    last_N->heap_index = N->heap_index;
    move_up(last_N->heap_index);
    move_down(last_N->heap_index);
    N->heap_index = -1;
}

void Neighbor_heap::add(Neighbor* N) {
    if (size >= max_size) {
        return;
    }
    N->heap_index = size++;
    H[N->heap_index] = N;
    move_up(N->heap_index);
}

void Neighbor_heap::update(Neighbor* N) {
    if (N->heap_index == -1) {
        return;
    }
    move_up(N->heap_index);
    move_down(N->heap_index);
}

long Neighbor_heap::memory() {
    return (sizeof(Neighbor_heap) + long(max_size) * sizeof(Neighbor*));
}

Neighbor_heap::Neighbor_heap(int max_s) {
    max_size = max_s;
    size = 0;
    H = new Neighbor*[max_s];
}

Neighbor_heap::~Neighbor_heap() {
    delete[] H;
}

bool Neighbor_heap::is_empty() {
    return (size == 0);
}



//#################################################################

void Min_delta_sigma_heap::move_up(int index) {
    while (delta_sigma[H[index / 2]] < delta_sigma[H[index]]) {
        int tmp = H[index / 2];
        I[H[index]] = index / 2;
        H[index / 2] = H[index];
        I[tmp] = index;
        H[index] = tmp;
        index = index / 2;
    }
}

void Min_delta_sigma_heap::move_down(int index) {
    while (true) {
        int max = index;
        if (2 * index < size && delta_sigma[H[2 * index]] > delta_sigma[H[max]]) {
            max = 2 * index;
        }
        if (2 * index + 1 < size && delta_sigma[H[2 * index + 1]] > delta_sigma[H[max]]) {
            max = 2 * index + 1;
        }
        if (max != index) {
            int tmp = H[max];
            I[H[index]] = max;
            H[max] = H[index];
            I[tmp] = index;
            H[index] = tmp;
            index = max;
        } else {
            break;
        }
    }
}

int Min_delta_sigma_heap::get_max_community() {
    if (size == 0) {
        return -1;
    } else {
        return H[0];
    }
}

void Min_delta_sigma_heap::remove_community(int community) {
    if (I[community] == -1 || size == 0) {
        return;
    }
    int last_community = H[--size];
    H[I[community]] = last_community;
    I[last_community] = I[community];
    move_up(I[last_community]);
    move_down(I[last_community]);
    I[community] = -1;
}

void Min_delta_sigma_heap::update(int community) {
    if (community < 0 || community >= max_size) {
        return;
    }
    if (I[community] == -1) {
        I[community] = size++;
        H[I[community]] = community;
    }
    move_up(I[community]);
    move_down(I[community]);
}

long Min_delta_sigma_heap::memory() {
    return (sizeof(Min_delta_sigma_heap) + long(max_size) * (2 * sizeof(int) + sizeof(float)));
}

Min_delta_sigma_heap::Min_delta_sigma_heap(int max_s) {
    max_size = max_s;
    size = 0;
    H = new int[max_s];
    I = new int[max_s];
    delta_sigma = new float[max_s];
    for (int i = 0; i < max_size; i++) {
        I[i] = -1;
        delta_sigma[i] = 1.;
    }
}

Min_delta_sigma_heap::~Min_delta_sigma_heap() {
    delete[] H;
    delete[] I;
    delete[] delta_sigma;
}

bool Min_delta_sigma_heap::is_empty() {
    return (size == 0);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/community/walktrap/walktrap_heap.h0000644000175100001710000001062300000000000027307 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* The original version of this file was written by Pascal Pons
   The original copyright notice follows here. The FSF address was
   fixed by Tamas Nepusz */

// File: heap.h
//-----------------------------------------------------------------------------
// Walktrap v0.2 -- Finds community structure of networks using random walks
// Copyright (C) 2004-2005 Pascal Pons
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//-----------------------------------------------------------------------------
// Author   : Pascal Pons
// Email    : pons@liafa.jussieu.fr
// Web page : http://www.liafa.jussieu.fr/~pons/
// Location : Paris, France
// Time     : June 2005
//-----------------------------------------------------------------------------
// see readme.txt for more details

#ifndef WALKTRAP_HEAP_H
#define WALKTRAP_HEAP_H

namespace igraph {

namespace walktrap {

class Neighbor {
public:
    int community1;   // the two adjacent communities
    int community2;   // community1 < community2

    float delta_sigma;    // the delta sigma between the two communities
    float weight;     // the total weight of the edges between the two communities
    bool exact;       // true if delta_sigma is exact, false if it is only a lower bound

    Neighbor* next_community1;        // pointers of two double
    Neighbor* previous_community1;    // chained lists containing
    Neighbor* next_community2;        // all the neighbors of
    Neighbor* previous_community2;    // each communities.

    int heap_index;   //

    Neighbor();
};


class Neighbor_heap {
private:
    int size;
    int max_size;

    Neighbor** H;   // the heap that contains a pointer to each Neighbor object stored

    void move_up(int index);
    void move_down(int index);

public:
    void add(Neighbor* N);        // add a new distance
    void update(Neighbor* N);     // update a distance
    void remove(Neighbor* N);     // remove a distance
    Neighbor* get_first();        // get the first item
    long memory();
    bool is_empty();

    Neighbor_heap(int max_size);
    ~Neighbor_heap();
};


class Min_delta_sigma_heap {
private:
    int size;
    int max_size;

    int* H;   // the heap that contains the number of each community
    int* I;   // the index of each community in the heap (-1 = not stored)

    void move_up(int index);
    void move_down(int index);

public:
    int get_max_community();              // return the community with the maximal delta_sigma
    void remove_community(int community);         // remove a community;
    void update(int community);               // update (or insert if necessary) the community
    long memory();                    // the memory used in Bytes.
    bool is_empty();

    float* delta_sigma;                    // the delta_sigma of the stored communities

    Min_delta_sigma_heap(int max_size);
    ~Min_delta_sigma_heap();
};

}
}        /* end of namespaces */

#endif // WALKTRAP_HEAP_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/config.h.in0000644000175100001710000000165400000000000022472 0ustar00runnerdocker00000000000000#ifndef IGRAPH_CONFIG_H
#define IGRAPH_CONFIG_H

#cmakedefine HAVE_EXPM1 1
#cmakedefine HAVE_FMIN 1
#cmakedefine HAVE_FINITE 1
#cmakedefine HAVE_ISFINITE 1
#cmakedefine HAVE_LOG2 1
#cmakedefine HAVE_LOG1P 1
#cmakedefine HAVE_RINT 1
#cmakedefine HAVE_RINTF 1
#cmakedefine HAVE_ROUND 1
#cmakedefine HAVE_STPCPY 1
#cmakedefine HAVE_STRCASECMP 1
#cmakedefine HAVE__STRICMP 1
#cmakedefine HAVE_STRDUP 1

#cmakedefine HAVE_GLPK 1
#cmakedefine HAVE_LIBXML 1

#cmakedefine INTERNAL_BLAS 1
#cmakedefine INTERNAL_LAPACK 1
#cmakedefine INTERNAL_ARPACK 1
#cmakedefine INTERNAL_GMP 1

#define IGRAPH_F77_SAVE static @TLS_KEYWORD@
#define IGRAPH_THREAD_LOCAL @TLS_KEYWORD@

#define PACKAGE_VERSION "@PACKAGE_VERSION@"
#define PACKAGE_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@
#define PACKAGE_VERSION_MINOR @PACKAGE_VERSION_MINOR@
#define PACKAGE_VERSION_PATCH @PACKAGE_VERSION_PATCH@
#define PACKAGE_VERSION_PRERELEASE "@PACKAGE_VERSION_PRERELEASE@"

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4911406
igraph-0.9.9/vendor/source/igraph/src/connectivity/0000755000175100001710000000000000000000000023157 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/connectivity/cohesive_blocks.c0000644000175100001710000005260200000000000026472 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_cohesive_blocks.h"

#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_flow.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_separators.h"
#include "igraph_statusbar.h"
#include "igraph_structural.h"

#include "core/interruption.h"

static void igraph_i_cohesive_blocks_free_graphs(igraph_vector_ptr_t *ptr) {
    long int i, n = igraph_vector_ptr_size(ptr);

    for (i = 0; i < n; i++) {
        igraph_t *g = VECTOR(*ptr)[i];
        if (g) {
            igraph_destroy(g);
            igraph_free(g);
        }
    }
}

static void igraph_i_cohesive_blocks_free_vectors(igraph_vector_ptr_t *ptr) {
    long int i, n = igraph_vector_ptr_size(ptr);

    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*ptr)[i];
        if (v) {
            igraph_vector_destroy(v);
            igraph_free(v);
        }
    }
}

/* This is kind of a BFS to find the components of the graph, after
 * deleting the vertices marked in 'excluded'.
 * These vertices are not put in the BFS queue, but they are added to
 * all neighboring components.
 */

static int igraph_i_cb_components(igraph_t *graph,
                                  const igraph_vector_bool_t *excluded,
                                  igraph_vector_long_t *components,
                                  long int *no,
                                  /* working area follows */
                                  igraph_vector_long_t *compid,
                                  igraph_dqueue_t *Q,
                                  igraph_vector_t *neis) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    long int cno = 0;

    igraph_vector_long_clear(components);
    igraph_dqueue_clear(Q);
    IGRAPH_CHECK(igraph_vector_long_resize(compid, no_of_nodes));
    igraph_vector_long_null(compid);

    for (i = 0; i < no_of_nodes; i++) {

        if (VECTOR(*compid)[i])   {
            continue;
        }
        if (VECTOR(*excluded)[i]) {
            continue;
        }

        IGRAPH_CHECK(igraph_dqueue_push(Q, i));
        IGRAPH_CHECK(igraph_vector_long_push_back(components, i));
        VECTOR(*compid)[i] = ++cno;

        while (!igraph_dqueue_empty(Q)) {
            igraph_integer_t node = (igraph_integer_t) igraph_dqueue_pop(Q);
            long int j, n;
            IGRAPH_CHECK(igraph_neighbors(graph, neis, node, IGRAPH_ALL));
            n = igraph_vector_size(neis);
            for (j = 0; j < n; j++) {
                long int v = (long int) VECTOR(*neis)[j];
                if (VECTOR(*excluded)[v]) {
                    if (VECTOR(*compid)[v] != cno) {
                        VECTOR(*compid)[v] = cno;
                        IGRAPH_CHECK(igraph_vector_long_push_back(components, v));
                    }
                } else {
                    if (!VECTOR(*compid)[v]) {
                        VECTOR(*compid)[v] = cno; /* could be anything positive */
                        IGRAPH_CHECK(igraph_vector_long_push_back(components, v));
                        IGRAPH_CHECK(igraph_dqueue_push(Q, v));
                    }
                }
            }
        } /* while !igraph_dqueue_empty */

        IGRAPH_CHECK(igraph_vector_long_push_back(components, -1));

    } /* for ik. Thus a hiearchy of vertex subsets
 * is found, whith the entire graph G at its root. See the following
 * reference for details: J. Moody and D. R. White. Structural
 * cohesion and embeddedness: A hierarchical concept of social
 * groups. American Sociological Review, 68(1):103--127, Feb 2003.
 *
 * This function implements cohesive blocking and
 * calculates the complete cohesive block hierarchy of a graph.
 *
 * \param graph The input graph. It must be undirected and simple. See
 *    \ref igraph_is_simple().
 * \param blocks If not a null pointer, then it must be an initialized
 *    vector of pointers and the cohesive blocks are stored here.
 *    Each block is encoded with a numeric vector, that contains the
 *    vertex ids of the block.
 * \param cohesion If not a null pointer, then it must be an initialized
 *    vector and the cohesion of the blocks is stored here, in the same
 *    order as the blocks in the \p blocks pointer vector.
 * \param parent If not a null pointer, then it must be an initialized
 *    vector and the block hierarchy is stored here. For each block, the
 *    id (i.e. the position in the \p blocks pointer vector) of its
 *    parent block is stored. For the top block in the hierarchy,
 *    -1 is stored.
 * \param block_tree If not a null pointer, then it must be a pointer
 *    to an uninitialized graph, and the block hierarchy is stored
 *    here as an igraph graph. The vertex ids correspond to the order
 *    of the blocks in the \p blocks vector.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/cohesive_blocks.c
 */

int igraph_cohesive_blocks(const igraph_t *graph,
                           igraph_vector_ptr_t *blocks,
                           igraph_vector_t *cohesion,
                           igraph_vector_t *parent,
                           igraph_t *block_tree) {

    /* Some implementation comments. Everything is relatively
       straightforward, except, that we need to follow the vertex ids
       of the various subgraphs, without having to store two-way
       mappings at each level. The subgraphs can overlap, this
       complicates things a bit.

       The 'Q' vector is used as a double ended queue and it contains
       the subgraphs to work on in the future. Some other vectors are
       associated with it. 'Qparent' gives the parent graph of a graph
       in Q. Qmapping gives the mapping of the vertices from the graph
       to the parent graph. Qcohesion is the vertex connectivity of the
       graph.

       Qptr is an integer and points to the next graph to work on.
    */

    igraph_vector_ptr_t Q;
    igraph_vector_ptr_t Qmapping;
    igraph_vector_long_t Qparent;
    igraph_vector_long_t Qcohesion;
    igraph_vector_bool_t Qcheck;
    long int Qptr = 0;
    igraph_integer_t conn;
    igraph_bool_t is_simple;

    igraph_t *graph_copy;

    igraph_vector_ptr_t separators;
    igraph_vector_t compvertices;
    igraph_vector_long_t components;
    igraph_vector_bool_t marked;

    igraph_vector_long_t compid;
    igraph_dqueue_t bfsQ;
    igraph_vector_t neis;

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Cohesive blocking only works on undirected graphs",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_is_simple(graph, &is_simple));
    if (!is_simple) {
        IGRAPH_ERROR("Cohesive blocking only works on simple graphs",
                     IGRAPH_EINVAL);
    }

    IGRAPH_STATUS("Starting cohesive block calculation.\n", 0);

    if (blocks)   {
        igraph_vector_ptr_clear(blocks);
    }
    if (cohesion) {
        igraph_vector_clear(cohesion);
    }
    if (parent)   {
        igraph_vector_clear(parent);
    }

    IGRAPH_CHECK(igraph_vector_ptr_init(&Q, 1));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Q);
    IGRAPH_FINALLY(igraph_i_cohesive_blocks_free_graphs, &Q);

    IGRAPH_CHECK(igraph_vector_ptr_init(&Qmapping, 1));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Qmapping);
    IGRAPH_FINALLY(igraph_i_cohesive_blocks_free_vectors, &Qmapping);

    IGRAPH_CHECK(igraph_vector_long_init(&Qparent, 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &Qparent);

    IGRAPH_CHECK(igraph_vector_long_init(&Qcohesion, 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &Qcohesion);

    IGRAPH_CHECK(igraph_vector_bool_init(&Qcheck, 1));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &Qcheck);

    IGRAPH_CHECK(igraph_vector_ptr_init(&separators, 0));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &separators);

    IGRAPH_VECTOR_INIT_FINALLY(&compvertices, 0);
    IGRAPH_CHECK(igraph_vector_bool_init(&marked, 0));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &marked);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_init(&bfsQ, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &bfsQ);
    IGRAPH_CHECK(igraph_vector_long_init(&compid, 0));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &compid);
    IGRAPH_CHECK(igraph_vector_long_init(&components, 0));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &components);

    /* Put the input graph in the queue */
    graph_copy = IGRAPH_CALLOC(1, igraph_t);
    if (!graph_copy) {
        IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
    }
    IGRAPH_CHECK(igraph_copy(graph_copy, graph));
    VECTOR(Q)[0] = graph_copy;
    VECTOR(Qmapping)[0] = NULL;  /* Identity mapping */
    VECTOR(Qparent)[0] = -1;  /* Has no parent */
    IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn, /*checks=*/ 1));
    VECTOR(Qcohesion)[0] = conn;
    VECTOR(Qcheck)[0] = 0;

    /* Then work until the queue is empty */
    while (Qptr < igraph_vector_ptr_size(&Q)) {
        igraph_t *mygraph = VECTOR(Q)[Qptr];
        igraph_bool_t mycheck = VECTOR(Qcheck)[Qptr];
        long int mynodes = igraph_vcount(mygraph);
        long int i, nsep;
        long int no, kept = 0;
        long int cptr = 0;
        long int nsepv = 0;
        igraph_bool_t addedsep = 0;

        IGRAPH_STATUSF(("Candidate %li: %li vertices,",
                        0, Qptr, mynodes));
        IGRAPH_ALLOW_INTERRUPTION();

        /* Get the separators */
        IGRAPH_CHECK(igraph_minimum_size_separators(mygraph, &separators));
        IGRAPH_FINALLY(igraph_i_cohesive_blocks_free_vectors, &separators);
        nsep = igraph_vector_ptr_size(&separators);

        IGRAPH_STATUSF((" %li separators,", 0, nsep));

        /* Remove them from the graph, also mark them */
        IGRAPH_CHECK(igraph_vector_bool_resize(&marked, mynodes));
        igraph_vector_bool_null(&marked);
        for (i = 0; i < nsep; i++) {
            igraph_vector_t *v = VECTOR(separators)[i];
            long int j, n = igraph_vector_size(v);
            for (j = 0; j < n; j++) {
                long int vv = (long int) VECTOR(*v)[j];
                if (!VECTOR(marked)[vv]) {
                    nsepv++;
                    VECTOR(marked)[vv] = 1;
                }
            }
        }

        /* Find the connected components, omitting the separator vertices,
           but including the neighboring separator vertices
         */
        IGRAPH_CHECK(igraph_i_cb_components(mygraph, &marked,
                                            &components, &no,
                                            &compid, &bfsQ, &neis));

        /* Add the separator vertices themselves, as another component,
           but only if there is at least one vertex not included in any
           separator. */
        if (nsepv != mynodes) {
            addedsep = 1;
            for (i = 0; i < mynodes; i++) {
                if (VECTOR(marked)[i]) {
                    IGRAPH_CHECK(igraph_vector_long_push_back(&components, i));
                }
            }
            IGRAPH_CHECK(igraph_vector_long_push_back(&components, -1));
            no++;
        }

        IGRAPH_STATUSF((" %li new candidates,", 0, no));

        for (i = 0; i < no; i++) {
            igraph_vector_t *newmapping;
            igraph_t *newgraph;
            igraph_integer_t maxdeg;

            igraph_vector_clear(&compvertices);

            while (1) {
                long int v = VECTOR(components)[cptr++];
                if (v < 0) {
                    break;
                }
                IGRAPH_CHECK(igraph_vector_push_back(&compvertices, v));
            }

            newmapping = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!newmapping) {
                IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, newmapping);
            IGRAPH_VECTOR_INIT_FINALLY(newmapping, 0);
            newgraph = IGRAPH_CALLOC(1, igraph_t);
            if (!newgraph) {
                IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, newgraph);
            IGRAPH_CHECK(igraph_induced_subgraph_map(mygraph, newgraph,
                         igraph_vss_vector(&compvertices),
                         IGRAPH_SUBGRAPH_AUTO,
                         /*map=*/ 0,
                         /*invmap=*/ newmapping));
            IGRAPH_FINALLY(igraph_destroy, newgraph);

            IGRAPH_CHECK(igraph_maxdegree(newgraph, &maxdeg, igraph_vss_all(),
                                          IGRAPH_ALL, IGRAPH_LOOPS));
            if (maxdeg > VECTOR(Qcohesion)[Qptr]) {
                igraph_integer_t newconn;
                kept++;
                IGRAPH_CHECK(igraph_vector_ptr_push_back(&Q, newgraph));
                IGRAPH_FINALLY_CLEAN(2);
                IGRAPH_CHECK(igraph_vector_ptr_push_back(&Qmapping, newmapping));
                IGRAPH_FINALLY_CLEAN(2);
                IGRAPH_CHECK(igraph_vertex_connectivity(newgraph, &newconn,
                                                        /*checks=*/ 1));
                IGRAPH_CHECK(igraph_vector_long_push_back(&Qcohesion, newconn));
                IGRAPH_CHECK(igraph_vector_long_push_back(&Qparent, Qptr));
                IGRAPH_CHECK(igraph_vector_bool_push_back(&Qcheck,
                             mycheck || addedsep));
            } else {
                igraph_destroy(newgraph);
                igraph_free(newgraph);
                igraph_vector_destroy(newmapping);
                igraph_free(newmapping);
                IGRAPH_FINALLY_CLEAN(4);
            }
        }

        IGRAPH_STATUSF((" keeping %li.\n", 0, kept));

        igraph_destroy(mygraph);
        igraph_free(mygraph);
        VECTOR(Q)[Qptr] = 0;
        igraph_i_cohesive_blocks_free_vectors(&separators);
        IGRAPH_FINALLY_CLEAN(1);

        Qptr++;
    }

    igraph_vector_long_destroy(&components);
    igraph_vector_long_destroy(&compid);
    igraph_dqueue_destroy(&bfsQ);
    igraph_vector_destroy(&neis);
    igraph_vector_bool_destroy(&marked);
    igraph_vector_destroy(&compvertices);
    igraph_vector_ptr_destroy(&separators);
    IGRAPH_FINALLY_CLEAN(7);

    if (blocks || cohesion || parent || block_tree) {
        igraph_integer_t noblocks = (igraph_integer_t) Qptr, badblocks = 0;
        igraph_vector_bool_t removed;
        long int i, resptr = 0;
        igraph_vector_long_t rewritemap;

        IGRAPH_CHECK(igraph_vector_bool_init(&removed, noblocks));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
        IGRAPH_CHECK(igraph_vector_long_init(&rewritemap, noblocks));
        IGRAPH_FINALLY(igraph_vector_long_destroy, &rewritemap);

        for (i = 1; i < noblocks; i++) {
            long int p = VECTOR(Qparent)[i];
            while (VECTOR(removed)[p]) {
                p = VECTOR(Qparent)[p];
            }
            if (VECTOR(Qcohesion)[p] >= VECTOR(Qcohesion)[i]) {
                VECTOR(removed)[i] = 1;
                badblocks++;
            }
        }

        /* Rewrite the mappings */
        for (i = 1; i < Qptr; i++) {
            long int p = VECTOR(Qparent)[i];
            igraph_vector_t *mapping = VECTOR(Qmapping)[i];
            igraph_vector_t *pmapping = VECTOR(Qmapping)[p];
            long int j, n = igraph_vector_size(mapping);

            if (!pmapping) {
                continue;
            }
            for (j = 0; j < n; j++) {
                long int v = (long int) VECTOR(*mapping)[j];
                VECTOR(*mapping)[j] = VECTOR(*pmapping)[v];
            }
        }

        /* Because we also put the separator vertices in the queue, it is
           not ensured that the found blocks are not subsets of each other.
           We check this now. */
        for (i = 1; i < noblocks; i++) {
            long int j, ic;
            igraph_vector_t *ivec;
            if (!VECTOR(Qcheck)[i] || VECTOR(removed)[i]) {
                continue;
            }
            ivec = VECTOR(Qmapping)[i];
            ic = VECTOR(Qcohesion)[i];
            for (j = 1; j < noblocks; j++) {
                igraph_vector_t *jvec;
                long int jc;
                if (j == i || !VECTOR(Qcheck)[j] || VECTOR(removed)[j]) {
                    continue;
                }
                jvec = VECTOR(Qmapping)[j];
                jc = VECTOR(Qcohesion)[j];
                if (igraph_i_cb_isin(ivec, jvec) && jc >= ic) {
                    badblocks++;
                    VECTOR(removed)[i] = 1;
                    break;
                }
            }
        }

        noblocks -= badblocks;

        if (blocks) {
            IGRAPH_CHECK(igraph_vector_ptr_resize(blocks, noblocks));
        }
        if (cohesion) {
            IGRAPH_CHECK(igraph_vector_resize(cohesion, noblocks));
        }
        if (parent) {
            IGRAPH_CHECK(igraph_vector_resize(parent, noblocks));
        }

        for (i = 0; i < Qptr; i++) {
            if (VECTOR(removed)[i]) {
                IGRAPH_STATUSF(("Candidate %li ignored.\n", 0, i));
                continue;
            } else {
                IGRAPH_STATUSF(("Candidate %li is a cohesive (sub)block\n", 0, i));
            }
            VECTOR(rewritemap)[i] = resptr;
            if (cohesion) {
                VECTOR(*cohesion)[resptr] = VECTOR(Qcohesion)[i];
            }
            if (parent || block_tree) {
                long int p = VECTOR(Qparent)[i];
                while (p >= 0 && VECTOR(removed)[p]) {
                    p = VECTOR(Qparent)[p];
                }
                if (p >= 0) {
                    p = VECTOR(rewritemap)[p];
                }
                VECTOR(Qparent)[i] = p;
                if (parent) {
                    VECTOR(*parent)[resptr] = p;
                }
            }
            if (blocks) {
                VECTOR(*blocks)[resptr] = VECTOR(Qmapping)[i];
                VECTOR(Qmapping)[i] = 0;
            }
            resptr++;
        }

        /* Plus the original graph */
        if (blocks) {
            igraph_vector_t *orig = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!orig) {
                IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, orig);
            IGRAPH_CHECK(igraph_vector_init_seq(orig, 0, igraph_vcount(graph) - 1));
            VECTOR(*blocks)[0] = orig;
            IGRAPH_FINALLY_CLEAN(1);
        }

        if (block_tree) {
            igraph_vector_t edges;
            long int eptr = 0;
            IGRAPH_VECTOR_INIT_FINALLY(&edges, noblocks * 2 - 2);
            for (i = 1; i < Qptr; i++) {
                if (VECTOR(removed)[i]) {
                    continue;
                }
                VECTOR(edges)[eptr++] = VECTOR(Qparent)[i];
                VECTOR(edges)[eptr++] = VECTOR(rewritemap)[i];
            }

            IGRAPH_CHECK(igraph_create(block_tree, &edges, noblocks,
                                       IGRAPH_DIRECTED));
            igraph_vector_destroy(&edges);
            IGRAPH_FINALLY_CLEAN(1);
        }

        igraph_vector_long_destroy(&rewritemap);
        igraph_vector_bool_destroy(&removed);
        IGRAPH_FINALLY_CLEAN(2);

    }

    igraph_vector_bool_destroy(&Qcheck);
    igraph_vector_long_destroy(&Qcohesion);
    igraph_vector_long_destroy(&Qparent);
    igraph_i_cohesive_blocks_free_vectors(&Qmapping);
    IGRAPH_FINALLY_CLEAN(4);

    igraph_vector_ptr_destroy(&Qmapping);
    igraph_vector_ptr_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(3);      /* + the elements of Q, they were
                   already destroyed */

    IGRAPH_STATUS("Cohesive blocking done.\n", 0);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/connectivity/components.c0000644000175100001710000015021100000000000025510 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_components.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_progress.h"
#include "igraph_stack.h"
#include "igraph_structural.h"
#include "igraph_vector.h"

#include "core/interruption.h"
#include "operators/subgraph.h"

#include 

static int igraph_i_clusters_weak(const igraph_t *graph, igraph_vector_t *membership,
                                  igraph_vector_t *csize, igraph_integer_t *no);

static int igraph_i_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
                                    igraph_vector_t *csize, igraph_integer_t *no);

/**
 * \ingroup structural
 * \function igraph_clusters
 * \brief Calculates the (weakly or strongly) connected components in a graph.
 *
 * \param graph The graph object to analyze.
 * \param membership First half of the result will be stored here. For
 *        every vertex the id of its component is given. The vector
 *        has to be preinitialized and will be resized. Alternatively
 *        this argument can be \c NULL, in which case it is ignored.
 * \param csize The second half of the result. For every component it
 *        gives its size, the order is defined by the component ids.
 *        The vector has to be preinitialized and will be resized.
 *        Alternatively this argument can be \c NULL, in which
 *        case it is ignored.
 * \param no Pointer to an integer, if not \c NULL then the number of
 *        clusters will be stored here.
 * \param mode For directed graph this specifies whether to calculate
 *        weakly or strongly connected components. Possible values:
 *        \c IGRAPH_WEAK,
 *        \c IGRAPH_STRONG. This argument is
 *        ignored for undirected graphs.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid mode argument.
 *
 * Time complexity: O(|V|+|E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 */

int igraph_clusters(const igraph_t *graph, igraph_vector_t *membership,
                    igraph_vector_t *csize, igraph_integer_t *no,
                    igraph_connectedness_t mode) {
    if (mode == IGRAPH_WEAK || !igraph_is_directed(graph)) {
        return igraph_i_clusters_weak(graph, membership, csize, no);
    } else if (mode == IGRAPH_STRONG) {
        return igraph_i_clusters_strong(graph, membership, csize, no);
    }

    IGRAPH_ERROR("Cannot calculate clusters", IGRAPH_EINVAL);
}

static int igraph_i_clusters_weak(const igraph_t *graph, igraph_vector_t *membership,
                                  igraph_vector_t *csize, igraph_integer_t *no) {

    long int no_of_nodes = igraph_vcount(graph);
    char *already_added;
    long int first_node, act_cluster_size = 0, no_of_clusters = 1;

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    long int i;
    igraph_vector_t neis = IGRAPH_VECTOR_NULL;

    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("Cannot calculate clusters", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);

    IGRAPH_DQUEUE_INIT_FINALLY(&q, no_of_nodes > 100000 ? 10000 : no_of_nodes / 10);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    /* Memory for result, csize is dynamically allocated */
    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
    }
    if (csize) {
        igraph_vector_clear(csize);
    }

    /* The algorithm */

    for (first_node = 0; first_node < no_of_nodes; ++first_node) {
        if (already_added[first_node] == 1) {
            continue;
        }
        IGRAPH_ALLOW_INTERRUPTION();

        already_added[first_node] = 1;
        act_cluster_size = 1;
        if (membership) {
            VECTOR(*membership)[first_node] = no_of_clusters - 1;
        }
        IGRAPH_CHECK(igraph_dqueue_push(&q, first_node));

        while ( !igraph_dqueue_empty(&q) ) {
            long int act_node = (long int) igraph_dqueue_pop(&q);
            IGRAPH_CHECK(igraph_neighbors(graph, &neis,
                                          (igraph_integer_t) act_node, IGRAPH_ALL));
            for (i = 0; i < igraph_vector_size(&neis); i++) {
                long int neighbor = (long int) VECTOR(neis)[i];
                if (already_added[neighbor] == 1) {
                    continue;
                }
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                already_added[neighbor] = 1;
                act_cluster_size++;
                if (membership) {
                    VECTOR(*membership)[neighbor] = no_of_clusters - 1;
                }
            }
        }
        no_of_clusters++;
        if (csize) {
            IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
        }
    }

    /* Cleaning up */

    if (no) {
        *no = (igraph_integer_t) no_of_clusters - 1;
    }

    IGRAPH_FREE(already_added);
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

static int igraph_i_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
                                    igraph_vector_t *csize, igraph_integer_t *no) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t next_nei = IGRAPH_VECTOR_NULL;

    long int i, n, num_seen;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    long int no_of_clusters = 1;
    long int act_cluster_size;

    igraph_vector_t out = IGRAPH_VECTOR_NULL;
    const igraph_vector_int_t* tmp;

    igraph_adjlist_t adjlist;

    /* The result */

    IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    if (membership) {
        IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
    }
    IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));

    igraph_vector_null(&out);
    if (csize) {
        igraph_vector_clear(csize);
    }

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    num_seen = 0;
    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_ALLOW_INTERRUPTION();

        tmp = igraph_adjlist_get(&adjlist, i);
        if (VECTOR(next_nei)[i] > igraph_vector_int_size(tmp)) {
            continue;
        }

        IGRAPH_CHECK(igraph_dqueue_push(&q, i));
        while (!igraph_dqueue_empty(&q)) {
            long int act_node = (long int) igraph_dqueue_back(&q);
            tmp = igraph_adjlist_get(&adjlist, act_node);
            if (VECTOR(next_nei)[act_node] == 0) {
                /* this is the first time we've met this vertex */
                VECTOR(next_nei)[act_node]++;
            } else if (VECTOR(next_nei)[act_node] <= igraph_vector_int_size(tmp)) {
                /* we've already met this vertex but it has more children */
                long int neighbor = (long int) VECTOR(*tmp)[(long int)
                                    VECTOR(next_nei)[act_node] - 1];
                if (VECTOR(next_nei)[neighbor] == 0) {
                    IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                }
                VECTOR(next_nei)[act_node]++;
            } else {
                /* we've met this vertex and it has no more children */
                IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
                igraph_dqueue_pop_back(&q);
                num_seen++;

                if (num_seen % 10000 == 0) {
                    /* time to report progress and allow the user to interrupt */
                    IGRAPH_PROGRESS("Strongly connected components: ",
                                    num_seen * 50.0 / no_of_nodes, NULL);
                    IGRAPH_ALLOW_INTERRUPTION();
                }
            }
        } /* while q */
    }  /* for */

    IGRAPH_PROGRESS("Strongly connected components: ", 50.0, NULL);

    igraph_adjlist_destroy(&adjlist);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    /* OK, we've the 'out' values for the nodes, let's use them in
       decreasing order with the help of a heap */

    igraph_vector_null(&next_nei);             /* mark already added vertices */
    num_seen = 0;

    while (!igraph_vector_empty(&out)) {
        long int grandfather = (long int) igraph_vector_pop_back(&out);

        if (VECTOR(next_nei)[grandfather] != 0) {
            continue;
        }
        VECTOR(next_nei)[grandfather] = 1;
        act_cluster_size = 1;
        if (membership) {
            VECTOR(*membership)[grandfather] = no_of_clusters - 1;
        }
        IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));

        num_seen++;
        if (num_seen % 10000 == 0) {
            /* time to report progress and allow the user to interrupt */
            IGRAPH_PROGRESS("Strongly connected components: ",
                            50.0 + num_seen * 50.0 / no_of_nodes, NULL);
            IGRAPH_ALLOW_INTERRUPTION();
        }

        while (!igraph_dqueue_empty(&q)) {
            long int act_node = (long int) igraph_dqueue_pop_back(&q);
            tmp = igraph_adjlist_get(&adjlist, act_node);
            n = igraph_vector_int_size(tmp);
            for (i = 0; i < n; i++) {
                long int neighbor = (long int) VECTOR(*tmp)[i];
                if (VECTOR(next_nei)[neighbor] != 0) {
                    continue;
                }
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                VECTOR(next_nei)[neighbor] = 1;
                act_cluster_size++;
                if (membership) {
                    VECTOR(*membership)[neighbor] = no_of_clusters - 1;
                }

                num_seen++;
                if (num_seen % 10000 == 0) {
                    /* time to report progress and allow the user to interrupt */
                    IGRAPH_PROGRESS("Strongly connected components: ",
                                    50.0 + num_seen * 50.0 / no_of_nodes, NULL);
                    IGRAPH_ALLOW_INTERRUPTION();
                }
            }
        }

        no_of_clusters++;
        if (csize) {
            IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
        }
    }

    IGRAPH_PROGRESS("Strongly connected components: ", 100.0, NULL);

    if (no) {
        *no = (igraph_integer_t) no_of_clusters - 1;
    }

    /* Clean up, return */

    igraph_adjlist_destroy(&adjlist);
    igraph_vector_destroy(&out);
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&next_nei);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

static int igraph_is_connected_weak(const igraph_t *graph, igraph_bool_t *res);

/**
 * \ingroup structural
 * \function igraph_is_connected
 * \brief Decides whether the graph is (weakly or strongly) connected.
 *
 * A graph is considered connected when any of its vertices is reachable
 * from any other. A directed graph with this property is called
 * \em strongly connected. A directed graph that would be connected when
 * ignoring the directions of its edges is called \em weakly connected.
 *
 * 
 * A graph with zero vertices (i.e. the null graph) is \em not connected by
 * definition. This behaviour changed in igraph 0.9; earlier versions assumed
 * that the null graph is connected. See the following issue on Github for the
 * argument that led us to change the definition:
 * https://github.com/igraph/igraph/issues/1538
 *
 * \param graph The graph object to analyze.
 * \param res Pointer to a logical variable, the result will be stored
 *        here.
 * \param mode For a directed graph this specifies whether to calculate
 *        weak or strong connectedness. Possible values:
 *        \c IGRAPH_WEAK,
 *        \c IGRAPH_STRONG. This argument is
 *        ignored for undirected graphs.
 * \return Error code:
 *        \c IGRAPH_EINVAL: invalid mode argument.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices
 * plus the number of edges in the graph.
 */

int igraph_is_connected(const igraph_t *graph, igraph_bool_t *res,
                        igraph_connectedness_t mode) {

    long int no_of_nodes = igraph_vcount(graph);

    if (no_of_nodes == 0) {
        /* Changed in igraph 0.9; see https://github.com/igraph/igraph/issues/1538
         * for the reasoning behind the change */
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    if (no_of_nodes == 1) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    if (mode == IGRAPH_WEAK || !igraph_is_directed(graph)) {
        return igraph_is_connected_weak(graph, res);
    } else if (mode == IGRAPH_STRONG) {
        int retval;
        igraph_integer_t no;

        /* A strongly connected graph has at least as many edges as vertices,
         * except for the singleton graph, which is handled above. */
        if (igraph_ecount(graph) < no_of_nodes) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }

        retval = igraph_i_clusters_strong(graph, NULL, NULL, &no);
        *res = (no == 1);
        return retval;
    }

    IGRAPH_ERROR("Invalid connectedness mode.", IGRAPH_EINVAL);
}

static int igraph_is_connected_weak(const igraph_t *graph, igraph_bool_t *res) {

    long int no_of_nodes = igraph_vcount(graph), no_of_edges = igraph_ecount(graph);
    long int added_count;
    char *already_added;
    igraph_vector_t neis = IGRAPH_VECTOR_NULL;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    /* By convention, the null graph is not considered connected.
     * See https://github.com/igraph/igraph/issues/1538 */
    if (no_of_nodes == 0) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    /* A connected graph has at least |V| - 1 edges. */
    if (no_of_edges < no_of_nodes - 1) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("Weak connectedness check failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);

    IGRAPH_DQUEUE_INIT_FINALLY(&q, 10);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    /* Try to find at least two clusters */
    already_added[0] = 1;
    IGRAPH_CHECK(igraph_dqueue_push(&q, 0));

    added_count = 1;
    while ( !igraph_dqueue_empty(&q)) {
        IGRAPH_ALLOW_INTERRUPTION();

        long int actnode = (long int) igraph_dqueue_pop(&q);

        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actnode, IGRAPH_ALL));
        long int nei_count = igraph_vector_size(&neis);

        for (long int i = 0; i < nei_count; i++) {
            long int neighbor = (long int) VECTOR(neis)[i];
            if (already_added[neighbor]) {
                continue;
            }

            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
            added_count++;
            already_added[neighbor] = 1;

            if (added_count == no_of_nodes) {
                /* We have already reached all nodes: the graph is connected.
                 * We can stop the traversal now. */
                igraph_dqueue_clear(&q);
                break;
            }
        }
    }

    /* Connected? */
    *res = (added_count == no_of_nodes);

    IGRAPH_FREE(already_added);
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_decompose_destroy
 * \brief Free the memory allocated by \ref igraph_decompose().
 *
 * This function destroys and frees all igraph_t
 * objects held in \p complist. However, it does not destroy
 * \p complist itself, as it was not allocated by \ref igraph_decompose().
 * Use \ref igraph_vector_ptr_destroy() to destroy \p complist.
 *
 * \param complist The list of graph components, as returned by
 *        \ref igraph_decompose().
 *
 * Time complexity: O(c), c is the number of components.
 */

void igraph_decompose_destroy(igraph_vector_ptr_t *complist) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(complist); i++) {
        if (VECTOR(*complist)[i] != 0) {
            igraph_destroy(VECTOR(*complist)[i]);
            igraph_free(VECTOR(*complist)[i]);
        }
    }
}

static int igraph_i_decompose_weak(const igraph_t *graph,
                                   igraph_vector_ptr_t *components,
                                   long int maxcompno, long int minelements);

static int igraph_i_decompose_strong(const igraph_t *graph,
                                     igraph_vector_ptr_t *components,
                                     long int maxcompno, long int minelements);

/**
 * \function igraph_decompose
 * \brief Decompose a graph into connected components.
 *
 * Create separate graph for each component of a graph. Note that the
 * vertex ids in the new graphs will be different than in the original
 * graph. (Except if there is only one component in the original graph.)
 *
 * \param graph The original graph.
 * \param components This pointer vector will contain pointers to the
 *   subcomponent graphs. It should be initialized before calling this
 *   function and will be resized to hold the graphs. Don't forget to
 *   call \ref igraph_destroy() and \ref igraph_free() on the elements of
 *   this pointer vector to free unneeded memory. Alternatively, you can
 *   simply call \ref igraph_decompose_destroy() that does this for you.
 * \param mode Either \c IGRAPH_WEAK or \c IGRAPH_STRONG for weakly
 *    and strongly connected components respectively.
 * \param maxcompno The maximum number of components to return. The
 *    first \p maxcompno components will be returned (which hold at
 *    least \p minelements vertices, see the next parameter), the
 *    others will be ignored. Supply -1 here if you don't want to limit
 *    the number of components.
 * \param minelements The minimum number of vertices a component
 *    should contain in order to place it in the \p components
 *    vector. Eg. supply 2 here to ignore isolated vertices.
 * \return Error code, \c IGRAPH_ENOMEM if there is not enough memory
 *   to perform the operation.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 *
 * \example examples/simple/igraph_decompose.c
 */

int igraph_decompose(const igraph_t *graph, igraph_vector_ptr_t *components,
                     igraph_connectedness_t mode,
                     long int maxcompno, long int minelements) {
    if (mode == IGRAPH_WEAK || !igraph_is_directed(graph)) {
        return igraph_i_decompose_weak(graph, components, maxcompno, minelements);
    } else if (mode == IGRAPH_STRONG) {
        return igraph_i_decompose_strong(graph, components, maxcompno, minelements);
    }

    IGRAPH_ERROR("Cannot decompose graph", IGRAPH_EINVAL);
}

static int igraph_i_decompose_weak(const igraph_t *graph,
                                   igraph_vector_ptr_t *components,
                                   long int maxcompno, long int minelements) {

    long int actstart;
    long int no_of_nodes = igraph_vcount(graph);
    long int resco = 0;   /* number of graphs created so far */
    char *already_added;
    igraph_dqueue_t q;
    igraph_vector_t verts;
    igraph_vector_t neis;
    igraph_vector_t vids_old2new;
    long int i;
    igraph_t *newg;


    if (maxcompno < 0) {
        maxcompno = LONG_MAX;
    }

    igraph_vector_ptr_clear(components);
    IGRAPH_FINALLY(igraph_decompose_destroy, components);

    /* already_added keeps track of what nodes made it into a graph already */
    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);

    IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &q);
    IGRAPH_VECTOR_INIT_FINALLY(&verts, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vids_old2new, no_of_nodes);

    /* vids_old2new would have been created internally in igraph_induced_subgraph(),
       but it is slow if the graph is large and consists of many small components,
       so we create it once here and then re-use it */

    /* add a node and its neighbors at once, recursively
       then switch to next node that has not been added already */
    for (actstart = 0; resco < maxcompno && actstart < no_of_nodes; actstart++) {

        if (already_added[actstart]) {
            continue;
        }
        IGRAPH_ALLOW_INTERRUPTION();

        igraph_vector_clear(&verts);

        /* add the node itself */
        already_added[actstart] = 1;
        IGRAPH_CHECK(igraph_vector_push_back(&verts, actstart));
        IGRAPH_CHECK(igraph_dqueue_push(&q, actstart));

        /* add the neighbors, recursively */
        while (!igraph_dqueue_empty(&q) ) {
            /* pop from the queue of this component */
            long int actvert = (long int) igraph_dqueue_pop(&q);
            IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actvert,
                                          IGRAPH_ALL));
            /* iterate over the neighbors */
            for (i = 0; i < igraph_vector_size(&neis); i++) {
                long int neighbor = (long int) VECTOR(neis)[i];
                if (already_added[neighbor] == 1) {
                    continue;
                }
                /* add neighbor */
                already_added[neighbor] = 1;

                /* recursion: append neighbor to the queues */
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_vector_push_back(&verts, neighbor));
            }
        }

        /* ok, we have a component */
        if (igraph_vector_size(&verts) < minelements) {
            continue;
        }

        newg = IGRAPH_CALLOC(1, igraph_t);
        if (newg == 0) {
            IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_ptr_push_back(components, newg));
        IGRAPH_CHECK(igraph_i_induced_subgraph_map(
            graph, newg, igraph_vss_vector(&verts),
            IGRAPH_SUBGRAPH_AUTO, &vids_old2new,
            /* invmap = */ 0, /* map_is_prepared = */ 1
        ));
        resco++;

        /* vids_old2new does not have to be cleaned up here; since we are doing
         * weak decomposition, each vertex will appear in only one of the
         * connected components so we won't ever touch an item in vids_old2new
         * if it was already set to a non-zero value in a previous component */

    } /* for actstart++ */

    igraph_vector_destroy(&vids_old2new);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&verts);
    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(already_added);
    IGRAPH_FINALLY_CLEAN(6);  /* + components */

    return 0;
}

static int igraph_i_decompose_strong(const igraph_t *graph,
                                     igraph_vector_ptr_t *components,
                                     long int maxcompno, long int minelements) {


    long int no_of_nodes = igraph_vcount(graph);

    /* this is a heap used twice for checking what nodes have
     * been counted already */
    igraph_vector_t next_nei = IGRAPH_VECTOR_NULL;

    long int i, n, num_seen;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    long int no_of_clusters = 0;
    long int act_cluster_size;

    igraph_vector_t out = IGRAPH_VECTOR_NULL;
    const igraph_vector_int_t* tmp;

    igraph_adjlist_t adjlist;
    igraph_vector_t verts;
    igraph_vector_t vids_old2new;
    igraph_t *newg;

    if (maxcompno < 0) {
        maxcompno = LONG_MAX;
    }

    igraph_vector_ptr_clear(components);
    IGRAPH_FINALLY(igraph_decompose_destroy, components);

    /* The result */

    IGRAPH_VECTOR_INIT_FINALLY(&vids_old2new, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&verts, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));

    igraph_vector_null(&out);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    /* vids_old2new would have been created internally in igraph_induced_subgraph(),
       but it is slow if the graph is large and consists of many small components,
       so we create it once here and then re-use it */

    /* number of components seen */
    num_seen = 0;
    /* populate the 'out' vector by browsing a node and following up
       all its neighbors recursively, then switching to the next
       unassigned node */
    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_ALLOW_INTERRUPTION();

        /* get all the 'out' neighbors of this node
         * NOTE: next_nei is initialized [0, 0, ...] */
        tmp = igraph_adjlist_get(&adjlist, i);
        if (VECTOR(next_nei)[i] > igraph_vector_int_size(tmp)) {
            continue;
        }

        /* add this node to the queue for this component */
        IGRAPH_CHECK(igraph_dqueue_push(&q, i));

        /* consume the tree from this node ("root") recursively
         * until there is no more */
        while (!igraph_dqueue_empty(&q)) {
            /* this looks up but does NOT consume the queue */
            long int act_node = (long int) igraph_dqueue_back(&q);

            /* get all neighbors of this node */
            tmp = igraph_adjlist_get(&adjlist, act_node);
            if (VECTOR(next_nei)[act_node] == 0) {
                /* this is the first time we've met this vertex,
                     * because next_nei is initialized [0, 0, ...] */
                VECTOR(next_nei)[act_node]++;
                /* back to the queue, same vertex is up again */

            } else if (VECTOR(next_nei)[act_node] <= igraph_vector_int_size(tmp)) {
                /* we've already met this vertex but it has more children */
                long int neighbor = (long int) VECTOR(*tmp)[(long int)
                                    VECTOR(next_nei)[act_node] - 1];
                if (VECTOR(next_nei)[neighbor] == 0) {
                    /* add the root of the other children to the queue */
                    IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                }
                VECTOR(next_nei)[act_node]++;
            } else {
                /* we've met this vertex and it has no more children */
                IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
                /* this consumes the queue, since there's nowhere to go */
                igraph_dqueue_pop_back(&q);
                num_seen++;

                if (num_seen % 10000 == 0) {
                    /* time to report progress and allow the user to interrupt */
                    IGRAPH_PROGRESS("Strongly connected components: ",
                                    num_seen * 50.0 / no_of_nodes, NULL);
                    IGRAPH_ALLOW_INTERRUPTION();
                }
            }
        } /* while q */
    }  /* for */

    IGRAPH_PROGRESS("Strongly connected components: ", 50.0, NULL);

    igraph_adjlist_destroy(&adjlist);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    /* OK, we've the 'out' values for the nodes, let's use them in
     * decreasing order with the help of the next_nei heap */

    igraph_vector_null(&next_nei);             /* mark already added vertices */

    /* number of components built */
    num_seen = 0;
    while (!igraph_vector_empty(&out) && no_of_clusters < maxcompno) {
        /* consume the vector from the last element */
        long int grandfather = (long int) igraph_vector_pop_back(&out);

        /* been here, done that
         * NOTE: next_nei is initialized as [0, 0, ...] */
        if (VECTOR(next_nei)[grandfather] != 0) {
            continue;
        }

        /* collect all the members of this component */
        igraph_vector_clear(&verts);

        /* this node is gone for any future components */
        VECTOR(next_nei)[grandfather] = 1;
        act_cluster_size = 1;

        /* add to component */
        IGRAPH_CHECK(igraph_vector_push_back(&verts, grandfather));
        IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));

        num_seen++;
        if (num_seen % 10000 == 0) {
            /* time to report progress and allow the user to interrupt */
            IGRAPH_PROGRESS("Strongly connected components: ",
                            50.0 + num_seen * 50.0 / no_of_nodes, NULL);
            IGRAPH_ALLOW_INTERRUPTION();
        }

        while (!igraph_dqueue_empty(&q)) {
            /* consume the queue from this node */
            long int act_node = (long int) igraph_dqueue_pop_back(&q);
            tmp = igraph_adjlist_get(&adjlist, act_node);
            n = igraph_vector_int_size(tmp);
            for (i = 0; i < n; i++) {
                long int neighbor = (long int) VECTOR(*tmp)[i];
                if (VECTOR(next_nei)[neighbor] != 0) {
                    continue;
                }
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                VECTOR(next_nei)[neighbor] = 1;
                act_cluster_size++;

                /* add to component */
                IGRAPH_CHECK(igraph_vector_push_back(&verts, neighbor));

                num_seen++;
                if (num_seen % 10000 == 0) {
                    /* time to report progress and allow the user to interrupt */
                    IGRAPH_PROGRESS("Strongly connected components: ",
                                    50.0 + num_seen * 50.0 / no_of_nodes, NULL);
                    IGRAPH_ALLOW_INTERRUPTION();
                }
            }
        }

        /* ok, we have a component */
        if (igraph_vector_size(&verts) < minelements) {
            continue;
        }

        newg = IGRAPH_CALLOC(1, igraph_t);
        if (newg == 0) {
            IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_ptr_push_back(components, newg));
        IGRAPH_CHECK(igraph_i_induced_subgraph_map(
            graph, newg, igraph_vss_vector(&verts),
            IGRAPH_SUBGRAPH_AUTO, &vids_old2new,
            /* invmap = */ 0, /* map_is_prepared = */ 1
        ));

        /* vids_old2new has to be cleaned up here because a vertex may appear
         * in multiple strongly connected components. Simply calling
         * igraph_vector_fill() would be an O(n) operation where n is the number
         * of vertices in the large graph so we cannot do that; we have to
         * iterate over 'verts' instead */
        n = igraph_vector_size(&verts);
        for (i = 0; i < n; i++) {
            VECTOR(vids_old2new)[(igraph_integer_t) VECTOR(verts)[i]] = 0;
        }

        no_of_clusters++;
    }

    IGRAPH_PROGRESS("Strongly connected components: ", 100.0, NULL);

    /* Clean up, return */

    igraph_vector_destroy(&vids_old2new);
    igraph_vector_destroy(&verts);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_destroy(&out);
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&next_nei);
    IGRAPH_FINALLY_CLEAN(7);  /* + components */

    return 0;

}

/**
 * \function igraph_articulation_points
 * Find the articulation points in a graph.
 *
 * A vertex is an articulation point if its removal increases
 * the number of connected components in the graph.
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the
 *    articulation points will be stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and edges.
 *
 * \sa \ref igraph_biconnected_components(), \ref igraph_clusters(), \ref igraph_bridges()
 */

int igraph_articulation_points(const igraph_t *graph,
                               igraph_vector_t *res) {

    igraph_integer_t no;
    return igraph_biconnected_components(graph, &no, 0, 0, 0, res);
}

void igraph_i_free_vectorlist(igraph_vector_ptr_t *list);

void igraph_i_free_vectorlist(igraph_vector_ptr_t *list) {
    long int i, n = igraph_vector_ptr_size(list);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*list)[i];
        if (v) {
            igraph_vector_destroy(v);
            IGRAPH_FREE(v);
        }
    }
    igraph_vector_ptr_destroy(list);
}

/**
 * \function igraph_biconnected_components
 * Calculate biconnected components
 *
 * A graph is biconnected if the removal of any single vertex (and
 * its incident edges) does not disconnect it.
 *
 * 
 * A biconnected component of a graph is a maximal biconnected
 * subgraph of it. The biconnected components of a graph can be given
 * by the partition of its edges: every edge is a member of exactly
 * one biconnected component. Note that this is not true for
 * vertices: the same vertex can be part of many biconnected
 * components.
 *
 * 
 * Somewhat arbitrarily, igraph does not consider components containing
 * a single vertex only as being biconnected. Isolated vertices will
 * not be part of any of the biconnected components.
 *
 * \param graph The input graph.
 * \param no The number of biconnected components will be stored here.
 * \param tree_edges If not a NULL pointer, then the found components
 *     are stored here, in a list of vectors. Every vector in the list
 *     is a biconnected component, represented by its edges. More precisely,
 *     a spanning tree of the biconnected component is returned.
 *     Note you'll have to
 *     destroy each vector first by calling \ref igraph_vector_destroy()
 *     and then \ref igraph_free() on it, plus you need to call
 *     \ref igraph_vector_ptr_destroy() on the list to regain all
 *     allocated memory.
 * \param component_edges If not a NULL pointer, then the edges of the
 *     biconnected components are stored here, in the same form as for
 *     \c tree_edges.
 * \param components If not a NULL pointer, then the vertices of the
 *     biconnected components are stored here, in the same format as
 *     for the previous two arguments.
 * \param articulation_points If not a NULL pointer, then the
 *     articulation points of the graph are stored in this vector.
 *     A vertex is an articulation point if its removal increases the
 *     number of (weakly) connected components in the graph.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges, but only if you do not calculate \c components and
 * \c component_edges. If you calculate \c components, then it is
 * quadratic in the number of vertices. If you calculate \c
 * component_edges as well, then it is cubic in the number of
 * vertices.
 *
 * \sa \ref igraph_articulation_points(), \ref igraph_clusters().
 *
 * \example examples/simple/igraph_biconnected_components.c
 */

int igraph_biconnected_components(const igraph_t *graph,
                                  igraph_integer_t *no,
                                  igraph_vector_ptr_t *tree_edges,
                                  igraph_vector_ptr_t *component_edges,
                                  igraph_vector_ptr_t *components,
                                  igraph_vector_t *articulation_points) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_long_t nextptr;
    igraph_vector_long_t num, low;
    igraph_vector_bool_t found;
    igraph_vector_int_t *adjedges;
    igraph_stack_t path;
    igraph_vector_t edgestack;
    igraph_inclist_t inclist;
    long int i, counter, rootdfs = 0;
    igraph_vector_long_t vertex_added;
    long int comps = 0;
    igraph_vector_ptr_t *mycomponents = components, vcomponents;

    IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
    IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
    IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
    IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);

    IGRAPH_CHECK(igraph_stack_init(&path, 100));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);
    IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));

    IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);

    IGRAPH_CHECK(igraph_vector_long_init(&vertex_added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &vertex_added);

    if (no) {
        *no = 0;
    }
    if (tree_edges) {
        igraph_vector_ptr_clear(tree_edges);
    }
    if (components) {
        igraph_vector_ptr_clear(components);
    }
    if (component_edges) {
        igraph_vector_ptr_clear(component_edges);
    }
    if (articulation_points) {
        igraph_vector_clear(articulation_points);
    }
    if (component_edges && !components) {
        mycomponents = &vcomponents;
        IGRAPH_CHECK(igraph_vector_ptr_init(mycomponents, 0));
        IGRAPH_FINALLY(igraph_i_free_vectorlist, mycomponents);
    }

    for (i = 0; i < no_of_nodes; i++) {

        if (VECTOR(low)[i] != 0) {
            continue;    /* already visited */
        }

        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_stack_push(&path, i));
        counter = 1;
        rootdfs = 0;
        VECTOR(low)[i] = VECTOR(num)[i] = counter++;
        while (!igraph_stack_empty(&path)) {
            long int n;
            long int act = (long int) igraph_stack_top(&path);
            long int actnext = VECTOR(nextptr)[act];

            adjedges = igraph_inclist_get(&inclist, act);
            n = igraph_vector_int_size(adjedges);
            if (actnext < n) {
                /* Step down (maybe) */
                long int edge = (long int) VECTOR(*adjedges)[actnext];
                long int nei = IGRAPH_OTHER(graph, edge, act);
                if (VECTOR(low)[nei] == 0) {
                    if (act == i) {
                        rootdfs++;
                    }
                    IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
                    IGRAPH_CHECK(igraph_stack_push(&path, nei));
                    VECTOR(low)[nei] = VECTOR(num)[nei] = counter++;
                } else {
                    /* Update low value if needed */
                    if (VECTOR(num)[nei] < VECTOR(low)[act]) {
                        VECTOR(low)[act] = VECTOR(num)[nei];
                    }
                }
                VECTOR(nextptr)[act] += 1;
            } else {
                /* Step up */
                igraph_stack_pop(&path);
                if (!igraph_stack_empty(&path)) {
                    long int prev = (long int) igraph_stack_top(&path);
                    /* Update LOW value if needed */
                    if (VECTOR(low)[act] < VECTOR(low)[prev]) {
                        VECTOR(low)[prev] = VECTOR(low)[act];
                    }
                    /* Check for articulation point */
                    if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
                        if (articulation_points && !VECTOR(found)[prev]
                            && prev != i /* the root */) {
                            IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
                            VECTOR(found)[prev] = 1;
                        }
                        if (no) {
                            *no += 1;
                        }

                        /*------------------------------------*/
                        /* Record the biconnected component just found */
                        if (tree_edges || mycomponents) {
                            igraph_vector_t *v = 0, *v2 = 0;
                            comps++;
                            if (tree_edges) {
                                v = IGRAPH_CALLOC(1, igraph_vector_t);
                                if (!v) {
                                    IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM);
                                }
                                IGRAPH_CHECK(igraph_vector_init(v, 0));
                                IGRAPH_FINALLY(igraph_vector_destroy, v);
                            }
                            if (mycomponents) {
                                v2 = IGRAPH_CALLOC(1, igraph_vector_t);
                                if (!v2) {
                                    IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM);
                                }
                                IGRAPH_CHECK(igraph_vector_init(v2, 0));
                                IGRAPH_FINALLY(igraph_vector_destroy, v2);
                            }

                            while (!igraph_vector_empty(&edgestack)) {
                                long int e = (long int) igraph_vector_pop_back(&edgestack);
                                long int from = IGRAPH_FROM(graph, e);
                                long int to = IGRAPH_TO(graph, e);
                                if (tree_edges) {
                                    IGRAPH_CHECK(igraph_vector_push_back(v, e));
                                }
                                if (mycomponents) {
                                    if (VECTOR(vertex_added)[from] != comps) {
                                        VECTOR(vertex_added)[from] = comps;
                                        IGRAPH_CHECK(igraph_vector_push_back(v2, from));
                                    }
                                    if (VECTOR(vertex_added)[to] != comps) {
                                        VECTOR(vertex_added)[to] = comps;
                                        IGRAPH_CHECK(igraph_vector_push_back(v2, to));
                                    }
                                }
                                if (from == prev || to == prev) {
                                    break;
                                }
                            }

                            if (mycomponents) {
                                IGRAPH_CHECK(igraph_vector_ptr_push_back(mycomponents, v2));
                                IGRAPH_FINALLY_CLEAN(1);
                            }
                            if (tree_edges) {
                                IGRAPH_CHECK(igraph_vector_ptr_push_back(tree_edges, v));
                                IGRAPH_FINALLY_CLEAN(1);
                            }
                            if (component_edges) {
                                igraph_vector_t *nodes = VECTOR(*mycomponents)[comps - 1];
                                igraph_vector_t *vv = IGRAPH_CALLOC(1, igraph_vector_t);
                                long int ii, no_vert = igraph_vector_size(nodes);
                                if (!vv) {
                                    IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM);
                                }
                                IGRAPH_CHECK(igraph_vector_init(vv, 0));
                                IGRAPH_FINALLY(igraph_vector_destroy, vv);
                                for (ii = 0; ii < no_vert; ii++) {
                                    long int vert = (long int) VECTOR(*nodes)[ii];
                                    igraph_vector_int_t *edges = igraph_inclist_get(&inclist,
                                                                 vert);
                                    long int j, nn = igraph_vector_int_size(edges);
                                    for (j = 0; j < nn; j++) {
                                        long int e = (long int) VECTOR(*edges)[j];
                                        long int nei = IGRAPH_OTHER(graph, e, vert);
                                        if (VECTOR(vertex_added)[nei] == comps && nei < vert) {
                                            IGRAPH_CHECK(igraph_vector_push_back(vv, e));
                                        }
                                    }
                                }
                                IGRAPH_CHECK(igraph_vector_ptr_push_back(component_edges, vv));
                                IGRAPH_FINALLY_CLEAN(1);
                            }
                        } /* record component if requested */
                        /*------------------------------------*/

                    }
                } /* !igraph_stack_empty(&path) */
            }

        } /* !igraph_stack_empty(&path) */

        if (articulation_points && rootdfs >= 2) {
            IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
        }

    } /* i < no_of_nodes */

    if (mycomponents != components) {
        igraph_i_free_vectorlist(mycomponents);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_long_destroy(&vertex_added);
    igraph_inclist_destroy(&inclist);
    igraph_vector_destroy(&edgestack);
    igraph_stack_destroy(&path);
    igraph_vector_bool_destroy(&found);
    igraph_vector_long_destroy(&low);
    igraph_vector_long_destroy(&num);
    igraph_vector_long_destroy(&nextptr);
    IGRAPH_FINALLY_CLEAN(8);

    return 0;
}


/* igraph_bridges -- find all bridges in the graph */
/* The algorithm is based on https://www.geeksforgeeks.org/bridge-in-a-graph/
   but instead of keeping track of the parent of each vertex in the DFS tree
   we keep track of its incoming edge. This is necessary to support multigraphs. */

static int igraph_i_bridges_rec(
        const igraph_t *graph, const igraph_inclist_t *il, igraph_integer_t u,
        igraph_integer_t *time, igraph_vector_t *bridges, igraph_vector_bool_t *visited,
        igraph_vector_int_t *disc, igraph_vector_int_t *low, igraph_vector_int_t *incoming_edge)
{
    igraph_vector_int_t *incedges;
    long nc; /* neighbour count */
    long i;

    VECTOR(*visited)[u] = 1;

    *time += 1;

    VECTOR(*disc)[u] = *time;
    VECTOR(*low)[u] = *time;

    incedges = igraph_inclist_get(il, u);
    nc = igraph_vector_int_size(incedges);
    for (i = 0; i < nc; ++i) {
        long edge = (long) VECTOR(*incedges)[i];
        igraph_integer_t v = IGRAPH_TO(graph, edge) == u ? IGRAPH_FROM(graph, edge) : IGRAPH_TO(graph, edge);

        if (! VECTOR(*visited)[v]) {
            VECTOR(*incoming_edge)[v] = edge;
            IGRAPH_CHECK(igraph_i_bridges_rec(graph, il, v, time, bridges, visited, disc, low, incoming_edge));

            VECTOR(*low)[u] = VECTOR(*low)[u] < VECTOR(*low)[v] ? VECTOR(*low)[u] : VECTOR(*low)[v];

            if (VECTOR(*low)[v] > VECTOR(*disc)[u]) {
                IGRAPH_CHECK(igraph_vector_push_back(bridges, edge));
            }
        } else if (edge != VECTOR(*incoming_edge)[u]) {
            VECTOR(*low)[u] = VECTOR(*low)[u] < VECTOR(*disc)[v] ? VECTOR(*low)[u] : VECTOR(*disc)[v];
        }
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_bridges
 * Find all bridges in a graph.
 *
 * An edge is a bridge if its removal increases the number of (weakly)
 * connected components in the graph.
 *
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the
 *    bridges will be stored here as edge indices.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and edges.
 *
 * \sa \ref igraph_articulation_points(), \ref igraph_biconnected_components(), \ref igraph_clusters()
 */

int igraph_bridges(const igraph_t *graph, igraph_vector_t *bridges) {
    igraph_inclist_t il;
    igraph_vector_bool_t visited;
    igraph_vector_int_t disc, low;
    igraph_vector_int_t incoming_edge;
    long n;
    long i;
    igraph_integer_t time;

    n = igraph_vcount(graph);

    IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &il);

    IGRAPH_CHECK(igraph_vector_bool_init(&visited, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &visited);

    IGRAPH_CHECK(igraph_vector_int_init(&disc, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &disc);

    IGRAPH_CHECK(igraph_vector_int_init(&low, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &low);

    IGRAPH_CHECK(igraph_vector_int_init(&incoming_edge, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &incoming_edge);
    for (i = 0; i < n; ++i) {
        VECTOR(incoming_edge)[i] = -1;
    }

    igraph_vector_clear(bridges);

    time = 0;
    for (i = 0; i < n; ++i)
        if (! VECTOR(visited)[i]) {
            IGRAPH_CHECK(igraph_i_bridges_rec(graph, &il, i, &time, bridges, &visited, &disc, &low, &incoming_edge));
        }

    igraph_vector_int_destroy(&incoming_edge);
    igraph_vector_int_destroy(&low);
    igraph_vector_int_destroy(&disc);
    igraph_vector_bool_destroy(&visited);
    igraph_inclist_destroy(&il);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_subcomponent
 * \brief The vertices in the same component as a given vertex.
 *
 * \param graph The graph object.
 * \param res The result, vector with the ids of the vertices in the
 *        same component.
 * \param vertex The id of the vertex of which the component is
 *        searched.
 * \param mode Type of the component for directed graphs, possible
 *        values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the set of vertices reachable \em from the
 *          \p vertex,
 *        \cli IGRAPH_IN
 *          the set of vertices from which the
 *          \p vertex is reachable.
 *        \cli IGRAPH_ALL
 *          the graph is considered as an
 *          undirected graph. Note that this is \em not the same
 *          as the union of the previous two.
 *        \endclist
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *          not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           \p vertex is an invalid vertex id
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument passed.
 *        \endclist
 *
 * Time complexity: O(|V|+|E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 *
 * \sa \ref igraph_induced_subgraph() if you want a graph object consisting only
 * a given set of vertices and the edges between them.
 */
int igraph_subcomponent(const igraph_t *graph, igraph_vector_t *res, igraph_real_t vertex,
                        igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    char *already_added;
    long int i, vsize;
    igraph_vector_t tmp = IGRAPH_VECTOR_NULL;

    if (!IGRAPH_FINITE(vertex) || vertex < 0 || vertex >= no_of_nodes) {
        IGRAPH_ERROR("Vertex id out of range.", IGRAPH_EINVVID);
    }
    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument.", IGRAPH_EINVMODE);
    }

    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("Subcomponent failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);

    igraph_vector_clear(res);

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_dqueue_push(&q, vertex));
    IGRAPH_CHECK(igraph_vector_push_back(res, vertex));
    already_added[(long int)vertex] = 1;

    while (!igraph_dqueue_empty(&q)) {
        long int actnode = (long int) igraph_dqueue_pop(&q);

        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) actnode,
                                      mode));
        vsize = igraph_vector_size(&tmp);
        for (i = 0; i < vsize; i++) {
            long int neighbor = (long int) VECTOR(tmp)[i];

            if (already_added[neighbor]) {
                continue;
            }
            already_added[neighbor] = 1;
            IGRAPH_CHECK(igraph_vector_push_back(res, neighbor));
            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
        }
    }

    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&tmp);
    IGRAPH_FREE(already_added);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/connectivity/separators.c0000644000175100001710000007575600000000000025532 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_separators.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_flow.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_structural.h"
#include "igraph_vector.h"

#include "core/interruption.h"

static int igraph_i_is_separator(const igraph_t *graph,
                                 igraph_vit_t *vit,
                                 long int except,
                                 igraph_bool_t *res,
                                 igraph_vector_bool_t *removed,
                                 igraph_dqueue_t *Q,
                                 igraph_vector_t *neis,
                                 long int no_of_nodes) {

    long int start = 0;

    if (IGRAPH_VIT_SIZE(*vit) >= no_of_nodes - 1) {
        /* Just need to check that we really have at least n-1 vertices in it */
        igraph_vector_bool_t hit;
        long int nohit = 0;
        IGRAPH_CHECK(igraph_vector_bool_init(&hit, no_of_nodes));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, &hit);
        for (IGRAPH_VIT_RESET(*vit);
             !IGRAPH_VIT_END(*vit);
             IGRAPH_VIT_NEXT(*vit)) {
            long int v = IGRAPH_VIT_GET(*vit);
            if (!VECTOR(hit)[v]) {
                nohit++;
                VECTOR(hit)[v] = 1;
            }
        }
        igraph_vector_bool_destroy(&hit);
        IGRAPH_FINALLY_CLEAN(1);
        if (nohit >= no_of_nodes - 1) {
            *res = 0;
            return 0;
        }
    }

    /* Remove the given vertices from the graph, do a breadth-first
       search and check the number of components */

    if (except < 0) {
        for (IGRAPH_VIT_RESET(*vit);
             !IGRAPH_VIT_END(*vit);
             IGRAPH_VIT_NEXT(*vit)) {
            VECTOR(*removed)[ (long int) IGRAPH_VIT_GET(*vit) ] = 1;
        }
    } else {
        /* There is an exception */
        long int i;
        for (i = 0, IGRAPH_VIT_RESET(*vit);
             i < except;
             i++, IGRAPH_VIT_NEXT(*vit)) {
            VECTOR(*removed)[ (long int) IGRAPH_VIT_GET(*vit) ] = 1;
        }
        for (IGRAPH_VIT_NEXT(*vit);
             !IGRAPH_VIT_END(*vit);
             IGRAPH_VIT_NEXT(*vit)) {
            VECTOR(*removed)[ (long int) IGRAPH_VIT_GET(*vit) ] = 1;
        }
    }

    /* Look for the first node that is not removed */
    while (start < no_of_nodes && VECTOR(*removed)[start]) {
        start++;
    }

    if (start == no_of_nodes) {
        IGRAPH_ERROR("All vertices are included in the separator",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_dqueue_push(Q, start));
    VECTOR(*removed)[start] = 1;
    while (!igraph_dqueue_empty(Q)) {
        long int node = (long int) igraph_dqueue_pop(Q);
        long int j, n;
        IGRAPH_CHECK(igraph_neighbors(graph, neis, (igraph_integer_t) node, IGRAPH_ALL));
        n = igraph_vector_size(neis);
        for (j = 0; j < n; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            if (!VECTOR(*removed)[nei]) {
                IGRAPH_CHECK(igraph_dqueue_push(Q, nei));
                VECTOR(*removed)[nei] = 1;
            }
        }
    }

    /* Look for the next node that was neighter removed, not visited */
    while (start < no_of_nodes && VECTOR(*removed)[start]) {
        start++;
    }

    /* If there is another component, then we have a separator */
    *res = (start < no_of_nodes);

    return 0;
}

/**
 * \function igraph_is_separator
 * \brief Would removing this set of vertices disconnect the graph?
 *
 * \param graph The input graph. It may be directed, but edge
 *        directions are ignored.
 * \param candidate The candidate separator. It must not contain all
 *        vertices.
 * \param res Pointer to a Boolean variable, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number vertices and edges.
 *
 * \example examples/simple/igraph_is_separator.c
 */

int igraph_is_separator(const igraph_t *graph,
                        const igraph_vs_t candidate,
                        igraph_bool_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_bool_t removed;
    igraph_dqueue_t Q;
    igraph_vector_t neis;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
    IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed,
                                       &Q, &neis, no_of_nodes));

    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&Q);
    igraph_vector_bool_destroy(&removed);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/**
 * \function igraph_is_minimal_separator
 * \brief Decides whether a set of vertices is a minimal separator.
 *
 * A set of vertices is a minimal separator, if the removal of the
 * vertices disconnects the graph, and this is not true for any subset
 * of the set.
 *
 * This implementation first checks that the given
 * candidate is a separator, by calling \ref
 * igraph_is_separator(). If it is a separator, then it checks that
 * each subset of size n-1, where n is the size of the candidate, is
 * not a separator.
 *
 * \param graph The input graph. It may be directed, but edge
 *        directions are ignored.
 * \param candidate Pointer to a vector of long integers, the
 *        candidate minimal separator.
 * \param res Pointer to a boolean variable, the result is stored
 *        here.
 * \return Error code.
 *
 * Time complexity: O(n(|V|+|E|)), |V| is the number of vertices, |E|
 * is the number of edges, n is the number vertices in the candidate
 * separator.
 *
 * \example examples/simple/igraph_is_minimal_separator.c
 */

int igraph_is_minimal_separator(const igraph_t *graph,
                                const igraph_vs_t candidate,
                                igraph_bool_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_bool_t removed;
    igraph_dqueue_t Q;
    igraph_vector_t neis;
    long int candsize;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    candsize = IGRAPH_VIT_SIZE(vit);

    IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
    IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    /* Is it a separator at all? */
    IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed,
                                       &Q, &neis, no_of_nodes));
    if (!(*res)) {
        /* Not a separator at all, nothing to do, *res is already set */
    } else if (candsize == 0) {
        /* Nothing to do, minimal, *res is already set */
    } else {
        /* General case, we need to remove each vertex from 'candidate'
         * and check whether the remainder is a separator. If this is
         * false for all vertices, then 'candidate' is a minimal
         * separator.
         */
        long int i;
        for (i = 0, *res = 0; i < candsize && (!*res); i++) {
            igraph_vector_bool_null(&removed);
            IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, i, res, &removed,
                                               &Q, &neis, no_of_nodes));
        }
        (*res) = (*res) ? 0 : 1;    /* opposite */
    }

    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&Q);
    igraph_vector_bool_destroy(&removed);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/* --------------------------------------------------------------------*/

#define UPDATEMARK() do {                              \
        (*mark)++;                         \
        if (!(*mark)) {                    \
            igraph_vector_null(leaveout);                \
            (*mark)=1;                       \
        }                                                  \
    } while (0)

static int igraph_i_clusters_leaveout(const igraph_adjlist_t *adjlist,
                                      igraph_vector_t *components,
                                      igraph_vector_t *leaveout,
                                      unsigned long int *mark,
                                      igraph_dqueue_t *Q) {

    /* Another trick: we use the same 'leaveout' vector to mark the
     * vertices that were already found in the BFS
     */

    long int i, no_of_nodes = igraph_adjlist_size(adjlist);

    igraph_dqueue_clear(Q);
    igraph_vector_clear(components);

    for (i = 0; i < no_of_nodes; i++) {

        if (VECTOR(*leaveout)[i] == *mark) {
            continue;
        }

        VECTOR(*leaveout)[i] = *mark;
        igraph_dqueue_push(Q, i);
        igraph_vector_push_back(components, i);

        while (!igraph_dqueue_empty(Q)) {
            long int act_node = (long int) igraph_dqueue_pop(Q);
            igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, act_node);
            long int j, n = igraph_vector_int_size(neis);
            for (j = 0; j < n; j++) {
                long int nei = (long int) VECTOR(*neis)[j];
                if (VECTOR(*leaveout)[nei] == *mark) {
                    continue;
                }
                IGRAPH_CHECK(igraph_dqueue_push(Q, nei));
                VECTOR(*leaveout)[nei] = *mark;
                igraph_vector_push_back(components, nei);
            }
        }

        igraph_vector_push_back(components, -1);
    }

    UPDATEMARK();

    return 0;
}

static igraph_bool_t igraph_i_separators_newsep(const igraph_vector_ptr_t *comps,
                                                const igraph_vector_t *newc) {

    long int co, nocomps = igraph_vector_ptr_size(comps);

    for (co = 0; co < nocomps; co++) {
        igraph_vector_t *act = VECTOR(*comps)[co];
        if (igraph_vector_all_e(act, newc)) {
            return 0;
        }
    }

    /* If not found, then it is new */
    return 1;
}

static int igraph_i_separators_store(igraph_vector_ptr_t *separators,
                                     const igraph_adjlist_t *adjlist,
                                     igraph_vector_t *components,
                                     igraph_vector_t *leaveout,
                                     unsigned long int *mark,
                                     igraph_vector_t *sorter) {

    /* We need to stote N(C), the neighborhood of C, but only if it is
     * not already stored among the separators.
     */

    long int cptr = 0, next, complen = igraph_vector_size(components);

    while (cptr < complen) {
        long int saved = cptr;
        igraph_vector_clear(sorter);

        /* Calculate N(C) for the next C */

        while ( (next = (long int) VECTOR(*components)[cptr++]) != -1) {
            VECTOR(*leaveout)[next] = *mark;
        }
        cptr = saved;

        while ( (next = (long int) VECTOR(*components)[cptr++]) != -1) {
            igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, next);
            long int j, nn = igraph_vector_int_size(neis);
            for (j = 0; j < nn; j++) {
                long int nei = (long int) VECTOR(*neis)[j];
                if (VECTOR(*leaveout)[nei] != *mark) {
                    igraph_vector_push_back(sorter, nei);
                    VECTOR(*leaveout)[nei] = *mark;
                }
            }
        }
        igraph_vector_sort(sorter);

        UPDATEMARK();

        /* Add it to the list of separators, if it is new */

        if (igraph_i_separators_newsep(separators, sorter)) {
            igraph_vector_t *newc = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!newc) {
                IGRAPH_ERROR("Cannot calculate minimal separators", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, newc);
            igraph_vector_copy(newc, sorter);
            IGRAPH_FINALLY(igraph_vector_destroy, newc);
            IGRAPH_CHECK(igraph_vector_ptr_push_back(separators, newc));
            IGRAPH_FINALLY_CLEAN(2);
        }
    } /* while cptr < complen */

    return 0;
}

static void igraph_i_separators_free(igraph_vector_ptr_t *separators) {
    long int i, n = igraph_vector_ptr_size(separators);
    for (i = 0; i < n; i++) {
        igraph_vector_t *vec = VECTOR(*separators)[i];
        if (vec) {
            igraph_vector_destroy(vec);
            IGRAPH_FREE(vec);
        }
    }
}

/**
 * \function igraph_all_minimal_st_separators
 * \brief List all vertex sets that are minimal (s,t) separators for some s and t.
 *
 * This function lists all vertex sets that are minimal (s,t)
 * separators for some (s,t) vertex pair.
 *
 * 
 * Note that some vertex sets returned by this function may not be minimal
 * with respect to disconnecting the graph (or increasing the number of
 * connected components). Take for example the 5-vertex graph with edges
 * 0-1-2-3-4-1. This function returns the vertex sets
 * {1}, {2,4} and {1,3}.
 * Notice that {1,3} is not minimal with respect to disconnecting
 * the graph, as {1} would be sufficient for that. However, it is
 * minimal with respect to separating vertices \c 2 and \c 4.
 *
 * 
 * See more about the implemented algorithm in
 * Anne Berry, Jean-Paul Bordat and Olivier Cogis: Generating All the
 * Minimal Separators of a Graph, In: Peter Widmayer, Gabriele Neyer
 * and Stephan Eidenbenz (editors): Graph-theoretic concepts in
 * computer science, 1665, 167--172, 1999. Springer.
 * https://doi.org/10.1007/3-540-46784-X_17
 *
 * \param graph The input graph. It may be directed, but edge
 *        directions are ignored.
 * \param separators An initialized pointer vector, the separators
 *        are stored here. It is a list of pointers to igraph_vector_t
 *        objects. Each vector will contain the ids of the vertices in
 *        the separator.
 *        To free all memory allocated for \p separators, you need call
 *        \ref igraph_vector_destroy() and then \ref igraph_free() on
 *        each element, before destroying the pointer vector itself.
 * \return Error code.
 *
 * \sa \ref igraph_minimum_size_separators()
 *
 * Time complexity: O(n|V|^3), |V| is the number of vertices, n is the
 * number of separators.
 *
 * \example examples/simple/igraph_minimal_separators.c
 */

int igraph_all_minimal_st_separators(const igraph_t *graph,
                                     igraph_vector_ptr_t *separators) {

    /*
     * Some notes about the tricks used here. For finding the components
     * of the graph after removing some vertices, we do the
     * following. First we mark the vertices with the actual mark stamp
     * (mark), then run breadth-first search on the graph, but not
     * considering the marked vertices. Then we increase the mark. If
     * there is integer overflow here, then we zero out the mark and set
     * it to one. (We might as well just always zero it out.)
     *
     * For each separator the vertices are stored in vertex id order.
     * This facilitates the comparison of the separators when we find a
     * potential new candidate.
     *
     * To keep track of which separator we already used as a basis, we
     * keep a boolean vector (already_tried). The try_next pointer show
     * the next separator to try as a basis.
     */

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t leaveout;
    igraph_vector_bool_t already_tried;
    long int try_next = 0;
    unsigned long int mark = 1;
    long int v;

    igraph_adjlist_t adjlist;
    igraph_vector_t components;
    igraph_dqueue_t Q;
    igraph_vector_t sorter;

    igraph_vector_ptr_clear(separators);
    IGRAPH_FINALLY(igraph_i_separators_free, separators);

    IGRAPH_CHECK(igraph_vector_init(&leaveout, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_destroy, &leaveout);
    IGRAPH_CHECK(igraph_vector_bool_init(&already_tried, 0));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &already_tried);
    IGRAPH_CHECK(igraph_vector_init(&components, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &components);
    IGRAPH_CHECK(igraph_vector_reserve(&components, no_of_nodes * 2));
    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
    IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
    IGRAPH_CHECK(igraph_vector_init(&sorter, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &sorter);
    IGRAPH_CHECK(igraph_vector_reserve(&sorter, no_of_nodes));

    /* ---------------------------------------------------------------
     * INITIALIZATION, we check whether the neighborhoods of the
     * vertices separate the graph. The ones that do will form the
     * initial basis.
     */

    for (v = 0; v < no_of_nodes; v++) {

        /* Mark v and its neighbors */
        igraph_vector_int_t *neis = igraph_adjlist_get(&adjlist, v);
        long int i, n = igraph_vector_int_size(neis);
        VECTOR(leaveout)[v] = mark;
        for (i = 0; i < n; i++) {
            long int nei = (long int) VECTOR(*neis)[i];
            VECTOR(leaveout)[nei] = mark;
        }

        /* Find the components */
        IGRAPH_CHECK(igraph_i_clusters_leaveout(&adjlist, &components, &leaveout,
                                                &mark, &Q));

        /* Store the corresponding separators, N(C) for each component C */
        IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist, &components,
                                               &leaveout, &mark, &sorter));

    }

    /* ---------------------------------------------------------------
     * GENERATION, we need to use all already found separators as
     * basis and see if they generate more separators
     */

    while (try_next < igraph_vector_ptr_size(separators)) {
        igraph_vector_t *basis = VECTOR(*separators)[try_next];
        long int b, basislen = igraph_vector_size(basis);
        for (b = 0; b < basislen; b++) {

            /* Remove N(x) U basis */
            long int x = (long int) VECTOR(*basis)[b];
            igraph_vector_int_t *neis = igraph_adjlist_get(&adjlist, x);
            long int i, n = igraph_vector_int_size(neis);
            for (i = 0; i < basislen; i++) {
                long int sn = (long int) VECTOR(*basis)[i];
                VECTOR(leaveout)[sn] = mark;
            }
            for (i = 0; i < n; i++) {
                long int nei = (long int) VECTOR(*neis)[i];
                VECTOR(leaveout)[nei] = mark;
            }

            /* Find the components */
            IGRAPH_CHECK(igraph_i_clusters_leaveout(&adjlist, &components,
                                                    &leaveout, &mark, &Q));

            /* Store the corresponding separators, N(C) for each component C */
            IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist,
                                                   &components, &leaveout, &mark,
                                                   &sorter));
        }

        try_next++;
    }

    /* --------------------------------------------------------------- */

    igraph_vector_destroy(&sorter);
    igraph_dqueue_destroy(&Q);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_destroy(&components);
    igraph_vector_bool_destroy(&already_tried);
    igraph_vector_destroy(&leaveout);
    IGRAPH_FINALLY_CLEAN(7);  /* +1 for separators */

    return 0;
}

#undef UPDATEMARK

static int igraph_i_minimum_size_separators_append(igraph_vector_ptr_t *old,
                                                   igraph_vector_ptr_t *new) {

    long int olen = igraph_vector_ptr_size(old);
    long int nlen = igraph_vector_ptr_size(new);
    long int i;

    for (i = 0; i < nlen; i++) {
        igraph_vector_t *newvec = VECTOR(*new)[i];
        long int j;
        for (j = 0; j < olen; j++) {
            igraph_vector_t *oldvec = VECTOR(*old)[j];
            if (igraph_vector_all_e(oldvec, newvec)) {
                break;
            }
        }
        if (j == olen) {
            IGRAPH_CHECK(igraph_vector_ptr_push_back(old, newvec));
            olen++;
        } else {
            igraph_vector_destroy(newvec);
            igraph_free(newvec);
        }
        VECTOR(*new)[i] = 0;
    }
    igraph_vector_ptr_clear(new);

    return 0;
}

static int igraph_i_minimum_size_separators_topkdeg(const igraph_t *graph,
                                                    igraph_vector_t *res,
                                                    long int k) {
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t deg, order;
    long int i;

    IGRAPH_VECTOR_INIT_FINALLY(°, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(), IGRAPH_ALL,
                               /*loops=*/ 0));

    IGRAPH_CHECK(igraph_vector_order1(°, &order, no_of_nodes));
    IGRAPH_CHECK(igraph_vector_resize(res, k));
    for (i = 0; i < k; i++) {
        VECTOR(*res)[i] = VECTOR(order)[no_of_nodes - 1 - i];
    }

    igraph_vector_destroy(&order);
    igraph_vector_destroy(°);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static void igraph_i_separators_stcuts_free(igraph_vector_ptr_t *p) {
    long int i, n = igraph_vector_ptr_size(p);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*p)[i];
        if (v) {
            igraph_vector_destroy(v);
            igraph_free(v);
            VECTOR(*p)[i] = 0;
        }
    }
    igraph_vector_ptr_destroy(p);
}

/**
 * \function igraph_minimum_size_separators
 * \brief Find all minimum size separating vertex sets.
 *
 * This function lists all separator vertex sets of minimum size.
 * A vertex set is a separator if its removal disconnects the graph.
 *
 * 
 * The implementation is based on the following paper:
 * Arkady Kanevsky: Finding all minimum-size separating vertex sets in
 * a graph, Networks 23, 533--541, 1993.
 *
 * \param graph The input graph, which must be undirected.
 * \param separators An initialized pointer vector, the separators
 *        are stored here. It is a list of pointers to igraph_vector_t
 *        objects. Each vector will contain the ids of the vertices in
 *        the separator.
 *        To free all memory allocated for \c separators, you need call
 *        \ref igraph_vector_destroy() and then \ref igraph_free() on
 *        each element, before destroying the pointer vector itself.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_minimum_size_separators.c
 */

int igraph_minimum_size_separators(const igraph_t *graph,
                                   igraph_vector_ptr_t *separators) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_integer_t conn; long int k;
    igraph_vector_t X;
    long int i, j;
    igraph_bool_t issepX;
    igraph_t Gbar;
    igraph_vector_t phi;
    igraph_t graph_copy;
    igraph_vector_t capacity;
    igraph_maxflow_stats_t stats;

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Minimum size separators currently only works on undirected graphs",
                     IGRAPH_EINVAL);
    }

    igraph_vector_ptr_clear(separators);
    IGRAPH_FINALLY(igraph_i_separators_free, separators);

    /* ---------------------------------------------------------------- */
    /* 1 Find the vertex connectivity of 'graph' */
    IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn,
                                            /* checks= */ 1)); k = conn;

    /* Special cases for low connectivity, two exits here! */
    if (conn == 0) {
        /* Nothing to do */
        IGRAPH_FINALLY_CLEAN(1);    /* separators */
        return 0;
    } else if (conn == 1) {
        igraph_vector_t ap;
        long int i, n;
        IGRAPH_VECTOR_INIT_FINALLY(&ap, 0);
        IGRAPH_CHECK(igraph_articulation_points(graph, &ap));
        n = igraph_vector_size(&ap);
        IGRAPH_CHECK(igraph_vector_ptr_resize(separators, n));
        igraph_vector_ptr_null(separators);
        for (i = 0; i < n; i++) {
            igraph_vector_t *v = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!v) {
                IGRAPH_ERROR("Minimum size separators failed", IGRAPH_ENOMEM);
            }
            IGRAPH_VECTOR_INIT_FINALLY(v, 1);
            VECTOR(*v)[0] = VECTOR(ap)[i];
            VECTOR(*separators)[i] = v;
            IGRAPH_FINALLY_CLEAN(1);
        }
        igraph_vector_destroy(&ap);
        IGRAPH_FINALLY_CLEAN(2);    /* +1 for separators */
        return 0;
    } else if (conn == no_of_nodes - 1) {
        long int k;
        IGRAPH_CHECK(igraph_vector_ptr_resize(separators, no_of_nodes));
        igraph_vector_ptr_null(separators);
        for (i = 0; i < no_of_nodes; i++) {
            igraph_vector_t *v = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!v) {
                IGRAPH_ERROR("Cannot list minimum size separators", IGRAPH_ENOMEM);
            }
            IGRAPH_VECTOR_INIT_FINALLY(v, no_of_nodes - 1);
            for (j = 0, k = 0; j < no_of_nodes; j++) {
                if (j != i) {
                    VECTOR(*v)[k++] = j;
                }
            }
            VECTOR(*separators)[i] = v;
            IGRAPH_FINALLY_CLEAN(1);
        }
        IGRAPH_FINALLY_CLEAN(1);    /* separators */
        return 0;
    }

    /* Work on a copy of 'graph' */
    IGRAPH_CHECK(igraph_copy(&graph_copy, graph));
    IGRAPH_FINALLY(igraph_destroy, &graph_copy);
    IGRAPH_CHECK(igraph_simplify(&graph_copy, /* multiple */ 1, /* loops */ 1, NULL));

    /* ---------------------------------------------------------------- */
    /* 2 Find k vertices with the largest degrees (x1;..,xk). Check
       if these k vertices form a separating k-set of G */
    IGRAPH_CHECK(igraph_vector_init(&X, conn));
    IGRAPH_FINALLY(igraph_vector_destroy, &X);
    IGRAPH_CHECK(igraph_i_minimum_size_separators_topkdeg(&graph_copy, &X, k));
    IGRAPH_CHECK(igraph_is_separator(&graph_copy, igraph_vss_vector(&X),
                                     &issepX));
    if (issepX) {
        igraph_vector_t *v = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!v) {
            IGRAPH_ERROR("Cannot find minimal size separators", IGRAPH_ENOMEM);
        }
        IGRAPH_VECTOR_INIT_FINALLY(v, k);
        for (i = 0; i < k; i++) {
            VECTOR(*v)[i] = VECTOR(X)[i];
        }
        IGRAPH_CHECK(igraph_vector_ptr_push_back(separators, v));
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* Create Gbar, the Even-Tarjan reduction of graph */
    IGRAPH_VECTOR_INIT_FINALLY(&capacity, 0);
    IGRAPH_CHECK(igraph_even_tarjan_reduction(&graph_copy, &Gbar, &capacity));
    IGRAPH_FINALLY(igraph_destroy, &Gbar);

    IGRAPH_VECTOR_INIT_FINALLY(&phi, no_of_edges);

    /* ---------------------------------------------------------------- */
    /* 3 If v[j] != x[i] and v[j] is not adjacent to x[i] then */
    for (i = 0; i < k; i++) {

        IGRAPH_ALLOW_INTERRUPTION();

        for (j = 0; j < no_of_nodes; j++) {
            long int ii = (long int) VECTOR(X)[i];
            igraph_real_t phivalue;
            igraph_bool_t conn;

            if (ii == j) {
                continue;    /* the same vertex */
            }
            IGRAPH_CHECK(igraph_are_connected(&graph_copy, (igraph_integer_t) ii,
                                 (igraph_integer_t) j, &conn));
            if (conn) {
                continue;    /* they are connected */
            }

            /* --------------------------------------------------------------- */
            /* 4 Compute a maximum flow phi in Gbar from x[i] to v[j].
            If |phi|=k, then */
            IGRAPH_CHECK(igraph_maxflow(&Gbar, &phivalue, &phi, /*cut=*/ 0,
                                        /*partition=*/ 0, /*partition2=*/ 0,
                                        /* source= */
                                        (igraph_integer_t) (ii + no_of_nodes),
                                        /* target= */ (igraph_integer_t) j,
                                        &capacity, &stats));

            if (phivalue == k) {

                /* ------------------------------------------------------------- */
                /* 5-6-7. Find all k-sets separating x[i] and v[j]. */
                igraph_vector_ptr_t stcuts;
                IGRAPH_CHECK(igraph_vector_ptr_init(&stcuts, 0));
                IGRAPH_FINALLY(igraph_i_separators_stcuts_free, &stcuts);
                IGRAPH_CHECK(igraph_all_st_mincuts(&Gbar, /*value=*/ 0,
                                                   /*cuts=*/ &stcuts,
                                                   /*partition1s=*/ 0,
                                                   /*source=*/ (igraph_integer_t)
                                                   (ii + no_of_nodes),
                                                   /*target=*/ (igraph_integer_t) j,
                                                   /*capacity=*/ &capacity));

                IGRAPH_CHECK(igraph_i_minimum_size_separators_append(separators,
                             &stcuts));
                igraph_vector_ptr_destroy(&stcuts);
                IGRAPH_FINALLY_CLEAN(1);

            } /* if phivalue == k */

            /* --------------------------------------------------------------- */
            /* 8 Add edge (x[i],v[j]) to G. */
            IGRAPH_CHECK(igraph_add_edge(&graph_copy, (igraph_integer_t) ii,
                                         (igraph_integer_t) j));
            IGRAPH_CHECK(igraph_add_edge(&Gbar, (igraph_integer_t) (ii + no_of_nodes),
                                         (igraph_integer_t) j));
            IGRAPH_CHECK(igraph_add_edge(&Gbar, (igraph_integer_t) (j + no_of_nodes),
                                         (igraph_integer_t) ii));
            IGRAPH_CHECK(igraph_vector_push_back(&capacity, no_of_nodes));
            IGRAPH_CHECK(igraph_vector_push_back(&capacity, no_of_nodes));

        } /* for j M2) {
                M1 = M2;
            }
            for (k = 0; k < M1; k++) {
                IGRAPH_CHECK(igraph_vector_push_back(edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            }
        }
    }

    return 0;
}

/**
 * \ingroup generators
 * \function igraph_adjacency
 * \brief Creates a graph from an adjacency matrix.
 *
 * The order of the vertices in the matrix is preserved, i.e. the vertex
 * corresponding to the first row/column will be vertex with id 0, the
 * next row is for vertex 1, etc.
 * \param graph Pointer to an uninitialized graph object.
 * \param adjmatrix The adjacency matrix. How it is interpreted
 *        depends on the \p mode argument.
 * \param mode Constant to specify how the given matrix is interpreted
 *        as an adjacency matrix. Possible values
 *        (A(i,j)
 *        is the element in row i and column
 *        j in the adjacency matrix
 *        \p adjmatrix):
 *        \clist
 *        \cli IGRAPH_ADJ_DIRECTED
 *          the graph will be directed and
 *          an element gives the number of edges between two vertices.
 *        \cli IGRAPH_ADJ_UNDIRECTED
 *          this is the same as \c IGRAPH_ADJ_MAX,
 *          for convenience.
 *        \cli IGRAPH_ADJ_MAX
 *          undirected graph will be created
 *          and the number of edges between vertices
 *          i and
 *          j is
 *          max(A(i,j), A(j,i)).
 *        \cli IGRAPH_ADJ_MIN
 *          undirected graph will be created
 *          with min(A(i,j), A(j,i))
 *          edges between vertices
 *          i and
 *          j.
 *        \cli IGRAPH_ADJ_PLUS
 *          undirected graph will be created
 *          with A(i,j)+A(j,i) edges
 *          between vertices
 *          i and
 *          j.
 *        \cli IGRAPH_ADJ_UPPER
 *          undirected graph will be created,
 *          only the upper right triangle (including the diagonal) is
 *          used for the number of edges.
 *        \cli IGRAPH_ADJ_LOWER
 *          undirected graph will be created,
 *          only the lower left triangle (including the diagonal) is
 *          used for creating the edges.
 *       \endclist
 * \return Error code,
 *         \c IGRAPH_NONSQUARE: non-square matrix.
 *
 * Time complexity: O(|V||V|),
 * |V| is the number of vertices in the graph.
 *
 * \example examples/simple/igraph_adjacency.c
 */
int igraph_adjacency(igraph_t *graph, const igraph_matrix_t *adjmatrix,
                     igraph_adjacency_t mode) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int no_of_nodes;

    /* Some checks */
    if (igraph_matrix_nrow(adjmatrix) != igraph_matrix_ncol(adjmatrix)) {
        IGRAPH_ERROR("Non-square matrix", IGRAPH_NONSQUARE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    /* Collect the edges */
    no_of_nodes = igraph_matrix_nrow(adjmatrix);
    switch (mode) {
    case IGRAPH_ADJ_DIRECTED:
        IGRAPH_CHECK(igraph_i_adjacency_directed(adjmatrix, &edges));
        break;
    case IGRAPH_ADJ_MAX:
        IGRAPH_CHECK(igraph_i_adjacency_max(adjmatrix, &edges));
        break;
    case IGRAPH_ADJ_UPPER:
        IGRAPH_CHECK(igraph_i_adjacency_upper(adjmatrix, &edges));
        break;
    case IGRAPH_ADJ_LOWER:
        IGRAPH_CHECK(igraph_i_adjacency_lower(adjmatrix, &edges));
        break;
    case IGRAPH_ADJ_MIN:
        IGRAPH_CHECK(igraph_i_adjacency_min(adjmatrix, &edges));
        break;
    case IGRAPH_ADJ_PLUS:
        IGRAPH_CHECK(igraph_i_adjacency_directed(adjmatrix, &edges));
        break;
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               (mode == IGRAPH_ADJ_DIRECTED)));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_weighted_adjacency_directed(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);
static int igraph_i_weighted_adjacency_plus(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);
static int igraph_i_weighted_adjacency_max(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);
static int igraph_i_weighted_adjacency_upper(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);
static int igraph_i_weighted_adjacency_lower(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);
static int igraph_i_weighted_adjacency_min(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops);

static int igraph_i_weighted_adjacency_directed(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j < no_of_nodes; j++) {
            igraph_real_t M = MATRIX(*adjmatrix, i, j);
            if (M == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M));
        }
    }

    return 0;
}

static int igraph_i_weighted_adjacency_plus(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = i; j < no_of_nodes; j++) {
            igraph_real_t M = MATRIX(*adjmatrix, i, j) + MATRIX(*adjmatrix, j, i);
            if (M == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            if (i == j) {
                M /= 2;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M));
        }
    }

    return 0;
}

static int igraph_i_weighted_adjacency_max(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = i; j < no_of_nodes; j++) {
            igraph_real_t M1 = MATRIX(*adjmatrix, i, j);
            igraph_real_t M2 = MATRIX(*adjmatrix, j, i);
            if (M1 < M2) {
                M1 = M2;
            }
            if (M1 == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M1));
        }
    }
    return 0;
}

static int igraph_i_weighted_adjacency_upper(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = i; j < no_of_nodes; j++) {
            igraph_real_t M = MATRIX(*adjmatrix, i, j);
            if (M == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M));
        }
    }
    return 0;
}

static int igraph_i_weighted_adjacency_lower(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j <= i; j++) {
            igraph_real_t M = MATRIX(*adjmatrix, i, j);
            if (M == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M));
        }
    }
    return 0;
}

static int igraph_i_weighted_adjacency_min(
        const igraph_matrix_t *adjmatrix,
        igraph_vector_t *edges,
        igraph_vector_t *weights,
        igraph_bool_t loops) {

    long int no_of_nodes = igraph_matrix_nrow(adjmatrix);
    long int i, j;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = i; j < no_of_nodes; j++) {
            igraph_real_t M1 = MATRIX(*adjmatrix, i, j);
            igraph_real_t M2 = MATRIX(*adjmatrix, j, i);
            if (M1 > M2) {
                M1 = M2;
            }
            if (M1 == 0.0) {
                continue;
            }
            if (i == j && !loops) {
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(edges, j));
            IGRAPH_CHECK(igraph_vector_push_back(weights, M1));
        }
    }

    return 0;
}

/**
 * \ingroup generators
 * \function igraph_weighted_adjacency
 * \brief Creates a graph from a weighted adjacency matrix.
 *
 * The order of the vertices in the matrix is preserved, i.e. the vertex
 * corresponding to the first row/column will be vertex with id 0, the
 * next row is for vertex 1, etc.
 * \param graph Pointer to an uninitialized graph object.
 * \param adjmatrix The weighted adjacency matrix. How it is interpreted
 *        depends on the \p mode argument. The common feature is that
 *        edges with zero weights are considered nonexistent (however,
 *        negative weights are permitted).
 * \param mode Constant to specify how the given matrix is interpreted
 *        as an adjacency matrix. Possible values
 *        (A(i,j)
 *        is the element in row i and column
 *        j in the adjacency matrix
 *        \p adjmatrix):
 *        \clist
 *        \cli IGRAPH_ADJ_DIRECTED
 *          the graph will be directed and
 *          an element gives the weight of the edge between two vertices.
 *        \cli IGRAPH_ADJ_UNDIRECTED
 *          this is the same as \c IGRAPH_ADJ_MAX,
 *          for convenience.
 *        \cli IGRAPH_ADJ_MAX
 *          undirected graph will be created
 *          and the weight of the edge between vertices
 *          i and
 *          j is
 *          max(A(i,j), A(j,i)).
 *        \cli IGRAPH_ADJ_MIN
 *          undirected graph will be created
 *          with edge weight min(A(i,j), A(j,i))
 *          between vertices
 *          i and
 *          j.
 *        \cli IGRAPH_ADJ_PLUS
 *          undirected graph will be created
 *          with edge weight A(i,j)+A(j,i)
 *          between vertices
 *          i and
 *          j.
 *        \cli IGRAPH_ADJ_UPPER
 *          undirected graph will be created,
 *          only the upper right triangle (including the diagonal) is
 *          used for the edge weights.
 *        \cli IGRAPH_ADJ_LOWER
 *          undirected graph will be created,
 *          only the lower left triangle (including the diagonal) is
 *          used for the edge weights.
 *       \endclist
 * \param attr the name of the attribute that will store the edge weights.
 *         If \c NULL , it will use \c weight as the attribute name.
 * \param loops Logical scalar, whether to ignore the diagonal elements
 *         in the adjacency matrix.
 * \return Error code,
 *         \c IGRAPH_NONSQUARE: non-square matrix.
 *
 * Time complexity: O(|V||V|),
 * |V| is the number of vertices in the graph.
 *
 * \example examples/simple/igraph_weighted_adjacency.c
 */
int igraph_weighted_adjacency(igraph_t *graph, const igraph_matrix_t *adjmatrix,
                              igraph_adjacency_t mode, const char* attr,
                              igraph_bool_t loops) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    igraph_vector_t weights = IGRAPH_VECTOR_NULL;
    const char* default_attr = "weight";
    igraph_vector_ptr_t attr_vec;
    igraph_attribute_record_t attr_rec;
    long int no_of_nodes;

    /* Some checks */
    if (igraph_matrix_nrow(adjmatrix) != igraph_matrix_ncol(adjmatrix)) {
        IGRAPH_ERROR("Non-square matrix", IGRAPH_NONSQUARE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&weights, 0);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&attr_vec, 1);

    /* Collect the edges */
    no_of_nodes = igraph_matrix_nrow(adjmatrix);
    switch (mode) {
    case IGRAPH_ADJ_DIRECTED:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_directed(adjmatrix, &edges,
                     &weights, loops));
        break;
    case IGRAPH_ADJ_MAX:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_max(adjmatrix, &edges,
                     &weights, loops));
        break;
    case IGRAPH_ADJ_UPPER:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_upper(adjmatrix, &edges,
                     &weights, loops));
        break;
    case IGRAPH_ADJ_LOWER:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_lower(adjmatrix, &edges,
                     &weights, loops));
        break;
    case IGRAPH_ADJ_MIN:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_min(adjmatrix, &edges,
                     &weights, loops));
        break;
    case IGRAPH_ADJ_PLUS:
        IGRAPH_CHECK(igraph_i_weighted_adjacency_plus(adjmatrix, &edges,
                     &weights, loops));
        break;
    }

    /* Prepare attribute record */
    attr_rec.name = attr ? attr : default_attr;
    attr_rec.type = IGRAPH_ATTRIBUTE_NUMERIC;
    attr_rec.value = &weights;
    VECTOR(attr_vec)[0] = &attr_rec;

    /* Create graph */
    IGRAPH_CHECK(igraph_empty(graph, (igraph_integer_t) no_of_nodes,
                              (mode == IGRAPH_ADJ_DIRECTED)));
    IGRAPH_FINALLY(igraph_destroy, graph);
    if (igraph_vector_size(&edges) > 0) {
        IGRAPH_CHECK(igraph_add_edges(graph, &edges, &attr_vec));
    }
    IGRAPH_FINALLY_CLEAN(1);

    /* Cleanup */
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&weights);
    igraph_vector_ptr_destroy(&attr_vec);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_adjlist
 * \brief Creates a graph from an adjacency list.
 *
 * An adjacency list is a list of vectors, containing the neighbors
 * of all vertices. For operations that involve many changes to the
 * graph structure, it is recommended that you convert the graph into
 * an adjacency list via \ref igraph_adjlist_init(), perform the
 * modifications (these are cheap for an adjacency list) and then
 * recreate the igraph graph via this function.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param adjlist The adjacency list.
 * \param mode Whether or not to create a directed graph. \c IGRAPH_ALL
 *             means an undirected graph, \c IGRAPH_OUT means a
 *             directed graph from an out-adjacency list (i.e. each
 *             list contains the successors of the corresponding
 *             vertices), \c IGRAPH_IN means a directed graph from an
 *             in-adjacency list
 * \param duplicate Logical, for undirected graphs this specified
 *        whether each edge is included twice, in the vectors of
 *        both adjacent vertices. If this is false (0), then it is
 *        assumed that every edge is included only once. This argument
 *        is ignored for directed graphs.
 * \return Error code.
 *
 * \sa \ref igraph_adjlist_init() for the opposite operation.
 *
 * Time complexity: O(|V|+|E|).
 *
 */
int igraph_adjlist(igraph_t *graph, const igraph_adjlist_t *adjlist,
                   igraph_neimode_t mode, igraph_bool_t duplicate) {

    long int no_of_nodes = igraph_adjlist_size(adjlist);
    long int no_of_edges = 0;
    long int i;

    igraph_vector_t edges;
    long int edgeptr = 0;

    duplicate = duplicate && (mode == IGRAPH_ALL); /* only duplicate if undirected */

    for (i = 0; i < no_of_nodes; i++) {
        no_of_edges += igraph_vector_int_size(igraph_adjlist_get(adjlist, i));
    }

    if (duplicate) {
        no_of_edges /= 2;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * no_of_edges);

    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, i);
        long int j, n = igraph_vector_int_size(neis);
        long int loops = 0;

        for (j = 0; j < n; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            if (nei == i) {
                loops++;
            } else {
                if (! duplicate || nei > i) {
                    if (edgeptr + 2 > 2 * no_of_edges) {
                        IGRAPH_ERROR("Invalid adjacency list, most probably not correctly"
                                     " duplicated edges for an undirected graph", IGRAPH_EINVAL);
                    }
                    if (mode == IGRAPH_IN) {
                        VECTOR(edges)[edgeptr++] = nei;
                        VECTOR(edges)[edgeptr++] = i;
                    } else {
                        VECTOR(edges)[edgeptr++] = i;
                        VECTOR(edges)[edgeptr++] = nei;
                    }
                }
            }
        }
        /* loops */
        if (duplicate) {
            loops = loops / 2;
        }
        if (edgeptr + 2 * loops > 2 * no_of_edges) {
            IGRAPH_ERROR("Invalid adjacency list, most probably not correctly"
                         " duplicated edges for an undirected graph", IGRAPH_EINVAL);
        }
        for (j = 0; j < loops; j++) {
            VECTOR(edges)[edgeptr++] = i;
            VECTOR(edges)[edgeptr++] = i;
        }
    }

    if (mode == IGRAPH_ALL)
        IGRAPH_CHECK(igraph_create(graph, &edges,
                                   (igraph_integer_t) no_of_nodes, 0));
    else
        IGRAPH_CHECK(igraph_create(graph, &edges,
                                   (igraph_integer_t) no_of_nodes, 1));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/atlas-edges.h0000644000175100001710000027450300000000000025566 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
    #define __BEGIN_DECLS extern "C" {
    #define __END_DECLS }
#else
    #define __BEGIN_DECLS /* empty */
    #define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

#include "igraph_types.h"

const igraph_real_t igraph_i_atlas_edges[] = {
    0, 0,
    1, 0,
    2, 0,
    2, 1, 0, 1,
    3, 0,
    3, 1, 1, 2,
    3, 2, 0, 1, 0, 2,
    3, 3, 0, 1, 0, 2, 1, 2,
    4, 0,
    4, 1, 3, 2,
    4, 2, 3, 2, 3, 1,
    4, 2, 0, 1, 3, 2,
    4, 3, 3, 2, 1, 2, 3, 1,
    4, 3, 3, 0, 3, 1, 3, 2,
    4, 3, 0, 1, 1, 2, 0, 3,
    4, 4, 3, 2, 1, 2, 3, 1, 3, 0,
    4, 4, 0, 1, 1, 2, 2, 3, 0, 3,
    4, 5, 0, 1, 0, 2, 0, 3, 1, 2, 2, 3,
    4, 6, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2,
    5, 0,
    5, 1, 4, 3,
    5, 2, 1, 2, 0, 1,
    5, 2, 0, 2, 4, 3,
    5, 3, 1, 2, 0, 1, 2, 0,
    5, 3, 4, 3, 3, 2, 3, 1,
    5, 3, 3, 2, 4, 3, 0, 4,
    5, 3, 1, 2, 0, 1, 4, 3,
    5, 4, 4, 3, 1, 2, 3, 1, 3, 2,
    5, 4, 0, 3, 1, 0, 2, 1, 3, 2,
    5, 4, 4, 3, 4, 0, 4, 1, 4, 2,
    5, 4, 4, 0, 3, 1, 4, 3, 3, 2,
    5, 4, 2, 3, 1, 2, 0, 1, 4, 0,
    5, 4, 1, 2, 0, 1, 2, 0, 4, 3,
    5, 5, 0, 3, 2, 0, 3, 2, 1, 0, 2, 1,
    5, 5, 4, 2, 4, 3, 2, 3, 4, 1, 4, 0,
    5, 5, 0, 1, 1, 2, 2, 3, 0, 4, 0, 2,
    5, 5, 4, 0, 1, 2, 4, 3, 3, 2, 3, 1,
    5, 5, 1, 0, 4, 1, 2, 4, 3, 2, 1, 3,
    5, 5, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4,
    5, 6, 1, 0, 4, 1, 4, 0, 0, 3, 1, 3, 3, 4,
    5, 6, 1, 0, 4, 1, 2, 4, 3, 2, 1, 3, 2, 1,
    5, 6, 1, 0, 4, 1, 2, 4, 3, 2, 1, 3, 3, 4,
    5, 6, 0, 1, 4, 3, 2, 3, 4, 2, 4, 0, 4, 1,
    5, 6, 0, 4, 3, 0, 4, 3, 2, 3, 1, 2, 0, 1,
    5, 6, 2, 1, 0, 2, 3, 0, 1, 3, 4, 1, 0, 4,
    5, 7, 4, 0, 1, 2, 4, 3, 3, 2, 3, 1, 4, 1, 2, 4,
    5, 7, 4, 1, 2, 4, 3, 2, 1, 3, 3, 4, 0, 3, 4, 0,
    5, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1,
    5, 7, 2, 1, 0, 2, 3, 0, 1, 3, 4, 1, 0, 4, 2, 4,
    5, 8, 1, 0, 4, 1, 2, 4, 3, 2, 1, 3, 4, 0, 3, 4, 0, 3,
    5, 8, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3,
    5, 9, 0, 1, 3, 4, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4,
    5, 10, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
    6, 0,
    6, 1, 5, 4,
    6, 2, 0, 3, 5, 4,
    6, 2, 1, 3, 1, 2,
    6, 3, 1, 3, 2, 1, 3, 2,
    6, 3, 0, 3, 5, 0, 4, 0,
    6, 3, 4, 3, 5, 4, 0, 5,
    6, 3, 4, 3, 5, 1, 5, 2,
    6, 3, 1, 2, 3, 0, 5, 4,
    6, 4, 0, 3, 4, 0, 5, 4, 0, 5,
    6, 4, 3, 0, 5, 3, 4, 5, 0, 4,
    6, 4, 5, 1, 5, 3, 5, 2, 0, 5,
    6, 4, 4, 3, 3, 1, 4, 0, 3, 2,
    6, 4, 0, 2, 1, 3, 2, 1, 5, 3,
    6, 4, 1, 3, 2, 1, 3, 2, 0, 5,
    6, 4, 1, 2, 0, 3, 5, 0, 4, 0,
    6, 4, 4, 5, 1, 2, 0, 5, 3, 4,
    6, 4, 0, 2, 4, 0, 3, 1, 5, 3,
    6, 5, 3, 0, 5, 3, 4, 5, 0, 4, 5, 0,
    6, 5, 5, 3, 3, 1, 3, 2, 4, 3, 4, 5,
    6, 5, 5, 3, 5, 4, 2, 3, 3, 4, 0, 4,
    6, 5, 4, 3, 1, 2, 4, 0, 3, 2, 3, 1,
    6, 5, 1, 4, 3, 4, 4, 0, 2, 1, 3, 2,
    6, 5, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4,
    6, 5, 5, 3, 5, 4, 5, 0, 5, 1, 5, 2,
    6, 5, 1, 4, 5, 1, 1, 0, 2, 1, 2, 3,
    6, 5, 0, 1, 3, 4, 0, 2, 3, 0, 5, 3,
    6, 5, 1, 0, 2, 1, 2, 4, 1, 3, 5, 3,
    6, 5, 4, 3, 0, 5, 4, 0, 3, 2, 3, 1,
    6, 5, 1, 2, 0, 1, 4, 5, 1, 3, 2, 3,
    6, 5, 0, 1, 0, 5, 2, 3, 3, 4, 4, 5,
    6, 5, 4, 3, 5, 1, 5, 2, 0, 3, 4, 0,
    6, 5, 1, 2, 3, 0, 5, 3, 4, 5, 0, 4,
    6, 6, 0, 3, 5, 0, 4, 5, 3, 4, 5, 3, 4, 0,
    6, 6, 1, 4, 2, 4, 4, 0, 2, 3, 3, 1, 3, 4,
    6, 6, 1, 4, 2, 4, 4, 0, 2, 1, 3, 1, 2, 3,
    6, 6, 2, 0, 5, 4, 4, 3, 5, 3, 4, 0, 2, 4,
    6, 6, 3, 2, 4, 3, 0, 4, 1, 0, 2, 1, 0, 3,
    6, 6, 4, 1, 3, 1, 4, 2, 3, 2, 2, 0, 1, 0,
    6, 6, 5, 2, 5, 3, 5, 4, 3, 4, 5, 1, 5, 0,
    6, 6, 4, 3, 4, 2, 4, 0, 1, 4, 3, 0, 5, 3,
    6, 6, 4, 3, 3, 5, 5, 4, 5, 1, 3, 2, 4, 0,
    6, 6, 4, 2, 1, 2, 4, 3, 4, 1, 4, 0, 0, 5,
    6, 6, 1, 2, 3, 1, 0, 3, 2, 0, 4, 0, 5, 0,
    6, 6, 2, 0, 4, 2, 1, 4, 2, 1, 3, 1, 5, 3,
    6, 6, 1, 2, 3, 1, 0, 3, 2, 0, 4, 0, 5, 3,
    6, 6, 5, 3, 2, 5, 2, 0, 4, 2, 4, 3, 3, 1,
    6, 6, 0, 2, 3, 4, 1, 0, 5, 3, 4, 5, 3, 0,
    6, 6, 1, 2, 3, 0, 5, 3, 4, 5, 0, 4, 5, 0,
    6, 6, 4, 3, 1, 2, 4, 0, 3, 2, 3, 1, 5, 0,
    6, 6, 1, 4, 2, 4, 4, 0, 0, 5, 3, 1, 2, 3,
    6, 6, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5,
    6, 6, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5,
    6, 6, 1, 3, 2, 1, 3, 2, 0, 4, 5, 0, 4, 5,
    6, 7, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 0, 5,
    6, 7, 1, 4, 2, 4, 2, 1, 3, 1, 2, 3, 2, 0, 0, 1,
    6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1,
    6, 7, 0, 1, 3, 2, 0, 2, 3, 0, 3, 1, 5, 1, 5, 2,
    6, 7, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 3, 4,
    6, 7, 1, 0, 4, 1, 2, 4, 3, 2, 5, 1, 2, 5, 1, 2,
    6, 7, 0, 4, 2, 0, 1, 2, 3, 1, 5, 3, 3, 0, 2, 3,
    6, 7, 1, 4, 2, 4, 2, 3, 2, 1, 3, 1, 4, 5, 0, 4,
    6, 7, 1, 0, 4, 1, 2, 4, 3, 2, 5, 1, 2, 5, 4, 5,
    6, 7, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4,
    6, 7, 0, 5, 4, 0, 5, 4, 0, 2, 3, 0, 3, 2, 0, 1,
    6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5, 4, 1,
    6, 7, 0, 1, 4, 0, 1, 4, 0, 2, 3, 0, 3, 2, 3, 5,
    6, 7, 1, 4, 2, 4, 4, 0, 0, 5, 3, 1, 2, 3, 3, 4,
    6, 7, 2, 0, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1,
    6, 7, 1, 5, 0, 1, 4, 0, 3, 4, 2, 3, 1, 2, 0, 3,
    6, 7, 1, 4, 2, 4, 4, 0, 0, 5, 3, 1, 2, 3, 2, 1,
    6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 0, 2, 5, 1,
    6, 7, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3,
    6, 7, 5, 0, 3, 5, 2, 3, 0, 2, 1, 3, 4, 1, 3, 4,
    6, 7, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 2, 3,
    6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3,
    6, 7, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3,
    6, 7, 1, 2, 0, 1, 2, 0, 3, 0, 4, 3, 5, 4, 3, 5,
    6, 8, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3,
    6, 8, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 0, 0, 4,
    6, 8, 1, 2, 3, 1, 0, 3, 1, 0, 2, 0, 3, 2, 5, 3, 4, 0,
    6, 8, 0, 1, 2, 4, 0, 2, 5, 2, 3, 1, 3, 2, 2, 1, 4, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 1, 5,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4,
    6, 8, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 2, 1, 5, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0,
    6, 8, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 3, 0, 5, 1,
    6, 8, 2, 0, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1, 5, 3,
    6, 8, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 0, 5, 5, 4,
    6, 8, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 5, 1, 5, 3,
    6, 8, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 3, 4,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 2, 0, 2,
    6, 8, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2,
    6, 8, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 1, 4, 0, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0,
    6, 8, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 2, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 5, 5, 3, 1, 5,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 1,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5, 5, 2, 5, 0,
    6, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 1, 5, 2,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3,
    6, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 2,
    6, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4,
    6, 9, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 4, 5,
    6, 9, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 4, 3,
    6, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 5,
    6, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0,
    6, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 0, 4, 1, 0, 4, 1,
    6, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1,
    6, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4, 4, 0, 5, 0,
    6, 9, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5,
    6, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0,
    6, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1,
    6, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 2, 0,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2,
    6, 9, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2,
    6, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 5, 2, 4, 1,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 4, 5,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 5,
    6, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 1, 0,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5,
    6, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 2, 4,
    6, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2,
    6, 10, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2,
    6, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1,
    6, 10, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4,
    6, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 0, 2, 1, 3, 5, 1,
    6, 10, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 3, 2, 0, 3,
    6, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0,
    6, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2, 1, 5,
    6, 11, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3,
    6, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5,
    6, 11, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 0, 2,
    6, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0, 5, 1,
    6, 11, 1, 3, 4, 1, 3, 4, 2, 3, 0, 2, 4, 0, 5, 4, 2, 5, 4, 2, 0, 5, 1, 5,
    6, 11, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1,
    6, 11, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2,
    6, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 0, 3,
    6, 12, 0, 1, 1, 2, 0, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 4, 3,
    6, 12, 3, 2, 1, 3, 2, 1, 0, 2, 5, 0, 2, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 0, 4,
    6, 12, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 4, 5,
    6, 12, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 2, 3,
    6, 12, 0, 1, 1, 2, 0, 2, 3, 2, 3, 1, 4, 0, 2, 4, 5, 1, 0, 5, 4, 5, 3, 4, 5, 3,
    6, 13, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 2, 3, 0, 4,
    6, 13, 0, 1, 1, 2, 0, 2, 3, 2, 3, 1, 4, 0, 2, 4, 5, 1, 0, 5, 4, 5, 3, 4, 5, 3, 3, 0,
    6, 14, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 1, 3, 2, 0, 4, 0, 5, 3,
    6, 15, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5,
    7, 0,
    7, 1, 6, 5,
    7, 2, 2, 3, 1, 2,
    7, 2, 5, 4, 6, 0,
    7, 3, 0, 4, 4, 2, 2, 0,
    7, 3, 0, 1, 0, 6, 0, 5,
    7, 3, 5, 4, 6, 0, 5, 6,
    7, 3, 3, 2, 1, 2, 5, 6,
    7, 3, 3, 1, 5, 6, 0, 4,
    7, 4, 2, 5, 6, 2, 5, 6, 1, 2,
    7, 4, 1, 2, 4, 1, 5, 4, 2, 5,
    7, 4, 1, 0, 5, 1, 1, 2, 4, 1,
    7, 4, 1, 0, 2, 1, 5, 2, 6, 2,
    7, 4, 3, 4, 2, 3, 1, 2, 0, 1,
    7, 4, 4, 2, 0, 4, 2, 0, 5, 6,
    7, 4, 0, 1, 6, 0, 0, 5, 4, 2,
    7, 4, 3, 1, 5, 4, 6, 5, 0, 6,
    7, 4, 0, 4, 3, 0, 2, 5, 6, 2,
    7, 4, 2, 3, 1, 2, 6, 0, 5, 4,
    7, 5, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0,
    7, 5, 2, 5, 6, 2, 5, 6, 4, 2, 3, 2,
    7, 5, 4, 2, 4, 0, 2, 0, 5, 4, 6, 0,
    7, 5, 2, 5, 6, 2, 5, 6, 1, 2, 0, 1,
    7, 5, 4, 1, 0, 4, 3, 0, 1, 3, 2, 1,
    7, 5, 1, 2, 0, 1, 4, 0, 3, 4, 2, 3,
    7, 5, 5, 1, 5, 0, 2, 5, 3, 5, 4, 5,
    7, 5, 1, 5, 6, 1, 1, 0, 2, 1, 3, 2,
    7, 5, 1, 5, 4, 1, 2, 3, 6, 2, 2, 1,
    7, 5, 1, 5, 6, 1, 1, 2, 2, 3, 4, 3,
    7, 5, 2, 1, 3, 2, 4, 3, 5, 4, 3, 6,
    7, 5, 6, 5, 2, 6, 1, 2, 5, 2, 3, 4,
    7, 5, 4, 3, 5, 4, 6, 5, 0, 6, 1, 0,
    7, 5, 0, 4, 3, 0, 2, 5, 6, 2, 5, 6,
    7, 5, 4, 1, 5, 2, 6, 5, 3, 6, 2, 3,
    7, 5, 1, 4, 3, 1, 1, 0, 2, 1, 6, 5,
    7, 5, 0, 4, 3, 0, 1, 0, 2, 1, 6, 5,
    7, 5, 0, 4, 3, 0, 2, 1, 5, 2, 6, 2,
    7, 5, 6, 5, 3, 4, 2, 3, 1, 2, 0, 1,
    7, 5, 2, 3, 1, 2, 6, 0, 5, 6, 5, 4,
    7, 5, 0, 1, 4, 6, 5, 4, 3, 2, 6, 5,
    7, 6, 1, 5, 6, 1, 5, 6, 2, 5, 1, 2, 6, 2,
    7, 6, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1,
    7, 6, 0, 4, 3, 0, 1, 3, 2, 1, 1, 4, 3, 4,
    7, 6, 5, 2, 4, 5, 2, 4, 3, 2, 6, 3, 2, 6,
    7, 6, 1, 2, 4, 1, 5, 4, 2, 5, 0, 1, 4, 0,
    7, 6, 1, 2, 5, 1, 4, 5, 2, 4, 0, 2, 5, 0,
    7, 6, 2, 5, 6, 2, 5, 6, 2, 4, 1, 2, 3, 2,
    7, 6, 1, 4, 3, 1, 2, 3, 1, 2, 2, 5, 6, 2,
    7, 6, 5, 4, 6, 5, 1, 6, 5, 1, 3, 6, 0, 1,
    7, 6, 6, 5, 1, 6, 5, 1, 3, 1, 0, 3, 1, 4,
    7, 6, 0, 4, 3, 0, 2, 3, 4, 2, 2, 5, 6, 2,
    7, 6, 1, 4, 3, 1, 2, 3, 1, 2, 2, 5, 6, 5,
    7, 6, 2, 3, 1, 2, 3, 6, 5, 4, 6, 5, 5, 2,
    7, 6, 2, 5, 6, 2, 5, 6, 1, 4, 3, 1, 2, 1,
    7, 6, 4, 5, 0, 4, 3, 0, 2, 3, 4, 2, 6, 3,
    7, 6, 0, 4, 3, 0, 1, 3, 6, 5, 1, 4, 1, 0,
    7, 6, 1, 4, 3, 1, 2, 3, 5, 2, 6, 5, 2, 6,
    7, 6, 6, 3, 5, 6, 4, 5, 1, 4, 2, 1, 5, 2,
    7, 6, 1, 0, 3, 1, 6, 3, 5, 6, 4, 5, 1, 4,
    7, 6, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5,
    7, 6, 0, 4, 3, 0, 4, 3, 2, 5, 6, 2, 5, 6,
    7, 6, 6, 3, 0, 6, 6, 2, 5, 6, 6, 1, 4, 6,
    7, 6, 2, 4, 5, 2, 2, 3, 6, 2, 1, 2, 1, 0,
    7, 6, 1, 0, 2, 1, 5, 2, 1, 4, 3, 1, 6, 2,
    7, 6, 1, 0, 2, 1, 3, 6, 1, 3, 4, 1, 5, 4,
    7, 6, 1, 0, 2, 1, 5, 2, 6, 5, 1, 4, 3, 1,
    7, 6, 1, 0, 2, 4, 5, 2, 6, 5, 2, 6, 3, 2,
    7, 6, 4, 0, 1, 4, 3, 1, 2, 1, 5, 2, 6, 2,
    7, 6, 6, 5, 1, 2, 0, 1, 2, 0, 3, 2, 0, 4,
    7, 6, 0, 4, 3, 0, 1, 0, 2, 1, 5, 2, 6, 2,
    7, 6, 1, 0, 3, 1, 6, 3, 2, 6, 4, 1, 5, 4,
    7, 6, 2, 5, 6, 2, 4, 2, 1, 4, 3, 1, 0, 3,
    7, 6, 0, 4, 3, 0, 2, 3, 4, 2, 1, 2, 6, 5,
    7, 6, 0, 4, 3, 0, 2, 1, 5, 2, 6, 5, 2, 6,
    7, 6, 3, 4, 1, 0, 2, 1, 5, 2, 6, 5, 2, 6,
    7, 6, 4, 5, 0, 4, 3, 0, 6, 3, 1, 0, 2, 1,
    7, 6, 2, 5, 6, 2, 5, 6, 1, 4, 3, 1, 1, 0,
    7, 6, 4, 5, 3, 4, 2, 3, 1, 2, 0, 1, 6, 0,
    7, 6, 6, 4, 5, 6, 4, 5, 2, 3, 1, 2, 0, 1,
    7, 6, 0, 1, 4, 0, 2, 3, 5, 2, 6, 5, 3, 6,
    7, 6, 1, 2, 0, 1, 4, 0, 3, 4, 2, 3, 6, 5,
    7, 7, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 3, 4,
    7, 7, 1, 2, 5, 1, 4, 5, 2, 4, 0, 2, 5, 0, 5, 2,
    7, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1,
    7, 7, 1, 2, 5, 1, 4, 5, 2, 4, 0, 2, 5, 0, 1, 0,
    7, 7, 0, 4, 3, 0, 2, 3, 4, 2, 2, 5, 6, 2, 2, 0,
    7, 7, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 2, 6,
    7, 7, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 3, 4, 6, 3,
    7, 7, 0, 4, 3, 0, 2, 3, 4, 2, 2, 5, 6, 2, 3, 4,
    7, 7, 0, 4, 3, 0, 1, 3, 3, 6, 1, 4, 1, 0, 5, 4,
    7, 7, 0, 4, 3, 0, 1, 3, 6, 5, 1, 4, 1, 0, 3, 4,
    7, 7, 5, 2, 4, 5, 2, 4, 3, 2, 6, 3, 2, 6, 2, 1,
    7, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 0, 2, 2, 5,
    7, 7, 5, 2, 4, 5, 2, 4, 3, 2, 6, 3, 2, 6, 3, 1,
    7, 7, 1, 4, 3, 1, 2, 3, 4, 2, 2, 0, 2, 1, 6, 0,
    7, 7, 1, 2, 5, 1, 4, 5, 2, 4, 0, 2, 5, 0, 3, 5,
    7, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 0, 2, 3, 5,
    7, 7, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 0, 2, 1, 5,
    7, 7, 3, 2, 4, 3, 3, 5, 2, 4, 5, 2, 6, 1, 6, 4,
    7, 7, 1, 2, 5, 1, 4, 5, 2, 4, 0, 2, 5, 0, 0, 3,
    7, 7, 3, 4, 1, 3, 2, 1, 6, 2, 5, 6, 1, 5, 4, 1,
    7, 7, 0, 1, 4, 0, 1, 4, 2, 1, 3, 2, 5, 3, 4, 5,
    7, 7, 6, 3, 5, 6, 1, 5, 2, 1, 3, 2, 4, 2, 5, 4,
    7, 7, 1, 2, 4, 1, 5, 4, 6, 5, 3, 6, 2, 3, 5, 2,
    7, 7, 4, 1, 3, 4, 1, 3, 2, 1, 6, 2, 5, 6, 2, 5,
    7, 7, 3, 0, 6, 3, 0, 6, 1, 0, 0, 2, 5, 0, 0, 4,
    7, 7, 1, 5, 6, 1, 1, 2, 3, 1, 4, 3, 1, 4, 4, 0,
    7, 7, 5, 0, 6, 5, 0, 6, 5, 2, 1, 5, 6, 3, 4, 6,
    7, 7, 4, 1, 0, 4, 1, 0, 2, 1, 0, 3, 6, 0, 4, 5,
    7, 7, 5, 2, 6, 5, 2, 6, 2, 4, 3, 2, 1, 0, 2, 1,
    7, 7, 4, 1, 0, 4, 3, 0, 1, 3, 2, 1, 1, 5, 6, 1,
    7, 7, 1, 0, 4, 1, 0, 4, 5, 4, 2, 1, 3, 2, 6, 1,
    7, 7, 0, 1, 4, 0, 1, 4, 2, 1, 3, 2, 5, 4, 6, 4,
    7, 7, 2, 3, 5, 2, 6, 5, 3, 6, 1, 2, 4, 5, 0, 5,
    7, 7, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 2, 1, 6, 5,
    7, 7, 2, 5, 6, 2, 5, 6, 4, 2, 1, 2, 0, 1, 3, 1,
    7, 7, 2, 5, 6, 2, 4, 2, 1, 4, 3, 1, 2, 3, 0, 1,
    7, 7, 6, 2, 5, 6, 2, 5, 1, 2, 0, 1, 4, 1, 3, 1,
    7, 7, 0, 4, 3, 0, 1, 3, 4, 1, 5, 4, 2, 1, 6, 3,
    7, 7, 2, 5, 6, 2, 5, 6, 4, 5, 3, 6, 1, 2, 0, 1,
    7, 7, 2, 5, 6, 2, 1, 4, 1, 2, 0, 1, 4, 0, 0, 3,
    7, 7, 6, 5, 1, 2, 4, 1, 0, 4, 3, 0, 1, 3, 3, 4,
    7, 7, 4, 1, 0, 4, 1, 0, 3, 6, 2, 3, 0, 2, 5, 0,
    7, 7, 4, 1, 0, 4, 3, 0, 1, 3, 2, 1, 5, 2, 6, 1,
    7, 7, 4, 1, 0, 4, 1, 0, 2, 3, 0, 2, 5, 0, 6, 5,
    7, 7, 0, 1, 5, 0, 6, 5, 3, 6, 2, 3, 0, 2, 4, 0,
    7, 7, 1, 0, 4, 1, 2, 4, 3, 2, 4, 3, 0, 4, 6, 5,
    7, 7, 3, 6, 2, 3, 1, 2, 0, 1, 4, 0, 1, 4, 5, 4,
    7, 7, 1, 0, 5, 1, 6, 5, 2, 6, 1, 2, 3, 2, 4, 3,
    7, 7, 2, 3, 1, 2, 0, 1, 4, 0, 5, 4, 6, 5, 4, 1,
    7, 7, 5, 2, 6, 5, 2, 6, 1, 2, 4, 1, 0, 4, 3, 1,
    7, 7, 2, 3, 1, 2, 0, 1, 4, 0, 5, 4, 6, 5, 5, 2,
    7, 7, 1, 4, 0, 1, 2, 0, 3, 2, 5, 3, 0, 5, 6, 3,
    7, 7, 2, 1, 3, 2, 6, 3, 5, 6, 0, 5, 2, 0, 5, 4,
    7, 7, 5, 2, 6, 5, 2, 6, 1, 2, 0, 1, 4, 0, 3, 0,
    7, 7, 4, 1, 0, 4, 3, 0, 1, 3, 2, 1, 5, 2, 6, 2,
    7, 7, 1, 0, 2, 1, 5, 2, 4, 5, 0, 4, 4, 1, 6, 3,
    7, 7, 2, 5, 6, 2, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0,
    7, 7, 6, 5, 0, 4, 3, 0, 1, 3, 4, 1, 2, 4, 3, 2,
    7, 7, 2, 1, 5, 2, 4, 5, 0, 4, 3, 0, 6, 3, 2, 6,
    7, 7, 4, 0, 3, 4, 1, 3, 2, 1, 5, 2, 6, 5, 2, 6,
    7, 7, 6, 5, 2, 6, 1, 2, 4, 1, 0, 4, 3, 0, 1, 3,
    7, 7, 4, 1, 0, 4, 2, 0, 3, 2, 6, 3, 5, 6, 0, 5,
    7, 7, 0, 4, 3, 0, 4, 3, 2, 1, 5, 2, 6, 5, 2, 6,
    7, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 6,
    7, 7, 1, 0, 4, 1, 0, 4, 5, 2, 6, 5, 3, 6, 2, 3,
    7, 8, 0, 1, 4, 0, 5, 4, 2, 5, 1, 2, 5, 1, 4, 1, 2, 4,
    7, 8, 4, 1, 5, 4, 2, 5, 1, 2, 0, 1, 5, 0, 0, 4, 2, 0,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 3, 4, 5, 1, 6, 1,
    7, 8, 4, 1, 5, 4, 2, 5, 1, 2, 5, 1, 6, 5, 2, 4, 3, 2,
    7, 8, 1, 3, 0, 1, 4, 0, 2, 4, 1, 2, 4, 1, 5, 4, 1, 5,
    7, 8, 2, 0, 3, 2, 6, 3, 5, 6, 0, 5, 3, 0, 0, 6, 4, 0,
    7, 8, 1, 0, 2, 1, 5, 2, 4, 5, 0, 4, 2, 0, 5, 0, 6, 5,
    7, 8, 1, 0, 2, 1, 3, 2, 1, 3, 4, 3, 2, 4, 5, 2, 3, 5,
    7, 8, 2, 0, 3, 2, 6, 3, 5, 6, 0, 5, 3, 0, 6, 0, 4, 5,
    7, 8, 1, 0, 2, 1, 4, 3, 1, 5, 4, 1, 2, 4, 5, 2, 3, 5,
    7, 8, 3, 5, 2, 1, 4, 3, 1, 5, 4, 1, 2, 4, 5, 2, 4, 6,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 3, 4, 2, 1, 5, 2,
    7, 8, 3, 5, 2, 1, 4, 3, 1, 5, 4, 1, 2, 4, 5, 2, 0, 3,
    7, 8, 4, 0, 2, 4, 0, 2, 3, 0, 2, 3, 5, 2, 6, 5, 2, 6,
    7, 8, 3, 2, 6, 3, 5, 6, 2, 5, 0, 2, 5, 0, 4, 5, 2, 4,
    7, 8, 0, 5, 4, 0, 2, 4, 5, 2, 1, 5, 4, 1, 3, 4, 5, 3,
    7, 8, 2, 3, 1, 2, 4, 1, 5, 4, 1, 5, 5, 2, 6, 5, 3, 6,
    7, 8, 5, 2, 4, 5, 0, 4, 3, 0, 6, 3, 2, 6, 4, 2, 3, 2,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 2, 4, 3, 2, 5, 4, 2, 5,
    7, 8, 5, 6, 2, 5, 6, 2, 3, 2, 4, 3, 0, 4, 3, 0, 2, 4,
    7, 8, 1, 0, 5, 0, 3, 2, 1, 3, 5, 2, 6, 1, 6, 2, 6, 5,
    7, 8, 5, 4, 6, 5, 3, 6, 0, 3, 4, 0, 2, 4, 3, 2, 0, 2,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 2, 1, 5,
    7, 8, 5, 0, 6, 2, 0, 6, 1, 0, 2, 1, 5, 2, 4, 5, 4, 6,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 2, 1, 1, 5, 6, 1,
    7, 8, 0, 2, 4, 0, 1, 4, 0, 1, 3, 0, 1, 3, 5, 1, 6, 1,
    7, 8, 4, 2, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 1, 5, 6, 1,
    7, 8, 0, 4, 3, 0, 4, 3, 1, 4, 3, 1, 1, 5, 2, 1, 6, 1,
    7, 8, 2, 1, 0, 2, 3, 0, 5, 3, 2, 5, 3, 2, 4, 3, 6, 5,
    7, 8, 4, 2, 0, 4, 3, 0, 1, 3, 4, 1, 3, 4, 1, 5, 6, 1,
    7, 8, 2, 1, 0, 2, 3, 0, 5, 3, 2, 5, 6, 5, 4, 3, 5, 0,
    7, 8, 1, 0, 2, 1, 3, 2, 1, 3, 4, 2, 3, 4, 4, 5, 6, 4,
    7, 8, 6, 5, 1, 2, 4, 1, 0, 4, 3, 0, 1, 3, 0, 1, 3, 4,
    7, 8, 0, 1, 6, 5, 2, 3, 6, 4, 6, 3, 6, 2, 6, 0, 6, 1,
    7, 8, 6, 4, 1, 2, 2, 3, 6, 5, 4, 5, 6, 2, 6, 0, 6, 1,
    7, 8, 0, 1, 1, 2, 2, 3, 6, 5, 6, 4, 6, 3, 6, 0, 6, 2,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 6, 1, 5, 1, 2, 5,
    7, 8, 3, 0, 2, 3, 4, 2, 0, 4, 1, 0, 2, 1, 5, 2, 6, 2,
    7, 8, 2, 1, 3, 2, 6, 3, 5, 6, 0, 5, 2, 0, 5, 2, 4, 5,
    7, 8, 1, 0, 2, 1, 3, 2, 4, 3, 5, 2, 1, 5, 6, 1, 2, 6,
    7, 8, 2, 5, 4, 2, 1, 4, 3, 1, 0, 3, 1, 0, 2, 1, 6, 2,
    7, 8, 4, 5, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 6, 3,
    7, 8, 0, 1, 4, 0, 1, 4, 2, 1, 4, 2, 5, 4, 1, 5, 6, 3,
    7, 8, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 1, 6, 5, 0,
    7, 8, 4, 5, 0, 4, 1, 0, 4, 1, 3, 0, 1, 3, 6, 1, 2, 6,
    7, 8, 2, 5, 4, 2, 0, 4, 1, 0, 4, 1, 3, 0, 1, 3, 6, 1,
    7, 8, 1, 6, 2, 1, 0, 2, 1, 0, 4, 1, 3, 4, 2, 3, 4, 5,
    7, 8, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 1, 6, 5, 3,
    7, 8, 0, 4, 3, 0, 4, 3, 1, 4, 3, 1, 5, 1, 6, 2, 1, 6,
    7, 8, 2, 3, 1, 2, 0, 1, 5, 0, 4, 5, 0, 4, 2, 0, 6, 5,
    7, 8, 4, 5, 0, 4, 3, 0, 1, 3, 4, 1, 2, 4, 3, 2, 6, 2,
    7, 8, 2, 3, 1, 2, 0, 1, 4, 0, 5, 4, 4, 1, 2, 6, 5, 2,
    7, 8, 0, 1, 1, 2, 2, 3, 6, 3, 4, 5, 6, 2, 6, 0, 6, 1,
    7, 8, 4, 1, 0, 4, 3, 0, 1, 3, 0, 1, 2, 1, 5, 2, 6, 2,
    7, 8, 0, 1, 1, 2, 2, 3, 6, 5, 4, 5, 6, 2, 6, 4, 6, 1,
    7, 8, 0, 1, 4, 0, 0, 2, 5, 0, 6, 5, 3, 6, 2, 3, 5, 2,
    7, 8, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 2, 5, 6, 2,
    7, 8, 4, 5, 3, 4, 1, 3, 2, 1, 6, 2, 4, 6, 3, 2, 0, 1,
    7, 8, 1, 0, 2, 6, 3, 2, 4, 3, 5, 2, 1, 5, 6, 1, 6, 5,
    7, 8, 2, 3, 1, 2, 0, 1, 4, 0, 5, 4, 6, 5, 5, 2, 4, 1,
    7, 8, 4, 1, 0, 4, 3, 0, 1, 3, 3, 4, 2, 1, 2, 5, 6, 2,
    7, 8, 0, 6, 4, 0, 1, 4, 3, 1, 0, 3, 2, 4, 3, 2, 5, 2,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 2, 4, 3, 2, 1, 0, 6, 5,
    7, 8, 0, 1, 4, 0, 3, 2, 6, 3, 5, 6, 2, 5, 6, 2, 3, 5,
    7, 8, 5, 2, 6, 5, 2, 6, 4, 2, 0, 4, 3, 0, 2, 3, 1, 2,
    7, 8, 2, 0, 1, 2, 0, 1, 5, 0, 4, 5, 0, 4, 6, 0, 3, 6,
    7, 8, 0, 1, 2, 0, 3, 2, 2, 1, 1, 4, 5, 4, 5, 3, 1, 6,
    7, 8, 1, 6, 2, 1, 0, 2, 1, 0, 4, 1, 3, 4, 2, 3, 5, 6,
    7, 8, 6, 1, 0, 6, 1, 0, 5, 1, 0, 5, 2, 1, 3, 2, 4, 3,
    7, 8, 6, 5, 2, 6, 1, 2, 4, 1, 3, 4, 0, 3, 4, 0, 2, 4,
    7, 8, 1, 6, 0, 1, 5, 0, 1, 5, 3, 0, 4, 3, 2, 4, 0, 2,
    7, 8, 2, 6, 4, 2, 0, 4, 1, 0, 4, 1, 3, 4, 5, 3, 2, 5,
    7, 8, 1, 0, 2, 1, 6, 2, 5, 6, 1, 5, 4, 1, 3, 4, 2, 3,
    7, 8, 6, 1, 4, 3, 1, 0, 5, 1, 3, 2, 2, 1, 4, 6, 5, 4,
    7, 8, 4, 2, 0, 4, 1, 0, 4, 1, 3, 4, 6, 3, 5, 6, 3, 5,
    7, 8, 4, 1, 2, 4, 0, 2, 6, 0, 3, 6, 0, 3, 5, 0, 4, 5,
    7, 8, 5, 6, 4, 5, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1,
    7, 8, 6, 3, 5, 6, 4, 5, 0, 4, 1, 0, 2, 1, 5, 2, 4, 1,
    7, 8, 0, 1, 2, 0, 3, 2, 2, 1, 1, 4, 5, 4, 5, 3, 4, 6,
    7, 8, 4, 0, 3, 4, 2, 3, 6, 2, 5, 6, 1, 5, 4, 1, 2, 1,
    7, 8, 6, 1, 0, 6, 4, 3, 5, 1, 0, 5, 2, 1, 3, 2, 5, 6,
    7, 8, 6, 2, 5, 6, 3, 5, 6, 3, 4, 3, 0, 4, 1, 0, 4, 1,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 6, 5, 1,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 6, 4, 2,
    7, 8, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 6, 0, 5,
    7, 8, 4, 0, 2, 4, 3, 2, 6, 3, 5, 6, 4, 5, 1, 2, 5, 1,
    7, 8, 5, 1, 2, 4, 3, 2, 0, 3, 5, 0, 4, 5, 1, 2, 0, 6,
    7, 8, 5, 6, 2, 5, 4, 2, 0, 4, 3, 0, 2, 3, 1, 4, 3, 1,
    7, 8, 0, 4, 1, 0, 4, 1, 3, 4, 5, 3, 6, 5, 2, 6, 4, 2,
    7, 8, 0, 1, 6, 5, 2, 3, 3, 4, 6, 4, 0, 5, 6, 2, 6, 1,
    7, 8, 1, 2, 0, 1, 4, 0, 5, 4, 2, 5, 3, 2, 6, 3, 5, 6,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 6, 1, 6,
    7, 8, 6, 2, 5, 6, 2, 5, 1, 2, 4, 1, 0, 4, 3, 0, 1, 3,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 5, 6, 1,
    7, 8, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 3,
    7, 8, 0, 4, 1, 0, 3, 2, 1, 4, 2, 5, 5, 3, 6, 4, 6, 3,
    7, 8, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 6, 2, 5, 6, 2, 5,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3,
    7, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 2,
    7, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 4, 5,
    7, 9, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 4, 3,
    7, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 5,
    7, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 0, 4, 1, 0, 4, 1,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4, 4, 0, 5, 0,
    7, 9, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1,
    7, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 2, 0,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2,
    7, 9, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 5, 2, 4, 1,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 0, 0, 4, 0, 6,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 0, 0, 4, 2, 6,
    7, 9, 1, 2, 3, 1, 0, 3, 1, 0, 2, 0, 3, 2, 5, 3, 4, 0, 1, 6,
    7, 9, 0, 1, 2, 4, 0, 2, 3, 1, 3, 2, 2, 1, 4, 1, 5, 2, 2, 6,
    7, 9, 0, 1, 2, 4, 0, 2, 5, 2, 3, 1, 3, 2, 2, 1, 4, 1, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 1, 5, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 1, 5, 4, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 2, 1, 5, 1, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0, 1, 6,
    7, 9, 2, 0, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1, 5, 3, 2, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 3, 0, 5, 1, 0, 6,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 0, 0, 4, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 2, 6,
    7, 9, 2, 0, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1, 5, 3, 5, 6,
    7, 9, 1, 2, 3, 1, 0, 3, 1, 0, 2, 0, 3, 2, 4, 0, 6, 5, 6, 3,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0, 0, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 6, 5, 4, 0, 3, 2, 4,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 2, 1, 5, 1, 5, 6,
    7, 9, 2, 0, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1, 5, 3, 4, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0, 2, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 3, 0, 5, 1, 5, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 5, 4, 3, 1, 3, 2, 3, 0, 5, 1, 2, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 4, 0, 3, 1, 3, 2, 5, 1, 5, 3, 0, 6,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 0, 5, 5, 4, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 3, 4, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 2, 0, 2, 0, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 3, 4, 3, 6,
    7, 9, 0, 1, 2, 4, 0, 2, 5, 2, 3, 1, 3, 2, 2, 1, 4, 1, 5, 6,
    7, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 2, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 6, 5, 6, 1,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 3, 4, 2, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 3, 4, 0, 6,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 3, 6, 1, 6, 0, 1, 1, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 0, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 2, 1, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 5, 6,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 3, 6, 1, 6, 0, 1, 0, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 2, 0, 2, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 2, 0, 2, 4, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 2, 1, 2, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 3, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 2, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 5, 1, 3, 1, 3, 2, 2, 1, 6, 0, 6, 4,
    7, 9, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 0, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 0, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 3, 6,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 3, 6, 1, 6, 0, 1, 2, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 5, 5, 3, 1, 5, 3, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 1, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 1, 4, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 5, 1, 3, 1, 3, 2, 3, 0, 6, 4, 6, 0,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5, 5, 2, 5, 0, 1, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 2, 1, 6, 0,
    7, 9, 5, 3, 3, 2, 4, 3, 5, 4, 2, 5, 1, 2, 4, 1, 6, 0, 6, 2,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5, 5, 2, 5, 0, 0, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 5, 5, 3, 1, 5, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 4, 6,
    7, 9, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 3, 6, 1, 6, 0, 1, 5, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 1, 5, 2, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 5, 5, 3, 1, 5, 1, 6,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 2, 1, 3, 6,
    7, 9, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 0, 5, 5, 4, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 5, 5, 3, 1, 5, 0, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 5, 5, 2, 5, 0, 4, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 1, 0, 6,
    7, 9, 0, 1, 2, 5, 0, 2, 5, 3, 3, 1, 3, 2, 5, 1, 6, 4, 6, 0,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 1, 5, 2, 0, 6,
    7, 9, 6, 3, 1, 2, 6, 5, 3, 4, 6, 4, 0, 5, 6, 0, 6, 1, 6, 2,
    7, 9, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 6, 2, 5, 6, 2, 5,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 3, 4, 6, 5, 6, 0,
    7, 9, 1, 4, 2, 4, 2, 3, 0, 4, 3, 1, 4, 5, 0, 5, 6, 4, 6, 3,
    7, 9, 4, 1, 5, 4, 6, 5, 3, 6, 2, 3, 1, 2, 5, 2, 0, 5, 2, 0,
    7, 9, 4, 1, 3, 1, 2, 3, 4, 0, 5, 0, 5, 2, 5, 4, 6, 4, 5, 6,
    7, 9, 1, 0, 2, 1, 6, 2, 3, 6, 5, 3, 4, 5, 3, 4, 2, 3, 0, 2,
    7, 9, 0, 2, 5, 0, 1, 5, 2, 1, 4, 2, 5, 4, 6, 5, 3, 6, 2, 3,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 6, 1, 3, 4, 1,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 4, 5, 1, 6, 1, 0, 6,
    7, 9, 0, 4, 1, 0, 4, 1, 3, 4, 2, 3, 6, 2, 5, 6, 1, 5, 2, 1,
    7, 9, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 3, 6, 5, 3, 6,
    7, 9, 6, 5, 3, 6, 2, 3, 0, 4, 0, 5, 1, 0, 2, 0, 1, 2, 5, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 3, 5, 1, 6, 1, 0, 6,
    7, 9, 5, 2, 6, 5, 3, 6, 2, 3, 0, 2, 4, 0, 5, 4, 1, 5, 0, 1,
    7, 9, 2, 4, 1, 2, 4, 1, 5, 4, 0, 5, 1, 0, 6, 4, 3, 6, 2, 3,
    7, 9, 6, 2, 5, 6, 2, 5, 1, 2, 0, 1, 4, 0, 1, 4, 3, 1, 0, 3,
    7, 9, 0, 5, 6, 0, 1, 6, 4, 1, 2, 4, 3, 2, 1, 3, 5, 1, 6, 5,
    7, 9, 6, 5, 3, 6, 2, 3, 5, 2, 0, 5, 1, 0, 4, 1, 0, 4, 2, 0,
    7, 9, 0, 4, 3, 0, 1, 3, 4, 1, 2, 4, 6, 2, 5, 6, 2, 5, 3, 2,
    7, 9, 1, 0, 4, 1, 5, 4, 0, 5, 6, 0, 3, 6, 2, 3, 0, 2, 3, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 3,
    7, 9, 0, 1, 1, 2, 2, 3, 0, 3, 4, 1, 5, 4, 5, 3, 6, 0, 6, 4,
    7, 9, 0, 1, 4, 0, 1, 4, 2, 1, 5, 2, 4, 5, 6, 5, 3, 6, 2, 3,
    7, 9, 1, 0, 6, 3, 0, 4, 5, 0, 3, 5, 5, 6, 1, 2, 1, 4, 6, 2,
    7, 9, 6, 2, 5, 6, 2, 5, 1, 2, 0, 3, 4, 0, 1, 4, 3, 1, 3, 4,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 1, 5, 6, 6, 0,
    7, 9, 0, 4, 1, 0, 2, 1, 3, 2, 0, 3, 2, 4, 5, 4, 6, 5, 3, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 2, 6, 1, 5, 6,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 3, 5, 4, 6, 1, 6, 5,
    7, 9, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 4, 6, 2,
    7, 9, 0, 4, 3, 0, 4, 3, 6, 1, 5, 6, 1, 5, 2, 1, 5, 2, 6, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 4,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 1, 0,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 2, 4,
    7, 10, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1,
    7, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2,
    7, 10, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 0, 2, 1, 3, 5, 1,
    7, 10, 0, 1, 1, 2, 3, 4, 0, 2, 3, 0, 2, 4, 5, 2, 1, 5, 4, 1, 3, 5,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 2, 2, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 2, 1, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4, 1, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4, 0, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4, 3, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 4, 5, 4, 6,
    7, 10, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 4, 3, 3, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 5, 2, 6,
    7, 10, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 4, 3, 2, 6,
    7, 10, 2, 3, 1, 2, 4, 1, 5, 4, 2, 5, 0, 2, 4, 0, 0, 1, 5, 0, 6, 5,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 0, 4, 5, 6,
    7, 10, 2, 0, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 4, 3, 4, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 4, 5, 6, 5,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 6, 5,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0, 0, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0, 2, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 1, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0, 3, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 0, 4, 1, 0, 4, 1, 0, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1, 1, 6,
    7, 10, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4, 4, 0, 5, 0, 0, 6,
    7, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 3, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0, 5, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 3, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1, 0, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 2, 0, 5, 3, 2, 3, 6, 2,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 6, 4, 6, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 2, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1, 5, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 3, 0, 4, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 3, 6,
    7, 10, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4, 4, 0, 5, 0, 2, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 2, 0, 5, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 2, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 2, 0, 5, 3, 2, 3, 0, 6,
    7, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 1, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 4, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 6, 4, 6, 0,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 5, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 0, 4, 1, 0, 4, 1, 5, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 2, 0, 0, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 1, 0, 5, 1, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 5, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1, 0, 6,
    7, 10, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 5, 4, 4, 0, 5, 0, 5, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 6, 5, 6, 4,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 1, 6,
    7, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 4, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 4, 6,
    7, 10, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 0, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2, 5, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1, 1, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 3, 6,
    7, 10, 4, 3, 4, 1, 1, 2, 5, 4, 2, 5, 3, 1, 5, 3, 3, 2, 6, 0, 6, 2,
    7, 10, 1, 0, 2, 1, 3, 2, 4, 3, 5, 4, 1, 5, 6, 1, 4, 6, 2, 6, 5, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2, 0, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1, 3, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1, 2, 6,
    7, 10, 0, 1, 2, 5, 0, 2, 3, 0, 3, 1, 3, 2, 2, 1, 5, 1, 6, 5, 6, 4,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 1, 6,
    7, 10, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 6,
    7, 10, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 2, 0, 1, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 1, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 4, 2, 5, 2, 1, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 0, 5, 2, 5, 0, 5, 1, 4, 6,
    7, 10, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2, 4, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 5, 2, 4, 1, 0, 6,
    7, 10, 4, 0, 1, 4, 3, 1, 2, 3, 1, 2, 6, 1, 0, 6, 5, 0, 1, 5, 0, 1,
    7, 10, 3, 2, 6, 3, 5, 6, 0, 5, 2, 0, 5, 2, 1, 5, 2, 1, 4, 2, 5, 4,
    7, 10, 2, 0, 1, 2, 3, 1, 0, 3, 6, 0, 1, 6, 5, 1, 0, 5, 4, 0, 1, 4,
    7, 10, 6, 4, 1, 2, 6, 5, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 2, 6, 3,
    7, 10, 0, 1, 6, 5, 2, 3, 3, 4, 6, 4, 0, 5, 6, 0, 6, 1, 6, 2, 6, 3,
    7, 10, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 0, 5, 5, 2, 6, 1, 2, 6,
    7, 10, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 0, 5, 2, 6, 2, 0, 6,
    7, 10, 6, 4, 1, 2, 6, 5, 3, 4, 4, 5, 0, 5, 6, 3, 6, 1, 6, 2, 0, 4,
    7, 10, 1, 0, 2, 1, 0, 2, 3, 2, 4, 3, 2, 4, 5, 2, 4, 5, 6, 4, 1, 6,
    7, 10, 0, 1, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 5, 2, 6,
    7, 10, 0, 2, 5, 0, 4, 5, 2, 4, 1, 2, 5, 1, 6, 5, 3, 6, 2, 3, 2, 6,
    7, 10, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 1, 0, 5, 6, 0, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 2, 6, 4, 0, 2, 4, 0,
    7, 10, 0, 4, 3, 0, 2, 3, 5, 2, 6, 5, 2, 6, 4, 2, 1, 4, 3, 1, 4, 3,
    7, 10, 1, 6, 2, 1, 0, 2, 1, 0, 4, 1, 3, 4, 2, 3, 5, 6, 4, 5, 3, 1,
    7, 10, 6, 5, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 2, 6, 4,
    7, 10, 0, 1, 6, 5, 2, 3, 3, 4, 6, 4, 0, 5, 6, 0, 6, 1, 6, 2, 5, 3,
    7, 10, 0, 1, 1, 2, 2, 3, 5, 4, 0, 4, 5, 0, 5, 3, 5, 2, 6, 5, 6, 1,
    7, 10, 0, 3, 2, 0, 1, 2, 3, 1, 4, 3, 2, 4, 0, 4, 6, 0, 5, 6, 0, 5,
    7, 10, 0, 3, 2, 0, 1, 2, 3, 1, 4, 3, 0, 5, 0, 4, 6, 0, 5, 6, 1, 4,
    7, 10, 0, 1, 6, 5, 2, 3, 3, 4, 6, 4, 0, 5, 6, 0, 6, 1, 6, 2, 4, 2,
    7, 10, 1, 2, 5, 1, 6, 5, 2, 6, 1, 6, 5, 2, 4, 1, 0, 4, 3, 0, 1, 3,
    7, 10, 4, 2, 6, 2, 5, 3, 4, 1, 2, 0, 6, 3, 5, 2, 0, 1, 0, 4, 6, 0,
    7, 10, 4, 2, 3, 6, 5, 3, 5, 1, 2, 0, 6, 0, 5, 2, 1, 4, 0, 4, 5, 4,
    7, 10, 4, 0, 5, 4, 4, 1, 2, 1, 3, 2, 0, 3, 3, 4, 5, 3, 6, 1, 6, 5,
    7, 10, 0, 4, 1, 0, 2, 1, 4, 2, 3, 4, 5, 3, 4, 5, 5, 2, 6, 3, 2, 6,
    7, 10, 1, 6, 2, 1, 0, 2, 1, 0, 4, 1, 3, 4, 2, 3, 5, 6, 4, 5, 4, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 3, 6, 1, 6, 5, 5, 1,
    7, 10, 1, 0, 4, 1, 0, 4, 2, 0, 3, 2, 6, 3, 5, 6, 0, 5, 5, 2, 6, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 3, 5, 1, 5, 4, 6, 1, 5, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 4, 1, 6, 1, 6, 5,
    7, 10, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 3, 2, 5, 6, 1, 4, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 2, 5, 4, 6, 5, 6, 0, 0, 2,
    7, 10, 2, 0, 5, 2, 1, 5, 0, 1, 3, 0, 5, 3, 6, 5, 4, 6, 0, 4, 4, 3,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 2, 1, 5, 6, 2, 6, 5,
    7, 10, 5, 0, 6, 5, 2, 6, 3, 2, 0, 3, 4, 0, 2, 4, 4, 3, 1, 4, 3, 1,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 6, 3, 5, 6, 3, 5, 4, 5, 4, 6,
    7, 10, 5, 2, 2, 1, 3, 2, 4, 3, 1, 4, 5, 0, 6, 1, 6, 0, 1, 5, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 2, 6, 4, 4, 2, 5, 1,
    7, 10, 4, 2, 2, 3, 4, 1, 0, 1, 3, 0, 6, 4, 0, 6, 5, 0, 4, 5, 1, 5,
    7, 10, 2, 1, 5, 2, 3, 5, 0, 3, 4, 0, 6, 4, 3, 6, 1, 3, 4, 1, 5, 4,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 6, 5, 6, 3,
    7, 10, 0, 1, 4, 0, 1, 4, 2, 1, 5, 2, 4, 5, 6, 5, 3, 6, 2, 3, 5, 3,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 5, 6, 1, 6, 2, 4, 2,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 3, 5, 2, 6, 5, 6, 4,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 3, 6, 2, 4, 0,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 4, 6, 5, 6, 3,
    7, 10, 0, 5, 6, 0, 1, 6, 0, 1, 1, 5, 2, 1, 3, 2, 4, 3, 6, 4, 4, 5,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 5, 6, 4, 2, 0,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 5, 6, 3,
    7, 10, 2, 1, 2, 0, 3, 2, 4, 3, 1, 4, 5, 1, 5, 0, 6, 0, 1, 6, 6, 5,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 3, 5, 1, 6, 1, 6, 4, 6, 5,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 2, 4, 1, 6, 0, 5, 6,
    7, 10, 3, 1, 0, 3, 5, 0, 1, 5, 2, 1, 6, 2, 0, 6, 0, 4, 4, 2, 4, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 4, 6, 1, 6, 2, 6, 5,
    7, 10, 0, 3, 2, 0, 1, 2, 3, 1, 4, 3, 2, 4, 5, 4, 5, 0, 6, 4, 6, 1,
    7, 10, 0, 1, 6, 5, 2, 3, 3, 4, 6, 4, 0, 5, 6, 2, 6, 1, 4, 2, 5, 1,
    7, 10, 5, 2, 6, 5, 2, 6, 4, 2, 0, 4, 3, 0, 2, 3, 1, 0, 1, 3, 4, 1,
    7, 10, 3, 4, 1, 3, 4, 1, 0, 4, 3, 0, 1, 0, 2, 1, 5, 2, 6, 5, 2, 6,
    7, 10, 5, 6, 2, 5, 6, 2, 3, 6, 0, 3, 4, 0, 5, 4, 1, 4, 3, 1, 2, 1,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 5, 4, 2,
    7, 10, 1, 0, 2, 1, 3, 2, 0, 3, 5, 0, 1, 5, 4, 5, 6, 4, 3, 6, 2, 6,
    7, 10, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 1, 2, 5, 6, 0, 3, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2, 1, 5,
    7, 11, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5,
    7, 11, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 0, 2,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 5, 1,
    7, 11, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 11, 3, 6, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 2, 6, 5, 1, 0, 3, 1, 6, 0, 1,
    7, 11, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 0, 3,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 4, 6, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 6, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 2, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 2, 5, 6, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 2, 0, 6,
    7, 11, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 6, 5,
    7, 11, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 1, 0, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5, 6, 4,
    7, 11, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 4, 5, 1, 0, 1, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 2, 4, 2, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5, 5, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2, 2, 6,
    7, 11, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2, 6, 1,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2, 3, 6,
    7, 11, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2, 6, 4,
    7, 11, 0, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 11, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2, 0, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2, 0, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1, 1, 6,
    7, 11, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 5, 4, 3, 5, 1, 5, 0, 6,
    7, 11, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 2, 6,
    7, 11, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2, 3, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1, 2, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2, 5, 6,
    7, 11, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2, 5, 6,
    7, 11, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 4, 5, 6,
    7, 11, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1, 5, 6,
    7, 11, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 4, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 4, 0, 2, 4, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 6, 5, 6, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 0, 2, 1, 3, 5, 1, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 1, 6,
    7, 11, 1, 0, 4, 1, 0, 4, 5, 0, 4, 5, 3, 4, 1, 3, 5, 1, 2, 3, 1, 2, 2, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 3, 2, 0, 3, 2, 4, 5, 2, 1, 6,
    7, 11, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 5, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 0, 2, 1, 3, 5, 1, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 0, 2, 1, 3, 5, 1, 6, 3,
    7, 11, 4, 3, 0, 4, 1, 0, 2, 1, 3, 2, 0, 5, 5, 3, 0, 3, 1, 5, 5, 2, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 5, 0, 5, 2, 0, 5, 1, 4, 1, 6, 3,
    7, 11, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 3, 2, 0, 3, 1, 6,
    7, 11, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0, 6, 2,
    7, 11, 0, 1, 2, 4, 0, 2, 4, 5, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 6,
    7, 11, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5,
    7, 11, 6, 5, 0, 6, 5, 0, 1, 5, 6, 1, 2, 6, 5, 2, 3, 5, 6, 3, 4, 6, 5, 4,
    7, 11, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 1, 2, 5, 6, 2, 1, 6, 3, 1,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 1, 3, 5, 6, 1, 4, 6, 1, 4, 3, 1,
    7, 11, 1, 4, 2, 3, 4, 2, 0, 6, 4, 5, 6, 5, 3, 1, 6, 4, 3, 0, 3, 6, 4, 3,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 2, 6, 4, 2, 6, 5, 2, 0, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 4, 0, 3, 0, 2, 0, 6, 0, 3, 6,
    7, 11, 0, 1, 2, 0, 5, 2, 6, 5, 2, 6, 1, 2, 4, 1, 2, 4, 3, 2, 4, 3, 3, 1,
    7, 11, 4, 5, 1, 4, 2, 1, 3, 2, 6, 3, 5, 6, 2, 5, 4, 2, 3, 5, 0, 5, 2, 0,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 2, 5, 2, 5, 0, 6, 2, 4, 6, 5, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 6, 1, 2, 6, 0, 2, 6, 0, 5, 2, 0, 5,
    7, 11, 0, 5, 6, 0, 1, 6, 5, 1, 2, 5, 6, 2, 4, 3, 3, 2, 4, 5, 6, 4, 6, 5,
    7, 11, 0, 5, 6, 0, 1, 6, 5, 1, 2, 5, 6, 2, 3, 6, 5, 3, 4, 5, 6, 4, 4, 3,
    7, 11, 0, 5, 0, 6, 1, 2, 1, 6, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 0, 2, 2, 4, 5, 2, 4, 5, 6, 5, 6, 0,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 6, 4, 2, 0, 4, 2, 0, 6, 4,
    7, 11, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 5, 1, 5, 2, 6, 1, 2, 6, 4, 2, 5, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 2, 5, 4, 2, 6, 2, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 4, 6, 2, 0, 2, 4, 0,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 3, 1, 5, 3, 4, 5, 1, 4, 6, 5, 6, 1,
    7, 11, 0, 4, 3, 0, 4, 3, 2, 4, 3, 2, 1, 3, 2, 1, 4, 1, 5, 2, 6, 5, 2, 6,
    7, 11, 0, 5, 0, 6, 1, 4, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 11, 0, 1, 4, 0, 5, 4, 6, 5, 3, 6, 2, 3, 1, 2, 4, 1, 2, 4, 5, 2, 1, 5,
    7, 11, 0, 4, 3, 0, 4, 3, 2, 4, 6, 2, 1, 6, 5, 1, 2, 5, 3, 2, 1, 3, 4, 1,
    7, 11, 0, 1, 6, 5, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 2, 6, 3, 6, 4,
    7, 11, 4, 1, 0, 4, 1, 0, 3, 1, 0, 3, 5, 1, 6, 5, 1, 6, 2, 1, 5, 2, 6, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 4, 6, 5, 4, 6,
    7, 11, 1, 0, 2, 1, 3, 2, 4, 3, 0, 4, 2, 0, 5, 2, 6, 5, 3, 6, 6, 0, 0, 5,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 2, 4, 0, 6, 4, 0, 6, 3, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 2, 0, 5, 2, 6, 5, 4, 6, 0, 5, 6, 0,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 2, 6, 3, 6, 0, 3, 4, 0,
    7, 11, 4, 6, 5, 4, 6, 5, 3, 6, 5, 3, 2, 5, 3, 2, 5, 0, 6, 0, 1, 0, 2, 1,
    7, 11, 2, 0, 4, 2, 5, 4, 3, 5, 1, 3, 0, 1, 2, 1, 3, 2, 6, 3, 5, 6, 4, 3,
    7, 11, 4, 3, 4, 2, 1, 4, 3, 1, 0, 3, 1, 0, 3, 2, 3, 5, 2, 5, 6, 0, 4, 6,
    7, 11, 0, 1, 0, 2, 2, 3, 5, 1, 1, 3, 5, 2, 6, 3, 6, 0, 5, 3, 4, 5, 3, 4,
    7, 11, 4, 0, 1, 4, 6, 1, 0, 6, 3, 0, 1, 3, 5, 1, 0, 5, 6, 5, 2, 3, 0, 2,
    7, 11, 0, 1, 5, 0, 4, 5, 1, 4, 2, 1, 3, 2, 4, 3, 4, 2, 6, 4, 2, 6, 3, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 3, 5, 6, 3, 4, 6, 5, 6,
    7, 11, 6, 3, 5, 6, 2, 5, 3, 2, 5, 3, 4, 5, 2, 4, 1, 2, 5, 1, 0, 1, 4, 0,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 6, 5, 4, 6,
    7, 11, 0, 4, 3, 0, 2, 3, 5, 2, 6, 5, 2, 6, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1,
    7, 11, 5, 0, 0, 1, 3, 0, 5, 3, 2, 5, 6, 2, 4, 6, 5, 4, 1, 5, 6, 1, 3, 6,
    7, 11, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 2, 1, 5, 1, 2, 5, 6, 4, 6, 2, 3, 6,
    7, 11, 3, 2, 6, 3, 5, 6, 0, 5, 2, 0, 1, 2, 0, 1, 5, 1, 2, 5, 4, 2, 6, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 1, 5, 3, 5, 1, 6, 4, 6, 5, 3, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 3, 6, 0, 6, 2, 6, 3, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 6, 5, 4, 6, 3, 6, 1, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 6, 5, 1, 6, 2, 6, 4, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 3, 4, 2, 6, 1, 6, 4, 5, 2, 3, 5,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 6, 1, 4, 6, 6, 5, 2, 6,
    7, 11, 0, 3, 0, 6, 1, 2, 1, 5, 2, 4, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 11, 5, 1, 6, 5, 4, 6, 3, 4, 2, 3, 0, 2, 1, 0, 5, 0, 6, 0, 2, 6, 4, 2,
    7, 11, 1, 0, 2, 1, 3, 2, 4, 3, 0, 4, 5, 2, 3, 5, 6, 0, 6, 5, 6, 2, 3, 6,
    7, 11, 0, 3, 4, 0, 2, 4, 3, 2, 1, 3, 4, 1, 5, 1, 6, 0, 6, 1, 5, 3, 4, 5,
    7, 11, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 5, 2, 6, 3, 4, 4, 5, 4, 6, 5, 6,
    7, 11, 0, 2, 1, 0, 2, 1, 0, 3, 3, 1, 5, 4, 5, 3, 6, 4, 6, 2, 6, 0, 1, 6,
    7, 11, 4, 1, 5, 4, 2, 5, 1, 2, 0, 1, 5, 0, 6, 5, 3, 6, 2, 3, 0, 2, 4, 0,
    7, 11, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 6, 1, 6, 2, 5, 1, 3, 5, 5, 2, 4, 5,
    7, 11, 0, 5, 0, 6, 1, 4, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 3, 6, 4, 6, 2, 2, 0, 4, 0,
    7, 11, 0, 2, 1, 0, 2, 1, 0, 3, 3, 1, 5, 4, 5, 3, 6, 4, 6, 2, 4, 0, 1, 4,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 6, 2, 0, 6, 1, 6,
    7, 11, 0, 3, 4, 0, 1, 4, 3, 1, 4, 3, 0, 1, 2, 4, 6, 2, 5, 6, 2, 5, 1, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 6, 1, 6, 5,
    7, 11, 4, 1, 5, 4, 2, 5, 1, 2, 0, 1, 4, 0, 5, 0, 6, 5, 3, 6, 2, 3, 5, 3,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 3, 4, 2, 5, 1, 5, 4, 6, 5, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 5, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 6, 3, 6, 4,
    7, 11, 0, 4, 3, 0, 1, 3, 4, 1, 3, 4, 5, 1, 6, 5, 1, 6, 2, 1, 5, 2, 6, 2,
    7, 11, 4, 1, 0, 4, 3, 0, 2, 5, 5, 4, 6, 5, 2, 6, 1, 2, 3, 1, 6, 3, 2, 3,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 2, 5, 4, 5, 3, 6, 0, 6, 5, 3, 6,
    7, 11, 5, 2, 2, 4, 5, 3, 4, 1, 5, 4, 0, 1, 3, 0, 0, 2, 6, 2, 6, 3, 0, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 4, 5, 2, 5, 3, 6, 1, 0, 6,
    7, 11, 0, 3, 0, 4, 1, 2, 1, 5, 1, 6, 2, 4, 2, 6, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 11, 4, 0, 3, 4, 5, 3, 0, 5, 1, 0, 2, 1, 3, 2, 4, 1, 5, 2, 6, 4, 5, 6,
    7, 11, 2, 3, 4, 2, 0, 4, 5, 0, 1, 5, 4, 1, 3, 4, 5, 3, 1, 0, 6, 5, 6, 2,
    7, 11, 4, 1, 0, 4, 3, 0, 4, 3, 5, 4, 6, 5, 2, 6, 1, 2, 3, 1, 6, 3, 2, 5,
    7, 11, 0, 3, 4, 0, 2, 4, 3, 2, 1, 3, 0, 1, 6, 0, 5, 6, 2, 5, 1, 5, 4, 1,
    7, 11, 0, 3, 0, 4, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 6, 4, 5, 5, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 3, 4, 2, 5, 1, 5, 4, 6, 1, 5, 6,
    7, 11, 4, 1, 5, 4, 6, 5, 3, 6, 2, 3, 1, 2, 0, 1, 5, 0, 4, 0, 5, 2, 6, 2,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 4, 2, 3, 5, 4, 5, 3, 0, 6, 5, 6, 1,
    7, 11, 0, 4, 1, 0, 4, 1, 3, 4, 2, 3, 1, 2, 6, 1, 5, 6, 3, 5, 5, 4, 2, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 5, 1, 4, 2, 6, 2, 3, 6, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 2, 1, 6, 5, 2, 4, 1, 0, 3,
    7, 11, 0, 3, 0, 4, 1, 2, 1, 5, 1, 6, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 11, 0, 1, 1, 2, 2, 3, 5, 4, 0, 4, 5, 3, 5, 1, 6, 3, 6, 4, 4, 2, 0, 3,
    7, 11, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 6, 3, 6, 4, 5,
    7, 11, 4, 3, 2, 4, 3, 2, 0, 3, 2, 1, 5, 4, 5, 0, 6, 4, 6, 1, 1, 5, 0, 6,
    7, 11, 6, 4, 3, 6, 1, 3, 4, 1, 0, 4, 2, 0, 3, 2, 0, 1, 5, 0, 6, 5, 5, 2,
    7, 11, 6, 1, 2, 6, 1, 2, 0, 1, 3, 0, 4, 3, 5, 4, 3, 5, 2, 0, 4, 0, 5, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 4, 3, 0, 2,
    7, 12, 3, 6, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 2, 6, 5, 1, 0, 3, 1, 6, 0, 1, 0, 6,
    7, 12, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 5, 1, 2, 4,
    7, 12, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 2, 3,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 2, 3, 1, 4, 0, 2, 4, 5, 1, 0, 5, 4, 5, 3, 4, 5, 3,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2, 1, 5, 6, 1,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2, 4, 6, 5, 3,
    7, 12, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 1, 6,
    7, 12, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 3, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5, 6, 1,
    7, 12, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 0, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5, 0, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5, 2, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 0, 2, 1, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 0, 2, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 0, 2, 6, 1, 6, 5,
    7, 12, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 1, 5, 3, 2, 5, 1, 0, 4, 1, 1, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 3, 5, 0, 3, 5, 6,
    7, 12, 3, 6, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 2, 6, 5, 1, 0, 3, 1, 6, 0, 1, 1, 4,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 3, 5, 0, 3, 3, 6,
    7, 12, 0, 1, 2, 4, 0, 2, 2, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 4, 6,
    7, 12, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 1, 5, 3, 2, 5, 1, 0, 4, 1, 2, 6,
    7, 12, 3, 6, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 2, 6, 5, 1, 0, 3, 1, 6, 0, 1, 0, 4,
    7, 12, 1, 3, 4, 1, 3, 4, 2, 3, 0, 2, 4, 0, 5, 4, 2, 5, 4, 2, 0, 5, 1, 5, 3, 6,
    7, 12, 1, 3, 4, 1, 3, 4, 2, 3, 0, 2, 4, 0, 5, 4, 2, 5, 4, 2, 0, 5, 1, 5, 0, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 0, 4, 5, 5, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 0, 3, 5, 6,
    7, 12, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 4, 6,
    7, 12, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 0, 6,
    7, 12, 3, 6, 1, 3, 2, 1, 0, 2, 5, 0, 6, 5, 2, 6, 5, 1, 0, 3, 1, 6, 0, 1, 4, 5,
    7, 12, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 3, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 0, 3, 0, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 0, 2, 5, 6,
    7, 12, 0, 3, 6, 0, 5, 6, 3, 5, 1, 3, 6, 1, 4, 6, 3, 4, 2, 3, 6, 2, 3, 6, 5, 4,
    7, 12, 0, 1, 4, 0, 5, 4, 1, 5, 4, 1, 2, 4, 1, 2, 6, 1, 4, 6, 2, 6, 3, 2, 4, 3,
    7, 12, 4, 1, 3, 2, 3, 0, 4, 2, 5, 1, 5, 0, 3, 5, 4, 3, 5, 4, 6, 5, 3, 6, 4, 6,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 4, 2, 3, 4, 5, 3, 0, 5, 6, 3, 1, 6,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 6, 3, 0, 6, 5, 0, 1, 5, 4, 1, 2, 4,
    7, 12, 6, 2, 5, 6, 3, 5, 2, 3, 1, 2, 4, 1, 5, 4, 2, 5, 4, 2, 0, 4, 1, 0, 5, 1,
    7, 12, 5, 4, 6, 5, 3, 6, 4, 3, 0, 4, 3, 0, 1, 3, 0, 1, 4, 1, 3, 5, 2, 3, 4, 2,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 5, 0, 1, 5, 6, 1, 0, 6,
    7, 12, 1, 2, 0, 1, 2, 0, 3, 2, 0, 3, 1, 3, 4, 2, 0, 4, 5, 4, 2, 5, 6, 2, 1, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 2, 4, 5, 6, 4, 3, 6,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 5, 0, 1, 5, 6, 1, 2, 6,
    7, 12, 1, 2, 0, 1, 2, 0, 3, 2, 0, 3, 1, 3, 4, 2, 0, 4, 6, 4, 2, 6, 5, 2, 4, 5,
    7, 12, 1, 0, 2, 1, 0, 2, 3, 0, 4, 3, 0, 4, 5, 0, 3, 5, 4, 5, 6, 4, 3, 6, 6, 0,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 4, 1, 0, 4, 5, 0, 2, 5, 6, 5, 2, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 6, 4, 0, 6, 5, 0, 3, 5,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 1, 5, 6, 1, 0, 6, 5, 0, 4, 5,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 6, 1, 0, 6, 5, 0, 2, 5,
    7, 12, 5, 4, 3, 5, 4, 3, 6, 4, 3, 6, 2, 3, 4, 2, 0, 4, 3, 0, 1, 0, 2, 1, 6, 2,
    7, 12, 4, 1, 3, 2, 3, 0, 4, 2, 5, 1, 5, 0, 3, 5, 4, 3, 5, 4, 6, 5, 0, 6, 3, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 6, 1, 0, 6, 5, 0, 1, 5,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 3, 1, 5, 1, 6, 5, 4, 6,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 5, 4, 3, 5, 6, 3, 4, 6,
    7, 12, 1, 0, 2, 1, 3, 2, 0, 3, 4, 3, 1, 4, 4, 0, 5, 4, 0, 5, 3, 5, 6, 0, 1, 6,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 6, 2, 4, 6, 5, 0, 1, 5,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 5, 4, 2, 5, 1, 5, 6, 1, 5, 6,
    7, 12, 0, 2, 1, 0, 2, 1, 0, 3, 3, 1, 4, 2, 5, 3, 6, 1, 6, 4, 4, 0, 3, 4, 1, 5,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 0, 3, 2, 4, 3, 4, 1, 0, 4, 5, 2, 5, 4, 6, 0, 3, 6,
    7, 12, 5, 0, 2, 5, 6, 2, 3, 6, 2, 3, 1, 2, 0, 1, 4, 0, 1, 4, 5, 1, 6, 5, 0, 2,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 6, 4, 2, 6, 5, 2, 3, 5,
    7, 12, 0, 2, 1, 0, 5, 1, 3, 5, 6, 3, 2, 6, 4, 2, 3, 4, 5, 4, 2, 5, 1, 2, 4, 1,
    7, 12, 0, 2, 1, 0, 2, 1, 0, 3, 3, 1, 4, 0, 1, 4, 4, 2, 3, 4, 5, 4, 6, 5, 3, 6,
    7, 12, 0, 1, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 6, 1, 2, 6, 4, 6, 3, 4, 5, 3, 6, 5,
    7, 12, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 5, 0, 6, 5, 0, 6, 3, 4,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 2, 5, 6, 0, 3, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 3, 5, 1, 5, 4, 6, 3, 4, 6, 1, 6, 6, 5,
    7, 12, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 2, 6, 5, 0, 6, 6, 2, 0, 5, 1, 5, 6, 1,
    7, 12, 0, 1, 6, 5, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 2, 6, 3, 6, 4, 5, 1,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 6, 1, 5, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 4, 5, 6, 4, 5, 6,
    7, 12, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 1, 5, 3, 2, 5, 1, 0, 4, 1, 6, 3, 6, 1,
    7, 12, 0, 4, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 12, 0, 1, 2, 4, 0, 2, 2, 1, 4, 6, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 6, 1, 2, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 5, 4, 0, 4, 5, 3, 5, 1, 6, 3, 6, 4, 4, 2, 0, 3, 4, 3,
    7, 12, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 6, 1, 6, 5,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 6, 5, 0, 6, 1, 6,
    7, 12, 0, 3, 4, 0, 2, 4, 3, 2, 1, 3, 4, 1, 1, 0, 5, 1, 5, 2, 6, 1, 2, 6, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 5, 4, 4, 1, 1, 6, 5, 3, 1, 5, 6, 2,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 5, 4, 4, 1, 1, 5, 5, 3, 6, 1, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 5, 4, 4, 1, 1, 5, 5, 3, 6, 1, 0, 6,
    7, 12, 4, 3, 1, 2, 0, 1, 0, 3, 4, 0, 6, 4, 4, 2, 5, 4, 6, 2, 6, 3, 3, 2, 5, 1,
    7, 12, 2, 3, 4, 2, 0, 4, 6, 0, 6, 5, 4, 5, 1, 3, 5, 1, 0, 5, 6, 1, 3, 6, 5, 3,
    7, 12, 0, 3, 0, 5, 1, 2, 1, 5, 1, 6, 2, 4, 2, 6, 3, 4, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 3, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 4, 3, 5, 3, 6, 1, 3, 6, 6, 2, 0, 6, 4, 6,
    7, 12, 0, 1, 2, 4, 0, 2, 6, 1, 3, 1, 3, 2, 4, 1, 5, 1, 5, 2, 5, 3, 0, 3, 4, 6,
    7, 12, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 6, 3, 1, 6,
    7, 12, 4, 3, 1, 2, 5, 0, 0, 3, 4, 0, 4, 1, 4, 2, 5, 1, 6, 2, 6, 3, 3, 2, 6, 4,
    7, 12, 2, 3, 4, 2, 5, 4, 0, 5, 6, 0, 1, 6, 3, 1, 6, 3, 5, 3, 1, 5, 4, 0, 3, 0,
    7, 12, 0, 3, 0, 5, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 6, 5, 6,
    7, 12, 3, 2, 1, 2, 5, 0, 0, 3, 4, 0, 4, 1, 6, 4, 5, 1, 6, 2, 6, 3, 6, 1, 0, 6,
    7, 12, 0, 5, 0, 6, 1, 3, 1, 4, 1, 6, 2, 3, 2, 4, 2, 6, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 3, 0, 5, 1, 2, 1, 4, 1, 6, 2, 4, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 3, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 6, 5, 6,
    7, 12, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 5, 4, 4, 1, 3, 4, 5, 3, 2, 6, 6, 1,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 5, 4, 4, 1, 3, 4, 5, 3, 6, 1, 6, 5,
    7, 12, 0, 2, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 12, 0, 5, 0, 6, 1, 3, 1, 4, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 1, 2, 4, 5, 2, 0, 5, 4, 3, 6, 5, 6, 4, 3, 5,
    7, 12, 0, 2, 0, 6, 1, 2, 1, 4, 1, 5, 2, 3, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 2, 0, 6, 1, 3, 1, 4, 1, 5, 2, 4, 2, 5, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6,
    7, 12, 0, 2, 0, 6, 1, 3, 1, 4, 1, 5, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 12, 0, 5, 0, 6, 1, 3, 1, 4, 1, 6, 2, 3, 2, 4, 2, 6, 3, 4, 3, 5, 4, 5, 5, 6,
    7, 12, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 12, 3, 0, 2, 3, 4, 2, 0, 4, 5, 1, 5, 2, 6, 1, 6, 0, 3, 6, 5, 3, 4, 5, 6, 4,
    7, 12, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 1, 0, 2, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 12, 3, 0, 2, 3, 4, 2, 0, 4, 5, 1, 5, 2, 6, 1, 6, 0, 3, 6, 5, 3, 6, 4, 1, 3,
    7, 12, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 3, 6, 4, 6, 5, 6,
    7, 12, 2, 3, 4, 2, 5, 2, 4, 1, 6, 0, 3, 0, 3, 1, 6, 3, 5, 6, 1, 5, 4, 0, 3, 4,
    7, 12, 2, 3, 4, 2, 4, 1, 2, 5, 6, 0, 6, 4, 3, 1, 6, 3, 0, 3, 1, 5, 4, 0, 5, 3,
    7, 12, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 3, 2, 6, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 12, 3, 0, 2, 3, 4, 2, 0, 4, 5, 1, 5, 2, 6, 1, 6, 0, 3, 6, 1, 3, 6, 4, 5, 4,
    7, 12, 6, 3, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 0, 6, 4, 1, 3, 4, 6, 5, 5, 1, 0, 4,
    7, 12, 0, 3, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 4, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6,
    7, 12, 0, 3, 0, 5, 0, 6, 1, 2, 1, 4, 1, 6, 2, 3, 2, 5, 3, 4, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 3, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 4, 5, 4, 6, 5, 6,
    7, 12, 0, 4, 3, 0, 1, 3, 4, 1, 1, 0, 4, 5, 2, 4, 6, 2, 5, 6, 2, 5, 3, 2, 6, 3,
    7, 12, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 5, 2, 5, 4, 6, 4, 6, 3, 6, 2, 5, 3,
    7, 12, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 4, 5, 4, 6,
    7, 12, 3, 0, 4, 2, 3, 1, 4, 0, 5, 2, 5, 1, 4, 3, 5, 4, 3, 5, 6, 1, 0, 6, 2, 6,
    7, 12, 1, 0, 4, 1, 0, 4, 5, 0, 6, 5, 1, 6, 3, 4, 5, 3, 2, 3, 5, 2, 6, 3, 2, 6,
    7, 12, 0, 1, 2, 0, 2, 3, 3, 4, 0, 4, 0, 5, 6, 1, 4, 6, 6, 5, 2, 6, 3, 1, 5, 3,
    7, 12, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 6, 0, 6, 1, 6, 2, 6, 3, 6, 4, 6, 5,
    7, 12, 3, 6, 1, 2, 0, 6, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 2, 5, 4, 5, 6, 4,
    7, 13, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 6, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 4, 3, 0, 2, 6, 4,
    7, 13, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 0, 4, 1, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 6, 4, 5, 5, 6,
    7, 13, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 3, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 13, 0, 6, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 4, 5, 1, 6,
    7, 13, 0, 1, 1, 2, 2, 3, 4, 5, 0, 4, 1, 3, 4, 1, 2, 4, 0, 3, 5, 3, 4, 3, 0, 2, 5, 6,
    7, 13, 0, 5, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 6, 5, 6,
    7, 13, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 5, 6, 0, 5, 6, 0, 4, 6, 5, 4, 1, 5, 6, 1, 3, 6, 5, 3, 2, 5, 6, 2, 1, 0, 2, 1,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 6,
    7, 13, 3, 4, 0, 3, 4, 0, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 6, 0, 3, 6, 5, 3, 4, 5,
    7, 13, 3, 4, 0, 3, 4, 0, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 6, 0, 3, 6, 5, 3, 0, 5,
    7, 13, 3, 4, 0, 3, 4, 0, 1, 4, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 6, 4, 0, 6, 5, 0, 3, 5,
    7, 13, 0, 5, 0, 6, 1, 3, 1, 4, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 5, 4, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 5, 1, 6, 5, 1, 6,
    7, 13, 0, 4, 0, 6, 1, 3, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 5, 0, 6, 1, 4, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 13, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 5, 3, 6, 5, 4, 6,
    7, 13, 0, 5, 0, 6, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 6, 1, 6, 5, 5, 1,
    7, 13, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 4, 0, 5, 6, 0, 3, 6, 6, 4,
    7, 13, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 6, 1, 5, 1, 2, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 5, 6,
    7, 13, 1, 0, 2, 1, 4, 2, 1, 4, 3, 1, 0, 3, 2, 3, 5, 2, 1, 5, 0, 5, 6, 0, 1, 6, 2, 6,
    7, 13, 2, 5, 6, 2, 5, 6, 4, 5, 3, 4, 0, 3, 4, 0, 1, 4, 3, 1, 6, 3, 2, 1, 4, 2, 3, 2,
    7, 13, 0, 3, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 13, 2, 4, 3, 2, 1, 3, 4, 1, 0, 4, 3, 0, 6, 3, 1, 6, 5, 1, 4, 5, 6, 4, 3, 5, 1, 2,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 4, 2, 5, 3, 5, 3, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 5, 5, 6,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 3, 2, 5, 3, 6, 4, 5,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 4, 2, 5, 3, 4, 3, 5,
    7, 13, 0, 2, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 2, 5, 1, 2, 5, 1, 4, 5, 3, 4, 0, 3, 4, 0, 3, 2, 4, 2, 1, 3, 6, 3, 2, 6, 1, 6,
    7, 13, 0, 4, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 13, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 0, 4, 6, 1, 4, 6,
    7, 13, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2, 5, 0, 6, 5, 1, 6, 4, 0,
    7, 13, 0, 1, 1, 2, 0, 2, 3, 0, 1, 3, 3, 2, 4, 0, 2, 5, 3, 4, 5, 3, 0, 5, 6, 4, 6, 1,
    7, 13, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2, 6, 2, 5, 6, 0, 5, 1, 2,
    7, 13, 5, 4, 6, 2, 6, 4, 4, 3, 5, 0, 3, 1, 3, 2, 6, 3, 5, 6, 4, 0, 1, 4, 5, 1, 0, 3,
    7, 13, 0, 2, 0, 6, 1, 3, 1, 4, 1, 5, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 1, 5, 4, 1, 0, 4, 5, 0, 2, 5, 4, 2, 3, 4, 5, 3, 0, 1, 2, 0, 3, 2, 6, 5, 6, 4,
    7, 13, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 0, 4, 0, 6, 4, 6,
    7, 13, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 5, 0, 4, 5, 1, 5, 6, 1, 0, 6, 3, 6,
    7, 13, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 4, 1, 5, 3, 2, 5, 1, 0, 6, 3, 4, 6, 5, 1,
    7, 13, 5, 2, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 6, 2, 6, 3, 1, 2, 3, 1, 4, 0,
    7, 13, 1, 0, 2, 1, 0, 2, 0, 3, 3, 2, 6, 2, 1, 6, 5, 1, 6, 5, 4, 6, 5, 4, 0, 5, 4, 0,
    7, 13, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6,
    7, 13, 0, 5, 0, 6, 1, 3, 1, 4, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 0, 1, 1, 2, 4, 1, 3, 1, 0, 4, 2, 3, 0, 3, 2, 0, 5, 0, 6, 5, 4, 6, 3, 5, 4, 2,
    7, 13, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6,
    7, 13, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 0, 4, 2, 3, 6, 5, 0, 6,
    7, 13, 5, 2, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 6, 2, 6, 3, 2, 3, 5, 0, 4, 0,
    7, 13, 0, 1, 1, 2, 2, 3, 5, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 6, 3, 6, 4, 4, 2, 0, 3,
    7, 13, 0, 1, 0, 6, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6,
    7, 13, 0, 1, 0, 6, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 6, 2, 0, 6, 5, 0, 2, 5, 5, 3, 4, 5, 6, 4, 3, 6,
    7, 13, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 6, 5, 0, 6, 0, 2, 2, 5, 5, 3, 4, 5, 6, 4, 3, 6,
    7, 13, 3, 4, 0, 3, 4, 0, 3, 6, 3, 1, 2, 3, 4, 2, 1, 0, 2, 1, 5, 2, 3, 5, 6, 2, 5, 6,
    7, 13, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 6, 5, 3, 6, 4, 6,
    7, 13, 1, 0, 2, 1, 6, 0, 1, 4, 3, 1, 0, 3, 2, 3, 1, 6, 1, 5, 2, 6, 4, 3, 5, 4, 6, 5,
    7, 13, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 5, 2, 6, 3, 5, 4, 6,
    7, 13, 0, 6, 1, 2, 2, 3, 0, 3, 4, 2, 5, 0, 6, 3, 4, 1, 3, 4, 6, 5, 1, 5, 3, 5, 1, 3,
    7, 13, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 6, 4, 4, 3, 5, 4, 5, 2, 6, 0, 3, 6, 3, 5,
    7, 13, 0, 1, 1, 2, 2, 3, 3, 6, 0, 4, 6, 5, 0, 6, 6, 4, 2, 5, 5, 3, 4, 5, 1, 5, 6, 1,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 4, 5, 4, 6, 5, 6,
    7, 13, 2, 3, 5, 2, 6, 5, 3, 6, 4, 3, 5, 4, 0, 5, 2, 0, 1, 2, 0, 1, 5, 1, 4, 2, 6, 4,
    7, 13, 2, 1, 0, 5, 6, 0, 4, 6, 5, 4, 1, 5, 6, 1, 3, 6, 5, 3, 2, 5, 6, 2, 1, 0, 3, 4,
    7, 13, 0, 1, 2, 0, 2, 3, 3, 4, 0, 4, 0, 5, 6, 1, 4, 6, 6, 5, 2, 6, 3, 1, 5, 3, 6, 0,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 3, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 2, 3, 0, 2, 3, 0, 4, 3, 4, 6, 5, 1, 4, 5, 3, 1, 5, 2, 6, 0, 6, 1, 2, 1, 4, 1,
    7, 13, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 3, 5, 4, 5, 2, 5, 1, 6, 5, 1, 6, 2, 6,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6,
    7, 13, 3, 0, 2, 3, 4, 2, 0, 4, 5, 1, 5, 2, 6, 1, 6, 0, 3, 6, 1, 3, 6, 4, 5, 4, 5, 3,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 2, 1, 4, 1, 5, 2, 3, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 6, 4, 6, 5, 6,
    7, 13, 0, 2, 0, 5, 0, 6, 1, 2, 1, 4, 1, 6, 2, 3, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 3, 4, 5, 0, 3, 5, 0, 6, 6, 4, 2, 3, 4, 2, 1, 0, 2, 1, 1, 6, 5, 1, 2, 5, 6, 2,
    7, 13, 0, 2, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 13, 3, 0, 2, 3, 4, 2, 0, 4, 5, 3, 5, 2, 5, 4, 1, 3, 1, 0, 4, 1, 6, 0, 3, 6, 1, 6,
    7, 13, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 6, 0, 1, 6, 6, 3, 4, 6, 1, 2, 5, 0,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6,
    7, 13, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5,
    7, 13, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 5, 3, 5, 4, 6, 4, 6, 2, 6, 5, 5, 2, 3, 6,
    7, 13, 0, 1, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 13, 0, 1, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 13, 0, 1, 2, 0, 2, 3, 3, 4, 0, 4, 0, 5, 6, 1, 4, 6, 6, 5, 2, 6, 3, 1, 5, 3, 2, 1,
    7, 14, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 1, 3, 2, 0, 4, 0, 5, 3,
    7, 14, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 2, 3, 0, 4, 1, 6,
    7, 14, 0, 6, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6,
    7, 14, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 3, 1, 2, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 3, 6, 5, 3, 4, 5, 6, 4,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 6, 2, 1, 6, 5, 1, 0, 5,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 5, 2, 3, 5, 6, 4, 0, 6,
    7, 14, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 2, 4, 5, 1, 0, 3, 1, 4, 0, 1, 0, 4, 6, 4, 0, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 3, 4, 3, 5, 4, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 6, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 3, 4, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 0, 1, 5, 1, 0, 4, 1, 4, 5, 3, 2, 5, 6, 4, 0, 6,
    7, 14, 1, 3, 2, 1, 0, 2, 5, 0, 4, 5, 3, 4, 5, 3, 2, 5, 1, 0, 4, 1, 6, 1, 5, 1, 2, 6, 0, 4,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 6, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 6, 0, 3, 4, 3, 1, 5, 4, 5, 0, 0, 3, 1, 5, 5, 3, 6, 4, 6, 1,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 5, 3, 6, 5, 4, 6, 5, 4,
    7, 14, 3, 1, 1, 4, 2, 3, 3, 4, 0, 4, 1, 5, 0, 1, 0, 2, 2, 5, 5, 3, 4, 5, 1, 2, 6, 2, 5, 6,
    7, 14, 0, 3, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 3, 0, 6, 1, 2, 1, 4, 1, 5, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 14, 0, 1, 0, 6, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 4, 6, 5, 2, 1, 5, 0, 5, 6, 3,
    7, 14, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 4, 2, 3, 0, 6, 1, 5, 6,
    7, 14, 0, 4, 0, 6, 1, 2, 1, 3, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 4, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 14, 0, 5, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 14, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 1, 2, 5, 2, 4, 0, 3, 1, 5, 0, 6, 5, 6, 4, 0, 1,
    7, 14, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 5, 2, 6, 0, 6, 1, 5, 0, 1, 2, 3, 1, 4, 0,
    7, 14, 5, 6, 0, 5, 6, 0, 4, 6, 5, 4, 1, 5, 6, 1, 3, 6, 5, 3, 2, 5, 6, 2, 1, 0, 2, 1, 3, 4,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 5, 1, 6, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 14, 0, 1, 2, 0, 2, 3, 3, 4, 0, 4, 0, 5, 6, 1, 4, 6, 6, 5, 2, 6, 3, 1, 5, 3, 6, 0, 3, 6,
    7, 14, 3, 1, 4, 2, 4, 5, 4, 0, 1, 4, 0, 3, 5, 0, 5, 2, 6, 1, 3, 6, 6, 0, 5, 6, 6, 2, 4, 6,
    7, 14, 0, 4, 3, 0, 2, 3, 4, 2, 1, 4, 3, 1, 1, 0, 2, 1, 5, 4, 1, 5, 6, 1, 3, 6, 0, 5, 6, 0,
    7, 14, 3, 4, 4, 2, 1, 5, 4, 0, 1, 4, 5, 3, 3, 0, 5, 2, 6, 4, 0, 6, 3, 6, 2, 6, 5, 6, 1, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 2, 3, 2, 6, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 4, 5, 3, 4, 3, 1, 5, 2, 1, 6, 5, 6, 6, 0, 5, 3, 6, 4, 0, 1,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 2, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 1, 4, 6, 0, 3, 1, 5, 2, 4, 5, 5, 6, 1, 5, 5, 3, 6, 4, 3, 0,
    7, 14, 3, 1, 4, 2, 0, 3, 4, 0, 1, 4, 5, 3, 5, 0, 5, 2, 6, 4, 1, 6, 6, 3, 0, 6, 6, 5, 2, 6,
    7, 14, 0, 1, 4, 2, 3, 0, 4, 0, 4, 5, 5, 3, 1, 3, 5, 2, 6, 4, 2, 6, 6, 5, 3, 6, 6, 1, 0, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 6, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 14, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 5, 1, 6, 2, 3, 2, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 1, 4, 6, 1, 3, 1, 5, 2, 5, 0, 5, 6, 4, 5, 5, 3, 6, 0, 3, 0,
    7, 14, 2, 3, 4, 2, 3, 0, 4, 0, 4, 5, 3, 4, 3, 1, 5, 2, 0, 1, 5, 6, 6, 0, 5, 3, 6, 4, 1, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 14, 0, 3, 0, 4, 0, 6, 1, 2, 1, 4, 1, 5, 2, 3, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 14, 0, 1, 0, 5, 0, 6, 1, 4, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 5, 6,
    7, 14, 0, 1, 0, 4, 0, 6, 1, 3, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 1, 4, 4, 5, 3, 1, 5, 2, 5, 0, 6, 1, 0, 6, 5, 3, 6, 4, 3, 0,
    7, 14, 0, 1, 0, 5, 0, 6, 1, 3, 1, 4, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 2, 3, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 5, 6,
    7, 14, 2, 3, 4, 2, 6, 3, 4, 0, 4, 5, 3, 5, 3, 1, 5, 2, 3, 0, 1, 4, 6, 0, 1, 6, 6, 4, 0, 1,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 4, 6,
    7, 14, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 6, 3, 4, 3, 5, 4, 6, 5, 6,
    7, 14, 0, 3, 0, 4, 0, 5, 1, 2, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 6, 5, 6,
    7, 14, 0, 3, 0, 4, 0, 5, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 6, 4, 6, 5, 6,
    7, 14, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 6, 0, 2, 5, 0, 3, 5, 1, 3, 6, 1, 4, 6, 2, 4,
    7, 14, 0, 3, 0, 4, 0, 5, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 6, 4, 5,
    7, 15, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5,
    7, 15, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 1, 3, 2, 0, 4, 0, 5, 3, 1, 6,
    7, 15, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 2, 4, 5, 2, 1, 5, 1, 4, 1, 3, 2, 0, 4, 0, 5, 3, 0, 6,
    7, 15, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 3, 4, 3, 5, 3, 6, 5, 6,
    7, 15, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 5, 1, 6, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 15, 3, 4, 4, 5, 0, 3, 0, 4, 0, 5, 0, 6, 3, 6, 4, 6, 5, 6, 1, 5, 3, 5, 2, 3, 2, 4, 1, 6, 0, 1,
    7, 15, 3, 4, 4, 5, 0, 3, 0, 4, 0, 5, 0, 6, 3, 6, 1, 3, 1, 4, 1, 5, 3, 5, 2, 3, 2, 4, 6, 1, 4, 6,
    7, 15, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 1, 4, 2, 4, 3, 5, 1, 0, 5, 5, 2, 3, 5, 4, 5, 6, 1, 5, 6,
    7, 15, 4, 3, 4, 5, 5, 3, 0, 1, 0, 5, 0, 3, 2, 4, 1, 5, 1, 3, 6, 5, 3, 6, 6, 0, 1, 6, 6, 2, 4, 6,
    7, 15, 3, 4, 4, 5, 5, 6, 0, 4, 0, 5, 0, 6, 3, 6, 1, 3, 4, 6, 1, 5, 3, 5, 2, 3, 2, 4, 1, 6, 0, 1,
    7, 15, 0, 2, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 15, 6, 1, 4, 5, 0, 3, 0, 4, 0, 5, 0, 6, 3, 6, 1, 3, 1, 4, 1, 5, 3, 5, 2, 3, 2, 4, 5, 6, 4, 6,
    7, 15, 3, 4, 4, 5, 0, 3, 0, 4, 0, 5, 4, 6, 3, 6, 1, 3, 1, 4, 1, 5, 3, 5, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 3, 4, 4, 5, 0, 3, 0, 4, 6, 0, 4, 6, 3, 6, 1, 3, 1, 4, 1, 5, 3, 5, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 0, 1, 1, 2, 0, 2, 3, 0, 1, 3, 2, 3, 5, 1, 3, 5, 4, 3, 2, 4, 6, 2, 3, 6, 6, 1, 0, 5, 4, 0,
    7, 15, 0, 1, 2, 0, 3, 2, 4, 3, 1, 4, 3, 1, 4, 2, 0, 4, 3, 0, 6, 3, 4, 6, 5, 4, 3, 5, 6, 2, 5, 1,
    7, 15, 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 6, 3,
    7, 15, 0, 1, 1, 2, 2, 3, 0, 3, 4, 0, 4, 3, 4, 2, 6, 1, 2, 6, 5, 2, 4, 5, 6, 4, 0, 6, 6, 5, 3, 6,
    7, 15, 0, 1, 5, 3, 1, 3, 0, 4, 3, 0, 4, 3, 2, 4, 5, 2, 4, 5, 6, 4, 2, 6, 6, 5, 3, 6, 6, 1, 0, 6,
    7, 15, 5, 2, 4, 5, 3, 1, 0, 4, 0, 5, 0, 3, 2, 4, 1, 5, 1, 4, 6, 3, 1, 6, 6, 0, 5, 6, 6, 2, 4, 6,
    7, 15, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 5, 0, 3, 2, 0, 3, 1, 6, 4, 5, 6, 6, 3, 0, 6, 6, 2, 1, 6,
    7, 15, 5, 2, 3, 0, 5, 3, 0, 4, 0, 5, 4, 3, 2, 4, 1, 5, 1, 4, 6, 4, 2, 6, 6, 0, 5, 6, 6, 3, 1, 6,
    7, 15, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 15, 6, 1, 4, 5, 0, 3, 0, 4, 0, 5, 4, 6, 3, 6, 1, 3, 1, 4, 0, 6, 3, 5, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 3, 4, 0, 1, 0, 3, 0, 4, 0, 5, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 1, 6, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 6,
    7, 15, 5, 2, 4, 5, 5, 3, 0, 4, 0, 1, 1, 3, 2, 4, 3, 0, 1, 4, 6, 4, 1, 6, 6, 0, 3, 6, 6, 2, 5, 6,
    7, 15, 5, 0, 4, 3, 5, 3, 5, 2, 0, 1, 1, 3, 2, 4, 3, 0, 1, 4, 6, 2, 5, 6, 6, 4, 3, 6, 6, 0, 1, 6,
    7, 15, 3, 4, 4, 5, 0, 3, 4, 6, 0, 1, 1, 6, 3, 6, 1, 3, 1, 4, 6, 0, 0, 5, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 0, 2, 0, 3, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 15, 0, 4, 0, 5, 0, 6, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 15, 3, 4, 5, 0, 0, 3, 0, 4, 4, 6, 1, 6, 3, 6, 1, 3, 1, 4, 6, 0, 1, 5, 2, 3, 2, 4, 5, 6, 5, 2,
    7, 15, 6, 4, 5, 2, 0, 3, 0, 4, 2, 4, 1, 6, 3, 6, 1, 3, 1, 4, 6, 0, 3, 5, 2, 3, 0, 1, 5, 6, 4, 5,
    7, 15, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 5, 1, 6, 2, 3, 2, 4, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 15, 0, 1, 0, 2, 0, 3, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 15, 2, 3, 0, 2, 3, 0, 4, 3, 1, 4, 5, 1, 4, 5, 1, 0, 5, 2, 6, 2, 5, 6, 6, 1, 0, 6, 6, 4, 3, 6,
    7, 15, 3, 0, 3, 5, 3, 4, 2, 0, 2, 5, 2, 4, 1, 4, 1, 5, 1, 0, 6, 0, 1, 6, 6, 5, 3, 6, 6, 4, 2, 6,
    7, 15, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 15, 3, 4, 6, 2, 0, 3, 0, 4, 5, 0, 1, 6, 3, 6, 1, 3, 1, 4, 6, 0, 4, 5, 2, 3, 2, 4, 5, 1, 5, 2,
    7, 15, 3, 4, 6, 2, 0, 3, 0, 4, 5, 0, 5, 6, 3, 6, 1, 3, 1, 4, 0, 1, 4, 6, 2, 3, 2, 4, 5, 1, 5, 2,
    7, 15, 0, 1, 1, 2, 2, 3, 3, 4, 0, 4, 6, 2, 1, 6, 6, 0, 4, 6, 5, 4, 0, 5, 3, 5, 6, 3, 5, 2, 1, 5,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5, 2, 6,
    7, 16, 3, 0, 4, 1, 4, 3, 1, 3, 4, 0, 2, 5, 6, 2, 5, 6, 1, 5, 4, 5, 3, 5, 0, 5, 0, 6, 3, 6, 4, 6, 6, 1,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 6, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 16, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 16, 3, 4, 5, 1, 0, 3, 0, 4, 5, 0, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 3, 5, 2, 3, 2, 4, 5, 6, 4, 5, 2, 5,
    7, 16, 2, 4, 3, 1, 3, 0, 4, 3, 4, 0, 5, 2, 4, 5, 5, 0, 3, 5, 5, 1, 6, 5, 1, 6, 3, 6, 6, 0, 4, 6, 6, 2,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 16, 2, 4, 4, 1, 3, 0, 3, 1, 4, 0, 5, 2, 4, 5, 5, 0, 3, 5, 6, 5, 1, 5, 6, 1, 3, 6, 4, 6, 6, 2, 6, 0,
    7, 16, 0, 1, 0, 3, 0, 5, 0, 6, 1, 3, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 16, 2, 5, 0, 1, 4, 5, 1, 3, 5, 0, 4, 3, 5, 3, 2, 4, 1, 4, 3, 0, 6, 3, 2, 6, 6, 4, 5, 6, 6, 1, 0, 6,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 3, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 4, 5, 4, 6, 5, 6,
    7, 16, 2, 5, 5, 1, 3, 1, 0, 4, 5, 0, 4, 3, 5, 3, 2, 4, 1, 4, 3, 0, 6, 2, 4, 6, 5, 6, 6, 1, 0, 6, 3, 6,
    7, 16, 1, 6, 0, 1, 0, 3, 0, 4, 5, 0, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 3, 5, 2, 3, 2, 4, 5, 6, 4, 5, 2, 5,
    7, 16, 3, 4, 5, 1, 0, 3, 0, 4, 5, 0, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 1, 6, 2, 3, 2, 4, 5, 6, 0, 1, 2, 5,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 3, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 5, 6,
    7, 16, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 5, 6,
    7, 16, 2, 5, 5, 1, 3, 5, 0, 4, 0, 1, 4, 3, 3, 2, 2, 4, 1, 4, 0, 5, 6, 4, 2, 6, 6, 3, 5, 6, 6, 1, 0, 6,
    7, 16, 5, 6, 5, 1, 0, 3, 0, 4, 0, 1, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 3, 5, 2, 3, 2, 4, 6, 2, 4, 5, 2, 5,
    7, 16, 3, 4, 5, 1, 0, 3, 0, 4, 0, 1, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 5, 0, 2, 3, 2, 4, 6, 2, 6, 5, 2, 5,
    7, 16, 5, 0, 5, 1, 0, 3, 0, 4, 6, 1, 4, 6, 3, 6, 1, 3, 1, 4, 6, 0, 3, 5, 2, 3, 2, 4, 6, 2, 4, 5, 2, 5,
    7, 17, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5, 6, 2, 1, 6,
    7, 17, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 4, 5, 4, 6,
    7, 17, 4, 0, 4, 3, 0, 1, 3, 0, 2, 4, 3, 1, 5, 3, 4, 5, 5, 2, 6, 5, 5, 0, 1, 5, 6, 1, 0, 6, 6, 4, 2, 6, 3, 6,
    7, 17, 0, 1, 5, 1, 5, 3, 0, 4, 5, 0, 4, 3, 3, 1, 2, 5, 1, 4, 3, 0, 2, 4, 6, 2, 5, 6, 6, 3, 1, 6, 6, 0, 4, 6,
    7, 17, 3, 4, 5, 1, 0, 3, 0, 4, 4, 5, 4, 6, 3, 6, 1, 3, 1, 4, 0, 1, 3, 5, 2, 3, 2, 4, 2, 5, 5, 0, 5, 6, 6, 2,
    7, 17, 3, 2, 4, 1, 0, 1, 3, 0, 2, 4, 4, 3, 5, 1, 4, 5, 5, 2, 0, 5, 5, 3, 6, 5, 2, 6, 6, 3, 0, 6, 1, 6, 4, 6,
    7, 17, 3, 2, 4, 1, 4, 0, 3, 0, 2, 4, 3, 1, 5, 2, 4, 5, 5, 0, 3, 5, 5, 1, 6, 5, 2, 6, 6, 0, 3, 6, 6, 4, 1, 6,
    7, 17, 3, 2, 5, 1, 5, 0, 0, 4, 0, 1, 4, 3, 5, 3, 2, 5, 1, 4, 3, 0, 2, 4, 6, 4, 5, 6, 6, 2, 3, 6, 6, 0, 1, 6,
    7, 17, 3, 2, 5, 1, 5, 0, 0, 4, 4, 5, 0, 1, 3, 1, 2, 5, 1, 4, 3, 0, 2, 4, 6, 0, 3, 6, 6, 1, 5, 6, 6, 2, 4, 6,
    7, 17, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 5, 3, 6, 4, 5, 4, 6,
    7, 18, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5, 6, 1, 0, 6, 5, 6,
    7, 18, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6,
    7, 18, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 4, 1, 5, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 18, 0, 1, 0, 2, 0, 3, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 18, 4, 0, 4, 5, 3, 0, 3, 5, 2, 0, 2, 5, 1, 3, 1, 4, 1, 5, 1, 0, 2, 3, 2, 4, 6, 0, 5, 6, 6, 1, 2, 6, 6, 4, 3, 6,
    7, 19, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 19, 0, 1, 0, 2, 0, 3, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 20, 0, 1, 0, 2, 0, 3, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
    7, 21, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, 3, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 4, 5, 4, 6, 5, 6,
};

const long int igraph_i_atlas_edges_pos[] = {0, 2, 4, 6, 10, 12, 16, 22, 30, 32, 36, 42, 48, 56, 64, 72, 82, 92, 104, 118, 120, 124, 130, 136, 144, 152, 160, 168, 178, 188, 198, 208, 218, 228, 240, 252, 264, 276, 288, 300, 314, 328, 342, 356, 370, 384, 400, 416, 432, 448, 466, 484, 504, 526, 528, 532, 538, 544, 552, 560, 568, 576, 584, 594, 604, 614, 624, 634, 644, 654, 664, 674, 686, 698, 710, 722, 734, 746, 758, 770, 782, 794, 806, 818, 830, 842, 854, 868, 882, 896, 910, 924, 938, 952, 966, 980, 994, 1008, 1022, 1036, 1050, 1064, 1078, 1092, 1106, 1120, 1134, 1148, 1164, 1180, 1196, 1212, 1228, 1244, 1260, 1276, 1292, 1308, 1324, 1340, 1356, 1372, 1388, 1404, 1420, 1436, 1452, 1468, 1484, 1500, 1516, 1532, 1550, 1568, 1586, 1604, 1622, 1640, 1658, 1676, 1694, 1712, 1730, 1748, 1766, 1784, 1802, 1820, 1838, 1856, 1874, 1892, 1910, 1928, 1946, 1964, 1984, 2004, 2024, 2044, 2064, 2084, 2104, 2124, 2144, 2164, 2184, 2204, 2224, 2244, 2264, 2284, 2304, 2324, 2344, 2364, 2384, 2406, 2428, 2450, 2472, 2494, 2516, 2538, 2560, 2582, 2604, 2626, 2648, 2670, 2692, 2714, 2738, 2762, 2786, 2810, 2834, 2858, 2882, 2906, 2930, 2956, 2982, 3008, 3034, 3060, 3088, 3116, 3146, 3178, 3180, 3184, 3190, 3196, 3204, 3212, 3220, 3228, 3236, 3246, 3256, 3266, 3276, 3286, 3296, 3306, 3316, 3326, 3336, 3348, 3360, 3372, 3384, 3396, 3408, 3420, 3432, 3444, 3456, 3468, 3480, 3492, 3504, 3516, 3528, 3540, 3552, 3564, 3576, 3588, 3602, 3616, 3630, 3644, 3658, 3672, 3686, 3700, 3714, 3728, 3742, 3756, 3770, 3784, 3798, 3812, 3826, 3840, 3854, 3868, 3882, 3896, 3910, 3924, 3938, 3952, 3966, 3980, 3994, 4008, 4022, 4036, 4050, 4064, 4078, 4092, 4106, 4120, 4134, 4148, 4162, 4178, 4194, 4210, 4226, 4242, 4258, 4274, 4290, 4306, 4322, 4338, 4354, 4370, 4386, 4402, 4418, 4434, 4450, 4466, 4482, 4498, 4514, 4530, 4546, 4562, 4578, 4594, 4610, 4626, 4642, 4658, 4674, 4690, 4706, 4722, 4738, 4754, 4770, 4786, 4802, 4818, 4834, 4850, 4866, 4882, 4898, 4914, 4930, 4946, 4962, 4978, 4994, 5010, 5026, 5042, 5058, 5074, 5090, 5106, 5122, 5138, 5154, 5170, 5186, 5202, 5220, 5238, 5256, 5274, 5292, 5310, 5328, 5346, 5364, 5382, 5400, 5418, 5436, 5454, 5472, 5490, 5508, 5526, 5544, 5562, 5580, 5598, 5616, 5634, 5652, 5670, 5688, 5706, 5724, 5742, 5760, 5778, 5796, 5814, 5832, 5850, 5868, 5886, 5904, 5922, 5940, 5958, 5976, 5994, 6012, 6030, 6048, 6066, 6084, 6102, 6120, 6138, 6156, 6174, 6192, 6210, 6228, 6246, 6264, 6282, 6300, 6318, 6336, 6354, 6372, 6390, 6408, 6426, 6444, 6462, 6480, 6498, 6516, 6534, 6552, 6570, 6588, 6606, 6624, 6642, 6660, 6678, 6696, 6714, 6732, 6750, 6768, 6786, 6804, 6822, 6840, 6858, 6876, 6894, 6912, 6930, 6948, 6968, 6988, 7008, 7028, 7048, 7068, 7088, 7108, 7128, 7148, 7168, 7188, 7208, 7228, 7248, 7268, 7288, 7308, 7328, 7348, 7368, 7388, 7408, 7428, 7448, 7468, 7488, 7508, 7528, 7548, 7568, 7588, 7608, 7628, 7648, 7668, 7688, 7708, 7728, 7748, 7768, 7788, 7808, 7828, 7848, 7868, 7888, 7908, 7928, 7948, 7968, 7988, 8008, 8028, 8048, 8068, 8088, 8108, 8128, 8148, 8168, 8188, 8208, 8228, 8248, 8268, 8288, 8308, 8328, 8348, 8368, 8388, 8408, 8428, 8448, 8468, 8488, 8508, 8528, 8548, 8568, 8588, 8608, 8628, 8648, 8668, 8688, 8708, 8728, 8748, 8768, 8788, 8808, 8828, 8848, 8868, 8888, 8908, 8928, 8948, 8968, 8988, 9008, 9028, 9048, 9068, 9088, 9108, 9128, 9148, 9168, 9188, 9208, 9228, 9248, 9268, 9288, 9308, 9328, 9348, 9368, 9388, 9408, 9428, 9448, 9468, 9488, 9508, 9528, 9548, 9568, 9590, 9612, 9634, 9656, 9678, 9700, 9722, 9744, 9766, 9788, 9810, 9832, 9854, 9876, 9898, 9920, 9942, 9964, 9986, 10008, 10030, 10052, 10074, 10096, 10118, 10140, 10162, 10184, 10206, 10228, 10250, 10272, 10294, 10316, 10338, 10360, 10382, 10404, 10426, 10448, 10470, 10492, 10514, 10536, 10558, 10580, 10602, 10624, 10646, 10668, 10690, 10712, 10734, 10756, 10778, 10800, 10822, 10844, 10866, 10888, 10910, 10932, 10954, 10976, 10998, 11020, 11042, 11064, 11086, 11108, 11130, 11152, 11174, 11196, 11218, 11240, 11262, 11284, 11306, 11328, 11350, 11372, 11394, 11416, 11438, 11460, 11482, 11504, 11526, 11548, 11570, 11592, 11614, 11636, 11658, 11680, 11702, 11724, 11746, 11768, 11790, 11812, 11834, 11856, 11878, 11900, 11922, 11944, 11966, 11988, 12010, 12032, 12054, 12076, 12098, 12120, 12142, 12164, 12186, 12208, 12230, 12252, 12274, 12296, 12318, 12340, 12362, 12384, 12406, 12428, 12450, 12472, 12494, 12516, 12538, 12560, 12582, 12604, 12626, 12648, 12670, 12692, 12714, 12736, 12758, 12780, 12802, 12824, 12848, 12872, 12896, 12920, 12944, 12968, 12992, 13016, 13040, 13064, 13088, 13112, 13136, 13160, 13184, 13208, 13232, 13256, 13280, 13304, 13328, 13352, 13376, 13400, 13424, 13448, 13472, 13496, 13520, 13544, 13568, 13592, 13616, 13640, 13664, 13688, 13712, 13736, 13760, 13784, 13808, 13832, 13856, 13880, 13904, 13928, 13952, 13976, 14000, 14024, 14048, 14072, 14096, 14120, 14144, 14168, 14192, 14216, 14240, 14264, 14288, 14312, 14336, 14360, 14384, 14408, 14432, 14456, 14480, 14504, 14528, 14552, 14576, 14600, 14624, 14648, 14672, 14696, 14720, 14744, 14768, 14792, 14816, 14840, 14864, 14888, 14912, 14936, 14960, 14984, 15008, 15032, 15056, 15080, 15104, 15128, 15152, 15176, 15200, 15224, 15248, 15272, 15296, 15320, 15344, 15368, 15392, 15416, 15440, 15464, 15488, 15512, 15536, 15560, 15584, 15608, 15632, 15656, 15680, 15704, 15728, 15752, 15776, 15800, 15824, 15848, 15872, 15896, 15920, 15944, 15968, 15992, 16016, 16040, 16064, 16088, 16112, 16136, 16160, 16184, 16208, 16232, 16256, 16280, 16304, 16328, 16352, 16376, 16402, 16428, 16454, 16480, 16506, 16532, 16558, 16584, 16610, 16636, 16662, 16688, 16714, 16740, 16766, 16792, 16818, 16844, 16870, 16896, 16922, 16948, 16974, 17000, 17026, 17052, 17078, 17104, 17130, 17156, 17182, 17208, 17234, 17260, 17286, 17312, 17338, 17364, 17390, 17416, 17442, 17468, 17494, 17520, 17546, 17572, 17598, 17624, 17650, 17676, 17702, 17728, 17754, 17780, 17806, 17832, 17858, 17884, 17910, 17936, 17962, 17988, 18014, 18040, 18066, 18092, 18118, 18144, 18170, 18196, 18222, 18248, 18274, 18300, 18326, 18352, 18378, 18404, 18430, 18456, 18482, 18508, 18534, 18560, 18586, 18612, 18638, 18664, 18690, 18716, 18742, 18768, 18794, 18820, 18846, 18872, 18898, 18924, 18950, 18976, 19002, 19028, 19054, 19080, 19106, 19132, 19158, 19184, 19210, 19236, 19262, 19288, 19314, 19340, 19366, 19392, 19418, 19444, 19470, 19496, 19522, 19548, 19574, 19600, 19626, 19652, 19678, 19704, 19730, 19756, 19782, 19810, 19838, 19866, 19894, 19922, 19950, 19978, 20006, 20034, 20062, 20090, 20118, 20146, 20174, 20202, 20230, 20258, 20286, 20314, 20342, 20370, 20398, 20426, 20454, 20482, 20510, 20538, 20566, 20594, 20622, 20650, 20678, 20706, 20734, 20762, 20790, 20818, 20846, 20874, 20902, 20930, 20958, 20986, 21014, 21042, 21070, 21098, 21126, 21154, 21182, 21210, 21238, 21266, 21294, 21322, 21350, 21378, 21406, 21434, 21462, 21490, 21518, 21546, 21574, 21602, 21630, 21658, 21686, 21714, 21742, 21770, 21798, 21826, 21854, 21882, 21910, 21938, 21966, 21994, 22022, 22050, 22078, 22106, 22134, 22162, 22190, 22218, 22246, 22274, 22302, 22330, 22358, 22386, 22414, 22442, 22470, 22498, 22528, 22558, 22588, 22618, 22648, 22678, 22708, 22738, 22768, 22798, 22828, 22858, 22888, 22918, 22948, 22978, 23008, 23038, 23068, 23098, 23128, 23158, 23188, 23218, 23248, 23278, 23308, 23338, 23368, 23398, 23428, 23458, 23488, 23518, 23548, 23578, 23608, 23638, 23668, 23698, 23728, 23758, 23788, 23818, 23848, 23878, 23908, 23938, 23968, 23998, 24028, 24058, 24088, 24118, 24148, 24178, 24208, 24238, 24268, 24298, 24328, 24358, 24388, 24418, 24448, 24480, 24512, 24544, 24576, 24608, 24640, 24672, 24704, 24736, 24768, 24800, 24832, 24864, 24896, 24928, 24960, 24992, 25024, 25056, 25088, 25120, 25152, 25184, 25216, 25248, 25280, 25312, 25344, 25376, 25408, 25440, 25472, 25504, 25536, 25568, 25600, 25632, 25664, 25696, 25728, 25760, 25794, 25828, 25862, 25896, 25930, 25964, 25998, 26032, 26066, 26100, 26134, 26168, 26202, 26236, 26270, 26304, 26338, 26372, 26406, 26440, 26474, 26510, 26546, 26582, 26618, 26654, 26690, 26726, 26762, 26798, 26834, 26872, 26910, 26948, 26986, 27024, 27064, 27104, 27146};

__END_DECLS
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/atlas.c0000644000175100001710000000540200000000000024462 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R package.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "constructors/atlas-edges.h"

/**
 * \function igraph_atlas
 * \brief Create a small graph from the \quote Graph Atlas \endquote.
 *
 * 
 * The number of the graph is given as a parameter.
 * The graphs are listed: \olist
 *      \oli in increasing order of number of nodes;
 *      \oli for a fixed number of nodes, in increasing order of the
 *           number of edges;
 *      \oli for fixed numbers of nodes and edges, in increasing
 *           order of the degree sequence, for example 111223 < 112222;
 *      \oli for fixed degree sequence, in increasing number of
 *           automorphisms.
 *      \endolist
 *
 * 
 * The data was converted from the NetworkX software package,
 * see http://networkx.github.io .
 *
 * 
 * See \emb An Atlas of Graphs \eme by Ronald C. Read and Robin J. Wilson,
 * Oxford University Press, 1998.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param number The number of the graph to generate.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of
 * edges.
 *
 * \example examples/simple/igraph_atlas.c
 */
int igraph_atlas(igraph_t *graph, int number) {

    igraph_integer_t pos, n, e;
    igraph_vector_t v = IGRAPH_VECTOR_NULL;

    if (number < 0 ||
        number >= (int) (sizeof(igraph_i_atlas_edges_pos) / sizeof(long int))) {
        IGRAPH_ERROR("No such graph in atlas", IGRAPH_EINVAL);
    }

    pos = (igraph_integer_t) igraph_i_atlas_edges_pos[number];
    n = (igraph_integer_t) igraph_i_atlas_edges[pos];
    e = (igraph_integer_t) igraph_i_atlas_edges[pos + 1];

    IGRAPH_CHECK(igraph_create(graph,
                               igraph_vector_view(&v, igraph_i_atlas_edges + pos + 2,
                                       e * 2),
                               n, IGRAPH_UNDIRECTED));

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/basic_constructors.c0000644000175100001710000001165100000000000027272 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

/**
 * \section about_generators
 *
 * Graph generators create graphs.
 *
 * Almost all functions which create graph objects are documented
 * here. The exceptions are \ref igraph_induced_subgraph() and alike, these
 * create graphs based on another graph.
 */


/**
 * \ingroup generators
 * \function igraph_create
 * \brief Creates a graph with the specified edges.
 *
 * \param graph An uninitialized graph object.
 * \param edges The edges to add, the first two elements are the first
 *        edge, etc.
 * \param n The number of vertices in the graph, if smaller or equal
 *        to the highest vertex id in the \p edges vector it
 *        will be increased automatically. So it is safe to give 0
 *        here.
 * \param directed Boolean, whether to create a directed graph or
 *        not. If yes, then the first edge points from the first
 *        vertex id in \p edges to the second, etc.
 * \return Error code:
 *         \c IGRAPH_EINVEVECTOR: invalid edges
 *         vector (odd number of vertices).
 *         \c IGRAPH_EINVVID: invalid (negative)
 *         vertex id.
 *
 * Time complexity: O(|V|+|E|),
 * |V| is the number of vertices,
 * |E| the number of edges in the
 * graph.
 *
 * \example examples/simple/igraph_create.c
 */
int igraph_create(igraph_t *graph, const igraph_vector_t *edges,
                  igraph_integer_t n, igraph_bool_t directed) {
    igraph_bool_t has_edges = igraph_vector_size(edges) > 0;
    igraph_real_t max = has_edges ? igraph_vector_max(edges) + 1 : 0;

    if (igraph_vector_size(edges) % 2 != 0) {
        IGRAPH_ERROR("Invalid (odd) edges vector", IGRAPH_EINVEVECTOR);
    }
    if (has_edges && !igraph_vector_isininterval(edges, 0, max - 1)) {
        IGRAPH_ERROR("Invalid (negative) vertex id", IGRAPH_EINVVID);
    }

    IGRAPH_CHECK(igraph_empty(graph, n, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);
    if (has_edges) {
        igraph_integer_t vc = igraph_vcount(graph);
        if (vc < max) {
            IGRAPH_CHECK(igraph_add_vertices(graph, (igraph_integer_t) (max - vc), 0));
        }
        IGRAPH_CHECK(igraph_add_edges(graph, edges, 0));
    }

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_small
 * \brief Shorthand to create a small graph, giving the edges as arguments.
 *
 * 
 * This function is handy when a relatively small graph needs to be created.
 * Instead of giving the edges as a vector, they are given simply as
 * arguments and a '-1' needs to be given after the last meaningful
 * edge argument.
 *
 * Note that only graphs which have vertices less than
 * the highest value of the 'int' type can be created this way. If you
 * give larger values then the result is undefined.
 *
 * \param graph Pointer to an uninitialized graph object. The result
 *        will be stored here.
 * \param n The number of vertices in the graph; a nonnegative integer.
 * \param directed Logical constant; gives whether the graph should be
 *        directed. Supported values are:
 *        \clist
 *        \cli IGRAPH_DIRECTED
 *          The graph to be created will be \em directed.
 *        \cli IGRAPH_UNDIRECTED
 *          The graph to be created will be \em undirected.
 *        \endclist
 * \param ... The additional arguments giving the edges of the
 *        graph. Don't forget to supply an additional '-1' after the last
 *        (meaningful) argument.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges in the graph to create.
 *
 * \example examples/simple/igraph_small.c
 */

int igraph_small(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                 ...) {
    igraph_vector_t edges;
    va_list ap;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    va_start(ap, directed);
    while (1) {
        int num = va_arg(ap, int);
        if (num == -1) {
            break;
        }
        igraph_vector_push_back(&edges, num);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/de_bruijn.c0000644000175100001710000000623300000000000025322 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

/**
 * \function igraph_de_bruijn
 * \brief Generate a de Bruijn graph.
 *
 * A de Bruijn graph represents relationships between strings. An alphabet
 * of \c m letters are used and strings of length \c n are considered.
 * A vertex corresponds to every possible string and there is a directed edge
 * from vertex \c v to vertex \c w if the string of \c v can be transformed into
 * the string of \c w by removing its first letter and appending a letter to it.
 *
 * 
 * Please note that the graph will have \c m to the power \c n vertices and
 * even more edges, so probably you don't want to supply too big numbers for
 * \c m and \c n.
 *
 * 
 * De Bruijn graphs have some interesting properties, please see another source,
 * e.g. Wikipedia for details.
 *
 * \param graph Pointer to an uninitialized graph object, the result will be
 *        stored here.
 * \param m Integer, the number of letters in the alphabet.
 * \param n Integer, the length of the strings.
 * \return Error code.
 *
 * \sa \ref igraph_kautz().
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
 */
int igraph_de_bruijn(igraph_t *graph, igraph_integer_t m, igraph_integer_t n) {

    /* m - number of symbols */
    /* n - length of strings */

    long int no_of_nodes, no_of_edges;
    igraph_vector_t edges;
    long int i, j;
    long int mm = m;

    if (m < 0 || n < 0) {
        IGRAPH_ERROR("`m' and `n' should be non-negative in a de Bruijn graph",
                     IGRAPH_EINVAL);
    }

    if (n == 0) {
        return igraph_empty(graph, 1, IGRAPH_DIRECTED);
    }
    if (m == 0) {
        return igraph_empty(graph, 0, IGRAPH_DIRECTED);
    }

    no_of_nodes = (long int) pow(m, n);
    no_of_edges = no_of_nodes * m;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    for (i = 0; i < no_of_nodes; i++) {
        long int basis = (i * mm) % no_of_nodes;
        for (j = 0; j < m; j++) {
            igraph_vector_push_back(&edges, i);
            igraph_vector_push_back(&edges, basis + j);
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               IGRAPH_DIRECTED));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/famous.c0000644000175100001710000005274200000000000024661 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "igraph_constructors.h"

#include "internal/hacks.h"

const igraph_real_t igraph_i_famous_bull[] = {
    5, 5, 0,
    0, 1, 0, 2, 1, 2, 1, 3, 2, 4
};

const igraph_real_t igraph_i_famous_chvatal[] = {
    12, 24, 0,
    5, 6, 6, 7, 7, 8, 8, 9, 5, 9, 4, 5, 4, 8, 2, 8, 2, 6, 0, 6, 0, 9, 3, 9, 3, 7,
    1, 7, 1, 5, 1, 10, 4, 10, 4, 11, 2, 11, 0, 10, 0, 11, 3, 11, 3, 10, 1, 2
};

const igraph_real_t igraph_i_famous_coxeter[] = {
    28, 42, 0,
    0, 1, 0, 2, 0, 7, 1, 4, 1, 13, 2, 3, 2, 8, 3, 6, 3, 9, 4, 5, 4, 12, 5, 6, 5,
    11, 6, 10, 7, 19, 7, 24, 8, 20, 8, 23, 9, 14, 9, 22, 10, 15, 10, 21, 11, 16,
    11, 27, 12, 17, 12, 26, 13, 18, 13, 25, 14, 17, 14, 18, 15, 18, 15, 19, 16, 19,
    16, 20, 17, 20, 21, 23, 21, 26, 22, 24, 22, 27, 23, 25, 24, 26, 25, 27
};

const igraph_real_t igraph_i_famous_cubical[] = {
    8, 12, 0,
    0, 1, 1, 2, 2, 3, 0, 3, 4, 5, 5, 6, 6, 7, 4, 7, 0, 4, 1, 5, 2, 6, 3, 7
};

const igraph_real_t igraph_i_famous_diamond[] = {
    4, 5, 0,
    0, 1, 0, 2, 1, 2, 1, 3, 2, 3
};

const igraph_real_t igraph_i_famous_dodecahedron[] = {
    20, 30, 0,
    0, 1, 0, 4, 0, 5, 1, 2, 1, 6, 2, 3, 2, 7, 3, 4, 3, 8, 4, 9, 5, 10, 5, 11, 6,
    10, 6, 14, 7, 13, 7, 14, 8, 12, 8, 13, 9, 11, 9, 12, 10, 15, 11, 16, 12, 17,
    13, 18, 14, 19, 15, 16, 15, 19, 16, 17, 17, 18, 18, 19
};

const igraph_real_t igraph_i_famous_folkman[] = {
    20, 40, 0,
    0, 5, 0, 8, 0, 10, 0, 13, 1, 7, 1, 9, 1, 12, 1, 14, 2, 6, 2, 8, 2, 11, 2, 13,
    3, 5, 3, 7, 3, 10, 3, 12, 4, 6, 4, 9, 4, 11, 4, 14, 5, 15, 5, 19, 6, 15, 6, 16,
    7, 16, 7, 17, 8, 17, 8, 18, 9, 18, 9, 19, 10, 15, 10, 19, 11, 15, 11, 16, 12,
    16, 12, 17, 13, 17, 13, 18, 14, 18, 14, 19
};

const igraph_real_t igraph_i_famous_franklin[] = {
    12, 18, 0,
    0, 1, 0, 2, 0, 6, 1, 3, 1, 7, 2, 4, 2, 10, 3, 5, 3, 11, 4, 5, 4, 6, 5, 7, 6, 8,
    7, 9, 8, 9, 8, 11, 9, 10, 10, 11
};

const igraph_real_t igraph_i_famous_frucht[] = {
    12, 18, 0,
    0, 1, 0, 2, 0, 11, 1, 3, 1, 6, 2, 5, 2, 10, 3, 4, 3, 6, 4, 8, 4, 11, 5, 9, 5,
    10, 6, 7, 7, 8, 7, 9, 8, 9, 10, 11
};

const igraph_real_t igraph_i_famous_grotzsch[] = {
    11, 20, 0,
    0, 1, 0, 2, 0, 7, 0, 10, 1, 3, 1, 6, 1, 9, 2, 4, 2, 6, 2, 8, 3, 4, 3, 8, 3, 10,
    4, 7, 4, 9, 5, 6, 5, 7, 5, 8, 5, 9, 5, 10
};

const igraph_real_t igraph_i_famous_heawood[] = {
    14, 21, 0,
    0, 1, 0, 5, 0, 13, 1, 2, 1, 10, 2, 3, 2, 7, 3, 4, 3, 12, 4, 5, 4, 9, 5, 6, 6,
    7, 6, 11, 7, 8, 8, 9, 8, 13, 9, 10, 10, 11, 11, 12, 12, 13
};

const igraph_real_t igraph_i_famous_herschel[] = {
    11, 18, 0,
    0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 6, 1, 7, 2, 10, 3, 9, 4, 8, 4, 9, 5, 8,
    5, 10, 6, 8, 6, 9, 7, 8, 7, 10
};

const igraph_real_t igraph_i_famous_house[] = {
    5, 6, 0,
    0, 1, 0, 2, 1, 3, 2, 3, 2, 4, 3, 4
};

const igraph_real_t igraph_i_famous_housex[] = {
    5, 8, 0,
    0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3, 2, 4, 3, 4
};

const igraph_real_t igraph_i_famous_icosahedron[] = {
    12, 30, 0,
    0, 1, 0, 2, 0, 3, 0, 4, 0, 8, 1, 2, 1, 6, 1, 7, 1, 8, 2, 4, 2, 5, 2, 6, 3, 4,
    3, 8, 3, 9, 3, 11, 4, 5, 4, 11, 5, 6, 5, 10, 5, 11, 6, 7, 6, 10, 7, 8, 7, 9, 7,
    10, 8, 9, 9, 10, 9, 11, 10, 11
};

const igraph_real_t igraph_i_famous_krackhardt_kite[] = {
    10, 18, 0,
    0, 1, 0, 2, 0, 3, 0, 5, 1, 3, 1, 4, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6, 5, 7, 6, 7, 7, 8, 8, 9
};

const igraph_real_t igraph_i_famous_levi[] = {
    30, 45, 0,
    0, 1, 0, 7, 0, 29, 1, 2, 1, 24, 2, 3, 2, 11, 3, 4, 3, 16, 4, 5, 4, 21, 5, 6, 5,
    26, 6, 7, 6, 13, 7, 8, 8, 9, 8, 17, 9, 10, 9, 22, 10, 11, 10, 27, 11, 12, 12,
    13, 12, 19, 13, 14, 14, 15, 14, 23, 15, 16, 15, 28, 16, 17, 17, 18, 18, 19, 18,
    25, 19, 20, 20, 21, 20, 29, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
    28, 28, 29
};

const igraph_real_t igraph_i_famous_mcgee[] = {
    24, 36, 0,
    0, 1, 0, 7, 0, 23, 1, 2, 1, 18, 2, 3, 2, 14, 3, 4, 3, 10, 4, 5, 4, 21, 5, 6, 5,
    17, 6, 7, 6, 13, 7, 8, 8, 9, 8, 20, 9, 10, 9, 16, 10, 11, 11, 12, 11, 23, 12,
    13, 12, 19, 13, 14, 14, 15, 15, 16, 15, 22, 16, 17, 17, 18, 18, 19, 19, 20, 20,
    21, 21, 22, 22, 23
};

const igraph_real_t igraph_i_famous_meredith[] = {
    70, 140, 0,
    0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 6, 2, 4, 2, 5, 2, 6, 3, 4, 3, 5, 3, 6, 7, 11,
    7, 12, 7, 13, 8, 11, 8, 12, 8, 13, 9, 11, 9, 12, 9, 13, 10, 11, 10, 12, 10, 13,
    14, 18, 14, 19, 14, 20, 15, 18, 15, 19, 15, 20, 16, 18, 16, 19, 16, 20, 17, 18,
    17, 19, 17, 20, 21, 25, 21, 26, 21, 27, 22, 25, 22, 26, 22, 27, 23, 25, 23, 26,
    23, 27, 24, 25, 24, 26, 24, 27, 28, 32, 28, 33, 28, 34, 29, 32, 29, 33, 29, 34,
    30, 32, 30, 33, 30, 34, 31, 32, 31, 33, 31, 34, 35, 39, 35, 40, 35, 41, 36, 39,
    36, 40, 36, 41, 37, 39, 37, 40, 37, 41, 38, 39, 38, 40, 38, 41, 42, 46, 42, 47,
    42, 48, 43, 46, 43, 47, 43, 48, 44, 46, 44, 47, 44, 48, 45, 46, 45, 47, 45, 48,
    49, 53, 49, 54, 49, 55, 50, 53, 50, 54, 50, 55, 51, 53, 51, 54, 51, 55, 52, 53,
    52, 54, 52, 55, 56, 60, 56, 61, 56, 62, 57, 60, 57, 61, 57, 62, 58, 60, 58, 61,
    58, 62, 59, 60, 59, 61, 59, 62, 63, 67, 63, 68, 63, 69, 64, 67, 64, 68, 64, 69,
    65, 67, 65, 68, 65, 69, 66, 67, 66, 68, 66, 69, 2, 50, 1, 51, 9, 57, 8, 58, 16,
    64, 15, 65, 23, 36, 22, 37, 30, 43, 29, 44, 3, 21, 7, 24, 14, 31, 0, 17, 10,
    28, 38, 42, 35, 66, 59, 63, 52, 56, 45, 49
};

const igraph_real_t igraph_i_famous_noperfectmatching[] = {
    16, 27, 0,
    0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3, 2, 4, 3, 4, 4, 5, 5, 6, 5, 7, 6, 12, 6, 13,
    7, 8, 7, 9, 8, 9, 8, 10, 8, 11, 9, 10, 9, 11, 10, 11, 12, 13, 12, 14, 12, 15,
    13, 14, 13, 15, 14, 15
};

const igraph_real_t igraph_i_famous_nonline[] = {
    50, 72, 0,
    0, 1, 0, 2, 0, 3, 4, 6, 4, 7, 5, 6, 5, 7, 6, 7, 7, 8, 9, 11, 9, 12, 9, 13, 10,
    11, 10, 12, 10, 13, 11, 12, 11, 13, 12, 13, 14, 15, 15, 16, 15, 17, 16, 17, 16,
    18, 17, 18, 18, 19, 20, 21, 20, 22, 20, 23, 21, 22, 21, 23, 21, 24, 22, 23, 22,
    24, 24, 25, 26, 27, 26, 28, 26, 29, 27, 28, 27, 29, 27, 30, 27, 31, 28, 29, 28,
    30, 28, 31, 30, 31, 32, 34, 32, 35, 32, 36, 33, 34, 33, 35, 33, 37, 34, 35, 36,
    37, 38, 39, 38, 40, 38, 43, 39, 40, 39, 41, 39, 42, 39, 43, 40, 41, 41, 42, 42,
    43, 44, 45, 44, 46, 45, 46, 45, 47, 46, 47, 46, 48, 47, 48, 47, 49, 48, 49
};

const igraph_real_t igraph_i_famous_octahedron[] = {
    6, 12, 0,
    0, 1, 0, 2, 1, 2, 3, 4, 3, 5, 4, 5, 0, 3, 0, 5, 1, 3, 1, 4, 2, 4, 2, 5
};

const igraph_real_t igraph_i_famous_petersen[] = {
    10, 15, 0,
    0, 1, 0, 4, 0, 5, 1, 2, 1, 6, 2, 3, 2, 7, 3, 4, 3, 8, 4, 9, 5, 7, 5, 8, 6, 8, 6, 9, 7, 9
};

const igraph_real_t igraph_i_famous_robertson[] = {
    19, 38, 0,
    0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12,
    12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 0, 18, 0, 4, 4, 9, 9, 13, 13,
    17, 2, 17, 2, 6, 6, 10, 10, 15, 0, 15, 1, 8, 8, 16, 5, 16, 5, 12, 1, 12, 7, 18,
    7, 14, 3, 14, 3, 11, 11, 18
};

const igraph_real_t igraph_i_famous_smallestcyclicgroup[] = {
    9, 15, 0,
    0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 1, 2, 1, 3, 1, 7, 1, 8, 2, 5, 2, 6, 2, 7, 3, 8,
    4, 5, 6, 7
};

const igraph_real_t igraph_i_famous_tetrahedron[] = {
    4, 6, 0,
    0, 3, 1, 3, 2, 3, 0, 1, 1, 2, 0, 2
};

const igraph_real_t igraph_i_famous_thomassen[] = {
    34, 52, 0,
    0, 2, 0, 3, 1, 3, 1, 4, 2, 4, 5, 7, 5, 8, 6, 8, 6, 9, 7, 9, 10, 12, 10, 13, 11,
    13, 11, 14, 12, 14, 15, 17, 15, 18, 16, 18, 16, 19, 17, 19, 9, 19, 4, 14, 24,
    25, 25, 26, 20, 26, 20, 21, 21, 22, 22, 23, 23, 27, 27, 28, 28, 29, 29, 30, 30,
    31, 31, 32, 32, 33, 24, 33, 5, 24, 6, 25, 7, 26, 8, 20, 0, 20, 1, 21, 2, 22, 3,
    23, 10, 27, 11, 28, 12, 29, 13, 30, 15, 30, 16, 31, 17, 32, 18, 33
};

const igraph_real_t igraph_i_famous_tutte[] = {
    46, 69, 0,
    0, 10, 0, 11, 0, 12, 1, 2, 1, 7, 1, 19, 2, 3, 2, 41, 3, 4, 3, 27, 4, 5, 4, 33,
    5, 6, 5, 45, 6, 9, 6, 29, 7, 8, 7, 21, 8, 9, 8, 22, 9, 24, 10, 13, 10, 14, 11,
    26, 11, 28, 12, 30, 12, 31, 13, 15, 13, 21, 14, 15, 14, 18, 15, 16, 16, 17, 16,
    20, 17, 18, 17, 23, 18, 24, 19, 25, 19, 40, 20, 21, 20, 22, 22, 23, 23, 24, 25,
    26, 25, 38, 26, 34, 27, 28, 27, 39, 28, 34, 29, 30, 29, 44, 30, 35, 31, 32, 31,
    35, 32, 33, 32, 42, 33, 43, 34, 36, 35, 37, 36, 38, 36, 39, 37, 42, 37, 44, 38,
    40, 39, 41, 40, 41, 42, 43, 43, 45, 44, 45
};

const igraph_real_t igraph_i_famous_uniquely3colorable[] = {
    12, 22, 0,
    0, 1, 0, 3, 0, 6, 0, 8, 1, 4, 1, 7, 1, 9, 2, 3, 2, 6, 2, 7, 2, 9, 2, 11, 3, 4,
    3, 10, 4, 5, 4, 11, 5, 6, 5, 7, 5, 8, 5, 10, 8, 11, 9, 10
};

const igraph_real_t igraph_i_famous_walther[] = {
    25, 31, 0,
    0, 1, 1, 2, 1, 8, 2, 3, 2, 13, 3, 4, 3, 16, 4, 5, 5, 6, 5, 19, 6, 7, 6, 20, 7,
    21, 8, 9, 8, 13, 9, 10, 9, 22, 10, 11, 10, 20, 11, 12, 13, 14, 14, 15, 14, 23,
    15, 16, 15, 17, 17, 18, 18, 19, 18, 24, 20, 24, 22, 23, 23, 24
};

const igraph_real_t igraph_i_famous_zachary[] = {
    34, 78, 0,
    0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
    0, 10, 0, 11, 0, 12, 0, 13, 0, 17, 0, 19, 0, 21, 0, 31,
    1, 2, 1, 3, 1, 7, 1, 13, 1, 17, 1, 19, 1, 21, 1, 30,
    2, 3, 2, 7, 2, 27, 2, 28, 2, 32, 2, 9, 2, 8, 2, 13,
    3, 7, 3, 12, 3, 13, 4, 6, 4, 10, 5, 6, 5, 10, 5, 16,
    6, 16, 8, 30, 8, 32, 8, 33, 9, 33, 13, 33, 14, 32, 14, 33,
    15, 32, 15, 33, 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
    22, 32, 22, 33, 23, 25, 23, 27, 23, 32, 23, 33, 23, 29,
    24, 25, 24, 27, 24, 31, 25, 31, 26, 29, 26, 33, 27, 33,
    28, 31, 28, 33, 29, 32, 29, 33, 30, 32, 30, 33, 31, 32, 31, 33,
    32, 33
};

static int igraph_i_famous(igraph_t *graph, const igraph_real_t *data) {
    long int no_of_nodes = (long int) data[0];
    long int no_of_edges = (long int) data[1];
    igraph_bool_t directed = (igraph_bool_t) data[2];
    igraph_vector_t edges;

    igraph_vector_view(&edges, data + 3, 2 * no_of_edges);
    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    return 0;
}

/**
 * \function igraph_famous
 * \brief Create a famous graph by simply providing its name.
 *
 * 
 * The name of the graph can be simply supplied as a string.
 * Note that this function creates graphs which don't take any parameters,
 * there are separate functions for graphs with parameters, e.g. \ref
 * igraph_full() for creating a full graph.
 *
 * 
 * The following graphs are supported:
 * \clist
 *   \cli Bull
 *           The bull graph, 5 vertices, 5 edges, resembles the
 *           head of a bull if drawn properly.
 *   \cli Chvatal
 *           This is the smallest triangle-free graph that is
 *           both 4-chromatic and 4-regular. According to the Grunbaum
 *           conjecture there exists an m-regular, m-chromatic graph
 *           with n vertices for every m>1 and n>2. The Chvatal graph
 *           is an example for m=4 and n=12. It has 24 edges.
 *   \cli Coxeter
 *           A non-Hamiltonian cubic symmetric graph with 28
 *           vertices and 42 edges.
 *   \cli Cubical
 *           The Platonic graph of the cube. A convex regular
 *           polyhedron with 8 vertices and 12 edges.
 *   \cli Diamond
 *           A graph with 4 vertices and 5 edges, resembles a
 *           schematic diamond if drawn properly.
 *   \cli Dodecahedral, Dodecahedron
 *           Another Platonic solid
 *           with 20 vertices and 30 edges.
 *   \cli Folkman
 *           The semisymmetric graph with minimum number of
 *           vertices, 20 and 40 edges. A semisymmetric graph is
 *           regular, edge transitive and not vertex transitive.
 *   \cli Franklin
 *           This is a graph whose embedding to the Klein
 *           bottle can be colored with six colors, it is a
 *           counterexample to the necessity of the Heawood
 *           conjecture on a Klein bottle. It has 12 vertices and 18
 *           edges.
 *   \cli Frucht
 *           The Frucht Graph is the smallest cubical graph
 *           whose automorphism group consists only of the identity
 *           element. It has 12 vertices and 18 edges.
 *   \cli Grotzsch
 *           The Grötzsch graph is a triangle-free graph with
 *           11 vertices, 20 edges, and chromatic number 4. It is named after
 *           German mathematician Herbert Grötzsch, and its existence
 *           demonstrates that the assumption of planarity is necessary in
 *           Grötzsch's theorem that every triangle-free planar
 *           graph is 3-colorable.
 *   \cli Heawood
 *           The Heawood graph is an undirected graph with 14
 *           vertices and 21 edges. The graph is cubic, and all cycles in the
 *           graph have six or more edges. Every smaller cubic graph has shorter
 *           cycles, so this graph is the 6-cage, the smallest cubic graph of
 *           girth 6.
 *   \cli Herschel
 *           The Herschel graph is the smallest
 *           nonhamiltonian polyhedral graph. It is the
 *           unique such graph on 11 nodes, and has 18 edges.
 *   \cli House
 *           The house graph is a 5-vertex, 6-edge graph, the
 *           schematic draw of a house if drawn properly, basically a
 *           triangle on top of a square.
 *   \cli HouseX
 *           The same as the house graph with an X in the square. 5
 *           vertices and 8 edges.
 *   \cli Icosahedral, Icosahedron
 *           A Platonic solid with 12
 *           vertices and 30 edges.
 *   \cli Krackhardt_Kite
 *           A social network with 10 vertices and 18 edges.
 *           Krackhardt, D. Assessing the Political Landscape:
 *           Structure, Cognition, and Power in Organizations.
 *           Admin. Sci. Quart. 35, 342-369, 1990.
 *   \cli Levi
 *           The graph is a 4-arc transitive cubic graph, it has
 *           30 vertices and 45 edges.
 *   \cli McGee
 *           The McGee graph is the unique 3-regular 7-cage
 *           graph, it has 24 vertices and 36 edges.
 *   \cli Meredith
 *           The Meredith graph is a quartic graph on 70
 *           nodes and 140 edges that is a counterexample to the conjecture that
 *           every 4-regular 4-connected graph is Hamiltonian.
 *   \cli Noperfectmatching
 *           A connected graph with 16 vertices and
 *           27 edges containing no perfect matching. A matching in a graph
 *           is a set of pairwise non-incident edges; that is, no two edges
 *           share a common vertex. A perfect matching is a matching
 *           which covers all vertices of the graph.
 *   \cli Nonline
 *           A graph whose connected components are the 9
 *           graphs whose presence as a vertex-induced subgraph in a
 *           graph makes a nonline graph. It has 50 vertices and 72 edges.
 *   \cli Octahedral, Octahedron
 *           Platonic solid with 6
 *           vertices and 12 edges.
 *   \cli Petersen
 *           A 3-regular graph with 10 vertices and 15 edges. It is
 *           the smallest hypohamiltonian graph, i.e. it is
 *           non-hamiltonian but removing any single vertex from it makes it
 *           Hamiltonian.
 *   \cli Robertson
 *           The unique (4,5)-cage graph, i.e. a 4-regular
 *           graph of girth 5. It has 19 vertices and 38 edges.
 *   \cli Smallestcyclicgroup
 *           A smallest nontrivial graph
 *           whose automorphism group is cyclic. It has 9 vertices and
 *           15 edges.
 *   \cli Tetrahedral, Tetrahedron
 *           Platonic solid with 4
 *           vertices and 6 edges.
 *   \cli Thomassen
 *           The smallest hypotraceable graph,
 *           on 34 vertices and 52 edges. A hypotracable graph does
 *           not contain a Hamiltonian path but after removing any
 *           single vertex from it the remainder always contains a
 *           Hamiltonian path. A graph containing a Hamiltonian path
 *           is called traceable.
 *   \cli Tutte
 *           Tait's Hamiltonian graph conjecture states that
 *           every 3-connected 3-regular planar graph is Hamiltonian.
 *           This graph is a counterexample. It has 46 vertices and 69
 *           edges.
 *   \cli Uniquely3colorable
 *           Returns a 12-vertex, triangle-free
 *           graph with chromatic number 3 that is uniquely
 *           3-colorable.
 *   \cli Walther
 *           An identity graph with 25 vertices and 31
 *           edges. An identity graph has a single graph automorphism,
 *           the trivial one.
 *   \cli Zachary
 *           Social network of friendships between 34 members of a
 *           karate club at a US university in the 1970s. See
 *           W. W. Zachary, An information flow model for conflict and
 *           fission in small groups, Journal of Anthropological
 *           Research 33, 452-473 (1977).
 * \endclist
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param name Character constant, the name of the graph to be
 *     created, it is case insensitive.
 * \return Error code, \c IGRAPH_EINVAL if there is no graph with the
 *     given name.
 *
 * \sa Other functions for creating graph structures:
 * \ref igraph_ring(), \ref igraph_tree(), \ref igraph_lattice(), \ref
 * igraph_full().
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges in the graph.
 */

int igraph_famous(igraph_t *graph, const char *name) {

    if (!strcasecmp(name, "bull")) {
        return igraph_i_famous(graph, igraph_i_famous_bull);
    } else if (!strcasecmp(name, "chvatal")) {
        return igraph_i_famous(graph, igraph_i_famous_chvatal);
    } else if (!strcasecmp(name, "coxeter")) {
        return igraph_i_famous(graph, igraph_i_famous_coxeter);
    } else if (!strcasecmp(name, "cubical")) {
        return igraph_i_famous(graph, igraph_i_famous_cubical);
    } else if (!strcasecmp(name, "diamond")) {
        return igraph_i_famous(graph, igraph_i_famous_diamond);
    } else if (!strcasecmp(name, "dodecahedral") ||
               !strcasecmp(name, "dodecahedron")) {
        return igraph_i_famous(graph, igraph_i_famous_dodecahedron);
    } else if (!strcasecmp(name, "folkman")) {
        return igraph_i_famous(graph, igraph_i_famous_folkman);
    } else if (!strcasecmp(name, "franklin")) {
        return igraph_i_famous(graph, igraph_i_famous_franklin);
    } else if (!strcasecmp(name, "frucht")) {
        return igraph_i_famous(graph, igraph_i_famous_frucht);
    } else if (!strcasecmp(name, "grotzsch")) {
        return igraph_i_famous(graph, igraph_i_famous_grotzsch);
    } else if (!strcasecmp(name, "heawood")) {
        return igraph_i_famous(graph, igraph_i_famous_heawood);
    } else if (!strcasecmp(name, "herschel")) {
        return igraph_i_famous(graph, igraph_i_famous_herschel);
    } else if (!strcasecmp(name, "house")) {
        return igraph_i_famous(graph, igraph_i_famous_house);
    } else if (!strcasecmp(name, "housex")) {
        return igraph_i_famous(graph, igraph_i_famous_housex);
    } else if (!strcasecmp(name, "icosahedral") ||
               !strcasecmp(name, "icosahedron")) {
        return igraph_i_famous(graph, igraph_i_famous_icosahedron);
    } else if (!strcasecmp(name, "krackhardt_kite")) {
        return igraph_i_famous(graph, igraph_i_famous_krackhardt_kite);
    } else if (!strcasecmp(name, "levi")) {
        return igraph_i_famous(graph, igraph_i_famous_levi);
    } else if (!strcasecmp(name, "mcgee")) {
        return igraph_i_famous(graph, igraph_i_famous_mcgee);
    } else if (!strcasecmp(name, "meredith")) {
        return igraph_i_famous(graph, igraph_i_famous_meredith);
    } else if (!strcasecmp(name, "noperfectmatching")) {
        return igraph_i_famous(graph, igraph_i_famous_noperfectmatching);
    } else if (!strcasecmp(name, "nonline")) {
        return igraph_i_famous(graph, igraph_i_famous_nonline);
    } else if (!strcasecmp(name, "octahedral") ||
               !strcasecmp(name, "octahedron")) {
        return igraph_i_famous(graph, igraph_i_famous_octahedron);
    } else if (!strcasecmp(name, "petersen")) {
        return igraph_i_famous(graph, igraph_i_famous_petersen);
    } else if (!strcasecmp(name, "robertson")) {
        return igraph_i_famous(graph, igraph_i_famous_robertson);
    } else if (!strcasecmp(name, "smallestcyclicgroup")) {
        return igraph_i_famous(graph, igraph_i_famous_smallestcyclicgroup);
    } else if (!strcasecmp(name, "tetrahedral") ||
               !strcasecmp(name, "tetrahedron")) {
        return igraph_i_famous(graph, igraph_i_famous_tetrahedron);
    } else if (!strcasecmp(name, "thomassen")) {
        return igraph_i_famous(graph, igraph_i_famous_thomassen);
    } else if (!strcasecmp(name, "tutte")) {
        return igraph_i_famous(graph, igraph_i_famous_tutte);
    } else if (!strcasecmp(name, "uniquely3colorable")) {
        return igraph_i_famous(graph, igraph_i_famous_uniquely3colorable);
    } else if (!strcasecmp(name, "walther")) {
        return igraph_i_famous(graph, igraph_i_famous_walther);
    } else if (!strcasecmp(name, "zachary")) {
        return igraph_i_famous(graph, igraph_i_famous_zachary);
    }

    IGRAPH_ERRORF("%s is not a known graph. See the documentation for valid graph names.", IGRAPH_EINVAL, name);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/full.c0000644000175100001710000001257300000000000024327 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

/**
 * \ingroup generators
 * \function igraph_full
 * \brief Creates a full graph (directed or undirected, with or without loops).
 *
 * 
 * In a full graph every possible edge is present, every vertex is
 * connected to every other vertex. A full graph in \c igraph should be
 * distinguished from the concept of complete graphs as used in graph theory.
 * If n is a positive integer, then the complete graph K_n on n vertices is
 * the undirected simple graph with the following property. For any distinct
 * pair (u,v) of vertices in K_n, uv (or equivalently vu) is an edge of K_n.
 * In \c igraph, a full graph on n vertices can be K_n, a directed version of
 * K_n, or K_n with at least one loop edge. In any case, if F is a full graph
 * on n vertices as generated by \c igraph, then K_n is a subgraph of the
 * undirected version of F.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param n Integer, the number of vertices in the graph.
 * \param directed Logical, whether to create a directed graph.
 * \param loops Logical, whether to include self-edges (loops).
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of vertices.
 *
 * Time complexity: O(|V|+|E|),
 * |V| is the number of vertices,
 * |E| the number of edges in the
 * graph. Of course this is the same as
 * O(|E|)=O(|V||V|)
 * here.
 *
 * \sa \ref igraph_lattice(), \ref igraph_star(), \ref igraph_tree()
 * for creating other regular structures.
 *
 * \example examples/simple/igraph_full.c
 */
int igraph_full(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                igraph_bool_t loops) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int i, j;

    if (n < 0) {
        IGRAPH_ERROR("invalid number of vertices", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    if (directed && loops) {
        IGRAPH_CHECK(igraph_vector_reserve(&edges, n * n));
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                igraph_vector_push_back(&edges, i); /* reserved */
                igraph_vector_push_back(&edges, j); /* reserved */
            }
        }
    } else if (directed && !loops) {
        IGRAPH_CHECK(igraph_vector_reserve(&edges, n * (n - 1)));
        for (i = 0; i < n; i++) {
            for (j = 0; j < i; j++) {
                igraph_vector_push_back(&edges, i); /* reserved */
                igraph_vector_push_back(&edges, j); /* reserved */
            }
            for (j = i + 1; j < n; j++) {
                igraph_vector_push_back(&edges, i); /* reserved */
                igraph_vector_push_back(&edges, j); /* reserved */
            }
        }
    } else if (!directed && loops) {
        IGRAPH_CHECK(igraph_vector_reserve(&edges, n * (n + 1) / 2));
        for (i = 0; i < n; i++) {
            for (j = i; j < n; j++) {
                igraph_vector_push_back(&edges, i); /* reserved */
                igraph_vector_push_back(&edges, j); /* reserved */
            }
        }
    } else {
        IGRAPH_CHECK(igraph_vector_reserve(&edges, n * (n - 1) / 2));
        for (i = 0; i < n; i++) {
            for (j = i + 1; j < n; j++) {
                igraph_vector_push_back(&edges, i); /* reserved */
                igraph_vector_push_back(&edges, j); /* reserved */
            }
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_full_citation
 * Creates a full citation graph
 *
 * This is a directed graph, where every i->j edge is
 * present if and only if j<i.
 * If the \c directed argument is zero then an undirected graph is
 * created, and it is just a full graph.
 * \param graph Pointer to an uninitialized graph object, the result
 *    is stored here.
 * \param n The number of vertices.
 * \param directed Whether to created a directed graph. If zero an
 *    undirected graph is created.
 * \return Error code.
 *
 * Time complexity: O(|V|^2), as we have many edges.
 */
int igraph_full_citation(igraph_t *graph, igraph_integer_t n,
                         igraph_bool_t directed) {
    igraph_vector_t edges;
    long int i, j, ptr = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, n * (n - 1));
    for (i = 1; i < n; i++) {
        for (j = 0; j < i; j++) {
            VECTOR(edges)[ptr++] = i;
            VECTOR(edges)[ptr++] = j;
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/kautz.c0000644000175100001710000001405300000000000024516 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

/**
 * \function igraph_kautz
 * \brief Generate a Kautz graph.
 *
 * A Kautz graph is a labeled graph, vertices are labeled by strings
 * of length \c n+1 above an alphabet with \c m+1 letters, with
 * the restriction that every two consecutive letters in the string
 * must be different. There is a directed edge from a vertex \c v to
 * another vertex \c w if it is possible to transform the string of
 * \c v into the string of \c w by removing the first letter and
 * appending a letter to it. For string length 1 the new letter
 * cannot equal the old letter, so there are no loops.
 *
 * 
 * Kautz graphs have some interesting properties, see e.g. Wikipedia
 * for details.
 *
 * 
 * Vincent Matossian wrote the first version of this function in R,
 * thanks.
 * \param graph Pointer to an uninitialized graph object, the result
 * will be stored here.
 * \param m Integer, \c m+1 is the number of letters in the alphabet.
 * \param n Integer, \c n+1 is the length of the strings.
 * \return Error code.
 *
 * \sa \ref igraph_de_bruijn().
 *
 * Time complexity: O(|V|* [(m+1)/m]^n +|E|), in practice it is more
 * like O(|V|+|E|). |V| is the number of vertices, |E| is the number
 * of edges and \c m and \c n are the corresponding arguments.
 */
int igraph_kautz(igraph_t *graph, igraph_integer_t m, igraph_integer_t n) {

    /* m+1 - number of symbols */
    /* n+1 - length of strings */

    long int mm = m;
    long int no_of_nodes, no_of_edges;
    long int allstrings;
    long int i, j, idx = 0;
    igraph_vector_t edges;
    igraph_vector_long_t digits, table;
    igraph_vector_long_t index1, index2;
    long int actb = 0;
    long int actvalue = 0;

    if (m < 0 || n < 0) {
        IGRAPH_ERROR("`m' and `n' should be non-negative in a Kautz graph",
                     IGRAPH_EINVAL);
    }

    if (n == 0) {
        return igraph_full(graph, m + 1, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    }
    if (m == 0) {
        return igraph_empty(graph, 0, IGRAPH_DIRECTED);
    }

    no_of_nodes = (long int) ((m + 1) * pow(m, n));
    no_of_edges = no_of_nodes * m;
    allstrings = (long int) pow(m + 1, n + 1);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    IGRAPH_CHECK(igraph_vector_long_init(&table, n + 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &table);
    j = 1;
    for (i = n; i >= 0; i--) {
        VECTOR(table)[i] = j;
        j *= (m + 1);
    }

    IGRAPH_CHECK(igraph_vector_long_init(&digits, n + 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &digits);
    IGRAPH_CHECK(igraph_vector_long_init(&index1, (long int) pow(m + 1, n + 1)));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &index1);
    IGRAPH_CHECK(igraph_vector_long_init(&index2, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &index2);

    /* Fill the index tables*/
    while (1) {
        /* at the beginning of the loop, 0:actb contain the valid prefix */
        /* we might need to fill it to get a valid string */
        long int z = 0;
        if (VECTOR(digits)[actb] == 0) {
            z = 1;
        }
        for (actb++; actb <= n; actb++) {
            VECTOR(digits)[actb] = z;
            actvalue += z * VECTOR(table)[actb];
            z = 1 - z;
        }
        actb = n;

        /* ok, we have a valid string now */
        VECTOR(index1)[actvalue] = idx + 1;
        VECTOR(index2)[idx] = actvalue;
        idx++;

        /* finished? */
        if (idx >= no_of_nodes) {
            break;
        }

        /* not yet, we need a valid prefix now */
        while (1) {
            /* try to increase digits at position actb */
            long int next = VECTOR(digits)[actb] + 1;
            if (actb != 0 && VECTOR(digits)[actb - 1] == next) {
                next++;
            }
            if (next <= m) {
                /* ok, no problem */
                actvalue += (next - VECTOR(digits)[actb]) * VECTOR(table)[actb];
                VECTOR(digits)[actb] = next;
                break;
            } else {
                /* bad luck, try the previous digit */
                actvalue -= VECTOR(digits)[actb] * VECTOR(table)[actb];
                actb--;
            }
        }
    }

    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    /* Now come the edges at last */
    for (i = 0; i < no_of_nodes; i++) {
        long int fromvalue = VECTOR(index2)[i];
        long int lastdigit = fromvalue % (mm + 1);
        long int basis = (fromvalue * (mm + 1)) % allstrings;
        for (j = 0; j <= m; j++) {
            long int tovalue, to;
            if (j == lastdigit) {
                continue;
            }
            tovalue = basis + j;
            to = VECTOR(index1)[tovalue] - 1;
            if (to < 0) {
                continue;
            }
            igraph_vector_push_back(&edges, i);
            igraph_vector_push_back(&edges, to);
        }
    }

    igraph_vector_long_destroy(&index2);
    igraph_vector_long_destroy(&index1);
    igraph_vector_long_destroy(&digits);
    igraph_vector_long_destroy(&table);
    IGRAPH_FINALLY_CLEAN(4);

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               IGRAPH_DIRECTED));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/lcf.c0000644000175100001710000001105600000000000024124 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_operators.h"

/**
 * \function igraph_lcf_vector
 * \brief Creates a graph from LCF notation.
 *
 * This function is essentially the same as \ref igraph_lcf(), only
 * the way for giving the arguments is different. See \ref
 * igraph_lcf() for details.
 * \param graph Pointer to an uninitialized graph object.
 * \param n Integer constant giving the number of vertices.
 * \param shifts A vector giving the shifts.
 * \param repeats An integer constant giving the number of repeats
 *        for the shifts.
 * \return Error code.
 *
 * \sa \ref igraph_lcf(), \ref igraph_extended_chordal_ring()
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices plus
 * the number of edges.
 */
int igraph_lcf_vector(igraph_t *graph, igraph_integer_t n,
                      const igraph_vector_t *shifts,
                      igraph_integer_t repeats) {

    igraph_vector_t edges;
    long int no_of_shifts = igraph_vector_size(shifts);
    long int ptr = 0, i, sptr = 0;
    long int no_of_nodes = n;
    long int no_of_edges = n + no_of_shifts * repeats;

    if (repeats < 0) {
        IGRAPH_ERROR("number of repeats must be positive", IGRAPH_EINVAL);
    }
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * no_of_edges);

    if (no_of_nodes > 0) {
        /* Create a ring first */
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(edges)[ptr++] = i;
            VECTOR(edges)[ptr++] = i + 1;
        }
        VECTOR(edges)[ptr - 1] = 0;
    }

    /* Then add the rest */
    while (ptr < 2 * no_of_edges) {
        long int sh = (long int) VECTOR(*shifts)[sptr % no_of_shifts];
        long int from = sptr % no_of_nodes;
        long int to = (no_of_nodes + sptr + sh) % no_of_nodes;
        VECTOR(edges)[ptr++] = from;
        VECTOR(edges)[ptr++] = to;
        sptr++;
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               IGRAPH_UNDIRECTED));
    IGRAPH_CHECK(igraph_simplify(graph, 1 /* true */, 1 /* true */, NULL));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_lcf
 * \brief Creates a graph from LCF notation.
 *
 * 
 * LCF is short for Lederberg-Coxeter-Frucht, it is a concise notation for
 * 3-regular Hamiltonian graphs. It consists of three parameters: the
 * number of vertices in the graph, a list of shifts giving additional
 * edges to a cycle backbone, and another integer giving how many times
 * the shifts should be performed. See
 * http://mathworld.wolfram.com/LCFNotation.html for details.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param n Integer, the number of vertices in the graph.
 * \param ... The shifts and the number of repeats for the shifts,
 *        plus an additional 0 to mark the end of the arguments.
 * \return Error code.
 *
 * \sa See \ref igraph_lcf_vector() for a similar function using a
 * vector_t instead of the variable length argument list.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 *
 * \example examples/simple/igraph_lcf.c
 */
int igraph_lcf(igraph_t *graph, igraph_integer_t n, ...) {
    igraph_vector_t shifts;
    igraph_integer_t repeats;
    va_list ap;

    IGRAPH_VECTOR_INIT_FINALLY(&shifts, 0);

    va_start(ap, n);
    while (1) {
        int num = va_arg(ap, int);
        if (num == 0) {
            break;
        }
        IGRAPH_CHECK(igraph_vector_push_back(&shifts, num));
    }
    if (igraph_vector_size(&shifts) == 0) {
        repeats = 0;
    } else {
        repeats = (igraph_integer_t) igraph_vector_pop_back(&shifts);
    }

    IGRAPH_CHECK(igraph_lcf_vector(graph, n, &shifts, repeats));
    igraph_vector_destroy(&shifts);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/linegraph.c0000644000175100001710000001302000000000000025322 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

#include "core/interruption.h"

/* Note to self: tried using adjacency lists instead of igraph_incident queries,
 * with minimal performance improvements on a graph with 70K vertices and 360K
 * edges. (1.09s instead of 1.10s). I think it's not worth the fuss. */
static int igraph_i_linegraph_undirected(const igraph_t *graph, igraph_t *linegraph) {
    long int no_of_edges = igraph_ecount(graph);
    long int i, j, n;
    igraph_vector_t adjedges, adjedges2;
    igraph_vector_t edges;
    long int prev = -1;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjedges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjedges2, 0);

    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);

        IGRAPH_ALLOW_INTERRUPTION();

        if (from != prev) {
            IGRAPH_CHECK(igraph_incident(graph, &adjedges, (igraph_integer_t) from,
                                         IGRAPH_ALL));
        }
        n = igraph_vector_size(&adjedges);
        for (j = 0; j < n; j++) {
            long int e = (long int) VECTOR(adjedges)[j];
            if (e < i) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, e));
            }
        }

        IGRAPH_CHECK(igraph_incident(graph, &adjedges2, (igraph_integer_t) to,
                                     IGRAPH_ALL));
        n = igraph_vector_size(&adjedges2);
        for (j = 0; j < n; j++) {
            long int e = (long int) VECTOR(adjedges2)[j];
            if (e < i) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, e));
            }
        }

        prev = from;
    }

    igraph_vector_destroy(&adjedges);
    igraph_vector_destroy(&adjedges2);
    IGRAPH_FINALLY_CLEAN(2);

    igraph_create(linegraph, &edges, (igraph_integer_t) no_of_edges,
                  igraph_is_directed(graph));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_linegraph_directed(const igraph_t *graph, igraph_t *linegraph) {
    long int no_of_edges = igraph_ecount(graph);
    long int i, j, n;
    igraph_vector_t adjedges;
    igraph_vector_t edges;
    long int prev = -1;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjedges, 0);

    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);

        IGRAPH_ALLOW_INTERRUPTION();

        if (from != prev) {
            IGRAPH_CHECK(igraph_incident(graph, &adjedges, (igraph_integer_t) from,
                                         IGRAPH_IN));
        }
        n = igraph_vector_size(&adjedges);
        for (j = 0; j < n; j++) {
            long int e = (long int) VECTOR(adjedges)[j];
            IGRAPH_CHECK(igraph_vector_push_back(&edges, e));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
        }

        prev = from;
    }

    igraph_vector_destroy(&adjedges);
    IGRAPH_FINALLY_CLEAN(1);
    igraph_create(linegraph, &edges, (igraph_integer_t) no_of_edges, igraph_is_directed(graph));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_linegraph
 * \brief Create the line graph of a graph.
 *
 * The line graph L(G) of a G undirected graph is defined as follows.
 * L(G) has one vertex for each edge in G and two different vertices in L(G)
 * are connected by an edge if their corresponding edges share an end point.
 * In a multigraph, if two end points are shared, two edges are created.
 * The vertex of a loop is counted as two end points.
 *
 * 
 * The line graph L(G) of a G directed graph is slightly different,
 * L(G) has one vertex for each edge in G and two vertices in L(G) are connected
 * by a directed edge if the target of the first vertex's corresponding edge
 * is the same as the source of the second vertex's corresponding edge.
 *
 * 
 * Edge \em i  in the original graph will correspond to vertex \em i
 * in the line graph.
 *
 * 
 * The first version of this function was contributed by Vincent Matossian,
 * thanks.
 * \param graph The input graph, may be directed or undirected.
 * \param linegraph Pointer to an uninitialized graph object, the
 *        result is stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of edges plus the number of vertices.
 */

int igraph_linegraph(const igraph_t *graph, igraph_t *linegraph) {

    if (igraph_is_directed(graph)) {
        return igraph_i_linegraph_directed(graph, linegraph);
    } else {
        return igraph_i_linegraph_undirected(graph, linegraph);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/prufer.c0000644000175100001710000000704300000000000024664 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"

/**
 * \ingroup generators
 * \function igraph_from_prufer
 * \brief Generates a tree from a Prüfer sequence.
 *
 * A Prüfer sequence is a unique sequence of integers associated
 * with a labelled tree. A tree on n vertices can be represented by a
 * sequence of n-2 integers, each between 0 and n-1 (inclusive).
 *
 * The algorithm used by this function is based on
 * Paulius Micikevičius, Saverio Caminiti, Narsingh Deo:
 * Linear-time Algorithms for Encoding Trees as Sequences of Node Labels
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param prufer The Prüfer sequence
 * \return Error code:
 *          \clist
 *          \cli IGRAPH_ENOMEM
 *             there is not enough memory to perform the operation.
 *          \cli IGRAPH_EINVAL
 *             invalid Prüfer sequence given
 *          \endclist
 *
 * \sa \ref igraph_to_prufer(), \ref igraph_tree(), \ref igraph_tree_game()
 *
 */
int igraph_from_prufer(igraph_t *graph, const igraph_vector_int_t *prufer) {
    igraph_vector_int_t degree;
    igraph_vector_t edges;
    long n;
    long i, k;
    long u, v; /* vertices */
    long ec;

    n = igraph_vector_int_size(prufer) + 2;

    IGRAPH_VECTOR_INT_INIT_FINALLY(°ree, n); /* initializes vector to zeros */
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * (n - 1));

    /* build out-degree vector (i.e. number of child vertices) and verify Prufer sequence */
    for (i = 0; i < n - 2; ++i) {
        long u = VECTOR(*prufer)[i];
        if (u >= n || u < 0) {
            IGRAPH_ERROR("Invalid Prufer sequence", IGRAPH_EINVAL);
        }
        VECTOR(degree)[u] += 1;
    }

    v = 0;  /* initialize v now, in case Prufer sequence is empty */
    k = 0;  /* index into the Prufer vector */
    ec = 0; /* index into the edges vector */
    for (i = 0; i < n; ++i) {
        u = i;

        while (k < n - 2 && u <= i && (VECTOR(degree)[u] == 0)) {
            /* u is a leaf here */

            v = VECTOR(*prufer)[k]; /* parent of u */

            /* add edge */
            VECTOR(edges)[ec++] = v;
            VECTOR(edges)[ec++] = u;

            k += 1;

            VECTOR(degree)[v] -= 1;

            u = v;
        }

        if (k == n - 2) {
            break;
        }
    }

    /* find u for last edge, v is already set */
    for (u = i + 1; u < n; ++u)
        if ((VECTOR(degree)[u] == 0) && u != v) {
            break;
        }

    /* add last edge */
    VECTOR(edges)[ec++] = v;
    VECTOR(edges)[ec++] = u;

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) n, /* directed = */ 0));

    igraph_vector_destroy(&edges);
    igraph_vector_int_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/constructors/regular.c0000644000175100001710000004321600000000000025024 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_constructors.h"

#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"

#include "core/interruption.h"

/**
 * \ingroup generators
 * \function igraph_star
 * \brief Creates a \em star graph, every vertex connects only to the center.
 *
 * \param graph Pointer to an uninitialized graph object, this will
 *        be the result.
 * \param n Integer constant, the number of vertices in the graph.
 * \param mode Constant, gives the type of the star graph to
 *        create. Possible values:
 *        \clist
 *        \cli IGRAPH_STAR_OUT
 *          directed star graph, edges point
 *          \em from the center to the other vertices.
 *        \cli IGRAPH_STAR_IN
 *          directed star graph, edges point
 *          \em to the center from the other vertices.
 *        \cli IGRAPH_STAR_MUTUAL
 *          directed star graph with mutual edges.
 *        \cli IGRAPH_STAR_UNDIRECTED
 *          an undirected star graph is
 *          created.
 *        \endclist
 * \param center Id of the vertex which will be the center of the
 *          graph.
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_EINVVID
 *           invalid number of vertices.
 *         \cli IGRAPH_EINVAL
 *           invalid center vertex.
 *         \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *         \endclist
 *
 * Time complexity: O(|V|), the
 * number of vertices in the graph.
 *
 * \sa \ref igraph_lattice(), \ref igraph_ring(), \ref igraph_tree()
 * for creating other regular structures.
 *
 * \example examples/simple/igraph_star.c
 */
int igraph_star(igraph_t *graph, igraph_integer_t n, igraph_star_mode_t mode,
                igraph_integer_t center) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int i;

    if (n < 0) {
        IGRAPH_ERROR("Invalid number of vertices", IGRAPH_EINVVID);
    }
    if (center < 0 || center > n - 1) {
        IGRAPH_ERROR("Invalid center vertex", IGRAPH_EINVAL);
    }
    if (mode != IGRAPH_STAR_OUT && mode != IGRAPH_STAR_IN &&
        mode != IGRAPH_STAR_MUTUAL && mode != IGRAPH_STAR_UNDIRECTED) {
        IGRAPH_ERROR("invalid mode", IGRAPH_EINVMODE);
    }

    if (mode != IGRAPH_STAR_MUTUAL) {
        IGRAPH_VECTOR_INIT_FINALLY(&edges, (n - 1) * 2);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&edges, (n - 1) * 2 * 2);
    }

    if (mode == IGRAPH_STAR_OUT) {
        for (i = 0; i < center; i++) {
            VECTOR(edges)[2 * i] = center;
            VECTOR(edges)[2 * i + 1] = i;
        }
        for (i = center + 1; i < n; i++) {
            VECTOR(edges)[2 * (i - 1)] = center;
            VECTOR(edges)[2 * (i - 1) + 1] = i;
        }
    } else if (mode == IGRAPH_STAR_MUTUAL) {
        for (i = 0; i < center; i++) {
            VECTOR(edges)[4 * i] = center;
            VECTOR(edges)[4 * i + 1] = i;
            VECTOR(edges)[4 * i + 2] = i;
            VECTOR(edges)[4 * i + 3] = center;
        }
        for (i = center + 1; i < n; i++) {
            VECTOR(edges)[4 * i - 4] = center;
            VECTOR(edges)[4 * i - 3] = i;
            VECTOR(edges)[4 * i - 2] = i;
            VECTOR(edges)[4 * i - 1] = center;
        }
    } else {
        for (i = 0; i < center; i++) {
            VECTOR(edges)[2 * i + 1] = center;
            VECTOR(edges)[2 * i] = i;
        }
        for (i = center + 1; i < n; i++) {
            VECTOR(edges)[2 * (i - 1) + 1] = center;
            VECTOR(edges)[2 * (i - 1)] = i;
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, 0,
                               (mode != IGRAPH_STAR_UNDIRECTED)));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup generators
 * \function igraph_lattice
 * \brief Arbitrary dimensional square lattices.
 *
 * Creates d-dimensional square lattices of the given size. Optionally,
 * the lattice can be made periodic, and the neighbors within a given
 * graph distance can be connected.
 *
 * 
 * In the zero-dimensional case, the singleton graph is returned.
 *
 * 
 * The vertices of the resulting graph are ordered such that the
 * index of the vertex at position (i_0, i_1, i_2, ..., i_d)
 * in a lattice of size (n_0, n_1, ..., n_d) will be
 * i_0 + n_0 * i_1 + n_0 * n_1 * i_2 + ....
 *
 * \param graph An uninitialized graph object.
 * \param dimvector Vector giving the sizes of the lattice in each of
 *        its dimensions. The dimension of the lattice will be the
 *        same as the length of this vector.
 * \param nei Integer value giving the distance (number of steps)
 *        within which two vertices will be connected.
 * \param directed Boolean, whether to create a directed graph.
 *        If the \c mutual and \c circular arguments are not set to true,
 *        edges will be directed from lower-index vertices towards
 *        higher-index ones.
 * \param mutual Boolean, if the graph is directed this gives whether
 *        to create all connections as mutual.
 * \param circular Boolean, defines whether the generated lattice is
 *        periodic.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid (negative)
 *         dimension vector.
 *
 * Time complexity: If \p nei is less than two then it is O(|V|+|E|) (as
 * far as I remember), |V| and |E| are the number of vertices
 * and edges in the generated graph. Otherwise it is O(|V|*d^k+|E|), d
 * is the average degree of the graph, k is the \p nei argument.
 */
int igraph_lattice(igraph_t *graph, const igraph_vector_t *dimvector,
                   igraph_integer_t nei, igraph_bool_t directed, igraph_bool_t mutual,
                   igraph_bool_t circular) {

    long int dims = igraph_vector_size(dimvector);
    long int no_of_nodes = (long int) igraph_vector_prod(dimvector);
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int *coords, *weights;
    long int i, j;
    int carry, pos;

    if (igraph_vector_any_smaller(dimvector, 0)) {
        IGRAPH_ERROR("Invalid dimension vector", IGRAPH_EINVAL);
    }

    /* init coords & weights */

    coords = IGRAPH_CALLOC(dims, long int);
    if (coords == 0) {
        IGRAPH_ERROR("Lattice creation failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, coords);
    weights = IGRAPH_CALLOC(dims, long int);
    if (weights == 0) {
        IGRAPH_ERROR("Lattice creation failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, weights);
    if (dims > 0) {
        weights[0] = 1;
        for (i = 1; i < dims; i++) {
            weights[i] = weights[i - 1] * (long int) VECTOR(*dimvector)[i - 1];
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_nodes * dims +
                                       mutual * directed * no_of_nodes * dims));

    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        for (j = 0; j < dims; j++) {
            if (circular || coords[j] != VECTOR(*dimvector)[j] - 1) {
                long int new_nei;
                if (coords[j] != VECTOR(*dimvector)[j] - 1) {
                    new_nei = i + weights[j] + 1;
                } else {
                    new_nei = i - (long int) (VECTOR(*dimvector)[j] - 1) * weights[j] + 1;
                }
                if (new_nei != i + 1 &&
                    (VECTOR(*dimvector)[j] != 2 || coords[j] != 1 || directed)) {
                    igraph_vector_push_back(&edges, i); /* reserved */
                    igraph_vector_push_back(&edges, new_nei - 1); /* reserved */
                }
            } /* if circular || coords[j] */
            if (mutual && directed && (circular || coords[j] != 0)) {
                long int new_nei;
                if (coords[j] != 0) {
                    new_nei = i - weights[j] + 1;
                } else {
                    new_nei = i + (long int) (VECTOR(*dimvector)[j] - 1) * weights[j] + 1;
                }
                if (new_nei != i + 1 &&
                    (VECTOR(*dimvector)[j] != 2 || !circular)) {
                    igraph_vector_push_back(&edges, i); /* reserved */
                    igraph_vector_push_back(&edges, new_nei - 1); /* reserved */
                }
            } /* if circular || coords[0] */
        } /* for j= 2) {
        IGRAPH_CHECK(igraph_connect_neighborhood(graph, nei, IGRAPH_ALL));
    }

    /* clean up */
    IGRAPH_FREE(coords);
    IGRAPH_FREE(weights);
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \ingroup generators
 * \function igraph_ring
 * \brief Creates a \em cycle graph or a \em path graph.
 *
 * A circular ring on \c n vertices is commonly known in graph
 * theory as the cycle graph, and often denoted by C_n.
 * Removing a single edge from the cycle graph C_n results
 * in the path graph P_n. This function can generate both.
 *
 * 
 * This function is a convenience wrapper for the one-dimensional case of
 * \ref igraph_lattice().
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param n The number of vertices in the graph.
 * \param directed Logical, whether to create a directed graph.
 *        All edges will be oriented in the same direction along
 *        the cycle or path.
 * \param mutual Logical, whether to create mutual edges in directed
 *        graphs. It is ignored for undirected graphs.
 * \param circular Logical, whether to create a closed ring (a cycle)
 *        or an open path.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of vertices.
 *
 * Time complexity: O(|V|), the number of vertices in the graph.
 *
 * \sa \ref igraph_lattice() for generating more general lattices.
 *
 * \example examples/simple/igraph_ring.c
 */
int igraph_ring(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed,
                igraph_bool_t mutual, igraph_bool_t circular) {

    igraph_vector_t v = IGRAPH_VECTOR_NULL;

    if (n < 0) {
        IGRAPH_ERRORF("The number of vertices must be non-negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, n);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&v, 1);
    VECTOR(v)[0] = n;

    IGRAPH_CHECK(igraph_lattice(graph, &v, 1, directed, mutual, circular));

    igraph_vector_destroy(&v);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup generators
 * \function igraph_tree
 * \brief Creates a tree in which almost all vertices have the same number of children.
 *
 * To obtain a completely symmetric tree with \c l layers, where each
 * vertex has precisely \p children descendants, use
 * n = (children^(l+1) - 1) / (children - 1).
 * Such trees are often called k-ary trees, where \c k refers
 * to the number of children.
 *
 * 
 * Note that for n=0, the null graph is returned,
 * which is not considered to be a tree by \ref igraph_is_tree().
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param n Integer, the number of vertices in the graph.
 * \param children Integer, the number of children of a vertex in the
 *        tree.
 * \param type Constant, gives whether to create a directed tree, and
 *        if this is the case, also its orientation. Possible values:
 *        \clist
 *        \cli IGRAPH_TREE_OUT
 *          directed tree, the edges point
 *          from the parents to their children,
 *        \cli IGRAPH_TREE_IN
 *          directed tree, the edges point from
 *          the children to their parents.
 *        \cli IGRAPH_TREE_UNDIRECTED
 *          undirected tree.
 *        \endclist
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of vertices.
 *         \c IGRAPH_INVMODE: invalid mode argument.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 * \sa \ref igraph_lattice(), \ref igraph_star() for creating other regular
 * structures; \ref igraph_from_prufer() for creating arbitrary trees;
 * \ref igraph_tree_game() for uniform random sampling of trees.
 *
 * \example examples/simple/igraph_tree.c
 */
int igraph_tree(igraph_t *graph, igraph_integer_t n, igraph_integer_t children,
                igraph_tree_mode_t type) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int i, j;
    long int idx = 0;
    long int to = 1;

    if (n < 0) {
        IGRAPH_ERROR("Number of vertices cannot be negative.", IGRAPH_EINVAL);
    }
    if (children <= 0) {
        IGRAPH_ERROR("Number of children must be positive.", IGRAPH_EINVAL);
    }
    if (type != IGRAPH_TREE_OUT && type != IGRAPH_TREE_IN &&
        type != IGRAPH_TREE_UNDIRECTED) {
        IGRAPH_ERROR("Invalid tree orientation type.", IGRAPH_EINVMODE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * (n - 1));

    i = 0;
    if (type == IGRAPH_TREE_OUT) {
        while (idx < 2 * (n - 1)) {
            for (j = 0; j < children && idx < 2 * (n - 1); j++) {
                VECTOR(edges)[idx++] = i;
                VECTOR(edges)[idx++] = to++;
            }
            i++;
        }
    } else {
        while (idx < 2 * (n - 1)) {
            for (j = 0; j < children && idx < 2 * (n - 1); j++) {
                VECTOR(edges)[idx++] = to++;
                VECTOR(edges)[idx++] = i;
            }
            i++;
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, type != IGRAPH_TREE_UNDIRECTED));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_extended_chordal_ring
 * \brief Create an extended chordal ring.
 *
 * An extended chordal ring is a cycle graph with additional chords
 * connecting its vertices.
 *
 * Each row \c L of the matrix \p W specifies a set of chords to be
 * inserted, in the following way: vertex \c i will connect to a vertex
 * L[(i mod p)] steps ahead of it along the cycle, where
 * \c p is the length of \c L.
 * In other words, vertex \c i will be connected to vertex
 * (i + L[(i mod p)]) mod nodes. If multiple edges are
 * defined in this way, this will output a non-simple graph. The result
 * can be simplified using \ref igraph_simplify().
 *
 * 
 * See also Kotsis, G: Interconnection Topologies for Parallel Processing
 * Systems, PARS Mitteilungen 11, 1-6, 1993. The igraph extended chordal
 * rings are not identical to the ones in the paper. In igraph
 * the matrix specifies which edges to add. In the paper, a condition is
 * specified which should simultaneously hold between two endpoints and
 * the reverse endpoints.
 *
 * \param graph Pointer to an uninitialized graph object, the result
 *   will be stored here.
 * \param nodes Integer constant, the number of vertices in the
 *   graph. It must be at least 3.
 * \param W The matrix specifying the extra edges. The number of
 *   columns should divide the number of total vertices. The elements
 *   are allowed to be negative.
 * \param directed Whether the graph should be directed.
 * \return Error code.
 *
 * \sa \ref igraph_ring(), \ref igraph_lcf(), \ref igraph_lcf_vector().
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 */
int igraph_extended_chordal_ring(
    igraph_t *graph, igraph_integer_t nodes, const igraph_matrix_t *W,
    igraph_bool_t directed) {
    igraph_vector_t edges;
    long int period = igraph_matrix_ncol(W);
    long int nrow   = igraph_matrix_nrow(W);
    long int i, j, mpos = 0, epos = 0;

    if (nodes < 3) {
        IGRAPH_ERROR("An extended chordal ring has at least 3 nodes", IGRAPH_EINVAL);
    }

    if ((long int)nodes % period != 0) {
        IGRAPH_ERROR("The period (number of columns in W) should divide the "
                     "number of nodes", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * (nodes + nodes * nrow));

    for (i = 0; i < nodes - 1; i++) {
        VECTOR(edges)[epos++] = i;
        VECTOR(edges)[epos++] = i + 1;
    }
    VECTOR(edges)[epos++] = nodes - 1;
    VECTOR(edges)[epos++] = 0;

    if (nrow > 0) {
        for (i = 0; i < nodes; i++) {
            for (j = 0; j < nrow; j++) {
                long int offset = (long int) MATRIX(*W, j, mpos);
                long int v = (i + offset) % nodes;

                if (v < 0) {
                    v += nodes;    /* handle negative offsets */
                }

                VECTOR(edges)[epos++] = i;
                VECTOR(edges)[epos++] = v;

            }
            mpos++; if (mpos == period) {
                mpos = 0;
            }
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.4991407
igraph-0.9.9/vendor/source/igraph/src/core/0000755000175100001710000000000000000000000021371 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/array.c0000644000175100001710000000260100000000000022652 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_array.h"

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "array.pmt"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "array.pmt"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "array.pmt"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "array.pmt"
#include "igraph_pmt_off.h"
#undef BASE_BOOL
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/array.pmt0000644000175100001710000000526700000000000023243 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

int FUNCTION(igraph_array3, init)(TYPE(igraph_array3) *a, long int n1, long int n2,
                                  long int n3) {
    int ret;
    ret = FUNCTION(igraph_vector, init)(&a->data, n1 * n2 * n3);
    a->n1 = n1;
    a->n2 = n2;
    a->n3 = n3;
    a->n1n2 = n1 * n2;

    return ret;
}

void FUNCTION(igraph_array3, destroy)(TYPE(igraph_array3) *a) {
    FUNCTION(igraph_vector, destroy)(&a->data);
}

long int FUNCTION(igraph_array3, size)(const TYPE(igraph_array3) *a) {
    return (a->n1n2) * (a->n3);
}

long int FUNCTION(igraph_array3, n)(const TYPE(igraph_array3) *a, long int idx) {
    switch (idx) {
    case 1: return a->n1;
        break;
    case 2: return a->n2;
        break;
    case 3: return a->n3;
        break;
    }
    return 0;
}

int FUNCTION(igraph_array3, resize)(TYPE(igraph_array3) *a, long int n1, long int n2,
                                    long int n3) {
    int ret = FUNCTION(igraph_vector, resize)(&a->data, n1 * n2 * n3);
    a->n1 = n1;
    a->n2 = n2;
    a->n3 = n3;
    a->n1n2 = n1 * n2;

    return ret;
}

void FUNCTION(igraph_array3, null)(TYPE(igraph_array3) *a) {
    FUNCTION(igraph_vector, null)(&a->data);
}

BASE FUNCTION(igraph_array3, sum)(const TYPE(igraph_array3) *a) {
    return FUNCTION(igraph_vector, sum)(&a->data);
}

void FUNCTION(igraph_array3, scale)(TYPE(igraph_array3) *a, BASE by) {
    FUNCTION(igraph_vector, scale)(&a->data, by);
}

void FUNCTION(igraph_array3, fill)(TYPE(igraph_array3) *a, BASE e) {
    FUNCTION(igraph_vector, fill)(&a->data, e);
}

int FUNCTION(igraph_array3, update)(TYPE(igraph_array3) *to,
                                    const TYPE(igraph_array3) *from) {
    IGRAPH_CHECK(FUNCTION(igraph_array3, resize)(to, from->n1, from->n2, from->n3));
    FUNCTION(igraph_vector, update)(&to->data, &from->data);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/buckets.c0000644000175100001710000001370300000000000023201 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

#include "core/buckets.h"

/* The igraph_buckets_t data structure can store at most 'size'
 * unique integers in 'bsize' buckets. It has the following simple
 * operations (in addition to _init() and _destroy():
 * - _add() adding an element to the given bucket.
 * - _popmax() removing an element from the bucket with the highest
 *   id.
 *   Currently buckets work as stacks, last-in-first-out mode.
 * - _empty() queries whether the buckets is empty.
 *
 * Internal representation: we use a vector to create single linked
 * lists, and another vector that points to the starting element of
 * each bucket. Zero means the end of the chain. So bucket i contains
 * elements bptr[i], buckets[bptr[i]], buckets[buckets[bptr[i]]],
 * etc., until a zero is found.
 *
 * We also keep the total number of elements in the buckets and the
 * id of the non-empty bucket with the highest id, to facilitate the
 * _empty() and _popmax() operations.
 */

int igraph_buckets_init(igraph_buckets_t *b, long int bsize, long int size) {
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&b->bptr, bsize);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&b->buckets, size);
    b->max = -1; b->no = 0;
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

void igraph_buckets_destroy(igraph_buckets_t *b) {
    igraph_vector_long_destroy(&b->bptr);
    igraph_vector_long_destroy(&b->buckets);
}

long int igraph_buckets_popmax(igraph_buckets_t *b) {
    /* Precondition: there is at least a non-empty bucket */
    /* Search for the highest bucket first */
    long int max;
    while ( (max = (long int) VECTOR(b->bptr)[(long int) b->max]) == 0) {
        b->max --;
    }
    VECTOR(b->bptr)[(long int) b->max] = VECTOR(b->buckets)[max - 1];
    b->no--;

    return max - 1;
}

long int igraph_buckets_pop(igraph_buckets_t *b, long int bucket) {
    long int ret = VECTOR(b->bptr)[bucket] - 1;
    VECTOR(b->bptr)[bucket] = VECTOR(b->buckets)[ret];
    b->no--;
    return ret;
}

igraph_bool_t igraph_buckets_empty(const igraph_buckets_t *b) {
    return (b->no == 0);
}

igraph_bool_t igraph_buckets_empty_bucket(const igraph_buckets_t *b,
        long int bucket) {
    return VECTOR(b->bptr)[bucket] == 0;
}

void igraph_buckets_add(igraph_buckets_t *b, long int bucket,
                        long int elem) {

    VECTOR(b->buckets)[(long int) elem] = VECTOR(b->bptr)[(long int) bucket];
    VECTOR(b->bptr)[(long int) bucket] = elem + 1;
    if (bucket > b->max) {
        b->max = (int) bucket;
    }
    b->no++;
}

void igraph_buckets_clear(igraph_buckets_t *b) {
    igraph_vector_long_null(&b->bptr);
    igraph_vector_long_null(&b->buckets);
    b->max = -1;
    b->no = 0;
}

int igraph_dbuckets_init(igraph_dbuckets_t *b, long int bsize, long int size) {
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&b->bptr, bsize);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&b->next, size);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&b->prev, size);
    b->max = -1; b->no = 0;
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

void igraph_dbuckets_destroy(igraph_dbuckets_t *b) {
    igraph_vector_long_destroy(&b->bptr);
    igraph_vector_long_destroy(&b->next);
    igraph_vector_long_destroy(&b->prev);
}

void igraph_dbuckets_clear(igraph_dbuckets_t *b) {
    igraph_vector_long_null(&b->bptr);
    igraph_vector_long_null(&b->next);
    igraph_vector_long_null(&b->prev);
    b->max = -1;
    b->no = 0;
}

long int igraph_dbuckets_popmax(igraph_dbuckets_t *b) {
    long int max;
    while ( (max = (long int) VECTOR(b->bptr)[(long int) b->max]) == 0) {
        b->max --;
    }
    return igraph_dbuckets_pop(b, b->max);
}

long int igraph_dbuckets_pop(igraph_dbuckets_t *b, long int bucket) {
    long int ret = VECTOR(b->bptr)[bucket] - 1;
    long int next = VECTOR(b->next)[ret];
    VECTOR(b->bptr)[bucket] = next;
    if (next != 0) {
        VECTOR(b->prev)[next - 1] = 0;
    }

    b->no--;
    return ret;
}

igraph_bool_t igraph_dbuckets_empty(const igraph_dbuckets_t *b) {
    return (b->no == 0);
}

igraph_bool_t igraph_dbuckets_empty_bucket(const igraph_dbuckets_t *b,
        long int bucket) {
    return VECTOR(b->bptr)[bucket] == 0;
}

void igraph_dbuckets_add(igraph_dbuckets_t *b, long int bucket,
                         long int elem) {
    long int oldfirst = VECTOR(b->bptr)[bucket];
    VECTOR(b->bptr)[bucket] = elem + 1;
    VECTOR(b->next)[elem] = oldfirst;
    if (oldfirst != 0) {
        VECTOR(b->prev)[oldfirst - 1] = elem + 1;
    }
    if (bucket > b->max) {
        b->max = (int) bucket;
    }
    b->no++;
}

/* Remove an arbitrary element */

void igraph_dbuckets_delete(igraph_dbuckets_t *b, long int bucket,
                            long int elem) {
    if (VECTOR(b->bptr)[bucket] == elem + 1) {
        /* First element in bucket */
        long int next = VECTOR(b->next)[elem];
        if (next != 0) {
            VECTOR(b->prev)[next - 1] = 0;
        }
        VECTOR(b->bptr)[bucket] = next;
    } else {
        long int next = VECTOR(b->next)[elem];
        long int prev = VECTOR(b->prev)[elem];
        if (next != 0) {
            VECTOR(b->prev)[next - 1] = prev;
        }
        if (prev != 0) {
            VECTOR(b->next)[prev - 1] = next;
        }
    }
    b->no--;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/buckets.h0000644000175100001710000000534000000000000023204 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_BUCKETS_H
#define IGRAPH_CORE_BUCKETS_H

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
    #define __BEGIN_DECLS extern "C" {
    #define __END_DECLS }
#else
    #define __BEGIN_DECLS /* empty */
    #define __END_DECLS /* empty */
#endif

#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* Buckets, needed for the maximum flow algorithm */

typedef struct igraph_buckets_t {
    igraph_vector_long_t bptr;
    igraph_vector_long_t buckets;
    igraph_integer_t max, no;
} igraph_buckets_t;

int igraph_buckets_init(igraph_buckets_t *b, long int bsize, long int size);
void igraph_buckets_destroy(igraph_buckets_t *b);
void igraph_buckets_clear(igraph_buckets_t *b);
long int igraph_buckets_popmax(igraph_buckets_t *b);
long int igraph_buckets_pop(igraph_buckets_t *b, long int bucket);
igraph_bool_t igraph_buckets_empty(const igraph_buckets_t *b);
igraph_bool_t igraph_buckets_empty_bucket(const igraph_buckets_t *b,
        long int bucket);
void igraph_buckets_add(igraph_buckets_t *b, long int bucket,
                        long int elem);

typedef struct igraph_dbuckets_t {
    igraph_vector_long_t bptr;
    igraph_vector_long_t next, prev;
    igraph_integer_t max, no;
} igraph_dbuckets_t;

int igraph_dbuckets_init(igraph_dbuckets_t *b, long int bsize, long int size);
void igraph_dbuckets_destroy(igraph_dbuckets_t *b);
void igraph_dbuckets_clear(igraph_dbuckets_t *b);
long int igraph_dbuckets_popmax(igraph_dbuckets_t *b);
long int igraph_dbuckets_pop(igraph_dbuckets_t *b, long int bucket);
igraph_bool_t igraph_dbuckets_empty(const igraph_dbuckets_t *b);
igraph_bool_t igraph_dbuckets_empty_bucket(const igraph_dbuckets_t *b,
        long int bucket);
void igraph_dbuckets_add(igraph_dbuckets_t *b, long int bucket,
                         long int elem);
void igraph_dbuckets_delete(igraph_dbuckets_t *b, long int bucket,
                            long int elem);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/cutheap.c0000644000175100001710000001321300000000000023166 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

#include "core/cutheap.h"

#define PARENT(x)     ((x)/2)
#define LEFTCHILD(x)  ((x)*2+1)
#define RIGHTCHILD(x) ((x)*2)
#define INACTIVE      IGRAPH_INFINITY
#define UNDEFINED     0.0
#define INDEXINC      1

static void igraph_i_cutheap_switch(igraph_i_cutheap_t *ch,
                                    long int hidx1, long int hidx2) {
    if (hidx1 != hidx2) {
        long int idx1 = (long int) VECTOR(ch->index)[hidx1];
        long int idx2 = (long int) VECTOR(ch->index)[hidx2];

        igraph_real_t tmp = VECTOR(ch->heap)[hidx1];
        VECTOR(ch->heap)[hidx1] = VECTOR(ch->heap)[hidx2];
        VECTOR(ch->heap)[hidx2] = tmp;

        VECTOR(ch->index)[hidx1] = idx2;
        VECTOR(ch->index)[hidx2] = idx1;

        VECTOR(ch->hptr)[idx1] = hidx2 + INDEXINC;
        VECTOR(ch->hptr)[idx2] = hidx1 + INDEXINC;
    }
}

static void igraph_i_cutheap_sink(igraph_i_cutheap_t *ch, long int hidx) {
    long int size = igraph_vector_size(&ch->heap);
    if (LEFTCHILD(hidx) >= size) {
        /* leaf node */
    } else if (RIGHTCHILD(hidx) == size ||
               VECTOR(ch->heap)[LEFTCHILD(hidx)] >=
               VECTOR(ch->heap)[RIGHTCHILD(hidx)]) {
        /* sink to the left if needed */
        if (VECTOR(ch->heap)[hidx] < VECTOR(ch->heap)[LEFTCHILD(hidx)]) {
            igraph_i_cutheap_switch(ch, hidx, LEFTCHILD(hidx));
            igraph_i_cutheap_sink(ch, LEFTCHILD(hidx));
        }
    } else {
        /* sink to the right */
        if (VECTOR(ch->heap)[hidx] < VECTOR(ch->heap)[RIGHTCHILD(hidx)]) {
            igraph_i_cutheap_switch(ch, hidx, RIGHTCHILD(hidx));
            igraph_i_cutheap_sink(ch, RIGHTCHILD(hidx));
        }
    }
}

static void igraph_i_cutheap_shift_up(igraph_i_cutheap_t *ch, long int hidx) {
    if (hidx == 0 || VECTOR(ch->heap)[hidx] < VECTOR(ch->heap)[PARENT(hidx)]) {
        /* at the top */
    } else {
        igraph_i_cutheap_switch(ch, hidx, PARENT(hidx));
        igraph_i_cutheap_shift_up(ch, PARENT(hidx));
    }
}

int igraph_i_cutheap_init(igraph_i_cutheap_t *ch, igraph_integer_t nodes) {
    ch->dnodes = nodes;
    IGRAPH_VECTOR_INIT_FINALLY(&ch->heap, nodes); /* all zero */
    IGRAPH_CHECK(igraph_vector_init_seq(&ch->index, 0, nodes - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &ch->index);
    IGRAPH_CHECK(igraph_vector_init_seq(&ch->hptr, INDEXINC, nodes + INDEXINC - 1));
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

void igraph_i_cutheap_destroy(igraph_i_cutheap_t *ch) {
    igraph_vector_destroy(&ch->hptr);
    igraph_vector_destroy(&ch->index);
    igraph_vector_destroy(&ch->heap);
}

igraph_bool_t igraph_i_cutheap_empty(igraph_i_cutheap_t *ch) {
    return igraph_vector_empty(&ch->heap);
}

/* Number of active vertices */

igraph_integer_t igraph_i_cutheap_active_size(igraph_i_cutheap_t *ch) {
    return (igraph_integer_t) igraph_vector_size(&ch->heap);
}

/* Number of all (defined) vertices */

igraph_integer_t igraph_i_cutheap_size(igraph_i_cutheap_t *ch) {
    return (igraph_integer_t) (ch->dnodes);
}

igraph_real_t igraph_i_cutheap_maxvalue(igraph_i_cutheap_t *ch) {
    return VECTOR(ch->heap)[0];
}

igraph_integer_t igraph_i_cutheap_popmax(igraph_i_cutheap_t *ch) {
    long int size = igraph_vector_size(&ch->heap);
    igraph_integer_t maxindex = (igraph_integer_t) VECTOR(ch->index)[0];
    /* put the last element to the top */
    igraph_i_cutheap_switch(ch, 0, size - 1);
    /* remove the last element */
    VECTOR(ch->hptr)[(long int) igraph_vector_tail(&ch->index)] = INACTIVE;
    igraph_vector_pop_back(&ch->heap);
    igraph_vector_pop_back(&ch->index);
    igraph_i_cutheap_sink(ch, 0);

    return maxindex;
}

/* Update the value of an active vertex, if not active it will be ignored */

int igraph_i_cutheap_update(igraph_i_cutheap_t *ch, igraph_integer_t index,
                            igraph_real_t add) {
    igraph_real_t hidx = VECTOR(ch->hptr)[(long int)index];
    if (hidx != INACTIVE && hidx != UNDEFINED) {
        long int hidx2 = (long int) (hidx - INDEXINC);
        /*     printf("updating vertex %li, heap index %li\n", (long int) index, hidx2); */
        VECTOR(ch->heap)[hidx2] += add;
        igraph_i_cutheap_sink(ch, hidx2);
        igraph_i_cutheap_shift_up(ch, hidx2);
    }
    return 0;
}

/* Reset the value of all vertices to zero and make them active */

int igraph_i_cutheap_reset_undefine(igraph_i_cutheap_t *ch, long int vertex) {
    long int i, j, n = igraph_vector_size(&ch->hptr);
    /* undefine */
    VECTOR(ch->hptr)[vertex] = UNDEFINED;
    ch->dnodes -= 1;

    IGRAPH_CHECK(igraph_vector_resize(&ch->heap, ch->dnodes));
    igraph_vector_null(&ch->heap);

    IGRAPH_CHECK(igraph_vector_resize(&ch->index, ch->dnodes));

    j = 0;
    for (i = 0; i < n; i++) {
        if (VECTOR(ch->hptr)[i] != UNDEFINED) {
            VECTOR(ch->index)[j] = i;
            VECTOR(ch->hptr)[i] = j + INDEXINC;
            j++;
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/cutheap.h0000644000175100001710000000436300000000000023201 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_CUTHEAP_H
#define IGRAPH_CORE_CUTHEAP_H

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
    #define __BEGIN_DECLS extern "C" {
    #define __END_DECLS }
#else
    #define __BEGIN_DECLS /* empty */
    #define __END_DECLS /* empty */
#endif

#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* Special maximum heap, needed for the minimum cut algorithm */

typedef struct igraph_i_cutheap_t {
    igraph_vector_t heap;
    igraph_vector_t index;
    igraph_vector_t hptr;
    long int dnodes;
} igraph_i_cutheap_t;

IGRAPH_PRIVATE_EXPORT int igraph_i_cutheap_init(igraph_i_cutheap_t *ch, igraph_integer_t nodes);
IGRAPH_PRIVATE_EXPORT void igraph_i_cutheap_destroy(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_i_cutheap_empty(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT igraph_integer_t igraph_i_cutheap_active_size(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT igraph_integer_t igraph_i_cutheap_size(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_i_cutheap_maxvalue(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT igraph_integer_t igraph_i_cutheap_popmax(igraph_i_cutheap_t *ch);
IGRAPH_PRIVATE_EXPORT int igraph_i_cutheap_update(igraph_i_cutheap_t *ch, igraph_integer_t index,
                                                  igraph_real_t add);
IGRAPH_PRIVATE_EXPORT int igraph_i_cutheap_reset_undefine(igraph_i_cutheap_t *ch, long int vertex);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/dqueue.c0000644000175100001710000000272700000000000023035 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_dqueue.h"

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "dqueue.pmt"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "dqueue.pmt"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "dqueue.pmt"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "dqueue.pmt"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_INT
#include "igraph_pmt.h"
#include "dqueue.pmt"
#include "igraph_pmt_off.h"
#undef BASE_INT
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/dqueue.pmt0000644000175100001710000002277200000000000023415 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include          /* memcpy & co. */
#include 

/**
 * \section igraph_dqueue
 * 
 * This is the classic data type of the double ended queue. Most of
 * the time it is used if a First-In-First-Out (FIFO) behavior is
 * needed. See the operations below.
 * 
 *
 * 
 * \example examples/simple/dqueue.c
 * 
 */

/**
 * \ingroup dqueue
 * \function igraph_dqueue_init
 * \brief Initialize a double ended queue (deque).
 *
 * The queue will be always empty.
 * \param q Pointer to an uninitialized deque.
 * \param size How many elements to allocate memory for.
 * \return Error code.
 *
 * Time complexity: O(\p size).
 */

int FUNCTION(igraph_dqueue, init) (TYPE(igraph_dqueue)* q, long int size) {
    IGRAPH_ASSERT(q != 0);
    if (size <= 0 ) {
        size = 1;
    }
    q->stor_begin = IGRAPH_CALLOC(size, BASE);
    if (q->stor_begin == 0) {
        IGRAPH_ERROR("dqueue init failed", IGRAPH_ENOMEM);
    }
    q->stor_end = q->stor_begin + size;
    q->begin = q->stor_begin;
    q->end = NULL;

    return 0;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_destroy
 * \brief Destroy a double ended queue.
 *
 * \param q The queue to destroy
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_dqueue, destroy) (TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    if (q->stor_begin != 0) {
        IGRAPH_FREE(q->stor_begin);
        q->stor_begin = 0;
    }
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_empty
 * \brief Decide whether the queue is empty.
 *
 * \param q The queue.
 * \return Boolean, \c TRUE if \p q contains at least one element, \c
 * FALSE otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t FUNCTION(igraph_dqueue, empty) (const TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    return q->end == NULL;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_clear
 * \brief Remove all elements from the queue.
 *
 * \param q The queue
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_dqueue, clear)   (TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    q->begin = q->stor_begin;
    q->end = NULL;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_full
 * \brief Check whether the queue is full.
 *
 * If a queue is full the next igraph_dqueue_push() operation will allocate
 * more memory.
 * \param q The queue.
 * \return \c TRUE if \p q is full, \c FALSE otherwise.
 *
 * Time complecity: O(1).
 */

igraph_bool_t FUNCTION(igraph_dqueue, full) (TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    return q->begin == q->end;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_size
 * \brief Number of elements in the queue.
 *
 * \param q The queue.
 * \return Integer, the number of elements currently in the queue.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_dqueue, size) (const TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    if (q->end == NULL) {
        return 0;
    } else if (q->begin < q->end) {
        return q->end - q->begin;
    } else {
        return q->stor_end - q->begin + q->end - q->stor_begin;
    }
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_head
 * \brief Head of the queue.
 *
 * The queue must contain at least one element.
 * \param q The queue.
 * \return The first element in the queue.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_dqueue, head) (const TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    return *(q->begin);
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_back
 * \brief Tail of the queue.
 *
 * The queue must contain at least one element.
 * \param q The queue.
 * \return The last element in the queue.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_dqueue, back) (const TYPE(igraph_dqueue)* q) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    if (q->end == q->stor_begin) {
        return *(q->stor_end - 1);
    }
    return *(q->end - 1);
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_pop
 * \brief Remove the head.
 *
 * Removes and returns the first element in the queue. The queue must
 * be non-empty.
 * \param q The input queue.
 * \return The first element in the queue.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_dqueue, pop) (TYPE(igraph_dqueue)* q) {
    BASE tmp = *(q->begin);
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    (q->begin)++;
    if (q->begin == q->stor_end) {
        q->begin = q->stor_begin;
    }
    if (q->begin == q->end) {
        q->end = NULL;
    }

    return tmp;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_pop_back
 * \brief Remove the tail
 *
 * Removes and returns the last element in the queue. The queue must
 * be non-empty.
 * \param q The queue.
 * \return The last element in the queue.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_dqueue, pop_back) (TYPE(igraph_dqueue)* q) {
    BASE tmp;
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    if (q->end != q->stor_begin) {
        tmp = *((q->end) - 1);
        q->end = (q->end) - 1;
    } else {
        tmp = *((q->stor_end) - 1);
        q->end = (q->stor_end) - 1;
    }
    if (q->begin == q->end) {
        q->end = NULL;
    }

    return tmp;
}

/**
 * \ingroup dqueue
 * \function igraph_dqueue_push
 * \brief Appends an element.
 *
 * Append an element to the end of the queue.
 * \param q The queue.
 * \param elem The element to append.
 * \return Error code.
 *
 * Time complexity: O(1) if no memory allocation is needed, O(n), the
 * number of elements in the queue otherwise. But not that by
 * allocating always twice as much memory as the current size of the
 * queue we ensure that n push operations can always be done in at
 * most O(n) time. (Assuming memory allocation is at most linear.)
 */

int FUNCTION(igraph_dqueue, push) (TYPE(igraph_dqueue)* q, BASE elem) {
    IGRAPH_ASSERT(q != 0);
    IGRAPH_ASSERT(q->stor_begin != 0);
    if (q->begin != q->end) {
        /* not full */
        if (q->end == NULL) {
            q->end = q->begin;
        }
        *(q->end) = elem;
        (q->end)++;
        if (q->end == q->stor_end) {
            q->end = q->stor_begin;
        }
    } else {
        /* full, allocate more storage */

        BASE *bigger = NULL, *old = q->stor_begin;

        bigger = IGRAPH_CALLOC( 2 * (q->stor_end - q->stor_begin) + 1, BASE );
        if (bigger == 0) {
            IGRAPH_ERROR("dqueue push failed", IGRAPH_ENOMEM);
        }

        if (q->stor_end - q->begin) {
            memcpy(bigger, q->begin,
                   (size_t)(q->stor_end - q->begin) * sizeof(BASE));
        }
        if (q->end - q->stor_begin > 0) {
            memcpy(bigger + (q->stor_end - q->begin), q->stor_begin,
                   (size_t)(q->end - q->stor_begin) * sizeof(BASE));
        }

        q->end       = bigger + (q->stor_end - q->stor_begin);
        q->stor_end  = bigger + 2 * (q->stor_end - q->stor_begin) + 1;
        q->stor_begin = bigger;
        q->begin     = bigger;

        *(q->end) = elem;
        (q->end)++;
        if (q->end == q->stor_end) {
            q->end = q->stor_begin;
        }

        IGRAPH_FREE(old);
    }

    return 0;
}

#if defined (OUT_FORMAT)

#ifndef USING_R
int FUNCTION(igraph_dqueue, print)(const TYPE(igraph_dqueue)* q) {
    return FUNCTION(igraph_dqueue, fprint)(q, stdout);
}
#endif

int FUNCTION(igraph_dqueue, fprint)(const TYPE(igraph_dqueue)* q, FILE *file) {
    if (q->end != NULL) {
        /* There is one element at least */
        BASE *p = q->begin;
        fprintf(file, OUT_FORMAT, *p);
        p++;
        if (q->end > q->begin) {
            /* Q is in one piece */
            while (p != q->end) {
                fprintf(file, " " OUT_FORMAT, *p);
                p++;
            }
        } else {
            /* Q is in two pieces */
            while (p != q->stor_end) {
                fprintf(file, " " OUT_FORMAT, *p);
                p++;
            }
            p = q->stor_begin;
            while (p != q->end) {
                fprintf(file, " " OUT_FORMAT, *p);
                p++;
            }
        }
    }

    fprintf(file, "\n");

    return 0;
}

#endif

BASE FUNCTION(igraph_dqueue, e)(const TYPE(igraph_dqueue) *q, long int idx) {
    if ((q->begin + idx < q->end) ||
        (q->begin >= q->end && q->begin + idx < q->stor_end)) {
        return q->begin[idx];
    } else if (q->begin >= q->end && q->stor_begin + idx < q->end) {
        idx = idx - (q->stor_end - q->begin);
        return q->stor_begin[idx];
    } else {
        return 0;           /* Error */
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/error.c0000644000175100001710000003307000000000000022671 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include "igraph_error.h"
#include "igraph_types.h"

#include 
#include 
#include 

/* Detecting ASan with GCC:
 *   https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
 * Detecting ASan with Clang:
 *   https://clang.llvm.org/docs/AddressSanitizer.html#conditional-compilation-with-has-feature-address-sanitizer
 */
#if defined(__SANITIZE_ADDRESS__)
#  define IGRAPH_SANITIZER_AVAILABLE 1
#elif defined(__has_feature)
#  if __has_feature(address_sanitizer)
#    define IGRAPH_SANITIZER_AVAILABLE 1
#  endif
#endif

#ifdef IGRAPH_SANITIZER_AVAILABLE
#include 
#endif

#ifdef USING_R
#include 
#endif

/***** Helper functions *****/

/* All calls to abort() in this compilation unit must go through igraph_abort(),
 * in order to make it easy for igraph's R interface to not have any reference to abort(),
 * which is disallowed by CRAN.
 *
 * Since the R interface sets its own error / fatal error handlers, this function
 * is never actually called by it.
 *
 * Note that some of the other #ifndef USING_R's in this file are still needed
 * to avoid references to fprintf and stderr.
 */
static IGRAPH_NORETURN void igraph_abort() {
#ifndef USING_R
#ifdef IGRAPH_SANITIZER_AVAILABLE
    fprintf(stderr, "\nStack trace:\n");
    __sanitizer_print_stack_trace();
#endif
    abort();
#else
    /* R's error() function is declared 'noreturn'. We use it here to satisfy the compiler that igraph_abort() does indeed not return. */
    error("igraph_abort() was called. This should never happen. Please report this as an igraph bug, along with steps to reproduce it.");
#endif
}


/***** Handling errors *****/

static IGRAPH_THREAD_LOCAL igraph_error_handler_t *igraph_i_error_handler = 0;
static IGRAPH_THREAD_LOCAL char igraph_i_errormsg_buffer[500];
static IGRAPH_THREAD_LOCAL char igraph_i_warningmsg_buffer[500];
static IGRAPH_THREAD_LOCAL char igraph_i_fatalmsg_buffer[500];

/* Error strings corresponding to each igraph_error_type_t enum value. */
static const char *igraph_i_error_strings[] = {
    /*  0 */ "No error",
    /*  1 */ "Failed",
    /*  2 */ "Out of memory",
    /*  3 */ "Parse error",
    /*  4 */ "Invalid value",
    /*  5 */ "Already exists",
    /*  6 */ "Invalid edge vector",
    /*  7 */ "Invalid vertex id",
    /*  8 */ "Non-square matrix",
    /*  9 */ "Invalid mode",
    /* 10 */ "File operation error",
    /* 11 */ "Unfold infinite iterator",
    /* 12 */ "Unimplemented function call",
    /* 13 */ "Interrupted",
    /* 14 */ "Numeric procedure did not converge",
    /* 15 */ "Matrix-vector product failed",
    /* 16 */ "N must be positive",
    /* 17 */ "NEV must be positive",
    /* 18 */ "NCV must be greater than NEV and less than or equal to N "
    "(and for the non-symmetric solver NCV-NEV >=2 must also hold)",
    /* 19 */ "Maximum number of iterations should be positive",
    /* 20 */ "Invalid WHICH parameter",
    /* 21 */ "Invalid BMAT parameter",
    /* 22 */ "WORKL is too small",
    /* 23 */ "LAPACK error in tridiagonal eigenvalue calculation",
    /* 24 */ "Starting vector is zero",
    /* 25 */ "MODE is invalid",
    /* 26 */ "MODE and BMAT are not compatible",
    /* 27 */ "ISHIFT must be 0 or 1",
    /* 28 */ "NEV and WHICH='BE' are incompatible",
    /* 29 */ "Could not build an Arnoldi factorization",
    /* 30 */ "No eigenvalues to sufficient accuracy",
    /* 31 */ "HOWMNY is invalid",
    /* 32 */ "HOWMNY='S' is not implemented",
    /* 33 */ "Different number of converged Ritz values",
    /* 34 */ "Error from calculation of a real Schur form",
    /* 35 */ "LAPACK (dtrevc) error for calculating eigenvectors",
    /* 36 */ "Unknown ARPACK error",
    /* 37 */ "Negative loop detected while calculating shortest paths",
    /* 38 */ "Internal error, likely a bug in igraph",
    /* 39 */ "Maximum number of iterations reached",
    /* 40 */ "No shifts could be applied during a cycle of the "
    "Implicitly restarted Arnoldi iteration. One possibility "
    "is to increase the size of NCV relative to NEV",
    /* 41 */ "The Schur form computed by LAPACK routine dlahqr "
    "could not be reordered by LAPACK routine dtrsen.",
    /* 42 */ "Big integer division by zero",
    /* 43 */ "GLPK Error, GLP_EBOUND",
    /* 44 */ "GLPK Error, GLP_EROOT",
    /* 45 */ "GLPK Error, GLP_ENOPFS",
    /* 46 */ "GLPK Error, GLP_ENODFS",
    /* 47 */ "GLPK Error, GLP_EFAIL",
    /* 48 */ "GLPK Error, GLP_EMIPGAP",
    /* 49 */ "GLPK Error, GLP_ETMLIM",
    /* 50 */ "GLPK Error, GLP_STOP",
    /* 51 */ "Internal attribute handler error",
    /* 52 */ "Unimplemented attribute combination for this type",
    /* 53 */ "LAPACK call resulted in an error",
    /* 54 */ "Internal DrL error",
    /* 55 */ "Integer or double overflow",
    /* 56 */ "Internal GPLK error",
    /* 57 */ "CPU time exceeded",
    /* 58 */ "Integer or double underflow",
    /* 59 */ "Random walk got stuck",
    /* 60 */ "Search stopped; this error should never be visible to the user, "
    "please report this error along with the steps to reproduce it."
};

const char* igraph_strerror(const int igraph_errno) {
    if (igraph_errno < 0 ||
        ((unsigned long)igraph_errno) >= sizeof(igraph_i_error_strings) / sizeof(char *)) {
        return "Invalid error code; no error string available.";
    }
    return igraph_i_error_strings[igraph_errno];
}

int igraph_error(const char *reason, const char *file, int line,
                 int igraph_errno) {

    if (igraph_i_error_handler) {
        igraph_i_error_handler(reason, file, line, igraph_errno);
#ifndef USING_R
    }  else {
        igraph_error_handler_abort(reason, file, line, igraph_errno);
#endif
    }
    return igraph_errno;
}

int igraph_errorf(const char *reason, const char *file, int line,
                  int igraph_errno, ...) {
    va_list ap;
    va_start(ap, igraph_errno);
    vsnprintf(igraph_i_errormsg_buffer,
              sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap);
    return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno);
}

int igraph_errorvf(const char *reason, const char *file, int line,
                   int igraph_errno, va_list ap) {
    vsnprintf(igraph_i_errormsg_buffer,
              sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap);
    return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno);
}

#ifndef USING_R
void igraph_error_handler_abort(const char *reason, const char *file,
                                int line, int igraph_errno) {
    fprintf(stderr, "Error at %s:%i : %s - %s.\n",
            file, line, reason, igraph_strerror(igraph_errno));
    igraph_abort();
}
#endif

void igraph_error_handler_ignore(const char *reason, const char *file,
                                 int line, int igraph_errno) {
    IGRAPH_UNUSED(reason);
    IGRAPH_UNUSED(file);
    IGRAPH_UNUSED(line);
    IGRAPH_UNUSED(igraph_errno);

    IGRAPH_FINALLY_FREE();
}

#ifndef USING_R
void igraph_error_handler_printignore(const char *reason, const char *file,
                                      int line, int igraph_errno) {
    fprintf(stderr, "Error at %s:%i : %s - %s.\n",
            file, line, reason, igraph_strerror(igraph_errno));
    IGRAPH_FINALLY_FREE();
}
#endif

igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) {
    igraph_error_handler_t *previous_handler = igraph_i_error_handler;
    igraph_i_error_handler = new_handler;
    return previous_handler;
}


/***** "Finally" stack *****/

IGRAPH_THREAD_LOCAL struct igraph_i_protectedPtr igraph_i_finally_stack[100];

/*
 * Adds another element to the free list
 */

void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) {
    int no = igraph_i_finally_stack[0].all;
    IGRAPH_ASSERT(no < 100);
    IGRAPH_ASSERT(no >= 0);
    igraph_i_finally_stack[no].ptr = ptr;
    igraph_i_finally_stack[no].func = func;
    igraph_i_finally_stack[0].all ++;
    /* printf("--> Finally stack contains now %d elements\n", igraph_i_finally_stack[0].all); */
}

void IGRAPH_FINALLY_CLEAN(int minus) {
    igraph_i_finally_stack[0].all -= minus;
    if (igraph_i_finally_stack[0].all < 0) {
        int left = igraph_i_finally_stack[0].all + minus;
        /* Set to zero in case fatal error handler does a longjmp instead of terminating the process: */
        igraph_i_finally_stack[0].all = 0;
        IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left);
    }
    /* printf("<-- Finally stack contains now %d elements\n", igraph_i_finally_stack[0].all); */
}

void IGRAPH_FINALLY_FREE(void) {
    int p;
    /*   printf("[X] Finally stack will be cleaned (contained %d elements)\n", igraph_i_finally_stack[0].all);  */
    for (p = igraph_i_finally_stack[0].all - 1; p >= 0; p--) {
        igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr);
    }
    igraph_i_finally_stack[0].all = 0;
}

int IGRAPH_FINALLY_STACK_SIZE(void) {
    return igraph_i_finally_stack[0].all;
}


/***** Handling warnings *****/

static IGRAPH_THREAD_LOCAL igraph_warning_handler_t *igraph_i_warning_handler = 0;

/**
 * \function igraph_warning_handler_ignore
 * \brief Ignores all warnings.
 *
 * This warning handler function simply ignores all warnings.
 * \param reason Textual description of the warning.
 * \param file The source file in which the warning was noticed.
 * \param line The number of line in the source file which triggered the
 *         warning..
 * \param igraph_errno Warnings could have potentially error codes as well,
 *        but this is currently not used in igraph.
 */

void igraph_warning_handler_ignore(const char *reason, const char *file,
                                   int line, int igraph_errno) {
    IGRAPH_UNUSED(reason);
    IGRAPH_UNUSED(file);
    IGRAPH_UNUSED(line);
    IGRAPH_UNUSED(igraph_errno);
}

#ifndef USING_R

/**
 * \function igraph_warning_handler_print
 * \brief Prints all warnings to the standard error.
 *
 * This warning handler function simply prints all warnings to the
 * standard error.
 * \param reason Textual description of the warning.
 * \param file The source file in which the warning was noticed.
 * \param line The number of line in the source file which triggered the
 *         warning..
 * \param igraph_errno Warnings could have potentially error codes as well,
 *        but this is currently not used in igraph.
 */

void igraph_warning_handler_print(const char *reason, const char *file,
                                  int line, int igraph_errno) {
    IGRAPH_UNUSED(igraph_errno);
    fprintf(stderr, "Warning at %s:%i : %s\n", file, line, reason);
}
#endif

int igraph_warning(const char *reason, const char *file, int line,
                   int igraph_errno) {

    if (igraph_i_warning_handler) {
        igraph_i_warning_handler(reason, file, line, igraph_errno);
#ifndef USING_R
    }  else {
        igraph_warning_handler_print(reason, file, line, igraph_errno);
#endif
    }
    return igraph_errno;
}

int igraph_warningf(const char *reason, const char *file, int line,
                    int igraph_errno, ...) {
    va_list ap;
    va_start(ap, igraph_errno);
    vsnprintf(igraph_i_warningmsg_buffer,
              sizeof(igraph_i_warningmsg_buffer) / sizeof(char), reason, ap);
    return igraph_warning(igraph_i_warningmsg_buffer, file, line,
                          igraph_errno);
}

igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) {
    igraph_warning_handler_t *previous_handler = igraph_i_warning_handler;
    igraph_i_warning_handler = new_handler;
    return previous_handler;
}


/***** Handling fatal errors *****/

static IGRAPH_THREAD_LOCAL igraph_fatal_handler_t *igraph_i_fatal_handler = NULL;

igraph_fatal_handler_t *igraph_set_fatal_handler(igraph_fatal_handler_t *new_handler) {
    igraph_fatal_handler_t *previous_handler = igraph_i_fatal_handler;
    igraph_i_fatal_handler = new_handler;
    return previous_handler;
}

#ifndef USING_R
void igraph_fatal_handler_abort(const char *reason, const char *file, int line) {
    fprintf(stderr, "Fatal error at %s:%i : %s\n", file, line, reason);
    igraph_abort();
}
#endif

void igraph_fatal(const char *reason, const char *file, int line) {
    if (igraph_i_fatal_handler) {
        igraph_i_fatal_handler(reason, file, line);
#ifndef USING_R
    }  else {
        igraph_fatal_handler_abort(reason, file, line);
#endif
    }
    /* The following line should never be reached, as fatal error handlers are not supposed to return.
       It is here to satisfy the compiler that this function indeed does not return. */
    igraph_abort();
}

void igraph_fatalf(const char *reason, const char *file, int line, ...) {
    va_list ap;
    va_start(ap, line);
    vsnprintf(igraph_i_fatalmsg_buffer, sizeof(igraph_i_fatalmsg_buffer) / sizeof(char), reason, ap);
    va_end(ap);
    igraph_fatal(igraph_i_fatalmsg_buffer, file, line);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/estack.c0000644000175100001710000000412600000000000023012 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "core/estack.h"

int igraph_estack_init(igraph_estack_t *s, long int setsize,
                       long int stacksize) {
    IGRAPH_CHECK(igraph_vector_bool_init(&s->isin, setsize));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &s->isin);
    IGRAPH_CHECK(igraph_stack_long_init(&s->stack, stacksize));
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

void igraph_estack_destroy(igraph_estack_t *s) {
    igraph_stack_long_destroy(&s->stack);
    igraph_vector_bool_destroy(&s->isin);
}

int igraph_estack_push(igraph_estack_t *s,  long int elem) {
    if ( !VECTOR(s->isin)[elem] ) {
        IGRAPH_CHECK(igraph_stack_long_push(&s->stack, elem));
        VECTOR(s->isin)[elem] = 1;
    }
    return 0;
}

long int igraph_estack_pop(igraph_estack_t *s) {
    long int elem = igraph_stack_long_pop(&s->stack);
    VECTOR(s->isin)[elem] = 0;
    return elem;
}

igraph_bool_t igraph_estack_iselement(const igraph_estack_t *s,
                                      long int elem) {
    return VECTOR(s->isin)[elem];
}

long int igraph_estack_size(const igraph_estack_t *s) {
    return igraph_stack_long_size(&s->stack);
}

#ifndef USING_R
int igraph_estack_print(const igraph_estack_t *s) {
    return igraph_stack_long_print(&s->stack);
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/estack.h0000644000175100001710000000337500000000000023024 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ESTACK_H
#define IGRAPH_ESTACK_H

#include "igraph_stack.h"
#include "igraph_vector.h"

typedef struct igraph_estack_t {
    igraph_stack_long_t stack;
    igraph_vector_bool_t isin;
} igraph_estack_t;

IGRAPH_PRIVATE_EXPORT int igraph_estack_init(igraph_estack_t *s, long int setsize,
                                             long int stacksize);
IGRAPH_PRIVATE_EXPORT void igraph_estack_destroy(igraph_estack_t *s);

IGRAPH_PRIVATE_EXPORT int igraph_estack_push(igraph_estack_t *s, long int elem);
IGRAPH_PRIVATE_EXPORT long int igraph_estack_pop(igraph_estack_t *s);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_estack_iselement(const igraph_estack_t *s,
                                                            long int elem);
IGRAPH_PRIVATE_EXPORT long int igraph_estack_size(const igraph_estack_t *s);

IGRAPH_PRIVATE_EXPORT int igraph_estack_print(const igraph_estack_t *s);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/exceptions.h0000644000175100001710000000140200000000000023720 0ustar00runnerdocker00000000000000#ifndef IGRAPH_HANDLE_EXCEPTIONS_H
#define IGRAPH_HANDLE_EXCEPTIONS_H

#include 
#include 

/* igraph functions which may be called from C code must not throw C++ exceptions.
 * This includes all public functions. This macro is meant to handle exceptions thrown
 * by C++ libraries used by igraph (such as bliss). Wrap the entire body
 * of public functions implemented in C++ in IGRAPH_HANDLE_EXCEPTIONS().
 */
#define IGRAPH_HANDLE_EXCEPTIONS(code) \
    try { code; } \
    catch (const std::bad_alloc &e) { IGRAPH_ERROR(e.what(), IGRAPH_ENOMEM); } \
    catch (const std::exception &e) { IGRAPH_ERROR(e.what(), IGRAPH_FAILURE); } \
    catch (...) { IGRAPH_ERROR("Unknown exception caught.", IGRAPH_FAILURE); }


#endif // IGRAPH_HANDLE_EXCEPTIONS_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/fixed_vectorlist.c0000644000175100001710000000502500000000000025114 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"

#include "core/fixed_vectorlist.h"

void igraph_fixed_vectorlist_destroy(igraph_fixed_vectorlist_t *l) {
    long int i, n = igraph_vector_ptr_size(&l->v);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(l->v)[i];
        if (v) {
            igraph_vector_destroy(v);
        }
    }
    igraph_vector_ptr_destroy(&l->v);
    igraph_free(l->vecs);
}

int igraph_fixed_vectorlist_convert(igraph_fixed_vectorlist_t *l,
                                    const igraph_vector_t *from,
                                    long int size) {

    igraph_vector_t sizes;
    long int i, no = igraph_vector_size(from);

    l->vecs = IGRAPH_CALLOC(size, igraph_vector_t);
    if (!l->vecs) {
        IGRAPH_ERROR("Cannot merge attributes for simplify",
                     IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, l->vecs);
    IGRAPH_CHECK(igraph_vector_ptr_init(&l->v, size));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &l->v);
    IGRAPH_VECTOR_INIT_FINALLY(&sizes, size);

    for (i = 0; i < no; i++) {
        long int to = (long int) VECTOR(*from)[i];
        if (to >= 0) {
            VECTOR(sizes)[to] += 1;
        }
    }
    for (i = 0; i < size; i++) {
        igraph_vector_t *v = &(l->vecs[i]);
        IGRAPH_CHECK(igraph_vector_init(v, (long int) VECTOR(sizes)[i]));
        igraph_vector_clear(v);
        VECTOR(l->v)[i] = v;
    }
    for (i = 0; i < no; i++) {
        long int to = (long int) VECTOR(*from)[i];
        if (to >= 0) {
            igraph_vector_t *v = &(l->vecs[to]);
            igraph_vector_push_back(v, i);
        }
    }

    igraph_vector_destroy(&sizes);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/fixed_vectorlist.h0000644000175100001710000000317700000000000025127 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_TYPES_INTERNAL_H
#define IGRAPH_TYPES_INTERNAL_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Vectorlist, fixed length                           */
/* -------------------------------------------------- */

typedef struct igraph_fixed_vectorlist_t {
    igraph_vector_t *vecs;
    igraph_vector_ptr_t v;
    long int length;
} igraph_fixed_vectorlist_t;

void igraph_fixed_vectorlist_destroy(igraph_fixed_vectorlist_t *l);
int igraph_fixed_vectorlist_convert(igraph_fixed_vectorlist_t *l,
                                    const igraph_vector_t *from,
                                    long int size);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/grid.c0000644000175100001710000002520100000000000022462 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R package.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

#include "core/grid.h"

#include 

/* internal function */

int igraph_2dgrid_which(igraph_2dgrid_t *grid, igraph_real_t xc, igraph_real_t yc,
                        long int *x, long int *y) {

    if (xc <= grid->minx) {
        *x = 0;
    } else if (xc >= grid->maxx) {
        *x = grid->stepsx - 1;
    } else {
        *x = (long int) floor((xc - (grid->minx)) / (grid->deltax));
    }

    if (yc <= grid->miny) {
        *y = 0;
    } else if (yc >= grid->maxy) {
        *y = grid->stepsy - 1;
    } else {
        *y = (long int) floor((yc - (grid->miny)) / (grid->deltay));
    }

    return 0;
}

int igraph_2dgrid_init(igraph_2dgrid_t *grid, igraph_matrix_t *coords,
                       igraph_real_t minx, igraph_real_t maxx, igraph_real_t deltax,
                       igraph_real_t miny, igraph_real_t maxy, igraph_real_t deltay) {
    long int i;

    grid->coords = coords;
    grid->minx = minx;
    grid->maxx = maxx;
    grid->deltax = deltax;
    grid->miny = miny;
    grid->maxy = maxy;
    grid->deltay = deltay;

    grid->stepsx = (long int) ceil((maxx - minx) / deltax);
    grid->stepsy = (long int) ceil((maxy - miny) / deltay);

    IGRAPH_CHECK(igraph_matrix_init(&grid->startidx,
                                    grid->stepsx, grid->stepsy));
    IGRAPH_FINALLY(igraph_matrix_destroy, &grid->startidx);
    IGRAPH_VECTOR_INIT_FINALLY(&grid->next, igraph_matrix_nrow(coords));
    IGRAPH_VECTOR_INIT_FINALLY(&grid->prev, igraph_matrix_nrow(coords));

    for (i = 0; i < igraph_vector_size(&grid->next); i++) {
        VECTOR(grid->next)[i] = -1;
    }

    grid->massx = 0;
    grid->massy = 0;
    grid->vertices = 0;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

void igraph_2dgrid_destroy(igraph_2dgrid_t *grid) {
    igraph_matrix_destroy(&grid->startidx);
    igraph_vector_destroy(&grid->next);
    igraph_vector_destroy(&grid->prev);
}

void igraph_2dgrid_add(igraph_2dgrid_t *grid, long int elem,
                       igraph_real_t xc, igraph_real_t yc) {
    long int x, y;
    long int first;

    MATRIX(*grid->coords, elem, 0) = xc;
    MATRIX(*grid->coords, elem, 1) = yc;

    /* add to cell */
    igraph_2dgrid_which(grid, xc, yc, &x, &y);
    first = (long int) MATRIX(grid->startidx, x, y);
    VECTOR(grid->prev)[elem] = 0;
    VECTOR(grid->next)[elem] = first;
    if (first != 0) {
        VECTOR(grid->prev)[first - 1] = elem + 1;
    }
    MATRIX(grid->startidx, x, y) = elem + 1;

    grid->massx += xc;
    grid->massy += yc;
    grid->vertices += 1;
}

void igraph_2dgrid_add2(igraph_2dgrid_t *grid, long int elem) {
    long int x, y;
    long int first;
    igraph_real_t xc, yc;

    xc = MATRIX(*grid->coords, elem, 0);
    yc = MATRIX(*grid->coords, elem, 1);

    /* add to cell */
    igraph_2dgrid_which(grid, xc, yc, &x, &y);
    first = (long int) MATRIX(grid->startidx, x, y);
    VECTOR(grid->prev)[elem] = 0;
    VECTOR(grid->next)[elem] = first;
    if (first != 0) {
        VECTOR(grid->prev)[first - 1] = elem + 1;
    }
    MATRIX(grid->startidx, x, y) = elem + 1;

    grid->massx += xc;
    grid->massy += yc;
    grid->vertices += 1;
}

void igraph_2dgrid_move(igraph_2dgrid_t *grid, long int elem,
                        igraph_real_t xc, igraph_real_t yc) {
    long int oldx, oldy;
    long int newx, newy;
    igraph_real_t oldxc = MATRIX(*grid->coords, elem, 0);
    igraph_real_t oldyc = MATRIX(*grid->coords, elem, 1);
    long int first;

    xc = oldxc + xc; yc = oldyc + yc;

    igraph_2dgrid_which(grid, oldxc, oldyc, &oldx, &oldy);
    igraph_2dgrid_which(grid, xc, yc, &newx, &newy);
    if (oldx != newx || oldy != newy) {
        /* remove from this cell */
        if (VECTOR(grid->prev)[elem] != 0) {
            VECTOR(grid->next) [ (long int) VECTOR(grid->prev)[elem] - 1 ] =
                VECTOR(grid->next)[elem];
        } else {
            MATRIX(grid->startidx, oldx, oldy) = VECTOR(grid->next)[elem];
        }
        if (VECTOR(grid->next)[elem] != 0) {
            VECTOR(grid->prev)[ (long int) VECTOR(grid->next)[elem] - 1 ] =
                VECTOR(grid->prev)[elem];
        }

        /* add to this cell */
        first = (long int) MATRIX(grid->startidx, newx, newy);
        VECTOR(grid->prev)[elem] = 0;
        VECTOR(grid->next)[elem] = first;
        if (first != 0) {
            VECTOR(grid->prev)[first - 1] = elem + 1;
        }
        MATRIX(grid->startidx, newx, newy) = elem + 1;
    }

    grid->massx += -oldxc + xc;
    grid->massy += -oldyc + yc;

    MATRIX(*grid->coords, elem, 0) = xc;
    MATRIX(*grid->coords, elem, 1) = yc;

}

void igraph_2dgrid_getcenter(const igraph_2dgrid_t *grid,
                             igraph_real_t *massx, igraph_real_t *massy) {
    *massx = (grid->massx) / (grid->vertices);
    *massy = (grid->massy) / (grid->vertices);
}

igraph_bool_t igraph_2dgrid_in(const igraph_2dgrid_t *grid, long int elem) {
    return VECTOR(grid->next)[elem] != -1;
}

igraph_real_t igraph_2dgrid_dist(const igraph_2dgrid_t *grid,
                                 long int e1, long int e2) {
    igraph_real_t x = MATRIX(*grid->coords, e1, 0) - MATRIX(*grid->coords, e2, 0);
    igraph_real_t y = MATRIX(*grid->coords, e1, 1) - MATRIX(*grid->coords, e2, 1);

    return sqrt(x * x + y * y);
}

igraph_real_t igraph_2dgrid_dist2(const igraph_2dgrid_t *grid,
                                  long int e1, long int e2) {
    igraph_real_t x = MATRIX(*grid->coords, e1, 0) - MATRIX(*grid->coords, e2, 0);
    igraph_real_t y = MATRIX(*grid->coords, e1, 1) - MATRIX(*grid->coords, e2, 1);

    return x * x + y * y;
}

static int igraph_i_2dgrid_addvertices(igraph_2dgrid_t *grid, igraph_vector_t *eids,
                                       igraph_integer_t vid, igraph_real_t r,
                                       long int x, long int y) {
    long int act;
    igraph_real_t *v = VECTOR(grid->next);

    r = r * r;
    act = (long int) MATRIX(grid->startidx, x, y);
    while (act != 0) {
        if (igraph_2dgrid_dist2(grid, vid, act - 1) < r) {
            IGRAPH_CHECK(igraph_vector_push_back(eids, act - 1));
        }
        act = (long int) v[act - 1];
    }
    return 0;
}

int igraph_2dgrid_neighbors(igraph_2dgrid_t *grid, igraph_vector_t *eids,
                            igraph_integer_t vid, igraph_real_t r) {
    igraph_real_t xc = MATRIX(*grid->coords, (long int)vid, 0);
    igraph_real_t yc = MATRIX(*grid->coords, (long int)vid, 1);
    long int x, y;
    igraph_vector_clear(eids);

    igraph_2dgrid_which(grid, xc, yc, &x, &y);

    /* this cell */
    igraph_i_2dgrid_addvertices(grid, eids, vid, r, x, y);

    /* left */
    if (x != 0) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x - 1, y);
    }
    /* right */
    if (x != grid->stepsx - 1) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x + 1, y);
    }
    /* up */
    if (y != 0) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x, y - 1);
    }
    /* down */
    if (y != grid->stepsy - 1) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x, y + 1);
    }
    /* up & left */
    if (x != 0 && y != 0) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x - 1, y - 1);
    }
    /* up & right */
    if (x != grid->stepsx - 1 && y != 0) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x + 1, y - 1);
    }
    /* down & left */
    if (x != 0 && y != grid->stepsy - 1) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x - 1, y + 1);
    }
    /* down & right */
    if (x != grid->stepsx - 1 && y != grid->stepsy - 1) {
        igraph_i_2dgrid_addvertices(grid, eids, vid, r, x - 1, y + 1);
    }

    return 0;
}

void igraph_2dgrid_reset(igraph_2dgrid_t *grid, igraph_2dgrid_iterator_t *it) {
    /* Search for the first cell containing a vertex */
    it->x = 0; it->y = 0; it->vid = (long int) MATRIX(grid->startidx, 0, 0);
    while ( it->vid == 0 && (it->x < grid->stepsx - 1 || it->y < grid->stepsy - 1)) {
        it->x += 1;
        if (it->x == grid->stepsx) {
            it->x = 0; it->y += 1;
        }
        it->vid = (long int) MATRIX(grid->startidx, it->x, it->y);
    }
}

igraph_integer_t igraph_2dgrid_next(igraph_2dgrid_t *grid,
                                    igraph_2dgrid_iterator_t *it) {
    long int ret = it->vid;

    if (ret == 0) {
        return 0;
    }

    /* First neighbor */
    it->ncells = -1;
    if (it->x != grid->stepsx - 1) {
        it->ncells += 1;
        it->nx[it->ncells] = it->x + 1;
        it->ny[it->ncells] = it->y;
    }
    if (it->y != grid->stepsy - 1) {
        it->ncells += 1;
        it->nx[it->ncells] = it->x;
        it->ny[it->ncells] = it->y + 1;
    }
    if (it->ncells == 1) {
        it->ncells += 1;
        it->nx[it->ncells] = it->x + 1;
        it->ny[it->ncells] = it->y + 1;
    }
    it->ncells += 1;
    it->nx[it->ncells] = it->x;
    it->ny[it->ncells] = it->y;

    it->nei = (long int) VECTOR(grid->next) [ ret - 1 ];
    while (it->ncells > 0 && it->nei == 0 ) {
        it->ncells -= 1;
        it->nei = (long int) MATRIX(grid->startidx, it->nx[it->ncells], it->ny[it->ncells]);
    }

    /* Next vertex */
    it->vid = (long int) VECTOR(grid->next)[ it->vid - 1 ];
    while ( (it->x < grid->stepsx - 1 || it->y < grid->stepsy - 1) &&
            it->vid == 0) {
        it->x += 1;
        if (it->x == grid->stepsx) {
            it->x = 0; it->y += 1;
        }
        it->vid = (long int) MATRIX(grid->startidx, it->x, it->y);
    }

    return (igraph_integer_t) ret;
}

igraph_integer_t igraph_2dgrid_next_nei(igraph_2dgrid_t *grid,
                                        igraph_2dgrid_iterator_t *it) {
    long int ret = it->nei;

    if (it->nei != 0) {
        it->nei = (long int) VECTOR(grid->next) [ ret - 1 ];
    }
    while (it->ncells > 0 && it->nei == 0 ) {
        it->ncells -= 1;
        it->nei = (long int) MATRIX(grid->startidx, it->nx[it->ncells], it->ny[it->ncells]);
    }

    return (igraph_integer_t) ret;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/grid.h0000644000175100001710000000571600000000000022500 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_GRID_H
#define IGRAPH_CORE_GRID_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_matrix.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/**
 * 2d grid containing points
 */

typedef struct igraph_2dgrid_t {
    igraph_matrix_t *coords;
    igraph_real_t minx, maxx, deltax;
    igraph_real_t miny, maxy, deltay;
    long int stepsx, stepsy;
    igraph_matrix_t startidx;
    igraph_vector_t next;
    igraph_vector_t prev;
    igraph_real_t massx, massy;       /* The sum of the coordinates */
    long int vertices;        /* Number of active vertices  */
} igraph_2dgrid_t;

int igraph_2dgrid_init(igraph_2dgrid_t *grid, igraph_matrix_t *coords,
                       igraph_real_t minx, igraph_real_t maxx, igraph_real_t deltax,
                       igraph_real_t miny, igraph_real_t maxy, igraph_real_t deltay);
void igraph_2dgrid_destroy(igraph_2dgrid_t *grid);
void igraph_2dgrid_add(igraph_2dgrid_t *grid, long int elem,
                       igraph_real_t xc, igraph_real_t yc);
void igraph_2dgrid_add2(igraph_2dgrid_t *grid, long int elem);
void igraph_2dgrid_move(igraph_2dgrid_t *grid, long int elem,
                        igraph_real_t xc, igraph_real_t yc);
void igraph_2dgrid_getcenter(const igraph_2dgrid_t *grid,
                             igraph_real_t *massx, igraph_real_t *massy);
igraph_bool_t igraph_2dgrid_in(const igraph_2dgrid_t *grid, long int elem);
igraph_real_t igraph_2dgrid_dist(const igraph_2dgrid_t *grid,
                                 long int e1, long int e2);
int igraph_2dgrid_neighbors(igraph_2dgrid_t *grid, igraph_vector_t *eids,
                            igraph_integer_t vid, igraph_real_t r);

typedef struct igraph_2dgrid_iterator_t {
    long int vid, x, y;
    long int nei;
    long int nx[4], ny[4], ncells;
} igraph_2dgrid_iterator_t;

void igraph_2dgrid_reset(igraph_2dgrid_t *grid, igraph_2dgrid_iterator_t *it);
igraph_integer_t igraph_2dgrid_next(igraph_2dgrid_t *grid,
                                    igraph_2dgrid_iterator_t *it);
igraph_integer_t igraph_2dgrid_next_nei(igraph_2dgrid_t *grid,
                                        igraph_2dgrid_iterator_t *it);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/hashtable.c0000644000175100001710000001037000000000000023471 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"

#include "core/hashtable.h"

#include 

int igraph_hashtable_init(igraph_hashtable_t *ht) {
    IGRAPH_CHECK(igraph_trie_init(&ht->keys, 1));
    IGRAPH_FINALLY(igraph_trie_destroy, &ht->keys);
    IGRAPH_CHECK(igraph_strvector_init(&ht->elements, 0));
    IGRAPH_FINALLY(igraph_strvector_destroy, &ht->elements);
    IGRAPH_CHECK(igraph_strvector_init(&ht->defaults, 0));

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

void igraph_hashtable_destroy(igraph_hashtable_t *ht) {
    igraph_trie_destroy(&ht->keys);
    igraph_strvector_destroy(&ht->elements);
    igraph_strvector_destroy(&ht->defaults);
}

/* Note: may leave the hash table in an inconsistent state if a new
   element is added, but this is not a big problem, since while the
   defaults, or the defaults plus the elements may contain more elements
   than the keys trie, but the data is always retrieved based on the trie
*/

int igraph_hashtable_addset(igraph_hashtable_t *ht,
                            const char *key, const char *def,
                            const char *elem) {
    long int size = igraph_trie_size(&ht->keys);
    long int newid;
    IGRAPH_CHECK(igraph_trie_get(&ht->keys, key, &newid));

    if (newid == size) {
        /* this is a new element */
        IGRAPH_CHECK(igraph_strvector_resize(&ht->defaults, newid + 1));
        IGRAPH_CHECK(igraph_strvector_resize(&ht->elements, newid + 1));
        IGRAPH_CHECK(igraph_strvector_set(&ht->defaults, newid, def));
        IGRAPH_CHECK(igraph_strvector_set(&ht->elements, newid, elem));
    } else {
        /* set an already existing element */
        IGRAPH_CHECK(igraph_strvector_set(&ht->elements, newid, elem));
    }

    return 0;
}

/* Previous comment also applies here */

int igraph_hashtable_addset2(igraph_hashtable_t *ht,
                             const char *key, const char *def,
                             const char *elem, int elemlen) {
    long int size = igraph_trie_size(&ht->keys);
    long int newid;
    char *tmp;

    IGRAPH_CHECK(igraph_trie_get(&ht->keys, key, &newid));

    tmp = IGRAPH_CALLOC(elemlen + 1, char);
    if (tmp == 0) {
        IGRAPH_ERROR("cannot add element to hash table", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp);
    strncpy(tmp, elem, elemlen);
    tmp[elemlen] = '\0';

    if (newid == size) {
        IGRAPH_CHECK(igraph_strvector_resize(&ht->defaults, newid + 1));
        IGRAPH_CHECK(igraph_strvector_resize(&ht->elements, newid + 1));
        IGRAPH_CHECK(igraph_strvector_set(&ht->defaults, newid, def));
        IGRAPH_CHECK(igraph_strvector_set(&ht->elements, newid, tmp));
    } else {
        IGRAPH_CHECK(igraph_strvector_set(&ht->elements, newid, tmp));
    }

    IGRAPH_FREE(tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

int igraph_hashtable_get(igraph_hashtable_t *ht,
                         const char *key, char **elem) {
    long int newid;
    IGRAPH_CHECK(igraph_trie_get(&ht->keys, key, &newid));

    igraph_strvector_get(&ht->elements, newid, elem);

    return 0;
}

int igraph_hashtable_reset(igraph_hashtable_t *ht) {
    igraph_strvector_destroy(&ht->elements);
    IGRAPH_CHECK(igraph_strvector_copy(&ht->elements, &ht->defaults));
    return 0;
}

int igraph_hashtable_getkeys(igraph_hashtable_t *ht,
                             const igraph_strvector_t **sv) {
    return igraph_trie_getkeys(&ht->keys, sv);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/hashtable.h0000644000175100001710000000425000000000000023476 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_HASHTABLE_H
#define IGRAPH_CORE_HASHTABLE_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_strvector.h"

#include "core/trie.h"

__BEGIN_DECLS

/* string -> string hash table */

typedef struct igraph_hashtable_t {
    igraph_trie_t keys;
    igraph_strvector_t elements;
    igraph_strvector_t defaults;
} igraph_hashtable_t;

IGRAPH_PRIVATE_EXPORT int igraph_hashtable_init(igraph_hashtable_t *ht);
IGRAPH_PRIVATE_EXPORT void igraph_hashtable_destroy(igraph_hashtable_t *ht);
IGRAPH_PRIVATE_EXPORT int igraph_hashtable_addset(igraph_hashtable_t *ht,
                                                  const char *key, const char *def,
                                                  const char *elem);
IGRAPH_PRIVATE_EXPORT int igraph_hashtable_addset2(igraph_hashtable_t *ht,
                                                   const char *key, const char *def,
                                                   const char *elem, int elemlen);
IGRAPH_PRIVATE_EXPORT int igraph_hashtable_get(igraph_hashtable_t *ht,
                                               const char *key, char **elem);
IGRAPH_PRIVATE_EXPORT int igraph_hashtable_getkeys(igraph_hashtable_t *ht,
                                                   const igraph_strvector_t **sv);
IGRAPH_PRIVATE_EXPORT int igraph_hashtable_reset(igraph_hashtable_t *ht);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/heap.c0000644000175100001710000000331700000000000022456 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_heap.h"

#define BASE_IGRAPH_REAL
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_LONG

#define BASE_CHAR
#define HEAP_TYPE_MAX
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MAX
#define HEAP_TYPE_MIN
#include "igraph_pmt.h"
#include "heap.pmt"
#include "igraph_pmt_off.h"
#undef HEAP_TYPE_MIN
#undef BASE_CHAR
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/heap.pmt0000644000175100001710000002346200000000000023037 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include          /* memcpy & co. */
#include 

#define PARENT(x)     (((x)+1)/2-1)
#define LEFTCHILD(x)  (((x)+1)*2-1)
#define RIGHTCHILD(x) (((x)+1)*2)

/* Declare internal functions */
static void FUNCTION(igraph_heap, i_build)(BASE* arr, long int size, long int head);
static void FUNCTION(igraph_heap, i_shift_up)(BASE* arr, long int size, long int elem);
static void FUNCTION(igraph_heap, i_sink)(BASE* arr, long int size, long int head);
static void FUNCTION(igraph_heap, i_switch)(BASE* arr, long int e1, long int e2);

/**
 * \ingroup heap
 * \function igraph_heap_init
 * \brief Initializes an empty heap object.
 *
 * Creates an empty heap, but allocates size for some elements.
 * \param h Pointer to an uninitialized heap object.
 * \param alloc_size Number of elements to allocate memory for.
 * \return Error code.
 *
 * Time complexity: O(\p alloc_size), assuming memory allocation is a
 * linear operation.
 */

int FUNCTION(igraph_heap, init)(TYPE(igraph_heap)* h, long int alloc_size) {
    if (alloc_size <= 0 ) {
        alloc_size = 1;
    }
    h->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
    if (h->stor_begin == 0) {
        IGRAPH_ERROR("heap init failed", IGRAPH_ENOMEM);
    }
    h->stor_end = h->stor_begin + alloc_size;
    h->end = h->stor_begin;
    h->destroy = 1;

    return 0;
}

/**
 * \ingroup heap
 * \function igraph_heap_init_array
 * \brief Build a heap from an array.
 *
 * Initializes a heap object from an array, the heap is also
 * built of course (constructor).
 * \param h Pointer to an uninitialized heap object.
 * \param data Pointer to an array of base data type.
 * \param len The length of the array at \p data.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements in the heap.
 */

int FUNCTION(igraph_heap, init_array)(TYPE(igraph_heap) *h, BASE* data, long int len) {
    h->stor_begin = IGRAPH_CALLOC(len, BASE);
    if (h->stor_begin == 0) {
        IGRAPH_ERROR("heap init from array failed", IGRAPH_ENOMEM);
    }
    h->stor_end = h->stor_begin + len;
    h->end = h->stor_end;
    h->destroy = 1;

    memcpy(h->stor_begin, data, (size_t) len * sizeof(igraph_real_t));

    FUNCTION(igraph_heap, i_build) (h->stor_begin, h->end - h->stor_begin, 0);

    return 0;
}

/**
 * \ingroup heap
 * \function igraph_heap_destroy
 * \brief Destroys an initialized heap object.
 *
 * \param h The heap object.
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_heap, destroy)(TYPE(igraph_heap)* h) {
    if (h->destroy) {
        if (h->stor_begin != 0) {
            IGRAPH_FREE(h->stor_begin);
            h->stor_begin = 0;
        }
    }
}

/**
 * \ingroup heap
 * \function igraph_heap_empty
 * \brief Decides whether a heap object is empty.
 *
 * \param h The heap object.
 * \return \c TRUE if the heap is empty, \c FALSE otherwise.
 *
 * TIme complexity: O(1).
 */

igraph_bool_t FUNCTION(igraph_heap, empty)(TYPE(igraph_heap)* h) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);
    return h->stor_begin == h->end;
}

/**
 * \ingroup heap
 * \function igraph_heap_push
 * \brief Add an element.
 *
 * Adds an element to the heap.
 * \param h The heap object.
 * \param elem The element to add.
 * \return Error code.
 *
 * Time complexity: O(log n), n is the number of elements in the
 * heap if no reallocation is needed, O(n) otherwise. It is ensured
 * that n push operations are performed in O(n log n) time.
 */

int FUNCTION(igraph_heap, push)(TYPE(igraph_heap)* h, BASE elem) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);

    /* full, allocate more storage */
    if (h->stor_end == h->end) {
        long int new_size = FUNCTION(igraph_heap, size)(h) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(FUNCTION(igraph_heap, reserve)(h, new_size));
    }

    *(h->end) = elem;
    h->end += 1;

    /* maintain heap */
    FUNCTION(igraph_heap, i_shift_up)(h->stor_begin, FUNCTION(igraph_heap, size)(h),
                                      FUNCTION(igraph_heap, size)(h) - 1);

    return 0;
}

/**
 * \ingroup heap
 * \function igraph_heap_top
 * \brief Top element.
 *
 * For maximum heaps this is the largest, for minimum heaps the
 * smallest element of the heap.
 * \param h The heap object.
 * \return The top element.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_heap, top)(TYPE(igraph_heap)* h) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);
    IGRAPH_ASSERT(h->stor_begin != h->end);

    return h->stor_begin[0];
}

/**
 * \ingroup heap
 * \function igraph_heap_delete_top
 * \brief Return and removes the top element
 *
 * Removes and returns the top element of the heap. For maximum heaps
 * this is the largest, for minimum heaps the smallest element.
 * \param h The heap object.
 * \return The top element.
 *
 * Time complexity: O(log n), n is the number of elements in the
 * heap.
 */

BASE FUNCTION(igraph_heap, delete_top)(TYPE(igraph_heap)* h) {
    BASE tmp;

    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);

    tmp = h->stor_begin[0];
    FUNCTION(igraph_heap, i_switch)(h->stor_begin, 0, FUNCTION(igraph_heap, size)(h) - 1);
    h->end -= 1;
    FUNCTION(igraph_heap, i_sink)(h->stor_begin, h->end - h->stor_begin, 0);

    return tmp;
}

/**
 * \ingroup heap
 * \function igraph_heap_size
 * \brief Number of elements
 *
 * Gives the number of elements in a heap.
 * \param h The heap object.
 * \return The number of elements in the heap.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_heap, size)(TYPE(igraph_heap)* h) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);
    return h->end - h->stor_begin;
}

/**
 * \ingroup heap
 * \function igraph_heap_reserve
 * \brief Allocate more memory
 *
 * Allocates memory for future use. The size of the heap is
 * unchanged. If the heap is larger than the \p size parameter then
 * nothing happens.
 * \param h The heap object.
 * \param size The number of elements to allocate memory for.
 * \return Error code.
 *
 * Time complexity: O(\p size) if \p size is larger than the current
 * number of elements. O(1) otherwise.
 */

int FUNCTION(igraph_heap, reserve)(TYPE(igraph_heap)* h, long int size) {
    long int actual_size = FUNCTION(igraph_heap, size)(h);
    BASE *tmp;
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);

    if (size <= actual_size) {
        return 0;
    }

    tmp = IGRAPH_REALLOC(h->stor_begin, (size_t) size, BASE);
    if (tmp == 0) {
        IGRAPH_ERROR("heap reserve failed", IGRAPH_ENOMEM);
    }
    h->stor_begin = tmp;
    h->stor_end = h->stor_begin + size;
    h->end = h->stor_begin + actual_size;

    return 0;
}

/**
 * \ingroup heap
 * \brief Build a heap, this should not be called directly.
 */

void FUNCTION(igraph_heap, i_build)(BASE* arr,
                                    long int size, long int head) {

    if (RIGHTCHILD(head) < size) {
        /* both subtrees */
        FUNCTION(igraph_heap, i_build)(arr, size, LEFTCHILD(head) );
        FUNCTION(igraph_heap, i_build)(arr, size, RIGHTCHILD(head));
        FUNCTION(igraph_heap, i_sink)(arr, size, head);
    } else if (LEFTCHILD(head) < size) {
        /* only left */
        FUNCTION(igraph_heap, i_build)(arr, size, LEFTCHILD(head));
        FUNCTION(igraph_heap, i_sink)(arr, size, head);
    } else {
        /* none */
    }
}

/**
 * \ingroup heap
 * \brief Shift an element upwards in a heap, this should not be
 * called directly.
 */

void FUNCTION(igraph_heap, i_shift_up)(BASE* arr, long int size, long int elem) {

    if (elem == 0 || arr[elem] HEAPLESS arr[PARENT(elem)]) {
        /* at the top */
    } else {
        FUNCTION(igraph_heap, i_switch)(arr, elem, PARENT(elem));
        FUNCTION(igraph_heap, i_shift_up)(arr, size, PARENT(elem));
    }
}

/**
 * \ingroup heap
 * \brief Moves an element down in a heap, this function should not be
 * called directly.
 */

void FUNCTION(igraph_heap, i_sink)(BASE* arr, long int size, long int head) {

    if (LEFTCHILD(head) >= size) {
        /* no subtrees */
    } else if (RIGHTCHILD(head) == size ||
               arr[LEFTCHILD(head)] HEAPMOREEQ arr[RIGHTCHILD(head)]) {
        /* sink to the left if needed */
        if (arr[head] HEAPLESS arr[LEFTCHILD(head)]) {
            FUNCTION(igraph_heap, i_switch)(arr, head, LEFTCHILD(head));
            FUNCTION(igraph_heap, i_sink)(arr, size, LEFTCHILD(head));
        }
    } else {
        /* sink to the right */
        if (arr[head] HEAPLESS arr[RIGHTCHILD(head)]) {
            FUNCTION(igraph_heap, i_switch)(arr, head, RIGHTCHILD(head));
            FUNCTION(igraph_heap, i_sink)(arr, size, RIGHTCHILD(head));
        }
    }
}

/**
 * \ingroup heap
 * \brief Switches two elements in a heap, this function should not be
 * called directly.
 */

void FUNCTION(igraph_heap, i_switch)(BASE* arr, long int e1, long int e2) {
    if (e1 != e2) {
        BASE tmp = arr[e1];
        arr[e1] = arr[e2];
        arr[e2] = tmp;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/indheap.c0000644000175100001710000006405600000000000023160 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"

#include "core/indheap.h"

#include          /* memcpy & co. */
#include 

/* -------------------------------------------------- */
/* Indexed heap                                       */
/* -------------------------------------------------- */

#define PARENT(x)     (((x)+1)/2-1)
#define LEFTCHILD(x)  (((x)+1)*2-1)
#define RIGHTCHILD(x) (((x)+1)*2)

static void igraph_indheap_i_build(igraph_indheap_t* h, long int head);
static void igraph_indheap_i_shift_up(igraph_indheap_t* h, long int elem);
static void igraph_indheap_i_sink(igraph_indheap_t* h, long int head);
static void igraph_indheap_i_switch(igraph_indheap_t* h, long int e1, long int e2);

/**
 * \ingroup indheap
 * \brief Initializes an indexed heap (constructor).
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_indheap_init(igraph_indheap_t* h, long int alloc_size) {
    if (alloc_size <= 0 ) {
        alloc_size = 1;
    }
    h->stor_begin = IGRAPH_CALLOC(alloc_size, igraph_real_t);
    if (h->stor_begin == 0) {
        h->index_begin = 0;
        IGRAPH_ERROR("indheap init failed", IGRAPH_ENOMEM);
    }
    h->index_begin = IGRAPH_CALLOC(alloc_size, long int);
    if (h->index_begin == 0) {
        IGRAPH_FREE(h->stor_begin);
        h->stor_begin = 0;
        IGRAPH_ERROR("indheap init failed", IGRAPH_ENOMEM);
    }

    h->stor_end = h->stor_begin + alloc_size;
    h->end = h->stor_begin;
    h->destroy = 1;

    return 0;
}

int igraph_indheap_clear(igraph_indheap_t *h) {
    h->end = h->stor_begin;
    return 0;
}

/**
 * \ingroup indheap
 * \brief Initializes and build an indexed heap from a C array (constructor).
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_indheap_init_array     (igraph_indheap_t *h, igraph_real_t* data, long int len) {
    long int i;

    h->stor_begin = IGRAPH_CALLOC(len, igraph_real_t);
    if (h->stor_begin == 0) {
        h->index_begin = 0;
        IGRAPH_ERROR("indheap init from array failed", IGRAPH_ENOMEM);
    }
    h->index_begin = IGRAPH_CALLOC(len, long int);
    if (h->index_begin == 0) {
        IGRAPH_FREE(h->stor_begin);
        h->stor_begin = 0;
        IGRAPH_ERROR("indheap init from array failed", IGRAPH_ENOMEM);
    }
    h->stor_end = h->stor_begin + len;
    h->end = h->stor_end;
    h->destroy = 1;

    memcpy(h->stor_begin, data, (size_t) len * sizeof(igraph_real_t));
    for (i = 0; i < len; i++) {
        h->index_begin[i] = i + 1;
    }

    igraph_indheap_i_build (h, 0);

    return 0;
}

/**
 * \ingroup indheap
 * \brief Destroys an initialized indexed heap.
 */

void igraph_indheap_destroy        (igraph_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    if (h->destroy) {
        if (h->stor_begin != 0) {
            IGRAPH_FREE(h->stor_begin);
            h->stor_begin = 0;
        }
        if (h->index_begin != 0) {
            IGRAPH_FREE(h->index_begin);
            h->index_begin = 0;
        }
    }
}

/**
 * \ingroup indheap
 * \brief Checks whether a heap is empty.
 */

igraph_bool_t igraph_indheap_empty          (igraph_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    return h->stor_begin == h->end;
}

/**
 * \ingroup indheap
 * \brief Adds an element to an indexed heap.
 */

int igraph_indheap_push           (igraph_indheap_t* h, igraph_real_t elem) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    /* full, allocate more storage */
    if (h->stor_end == h->end) {
        long int new_size = igraph_indheap_size(h) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(igraph_indheap_reserve(h, new_size));
    }

    *(h->end) = elem;
    h->end += 1;
    *(h->index_begin + igraph_indheap_size(h) - 1) = igraph_indheap_size(h) - 1;

    /* maintain indheap */
    igraph_indheap_i_shift_up(h, igraph_indheap_size(h) - 1);

    return 0;
}

/**
 * \ingroup indheap
 * \brief Adds an element to an indexed heap with a given index.
 */

int igraph_indheap_push_with_index(igraph_indheap_t* h, long int idx, igraph_real_t elem) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    /* full, allocate more storage */
    if (h->stor_end == h->end) {
        long int new_size = igraph_indheap_size(h) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(igraph_indheap_reserve(h, new_size));
    }

    *(h->end) = elem;
    h->end += 1;
    *(h->index_begin + igraph_indheap_size(h) - 1) = idx;

    /* maintain indheap */
    igraph_indheap_i_shift_up(h, igraph_indheap_size(h) - 1);

    return 0;
}

/**
 * \ingroup indheap
 * \brief Modifies an element in an indexed heap.
 */

int igraph_indheap_modify(igraph_indheap_t* h, long int idx, igraph_real_t elem) {
    long int i, n;

    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    n = igraph_indheap_size(h);
    for (i = 0; i < n; i++)
        if (h->index_begin[i] == idx) {
            h->stor_begin[i] = elem;
            break;
        }

    if (i == n) {
        return 0;
    }

    /* maintain indheap */
    igraph_indheap_i_build(h, 0);

    return 0;
}

/**
 * \ingroup indheap
 * \brief Returns the largest element in an indexed heap.
 */

igraph_real_t igraph_indheap_max       (igraph_indheap_t* h) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);
    IGRAPH_ASSERT(h->stor_begin != h->end);

    return h->stor_begin[0];
}

/**
 * \ingroup indheap
 * \brief Removes the largest element from an indexed heap.
 */

igraph_real_t igraph_indheap_delete_max(igraph_indheap_t* h) {
    igraph_real_t tmp;

    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);

    tmp = h->stor_begin[0];
    igraph_indheap_i_switch(h, 0, igraph_indheap_size(h) - 1);
    h->end -= 1;
    igraph_indheap_i_sink(h, 0);

    return tmp;
}

/**
 * \ingroup indheap
 * \brief Gives the number of elements in an indexed heap.
 */

long int igraph_indheap_size      (igraph_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    return h->end - h->stor_begin;
}

/**
 * \ingroup indheap
 * \brief Reserves more memory for an indexed heap.
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_indheap_reserve        (igraph_indheap_t* h, long int size) {
    long int actual_size = igraph_indheap_size(h);
    igraph_real_t *tmp1;
    long int *tmp2;
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    if (size <= actual_size) {
        return 0;
    }

    tmp1 = IGRAPH_CALLOC(size, igraph_real_t);
    if (tmp1 == 0) {
        IGRAPH_ERROR("indheap reserve failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp1);
    tmp2 = IGRAPH_CALLOC(size, long int);
    if (tmp2 == 0) {
        IGRAPH_ERROR("indheap reserve failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp2);
    memcpy(tmp1, h->stor_begin, (size_t) actual_size * sizeof(igraph_real_t));
    memcpy(tmp2, h->index_begin, (size_t) actual_size * sizeof(long int));
    IGRAPH_FREE(h->stor_begin);
    IGRAPH_FREE(h->index_begin);

    h->stor_begin = tmp1;
    h->index_begin = tmp2;
    h->stor_end = h->stor_begin + size;
    h->end = h->stor_begin + actual_size;

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

/**
 * \ingroup indheap
 * \brief Returns the index of the largest element in an indexed heap.
 */

long int igraph_indheap_max_index(igraph_indheap_t *h) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    return h->index_begin[0];
}

/**
 * \ingroup indheap
 * \brief Builds an indexed heap, this function should not be called
 * directly.
 */

static void igraph_indheap_i_build(igraph_indheap_t* h, long int head) {

    long int size = igraph_indheap_size(h);
    if (RIGHTCHILD(head) < size) {
        /* both subtrees */
        igraph_indheap_i_build(h, LEFTCHILD(head) );
        igraph_indheap_i_build(h, RIGHTCHILD(head));
        igraph_indheap_i_sink(h, head);
    } else if (LEFTCHILD(head) < size) {
        /* only left */
        igraph_indheap_i_build(h, LEFTCHILD(head));
        igraph_indheap_i_sink(h, head);
    } else {
        /* none */
    }
}

/**
 * \ingroup indheap
 * \brief Moves an element up in the heap, don't call this function
 * directly.
 */

static void igraph_indheap_i_shift_up(igraph_indheap_t *h, long int elem) {

    if (elem == 0 || h->stor_begin[elem] < h->stor_begin[PARENT(elem)]) {
        /* at the top */
    } else {
        igraph_indheap_i_switch(h, elem, PARENT(elem));
        igraph_indheap_i_shift_up(h, PARENT(elem));
    }
}

/**
 * \ingroup indheap
 * \brief Moves an element down in the heap, don't call this function
 * directly.
 */

static void igraph_indheap_i_sink(igraph_indheap_t* h, long int head) {

    long int size = igraph_indheap_size(h);
    if (LEFTCHILD(head) >= size) {
        /* no subtrees */
    } else if (RIGHTCHILD(head) == size ||
               h->stor_begin[LEFTCHILD(head)] >= h->stor_begin[RIGHTCHILD(head)]) {
        /* sink to the left if needed */
        if (h->stor_begin[head] < h->stor_begin[LEFTCHILD(head)]) {
            igraph_indheap_i_switch(h, head, LEFTCHILD(head));
            igraph_indheap_i_sink(h, LEFTCHILD(head));
        }
    } else {
        /* sink to the right */
        if (h->stor_begin[head] < h->stor_begin[RIGHTCHILD(head)]) {
            igraph_indheap_i_switch(h, head, RIGHTCHILD(head));
            igraph_indheap_i_sink(h, RIGHTCHILD(head));
        }
    }
}

/**
 * \ingroup indheap
 * \brief Switches two elements in a heap, don't call this function
 * directly.
 */

static void igraph_indheap_i_switch(igraph_indheap_t* h, long int e1, long int e2) {
    if (e1 != e2) {
        igraph_real_t tmp = h->stor_begin[e1];
        h->stor_begin[e1] = h->stor_begin[e2];
        h->stor_begin[e2] = tmp;

        tmp = h->index_begin[e1];
        h->index_begin[e1] = h->index_begin[e2];
        h->index_begin[e2] = (long int) tmp;
    }
}

/*************************************************/

/* -------------------------------------------------- */
/* Doubly indexed heap                                */
/* -------------------------------------------------- */

/* static void igraph_d_indheap_i_build(igraph_d_indheap_t* h, long int head); */ /* Unused function */
static void igraph_d_indheap_i_shift_up(igraph_d_indheap_t* h, long int elem);
static void igraph_d_indheap_i_sink(igraph_d_indheap_t* h, long int head);
static void igraph_d_indheap_i_switch(igraph_d_indheap_t* h, long int e1, long int e2);

/**
 * \ingroup doubleindheap
 * \brief Initializes an empty doubly indexed heap object (constructor).
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_d_indheap_init           (igraph_d_indheap_t* h, long int alloc_size) {
    if (alloc_size <= 0 ) {
        alloc_size = 1;
    }
    h->stor_begin = IGRAPH_CALLOC(alloc_size, igraph_real_t);
    if (h->stor_begin == 0) {
        h->index_begin = 0;
        h->index2_begin = 0;
        IGRAPH_ERROR("d_indheap init failed", IGRAPH_ENOMEM);
    }
    h->stor_end = h->stor_begin + alloc_size;
    h->end = h->stor_begin;
    h->destroy = 1;
    h->index_begin = IGRAPH_CALLOC(alloc_size, long int);
    if (h->index_begin == 0) {
        IGRAPH_FREE(h->stor_begin);
        h->stor_begin = 0;
        h->index2_begin = 0;
        IGRAPH_ERROR("d_indheap init failed", IGRAPH_ENOMEM);
    }
    h->index2_begin = IGRAPH_CALLOC(alloc_size, long int);
    if (h->index2_begin == 0) {
        IGRAPH_FREE(h->stor_begin);
        IGRAPH_FREE(h->index_begin);
        h->stor_begin = 0;
        h->index_begin = 0;
        IGRAPH_ERROR("d_indheap init failed", IGRAPH_ENOMEM);
    }

    return 0;
}

/**
 * \ingroup doubleindheap
 * \brief Destroys an initialized doubly indexed heap object.
 */

void igraph_d_indheap_destroy        (igraph_d_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    if (h->destroy) {
        if (h->stor_begin != 0) {
            IGRAPH_FREE(h->stor_begin);
            h->stor_begin = 0;
        }
        if (h->index_begin != 0) {
            IGRAPH_FREE(h->index_begin);
            h->index_begin = 0;
        }
        if (h->index2_begin != 0) {
            IGRAPH_FREE(h->index2_begin);
            h->index2_begin = 0;
        }
    }
}

/**
 * \ingroup doubleindheap
 * \brief Decides whether a heap is empty.
 */

igraph_bool_t igraph_d_indheap_empty          (igraph_d_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    return h->stor_begin == h->end;
}

/**
 * \ingroup doubleindheap
 * \brief Adds an element to the heap.
 */

int igraph_d_indheap_push           (igraph_d_indheap_t* h, igraph_real_t elem,
                                     long int idx, long int idx2) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    /* full, allocate more storage */
    if (h->stor_end == h->end) {
        long int new_size = igraph_d_indheap_size(h) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(igraph_d_indheap_reserve(h, new_size));
    }

    *(h->end) = elem;
    h->end += 1;
    *(h->index_begin + igraph_d_indheap_size(h) - 1) = idx ;
    *(h->index2_begin + igraph_d_indheap_size(h) - 1) = idx2 ;

    /* maintain d_indheap */
    igraph_d_indheap_i_shift_up(h, igraph_d_indheap_size(h) - 1);

    return 0;
}

/**
 * \ingroup doubleindheap
 * \brief Returns the largest element in the heap.
 */

igraph_real_t igraph_d_indheap_max       (igraph_d_indheap_t* h) {
    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);
    IGRAPH_ASSERT(h->stor_begin != h->end);

    return h->stor_begin[0];
}

/**
 * \ingroup doubleindheap
 * \brief Removes the largest element from the heap.
 */

igraph_real_t igraph_d_indheap_delete_max(igraph_d_indheap_t* h) {
    igraph_real_t tmp;

    IGRAPH_ASSERT(h != NULL);
    IGRAPH_ASSERT(h->stor_begin != NULL);

    tmp = h->stor_begin[0];
    igraph_d_indheap_i_switch(h, 0, igraph_d_indheap_size(h) - 1);
    h->end -= 1;
    igraph_d_indheap_i_sink(h, 0);

    return tmp;
}

/**
 * \ingroup doubleindheap
 * \brief Gives the number of elements in the heap.
 */

long int igraph_d_indheap_size      (igraph_d_indheap_t* h) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    return h->end - h->stor_begin;
}

/**
 * \ingroup doubleindheap
 * \brief Allocates memory for a heap.
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_d_indheap_reserve        (igraph_d_indheap_t* h, long int size) {
    long int actual_size = igraph_d_indheap_size(h);
    igraph_real_t *tmp1;
    long int *tmp2, *tmp3;
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);

    if (size <= actual_size) {
        return 0;
    }

    tmp1 = IGRAPH_CALLOC(size, igraph_real_t);
    if (tmp1 == 0) {
        IGRAPH_ERROR("d_indheap reserve failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp1);
    tmp2 = IGRAPH_CALLOC(size, long int);
    if (tmp2 == 0) {
        IGRAPH_ERROR("d_indheap reserve failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp2);
    tmp3 = IGRAPH_CALLOC(size, long int);
    if (tmp3 == 0) {
        IGRAPH_ERROR("d_indheap reserve failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, tmp3);

    memcpy(tmp1, h->stor_begin, (size_t) actual_size * sizeof(igraph_real_t));
    memcpy(tmp2, h->index_begin, (size_t) actual_size * sizeof(long int));
    memcpy(tmp3, h->index2_begin, (size_t) actual_size * sizeof(long int));
    IGRAPH_FREE(h->stor_begin);
    IGRAPH_FREE(h->index_begin);
    IGRAPH_FREE(h->index2_begin);

    h->stor_begin = tmp1;
    h->stor_end = h->stor_begin + size;
    h->end = h->stor_begin + actual_size;
    h->index_begin = tmp2;
    h->index2_begin = tmp3;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

/**
 * \ingroup doubleindheap
 * \brief Gives the indices of the maximal element in the heap.
 */

void igraph_d_indheap_max_index(igraph_d_indheap_t *h, long int *idx, long int *idx2) {
    IGRAPH_ASSERT(h != 0);
    IGRAPH_ASSERT(h->stor_begin != 0);
    (*idx) = h->index_begin[0];
    (*idx2) = h->index2_begin[0];
}

/**
 * \ingroup doubleindheap
 * \brief Builds the heap, don't call it directly.
 */

/* Unused function, temporarily disabled */
#if 0
static void igraph_d_indheap_i_build(igraph_d_indheap_t* h, long int head) {

    long int size = igraph_d_indheap_size(h);
    if (RIGHTCHILD(head) < size) {
        /* both subtrees */
        igraph_d_indheap_i_build(h, LEFTCHILD(head) );
        igraph_d_indheap_i_build(h, RIGHTCHILD(head));
        igraph_d_indheap_i_sink(h, head);
    } else if (LEFTCHILD(head) < size) {
        /* only left */
        igraph_d_indheap_i_build(h, LEFTCHILD(head));
        igraph_d_indheap_i_sink(h, head);
    } else {
        /* none */
    }
}
#endif

/**
 * \ingroup doubleindheap
 * \brief Moves an element up in the heap, don't call it directly.
 */

static void igraph_d_indheap_i_shift_up(igraph_d_indheap_t *h, long int elem) {

    if (elem == 0 || h->stor_begin[elem] < h->stor_begin[PARENT(elem)]) {
        /* at the top */
    } else {
        igraph_d_indheap_i_switch(h, elem, PARENT(elem));
        igraph_d_indheap_i_shift_up(h, PARENT(elem));
    }
}

/**
 * \ingroup doubleindheap
 * \brief Moves an element down in the heap, don't call it directly.
 */

static void igraph_d_indheap_i_sink(igraph_d_indheap_t* h, long int head) {

    long int size = igraph_d_indheap_size(h);
    if (LEFTCHILD(head) >= size) {
        /* no subtrees */
    } else if (RIGHTCHILD(head) == size ||
               h->stor_begin[LEFTCHILD(head)] >= h->stor_begin[RIGHTCHILD(head)]) {
        /* sink to the left if needed */
        if (h->stor_begin[head] < h->stor_begin[LEFTCHILD(head)]) {
            igraph_d_indheap_i_switch(h, head, LEFTCHILD(head));
            igraph_d_indheap_i_sink(h, LEFTCHILD(head));
        }
    } else {
        /* sink to the right */
        if (h->stor_begin[head] < h->stor_begin[RIGHTCHILD(head)]) {
            igraph_d_indheap_i_switch(h, head, RIGHTCHILD(head));
            igraph_d_indheap_i_sink(h, RIGHTCHILD(head));
        }
    }
}

/**
 * \ingroup doubleindheap
 * \brief Switches two elements in the heap, don't call it directly.
 */

static void igraph_d_indheap_i_switch(igraph_d_indheap_t* h, long int e1, long int e2) {
    if (e1 != e2) {
        long int tmpi;
        igraph_real_t tmp = h->stor_begin[e1];
        h->stor_begin[e1] = h->stor_begin[e2];
        h->stor_begin[e2] = tmp;

        tmpi = h->index_begin[e1];
        h->index_begin[e1] = h->index_begin[e2];
        h->index_begin[e2] = tmpi;

        tmpi = h->index2_begin[e1];
        h->index2_begin[e1] = h->index2_begin[e2];
        h->index2_begin[e2] = tmpi;
    }
}

/*************************************************/

/* -------------------------------------------------- */
/* Two-way indexed heap                               */
/* -------------------------------------------------- */

#undef PARENT
#undef LEFTCHILD
#undef RIGHTCHILD
#define PARENT(x)     (((x)+1)/2-1)
#define LEFTCHILD(x)  (((x)+1)*2-1)
#define RIGHTCHILD(x) (((x)+1)*2)

/* This is a smart indexed heap. In addition to the "normal" indexed heap
   it allows to access every element through its index in O(1) time.
   In other words, for this heap the indexing operation is O(1), the
   normal heap does this in O(n) time.... */

static void igraph_i_2wheap_switch(igraph_2wheap_t *h,
                                   long int e1, long int e2) {
    if (e1 != e2) {
        long int tmp1, tmp2;
        igraph_real_t tmp3 = VECTOR(h->data)[e1];
        VECTOR(h->data)[e1] = VECTOR(h->data)[e2];
        VECTOR(h->data)[e2] = tmp3;

        tmp1 = VECTOR(h->index)[e1];
        tmp2 = VECTOR(h->index)[e2];

        VECTOR(h->index2)[tmp1] = e2 + 2;
        VECTOR(h->index2)[tmp2] = e1 + 2;

        VECTOR(h->index)[e1] = tmp2;
        VECTOR(h->index)[e2] = tmp1;
    }
}

static void igraph_i_2wheap_shift_up(igraph_2wheap_t *h,
                                     long int elem) {
    if (elem == 0 || VECTOR(h->data)[elem] < VECTOR(h->data)[PARENT(elem)]) {
        /* at the top */
    } else {
        igraph_i_2wheap_switch(h, elem, PARENT(elem));
        igraph_i_2wheap_shift_up(h, PARENT(elem));
    }
}

static void igraph_i_2wheap_sink(igraph_2wheap_t *h,
                                 long int head) {
    long int size = igraph_2wheap_size(h);
    if (LEFTCHILD(head) >= size) {
        /* no subtrees */
    } else if (RIGHTCHILD(head) == size ||
               VECTOR(h->data)[LEFTCHILD(head)] >= VECTOR(h->data)[RIGHTCHILD(head)]) {
        /* sink to the left if needed */
        if (VECTOR(h->data)[head] < VECTOR(h->data)[LEFTCHILD(head)]) {
            igraph_i_2wheap_switch(h, head, LEFTCHILD(head));
            igraph_i_2wheap_sink(h, LEFTCHILD(head));
        }
    } else {
        /* sink to the right */
        if (VECTOR(h->data)[head] < VECTOR(h->data)[RIGHTCHILD(head)]) {
            igraph_i_2wheap_switch(h, head, RIGHTCHILD(head));
            igraph_i_2wheap_sink(h, RIGHTCHILD(head));
        }
    }
}

/* ------------------ */
/* These are public   */
/* ------------------ */

int igraph_2wheap_init(igraph_2wheap_t *h, long int size) {
    h->size = size;
    /* We start with the biggest */
    IGRAPH_CHECK(igraph_vector_long_init(&h->index2, size));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &h->index2);
    IGRAPH_VECTOR_INIT_FINALLY(&h->data, 0);
    IGRAPH_CHECK(igraph_vector_long_init(&h->index, 0));
    /* IGRAPH_FINALLY(igraph_vector_long_destroy, &h->index); */

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

void igraph_2wheap_destroy(igraph_2wheap_t *h) {
    igraph_vector_destroy(&h->data);
    igraph_vector_long_destroy(&h->index);
    igraph_vector_long_destroy(&h->index2);
}

int igraph_2wheap_clear(igraph_2wheap_t *h) {
    igraph_vector_clear(&h->data);
    igraph_vector_long_clear(&h->index);
    igraph_vector_long_null(&h->index2);
    return 0;
}

igraph_bool_t igraph_2wheap_empty(const igraph_2wheap_t *h) {
    return igraph_vector_empty(&h->data);
}

int igraph_2wheap_push_with_index(igraph_2wheap_t *h,
                                  long int idx, igraph_real_t elem) {

    /*   printf("-> %.2g [%li]\n", elem, idx); */

    long int size = igraph_vector_size(&h->data);
    IGRAPH_CHECK(igraph_vector_push_back(&h->data, elem));
    IGRAPH_CHECK(igraph_vector_long_push_back(&h->index, idx));
    VECTOR(h->index2)[idx] = size + 2;

    /* maintain heap */
    igraph_i_2wheap_shift_up(h, size);
    return 0;
}

long int igraph_2wheap_size(const igraph_2wheap_t *h) {
    return igraph_vector_size(&h->data);
}

long int igraph_2wheap_max_size(const igraph_2wheap_t *h) {
    return h->size;
}

igraph_real_t igraph_2wheap_max(const igraph_2wheap_t *h) {
    return VECTOR(h->data)[0];
}

long int igraph_2wheap_max_index(const igraph_2wheap_t *h) {
    return VECTOR(h->index)[0];
}

igraph_bool_t igraph_2wheap_has_elem(const igraph_2wheap_t *h, long int idx) {
    return VECTOR(h->index2)[idx] != 0;
}

igraph_bool_t igraph_2wheap_has_active(const igraph_2wheap_t *h, long int idx) {
    return VECTOR(h->index2)[idx] > 1;
}

igraph_real_t igraph_2wheap_get(const igraph_2wheap_t *h, long int idx) {
    long int i = VECTOR(h->index2)[idx] - 2;
    return VECTOR(h->data)[i];
}

igraph_real_t igraph_2wheap_delete_max(igraph_2wheap_t *h) {

    igraph_real_t tmp = VECTOR(h->data)[0];
    long int tmpidx = VECTOR(h->index)[0];
    igraph_i_2wheap_switch(h, 0, igraph_2wheap_size(h) - 1);
    igraph_vector_pop_back(&h->data);
    igraph_vector_long_pop_back(&h->index);
    VECTOR(h->index2)[tmpidx] = 0;
    igraph_i_2wheap_sink(h, 0);

    /*   printf("<-max %.2g\n", tmp); */

    return tmp;
}

igraph_real_t igraph_2wheap_deactivate_max(igraph_2wheap_t *h) {

    igraph_real_t tmp = VECTOR(h->data)[0];
    long int tmpidx = VECTOR(h->index)[0];
    igraph_i_2wheap_switch(h, 0, igraph_2wheap_size(h) - 1);
    igraph_vector_pop_back(&h->data);
    igraph_vector_long_pop_back(&h->index);
    VECTOR(h->index2)[tmpidx] = 1;
    igraph_i_2wheap_sink(h, 0);

    return tmp;
}

igraph_real_t igraph_2wheap_delete_max_index(igraph_2wheap_t *h, long int *idx) {

    igraph_real_t tmp = VECTOR(h->data)[0];
    long int tmpidx = VECTOR(h->index)[0];
    igraph_i_2wheap_switch(h, 0, igraph_2wheap_size(h) - 1);
    igraph_vector_pop_back(&h->data);
    igraph_vector_long_pop_back(&h->index);
    VECTOR(h->index2)[tmpidx] = 0;
    igraph_i_2wheap_sink(h, 0);

    if (idx) {
        *idx = tmpidx;
    }
    return tmp;
}

int igraph_2wheap_modify(igraph_2wheap_t *h, long int idx, igraph_real_t elem) {

    long int pos = VECTOR(h->index2)[idx] - 2;

    /*   printf("-- %.2g -> %.2g\n", VECTOR(h->data)[pos], elem); */

    VECTOR(h->data)[pos] = elem;
    igraph_i_2wheap_sink(h, pos);
    igraph_i_2wheap_shift_up(h, pos);

    return 0;
}

/* Check that the heap is in a consistent state */

int igraph_2wheap_check(igraph_2wheap_t *h) {
    long int size = igraph_2wheap_size(h);
    long int i;
    igraph_bool_t error = 0;

    /* Check the heap property */
    for (i = 0; i < size; i++) {
        if (LEFTCHILD(i) >= size) {
            break;
        }
        if (VECTOR(h->data)[LEFTCHILD(i)] > VECTOR(h->data)[i]) {
            error = 1; break;
        }
        if (RIGHTCHILD(i) >= size) {
            break;
        }
        if (VECTOR(h->data)[RIGHTCHILD(i)] > VECTOR(h->data)[i]) {
            error = 1; break;
        }
    }

    if (error) {
        IGRAPH_ERROR("Inconsistent heap", IGRAPH_EINTERNAL);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/indheap.h0000644000175100001710000001346500000000000023163 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_INDHEAP_H
#define IGRAPH_CORE_INDHEAP_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Indexed heap                                       */
/* -------------------------------------------------- */

/**
 * Indexed heap data type.
 * \ingroup internal
 */

typedef struct s_indheap {
    igraph_real_t* stor_begin;
    igraph_real_t* stor_end;
    igraph_real_t* end;
    int destroy;
    long int* index_begin;
} igraph_indheap_t;

#define IGRAPH_INDHEAP_NULL { 0,0,0,0,0 }

int igraph_indheap_init           (igraph_indheap_t* h, long int size);
int igraph_indheap_init_array     (igraph_indheap_t *t, igraph_real_t* data, long int len);
void igraph_indheap_destroy        (igraph_indheap_t* h);
int igraph_indheap_clear(igraph_indheap_t *h);
igraph_bool_t igraph_indheap_empty          (igraph_indheap_t* h);
int igraph_indheap_push           (igraph_indheap_t* h, igraph_real_t elem);
int igraph_indheap_push_with_index(igraph_indheap_t* h, long int idx, igraph_real_t elem);
int igraph_indheap_modify(igraph_indheap_t* h, long int idx, igraph_real_t elem);
igraph_real_t igraph_indheap_max       (igraph_indheap_t* h);
igraph_real_t igraph_indheap_delete_max(igraph_indheap_t* h);
long int igraph_indheap_size      (igraph_indheap_t* h);
int igraph_indheap_reserve        (igraph_indheap_t* h, long int size);
long int igraph_indheap_max_index(igraph_indheap_t *h);


/* -------------------------------------------------- */
/* Doubly indexed heap                                */
/* -------------------------------------------------- */

/* This is a heap containing double elements and
   two indices, its intended usage is the storage of
   weighted edges.
*/

/**
 * Doubly indexed heap data type.
 * \ingroup internal
 */

typedef struct s_indheap_d {
    igraph_real_t* stor_begin;
    igraph_real_t* stor_end;
    igraph_real_t* end;
    int destroy;
    long int* index_begin;
    long int* index2_begin;
} igraph_d_indheap_t;


#define IGRAPH_D_INDHEAP_NULL { 0,0,0,0,0,0 }

IGRAPH_PRIVATE_EXPORT int igraph_d_indheap_init(igraph_d_indheap_t *h, long int size);
IGRAPH_PRIVATE_EXPORT void igraph_d_indheap_destroy(igraph_d_indheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_d_indheap_empty(igraph_d_indheap_t *h);
IGRAPH_PRIVATE_EXPORT int igraph_d_indheap_push(igraph_d_indheap_t *h, igraph_real_t elem,
                                                long int idx, long int idx2);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_d_indheap_max(igraph_d_indheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_d_indheap_delete_max(igraph_d_indheap_t *h);
IGRAPH_PRIVATE_EXPORT long int igraph_d_indheap_size(igraph_d_indheap_t *h);
IGRAPH_PRIVATE_EXPORT int igraph_d_indheap_reserve(igraph_d_indheap_t *h, long int size);
IGRAPH_PRIVATE_EXPORT void igraph_d_indheap_max_index(igraph_d_indheap_t *h, long int *idx, long int *idx2);

/* -------------------------------------------------- */
/* Two-way indexed heap                               */
/* -------------------------------------------------- */

/* This is a smart indexed heap. In addition to the "normal" indexed heap
   it allows to access every element through its index in O(1) time.
   In other words, for this heap the _modify operation is O(1), the
   normal heap does this in O(n) time.... */

typedef struct igraph_2wheap_t {
    long int size;
    igraph_vector_t data;
    igraph_vector_long_t index;
    igraph_vector_long_t index2;
} igraph_2wheap_t;

IGRAPH_PRIVATE_EXPORT int igraph_2wheap_init(igraph_2wheap_t *h, long int size);
IGRAPH_PRIVATE_EXPORT void igraph_2wheap_destroy(igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT int igraph_2wheap_clear(igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT int igraph_2wheap_push_with_index(igraph_2wheap_t *h,
                                                        long int idx, igraph_real_t elem);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_2wheap_empty(const igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT long int igraph_2wheap_size(const igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT long int igraph_2wheap_max_size(const igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_2wheap_max(const igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT long int igraph_2wheap_max_index(const igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_2wheap_deactivate_max(igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_2wheap_has_elem(const igraph_2wheap_t *h, long int idx);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_2wheap_has_active(const igraph_2wheap_t *h, long int idx);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_2wheap_get(const igraph_2wheap_t *h, long int idx);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_2wheap_delete_max(igraph_2wheap_t *h);
IGRAPH_PRIVATE_EXPORT igraph_real_t igraph_2wheap_delete_max_index(igraph_2wheap_t *h, long int *idx);
IGRAPH_PRIVATE_EXPORT int igraph_2wheap_modify(igraph_2wheap_t *h, long int idx, igraph_real_t elem);
IGRAPH_PRIVATE_EXPORT int igraph_2wheap_check(igraph_2wheap_t *h);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/interruption.c0000644000175100001710000000267400000000000024310 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_interrupt.h"
#include "config.h"

IGRAPH_THREAD_LOCAL igraph_interruption_handler_t
*igraph_i_interruption_handler = 0;

int igraph_allow_interruption(void* data) {
    if (igraph_i_interruption_handler) {
        return igraph_i_interruption_handler(data);
    }
    return IGRAPH_SUCCESS;
}

igraph_interruption_handler_t *
igraph_set_interruption_handler (igraph_interruption_handler_t * new_handler) {
    igraph_interruption_handler_t * previous_handler = igraph_i_interruption_handler;
    igraph_i_interruption_handler = new_handler;
    return previous_handler;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/interruption.h0000644000175100001710000000352100000000000024305 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_INTERRUPT_INTERNAL_H
#define IGRAPH_INTERRUPT_INTERNAL_H

#include "igraph_decls.h"
#include "igraph_interrupt.h"
#include "config.h"

__BEGIN_DECLS

extern IGRAPH_THREAD_LOCAL igraph_interruption_handler_t
*igraph_i_interruption_handler;

/**
 * \define IGRAPH_ALLOW_INTERRUPTION
 * \brief
 *
 * This macro should be called when interruption is allowed.  It calls
 * \ref igraph_allow_interruption() with the proper parameters and if that returns
 * anything but \c IGRAPH_SUCCESS then
 * the macro returns the "calling" function as well, with the proper
 * error code (\c IGRAPH_INTERRUPTED).
 */

#define IGRAPH_ALLOW_INTERRUPTION() \
    do { \
        if (igraph_i_interruption_handler) { if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) return IGRAPH_INTERRUPTED; \
        } } while (0)

#define IGRAPH_ALLOW_INTERRUPTION_NORETURN() \
    do { \
        if (igraph_i_interruption_handler) { igraph_allow_interruption(NULL); } \
    } while (0)

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/marked_queue.c0000644000175100001710000000651300000000000024211 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "core/marked_queue.h"

#define BATCH_MARKER -1

int igraph_marked_queue_init(igraph_marked_queue_t *q,
                             long int size) {
    IGRAPH_CHECK(igraph_dqueue_init(&q->Q, 0));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &q->Q);
    IGRAPH_CHECK(igraph_vector_long_init(&q->set, size));
    q->mark = 1;
    q->size = 0;
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

void igraph_marked_queue_destroy(igraph_marked_queue_t *q) {
    igraph_vector_long_destroy(&q->set);
    igraph_dqueue_destroy(&q->Q);
}

void igraph_marked_queue_reset(igraph_marked_queue_t *q) {
    igraph_dqueue_clear(&q->Q);
    q->size = 0;
    q->mark += 1;
    if (q->mark == 0) {
        igraph_vector_long_null(&q->set);
        q->mark += 1;
    }
}

igraph_bool_t igraph_marked_queue_empty(const igraph_marked_queue_t *q) {
    return q->size == 0;
}

long int igraph_marked_queue_size(const igraph_marked_queue_t *q) {
    return q->size;
}

igraph_bool_t igraph_marked_queue_iselement(const igraph_marked_queue_t *q,
        long int elem) {
    return (VECTOR(q->set)[elem] == q->mark);
}

int igraph_marked_queue_push(igraph_marked_queue_t *q, long int elem) {
    if (VECTOR(q->set)[elem] != q->mark) {
        IGRAPH_CHECK(igraph_dqueue_push(&q->Q, elem));
        VECTOR(q->set)[elem] = q->mark;
        q->size += 1;
    }
    return 0;
}

int igraph_marked_queue_start_batch(igraph_marked_queue_t *q) {
    IGRAPH_CHECK(igraph_dqueue_push(&q->Q, BATCH_MARKER));
    return 0;
}

void igraph_marked_queue_pop_back_batch(igraph_marked_queue_t *q) {
    long int size = igraph_dqueue_size(&q->Q);
    long int elem;
    while (size > 0 &&
           (elem = (long int) igraph_dqueue_pop_back(&q->Q)) != BATCH_MARKER) {
        VECTOR(q->set)[elem] = 0;
        size--;
        q->size--;
    }
}

#ifndef USING_R
int igraph_marked_queue_print(const igraph_marked_queue_t *q) {
    IGRAPH_CHECK(igraph_dqueue_print(&q->Q));
    return 0;
}
#endif

int igraph_marked_queue_fprint(const igraph_marked_queue_t *q, FILE *file) {
    IGRAPH_CHECK(igraph_dqueue_fprint(&q->Q, file));
    return 0;
}

int igraph_marked_queue_as_vector(const igraph_marked_queue_t *q,
                                  igraph_vector_t *vec) {
    long int i, p, n = igraph_dqueue_size(&q->Q);
    IGRAPH_CHECK(igraph_vector_resize(vec, q->size));
    for (i = 0, p = 0; i < n; i++) {
        igraph_real_t e = igraph_dqueue_e(&q->Q, i);
        if (e != BATCH_MARKER) {
            VECTOR(*vec)[p++] = e;
        }
    }
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/marked_queue.h0000644000175100001710000000546200000000000024220 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MARKED_QUEUE_H
#define IGRAPH_MARKED_QUEUE_H

#include "igraph_vector.h"
#include "igraph_dqueue.h"

#include 

/* This is essentially a double ended queue, with some extra features:
   (1) The is-element? operation is fast, O(1). This requires that we
       know a limit for the number of elements in the queue.
   (2) We can insert elements in batches, and the whole batch can be
      removed at once.

  Currently only the top-end operations are implemented, so the queue
  is essentially a stack.
*/

typedef struct igraph_marked_queue_t {
    igraph_dqueue_t Q;
    igraph_vector_long_t set;
    long int mark;
    long int size;
} igraph_marked_queue_t;

IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_init(igraph_marked_queue_t *q,
                                                   long int size);
IGRAPH_PRIVATE_EXPORT void igraph_marked_queue_destroy(igraph_marked_queue_t *q);
IGRAPH_PRIVATE_EXPORT void igraph_marked_queue_reset(igraph_marked_queue_t *q);

IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_marked_queue_empty(const igraph_marked_queue_t *q);
IGRAPH_PRIVATE_EXPORT long int igraph_marked_queue_size(const igraph_marked_queue_t *q);

IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_print(const igraph_marked_queue_t *q);
IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_fprint(const igraph_marked_queue_t *q, FILE *file);

IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_marked_queue_iselement(const igraph_marked_queue_t *q,
                                                                  long int elem);
IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_push(igraph_marked_queue_t *q, long int elem);

IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_start_batch(igraph_marked_queue_t *q);
IGRAPH_PRIVATE_EXPORT void igraph_marked_queue_pop_back_batch(igraph_marked_queue_t *q);

IGRAPH_PRIVATE_EXPORT int igraph_marked_queue_as_vector(const igraph_marked_queue_t *q,
                                                        igraph_vector_t *vec);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/math.h0000644000175100001710000000447100000000000022501 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_MATH_H
#define IGRAPH_MATH_H

#include "igraph_decls.h"

#include "config.h"

#include 
#include 

__BEGIN_DECLS

/**
 * \def IGRAPH_SHORTEST_PATH_EPSILON
 *
 * Relative error threshold used in weighted shortest path calculations
 * to decide whether two shortest paths are of equal length.
 */
#define IGRAPH_SHORTEST_PATH_EPSILON 1e-10

/*
 * Compiler-related hacks, mostly because of Microsoft Visual C++
 */
double igraph_i_round(double X);
int igraph_i_snprintf(char *buffer, size_t count, const char *format, ...);

double igraph_log2(const double a);
double igraph_log1p(double a);
double igraph_fmin(double a, double b);
#ifndef HAVE_LOG2
    #define log2(a) igraph_log2(a)
#endif
#ifndef HAVE_LOG1P
    #define log1p(a) igraph_log1p(a)
#endif
#ifndef HAVE_FMIN
    #define fmin(a,b) igraph_fmin((a),(b))
#endif
#ifndef HAVE_ROUND
    #define round igraph_i_round
#endif

#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif
#ifndef M_PI_2
    #define M_PI_2 1.57079632679489661923
#endif
#ifndef M_LN2
    #define M_LN2 0.69314718055994530942
#endif
#ifndef M_SQRT2
    #define M_SQRT2 1.4142135623730950488016887
#endif
#ifndef M_LN_SQRT_2PI
    #define M_LN_SQRT_2PI   0.918938533204672741780329736406 /* log(sqrt(2*pi))
    == log(2*pi)/2 */
#endif

IGRAPH_PRIVATE_EXPORT int igraph_almost_equals(double a, double b, double eps);
IGRAPH_PRIVATE_EXPORT int igraph_cmp_epsilon(double a, double b, double eps);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/matrix.c0000644000175100001710000001152100000000000023041 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_matrix.h"

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_INT
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_LONG
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_COMPLEX
#include "igraph_pmt.h"
#include "matrix.pmt"
#include "igraph_pmt_off.h"
#undef BASE_COMPLEX

#ifndef USING_R
int igraph_matrix_complex_print(const igraph_matrix_complex_t *m) {

    long int nr = igraph_matrix_complex_nrow(m);
    long int nc = igraph_matrix_complex_ncol(m);
    long int i, j;
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            igraph_complex_t z = MATRIX(*m, i, j);
            if (j != 0) {
                putchar(' ');
            }
            printf("%g%+gi", IGRAPH_REAL(z), IGRAPH_IMAG(z));
        }
        printf("\n");
    }

    return 0;
}
#endif

int igraph_matrix_complex_fprint(const igraph_matrix_complex_t *m,
                                 FILE *file) {

    long int nr = igraph_matrix_complex_nrow(m);
    long int nc = igraph_matrix_complex_ncol(m);
    long int i, j;
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            igraph_complex_t z = MATRIX(*m, i, j);
            if (j != 0) {
                fputc(' ', file);
            }
            fprintf(file, "%g%+gi", IGRAPH_REAL(z), IGRAPH_IMAG(z));
        }
        fprintf(file, "\n");
    }

    return 0;
}

int igraph_matrix_complex_real(const igraph_matrix_complex_t *v,
                               igraph_matrix_t *real) {
    long int nrow = igraph_matrix_complex_nrow(v);
    long int ncol = igraph_matrix_complex_ncol(v);
    IGRAPH_CHECK(igraph_matrix_resize(real, nrow, ncol));
    IGRAPH_CHECK(igraph_vector_complex_real(&v->data, &real->data));
    return 0;
}

int igraph_matrix_complex_imag(const igraph_matrix_complex_t *v,
                               igraph_matrix_t *imag) {
    long int nrow = igraph_matrix_complex_nrow(v);
    long int ncol = igraph_matrix_complex_ncol(v);
    IGRAPH_CHECK(igraph_matrix_resize(imag, nrow, ncol));
    IGRAPH_CHECK(igraph_vector_complex_imag(&v->data, &imag->data));
    return 0;
}

int igraph_matrix_complex_realimag(const igraph_matrix_complex_t *v,
                                   igraph_matrix_t *real,
                                   igraph_matrix_t *imag) {
    long int nrow = igraph_matrix_complex_nrow(v);
    long int ncol = igraph_matrix_complex_ncol(v);
    IGRAPH_CHECK(igraph_matrix_resize(real, nrow, ncol));
    IGRAPH_CHECK(igraph_matrix_resize(imag, nrow, ncol));
    IGRAPH_CHECK(igraph_vector_complex_realimag(&v->data, &real->data,
                 &imag->data));
    return 0;
}

int igraph_matrix_complex_create(igraph_matrix_complex_t *v,
                                 const igraph_matrix_t *real,
                                 const igraph_matrix_t *imag) {
    IGRAPH_CHECK(igraph_vector_complex_create(&v->data, &real->data,
                 &imag->data));
    return 0;
}

int igraph_matrix_complex_create_polar(igraph_matrix_complex_t *v,
                                       const igraph_matrix_t *r,
                                       const igraph_matrix_t *theta) {
    IGRAPH_CHECK(igraph_vector_complex_create_polar(&v->data, &r->data,
                 &theta->data));
    return 0;
}

igraph_bool_t igraph_matrix_all_e_tol(const igraph_matrix_t *lhs,
                                      const igraph_matrix_t *rhs,
                                      igraph_real_t tol) {
    return igraph_vector_e_tol(&lhs->data, &rhs->data, tol);
}

int igraph_matrix_zapsmall(igraph_matrix_t *m, igraph_real_t tol) {
    return igraph_vector_zapsmall(&m->data, tol);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/matrix.pmt0000644000175100001710000014140600000000000023425 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_error.h"

#include          /* memcpy & co. */
#include 

/**
 * \section about_igraph_matrix_t_objects About \type igraph_matrix_t objects
 *
 * This type is just an interface to \type igraph_vector_t.
 *
 * The \type igraph_matrix_t type usually stores n
 * elements in O(n) space, but not always. See the documentation of
 * the vector type.
 */

/**
 * \section igraph_matrix_constructor_and_destructor Matrix constructors and
 * destructors
 */

/**
 * \ingroup matrix
 * \function igraph_matrix_init
 * \brief Initializes a matrix.
 *
 * 
 * Every matrix needs to be initialized before using it. This is done
 * by calling this function. A matrix has to be destroyed if it is not
 * needed any more; see \ref igraph_matrix_destroy().
 * \param m Pointer to a not yet initialized matrix object to be
 *        initialized.
 * \param nrow The number of rows in the matrix.
 * \param ncol The number of columns in the matrix.
 * \return Error code.
 *
 * Time complexity: usually O(n),
 * n is the
 * number of elements in the matrix.
 */

int FUNCTION(igraph_matrix, init)(TYPE(igraph_matrix) *m, long int nrow, long int ncol) {
    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(&m->data, nrow * ncol));
    m->nrow = nrow;
    m->ncol = ncol;
    return IGRAPH_SUCCESS;
}

const TYPE(igraph_matrix) *FUNCTION(igraph_matrix, view)(const TYPE(igraph_matrix) *m,
        const BASE *data,
        long int nrow,
        long int ncol) {
    TYPE(igraph_matrix) *m2 = (TYPE(igraph_matrix)*)m;
    FUNCTION(igraph_vector, view)(&m2->data, data, nrow * ncol);
    m2->nrow = nrow;
    m2->ncol = ncol;
    return m;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_destroy
 * \brief Destroys a matrix object.
 *
 * 
 * This function frees all the memory allocated for a matrix
 * object. The destroyed object needs to be reinitialized before using
 * it again.
 * \param m The matrix to destroy.
 *
 * Time complexity: operating system dependent.
 */

void FUNCTION(igraph_matrix, destroy)(TYPE(igraph_matrix) *m) {
    FUNCTION(igraph_vector, destroy)(&m->data);
}

/**
 * \ingroup matrix
 * \function igraph_matrix_capacity
 * \brief Returns the number of elements allocated for a matrix.
 *
 * Note that this might be different from the size of the matrix (as
 * queried by \ref igraph_matrix_size(), and specifies how many elements
 * the matrix can hold, without reallocation.
 * \param v Pointer to the (previously initialized) matrix object
 *          to query.
 * \return The allocated capacity.
 *
 * \sa \ref igraph_matrix_size(), \ref igraph_matrix_nrow(),
 * \ref igraph_matrix_ncol().
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_matrix, capacity)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, capacity)(&m->data);
}


/**
 * \section igraph_matrix_accessing_elements Accessing elements of a matrix
 */

/**
 * \ingroup matrix
 * \function igraph_matrix_resize
 * \brief Resizes a matrix.
 *
 * 
 * This function resizes a matrix by adding more elements to it.
 * The matrix contains arbitrary data after resizing it.
 * That is, after calling this function you cannot expect that element
 * (i,j) in the matrix remains the
 * same as before.
 * \param m Pointer to an already initialized matrix object.
 * \param nrow The number of rows in the resized matrix.
 * \param ncol The number of columns in the resized matrix.
 * \return Error code.
 *
 * Time complexity: O(1) if the
 * matrix gets smaller, usually O(n)
 * if it gets larger, n is the
 * number of elements in the resized matrix.
 */

int FUNCTION(igraph_matrix, resize)(TYPE(igraph_matrix) *m, long int nrow, long int ncol) {
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(&m->data, nrow * ncol));
    m->nrow = nrow;
    m->ncol = ncol;
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_resize_min
 * \brief Deallocates unused memory for a matrix.
 *
 * 
 * Note that this function might fail if there is not enough memory
 * available.
 *
 * 
 * Also note, that this function leaves the matrix intact, i.e.
 * it does not destroy any of the elements. However, usually it involves
 * copying the matrix in memory.
 * \param m Pointer to an initialized matrix.
 * \return Error code.
 *
 * \sa \ref igraph_matrix_resize().
 *
 * Time complexity: operating system dependent.
 */

int FUNCTION(igraph_matrix, resize_min)(TYPE(igraph_matrix) *m) {
    TYPE(igraph_vector) tmp;
    long int size = FUNCTION(igraph_matrix, size)(m);
    long int capacity = FUNCTION(igraph_matrix, capacity)(m);
    if (size == capacity) {
        return 0;
    }

    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(&tmp, size));
    FUNCTION(igraph_vector, update)(&tmp, &m->data);
    FUNCTION(igraph_vector, destroy)(&m->data);
    m->data = tmp;

    return 0;
}


/**
 * \ingroup matrix
 * \function igraph_matrix_size
 * \brief The number of elements in a matrix.
 *
 * \param m Pointer to an initialized matrix object.
 * \return The size of the matrix.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_matrix, size)(const TYPE(igraph_matrix) *m) {
    return (m->nrow) * (m->ncol);
}

/**
 * \ingroup matrix
 * \function igraph_matrix_nrow
 * \brief The number of rows in a matrix.
 *
 * \param m Pointer to an initialized matrix object.
 * \return The number of rows in the matrix.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_matrix, nrow)(const TYPE(igraph_matrix) *m) {
    return m->nrow;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_ncol
 * \brief The number of columns in a matrix.
 *
 * \param m Pointer to an initialized matrix object.
 * \return The number of columns in the matrix.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_matrix, ncol)(const TYPE(igraph_matrix) *m) {
    return m->ncol;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_copy_to
 * \brief Copies a matrix to a regular C array.
 *
 * 
 * The matrix is copied columnwise, as this is the format most
 * programs and languages use.
 * The C array should be of sufficient size; there are (of course) no
 * range checks.
 * \param m Pointer to an initialized matrix object.
 * \param to Pointer to a C array; the place to copy the data to.
 * \return Error code.
 *
 * Time complexity: O(n),
 * n is the number of
 * elements in the matrix.
 */

void FUNCTION(igraph_matrix, copy_to)(const TYPE(igraph_matrix) *m, BASE *to) {
    FUNCTION(igraph_vector, copy_to)(&m->data, to);
}

/**
 * \ingroup matrix
 * \function igraph_matrix_null
 * \brief Sets all elements in a matrix to zero.
 *
 * \param m Pointer to an initialized matrix object.
 *
 * Time complexity: O(n),
 * n is the number of  elements in
 * the matrix.
 */

void FUNCTION(igraph_matrix, null)(TYPE(igraph_matrix) *m) {
    FUNCTION(igraph_vector, null)(&m->data);
}

/**
 * \ingroup matrix
 * \function igraph_matrix_add_cols
 * \brief Adds columns to a matrix.
 * \param m The matrix object.
 * \param n The number of columns to add.
 * \return Error code, \c IGRAPH_ENOMEM if there is
 *   not enough memory to perform the operation.
 *
 * Time complexity: linear with the number of elements of the new,
 * resized matrix.
 */

int FUNCTION(igraph_matrix, add_cols)(TYPE(igraph_matrix) *m, long int n) {
    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(m, m->nrow, m->ncol + n));
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_add_rows
 * \brief Adds rows to a matrix.
 * \param m The matrix object.
 * \param n The number of rows to add.
 * \return Error code, \c IGRAPH_ENOMEM if there
 *   isn't enough memory for the operation.
 *
 * Time complexity: linear with the number of elements of the new,
 * resized matrix.
 */

int FUNCTION(igraph_matrix, add_rows)(TYPE(igraph_matrix) *m, long int n) {
    long int i;
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(&m->data, (m->ncol) * (m->nrow + n)));
    for (i = m->ncol - 1; i >= 0; i--) {
        FUNCTION(igraph_vector, move_interval2)(&m->data, (m->nrow)*i, (m->nrow) * (i + 1),
                                                (m->nrow + n)*i);
    }
    m->nrow += n;
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_remove_col
 * \brief Removes a column from a matrix.
 *
 * \param m The matrix object.
 * \param col The column to remove.
 * \return Error code, always returns with success.
 *
 * Time complexity: linear with the number of elements of the new,
 * resized matrix.
 */

int FUNCTION(igraph_matrix, remove_col)(TYPE(igraph_matrix) *m, long int col) {
    FUNCTION(igraph_vector, remove_section)(&m->data, (m->nrow)*col, (m->nrow) * (col + 1));
    m->ncol--;
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_permdelete_rows
 * \brief Removes rows from a matrix (for internal use).
 *
 * Time complexity: linear with the number of elements of the original
 * matrix.
 */

int FUNCTION(igraph_matrix, permdelete_rows)(TYPE(igraph_matrix) *m, long int *index, long int nremove) {
    long int i, j;
    for (j = 0; j < m->nrow; j++) {
        if (index[j] != 0) {
            for (i = 0; i < m->ncol; i++) {
                MATRIX(*m, index[j] - 1, i) = MATRIX(*m, j, i);
            }
        }
    }
    /* Remove unnecessary elements from the end of each column */
    for (i = 0; i < m->ncol; i++)
        FUNCTION(igraph_vector, remove_section)(&m->data,
                                                (i + 1) * (m->nrow - nremove), (i + 1) * (m->nrow - nremove) + nremove);
    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(m, m->nrow - nremove, m->ncol));

    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_delete_rows_neg
 * \brief Removes columns from a matrix (for internal use).
 *
 * Time complexity: linear with the number of elements of the original
 * matrix.
 */

int FUNCTION(igraph_matrix, delete_rows_neg)(TYPE(igraph_matrix) *m,
        const igraph_vector_t *neg, long int nremove) {
    long int i, j, idx = 0;
    for (i = 0; i < m->ncol; i++) {
        for (j = 0; j < m->nrow; j++) {
            if (VECTOR(*neg)[j] >= 0) {
                MATRIX(*m, idx++, i) = MATRIX(*m, j, i);
            }
        }
        idx = 0;
    }
    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(m, m->nrow - nremove, m->ncol));

    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_matrix_copy
 * \brief Copies a matrix.
 *
 * 
 * Creates a matrix object by copying from an existing matrix.
 * \param to Pointer to an uninitialized matrix object.
 * \param from The initialized matrix object to copy.
 * \return Error code, \c IGRAPH_ENOMEM if there
 *   isn't enough memory to allocate the new matrix.
 *
 * Time complexity: O(n), the number
 * of elements in the matrix.
 */

int FUNCTION(igraph_matrix, copy)(TYPE(igraph_matrix) *to, const TYPE(igraph_matrix) *from) {
    IGRAPH_CHECK(FUNCTION(igraph_vector, copy)(&to->data, &from->data));
    to->nrow = from->nrow;
    to->ncol = from->ncol;
    return IGRAPH_SUCCESS;
}

#ifndef NOTORDERED

/**
 * \function igraph_matrix_max
 * \brief Largest element of a matrix.
 *
 * 
 * If the matrix is empty, an arbitrary number is returned.
 * \param m The matrix object.
 * \return The maximum element of \p m, or NaN if any element is NaN.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

igraph_real_t FUNCTION(igraph_matrix, max)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, max)(&m->data);
}

#endif

/**
 * \function igraph_matrix_scale
 *
 * Multiplies each element of the matrix by a constant.
 * \param m The matrix.
 * \param by The constant.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(n), the number of elements in the matrix.
 */

void FUNCTION(igraph_matrix, scale)(TYPE(igraph_matrix) *m, BASE by) {
    FUNCTION(igraph_vector, scale)(&m->data, by);
}

/**
 * \function igraph_matrix_select_rows
 * \brief Select some rows of a matrix.
 *
 * This function selects some rows of a matrix and returns them in a
 * new matrix. The result matrix should be initialized before calling
 * the function.
 * \param m The input matrix.
 * \param res The result matrix. It should be initialized and will be
 *    resized as needed.
 * \param rows Vector; it contains the row indices (starting with
 *    zero) to extract. Note that no range checking is performed.
 * \return Error code.
 *
 * Time complexity: O(nm), n is the number of rows, m the number of
 * columns of the result matrix.
 */

int FUNCTION(igraph_matrix, select_rows)(const TYPE(igraph_matrix) *m,
        TYPE(igraph_matrix) *res,
        const igraph_vector_t *rows) {
    long int norows = igraph_vector_size(rows);
    long int i, j, ncols = FUNCTION(igraph_matrix, ncol)(m);

    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(res, norows, ncols));
    for (i = 0; i < norows; i++) {
        for (j = 0; j < ncols; j++) {
            MATRIX(*res, i, j) = MATRIX(*m, (long int)VECTOR(*rows)[i], j);
        }
    }

    return 0;
}

/**
 * \function igraph_matrix_select_rows_cols
 * \brief Select some rows and columns of a matrix.
 *
 * This function selects some rows and columns of a matrix and returns
 * them in a new matrix. The result matrix should be initialized before
 * calling the function.
 * \param m The input matrix.
 * \param res The result matrix. It should be initialized and will be
 *    resized as needed.
 * \param rows Vector; it contains the row indices (starting with
 *    zero) to extract. Note that no range checking is performed.
 * \param cols Vector; it contains the column indices (starting with
 *    zero) to extract. Note that no range checking is performed.
 * \return Error code.
 *
 * Time complexity: O(nm), n is the number of rows, m the number of
 * columns of the result matrix.
 */

int FUNCTION(igraph_matrix, select_rows_cols)(const TYPE(igraph_matrix) *m,
        TYPE(igraph_matrix) *res,
        const igraph_vector_t *rows,
        const igraph_vector_t *cols) {
    long int nrows = igraph_vector_size(rows);
    long int ncols = igraph_vector_size(cols);
    long int i, j;

    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(res, nrows, ncols));
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < ncols; j++) {
            MATRIX(*res, i, j) = MATRIX(*m, (long int)VECTOR(*rows)[i],
                                        (long int)VECTOR(*cols)[j]);
        }
    }

    return 0;
}

/**
 * \function igraph_matrix_get_col
 * \brief Select a column.
 *
 * Extract a column of a matrix and return it as a vector.
 * \param m The input matrix.
 * \param res The result will we stored in this vector. It should be
 *   initialized and will be resized as needed.
 * \param index The index of the column to select.
 * \return Error code.
 *
 * Time complexity: O(n), the number of rows in the matrix.
 */

int FUNCTION(igraph_matrix, get_col)(const TYPE(igraph_matrix) *m,
                                     TYPE(igraph_vector) *res,
                                     long int index) {
    long int nrow = FUNCTION(igraph_matrix, nrow)(m);

    if (index >= m->ncol) {
        IGRAPH_ERROR("Index out of range for selecting matrix column", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(FUNCTION(igraph_vector, get_interval)(&m->data, res,
                 nrow * index, nrow * (index + 1)));
    return 0;
}

/**
 * \function igraph_matrix_sum
 * \brief Sum of elements.
 *
 * Returns the sum of the elements of a matrix.
 * \param m The input matrix.
 * \return The sum of the elements.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

BASE FUNCTION(igraph_matrix, sum)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, sum)(&m->data);
}

/**
 * \function igraph_matrix_all_e
 * \brief Are all elements equal?
 *
 * \param lhs The first matrix.
 * \param rhs The second matrix.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    equal to the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the dimensions of the matrices don't match.
 *
 * Time complexity: O(nm), the size of the matrices.
 */

igraph_bool_t FUNCTION(igraph_matrix, all_e)(const TYPE(igraph_matrix) *lhs,
        const TYPE(igraph_matrix) *rhs) {
    return lhs->ncol == rhs->ncol && lhs->nrow == rhs->nrow &&
           FUNCTION(igraph_vector, all_e)(&lhs->data, &rhs->data);
}

igraph_bool_t
FUNCTION(igraph_matrix, is_equal)(const TYPE(igraph_matrix) *lhs,
                                  const TYPE(igraph_matrix) *rhs) {
    return FUNCTION(igraph_matrix, all_e)(lhs, rhs);
}

#ifndef NOTORDERED

/**
 * \function igraph_matrix_all_l
 * \brief Are all elements less?
 *
 * \param lhs The first matrix.
 * \param rhs The second matrix.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    less than the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the dimensions of the matrices don't match.
 *
 * Time complexity: O(nm), the size of the matrices.
 */

igraph_bool_t FUNCTION(igraph_matrix, all_l)(const TYPE(igraph_matrix) *lhs,
        const TYPE(igraph_matrix) *rhs) {
    return lhs->ncol == rhs->ncol && lhs->nrow == rhs->nrow &&
           FUNCTION(igraph_vector, all_l)(&lhs->data, &rhs->data);
}

/**
 * \function igraph_matrix_all_g
 * \brief Are all elements greater?
 *
 * \param lhs The first matrix.
 * \param rhs The second matrix.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    greater than the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the dimensions of the matrices don't match.
 *
 * Time complexity: O(nm), the size of the matrices.
 */

igraph_bool_t FUNCTION(igraph_matrix, all_g)(const TYPE(igraph_matrix) *lhs,
        const TYPE(igraph_matrix) *rhs) {
    return lhs->ncol == rhs->ncol && lhs->nrow == rhs->nrow &&
           FUNCTION(igraph_vector, all_g)(&lhs->data, &rhs->data);
}

/**
 * \function igraph_matrix_all_le
 * \brief Are all elements less or equal?
 *
 * \param lhs The first matrix.
 * \param rhs The second matrix.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    less than or equal to the corresponding elements in \p
 *    rhs. Returns \c 0 (=false) if the dimensions of the matrices
 *    don't match.
 *
 * Time complexity: O(nm), the size of the matrices.
 */

igraph_bool_t
FUNCTION(igraph_matrix, all_le)(const TYPE(igraph_matrix) *lhs,
                                const TYPE(igraph_matrix) *rhs) {
    return lhs->ncol == rhs->ncol && lhs->nrow == rhs->nrow &&
           FUNCTION(igraph_vector, all_le)(&lhs->data, &rhs->data);
}

/**
 * \function igraph_matrix_all_ge
 * \brief Are all elements greater or equal?
 *
 * \param lhs The first matrix.
 * \param rhs The second matrix.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    greater than or equal to the corresponding elements in \p
 *    rhs. Returns \c 0 (=false) if the dimensions of the matrices
 *    don't match.
 *
 * Time complexity: O(nm), the size of the matrices.
 */

igraph_bool_t
FUNCTION(igraph_matrix, all_ge)(const TYPE(igraph_matrix) *lhs,
                                const TYPE(igraph_matrix) *rhs) {
    return lhs->ncol == rhs->ncol && lhs->nrow == rhs->nrow &&
           FUNCTION(igraph_vector, all_ge)(&lhs->data, &rhs->data);
}

#endif

#ifndef NOTORDERED

/**
 * \function igraph_matrix_maxdifference
 * \brief Maximum absolute difference between two matrices.
 *
 * Calculate the maximum absolute difference of two matrices. Both matrices
 * must be non-empty. If their dimensions differ then a warning is given and
 * the comparison is performed by vectors columnwise from both matrices.
 * The remaining elements in the larger vector are ignored.
 * \param m1 The first matrix.
 * \param m2 The second matrix.
 * \return The element with the largest absolute value in \c m1 - \c m2.
 *
 * Time complexity: O(mn), the elements in the smaller matrix.
 */

igraph_real_t FUNCTION(igraph_matrix, maxdifference)(const TYPE(igraph_matrix) *m1,
        const TYPE(igraph_matrix) *m2) {
    long int col1 = FUNCTION(igraph_matrix, ncol)(m1);
    long int col2 = FUNCTION(igraph_matrix, ncol)(m2);
    long int row1 = FUNCTION(igraph_matrix, nrow)(m1);
    long int row2 = FUNCTION(igraph_matrix, nrow)(m2);
    if (col1 != col2 || row1 != row2) {
        IGRAPH_WARNING("Comparing non-conformant matrices");
    }
    return FUNCTION(igraph_vector, maxdifference)(&m1->data, &m2->data);
}

#endif

/**
 * \function igraph_matrix_transpose
 * \brief Transpose a matrix.
 *
 * Calculate the transpose of a matrix. Note that the function
 * reallocates the memory used for the matrix.
 * \param m The input (and output) matrix.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

int FUNCTION(igraph_matrix, transpose)(TYPE(igraph_matrix) *m) {
    long int nrow = m->nrow;
    long int ncol = m->ncol;
    if (nrow > 1 && ncol > 1) {
        TYPE(igraph_vector) newdata;
        long int i, size = nrow * ncol, mod = size - 1;
        IGRAPH_CHECK(FUNCTION(igraph_vector, init)(&newdata, size));
        IGRAPH_FINALLY(FUNCTION(igraph_vector, destroy), &newdata);
        for (i = 0; i < size; i++) {
            VECTOR(newdata)[i] = VECTOR(m->data)[ (i * nrow) % mod ];
        }
        VECTOR(newdata)[size - 1] = VECTOR(m->data)[size - 1];
        FUNCTION(igraph_vector, destroy)(&m->data);
        IGRAPH_FINALLY_CLEAN(1);
        m->data = newdata;
    }
    m->nrow = ncol;
    m->ncol = nrow;

    return 0;
}

/**
 * \function igraph_matrix_e
 * Extract an element from a matrix.
 *
 * Use this if you need a function for some reason and cannot use the
 * \ref MATRIX macro. Note that no range checking is performed.
 * \param m The input matrix.
 * \param row The row index.
 * \param col The column index.
 * \return The element in the given row and column.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_matrix, e)(const TYPE(igraph_matrix) *m,
                                long int row, long int col) {
    return MATRIX(*m, row, col);
}

/**
 * \function igraph_matrix_e_ptr
 * Pointer to an element of a matrix.
 *
 * The function returns a pointer to an element. No range checking is
 * performed.
 * \param m The input matrix.
 * \param row The row index.
 * \param col The column index.
 * \return Pointer to the element in the given row and column.
 *
 * Time complexity: O(1).
 */

BASE* FUNCTION(igraph_matrix, e_ptr)(const TYPE(igraph_matrix) *m,
                                     long int row, long int col) {
    return &MATRIX(*m, row, col);
}

/**
 * \function igraph_matrix_set
 * Set an element.
 *
 * Set an element of a matrix. No range checking is performed.
 * \param m The input matrix.
 * \param row The row index.
 * \param col The column index.
 * \param value The new value of the element.
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_matrix, set)(TYPE(igraph_matrix)* m, long int row, long int col,
                                  BASE value) {
    MATRIX(*m, row, col) = value;
}

/**
 * \function igraph_matrix_fill
 * Fill with an element.
 *
 * Set the matrix to a constant matrix.
 * \param m The input matrix.
 * \param e The element to set.
 *
 * Time complexity: O(mn), the number of elements.
 */

void FUNCTION(igraph_matrix, fill)(TYPE(igraph_matrix) *m, BASE e) {
    FUNCTION(igraph_vector, fill)(&m->data, e);
}

/**
 * \function igraph_matrix_update
 * Update from another matrix.
 *
 * This function replicates \p from in the matrix \p to.
 * Note that \p to must be already initialized.
 * \param to The result matrix.
 * \param from The matrix to replicate; it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, update)(TYPE(igraph_matrix) *to,
                                    const TYPE(igraph_matrix) *from) {

    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(to, from->nrow, from->ncol));
    FUNCTION(igraph_vector, update)(&to->data, &from->data);
    return 0;
}

/**
 * \function igraph_matrix_rbind
 * Combine two matrices rowwise.
 *
 * This function places the rows of \p from below the rows of \c to
 * and stores the result in \p to. The number of columns in the two
 * matrices must match.
 * \param to The upper matrix; the result is also stored here.
 * \param from The lower matrix. It is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the newly created
 * matrix.
 */

int FUNCTION(igraph_matrix, rbind)(TYPE(igraph_matrix) *to,
                                   const TYPE(igraph_matrix) *from) {
    long int tocols = to->ncol, fromcols = from->ncol;
    long int torows = to->nrow, fromrows = from->nrow;
    long int offset, c, r, index, offset2;
    if (tocols != fromcols) {
        IGRAPH_ERROR("Cannot do rbind, number of columns do not match", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(&to->data,
                 tocols * (fromrows + torows)));
    to->nrow += fromrows;

    offset = (tocols - 1) * fromrows;
    index = tocols * torows - 1;
    for (c = tocols - 1; c > 0; c--) {
        for (r = 0; r < torows; r++, index--) {
            VECTOR(to->data)[index + offset] = VECTOR(to->data)[index];
        }
        offset -= fromrows;
    }

    offset = torows; offset2 = 0;
    for (c = 0; c < tocols; c++) {
        memcpy(VECTOR(to->data) + offset, VECTOR(from->data) + offset2,
               sizeof(BASE) * (size_t) fromrows);
        offset += fromrows + torows;
        offset2 += fromrows;
    }
    return 0;
}

/**
 * \function igraph_matrix_cbind
 * Combine matrices columnwise.
 *
 * This function places the columns of \p from on the right of \p to,
 * and stores the result in \p to.
 * \param to The left matrix; the result is stored here too.
 * \param from The right matrix. It is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements on the new matrix.
 */

int FUNCTION(igraph_matrix, cbind)(TYPE(igraph_matrix) *to,
                                   const TYPE(igraph_matrix) *from) {

    long int tocols = to->ncol, fromcols = from->ncol;
    long int torows = to->nrow, fromrows = from->nrow;
    if (torows != fromrows) {
        IGRAPH_ERROR("Cannot do rbind, number of rows do not match", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(to, torows, tocols + fromcols));
    FUNCTION(igraph_vector, copy_to)(&from->data, VECTOR(to->data) + tocols * torows);
    return 0;
}

/**
 * \function igraph_matrix_swap
 * Swap two matrices.
 *
 * The contents of the two matrices will be swapped. They must have the
 * same dimensions.
 * \param m1 The first matrix.
 * \param m2 The second matrix.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the matrices.
 */

int FUNCTION(igraph_matrix, swap)(TYPE(igraph_matrix) *m1, TYPE(igraph_matrix) *m2) {
    if (m1->nrow != m2->nrow || m1->ncol != m2->ncol) {
        IGRAPH_ERROR("Cannot swap non-conformant matrices", IGRAPH_EINVAL);
    }
    return FUNCTION(igraph_vector, swap)(&m1->data, &m2->data);
}

/**
 * \function igraph_matrix_get_row
 * Extract a row.
 *
 * Extract a row from a matrix and return it as a vector.
 * \param m The input matrix.
 * \param res Pointer to an initialized vector; it will be resized if
 *   needed.
 * \param index The index of the row to select.
 * \return Error code.
 *
 * Time complexity: O(n), the number of columns in the matrix.
 */

int FUNCTION(igraph_matrix, get_row)(const TYPE(igraph_matrix) *m,
                                     TYPE(igraph_vector) *res, long int index) {
    long int rows = m->nrow, cols = m->ncol;
    long int i, j;

    if (index >= rows) {
        IGRAPH_ERROR("Index out of range for selecting matrix row", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(res, cols));

    for (i = index, j = 0; j < cols; i += rows, j++) {
        VECTOR(*res)[j] = VECTOR(m->data)[i];
    }
    return 0;
}

/**
 * \function igraph_matrix_set_row
 * Set a row from a vector.
 *
 * Sets the elements of a row with the given vector. This has the effect of
 * setting row \c index to have the elements in the vector \c v. The length of
 * the vector and the number of columns in the matrix must match,
 * otherwise an error is triggered.
 * \param m The input matrix.
 * \param v The vector containing the new elements of the row.
 * \param index Index of the row to set.
 * \return Error code.
 *
 * Time complexity: O(n), the number of columns in the matrix.
 */

int FUNCTION(igraph_matrix, set_row)(TYPE(igraph_matrix) *m,
                                     const TYPE(igraph_vector) *v, long int index) {
    long int rows = m->nrow, cols = m->ncol;
    long int i, j;

    if (index >= rows) {
        IGRAPH_ERROR("Index out of range for selecting matrix row", IGRAPH_EINVAL);
    }
    if (FUNCTION(igraph_vector, size)(v) != cols) {
        IGRAPH_ERROR("Cannot set matrix row, invalid vector length", IGRAPH_EINVAL);
    }
    for (i = index, j = 0; j < cols; i += rows, j++) {
        VECTOR(m->data)[i] = VECTOR(*v)[j];
    }
    return 0;
}

/**
 * \function igraph_matrix_set_col
 * Set a column from a vector.
 *
 * Sets the elements of a column with the given vector. In effect, column
 * \c index will be set with elements from the vector \c v. The length of
 * the vector and the number of rows in the matrix must match,
 * otherwise an error is triggered.
 * \param m The input matrix.
 * \param v The vector containing the new elements of the column.
 * \param index Index of the column to set.
 * \return Error code.
 *
 * Time complexity: O(m), the number of rows in the matrix.
 */

int FUNCTION(igraph_matrix, set_col)(TYPE(igraph_matrix) *m,
                                     const TYPE(igraph_vector) *v, long int index) {
    long int rows = m->nrow, cols = m->ncol;
    long int i, j;

    if (index >= cols) {
        IGRAPH_ERROR("Index out of range for setting matrix column", IGRAPH_EINVAL);
    }
    if (FUNCTION(igraph_vector, size)(v) != rows) {
        IGRAPH_ERROR("Cannot set matrix column, invalid vector length", IGRAPH_EINVAL);
    }
    for (i = index * rows, j = 0; j < rows; i++, j++) {
        VECTOR(m->data)[i] = VECTOR(*v)[j];
    }
    return 0;
}

/**
 * \function igraph_matrix_swap_rows
 * Swap two rows.
 *
 * Swap two rows in the matrix.
 * \param m The input matrix.
 * \param i The index of the first row.
 * \param j The index of the second row.
 * \return Error code.
 *
 * Time complexity: O(n), the number of columns.
 */

int FUNCTION(igraph_matrix, swap_rows)(TYPE(igraph_matrix) *m,
                                       long int i, long int j) {
    long int ncol = m->ncol, nrow = m->nrow;
    long int n = nrow * ncol;
    long int index1, index2;
    if (i >= nrow || j >= nrow) {
        IGRAPH_ERROR("Cannot swap rows, index out of range", IGRAPH_EINVAL);
    }
    if (i == j) {
        return 0;
    }
    for (index1 = i, index2 = j; index1 < n; index1 += nrow, index2 += nrow) {
        BASE tmp;
        tmp = VECTOR(m->data)[index1];
        VECTOR(m->data)[index1] = VECTOR(m->data)[index2];
        VECTOR(m->data)[index2] = tmp;
    }
    return 0;
}

/**
 * \function igraph_matrix_swap_cols
 * Swap two columns.
 *
 * Swap two columns in the matrix.
 * \param m The input matrix.
 * \param i The index of the first column.
 * \param j The index of the second column.
 * \return Error code.
 *
 * Time complexity: O(m), the number of rows.
 */

int FUNCTION(igraph_matrix, swap_cols)(TYPE(igraph_matrix) *m,
                                       long int i, long int j) {
    long int ncol = m->ncol, nrow = m->nrow;
    long int k, index1, index2;
    if (i >= ncol || j >= ncol) {
        IGRAPH_ERROR("Cannot swap columns, index out of range", IGRAPH_EINVAL);
    }
    if (i == j) {
        return 0;
    }
    for (index1 = i * nrow, index2 = j * nrow, k = 0; k < nrow; k++, index1++, index2++) {
        BASE tmp = VECTOR(m->data)[index1];
        VECTOR(m->data)[index1] = VECTOR(m->data)[index2];
        VECTOR(m->data)[index2] = tmp;
    }
    return 0;
}

/**
 * \function igraph_matrix_add_constant
 * Add a constant to every element.
 *
 * \param m The input matrix.
 * \param plud The constant to add.
 *
 * Time complexity: O(mn), the number of elements.
 */

void FUNCTION(igraph_matrix, add_constant)(TYPE(igraph_matrix) *m, BASE plus) {
    FUNCTION(igraph_vector, add_constant)(&m->data, plus);
}

/**
 * \function igraph_matrix_add
 * Add two matrices.
 *
 * Add \p m2 to \p m1, and store the result in \p m1. The dimensions of the
 * matrices must match.
 * \param m1 The first matrix; the result will be stored here.
 * \param m2 The second matrix; it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, add)(TYPE(igraph_matrix) *m1,
                                 const TYPE(igraph_matrix) *m2) {
    if (m1->nrow != m2->nrow || m1->ncol != m2->ncol) {
        IGRAPH_ERROR("Cannot add non-conformant matrices", IGRAPH_EINVAL);
    }
    return FUNCTION(igraph_vector, add)(&m1->data, &m2->data);
}

/**
 * \function igraph_matrix_sub
 * Difference of two matrices.
 *
 * Subtract \p m2 from \p m1 and store the result in \p m1.
 * The dimensions of the two matrices must match.
 * \param m1 The first matrix; the result is stored here.
 * \param m2 The second matrix; it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, sub)(TYPE(igraph_matrix) *m1,
                                 const TYPE(igraph_matrix) *m2) {
    if (m1->nrow != m2->nrow || m1->ncol != m2->ncol) {
        IGRAPH_ERROR("Cannot subtract non-conformant matrices", IGRAPH_EINVAL);
    }
    return FUNCTION(igraph_vector, sub)(&m1->data, &m2->data);
}

/**
 * \function igraph_matrix_mul_elements
 * Elementwise multiplication.
 *
 * Multiply \p m1 by \p m2 elementwise and store the result in \p m1.
 * The dimensions of the two matrices must match.
 * \param m1 The first matrix; the result is stored here.
 * \param m2 The second matrix; it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, mul_elements)(TYPE(igraph_matrix) *m1,
        const TYPE(igraph_matrix) *m2) {
    if (m1->nrow != m2->nrow || m1->ncol != m2->ncol) {
        IGRAPH_ERROR("Cannot multiply non-conformant matrices", IGRAPH_EINVAL);
    }
    return FUNCTION(igraph_vector, mul)(&m1->data, &m2->data);
}

/**
 * \function igraph_matrix_div_elements
 * Elementwise division.
 *
 * Divide \p m1 by \p m2 elementwise and store the result in \p m1.
 * The dimensions of the two matrices must match.
 * \param m1 The dividend. The result is store here.
 * \param m2 The divisor. It is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, div_elements)(TYPE(igraph_matrix) *m1,
        const TYPE(igraph_matrix) *m2) {
    if (m1->nrow != m2->nrow || m1->ncol != m2->ncol) {
        IGRAPH_ERROR("Cannot divide non-conformant matrices", IGRAPH_EINVAL);
    }
    return FUNCTION(igraph_vector, div)(&m1->data, &m2->data);
}

#ifndef NOTORDERED

/**
 * \function igraph_matrix_min
 * \brief Smallest element of a matrix.
 *
 * The matrix must be non-empty.
 * \param m The input matrix.
 * \return The smallest element of \p m, or NaN if any element is NaN.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

igraph_real_t FUNCTION(igraph_matrix, min)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, min)(&m->data);
}

/**
 * \function igraph_matrix_which_min
 * \brief Indices of the smallest element.
 *
 * 
 * The matrix must be non-empty. If the smallest element is not unique,
 * then the indices of the first such element are returned. If the matrix contains
 * NaN values, the indices of the first NaN value are returned.
 * \param m The matrix.
 * \param i Pointer to a long int. The row index of the
 *   minimum is stored here.
 * \param j Pointer to a long int. The column index of
 *   the minimum is stored here.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, which_min)(const TYPE(igraph_matrix) *m,
                                       long int *i, long int *j) {
    long int vmin = FUNCTION(igraph_vector, which_min)(&m->data);
    *i = vmin % m->nrow;
    *j = vmin / m->nrow;
    return 0;
}

/**
 * \function igraph_matrix_which_max
 * \brief Indices of the largest element.
 *
 * 
 * The matrix must be non-empty. If the largest element is not unique,
 * then the indices of the first such element are returned. If the matrix contains
 * NaN values, the indices of the first NaN value are returned.
 * \param m The matrix.
 * \param i Pointer to a long int. The row index of the
 *   maximum is stored here.
 * \param j Pointer to a long int. The column index of
 *   the maximum is stored here.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, which_max)(const TYPE(igraph_matrix) *m,
                                       long int *i, long int *j) {
    long int vmax = FUNCTION(igraph_vector, which_max)(&m->data);
    *i = vmax % m->nrow;
    *j = vmax / m->nrow;
    return 0;
}

/**
 * \function igraph_matrix_minmax
 * \brief Minimum and maximum elements of a matrix.
 *
 * Handy if you want to have both the smallest and largest element of
 * a matrix. The matrix is only traversed once. The matrix must be non-empty.
 * If a matrix contains at least one NaN, both \c min and \c max will be NaN.
 * \param m The input matrix. It must contain at least one element.
 * \param min Pointer to a base type variable. The minimum is stored here.
 * \param max Pointer to a base type variable. The maximum is stored here.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, minmax)(const TYPE(igraph_matrix) *m,
                                    BASE *min, BASE *max) {
    return FUNCTION(igraph_vector, minmax)(&m->data, min, max);
}

/**
 * \function igraph_matrix_which_minmax
 * \brief Indices of the minimum and maximum elements
 *
 * 
 * Handy if you need the indices of the smallest and largest
 * elements. The matrix is traversed only once. The matrix must be
 * non-empty. If the minimum or maximum is not unique, the index
 * of the first minimum or the first maximum is returned, respectively.
 * If a matrix contains at least one NaN, both \c which_min and \c which_max
 * will point to the first NaN value.
 * \param m The input matrix.
 * \param imin Pointer to a long int, the row index of
 *   the minimum is stored here.
 * \param jmin Pointer to a long int, the column index of
 *   the minimum is stored here.
 * \param imax Pointer to a long int, the row index of
 *   the maximum is stored here.
 * \param jmax Pointer to a long int, the column index of
 *   the maximum is stored here.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements.
 */

int FUNCTION(igraph_matrix, which_minmax)(const TYPE(igraph_matrix) *m,
        long int *imin, long int *jmin,
        long int *imax, long int *jmax) {
    long int vmin, vmax;
    FUNCTION(igraph_vector, which_minmax)(&m->data, &vmin, &vmax);
    *imin = vmin % m->nrow;
    *jmin = vmin / m->nrow;
    *imax = vmax % m->nrow;
    *jmax = vmax / m->nrow;
    return 0;
}

#endif

/**
 * \function igraph_matrix_isnull
 * Check for a null matrix.
 *
 * Checks whether all elements are zero.
 * \param m The input matrix.
 * \return Boolean, \c TRUE is \p m contains only zeros and \c FALSE
 *   otherwise.
 *
 * Time complexity: O(mn), the number of elements.
 */

igraph_bool_t FUNCTION(igraph_matrix, isnull)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, isnull)(&m->data);
}

/**
 * \function igraph_matrix_empty
 * Check for an empty matrix.
 *
 * It is possible to have a matrix with zero rows or zero columns, or
 * even both. This functions checks for these.
 * \param m The input matrix.
 * \return Boolean, \c TRUE if the matrix contains zero elements, and
 *    \c FALSE otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t FUNCTION(igraph_matrix, empty)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, empty)(&m->data);
}

/**
 * \function igraph_matrix_is_symmetric
 * Check for symmetric matrix.
 *
 * A non-square matrix is not symmetric by definition.
 * \param m The input matrix.
 * \return Boolean, \c TRUE if the matrix is square and symmetric, \c
 *    FALSE otherwise.
 *
 * Time complexity: O(mn), the number of elements. O(1) for non-square
 * matrices.
 */

igraph_bool_t FUNCTION(igraph_matrix, is_symmetric)(const TYPE(igraph_matrix) *m) {

    long int n = m->nrow;
    long int r, c;
    if (m->ncol != n) {
        return 0;
    }
    for (r = 1; r < n; r++) {
        for (c = 0; c < r; c++) {
            BASE a1 = MATRIX(*m, r, c);
            BASE a2 = MATRIX(*m, c, r);
#ifdef EQ
            if (!EQ(a1, a2)) {
                return 0;
            }
#else
            if (a1 != a2) {
                return 0;
            }
#endif
        }
    }
    return 1;
}

/**
 * \function igraph_matrix_prod
 * Product of the elements.
 *
 * Note this function can result in overflow easily, even for not too
 * big matrices.
 * \param m The input matrix.
 * \return The product of the elements.
 *
 * Time complexity: O(mn), the number of elements.
 */

BASE FUNCTION(igraph_matrix, prod)(const TYPE(igraph_matrix) *m) {
    return FUNCTION(igraph_vector, prod)(&m->data);
}

/**
 * \function igraph_matrix_rowsum
 * Rowwise sum.
 *
 * Calculate the sum of the elements in each row.
 * \param m The input matrix.
 * \param res Pointer to an initialized vector; the result is stored
 *   here. It will be resized if necessary.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

int FUNCTION(igraph_matrix, rowsum)(const TYPE(igraph_matrix) *m,
                                    TYPE(igraph_vector) *res) {
    long int nrow = m->nrow, ncol = m->ncol;
    long int r, c;
    BASE sum;
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(res, nrow));
    for (r = 0; r < nrow; r++) {
        sum = ZERO;
        for (c = 0; c < ncol; c++) {
#ifdef SUM
            SUM(sum, sum, MATRIX(*m, r, c));
#else
            sum += MATRIX(*m, r, c);
#endif
        }
        VECTOR(*res)[r] = sum;
    }
    return 0;
}

/**
 * \function igraph_matrix_colsum
 * Columnwise sum.
 *
 * Calculate the sum of the elements in each column.
 * \param m The input matrix.
 * \param res Pointer to an initialized vector; the result is stored
 *   here. It will be resized if necessary.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

int FUNCTION(igraph_matrix, colsum)(const TYPE(igraph_matrix) *m,
                                    TYPE(igraph_vector) *res) {
    long int nrow = m->nrow, ncol = m->ncol;
    long int r, c;
    BASE sum;
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(res, ncol));
    for (c = 0; c < ncol; c++) {
        sum = ZERO;
        for (r = 0; r < nrow; r++) {
#ifdef SUM
            SUM(sum, sum, MATRIX(*m, r, c));
#else
            sum += MATRIX(*m, r, c);
#endif
        }
        VECTOR(*res)[c] = sum;
    }
    return 0;
}

/**
 * \function igraph_matrix_contains
 * Search for an element.
 *
 * Search for the given element in the matrix.
 * \param m The input matrix.
 * \param e The element to search for.
 * \return Boolean, \c TRUE if the matrix contains \p e, \c FALSE
 * otherwise.
 *
 * Time complexity: O(mn), the number of elements.
 */

igraph_bool_t FUNCTION(igraph_matrix, contains)(const TYPE(igraph_matrix) *m,
        BASE e) {
    return FUNCTION(igraph_vector, contains)(&m->data, e);
}

/**
 * \function igraph_matrix_search
 * Search from a given position.
 *
 * Search for an element in a matrix and start the search from the
 * given position. The search is performed columnwise.
 * \param m The input matrix.
 * \param from The position to search from, the positions are
 *    enumerated columnwise.
 * \param what The element to search for.
 * \param pos Pointer to a long int. If the element is
 *    found, then this is set to the position of its first appearance.
 * \param row Pointer to a long int. If the element is
 *    found, then this is set to its row index.
 * \param col Pointer to a long int. If the element is
 *    found, then this is set to its column index.
 * \return Boolean, \c TRUE if the element is found, \c FALSE
 *    otherwise.
 *
 * Time complexity: O(mn), the number of elements.
 */

igraph_bool_t FUNCTION(igraph_matrix, search)(const TYPE(igraph_matrix) *m,
        long int from, BASE what,
        long int *pos,
        long int *row, long int *col) {
    igraph_bool_t find = FUNCTION(igraph_vector, search)(&m->data, from, what, pos);
    if (find) {
        *row = *pos % m->nrow;
        *col = *pos / m->nrow;
    }
    return find;
}

/**
 * \function igraph_matrix_remove_row
 * Remove a row.
 *
 * A row is removed from the matrix.
 * \param m The input matrix.
 * \param row The index of the row to remove.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the matrix.
 */

int FUNCTION(igraph_matrix, remove_row)(TYPE(igraph_matrix) *m, long int row) {

    long int c, r, index = row + 1, leap = 1, n = m->nrow * m->ncol;
    if (row >= m->nrow) {
        IGRAPH_ERROR("Cannot remove row, index out of range", IGRAPH_EINVAL);
    }

    for (c = 0; c < m->ncol; c++) {
        for (r = 0; r < m->nrow - 1 && index < n; r++) {
            VECTOR(m->data)[index - leap] = VECTOR(m->data)[index];
            index++;
        }
        leap++;
        index++;
    }
    m->nrow--;
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(&m->data, m->nrow * m->ncol));
    return 0;
}

/**
 * \function igraph_matrix_select_cols
 * \brief Select some columns of a matrix.
 *
 * This function selects some columns of a matrix and returns them in a
 * new matrix. The result matrix should be initialized before calling
 * the function.
 * \param m The input matrix.
 * \param res The result matrix. It should be initialized and will be
 *    resized as needed.
 * \param cols Vector; it contains the column indices (starting with
 *    zero) to extract. Note that no range checking is performed.
 * \return Error code.
 *
 * Time complexity: O(nm), n is the number of rows, m the number of
 * columns of the result matrix.
 */

int FUNCTION(igraph_matrix, select_cols)(const TYPE(igraph_matrix) *m,
        TYPE(igraph_matrix) *res,
        const igraph_vector_t *cols) {
    long int ncols = igraph_vector_size(cols);
    long int nrows = m->nrow;
    long int i, j;

    IGRAPH_CHECK(FUNCTION(igraph_matrix, resize)(res, nrows, ncols));
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < ncols; j++) {
            MATRIX(*res, i, j) = MATRIX(*m, i, (long int)VECTOR(*cols)[j]);
        }
    }
    return 0;
}

#ifdef OUT_FORMAT

#ifndef USING_R
int FUNCTION(igraph_matrix, print)(const TYPE(igraph_matrix) *m) {

    long int nr = FUNCTION(igraph_matrix, nrow)(m);
    long int nc = FUNCTION(igraph_matrix, ncol)(m);
    long int i, j;
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            if (j != 0) {
                putchar(' ');
            }
            printf(OUT_FORMAT, MATRIX(*m, i, j));
        }
        printf("\n");
    }

    return 0;
}

int FUNCTION(igraph_matrix, printf)(const TYPE(igraph_matrix) *m,
                                    const char *format) {
    long int nr = FUNCTION(igraph_matrix, nrow)(m);
    long int nc = FUNCTION(igraph_matrix, ncol)(m);
    long int i, j;
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            if (j != 0) {
                putchar(' ');
            }
            printf(format, MATRIX(*m, i, j));
        }
        printf("\n");
    }

    return 0;
}

#endif

int FUNCTION(igraph_matrix, fprint)(const TYPE(igraph_matrix) *m,
                                    FILE *file) {

    long int nr = FUNCTION(igraph_matrix, nrow)(m);
    long int nc = FUNCTION(igraph_matrix, ncol)(m);
    long int i, j;
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            if (j != 0) {
                fputc(' ', file);
            }
            fprintf(file, OUT_FORMAT, MATRIX(*m, i, j));
        }
        fprintf(file, "\n");
    }

    return 0;
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/memory.c0000644000175100001710000000464300000000000023054 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"

/**
 * \function igraph_free
 * \brief Deallocate memory that was allocated by igraph functions.
 *
 * Some igraph functions return a pointer vector (igraph_vector_ptr_t)
 * containing pointers to other igraph or other data types. These data
 * types are dynamically allocated and have to be deallocated
 * manually when the user does not need them any more. This can be done
 * by calling igraph_free on them.
 *
 * 
 * Here is a complete example on how to use \c igraph_free properly.
 *
 * \example examples/simple/igraph_free.c
 *
 * \param p Pointer to the piece of memory to be deallocated.
 * \return Error code, currently always zero, meaning success.
 *
 * Time complexity: platform dependent, ideally it should be O(1).
 *
 * \sa \ref igraph_malloc()
 */

void igraph_free(void *p) {
    IGRAPH_FREE(p);
}


/**
 * \function igraph_malloc
 * \brief Allocate memory that can be safely deallocated by igraph functions.
 *
 * Some igraph functions, such as \ref igraph_vector_ptr_free_all() and
 * \ref igraph_vector_ptr_destroy_all() can free memory that may have been
 * allocated by the user.  \c igraph_malloc() works exactly like \c malloc()
 * from the C standard library, but it is guaranteed that it can be safely
 * paired with the \c free() function used by igraph internally (which is
 * also user-accessible through \ref igraph_free()).
 *
 * \param n Number of bytes to be allocated.
 * \return Pointer to the piece of allocated memory.
 *
 * \sa \ref igraph_free()
 */

void *igraph_malloc(size_t n) {
    return malloc(n);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/printing.c0000644000175100001710000001033000000000000023364 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

#include 

#ifdef _MSC_VER
    #define snprintf _snprintf
#endif

#ifdef DBL_DIG
    /* Use DBL_DIG to determine the maximum precision used for %g */
    #define STRINGIFY_HELPER(x) #x
    #define STRINGIFY(x) STRINGIFY_HELPER(x)
    #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%." STRINGIFY(DBL_DIG) "g"
#else
    /* Assume a precision of 10 digits for %g */
    #define IGRAPH_REAL_PRINTF_PRECISE_FORMAT "%.10g"
#endif

#ifndef USING_R
int igraph_real_printf(igraph_real_t val) {
    if (igraph_finite(val)) {
        return printf("%g", val);
    } else if (igraph_is_nan(val)) {
        return printf("NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return printf("-Inf");
        } else {
            return printf("Inf");
        }
    } else {
        /* fallback */
        return printf("%g", val);
    }
}
#endif

int igraph_real_fprintf(FILE *file, igraph_real_t val) {
    if (igraph_finite(val)) {
        return fprintf(file, "%g", val);
    } else if (igraph_is_nan(val)) {
        return fprintf(file, "NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return fprintf(file, "-Inf");
        } else {
            return fprintf(file, "Inf");
        }
    } else {
        /* fallback */
        return fprintf(file, "%g", val);
    }
}

int igraph_real_snprintf(char* str, size_t size, igraph_real_t val) {
    if (igraph_finite(val)) {
        return snprintf(str, size, "%g", val);
    } else if (igraph_is_nan(val)) {
        return snprintf(str, size, "NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return snprintf(str, size, "-Inf");
        } else {
            return snprintf(str, size, "Inf");
        }
    } else {
        /* fallback */
        return snprintf(str, size, "%g", val);
    }
}

#ifndef USING_R
int igraph_real_printf_precise(igraph_real_t val) {
    if (igraph_finite(val)) {
        return printf(IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    } else if (igraph_is_nan(val)) {
        return printf("NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return printf("-Inf");
        } else {
            return printf("Inf");
        }
    } else {
        /* fallback */
        return printf(IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    }
}
#endif

int igraph_real_fprintf_precise(FILE *file, igraph_real_t val) {
    if (igraph_finite(val)) {
        return fprintf(file, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    } else if (igraph_is_nan(val)) {
        return fprintf(file, "NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return fprintf(file, "-Inf");
        } else {
            return fprintf(file, "Inf");
        }
    } else {
        /* fallback */
        return fprintf(file, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    }
}

int igraph_real_snprintf_precise(char* str, size_t size, igraph_real_t val) {
    if (igraph_finite(val)) {
        return snprintf(str, size, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    } else if (igraph_is_nan(val)) {
        return snprintf(str, size, "NaN");
    } else if (igraph_is_inf(val)) {
        if (val < 0) {
            return snprintf(str, size, "-Inf");
        } else {
            return snprintf(str, size, "Inf");
        }
    } else {
        /* fallback */
        return snprintf(str, size, IGRAPH_REAL_PRINTF_PRECISE_FORMAT, val);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/progress.c0000644000175100001710000001343500000000000023407 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_progress.h"

#include "config.h"

static IGRAPH_THREAD_LOCAL igraph_progress_handler_t *igraph_i_progress_handler = 0;
static IGRAPH_THREAD_LOCAL char igraph_i_progressmsg_buffer[1000];

/**
 * \function igraph_progress
 * Report progress
 *
 * Note that the usual way to report progress is the \ref IGRAPH_PROGRESS
 * macro, as that takes care of the return value of the progress
 * handler.
 * \param message A string describing the function or algorithm
 *     that is reporting the progress. Current igraph functions
 *     always use the name \p message argument if reporting from the
 *     same function.
 * \param percent Numeric, the percentage that was completed by the
 *     algorithm or function.
 * \param data User-defined data. Current igraph functions that
 *     report progress pass a null pointer here. Users can
 *     write their own progress handlers and functions with progress
 *     reporting, and then pass some meaningfull context here.
 * \return If there is a progress handler installed and
 *     it does not return \c IGRAPH_SUCCESS, then \c IGRAPH_INTERRUPTED
 *     is returned.
 *
 * Time complexity: O(1).
 */

int igraph_progress(const char *message, igraph_real_t percent, void *data) {
    if (igraph_i_progress_handler) {
        if (igraph_i_progress_handler(message, percent, data) != IGRAPH_SUCCESS) {
            return IGRAPH_INTERRUPTED;
        }
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_progressf
 * Report progress, printf-like version
 *
 * This is a more flexible version of \ref igraph_progress(), with
 * a printf-like template string. First the template string
 * is filled with the additional arguments and then \ref
 * igraph_progress() is called.
 *
 * Note that there is an upper limit for the length of
 * the \p message string, currently 1000 characters.
 * \param message A string describing the function or algorithm
 *     that is reporting the progress. For this function this is a
 *     template string, using the same syntax as the standard
 *     \c libc \c printf function.
 * \param percent Numeric, the percentage that was completed by the
 *     algorithm or function.
 * \param data User-defined data. Current igraph functions that
 *     report progress pass a null pointer here. Users can
 *     write their own progress handlers and functions with progress
 *     reporting, and then pass some meaningfull context here.
 * \param ... Additional argument that were specified in the
 *     \p message argument.
 * \return If there is a progress handler installed and
 *     it does not return \c IGRAPH_SUCCESS, then \c IGRAPH_INTERRUPTED
 *     is returned.
 * \return
 */

int igraph_progressf(const char *message, igraph_real_t percent, void *data,
                     ...) {
    va_list ap;
    va_start(ap, data);
    vsnprintf(igraph_i_progressmsg_buffer,
              sizeof(igraph_i_progressmsg_buffer) / sizeof(char), message, ap);
    return igraph_progress(igraph_i_progressmsg_buffer, percent, data);
}

#ifndef USING_R

/**
 * \function igraph_progress_handler_stderr
 * \brief A simple predefined progress handler.
 *
 * This simple progress handler first prints \p message, and then
 * the percentage complete value in a short message to standard error.
 * \param message A string describing the function or algorithm
 *     that is reporting the progress. Current igraph functions
 *     always use the same \p message argument if reporting from the
 *     same function.
 * \param percent Numeric, the percentage that was completed by the
 *     algorithm or function.
 * \param data User-defined data. Current igraph functions that
 *     report progress pass a null pointer here. Users can
 *     write their own progress handlers and functions with progress
 *     reporting, and then pass some meaningfull context here.
 * \return This function always returns with \c IGRAPH_SUCCESS.
 *
 * Time complexity: O(1).
 */

int igraph_progress_handler_stderr(const char *message, igraph_real_t percent,
                                   void* data) {
    IGRAPH_UNUSED(data);
    fputs(message, stderr);
    fprintf(stderr, "%.1f percent ready.\n", percent);
    return IGRAPH_SUCCESS;
}
#endif

/**
 * \function igraph_set_progress_handler
 * \brief Install a progress handler, or remove the current handler.
 *
 * There is a single simple predefined progress handler:
 * \ref igraph_progress_handler_stderr().
 * \param new_handler Pointer to a function of type
 *     \ref igraph_progress_handler_t, the progress handler function to
 *     install. To uninstall the current progress handler, this argument
 *     can be a null pointer.
 * \return Pointer to the previously installed progress handler function.
 *
 * Time complexity: O(1).
 */

igraph_progress_handler_t *
igraph_set_progress_handler(igraph_progress_handler_t new_handler) {
    igraph_progress_handler_t *previous_handler = igraph_i_progress_handler;
    igraph_i_progress_handler = new_handler;
    return previous_handler;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/psumtree.c0000644000175100001710000002105000000000000023377 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA
   Copyright (C) 2006 Elliot Paquette 
   Kalamazoo College, 1200 Academy st, Kalamazoo, MI

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_psumtree.h"
#include "igraph_error.h"

#include 

static double igraph_i_log2(double f) {
    return log(f) / log(2.0);
}

/**
 * \ingroup psumtree
 * \section igraph_psumtree
 *
 * The \type igraph_psumtree_t data type represents a partial prefix sum
 * tree. A partial prefix sum tree is a data structure that can be used to draw
 * samples from a discrete probability distribution with dynamic probabilities
 * that are updated frequently. This is achieved by creating a binary tree where
 * the leaves are the items. Each leaf contains the probability corresponding to
 * the items. Intermediate nodes of the tree always contain the sum of its two
 * children. When the value of a leaf node is updated, the values of its
 * ancestors are also updated accordingly.
 *
 * Samples can be drawn from the probability distribution represented by
 * the tree by generating a uniform random number between 0 (inclusive) and the
 * value of the root of the tree (exclusive), and then following the branches
 * of the tree as follows. In each step, the value in the current node is
 * compared with the generated number. If the value in the node is larger,
 * the left branch of the tree is taken; otherwise the generated number is
 * decreased by the value in the node and the right branch of the tree is
 * taken, until a leaf node is reached.
 *
 * Note that the sampling process works only if all the values in the tree
 * are non-negative. This is enforced by the object; in particular, trying to
 * set a negative value for an item will produce an igraph error.
 */

/*
 * Internally, a partial prefix sum tree is stored in a contiguous chunk of
 * memory which we treat as a vector v. The first part (0,...,offset - 1) of
 * the vector v contains the prefixes of the values contained in the latter part
 * (offset, offset + size - 1) of vector v.
 *
 * More precisely: the part between (offset, offset + size - 1) of vector v
 * contains the values (not necessarily probabilities) corresponding to the
 * individual items. For the part in front of it, it holds that the value at
 * index i (zero-based) is the sum of values at index (2*i + 1) and index
 * (2*i + 2). The item at index zero contains the sum of all values in the
 * slice between (offset, offset + size - 1).
 */

/**
 * \ingroup psumtree
 * \function igraph_psumtree_init
 * \brief Initializes a partial prefix sum tree.
 *
 * 
 * The tree is initialized with a fixed number of elements. After initialization,
 * the value corresponding to each element is zero.
 *
 * \param t The tree to initialize
 * \param size The number of elements in the tree
 * \return Error code, typically \c IGRAPH_ENOMEM if there is not enough memory
 *
 * Time complexity: O(n) for a tree containing n elements
 */
int igraph_psumtree_init(igraph_psumtree_t *t, long int size) {
    t->size = size;
    t->offset = (long int) (pow(2, ceil(igraph_i_log2(size))) - 1);
    IGRAPH_CHECK(igraph_vector_init(&t->v, t->offset + t->size));
    return 0;
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_reset
 * \brief Resets all the values in the tree to zero.
 *
 * \param t The tree to reset.
 */
void igraph_psumtree_reset(igraph_psumtree_t *t) {
    igraph_vector_fill(&(t->v), 0);
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_destroy
 * \brief Destroys a partial prefix sum tree.
 *
 * 
 * All partial prefix sum trees initialized by \ref igraph_psumtree_init()
 * should be properly destroyed by this function. A destroyed tree needs to be
 * reinitialized by \ref igraph_psumtree_init() if you want to use it again.
 *
 * \param t Pointer to the (previously initialized) tree to destroy.
 *
 * Time complexity: operating system dependent.
 */
void igraph_psumtree_destroy(igraph_psumtree_t *t) {
    igraph_vector_destroy(&(t->v));
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_get
 * \brief Retrieves the value corresponding to an item in the tree.
 *
 * 
 *
 * \param t The tree to query.
 * \param idx The index of the item whose value is to be retrieved.
 * \return The value corresponding to the item with the given index.
 *
 * Time complexity: O(1)
 */
igraph_real_t igraph_psumtree_get(const igraph_psumtree_t *t, long int idx) {
    const igraph_vector_t *tree = &t->v;
    return VECTOR(*tree)[t->offset + idx];
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_search
 * \brief Finds an item in the tree, given a value.
 *
 * This function finds the item with the lowest index where it holds that the
 * sum of all the items with a \em lower index is less than or equal to the given
 * value and that the sum of all the items with a lower index plus the item
 * itself is larger than the given value.
 *
 * 
 * If you think about the partial prefix sum tree as a tool to sample from a
 * discrete probability distribution, then calling this function repeatedly
 * with uniformly distributed random numbers in the range 0 (inclusive) to the
 * sum of all values in the tree (exclusive) will sample the items in the tree
 * with a probability that is proportional to their associated values.
 *
 * \param t The tree to query.
 * \param idx The index of the item is returned here.
 * \param search The value to use for the search.
 * \return Error code; currently the search always succeeds.
 *
 * Time complexity: O(log n), where n is the number of items in the tree.
 */
int igraph_psumtree_search(const igraph_psumtree_t *t, long int *idx,
                           igraph_real_t search) {
    const igraph_vector_t *tree = &t->v;
    long int i = 1;
    long int size = igraph_vector_size(tree);

    while ( 2 * i + 1 <= size) {
        if ( search <= VECTOR(*tree)[i * 2 - 1] ) {
            i <<= 1;
        } else {
            search -= VECTOR(*tree)[i * 2 - 1];
            i <<= 1;
            i += 1;
        }
    }
    if (2 * i <= size) {
        i = 2 * i;
    }

    *idx = i - t->offset - 1;
    return IGRAPH_SUCCESS;
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_update
 * \brief Updates the value associated to an item in the tree.
 *
 * \param t The tree to query.
 * \param idx The index of the item to update.
 * \param new_value The new value of the item.
 * \return Error code, \c IGRAPH_EINVAL if the new value is negative or NaN,
 *         \c IGRAPH_SUCCESS if the operation was successful.
 *
 * Time complexity: O(log n), where n is the number of items in the tree.
 */
int igraph_psumtree_update(igraph_psumtree_t *t, long int idx,
                           igraph_real_t new_value) {
    const igraph_vector_t *tree = &t->v;
    igraph_real_t difference;

    if (new_value >= 0) {
        idx = idx + t->offset + 1;
        difference = new_value - VECTOR(*tree)[idx - 1];

        while ( idx >= 1 ) {
            VECTOR(*tree)[idx - 1] += difference;
            idx >>= 1;
        }

        return IGRAPH_SUCCESS;
    } else {
        /* caters for negative values and NaN */
        return IGRAPH_EINVAL;
    }
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_size
 * \brief Returns the size of the tree.
 *
 * \param t The tree object
 * \return The number of discrete items in the tree.
 *
 * Time complexity: O(1).
 */
long int igraph_psumtree_size(const igraph_psumtree_t *t) {
    return t->size;
}

/**
 * \ingroup psumtree
 * \function igraph_psumtree_sum
 * \brief Returns the sum of the values of the leaves in the tree.
 *
 * \param t The tree object
 * \return The sum of the values of the leaves in the tree.
 *
 * Time complexity: O(1).
 */
igraph_real_t igraph_psumtree_sum(const igraph_psumtree_t *t) {
    return VECTOR(t->v)[0];
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/set.c0000644000175100001710000002107500000000000022335 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"

#include "core/set.h"

#include      /* memmove */

#define SET(s) ((s).stor_begin)

/**
 * \ingroup set
 * \function igraph_set_init
 * \brief Initializes a set.
 *
 * \param set pointer to the set to be initialized
 * \param size the expected number of elements in the set
 *
 * \return error code:
 *       \c IGRAPH_ENOMEM if there is not enough memory.
 *
 * Time complexity: operating system dependent, should be around
 * O(n), n is the expected size of the set.
 */
int igraph_set_init(igraph_set_t *set, int long size) {
    long int alloc_size;

    if (size < 0) {
        size = 0;
    }
    alloc_size = size > 0 ? size : 1;
    set->stor_begin = IGRAPH_CALLOC(alloc_size, igraph_integer_t);
    set->stor_end = set->stor_begin + alloc_size;
    set->end = set->stor_begin;

    return 0;
}

/**
 * \ingroup set
 * \function igraph_set_destroy
 * \brief Destroys a set object.
 *
 * \param set pointer to the set to be destroyed
 *
 * Time complexity: operating system dependent.
 */
void igraph_set_destroy(igraph_set_t* set) {
    IGRAPH_ASSERT(set != 0);
    if (set->stor_begin != 0) {
        IGRAPH_FREE(set->stor_begin);
        set->stor_begin = NULL;
    }
}

/**
 * \ingroup set
 * \function igraph_set_inited
 * \brief Determines whether a set is initialized or not.
 *
 * This function checks whether the internal storage for the members of the
 * set has been allocated or not, and it assumes that the pointer for the
 * internal storage area contains \c NULL if the area is not initialized yet.
 * This only applies if you have allocated an array of sets with \c IGRAPH_CALLOC or
 * if you used the \c IGRAPH_SET_NULL constant to initialize the set.
 *
 * \param set The set object.
 *
 * Time complexity: O(1)
 */
igraph_bool_t igraph_set_inited(igraph_set_t* set) {
    return (set->stor_begin != 0);
}

/**
 * \ingroup set
 * \function igraph_set_reserve
 * \brief Reserve memory for a set.
 *
 * \param set The set object.
 * \param size the new \em allocated size of the set.
 *
 * Time complexity: operating system dependent, should be around
 * O(n), n is the new allocated size of the set.
 */
int igraph_set_reserve(igraph_set_t* set, long int size) {
    long int actual_size = igraph_set_size(set);
    igraph_integer_t *tmp;
    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);
    if (size <= actual_size) {
        return 0;
    }

    tmp = IGRAPH_REALLOC(set->stor_begin, (size_t) size, igraph_integer_t);
    if (tmp == 0) {
        IGRAPH_ERROR("cannot reserve space for set", IGRAPH_ENOMEM);
    }
    set->stor_begin = tmp;
    set->stor_end = set->stor_begin + size;
    set->end = set->stor_begin + actual_size;

    return 0;
}

/**
 * \ingroup set
 * \function igraph_set_empty
 * \brief Decides whether the size of the set is zero.
 *
 * \param set The set object.
 * \return Non-zero number if the size of the set is not zero and
 *         zero otherwise.
 *
 * Time complexity: O(1).
 */
igraph_bool_t igraph_set_empty(const igraph_set_t* set) {
    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);
    return set->stor_begin == set->end;
}

/**
 * \ingroup set
 * \function igraph_set_clear
 * \brief Removes all elements from a set.
 *
 * 
 * This function simply sets the size of the set to zero, it does
 * not free any allocated memory. For that you have to call
 * \ref igraph_set_destroy().
 * \param v The set object.
 *
 * Time complexity: O(1).
 */
void igraph_set_clear(igraph_set_t* set) {
    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);
    set->end = set->stor_begin;
}


/**
 * \ingroup set
 * \function igraph_set_size
 * \brief Gives the size (=length) of the set.
 *
 * \param v The set object
 * \return The size of the set.
 *
 * Time complexity: O(1).
 */

long int igraph_set_size(const igraph_set_t* set) {
    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);
    return set->end - set->stor_begin;
}


/**
 * \ingroup set
 * \function igraph_set_add
 * \brief Adds an element to the set.
 *
 * \param set The set object.
 * \param e The element to be added.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: not enough memory.
 *
 * Time complexity: O(log(n)), n is the number of elements in \p set.
 */
int igraph_set_add(igraph_set_t* set, igraph_integer_t e) {
    long int left, right, middle;
    long int size;
    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);

    size = igraph_set_size(set);

    /* search where to insert the new element */
    left = 0;
    right = size - 1;
    while (left < right - 1) {
        middle = (left + right) / 2;
        if (SET(*set)[middle] > e) {
            right = middle;
        } else if (SET(*set)[middle] < e) {
            left = middle;
        } else {
            left = middle;
            break;
        }
    }

    if (right >= 0 && SET(*set)[left] != e && SET(*set)[right] == e) {
        left = right;
    }

    while (left < size && set->stor_begin[left] < e) {
        left++;
    }
    if (left >= size || set->stor_begin[left] != e) {
        /* full, allocate more storage */
        if (set->stor_end == set->end) {
            long int new_size = size * 2;
            if (new_size == 0) {
                new_size = 1;
            }
            IGRAPH_CHECK(igraph_set_reserve(set, new_size));
        }

        /* Element should be inserted at position 'left' */
        if (left < size)
            memmove(set->stor_begin + left + 1, set->stor_begin + left,
                    (size_t) (size - left)*sizeof(set->stor_begin[0]));

        set->stor_begin[left] = e;
        set->end += 1;
    }

    return 0;
}

/**
 * \ingroup set
 * \function igraph_set_contains
 * \brief Checks whether a given element is in the set or not.
 *
 * \param set The set object.
 * \param e The element being sought.
 * \return Positive integer (true) if \p e is found, zero (false) otherwise.
 *
 * Time complexity: O(log(n)), n is the number of elements in \p set.
 */
igraph_bool_t igraph_set_contains(igraph_set_t* set, igraph_integer_t e) {
    long int left, right, middle;

    IGRAPH_ASSERT(set != NULL);
    IGRAPH_ASSERT(set->stor_begin != NULL);

    left = 0;
    right = igraph_set_size(set) - 1;

    if (right == -1) {
        return 0;    /* the set is empty */
    }

    /* search for the new element */
    while (left < right - 1) {
        middle = (left + right) / 2;
        if (SET(*set)[middle] > e) {
            right = middle;
        } else if (SET(*set)[middle] < e) {
            left = middle;
        } else {
            return 1;
        }
    }

    return SET(*set)[left] == e || SET(*set)[right] == e;
}

/**
 * \ingroup set
 * \function igraph_set_iterate
 * \brief Iterates through the element to the set.
 *
 * Elements are returned in an arbitrary order.
 *
 * \param set The set object.
 * \param state Internal state of the iteration.
 *   This should be a pointer to a \c long variable
 *   which must be zero for the first invocation.
 *   The object should not be adjusted and its value should
 *   not be used for anything during the iteration.
 * \param element The next element or \c NULL (if the iteration
 *   has ended) is returned here.
 *
 * \return Nonzero if there are more elements, zero otherwise.
 */
igraph_bool_t igraph_set_iterate(igraph_set_t* set, long int* state,
                                 igraph_integer_t* element) {
    IGRAPH_ASSERT(set != 0);
    IGRAPH_ASSERT(set->stor_begin != 0);
    IGRAPH_ASSERT(state != 0);
    IGRAPH_ASSERT(element != 0);

    if (*state < igraph_set_size(set)) {
        *element = set->stor_begin[*state];
        *state = *state + 1;
        return 1;
    } else {
        *element = 0;
        return 0;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/set.h0000644000175100001710000000454500000000000022345 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_SET_H
#define IGRAPH_CORE_SET_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

/* -------------------------------------------------- */
/* Flexible set                                       */
/* -------------------------------------------------- */

/**
 * Set containing integer numbers regardless of the order
 * \ingroup types
 */

typedef struct s_set {
    igraph_integer_t* stor_begin;
    igraph_integer_t* stor_end;
    igraph_integer_t* end;
} igraph_set_t;

#define IGRAPH_SET_NULL { 0,0,0 }
#define IGRAPH_SET_INIT_FINALLY(v, size) \
    do { IGRAPH_CHECK(igraph_set_init(v, size)); \
        IGRAPH_FINALLY(igraph_set_destroy, v); } while (0)

IGRAPH_PRIVATE_EXPORT int igraph_set_init(igraph_set_t* set, long int size);
IGRAPH_PRIVATE_EXPORT void igraph_set_destroy(igraph_set_t* set);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_set_inited(igraph_set_t* set);
IGRAPH_PRIVATE_EXPORT int igraph_set_reserve(igraph_set_t* set, long int size);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_set_empty(const igraph_set_t* set);
IGRAPH_PRIVATE_EXPORT void igraph_set_clear(igraph_set_t* set);
IGRAPH_PRIVATE_EXPORT long int igraph_set_size(const igraph_set_t* set);
IGRAPH_PRIVATE_EXPORT int igraph_set_add(igraph_set_t* v, igraph_integer_t e);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_set_contains(igraph_set_t* set, igraph_integer_t e);
IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_set_iterate(igraph_set_t* set, long int* state,
                                                       igraph_integer_t* element);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/sparsemat.c0000644000175100001710000030706000000000000023542 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "igraph_sparsemat.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_vector_ptr.h"
#include "igraph_attributes.h"

#include 

/**
 * \section about_sparsemat About sparse matrices
 *
 * 
 * The igraph_sparsemat_t data type stores sparse matrices,
 * i.e. matrices in which the majority of the elements are zero.
 * 
 *
 * The data type is essentially a wrapper to some of the
 * functions in the CXSparse library, by Tim Davis, see
 * http://faculty.cse.tamu.edu/davis/suitesparse.html
 * 
 *
 * 
 * Matrices can be stored in two formats: triplet and
 * column-compressed. The triplet format is intended for sparse matrix
 * initialization, as it is easy to add new (non-zero) elements to
 * it. Most of the computations are done on sparse matrices in
 * column-compressed format, after the user has converted the triplet
 * matrix to column-compressed, via \ref igraph_sparsemat_compress().
 * 
 *
 * 
 * Both formats are dynamic, in the sense that new elements can be
 * added to them, possibly resulting the allocation of more memory.
 * 
 *
 * 
 * Row and column indices follow the C convention and are zero-based.
 * 
 *
 * 
 * \example examples/simple/igraph_sparsemat.c
 * \example examples/simple/igraph_sparsemat3.c
 * \example examples/simple/igraph_sparsemat4.c
 * \example examples/simple/igraph_sparsemat6.c
 * \example examples/simple/igraph_sparsemat7.c
 * \example examples/simple/igraph_sparsemat8.c
 * 
 */

/**
 * \function igraph_sparsemat_init
 * \brief Initializes a sparse matrix, in triplet format.
 *
 * This is the most common way to create a sparse matrix, together
 * with the \ref igraph_sparsemat_entry() function, which can be used to
 * add the non-zero elements one by one. Once done, the user can call
 * \ref igraph_sparsemat_compress() to convert the matrix to
 * column-compressed, to allow computations with it.
 *
 * The user must call \ref igraph_sparsemat_destroy() on
 * the matrix to deallocate the memory, once the matrix is no more
 * needed.
 * \param A Pointer to a not yet initialized sparse matrix.
 * \param rows The number of rows in the matrix.
 * \param cols The number of columns.
 * \param nzmax The maximum number of non-zero elements in the
 *    matrix. It is not compulsory to get this right, but it is
 *    useful for the allocation of the proper amount of memory.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_init(igraph_sparsemat_t *A, int rows, int cols, int nzmax) {

    if (rows < 0) {
        IGRAPH_ERROR("Negative number of rows", IGRAPH_EINVAL);
    }
    if (cols < 0) {
        IGRAPH_ERROR("Negative number of columns", IGRAPH_EINVAL);
    }

    A->cs = cs_spalloc( rows, cols, nzmax, /*values=*/ 1,
                        /*triplet=*/ 1);
    if (!A->cs) {
        IGRAPH_ERROR("Cannot allocate memory for sparse matrix", IGRAPH_ENOMEM);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_copy
 * \brief Copies a sparse matrix.
 *
 * Create a sparse matrix object, by copying another one. The source
 * matrix can be either in triplet or column-compressed format.
 *
 * 
 * Exactly the same amount of memory will be allocated to the
 * copy matrix, as it is currently for the original one.
 * \param to Pointer to an uninitialized sparse matrix, the copy will
 *    be created here.
 * \param from The sparse matrix to copy.
 * \return Error code.
 *
 * Time complexity: O(n+nzmax), the number of columns plus the maximum
 * number of non-zero elements.
 */

int igraph_sparsemat_copy(igraph_sparsemat_t *to,
                          const igraph_sparsemat_t *from) {

    CS_INT ne = from->cs->nz == -1 ? from->cs->n + 1 : from->cs->nzmax;

    to->cs = cs_spalloc(from->cs->m, from->cs->n, from->cs->nzmax,
                        /*values=*/ 1,
                        /*triplet=*/ igraph_sparsemat_is_triplet(from));

    to->cs->nzmax = from->cs->nzmax;
    to->cs->m     = from->cs->m;
    to->cs->n     = from->cs->n;
    to->cs->nz    = from->cs->nz;

    memcpy(to->cs->p, from->cs->p, sizeof(int) * (size_t) ne);
    memcpy(to->cs->i, from->cs->i, sizeof(int) * (size_t) (from->cs->nzmax));
    memcpy(to->cs->x, from->cs->x, sizeof(double) * (size_t) (from->cs->nzmax));

    return 0;
}

/**
 * \function igraph_sparsemat_destroy
 * \brief Deallocates memory used by a sparse matrix.
 *
 * One destroyed, the sparse matrix must be initialized again, before
 * calling any other operation on it.
 * \param A The sparse matrix to destroy.
 *
 * Time complexity: O(1).
 */

void igraph_sparsemat_destroy(igraph_sparsemat_t *A) {
    cs_spfree(A->cs);
}

/**
 * \function igraph_sparsemat_realloc
 * \brief Allocates more (or less) memory for a sparse matrix.
 *
 * Sparse matrices automatically allocate more memory, as needed. To
 * control memory allocation, the user can call this function, to
 * allocate memory for a given number of non-zero elements.
 *
 * \param A The sparse matrix, it can be in triplet or
 *    column-compressed format.
 * \param nzmax The new maximum number of non-zero elements.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_realloc(igraph_sparsemat_t *A, int nzmax) {
    if (!cs_sprealloc(A->cs, nzmax)) {
        IGRAPH_ERROR("Could not allocate more memory for sparse matrix.", IGRAPH_ENOMEM);
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_nrow
 * \brief Number of rows.
 *
 * \param A The input matrix, in triplet or column-compressed format.
 * \return The number of rows in the \p A matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_sparsemat_nrow(const igraph_sparsemat_t *A) {
    return A->cs->m;
}

/**
 * \function igraph_sparsemat_ncol
 * \brief Number of columns.
 *
 * \param A The input matrix, in triplet or column-compressed format.
 * \return The number of columns in the \p A matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_sparsemat_ncol(const igraph_sparsemat_t *A) {
    return A->cs->n;
}

/**
 * \function igraph_sparsemat_type
 * \brief Type of a sparse matrix (triplet or column-compressed).
 *
 * Gives whether a sparse matrix is stored in the triplet format or in
 * column-compressed format.
 * \param A The input matrix.
 * \return Either \c IGRAPH_SPARSEMAT_CC or \c
 * IGRAPH_SPARSEMAT_TRIPLET.
 *
 * Time complexity: O(1).
 */

igraph_sparsemat_type_t igraph_sparsemat_type(const igraph_sparsemat_t *A) {
    return A->cs->nz < 0 ? IGRAPH_SPARSEMAT_CC : IGRAPH_SPARSEMAT_TRIPLET;
}

/**
 * \function igraph_sparsemat_is_triplet
 * \brief Is this sparse matrix in triplet format?
 *
 * Decides whether a sparse matrix is in triplet format.
 * \param A The input matrix.
 * \return One if the input matrix is in triplet format, zero
 * otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t igraph_sparsemat_is_triplet(const igraph_sparsemat_t *A) {
    return A->cs->nz >= 0;
}

/**
 * \function igraph_sparsemat_is_cc
 * \brief Is this sparse matrix in column-compressed format?
 *
 * Decides whether a sparse matrix is in column-compressed format.
 * \param A The input matrix.
 * \return One if the input matrix is in column-compressed format, zero
 * otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t igraph_sparsemat_is_cc(const igraph_sparsemat_t *A) {
    return A->cs->nz < 0;
}

/**
 * \function igraph_sparsemat_permute
 * \brief Permutes the rows and columns of a sparse matrix.
 *
 * \param A The input matrix, it must be in column-compressed format.
 * \param p Integer vector, giving the permutation of the rows.
 * \param q Integer vector, the permutation of the columns.
 * \param res Pointer to an uninitialized sparse matrix, the result is
 *   stored here.
 * \return Error code.
 *
 * Time complexity: O(m+n+nz), the number of rows plus the number of
 * columns plus the number of non-zero elements in the matrix.
 */

int igraph_sparsemat_permute(const igraph_sparsemat_t *A,
                             const igraph_vector_int_t *p,
                             const igraph_vector_int_t *q,
                             igraph_sparsemat_t *res) {

    CS_INT nrow = A->cs->m, ncol = A->cs->n;
    igraph_vector_int_t pinv;
    CS_INT i;

    if (nrow != igraph_vector_int_size(p)) {
        IGRAPH_ERROR("Invalid row permutation length", IGRAPH_FAILURE);
    }
    if (ncol != igraph_vector_int_size(q)) {
        IGRAPH_ERROR("Invalid column permutation length", IGRAPH_FAILURE);
    }

    /* We invert the permutation by hand */
    IGRAPH_CHECK(igraph_vector_int_init(&pinv, nrow));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &pinv);
    for (i = 0; i < nrow; i++) {
        VECTOR(pinv)[ VECTOR(*p)[i] ] = (int) i;
    }

    /* And call the permutation routine */
    res->cs = cs_permute(A->cs, VECTOR(pinv), VECTOR(*q), /*values=*/ 1);
    if (!res->cs) {
        IGRAPH_ERROR("Cannot index sparse matrix", IGRAPH_FAILURE);
    }

    igraph_vector_int_destroy(&pinv);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_sparsemat_index_rows(const igraph_sparsemat_t *A,
                                         const igraph_vector_int_t *p,
                                         igraph_sparsemat_t *res,
                                         igraph_real_t *constres) {

    igraph_sparsemat_t II, II2;
    CS_INT nrow = A->cs->m;
    long int idx_rows = igraph_vector_int_size(p);
    long int k;

    /* Create index matrix */
    IGRAPH_CHECK(igraph_sparsemat_init(&II2, (int) idx_rows, (int) nrow,
                                       (int) idx_rows));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &II2);
    for (k = 0; k < idx_rows; k++) {
        igraph_sparsemat_entry(&II2, (int) k, VECTOR(*p)[k], 1.0);
    }
    IGRAPH_CHECK(igraph_sparsemat_compress(&II2, &II));
    igraph_sparsemat_destroy(&II2);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &II);

    /* Multiply */
    IGRAPH_CHECK(igraph_sparsemat_multiply(&II, A, res));
    igraph_sparsemat_destroy(&II);
    IGRAPH_FINALLY_CLEAN(1);

    if (constres) {
        if (res->cs->p[1] != 0) {
            *constres = res->cs->x[0];
        } else {
            *constres = 0.0;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_index_cols(const igraph_sparsemat_t *A,
                                         const igraph_vector_int_t *q,
                                         igraph_sparsemat_t *res,
                                         igraph_real_t *constres) {

    igraph_sparsemat_t JJ, JJ2;
    CS_INT ncol = A->cs->n;
    long int idx_cols = igraph_vector_int_size(q);
    long int k;

    /* Create index matrix */
    IGRAPH_CHECK(igraph_sparsemat_init(&JJ2, (int) ncol, (int) idx_cols,
                                       (int) idx_cols));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &JJ2);
    for (k = 0; k < idx_cols; k++) {
        igraph_sparsemat_entry(&JJ2, VECTOR(*q)[k], (int) k, 1.0);
    }
    IGRAPH_CHECK(igraph_sparsemat_compress(&JJ2, &JJ));
    igraph_sparsemat_destroy(&JJ2);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &JJ);

    /* Multiply */
    IGRAPH_CHECK(igraph_sparsemat_multiply(A, &JJ, res));
    igraph_sparsemat_destroy(&JJ);
    IGRAPH_FINALLY_CLEAN(1);

    if (constres) {
        if (res->cs->p [1] != 0) {
            *constres = res->cs->x [0];
        } else {
            *constres = 0.0;
        }
    }

    return 0;
}

/**
 * \function igraph_sparsemat_index
 * \brief Extracts a submatrix or a single element.
 *
 * This function indexes into a sparse matrix.
 * It serves two purposes. First, it can extract
 * submatrices from a sparse matrix. Second, as a special case, it can
 * extract a single element from a sparse matrix.
 *
 * \param A The input matrix, it must be in column-compressed format.
 * \param p An integer vector, or a null pointer. The selected row
 *    index or indices. A null pointer selects all rows.
 * \param q An integer vector, or a null pointer. The selected column
 *    index or indices. A null pointer selects all columns.
 * \param res Pointer to an uninitialized sparse matrix, or a null
 *    pointer. If not a null pointer, then the selected submatrix is
 *    stored here.
 * \param constres Pointer to a real variable or a null pointer. If
 *    not a null pointer, then the first non-zero element in the
 *    selected submatrix is stored here, if there is one. Otherwise
 *    zero is stored here. This behavior is handy if one
 *    wants to select a single entry from the matrix.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_index(const igraph_sparsemat_t *A,
                           const igraph_vector_int_t *p,
                           const igraph_vector_int_t *q,
                           igraph_sparsemat_t *res,
                           igraph_real_t *constres) {

    igraph_sparsemat_t II, JJ, II2, JJ2, tmp;
    CS_INT nrow = A->cs->m;
    CS_INT ncol = A->cs->n;
    long int idx_rows = p ? igraph_vector_int_size(p) : -1;
    long int idx_cols = q ? igraph_vector_int_size(q) : -1;
    long int k;

    igraph_sparsemat_t *myres = res, mres;

    if (!p && !q) {
        IGRAPH_ERROR("No index vectors", IGRAPH_EINVAL);
    }

    if (!res && (idx_rows != 1 || idx_cols != 1)) {
        IGRAPH_ERROR("Sparse matrix indexing: must give `res' if not a "
                     "single element is selected", IGRAPH_EINVAL);
    }

    if (!q) {
        return igraph_i_sparsemat_index_rows(A, p, res, constres);
    }
    if (!p) {
        return igraph_i_sparsemat_index_cols(A, q, res, constres);
    }

    if (!res) {
        myres = &mres;
    }

    /* Create first index matrix */
    IGRAPH_CHECK(igraph_sparsemat_init(&II2, (int) idx_rows, (int) nrow,
                                       (int) idx_rows));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &II2);
    for (k = 0; k < idx_rows; k++) {
        igraph_sparsemat_entry(&II2, (int) k, VECTOR(*p)[k], 1.0);
    }
    IGRAPH_CHECK(igraph_sparsemat_compress(&II2, &II));
    igraph_sparsemat_destroy(&II2);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &II);

    /* Create second index matrix */
    IGRAPH_CHECK(igraph_sparsemat_init(&JJ2, (int) ncol, (int) idx_cols,
                                       (int) idx_cols));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &JJ2);
    for (k = 0; k < idx_cols; k++) {
        igraph_sparsemat_entry(&JJ2, VECTOR(*q)[k], (int) k, 1.0);
    }
    IGRAPH_CHECK(igraph_sparsemat_compress(&JJ2, &JJ));
    igraph_sparsemat_destroy(&JJ2);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &JJ);

    /* Multiply */
    IGRAPH_CHECK(igraph_sparsemat_multiply(&II, A, &tmp));
    igraph_sparsemat_destroy(&II);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
    IGRAPH_CHECK(igraph_sparsemat_multiply(&tmp, &JJ, myres));
    igraph_sparsemat_destroy(&tmp);
    igraph_sparsemat_destroy(&JJ);
    IGRAPH_FINALLY_CLEAN(2);

    if (constres) {
        if (myres->cs->p [1] != 0) {
            *constres = myres->cs->x [0];
        } else {
            *constres = 0.0;
        }
    }

    if (!res) {
        igraph_sparsemat_destroy(myres);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_entry
 * \brief Adds an element to a sparse matrix.
 *
 * This function can be used to add the entries to a sparse matrix,
 * after initializing it with \ref igraph_sparsemat_init(). If you add
 * multiple entries in the same position, they will all be saved, and
 * the resulting value is the sum of all entries in that position.
 *
 * \param A The input matrix, it must be in triplet format.
 * \param row The row index of the entry to add.
 * \param col The column index of the entry to add.
 * \param elem The value of the entry.
 * \return Error code.
 *
 * Time complexity: O(1) on average.
 */

int igraph_sparsemat_entry(igraph_sparsemat_t *A, int row, int col,
                           igraph_real_t elem) {
    if (!igraph_sparsemat_is_triplet(A)) {
        IGRAPH_ERROR("Entries can only be added to sparse matrices that are in triplet format.",
                     IGRAPH_EINVAL);
    }

    if (!cs_entry(A->cs, row, col, elem)) {
        IGRAPH_ERROR("Cannot add entry to sparse matrix.",
                     IGRAPH_FAILURE);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_compress
 * \brief Converts a sparse matrix to column-compressed format.
 *
 * Converts a sparse matrix from triplet format to column-compressed format.
 * Almost all sparse matrix operations require that the matrix is in
 * column-compressed format.
 *
 * \param A The input matrix, it must be in triplet format.
 * \param res Pointer to an uninitialized sparse matrix object, the
 *    compressed version of \p A is stored here.
 * \return Error code.
 *
 * Time complexity: O(nz) where \c nz is the number of non-zero elements.
 */

int igraph_sparsemat_compress(const igraph_sparsemat_t *A,
                              igraph_sparsemat_t *res) {

    if (! igraph_sparsemat_is_triplet(A)) {
        IGRAPH_ERROR("Sparse matrix to compress is not in triplet format.", IGRAPH_EINVAL);
    }
    res->cs = cs_compress(A->cs);
    if (!res->cs) {
        IGRAPH_ERROR("Cannot compress sparse matrix", IGRAPH_FAILURE);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_transpose
 * \brief Transposes a sparse matrix.
 *
 * \param A The input matrix, column-compressed or triple format.
 * \param res Pointer to an uninitialized sparse matrix, the result is
 *    stored here.
 * \param values If this is non-zero, the matrix transpose is
 *    calculated the normal way. If it is zero, then only the pattern
 *    of the input matrix is stored in the result, the values are not.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_transpose(const igraph_sparsemat_t *A,
                               igraph_sparsemat_t *res,
                               int values) {

    if (A->cs->nz < 0) {
        /* column-compressed */
        res->cs = cs_transpose(A->cs, values);
        if (!res->cs) {
            IGRAPH_ERROR("Cannot transpose sparse matrix", IGRAPH_FAILURE);
        }
    } else {
        /* triplets */
        CS_INT *tmp;
        IGRAPH_CHECK(igraph_sparsemat_copy(res, A));
        tmp = res->cs->p;
        res->cs->p = res->cs->i;
        res->cs->i = tmp;
    }
    return 0;
}

static int igraph_i_sparsemat_is_symmetric_cc(const igraph_sparsemat_t *A, igraph_bool_t *result) {
    igraph_sparsemat_t t, tt;
    igraph_bool_t res;
    int nz;

    IGRAPH_CHECK(igraph_sparsemat_transpose(A, &t, /*values=*/ 1));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &t);
    IGRAPH_CHECK(igraph_sparsemat_dupl(&t));
    IGRAPH_CHECK(igraph_sparsemat_transpose(&t, &tt, /*values=*/ 1));
    igraph_sparsemat_destroy(&t);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tt);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&tt, &t, /*values=*/ 1));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &t);

    nz = t.cs->p[t.cs->n];
    res = memcmp(t.cs->i, tt.cs->i, sizeof(int) * (size_t) nz) == 0;
    res = res && memcmp(t.cs->p, tt.cs->p, sizeof(int) *
                        (size_t)(t.cs->n + 1)) == 0;
    res = res && memcmp(t.cs->x, tt.cs->x, sizeof(igraph_real_t) * (size_t)nz) == 0;

    igraph_sparsemat_destroy(&t);
    igraph_sparsemat_destroy(&tt);
    IGRAPH_FINALLY_CLEAN(2);

    *result = res;

    return IGRAPH_SUCCESS;
}

static int igraph_i_sparsemat_is_symmetric_triplet(const igraph_sparsemat_t *A, igraph_bool_t *result) {
    igraph_sparsemat_t tmp;

    IGRAPH_CHECK(igraph_sparsemat_compress(A, &tmp));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
    IGRAPH_CHECK(igraph_i_sparsemat_is_symmetric_cc(&tmp, result));
    igraph_sparsemat_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

igraph_bool_t igraph_sparsemat_is_symmetric(const igraph_sparsemat_t *A) {
    igraph_bool_t res = 0;

    if (A->cs->m != A->cs->n) {
        return 0;
    }

    /* TODO(ntamas): return values from igraph_i_sparsemat_is_symmetric_... are
     * ignored here; this should be fixed. Right now these functions don't
     * change 'res' if they fail so we will report matrices as not being
     * symmetric if an error happens */
    if (A->cs->nz < 0) {
        igraph_i_sparsemat_is_symmetric_cc(A, &res);
    } else {
        igraph_i_sparsemat_is_symmetric_triplet(A, &res);
    }

    return res;
}

/**
 * \function igraph_sparsemat_dupl
 * \brief Removes duplicate elements from a sparse matrix.
 *
 * It is possible that a column-compressed sparse matrix stores a
 * single matrix entry in multiple pieces. The entry is then the sum
 * of all its pieces. (Some functions create matrices like this.) This
 * function eliminates the multiple pieces.
 * \param A The input matrix, in column-compressed format.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_dupl(igraph_sparsemat_t *A) {

    if (!cs_dupl(A->cs)) {
        IGRAPH_ERROR("Cannot remove duplicates from sparse matrix",
                     IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_fkeep
 * \brief Filters the elements of a sparse matrix.
 *
 * This function can be used to filter the (non-zero) elements of a
 * sparse matrix. For all entries, it calls the supplied function and
 * depending on the return values either keeps, or deleted the element
 * from the matrix.
 * \param A The input matrix, in column-compressed format.
 * \param fkeep The filter function. It must take four arguments: the
 *    first is an \c int, the row index of the entry, the second is
 *    another \c int, the column index. The third is \c igraph_real_t,
 *    the value of the entry. The fourth element is a \c void pointer,
 *    the \p other argument is passed here. The function must return
 *    an \c int. If this is zero, then the entry is deleted, otherwise
 *    it is kept.
 * \param other A \c void pointer that is passed to the filtering
 * function.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_fkeep(
    igraph_sparsemat_t *A,
    igraph_integer_t (*fkeep)(igraph_integer_t, igraph_integer_t, igraph_real_t, void*),
    void *other
) {

    IGRAPH_ASSERT(A);
    IGRAPH_ASSERT(fkeep);
    if (!igraph_sparsemat_is_cc(A)) {
        IGRAPH_ERROR("The sparse matrix is not in compressed format.", IGRAPH_EINVAL);
    }
    if (cs_fkeep(A->cs, fkeep, other) < 0) {
        IGRAPH_ERROR("External function cs_keep has returned an unknown error while filtering the matrix.", IGRAPH_FAILURE);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_dropzeros
 * \brief Drops the zero elements from a sparse matrix.
 *
 * As a result of matrix operations, some of the entries in a sparse
 * matrix might be zero. This function removes these entries.
 * \param A The input matrix, it must be in column-compressed format.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_dropzeros(igraph_sparsemat_t *A) {

    if (!cs_dropzeros(A->cs)) {
        IGRAPH_ERROR("Cannot drop zeros from sparse matrix", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_droptol
 * \brief Drops the almost zero elements from a sparse matrix.
 *
 * This function is similar to \ref igraph_sparsemat_dropzeros(), but it
 * also drops entries that are closer to zero than the given tolerance
 * threshold.
 * \param A The input matrix, it must be in column-compressed format.
 * \param tol Real number, giving the tolerance threshold.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_droptol(igraph_sparsemat_t *A, igraph_real_t tol) {

    IGRAPH_ASSERT(A);
    if (!igraph_sparsemat_is_cc(A)) {
        IGRAPH_ERROR("The sparse matrix is not in compressed format.", IGRAPH_EINVAL);
    }
    if (cs_droptol(A->cs, tol) < 0) {
        IGRAPH_ERROR("External function cs_droptol has returned an unknown error.", IGRAPH_FAILURE);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_multiply
 * \brief Matrix multiplication.
 *
 * Multiplies two sparse matrices.
 * \param A The first input matrix (left hand side), in
 *   column-compressed format.
 * \param B The second input matrix (right hand side), in
 *   column-compressed format.
 * \param res Pointer to an uninitialized sparse matrix, the result is
 *   stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_multiply(const igraph_sparsemat_t *A,
                              const igraph_sparsemat_t *B,
                              igraph_sparsemat_t *res) {

    res->cs = cs_multiply(A->cs, B->cs);
    if (!res->cs) {
        IGRAPH_ERROR("Cannot multiply matrices", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_add
 * \brief Sum of two sparse matrices.
 *
 * \param A The first input matrix, in column-compressed format.
 * \param B The second input matrix, in column-compressed format.
 * \param alpha Real scalar, \p A is multiplied by \p alpha before the
 *    addition.
 * \param beta Real scalar, \p B is multiplied by \p beta before the
 *    addition.
 * \param res Pointer to an uninitialized sparse matrix, the result
 *    is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_add(const igraph_sparsemat_t *A,
                         const igraph_sparsemat_t *B,
                         igraph_real_t alpha,
                         igraph_real_t beta,
                         igraph_sparsemat_t *res) {

    res->cs = cs_add(A->cs, B->cs, alpha, beta);
    if (!res->cs) {
        IGRAPH_ERROR("Cannot add matrices", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_gaxpy
 * \brief Matrix-vector product, added to another vector.
 *
 * \param A The input matrix, in column-compressed format.
 * \param x The input vector, its size must match the number of
 *    columns in \p A.
 * \param res This vector is added to the matrix-vector product
 *    and it is overwritten by the result.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_gaxpy(const igraph_sparsemat_t *A,
                           const igraph_vector_t *x,
                           igraph_vector_t *res) {

    if (A->cs->n != igraph_vector_size(x) ||
        A->cs->m != igraph_vector_size(res)) {
        IGRAPH_ERROR("Invalid matrix/vector size for multiplication",
                     IGRAPH_EINVAL);
    }

    if (! (cs_gaxpy(A->cs, VECTOR(*x), VECTOR(*res)))) {
        IGRAPH_ERROR("Cannot perform sparse matrix vector multiplication",
                     IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_lsolve
 * \brief Solves a lower-triangular linear system.
 *
 * Solve the Lx=b linear equation system, where the L coefficient
 * matrix is square and lower-triangular, with a zero-free diagonal.
 * \param L The input matrix, in column-compressed format.
 * \param b The right hand side of the linear system.
 * \param res An initialized vector, the result is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_lsolve(const igraph_sparsemat_t *L,
                            const igraph_vector_t *b,
                            igraph_vector_t *res) {

    if (L->cs->m != L->cs->n) {
        IGRAPH_ERROR("Cannot perform lower triangular solve", IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (! cs_lsolve(L->cs, VECTOR(*res))) {
        IGRAPH_ERROR("Cannot perform lower triangular solve", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_ltsolve
 * \brief Solves an upper-triangular linear system.
 *
 * Solve the L'x=b linear equation system, where the L
 * matrix is square and lower-triangular, with a zero-free diagonal.
 * \param L The input matrix, in column-compressed format.
 * \param b The right hand side of the linear system.
 * \param res An initialized vector, the result is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_ltsolve(const igraph_sparsemat_t *L,
                             const igraph_vector_t *b,
                             igraph_vector_t *res) {

    if (L->cs->m != L->cs->n) {
        IGRAPH_ERROR("Cannot perform transposed lower triangular solve",
                     IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (!cs_ltsolve(L->cs, VECTOR(*res))) {
        IGRAPH_ERROR("Cannot perform lower triangular solve", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_usolve
 * \brief Solves an upper-triangular linear system.
 *
 * Solves the Ux=b upper triangular system.
 * \param U The input matrix, in column-compressed format.
 * \param b The right hand side of the linear system.
 * \param res An initialized vector, the result is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_usolve(const igraph_sparsemat_t *U,
                            const igraph_vector_t *b,
                            igraph_vector_t *res) {

    if (U->cs->m != U->cs->n) {
        IGRAPH_ERROR("Cannot perform upper triangular solve", IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (! cs_usolve(U->cs, VECTOR(*res))) {
        IGRAPH_ERROR("Cannot perform upper triangular solve", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_utsolve
 * \brief Solves a lower-triangular linear system.
 *
 * This is the same as \ref igraph_sparsemat_usolve(), but U'x=b is
 * solved, where the apostrophe denotes the transpose.
 * \param U The input matrix, in column-compressed format.
 * \param b The right hand side of the linear system.
 * \param res An initialized vector, the result is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_utsolve(const igraph_sparsemat_t *U,
                             const igraph_vector_t *b,
                             igraph_vector_t *res) {

    if (U->cs->m != U->cs->n) {
        IGRAPH_ERROR("Cannot perform transposed upper triangular solve",
                     IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (!cs_utsolve(U->cs, VECTOR(*res))) {
        IGRAPH_ERROR("Cannot perform transposed upper triangular solve",
                     IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_cholsol
 * \brief Solves a symmetric linear system via Cholesky decomposition.
 *
 * Solve Ax=b, where A is a symmetric positive definite matrix.
 * \param A The input matrix, in column-compressed format.
 * \param v The right hand side.
 * \param res An initialized vector, the result is stored here.
 * \param order An integer giving the ordering method to use for the
 *    factorization. Zero is the natural ordering; if it is one, then
 *    the fill-reducing minimum-degree ordering of A+A' is used.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_cholsol(const igraph_sparsemat_t *A,
                             const igraph_vector_t *b,
                             igraph_vector_t *res,
                             int order) {

    if (A->cs->m != A->cs->n) {
        IGRAPH_ERROR("Cannot perform sparse symmetric solve",
                     IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (! cs_cholsol(order, A->cs, VECTOR(*res))) {
        IGRAPH_ERROR("Cannot perform sparse symmetric solve", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_lusol
 * \brief Solves a linear system via LU decomposition.
 *
 * Solve Ax=b, via LU factorization of A.
 * \param A The input matrix, in column-compressed format.
 * \param b The right hand side of the equation.
 * \param res An initialized vector, the result is stored here.
 * \param order The ordering method to use, zero means the natural
 *    ordering, one means the fill-reducing minimum-degree ordering of
 *    A+A', two means the ordering of A'*A, after removing the dense
 *    rows from A. Three means the ordering of A'*A.
 * \param tol Real number, the tolerance limit to use for the numeric
 *    LU factorization.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_lusol(const igraph_sparsemat_t *A,
                           const igraph_vector_t *b,
                           igraph_vector_t *res,
                           int order,
                           igraph_real_t tol) {

    if (A->cs->m != A->cs->n) {
        IGRAPH_ERROR("Cannot perform LU solve",
                     IGRAPH_NONSQUARE);
    }

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    if (! cs_lusol(order, A->cs, VECTOR(*res), tol)) {
        IGRAPH_ERROR("Cannot perform LU solve", IGRAPH_FAILURE);
    }

    return 0;
}

static int igraph_i_sparsemat_cc(igraph_t *graph, const igraph_sparsemat_t *A,
                                 igraph_bool_t directed) {

    igraph_vector_t edges;
    CS_INT no_of_nodes = A->cs->m;
    CS_INT no_of_edges = A->cs->p[A->cs->n];
    CS_INT *p = A->cs->p;
    CS_INT *i = A->cs->i;
    long int from = 0;
    long int to = 0;
    long int e = 0;

    if (no_of_nodes != A->cs->n) {
        IGRAPH_ERROR("Cannot create graph object", IGRAPH_NONSQUARE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    while (*p < no_of_edges) {
        while (to < * (p + 1)) {
            if (directed || from >= *i) {
                VECTOR(edges)[e++] = from;
                VECTOR(edges)[e++] = (*i);
            }
            to++;
            i++;
        }
        from++;
        p++;
    }
    igraph_vector_resize(&edges, e);

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_sparsemat_triplet(igraph_t *graph, const igraph_sparsemat_t *A,
                                      igraph_bool_t directed) {

    igraph_vector_t edges;
    CS_INT no_of_nodes = A->cs->m;
    CS_INT no_of_edges = A->cs->nz;
    CS_INT *i = A->cs->p;
    CS_INT *j = A->cs->i;
    long int e;

    if (no_of_nodes != A->cs->n) {
        IGRAPH_ERROR("Cannot create graph object", IGRAPH_NONSQUARE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    for (e = 0; e < 2 * no_of_edges; i++, j++) {
        if (directed || *i >= *j) {
            VECTOR(edges)[e++] = (*i);
            VECTOR(edges)[e++] = (*j);
        }
    }
    igraph_vector_resize(&edges, e);

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_sparsemat
 * \brief Creates an igraph graph from a sparse matrix.
 *
 * One edge is created for each non-zero entry in the matrix. If you
 * have a symmetric matrix, and want to create an undirected graph,
 * then delete the entries in the upper diagonal first, or call \ref
 * igraph_simplify() on the result graph to eliminate the multiple
 * edges.
 * \param graph Pointer to an uninitialized igraph_t object, the
 *    graphs is stored here.
 * \param A The input matrix, in triplet or column-compressed format.
 * \param directed Boolean scalar, whether to create a directed
 *    graph.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat(igraph_t *graph, const igraph_sparsemat_t *A,
                     igraph_bool_t directed) {

    if (A->cs->nz < 0) {
        return (igraph_i_sparsemat_cc(graph, A, directed));
    } else {
        return (igraph_i_sparsemat_triplet(graph, A, directed));
    }
}

static int igraph_i_weighted_sparsemat_cc(const igraph_sparsemat_t *A,
                                          igraph_bool_t directed, const char *attr,
                                          igraph_bool_t loops,
                                          igraph_vector_t *edges,
                                          igraph_vector_t *weights) {

    CS_INT no_of_edges = A->cs->p[A->cs->n];
    CS_INT *p = A->cs->p;
    CS_INT *i = A->cs->i;
    CS_ENTRY *x = A->cs->x;
    long int from = 0;
    long int to = 0;
    long int e = 0, w = 0;

    IGRAPH_UNUSED(attr);

    igraph_vector_resize(edges, no_of_edges * 2);
    igraph_vector_resize(weights, no_of_edges);

    while (*p < no_of_edges) {
        while (to < * (p + 1)) {
            if ( (loops || from != *i) && (directed || from >= *i) && *x != 0) {
                VECTOR(*edges)[e++] = (*i);
                VECTOR(*edges)[e++] = from;
                VECTOR(*weights)[w++] = (*x);
            }
            to++;
            i++;
            x++;
        }
        from++;
        p++;
    }

    igraph_vector_resize(edges, e);
    igraph_vector_resize(weights, w);

    return 0;
}

static int igraph_i_weighted_sparsemat_triplet(const igraph_sparsemat_t *A,
                                               igraph_bool_t directed,
                                               const char *attr,
                                               igraph_bool_t loops,
                                               igraph_vector_t *edges,
                                               igraph_vector_t *weights) {

    IGRAPH_UNUSED(A); IGRAPH_UNUSED(directed); IGRAPH_UNUSED(attr);
    IGRAPH_UNUSED(loops); IGRAPH_UNUSED(edges); IGRAPH_UNUSED(weights);

    /* TODO */
    IGRAPH_ERROR("Triplet matrices are not implemented",
                 IGRAPH_UNIMPLEMENTED);
}

int igraph_weighted_sparsemat(igraph_t *graph, const igraph_sparsemat_t *A,
                              igraph_bool_t directed, const char *attr,
                              igraph_bool_t loops) {

    igraph_vector_t edges, weights;
    CS_INT pot_edges = A->cs->nz < 0 ? A->cs->p[A->cs->n] : A->cs->nz;
    const char* default_attr = "weight";
    igraph_vector_ptr_t attr_vec;
    igraph_attribute_record_t attr_rec;
    CS_INT no_of_nodes = A->cs->m;

    if (no_of_nodes != A->cs->n) {
        IGRAPH_ERROR("Cannot create graph object", IGRAPH_NONSQUARE);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, pot_edges * 2);
    IGRAPH_VECTOR_INIT_FINALLY(&weights, pot_edges);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&attr_vec, 1);

    if (A->cs->nz < 0) {
        IGRAPH_CHECK(igraph_i_weighted_sparsemat_cc(A, directed, attr, loops,
                     &edges, &weights));
    } else {
        IGRAPH_CHECK(igraph_i_weighted_sparsemat_triplet(A, directed, attr,
                     loops, &edges,
                     &weights));
    }

    /* Prepare attribute record */
    attr_rec.name = attr ? attr : default_attr;
    attr_rec.type = IGRAPH_ATTRIBUTE_NUMERIC;
    attr_rec.value = &weights;
    VECTOR(attr_vec)[0] = &attr_rec;

    /* Create graph */
    IGRAPH_CHECK(igraph_empty(graph, (igraph_integer_t) no_of_nodes, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);
    if (igraph_vector_size(&edges) > 0) {
        IGRAPH_CHECK(igraph_add_edges(graph, &edges, &attr_vec));
    }
    IGRAPH_FINALLY_CLEAN(1);

    /* Cleanup */
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&weights);
    igraph_vector_ptr_destroy(&attr_vec);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_get_sparsemat
 * \brief Converts an igraph graph to a sparse matrix.
 *
 * If the graph is undirected, then a symmetric matrix is created.
 * \param graph The input graph.
 * \param res Pointer to an uninitialized sparse matrix. The result
 *    will be stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_get_sparsemat(const igraph_t *graph, igraph_sparsemat_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    long int nzmax = directed ? no_of_edges : no_of_edges * 2;
    long int i;

    IGRAPH_CHECK(igraph_sparsemat_init(res, (igraph_integer_t) no_of_nodes,
                                       (igraph_integer_t) no_of_nodes,
                                       (igraph_integer_t) nzmax));

    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);
        IGRAPH_CHECK(igraph_sparsemat_entry(res, (int) from, (int) to, 1.0));
        if (!directed && from != to) {
            IGRAPH_CHECK(igraph_sparsemat_entry(res, (int) to, (int) from, 1.0));
        }
    }

    return 0;
}

#define CHECK(x) if ((x)<0) { IGRAPH_ERROR("Cannot write to file", IGRAPH_EFILE); }

/**
 * \function igraph_sparsemat_print
 * \brief Prints a sparse matrix to a file.
 *
 * Only the non-zero entries are printed. This function serves more as
 * a debugging utility, as currently there is no function that could
 * read back the printed matrix from the file.
 * \param A The input matrix, triplet or column-compressed format.
 * \param outstream The stream to print it to.
 * \return Error code.
 *
 * Time complexity: O(nz) for triplet matrices, O(n+nz) for
 * column-compressed matrices. nz is the number of non-zero elements,
 * n is the number columns in the matrix.
 */

int igraph_sparsemat_print(const igraph_sparsemat_t *A,
                           FILE *outstream) {

    if (A->cs->nz < 0) {
        /* CC */
        CS_INT j, p;
        for (j = 0; j < A->cs->n; j++) {
            CHECK(fprintf(outstream, "col " CS_ID ": locations " CS_ID " to " CS_ID "\n",
                          j, A->cs->p[j], A->cs->p[j + 1] - 1));
            for (p = A->cs->p[j]; p < A->cs->p[j + 1]; p++) {
                CHECK(fprintf(outstream, CS_ID " : %g\n", A->cs->i[p], A->cs->x[p]));
            }
        }
    } else {
        /* Triplet */
        CS_INT p;
        for (p = 0; p < A->cs->nz; p++) {
            CHECK(fprintf(outstream, CS_ID " " CS_ID " : %g\n",
                          A->cs->i[p], A->cs->p[p], A->cs->x[p]));
        }
    }

    return 0;
}

#undef CHECK

static int igraph_i_sparsemat_eye_triplet(igraph_sparsemat_t *A, int n, int nzmax,
                                          igraph_real_t value) {
    long int i;

    IGRAPH_CHECK(igraph_sparsemat_init(A, n, n, nzmax));

    for (i = 0; i < n; i++) {
        igraph_sparsemat_entry(A, (int) i, (int) i, value);
    }

    return 0;
}

static int igraph_i_sparsemat_eye_cc(igraph_sparsemat_t *A, int n,
                                     igraph_real_t value) {
    CS_INT i;

    A->cs = cs_spalloc(n, n, n, /*values=*/ 1, /*triplet=*/ 0);
    if (!A->cs) {
        IGRAPH_ERROR("Cannot create eye sparse matrix", IGRAPH_FAILURE);
    }

    for (i = 0; i < n; i++) {
        A->cs->p [i] = i;
        A->cs->i [i] = i;
        A->cs->x [i] = value;
    }
    A->cs->p [n] = n;

    return 0;
}

/**
 * \function igraph_sparsemat_eye
 * \brief Creates a sparse identity matrix.
 *
 * \param A An uninitialized sparse matrix, the result is stored
 *   here.
 * \param n The number of rows and number of columns in the matrix.
 * \param nzmax The maximum number of non-zero elements, this
 *   essentially gives the amount of memory that will be allocated for
 *   matrix elements.
 * \param value The value to store in the diagonal.
 * \param compress Whether to create a column-compressed matrix. If
 *   false, then a triplet matrix is created.
 * \return Error code.
 *
 * Time complexity: O(n).
 */

int igraph_sparsemat_eye(igraph_sparsemat_t *A, int n, int nzmax,
                         igraph_real_t value,
                         igraph_bool_t compress) {
    if (compress) {
        return (igraph_i_sparsemat_eye_cc(A, n, value));
    } else {
        return (igraph_i_sparsemat_eye_triplet(A, n, nzmax, value));
    }
}

static int igraph_i_sparsemat_diag_triplet(igraph_sparsemat_t *A, int nzmax,
                                           const igraph_vector_t *values) {

    int i, n = (int) igraph_vector_size(values);

    IGRAPH_CHECK(igraph_sparsemat_init(A, n, n, nzmax));

    for (i = 0; i < n; i++) {
        igraph_sparsemat_entry(A, i, i, VECTOR(*values)[i]);
    }

    return 0;

}

static int igraph_i_sparsemat_diag_cc(igraph_sparsemat_t *A,
                                      const igraph_vector_t *values) {

    CS_INT i, n = igraph_vector_size(values);

    A->cs = cs_spalloc(n, n, n, /*values=*/ 1, /*triplet=*/ 0);
    if (!A->cs) {
        IGRAPH_ERROR("Cannot create eye sparse matrix", IGRAPH_FAILURE);
    }

    for (i = 0; i < n; i++) {
        A->cs->p [i] = i;
        A->cs->i [i] = i;
        A->cs->x [i] = VECTOR(*values)[i];
    }
    A->cs->p [n] = n;

    return 0;

}

/**
 * \function igraph_sparsemat_diag
 * \brief Creates a sparse diagonal matrix.
 *
 * \param A An uninitialized sparse matrix, the result is stored
 *    here.
 * \param nzmax The maximum number of non-zero elements, this
 *   essentially gives the amount of memory that will be allocated for
 *   matrix elements.
 * \param values The values to store in the diagonal, the size of the
 *    matrix defined by the length of this vector.
 * \param compress Whether to create a column-compressed matrix. If
 *   false, then a triplet matrix is created.
 * \return Error code.
 *
 * Time complexity: O(n), the length of the diagonal vector.
 */

int igraph_sparsemat_diag(igraph_sparsemat_t *A, int nzmax,
                          const igraph_vector_t *values,
                          igraph_bool_t compress) {

    if (compress) {
        return (igraph_i_sparsemat_diag_cc(A, values));
    } else {
        return (igraph_i_sparsemat_diag_triplet(A, nzmax, values));
    }
}

static int igraph_i_sparsemat_arpack_multiply(igraph_real_t *to,
                                              const igraph_real_t *from,
                                              int n,
                                              void *extra) {
    igraph_sparsemat_t *A = extra;
    igraph_vector_t vto, vfrom;
    igraph_vector_view(&vto, to, n);
    igraph_vector_view(&vfrom, from, n);
    igraph_vector_null(&vto);
    IGRAPH_CHECK(igraph_sparsemat_gaxpy(A, &vfrom, &vto));
    return 0;
}

typedef struct igraph_i_sparsemat_arpack_rssolve_data_t {
    igraph_sparsemat_symbolic_t *dis;
    igraph_sparsemat_numeric_t *din;
    igraph_real_t tol;
    igraph_sparsemat_solve_t method;
} igraph_i_sparsemat_arpack_rssolve_data_t;

static int igraph_i_sparsemat_arpack_solve(igraph_real_t *to,
                                           const igraph_real_t *from,
                                           int n,
                                           void *extra) {

    igraph_i_sparsemat_arpack_rssolve_data_t *data = extra;
    igraph_vector_t vfrom, vto;

    igraph_vector_view(&vfrom, from, n);
    igraph_vector_view(&vto, to, n);

    if (data->method == IGRAPH_SPARSEMAT_SOLVE_LU) {
        IGRAPH_CHECK(igraph_sparsemat_luresol(data->dis, data->din, &vfrom,
                                              &vto));
    } else if (data->method == IGRAPH_SPARSEMAT_SOLVE_QR) {
        IGRAPH_CHECK(igraph_sparsemat_qrresol(data->dis, data->din, &vfrom,
                                              &vto));

    }

    return 0;
}

/**
 * \function igraph_sparsemat_arpack_rssolve
 * \brief Eigenvalues and eigenvectors of a symmetric sparse matrix via ARPACK.
 *
 * \param The input matrix, must be column-compressed.
 * \param options It is passed to \ref igraph_arpack_rssolve(). See
 *    \ref igraph_arpack_options_t for the details. If \c mode is 1,
 *    then ARPACK uses regular mode, if \c mode is 3, then shift and
 *    invert mode is used and the \c sigma structure member defines
 *    the shift.
 * \param storage Storage for ARPACK. See \ref
 *    igraph_arpack_rssolve() and \ref igraph_arpack_storage_t for
 *    details.
 * \param values An initialized vector or a null pointer, the
 *    eigenvalues are stored here.
 * \param vectors An initialised matrix, or a null pointer, the
 *    eigenvectors are stored here, in the columns.
 * \param solvemethod The method to solve the linear system, if \c
 *    mode is 3, i.e. the shift and invert mode is used.
 *    Possible values:
 *    \clist
 *      \cli IGRAPH_SPARSEMAT_SOLVE_LU
 *           The linear system is solved using LU decomposition.
 *      \cli IGRAPH_SPARSEMAT_SOLVE_QR
 *           The linear system is solved using QR decomposition.
 *    \endclist
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_arpack_rssolve(const igraph_sparsemat_t *A,
                                    igraph_arpack_options_t *options,
                                    igraph_arpack_storage_t *storage,
                                    igraph_vector_t *values,
                                    igraph_matrix_t *vectors,
                                    igraph_sparsemat_solve_t solvemethod) {

    int n = (int) igraph_sparsemat_nrow(A);

    if (n != igraph_sparsemat_ncol(A)) {
        IGRAPH_ERROR("Non-square matrix for ARPACK", IGRAPH_NONSQUARE);
    }

    options->n = n;

    if (options->mode == 1) {
        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_sparsemat_arpack_multiply,
                                           (void*) A, options, storage,
                                           values, vectors));
    } else if (options->mode == 3) {
        igraph_real_t sigma = options->sigma;
        igraph_sparsemat_t OP, eye;
        igraph_sparsemat_symbolic_t symb;
        igraph_sparsemat_numeric_t num;
        igraph_i_sparsemat_arpack_rssolve_data_t data;
        /*-----------------------------------*/
        /* We need to factor the (A-sigma*I) */
        /*-----------------------------------*/

        /* Create (A-sigma*I) */
        IGRAPH_CHECK(igraph_sparsemat_eye(&eye, /*n=*/ n, /*nzmax=*/ n,
                                          /*value=*/ -sigma, /*compress=*/ 1));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, &eye);
        IGRAPH_CHECK(igraph_sparsemat_add(/*A=*/ A, /*B=*/ &eye, /*alpha=*/ 1.0,
                     /*beta=*/ 1.0, /*res=*/ &OP));
        igraph_sparsemat_destroy(&eye);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_FINALLY(igraph_sparsemat_destroy, &OP);

        if (solvemethod == IGRAPH_SPARSEMAT_SOLVE_LU) {
            /* Symbolic analysis */
            IGRAPH_CHECK(igraph_sparsemat_symblu(/*order=*/ 0, &OP, &symb));
            IGRAPH_FINALLY(igraph_sparsemat_symbolic_destroy, &symb);
            /* Numeric LU factorization */
            IGRAPH_CHECK(igraph_sparsemat_lu(&OP, &symb, &num, /*tol=*/ 0));
            IGRAPH_FINALLY(igraph_sparsemat_numeric_destroy, &num);
        } else if (solvemethod == IGRAPH_SPARSEMAT_SOLVE_QR) {
            /* Symbolic analysis */
            IGRAPH_CHECK(igraph_sparsemat_symbqr(/*order=*/ 0, &OP, &symb));
            IGRAPH_FINALLY(igraph_sparsemat_symbolic_destroy, &symb);
            /* Numeric QR factorization */
            IGRAPH_CHECK(igraph_sparsemat_qr(&OP, &symb, &num));
            IGRAPH_FINALLY(igraph_sparsemat_numeric_destroy, &num);
        }

        data.dis = &symb;
        data.din = #
        data.tol = options->tol;
        data.method = solvemethod;
        IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_sparsemat_arpack_solve,
                                           (void*) &data, options, storage,
                                           values, vectors));

        igraph_sparsemat_numeric_destroy(&num);
        igraph_sparsemat_symbolic_destroy(&symb);
        igraph_sparsemat_destroy(&OP);
        IGRAPH_FINALLY_CLEAN(3);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_arpack_rnsolve
 * \brief Eigenvalues and eigenvectors of a nonsymmetric sparse matrix via ARPACK.
 *
 * Eigenvalues and/or eigenvectors of a nonsymmetric sparse matrix.
 * \param A The input matrix, in column-compressed mode.
 * \param options ARPACK options, it is passed to \ref
 *    igraph_arpack_rnsolve(). See also \ref igraph_arpack_options_t
 *    for details.
 * \param storage Storage for ARPACK, this is passed to \ref
 *    igraph_arpack_rnsolve(). See \ref igraph_arpack_storage_t for
 *    details.
 * \param values An initialized matrix, or a null pointer. If not a
 *    null pointer, then the eigenvalues are stored here, the first
 *    column is the real part, the second column is the imaginary
 *    part.
 * \param vectors An initialized matrix, or a null pointer. If not a
 *    null pointer, then the eigenvectors are stored here, please see
 *    \ref igraph_arpack_rnsolve() for the format.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_arpack_rnsolve(const igraph_sparsemat_t *A,
                                    igraph_arpack_options_t *options,
                                    igraph_arpack_storage_t *storage,
                                    igraph_matrix_t *values,
                                    igraph_matrix_t *vectors) {

    int n = (int) igraph_sparsemat_nrow(A);

    if (n != igraph_sparsemat_ncol(A)) {
        IGRAPH_ERROR("Non-square matrix for ARPACK", IGRAPH_NONSQUARE);
    }

    options->n = n;

    return igraph_arpack_rnsolve(igraph_i_sparsemat_arpack_multiply,
                                 (void*) A, options, storage,
                                 values, vectors);
}

/**
 * \function igraph_sparsemat_symbqr
 * \brief Symbolic QR decomposition.
 *
 * QR decomposition of sparse matrices involves two steps, the first
 * is calling this function, and then \ref
 * igraph_sparsemat_qr().
 * \param order The ordering to use: 0 means natural ordering, 1 means
 *   minimum degree ordering of A+A', 2 is minimum degree ordering of
 *   A'A after removing the dense rows from A, and 3 is the minimum
 *   degree ordering of A'A.
 * \param A The input matrix, in column-compressed format.
 * \param dis The result of the symbolic analysis is stored here. Once
 *    not needed anymore, it must be destroyed by calling \ref
 *    igraph_sparsemat_symbolic_destroy().
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_symbqr(long int order, const igraph_sparsemat_t *A,
                            igraph_sparsemat_symbolic_t *dis) {

    dis->symbolic = cs_sqr((int) order, A->cs, /*qr=*/ 1);
    if (!dis->symbolic) {
        IGRAPH_ERROR("Cannot do symbolic QR decomposition", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_symblu
 * \brief Symbolic LU decomposition.
 *
 * LU decomposition of sparse matrices involves two steps, the first
 * is calling this function, and then \ref igraph_sparsemat_lu().
 * \param order The ordering to use: 0 means natural ordering, 1 means
 *   minimum degree ordering of A+A', 2 is minimum degree ordering of
 *   A'A after removing the dense rows from A, and 3 is the minimum
 *   degree ordering of A'A.
 * \param A The input matrix, in column-compressed format.
 * \param dis The result of the symbolic analysis is stored here. Once
 *    not needed anymore, it must be destroyed by calling \ref
 *    igraph_sparsemat_symbolic_destroy().
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_symblu(long int order, const igraph_sparsemat_t *A,
                            igraph_sparsemat_symbolic_t *dis) {

    dis->symbolic = cs_sqr((int) order, A->cs, /*qr=*/ 0);
    if (!dis->symbolic) {
        IGRAPH_ERROR("Cannot do symbolic LU decomposition", IGRAPH_FAILURE);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_lu
 * \brief LU decomposition of a sparse matrix.
 *
 * Performs numeric sparse LU decomposition of a matrix.
 * \param A The input matrix, in column-compressed format.
 * \param dis The symbolic analysis for LU decomposition, coming from
 *    a call to the \ref igraph_sparsemat_symblu() function.
 * \param din The numeric decomposition, the result is stored here. It
 *    can be used to solve linear systems with changing right hand
 *    side vectors, by calling \ref igraph_sparsemat_luresol(). Once
 *    not needed any more, it must be destroyed by calling \ref
 *    igraph_sparsemat_symbolic_destroy() on it.
 * \param tol The tolerance for the numeric LU decomposition.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_lu(const igraph_sparsemat_t *A,
                        const igraph_sparsemat_symbolic_t *dis,
                        igraph_sparsemat_numeric_t *din, double tol) {
    din->numeric = cs_lu(A->cs, dis->symbolic, tol);
    if (!din->numeric) {
        IGRAPH_ERROR("Cannot do LU decomposition", IGRAPH_FAILURE);
    }
    return 0;
}

/**
 * \function igraph_sparsemat_qr
 * \brief QR decomposition of a sparse matrix.
 *
 * Numeric QR decomposition of a sparse matrix.
 * \param A The input matrix, in column-compressed format.
 * \param dis The result of the symbolic QR analysis, from the
 *    function \ref igraph_sparsemat_symbqr().
 * \param din The result of the decomposition is stored here, it can
 *    be used to solve many linear systems with the same coefficient
 *    matrix and changing right hand sides, using the \ref
 *    igraph_sparsemat_qrresol() function. Once not needed any more,
 *    one should call \ref igraph_sparsemat_numeric_destroy() on it to
 *    free the allocated memory.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_qr(const igraph_sparsemat_t *A,
                        const igraph_sparsemat_symbolic_t *dis,
                        igraph_sparsemat_numeric_t *din) {
    din->numeric = cs_qr(A->cs, dis->symbolic);
    if (!din->numeric) {
        IGRAPH_ERROR("Cannot do QR decomposition", IGRAPH_FAILURE);
    }
    return 0;
}

/**
 * \function igraph_sparsemat_luresol
 * \brief Solves a linear system using a precomputed LU decomposition.
 *
 * Uses the LU decomposition of a matrix to solve linear systems.
 * \param dis The symbolic analysis of the coefficient matrix, the
 *    result of \ref igraph_sparsemat_symblu().
 * \param din The LU decomposition, the result of a call to \ref
 *    igraph_sparsemat_lu().
 * \param b A vector that defines the right hand side of the linear
 *    equation system.
 * \param res An initialized vector, the solution of the linear system
 *    is stored here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_luresol(const igraph_sparsemat_symbolic_t *dis,
                             const igraph_sparsemat_numeric_t *din,
                             const igraph_vector_t *b,
                             igraph_vector_t *res) {
    int n = din->numeric->L->n;
    igraph_real_t *workspace;

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    workspace = IGRAPH_CALLOC(n, igraph_real_t);
    if (!workspace) {
        IGRAPH_ERROR("Cannot LU (re)solve sparse matrix", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, workspace);

    if (!cs_ipvec(din->numeric->pinv, VECTOR(*res), workspace, n)) {
        IGRAPH_ERROR("Cannot LU (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    if (!cs_lsolve(din->numeric->L, workspace)) {
        IGRAPH_ERROR("Cannot LU (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    if (!cs_usolve(din->numeric->U, workspace)) {
        IGRAPH_ERROR("Cannot LU (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    if (!cs_ipvec(dis->symbolic->q, workspace, VECTOR(*res), n)) {
        IGRAPH_ERROR("Cannot LU (re)solve sparse matrix", IGRAPH_FAILURE);
    }

    IGRAPH_FREE(workspace);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_sparsemat_qrresol
 * \brief Solves a linear system using a precomputed QR decomposition.
 *
 * Solves a linear system using a QR decomposition of its coefficient
 * matrix.
 * \param dis Symbolic analysis of the coefficient matrix, the result
 *    of \ref igraph_sparsemat_symbqr().
 * \param din The QR decomposition of the coefficient matrix, the
 *    result of \ref igraph_sparsemat_qr().
 * \param b Vector, giving the right hand side of the linear equation
 *    system.
 * \param res An initialized vector, the solution is stored here. It
 *    is resized as needed.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_qrresol(const igraph_sparsemat_symbolic_t *dis,
                             const igraph_sparsemat_numeric_t *din,
                             const igraph_vector_t *b,
                             igraph_vector_t *res) {
    int n = din->numeric->L->n;
    igraph_real_t *workspace;
    int k;

    if (res != b) {
        IGRAPH_CHECK(igraph_vector_update(res, b));
    }

    workspace = IGRAPH_CALLOC(dis->symbolic ? dis->symbolic->m2 : 1,
                              igraph_real_t);
    if (!workspace) {
        IGRAPH_ERROR("Cannot QR (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    IGRAPH_FINALLY(igraph_free, workspace);

    if (!cs_ipvec(dis->symbolic->pinv, VECTOR(*res), workspace, n)) {
        IGRAPH_ERROR("Cannot QR (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    for (k = 0; k < n; k++) {
        if (!cs_happly(din->numeric->L, k, din->numeric->B[k], workspace)) {
            IGRAPH_ERROR("Cannot QR (re)solve sparse matrix", IGRAPH_FAILURE);
        }
    }
    if (!cs_usolve(din->numeric->U, workspace)) {
        IGRAPH_ERROR("Cannot QR (re)solve sparse matrix", IGRAPH_FAILURE);
    }
    if (!cs_ipvec(dis->symbolic->q, workspace, VECTOR(*res), n)) {
        IGRAPH_ERROR("Cannot QR (re)solve sparse matrix", IGRAPH_FAILURE);
    }

    IGRAPH_FREE(workspace);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_sparsemat_symbolic_destroy
 * \brief Deallocates memory after a symbolic decomposition.
 *
 * Frees the memory allocated by \ref igraph_sparsemat_symbqr() or
 * \ref igraph_sparsemat_symblu().
 * \param dis The symbolic analysis.
 *
 * Time complexity: O(1).
 */

void igraph_sparsemat_symbolic_destroy(igraph_sparsemat_symbolic_t *dis) {
    cs_sfree(dis->symbolic);
    dis->symbolic = 0;
}

/**
 * \function igraph_sparsemat_numeric_destroy
 * \brief Deallocates memory after a numeric decomposition.
 *
 * Frees the memoty allocated by \ref igraph_sparsemat_qr() or \ref
 * igraph_sparsemat_lu().
 * \param din The LU or QR decomposition.
 *
 * Time complexity: O(1).
 */

void igraph_sparsemat_numeric_destroy(igraph_sparsemat_numeric_t *din) {
    cs_nfree(din->numeric);
    din->numeric = 0;
}

/**
 * \function igraph_matrix_as_sparsemat
 * \brief Converts a dense matrix to a sparse matrix.
 *
 * \param res An uninitialized sparse matrix, the result is stored
 *    here.
 * \param mat The dense input matrix.
 * \param tol Real scalar, the tolerance. Values closer than \p tol to
 *    zero are considered as zero, and will not be included in the
 *    sparse matrix.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the dense
 * matrix.
 */

int igraph_matrix_as_sparsemat(igraph_sparsemat_t *res,
                               const igraph_matrix_t *mat,
                               igraph_real_t tol) {
    int nrow = (int) igraph_matrix_nrow(mat);
    int ncol = (int) igraph_matrix_ncol(mat);
    int i, j, nzmax = 0;

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            if (fabs(MATRIX(*mat, i, j)) > tol) {
                nzmax++;
            }
        }
    }

    IGRAPH_CHECK(igraph_sparsemat_init(res, nrow, ncol, nzmax));

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            if (fabs(MATRIX(*mat, i, j)) > tol) {
                IGRAPH_CHECK(igraph_sparsemat_entry(res, i, j, MATRIX(*mat, i, j)));
            }
        }
    }

    return 0;
}

static int igraph_i_sparsemat_as_matrix_cc(igraph_matrix_t *res,
                                           const igraph_sparsemat_t *spmat) {

    long int nrow = igraph_sparsemat_nrow(spmat);
    long int ncol = igraph_sparsemat_ncol(spmat);
    CS_INT from = 0, to = 0;
    CS_INT *p = spmat->cs->p;
    CS_INT *i = spmat->cs->i;
    CS_ENTRY *x = spmat->cs->x;
    CS_INT nzmax = spmat->cs->nzmax;

    IGRAPH_CHECK(igraph_matrix_resize(res, nrow, ncol));
    igraph_matrix_null(res);

    while (*p < nzmax) {
        while (to < * (p + 1)) {
            MATRIX(*res, *i, from) += *x;
            to++;
            i++;
            x++;
        }
        from++;
        p++;
    }

    return 0;
}

static int igraph_i_sparsemat_as_matrix_triplet(igraph_matrix_t *res,
                                                const igraph_sparsemat_t *spmat) {
    long int nrow = igraph_sparsemat_nrow(spmat);
    long int ncol = igraph_sparsemat_ncol(spmat);
    CS_INT *i = spmat->cs->p;
    CS_INT *j = spmat->cs->i;
    CS_ENTRY *x = spmat->cs->x;
    CS_INT nz = spmat->cs->nz;
    CS_INT e;

    IGRAPH_CHECK(igraph_matrix_resize(res, nrow, ncol));
    igraph_matrix_null(res);

    for (e = 0; e < nz; e++, i++, j++, x++) {
        MATRIX(*res, *j, *i) += *x;
    }

    return 0;
}

/**
 * \function igraph_sparsemat_as_matrix
 * \brief Converts a sparse matrix to a dense matrix.
 *
 * \param res Pointer to an initialized matrix, the result is stored
 *    here. It will be resized to the required size.
 * \param spmat The input sparse matrix, in triplet or
 *    column-compressed format.
 * \return Error code.
 *
 * Time complexity: O(mn), the number of elements in the dense
 * matrix.
 */

int igraph_sparsemat_as_matrix(igraph_matrix_t *res,
                               const igraph_sparsemat_t *spmat) {
    if (spmat->cs->nz < 0) {
        return (igraph_i_sparsemat_as_matrix_cc(res, spmat));
    } else {
        return (igraph_i_sparsemat_as_matrix_triplet(res, spmat));
    }
}

/**
 * \function igraph_sparsemat_max
 * \brief Maximum of a sparse matrix.
 *
 * \param A The input matrix, column-compressed.
 * \return The maximum in the input matrix, or \c IGRAPH_NEGINFINITY
 *    if the matrix has zero elements.
 *
 * Time complexity: TODO.
 */

igraph_real_t igraph_sparsemat_max(igraph_sparsemat_t *A) {
    CS_INT i, n;
    CS_ENTRY *ptr;
    igraph_real_t res;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ptr = A->cs->x;
    n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    if (n == 0) {
        return IGRAPH_NEGINFINITY;
    }
    res = *ptr;
    for (i = 1; i < n; i++, ptr++) {
        if (*ptr > res) {
            res = *ptr;
        }
    }
    return res;
}

/* TODO: CC matrix don't actually need _dupl,
   because the elements are right beside each other.
   Same for max and minmax. */

/**
 * \function igraph_sparsemat_min
 * \brief Minimum of a sparse matrix.
 *
 * \param A The input matrix, column-compressed.
 * \return The minimum in the input matrix, or \c IGRAPH_POSINFINITY
 *    if the matrix has zero elements.
 *
 * Time complexity: TODO.
 */

igraph_real_t igraph_sparsemat_min(igraph_sparsemat_t *A) {
    CS_INT i, n;
    CS_ENTRY *ptr;
    igraph_real_t res;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ptr = A->cs->x;
    n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    if (n == 0) {
        return IGRAPH_POSINFINITY;
    }
    res = *ptr;
    for (i = 1; i < n; i++, ptr++) {
        if (*ptr < res) {
            res = *ptr;
        }
    }
    return res;
}

/**
 * \function igraph_sparsemat_minmax
 * \brief Minimum and maximum of a sparse matrix.
 *
 * \param A The input matrix, column-compressed.
 * \param min The minimum in the input matrix is stored here, or \c
 *    IGRAPH_POSINFINITY if the matrix has zero elements.
 * \param max The maximum in the input matrix is stored here, or \c
 *    IGRAPH_NEGINFINITY if the matrix has zero elements.
 * \return Error code.
 *
 * Time complexity: TODO.
 */


int igraph_sparsemat_minmax(igraph_sparsemat_t *A,
                            igraph_real_t *min, igraph_real_t *max) {
    CS_INT i, n;
    CS_ENTRY *ptr;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ptr = A->cs->x;
    n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    if (n == 0) {
        *min = IGRAPH_POSINFINITY;
        *max = IGRAPH_NEGINFINITY;
        return 0;
    }
    *min = *max = *ptr;
    for (i = 1; i < n; i++, ptr++) {
        if (*ptr > *max) {
            *max = *ptr;
        } else if (*ptr < *min) {
            *min = *ptr;
        }
    }
    return 0;
}

/**
 * \function igraph_sparsemat_count_nonzero
 * \brief Counts nonzero elements of a sparse matrix.
 *
 * \param A The input matrix, column-compressed.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

long int igraph_sparsemat_count_nonzero(igraph_sparsemat_t *A) {
    CS_INT i, n;
    CS_ENTRY *ptr;
    int res = 0;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ptr = A->cs->x;
    n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    if (n == 0) {
        return 0;
    }
    for (i = 0; i < n; i++, ptr++) {
        if (*ptr) {
            res++;
        }
    }
    return res;
}

/**
 * \function igraph_sparsemat_count_nonzerotol
 * \brief Counts nonzero elements of a sparse matrix, ignoring elements close to zero.
 *
 * Count the number of matrix entries that are closer to zero than \p
 * tol.
 * \param The input matrix, column-compressed.
 * \param Real scalar, the tolerance.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

long int igraph_sparsemat_count_nonzerotol(igraph_sparsemat_t *A,
        igraph_real_t tol) {
    CS_INT i, n;
    CS_ENTRY *ptr;
    int res = 0;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ptr = A->cs->x;
    n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    if (n == 0) {
        return 0;
    }
    for (i = 0; i < n; i++, ptr++) {
        if (*ptr < - tol || *ptr > tol) {
            res++;
        }
    }
    return res;
}

static int igraph_i_sparsemat_rowsums_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pi = A->cs->i;
    CS_ENTRY *px = A->cs->x;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_null(res);

    for (i = 0; i < A->cs->nz; i++, pi++, px++) {
        VECTOR(*res)[ *pi ] += *px;
    }

    return 0;
}

static int igraph_i_sparsemat_rowsums_cc(const igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT ne = A->cs->p[A->cs->n];
    CS_ENTRY *px = A->cs->x;
    CS_INT *pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_null(res);

    for (; pi < A->cs->i + ne; pi++, px++) {
        VECTOR(*res)[ *pi ] += *px;
    }

    return 0;
}

/**
 * \function igraph_sparsemat_rowsums
 * \brief Row-wise sums.
 *
 * \param A The input matrix, in triplet or column-compressed format.
 * \param res An initialized vector, the result is stored here. It
 *    will be resized as needed.
 * \return Error code.
 *
 * Time complexity: O(nz), the number of non-zero elements.
 */

int igraph_sparsemat_rowsums(const igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_rowsums_triplet(A, res);
    } else {
        return igraph_i_sparsemat_rowsums_cc(A, res);
    }
}

static int igraph_i_sparsemat_rowmins_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pi = A->cs->i;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_fill(res, inf);

    for (i = 0; i < A->cs->nz; i++, pi++, px++) {
        if (*px < VECTOR(*res)[ *pi ]) {
            VECTOR(*res)[ *pi ] = *px;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_rowmins_cc(igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT ne;
    CS_ENTRY *px;
    CS_INT *pi;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ne = A->cs->p[A->cs->n];
    px = A->cs->x;
    pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_fill(res, inf);

    for (; pi < A->cs->i + ne; pi++, px++) {
        if (*px < VECTOR(*res)[ *pi ]) {
            VECTOR(*res)[ *pi ] = *px;
        }
    }

    return 0;
}

int igraph_sparsemat_rowmins(igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_rowmins_triplet(A, res);
    } else {
        return igraph_i_sparsemat_rowmins_cc(A, res);
    }
}


static int igraph_i_sparsemat_rowmaxs_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pi = A->cs->i;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_NEGINFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_fill(res, inf);

    for (i = 0; i < A->cs->nz; i++, pi++, px++) {
        if (*px > VECTOR(*res)[ *pi ]) {
            VECTOR(*res)[ *pi ] = *px;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_rowmaxs_cc(igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT ne;
    CS_ENTRY *px;
    CS_INT *pi;
    double inf = IGRAPH_NEGINFINITY;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    ne = A->cs->p[A->cs->n];
    px = A->cs->x;
    pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    igraph_vector_fill(res, inf);

    for (; pi < A->cs->i + ne; pi++, px++) {
        if (*px > VECTOR(*res)[ *pi ]) {
            VECTOR(*res)[ *pi ] = *px;
        }
    }

    return 0;
}

int igraph_sparsemat_rowmaxs(igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_rowmaxs_triplet(A, res);
    } else {
        return igraph_i_sparsemat_rowmaxs_cc(A, res);
    }
}

static int igraph_i_sparsemat_colmins_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pp = A->cs->p;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->n));
    igraph_vector_fill(res, inf);

    for (i = 0; i < A->cs->nz; i++, pp++, px++) {
        if (*px < VECTOR(*res)[ *pp ]) {
            VECTOR(*res)[ *pp ] = *px;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_colmins_cc(igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT n;
    CS_ENTRY *px;
    CS_INT *pp;
    CS_INT *pi;
    double *pr;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    n = A->cs->n;
    px = A->cs->x;
    pp = A->cs->p;
    pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, n));
    igraph_vector_fill(res, inf);
    pr = VECTOR(*res);

    for (; pp < A->cs->p + n; pp++, pr++) {
        for (; pi < A->cs->i + * (pp + 1); pi++, px++) {
            if (*px < *pr) {
                *pr = *px;
            }
        }
    }
    return 0;
}

int igraph_sparsemat_colmins(igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_colmins_triplet(A, res);
    } else {
        return igraph_i_sparsemat_colmins_cc(A, res);
    }
}

static int igraph_i_sparsemat_colmaxs_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pp = A->cs->p;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_NEGINFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->n));
    igraph_vector_fill(res, inf);

    for (i = 0; i < A->cs->nz; i++, pp++, px++) {
        if (*px > VECTOR(*res)[ *pp ]) {
            VECTOR(*res)[ *pp ] = *px;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_colmaxs_cc(igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT n;
    CS_ENTRY *px;
    CS_INT *pp;
    CS_INT *pi;
    double *pr;
    double inf = IGRAPH_NEGINFINITY;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    n = A->cs->n;
    px = A->cs->x;
    pp = A->cs->p;
    pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, n));
    igraph_vector_fill(res, inf);
    pr = VECTOR(*res);

    for (; pp < A->cs->p + n; pp++, pr++) {
        for (; pi < A->cs->i + * (pp + 1); pi++, px++) {
            if (*px > *pr) {
                *pr = *px;
            }
        }
    }
    return 0;
}

int igraph_sparsemat_colmaxs(igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_colmaxs_triplet(A, res);
    } else {
        return igraph_i_sparsemat_colmaxs_cc(A, res);
    }
}

static int igraph_i_sparsemat_which_min_rows_triplet(igraph_sparsemat_t *A,
                                                     igraph_vector_t *res,
                                                     igraph_vector_int_t *pos) {
    CS_INT i;
    CS_INT *pi = A->cs->i;
    CS_INT *pp = A->cs->p;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    IGRAPH_CHECK(igraph_vector_int_resize(pos, A->cs->m));
    igraph_vector_fill(res, inf);
    igraph_vector_int_null(pos);

    for (i = 0; i < A->cs->nz; i++, pi++, px++, pp++) {
        if (*px < VECTOR(*res)[ *pi ]) {
            VECTOR(*res)[ *pi ] = *px;
            VECTOR(*pos)[ *pi ] = *pp;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_which_min_rows_cc(igraph_sparsemat_t *A,
                                                igraph_vector_t *res,
                                                igraph_vector_int_t *pos) {
    CS_INT n;
    CS_ENTRY *px;
    CS_INT *pp;
    CS_INT *pi;
    double inf = IGRAPH_INFINITY;
    int j;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    n = A->cs->n;
    px = A->cs->x;
    pp = A->cs->p;
    pi = A->cs->i;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->m));
    IGRAPH_CHECK(igraph_vector_int_resize(pos, A->cs->m));
    igraph_vector_fill(res, inf);
    igraph_vector_int_null(pos);

    for (j = 0; pp < A->cs->p + n; pp++, j++) {
        for (; pi < A->cs->i + * (pp + 1); pi++, px++) {
            if (*px < VECTOR(*res)[ *pi ]) {
                VECTOR(*res)[ *pi ] = *px;
                VECTOR(*pos)[ *pi ] = j;
            }
        }
    }

    return 0;
}

int igraph_sparsemat_which_min_rows(igraph_sparsemat_t *A,
                                    igraph_vector_t *res,
                                    igraph_vector_int_t *pos) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_which_min_rows_triplet(A, res, pos);
    } else {
        return igraph_i_sparsemat_which_min_rows_cc(A, res, pos);
    }
}

static int igraph_i_sparsemat_which_min_cols_triplet(igraph_sparsemat_t *A,
                                                     igraph_vector_t *res,
                                                     igraph_vector_int_t *pos) {

    CS_INT i;
    CS_INT *pi = A->cs->i;
    CS_INT *pp = A->cs->p;
    CS_ENTRY *px = A->cs->x;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->n));
    IGRAPH_CHECK(igraph_vector_int_resize(pos, A->cs->n));
    igraph_vector_fill(res, inf);
    igraph_vector_int_null(pos);

    for (i = 0; i < A->cs->nz; i++, pi++, pp++, px++) {
        if (*px < VECTOR(*res)[ *pp ]) {
            VECTOR(*res)[ *pp ] = *px;
            VECTOR(*pos)[ *pp ] = *pi;
        }
    }

    return 0;
}

static int igraph_i_sparsemat_which_min_cols_cc(igraph_sparsemat_t *A,
                                                igraph_vector_t *res,
                                                igraph_vector_int_t *pos) {
    CS_INT n, j, p;
    CS_ENTRY *px;
    double *pr;
    igraph_integer_t *ppos;
    double inf = IGRAPH_INFINITY;

    IGRAPH_CHECK(igraph_sparsemat_dupl(A));

    n = A->cs->n;
    px = A->cs->x;

    IGRAPH_CHECK(igraph_vector_resize(res, n));
    igraph_vector_fill(res, inf);
    pr = VECTOR(*res);
    IGRAPH_CHECK(igraph_vector_int_resize(pos, n));
    igraph_vector_int_null(pos);
    ppos = VECTOR(*pos);

    for (j = 0; j < A->cs->n; j++, pr++, ppos++) {
        for (p = A->cs->p[j]; p < A->cs->p[j + 1]; p++, px++) {
            if (*px < *pr) {
                *pr = *px;
                *ppos = A->cs->i[p];
            }
        }
    }
    return 0;
}

int igraph_sparsemat_which_min_cols(igraph_sparsemat_t *A,
                                    igraph_vector_t *res,
                                    igraph_vector_int_t *pos) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_which_min_cols_triplet(A, res, pos);
    } else {
        return igraph_i_sparsemat_which_min_cols_cc(A, res, pos);
    }
}

static int igraph_i_sparsemat_colsums_triplet(const igraph_sparsemat_t *A,
                                              igraph_vector_t *res) {
    CS_INT i;
    CS_INT *pp = A->cs->p;
    CS_ENTRY *px = A->cs->x;

    IGRAPH_CHECK(igraph_vector_resize(res, A->cs->n));
    igraph_vector_null(res);

    for (i = 0; i < A->cs->nz; i++, pp++, px++) {
        VECTOR(*res)[ *pp ] += *px;
    }

    return 0;
}

static int igraph_i_sparsemat_colsums_cc(const igraph_sparsemat_t *A,
                                         igraph_vector_t *res) {
    CS_INT n = A->cs->n;
    CS_ENTRY *px = A->cs->x;
    CS_INT *pp = A->cs->p;
    CS_INT *pi = A->cs->i;
    double *pr;

    IGRAPH_CHECK(igraph_vector_resize(res, n));
    igraph_vector_null(res);
    pr = VECTOR(*res);

    for (; pp < A->cs->p + n; pp++, pr++) {
        for (; pi < A->cs->i + * (pp + 1); pi++, px++) {
            *pr += *px;
        }
    }
    return 0;
}

/**
 * \function igraph_sparsemat_colsums
 * \brief Column-wise sums.
 *
 * \param A The input matrix, in triplet or column-compressed format.
 * \param res An initialized vector, the result is stored here. It
 *    will be resized as needed.
 * \return Error code.
 *
 * Time complexity: O(nz) for triplet matrices, O(nz+n) for
 * column-compressed ones, nz is the number of non-zero elements, n is
 * the number of columns.
 */

int igraph_sparsemat_colsums(const igraph_sparsemat_t *A,
                             igraph_vector_t *res) {
    if (igraph_sparsemat_is_triplet(A)) {
        return igraph_i_sparsemat_colsums_triplet(A, res);
    } else {
        return igraph_i_sparsemat_colsums_cc(A, res);
    }
}

/**
 * \function igraph_sparsemat_scale
 * \brief Scales a sparse matrix.
 *
 * Multiplies all elements of a sparse matrix, by the given scalar.
 * \param A The input matrix.
 * \param by The scaling factor.
 * \return Error code.
 *
 * Time complexity: O(nz), the number of non-zero elements in the
 * matrix.
 */

int igraph_sparsemat_scale(igraph_sparsemat_t *A, igraph_real_t by) {

    CS_ENTRY *px = A->cs->x;
    CS_INT n = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    CS_ENTRY *stop = px + n;

    for (; px < stop; px++) {
        *px *= by;
    }

    return 0;
}

/**
 * \function igraph_sparsemat_add_rows
 * \brief Adds rows to a sparse matrix.
 *
 * The current matrix elements are retained and all elements in the
 * new rows are zero.
 * \param A The input matrix, in triplet or column-compressed format.
 * \param n The number of rows to add.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_add_rows(igraph_sparsemat_t *A, long int n) {
    A->cs->m += n;
    return 0;
}

/**
 * \function igraph_sparsemat_add_cols
 * \brief Adds columns to a sparse matrix.
 *
 * The current matrix elements are retained, and all elements in the
 * new columns are zero.
 * \param A The input matrix, in triplet or column-compressed format.
 * \param n The number of columns to add.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_sparsemat_add_cols(igraph_sparsemat_t *A, long int n) {
    if (igraph_sparsemat_is_triplet(A)) {
        A->cs->n += n;
    } else {
        CS_INT realloc_ok = 0, i;
        CS_INT *newp = cs_realloc(A->cs->p, (A->cs->n + n + 1), sizeof(int), &realloc_ok);
        if (!realloc_ok) {
            IGRAPH_ERROR("Cannot add columns to sparse matrix", IGRAPH_ENOMEM);
        }
        if (newp != A->cs->p) {
            A->cs->p = newp;
        }
        for (i = A->cs->n + 1; i < A->cs->n + n + 1; i++) {
            A->cs->p[i] = A->cs->p[i - 1];
        }
        A->cs->n += n;
    }
    return 0;
}

/**
 * \function igraph_sparsemat_resize
 * \brief Resizes a sparse matrix.
 *
 * This function resizes a sparse matrix. The resized sparse matrix
 * will be empty.
 *
 * \param A The initialized sparse matrix to resize.
 * \param nrow The new number of rows.
 * \param ncol The new number of columns.
 * \param nzmax The new maximum number of elements.
 * \return Error code.
 *
 * Time complexity: O(nzmax), the maximum number of non-zero elements.
 */

int igraph_sparsemat_resize(igraph_sparsemat_t *A, long int nrow,
                            long int ncol, int nzmax) {

    if (A->cs->nz < 0) {
        igraph_sparsemat_t tmp;
        IGRAPH_CHECK(igraph_sparsemat_init(&tmp, (int) nrow, (int) ncol, nzmax));
        igraph_sparsemat_destroy(A);
        *A = tmp;
    } else {
        IGRAPH_CHECK(igraph_sparsemat_realloc(A, nzmax));
        A->cs->m = (int) nrow;
        A->cs->n = (int) ncol;
        A->cs->nz = 0;
    }
    return 0;
}

/**
 * \function igraph_sparsemat_nonzero_storage
 * \brief Returns number of stored entries of a sparse matrix.
 *
 * This function will return the number of stored entries of a sparse
 * matrix. These entries can be zero, and multiple entries can be
 * at the same position. Use \ref igraph_sparsemat_dupl() to sum
 * duplicate entries, and \ref igraph_sparsemat_dropzeros() to remove
 * zeros.
 *
 * \param A A sparse matrix in either triplet or compressed form.
 * \return Number of stored entries.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_nonzero_storage(const igraph_sparsemat_t *A) {
    if (A->cs->nz < 0) {
        return A->cs->p[A->cs->n];
    } else {
        return A->cs->nz;
    }
}

int igraph_sparsemat_getelements(const igraph_sparsemat_t *A,
                                 igraph_vector_int_t *i,
                                 igraph_vector_int_t *j,
                                 igraph_vector_t *x) {
    CS_INT nz = A->cs->nz;
    if (nz < 0) {
        nz = A->cs->p[A->cs->n];
        IGRAPH_CHECK(igraph_vector_int_resize(i, nz));
        IGRAPH_CHECK(igraph_vector_int_resize(j, A->cs->n + 1));
        IGRAPH_CHECK(igraph_vector_resize(x, nz));
        memcpy(VECTOR(*i), A->cs->i, (size_t) nz * sizeof(int));
        memcpy(VECTOR(*j), A->cs->p, (size_t) (A->cs->n + 1) * sizeof(int));
        memcpy(VECTOR(*x), A->cs->x, (size_t) nz * sizeof(igraph_real_t));
    } else {
        IGRAPH_CHECK(igraph_vector_int_resize(i, nz));
        IGRAPH_CHECK(igraph_vector_int_resize(j, nz));
        IGRAPH_CHECK(igraph_vector_resize(x, nz));
        memcpy(VECTOR(*i), A->cs->i, (size_t) nz * sizeof(int));
        memcpy(VECTOR(*j), A->cs->p, (size_t) nz * sizeof(int));
        memcpy(VECTOR(*x), A->cs->x, (size_t) nz * sizeof(igraph_real_t));
    }
    return 0;
}

int igraph_sparsemat_scale_rows(igraph_sparsemat_t *A,
                                const igraph_vector_t *fact) {
    CS_INT *i = A->cs->i;
    CS_ENTRY *x = A->cs->x;
    CS_INT no_of_edges = A->cs->nz < 0 ? A->cs->p[A->cs->n] : A->cs->nz;
    CS_INT e;

    for (e = 0; e < no_of_edges; e++, x++, i++) {
        igraph_real_t f = VECTOR(*fact)[*i];
        (*x) *= f;
    }

    return 0;
}

static int igraph_i_sparsemat_scale_cols_cc(igraph_sparsemat_t *A,
                                            const igraph_vector_t *fact) {
    CS_INT *i = A->cs->i;
    CS_ENTRY *x = A->cs->x;
    CS_INT no_of_edges = A->cs->p[A->cs->n];
    CS_INT e;
    CS_INT c = 0;        /* actual column */

    for (e = 0; e < no_of_edges; e++, x++, i++) {
        igraph_real_t f;
        while (c < A->cs->n && A->cs->p[c + 1] == e) {
            c++;
        }
        f = VECTOR(*fact)[c];
        (*x) *= f;
    }

    return 0;
}

static int igraph_i_sparsemat_scale_cols_triplet(igraph_sparsemat_t *A,
                                                 const igraph_vector_t *fact) {
    CS_INT *j = A->cs->p;
    CS_ENTRY *x = A->cs->x;
    CS_INT no_of_edges = A->cs->nz;
    CS_INT e;

    for (e = 0; e < no_of_edges; e++, x++, j++) {
        igraph_real_t f = VECTOR(*fact)[*j];
        (*x) *= f;
    }

    return 0;
}

int igraph_sparsemat_scale_cols(igraph_sparsemat_t *A,
                                const igraph_vector_t *fact) {
    if (A->cs->nz < 0) {
        return igraph_i_sparsemat_scale_cols_cc(A, fact);
    } else {
        return igraph_i_sparsemat_scale_cols_triplet(A, fact);
    }
}

int igraph_sparsemat_multiply_by_dense(const igraph_sparsemat_t *A,
                                       const igraph_matrix_t *B,
                                       igraph_matrix_t *res) {

    int m = (int) igraph_sparsemat_nrow(A);
    int n = (int) igraph_sparsemat_ncol(A);
    int p = (int) igraph_matrix_ncol(B);
    int i;

    if (igraph_matrix_nrow(B) != n) {
        IGRAPH_ERROR("Invalid dimensions in sparse-dense matrix product",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, m, p));
    igraph_matrix_null(res);

    for (i = 0; i < p; i++) {
        if (!(cs_gaxpy(A->cs, &MATRIX(*B, 0, i), &MATRIX(*res, 0, i)))) {
            IGRAPH_ERROR("Cannot perform sparse-dense matrix multiplication",
                         IGRAPH_FAILURE);
        }
    }

    return 0;
}

int igraph_sparsemat_dense_multiply(const igraph_matrix_t *A,
                                    const igraph_sparsemat_t *B,
                                    igraph_matrix_t *res) {
    int m = (int) igraph_matrix_nrow(A);
    int n = (int) igraph_matrix_ncol(A);
    int p = (int) igraph_sparsemat_ncol(B);
    int r, c;
    CS_INT *Bp = B->cs->p;

    if (igraph_sparsemat_nrow(B) != n) {
        IGRAPH_ERROR("Invalid dimensions in dense-sparse matrix product",
                     IGRAPH_EINVAL);
    }

    if (!igraph_sparsemat_is_cc(B)) {
        IGRAPH_ERROR("Dense-sparse product is only implemented for "
                     "column-compressed sparse matrices", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, m, p));
    igraph_matrix_null(res);

    for (c = 0; c < p; c++) {
        for (r = 0; r < m; r++) {
            int idx = *Bp;
            while (idx < * (Bp + 1)) {
                MATRIX(*res, r, c) += MATRIX(*A, r, B->cs->i[idx]) * B->cs->x[idx];
                idx++;
            }
        }
        Bp++;
    }

    return 0;
}

/**
 * \function igraph_sparsemat_view
 * \brief Initialize a sparse matrix and set all parameters.
 *
 * This function can be used to temporarily handle existing sparse matrix data,
 * usually created by another software library, as an \c igraph_sparsemat_t object,
 * and thus avoid unnecessary copying. It supports data stored in either the
 * compressed sparse column format, or the (i, j, x) triplet format
 * where \c i and \c j are the matrix indices of a non-zero element, and \c x
 * is its value.
 *
 * 
 * The compressed sparse column (or row) format is commonly used to represent
 * sparse matrix data. It consists of three vectors, the \p p column pointers, the
 * \p i row indices, and the \p x values. p[k] is the number
 * of non-zero entires in matrix columns k-1 and lower.
 * p[0] is always zero and p[n] is always the total
 * number of non-zero entires in the matrix. i[l] is the row index
 * of the \c l-th stored element, while x[l] is its value.
 * If a matrix element with indices (j, k) is explicitly stored,
 * it must be located between positions p[k] and p[k+1] - 1
 * (inclusive) in the \p i and \p x vectors.
 *
 * 
 * Do not call \ref igraph_sparsemat_destroy() on a sparse matrix created with
 * this function. Instead, \ref igraph_free() must be called on the \c cs
 * field of \p A to free the storage allocated by this function.
 *
 * 
 * Warning: Matrices created with this function must not be used with functions
 * that may reallocate the underlying storage, such as \ref igraph_sparsemat_entry().
 *
 * \param A The non-initialized sparse matrix.
 * \param nzmax The maximum number of entries, typically the actual number of entries.
 * \param m The number of matrix rows.
 * \param n The number of matrix columns.
 * \param p For a compressed matrix, this is the column pointer vector, and
 *          must be of size n+1. For a triplet format matrix, it
 *          is a vector of column indices and must be of size \p nzmax.
 * \param i The row vector. This should contain the row indices of the
 *          elements in \p x. It must be of size \p nzmax.
 * \param x The values of the non-zero elements of the sparse matrix.
 *          It must be of size \p nzmax.
 * \param nz For a compressed matrix, is must be -1. For a triplet format
 *           matrix, is must contain the number of entries.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_view(igraph_sparsemat_t *A, int nzmax, int m, int n,
                          int *p, int *i, double *x, int nz) {

    A->cs = IGRAPH_CALLOC(1, cs_di);
    A->cs->nzmax = nzmax;
    A->cs->m = m;
    A->cs->n = n;
    A->cs->p = p;
    A->cs->i = i;
    A->cs->x = x;
    A->cs->nz = nz;

    return IGRAPH_SUCCESS;
}

int igraph_i_sparsemat_view(igraph_sparsemat_t *A, int nzmax, int m, int n,
                            int *p, int *i, double *x, int nz) {
    IGRAPH_WARNING("igraph_i_sparsemat_view() is deprecated, use igraph_sparsemat_view()");
    return igraph_sparsemat_view(A, nzmax, m, n, p, i, x, nz);
}

int igraph_sparsemat_sort(const igraph_sparsemat_t *A,
                          igraph_sparsemat_t *sorted) {

    igraph_sparsemat_t tmp;

    IGRAPH_CHECK(igraph_sparsemat_transpose(A, &tmp, /*values=*/ 1));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&tmp, sorted, /*values=*/ 1));
    igraph_sparsemat_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_sparsemat_getelements_sorted
 * \brief Returns the sorted elements of a sparse matrix.
 *
 * This function will sort a sparse matrix and return the elements in
 * 3 vectors. Two vectors will indicate where the elements are located,
 * and one will give the elements.
 *
 * \param A A sparse matrix in either triplet or compressed form.
 * \param i An initialized int vector. This will store the rows of the
 *          returned elements.
 * \param j An initialized int vector. For a triplet matrix this will
 *          store the columns of the returned elements. For a compressed
 *          matrix, if the column index is \c k, then j[k]
 *          is the index in \p x of the start of the \c k-th column, and
 *          the last element of \c j is the total number of elements.
 *          The total number of elements in the \c k-th column is
 *          therefore j[k+1] - j[k]. For example, if there
 *          is one element in the first column, and five in the second,
 *          \c j will be set to {0, 1, 6}.
 * \param x An initialized vector. The elements will be placed here.
 * \return Error code.
 *
 * Time complexity: O(n), the number of stored elements in the sparse matrix.
 */

int igraph_sparsemat_getelements_sorted(const igraph_sparsemat_t *A,
                                        igraph_vector_int_t *i,
                                        igraph_vector_int_t *j,
                                        igraph_vector_t *x) {
    if (A->cs->nz < 0) {
        igraph_sparsemat_t tmp;
        IGRAPH_CHECK(igraph_sparsemat_sort(A, &tmp));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
        IGRAPH_CHECK(igraph_sparsemat_getelements(&tmp, i, j, x));
        igraph_sparsemat_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        IGRAPH_CHECK(igraph_sparsemat_getelements(A, i, j, x));
    }

    return IGRAPH_SUCCESS;
}

int igraph_sparsemat_nzmax(const igraph_sparsemat_t *A) {
    return A->cs->nzmax;
}

int igraph_sparsemat_neg(igraph_sparsemat_t *A) {
    CS_INT i, nz = A->cs->nz == -1 ? A->cs->p[A->cs->n] : A->cs->nz;
    CS_ENTRY *px = A->cs->x;

    for (i = 0; i < nz; i++, px++) {
        *px = - (*px);
    }

    return 0;
}

/**
 * \function igraph_sparsemat_iterator_init
 * \brief Initialize a sparse matrix iterator.
 *
 * \param it A pointer to an uninitialized sparse matrix iterator.
 * \param sparsemat Pointer to the sparse matrix.
 * \return Error code. This will always return \c IGRAPH_SUCCESS
 *
 * Time complexity: O(n), the number of columns of the sparse matrix.
 */

int igraph_sparsemat_iterator_init(igraph_sparsemat_iterator_t *it,
                                   igraph_sparsemat_t *sparsemat) {

    it->mat = sparsemat;
    igraph_sparsemat_iterator_reset(it);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_iterator_reset
 * \brief Reset a sparse matrix iterator to the first element.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return Error code. This will always return \c IGRAPH_SUCCESS
 *
 * Time complexity: O(n), the number of columns of the sparse matrix.
 */

int igraph_sparsemat_iterator_reset(igraph_sparsemat_iterator_t *it) {
    it->pos = 0;
    it->col = 0;
    if (!igraph_sparsemat_is_triplet(it->mat)) {
        while (it->col < it->mat->cs->n &&
               it->mat->cs->p[it->col + 1] == it->pos) {
            it->col ++;
        }
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_sparsemat_iterator_end
 * \brief Query if the iterator is past the last element.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return true if the iterator is past the last element, false if it
 *         points to an element in a sparse matrix.
 *
 * Time complexity: O(1).
 */

igraph_bool_t
igraph_sparsemat_iterator_end(const igraph_sparsemat_iterator_t *it) {
    CS_INT nz = it->mat->cs->nz == -1 ? it->mat->cs->p[it->mat->cs->n] :
                it->mat->cs->nz;
    return it->pos >= nz;
}

/**
 * \function igraph_sparsemat_iterator_row
 * \brief Return the row of the iterator.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return The row of the element at the current iterator position.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_iterator_row(const igraph_sparsemat_iterator_t *it) {
    return it->mat->cs->i[it->pos];
}

/**
 * \function igraph_sparsemat_iterator_col
 * \brief Return the column of the iterator.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return The column of the element at the current iterator position.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_iterator_col(const igraph_sparsemat_iterator_t *it) {
    if (igraph_sparsemat_is_triplet(it->mat)) {
        return it->mat->cs->p[it->pos];
    } else {
        return it->col;
    }
}

/**
 * \function igraph_sparsemat_iterator_get
 * \brief Return the element at the current iterator position.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return The value of the element at the current iterator position.
 *
 * Time complexity: O(1).
 */

igraph_real_t
igraph_sparsemat_iterator_get(const igraph_sparsemat_iterator_t *it) {
    return it->mat->cs->x[it->pos];
}

/**
 * \function igraph_sparsemat_iterator_next
 * \brief Let a sparse matrix iterator go to the next element.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return The position of the iterator in the element vector.
 *
 * Time complexity: O(n), the number of columns of the sparse matrix.
 */

int igraph_sparsemat_iterator_next(igraph_sparsemat_iterator_t *it) {
    it->pos += 1;
    while (it->col < it->mat->cs->n &&
           it->mat->cs->p[it->col + 1] == it->pos) {
        it->col++;
    }
    return it->pos;
}

/**
 * \function igraph_sparsemat_iterator_idx
 * \brief Returns the element vector index of a sparse matrix iterator.
 *
 * \param it A pointer to the sparse matrix iterator.
 * \return The position of the iterator in the element vector.
 *
 * Time complexity: O(1).
 */

int igraph_sparsemat_iterator_idx(const igraph_sparsemat_iterator_t *it) {
    return it->pos;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/spmatrix.c0000644000175100001710000010053200000000000023405 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_spmatrix.h"
#include "igraph_error.h"

#include      /* memcpy & co. */

/**
 * \section igraph_spmatrix_constructor_and_destructor Sparse matrix constructors
 * and destructors.
 */

/**
 * \ingroup matrix
 * \function igraph_spmatrix_init
 * \brief Initializes a sparse matrix.
 *
 * 
 * Every sparse matrix needs to be initialized before using it, this is done
 * by calling this function. A matrix has to be destroyed if it is not
 * needed any more, see \ref igraph_spmatrix_destroy().
 * \param m Pointer to a not yet initialized sparse matrix object to be
 *        initialized.
 * \param nrow The number of rows in the matrix.
 * \param ncol The number of columns in the matrix.
 * \return Error code.
 *
 * Time complexity: operating system dependent.
 */

int igraph_spmatrix_init(igraph_spmatrix_t *m, long int nrow, long int ncol) {
    IGRAPH_ASSERT(m != NULL);
    IGRAPH_VECTOR_INIT_FINALLY(&m->ridx, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&m->cidx, ncol + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&m->data, 0);
    IGRAPH_FINALLY_CLEAN(3);
    m->nrow = nrow;
    m->ncol = ncol;
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_destroy
 * \brief Destroys a sparse matrix object.
 *
 * 
 * This function frees all the memory allocated for a sparse matrix
 * object. The destroyed object needs to be reinitialized before using
 * it again.
 * \param m The matrix to destroy.
 *
 * Time complexity: operating system dependent.
 */

void igraph_spmatrix_destroy(igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    igraph_vector_destroy(&m->ridx);
    igraph_vector_destroy(&m->cidx);
    igraph_vector_destroy(&m->data);
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_copy
 * \brief Copies a sparse matrix.
 *
 * 
 * Creates a sparse matrix object by copying another one.
 * \param to Pointer to an uninitialized sparse matrix object.
 * \param from The initialized sparse matrix object to copy.
 * \return Error code, \c IGRAPH_ENOMEM if there
 *   isn't enough memory to allocate the new sparse matrix.
 *
 * Time complexity: O(n), the number
 * of elements in the matrix.
 */

int igraph_spmatrix_copy(igraph_spmatrix_t *to, const igraph_spmatrix_t *from) {
    IGRAPH_ASSERT(from != NULL);
    IGRAPH_ASSERT(to != NULL);
    to->nrow = from->nrow;
    to->ncol = from->ncol;
    IGRAPH_CHECK(igraph_vector_copy(&to->ridx, &from->ridx));
    IGRAPH_CHECK(igraph_vector_copy(&to->cidx, &from->cidx));
    IGRAPH_CHECK(igraph_vector_copy(&to->data, &from->data));
    return 0;
}

/**
 * \section igraph_spmatrix_accessing_elements Accessing elements of a sparse matrix
 */

/**
 * \ingroup matrix
 * \function igraph_spmatrix_e
 * \brief Accessing an element of a sparse matrix.
 *
 * Note that there are no range checks right now.
 * \param m The matrix object.
 * \param row The index of the row, starting with zero.
 * \param col The index of the column, starting with zero.
 *
 * Time complexity: O(log n), where n is the number of nonzero elements in
 * the requested column.
 */
igraph_real_t igraph_spmatrix_e(const igraph_spmatrix_t *m,
                                long int row, long int col) {
    long int start, end;

    IGRAPH_ASSERT(m != NULL);
    start = (long) VECTOR(m->cidx)[col];
    end = (long) VECTOR(m->cidx)[col + 1] - 1;

    if (end < start) {
        return 0;
    }
    /* Elements residing in column col are between m->data[start] and
     * m->data[end], inclusive, ordered by row index */
    while (start < end - 1) {
        long int mid = (start + end) / 2;
        if (VECTOR(m->ridx)[mid] > row) {
            end = mid;
        } else if (VECTOR(m->ridx)[mid] < row) {
            start = mid;
        } else {
            start = mid;
            break;
        }
    }

    if (VECTOR(m->ridx)[start] == row) {
        return VECTOR(m->data)[start];
    }
    if (VECTOR(m->ridx)[start] != row && VECTOR(m->ridx)[end] == row) {
        return VECTOR(m->data)[end];
    }
    return 0;
}


/**
 * \ingroup matrix
 * \function igraph_spmatrix_set
 * \brief Setting an element of a sparse matrix.
 *
 * Note that there are no range checks right now.
 * \param m The matrix object.
 * \param row The index of the row, starting with zero.
 * \param col The index of the column, starting with zero.
 * \param value The new value.
 *
 * Time complexity: O(log n), where n is the number of nonzero elements in
 * the requested column.
 */
int igraph_spmatrix_set(igraph_spmatrix_t *m, long int row, long int col,
                        igraph_real_t value) {
    long int start, end;

    IGRAPH_ASSERT(m != NULL);
    start = (long) VECTOR(m->cidx)[col];
    end = (long) VECTOR(m->cidx)[col + 1] - 1;

    if (end < start) {
        /* First element in the column */
        if (value == 0.0) {
            return 0;
        }
        IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start, row));
        IGRAPH_CHECK(igraph_vector_insert(&m->data, start, value));
        for (start = col + 1; start < m->ncol + 1; start++) {
            VECTOR(m->cidx)[start]++;
        }
        return 0;
    }

    /* Elements residing in column col are between m->data[start] and
     * m->data[end], inclusive, ordered by row index */
    while (start < end - 1) {
        long int mid = (start + end) / 2;
        if (VECTOR(m->ridx)[mid] > row) {
            end = mid;
        } else if (VECTOR(m->ridx)[mid] < row) {
            start = mid;
        } else {
            start = mid;
            break;
        }
    }

    if (VECTOR(m->ridx)[start] == row) {
        /* Overwriting a value - or deleting it if it has been overwritten by zero */
        if (value == 0) {
            igraph_vector_remove(&m->ridx, start);
            igraph_vector_remove(&m->data, start);
            for (start = col + 1; start < m->ncol + 1; start++) {
                VECTOR(m->cidx)[start]--;
            }
        } else {
            VECTOR(m->data)[start] = value;
        }
        return 0;
    } else if (VECTOR(m->ridx)[end] == row) {
        /* Overwriting a value - or deleting it if it has been overwritten by zero */
        if (value == 0) {
            igraph_vector_remove(&m->ridx, end);
            igraph_vector_remove(&m->data, end);
            for (start = col + 1; start < m->ncol + 1; start++) {
                VECTOR(m->cidx)[start]--;
            }
        } else {
            VECTOR(m->data)[end] = value;
        }
        return 0;
    }

    /* New element has to be inserted, but only if not a zero is
     * being written into the matrix */
    if (value != 0.0) {
        if (VECTOR(m->ridx)[end] < row) {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, end + 1, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, end + 1, value));
        } else if (VECTOR(m->ridx)[start] < row) {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start + 1, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, start + 1, value));
        } else {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, start, value));
        }
        for (start = col + 1; start < m->ncol + 1; start++) {
            VECTOR(m->cidx)[start]++;
        }
    }
    return 0;
}


/**
 * \ingroup matrix
 * \function igraph_spmatrix_add_e
 * \brief Adding a real value to an element of a sparse matrix.
 *
 * Note that there are no range checks right now. This is implemented to avoid
 * double lookup of a given element in the matrix by using \ref igraph_spmatrix_e()
 * and \ref igraph_spmatrix_set() consecutively.
 *
 * \param m The matrix object.
 * \param row The index of the row, starting with zero.
 * \param col The index of the column, starting with zero.
 * \param value The value to add.
 *
 * Time complexity: O(log n), where n is the number of nonzero elements in
 * the requested column.
 */
int igraph_spmatrix_add_e(igraph_spmatrix_t *m, long int row, long int col,
                          igraph_real_t value) {
    long int start, end;

    IGRAPH_ASSERT(m != NULL);
    start = (long) VECTOR(m->cidx)[col];
    end = (long) VECTOR(m->cidx)[col + 1] - 1;

    if (end < start) {
        /* First element in the column */
        if (value == 0.0) {
            return 0;
        }
        IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start, row));
        IGRAPH_CHECK(igraph_vector_insert(&m->data, start, value));
        for (start = col + 1; start < m->ncol + 1; start++) {
            VECTOR(m->cidx)[start]++;
        }
        return 0;
    }

    /* Elements residing in column col are between m->data[start] and
     * m->data[end], inclusive, ordered by row index */
    while (start < end - 1) {
        long int mid = (start + end) / 2;
        if (VECTOR(m->ridx)[mid] > row) {
            end = mid;
        } else if (VECTOR(m->ridx)[mid] < row) {
            start = mid;
        } else {
            start = mid;
            break;
        }
    }

    if (VECTOR(m->ridx)[start] == row) {
        /* Overwriting a value */
        if (VECTOR(m->data)[start] == -1) {
            igraph_vector_remove(&m->ridx, start);
            igraph_vector_remove(&m->data, start);
            for (start = col + 1; start < m->ncol + 1; start++) {
                VECTOR(m->cidx)[start]--;
            }
        } else {
            VECTOR(m->data)[start] += value;
        }
        return 0;
    } else if (VECTOR(m->ridx)[end] == row) {
        /* Overwriting a value */
        if (VECTOR(m->data)[end] == -1) {
            igraph_vector_remove(&m->ridx, end);
            igraph_vector_remove(&m->data, end);
            for (start = col + 1; start < m->ncol + 1; start++) {
                VECTOR(m->cidx)[start]--;
            }
        } else {
            VECTOR(m->data)[end] += value;
        }
        return 0;
    }

    /* New element has to be inserted, but only if not a zero is
     * being added to a zero element of the matrix */
    if (value != 0.0) {
        if (VECTOR(m->ridx)[end] < row) {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, end + 1, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, end + 1, value));
        } else if (VECTOR(m->ridx)[start] < row) {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start + 1, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, start + 1, value));
        } else {
            IGRAPH_CHECK(igraph_vector_insert(&m->ridx, start, row));
            IGRAPH_CHECK(igraph_vector_insert(&m->data, start, value));
        }
        for (start = col + 1; start < m->ncol + 1; start++) {
            VECTOR(m->cidx)[start]++;
        }
    }
    return 0;
}

/**
 * \function igraph_spmatrix_add_col_values
 * \brief Adds the values of a column to another column.
 *
 * \param to The index of the column to be added to.
 * \param from The index of the column to be added.
 * \return Error code.
 */
int igraph_spmatrix_add_col_values(igraph_spmatrix_t *m, long int to, long int from) {
    long int i;
    if (to < 0 || to >= m->ncol) {
       IGRAPH_ERROR("The 'to' column does not exist.", IGRAPH_EINVAL);
    }
    if (from < 0 || from >= m->ncol) {
       IGRAPH_ERROR("The 'from' column does not exist.", IGRAPH_EINVAL);
    }
    /* TODO: I think this implementation could be speeded up if I don't use
     * igraph_spmatrix_add_e directly -- but maybe it's not worth the fuss */
    for (i = (long int) VECTOR(m->cidx)[from]; i < VECTOR(m->cidx)[from + 1]; i++) {
        IGRAPH_CHECK(igraph_spmatrix_add_e(m, (long int) VECTOR(m->ridx)[i],
                                           to, VECTOR(m->data)[i]));
    }

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup matrix
 * \function igraph_spmatrix_resize
 * \brief Resizes a sparse matrix.
 *
 * 
 * This function resizes a sparse matrix by adding more elements to it.
 * The matrix retains its data even after resizing it, except for the data
 * which lies outside the new boundaries (if the new size is smaller).
 * \param m Pointer to an already initialized sparse matrix object.
 * \param nrow The number of rows in the resized matrix.
 * \param ncol The number of columns in the resized matrix.
 * \return Error code.
 *
 * Time complexity: O(n).
 * n is the number of elements in the old matrix.
 */

int igraph_spmatrix_resize(igraph_spmatrix_t *m, long int nrow, long int ncol) {
    long int i, j, ci, ei, mincol;
    IGRAPH_ASSERT(m != NULL);
    /* Iterating through the matrix data and deleting unnecessary data. */
    /* At the same time, we create the new indices as well */
    if (nrow < m->nrow) {
        ei = j = 0;
        mincol = (m->ncol < ncol) ? m->ncol : ncol;
        for (ci = 0; ci < mincol; ci++) {
            for (; ei < VECTOR(m->cidx)[ci + 1]; ei++) {
                if (VECTOR(m->ridx)[ei] < nrow) {
                    VECTOR(m->ridx)[j] = VECTOR(m->ridx)[ei];
                    VECTOR(m->data)[j] = VECTOR(m->data)[ei];
                    j++;
                }
            }
            VECTOR(m->cidx)[ci] = j;
        }
        /* Contract the row index and the data vector */
        IGRAPH_CHECK(igraph_vector_resize(&m->ridx, j));
        IGRAPH_CHECK(igraph_vector_resize(&m->cidx, j));
    }
    /* Updating cidx */
    IGRAPH_CHECK(igraph_vector_resize(&m->cidx, ncol + 1));
    for (i = m->ncol + 1; i < ncol + 1; i++) {
        VECTOR(m->cidx)[i] = VECTOR(m->cidx)[m->ncol];
    }
    m->nrow = nrow;
    m->ncol = ncol;
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_count_nonzero
 * \brief The number of non-zero elements in a sparse matrix.
 *
 * \param m Pointer to an initialized sparse matrix object.
 * \return The size of the matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_spmatrix_count_nonzero(const igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    return igraph_vector_size(&m->data);
}


/**
 * \ingroup matrix
 * \function igraph_spmatrix_size
 * \brief The number of elements in a sparse matrix.
 *
 * \param m Pointer to an initialized sparse matrix object.
 * \return The size of the matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_spmatrix_size(const igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    return (m->nrow) * (m->ncol);
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_nrow
 * \brief The number of rows in a sparse matrix.
 *
 * \param m Pointer to an initialized sparse matrix object.
 * \return The number of rows in the matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_spmatrix_nrow(const igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    return m->nrow;
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_ncol
 * \brief The number of columns in a sparse matrix.
 *
 * \param m Pointer to an initialized sparse matrix object.
 * \return The number of columns in the sparse matrix.
 *
 * Time complexity: O(1).
 */

long int igraph_spmatrix_ncol(const igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    return m->ncol;
}

/**
 * \ingroup matrix
 * \brief Copies a sparse matrix to a regular C array.
 *
 * 
 * The matrix is copied columnwise, as this is the format most
 * programs and languages use.
 * The C array should be of sufficient size, there are (of course) no
 * range checks done.
 * \param m Pointer to an initialized sparse matrix object.
 * \param to Pointer to a C array, the place to copy the data to.
 * \return Error code.
 *
 * Time complexity: O(n),
 * n is the number of
 * elements in the matrix.
 */

int igraph_spmatrix_copy_to(const igraph_spmatrix_t *m, igraph_real_t *to) {
    long int c, dest_idx, idx;

    memset(to, 0, sizeof(igraph_real_t) * (size_t) igraph_spmatrix_size(m));
    for (c = 0, dest_idx = 0; c < m->ncol; c++, dest_idx += m->nrow) {
        for (idx = (long int) VECTOR(m->cidx)[c]; idx < VECTOR(m->cidx)[c + 1]; idx++) {
            to[dest_idx + (long)VECTOR(m->ridx)[idx]] = VECTOR(m->data)[idx];
        }
    }
    return 0;
}

/**
 * \ingroup matrix
 * \brief Sets all element in a sparse matrix to zero.
 *
 * \param m Pointer to an initialized matrix object.
 * \return Error code, always returns with success.
 *
 * Time complexity: O(n),
 * n is the number of columns in the matrix
 */

int igraph_spmatrix_null(igraph_spmatrix_t *m) {
    IGRAPH_ASSERT(m != NULL);
    igraph_vector_clear(&m->data);
    igraph_vector_clear(&m->ridx);
    igraph_vector_null(&m->cidx);
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_add_cols
 * \brief Adds columns to a sparse matrix.
 * \param m The sparse matrix object.
 * \param n The number of columns to add.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_spmatrix_add_cols(igraph_spmatrix_t *m, long int n) {
    igraph_spmatrix_resize(m, m->nrow, m->ncol + n);
    return 0;
}

/**
 * \ingroup matrix
 * \function igraph_spmatrix_add_rows
 * \brief Adds rows to a sparse matrix.
 * \param m The sparse matrix object.
 * \param n The number of rows to add.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_spmatrix_add_rows(igraph_spmatrix_t *m, long int n) {
    igraph_spmatrix_resize(m, m->nrow + n, m->ncol);
    return 0;
}

/**
 * \function igraph_spmatrix_clear_row
 * \brief Clears a row in the matrix (sets all of its elements to zero).
 * \param m The matrix.
 * \param row The index of the row to be cleared.
 * \return Error code.
 *
 * Time complexity: O(n), the number of nonzero elements in the matrix.
 */

int igraph_spmatrix_clear_row(igraph_spmatrix_t *m, long int row) {
    if (row < 0 || row >= m->nrow) {
       IGRAPH_ERROR("The row does not exist.", IGRAPH_EINVAL);
    }
    long int ci, ei, i, j, nremove = 0, nremove_old = 0;
    igraph_vector_t permvec;

    IGRAPH_ASSERT(m != NULL);
    IGRAPH_VECTOR_INIT_FINALLY(&permvec, igraph_vector_size(&m->data));
    for (ci = 0, i = 0, j = 1; ci < m->ncol; ci++) {
        for (ei = (long int) VECTOR(m->cidx)[ci]; ei < VECTOR(m->cidx)[ci + 1]; ei++) {
            if (VECTOR(m->ridx)[ei] == row) {
                /* this element will be deleted, so all elements in cidx from the
                 * column index of this element will have to be decreased by one */
                nremove++;
            } else {
                /* this element will be kept */
                VECTOR(permvec)[i] = j;
                j++;
            }
            i++;
        }
        if (ci > 0) {
            VECTOR(m->cidx)[ci] -= nremove_old;
        }
        nremove_old = nremove;
    }
    VECTOR(m->cidx)[m->ncol] -= nremove;
    igraph_vector_permdelete(&m->ridx, &permvec, nremove);
    igraph_vector_permdelete(&m->data, &permvec, nremove);
    igraph_vector_destroy(&permvec);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/* Unused local functions---temporarily disabled */
#if 0
static int igraph_i_spmatrix_clear_row_fast(igraph_spmatrix_t *m, long int row) {
    long int ei, n;

    IGRAPH_ASSERT(m != NULL);
    n = igraph_vector_size(&m->data);
    for (ei = 0; ei < n; ei++) {
        if (VECTOR(m->ridx)[ei] == row) {
            VECTOR(m->data)[ei] = 0.0;
        }
    }
    return 0;
}

static int igraph_i_spmatrix_cleanup(igraph_spmatrix_t *m) {
    long int ci, ei, i, j, nremove = 0, nremove_old = 0;
    igraph_vector_t permvec;

    IGRAPH_ASSERT(m != NULL);
    IGRAPH_VECTOR_INIT_FINALLY(&permvec, igraph_vector_size(&m->data));
    for (ci = 0, i = 0, j = 1; ci < m->ncol; ci++) {
        for (ei = (long int) VECTOR(m->cidx)[ci]; ei < VECTOR(m->cidx)[ci + 1]; ei++) {
            if (VECTOR(m->data)[ei] == 0.0) {
                /* this element will be deleted, so all elements in cidx from the
                 * column index of this element will have to be decreased by one */
                nremove++;
            } else {
                /* this element will be kept */
                VECTOR(permvec)[i] = j;
                j++;
            }
            i++;
        }
        if (ci > 0) {
            VECTOR(m->cidx)[ci] -= nremove_old;
        }
        nremove_old = nremove;
    }
    VECTOR(m->cidx)[m->ncol] -= nremove;
    igraph_vector_permdelete(&m->ridx, &permvec, nremove);
    igraph_vector_permdelete(&m->data, &permvec, nremove);
    igraph_vector_destroy(&permvec);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
#endif

/**
 * \function igraph_spmatrix_clear_col
 * \brief Clears a column in the matrix (sets all of its elements to zero).
 * \param m The matrix.
 * \param col The index of the column to be cleared.
 * \return Error code.
 *
 * Time complexity: TODO
 */

int igraph_spmatrix_clear_col(igraph_spmatrix_t *m, long int col) {
    if (col < 0 || col >= m->ncol) {
       IGRAPH_ERROR("The column does not exist.", IGRAPH_EINVAL);
    }
    long int i, n;
    IGRAPH_ASSERT(m != NULL);
    n = (long)VECTOR(m->cidx)[col + 1] - (long)VECTOR(m->cidx)[col];
    if (n == 0) {
        return 0;
    }
    igraph_vector_remove_section(&m->ridx, (long int) VECTOR(m->cidx)[col],
                                 (long int) VECTOR(m->cidx)[col + 1]);
    igraph_vector_remove_section(&m->data, (long int) VECTOR(m->cidx)[col],
                                 (long int) VECTOR(m->cidx)[col + 1]);
    for (i = col + 1; i <= m->ncol; i++) {
        VECTOR(m->cidx)[i] -= n;
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_spmatrix_scale
 * \brief Multiplies each element of the sparse matrix by a constant.
 * \param m The matrix.
 * \param by The constant.
 *
 * Time complexity: O(n), the number of elements in the matrix.
 */

void igraph_spmatrix_scale(igraph_spmatrix_t *m, igraph_real_t by) {
    IGRAPH_ASSERT(m != NULL);
    igraph_vector_scale(&m->data, by);
}

/**
 * \function igraph_spmatrix_colsums
 * \brief Calculates the column sums of the matrix.
 * \param m The matrix.
 * \param res An initialized \c igraph_vector_t, the result will be stored here.
 *   The vector will be resized as needed.
 *
 * Time complexity: O(n), the number of nonzero elements in the matrix.
 */

int igraph_spmatrix_colsums(const igraph_spmatrix_t *m, igraph_vector_t *res) {
    long int i, c;
    IGRAPH_ASSERT(m != NULL);
    IGRAPH_CHECK(igraph_vector_resize(res, m->ncol));
    igraph_vector_null(res);
    for (c = 0; c < m->ncol; c++) {
        for (i = (long int) VECTOR(m->cidx)[c]; i < VECTOR(m->cidx)[c + 1]; i++) {
            VECTOR(*res)[c] += VECTOR(m->data)[i];
        }
    }
    return 0;
}

/**
 * \function igraph_spmatrix_rowsums
 * \brief Calculates the row sums of the matrix.
 * \param m The matrix.
 * \param res An initialized \c igraph_vector_t, the result will be stored here.
 *   The vector will be resized as needed.
 *
 * Time complexity: O(n), the number of nonzero elements in the matrix.
 */

int igraph_spmatrix_rowsums(const igraph_spmatrix_t *m, igraph_vector_t *res) {
    long int i, n;
    IGRAPH_ASSERT(m != NULL);

    IGRAPH_CHECK(igraph_vector_resize(res, m->nrow));
    n = igraph_vector_size(&m->data);
    igraph_vector_null(res);
    for (i = 0; i < n; i++) {
        VECTOR(*res)[(long int)VECTOR(m->ridx)[i]] += VECTOR(m->data)[i];
    }
    return 0;
}

/**
 * \function igraph_spmatrix_max_nonzero
 * \brief Returns the maximum nonzero element of a matrix.
 * If the matrix is empty, zero is returned.
 *
 * \param m the matrix object.
 * \param ridx the row index of the maximum element if not \c NULL.
 * \param cidx the column index of the maximum element if not \c NULL.
 *
 * Time complexity: O(n), the number of nonzero elements in the matrix.
 */
igraph_real_t igraph_spmatrix_max_nonzero(const igraph_spmatrix_t *m,
        igraph_real_t *ridx, igraph_real_t *cidx) {
    igraph_real_t res;
    long int i, n, maxidx;

    IGRAPH_ASSERT(m != NULL);
    n = igraph_vector_size(&m->data);
    if (n == 0) {
        return 0.0;
    }

    maxidx = -1;
    for (i = 0; i < n; i++)
        if (VECTOR(m->data)[i] != 0.0 &&
            (maxidx == -1 || VECTOR(m->data)[i] >= VECTOR(m->data)[maxidx])) {
            maxidx = i;
        }

    if (maxidx == -1) {
        return 0.0;
    }

    res = VECTOR(m->data)[maxidx];
    if (ridx != 0) {
        *ridx = VECTOR(m->ridx)[maxidx];
    }
    if (cidx != 0) {
        igraph_vector_binsearch(&m->cidx, maxidx, &i);
        while (VECTOR(m->cidx)[i + 1] == VECTOR(m->cidx)[i]) {
            i++;
        }
        *cidx = (igraph_real_t)i;
    }
    return res;
}

/**
 * \function igraph_spmatrix_max
 * \brief Returns the maximum element of a matrix.
 * If the matrix is empty, zero is returned.
 *
 * \param m the matrix object.
 * \param ridx the row index of the maximum element if not \c NULL.
 * \param cidx the column index of the maximum element if not \c NULL.
 *
 * Time complexity: O(n), the number of nonzero elements in the matrix.
 */
igraph_real_t igraph_spmatrix_max(const igraph_spmatrix_t *m,
                                  igraph_real_t *ridx, igraph_real_t *cidx) {
    igraph_real_t res;
    long int i, j, k, maxidx;

    IGRAPH_ASSERT(m != NULL);
    i = igraph_vector_size(&m->data);
    if (i == 0) {
        return 0.0;
    }

    maxidx = (long)igraph_vector_which_max(&m->data);
    res = VECTOR(m->data)[maxidx];
    if (res >= 0.0 || i == m->nrow * m->ncol) {
        if (ridx != 0) {
            *ridx = VECTOR(m->ridx)[maxidx];
        }
        if (cidx != 0) {
            igraph_vector_binsearch(&m->cidx, maxidx, &i);
            i--;
            while (i < m->ncol - 1 && VECTOR(m->cidx)[i + 1] == VECTOR(m->cidx)[i]) {
                i++;
            }
            *cidx = (igraph_real_t)i;
        }
        return res;
    }
    /* the maximal nonzero element is negative and there is at least a
     * single zero
     */
    res = 0.0;
    if (cidx != 0 || ridx != 0) {
        for (i = 0; i < m->ncol; i++) {
            if (VECTOR(m->cidx)[i + 1] - VECTOR(m->cidx)[i] < m->nrow) {
                if (cidx != 0) {
                    *cidx = i;
                }
                if (ridx != 0) {
                    for (j = (long int) VECTOR(m->cidx)[i], k = 0;
                         j < VECTOR(m->cidx)[i + 1]; j++, k++) {
                        if (VECTOR(m->ridx)[j] != k) {
                            *ridx = k;
                            break;
                        }
                    }
                }
                break;
            }
        }
    }

    return res;
}


/* Unused function, temporarily disabled */
/*
static int igraph_i_spmatrix_get_col_nonzero_indices(const igraph_spmatrix_t *m,
                                                     igraph_vector_t *res, long int col) {
    long int i, n;
    IGRAPH_ASSERT(m != NULL);
    n = (long int) (VECTOR(m->cidx)[col + 1] - VECTOR(m->cidx)[col]);
    IGRAPH_CHECK(igraph_vector_resize(res, n));
    for (i = (long int) VECTOR(m->cidx)[col], n = 0;
         i < VECTOR(m->cidx)[col + 1]; i++, n++)
        if (VECTOR(m->data)[i] != 0.0) {
            VECTOR(*res)[n] = VECTOR(m->ridx)[i];
        }
    return 0;
}
*/


/**
 * \section igraph_spmatrix_iterating Iterating over the non-zero elements of a sparse matrix
 *
 * The \type igraph_spmatrix_iter_t type represents an iterator that can
 * be used to step over the non-zero elements of a sparse matrix in columnwise
 * order efficiently. In general, you shouldn't modify the elements of the matrix
 * while iterating over it; doing so will probably invalidate the iterator, but
 * there are no checks to prevent you from doing this.
 *
 * To access the row index of the current element of the iterator, use its
 * \c ri field. Similarly, the \c ci field stores the column index of the current
 * element and the \c value field stores the value of the element.
 */

/**
 * \function igraph_spmatrix_iter_create
 * \brief Creates a sparse matrix iterator corresponding to the given matrix.
 *
 * \param  mit  pointer to the matrix iterator being initialized
 * \param  m    pointer to the matrix we will be iterating over
 * \return  Error code. The current implementation is always successful.
 *
 * Time complexity: O(1).
 */
int igraph_spmatrix_iter_create(igraph_spmatrix_iter_t *mit, const igraph_spmatrix_t *m) {
    mit->m = m;
    IGRAPH_CHECK(igraph_spmatrix_iter_reset(mit));
    return 0;
}

/**
 * \function igraph_spmatrix_iter_reset
 * \brief Resets a sparse matrix iterator.
 *
 * 
 * After resetting, the iterator will point to the first nonzero element (if any).
 *
 * \param  mit  pointer to the matrix iterator being reset
 * \return  Error code. The current implementation is always successful.
 *
 * Time complexity: O(1).
 */
int igraph_spmatrix_iter_reset(igraph_spmatrix_iter_t *mit) {
    IGRAPH_ASSERT(mit->m);

    if (igraph_spmatrix_count_nonzero(mit->m) == 0) {
        mit->pos = mit->ri = mit->ci = -1L;
        mit->value = -1;
        return 0;
    }

    mit->ci = 0;
    mit->pos = -1;

    IGRAPH_CHECK(igraph_spmatrix_iter_next(mit));

    return 0;
}

/**
 * \function igraph_spmatrix_iter_next
 * \brief Moves a sparse matrix iterator to the next nonzero element.
 *
 * 
 * You should call this function only if \ref igraph_spmatrix_iter_end()
 * returns FALSE (0).
 *
 * \param  mit  pointer to the matrix iterator being moved
 * \return  Error code. The current implementation is always successful.
 *
 * Time complexity: O(1).
 */
int igraph_spmatrix_iter_next(igraph_spmatrix_iter_t *mit) {
    mit->pos++;

    if (igraph_spmatrix_iter_end(mit)) {
        return 0;
    }

    mit->ri = (long int)VECTOR(mit->m->ridx)[mit->pos];
    mit->value = VECTOR(mit->m->data)[mit->pos];

    while (VECTOR(mit->m->cidx)[mit->ci + 1] <= mit->pos) {
        mit->ci++;
    }

    return 0;
}

/**
 * \function igraph_spmatrix_iter_end
 * \brief Checks whether there are more elements in the iterator.
 *
 * 
 * You should call this function before calling \ref igraph_spmatrix_iter_next()
 * to make sure you have more elements in the iterator.
 *
 * \param  mit  pointer to the matrix iterator being checked
 * \return   TRUE (1) if there are more elements in the iterator,
 *           FALSE (0) otherwise.
 *
 * Time complexity: O(1).
 */
igraph_bool_t igraph_spmatrix_iter_end(igraph_spmatrix_iter_t *mit) {
    return mit->pos >= igraph_spmatrix_count_nonzero(mit->m);
}

/**
 * \function igraph_spmatrix_iter_destroy
 * \brief Frees the memory used by the iterator.
 *
 * 
 * The current implementation does not allocate any memory upon
 * creation, so this function does nothing. However, since there is
 * no guarantee that future implementations will not allocate any
 * memory in \ref igraph_spmatrix_iter_create(), you are still
 * required to call this function whenever you are done with the
 * iterator.
 *
 * \param  mit  pointer to the matrix iterator being destroyed
 *
 * Time complexity: O(1).
 */
void igraph_spmatrix_iter_destroy(igraph_spmatrix_iter_t *mit) {
    IGRAPH_UNUSED(mit);
    /* Nothing to do at the moment */
}

#ifndef USING_R
/**
 * \function igraph_spmatrix_print
 * \brief Prints a sparse matrix.
 *
 * Prints a sparse matrix to the standard output. Only the non-zero entries
 * are printed.
 *
 * \return Error code.
 *
 * Time complexity: O(n), the number of non-zero elements.
 */
int igraph_spmatrix_print(const igraph_spmatrix_t* matrix) {
    return igraph_spmatrix_fprint(matrix, stdout);
}
#endif

/**
 * \function igraph_spmatrix_fprint
 * \brief Prints a sparse matrix to the given file.
 *
 * Prints a sparse matrix to the given file. Only the non-zero entries
 * are printed.
 *
 * \return Error code.
 *
 * Time complexity: O(n), the number of non-zero elements.
 */
int igraph_spmatrix_fprint(const igraph_spmatrix_t* matrix, FILE *file) {
    igraph_spmatrix_iter_t mit;

    IGRAPH_CHECK(igraph_spmatrix_iter_create(&mit, matrix));
    IGRAPH_FINALLY(igraph_spmatrix_iter_destroy, &mit);
    while (!igraph_spmatrix_iter_end(&mit)) {
        fprintf(file, "[%ld, %ld] = %.4f\n", (long int)mit.ri,
                (long int)mit.ci, mit.value);
        igraph_spmatrix_iter_next(&mit);
    }
    igraph_spmatrix_iter_destroy(&mit);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/stack.c0000644000175100001710000000425400000000000022647 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_types.h"
#include "igraph_stack.h"

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_LONG
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_INT
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_CHAR
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_PTR
#include "igraph_pmt.h"
#include "stack.pmt"
#include "igraph_pmt_off.h"
#undef BASE_PTR

/**
 * \ingroup stack
 * \brief Calls free() on all elements of a pointer stack.
 */

void igraph_stack_ptr_free_all(igraph_stack_ptr_t* v) {
    void **ptr;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->stor_begin != 0);
    for (ptr = v->stor_begin; ptr < v->end; ptr++) {
        IGRAPH_FREE(*ptr);
    }
}

/**
 * \ingroup stack
 * \brief Calls free() on all elements and destroys the stack.
 */

void igraph_stack_ptr_destroy_all(igraph_stack_ptr_t* v) {
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->stor_begin != 0);
    igraph_stack_ptr_free_all(v);
    igraph_stack_ptr_destroy(v);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/stack.pmt0000644000175100001710000001666200000000000023233 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include          /* memcpy & co. */
#include 

/**
 * \ingroup stack
 * \function igraph_stack_init
 * \brief Initializes a stack.
 *
 * The initialized stack is always empty.
 * \param s Pointer to an uninitialized stack.
 * \param size The number of elements to allocate memory for.
 * \return Error code.
 *
 * Time complexity: O(\p size).
 */

int FUNCTION(igraph_stack, init)       (TYPE(igraph_stack)* s, long int size) {
    long int alloc_size;
    IGRAPH_ASSERT(s != NULL);
    if (size < 0) {
        size = 0;
    }
    alloc_size = size > 0 ? size : 1;
    s->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
    if (s->stor_begin == 0) {
        IGRAPH_ERROR("stack init failed", IGRAPH_ENOMEM);
    }
    s->stor_end = s->stor_begin + alloc_size;
    s->end = s->stor_begin;

    return 0;
}

/**
 * \ingroup stack
 * \function igraph_stack_destroy
 * \brief Destroys a stack object.
 *
 * Deallocate the memory used for a stack.
 * It is possible to reinitialize a destroyed stack again by
 * \ref igraph_stack_init().
 * \param s The stack to destroy.
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_stack, destroy)    (TYPE(igraph_stack)* s) {
    IGRAPH_ASSERT(s != NULL);
    if (s->stor_begin != 0) {
        IGRAPH_FREE(s->stor_begin);
        s->stor_begin = NULL;
    }
}

/**
 * \ingroup stack
 * \function igraph_stack_reserve
 * \brief Reserve memory.
 *
 * Reserve memory for future use. The actual size of the stack is
 * unchanged.
 * \param s The stack object.
 * \param size The number of elements to reserve memory for. If it is
 *     not bigger than the current size then nothing happens.
 * \return Error code.
 *
 * Time complexity: should be around O(n), the new allocated size of
 * the stack.
 */

int FUNCTION(igraph_stack, reserve)    (TYPE(igraph_stack)* s, long int size) {
    long int actual_size = FUNCTION(igraph_stack, size)(s);
    BASE *tmp;
    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);

    if (size <= actual_size) {
        return 0;
    }

    tmp = IGRAPH_REALLOC(s->stor_begin, (size_t) size, BASE);
    if (tmp == 0) {
        IGRAPH_ERROR("stack reserve failed", IGRAPH_ENOMEM);
    }
    s->stor_begin = tmp;
    s->stor_end = s->stor_begin + size;
    s->end = s->stor_begin + actual_size;

    return 0;
}

/**
 * \ingroup stack
 * \function igraph_stack_empty
 * \brief Decides whether a stack object is empty.
 *
 * \param s The stack object.
 * \return Boolean, \c TRUE if the stack is empty, \c FALSE
 * otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t FUNCTION(igraph_stack, empty)      (TYPE(igraph_stack)* s) {
    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    IGRAPH_ASSERT(s->end != NULL);
    return s->stor_begin == s->end;
}

/**
 * \ingroup stack
 * \function igraph_stack_size
 * \brief Returns the number of elements in a stack.
 *
 * \param s The stack object.
 * \return The number of elements in the stack.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_stack, size)       (const TYPE(igraph_stack)* s) {
    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    return s->end - s->stor_begin;
}

/**
 * \ingroup stack
 * \function igraph_stack_clear
 * \brief Removes all elements from a stack.
 *
 * \param s The stack object.
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_stack, clear)      (TYPE(igraph_stack)* s) {
    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    s->end = s->stor_begin;
}

/**
 * \ingroup stack
 * \function igraph_stack_push
 * \brief Places an element on the top of a stack.
 *
 * The capacity of the stack is increased, if needed.
 * \param s The stack object.
 * \param elem The element to push.
 * \return Error code.
 *
 * Time complexity: O(1) is no reallocation is needed, O(n)
 * otherwise, but it is ensured that n push operations are performed
 * in O(n) time.
 */

int FUNCTION(igraph_stack, push)(TYPE(igraph_stack)* s, BASE elem) {
    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    if (s->end == s->stor_end) {
        /* full, allocate more storage */

        BASE *bigger = NULL, *old = s->stor_begin;

        bigger = IGRAPH_CALLOC(2 * FUNCTION(igraph_stack, size)(s), BASE);
        if (bigger == 0) {
            IGRAPH_ERROR("stack push failed", IGRAPH_ENOMEM);
        }
        memcpy(bigger, s->stor_begin,
               (size_t) FUNCTION(igraph_stack, size)(s)*sizeof(BASE));

        s->end        = bigger + (s->stor_end - s->stor_begin);
        s->stor_end   = bigger + 2 * (s->stor_end - s->stor_begin);
        s->stor_begin = bigger;

        *(s->end) = elem;
        (s->end) += 1;

        IGRAPH_FREE(old);
    } else {
        *(s->end) = elem;
        (s->end) += 1;
    }
    return 0;
}

/**
 * \ingroup stack
 * \function igraph_stack_pop
 * \brief Removes and returns an element from the top of a stack.
 *
 * The stack must contain at least one element, call \ref
 * igraph_stack_empty() to make sure of this.
 * \param s The stack object.
 * \return The removed top element.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_stack, pop)        (TYPE(igraph_stack)* s) {

    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    IGRAPH_ASSERT(s->end != NULL);
    IGRAPH_ASSERT(s->end != s->stor_begin);

    (s->end)--;

    return *(s->end);
}

/**
 * \ingroup stack
 * \function igraph_stack_top
 * \brief Query top element.
 *
 * Returns the top element of the stack, without removing it.
 * The stack must be non-empty.
 * \param s The stack.
 * \return The top element.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_stack, top)        (const TYPE(igraph_stack)* s) {

    IGRAPH_ASSERT(s != NULL);
    IGRAPH_ASSERT(s->stor_begin != NULL);
    IGRAPH_ASSERT(s->end != NULL);
    IGRAPH_ASSERT(s->end != s->stor_begin);

    return *(s->end - 1);
}

#if defined (OUT_FORMAT)
#ifndef USING_R

int FUNCTION(igraph_stack, print)(const TYPE(igraph_stack) *s) {
    long int i, n = FUNCTION(igraph_stack, size)(s);
    if (n != 0) {
        printf(OUT_FORMAT, s->stor_begin[0]);
    }
    for (i = 1; i < n; i++) {
        printf(" " OUT_FORMAT, s->stor_begin[i]);
    }
    printf("\n");
    return 0;
}
#endif

int FUNCTION(igraph_stack, fprint)(const TYPE(igraph_stack) *s, FILE *file) {
    long int i, n = FUNCTION(igraph_stack, size)(s);
    if (n != 0) {
        fprintf(file, OUT_FORMAT, s->stor_begin[0]);
    }
    for (i = 1; i < n; i++) {
        fprintf(file, " " OUT_FORMAT, s->stor_begin[i]);
    }
    fprintf(file, "\n");
    return 0;
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/statusbar.c0000644000175100001710000001051200000000000023544 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_statusbar.h"
#include "igraph_error.h"

#include "config.h"

#include 
#include 

static IGRAPH_THREAD_LOCAL igraph_status_handler_t *igraph_i_status_handler = 0;

/**
 * \function igraph_status
 * Report status from an igraph function.
 *
 * It calls the installed status handler function, if there is
 * one. Otherwise it does nothing. Note that the standard way to
 * report the status from an igraph function is the
 * \ref IGRAPH_STATUS or \ref IGRAPH_STATUSF macro, as these
 * take care of the termination of the calling function if the
 * status handler returns with \c IGRAPH_INTERRUPTED.
 * \param message The status message.
 * \param data Additional context, with user-defined semantics.
 *        Existing igraph functions pass a null pointer here.
 * \return Error code. If a status handler function was called
 *        and it did not return with \c IGRAPH_SUCCESS, then
 *        \c IGRAPH_INTERRUPTED is returned by \c igraph_status().
 *
 * Time complexity: O(1).
 */

int igraph_status(const char *message, void *data) {
    if (igraph_i_status_handler) {
        if (igraph_i_status_handler(message, data) != IGRAPH_SUCCESS) {
            return IGRAPH_INTERRUPTED;
        }
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_statusf
 * Report status, more flexible printf-like version.
 *
 * This is the more flexible version of \ref igraph_status(),
 * that has a syntax similar to the \c printf standard C library function.
 * It substitutes the values of the additional arguments into the
 * \p message template string and calls \ref igraph_status().
 * \param message Status message template string, the syntax is the same
 *        as for the \c printf function.
 * \param data Additional context, with user-defined semantics.
 *        Existing igraph functions pass a null pointer here.
 * \param ... The additional arguments to fill the template given in the
 *        \p message argument.
 * \return Error code. If a status handler function was called
 *        and it did not return with \c IGRAPH_SUCCESS, then
 *        \c IGRAPH_INTERRUPTED is returned by \c igraph_status().
 */

int igraph_statusf(const char *message, void *data, ...) {
    char buffer[300];
    va_list ap;
    va_start(ap, data);
    vsnprintf(buffer, sizeof(buffer) - 1, message, ap);
    return igraph_status(buffer, data);
}

#ifndef USING_R

/**
 * \function igraph_status_handler_stderr
 * A simple predefined status handler function.
 *
 * A simple status handler function, that writes the status
 * message to the standard errror.
 * \param message The status message.
 * \param data Additional context, with user-defined semantics.
 *        Existing igraph functions pass a null pointer here.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_status_handler_stderr(const char *message, void *data) {
    IGRAPH_UNUSED(data);
    fputs(message, stderr);
    return 0;
}
#endif

/**
 * \function igraph_set_status_handler
 * Install of uninstall a status handler function.
 *
 * To uninstall the currently installed status handler, call
 * this function with a null pointer.
 * \param new_handler The status handler function to install.
 * \return The previously installed status handler function.
 *
 * Time complexity: O(1).
 */

igraph_status_handler_t *
igraph_set_status_handler(igraph_status_handler_t new_handler) {
    igraph_status_handler_t *previous_handler = igraph_i_status_handler;
    igraph_i_status_handler = new_handler;
    return previous_handler;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/strvector.c0000644000175100001710000004200200000000000023566 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_strvector.h"
#include "igraph_memory.h"
#include "igraph_error.h"

#include          /* memcpy & co. */
#include 

/**
 * \section igraph_strvector_t
 * The igraph_strvector_t type is a vector of strings.
 * The current implementation is very simple and not too efficient. It
 * works fine for not too many strings, e.g. the list of attribute
 * names is returned in a string vector by \ref
 * igraph_cattribute_list(). Do not expect great performance from this
 * type.
 *
 * 
 * \example examples/simple/igraph_strvector.c
 * 
 */

/**
 * \ingroup strvector
 * \function igraph_strvector_init
 * \brief Initialize
 *
 * Reserves memory for the string vector, a string vector must be
 * first initialized before calling other functions on it.
 * All elements of the string vector are set to the empty string.
 * \param sv Pointer to an initialized string vector.
 * \param len The (initial) length of the string vector.
 * \return Error code.
 *
 * Time complexity: O(\p len).
 */

int igraph_strvector_init(igraph_strvector_t *sv, long int len) {
    long int i;
    sv->data = IGRAPH_CALLOC(len, char*);
    if (sv->data == 0) {
        IGRAPH_ERROR("strvector init failed", IGRAPH_ENOMEM);
    }
    for (i = 0; i < len; i++) {
        sv->data[i] = IGRAPH_CALLOC(1, char);
        if (sv->data[i] == 0) {
            igraph_strvector_destroy(sv);
            IGRAPH_ERROR("strvector init failed", IGRAPH_ENOMEM);
        }
        sv->data[i][0] = '\0';
    }
    sv->len = len;

    return 0;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_destroy
 * \brief Free allocated memory
 *
 * Destroy a string vector. It may be reinitialized with \ref
 * igraph_strvector_init() later.
 * \param sv The string vector.
 *
 * Time complexity: O(l), the total length of the strings, maybe less
 * depending on the memory manager.
 */

void igraph_strvector_destroy(igraph_strvector_t *sv) {
    long int i;
    IGRAPH_ASSERT(sv != 0);
    if (sv->data != 0) {
        for (i = 0; i < sv->len; i++) {
            if (sv->data[i] != 0) {
                IGRAPH_FREE(sv->data[i]);
            }
        }
        IGRAPH_FREE(sv->data);
    }
}

/**
 * \ingroup strvector
 * \function igraph_strvector_get
 * \brief Indexing
 *
 * Query an element of a string vector. See also the \ref STR macro
 * for an easier way.
 * \param sv The input string vector.
 * \param idx The index of the element to query.
 * \param Pointer to a char*, the address of the string
 *   is stored here.
 *
 * Time complexity: O(1).
 */

void igraph_strvector_get(const igraph_strvector_t *sv, long int idx,
                          char **value) {
    IGRAPH_ASSERT(sv != 0);
    IGRAPH_ASSERT(sv->data != 0);
    IGRAPH_ASSERT(sv->data[idx] != 0);
    *value = sv->data[idx];
}

/**
 * \ingroup strvector
 * \function igraph_strvector_set
 * \brief Set an element
 *
 * The provided \p value is copied into the \p idx position in the
 * string vector.
 * \param sv The string vector.
 * \param idx The position to set.
 * \param value The new value.
 * \return Error code.
 *
 * Time complexity: O(l), the length of the new string. Maybe more,
 * depending on the memory management, if reallocation is needed.
 */

int igraph_strvector_set(igraph_strvector_t *sv, long int idx,
                         const char *value) {
    size_t value_len;

    IGRAPH_ASSERT(sv != 0);
    IGRAPH_ASSERT(sv->data != 0);

    value_len = strlen(value);
    if (sv->data[idx] == 0) {
        sv->data[idx] = IGRAPH_CALLOC(value_len + 1, char);
        if (sv->data[idx] == 0) {
            IGRAPH_ERROR("strvector set failed", IGRAPH_ENOMEM);
        }
    } else {
        char *tmp = IGRAPH_REALLOC(sv->data[idx], value_len + 1, char);
        if (tmp == 0) {
            IGRAPH_ERROR("strvector set failed", IGRAPH_ENOMEM);
        }
        sv->data[idx] = tmp;
    }
    strcpy(sv->data[idx], value);

    return 0;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_set2
 * \brief Sets an element.
 *
 * This is almost the same as \ref igraph_strvector_set, but the new
 * value is not a zero terminated string, but its length is given.
 * \param sv The string vector.
 * \param idx The position to set.
 * \param value The new value.
 * \param len The length of the new value.
 * \return Error code.
 *
 * Time complexity: O(l), the length of the new string. Maybe more,
 * depending on the memory management, if reallocation is needed.
 */
int igraph_strvector_set2(igraph_strvector_t *sv, long int idx,
                          const char *value, int len) {
    if (idx < 0 || idx >= sv->len) {
        IGRAPH_ERROR("String vector index out of bounds.", IGRAPH_EINVAL);
    }
    IGRAPH_ASSERT(sv != 0);
    IGRAPH_ASSERT(sv->data != 0);
    if (sv->data[idx] == 0) {
        sv->data[idx] = IGRAPH_CALLOC(len + 1, char);
        if (sv->data[idx] == 0) {
            IGRAPH_ERROR("strvector set failed", IGRAPH_ENOMEM);
        }
    } else {
        char *tmp = IGRAPH_REALLOC(sv->data[idx], (size_t) len + 1, char);
        if (tmp == 0) {
            IGRAPH_ERROR("strvector set failed", IGRAPH_ENOMEM);
        }
        sv->data[idx] = tmp;
    }
    memcpy(sv->data[idx], value, (size_t) len * sizeof(char));
    sv->data[idx][len] = '\0';

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_remove_section
 * \brief Removes a section from a string vector.
 * \todo repair realloc
 */

void igraph_strvector_remove_section(igraph_strvector_t *v, long int from,
                                     long int to) {
    long int i;
    /*   char **tmp; */

    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);

    for (i = from; i < to; i++) {
        if (v->data[i] != 0) {
            IGRAPH_FREE(v->data[i]);
        }
    }
    for (i = 0; i < v->len - to; i++) {
        v->data[from + i] = v->data[to + i];
    }

    v->len -= (to - from);

    /* try to make it smaller */
    /*   tmp=IGRAPH_REALLOC(v->data, v->len, char*); */
    /*   if (tmp!=0) { */
    /*     v->data=tmp; */
    /*   } */
}

/**
 * \ingroup strvector
 * \function igraph_strvector_remove
 * \brief Removes a single element from a string vector.
 *
 * The string will be one shorter.
 * \param v The string vector.
 * \param elem The index of the element to remove.
 *
 * Time complexity: O(n), the length of the string.
 */

void igraph_strvector_remove(igraph_strvector_t *v, long int elem) {
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);
    igraph_strvector_remove_section(v, elem, elem + 1);
}

/**
 * \ingroup strvector
 * \function igraph_strvector_move_interval
 * \brief Copies an interval of a string vector.
 */

void igraph_strvector_move_interval(igraph_strvector_t *v, long int begin,
                                    long int end, long int to) {
    long int i;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);
    for (i = to; i < to + end - begin; i++) {
        if (v->data[i] != 0) {
            IGRAPH_FREE(v->data[i]);
        }
    }
    for (i = 0; i < end - begin; i++) {
        if (v->data[begin + i] != 0) {
            size_t len = strlen(v->data[begin + i]) + 1;
            v->data[to + i] = IGRAPH_CALLOC(len, char);
            memcpy(v->data[to + i], v->data[begin + i], sizeof(char)*len);
        }
    }
}

/**
 * \ingroup strvector
 * \function igraph_strvector_copy
 * \brief Initialization by copying.
 *
 * Initializes a string vector by copying another string vector.
 * \param to Pointer to an uninitialized string vector.
 * \param from The other string vector, to be copied.
 * \return Error code.
 *
 * Time complexity: O(l), the total length of the strings in \p from.
 */

int igraph_strvector_copy(igraph_strvector_t *to,
                          const igraph_strvector_t *from) {
    long int i;
    char *str;
    IGRAPH_ASSERT(from != 0);
    /*   IGRAPH_ASSERT(from->data != 0); */
    to->data = IGRAPH_CALLOC(from->len, char*);
    if (to->data == 0) {
        IGRAPH_ERROR("Cannot copy string vector", IGRAPH_ENOMEM);
    }
    to->len = from->len;

    for (i = 0; i < from->len; i++) {
        int ret;
        igraph_strvector_get(from, i, &str);
        ret = igraph_strvector_set(to, i, str);
        if (ret != 0) {
            igraph_strvector_destroy(to);
            IGRAPH_ERROR("cannot copy string vector", ret);
        }
    }

    return 0;
}

/**
 * \function igraph_strvector_append
 * Concatenate two string vectors.
 *
 * \param to The first string vector, the result is stored here.
 * \param from The second string vector, it is kept unchanged.
 * \return Error code.
 *
 * Time complexity: O(n+l2), n is the number of strings in the new
 * string vector, l2 is the total length of strings in the \p from
 * string vector.
 */

int igraph_strvector_append(igraph_strvector_t *to,
                            const igraph_strvector_t *from) {
    long int len1 = igraph_strvector_size(to), len2 = igraph_strvector_size(from);
    long int i;
    igraph_bool_t error = 0;
    IGRAPH_CHECK(igraph_strvector_resize(to, len1 + len2));
    for (i = 0; i < len2; i++) {
        if (from->data[i][0] != '\0') {
            IGRAPH_FREE(to->data[len1 + i]);
            to->data[len1 + i] = strdup(from->data[i]);
            if (!to->data[len1 + i]) {
                error = 1;
                break;
            }
        }
    }
    if (error) {
        igraph_strvector_resize(to, len1);
        IGRAPH_ERROR("Cannot append string vector", IGRAPH_ENOMEM);
    }
    return 0;
}

/**
 * \function igraph_strvector_clear
 * Remove all elements
 *
 * After this operation the string vector will be empty.
 * \param sv The string vector.
 *
 * Time complexity: O(l), the total length of strings, maybe less,
 * depending on the memory manager.
 */

void igraph_strvector_clear(igraph_strvector_t *sv) {
    long int i, n = igraph_strvector_size(sv);
    char **tmp;

    for (i = 0; i < n; i++) {
        IGRAPH_FREE(sv->data[i]);
    }
    sv->len = 0;
    /* try to give back some memory */
    tmp = IGRAPH_REALLOC(sv->data, 1, char*);
    if (tmp != 0) {
        sv->data = tmp;
    }
}

/**
 * \ingroup strvector
 * \function igraph_strvector_resize
 * \brief Resize
 *
 * If the new size is bigger then empty strings are added, if it is
 * smaller then the unneeded elements are removed.
 * \param v The string vector.
 * \param newsize The new size.
 * \return Error code.
 *
 * Time complexity: O(n), the number of strings if the vector is made
 * bigger, O(l), the total length of the deleted strings if it is made
 * smaller, maybe less, depending on memory management.
 */

int igraph_strvector_resize(igraph_strvector_t* v, long int newsize) {
    long int toadd = newsize - v->len, i, j;
    char **tmp;
    long int reallocsize = newsize;

    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);
    /*   printf("resize %li to %li\n", v->len, newsize); */
    if (newsize < v->len) {
        for (i = newsize; i < v->len; i++) {
            IGRAPH_FREE(v->data[i]);
        }
        /* try to give back some space */
        tmp = IGRAPH_REALLOC(v->data, (size_t) reallocsize, char*);
        /*     printf("resize %li to %li, %p\n", v->len, newsize, tmp); */
        if (tmp != 0) {
            v->data = tmp;
        }
    } else if (newsize > v->len) {
        igraph_bool_t error = 0;
        tmp = IGRAPH_REALLOC(v->data, (size_t) reallocsize, char*);
        if (tmp == 0) {
            IGRAPH_ERROR("cannot resize string vector", IGRAPH_ENOMEM);
        }
        v->data = tmp;

        for (i = 0; i < toadd; i++) {
            v->data[v->len + i] = IGRAPH_CALLOC(1, char);
            if (v->data[v->len + i] == 0) {
                error = 1;
                break;
            }
            v->data[v->len + i][0] = '\0';
        }
        if (error) {
            /* There was an error, free everything we've allocated so far */
            for (j = 0; j < i; j++) {
                if (v->data[v->len + i] != 0) {
                    IGRAPH_FREE(v->data[v->len + i]);
                }
            }
            /* Try to give back space */
            tmp = IGRAPH_REALLOC(v->data, (size_t) (v->len), char*);
            if (tmp != 0) {
                v->data = tmp;
            }
            IGRAPH_ERROR("Cannot resize string vector", IGRAPH_ENOMEM);
        }
    }
    v->len = newsize;

    return 0;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_size
 * \brief Gives the size of a string vector.
 *
 * \param sv The string vector.
 * \return The length of the string vector.
 *
 * Time complexity: O(1).
 */

long int igraph_strvector_size(const igraph_strvector_t *sv) {
    IGRAPH_ASSERT(sv != 0);
    IGRAPH_ASSERT(sv->data != 0);
    return sv->len;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_add
 * \brief Adds an element to the back of a string vector.
 *
 * \param v The string vector.
 * \param value The string to add, it will be copied.
 * \return Error code.
 *
 * Time complexity: O(n+l), n is the total number of strings, l is the
 * length of the new string.
 */

int igraph_strvector_add(igraph_strvector_t *v, const char *value) {
    long int s = igraph_strvector_size(v);
    long int value_len = strlen(value);
    char **tmp;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);
    tmp = IGRAPH_REALLOC(v->data, (size_t) s + 1, char*);
    if (tmp == 0) {
        IGRAPH_ERROR("cannot add string to string vector", IGRAPH_ENOMEM);
    }
    v->data = tmp;
    v->data[s] = IGRAPH_CALLOC(value_len + 1, char);
    if (v->data[s] == 0) {
        IGRAPH_ERROR("cannot add string to string vector", IGRAPH_ENOMEM);
    }
    strcpy(v->data[s], value);
    v->len += 1;

    return 0;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_permdelete
 * \brief Removes elements from a string vector (for internal use)
 */

void igraph_strvector_permdelete(igraph_strvector_t *v, const igraph_vector_t *index,
                                 long int nremove) {
    long int i;
    char **tmp;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);

    for (i = 0; i < igraph_strvector_size(v); i++) {
        if (VECTOR(*index)[i] != 0) {
            v->data[ (long int) VECTOR(*index)[i] - 1 ] = v->data[i];
        } else {
            IGRAPH_FREE(v->data[i]);
        }
    }
    /* Try to make it shorter */
    tmp = IGRAPH_REALLOC(v->data, v->len - nremove ?
                         (size_t) (v->len - nremove) : 1, char*);
    if (tmp != 0) {
        v->data = tmp;
    }
    v->len -= nremove;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_remove_negidx
 * \brief Removes elements from a string vector (for internal use)
 */

void igraph_strvector_remove_negidx(igraph_strvector_t *v, const igraph_vector_t *neg,
                                    long int nremove) {
    long int i, idx = 0;
    char **tmp;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->data != 0);
    for (i = 0; i < igraph_strvector_size(v); i++) {
        if (VECTOR(*neg)[i] >= 0) {
            v->data[idx++] = v->data[i];
        } else {
            IGRAPH_FREE(v->data[i]);
        }
    }
    /* Try to give back some memory */
    tmp = IGRAPH_REALLOC(v->data, v->len - nremove ?
                         (size_t) (v->len - nremove) : 1, char*);
    if (tmp != 0) {
        v->data = tmp;
    }
    v->len -= nremove;
}

/**
 * \ingroup strvector
 * \function igraph_strvector_print
 * \brief Prints a string vector.
 *
 * \param v The string vector.
 * \param file The file to write to.
 * \param sep The separator to print between strings.
 * \return Error code.
 */
int igraph_strvector_print(const igraph_strvector_t *v, FILE *file,
                           const char *sep) {

    long int i, n = igraph_strvector_size(v);
    if (n != 0) {
        fprintf(file, "%s", STR(*v, 0));
    }
    for (i = 1; i < n; i++) {
        fprintf(file, "%s%s", sep, STR(*v, i));
    }
    return IGRAPH_SUCCESS;
}

int igraph_strvector_index(const igraph_strvector_t *v,
                           igraph_strvector_t *newv,
                           const igraph_vector_t *idx) {

    long int i, newlen = igraph_vector_size(idx);
    IGRAPH_CHECK(igraph_strvector_resize(newv, newlen));

    for (i = 0; i < newlen; i++) {
        long int j = (long int) VECTOR(*idx)[i];
        char *str;
        igraph_strvector_get(v, j, &str);
        igraph_strvector_set(newv, i, str);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/trie.c0000644000175100001710000003004500000000000022502 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_error.h"

#include "core/trie.h"

#include "config.h"

#include 

/**
 * \ingroup igraphtrie
 * \brief Creates a trie node (not to be called directly)
 * \return Error code: errors by igraph_strvector_init(),
 *         igraph_vector_ptr_init() and igraph_vector_init() might be returned.
 */

static int igraph_i_trie_init_node(igraph_trie_node_t *t) {
    IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&t->values, 0);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

static void igraph_i_trie_destroy_node(igraph_trie_node_t *t);

/**
 * \ingroup igraphtrie
 * \brief Creates a trie.
 * \return Error code: errors by igraph_strvector_init(),
 *         igraph_vector_ptr_init() and igraph_vector_init() might be returned.
 */

int igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) {
    t->maxvalue = -1;
    t->storekeys = storekeys;
    IGRAPH_CHECK(igraph_i_trie_init_node( (igraph_trie_node_t *) t ));
    IGRAPH_FINALLY(igraph_i_trie_destroy_node, (igraph_trie_node_t *) t );
    if (storekeys) {
        IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0));
    }

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \ingroup igraphtrie
 * \brief Destroys a node of a trie (not to be called directly).
 */

static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) {
    long int i;
    igraph_strvector_destroy(&t->strs);
    for (i = 0; i < igraph_vector_ptr_size(&t->children); i++) {
        igraph_trie_node_t *child = VECTOR(t->children)[i];
        if (child != 0) {
            igraph_i_trie_destroy_node_helper(child, 1);
        }
    }
    igraph_vector_ptr_destroy(&t->children);
    igraph_vector_destroy(&t->values);
    if (sfree) {
        IGRAPH_FREE(t);
    }
}

static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) {
    igraph_i_trie_destroy_node_helper(t, 0);
}

/**
 * \ingroup igraphtrie
 * \brief Destroys a trie (frees allocated memory).
 */

void igraph_trie_destroy(igraph_trie_t *t) {
    if (t->storekeys) {
        igraph_strvector_destroy(&t->keys);
    }
    igraph_i_trie_destroy_node( (igraph_trie_node_t*) t);
}


/**
 * \ingroup igraphtrie
 * \brief Internal helping function for igraph_trie_t
 */

static long int igraph_i_strdiff(const char *str, const char *key) {

    long int diff = 0;
    while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) {
        diff++;
    }
    return diff;
}

/**
 * \ingroup igraphtrie
 * \brief Search/insert in a trie (not to be called directly).
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_trie_get_node(igraph_trie_node_t *t, const char *key,
                         igraph_real_t newvalue, long int *id) {
    char *str;
    long int i;
    igraph_bool_t add;

    /* If newvalue is negative, we don't add the node if nonexistent, only check
     * for its existence */
    add = (newvalue >= 0);

    for (i = 0; i < igraph_strvector_size(&t->strs); i++) {
        long int diff;
        igraph_strvector_get(&t->strs, i, &str);
        diff = igraph_i_strdiff(str, key);

        if (diff == 0) {

            /* ------------------------------------ */
            /* No match, next */

        } else if (str[diff] == '\0' && key[diff] == '\0') {

            /* ------------------------------------ */
            /* They are exactly the same */
            if (VECTOR(t->values)[i] != -1) {
                *id = (long int) VECTOR(t->values)[i];
                return 0;
            } else {
                VECTOR(t->values)[i] = newvalue;
                *id = (long int) newvalue;
                return 0;
            }

        } else if (str[diff] == '\0') {

            /* ------------------------------------ */
            /* str is prefix of key, follow its link if there is one */
            igraph_trie_node_t *node = VECTOR(t->children)[i];
            if (node != 0) {
                return igraph_trie_get_node(node, key + diff, newvalue, id);
            } else if (add) {
                igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
                if (node == 0) {
                    IGRAPH_ERROR("cannot add to trie", IGRAPH_ENOMEM);
                }
                IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1);
                IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1);
                IGRAPH_VECTOR_INIT_FINALLY(&node->values, 1);
                IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, key + diff));
                VECTOR(node->children)[0] = 0;
                VECTOR(node->values)[0] = newvalue;

                VECTOR(t->children)[i] = node;

                *id = (long int) newvalue;
                IGRAPH_FINALLY_CLEAN(3);
                return 0;
            } else {
                *id = -1;
                return 0;
            }

        } else if (key[diff] == '\0' && add) {

            /* ------------------------------------ */
            /* key is prefix of str, the node has to be cut */
            char *str2;

            igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
            if (node == 0) {
                IGRAPH_ERROR("cannot add to trie", IGRAPH_ENOMEM);
            }
            IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1);
            IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1);
            IGRAPH_VECTOR_INIT_FINALLY(&node->values, 1);
            IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));

            VECTOR(node->children)[0] = VECTOR(t->children)[i];
            VECTOR(node->values)[0] = VECTOR(t->values)[i];

            str2 = strdup(str);
            if (str2 == 0) {
                IGRAPH_ERROR("cannot add to trie", IGRAPH_ENOMEM);
            }
            str2[diff] = '\0';
            IGRAPH_FINALLY(igraph_free, str2);
            IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
            IGRAPH_FREE(str2);
            IGRAPH_FINALLY_CLEAN(4);

            VECTOR(t->values)[i] = newvalue;
            VECTOR(t->children)[i] = node;

            *id = (long int) newvalue;
            return 0;

        } else if (add) {

            /* ------------------------------------ */
            /* the first diff characters match */
            char *str2;

            igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t);
            if (node == 0) {
                IGRAPH_ERROR("cannot add to trie", IGRAPH_ENOMEM);
            }
            IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2);
            IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2);
            IGRAPH_VECTOR_INIT_FINALLY(&node->values, 2);
            IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff));
            IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff));
            VECTOR(node->children)[0] = VECTOR(t->children)[i];
            VECTOR(node->children)[1] = 0;
            VECTOR(node->values)[0] = VECTOR(t->values)[i];
            VECTOR(node->values)[1] = newvalue;

            str2 = strdup(str);
            if (str2 == 0) {
                IGRAPH_ERROR("cannot add to trie", IGRAPH_ENOMEM);
            }
            str2[diff] = '\0';
            IGRAPH_FINALLY(igraph_free, str2);
            IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2));
            IGRAPH_FREE(str2);
            IGRAPH_FINALLY_CLEAN(4);

            VECTOR(t->values)[i] = -1;
            VECTOR(t->children)[i] = node;

            *id = (long int) newvalue;
            return 0;
        } else {

            /* ------------------------------------------------- */
            /* No match, but we requested not to add the new key */
            *id = -1;
            return 0;
        }
    }

    /* ------------------------------------ */
    /* Nothing matches */

    if (add) {
        IGRAPH_CHECK(igraph_vector_ptr_reserve(&t->children,
                                               igraph_vector_ptr_size(&t->children) + 1));
        IGRAPH_CHECK(igraph_vector_reserve(&t->values, igraph_vector_size(&t->values) + 1));
        IGRAPH_CHECK(igraph_strvector_add(&t->strs, key));

        igraph_vector_ptr_push_back(&t->children, 0); /* allocated */
        igraph_vector_push_back(&t->values, newvalue); /* allocated */
        *id = (long int) newvalue;
    } else {
        *id = -1;
    }

    return 0;
}

/**
 * \ingroup igraphtrie
 * \brief Search/insert in a trie.
 */

int igraph_trie_get(igraph_trie_t *t, const char *key, long int *id) {
    if (!t->storekeys) {
        IGRAPH_CHECK(igraph_trie_get_node( (igraph_trie_node_t*) t,
                                           key, t->maxvalue + 1, id));
        if (*id > t->maxvalue) {
            t->maxvalue = *id;
        }
        return 0;
    } else {
        int ret;
        igraph_error_handler_t *oldhandler;
        oldhandler = igraph_set_error_handler(igraph_error_handler_ignore);
        /* Add it to the string vector first, we can undo this later */
        ret = igraph_strvector_add(&t->keys, key);
        if (ret != 0) {
            igraph_set_error_handler(oldhandler);
            IGRAPH_ERROR("cannot get element from trie", ret);
        }
        ret = igraph_trie_get_node( (igraph_trie_node_t*) t,
                                    key, t->maxvalue + 1, id);
        if (ret != 0) {
            igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1);
            igraph_set_error_handler(oldhandler);
            IGRAPH_ERROR("cannot get element from trie", ret);
        }

        /* everything is fine */
        if (*id > t->maxvalue) {
            t->maxvalue = *id;
        } else {
            igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1);
        }
        igraph_set_error_handler(oldhandler);
    }

    return 0;
}

/**
 * \ingroup igraphtrie
 * \brief Search/insert in a trie (for internal use).
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_trie_get2(igraph_trie_t *t, const char *key, long int length,
                     long int *id) {
    char *tmp = IGRAPH_CALLOC(length + 1, char);

    if (tmp == 0) {
        IGRAPH_ERROR("Cannot get from trie", IGRAPH_ENOMEM);
    }

    strncpy(tmp, key, length);
    tmp[length] = '\0';
    IGRAPH_FINALLY(igraph_free, tmp);
    IGRAPH_CHECK(igraph_trie_get(t, tmp, id));
    IGRAPH_FREE(tmp);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \ingroup igraphtrie
 * \brief Search in a trie.
 * This variant does not add \c key to the trie if it does not exist.
 * In this case, a negative id is returned.
 */

int igraph_trie_check(igraph_trie_t *t, const char *key, long int *id) {
    IGRAPH_CHECK(igraph_trie_get_node( (igraph_trie_node_t*) t,
                                       key, -1, id));
    return 0;
}

/**
 * \ingroup igraphtrie
 * \brief Get an element of a trie based on its index.
 */

void igraph_trie_idx(igraph_trie_t *t, long int idx, char **str) {
    igraph_strvector_get(&t->keys, idx, str);
}

/**
 * \ingroup igraphtrie
 * \brief Returns the size of a trie.
 */

long int igraph_trie_size(igraph_trie_t *t) {
    return t->maxvalue + 1;
}

/* Hmmm, very dirty.... */

int igraph_trie_getkeys(igraph_trie_t *t, const igraph_strvector_t **strv) {
    *strv = &t->keys;
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/trie.h0000644000175100001710000000471500000000000022514 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_CORE_TRIE_H
#define IGRAPH_CORE_TRIE_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_strvector.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

/**
 * Trie data type
 * \ingroup internal
 */

typedef struct s_igraph_trie_node {
    igraph_strvector_t strs;
    igraph_vector_ptr_t children;
    igraph_vector_t values;
} igraph_trie_node_t;

typedef struct s_igraph_trie {
    igraph_strvector_t strs;
    igraph_vector_ptr_t children;
    igraph_vector_t values;
    long int maxvalue;
    igraph_bool_t storekeys;
    igraph_strvector_t keys;
} igraph_trie_t;

#define IGRAPH_TRIE_NULL { IGRAPH_STRVECTOR_NULL, IGRAPH_VECTOR_PTR_NULL, \
        IGRAPH_VECTOR_NULL, 0, 0, IGRAPH_STRVECTOR_NULL }
#define IGRAPH_TRIE_INIT_FINALLY(tr, sk) \
    do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \
        IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0)

IGRAPH_PRIVATE_EXPORT int igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys);
IGRAPH_PRIVATE_EXPORT void igraph_trie_destroy(igraph_trie_t *t);
IGRAPH_PRIVATE_EXPORT int igraph_trie_get(igraph_trie_t *t, const char *key, long int *id);
IGRAPH_PRIVATE_EXPORT int igraph_trie_check(igraph_trie_t *t, const char *key, long int *id);
IGRAPH_PRIVATE_EXPORT int igraph_trie_get2(igraph_trie_t *t, const char *key, long int length,
                                           long int *id);
IGRAPH_PRIVATE_EXPORT void igraph_trie_idx(igraph_trie_t *t, long int idx, char **str);
IGRAPH_PRIVATE_EXPORT int igraph_trie_getkeys(igraph_trie_t *t, const igraph_strvector_t **strv);
IGRAPH_PRIVATE_EXPORT long int igraph_trie_size(igraph_trie_t *t);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/vector.c0000644000175100001710000003617200000000000023050 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_complex.h"

#include 

#define BASE_IGRAPH_REAL
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_IGRAPH_REAL

#define BASE_FLOAT
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_FLOAT

#define BASE_LONG
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_LONG

#define BASE_CHAR
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_CHAR

#define BASE_BOOL
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_BOOL

#define BASE_INT
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_INT

#define BASE_COMPLEX
#include "igraph_pmt.h"
#include "vector.pmt"
#include "igraph_pmt_off.h"
#undef BASE_COMPLEX

#include "core/math.h"

#include "core/indheap.h"

/**
 * \ingroup vector
 * \function igraph_vector_floor
 * \brief Transform a real vector to a long vector by flooring each element.
 *
 * 
 * Flooring means rounding down to the nearest integer.
 *
 * \param from The original real vector object.
 * \param to Pointer to an initialized long vector. The result will
 *           be stored here.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: out of memory
 *
 * Time complexity: O(n), where n is the number of elements in the vector.
 */
int igraph_vector_floor(const igraph_vector_t *from, igraph_vector_long_t *to) {
    long int i, n = igraph_vector_size(from);

    IGRAPH_CHECK(igraph_vector_long_resize(to, n));
    for (i = 0; i < n; i++) {
        VECTOR(*to)[i] = (long int) floor(VECTOR(*from)[i]);
    }
    return IGRAPH_SUCCESS;
}

int igraph_vector_round(const igraph_vector_t *from, igraph_vector_long_t *to) {
    long int i, n = igraph_vector_size(from);

    IGRAPH_CHECK(igraph_vector_long_resize(to, n));
    for (i = 0; i < n; i++) {
        VECTOR(*to)[i] = (long int) round(VECTOR(*from)[i]);
    }
    return 0;
}

int igraph_vector_order2(igraph_vector_t *v) {

    igraph_indheap_t heap;

    igraph_indheap_init_array(&heap, VECTOR(*v), igraph_vector_size(v));
    IGRAPH_FINALLY(igraph_indheap_destroy, &heap);

    igraph_vector_clear(v);
    while (!igraph_indheap_empty(&heap)) {
        IGRAPH_CHECK(igraph_vector_push_back(v, igraph_indheap_max_index(&heap) - 1));
        igraph_indheap_delete_max(&heap);
    }

    igraph_indheap_destroy(&heap);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_order
 * \brief Calculate the order of the elements in a vector.
 *
 * 
 * The smallest element will have order zero, the second smallest
 * order one, etc.
 * \param v The original \type igraph_vector_t object.
 * \param v2 A secondary key, another \type igraph_vector_t object.
 * \param res An initialized \type igraph_vector_t object, it will be
 *    resized to match the size of \p v. The
 *    result of the computation will be stored here.
 * \param nodes Hint, the largest element in \p v.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: out of memory
 *
 * Time complexity: O()
 */

int igraph_vector_order(const igraph_vector_t* v,
                        const igraph_vector_t *v2,
                        igraph_vector_t* res, igraph_real_t nodes) {
    long int edges = igraph_vector_size(v);
    igraph_vector_t ptr;
    igraph_vector_t rad;
    long int i, j;

    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    IGRAPH_VECTOR_INIT_FINALLY(&ptr, (long int) nodes + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&rad, edges);
    IGRAPH_CHECK(igraph_vector_resize(res, edges));

    for (i = 0; i < edges; i++) {
        long int radix = (long int) v2->stor_begin[i];
        if (VECTOR(ptr)[radix] != 0) {
            VECTOR(rad)[i] = VECTOR(ptr)[radix];
        }
        VECTOR(ptr)[radix] = i + 1;
    }

    j = 0;
    for (i = 0; i < nodes + 1; i++) {
        if (VECTOR(ptr)[i] != 0) {
            long int next = (long int) VECTOR(ptr)[i] - 1;
            res->stor_begin[j++] = next;
            while (VECTOR(rad)[next] != 0) {
                next = (long int) VECTOR(rad)[next] - 1;
                res->stor_begin[j++] = next;
            }
        }
    }

    igraph_vector_null(&ptr);
    igraph_vector_null(&rad);

    for (i = 0; i < edges; i++) {
        long int edge = (long int) VECTOR(*res)[edges - i - 1];
        long int radix = (long int) VECTOR(*v)[edge];
        if (VECTOR(ptr)[radix] != 0) {
            VECTOR(rad)[edge] = VECTOR(ptr)[radix];
        }
        VECTOR(ptr)[radix] = edge + 1;
    }

    j = 0;
    for (i = 0; i < nodes + 1; i++) {
        if (VECTOR(ptr)[i] != 0) {
            long int next = (long int) VECTOR(ptr)[i] - 1;
            res->stor_begin[j++] = next;
            while (VECTOR(rad)[next] != 0) {
                next = (long int) VECTOR(rad)[next] - 1;
                res->stor_begin[j++] = next;
            }
        }
    }

    igraph_vector_destroy(&ptr);
    igraph_vector_destroy(&rad);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

int igraph_vector_order1(const igraph_vector_t* v,
                         igraph_vector_t* res, igraph_real_t nodes) {
    long int edges = igraph_vector_size(v);
    igraph_vector_t ptr;
    igraph_vector_t rad;
    long int i, j;

    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    IGRAPH_VECTOR_INIT_FINALLY(&ptr, (long int) nodes + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&rad, edges);
    IGRAPH_CHECK(igraph_vector_resize(res, edges));

    for (i = 0; i < edges; i++) {
        long int radix = (long int) v->stor_begin[i];
        if (VECTOR(ptr)[radix] != 0) {
            VECTOR(rad)[i] = VECTOR(ptr)[radix];
        }
        VECTOR(ptr)[radix] = i + 1;
    }

    j = 0;
    for (i = 0; i < nodes + 1; i++) {
        if (VECTOR(ptr)[i] != 0) {
            long int next = (long int) VECTOR(ptr)[i] - 1;
            res->stor_begin[j++] = next;
            while (VECTOR(rad)[next] != 0) {
                next = (long int) VECTOR(rad)[next] - 1;
                res->stor_begin[j++] = next;
            }
        }
    }

    igraph_vector_destroy(&ptr);
    igraph_vector_destroy(&rad);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

int igraph_vector_order1_int(const igraph_vector_t* v,
                             igraph_vector_int_t* res,
                             igraph_real_t nodes) {
    long int edges = igraph_vector_size(v);
    igraph_vector_t ptr;
    igraph_vector_t rad;
    long int i, j;

    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    IGRAPH_VECTOR_INIT_FINALLY(&ptr, (long int) nodes + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&rad, edges);
    IGRAPH_CHECK(igraph_vector_int_resize(res, edges));

    for (i = 0; i < edges; i++) {
        long int radix = (long int) v->stor_begin[i];
        if (VECTOR(ptr)[radix] != 0) {
            VECTOR(rad)[i] = VECTOR(ptr)[radix];
        }
        VECTOR(ptr)[radix] = i + 1;
    }

    j = 0;
    for (i = 0; i < nodes + 1; i++) {
        if (VECTOR(ptr)[i] != 0) {
            long int next = (long int) VECTOR(ptr)[i] - 1;
            res->stor_begin[j++] = next;
            while (VECTOR(rad)[next] != 0) {
                next = (long int) VECTOR(rad)[next] - 1;
                res->stor_begin[j++] = next;
            }
        }
    }

    igraph_vector_destroy(&ptr);
    igraph_vector_destroy(&rad);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

int igraph_vector_rank(const igraph_vector_t *v, igraph_vector_t *res,
                       long int nodes) {

    igraph_vector_t rad;
    igraph_vector_t ptr;
    long int edges = igraph_vector_size(v);
    long int i, c = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&rad, nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&ptr, edges);
    IGRAPH_CHECK(igraph_vector_resize(res, edges));

    for (i = 0; i < edges; i++) {
        long int elem = (long int) VECTOR(*v)[i];
        VECTOR(ptr)[i] = VECTOR(rad)[elem];
        VECTOR(rad)[elem] = i + 1;
    }

    for (i = 0; i < nodes; i++) {
        long int p = (long int) VECTOR(rad)[i];
        while (p != 0) {
            VECTOR(*res)[p - 1] = c++;
            p = (long int) VECTOR(ptr)[p - 1];
        }
    }

    igraph_vector_destroy(&ptr);
    igraph_vector_destroy(&rad);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

#ifndef USING_R
int igraph_vector_complex_print(const igraph_vector_complex_t *v) {
    long int i, n = igraph_vector_complex_size(v);
    if (n != 0) {
        igraph_complex_t z = VECTOR(*v)[0];
        printf("%g%+gi", IGRAPH_REAL(z), IGRAPH_IMAG(z));
    }
    for (i = 1; i < n; i++) {
        igraph_complex_t z = VECTOR(*v)[i];
        printf(" %g%+gi", IGRAPH_REAL(z), IGRAPH_IMAG(z));
    }
    printf("\n");
    return 0;
}
#endif

int igraph_vector_complex_fprint(const igraph_vector_complex_t *v,
                                 FILE *file) {
    long int i, n = igraph_vector_complex_size(v);
    if (n != 0) {
        igraph_complex_t z = VECTOR(*v)[0];
        fprintf(file, "%g%+g", IGRAPH_REAL(z), IGRAPH_IMAG(z));
    }
    for (i = 1; i < n; i++) {
        igraph_complex_t z = VECTOR(*v)[i];
        fprintf(file, " %g%+g", IGRAPH_REAL(z), IGRAPH_IMAG(z));
    }
    fprintf(file, "\n");
    return 0;
}

int igraph_vector_complex_real(const igraph_vector_complex_t *v,
                               igraph_vector_t *real) {
    long int i, n = igraph_vector_complex_size(v);
    IGRAPH_CHECK(igraph_vector_resize(real, n));
    for (i = 0; i < n; i++) {
        VECTOR(*real)[i] = IGRAPH_REAL(VECTOR(*v)[i]);
    }

    return 0;
}

int igraph_vector_complex_imag(const igraph_vector_complex_t *v,
                               igraph_vector_t *imag) {
    long int i, n = igraph_vector_complex_size(v);
    IGRAPH_CHECK(igraph_vector_resize(imag, n));
    for (i = 0; i < n; i++) {
        VECTOR(*imag)[i] = IGRAPH_IMAG(VECTOR(*v)[i]);
    }

    return 0;
}

int igraph_vector_complex_realimag(const igraph_vector_complex_t *v,
                                   igraph_vector_t *real,
                                   igraph_vector_t *imag) {
    long int i, n = igraph_vector_complex_size(v);
    IGRAPH_CHECK(igraph_vector_resize(real, n));
    IGRAPH_CHECK(igraph_vector_resize(imag, n));
    for (i = 0; i < n; i++) {
        igraph_complex_t z = VECTOR(*v)[i];
        VECTOR(*real)[i] = IGRAPH_REAL(z);
        VECTOR(*imag)[i] = IGRAPH_IMAG(z);
    }

    return 0;
}

int igraph_vector_complex_create(igraph_vector_complex_t *v,
                                 const igraph_vector_t *real,
                                 const igraph_vector_t *imag) {
    long int i, n = igraph_vector_size(real);
    if (n != igraph_vector_size(imag)) {
        IGRAPH_ERROR("Real and imag vector sizes don't match", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_complex_init(v, n));
    /* FINALLY not needed */

    for (i = 0; i < n; i++) {
        VECTOR(*v)[i] = igraph_complex(VECTOR(*real)[i], VECTOR(*imag)[i]);
    }

    return 0;
}

int igraph_vector_complex_create_polar(igraph_vector_complex_t *v,
                                       const igraph_vector_t *r,
                                       const igraph_vector_t *theta) {
    long int i, n = igraph_vector_size(r);
    if (n != igraph_vector_size(theta)) {
        IGRAPH_ERROR("'r' and 'theta' vector sizes don't match", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_complex_init(v, n));
    /* FINALLY not needed */

    for (i = 0; i < n; i++) {
        VECTOR(*v)[i] = igraph_complex_polar(VECTOR(*r)[i], VECTOR(*theta)[i]);
    }

    return 0;
}

igraph_bool_t igraph_vector_e_tol(const igraph_vector_t *lhs,
                                  const igraph_vector_t *rhs,
                                  igraph_real_t tol) {
    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = igraph_vector_size(lhs);
    if (s != igraph_vector_size(rhs)) {
        return 0;
    } else {
        if (tol == 0) {
            tol = DBL_EPSILON;
        }
        for (i = 0; i < s; i++) {
            igraph_real_t l = VECTOR(*lhs)[i];
            igraph_real_t r = VECTOR(*rhs)[i];
            if (l < r - tol || l > r + tol) {
                return 0;
            }
        }
        return 1;
    }
}

int igraph_vector_zapsmall(igraph_vector_t *v, igraph_real_t tol) {
    long int i, n = igraph_vector_size(v);
    if (tol < 0.0) {
        IGRAPH_ERROR("`tol' tolerance must be non-negative", IGRAPH_EINVAL);
    }
    if (tol == 0.0) {
        tol = sqrt(DBL_EPSILON);
    }
    for (i = 0; i < n; i++) {
        igraph_real_t val = VECTOR(*v)[i];
        if (val < tol && val > -tol) {
            VECTOR(*v)[i] = 0.0;
        }
    }
    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_is_nan
 * \brief Check for each element if it is NaN.
 *
 * 
 * \param v The \type igraph_vector_t object to check.
 * \param is_nan The resulting boolean vector indicating for each element
 *               whether it is NaN or not.
 * \return Error code,
 *         \c IGRAPH_ENOMEM if there is not enough
 *         memory. Note that this function \em never returns an error
 *         if the vector \p is_nan will already be large enough.
 * Time complexity: O(n), the number of elements.
 */
int igraph_vector_is_nan(const igraph_vector_t *v, igraph_vector_bool_t *is_nan)
{
    igraph_real_t *ptr;
    igraph_bool_t *ptr_nan;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(is_nan != NULL);
    IGRAPH_ASSERT(is_nan->stor_begin != NULL);
    IGRAPH_CHECK(igraph_vector_bool_resize(is_nan, igraph_vector_size(v)));
    for (ptr = v->stor_begin, ptr_nan = is_nan->stor_begin; ptr < v->end; ptr++, ptr_nan++) {
        *ptr_nan = igraph_is_nan(*ptr) ? 1 : 0;
    }
    return IGRAPH_SUCCESS;
}

/**
 * \ingroup vector
 * \function igraph_vector_is_any_nan
 * \brief Check if any element is NaN.
 *
 * 
 * \param v The \type igraph_vector_t object to check.
 * \return 1 if any element is NaN, 0 otherwise.
 *
 * Time complexity: O(n), the number of elements.
 */
igraph_bool_t igraph_vector_is_any_nan(const igraph_vector_t *v)
{
    igraph_real_t *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    ptr = v->stor_begin;
    while (ptr < v->end) {
        if (igraph_is_nan(*ptr)) {
            return 1;
        }
        ptr++;
    }
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/vector.pmt0000644000175100001710000025432500000000000023430 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"
#include "igraph_error.h"
#include "igraph_random.h"
#include "igraph_qsort.h"

#include          /* memcpy & co. */
#include 
#include      /* va_start & co */
#include 

/**
 * \ingroup vector
 * \section about_igraph_vector_t_objects About \type igraph_vector_t objects
 *
 * The \type igraph_vector_t data type is a simple and efficient
 * interface to arrays containing numbers. It is something
 * similar as (but much simpler than) the \type vector template
 * in the C++ standard library.
 *
 * Vectors are used extensively in \a igraph, all
 * functions which expect or return a list of numbers use
 * igraph_vector_t to achieve this.
 *
 * The \type igraph_vector_t type usually uses
 * O(n) space
 * to store n elements. Sometimes it
 * uses more, this is because vectors can shrink, but even if they
 * shrink, the current implementation does not free a single bit of
 * memory.
 *
 * The elements in an \type igraph_vector_t
 * object are indexed from zero, we follow the usual C convention
 * here.
 *
 * The elements of a vector always occupy a single block of
 * memory, the starting address of this memory block can be queried
 * with the \ref VECTOR macro. This way, vector objects can be used
 * with standard mathematical libraries, like the GNU Scientific
 * Library.
 */

/**
 * \ingroup vector
 * \section igraph_vector_constructors_and_destructors Constructors and
 * Destructors
 *
 * \type igraph_vector_t objects have to be initialized before using
 * them, this is analogous to calling a constructor on them. There are a
 * number of \type igraph_vector_t constructors, for your
 * convenience. \ref igraph_vector_init() is the basic constructor, it
 * creates a vector of the given length, filled with zeros.
 * \ref igraph_vector_copy() creates a new identical copy
 * of an already existing and initialized vector. \ref
 * igraph_vector_init_copy() creates a vector by copying a regular C array.
 * \ref igraph_vector_init_seq() creates a vector containing a regular
 * sequence with increment one.
 *
 * \ref igraph_vector_view() is a special constructor, it allows you to
 * handle a regular C array as a \type vector without copying
 * its elements.
 * 
 *
 * If a \type igraph_vector_t object is not needed any more, it
 * should be destroyed to free its allocated memory by calling the
 * \type igraph_vector_t destructor, \ref igraph_vector_destroy().
 *
 *  Note that vectors created by \ref igraph_vector_view() are special,
 * you mustn't call \ref igraph_vector_destroy() on these.
 */

/**
 * \ingroup vector
 * \function igraph_vector_init
 * \brief Initializes a vector object (constructor).
 *
 * 
 * Every vector needs to be initialized before it can be used, and
 * there are a number of initialization functions or otherwise called
 * constructors. This function constructs a vector of the given size and
 * initializes each entry to 0. Note that \ref igraph_vector_null() can be
 * used to set each element of a vector to zero. However, if you want a
 * vector of zeros, it is much faster to use this function than to create a
 * vector and then invoke \ref igraph_vector_null().
 *
 * 
 * Every vector object initialized by this function should be
 * destroyed (ie. the memory allocated for it should be freed) when it
 * is not needed anymore, the \ref igraph_vector_destroy() function is
 * responsible for this.
 * \param v Pointer to a not yet initialized vector object.
 * \param size The size of the vector.
 * \return error code:
 *       \c IGRAPH_ENOMEM if there is not enough memory.
 *
 * Time complexity: operating system dependent, the amount of
 * \quote time \endquote required to allocate
 * O(n) elements,
 * n is the number of elements.
 */

int FUNCTION(igraph_vector, init)      (TYPE(igraph_vector)* v, int long size) {
    long int alloc_size = size > 0 ? size : 1;
    if (size < 0) {
        size = 0;
    }
    v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE);
    if (v->stor_begin == 0) {
        IGRAPH_ERROR("cannot init vector", IGRAPH_ENOMEM);
    }
    v->stor_end = v->stor_begin + alloc_size;
    v->end = v->stor_begin + size;

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_view
 * \brief Handle a regular C array as a \type igraph_vector_t.
 *
 * 
 * This is a special \type igraph_vector_t constructor. It allows to
 * handle a regular C array as a \type igraph_vector_t temporarily.
 * Be sure that you \em don't ever call the destructor (\ref
 * igraph_vector_destroy()) on objects created by this constructor.
 * \param v Pointer to an uninitialized \type igraph_vector_t object.
 * \param data Pointer, the C array. It may not be \c NULL.
 * \param length The length of the C array.
 * \return Pointer to the vector object, the same as the
 *     \p v parameter, for convenience.
 *
 * Time complexity: O(1)
 */

const TYPE(igraph_vector)*FUNCTION(igraph_vector, view) (const TYPE(igraph_vector) *v,
        const BASE *data,
        long int length) {
    TYPE(igraph_vector) *v2 = (TYPE(igraph_vector)*)v;

    IGRAPH_ASSERT(data != 0);

    v2->stor_begin = (BASE*)data;
    v2->stor_end = (BASE*)data + length;
    v2->end = v2->stor_end;
    return v;
}

#ifndef BASE_COMPLEX

/**
 * \ingroup vector
 * \function igraph_vector_init_real
 * \brief Create an \type igraph_vector_t from the parameters.
 *
 * 
 * Because of how C and the C library handles variable length argument
 * lists, it is required that you supply real constants to this
 * function. This means that
 * \verbatim igraph_vector_t v;
 * igraph_vector_init_real(&v, 5, 1,2,3,4,5); \endverbatim
 * is an error at runtime and the results are undefined. This is
 * the proper way:
 * \verbatim igraph_vector_t v;
 * igraph_vector_init_real(&v, 5, 1.0,2.0,3.0,4.0,5.0); \endverbatim
 * \param v Pointer to an uninitialized \type igraph_vector_t object.
 * \param no Positive integer, the number of \type igraph_real_t
 *    parameters to follow.
 * \param ... The elements of the vector.
 * \return Error code, this can be \c IGRAPH_ENOMEM
 *     if there isn't enough memory to allocate the vector.
 *
 * \sa \ref igraph_vector_init_real_end(), \ref igraph_vector_init_int() for similar
 * functions.
 *
 * Time complexity: depends on the time required to allocate memory,
 * but at least O(n), the number of
 * elements in the vector.
 */

int FUNCTION(igraph_vector, init_real)(TYPE(igraph_vector) *v, int no, ...) {
    int i = 0;
    va_list ap;
    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(v, no));

    va_start(ap, no);
    for (i = 0; i < no; i++) {
        VECTOR(*v)[i] = (BASE) va_arg(ap, double);
    }
    va_end(ap);

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_init_real_end
 * \brief Create an \type igraph_vector_t from the parameters.
 *
 * 
 * This constructor is similar to \ref igraph_vector_init_real(), the only
 * difference is that instead of giving the number of elements in the
 * vector, a special marker element follows the last real vector
 * element.
 * \param v Pointer to an uninitialized \type igraph_vector_t object.
 * \param endmark This element will signal the end of the vector. It
 *    will \em not be part of the vector.
 * \param ... The elements of the vector.
 * \return Error code, \c IGRAPH_ENOMEM if there
 *    isn't enough memory.
 *
 * \sa \ref igraph_vector_init_real() and \ref igraph_vector_init_int_end() for
 * similar functions.
 *
 * Time complexity: at least O(n) for
 * n elements plus the time
 * complexity of the memory allocation.
 */

int FUNCTION(igraph_vector, init_real_end)(TYPE(igraph_vector) *v,
        double endmark, ...) {
    int i = 0, n = 0;
    va_list ap;

    va_start(ap, endmark);
    while (1) {
        BASE num = (BASE) va_arg(ap, double);
        if (num == endmark) {
            break;
        }
        n++;
    }
    va_end(ap);

    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(v, n));
    IGRAPH_FINALLY(FUNCTION(igraph_vector, destroy), v);

    va_start(ap, endmark);
    for (i = 0; i < n; i++) {
        VECTOR(*v)[i] = (BASE) va_arg(ap, double);
    }
    va_end(ap);

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_init_int
 * \brief Create an \type igraph_vector_t containing the parameters.
 *
 * 
 * This function is similar to \ref igraph_vector_init_real(), but it expects
 * \type int parameters. It is important that all parameters
 * should be of this type, otherwise the result of the function call
 * is undefined.
 * \param v Pointer to an uninitialized \type igraph_vector_t object.
 * \param no The number of \type int parameters to follow.
 * \param ... The elements of the vector.
 * \return Error code, \c IGRAPH_ENOMEM if there is
 *    not enough memory.
 * \sa \ref igraph_vector_init_real() and igraph_vector_init_int_end(), these are
 *    similar functions.
 *
 * Time complexity: at least O(n) for
 * n elements plus the time
 * complexity of the memory allocation.
 */

int FUNCTION(igraph_vector, init_int)(TYPE(igraph_vector) *v, int no, ...) {
    int i = 0;
    va_list ap;
    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(v, no));

    va_start(ap, no);
    for (i = 0; i < no; i++) {
        VECTOR(*v)[i] = (BASE) va_arg(ap, int);
    }
    va_end(ap);

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_init_int_end
 * \brief Create an \type igraph_vector_t from the parameters.
 *
 * 
 * This constructor is similar to \ref igraph_vector_init_int(), the only
 * difference is that instead of giving the number of elements in the
 * vector, a special marker element follows the last real vector
 * element.
 * \param v Pointer to an uninitialized \type igraph_vector_t object.
 * \param endmark This element will signal the end of the vector. It
 *    will \em not be part of the vector.
 * \param ... The elements of the vector.
 * \return Error code, \c IGRAPH_ENOMEM if there
 *    isn't enough memory.
 *
 * \sa \ref igraph_vector_init_int() and \ref igraph_vector_init_real_end() for
 * similar functions.
 *
 * Time complexity: at least O(n) for
 * n elements plus the time
 * complexity of the memory allocation.
 */

int FUNCTION(igraph_vector_init, int_end)(TYPE(igraph_vector) *v, int endmark, ...) {
    int i = 0, n = 0;
    va_list ap;

    va_start(ap, endmark);
    while (1) {
        int num = va_arg(ap, int);
        if (num == endmark) {
            break;
        }
        n++;
    }
    va_end(ap);

    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(v, n));
    IGRAPH_FINALLY(FUNCTION(igraph_vector, destroy), v);

    va_start(ap, endmark);
    for (i = 0; i < n; i++) {
        VECTOR(*v)[i] = (BASE) va_arg(ap, int);
    }
    va_end(ap);

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

#endif /* ifndef BASE_COMPLEX */

/**
 * \ingroup vector
 * \function igraph_vector_destroy
 * \brief Destroys a vector object.
 *
 * 
 * All vectors initialized by \ref igraph_vector_init() should be properly
 * destroyed by this function. A destroyed vector needs to be
 * reinitialized by \ref igraph_vector_init(), \ref igraph_vector_init_copy() or
 * another constructor.
 * \param v Pointer to the (previously initialized) vector object to
 *        destroy.
 *
 * Time complexity: operating system dependent.
 */

void FUNCTION(igraph_vector, destroy)   (TYPE(igraph_vector)* v) {
    IGRAPH_ASSERT(v != 0);
    if (v->stor_begin != 0) {
        IGRAPH_FREE(v->stor_begin);
        v->stor_begin = NULL;
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_capacity
 * \brief Returns the allocated capacity of the vector
 *
 * Note that this might be different from the size of the vector (as
 * queried by \ref igraph_vector_size(), and specifies how many elements
 * the vector can hold, without reallocation.
 * \param v Pointer to the (previously initialized) vector object
 *          to query.
 * \return The allocated capacity.
 *
 * \sa \ref igraph_vector_size().
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v) {
    return v->stor_end - v->stor_begin;
}

/**
 * \ingroup vector
 * \function igraph_vector_reserve
 * \brief Reserves memory for a vector.
 *
 * 
 * \a igraph vectors are flexible, they can grow and
 * shrink. Growing
 * however occasionally needs the data in the vector to be copied.
 * In order to avoid this, you can call this function to reserve space for
 * future growth of the vector.
 *
 * 
 * Note that this function does \em not change the size of the
 * vector. Let us see a small example to clarify things: if you
 * reserve space for 100 elements and the size of your
 * vector was (and still is) 60, then you can surely add additional 40
 * elements to your vector before it will be copied.
 * \param v The vector object.
 * \param size The new \em allocated size of the vector.
 * \return Error code:
 *         \c IGRAPH_ENOMEM if there is not enough memory.
 *
 * Time complexity: operating system dependent, should be around
 * O(n), n
 * is the new allocated size of the vector.
 */

int FUNCTION(igraph_vector, reserve)   (TYPE(igraph_vector)* v, long int size) {
    long int actual_size = FUNCTION(igraph_vector, size)(v);
    BASE *tmp;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (size <= actual_size) {
        return 0;
    }

    tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) size, BASE);
    if (tmp == 0) {
        IGRAPH_ERROR("cannot reserve space for vector", IGRAPH_ENOMEM);
    }
    v->stor_begin = tmp;
    v->stor_end = v->stor_begin + size;
    v->end = v->stor_begin + actual_size;

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_empty
 * \brief Decides whether the size of the vector is zero.
 *
 * \param v The vector object.
 * \return Non-zero number (true) if the size of the vector is zero and
 *         zero (false) otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t FUNCTION(igraph_vector, empty)     (const TYPE(igraph_vector)* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return v->stor_begin == v->end;
}

/**
 * \ingroup vector
 * \function igraph_vector_size
 * \brief Returns the size (=length) of the vector.
 *
 * \param v The vector object
 * \return The size of the vector.
 *
 * Time complexity: O(1).
 */

long int FUNCTION(igraph_vector, size)      (const TYPE(igraph_vector)* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return v->end - v->stor_begin;
}

/**
 * \ingroup vector
 * \function igraph_vector_clear
 * \brief Removes all elements from a vector.
 *
 * 
 * This function simply sets the size of the vector to zero, it does
 * not free any allocated memory. For that you have to call
 * \ref igraph_vector_destroy().
 * \param v The vector object.
 *
 * Time complexity: O(1).
 */

void FUNCTION(igraph_vector, clear)     (TYPE(igraph_vector)* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    v->end = v->stor_begin;
}

/**
 * \ingroup vector
 * \function igraph_vector_push_back
 * \brief Appends one element to a vector.
 *
 * 
 * This function resizes the vector to be one element longer and
 * sets the very last element in the vector to \p e.
 * \param v The vector object.
 * \param e The element to append to the vector.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: not enough memory.
 *
 * Time complexity: operating system dependent. What is important is that
 * a sequence of n
 * subsequent calls to this function has time complexity
 * O(n), even if there
 * hadn't been any space reserved for the new elements by
 * \ref igraph_vector_reserve(). This is implemented by a trick similar to the C++
 * \type vector class: each time more memory is allocated for a
 * vector, the size of the additionally allocated memory is the same
 * as the vector's current length. (We assume here that the time
 * complexity of memory allocation is at most linear.)
 */

int FUNCTION(igraph_vector, push_back) (TYPE(igraph_vector)* v, BASE e) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    /* full, allocate more storage */
    if (v->stor_end == v->end) {
        long int new_size = FUNCTION(igraph_vector, size)(v) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size));
    }

    *(v->end) = e;
    v->end += 1;

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_insert
 * \brief Inserts a single element into a vector.
 *
 * Note that this function does not do range checking. Insertion will shift the
 * elements from the position given to the end of the vector one position to the
 * right, and the new element will be inserted in the empty space created at
 * the given position. The size of the vector will increase by one.
 *
 * \param v The vector object.
 * \param pos The position where the new element is to be inserted.
 * \param value The new element to be inserted.
 */
int FUNCTION(igraph_vector, insert)(TYPE(igraph_vector) *v, long int pos,
                                    BASE value) {
    size_t size = (size_t) FUNCTION(igraph_vector, size)(v);
    if (pos < 0) {
        return IGRAPH_EINVAL;
    }
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(v, (long) size + 1));
    if (((unsigned long)pos) < size) {
        memmove(v->stor_begin + pos + 1, v->stor_begin + pos,
                sizeof(BASE) * (size - (size_t) pos));
    }
    v->stor_begin[pos] = value;
    return 0;
}

/**
 * \ingroup vector
 * \section igraph_vector_accessing_elements Accessing elements
 *
 * The simplest way to access an element of a vector is to use the
 * \ref VECTOR macro. This macro can be used both for querying and setting
 * \type igraph_vector_t elements. If you need a function, \ref
 * igraph_vector_e() queries and \ref igraph_vector_set() sets an element of a
 * vector. \ref igraph_vector_e_ptr() returns the address of an element.
 *
 * \ref igraph_vector_tail() returns the last element of a non-empty
 * vector. There is no igraph_vector_head() function
 * however, as it is easy to write VECTOR(v)[0]
 * instead.
 */

/**
 * \ingroup vector
 * \function igraph_vector_e
 * \brief Access an element of a vector.
 * \param v The \type igraph_vector_t object.
 * \param pos The position of the element, the index of the first
 *    element is zero.
 * \return The desired element.
 * \sa \ref igraph_vector_e_ptr() and the \ref VECTOR macro.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_vector, e)         (const TYPE(igraph_vector)* v, long int pos) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return * (v->stor_begin + pos);
}

/**
 * \ingroup vector
 * \function igraph_vector_e_ptr
 * \brief Get the address of an element of a vector
 * \param v The \type igraph_vector_t object.
 * \param pos The position of the element, the position of the first
 *   element is zero.
 * \return Pointer to the desired element.
 * \sa \ref igraph_vector_e() and the \ref VECTOR macro.
 *
 * Time complexity: O(1).
 */

BASE* FUNCTION(igraph_vector, e_ptr)  (const TYPE(igraph_vector)* v, long int pos) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return v->stor_begin + pos;
}

/**
 * \ingroup vector
 * \function igraph_vector_set
 * \brief Assignment to an element of a vector.
 * \param v The \type igraph_vector_t element.
 * \param pos Position of the element to set.
 * \param value New value of the element.
 * \sa \ref igraph_vector_e().
 */

void FUNCTION(igraph_vector, set)       (TYPE(igraph_vector)* v,
        long int pos, BASE value) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    *(v->stor_begin + pos) = value;
}

/**
 * \ingroup vector
 * \function igraph_vector_null
 * \brief Sets each element in the vector to zero.
 *
 * 
 * Note that \ref igraph_vector_init() sets the elements to zero as well, so
 * it makes no sense to call this function on a just initialized
 * vector. Thus if you want to construct a vector of zeros, then you should
 * use \ref igraph_vector_init().
 * \param v The vector object.
 *
 * Time complexity: O(n), the size of
 * the vector.
 */

void FUNCTION(igraph_vector, null)      (TYPE(igraph_vector)* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (FUNCTION(igraph_vector, size)(v) > 0) {
        memset(v->stor_begin, 0,
               sizeof(BASE) * (size_t) FUNCTION(igraph_vector, size)(v));
    }
}

/**
 * \function igraph_vector_fill
 * \brief Fill a vector with a constant element
 *
 * Sets each element of the vector to the supplied constant.
 * \param vector The vector to work on.
 * \param e The element to fill with.
 *
 * Time complexity: O(n), the size of the vector.
 */

void FUNCTION(igraph_vector, fill)      (TYPE(igraph_vector)* v, BASE e) {
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (ptr = v->stor_begin; ptr < v->end; ptr++) {
        *ptr = e;
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_tail
 * \brief Returns the last element in a vector.
 *
 * 
 * It is an error to call this function on an empty vector, the result
 * is undefined.
 * \param v The vector object.
 * \return The last element.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_vector, tail)(const TYPE(igraph_vector) *v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return *((v->end) - 1);
}

/**
 * \ingroup vector
 * \function igraph_vector_pop_back
 * \brief Removes and returns the last element of a vector.
 *
 * 
 * It is an error to call this function with an empty vector.
 * \param v The vector object.
 * \return The removed last element.
 *
 * Time complexity: O(1).
 */

BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector)* v) {
    BASE tmp;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->end != v->stor_begin);
    tmp = FUNCTION(igraph_vector, e)(v, FUNCTION(igraph_vector, size)(v) - 1);
    v->end -= 1;
    return tmp;
}

#ifndef NOTORDERED

/**
 * \ingroup vector
 * \function igraph_vector_sort_cmp
 * \brief Internal comparison function of vector elements, used by
 * \ref igraph_vector_sort().
 */

static int FUNCTION(igraph_vector, sort_cmp)(const void *a, const void *b) {
    const BASE *da = (const BASE *) a;
    const BASE *db = (const BASE *) b;

    return (*da > *db) - (*da < *db);
}

/**
 * \ingroup vector
 * \function igraph_vector_reverse_sort_cmp
 * \brief Internal comparison function of vector elements, used by
 * \ref igraph_vector_reverse_sort().
 */

static int FUNCTION(igraph_vector, reverse_sort_cmp)(const void *a, const void *b) {
    const BASE *da = (const BASE *) a;
    const BASE *db = (const BASE *) b;

    return (*da < *db) - (*da > *db);
}

/**
 * \ingroup vector
 * \function igraph_vector_sort
 * \brief Sorts the elements of the vector into ascending order.
 *
 * 
 * If the vector contains any NaN values, the resulting ordering of
 * NaN values is undefined and may appear anywhere in the vector.
 * \param v Pointer to an initialized vector object.
 *
 * Time complexity:
 * O(n log n) for n elements.
 */

void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    igraph_qsort(v->stor_begin, (size_t) FUNCTION(igraph_vector, size)(v),
                 sizeof(BASE), FUNCTION(igraph_vector, sort_cmp));
}

/**
 * \ingroup vector
 * \function igraph_vector_reverse_sort
 * \brief Sorts the elements of the vector into descending order.
 *
 * 
 * If the vector contains any NaN values, the resulting ordering of
 * NaN values is undefined and may appear anywhere in the vector.
 * \param v Pointer to an initialized vector object.
 *
 * Time complexity:
 * O(n log n) for n elements.
 */

void FUNCTION(igraph_vector, reverse_sort)(TYPE(igraph_vector) *v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    igraph_qsort(v->stor_begin, (size_t) FUNCTION(igraph_vector, size)(v),
                 sizeof(BASE), FUNCTION(igraph_vector, reverse_sort_cmp));
}

/**
 * Ascending comparison function passed to qsort from  igraph_vector_qsort_ind
 */
static int FUNCTION(igraph_vector, i_qsort_ind_cmp_asc)(const void *p1, const void *p2) {
    BASE **pa = (BASE **) p1;
    BASE **pb = (BASE **) p2;
    if ( **pa < **pb ) {
        return -1;
    }
    if ( **pa > **pb) {
        return 1;
    }
    return 0;
}

/**
 * Descending comparison function passed to qsort from  igraph_vector_qsort_ind
 */
static int FUNCTION(igraph_vector, i_qsort_ind_cmp_desc)(const void *p1, const void *p2) {
    BASE **pa = (BASE **) p1;
    BASE **pb = (BASE **) p2;
    if ( **pa < **pb ) {
        return 1;
    }
    if ( **pa > **pb) {
        return -1;
    }
    return 0;
}

/**
 * \function igraph_vector_qsort_ind
 * \brief Return a permutation of indices that sorts a vector
 *
 * Takes an unsorted array \c v as input and computes an array of
 * indices inds such that v[ inds[i] ], with i increasing from 0, is
 * an ordered array (either ascending or descending, depending on
 * \v order). The order of indices for identical elements is not
 * defined. If the vector contains any NaN values, the ordering of
 * NaN values is undefined.
 *
 * \param v the array to be sorted
 * \param inds the output array of indices. This must be initialized,
 *         but will be resized
 * \param descending whether the output array should be sorted in descending
 *        order.
 * \return Error code.
 *
 * This routine uses igraph's built-in qsort routine.
 * Algorithm: 1) create an array of pointers to the elements of v. 2)
 * Pass this array to qsort. 3) after sorting the difference between
 * the pointer value and the first pointer value gives its original
 * position in the array. Use this to set the values of inds.
 */

long int FUNCTION(igraph_vector, qsort_ind)(TYPE(igraph_vector) *v,
        igraph_vector_t *inds, igraph_bool_t descending) {
    unsigned long int i;
    BASE **vind, *first;
    size_t n = (size_t) FUNCTION(igraph_vector, size)(v);
    IGRAPH_CHECK(igraph_vector_resize(inds, (long) n));
    if (n == 0) {
        return 0;
    }
    vind = IGRAPH_CALLOC(n, BASE*);
    if (vind == 0) {
        IGRAPH_ERROR("igraph_vector_qsort_ind failed", IGRAPH_ENOMEM);
    }
    for (i = 0; i < n; i++) {
        vind[i] = &VECTOR(*v)[i];
    }
    first = vind[0];
    if (descending) {
        igraph_qsort(vind, n, sizeof(BASE**), FUNCTION(igraph_vector, i_qsort_ind_cmp_desc));
    } else {
        igraph_qsort(vind, n, sizeof(BASE**), FUNCTION(igraph_vector, i_qsort_ind_cmp_asc));
    }
    for (i = 0; i < n; i++) {
        VECTOR(*inds)[i] = vind[i] - first;
    }
    IGRAPH_FREE(vind);
    return 0;
}

/**
 * \function igraph_vector_lex_cmp
 * \brief Lexicographical comparison of two vectors.
 *
 * 
 * If the elements of two vectors match but one is shorter, the shorter
 * one comes first. Thus {1, 3} comes after {1, 2, 3}, but before {1, 3, 4}.
 *
 * 
 * This function is typically used together with \ref igraph_vector_ptr_sort().
 *
 * \param lhs Pointer to a pointer to the first vector (interpreted as an igraph_vector_t **).
 * \param rhs Pointer to a pointer to the second vector (interpreted as an igraph_vector_t **).
 * \return -1 if \p lhs is lexicographically smaller,
 *         0 if \p lhs and \p rhs are equal, else 1.
 * \sa \ref igraph_vector_colex_cmp() to compare vectors starting from
 *     the last element.
 *
 * Time complexity: O(n), the number of elements in the smaller vector.
 *
 * \example examples/simple/igraph_vector_ptr_sort.c
 */
int FUNCTION(igraph_vector, lex_cmp)(const void *lhs, const void *rhs) {
    const TYPE(igraph_vector) *a = * (TYPE(igraph_vector) **) lhs;
    const TYPE(igraph_vector) *b = * (TYPE(igraph_vector) **) rhs;
    long int i, sa, sb;

    sa = FUNCTION(igraph_vector, size)(a);
    sb = FUNCTION(igraph_vector, size)(b);

    for (i = 0; i < sa; i++) {
        if (i >= sb) {
            /* b is shorter, and equal to the first part of a */
            return 1;
        }
        if (VECTOR(*a)[i] < VECTOR(*b)[i]) {
            return -1;
        }
        if (VECTOR(*a)[i] > VECTOR(*b)[i]) {
            return 1;
        }
    }
    if (i == sb) {
        return 0;
    }
    /* a is shorter, and equal to the first part of b */
    return -1;
}

/**
 * \function igraph_vector_colex_cmp
 * \brief Colexicographical comparison of two vectors.
 *
 * 
 * This comparison starts from the last element of both vectors and
 * moves backward. If the elements of two vectors match but one is
 * shorter, the shorter one comes first. Thus {1, 2} comes after {3, 2, 1},
 * but before {0, 1, 2}.
 *
 * 
 * This function is typically used together with \ref igraph_vector_ptr_sort().
 *
 * \param lhs Pointer to a pointer to the first vector (interpreted as an igraph_vector_t **).
 * \param rhs Pointer to a pointer to the second vector (interpreted as an igraph_vector_t **).
 * \return -1 if \p lhs in reverse order is
 *         lexicographically smaller than the reverse of \p rhs,
 *         0 if \p lhs and \p rhs are equal, else 1.
 * \sa \ref igraph_vector_lex_cmp() to compare vectors starting from
 *     the first element.
 *
 * Time complexity: O(n), the number of elements in the smaller vector.
 *
 * \example examples/simple/igraph_vector_ptr_sort.c
 */
int FUNCTION(igraph_vector, colex_cmp)(const void *lhs, const void *rhs) {
    const TYPE(igraph_vector) *a = * (TYPE(igraph_vector) **) lhs;
    const TYPE(igraph_vector) *b = * (TYPE(igraph_vector) **) rhs;
    long int i, sa, sb, rai, rbi;

    sa = FUNCTION(igraph_vector, size)(a);
    sb = FUNCTION(igraph_vector, size)(b);

    for (i = 0; i < sa; i++) {
        if (i >= sb) {
            /* b is shorter, and equal to the last part of a */
            return 1;
        }
        /* use reversed indexes */
        rai = sa - i - 1;
        rbi = sb - i - 1;
        if (VECTOR(*a)[rai] < VECTOR(*b)[rbi]) {
            return -1;
        }
        if (VECTOR(*a)[rai] > VECTOR(*b)[rbi]) {
            return 1;
        }
    }
    if (i == sb) {
        return 0;
    }
    /* a is shorter, and equal to the last part of b */
    return -1;
}
#endif /*NOTORDERED*/

/**
 * \ingroup vector
 * \function igraph_vector_resize
 * \brief Resize the vector.
 *
 * 
 * Note that this function does not free any memory, just sets the
 * size of the vector to the given one. It can on the other hand
 * allocate more memory if the new size is larger than the previous
 * one. In this case the newly appeared elements in the vector are
 * \em not set to zero, they are uninitialized.
 * \param v The vector object
 * \param newsize The new size of the vector.
 * \return Error code,
 *         \c IGRAPH_ENOMEM if there is not enough
 *         memory. Note that this function \em never returns an error
 *         if the vector is made smaller.
 * \sa \ref igraph_vector_reserve() for allocating memory for future
 * extensions of a vector. \ref igraph_vector_resize_min() for
 * deallocating the unnneded memory for a vector.
 *
 * Time complexity: O(1) if the new
 * size is smaller, operating system dependent if it is larger. In the
 * latter case it is usually around
 * O(n),
 * n is the new size of the vector.
 */

int FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, long int newsize) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, newsize));
    v->end = v->stor_begin + newsize;
    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_resize_min
 * \brief Deallocate the unused memory of a vector.
 *
 * 
 * Note that this function involves additional memory allocation and
 * may result an out-of-memory error.
 * \param v Pointer to an initialized vector.
 * \return Error code.
 *
 * \sa \ref igraph_vector_resize(), \ref igraph_vector_reserve().
 *
 * Time complexity: operating system dependent.
 */

int FUNCTION(igraph_vector, resize_min)(TYPE(igraph_vector)*v) {
    size_t size;
    BASE *tmp;
    if (v->stor_end == v->end) {
        return 0;
    }

    size = (size_t) (v->end - v->stor_begin);
    tmp = IGRAPH_REALLOC(v->stor_begin, size, BASE);
    if (tmp == 0) {
        IGRAPH_ERROR("cannot resize vector", IGRAPH_ENOMEM);
    } else {
        v->stor_begin = tmp;
        v->stor_end = v->end = v->stor_begin + size;
    }

    return 0;
}

#ifndef NOTORDERED

/* We will use x != x for NaN checks below and Clang does not like it unless
 * we disable a warning */

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wtautological-compare"
#endif

/**
 * \ingroup vector
 * \function igraph_vector_max
 * \brief Largest element of a vector.
 *
 * 
 * If the size of the vector is zero, an arbitrary number is
 * returned.
 * \param v The vector object.
 * \return The maximum element of \p v, or NaN if any element is NaN.
 *
 * Time complexity: O(n), the number of elements.
 */
BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector)* v) {
    BASE max;
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->stor_begin != v->end);
    max = *(v->stor_begin);
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
    if (igraph_is_nan(max)) { return max; }; /* Result is NaN */
#endif
    ptr = v->stor_begin + 1;
    while (ptr < v->end) {
        if ((*ptr) > max) {
            max = *ptr;
        }
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        else if (igraph_is_nan(*ptr))
            return *ptr; /* Result is NaN */
#endif
        ptr++;
    }
    return max;
}


/**
 * \ingroup vector
 * \function igraph_vector_which_max
 * \brief Gives the index of the maximum element of the vector.
 *
 * 
 * If the size of the vector is zero, -1 is returned. If the largest
 * element is not unique, then the index of the first is returned.
 * If the vector contains NaN values, the index of the first NaN value
 * is returned.
 * \param v The vector object.
 * \return The index of the first maximum element.
 *
 * Time complexity: O(n), n is the size of the vector.
 */
long int FUNCTION(igraph_vector, which_max)(const TYPE(igraph_vector)* v) {
    if (!FUNCTION(igraph_vector, empty)(v)) {
        BASE *max;
        BASE *ptr;
        IGRAPH_ASSERT(v != NULL);
        IGRAPH_ASSERT(v->stor_begin != NULL);
        IGRAPH_ASSERT(v->stor_begin != v->end);
        max = ptr = v->stor_begin;
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        if (igraph_is_nan(*ptr)) { return ptr - v->stor_begin; } /* Result is NaN */
#endif
        ptr++;
        while (ptr < v->end) {
            if (*ptr > *max) {
                max = ptr;
            }
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
            else if (igraph_is_nan(*ptr)) {
                return ptr - v->stor_begin; /* Result is NaN */
            }
#endif
            ptr++;
        }
        return max - v->stor_begin;
    }
    return -1;
}

/**
 * \ingroup vector
 * \function igraph_vector_min
 * \brief Smallest element of a vector.
 *
 * The vector must be non-empty.
 * \param v The input vector.
 * \return The smallest element of \p v, or NaN if any element is NaN.
 *
 * Time complexity: O(n), the number of elements.
 */

BASE FUNCTION(igraph_vector, min)(const TYPE(igraph_vector)* v) {
    BASE min;
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->stor_begin != v->end);
    min = *(v->stor_begin);
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
    if (igraph_is_nan(min)) { return min; }; /* Result is NaN */
#endif
    ptr = v->stor_begin + 1;
    while (ptr < v->end) {
        if ((*ptr) < min) {
            min = *ptr;
        }
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        else if (igraph_is_nan(*ptr)) {
            return *ptr; /* Result is NaN */
        }
#endif
        ptr++;
    }
    return min;
}

/**
 * \ingroup vector
 * \function igraph_vector_which_min
 * \brief Index of the smallest element.
 *
 * 
 * The vector must be non-empty. If the smallest element is not unique,
 * then the index of the first is returned. If the vector contains NaN
 * values, the index of the first NaN value is returned.
 * \param v The input vector.
 * \return Index of the smallest element.
 *
 * Time complexity: O(n), the number of elements.
 */
long int FUNCTION(igraph_vector, which_min)(const TYPE(igraph_vector)* v) {
    if (!FUNCTION(igraph_vector, empty)(v)) {
        BASE *min;
        BASE *ptr;
        IGRAPH_ASSERT(v != NULL);
        IGRAPH_ASSERT(v->stor_begin != NULL);
        IGRAPH_ASSERT(v->stor_begin != v->end);
        min = ptr = v->stor_begin;
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        if (igraph_is_nan(*ptr)) { return ptr - v->stor_begin; } /* Result is NaN */
#endif
        ptr++;
        while (ptr < v->end) {
            if (*ptr < *min) {
                min = ptr;
            }
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
            else if (igraph_is_nan(*ptr)) {
                return ptr - v->stor_begin; /* Result is NaN */
            }
#endif
            ptr++;
        }
        return min - v->stor_begin;
    }
    return -1;
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif

/**
 * \ingroup vector
 * \function igraph_vector_init_copy
 * \brief Initializes a vector from an ordinary C array (constructor).
 *
 * \param v Pointer to an uninitialized vector object.
 * \param data A regular C array.
 * \param length The length of the C array.
 * \return Error code:
 *         \c IGRAPH_ENOMEM if there is not enough memory.
 *
 * Time complexity: operating system specific, usually
 * O(\p length).
 */

int FUNCTION(igraph_vector, init_copy)(TYPE(igraph_vector) *v,
                                       const BASE *data, long int length) {
    v->stor_begin = IGRAPH_CALLOC(length, BASE);
    if (v->stor_begin == 0) {
        IGRAPH_ERROR("cannot init vector from array", IGRAPH_ENOMEM);
    }
    v->stor_end = v->stor_begin + length;
    v->end = v->stor_end;
    memcpy(v->stor_begin, data, (size_t) length * sizeof(BASE));

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_copy_to
 * \brief Copies the contents of a vector to a C array.
 *
 * 
 * The C array should have sufficient length.
 * \param v The vector object.
 * \param to The C array.
 *
 * Time complexity: O(n),
 * n is the size of the vector.
 */

void FUNCTION(igraph_vector, copy_to)(const TYPE(igraph_vector) *v, BASE *to) {

    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (v->end != v->stor_begin) {
        memcpy(to, v->stor_begin, sizeof(BASE) * (size_t) (v->end - v->stor_begin));
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_copy
 * \brief Initializes a vector from another vector object (constructor).
 *
 * 
 * The contents of the existing vector object will be copied to
 * the new one.
 * \param to Pointer to a not yet initialized vector object.
 * \param from The original vector object to copy.
 * \return Error code:
 *         \c IGRAPH_ENOMEM if there is not enough memory.
 *
 * Time complexity: operating system dependent, usually
 * O(n),
 * n is the size of the vector.
 */

int FUNCTION(igraph_vector, copy)(TYPE(igraph_vector) *to,
                                  const TYPE(igraph_vector) *from) {
    long int from_size;

    IGRAPH_ASSERT(from != NULL);
    IGRAPH_ASSERT(from->stor_begin != NULL);

    from_size = FUNCTION(igraph_vector, size)(from);
    to->stor_begin = IGRAPH_CALLOC(from_size, BASE);
    if (to->stor_begin == 0) {
        IGRAPH_ERROR("cannot copy vector", IGRAPH_ENOMEM);
    }
    to->stor_end = to->stor_begin + FUNCTION(igraph_vector, size)(from);
    to->end = to->stor_end;
    memcpy(to->stor_begin, from->stor_begin,
           (size_t) FUNCTION(igraph_vector, size)(from) * sizeof(BASE));

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_sum
 * \brief Calculates the sum of the elements in the vector.
 *
 * 
 * For the empty vector 0.0 is returned.
 * \param v The vector object.
 * \return The sum of the elements.
 *
 * Time complexity: O(n), the size of
 * the vector.
 */

BASE FUNCTION(igraph_vector, sum)(const TYPE(igraph_vector) *v) {
    BASE res = ZERO;
    BASE *p;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (p = v->stor_begin; p < v->end; p++) {
#ifdef SUM
        SUM(res, res, *p);
#else
        res += *p;
#endif
    }
    return res;
}

igraph_real_t FUNCTION(igraph_vector, sumsq)(const TYPE(igraph_vector) *v) {
    igraph_real_t res = 0.0;
    BASE *p;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (p = v->stor_begin; p < v->end; p++) {
#ifdef SQ
        res += SQ(*p);
#else
        res += (*p) * (*p);
#endif
    }
    return res;
}

/**
 * \ingroup vector
 * \function igraph_vector_prod
 * \brief Calculates the product of the elements in the vector.
 *
 * 
 * For the empty vector one (1) is returned.
 * \param v The vector object.
 * \return The product of the elements.
 *
 * Time complexity: O(n), the size of
 * the vector.
 */

BASE FUNCTION(igraph_vector, prod)(const TYPE(igraph_vector) *v) {
    BASE res = ONE;
    BASE *p;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (p = v->stor_begin; p < v->end; p++) {
#ifdef PROD
        PROD(res, res, *p);
#else
        res *= *p;
#endif
    }
    return res;
}

/**
 * \ingroup vector
 * \function igraph_vector_cumsum
 * \brief Calculates the cumulative sum of the elements in the vector.
 *
 * 
 * \param to An initialized vector object that will store the cumulative
 *           sums. Element i of this vector will store the sum of the elements
 *           of the 'from' vector, up to and including element i.
 * \param from The input vector.
 * \return Error code.
 *
 * Time complexity: O(n), the size of the vector.
 */

int FUNCTION(igraph_vector, cumsum)(TYPE(igraph_vector) *to,
                                    const TYPE(igraph_vector) *from) {
    BASE res = ZERO;
    BASE *p, *p2;

    IGRAPH_ASSERT(from != NULL);
    IGRAPH_ASSERT(from->stor_begin != NULL);
    IGRAPH_ASSERT(to != NULL);
    IGRAPH_ASSERT(to->stor_begin != NULL);

    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, FUNCTION(igraph_vector, size)(from)));

    for (p = from->stor_begin, p2 = to->stor_begin; p < from->end; p++, p2++) {
#ifdef SUM
        SUM(res, res, *p);
#else
        res += *p;
#endif
        *p2 = res;
    }

    return 0;
}

#ifndef NOTORDERED

/**
 * \ingroup vector
 * \function igraph_vector_init_seq
 * \brief Initializes a vector with a sequence.
 *
 * 
 * The vector will contain the numbers \p from,
 * \p from+1, ..., \p to.
 * \param v Pointer to an uninitialized vector object.
 * \param from The lower limit in the sequence (inclusive).
 * \param to The upper limit in the sequence (inclusive).
 * \return Error code:
 *         \c IGRAPH_ENOMEM: out of memory.
 *
 * Time complexity: O(n), the number
 * of elements in the vector.
 */

int FUNCTION(igraph_vector, init_seq)(TYPE(igraph_vector) *v,
                                      BASE from, BASE to) {
    BASE *p;
    IGRAPH_CHECK(FUNCTION(igraph_vector, init)(v, (long int) (to - from + 1)));

    for (p = v->stor_begin; p < v->end; p++) {
        *p = from++;
    }

    return 0;
}

#endif

/**
 * \ingroup vector
 * \function igraph_vector_remove_section
 * \brief Deletes a section from a vector.
 *
 * 
 * Note that this function does not do range checking. The result is
 * undefined if you supply invalid limits.
 * \param v The vector object.
 * \param from The position of the first element to remove.
 * \param to The position of the first element \em not to remove.
 *
 * Time complexity: O(n-from),
 * n is the number of elements in the
 * vector.
 */

void FUNCTION(igraph_vector, remove_section)(TYPE(igraph_vector) *v,
        long int from, long int to) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    /* Not removing from the end? */
    if (to < FUNCTION(igraph_vector, size)(v)) {
        memmove(v->stor_begin + from, v->stor_begin + to,
                sizeof(BASE) * (size_t) (v->end - v->stor_begin - to));
    }
    v->end -= (to - from);
}

/**
 * \ingroup vector
 * \function igraph_vector_remove
 * \brief Removes a single element from a vector.
 *
 * Note that this function does not do range checking.
 * \param v The vector object.
 * \param elem The position of the element to remove.
 *
 * Time complexity: O(n-elem),
 * n is the number of elements in the
 * vector.
 */

void FUNCTION(igraph_vector, remove)(TYPE(igraph_vector) *v, long int elem) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    FUNCTION(igraph_vector, remove_section)(v, elem, elem + 1);
}

/**
 * \ingroup vector
 * \function igraph_vector_move_interval
 * \brief Copies a section of a vector.
 *
 * 
 * The result of this function is undefined if the source and target
 * intervals overlap.
 * \param v The vector object.
 * \param begin The position of the first element to move.
 * \param end The position of the first element \em not to move.
 * \param to The target position.
 * \return Error code, the current implementation always returns with
 *    success.
 *
 * Time complexity: O(end-begin).
 */

int FUNCTION(igraph_vector, move_interval)(TYPE(igraph_vector) *v,
        long int begin, long int end,
        long int to) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    memcpy(v->stor_begin + to, v->stor_begin + begin,
           sizeof(BASE) * (size_t) (end - begin));

    return 0;
}

int FUNCTION(igraph_vector, move_interval2)(TYPE(igraph_vector) *v,
        long int begin, long int end,
        long int to) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    memmove(v->stor_begin + to, v->stor_begin + begin,
            sizeof(BASE) * (size_t) (end - begin));

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_permdelete
 * \brief Remove elements of a vector (for internal use).
 */

void FUNCTION(igraph_vector, permdelete)(TYPE(igraph_vector) *v,
        const igraph_vector_t *index, long int nremove) {
    long int i, n;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    n = FUNCTION(igraph_vector, size)(v);
    for (i = 0; i < n; i++) {
        if (VECTOR(*index)[i] != 0) {
            VECTOR(*v)[ (long int)VECTOR(*index)[i] - 1 ] = VECTOR(*v)[i];
        }
    }
    v->end -= nremove;
}

#ifndef NOTORDERED

/**
 * \ingroup vector
 * \function igraph_vector_isininterval
 * \brief Checks if all elements of a vector are in the given
 * interval.
 *
 * \param v The vector object.
 * \param low The lower limit of the interval (inclusive).
 * \param high The higher limit of the interval (inclusive).
 * \return True (positive integer) if all vector elements are in the
 *   interval, false (zero) otherwise. If any element is NaN, it will
 *   return \c 0 (=false).
 *
 * Time complexity: O(n), the number
 * of elements in the vector.
 */

igraph_bool_t FUNCTION(igraph_vector, isininterval)(const TYPE(igraph_vector) *v,
        BASE low,
        BASE high) {
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (ptr = v->stor_begin; ptr < v->end; ptr++) {
        if (!(*ptr >= low && *ptr <= high)) {
            return 0;
        }
    }
    return 1;
}

/**
 * \ingroup vector
 * \function igraph_vector_any_smaller
 * \brief Checks if any element of a vector is smaller than a limit.
 *
 * \param v The \type igraph_vector_t object.
 * \param limit The limit.
 * \return True (positive integer) if the vector contains at least one
 *   smaller element than \p limit, false (zero)
 *   otherwise.
 *
 * Time complexity: O(n), the number
 * of elements in the vector.
 */

igraph_bool_t FUNCTION(igraph_vector, any_smaller)(const TYPE(igraph_vector) *v,
        BASE limit) {
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    for (ptr = v->stor_begin; ptr < v->end; ptr++) {
        if (*ptr < limit) {
            return 1;
        }
    }
    return 0;
}

#endif

/**
 * \ingroup vector
 * \function igraph_vector_all_e
 * \brief Are all elements equal?
 *
 * \param lhs The first vector.
 * \param rhs The second vector.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    equal to the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the lengths of the vectors don't match.
 *
 * Time complexity: O(n), the length of the vectors.
 */

igraph_bool_t FUNCTION(igraph_vector, all_e)(const TYPE(igraph_vector) *lhs,
        const TYPE(igraph_vector) *rhs) {
    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = FUNCTION(igraph_vector, size)(lhs);
    if (s != FUNCTION(igraph_vector, size)(rhs)) {
        return 0;
    } else {
        for (i = 0; i < s; i++) {
            BASE l = VECTOR(*lhs)[i];
            BASE r = VECTOR(*rhs)[i];
#ifdef EQ
            if (!EQ(l, r)) {
#else
            if (l != r) {
#endif
                return 0;
            }
        }
        return 1;
    }
}

igraph_bool_t
FUNCTION(igraph_vector, is_equal)(const TYPE(igraph_vector) *lhs,
                                  const TYPE(igraph_vector) *rhs) {
    return FUNCTION(igraph_vector, all_e)(lhs, rhs);
}

#ifndef NOTORDERED

/**
 * \ingroup vector
 * \function igraph_vector_all_l
 * \brief Are all elements less?
 *
 * \param lhs The first vector.
 * \param rhs The second vector.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    less than the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the lengths of the vectors don't match. If any element
 *    is NaN, it will return \c 0 (=false).
 *
 * Time complexity: O(n), the length of the vectors.
 */

igraph_bool_t FUNCTION(igraph_vector, all_l)(const TYPE(igraph_vector) *lhs,
        const TYPE(igraph_vector) *rhs) {
    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = FUNCTION(igraph_vector, size)(lhs);
    if (s != FUNCTION(igraph_vector, size)(rhs)) {
        return 0;
    } else {
        for (i = 0; i < s; i++) {
            BASE l = VECTOR(*lhs)[i];
            BASE r = VECTOR(*rhs)[i];
            if (l >= r) {
                return 0;
            }
        }
        return 1;
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_all_g
 * \brief Are all elements greater?
 *
 * \param lhs The first vector.
 * \param rhs The second vector.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    greater than the corresponding elements in \p rhs. Returns \c 0
 *    (=false) if the lengths of the vectors don't match. If any element
 *    is NaN, it will return \c 0 (=false).
 *
 * Time complexity: O(n), the length of the vectors.
 */

igraph_bool_t FUNCTION(igraph_vector, all_g)(const TYPE(igraph_vector) *lhs,
        const TYPE(igraph_vector) *rhs) {

    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = FUNCTION(igraph_vector, size)(lhs);
    if (s != FUNCTION(igraph_vector, size)(rhs)) {
        return 0;
    } else {
        for (i = 0; i < s; i++) {
            BASE l = VECTOR(*lhs)[i];
            BASE r = VECTOR(*rhs)[i];
            if (l <= r) {
                return 0;
            }
        }
        return 1;
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_all_le
 * \brief Are all elements less or equal?
 *
 * \param lhs The first vector.
 * \param rhs The second vector.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    less than or equal to the corresponding elements in \p
 *    rhs. Returns \c 0 (=false) if the lengths of the vectors don't
 *    match. If any element is NaN, it will return \c 0 (=false).
 *
 * Time complexity: O(n), the length of the vectors.
 */

igraph_bool_t
FUNCTION(igraph_vector, all_le)(const TYPE(igraph_vector) *lhs,
                                const TYPE(igraph_vector) *rhs) {
    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = FUNCTION(igraph_vector, size)(lhs);
    if (s != FUNCTION(igraph_vector, size)(rhs)) {
        return 0;
    } else {
        for (i = 0; i < s; i++) {
            BASE l = VECTOR(*lhs)[i];
            BASE r = VECTOR(*rhs)[i];
            if (l > r) {
                return 0;
            }
        }
        return 1;
    }
}

/**
 * \ingroup vector
 * \function igraph_vector_all_ge
 * \brief Are all elements greater or equal?
 *
 * \param lhs The first vector.
 * \param rhs The second vector.
 * \return Positive integer (=true) if the elements in the \p lhs are all
 *    greater than or equal to the corresponding elements in \p
 *    rhs. Returns \c 0 (=false) if the lengths of the vectors don't
 *    match.  If any element is NaN, it will return \c 0 (=false).
 *
 * Time complexity: O(n), the length of the vectors.
 */

igraph_bool_t
FUNCTION(igraph_vector, all_ge)(const TYPE(igraph_vector) *lhs,
                                const TYPE(igraph_vector) *rhs) {
    long int i, s;
    IGRAPH_ASSERT(lhs != 0);
    IGRAPH_ASSERT(rhs != 0);
    IGRAPH_ASSERT(lhs->stor_begin != 0);
    IGRAPH_ASSERT(rhs->stor_begin != 0);

    s = FUNCTION(igraph_vector, size)(lhs);
    if (s != FUNCTION(igraph_vector, size)(rhs)) {
        return 0;
    } else {
        for (i = 0; i < s; i++) {
            BASE l = VECTOR(*lhs)[i];
            BASE r = VECTOR(*rhs)[i];
            if (l < r) {
                return 0;
            }
        }
        return 1;
    }
}

#endif


#ifndef NOTORDERED

igraph_bool_t FUNCTION(igraph_i_vector, binsearch_slice)(const TYPE(igraph_vector) *v,
        BASE what, long int *pos,
        long int start, long int end);

/**
 * \ingroup vector
 * \function igraph_vector_binsearch
 * \brief Finds an element by binary searching a sorted vector.
 *
 * 
 * It is assumed that the vector is sorted. If the specified element
 * (\p what) is not in the vector, then the
 * position of where it should be inserted (to keep the vector sorted)
 * is returned. If the vector contains any NaN values, the returned
 * value is undefined and \p pos may point to any position.
 * \param v The \type igraph_vector_t object.
 * \param what The element to search for.
 * \param pos Pointer to a \type long int. This is set to the
 *   position of an instance of \p what in the
 *   vector if it is present. If \p v does not
 *   contain \p what then
 *   \p pos is set to the position to which it
 *   should be inserted (to keep the the vector sorted of course).
 * \return Positive integer (true) if \p what is
 *   found in the vector, zero (false) otherwise.
 *
 * Time complexity: O(log(n)),
 * n is the number of elements in
 * \p v.
 */

igraph_bool_t FUNCTION(igraph_vector, binsearch)(const TYPE(igraph_vector) *v,
        BASE what, long int *pos) {
    return FUNCTION(igraph_i_vector, binsearch_slice)(v, what, pos,
            0, FUNCTION(igraph_vector, size)(v));
}

/**
 * \ingroup vector
 * \function igraph_vector_binsearch_slice
 * \brief Finds an element by binary searching a sorted slice of a vector.
 *
 * 

 * It is assumed that the indicated slice of the vector, from \p start to \p end,
 * is sorted. If the specified element (\p what) is not in the slice of the
 * vector, then the position of where it should be inserted (to keep the vector
 * sorted) is returned. If the indicated slice contains any NaN values, the
 * returned value is undefined and \c pos may point to any position within
 * the slice.
 * \param v The \type igraph_vector_t object.
 * \param what The element to search for.
 * \param pos Pointer to a \type long int. This is set to the position of an
 *        instance of \p what in the slice of the vector if it is present. If \p
 *        v does not contain \p what then \p pos is set to the position to which
 *        it should be inserted (to keep the the vector sorted).
 * \param start The start position of the slice to search (inclusive).
 * \param end The end position of the slice to search (exclusive).
 * \return Positive integer (true) if \p what is found in the vector,
 *         zero (false) otherwise.
 *
 * Time complexity: O(log(n)),
 * n is the number of elements in the slice of \p v, i.e. \p end - \p start.
 */

igraph_bool_t FUNCTION(igraph_vector, binsearch_slice)(const TYPE(igraph_vector) *v,
        BASE what, long int *pos,
        long int start, long int end) {
    long int left  = start;
    long int right = end - 1;

    if (left < 0)
        IGRAPH_ERROR("Invalid start position.", IGRAPH_EINVAL);

    if (right >= FUNCTION(igraph_vector, size)(v))
        IGRAPH_ERROR("Invalid end position.", IGRAPH_EINVAL);

    if (left > right)
        IGRAPH_ERROR("Invalid slice, start position must be smaller than end position.",
                     IGRAPH_EINVAL);

    return FUNCTION(igraph_i_vector, binsearch_slice)(v, what, pos, start, end);
}

igraph_bool_t FUNCTION(igraph_i_vector, binsearch_slice)(const TYPE(igraph_vector) *v,
        BASE what, long int *pos,
        long int start, long int end) {
    long int left  = start;
    long int right = end - 1;

    while (left <= right) {
        /* (right + left) / 2 could theoretically overflow for long vectors */
        long int middle = left + ((right - left) >> 1);
        if (VECTOR(*v)[middle] > what) {
            right = middle - 1;
        } else if (VECTOR(*v)[middle] < what) {
            left = middle + 1;
        } else {
            if (pos != 0) {
                *pos = middle;
            }
            return 1;
        }
    }

    /* if we are here, the element was not found */
    if (pos != 0) {
        *pos = left;
    }

    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_binsearch2
 * \brief Binary search, without returning the index.
 *
 * 
 * It is assumed that the vector is sorted.
 * \param v The \type igraph_vector_t object.
 * \param what The element to search for.
 * \return Positive integer (true) if \p what is
 *   found in the vector, zero (false) otherwise.
 *
 * Time complexity: O(log(n)),
 * n is the number of elements in
 * \p v.
 */

igraph_bool_t FUNCTION(igraph_vector, binsearch2)(const TYPE(igraph_vector) *v,
        BASE what) {
    long int left = 0;
    long int right = FUNCTION(igraph_vector, size)(v) - 1;

    while (left <= right) {
        /* (right + left) / 2 could theoretically overflow for long vectors */
        long int middle = left + ((right - left) >> 1);
        if (what < VECTOR(*v)[middle]) {
            right = middle - 1;
        } else if (what > VECTOR(*v)[middle]) {
            left = middle + 1;
        } else {
            return 1;
        }
    }

    return 0;
}

#endif

/**
 * \function igraph_vector_scale
 * \brief Multiply all elements of a vector by a constant
 *
 * \param v The vector.
 * \param by The constant.
 * \return Error code. The current implementation always returns with success.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(n), the number of elements in a vector.
 */

void FUNCTION(igraph_vector, scale)(TYPE(igraph_vector) *v, BASE by) {
    long int i;
    for (i = 0; i < FUNCTION(igraph_vector, size)(v); i++) {
#ifdef PROD
        PROD(VECTOR(*v)[i], VECTOR(*v)[i], by);
#else
        VECTOR(*v)[i] *= by;
#endif
    }
}

/**
 * \function igraph_vector_add_constant
 * \brief Add a constant to the vector.
 *
 * \p plus is added to every element of \p v. Note that overflow
 * might happen.
 * \param v The input vector.
 * \param plus The constant to add.
 *
 * Time complexity: O(n), the number of elements.
 */

void FUNCTION(igraph_vector, add_constant)(TYPE(igraph_vector) *v, BASE plus) {
    long int i, n = FUNCTION(igraph_vector, size)(v);
    for (i = 0; i < n; i++) {
#ifdef SUM
        SUM(VECTOR(*v)[i], VECTOR(*v)[i], plus);
#else
        VECTOR(*v)[i] += plus;
#endif
    }
}

/**
 * \function igraph_vector_contains
 * \brief Linear search in a vector.
 *
 * Check whether the supplied element is included in the vector, by
 * linear search.
 * \param v The input vector.
 * \param e The element to look for.
 * \return \c TRUE if the element is found and \c FALSE otherwise.
 *
 * Time complexity: O(n), the length of the vector.
 */

igraph_bool_t FUNCTION(igraph_vector, contains)(const TYPE(igraph_vector) *v,
        BASE e) {
    BASE *p = v->stor_begin;
    while (p < v->end) {
#ifdef EQ
        if (EQ(*p, e)) {
#else
        if (*p == e) {
#endif
            return 1;
        }
        p++;
    }
    return 0;
}

/**
 * \function igraph_vector_search
 * \brief Search from a given position
 *
 * The supplied element \p what is searched in vector \p v, starting
 * from element index \p from. If found then the index of the first
 * instance (after \p from) is stored in \p pos.
 * \param v The input vector.
 * \param from The index to start searching from. No range checking is
 *     performed.
 * \param what The element to find.
 * \param pos If not \c NULL then the index of the found element is
 *    stored here.
 * \return Boolean, \c TRUE if the element was found, \c FALSE
 *   otherwise.
 *
 * Time complexity: O(m), the number of elements to search, the length
 * of the vector minus the \p from argument.
 */

igraph_bool_t FUNCTION(igraph_vector, search)(const TYPE(igraph_vector) *v,
        long int from, BASE what,
        long int *pos) {
    long int i, n = FUNCTION(igraph_vector, size)(v);
    for (i = from; i < n; i++) {
#ifdef EQ
        if (EQ(VECTOR(*v)[i], what)) {
            break;
        }
#else
        if (VECTOR(*v)[i] == what) {
            break;
        }
#endif
    }

    if (i < n) {
        if (pos != 0) {
            *pos = i;
        }
        return 1;
    } else {
        return 0;
    }
}

#ifndef NOTORDERED

/**
 * \function igraph_vector_filter_smaller
 * \ingroup internal
 */

int FUNCTION(igraph_vector, filter_smaller)(TYPE(igraph_vector) *v,
        BASE elem) {
    long int i = 0, n = FUNCTION(igraph_vector, size)(v);
    long int s;
    while (i < n && VECTOR(*v)[i] < elem) {
        i++;
    }
    s = i;

    while (s < n && VECTOR(*v)[s] == elem) {
        s++;
    }

    FUNCTION(igraph_vector, remove_section)(v, 0, i + (s - i) / 2);
    return 0;
}

#endif

/**
 * \function igraph_vector_append
 * \brief Append a vector to another one.
 *
 * The target vector will be resized (except when \p from is empty).
 * \param to The vector to append to.
 * \param from The vector to append, it is kept unchanged.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements in the new vector.
 */

int FUNCTION(igraph_vector, append)(TYPE(igraph_vector) *to,
                                    const TYPE(igraph_vector) *from) {
    long tosize, fromsize;

    tosize = FUNCTION(igraph_vector, size)(to);
    fromsize = FUNCTION(igraph_vector, size)(from);
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, tosize + fromsize));
    memcpy(to->stor_begin + tosize, from->stor_begin,
           sizeof(BASE) * (size_t) fromsize);
    to->end = to->stor_begin + tosize + fromsize;

    return 0;
}

/**
 * \function igraph_vector_get_interval
 */

int FUNCTION(igraph_vector, get_interval)(const TYPE(igraph_vector) *v,
        TYPE(igraph_vector) *res,
        long int from, long int to) {
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(res, to - from));
    memcpy(res->stor_begin, v->stor_begin + from,
           (size_t) (to - from) * sizeof(BASE));
    return 0;
}

#ifndef NOTORDERED

/**
 * \function igraph_vector_maxdifference
 * \brief The maximum absolute difference of \p m1 and \p m2
 *
 * The element with the largest absolute value in \p m1 - \p m2 is
 * returned. Both vectors must be non-empty, but they not need to have
 * the same length, the extra elements in the longer vector are ignored. If
 * any value is NaN in the shorter vector, the result will be NaN.
 * \param m1 The first vector.
 * \param m2 The second vector.
 * \return The maximum absolute difference of \p m1 and \p m2.
 *
 * Time complexity: O(n), the number of elements in the shorter
 * vector.
 */

igraph_real_t FUNCTION(igraph_vector, maxdifference)(const TYPE(igraph_vector) *m1,
        const TYPE(igraph_vector) *m2) {
    long int n1 = FUNCTION(igraph_vector, size)(m1);
    long int n2 = FUNCTION(igraph_vector, size)(m2);
    long int n = n1 < n2 ? n1 : n2;
    long int i;
    igraph_real_t diff = 0.0;

    for (i = 0; i < n; i++) {
        igraph_real_t d = fabs((igraph_real_t)(VECTOR(*m1)[i]) -
                               (igraph_real_t)(VECTOR(*m2)[i]));
        if (d > diff) {
            diff = d;
        }
    #if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        else if (igraph_is_nan(d)) { /* Result is NaN */
            return d;
        };
    #endif
    }

    return diff;
}

#endif

/**
 * \function igraph_vector_update
 * \brief Update a vector from another one.
 *
 * After this operation the contents of \p to will be exactly the same
 * as that of \p from. The vector \p to will be resized if it was originally
 * shorter or longer than \p from.
 * \param to The vector to update.
 * \param from The vector to update from.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements in \p from.
 */

int FUNCTION(igraph_vector, update)(TYPE(igraph_vector) *to,
                                    const TYPE(igraph_vector) *from) {
    size_t n = (size_t) FUNCTION(igraph_vector, size)(from);
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, (long) n));
    memcpy(to->stor_begin, from->stor_begin, sizeof(BASE)*n);
    return 0;
}

/**
 * \function igraph_vector_swap
 * \brief Swap elements of two vectors.
 *
 * The two vectors must have the same length, otherwise an error
 * happens.
 * \param v1 The first vector.
 * \param v2 The second vector.
 * \return Error code.
 *
 * Time complexity: O(n), the length of the vectors.
 */

int FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) {

    long int i, n1 = FUNCTION(igraph_vector, size)(v1);
    long int n2 = FUNCTION(igraph_vector, size)(v2);
    if (n1 != n2) {
        IGRAPH_ERROR("Vectors must have the same number of elements for swapping",
                     IGRAPH_EINVAL);
    }

    for (i = 0; i < n1; i++) {
        BASE tmp;
        tmp = VECTOR(*v1)[i];
        VECTOR(*v1)[i] = VECTOR(*v2)[i];
        VECTOR(*v2)[i] = tmp;
    }
    return 0;
}

/**
 * \function igraph_vector_swap_elements
 * \brief Swap two elements in a vector.
 *
 * Note that currently no range checking is performed.
 * \param v The input vector.
 * \param i Index of the first element.
 * \param j Index of the second element (may be the same as the
 * first one).
 * \return Error code, currently always \c IGRAPH_SUCCESS.
 *
 * Time complexity: O(1).
 */

int FUNCTION(igraph_vector, swap_elements)(TYPE(igraph_vector) *v,
        long int i, long int j) {
    BASE tmp = VECTOR(*v)[i];
    VECTOR(*v)[i] = VECTOR(*v)[j];
    VECTOR(*v)[j] = tmp;

    return 0;
}

/**
 * \function igraph_vector_reverse
 * \brief Reverse the elements of a vector.
 *
 * The first element will be last, the last element will be
 * first, etc.
 * \param v The input vector.
 * \return Error code, currently always \c IGRAPH_SUCCESS.
 *
 * Time complexity: O(n), the number of elements.
 */

int FUNCTION(igraph_vector, reverse)(TYPE(igraph_vector) *v) {

    long int n = FUNCTION(igraph_vector, size)(v), n2 = n / 2;
    long int i, j;
    for (i = 0, j = n - 1; i < n2; i++, j--) {
        BASE tmp;
        tmp = VECTOR(*v)[i];
        VECTOR(*v)[i] = VECTOR(*v)[j];
        VECTOR(*v)[j] = tmp;
    }
    return 0;
}

/**
 * \ingroup vector
 * \function igraph_vector_shuffle
 * \brief Shuffles a vector in-place using the Fisher-Yates method
 *
 * 
 * The Fisher-Yates shuffle ensures that every permutation is
 * equally probable when using a proper randomness source. Of course
 * this does not apply to pseudo-random generators as the cycle of
 * these generators is less than the number of possible permutations
 * of the vector if the vector is long enough.
 * \param v The vector object.
 * \return Error code, currently always \c IGRAPH_SUCCESS.
 *
 * Time complexity: O(n),
 * n is the number of elements in the
 * vector.
 *
 * 
 * References:
 * \clist
 * \cli (Fisher & Yates 1963)
 *   R. A. Fisher and F. Yates. \emb Statistical Tables for Biological,
 *   Agricultural and Medical Research. \eme Oliver and Boyd, 6th edition,
 *   1963, page 37.
 * \cli (Knuth 1998)
 *   D. E. Knuth. \emb Seminumerical Algorithms, \eme volume 2 of \emb The Art
 *   of Computer Programming. \eme Addison-Wesley, 3rd edition, 1998, page 145.
 * \endclist
 *
 * \example examples/simple/igraph_fisher_yates_shuffle.c
 */

int FUNCTION(igraph_vector, shuffle)(TYPE(igraph_vector) *v) {
    long int n = FUNCTION(igraph_vector, size)(v);
    long int k;
    BASE dummy;

    RNG_BEGIN();
    while (n > 1) {
        k = RNG_INTEGER(0, n - 1);
        n--;
        dummy = VECTOR(*v)[n];
        VECTOR(*v)[n] = VECTOR(*v)[k];
        VECTOR(*v)[k] = dummy;
    }
    RNG_END();

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_vector_add
 * \brief Add two vectors.
 *
 * Add the elements of \p v2 to \p v1, the result is stored in \p
 * v1. The two vectors must have the same length.
 * \param v1 The first vector, the result will be stored here.
 * \param v2 The second vector, its contents will be unchanged.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements.
 */

int FUNCTION(igraph_vector, add)(TYPE(igraph_vector) *v1,
                                 const TYPE(igraph_vector) *v2) {

    long int n1 = FUNCTION(igraph_vector, size)(v1);
    long int n2 = FUNCTION(igraph_vector, size)(v2);
    long int i;
    if (n1 != n2) {
        IGRAPH_ERROR("Vectors must have the same number of elements for swapping",
                     IGRAPH_EINVAL);
    }

    for (i = 0; i < n1; i++) {
#ifdef SUM
        SUM(VECTOR(*v1)[i], VECTOR(*v1)[i], VECTOR(*v2)[i]);
#else
        VECTOR(*v1)[i] += VECTOR(*v2)[i];
#endif
    }

    return 0;
}

/**
 * \function igraph_vector_sub
 * \brief Subtract a vector from another one.
 *
 * Subtract the elements of \p v2 from \p v1, the result is stored in
 * \p v1. The two vectors must have the same length.
 * \param v1 The first vector, to subtract from. The result is stored
 *    here.
 * \param v2 The vector to subtract, it will be unchanged.
 * \return Error code.
 *
 * Time complexity: O(n), the length of the vectors.
 */

int FUNCTION(igraph_vector, sub)(TYPE(igraph_vector) *v1,
                                 const TYPE(igraph_vector) *v2) {

    long int n1 = FUNCTION(igraph_vector, size)(v1);
    long int n2 = FUNCTION(igraph_vector, size)(v2);
    long int i;
    if (n1 != n2) {
        IGRAPH_ERROR("Vectors must have the same number of elements for swapping",
                     IGRAPH_EINVAL);
    }

    for (i = 0; i < n1; i++) {
#ifdef DIFF
        DIFF(VECTOR(*v1)[i], VECTOR(*v1)[i], VECTOR(*v2)[i]);
#else
        VECTOR(*v1)[i] -= VECTOR(*v2)[i];
#endif
    }

    return 0;
}

/**
 * \function igraph_vector_mul
 * \brief Multiply two vectors.
 *
 * \p v1 will be multiplied by \p v2, elementwise. The two vectors
 * must have the same length.
 * \param v1 The first vector, the result will be stored here.
 * \param v2 The second vector, it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements.
 */

int FUNCTION(igraph_vector, mul)(TYPE(igraph_vector) *v1,
                                 const TYPE(igraph_vector) *v2) {

    long int n1 = FUNCTION(igraph_vector, size)(v1);
    long int n2 = FUNCTION(igraph_vector, size)(v2);
    long int i;
    if (n1 != n2) {
        IGRAPH_ERROR("Vectors must have the same number of elements for swapping",
                     IGRAPH_EINVAL);
    }

    for (i = 0; i < n1; i++) {
#ifdef PROD
        PROD(VECTOR(*v1)[i], VECTOR(*v1)[i], VECTOR(*v2)[i]);
#else
        VECTOR(*v1)[i] *= VECTOR(*v2)[i];
#endif
    }

    return 0;
}

/**
 * \function igraph_vector_div
 * \brief Divide a vector by another one.
 *
 * \p v1 is divided by \p v2, elementwise. They must have the same length. If the
 * base type of the vector can generate divide by zero errors then
 * please make sure that \p v2 contains no zero if you want to avoid
 * trouble.
 * \param v1 The dividend. The result is also stored here.
 * \param v2 The divisor, it is left unchanged.
 * \return Error code.
 *
 * Time complexity: O(n), the length of the vectors.
 */

int FUNCTION(igraph_vector, div)(TYPE(igraph_vector) *v1,
                                 const TYPE(igraph_vector) *v2) {

    long int n1 = FUNCTION(igraph_vector, size)(v1);
    long int n2 = FUNCTION(igraph_vector, size)(v2);
    long int i;
    if (n1 != n2) {
        IGRAPH_ERROR("Vectors must have the same number of elements for swapping",
                     IGRAPH_EINVAL);
    }

    for (i = 0; i < n1; i++) {
#ifdef DIV
        DIV(VECTOR(*v1)[i], VECTOR(*v1)[i], VECTOR(*v2)[i]);
#else
        VECTOR(*v1)[i] /= VECTOR(*v2)[i];
#endif
    }

    return 0;
}

#ifndef NOABS

int FUNCTION(igraph_vector, abs)(TYPE(igraph_vector) *v) {
#ifdef UNSIGNED
    /* Nothing do to, unsigned type */
    IGRAPH_UNUSED(v);
#else
    long int i, n = FUNCTION(igraph_vector, size)(v);
    for (i = 0; i < n; i++) {
        VECTOR(*v)[i] = VECTOR(*v)[i] >= 0 ? VECTOR(*v)[i] : -VECTOR(*v)[i];
    }
#endif

    return 0;
}

#endif

#ifndef NOTORDERED

/**
 * \function igraph_vector_minmax
 * \brief Minimum and maximum elements of a vector.
 *
 * Handy if you want to have both the smallest and largest element of
 * a vector. The vector is only traversed once. The vector must be non-empty.
 * If a vector contains at least one NaN, both \c min and \c max will be NaN.
 * \param v The input vector. It must contain at least one element.
 * \param min Pointer to a base type variable, the minimum is stored
 *     here.
 * \param max Pointer to a base type variable, the maximum is stored
 *     here.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements.
 */

int FUNCTION(igraph_vector, minmax)(const TYPE(igraph_vector) *v,
                                    BASE *min, BASE *max) {
    BASE* ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->stor_begin != v->end);
    *min = *max = *(v->stor_begin);
    #if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        if (igraph_is_nan(*min)) { return IGRAPH_SUCCESS; }; /* Result is NaN */
    #endif
    ptr = v->stor_begin + 1;
    while (ptr < v->end) {
        if (*ptr > *max) {
            *max = *ptr;
        } else if (*ptr < *min) {
            *min = *ptr;
        }
        #if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        else if (igraph_is_nan(*ptr)) { /* Result is NaN */
            *min = *max = *ptr;
            return IGRAPH_SUCCESS;
        };
        #endif
        ptr++;
    }
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_vector_which_minmax
 * \brief Index of the minimum and maximum elements
 *
 * 
 * Handy if you need the indices of the smallest and largest
 * elements. The vector is traversed only once. The vector must be
 * non-empty. If the minimum or maximum is not unique, the index
 * of the first minimum or the first maximum is returned, respectively.
 * If a vector contains at least one NaN, both \c which_min and \c which_max
 * will point to the first NaN value.
 * \param v The input vector. It must contain at least one element.
 * \param which_min The index of the minimum element will be stored
 *   here.
 * \param which_max The index of the maximum element will be stored
 *   here.
 * \return Error code.
 *
 * Time complexity: O(n), the number of elements.
 */

int FUNCTION(igraph_vector, which_minmax)(const TYPE(igraph_vector) *v,
        long int *which_min, long int *which_max) {
    BASE *min, *max;
    BASE *ptr;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->stor_begin != v->end);
    ptr = v->stor_begin;
    min = max = ptr;
    #if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        if (igraph_is_nan(*ptr)) {  /* Result is NaN */
            *which_min = *which_max = 0;
            return IGRAPH_SUCCESS;
        }
    #endif
    while (ptr < v->end) {
        if (*ptr > *max) {
            max = ptr;
        } else if (*ptr < *min) {
            min = ptr;
        }
#if defined(BASE_IGRAPH_REAL) || defined(BASE_FLOAT)
        else if (igraph_is_nan(*ptr)) {  /* Result is NaN */
            *which_min = *which_max  = ptr - v->stor_begin;
            return IGRAPH_SUCCESS;
        }
#endif
        ptr++;
    }
    *which_min = min - v->stor_begin;
    *which_max = max - v->stor_begin;
    return IGRAPH_SUCCESS;
}

#endif

/**
 * \function igraph_vector_isnull
 * \brief Are all elements zero?
 *
 * Checks whether all elements of a vector are zero.
 * \param v The input vector
 * \return Boolean, \c TRUE if the vector contains only zeros, \c
 *    FALSE otherwise.
 *
 * Time complexity: O(n), the number of elements.
 */

igraph_bool_t FUNCTION(igraph_vector, isnull)(const TYPE(igraph_vector) *v) {

    long int n = FUNCTION(igraph_vector, size)(v);
    long int i = 0;

#ifdef EQ
    while (i < n && EQ(VECTOR(*v)[i], ZERO)) {
#else
    while (i < n && VECTOR(*v)[i] == ZERO) {
#endif
        i++;
    }

    return i == n;
}

#ifndef NOTORDERED

int FUNCTION(igraph_i_vector, intersect_sorted)(
    const TYPE(igraph_vector) *v1, long int begin1, long int end1,
    const TYPE(igraph_vector) *v2, long int begin2, long int end2,
    TYPE(igraph_vector) *result);

/**
 * \function igraph_vector_intersect_sorted
 * \brief Calculates the intersection of two sorted vectors
 *
 * The elements that are contained in both vectors are stored in the result
 * vector. All three vectors must be initialized.
 *
 * 
 * Instead of the naive intersection which takes O(n), this function uses
 * the set intersection method of Ricardo Baeza-Yates, which is more efficient
 * when one of the vectors is significantly smaller than the other, and
 * gives similar performance on average when the two vectors are equal.
 *
 * 
 * The algorithm keeps the multiplicities of the elements: if an element appears
 * k1 times in the first vector and k2 times in the second, the result
 * will include that element min(k1, k2) times.
 *
 * 
 * Reference: Baeza-Yates R: A fast set intersection algorithm for sorted
 * sequences. In: Lecture Notes in Computer Science, vol. 3109/2004, pp.
 * 400--408, 2004. Springer Berlin/Heidelberg. ISBN: 978-3-540-22341-2.
 *
 * \param v1 the first vector
 * \param v2 the second vector
 * \param result the result vector, which will also be sorted.
 *
 * Time complexity: O(m log(n)) where m is the size of the smaller vector
 * and n is the size of the larger one.
 */
int FUNCTION(igraph_vector, intersect_sorted)(const TYPE(igraph_vector) *v1,
        const TYPE(igraph_vector) *v2, TYPE(igraph_vector) *result) {
    long int size1, size2;

    size1 = FUNCTION(igraph_vector, size)(v1);
    size2 = FUNCTION(igraph_vector, size)(v2);

    FUNCTION(igraph_vector, clear)(result);

    if (size1 == 0 || size2 == 0) {
        return 0;
    }

    IGRAPH_CHECK(FUNCTION(igraph_i_vector, intersect_sorted)(
                     v1, 0, size1, v2, 0, size2, result));
    return 0;
}

int FUNCTION(igraph_i_vector, intersect_sorted)(
    const TYPE(igraph_vector) *v1, long int begin1, long int end1,
    const TYPE(igraph_vector) *v2, long int begin2, long int end2,
    TYPE(igraph_vector) *result) {
    long int size1, size2, probe1, probe2;

    if (begin1 == end1 || begin2 == end2) {
        return 0;
    }

    size1 = end1 - begin1;
    size2 = end2 - begin2;

    if (size1 < size2) {
        probe1 = begin1 + (size1 >> 1);      /* pick the median element */
        FUNCTION(igraph_i_vector, binsearch_slice)(v2, VECTOR(*v1)[probe1], &probe2, begin2, end2);
        IGRAPH_CHECK(FUNCTION(igraph_i_vector, intersect_sorted)(
                         v1, begin1, probe1, v2, begin2, probe2, result
                     ));
        if (!(probe2 == end2 || VECTOR(*v1)[probe1] < VECTOR(*v2)[probe2])) {
            IGRAPH_CHECK(FUNCTION(igraph_vector, push_back)(result, VECTOR(*v2)[probe2]));
            probe2++;
        }
        IGRAPH_CHECK(FUNCTION(igraph_i_vector, intersect_sorted)(
                         v1, probe1 + 1, end1, v2, probe2, end2, result
                     ));
    } else {
        probe2 = begin2 + (size2 >> 1);      /* pick the median element */
        FUNCTION(igraph_i_vector, binsearch_slice)(v1, VECTOR(*v2)[probe2], &probe1, begin1, end1);
        IGRAPH_CHECK(FUNCTION(igraph_i_vector, intersect_sorted)(
                         v1, begin1, probe1, v2, begin2, probe2, result
                     ));
        if (!(probe1 == end1 || VECTOR(*v2)[probe2] < VECTOR(*v1)[probe1])) {
            IGRAPH_CHECK(FUNCTION(igraph_vector, push_back)(result, VECTOR(*v2)[probe2]));
            probe1++;
        }
        IGRAPH_CHECK(FUNCTION(igraph_i_vector, intersect_sorted)(
                         v1, probe1, end1, v2, probe2 + 1, end2, result
                     ));
    }

    return 0;
}

/**
 * \function igraph_vector_difference_sorted
 * \brief Calculates the difference between two sorted vectors (considered as sets)
 *
 * The elements that are contained in only the first vector but not the second are
 * stored in the result vector. All three vectors must be initialized.
 *
 * \param v1 the first vector
 * \param v2 the second vector
 * \param result the result vector
 */
int FUNCTION(igraph_vector, difference_sorted)(const TYPE(igraph_vector) *v1,
        const TYPE(igraph_vector) *v2, TYPE(igraph_vector) *result) {
    long int i, j, i0, j0;
    i0 = FUNCTION(igraph_vector, size)(v1);
    j0 = FUNCTION(igraph_vector, size)(v2);
    i = j = 0;

    if (i0 == 0) {
        /* v1 is empty, this is easy */
        FUNCTION(igraph_vector, clear)(result);
        return IGRAPH_SUCCESS;
    }

    if (j0 == 0) {
        /* v2 is empty, this is easy */
        IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(result, i0));
        memcpy(result->stor_begin, v1->stor_begin, sizeof(BASE) * (size_t) i0);
        return IGRAPH_SUCCESS;
    }

    FUNCTION(igraph_vector, clear)(result);

    /* Copy the part of v1 that is less than the first element of v2 */
    while (i < i0 && VECTOR(*v1)[i] < VECTOR(*v2)[j]) {
        i++;
    }
    if (i > 0) {
        IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(result, i));
        memcpy(result->stor_begin, v1->stor_begin, sizeof(BASE) * (size_t) i);
    }

    while (i < i0 && j < j0) {
        BASE element = VECTOR(*v1)[i];
        if (element == VECTOR(*v2)[j]) {
            i++; j++;
            while (i < i0 && VECTOR(*v1)[i] == element) {
                i++;
            }
            while (j < j0 && VECTOR(*v2)[j] == element) {
                j++;
            }
        } else if (element < VECTOR(*v2)[j]) {
            IGRAPH_CHECK(FUNCTION(igraph_vector, push_back)(result, element));
            i++;
        } else {
            j++;
        }
    }
    if (i < i0) {
        long int oldsize = FUNCTION(igraph_vector, size)(result);
        IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(result, oldsize + i0 - i));
        memcpy(result->stor_begin + oldsize, v1->stor_begin + i,
               sizeof(BASE) * (size_t) (i0 - i));
    }

    return 0;
}

#endif

#if defined(OUT_FORMAT)

#ifndef USING_R
int FUNCTION(igraph_vector, print)(const TYPE(igraph_vector) *v) {
    long int i, n = FUNCTION(igraph_vector, size)(v);
    if (n != 0) {
#ifdef PRINTFUNC
        PRINTFUNC(VECTOR(*v)[0]);
#else
        printf(OUT_FORMAT, VECTOR(*v)[0]);
#endif
    }
    for (i = 1; i < n; i++) {
#ifdef PRINTFUNC
        putchar(' '); PRINTFUNC(VECTOR(*v)[i]);
#else
        printf(" " OUT_FORMAT, VECTOR(*v)[i]);
#endif
    }
    printf("\n");
    return 0;
}

int FUNCTION(igraph_vector, printf)(const TYPE(igraph_vector) *v,
                                    const char *format) {
    long int i, n = FUNCTION(igraph_vector, size)(v);
    if (n != 0) {
        printf(format, VECTOR(*v)[0]);
    }
    for (i = 1; i < n; i++) {
        putchar(' '); printf(format, VECTOR(*v)[i]);
    }
    printf("\n");
    return 0;
}

#endif

int FUNCTION(igraph_vector, fprint)(const TYPE(igraph_vector) *v, FILE *file) {
    long int i, n = FUNCTION(igraph_vector, size)(v);
    if (n != 0) {
#ifdef FPRINTFUNC
        FPRINTFUNC(file, VECTOR(*v)[0]);
#else
        fprintf(file, OUT_FORMAT, VECTOR(*v)[0]);
#endif
    }
    for (i = 1; i < n; i++) {
#ifdef FPRINTFUNC
        fputc(' ', file); FPRINTFUNC(file, VECTOR(*v)[i]);
#else
        fprintf(file, " " OUT_FORMAT, VECTOR(*v)[i]);
#endif
    }
    fprintf(file, "\n");
    return 0;
}

#endif

int FUNCTION(igraph_vector, index)(const TYPE(igraph_vector) *v,
                                   TYPE(igraph_vector) *newv,
                                   const igraph_vector_t *idx) {

    long int i, newlen = igraph_vector_size(idx);
    IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(newv, newlen));

    for (i = 0; i < newlen; i++) {
        long int j = (long int) VECTOR(*idx)[i];
        VECTOR(*newv)[i] = VECTOR(*v)[j];
    }

    return 0;
}

int FUNCTION(igraph_vector, index_int)(TYPE(igraph_vector) *v,
                                       const igraph_vector_int_t *idx) {
    BASE *tmp;
    int i, n = igraph_vector_int_size(idx);

    tmp = IGRAPH_CALLOC(n, BASE);
    if (!tmp) {
        IGRAPH_ERROR("Cannot index vector", IGRAPH_ENOMEM);
    }

    for (i = 0; i < n; i++) {
        tmp[i] = VECTOR(*v)[ VECTOR(*idx)[i] ];
    }

    IGRAPH_FREE(v->stor_begin);
    v->stor_begin = tmp;
    v->stor_end = v->end = tmp + n;

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/core/vector_ptr.c0000644000175100001710000005056100000000000023733 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"
#include "igraph_vector_ptr.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "igraph_qsort.h"

#include          /* memcpy & co. */
#include 

/**
 * \section about_igraph_vector_ptr_objects Pointer vectors
 * (igraph_vector_ptr_t)
 *
 * The \type igraph_vector_ptr_t data type is very similar to
 * the \ref igraph_vector_t type, but it stores generic pointers instead of
 * real numbers.
 *
 * This type has the same space complexity as \ref
 * igraph_vector_t, and most implemented operations work the same way
 * as for \ref igraph_vector_t.
 *
 * This type is mostly used to pass to or receive from a set of
 * graphs to some \a igraph functions, such as \ref
 * igraph_decompose(), which decomposes a graph to connected
 * components.
 *
 * The same \ref VECTOR macro used for ordinary vectors can be
 * used for pointer vectors as well, please note that a typeless
 * generic pointer will be provided by this macro and you may need to
 * cast it to a specific pointer before starting to work with it.
 *
 * Pointer vectors may have an associated item destructor function
 * which takes a pointer and returns nothing. The item destructor will
 * be called on each item in the pointer vector when it is destroyed by
 * \ref igraph_vector_ptr_destroy() or \ref igraph_vector_ptr_destroy_all(),
 * or when its elements are freed by \ref igraph_vector_ptr_free_all().
 * Note that the semantics of an item destructor does not coincide with
 * C++ destructors; for instance, when a pointer vector is resized to a
 * smaller size, the extra items will \em not be destroyed automatically!
 * Nevertheless, item destructors may become handy in many cases; for
 * instance, a vector of graphs generated by \ref igraph_decompose() can
 * be destroyed with a single call to \ref igraph_vector_ptr_destroy_all()
 * if the item destructor is set to \ref igraph_destroy().
 */


/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_init
 * \brief Initialize a pointer vector (constructor).
 *
 * 
 * This is the constructor of the pointer vector data type. All
 * pointer vectors constructed this way should be destroyed via
 * calling \ref igraph_vector_ptr_destroy().
 * \param v Pointer to an uninitialized
 *        igraph_vector_ptr_t object, to be created.
 * \param size Integer, the size of the pointer vector.
 * \return Error code:
 *         \c IGRAPH_ENOMEM if out of memory
 *
 * Time complexity: operating system dependent, the amount of \quote
 * time \endquote required to allocate \p size elements.
 */

int igraph_vector_ptr_init(igraph_vector_ptr_t* v, int long size) {
    long int alloc_size = size > 0 ? size : 1;
    IGRAPH_ASSERT(v != NULL);
    if (size < 0) {
        size = 0;
    }
    v->stor_begin = IGRAPH_CALLOC(alloc_size, void*);
    if (v->stor_begin == 0) {
        IGRAPH_ERROR("vector ptr init failed", IGRAPH_ENOMEM);
    }
    v->stor_end = v->stor_begin + alloc_size;
    v->end = v->stor_begin + size;
    v->item_destructor = 0;

    return 0;
}

/**
 */

const igraph_vector_ptr_t *igraph_vector_ptr_view(const igraph_vector_ptr_t *v, void *const *data,
        long int length) {
    igraph_vector_ptr_t *v2 = (igraph_vector_ptr_t*) v;
    v2->stor_begin = (void **)data;
    v2->stor_end = (void**)data + length;
    v2->end = v2->stor_end;
    v2->item_destructor = 0;
    return v;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_destroy
 * \brief Destroys a pointer vector.
 *
 * 
 * The destructor for pointer vectors.
 * \param v Pointer to the pointer vector to destroy.
 *
 * Time complexity: operating system dependent, the \quote time
 * \endquote required to deallocate O(n) bytes, n is the number of
 * elements allocated for the pointer vector (not necessarily the
 * number of elements in the vector).
 */

void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != 0);
    if (v->stor_begin != 0) {
        IGRAPH_FREE(v->stor_begin);
        v->stor_begin = NULL;
    }
}

static void igraph_i_vector_ptr_call_item_destructor_all(igraph_vector_ptr_t* v) {
    void **ptr;

    if (v->item_destructor != 0) {
        for (ptr = v->stor_begin; ptr < v->end; ptr++) {
            if (*ptr != 0) {
                v->item_destructor(*ptr);
            }
        }
    }
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_free_all
 * \brief Frees all the elements of a pointer vector.
 *
 * If an item destructor is set for this pointer vector, this function will
 * first call the destructor on all elements of the vector and then
 * free all the elements using \ref igraph_free(). If an item destructor is not set,
 * the elements will simply be freed.
 *
 * \param v Pointer to the pointer vector whose elements will be freed.
 *
 * Time complexity: operating system dependent, the \quote time
 * \endquote required to call the destructor n times and then
 * deallocate O(n) pointers, each pointing to a memory area of
 * arbitrary size. n is the number of elements in the pointer vector.
 */

void igraph_vector_ptr_free_all(igraph_vector_ptr_t* v) {
    void **ptr;
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->stor_begin != 0);

    igraph_i_vector_ptr_call_item_destructor_all(v);
    for (ptr = v->stor_begin; ptr < v->end; ptr++) {
        IGRAPH_FREE(*ptr);
    }
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_destroy_all
 * \brief Frees all the elements and destroys the pointer vector.
 *
 * This function is equivalent to \ref igraph_vector_ptr_free_all()
 * followed by \ref igraph_vector_ptr_destroy().
 *
 * \param v Pointer to the pointer vector to destroy.
 *
 * Time complexity: operating system dependent, the \quote time
 * \endquote required to deallocate O(n) pointers, each pointing to
 * a memory area of arbitrary size, plus the \quote time \endquote
 * required to deallocate O(n) bytes, n being the number of elements
 * allocated for the pointer vector (not necessarily the number of
 * elements in the vector).
 */

void igraph_vector_ptr_destroy_all(igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != 0);
    IGRAPH_ASSERT(v->stor_begin != 0);
    igraph_vector_ptr_free_all(v);
    igraph_vector_ptr_set_item_destructor(v, 0);
    igraph_vector_ptr_destroy(v);
}

/**
 * \ingroup vectorptr
 * \brief Reserves memory for a pointer vector for later use.
 *
 * @return Error code:
 *         - IGRAPH_ENOMEM: out of memory
 */

int igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, long int size) {
    long int actual_size = igraph_vector_ptr_size(v);
    void **tmp;
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    if (size <= igraph_vector_ptr_size(v)) {
        return 0;
    }

    tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) size, void*);
    if (tmp == 0) {
        IGRAPH_ERROR("vector ptr reserve failed", IGRAPH_ENOMEM);
    }
    v->stor_begin = tmp;
    v->stor_end = v->stor_begin + size;
    v->end = v->stor_begin + actual_size;

    return 0;
}

/**
 * \ingroup vectorptr
 * \brief Decides whether the pointer vector is empty.
 */

igraph_bool_t igraph_vector_ptr_empty(const igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return v->stor_begin == v->end;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_size
 * \brief Gives the number of elements in the pointer vector.
 *
 * \param v The pointer vector object.
 * \return The size of the object, i.e. the number of pointers stored.
 *
 * Time complexity: O(1).
 */

long int igraph_vector_ptr_size(const igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != NULL);
    /*  IGRAPH_ASSERT(v->stor_begin != NULL);       */ /* TODO */
    return v->end - v->stor_begin;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_clear
 * \brief Removes all elements from a pointer vector.
 *
 * 
 * This function resizes a pointer to vector to zero length. Note that
 * the pointed objects are \em not deallocated, you should call
 * \ref igraph_free() on them, or make sure that their allocated memory is freed
 * in some other way, you'll get memory leaks otherwise. If you have
 * set up an item destructor earlier, the destructor will be called
 * on every element.
 *
 * 
 * Note that the current implementation of this function does
 * \em not deallocate the memory required for storing the
 * pointers, so making a pointer vector smaller this way does not give
 * back any memory. This behavior might change in the future.
 * \param v The pointer vector to clear.
 *
 * Time complexity: O(1).
 */

void igraph_vector_ptr_clear(igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    igraph_i_vector_ptr_call_item_destructor_all(v);
    v->end = v->stor_begin;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_push_back
 * \brief Appends an element to the back of a pointer vector.
 *
 * \param v The pointer vector.
 * \param e The new element to include in the pointer vector.
 * \return Error code.
 * \sa igraph_vector_push_back() for the corresponding operation of
 * the ordinary vector type.
 *
 * Time complexity: O(1) or O(n), n is the number of elements in the
 * vector. The pointer vector implementation ensures that n subsequent
 * push_back operations need O(n) time to complete.
 */

int igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);

    /* full, allocate more storage */
    if (v->stor_end == v->end) {
        long int new_size = igraph_vector_ptr_size(v) * 2;
        if (new_size == 0) {
            new_size = 1;
        }
        IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size));
    }

    *(v->end) = e;
    v->end += 1;

    return 0;
}

void *igraph_vector_ptr_pop_back(igraph_vector_ptr_t *v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    IGRAPH_ASSERT(v->stor_begin != v->end);
    v->end -= 1;
    return *(v->end);
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_insert
 * \brief Inserts a single element into a pointer vector.
 *
 * Note that this function does not do range checking. Insertion will shift the
 * elements from the position given to the end of the vector one position to the
 * right, and the new element will be inserted in the empty space created at
 * the given position. The size of the vector will increase by one.
 *
 * \param v The pointer vector object.
 * \param pos The position where the new element is inserted.
 * \param e The inserted element
 */
int igraph_vector_ptr_insert(igraph_vector_ptr_t* v, long int pos, void* e) {
    long int size = igraph_vector_ptr_size(v);
    IGRAPH_CHECK(igraph_vector_ptr_resize(v, size + 1));
    if (pos < size) {
        memmove(v->stor_begin + pos + 1, v->stor_begin + pos,
                sizeof(void*) * (size_t) (size - pos));
    }
    v->stor_begin[pos] = e;
    return 0;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_e
 * \brief Access an element of a pointer vector.
 *
 * \param v Pointer to a pointer vector.
 * \param pos The index of the pointer to return.
 * \return The pointer at \p pos position.
 *
 * Time complexity: O(1).
 */

void *igraph_vector_ptr_e(const igraph_vector_ptr_t* v, long int pos) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    return *(v->stor_begin + pos);
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_set
 * \brief Assign to an element of a pointer vector.
 *
 * \param v Pointer to a pointer vector.
 * \param pos The index of the pointer to update.
 * \param value The new pointer to set in the vector.
 *
 * Time complexity: O(1).
 */

void igraph_vector_ptr_set(igraph_vector_ptr_t* v, long int pos, void* value) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    *(v->stor_begin + pos) = value;
}

/**
 * \ingroup vectorptr
 * \brief Set all elements of a pointer vector to the NULL pointer.
 */

void igraph_vector_ptr_null(igraph_vector_ptr_t* v) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (igraph_vector_ptr_size(v) > 0) {
        memset(v->stor_begin, 0, sizeof(void*) *
               (size_t) igraph_vector_ptr_size(v));
    }
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_resize
 * \brief Resizes a pointer vector.
 *
 * 
 * Note that if a vector is made smaller the pointed object are not
 * deallocated by this function and the item destructor is not called
 * on the extra elements.
 *
 * \param v A pointer vector.
 * \param newsize The new size of the pointer vector.
 * \return Error code.
 *
 * Time complexity: O(1) if the vector if made smaller. Operating
 * system dependent otherwise, the amount of \quote time \endquote
 * needed to allocate the memory for the vector elements.
 */

int igraph_vector_ptr_resize(igraph_vector_ptr_t* v, long int newsize) {
    IGRAPH_CHECK(igraph_vector_ptr_reserve(v, newsize));
    v->end = v->stor_begin + newsize;
    return 0;
}

/**
 * \ingroup vectorptr
 * \brief Initializes a pointer vector from an array (constructor).
 *
 * \return Error code:
 *         \c IGRAPH_ENOMEM if out of memory
 */

int igraph_vector_ptr_init_copy(igraph_vector_ptr_t *v, void * *data, long int length) {
    v->stor_begin = IGRAPH_CALLOC(length, void*);
    if (v->stor_begin == 0) {
        IGRAPH_ERROR("cannot init ptr vector from array", IGRAPH_ENOMEM);
    }
    v->stor_end = v->stor_begin + length;
    v->end = v->stor_end;
    v->item_destructor = 0;
    memcpy(v->stor_begin, data, (size_t) length * sizeof(void*));

    return 0;
}

/**
 * \ingroup vectorptr
 * \brief Copy the contents of a pointer vector to a regular C array.
 */

void igraph_vector_ptr_copy_to(const igraph_vector_ptr_t *v, void** to) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (v->end != v->stor_begin) {
        memcpy(to, v->stor_begin, sizeof(void*) *
               (size_t) (v->end - v->stor_begin));
    }
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_copy
 * \brief Copy a pointer vector (constructor).
 *
 * 
 * This function creates a pointer vector by copying another one. This
 * is shallow copy, only the pointers in the vector will be copied.
 *
 * 
 * It is potentially dangerous to copy a pointer vector with an associated
 * item destructor. The copied vector will inherit the item destructor,
 * which may cause problems when both vectors are destroyed as the items
 * might get destroyed twice. Make sure you know what you are doing when
 * copying a pointer vector with an item destructor, or unset the item
 * destructor on one of the vectors later.
 *
 * \param to Pointer to an uninitialized pointer vector object.
 * \param from A pointer vector object.
 * \return Error code:
 *         \c IGRAPH_ENOMEM if out of memory
 *
 * Time complexity: O(n) if allocating memory for n elements can be
 * done in O(n) time.
 */

int igraph_vector_ptr_copy(igraph_vector_ptr_t *to, const igraph_vector_ptr_t *from) {
    long int from_size;

    IGRAPH_ASSERT(from != NULL);
    /*   IGRAPH_ASSERT(from->stor_begin != NULL); */ /* TODO */

    from_size = igraph_vector_ptr_size(from);

    to->stor_begin = IGRAPH_CALLOC(from_size, void*);
    if (to->stor_begin == 0) {
        IGRAPH_ERROR("cannot copy ptr vector", IGRAPH_ENOMEM);
    }
    to->stor_end = to->stor_begin + igraph_vector_ptr_size(from);
    to->end = to->stor_end;
    to->item_destructor = from->item_destructor;
    memcpy(to->stor_begin, from->stor_begin,
           (size_t) igraph_vector_ptr_size(from)*sizeof(void*));

    return 0;
}

/**
 * \ingroup vectorptr
 * \brief Remove an element from a pointer vector.
 */

void igraph_vector_ptr_remove(igraph_vector_ptr_t *v, long int pos) {
    IGRAPH_ASSERT(v != NULL);
    IGRAPH_ASSERT(v->stor_begin != NULL);
    if (pos + 1 < igraph_vector_ptr_size(v)) { /* No need to move data when removing the last element. */
        memmove(v->stor_begin + pos, v->stor_begin + pos + 1,
                sizeof(void*) * (size_t) (igraph_vector_ptr_size(v) - pos - 1));
    }
    v->end--;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_sort
 * \brief Sorts the pointer vector based on an external comparison function.
 *
 * Sometimes it is necessary to sort the pointers in the vector based on
 * the property of the element being referenced by the pointer. This
 * function allows us to sort the vector based on an arbitrary external
 * comparison function which accepts two void * pointers \c p1 and \c p2
 * and returns an integer less than, equal to or greater than zero if the
 * first argument is considered to be respectively less than, equal to, or
 * greater than the second. \c p1 and \c p2 will point to the pointer in the
 * vector, so they have to be double-dereferenced if one wants to get access
 * to the underlying object the address of which is stored in \c v.
 *
 * \param v The pointer vector to be sorted.
 * \param compar A qsort-compatible comparison function. It must take pointers to the
 *    elements of the pointer vector. For example, if the pointer vector contains
 *    igraph_vector_t * pointers, then the comparison function must
 *    interpret its arguments as igraph_vector_t **.
 *
 * \example examples/simple/igraph_vector_ptr_sort.c
 */
void igraph_vector_ptr_sort(igraph_vector_ptr_t *v, int (*compar)(const void*, const void*)) {
    igraph_qsort(v->stor_begin, (size_t) igraph_vector_ptr_size(v), sizeof(void*),
          compar);
}

int igraph_vector_ptr_index_int(igraph_vector_ptr_t *v,
                                const igraph_vector_int_t *idx) {
    void **tmp;
    int i, n = igraph_vector_int_size(idx);

    tmp = IGRAPH_CALLOC(n, void*);
    if (!tmp) {
        IGRAPH_ERROR("Cannot index pointer vector", IGRAPH_ENOMEM);
    }

    for (i = 0; i < n; i++) {
        tmp[i] = VECTOR(*v)[ VECTOR(*idx)[i] ];
    }

    IGRAPH_FREE(v->stor_begin);
    v->stor_begin = tmp;
    v->stor_end = v->end = tmp + n;

    return 0;
}

int igraph_vector_ptr_append(igraph_vector_ptr_t *to, const igraph_vector_ptr_t *from) {
    long int origsize = igraph_vector_ptr_size(to);
    long int othersize = igraph_vector_ptr_size(from);
    long int i;

    IGRAPH_CHECK(igraph_vector_ptr_resize(to, origsize + othersize));
    for (i = 0; i < othersize; i++, origsize++) {
        to->stor_begin[origsize] = from->stor_begin[i];
    }

    return 0;
}


/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_set_item_destructor
 * \brief Sets the item destructor for this pointer vector.
 *
 * The item destructor is a function which will be called on every non-null
 * pointer stored in this vector when \ref igraph_vector_ptr_destroy(),
 * igraph_vector_ptr_destroy_all() or \ref igraph_vector_ptr_free_all()
 * is called.
 *
 * \return The old item destructor.
 *
 * Time complexity: O(1).
 */
igraph_finally_func_t* igraph_vector_ptr_set_item_destructor(
    igraph_vector_ptr_t *v, igraph_finally_func_t *func) {
    igraph_finally_func_t* result = v->item_destructor;

    v->item_destructor = func;

    return result;
}

/**
 * \ingroup vectorptr
 * \function igraph_vector_ptr_get_item_destructor
 * \brief Gets the current item destructor for this pointer vector.
 *
 * The item destructor is a function which will be called on every non-null
 * pointer stored in this vector when \ref igraph_vector_ptr_destroy(),
 * igraph_vector_ptr_destroy_all() or \ref igraph_vector_ptr_free_all()
 * is called.
 *
 * \return The current item destructor.
 *
 * Time complexity: O(1).
 */
igraph_finally_func_t* igraph_vector_ptr_get_item_destructor(const igraph_vector_ptr_t *v) {
    IGRAPH_ASSERT(v != 0);
    return v->item_destructor;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/f2c.h0000644000175100001710000001227400000000000021272 0ustar00runnerdocker00000000000000/* f2c.h  --  Standard Fortran to C header file */

/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."

    - From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */

#ifndef F2C_INCLUDE
#define F2C_INCLUDE

#include "linalg/blas_internal.h"
#include "linalg/lapack_internal.h"
#include "linalg/arpack_internal.h"

typedef int integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct {
    real r, i;
} f2c_complex;
typedef struct {
    doublereal r, i;
} doublecomplex;
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#ifdef INTEGER_STAR_8   /* Adjust for integer*8. */
    typedef long longint;       /* system-dependent */
    typedef unsigned long ulongint; /* system-dependent */
    #define qbit_clear(a,b) ((a) & ~((ulongint)1 << (b)))
    #define qbit_set(a,b)   ((a) |  ((ulongint)1 << (b)))
#endif

#define TRUE_ (1)
#define FALSE_ (0)

/* Extern is for use with -E */
#ifndef Extern
    #define Extern extern
#endif

/* I/O stuff */

#ifdef f2c_i2
    /* for -i2 */
    typedef short flag;
    typedef short ftnlen;
    typedef short ftnint;
#else
    typedef int flag;
    typedef int ftnlen;
    typedef int ftnint;
#endif

/*external read, write*/
typedef struct {
    flag cierr;
    ftnint ciunit;
    flag ciend;
    char *cifmt;
    ftnint cirec;
} cilist;

/*internal read, write*/
typedef struct {
    flag icierr;
    char *iciunit;
    flag iciend;
    char *icifmt;
    ftnint icirlen;
    ftnint icirnum;
} icilist;

/*open*/
typedef struct {
    flag oerr;
    ftnint ounit;
    char *ofnm;
    ftnlen ofnmlen;
    char *osta;
    char *oacc;
    char *ofm;
    ftnint orl;
    char *oblnk;
} olist;

/*close*/
typedef struct {
    flag cerr;
    ftnint cunit;
    char *csta;
} cllist;

/*rewind, backspace, endfile*/
typedef struct {
    flag aerr;
    ftnint aunit;
} alist;

/* inquire */
typedef struct {
    flag inerr;
    ftnint inunit;
    char *infile;
    ftnlen infilen;
    ftnint  *inex;  /*parameters in standard's order*/
    ftnint  *inopen;
    ftnint  *innum;
    ftnint  *innamed;
    char    *inname;
    ftnlen  innamlen;
    char    *inacc;
    ftnlen  inacclen;
    char    *inseq;
    ftnlen  inseqlen;
    char    *indir;
    ftnlen  indirlen;
    char    *infmt;
    ftnlen  infmtlen;
    char    *inform;
    ftnint  informlen;
    char    *inunf;
    ftnlen  inunflen;
    ftnint  *inrecl;
    ftnint  *innrec;
    char    *inblank;
    ftnlen  inblanklen;
} inlist;

#define VOID void

union Multitype {   /* for multiple entry points */
    integer1 g;
    shortint h;
    integer i;
    /* longint j; */
    real r;
    doublereal d;
    f2c_complex c;
    doublecomplex z;
};

typedef union Multitype Multitype;

/*typedef long int Long;*/  /* No longer used; formerly in Namelist */

struct Vardesc {    /* for Namelist */
    char *name;
    char *addr;
    ftnlen *dims;
    int  type;
};
typedef struct Vardesc Vardesc;

struct Namelist {
    char *name;
    Vardesc **vars;
    int nvars;
};
typedef struct Namelist Namelist;

#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (doublereal)abs(x)
#ifndef min
#define min(a,b) ((a) <= (b) ? (a) : (b))
#endif
#ifndef max
#define max(a,b) ((a) >= (b) ? (a) : (b))
#endif
#define dmin(a,b) (doublereal)min(a,b)
#define dmax(a,b) (doublereal)max(a,b)
#define bit_test(a,b)   ((a) >> (b) & 1)
#define bit_clear(a,b)  ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b)    ((a) |  ((uinteger)1 << (b)))

/* procedure parameter types for -A and -C++ */

#define F2C_proc_par_types 1
#ifdef __cplusplus
    typedef int /* Unknown procedure type */ (*U_fp)(...);
    typedef shortint (*J_fp)(...);
    typedef integer (*I_fp)(...);
    typedef real (*R_fp)(...);
    typedef doublereal (*D_fp)(...), (*E_fp)(...);
    typedef /* Complex */ VOID (*C_fp)(...);
    typedef /* Double Complex */ VOID (*Z_fp)(...);
    typedef logical (*L_fp)(...);
    typedef shortlogical (*K_fp)(...);
    typedef /* Character */ VOID (*H_fp)(...);
    typedef /* Subroutine */ int (*S_fp)(...);
#else
    typedef int /* Unknown procedure type */ (*U_fp)();
    typedef shortint (*J_fp)();
    typedef integer (*I_fp)();
    typedef real (*R_fp)();
    typedef doublereal (*D_fp)(), (*E_fp)();
    typedef /* Complex */ VOID (*C_fp)();
    typedef /* Double Complex */ VOID (*Z_fp)();
    typedef logical (*L_fp)();
    typedef shortlogical (*K_fp)();
    typedef /* Character */ VOID (*H_fp)();
    typedef /* Subroutine */ int (*S_fp)();
#endif
/* E_fp is for real functions when -R is not specified */
typedef VOID C_f;   /* complex function */
typedef VOID H_f;   /* character function */
typedef VOID Z_f;   /* double complex function */
typedef doublereal E_f; /* real function with -R not specified */

/* undef any lower-case symbols that your C compiler predefines, e.g.: */

#ifndef Skip_f2c_Undefs
    #undef cray
    #undef gcos
    #undef mc68010
    #undef mc68020
    #undef mips
    #undef pdp11
    #undef sgi
    #undef sparc
    #undef sun
    #undef sun2
    #undef sun3
    #undef sun4
    #undef u370
    #undef u3b
    #undef u3b2
    #undef u3b5
    #undef unix
    #undef vax
#endif

#include "config.h"

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5031407
igraph-0.9.9/vendor/source/igraph/src/flow/0000755000175100001710000000000000000000000021410 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/flow/flow.c0000644000175100001710000030217300000000000022531 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_flow.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_conversion.h"
#include "igraph_constants.h"
#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_progress.h"
#include "igraph_operators.h"
#include "igraph_structural.h"
#include "igraph_topology.h"

#include "core/buckets.h"
#include "core/cutheap.h"
#include "core/interruption.h"
#include "core/math.h"

#include "config.h"

/*
 * Some general remarks about the functions in this file.
 *
 * The following measures can be calculated:
 * ( 1) s-t maximum flow value, directed graph
 * ( 2) s-t maximum flow value, undirected graph
 * ( 3) s-t maximum flow, directed graph
 * ( 4) s-t maximum flow, undirected graph
 * ( 5) s-t minimum cut value, directed graph
 * ( 6) s-t minimum cut value, undirected graph
 * ( 7) minimum cut value, directed graph
 * ( 8) minimum cut value, undirected graph
 * ( 9) s-t minimum cut, directed graph
 * (10) s-t minimum cut, undirected graph
 * (11) minimum cut, directed graph
 * (12) minimum cut, undirected graph
 * (13) s-t edge connectivity, directed graph
 * (14) s-t edge connectivity, undirected graph
 * (15) edge connectivity, directed graph
 * (16) edge connectivity, undirected graph
 * (17) s-t vertex connectivity, directed graph
 * (18) s-t vertex connectivity, undirected graph
 * (19) vertex connectivity, directed graph
 * (20) vertex connectivity, undirected graph
 * (21) s-t number of edge disjoint paths, directed graph
 * (22) s-t number of edge disjoint paths, undirected graph
 * (23) s-t number of vertex disjoint paths, directed graph
 * (24) s-t number of vertex disjoint paths, undirected graph
 * (25) graph adhesion, directed graph
 * (26) graph adhesion, undirected graph
 * (27) graph cohesion, directed graph
 * (28) graph cohesion, undirected graph
 *
 * This is how they are calculated:
 * ( 1) igraph_maxflow_value, calls igraph_maxflow.
 * ( 2) igraph_maxflow_value, calls igraph_maxflow, this calls
 *      igraph_i_maxflow_undirected. This transforms the graph into a
 *      directed graph, including two mutual edges instead of every
 *      undirected edge, then igraph_maxflow is called again with the
 *      directed graph.
 * ( 3) igraph_maxflow, does the push-relabel algorithm, optionally
 *      calculates the cut, the partitions and the flow itself.
 * ( 4) igraph_maxflow calls igraph_i_maxflow_undirected, this converts
 *      the undirected graph into a directed one, adding two mutual edges
 *      for each undirected edge, then igraph_maxflow is called again,
 *      with the directed graph. After igraph_maxflow returns, we need
 *      to edit the flow (and the cut) to make it sense for the
 *      original graph.
 * ( 5) igraph_st_mincut_value, we just call igraph_maxflow_value
 * ( 6) igraph_st_mincut_value, we just call igraph_maxflow_value
 * ( 7) igraph_mincut_value, we call igraph_maxflow_value (|V|-1)*2
 *      times, from vertex 0 to all other vertices and from all other
 *      vertices to vertex 0
 * ( 8) We call igraph_i_mincut_value_undirected, that calls
 *      igraph_i_mincut_undirected with partition=partition2=cut=NULL
 *      The Stoer-Wagner algorithm is used.
 * ( 9) igraph_st_mincut, just calls igraph_maxflow.
 * (10) igraph_st_mincut, just calls igraph_maxflow.
 * (11) igraph_mincut, calls igraph_i_mincut_directed, which runs
 *      the maximum flow algorithm 2(|V|-1) times, from vertex zero to
 *      and from all other vertices and stores the smallest cut.
 * (12) igraph_mincut, igraph_i_mincut_undirected is called,
 *      this is the Stoer-Wagner algorithm
 * (13) We just call igraph_maxflow_value, back to (1)
 * (14) We just call igraph_maxflow_value, back to (2)
 * (15) We just call igraph_mincut_value (possibly after some basic
 *      checks). Back to (7)
 * (16) We just call igraph_mincut_value (possibly after some basic
 *      checks). Back to (8).
 * (17) We call igraph_i_st_vertex_connectivity_directed.
 *      That creates a new graph with 2*|V| vertices and smartly chosen
 *      edges, so that the s-t edge connectivity of this graph is the
 *      same as the s-t vertex connectivity of the original graph.
 *      So finally it calls igraph_maxflow_value, go to (1)
 * (18) We call igraph_i_st_vertex_connectivity_undirected.
 *      We convert the graph to a directed one,
 *      IGRAPH_TO_DIRECTED_MUTUAL method. Then we call
 *      igraph_i_st_vertex_connectivity_directed, see (17).
 * (19) We call igraph_i_vertex_connectivity_directed.
 *      That calls igraph_st_vertex_connectivity for all pairs of
 *      vertices. Back to (17).
 * (20) We call igraph_i_vertex_connectivity_undirected.
 *      That converts the graph into a directed one
 *      (IGRAPH_TO_DIRECTED_MUTUAL) and calls the directed version,
 *      igraph_i_vertex_connectivity_directed, see (19).
 * (21) igraph_edge_disjoint_paths, we just call igraph_maxflow_value, (1).
 * (22) igraph_edge_disjoint_paths, we just call igraph_maxflow_value, (2).
 * (23) igraph_vertex_disjoint_paths, if there is a connection between
 *      the two vertices, then we remove that (or all of them if there
 *      are many), as this could mess up vertex connectivity
 *      calculation. The we call
 *      igraph_i_st_vertex_connectivity_directed, see (19).
 * (24) igraph_vertex_disjoint_paths, if there is a connection between
 *      the two vertices, then we remove that (or all of them if there
 *      are many), as this could mess up vertex connectivity
 *      calculation. The we call
 *      igraph_i_st_vertex_connectivity_undirected, see (20).
 * (25) We just call igraph_edge_connectivity, see (15).
 * (26) We just call igraph_edge_connectivity, see (16).
 * (27) We just call igraph_vertex_connectivity, see (19).
 * (28) We just call igraph_vertex_connectivity, see (20).
 */

/*
 * This is an internal function that calculates the maximum flow value
 * on undirected graphs, either for an s-t vertex pair or for the
 * graph (i.e. all vertex pairs).
 *
 * It does it by converting the undirected graph to a corresponding
 * directed graph, including reciprocal directed edges instead of each
 * undirected edge.
 */

static int igraph_i_maxflow_undirected(const igraph_t *graph,
                                       igraph_real_t *value,
                                       igraph_vector_t *flow,
                                       igraph_vector_t *cut,
                                       igraph_vector_t *partition,
                                       igraph_vector_t *partition2,
                                       igraph_integer_t source,
                                       igraph_integer_t target,
                                       const igraph_vector_t *capacity,
                                       igraph_maxflow_stats_t *stats) {
    igraph_integer_t no_of_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_vector_t edges;
    igraph_vector_t newcapacity;
    igraph_t newgraph;
    long int i;

    /* We need to convert this to directed by hand, since we need to be
       sure that the edge ids will be handled properly to build the new
       capacity vector. */

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&newcapacity, no_of_edges * 2);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 4));
    IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
    IGRAPH_CHECK(igraph_vector_resize(&edges, no_of_edges * 4));
    for (i = 0; i < no_of_edges; i++) {
        VECTOR(edges)[no_of_edges * 2 + i * 2] = VECTOR(edges)[i * 2 + 1];
        VECTOR(edges)[no_of_edges * 2 + i * 2 + 1] = VECTOR(edges)[i * 2];
        VECTOR(newcapacity)[i] = VECTOR(newcapacity)[no_of_edges + i] =
                                     capacity ? VECTOR(*capacity)[i] : 1.0;
    }

    IGRAPH_CHECK(igraph_create(&newgraph, &edges, no_of_nodes, IGRAPH_DIRECTED));
    IGRAPH_FINALLY(igraph_destroy, &newgraph);

    IGRAPH_CHECK(igraph_maxflow(&newgraph, value, flow, cut, partition,
                                partition2, source, target, &newcapacity, stats));

    if (cut) {
        long int i, cs = igraph_vector_size(cut);
        for (i = 0; i < cs; i++) {
            if (VECTOR(*cut)[i] >= no_of_edges) {
                VECTOR(*cut)[i] -= no_of_edges;
            }
        }
    }

    /* The flow has one non-zero value for each real-nonreal edge pair,
       by definition, we convert it to a positive-negative vector. If
       for an edge the flow is negative that means that it is going
       from the bigger vertex id to the smaller one. For positive
       values the direction is the opposite. */
    if (flow) {
        long int i;
        for (i = 0; i < no_of_edges; i++) {
            VECTOR(*flow)[i] -= VECTOR(*flow)[i + no_of_edges];
        }
        IGRAPH_CHECK(igraph_vector_resize(flow, no_of_edges));
    }

    igraph_destroy(&newgraph);
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&newcapacity);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

#define FIRST(i)       (VECTOR(*first)[(i)])
#define LAST(i)        (VECTOR(*first)[(i)+1])
#define CURRENT(i)     (VECTOR(*current)[(i)])
#define RESCAP(i)      (VECTOR(*rescap)[(i)])
#define REV(i)         (VECTOR(*rev)[(i)])
#define HEAD(i)        (VECTOR(*to)[(i)])
#define EXCESS(i)      (VECTOR(*excess)[(i)])
#define DIST(i)        (VECTOR(*distance)[(i)])
#define DISCHARGE(v)   (igraph_i_mf_discharge((v), ¤t, &first, &rescap, \
                        &to, &distance, &excess,        \
                        no_of_nodes, source, target,    \
                        &buckets, &ibuckets,        \
                        &rev, stats, &npushsince,       \
                        &nrelabelsince))
#define PUSH(v,e,n)    (igraph_i_mf_push((v), (e), (n), current, rescap,      \
                        excess, target, source, buckets,     \
                        ibuckets, distance, rev, stats,      \
                        npushsince))
#define RELABEL(v)     (igraph_i_mf_relabel((v), no_of_nodes, distance,       \
                        first, rescap, to, current,       \
                        stats, nrelabelsince))
#define GAP(b)         (igraph_i_mf_gap((b), stats, buckets, ibuckets,        \
                                        no_of_nodes, distance))
#define BFS()          (igraph_i_mf_bfs(&bfsq, source, target, no_of_nodes,   \
                                        &buckets, &ibuckets, &distance,       \
                                        &first, ¤t, &to, &excess,       \
                                        &rescap, &rev))

static void igraph_i_mf_gap(long int b, igraph_maxflow_stats_t *stats,
                            igraph_buckets_t *buckets, igraph_dbuckets_t *ibuckets,
                            long int no_of_nodes,
                            igraph_vector_long_t *distance) {

    IGRAPH_UNUSED(buckets);

    long int bo;
    (stats->nogap)++;
    for (bo = b + 1; bo <= no_of_nodes; bo++) {
        while (!igraph_dbuckets_empty_bucket(ibuckets, bo)) {
            long int n = igraph_dbuckets_pop(ibuckets, bo);
            (stats->nogapnodes)++;
            DIST(n) = no_of_nodes;
        }
    }
}

static void igraph_i_mf_relabel(long int v, long int no_of_nodes,
                                igraph_vector_long_t *distance,
                                igraph_vector_long_t *first,
                                igraph_vector_t *rescap, igraph_vector_long_t *to,
                                igraph_vector_long_t *current,
                                igraph_maxflow_stats_t *stats, int *nrelabelsince) {

    long int min = no_of_nodes;
    long int k, l, min_edge = 0;
    (stats->norelabel)++; (*nrelabelsince)++;
    DIST(v) = no_of_nodes;
    for (k = FIRST(v), l = LAST(v); k < l; k++) {
        if (RESCAP(k) > 0 && DIST(HEAD(k)) < min) {
            min = DIST(HEAD(k));
            min_edge = k;
        }
    }
    min++;
    if (min < no_of_nodes) {
        DIST(v) = min;
        CURRENT(v) = min_edge;
    }
}

static void igraph_i_mf_push(long int v, long int e, long int n,
                             igraph_vector_long_t *current,
                             igraph_vector_t *rescap, igraph_vector_t *excess,
                             long int target, long int source,
                             igraph_buckets_t *buckets, igraph_dbuckets_t *ibuckets,
                             igraph_vector_long_t *distance,
                             igraph_vector_long_t *rev, igraph_maxflow_stats_t *stats,
                             int *npushsince) {


    IGRAPH_UNUSED(current);
    IGRAPH_UNUSED(source);

    igraph_real_t delta =
        RESCAP(e) < EXCESS(v) ? RESCAP(e) : EXCESS(v);
    (stats->nopush)++; (*npushsince)++;
    if (EXCESS(n) == 0 && n != target) {
        igraph_dbuckets_delete(ibuckets, DIST(n), n);
        igraph_buckets_add(buckets, (long int) DIST(n), n);
    }
    RESCAP(e) -= delta;
    RESCAP(REV(e)) += delta;
    EXCESS(n) += delta;
    EXCESS(v) -= delta;
}

static void igraph_i_mf_discharge(long int v,
                                  igraph_vector_long_t *current,
                                  igraph_vector_long_t *first,
                                  igraph_vector_t *rescap,
                                  igraph_vector_long_t *to,
                                  igraph_vector_long_t *distance,
                                  igraph_vector_t *excess,
                                  long int no_of_nodes, long int source,
                                  long int target, igraph_buckets_t *buckets,
                                  igraph_dbuckets_t *ibuckets,
                                  igraph_vector_long_t *rev,
                                  igraph_maxflow_stats_t *stats,
                                  int *npushsince, int *nrelabelsince) {
    do {
        long int i;
        long int start = (long int) CURRENT(v);
        long int stop = (long int) LAST(v);
        for (i = start; i < stop; i++) {
            if (RESCAP(i) > 0) {
                long int nei = HEAD(i);
                if (DIST(v) == DIST(nei) + 1) {
                    PUSH((v), i, nei);
                    if (EXCESS(v) == 0) {
                        break;
                    }
                }
            }
        }
        if (i == stop) {
            long int origdist = DIST(v);
            RELABEL(v);
            if (igraph_buckets_empty_bucket(buckets, origdist) &&
                igraph_dbuckets_empty_bucket(ibuckets, origdist)) {
                GAP(origdist);
            }
            if (DIST(v) == no_of_nodes) {
                break;
            }
        } else {
            CURRENT(v) = i;
            igraph_dbuckets_add(ibuckets, DIST(v), v);
            break;
        }
    } while (1);
}

static void igraph_i_mf_bfs(igraph_dqueue_long_t *bfsq,
                            long int source, long int target,
                            long int no_of_nodes, igraph_buckets_t *buckets,
                            igraph_dbuckets_t *ibuckets,
                            igraph_vector_long_t *distance,
                            igraph_vector_long_t *first, igraph_vector_long_t *current,
                            igraph_vector_long_t *to, igraph_vector_t *excess,
                            igraph_vector_t *rescap, igraph_vector_long_t *rev) {

    long int k, l;

    IGRAPH_UNUSED(source);

    igraph_buckets_clear(buckets);
    igraph_dbuckets_clear(ibuckets);
    igraph_vector_long_fill(distance, no_of_nodes);
    DIST(target) = 0;

    igraph_dqueue_long_push(bfsq, target);
    while (!igraph_dqueue_long_empty(bfsq)) {
        long int node = igraph_dqueue_long_pop(bfsq);
        long int ndist = DIST(node) + 1;
        for (k = FIRST(node), l = LAST(node); k < l; k++) {
            if (RESCAP(REV(k)) > 0) {
                long int nei = HEAD(k);
                if (DIST(nei) == no_of_nodes) {
                    DIST(nei) = ndist;
                    CURRENT(nei) = FIRST(nei);
                    if (EXCESS(nei) > 0) {
                        igraph_buckets_add(buckets, ndist, nei);
                    } else {
                        igraph_dbuckets_add(ibuckets, ndist, nei);
                    }
                    igraph_dqueue_long_push(bfsq, nei);
                }
            }
        }
    }
}

/**
 * \function igraph_maxflow
 * Maximum network flow between a pair of vertices
 *
 * This function implements the Goldberg-Tarjan algorithm for
 * calculating value of the maximum flow in a directed or undirected
 * graph. The algorithm was given in Andrew V. Goldberg, Robert
 * E. Tarjan: A New Approach to the Maximum-Flow Problem, Journal of
 * the ACM, 35(4), 921-940, 1988. 
 *
 *  The input of the function is a graph, a vector
 * of real numbers giving the capacity of the edges and two vertices
 * of the graph, the source and the target. A flow is a function
 * assigning positive real numbers to the edges and satisfying two
 * requirements: (1) the flow value is less than the capacity of the
 * edge and (2) at each vertex except the source and the target, the
 * incoming flow (i.e. the sum of the flow on the incoming edges) is
 * the same as the outgoing flow (i.e. the sum of the flow on the
 * outgoing edges). The value of the flow is the incoming flow at the
 * target vertex. The maximum flow is the flow with the maximum
 * value.
 *
 * \param graph The input graph, either directed or undirected.
 * \param value Pointer to a real number, the value of the maximum
 *        will be placed here, unless it is a null pointer.
 * \param flow If not a null pointer, then it must be a pointer to an
 *        initialized vector. The vector will be resized, and the flow
 *        on each edge will be placed in it, in the order of the edge
 *        ids. For undirected graphs this argument is bit trickier,
 *        since for these the flow direction is not predetermined by
 *        the edge direction. For these graphs the elements of the
 *        \p flow vector can be negative, this means that the flow
 *        goes from the bigger vertex id to the smaller one. Positive
 *        values mean that the flow goes from the smaller vertex id to
 *        the bigger one.
 * \param cut A null pointer or a pointer to an initialized vector.
 *        If not a null pointer, then the minimum cut corresponding to
 *        the maximum flow is stored here, i.e. all edge ids that are
 *        part of the minimum cut are stored in the vector.
 * \param partition A null pointer or a pointer to an initialized
 *        vector. If not a null pointer, then the first partition of
 *        the minimum cut that corresponds to the maximum flow will be
 *        placed here. The first partition is always the one that
 *        contains the source vertex.
 * \param partition2 A null pointer or a pointer to an initialized
 *        vector. If not a null pointer, then the second partition of
 *        the minimum cut that corresponds to the maximum flow will be
 *        placed here. The second partition is always the one that
 *        contains the target vertex.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \param capacity Vector containing the capacity of the edges. If NULL, then
 *        every edge is considered to have capacity 1.0.
 * \param stats Counts of the number of different operations
 *        preformed by the algorithm are stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|^3). In practice it is much faster, but i
 * cannot prove a better lower bound for the data structure i've
 * used. In fact, this implementation runs much faster than the
 * \c hi_pr implementation discussed in
 * B. V. Cherkassky and A. V. Goldberg: On implementing the
 * push-relabel method for the maximum flow problem, (Algorithmica,
 * 19:390--410, 1997) on all the graph classes i've tried.
 *
 * \sa \ref igraph_mincut_value(), \ref igraph_edge_connectivity(),
 * \ref igraph_vertex_connectivity() for
 * properties based on the maximum flow.
 *
 * \example examples/simple/flow.c
 * \example examples/simple/flow2.c
 */

int igraph_maxflow(const igraph_t *graph, igraph_real_t *value,
                   igraph_vector_t *flow, igraph_vector_t *cut,
                   igraph_vector_t *partition, igraph_vector_t *partition2,
                   igraph_integer_t source, igraph_integer_t target,
                   const igraph_vector_t *capacity,
                   igraph_maxflow_stats_t *stats) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_integer_t no_of_orig_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_integer_t no_of_edges = 2 * no_of_orig_edges;

    igraph_vector_t rescap, excess;
    igraph_vector_long_t from, to, rev, distance;
    igraph_vector_t edges, rank;
    igraph_vector_long_t current, first;
    igraph_buckets_t buckets;
    igraph_dbuckets_t ibuckets;

    igraph_dqueue_long_t bfsq;

    long int i, j, idx;
    int npushsince = 0, nrelabelsince = 0;

    igraph_maxflow_stats_t local_stats;   /* used if the user passed a null pointer for stats */

    if (stats == 0) {
        stats = &local_stats;
    }

    if (!igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_maxflow_undirected(graph, value, flow, cut,
                     partition, partition2, source,
                     target, capacity, stats));
        return 0;
    }

    if (capacity && igraph_vector_size(capacity) != no_of_orig_edges) {
        IGRAPH_ERROR("Invalid capacity vector", IGRAPH_EINVAL);
    }
    if (source < 0 || source >= no_of_nodes || target < 0 || target >= no_of_nodes) {
        IGRAPH_ERROR("Invalid source or target vertex", IGRAPH_EINVAL);
    }

    stats->nopush = stats->norelabel = stats->nogap = stats->nogapnodes =
                                           stats->nobfs = 0;

    /*
     * The data structure:
     * - First of all, we consider every edge twice, first the edge
     *   itself, but also its opposite.
     * - (from, to) contain all edges (original + opposite), ordered by
     *   the id of the source vertex. During the algorithm we just need
     *   'to', so from is destroyed soon. We only need it in the
     *   beginning, to create the 'first' pointers.
     * - 'first' is a pointer vector for 'to', first[i] points to the
     *   first neighbor of vertex i and first[i+1]-1 is the last
     *   neighbor of vertex i. (Unless vertex i is isolate, in which
     *   case first[i]==first[i+1]).
     * - 'rev' contains a mapping from an edge to its opposite pair
     * - 'rescap' contains the residual capacities of the edges, this is
     *   initially equal to the capacity of the edges for the original
     *   edges and it is zero for the opposite edges.
     * - 'excess' contains the excess flow for the vertices. I.e. the flow
     *   that is coming in, but it is not going out.
     * - 'current' stores the next neighboring vertex to check, for every
     *   vertex, when excess flow is being pushed to neighbors.
     * - 'distance' stores the distance of the vertices from the source.
     * - 'rank' and 'edges' are only needed temporarily, for ordering and
     *   storing the edges.
     * - we use an igraph_buckets_t data structure ('buckets') to find
     *   the vertices with the highest 'distance' values quickly.
     *   This always contains the vertices that have a positive excess
     *   flow.
     */
#undef FIRST
#undef LAST
#undef CURRENT
#undef RESCAP
#undef REV
#undef HEAD
#undef EXCESS
#undef DIST
#define FIRST(i)       (VECTOR(first)[(i)])
#define LAST(i)        (VECTOR(first)[(i)+1])
#define CURRENT(i)     (VECTOR(current)[(i)])
#define RESCAP(i)      (VECTOR(rescap)[(i)])
#define REV(i)         (VECTOR(rev)[(i)])
#define HEAD(i)        (VECTOR(to)[(i)])
#define EXCESS(i)      (VECTOR(excess)[(i)])
#define DIST(i)        (VECTOR(distance)[(i)])

    igraph_dqueue_long_init(&bfsq,             no_of_nodes);
    IGRAPH_FINALLY(igraph_dqueue_long_destroy, &bfsq);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&to,       no_of_edges);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&rev,      no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&rescap,        no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&excess,        no_of_nodes);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&distance, no_of_nodes);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&first,    no_of_nodes + 1);

    IGRAPH_VECTOR_INIT_FINALLY(&rank,          no_of_edges);
    IGRAPH_VECTOR_LONG_INIT_FINALLY(&from,     no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&edges,         no_of_edges);

    /* Create the basic data structure */
    IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
    IGRAPH_CHECK(igraph_vector_rank(&edges, &rank, no_of_nodes));

    for (i = 0; i < no_of_edges; i += 2) {
        long int pos = (long int) VECTOR(rank)[i];
        long int pos2 = (long int) VECTOR(rank)[i + 1];
        VECTOR(from)[pos] = VECTOR(edges)[i];
        VECTOR(to)[pos]   = VECTOR(edges)[i + 1];
        VECTOR(from)[pos2] = VECTOR(edges)[i + 1];
        VECTOR(to)[pos2]   = VECTOR(edges)[i];
        VECTOR(rev)[pos] = pos2;
        VECTOR(rev)[pos2] = pos;
        VECTOR(rescap)[pos] = capacity ? VECTOR(*capacity)[i / 2] : 1.0;
        VECTOR(rescap)[pos2] = 0.0;
    }

    /* The first pointers. This is a but trickier, than one would
       think, because of the possible isolate vertices. */

    idx = -1;
    for (i = 0; i <= VECTOR(from)[0]; i++) {
        idx++; VECTOR(first)[idx] = 0;
    }
    for (i = 1; i < no_of_edges; i++) {
        long int n = (long int) (VECTOR(from)[i] -
                                 VECTOR(from)[ (long int) VECTOR(first)[idx] ]);
        for (j = 0; j < n; j++) {
            idx++; VECTOR(first)[idx] = i;
        }
    }
    idx++;
    while (idx < no_of_nodes + 1) {
        VECTOR(first)[idx++] = no_of_edges;
    }

    igraph_vector_long_destroy(&from);
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(2);

    if (!flow) {
        igraph_vector_destroy(&rank);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* And the current pointers, initially the same as the first */
    IGRAPH_VECTOR_LONG_INIT_FINALLY(¤t, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(current)[i] = VECTOR(first)[i];
    }

    /* OK, the graph is set up, initialization */

    IGRAPH_CHECK(igraph_buckets_init(&buckets, no_of_nodes + 1, no_of_nodes));
    IGRAPH_FINALLY(igraph_buckets_destroy, &buckets);
    IGRAPH_CHECK(igraph_dbuckets_init(&ibuckets, no_of_nodes + 1, no_of_nodes));
    IGRAPH_FINALLY(igraph_dbuckets_destroy, &ibuckets);

    /* Send as much flow as possible from the source to its neighbors */
    for (i = FIRST(source), j = LAST(source); i < j; i++) {
        if (HEAD(i) != source) {
            igraph_real_t delta = RESCAP(i);
            RESCAP(i) = 0;
            RESCAP(REV(i)) += delta;
            EXCESS(HEAD(i)) += delta;
        }
    }

    BFS();
    (stats->nobfs)++;

    while (!igraph_buckets_empty(&buckets)) {
        long int vertex = igraph_buckets_popmax(&buckets);
        DISCHARGE(vertex);
        if (npushsince > no_of_nodes / 2 && nrelabelsince > no_of_nodes) {
            (stats->nobfs)++;
            BFS();
            npushsince = nrelabelsince = 0;
        }
    }

    /* Store the result */
    if (value) {
        *value = EXCESS(target);
    }

    /* If we also need the minimum cut */
    if (cut || partition || partition2) {
        /* We need to find all vertices from which the target is reachable
           in the residual graph. We do a breadth-first search, going
           backwards. */
        igraph_dqueue_t Q;
        igraph_vector_bool_t added;
        long int marked = 0;

        IGRAPH_CHECK(igraph_vector_bool_init(&added, no_of_nodes));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, &added);

        IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
        IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);

        igraph_dqueue_push(&Q, target);
        VECTOR(added)[(long int)target] = 1;
        marked++;
        while (!igraph_dqueue_empty(&Q)) {
            long int actnode = (long int) igraph_dqueue_pop(&Q);
            for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) {
                long int nei = HEAD(i);
                if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) {
                    VECTOR(added)[nei] = 1;
                    marked++;
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
                }
            }
        }
        igraph_dqueue_destroy(&Q);
        IGRAPH_FINALLY_CLEAN(1);

        /* Now we marked each vertex that is on one side of the cut,
           check the crossing edges */

        if (cut) {
            igraph_vector_clear(cut);
            for (i = 0; i < no_of_orig_edges; i++) {
                long int f = IGRAPH_FROM(graph, i);
                long int t = IGRAPH_TO(graph, i);
                if (!VECTOR(added)[f] && VECTOR(added)[t]) {
                    IGRAPH_CHECK(igraph_vector_push_back(cut, i));
                }
            }
        }

        if (partition2) {
            long int x = 0;
            IGRAPH_CHECK(igraph_vector_resize(partition2, marked));
            for (i = 0; i < no_of_nodes; i++) {
                if (VECTOR(added)[i]) {
                    VECTOR(*partition2)[x++] = i;
                }
            }
        }

        if (partition) {
            long int x = 0;
            IGRAPH_CHECK(igraph_vector_resize(partition,
                                              no_of_nodes - marked));
            for (i = 0; i < no_of_nodes; i++) {
                if (!VECTOR(added)[i]) {
                    VECTOR(*partition)[x++] = i;
                }
            }
        }

        igraph_vector_bool_destroy(&added);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (flow) {
        /* Initialize the backward distances, with a breadth-first search
           from the source */
        igraph_dqueue_t Q;
        igraph_vector_int_t added;
        long int j, k, l;
        igraph_t flow_graph;
        igraph_vector_t flow_edges;
        igraph_bool_t dag;

        IGRAPH_CHECK(igraph_vector_int_init(&added, no_of_nodes));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &added);
        IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
        IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);

        igraph_dqueue_push(&Q, source);
        igraph_dqueue_push(&Q, 0);
        VECTOR(added)[(long int)source] = 1;
        while (!igraph_dqueue_empty(&Q)) {
            long int actnode = (long int) igraph_dqueue_pop(&Q);
            long int actdist = (long int) igraph_dqueue_pop(&Q);
            DIST(actnode) = actdist;

            for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) {
                long int nei = HEAD(i);
                if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) {
                    VECTOR(added)[nei] = 1;
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, actdist + 1));
                }
            }
        } /* !igraph_dqueue_empty(&Q) */

        igraph_vector_int_destroy(&added);
        igraph_dqueue_destroy(&Q);
        IGRAPH_FINALLY_CLEAN(2);

        /* Reinitialize the buckets */
        igraph_buckets_clear(&buckets);
        for (i = 0; i < no_of_nodes; i++) {
            if (EXCESS(i) > 0.0 && i != source && i != target) {
                igraph_buckets_add(&buckets, (long int) DIST(i), i);
            }
        }

        /* Now we return the flow to the source */
        while (!igraph_buckets_empty(&buckets)) {
            long int vertex = igraph_buckets_popmax(&buckets);

            /* DISCHARGE(vertex) comes here */
            do {
                for (i = (long int) CURRENT(vertex), j = LAST(vertex); i < j; i++) {
                    if (RESCAP(i) > 0) {
                        long int nei = HEAD(i);

                        if (DIST(vertex) == DIST(nei) + 1) {
                            igraph_real_t delta =
                                RESCAP(i) < EXCESS(vertex) ? RESCAP(i) : EXCESS(vertex);
                            RESCAP(i) -= delta;
                            RESCAP(REV(i)) += delta;

                            if (nei != source && EXCESS(nei) == 0.0 &&
                                DIST(nei) != no_of_nodes) {
                                igraph_buckets_add(&buckets, (long int) DIST(nei), nei);
                            }

                            EXCESS(nei) += delta;
                            EXCESS(vertex) -= delta;

                            if (EXCESS(vertex) == 0) {
                                break;
                            }

                        }
                    }
                }

                if (i == j) {

                    /* RELABEL(vertex) comes here */
                    igraph_real_t min;
                    long int min_edge = 0;
                    DIST(vertex) = min = no_of_nodes;
                    for (k = FIRST(vertex), l = LAST(vertex); k < l; k++) {
                        if (RESCAP(k) > 0) {
                            if (DIST(HEAD(k)) < min) {
                                min = DIST(HEAD(k));
                                min_edge = k;
                            }
                        }
                    }

                    min++;

                    if (min < no_of_nodes) {
                        DIST(vertex) = min;
                        CURRENT(vertex) = min_edge;
                        /* Vertex is still active */
                        igraph_buckets_add(&buckets, (long int) DIST(vertex), vertex);
                    }

                    /* TODO: gap heuristics here ??? */

                } else {
                    CURRENT(vertex) = FIRST(vertex);
                }

                break;

            } while (1);
        }

        /* We need to eliminate flow cycles now. Before that we check that
           there is a cycle in the flow graph.

           First we do a couple of DFSes from the source vertex to the
           target and factor out the paths we find. If there is no more
           path to the target, then all remaining flow must be in flow
           cycles, so we don't need it at all.

           Some details. 'stack' contains the whole path of the DFS, both
           the vertices and the edges, they are alternating in the stack.
           'current' helps finding the next outgoing edge of a vertex
           quickly, the next edge of 'v' is FIRST(v)+CURRENT(v). If this
           is LAST(v), then there are no more edges to try.

           The 'added' vector contains 0 if the vertex was not visited
           before, 1 if it is currently in 'stack', and 2 if it is not in
           'stack', but it was visited before. */

        IGRAPH_VECTOR_INIT_FINALLY(&flow_edges, 0);
        for (i = 0, j = 0; i < no_of_edges; i += 2, j++) {
            long int pos = (long int) VECTOR(rank)[i];
            if ((capacity ? VECTOR(*capacity)[j] : 1.0) > RESCAP(pos)) {
                IGRAPH_CHECK(igraph_vector_push_back(&flow_edges,
                                                     IGRAPH_FROM(graph, j)));
                IGRAPH_CHECK(igraph_vector_push_back(&flow_edges,
                                                     IGRAPH_TO(graph, j)));
            }
        }
        IGRAPH_CHECK(igraph_create(&flow_graph, &flow_edges, no_of_nodes,
                                   IGRAPH_DIRECTED));
        igraph_vector_destroy(&flow_edges);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_FINALLY(igraph_destroy, &flow_graph);
        IGRAPH_CHECK(igraph_is_dag(&flow_graph, &dag));
        igraph_destroy(&flow_graph);
        IGRAPH_FINALLY_CLEAN(1);

        if (!dag) {
            igraph_vector_long_t stack;
            igraph_vector_t mycap;

            IGRAPH_CHECK(igraph_vector_long_init(&stack, 0));
            IGRAPH_FINALLY(igraph_vector_long_destroy, &stack);
            IGRAPH_CHECK(igraph_vector_int_init(&added, no_of_nodes));
            IGRAPH_FINALLY(igraph_vector_int_destroy, &added);
            IGRAPH_VECTOR_INIT_FINALLY(&mycap, no_of_edges);

#define MYCAP(i)      (VECTOR(mycap)[(i)])

            for (i = 0; i < no_of_edges; i += 2) {
                long int pos = (long int) VECTOR(rank)[i];
                long int pos2 = (long int) VECTOR(rank)[i + 1];
                MYCAP(pos) = (capacity ? VECTOR(*capacity)[i / 2] : 1.0) - RESCAP(pos);
                MYCAP(pos2) = 0.0;
            }

            do {
                igraph_vector_long_null(¤t);
                igraph_vector_long_clear(&stack);
                igraph_vector_int_null(&added);

                IGRAPH_CHECK(igraph_vector_long_push_back(&stack, -1));
                IGRAPH_CHECK(igraph_vector_long_push_back(&stack, source));
                VECTOR(added)[(long int)source] = 1;
                while (!igraph_vector_long_empty(&stack) &&
                       igraph_vector_long_tail(&stack) != target) {
                    long int actnode = igraph_vector_long_tail(&stack);
                    long int edge = FIRST(actnode) + (long int) CURRENT(actnode);
                    long int nei;
                    while (edge < LAST(actnode) && MYCAP(edge) == 0.0) {
                        edge++;
                    }
                    nei = edge < LAST(actnode) ? HEAD(edge) : -1;

                    if (edge < LAST(actnode) && !VECTOR(added)[nei]) {
                        /* Go forward along next edge, if the vertex was not
                           visited before */
                        IGRAPH_CHECK(igraph_vector_long_push_back(&stack, edge));
                        IGRAPH_CHECK(igraph_vector_long_push_back(&stack, nei));
                        VECTOR(added)[nei] = 1;
                        CURRENT(actnode) += 1;
                    } else if (edge < LAST(actnode) && VECTOR(added)[nei] == 1) {
                        /* We found a flow cycle, factor it out. Go back in stack
                           until we find 'nei' again, determine the flow along the
                           cycle. */
                        igraph_real_t thisflow = MYCAP(edge);
                        long int idx;
                        for (idx = igraph_vector_long_size(&stack) - 2;
                             idx >= 0 && VECTOR(stack)[idx + 1] != nei; idx -= 2) {
                            long int e = VECTOR(stack)[idx];
                            igraph_real_t rcap = e >= 0 ? MYCAP(e) : MYCAP(edge);
                            if (rcap < thisflow) {
                                thisflow = rcap;
                            }
                        }
                        MYCAP(edge) -= thisflow; RESCAP(edge) += thisflow;
                        for (idx = igraph_vector_long_size(&stack) - 2;
                             idx >= 0 && VECTOR(stack)[idx + 1] != nei; idx -= 2) {
                            long int e = VECTOR(stack)[idx];
                            if (e >= 0) {
                                MYCAP(e) -= thisflow;
                                RESCAP(e) += thisflow;
                            }
                        }
                        CURRENT(actnode) += 1;
                    } else if (edge < LAST(actnode)) { /* && VECTOR(added)[nei]==2 */
                        /* The next edge leads to a vertex that was visited before,
                           but it is currently not in 'stack' */
                        CURRENT(actnode) += 1;
                    } else {
                        /* Go backward, take out the node and the edge that leads to it */
                        igraph_vector_long_pop_back(&stack);
                        igraph_vector_long_pop_back(&stack);
                        VECTOR(added)[actnode] = 2;
                    }
                }

                /* If non-empty, then it contains a path from source to target
                   in the residual graph. We factor out this path from the flow. */
                if (!igraph_vector_long_empty(&stack)) {
                    long int pl = igraph_vector_long_size(&stack);
                    igraph_real_t thisflow = EXCESS(target);
                    for (i = 2; i < pl; i += 2) {
                        long int edge = VECTOR(stack)[i];
                        igraph_real_t rcap = MYCAP(edge);
                        if (rcap < thisflow) {
                            thisflow = rcap;
                        }
                    }
                    for (i = 2; i < pl; i += 2) {
                        long int edge = VECTOR(stack)[i];
                        MYCAP(edge) -= thisflow;
                    }
                }

            } while (!igraph_vector_long_empty(&stack));

            igraph_vector_destroy(&mycap);
            igraph_vector_int_destroy(&added);
            igraph_vector_long_destroy(&stack);
            IGRAPH_FINALLY_CLEAN(3);
        }

        /* ----------------------------------------------------------- */

        IGRAPH_CHECK(igraph_vector_resize(flow, no_of_orig_edges));
        for (i = 0, j = 0; i < no_of_edges; i += 2, j++) {
            long int pos = (long int) VECTOR(rank)[i];
            VECTOR(*flow)[j] = (capacity ? VECTOR(*capacity)[j] : 1.0) -
                               RESCAP(pos);
        }

        igraph_vector_destroy(&rank);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_dbuckets_destroy(&ibuckets);
    igraph_buckets_destroy(&buckets);
    igraph_vector_long_destroy(¤t);
    igraph_vector_long_destroy(&first);
    igraph_vector_long_destroy(&distance);
    igraph_vector_destroy(&excess);
    igraph_vector_destroy(&rescap);
    igraph_vector_long_destroy(&rev);
    igraph_vector_long_destroy(&to);
    igraph_dqueue_long_destroy(&bfsq);
    IGRAPH_FINALLY_CLEAN(10);

    return 0;
}

/**
 * \function igraph_maxflow_value
 * \brief Maximum flow in a network with the push/relabel algorithm
 *
 * This function implements the Goldberg-Tarjan algorithm for
 * calculating value of the maximum flow in a directed or undirected
 * graph. The algorithm was given in Andrew V. Goldberg, Robert
 * E. Tarjan: A New Approach to the Maximum-Flow Problem, Journal of
 * the ACM, 35(4), 921-940, 1988. 
 *
 *  The input of the function is a graph, a vector
 * of real numbers giving the capacity of the edges and two vertices
 * of the graph, the source and the target. A flow is a function
 * assigning positive real numbers to the edges and satisfying two
 * requirements: (1) the flow value is less than the capacity of the
 * edge and (2) at each vertex except the source and the target, the
 * incoming flow (i.e. the sum of the flow on the incoming edges) is
 * the same as the outgoing flow (i.e. the sum of the flow on the
 * outgoing edges). The value of the flow is the incoming flow at the
 * target vertex. The maximum flow is the flow with the maximum
 * value. 
 *
 *  According to a theorem by Ford and Fulkerson
 * (L. R. Ford Jr. and D. R. Fulkerson. Maximal flow through a
 * network. Canadian J. Math., 8:399-404, 1956.) the maximum flow
 * between two vertices is the same as the
 * minimum cut between them (also called the minimum s-t cut). So \ref
 * igraph_st_mincut_value() gives the same result in all cases as \c
 * igraph_maxflow_value().
 *
 *  Note that the value of the maximum flow is the same as the
 * minimum cut in the graph.
 * \param graph The input graph, either directed or undirected.
 * \param value Pointer to a real number, the result will be placed here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \param capacity Vector containing the capacity of the edges. If NULL, then
 *        every edge is considered to have capacity 1.0.
 * \param stats Counts of the number of different operations
 *        preformed by the algorithm are stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|^3).
 *
 * \sa \ref igraph_maxflow() to calculate the actual flow.
 * \ref igraph_mincut_value(), \ref igraph_edge_connectivity(),
 * \ref igraph_vertex_connectivity() for
 * properties based on the maximum flow.
 */

int igraph_maxflow_value(const igraph_t *graph, igraph_real_t *value,
                         igraph_integer_t source, igraph_integer_t target,
                         const igraph_vector_t *capacity,
                         igraph_maxflow_stats_t *stats) {

    return igraph_maxflow(graph, value, /*flow=*/ 0, /*cut=*/ 0,
                          /*partition=*/ 0, /*partition1=*/ 0,
                          source, target, capacity, stats);
}

/**
 * \function igraph_st_mincut_value
 * \brief The minimum s-t cut in a graph
 *
 *  The minimum s-t cut in a weighted (=valued) graph is the
 * total minimum edge weight needed to remove from the graph to
 * eliminate all paths from a given vertex (\c source) to
 * another vertex (\c target). Directed paths are considered in
 * directed graphs, and undirected paths in undirected graphs.  
 *
 *  The minimum s-t cut between two vertices is known to be same
 * as the maximum flow between these two vertices. So this function
 * calls \ref igraph_maxflow_value() to do the calculation.
 * \param graph The input graph.
 * \param value Pointer to a real variable, the result will be stored
 *        here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \param capacity Pointer to the capacity vector, it should contain
 *        non-negative numbers and its length should be the same the
 *        the number of edges in the graph. It can be a null pointer, then
 *        every edge has unit capacity.
 * \return Error code.
 *
 * Time complexity: O(|V|^3), see also the discussion for \ref
 * igraph_maxflow_value(), |V| is the number of vertices.
 */

int igraph_st_mincut_value(const igraph_t *graph, igraph_real_t *value,
                           igraph_integer_t source, igraph_integer_t target,
                           const igraph_vector_t *capacity) {

    if (source == target) {
        IGRAPH_ERROR("source and target vertices are the same", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_maxflow_value(graph, value, source, target, capacity, 0));

    return 0;
}

/**
 * \function igraph_st_mincut
 * Minimum cut between a source and a target vertex
 *
 * Finds the edge set that has the smallest total capacity among all
 * edge sets that disconnect the source and target vertices.
 *
 * The calculation is performed using maximum flow
 * techniques, by calling \ref igraph_maxflow().
 * \param graph The input graph.
 * \param value Pointer to a real variable, the value of the cut is
 *        stored here.
 * \param cut Pointer to a real vector, the edge ids that are included
 *        in the cut are stored here. This argument is ignored if it
 *        is a null pointer.
 * \param partition Pointer to a real vector, the vertex ids of the
 *        vertices in the first partition of the cut are stored
 *        here. The first partition is always the one that contains the
 *        source vertex. This argument is ignored if it is a null pointer.
 * \param partition2 Pointer to a real vector, the vertex ids of the
 *        vertices in the second partition of the cut are stored here.
 *        The second partition is always the one that contains the
 *        target vertex. This argument is ignored if it is a null pointer.
 * \param source Integer, the id of the source vertex.
 * \param target Integer, the id of the target vertex.
 * \param capacity Vector containing the capacity of the edges. If a
 *        null pointer, then every edge is considered to have capacity
 *        1.0.
 * \return Error code.
 *
 * \sa \ref igraph_maxflow().
 *
 * Time complexity: see \ref igraph_maxflow().
 */

int igraph_st_mincut(const igraph_t *graph, igraph_real_t *value,
                     igraph_vector_t *cut, igraph_vector_t *partition,
                     igraph_vector_t *partition2,
                     igraph_integer_t source, igraph_integer_t target,
                     const igraph_vector_t *capacity) {

    return igraph_maxflow(graph, value, /*flow=*/ 0,
                          cut, partition, partition2,
                          source, target, capacity, 0);
}

/* This is a flow-based version, but there is a better one
   for undirected graphs */

/* int igraph_i_mincut_value_undirected(const igraph_t *graph, */
/*                   igraph_real_t *res, */
/*                   const igraph_vector_t *capacity) { */

/*   long int no_of_edges=igraph_ecount(graph); */
/*   long int no_of_nodes=igraph_vcount(graph); */
/*   igraph_vector_t edges; */
/*   igraph_vector_t newcapacity; */
/*   igraph_t newgraph; */
/*   long int i; */

/*   /\* We need to convert this to directed by hand, since we need to be */
/*      sure that the edge ids will be handled properly to build the new */
/*      capacity vector. *\/ */

/*   IGRAPH_VECTOR_INIT_FINALLY(&edges, 0); */
/*   IGRAPH_VECTOR_INIT_FINALLY(&newcapacity, no_of_edges*2); */
/*   IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges*4)); */
/*   IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0)); */
/*   IGRAPH_CHECK(igraph_vector_resize(&edges, no_of_edges*4)); */
/*   for (i=0; i= 2) {

        long int last;
        igraph_real_t acut;
        long int a, n;

        igraph_vector_int_t *edges, *edges2;
        igraph_vector_int_t *neis, *neis2;

        do {
            a = igraph_i_cutheap_popmax(&heap);

            /* update the weights of the active vertices connected to a */
            edges = igraph_inclist_get(&inclist, a);
            neis = igraph_adjlist_get(&adjlist, a);
            n = igraph_vector_int_size(edges);
            for (i = 0; i < n; i++) {
                igraph_integer_t edge = (igraph_integer_t) VECTOR(*edges)[i];
                igraph_integer_t to = (igraph_integer_t) VECTOR(*neis)[i];
                igraph_real_t weight = capacity ? VECTOR(*capacity)[(long int)edge] : 1.0;
                igraph_i_cutheap_update(&heap, to, weight);
            }

        } while (igraph_i_cutheap_active_size(&heap) > 1);

        /* Now, there is only one active vertex left,
           calculate the cut of the phase */
        acut = igraph_i_cutheap_maxvalue(&heap);
        last = igraph_i_cutheap_popmax(&heap);

        if (acut < mincut) {
            mincut = acut;
            mincut_step = act_step;
        }

        if (mincut == 0) {
            break;
        }

        /* And contract the last and the remaining vertex (a and last) */
        /* Before actually doing that, make some notes */
        act_step++;
        if (calc_cut) {
            IGRAPH_CHECK(igraph_vector_push_back(&mergehist, a));
            IGRAPH_CHECK(igraph_vector_push_back(&mergehist, last));
        }
        /* First remove the a--last edge if there is one, a is still the
           last deactivated vertex */
        edges = igraph_inclist_get(&inclist, a);
        neis = igraph_adjlist_get(&adjlist, a);
        n = igraph_vector_int_size(edges);
        for (i = 0; i < n; ) {
            if (VECTOR(*neis)[i] == last) {
                VECTOR(*neis)[i] = VECTOR(*neis)[n - 1];
                VECTOR(*edges)[i] = VECTOR(*edges)[n - 1];
                igraph_vector_int_pop_back(neis);
                igraph_vector_int_pop_back(edges);
                n--;
            } else {
                i++;
            }
        }

        edges = igraph_inclist_get(&inclist, last);
        neis = igraph_adjlist_get(&adjlist, last);
        n = igraph_vector_int_size(edges);
        for (i = 0; i < n; ) {
            if (VECTOR(*neis)[i] == a) {
                VECTOR(*neis)[i] = VECTOR(*neis)[n - 1];
                VECTOR(*edges)[i] = VECTOR(*edges)[n - 1];
                igraph_vector_int_pop_back(neis);
                igraph_vector_int_pop_back(edges);
                n--;
            } else {
                i++;
            }
        }

        /* Now rewrite the edge lists of last's neighbors */
        neis = igraph_adjlist_get(&adjlist, last);
        n = igraph_vector_int_size(neis);
        for (i = 0; i < n; i++) {
            igraph_integer_t nei = (igraph_integer_t) VECTOR(*neis)[i];
            long int n2, j;
            neis2 = igraph_adjlist_get(&adjlist, nei);
            n2 = igraph_vector_int_size(neis2);
            for (j = 0; j < n2; j++) {
                if (VECTOR(*neis2)[j] == last) {
                    VECTOR(*neis2)[j] = a;
                }
            }
        }

        /* And append the lists of last to the lists of a */
        edges = igraph_inclist_get(&inclist, a);
        neis = igraph_adjlist_get(&adjlist, a);
        edges2 = igraph_inclist_get(&inclist, last);
        neis2 = igraph_adjlist_get(&adjlist, last);
        IGRAPH_CHECK(igraph_vector_int_append(edges, edges2));
        IGRAPH_CHECK(igraph_vector_int_append(neis, neis2));
        igraph_vector_int_clear(edges2); /* TODO: free it */
        igraph_vector_int_clear(neis2);  /* TODO: free it */

        /* Remove the deleted vertex from the heap entirely */
        igraph_i_cutheap_reset_undefine(&heap, last);
    }

    *res = mincut;

    igraph_inclist_destroy(&inclist);
    igraph_adjlist_destroy(&adjlist);
    igraph_i_cutheap_destroy(&heap);
    IGRAPH_FINALLY_CLEAN(3);

    if (calc_cut) {
        long int bignode = (long int) VECTOR(mergehist)[2 * mincut_step + 1];
        long int i, idx;
        long int size = 1;
        char *mark;
        mark = IGRAPH_CALLOC(no_of_nodes, char);
        if (!mark) {
            IGRAPH_ERROR("Not enough memory for minimum cut", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, mark);

        /* first count the vertices in the partition */
        mark[bignode] = 1;
        for (i = mincut_step - 1; i >= 0; i--) {
            if ( mark[ (long int) VECTOR(mergehist)[2 * i] ] ) {
                size++;
                mark [ (long int) VECTOR(mergehist)[2 * i + 1] ] = 1;
            }
        }

        /* now store them, if requested */
        if (partition) {
            IGRAPH_CHECK(igraph_vector_resize(partition, size));
            idx = 0;
            VECTOR(*partition)[idx++] = bignode;
            for (i = mincut_step - 1; i >= 0; i--) {
                if (mark[ (long int) VECTOR(mergehist)[2 * i] ]) {
                    VECTOR(*partition)[idx++] = VECTOR(mergehist)[2 * i + 1];
                }
            }
        }

        /* The other partition too? */
        if (partition2) {
            IGRAPH_CHECK(igraph_vector_resize(partition2, no_of_nodes - size));
            idx = 0;
            for (i = 0; i < no_of_nodes; i++) {
                if (!mark[i]) {
                    VECTOR(*partition2)[idx++] = i;
                }
            }
        }

        /* The edges in the cut are also requested? */
        /* We want as few memory allocated for 'cut' as possible,
           so we first collect the edges in mergehist, we don't
           need that anymore. Then we copy it to 'cut';  */
        if (cut) {
            igraph_integer_t from, to;
            igraph_vector_clear(&mergehist);
            for (i = 0; i < no_of_edges; i++) {
                igraph_edge(graph, (igraph_integer_t) i, &from, &to);
                if ((mark[(long int)from] && !mark[(long int)to]) ||
                    (mark[(long int)to] && !mark[(long int)from])) {
                    IGRAPH_CHECK(igraph_vector_push_back(&mergehist, i));
                }
            }
            igraph_vector_clear(cut);
            IGRAPH_CHECK(igraph_vector_append(cut, &mergehist));
        }

        igraph_free(mark);
        igraph_vector_destroy(&mergehist);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return 0;
}

static int igraph_i_mincut_directed(const igraph_t *graph,
                                    igraph_real_t *value,
                                    igraph_vector_t *partition,
                                    igraph_vector_t *partition2,
                                    igraph_vector_t *cut,
                                    const igraph_vector_t *capacity) {
    long int i;
    long int no_of_nodes = igraph_vcount(graph);
    igraph_real_t flow;
    igraph_real_t minmaxflow = IGRAPH_INFINITY;
    igraph_vector_t mypartition, mypartition2, mycut;
    igraph_vector_t *ppartition = 0, *ppartition2 = 0, *pcut = 0;
    igraph_vector_t bestpartition, bestpartition2, bestcut;

    if (partition) {
        IGRAPH_VECTOR_INIT_FINALLY(&bestpartition, 0);
    }
    if (partition2) {
        IGRAPH_VECTOR_INIT_FINALLY(&bestpartition2, 0);
    }
    if (cut) {
        IGRAPH_VECTOR_INIT_FINALLY(&bestcut, 0);
    }

    if (partition) {
        IGRAPH_VECTOR_INIT_FINALLY(&mypartition, 0);
        ppartition = &mypartition;
    }
    if (partition2) {
        IGRAPH_VECTOR_INIT_FINALLY(&mypartition2, 0);
        ppartition2 = &mypartition2;
    }
    if (cut) {
        IGRAPH_VECTOR_INIT_FINALLY(&mycut, 0);
        pcut = &mycut;
    }

    for (i = 1; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_maxflow(graph, /*value=*/ &flow, /*flow=*/ 0,
                                    pcut, ppartition, ppartition2, /*source=*/ 0,
                                    /*target=*/ (igraph_integer_t) i, capacity, 0));
        if (flow < minmaxflow) {
            minmaxflow = flow;
            if (cut) {
                IGRAPH_CHECK(igraph_vector_update(&bestcut, &mycut));
            }
            if (partition) {
                IGRAPH_CHECK(igraph_vector_update(&bestpartition, &mypartition));
            }
            if (partition2) {
                IGRAPH_CHECK(igraph_vector_update(&bestpartition2, &mypartition2));
            }

            if (minmaxflow == 0) {
                break;
            }
        }
        IGRAPH_CHECK(igraph_maxflow(graph, /*value=*/ &flow, /*flow=*/ 0,
                                    pcut, ppartition, ppartition2,
                                    /*source=*/ (igraph_integer_t) i,
                                    /*target=*/ 0, capacity, 0));
        if (flow < minmaxflow) {
            minmaxflow = flow;
            if (cut) {
                IGRAPH_CHECK(igraph_vector_update(&bestcut, &mycut));
            }
            if (partition) {
                IGRAPH_CHECK(igraph_vector_update(&bestpartition, &mypartition));
            }
            if (partition2) {
                IGRAPH_CHECK(igraph_vector_update(&bestpartition2, &mypartition2));
            }

            if (minmaxflow == 0) {
                break;
            }
        }
    }

    if (value) {
        *value = minmaxflow;
    }

    if (cut) {
        igraph_vector_destroy(&mycut);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (partition) {
        igraph_vector_destroy(&mypartition);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (partition2) {
        igraph_vector_destroy(&mypartition2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (cut) {
        IGRAPH_CHECK(igraph_vector_update(cut, &bestcut));
        igraph_vector_destroy(&bestcut);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (partition2) {
        IGRAPH_CHECK(igraph_vector_update(partition2, &bestpartition2));
        igraph_vector_destroy(&bestpartition2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (partition) {
        IGRAPH_CHECK(igraph_vector_update(partition, &bestpartition));
        igraph_vector_destroy(&bestpartition);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_mincut
 * \brief Calculates the minimum cut in a graph.
 *
 * This function calculates the minimum cut in a graph.
 * The minimum cut is the minimum set of edges which needs to be
 * removed to disconnect the graph. The minimum is calculated using
 * the weights (\p capacity) of the edges, so the cut with the minimum
 * total capacity is calculated.
 *
 *  For directed graphs an implementation based on
 * calculating 2|V|-2 maximum flows is used.
 * For undirected graphs we use the Stoer-Wagner
 * algorithm, as described in M. Stoer and F. Wagner: A simple min-cut
 * algorithm, Journal of the ACM, 44 585-591, 1997.
 *
 * 
 * The first implementation of the actual cut calculation for
 * undirected graphs was made by Gregory Benison, thanks Greg.
 * \param graph The input graph.
 * \param value Pointer to a float, the value of the cut will be
 *    stored here.
 * \param partition Pointer to an initialized vector, the ids
 *    of the vertices in the first partition after separating the
 *    graph will be stored here. The vector will be resized as
 *    needed. This argument is ignored if it is a NULL pointer.
 * \param partition2 Pointer to an initialized vector the ids
 *    of the vertices in the second partition will be stored here.
 *    The vector will be resized as needed. This argument is ignored
 *    if it is a NULL pointer.
 * \param cut Pointer to an initialized vector, the ids of the edges
 *    in the cut will be stored here. This argument is ignored if it
 *    is a NULL pointer.
 * \param capacity A numeric vector giving the capacities of the
 *    edges. If a null pointer then all edges have unit capacity.
 * \return Error code.
 *
 * \sa \ref igraph_mincut_value(), a simpler interface for calculating
 * the value of the cut only.
 *
 * Time complexity: for directed graphs it is O(|V|^4), but see the
 * remarks at \ref igraph_maxflow(). For undirected graphs it is
 * O(|V||E|+|V|^2 log|V|). |V| and |E| are the number of vertices and
 * edges respectively.
 *
 * \example examples/simple/igraph_mincut.c
 */

int igraph_mincut(const igraph_t *graph,
                  igraph_real_t *value,
                  igraph_vector_t *partition,
                  igraph_vector_t *partition2,
                  igraph_vector_t *cut,
                  const igraph_vector_t *capacity) {

    if (igraph_is_directed(graph)) {
        if (partition || partition2 || cut) {
            igraph_i_mincut_directed(graph, value, partition, partition2, cut,
                                     capacity);
        } else {
            return igraph_mincut_value(graph, value, capacity);
        }
    } else {
        IGRAPH_CHECK(igraph_i_mincut_undirected(graph, value, partition,
                                                partition2, cut, capacity));
        return IGRAPH_SUCCESS;
    }

    return 0;
}


static int igraph_i_mincut_value_undirected(const igraph_t *graph,
                                            igraph_real_t *res,
                                            const igraph_vector_t *capacity) {
    return igraph_i_mincut_undirected(graph, res, 0, 0, 0, capacity);
}

/**
 * \function igraph_mincut_value
 * \brief The minimum edge cut in a graph
 *
 *  The minimum edge cut in a graph is the total minimum
 * weight of the edges needed to remove from the graph to make the
 * graph \em not strongly connected. (If the original graph is not
 * strongly connected then this is zero.) Note that in undirected
 * graphs strong connectedness is the same as weak connectedness. 
 *
 *  The minimum cut can be calculated with maximum flow
 * techniques, although the current implementation does this only for
 * directed graphs and a separate non-flow based implementation is
 * used for undirected graphs. See Mechthild Stoer and Frank Wagner: A
 * simple min-cut algorithm, Journal of the ACM 44 585--591, 1997.
 * For directed graphs
 * the maximum flow is calculated between a fixed vertex and all the
 * other vertices in the graph and this is done in both
 * directions. Then the minimum is taken to get the minimum cut.
 *
 * \param graph The input graph.
 * \param res Pointer to a real variable, the result will be stored
 *    here.
 * \param capacity Pointer to the capacity vector, it should contain
 *    the same number of non-negative numbers as the number of edges in
 *    the graph. If a null pointer then all edges will have unit capacity.
 * \return Error code.
 *
 * \sa \ref igraph_mincut(), \ref igraph_maxflow_value(), \ref
 * igraph_st_mincut_value().
 *
 * Time complexity: O(log(|V|)*|V|^2) for undirected graphs and
 * O(|V|^4) for directed graphs, but see also the discussion at the
 * documentation of \ref igraph_maxflow_value().
 */

int igraph_mincut_value(const igraph_t *graph, igraph_real_t *res,
                        const igraph_vector_t *capacity) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_real_t minmaxflow, flow;
    long int i;

    minmaxflow = IGRAPH_INFINITY;

    if (!igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_mincut_value_undirected(graph, res, capacity));
        return 0;
    }

    for (i = 1; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_maxflow_value(graph, &flow, 0, (igraph_integer_t) i,
                                          capacity, 0));
        if (flow < minmaxflow) {
            minmaxflow = flow;
            if (flow == 0) {
                break;
            }
        }
        IGRAPH_CHECK(igraph_maxflow_value(graph, &flow, (igraph_integer_t) i, 0,
                                          capacity, 0));
        if (flow < minmaxflow) {
            minmaxflow = flow;
            if (flow == 0) {
                break;
            }
        }
    }

    if (res) {
        *res = minmaxflow;
    }

    return 0;
}

static int igraph_i_st_vertex_connectivity_directed(const igraph_t *graph,
                                                    igraph_integer_t *res,
                                                    igraph_integer_t source,
                                                    igraph_integer_t target,
                                                    igraph_vconn_nei_t neighbors) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_integer_t no_of_edges = (igraph_integer_t) igraph_ecount(graph);
    igraph_vector_t edges;
    igraph_real_t real_res;
    igraph_t newgraph;
    long int i;
    igraph_bool_t conn1;

    if (source < 0 || source >= no_of_nodes || target < 0 || target >= no_of_nodes) {
        IGRAPH_ERROR("Invalid source or target vertex", IGRAPH_EINVAL);
    }

    switch (neighbors) {
    case IGRAPH_VCONN_NEI_ERROR:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn1));
        if (conn1) {
            IGRAPH_ERROR("vertices connected", IGRAPH_EINVAL);
        }
        break;
    case IGRAPH_VCONN_NEI_NEGATIVE:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn1));
        if (conn1) {
            *res = -1;
            return 0;
        }
        break;
    case IGRAPH_VCONN_NEI_NUMBER_OF_NODES:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn1));
        if (conn1) {
            *res = no_of_nodes;
            return 0;
        }
        break;
    case IGRAPH_VCONN_NEI_IGNORE:
        break;
    default:
        IGRAPH_ERROR("Unknown `igraph_vconn_nei_t'", IGRAPH_EINVAL);
        break;
    }

    /* Create the new graph */

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, 2 * (no_of_edges + no_of_nodes)));
    IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
    IGRAPH_CHECK(igraph_vector_resize(&edges, 2 * (no_of_edges + no_of_nodes)));

    for (i = 0; i < 2 * no_of_edges; i += 2) {
        igraph_integer_t to = (igraph_integer_t) VECTOR(edges)[i + 1];
        if (to != source && to != target) {
            VECTOR(edges)[i + 1] = no_of_nodes + to;
        }
    }

    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(edges)[ 2 * (no_of_edges + i)   ] = no_of_nodes + i;
        VECTOR(edges)[ 2 * (no_of_edges + i) + 1 ] = i;
    }

    IGRAPH_CHECK(igraph_create(&newgraph, &edges, 2 * no_of_nodes,
                               igraph_is_directed(graph)));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, &newgraph);

    /* Do the maximum flow */

    IGRAPH_CHECK(igraph_maxflow_value(&newgraph, &real_res,
                                      source, target, 0, 0));
    *res = (igraph_integer_t)real_res;

    igraph_destroy(&newgraph);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_st_vertex_connectivity_undirected(const igraph_t *graph,
                                                      igraph_integer_t *res,
                                                      igraph_integer_t source,
                                                      igraph_integer_t target,
                                                      igraph_vconn_nei_t neighbors) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    igraph_t newgraph;
    igraph_bool_t conn;

    if (source < 0 || source >= no_of_nodes || target < 0 || target >= no_of_nodes) {
        IGRAPH_ERROR("Invalid source or target vertex", IGRAPH_EINVAL);
    }

    switch (neighbors) {
    case IGRAPH_VCONN_NEI_ERROR:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn));
        if (conn) {
            IGRAPH_ERROR("vertices connected", IGRAPH_EINVAL);
        }
        break;
    case IGRAPH_VCONN_NEI_NEGATIVE:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn));
        if (conn) {
            *res = -1;
            return 0;
        }
        break;
    case IGRAPH_VCONN_NEI_NUMBER_OF_NODES:
        IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn));
        if (conn) {
            *res = no_of_nodes;
            return 0;
        }
        break;
    case IGRAPH_VCONN_NEI_IGNORE:
        break;
    default:
        IGRAPH_ERROR("Unknown `igraph_vconn_nei_t'", IGRAPH_EINVAL);
        break;
    }

    IGRAPH_CHECK(igraph_copy(&newgraph, graph));
    IGRAPH_FINALLY(igraph_destroy, &newgraph);
    IGRAPH_CHECK(igraph_to_directed(&newgraph, IGRAPH_TO_DIRECTED_MUTUAL));

    IGRAPH_CHECK(igraph_i_st_vertex_connectivity_directed(&newgraph, res,
                 source, target,
                 IGRAPH_VCONN_NEI_IGNORE));

    igraph_destroy(&newgraph);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_st_vertex_connectivity
 * \brief The vertex connectivity of a pair of vertices
 *
 * The vertex connectivity of two vertices (\c source and
 * \c target) is the minimum number of vertices that have to be
 * deleted to eliminate all paths from \c source to \c
 * target. Directed paths are considered in directed graphs.
 *
 * The vertex connectivity of a pair is the same as the number
 * of different (i.e. node-independent) paths from source to
 * target.
 *
 * The current implementation uses maximum flow calculations to
 * obtain the result.
 * \param graph The input graph.
 * \param res Pointer to an integer, the result will be stored here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \param neighbors A constant giving what to do if the two vertices
 *     are connected. Possible values:
 *     \c IGRAPH_VCONN_NEI_ERROR, stop with an error message,
 *     \c IGRAPH_VCONN_NEGATIVE, return -1.
 *     \c IGRAPH_VCONN_NUMBER_OF_NODES, return the number of nodes.
 *     \c IGRAPH_VCONN_IGNORE, ignore the fact that the two vertices
 *        are connected and calculate the number of vertices needed
 *        to eliminate all paths except for the trivial (direct) paths
 *        between \p source and \p vertex. TODO: what about neighbors?
 * \return Error code.
 *
 * Time complexity: O(|V|^3), but see the discussion at \ref
 * igraph_maxflow_value().
 *
 * \sa \ref igraph_vertex_connectivity(),
 * \ref igraph_edge_connectivity(),
 * \ref igraph_maxflow_value().
 */

int igraph_st_vertex_connectivity(const igraph_t *graph,
                                  igraph_integer_t *res,
                                  igraph_integer_t source,
                                  igraph_integer_t target,
                                  igraph_vconn_nei_t neighbors) {

    if (source == target) {
        IGRAPH_ERROR("source and target vertices are the same", IGRAPH_EINVAL);
    }

    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_st_vertex_connectivity_directed(graph, res,
                     source, target,
                     neighbors));
    } else {
        IGRAPH_CHECK(igraph_i_st_vertex_connectivity_undirected(graph, res,
                     source, target,
                     neighbors));
    }

    return 0;
}

static int igraph_i_vertex_connectivity_directed(const igraph_t *graph,
                                                 igraph_integer_t *res) {

    igraph_integer_t no_of_nodes = (igraph_integer_t) igraph_vcount(graph);
    long int i, j;
    igraph_integer_t minconn = no_of_nodes - 1, conn = 0;

    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j < no_of_nodes; j++) {
            if (i == j) {
                continue;
            }

            IGRAPH_ALLOW_INTERRUPTION();

            IGRAPH_CHECK(igraph_st_vertex_connectivity(graph, &conn,
                         (igraph_integer_t) i,
                         (igraph_integer_t) j,
                         IGRAPH_VCONN_NEI_NUMBER_OF_NODES));
            if (conn < minconn) {
                minconn = conn;
                if (conn == 0) {
                    break;
                }
            }
        }
        if (conn == 0) {
            break;
        }
    }

    if (res) {
        *res = minconn;
    }

    return 0;
}

static int igraph_i_vertex_connectivity_undirected(const igraph_t *graph,
                                                   igraph_integer_t *res) {
    igraph_t newgraph;

    IGRAPH_CHECK(igraph_copy(&newgraph, graph));
    IGRAPH_FINALLY(igraph_destroy, &newgraph);
    IGRAPH_CHECK(igraph_to_directed(&newgraph, IGRAPH_TO_DIRECTED_MUTUAL));

    IGRAPH_CHECK(igraph_i_vertex_connectivity_directed(&newgraph, res));

    igraph_destroy(&newgraph);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/* Use that vertex.connectivity(G) <= edge.connectivity(G) <= min(degree(G)) */
static int igraph_i_connectivity_checks(const igraph_t *graph,
                                        igraph_integer_t *res,
                                        igraph_bool_t *found) {
    igraph_bool_t conn;
    *found = 0;

    if (igraph_vcount(graph) == 0) {
        *res = 0;
        *found = 1;
        return 0;
    }

    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_STRONG));
    if (!conn) {
        *res = 0;
        *found = 1;
    } else {
        igraph_vector_t degree;
        IGRAPH_VECTOR_INIT_FINALLY(°ree, 0);
        if (!igraph_is_directed(graph)) {
            IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                                       IGRAPH_OUT, IGRAPH_LOOPS));
            if (igraph_vector_min(°ree) == 1) {
                *res = 1;
                *found = 1;
            }
        } else {
            /* directed, check both in- & out-degree */
            IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                                       IGRAPH_OUT, IGRAPH_LOOPS));
            if (igraph_vector_min(°ree) == 1) {
                *res = 1;
                *found = 1;
            } else {
                IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                                           IGRAPH_IN, IGRAPH_LOOPS));
                if (igraph_vector_min(°ree) == 1) {
                    *res = 1;
                    *found = 1;
                }
            }
        }
        igraph_vector_destroy(°ree);
        IGRAPH_FINALLY_CLEAN(1);
    }
    return 0;
}

/**
 * \function igraph_vertex_connectivity
 * The vertex connectivity of a graph
 *
 *  The vertex connectivity of a graph is the minimum
 * vertex connectivity along each pairs of vertices in the graph.
 * 
 *  The vertex connectivity of a graph is the same as group
 * cohesion as defined in Douglas R. White and Frank Harary: The
 * cohesiveness of blocks in social networks: node connectivity and
 * conditional density, Sociological Methodology 31:305--359, 2001.
 * \param graph The input graph.
 * \param res Pointer to an integer, the result will be stored here.
 * \param checks Logical constant. Whether to check that the graph is
 *    connected and also the degree of the vertices. If the graph is
 *    not (strongly) connected then the connectivity is obviously zero. Otherwise
 *    if the minimum degree is one then the vertex connectivity is also
 *    one. It is a good idea to perform these checks, as they can be
 *    done quickly compared to the connectivity calculation itself.
 *    They were suggested by Peter McMahan, thanks Peter.
 * \return Error code.
 *
 * Time complexity: O(|V|^5).
 *
 * \sa \ref igraph_st_vertex_connectivity(), \ref igraph_maxflow_value(),
 * and \ref igraph_edge_connectivity().
 */

int igraph_vertex_connectivity(const igraph_t *graph, igraph_integer_t *res,
                               igraph_bool_t checks) {

    igraph_bool_t ret = 0;

    if (checks) {
        IGRAPH_CHECK(igraph_i_connectivity_checks(graph, res, &ret));
    }

    /* Are we done yet? */
    if (!ret) {
        if (igraph_is_directed(graph)) {
            IGRAPH_CHECK(igraph_i_vertex_connectivity_directed(graph, res));
        } else {
            IGRAPH_CHECK(igraph_i_vertex_connectivity_undirected(graph, res));
        }
    }

    return 0;
}

/**
 * \function igraph_st_edge_connectivity
 * \brief Edge connectivity of a pair of vertices
 *
 *  The edge connectivity of two vertices (\c source and
 * \c target) in a graph is the minimum number of edges that
 * have to be deleted from the graph to eliminate all paths from \c
 * source to \c target.
 *
 * This function uses the maximum flow algorithm to calculate
 * the edge connectivity.
 * \param graph The input graph, it has to be directed.
 * \param res Pointer to an integer, the result will be stored here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \return Error code.
 *
 * Time complexity: O(|V|^3).
 *
 * \sa \ref igraph_maxflow_value(), \ref igraph_edge_connectivity(),
 * \ref igraph_st_vertex_connectivity(), \ref
 * igraph_vertex_connectivity().
 */

int igraph_st_edge_connectivity(const igraph_t *graph, igraph_integer_t *res,
                                igraph_integer_t source,
                                igraph_integer_t target) {
    igraph_real_t flow;

    if (source == target) {
        IGRAPH_ERROR("source and target vertices are the same", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_maxflow_value(graph, &flow, source, target, 0, 0));
    *res = (igraph_integer_t) flow;

    return 0;
}


/**
 * \function igraph_edge_connectivity
 * \brief The minimum edge connectivity in a graph.
 *
 *  This is the minimum of the edge connectivity over all
 * pairs of vertices in the graph. 
 *
 * 
 * The edge connectivity of a graph is the same as group adhesion as
 * defined in Douglas R. White and Frank Harary: The cohesiveness of
 * blocks in social networks: node connectivity and conditional
 * density, Sociological Methodology 31:305--359, 2001.
 * \param graph The input graph.
 * \param res Pointer to an integer, the result will be stored here.
 * \param checks Logical constant. Whether to check that the graph is
 *    connected and also the degree of the vertices. If the graph is
 *    not (strongly) connected then the connectivity is obviously zero. Otherwise
 *    if the minimum degree is one then the edge connectivity is also
 *    one. It is a good idea to perform these checks, as they can be
 *    done quickly compared to the connectivity calculation itself.
 *    They were suggested by Peter McMahan, thanks Peter.
 * \return Error code.
 *
 * Time complexity: O(log(|V|)*|V|^2) for undirected graphs and
 * O(|V|^4) for directed graphs, but see also the discussion at the
 * documentation of \ref igraph_maxflow_value().
 *
 * \sa \ref igraph_st_edge_connectivity(), \ref igraph_maxflow_value(),
 * \ref igraph_vertex_connectivity().
 */

int igraph_edge_connectivity(const igraph_t *graph, igraph_integer_t *res,
                             igraph_bool_t checks) {
    igraph_bool_t ret = 0;
    igraph_integer_t number_of_nodes = igraph_vcount(graph);

    /* igraph_mincut_value returns infinity for the singleton graph,
     * which cannot be cast to an integer. We catch this case early
     * and postulate the edge-connectivity of this graph to be 0.
     * This is consistent with what other software packages return. */
    if (number_of_nodes <= 1) {
        *res = 0;
        return 0;
    }

    /* Use that vertex.connectivity(G) <= edge.connectivity(G) <= min(degree(G)) */
    if (checks) {
        IGRAPH_CHECK(igraph_i_connectivity_checks(graph, res, &ret));
    }

    if (!ret) {
        igraph_real_t real_res;
        IGRAPH_CHECK(igraph_mincut_value(graph, &real_res, 0));
        *res = (igraph_integer_t)real_res;
    }

    return 0;
}

/**
 * \function igraph_edge_disjoint_paths
 * \brief The maximum number of edge-disjoint paths between two vertices.
 *
 *  A set of paths between two vertices is called
 * edge-disjoint if they do not share any edges. The maximum number of
 * edge-disjoint paths are calculated by this function using maximum
 * flow techniques. Directed paths are considered in directed
 * graphs. 
 *
 *  Note that the number of disjoint paths is the same as the
 * edge connectivity of the two vertices using uniform edge weights.
 * \param graph The input graph, can be directed or undirected.
 * \param res Pointer to an integer variable, the result will be
 *        stored here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \return Error code.
 *
 * Time complexity: O(|V|^3), but see the discussion at \ref
 * igraph_maxflow_value().
 *
 * \sa \ref igraph_vertex_disjoint_paths(), \ref
 * igraph_st_edge_connectivity(), \ref igraph_maxflow_value().
 */

int igraph_edge_disjoint_paths(const igraph_t *graph, igraph_integer_t *res,
                               igraph_integer_t source,
                               igraph_integer_t target) {

    igraph_real_t flow;

    if (source == target) {
        IGRAPH_ERROR("Not implemented for source=target", IGRAPH_UNIMPLEMENTED);
    }

    IGRAPH_CHECK(igraph_maxflow_value(graph, &flow, source, target, 0, 0));

    *res = (igraph_integer_t) flow;

    return 0;
}

/**
 * \function igraph_vertex_disjoint_paths
 * \brief Maximum number of vertex-disjoint paths between two vertices.
 *
 *  A set of paths between two vertices is called
 * vertex-disjoint if they share no vertices. The calculation is
 * performed by using maximum flow techniques. 
 *
 *  Note that the number of vertex-disjoint paths is the same as
 * the vertex connectivity of the two vertices in most cases (if the
 * two vertices are not connected by an edge).
 * \param graph The input graph.
 * \param res Pointer to an integer variable, the result will be
 *        stored here.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \return Error code.
 *
 * Time complexity: O(|V|^3).
 *
 * \sa \ref igraph_edge_disjoint_paths(), \ref
 * igraph_vertex_connectivity(), \ref igraph_maxflow_value().
 */

int igraph_vertex_disjoint_paths(const igraph_t *graph, igraph_integer_t *res,
                                 igraph_integer_t source,
                                 igraph_integer_t target) {

    igraph_bool_t conn;

    if (source == target) {
        IGRAPH_ERROR("The source==target case is not implemented",
                     IGRAPH_UNIMPLEMENTED);
    }

    IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn));
    if (conn) {
        /* We need to remove every (possibly directed) edge between source
           and target and calculate the disjoint paths on the new
           graph. Finally we add 1 for the removed connection(s).  */
        igraph_es_t es;
        igraph_vector_t v;
        igraph_t newgraph;
        IGRAPH_VECTOR_INIT_FINALLY(&v, 2);
        VECTOR(v)[0] = source;
        VECTOR(v)[1] = target;
        IGRAPH_CHECK(igraph_es_multipairs(&es, &v, IGRAPH_DIRECTED));
        IGRAPH_FINALLY(igraph_es_destroy, &es);

        IGRAPH_CHECK(igraph_copy(&newgraph, graph));
        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        IGRAPH_CHECK(igraph_delete_edges(&newgraph, es));

        if (igraph_is_directed(graph)) {
            IGRAPH_CHECK(igraph_i_st_vertex_connectivity_directed(&newgraph, res,
                         source, target,
                         IGRAPH_VCONN_NEI_IGNORE));
        } else {
            IGRAPH_CHECK(igraph_i_st_vertex_connectivity_undirected(&newgraph, res,
                         source, target,
                         IGRAPH_VCONN_NEI_IGNORE));
        }

        if (res) {
            *res += 1;
        }

        IGRAPH_FINALLY_CLEAN(3);
        igraph_destroy(&newgraph);
        igraph_es_destroy(&es);
        igraph_vector_destroy(&v);
    }

    /* These do nothing if the two vertices are connected,
       so it is safe to call them. */

    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_st_vertex_connectivity_directed(graph, res,
                     source, target,
                     IGRAPH_VCONN_NEI_IGNORE));
    } else {
        IGRAPH_CHECK(igraph_i_st_vertex_connectivity_undirected(graph, res,
                     source, target,
                     IGRAPH_VCONN_NEI_IGNORE));
    }

    return 0;
}

/**
 * \function igraph_adhesion
 * \brief Graph adhesion, this is (almost) the same as edge connectivity.
 *
 *  This quantity is defined by White and Harary in
 * The cohesiveness of blocks in social networks: node connectivity and
 * conditional density, (Sociological Methodology 31:305--359, 2001)
 * and basically it is the edge connectivity of the graph
 * with uniform edge weights.
 * \param graph The input graph, either directed or undirected.
 * \param res Pointer to an integer, the result will be stored here.
 * \param checks Logical constant. Whether to check that the graph is
 *    connected and also the degree of the vertices. If the graph is
 *    not (strongly) connected then the adhesion is obviously zero. Otherwise
 *    if the minimum degree is one then the adhesion is also
 *    one. It is a good idea to perform these checks, as they can be
 *    done quickly compared to the edge connectivity calculation itself.
 *    They were suggested by Peter McMahan, thanks Peter.
* \return Error code.
 *
 * Time complexity: O(log(|V|)*|V|^2) for undirected graphs and
 * O(|V|^4) for directed graphs, but see also the discussion at the
 * documentation of \ref igraph_maxflow_value().
 *
 * \sa \ref igraph_cohesion(), \ref igraph_maxflow_value(), \ref
 * igraph_edge_connectivity(), \ref igraph_mincut_value().
 */

int igraph_adhesion(const igraph_t *graph, igraph_integer_t *res,
                    igraph_bool_t checks) {
    return igraph_edge_connectivity(graph, res, checks);
}

/**
 * \function igraph_cohesion
 * \brief Graph cohesion, this is the same as vertex connectivity.
 *
 *  This quantity was defined by White and Harary in The
 * cohesiveness of blocks in social networks: node connectivity and
 * conditional density, (Sociological Methodology 31:305--359, 2001)
 * and it is the same as the vertex connectivity of a
 * graph.
 * \param graph The input graph.
 * \param res Pointer to an integer variable, the result will be
 *        stored here.
 * \param checks Logical constant. Whether to check that the graph is
 *    connected and also the degree of the vertices. If the graph is
 *    not (strongly) connected then the cohesion is obviously zero. Otherwise
 *    if the minimum degree is one then the cohesion is also
 *    one. It is a good idea to perform these checks, as they can be
 *    done quickly compared to the vertex connectivity calculation itself.
 *    They were suggested by Peter McMahan, thanks Peter.
 * \return Error code.
 *
 * Time complexity: O(|V|^4), |V| is the number of vertices. In
 * practice it is more like O(|V|^2), see \ref igraph_maxflow_value().
 *
 * \sa \ref igraph_vertex_connectivity(), \ref igraph_adhesion(),
 * \ref igraph_maxflow_value().
 */

int igraph_cohesion(const igraph_t *graph, igraph_integer_t *res,
                    igraph_bool_t checks) {

    IGRAPH_CHECK(igraph_vertex_connectivity(graph, res, checks));
    return 0;
}

/**
 * \function igraph_gomory_hu_tree
 * \brief Gomory-Hu tree of a graph.
 *
 * 
 * The Gomory-Hu tree is a concise representation of the value of all the
 * maximum flows (or minimum cuts) in a graph. The vertices of the tree
 * correspond exactly to the vertices of the original graph in the same order.
 * Edges of the Gomory-Hu tree are annotated by flow values.  The value of
 * the maximum flow (or minimum cut) between an arbitrary (u,v) vertex
 * pair in the original graph is then given by the minimum flow value (i.e.
 * edge annotation) along the shortest path between u and v in the
 * Gomory-Hu tree.
 *
 * This implementation uses Gusfield's algorithm to construct the
 * Gomory-Hu tree. See the following paper for more details:
 *
 * 
 * Gusfield D: Very simple methods for all pairs network flow analysis. SIAM J
 * Comput 19(1):143-155, 1990.
 *
 * \param graph The input graph.
 * \param tree  Pointer to an uninitialized graph; the result will be
 *              stored here.
 * \param flows Pointer to an uninitialized vector; the flow values
 *              corresponding to each edge in the Gomory-Hu tree will
 *              be returned here. You may pass a NULL pointer here if you are
 *              not interested in the flow values.
 * \param capacity Vector containing the capacity of the edges. If NULL, then
 *        every edge is considered to have capacity 1.0.
 * \return Error code.
 *
 * Time complexity: O(|V|^4) since it performs a max-flow calculation
 * between vertex zero and every other vertex and max-flow is
 * O(|V|^3).
 *
 * \sa \ref igraph_maxflow()
 */
int igraph_gomory_hu_tree(const igraph_t *graph, igraph_t *tree,
                          igraph_vector_t *flows, const igraph_vector_t *capacity) {

    igraph_integer_t no_of_nodes = igraph_vcount(graph);
    igraph_integer_t source, target, mid, i, n;
    igraph_vector_t neighbors;
    igraph_vector_t flow_values;
    igraph_vector_t partition;
    igraph_vector_t partition2;
    igraph_real_t flow_value;

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Gomory-Hu tree can only be calculated for undirected graphs",
                     IGRAPH_EINVAL);
    }

    /* Allocate memory */
    IGRAPH_VECTOR_INIT_FINALLY(&neighbors, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&flow_values, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&partition, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&partition2, 0);

    /* Initialize the tree: every edge points to node 0 */
    /* Actually, this is done implicitly since both 'neighbors' and 'flow_values' are
     * initialized to zero already */

    /* For each source vertex except vertex zero... */
    for (source = 1; source < no_of_nodes; source++) {
        IGRAPH_ALLOW_INTERRUPTION();
        IGRAPH_PROGRESS("Gomory-Hu tree", (100.0 * (source - 1)) / (no_of_nodes - 1), 0);

        /* Find its current neighbor in the tree */
        target = VECTOR(neighbors)[(long int)source];

        /* Find the maximum flow between source and target */
        IGRAPH_CHECK(igraph_maxflow(graph, &flow_value, 0, 0, &partition, &partition2,
                                    source, target, capacity, 0));

        /* Store the maximum flow */
        VECTOR(flow_values)[(long int)source] = flow_value;

        /* Update the tree */
        /* igraph_maxflow() guarantees that the source vertex will be in &partition
         * and not in &partition2 so we need to iterate over &partition to find
         * all the nodes that are of interest to us */
        n = igraph_vector_size(&partition);
        for (i = 0; i < n; i++) {
            mid = VECTOR(partition)[i];
            if (mid != source) {
                if (VECTOR(neighbors)[(long int)mid] == target) {
                    VECTOR(neighbors)[(long int)mid] = source;
                } else if (VECTOR(neighbors)[(long int)target] == mid) {
                    VECTOR(neighbors)[(long int)target] = source;
                    VECTOR(neighbors)[(long int)source] = mid;
                    VECTOR(flow_values)[(long int)source] = VECTOR(flow_values)[(long int)target];
                    VECTOR(flow_values)[(long int)target] = flow_value;
                }
            }
        }
    }

    IGRAPH_PROGRESS("Gomory-Hu tree", 100.0, 0);

    /* Re-use the 'partition' vector as an edge list now */
    IGRAPH_CHECK(igraph_vector_resize(&partition, 2 * (no_of_nodes - 1)));
    for (i = 1, mid = 0; i < no_of_nodes; i++, mid += 2) {
        VECTOR(partition)[(long int)mid]   = i;
        VECTOR(partition)[(long int)mid + 1] = VECTOR(neighbors)[(long int)i];
    }

    /* Create the tree graph; we use igraph_subgraph_edges here to keep the
     * graph and vertex attributes */
    IGRAPH_CHECK(igraph_subgraph_edges(graph, tree, igraph_ess_none(), 0));
    IGRAPH_CHECK(igraph_add_edges(tree, &partition, 0));

    /* Free the allocated memory */
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&partition);
    igraph_vector_destroy(&neighbors);
    IGRAPH_FINALLY_CLEAN(3);

    /* Return the flow values to the caller */
    if (flows != 0) {
        IGRAPH_CHECK(igraph_vector_update(flows, &flow_values));
        if (no_of_nodes > 0) {
            igraph_vector_remove(flows, 0);
        }
    }

    /* Free the remaining allocated memory */
    igraph_vector_destroy(&flow_values);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/flow/flow_internal.h0000644000175100001710000000277100000000000024433 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_FLOW_INTERNAL_H
#define IGRAPH_FLOW_INTERNAL_H

#include "igraph_types.h"

__BEGIN_DECLS

IGRAPH_PRIVATE_EXPORT int igraph_i_all_st_cuts_pivot(const igraph_t *graph,
                                                     const igraph_marked_queue_t *S,
                                                     const igraph_estack_t *T,
                                                     long int source,
                                                     long int target,
                                                     long int *v,
                                                     igraph_vector_t *Isv,
                                                     void *arg);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/flow/st-cuts.c0000644000175100001710000016542600000000000023174 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_flow.h"

#include "igraph_adjlist.h"
#include "igraph_constants.h"
#include "igraph_constructors.h"
#include "igraph_components.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_stack.h"
#include "igraph_visitor.h"

#include "core/math.h"
#include "core/estack.h"
#include "core/marked_queue.h"
#include "graph/attributes.h"
#include "flow/flow_internal.h"

typedef int igraph_provan_shier_pivot_t(const igraph_t *graph,
                                        const igraph_marked_queue_t *S,
                                        const igraph_estack_t *T,
                                        long int source,
                                        long int target,
                                        long int *v,
                                        igraph_vector_t *Isv,
                                        void *arg);

/**
 * \function igraph_even_tarjan_reduction
 * Even-Tarjan reduction of a graph
 *
 * A digraph is created with twice as many vertices and edges. For each
 * original vertex i, two vertices i'= i and i'' = i' + n are created,
 * with a directed edge from i' to i''. For each original directed edge
 * from i to j, two new edges are created, from i' to j'' and from i''
 * to j'.
 *
 * This reduction is used in the paper (observation 2):
 * Arkady Kanevsky: Finding all minimum-size separating vertex sets in
 * a graph, Networks 23, 533--541, 1993.
 *
 * The original paper where this reduction was conceived is
 * Shimon Even and R. Endre Tarjan: Network Flow and Testing Graph
 * Connectivity, SIAM J. Comput., 4(4), 507–518.
 *
 * \param graph A graph. Although directness is not checked, this function
 *        is commonly used only on directed graphs.
 * \param graphbar Pointer to a new directed graph that will contain the
 *        reduction, with twice as many vertices and edges.
 * \param capacity Pointer to an initialized vector or a null pointer. If
 *        not a null pointer, then it will be filled the capacity from
 *        the reduction: the first |E| elements are 1, the remaining |E|
 *        are equal to |V| (which is used to mean infinity).
 * \return Error code.
 *
 * Time complexity: O(|E|+|V|).
 *
 * \example examples/simple/even_tarjan.c
 */

int igraph_even_tarjan_reduction(const igraph_t *graph, igraph_t *graphbar,
                                 igraph_vector_t *capacity) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);

    long int new_no_of_nodes = no_of_nodes * 2;
    long int new_no_of_edges = no_of_nodes + no_of_edges * 2;

    igraph_vector_t edges;
    long int edgeptr = 0, capptr = 0;
    long int i;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, new_no_of_edges * 2);

    if (capacity) {
        IGRAPH_CHECK(igraph_vector_resize(capacity, new_no_of_edges));
    }

    /* Every vertex 'i' is replaced by two vertices, i' and i'' */
    /* id[i'] := id[i] ; id[i''] := id[i] + no_of_nodes */

    /* One edge for each original vertex, for i, we add (i',i'') */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(edges)[edgeptr++] = i;
        VECTOR(edges)[edgeptr++] = i + no_of_nodes;
        if (capacity) {
            VECTOR(*capacity)[capptr++] = 1.0;
        }
    }

    /* Two news edges for each original edge
       (from,to) becomes (from'',to'), (to'',from') */
    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);
        VECTOR(edges)[edgeptr++] = from + no_of_nodes;
        VECTOR(edges)[edgeptr++] = to;
        VECTOR(edges)[edgeptr++] = to + no_of_nodes;
        VECTOR(edges)[edgeptr++] = from;
        if (capacity) {
            VECTOR(*capacity)[capptr++] = no_of_nodes; /* TODO: should be Inf */
            VECTOR(*capacity)[capptr++] = no_of_nodes; /* TODO: should be Inf */
        }
    }

    IGRAPH_CHECK(igraph_create(graphbar, &edges, (igraph_integer_t)
                               new_no_of_nodes, IGRAPH_DIRECTED));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_residual_graph(const igraph_t *graph,
                                   const igraph_vector_t *capacity,
                                   igraph_t *residual,
                                   igraph_vector_t *residual_capacity,
                                   const igraph_vector_t *flow,
                                   igraph_vector_t *tmp) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int i, no_new_edges = 0;
    long int edgeptr = 0, capptr = 0;

    for (i = 0; i < no_of_edges; i++) {
        if (VECTOR(*flow)[i] < VECTOR(*capacity)[i]) {
            no_new_edges++;
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(tmp, no_new_edges * 2));
    if (residual_capacity) {
        IGRAPH_CHECK(igraph_vector_resize(residual_capacity, no_new_edges));
    }

    for (i = 0; i < no_of_edges; i++) {
        igraph_real_t c = VECTOR(*capacity)[i] - VECTOR(*flow)[i];
        if (c > 0) {
            long int from = IGRAPH_FROM(graph, i);
            long int to = IGRAPH_TO(graph, i);
            VECTOR(*tmp)[edgeptr++] = from;
            VECTOR(*tmp)[edgeptr++] = to;
            if (residual_capacity) {
                VECTOR(*residual_capacity)[capptr++] = c;
            }
        }
    }

    IGRAPH_CHECK(igraph_create(residual, tmp, (igraph_integer_t) no_of_nodes,
                               IGRAPH_DIRECTED));

    return 0;
}

int igraph_residual_graph(const igraph_t *graph,
                          const igraph_vector_t *capacity,
                          igraph_t *residual,
                          igraph_vector_t *residual_capacity,
                          const igraph_vector_t *flow) {

    igraph_vector_t tmp;
    long int no_of_edges = igraph_ecount(graph);

    if (igraph_vector_size(capacity) != no_of_edges) {
        IGRAPH_ERROR("Invalid `capacity' vector size", IGRAPH_EINVAL);
    }
    if (igraph_vector_size(flow) != no_of_edges) {
        IGRAPH_ERROR("Invalid `flow' vector size", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);

    IGRAPH_CHECK(igraph_i_residual_graph(graph, capacity, residual,
                                         residual_capacity, flow, &tmp));

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_reverse_residual_graph(const igraph_t *graph,
                                           const igraph_vector_t *capacity,
                                           igraph_t *residual,
                                           const igraph_vector_t *flow,
                                           igraph_vector_t *tmp) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int i, no_new_edges = 0;
    long int edgeptr = 0;

    for (i = 0; i < no_of_edges; i++) {
        igraph_real_t cap = capacity ? VECTOR(*capacity)[i] : 1.0;
        if (VECTOR(*flow)[i] > 0) {
            no_new_edges++;
        }
        if (VECTOR(*flow)[i] < cap) {
            no_new_edges++;
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(tmp, no_new_edges * 2));

    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);
        igraph_real_t cap = capacity ? VECTOR(*capacity)[i] : 1.0;
        if (VECTOR(*flow)[i] > 0) {
            VECTOR(*tmp)[edgeptr++] = from;
            VECTOR(*tmp)[edgeptr++] = to;
        }
        if (VECTOR(*flow)[i] < cap) {
            VECTOR(*tmp)[edgeptr++] = to;
            VECTOR(*tmp)[edgeptr++] = from;
        }
    }

    IGRAPH_CHECK(igraph_create(residual, tmp, (igraph_integer_t) no_of_nodes,
                               IGRAPH_DIRECTED));

    return 0;
}

int igraph_reverse_residual_graph(const igraph_t *graph,
                                  const igraph_vector_t *capacity,
                                  igraph_t *residual,
                                  const igraph_vector_t *flow) {
    igraph_vector_t tmp;
    long int no_of_edges = igraph_ecount(graph);

    if (capacity && igraph_vector_size(capacity) != no_of_edges) {
        IGRAPH_ERROR("Invalid `capacity' vector size", IGRAPH_EINVAL);
    }
    if (igraph_vector_size(flow) != no_of_edges) {
        IGRAPH_ERROR("Invalid `flow' vector size", IGRAPH_EINVAL);
    }
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);

    IGRAPH_CHECK(igraph_i_reverse_residual_graph(graph, capacity, residual,
                 flow, &tmp));

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

typedef struct igraph_i_dbucket_t {
    igraph_vector_long_t head;
    igraph_vector_long_t next;
} igraph_i_dbucket_t;

static int igraph_i_dbucket_init(igraph_i_dbucket_t *buck, long int size) {
    IGRAPH_CHECK(igraph_vector_long_init(&buck->head, size));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &buck->head);
    IGRAPH_CHECK(igraph_vector_long_init(&buck->next, size));
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

static void igraph_i_dbucket_destroy(igraph_i_dbucket_t *buck) {
    igraph_vector_long_destroy(&buck->head);
    igraph_vector_long_destroy(&buck->next);
}

static int igraph_i_dbucket_insert(igraph_i_dbucket_t *buck, long int bid,
                                   long int elem) {
    /* Note: we can do this, since elem is not in any buckets */
    VECTOR(buck->next)[elem] = VECTOR(buck->head)[bid];
    VECTOR(buck->head)[bid] = elem + 1;
    return 0;
}

static long int igraph_i_dbucket_empty(const igraph_i_dbucket_t *buck,
                                       long int bid) {
    return VECTOR(buck->head)[bid] == 0;
}

static long int igraph_i_dbucket_delete(igraph_i_dbucket_t *buck, long int bid) {
    long int elem = VECTOR(buck->head)[bid] - 1;
    VECTOR(buck->head)[bid] = VECTOR(buck->next)[elem];
    return elem;
}

static int igraph_i_dominator_LINK(long int v, long int w,
                                   igraph_vector_long_t *ancestor) {
    VECTOR(*ancestor)[w] = v + 1;
    return 0;
}

/* TODO: don't always reallocate path */

static int igraph_i_dominator_COMPRESS(long int v,
                                       igraph_vector_long_t *ancestor,
                                       igraph_vector_long_t *label,
                                       igraph_vector_long_t *semi) {
    igraph_stack_long_t path;
    long int w = v;
    long int top, pretop;

    IGRAPH_CHECK(igraph_stack_long_init(&path, 10));
    IGRAPH_FINALLY(igraph_stack_long_destroy, &path);

    while (VECTOR(*ancestor)[w] != 0) {
        IGRAPH_CHECK(igraph_stack_long_push(&path, w));
        w = VECTOR(*ancestor)[w] - 1;
    }

    top = igraph_stack_long_pop(&path);
    while (!igraph_stack_long_empty(&path)) {
        pretop = igraph_stack_long_pop(&path);

        if (VECTOR(*semi)[VECTOR(*label)[top]] <
            VECTOR(*semi)[VECTOR(*label)[pretop]]) {
            VECTOR(*label)[pretop] = VECTOR(*label)[top];
        }
        VECTOR(*ancestor)[pretop] = VECTOR(*ancestor)[top];

        top = pretop;
    }

    igraph_stack_long_destroy(&path);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static long int igraph_i_dominator_EVAL(long int v,
                                        igraph_vector_long_t *ancestor,
                                        igraph_vector_long_t *label,
                                        igraph_vector_long_t *semi) {
    if (VECTOR(*ancestor)[v] == 0) {
        return v;
    } else {
        igraph_i_dominator_COMPRESS(v, ancestor, label, semi);
        return VECTOR(*label)[v];
    }
}

/* TODO: implement the faster version. */

/**
 * \function igraph_dominator_tree
 * Calculates the dominator tree of a flowgraph
 *
 * A flowgraph is a directed graph with a distinguished start (or
 * root) vertex r, such that for any vertex v, there is a path from r
 * to v. A vertex v dominates another vertex w (not equal to v), if
 * every path from r to w contains v. Vertex v is the immediate
 * dominator or w, v=idom(w), if v dominates w and every other
 * dominator of w dominates v. The edges {(idom(w), w)| w is not r}
 * form a directed tree, rooted at r, called the dominator tree of the
 * graph. Vertex v dominates vertex w if and only if v is an ancestor
 * of w in the dominator tree.
 *
 * This function implements the Lengauer-Tarjan algorithm
 * to construct the dominator tree of a directed graph. For details
 * please see Thomas Lengauer, Robert Endre Tarjan: A fast algorithm
 * for finding dominators in a flowgraph, ACM Transactions on
 * Programming Languages and Systems (TOPLAS) I/1, 121--141, 1979.
 *
 * \param graph A directed graph. If it is not a flowgraph, and it
 *        contains some vertices not reachable from the root vertex,
 *        then these vertices will be collected in the \c leftout
 *        vector.
 * \param root The id of the root (or source) vertex, this will be the
 *        root of the tree.
 * \param dom Pointer to an initialized vector or a null pointer. If
 *        not a null pointer, then the immediate dominator of each
 *        vertex will be stored here. For vertices that are not
 *        reachable from the root, NaN is stored here. For
 *        the root vertex itself, -1 is added.
 * \param domtree Pointer to an uninitialized igraph_t, or NULL. If
 *        not a null pointer, then the dominator tree is returned
 *        here. The graph contains the vertices that are unreachable
 *        from the root (if any), these will be isolates.
 * \param leftout Pointer to an initialized vector object, or NULL. If
 *        not NULL, then the ids of the vertices that are unreachable
 *        from the root vertex (and thus not part of the dominator
 *        tree) are stored here.
 * \param mode Constant, must be \c IGRAPH_IN or \c IGRAPH_OUT. If it
 *        is \c IGRAPH_IN, then all directions are considered as
 *        opposite to the original one in the input graph.
 * \return Error code.
 *
 * Time complexity: very close to O(|E|+|V|), linear in the number of
 * edges and vertices. More precisely, it is O(|V|+|E|alpha(|E|,|V|)),
 * where alpha(|E|,|V|) is a functional inverse of Ackermann's
 * function.
 *
 * \example examples/simple/dominator_tree.c
 */

int igraph_dominator_tree(const igraph_t *graph,
                          igraph_integer_t root,
                          igraph_vector_t *dom,
                          igraph_t *domtree,
                          igraph_vector_t *leftout,
                          igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);

    igraph_adjlist_t succ, pred;
    igraph_vector_t parent;
    igraph_vector_long_t semi;    /* +1 always */
    igraph_vector_t vertex;   /* +1 always */
    igraph_i_dbucket_t bucket;
    igraph_vector_long_t ancestor;
    igraph_vector_long_t label;

    igraph_neimode_t invmode = mode == IGRAPH_IN ? IGRAPH_OUT : IGRAPH_IN;

    long int i;

    igraph_vector_t vdom, *mydom = dom;

    long int component_size = 0;

    if (root < 0 || root >= no_of_nodes) {
        IGRAPH_ERROR("Invalid root vertex id for dominator tree",
                     IGRAPH_EINVAL);
    }

    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("Dominator tree of an undirected graph requested",
                     IGRAPH_EINVAL);
    }

    if (mode == IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid neighbor mode for dominator tree",
                     IGRAPH_EINVAL);
    }

    if (dom) {
        IGRAPH_CHECK(igraph_vector_resize(dom, no_of_nodes));
    } else {
        mydom = &vdom;
        IGRAPH_VECTOR_INIT_FINALLY(mydom, no_of_nodes);
    }
    igraph_vector_fill(mydom, IGRAPH_NAN);

    IGRAPH_CHECK(igraph_vector_init(&parent, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_destroy, &parent);
    IGRAPH_CHECK(igraph_vector_long_init(&semi, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &semi);
    IGRAPH_CHECK(igraph_vector_init(&vertex, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_destroy, &vertex);
    IGRAPH_CHECK(igraph_vector_long_init(&ancestor, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &ancestor);
    IGRAPH_CHECK(igraph_vector_long_init_seq(&label, 0, no_of_nodes - 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &label);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &succ, mode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &succ);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &pred, invmode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &pred);
    IGRAPH_CHECK(igraph_i_dbucket_init(&bucket, no_of_nodes));
    IGRAPH_FINALLY(igraph_i_dbucket_destroy, &bucket);

    /* DFS first, to set semi, vertex and parent, step 1 */

    IGRAPH_CHECK(igraph_dfs(graph, root, mode, /*unreachable=*/ 0,
                            /*order=*/ &vertex,
                            /*order_out=*/ 0, /*father=*/ &parent,
                            /*dist=*/ 0, /*in_callback=*/ 0,
                            /*out_callback=*/ 0, /*extra=*/ 0));

    for (i = 0; i < no_of_nodes; i++) {
        if (IGRAPH_FINITE(VECTOR(vertex)[i])) {
            long int t = (long int) VECTOR(vertex)[i];
            VECTOR(semi)[t] = component_size + 1;
            VECTOR(vertex)[component_size] = t + 1;
            component_size++;
        }
    }
    if (leftout) {
        long int n = no_of_nodes - component_size;
        long int p = 0, j;
        IGRAPH_CHECK(igraph_vector_resize(leftout, n));
        for (j = 0; j < no_of_nodes && p < n; j++) {
            if (!IGRAPH_FINITE(VECTOR(parent)[j])) {
                VECTOR(*leftout)[p++] = j;
            }
        }
    }

    /* We need to go over 'pred' because it should contain only the
       edges towards the target vertex. */
    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_int_t *v = igraph_adjlist_get(&pred, i);
        long int j, n = igraph_vector_int_size(v);
        for (j = 0; j < n; ) {
            long int v2 = (long int) VECTOR(*v)[j];
            if (IGRAPH_FINITE(VECTOR(parent)[v2])) {
                j++;
            } else {
                VECTOR(*v)[j] = VECTOR(*v)[n - 1];
                igraph_vector_int_pop_back(v);
                n--;
            }
        }
    }

    /* Now comes the main algorithm, steps 2 & 3 */

    for (i = component_size - 1; i > 0; i--) {
        long int w = (long int) VECTOR(vertex)[i] - 1;
        igraph_vector_int_t *predw = igraph_adjlist_get(&pred, w);
        long int j, n = igraph_vector_int_size(predw);
        for (j = 0; j < n; j++) {
            long int v = (long int) VECTOR(*predw)[j];
            long int u = igraph_i_dominator_EVAL(v, &ancestor, &label, &semi);
            if (VECTOR(semi)[u] < VECTOR(semi)[w]) {
                VECTOR(semi)[w] = VECTOR(semi)[u];
            }
        }
        igraph_i_dbucket_insert(&bucket, (long int)
                                VECTOR(vertex)[ VECTOR(semi)[w] - 1 ] - 1, w);
        igraph_i_dominator_LINK((long int) VECTOR(parent)[w], w, &ancestor);
        while (!igraph_i_dbucket_empty(&bucket, (long int) VECTOR(parent)[w])) {
            long int v = igraph_i_dbucket_delete(&bucket, (long int) VECTOR(parent)[w]);
            long int u = igraph_i_dominator_EVAL(v, &ancestor, &label, &semi);
            VECTOR(*mydom)[v] = VECTOR(semi)[u] < VECTOR(semi)[v] ? u :
                                VECTOR(parent)[w];
        }
    }

    /* Finally, step 4 */

    for (i = 1; i < component_size; i++) {
        long int w = (long int) VECTOR(vertex)[i] - 1;
        if (VECTOR(*mydom)[w] != VECTOR(vertex)[VECTOR(semi)[w] - 1] - 1) {
            VECTOR(*mydom)[w] = VECTOR(*mydom)[(long int)VECTOR(*mydom)[w]];
        }
    }
    VECTOR(*mydom)[(long int)root] = -1;

    igraph_i_dbucket_destroy(&bucket);
    igraph_adjlist_destroy(&pred);
    igraph_adjlist_destroy(&succ);
    igraph_vector_long_destroy(&label);
    igraph_vector_long_destroy(&ancestor);
    igraph_vector_destroy(&vertex);
    igraph_vector_long_destroy(&semi);
    igraph_vector_destroy(&parent);
    IGRAPH_FINALLY_CLEAN(8);

    if (domtree) {
        igraph_vector_t edges;
        long int ptr = 0;
        IGRAPH_VECTOR_INIT_FINALLY(&edges, component_size * 2 - 2);
        for (i = 0; i < no_of_nodes; i++) {
            if (i != root && IGRAPH_FINITE(VECTOR(*mydom)[i])) {
                if (mode == IGRAPH_OUT) {
                    VECTOR(edges)[ptr++] = VECTOR(*mydom)[i];
                    VECTOR(edges)[ptr++] = i;
                } else {
                    VECTOR(edges)[ptr++] = i;
                    VECTOR(edges)[ptr++] = VECTOR(*mydom)[i];
                }
            }
        }
        IGRAPH_CHECK(igraph_create(domtree, &edges, (igraph_integer_t) no_of_nodes,
                                   IGRAPH_DIRECTED));
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);

        IGRAPH_I_ATTRIBUTE_DESTROY(domtree);
        IGRAPH_I_ATTRIBUTE_COPY(domtree, graph, /*graph=*/ 1, /*vertex=*/ 1,
                                /*edge=*/ 0);
    }

    if (!dom) {
        igraph_vector_destroy(&vdom);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

typedef struct igraph_i_all_st_cuts_minimal_dfs_data_t {
    igraph_stack_t *stack;
    igraph_vector_bool_t *nomark;
    const igraph_vector_bool_t *GammaX;
    long int root;
    const igraph_vector_t *map;
} igraph_i_all_st_cuts_minimal_dfs_data_t;

static igraph_bool_t igraph_i_all_st_cuts_minimal_dfs_incb(
        const igraph_t *graph,
        igraph_integer_t vid,
        igraph_integer_t dist,
        void *extra) {

    igraph_i_all_st_cuts_minimal_dfs_data_t *data = extra;
    igraph_stack_t *stack = data->stack;
    igraph_vector_bool_t *nomark = data->nomark;
    const igraph_vector_bool_t *GammaX = data->GammaX;
    const igraph_vector_t *map = data->map;
    long int realvid = (long int) VECTOR(*map)[(long int)vid];

    IGRAPH_UNUSED(graph); IGRAPH_UNUSED(dist);

    if (VECTOR(*GammaX)[(long int)realvid]) {
        if (!igraph_stack_empty(stack)) {
            long int top = (long int) igraph_stack_top(stack);
            VECTOR(*nomark)[top] = 1; /* we just found a smaller one */
        }
        igraph_stack_push(stack, realvid); /* TODO: error check */
    }

    return 0;
}

static igraph_bool_t igraph_i_all_st_cuts_minimal_dfs_otcb(
        const igraph_t *graph,
        igraph_integer_t vid,
        igraph_integer_t dist,
        void *extra) {
    igraph_i_all_st_cuts_minimal_dfs_data_t *data = extra;
    igraph_stack_t *stack = data->stack;
    const igraph_vector_t *map = data->map;
    long int realvid = (long int) VECTOR(*map)[(long int)vid];

    IGRAPH_UNUSED(graph); IGRAPH_UNUSED(dist);

    if (!igraph_stack_empty(stack) &&
        igraph_stack_top(stack) == realvid) {
        igraph_stack_pop(stack);
    }

    return 0;
}

static int igraph_i_all_st_cuts_minimal(const igraph_t *graph,
                                        const igraph_t *domtree,
                                        long int root,
                                        const igraph_marked_queue_t *X,
                                        const igraph_vector_bool_t *GammaX,
                                        const igraph_vector_t *invmap,
                                        igraph_vector_t *minimal) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_stack_t stack;
    igraph_vector_bool_t nomark;
    igraph_i_all_st_cuts_minimal_dfs_data_t data;
    long int i;

    IGRAPH_UNUSED(X);

    IGRAPH_CHECK(igraph_stack_init(&stack, 10));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);
    IGRAPH_CHECK(igraph_vector_bool_init(&nomark, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &nomark);

    data.stack = &stack;
    data.nomark = &nomark;
    data.GammaX = GammaX;
    data.root = root;
    data.map = invmap;

    /* We mark all GammaX elements as minimal first.
       TODO: actually, we could just use GammaX to return the minimal
       elements. */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(nomark)[i] = VECTOR(*GammaX)[i] == 0 ? 1 : 0;
    }

    /* We do a reverse DFS from root. If, along a path we find a GammaX
       vertex after (=below) another GammaX vertex, we mark the higher
       one as non-minimal. */

    IGRAPH_CHECK(igraph_dfs(domtree, (igraph_integer_t) root, IGRAPH_IN,
                            /*unreachable=*/ 0, /*order=*/ 0,
                            /*order_out=*/ 0, /*father=*/ 0,
                            /*dist=*/ 0, /*in_callback=*/
                            igraph_i_all_st_cuts_minimal_dfs_incb,
                            /*out_callback=*/
                            igraph_i_all_st_cuts_minimal_dfs_otcb,
                            /*extra=*/ &data));

    igraph_vector_clear(minimal);
    for (i = 0; i < no_of_nodes; i++) {
        if (!VECTOR(nomark)[i]) {
            IGRAPH_CHECK(igraph_vector_push_back(minimal, i));
        }
    }

    igraph_vector_bool_destroy(&nomark);
    igraph_stack_destroy(&stack);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/* not 'static' because used in igraph_all_st_cuts.c test program */
int igraph_i_all_st_cuts_pivot(const igraph_t *graph,
                               const igraph_marked_queue_t *S,
                               const igraph_estack_t *T,
                               long int source,
                               long int target,
                               long int *v,
                               igraph_vector_t *Isv,
                               void *arg) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_t Sbar;
    igraph_vector_t Sbar_map, Sbar_invmap;
    igraph_vector_t keep;
    igraph_t domtree;
    igraph_vector_t leftout;
    long int i, nomin, n;
    long int root;
    igraph_vector_t M;
    igraph_vector_bool_t GammaS;
    igraph_vector_t Nuv;
    igraph_vector_t Isv_min;
    igraph_vector_t GammaS_vec;
    long int Sbar_size;

    IGRAPH_UNUSED(arg);

    /* We need to create the graph induced by Sbar */
    IGRAPH_VECTOR_INIT_FINALLY(&Sbar_map, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&Sbar_invmap, 0);

    IGRAPH_VECTOR_INIT_FINALLY(&keep, 0);
    for (i = 0; i < no_of_nodes; i++) {
        if (!igraph_marked_queue_iselement(S, i)) {
            IGRAPH_CHECK(igraph_vector_push_back(&keep, i));
        }
    }
    Sbar_size = igraph_vector_size(&keep);

    IGRAPH_CHECK(igraph_induced_subgraph_map(graph, &Sbar,
                 igraph_vss_vector(&keep),
                 IGRAPH_SUBGRAPH_AUTO,
                 /* map= */ &Sbar_map,
                 /* invmap= */ &Sbar_invmap));
    igraph_vector_destroy(&keep);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, &Sbar);

    root = (long int) VECTOR(Sbar_map)[target] - 1;

    /* -------------------------------------------------------------*/
    /* Construct the dominator tree of Sbar */

    IGRAPH_VECTOR_INIT_FINALLY(&leftout, 0);
    IGRAPH_CHECK(igraph_dominator_tree(&Sbar, (igraph_integer_t) root,
                                       /*dom=*/ 0, &domtree,
                                       &leftout, IGRAPH_IN));
    IGRAPH_FINALLY(igraph_destroy, &domtree);

    /* -------------------------------------------------------------*/
    /* Identify the set M of minimal elements of Gamma(S) with respect
       to the dominator relation. */

    /* First we create GammaS */
    /* TODO: use the adjacency list, instead of neighbors() */
    IGRAPH_CHECK(igraph_vector_bool_init(&GammaS, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &GammaS);
    if (igraph_marked_queue_size(S) == 0) {
        VECTOR(GammaS)[(long int) VECTOR(Sbar_map)[source] - 1] = 1;
    } else {
        for (i = 0; i < no_of_nodes; i++) {
            if (igraph_marked_queue_iselement(S, i)) {
                igraph_vector_t neis;
                long int j;
                IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
                IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
                                              IGRAPH_OUT));
                n = igraph_vector_size(&neis);
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (!igraph_marked_queue_iselement(S, nei)) {
                        VECTOR(GammaS)[nei] = 1;
                    }
                }
                igraph_vector_destroy(&neis);
                IGRAPH_FINALLY_CLEAN(1);
            }
        }
    }

    /* Relabel left out vertices (set K in Provan & Shier) to
       correspond to node labelling of graph instead of SBar.
       At the same time ensure that GammaS is a proper subset of
       L, where L are the nodes in the dominator tree. */
    n = igraph_vector_size(&leftout);
    for (i = 0; i < n; i++) {
        VECTOR(leftout)[i] = VECTOR(Sbar_invmap)[(long int)VECTOR(leftout)[i]];
        VECTOR(GammaS)[(long int)VECTOR(leftout)[i]] = 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&M, 0);
    if (igraph_ecount(&domtree) > 0) {
        IGRAPH_CHECK(igraph_i_all_st_cuts_minimal(graph, &domtree, root, S,
                     &GammaS, &Sbar_invmap, &M));
    }

    igraph_vector_clear(Isv);
    IGRAPH_VECTOR_INIT_FINALLY(&Nuv, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&Isv_min, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&GammaS_vec, 0);
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(GammaS)[i]) {
            IGRAPH_CHECK(igraph_vector_push_back(&GammaS_vec, i));
        }
    }

    nomin = igraph_vector_size(&M);
    for (i = 0; i < nomin; i++) {
        /* -------------------------------------------------------------*/
        /* For each v in M find the set Nu(v)=dom(Sbar, v)-K
           Nu(v) contains all vertices that are dominated by v, for every
           v, this is a subtree of the dominator tree, rooted at v. The
           different subtrees are disjoint. */
        long int min = (long int) VECTOR(Sbar_map)[(long int) VECTOR(M)[i] ] - 1;
        long int nuvsize, isvlen, j;
        IGRAPH_CHECK(igraph_dfs(&domtree, (igraph_integer_t) min, IGRAPH_IN,
                                /*unreachable=*/ 0, /*order=*/ &Nuv,
                                /*order_out=*/ 0, /*father=*/ 0, /*dist=*/ 0,
                                /*in_callback=*/ 0, /*out_callback=*/ 0,
                                /*extra=*/ 0));
        /* Remove the NAN values from the end of the vector */
        for (nuvsize = 0; nuvsize < Sbar_size; nuvsize++) {
            igraph_real_t t = VECTOR(Nuv)[nuvsize];
            if (IGRAPH_FINITE(t)) {
                VECTOR(Nuv)[nuvsize] = VECTOR(Sbar_invmap)[(long int) t];
            } else {
                break;
            }
        }
        igraph_vector_resize(&Nuv, nuvsize);

        /* -------------------------------------------------------------*/
        /* By a BFS search of  determine I(S,v)-K.
           I(S,v) contains all vertices that are in Nu(v) and that are
           reachable from Gamma(S) via a path in Nu(v). */
        IGRAPH_CHECK(igraph_bfs(graph, /*root=*/ -1, /*roots=*/ &GammaS_vec,
                                /*mode=*/ IGRAPH_OUT, /*unreachable=*/ 0,
                                /*restricted=*/ &Nuv,
                                /*order=*/ &Isv_min, /*rank=*/ 0,
                                /*father=*/ 0, /*pred=*/ 0, /*succ=*/ 0,
                                /*dist=*/ 0, /*callback=*/ 0, /*extra=*/ 0));
        for (isvlen = 0; isvlen < no_of_nodes; isvlen++) {
            if (!IGRAPH_FINITE(VECTOR(Isv_min)[isvlen])) {
                break;
            }
        }
        igraph_vector_resize(&Isv_min, isvlen);

        /* -------------------------------------------------------------*/
        /* For each c in M check whether Isv-K is included in Tbar. If
           such a v is found, compute Isv={x|v[Nu(v) U K]x} and return v and
           Isv; otherwise return Isv={}. */
        for (j = 0; j < isvlen; j++) {
            long int u = (long int) VECTOR(Isv_min)[j];
            if (igraph_estack_iselement(T, u) || u == target) {
                break;
            }
        }
        /* We might have found one */
        if (j == isvlen) {
            *v = (long int) VECTOR(M)[i];
            /* Calculate real Isv */
            IGRAPH_CHECK(igraph_vector_append(&Nuv, &leftout));
            IGRAPH_CHECK(igraph_bfs(graph, /*root=*/ (igraph_integer_t) *v,
                                    /*roots=*/ 0, /*mode=*/ IGRAPH_OUT,
                                    /*unreachable=*/ 0, /*restricted=*/ &Nuv,
                                    /*order=*/ &Isv_min, /*rank=*/ 0,
                                    /*father=*/ 0, /*pred=*/ 0, /*succ=*/ 0,
                                    /*dist=*/ 0, /*callback=*/ 0, /*extra=*/ 0));
            for (isvlen = 0; isvlen < no_of_nodes; isvlen++) {
                if (!IGRAPH_FINITE(VECTOR(Isv_min)[isvlen])) {
                    break;
                }
            }
            igraph_vector_resize(&Isv_min, isvlen);
            igraph_vector_update(Isv, &Isv_min);

            break;
        }
    }

    igraph_vector_destroy(&GammaS_vec);
    igraph_vector_destroy(&Isv_min);
    igraph_vector_destroy(&Nuv);
    IGRAPH_FINALLY_CLEAN(3);

    igraph_vector_destroy(&M);
    igraph_vector_bool_destroy(&GammaS);
    igraph_destroy(&domtree);
    igraph_vector_destroy(&leftout);
    igraph_destroy(&Sbar);
    igraph_vector_destroy(&Sbar_map);
    igraph_vector_destroy(&Sbar_invmap);
    IGRAPH_FINALLY_CLEAN(7);

    return 0;
}

/* TODO: This is a temporary recursive version, without proper error
   handling */

int igraph_provan_shier_list(const igraph_t *graph,
                             igraph_marked_queue_t *S,
                             igraph_estack_t *T,
                             long int source,
                             long int target,
                             igraph_vector_ptr_t *result,
                             igraph_provan_shier_pivot_t *pivot,
                             void *pivot_arg) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t Isv;
    long int v = 0;
    long int i, n;

    igraph_vector_init(&Isv, 0);

    pivot(graph, S, T, source, target, &v, &Isv, pivot_arg);
    if (igraph_vector_size(&Isv) == 0) {
        if (igraph_marked_queue_size(S) != 0 &&
            igraph_marked_queue_size(S) != no_of_nodes) {
            igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t);
            igraph_vector_init(vec, igraph_marked_queue_size(S));
            igraph_marked_queue_as_vector(S, vec);
            IGRAPH_CHECK(igraph_vector_ptr_push_back(result, vec));
        }
    } else {
        /* Put v into T */
        igraph_estack_push(T, v);

        /* Go down left in the search tree */
        igraph_provan_shier_list(graph, S, T, source, target,
                                 result, pivot, pivot_arg);

        /* Take out v from T */
        igraph_estack_pop(T);

        /* Add Isv to S */
        igraph_marked_queue_start_batch(S);
        n = igraph_vector_size(&Isv);
        for (i = 0; i < n; i++) {
            if (!igraph_marked_queue_iselement(S, (long int) VECTOR(Isv)[i])) {
                igraph_marked_queue_push(S, (long int) VECTOR(Isv)[i]);
            }
        }

        /* Go down right in the search tree */

        igraph_provan_shier_list(graph, S, T, source, target,
                                 result, pivot, pivot_arg);

        /* Take out Isv from S */
        igraph_marked_queue_pop_back_batch(S);
    }

    igraph_vector_destroy(&Isv);

    return 0;
}

/**
 * \function igraph_all_st_cuts
 * List all edge-cuts between two vertices in a directed graph
 *
 * This function lists all edge-cuts between a source and a target
 * vertex. Every cut is listed exactly once. The implemented algorithm
 * is described in JS Provan and DR Shier: A Paradigm for listing
 * (s,t)-cuts in graphs, Algorithmica 15, 351--372, 1996.
 *
 * \param graph The input graph, is must be directed.
 * \param cuts An initialized pointer vector, the cuts are stored
 *        here. It is a list of pointers to igraph_vector_t
 *        objects. Each vector will contain the ids of the edges in
 *        the cut. This argument is ignored if it is a null pointer.
 *        To free all memory allocated for \c cuts, you need call
 *        \ref igraph_vector_destroy() and then \ref igraph_free() on
 *        each element, before destroying the pointer vector itself.
 * \param partition1s An initialized pointer vector, the list of
 *        vertex sets, generating the actual edge cuts, are stored
 *        here. Each vector contains a set of vertex ids. If X is such
 *        a set, then all edges going from X to the complement of X
 *        form an (s,t) edge-cut in the graph. This argument is
 *        ignored if it is a null pointer.
 *        To free all memory allocated for \c partition1s, you need call
 *        \ref igraph_vector_destroy() and then \ref igraph_free() on
 *        each element, before destroying the pointer vector itself.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \return Error code.
 *
 * Time complexity: O(n(|V|+|E|)), where |V| is the number of
 * vertices, |E| is the number of edges, and n is the number of cuts.
 */

int igraph_all_st_cuts(const igraph_t *graph,
                       igraph_vector_ptr_t *cuts,
                       igraph_vector_ptr_t *partition1s,
                       igraph_integer_t source,
                       igraph_integer_t target) {

    /* S is a special stack, in which elements are pushed in batches.
       It is then possible to remove the whole batch in one step.

       T is a stack with an is-element operation.
       Every element is included at most once.
    */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_marked_queue_t S;
    igraph_estack_t T;
    igraph_vector_ptr_t *mypartition1s = partition1s, vpartition1s;
    long int i, nocuts;

    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("Listing all s-t cuts only implemented for "
                     "directed graphs", IGRAPH_UNIMPLEMENTED);
    }

    if (!partition1s) {
        mypartition1s = &vpartition1s;
        IGRAPH_CHECK(igraph_vector_ptr_init(mypartition1s, 0));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, mypartition1s);
    } else {
        igraph_vector_ptr_clear(mypartition1s);
    }

    IGRAPH_CHECK(igraph_marked_queue_init(&S, no_of_nodes));
    IGRAPH_FINALLY(igraph_marked_queue_destroy, &S);
    IGRAPH_CHECK(igraph_estack_init(&T, no_of_nodes, 0));
    IGRAPH_FINALLY(igraph_estack_destroy, &T);

    if (cuts)        {
        igraph_vector_ptr_clear(cuts);
    }

    /* We call it with S={}, T={} */
    IGRAPH_CHECK(igraph_provan_shier_list(graph, &S, &T,
                                          source, target, mypartition1s,
                                          igraph_i_all_st_cuts_pivot,
                                          /*pivot_arg=*/ 0));

    nocuts = igraph_vector_ptr_size(mypartition1s);

    if (cuts) {
        igraph_vector_long_t inS;
        IGRAPH_CHECK(igraph_vector_long_init(&inS, no_of_nodes));
        IGRAPH_FINALLY(igraph_vector_long_destroy, &inS);
        IGRAPH_CHECK(igraph_vector_ptr_resize(cuts, nocuts));
        for (i = 0; i < nocuts; i++) {
            igraph_vector_t *cut;
            igraph_vector_t *part = VECTOR(*mypartition1s)[i];
            long int cutsize = 0;
            long int j, partlen = igraph_vector_size(part);
            /* Mark elements */
            for (j = 0; j < partlen; j++) {
                long int v = (long int) VECTOR(*part)[j];
                VECTOR(inS)[v] = i + 1;
            }
            /* Check how many edges */
            for (j = 0; j < no_of_edges; j++) {
                long int from = IGRAPH_FROM(graph, j);
                long int to = IGRAPH_TO(graph, j);
                long int pfrom = VECTOR(inS)[from];
                long int pto = VECTOR(inS)[to];
                if (pfrom == i + 1 && pto != i + 1) {
                    cutsize++;
                }
            }
            /* Add the edges */
            cut = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!cut) {
                IGRAPH_ERROR("Cannot calculate s-t cuts", IGRAPH_ENOMEM);
            }
            IGRAPH_VECTOR_INIT_FINALLY(cut, cutsize);
            cutsize = 0;
            for (j = 0; j < no_of_edges; j++) {
                long int from = IGRAPH_FROM(graph, j);
                long int to = IGRAPH_TO(graph, j);
                long int pfrom = VECTOR(inS)[from];
                long int pto = VECTOR(inS)[to];
                if ((pfrom == i + 1 && pto != i + 1)) {
                    VECTOR(*cut)[cutsize++] = j;
                }
            }
            VECTOR(*cuts)[i] = cut;
            IGRAPH_FINALLY_CLEAN(1);
        }

        igraph_vector_long_destroy(&inS);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    IGRAPH_FINALLY_CLEAN(2);

    if (!partition1s) {
        for (i = 0; i < nocuts; i++) {
            igraph_vector_t *cut = VECTOR(*mypartition1s)[i];
            igraph_vector_destroy(cut);
            igraph_free(cut);
            VECTOR(*mypartition1s)[i] = 0;
        }
        igraph_vector_ptr_destroy(mypartition1s);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/* We need to find the minimal active elements of Sbar. I.e. all
   active Sbar elements 'v', s.t. there is no other 'w' active Sbar
   element from which 'v' is reachable. (Not necessarily through
   active vertices.)

   We calculate the in-degree of all vertices in Sbar first. Then we
   look at the vertices with zero in-degree. If these are active,
   then they are minimal. If they are are not active, then we remove
   them from the graph, and check whether they resulted in more
   zero-indegree vertices.
*/

static int igraph_i_all_st_mincuts_minimal(const igraph_t *Sbar,
                                           const igraph_vector_bool_t *active,
                                           const igraph_vector_t *invmap,
                                           igraph_vector_t *minimal) {

    long int no_of_nodes = igraph_vcount(Sbar);
    igraph_vector_t indeg;
    long int i, minsize;
    igraph_vector_t neis;

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&indeg, no_of_nodes);

    IGRAPH_CHECK(igraph_degree(Sbar, &indeg, igraph_vss_all(),
                               IGRAPH_IN, /*loops=*/ 1));

#define ACTIVE(x) (VECTOR(*active)[(long int)VECTOR(*invmap)[(x)]])
#define ZEROIN(x) (VECTOR(indeg)[(x)]==0)

    for (i = 0; i < no_of_nodes; i++) {
        if (!ACTIVE(i)) {
            long int j, n;
            IGRAPH_CHECK(igraph_neighbors(Sbar, &neis, (igraph_integer_t) i,
                                          IGRAPH_OUT));
            n = igraph_vector_size(&neis);
            for (j = 0; j < n; j++) {
                long int nei = (long int) VECTOR(neis)[j];
                VECTOR(indeg)[nei] -= 1;
            }
        }
    }

    for (minsize = 0, i = 0; i < no_of_nodes; i++) {
        if (ACTIVE(i) && ZEROIN(i)) {
            minsize++;
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(minimal, minsize));

    for (minsize = 0, i = 0; i < no_of_nodes; i++) {
        if (ACTIVE(i) && ZEROIN(i)) {
            VECTOR(*minimal)[minsize++] = i;
        }
    }

#undef ACTIVE
#undef ZEROIN

    igraph_vector_destroy(&indeg);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

typedef struct igraph_i_all_st_mincuts_data_t {
    const igraph_vector_bool_t *active;
} igraph_i_all_st_mincuts_data_t;

static int igraph_i_all_st_mincuts_pivot(const igraph_t *graph,
                                         const igraph_marked_queue_t *S,
                                         const igraph_estack_t *T,
                                         long int source,
                                         long int target,
                                         long int *v,
                                         igraph_vector_t *Isv,
                                         void *arg) {

    igraph_i_all_st_mincuts_data_t *data = arg;
    const igraph_vector_bool_t *active = data->active;

    long int no_of_nodes = igraph_vcount(graph);
    long int i, j;
    igraph_vector_t Sbar_map, Sbar_invmap;
    igraph_vector_t keep;
    igraph_t Sbar;
    igraph_vector_t M;
    long int nomin;

    IGRAPH_UNUSED(source); IGRAPH_UNUSED(target);

    if (igraph_marked_queue_size(S) == no_of_nodes) {
        igraph_vector_clear(Isv);
        return 0;
    }

    /* Create the graph induced by Sbar */
    IGRAPH_VECTOR_INIT_FINALLY(&Sbar_map, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&Sbar_invmap, 0);

    IGRAPH_VECTOR_INIT_FINALLY(&keep, 0);
    for (i = 0; i < no_of_nodes; i++) {
        if (!igraph_marked_queue_iselement(S, i)) {
            IGRAPH_CHECK(igraph_vector_push_back(&keep, i));
        }
    }

    /* TODO: it is not even necessary to create Sbar explicitly, we
       just need to find the M elements efficiently. See the
       Provan-Shier paper for details. */
    IGRAPH_CHECK(igraph_induced_subgraph_map(graph, &Sbar,
                 igraph_vss_vector(&keep),
                 IGRAPH_SUBGRAPH_AUTO,
                 /* map= */ &Sbar_map,
                 /* invmap= */ &Sbar_invmap));
    IGRAPH_FINALLY(igraph_destroy, &Sbar);

    /* ------------------------------------------------------------- */
    /* Identify the set M of minimal elements that are active */
    IGRAPH_VECTOR_INIT_FINALLY(&M, 0);
    IGRAPH_CHECK(igraph_i_all_st_mincuts_minimal(&Sbar, active,
                 &Sbar_invmap, &M));

    /* ------------------------------------------------------------- */
    /* Now find a minimal element that is not in T */
    igraph_vector_clear(Isv);
    nomin = igraph_vector_size(&M);
    for (i = 0; i < nomin; i++) {
        long int min = (long int) VECTOR(Sbar_invmap)[ (long int) VECTOR(M)[i] ];
        if (min != target)
            if (!igraph_estack_iselement(T, min)) {
                break;
            }
    }
    if (i != nomin) {
        /* OK, we found a pivot element. I(S,v) contains all elements
           that can reach the pivot element */
        igraph_vector_t Isv_min;
        IGRAPH_VECTOR_INIT_FINALLY(&Isv_min, 0);
        *v = (long int) VECTOR(Sbar_invmap)[ (long int) VECTOR(M)[i] ];
        /* TODO: restricted == keep ? */
        IGRAPH_CHECK(igraph_bfs(graph, /*root=*/ (igraph_integer_t) *v,/*roots=*/ 0,
                                /*mode=*/ IGRAPH_IN, /*unreachable=*/ 0,
                                /*restricted=*/ &keep, /*order=*/ &Isv_min,
                                /*rank=*/ 0, /*father=*/ 0, /*pred=*/ 0,
                                /*succ=*/ 0, /*dist=*/ 0, /*callback=*/ 0,
                                /*extra=*/ 0));
        for (j = 0; j < no_of_nodes; j++) {
            igraph_real_t u = VECTOR(Isv_min)[j];
            if (!IGRAPH_FINITE(u)) {
                break;
            }
            if (!igraph_estack_iselement(T, u)) {
                IGRAPH_CHECK(igraph_vector_push_back(Isv, u));
            }
        }
        igraph_vector_destroy(&Isv_min);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&M);
    igraph_destroy(&Sbar);
    igraph_vector_destroy(&keep);
    igraph_vector_destroy(&Sbar_invmap);
    igraph_vector_destroy(&Sbar_map);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \function igraph_all_st_mincuts
 * All minimum s-t cuts of a directed graph
 *
 * This function lists all edge cuts between two vertices, in a directed graph,
 * with minimum total capacity. Possibly, multiple cuts may have the same total
 * capacity, although there is often only one minimum cut in weighted graphs.
 * It is recommended to supply integer-values capacities. Otherwise, not all
 * minimum cuts may be detected because of numerical roundoff errors.
 * The implemented algorithm is described in JS Provan and DR
 * Shier: A Paradigm for listing (s,t)-cuts in graphs, Algorithmica 15,
 * 351--372, 1996.
 *
 * \param graph The input graph, it must be directed.
 * \param value Pointer to a real number, the value of the minimum cut
 *        is stored here, unless it is a null pointer.
 * \param cuts An initialized pointer vector, the cuts are stored
 *        here. It is a list of pointers to igraph_vector_t
 *        objects. Each vector will contain the ids of the edges in
 *        the cut. This argument is ignored if it is a null pointer.
 *        To free all memory allocated for \c cuts, you need call
 *        \ref igraph_vector_destroy() and then \ref igraph_free() on
 *        each element, before destroying the pointer vector itself.
 * \param partition1s An initialized pointer vector, the list of
 *        vertex sets, generating the actual edge cuts, are stored
 *        here. Each vector contains a set of vertex ids. If X is such
 *        a set, then all edges going from X to the complement of X
 *        form an (s,t) edge-cut in the graph. This argument is
 *        ignored if it is a null pointer.
 * \param source The id of the source vertex.
 * \param target The id of the target vertex.
 * \param capacity Vector of edge capacities. All capacities must be
 *        strictly positive. If this is a null pointer, then all edges
 *        are assumed to have capacity one.
 * \return Error code.
 *
 * Time complexity: O(n(|V|+|E|))+O(F), where |V| is the number of
 * vertices, |E| is the number of edges, and n is the number of cuts;
 * O(F) is the time complexity of the maximum flow algorithm, see \ref
 * igraph_maxflow().
 *
 * \example examples/simple/igraph_all_st_mincuts.c
 */

int igraph_all_st_mincuts(const igraph_t *graph, igraph_real_t *value,
                          igraph_vector_ptr_t *cuts,
                          igraph_vector_ptr_t *partition1s,
                          igraph_integer_t source,
                          igraph_integer_t target,
                          const igraph_vector_t *capacity) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t flow;
    igraph_t residual;
    igraph_vector_t NtoL;
    long int newsource, newtarget;
    igraph_marked_queue_t S;
    igraph_estack_t T;
    igraph_i_all_st_mincuts_data_t pivot_data;
    igraph_vector_bool_t VE1bool;
    igraph_vector_t VE1;
    long int VE1size = 0;
    long int i, nocuts;
    igraph_integer_t proj_nodes;
    igraph_vector_t revmap_ptr, revmap_next;
    igraph_vector_ptr_t closedsets;
    igraph_vector_ptr_t *mypartition1s = partition1s, vpartition1s;
    igraph_maxflow_stats_t stats;

    /* -------------------------------------------------------------------- */
    /* Error checks */
    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("S-t cuts can only be listed in directed graphs",
                     IGRAPH_UNIMPLEMENTED);
    }
    if (source < 0 || source >= no_of_nodes) {
        IGRAPH_ERROR("Invalid `source' vertex", IGRAPH_EINVAL);
    }
    if (target < 0 || target >= no_of_nodes) {
        IGRAPH_ERROR("Invalid `target' vertex", IGRAPH_EINVAL);
    }
    if (source == target) {
        IGRAPH_ERROR("`source' and 'target' are the same vertex", IGRAPH_EINVAL);
    }
    if (capacity != NULL && igraph_vector_min(capacity) <= 0)
    {
        IGRAPH_ERROR("Not all capacities are strictly positive.", IGRAPH_EINVAL);
    }

    if (!partition1s) {
        mypartition1s = &vpartition1s;
        IGRAPH_CHECK(igraph_vector_ptr_init(mypartition1s, 0));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, mypartition1s);
    }

    /* -------------------------------------------------------------------- */
    /* We need to calculate the maximum flow first */
    IGRAPH_VECTOR_INIT_FINALLY(&flow, 0);
    IGRAPH_CHECK(igraph_maxflow(graph, value, &flow, /*cut=*/ 0,
                                /*partition1=*/ 0, /*partition2=*/ 0,
                                /*source=*/ source, /*target=*/ target,
                                capacity, &stats));

    /* -------------------------------------------------------------------- */
    /* Then we need the reverse residual graph */
    IGRAPH_CHECK(igraph_reverse_residual_graph(graph, capacity, &residual,
                 &flow));
    IGRAPH_FINALLY(igraph_destroy, &residual);

    /* -------------------------------------------------------------------- */
    /* We shrink it to its strongly connected components */
    IGRAPH_VECTOR_INIT_FINALLY(&NtoL, 0);
    IGRAPH_CHECK(igraph_clusters(&residual, /*membership=*/ &NtoL,
                                 /*csize=*/ 0, /*no=*/ &proj_nodes,
                                 IGRAPH_STRONG));
    IGRAPH_CHECK(igraph_contract_vertices(&residual, /*mapping=*/ &NtoL,
                                          /*vertex_comb=*/ 0));
    IGRAPH_CHECK(igraph_simplify(&residual, /*multiple=*/ 1, /*loops=*/ 1,
                                 /*edge_comb=*/ 0));

    newsource = (long int) VECTOR(NtoL)[(long int)source];
    newtarget = (long int) VECTOR(NtoL)[(long int)target];

    /* TODO: handle the newsource == newtarget case */

    /* -------------------------------------------------------------------- */
    /* Determine the active vertices in the projection */
    IGRAPH_VECTOR_INIT_FINALLY(&VE1, 0);
    IGRAPH_CHECK(igraph_vector_bool_init(&VE1bool, proj_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &VE1bool);
    for (i = 0; i < no_of_edges; i++) {
        if (VECTOR(flow)[i] > 0) {
            long int from = IGRAPH_FROM(graph, i);
            long int to = IGRAPH_TO(graph, i);
            long int pfrom = (long int) VECTOR(NtoL)[from];
            long int pto = (long int) VECTOR(NtoL)[to];
            if (!VECTOR(VE1bool)[pfrom]) {
                VECTOR(VE1bool)[pfrom] = 1;
                VE1size++;
            }
            if (!VECTOR(VE1bool)[pto]) {
                VECTOR(VE1bool)[pto] = 1;
                VE1size++;
            }
        }
    }
    IGRAPH_CHECK(igraph_vector_reserve(&VE1, VE1size));
    for (i = 0; i < proj_nodes; i++) {
        if (VECTOR(VE1bool)[i]) {
            igraph_vector_push_back(&VE1, i);
        }
    }

    if (cuts)        {
        igraph_vector_ptr_clear(cuts);
    }
    if (partition1s) {
        igraph_vector_ptr_clear(partition1s);
    }

    /* -------------------------------------------------------------------- */
    /* Everything is ready, list the cuts, using the right PIVOT
       function  */
    IGRAPH_CHECK(igraph_marked_queue_init(&S, no_of_nodes));
    IGRAPH_FINALLY(igraph_marked_queue_destroy, &S);
    IGRAPH_CHECK(igraph_estack_init(&T, no_of_nodes, 0));
    IGRAPH_FINALLY(igraph_estack_destroy, &T);

    pivot_data.active = &VE1bool;

    IGRAPH_CHECK(igraph_vector_ptr_init(&closedsets, 0));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &closedsets); /* TODO */
    IGRAPH_CHECK(igraph_provan_shier_list(&residual, &S, &T,
                                          newsource, newtarget, &closedsets,
                                          igraph_i_all_st_mincuts_pivot,
                                          &pivot_data));

    /* Convert the closed sets in the contracted graphs to cutsets in the
       original graph */
    IGRAPH_VECTOR_INIT_FINALLY(&revmap_ptr, igraph_vcount(&residual));
    IGRAPH_VECTOR_INIT_FINALLY(&revmap_next, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        long int id = (long int) VECTOR(NtoL)[i];
        VECTOR(revmap_next)[i] = VECTOR(revmap_ptr)[id];
        VECTOR(revmap_ptr)[id] = i + 1;
    }

    /* Create partitions in original graph */
    nocuts = igraph_vector_ptr_size(&closedsets);
    igraph_vector_ptr_clear(mypartition1s);
    IGRAPH_CHECK(igraph_vector_ptr_reserve(mypartition1s, nocuts));
    for (i = 0; i < nocuts; i++) {
        igraph_vector_t *supercut = VECTOR(closedsets)[i];
        long int j, supercutsize = igraph_vector_size(supercut);
        igraph_vector_t *cut = IGRAPH_CALLOC(1, igraph_vector_t);
        IGRAPH_VECTOR_INIT_FINALLY(cut, 0); /* TODO: better allocation */
        for (j = 0; j < supercutsize; j++) {
            long int vtx = (long int) VECTOR(*supercut)[j];
            long int ovtx = (long int) VECTOR(revmap_ptr)[vtx];
            while (ovtx != 0) {
                ovtx--;
                IGRAPH_CHECK(igraph_vector_push_back(cut, ovtx));
                ovtx = (long int) VECTOR(revmap_next)[ovtx];
            }
        }
        igraph_vector_ptr_push_back(mypartition1s, cut);
        IGRAPH_FINALLY_CLEAN(1);

        igraph_vector_destroy(supercut);
        igraph_free(supercut);
        VECTOR(closedsets)[i] = 0;
    }

    igraph_vector_destroy(&revmap_next);
    igraph_vector_destroy(&revmap_ptr);
    igraph_vector_ptr_destroy(&closedsets);
    IGRAPH_FINALLY_CLEAN(3);

    /* Create cuts in original graph */
    if (cuts) {
        igraph_vector_long_t memb;
        IGRAPH_CHECK(igraph_vector_long_init(&memb, no_of_nodes));
        IGRAPH_FINALLY(igraph_vector_long_destroy, &memb);
        IGRAPH_CHECK(igraph_vector_ptr_resize(cuts, nocuts));
        for (i = 0; i < nocuts; i++) {
            igraph_vector_t *part = VECTOR(*mypartition1s)[i];
            long int j, n = igraph_vector_size(part);
            igraph_vector_t *v;
            v = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!v) {
                IGRAPH_ERROR("Cannot list minimum s-t cuts", IGRAPH_ENOMEM);
            }
            IGRAPH_VECTOR_INIT_FINALLY(v, 0);
            for (j = 0; j < n; j++) {
                long int vtx = (long int) VECTOR(*part)[j];
                VECTOR(memb)[vtx] = i + 1;
            }
            for (j = 0; j < no_of_edges; j++) {
                if (VECTOR(flow)[j] > 0) {
                    long int from = IGRAPH_FROM(graph, j);
                    long int to = IGRAPH_TO(graph, j);
                    if (VECTOR(memb)[from] == i + 1 && VECTOR(memb)[to] != i + 1) {
                        IGRAPH_CHECK(igraph_vector_push_back(v, j)); /* TODO: allocation */
                    }
                }
            }
            VECTOR(*cuts)[i] = v;
            IGRAPH_FINALLY_CLEAN(1);
        }
        igraph_vector_long_destroy(&memb);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_vector_bool_destroy(&VE1bool);
    igraph_vector_destroy(&VE1);
    igraph_vector_destroy(&NtoL);
    igraph_destroy(&residual);
    igraph_vector_destroy(&flow);
    IGRAPH_FINALLY_CLEAN(7);

    if (!partition1s) {
        for (i = 0; i < nocuts; i++) {
            igraph_vector_t *cut = VECTOR(*mypartition1s)[i];
            igraph_vector_destroy(cut);
            igraph_free(cut);
            VECTOR(*mypartition1s)[i] = 0;
        }
        igraph_vector_ptr_destroy(mypartition1s);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5071409
igraph-0.9.9/vendor/source/igraph/src/games/0000755000175100001710000000000000000000000021535 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/barabasi.c0000644000175100001710000007200400000000000023450 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_conversion.h"
#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_psumtree.h"
#include "igraph_random.h"

#include "core/interruption.h"

static int igraph_i_barabasi_game_bag(igraph_t *graph, igraph_integer_t n,
                                      igraph_integer_t m,
                                      const igraph_vector_t *outseq,
                                      igraph_bool_t outpref,
                                      igraph_bool_t directed,
                                      const igraph_t *start_from);

static int igraph_i_barabasi_game_psumtree_multiple(igraph_t *graph,
                                                    igraph_integer_t n,
                                                    igraph_real_t power,
                                                    igraph_integer_t m,
                                                    const igraph_vector_t *outseq,
                                                    igraph_bool_t outpref,
                                                    igraph_real_t A,
                                                    igraph_bool_t directed,
                                                    const igraph_t *start_from);

static int igraph_i_barabasi_game_psumtree(igraph_t *graph,
                                           igraph_integer_t n,
                                           igraph_real_t power,
                                           igraph_integer_t m,
                                           const igraph_vector_t *outseq,
                                           igraph_bool_t outpref,
                                           igraph_real_t A,
                                           igraph_bool_t directed,
                                           const igraph_t *start_from);

static int igraph_i_barabasi_game_bag(igraph_t *graph, igraph_integer_t n,
                                      igraph_integer_t m,
                                      const igraph_vector_t *outseq,
                                      igraph_bool_t outpref,
                                      igraph_bool_t directed,
                                      const igraph_t *start_from) {

    long int no_of_nodes = n;
    long int no_of_neighbors = m;
    long int *bag;
    long int bagp = 0;
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int resp;
    long int i, j, k;
    long int bagsize, start_nodes, start_edges, new_edges, no_of_edges;

    if (!directed) {
        outpref = 1;
    }

    start_nodes = start_from ? igraph_vcount(start_from) : 1;
    start_edges = start_from ? igraph_ecount(start_from) : 0;
    if (outseq) {
        if (igraph_vector_size(outseq) > 1) {
            new_edges = (long int) (igraph_vector_sum(outseq) - VECTOR(*outseq)[0]);
        } else {
            new_edges = 0;
        }
    } else {
        new_edges = (no_of_nodes - start_nodes) * no_of_neighbors;
    }
    no_of_edges = start_edges + new_edges;
    resp = start_edges * 2;
    bagsize = no_of_nodes + no_of_edges + (outpref ? no_of_edges : 0);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    bag = IGRAPH_CALLOC(bagsize, long int);
    if (bag == 0) {
        IGRAPH_ERROR("barabasi_game failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, bag);

    /* The first node(s) in the bag */
    if (start_from) {
        igraph_vector_t deg;
        long int ii, jj, sn = igraph_vcount(start_from);
        igraph_neimode_t mm = outpref ? IGRAPH_ALL : IGRAPH_IN;

        IGRAPH_VECTOR_INIT_FINALLY(°, sn);
        IGRAPH_CHECK(igraph_degree(start_from, °, igraph_vss_all(), mm,
                                   IGRAPH_LOOPS));
        for (ii = 0; ii < sn; ii++) {
            long int d = (long int) VECTOR(deg)[ii];
            for (jj = 0; jj <= d; jj++) {
                bag[bagp++] = ii;
            }
        }

        igraph_vector_destroy(°);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        bag[bagp++] = 0;
    }

    /* Initialize the edges vector */
    if (start_from) {
        IGRAPH_CHECK(igraph_get_edgelist(start_from, &edges, /* bycol= */ 0));
        igraph_vector_resize(&edges, no_of_edges * 2);
    }

    RNG_BEGIN();

    /* and the others */

    for (i = (start_from ? start_nodes : 1), k = (start_from ? 0 : 1);
         i < no_of_nodes; i++, k++) {

        IGRAPH_ALLOW_INTERRUPTION();

        /* draw edges */
        if (outseq) {
            no_of_neighbors = (long int) VECTOR(*outseq)[k];
        }
        for (j = 0; j < no_of_neighbors; j++) {
            long int to = bag[RNG_INTEGER(0, bagp - 1)];
            VECTOR(edges)[resp++] = i;
            VECTOR(edges)[resp++] = to;
        }
        /* update bag */
        bag[bagp++] = i;
        for (j = 0; j < no_of_neighbors; j++) {
            bag[bagp++] = (long int) VECTOR(edges)[resp - 2 * j - 1];
            if (outpref) {
                bag[bagp++] = i;
            }
        }
    }

    RNG_END();

    IGRAPH_FREE(bag);
    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_barabasi_game_psumtree_multiple(igraph_t *graph,
                                                    igraph_integer_t n,
                                                    igraph_real_t power,
                                                    igraph_integer_t m,
                                                    const igraph_vector_t *outseq,
                                                    igraph_bool_t outpref,
                                                    igraph_real_t A,
                                                    igraph_bool_t directed,
                                                    const igraph_t *start_from) {

    long int no_of_nodes = n;
    long int no_of_neighbors = m;
    igraph_vector_t edges;
    long int i, j, k;
    igraph_psumtree_t sumtree;
    long int edgeptr = 0;
    igraph_vector_t degree;
    long int start_nodes, start_edges, new_edges, no_of_edges;

    if (!directed) {
        outpref = 1;
    }

    start_nodes = start_from ? igraph_vcount(start_from) : 1;
    start_edges = start_from ? igraph_ecount(start_from) : 0;
    if (outseq) {
        if (igraph_vector_size(outseq) > 1) {
            new_edges = (long int) (igraph_vector_sum(outseq) - VECTOR(*outseq)[0]);
        } else {
            new_edges = 0;
        }
    } else {
        new_edges = (no_of_nodes - start_nodes) * no_of_neighbors;
    }
    no_of_edges = start_edges + new_edges;
    edgeptr = start_edges * 2;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    /* first node(s) */
    if (start_from) {
        long int ii, sn = igraph_vcount(start_from);
        igraph_neimode_t mm = outpref ? IGRAPH_ALL : IGRAPH_IN;
        IGRAPH_CHECK(igraph_degree(start_from, °ree, igraph_vss_all(), mm,
                                   IGRAPH_LOOPS));
        IGRAPH_CHECK(igraph_vector_resize(°ree,  no_of_nodes));
        for (ii = 0; ii < sn; ii++) {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, ii, pow(VECTOR(degree)[ii], power) + A));
        }
    } else {
        IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, A));
    }

    /* Initialize the edges vector */
    if (start_from) {
        IGRAPH_CHECK(igraph_get_edgelist(start_from, &edges, /* bycol= */ 0));
        igraph_vector_resize(&edges, no_of_edges * 2);
    }

    RNG_BEGIN();

    /* and the rest */
    for (i = (start_from ? start_nodes : 1), k = (start_from ? 0 : 1);
         i < no_of_nodes; i++, k++) {
        igraph_real_t sum = igraph_psumtree_sum(&sumtree);
        long int to;

        IGRAPH_ALLOW_INTERRUPTION();

        if (outseq) {
            no_of_neighbors = (long int) VECTOR(*outseq)[k];
        }
        for (j = 0; j < no_of_neighbors; j++) {
            igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
            VECTOR(degree)[to]++;
            VECTOR(edges)[edgeptr++] = i;
            VECTOR(edges)[edgeptr++] = to;
        }
        /* update probabilities */
        for (j = 0; j < no_of_neighbors; j++) {
            long int nn = (long int) VECTOR(edges)[edgeptr - 2 * j - 1];
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, nn, pow(VECTOR(degree)[nn], power) + A));
        }
        if (outpref) {
            VECTOR(degree)[i] += no_of_neighbors;
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, pow(VECTOR(degree)[i], power) + A));
        } else {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, A));
        }
    }

    RNG_END();

    igraph_psumtree_destroy(&sumtree);
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_barabasi_game_psumtree(igraph_t *graph,
                                           igraph_integer_t n,
                                           igraph_real_t power,
                                           igraph_integer_t m,
                                           const igraph_vector_t *outseq,
                                           igraph_bool_t outpref,
                                           igraph_real_t A,
                                           igraph_bool_t directed,
                                           const igraph_t *start_from) {

    long int no_of_nodes = n;
    long int no_of_neighbors = m;
    igraph_vector_t edges;
    long int i, j, k;
    igraph_psumtree_t sumtree;
    long int edgeptr = 0;
    igraph_vector_t degree;
    long int start_nodes, start_edges, new_edges, no_of_edges;

    if (!directed) {
        outpref = 1;
    }

    start_nodes = start_from ? igraph_vcount(start_from) : 1;
    start_edges = start_from ? igraph_ecount(start_from) : 0;
    if (outseq) {
        if (igraph_vector_size(outseq) > 1) {
            new_edges = (long int) (igraph_vector_sum(outseq) - VECTOR(*outseq)[0]);
        } else {
            new_edges = 0;
        }
    } else {
        new_edges = (no_of_nodes - start_nodes) * no_of_neighbors;
    }
    no_of_edges = start_edges + new_edges;
    edgeptr = start_edges * 2;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));
    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    RNG_BEGIN();

    /* first node(s) */
    if (start_from) {
        long int ii, sn = igraph_vcount(start_from);
        igraph_neimode_t mm = outpref ? IGRAPH_ALL : IGRAPH_IN;
        IGRAPH_CHECK(igraph_degree(start_from, °ree, igraph_vss_all(), mm,
                                   IGRAPH_LOOPS));
        IGRAPH_CHECK(igraph_vector_resize(°ree,  no_of_nodes));
        for (ii = 0; ii < sn; ii++) {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, ii, pow(VECTOR(degree)[ii], power) + A));
        }
    } else {
        IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, A));
    }

    /* Initialize the edges vector */
    if (start_from) {
        IGRAPH_CHECK(igraph_get_edgelist(start_from, &edges, /* bycol= */ 0));
    }

    /* and the rest */
    for (i = (start_from ? start_nodes : 1), k = (start_from ? 0 : 1);
         i < no_of_nodes; i++, k++) {
        igraph_real_t sum;
        long int to;

        IGRAPH_ALLOW_INTERRUPTION();

        if (outseq) {
            no_of_neighbors = (long int) VECTOR(*outseq)[k];
        }
        if (no_of_neighbors >= i) {
            /* All existing vertices are cited */
            for (to = 0; to < i; to++) {
                VECTOR(degree)[to]++;
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                edgeptr += 2;
                IGRAPH_CHECK(igraph_psumtree_update(&sumtree, to, pow(VECTOR(degree)[to], power) + A));
            }
        } else {
            for (j = 0; j < no_of_neighbors; j++) {
                sum = igraph_psumtree_sum(&sumtree);
                igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
                VECTOR(degree)[to]++;
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                edgeptr += 2;
                IGRAPH_CHECK(igraph_psumtree_update(&sumtree, to, 0.0));
            }
            /* update probabilities */
            for (j = 0; j < no_of_neighbors; j++) {
                long int nn = (long int) VECTOR(edges)[edgeptr - 2 * j - 1];
                IGRAPH_CHECK(igraph_psumtree_update(&sumtree, nn, pow(VECTOR(degree)[nn], power) + A));
            }
        }
        if (outpref) {
            VECTOR(degree)[i] += no_of_neighbors > i ? i : no_of_neighbors;
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, pow(VECTOR(degree)[i], power) + A));
        } else {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, A));
        }
    }

    RNG_END();

    igraph_psumtree_destroy(&sumtree);
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup generators
 * \function igraph_barabasi_game
 * \brief Generates a graph based on the Barabási-Albert model.
 *
 * \param graph An uninitialized graph object.
 * \param n The number of vertices in the graph.
 * \param power Power of the preferential attachment. The probability
 *        that a vertex is cited is proportional to d^power+A, where
 *        d is its degree (see also the \p outpref argument), power
 *        and A are given by arguments. In the classic preferential
 *        attachment model power=1.
 * \param m The number of outgoing edges generated for each
 *        vertex. (Only if \p outseq is \c NULL.)
 * \param outseq Gives the (out-)degrees of the vertices. If this is
 *        constant, this can be a NULL pointer or an empty (but
 *        initialized!) vector, in this case \p m contains
 *        the constant out-degree. The very first vertex has by definition
 *        no outgoing edges, so the first number in this vector is
 *        ignored.
 * \param outpref Boolean, if true not only the in- but also the out-degree
 *        of a vertex increases its citation probability. I.e., the
 *        citation probability is determined by the total degree of
 *        the vertices. Ignored and assumed to be true if the graph
 *        being generated is undirected.
 * \param A The probability that a vertex is cited is proportional to
 *        d^power+A, where d is its degree (see also the \p outpref
 *        argument), power and A are given by arguments. In the
 *        previous versions of the function this parameter was
 *        implicitly set to one.
 * \param directed Boolean, whether to generate a directed graph.
 * \param algo The algorithm to use to generate the network. Possible
 *        values:
 *        \clist
 *        \cli IGRAPH_BARABASI_BAG
 *          This is the algorithm that was previously (before version
 *          0.6) solely implemented in igraph. It works by putting the
 *          ids of the vertices into a bag (multiset, really), exactly
 *          as many times as their (in-)degree, plus once more. Then
 *          the required number of cited vertices are drawn from the
 *          bag, with replacement. This method might generate multiple
 *          edges. It only works if power=1 and A=1.
 *        \cli IGRAPH_BARABASI_PSUMTREE
 *          This algorithm uses a partial prefix-sum tree to generate
 *          the graph. It does not generate multiple edges and
 *          works for any power and A values.
 *        \cli IGRAPH_BARABASI_PSUMTREE_MULTIPLE
 *          This algorithm also uses a partial prefix-sum tree to
 *          generate the graph. The difference is, that now multiple
 *          edges are allowed. This method was implemented under the
 *          name \c igraph_nonlinear_barabasi_game before version 0.6.
 *        \endclist
 * \param start_from Either a null pointer, or a graph. In the former
 *        case, the starting configuration is a clique of size \p m.
 *        In the latter case, the graph is a starting configuration.
 *        The graph must be non-empty, i.e. it must have at least one
 *        vertex. If a graph is supplied here and the \p outseq
 *        argument is also given, then \p outseq should only contain
 *        information on the vertices that are not in the \p
 *        start_from graph.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid \p n,
 *         \p m or \p outseq parameter.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges.
 *
 * \example examples/simple/igraph_barabasi_game.c
 * \example examples/simple/igraph_barabasi_game2.c
 */
int igraph_barabasi_game(igraph_t *graph, igraph_integer_t n,
                         igraph_real_t power,
                         igraph_integer_t m,
                         const igraph_vector_t *outseq,
                         igraph_bool_t outpref,
                         igraph_real_t A,
                         igraph_bool_t directed,
                         igraph_barabasi_algorithm_t algo,
                         const igraph_t *start_from) {

    long int start_nodes = start_from ? igraph_vcount(start_from) : 0;
    long int newn = start_from ? n - start_nodes : n;

    /* Fix obscure parameterizations */
    if (outseq && igraph_vector_size(outseq) == 0) {
        outseq = 0;
    }
    if (!directed) {
        outpref = 1;
    }

    /* Check arguments */

    if (algo != IGRAPH_BARABASI_BAG &&
        algo != IGRAPH_BARABASI_PSUMTREE &&
        algo != IGRAPH_BARABASI_PSUMTREE_MULTIPLE) {
        IGRAPH_ERROR("Invalid algorithm", IGRAPH_EINVAL);
    }
    if (n < 0) {
        IGRAPH_ERROR("Invalid number of vertices.", IGRAPH_EINVAL);
    } else if (newn < 0) {
        IGRAPH_ERROR("Starting graph has too many vertices.", IGRAPH_EINVAL);
    }
    if (start_from && start_nodes == 0) {
        IGRAPH_ERROR("Cannot start from an empty graph.", IGRAPH_EINVAL);
    }
    if (outseq != 0 && igraph_vector_size(outseq) != 0 &&
        igraph_vector_size(outseq) != newn) {
        IGRAPH_ERROR("Invalid out-degree sequence length.", IGRAPH_EINVAL);
    }
    if ( (outseq == 0 || igraph_vector_size(outseq) == 0) && m < 0) {
        IGRAPH_ERROR("Number of edges added per step must not be negative.", IGRAPH_EINVAL);
    }
    if (outseq && igraph_vector_min(outseq) < 0) {
        IGRAPH_ERROR("Negative out-degree in sequence.", IGRAPH_EINVAL);
    }
    if (!outpref && A <= 0) {
        IGRAPH_ERROR("Constant attractiveness (A) must be positive.",
                     IGRAPH_EINVAL);
    }
    if (outpref && A < 0) {
        IGRAPH_ERROR("Constant attractiveness (A) must be non-negative.",
                     IGRAPH_EINVAL);
    }
    if (algo == IGRAPH_BARABASI_BAG) {
        if (power != 1) {
            IGRAPH_ERROR("Power must be one for 'bag' algorithm.", IGRAPH_EINVAL);
        }
        if (A != 1) {
            IGRAPH_ERROR("Constant attractiveness (A) must be one for bag algorithm.",
                         IGRAPH_EINVAL);
        }
    }
    if (start_from && directed != igraph_is_directed(start_from)) {
        IGRAPH_WARNING("Directedness of the start graph and the output graph mismatch.");
    }
    if (start_from && !igraph_is_directed(start_from) && !outpref) {
        IGRAPH_ERROR("`outpref' must be true if starting from an undirected graph.",
                     IGRAPH_EINVAL);
    }

    if (n == 0) {
        return igraph_empty(graph, 0, directed);
    }

    if (algo == IGRAPH_BARABASI_BAG) {
        return igraph_i_barabasi_game_bag(graph, n, m, outseq, outpref, directed,
                                          start_from);
    } else if (algo == IGRAPH_BARABASI_PSUMTREE) {
        return igraph_i_barabasi_game_psumtree(graph, n, power, m, outseq,
                                               outpref, A, directed, start_from);
    } else if (algo == IGRAPH_BARABASI_PSUMTREE_MULTIPLE) {
        return igraph_i_barabasi_game_psumtree_multiple(graph, n, power, m,
                outseq, outpref, A,
                directed, start_from);
    }

    return 0;
}

/**
 * \function igraph_barabasi_aging_game
 * \brief Preferential attachment with aging of vertices.
 *
 * 
 * This game starts with one vertex (if \p nodes > 0). In each step
 * a new node is added, and it is connected to \p m existing nodes.
 * Existing nodes to connect to are chosen with probability dependent
 * on their (in-)degree (\c k) and age (\c l).
 * The degree-dependent part is
 * deg_coef * k^pa_exp + zero_deg_appeal,
 * while the age-dependent part is
 * age_coef * l^aging_exp + zero_age_appeal,
 * which are summed to obtain the final weight.
 *
 * 
 * The age \c l is based on the number of vertices in the
 * network and the \p aging_bins argument: the age of a node
 * is incremented by 1 after each
 * floor(nodes / aging_bins) + 1
 * time steps.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the graph.
 * \param m The number of edges to add in each time step.
 *        Ignored if \p outseq is a non-zero length vector.
 * \param outseq The number of edges to add in each time step. If it
 *        is \c NULL or a zero-length vector then it is ignored
 *        and the \p m argument is used instead.
 * \param outpref Logical constant, whether the edges
 *        initiated by a vertex contribute to the probability to gain
 *        a new edge.
 * \param pa_exp The exponent of the preferential attachment, a small
 *        positive number usually, the value 1 yields the classic
 *        linear preferential attachment.
 * \param aging_exp The exponent of the aging, this is a negative
 *        number usually.
 * \param aging_bins Integer constant, the number of age bins to use.
 * \param zero_deg_appeal The degree dependent part of the
 *        attractiveness of the zero degree vertices.
 * \param zero_age_appeal The age dependent part of the attractiveness
 *        of the vertices of age zero. This parameter is usually zero.
 * \param deg_coef The coefficient for the degree.
 * \param age_coef The coefficient for the age.
 * \param directed Logical constant, whether to generate a directed
 *        graph.
 * \return Error code.
 *
 * Time complexity: O((|V|+|V|/aging_bins)*log(|V|)+|E|). |V| is the number
 * of vertices, |E| the number of edges.
 */
int igraph_barabasi_aging_game(igraph_t *graph,
                               igraph_integer_t nodes,
                               igraph_integer_t m,
                               const igraph_vector_t *outseq,
                               igraph_bool_t outpref,
                               igraph_real_t pa_exp,
                               igraph_real_t aging_exp,
                               igraph_integer_t aging_bins,
                               igraph_real_t zero_deg_appeal,
                               igraph_real_t zero_age_appeal,
                               igraph_real_t deg_coef,
                               igraph_real_t age_coef,
                               igraph_bool_t directed) {
    long int no_of_nodes = nodes;
    long int no_of_neighbors = m;
    long int binwidth;
    long int no_of_edges;
    igraph_vector_t edges;
    long int i, j, k;
    igraph_psumtree_t sumtree;
    long int edgeptr = 0;
    igraph_vector_t degree;

    if (no_of_nodes < 0) {
        IGRAPH_ERRORF("Number of nodes must not be negative, got %ld.", IGRAPH_EINVAL, no_of_nodes);
    }
    if (outseq != 0 && igraph_vector_size(outseq) != 0 && igraph_vector_size(outseq) != no_of_nodes) {
        IGRAPH_ERRORF("The length of the out-degree sequence (%ld) does not agree with the number of nodes (%ld).",
                       IGRAPH_EINVAL,
                       igraph_vector_size(outseq), no_of_nodes);
    }
    if ( (outseq == 0 || igraph_vector_size(outseq) == 0) && m < 0) {
        IGRAPH_ERRORF("The number of edges per time step must not be negative, got %" IGRAPH_PRId ".",
                      IGRAPH_EINVAL,
                      m);
    }
    if (aging_bins <= 0) {
        IGRAPH_ERRORF("Number of aging bins must be positive, got %" IGRAPH_PRId ".",
                     IGRAPH_EINVAL,
                     aging_bins);
    }
    if (deg_coef < 0) {
        IGRAPH_ERRORF("Degree coefficient must be non-negative, got %g.",
                     IGRAPH_EINVAL,
                     deg_coef);
    }
    if (age_coef < 0) {
        IGRAPH_ERRORF("Age coefficient must be non-negative, got %g.",
                     IGRAPH_EINVAL,
                     deg_coef);
    }

    if (zero_deg_appeal < 0) {
        IGRAPH_ERRORF("Zero degree appeal must be non-negative, got %g.",
                     IGRAPH_EINVAL,
                     zero_deg_appeal);
    }
    if (zero_age_appeal < 0) {
        IGRAPH_ERRORF("Zero age appeal must be non-negative, got %g.",
                     IGRAPH_EINVAL,
                     zero_age_appeal);
    }

    if (no_of_nodes == 0) {
         return igraph_empty(graph, 0, directed);
    }

    binwidth = no_of_nodes / aging_bins + 1;

    if (outseq == 0 || igraph_vector_size(outseq) == 0) {
        no_of_neighbors = m;
        no_of_edges = (no_of_nodes - 1) * no_of_neighbors;
    } else {
        no_of_edges = 0;
        for (i = 1; i < igraph_vector_size(outseq); i++) {
            no_of_edges += VECTOR(*outseq)[i];
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    RNG_BEGIN();

    /* first node */
    IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, zero_deg_appeal * (1 + zero_age_appeal)));

    /* and the rest */
    for (i = 1; i < no_of_nodes; i++) {
        igraph_real_t sum;
        long int to;

        IGRAPH_ALLOW_INTERRUPTION();

        if (outseq != 0 && igraph_vector_size(outseq) != 0) {
            no_of_neighbors = (long int) VECTOR(*outseq)[i];
        }
        sum = igraph_psumtree_sum(&sumtree);
        for (j = 0; j < no_of_neighbors; j++) {
            igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
            VECTOR(degree)[to]++;
            VECTOR(edges)[edgeptr++] = i;
            VECTOR(edges)[edgeptr++] = to;
        }
        /* update probabilities */
        for (j = 0; j < no_of_neighbors; j++) {
            long int n = (long int) VECTOR(edges)[edgeptr - 2 * j - 1];
            long int age = (i - n) / binwidth;
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, n,
                (deg_coef * pow(VECTOR(degree)[n], pa_exp) + zero_deg_appeal) *
                (age_coef * pow(age + 1, aging_exp) + zero_age_appeal)
            ));
        }
        if (outpref) {
            VECTOR(degree)[i] += no_of_neighbors;
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, i,
                (zero_age_appeal + 1) * (deg_coef * pow(VECTOR(degree)[i], pa_exp) + zero_deg_appeal)
            ));
        } else {
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, i, (1 + zero_age_appeal) * zero_deg_appeal
            ));
        }

        /* aging */
        for (k = 1; binwidth * k <= i; k++) {
            long int shnode = i - binwidth * k;
            long int deg = (long int) VECTOR(degree)[shnode];
            long int age = (i - shnode) / binwidth;
            /* igraph_real_t old=igraph_psumtree_get(&sumtree, shnode); */
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, shnode,
                (deg_coef * pow(deg, pa_exp) + zero_deg_appeal) *
                (age_coef * pow(age + 2, aging_exp) + zero_age_appeal)
                ));
        }
    }

    RNG_END();

    igraph_vector_destroy(°ree);
    igraph_psumtree_destroy(&sumtree);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/callaway_traits.c0000644000175100001710000001610000000000000025062 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_random.h"

/**
 * \function igraph_callaway_traits_game
 * \brief Simulates a growing network with vertex types.
 *
 * 
 * The different types of vertices prefer to connect other types of
 * vertices with a given probability.
 *
 * 
 * The simulation goes like this: in each discrete time step a new
 * vertex is added to the graph. The type of this vertex is generated
 * based on \p type_dist. Then two vertices are selected uniformly
 * randomly from the graph. The probability that they will be
 * connected depends on the types of these vertices and is taken from
 * \p pref_matrix. Then another two vertices are selected and this is
 * repeated \p edges_per_step times in each time step.
 *
 * 
 * References:
 *
 * 
 * D. S. Callaway, J. E. Hopcroft, J. M. Kleinberg, M. E. J. Newman, and S. H. Strogatz,
 * Are randomly grown graphs really random?
 * Phys. Rev. E 64, 041902 (2001).
 * https://doi.org/10.1103/PhysRevE.64.041902
 *
 * \param graph Pointer to an uninitialized graph.
 * \param nodes The number of nodes in the graph.
 * \param types Number of node types.
 * \param edges_per_step The number of connections tried in each time step.
 * \param type_dist Vector giving the distribution of the vertex types.
 * If \c NULL, the distribution is assumed to be uniform.
 * \param pref_matrix Matrix giving the connection probabilities for
 * the vertex types.
 * \param directed Logical, whether to generate a directed graph.
 * \param node_type_vec An initialized vector or \c NULL.
 * If not \c NULL, the type of each node will be stored here.
 * \return Error code.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|*k*log(|V|)), |V| is the number of vertices,
 * k is \p edges_per_step.
 */
int igraph_callaway_traits_game(igraph_t *graph, igraph_integer_t nodes,
                                igraph_integer_t types, igraph_integer_t edges_per_step,
                                const igraph_vector_t *type_dist,
                                const igraph_matrix_t *pref_matrix,
                                igraph_bool_t directed,
                                igraph_vector_t *node_type_vec) {
    long int i, j;
    igraph_vector_t edges;
    igraph_vector_t cumdist;
    igraph_real_t maxcum;
    igraph_vector_t *nodetypes;

    /* Argument contracts */
    if(nodes < 0){
        IGRAPH_ERROR("The number of vertices must be non-negative.", IGRAPH_EINVAL);
    }

    if (types < 1) {
        IGRAPH_ERROR("The number of vertex types must be at least 1.", IGRAPH_EINVAL);
    }

    if (type_dist) {
        igraph_real_t lo;

        if (igraph_vector_size(type_dist) != types) {
            IGRAPH_ERROR("The vertex type distribution vector must agree in length with the number of types.",
                         IGRAPH_EINVAL);
        }

        lo = igraph_vector_min(type_dist);
        if (lo < 0) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain negative values.", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo)) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (igraph_matrix_nrow(pref_matrix) != types || igraph_matrix_ncol(pref_matrix) != types) {
        IGRAPH_ERROR("The preference matrix must be square and agree in dimensions with the number of types.", IGRAPH_EINVAL);
    }

    {
        igraph_real_t lo, hi;
        igraph_matrix_minmax(pref_matrix, &lo, &hi);

        if (lo < 0 || hi > 1) {
            IGRAPH_ERROR("The preference matrix must contain probabilities in [0, 1].", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo) || igraph_is_nan(hi)) {
            IGRAPH_ERROR("The preference matrix must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (! directed && ! igraph_matrix_is_symmetric(pref_matrix)) {
        IGRAPH_ERROR("The preference matrix must be symmetric when generating undirected graphs.", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&cumdist, types + 1);

    if (type_dist) {
        VECTOR(cumdist)[0] = 0;
        for (i = 0; i < types; ++i) {
            VECTOR(cumdist)[i + 1] = VECTOR(cumdist)[i] + VECTOR(*type_dist)[i];
        }
    } else {
        for (i = 0; i < types+1; ++i) {
            VECTOR(cumdist)[i] = i;
        }
    }
    maxcum = igraph_vector_tail(&cumdist);

    if (maxcum <= 0) {
        IGRAPH_ERROR("The vertex type distribution vector must contain at least one positive value.", IGRAPH_EINVAL);
    }

    if (node_type_vec) {
        nodetypes = node_type_vec;
        IGRAPH_CHECK(igraph_vector_resize(nodetypes, nodes));
    } else {
        nodetypes = IGRAPH_CALLOC(1, igraph_vector_t);
        if (! nodetypes) {
            IGRAPH_ERROR("Insufficient memory for callaway_traits_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, nodetypes);
        IGRAPH_VECTOR_INIT_FINALLY(nodetypes, nodes);
    }

    RNG_BEGIN();

    for (i = 0; i < nodes; i++) {
        igraph_real_t uni = RNG_UNIF(0, maxcum);
        long int type;
        igraph_vector_binsearch(&cumdist, uni, &type);
        VECTOR(*nodetypes)[i] = type - 1;
    }

    for (i = 1; i < nodes; i++) {
        for (j = 0; j < edges_per_step; j++) {
            long int node1 = RNG_INTEGER(0, i);
            long int node2 = RNG_INTEGER(0, i);
            long int type1 = (long int) VECTOR(*nodetypes)[node1];
            long int type2 = (long int) VECTOR(*nodetypes)[node2];
            /*    printf("unif: %f, %f, types: %li, %li\n", uni1, uni2, type1, type2); */
            if (RNG_UNIF01() < MATRIX(*pref_matrix, type1, type2)) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, node1));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, node2));
            }
        }
    }

    RNG_END();

    if (! node_type_vec) {
        igraph_vector_destroy(nodetypes);
        IGRAPH_FREE(nodetypes);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_vector_destroy(&cumdist);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/citations.c0000644000175100001710000004256500000000000023712 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_psumtree.h"
#include "igraph_random.h"
#include "igraph_interface.h"

typedef struct {
    long int no;
    igraph_psumtree_t *sumtrees;
} igraph_i_citing_cited_type_game_struct_t;

static void igraph_i_citing_cited_type_game_free (
        igraph_i_citing_cited_type_game_struct_t *s);

/**
 * \function igraph_lastcit_game
 * \brief Simulates a citation network, based on time passed since the last citation.
 *
 * This is a quite special stochastic graph generator, it models an
 * evolving graph. In each time step a single vertex is added to the
 * network and it cites a number of other vertices (as specified by
 * the \p edges_per_step argument). The cited vertices are selected
 * based on the last time they were cited. Time is measured by the
 * addition of vertices and it is binned into \p agebins bins.
 * So if the current time step is \c t and the last citation to a
 * given \c i vertex was made in time step \c t0, then \c
 * (t-t0)/binwidth is calculated where binwidth is \c nodes/agebins+1,
 * in the last expression '/' denotes integer division, so the
 * fraction part is omitted.
 *
 * 
 * The \p preference argument specifies the preferences for the
 * citation lags, i.e. its first elements contains the attractivity
 * of the very recently cited vertices, etc. The last element is
 * special, it contains the attractivity of the vertices which were
 * never cited. This element should be bigger than zero.
 *
 * 
 * Note that this function generates networks with multiple edges if
 * \p edges_per_step is bigger than one, call \ref igraph_simplify()
 * on the result to get rid of these edges.
 * \param graph Pointer to an uninitialized graph object, the result
 *     will be stored here.
 * \param node The number of vertices in the network.
 * \param edges_per_node The number of edges to add in each time
 *     step.
 * \param agebins The number of age bins to use.
 * \param preference Pointer to an initialized vector of length
 *     \c agebins+1. This contains the `attractivity' of the various
 *     age bins, the last element is the attractivity of the vertices
 *     which were never cited, and it should be greater than zero.
 *     It is a good idea to have all positive values in this vector.
 *     Preferences cannot be negative.
 * \param directed Logical constant, whether to create directed
 *      networks.
 * \return Error code.
 *
 * \sa \ref igraph_barabasi_aging_game().
 *
 * Time complexity: O(|V|*a+|E|*log|V|), |V| is the number of vertices,
 * |E| is the total number of edges, a is the \p agebins parameter.
 */
int igraph_lastcit_game(igraph_t *graph,
                        igraph_integer_t nodes, igraph_integer_t edges_per_node,
                        igraph_integer_t agebins,
                        const igraph_vector_t *preference,
                        igraph_bool_t directed) {

    long int no_of_nodes = nodes;
    igraph_psumtree_t sumtree;
    igraph_vector_t edges;
    long int i, j, k;
    long int *lastcit;
    long int *index;
    long int binwidth;

    if (agebins != igraph_vector_size(preference) - 1) {
        IGRAPH_ERRORF("The `preference' vector should be of length `agebins' plus one."
                     "Number of agebins is %"IGRAPH_PRId", preference vector is of length %ld.",
                     IGRAPH_EINVAL,
                     agebins, igraph_vector_size(preference));
    }
    if (nodes < 0 ) {
        IGRAPH_ERRORF("Number of nodes should be non-negative, received %"IGRAPH_PRId".",
                     IGRAPH_EINVAL,
                     nodes);
    }
    if (agebins < 1 ) {
        IGRAPH_ERRORF("Number of age bins should be at least 1, received %"IGRAPH_PRId".",
                     IGRAPH_EINVAL,
                     agebins);
    }
    if (VECTOR(*preference)[agebins] <= 0) {
        IGRAPH_ERRORF("The last element of the `preference' vector needs to be positive, but is %g.",
                     IGRAPH_EINVAL,
                     VECTOR(*preference)[agebins]);
    }
    if (igraph_vector_min(preference) < 0) {
        IGRAPH_ERRORF("The preference vector must contain only non-negative values, but found %g.",
                     IGRAPH_EINVAL,
                     igraph_vector_min(preference));
    }

    if (nodes == 0) {
        IGRAPH_CHECK(igraph_empty(graph, nodes, directed));
        return IGRAPH_SUCCESS;
    }

    binwidth = no_of_nodes / agebins + 1;
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    lastcit = IGRAPH_CALLOC(no_of_nodes, long int);
    if (!lastcit) {
        IGRAPH_ERROR("lastcit game failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, lastcit);

    index = IGRAPH_CALLOC(no_of_nodes + 1, long int);
    if (!index) {
        IGRAPH_ERROR("lastcit game failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, index);

    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, nodes * edges_per_node));

    /* The first node */
    IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, VECTOR(*preference)[agebins]));
    index[0] = 0;
    index[1] = 0;

    RNG_BEGIN();

    for (i = 1; i < no_of_nodes; i++) {

        /* Add new edges */
        for (j = 0; j < edges_per_node; j++) {
            long int to;
            igraph_real_t sum = igraph_psumtree_sum(&sumtree);
            igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
            igraph_vector_push_back(&edges, i);
            igraph_vector_push_back(&edges, to);
            lastcit[to] = i + 1;
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, to, VECTOR(*preference)[0]));
        }

        /* Add the node itself */
        IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, VECTOR(*preference)[agebins]));
        index[i + 1] = index[i] + edges_per_node;

        /* Update the preference of some vertices if they got to another bin.
           We need to know the citations of some older vertices, this is in the index. */
        for (k = 1; i - binwidth * k >= 1; k++) {
            long int shnode = i - binwidth * k;
            long int m = index[shnode], n = index[shnode + 1];
            for (j = 2 * m; j < 2 * n; j += 2) {
                long int cnode = (long int) VECTOR(edges)[j + 1];
                if (lastcit[cnode] == shnode + 1) {
                    IGRAPH_CHECK(igraph_psumtree_update(&sumtree, cnode, VECTOR(*preference)[k]));
                }
            }
        }

    }

    RNG_END();

    igraph_psumtree_destroy(&sumtree);
    igraph_free(index);
    igraph_free(lastcit);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_cited_type_game
 * \brief Simulates a citation based on vertex types.
 *
 * Function to create a network based on some vertex categories. This
 * function creates a citation network: in each step a single vertex
 * and \p edges_per_step citing edges are added. Nodes with
 * different categories may have different probabilities to get
 * cited, as given by the \p pref vector.
 *
 * 
 * Note that this function might generate networks with multiple edges
 * if \p edges_per_step is greater than one. You might want to call
 * \ref igraph_simplify() on the result to remove multiple edges.
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the network.
 * \param types Numeric vector giving the categories of the vertices,
 *     so it should contain \p nodes non-negative integer
 *     numbers. Types are numbered from zero.
 * \param pref The attractivity of the different vertex categories in
 *     a vector. Its length should be the maximum element in \p types
 *     plus one (types are numbered from zero).
 * \param edges_per_step Integer constant, the number of edges to add
 *     in each time step.
 * \param directed Logical constant, whether to create a directed
 *     network.
 * \return Error code.
 *
 * \sa \ref igraph_citing_cited_type_game() for a bit more general
 * game.
 *
 * Time complexity: O((|V|+|E|)log|V|), |V| and |E| are number of
 * vertices and edges, respectively.
 */

int igraph_cited_type_game(igraph_t *graph, igraph_integer_t nodes,
                           const igraph_vector_t *types,
                           const igraph_vector_t *pref,
                           igraph_integer_t edges_per_step,
                           igraph_bool_t directed) {

    igraph_vector_t edges;
    igraph_vector_t cumsum;
    igraph_real_t sum, nnval;
    long int i, j, type;
    long int pref_len = igraph_vector_size(pref);

    if (igraph_vector_size(types) != nodes) {
        IGRAPH_ERRORF("Length of types vector (%ld) must match number of nodes (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, (long) igraph_vector_size(types), nodes);
    }

    if (nodes == 0) {
        igraph_empty(graph, 0, directed);
        return IGRAPH_SUCCESS;
    }

    /* the case of zero-length type vector is caught above, safe to call vector_min here */
    if (igraph_vector_min(types) < 0) {
        IGRAPH_ERRORF("Types should be non-negative, but found %g.",
                      IGRAPH_EINVAL, igraph_vector_min(types));
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    IGRAPH_VECTOR_INIT_FINALLY(&cumsum, 2);
    IGRAPH_CHECK(igraph_vector_reserve(&cumsum, nodes + 1));
    IGRAPH_CHECK(igraph_vector_reserve(&edges, nodes * edges_per_step));

    /* first node */
    VECTOR(cumsum)[0] = 0;
    type = (long int) VECTOR(*types)[0];
    if (type >= pref_len) {
        goto err_pref_too_short;
    }
    nnval = VECTOR(*pref)[type];
    if (nnval < 0) {
        goto err_pref_neg;
    }
    sum = VECTOR(cumsum)[1] = nnval;

    RNG_BEGIN();

    for (i = 1; i < nodes; i++) {
        for (j = 0; j < edges_per_step; j++) {
            long int to;
            if (sum > 0) {
                igraph_vector_binsearch(&cumsum, RNG_UNIF(0, sum), &to);
            } else {
                to = i + 1;
            }
            igraph_vector_push_back(&edges, i);
            igraph_vector_push_back(&edges, to - 1);
        }
        type = (long int) VECTOR(*types)[i];
        if (type >= pref_len) {
            goto err_pref_too_short;
        }
        nnval = VECTOR(*pref)[type];
        if (nnval < 0) {
            goto err_pref_neg;
        }
        sum += nnval;
        igraph_vector_push_back(&cumsum, sum);
    }

    RNG_END();

    igraph_vector_destroy(&cumsum);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;

err_pref_too_short:
    IGRAPH_ERRORF("Preference vector should have length at least %ld with the given types.", IGRAPH_EINVAL,
                  (long) igraph_vector_max(types) + 1);

err_pref_neg:
    IGRAPH_ERRORF("Preferences should be non-negative, but found %g.", IGRAPH_EINVAL,
                  igraph_vector_min(pref));
}

static void igraph_i_citing_cited_type_game_free(igraph_i_citing_cited_type_game_struct_t *s) {
    long int i;
    if (!s->sumtrees) {
        return;
    }
    for (i = 0; i < s->no; i++) {
        igraph_psumtree_destroy(&s->sumtrees[i]);
    }
    igraph_free(s->sumtrees);
}

/**
 * \function igraph_citing_cited_type_game
 * \brief Simulates a citation network based on vertex types.
 *
 * This game is similar to \ref igraph_cited_type_game() but here the
 * category of the citing vertex is also considered.
 *
 * 
 * An evolving citation network is modeled here, a single vertex and
 * its \p edges_per_step citation are added in each time step. The
 * odds the a given vertex is cited by the new vertex depends on the
 * category of both the citing and the cited vertex and is given in
 * the \p pref matrix. The categories of the citing vertex correspond
 * to the rows, the categories of the cited vertex to the columns of
 * this matrix. I.e. the element in row \c i and column \c j gives the
 * probability that a \c j vertex is cited, if the category of the
 * citing vertex is \c i.
 *
 * 
 * Note that this function might generate networks with multiple edges
 * if \p edges_per_step is greater than one. You might want to call
 * \ref igraph_simplify() on the result to remove multiple edges.
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the network.
 * \param types A numeric matrix of length \p nodes, containing the
 *    categories of the vertices. The categories are numbered from
 *    zero.
 * \param pref The preference matrix, a square matrix is required,
 *     both the number of rows and columns should be the maximum
 *     element in \p types plus one (types are numbered from zero).
 * \param directed Logical constant, whether to create a directed
 *     network.
 * \return Error code.
 *
 * Time complexity: O((|V|+|E|)log|V|), |V| and |E| are number of
 * vertices and edges, respectively.
 */

int igraph_citing_cited_type_game(igraph_t *graph, igraph_integer_t nodes,
                                  const igraph_vector_t *types,
                                  const igraph_matrix_t *pref,
                                  igraph_integer_t edges_per_step,
                                  igraph_bool_t directed) {

    igraph_vector_t edges;
    igraph_i_citing_cited_type_game_struct_t str = { 0, NULL };
    igraph_psumtree_t *sumtrees;
    igraph_vector_t sums;
    long int no_of_types;
    long int i, j;

    if (igraph_vector_size(types) != nodes) {
        IGRAPH_ERRORF("Length of types vector (%ld) not equal to number"
                      " of nodes (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_size(types), nodes);
    }

    /* avoid calling vector_max on empty vector */
    no_of_types = nodes == 0 ? 0 : igraph_vector_max(types) + 1;

    if (igraph_matrix_ncol(pref) != no_of_types) {
        IGRAPH_ERRORF("Number of preference matrix columns (%ld) not "
                      "equal to number of types (%ld).",
                      IGRAPH_EINVAL,
                      igraph_matrix_ncol(pref),
                      no_of_types);
    }
    if (igraph_matrix_nrow(pref) != no_of_types) {
        IGRAPH_ERRORF("Number of preference matrix rows (%ld) not "
                      "equal to number of types (%ld).",
                      IGRAPH_EINVAL,
                      igraph_matrix_nrow(pref),
                      no_of_types);
    }

    /* return an empty graph if nodes is zero */
    if (nodes == 0) {
        return igraph_empty(graph, 0, directed);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    str.sumtrees = sumtrees = IGRAPH_CALLOC(no_of_types, igraph_psumtree_t);
    if (!sumtrees) {
        IGRAPH_ERROR("Citing-cited type game failed.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_i_citing_cited_type_game_free, &str);

    for (i = 0; i < no_of_types; i++) {
        IGRAPH_CHECK(igraph_psumtree_init(&sumtrees[i], nodes));
        str.no++;
    }
    IGRAPH_VECTOR_INIT_FINALLY(&sums, no_of_types);

    IGRAPH_CHECK(igraph_vector_reserve(&edges, nodes * edges_per_step));

    /* First node */
    for (i = 0; i < no_of_types; i++) {
        long int type = (long int) VECTOR(*types)[0];
        if ( MATRIX(*pref, i, type) < 0) {
            IGRAPH_ERRORF("Preference matrix contains negative entry: %g.", IGRAPH_EINVAL, MATRIX(*pref, i, type));
        }
        IGRAPH_CHECK(igraph_psumtree_update(&sumtrees[i], 0, MATRIX(*pref, i, type)));
        VECTOR(sums)[i] = MATRIX(*pref, i, type);
    }

    RNG_BEGIN();

    for (i = 1; i < nodes; i++) {
        long int type = (long int) VECTOR(*types)[i];
        igraph_real_t sum = VECTOR(sums)[type];
        for (j = 0; j < edges_per_step; j++) {
            long int to;
            igraph_psumtree_search(&sumtrees[type], &to, RNG_UNIF(0, sum));
            igraph_vector_push_back(&edges, i);
            igraph_vector_push_back(&edges, to);
        }

        /* add i */
        for (j = 0; j < no_of_types; j++) {
            if ( MATRIX(*pref, j, type) < 0) {
                IGRAPH_ERRORF("Preference matrix contains negative entry: %g.", IGRAPH_EINVAL, MATRIX(*pref, j, type));
            }
            IGRAPH_CHECK(igraph_psumtree_update(&sumtrees[j], i, MATRIX(*pref, j,  type)));
            VECTOR(sums)[j] += MATRIX(*pref, j, type);
        }
    }

    RNG_END();

    igraph_i_citing_cited_type_game_free(&str);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_create(graph, &edges, nodes, directed);
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&sums);
    IGRAPH_FINALLY_CLEAN(2);
    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/correlated.c0000644000175100001710000002400300000000000024024 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_conversion.h"
#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_random.h"

/**
 * \function igraph_correlated_game
 * \brief Generates a random graph correlated to an existing graph.
 *
 * Sample a new graph by perturbing the adjacency matrix of a
 * given graph and shuffling its vertices.
 *
 * \param old_graph The original graph.
 * \param new_graph The new graph will be stored here.
 * \param corr A scalar in the unit interval, the target Pearson
 *        correlation between the adjacency matrices of the original the
 *        generated graph (the adjacency matrix being used as a vector).
 * \param p A numeric scalar, the probability of an edge between two
 *        vertices, it must in the open (0,1) interval.
 * \param permutation A permutation to apply to the vertices of the
 *        generated graph. It can also be a null pointer, in which case
 *        the vertices will not be permuted.
 * \return Error code
 *
 * \sa \ref igraph_correlated_pair_game() for generating a pair
 * of correlated random graphs in one go.
 */
int igraph_correlated_game(const igraph_t *old_graph, igraph_t *new_graph,
                           igraph_real_t corr, igraph_real_t p,
                           const igraph_vector_t *permutation) {

    int no_of_nodes = igraph_vcount(old_graph);
    int no_of_edges = igraph_ecount(old_graph);
    igraph_bool_t directed = igraph_is_directed(old_graph);
    igraph_real_t no_of_all = directed ? no_of_nodes * (no_of_nodes - 1) :
                              no_of_nodes * (no_of_nodes - 1) / 2;
    igraph_real_t no_of_missing = no_of_all - no_of_edges;
    igraph_real_t q = p + corr * (1 - p);
    igraph_real_t p_del = 1 - q;
    igraph_real_t p_add = ((1 - q) * (p / (1 - p)));
    igraph_vector_t add, delete, edges, newedges;
    igraph_real_t last;
    int p_e = 0, p_a = 0, p_d = 0, no_add, no_del;
    igraph_real_t inf = IGRAPH_INFINITY;
    igraph_real_t next_e, next_a, next_d;
    int i;

    if (corr < -1 || corr > 1) {
        IGRAPH_ERROR("Correlation must be in [-1,1] in correlated "
                     "Erdos-Renyi game", IGRAPH_EINVAL);
    }
    if (p <= 0 || p >= 1) {
        IGRAPH_ERROR("Edge probability must be in (0,1) in correlated "
                     "Erdos-Renyi game", IGRAPH_EINVAL);
    }
    if (permutation) {
        if (igraph_vector_size(permutation) != no_of_nodes) {
            IGRAPH_ERROR("Invalid permutation length in correlated Erdos-Renyi game",
                         IGRAPH_EINVAL);
        }
    }

    /* Special cases */

    if (corr == 0) {
        return igraph_erdos_renyi_game(new_graph, IGRAPH_ERDOS_RENYI_GNP,
                                       no_of_nodes, p, directed,
                                       IGRAPH_NO_LOOPS);
    }
    if (corr == 1) {
        /* We don't copy, because we don't need the attributes.... */
        IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
        IGRAPH_CHECK(igraph_get_edgelist(old_graph, &edges, /* bycol= */ 0));
        if (permutation) {
            int newec = igraph_vector_size(&edges);
            for (i = 0; i < newec; i++) {
                int tmp = VECTOR(edges)[i];
                VECTOR(edges)[i] = VECTOR(*permutation)[tmp];
            }
        }
        IGRAPH_CHECK(igraph_create(new_graph, &edges, no_of_nodes, directed));
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&newedges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&add, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&delete, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    IGRAPH_CHECK(igraph_get_edgelist(old_graph, &edges, /* bycol= */ 0));

    RNG_BEGIN();

    if (p_del > 0) {
        last = RNG_GEOM(p_del);
        while (last < no_of_edges) {
            IGRAPH_CHECK(igraph_vector_push_back(&delete, last));
            last += RNG_GEOM(p_del);
            last += 1;
        }
    }
    no_del = igraph_vector_size(&delete);

    if (p_add > 0) {
        last = RNG_GEOM(p_add);
        while (last < no_of_missing) {
            IGRAPH_CHECK(igraph_vector_push_back(&add, last));
            last += RNG_GEOM(p_add);
            last += 1;
        }
    }
    no_add = igraph_vector_size(&add);

    RNG_END();

    IGRAPH_CHECK(igraph_get_edgelist(old_graph, &edges, /* bycol= */ 0));

    /* Now we are merging the original edges, the edges that are removed,
       and the new edges. We have the following pointers:
       - p_a: the next edge to add
       - p_d: the next edge to delete
       - p_e: the next original edge
       - next_e: the code of the next edge in 'edges'
       - next_a: the code of the next edge to add
       - next_d: the code of the next edge to delete */

#define D_CODE(f,t) (((t)==no_of_nodes-1 ? f : t) * no_of_nodes + (f))
#define U_CODE(f,t) ((t) * ((t)-1) / 2 + (f))
#define CODE(f,t) (directed ? D_CODE(f,t) : U_CODE(f,t))
#define CODEE() (CODE(VECTOR(edges)[2*p_e], VECTOR(edges)[2*p_e+1]))

    /* First we (re)code the edges to delete */

    for (i = 0; i < no_del; i++) {
        int td = VECTOR(delete)[i];
        int from = VECTOR(edges)[2 * td];
        int to = VECTOR(edges)[2 * td + 1];
        VECTOR(delete)[i] = CODE(from, to);
    }

    IGRAPH_CHECK(igraph_vector_reserve(&newedges,
                                       (no_of_edges - no_del + no_add) * 2));

    /* Now we can do the merge. Additional edges are tricky, because
       the code must be shifted by the edges in the original graph. */

#define UPD_E()                             \
    { if (p_e < no_of_edges) { next_e=CODEE(); } else { next_e = inf; } }
#define UPD_A()                             \
{ if (p_a < no_add) { \
            next_a = VECTOR(add)[p_a] + p_e; } else { next_a = inf; } }
#define UPD_D()                             \
{ if (p_d < no_del) { \
            next_d = VECTOR(delete)[p_d]; } else { next_d = inf; } }

    UPD_E(); UPD_A(); UPD_D();

    while (next_e != inf || next_a != inf || next_d != inf) {
        if (next_e <= next_a && next_e < next_d) {

            /* keep an edge */
            IGRAPH_CHECK(igraph_vector_push_back(&newedges, VECTOR(edges)[2 * p_e]));
            IGRAPH_CHECK(igraph_vector_push_back(&newedges, VECTOR(edges)[2 * p_e + 1]));
            p_e ++; UPD_E(); UPD_A()

        } else if (next_e <= next_a && next_e == next_d) {

            /* delete an edge */
            p_e ++; UPD_E(); UPD_A();
            p_d++; UPD_D();

        } else {

            /* add an edge */
            int to, from;
            if (directed) {
                to = (int) floor(next_a / no_of_nodes);
                from = (int) (next_a - ((igraph_real_t)to) * no_of_nodes);
                if (from == to) {
                    to = no_of_nodes - 1;
                }
            } else {
                to = (int) floor((sqrt(8 * next_a + 1) + 1) / 2);
                from = (int) (next_a - (((igraph_real_t)to) * (to - 1)) / 2);
            }
            IGRAPH_CHECK(igraph_vector_push_back(&newedges, from));
            IGRAPH_CHECK(igraph_vector_push_back(&newedges, to));
            p_a++; UPD_A();

        }
    }

    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&add);
    igraph_vector_destroy(&delete);
    IGRAPH_FINALLY_CLEAN(3);

    if (permutation) {
        int newec = igraph_vector_size(&newedges);
        for (i = 0; i < newec; i++) {
            int tmp = VECTOR(newedges)[i];
            VECTOR(newedges)[i] = VECTOR(*permutation)[tmp];
        }
    }

    IGRAPH_CHECK(igraph_create(new_graph, &newedges, no_of_nodes, directed));

    igraph_vector_destroy(&newedges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

#undef D_CODE
#undef U_CODE
#undef CODE
#undef CODEE
#undef UPD_E
#undef UPD_A
#undef UPD_D

/**
 * \function igraph_correlated_pair_game
 * \brief Generates pairs of correlated random graphs.
 *
 * Sample two random graphs, with given correlation.
 *
 * \param graph1 The first graph will be stored here.
 * \param graph2 The second graph will be stored here.
 * \param n The number of vertices in both graphs.
 * \param corr A scalar in the unit interval, the target Pearson
 *        correlation between the adjacency matrices of the original the
 *        generated graph (the adjacency matrix being used as a vector).
 * \param p A numeric scalar, the probability of an edge between two
 *        vertices, it must in the open (0,1) interval.
 * \param directed Whether to generate directed graphs.
 * \param permutation A permutation to apply to the vertices of the
 *        second graph. It can also be a null pointer, in which case
 *        the vertices will not be permuted.
 * \return Error code
 *
 * \sa \ref igraph_correlated_game() for generating a correlated pair
 * to a given graph.
 */
int igraph_correlated_pair_game(igraph_t *graph1, igraph_t *graph2,
                                igraph_integer_t n, igraph_real_t corr, igraph_real_t p,
                                igraph_bool_t directed,
                                const igraph_vector_t *permutation) {

    IGRAPH_CHECK(igraph_erdos_renyi_game(graph1, IGRAPH_ERDOS_RENYI_GNP, n, p,
                                         directed, IGRAPH_NO_LOOPS));
    IGRAPH_CHECK(igraph_correlated_game(graph1, graph2, corr, p, permutation));
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence.c0000644000175100001710000006745500000000000025045 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_adjlist.h"
#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_graphicality.h"
#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_vector_ptr.h"

#include "core/interruption.h"
#include "core/set.h"

static int igraph_i_degree_sequence_game_simple(igraph_t *graph,
                                       const igraph_vector_t *out_seq,
                                       const igraph_vector_t *in_seq) {

    long int outsum = 0, insum = 0;
    igraph_bool_t directed = (in_seq != 0 && igraph_vector_size(in_seq) != 0);
    igraph_bool_t degseq_ok;
    long int no_of_nodes, no_of_edges;
    long int *bag1 = 0, *bag2 = 0;
    long int bagp1 = 0, bagp2 = 0;
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int i, j;

    IGRAPH_CHECK(igraph_is_graphical(out_seq, in_seq, IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW, °seq_ok));
    if (!degseq_ok) {
        IGRAPH_ERROR(in_seq ? "No directed graph can realize the given degree sequences" :
                     "No undirected graph can realize the given degree sequence", IGRAPH_EINVAL);
    }

    outsum = (long int) igraph_vector_sum(out_seq);
    if (directed) {
        insum = (long int) igraph_vector_sum(in_seq);
    }

    no_of_nodes = igraph_vector_size(out_seq);
    no_of_edges = directed ? outsum : outsum / 2;

    bag1 = IGRAPH_CALLOC(outsum, long int);
    if (bag1 == 0) {
        IGRAPH_ERROR("degree sequence game (simple)", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, bag1);

    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j < VECTOR(*out_seq)[i]; j++) {
            bag1[bagp1++] = i;
        }
    }
    if (directed) {
        bag2 = IGRAPH_CALLOC(insum, long int);
        if (bag2 == 0) {
            IGRAPH_ERROR("degree sequence game (simple)", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, bag2);
        for (i = 0; i < no_of_nodes; i++) {
            for (j = 0; j < VECTOR(*in_seq)[i]; j++) {
                bag2[bagp2++] = i;
            }
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    RNG_BEGIN();

    if (directed) {
        for (i = 0; i < no_of_edges; i++) {
            long int from = RNG_INTEGER(0, bagp1 - 1);
            long int to = RNG_INTEGER(0, bagp2 - 1);
            igraph_vector_push_back(&edges, bag1[from]); /* safe, already reserved */
            igraph_vector_push_back(&edges, bag2[to]);   /* ditto */
            bag1[from] = bag1[bagp1 - 1];
            bag2[to] = bag2[bagp2 - 1];
            bagp1--; bagp2--;
        }
    } else {
        for (i = 0; i < no_of_edges; i++) {
            long int from = RNG_INTEGER(0, bagp1 - 1);
            long int to;
            igraph_vector_push_back(&edges, bag1[from]); /* safe, already reserved */
            bag1[from] = bag1[bagp1 - 1];
            bagp1--;
            to = RNG_INTEGER(0, bagp1 - 1);
            igraph_vector_push_back(&edges, bag1[to]);   /* ditto */
            bag1[to] = bag1[bagp1 - 1];
            bagp1--;
        }
    }

    RNG_END();

    IGRAPH_FREE(bag1);
    IGRAPH_FINALLY_CLEAN(1);
    if (directed) {
        IGRAPH_FREE(bag2);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_degree_sequence_game_no_multiple_undirected(
    igraph_t *graph, const igraph_vector_t *seq) {

    igraph_vector_t stubs = IGRAPH_VECTOR_NULL;
    igraph_vector_int_t *neis;
    igraph_vector_t residual_degrees = IGRAPH_VECTOR_NULL;
    igraph_set_t incomplete_vertices;
    igraph_adjlist_t al;
    igraph_bool_t finished, failed;
    igraph_integer_t from, to, dummy;
    long int i, j, k;
    long int no_of_nodes, outsum = 0;
    igraph_bool_t degseq_ok;

    IGRAPH_CHECK(igraph_is_graphical(seq, 0, IGRAPH_SIMPLE_SW, °seq_ok));
    if (!degseq_ok) {
        IGRAPH_ERROR("No simple undirected graph can realize the given degree sequence",
                     IGRAPH_EINVAL);
    }

    outsum = (long int) igraph_vector_sum(seq);
    no_of_nodes = igraph_vector_size(seq);

    /* Allocate required data structures */
    IGRAPH_CHECK(igraph_adjlist_init_empty(&al, (igraph_integer_t) no_of_nodes));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &al);
    IGRAPH_VECTOR_INIT_FINALLY(&stubs, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&stubs, outsum));
    IGRAPH_VECTOR_INIT_FINALLY(&residual_degrees, no_of_nodes);
    IGRAPH_CHECK(igraph_set_init(&incomplete_vertices, 0));
    IGRAPH_FINALLY(igraph_set_destroy, &incomplete_vertices);

    /* Start the RNG */
    RNG_BEGIN();

    /* Outer loop; this will try to construct a graph several times from scratch
     * until it finally succeeds. */
    finished = 0;
    while (!finished) {
        IGRAPH_ALLOW_INTERRUPTION();

        /* Be optimistic :) */
        failed = 0;

        /* Clear the adjacency list to get rid of the previous attempt (if any) */
        igraph_adjlist_clear(&al);

        /* Initialize the residual degrees from the degree sequence */
        IGRAPH_CHECK(igraph_vector_update(&residual_degrees, seq));

        /* While there are some unconnected stubs left... */
        while (!finished && !failed) {
            /* Construct the initial stub vector */
            igraph_vector_clear(&stubs);
            for (i = 0; i < no_of_nodes; i++) {
                for (j = 0; j < VECTOR(residual_degrees)[i]; j++) {
                    igraph_vector_push_back(&stubs, i);
                }
            }

            /* Clear the skipped stub counters and the set of incomplete vertices */
            igraph_vector_null(&residual_degrees);
            igraph_set_clear(&incomplete_vertices);

            /* Shuffle the stubs in-place */
            igraph_vector_shuffle(&stubs);

            /* Connect the stubs where possible */
            k = igraph_vector_size(&stubs);
            for (i = 0; i < k; ) {
                from = (igraph_integer_t) VECTOR(stubs)[i++];
                to = (igraph_integer_t) VECTOR(stubs)[i++];

                if (from > to) {
                    dummy = from; from = to; to = dummy;
                }

                neis = igraph_adjlist_get(&al, from);
                if (from == to || igraph_vector_int_binsearch(neis, to, &j)) {
                    /* Edge exists already */
                    VECTOR(residual_degrees)[from]++;
                    VECTOR(residual_degrees)[to]++;
                    IGRAPH_CHECK(igraph_set_add(&incomplete_vertices, from));
                    IGRAPH_CHECK(igraph_set_add(&incomplete_vertices, to));
                } else {
                    /* Insert the edge */
                    IGRAPH_CHECK(igraph_vector_int_insert(neis, j, to));
                }
            }

            finished = igraph_set_empty(&incomplete_vertices);

            if (!finished) {
                /* We are not done yet; check if the remaining stubs are feasible. This
                 * is done by enumerating all possible pairs and checking whether at
                 * least one feasible pair is found. */
                i = 0;
                failed = 1;
                while (failed && igraph_set_iterate(&incomplete_vertices, &i, &from)) {
                    j = 0;
                    while (igraph_set_iterate(&incomplete_vertices, &j, &to)) {
                        if (from == to) {
                            /* This is used to ensure that each pair is checked once only */
                            break;
                        }
                        if (from > to) {
                            dummy = from; from = to; to = dummy;
                        }
                        neis = igraph_adjlist_get(&al, from);
                        if (!igraph_vector_int_binsearch(neis, to, 0)) {
                            /* Found a suitable pair, so we can continue */
                            failed = 0;
                            break;
                        }
                    }
                }
            }
        }
    }

    /* Finish the RNG */
    RNG_END();

    /* Clean up */
    igraph_set_destroy(&incomplete_vertices);
    igraph_vector_destroy(&residual_degrees);
    igraph_vector_destroy(&stubs);
    IGRAPH_FINALLY_CLEAN(3);

    /* Create the graph. We cannot use IGRAPH_ALL here for undirected graphs
     * because we did not add edges in both directions in the adjacency list.
     * We will use igraph_to_undirected in an extra step. */
    IGRAPH_CHECK(igraph_adjlist(graph, &al, IGRAPH_OUT, 1));
    IGRAPH_CHECK(igraph_to_undirected(graph, IGRAPH_TO_UNDIRECTED_EACH, 0));

    /* Clear the adjacency list */
    igraph_adjlist_destroy(&al);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

static int igraph_i_degree_sequence_game_no_multiple_directed(igraph_t *graph,
        const igraph_vector_t *out_seq, const igraph_vector_t *in_seq) {
    igraph_adjlist_t al;
    igraph_bool_t deg_seq_ok, failed, finished;
    igraph_vector_t in_stubs = IGRAPH_VECTOR_NULL;
    igraph_vector_t out_stubs = IGRAPH_VECTOR_NULL;
    igraph_vector_int_t *neis;
    igraph_vector_t residual_in_degrees = IGRAPH_VECTOR_NULL;
    igraph_vector_t residual_out_degrees = IGRAPH_VECTOR_NULL;
    igraph_set_t incomplete_in_vertices;
    igraph_set_t incomplete_out_vertices;
    igraph_integer_t from, to;
    long int i, j, k;
    long int no_of_nodes, outsum;

    IGRAPH_CHECK(igraph_is_graphical(out_seq, in_seq, IGRAPH_SIMPLE_SW, °_seq_ok));
    if (!deg_seq_ok) {
        IGRAPH_ERROR("No simple directed graph can realize the given degree sequence",
                     IGRAPH_EINVAL);
    }

    outsum = (long int) igraph_vector_sum(out_seq);
    no_of_nodes = igraph_vector_size(out_seq);

    /* Allocate required data structures */
    IGRAPH_CHECK(igraph_adjlist_init_empty(&al, (igraph_integer_t) no_of_nodes));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &al);
    IGRAPH_VECTOR_INIT_FINALLY(&out_stubs, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&out_stubs, outsum));
    IGRAPH_VECTOR_INIT_FINALLY(&in_stubs, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&in_stubs, outsum));
    IGRAPH_VECTOR_INIT_FINALLY(&residual_out_degrees, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&residual_in_degrees, no_of_nodes);
    IGRAPH_CHECK(igraph_set_init(&incomplete_out_vertices, 0));
    IGRAPH_FINALLY(igraph_set_destroy, &incomplete_out_vertices);
    IGRAPH_CHECK(igraph_set_init(&incomplete_in_vertices, 0));
    IGRAPH_FINALLY(igraph_set_destroy, &incomplete_in_vertices);

    /* Start the RNG */
    RNG_BEGIN();

    /* Outer loop; this will try to construct a graph several times from scratch
     * until it finally succeeds. */
    finished = 0;
    while (!finished) {
        IGRAPH_ALLOW_INTERRUPTION();

        /* Be optimistic :) */
        failed = 0;

        /* Clear the adjacency list to get rid of the previous attempt (if any) */
        igraph_adjlist_clear(&al);

        /* Initialize the residual degrees from the degree sequences */
        IGRAPH_CHECK(igraph_vector_update(&residual_out_degrees, out_seq));
        IGRAPH_CHECK(igraph_vector_update(&residual_in_degrees, in_seq));

        /* While there are some unconnected stubs left... */
        while (!finished && !failed) {
            /* Construct the initial stub vectors */
            igraph_vector_clear(&out_stubs);
            igraph_vector_clear(&in_stubs);
            for (i = 0; i < no_of_nodes; i++) {
                for (j = 0; j < VECTOR(residual_out_degrees)[i]; j++) {
                    igraph_vector_push_back(&out_stubs, i);
                }
                for (j = 0; j < VECTOR(residual_in_degrees)[i]; j++) {
                    igraph_vector_push_back(&in_stubs, i);
                }
            }

            /* Clear the skipped stub counters and the set of incomplete vertices */
            igraph_vector_null(&residual_out_degrees);
            igraph_vector_null(&residual_in_degrees);
            igraph_set_clear(&incomplete_out_vertices);
            igraph_set_clear(&incomplete_in_vertices);

            /* Shuffle the out-stubs in-place */
            igraph_vector_shuffle(&out_stubs);

            /* Connect the stubs where possible */
            k = igraph_vector_size(&out_stubs);
            for (i = 0; i < k; i++) {
                from = (igraph_integer_t) VECTOR(out_stubs)[i];
                to = (igraph_integer_t) VECTOR(in_stubs)[i];

                neis = igraph_adjlist_get(&al, from);
                if (from == to || igraph_vector_int_binsearch(neis, to, &j)) {
                    /* Edge exists already */
                    VECTOR(residual_out_degrees)[from]++;
                    VECTOR(residual_in_degrees)[to]++;
                    IGRAPH_CHECK(igraph_set_add(&incomplete_out_vertices, from));
                    IGRAPH_CHECK(igraph_set_add(&incomplete_in_vertices, to));
                } else {
                    /* Insert the edge */
                    IGRAPH_CHECK(igraph_vector_int_insert(neis, j, to));
                }
            }

            /* Are we finished? */
            finished = igraph_set_empty(&incomplete_out_vertices);

            if (!finished) {
                /* We are not done yet; check if the remaining stubs are feasible. This
                 * is done by enumerating all possible pairs and checking whether at
                 * least one feasible pair is found. */
                i = 0;
                failed = 1;
                while (failed && igraph_set_iterate(&incomplete_out_vertices, &i, &from)) {
                    j = 0;
                    while (igraph_set_iterate(&incomplete_in_vertices, &j, &to)) {
                        neis = igraph_adjlist_get(&al, from);
                        if (from != to && !igraph_vector_int_binsearch(neis, to, 0)) {
                            /* Found a suitable pair, so we can continue */
                            failed = 0;
                            break;
                        }
                    }
                }
            }
        }
    }

    /* Finish the RNG */
    RNG_END();

    /* Clean up */
    igraph_set_destroy(&incomplete_in_vertices);
    igraph_set_destroy(&incomplete_out_vertices);
    igraph_vector_destroy(&residual_in_degrees);
    igraph_vector_destroy(&residual_out_degrees);
    igraph_vector_destroy(&in_stubs);
    igraph_vector_destroy(&out_stubs);
    IGRAPH_FINALLY_CLEAN(6);

    /* Create the graph */
    IGRAPH_CHECK(igraph_adjlist(graph, &al, IGRAPH_OUT, 1));

    /* Clear the adjacency list */
    igraph_adjlist_destroy(&al);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* swap two elements of a vector_int */
#define SWAP_INT_ELEM(vec, i, j) \
    { \
        igraph_integer_t temp; \
        temp = VECTOR(vec)[i]; \
        VECTOR(vec)[i] = VECTOR(vec)[j]; \
        VECTOR(vec)[j] = temp; \
    }

static int igraph_i_degree_sequence_game_no_multiple_undirected_uniform(igraph_t *graph, const igraph_vector_t *degseq) {
    igraph_vector_int_t stubs;
    igraph_vector_t edges;
    igraph_bool_t degseq_ok;
    igraph_vector_ptr_t adjlist;
    long i, j;
    long vcount, ecount, stub_count;

    IGRAPH_CHECK(igraph_is_graphical(degseq, NULL, IGRAPH_SIMPLE_SW, °seq_ok));
    if (!degseq_ok) {
        IGRAPH_ERROR("No simple undirected graph can realize the given degree sequence", IGRAPH_EINVAL);
    }

    stub_count = (long) igraph_vector_sum(degseq);
    ecount = stub_count / 2;
    vcount = igraph_vector_size(degseq);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&stubs, stub_count);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, stub_count);

    /* Fill stubs vector. */
    {
        long k = 0;
        for (i = 0; i < vcount; ++i) {
            long deg = (long) VECTOR(*degseq)[i];
            for (j = 0; j < deg; ++j) {
                VECTOR(stubs)[k++] = i;
            }
        }
    }

    /* Build an adjacency list in terms of sets; used to check for multi-edges. */
    IGRAPH_CHECK(igraph_vector_ptr_init(&adjlist, vcount));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&adjlist, igraph_set_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &adjlist);
    for (i = 0; i < vcount; ++i) {
        igraph_set_t *set = IGRAPH_CALLOC(1, igraph_set_t);
        if (! set) {
            IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_set_init(set, 0));
        VECTOR(adjlist)[i] = set;
        IGRAPH_CHECK(igraph_set_reserve(set, (long) VECTOR(*degseq)[i]));
    }

    RNG_BEGIN();

    for (;;) {
        igraph_bool_t success = 1;

        /* Shuffle stubs vector with Fisher-Yates and check for self-loops and multi-edges as we go. */
        for (i = 0; i < ecount; ++i) {
            long k, from, to;

            k = RNG_INTEGER(2*i, stub_count-1);
            SWAP_INT_ELEM(stubs, 2*i, k);

            k = RNG_INTEGER(2*i+1, stub_count-1);
            SWAP_INT_ELEM(stubs, 2*i+1, k);

            from = VECTOR(stubs)[2*i];
            to   = VECTOR(stubs)[2*i+1];

            /* self-loop, fail */
            if (from == to) {
                success = 0;
                break;
            }

            /* multi-edge, fail */
            if (igraph_set_contains((igraph_set_t *) VECTOR(adjlist)[to], from)) {
                success = 0;
                break;
            }

            /* sets are already reserved */
            igraph_set_add((igraph_set_t *) VECTOR(adjlist)[to], from);
            igraph_set_add((igraph_set_t *) VECTOR(adjlist)[from], to);

            /* register edge */
            VECTOR(edges)[2 * i]   = from;
            VECTOR(edges)[2 * i + 1] = to;
        }

        if (success) {
            break;
        }

        /* Clear adjacency list. */
        for (j = 0; j < vcount; ++j) {
            igraph_set_clear((igraph_set_t *) VECTOR(adjlist)[j]);
        }

        IGRAPH_ALLOW_INTERRUPTION();
    }

    RNG_END();

    igraph_vector_ptr_destroy_all(&adjlist);
    igraph_vector_int_destroy(&stubs);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(graph, &edges, vcount, /* directed = */ 0));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


static int igraph_i_degree_sequence_game_no_multiple_directed_uniform(
    igraph_t *graph, const igraph_vector_t *out_deg, const igraph_vector_t *in_deg) {
    igraph_vector_int_t out_stubs, in_stubs;
    igraph_vector_t edges;
    igraph_bool_t degseq_ok;
    igraph_vector_ptr_t adjlist;
    long i, j;
    long vcount, ecount;

    IGRAPH_CHECK(igraph_is_graphical(out_deg, in_deg, IGRAPH_SIMPLE_SW, °seq_ok));
    if (!degseq_ok) {
        IGRAPH_ERROR("No simple directed graph can realize the given degree sequence", IGRAPH_EINVAL);
    }

    ecount = (long) igraph_vector_sum(out_deg);
    vcount = igraph_vector_size(out_deg);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&out_stubs, ecount);
    IGRAPH_VECTOR_INT_INIT_FINALLY(&in_stubs, ecount);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * ecount);

    /* Fill in- and out-stubs vectors. */
    {
        long k = 0, l = 0;
        for (i = 0; i < vcount; ++i) {
            long dout, din;

            dout = (long) VECTOR(*out_deg)[i];
            for (j = 0; j < dout; ++j) {
                VECTOR(out_stubs)[k++] = i;
            }

            din  = (long) VECTOR(*in_deg)[i];
            for (j = 0; j < din; ++j) {
                VECTOR(in_stubs)[l++] = i;
            }
        }
    }

    /* Build an adjacency list in terms of sets; used to check for multi-edges. */
    IGRAPH_CHECK(igraph_vector_ptr_init(&adjlist, vcount));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&adjlist, igraph_set_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &adjlist);
    for (i = 0; i < vcount; ++i) {
        igraph_set_t *set = IGRAPH_CALLOC(1, igraph_set_t);
        if (! set) {
            IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_set_init(set, 0));
        VECTOR(adjlist)[i] = set;
        IGRAPH_CHECK(igraph_set_reserve(set, (long) VECTOR(*out_deg)[i]));
    }

    RNG_BEGIN();

    for (;;) {
        igraph_bool_t success = 1;

        /* Shuffle out-stubs vector with Fisher-Yates and check for self-loops and multi-edges as we go. */
        for (i = 0; i < ecount; ++i) {
            long k, from, to;
            igraph_set_t *set;

            k = RNG_INTEGER(i, ecount-1);
            SWAP_INT_ELEM(out_stubs, i, k);

            from = VECTOR(out_stubs)[i];
            to   = VECTOR(in_stubs)[i];

            /* self-loop, fail */
            if (to == from) {
                success = 0;
                break;
            }

            /* multi-edge, fail */
            set = (igraph_set_t *) VECTOR(adjlist)[from];
            if (igraph_set_contains(set, to)) {
                success = 0;
                break;
            }

            /* sets are already reserved */
            igraph_set_add(set, to);

            /* register edge */
            VECTOR(edges)[2 * i]   = from;
            VECTOR(edges)[2 * i + 1] = to;
        }

        if (success) {
            break;
        }

        /* Clear adjacency list. */
        for (j = 0; j < vcount; ++j) {
            igraph_set_clear((igraph_set_t *) VECTOR(adjlist)[j]);
        }

        IGRAPH_ALLOW_INTERRUPTION();
    }

    RNG_END();

    igraph_vector_ptr_destroy_all(&adjlist);
    igraph_vector_int_destroy(&out_stubs);
    igraph_vector_int_destroy(&in_stubs);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_CHECK(igraph_create(graph, &edges, vcount, /* directed = */ 1));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

#undef SWAP_INT_ELEM


/* This is in gengraph_mr-connected.cpp */

int igraph_degree_sequence_game_vl(igraph_t *graph,
                                   const igraph_vector_t *out_seq,
                                   const igraph_vector_t *in_seq);

/**
 * \ingroup generators
 * \function igraph_degree_sequence_game
 * \brief Generates a random graph with a given degree sequence.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param out_deg The degree sequence for an undirected graph (if
 *        \p in_seq is \c NULL or of length zero), or the out-degree
 *        sequence of a directed graph (if \p in_deq is not
 *        of length zero).
 * \param in_deg It is either a zero-length vector or
 *        \c NULL (if an undirected
 *        graph is generated), or the in-degree sequence.
 * \param method The method to generate the graph. Possible values:
 *        \clist
 *          \cli IGRAPH_DEGSEQ_SIMPLE
 *          This method implements the configuration model.
 *          For undirected graphs, it puts all vertex IDs in a bag
 *          such that the multiplicity of a vertex in the bag is the same as
 *          its degree. Then it draws pairs from the bag until the bag becomes
 *          empty. This method may generate both loop (self) edges and multiple
 *          edges. For directed graphs, the algorithm is basically the same,
 *          but two separate bags are used for the in- and out-degrees.
 *          Undirected graphs are generated with probability proportional to
 *          (\prod_{i<j} A_{ij} ! \prod_i A_{ii} !!)^{-1},
 *          where \c A denotes the adjacency matrix and !! denotes
 *          the double factorial. Here \c A is assumed to have twice the number of
 *          self-loops on its diagonal.
 *          The corresponding  expression for directed graphs is
 *          (\prod_{i,j} A_{ij}!)^{-1}.
 *          Thus the probability of all simple graphs (which only have 0s and 1s
 *          in the adjacency matrix) is the same, while that of
 *          non-simple ones depends on their edge and self-loop multiplicities.
 *          \cli IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE
 *          This method generates simple graphs.
 *          It is similar to \c IGRAPH_DEGSEQ_SIMPLE
 *          but tries to avoid multiple and loop edges and restarts the
 *          generation from scratch if it gets stuck. It can generate all simple
 *          realizations of a degree sequence, but it is not guaranteed
 *          to sample them uniformly. This method is relatively fast and it will
 *          eventually succeed if the provided degree sequence is graphical,
 *          but there is no upper bound on the number of iterations.
 *          \cli IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM
 *          This method is identical to \c IGRAPH_DEGSEQ_SIMPLE, but if the
 *          generated graph is not simple, it rejects it and re-starts the
 *          generation. It generates all simple graphs with the same probability.
 *          \cli IGRAPH_DEGSEQ_VL
 *          This method samples undirected \em connected graphs approximately
 *          uniformly. It is a Monte Carlo method based on degree-preserving
 *          edge swaps.
 *          This generator should be favoured if undirected and connected
 *          graphs are to be generated and execution time is not a concern.
 *          igraph uses the original implementation of Fabien Viger; for the algorithm,
 *          see https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html
 *          and the paper https://arxiv.org/abs/cs/0502085
 *        \endclist
 * \return Error code:
 *          \c IGRAPH_ENOMEM: there is not enough
 *           memory to perform the operation.
 *          \c IGRAPH_EINVAL: invalid method parameter, or
 *           invalid in- and/or out-degree vectors. The degree vectors
 *           should be non-negative, \p out_deg should sum
 *           up to an even integer for undirected graphs; the length
 *           and sum of \p out_deg and
 *           \p in_deg
 *           should match for directed graphs.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of edges
 *                  for \c IGRAPH_DEGSEQ_SIMPLE. The time complexity of the
 *                  other modes is not known.
 *
 * \sa \ref igraph_barabasi_game(), \ref igraph_erdos_renyi_game(),
 *     \ref igraph_is_graphical()
 *
 * \example examples/simple/igraph_degree_sequence_game.c
 */

int igraph_degree_sequence_game(igraph_t *graph, const igraph_vector_t *out_deg,
                                const igraph_vector_t *in_deg,
                                igraph_degseq_t method) {
    if (in_deg && igraph_vector_empty(in_deg) && !igraph_vector_empty(out_deg)) {
        in_deg = 0;
    }

    switch (method) {
    case IGRAPH_DEGSEQ_SIMPLE:
        return igraph_i_degree_sequence_game_simple(graph, out_deg, in_deg);

    case IGRAPH_DEGSEQ_VL:
        return igraph_degree_sequence_game_vl(graph, out_deg, in_deg);

    case IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE:
        if (in_deg == 0) {
            return igraph_i_degree_sequence_game_no_multiple_undirected(graph, out_deg);
        } else {
            return igraph_i_degree_sequence_game_no_multiple_directed(graph, out_deg, in_deg);
        }

    case IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM:
        if (in_deg == 0) {
            return igraph_i_degree_sequence_game_no_multiple_undirected_uniform(graph, out_deg);
        } else {
            return igraph_i_degree_sequence_game_no_multiple_directed_uniform(graph, out_deg, in_deg);
        }

    default:
        IGRAPH_ERROR("Invalid degree sequence game method", IGRAPH_EINVAL);
    }
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5071409
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/0000755000175100001710000000000000000000000025361 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_box_list.cpp0000644000175100001710000000467000000000000031572 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_box_list.h"
#include 

namespace gengraph {

void box_list::insert(int v) {
    int d = deg[v];
    if (d < 1) {
        return;
    }
    if (d > dmax) {
        dmax = d;
    }
    int yo = list[d - 1];
    list[d - 1] = v;
    prev[v] = -1;
    next[v] = yo;
    if (yo >= 0) {
        prev[yo] = v;
    }
}

void box_list::pop(int v) {
    int p = prev[v];
    int nxt = next[v];
    if (p < 0) {
        int d = deg[v];
        assert(list[d - 1] == v);
        list[d - 1] = nxt;
        if (d == dmax && nxt < 0) {
            do {
                dmax--;
            } while (dmax > 0 && list[dmax - 1] < 0);
        }
    } else {
        next[p] = nxt;
    }
    if (nxt >= 0) {
        prev[nxt] = p;
    }
}

box_list::box_list(int n0, int *deg0) : n(n0), deg(deg0) {
    next = new int[n];
    prev = new int[n];
    dmax = -1;
    int i;
    for (i = 0; i < n; i++) if (deg[i] > dmax) {
            dmax = deg[i];
        }
    list = new int[dmax];
    for (i = 0; i < dmax; i++) {
        list[i] = -1;
    }
    for (i = 0; i < n; i++) {
        insert(i);
    }
}

box_list::~box_list() {
    delete[] prev;
    delete[] next;
    delete[] list;
}

void box_list::pop_vertex(int v, int **neigh) {
    int k = deg[v];
    if (k < 1) {
        return;
    }
    pop(v);
    int *w = neigh[v];
    while (k--) {
        int v2 = *(w++);
        int *w2 = neigh[v2];
        while (*w2 != v) {
            w2++;
        }
        int *w3 = neigh[v2] + (deg[v2] - 1);
        assert(w2 <= w3);
        int tmp = *w3;
        *w3 = *w2;
        *w2 = tmp;
        pop(v2);
        deg[v2]--;
        insert(v2);
    }
}

} // namespace gengraph
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_box_list.h0000644000175100001710000000514200000000000031232 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
// This class allows to maintain a list of vertices,
// sorted by degree (largest degrees first)
// Operations allowed :
// - get the vertex having max degree -> Cost = O(1)
// - remove any vertex from the graph -> Cost = Sum(degrees of neighbours)
//                                       [ could be O(degree) if optimized ]

#ifndef _BOX_LIST_H
#define _BOX_LIST_H

namespace gengraph {

class box_list {

private:
    int n;     // INITIAL number of vertices
    int dmax;  // CURRENT Maximum degree
    int *deg;  // CURRENT Degrees (points directly to the deg[] of the graph

    // Vertices are grouped by degree: one double-chained lists for each degree
    int *list;        // list[d-1] is the head of list of vertices of degree d
    int *next;        // next[v]/prev[v] are the vertices next/previous to v
    int *prev;        //   in the list where v belongs
    void pop(int);    // pop(v) just removes v from its list
    void insert(int); // insert(v) insert v at the head of its list

public:

    // Ctor. Takes O(n) time.
    box_list(int n0, int *deg0);

    // Dtor
    ~box_list();

    // Self-explaining inline routines
    inline bool is_empty() {
        return dmax < 1;
    };
    inline int get_max()   {
        return list[dmax - 1];
    };
    inline int get_one()   {
        return list[0];
    };
    inline int get_min()   {
        int i = 0;
        while (list[i] < 0) {
            i++;
        }
        return list[i];
    };

    // Remove v from box_list
    // Also, semi-remove vertex v from graph: all neighbours of v will swap
    // their last neighbour wit hv, and then decrease their degree, so
    // that any arc w->v virtually disappear
    // Actually, adjacency lists are just permuted, and deg[] is changed
    void pop_vertex(int v, int **neigh);
};

} // namespace gengraph

#endif //_BOX_LIST_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_definitions.h0000644000175100001710000001104500000000000031721 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef DEFINITIONS_H
#define DEFINITIONS_H

#include 
#include 
#include 

#include "internal/hacks.h"

namespace gengraph {

// Max line size in files
#define FBUFF_SIZE 1000000

// disable lousy VC++ warnings
#ifdef _ATL_VER_
    #pragma warning(disable : 4127)
#endif //_ATL_VER_

// Verbose
#define VERBOSE_NONE 0
#define VERBOSE_SOME 1
#define VERBOSE_LOTS 2
int VERBOSE();
void SET_VERBOSE(int v);

// Random number generator
void my_srandom(int);
int my_random();
int my_binomial(double pp, int n);
double my_random01(); // (0,1]

#define MY_RAND_MAX 0x7FFFFFFF

// IPv4 address direct translation into 32-bit uint + special IP defs
typedef unsigned int ip_addr;
#define IP_NONE   0x7FFFFFFF
#define IP_STAR   0x00000000
#define IP_MYSELF 0x7F000001

//inline double round(double x) throw () { return (floor(0.5+x)); }

// Min & Max
#ifndef min
    #define defmin(type) inline type min(type a, type b) { return ab ? a : b; }
    defmax(int)
    defmax(double)
    defmax(unsigned long)
#endif //max

// Traceroute Sampling
#define MODE_USP 0
#define MODE_ASP 1
#define MODE_RSP 2

// Debug definitions
//#define PERFORMANCE_MONITOR
//#define OPT_ISOLATED

// Max Int
#ifndef MAX_INT
    #define MAX_INT 0x7FFFFFFF
#endif //MAX_INT

//Edge type
typedef struct {
    int from;
    int to;
} edge;

// Tag Int
#define TAG_INT 0x40000000

// Oldies ....
#define S_VECTOR_RAW

//*********************
// Routine definitions
//*********************

/* log(1+x)
inline double logp(double x) {
  if(fabs(x)<1e-6) return x+0.5*x*x+0.333333333333333*x*x*x;
  else return log(1.0+x);
}
*/


//Fast search or replace
inline int* fast_rpl(int *m, const int a, const int b) {
    while (*m != a) {
        m++;
    }
    *m = b;
    return m;
}
inline int* fast_search(int *m, const int size, const int a) {
    int *p = m + size;
    while (m != p--) if (*p == a) {
            return p;
        }
    return NULL;
}

// Lovely percentage print
// inline void print_percent(double yo, FILE *f = stderr) {
//   int arf = int(100.0*yo);
//   if(double(arf)>100.0*yo) arf--;
//   if(arf<100) fprintf(f," ");
//   if(arf<10) fprintf(f," ");
//   fprintf(f,"%d.%d%%",arf,int(1000.0*yo-double(10*arf)));
// }

// Skips non-numerical chars, then numerical chars, then non-numerical chars.
inline char skip_int(char* &c) {
    while (*c < '0' || *c > '9') {
        c++;
    }
    while (*c >= '0' && *c <= '9') {
        c++;
    }
    while (*c != 0 && (*c < '0' || *c > '9')) {
        c++;
    }
    return *c;
}

// distance+1 modulo 255 for breadth-first search
inline unsigned char next_dist(const unsigned char c) {
    return c == 255 ? 1 : c + 1;
}
inline unsigned char prev_dist(const unsigned char c) {
    return c == 1 ? 255 : c - 1;
}

// 1/(RANDMAX+1)
#define inv_RANDMAX (1.0/(1.0+double(MY_RAND_MAX)))

// random number in ]0,1[, _very_ accurate around 0
inline double random_float() {
    int r = my_random();
    double mul = inv_RANDMAX;
    while (r <= 0x7FFFFF) {
        r <<= 8;
        r += (my_random() & 0xFF);
        mul *= (1.0 / 256.0);
    }
    return double(r) * mul;
}

// Return true with probability p. Very accurate when p is small.
#define test_proba(p) (random_float()<(p))

// Random bit generator, sparwise.
static int _random_bits_stored = 0;
static int _random_bits = 0;

inline int random_bit() {
    int a = _random_bits;
    _random_bits = a >> 1;
    if (_random_bits_stored--) {
        return a & 0x1;
    }
    a = my_random();
    _random_bits = a >> 1;
    _random_bits_stored = 30;
    return a & 0x1;
}

// Hash Profiling (see hash.h)
void _hash_prof();

} // namespace gengraph

#endif //DEFINITIONS_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_degree_sequence.cpp0000644000175100001710000002675200000000000033077 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_definitions.h"
#include "gengraph_random.h"
#include "gengraph_powerlaw.h"
#include "gengraph_degree_sequence.h"
#include "gengraph_hash.h"

#include "igraph_statusbar.h"

#include 
#include 
#include 
#include 
#include 
#include 

// using namespace __gnu_cxx;
using namespace std;

namespace gengraph {

// shuffle an int[] randomly
void random_permute(int *a, int n);

// sort an array of positive integers in time & place O(n + max)
void cumul_sort(int *q, int n);


void degree_sequence::detach() {
    deg = NULL;
}

degree_sequence::~degree_sequence() {
    if (deg != NULL) {
        delete[] deg;
    }
    deg = NULL;
}

void degree_sequence::make_even(int mini, int maxi) {
    if (total % 2 == 0) {
        return;
    }
    if (maxi < 0) {
        maxi = 0x7FFFFFFF;
    }
    int i;
    for (i = 0; i < n; i++) {
        if (deg[i] > mini) {
            deg[i]--;
            total--;
            break;
        } else if (deg[i] < maxi) {
            deg[i]++;
            total++;
            break;
        }
    }
    if (i == n) {
        IGRAPH_WARNING("Warning: degree_sequence::make_even() forced one "
                       "degree to go over degmax");
        deg[0]++;
        total++;
    }
}

void degree_sequence::shuffle() {
    random_permute(deg, n);
}

void degree_sequence::sort() {
    cumul_sort(deg, n);
}

void degree_sequence::compute_total() {
    total = 0;
    for (int i = 0; i < n; i++) {
        total += deg[i];
    }
}

degree_sequence::
degree_sequence(int n0, int *degs) {
    deg = degs;
    n = n0;
    compute_total();
}

degree_sequence::
degree_sequence(const igraph_vector_t *out_seq) {
    n = igraph_vector_size(out_seq);
    deg = new int[n];
    for (long int i = 0; i < n; i++) {
        deg[i] = VECTOR(*out_seq)[i];
    }
    compute_total();
}

#ifndef FBUFF_SIZE
    #define FBUFF_SIZE 999
#endif //FBUFF_SIZE

// degree_sequence::degree_sequence(FILE *f, bool DISTRIB) {
//   n = 0;
//   total = 0;
//   char *buff = new char[FBUFF_SIZE];
//   char *c;
//   vector degree;
//   if(!DISTRIB) {
//     // Input is a 'raw' degree sequence d0 d1 d2 d3 ...
//     while(fgets(buff, FBUFF_SIZE, f)) {
//       int d = strtol(buff, &c, 10);
//       if(c == buff) continue;
//       degree.push_back(d);
//       total += d;
//     }
//     n = int(degree.size());
//     deg = new int[n];
//     int *yo = deg;
//     vector::iterator end = degree.end();
//     for(vector::iterator it=degree.begin(); it!=end; *(yo++) = *(it++));
//   }
//   else {
//     // Input is a degree distribution : d0 #(degree=d0), d1 #(degree=d1), ...
//     vector n_with_degree;
//     int line = 0;
//     int syntax  = 0;
//     int ignored = 0;
//     int first_syntax  = 0;
//     int first_ignored = 0;
//     while(fgets(buff, FBUFF_SIZE, f)) {
//       line++;
//       int d = strtol(buff, &c, 10);
//       if(c == buff) { ignored++; first_ignored = line; continue; }
//       char *cc;
//       int i = strtol(c, &cc, 10);
//       if(cc == c) { syntax++; first_syntax = line; continue; }
//       n += i;
//       total += i*d;
//       degree.push_back(d);
//       n_with_degree.push_back(i);
//       if( cc != c) {  syntax++; first_syntax = line; }
//     }
//     if(VERBOSE()) {
//       if(ignored > 0) fprintf(stderr,"Ignored %d lines (first was line #%d)\n", ignored, first_ignored);
//       if(syntax > 0) fprintf(stderr,"Found %d probable syntax errors (first was line #%d)\n", syntax, first_syntax);
//     }
//     deg = new int[n];
//     int *yo = deg;
//     vector::iterator it_n = n_with_degree.begin();
//     for(vector::iterator it = degree.begin(); it != degree.end(); it++)
//       for(int k = *(it_n++); k--; *yo++ = *it);
//   }
//   if(VERBOSE()) {
//     if(total % 2 != 0) fprintf(stderr,"Warning: degree sequence is odd\n");
//     fprintf(stderr,"Degree sequence created. N=%d, 2M=%d\n", n, total);
//   }
// }

// n vertices, exponent, min degree, max degree, average degree (optional, default is -1)
degree_sequence::
degree_sequence(int _n, double exp, int degmin, int degmax, double z) {

    n = _n;
    if (exp == 0.0) {
        // Binomial distribution
        if (z < 0) {
            throw std::invalid_argument(
                        "Fatal error in degree_sequence constructor: "
                        "positive average degree must be specified.");
        }
        if (degmax < 0) {
            degmax = n - 1;
        }
        total = int(floor(double(n) * z + 0.5));
        deg = new int[n];
        KW_RNG::RNG myrand;
        double p = (z - double(degmin)) / double(n);
        total = 0;
        for (int i = 0; i < n; i++) {
            do {
                deg[i] = 1 + myrand.binomial(p, n);
            } while (deg[i] > degmax);
            total += deg[i];
        }
    } else {
        // Power-law distribution
        igraph_status("Creating powerlaw sampler...", 0);
        powerlaw pw(exp, degmin, degmax);
        if (z == -1.0) {
            pw.init();
            igraph_statusf("done. Mean=%f\n", 0, pw.mean());
        } else {
            double offset = pw.init_to_mean(z);
            igraph_statusf("done. Offset=%f, Mean=%f\n", 0, offset, pw.mean());
        }

        deg = new int[n];
        total = 0;
        int i;

        igraph_statusf("Sampling %d random numbers...", 0, n);
        for (i = 0; i < n; i++) {
            deg[i] = pw.sample();
            total += deg[i];
        }

        igraph_status("done\nSimple statistics on degrees...", 0);
        int wanted_total = int(floor(z * n + 0.5));
        sort();
        igraph_statusf("done : Max=%d, Total=%d.\n", 0, deg[0], total);
        if (z != -1.0)  {
            igraph_statusf("Adjusting total to %d...", 0, wanted_total);
            int iterations = 0;

            while (total != wanted_total) {
                sort();
                for (i = 0; i < n && total > wanted_total; i++) {
                    total -= deg[i];
                    if (total + degmin <= wanted_total) {
                        deg[i] = wanted_total - total;
                    } else {
                        deg[i] = pw.sample();
                    }
                    total += deg[i];
                }
                iterations += i;
                for (i = n - 1; i > 0 && total < wanted_total; i--) {
                    total -= deg[i];
                    if (total + (deg[0] >> 1) >= wanted_total) {
                        deg[i] = wanted_total - total;
                    } else {
                        deg[i] = pw.sample();
                    }
                    total += deg[i];
                }
                iterations += n - 1 - i;
            }
            igraph_statusf("done(%d iterations).", 0, iterations);
            igraph_statusf("  Now, degmax = %d\n", 0, dmax());
        }

        shuffle();
    }
}

// void degree_sequence::print() {
//   for(int i=0; ideg[i]) dmin=deg[i];
//   int *dd = new int[dmax-dmin+1];
//   for(i=dmin; i<=dmax; i++) dd[i-dmin]=0;
//   if(VERBOSE()) fprintf(stderr,"Computing cumulative distribution...");
//   for(i=0; i0) printf("%d %d\n",i,dd[i-dmin]);
//   delete[] dd;
// }

bool degree_sequence::havelhakimi() {

    int i;
    int dm = dmax() + 1;
    // Sort vertices using basket-sort, in descending degrees
    int *nb = new int[dm];
    int *sorted = new int[n];
    // init basket
    for (i = 0; i < dm; i++) {
        nb[i] = 0;
    }
    // count basket
    for (i = 0; i < n; i++) {
        nb[deg[i]]++;
    }
    // cumul
    int c = 0;
    for (i = dm - 1; i >= 0; i--) {
        int t = nb[i];
        nb[i] = c;
        c += t;
    }
    // sort
    for (i = 0; i < n; i++) {
        sorted[nb[deg[i]]++] = i;
    }

// Binding process starts
    int first = 0;  // vertex with biggest residual degree
    int d = dm - 1; // maximum residual degree available

    for (c = total / 2; c > 0; ) {
        // We design by 'v' the vertex of highest degree (indexed by first)
        // look for current degree of v
        while (nb[d] <= first) {
            d--;
        }
        // store it in dv
        int dv = d;
        // bind it !
        c -= dv;
        int dc = d;         // residual degree of vertices we bind to
        int fc = ++first;   // position of the first vertex with degree dc

        while (dv > 0 && dc > 0) {
            int lc = nb[dc];
            if (lc != fc) {
                while (dv > 0 && lc > fc) {
                    // binds v with sorted[--lc]
                    dv--;
                    lc--;
                }
                fc = nb[dc];
                nb[dc] = lc;
            }
            dc--;
        }
        if (dv != 0) { // We couldn't bind entirely v
            delete[] nb;
            delete[] sorted;
            return false;
        }
    }
    delete[] nb;
    delete[] sorted;
    return true;
}

//*************************
// Subroutines definitions
//*************************

inline int int_adjust(double x) {
    return (int(floor(x + random_float())));
}

void random_permute(int *a, int n) {
    int j, tmp;
    for (int i = 0; i < n - 1; i++) {
        j = i + my_random() % (n - i);
        tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
}

void cumul_sort(int *q, int n) {
    // looks for the maximum q[i] and minimum
    if (n == 0) {
        return;
    }
    int qmax = q[0];
    int qmin = q[0];
    int i;
    for (i = 0; i < n; i++) if (q[i] > qmax) {
            qmax = q[i];
        }
    for (i = 0; i < n; i++) if (q[i] < qmin) {
            qmin = q[i];
        }

    // counts #q[i] with given q
    int *nb = new int[qmax - qmin + 1];
    for (int *onk = nb + (qmax - qmin + 1); onk != nb; * (--onk) = 0) { }
    for (i = 0; i < n; i++) {
        nb[q[i] - qmin]++;
    }

    // counts cumulative distribution
    for (i = qmax - qmin; i > 0; i--) {
        nb[i - 1] += nb[i];
    }

    // sort by q[i]
    int last_q;
    int tmp;
    int modifier = qmax - qmin + 1;
    for (int current = 0; current < n; current++) {
        tmp = q[current];
        if (tmp >= qmin && tmp <= qmax) {
            last_q = qmin;
            do {
                q[current] = last_q + modifier;
                last_q = tmp;
                current = --nb[last_q - qmin];
            } while ((tmp = q[current]) >= qmin && tmp <= qmax);
            q[current] = last_q + modifier;
        }
    }
    delete[] nb;
    for (i = 0; i < n; i++) {
        q[i] = q[i] - modifier;
    }
}

} // namespace gengraph
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_degree_sequence.h0000644000175100001710000000465500000000000032542 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef DEGREE_SEQUENCE_H
#define DEGREE_SEQUENCE_H

#include "igraph_types.h"
#include "igraph_datatype.h"

namespace gengraph {

class degree_sequence {

private:
    int n;
    int * deg;
    int total;

public :
    // #vertices
    inline int size() {
        return n;
    };
    inline int sum() {
        return total;
    };
    inline int operator[](int i) {
        return deg[i];
    };
    inline int *seq() {
        return deg;
    };
    inline void assign(int n0, int* d0) {
        n = n0;
        deg = d0;
    };
    inline int dmax() {
        int dm = deg[0];
        for (int i = 1; i < n; i++) if (deg[i] > dm) {
                dm = deg[i];
            }
        return dm;
    }

    void make_even(int mini = -1, int maxi = -1);
    void sort();
    void shuffle();

    // raw constructor
    degree_sequence(int n, int *degs);

    // read-from-file constrictor
    degree_sequence(FILE *f, bool DISTRIB = true);

    // simple power-law constructor : Pk = int((x+k0)^(-exp),x=k..k+1), with k0 so that avg(X)=z
    degree_sequence(int n, double exp, int degmin, int degmax, double avg_degree = -1.0);

    // igraph constructor
    degree_sequence(const igraph_vector_t *out_seq);

    // destructor
    ~degree_sequence();

    // unbind the deg[] vector (so that it doesn't get deleted when the class is destroyed)
    void detach();

    // compute total number of arcs
    void compute_total();

    // raw print (vertex by vertex)
    void print();

    // distribution print (degree frequency)
    void print_cumul();

    // is degree sequence realizable ?
    bool havelhakimi();

};

} // namespace gengraph

#endif //DEGREE_SEQUENCE_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_hash.cpp0000644000175100001710000010230500000000000033440 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_definitions.h"
#include 
#include 
#include 
#include 
#include 

#include "gengraph_qsort.h"
#include "gengraph_hash.h"
#include "gengraph_degree_sequence.h"
#include "gengraph_graph_molloy_hash.h"

#include "config.h"
#include "core/math.h"
#include "igraph_constructors.h"
#include "igraph_error.h"
#include "igraph_statusbar.h"
#include "igraph_progress.h"

namespace gengraph {

//_________________________________________________________________________
void graph_molloy_hash::compute_neigh() {
    int *p = links;
    for (int i = 0; i < n; i++) {
        neigh[i] = p;
        p += HASH_SIZE(deg[i]);
    }
}

//_________________________________________________________________________
void graph_molloy_hash::compute_size() {
    size = 0;
    for (int i = 0; i < n; i++) {
        size += HASH_SIZE(deg[i]);
    }
}

//_________________________________________________________________________
void graph_molloy_hash::init() {
    for (int i = 0; i < size; i++) {
        links[i] = HASH_NONE;
    }
}

//_________________________________________________________________________
graph_molloy_hash::graph_molloy_hash(degree_sequence °s) {
    igraph_status("Allocating memory for graph...", 0);
    int s = alloc(degs);
    igraph_statusf("%d bytes allocated successfully\n", 0, s);
}

//_________________________________________________________________________
int graph_molloy_hash::alloc(degree_sequence °s) {
    n = degs.size();
    a = degs.sum();
    assert(a % 2 == 0);

    deg = degs.seq();
    compute_size();
    deg = new int[n + size];
    if (deg == NULL) {
        return 0;
    }
    int i;
    for (i = 0; i < n; i++) {
        deg[i] = degs[i];
    }
    links = deg + n;
    init();
    neigh = new int*[n];
    if (neigh == NULL) {
        return 0;
    }
    compute_neigh();
    return sizeof(int *)*n + sizeof(int) * (n + size);
}

//_________________________________________________________________________
graph_molloy_hash::~graph_molloy_hash() {
    if (deg != NULL) {
        delete[] deg;
    }
    if (neigh != NULL) {
        delete[] neigh;
    }
    deg = NULL;
    neigh = NULL;
}

//_________________________________________________________________________
graph_molloy_hash::graph_molloy_hash(int *svg) {
    // Read n
    n = *(svg++);
    // Read a
    a = *(svg++);
    assert(a % 2 == 0);
    // Read degree sequence
    degree_sequence dd(n, svg);
    // Build neigh[] and alloc links[]
    alloc(dd);
    dd.detach();
    // Read links[]
    restore(svg + n);
}

//_________________________________________________________________________
int *graph_molloy_hash::hard_copy() {
    int *hc = new int[2 + n + a / 2]; // to store n,a,deg[] and links[]
    hc[0] = n;
    hc[1] = a;
    memcpy(hc + 2, deg, sizeof(int)*n);
    int *p = hc + 2 + n;
    int *l = links;
    for (int i = 0; i < n; i++) for (int j = HASH_SIZE(deg[i]); j--; l++) {
            int d;
            if ((d = *l) != HASH_NONE && d >= i) {
                *(p++) = d;
            }
        }
    assert(p == hc + 2 + n + a / 2);
    return hc;
}

//_________________________________________________________________________
bool graph_molloy_hash::is_connected() {
    bool *visited = new bool[n];
    int *buff = new int[n];
    int comp_size = depth_search(visited, buff);
    delete[] visited;
    delete[] buff;
    return (comp_size == n);
}

//_________________________________________________________________________
int* graph_molloy_hash::backup() {
    int *b = new int[a / 2];
    int *c = b;
    int *p = links;
    for (int i = 0; i < n; i++)
        for (int d = HASH_SIZE(deg[i]); d--; p++) if (*p != HASH_NONE && *p > i) {
                *(c++) = *p;
            }
    assert(c == b + (a / 2));
    return b;
}

//_________________________________________________________________________
void graph_molloy_hash::restore(int* b) {
    init();
    int i;
    int *dd = new int[n];
    memcpy(dd, deg, sizeof(int)*n);
    for (i = 0; i < n; i++) {
        deg[i] = 0;
    }
    for (i = 0; i < n - 1; i++) {
        while (deg[i] < dd[i]) {
            add_edge(i, *b, dd);
            b++;
        }
    }
    delete[] dd;
}

//_________________________________________________________________________
bool graph_molloy_hash::isolated(int v, int K, int *Kbuff, bool *visited) {
    if (K < 2) {
        return false;
    }
#ifdef OPT_ISOLATED
    if (K <= deg[v] + 1) {
        return false;
    }
#endif //OPT_ISOLATED
    int *seen  = Kbuff;
    int *known = Kbuff;
    int *max   = Kbuff + K;
    *(known++) = v;
    visited[v] = true;
    bool is_isolated = true;

    while (known != seen) {
        v = *(seen++);
        int *ww = neigh[v];
        int w;
        for (int d = HASH_SIZE(deg[v]); d--; ww++) if ((w = *ww) != HASH_NONE && !visited[w]) {
#ifdef OPT_ISOLATED
                if (K <= deg[w] + 1 || known == max) {
#else //OPT_ISOLATED
                if (known == max) {
#endif //OPT_ISOLATED
                    is_isolated = false;
                    goto end_isolated;
                }
                visited[w] = true;
                *(known++) = w;
            }
    }
end_isolated:
    // Undo the changes to visited[]...
    while (known != Kbuff) {
        visited[*(--known)] = false;
    }
    return is_isolated;
}

//_________________________________________________________________________
int graph_molloy_hash::random_edge_swap(int K, int *Kbuff, bool *visited) {
    // Pick two random vertices a and c
    int f1 = pick_random_vertex();
    int f2 = pick_random_vertex();
    // Check that f1 != f2
    if (f1 == f2) {
        return 0;
    }
    // Get two random edges (f1,*f1t1) and (f2,*f2t2)
    int *f1t1 = random_neighbour(f1);
    int t1 = *f1t1;
    int *f2t2 = random_neighbour(f2);
    int t2 = *f2t2;
    // Check simplicity
    if (t1 == t2 || f1 == t2 || f2 == t1) {
        return 0;
    }
    if (is_edge(f1, t2) || is_edge(f2, t1)) {
        return 0;
    }
    // Swap
    int *f1t2 = H_rpl(neigh[f1], deg[f1], f1t1, t2);
    int *f2t1 = H_rpl(neigh[f2], deg[f2], f2t2, t1);
    int *t1f2 = H_rpl(neigh[t1], deg[t1], f1, f2);
    int *t2f1 = H_rpl(neigh[t2], deg[t2], f2, f1);
    // isolation test
    if (K <= 2) {
        return 1;
    }
    if ( !isolated(f1, K, Kbuff, visited) && !isolated(f2, K, Kbuff, visited) ) {
        return 1;
    }
    // undo swap
    H_rpl(neigh[f1], deg[f1], f1t2, t1);
    H_rpl(neigh[f2], deg[f2], f2t1, t2);
    H_rpl(neigh[t1], deg[t1], t1f2, f1);
    H_rpl(neigh[t2], deg[t2], t2f1, f2);
    return 0;
}

//_________________________________________________________________________
unsigned long graph_molloy_hash::shuffle(unsigned long times,
        unsigned long maxtimes, int type) {
    igraph_progress("Shuffle", 0, 0);
    // assert(verify());
    // counters
    unsigned long nb_swaps = 0;
    unsigned long all_swaps = 0;
    unsigned long cost = 0;
    // window
    double T = double(min((unsigned long)(a), times) / 10);
    if (type == OPTIMAL_HEURISTICS) {
        T = double(optimal_window());
    }
    if (type == BRUTE_FORCE_HEURISTICS) {
        T = double(times * 2);
    }
    // isolation test parameter, and buffers
    double K = 2.4;
    int *Kbuff = new int[int(K) + 1];
    bool *visited = new bool[n];
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }
    // Used for monitoring , active only if VERBOSE()
    int failures = 0;
    int successes = 0;
    double avg_K = 0;
    double avg_T = 0;
    unsigned long next = times;
    next = 0;

    // Shuffle: while #edge swap attempts validated by connectivity < times ...
    while (times > nb_swaps && maxtimes > all_swaps) {
        // Backup graph
        int *save = backup();
        // Prepare counters, K, T
        unsigned long swaps = 0;
        int K_int = 0;
        if (type == FINAL_HEURISTICS || type == BRUTE_FORCE_HEURISTICS) {
            K_int = int(K);
        }
        unsigned long T_int = (unsigned long)(floor(T));
        if (T_int < 1) {
            T_int = 1;
        }
        // compute cost
        cost += T_int;
        if (K_int > 2) {
            cost += (unsigned long)(K_int) * (unsigned long)(T_int);
        }
        // Perform T edge swap attempts
        for (int i = T_int; i > 0; i--) {
            // try one swap
            swaps += (unsigned long)(random_edge_swap(K_int, Kbuff, visited));
            all_swaps++;
            // Verbose
            if (nb_swaps + swaps > next) {
                next = (nb_swaps + swaps) + max((unsigned long)(100), (unsigned long)(times / 1000));
                int progress = int(double(nb_swaps + swaps) / double(times));
                igraph_progress("Shuffle",  progress, 0);
            }
        }
        // test connectivity
        cost += (unsigned long)(a / 2);
        bool ok = is_connected();
        // performance monitor
        {
            avg_T += double(T_int); avg_K += double(K_int);
            if (ok) {
                successes++;
            } else {
                failures++;
            }
        }
        // restore graph if needed, and count validated swaps
        if (ok) {
            nb_swaps += swaps;
        } else {
            restore(save);
            next = nb_swaps;
        }
        delete[] save;
        // Adjust K and T following the heuristics.
        switch (type) {
            int steps;
        case GKAN_HEURISTICS:
            if (ok) {
                T += 1.0;
            } else {
                T *= 0.5;
            }
            break;
        case FAB_HEURISTICS:
            steps = 50 / (8 + failures + successes);
            if (steps < 1) {
                steps = 1;
            }
            while (steps--) if (ok) {
                    T *= 1.17182818;
                } else {
                    T *= 0.9;
                }
            if (T > double(5 * a)) {
                T = double(5 * a);
            }
            break;
        case FINAL_HEURISTICS:
            if (ok) {
                if ((K + 10.0)*T > 5.0 * double(a)) {
                    K /= 1.03;
                } else {
                    T *= 2;
                }
            } else {
                K *= 1.35;
                delete[] Kbuff;
                Kbuff = new int[int(K) + 1];
            }
            break;
        case OPTIMAL_HEURISTICS:
            if (ok) {
                T = double(optimal_window());
            }
            break;
        case BRUTE_FORCE_HEURISTICS:
            K *= 2; delete[] Kbuff; Kbuff = new int[int(K) + 1];
            break;
        default:
            throw std::invalid_argument("Error in graph_molloy_hash::shuffle(): Unknown heuristics type.");
        }
    }

    delete[] Kbuff;
    delete[] visited;

    if (maxtimes <= all_swaps) {
        IGRAPH_WARNING("Cannot shuffle graph, maybe it is the only realization of its degree sequence?");
    }

    // Status report
    {
        igraph_status("*** Shuffle Monitor ***\n", 0);
        igraph_statusf(" - Average cost : %f / validated edge swap\n", 0,
                       double(cost) / double(nb_swaps));
        igraph_statusf(" - Connectivity tests : %d (%d successes, %d failures)\n",
                       0, successes + failures, successes, failures);
        igraph_statusf(" - Average window : %d\n", 0,
                       int(avg_T / double(successes + failures)));
        if (type == FINAL_HEURISTICS || type == BRUTE_FORCE_HEURISTICS)
            igraph_statusf(" - Average isolation test width : %f\n", 0,
                           avg_K / double(successes + failures));
    }
    return nb_swaps;
}

//_________________________________________________________________________
void graph_molloy_hash::print(FILE *f) {
    int i, j;
    for (i = 0; i < n; i++) {
        fprintf(f, "%d", i);
        for (j = 0; j < HASH_SIZE(deg[i]); j++) if (neigh[i][j] != HASH_NONE) {
                fprintf(f, " %d", neigh[i][j]);
            }
        fprintf(f, "\n");
    }
}

int graph_molloy_hash::print(igraph_t *graph) {
    int i, j;
    long int ptr = 0;
    igraph_vector_t edges;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, a); // every edge is counted twice....

    for (i = 0; i < n; i++) {
        for (j = 0; j < HASH_SIZE(deg[i]); j++) {
            if (neigh[i][j] != HASH_NONE) {
                if (neigh[i][j] > i) {
                    VECTOR(edges)[ptr++] = i;
                    VECTOR(edges)[ptr++] = neigh[i][j];
                }
            }
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, /*undirected=*/ 0));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

//_________________________________________________________________________
bool graph_molloy_hash::try_shuffle(int T, int K, int *backup_graph) {
    // init all
    int *Kbuff = NULL;
    bool *visited = NULL;
    if (K > 2) {
        Kbuff = new int[K];
        visited = new bool[n];
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
    }
    int *back = backup_graph;
    if (back == NULL) {
        back = backup();
    }
    // perform T edge swap attempts
    while (T--) {
        random_edge_swap(K, Kbuff, visited);
    }
    // clean
    if (visited != NULL) {
        delete[] visited;
    }
    if (Kbuff   != NULL) {
        delete[] Kbuff;
    }
    // check & restore
    bool yo = is_connected();
    restore(back);
    if (backup_graph == NULL) {
        delete[] back;
    }
    return yo;
}

//_________________________________________________________________________
#define _TRUST_BERNOULLI_LOWER 0.01

bool bernoulli_param_is_lower(int success, int trials, double param) {
    if (double(success) >= double(trials)*param) {
        return false;
    }
    double comb = 1.0;
    double fact = 1.0;
    for (int i = 0; i < success; i++) {
        comb *= double(trials - i);
        fact *= double(i + 1);
    }
    comb /= fact;
    comb *= pow(param, double(success)) * exp(double(trials - success) * log1p(-param));
    double sum = comb;
    while (success && sum < _TRUST_BERNOULLI_LOWER) {
        comb *= double(success) * (1.0 - param) / (double(trials - success) * param);
        sum += comb;
        success--;
    }
    // fprintf(stderr,"bernoulli test : %d/%d success against p=%f -> %s\n",success, trials, param, (sum < _TRUST_BERNOULLI_LOWER) ? "lower" : "can't say");
    return (sum < _TRUST_BERNOULLI_LOWER);
}

//_________________________________________________________________________
#define _MIN_SUCCESS_FOR_BERNOULLI_TRUST 100
double graph_molloy_hash::average_cost(int T, int *backup, double min_cost) {
    if (T < 1) {
        return 1e+99;
    }
    int successes = 0;
    int trials = 0;
    while (successes < _MIN_SUCCESS_FOR_BERNOULLI_TRUST &&
           !bernoulli_param_is_lower(successes, trials, 1.0 / min_cost)) {
        if (try_shuffle(T, 0, backup)) {
            successes++;
        }
        trials++;
    }
    if (successes >= _MIN_SUCCESS_FOR_BERNOULLI_TRUST) {
        return double(trials) / double(successes) * (1.0 + double(a / 2) / double(T));
    } else {
        return 2.0 * min_cost;
    }
}

//_________________________________________________________________________
int graph_molloy_hash::optimal_window() {
    int Tmax;
    int optimal_T = 1;
    double min_cost = 1e+99;
    int *back = backup();
    // on cherche une borne sup pour Tmax
    int been_greater = 0;
    for (Tmax = 1; Tmax <= 5 * a ; Tmax *= 2) {
        double c = average_cost(Tmax, back, min_cost);
        if (c > 1.5 * min_cost) {
            break;
        }
        if (c > 1.2 * min_cost && ++been_greater >= 3) {
            break;
        }
        if (c < min_cost) {
            min_cost = c;
            optimal_T = Tmax;
        }
        igraph_statusf("Tmax = %d [%f]", 0, Tmax, min_cost);
    }
    // on cree Tmin
    int Tmin = int(0.5 * double(a) / (min_cost - 1.0));
    igraph_statusf("Optimal T is in [%d, %d]\n", 0, Tmin, Tmax);
    // on cherche autour
    double span = 2.0;
    int try_again = 4;
    while (span > 1.05 && optimal_T <= 5 * a) {
        igraph_statusf("Best T [cost]: %d [%f]", 0, optimal_T, min_cost);
        int T_low  = int(double(optimal_T) / span);
        int T_high = int(double(optimal_T) * span);
        double c_low  = average_cost(T_low, back, min_cost);
        double c_high = average_cost(T_high, back, min_cost);
        if (c_low < min_cost && c_high < min_cost) {
            if (try_again--) {
                continue;
            }
            {
                igraph_status("Warning: when looking for optimal T,\n", 0);
                igraph_statusf("Low: %d [%f]  Middle: %d [%f]  High: %d [%f]\n", 0,
                               T_low, c_low, optimal_T, min_cost, T_high, c_high);
            }
            delete[] back;
            return optimal_T;
        }
        if (c_low < min_cost) {
            optimal_T = T_low;
            min_cost = c_low;
        } else if (c_high < min_cost) {
            optimal_T = T_high;
            min_cost = c_high;
        };
        span = pow(span, 0.618);
    }
    delete[] back;
    return optimal_T;
}

//_________________________________________________________________________
double graph_molloy_hash::eval_K(int quality) {
    double K = 5.0;
    double avg_K = 1.0;
    for (int i = quality; i--; ) {
        int int_K = int(floor(K + 0.5));
        if (try_shuffle(a / (int_K + 1), int_K)) {
            K *= 0.8; /*fprintf(stderr,"+");*/
        } else {
            K *= 1.25; /*fprintf(stderr,"-");*/
        }
        if (i < quality / 2) {
            avg_K *= K;
        }
    }
    return pow(avg_K, 1.0 / double(quality / 2));
}

//_________________________________________________________________________
double graph_molloy_hash::effective_K(int K, int quality) {
    if (K < 3) {
        return 0.0;
    }
    long sum_K = 0;
    int *Kbuff = new int[K];
    bool *visited = new bool[n];
    int i;
    for (i = 0; i < n; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < quality; i++) {
        // assert(verify());
        int f1, f2, t1, t2;
        int *f1t1, *f2t2;
        do {
            // Pick two random vertices
            do {
                f1 = pick_random_vertex();
                f2 = pick_random_vertex();
            } while (f1 == f2);
            // Pick two random neighbours
            f1t1 = random_neighbour(f1);
            t1 = *f1t1;
            f2t2 = random_neighbour(f2);
            t2 = *f2t2;
            // test simplicity
        } while (t1 == t2 || f1 == t2 || f2 == t1 || is_edge(f1, t2) || is_edge(f2, t1));
        // swap
        swap_edges(f1, t2, f2, t1);
        // assert(verify());
        sum_K += effective_isolated(deg[f1] > deg[t2] ? f1 : t2, K, Kbuff, visited);
        // assert(verify());
        sum_K += effective_isolated(deg[f2] > deg[t1] ? f2 : t1, K, Kbuff, visited);
        // assert(verify());
        // undo swap
        swap_edges(f1, t2, f2, t1);
        // assert(verify());
    }
    delete[] Kbuff;
    delete[] visited;
    return double(sum_K) / double(2 * quality);
}

//_________________________________________________________________________
long graph_molloy_hash::effective_isolated(int v, int K, int *Kbuff, bool *visited) {
    int i;
    for (i = 0; i < K; i++) {
        Kbuff[i] = -1;
    }
    long count = 0;
    int left = K;
    int *KB = Kbuff;
    //yapido = (my_random()%1000 == 0);
    depth_isolated(v, count, left, K, KB, visited);
    while (KB-- != Kbuff) {
        visited[*KB] = false;
    }
    //if(yapido) fprintf(stderr,"\n");
    return count;
}

//_________________________________________________________________________
void graph_molloy_hash::depth_isolated(int v, long &calls, int &left_to_explore, int dmax, int * &Kbuff, bool *visited) {
    if (left_to_explore == 0) {
        return;
    }
//  if(yapido) fprintf(stderr,"%d ",deg[v]);
    if (--left_to_explore == 0) {
        return;
    }
    if (deg[v] + 1 >= dmax) {
        left_to_explore = 0;
        return;
    }
    *(Kbuff++) = v;
    visited[v] = true;
//  print();
//  fflush(stdout);
    calls++;
    int *copy = NULL;
    int *w = neigh[v];
    if (IS_HASH(deg[v])) {
        copy = new int[deg[v]];
        H_copy(copy, w, deg[v]);
        w = copy;
    }
    qsort(deg, w, deg[v]);
    w += deg[v];
    for (int i = deg[v]; i--; ) {
        if (visited[*--w]) {
            calls++;
        } else {
            depth_isolated(*w, calls, left_to_explore, dmax, Kbuff, visited);
        }
        if (left_to_explore == 0) {
            break;
        }
    }
    if (copy != NULL) {
        delete[] copy;
    }
}

//_________________________________________________________________________
int graph_molloy_hash::depth_search(bool *visited, int *buff, int v0) {
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }
    int *to_visit = buff;
    int nb_visited = 1;
    visited[v0] = true;
    *(to_visit++) = v0;
    while (to_visit != buff && nb_visited < n) {
        int v = *(--to_visit);
        int *ww = neigh[v];
        int w;
        for (int k = HASH_SIZE(deg[v]); k--; ww++) {
            if (HASH_NONE != (w = *ww) && !visited[w]) {
                visited[w] = true;
                nb_visited++;
                *(to_visit++) = w;
            }
        }
    }
    return nb_visited;
}

//_________________________________________________________________________
// bool graph_molloy_hash::verify() {
//   fprintf(stderr,"Warning: graph_molloy_hash::verify() called..\n");
//   fprintf(stderr,"   try to convert graph into graph_molloy_opt() instead\n");
//   return true;
// }


/*____________________________________________________________________________
  Not to use anymore : use graph_molloy_opt class instead

bool graph_molloy_hash::verify() {
int i;
  assert(neigh[0]==links);
  // verify edges count
  int sum = 0;
  for(i=0; in) n=i;
  n++;
  // degrees ?
  if(VERBOSE()) fprintf(stderr,"%d, #edges=",n);
  int *degs = new int[n];
  rewind(f);
  while(fgets(buff,FBUFF_SIZE,f)) {
    int d = 0;
    if(sscanf(buff,"%d",&i)==1) {
      char *b = buff;
      while(skip_int(b)) d++;
      degs[i]=d;
    }
  }
  // allocate memory
  degree_sequence dd(n,degs);
  if(VERBOSE()) fprintf(stderr,"%d\nAllocating memory...",dd.sum());
  alloc(dd);
  // add edges
  if(VERBOSE()) fprintf(stderr,"done\nCreating edges...");
  rewind(f);
  for(i=0; im) m=deg[k];
  return m;
}


bool graph_molloy_hash::havelhakimi() {

  int i;
  int dmax = max_degree()+1;
  // Sort vertices using basket-sort, in descending degrees
  int *nb = new int[dmax];
  int *sorted = new int[n];
  // init basket
  for(i=0; i=0; i--) {
    int t=nb[i];
    nb[i]=c;
    c+=t;
  }
  // sort
  for(i=0; i0; ) {
    // pick a vertex. we could pick any, but here we pick the one with biggest degree
    int v = sorted[first];
    // look for current degree of v
    while(nb[d]<=first) d--;
    // store it in dv
    int dv = d;
    // bind it !
    c -= dv;
    int dc = d;         // residual degree of vertices we bind to
    int fc = ++first;   // position of the first vertex with degree dc

    while(dv>0 && dc>0) {
      int lc = nb[dc];
      if(lc!=fc) {
        while(dv>0 && lc>fc) {
          // binds v with sorted[--lc]
          dv--;
          int w = sorted[--lc];
          add_edge(v,w);
        }
        fc = nb[dc];
        nb[dc] = lc;
      }
      dc--;
    }
    if(dv != 0) { // We couldn't bind entirely v
      if(VERBOSE()) {
        fprintf(stderr,"Error in graph_molloy_hash::havelhakimi() :\n");
        fprintf(stderr,"Couldn't bind vertex %d entirely (%d edges remaining)\n",v,dv);
      }
      delete[] nb;
      delete[] sorted;
      return false;
    }
  }
  assert(c==0);
  delete[] nb;
  delete[] sorted;
  return true;
}


bool graph_molloy_hash::make_connected() {
  assert(verify());
  if(a/2 < n-1) {
    // fprintf(stderr,"\ngraph::make_connected() failed : #edges < #vertices-1\n");
    return false;
  }
  int i;

// Data struct for the visit :
// - buff[] contains vertices to visit
// - dist[V] is V's distance modulo 4 to the root of its comp, or -1 if it hasn't been visited yet
#define MC_BUFF_SIZE (n+2)
  int *buff = new int[MC_BUFF_SIZE];
  unsigned char * dist  = new unsigned char[n];
#define NOT_VISITED 255
#define FORBIDDEN   254
  for(i=n; i>0; dist[--i]=NOT_VISITED);

// Data struct to store components : either surplus trees or surplus edges are stored at buff[]'s end
// - A Tree is coded by one of its vertices
// - An edge (a,b) is coded by the TWO ints a and b
  int *ffub = buff+MC_BUFF_SIZE;
  edge *edges = (edge *) ffub;
  int *trees = ffub;
  int *min_ffub = buff+1+(MC_BUFF_SIZE%2 ? 0 : 1);

// There will be only one "fatty" component, and trees.
  edge fatty_edge;
  fatty_edge.from = -1;
  bool enough_edges = false;

  // start main loop
  for(int v0=0; v0min_ffub) min_ffub+=2; // update limit of ffub's storage
          //assert(verify());
        }
        else if(dist[w]==next_dist || (w!=HASH_NONE && w>v && dist[w]==current_dist)) {
          // we found a removable edge
          if(is_a_tree) {
            // we must first merge with the fatty component
            is_a_tree = false;
            if(fatty_edge.from < 0) {
              // we ARE the first component! fatty is us
              fatty_edge.from = v;
              fatty_edge.to   = w;
            }
            else {
              // we connect to fatty
              swap_edges(fatty_edge.from, fatty_edge.to, v, w);
              //assert(verify());
            }
          }
          else {
            // we have removable edges to give!
            if(trees!=ffub) {
              // some trees still.. Let's merge with them!
              assert(trees>=min_ffub);
              assert(edges==(edge *)ffub);
              swap_edges(v,w,*trees,neigh[*trees][0]);
              trees++;
              //assert(verify());
            }
            else if(!enough_edges) {
              // Store the removable edge for future use
              if(edges<=(edge *)min_ffub+1)
                enough_edges = true;
              else {
                edges--;
                edges->from = v;
                edges->to   = w;
              }
            }
          }
        }
      }
    }
    // Mark component
    while(to_visit!=buff) dist[*(--to_visit)] = FORBIDDEN;
    // Check if it is a tree
    if(is_a_tree ) {
      assert(deg[v0]!=0);
      if(edges!=(edge *)ffub) {
        // let's bind the tree we found with a removable edge in stock
        assert(trees == ffub);
        if(edges<(edge *)min_ffub) edges=(edge *)min_ffub;
        swap_edges(v0,neigh[v0][0],edges->from,edges->to);
        edges++;
        assert(verify());
    }
      else {
        // add the tree to the list of trees
        assert(trees>min_ffub);
        *(--trees) = v0;
        assert(verify());
      }
    }
  }
  delete[] buff;
  delete[] dist;
  return(trees == ffub);
}

int64_t graph_molloy_hash::slow_connected_shuffle(int64_t times) {
  assert(verify());
  int64_t nb_swaps = 0;
  int T = 1;

  while(times>nb_swaps) {
    // Backup graph
    int *save = backup();
    // Swaps
    int swaps = 0;
    for(int i=T; i>0; i--) {
      // Pick two random vertices a and c
      int f1 = pick_random_vertex();
      int f2 = pick_random_vertex();
      // Check that f1 != f2
      if(f1==f2) continue;
      // Get two random edges (f1,*f1t1) and (f2,*f2t2)
      int *f1t1 = random_neighbour(f1);
      int t1 = *f1t1;
      int *f2t2 = random_neighbour(f2);
      int t2 = *f2t2;
      // Check simplicity
      if(t1==t2 || f1==t2 || f2==t1) continue;
      if(is_edge(f1,t2) || is_edge(f2,t1)) continue;
      // Swap
      H_rpl(neigh[f1],deg[f1],f1t1,t2);
      H_rpl(neigh[f2],deg[f2],f2t2,t1);
      H_rpl(neigh[t1],deg[t1],f1,f2);
      H_rpl(neigh[t2],deg[t2],f2,f1);
      swaps++;
    }
    // test connectivity
    bool ok = is_connected();
    if(ok) {
      nb_swaps += swaps;
    }
    else {
      restore(save);
    }
    delete[] save;
  }
  return nb_swaps;
}


int graph_molloy_hash::width_search(unsigned char *dist, int *buff, int v0) {
  for(int i=0; i.
 */
#ifndef GRAPH_MOLLOY_HASH_H
#define GRAPH_MOLLOY_HASH_H

#include "gengraph_definitions.h"
#include "gengraph_hash.h"
#include "gengraph_degree_sequence.h"

#include 
#include 
// This class handles graphs with a constant degree sequence.

#define FINAL_HEURISTICS        0
#define GKAN_HEURISTICS         1
#define FAB_HEURISTICS          2
#define OPTIMAL_HEURISTICS      3
#define BRUTE_FORCE_HEURISTICS  4

namespace gengraph {

//****************************
//  class graph_molloy_hash
//****************************

class graph_molloy_hash {

private:
    // Number of vertices
    int n;
    //Number of arcs ( = #edges * 2 )
    int a;
    //Total size of links[]
    int size;
    // The degree sequence of the graph
    int *deg;
    // The array containing all links
    int *links;
    // The array containing pointers to adjacency list of every vertices
    int **neigh;
    // Counts total size
    void compute_size();
    // Build neigh with deg and links
    void compute_neigh();
    // Allocate memory according to degree_sequence (for constructor use only!!)
    int alloc(degree_sequence &);
    // Add edge (u,v). Return FALSE if vertex a is already full.
    // WARNING : only to be used by havelhakimi(), restore() or constructors
    inline bool add_edge(int u, int v, int *realdeg) {
        int deg_u = realdeg[u];
        if (deg_u == deg[u]) {
            return false;
        }
        // Check that edge was not already inserted
        assert(fast_search(neigh[u], int((u == n - 1 ? links + size : neigh[u + 1]) - neigh[u]), v) == NULL);
        assert(fast_search(neigh[v], int((v == n - 1 ? links + size : neigh[v + 1]) - neigh[v]), u) == NULL);
        assert(deg[u] < deg_u);
        int deg_v = realdeg[v];
        if (IS_HASH(deg_u)) {
            *H_add(neigh[u], HASH_EXPAND(deg_u), v) = v;
        } else {
            neigh[u][deg[u]] = v;
        }
        if (IS_HASH(deg_v)) {
            *H_add(neigh[v], HASH_EXPAND(deg_v), u) = u;
        } else {
            neigh[v][deg[v]] = u;
        }
        deg[u]++;
        deg[v]++;
        // Check that edge was actually inserted
        assert(fast_search(neigh[u], int((u == n - 1 ? links + size : neigh[u + 1]) - neigh[u]), v) != NULL);
        assert(fast_search(neigh[v], int((v == n - 1 ? links + size : neigh[v + 1]) - neigh[v]), u) != NULL);
        return true;
    }
    // Swap edges
    inline void swap_edges(int from1, int to1, int from2, int to2) {
        H_rpl(neigh[from1], deg[from1], to1, to2);
        H_rpl(neigh[from2], deg[from2], to2, to1);
        H_rpl(neigh[to1], deg[to1], from1, from2);
        H_rpl(neigh[to2], deg[to2], from2, from1);
    }
    // Backup graph [sizeof(int) bytes per edge]
    int* backup();
    // Test if vertex is in an isolated component of size dmax.
    void depth_isolated(int v, long &calls, int &left_to_explore, int dmax, int * &Kbuff, bool *visited);


public:
    //degree of v
    inline int degree(const int v) {
        return deg[v];
    };
    // For debug purposes : verify validity of the graph (symetry, simplicity)
    bool verify();
    // Destroy deg[], neigh[] and links[]
    ~graph_molloy_hash();
    // Allocate memory for the graph. Create deg and links. No edge is created.
    graph_molloy_hash(degree_sequence &);
    // Create graph from hard copy
    graph_molloy_hash(int *);
    // Create hard copy of graph
    int *hard_copy();
    // Restore from backup
    void restore(int* back);
    //Clear hash tables
    void init();
    // nb arcs
    inline int nbarcs() {
        return a;
    };
    // nb vertices
    inline int nbvertices() {
        return n;
    };
    // print graph in SUCC_LIST mode, in stdout
    void print(FILE *f = stdout);
    int print(igraph_t *graph);
    // Test if graph is connected
    bool is_connected();
    // is edge ?
    inline bool is_edge(int u, int v) {
        assert(H_is(neigh[u], deg[u], v) == (fast_search(neigh[u], HASH_SIZE(deg[u]), v) != NULL));
        assert(H_is(neigh[v], deg[v], u) == (fast_search(neigh[v], HASH_SIZE(deg[v]), u) != NULL));
        assert(H_is(neigh[u], deg[u], v) == H_is(neigh[v], deg[v], u));
        if (deg[u] < deg[v]) {
            return H_is(neigh[u], deg[u], v);
        } else {
            return H_is(neigh[v], deg[v], u);
        }
    }
    // Random edge swap ATTEMPT. Return 1 if attempt was a succes, 0 otherwise
    int random_edge_swap(int K = 0, int *Kbuff = NULL, bool *visited = NULL);
    // Connected Shuffle
    unsigned long shuffle(unsigned long, unsigned long, int type);
    // Optimal window for the gkantsidis heuristics
    int optimal_window();
    // Average unitary cost per post-validated edge swap, for some window
    double average_cost(int T, int *back, double min_cost);
    // Get caracteristic K
    double eval_K(int quality = 100);
    // Get effective K
    double effective_K(int K, int quality = 10000);
    // Try to shuffle T times. Return true if at the end, the graph was still connected.
    bool try_shuffle(int T, int K, int *back = NULL);


    /*_____________________________________________________________________________
      Not to use anymore : use graph_molloy_opt class instead

    private:
      // breadth-first search. Store the distance (modulo 3)  in dist[]. Returns eplorated component size.
      int width_search(unsigned char *dist, int *buff, int v0=0);

    public:
      // Create graph
      graph_molloy_hash(FILE *f);
      // Bind the graph avoiding multiple edges or self-edges (return false if fail)
      bool havelhakimi();
      // Get the graph connected  (return false if fail)
      bool make_connected();
      // "Fab" Shuffle (Optimized heuristic of Gkantsidis algo.)
      long long fab_connected_shuffle(long long);
      // Naive Shuffle
      long long slow_connected_shuffle(long long);
      // Maximum degree
      int max_degree();
      // compute vertex betweenness : for each vertex, a unique random shortest path is chosen.
      // this choice is consistent (if shortest path from a to c goes through b and then d,
      // then shortest path from a to d goes through b). If(trivial path), also count all the
      // shortest paths where vertex is an extremity
      int *vertex_betweenness_rsp(bool trivial_path);
      // same, but when multiple shortest path are possible, average the weights.
      double *vertex_betweenness_asp(bool trivial_path);
    //___________________________________________________________________________________
    */

};

} // namespace gengraph

#endif //GRAPH_MOLLOY_HASH_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_graph_molloy_optimized.cpp0000644000175100001710000020622300000000000034525 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_definitions.h"
#include 
#include 
#include 
#include 

#include "gengraph_qsort.h"
#include "gengraph_box_list.h"
#include "gengraph_vertex_cover.h"
#include "gengraph_degree_sequence.h"
#include "gengraph_graph_molloy_optimized.h"

#include "igraph_error.h"
#include "igraph_statusbar.h"
#include "igraph_progress.h"


using namespace std;

namespace gengraph {

void graph_molloy_opt::breadth_search(int *dist, int v0, int *buff) {
    bool tmpbuff = (buff == NULL);
    if (tmpbuff) {
        buff = new int[n];
    }
    for (int i = 0; i < n; i++) {
        dist[i] = -1;
    }
    dist[v0] = 0;
    int *visited = buff;
    int *to_visit = buff;
    *to_visit++ = v0;
    while (visited != to_visit) {
        int v = *visited++;
        int *w = neigh[v];
        int dd = dist[v] + 1;
        for (int d = deg[v]; d--; w++) if (dist[*w] < 0) {
                dist[*w] = dd;
                *to_visit++ = *w;
            }
    }
    if (tmpbuff) {
        delete[] buff;
    }
}


int graph_molloy_opt::max_degree() {
    int m = 0;
    for (int k = 0; k < n; k++) if (deg[k] > m) {
            m = deg[k];
        }
    return m;
}

void graph_molloy_opt::compute_neigh() {
    int *p = links;
    for (int i = 0; i < n; i++) {
        neigh[i] = p;
        p += deg[i];
    }
}

void graph_molloy_opt::alloc(degree_sequence °s) {
    n = degs.size();
    a = degs.sum();
    assert(a % 2 == 0);
    deg = new int[n + a];
    for (int i = 0; i < n; i++) {
        deg[i] = degs[i];
    }
    links = deg + n;
    neigh = new int*[n];
    compute_neigh();
}

graph_molloy_opt::graph_molloy_opt(degree_sequence °s) {
    alloc(degs);
}

// graph_molloy_opt::graph_molloy_opt(FILE *f) {
//   char *buff = new char[FBUFF_SIZE];
//   // How many vertices ?
//   if(VERBOSE()) fprintf(stderr,"Read file: #vertices=");
//   int i;
//   int n=0;
//   while(fgets(buff,FBUFF_SIZE,f)) if(sscanf(buff,"%d",&i)==1 && i>n) n=i;
//   n++;
//   // degrees ?
//   if(VERBOSE()) fprintf(stderr,"%d, #edges=",n);
//   int *degs = new int[n];
//   for(i=0; i= i) {
                *(c++) = *p;
            }
        }
    }
    assert(c == b + (a / 2));
    return b;
}

int *graph_molloy_opt::hard_copy() {
    int *hc = new int[2 + n + a / 2]; // to store n,a,deg[] and links[]
    hc[0] = n;
    hc[1] = a;
    memcpy(hc + 2, deg, sizeof(int)*n);
    int *c = hc + 2 + n;
    for (int i = 0; i < n; i++) {
        int *p = neigh[i];
        for (int d = deg[i]; d--; p++) {
            assert(*p != i);
            if (*p >= i) {
                *(c++) = *p;
            }
        }
    }
    assert(c == hc + 2 + n + a / 2);
    return hc;
}

void graph_molloy_opt::restore(int* b) {
    int i;
    for (i = 0; i < n; i++) {
        deg[i] = 0;
    }
    int *p = links;
    for (i = 0; i < n - 1; i++) {
        p += deg[i];
        deg[i] = int(neigh[i + 1] - neigh[i]);
        assert((neigh[i] + deg[i]) == neigh[i + 1]);
        while (p != neigh[i + 1]) {
            // b points to the current 'j'
            neigh[*b][deg[*b]++] = i;
            *(p++) = *(b++);
        }
    }
}

int* graph_molloy_opt::backup_degs(int *b) {
    if (b == NULL) {
        b = new int[n];
    }
    memcpy(b, deg, sizeof(int)*n);
    return b;
}

void graph_molloy_opt::restore_degs_only(int *b) {
    memcpy(deg, b, sizeof(int)*n);
    refresh_nbarcs();
}

void graph_molloy_opt::restore_degs_and_neigh(int *b) {
    restore_degs_only(b);
    compute_neigh();
}

void graph_molloy_opt::restore_degs(int last_degree) {
    a = last_degree;
    deg[n - 1] = last_degree;
    for (int i = n - 2; i >= 0; i--) {
        a += (deg[i] = int(neigh[i + 1] - neigh[i]));
    }
    refresh_nbarcs();
}

void graph_molloy_opt::clean() {
    int *b = hard_copy();
    replace(b);
    delete[] b;
}

void graph_molloy_opt::replace(int *_hardcopy) {
    delete[] deg;
    n = *(_hardcopy++);
    a = *(_hardcopy++);
    deg = new int[a + n];
    memcpy(deg, _hardcopy, sizeof(int)*n);
    links = deg + n;
    compute_neigh();
    restore(_hardcopy + n);
}

int* graph_molloy_opt::components(int *comp) {
    int i;
    // breadth-first search buffer
    int *buff = new int[n];
    // comp[i] will contain the index of the component that contains vertex i
    if (comp == NULL) {
        comp = new int[n];
    }
    memset(comp, 0, sizeof(int)*n);
    // current component index
    int curr_comp = 0;
    // loop over all non-visited vertices...
    for (int v0 = 0; v0 < n; v0++) if (comp[v0] == 0) {
            curr_comp++;
            // initiate breadth-first search
            int *to_visit = buff;
            int *visited = buff;
            *(to_visit++) = v0;
            comp[v0] = curr_comp;
            // breadth-first search
            while (visited != to_visit) {
                int v = *(visited++);
                int d = deg[v];
                for (int *w = neigh[v]; d--; w++) if (comp[*w] == 0) {
                        comp[*w] = curr_comp;
                        *(to_visit++) = *w;
                    }
            }
        }
    // compute component sizes and store them in buff[]
    int nb_comp = 0;
    memset(buff, 0, sizeof(int)*n);
    for (i = 0; i < n; i++)
        if (buff[comp[i] - 1]++ == 0 && comp[i] > nb_comp) {
            nb_comp = comp[i];
        }
    // box-sort sizes
    int offset = 0;
    int *box = pre_boxsort(buff, nb_comp, offset);
    for (i = nb_comp - 1; i >= 0; i--) {
        buff[i] = --box[buff[i] - offset];
    }
    delete[] box;
    // reassign component indexes
    for (int *c = comp + n; comp != c--; *c = buff[*c - 1]) { }
    // clean.. at last!
    delete[] buff;
    return comp;
}

void graph_molloy_opt::giant_comp() {
    int *comp = components();
    // Clear edges of all vertices that do not belong to comp 0
    for (int i = 0; i < n; i++) if (comp[i] != 0) {
            deg[i] = 0;
        }
    // Clean comp[]
    delete[] comp;
}

int graph_molloy_opt::nbvertices_comp() {
    int *comp = components();
    // Count all vertices that belong to comp 0
    int nb = 0;
    for (int i = 0; i < n; i++) if (comp[i] == 0) {
            nb++;
        }
    // Clean comp[]
    delete[] comp;
    return nb;
}

int graph_molloy_opt::nbarcs_comp() {
    int *comp = components();
    // Count all vertices that belong to comp 0
    int nb = 0;
    for (int i = 0; i < n; i++) if (comp[i] == 0) {
            nb += deg[i];
        }
    // Clean comp[]
    delete[] comp;
    return nb;
}

bool graph_molloy_opt::havelhakimi() {

    int i;
    int dmax = max_degree() + 1;
    // Sort vertices using basket-sort, in descending degrees
    int *nb = new int[dmax];
    int *sorted = new int[n];
    // init basket
    for (i = 0; i < dmax; i++) {
        nb[i] = 0;
    }
    // count basket
    for (i = 0; i < n; i++) {
        nb[deg[i]]++;
    }
    // cumul
    int c = 0;
    for (i = dmax - 1; i >= 0; i--) {
        c += nb[i];
        nb[i] = -nb[i] + c;
    }
    // sort
    for (i = 0; i < n; i++) {
        sorted[nb[deg[i]]++] = i;
    }

// Binding process starts
    int first = 0;  // vertex with biggest residual degree
    int d = dmax - 1; // maximum residual degree available

    for (c = a / 2; c > 0; ) {
        // pick a vertex. we could pick any, but here we pick the one with biggest degree
        int v = sorted[first];
        // look for current degree of v
        while (nb[d] <= first) {
            d--;
        }
        // store it in dv
        int dv = d;
        // bind it !
        c -= dv;
        int dc = d;         // residual degree of vertices we bind to
        int fc = ++first;   // position of the first vertex with degree dc

        while (dv > 0 && dc > 0) {
            int lc = nb[dc];
            if (lc != fc) {
                while (dv > 0 && lc > fc) {
                    // binds v with sorted[--lc]
                    dv--;
                    int w = sorted[--lc];
                    *(neigh[v]++) = w;
                    *(neigh[w]++) = v;
                }
                fc = nb[dc];
                nb[dc] = lc;
            }
            dc--;
        }
        if (dv != 0) { // We couldn't bind entirely v
            delete[] nb;
            delete[] sorted;
            compute_neigh();

            /* Cannot use IGRAPH_ERRORF() as this function does not return
             * an error code. This situation should only occur when the degree
             * sequence is not graphical, but that is already checked at the top
             * level. Therefore, we report EINTERNAL, as triggering this
             * indicates a bug. */
            igraph_errorf("Error in graph_molloy_opt::havelhakimi(): "
                          "Couldn't bind vertex %d entirely (%d edges remaining)",
                          IGRAPH_FILE_BASENAME, __LINE__,
                          IGRAPH_EINTERNAL, v, dv);
            return false;
        }
    }
    assert(c == 0);
    compute_neigh();
    delete[] nb;
    delete[] sorted;
    return true;
}

bool graph_molloy_opt::is_connected() {
    bool *visited = new bool[n];
    for (int i = n; i > 0; visited[--i] = false) { }
    int *to_visit = new int[n];
    int *stop = to_visit;
    int left = n - 1;
    *(to_visit++) = 0;
    visited[0] = true;
    while (left > 0 && to_visit != stop) {
        int v = *(--to_visit);
        int *w = neigh[v];
        for (int k = deg[v]; k--; w++) if (!visited[*w]) {
                visited[*w] = true;
                left--;
                *(to_visit++) = *w;
            }
    }
    delete[] visited;
    delete[] stop;
    assert(left >= 0);
    return (left == 0);
}


bool graph_molloy_opt::make_connected() {
    //assert(verify());
    if (a / 2 < n - 1) {
        // fprintf(stderr,"\ngraph::make_connected() failed : #edges < #vertices-1\n");
        return false;
    }
    int i;

// Data struct for the visit :
// - buff[] contains vertices to visit
// - dist[V] is V's distance modulo 4 to the root of its comp, or -1 if it hasn't been visited yet
#define MC_BUFF_SIZE (n+2)
    int *buff = new int[MC_BUFF_SIZE];
    unsigned char * dist  = new unsigned char[n];
#define NOT_VISITED 255
#define FORBIDDEN   254
    for (i = n; i > 0; dist[--i] = NOT_VISITED) { }

// Data struct to store components : either surplus trees or surplus edges are stored at buff[]'s end
// - A Tree is coded by one of its vertices
// - An edge (a,b) is coded by the TWO ints a and b
    int *ffub = buff + MC_BUFF_SIZE;
    edge *edges = (edge *) ffub;
    int *trees = ffub;
    int *min_ffub = buff + 1 + (MC_BUFF_SIZE % 2 ? 0 : 1);

// There will be only one "fatty" component, and trees.
    edge fatty_edge = { -1, -1 };
    bool enough_edges = false;

    // start main loop
    for (int v0 = 0; v0 < n; v0++) if (dist[v0] == NOT_VISITED) {
            // is v0 an isolated vertex?
            if (deg[v0] == 0) {
                delete[] dist;
                delete[] buff;
                /* Cannot use IGRAPH_ERROR() as this function does not return an error code. */
                igraph_error("Cannot create connected graph from degree sequence: "
                              "vertex with degree 0 found.",
                              IGRAPH_FILE_BASENAME, __LINE__,
                              IGRAPH_EINVAL);
                return false;
            }
            dist[v0] = 0; // root
            int *to_visit = buff;
            int *current  = buff;
            *(to_visit++) = v0;

            // explore component connected to v0
            bool is_a_tree = true;
            while (current != to_visit) {
                int v = *(current++);
                unsigned char current_dist = dist[v];
                unsigned char next_dist = (current_dist + 1) & 0x03;
                //unsigned char prev_dist = (current_dist-1) & 0x03;
                int* ww = neigh[v];
                int w;
                for (int k = deg[v]; k--; ww++) {
                    if (dist[w = *ww] == NOT_VISITED) {
                        // we didn't visit *w yet
                        dist[w] = next_dist;
                        *(to_visit++) = w;
                        if (to_visit > min_ffub) {
                            min_ffub += 2;    // update limit of ffub's storage
                        }
                        //assert(verify());
                    } else if (dist[w] == next_dist || (w >= v && dist[w] == current_dist)) {
                        // we found a removable edge
                        if (trees != ffub) {
                            // some trees still.. Let's merge with them!
                            assert(trees >= min_ffub);
                            assert(edges == (edge *)ffub);
                            swap_edges(v, w, *trees, neigh[*trees][0]);
                            trees++;
                            //assert(verify());
                        } else if (is_a_tree) {
                            // we must merge with the fatty component
                            is_a_tree = false;
                            if (fatty_edge.from < 0) {
                                // we ARE the first component! fatty is us
                                fatty_edge.from = v;
                                fatty_edge.to   = w;
                            } else {
                                // we connect to fatty
                                swap_edges(fatty_edge.from, fatty_edge.to, v, w);
                                fatty_edge.to = w;
                                //assert(verify());
                            }
                        } else if (!enough_edges) {
                            // Store the removable edge for future use
                            if (edges <= (edge *)min_ffub + 1) {
                                enough_edges = true;
                            } else {
                                edges--;
                                edges->from = v;
                                edges->to   = w;
                            }
                        }
                    }
                }
            }
            // Mark component
            while (to_visit != buff) {
                dist[*(--to_visit)] = FORBIDDEN;
            }
            // Check if it is a tree
            if (is_a_tree ) {
                assert(deg[v0] != 0);
                if (edges != (edge *)ffub) {
                    // let's bind the tree we found with a removable edge in stock
                    assert(trees == ffub);
                    if (edges < (edge *)min_ffub) {
                        edges = (edge *)min_ffub;
                    }
                    swap_edges(v0, neigh[v0][0], edges->from, edges->to);
                    edges++;
                    assert(verify());
                } else if (fatty_edge.from >= 0) {
                    // if there is a fatty component, let's merge with it ! and discard fatty :-/
                    assert(trees == ffub);
                    swap_edges(v0, neigh[v0][0], fatty_edge.from, fatty_edge.to);
                    fatty_edge.from = -1;
                    fatty_edge.to = -1;
                    assert(verify());
                } else {
                    // add the tree to the list of trees
                    assert(trees > min_ffub);
                    *(--trees) = v0;
                    assert(verify());
                }
            }
        }
    delete[] buff;
    delete[] dist;
    // Should ALWAYS return true : either we have no tree left, or we are a unique, big tree
    return (trees == ffub || ((trees + 1) == ffub && fatty_edge.from < 0));
}

bool graph_molloy_opt::swap_edges_simple(int from1, int to1, int from2, int to2) {
    if (from1 == to1 || from1 == from2 || from1 == to2 || to1 == from2 || to1 == to2 || from2 == to2) {
        return false;
    }
    if (is_edge(from1, to2) || is_edge(from2, to1)) {
        return false;
    }
    swap_edges(from1, to1, from2, to2);
    return true;
}

long graph_molloy_opt::fab_connected_shuffle(long times) {
    //assert(verify());
    long nb_swaps = 0;
    double T = double(min(a, times)) / 10.0;
    double q1 = 1.131;
    double q2 = 0.9237;

    while (times > 0) {
        long iperiod = max(1, long(T));
        // Backup graph
        int *save = backup();
        //assert(verify());
        // Swaps
        long swaps = 0;
        for (long i = iperiod; i > 0; i--) {
            // Pick two random vertices
            int f1 = links[my_random() % a];
            int f2 = links[my_random() % a];
            if (f1 == f2) {
                continue;
            }
            // Pick two random neighbours
            int *f1t1 = neigh[f1] + my_random() % deg[f1];
            int *f2t2 = neigh[f2] + my_random() % deg[f2];
            int t1 = *f1t1;
            int t2 = *f2t2;
            // test simplicity
            if (t1 != t2 && f1 != t2 && f2 != t1 && is_edge(f1, t2) && !is_edge(f2, t1)) {
                // swap
                *f1t1 = t2;
                *f2t2 = t1;
                fast_rpl(neigh[t1], f1, f2);
                fast_rpl(neigh[t2], f2, f1);
                swaps++;
            }
        }
        //assert(verify());
        // test connectivity
        if (is_connected()) {
            nb_swaps += swaps;
            times -= iperiod;
            // adjust T
            T *= q1;
        } else {
            restore(save);
            //assert(verify());
            T *= q2;
        }
        delete[] save;
    }
    return nb_swaps;
}

long graph_molloy_opt::opt_fab_connected_shuffle(long times) {
    //assert(verify());
    long nb_swaps = 0;
    double T = double(min(a, times)) / 10.0;
    double q1 = 1.131;
    double q2 = 0.9237;

    while (times > 0) {
        long iperiod = max(1, long(T));
        // Backup graph
        int *save = backup();
        //assert(verify());
        // Swaps
        long swaps = 0;
        for (long i = iperiod; i > 0; i--) {
            // Pick two random vertices
            int f1 = links[my_random() % a];
            int f2 = links[my_random() % a];
            if (f1 == f2) {
                continue;
            }
            // Pick two random neighbours
            int *f1t1 = neigh[f1] + my_random() % deg[f1];
            int *f2t2 = neigh[f2] + my_random() % deg[f2];
            int t1 = *f1t1;
            int t2 = *f2t2;
            if (
                // test simplicity
                t1 != t2 && f1 != t2 && f2 != t1 && is_edge(f1, t2) && !is_edge(f2, t1) &&
                // test isolated pair
                (deg[f1] > 1 || deg[t2] > 1) && (deg[f2] > 1 || deg[t1] > 1)
            ) {
                // swap
                *f1t1 = t2;
                *f2t2 = t1;
                fast_rpl(neigh[t1], f1, f2);
                fast_rpl(neigh[t2], f2, f1);
                swaps++;
            }
        }
        //assert(verify());
        // test connectivity
        if (is_connected()) {
            nb_swaps += swaps;
            times -= iperiod;
            // adjust T
            T *= q1;
        } else {
            restore(save);
            //assert(verify());
            T *= q2;
        }
        delete[] save;
    }
    return nb_swaps;
}

long graph_molloy_opt::gkantsidis_connected_shuffle(long times) {
    //assert(verify());
    long nb_swaps = 0;
    long T = min(a, times) / 10;

    while (times > 0) {
        // Backup graph
        int *save = backup();
        //assert(verify());
        // Swaps
        long swaps = 0;
        for (int i = T; i > 0; i--) {
            // Pick two random vertices
            int f1 = links[my_random() % a];
            int f2 = links[my_random() % a];
            if (f1 == f2) {
                continue;
            }
            // Pick two random neighbours
            int *f1t1 = neigh[f1] + my_random() % deg[f1];
            int *f2t2 = neigh[f2] + my_random() % deg[f2];
            int t1 = *f1t1;
            int t2 = *f2t2;
            // test simplicity
            if (t1 != t2 && f1 != t2 && f2 != t1 && is_edge(f1, t2) && !is_edge(f2, t1)) {
                // swap
                *f1t1 = t2;
                *f2t2 = t1;
                fast_rpl(neigh[t1], f1, f2);
                fast_rpl(neigh[t2], f2, f1);
                swaps++;
            }
        }
        //assert(verify());
        // test connectivity
        if (is_connected()) {
            nb_swaps += swaps;
            times -= T;
            // adjust T
            T++;
        } else {
            restore(save);
            //assert(verify());
            T /= 2; if (T == 0) T = 1;
        }
        delete[] save;
    }
    return nb_swaps;
}

long graph_molloy_opt::slow_connected_shuffle(long times) {
    //assert(verify());
    long nb_swaps = 0;

    while (times--) {
        // Pick two random vertices
        int f1 = links[my_random() % a];
        int f2 = links[my_random() % a];
        if (f1 == f2) {
            continue;
        }
        // Pick two random neighbours
        int *f1t1 = neigh[f1] + my_random() % deg[f1];
        int *f2t2 = neigh[f2] + my_random() % deg[f2];
        int t1 = *f1t1;
        int t2 = *f2t2;
        // test simplicity
        if (t1 != t2 && f1 != t2 && f2 != t1 && is_edge(f1, t2) && !is_edge(f2, t1)) {
            // swap
            *f1t1 = t2;
            *f2t2 = t1;
            int *t1f1 = fast_rpl(neigh[t1], f1, f2);
            int *t2f2 = fast_rpl(neigh[t2], f2, f1);
            // test connectivity
            if (is_connected()) {
                nb_swaps++;
            } else {
                // undo swap
                *t1f1 = f1; *t2f2 = f2; *f1t1 = t1; *f2t2 = t2;
            }
        }
    }
    return nb_swaps;
}

void graph_molloy_opt::print(FILE *f, bool NOZERO) {
    int i, j;
    for (i = 0; i < n; i++) {
        if (!NOZERO || deg[i] > 0) {
            fprintf(f, "%d", i);
            for (j = 0; j < deg[i]; j++) {
                fprintf(f, " %d", neigh[i][j]);
            }
            fprintf(f, "\n");
        }
    }
}

long graph_molloy_opt::effective_isolated(int v, int K, int *Kbuff, bool *visited) {
    int i;
    for (i = 0; i < K; i++) {
        Kbuff[i] = -1;
    }
    long count = 0;
    int left = K;
    int *KB = Kbuff;
    //yapido = (my_random()%1000 == 0);
    depth_isolated(v, count, left, K, KB, visited);
    while (KB-- != Kbuff) {
        visited[*KB] = false;
    }
    //if(yapido) fprintf(stderr,"\n");
    return count;
}

void graph_molloy_opt::depth_isolated(int v, long &calls, int &left_to_explore, int dmax, int * &Kbuff, bool *visited) {
    if (left_to_explore == 0) {
        return;
    }
//  if(yapido) fprintf(stderr,"%d ",deg[v]);
    if (--left_to_explore == 0) {
        return;
    }
    if (deg[v] + 1 >= dmax) {
        left_to_explore = 0;
        return;
    }
    *(Kbuff++) = v;
    visited[v] = true;
    calls++;
    int *w = neigh[v];
    qsort(deg, w, deg[v]);
    w += deg[v];
    for (int i = deg[v]; i--; ) {
        if (visited[*--w]) {
            calls++;
        } else {
            depth_isolated(*w, calls, left_to_explore, dmax, Kbuff, visited);
        }
        if (left_to_explore == 0) {
            break;
        }
    }
}

int graph_molloy_opt::depth_search(bool *visited, int *buff, int v0) {
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }
    int *to_visit = buff;
    int nb_visited = 1;
    visited[v0] = true;
    *(to_visit++) = v0;
    while (to_visit != buff && nb_visited < n) {
        int v = *(--to_visit);
        int *ww = neigh[v];
        int w;
        for (int k = deg[v]; k--; ww++) if (!visited[w = *ww]) {
                visited[w] = true;
                nb_visited++;
                *(to_visit++) = w;
            }
    }
    return nb_visited;
}

int graph_molloy_opt::width_search(unsigned char *dist, int *buff, int v0, int toclear) {
    if (toclear >= 0) for (int i = 0; i < toclear; i++) {
            dist[buff[i]] = 0;
        } else for (int i = 0; i < n; i++) {
            dist[i] = 0;
        }
    int *to_visit = buff;
    int *to_add = buff;
    int nb_visited = 1;
    dist[v0] = 1;
    *(to_add++) = v0;
    while (to_visit != to_add && nb_visited < n) {
        int v = *(to_visit++);
        int *ww = neigh[v];
        int w;
        unsigned char d = next_dist(dist[v]);
        for (int k = deg[v]; k--; ww++) if (dist[w = *ww] == 0) {
                dist[w] = d;
                nb_visited++;
                *(to_add++) = w;
            }
    }
    return nb_visited;
}

double graph_molloy_opt::avg_dist(unsigned char *dist, int *buff, int v0, int &nb_visited, int toclear) {
    nb_visited = width_search(dist, buff, v0, toclear);
    unsigned char curr_dist = 1;
    assert(curr_dist == dist[v0]);
    double total_dist = 0.0;
    int current_dist = 0;
    for (int p = 0; p < nb_visited; p++) {
        v0 = buff[p];
        if (dist[v0] != curr_dist) {
            current_dist++;
            curr_dist = dist[v0];
        }
        total_dist += double(current_dist);
    }
    nb_visited--;
    return total_dist / double(nb_visited);
}


void graph_molloy_opt::add_traceroute_edge(int v, int k, int *newdeg, double **edge_redudancy, double red) {
    int *ww = neigh[v] + k;
    int w = *ww;
    int k2 = 0;
    // Is neigh[v][k] a new edge ?
    if (k >= newdeg[v]) {
        int *p = neigh[v] + (newdeg[v]++);
        *ww = *p;
        *p = w;
        // Now, add the dual edge
        ww = neigh[w];
        p = ww + (newdeg[w]);
        while (ww != p && *ww != v) {
            ww++;
            k2++;
        }
        if (ww == p) {
            // dual edge was not discovered.. search it and add it.
            while (*ww != v) {
                ww++;
                k2++;
            }
            *ww = *p;
            *p = v;
            newdeg[w]++;
        }
    }
    // if edge redudancy is asked, look for dual edge
    else if (edge_redudancy != NULL)
        for (int *ww = neigh[w]; * (ww++) != v; k2++) { }
    // add edge redudancy
    if (edge_redudancy != NULL) {
        edge_redudancy[v][k]  += red;
        edge_redudancy[w][k2] += red;
    }
    assert(newdeg[v] <= deg[v]);
}

// dist[] MUST be full of zeros !!!!
int graph_molloy_opt::breadth_path_search(int src, int *buff, double *paths, unsigned char *dist) {
    unsigned char last_dist = 0;
    unsigned char curr_dist = 1;
    int *to_visit = buff;
    int *visited  = buff;
    *(to_visit++) = src;
    paths[src] = 1.0;
    dist[src]  = curr_dist;
    int nb_visited = 1;
    while (visited != to_visit) {
        int v = *(visited++);
        if (last_dist == (curr_dist = dist[v])) {
            break;
        }
        unsigned char nd = next_dist(curr_dist);
        int *ww = neigh[v];
        double p = paths[v];
        for (int k = deg[v]; k--;) {
            int w = *(ww++);
            unsigned char d = dist[w];
            if (d == 0) {
                // not visited yet !
                *(to_visit++) = w;
                dist[w] = nd;
                paths[w] = p;
                // is it the last one ?
                if (++nb_visited == n) {
                    last_dist = nd;
                }
            } else if (d == nd) {
                if ((paths[w] += p) == numeric_limits::infinity()) {
                    IGRAPH_ERROR("Fatal error : too many (>MAX_DOUBLE) possible"
                                 " paths in graph", IGRAPH_EOVERFLOW);
                }
            }
        }
    }
    assert(to_visit == buff + nb_visited);
    return nb_visited;
}

// dist[] MUST be full of zeros !!!!
void graph_molloy_opt::explore_usp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg, double **edge_redudancy) {

    while (--nb_vertices) {
        int v = buff[nb_vertices];
        if (target[v] > 0.0) {
            unsigned char pd = prev_dist(dist[v]);
            int *ww = neigh[v];
            int k = 0;
            // pick ONE father at random
            double father_index = my_random01() * paths[v];
            double f = 0.0;
            int father = -1;
            while (f < father_index) {
                while (dist[father = ww[k++]] != pd) { }
                f += paths[father];
            }
            // increase target[] of father
            target[father] += target[v];
            // add edge, if necessary
            if (newdeg != NULL) {
                add_traceroute_edge(v, k - 1, newdeg, edge_redudancy, target[v]);
            }
        }
        // clear dist[]
        dist[v] = 0;
    }
    dist[buff[0]] = 0;
}

// dist[] MUST be full of zeros !!!!
void graph_molloy_opt::explore_asp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg, double **edge_redudancy) {

    while (--nb_vertices) {
        int v = buff[nb_vertices];
        if (target[v] > 0.0) {
            unsigned char pd = prev_dist(dist[v]);
            int *ww = neigh[v];
            int dv = deg[v];
            double f = target[v] / paths[v];
            // pick ALL fathers
            int father;
            for (int k = 0; k < dv; k++) if (dist[father = ww[k]] == pd) {
                    // increase target[] of father
                    target[father] += paths[father] * f;
                    // add edge, if necessary
                    if (newdeg != NULL) {
                        add_traceroute_edge(v, k, newdeg, edge_redudancy, target[v]);
                    }
                }
        }
        // clear dist[]
        dist[v] = 0;
    }
    dist[buff[0]] = 0;
}

// dist[] MUST be full of zeros !!!!
void graph_molloy_opt::explore_rsp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg, double** edge_redudancy) {

    while (--nb_vertices) {
        int v = buff[nb_vertices];
        if (target[v] > 0.0) {
            unsigned char pd = prev_dist(dist[v]);
            int *ww = neigh[v];
            // for all fathers : do we take it ?
            int paths_left = int(target[v]);
            double father_index = paths[v];
            int father;
            for (int k = 0; k < deg[v]; k++) if (dist[father = ww[k]] == pd) {
                    double pf = paths[father];
                    int to_add_to_father = my_binomial(pf / father_index, paths_left);
                    father_index -= pf;
                    if (to_add_to_father > 0) {
                        paths_left -= to_add_to_father;
                        // increase target[] of father
                        target[father] += to_add_to_father;
                        // add edge, if necessary
                        if (newdeg != NULL) {
                            add_traceroute_edge(v, k, newdeg, edge_redudancy, target[v]);
                        }
                    }
                }
        }
        // clear dist[]
        dist[v] = 0;
    }
    dist[buff[0]] = 0;
}

double *graph_molloy_opt::vertex_betweenness(int mode, bool trivial_paths) {
    char MODES[3] = {'U', 'A', 'R'};
    igraph_statusf("Computing vertex betweenness %cSP...", 0, MODES[mode]);

    // breadth-first search vertex fifo
    int *buff = new int[n];
    // breadth-first search path count
    double *paths = new double[n];
    // breadth-first search distance vector
    unsigned char *dist = new unsigned char[n];
    // global betweenness
    double *b = new double[n];
    // local betweenness (for one source)
    double *target = new double[n];
    // init all
    int progress = 0;
    memset(dist, 0, sizeof(unsigned char)*n);
    for (double *yo = target + n; (yo--) != target; *yo = 1.0) { }
    for (double *yo = b + n; (yo--) != b; *yo = 0.0) { }

    int progress_steps = max(1000, n / 10);
    // Main loop
    for (int v0 = 0; v0 < n; v0++) {
        // Verbose
        if (v0 > (progress * n) / progress_steps) {
            progress++;
            igraph_progressf("Computing vertex betweenness %cSP",
                             100.0 * double(progress) / double(progress_steps), 0,
                             MODES[mode]);
        }
        // Breadth-first search
        int nb_vertices = breadth_path_search(v0, buff, paths, dist);
        // initialize target[vertices in component] to 1
        //for(int *yo = buff+nb_vertices; (yo--)!=buff; target[*yo]=1.0);
        // backwards-cumulative exploration
        switch (mode) {
        case MODE_USP:
            explore_usp(target, nb_vertices, buff, paths, dist); break;
        case MODE_ASP:
            explore_asp(target, nb_vertices, buff, paths, dist); break;
        case MODE_RSP:
            explore_rsp(target, nb_vertices, buff, paths, dist); break;
        default:
            IGRAPH_WARNING("graph_molloy_opt::vertex_betweenness() "
                           "called with Invalid Mode");
        }
        // add targets[vertices in component] to global betweenness and reset targets[]
        if (nb_vertices == n) {
            // cache optimization if all vertices are in component
            double *bb = b;
            double *tt_end = target + n;
            if (trivial_paths) for (double *yo = target; yo != tt_end; * (bb++) += *(yo++)) {}
            else {
                for (double *yo = target; yo != tt_end; * (bb++) += (*(yo++) - 1.0)) { }
                b[*buff] -= (target[*buff] - 1.0);
            }
            for (double *yo = target; yo != tt_end; * (yo++) = 1.0) { }
        } else {
            if (trivial_paths)
                for (int *yo = buff + nb_vertices; (yo--) != buff; b[*yo] += target[*yo]) { }
            else
                for (int *yo = buff + nb_vertices; (--yo) != buff; b[*yo] += (target[*yo] - 1.0)) { }
            for (int *yo = buff + nb_vertices; (yo--) != buff; target[*yo] = 1.0) { }
        }
    }
    // Clean all & return
    delete[] target;
    delete[] dist;
    delete[] buff;
    delete[] paths;
    igraph_status("Done\n", 0);
    return b;
}

double graph_molloy_opt::traceroute_sample(int mode, int nb_src, int *src, int nb_dst, int* dst, double *redudancy, double **edge_redudancy) {
    // verify & verbose
    assert(verify());
    char MODES[3] = {'U', 'A', 'R'};
    igraph_statusf("traceroute %cSP on G(N=%d,M=%d) with %d src and %d dst...",
                   0, MODES[mode], nbvertices_real(), nbarcs(), nb_src, nb_dst);

    // create dst[] buffer if necessary
    bool newdist = dst == NULL;
    if (newdist) {
        dst = new int[n];
    }
    // breadth-first search vertex fifo
    int *buff = new int[n];
    // breadth-first search path count
    double *paths = new double[n];
    // breadth-first search distance vector
    unsigned char *dist = new unsigned char[n];
    // newdeg[] allows to tag discovered edges
    int *newdeg = new int[n];
    // target[v] is > 0 if v is a destination
    double *target = new double[n];

    // init all
    int i;
    memset(dist, 0, sizeof(unsigned char)*n);
    memset(newdeg, 0, sizeof(int)*n);
    for (double *yo = target + n; (yo--) != target; *yo = 0.0) { }
    if (redudancy != NULL)
        for (double *yo = redudancy + n; (yo--) != redudancy; *yo = 0.0) { }

    // src_0 counts the number of sources having degree 0
    int src_0 = 0;
    // nopath counts the number of pairs (src,dst) having no possible path
    int nopath = 0;
    // nb_paths & total_dist are for the average distance estimator
    int nb_paths = 0;
    double total_dist = 0;
    // s will be the current source
    int s;

    while (nb_src--) if (deg[s = *(src++)] == 0) {
            src_0++;
        } else {
            // breadth-first search
            int nb_vertices = breadth_path_search(s, buff, paths, dist);
            // do we have to pick new destinations ?
            if (newdist) {
                pick_random_dst(double(nb_dst), NULL, dst);
            }
            // mark reachable destinations as "targets"
            for (i = 0; i < nb_dst; i++) {
                if (dist[dst[i]] != 0) {
                    target[dst[i]] = 1.0;
                } else {
                    nopath++;
                }
            }
            // compute avg_dist estimator
            int current_dist = 0;
            unsigned char curr_dist = 1;
            for (int p = 1; p < nb_vertices; p++) {
                int v = buff[p];
                if (dist[v] != curr_dist) {
                    curr_dist = dist[v];
                    current_dist++;
                }
                if (target[v] > 0.0) {
                    total_dist += double(current_dist);
                    nb_paths++;
                }
            }
            // substract target[] to redudancy if needed
            if (redudancy != NULL) for (i = 1; i < nb_vertices; i++) {
                    redudancy[buff[i]] -= (target[buff[i]]);
                }
            // traceroute exploration
            switch (mode) {
            case MODE_USP:
                explore_usp(target, nb_vertices, buff, paths, dist, newdeg, edge_redudancy); break;
            case MODE_ASP:
                explore_asp(target, nb_vertices, buff, paths, dist, newdeg, edge_redudancy); break;
            case MODE_RSP:
                explore_rsp(target, nb_vertices, buff, paths, dist, newdeg, edge_redudancy); break;
            default:
                IGRAPH_WARNING("graph_molloy_opt::traceroute_sample() called "
                               "with Invalid Mode");
            }
            // add target[] to redudancy[] if needed
            if (redudancy != NULL) for (i = 1; i < nb_vertices; i++) {
                    redudancy[buff[i]] += (target[buff[i]]);
                }
            // clear target[]
            for (int *yo = buff + nb_vertices; yo-- != buff; target[*yo] = 0.0) { }
        }
    // update degrees
    for (i = 0; i < n; i++) {
        deg[i] = newdeg[i];
    }
    refresh_nbarcs();
    // clean all
    delete[] buff;
    delete[] paths;
    delete[] dist;
    delete[] newdeg;
    delete[] target;
    if (newdist) {
        delete[] dst;
    }
    {
        igraph_statusf("discovered %d vertices and %d edges\n", 0,
                       nbvertices_real(), nbarcs());
        if (src_0)  igraph_warningf("%d sources had degree 0\n", IGRAPH_FILE_BASENAME,
                                        __LINE__, -1, src_0);
        if (nopath) igraph_warningf("%d (src,dst) pairs had no possible path\n",
                                        IGRAPH_FILE_BASENAME, __LINE__, -1, nopath);
    }
    return total_dist / double(nb_paths);
}

int graph_molloy_opt::disconnecting_edges() {
    int removed = 0;
    while (is_connected()) {
        // replace random edge by loops
        int i;
        do {
            i = pick_random_vertex();
        } while (i < 0 || deg[i] < 1);
        int *p = neigh[i] + (my_random() % deg[i]);
        int j = *p; *p = i;
        fast_rpl(neigh[j], i, j);
        removed++;
    }
    return removed;
}

void graph_molloy_opt::vertex_covering() {
    vertex_cover(n, links, deg, neigh);
}


// optimisations a faire :
// 1/ arreter le breadth-first search qd on a vu toutes les dst
// 2/ faire une seule redescente pour toutes les dst.

double graph_molloy_opt::path_sampling(int *nb_dst, int *dst, double* redudancies, double **edge_redudancies) {
    assert(verify());
    // do we have to store the destinations (for one src) in a temp buffer?
    bool NOMEM = (dst == NULL);
    if (NOMEM) {
        dst = new int[n];
    }
    int i;
    int next_step = n + 1;
    {
        igraph_status("Sampling paths", 0);
        next_step = 0;
    }
    // breadth-first search buffers buff[] and dist[]
    int *buff = new int[n];
    unsigned char *dist = new unsigned char[n];
    for (i = 0; i < n; i++) {
        dist[i] = 0;
    }
    // nb_pos[] counts the number of possible paths to get to a vertex
    int *nb_pos = new int[n];
    for (i = 0; i < n; i++) {
        nb_pos[i] = 0;
    }
    // newdeg[i] is the number of edges of vertex i "seen" by traceroute
    int *newdeg = new int[n];
    for (i = 0; i < n; i++) {
        newdeg[i] = 0;
    }

    // src_0 counts the number of sources having degree 0
    int src_0 = 0;
    // nopath counts the number of pairs (src,dst) having no possible path
    int nopath = 0;
    // nb_paths & total_dist are for the average distance estimator
    int nb_paths = 0;
    unsigned int total_dist = 0;
    unsigned int total_dist64 = 0;

    // s is the source of the breadth-first search
    for (int s = 0; s < n; s++) if (nb_dst[s] > 0) {
            if (deg[s] == 0) {
                src_0++;
            } else {
                if (s > next_step) {
                    next_step = s + (n / 1000) + 1;
                    igraph_progress("Sampling paths", double(s) / double(n), 0);
                }
                int v;
                // breadth-first search
                int *to_visit = buff;
                int *visited = buff;
                *(to_visit++) = s;
                dist[s] = 1;
                nb_pos[s] = 1;
                while (visited != to_visit) {
                    v = *(visited++);
                    unsigned char n_dist = next_dist(dist[v]);
                    int *w0 = neigh[v];
                    for (int *w = w0 + deg[v]; w-- != w0; ) {
                        unsigned char d2 = dist[*w];
                        if (d2 == 0) {
                            dist[*w] = d2 = n_dist;
                            *(to_visit++) = *w;
                        }
                        if (d2 == n_dist) {
                            nb_pos[*w] += nb_pos[v];
                        }
                    }
                }

                // for every target, pick a random path.
                int t_index = nb_dst[s];
                // create dst[] if necessary
                if (NOMEM) {
                    pick_random_src(double(t_index), NULL, dst);
                }
                while (t_index--) if (dist[v = *(dst++)] == 0) {
                        nopath++;
                    } else {
#ifdef DEGSEQ_VL_DEBUG
                        igraph_statusf("Sampling path %d -> %d\n", 0, s, v);
#endif // DEGSEQ_VL_DEBUG
                        nb_paths++;
                        // while we haven't reached the source..
                        while (v != s) {
                            // pick a random father
                            int index = my_random() % nb_pos[v];
                            unsigned char p_dist = prev_dist(dist[v]);
                            int *w = neigh[v];
                            int k = 0;
                            int new_father;
                            while (dist[new_father = w[k]] != p_dist || (index -= nb_pos[new_father]) >= 0) {
                                k++;
                            }
                            // add edge
                            add_traceroute_edge(v, k, newdeg, edge_redudancies, 1.0);
                            if (redudancies != NULL && new_father != s) {
                                redudancies[new_father] += 1.0;
                            }
                            // step down to father
                            v = new_father;
                            // increase total distance
                            total_dist++;
                            if (total_dist == 0) {
                                total_dist64++;
                            }
                        }
                    }
                // reset (int *)dst if necessary
                if (NOMEM) {
                    dst -= nb_dst[s];
                }

                // clear breadth-first search buffers
                while (visited != buff) {
                    v = *(--visited);
                    dist[v] = 0;
                    nb_pos[v] = 0;
                }
            }
        }
    // update degrees
    for (i = 0; i < n; i++) {
        deg[i] = newdeg[i];
    }
    refresh_nbarcs();
    // clean
    delete[] newdeg;
    delete[] buff;
    delete[] dist;
    delete[] nb_pos;
    if (NOMEM) {
        delete[] dst;
    }
    if (VERBOSE()) {
        igraph_status("Sampling paths :  Done   \n", 0);
        if (src_0)  igraph_warningf("%d sources had degree 0", IGRAPH_FILE_BASENAME,
                                        __LINE__, -1, src_0);
        if (nopath) igraph_warningf("%d (src,dst) pairs had no possible path",
                                        IGRAPH_FILE_BASENAME, __LINE__, -1, nopath);
    }
    double tdist = double(total_dist64);
    if (total_dist64 > 0) {
        tdist *= 4294967296.0;
    }
    tdist += double(total_dist);
    return tdist / double(nb_paths);
}

int *graph_molloy_opt::vertices_real(int &nb_v) {
    int *yo;
    if (nb_v < 0) {
        nb_v = 0;
        for (yo = deg; yo != deg + n; ) if (*(yo++) > 0) {
                nb_v++;
            }
    }
    if (nb_v == 0) {
        IGRAPH_WARNING("graph is empty");
        return NULL;
    }
    int *buff = new int[nb_v];
    yo = buff;
    for (int i = 0; i < n; i++) if (deg[i] > 0) {
            *(yo++) = i;
        }
    if (yo != buff + nb_v) {
        igraph_warningf("wrong #vertices in graph_molloy_opt::vertices_real(%d)",
                        IGRAPH_FILE_BASENAME, __LINE__, -1, nb_v);
        delete[] buff;
        return NULL;
    } else {
        return buff;
    }
}

int *graph_molloy_opt::pick_random_vertices(int &k, int *output, int nb_v, int *among) {
    int i;
    bool CREATED_AMONG = false;
    if (among == NULL && k > 0) {
        among = vertices_real(nb_v);
        CREATED_AMONG = true;
    }
    if (k > nb_v) {
        igraph_warningf("Warning : tried to pick %d among %d vertices. "
                        "Picked only %d", IGRAPH_FILE_BASENAME, __LINE__, -1, k, nb_v, nb_v);
        k = nb_v;
    }
    if (k > 0) {
        if (output == NULL) {
            output = new int[k];
        }
        for (i = 0; i < k; i++) {
            int tmp = i + my_random() % (nb_v - i);
            output[i] = among[tmp];
            among[tmp] = among[i];
            among[i] = output[i];
        }
    }
    if (CREATED_AMONG) {
        delete[] among;
    }
    return output;
}

int *graph_molloy_opt::pick_random_src(double k, int *nb, int* buff, int nb_v, int* among) {
    bool AMONG_CREATED = false;
    if (among == NULL || nb_v < 0) {
        AMONG_CREATED = true;
        among = vertices_real(nb_v);
    }
    int kk = int(floor(0.5 + (k >= 1.0 ? k : k * double(nb_v))));
    if (kk == 0) {
        kk = 1;
    }
    int *yo = pick_random_vertices(kk, buff, nb_v, among);
    if (nb != NULL) {
        *nb = kk;
    }
    if (AMONG_CREATED) {
        delete[] among;
    }
    return yo;
}

int *graph_molloy_opt::pick_random_dst(double k, int *nb, int* buff, int nb_v, int* among) {
    bool AMONG_CREATED = false;
    if (among == NULL || nb_v < 0) {
        AMONG_CREATED = true;
        among = vertices_real(nb_v);
    }
    int kk = int(floor(0.5 + (k > 1.0 ? k : k * double(nb_v))));
    if (kk == 0) {
        kk = 1;
    }
    int *yo = pick_random_vertices(kk, buff, nb_v, among);
    if (nb != NULL) {
        *nb = kk;
    }
    if (AMONG_CREATED) {
        delete[] among;
    }
    return yo;
}

int graph_molloy_opt::core() {
    box_list b(n, deg);
    int v;
    int removed = 0;
    while ((v = b.get_one()) >= 0) {
        b.pop_vertex(v, neigh);
        deg[v] = 0;
        removed++;
    }
    refresh_nbarcs();
    return removed;
}

int graph_molloy_opt::try_disconnect(int K, int max_tries) {
    bool *visited = new bool[n];
    for (bool *p = visited + n; p != visited; * (--p) = false) { }
    int *Kbuff = new int[K];
    int tries = 0;
    int next_step = -1;
    if (VERBOSE()) {
        next_step = 0;
    }
    bool yo = true;
    while (yo && tries < max_tries) {
        if (tries == next_step) {
            igraph_statusf("Trying to disconnect the graph... "
                           "%d edges swaps done so far", 0, tries);
            next_step += 100;
        }
        int v1 = pick_random_vertex();
        int v2 = pick_random_vertex();
        int w1 = *(random_neighbour(v1));
        int w2 = *(random_neighbour(v2));
        if (swap_edges_simple(v1, w1, v2, w2)) {
            tries++;
            yo = (!isolated(v1, K, Kbuff, visited) && !isolated(v2, K, Kbuff, visited) && !is_connected());
            swap_edges(v1, w2, v2, w1);
        }
    }
    delete[] visited;
    delete[] Kbuff;
    return tries;
}

bool graph_molloy_opt::isolated(int v, int K, int *Kbuff, bool *visited) {
    if (K < 2) {
        return false;
    }
#ifdef OPT_ISOLATED
    if (K <= deg[v] + 1) {
        return false;
    }
#endif //OPT_ISOLATED
    int *seen  = Kbuff;
    int *known = Kbuff;
    int *max   = Kbuff + (K - 1);
    *(known++) = v;
    visited[v] = true;
    bool is_isolated = true;

    while (known != seen) {
        v = *(seen++);
        int *w = neigh[v];
        for (int d = deg[v]; d--; w++) if (!visited[*w]) {
#ifdef OPT_ISOLATED
                if (K <= deg[*w] + 1 || known == max) {
#else //OPT_ISOLATED
                if (known == max) {
#endif //OPT_ISOLATED
                    is_isolated = false;
                    goto end_isolated;
                }
                visited[*w] = true;
                *(known++) = *w;
            }
    }
end_isolated:
    // Undo the changes to visited[]...
    while (known != Kbuff) {
        visited[*(--known)] = false;
    }
    return is_isolated;
}

double graph_molloy_opt::rho(int mode, int nb_src, int *src, int nb_dst, int *dst) {
    assert(verify());

    // create dst[] buffer if necessary
    bool newdist = dst == NULL;
    if (newdist) {
        dst = new int[n];
    }
    // breadth-first search vertex fifo
    int *buff = new int[n];
    // breadth-first search path count
    double *paths = new double[n];
    // breadth-first search distance vector
    unsigned char *dist = new unsigned char[n];
    // target[v] is > 0 if v is a destination
    double *target = new double[n];
    // times_seen count the times we saw each vertex
    int *times_seen = new int[n];

    // init all
    int i;
    memset(dist, 0, sizeof(unsigned char)*n);
    memset(times_seen, 0, sizeof(int)*n);
    for (double *yo = target + n; (yo--) != target; *yo = 0.0) { }

    // src_0 counts the number of sources having degree 0
    int src_0 = 0;
    // nopath counts the number of pairs (src,dst) having no possible path
    int nopath = 0;
    // s will be the current source
    int s;

    for (int nsrc = 0; nsrc < nb_src; nsrc++) if (deg[s = *(src++)] == 0) {
            src_0++;
        } else {
            // breadth-first search
            int nb_vertices = breadth_path_search(s, buff, paths, dist);
            // do we have to pick new destinations ?
            if (newdist) {
                pick_random_dst(double(nb_dst), NULL, dst);
            }
            // mark reachable destinations as "targets" and substract one time_seen
            for (i = 0; i < nb_dst; i++) {
                if (dist[dst[i]] != 0) {
                    target[dst[i]] = 1.0;
                } else {
                    nopath++;
                }
            }
            // traceroute exploration
            switch (mode) {
            case MODE_USP:
                explore_usp(target, nb_vertices, buff, paths, dist); break;
            case MODE_ASP:
                explore_asp(target, nb_vertices, buff, paths, dist); break;
            case MODE_RSP:
                explore_rsp(target, nb_vertices, buff, paths, dist); break;
            default:
                IGRAPH_WARNING("graph_molloy_opt::rho() called with Invalid Mode");
            }
            // remove destinations that weren't discovered by a path coming through
            for (i = 0; i < nb_dst; i++) {
                int yo = dst[i];
                if (target[yo] == 1.0) {
                    target[yo] = 0.0;
                }
            }
            // add target[] to times_seen[]
            for (i = 1; i < nb_vertices; i++) {
                int yo = buff[i];
                if (target[yo] != 0.0) {
                    target[yo] = 0.0;
                    times_seen[yo]++;
                }
            }
            // also clear  the source
            target[buff[0]] = 0.0;
        }
    // clean all
    delete[] buff;
    delete[] paths;
    delete[] dist;
    delete[] target;
    if (newdist) {
        delete[] dst;
    }
    // compute rho
    double sum_nij = 0.0;
    double sum_ni = 0.0;
    for (i = 0; i < n; i++) {
        double d = double(times_seen[i]);
        sum_ni += d;
        sum_nij += d * d;
    }
    delete[] times_seen;
    {
        igraph_status("done\n", 0);
        if (src_0)  igraph_warningf("%d sources had degree 0", IGRAPH_FILE_BASENAME, __LINE__,
                                        -1, src_0);
        if (nopath) igraph_warningf("%d (src,dst) pairs had no possible path",
                                        IGRAPH_FILE_BASENAME, __LINE__, -1, nopath);
    }
    return (sum_nij - sum_ni) * double(n) * double(nb_src) / (sum_ni * sum_ni * double(nb_src - 1));
}

void graph_molloy_opt::sort() {
    for (int v = 0; v < n; v++) {
        qsort(neigh[v], deg[v]);
    }
}

int* graph_molloy_opt::sort_vertices(int *buff) {
    // pre-sort vertices by degrees
    buff = boxsort(deg, n, buff);
    // sort vertices having the same degrees
    int i = 0;
    while (i < n) {
        int d = deg[buff[i]];
        int j = i + 1;
        while (j < n && deg[buff[j]] == d) {
            j++;
        }
        lex_qsort(neigh, buff + i, j - i, d);
        i = j;
    }
    return buff;
}

int graph_molloy_opt::cycles(int v) {
    return v;
}

// void graph_molloy_opt::remove_vertex(int v) {
//   fprintf(stderr,"Warning : graph_molloy_opt::remove_vertex(%d) called",v);
// }

bool graph_molloy_opt::verify(int mode) {
    IGRAPH_UNUSED(mode);
#ifndef NDEBUG
    int i, j, k;
    assert(neigh[0] == links);
    // verify edges count
    if ((mode & VERIFY_NOARCS) == 0) {
        int sum = 0;
        for (i = 0; i < n; i++) {
            sum += deg[i];
        }
        assert(sum == a);
    }
    // verify neigh[] and deg[] compatibility
    if ((mode & VERIFY_NONEIGH) == 0)
        for (i = 0; i < n - 1; i++) {
            assert(neigh[i] + deg[i] == neigh[i + 1]);
        }
    // verify vertex range
    for (i = 0; i < a; i++) {
        assert(links[i] >= 0 && links[i] < n);
    }
    // verify simplicity
//  for(i=0; i 0);
        }
#endif
    return true;
}

/*___________________________________________________________________________________
  Not to use anymore : use graph_molloy_hash class instead

void graph_molloy_opt::shuffle(long times) {
  while(times) {
    int f1 = links[my_random()%a];
    int f2 = links[my_random()%a];
    int t1 = neigh[f1][my_random()%deg[f1]];
    int t2 = neigh[f2][my_random()%deg[f2]];
    if(swap_edges_simple(f1,t1,f2,t2)) times--;
  }
}


long graph_molloy_opt::connected_shuffle(long times) {
  //assert(verify());
#ifdef PERFORMANCE_MONITOR
  long failures = 0;
  long successes = 0;
  double avg_K = 0.0;
  long avg_T = 0;
#endif //PERFORMANCE_MONITOR

  long nb_swaps = 0;
  long T = min(a,times)/10;
  double double_K = 1.0;
  int K = int(double_K);
  double Q1 = 1.35;
  double Q2 = 1.01;
  int *Kbuff = new int[K];
  bool *visited = new bool[n];
  for(int i=0; inb_swaps) {
    // Backup graph
#ifdef PERFORMANCE_MONITOR
    avg_K+=double_K;
    avg_T+=T;
#endif //PERFORMANCE_MONITOR
    int *save = backup();
    //assert(verify());
    // Swaps
    long swaps = 0;
    for(int i=T; i>0; i--) {
      // Pick two random vertices
      int f1 = pick_random_vertex();
      int f2 = pick_random_vertex();
      if(f1==f2) continue;
      // Pick two random neighbours
      int *f1t1 = random_neighbour(f1);
      int t1 = *f1t1;
      int *f2t2 = random_neighbour(f2);
      int t2 = *f2t2;
      // test simplicity
      if(t1!=t2 && f1!=t2 && f2!=t1 && !is_edge(f1,t2) && !is_edge(f2,t1)) {
        // swap
        *f1t1 = t2;
        *f2t2 = t1;
        int *t1f1 = fast_rpl(neigh[t1],f1,f2);
        int *t2f2 = fast_rpl(neigh[t2],f2,f1);
        // isolation test
        if(isolated(f1, K, Kbuff, visited) || isolated(f2, K, Kbuff, visited)) {
          // undo swap
          *t1f1 = f1; *t2f2 = f2; *f1t1 = t1; *f2t2 = t2;
        }
        else swaps++;
      }
    }
    //assert(verify());
    // test connectivity
    bool ok = is_connected();
#ifdef PERFORMANCE_MONITOR
    if(ok) successes++; else failures++;
#endif //PERFORMANCE_MONITOR
    if(ok) {
      nb_swaps += swaps;
      // adjust K and T
      if((K+10)*T>5*a) {
        double_K/=Q2;
        K = int(double_K);
      }
      else T*=2;
    }
    else {
      restore(save);
      //assert(verify());
      double_K*=Q1;
      K = int(double_K);
      delete[] Kbuff;
      Kbuff = new int[K];
    }
    delete[] save;
  }
#ifdef PERFORMANCE_MONITOR
    fprintf(stderr,"\n*** Performance Monitor ***\n");
    fprintf(stderr," - Connectivity test successes : %ld\n",successes);
    fprintf(stderr," - Connectivity test failures  : %ld\n",failures);
    fprintf(stderr," - Average window : %ld\n",avg_T/long(successes+failures));
    fprintf(stderr," - Average isolation test width : %f\n",avg_K/double(successes+failures));
#endif //PERFORMANCE_MONITOR
  return nb_swaps;
}

bool graph_molloy_opt::try_shuffle(int T, int K) {
    int i;
    int *Kbuff = NULL;
    if(K>0) Kbuff = new int[K];
    bool *visited = new bool[n];
    for(i=0; i0; i--) {
      // Pick two random vertices
      int f1 = pick_random_vertex();
      int f2 = pick_random_vertex();
      if(f1==f2) continue;
      // Pick two random neighbours
      int *f1t1 = random_neighbour(f1);
      int t1 = *f1t1;
      int *f2t2 = random_neighbour(f2);
      int t2 = *f2t2;
      // test simplicity
      if(t1!=t2 && f1!=t2 && f2!=t1 && is_edge(f1,t2) && !is_edge(f2,t1)) {
        // swap
        *f1t1 = t2;
        *f2t2 = t1;
        int *t1f1 = fast_rpl(neigh[t1],f1,f2);
        int *t2f2 = fast_rpl(neigh[t2],f2,f1);
        // isolation test
        if(isolated(f1, K, Kbuff, visited) || isolated(f2, K, Kbuff, visited)) {
          // undo swap
          *t1f1 = f1; *t2f2 = f2; *f1t1 = t1; *f2t2 = t2;
        }
      }
    }
    delete[] visited;
    if(Kbuff != NULL) delete[] Kbuff;
    bool yo = is_connected();
    restore(back);
    delete[] back;
    return yo;
}

double graph_molloy_opt::window(int K, double ratio) {
  int steps = 100;
  double T = double(a*10);
  double q2 = 0.1;
  double q1 = pow(q2,(ratio-1.0)/ratio);

  int failures = 0;
  int successes = 0;
  int *Kbuff = new int[K];
  bool *visited = new bool[n];

  while(successes<10*steps) {
    int *back=backup();
    for(int i=int(T); i>0; i--) {
      // Pick two random vertices
      int f1 = links[my_random()%a];
      int f2 = links[my_random()%a];
      if(f1==f2) continue;
      // Pick two random neighbours
      int *f1t1 = neigh[f1]+my_random()%deg[f1];
      int *f2t2 = neigh[f2]+my_random()%deg[f2];
      int t1 = *f1t1;
      int t2 = *f2t2;
      // test simplicity
      if(t1!=t2 && f1!=t2 && f2!=t1 && is_edge(f1,t2) && !is_edge(f2,t1)) {
        // swap
        *f1t1 = t2;
        *f2t2 = t1;
        int *t1f1 = fast_rpl(neigh[t1],f1,f2);
        int *t2f2 = fast_rpl(neigh[t2],f2,f1);
        // isolation test
        if(isolated(f1, K, Kbuff, visited) || isolated(f2, K, Kbuff, visited)) {
          // undo swap
          *t1f1 = f1; *t2f2 = f2; *f1t1 = t1; *f2t2 = t2;
        }
      }
    }
    if(is_connected()) {
      T *= q1;
      if(T>double(5*a)) T=double(5*a);
      successes++;
      if((successes%steps)==0) {
        q2 = sqrt(q2);
        q1 = sqrt(q1);
      }
    }
    else {
      T*=q2;
      failures++;
    }
    if(VERBOSE()) fprintf(stderr,".");
    restore(back);
    delete[] back;
  }
  delete[] Kbuff;
  delete[] visited;
  if(VERBOSE()) fprintf(stderr,"Failures:%d   Successes:%d\n",failures, successes);
  return T;
}


double graph_molloy_opt::eval_K(int quality) {
  double K = 5.0;
  double avg_K = 1.0;
  for(int i=quality; i--; ) {
    int int_K = int(floor(K+0.5));
    if(try_shuffle(a/(int_K+1),int_K)) {
      K*=0.8; fprintf(stderr,"+"); }
    else {
      K*=1.25; fprintf(stderr,"-"); }
    if(ideg[t2] ? f1 : t2, K, Kbuff, visited);
    sum_K += effective_isolated(deg[f2]>deg[t1] ? f2 : t1, K, Kbuff, visited);
    // undo swap
    swap_edges(f1,t2,f2,t1);
//    assert(verify());
  }
  delete[] Kbuff;
  delete[] visited;
  return double(sum_K)/double(2*quality);
}


//___________________________________________________________________________________
*/



/***** NOT USED ANYMORE (Modif 22/04/2005) ******

int64_t *graph_molloy_opt::vertex_betweenness_usp(bool trivial_paths) {
  if(VERBOSE()) fprintf(stderr,"Computing vertex betweenness USP...");
  int i;
  unsigned char *dist = new unsigned char[n];
  int *buff = new int[n];
  int64_t *b = new int64_t[n];
  int *bb = new int[n];
  int *dd = new int[max_degree()];
  for(i=0; i(progress*n)/1000) {
      progress++;
      fprintf(stderr,"\rComputing vertex betweenness USP : %d.%d%% ",progress/10,progress%10);
    }
    int nb_vertices = width_search(dist, buff, v0);
    int nv = nb_vertices;
    for(i=0; i(progress*n)/1000) {
      progress++;
      fprintf(stderr,"\rComputing vertex betweenness RSP : %d.%d%% ",progress/10,progress%10);
    }
    int nb_vertices = width_search(dist, buff, v0);
    int nv = nb_vertices;
    for(i=0; i1 && to_give>2*n_father) {
          int o = rng.binomial(1.0/n_father,to_give);
          to_give -= o;
          bb[dd[--n_father]]+=o;
        }
        if(n_father==1) bb[dd[0]]+=to_give;
        else {
          while(to_give--) bb[dd[my_random()%n_father]]++;
        }
      }
      if(trivial_paths) bb[v]++;
    }
    for(i=0; i0) {
    if(VERBOSE()==VERBOSE_LOTS && v0>(progress*n)/1000) {
      progress++;
      fprintf(stderr,"\rComputing vertex betweenness ASP : %d.%d%% ",progress/10,progress%10);
    }
    int nb_vertices = width_search(dist, buff, v0);
    if(!trivial_paths) dist[v0]=2;
    int nv = nb_vertices;
    for(i=0; i.
 */
#ifndef GRAPH_MOLLOY_OPT_H
#define GRAPH_MOLLOY_OPT_H

#include "gengraph_definitions.h"
#include "gengraph_degree_sequence.h"
#include "gengraph_qsort.h"

#include 
#include "gengraph_random.h"

namespace gengraph {

// This class handles graphs with a constant degree sequence.

class graph_molloy_opt {

private:
    // Random generator
    KW_RNG::RNG rng;
    // Number of vertices
    int n;
    //Number of arcs ( = #edges * 2 )
    int a;
    // The degree sequence of the graph
    int *deg;
    // The array containing all links
    int *links;
    // The array containing pointers to adjacency list of every vertices
    int **neigh;
    // Allocate memory according to degree_sequence (for constructor use only!!)
    void alloc(degree_sequence &);
    // Compute #edges
    inline void refresh_nbarcs() {
        a = 0;
        for (int* d = deg + n; d != deg; ) {
            a += *(--d);
        }
    }
    // Build neigh with deg and links
    void compute_neigh();
    // Swap edges. The swap MUST be valid !!!
    inline void swap_edges(int from1, int to1, int from2, int to2) {
        fast_rpl(neigh[from1], to1, to2);
        fast_rpl(neigh[from2], to2, to1);
        fast_rpl(neigh[to1], from1, from2);
        fast_rpl(neigh[to2], from2, from1);
    }

    // Swap edges only if they are simple. return false if unsuccessful.
    bool swap_edges_simple(int, int, int, int);
    // Test if vertex is in an isolated component of size dmax.
    void depth_isolated(int v, long &calls, int &left_to_explore, int dmax, int * &Kbuff, bool *visited);
    // breadth-first search. Store the distance (modulo 3)  in dist[]. Returns eplorated component size.
    int width_search(unsigned char *dist, int *buff, int v0 = 0, int toclear = -1);
    // depth-first search.
    int depth_search(bool *visited, int *buff, int v0 = 0);
    // breadth-first search that count the number of shortest paths going from src to each vertex
    int breadth_path_search(int src, int *buff, double *paths, unsigned char *dist);
    // Used by traceroute_sample() ONLY
    void add_traceroute_edge(int, int, int*, double** red = NULL, double t = 1.0);
    // Used by traceroute() and betweenness(). if newdeg[]=NULL, do not discover edges.
    // breadth_path_search() must have been called to give the corresponding buff[],dist[],paths[] and nb_vertices
    void explore_usp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg = NULL, double **edge_redudancy = NULL);
    void explore_asp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg = NULL, double **edge_redudancy = NULL);
    void explore_rsp(double *target, int nb_vertices, int *buff, double *paths, unsigned char *dist, int *newdeg = NULL, double **edge_redudancy = NULL);
    // Return component indexes where vertices belong to, starting from 0,
    // sorted by size (biggest component has index 0)
    int *components(int *comp = NULL);
    // pick k random vertices of degree > 0.
    int *pick_random_vertices(int &k, int *output = NULL, int nb_v = -1, int *among = NULL);

public:
    // neigh[]
    inline int** neighbors() {
        return neigh;
    };
    // deg[]
    inline int* degrees() {
        return deg;
    };
    //adjacency list of v
    inline int* operator[](const int v) {
        return neigh[v];
    };
    //degree of v
    inline int degree(const int v) {
        return deg[v];
    };
    //compare adjacency lists
    inline int compare(const int v, const int w) {
        return deg[v] == deg[w] ? lex_comp(neigh[v], neigh[w], deg[v]) : (deg[v] > deg[w] ? -1 : 1);
    };
    // Detach deg[] and neigh[]
    void detach();
    // Destroy deg and links
    ~graph_molloy_opt();
    // Create graph from file (stdin not supported unless rewind() possible)
    graph_molloy_opt(FILE *f);
    // Allocate memory for the graph. Create deg and links. No edge is created.
    graph_molloy_opt(degree_sequence &);
    // Create graph from hard copy
    graph_molloy_opt(int *);
    // Create hard copy of graph
    int *hard_copy();
    // Remove unused edges, updates neigh[], recreate links[]
    void clean();
    // nb arcs
    inline int nbarcs() {
        return a;
    };
    // last degree
    inline int last_degree() {
        return deg[n - 1];
    };
    // nb vertices
    inline int nbvertices() {
        return n;
    };
    // nb vertices having degree > 0
    inline int nbvertices_real() {
        int s = 0;
        for (int *d = deg + n; d-- != deg; ) if (*d) {
                s++;
            }
        return s;
    };
    // return list of vertices with degree > 0. Compute #vertices, if not given.
    int *vertices_real(int &nb_v);
    // Keep only giant component
    void giant_comp();
    // nb vertices in giant component
    int nbvertices_comp();
    // nb arcs in giant component
    int nbarcs_comp();
    // print graph in SUCC_LIST mode, in stdout
    void print(FILE *f = stdout, bool NOZERO = true);
    // Bind the graph avoiding multiple edges or self-edges (return false if fail)
    bool havelhakimi();
    // Get the graph connected  (return false if fail)
    bool make_connected();
    // Test if graph is connected
    bool is_connected();
    // Maximum degree
    int max_degree();
    // breadth-first search. Store the distance (modulo 3)  in dist[].
    void breadth_search(int *dist, int v0 = 0, int* buff = NULL);
    // is edge ?
    inline bool is_edge(const int u, const int v) {
        if (deg[v] < deg[u]) {
            return (fast_search(neigh[v], deg[v], u) != NULL);
        } else {
            return (fast_search(neigh[u], deg[u], v) != NULL);
        }
    }
    // Backup graph [sizeof(int) bytes per edge]
    int* backup(int *here = NULL);
    // Restore from backup. Assume that degrees haven't changed
    void restore(int* back);
    // Resplace with hard backup.
    void replace(int* _hardbackup);
    // Backup degs of graph
    int* backup_degs(int *here = NULL);
    // Restore degs from neigh[]. Need last degree, though
    void restore_degs(int last_degree);
    // Restore degs[] from backup. Assume that links[] has only been permuted
    void restore_degs_only(int* backup_degs);
    // Restore degs[] and neigh[]. Assume that links[] has only been permuted
    void restore_degs_and_neigh(int* backup_degs);
// WARNING : the following shuffle() algorithms are slow.
// Use graph_molloy_hash::connected_shuffle() instead.
    // "Fab" Shuffle (Optimized heuristic of Gkantsidis algo.)
    long fab_connected_shuffle(long);
    // "Optimized-Fab" Shuffle (Optimized heuristic of Gkantsidis algo, with isolated pairs)
    long opt_fab_connected_shuffle(long);
    // Gkantsidis Shuffle
    long gkantsidis_connected_shuffle(long);
    // Connected Shuffle
    long slow_connected_shuffle(long);
    // shortest paths where vertex is an extremity
    double *vertex_betweenness(int mode, bool trivial_path = false);
    // Sample the graph with traceroute-like exploration from src[] to dst[].
    // if dst[]=NULL, pick nb_dst new random destinations for each src
    double traceroute_sample(int mode, int nb_src, int *src, int nb_dst, int* dst, double *redudancy = NULL, double **edge_redudancy = NULL);
    // does one breadth-first search and returns the average_distance.
    double avg_dist(unsigned char *dist, int *buff, int v0, int &nb_vertices, int toclear = -1);
    // Number of edges needed to disconnect graph (one random instance)
    int disconnecting_edges();
    // Compute vertex covering of the graph. Warning : this modifies degs[]
    void vertex_covering();
    // Path sampling. Input is nb_dst[] and dst[]. nb_dst[v],dst[v] describe all paths (v,x)
    double path_sampling(int *nb_dst, int *dst = NULL, double *redudancies = NULL, double **edge_redudancy = NULL);
    // keep only core (tree parts are deleted). Returns number of removed vertices.
    int core();
    // try to disconnect the graph by swapping edges (with isolation tests)
    int try_disconnect(int K, int max_tries = 10000000);
    // Eric & Cun-Hui estimator
    double rho(int mode, int nb_src, int *src, int nb_dst, int *dst = NULL);
    // sort adjacency lists
    void sort();
    // sort the vertices according to their degrees (highest first) and to their adjacency lists (lexicographic)
    int* sort_vertices(int *buff = NULL);
    // count cycles passing through vertex v
    int cycles(int v);
    // remove vertex (i.e. remove all edges adjacent to vertex)
    void remove_vertex(int v);
    // pick k random vertices of degree > 0. If k \in [0,1[, k is understood as a density.
    int *pick_random_src(double k, int *nb = NULL, int* buff = NULL, int nb_v = -1, int* among = NULL);
    // pick k random vertices of degree > 0. If k \in [0,1], k is understood as a density.
    int *pick_random_dst(double k, int *nb = NULL, int* buff = NULL, int nb_v = -1, int* among = NULL);

    // For debug purposes : verify validity of the graph (symetry, simplicity)
#define VERIFY_NORMAL  0
#define VERIFY_NONEIGH 1
#define VERIFY_NOARCS  2
    bool verify(int mode = VERIFY_NORMAL);

    /*___________________________________________________________________________________
      Not to use anymore : use graph_molloy_hash class instead


    public:
      // Shuffle. returns number of swaps done.
      void shuffle(long);
      // Connected Shuffle
      long connected_shuffle(long);
      // Get caracteristic K
      double eval_K(int quality = 100);
      // Get effective K
      double effective_K(int K, int quality = 10000);
      // Test window
      double window(int K, double ratio);
      // Try to shuffle n times. Return true if at the end, the graph was still connected.
      bool try_shuffle(int T, int K);

    //___________________________________________________________________________________
    */

    /*___________________________________________________________________________________
      Not to use anymore : replaced by vertex_betweenness()     22/04/2005

      // shortest paths where vertex is an extremity
      long long *vertex_betweenness_usp(bool trivial_path);
      // shortest paths where vertex is an extremity
      long long *vertex_betweenness_rsp(bool trivial_path);
      // same, but when multiple shortest path are possible, average the weights.
      double *vertex_betweenness_asp(bool trivial_path);
    //___________________________________________________________________________________
    */

};

} // namespace gengraph

#endif //GRAPH_MOLLOY_OPT_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_hash.h0000644000175100001710000002126000000000000030331 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef HASH_H
#define HASH_H

#include 
#include "gengraph_definitions.h"

//_________________________________________________________________________
// Hash table profiling... Active only if definition below is uncommented
//_________________________________________________________________________
//#define _HASH_PROFILE

namespace gengraph {

#ifdef _HASH_PROFILE
    void _hash_add_iter();
    void _hash_add_call();
    void _hash_put_iter();
    void _hash_put_call();
    void _hash_rm_iter();
    void _hash_rm_call();
    void _hash_find_iter();
    void _hash_find_call();
    void _hash_rand_iter();
    void _hash_rand_call();
    void _hash_expand_call();
    void _hash_prof();
    #define _HASH_ADD_ITER()  _hash_add_iter()
    #define _HASH_ADD_CALL()  _hash_add_call()
    #define _HASH_PUT_ITER()  _hash_put_iter()
    #define _HASH_PUT_CALL()  _hash_put_call()
    #define _HASH_RM_ITER()   _hash_rm_iter()
    #define _HASH_RM_CALL()   _hash_rm_call()
    #define _HASH_FIND_ITER() _hash_find_iter()
    #define _HASH_FIND_CALL() _hash_find_call()
    #define _HASH_RAND_ITER() _hash_rand_iter()
    #define _HASH_RAND_CALL() _hash_rand_call()
    #define _HASH_EXP_CALL()  _hash_expand_call()
#else
    #define _HASH_ADD_ITER()  {}
    #define _HASH_ADD_CALL()  {}
    #define _HASH_PUT_ITER()  {}
    #define _HASH_PUT_CALL()  {}
    #define _HASH_RM_ITER()   {}
    #define _HASH_RM_CALL()   {}
    #define _HASH_FIND_ITER() {}
    #define _HASH_FIND_CALL() {}
    #define _HASH_RAND_ITER() {}
    #define _HASH_RAND_CALL() {}
    #define _HASH_EXP_CALL()  {}
#endif

//_________________________________________________________________________
// Hash Table properties. Works best when HASH_SIZE_IS_POWER2 is uncommented
// but takes 2.25 times the needed space, in average (from 1.5 to 3)
// If you have memory issues, Try to comment it: tables will take 1.5 times
// the minimal space
//_________________________________________________________________________

#define HASH_SIZE_IS_POWER2
#define MACRO_RATHER_THAN_INLINE

// under HASH_MIN_SIZE, vectors are not hash table (just a simle array)
#define HASH_MIN_SIZE 100
#define IS_HASH(x) ((x)>HASH_MIN_SIZE)
#define HASH_NONE (-1)

#ifdef HASH_SIZE_IS_POWER2
inline int HASH_EXPAND(int x) {
    _HASH_EXP_CALL();
    x += x;
    x |= x >> 1;  x |= x >> 2;  x |= x >> 4;  x |= x >> 8;  x |= x >> 16;
    return x + 1;
}
#define HASH_KEY(x,size) ((x*2198737)&((size)-1))
#endif //HASH_SIZE_IS_POWER2

#ifdef MACRO_RATHER_THAN_INLINE
#ifndef HASH_SIZE_IS_POWER2
    #define HASH_EXPAND(x) ((x)+((x)>>1))
    #define HASH_UNEXPAND(x) ((((x)<<1)+1)/3)
    #define HASH_KEY(x,size) ((x)%(size))
#endif //HASH_SIZE_IS_POWER2
#define HASH_SIZE(x) (IS_HASH(x) ? HASH_EXPAND(x) : (x) )
#define HASH_REKEY(k,size) ((k)==0 ? (size)-1 : (k)-1)
#else //MACRO_RATHER_THAN_INLINE
#ifndef HASH_SIZE_IS_POWER2
inline int  HASH_KEY(const int x, const int size) {
    assert(x >= 0);
    return x % size;
};
inline int  HASH_EXPAND(const int x) {
    _HASH_EXP_CALL();
    return x + (x >> 1);
};
inline int  HASH_UNEXPAND(const int x) {
    return ((x << 1) + 1) / 3;
};
#endif //HASH_SIZE_IS_POWER2
inline int  HASH_REKEY(const int k, const int s) {
    assert(k >= 0);
    if (k == 0) {
        return s - 1;
    } else {
        return k - 1;
    }
};
inline int  HASH_SIZE(const int x) {
    if (IS_HASH(x)) {
        return HASH_EXPAND(x);
    } else {
        return x;
    }
};
#endif //MACRO_RATHER_THAN_INLINE

inline int HASH_PAIR_KEY(const int x, const int y, const int size) {
    return HASH_KEY(x * 1434879443 + y, size);
}

//_________________________________________________________________________
// Hash-only functions : table must NOT be Raw.
// the argument 'size' is the total size of the hash table
//_________________________________________________________________________

// copy hash table into raw vector
inline void H_copy(int *mem, int *h, int size) {
    for (int i = HASH_EXPAND(size); i--; h++) if (*h != HASH_NONE) {
            *(mem++) = *h;
        }
}

// Look for the place to add an element. Return NULL if element is already here.
inline int* H_add(int* h, const int size, int a) {
    _HASH_ADD_CALL();
    _HASH_ADD_ITER();
    int k = HASH_KEY(a, size);
    if (h[k] == HASH_NONE) {
        return h + k;
    }
    while (h[k] != a) {
        _HASH_ADD_ITER();
        k = HASH_REKEY(k, size);
        if (h[k] == HASH_NONE) {
            return h + k;
        }
    }
    return NULL;
}

// would element be well placed in newk ?
inline bool H_better(const int a, const int size, const int currentk, const int newk) {
    int k = HASH_KEY(a, size);
    if (newk < currentk) {
        return (k < currentk && k >= newk);
    } else {
        return (k < currentk || k >= newk);
    }
}

// removes h[k]
inline void H_rm(int* h, const int size, int k) {
    _HASH_RM_CALL();
    int lasthole = k;
    do {
        _HASH_RM_ITER();
        k = HASH_REKEY(k, size);
        int next = h[k];
        if (next == HASH_NONE) {
            break;
        }
        if (H_better(next, size, k, lasthole)) {
            h[lasthole] = next;
            lasthole = k;
        }
    } while (true);
    h[lasthole] = HASH_NONE;
}

//put a
inline int* H_put(int* h, const int size, const int a) {
    assert(H_add(h, size, a) != NULL);
    _HASH_PUT_CALL();
    _HASH_PUT_ITER();
    int k = HASH_KEY(a, size);
    while (h[k] != HASH_NONE) {
        k = HASH_REKEY(k, size);
        _HASH_PUT_ITER();
    }
    h[k] = a;
    assert(H_add(h, size, a) == NULL);
    return h + k;
}

// find A
inline int H_find(int *h, int size, const int a) {
    assert(H_add(h, size, a) == NULL);
    _HASH_FIND_CALL();
    _HASH_FIND_ITER();
    int k = HASH_KEY(a, size);
    while (h[k] != a) {
        k = HASH_REKEY(k, size);
        _HASH_FIND_ITER();
    }
    return k;
}

// Look for the place to add an element. Return NULL if element is already here.
inline bool H_pair_insert(int* h, const int size, int a, int b) {
    _HASH_ADD_CALL();
    _HASH_ADD_ITER();
    int k = HASH_PAIR_KEY(a, b, size);
    if (h[2 * k] == HASH_NONE) {
        h[2 * k] = a;
        h[2 * k + 1] = b;
        return true;
    }
    while (h[2 * k] != a || h[2 * k + 1] != b) {
        _HASH_ADD_ITER();
        k = HASH_REKEY(k, size);
        if (h[2 * k] == HASH_NONE) {
            h[2 * k] = a;
            h[2 * k + 1] = b;
            return true;
        }
    }
    return false;
}


//_________________________________________________________________________
// Generic functions : table can be either Hash or Raw.
// the argument 'size' is the number of elements
//_________________________________________________________________________

// Look for an element
inline bool H_is(int *mem, const int size, const int elem) {
    if (IS_HASH(size)) {
        return (H_add(mem, HASH_EXPAND(size), elem) == NULL);
    } else {
        return fast_search(mem, size, elem) != NULL;
    }
}

//pick random location (containing an element)
inline int* H_random(int* mem, int size) {
    if (!IS_HASH(size)) {
        return mem + (my_random() % size);
    }
    _HASH_RAND_CALL();
    size = HASH_EXPAND(size);
    int* yo;
    do {
        yo = mem + HASH_KEY(my_random(), size);
        _HASH_RAND_ITER();
    } while (*yo == HASH_NONE);
    return yo;
}

// replace *k by b
inline int* H_rpl(int *mem, int size, int* k, const int b) {
    assert(!H_is(mem, size, b));
    if (!IS_HASH(size)) {
        *k = b;
        return k;
    } else {
        size = HASH_EXPAND(size);
        assert(mem + int(k - mem) == k);
        H_rm(mem, size, int(k - mem));
        return H_put(mem, size, b);
    }
}

// replace a by b
inline int* H_rpl(int *mem, int size, const int a, const int b) {
    assert(H_is(mem, size, a));
    assert(!H_is(mem, size, b));
    if (!IS_HASH(size)) {
        return fast_rpl(mem, a, b);
    } else {
        size = HASH_EXPAND(size);
        H_rm(mem, size, H_find(mem, size, a));
        return H_put(mem, size, b);
    }
}

} // namespace gengraph

#endif //HASH_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_header.h0000644000175100001710000000551700000000000030645 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_definitions.h"
#include 
#include 

#include "gengraph_random.h"

namespace gengraph {

static KW_RNG::RNG _my_random;
int my_random() {
    return _my_random.rand_int31();
}
void my_srandom(int x) {
    _my_random.init(x, !x * 13, x * x + 1, (x >> 16) + (x << 16));
}
int my_binomial(double pp, int n) {
    return _my_random.binomial(pp, n);
}
double my_random01() {
    return _my_random.rand_halfopen01();
}

}

namespace gengraph {

static int VERB;
int VERBOSE() {
    return VERB;
}
void SET_VERBOSE(int v) {
    VERB = v;
}

//Hash profiling
static unsigned long _hash_rm_i   = 0;
static unsigned long _hash_rm_c   = 0;
static unsigned long _hash_add_i  = 0;
static unsigned long _hash_add_c  = 0;
static unsigned long _hash_put_i  = 0;
static unsigned long _hash_put_c  = 0;
static unsigned long _hash_find_i = 0;
static unsigned long _hash_find_c = 0;
static unsigned long _hash_rand_i = 0;
static unsigned long _hash_rand_c = 0;
static unsigned long _hash_expand = 0;
inline void _hash_add_iter()  {
    _hash_add_i++;
}
inline void _hash_add_call()  {
    _hash_add_c++;
}
inline void _hash_put_iter()  {
    _hash_put_i++;
}
inline void _hash_put_call()  {
    _hash_put_c++;
}
inline void _hash_rm_iter()   {
    _hash_rm_i++;
}
inline void _hash_rm_call()   {
    _hash_rm_c++;
}
inline void _hash_find_iter() {
    _hash_find_i++;
}
inline void _hash_find_call() {
    _hash_find_c++;
}
inline void _hash_rand_iter() {
    _hash_rand_i++;
}
inline void _hash_rand_call() {
    _hash_rand_c++;
}
inline void _hash_expand_call() {
    _hash_expand++;
}
// void _hash_prof() {
//   fprintf(stderr,"HASH_ADD : %lu / %lu\n", _hash_add_c , _hash_add_i);
//   fprintf(stderr,"HASH_PUT : %lu / %lu\n", _hash_put_c , _hash_put_i);
//   fprintf(stderr,"HASH_FIND: %lu / %lu\n", _hash_find_c, _hash_find_i);
//   fprintf(stderr,"HASH_RM  : %lu / %lu\n", _hash_rm_c  , _hash_rm_i);
//   fprintf(stderr,"HASH_RAND: %lu / %lu\n", _hash_rand_c, _hash_rand_i);
//   fprintf(stderr,"HASH_EXPAND : %lu calls\n", _hash_expand);
// }

} // namespace gengraph
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_mr-connected.cpp0000644000175100001710000001524200000000000032322 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#include "gengraph_header.h"
#include "gengraph_graph_molloy_optimized.h"
#include "gengraph_graph_molloy_hash.h"
#include "gengraph_degree_sequence.h"
#include "gengraph_random.h"

#include "igraph_datatype.h"
#include "igraph_graphicality.h"
#include "igraph_types.h"
#include "igraph_error.h"

#include "core/exceptions.h"

namespace gengraph {

// return negative number if program should exit
int parse_options(int &argc, char** &argv);

// options
// static const bool MONITOR_TIME = false;
static const int  SHUFFLE_TYPE = FINAL_HEURISTICS;
// static const bool RAW_DEGREES  = false;
// static const FILE *Fdeg = stdin;

//_________________________________________________________________________
// int main(int argc, char** argv) {

//   // options
//   SET_VERBOSE(VERBOSE_NONE);
//   if(parse_options(argc, argv) < 0) return -1;

//   //Read degree distribution
//   degree_sequence dd(Fdeg, !RAW_DEGREES);

//   //Allocate memory
//   if(VERBOSE()) fprintf(stderr,"Allocate memory for graph...");
//   graph_molloy_opt g(dd);
//   dd.~degree_sequence();
//   //Realize degree sequence
//   if(VERBOSE()) fprintf(stderr,"done\nRealize degree sequence...");
//   bool FAILED = !g.havelhakimi();
//   if(VERBOSE()) fprintf(stderr," %s\n", FAILED ? "Failed" : "Success");
//   if(FAILED) return 2;
//   //Merge connected components together
//   if(VERBOSE()) fprintf(stderr,"Connecting...");
//   FAILED = !g.make_connected();
//   if(VERBOSE()) fprintf(stderr," %s\n", FAILED ? "Failed" : "Success");
//   if(FAILED) return 3;
//   //Convert graph_molloy_opt to graph_molloy_hash
//   if(VERBOSE()) fprintf(stderr,"Convert adjacency lists into hash tables...");
//   int *hc = g.hard_copy();
//   g.~graph_molloy_opt();
//   graph_molloy_hash gh(hc);
//   delete[] hc;
//   if(VERBOSE()) fprintf(stderr,"Done\n");
//   //Shuffle
//   gh.shuffle(5*gh.nbarcs(), SHUFFLE_TYPE);
//   //Output
//   gh.print();
//   if(MONITOR_TIME) {
//     double t = double(clock()) / double(CLOCKS_PER_SEC);
//     fprintf(stderr,"Time used: %f\n", t);
//   }
//   return 0;
// }

//_________________________________________________________________________
// int parse_options(int &argc, char** &argv) {
// bool HELP = false;
// int argc0 = argc;
// argc = 1;
// for(int a=1; a %s returns a graph in its standard output\n",argv[0]);
//   fprintf(stderr,"    If no file is given, %s reads its standard input\n",argv[0]);
//   fprintf(stderr,"    [-v] and [-vv] options causes extra verbose.\n");
//   fprintf(stderr,"    [-g] option uses the Gkantsidis heuristics.\n");
//   fprintf(stderr,"    [-b] option uses the Brute Force heuristics.\n");
//   fprintf(stderr,"    [-f] option uses the Modified Gkantsidis heuristics.\n");
//   fprintf(stderr,"    [-o] option uses the Optimal Gkantsidis heuristics.\n");
//   fprintf(stderr,"    [-t] option monitors computation time\n");
//   fprintf(stderr,"    [-s] does a srandom(0) to get a constant random graph\n");
//   fprintf(stderr,"    [-raw] is to take raw degree sequences as input\n");
//   return -1;
// }
//   return 0;
// }


} // namespace gengraph

using namespace gengraph;

extern "C" {

    int igraph_degree_sequence_game_vl(igraph_t *graph,
                                       const igraph_vector_t *out_seq,
                                       const igraph_vector_t *in_seq) {
        IGRAPH_HANDLE_EXCEPTIONS(
            igraph_bool_t is_graphical;

            if (in_seq && igraph_vector_size(in_seq) != 0) {
                IGRAPH_ERROR("This generator works with undirected graphs only", IGRAPH_EINVAL);
            }

            IGRAPH_CHECK(igraph_is_graphical(out_seq, 0, IGRAPH_SIMPLE_SW, &is_graphical));
            if (!is_graphical) {
                IGRAPH_ERROR("Cannot realize the given degree sequence as an undirected, simple graph",
                             IGRAPH_EINVAL);
            }

            RNG_BEGIN();

            degree_sequence *dd = new degree_sequence(out_seq);

            graph_molloy_opt *g = new graph_molloy_opt(*dd);
            delete dd;

            if (!g->havelhakimi()) {
                delete g;
                RNG_END();
                IGRAPH_FATAL("g->havelhakimi() failed; please report as a bug.");
            }

            if (!g->make_connected()) {
                delete g;
                RNG_END();
                IGRAPH_ERROR("Cannot make a connected graph from the given degree sequence",
                             IGRAPH_EINVAL);
            }

            int *hc = g->hard_copy();
            delete g;
            graph_molloy_hash *gh = new graph_molloy_hash(hc);
            delete [] hc;

            gh->shuffle(5 * gh->nbarcs(), 100 * gh->nbarcs(), SHUFFLE_TYPE);

            IGRAPH_CHECK(gh->print(graph));
            delete gh;

            RNG_END();
        );

        return IGRAPH_SUCCESS;
    }

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_powerlaw.cpp0000644000175100001710000002000500000000000031575 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
// Pascalou ...
#ifdef pascalou
    #define my_random() random()
    #define MY_RAND_MAX 0x7FFFFFFF
#else
    #include "gengraph_definitions.h"
#endif

#include "gengraph_powerlaw.h"
#include 
#include 
#include 

#include "igraph_error.h"

namespace gengraph {

// Destructor
powerlaw::~powerlaw() {
    delete[] table;
    if (dt != NULL) {
        delete[] dt;
    }
}

// Constructor
powerlaw::powerlaw(double _alpha, int _mini, int _maxi) {
    alpha = _alpha;
    mini = _mini;
    maxi = _maxi;
    if (alpha <= 2.0 && maxi < 0)
        igraph_warningf("powerlaw exponent %f should be > 2 when no "
                        "Maximum is specified", IGRAPH_FILE_BASENAME, __LINE__, -1, alpha);
    if (alpha <= 1.0 && maxi >= 0)
        igraph_warningf("powerlaw exponent %f should be > 1", IGRAPH_FILE_BASENAME, __LINE__,
                        -1, alpha);
    if (maxi >= 0 && mini > maxi)
        igraph_warningf("powerlaw max %d should be greater than min %d",
                        IGRAPH_FILE_BASENAME, __LINE__, -1, maxi, mini);
    table = new int[POWERLAW_TABLE];
    tabulated = 0;
    dt = NULL;
}

// Sample
int powerlaw::sample() {
    if (proba_big != 0 && test_proba(proba_big)) {
        return int(floor(0.5 + big_sample(random_float())));
    }
    int r = my_random();
    // table[] contains integer from MY_RAND_MAX downto 0, in blocks. Search block...
    if (r > (MY_RAND_MAX >> max_dt)) {
        return mini;
    }
    int k = 0;
    while (k < max_dt) {
        r <<= 1;
        r += random_bit();
        k++;
    };
    int a = 0;
    int b;
    while ((b = dt[k++]) < 0 || r < table[b]) {
        if (b >= 0) {
            a = b + 1;
            if (a == tabulated - 1) {
                break;
            }
            r <<= 1;
            r += random_bit();
        }
    }

    // Now that we found the good block, run a dichotomy on this block [a,b]
    while (a < b) {
        int c = (a + b) / 2;
        if (r < table[c]) {
            a = c + 1;
        } else {
            b = c;
        }
    }
    return mini + a;
}

// Proba
double powerlaw::proba(int k) {
    if (k < mini || (maxi >= 0 && k > maxi)) {
        return 0.0;
    }
    if (k >= mini + tabulated) {
        return proba_big * (big_inv_sample(double(k) - 0.5) - big_inv_sample(double(k) + 0.5));
    } else {
        double div = table_mul;
        int prev_pos_in_table = k - mini - 1;
        if (prev_pos_in_table < 0) {
            return (double(MY_RAND_MAX) + 1.0 - double(table[0] >> max_dt)) * div;
        }
        // what block are we in ?
        int k1 = 0;
        while (k1 < max_dt) {
            div *= 0.5;
            k1++;
        };
        while (dt[k1] < 0 || dt[k1] < prev_pos_in_table) {
            k1++;
            div *= 0.5;
        };
        double prob2 = double(table[prev_pos_in_table + 1]);
        if (dt[k1] == prev_pos_in_table) do {
                prob2 *= 0.5;
            } while (dt[++k1] < 0);
        return (double(table[prev_pos_in_table]) - prob2) * div;
    }
}

// Relative Error
double powerlaw::error() {
    return 1.0 / (double(tabulated) * double(tabulated));
}

// Mean
double powerlaw::mean() {
    double sum = 0.0;
    for (int i = mini + tabulated; --i >= mini; ) {
        sum += double(i) * proba(i);
    }
    // add proba_big * integral(big_sample(t),t=0..1)
    if (proba_big != 0) {
        sum += proba_big * ((pow(_a + _b, _exp + 1.0) - pow(_b, _exp + 1.0)) / (_a * (_exp + 1.0)) + double(mini) - offset - sum);
    }
    return sum;
}

// Median. Returns integer Med such that P(X<=Med) >= 1/2
int powerlaw::median() {
    if (proba_big > 0.5) {
        return int(floor(0.5 + big_sample(1.0 - 0.5 / proba_big)));
    }
    double sum = 0.0;
    int i = mini;
    while (sum < 0.5) {
        sum += proba(i++);
    }
    return i - 1;
}

void powerlaw::init_to_offset(double _offset, int _tabulated) {
    offset = _offset;
    tabulated = _tabulated;
    if (maxi >= 0 && tabulated > maxi - mini) {
        tabulated = maxi - mini + 1;
    }
    double sum = 0.0;
    double item = double(tabulated) + offset;
    // Compute sum of tabulated probabilities
    for (int i = tabulated; i--; ) {
        sum += pow(item -= 1.0, -alpha);
    }
    // Compute others parameters : proba_big, table_mul, _a, _b, _exp
    if (maxi > 0 && maxi <= mini + tabulated - 1) {
        proba_big = 0;
        table_mul = inv_RANDMAX;
    } else {
        if (maxi < 0) {
            _b = 0.0;
        } else {
            _b = pow(double(maxi - mini) + 0.5 + offset, 1.0 - alpha);
        }
        _a = pow(double(tabulated) - 0.5 + offset, 1.0 - alpha) - _b;
        _exp = 1.0 / (1.0 - alpha);
        double sum_big = _a * (-_exp);
        proba_big = sum_big / (sum + sum_big);
        table_mul = inv_RANDMAX * sum / (sum + sum_big);
    }
    // How many delimiters will be necessary for the table ?
    max_dt = max(0, int(floor(alpha * log(double(tabulated)) / log(2.0))) - 6);
    if (dt != NULL) {
        delete[] dt;
    }
    dt = new int[max_dt + 1];
    // Create table as decreasing integers from MY_RAND_MAX+1 (in virtual position -1) down to 0
    // Every time the index crosses a delimiter, numbers get doubled.
    double ssum = 0;
    double mul = (double(MY_RAND_MAX) + 1.0) * pow(2.0, max_dt) / sum;
    item = double(tabulated) + offset;
    int k = max_dt;
    dt[k--] = tabulated - 1;
    for (int i = tabulated; --i > 0; ) {
        table[i] = int(floor(0.5 + ssum));
        ssum += mul * pow(item -= 1.0, -alpha);
        if (ssum > double(MY_RAND_MAX / 2) && k >= 0) {
            while ((ssum *= 0.5) > double(MY_RAND_MAX / 2)) {
                mul *= 0.5;
                dt[k--] = -1;
            };
            mul *= 0.5; dt[k--] = i - 1;
        }
    }
    table[0] = int(floor(0.5 + ssum));
    max_dt = k + 1;
}

void powerlaw::adjust_offset_mean(double _mean, double err, double factor) {
    // Set two bounds for offset
    double ol = offset;
    double oh = offset;
    if (mean() < _mean) {
        do {
            ol = oh;
            oh *= factor;
            init_to_offset(oh, tabulated);
        } while (mean() < _mean);
    } else {
        do {
            oh = ol;
            ol /= factor;
            init_to_offset(ol, tabulated);
        } while (mean() > _mean);
    }
    // Now, dichotomy
    while (fabs(oh - ol) > err * ol) {
        double oc = sqrt(oh * ol);
        init_to_offset(oc, tabulated);
        if (mean() < _mean) {
            ol = oc;
        } else {
            oh = oc;
        }
    }
    init_to_offset(sqrt(ol * oh), tabulated);
}

double powerlaw::init_to_mean(double _mean) {
    if (maxi >= 0 && _mean >= 0.5 * double((mini + maxi))) {
        /* Cannot use IGRAPH_ERRORF() as this function does not
         * return an igraph error code. */
        igraph_errorf("Fatal error in powerlaw::init_to_mean(%f): "
                      "Mean must be in ]min, (min+max)/2[ = ]%d, %d[",
                      IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL,
                      _mean, mini, (mini + maxi) / 2);
        return (-1.0);
    }
    init_to_offset(_mean - double(mini), 100);
    adjust_offset_mean(_mean, 0.01, 2);
    init_to_offset(offset, POWERLAW_TABLE);
    double eps = 1.0 / (double(POWERLAW_TABLE));
    adjust_offset_mean(_mean, eps * eps, 1.01);
    return offset;
}

} // namespace gengraph
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_powerlaw.h0000644000175100001710000000571600000000000031256 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef _POWERLAW_H
#define _POWERLAW_H

// pascalou
#ifndef pascalou
    #include "gengraph_definitions.h"
#endif

// Discrete integer power-law : P(X=min+k) is proportionnal to (k+k0)^-alpha
// - possibility to determine a range [Min, Max] of possible samples
// - possibility to automatically compute k0 to obtain a given mean z

namespace gengraph {

#define POWERLAW_TABLE 10000

class powerlaw {
private:
    double alpha;  // Exponent
    int mini; // Minimum sample
    int maxi; // Maximum sample
    double offset; // Offset
    int tabulated; // Number of values to tabulate
    int *table;    // Table containing cumulative distribution for k=mini..mini+tabulated-1
    int *dt;        // Table delimiters
    int max_dt;     // number of delimiters - 1
    double proba_big;   // Probability to take a non-tabulated value
    double table_mul;   // equal to (1-proba_big)/(RAND_MAX+1)

    // Sample a non-tabulated value >= mini+tabulated
    inline double big_sample(double randomfloat) {
        return double(mini) + pow(_a * randomfloat + _b, _exp) - offset;
    }
    inline double big_inv_sample(double s) {
        return (pow(s - double(mini) + offset, 1.0 / _exp) - _b) / _a;
    }
    double _exp, _a, _b; // Cached values used by big_sample();

    // Dichotomic adjust of offset, so that to_adjust() returns value with
    // a precision of eps. Note that to_adjust() must be an increasing function of offset.
    void adjust_offset_mean(double value, double eps, double fac);

public:
    int sample();      // Return a random integer
    double proba(int); // Return probability to return integer
    double error();    // Returns relative numerical error done by this class
    double mean();     // Returns mean of the sampler
    int median();      // Returns median of the sampler

    // Initialize the power-law sampler.
    void init_to_offset(double, int);
    // Same, but also returns the offset found
    double init_to_mean(double);
    double init_to_median(double);

    inline void init() {
        init_to_offset(double(mini), POWERLAW_TABLE);
    };

    ~powerlaw();
    powerlaw(double exponent, int mini, int maxi = -1);
};

} // namespace gengraph

#endif //_POWERLAW_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_qsort.h0000644000175100001710000003334100000000000030561 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef QSORT_H
#define QSORT_H

#include 
#include 

namespace gengraph {

//___________________________________________________________________________
// check if every element is zero
inline bool check_zero(int *mem, int n) {
    for (int *v = mem + n; v != mem; ) if (*(--v) != 0) {
            return false;
        }
    return true;
}

//___________________________________________________________________________
//  Sort simple integer arrays in ASCENDING order
//___________________________________________________________________________
inline int med3(int a, int b, int c) {
    if (a < b) {
        if (c < b) {
            return (a < c) ? c : a;
        } else {
            return b;
        }
    } else {
        if (c < a) {
            return (b < c) ? c : b;
        } else {
            return a;
        }
    }
}

inline void isort(int *v, int t) {
    if (t < 2) {
        return;
    }
    for (int i = 1; i < t; i++) {
        int *w = v + i;
        int tmp = *w;
        while (w != v && *(w - 1) > tmp) {
            *w = *(w - 1);
            w--;
        }
        *w = tmp;
    }
}

inline int partitionne(int *v, int t, int p) {
    int i = 0;
    int j = t - 1;
    while (i < j) {
        while (i <= j && v[i] < p) {
            i++;
        }
        while (i <= j && v[j] > p) {
            j--;
        }
        if (i < j) {
            int tmp = v[i];
            v[i++] = v[j];
            v[j--] = tmp;
        }
    }
    if (i == j && v[i] < p) {
        i++;
    }
    assert(i != 0 && i != t);
    return i;
}

inline void qsort(int *v, int t) {
    if (t < 15) {
        isort(v, t);
    } else {
        int x = partitionne(v, t, med3(v[t >> 1], v[(t >> 2) + 2], v[t - (t >> 1) - 2]));
        qsort(v, x);
        qsort(v + x, t - x);
    }
}

inline int qsort_median(int *v, int t, int pos) {
    if (t < 10) {
        isort(v, t);
        return v[pos];
    }
    int x = partitionne(v, t, med3(v[t >> 1], v[(t >> 2) + 2], v[t - (t >> 1) - 2]));
    if (pos < x) {
        return qsort_median(v, x, pos);
    } else {
        return qsort_median(v + x, t - x, pos - x);
    }
}

inline int qsort_median(int *v, int t) {
    return qsort_median(v, t, t / 2);
}

//___________________________________________________________________________
//  Sort simple double arrays in ASCENDING order
//___________________________________________________________________________
inline double med3(double a, double b, double c) {
    if (a < b) {
        if (c < b) {
            return (a < c) ? c : a;
        } else {
            return b;
        }
    } else {
        if (c < a) {
            return (b < c) ? c : b;
        } else {
            return a;
        }
    }
}

inline void isort(double *v, int t) {
    if (t < 2) {
        return;
    }
    for (int i = 1; i < t; i++) {
        double *w = v + i;
        double tmp = *w;
        while (w != v && *(w - 1) > tmp) {
            *w = *(w - 1);
            w--;
        }
        *w = tmp;
    }
}

inline int partitionne(double *v, int t, double p) {
    int i = 0;
    int j = t - 1;
    while (i < j) {
        while (i <= j && v[i] < p) {
            i++;
        }
        while (i <= j && v[j] > p) {
            j--;
        }
        if (i < j) {
            double tmp = v[i];
            v[i++] = v[j];
            v[j--] = tmp;
        }
    }
    if (i == j && v[i] < p) {
        i++;
    }
    assert(i != 0 && i != t);
    return i;
}

inline void qsort(double *v, int t) {
    if (t < 15) {
        isort(v, t);
    } else {
        int x = partitionne(v, t, med3(v[t >> 1], v[(t >> 2) + 2], v[t - (t >> 1) - 2]));
        qsort(v, x);
        qsort(v + x, t - x);
    }
}

inline double qsort_median(double *v, int t, int pos) {
    if (t < 10) {
        isort(v, t);
        return v[pos];
    }
    int x = partitionne(v, t, med3(v[t >> 1], v[(t >> 2) + 2], v[t - (t >> 1) - 2]));
    if (pos < x) {
        return qsort_median(v, x, pos);
    } else {
        return qsort_median(v + x, t - x, pos - x);
    }
}

inline double qsort_median(double *v, int t) {
    return qsort_median(v, t, t / 2);
}

//___________________________________________________________________________
// Sort integer arrays according to value stored in mem[], in ASCENDING order
inline void isort(int *mem, int *v, int t) {
    if (t < 2) {
        return;
    }
    for (int i = 1; i < t; i++) {
        int vtmp = v[i];
        int tmp = mem[vtmp];
        int j;
        for (j = i; j > 0 && tmp < mem[v[j - 1]]; j--) {
            v[j] = v[j - 1];
        }
        v[j] = vtmp;
    }
}

inline void qsort(int *mem, int *v, int t) {
    if (t < 15) {
        isort(mem, v, t);
    } else {
        int p = med3(mem[v[t >> 1]], mem[v[(t >> 2) + 3]], mem[v[t - (t >> 1) - 3]]);
        int i = 0;
        int j = t - 1;
        while (i < j) {
            while (i <= j && mem[v[i]] < p) {
                i++;
            }
            while (i <= j && mem[v[j]] > p) {
                j--;
            }
            if (i < j) {
                int tmp = v[i];
                v[i++] = v[j];
                v[j--] = tmp;
            }
        }
        if (i == j && mem[v[i]] < p) {
            i++;
        }
        assert(i != 0 && i != t);
        qsort(mem, v, i);
        qsort(mem, v + i, t - i);
    }
}

//Box-Sort 1..n according to value stored in mem[], in DESCENDING order.
inline int *pre_boxsort(int *mem, int n, int &offset) {
    int *yo;
    // maximum and minimum
    int mx = mem[0];
    int mn = mem[0];
    for (yo = mem + n - 1; yo != mem; yo--) {
        int x = *yo;
        if (x > mx) {
            mx = x;
        }
        if (x < mn) {
            mn = x;
        }
    }
    // box
    int c = mx - mn + 1;
    int *box = new int[c];
    for (yo = box + c; yo != box; * (--yo) = 0) { }
    for (yo = mem + n; yo != mem; box[*(--yo) - mn]++) { }
    // cumul sum
    int sum = 0;
    for (yo = box + c; yo != box; ) {
        sum += *(--yo);
        *yo = sum;
    }
    offset = mn;
    return box;
}

inline int *boxsort(int *mem, int n, int *buff = NULL) {
    int i;
    if (n <= 0) {
        return buff;
    }
    int offset = 0;
    int *box = pre_boxsort(mem, n, offset);
    // sort
    if (buff == NULL) {
        buff = new int[n];
    }
    for (i = 0; i < n; i++) {
        buff[--box[mem[i] - offset]] = i;
    }
    // clean
    delete[] box;
    return buff;
}

// merge two sorted arays in their intersection. Store the result in first array, and return length
inline int intersect(int *a, int a_len, int *b, int b_len) {
    if (a_len == 0 || b_len == 0) {
        return 0;
    }
    int *asup = a + a_len;
    int *bsup = b + b_len;
    int len = 0;
    int *p = a;
    do {
        if (*a == *b) {
            p[len++] = *a;
        }
        do if (++a == asup) {
                return len;
            } while (*a < *b);
        if (*a == *b) {
            p[len++] = *a;
        }
        do if (++b == bsup) {
                return len;
            } while (*b < *a);
    } while (true);
}

// merge two sorted arays in their union, store result in m
inline int unify(int *m, int *a, int a_len, int *b, int b_len) {
    int *asup = a + a_len;
    int *bsup = b + b_len;
    int len = 0;
    while (a != asup && b != bsup) {
        if (*a < *b) {
            m[len++] = *(a++);
        } else {
            if (*a == *b) {
                a++;
            }
            m[len++] = *(b++);
        }
    }
    while (a != asup) {
        m[len++] = *(a++);
    }
    while (b != asup) {
        m[len++] = *(b++);
    }
    return len;
}

// lexicographic compare
inline int lex_comp(int *v1, int *v2, int n) {
    int *stop = v1 + n;
    while (v1 != stop && *v1 == *v2) {
        v1++;
        v2++;
    };
    if (v1 == stop) {
        return 0;
    } else if (*v1 < *v2) {
        return -1;
    } else {
        return 1;
    }
}
// lexicographic median of three
inline int *lex_med3(int *a, int *b, int *c, int s) {
    int ab = lex_comp(a, b, s);
    if (ab == 0) {
        return a;
    } else {
        int cb = lex_comp(c, b, s);
        if (cb == 0) {
            return b;
        }
        int ca = lex_comp(c, a, s);
        if (ab < 0) {
            if (cb > 0) {
                return b;
            } else {
                return (ca > 0) ? c : a;
            }
        } else     {
            if (cb < 0) {
                return b;
            } else {
                return (ca < 0) ? c : a;
            }
        }
    }
}

// Lexicographic sort
inline void lex_isort(int **l, int *v, int t, int s) {
    if (t < 2) {
        return;
    }
    for (int i = 1; i < t; i++) {
        int *w = v + i;
        int tmp = *w;
        while (w != v && lex_comp(l[tmp], l[*(w - 1)], s) < 0) {
            *w = *(w - 1);
            w--;
        }
        *w = tmp;
    }
}

#ifdef _STABLE_SORT_ONLY
    #define _CRITICAL_SIZE_QSORT 0x7FFFFFFF
    #warning "lex_qsort will be replaced by lex_isort"
#else
    #define _CRITICAL_SIZE_QSORT 15
#endif

inline void lex_qsort(int **l, int *v, int t, int s) {

    if (t < _CRITICAL_SIZE_QSORT) {
        lex_isort(l, v, t, s);
    } else {
        int *p = lex_med3(l[v[t >> 1]], l[v[(t >> 2) + 2]], l[v[t - (t >> 1) - 2]], s);
        int i = 0;
        int j = t - 1;
//    printf("pivot = %d\n",p);
        while (i < j) {
//      for(int k=0; k 0) {
                j--;
            }
            if (i < j) {
//        printf("  swap %d[%d] with %d[%d]\n",i,v[i],j,v[j]);
                int tmp = v[i];
                v[i++] = v[j];
                v[j--] = tmp;
            }
        }
        if (i == j && lex_comp(l[v[i]], p, s) < 0) {
            i++;
        }
        assert(i != 0 && i != t);
        lex_qsort(l, v, i, s);
        lex_qsort(l, v + i, t - i, s);
    }
}

// lexicographic indirect compare
inline int lex_comp_indirect(int *key, int *v1, int *v2, int n) {
    int *stop = v1 + n;
    while (v1 != stop && key[*v1] == key[*v2]) {
        v1++;
        v2++;
    };
    if (v1 == stop) {
        return 0;
    } else if (key[*v1] < key[*v2]) {
        return -1;
    } else {
        return 1;
    }
}

inline int qsort_min(const int a, const int b) {
    return a <= b ? a : b;
}

// mix indirect compare
inline int mix_comp_indirect(int *key, int a, int b, int **neigh, int *degs) {
    if (key[a] < key[b]) {
        return -1;
    } else if (key[a] > key[b]) {
        return 1;
    } else {
        int cmp = lex_comp_indirect(key, neigh[a], neigh[b], qsort_min(degs[a], degs[b]));
        if (cmp == 0) {
            if (degs[a] > degs[b]) {
                return -1;
            }
            if (degs[a] < degs[b]) {
                return 1;
            }
        }
        return cmp;
    }
}
// lexicographic indirect median of three
inline int mix_med3_indirect(int *key, int a, int b, int c, int **neigh, int *degs) {
    int ab = mix_comp_indirect(key, a, b, neigh, degs);
    if (ab == 0) {
        return a;
    } else {
        int cb = mix_comp_indirect(key, c, b, neigh, degs);
        if (cb == 0) {
            return b;
        }
        int ca = mix_comp_indirect(key, c, a, neigh, degs);
        if (ab < 0) {
            if (cb > 0) {
                return b;
            } else {
                return (ca > 0) ? c : a;
            }
        } else     {
            if (cb < 0) {
                return b;
            } else {
                return (ca < 0) ? c : a;
            }
        }
    }
}

// Sort integer arrays in ASCENDING order
inline void mix_isort_indirect(int *key, int *v, int t, int **neigh, int *degs) {
    if (t < 2) {
        return;
    }
    for (int i = 1; i < t; i++) {
        int *w = v + i;
        int tmp = *w;
        while (w != v && mix_comp_indirect(key, tmp, *(w - 1), neigh, degs) < 0) {
            *w = *(w - 1);
            w--;
        }
        *w = tmp;
    }
}

inline void mix_qsort_indirect(int *key, int *v, int t, int **neigh, int *degs) {
    if (t < 15) {
        mix_isort_indirect(key, v, t, neigh, degs);
    } else {
        int p = mix_med3_indirect(key, v[t >> 1], v[(t >> 2) + 2], v[t - (t >> 1) - 2], neigh, degs);
        int i = 0;
        int j = t - 1;
//    printf("pivot = %d\n",p);
        while (i < j) {
//      for(int k=0; k 0) {
                j--;
            }
            if (i < j) {
//        printf("  swap %d[%d] with %d[%d]\n",i,v[i],j,v[j]);
                int tmp = v[i];
                v[i++] = v[j];
                v[j--] = tmp;
            }
        }
        if (i == j && mix_comp_indirect(key, v[i], p, neigh, degs) < 0) {
            i++;
        }
        assert(i != 0 && i != t);
        mix_qsort_indirect(key, v, i, neigh, degs);
        mix_qsort_indirect(key, v + i, t - i, neigh, degs);
    }
}

} // namespace gengraph

#endif //QSORT_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_random.cpp0000644000175100001710000001723600000000000031231 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#define RNG_C

#ifdef RCSID
    static const char rcsid[] = "$Id: random.cpp,v 1.15 2003/05/14 03:04:45 wilder Exp wilder $";
#endif

//________________________________________________________________________
// See the header file random.h for a description of the contents of this
// file as well as references and credits.

#include "gengraph_random.h"
#include 

using namespace std;
using namespace KW_RNG;

//________________________________________________________________________
// RNG::RNOR generates normal variates with rejection.
// nfix() generates variates after rejection in RNOR.
// Despite rejection, this method is much faster than Box-Muller.

// double RNG::nfix(slong h, ulong i)
// {
//   const double r = 3.442620f;    // The starting of the right tail
//   static double x, y;

//   for(;;) {
//     x = h * wn[i];

//     // If i == 0, handle the base strip
//     if (i==0){
//       do {
//  x = -log(rand_open01()) * 0.2904764;   // .2904764 is 1/r
//  y = -log(rand_open01());
//       } while (y + y < x * x);
//       return ((h > 0) ? r + x : -r - x);
//     }

//     // If i > 0, handle the wedges of other strips
//     if (fn[i] + rand_open01() * (fn[i - 1] - fn[i]) < exp(-.5 * x * x) )
//       return x;

//     // start all over
//     h = rand_int32();
//     i = h & 127;
//     if ((ulong) abs((sint) h) < kn[i])
//       return (h * wn[i]);
//   }

// } // RNG::nfix

// // __________________________________________________________________________
// // RNG::RNOR generates exponential variates with rejection.
// // efix() generates variates after rejection in REXP.

// double RNG::efix(ulong j, ulong i)
// {
//   double x;
//   for (;;)
//   {
//     if (i == 0)
//       return (7.69711 - log(rand_open01()));

//     x = j * we[i];
//     if (fe[i] + rand_open01() * (fe[i - 1] - fe[i]) < exp(-x))
//       return (x);

//     j = rand_int32();
//     i = (j & 255);
//     if (j < ke[i])
//       return (j * we[i]);
//   }

// } // RNG::efix

// // __________________________________________________________________________
// // This procedure creates the tables used by RNOR and REXP

// void RNG::zigset()
// {
//   const double m1 = 2147483648.0; // 2^31
//   const double m2 = 4294967296.0; // 2^32

//   const double vn = 9.91256303526217e-3;
//   const double ve = 3.949659822581572e-3;

//   double dn = 3.442619855899, tn = dn;
//   double de = 7.697117470131487, te = de;

//   int i;

//   // Set up tables for RNOR
//   double q = vn / exp(-.5 * dn * dn);
//   kn[0] = (ulong) ((dn / q) * m1);
//   kn[1] = 0;
//   wn[0] = q / m1;
//   wn[127] = dn / m1;
//   fn[0]=1.;
//   fn[127] = exp(-.5 * dn * dn);
//   for(i = 126; i >= 1; i--)
//   {
//     dn = sqrt(-2 * log(vn / dn + exp(-.5 * dn * dn)));
//     kn[i + 1] = (ulong) ((dn / tn) * m1);
//     tn = dn;
//     fn[i] = exp(-.5 * dn * dn);
//     wn[i] = dn / m1;
//   }

//   // Set up tables for REXP
//   q = ve / exp(-de);
//   ke[0] = (ulong) ((de / q) * m2);
//   ke[1] = 0;
//   we[0] = q / m2;
//   we[255] = de / m2;
//   fe[0] = 1.;
//   fe[255] = exp(-de);
//   for (i = 254; i >= 1; i--)
//   {
//     de = -log(ve / de + exp(-de));
//     ke[i+1] = (ulong) ((de / te) * m2);
//     te = de;
//     fe[i] = exp(-de);
//     we[i] = de / m2;
//   }

// } // RNG::zigset

// // __________________________________________________________________________
// // Generate a gamma variate with parameters 'shape' and 'scale'

// double RNG::gamma(double shape, double scale)
// {
//   if (shape < 1)
//     return gamma(shape + 1, scale) * pow(rand_open01(), 1.0 / shape);

//   const double d = shape - 1.0 / 3.0;
//   const double c = 1.0 / sqrt(9.0 * d);
//   double x, v, u;
//   for (;;) {
//     do {
//       x = RNOR();
//       v = 1.0 + c * x;
//     } while (v <= 0.0);
//     v = v * v * v;
//     u = rand_open01();
//     if (u < 1.0 - 0.0331 * x * x * x * x)
//       return (d * v / scale);
//     if (log(u) < 0.5 * x * x + d * (1.0 - v + log(v)))
//       return (d * v / scale);
//   }

// } // RNG::gamma

// // __________________________________________________________________________
// // gammalog returns the logarithm of the gamma function.  From Numerical
// // Recipes.

// double gammalog(double xx)
// {
//   static double cof[6]={
//     76.18009172947146, -86.50532032941677, 24.01409824083091,
//     -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5};

//   double x = xx;
//   double y = xx;
//   double tmp = x + 5.5;
//   tmp -= (x + 0.5) * log(tmp);
//   double ser=1.000000000190015;
//   for (int j=0; j<=5; j++)
//     ser += cof[j] / ++y;
//   return -tmp + log(2.5066282746310005 * ser / x);
// }

// // __________________________________________________________________________
// // Generate a Poisson variate
// // This is essentially the algorithm from Numerical Recipes

// double RNG::poisson(double lambda)
// {
//   static double sq, alxm, g, oldm = -1.0;
//   double em, t, y;

//   if (lambda < 12.0) {
//     if (lambda != oldm) {
//       oldm = lambda;
//       g = exp(-lambda);
//     }
//     em = -1;
//     t = 1.0;
//     do {
//       ++em;
//       t *= rand_open01();
//     } while (t > g);
//   } else {
//     if (lambda != oldm) {
//       oldm = lambda;
//       sq = sqrt(2.0 * lambda);
//       alxm = log(lambda);
//       g = lambda * alxm - gammalog(lambda + 1.0);
//     }
//     do {
//       do {
//  y = tan(PI * rand_open01());
//  em = sq * y + lambda;
//       } while (em < 0.0);
//       em = floor(em);
//       t = 0.9 * (1.0 + y * y) * exp(em * alxm - gammalog(em + 1.0)-g);
//     } while (rand_open01() > t);
//   }
//   return em;

// } // RNG::poisson

// // __________________________________________________________________________
// // Generate a binomial variate
// // This is essentially the algorithm from Numerical Recipes

// int RNG::binomial(double pp, int n)
// {
//   if(n==0) return 0;
//   if(pp==0.0) return 0;
//   if(pp==1.0) return n;
//   double p = (pp<0.5 ? pp : 1.0-pp);
//   double am = n*p;
//   int bnl = 0;
//   if(n<25) {
//     for(int j=n; j--; ) if(rand_closed01()= en + 1.0);
//       em = floor(em);
//       t = 1.2 * sq * (1 + y * y) * exp(oldg - gammalog(em + 1.0) -
//           gammalog(en - em + 1.0) + em * log(p) + (en - em) * log(pc));
//     } while (rand_closed01() > t);
//     bnl = int(em);
//   }
//   if (p!=pp) bnl=n-bnl;
//   return bnl;
// } // RNG::binomial

// __________________________________________________________________________
// rng.C
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_random.h0000644000175100001710000001644300000000000030675 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef RNG_H
#define RNG_H

#include "igraph_random.h"

namespace KW_RNG {

typedef signed int  sint;
typedef unsigned int uint;
typedef signed long  slong;
typedef unsigned long ulong;

class RNG {
public:
    RNG() { }
    RNG(ulong z_, ulong w_, ulong jsr_, ulong jcong_ ) {
        IGRAPH_UNUSED(z_); IGRAPH_UNUSED(w_); IGRAPH_UNUSED(jsr_);
        IGRAPH_UNUSED(jcong_);
    };
    ~RNG() { }

    void init(ulong z_, ulong w_, ulong jsr_, ulong jcong_ ) {
        IGRAPH_UNUSED(z_); IGRAPH_UNUSED(w_); IGRAPH_UNUSED(jsr_);
        IGRAPH_UNUSED(jcong_);
    }
    long rand_int31() {
        return RNG_INT31();
    }
    double rand_halfopen01() { // (0,1]
        return RNG_UNIF01();
    }
    int binomial(double pp, int n) {
        return RNG_BINOM(n, pp);
    }
};

} // namespace KW_RNG

/* This was the original RNG, but now we use the igraph version */

// __________________________________________________________________________
// random.h   - a Random Number Generator Class
// random.cpp - contains the non-inline class methods

// __________________________________________________________________________
// This C++ code uses the simple, very fast "KISS" (Keep It Simple
// Stupid) random number generator suggested by George Marsaglia in a
// Usenet posting from 1999.  He describes it as "one of my favorite
// generators".  It generates high-quality random numbers that
// apparently pass all commonly used tests for randomness.  In fact, it
// generates random numbers by combining the results of three other good
// random number generators that have different periods and are
// constructed from completely different algorithms.  It does not have
// the ultra-long period of some other generators - a "problem" that can
// be fixed fairly easily - but that seems to be its only potential
// problem.  The period is about 2^123.

// The ziggurat method of Marsaglia is used to generate exponential and
// normal variates.  The method as well as source code can be found in
// the article "The Ziggurat Method for Generating Random Variables" by
// Marsaglia and Tsang, Journal of Statistical Software 5, 2000.

// The method for generating gamma variables appears in "A Simple Method
// for Generating Gamma Variables" by Marsaglia and Tsang, ACM
// Transactions on Mathematical Software, Vol. 26, No 3, Sep 2000, pages
// 363-372.

// The code for Poisson and Binomial random numbers comes from
// Numerical Recipes in C.

// Some of this code is unlikely to work correctly as is on 64 bit
// machines.

// #include 
// #include 
// #ifdef _WIN32
// #include 
// #define getpid _getpid
// #else
// #include 
// #endif

// //#ifdef _WIN32
//   static const double PI   =  3.1415926535897932;
//   static const double AD_l =  0.6931471805599453;
//   static const double AD_a =  5.7133631526454228;
//   static const double AD_b =  3.4142135623730950;
//   static const double AD_c = -1.6734053240284925;
//   static const double AD_p =  0.9802581434685472;
//   static const double AD_A =  5.6005707569738080;
//   static const double AD_B =  3.3468106480569850;
//   static const double AD_H =  0.0026106723602095;
//   static const double AD_D =  0.0857864376269050;
// //#endif //_WIN32

// namespace KW_RNG {

// class RNG
// {
// private:
//   ulong z, w, jsr, jcong; // Seeds

//   ulong kn[128], ke[256];
//   double wn[128],fn[128], we[256],fe[256];

// /*
// #ifndef _WIN32
//   static const double PI   =  3.1415926535897932;
//   static const double AD_l =  0.6931471805599453;
//   static const double AD_a =  5.7133631526454228;
//   static const double AD_b =  3.4142135623730950;
//   static const double AD_c = -1.6734053240284925;
//   static const double AD_p =  0.9802581434685472;
//   static const double AD_A =  5.6005707569738080;
//   static const double AD_B =  3.3468106480569850;
//   static const double AD_H =  0.0026106723602095;
//   static const double AD_D =  0.0857864376269050;
// #endif //_WIN32
// */

// public:
//   RNG() { init(); zigset(); }
//   RNG(ulong z_, ulong w_, ulong jsr_, ulong jcong_ ) :
//     z(z_), w(w_), jsr(jsr_), jcong(jcong_) { zigset(); }
//   ~RNG() { }


//   inline ulong znew()
//     { return (z = 36969 * (z & 65535) + (z >> 16)); }
//   inline ulong wnew()
//     { return (w = 18000 * (w & 65535) + (w >> 16)); }
//   inline ulong MWC()
//     { return (((znew() & 65535) << 16) + wnew()); }
//   inline ulong SHR3()
//     { jsr ^= ((jsr & 32767) << 17); jsr ^= (jsr >> 13); return (jsr ^= ((jsr << 5) & 0xFFFFFFFF)); }
//   inline ulong CONG()
//     { return (jcong = (69069 * jcong + 1234567) & 0xFFFFFFFF); }
//   inline double RNOR() {
//     slong h = rand_int32();
//     ulong i = h & 127;
//     return (((ulong) abs((sint) h) < kn[i]) ? h * wn[i] : nfix(h, i));
//   }
//   inline double REXP() {
//     ulong j = rand_int32();
//     ulong i = j & 255;
//     return ((j < ke[i]) ? j * we[i] : efix(j, i));
//   }

//   double nfix(slong h, ulong i);
//   double efix(ulong j, ulong i);
//   void zigset();

//   inline void init()
//     { ulong yo = time(0) + getpid();
//       z = w = jsr = jcong = yo; }
//   inline void init(ulong z_, ulong w_, ulong jsr_, ulong jcong_ )
//     { z = z_; w = w_; jsr = jsr_; jcong = jcong_; }

//   inline ulong rand_int32()         // [0,2^32-1]
//     { return ((MWC() ^ CONG()) + SHR3()) & 0xFFFFFFFF; }
//   inline long rand_int31()          // [0,2^31-1]
//     { return long(rand_int32() >> 1);}
//   inline double rand_closed01()     // [0,1]
//     { return ((double) rand_int32() / 4294967295.0); }
//   inline double rand_open01()       // (0,1)
//     { return (((double) rand_int32() + 0.5) / 4294967296.0); }
//   inline double rand_halfclosed01() // [0,1)
//     { return ((double) rand_int32() / 4294967296.0); }
//   inline double rand_halfopen01()   // (0,1]
//     { return (((double) rand_int32() + 0.5) / 4294967295.5); }

//   // Continuous Distributions
//   inline double uniform(double x = 0.0, double y = 1.0)
//     { return rand_closed01() * (y - x) + x; }
//   inline double normal(double mu = 0.0, double sd = 1.0)
//     { return RNOR() * sd + mu; }
//   inline double exponential(double lambda = 1)
//     { return REXP() / lambda; }
//   double gamma(double shape = 1, double scale = 1);
//   double chi_square(double df)
//     { return gamma(df / 2.0, 0.5); }
//   double beta(double a1, double a2)
//     { double x1 = gamma(a1, 1); return (x1 / (x1 + gamma(a2, 1))); }

//   // Discrete Distributions
//   double poisson(double lambda);
//   int binomial(double pp, int n);

// }; // class RNG

// } // namespace

#endif // RNG_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/degree_sequence_vl/gengraph_vertex_cover.h0000644000175100001710000000444700000000000032131 0ustar00runnerdocker00000000000000/*
 *
 * gengraph - generation of random simple connected graphs with prescribed
 *            degree sequence
 *
 * Copyright (C) 2006  Fabien Viger
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
#ifndef _VERTEX_COVER_H
#define _VERTEX_COVER_H

// vertex_cover() builds a list of vertices which covers every edge of the graph
// Input is a classical adjacency-list graph
// As an output, vertex_cover() modify the degrees in degs[], so that
// any vertex with a degree > 0 belongs to the vertex coverage.
// Moreover, vertex_cover() keeps links[] intact, permuting only the adjacency lists

#include "gengraph_box_list.h"
#include 

namespace gengraph {

void vertex_cover(int n, int *links, int *deg, int **neigh = NULL) {
    int i;
    // create and initialize neigh[]
    if (neigh == NULL) {
        neigh = new int*[n];
        neigh[0] = links;
        for (i = 1; i < n; i++) {
            neigh[i] = neigh[i - 1] + deg[i];
        }
    }
    // create box_list
    box_list bl(n, deg);
    do {
        int v;
        // remove vertices adjacent to vertices of degree 1
        while ((v = bl.get_one()) >= 0) {
            bl.pop_vertex(v, neigh);
        }
        // remove vertex of max degree and its highest-degree neighbour
        if (!bl.is_empty()) {
            v = bl.get_max();
            int *w = neigh[v];
            int v2 = *(w++);
            int dm = deg[v2];
            int k = deg[v] - 1;
            while (k--) if (deg[*(w++)] > dm) {
                    v2 = *(w - 1);
                    dm = deg[v2];
                };
            bl.pop_vertex(v, neigh);
            bl.pop_vertex(v2, neigh);
        }
    } while (!bl.is_empty());
}

} // namespace gengraph

#endif //_VERTEX_COVER_H
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/dotproduct.c0000644000175100001710000002167400000000000024102 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"
#include "igraph_random.h"
#include "igraph_constructors.h"
#include "igraph_blas.h"

/**
 * \function igraph_dot_product_game
 * \brief Generates a random dot product graph.
 *
 * In this model, each vertex is represented by a latent
 * position vector. Probability of an edge between two vertices are given
 * by the dot product of their latent position vectors.
 *
 * 
 * See also Christine Leigh Myers Nickel: Random dot product graphs, a
 * model for social networks. Dissertation, Johns Hopkins University,
 * Maryland, USA, 2006.
 *
 * \param graph The output graph is stored here.
 * \param vecs A matrix in which each latent position vector is a
 *    column. The dot product of the latent position vectors should be
 *    in the [0,1] interval, otherwise a warning is given. For
 *    negative dot products, no edges are added; dot products that are
 *    larger than one always add an edge.
 * \param directed Should the generated graph be directed?
 * \return Error code.
 *
 * Time complexity: O(n*n*m), where n is the number of vertices,
 * and m is the length of the latent vectors.
 *
 * \sa \ref igraph_sample_dirichlet(), \ref
 * igraph_sample_sphere_volume(), \ref igraph_sample_sphere_surface()
 * for functions to generate the latent vectors.
 */

int igraph_dot_product_game(igraph_t *graph, const igraph_matrix_t *vecs,
                            igraph_bool_t directed) {

    igraph_integer_t nrow = igraph_matrix_nrow(vecs);
    igraph_integer_t ncol = igraph_matrix_ncol(vecs);
    int i, j;
    igraph_vector_t edges;
    igraph_bool_t warned_neg = 0, warned_big = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    RNG_BEGIN();

    for (i = 0; i < ncol; i++) {
        int from = directed ? 0 : i + 1;
        igraph_vector_t v1;
        igraph_vector_view(&v1, &MATRIX(*vecs, 0, i), nrow);
        for (j = from; j < ncol; j++) {
            igraph_real_t prob;
            igraph_vector_t v2;
            if (i == j) {
                continue;
            }
            igraph_vector_view(&v2, &MATRIX(*vecs, 0, j), nrow);
            igraph_blas_ddot(&v1, &v2, &prob);
            if (prob < 0 && ! warned_neg) {
                warned_neg = 1;
                IGRAPH_WARNING("Negative connection probability in "
                               "dot-product graph");
            } else if (prob > 1 && ! warned_big) {
                warned_big = 1;
                IGRAPH_WARNING("Greater than 1 connection probability in "
                               "dot-product graph");
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
            } else if (RNG_UNIF01() < prob) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
            }
        }
    }

    RNG_END();

    igraph_create(graph, &edges, ncol, directed);
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_sample_sphere_surface
 * Sample points uniformly from the surface of a sphere
 *
 * The center of the sphere is at the origin.
 *
 * \param dim The dimension of the random vectors.
 * \param n The number of vectors to sample.
 * \param radius Radius of the sphere, it must be positive.
 * \param positive Whether to restrict sampling to the positive
 *    orthant.
 * \param res Pointer to an initialized matrix, the result is
 *    stored here, each column will be a sampled vector. The matrix is
 *    resized, as needed.
 * \return Error code.
 *
 * Time complexity: O(n*dim*g), where g is the time complexity of
 * generating a standard normal random number.
 *
 * \sa \ref igraph_sample_sphere_volume(), \ref
 * igraph_sample_dirichlet() for other similar samplers.
 */

int igraph_sample_sphere_surface(igraph_integer_t dim, igraph_integer_t n,
                                 igraph_real_t radius,
                                 igraph_bool_t positive,
                                 igraph_matrix_t *res) {
    igraph_integer_t i, j;

    if (dim < 2) {
        IGRAPH_ERROR("Sphere must be at least two dimensional to sample from "
                     "surface", IGRAPH_EINVAL);
    }
    if (n < 0) {
        IGRAPH_ERROR("Number of samples must be non-negative", IGRAPH_EINVAL);
    }
    if (radius <= 0) {
        IGRAPH_ERROR("Sphere radius must be positive", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, dim, n));

    RNG_BEGIN();

    for (i = 0; i < n; i++) {
        igraph_real_t *col = &MATRIX(*res, 0, i);
        igraph_real_t sum = 0.0;
        for (j = 0; j < dim; j++) {
            col[j] = RNG_NORMAL(0, 1);
            sum += col[j] * col[j];
        }
        sum = sqrt(sum);
        for (j = 0; j < dim; j++) {
            col[j] = radius * col[j] / sum;
        }
        if (positive) {
            for (j = 0; j < dim; j++) {
                col[j] = fabs(col[j]);
            }
        }
    }

    RNG_END();

    return 0;
}

/**
 * \function igraph_sample_sphere_volume
 * Sample points uniformly from the volume of a sphere
 *
 * The center of the sphere is at the origin.
 *
 * \param dim The dimension of the random vectors.
 * \param n The number of vectors to sample.
 * \param radius Radius of the sphere, it must be positive.
 * \param positive Whether to restrict sampling to the positive
 *    orthant.
 * \param res Pointer to an initialized matrix, the result is
 *    stored here, each column will be a sampled vector. The matrix is
 *    resized, as needed.
 * \return Error code.
 *
 * Time complexity: O(n*dim*g), where g is the time complexity of
 * generating a standard normal random number.
 *
 * \sa \ref igraph_sample_sphere_surface(), \ref
 * igraph_sample_dirichlet() for other similar samplers.
 */


int igraph_sample_sphere_volume(igraph_integer_t dim, igraph_integer_t n,
                                igraph_real_t radius,
                                igraph_bool_t positive,
                                igraph_matrix_t *res) {

    igraph_integer_t i, j;

    /* Arguments are checked by the following call */

    IGRAPH_CHECK(igraph_sample_sphere_surface(dim, n, radius, positive, res));

    RNG_BEGIN();

    for (i = 0; i < n; i++) {
        igraph_real_t *col = &MATRIX(*res, 0, i);
        igraph_real_t U = pow(RNG_UNIF01(), 1.0 / dim);
        for (j = 0; j < dim; j++) {
            col[j] *= U;
        }
    }

    RNG_END();

    return 0;
}

/**
 * \function igraph_sample_dirichlet
 * Sample points from a Dirichlet distribution
 *
 * \param n The number of vectors to sample.
 * \param alpha The parameters of the Dirichlet distribution. They
 *    must be positive. The length of this vector gives the dimension
 *    of the generated samples.
 * \param res Pointer to an initialized matrix, the result is stored
 *    here, one sample in each column. It will be resized, as needed.
 * \return Error code.
 *
 * Time complexity: O(n * dim * g), where dim is the dimension of the
 * sample vectors, set by the length of alpha, and g is the time
 * complexity of sampling from a Gamma distribution.
 *
 * \sa \ref igraph_sample_sphere_surface() and
 * \ref igraph_sample_sphere_volume() for other methods to sample
 * latent vectors.
 */

int igraph_sample_dirichlet(igraph_integer_t n, const igraph_vector_t *alpha,
                            igraph_matrix_t *res) {

    igraph_integer_t len = igraph_vector_size(alpha);
    igraph_integer_t i;
    igraph_vector_t vec;

    if (n < 0) {
        IGRAPH_ERROR("Number of samples should be non-negative",
                     IGRAPH_EINVAL);
    }
    if (len < 2) {
        IGRAPH_ERROR("Dirichlet parameter vector too short, must "
                     "have at least two entries", IGRAPH_EINVAL);
    }
    if (igraph_vector_min(alpha) <= 0) {
        IGRAPH_ERROR("Dirichlet concentration parameters must be positive",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, len, n));

    RNG_BEGIN();

    for (i = 0; i < n; i++) {
        igraph_vector_view(&vec, &MATRIX(*res, 0, i), len);
        igraph_rng_get_dirichlet(igraph_rng_default(), alpha, &vec);
    }

    RNG_END();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/erdos_renyi.c0000644000175100001710000002376600000000000024241 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_nongraph.h"
#include "igraph_random.h"

/**
 * \section about_games
 *
 * Games are randomized graph generators. Randomization means that
 * they generate a different graph every time you call them. 
 */

int igraph_erdos_renyi_game_gnp(
    igraph_t *graph, igraph_integer_t n, igraph_real_t p,
    igraph_bool_t directed, igraph_bool_t loops
) {

    long int no_of_nodes = n;
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    igraph_vector_t s = IGRAPH_VECTOR_NULL;
    int retval = 0;
    long int vsize;

    if (n < 0) {
        IGRAPH_ERROR("Invalid number of vertices", IGRAPH_EINVAL);
    }
    if (p < 0.0 || p > 1.0) {
        IGRAPH_ERROR("Invalid probability given", IGRAPH_EINVAL);
    }

    if (p == 0.0 || no_of_nodes == 0) {
        IGRAPH_CHECK(retval = igraph_empty(graph, n, directed));
    } else if (p == 1.0) {
        IGRAPH_CHECK(retval = igraph_full(graph, n, directed, loops));
    } else {

        long int i;
        double maxedges = n, last;
        if (directed && loops) {
            maxedges *= n;
        } else if (directed && !loops) {
            maxedges *= (n - 1);
        } else if (!directed && loops) {
            maxedges *= (n + 1) / 2.0;
        } else {
            maxedges *= (n - 1) / 2.0;
        }

        IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&s, (long int) (maxedges * p * 1.1)));

        RNG_BEGIN();

        last = RNG_GEOM(p);
        while (last < maxedges) {
            IGRAPH_CHECK(igraph_vector_push_back(&s, last));
            last += RNG_GEOM(p);
            last += 1;
        }

        RNG_END();

        IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&edges, igraph_vector_size(&s) * 2));

        vsize = igraph_vector_size(&s);
        if (directed && loops) {
            for (i = 0; i < vsize; i++) {
                long int to = (long int) floor(VECTOR(s)[i] / no_of_nodes);
                long int from = (long int) (VECTOR(s)[i] - ((igraph_real_t)to) * no_of_nodes);
                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            }
        } else if (directed && !loops) {
            for (i = 0; i < vsize; i++) {
                long int to = (long int) floor(VECTOR(s)[i] / no_of_nodes);
                long int from = (long int) (VECTOR(s)[i] - ((igraph_real_t)to) * no_of_nodes);
                if (from == to) {
                    to = no_of_nodes - 1;
                }
                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            }
        } else if (!directed && loops) {
            for (i = 0; i < vsize; i++) {
                long int to = (long int) floor((sqrt(8 * VECTOR(s)[i] + 1) - 1) / 2);
                long int from = (long int) (VECTOR(s)[i] - (((igraph_real_t)to) * (to + 1)) / 2);
                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            }
        } else { /* !directed && !loops */
            for (i = 0; i < vsize; i++) {
                long int to = (long int) floor((sqrt(8 * VECTOR(s)[i] + 1) + 1) / 2);
                long int from = (long int) (VECTOR(s)[i] - (((igraph_real_t)to) * (to - 1)) / 2);
                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            }
        }

        igraph_vector_destroy(&s);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_CHECK(retval = igraph_create(graph, &edges, n, directed));
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return retval;
}

int igraph_erdos_renyi_game_gnm(
    igraph_t *graph, igraph_integer_t n, igraph_real_t m,
    igraph_bool_t directed, igraph_bool_t loops
) {

    igraph_integer_t no_of_nodes = n;
    igraph_integer_t no_of_edges = (igraph_integer_t) m;
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    igraph_vector_t s = IGRAPH_VECTOR_NULL;
    int retval = 0;

    if (n < 0) {
        IGRAPH_ERROR("Invalid number of vertices", IGRAPH_EINVAL);
    }
    if (m < 0) {
        IGRAPH_ERROR("Invalid number of edges", IGRAPH_EINVAL);
    }

    if (m == 0.0 || no_of_nodes == 0) {
        IGRAPH_CHECK(retval = igraph_empty(graph, n, directed));
    } else {

        long int i;
        double maxedges = n;
        if (directed && loops) {
            maxedges *= n;
        } else if (directed && !loops) {
            maxedges *= (n - 1);
        } else if (!directed && loops) {
            maxedges *= (n + 1) / 2.0;
        } else {
            maxedges *= (n - 1) / 2.0;
        }

        if (no_of_edges > maxedges) {
            IGRAPH_ERROR("Invalid number (too large) of edges", IGRAPH_EINVAL);
        }

        if (maxedges == no_of_edges) {
            retval = igraph_full(graph, n, directed, loops);
        } else {

            long int slen;

            IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
            IGRAPH_CHECK(igraph_random_sample(&s, 0, maxedges - 1,
                                              (igraph_integer_t) no_of_edges));

            IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
            IGRAPH_CHECK(igraph_vector_reserve(&edges, igraph_vector_size(&s) * 2));

            slen = igraph_vector_size(&s);
            if (directed && loops) {
                for (i = 0; i < slen; i++) {
                    long int to = (long int) floor(VECTOR(s)[i] / no_of_nodes);
                    long int from = (long int) (VECTOR(s)[i] - ((igraph_real_t)to) * no_of_nodes);
                    igraph_vector_push_back(&edges, from);
                    igraph_vector_push_back(&edges, to);
                }
            } else if (directed && !loops) {
                for (i = 0; i < slen; i++) {
                    long int from = (long int) floor(VECTOR(s)[i] / (no_of_nodes - 1));
                    long int to = (long int) (VECTOR(s)[i] - ((igraph_real_t)from) * (no_of_nodes - 1));
                    if (from == to) {
                        to = no_of_nodes - 1;
                    }
                    igraph_vector_push_back(&edges, from);
                    igraph_vector_push_back(&edges, to);
                }
            } else if (!directed && loops) {
                for (i = 0; i < slen; i++) {
                    long int to = (long int) floor((sqrt(8 * VECTOR(s)[i] + 1) - 1) / 2);
                    long int from = (long int) (VECTOR(s)[i] - (((igraph_real_t)to) * (to + 1)) / 2);
                    igraph_vector_push_back(&edges, from);
                    igraph_vector_push_back(&edges, to);
                }
            } else { /* !directed && !loops */
                for (i = 0; i < slen; i++) {
                    long int to = (long int) floor((sqrt(8 * VECTOR(s)[i] + 1) + 1) / 2);
                    long int from = (long int) (VECTOR(s)[i] - (((igraph_real_t)to) * (to - 1)) / 2);
                    igraph_vector_push_back(&edges, from);
                    igraph_vector_push_back(&edges, to);
                }
            }

            igraph_vector_destroy(&s);
            IGRAPH_FINALLY_CLEAN(1);
            retval = igraph_create(graph, &edges, n, directed);
            igraph_vector_destroy(&edges);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    return retval;
}

/**
 * \ingroup generators
 * \function igraph_erdos_renyi_game
 * \brief Generates a random (Erdős-Rényi) graph.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param type The type of the random graph, possible values:
 *        \clist
 *        \cli IGRAPH_ERDOS_RENYI_GNM
 *          G(n,m) graph,
 *          m edges are
 *          selected uniformly randomly in a graph with
 *          n vertices.
 *        \cli IGRAPH_ERDOS_RENYI_GNP
 *          G(n,p) graph,
 *          every possible edge is included in the graph with
 *          probability p.
 *        \endclist
 * \param n The number of vertices in the graph.
 * \param p_or_m This is the p parameter for
 *        G(n,p) graphs and the
 *        m
 *        parameter for G(n,m) graphs.
 * \param directed Logical, whether to generate a directed graph.
 * \param loops Logical, whether to generate loops (self) edges.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid
 *         \p type, \p n,
 *         \p p or \p m
 *          parameter.
 *         \c IGRAPH_ENOMEM: there is not enough
 *         memory for the operation.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 * \sa \ref igraph_barabasi_game(), \ref igraph_growing_random_game()
 *
 * \example examples/simple/igraph_erdos_renyi_game.c
 */
int igraph_erdos_renyi_game(igraph_t *graph, igraph_erdos_renyi_t type,
                            igraph_integer_t n, igraph_real_t p_or_m,
                            igraph_bool_t directed, igraph_bool_t loops) {
    int retval = 0;

    if (type == IGRAPH_ERDOS_RENYI_GNP) {
        retval = igraph_erdos_renyi_game_gnp(graph, n, p_or_m, directed, loops);
    } else if (type == IGRAPH_ERDOS_RENYI_GNM) {
        retval = igraph_erdos_renyi_game_gnm(graph, n, p_or_m, directed, loops);
    } else {
        IGRAPH_ERROR("Invalid type", IGRAPH_EINVAL);
    }

    return retval;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/establishment.c0000644000175100001710000001473500000000000024555 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_nongraph.h"
#include "igraph_random.h"

/**
 * \function igraph_establishment_game
 * \brief Generates a graph with a simple growing model with vertex types.
 *
 * 
 * The simulation goes like this: a single vertex is added at each
 * time step. This new vertex tries to connect to \p k vertices in the
 * graph. The probability that such a connection is realized depends
 * on the types of the vertices involved.
 *
 * \param graph Pointer to an uninitialized graph.
 * \param nodes The number of vertices in the graph.
 * \param types The number of vertex types.
 * \param k The number of connections tried in each time step.
 * \param type_dist Vector giving the distribution of vertex types.
 * If \c NULL, the distribution is assumed to be uniform.
 * \param pref_matrix Matrix giving the connection probabilities for
 * different vertex types.
 * \param directed Logical, whether to generate a directed graph.
 * \param node_type_vec An initialized vector or \c NULL.
 * If not \c NULL, the type of each node will be stored here.
 * \return Error code.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|*k*log(|V|)), |V| is the number of vertices
 * and k is the \p k parameter.
 */
int igraph_establishment_game(igraph_t *graph, igraph_integer_t nodes,
                              igraph_integer_t types, igraph_integer_t k,
                              const igraph_vector_t *type_dist,
                              const igraph_matrix_t *pref_matrix,
                              igraph_bool_t directed,
                              igraph_vector_t *node_type_vec) {
    long int i, j;
    igraph_vector_t edges;
    igraph_vector_t cumdist;
    igraph_vector_t potneis;
    igraph_real_t maxcum;
    igraph_vector_t *nodetypes;

    /* Argument contracts */
    if(nodes < 0){
        IGRAPH_ERROR("The number of vertices must be non-negative.", IGRAPH_EINVAL);
    }

    if (types < 1) {
        IGRAPH_ERROR("The number of vertex types must be at least 1.", IGRAPH_EINVAL);
    }

    if (type_dist) {
        igraph_real_t lo;

        if (igraph_vector_size(type_dist) != types) {
            IGRAPH_ERROR("The vertex type distribution vector must agree in length with the number of types.",
                         IGRAPH_EINVAL);
        }

        lo = igraph_vector_min(type_dist);
        if (lo < 0) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain negative values.", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo)) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (igraph_matrix_nrow(pref_matrix) != types || igraph_matrix_ncol(pref_matrix) != types) {
        IGRAPH_ERROR("The preference matrix must be square and agree in dimensions with the number of types.", IGRAPH_EINVAL);
    }

    {
        igraph_real_t lo, hi;
        igraph_matrix_minmax(pref_matrix, &lo, &hi);

        if (lo < 0 || hi > 1) {
            IGRAPH_ERROR("The preference matrix must contain probabilities in [0, 1].", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo) || igraph_is_nan(hi)) {
            IGRAPH_ERROR("The preference matrix must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (! directed && ! igraph_matrix_is_symmetric(pref_matrix)) {
        IGRAPH_ERROR("The preference matrix must be symmetric when generating undirected graphs.", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&cumdist, types + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&potneis, k);

    if (type_dist) {
        VECTOR(cumdist)[0] = 0;
        for (i = 0; i < types; ++i) {
            VECTOR(cumdist)[i + 1] = VECTOR(cumdist)[i] + VECTOR(*type_dist)[i];
        }
    } else {
        for (i = 0; i < types+1; ++i) {
            VECTOR(cumdist)[i] = i;
        }
    }
    maxcum = igraph_vector_tail(&cumdist);

    if (maxcum <= 0) {
        IGRAPH_ERROR("The vertex type distribution vector must contain at least one positive value.", IGRAPH_EINVAL);
    }

    if (node_type_vec) {
        nodetypes = node_type_vec;
        IGRAPH_CHECK(igraph_vector_resize(nodetypes, nodes));
    } else {
        nodetypes = IGRAPH_CALLOC(1, igraph_vector_t);
        if (! nodetypes) {
            IGRAPH_ERROR("Insufficient memory for establishment_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, nodetypes);
        IGRAPH_VECTOR_INIT_FINALLY(nodetypes, nodes);
    }

    RNG_BEGIN();

    for (i = 0; i < nodes; i++) {
        igraph_real_t uni = RNG_UNIF(0, maxcum);
        long int type;
        igraph_vector_binsearch(&cumdist, uni, &type);
        VECTOR(*nodetypes)[i] = type - 1;
    }

    for (i = k; i < nodes; i++) {
        long int type1 = (long int) VECTOR(*nodetypes)[i];
        igraph_random_sample(&potneis, 0, i - 1, k);
        for (j = 0; j < k; j++) {
            long int type2 = (long int) VECTOR(*nodetypes)[(long int)VECTOR(potneis)[j]];
            if (RNG_UNIF01() < MATRIX(*pref_matrix, type1, type2)) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, VECTOR(potneis)[j]));
            }
        }
    }

    RNG_END();

    if (! node_type_vec) {
        igraph_vector_destroy(nodetypes);
        IGRAPH_FREE(nodetypes);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_vector_destroy(&potneis);
    igraph_vector_destroy(&cumdist);
    IGRAPH_FINALLY_CLEAN(2);
    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/forestfire.c0000644000175100001710000002326600000000000024062 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"
#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_progress.h"
#include "igraph_interface.h"
#include "igraph_constructors.h"
#include "igraph_dqueue.h"

#include "core/interruption.h"

typedef struct igraph_i_forest_fire_data_t {
    igraph_vector_t *inneis;
    igraph_vector_t *outneis;
    long int no_of_nodes;
} igraph_i_forest_fire_data_t;


static void igraph_i_forest_fire_free(igraph_i_forest_fire_data_t *data) {
    long int i;
    for (i = 0; i < data->no_of_nodes; i++) {
        igraph_vector_destroy(data->inneis + i);
        igraph_vector_destroy(data->outneis + i);
    }
}

/**
 * \function igraph_forest_fire_game
 * \brief Generates a network according to the \quote forest fire game \endquote.
 *
 * The forest fire model intends to reproduce the following network
 * characteristics, observed in real networks:
 * \ilist
 * \ili Heavy-tailed in-degree distribution.
 * \ili Heavy-tailed out-degree distribution.
 * \ili Communities.
 * \ili Densification power-law. The network is densifying in time,
 *      according to a power-law rule.
 * \ili Shrinking diameter. The diameter of the network decreases in
 *      time.
 * \endilist
 *
 * 
 * The network is generated in the following way. One vertex is added at
 * a time. This vertex connects to (cites) ambs vertices already
 * present in the network, chosen uniformly random. Now, for each cited
 * vertex v we do the following procedure:
 * \olist
 * \oli We generate two random numbers, x and y, that are
 *   geometrically distributed with means p/(1-p) and
 *   rp(1-rp). (p is \p fw_prob, r is
 *   \p bw_factor.) The new vertex cites x outgoing neighbors
 *   and y incoming neighbors of v, from those which are
 *   not yet cited by the new vertex. If there are less than x or
 *   y such vertices available then we cite all of them.
 * \oli The same procedure is applied to all the newly cited
 *   vertices.
 * \endolist
 * 
 * See also:
 * Jure Leskovec, Jon Kleinberg and Christos Faloutsos. Graphs over time:
 * densification laws, shrinking diameters and possible explanations.
 * \emb KDD '05: Proceeding of the eleventh ACM SIGKDD international
 * conference on Knowledge discovery in data mining \eme, 177--187, 2005.
 * 
 * Note however, that the version of the model in the published paper is incorrect
 * in the sense that it cannot generate the kind of graphs the authors
 * claim. A corrected version is available from
 * http://cs.stanford.edu/people/jure/pubs/powergrowth-tkdd.pdf , our
 * implementation is based on this.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the graph.
 * \param fw_prob The forward burning probability.
 * \param bw_factor The backward burning ratio. The backward burning
      probability is calculated as bw.factor*fw.prob.
 * \param pambs The number of ambassador vertices.
 * \param directed Whether to create a directed graph.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_forest_fire_game(igraph_t *graph, igraph_integer_t nodes,
                            igraph_real_t fw_prob, igraph_real_t bw_factor,
                            igraph_integer_t pambs, igraph_bool_t directed) {

    igraph_vector_long_t visited;
    long int no_of_nodes = nodes, actnode, i;
    igraph_vector_t edges;
    igraph_vector_t *inneis, *outneis;
    igraph_i_forest_fire_data_t data;
    igraph_dqueue_t neiq;
    long int ambs = pambs;
    igraph_real_t param_geom_out = 1 - fw_prob;
    igraph_real_t param_geom_in = 1 - fw_prob * bw_factor;

    if (fw_prob < 0 || fw_prob >= 1) {
        IGRAPH_ERROR("Forest fire model: 'fw_prob' must satisfy 0 <= fw_prob < 1.",
                     IGRAPH_EINVAL);
    }
    if (bw_factor * fw_prob < 0 || bw_factor * fw_prob >= 1) {
        IGRAPH_ERROR("Forest fire model: 'bw_factor' must satisfy 0 <= bw_factor * fw_prob < 1.",
                     IGRAPH_EINVAL);
    }
    if (ambs < 0) {
        IGRAPH_ERROR("Forest fire model: Number of ambassadors must not be negative.",
                     IGRAPH_EINVAL);
    }

    if (ambs == 0) {
        IGRAPH_CHECK(igraph_empty(graph, nodes, directed));
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    inneis = IGRAPH_CALLOC(no_of_nodes, igraph_vector_t);
    if (!inneis) {
        IGRAPH_ERROR("Cannot run forest fire model.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, inneis);
    outneis = IGRAPH_CALLOC(no_of_nodes, igraph_vector_t);
    if (!outneis) {
        IGRAPH_ERROR("Cannot run forest fire model.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, outneis);
    data.inneis = inneis;
    data.outneis = outneis;
    data.no_of_nodes = no_of_nodes;
    IGRAPH_FINALLY(igraph_i_forest_fire_free, &data);
    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_CHECK(igraph_vector_init(inneis + i, 0));
        IGRAPH_CHECK(igraph_vector_init(outneis + i, 0));
    }

    IGRAPH_CHECK(igraph_vector_long_init(&visited, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &visited);
    IGRAPH_DQUEUE_INIT_FINALLY(&neiq, 10);

    RNG_BEGIN();

#define ADD_EDGE_TO(nei) \
    if (VECTOR(visited)[(nei)] != actnode+1) {                     \
        VECTOR(visited)[(nei)] = actnode+1;                          \
        IGRAPH_CHECK(igraph_dqueue_push(&neiq, nei));                \
        IGRAPH_CHECK(igraph_vector_push_back(&edges, actnode));      \
        IGRAPH_CHECK(igraph_vector_push_back(&edges, nei));          \
        IGRAPH_CHECK(igraph_vector_push_back(outneis+actnode, nei)); \
        IGRAPH_CHECK(igraph_vector_push_back(inneis+nei, actnode));  \
    }

    IGRAPH_PROGRESS("Forest fire: ", 0.0, NULL);

    for (actnode = 1; actnode < no_of_nodes; actnode++) {

        IGRAPH_PROGRESS("Forest fire: ", 100.0 * actnode / no_of_nodes, NULL);

        IGRAPH_ALLOW_INTERRUPTION();

        /* We don't want to visit the current vertex */
        VECTOR(visited)[actnode] = actnode + 1;

        /* Choose ambassador(s) */
        for (i = 0; i < ambs; i++) {
            long int a = RNG_INTEGER(0, actnode - 1);
            ADD_EDGE_TO(a);
        }

        while (!igraph_dqueue_empty(&neiq)) {
            long int actamb = (long int) igraph_dqueue_pop(&neiq);
            igraph_vector_t *outv = outneis + actamb;
            igraph_vector_t *inv = inneis + actamb;
            long int no_in = igraph_vector_size(inv);
            long int no_out = igraph_vector_size(outv);
            long int neis_out = (long int) RNG_GEOM(param_geom_out);
            long int neis_in = (long int) RNG_GEOM(param_geom_in);
            /* outgoing neighbors */
            if (neis_out >= no_out) {
                for (i = 0; i < no_out; i++) {
                    long int nei = (long int) VECTOR(*outv)[i];
                    ADD_EDGE_TO(nei);
                }
            } else {
                long int oleft = no_out;
                for (i = 0; i < neis_out && oleft > 0; ) {
                    long int which = RNG_INTEGER(0, oleft - 1);
                    long int nei = (long int) VECTOR(*outv)[which];
                    VECTOR(*outv)[which] = VECTOR(*outv)[oleft - 1];
                    VECTOR(*outv)[oleft - 1] = nei;
                    if (VECTOR(visited)[nei] != actnode + 1) {
                        ADD_EDGE_TO(nei);
                        i++;
                    }
                    oleft--;
                }
            }
            /* incoming neighbors */
            if (neis_in >= no_in) {
                for (i = 0; i < no_in; i++) {
                    long int nei = (long int) VECTOR(*inv)[i];
                    ADD_EDGE_TO(nei);
                }
            } else {
                long int ileft = no_in;
                for (i = 0; i < neis_in && ileft > 0; ) {
                    long int which = RNG_INTEGER(0, ileft - 1);
                    long int nei = (long int) VECTOR(*inv)[which];
                    VECTOR(*inv)[which] = VECTOR(*inv)[ileft - 1];
                    VECTOR(*inv)[ileft - 1] = nei;
                    if (VECTOR(visited)[nei] != actnode + 1) {
                        ADD_EDGE_TO(nei);
                        i++;
                    }
                    ileft--;
                }
            }

        } /* while neiq not empty */

    } /* actnode < no_of_nodes */

#undef ADD_EDGE_TO

    RNG_END();

    IGRAPH_PROGRESS("Forest fire: ", 100.0, NULL);

    igraph_dqueue_destroy(&neiq);
    igraph_vector_long_destroy(&visited);
    igraph_i_forest_fire_free(&data);
    igraph_free(outneis);
    igraph_free(inneis);
    IGRAPH_FINALLY_CLEAN(5);

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/grg.c0000644000175100001710000001234200000000000022462 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_random.h"

#include "core/interruption.h"

/**
 * \function igraph_grg_game
 * \brief Generates a geometric random graph.
 *
 * A geometric random graph is created by dropping points (i.e. vertices)
 * randomly on the unit square and then connecting all those pairs
 * which are less than \c radius apart in Euclidean distance.
 *
 * 
 * Original code contributed by Keith Briggs, thanks Keith.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the graph.
 * \param radius The radius within which the vertices will be connected.
 * \param torus Logical constant. If true, periodic boundary conditions
 *        will be used, i.e. the vertices are assumed to be on a torus
 *        instead of a square.
 * \param x An initialized vector or \c NULL. If not \c NULL, the points'
 *          x coordinates will be returned here.
 * \param y An initialized vector or \c NULL. If not \c NULL, the points'
 *          y coordinates will be returned here.
 * \return Error code.
 *
 * Time complexity: TODO, less than O(|V|^2+|E|).
 *
 * \example examples/simple/igraph_grg_game.c
 */
int igraph_grg_game(igraph_t *graph, igraph_integer_t nodes,
                    igraph_real_t radius, igraph_bool_t torus,
                    igraph_vector_t *x, igraph_vector_t *y) {

    long int i;
    igraph_vector_t myx, myy, *xx = &myx, *yy = &myy, edges;
    igraph_real_t r2 = radius * radius;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, nodes));

    if (x) {
        xx = x;
        IGRAPH_CHECK(igraph_vector_resize(xx, nodes));
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(xx, nodes);
    }
    if (y) {
        yy = y;
        IGRAPH_CHECK(igraph_vector_resize(yy, nodes));
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(yy, nodes);
    }

    RNG_BEGIN();

    for (i = 0; i < nodes; i++) {
        VECTOR(*xx)[i] = RNG_UNIF01();
        VECTOR(*yy)[i] = RNG_UNIF01();
    }

    RNG_END();

    igraph_vector_sort(xx);

    if (!torus) {
        for (i = 0; i < nodes; i++) {
            igraph_real_t xx1 = VECTOR(*xx)[i];
            igraph_real_t yy1 = VECTOR(*yy)[i];
            long int j = i + 1;
            igraph_real_t dx, dy;

            IGRAPH_ALLOW_INTERRUPTION();

            while ( j < nodes && (dx = VECTOR(*xx)[j] - xx1) < radius) {
                dy = VECTOR(*yy)[j] - yy1;
                if (dx * dx + dy * dy < r2) {
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
                }
                j++;
            }
        }
    } else {
        for (i = 0; i < nodes; i++) {
            igraph_real_t xx1 = VECTOR(*xx)[i];
            igraph_real_t yy1 = VECTOR(*yy)[i];
            long int j = i + 1;
            igraph_real_t dx, dy;

            IGRAPH_ALLOW_INTERRUPTION();

            while ( j < nodes && (dx = VECTOR(*xx)[j] - xx1) < radius) {
                dy = fabs(VECTOR(*yy)[j] - yy1);
                if (dx > 0.5) {
                    dx = 1 - dx;
                }
                if (dy > 0.5) {
                    dy = 1 - dy;
                }
                if (dx * dx + dy * dy < r2) {
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
                }
                j++;
            }
            if (j == nodes) {
                j = 0;
                while (j < i && (dx = 1 - xx1 + VECTOR(*xx)[j]) < radius &&
                       xx1 - VECTOR(*xx)[j] >= radius) {
                    dy = fabs(VECTOR(*yy)[j] - yy1);
                    if (dy > 0.5) {
                        dy = 1 - dy;
                    }
                    if (dx * dx + dy * dy < r2) {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
                    }
                    j++;
                }
            }
        }
    }

    if (!y) {
        igraph_vector_destroy(yy);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!x) {
        igraph_vector_destroy(xx);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, IGRAPH_UNDIRECTED));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/growing_random.c0000644000175100001710000000634600000000000024726 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_random.h"

/**
 * \ingroup generators
 * \function igraph_growing_random_game
 * \brief Generates a growing random graph.
 *
 * 
 * This function simulates a growing random graph. We start out with
 * one vertex. In each step a new vertex is added and a number of new
 * edges are also added. These graphs are known to be different
 * from standard (not growing) random graphs.
 * \param graph Uninitialized graph object.
 * \param n The number of vertices in the graph.
 * \param m The number of edges to add in a time step (i.e. after
 *        adding a vertex).
 * \param directed Boolean, whether to generate a directed graph.
 * \param citation Boolean, if \c TRUE, the edges always
 *        originate from the most recently added vertex and are
 *        connected to a previous vertex.
 * \return Error code:
 *          \c IGRAPH_EINVAL: invalid
 *          \p n or \p m
 *          parameter.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges.
 */
int igraph_growing_random_game(igraph_t *graph, igraph_integer_t n,
                               igraph_integer_t m, igraph_bool_t directed,
                               igraph_bool_t citation) {

    long int no_of_nodes = n;
    long int no_of_neighbors = m;
    long int no_of_edges;
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;

    long int resp = 0;

    long int i, j;

    if (n < 0) {
        IGRAPH_ERROR("Invalid number of vertices", IGRAPH_EINVAL);
    }
    if (m < 0) {
        IGRAPH_ERROR("Invalid number of edges per step (m)", IGRAPH_EINVAL);
    }

    no_of_edges = (no_of_nodes - 1) * no_of_neighbors;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    RNG_BEGIN();

    for (i = 1; i < no_of_nodes; i++) {
        for (j = 0; j < no_of_neighbors; j++) {
            if (citation) {
                long int to = RNG_INTEGER(0, i - 1);
                VECTOR(edges)[resp++] = i;
                VECTOR(edges)[resp++] = to;
            } else {
                long int from = RNG_INTEGER(0, i);
                long int to = RNG_INTEGER(1, i);
                VECTOR(edges)[resp++] = from;
                VECTOR(edges)[resp++] = to;
            }
        }
    }

    RNG_END();

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/islands.c0000644000175100001710000001273200000000000023343 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_random.h"

/**
 * \ingroup generators
 * \function igraph_simple_interconnected_islands_game
 * \brief Generates a random graph made of several interconnected islands, each island being a random graph.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param islands_n The number of islands in the graph.
 * \param islands_size The size of islands in the graph.
 * \param islands_pin The probability to create each possible edge into each island.
 * \param n_inter The number of edges to create between two islands.
 *
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid parameter
 *         \c IGRAPH_ENOMEM: there is not enough
 *         memory for the operation.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 */
int igraph_simple_interconnected_islands_game(
        igraph_t *graph,
        igraph_integer_t islands_n,
        igraph_integer_t islands_size,
        igraph_real_t islands_pin,
        igraph_integer_t n_inter) {


    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    igraph_vector_t s = IGRAPH_VECTOR_NULL;
    int nbNodes;
    double maxpossibleedgesPerIsland;
    double maxedgesPerIsland;
    int nbEdgesInterIslands;
    double maxedges;
    int startIsland = 0;
    int endIsland = 0;
    int i, j, is;
    double myrand, last;
    long int vsize;

    if (islands_n < 0) {
        IGRAPH_ERRORF("Number of islands cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, islands_n);
    }
    if (islands_size < 0) {
        IGRAPH_ERRORF("Size of islands cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, islands_size);
    }
    if (islands_pin < 0 || islands_pin > 1) {
        IGRAPH_ERRORF("Edge probability within islands should be between 0 and 1, got %g.", IGRAPH_EINVAL, islands_pin);
    }
    if (n_inter < 0) {
        IGRAPH_ERRORF("Number of inter-island links cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, n_inter);
    }

    /* how much memory ? */
    nbNodes = islands_n * islands_size;
    maxpossibleedgesPerIsland = ((double)islands_size * ((double)islands_size - (double)1)) / (double)2;
    maxedgesPerIsland = islands_pin * maxpossibleedgesPerIsland;
    nbEdgesInterIslands = n_inter * (islands_n * (islands_n - 1)) / 2;
    maxedges = maxedgesPerIsland * islands_n + nbEdgesInterIslands;

    /* reserve enough space for all the edges */
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, (long int) maxedges));

    RNG_BEGIN();

    /* first create all the islands */
    for (is = 0; is < islands_n; is++) { /* for each island */

        /* index for start and end of nodes in this island */
        startIsland = islands_size * is;
        endIsland = startIsland + islands_size - 1;

        /* create the random numbers to be used (into s) */
        IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&s, (long int) maxedgesPerIsland));

        last = RNG_GEOM(islands_pin);
        while (last < maxpossibleedgesPerIsland) { /* maxedgesPerIsland */
            IGRAPH_CHECK(igraph_vector_push_back(&s, last));
            myrand = RNG_GEOM(islands_pin);
            last += myrand; /* RNG_GEOM(islands_pin); */
            last += 1;
        }



        /* change this to edges ! */
        vsize = igraph_vector_size(&s);
        for (i = 0; i < vsize; i++) {
            long int to = (long int) floor((sqrt(8 * VECTOR(s)[i] + 1) + 1) / 2);
            long int from = (long int) (VECTOR(s)[i] - (((igraph_real_t)to) * (to - 1)) / 2);
            to += startIsland;
            from += startIsland;

            igraph_vector_push_back(&edges, from);
            igraph_vector_push_back(&edges, to);
        }

        /* clear the memory used for random number for this island */
        igraph_vector_destroy(&s);
        IGRAPH_FINALLY_CLEAN(1);


        /* create the links with other islands */
        for (i = is + 1; i < islands_n; i++) { /* for each other island (not the previous ones) */

            for (j = 0; j < n_inter; j++) { /* for each link between islands */
                long int from = RNG_INTEGER(startIsland, endIsland);
                long int to = RNG_INTEGER(i * islands_size, (i + 1) * islands_size - 1);

                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            }

        }
    }

    RNG_END();

    /* actually fill the graph object */
    IGRAPH_CHECK(igraph_create(graph, &edges, nbNodes, 0));

    /* clean remaining things */
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/k_regular.c0000644000175100001710000000665500000000000023670 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_interface.h"

/**
 * \ingroup generators
 * \function igraph_k_regular_game
 * \brief Generates a random graph where each vertex has the same degree.
 *
 * This game generates a directed or undirected random graph where the
 * degrees of vertices are equal to a predefined constant k. For undirected
 * graphs, at least one of k and the number of vertices must be even.
 *
 * 
 * Currently, this game simply uses \ref igraph_degree_sequence_game with
 * the \c SIMPLE_NO_MULTIPLE method and appropriately constructed degree sequences.
 * Thefore, it does not sample uniformly: while it can generate all k-regular graphs
 * with the given number of vertices, it does not generate each one with the same
 * probability.
 *
 * \param graph        Pointer to an uninitialized graph object.
 * \param no_of_nodes  The number of nodes in the generated graph.
 * \param k            The degree of each vertex in an undirected graph, or
 *                     the out-degree and in-degree of each vertex in a
 *                     directed graph.
 * \param directed     Whether the generated graph will be directed.
 * \param multiple     Whether to allow multiple edges in the generated graph.
 *
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid parameter; e.g., negative number of nodes,
 *                           or odd number of nodes and odd k for undirected
 *                           graphs.
 *         \c IGRAPH_ENOMEM: there is not enough memory for the operation.
 *
 * Time complexity: O(|V|+|E|) if \c multiple is true, otherwise not known.
 */
int igraph_k_regular_game(igraph_t *graph,
                          igraph_integer_t no_of_nodes, igraph_integer_t k,
                          igraph_bool_t directed, igraph_bool_t multiple) {
    igraph_vector_t degseq;
    igraph_degseq_t mode = multiple ? IGRAPH_DEGSEQ_SIMPLE : IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE;

    /* Note to self: we are not using IGRAPH_DEGSEQ_VL when multiple = false
     * because the VL method is not really good at generating k-regular graphs.
     * Actually, that's why we have added SIMPLE_NO_MULTIPLE. */

    if (no_of_nodes < 0) {
        IGRAPH_ERROR("number of nodes must be non-negative", IGRAPH_EINVAL);
    }
    if (k < 0) {
        IGRAPH_ERROR("degree must be non-negative", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(°seq, no_of_nodes);
    igraph_vector_fill(°seq, k);
    IGRAPH_CHECK(igraph_degree_sequence_game(graph, °seq, directed ? °seq : 0, mode));

    igraph_vector_destroy(°seq);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/preference.c0000644000175100001710000006042100000000000024022 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_memory.h"
#include "igraph_random.h"

#include "core/interruption.h"

static void igraph_i_preference_game_free_vids_by_type(igraph_vector_ptr_t *vecs) {
    int i = 0, n;
    igraph_vector_t *v;

    n = (int) igraph_vector_ptr_size(vecs);
    for (i = 0; i < n; i++) {
        v = (igraph_vector_t*)VECTOR(*vecs)[i];
        if (v) {
            igraph_vector_destroy(v);
        }
    }
    igraph_vector_ptr_destroy_all(vecs);
}

/**
 * \function igraph_preference_game
 * \brief Generates a graph with vertex types and connection preferences.
 *
 * 
 * This is practically the nongrowing variant of
 * \ref igraph_establishment_game(). A given number of vertices are
 * generated. Every vertex is assigned to a vertex type according to
 * the given type probabilities. Finally, every
 * vertex pair is evaluated and an edge is created between them with a
 * probability depending on the types of the vertices involved.
 *
 * 
 * In other words, this function generates a graph according to a
 * block-model. Vertices are divided into groups (or blocks), and
 * the probability the two vertices are connected depends on their
 * groups only.
 *
 * \param graph Pointer to an uninitialized graph.
 * \param nodes The number of vertices in the graph.
 * \param types The number of vertex types.
 * \param type_dist Vector giving the distribution of vertex types. If
 *   \c NULL, all vertex types will have equal probability. See also the
 *   \p fixed_sizes argument.
 * \param fixed_sizes Boolean. If true, then the number of vertices with a
 *   given vertex type is fixed and the \p type_dist argument gives these
 *   numbers for each vertex type. If true, and \p type_dist is \c NULL,
 *   then the function tries to make vertex groups of the same size. If this
 *   is not possible, then some groups will have an extra vertex.
 * \param pref_matrix Matrix giving the connection probabilities for
 *   different vertex types. This should be symmetric if the requested
 *   graph is undirected.
 * \param node_type_vec A vector where the individual generated vertex types
 *   will be stored. If \c NULL, the vertex types won't be saved.
 * \param directed Logical, whether to generate a directed graph. If undirected
 *   graphs are requested, only the lower left triangle of the preference
 *   matrix is considered.
 * \param loops Logical, whether loop edges are allowed.
 * \return Error code.
 *
 * Added in version 0.3.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 * \sa \ref igraph_asymmetric_preference_game(),
 * \ref igraph_establishment_game(), \ref igraph_callaway_traits_game()
 */

int igraph_preference_game(igraph_t *graph, igraph_integer_t nodes,
                           igraph_integer_t types,
                           const igraph_vector_t *type_dist,
                           igraph_bool_t fixed_sizes,
                           const igraph_matrix_t *pref_matrix,
                           igraph_vector_t *node_type_vec,
                           igraph_bool_t directed,
                           igraph_bool_t loops) {

    long int i, j;
    igraph_vector_t edges, s;
    igraph_vector_t* nodetypes;
    igraph_vector_ptr_t vids_by_type;
    igraph_real_t maxcum, maxedges;

    if(nodes < 0){
        IGRAPH_ERROR("The number of vertices must be non-negative.", IGRAPH_EINVAL);
    }

    if (types < 1) {
        IGRAPH_ERROR("The number of vertex types must be at least 1.", IGRAPH_EINVAL);
    }

    if (type_dist) {
        igraph_real_t lo;

        if (igraph_vector_size(type_dist) != types) {
            IGRAPH_ERROR("The vertex type distribution vector must agree in length with the number of types.",
                         IGRAPH_EINVAL);
        }

        lo = igraph_vector_min(type_dist);
        if (lo < 0) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain negative values.", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo)) {
            IGRAPH_ERROR("The vertex type distribution vector must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (igraph_matrix_nrow(pref_matrix) != types || igraph_matrix_ncol(pref_matrix) != types) {
        IGRAPH_ERROR("The preference matrix must be square and agree in dimensions with the number of types.", IGRAPH_EINVAL);
    }

    {
        igraph_real_t lo, hi;
        igraph_matrix_minmax(pref_matrix, &lo, &hi);

        if (lo < 0 || hi > 1) {
            IGRAPH_ERROR("The preference matrix must contain probabilities in [0, 1].", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo) || igraph_is_nan(hi)) {
            IGRAPH_ERROR("The preference matrix must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (! directed && ! igraph_matrix_is_symmetric(pref_matrix)) {
        IGRAPH_ERROR("The preference matrix must be symmetric when generating undirected graphs.", IGRAPH_EINVAL);
    }

    if (fixed_sizes && type_dist) {
        if (igraph_vector_sum(type_dist) != nodes) {
            IGRAPH_ERROR("Invalid group sizes, their sum must match the number of vertices.", IGRAPH_EINVAL);
        }
    }

    if (node_type_vec) {
        IGRAPH_CHECK(igraph_vector_resize(node_type_vec, nodes));
        nodetypes = node_type_vec;
    } else {
        nodetypes = IGRAPH_CALLOC(1, igraph_vector_t);
        if (nodetypes == 0) {
            IGRAPH_ERROR("Insufficient memory for preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, nodetypes);
        IGRAPH_VECTOR_INIT_FINALLY(nodetypes, nodes);
    }

    IGRAPH_CHECK(igraph_vector_ptr_init(&vids_by_type, types));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &vids_by_type);
    for (i = 0; i < types; i++) {
        VECTOR(vids_by_type)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
        if (VECTOR(vids_by_type)[i] == 0) {
            IGRAPH_ERROR("Insufficient memory for preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(VECTOR(vids_by_type)[i], 0));
    }
    IGRAPH_FINALLY_CLEAN(1);   /* removing igraph_vector_ptr_destroy_all */
    IGRAPH_FINALLY(igraph_i_preference_game_free_vids_by_type, &vids_by_type);

    RNG_BEGIN();

    if (!fixed_sizes) {

        igraph_vector_t cumdist;
        IGRAPH_VECTOR_INIT_FINALLY(&cumdist, types + 1);

        VECTOR(cumdist)[0] = 0;
        if (type_dist) {
            for (i = 0; i < types; i++) {
                VECTOR(cumdist)[i + 1] = VECTOR(cumdist)[i] + VECTOR(*type_dist)[i];
            }
        } else {
            for (i = 0; i < types; i++) {
                VECTOR(cumdist)[i + 1] = i + 1;
            }
        }
        maxcum = igraph_vector_tail(&cumdist);

        for (i = 0; i < nodes; i++) {
            long int type1;
            igraph_real_t uni1 = RNG_UNIF(0, maxcum);
            igraph_vector_binsearch(&cumdist, uni1, &type1);
            VECTOR(*nodetypes)[i] = type1 - 1;
            IGRAPH_CHECK(igraph_vector_push_back(
                             (igraph_vector_t*)VECTOR(vids_by_type)[type1 - 1], i));
        }

        igraph_vector_destroy(&cumdist);
        IGRAPH_FINALLY_CLEAN(1);

    } else {
        long int an = 0;
        if (type_dist) {
            for (i = 0; i < types; i++) {
                long int no = (long int) VECTOR(*type_dist)[i];
                igraph_vector_t *v = VECTOR(vids_by_type)[i];
                for (j = 0; j < no && an < nodes; j++) {
                    VECTOR(*nodetypes)[an] = i;
                    IGRAPH_CHECK(igraph_vector_push_back(v, an));
                    an++;
                }
            }
        } else {
            long int fixno = (long int) ceil( (double)nodes / types);
            for (i = 0; i < types; i++) {
                igraph_vector_t *v = VECTOR(vids_by_type)[i];
                for (j = 0; j < fixno && an < nodes; j++) {
                    VECTOR(*nodetypes)[an++] = i;
                    IGRAPH_CHECK(igraph_vector_push_back(v, an));
                    an++;
                }
            }
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&s, 0);

    for (i = 0; i < types; i++) {
        for (j = 0; j < types; j++) {
            /* Generating the random subgraph between vertices of type i and j */
            long int k, l;
            igraph_real_t p, last;
            igraph_vector_t *v1, *v2;
            long int v1_size, v2_size;

            IGRAPH_ALLOW_INTERRUPTION();

            v1 = (igraph_vector_t*)VECTOR(vids_by_type)[i];
            v2 = (igraph_vector_t*)VECTOR(vids_by_type)[j];
            v1_size = igraph_vector_size(v1);
            v2_size = igraph_vector_size(v2);

            p = MATRIX(*pref_matrix, i, j);
            igraph_vector_clear(&s);
            if (i != j) {
                /* The two vertex sets are disjoint, this is the easier case */
                if (i > j && !directed) {
                    continue;
                }
                maxedges = v1_size * v2_size;
            } else {
                if (directed && loops) {
                    maxedges = v1_size * v1_size;
                } else if (directed && !loops) {
                    maxedges = v1_size * (v1_size - 1);
                } else if (!directed && loops) {
                    maxedges = v1_size * (v1_size + 1) / 2;
                } else {
                    maxedges = v1_size * (v1_size - 1) / 2;
                }
            }

            IGRAPH_CHECK(igraph_vector_reserve(&s, (long int) (maxedges * p * 1.1)));

            last = RNG_GEOM(p);
            while (last < maxedges) {
                IGRAPH_CHECK(igraph_vector_push_back(&s, last));
                last += RNG_GEOM(p);
                last += 1;
            }
            l = igraph_vector_size(&s);

            IGRAPH_CHECK(igraph_vector_reserve(&edges, igraph_vector_size(&edges) + l * 2));

            if (i != j) {
                /* Generating the subgraph between vertices of type i and j */
                for (k = 0; k < l; k++) {
                    long int to = (long int) floor(VECTOR(s)[k] / v1_size);
                    long int from = (long int) (VECTOR(s)[k] - ((igraph_real_t)to) * v1_size);
                    igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                    igraph_vector_push_back(&edges, VECTOR(*v2)[to]);
                }
            } else {
                /* Generating the subgraph among vertices of type i */
                if (directed && loops) {
                    for (k = 0; k < l; k++) {
                        long int to = (long int) floor(VECTOR(s)[k] / v1_size);
                        long int from = (long int) (VECTOR(s)[k] - ((igraph_real_t)to) * v1_size);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[to]);
                    }
                } else if (directed && !loops) {
                    for (k = 0; k < l; k++) {
                        long int to = (long int) floor(VECTOR(s)[k] / v1_size);
                        long int from = (long int) (VECTOR(s)[k] - ((igraph_real_t)to) * v1_size);
                        if (from == to) {
                            to = v1_size - 1;
                        }
                        igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[to]);
                    }
                } else if (!directed && loops) {
                    for (k = 0; k < l; k++) {
                        long int to = (long int) floor((sqrt(8 * VECTOR(s)[k] + 1) - 1) / 2);
                        long int from = (long int) (VECTOR(s)[k] - (((igraph_real_t)to) * (to + 1)) / 2);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[to]);
                    }
                } else {
                    for (k = 0; k < l; k++) {
                        long int to = (long int) floor((sqrt(8 * VECTOR(s)[k] + 1) + 1) / 2);
                        long int from = (long int) (VECTOR(s)[k] - (((igraph_real_t)to) * (to - 1)) / 2);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                        igraph_vector_push_back(&edges, VECTOR(*v1)[to]);
                    }
                }
            }
        }
    }

    RNG_END();

    igraph_vector_destroy(&s);
    igraph_i_preference_game_free_vids_by_type(&vids_by_type);
    IGRAPH_FINALLY_CLEAN(2);

    if (node_type_vec == 0) {
        igraph_vector_destroy(nodetypes);
        IGRAPH_FREE(nodetypes);
        IGRAPH_FINALLY_CLEAN(2);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_asymmetric_preference_game
 * \brief Generates a graph with asymmetric vertex types and connection preferences.
 *
 * 
 * This is the asymmetric variant of \ref igraph_preference_game().
 * A given number of vertices are generated. Every vertex is assigned to an
 * "outgoing" and an "incoming " vertex type according to the given joint
 * type probabilities. Finally, every vertex pair is evaluated and a
 * directed edge is created between them with a probability depending on the
 * "outgoing" type of the source vertex and the "incoming" type of the target
 * vertex.
 *
 * \param graph Pointer to an uninitialized graph.
 * \param nodes The number of vertices in the graph.
 * \param out_types The number of vertex out-types.
 * \param in_types The number of vertex in-types.
 * \param type_dist_matrix Matrix of size out_types * in_types,
 *   giving the joint distribution of vertex types.
 *   If \c NULL, incoming and outgoing vertex types are independent and uniformly
 *   distributed.
 * \param pref_matrix Matrix of size out_types * in_types,
 *   giving the connection probabilities for different vertex types.
 * \param node_type_out_vec A vector where the individual generated "outgoing"
 *   vertex types will be stored. If \c NULL, the vertex types won't be saved.
 * \param node_type_in_vec A vector where the individual generated "incoming"
 *   vertex types will be stored. If \c NULL, the vertex types won't be saved.
 * \param loops Logical, whether loop edges are allowed.
 * \return Error code.
 *
 * Added in version 0.3.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 * \sa \ref igraph_preference_game()
 */

int igraph_asymmetric_preference_game(igraph_t *graph, igraph_integer_t nodes,
                                      igraph_integer_t out_types,
                                      igraph_integer_t in_types,
                                      const igraph_matrix_t *type_dist_matrix,
                                      const igraph_matrix_t *pref_matrix,
                                      igraph_vector_t *node_type_out_vec,
                                      igraph_vector_t *node_type_in_vec,
                                      igraph_bool_t loops) {

    long int i, j, k;
    igraph_vector_t edges, cumdist, s, intersect;
    igraph_vector_t *nodetypes_in;
    igraph_vector_t *nodetypes_out;
    igraph_vector_ptr_t vids_by_intype, vids_by_outtype;
    igraph_real_t maxcum, maxedges;

    if(nodes < 0){
        IGRAPH_ERROR("The number of vertices must not be negative.", IGRAPH_EINVAL);
    }

    if (in_types < 1) {
        IGRAPH_ERROR("The number of vertex in-types must be at least 1.", IGRAPH_EINVAL);
    }

    if (out_types < 1) {
        IGRAPH_ERROR("The number of vertex out-types must be at least 1.", IGRAPH_EINVAL);
    }

    if (type_dist_matrix) {
        igraph_real_t lo;

        if (igraph_matrix_nrow(type_dist_matrix) != out_types ||
            igraph_matrix_ncol(type_dist_matrix) != in_types) {
            IGRAPH_ERROR("The type distribution matrix must have dimensions out_types * in_types.", IGRAPH_EINVAL);
        }

        lo = igraph_matrix_min(type_dist_matrix);
        if (lo < 0) {
            IGRAPH_ERROR("The type distribution matrix must not contain negative values.", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo)) {
            IGRAPH_ERROR("The type distribution matrix must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    if (igraph_matrix_nrow(pref_matrix) != out_types ||
        igraph_matrix_ncol(pref_matrix) != in_types) {
        IGRAPH_ERROR("The preference matrix must have dimensions out_types * in_types.", IGRAPH_EINVAL);
    }

    {
        igraph_real_t lo, hi;
        igraph_matrix_minmax(pref_matrix, &lo, &hi);

        if (lo < 0 || hi > 1) {
            IGRAPH_ERROR("The preference matrix must contain probabilities in [0, 1].", IGRAPH_EINVAL);
        }
        if (igraph_is_nan(lo) || igraph_is_nan(hi)) {
            IGRAPH_ERROR("The preference matrix must not contain NaN.", IGRAPH_EINVAL);
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&cumdist, in_types * out_types + 1);

    if (node_type_in_vec) {
        nodetypes_in = node_type_in_vec;
        IGRAPH_CHECK(igraph_vector_resize(nodetypes_in, nodes));
    } else {
        nodetypes_in = IGRAPH_CALLOC(1, igraph_vector_t);
        if (nodetypes_in == 0) {
            IGRAPH_ERROR("Insufficient memory for asymmetric_preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_VECTOR_INIT_FINALLY(nodetypes_in, nodes);
    }

    if (node_type_out_vec) {
        nodetypes_out = node_type_out_vec;
        IGRAPH_CHECK(igraph_vector_resize(nodetypes_out, nodes));
    } else {
        nodetypes_out = IGRAPH_CALLOC(1, igraph_vector_t);
        if (nodetypes_out == 0) {
            IGRAPH_ERROR("Insufficient memory for asymmetric_preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_VECTOR_INIT_FINALLY(nodetypes_out, nodes);
    }

    IGRAPH_CHECK(igraph_vector_ptr_init(&vids_by_intype, in_types));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &vids_by_intype);
    IGRAPH_CHECK(igraph_vector_ptr_init(&vids_by_outtype, out_types));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &vids_by_outtype);
    for (i = 0; i < in_types; i++) {
        VECTOR(vids_by_intype)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
        if (! VECTOR(vids_by_intype)[i]) {
            IGRAPH_ERROR("Insufficient memory for asymmetric_preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(VECTOR(vids_by_intype)[i], 0));
    }
    for (i = 0; i < out_types; i++) {
        VECTOR(vids_by_outtype)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
        if (! VECTOR(vids_by_outtype)[i]) {
            IGRAPH_ERROR("Insufficient memory for asymmetric_preference_game.", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(VECTOR(vids_by_outtype)[i], 0));
    }
    IGRAPH_FINALLY_CLEAN(2);   /* removing igraph_vector_ptr_destroy_all */
    IGRAPH_FINALLY(igraph_i_preference_game_free_vids_by_type, &vids_by_intype);
    IGRAPH_FINALLY(igraph_i_preference_game_free_vids_by_type, &vids_by_outtype);

    VECTOR(cumdist)[0] = 0;
    if (type_dist_matrix) {
        for (i = 0, k = 0; i < out_types; i++) {
            for (j = 0; j < in_types; j++, k++) {
                VECTOR(cumdist)[k + 1] = VECTOR(cumdist)[k] + MATRIX(*type_dist_matrix, i, j);
            }
        }
    } else {
        for (i = 0; i < out_types * in_types; i++) {
            VECTOR(cumdist)[i + 1] = i + 1;
        }
    }
    maxcum = igraph_vector_tail(&cumdist);

    RNG_BEGIN();

    for (i = 0; i < nodes; i++) {
        long int type1, type2;
        igraph_real_t uni1 = RNG_UNIF(0, maxcum);
        igraph_vector_binsearch(&cumdist, uni1, &type1);
        type2 = (type1 - 1) % (long int) out_types;
        type1 = (type1 - 1) / (long int) out_types;
        VECTOR(*nodetypes_in)[i] = type1;
        VECTOR(*nodetypes_out)[i] = type2;
        IGRAPH_CHECK(igraph_vector_push_back(
                         (igraph_vector_t*)VECTOR(vids_by_intype)[type1], i));
        IGRAPH_CHECK(igraph_vector_push_back(
                         (igraph_vector_t*)VECTOR(vids_by_outtype)[type2], i));
    }

    igraph_vector_destroy(&cumdist);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&intersect, 0);
    for (i = 0; i < out_types; i++) {
        for (j = 0; j < in_types; j++) {
            long int kk, l, c = 0;
            igraph_real_t p, last;
            igraph_vector_t *v1, *v2;
            long int v1_size, v2_size;

            IGRAPH_ALLOW_INTERRUPTION();

            v1 = (igraph_vector_t*)VECTOR(vids_by_outtype)[i];
            v2 = (igraph_vector_t*)VECTOR(vids_by_intype)[j];
            v1_size = igraph_vector_size(v1);
            v2_size = igraph_vector_size(v2);

            maxedges = v1_size * v2_size;
            if (!loops) {
                IGRAPH_CHECK(igraph_vector_intersect_sorted(v1, v2, &intersect));
                c = igraph_vector_size(&intersect);
                maxedges -= c;
            }

            p = MATRIX(*pref_matrix, i, j);
            igraph_vector_clear(&s);
            IGRAPH_CHECK(igraph_vector_reserve(&s, (long int) (maxedges * p * 1.1)));

            last = RNG_GEOM(p);
            while (last < maxedges) {
                IGRAPH_CHECK(igraph_vector_push_back(&s, last));
                last += RNG_GEOM(p);
                last += 1;
            }
            l = igraph_vector_size(&s);

            IGRAPH_CHECK(igraph_vector_reserve(&edges, igraph_vector_size(&edges) + l * 2));

            if (!loops && c > 0) {
                for (kk = 0; kk < l; kk++) {
                    long int to = (long int) floor(VECTOR(s)[kk] / v1_size);
                    long int from = (long int) (VECTOR(s)[kk] - ((igraph_real_t)to) * v1_size);
                    if (VECTOR(*v1)[from] == VECTOR(*v2)[to]) {
                        /* remap loop edges */
                        to = v2_size - 1;
                        igraph_vector_binsearch(&intersect, VECTOR(*v1)[from], &c);
                        from = v1_size - 1;
                        if (VECTOR(*v1)[from] == VECTOR(*v2)[to]) {
                            from--;
                        }
                        while (c > 0) {
                            c--; from--;
                            if (VECTOR(*v1)[from] == VECTOR(*v2)[to]) {
                                from--;
                            }
                        }
                    }
                    igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                    igraph_vector_push_back(&edges, VECTOR(*v2)[to]);
                }
            } else {
                for (kk = 0; kk < l; kk++) {
                    long int to = (long int) floor(VECTOR(s)[kk] / v1_size);
                    long int from = (long int) (VECTOR(s)[kk] - ((igraph_real_t)to) * v1_size);
                    igraph_vector_push_back(&edges, VECTOR(*v1)[from]);
                    igraph_vector_push_back(&edges, VECTOR(*v2)[to]);
                }
            }
        }
    }

    RNG_END();

    igraph_vector_destroy(&s);
    igraph_vector_destroy(&intersect);
    igraph_i_preference_game_free_vids_by_type(&vids_by_intype);
    igraph_i_preference_game_free_vids_by_type(&vids_by_outtype);
    IGRAPH_FINALLY_CLEAN(4);

    if (node_type_out_vec == 0) {
        igraph_vector_destroy(nodetypes_out);
        IGRAPH_FREE(nodetypes_out);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (node_type_in_vec == 0) {
        igraph_vector_destroy(nodetypes_in);
        IGRAPH_FREE(nodetypes_in);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, 1));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/recent_degree.c0000644000175100001710000003417300000000000024504 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_psumtree.h"
#include "igraph_random.h"
#include "igraph_interface.h"

/**
 * \function igraph_recent_degree_game
 * \brief Stochastic graph generator based on the number of incident edges a node has gained recently.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the graph, this is the same as
 *        the number of time steps.
 * \param power The exponent, the probability that a node gains a
 *        new edge is proportional to the number of edges it has
 *        gained recently (in the last \p window time steps) to \p
 *        power.
 * \param time_window Integer constant, the size of the time window to use
 *        to count the number of recent edges.
 * \param m Integer constant, the number of edges to add per time
 *        step if the \p outseq parameter is a null pointer or a
 *        zero-length vector.
 * \param outseq The number of edges to add in each time step. This
 *        argument is ignored if it is a null pointer or a zero length
 *        vector. In this case the constant \p m parameter is used.
 * \param outpref Logical constant, if true the edges originated by a
 *        vertex also count as recent incident edges.
 *        For most applications it is reasonable to set it to false.
 * \param zero_appeal Constant giving the attractiveness of the
 *        vertices which haven't gained any edge recently.
 * \param directed Logical constant, whether to generate a directed
 *        graph.
 * \return Error code.
 *
 * Time complexity: O(|V|*log(|V|)+|E|), |V| is the number of
 * vertices, |E| is the number of edges in the graph.
 *
 */
int igraph_recent_degree_game(igraph_t *graph, igraph_integer_t nodes,
                              igraph_real_t power,
                              igraph_integer_t time_window,
                              igraph_integer_t m,
                              const igraph_vector_t *outseq,
                              igraph_bool_t outpref,
                              igraph_real_t zero_appeal,
                              igraph_bool_t directed) {

    long int no_of_nodes = nodes;
    long int no_of_neighbors = 0;
    long int no_of_edges;
    igraph_vector_t edges;
    long int i, j;
    igraph_psumtree_t sumtree;
    long int edgeptr = 0;
    igraph_vector_t degree;
    igraph_dqueue_t history;
    igraph_bool_t have_outseq = outseq && igraph_vector_size(outseq) > 0;

    if (no_of_nodes < 0) {
        IGRAPH_ERRORF("Number of vertices cannot be negative, got %ld.", IGRAPH_EINVAL, no_of_nodes);
    }
    if (have_outseq && igraph_vector_size(outseq) != no_of_nodes) {
        IGRAPH_ERRORF("Out-degree sequence is specified, but its length (%ld) does not equal the number of nodes (%ld).",
                      IGRAPH_EINVAL, (long) igraph_vector_size(outseq), no_of_nodes);
    }
    if (!have_outseq && m < 0) {
        IGRAPH_ERRORF("Numer of edges per step cannot be negative, got %" IGRAPH_PRId ".",
                       IGRAPH_EINVAL, m);
    }
    if (time_window < 0) {
        IGRAPH_ERRORF("Time window cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, time_window);
    }
    if (zero_appeal < 0) {
        IGRAPH_ERRORF("The zero appeal cannot be negative, got %g.", IGRAPH_EINVAL, zero_appeal);
    }

    if (nodes == 0) {
        igraph_empty(graph, 0, directed);
        return IGRAPH_SUCCESS;
    }

    if (!have_outseq) {
        no_of_neighbors = m;
        no_of_edges = (no_of_nodes - 1) * no_of_neighbors;
    } else {
        long int outseq_len = igraph_vector_size(outseq);
        no_of_edges = 0;
        for (i = 1; i < outseq_len; i++) {
            no_of_edges += VECTOR(*outseq)[i];
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);
    IGRAPH_CHECK(igraph_dqueue_init(&history,
                                    1.5 * time_window * no_of_edges / no_of_nodes + 10));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &history);

    RNG_BEGIN();

    /* first node */
    IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, zero_appeal));
    igraph_dqueue_push(&history, -1);

    /* and the rest */
    for (i = 1; i < no_of_nodes; i++) {
        igraph_real_t sum;
        long int to;
        if (have_outseq) {
            no_of_neighbors = (long int) VECTOR(*outseq)[i];
        }

        if (i >= time_window) {
            while ((j = (long int) igraph_dqueue_pop(&history)) != -1) {
                VECTOR(degree)[j] -= 1;
                IGRAPH_CHECK(igraph_psumtree_update(&sumtree, j, pow(VECTOR(degree)[j], power) + zero_appeal));
            }
        }

        sum = igraph_psumtree_sum(&sumtree);
        for (j = 0; j < no_of_neighbors; j++) {
            igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
            VECTOR(degree)[to]++;
            VECTOR(edges)[edgeptr++] = i;
            VECTOR(edges)[edgeptr++] = to;
            igraph_dqueue_push(&history, to);
        }
        igraph_dqueue_push(&history, -1);

        /* update probabilities */
        for (j = 0; j < no_of_neighbors; j++) {
            long int nn = (long int) VECTOR(edges)[edgeptr - 2 * j - 1];
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, nn, pow(VECTOR(degree)[nn], power) + zero_appeal));
        }
        if (outpref) {
            VECTOR(degree)[i] += no_of_neighbors;
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, pow(VECTOR(degree)[i], power) + zero_appeal));
        } else {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, zero_appeal));
        }
    }

    RNG_END();

    igraph_dqueue_destroy(&history);
    igraph_psumtree_destroy(&sumtree);
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_recent_degree_aging_game
 * \brief Preferential attachment based on the number of edges gained recently, with aging of vertices.
 *
 * 
 * This game is very similar to \ref igraph_barabasi_aging_game(),
 * except that instead of the total number of incident edges the
 * number of edges gained in the last \p time_window time steps are
 * counted.
 *
 * The degree dependent part of the attractiveness is
 * given by k to the power of \p pa_exp plus \p zero_appeal; the age
 * dependent part is l to the power to \p aging_exp.
 * k is the number of edges gained in the last \p time_window time
 * steps, l is the age of the vertex.
 * \param graph Pointer to an uninitialized graph object.
 * \param nodes The number of vertices in the graph.
 * \param m The number of edges to add in each time step. If the \p
 *        outseq argument is not a null vector or a zero-length vector
 *        then it is ignored.
 * \param outseq Vector giving the number of edges to add in each time
 *        step. If it is a null pointer or a zero-length vector then
 *        it is ignored and the \p m argument is used.
 * \param outpref Logical constant, if true the edges initiated by a
 *        vertex are also counted. Normally it is false.
 * \param pa_exp The exponent for the preferential attachment.
 * \param aging_exp The exponent for the aging, normally it is
 *        negative: old vertices gain edges with less probability.
 * \param aging_bins Integer constant, the number of age bins to use.
 * \param time_window The time window to use to count the number of
 *        incident edges for the vertices.
 * \param zero_appeal The degree dependent part of the attractiveness
 *        for zero degree vertices.
 * \param directed Logical constant, whether to create a directed
 *        graph.
 * \return Error code.
 *
 * Time complexity: O((|V|+|V|/aging_bins)*log(|V|)+|E|). |V| is the number
 * of vertices, |E| the number of edges.
 */
int igraph_recent_degree_aging_game(igraph_t *graph,
                                    igraph_integer_t nodes,
                                    igraph_integer_t m,
                                    const igraph_vector_t *outseq,
                                    igraph_bool_t outpref,
                                    igraph_real_t pa_exp,
                                    igraph_real_t aging_exp,
                                    igraph_integer_t aging_bins,
                                    igraph_integer_t time_window,
                                    igraph_real_t zero_appeal,
                                    igraph_bool_t directed) {

    long int no_of_nodes = nodes;
    long int no_of_neighbors;
    long int binwidth;
    long int no_of_edges;
    igraph_vector_t edges;
    long int i, j, k;
    igraph_psumtree_t sumtree;
    long int edgeptr = 0;
    igraph_vector_t degree;
    igraph_dqueue_t history;
    igraph_bool_t have_outseq = outseq && igraph_vector_size(outseq) > 0;

    if (no_of_nodes == 0) {
        igraph_empty(graph, 0, directed);
        return IGRAPH_SUCCESS;
    }
    if (no_of_nodes < 0) {
        IGRAPH_ERRORF("Number of nodes should not be negative, got %ld.", IGRAPH_EINVAL, no_of_nodes);
    }
    if (have_outseq && igraph_vector_size(outseq) != no_of_nodes) {
        IGRAPH_ERRORF("Out-degree sequence is specified, but its length (%ld) does not equal the number of nodes (%ld).",
                      IGRAPH_EINVAL, (long) igraph_vector_size(outseq), no_of_nodes);
    }
    if (!have_outseq && m < 0) {
        IGRAPH_ERRORF("Numer of edges per step cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, m);
    }
    if (aging_bins <= 0) {
        IGRAPH_ERRORF("Aging bins should be positive, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, aging_bins);
    }
    if (time_window < 0) {
        IGRAPH_ERRORF("Time window cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, time_window);
    }
    if (zero_appeal < 0) {
        IGRAPH_ERRORF("The zero appeal cannot be negative, got %g.", IGRAPH_EINVAL, zero_appeal);
    }

    if (!have_outseq) {
        no_of_neighbors = m;
        no_of_edges = (no_of_nodes - 1) * no_of_neighbors;
    } else {
        long int outseq_len = igraph_vector_size(outseq);
        no_of_edges = 0;
        for (i = 1; i < outseq_len; i++) {
            no_of_edges += VECTOR(*outseq)[i];
        }
    }

    binwidth = nodes / aging_bins + 1;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
    IGRAPH_CHECK(igraph_psumtree_init(&sumtree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &sumtree);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);
    IGRAPH_CHECK(igraph_dqueue_init(&history,
                                    1.5 * time_window * no_of_edges / no_of_nodes + 10));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &history);

    RNG_BEGIN();

    /* first node */
    IGRAPH_CHECK(igraph_psumtree_update(&sumtree, 0, zero_appeal));
    igraph_dqueue_push(&history, -1);

    /* and the rest */
    for (i = 1; i < no_of_nodes; i++) {
        igraph_real_t sum;
        long int to;

        if (have_outseq) {
            no_of_neighbors = (long int) VECTOR(*outseq)[i];
        }

        if (i >= time_window) {
            while ((j = (long int) igraph_dqueue_pop(&history)) != -1) {
                long int age = (i - j) / binwidth;
                VECTOR(degree)[j] -= 1;
                IGRAPH_CHECK(igraph_psumtree_update(
                    &sumtree, j,
                    (pow(VECTOR(degree)[j], pa_exp) + zero_appeal) * pow(age + 1, aging_exp)
                ));
            }
        }

        sum = igraph_psumtree_sum(&sumtree);
        for (j = 0; j < no_of_neighbors; j++) {
            igraph_psumtree_search(&sumtree, &to, RNG_UNIF(0, sum));
            VECTOR(degree)[to]++;
            VECTOR(edges)[edgeptr++] = i;
            VECTOR(edges)[edgeptr++] = to;
            igraph_dqueue_push(&history, to);
        }
        igraph_dqueue_push(&history, -1);

        /* update probabilities */
        for (j = 0; j < no_of_neighbors; j++) {
            long int n = (long int) VECTOR(edges)[edgeptr - 2 * j - 1];
            long int age = (i - n) / binwidth;
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, n,
                (pow(VECTOR(degree)[n], pa_exp) + zero_appeal) * pow(age + 1, aging_exp)
            ));
        }
        if (outpref) {
            VECTOR(degree)[i] += no_of_neighbors;
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, i,
                pow(VECTOR(degree)[i], pa_exp) + zero_appeal
            ));
        } else {
            IGRAPH_CHECK(igraph_psumtree_update(&sumtree, i, zero_appeal));
        }

        /* aging */
        for (k = 1; binwidth * k <= i; k++) {
            long int shnode = i - binwidth * k;
            long int deg = (long int) VECTOR(degree)[shnode];
            long int age = (i - shnode) / binwidth;
            IGRAPH_CHECK(igraph_psumtree_update(
                &sumtree, shnode,
                (pow(deg, pa_exp) + zero_appeal) * pow(age + 2, aging_exp)
            ));
        }
    }

    RNG_END();

    igraph_dqueue_destroy(&history);
    igraph_vector_destroy(°ree);
    igraph_psumtree_destroy(&sumtree);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/sbm.c0000644000175100001710000005611500000000000022472 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph R library.
   Copyright (C) 2003-2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_interface.h"
#include "igraph_vector.h"
#include "igraph_matrix.h"
#include "igraph_random.h"
#include "igraph_constructors.h"
#include "igraph_games.h"

#include "core/interruption.h"

#include       /* for DBL_EPSILON */
#include        /* for sqrt */

/**
 * \function igraph_sbm_game
 * \brief Sample from a stochastic block model.
 *
 * This function samples graphs from a stochastic block
 * model by (doing the equivalent of) Bernoulli
 * trials for each potential edge with the probabilities
 * given by the Bernoulli rate matrix, \p pref_matrix.
 * See Faust, K., & Wasserman, S. (1992a). Blockmodels:
 * Interpretation and evaluation. Social Networks, 14, 5-–61.
 *
 * 
 * The order of the vertex ids in the generated graph corresponds to
 * the \p block_sizes argument.
 *
 * \param graph The output graph. This should be a pointer to an
 *     uninitialized graph.
 * \param n Number of vertices.
 * \param pref_matrix The matrix giving the Bernoulli rates.
 *     This is a KxK matrix, where K is the number of groups.
 *     The probability of creating an edge between vertices from
 *     groups i and j is given by element (i,j).
 * \param block_sizes An integer vector giving the number of
 *     vertices in each group.
 * \param directed Boolean, whether to create a directed graph. If
 *     this argument is false, then \p pref_matrix must be symmetric.
 * \param loops Boolean, whether to create self-loops.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|+K^2), where |V| is the number of
 * vertices, |E| is the number of edges, and K is the number of
 * groups.
 *
 * \sa \ref igraph_erdos_renyi_game() for a simple Bernoulli graph.
 *
 */

int igraph_sbm_game(igraph_t *graph, igraph_integer_t n,
                    const igraph_matrix_t *pref_matrix,
                    const igraph_vector_int_t *block_sizes,
                    igraph_bool_t directed, igraph_bool_t loops) {

    long int no_blocks = igraph_matrix_nrow(pref_matrix);
    long int from, to, fromoff = 0;
    igraph_real_t minp, maxp;
    igraph_vector_t edges;

    /* ------------------------------------------------------------ */
    /* Check arguments                                              */
    /* ------------------------------------------------------------ */

    if (igraph_matrix_ncol(pref_matrix) != no_blocks) {
        IGRAPH_ERROR("Preference matrix is not square.",
                     IGRAPH_NONSQUARE);
    }

    if (no_blocks > 0) {
        igraph_matrix_minmax(pref_matrix, &minp, &maxp);
        if (minp < 0 || maxp > 1) {
            IGRAPH_ERROR("Connection probabilities must be in [0,1].", IGRAPH_EINVAL);
        }
    }

    if (!directed && !igraph_matrix_is_symmetric(pref_matrix)) {
        IGRAPH_ERROR("Preference matrix must be symmetric for undirected graphs.",
                     IGRAPH_EINVAL);
    }

    if (igraph_vector_int_size(block_sizes) != no_blocks) {
        IGRAPH_ERRORF("Block size vector length (%ld) does not agree with "
                      "preference matrix size (%ld).", IGRAPH_EINVAL,
                      igraph_vector_int_size(block_sizes), no_blocks);
    }

    if (no_blocks > 0) {
        if (igraph_vector_int_min(block_sizes) < 0) {
            IGRAPH_ERRORF("Block sizes must be non-negative, but got %" IGRAPH_PRId ".",
                          IGRAPH_EINVAL, igraph_vector_int_min(block_sizes));
        }
    }

    if (igraph_vector_int_sum(block_sizes) != n) {
        IGRAPH_ERRORF("Sum of the block sizes (%" IGRAPH_PRId ") must equal the number of vertices (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_int_sum(block_sizes), n);
    }

    /* Since the sum of the block sizes should equal the number of vertices,
     * and the block sizes are non-negative, the number of vertices is
     * guaranteed to be non-negative. This shouldn't be checked separately.
     */

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    RNG_BEGIN();

    for (from = 0; from < no_blocks; from++) {
        double fromsize = VECTOR(*block_sizes)[from];
        long int start = directed ? 0 : from;
        long int i, tooff = 0;

        IGRAPH_ALLOW_INTERRUPTION();

        for (i = 0; i < start; i++) {
            tooff += VECTOR(*block_sizes)[i];
        }
        for (to = start; to < no_blocks; to++) {
            double tosize = VECTOR(*block_sizes)[to];
            igraph_real_t prob = MATRIX(*pref_matrix, from, to);
            double maxedges, last = RNG_GEOM(prob);
            if (directed && loops) {
                maxedges = fromsize * tosize;
                while (last < maxedges) {
                    long int vto = floor(last / fromsize);
                    long int vfrom = last - (igraph_real_t)vto * fromsize;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else if (directed && !loops && from != to) {
                maxedges = fromsize * tosize;
                while (last < maxedges) {
                    long int vto = floor(last / fromsize);
                    long int vfrom = last - (igraph_real_t)vto * fromsize;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else if (directed && !loops && from == to) {
                maxedges = fromsize * (fromsize - 1);
                while (last < maxedges) {
                    long int vto = floor(last / fromsize);
                    long int vfrom = last - (igraph_real_t)vto * fromsize;
                    if (vfrom == vto) {
                        vto = fromsize - 1;
                    }
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else if (!directed && loops && from != to) {
                maxedges = fromsize * tosize;
                while (last < maxedges) {
                    long int vto = floor(last / fromsize);
                    long int vfrom = last - (igraph_real_t)vto * fromsize;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else if (!directed && loops && from == to) {
                maxedges = fromsize * (fromsize + 1) / 2.0;
                while (last < maxedges) {
                    long int vto = floor((sqrt(8 * last + 1) - 1) / 2);
                    long int vfrom = last - (((igraph_real_t)vto) * (vto + 1)) / 2;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else if (!directed && !loops && from != to) {
                maxedges = fromsize * tosize;
                while (last < maxedges) {
                    long int vto = floor(last / fromsize);
                    long int vfrom = last - (igraph_real_t)vto * fromsize;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            } else { /*!directed && !loops && from==to */
                maxedges = fromsize * (fromsize - 1) / 2.0;
                while (last < maxedges) {
                    long int vto = floor((sqrt(8 * last + 1) + 1) / 2);
                    long int vfrom = last - (((igraph_real_t)vto) * (vto - 1)) / 2;
                    igraph_vector_push_back(&edges, fromoff + vfrom);
                    igraph_vector_push_back(&edges, tooff + vto);
                    last += RNG_GEOM(prob);
                    last += 1;
                }
            }

            tooff += tosize;
        }
        fromoff += fromsize;
    }

    RNG_END();

    igraph_create(graph, &edges, n, directed);
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_hsbm_game
 * \brief Hierarchical stochastic block model.
 *
 * The function generates a random graph according to the hierarchical
 * stochastic block model.
 *
 * \param graph The generated graph is stored here.
 * \param n The number of vertices in the graph.
 * \param m The number of vertices per block. n/m must be integer.
 * \param rho The fraction of vertices per cluster,
 *        within a block. Must sum up to 1, and rho * m must be integer
 *        for all elements of rho.
 * \param C A square, symmetric numeric matrix, the Bernoulli rates for
 *        the clusters within a block. Its size must mach the size of the
 *        \code{rho} vector.
 * \param p The Bernoulli rate of connections between
 *        vertices in different blocks.
 * \return Error code.
 *
 * \sa \ref igraph_sbm_game() for the classic stochastic block model,
 * \ref igraph_hsbm_list_game() for a more general version.
 */

int igraph_hsbm_game(igraph_t *graph, igraph_integer_t n,
                     igraph_integer_t m, const igraph_vector_t *rho,
                     const igraph_matrix_t *C, igraph_real_t p) {

    int b, i, k = igraph_vector_size(rho);
    igraph_vector_t csizes;
    igraph_real_t sq_dbl_epsilon = sqrt(DBL_EPSILON);
    int no_blocks = n / m;
    igraph_vector_t edges;
    int offset = 0;

    if (n < 1) {
        IGRAPH_ERROR("`n' must be positive for HSBM", IGRAPH_EINVAL);
    }
    if (m < 1) {
        IGRAPH_ERROR("`m' must be positive for HSBM", IGRAPH_EINVAL);
    }
    if ((long) n  % (long) m) {
        IGRAPH_ERROR("`n' must be a multiple of `m' for HSBM", IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(rho, 0, 1)) {
        IGRAPH_ERROR("`rho' must be between zero and one for HSBM",
                     IGRAPH_EINVAL);
    }
    if (igraph_matrix_min(C) < 0 || igraph_matrix_max(C) > 1) {
        IGRAPH_ERROR("`C' must be between zero and one for HSBM", IGRAPH_EINVAL);
    }
    if (fabs(igraph_vector_sum(rho) - 1.0) > sq_dbl_epsilon) {
        IGRAPH_ERROR("`rho' must sum up to 1 for HSBM", IGRAPH_EINVAL);
    }
    if (igraph_matrix_nrow(C) != k || igraph_matrix_ncol(C) != k) {
        IGRAPH_ERROR("`C' dimensions must match `rho' dimensions in HSBM",
                     IGRAPH_EINVAL);
    }
    if (!igraph_matrix_is_symmetric(C)) {
        IGRAPH_ERROR("`C' must be a symmetric matrix", IGRAPH_EINVAL);
    }
    if (p < 0 || p > 1) {
        IGRAPH_ERROR("`p' must be a probability for HSBM", IGRAPH_EINVAL);
    }
    for (i = 0; i < k; i++) {
        igraph_real_t s = VECTOR(*rho)[i] * m;
        if (fabs(round(s) - s) > sq_dbl_epsilon) {
            IGRAPH_ERROR("`rho' * `m' is not integer in HSBM", IGRAPH_EINVAL);
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&csizes, k);
    for (i = 0; i < k; i++) {
        VECTOR(csizes)[i] = round(VECTOR(*rho)[i] * m);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    RNG_BEGIN();

    /* Block models first */

    for (b = 0; b < no_blocks; b++) {
        int from, to, fromoff = 0;

        for (from = 0; from < k; from++) {
            int fromsize = VECTOR(csizes)[from];
            int i, tooff = 0;
            for (i = 0; i < from; i++) {
                tooff += VECTOR(csizes)[i];
            }
            for (to = from; to < k; to++) {
                int tosize = VECTOR(csizes)[to];
                igraph_real_t prob = MATRIX(*C, from, to);
                igraph_real_t maxedges;
                igraph_real_t last = RNG_GEOM(prob);
                if (from != to) {
                    maxedges = fromsize * tosize;
                    while (last < maxedges) {
                        int vto = floor(last / fromsize);
                        int vfrom = last - (igraph_real_t)vto * fromsize;
                        igraph_vector_push_back(&edges, offset + fromoff + vfrom);
                        igraph_vector_push_back(&edges, offset + tooff + vto);
                        last += RNG_GEOM(prob);
                        last += 1;
                    }
                } else { /* from==to */
                    maxedges = fromsize * (fromsize - 1) / 2.0;
                    while (last < maxedges) {
                        int vto = floor((sqrt(8 * last + 1) + 1) / 2);
                        int vfrom = last - (((igraph_real_t)vto) * (vto - 1)) / 2;
                        igraph_vector_push_back(&edges, offset + fromoff + vfrom);
                        igraph_vector_push_back(&edges, offset + tooff + vto);
                        last += RNG_GEOM(prob);
                        last += 1;
                    }
                }

                tooff += tosize;
            }
            fromoff += fromsize;
        }

        offset += m;
    }

    /* And now the rest, if not a special case */

    if (p == 1) {
        int fromoff = 0, tooff = m;
        for (b = 0; b < no_blocks; b++) {
            igraph_real_t fromsize = m;
            igraph_real_t tosize = n - tooff;
            int from, to;
            for (from = 0; from < fromsize; from++) {
                for (to = 0; to < tosize; to++) {
                    igraph_vector_push_back(&edges, fromoff + from);
                    igraph_vector_push_back(&edges, tooff + to);
                }
            }
            fromoff += m;
            tooff += m;
        }
    } else if (p > 0) {
        int fromoff = 0, tooff = m;
        for (b = 0; b < no_blocks; b++) {
            igraph_real_t fromsize = m;
            igraph_real_t tosize = n - tooff;
            igraph_real_t maxedges = fromsize * tosize;
            igraph_real_t last = RNG_GEOM(p);
            while (last < maxedges) {
                int vto = floor(last / fromsize);
                int vfrom = last - (igraph_real_t) vto * fromsize;
                igraph_vector_push_back(&edges, fromoff + vfrom);
                igraph_vector_push_back(&edges, tooff + vto);
                last += RNG_GEOM(p);
                last += 1;
            }

            fromoff += m;
            tooff += m;
        }
    }

    RNG_END();

    igraph_create(graph, &edges, n, /*directed=*/ 0);

    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&csizes);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_hsbm_list_game
 * \brief Hierarchical stochastic block model, more general version.
 *
 * The function generates a random graph according to the hierarchical
 * stochastic block model.
 *
 * \param graph The generated graph is stored here.
 * \param n The number of vertices in the graph.
 * \param mlist An integer vector of block sizes.
 * \param rholist A list of rho vectors (\c igraph_vector_t objects), one
 *        for each block.
 * \param Clist A list of square matrices (\c igraph_matrix_t objects),
 *        one for each block, giving the Bernoulli rates of connections
 *        within the block.
 * \param p The Bernoulli rate of connections between
 *        vertices in different blocks.
 * \return Error code.
 *
 * \sa \ref igraph_sbm_game() for the classic stochastic block model,
 * \ref igraph_hsbm_game() for a simpler general version.
 */

int igraph_hsbm_list_game(igraph_t *graph, igraph_integer_t n,
                          const igraph_vector_int_t *mlist,
                          const igraph_vector_ptr_t *rholist,
                          const igraph_vector_ptr_t *Clist,
                          igraph_real_t p) {

    int i, no_blocks = igraph_vector_ptr_size(rholist);
    igraph_real_t sq_dbl_epsilon = sqrt(DBL_EPSILON);
    igraph_vector_t csizes, edges;
    int b, offset = 0;

    if (n < 1) {
        IGRAPH_ERROR("`n' must be positive for HSBM", IGRAPH_EINVAL);
    }
    if (no_blocks == 0) {
        IGRAPH_ERROR("`rholist' empty for HSBM", IGRAPH_EINVAL);
    }
    if (igraph_vector_ptr_size(Clist) != no_blocks &&
        igraph_vector_int_size(mlist) != no_blocks) {
        IGRAPH_ERROR("`rholist' must have same length as `Clist' and `m' "
                     "for HSBM", IGRAPH_EINVAL);
    }
    if (p < 0 || p > 1) {
        IGRAPH_ERROR("`p' must be a probability for HSBM", IGRAPH_EINVAL);
    }
    /* Checks for m's */
    if (igraph_vector_int_sum(mlist) != n) {
        IGRAPH_ERROR("`m' must sum up to `n' for HSBM", IGRAPH_EINVAL);
    }
    if (igraph_vector_int_min(mlist) < 1) {
        IGRAPH_ERROR("`m' must be positive for HSBM", IGRAPH_EINVAL);
    }
    /* Checks for the rhos */
    for (i = 0; i < no_blocks; i++) {
        const igraph_vector_t *rho = VECTOR(*rholist)[i];
        if (!igraph_vector_isininterval(rho, 0, 1)) {
            IGRAPH_ERROR("`rho' must be between zero and one for HSBM",
                         IGRAPH_EINVAL);
        }
        if (fabs(igraph_vector_sum(rho) - 1.0) > sq_dbl_epsilon) {
            IGRAPH_ERROR("`rho' must sum up to 1 for HSBM", IGRAPH_EINVAL);
        }
    }
    /* Checks for the Cs */
    for (i = 0; i < no_blocks; i++) {
        const igraph_matrix_t *C = VECTOR(*Clist)[i];
        if (igraph_matrix_min(C) < 0 || igraph_matrix_max(C) > 1) {
            IGRAPH_ERROR("`C' must be between zero and one for HSBM",
                         IGRAPH_EINVAL);
        }
        if (!igraph_matrix_is_symmetric(C)) {
            IGRAPH_ERROR("`C' must be a symmetric matrix", IGRAPH_EINVAL);
        }
    }
    /* Check that C and rho sizes match */
    for (i = 0; i < no_blocks; i++) {
        const igraph_vector_t *rho = VECTOR(*rholist)[i];
        const igraph_matrix_t *C = VECTOR(*Clist)[i];
        int k = igraph_vector_size(rho);
        if (igraph_matrix_nrow(C) != k || igraph_matrix_ncol(C) != k) {
            IGRAPH_ERROR("`C' dimensions must match `rho' dimensions in HSBM",
                         IGRAPH_EINVAL);
        }
    }
    /* Check that rho * m is integer */
    for (i = 0; i < no_blocks; i++) {
        const igraph_vector_t *rho = VECTOR(*rholist)[i];
        igraph_real_t m = VECTOR(*mlist)[i];
        int j, k = igraph_vector_size(rho);
        for (j = 0; j < k; j++) {
            igraph_real_t s = VECTOR(*rho)[j] * m;
            if (fabs(round(s) - s) > sq_dbl_epsilon) {
                IGRAPH_ERROR("`rho' * `m' is not integer in HSBM", IGRAPH_EINVAL);
            }
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&csizes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    RNG_BEGIN();

    /* Block models first */

    for (b = 0; b < no_blocks; b++) {
        int from, to, fromoff = 0;
        const igraph_vector_t *rho = VECTOR(*rholist)[b];
        const igraph_matrix_t *C = VECTOR(*Clist)[b];
        igraph_real_t m = VECTOR(*mlist)[b];
        int k = igraph_vector_size(rho);

        igraph_vector_resize(&csizes, k);
        for (i = 0; i < k; i++) {
            VECTOR(csizes)[i] = round(VECTOR(*rho)[i] * m);
        }

        for (from = 0; from < k; from++) {
            int fromsize = VECTOR(csizes)[from];
            int i, tooff = 0;
            for (i = 0; i < from; i++) {
                tooff += VECTOR(csizes)[i];
            }
            for (to = from; to < k; to++) {
                int tosize = VECTOR(csizes)[to];
                igraph_real_t prob = MATRIX(*C, from, to);
                igraph_real_t maxedges;
                igraph_real_t last = RNG_GEOM(prob);
                if (from != to) {
                    maxedges = fromsize * tosize;
                    while (last < maxedges) {
                        int vto = floor(last / fromsize);
                        int vfrom = last - (igraph_real_t)vto * fromsize;
                        igraph_vector_push_back(&edges, offset + fromoff + vfrom);
                        igraph_vector_push_back(&edges, offset + tooff + vto);
                        last += RNG_GEOM(prob);
                        last += 1;
                    }
                } else { /* from==to */
                    maxedges = fromsize * (fromsize - 1) / 2.0;
                    while (last < maxedges) {
                        int vto = floor((sqrt(8 * last + 1) + 1) / 2);
                        int vfrom = last - (((igraph_real_t)vto) * (vto - 1)) / 2;
                        igraph_vector_push_back(&edges, offset + fromoff + vfrom);
                        igraph_vector_push_back(&edges, offset + tooff + vto);
                        last += RNG_GEOM(prob);
                        last += 1;
                    }
                }

                tooff += tosize;
            }
            fromoff += fromsize;
        }

        offset += m;
    }

    /* And now the rest, if not a special case */

    if (p == 1) {
        int fromoff = 0, tooff = VECTOR(*mlist)[0];
        for (b = 0; b < no_blocks; b++) {
            igraph_real_t fromsize = VECTOR(*mlist)[b];
            igraph_real_t tosize = n - tooff;
            int from, to;
            for (from = 0; from < fromsize; from++) {
                for (to = 0; to < tosize; to++) {
                    igraph_vector_push_back(&edges, fromoff + from);
                    igraph_vector_push_back(&edges, tooff + to);
                }
            }
            fromoff += fromsize;
            if (b + 1 < no_blocks) {
                tooff += VECTOR(*mlist)[b + 1];
            }
        }
    } else if (p > 0) {
        int fromoff = 0, tooff = VECTOR(*mlist)[0];
        for (b = 0; b < no_blocks; b++) {
            igraph_real_t fromsize = VECTOR(*mlist)[b];
            igraph_real_t tosize = n - tooff;
            igraph_real_t maxedges = fromsize * tosize;
            igraph_real_t last = RNG_GEOM(p);
            while (last < maxedges) {
                int vto = floor(last / fromsize);
                int vfrom = last - (igraph_real_t) vto * fromsize;
                igraph_vector_push_back(&edges, fromoff + vfrom);
                igraph_vector_push_back(&edges, tooff + vto);
                last += RNG_GEOM(p);
                last += 1;
            }

            fromoff += fromsize;
            if (b + 1 < no_blocks) {
                tooff += VECTOR(*mlist)[b + 1];
            }
        }
    }

    RNG_END();

    igraph_create(graph, &edges, n, /*directed=*/ 0);

    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&csizes);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/static_fitness.c0000644000175100001710000004162000000000000024726 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_adjlist.h"
#include "igraph_conversion.h"
#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_random.h"

#include "core/interruption.h"

/**
 * \ingroup generators
 * \function igraph_static_fitness_game
 * \brief Non-growing random graph with edge probabilities proportional to node fitness scores.
 *
 * This game generates a directed or undirected random graph where the
 * probability of an edge between vertices i and j depends on the fitness
 * scores of the two vertices involved. For undirected graphs, each vertex
 * has a single fitness score. For directed graphs, each vertex has an out-
 * and an in-fitness, and the probability of an edge from i to j depends on
 * the out-fitness of vertex i and the in-fitness of vertex j.
 *
 * 
 * The generation process goes as follows. We start from N disconnected nodes
 * (where N is given by the length of the fitness vector). Then we randomly
 * select two vertices i and j, with probabilities proportional to their
 * fitnesses. (When the generated graph is directed, i is selected according to
 * the out-fitnesses and j is selected according to the in-fitnesses). If the
 * vertices are not connected yet (or if multiple edges are allowed), we
 * connect them; otherwise we select a new pair. This is repeated until the
 * desired number of links are created.
 *
 * 
 * It can be shown that the \em expected degree of each vertex will be
 * proportional to its fitness, although the actual, observed degree will not
 * be. If you need to generate a graph with an exact degree sequence, consider
 * \ref igraph_degree_sequence_game instead.
 *
 * 
 * This model is commonly used to generate static scale-free networks. To
 * achieve this, you have to draw the fitness scores from the desired power-law
 * distribution. Alternatively, you may use \ref igraph_static_power_law_game
 * which generates the fitnesses for you with a given exponent.
 *
 * 
 * Reference: Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution
 * in scale-free networks. Phys Rev Lett 87(27):278701, 2001.
 *
 * \param graph        Pointer to an uninitialized graph object.
 * \param fitness_out  A numeric vector containing the fitness of each vertex.
 *                     For directed graphs, this specifies the out-fitness
 *                     of each vertex.
 * \param fitness_in   If \c NULL, the generated graph will be undirected.
 *                     If not \c NULL, this argument specifies the in-fitness
 *                     of each vertex.
 * \param no_of_edges  The number of edges in the generated graph.
 * \param loops        Whether to allow loop edges in the generated graph.
 * \param multiple     Whether to allow multiple edges in the generated graph.
 *
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid parameter
 *         \c IGRAPH_ENOMEM: there is not enough
 *         memory for the operation.
 *
 * Time complexity: O(|V| + |E| log |E|).
 */
int igraph_static_fitness_game(igraph_t *graph, igraph_integer_t no_of_edges,
                               const igraph_vector_t *fitness_out, const igraph_vector_t *fitness_in,
                               igraph_bool_t loops, igraph_bool_t multiple) {
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    igraph_integer_t no_of_nodes;
    igraph_integer_t outnodes, innodes, nodes;
    igraph_vector_t cum_fitness_in, cum_fitness_out;
    igraph_vector_t *p_cum_fitness_in, *p_cum_fitness_out;
    igraph_real_t x, max_in, max_out;
    igraph_real_t max_no_of_edges;
    igraph_bool_t is_directed = (fitness_in != 0);
    float num_steps;
    igraph_integer_t step_counter = 0;
    long int i, from, to, pos;

    if (fitness_out == 0) {
        IGRAPH_ERROR("fitness_out must not be null.", IGRAPH_EINVAL);
    }

    if (no_of_edges < 0) {
        IGRAPH_ERRORF("Number of edges cannot be negative, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, no_of_edges);
    }

    no_of_nodes = (igraph_integer_t) igraph_vector_size(fitness_out);
    if (no_of_nodes == 0) {
        IGRAPH_CHECK(igraph_empty(graph, 0, is_directed));
        return IGRAPH_SUCCESS;
    }

    if (is_directed && igraph_vector_size(fitness_in) != no_of_nodes) {
        IGRAPH_ERROR("fitness_in must have the same size as fitness_out.", IGRAPH_EINVAL);
    }

    /* Sanity checks for the fitnesses */
    if (igraph_vector_min(fitness_out) < 0) {
        IGRAPH_ERROR("Fitness scores must be non-negative.", IGRAPH_EINVAL);
    }
    if (fitness_in != 0 && igraph_vector_min(fitness_in) < 0) {
        IGRAPH_ERROR("Fitness scores must be non-negative.", IGRAPH_EINVAL);
    }

    /* Avoid getting into an infinite loop when too many edges are requested */
    if (!multiple) {
        if (is_directed) {
            outnodes = innodes = nodes = 0;
            for (i = 0; i < no_of_nodes; i++) {
                if (VECTOR(*fitness_out)[i] != 0) {
                    outnodes++;
                }
                if (VECTOR(*fitness_in)[i] != 0) {
                    innodes++;
                }
                if (VECTOR(*fitness_out)[i] != 0 && VECTOR(*fitness_in)[i] != 0) {
                    nodes++;
                }
            }
            max_no_of_edges = ((igraph_real_t) outnodes) * innodes - (loops ? 0 : nodes);
        } else {
            nodes = 0;
            for (i = 0; i < no_of_nodes; i++) {
                if (VECTOR(*fitness_out)[i] != 0) {
                    nodes++;
                }
            }
            max_no_of_edges = loops
                              ? nodes * ((igraph_real_t)nodes + 1) / 2
                              : nodes * ((igraph_real_t)nodes - 1) / 2;
        }
        if (no_of_edges > max_no_of_edges) {
            IGRAPH_ERROR("Too many edges requested.", IGRAPH_EINVAL);
        }
    }

    /* Calculate the cumulative fitness scores */
    IGRAPH_VECTOR_INIT_FINALLY(&cum_fitness_out, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_cumsum(&cum_fitness_out, fitness_out));
    max_out = igraph_vector_tail(&cum_fitness_out);
    p_cum_fitness_out = &cum_fitness_out;
    if (is_directed) {
        IGRAPH_VECTOR_INIT_FINALLY(&cum_fitness_in, no_of_nodes);
        IGRAPH_CHECK(igraph_vector_cumsum(&cum_fitness_in, fitness_in));
        max_in = igraph_vector_tail(&cum_fitness_in);
        p_cum_fitness_in = &cum_fitness_in;
    } else {
        max_in = max_out;
        p_cum_fitness_in = &cum_fitness_out;
    }

    RNG_BEGIN();
    num_steps = no_of_edges;
    if (multiple) {
        /* Generating when multiple edges are allowed */

        IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&edges, 2 * no_of_edges));

        while (no_of_edges > 0) {
            /* Report progress after every 10000 edges */
            if ((step_counter++) % 10000 == 0) {
                IGRAPH_PROGRESS("Static fitness game", 100.0 * (1 - no_of_edges / num_steps), NULL);
                IGRAPH_ALLOW_INTERRUPTION();
            }

            x = RNG_UNIF(0, max_out);
            igraph_vector_binsearch(p_cum_fitness_out, x, &from);
            x = RNG_UNIF(0, max_in);
            igraph_vector_binsearch(p_cum_fitness_in, x, &to);

            /* Skip if loop edge and loops = false */
            if (!loops && from == to) {
                continue;
            }

            igraph_vector_push_back(&edges, from);
            igraph_vector_push_back(&edges, to);

            no_of_edges--;
        }

        /* Create the graph */
        IGRAPH_CHECK(igraph_create(graph, &edges, no_of_nodes, is_directed));

        /* Clear the edge list */
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Multiple edges are disallowed */
        igraph_adjlist_t al;
        igraph_vector_int_t* neis;

        IGRAPH_CHECK(igraph_adjlist_init_empty(&al, no_of_nodes));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &al);
        while (no_of_edges > 0) {
            /* Report progress after every 10000 edges */
            if ((step_counter++) % 10000 == 0) {
                IGRAPH_PROGRESS("Static fitness game", 100.0 * (1 - no_of_edges / num_steps), NULL);
                IGRAPH_ALLOW_INTERRUPTION();
            }

            x = RNG_UNIF(0, max_out);
            igraph_vector_binsearch(p_cum_fitness_out, x, &from);
            x = RNG_UNIF(0, max_in);
            igraph_vector_binsearch(p_cum_fitness_in, x, &to);

            /* Skip if loop edge and loops = false */
            if (!loops && from == to) {
                continue;
            }

            /* For undirected graphs, ensure that from < to */
            if (!is_directed && from > to) {
                pos = from; from = to; to = pos;
            }

            /* Is there already an edge? If so, try again */
            neis = igraph_adjlist_get(&al, from);
            if (igraph_vector_int_binsearch(neis, to, &pos)) {
                continue;
            }

            /* Insert the edge */
            IGRAPH_CHECK(igraph_vector_int_insert(neis, pos, to));

            no_of_edges--;
        }

        /* Create the graph. We cannot use IGRAPH_ALL here for undirected graphs
         * because we did not add edges in both directions in the adjacency list.
         * We will use igraph_to_undirected in an extra step. */
        IGRAPH_CHECK(igraph_adjlist(graph, &al, IGRAPH_OUT, 1));
        if (!is_directed) {
            IGRAPH_CHECK(igraph_to_undirected(graph, IGRAPH_TO_UNDIRECTED_EACH, 0));
        }

        /* Clear the adjacency list */
        igraph_adjlist_destroy(&al);
        IGRAPH_FINALLY_CLEAN(1);
    }
    RNG_END();

    IGRAPH_PROGRESS("Static fitness game", 100.0, NULL);

    /* Cleanup before we create the graph */
    if (is_directed) {
        igraph_vector_destroy(&cum_fitness_in);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_destroy(&cum_fitness_out);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup generators
 * \function igraph_static_power_law_game
 * \brief Generates a non-growing random graph with expected power-law degree distributions.
 *
 * This game generates a directed or undirected random graph where the
 * degrees of vertices follow power-law distributions with prescribed
 * exponents. For directed graphs, the exponents of the in- and out-degree
 * distributions may be specified separately.
 *
 * 
 * The game simply uses \ref igraph_static_fitness_game with appropriately
 * constructed fitness vectors. In particular, the fitness of vertex i
 * is i-alpha, where alpha = 1/(gamma-1)
 * and gamma is the exponent given in the arguments.
 *
 * 
 * To remove correlations between in- and out-degrees in case of directed
 * graphs, the in-fitness vector will be shuffled after it has been set up
 * and before \ref igraph_static_fitness_game is called.
 *
 * 
 * Note that significant finite size effects may be observed for exponents
 * smaller than 3 in the original formulation of the game. This function
 * provides an argument that lets you remove the finite size effects by
 * assuming that the fitness of vertex i is
 * (i+i0-1)-alpha,
 * where i0 is a constant chosen appropriately to ensure that the maximum
 * degree is less than the square root of the number of edges times the
 * average degree; see the paper of Chung and Lu, and Cho et al for more
 * details.
 *
 * 
 * References:
 *
 * 
 * Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution
 * in scale-free networks. Phys Rev Lett 87(27):278701, 2001.
 *
 * 
 * Chung F and Lu L: Connected components in a random graph with given
 * degree sequences. Annals of Combinatorics 6, 125-145, 2002.
 *
 * 
 * Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in
 * scale-free networks under the Achlioptas process. Phys Rev Lett
 * 103:135702, 2009.
 *
 * \param graph        Pointer to an uninitialized graph object.
 * \param no_of_nodes  The number of nodes in the generated graph.
 * \param no_of_edges  The number of edges in the generated graph.
 * \param exponent_out The power law exponent of the degree distribution.
 *                     For directed graphs, this specifies the exponent of the
 *                     out-degree distribution. It must be greater than or
 *                     equal to 2. If you pass \c IGRAPH_INFINITY here, you
 *                     will get back an Erdos-Renyi random network.
 * \param exponent_in  If negative, the generated graph will be undirected.
 *                     If greater than or equal to 2, this argument specifies
 *                     the exponent of the in-degree distribution. If
 *                     non-negative but less than 2, an error will be
 *                     generated.
 * \param loops        Whether to allow loop edges in the generated graph.
 * \param multiple     Whether to allow multiple edges in the generated graph.
 * \param finite_size_correction  Whether to use the proposed finite size
 *                     correction of Cho et al.
 *
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid parameter
 *         \c IGRAPH_ENOMEM: there is not enough
 *         memory for the operation.
 *
 * Time complexity: O(|V| + |E| log |E|).
 */
int igraph_static_power_law_game(igraph_t *graph,
                                 igraph_integer_t no_of_nodes, igraph_integer_t no_of_edges,
                                 igraph_real_t exponent_out, igraph_real_t exponent_in,
                                 igraph_bool_t loops, igraph_bool_t multiple,
                                 igraph_bool_t finite_size_correction) {

    igraph_vector_t fitness_out, fitness_in;
    igraph_real_t alpha_out = 0.0, alpha_in = 0.0;
    long int i;
    igraph_real_t j;

    if (no_of_nodes < 0) {
        IGRAPH_ERRORF("Number of nodes cannot be negative, got %" IGRAPH_PRId".", IGRAPH_EINVAL, no_of_nodes);
    }

    /* Calculate alpha_out */
    if (exponent_out < 2) {
        IGRAPH_ERRORF("Out-degree exponent must be >= 2, got %g.", IGRAPH_EINVAL, exponent_out);
    } else if (igraph_finite(exponent_out)) {
        alpha_out = -1.0 / (exponent_out - 1);
    } else {
        alpha_out = 0.0;
    }

    /* Construct the out-fitnesses */
    IGRAPH_VECTOR_INIT_FINALLY(&fitness_out, no_of_nodes);
    j = no_of_nodes;
    if (finite_size_correction && alpha_out < -0.5) {
        /* See the Cho et al paper, first page first column + footnote 7 */
        j += pow(no_of_nodes, 1 + 0.5 / alpha_out) *
             pow(10 * sqrt(2) * (1 + alpha_out), -1.0 / alpha_out) - 1;
    }
    if (j < no_of_nodes) {
        j = no_of_nodes;
    }
    for (i = 0; i < no_of_nodes; i++, j--) {
        VECTOR(fitness_out)[i] = pow(j, alpha_out);
    }

    if (exponent_in >= 0) {
        if (exponent_in < 2) {
            IGRAPH_ERRORF("For directed graphs the in-degree exponent must be >= 2, got %g.",
                          IGRAPH_EINVAL, exponent_in);
        } else if (igraph_finite(exponent_in)) {
            alpha_in = -1.0 / (exponent_in - 1);
        } else {
            alpha_in = 0.0;
        }

        IGRAPH_VECTOR_INIT_FINALLY(&fitness_in, no_of_nodes);
        j = no_of_nodes;
        if (finite_size_correction && alpha_in < -0.5) {
            /* See the Cho et al paper, first page first column + footnote 7 */
            j += pow(no_of_nodes, 1 + 0.5 / alpha_in) *
                 pow(10 * sqrt(2) * (1 + alpha_in), -1.0 / alpha_in) - 1;
        }
        if (j < no_of_nodes) {
            j = no_of_nodes;
        }
        for (i = 0; i < no_of_nodes; i++, j--) {
            VECTOR(fitness_in)[i] = pow(j, alpha_in);
        }
        IGRAPH_CHECK(igraph_vector_shuffle(&fitness_in));

        IGRAPH_CHECK(igraph_static_fitness_game(graph, no_of_edges,
                                                &fitness_out, &fitness_in, loops, multiple));

        igraph_vector_destroy(&fitness_in);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        IGRAPH_CHECK(igraph_static_fitness_game(graph, no_of_edges,
                                                &fitness_out, 0, loops, multiple));
    }

    igraph_vector_destroy(&fitness_out);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/tree.c0000644000175100001710000001423200000000000022642 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_random.h"

/* Uniform sampling of labelled trees (igraph_tree_game) */

/* The following implementation uniformly samples Prufer trees and converts
 * them to trees.
 */

static int igraph_i_tree_game_prufer(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) {
    igraph_vector_int_t prufer;
    long i;

    if (directed) {
        IGRAPH_ERROR("The Prufer method for random tree generation does not support directed trees", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_int_init(&prufer, n - 2));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &prufer);

    RNG_BEGIN();

    for (i = 0; i < n - 2; ++i) {
        VECTOR(prufer)[i] = RNG_INTEGER(0, n - 1);
    }

    RNG_END();

    IGRAPH_CHECK(igraph_from_prufer(graph, &prufer));

    igraph_vector_int_destroy(&prufer);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* The following implementation is based on loop-erased random walks and Wilson's algorithm
 * for uniformly sampling spanning trees. We effectively sample spanning trees of the complete
 * graph.
 */

/* swap two elements of a vector_int */
#define SWAP_INT_ELEM(vec, i, j) \
    { \
        igraph_integer_t temp; \
        temp = VECTOR(vec)[i]; \
        VECTOR(vec)[i] = VECTOR(vec)[j]; \
        VECTOR(vec)[j] = temp; \
    }

static int igraph_i_tree_game_loop_erased_random_walk(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) {
    igraph_vector_t edges;
    igraph_vector_int_t vertices;
    igraph_vector_bool_t visited;
    long i, j, k;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * (n - 1));

    IGRAPH_CHECK(igraph_vector_bool_init(&visited, n));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &visited);

    /* The vertices vector contains visited vertices between 0..k-1, unvisited ones between k..n-1. */
    IGRAPH_CHECK(igraph_vector_int_init_seq(&vertices, 0, n - 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &vertices);

    RNG_BEGIN();

    /* A simple implementation could be as below. This is for illustration only.
     * The actually implemented algorithm avoids unnecessary walking on the already visited
     * portion of the vertex set.
     */
    /*
    // pick starting point for the walk
    i = RNG_INTEGER(0, n-1);
    VECTOR(visited)[i] = 1;

    k=1;
    while (k < n) {
        // pick next vertex in the walk
        j = RNG_INTEGER(0, n-1);
        // if it has not been visited before, connect to the previous vertex in the sequence
        if (! VECTOR(visited)[j]) {
            VECTOR(edges)[2*k - 2] = i;
            VECTOR(edges)[2*k - 1] = j;
            VECTOR(visited)[j] = 1;
            k++;
        }
        i=j;
    }
    */

    i = RNG_INTEGER(0, n - 1);
    VECTOR(visited)[i] = 1;
    SWAP_INT_ELEM(vertices, 0, i);

    for (k = 1; k < n; ++k) {
        j = RNG_INTEGER(0, n - 1);
        if (VECTOR(visited)[VECTOR(vertices)[j]]) {
            i = VECTOR(vertices)[j];
            j = RNG_INTEGER(k, n - 1);
        }
        VECTOR(visited)[VECTOR(vertices)[j]] = 1;
        SWAP_INT_ELEM(vertices, k, j);
        VECTOR(edges)[2 * k - 2] = i;
        i = VECTOR(vertices)[k];
        VECTOR(edges)[2 * k - 1] = i;
    }

    RNG_END();

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));

    igraph_vector_int_destroy(&vertices);
    igraph_vector_bool_destroy(&visited);
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

#undef SWAP_INT_ELEM

/**
 * \ingroup generators
 * \function igraph_tree_game
 * \brief Generates a random tree with the given number of nodes.
 *
 * This function samples uniformly from the set of labelled trees,
 * i.e. it generates each labelled tree with the same probability.
 *
 * 
 * Note that for n=0, the null graph is returned,
 * which is not considered to be a tree by \ref igraph_is_tree().
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param n The number of nodes in the tree.
 * \param directed Whether to create a directed tree. The edges are oriented away from the root.
 * \param method The algorithm to use to generate the tree. Possible values:
 *        \clist
 *        \cli IGRAPH_RANDOM_TREE_PRUFER
 *          This algorithm samples Prüfer sequences uniformly, then converts them to trees.
 *          Directed trees are not currently supported.
 *        \cli IGRAPH_RANDOM_LERW
 *          This algorithm effectively performs a loop-erased random walk on the complete graph
 *          to uniformly sample its spanning trees (Wilson's algorithm).
 *        \endclist
 * \return Error code:
 *          \c IGRAPH_ENOMEM: there is not enough
 *           memory to perform the operation.
 *          \c IGRAPH_EINVAL: invalid tree size
 *
 * \sa \ref igraph_from_prufer()
 *
 */

int igraph_tree_game(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, igraph_random_tree_t method) {
    if (n < 2) {
        IGRAPH_CHECK(igraph_empty(graph, n, directed));
        return IGRAPH_SUCCESS;
    }

    switch (method) {
    case IGRAPH_RANDOM_TREE_PRUFER:
        return igraph_i_tree_game_prufer(graph, n, directed);
    case IGRAPH_RANDOM_TREE_LERW:
        return igraph_i_tree_game_loop_erased_random_walk(graph, n, directed);
    default:
        IGRAPH_ERROR("Invalid method for random tree construction", IGRAPH_EINVAL);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/games/watts_strogatz.c0000644000175100001710000000701700000000000025005 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

/**
 * \function igraph_watts_strogatz_game
 * \brief The Watts-Strogatz small-world model.
 *
 * This function generates a graph according to the Watts-Strogatz
 * model of small-world networks. The graph is obtained by creating a
 * circular undirected lattice and then rewire the edges randomly with
 * a constant probability.
 *
 * See also: Duncan J Watts and Steven H Strogatz:
 * Collective dynamics of small world networks, Nature
 * 393, 440-442, 1998.
 *
 * \param graph The graph to initialize.
 * \param dim The dimension of the lattice.
 * \param size The size of the lattice along each dimension.
 * \param nei The size of the neighborhood for each vertex. This is
 *    the same as the \p nei argument of \ref
 *    igraph_connect_neighborhood().
 * \param p The rewiring probability. A real number between zero and
 *   one (inclusive).
 * \param loops Logical, whether to generate loop edges.
 * \param multiple Logical, whether to allow multiple edges in the
 *   generated graph.
 * \return Error code.
 *
 * \sa \ref igraph_lattice(), \ref igraph_connect_neighborhood() and
 * \ref igraph_rewire_edges() can be used if more flexibility is
 * needed, e.g. a different type of lattice.
 *
 * Time complexity: O(|V|*d^o+|E|), |V| and |E| are the number of
 * vertices and edges, d is the average degree, o is the \p nei
 * argument.
 */
int igraph_watts_strogatz_game(igraph_t *graph, igraph_integer_t dim,
                               igraph_integer_t size, igraph_integer_t nei,
                               igraph_real_t p, igraph_bool_t loops,
                               igraph_bool_t multiple) {

    igraph_vector_t dimvector;
    long int i;

    if (dim < 1) {
        IGRAPH_ERROR("WS game: dimension should be at least one", IGRAPH_EINVAL);
    }
    if (size < 1) {
        IGRAPH_ERROR("WS game: lattice size should be at least one",
                     IGRAPH_EINVAL);
    }
    if (p < 0 || p > 1) {
        IGRAPH_ERROR("WS game: rewiring probability should be between 0 and 1",
                     IGRAPH_EINVAL);
    }

    /* Create the lattice first */

    IGRAPH_VECTOR_INIT_FINALLY(&dimvector, dim);
    for (i = 0; i < dim; i++) {
        VECTOR(dimvector)[i] = size;
    }

    IGRAPH_CHECK(igraph_lattice(graph, &dimvector, nei, IGRAPH_UNDIRECTED,
                                0 /* mutual */, 1 /* circular */));
    igraph_vector_destroy(&dimvector);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, graph);

    /* Rewire the edges then */

    IGRAPH_CHECK(igraph_rewire_edges(graph, p, loops, multiple));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5111408
igraph-0.9.9/vendor/source/igraph/src/graph/0000755000175100001710000000000000000000000021542 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/adjlist.c0000644000175100001710000011572500000000000023353 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_adjlist.h"
#include "igraph_memory.h"
#include "igraph_interface.h"

#include "core/interruption.h"

#include    /* memset */
#include 

/**
 * Helper function that simplifies a sorted adjacency vector by removing
 * duplicate elements and optionally self-loops.
 */
static int igraph_i_simplify_sorted_int_adjacency_vector_in_place(
    igraph_vector_int_t *v, igraph_integer_t index, igraph_neimode_t mode,
    igraph_loops_t loops, igraph_multiple_t multiple
);

/**
 * Helper function that removes loops from an incidence vector (either both
 * occurrences or only one of them).
 */
static int igraph_i_remove_loops_from_incidence_vector_in_place(
    igraph_vector_int_t *v, const igraph_t *graph, igraph_loops_t loops
);

/**
 * \section about_adjlists
 *
 * Sometimes it is easier to work with a graph which is in
 * adjacency list format: a list of vectors; each vector contains the
 * neighbor vertices or incident edges of a given vertex. Typically,
 * this representation is good if we need to iterate over the neighbors
 * of all vertices many times. E.g. when finding the shortest paths
 * between all pairs of vertices or calculating closeness centrality
 * for all the vertices.
 *
 * The igraph_adjlist_t stores the adjacency lists
 * of a graph. After creation it is independent of the original graph,
 * it can be modified freely with the usual vector operations, the
 * graph is not affected. E.g. the adjacency list can be used to
 * rewire the edges of a graph efficiently. If one used the
 * straightforward \ref igraph_delete_edges() and \ref
 * igraph_add_edges() combination for this that needs O(|V|+|E|) time
 * for every single deletion and insertion operation, it is thus very
 * slow if many edges are rewired. Extracting the graph into an
 * adjacency list, do all the rewiring operations on the vectors of
 * the adjacency list and then creating a new graph needs (depending
 * on how exactly the rewiring is done) typically O(|V|+|E|) time for
 * the whole rewiring process.
 *
 * Lazy adjacency lists are a bit different. When creating a
 * lazy adjacency list, the neighbors of the vertices are not queried,
 * only some memory is allocated for the vectors. When \ref
 * igraph_lazy_adjlist_get() is called for vertex v the first time,
 * the neighbors of v are queried and stored in a vector of the
 * adjacency list, so they don't need to be queried again. Lazy
 * adjacency lists are handy if you have an at least linear operation
 * (because initialization is generally linear in terms of the number of
 * vertices), but you don't know how many vertices you will visit
 * during the computation.
 * 
 *
 * 
 * \example examples/simple/adjlist.c
 * 
 */

/**
 * \function igraph_adjlist_init
 * \brief Constructs an adjacency list of vertices from a given graph.
 *
 * Creates a list of vectors containing the neighbors of all vertices
 * in a graph. The adjacency list is independent of the graph after
 * creation, e.g. the graph can be destroyed and modified, the
 * adjacency list contains the state of the graph at the time of its
 * initialization.
 *
 * \param graph The input graph.
 * \param al Pointer to an uninitialized igraph_adjlist_t object.
 * \param mode Constant specifying whether outgoing
 *   (IGRAPH_OUT), incoming (IGRAPH_IN),
 *   or both (IGRAPH_ALL) types of neighbors to include
 *   in the adjacency list. It is ignored for undirected networks.
 * \param loops Specifies how to treat loop edges. IGRAPH_NO_LOOPS
 *   removes loop edges from the adjacency list. IGRAPH_LOOPS_ONCE
 *   makes each loop edge appear only once in the adjacency list of the
 *   corresponding vertex. IGRAPH_LOOPS_TWICE makes loop edges
 *   appear \em twice in the adjacency list of the corresponding vertex,
 *   but only if the graph is undirected or mode is set to
 *   IGRAPH_ALL.
 * \param multiple Specifies how to treat multiple (parallel) edges.
 *   IGRAPH_NO_MULTIPLE collapses parallel edges into a single one;
 *   IGRAPH_MULTIPLE keeps the multiplicities of parallel edges
 *   so the same vertex will appear as many times in the adjacency list of
 *   another vertex as the number of parallel edges going between the two
 *   vertices.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 */

int igraph_adjlist_init(const igraph_t *graph, igraph_adjlist_t *al,
                        igraph_neimode_t mode, igraph_loops_t loops,
                        igraph_multiple_t multiple) {
    igraph_integer_t i;
    igraph_vector_t tmp;
    int j, n;

    if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Cannot create adjacency list view", IGRAPH_EINVMODE);
    }

    igraph_vector_init(&tmp, 0);
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp);

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    al->length = igraph_vcount(graph);
    al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t);
    if (al->adjs == 0) {
        IGRAPH_ERROR("Cannot create adjacency list view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_adjlist_destroy, al);

    for (i = 0; i < al->length; i++) {
        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_neighbors(graph, &tmp, i, mode));

        n = igraph_vector_size(&tmp);
        IGRAPH_CHECK(igraph_vector_int_init(&al->adjs[i], n));
        for (j = 0; j < n; j++) {
            VECTOR(al->adjs[i])[j] = VECTOR(tmp)[j];
        }

        IGRAPH_CHECK(igraph_i_simplify_sorted_int_adjacency_vector_in_place(
            &al->adjs[i], i, mode, loops, multiple
        ));
    }

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_adjlist_init_empty
 * \brief Initializes an empty adjacency list.
 *
 * Creates a list of vectors, one for each vertex. This is useful when you
 * are \em constructing a graph using an adjacency list representation as
 * it does not require your graph to exist yet.
 * \param no_of_nodes The number of vertices
 * \param al Pointer to an uninitialized igraph_adjlist_t object.
 * \return Error code.
 *
 * Time complexity: O(|V|), linear in the number of vertices.
 */
int igraph_adjlist_init_empty(igraph_adjlist_t *al, igraph_integer_t no_of_nodes) {
    long int i;

    al->length = no_of_nodes;
    al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t);
    if (al->adjs == 0) {
        IGRAPH_ERROR("Cannot create adjlist view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_adjlist_destroy, al);
    for (i = 0; i < al->length; i++) {
        IGRAPH_CHECK(igraph_vector_int_init(&al->adjs[i], 0));
    }
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_adjlist_init_complementer
 * \brief Adjacency lists for the complementer graph.
 *
 * This function creates adjacency lists for the complementer
 * of the input graph. In the complementer graph all edges are present
 * which are not present in the original graph. Multiple edges in the
 * input graph are ignored.
 * \param graph The input graph.
 * \param al Pointer to a not yet initialized adjacency list.
 * \param mode Constant specifying whether outgoing
 *   (IGRAPH_OUT), incoming (IGRAPH_IN),
 *   or both (IGRAPH_ALL) types of neighbors (in the
 *   complementer graph) to include in the adjacency list. It is
 *   ignored for undirected networks.
 * \param loops Whether to consider loop edges.
 * \return Error code.
 *
 * Time complexity: O(|V|^2+|E|), quadratic in the number of vertices.
 */
int igraph_adjlist_init_complementer(const igraph_t *graph,
                                     igraph_adjlist_t *al,
                                     igraph_neimode_t mode,
                                     igraph_bool_t loops) {
    igraph_integer_t i, j, k, n;
    igraph_bool_t* seen;
    igraph_vector_t vec;

    if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    al->length = igraph_vcount(graph);
    al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t);
    if (al->adjs == 0) {
        IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_adjlist_destroy, al);

    n = al->length;
    seen = IGRAPH_CALLOC(n, igraph_bool_t);
    if (seen == 0) {
        IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, seen);

    IGRAPH_VECTOR_INIT_FINALLY(&vec, 0);

    for (i = 0; i < al->length; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        igraph_neighbors(graph, &vec, i, mode);
        memset(seen, 0, sizeof(igraph_bool_t) * (unsigned) al->length);
        n = al->length;
        if (!loops) {
            seen[i] = 1;
            n--;
        }
        for (j = 0; j < igraph_vector_size(&vec); j++) {
            if (! seen [ (long int) VECTOR(vec)[j] ] ) {
                n--;
                seen[ (long int) VECTOR(vec)[j] ] = 1;
            }
        }
        IGRAPH_CHECK(igraph_vector_int_init(&al->adjs[i], n));
        for (j = 0, k = 0; k < n; j++) {
            if (!seen[j]) {
                VECTOR(al->adjs[i])[k++] = j;
            }
        }
    }

    IGRAPH_FREE(seen);
    igraph_vector_destroy(&vec);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

/**
 * \function igraph_adjlist_destroy
 * \brief Deallocates an adjacency list.
 *
 * Free all memory allocated for an adjacency list.
 * \param al The adjacency list to destroy.
 *
 * Time complexity: depends on memory management.
 */
void igraph_adjlist_destroy(igraph_adjlist_t *al) {
    long int i;
    for (i = 0; i < al->length; i++) {
        if (&al->adjs[i]) {
            igraph_vector_int_destroy(&al->adjs[i]);
        }
    }
    IGRAPH_FREE(al->adjs);
}

/**
 * \function igraph_adjlist_clear
 * Removes all edges from an adjacency list.
 *
 * \param al The adjacency list.
 * Time complexity: depends on memory management, typically O(n), where n is
 * the total number of elements in the adjacency list.
 */
void igraph_adjlist_clear(igraph_adjlist_t *al) {
    long int i;
    for (i = 0; i < al->length; i++) {
        igraph_vector_int_clear(&al->adjs[i]);
    }
}

/**
 * \function igraph_adjlist_size
 * \brief Returns the number of vertices in an adjacency list.
 *
 * \param al The adjacency list.
 * \return The number of vertices in the adjacency list.
 *
 * Time complexity: O(1).
 */
igraph_integer_t igraph_adjlist_size(const igraph_adjlist_t *al) {
    return al->length;
}

/**
 * \function igraph_adjlist_sort
 * \brief Sorts each vector in an adjacency list.
 *
 * Sorts every vector of the adjacency list.
 * \param al The adjacency list.
 *
 * Time complexity: O(n log n), n is the total number of elements in
 * the adjacency list.
 */
void igraph_adjlist_sort(igraph_adjlist_t *al) {
    long int i;
    for (i = 0; i < al->length; i++) {
        igraph_vector_int_sort(&al->adjs[i]);
    }
}

/**
 * \function igraph_adjlist_simplify
 * \brief Simplifies an adjacency list.
 *
 * Simplifies an adjacency list, i.e. removes loop and multiple edges.
 *
 * \param al The adjacency list.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of edges and
 * vertices.
 */
int igraph_adjlist_simplify(igraph_adjlist_t *al) {
    long int i;
    long int n = al->length;
    igraph_vector_int_t mark;
    igraph_vector_int_init(&mark, n);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &mark);
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->adjs[i];
        long int j, l = igraph_vector_int_size(v);
        VECTOR(mark)[i] = i + 1;
        for (j = 0; j < l; /* nothing */) {
            long int e = (long int) VECTOR(*v)[j];
            if (VECTOR(mark)[e] != i + 1) {
                VECTOR(mark)[e] = i + 1;
                j++;
            } else {
                VECTOR(*v)[j] = igraph_vector_int_tail(v);
                igraph_vector_int_pop_back(v);
                l--;
            }
        }
    }

    igraph_vector_int_destroy(&mark);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

int igraph_adjlist_remove_duplicate(const igraph_t *graph,
                                    igraph_adjlist_t *al) {
    long int i, j, l, n, p;
    igraph_vector_int_t *v;

    IGRAPH_WARNING(
        "igraph_adjlist_remove_duplicate() is deprecated; use the constructor "
        "arguments of igraph_adjlist_init() to specify whether you want loop "
        "edges to appear once or twice in the adjacency list."
    );

    IGRAPH_UNUSED(graph);

    n = al->length;
    for (i = 0; i < n; i++) {
        v = &al->adjs[i];
        l = igraph_vector_int_size(v);
        if (l > 0) {
            p = 1;
            for (j = 1; j < l; j++) {
                long int e = (long int) VECTOR(*v)[j];
                /* Non-loop edges, and one end of loop edges are fine. */
                /* We assume that the vector is sorted and we also keep it sorted */
                if (e != i || VECTOR(*v)[j - 1] != e) {
                    VECTOR(*v)[p++] = e;
                }
            }
            igraph_vector_int_resize(v, p);
        }
    }

    return 0;
}

#ifndef USING_R
int igraph_adjlist_print(const igraph_adjlist_t *al) {
    long int i;
    long int n = al->length;
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->adjs[i];
        igraph_vector_int_print(v);
    }
    return 0;
}
#endif

int igraph_adjlist_fprint(const igraph_adjlist_t *al, FILE *outfile) {
    long int i;
    long int n = al->length;
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->adjs[i];
        igraph_vector_int_fprint(v, outfile);
    }
    return 0;
}

#define ADJLIST_CANON_EDGE(from, to, directed) \
    do {                     \
        igraph_integer_t temp;         \
        if((!directed) && from < to) {     \
            temp = to;               \
            to = from;               \
            from = temp;             \
        }                      \
    } while(0);

igraph_bool_t igraph_adjlist_has_edge(igraph_adjlist_t* al, igraph_integer_t from, igraph_integer_t to, igraph_bool_t directed) {
    igraph_vector_int_t* fromvec;
    ADJLIST_CANON_EDGE(from, to, directed);
    fromvec = igraph_adjlist_get(al, from);
    return igraph_vector_int_binsearch2(fromvec, to);

}

int igraph_adjlist_replace_edge(igraph_adjlist_t* al, igraph_integer_t from, igraph_integer_t oldto, igraph_integer_t newto, igraph_bool_t directed) {
    igraph_vector_int_t *oldfromvec, *newfromvec;
    int err1, err2;
    long int oldpos, newpos;
    igraph_integer_t oldfrom = from, newfrom = from;
    ADJLIST_CANON_EDGE(oldfrom, oldto, directed);
    ADJLIST_CANON_EDGE(newfrom, newto, directed);

    oldfromvec = igraph_adjlist_get(al, oldfrom);
    newfromvec = igraph_adjlist_get(al, newfrom);


    err1 = igraph_vector_int_binsearch(oldfromvec, oldto, &oldpos);
    err2 = igraph_vector_int_binsearch(newfromvec, newto, &newpos);

    /* oldfrom -> oldto should exist; newfrom -> newto should not. */
    if ((!err1) || err2) {
        return 1;
    }

    igraph_vector_int_remove(oldfromvec, oldpos);
    if (oldfromvec == newfromvec && oldpos < newpos) {
        --newpos;
    }
    IGRAPH_CHECK(igraph_vector_int_insert(newfromvec, newpos, newto));

    return 0;

}

static int igraph_i_remove_loops_from_incidence_vector_in_place(
    igraph_vector_int_t *v, const igraph_t *graph, igraph_loops_t loops
) {
    long int i, length, eid, write_ptr;
    igraph_vector_int_t *seen_loops = 0;

    /* In this function we make use of the fact that we are dealing with
     * _incidence_ lists, and the only way for an edge ID to appear twice
     * within an incidence list is if the edge is a loop edge; otherwise each
     * element will be unique.
     *
     * Note that incidence vectors are not sorted by edge ID, so we need to
     * look up the edges in the graph to decide whether they are loops or not.
     *
     * Also, it may be tempting to introduce a boolean in case of IGRAPH_LOOPS_ONCE,
     * and flip it every time we see a loop to get rid of half of the occurrences,
     * but the problem is that even if the same loop edge ID appears twice in
     * the input list, they are not guaranteed to be next to each other; it
     * may be the case that there are multiple loop edges, each edge appears
     * twice, and we want to keep exactly one of them for each ID. That's why
     * we have a "seen_loops" vector.
     */

    if (loops == IGRAPH_LOOPS_TWICE) {
        /* Loop edges appear twice by default, nothing to do. */
        return IGRAPH_SUCCESS;
    }

    length = igraph_vector_int_size(v);
    if (length == 0) {
        return IGRAPH_SUCCESS;
    }

    if (loops == IGRAPH_LOOPS_ONCE) {
        /* We need a helper vector */
        seen_loops = IGRAPH_CALLOC(1, igraph_vector_int_t);
        IGRAPH_FINALLY(igraph_free, seen_loops);
        IGRAPH_CHECK(igraph_vector_int_init(seen_loops, 0));
        IGRAPH_FINALLY(igraph_vector_int_destroy, seen_loops);
    } else if (loops != IGRAPH_NO_LOOPS) {
        IGRAPH_ERROR("Invalid value for 'loops' argument", IGRAPH_EINVAL);
    }

    for (i = 0, write_ptr = 0; i < length; i++) {
        eid = VECTOR(*v)[i];
        if (IGRAPH_FROM(graph, eid) == IGRAPH_TO(graph, eid)) {
            /* Loop edge */
            if (seen_loops && !igraph_vector_int_contains(seen_loops, eid)) {
                VECTOR(*v)[write_ptr++] = eid;
                IGRAPH_CHECK(igraph_vector_int_push_back(seen_loops, eid));
            }
        } else {
            /* Not a loop edge */
            VECTOR(*v)[write_ptr++] = eid;
        }
    }

    /* Always succeeds since we never grow the vector */
    igraph_vector_int_resize(v, write_ptr);

    /* Destroy the helper vector */
    if (seen_loops) {
        igraph_vector_int_destroy(seen_loops);
        IGRAPH_FREE(seen_loops);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return IGRAPH_SUCCESS;
}

int igraph_inclist_remove_duplicate(const igraph_t *graph, igraph_inclist_t *il) {
    long int i, n;

    IGRAPH_WARNING(
        "igraph_inclist_remove_duplicate() is deprecated; use the constructor "
        "arguments of igraph_inclist_init() to specify whether you want loop "
        "edges to appear once or twice in the incidence list."
    );

    IGRAPH_UNUSED(graph);

    n = il->length;
    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(
            igraph_i_remove_loops_from_incidence_vector_in_place(
                &il->incs[i], graph, IGRAPH_LOOPS_ONCE
            )
        );
    }

    return 0;
}

#ifndef USING_R
int igraph_inclist_print(const igraph_inclist_t *al) {
    long int i;
    long int n = al->length;
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->incs[i];
        igraph_vector_int_print(v);
    }
    return 0;
}
#endif

int igraph_inclist_fprint(const igraph_inclist_t *al, FILE *outfile) {
    long int i;
    long int n = al->length;
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->incs[i];
        igraph_vector_int_fprint(v, outfile);
    }
    return 0;
}

/**
 * \function igraph_inclist_init
 * \brief Initializes an incidence list.
 *
 * Creates a list of vectors containing the incident edges for all
 * vertices. The incidence list is independent of the graph after
 * creation, subsequent changes of the graph object do not update the
 * incidence list, and changes to the incidence list do not update the
 * graph.
 *
 * 
 * When \p mode is \c IGRAPH_IN or \c IGRAPH_OUT, each edge ID will appear
 * in the incidence list \em once. When \p mode is \c IGRAPH_ALL, each edge ID
 * will appear in the incidence list \em twice, once for the source vertex
 * and once for the target edge. It also means that the edge IDs of loop edges
 * may potentially appear \em twice for the \em same vertex. Use the \p loops
 * argument to control whether this will be the case (\c IGRAPH_LOOPS_TWICE )
 * or not (\c IGRAPH_LOOPS_ONCE or \c IGRAPH_NO_LOOPS).
 *
 * \param graph The input graph.
 * \param il Pointer to an uninitialized incidence list.
 * \param mode Constant specifying whether incoming edges
 *   (IGRAPH_IN), outgoing edges (IGRAPH_OUT) or
 *   both (IGRAPH_ALL) to include in the incidence lists
 *   of directed graphs. It is ignored for undirected graphs.
 * \param loops Specifies how to treat loop edges. IGRAPH_NO_LOOPS
 *   removes loop edges from the incidence list. IGRAPH_LOOPS_ONCE
 *   makes each loop edge appear only once in the incidence list of the
 *   corresponding vertex. IGRAPH_LOOPS_TWICE makes loop edges
 *   appear \em twice in the incidence list of the corresponding vertex,
 *   but only if the graph is undirected or mode is set to
 *   IGRAPH_ALL.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 */
int igraph_inclist_init(const igraph_t *graph,
                        igraph_inclist_t *il,
                        igraph_neimode_t mode,
                        igraph_loops_t loops) {
    igraph_integer_t i;
    igraph_vector_t tmp;

    if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_EINVMODE);
    }

    igraph_vector_init(&tmp, 0);
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp);

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    il->length = igraph_vcount(graph);
    il->incs = IGRAPH_CALLOC(il->length, igraph_vector_int_t);
    if (il->incs == 0) {
        IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_inclist_destroy, il);
    for (i = 0; i < il->length; i++) {
        int j, n;

        IGRAPH_ALLOW_INTERRUPTION();

        IGRAPH_CHECK(igraph_incident(graph, &tmp, i, mode));

        n = igraph_vector_size(&tmp);
        IGRAPH_CHECK(igraph_vector_int_init(&il->incs[i], n));

        for (j = 0; j < n; j++) {
            VECTOR(il->incs[i])[j] = VECTOR(tmp)[j];
        }

        if (loops != IGRAPH_LOOPS_TWICE) {
            IGRAPH_CHECK(
                igraph_i_remove_loops_from_incidence_vector_in_place(&il->incs[i], graph, loops)
            );
        }
    }

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

/**
 * \function igraph_inclist_init_empty
 * \brief Initializes an incidence list corresponding to an empty graph.
 *
 * This function essentially creates a list of empty vectors that may
 * be treated as an incidence list for a graph with a given number of
 * vertices.
 *
 * \param il Pointer to an uninitialized incidence list.
 * \param n  The number of vertices in the incidence list.
 * \return Error code.
 *
 * Time complexity: O(|V|), linear in the number of vertices.
 */

int igraph_inclist_init_empty(igraph_inclist_t *il, igraph_integer_t n) {
    long int i;

    il->length = n;
    il->incs = IGRAPH_CALLOC(il->length, igraph_vector_int_t);
    if (il->incs == 0) {
        IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_inclist_destroy, il);
    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_vector_int_init(&il->incs[i], 0));
    }

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_inclist_destroy
 * \brief Frees all memory allocated for an incidence list.
 *
 * \param eal The incidence list to destroy.
 *
 * Time complexity: depends on memory management.
 */

void igraph_inclist_destroy(igraph_inclist_t *il) {
    long int i;
    for (i = 0; i < il->length; i++) {
        /* This works if some igraph_vector_int_t's are 0,
           because igraph_vector_destroy can handle this. */
        igraph_vector_int_destroy(&il->incs[i]);
    }
    IGRAPH_FREE(il->incs);
}

/**
 * \function igraph_inclist_clear
 * \brief Removes all edges from an incidence list.
 *
 * \param il The incidence list.
 *
 * Time complexity: depends on memory management, typically O(n), where n is
 * the total number of elements in the incidence list.
 */
void igraph_inclist_clear(igraph_inclist_t *il) {
    long int i;
    for (i = 0; i < il->length; i++) {
        igraph_vector_int_clear(&il->incs[i]);
    }
}

/**
 * \function igraph_inclist_size
 * \brief Returns the number of vertices in an incidence list.
 *
 * \param il The incidence list.
 * \return The number of vertices in the incidence list.
 *
 * Time complexity: O(1).
 */
igraph_integer_t igraph_inclist_size(const igraph_inclist_t *il) {
    return il->length;
}

static int igraph_i_simplify_sorted_int_adjacency_vector_in_place(
    igraph_vector_int_t *v, igraph_integer_t index, igraph_neimode_t mode,
    igraph_loops_t loops, igraph_multiple_t multiple
) {
    long int i, p = 0;
    long int n = igraph_vector_int_size(v);

    if (
        multiple == IGRAPH_MULTIPLE &&
        (
            loops == IGRAPH_LOOPS_TWICE ||
            (loops == IGRAPH_LOOPS_ONCE && (mode == IGRAPH_IN || mode == IGRAPH_OUT))
        )
    ) {
        /* nothing to simplify */
        return IGRAPH_SUCCESS;
    }

    if (loops == IGRAPH_NO_LOOPS) {
        if (multiple == IGRAPH_NO_MULTIPLE) {
            /* We need to get rid of loops and multiple edges completely */
            for (i = 0; i < n; i++) {
                if (VECTOR(*v)[i] != index &&
                    (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i])) {
                    VECTOR(*v)[p] = VECTOR(*v)[i];
                    p++;
                }
            }
        } else {
            /* We need to get rid of loops but keep multiple edges */
            for (i = 0; i < n; i++) {
                if (VECTOR(*v)[i] != index) {
                    VECTOR(*v)[p] = VECTOR(*v)[i];
                    p++;
                }
            }
        }
    } else if (loops == IGRAPH_LOOPS_ONCE) {
        if (multiple == IGRAPH_NO_MULTIPLE) {
            /* We need to get rid of multiple edges completely (including
             * multiple loop edges), but keep one edge from each loop edge */
            /* TODO(ntamas): think this through! */
            for (i = 0; i < n; i++) {
                if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) {
                    VECTOR(*v)[p] = VECTOR(*v)[i];
                    p++;
                }
            }
        } else {
            /* We need to keep one edge from each loop edge and we don't need to
             * touch multiple edges. Note that we can get here only if
             * mode == IGRAPH_ALL; if mode was IGRAPH_IN or IGRAPH_OUT, we would
             * have bailed out earlier */
            for (i = 0; i < n; i++) {
                VECTOR(*v)[p] = VECTOR(*v)[i];
                if (VECTOR(*v)[i] == index) {
                    /* this was a loop edge so if the next element is the same, we
                    * need to skip that */
                    if (i < n-1 && VECTOR(*v)[i + 1] == index) {
                        i++;
                    }
                }
                p++;
            }
        }
    } else if (loops == IGRAPH_LOOPS_TWICE && multiple == IGRAPH_NO_MULTIPLE) {
        /* We need to get rid of multiple edges completely (including
         * multiple loop edges), but keep both edge from each loop edge */
        /* TODO(ntamas): think this through! */
        for (i = 0; i < n; i++) {
            if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) {
                VECTOR(*v)[p] = VECTOR(*v)[i];
                p++;
            } else {
                /* Current item is the same as the next one, but if it is a
                 * loop edge, then the first one or two items are okay. We need
                 * to keep one if mode == IGRAPH_IN or mode == IGRAPH_OUT,
                 * otherwise we need to keep two */
                if (VECTOR(*v)[i] == index) {
                    VECTOR(*v)[p] = VECTOR(*v)[i];
                    p++;
                    if (mode == IGRAPH_ALL) {
                        VECTOR(*v)[p] = VECTOR(*v)[i];
                        p++;
                    }
                    /* skip over all the items corresponding to the loop edges */
                    while (i < n && VECTOR(*v)[i] == index) {
                        i++;
                    }
                    i--; /* because the for loop also increases i by 1 */
                }
            }
        }
    } else {
        /* TODO; we don't use this combination yet */
        return IGRAPH_UNIMPLEMENTED;
    }

    /* always succeeds since we are never growing the vector */
    igraph_vector_int_resize(v, p);

    return IGRAPH_SUCCESS;
}


/**
 * \function igraph_lazy_adjlist_init
 * \brief Initialized a lazy adjacency list.
 *
 * Create a lazy adjacency list for vertices. This function only
 * allocates some memory for storing the vectors of an adjacency list,
 * but the neighbor vertices are not queried, only at the \ref
 * igraph_lazy_adjlist_get() calls.
 * \param graph The input graph.
 * \param al Pointer to an uninitialized adjacency list object.
 * \param mode Constant, it gives whether incoming edges
 *   (IGRAPH_IN), outgoing edges
 *   (IGRPAH_OUT) or both types of edges
 *   (IGRAPH_ALL) are considered. It is ignored for
 *   undirected graphs.
 * \param simplify Constant, it gives whether to simplify the vectors
 *   in the adjacency list (IGRAPH_SIMPLIFY) or not
 *   (IGRAPH_DONT_SIMPLIFY).
 * \return Error code.
 *
 * Time complexity: O(|V|), the number of vertices, possibly, but
 * depends on the underlying memory management too.
 */

int igraph_lazy_adjlist_init(const igraph_t *graph,
                             igraph_lazy_adjlist_t *al,
                             igraph_neimode_t mode,
                             igraph_loops_t loops,
                             igraph_multiple_t multiple) {
    if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Cannor create lazy adjacency list view", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    al->mode = mode;
    al->loops = loops;
    al->multiple = multiple;
    al->graph = graph;

    al->length = igraph_vcount(graph);
    al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t*);

    if (al->adjs == 0) {
        IGRAPH_ERROR("Cannot create lazy adjacency list view", IGRAPH_ENOMEM);
    }

    IGRAPH_FINALLY(igraph_free, al->adjs);

    IGRAPH_CHECK(igraph_vector_init(&al->dummy, 0));
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_lazy_adjlist_destroy
 * \brief Deallocate a lazt adjacency list.
 *
 * Free all allocated memory for a lazy adjacency list.
 * \param al The adjacency list to deallocate.
 *
 * Time complexity: depends on the memory management.
 */

void igraph_lazy_adjlist_destroy(igraph_lazy_adjlist_t *al) {
    igraph_lazy_adjlist_clear(al);
    igraph_vector_destroy(&al->dummy);
    IGRAPH_FREE(al->adjs);
}

/**
 * \function igraph_lazy_adjlist_clear
 * \brief Removes all edges from a lazy adjacency list.
 *
 * \param al The lazy adjacency list.
 * Time complexity: depends on memory management, typically O(n), where n is
 * the total number of elements in the adjacency list.
 */
void igraph_lazy_adjlist_clear(igraph_lazy_adjlist_t *al) {
    long int i, n = al->length;
    for (i = 0; i < n; i++) {
        if (al->adjs[i] != 0) {
            igraph_vector_int_destroy(al->adjs[i]);
            IGRAPH_FREE(al->adjs[i]);
        }
    }
}

/**
 * \function igraph_lazy_adjlist_size
 * \brief Returns the number of vertices in a lazy adjacency list.
 *
 * \param al The lazy adjacency list.
 * \return The number of vertices in the lazy adjacency list.
 *
 * Time complexity: O(1).
 */
igraph_integer_t igraph_lazy_adjlist_size(const igraph_lazy_adjlist_t *al) {
    return al->length;
}

igraph_vector_int_t *igraph_i_lazy_adjlist_get_real(igraph_lazy_adjlist_t *al,
        igraph_integer_t pno) {
    igraph_integer_t no = pno;
    long int i, n;
    int ret;

    if (al->adjs[no] == 0) {
        ret = igraph_neighbors(al->graph, &al->dummy, no, al->mode);
        if (ret != 0) {
            igraph_error("", IGRAPH_FILE_BASENAME, __LINE__, ret);
            return 0;
        }

        al->adjs[no] = IGRAPH_CALLOC(1, igraph_vector_int_t);
        if (al->adjs[no] == 0) {
            igraph_error("Lazy adjlist failed", IGRAPH_FILE_BASENAME, __LINE__,
                         IGRAPH_ENOMEM);
            return 0;
        }

        n = igraph_vector_size(&al->dummy);
        ret = igraph_vector_int_init(al->adjs[no], n);
        if (ret != 0) {
            IGRAPH_FREE(al->adjs[no]);
            igraph_error("", IGRAPH_FILE_BASENAME, __LINE__, ret);
            return 0;
        }

        for (i = 0; i < n; i++) {
            VECTOR(*al->adjs[no])[i] = VECTOR(al->dummy)[i];
        }

        ret = igraph_i_simplify_sorted_int_adjacency_vector_in_place(
            al->adjs[no], no, al->mode, al->loops, al->multiple
        );
        if (ret != 0) {
            igraph_vector_int_destroy(al->adjs[no]);
            IGRAPH_FREE(al->adjs[no]);
            igraph_error("", IGRAPH_FILE_BASENAME, __LINE__, ret);
            return 0;
        }
    }

    return al->adjs[no];
}

/**
 * \function igraph_lazy_inclist_init
 * \brief Initializes a lazy incidence list of edges.
 *
 * Create a lazy incidence list for edges. This function only
 * allocates some memory for storing the vectors of an incidence list,
 * but the incident edges are not queried, only when \ref
 * igraph_lazy_inclist_get() is called.
 *
 * 
 * When \p mode is \c IGRAPH_IN or \c IGRAPH_OUT, each edge ID will appear
 * in the incidence list \em once. When \p mode is \c IGRAPH_ALL, each edge ID
 * will appear in the incidence list \em twice, once for the source vertex
 * and once for the target edge. It also means that the edge IDs of loop edges
 * will appear \em twice for the \em same vertex.
 *
 * \param graph The input graph.
 * \param al Pointer to an uninitialized incidence list.
 * \param mode Constant, it gives whether incoming edges
 *   (IGRAPH_IN), outgoing edges
 *   (IGRAPH_OUT) or both types of edges
 *   (IGRAPH_ALL) are considered. It is ignored for
 *   undirected graphs.
 * \param loops Specifies how to treat loop edges. IGRAPH_NO_LOOPS
 *   removes loop edges from the incidence list. IGRAPH_LOOPS_ONCE
 *   makes each loop edge appear only once in the incidence list of the
 *   corresponding vertex. IGRAPH_LOOPS_TWICE makes loop edges
 *   appear \em twice in the incidence list of the corresponding vertex,
 *   but only if the graph is undirected or mode is set to
 *   IGRAPH_ALL.
 * \return Error code.
 *
 * Time complexity: O(|V|), the number of vertices, possibly. But it
 * also depends on the underlying memory management.
 */

int igraph_lazy_inclist_init(const igraph_t *graph,
                             igraph_lazy_inclist_t *il,
                             igraph_neimode_t mode,
                             igraph_loops_t loops) {

    if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Cannot create lazy incidence list view", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    il->graph = graph;
    il->loops = loops;
    il->mode = mode;

    il->length = igraph_vcount(graph);
    il->incs = IGRAPH_CALLOC(il->length, igraph_vector_int_t*);
    if (il->incs == 0) {

        IGRAPH_ERROR("Cannot create lazy incidence list view", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, il->incs);

    IGRAPH_CHECK(igraph_vector_init(&il->dummy, 0));
    IGRAPH_FINALLY_CLEAN(1);

    return 0;

}

/**
 * \function igraph_lazy_inclist_destroy
 * \brief Deallocates a lazy incidence list.
 *
 * Frees all allocated memory for a lazy incidence list.
 * \param al The incidence list to deallocate.
 *
 * Time complexity: depends on memory management.
 */

void igraph_lazy_inclist_destroy(igraph_lazy_inclist_t *il) {
    igraph_lazy_inclist_clear(il);
    igraph_vector_destroy(&il->dummy);
    IGRAPH_FREE(il->incs);
}

/**
 * \function igraph_lazy_inclist_clear
 * \brief Removes all edges from a lazy incidence list.
 *
 * \param il The lazy incidence list.
 *
 * Time complexity: depends on memory management, typically O(n), where n is
 * the total number of elements in the incidence list.
 */
void igraph_lazy_inclist_clear(igraph_lazy_inclist_t *il) {
    long int i, n = il->length;
    for (i = 0; i < n; i++) {
        if (il->incs[i] != 0) {
            igraph_vector_int_destroy(il->incs[i]);
            IGRAPH_FREE(il->incs[i]);
        }
    }
}

/**
 * \function igraph_lazy_inclist_size
 * \brief Returns the number of vertices in a lazy incidence list.
 *
 * \param il The lazy incidence list.
 * \return The number of vertices in the lazy incidence list.
 *
 * Time complexity: O(1).
 */
igraph_integer_t igraph_lazy_inclist_size(const igraph_lazy_inclist_t *il) {
    return il->length;
}

igraph_vector_int_t *igraph_i_lazy_inclist_get_real(igraph_lazy_inclist_t *il,
        igraph_integer_t pno) {
    igraph_integer_t no = pno;
    int ret;
    long int i, n;

    if (il->incs[no] == 0) {
        ret = igraph_incident(il->graph, &il->dummy, no, il->mode);
        if (ret != 0) {
            igraph_error("", IGRAPH_FILE_BASENAME, __LINE__, ret);
            return 0;
        }

        il->incs[no] = IGRAPH_CALLOC(1, igraph_vector_int_t);
        if (il->incs[no] == 0) {
            igraph_error("Lazy incidence list query failed", IGRAPH_FILE_BASENAME, __LINE__,
                         IGRAPH_ENOMEM);
            return 0;
        }

        n = igraph_vector_size(&il->dummy);
        ret = igraph_vector_int_init(il->incs[no], n);
        if (ret != 0) {
            IGRAPH_FREE(il->incs[no]);
            igraph_error("", IGRAPH_FILE_BASENAME, __LINE__, ret);
            return 0;
        }

        for (i = 0; i < n; i++) {
            VECTOR(*il->incs[no])[i] = VECTOR(il->dummy)[i];
        }

        if (il->loops != IGRAPH_LOOPS_TWICE) {
            ret = igraph_i_remove_loops_from_incidence_vector_in_place(il->incs[no], il->graph, il->loops);
            if (ret != 0) {
                igraph_vector_int_destroy(il->incs[no]);
                IGRAPH_FREE(il->incs[no]);
                return 0;
            }
        }
    }

    return il->incs[no];
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/attributes.c0000644000175100001710000003651100000000000024102 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_attributes.h"
#include "igraph_memory.h"

#include "graph/attributes.h"

#include "config.h"

#include 
#include 

/* Should you ever want to have a thread-local attribute handler table, prepend
 * IGRAPH_THREAD_LOCAL to the following declaration */
igraph_attribute_table_t *igraph_i_attribute_table = 0;

int igraph_i_attribute_init(igraph_t *graph, void *attr) {
    graph->attr = 0;
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->init(graph, attr);
    } else {
        return 0;
    }
}

void igraph_i_attribute_destroy(igraph_t *graph) {
    if (igraph_i_attribute_table) {
        igraph_i_attribute_table->destroy(graph);
    }
}

int igraph_i_attribute_copy(igraph_t *to, const igraph_t *from, igraph_bool_t ga,
                            igraph_bool_t va, igraph_bool_t ea) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->copy(to, from, ga, va, ea);
    } else {
        return 0;
    }
}

int igraph_i_attribute_add_vertices(igraph_t *graph, long int nv, void *attr) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->add_vertices(graph, nv, attr);
    } else {
        return 0;
    }
}

int igraph_i_attribute_permute_vertices(const igraph_t *graph,
                                        igraph_t *newgraph,
                                        const igraph_vector_t *idx) {

    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->permute_vertices(graph, newgraph, idx);
    } else {
        return 0;
    }
}

int igraph_i_attribute_combine_vertices(const igraph_t *graph,
                                        igraph_t *newgraph,
                                        const igraph_vector_ptr_t *merges,
                                        const igraph_attribute_combination_t *comb) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->combine_vertices(graph, newgraph,
                merges,
                comb);
    } else {
        return 0;
    }
}

int igraph_i_attribute_add_edges(igraph_t *graph,
                                 const igraph_vector_t *edges, void *attr) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->add_edges(graph, edges, attr);
    } else {
        return 0;
    }
}

int igraph_i_attribute_permute_edges(const igraph_t *graph,
                                     igraph_t *newgraph,
                                     const igraph_vector_t *idx) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->permute_edges(graph, newgraph, idx);
    } else {
        return 0;
    }
}

int igraph_i_attribute_combine_edges(const igraph_t *graph,
                                     igraph_t *newgraph,
                                     const igraph_vector_ptr_t *merges,
                                     const igraph_attribute_combination_t *comb) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->combine_edges(graph, newgraph,
                merges,
                comb);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_info(const igraph_t *graph,
                                igraph_strvector_t *gnames,
                                igraph_vector_t *gtypes,
                                igraph_strvector_t *vnames,
                                igraph_vector_t *vtypes,
                                igraph_strvector_t *enames,
                                igraph_vector_t *etypes) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_info(graph, gnames, gtypes,
                vnames, vtypes,
                enames, etypes);
    } else {
        return 0;
    }
}

igraph_bool_t igraph_i_attribute_has_attr(const igraph_t *graph,
        igraph_attribute_elemtype_t type,
        const char *name) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->has_attr(graph, type, name);
    } else {
        return 0;
    }
}

int igraph_i_attribute_gettype(const igraph_t *graph,
                               igraph_attribute_type_t *type,
                               igraph_attribute_elemtype_t elemtype,
                               const char *name) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->gettype(graph, type, elemtype, name);
    } else {
        return 0;
    }

}

int igraph_i_attribute_get_numeric_graph_attr(const igraph_t *graph,
        const char *name,
        igraph_vector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_numeric_graph_attr(graph, name, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_numeric_vertex_attr(const igraph_t *graph,
        const char *name,
        igraph_vs_t vs,
        igraph_vector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_numeric_vertex_attr(graph, name, vs, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_numeric_edge_attr(const igraph_t *graph,
        const char *name,
        igraph_es_t es,
        igraph_vector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_numeric_edge_attr(graph, name, es, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_string_graph_attr(const igraph_t *graph,
        const char *name,
        igraph_strvector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_string_graph_attr(graph, name, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_string_vertex_attr(const igraph_t *graph,
        const char *name,
        igraph_vs_t vs,
        igraph_strvector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_string_vertex_attr(graph, name, vs, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_string_edge_attr(const igraph_t *graph,
        const char *name,
        igraph_es_t es,
        igraph_strvector_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_string_edge_attr(graph, name, es, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_bool_graph_attr(const igraph_t *graph,
        const char *name,
        igraph_vector_bool_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_bool_graph_attr(graph, name, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_bool_vertex_attr(const igraph_t *graph,
        const char *name,
        igraph_vs_t vs,
        igraph_vector_bool_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_bool_vertex_attr(graph, name, vs, value);
    } else {
        return 0;
    }
}

int igraph_i_attribute_get_bool_edge_attr(const igraph_t *graph,
        const char *name,
        igraph_es_t es,
        igraph_vector_bool_t *value) {
    if (igraph_i_attribute_table) {
        return igraph_i_attribute_table->get_bool_edge_attr(graph, name, es, value);
    } else {
        return 0;
    }
}

/**
 * \function igraph_set_attribute_table
 * \brief Attach an attribute table.
 *
 * This function attaches attribute handling code to the igraph library.
 * Note that the attribute handler table is \em not thread-local even if
 * igraph is compiled in thread-local mode. In the vast majority of cases,
 * this is not a significant restriction.
 *
 * \param table Pointer to an \ref igraph_attribute_table_t object
 *    containing the functions for attribute manipulation. Supply \c
 *    NULL here if you don't want attributes.
 * \return Pointer to the old attribute handling table.
 *
 * Time complexity: O(1).
 */

igraph_attribute_table_t *
igraph_set_attribute_table(const igraph_attribute_table_t * table) {
    igraph_attribute_table_t *old = igraph_i_attribute_table;
    igraph_i_attribute_table = (igraph_attribute_table_t*) table;
    return old;
}

igraph_attribute_table_t *
igraph_i_set_attribute_table(const igraph_attribute_table_t * table) {
    IGRAPH_WARNING("igraph_i_set_attribute_table is deprecated, use igraph_set_attribute_table.");
    return igraph_set_attribute_table(table);
}

igraph_bool_t igraph_has_attribute_table() {
    return igraph_i_attribute_table != 0;
}


/**
 * \function igraph_attribute_combination_init
 * \brief Initialize attribute combination list.
 *
 * \param comb The uninitialized attribute combination list.
 * \return Error code.
 *
 * Time complexity: O(1)
 */
int igraph_attribute_combination_init(igraph_attribute_combination_t *comb) {
    IGRAPH_CHECK(igraph_vector_ptr_init(&comb->list, 0));
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_attribute_combination_destroy
 * \brief Destroy attribute combination list.
 *
 * \param comb The attribute combination list.
 *
 * Time complexity: O(n), where n is the number of records in the
                    attribute combination list.
 */
void igraph_attribute_combination_destroy(igraph_attribute_combination_t *comb) {
    long int i, n = igraph_vector_ptr_size(&comb->list);
    for (i = 0; i < n; i++) {
        igraph_attribute_combination_record_t *rec = VECTOR(comb->list)[i];
        if (rec->name) {
            IGRAPH_FREE(rec->name);
        }
        IGRAPH_FREE(rec);
    }
    igraph_vector_ptr_destroy(&comb->list);
}

/**
 * \function igraph_attribute_combination_add
 * \brief Add combination record to attribute combination list.
 *
 * \param comb The attribute combination list.
 * \param name The name of the attribute. If the name already exists
 *             the attribute combination record will be replaced.
 *             Use NULL to add a default combination record for all
 *             atributes not in the list.
 * \param type The type of the attribute combination. See \ref
 *             igraph_attribute_combination_type_t for the options.
 * \param func Function to be used if \p type is
 *             \c IGRAPH_ATTRIBUTE_COMBINE_FUNCTION.
 * \return Error code.
 *
 * Time complexity: O(n), where n is the number of current attribute
 *                  combinations.
 */
int igraph_attribute_combination_add(igraph_attribute_combination_t *comb,
                                     const char *name,
                                     igraph_attribute_combination_type_t type,
                                     igraph_function_pointer_t func) {
    long int i, n = igraph_vector_ptr_size(&comb->list);

    /* Search, in case it is already there */
    for (i = 0; i < n; i++) {
        igraph_attribute_combination_record_t *r = VECTOR(comb->list)[i];
        const char *n = r->name;
        if ( (!name && !n) ||
             (name && n && !strcmp(n, name)) ) {
            r->type = type;
            r->func = func;
            break;
        }
    }

    if (i == n) {
        /* This is a new attribute name */
        igraph_attribute_combination_record_t *rec =
            IGRAPH_CALLOC(1, igraph_attribute_combination_record_t);

        if (!rec) {
            IGRAPH_ERROR("Cannot create attribute combination data",
                         IGRAPH_ENOMEM);
        }
        if (!name) {
            rec->name = NULL;
        } else {
            rec->name = strdup(name);
        }
        rec->type = type;
        rec->func = func;

        IGRAPH_CHECK(igraph_vector_ptr_push_back(&comb->list, rec));

    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_attribute_combination_remove
 * \brief Remove a record from an attribute combination list.
 *
 * \param comb The attribute combination list.
 * \param name The attribute name of the attribute combination record
 *             to remove. It will be ignored if the named attribute
 *             does not exist. It can be NULL to remove the default
 *             combination record.
 * \return Error code. This currently always returns IGRAPH_SUCCESS.
 *
 * Time complexity: O(n), where n is the number of records in the attribute
                    combination list.
 */
int igraph_attribute_combination_remove(igraph_attribute_combination_t *comb,
                                        const char *name) {
    long int i, n = igraph_vector_ptr_size(&comb->list);

    /* Search, in case it is already there */
    for (i = 0; i < n; i++) {
        igraph_attribute_combination_record_t *r = VECTOR(comb->list)[i];
        const char *n = r->name;
        if ( (!name && !n) ||
             (name && n && !strcmp(n, name)) ) {
            break;
        }
    }

    if (i != n) {
        igraph_attribute_combination_record_t *r = VECTOR(comb->list)[i];
        if (r->name) {
            IGRAPH_FREE(r->name);
        }
        IGRAPH_FREE(r);
        igraph_vector_ptr_remove(&comb->list, i);
    } else {
        /* It is not there, we don't do anything */
    }

    return IGRAPH_SUCCESS;
}

int igraph_attribute_combination_query(const igraph_attribute_combination_t *comb,
                                       const char *name,
                                       igraph_attribute_combination_type_t *type,
                                       igraph_function_pointer_t *func) {
    long int i, def = -1, len = igraph_vector_ptr_size(&comb->list);

    for (i = 0; i < len; i++) {
        igraph_attribute_combination_record_t *rec = VECTOR(comb->list)[i];
        const char *n = rec->name;
        if ( (!name && !n) ||
             (name && n && !strcmp(n, name)) ) {
            *type = rec->type;
            *func = rec->func;
            return 0;
        }
        if (!n) {
            def = i;
        }
    }

    if (def == -1) {
        /* Did not find anything */
        *type = IGRAPH_ATTRIBUTE_COMBINE_DEFAULT;
        *func = 0;
    } else {
        igraph_attribute_combination_record_t *rec = VECTOR(comb->list)[def];
        *type = rec->type;
        *func = rec->func;
    }

    return 0;
}

int igraph_attribute_combination(igraph_attribute_combination_t *comb, ...) {

    va_list ap;

    IGRAPH_CHECK(igraph_attribute_combination_init(comb));

    va_start(ap, comb);
    while (1) {
        igraph_function_pointer_t func = 0;
        igraph_attribute_combination_type_t type;
        const char *name;

        name = va_arg(ap, const char *);

        if (name == IGRAPH_NO_MORE_ATTRIBUTES) {
            break;
        }

        type = (igraph_attribute_combination_type_t)va_arg(ap, int);
        if (type == IGRAPH_ATTRIBUTE_COMBINE_FUNCTION) {
            func = va_arg(ap, igraph_function_pointer_t);
        }

        if (strlen(name) == 0) {
            name = 0;
        }

        IGRAPH_CHECK(igraph_attribute_combination_add(comb, name, type, func));
    }

    va_end(ap);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/attributes.h0000644000175100001710000001340500000000000024104 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_GRAPH_ATTRIBUTES_H
#define IGRAPH_GRAPH_ATTRIBUTES_H

#include "igraph_attributes.h"
#include "igraph_strvector.h"
#include "igraph_types.h"
#include "igraph_vector_ptr.h"

#define IGRAPH_I_ATTRIBUTE_DESTROY(graph) \
    do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0)
#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \
        int igraph_i_ret2=0; \
        if ((from)->attr) { \
            IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \
        } else { \
            (to)->attr = 0; \
        } \
        if (igraph_i_ret2 != 0) { \
            IGRAPH_ERROR("", igraph_i_ret2); \
        } \
    } while(0)

int igraph_i_attribute_init(igraph_t *graph, void *attr);
void igraph_i_attribute_destroy(igraph_t *graph);
int igraph_i_attribute_copy(igraph_t *to, const igraph_t *from,
                            igraph_bool_t ga, igraph_bool_t va, igraph_bool_t ea);
int igraph_i_attribute_add_vertices(igraph_t *graph, long int nv, void *attr);
int igraph_i_attribute_permute_vertices(const igraph_t *graph,
                                        igraph_t *newgraph,
                                        const igraph_vector_t *idx);
int igraph_i_attribute_combine_vertices(const igraph_t *graph,
                                        igraph_t *newgraph,
                                        const igraph_vector_ptr_t *merges,
                                        const igraph_attribute_combination_t *comb);
int igraph_i_attribute_add_edges(igraph_t *graph,
                                 const igraph_vector_t *edges, void *attr);
int igraph_i_attribute_permute_edges(const igraph_t *graph,
                                     igraph_t *newgraph,
                                     const igraph_vector_t *idx);
int igraph_i_attribute_combine_edges(const igraph_t *graph,
                                     igraph_t *newgraph,
                                     const igraph_vector_ptr_t *merges,
                                     const igraph_attribute_combination_t *comb);

int igraph_i_attribute_get_info(const igraph_t *graph,
                                igraph_strvector_t *gnames,
                                igraph_vector_t *gtypes,
                                igraph_strvector_t *vnames,
                                igraph_vector_t *vtypes,
                                igraph_strvector_t *enames,
                                igraph_vector_t *etypes);
igraph_bool_t igraph_i_attribute_has_attr(const igraph_t *graph,
                                          igraph_attribute_elemtype_t type,
                                          const char *name);
int igraph_i_attribute_gettype(const igraph_t *graph,
                               igraph_attribute_type_t *type,
                               igraph_attribute_elemtype_t elemtype,
                               const char *name);

int igraph_i_attribute_get_numeric_graph_attr(const igraph_t *graph,
                                              const char *name,
                                              igraph_vector_t *value);
int igraph_i_attribute_get_numeric_vertex_attr(const igraph_t *graph,
                                               const char *name,
                                               igraph_vs_t vs,
                                               igraph_vector_t *value);
int igraph_i_attribute_get_numeric_edge_attr(const igraph_t *graph,
                                             const char *name,
                                             igraph_es_t es,
                                             igraph_vector_t *value);
int igraph_i_attribute_get_string_graph_attr(const igraph_t *graph,
                                             const char *name,
                                             igraph_strvector_t *value);
int igraph_i_attribute_get_string_vertex_attr(const igraph_t *graph,
                                              const char *name,
                                              igraph_vs_t vs,
                                              igraph_strvector_t *value);
int igraph_i_attribute_get_string_edge_attr(const igraph_t *graph,
                                            const char *name,
                                            igraph_es_t es,
                                            igraph_strvector_t *value);
int igraph_i_attribute_get_bool_graph_attr(const igraph_t *graph,
                                           const char *name,
                                           igraph_vector_bool_t *value);
int igraph_i_attribute_get_bool_vertex_attr(const igraph_t *graph,
                                            const char *name,
                                            igraph_vs_t vs,
                                            igraph_vector_bool_t *value);
int igraph_i_attribute_get_bool_edge_attr(const igraph_t *graph,
                                          const char *name,
                                          igraph_es_t es,
                                          igraph_vector_bool_t *value);

#endif /* IGRAPH_GRAPH_ATTRIBUTES_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/basic_query.c0000644000175100001710000000407000000000000024215 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_datatype.h"
#include "igraph_types.h"
#include "igraph_interface.h"
#include "igraph_structural.h"

/**
 * \ingroup structural
 * \function igraph_are_connected
 * \brief Decides whether two vertices are connected
 *
 * \param graph The graph object.
 * \param v1 The first vertex.
 * \param v2 The second vertex.
 * \param res Boolean, \c TRUE if there is an edge from
 *         \p v1 to \p v2, \c FALSE otherwise.
 * \return The error code \c IGRAPH_EINVVID is returned if an invalid
 *         vertex ID is given.
 *
 * The function is of course symmetric for undirected graphs.
 *
 * 
 * Time complexity: O( min(log(d1), log(d2)) ),
 * d1 is the (out-)degree of \p v1 and d2 is the (in-)degree of \p v2.
 */
int igraph_are_connected(const igraph_t *graph,
                         igraph_integer_t v1, igraph_integer_t v2,
                         igraph_bool_t *res) {

    long int nov = igraph_vcount(graph);
    igraph_integer_t eid = -1;

    if (v1 < 0 || v2 < 0 || v1 > nov - 1 || v2 > nov - 1) {
        IGRAPH_ERROR("are connected", IGRAPH_EINVVID);
    }

    igraph_get_eid(graph, &eid, v1, v2, /*directed=*/1, /*error=*/ 0);
    *res = (eid >= 0);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/cattributes.c0000644000175100001710000045065100000000000024252 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_attributes.h"
#include "igraph_memory.h"
#include "core/math.h"
#include "igraph_interface.h"
#include "igraph_random.h"

#include 

/* An attribute is either a numeric vector (vector_t) or a string
   vector (strvector_t). The attribute itself is stored in a
   struct igraph_attribute_record_t, there is one such object for each
   attribute. The igraph_t has a pointer to an array of three
   vector_ptr_t's which contains pointers to
   igraph_i_cattribute_t's. Graph attributes are first, then vertex
   and edge attributes. */

static igraph_bool_t igraph_i_cattribute_find(const igraph_vector_ptr_t *ptrvec,
                                              const char *name, long int *idx) {
    long int i, n = igraph_vector_ptr_size(ptrvec);
    igraph_bool_t l = 0;
    for (i = 0; !l && i < n; i++) {
        igraph_attribute_record_t *rec = VECTOR(*ptrvec)[i];
        l = !strcmp(rec->name, name);
    }
    if (idx) {
        *idx = i - 1;
    }
    return l;
}

typedef struct igraph_i_cattributes_t {
    igraph_vector_ptr_t gal;
    igraph_vector_ptr_t val;
    igraph_vector_ptr_t eal;
} igraph_i_cattributes_t;

static int igraph_i_cattributes_copy_attribute_record(igraph_attribute_record_t **newrec,
                                                      const igraph_attribute_record_t *rec) {
    igraph_vector_t *num, *newnum;
    igraph_strvector_t *str, *newstr;

    *newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
    if (!(*newrec)) {
        IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, *newrec);
    (*newrec)->type = rec->type;
    (*newrec)->name = strdup(rec->name);
    if (!(*newrec)->name) {
        IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (void*)(*newrec)->name);
    if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
        num = (igraph_vector_t *)rec->value;
        newnum = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!newnum) {
            IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, newnum);
        IGRAPH_CHECK(igraph_vector_copy(newnum, num));
        IGRAPH_FINALLY(igraph_vector_destroy, newnum);
        (*newrec)->value = newnum;
    } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
        str = (igraph_strvector_t*)rec->value;
        newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!newstr) {
            IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, newstr);
        IGRAPH_CHECK(igraph_strvector_copy(newstr, str));
        IGRAPH_FINALLY(igraph_strvector_destroy, newstr);
        (*newrec)->value = newstr;
    } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
        igraph_vector_bool_t *log = (igraph_vector_bool_t*) rec->value;
        igraph_vector_bool_t *newlog = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!newlog) {
            IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, newlog);
        IGRAPH_CHECK(igraph_vector_bool_copy(newlog, log));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, newlog);
        (*newrec)->value = newlog;
    }

    IGRAPH_FINALLY_CLEAN(4);
    return 0;
}


static int igraph_i_cattribute_init(igraph_t *graph, igraph_vector_ptr_t *attr) {
    igraph_attribute_record_t *attr_rec;
    long int i, n;
    igraph_i_cattributes_t *nattr;

    n = attr ? igraph_vector_ptr_size(attr) : 0;

    nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t);
    if (!nattr) {
        IGRAPH_ERROR("Can't init attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, nattr);

    IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->gal, n));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &nattr->gal);
    IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->val, 0));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &nattr->val);
    IGRAPH_CHECK(igraph_vector_ptr_init(&nattr->eal, 0));
    IGRAPH_FINALLY_CLEAN(3);

    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_i_cattributes_copy_attribute_record(
                         &attr_rec, VECTOR(*attr)[i]));
        VECTOR(nattr->gal)[i] = attr_rec;
    }

    graph->attr = nattr;

    return 0;
}

static void igraph_i_cattribute_destroy(igraph_t *graph) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *als[3] = { &attr->gal, &attr->val, &attr->eal };
    long int i, n, a;
    igraph_vector_t *num;
    igraph_strvector_t *str;
    igraph_vector_bool_t *boolvec;
    igraph_attribute_record_t *rec;
    for (a = 0; a < 3; a++) {
        n = igraph_vector_ptr_size(als[a]);
        for (i = 0; i < n; i++) {
            rec = VECTOR(*als[a])[i];
            if (rec) {
                if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
                    num = (igraph_vector_t*)rec->value;
                    igraph_vector_destroy(num);
                    igraph_free(num);
                } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
                    str = (igraph_strvector_t*)rec->value;
                    igraph_strvector_destroy(str);
                    igraph_free(str);
                } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                    boolvec = (igraph_vector_bool_t*)rec->value;
                    igraph_vector_bool_destroy(boolvec);
                    igraph_free(boolvec);
                }
                igraph_free((char*)rec->name);
                igraph_free(rec);
            }
        }
    }
    igraph_vector_ptr_destroy(&attr->gal);
    igraph_vector_ptr_destroy(&attr->val);
    igraph_vector_ptr_destroy(&attr->eal);
    igraph_free(graph->attr);
    graph->attr = 0;
}

/* Almost the same as destroy, but we might have null pointers */

static void igraph_i_cattribute_copy_free(igraph_i_cattributes_t *attr) {
    igraph_vector_ptr_t *als[3] = { &attr->gal, &attr->val, &attr->eal };
    long int i, n, a;
    igraph_vector_t *num;
    igraph_strvector_t *str;
    igraph_vector_bool_t *boolvec;
    igraph_attribute_record_t *rec;
    for (a = 0; a < 3; a++) {
        n = igraph_vector_ptr_size(als[a]);
        for (i = 0; i < n; i++) {
            rec = VECTOR(*als[a])[i];
            if (!rec) {
                continue;
            }
            if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
                num = (igraph_vector_t*)rec->value;
                igraph_vector_destroy(num);
                igraph_free(num);
            } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                boolvec = (igraph_vector_bool_t*)rec->value;
                igraph_vector_bool_destroy(boolvec);
                igraph_free(boolvec);
            } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
                str = (igraph_strvector_t*)rec->value;
                igraph_strvector_destroy(str);
                igraph_free(str);
            }
            igraph_free((char*)rec->name);
            igraph_free(rec);
        }
    }
}

/* No reference counting here. If you use attributes in C you should
   know what you're doing. */

static int igraph_i_cattribute_copy(igraph_t *to, const igraph_t *from,
                             igraph_bool_t ga, igraph_bool_t va, igraph_bool_t ea) {
    igraph_i_cattributes_t *attrfrom = from->attr, *attrto;
    igraph_vector_ptr_t *alto[3], *alfrom[3] = { &attrfrom->gal, &attrfrom->val,
                                                 &attrfrom->eal
                                               };
    long int i, n, a;
    igraph_bool_t copy[3] = { ga, va, ea };
    to->attr = attrto = IGRAPH_CALLOC(1, igraph_i_cattributes_t);
    if (!attrto) {
        IGRAPH_ERROR("Cannot copy attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, attrto);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&attrto->gal, 0);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&attrto->val, 0);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&attrto->eal, 0);
    IGRAPH_FINALLY_CLEAN(3);
    IGRAPH_FINALLY(igraph_i_cattribute_copy_free, attrto);

    alto[0] = &attrto->gal; alto[1] = &attrto->val; alto[2] = &attrto->eal;
    for (a = 0; a < 3; a++) {
        if (copy[a]) {
            n = igraph_vector_ptr_size(alfrom[a]);
            IGRAPH_CHECK(igraph_vector_ptr_resize(alto[a], n));
            igraph_vector_ptr_null(alto[a]);
            for (i = 0; i < n; i++) {
                igraph_attribute_record_t *newrec;
                IGRAPH_CHECK(igraph_i_cattributes_copy_attribute_record(&newrec,
                             VECTOR(*alfrom[a])[i]));
                VECTOR(*alto[a])[i] = newrec;
            }
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

static int igraph_i_cattribute_add_vertices(igraph_t *graph, long int nv,
                                            igraph_vector_ptr_t *nattr) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int length = igraph_vector_ptr_size(val);
    long int nattrno = nattr == NULL ? 0 : igraph_vector_ptr_size(nattr);
    long int origlen = igraph_vcount(graph) - nv;
    long int newattrs = 0, i;
    igraph_vector_t news;

    /* First add the new attributes if any */
    newattrs = 0;
    IGRAPH_VECTOR_INIT_FINALLY(&news, 0);
    for (i = 0; i < nattrno; i++) {
        igraph_attribute_record_t *nattr_entry = VECTOR(*nattr)[i];
        const char *nname = nattr_entry->name;
        long int j;
        igraph_bool_t l = igraph_i_cattribute_find(val, nname, &j);
        if (!l) {
            newattrs++;
            IGRAPH_CHECK(igraph_vector_push_back(&news, i));
        } else {
            /* check types */
            if (nattr_entry->type !=
                ((igraph_attribute_record_t*)VECTOR(*val)[j])->type) {
                IGRAPH_ERROR("You cannot mix attribute types", IGRAPH_EINVAL);
            }
        }
    }

    /* Add NA/empty string vectors for the existing vertices */
    if (newattrs != 0) {
        for (i = 0; i < newattrs; i++) {
            igraph_attribute_record_t *tmp = VECTOR(*nattr)[(long int)VECTOR(news)[i]];
            igraph_attribute_record_t *newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
            igraph_attribute_type_t type = tmp->type;
            if (!newrec) {
                IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, newrec);
            newrec->type = type;
            newrec->name = strdup(tmp->name);
            if (!newrec->name) {
                IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, (char*)newrec->name);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_vector_t *newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newnum);
                IGRAPH_VECTOR_INIT_FINALLY(newnum, origlen);
                newrec->value = newnum;
                igraph_vector_fill(newnum, IGRAPH_NAN);
            } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                igraph_strvector_t *newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newstr);
                IGRAPH_STRVECTOR_INIT_FINALLY(newstr, origlen);
                newrec->value = newstr;
            } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                igraph_vector_bool_t *newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newbool);
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, origlen));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                newrec->value = newbool;
                igraph_vector_bool_fill(newbool, 0);
            }
            IGRAPH_CHECK(igraph_vector_ptr_push_back(val, newrec));
            IGRAPH_FINALLY_CLEAN(4);
        }
        length = igraph_vector_ptr_size(val);
    }

    /* Now append the new values */
    for (i = 0; i < length; i++) {
        igraph_attribute_record_t *oldrec = VECTOR(*val)[i];
        igraph_attribute_record_t *newrec = 0;
        const char *name = oldrec->name;
        long int j = -1;
        igraph_bool_t l = 0;
        if (nattr) {
            l = igraph_i_cattribute_find(nattr, name, &j);
        }
        if (l) {
            /* This attribute is present in nattr */
            igraph_vector_t *oldnum, *newnum;
            igraph_strvector_t *oldstr, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;
            newrec = VECTOR(*nattr)[j];
            oldnum = (igraph_vector_t*)oldrec->value;
            newnum = (igraph_vector_t*)newrec->value;
            oldstr = (igraph_strvector_t*)oldrec->value;
            newstr = (igraph_strvector_t*)newrec->value;
            oldbool = (igraph_vector_bool_t*)oldrec->value;
            newbool = (igraph_vector_bool_t*)newrec->value;
            if (oldrec->type != newrec->type) {
                IGRAPH_ERROR("Attribute types do not match", IGRAPH_EINVAL);
            }
            switch (oldrec->type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                if (nv != igraph_vector_size(newnum)) {
                    IGRAPH_ERROR("Invalid numeric attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_vector_append(oldnum, newnum));
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                if (nv != igraph_strvector_size(newstr)) {
                    IGRAPH_ERROR("Invalid string attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_strvector_append(oldstr, newstr));
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                if (nv != igraph_vector_bool_size(newbool)) {
                    IGRAPH_ERROR("Invalid Boolean attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_vector_bool_append(oldbool, newbool));
                break;
            default:
                IGRAPH_WARNING("Invalid attribute type");
                break;
            }
        } else {
            /* No such attribute, append NA's */
            igraph_vector_t *oldnum = (igraph_vector_t *)oldrec->value;
            igraph_strvector_t *oldstr = (igraph_strvector_t*)oldrec->value;
            igraph_vector_bool_t *oldbool = (igraph_vector_bool_t*)oldrec->value;
            switch (oldrec->type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                IGRAPH_CHECK(igraph_vector_resize(oldnum, origlen + nv));
                for (j = origlen; j < origlen + nv; j++) {
                    VECTOR(*oldnum)[j] = IGRAPH_NAN;
                }
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                IGRAPH_CHECK(igraph_strvector_resize(oldstr, origlen + nv));
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                IGRAPH_CHECK(igraph_vector_bool_resize(oldbool, origlen + nv));
                for (j = origlen; j < origlen + nv; j++) {
                    VECTOR(*oldbool)[j] = 0;
                }
                break;
            default:
                IGRAPH_WARNING("Invalid attribute type");
                break;
            }
        }
    }

    igraph_vector_destroy(&news);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static void igraph_i_cattribute_permute_free(igraph_vector_ptr_t *v) {
    long int i, n = igraph_vector_ptr_size(v);
    for (i = 0; i < n; i++) {
        igraph_attribute_record_t *rec = VECTOR(*v)[i];
        IGRAPH_FREE(rec->name);
        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *numv = (igraph_vector_t*) rec->value;
            igraph_vector_destroy(numv);
            IGRAPH_FREE(numv);
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strv = (igraph_strvector_t*) rec->value;
            igraph_strvector_destroy(strv);
            IGRAPH_FREE(strv);
        } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            igraph_vector_bool_t *boolv = (igraph_vector_bool_t*) rec->value;
            igraph_vector_bool_destroy(boolv);
            IGRAPH_FREE(boolv);
        }
        IGRAPH_FREE(rec);
    }
    igraph_vector_ptr_clear(v);
}

static int igraph_i_cattribute_permute_vertices(const igraph_t *graph,
        igraph_t *newgraph,
        const igraph_vector_t *idx) {

    if (graph == newgraph) {

        igraph_i_cattributes_t *attr = graph->attr;
        igraph_vector_ptr_t *val = &attr->val;
        long int valno = igraph_vector_ptr_size(val);
        long int i;

        for (i = 0; i < valno; i++) {
            igraph_attribute_record_t *oldrec = VECTOR(*val)[i];
            igraph_attribute_type_t type = oldrec->type;
            igraph_vector_t *num, *newnum;
            igraph_strvector_t *str, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;
            switch (type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                num = (igraph_vector_t*) oldrec->value;
                newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_VECTOR_INIT_FINALLY(newnum, 0);
                igraph_vector_index(num, newnum, idx);
                oldrec->value = newnum;
                igraph_vector_destroy(num);
                IGRAPH_FREE(num);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                oldbool = (igraph_vector_bool_t*) oldrec->value;
                newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, 0));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                igraph_vector_bool_index(oldbool, newbool, idx);
                oldrec->value = newbool;
                igraph_vector_bool_destroy(oldbool);
                IGRAPH_FREE(oldbool);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                str = (igraph_strvector_t*)oldrec->value;
                newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_strvector_init(newstr, 0));
                IGRAPH_FINALLY(igraph_strvector_destroy, newstr);
                igraph_strvector_index(str, newstr, idx);
                oldrec->value = newstr;
                igraph_strvector_destroy(str);
                IGRAPH_FREE(str);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            default:
                IGRAPH_WARNING("Unknown edge attribute ignored");
            }
        }

    } else {
        igraph_i_cattributes_t *attr = graph->attr;
        igraph_vector_ptr_t *val = &attr->val;
        long int valno = igraph_vector_ptr_size(val);
        long int i;

        /* New vertex attributes */
        igraph_i_cattributes_t *new_attr = newgraph->attr;
        igraph_vector_ptr_t *new_val = &new_attr->val;
        if (igraph_vector_ptr_size(new_val) != 0) {
            IGRAPH_ERROR("Vertex attributes were already copied",
                         IGRAPH_EATTRIBUTES);
        }
        IGRAPH_CHECK(igraph_vector_ptr_resize(new_val, valno));

        IGRAPH_FINALLY(igraph_i_cattribute_permute_free, new_val);

        for (i = 0; i < valno; i++) {
            igraph_attribute_record_t *oldrec = VECTOR(*val)[i];
            igraph_attribute_type_t type = oldrec->type;
            igraph_vector_t *num, *newnum;
            igraph_strvector_t *str, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;

            /* The record itself */
            igraph_attribute_record_t *new_rec =
                IGRAPH_CALLOC(1, igraph_attribute_record_t);
            if (!new_rec) {
                IGRAPH_ERROR("Cannot create vertex attributes", IGRAPH_ENOMEM);
            }
            new_rec->name = strdup(oldrec->name);
            new_rec->type = oldrec->type;
            VECTOR(*new_val)[i] = new_rec;

            /* The data */
            switch (type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                num = (igraph_vector_t*)oldrec->value;
                newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_VECTOR_INIT_FINALLY(newnum, 0);
                igraph_vector_index(num, newnum, idx);
                new_rec->value = newnum;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                oldbool = (igraph_vector_bool_t*)oldrec->value;
                newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, 0));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                igraph_vector_bool_index(oldbool, newbool, idx);
                new_rec->value = newbool;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                str = (igraph_strvector_t*)oldrec->value;
                newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot permute vertex attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_strvector_init(newstr, 0));
                IGRAPH_FINALLY(igraph_strvector_destroy, newstr);
                igraph_strvector_index(str, newstr, idx);
                new_rec->value = newstr;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            default:
                IGRAPH_WARNING("Unknown vertex attribute ignored");
            }
        }
    }

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

typedef int igraph_cattributes_combine_num_t(const igraph_vector_t *input,
        igraph_real_t *output);

typedef int igraph_cattributes_combine_str_t(const igraph_strvector_t *input,
        char **output);

typedef int igraph_cattributes_combine_bool_t(const igraph_vector_bool_t *input,
        igraph_bool_t *output);

static int igraph_i_cattributes_cn_sum(const igraph_attribute_record_t *oldrec,
                                       igraph_attribute_record_t * newrec,
                                       const igraph_vector_ptr_t *merges) {
    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_real_t s = 0.0;
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            s += VECTOR(*oldv)[x];
        }
        VECTOR(*newv)[i] = s;
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_prod(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t * newrec,
                                        const igraph_vector_ptr_t *merges) {
    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_real_t s = 1.0;
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            s *= VECTOR(*oldv)[x];
        }
        VECTOR(*newv)[i] = s;
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_min(const igraph_attribute_record_t *oldrec,
                                       igraph_attribute_record_t * newrec,
                                       const igraph_vector_ptr_t *merges) {
    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        igraph_real_t m = n > 0 ? VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ] : nan;
        for (j = 1; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            igraph_real_t val = VECTOR(*oldv)[x];
            if (val < m) {
                m = val;
            }
        }
        VECTOR(*newv)[i] = m;
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_max(const igraph_attribute_record_t *oldrec,
                                       igraph_attribute_record_t * newrec,
                                       const igraph_vector_ptr_t *merges) {
    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        igraph_real_t m = n > 0 ? VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ] : nan;
        for (j = 1; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            igraph_real_t val = VECTOR(*oldv)[x];
            if (val > m) {
                m = val;
            }
        }
        VECTOR(*newv)[i] = m;
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_random(const igraph_attribute_record_t *oldrec,
                                          igraph_attribute_record_t * newrec,
                                          const igraph_vector_ptr_t *merges) {

    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    RNG_BEGIN();

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = nan;
        } else if (n == 1) {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ];
        } else {
            long int r = RNG_INTEGER(0, n - 1);
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[r] ];
        }
    }

    RNG_END();

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_first(const igraph_attribute_record_t *oldrec,
                                         igraph_attribute_record_t * newrec,
                                         const igraph_vector_ptr_t *merges) {

    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = nan;
        } else {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ];
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_last(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t * newrec,
                                        const igraph_vector_ptr_t *merges) {

    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = nan;
        } else {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[n - 1] ];
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_mean(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t * newrec,
                                        const igraph_vector_ptr_t *merges) {
    const igraph_vector_t *oldv = oldrec->value;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_real_t nan = IGRAPH_NAN;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        igraph_real_t s = n > 0 ? 0.0 : nan;
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            s += VECTOR(*oldv)[x];
        }
        if (n > 0) {
            s = s / n;
        }
        VECTOR(*newv)[i] = s;
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cn_func(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t *newrec,
                                        const igraph_vector_ptr_t *merges,
                                        igraph_cattributes_combine_num_t *func) {

    const igraph_vector_t *oldv = oldrec->value;
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_vector_t *newv = IGRAPH_CALLOC(1, igraph_vector_t);
    igraph_vector_t values;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_VECTOR_INIT_FINALLY(newv, newlen);

    IGRAPH_VECTOR_INIT_FINALLY(&values, 0);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        igraph_real_t res;
        IGRAPH_CHECK(igraph_vector_resize(&values, n));
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            VECTOR(values)[j] = VECTOR(*oldv)[x];
        }
        IGRAPH_CHECK(func(&values, &res));
        VECTOR(*newv)[i] = res;
    }

    igraph_vector_destroy(&values);
    IGRAPH_FINALLY_CLEAN(3);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_random(const igraph_attribute_record_t *oldrec,
                                          igraph_attribute_record_t * newrec,
                                          const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    RNG_BEGIN();

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = 0;
        } else if (n == 1) {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ];
        } else {
            long int r = RNG_INTEGER(0, n - 1);
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[r] ];
        }
    }

    RNG_END();

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_first(const igraph_attribute_record_t *oldrec,
                                         igraph_attribute_record_t * newrec,
                                         const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = 0;
        } else {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[0] ];
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_last(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t * newrec,
                                        const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            VECTOR(*newv)[i] = 0;
        } else {
            VECTOR(*newv)[i] = VECTOR(*oldv)[ (long int) VECTOR(*idx)[n - 1] ];
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_all_is_true(const igraph_attribute_record_t *oldrec,
                                               igraph_attribute_record_t * newrec,
                                               const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i, j, n, x;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        n = igraph_vector_size(idx);
        VECTOR(*newv)[i] = 1;
        for (j = 0; j < n; j++) {
            x = (long int) VECTOR(*idx)[j];
            if (!VECTOR(*oldv)[x]) {
                VECTOR(*newv)[i] = 0;
                break;
            }
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_any_is_true(const igraph_attribute_record_t *oldrec,
                                               igraph_attribute_record_t * newrec,
                                               const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i, j, n, x;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        n = igraph_vector_size(idx);
        VECTOR(*newv)[i] = 0;
        for (j = 0; j < n; j++) {
            x = (long int) VECTOR(*idx)[j];
            if (VECTOR(*oldv)[x]) {
                VECTOR(*newv)[i] = 1;
                break;
            }
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_majority(const igraph_attribute_record_t *oldrec,
                                            igraph_attribute_record_t * newrec,
                                            const igraph_vector_ptr_t *merges) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    long int newlen = igraph_vector_ptr_size(merges);
    long int i, j, n, x, num_trues;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    RNG_BEGIN();

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];

        n = igraph_vector_size(idx);

        num_trues = 0;
        for (j = 0; j < n; j++) {
            x = (long int) VECTOR(*idx)[j];
            if (VECTOR(*oldv)[x]) {
                num_trues++;
            }
        }

        if (n % 2 != 0) {
            VECTOR(*newv)[i] = (num_trues > n / 2);
        } else {
            if (num_trues == n / 2) {
                VECTOR(*newv)[i] = (RNG_UNIF01() < 0.5);
            } else {
                VECTOR(*newv)[i] = (num_trues > n / 2);
            }
        }
    }

    RNG_END();

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_cb_func(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t *newrec,
                                        const igraph_vector_ptr_t *merges,
                                        igraph_cattributes_combine_bool_t *func) {

    const igraph_vector_bool_t *oldv = oldrec->value;
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_vector_bool_t *newv = IGRAPH_CALLOC(1, igraph_vector_bool_t);
    igraph_vector_bool_t values;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_vector_bool_init(newv, newlen));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    IGRAPH_CHECK(igraph_vector_bool_init(&values, 0));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        igraph_bool_t res;

        IGRAPH_CHECK(igraph_vector_bool_resize(&values, n));
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            VECTOR(values)[j] = VECTOR(*oldv)[x];
        }

        IGRAPH_CHECK(func(&values, &res));
        VECTOR(*newv)[i] = res;
    }

    igraph_vector_bool_destroy(&values);
    IGRAPH_FINALLY_CLEAN(3);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_sn_random(const igraph_attribute_record_t *oldrec,
                                          igraph_attribute_record_t *newrec,
                                          const igraph_vector_ptr_t *merges) {

    const igraph_strvector_t *oldv = oldrec->value;
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_strvector_t *newv = IGRAPH_CALLOC(1, igraph_strvector_t);

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_strvector_init(newv, newlen));
    IGRAPH_FINALLY(igraph_strvector_destroy, newv);

    RNG_BEGIN();

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        char *tmp;
        if (n == 0) {
            IGRAPH_CHECK(igraph_strvector_set(newv, i, ""));
        } else if (n == 1) {
            igraph_strvector_get(oldv, 0, &tmp);
            IGRAPH_CHECK(igraph_strvector_set(newv, i, tmp));
        } else {
            long int r = RNG_INTEGER(0, n - 1);
            igraph_strvector_get(oldv, r, &tmp);
            IGRAPH_CHECK(igraph_strvector_set(newv, i, tmp));
        }
    }

    RNG_END();

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_sn_first(const igraph_attribute_record_t *oldrec,
                                         igraph_attribute_record_t *newrec,
                                         const igraph_vector_ptr_t *merges) {

    const igraph_strvector_t *oldv = oldrec->value;
    long int i, newlen = igraph_vector_ptr_size(merges);
    igraph_strvector_t *newv = IGRAPH_CALLOC(1, igraph_strvector_t);

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_strvector_init(newv, newlen));
    IGRAPH_FINALLY(igraph_strvector_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            IGRAPH_CHECK(igraph_strvector_set(newv, i, ""));
        } else {
            char *tmp;
            igraph_strvector_get(oldv, (long int) VECTOR(*idx)[0], &tmp);
            IGRAPH_CHECK(igraph_strvector_set(newv, i, tmp));
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_sn_last(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t *newrec,
                                        const igraph_vector_ptr_t *merges) {

    const igraph_strvector_t *oldv = oldrec->value;
    long int i, newlen = igraph_vector_ptr_size(merges);
    igraph_strvector_t *newv = IGRAPH_CALLOC(1, igraph_strvector_t);

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_strvector_init(newv, newlen));
    IGRAPH_FINALLY(igraph_strvector_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int n = igraph_vector_size(idx);
        if (n == 0) {
            IGRAPH_CHECK(igraph_strvector_set(newv, i, ""));
        } else {
            char *tmp;
            igraph_strvector_get(oldv, (long int) VECTOR(*idx)[n - 1], &tmp);
            IGRAPH_CHECK(igraph_strvector_set(newv, i, tmp));
        }
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_sn_concat(const igraph_attribute_record_t *oldrec,
                                          igraph_attribute_record_t *newrec,
                                          const igraph_vector_ptr_t *merges) {

    const igraph_strvector_t *oldv = oldrec->value;
    long int i, newlen = igraph_vector_ptr_size(merges);
    igraph_strvector_t *newv = IGRAPH_CALLOC(1, igraph_strvector_t);

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_strvector_init(newv, newlen));
    IGRAPH_FINALLY(igraph_strvector_destroy, newv);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        size_t len = 0;
        char *tmp, *tmp2;
        for (j = 0; j < n; j++) {
            igraph_strvector_get(oldv, j, &tmp);
            len += strlen(tmp);
        }
        tmp2 = IGRAPH_CALLOC(len + 1, char);
        if (!tmp2) {
            IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, tmp2);
        len = 0;
        for (j = 0; j < n; j++) {
            igraph_strvector_get(oldv, j, &tmp);
            strcpy(tmp2 + len, tmp);
            len += strlen(tmp);
        }

        IGRAPH_CHECK(igraph_strvector_set(newv, i, tmp2));
        IGRAPH_FREE(tmp2);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_FINALLY_CLEAN(2);
    newrec->value = newv;

    return 0;
}

static int igraph_i_cattributes_sn_func(const igraph_attribute_record_t *oldrec,
                                        igraph_attribute_record_t *newrec,
                                        const igraph_vector_ptr_t *merges,
                                        igraph_cattributes_combine_str_t *func) {

    const igraph_strvector_t *oldv = oldrec->value;
    long int newlen = igraph_vector_ptr_size(merges);
    long int i;
    igraph_strvector_t *newv = IGRAPH_CALLOC(1, igraph_strvector_t);
    igraph_strvector_t values;

    if (!newv) {
        IGRAPH_ERROR("Cannot combine attributes", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newv);
    IGRAPH_CHECK(igraph_strvector_init(newv, newlen));
    IGRAPH_FINALLY(igraph_strvector_destroy, newv);

    IGRAPH_CHECK(igraph_strvector_init(newv, 0));
    IGRAPH_FINALLY(igraph_strvector_destroy, &values);

    for (i = 0; i < newlen; i++) {
        igraph_vector_t *idx = VECTOR(*merges)[i];
        long int j, n = igraph_vector_size(idx);
        char *res;
        IGRAPH_CHECK(igraph_strvector_resize(&values, n));
        for (j = 0; j < n; j++) {
            long int x = (long int) VECTOR(*idx)[j];
            char *elem;
            igraph_strvector_get(oldv, x, &elem);
            IGRAPH_CHECK(igraph_strvector_set(newv, j, elem));
        }
        IGRAPH_CHECK(func(&values, &res));
        IGRAPH_FINALLY(igraph_free, res);
        IGRAPH_CHECK(igraph_strvector_set(newv, i, res));
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_FREE(res);
    }

    igraph_strvector_destroy(&values);
    IGRAPH_FINALLY_CLEAN(3);
    newrec->value = newv;

    return 0;
}


static int igraph_i_cattribute_combine_vertices(const igraph_t *graph,
                                                igraph_t *newgraph,
                                                const igraph_vector_ptr_t *merges,
                                                const igraph_attribute_combination_t *comb) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_i_cattributes_t *toattr = newgraph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    igraph_vector_ptr_t *new_val = &toattr->val;
    long int valno = igraph_vector_ptr_size(val);
    long int i, j, keepno = 0;
    int *TODO;
    igraph_function_pointer_t *funcs;

    TODO = IGRAPH_CALLOC(valno, int);
    if (!TODO) {
        IGRAPH_ERROR("Cannot combine vertex attributes",
                     IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, TODO);
    funcs = IGRAPH_CALLOC(valno, igraph_function_pointer_t);
    if (!funcs) {
        IGRAPH_ERROR("Cannot combine vertex attributes",
                     IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, funcs);

    for (i = 0; i < valno; i++) {
        igraph_attribute_record_t *oldrec = VECTOR(*val)[i];
        const char *name = oldrec->name;
        igraph_attribute_combination_type_t todo;
        igraph_function_pointer_t voidfunc;
        igraph_attribute_combination_query(comb, name, &todo, &voidfunc);
        TODO[i] = todo;
        funcs[i] = voidfunc;
        if (todo != IGRAPH_ATTRIBUTE_COMBINE_IGNORE) {
            keepno++;
        }
    }

    IGRAPH_CHECK(igraph_vector_ptr_resize(new_val, keepno));
    IGRAPH_FINALLY(igraph_i_cattribute_permute_free, new_val);

    for (i = 0, j = 0; i < valno; i++) {
        igraph_attribute_record_t *newrec, *oldrec = VECTOR(*val)[i];
        const char *name = oldrec->name;
        igraph_attribute_combination_type_t todo =
            (igraph_attribute_combination_type_t) (TODO[i]);
        igraph_attribute_type_t type = oldrec->type;
        igraph_cattributes_combine_num_t *numfunc =
            (igraph_cattributes_combine_num_t*) funcs[i];
        igraph_cattributes_combine_str_t *strfunc =
            (igraph_cattributes_combine_str_t*) funcs[i];
        igraph_cattributes_combine_bool_t *boolfunc =
            (igraph_cattributes_combine_bool_t*) funcs[i];

        if (todo == IGRAPH_ATTRIBUTE_COMBINE_DEFAULT ||
            todo == IGRAPH_ATTRIBUTE_COMBINE_IGNORE) {
            continue;
        }

        newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        if (!newrec) {
            IGRAPH_ERROR("Cannot combine vertex attributes",
                         IGRAPH_ENOMEM);
        }
        newrec->name = strdup(name);
        newrec->type = type;
        VECTOR(*new_val)[j] = newrec;

        if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_cn_func(oldrec, newrec, merges,
                             numfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
                IGRAPH_CHECK(igraph_i_cattributes_cn_sum(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
                IGRAPH_CHECK(igraph_i_cattributes_cn_prod(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_CHECK(igraph_i_cattributes_cn_min(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_CHECK(igraph_i_cattributes_cn_max(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_cn_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_cn_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_cn_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
                IGRAPH_CHECK(igraph_i_cattributes_cn_mean(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_ERROR("Median calculation not implemented",
                             IGRAPH_UNIMPLEMENTED);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_ERROR("Cannot concatenate numeric attributes",
                             IGRAPH_EATTRCOMBINE);
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_cb_func(oldrec, newrec, merges,
                             boolfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_CHECK(igraph_i_cattributes_cb_any_is_true(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_CHECK(igraph_i_cattributes_cb_all_is_true(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_CHECK(igraph_i_cattributes_cb_majority(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_cb_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_cb_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_cb_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_ERROR("Cannot calculate concatenation of Booleans",
                             IGRAPH_EATTRCOMBINE);
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else if (type == IGRAPH_ATTRIBUTE_STRING) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_sn_func(oldrec, newrec, merges,
                             strfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
                IGRAPH_ERROR("Cannot sum strings", IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
                IGRAPH_ERROR("Cannot multiply strings", IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_ERROR("Cannot find minimum of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_ERROR("Cannot find maximum of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
                IGRAPH_ERROR("Cannot calculate mean of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_ERROR("Cannot calculate median of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_sn_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_sn_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_sn_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_CHECK(igraph_i_cattributes_sn_concat(oldrec, newrec, merges));
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else {
            IGRAPH_ERROR("Unknown attribute type, this should not happen",
                         IGRAPH_UNIMPLEMENTED);
        }

        j++;
    }

    igraph_free(funcs);
    igraph_free(TODO);
    igraph_i_cattribute_permute_free(new_val);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/* void igraph_i_cattribute_delete_vertices(igraph_t *graph, */
/*                     const igraph_vector_t *eidx, */
/*                     const igraph_vector_t *vidx) { */

/*   igraph_i_cattributes_t *attr=graph->attr; */
/*   igraph_vector_ptr_t *val=&attr->val; */
/*   igraph_vector_ptr_t *eal=&attr->eal; */
/*   long int valno=igraph_vector_ptr_size(val); */
/*   long int ealno=igraph_vector_ptr_size(eal); */
/*   long int i; */
/*   long int origlen, newlen; */

/*   /\* Vertices *\/ */
/*   origlen=igraph_vector_size(vidx); */
/*   newlen=0; */
/*   for (i=0; i0) { */
/*       newlen++; */
/*     } */
/*   } */
/*   for (i=0; itype; */
/*     igraph_vector_t *num=(igraph_vector_t*)oldrec->value; */
/*     igraph_strvector_t *str=(igraph_strvector_t*)oldrec->value; */
/*     switch (type) { */
/*     case IGRAPH_ATTRIBUTE_NUMERIC: */
/*       igraph_vector_permdelete(num, vidx, origlen-newlen); */
/*       break; */
/*     case IGRAPH_ATTRIBUTE_STRING: */
/*       igraph_strvector_permdelete(str, vidx, origlen-newlen); */
/*       break; */
/*     default: */
/*       IGRAPH_WARNING("Unknown vertex attribute ignored"); */
/*     } */
/*   } */

/*   /\* Edges *\/ */
/*   origlen=igraph_vector_size(eidx); */
/*   newlen=0; */
/*   for (i=0; i0) { */
/*       newlen++; */
/*     } */
/*   } */
/*   for (i=0; itype; */
/*     igraph_vector_t *num=(igraph_vector_t*)oldrec->value; */
/*     igraph_strvector_t *str=(igraph_strvector_t*)oldrec->value; */
/*     switch (type) { */
/*     case IGRAPH_ATTRIBUTE_NUMERIC: */
/*       igraph_vector_permdelete(num, eidx, origlen-newlen); */
/*       break; */
/*     case IGRAPH_ATTRIBUTE_STRING: */
/*       igraph_strvector_permdelete(str, eidx, origlen-newlen); */
/*       break; */
/*     default: */
/*       IGRAPH_WARNING("Unknown edge attribute ignored"); */
/*     } */
/*   } */
/* } */

static int igraph_i_cattribute_add_edges(igraph_t *graph, const igraph_vector_t *edges,
                                         igraph_vector_ptr_t *nattr) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int ealno = igraph_vector_ptr_size(eal);
    long int ne = igraph_vector_size(edges) / 2;
    long int origlen = igraph_ecount(graph) - ne;
    long int nattrno = nattr == 0 ? 0 : igraph_vector_ptr_size(nattr);
    igraph_vector_t news;
    long int newattrs, i;

    /* First add the new attributes if any */
    newattrs = 0;
    IGRAPH_VECTOR_INIT_FINALLY(&news, 0);
    for (i = 0; i < nattrno; i++) {
        igraph_attribute_record_t *nattr_entry = VECTOR(*nattr)[i];
        const char *nname = nattr_entry->name;
        long int j;
        igraph_bool_t l = igraph_i_cattribute_find(eal, nname, &j);
        if (!l) {
            newattrs++;
            IGRAPH_CHECK(igraph_vector_push_back(&news, i));
        } else {
            /* check types */
            if (nattr_entry->type !=
                ((igraph_attribute_record_t*)VECTOR(*eal)[j])->type) {
                IGRAPH_ERROR("You cannot mix attribute types", IGRAPH_EINVAL);
            }
        }
    }

    /* Add NA/empty string vectors for the existing vertices */
    if (newattrs != 0) {
        for (i = 0; i < newattrs; i++) {
            igraph_attribute_record_t *tmp = VECTOR(*nattr)[(long int)VECTOR(news)[i]];
            igraph_attribute_record_t *newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
            igraph_attribute_type_t type = tmp->type;
            if (!newrec) {
                IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, newrec);
            newrec->type = type;
            newrec->name = strdup(tmp->name);
            if (!newrec->name) {
                IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, (char*)newrec->name);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_vector_t *newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newnum);
                IGRAPH_VECTOR_INIT_FINALLY(newnum, origlen);
                newrec->value = newnum;
                igraph_vector_fill(newnum, IGRAPH_NAN);
            } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                igraph_vector_bool_t *newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newbool);
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, origlen));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                newrec->value = newbool;
                igraph_vector_bool_fill(newbool, 0);
            } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                igraph_strvector_t *newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot add attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_FINALLY(igraph_free, newstr);
                IGRAPH_STRVECTOR_INIT_FINALLY(newstr, origlen);
                newrec->value = newstr;
            }
            IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, newrec));
            IGRAPH_FINALLY_CLEAN(4);
        }
        ealno = igraph_vector_ptr_size(eal);
    }

    /* Now append the new values */
    for (i = 0; i < ealno; i++) {
        igraph_attribute_record_t *oldrec = VECTOR(*eal)[i];
        igraph_attribute_record_t *newrec = 0;
        const char *name = oldrec->name;
        long int j = -1;
        igraph_bool_t l = 0;
        if (nattr) {
            l = igraph_i_cattribute_find(nattr, name, &j);
        }
        if (l) {
            /* This attribute is present in nattr */
            igraph_vector_t *oldnum, *newnum;
            igraph_strvector_t *oldstr, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;
            newrec = VECTOR(*nattr)[j];
            oldnum = (igraph_vector_t*)oldrec->value;
            newnum = (igraph_vector_t*)newrec->value;
            oldstr = (igraph_strvector_t*)oldrec->value;
            newstr = (igraph_strvector_t*)newrec->value;
            oldbool = (igraph_vector_bool_t*)oldrec->value;
            newbool = (igraph_vector_bool_t*)newrec->value;
            if (oldrec->type != newrec->type) {
                IGRAPH_ERROR("Attribute types do not match", IGRAPH_EINVAL);
            }
            switch (oldrec->type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                if (ne != igraph_vector_size(newnum)) {
                    IGRAPH_ERROR("Invalid numeric attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_vector_append(oldnum, newnum));
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                if (ne != igraph_strvector_size(newstr)) {
                    IGRAPH_ERROR("Invalid string attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_strvector_append(oldstr, newstr));
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                if (ne != igraph_vector_bool_size(newbool)) {
                    IGRAPH_ERROR("Invalid Boolean attribute length", IGRAPH_EINVAL);
                }
                IGRAPH_CHECK(igraph_vector_bool_append(oldbool, newbool));
                break;
            default:
                IGRAPH_WARNING("Invalid attribute type");
                break;
            }
        } else {
            /* No such attribute, append NA's */
            igraph_vector_t *oldnum = (igraph_vector_t *)oldrec->value;
            igraph_strvector_t *oldstr = (igraph_strvector_t*)oldrec->value;
            igraph_vector_bool_t *oldbool = (igraph_vector_bool_t *)oldrec->value;
            switch (oldrec->type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                IGRAPH_CHECK(igraph_vector_resize(oldnum, origlen + ne));
                for (j = origlen; j < origlen + ne; j++) {
                    VECTOR(*oldnum)[j] = IGRAPH_NAN;
                }
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                IGRAPH_CHECK(igraph_strvector_resize(oldstr, origlen + ne));
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                IGRAPH_CHECK(igraph_vector_bool_resize(oldbool, origlen + ne));
                for (j = origlen; j < origlen + ne; j++) {
                    VECTOR(*oldbool)[j] = 0;
                }
                break;
            default:
                IGRAPH_WARNING("Invalid attribute type");
                break;
            }
        }
    }

    igraph_vector_destroy(&news);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/* void igraph_i_cattribute_delete_edges(igraph_t *graph, const igraph_vector_t *idx) { */

/*   igraph_i_cattributes_t *attr=graph->attr; */
/*   igraph_vector_ptr_t *eal=&attr->eal; */
/*   long int ealno=igraph_vector_ptr_size(eal); */
/*   long int i; */
/*   long int origlen=igraph_vector_size(idx), newlen; */

/*   newlen=0; */
/*   for (i=0; i0) { */
/*       newlen++; */
/*     } */
/*   } */
/*   for (i=0; itype; */
/*     igraph_vector_t *num=(igraph_vector_t*)oldrec->value; */
/*     igraph_strvector_t *str=(igraph_strvector_t*)oldrec->value; */
/*     switch (type) { */
/*     case IGRAPH_ATTRIBUTE_NUMERIC: */
/*       igraph_vector_permdelete(num, idx, origlen-newlen); */
/*       break; */
/*     case IGRAPH_ATTRIBUTE_STRING: */
/*       igraph_strvector_permdelete(str, idx, origlen-newlen); */
/*       break; */
/*     default: */
/*       IGRAPH_WARNING("Unknown edge attribute ignored"); */
/*     } */
/*   } */

/* } */

static int igraph_i_cattribute_permute_edges(const igraph_t *graph,
                                             igraph_t *newgraph,
                                             const igraph_vector_t *idx) {

    if (graph == newgraph) {

        igraph_i_cattributes_t *attr = graph->attr;
        igraph_vector_ptr_t *eal = &attr->eal;
        long int ealno = igraph_vector_ptr_size(eal);
        long int i;

        for (i = 0; i < ealno; i++) {
            igraph_attribute_record_t *oldrec = VECTOR(*eal)[i];
            igraph_attribute_type_t type = oldrec->type;
            igraph_vector_t *num, *newnum;
            igraph_strvector_t *str, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;
            switch (type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                num = (igraph_vector_t*) oldrec->value;
                newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_VECTOR_INIT_FINALLY(newnum, 0);
                igraph_vector_index(num, newnum, idx);
                oldrec->value = newnum;
                igraph_vector_destroy(num);
                IGRAPH_FREE(num);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                oldbool = (igraph_vector_bool_t*) oldrec->value;
                newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, 0));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                igraph_vector_bool_index(oldbool, newbool, idx);
                oldrec->value = newbool;
                igraph_vector_bool_destroy(oldbool);
                IGRAPH_FREE(oldbool);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                str = (igraph_strvector_t*)oldrec->value;
                newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_strvector_init(newstr, 0));
                IGRAPH_FINALLY(igraph_strvector_destroy, newstr);
                igraph_strvector_index(str, newstr, idx);
                oldrec->value = newstr;
                igraph_strvector_destroy(str);
                IGRAPH_FREE(str);
                IGRAPH_FINALLY_CLEAN(1);
                break;
            default:
                IGRAPH_WARNING("Unknown edge attribute ignored");
            }
        }

    } else {

        igraph_i_cattributes_t *attr = graph->attr;
        igraph_vector_ptr_t *eal = &attr->eal;
        long int ealno = igraph_vector_ptr_size(eal);
        long int i;

        /* New edge attributes */
        igraph_i_cattributes_t *new_attr = newgraph->attr;
        igraph_vector_ptr_t *new_eal = &new_attr->eal;
        IGRAPH_CHECK(igraph_vector_ptr_resize(new_eal, ealno));

        IGRAPH_FINALLY(igraph_i_cattribute_permute_free, new_eal);

        for (i = 0; i < ealno; i++) {
            igraph_attribute_record_t *oldrec = VECTOR(*eal)[i];
            igraph_attribute_type_t type = oldrec->type;
            igraph_vector_t *num, *newnum;
            igraph_strvector_t *str, *newstr;
            igraph_vector_bool_t *oldbool, *newbool;

            /* The record itself */
            igraph_attribute_record_t *new_rec =
                IGRAPH_CALLOC(1, igraph_attribute_record_t);
            if (!new_rec) {
                IGRAPH_ERROR("Cannot create edge attributes", IGRAPH_ENOMEM);
            }
            new_rec->name = strdup(oldrec->name);
            new_rec->type = oldrec->type;
            VECTOR(*new_eal)[i] = new_rec;

            switch (type) {
            case IGRAPH_ATTRIBUTE_NUMERIC:
                num = (igraph_vector_t*) oldrec->value;
                newnum = IGRAPH_CALLOC(1, igraph_vector_t);
                if (!newnum) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_VECTOR_INIT_FINALLY(newnum, 0);
                igraph_vector_index(num, newnum, idx);
                new_rec->value = newnum;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_STRING:
                str = (igraph_strvector_t*)oldrec->value;
                newstr = IGRAPH_CALLOC(1, igraph_strvector_t);
                if (!newstr) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_strvector_init(newstr, 0));
                IGRAPH_FINALLY(igraph_strvector_destroy, newstr);
                igraph_strvector_index(str, newstr, idx);
                new_rec->value = newstr;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            case IGRAPH_ATTRIBUTE_BOOLEAN:
                oldbool = (igraph_vector_bool_t*) oldrec->value;
                newbool = IGRAPH_CALLOC(1, igraph_vector_bool_t);
                if (!newbool) {
                    IGRAPH_ERROR("Cannot permute edge attributes", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_vector_bool_init(newbool, 0));
                IGRAPH_FINALLY(igraph_vector_bool_destroy, newbool);
                igraph_vector_bool_index(oldbool, newbool, idx);
                new_rec->value = newbool;
                IGRAPH_FINALLY_CLEAN(1);
                break;
            default:
                IGRAPH_WARNING("Unknown edge attribute ignored");
            }
        }
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_combine_edges(const igraph_t *graph,
                                             igraph_t *newgraph,
                                             const igraph_vector_ptr_t *merges,
                                             const igraph_attribute_combination_t *comb) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_i_cattributes_t *toattr = newgraph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    igraph_vector_ptr_t *new_eal = &toattr->eal;
    long int ealno = igraph_vector_ptr_size(eal);
    long int i, j, keepno = 0;
    int *TODO;
    igraph_function_pointer_t *funcs;

    TODO = IGRAPH_CALLOC(ealno, int);
    if (!TODO) {
        IGRAPH_ERROR("Cannot combine edge attributes",
                     IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, TODO);
    funcs = IGRAPH_CALLOC(ealno, igraph_function_pointer_t);
    if (!funcs) {
        IGRAPH_ERROR("Cannot combine edge attributes",
                     IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, funcs);

    for (i = 0; i < ealno; i++) {
        igraph_attribute_record_t *oldrec = VECTOR(*eal)[i];
        const char *name = oldrec->name;
        igraph_attribute_combination_type_t todo;
        igraph_function_pointer_t voidfunc;
        igraph_attribute_combination_query(comb, name, &todo, &voidfunc);
        TODO[i] = todo;
        funcs[i] = voidfunc;
        if (todo != IGRAPH_ATTRIBUTE_COMBINE_IGNORE) {
            keepno++;
        }
    }

    IGRAPH_CHECK(igraph_vector_ptr_resize(new_eal, keepno));
    IGRAPH_FINALLY(igraph_i_cattribute_permute_free, new_eal);

    for (i = 0, j = 0; i < ealno; i++) {
        igraph_attribute_record_t *newrec, *oldrec = VECTOR(*eal)[i];
        const char *name = oldrec->name;
        igraph_attribute_combination_type_t todo =
            (igraph_attribute_combination_type_t) (TODO[i]);
        igraph_attribute_type_t type = oldrec->type;
        igraph_cattributes_combine_num_t *numfunc =
            (igraph_cattributes_combine_num_t*) funcs[i];
        igraph_cattributes_combine_str_t *strfunc =
            (igraph_cattributes_combine_str_t*) funcs[i];
        igraph_cattributes_combine_bool_t *boolfunc =
            (igraph_cattributes_combine_bool_t*) funcs[i];

        if (todo == IGRAPH_ATTRIBUTE_COMBINE_DEFAULT ||
            todo == IGRAPH_ATTRIBUTE_COMBINE_IGNORE) {
            continue;
        }

        newrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        if (!newrec) {
            IGRAPH_ERROR("Cannot combine edge attributes",
                         IGRAPH_ENOMEM);
        }
        newrec->name = strdup(name);
        newrec->type = type;
        VECTOR(*new_eal)[j] = newrec;

        if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_cn_func(oldrec, newrec, merges,
                             numfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
                IGRAPH_CHECK(igraph_i_cattributes_cn_sum(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
                IGRAPH_CHECK(igraph_i_cattributes_cn_prod(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_CHECK(igraph_i_cattributes_cn_min(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_CHECK(igraph_i_cattributes_cn_max(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_cn_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_cn_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_cn_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
                IGRAPH_CHECK(igraph_i_cattributes_cn_mean(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_ERROR("Median calculation not implemented",
                             IGRAPH_UNIMPLEMENTED);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_ERROR("Cannot concatenate numeric attributes",
                             IGRAPH_EATTRCOMBINE);
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_cb_func(oldrec, newrec, merges,
                             boolfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_CHECK(igraph_i_cattributes_cb_any_is_true(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_CHECK(igraph_i_cattributes_cb_all_is_true(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_CHECK(igraph_i_cattributes_cb_majority(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_cb_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_cb_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_cb_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_ERROR("Cannot calculate concatenation of Booleans",
                             IGRAPH_EATTRCOMBINE);
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else if (type == IGRAPH_ATTRIBUTE_STRING) {
            switch (todo) {
            case IGRAPH_ATTRIBUTE_COMBINE_FUNCTION:
                IGRAPH_CHECK(igraph_i_cattributes_sn_func(oldrec, newrec, merges,
                             strfunc));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_SUM:
                IGRAPH_ERROR("Cannot sum strings", IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_PROD:
                IGRAPH_ERROR("Cannot multiply strings", IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MIN:
                IGRAPH_ERROR("Cannot find minimum of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MAX:
                IGRAPH_ERROR("Cannot find maximum of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEAN:
                IGRAPH_ERROR("Cannot calculate mean of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_MEDIAN:
                IGRAPH_ERROR("Cannot calculate median of strings",
                             IGRAPH_EATTRCOMBINE);
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_RANDOM:
                IGRAPH_CHECK(igraph_i_cattributes_sn_random(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_FIRST:
                IGRAPH_CHECK(igraph_i_cattributes_sn_first(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_LAST:
                IGRAPH_CHECK(igraph_i_cattributes_sn_last(oldrec, newrec, merges));
                break;
            case IGRAPH_ATTRIBUTE_COMBINE_CONCAT:
                IGRAPH_CHECK(igraph_i_cattributes_sn_concat(oldrec, newrec, merges));
                break;
            default:
                IGRAPH_ERROR("Unknown attribute_combination",
                             IGRAPH_UNIMPLEMENTED);
                break;
            }
        } else {
            IGRAPH_ERROR("Unknown attribute type, this should not happen",
                         IGRAPH_UNIMPLEMENTED);
        }

        j++;
    }

    igraph_free(funcs);
    igraph_free(TODO);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

static int igraph_i_cattribute_get_info(const igraph_t *graph,
                                        igraph_strvector_t *gnames,
                                        igraph_vector_t *gtypes,
                                        igraph_strvector_t *vnames,
                                        igraph_vector_t *vtypes,
                                        igraph_strvector_t *enames,
                                        igraph_vector_t *etypes) {

    igraph_strvector_t *names[3] = { gnames, vnames, enames };
    igraph_vector_t *types[3] = { gtypes, vtypes, etypes };
    igraph_i_cattributes_t *at = graph->attr;
    igraph_vector_ptr_t *attr[3] = { &at->gal, &at->val, &at->eal };
    long int i, j;

    for (i = 0; i < 3; i++) {
        igraph_strvector_t *n = names[i];
        igraph_vector_t *t = types[i];
        igraph_vector_ptr_t *al = attr[i];
        long int len = igraph_vector_ptr_size(al);

        if (n) {
            IGRAPH_CHECK(igraph_strvector_resize(n, len));
        }
        if (t) {
            IGRAPH_CHECK(igraph_vector_resize(t, len));
        }

        for (j = 0; j < len; j++) {
            igraph_attribute_record_t *rec = VECTOR(*al)[j];
            const char *name = rec->name;
            igraph_attribute_type_t type = rec->type;
            if (n) {
                IGRAPH_CHECK(igraph_strvector_set(n, j, name));
            }
            if (t) {
                VECTOR(*t)[j] = type;
            }
        }
    }

    return 0;
}

static igraph_bool_t igraph_i_cattribute_has_attr(const igraph_t *graph,
                                                  igraph_attribute_elemtype_t type,
                                                  const char *name) {
    igraph_i_cattributes_t *at = graph->attr;
    igraph_vector_ptr_t *attr[3] = { &at->gal, &at->val, &at->eal };
    long int attrnum;

    switch (type) {
    case IGRAPH_ATTRIBUTE_GRAPH:
        attrnum = 0;
        break;
    case IGRAPH_ATTRIBUTE_VERTEX:
        attrnum = 1;
        break;
    case IGRAPH_ATTRIBUTE_EDGE:
        attrnum = 2;
        break;
    default:
        IGRAPH_ERROR("Unknown attribute element type", IGRAPH_EINVAL);
        break;
    }

    return igraph_i_cattribute_find(attr[attrnum], name, 0);
}

static int igraph_i_cattribute_gettype(const igraph_t *graph,
                                       igraph_attribute_type_t *type,
                                       igraph_attribute_elemtype_t elemtype,
                                       const char *name) {
    long int attrnum;
    igraph_attribute_record_t *rec;
    igraph_i_cattributes_t *at = graph->attr;
    igraph_vector_ptr_t *attr[3] = { &at->gal, &at->val, &at->eal };
    igraph_vector_ptr_t *al;
    long int j;
    igraph_bool_t l = 0;

    switch (elemtype) {
    case IGRAPH_ATTRIBUTE_GRAPH:
        attrnum = 0;
        break;
    case IGRAPH_ATTRIBUTE_VERTEX:
        attrnum = 1;
        break;
    case IGRAPH_ATTRIBUTE_EDGE:
        attrnum = 2;
        break;
    default:
        IGRAPH_ERROR("Unknown attribute element type", IGRAPH_EINVAL);
        break;
    }

    al = attr[attrnum];
    l = igraph_i_cattribute_find(al, name, &j);
    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }
    rec = VECTOR(*al)[j];
    *type = rec->type;

    return 0;
}

static int igraph_i_cattribute_get_numeric_graph_attr(const igraph_t *graph,
                                                      const char *name,
                                                      igraph_vector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*gal)[j];
    num = (igraph_vector_t*)rec->value;
    IGRAPH_CHECK(igraph_vector_resize(value, 1));
    VECTOR(*value)[0] = VECTOR(*num)[0];

    return 0;
}

static int igraph_i_cattribute_get_bool_graph_attr(const igraph_t *graph,
                                                   const char *name,
                                                   igraph_vector_bool_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*gal)[j];
    log = (igraph_vector_bool_t*)rec->value;
    IGRAPH_CHECK(igraph_vector_bool_resize(value, 1));
    VECTOR(*value)[0] = VECTOR(*log)[0];

    return 0;
}

static int igraph_i_cattribute_get_string_graph_attr(const igraph_t *graph,
                                                     const char *name,
                                                     igraph_strvector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*gal)[j];
    str = (igraph_strvector_t*)rec->value;
    IGRAPH_CHECK(igraph_strvector_resize(value, 1));
    IGRAPH_CHECK(igraph_strvector_set(value, 0, STR(*str, 0)));

    return 0;
}

static int igraph_i_cattribute_get_numeric_vertex_attr(const igraph_t *graph,
                                                       const char *name,
                                                       igraph_vs_t vs,
                                                       igraph_vector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*val)[j];
    num = (igraph_vector_t*)rec->value;
    if (igraph_vs_is_all(&vs)) {
        igraph_vector_clear(value);
        IGRAPH_CHECK(igraph_vector_append(value, num));
    } else {
        igraph_vit_t it;
        long int i = 0;
        IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
        IGRAPH_FINALLY(igraph_vit_destroy, &it);
        IGRAPH_CHECK(igraph_vector_resize(value, IGRAPH_VIT_SIZE(it)));
        for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
            long int v = IGRAPH_VIT_GET(it);
            VECTOR(*value)[i] = VECTOR(*num)[v];
        }
        igraph_vit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_get_bool_vertex_attr(const igraph_t *graph,
                                                    const char *name,
                                                    igraph_vs_t vs,
                                                    igraph_vector_bool_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    igraph_vit_t it;
    long int i, j, v;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*val)[j];
    log = (igraph_vector_bool_t*)rec->value;
    if (igraph_vs_is_all(&vs)) {
        igraph_vector_bool_clear(value);
        IGRAPH_CHECK(igraph_vector_bool_append(value, log));
    } else {
        IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
        IGRAPH_FINALLY(igraph_vit_destroy, &it);
        IGRAPH_CHECK(igraph_vector_bool_resize(value, IGRAPH_VIT_SIZE(it)));
        for (i = 0; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
            v = IGRAPH_VIT_GET(it);
            VECTOR(*value)[i] = VECTOR(*log)[v];
        }
        igraph_vit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_get_string_vertex_attr(const igraph_t *graph,
                                                      const char *name,
                                                      igraph_vs_t vs,
                                                      igraph_strvector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*val)[j];
    str = (igraph_strvector_t*)rec->value;
    if (igraph_vs_is_all(&vs)) {
        igraph_strvector_resize(value, 0);
        IGRAPH_CHECK(igraph_strvector_append(value, str));
    } else {
        igraph_vit_t it;
        long int i = 0;
        IGRAPH_CHECK(igraph_vit_create(graph, vs, &it));
        IGRAPH_FINALLY(igraph_vit_destroy, &it);
        IGRAPH_CHECK(igraph_strvector_resize(value, IGRAPH_VIT_SIZE(it)));
        for (; !IGRAPH_VIT_END(it); IGRAPH_VIT_NEXT(it), i++) {
            long int v = IGRAPH_VIT_GET(it);
            char *s;
            igraph_strvector_get(str, v, &s);
            IGRAPH_CHECK(igraph_strvector_set(value, i, s));
        }
        igraph_vit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_get_numeric_edge_attr(const igraph_t *graph,
                                                     const char *name,
                                                     igraph_es_t es,
                                                     igraph_vector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*eal)[j];
    num = (igraph_vector_t*)rec->value;
    if (igraph_es_is_all(&es)) {
        igraph_vector_clear(value);
        IGRAPH_CHECK(igraph_vector_append(value, num));
    } else {
        igraph_eit_t it;
        long int i = 0;
        IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
        IGRAPH_FINALLY(igraph_eit_destroy, &it);
        IGRAPH_CHECK(igraph_vector_resize(value, IGRAPH_EIT_SIZE(it)));
        for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
            long int e = IGRAPH_EIT_GET(it);
            VECTOR(*value)[i] = VECTOR(*num)[e];
        }
        igraph_eit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_get_string_edge_attr(const igraph_t *graph,
                                                    const char *name,
                                                    igraph_es_t es,
                                                    igraph_strvector_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*eal)[j];
    str = (igraph_strvector_t*)rec->value;
    if (igraph_es_is_all(&es)) {
        igraph_strvector_resize(value, 0);
        IGRAPH_CHECK(igraph_strvector_append(value, str));
    } else {
        igraph_eit_t it;
        long int i = 0;
        IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
        IGRAPH_FINALLY(igraph_eit_destroy, &it);
        IGRAPH_CHECK(igraph_strvector_resize(value, IGRAPH_EIT_SIZE(it)));
        for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
            long int e = IGRAPH_EIT_GET(it);
            char *s;
            igraph_strvector_get(str, e, &s);
            IGRAPH_CHECK(igraph_strvector_set(value, i, s));
        }
        igraph_eit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_cattribute_get_bool_edge_attr(const igraph_t *graph,
                                                  const char *name,
                                                  igraph_es_t es,
                                                  igraph_vector_bool_t *value) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        IGRAPH_ERROR("Unknown attribute", IGRAPH_EINVAL);
    }

    rec = VECTOR(*eal)[j];
    log = (igraph_vector_bool_t*)rec->value;
    if (igraph_es_is_all(&es)) {
        igraph_vector_bool_clear(value);
        IGRAPH_CHECK(igraph_vector_bool_append(value, log));
    } else {
        igraph_eit_t it;
        long int i = 0;
        IGRAPH_CHECK(igraph_eit_create(graph, es, &it));
        IGRAPH_FINALLY(igraph_eit_destroy, &it);
        IGRAPH_CHECK(igraph_vector_bool_resize(value, IGRAPH_EIT_SIZE(it)));
        for (; !IGRAPH_EIT_END(it); IGRAPH_EIT_NEXT(it), i++) {
            long int e = IGRAPH_EIT_GET(it);
            VECTOR(*value)[i] = VECTOR(*log)[e];
        }
        igraph_eit_destroy(&it);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/* -------------------------------------- */

const igraph_attribute_table_t igraph_cattribute_table = {
    &igraph_i_cattribute_init,
    &igraph_i_cattribute_destroy,
    &igraph_i_cattribute_copy,
    &igraph_i_cattribute_add_vertices,
    &igraph_i_cattribute_permute_vertices,
    &igraph_i_cattribute_combine_vertices, &igraph_i_cattribute_add_edges,
    &igraph_i_cattribute_permute_edges,
    &igraph_i_cattribute_combine_edges,
    &igraph_i_cattribute_get_info,
    &igraph_i_cattribute_has_attr,
    &igraph_i_cattribute_gettype,
    &igraph_i_cattribute_get_numeric_graph_attr,
    &igraph_i_cattribute_get_string_graph_attr,
    &igraph_i_cattribute_get_bool_graph_attr,
    &igraph_i_cattribute_get_numeric_vertex_attr,
    &igraph_i_cattribute_get_string_vertex_attr,
    &igraph_i_cattribute_get_bool_vertex_attr,
    &igraph_i_cattribute_get_numeric_edge_attr,
    &igraph_i_cattribute_get_string_edge_attr,
    &igraph_i_cattribute_get_bool_edge_attr
};

/* -------------------------------------- */

/**
 * \section cattributes
 * There is an experimental attribute handler that can be used
 * from C code. In this section we show how this works. This attribute
 * handler is by default not attached (the default is no attribute
 * handler), so we first need to attach it:
 * 
 * igraph_set_attribute_table(&igraph_cattribute_table);
 * 
 * 
 * Now the attribute functions are available. Please note that
 * the attribute handler must be attached before you call any other
 * igraph functions, otherwise you might end up with graphs without
 * attributes and an active attribute handler, which might cause
 * unexpected program behaviour. The rule is that you attach the
 * attribute handler in the beginning of your
 * main() and never touch it again. (Detaching
 * the attribute handler might lead to memory leaks.)
 *
 * It is not currently possible to have attribute handlers on a
 * per-graph basis. All graphs in an application must be managed with
 * the same attribute handler. (Including the default case when there
 * is no attribute handler at all.
 *
 * The C attribute handler supports attaching real numbers and
 * character strings as attributes. No vectors are allowed, i.e. every
 * vertex might have an attribute called name, but it is
 * not possible to have a coords graph (or other)
 * attribute which is a vector of numbers.
 *
 * \example examples/simple/cattributes.c
 * \example examples/simple/cattributes2.c
 * \example examples/simple/cattributes3.c
 * \example examples/simple/cattributes4.c
 */

/**
 * \function igraph_cattribute_GAN
 * Query a numeric graph attribute.
 *
 * Returns the value of the given numeric graph attribute.
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute to query.
 * \return The value of the attribute.
 *
 * \sa \ref GAN for a simpler interface.
 *
 * Time complexity: O(Ag), the number of graph attributes.
 */
igraph_real_t igraph_cattribute_GAN(const igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*gal)[j];
    num = (igraph_vector_t*)rec->value;
    return VECTOR(*num)[0];
}

/**
 * \function igraph_cattribute_GAB
 * Query a boolean graph attribute.
 *
 * Returns the value of the given numeric graph attribute.
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute to query.
 * \return The value of the attribute.
 *
 * \sa \ref GAB for a simpler interface.
 *
 * Time complexity: O(Ag), the number of graph attributes.
 */
igraph_bool_t igraph_cattribute_GAB(const igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*gal)[j];
    log = (igraph_vector_bool_t*)rec->value;
    return VECTOR(*log)[0];
}

/**
 * \function igraph_cattribute_GAS
 * Query a string graph attribute.
 *
 * Returns a const pointer to the string graph attribute
 * specified in \p name.
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute to query.
 * \return The value of the attribute.
 *
 * \sa \ref GAS for a simpler interface.
 *
 * Time complexity: O(Ag), the number of graph attributes.
 */
const char* igraph_cattribute_GAS(const igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*gal)[j];
    str = (igraph_strvector_t*)rec->value;
    return STR(*str, 0);
}

/**
 * \function igraph_cattribute_VAN
 * Query a numeric vertex attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vid The id of the queried vertex.
 * \return The value of the attribute.
 *
 * \sa \ref VAN macro for a simpler interface.
 *
 * Time complexity: O(Av), the number of vertex attributes.
 */
igraph_real_t igraph_cattribute_VAN(const igraph_t *graph, const char *name,
                                    igraph_integer_t vid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*val)[j];
    num = (igraph_vector_t*)rec->value;
    return VECTOR(*num)[(long int)vid];
}

/**
 * \function igraph_cattribute_VAB
 * Query a boolean vertex attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vid The id of the queried vertex.
 * \return The value of the attribute.
 *
 * \sa \ref VAB macro for a simpler interface.
 *
 * Time complexity: O(Av), the number of vertex attributes.
 */
igraph_bool_t igraph_cattribute_VAB(const igraph_t *graph, const char *name,
                                    igraph_integer_t vid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*val)[j];
    log = (igraph_vector_bool_t*)rec->value;
    return VECTOR(*log)[(long int)vid];
}

/**
 * \function igraph_cattribute_VAS
 * Query a string vertex attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vid The id of the queried vertex.
 * \return The value of the attribute.
 *
 * \sa The macro \ref VAS for a simpler interface.
 *
 * Time complexity: O(Av), the number of vertex attributes.
 */
const char* igraph_cattribute_VAS(const igraph_t *graph, const char *name,
                                  igraph_integer_t vid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*val)[j];
    str = (igraph_strvector_t*)rec->value;
    return STR(*str, (long int)vid);
}

/**
 * \function igraph_cattribute_EAN
 * Query a numeric edge attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param eid The id of the queried edge.
 * \return The value of the attribute.
 *
 * \sa \ref EAN for an easier interface.
 *
 * Time complexity: O(Ae), the number of edge attributes.
 */
igraph_real_t igraph_cattribute_EAN(const igraph_t *graph, const char *name,
                                    igraph_integer_t eid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_t *num;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*eal)[j];
    num = (igraph_vector_t*)rec->value;
    return VECTOR(*num)[(long int)eid];
}

/**
 * \function igraph_cattribute_EAB
 * Query a boolean edge attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param eid The id of the queried edge.
 * \return The value of the attribute.
 *
 * \sa \ref EAB for an easier interface.
 *
 * Time complexity: O(Ae), the number of edge attributes.
 */
igraph_bool_t igraph_cattribute_EAB(const igraph_t *graph, const char *name,
                                    igraph_integer_t eid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_vector_bool_t *log;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*eal)[j];
    log = (igraph_vector_bool_t*)rec->value;
    return VECTOR(*log)[(long int)eid];
}

/**
 * \function igraph_cattribute_EAS
 * Query a string edge attribute.
 *
 * The attribute must exist, otherwise an error is triggered.
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param eid The id of the queried edge.
 * \return The value of the attribute.
 *
 * \se \ref EAS if you want to type less.
 *
 * Time complexity: O(Ae), the number of edge attributes.
 */
const char* igraph_cattribute_EAS(const igraph_t *graph, const char *name,
                                  igraph_integer_t eid) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_attribute_record_t *rec;
    igraph_strvector_t *str;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (!l) {
        igraph_error("Unknown attribute", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EINVAL);
        return 0;
    }

    rec = VECTOR(*eal)[j];
    str = (igraph_strvector_t*)rec->value;
    return STR(*str, (long int)eid);
}

/**
 * \function igraph_cattribute_VANV
 * Query a numeric vertex attribute for many vertices
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vids The vertices to query.
 * \param result Pointer to an initialized vector, the result is
 *    stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(v), where v is the number of vertices in 'vids'.
 */

int igraph_cattribute_VANV(const igraph_t *graph, const char *name,
                           igraph_vs_t vids, igraph_vector_t *result) {

    return igraph_i_cattribute_get_numeric_vertex_attr(graph, name, vids,
            result);
}

/**
 * \function igraph_cattribute_VABV
 * Query a boolean vertex attribute for many vertices
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vids The vertices to query.
 * \param result Pointer to an initialized boolean vector, the result is
 *    stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(v), where v is the number of vertices in 'vids'.
 */

int igraph_cattribute_VABV(const igraph_t *graph, const char *name,
                           igraph_vs_t vids, igraph_vector_bool_t *result) {

    return igraph_i_cattribute_get_bool_vertex_attr(graph, name, vids,
            result);
}

/**
 * \function igraph_cattribute_EANV
 * Query a numeric edge attribute for many edges
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param eids The edges to query.
 * \param result Pointer to an initialized vector, the result is
 *    stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(e), where e is the number of edges in 'eids'.
 */

int igraph_cattribute_EANV(const igraph_t *graph, const char *name,
                           igraph_es_t eids, igraph_vector_t *result) {

    return igraph_i_cattribute_get_numeric_edge_attr(graph, name, eids,
            result);
}

/**
 * \function igraph_cattribute_EABV
 * Query a boolean edge attribute for many edges
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param eids The edges to query.
 * \param result Pointer to an initialized boolean vector, the result is
 *    stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(e), where e is the number of edges in 'eids'.
 */

int igraph_cattribute_EABV(const igraph_t *graph, const char *name,
                           igraph_es_t eids, igraph_vector_bool_t *result) {

    return igraph_i_cattribute_get_bool_edge_attr(graph, name, eids,
            result);
}

/**
 * \function igraph_cattribute_VASV
 * Query a string vertex attribute for many vertices
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vids The vertices to query.
 * \param result Pointer to an initialized string vector, the result
 *     is stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(v), where v is the number of vertices in 'vids'.
 * (We assume that the string attributes have a bounded length.)
 */

int igraph_cattribute_VASV(const igraph_t *graph, const char *name,
                           igraph_vs_t vids, igraph_strvector_t *result) {

    return igraph_i_cattribute_get_string_vertex_attr(graph, name, vids,
            result);
}

/**
 * \function igraph_cattribute_EASV
 * Query a string edge attribute for many edges
 *
 * \param graph The input graph.
 * \param name The name of the attribute.
 * \param vids The edges to query.
 * \param result Pointer to an initialized string vector, the result
 *     is stored here. It will be resized, if needed.
 * \return Error code.
 *
 * Time complexity: O(e), where e is the number of edges in
 * 'eids'. (We assume that the string attributes have a bounded length.)
 */

int igraph_cattribute_EASV(const igraph_t *graph, const char *name,
                           igraph_es_t eids, igraph_strvector_t *result) {

    return igraph_i_cattribute_get_string_edge_attr(graph, name, eids,
            result);
}

/**
 * \function igraph_cattribute_list
 * List all attributes
 *
 * See \ref igraph_attribute_type_t for the various attribute types.
 * \param graph The input graph.
 * \param gnames String vector, the names of the graph attributes.
 * \param gtypes Numeric vector, the types of the graph attributes.
 * \param vnames String vector, the names of the vertex attributes.
 * \param vtypes Numeric vector, the types of the vertex attributes.
 * \param enames String vector, the names of the edge attributes.
 * \param etypes Numeric vector, the types of the edge attributes.
 * \return Error code.
 *
 * Naturally, the string vector with the attribute names and the
 * numeric vector with the attribute types are in the right order,
 * i.e. the first name corresponds to the first type, etc.
 *
 * Time complexity: O(Ag+Av+Ae), the number of all attributes.
 */
int igraph_cattribute_list(const igraph_t *graph,
                           igraph_strvector_t *gnames, igraph_vector_t *gtypes,
                           igraph_strvector_t *vnames, igraph_vector_t *vtypes,
                           igraph_strvector_t *enames, igraph_vector_t *etypes) {
    return igraph_i_cattribute_get_info(graph, gnames, gtypes, vnames, vtypes,
                                        enames, etypes);
}

/**
 * \function igraph_cattribute_has_attr
 * Checks whether a (graph, vertex or edge) attribute exists
 *
 * \param graph The graph.
 * \param type The type of the attribute, \c IGRAPH_ATTRIBUTE_GRAPH,
 *        \c IGRAPH_ATTRIBUTE_VERTEX or \c IGRAPH_ATTRIBUTE_EDGE.
 * \param name Character constant, the name of the attribute.
 * \return Logical value, TRUE if the attribute exists, FALSE otherwise.
 *
 * Time complexity: O(A), the number of (graph, vertex or edge)
 * attributes, assuming attribute names are not too long.
 */
igraph_bool_t igraph_cattribute_has_attr(const igraph_t *graph,
        igraph_attribute_elemtype_t type,
        const char *name) {
    return igraph_i_cattribute_has_attr(graph, type, name);
}

/**
 * \function igraph_cattribute_GAN_set
 * Set a numeric graph attribute
 *
 * \param graph The graph.
 * \param name Name of the graph attribute. If there is no such
 *   attribute yet, then it will be added.
 * \param value The (new) value of the graph attribute.
 * \return Error code.
 *
 * \se \ref SETGAN if you want to type less.
 *
 * Time complexity: O(1).
 */
int igraph_cattribute_GAN_set(igraph_t *graph, const char *name,
                              igraph_real_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*gal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_t *num = (igraph_vector_t *)rec->value;
            VECTOR(*num)[0] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_t *num;
        if (!rec) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_NUMERIC;
        num = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!num) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, num);
        IGRAPH_VECTOR_INIT_FINALLY(num, 1);
        VECTOR(*num)[0] = value;
        rec->value = num;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(gal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_GAB_set
 * Set a boolean graph attribute
 *
 * \param graph The graph.
 * \param name Name of the graph attribute. If there is no such
 *   attribute yet, then it will be added.
 * \param value The (new) value of the graph attribute.
 * \return Error code.
 *
 * \se \ref SETGAN if you want to type less.
 *
 * Time complexity: O(1).
 */
int igraph_cattribute_GAB_set(igraph_t *graph, const char *name,
                              igraph_bool_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*gal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_bool_t *log = (igraph_vector_bool_t *)rec->value;
            VECTOR(*log)[0] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_bool_t *log;
        if (!rec) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_BOOLEAN;
        log = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!log) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, log);
        IGRAPH_CHECK(igraph_vector_bool_init(log, 1));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, log);
        VECTOR(*log)[0] = value;
        rec->value = log;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(gal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_GAS_set
 * Set a string graph attribute.
 *
 * \param graph The graph.
 * \param name Name of the graph attribute. If there is no such
 *   attribute yet, then it will be added.
 * \param value The (new) value of the graph attribute. It will be
 *   copied.
 * \return Error code.
 *
 * \se \ref SETGAS if you want to type less.
 *
 * Time complexity: O(1).
 */
int igraph_cattribute_GAS_set(igraph_t *graph, const char *name,
                              const char *value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*gal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_strvector_t *str = (igraph_strvector_t*)rec->value;
            IGRAPH_CHECK(igraph_strvector_set(str, 0, value));
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_strvector_t *str;
        if (!rec) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_STRING;
        str = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!str) {
            IGRAPH_ERROR("Cannot add graph attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, str);
        IGRAPH_STRVECTOR_INIT_FINALLY(str, 1);
        IGRAPH_CHECK(igraph_strvector_set(str, 0, value));
        rec->value = str;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(gal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_VAN_set
 * Set a numeric vertex attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all vertices
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param vid Vertices for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETVAN for a simpler way.
 *
 * Time complexity: O(n), the number of vertices if the attribute is
 * new, O(|vid|) otherwise.
 */
int igraph_cattribute_VAN_set(igraph_t *graph, const char *name,
                              igraph_integer_t vid, igraph_real_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_t *num = (igraph_vector_t*)rec->value;
            VECTOR(*num)[(long int)vid] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_t *num;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_NUMERIC;
        num = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!num) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, num);
        IGRAPH_VECTOR_INIT_FINALLY(num, igraph_vcount(graph));
        igraph_vector_fill(num, IGRAPH_NAN);
        VECTOR(*num)[(long int)vid] = value;
        rec->value = num;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_VAB_set
 * Set a boolean vertex attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all vertices
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param vid Vertices for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETVAB for a simpler way.
 *
 * Time complexity: O(n), the number of vertices if the attribute is
 * new, O(|vid|) otherwise.
 */
int igraph_cattribute_VAB_set(igraph_t *graph, const char *name,
                              igraph_integer_t vid, igraph_bool_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_bool_t *log = (igraph_vector_bool_t*)rec->value;
            VECTOR(*log)[(long int)vid] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_bool_t *log;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_BOOLEAN;
        log = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!log) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, log);
        IGRAPH_CHECK(igraph_vector_bool_init(log, igraph_vcount(graph)));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, log);
        igraph_vector_bool_fill(log, 0);
        VECTOR(*log)[(long int)vid] = value;
        rec->value = log;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_VAS_set
 * Set a string vertex attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all vertices
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param vid Vertices for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETVAS for a simpler way.
 *
 * Time complexity: O(n*l), n is the number of vertices, l is the
 * length of the string to set. If the attribute if not new then only
 * O(|vid|*l).
 */
int igraph_cattribute_VAS_set(igraph_t *graph, const char *name,
                              igraph_integer_t vid, const char *value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_strvector_t *str = (igraph_strvector_t*)rec->value;
            IGRAPH_CHECK(igraph_strvector_set(str, vid, value));
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_strvector_t *str;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_STRING;
        str = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!str) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, str);
        IGRAPH_STRVECTOR_INIT_FINALLY(str, igraph_vcount(graph));
        IGRAPH_CHECK(igraph_strvector_set(str, vid, value));
        rec->value = str;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAN_set
 * Set a numeric edge attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all edges
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param eid Edges for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETEAN for a simpler way.
 *
 * Time complexity: O(e), the number of edges if the attribute is
 * new, O(|eid|) otherwise.
 */
int igraph_cattribute_EAN_set(igraph_t *graph, const char *name,
                              igraph_integer_t eid, igraph_real_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_t *num = (igraph_vector_t*)rec->value;
            VECTOR(*num)[(long int)eid] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_t *num;
        if (!rec) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_NUMERIC;
        num = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!num) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, num);
        IGRAPH_VECTOR_INIT_FINALLY(num, igraph_ecount(graph));
        igraph_vector_fill(num, IGRAPH_NAN);
        VECTOR(*num)[(long int)eid] = value;
        rec->value = num;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAB_set
 * Set a boolean edge attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all edges
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param eid Edges for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETEAB for a simpler way.
 *
 * Time complexity: O(e), the number of edges if the attribute is
 * new, O(|eid|) otherwise.
 */
int igraph_cattribute_EAB_set(igraph_t *graph, const char *name,
                              igraph_integer_t eid, igraph_bool_t value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_vector_bool_t *log = (igraph_vector_bool_t*)rec->value;
            VECTOR(*log)[(long int)eid] = value;
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_bool_t *log;
        if (!rec) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_BOOLEAN;
        log = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!log) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, log);
        IGRAPH_CHECK(igraph_vector_bool_init(log, igraph_ecount(graph)));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, log);
        igraph_vector_bool_fill(log, 0);
        VECTOR(*log)[(long int)eid] = value;
        rec->value = log;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAS_set
 * Set a string edge attribute
 *
 * The attribute will be added if not present already. If present it
 * will be overwritten. The same \p value is set for all edges
 * included in \p vid.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param eid Edges for which to set the attribute.
 * \param value The (new) value of the attribute.
 * \return Error code.
 *
 * \sa \ref SETEAS for a simpler way.
 *
 * Time complexity: O(e*l), n is the number of edges, l is the
 * length of the string to set. If the attribute if not new then only
 * O(|eid|*l).
 */
int igraph_cattribute_EAS_set(igraph_t *graph, const char *name,
                              igraph_integer_t eid, const char *value) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (l) {
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        if (rec->type != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_ERROR("Invalid attribute type", IGRAPH_EINVAL);
        } else {
            igraph_strvector_t *str = (igraph_strvector_t*)rec->value;
            IGRAPH_CHECK(igraph_strvector_set(str, eid, value));
        }
    } else {
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_strvector_t *str;
        if (!rec) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        rec->type = IGRAPH_ATTRIBUTE_STRING;
        str = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!str) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, str);
        IGRAPH_STRVECTOR_INIT_FINALLY(str, igraph_ecount(graph));
        IGRAPH_CHECK(igraph_strvector_set(str, eid, value));
        rec->value = str;
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_VAN_setv
 * Set a numeric vertex attribute for all vertices.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param v The new attribute values. The length of this vector must
 *   match the number of vertices.
 * \return Error code.
 *
 * \sa \ref SETVANV for a simpler way.
 *
 * Time complexity: O(n), the number of vertices.
 */

int igraph_cattribute_VAN_setv(igraph_t *graph, const char *name,
                               const igraph_vector_t *v) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    /* Check length first */
    if (igraph_vector_size(v) != igraph_vcount(graph)) {
        IGRAPH_ERROR("Invalid vertex attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        igraph_vector_t *num = (igraph_vector_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_vector_clear(num);
        IGRAPH_CHECK(igraph_vector_append(num, v));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_t *num;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_NUMERIC;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        num = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!num) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, num);
        rec->value = num;
        IGRAPH_CHECK(igraph_vector_copy(num, v));
        IGRAPH_FINALLY(igraph_vector_destroy, num);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}
/**
 * \function igraph_cattribute_VAB_setv
 * Set a boolean vertex attribute for all vertices.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param v The new attribute values. The length of this boolean vector must
 *   match the number of vertices.
 * \return Error code.
 *
 * \sa \ref SETVANV for a simpler way.
 *
 * Time complexity: O(n), the number of vertices.
 */

int igraph_cattribute_VAB_setv(igraph_t *graph, const char *name,
                               const igraph_vector_bool_t *v) {
    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    /* Check length first */
    if (igraph_vector_bool_size(v) != igraph_vcount(graph)) {
        IGRAPH_ERROR("Invalid vertex attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        igraph_vector_bool_t *log = (igraph_vector_bool_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_vector_bool_clear(log);
        IGRAPH_CHECK(igraph_vector_bool_append(log, v));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_bool_t *log;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_BOOLEAN;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        log = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!log) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, log);
        rec->value = log;
        IGRAPH_CHECK(igraph_vector_bool_copy(log, v));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, log);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_VAS_setv
 * Set a string vertex attribute for all vertices.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param sv String vector, the new attribute values. The length of this vector must
 *   match the number of vertices.
 * \return Error code.
 *
 * \sa \ref SETVASV for a simpler way.
 *
 * Time complexity: O(n+l), n is the number of vertices, l is the
 * total length of the strings.
 */
int igraph_cattribute_VAS_setv(igraph_t *graph, const char *name,
                               const igraph_strvector_t *sv) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    /* Check length first */
    if (igraph_strvector_size(sv) != igraph_vcount(graph)) {
        IGRAPH_ERROR("Invalid vertex attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*val)[j];
        igraph_strvector_t *str = (igraph_strvector_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_strvector_clear(str);
        IGRAPH_CHECK(igraph_strvector_append(str, sv));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_strvector_t *str;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_STRING;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        str = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!str) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, str);
        rec->value = str;
        IGRAPH_CHECK(igraph_strvector_copy(str, sv));
        IGRAPH_FINALLY(igraph_strvector_destroy, str);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(val, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAN_setv
 * Set a numeric edge attribute for all edges.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param v The new attribute values. The length of this vector must
 *   match the number of edges.
 * \return Error code.
 *
 * \sa \ref SETEANV for a simpler way.
 *
 * Time complexity: O(e), the number of edges.
 */
int igraph_cattribute_EAN_setv(igraph_t *graph, const char *name,
                               const igraph_vector_t *v) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    /* Check length first */
    if (igraph_vector_size(v) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid edge attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        igraph_vector_t *num = (igraph_vector_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_vector_clear(num);
        IGRAPH_CHECK(igraph_vector_append(num, v));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_t *num;
        if (!rec) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_NUMERIC;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        num = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!num) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, num);
        rec->value = num;
        IGRAPH_CHECK(igraph_vector_copy(num, v));
        IGRAPH_FINALLY(igraph_vector_destroy, num);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAB_setv
 * Set a boolean edge attribute for all edges.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param v The new attribute values. The length of this vector must
 *   match the number of edges.
 * \return Error code.
 *
 * \sa \ref SETEABV for a simpler way.
 *
 * Time complexity: O(e), the number of edges.
 */
int igraph_cattribute_EAB_setv(igraph_t *graph, const char *name,
                               const igraph_vector_bool_t *v) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    /* Check length first */
    if (igraph_vector_bool_size(v) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid edge attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        igraph_vector_bool_t *log = (igraph_vector_bool_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_vector_bool_clear(log);
        IGRAPH_CHECK(igraph_vector_bool_append(log, v));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_vector_bool_t *log;
        if (!rec) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_BOOLEAN;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        log = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (!log) {
            IGRAPH_ERROR("Cannot add edge attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, log);
        rec->value = log;
        IGRAPH_CHECK(igraph_vector_bool_copy(log, v));
        IGRAPH_FINALLY(igraph_vector_bool_destroy, log);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

/**
 * \function igraph_cattribute_EAS_setv
 * Set a string edge attribute for all edges.
 *
 * The attribute will be added if not present yet.
 * \param graph The graph.
 * \param name Name of the attribute.
 * \param sv String vector, the new attribute values. The length of this vector must
 *   match the number of edges.
 * \return Error code.
 *
 * \sa \ref SETEASV for a simpler way.
 *
 * Time complexity: O(e+l), e is the number of edges, l is the
 * total length of the strings.
 */
int igraph_cattribute_EAS_setv(igraph_t *graph, const char *name,
                               const igraph_strvector_t *sv) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    /* Check length first */
    if (igraph_strvector_size(sv) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid edge attribute vector length", IGRAPH_EINVAL);
    }

    if (l) {
        /* Already present, check type */
        igraph_attribute_record_t *rec = VECTOR(*eal)[j];
        igraph_strvector_t *str = (igraph_strvector_t *)rec->value;
        if (rec->type != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_ERROR("Attribute type mismatch", IGRAPH_EINVAL);
        }
        igraph_strvector_clear(str);
        IGRAPH_CHECK(igraph_strvector_append(str, sv));
    } else {
        /* Add it */
        igraph_attribute_record_t *rec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
        igraph_strvector_t *str;
        if (!rec) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, rec);
        rec->type = IGRAPH_ATTRIBUTE_STRING;
        rec->name = strdup(name);
        if (!rec->name) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (char*)rec->name);
        str = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (!str) {
            IGRAPH_ERROR("Cannot add vertex attribute", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, str);
        rec->value = str;
        IGRAPH_CHECK(igraph_strvector_copy(str, sv));
        IGRAPH_FINALLY(igraph_strvector_destroy, str);
        IGRAPH_CHECK(igraph_vector_ptr_push_back(eal, rec));
        IGRAPH_FINALLY_CLEAN(4);
    }

    return 0;
}

static void igraph_i_cattribute_free_rec(igraph_attribute_record_t *rec) {

    if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
        igraph_vector_t *num = (igraph_vector_t*)rec->value;
        igraph_vector_destroy(num);
    } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
        igraph_strvector_t *str = (igraph_strvector_t*)rec->value;
        igraph_strvector_destroy(str);
    } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
        igraph_vector_bool_t *boolvec = (igraph_vector_bool_t*)rec->value;
        igraph_vector_bool_destroy(boolvec);
    }
    IGRAPH_FREE(rec->name);
    IGRAPH_FREE(rec->value);
    IGRAPH_FREE(rec);
}

/**
 * \function igraph_cattribute_remove_g
 * Remove a graph attribute
 *
 * \param graph The graph object.
 * \param name Name of the graph attribute to remove.
 *
 * \sa \ref DELGA for a simpler way.
 *
 */
void igraph_cattribute_remove_g(igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *gal = &attr->gal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(gal, name, &j);

    if (l) {
        igraph_i_cattribute_free_rec(VECTOR(*gal)[j]);
        igraph_vector_ptr_remove(gal, j);
    } else {
        IGRAPH_WARNING("Cannot remove non-existent graph attribute");
    }
}

/**
 * \function igraph_cattribute_remove_v
 * Remove a vertex attribute
 *
 * \param graph The graph object.
 * \param name Name of the vertex attribute to remove.
 *
 * \sa \ref DELVA for a simpler way.
 *
 */
void igraph_cattribute_remove_v(igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *val = &attr->val;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(val, name, &j);

    if (l) {
        igraph_i_cattribute_free_rec(VECTOR(*val)[j]);
        igraph_vector_ptr_remove(val, j);
    } else {
        IGRAPH_WARNING("Cannot remove non-existent graph attribute");
    }
}

/**
 * \function igraph_cattribute_remove_e
 * Remove an edge attribute
 *
 * \param graph The graph object.
 * \param name Name of the edge attribute to remove.
 *
 * \sa \ref DELEA for a simpler way.
 *
 */
void igraph_cattribute_remove_e(igraph_t *graph, const char *name) {

    igraph_i_cattributes_t *attr = graph->attr;
    igraph_vector_ptr_t *eal = &attr->eal;
    long int j;
    igraph_bool_t l = igraph_i_cattribute_find(eal, name, &j);

    if (l) {
        igraph_i_cattribute_free_rec(VECTOR(*eal)[j]);
        igraph_vector_ptr_remove(eal, j);
    } else {
        IGRAPH_WARNING("Cannot remove non-existent graph attribute");
    }
}

/**
 * \function igraph_cattribute_remove_all
 * Remove all graph/vertex/edge attributes
 *
 * \param graph The graph object.
 * \param g Boolean, whether to remove graph attributes.
 * \param v Boolean, whether to remove vertex attributes.
 * \param e Boolean, whether to remove edge attributes.
 *
 * \sa \ref DELGAS, \ref DELVAS, \ref DELEAS, \ref DELALL for simpler
 * ways.
 */
void igraph_cattribute_remove_all(igraph_t *graph, igraph_bool_t g,
                                  igraph_bool_t v, igraph_bool_t e) {

    igraph_i_cattributes_t *attr = graph->attr;

    if (g) {
        igraph_vector_ptr_t *gal = &attr->gal;
        long int i, n = igraph_vector_ptr_size(gal);
        for (i = 0; i < n; i++) {
            igraph_i_cattribute_free_rec(VECTOR(*gal)[i]);
        }
        igraph_vector_ptr_clear(gal);
    }
    if (v) {
        igraph_vector_ptr_t *val = &attr->val;
        long int i, n = igraph_vector_ptr_size(val);
        for (i = 0; i < n; i++) {
            igraph_i_cattribute_free_rec(VECTOR(*val)[i]);
        }
        igraph_vector_ptr_clear(val);
    }
    if (e) {
        igraph_vector_ptr_t *eal = &attr->eal;
        long int i, n = igraph_vector_ptr_size(eal);
        for (i = 0; i < n; i++) {
            igraph_i_cattribute_free_rec(VECTOR(*eal)[i]);
        }
        igraph_vector_ptr_clear(eal);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/iterators.c0000644000175100001710000016767600000000000023751 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_iterators.h"
#include "igraph_memory.h"
#include "igraph_interface.h"

#include 
#include 

/**
 * \section about_iterators About selectors, iterators
 *
 * Everything about vertices and vertex selectors also applies
 * to edges and edge selectors unless explicitly noted otherwise.
 *
 * The vertex (and edge) selector notion was introduced in igraph 0.2.
 * It is a way to reference a sequence of vertices or edges
 * independently of the graph.
 *
 * While this might sound quite mysterious, it is actually very
 * simple. For example, all vertices of a graph can be selected by
 * \ref igraph_vs_all() and the graph independence means that
 * \ref igraph_vs_all() is not parametrized by a graph object. That is,
 * \ref igraph_vs_all() is the general \em concept of selecting all vertices
 * of a graph. A vertex selector is then a way to specify the class of vertices
 * to be visited. The selector might specify that all vertices of a graph or
 * all the neighbours of a vertex are to be visited. A vertex selector is a
 * way of saying that you want to visit a bunch of vertices, as opposed to a
 * vertex iterator which is a concrete plan for visiting each of the
 * chosen vertices of a specific graph.
 *
 * To determine the actual vertex IDs implied by a vertex selector, you
 * need to apply the concept of selecting vertices to a specific graph object.
 * This can be accomplished by instantiating a vertex iterator using a
 * specific vertex selection concept and a specific graph object. The notion
 * of vertex iterators can be thought of in the following way. Given a
 * specific graph object and the class of vertices to be visited, a vertex
 * iterator is a road map, plan or route for how to visit the chosen
 * vertices.
 *
 * Some vertex selectors have \em immediate versions. These have the
 * prefix \c igraph_vss instead of \c igraph_vs, e.g. \ref igraph_vss_all()
 * instead of \ref igraph_vs_all(). The immediate versions are to be used in
 * the parameter list of the igraph functions, such as \ref igraph_degree().
 * These functions are not associated with any \type igraph_vs_t object, so
 * they have no separate constructors and destructors
 * (destroy functions).
 */

/**
 * \section about_vertex_selectors
 *
 * Vertex selectors are created by vertex selector constructors,
 * can be instantiated with \ref igraph_vit_create(), and are
 * destroyed with \ref igraph_vs_destroy().
 */

/**
 * \function igraph_vs_all
 * \brief Vertex set, all vertices of a graph.
 *
 * \param vs Pointer to an uninitialized \type igraph_vs_t object.
 * \return Error code.
 * \sa \ref igraph_vss_all(), \ref igraph_vs_destroy()
 *
 * This selector includes all vertices of a given graph in
 * increasing vertex id order.
 *
 * 
 * Time complexity: O(1).
 */

int igraph_vs_all(igraph_vs_t *vs) {
    vs->type = IGRAPH_VS_ALL;
    return 0;
}

/**
 * \function igraph_vss_all
 * \brief All vertices of a graph (immediate version).
 *
 * Immediate vertex selector for all vertices in a graph. It can
 * be used conveniently when some vertex property (e.g. betweenness,
 * degree, etc.) should be calculated for all vertices.
 *
 * \return A vertex selector for all vertices in a graph.
 * \sa \ref igraph_vs_all()
 *
 * Time complexity: O(1).
 */

igraph_vs_t igraph_vss_all(void) {
    igraph_vs_t allvs;
    allvs.type = IGRAPH_VS_ALL;
    return allvs;
}

/**
 * \function igraph_vs_adj
 * \brief Adjacent vertices of a vertex.
 *
 * All neighboring vertices of a given vertex are selected by this
 * selector. The \c mode argument controls the type of the neighboring
 * vertices to be selected. The vertices are visited in increasing vertex
 * ID order, as of igraph version 0.4.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \param vid Vertex ID, the center of the neighborhood.
 * \param mode Decides the type of the neighborhood for directed
 *        graphs. This parameter is ignored for undirected graphs.
 *        Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          All vertices to which there is a directed edge from \c vid. That
 *          is, all the out-neighbors of \c vid.
 *        \cli IGRAPH_IN
 *          All vertices from which there is a directed edge to \c vid. In
 *          other words, all the in-neighbors of \c vid.
 *        \cli IGRAPH_ALL
 *          All vertices to which or from which there is a directed edge
 *          from/to \c vid. That is, all the neighbors of \c vid considered
 *          as if the graph is undirected.
 *        \endclist
 * \return Error code.
 * \sa \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_vs_adj(igraph_vs_t *vs,
                  igraph_integer_t vid, igraph_neimode_t mode) {
    vs->type = IGRAPH_VS_ADJ;
    vs->data.adj.vid = vid;
    vs->data.adj.mode = mode;
    return 0;
}

/**
 * \function igraph_vs_nonadj
 * \brief Non-adjacent vertices of a vertex.
 *
 * All non-neighboring vertices of a given vertex. The \p mode
 * argument controls the type of neighboring vertices \em not to
 * select. Instead of selecting immediate neighbors of \c vid as is done by
 * \ref igraph_vs_adj(), the current function selects vertices that are \em not
 * immediate neighbors of \c vid.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \param vid Vertex ID, the \quote center \endquote of the
 *        non-neighborhood.
 * \param mode The type of neighborhood not to select in directed
 *        graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          All vertices will be selected except those to which there is a
 *          directed edge from \c vid. That is, we select all vertices
 *          excluding the out-neighbors of \c vid.
 *        \cli IGRAPH_IN
 *          All vertices will be selected except those from which there is a
 *          directed edge to \c vid. In other words, we select all vertices
 *          but the in-neighbors of \c vid.
 *        \cli IGRAPH_ALL
 *          All vertices will be selected except those from or to which there
 *          is a directed edge to or from \c vid. That is, we select all
 *          vertices of \c vid except for its immediate neighbors.
 *        \endclist
 * \return Error code.
 * \sa \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 *
 * \example examples/simple/igraph_vs_nonadj.c
 */

int igraph_vs_nonadj(igraph_vs_t *vs, igraph_integer_t vid,
                     igraph_neimode_t mode) {
    vs->type = IGRAPH_VS_NONADJ;
    vs->data.adj.vid = vid;
    vs->data.adj.mode = mode;
    return 0;
}

/**
 * \function igraph_vs_none
 * \brief Empty vertex set.
 *
 * Creates an empty vertex selector.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \return Error code.
 * \sa \ref igraph_vss_none(), \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_vs_none(igraph_vs_t *vs) {
    vs->type = IGRAPH_VS_NONE;
    return 0;
}

/**
 * \function igraph_vss_none
 * \brief Empty vertex set (immediate version).
 *
 * The immediate version of the empty vertex selector.
 *
 * \return An empty vertex selector.
 * \sa \ref igraph_vs_none()
 *
 * Time complexity: O(1).
 */

igraph_vs_t igraph_vss_none(void) {
    igraph_vs_t nonevs;
    nonevs.type = IGRAPH_VS_NONE;
    return nonevs;
}

/**
 * \function igraph_vs_1
 * \brief Vertex set with a single vertex.
 *
 * This vertex selector selects a single vertex.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \param vid The vertex id to be selected.
 * \return Error Code.
 * \sa \ref igraph_vss_1(), \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_vs_1(igraph_vs_t *vs, igraph_integer_t vid) {
    vs->type = IGRAPH_VS_1;
    vs->data.vid = vid;
    return 0;
}

/**
 * \function igraph_vss_1
 * \brief Vertex set with a single vertex (immediate version).
 *
 * The immediate version of the single-vertex selector.
 *
 * \param vid The vertex to be selected.
 * \return A vertex selector containing a single vertex.
 * \sa \ref igraph_vs_1()
 *
 * Time complexity: O(1).
 */

igraph_vs_t igraph_vss_1(igraph_integer_t vid) {
    igraph_vs_t onevs;
    onevs.type = IGRAPH_VS_1;
    onevs.data.vid = vid;
    return onevs;
}

/**
 * \function igraph_vs_vector
 * \brief Vertex set based on a vector.
 *
 * This function makes it possible to handle a \type vector_t
 * temporarily as a vertex selector. The vertex selector should be
 * thought of like a \em view to the vector. If you make changes to
 * the vector that also affects the vertex selector. Destroying the
 * vertex selector does not destroy the vector. (Of course.) Do not
 * destroy the vector before destroying the vertex selector, or you
 * might get strange behavior.
 *
 * \param vs Pointer to an uninitialized vertex selector.
 * \param v Pointer to a \type igraph_vector_t object.
 * \return Error code.
 * \sa \ref igraph_vss_vector(), \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 *
 * \example examples/simple/igraph_vs_vector.c
 */

int igraph_vs_vector(igraph_vs_t *vs,
                     const igraph_vector_t *v) {
    vs->type = IGRAPH_VS_VECTORPTR;
    vs->data.vecptr = v;
    return 0;
}

/**
 * \function igraph_vss_vector
 * \brief Vertex set based on a vector (immediate version).
 *
 * This is the immediate version of \ref igraph_vs_vector.
 *
 * \param v Pointer to a \type igraph_vector_t object.
 * \return A vertex selector object containing the vertices in the
 *         vector.
 * \sa \ref igraph_vs_vector()
 *
 * Time complexity: O(1).
 */

igraph_vs_t igraph_vss_vector(const igraph_vector_t *v) {
    igraph_vs_t vecvs;
    vecvs.type = IGRAPH_VS_VECTORPTR;
    vecvs.data.vecptr = v;
    return vecvs;
}

/**
 * \function igraph_vs_vector_small
 * \brief Create a vertex set by giving its elements.
 *
 * This function can be used to create a vertex selector with a couple
 * of vertices. Do not forget to include a -1 after the
 * last vertex id. The behavior of the function is undefined if you
 * don't use a -1 properly.
 *
 * 
 * Note that the vertex ids supplied will be parsed as
 * int's so you cannot supply arbitrarily large (too
 * large for int) vertex ids here.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \param ... Additional parameters, these will be the vertex ids to
 *        be included in the vertex selector. Supply a -1
 *        after the last vertex id.
 * \return Error code.
 * \sa \ref igraph_vs_destroy()
 *
 * Time complexity: O(n), the number of vertex ids supplied.
 */

int igraph_vs_vector_small(igraph_vs_t *vs, ...) {
    va_list ap;
    long int i, n = 0;
    vs->type = IGRAPH_VS_VECTOR;
    vs->data.vecptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (vs->data.vecptr == 0) {
        IGRAPH_ERROR("Cannot create vertex selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)vs->data.vecptr);

    va_start(ap, vs);
    while (1) {
        int num = va_arg(ap, int);
        if (num == -1) {
            break;
        }
        n++;
    }
    va_end(ap);

    IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)vs->data.vecptr, n);

    va_start(ap, vs);
    for (i = 0; i < n; i++) {
        VECTOR(*vs->data.vecptr)[i] = (igraph_real_t) va_arg(ap, int);
    }
    va_end(ap);

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

/**
 * \function igraph_vs_vector_copy
 * \brief Vertex set based on a vector, with copying.
 *
 * This function makes it possible to handle a \type vector_t
 * permanently as a vertex selector. The vertex selector creates a
 * copy of the original vector, so the vector can safely be destroyed
 * after creating the vertex selector. Changing the original vector
 * will not affect the vertex selector. The vertex selector is
 * responsible for deleting the copy made by itself.
 *
 * \param vs Pointer to an uninitialized vertex selector.
 * \param v Pointer to a \type igraph_vector_t object.
 * \return Error code.
 * \sa \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_vs_vector_copy(igraph_vs_t *vs,
                          const igraph_vector_t *v) {
    vs->type = IGRAPH_VS_VECTOR;
    vs->data.vecptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (vs->data.vecptr == 0) {
        IGRAPH_ERROR("Cannot create vertex selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)vs->data.vecptr);
    IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*)vs->data.vecptr, v));
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_vs_seq
 * \brief Vertex set, an interval of vertices.
 *
 * Creates a vertex selector containing all vertices with vertex id
 * equal to or bigger than \c from and equal to or smaller than \c
 * to.
 *
 * \param vs Pointer to an uninitialized vertex selector object.
 * \param from The first vertex id to be included in the vertex
 *        selector.
 * \param to The last vertex id to be included in the vertex
 *        selector.
 * \return Error code.
 * \sa \ref igraph_vss_seq(), \ref igraph_vs_destroy()
 *
 * Time complexity: O(1).
 *
 * \example examples/simple/igraph_vs_seq.c
 */

int igraph_vs_seq(igraph_vs_t *vs,
                  igraph_integer_t from, igraph_integer_t to) {
    vs->type = IGRAPH_VS_SEQ;
    vs->data.seq.from = from;
    vs->data.seq.to = to + 1;
    return 0;
}

/**
 * \function igraph_vss_seq
 * \brief An interval of vertices (immediate version).
 *
 * The immediate version of \ref igraph_vs_seq().
 *
 * \param from The first vertex id to be included in the vertex
 *        selector.
 * \param to The last vertex id to be included in the vertex
 *        selector.
 * \return Error code.
 * \sa \ref igraph_vs_seq()
 *
 * Time complexity: O(1).
 */

igraph_vs_t igraph_vss_seq(igraph_integer_t from, igraph_integer_t to) {
    igraph_vs_t vs;
    vs.type = IGRAPH_VS_SEQ;
    vs.data.seq.from = from;
    vs.data.seq.to = to + 1;
    return vs;
}

/**
 * \function igraph_vs_destroy
 * \brief Destroy a vertex set.
 *
 * This function should be called for all vertex selectors when they
 * are not needed. The memory allocated for the vertex selector will
 * be deallocated. Do not call this function on vertex selectors
 * created with the immediate versions of the vertex selector
 * constructors (starting with igraph_vss).
 *
 * \param vs Pointer to a vertex selector object.
 *
 * Time complexity: operating system dependent, usually O(1).
 */

void igraph_vs_destroy(igraph_vs_t *vs) {
    switch (vs->type) {
    case IGRAPH_VS_ALL:
    case IGRAPH_VS_ADJ:
    case IGRAPH_VS_NONE:
    case IGRAPH_VS_1:
    case IGRAPH_VS_VECTORPTR:
    case IGRAPH_VS_SEQ:
    case IGRAPH_VS_NONADJ:
        break;
    case IGRAPH_VS_VECTOR:
        igraph_vector_destroy((igraph_vector_t*)vs->data.vecptr);
        IGRAPH_FREE(vs->data.vecptr);
        break;
    default:
        break;
    }
}

/**
 * \function igraph_vs_is_all
 * \brief Check whether all vertices are included.
 *
 * This function checks whether the vertex selector object was created
 * by \ref igraph_vs_all() or \ref igraph_vss_all(). Note that the
 * vertex selector might contain all vertices in a given graph but if
 * it wasn't created by the two constructors mentioned here the return
 * value will be FALSE.
 *
 * \param vs Pointer to a vertex selector object.
 * \return TRUE (1) if the vertex selector contains all vertices and
 *         FALSE (0) otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs) {
    return vs->type == IGRAPH_VS_ALL;
}

int igraph_vs_as_vector(const igraph_t *graph, igraph_vs_t vs,
                        igraph_vector_t *v) {
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, vs, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_CHECK(igraph_vit_as_vector(&vit, v));

    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_vs_copy
 * \brief Creates a copy of a vertex selector.
 * \param src The selector being copied.
 * \param dest An uninitialized selector that will contain the copy.
 */
int igraph_vs_copy(igraph_vs_t* dest, const igraph_vs_t* src) {
    memcpy(dest, src, sizeof(igraph_vs_t));
    switch (dest->type) {
    case IGRAPH_VS_VECTOR:
        dest->data.vecptr = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!dest->data.vecptr) {
            IGRAPH_ERROR("Cannot copy vertex selector", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*)dest->data.vecptr,
                                        (igraph_vector_t*)src->data.vecptr));
        break;
    }
    return 0;
}

/**
 * \function igraph_vs_type
 * \brief Returns the type of the vertex selector.
 */
int igraph_vs_type(const igraph_vs_t *vs) {
    return vs->type;
}

/**
 * \function igraph_vs_size
 * \brief Returns the size of the vertex selector.
 *
 * The size of the vertex selector is the number of vertices it will
 * yield when it is iterated over.
 *
 * \param graph The graph over which we will iterate.
 * \param result The result will be returned here.
 */
int igraph_vs_size(const igraph_t *graph, const igraph_vs_t *vs,
                   igraph_integer_t *result) {
    igraph_vector_t vec;
    igraph_bool_t *seen;
    long i;

    switch (vs->type) {
    case IGRAPH_VS_NONE:
        *result = 0; return 0;

    case IGRAPH_VS_1:
        *result = 0;
        if (vs->data.vid < igraph_vcount(graph) && vs->data.vid >= 0) {
            *result = 1;
        }
        return 0;

    case IGRAPH_VS_SEQ:
        *result = vs->data.seq.to - vs->data.seq.from;
        return 0;

    case IGRAPH_VS_ALL:
        *result = igraph_vcount(graph); return 0;

    case IGRAPH_VS_ADJ:
        IGRAPH_VECTOR_INIT_FINALLY(&vec, 0);
        IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs->data.adj.vid, vs->data.adj.mode));
        *result = (igraph_integer_t) igraph_vector_size(&vec);
        igraph_vector_destroy(&vec);
        IGRAPH_FINALLY_CLEAN(1);
        return 0;

    case IGRAPH_VS_NONADJ:
        IGRAPH_VECTOR_INIT_FINALLY(&vec, 0);
        IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs->data.adj.vid, vs->data.adj.mode));
        *result = igraph_vcount(graph);
        seen = IGRAPH_CALLOC(*result, igraph_bool_t);
        if (seen == 0) {
            IGRAPH_ERROR("Cannot calculate selector length", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, seen);
        for (i = 0; i < igraph_vector_size(&vec); i++) {
            if (!seen[(long int)VECTOR(vec)[i]]) {
                (*result)--;
                seen[(long int)VECTOR(vec)[i]] = 1;
            }
        }
        igraph_free(seen);
        igraph_vector_destroy(&vec);
        IGRAPH_FINALLY_CLEAN(2);
        return 0;

    case IGRAPH_VS_VECTOR:
    case IGRAPH_VS_VECTORPTR:
        *result = (igraph_integer_t) igraph_vector_size((igraph_vector_t*)vs->data.vecptr);
        return 0;
    }

    IGRAPH_ERROR("Cannot calculate selector length, invalid selector type",
                 IGRAPH_EINVAL);
}

/***************************************************/

/**
 * \function igraph_vit_create
 * \brief Creates a vertex iterator from a vertex selector.
 *
 * This function instantiates a vertex selector object with a given
 * graph. This is the step when the actual vertex ids are created from
 * the \em logical notion of the vertex selector based on the graph.
 * E.g. a vertex selector created with \ref igraph_vs_all() contains
 * knowledge that \em all vertices are included in a (yet indefinite)
 * graph. When instantiating it a vertex iterator object is created,
 * this contains the actual vertex ids in the graph supplied as a
 * parameter.
 *
 * 
 * The same vertex selector object can be used to instantiate any
 * number vertex iterators.
 *
 * \param graph An \type igraph_t object, a graph.
 * \param vs A vertex selector object.
 * \param vit Pointer to an uninitialized vertex iterator object.
 * \return Error code.
 * \sa \ref igraph_vit_destroy().
 *
 * Time complexity: it depends on the vertex selector type. O(1) for
 * vertex selectors created with \ref igraph_vs_all(), \ref
 * igraph_vs_none(), \ref igraph_vs_1, \ref igraph_vs_vector, \ref
 * igraph_vs_seq(), \ref igraph_vs_vector(), \ref
 * igraph_vs_vector_small(). O(d) for \ref igraph_vs_adj(), d is the
 * number of vertex ids to be included in the iterator. O(|V|) for
 * \ref igraph_vs_nonadj(), |V| is the number of vertices in the graph.
 */

int igraph_vit_create(const igraph_t *graph,
                      igraph_vs_t vs, igraph_vit_t *vit) {
    igraph_vector_t vec;
    igraph_bool_t *seen;
    long int i, j, n;

    switch (vs.type) {
    case IGRAPH_VS_ALL:
        vit->type = IGRAPH_VIT_SEQ;
        vit->pos = 0;
        vit->start = 0;
        vit->end = igraph_vcount(graph);
        break;
    case IGRAPH_VS_ADJ:
        vit->type = IGRAPH_VIT_VECTOR;
        vit->pos = 0;
        vit->start = 0;
        vit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
        if (vit->vec == 0) {
            IGRAPH_ERROR("Cannot create iterator", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) vit->vec);
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)vit->vec, 0);
        IGRAPH_CHECK(igraph_neighbors(graph, (igraph_vector_t*)vit->vec,
                                      vs.data.adj.vid, vs.data.adj.mode));
        vit->end = igraph_vector_size(vit->vec);
        IGRAPH_FINALLY_CLEAN(2);
        break;
    case IGRAPH_VS_NONADJ:
        vit->type = IGRAPH_VIT_VECTOR;
        vit->pos = 0;
        vit->start = 0;
        vit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
        if (vit->vec == 0) {
            IGRAPH_ERROR("Cannot create iterator", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) vit->vec);
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t *) vit->vec, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&vec, 0);
        IGRAPH_CHECK(igraph_neighbors(graph, &vec,
                                      vs.data.adj.vid, vs.data.adj.mode));
        n = igraph_vcount(graph);
        seen = IGRAPH_CALLOC(n, igraph_bool_t);
        if (seen == 0) {
            IGRAPH_ERROR("Cannot create iterator", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, seen);
        for (i = 0; i < igraph_vector_size(&vec); i++) {
            if (! seen [ (long int) VECTOR(vec)[i] ] ) {
                n--;
                seen[ (long int) VECTOR(vec)[i] ] = 1;
            }
        }
        IGRAPH_CHECK(igraph_vector_resize((igraph_vector_t*)vit->vec, n));
        for (i = 0, j = 0; j < n; i++) {
            if (!seen[i]) {
                VECTOR(*vit->vec)[j++] = i;
            }
        }

        IGRAPH_FREE(seen);
        igraph_vector_destroy(&vec);
        vit->end = n;
        IGRAPH_FINALLY_CLEAN(4);
        break;
    case IGRAPH_VS_NONE:
        vit->type = IGRAPH_VIT_SEQ;
        vit->pos = 0;
        vit->start = 0;
        vit->end = 0;
        break;
    case IGRAPH_VS_1:
        vit->type = IGRAPH_VIT_SEQ;
        vit->pos = vs.data.vid;
        vit->start = vs.data.vid;
        vit->end = vs.data.vid + 1;
        if (vit->pos >= igraph_vcount(graph)) {
            IGRAPH_ERROR("Cannot create iterator, invalid vertex id", IGRAPH_EINVVID);
        }
        break;
    case IGRAPH_VS_VECTORPTR:
    case IGRAPH_VS_VECTOR:
        vit->type = IGRAPH_VIT_VECTORPTR;
        vit->pos = 0;
        vit->start = 0;
        vit->vec = vs.data.vecptr;
        vit->end = igraph_vector_size(vit->vec);
        if (!igraph_vector_isininterval(vit->vec, 0, igraph_vcount(graph) - 1)) {
            IGRAPH_ERROR("Cannot create iterator, invalid vertex id", IGRAPH_EINVVID);
        }
        break;
    case IGRAPH_VS_SEQ:
        vit->type = IGRAPH_VIT_SEQ;
        vit->pos = vs.data.seq.from;
        vit->start = vs.data.seq.from;
        vit->end = vs.data.seq.to;
        break;
    default:
        IGRAPH_ERROR("Cannot create iterator, invalid selector", IGRAPH_EINVAL);
        break;
    }
    return 0;
}

/**
 * \function igraph_vit_destroy
 * \brief Destroys a vertex iterator.
 *
 * 
 * Deallocates memory allocated for a vertex iterator.
 *
 * \param vit Pointer to an initialized vertex iterator object.
 * \sa \ref igraph_vit_create()
 *
 * Time complexity: operating system dependent, usually O(1).
 */

void igraph_vit_destroy(const igraph_vit_t *vit) {
    switch (vit->type) {
    case IGRAPH_VIT_SEQ:
    case IGRAPH_VIT_VECTORPTR:
        break;
    case IGRAPH_VIT_VECTOR:
        igraph_vector_destroy((igraph_vector_t*)vit->vec);
        igraph_free((igraph_vector_t*)vit->vec);
        break;
    default:
        /*     IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
        break;
    }
}

int igraph_vit_as_vector(const igraph_vit_t *vit, igraph_vector_t *v) {

    long int i;

    IGRAPH_CHECK(igraph_vector_resize(v, IGRAPH_VIT_SIZE(*vit)));

    switch (vit->type) {
    case IGRAPH_VIT_SEQ:
        for (i = 0; i < IGRAPH_VIT_SIZE(*vit); i++) {
            VECTOR(*v)[i] = vit->start + i;
        }
        break;
    case IGRAPH_VIT_VECTOR:
    case IGRAPH_VIT_VECTORPTR:
        for (i = 0; i < IGRAPH_VIT_SIZE(*vit); i++) {
            VECTOR(*v)[i] = VECTOR(*vit->vec)[i];
        }
        break;
    default:
        IGRAPH_ERROR("Cannot convert to vector, unknown iterator type",
                     IGRAPH_EINVAL);
        break;
    }

    return 0;
}

/*******************************************************/

/**
 * \function igraph_es_all
 * \brief Edge set, all edges.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param order Constant giving the order in which the edges will be
 *        included in the selector. Possible values:
 *        \c IGRAPH_EDGEORDER_ID, edge id order.
 *        \c IGRAPH_EDGEORDER_FROM, vertex id order, the id of the
 *           \em source vertex counts for directed graphs. The order
 *           of the incident edges of a given vertex is arbitrary.
 *        \c IGRAPH_EDGEORDER_TO, vertex id order, the id of the \em
 *           target vertex counts for directed graphs. The order
 *           of the incident edges of a given vertex is arbitrary.
 *        For undirected graph the latter two is the same.
 * \return Error code.
 * \sa \ref igraph_ess_all(), \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_all(igraph_es_t *es,
                  igraph_edgeorder_type_t order) {
    switch (order) {
    case IGRAPH_EDGEORDER_ID:
        es->type = IGRAPH_ES_ALL;
        break;
    case IGRAPH_EDGEORDER_FROM:
        es->type = IGRAPH_ES_ALLFROM;
        break;
    case IGRAPH_EDGEORDER_TO:
        es->type = IGRAPH_ES_ALLTO;
        break;
    default:
        IGRAPH_ERROR("Invalid edge order, cannot create selector", IGRAPH_EINVAL);
        break;
    }
    return 0;
}

/**
 * \function igraph_ess_all
 * \brief Edge set, all edges (immediate version)
 *
 * The immediate version of the all-edges selector.
 *
 * \param order Constant giving the order of the edges in the edge
 *        selector. See \ref igraph_es_all() for the possible values.
 * \return The edge selector.
 * \sa \ref igraph_es_all()
 *
 * Time complexity: O(1).
 */

igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order) {
    igraph_es_t es;
    igraph_es_all(&es, order); /* cannot fail */
    return es;
}

/**
 * \function igraph_es_incident
 * \brief Edges incident on a given vertex.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param vid Vertex id, of which the incident edges will be
 *        selected.
 * \param mode Constant giving the type of the incident edges to
 *        select. This is ignored for undirected graphs. Possible values:
 *        \c IGRAPH_OUT, outgoing edges;
 *        \c IGRAPH_IN, incoming edges;
 *        \c IGRAPH_ALL, all edges.
 * \return Error code.
 * \sa \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_incident(igraph_es_t *es,
                       igraph_integer_t vid, igraph_neimode_t mode) {
    es->type = IGRAPH_ES_INCIDENT;
    es->data.incident.vid = vid;
    es->data.incident.mode = mode;
    return 0;
}

/**
 * \function igraph_es_none
 * \brief Empty edge selector.
 *
 * \param es Pointer to an uninitialized edge selector object to
 * initialize.
 * \return Error code.
 * \sa \ref igraph_ess_none(), \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_none(igraph_es_t *es) {
    es->type = IGRAPH_ES_NONE;
    return 0;
}

/**
 * \function igraph_ess_none
 * \brief Immediate empty edge selector.
 *
 * 
 * Immediate version of the empty edge selector.
 *
 * \return Initialized empty edge selector.
 * \sa \ref igraph_es_none()
 *
 * Time complexity: O(1).
 */

igraph_es_t igraph_ess_none(void) {
    igraph_es_t es;
    es.type = IGRAPH_ES_NONE;
    return es;
}

/**
 * \function igraph_es_1
 * \brief Edge selector containing a single edge.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param eid Edge id of the edge to select.
 * \return Error code.
 * \sa \ref igraph_ess_1(), \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_1(igraph_es_t *es, igraph_integer_t eid) {
    es->type = IGRAPH_ES_1;
    es->data.eid = eid;
    return 0;
}

/**
 * \function igraph_ess_1
 * \brief Immediate version of the single edge edge selector.
 *
 * \param eid The id of the edge.
 * \return The edge selector.
 * \sa \ref igraph_es_1()
 *
 * Time complexity: O(1).
 */

igraph_es_t igraph_ess_1(igraph_integer_t eid) {
    igraph_es_t es;
    es.type = IGRAPH_ES_1;
    es.data.eid = eid;
    return es;
}

/**
 * \function igraph_es_vector
 * \brief Handle a vector as an edge selector.
 *
 * 
 * Creates an edge selector which serves as a view to a vector
 * containing edge ids. Do not destroy the vector before destroying
 * the view.
 *
 * Many views can be created to the same vector.
 *
 * \param es Pointer to an uninitialized edge selector.
 * \param v Vector containing edge ids.
 * \return Error code.
 * \sa \ref igraph_ess_vector(), \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_vector(igraph_es_t *es,
                     const igraph_vector_t *v) {
    es->type = IGRAPH_ES_VECTORPTR;
    es->data.vecptr = v;
    return 0;
}

/**
 * \function igraph_es_vector_copy
 * \brief Edge set, based on a vector, with copying.
 *
 *
 * This function makes it possible to handle a \type vector_t
 * permanently as an edge selector. The edge selector creates a
 * copy of the original vector, so the vector can safely be destroyed
 * after creating the edge selector. Changing the original vector
 * will not affect the edge selector. The edge selector is
 * responsible for deleting the copy made by itself.
 *
 * \param es Pointer to an uninitialized edge selector.
 * \param v Pointer to a \type igraph_vector_t object.
 * \return Error code.
 * \sa \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_vector_copy(igraph_es_t *es, const igraph_vector_t *v) {
    es->type = IGRAPH_ES_VECTOR;
    es->data.vecptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.vecptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)es->data.vecptr);
    IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*)es->data.vecptr, v));
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_ess_vector
 * \brief Immediate vector view edge selector.
 *
 * 
 * This is the immediate version of the vector of edge ids edge
 * selector.
 *
 * \param v The vector of edge ids.
 * \return Edge selector, initialized.
 * \sa \ref igraph_es_vector()
 *
 * Time complexity: O(1).
 */

igraph_es_t igraph_ess_vector(const igraph_vector_t *v) {
    igraph_es_t es;
    es.type = IGRAPH_ES_VECTORPTR;
    es.data.vecptr = v;
    return es;
}

/**
 * \function igraph_es_fromto
 * \brief Edge selector, all edges between two vertex sets.
 *
 * 
 * This function is not implemented yet.
 *
 * \param es Pointer to an uninitialized edge selector.
 * \param from Vertex selector, their outgoing edges will be
 *        selected.
 * \param to Vertex selector, their incoming edges will be selected
 *        from the previous selection.
 * \return Error code.
 * \sa \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_fromto(igraph_es_t *es,
                     igraph_vs_t from, igraph_vs_t to) {

    IGRAPH_UNUSED(es); IGRAPH_UNUSED(from); IGRAPH_UNUSED(to);
    IGRAPH_ERROR("igraph_es_fromto not implemented yet", IGRAPH_UNIMPLEMENTED);
    /* TODO */
}

/**
 * \function igraph_es_seq
 * \brief Edge selector, a sequence of edge ids.
 *
 * All edge ids between from and to will be
 * included in the edge selection. This includes from and
 * excludes to.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param from The first edge id to be included.
 * \param to The last edge id to be included.
 * \return Error code.
 * \sa \ref igraph_ess_seq(), \ref igraph_es_destroy()
 *
 * Time complexity: O(1).
 */

int igraph_es_seq(igraph_es_t *es,
                  igraph_integer_t from, igraph_integer_t to) {
    es->type = IGRAPH_ES_SEQ;
    es->data.seq.from = from;
    es->data.seq.to = to;
    return 0;
}

/**
 * \function igraph_ess_seq
 * \brief Immediate version of the sequence edge selector.
 *
 * \param from The first edge id to include.
 * \param to The last edge id to include.
 * \return The initialized edge selector.
 * \sa \ref igraph_es_seq()
 *
 * Time complexity: O(1).
 */

igraph_es_t igraph_ess_seq(igraph_integer_t from, igraph_integer_t to) {
    igraph_es_t es;
    es.type = IGRAPH_ES_SEQ;
    es.data.seq.from = from;
    es.data.seq.to = to;
    return es;
}

/**
 * \function igraph_es_pairs
 * \brief Edge selector, multiple edges defined by their endpoints in a vector.
 *
 * The edges between the given pairs of vertices will be included in the
 * edge selection. The vertex pairs must be defined in the vector v,
 * the first element of the vector is the first vertex of the first edge
 * to be selected, the second element is the second vertex of the first
 * edge, the third element is the first vertex of the second edge and
 * so on.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param v The vector containing the endpoints of the edges.
 * \param directed Whether the graph is directed or not.
 * \return Error code.
 * \sa \ref igraph_es_pairs_small(), \ref igraph_es_destroy()
 *
 * Time complexity: O(n), the number of edges being selected.
 *
 * \example examples/simple/igraph_es_pairs.c
 */

int igraph_es_pairs(igraph_es_t *es, const igraph_vector_t *v,
                    igraph_bool_t directed) {
    es->type = IGRAPH_ES_PAIRS;
    es->data.path.mode = directed;
    es->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.path.ptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) es->data.path.ptr);

    IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*) es->data.path.ptr, v));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_es_pairs_small
 * \brief Edge selector, multiple edges defined by their endpoints as arguments.
 *
 * The edges between the given pairs of vertices will be included in the
 * edge selection. The vertex pairs must be given as the arguments of the
 * function call, the third argument is the first vertex of the first edge,
 * the fourth argument is the second vertex of the first edge, the fifth
 * is the first vertex of the second edge and so on. The last element of the
 * argument list must be -1 to denote the end of the argument list.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param directed Whether the graph is directed or not.
 * \return Error code.
 * \sa \ref igraph_es_pairs(), \ref igraph_es_destroy()
 *
 * Time complexity: O(n), the number of edges being selected.
 */

int igraph_es_pairs_small(igraph_es_t *es, igraph_bool_t directed, ...) {
    va_list ap;
    long int i, n = 0;
    es->type = IGRAPH_ES_PAIRS;
    es->data.path.mode = directed;
    es->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.path.ptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)es->data.path.ptr);

    va_start(ap, directed);
    while (1) {
        int num = va_arg(ap, int);
        if (num == -1) {
            break;
        }
        n++;
    }
    va_end(ap);

    IGRAPH_VECTOR_INIT_FINALLY( (igraph_vector_t*) es->data.path.ptr, n);

    va_start(ap, directed);
    for (i = 0; i < n; i++) {
        VECTOR(*es->data.path.ptr)[i] = (igraph_real_t) va_arg(ap, int);
    }
    va_end(ap);

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

int igraph_es_multipairs(igraph_es_t *es, const igraph_vector_t *v,
                         igraph_bool_t directed) {
    es->type = IGRAPH_ES_MULTIPAIRS;
    es->data.path.mode = directed;
    es->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.path.ptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) es->data.path.ptr);

    IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*) es->data.path.ptr, v));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_es_path
 * \brief Edge selector, edge ids on a path.
 *
 * This function takes a vector of vertices and creates a selector of
 * edges between those vertices. Vector {0, 3, 4, 7} will select edges
 * (0 -> 3), (3 -> 4), (4 -> 7). If these edges don't exist then trying
 * to create an iterator using this selector will fail.
 *
 * \param es Pointer to an uninitialized edge selector object.
 * \param v Pointer to a vector of vertex id's along the path.
 * \param directed If edge directions should be taken into account. This
 *                 will be ignored if the graph to select from is undirected.
 * \return Error code.
 * \sa \ref igraph_es_destroy()
 *
 * Time complexity: O(n), the number of vertices.
 */
int igraph_es_path(igraph_es_t *es, const igraph_vector_t *v,
                   igraph_bool_t directed) {
    es->type = IGRAPH_ES_PATH;
    es->data.path.mode = directed;
    es->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.path.ptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) es->data.path.ptr);

    IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*) es->data.path.ptr, v));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

int igraph_es_path_small(igraph_es_t *es, igraph_bool_t directed, ...) {
    va_list ap;
    long int i, n = 0;
    es->type = IGRAPH_ES_PATH;
    es->data.path.mode = directed;
    es->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
    if (es->data.path.ptr == 0) {
        IGRAPH_ERROR("Cannot create edge selector", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)es->data.path.ptr);

    va_start(ap, directed);
    while (1) {
        int num = va_arg(ap, int);
        if (num == -1) {
            break;
        }
        n++;
    }
    va_end(ap);

    IGRAPH_VECTOR_INIT_FINALLY( (igraph_vector_t*) es->data.path.ptr, n);

    va_start(ap, directed);
    for (i = 0; i < n; i++) {
        VECTOR(*es->data.path.ptr)[i] = (igraph_real_t) va_arg(ap, int);
    }
    va_end(ap);

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

/**
 * \function igraph_es_destroy
 * \brief Destroys an edge selector object.
 *
 * 
 * Call this function on an edge selector when it is not needed any
 * more. Do \em not call this function on edge selectors created by
 * immediate constructors, those don't need to be destroyed.
 *
 * \param es Pointer to an edge selector object.
 *
 * Time complexity: operating system dependent, usually O(1).
 */

void igraph_es_destroy(igraph_es_t *es) {
    switch (es->type) {
    case IGRAPH_ES_ALL:
    case IGRAPH_ES_ALLFROM:
    case IGRAPH_ES_ALLTO:
    case IGRAPH_ES_INCIDENT:
    case IGRAPH_ES_NONE:
    case IGRAPH_ES_1:
    case IGRAPH_ES_VECTORPTR:
    case IGRAPH_ES_SEQ:
        break;
    case IGRAPH_ES_VECTOR:
        igraph_vector_destroy((igraph_vector_t*)es->data.vecptr);
        IGRAPH_FREE(es->data.vecptr);
        break;
    case IGRAPH_ES_PAIRS:
    case IGRAPH_ES_PATH:
    case IGRAPH_ES_MULTIPAIRS:
        igraph_vector_destroy((igraph_vector_t*)es->data.path.ptr);
        IGRAPH_FREE(es->data.path.ptr);
        break;
    default:
        break;
    }
}

/**
 * \function igraph_es_is_all
 * \brief Check whether an edge selector includes all edges.
 *
 * \param es Pointer to an edge selector object.
 * \return TRUE (1) if es was created with \ref
 * igraph_es_all() or \ref igraph_ess_all(), and FALSE (0) otherwise.
 *
 * Time complexity: O(1).
 */

igraph_bool_t igraph_es_is_all(const igraph_es_t *es) {
    return es->type == IGRAPH_ES_ALL;
}

/**
 * \function igraph_es_copy
 * \brief Creates a copy of an edge selector.
 * \param src The selector being copied.
 * \param dest An uninitialized selector that will contain the copy.
 * \sa \ref igraph_es_destroy()
 */
int igraph_es_copy(igraph_es_t* dest, const igraph_es_t* src) {
    memcpy(dest, src, sizeof(igraph_es_t));
    switch (dest->type) {
    case IGRAPH_ES_VECTOR:
        dest->data.vecptr = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!dest->data.vecptr) {
            IGRAPH_ERROR("Cannot copy edge selector", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*)dest->data.vecptr,
                                        (igraph_vector_t*)src->data.vecptr));
        break;
    case IGRAPH_ES_PATH:
    case IGRAPH_ES_PAIRS:
    case IGRAPH_ES_MULTIPAIRS:
        dest->data.path.ptr = IGRAPH_CALLOC(1, igraph_vector_t);
        if (!dest->data.path.ptr) {
            IGRAPH_ERROR("Cannot copy edge selector", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_copy((igraph_vector_t*)dest->data.path.ptr,
                                        (igraph_vector_t*)src->data.path.ptr));
        break;
    }
    return 0;
}

/**
 * \function igraph_es_as_vector
 * \brief Transform edge selector into vector.
 *
 * 
 * Call this function on an edge selector to transform it into a vector.
 * This is only implemented for sequence and vector selectors. If the
 * edges do not exist in the graph, this will result in an error.
 *
 * \param graph Pointer to a graph to check if the edges in the selector exist.
 * \param es An edge selector object.
 * \param v Pointer to initialized vector. The result will be stored here.
 *
 * Time complexity: O(n), the number of edges in the selector.
 */
int igraph_es_as_vector(const igraph_t *graph, igraph_es_t es,
                        igraph_vector_t *v) {
    igraph_eit_t eit;

    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);
    IGRAPH_CHECK(igraph_eit_as_vector(&eit, v));

    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_es_type
 * \brief Returns the type of the edge selector.
 */
int igraph_es_type(const igraph_es_t *es) {
    return es->type;
}

static int igraph_i_es_pairs_size(const igraph_t *graph,
                                  const igraph_es_t *es, igraph_integer_t *result);
static int igraph_i_es_path_size(const igraph_t *graph,
                                 const igraph_es_t *es, igraph_integer_t *result);
static int igraph_i_es_multipairs_size(const igraph_t *graph,
                                       const igraph_es_t *es, igraph_integer_t *result);

/**
 * \function igraph_es_size
 * \brief Returns the size of the edge selector.
 *
 * The size of the edge selector is the number of edges it will
 * yield when it is iterated over.
 *
 * \param graph The graph over which we will iterate.
 * \param result The result will be returned here.
 */
int igraph_es_size(const igraph_t *graph, const igraph_es_t *es,
                   igraph_integer_t *result) {
    igraph_vector_t v;

    switch (es->type) {
    case IGRAPH_ES_ALL:
        *result = igraph_ecount(graph);
        return 0;

    case IGRAPH_ES_ALLFROM:
        *result = igraph_ecount(graph);
        return 0;

    case IGRAPH_ES_ALLTO:
        *result = igraph_ecount(graph);
        return 0;

    case IGRAPH_ES_INCIDENT:
        IGRAPH_VECTOR_INIT_FINALLY(&v, 0);
        IGRAPH_CHECK(igraph_incident(graph, &v,
                                     es->data.incident.vid, es->data.incident.mode));
        *result = (igraph_integer_t) igraph_vector_size(&v);
        igraph_vector_destroy(&v);
        IGRAPH_FINALLY_CLEAN(1);
        return 0;

    case IGRAPH_ES_NONE:
        *result = 0;
        return 0;

    case IGRAPH_ES_1:
        if (es->data.eid < igraph_ecount(graph) && es->data.eid >= 0) {
            *result = 1;
        } else {
            *result = 0;
        }
        return 0;

    case IGRAPH_ES_VECTOR:
    case IGRAPH_ES_VECTORPTR:
        *result = (igraph_integer_t) igraph_vector_size((igraph_vector_t*)es->data.vecptr);
        return 0;

    case IGRAPH_ES_SEQ:
        *result = es->data.seq.to - es->data.seq.from;
        return 0;

    case IGRAPH_ES_PAIRS:
        IGRAPH_CHECK(igraph_i_es_pairs_size(graph, es, result));
        return 0;

    case IGRAPH_ES_PATH:
        IGRAPH_CHECK(igraph_i_es_path_size(graph, es, result));
        return 0;

    case IGRAPH_ES_MULTIPAIRS:
        IGRAPH_CHECK(igraph_i_es_multipairs_size(graph, es, result));
        return 0;

    default:
        IGRAPH_ERROR("Cannot calculate selector length, invalid selector type",
                     IGRAPH_EINVAL);
    }
}

static int igraph_i_es_pairs_size(const igraph_t *graph,
                                  const igraph_es_t *es, igraph_integer_t *result) {
    long int n = igraph_vector_size(es->data.path.ptr);
    long int no_of_nodes = igraph_vcount(graph);
    long int i;

    if (n % 2 != 0) {
        IGRAPH_ERROR("Cannot calculate edge selector length from odd number of vertices",
                     IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(es->data.path.ptr, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot calculate edge selector length", IGRAPH_EINVVID);
    }

    *result = (igraph_integer_t) (n / 2);
    /* Check for the existence of all edges */
    for (i = 0; i < *result; i++) {
        long int from = (long int) VECTOR(*es->data.path.ptr)[2 * i];
        long int to = (long int) VECTOR(*es->data.path.ptr)[2 * i + 1];
        igraph_integer_t eid;
        IGRAPH_CHECK(igraph_get_eid(graph, &eid, (igraph_integer_t) from,
                                    (igraph_integer_t) to, es->data.path.mode,
                                    /*error=*/ 1));
    }

    return 0;
}

static int igraph_i_es_path_size(const igraph_t *graph,
                                 const igraph_es_t *es, igraph_integer_t *result) {
    long int n = igraph_vector_size(es->data.path.ptr);
    long int no_of_nodes = igraph_vcount(graph);
    long int i;

    if (!igraph_vector_isininterval(es->data.path.ptr, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot calculate selector length", IGRAPH_EINVVID);
    }

    if (n <= 1) {
        *result = 0;
    } else {
        *result = (igraph_integer_t) (n - 1);
    }
    for (i = 0; i < *result; i++) {
        long int from = (long int) VECTOR(*es->data.path.ptr)[i];
        long int to = (long int) VECTOR(*es->data.path.ptr)[i + 1];
        igraph_integer_t eid;
        IGRAPH_CHECK(igraph_get_eid(graph, &eid, (igraph_integer_t) from,
                                    (igraph_integer_t) to, es->data.path.mode,
                                    /*error=*/ 1));
    }

    return 0;
}

static int igraph_i_es_multipairs_size(const igraph_t *graph,
                                       const igraph_es_t *es, igraph_integer_t *result) {
    IGRAPH_UNUSED(graph); IGRAPH_UNUSED(es); IGRAPH_UNUSED(result);
    IGRAPH_ERROR("Cannot calculate edge selector length", IGRAPH_UNIMPLEMENTED);
}

/**************************************************/

static int igraph_i_eit_create_allfromto(const igraph_t *graph,
                                         igraph_eit_t *eit,
                                         igraph_neimode_t mode);
static int igraph_i_eit_pairs(const igraph_t *graph,
                              igraph_es_t es, igraph_eit_t *eit);
static int igraph_i_eit_multipairs(const igraph_t *graph,
                                   igraph_es_t es, igraph_eit_t *eit);
static int igraph_i_eit_path(const igraph_t *graph,
                             igraph_es_t es, igraph_eit_t *eit);

static int igraph_i_eit_create_allfromto(const igraph_t *graph,
                                         igraph_eit_t *eit,
                                         igraph_neimode_t mode) {
    igraph_vector_t *vec;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int i;

    vec = IGRAPH_CALLOC(1, igraph_vector_t);
    if (vec == 0) {
        IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, vec);
    IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
    IGRAPH_CHECK(igraph_vector_reserve(vec, no_of_edges));

    if (igraph_is_directed(graph)) {
        igraph_vector_t adj;
        IGRAPH_VECTOR_INIT_FINALLY(&adj, 0);
        for (i = 0; i < no_of_nodes; i++) {
            igraph_incident(graph, &adj, (igraph_integer_t) i, mode);
            igraph_vector_append(vec, &adj);
        }
        igraph_vector_destroy(&adj);
        IGRAPH_FINALLY_CLEAN(1);

    } else {

        igraph_vector_t adj;
        igraph_bool_t *added;
        long int j;
        IGRAPH_VECTOR_INIT_FINALLY(&adj, 0);
        added = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
        if (added == 0) {
            IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, added);
        for (i = 0; i < no_of_nodes; i++) {
            igraph_incident(graph, &adj, (igraph_integer_t) i, IGRAPH_ALL);
            for (j = 0; j < igraph_vector_size(&adj); j++) {
                if (!added[ (long int)VECTOR(adj)[j] ]) {
                    igraph_vector_push_back(vec, VECTOR(adj)[j]);
                    added[ (long int)VECTOR(adj)[j] ] += 1;
                }
            }
        }
        igraph_vector_destroy(&adj);
        IGRAPH_FREE(added);
        IGRAPH_FINALLY_CLEAN(2);
    }

    eit->type = IGRAPH_EIT_VECTOR;
    eit->pos = 0;
    eit->start = 0;
    eit->vec = vec;
    eit->end = igraph_vector_size(eit->vec);

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

static int igraph_i_eit_pairs(const igraph_t *graph,
                              igraph_es_t es, igraph_eit_t *eit) {
    long int n = igraph_vector_size(es.data.path.ptr);
    long int no_of_nodes = igraph_vcount(graph);
    long int i;

    if (n % 2 != 0) {
        IGRAPH_ERROR("Cannot create edge iterator from odd number of vertices",
                     IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(es.data.path.ptr, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_EINVVID);
    }

    eit->type = IGRAPH_EIT_VECTOR;
    eit->pos = 0;
    eit->start = 0;
    eit->end = n / 2;
    eit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
    if (eit->vec == 0) {
        IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)eit->vec);
    IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)eit->vec, n / 2);

    for (i = 0; i < igraph_vector_size(eit->vec); i++) {
        long int from = (long int) VECTOR(*es.data.path.ptr)[2 * i];
        long int to = (long int) VECTOR(*es.data.path.ptr)[2 * i + 1];
        igraph_integer_t eid;
        IGRAPH_CHECK(igraph_get_eid(graph, &eid, (igraph_integer_t) from,
                                    (igraph_integer_t) to, es.data.path.mode,
                                    /*error=*/ 1));
        VECTOR(*eit->vec)[i] = eid;
    }

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

static int igraph_i_eit_multipairs(const igraph_t *graph,
                                   igraph_es_t es, igraph_eit_t *eit) {
    long int n = igraph_vector_size(es.data.path.ptr);
    long int no_of_nodes = igraph_vcount(graph);

    if (n % 2 != 0) {
        IGRAPH_ERROR("Cannot create edge iterator from odd number of vertices",
                     IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(es.data.path.ptr, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_EINVVID);
    }

    eit->type = IGRAPH_EIT_VECTOR;
    eit->pos = 0;
    eit->start = 0;
    eit->end = n / 2;
    eit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
    if (eit->vec == 0) {
        IGRAPH_ERROR("Cannot create edge iterator", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)eit->vec);
    IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)eit->vec, n / 2);

    IGRAPH_CHECK(igraph_get_eids_multi(graph, (igraph_vector_t *) eit->vec,
                                       /*pairs=*/ es.data.path.ptr, /*path=*/ 0,
                                       es.data.path.mode, /*error=*/ 1));

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

static int igraph_i_eit_path(const igraph_t *graph,
                             igraph_es_t es, igraph_eit_t *eit) {
    long int n = igraph_vector_size(es.data.path.ptr);
    long int no_of_nodes = igraph_vcount(graph);
    long int i, len;

    if (!igraph_vector_isininterval(es.data.path.ptr, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot create edge iterator.", IGRAPH_EINVVID);
    }

    if (n <= 1) {
        len = 0;
    } else {
        len = n - 1;
    }

    eit->type = IGRAPH_EIT_VECTOR;
    eit->pos = 0;
    eit->start = 0;
    eit->end = len;
    eit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
    if (eit->vec == 0) {
        IGRAPH_ERROR("Cannot create edge iterator.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, (igraph_vector_t*)eit->vec);

    IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t *)eit->vec, len);

    for (i = 0; i < len; i++) {
        long int from = (long int) VECTOR(*es.data.path.ptr)[i];
        long int to = (long int) VECTOR(*es.data.path.ptr)[i + 1];
        igraph_integer_t eid;
        IGRAPH_CHECK(igraph_get_eid(graph, &eid, (igraph_integer_t) from,
                                    (igraph_integer_t) to, es.data.path.mode,
                                    /*error=*/ 1));
        VECTOR(*eit->vec)[i] = eid;
    }

    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}

/**
 * \function igraph_eit_create
 * \brief Creates an edge iterator from an edge selector.
 *
 * 
 * This function creates an edge iterator based on an edge selector
 * and a graph.
 *
 * 
 * The same edge selector can be used to create many edge iterators,
 * also for different graphs.
 *
 * \param graph An \type igraph_t object for which the edge selector
 *        will be instantiated.
 * \param es The edge selector to instantiate.
 * \param eit Pointer to an uninitialized edge iterator.
 * \return Error code.
 * \sa \ref igraph_eit_destroy()
 *
 * Time complexity: depends on the type of the edge selector. For edge
 * selectors created by \ref igraph_es_all(), \ref igraph_es_none(),
 * \ref igraph_es_1(), igraph_es_vector(), igraph_es_seq() it is
 * O(1). For \ref igraph_es_incident() it is O(d) where d is the number of
 * incident edges of the vertex.
 */

int igraph_eit_create(const igraph_t *graph,
                      igraph_es_t es, igraph_eit_t *eit) {
    switch (es.type) {
    case IGRAPH_ES_ALL:
        eit->type = IGRAPH_EIT_SEQ;
        eit->pos = 0;
        eit->start = 0;
        eit->end = igraph_ecount(graph);
        break;
    case IGRAPH_ES_ALLFROM:
        IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_OUT));
        break;
    case IGRAPH_ES_ALLTO:
        IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_IN));
        break;
    case IGRAPH_ES_INCIDENT:
        eit->type = IGRAPH_EIT_VECTOR;
        eit->pos = 0;
        eit->start = 0;
        eit->vec = IGRAPH_CALLOC(1, igraph_vector_t);
        if (eit->vec == 0) {
            IGRAPH_ERROR("Cannot create iterator.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, (igraph_vector_t*) eit->vec);
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)eit->vec, 0);
        IGRAPH_CHECK(igraph_incident(graph, (igraph_vector_t*)eit->vec,
                                     es.data.incident.vid, es.data.incident.mode));
        eit->end = igraph_vector_size(eit->vec);
        IGRAPH_FINALLY_CLEAN(2);
        break;
    case IGRAPH_ES_NONE:
        eit->type = IGRAPH_EIT_SEQ;
        eit->pos = 0;
        eit->start = 0;
        eit->end = 0;
        break;
    case IGRAPH_ES_1:
        eit->type = IGRAPH_EIT_SEQ;
        eit->pos = es.data.eid;
        eit->start = es.data.eid;
        eit->end = es.data.eid + 1;
        if (eit->pos >= igraph_ecount(graph)) {
            IGRAPH_ERROR("Cannot create iterator, invalid edge id.", IGRAPH_EINVAL);
        }
        break;
    case IGRAPH_ES_VECTOR:
    case IGRAPH_ES_VECTORPTR:
        eit->type = IGRAPH_EIT_VECTORPTR;
        eit->pos = 0;
        eit->start = 0;
        eit->vec = es.data.vecptr;
        eit->end = igraph_vector_size(eit->vec);
        if (!igraph_vector_isininterval(eit->vec, 0, igraph_ecount(graph) - 1)) {
            IGRAPH_ERROR("Cannot create iterator, invalid edge id.", IGRAPH_EINVAL);
        }
        break;
    case IGRAPH_ES_SEQ:
        eit->type = IGRAPH_EIT_SEQ;
        eit->pos = es.data.seq.from;
        eit->start = es.data.seq.from;
        eit->end = es.data.seq.to;
        if (eit->start < 0) {
            IGRAPH_ERROR("Cannot create iterator, invalid edge id.", IGRAPH_EINVAL);
        }
        if (eit->end < 0) {
            IGRAPH_ERROR("Cannot create iterator, invalid edge id.", IGRAPH_EINVAL);
        }
        if (eit->start >= igraph_ecount(graph)) {
            IGRAPH_ERROR("Cannot create iterator, starting edge greater than number of edges.", IGRAPH_EINVAL);
        }
        break;
    case IGRAPH_ES_PAIRS:
        IGRAPH_CHECK(igraph_i_eit_pairs(graph, es, eit));
        break;
    case IGRAPH_ES_MULTIPAIRS:
        IGRAPH_CHECK(igraph_i_eit_multipairs(graph, es, eit));
        break;
    case IGRAPH_ES_PATH:
        IGRAPH_CHECK(igraph_i_eit_path(graph, es, eit));
        break;
    default:
        IGRAPH_ERROR("Cannot create iterator, invalid selector.", IGRAPH_EINVAL);
        break;
    }
    return 0;
}

/**
 * \function igraph_eit_destroy
 * \brief Destroys an edge iterator.
 *
 * \param eit Pointer to an edge iterator to destroy.
 * \sa \ref igraph_eit_create()
 *
 * Time complexity: operating system dependent, usually O(1).
 */

void igraph_eit_destroy(const igraph_eit_t *eit) {
    switch (eit->type) {
    case IGRAPH_EIT_SEQ:
    case IGRAPH_EIT_VECTORPTR:
        break;
    case IGRAPH_EIT_VECTOR:
        igraph_vector_destroy((igraph_vector_t*)eit->vec);
        igraph_free((igraph_vector_t*)eit->vec);
        break;
    default:
        /*     IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */
        break;
    }
}

int igraph_eit_as_vector(const igraph_eit_t *eit, igraph_vector_t *v) {

    long int i;

    IGRAPH_CHECK(igraph_vector_resize(v, IGRAPH_EIT_SIZE(*eit)));

    switch (eit->type) {
    case IGRAPH_EIT_SEQ:
        for (i = 0; i < IGRAPH_EIT_SIZE(*eit); i++) {
            VECTOR(*v)[i] = eit->start + i;
        }
        break;
    case IGRAPH_EIT_VECTOR:
    case IGRAPH_EIT_VECTORPTR:
        for (i = 0; i < IGRAPH_EIT_SIZE(*eit); i++) {
            VECTOR(*v)[i] = VECTOR(*eit->vec)[i];
        }
        break;
    default:
        IGRAPH_ERROR("Cannot convert to vector, unknown iterator type",
                     IGRAPH_EINVAL);
        break;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/neighbors.h0000644000175100001710000000273000000000000023675 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_NEIGHBORS_H
#define IGRAPH_NEIGHBORS_H

#include "igraph_constants.h"

__BEGIN_DECLS

IGRAPH_PRIVATE_EXPORT int igraph_i_neighbors(const igraph_t *graph,
                       igraph_vector_t *neis,
                       igraph_integer_t pnode,
                       igraph_neimode_t mode,
                       igraph_loops_t loops,
                       igraph_multiple_t multiple);

IGRAPH_PRIVATE_EXPORT int igraph_i_incident(const igraph_t *graph,
                       igraph_vector_t *eids,
                       igraph_integer_t pnode,
                       igraph_neimode_t mode,
                       igraph_loops_t loops,
                       igraph_multiple_t multiple);

__END_DECLS

#endif /* IGRAPH_NEIGHBORS_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/type_indexededgelist.c0000644000175100001710000021665500000000000026127 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_datatype.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "graph/attributes.h"
#include "graph/neighbors.h"

/* Internal functions */

static int igraph_i_create_start(
        igraph_vector_t *res, igraph_vector_t *el,
        igraph_vector_t *index, igraph_integer_t nodes);

/**
 * \section about_basic_interface
 *
 * This is the very minimal API in \a igraph. All the other
 * functions use this minimal set for creating and manipulating
 * graphs.
 *
 * This is a very important principle since it makes possible to
 * implement other data representations by implementing only this
 * minimal set.
 */

/**
 * \ingroup interface
 * \function igraph_empty
 * \brief Creates an empty graph with some vertices and no edges.
 *
 * 
 * The most basic constructor, all the other constructors should call
 * this to create a minimal graph object. Our use of the term "empty graph"
 * in the above description should be distinguished from the mathematical
 * definition of the empty or null graph. Strictly speaking, the empty or null
 * graph in graph theory is the graph with no vertices and no edges. However
 * by "empty graph" as used in \c igraph we mean a graph having zero or more
 * vertices, but no edges.
 * \param graph Pointer to a not-yet initialized graph object.
 * \param n The number of vertices in the graph, a non-negative
 *          integer number is expected.
 * \param directed Boolean; whether the graph is directed or not. Supported
 *        values are:
 *        \clist
 *        \cli IGRAPH_DIRECTED
 *          The graph will be \em directed.
 *        \cli IGRAPH_UNDIRECTED
 *          The graph will be \em undirected.
 *        \endclist
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of vertices.
 *
 * Time complexity: O(|V|) for a graph with
 * |V| vertices (and no edges).
 *
 * \example examples/simple/igraph_empty.c
 */
int igraph_empty(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) {
    return igraph_empty_attrs(graph, n, directed, 0);
}


/**
 * \ingroup interface
 * \function igraph_empty_attrs
 * \brief Creates an empty graph with some vertices, no edges and some graph attributes.
 *
 * 
 * Use this instead of \ref igraph_empty() if you wish to add some graph
 * attributes right after initialization. This function is currently
 * not very interesting for the ordinary user. Just supply 0 here or
 * use \ref igraph_empty().
 * \param graph Pointer to a not-yet initialized graph object.
 * \param n The number of vertices in the graph; a non-negative
 *          integer number is expected.
 * \param directed Boolean; whether the graph is directed or not. Supported
 *        values are:
 *        \clist
 *        \cli IGRAPH_DIRECTED
 *          Create a \em directed graph.
 *        \cli IGRAPH_UNDIRECTED
 *          Create an \em undirected graph.
 *        \endclist
 * \param attr The attributes.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of vertices.
 *
 * Time complexity: O(|V|) for a graph with
 * |V| vertices (and no edges).
 */
int igraph_empty_attrs(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, void* attr) {

    if (n < 0) {
        IGRAPH_ERROR("cannot create empty graph with negative number of vertices",
                     IGRAPH_EINVAL);
    }

    if (!IGRAPH_FINITE(n)) {
        IGRAPH_ERROR("number of vertices is not finite (NA, NaN or Inf)", IGRAPH_EINVAL);
    }

    graph->n = 0;
    graph->directed = directed;
    IGRAPH_VECTOR_INIT_FINALLY(&graph->from, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&graph->to, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&graph->oi, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&graph->ii, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&graph->os, 1);
    IGRAPH_VECTOR_INIT_FINALLY(&graph->is, 1);

    VECTOR(graph->os)[0] = 0;
    VECTOR(graph->is)[0] = 0;

    /* init attributes */
    graph->attr = 0;
    IGRAPH_CHECK(igraph_i_attribute_init(graph, attr));

    /* add the vertices */
    IGRAPH_CHECK(igraph_add_vertices(graph, n, 0));

    IGRAPH_FINALLY_CLEAN(6);
    return 0;
}

/**
 * \ingroup interface
 * \function igraph_destroy
 * \brief Frees the memory allocated for a graph object.
 *
 * 
 * This function should be called for every graph object exactly once.
 *
 * 
 * This function invalidates all iterators (of course), but the
 * iterators of a graph should be destroyed before the graph itself
 * anyway.
 * \param graph Pointer to the graph to free.
 *
 * Time complexity: operating system specific.
 */
void igraph_destroy(igraph_t *graph) {

    IGRAPH_I_ATTRIBUTE_DESTROY(graph);

    igraph_vector_destroy(&graph->from);
    igraph_vector_destroy(&graph->to);
    igraph_vector_destroy(&graph->oi);
    igraph_vector_destroy(&graph->ii);
    igraph_vector_destroy(&graph->os);
    igraph_vector_destroy(&graph->is);
}

/**
 * \ingroup interface
 * \function igraph_copy
 * \brief Creates an exact (deep) copy of a graph.
 *
 * 
 * This function deeply copies a graph object to create an exact
 * replica of it. The new replica should be destroyed by calling
 * \ref igraph_destroy() on it when not needed any more.
 *
 * 
 * You can also create a shallow copy of a graph by simply using the
 * standard assignment operator, but be careful and do \em not
 * destroy a shallow replica. To avoid this mistake, creating shallow
 * copies is not recommended.
 * \param to Pointer to an uninitialized graph object.
 * \param from Pointer to the graph object to copy.
 * \return Error code.
 *
 * Time complexity:  O(|V|+|E|) for a
 * graph with |V| vertices and
 * |E| edges.
 *
 * \example examples/simple/igraph_copy.c
 */

int igraph_copy(igraph_t *to, const igraph_t *from) {
    to->n = from->n;
    to->directed = from->directed;
    IGRAPH_CHECK(igraph_vector_copy(&to->from, &from->from));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->from);
    IGRAPH_CHECK(igraph_vector_copy(&to->to, &from->to));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->to);
    IGRAPH_CHECK(igraph_vector_copy(&to->oi, &from->oi));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->oi);
    IGRAPH_CHECK(igraph_vector_copy(&to->ii, &from->ii));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->ii);
    IGRAPH_CHECK(igraph_vector_copy(&to->os, &from->os));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->os);
    IGRAPH_CHECK(igraph_vector_copy(&to->is, &from->is));
    IGRAPH_FINALLY(igraph_vector_destroy, &to->is);

    IGRAPH_I_ATTRIBUTE_COPY(to, from, 1, 1, 1); /* does IGRAPH_CHECK */

    IGRAPH_FINALLY_CLEAN(6);
    return 0;
}

/**
 * \ingroup interface
 * \function igraph_add_edges
 * \brief Adds edges to a graph object.
 *
 * 
 * The edges are given in a vector, the
 * first two elements define the first edge (the order is
 * from, to for directed
 * graphs). The vector
 * should contain even number of integer numbers between zero and the
 * number of vertices in the graph minus one (inclusive). If you also
 * want to add new vertices, call igraph_add_vertices() first.
 * \param graph The graph to which the edges will be added.
 * \param edges The edges themselves.
 * \param attr The attributes of the new edges, only used by high level
 *        interfaces currently, you can supply 0 here.
 * \return Error code:
 *    \c IGRAPH_EINVEVECTOR: invalid (odd)
 *    edges vector length, \c IGRAPH_EINVVID:
 *    invalid vertex id in edges vector.
 *
 * This function invalidates all iterators.
 *
 * 
 * Time complexity: O(|V|+|E|) where
 * |V| is the number of vertices and
 * |E| is the number of
 * edges in the \em new, extended graph.
 *
 * \example examples/simple/igraph_add_edges.c
 */
int igraph_add_edges(igraph_t *graph, const igraph_vector_t *edges,
                     void *attr) {
    long int no_of_edges = igraph_vector_size(&graph->from);
    long int edges_to_add = igraph_vector_size(edges) / 2;
    long int i = 0;
    igraph_error_handler_t *oldhandler;
    int ret1, ret2;
    igraph_vector_t newoi, newii;
    igraph_bool_t directed = igraph_is_directed(graph);

    if (igraph_vector_size(edges) % 2 != 0) {
        IGRAPH_ERROR("invalid (odd) length of edges vector", IGRAPH_EINVEVECTOR);
    }
    if (!igraph_vector_isininterval(edges, 0, igraph_vcount(graph) - 1)) {
        IGRAPH_ERROR("cannot add edges", IGRAPH_EINVVID);
    }

    /* from & to */
    IGRAPH_CHECK(igraph_vector_reserve(&graph->from, no_of_edges + edges_to_add));
    IGRAPH_CHECK(igraph_vector_reserve(&graph->to, no_of_edges + edges_to_add));

    while (i < edges_to_add * 2) {
        if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) {
            igraph_vector_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
            igraph_vector_push_back(&graph->to,   VECTOR(*edges)[i++]); /* reserved */
        } else {
            igraph_vector_push_back(&graph->to,   VECTOR(*edges)[i++]); /* reserved */
            igraph_vector_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */
        }
    }

    /* disable the error handler temporarily */
    oldhandler = igraph_set_error_handler(igraph_error_handler_ignore);

    /* oi & ii */
    ret1 = igraph_vector_init(&newoi, no_of_edges);
    ret2 = igraph_vector_init(&newii, no_of_edges);
    if (ret1 != 0 || ret2 != 0) {
        igraph_vector_resize(&graph->from, no_of_edges); /* gets smaller */
        igraph_vector_resize(&graph->to, no_of_edges);   /* gets smaller */
        igraph_set_error_handler(oldhandler);
        IGRAPH_ERROR("cannot add edges", IGRAPH_ERROR_SELECT_2(ret1, ret2));
    }
    ret1 = igraph_vector_order(&graph->from, &graph->to, &newoi, graph->n);
    ret2 = igraph_vector_order(&graph->to, &graph->from, &newii, graph->n);
    if (ret1 != 0 || ret2 != 0) {
        igraph_vector_resize(&graph->from, no_of_edges);
        igraph_vector_resize(&graph->to, no_of_edges);
        igraph_vector_destroy(&newoi);
        igraph_vector_destroy(&newii);
        igraph_set_error_handler(oldhandler);
        IGRAPH_ERROR("cannot add edges", IGRAPH_ERROR_SELECT_2(ret1, ret2));
    }

    /* Attributes */
    if (graph->attr) {
        igraph_set_error_handler(oldhandler);
        ret1 = igraph_i_attribute_add_edges(graph, edges, attr);
        igraph_set_error_handler(igraph_error_handler_ignore);
        if (ret1 != 0) {
            igraph_vector_resize(&graph->from, no_of_edges);
            igraph_vector_resize(&graph->to, no_of_edges);
            igraph_vector_destroy(&newoi);
            igraph_vector_destroy(&newii);
            igraph_set_error_handler(oldhandler);
            IGRAPH_ERROR("cannot add edges", ret1);
        }
    }

    /* os & is, its length does not change, error safe */
    igraph_i_create_start(&graph->os, &graph->from, &newoi, graph->n);
    igraph_i_create_start(&graph->is, &graph->to, &newii, graph->n);

    /* everything went fine  */
    igraph_vector_destroy(&graph->oi);
    igraph_vector_destroy(&graph->ii);
    graph->oi = newoi;
    graph->ii = newii;
    igraph_set_error_handler(oldhandler);

    return 0;
}

/**
 * \ingroup interface
 * \function igraph_add_vertices
 * \brief Adds vertices to a graph.
 *
 * 
 * This function invalidates all iterators.
 *
 * \param graph The graph object to extend.
 * \param nv Non-negative integer giving the number of
 *           vertices to add.
 * \param attr The attributes of the new vertices, only used by
 *           high level interfaces, you can supply 0 here.
 * \return Error code:
 *         \c IGRAPH_EINVAL: invalid number of new
 *         vertices.
 *
 * Time complexity: O(|V|) where
 * |V| is
 * the number of vertices in the \em new, extended graph.
 *
 * \example examples/simple/igraph_add_vertices.c
 */
int igraph_add_vertices(igraph_t *graph, igraph_integer_t nv, void *attr) {
    long int ec = igraph_ecount(graph);
    long int i;

    if (nv < 0) {
        IGRAPH_ERROR("cannot add negative number of vertices", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_reserve(&graph->os, graph->n + nv + 1));
    IGRAPH_CHECK(igraph_vector_reserve(&graph->is, graph->n + nv + 1));

    igraph_vector_resize(&graph->os, graph->n + nv + 1); /* reserved */
    igraph_vector_resize(&graph->is, graph->n + nv + 1); /* reserved */
    for (i = graph->n + 1; i < graph->n + nv + 1; i++) {
        VECTOR(graph->os)[i] = ec;
        VECTOR(graph->is)[i] = ec;
    }

    graph->n += nv;

    if (graph->attr) {
        IGRAPH_CHECK(igraph_i_attribute_add_vertices(graph, nv, attr));
    }

    return 0;
}

/**
 * \ingroup interface
 * \function igraph_delete_edges
 * \brief Removes edges from a graph.
 *
 * 
 * The edges to remove are given as an edge selector.
 *
 * 
 * This function cannot remove vertices, they will be kept, even if
 * they lose all their edges.
 *
 * 
 * This function invalidates all iterators.
 * \param graph The graph to work on.
 * \param edges The edges to remove.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|) where
 * |V|
 * and |E| are the number of vertices
 * and edges in the \em original graph, respectively.
 *
 * \example examples/simple/igraph_delete_edges.c
 */
int igraph_delete_edges(igraph_t *graph, igraph_es_t edges) {
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_nodes = igraph_vcount(graph);
    long int edges_to_remove = 0;
    long int remaining_edges;
    igraph_eit_t eit;

    igraph_vector_t newfrom, newto, newoi;

    int *mark;
    long int i, j;

    mark = IGRAPH_CALLOC(no_of_edges, int);
    if (mark == 0) {
        IGRAPH_ERROR("Cannot delete edges", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, mark);

    IGRAPH_CHECK(igraph_eit_create(graph, edges, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    for (IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        long int e = IGRAPH_EIT_GET(eit);
        if (mark[e] == 0) {
            edges_to_remove++;
            mark[e]++;
        }
    }
    remaining_edges = no_of_edges - edges_to_remove;

    /* We don't need the iterator any more */
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_VECTOR_INIT_FINALLY(&newfrom, remaining_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&newto, remaining_edges);

    /* Actually remove the edges, move from pos i to pos j in newfrom/newto */
    for (i = 0, j = 0; j < remaining_edges; i++) {
        if (mark[i] == 0) {
            VECTOR(newfrom)[j] = VECTOR(graph->from)[i];
            VECTOR(newto)[j] = VECTOR(graph->to)[i];
            j++;
        }
    }

    /* Create index, this might require additional memory */
    IGRAPH_VECTOR_INIT_FINALLY(&newoi, remaining_edges);
    IGRAPH_CHECK(igraph_vector_order(&newfrom, &newto, &newoi, no_of_nodes));
    IGRAPH_CHECK(igraph_vector_order(&newto, &newfrom, &graph->ii, no_of_nodes));

    /* Edge attributes, we need an index that gives the ids of the
       original edges for every new edge.
    */
    if (graph->attr) {
        igraph_vector_t idx;
        IGRAPH_VECTOR_INIT_FINALLY(&idx, remaining_edges);
        for (i = 0, j = 0; i < no_of_edges; i++) {
            if (mark[i] == 0) {
                VECTOR(idx)[j++] = i;
            }
        }
        IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, graph, &idx));
        igraph_vector_destroy(&idx);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* Ok, we've all memory needed, free the old structure  */
    igraph_vector_destroy(&graph->from);
    igraph_vector_destroy(&graph->to);
    igraph_vector_destroy(&graph->oi);
    graph->from = newfrom;
    graph->to = newto;
    graph->oi = newoi;
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_FREE(mark);
    IGRAPH_FINALLY_CLEAN(1);

    /* Create start vectors, no memory is needed for this */
    igraph_i_create_start(&graph->os, &graph->from, &graph->oi,
                          (igraph_integer_t) no_of_nodes);
    igraph_i_create_start(&graph->is, &graph->to,   &graph->ii,
                          (igraph_integer_t) no_of_nodes);

    /* Nothing to deallocate... */
    return 0;
}

/**
 * \ingroup interface
 * \function igraph_delete_vertices
 * \brief Removes vertices (with all their edges) from the graph.
 *
 * 
 * This function changes the ids of the vertices (except in some very
 * special cases, but these should not be relied on anyway).
 *
 * 
 * This function invalidates all iterators.
 *
 * \param graph The graph to work on.
 * \param vertices The ids of the vertices to remove in a
 *                 vector. The vector may contain the same id more
 *                 than once.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *
 * Time complexity: O(|V|+|E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the original graph.
 *
 * \example examples/simple/igraph_delete_vertices.c
 */
int igraph_delete_vertices(igraph_t *graph, const igraph_vs_t vertices) {
    return igraph_delete_vertices_idx(graph, vertices, /* idx= */ 0,
                                      /* invidx= */ 0);
}

int igraph_delete_vertices_idx(igraph_t *graph, const igraph_vs_t vertices,
                               igraph_vector_t *idx,
                               igraph_vector_t *invidx) {

    long int no_of_edges = igraph_ecount(graph);
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t edge_recoding, vertex_recoding;
    igraph_vector_t *my_vertex_recoding = &vertex_recoding;
    igraph_vit_t vit;
    igraph_t newgraph;
    long int i, j;
    long int remaining_vertices, remaining_edges;

    if (idx) {
        my_vertex_recoding = idx;
        IGRAPH_CHECK(igraph_vector_resize(idx, no_of_nodes));
        igraph_vector_null(idx);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&vertex_recoding, no_of_nodes);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edge_recoding, no_of_edges);

    IGRAPH_CHECK(igraph_vit_create(graph, vertices, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    /* mark the vertices to delete */
    for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit) ) {
        long int vertex = IGRAPH_VIT_GET(vit);
        if (vertex < 0 || vertex >= no_of_nodes) {
            IGRAPH_ERROR("Cannot delete vertices", IGRAPH_EINVVID);
        }
        VECTOR(*my_vertex_recoding)[vertex] = 1;
    }
    /* create vertex recoding vector */
    for (remaining_vertices = 0, i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*my_vertex_recoding)[i] == 0) {
            VECTOR(*my_vertex_recoding)[i] = remaining_vertices + 1;
            remaining_vertices++;
        } else {
            VECTOR(*my_vertex_recoding)[i] = 0;
        }
    }
    /* create edge recoding vector */
    for (remaining_edges = 0, i = 0; i < no_of_edges; i++) {
        long int from = (long int) VECTOR(graph->from)[i];
        long int to = (long int) VECTOR(graph->to)[i];
        if (VECTOR(*my_vertex_recoding)[from] != 0 &&
            VECTOR(*my_vertex_recoding)[to  ] != 0) {
            VECTOR(edge_recoding)[i] = remaining_edges + 1;
            remaining_edges++;
        }
    }

    /* start creating the graph */
    newgraph.n = (igraph_integer_t) remaining_vertices;
    newgraph.directed = graph->directed;

    /* allocate vectors */
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.from, remaining_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.to, remaining_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.oi, remaining_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.ii, remaining_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.os, remaining_vertices + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&newgraph.is, remaining_vertices + 1);

    /* Add the edges */
    for (i = 0, j = 0; j < remaining_edges; i++) {
        if (VECTOR(edge_recoding)[i] > 0) {
            long int from = (long int) VECTOR(graph->from)[i];
            long int to = (long int) VECTOR(graph->to  )[i];
            VECTOR(newgraph.from)[j] = VECTOR(*my_vertex_recoding)[from] - 1;
            VECTOR(newgraph.to  )[j] = VECTOR(*my_vertex_recoding)[to] - 1;
            j++;
        }
    }
    /* update oi & ii */
    IGRAPH_CHECK(igraph_vector_order(&newgraph.from, &newgraph.to, &newgraph.oi,
                                     remaining_vertices));
    IGRAPH_CHECK(igraph_vector_order(&newgraph.to, &newgraph.from, &newgraph.ii,
                                     remaining_vertices));

    IGRAPH_CHECK(igraph_i_create_start(&newgraph.os, &newgraph.from,
                                       &newgraph.oi, (igraph_integer_t)
                                       remaining_vertices));
    IGRAPH_CHECK(igraph_i_create_start(&newgraph.is, &newgraph.to,
                                       &newgraph.ii, (igraph_integer_t)
                                       remaining_vertices));

    /* attributes */
    IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph,
                            /*graph=*/ 1, /*vertex=*/0, /*edge=*/0);
    IGRAPH_FINALLY_CLEAN(6);
    IGRAPH_FINALLY(igraph_destroy, &newgraph);

    if (newgraph.attr) {
        igraph_vector_t iidx;
        IGRAPH_VECTOR_INIT_FINALLY(&iidx, remaining_vertices);
        for (i = 0; i < no_of_nodes; i++) {
            long int jj = (long int) VECTOR(*my_vertex_recoding)[i];
            if (jj != 0) {
                VECTOR(iidx)[ jj - 1 ] = i;
            }
        }
        IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph,
                     &newgraph,
                     &iidx));
        IGRAPH_CHECK(igraph_vector_resize(&iidx, remaining_edges));
        for (i = 0; i < no_of_edges; i++) {
            long int jj = (long int) VECTOR(edge_recoding)[i];
            if (jj != 0) {
                VECTOR(iidx)[ jj - 1 ] = i;
            }
        }
        IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, &newgraph, &iidx));
        igraph_vector_destroy(&iidx);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vit_destroy(&vit);
    igraph_vector_destroy(&edge_recoding);
    igraph_destroy(graph);
    *graph = newgraph;

    IGRAPH_FINALLY_CLEAN(3);

    /* TODO: this is duplicate */
    if (invidx) {
        IGRAPH_CHECK(igraph_vector_resize(invidx, remaining_vertices));
        for (i = 0; i < no_of_nodes; i++) {
            long int newid = (long int) VECTOR(*my_vertex_recoding)[i];
            if (newid != 0) {
                VECTOR(*invidx)[newid - 1] = i;
            }
        }
    }

    if (!idx) {
        igraph_vector_destroy(my_vertex_recoding);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \ingroup interface
 * \function igraph_vcount
 * \brief The number of vertices in a graph.
 *
 * \param graph The graph.
 * \return Number of vertices.
 *
 * Time complexity: O(1)
 */
igraph_integer_t igraph_vcount(const igraph_t *graph) {
    return graph->n;
}

/**
 * \ingroup interface
 * \function igraph_ecount
 * \brief The number of edges in a graph.
 *
 * \param graph The graph.
 * \return Number of edges.
 *
 * Time complexity: O(1)
 */
igraph_integer_t igraph_ecount(const igraph_t *graph) {
    return (igraph_integer_t) igraph_vector_size(&graph->from);
}

/**
 * \ingroup interface
 * \function igraph_neighbors
 * \brief Adjacent vertices to a vertex.
 *
 * \param graph The graph to work on.
 * \param neis This vector will contain the result. The vector should
 *        be initialized beforehand and will be resized. Starting from igraph
 *        version 0.4 this vector is always sorted, the vertex ids are
 *        in increasing order.
 * \param pnode The id of the node for which the adjacent vertices are
 *        to be searched.
 * \param mode Defines the way adjacent vertices are searched in
 *        directed graphs. It can have the following values:
 *        \c IGRAPH_OUT, vertices reachable by an
 *        edge from the specified vertex are searched;
 *        \c IGRAPH_IN, vertices from which the
 *        specified vertex is reachable are searched;
 *        \c IGRAPH_ALL, both kinds of vertices are
 *        searched.
 *        This parameter is ignored for undirected graphs.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *         \c IGRAPH_EINVMODE: invalid mode argument.
 *         \c IGRAPH_ENOMEM: not enough memory.
 *
 * Time complexity: O(d),
 * d is the number
 * of adjacent vertices to the queried vertex.
 *
 * \example examples/simple/igraph_neighbors.c
 */
int igraph_neighbors(const igraph_t *graph, igraph_vector_t *neis, igraph_integer_t pnode,
        igraph_neimode_t mode) {
    if (!igraph_is_directed(graph) || mode == IGRAPH_ALL) {
        return igraph_i_neighbors(graph, neis, pnode, mode, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);
    } else {
        return igraph_i_neighbors(graph, neis, pnode, mode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    }
}

int igraph_i_neighbors(const igraph_t *graph, igraph_vector_t *neis, igraph_integer_t pnode,
        igraph_neimode_t mode, igraph_loops_t loops, igraph_multiple_t multiple) {
#define DEDUPLICATE_IF_NEEDED(vertex, n)                                                 \
    if (should_filter_duplicates) {                                                        \
        if ((loops == IGRAPH_NO_LOOPS && vertex == pnode) ||                               \
                (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) ||  \
                (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added)) {                \
            length -= n;                                                                   \
            continue;                                                                      \
        } else {                                                                           \
            last_added = vertex;                                                           \
        }                                                                                  \
    }

    long int length = 0, idx = 0;
    long int i, j;

    long int node = pnode;
    igraph_real_t last_added = -1;
    igraph_bool_t should_filter_duplicates;

    if (node < 0 || node > igraph_vcount(graph) - 1) {
        IGRAPH_ERROR("Given vertex is not in the graph.", IGRAPH_EINVVID);
    }
    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
            mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) {
        IGRAPH_ERROR("For a directed graph (with directions not ignored), "
                     "IGRAPH_LOOPS_TWICE does not make sense.\n", IGRAPH_EINVAL);
    }
    /* Calculate needed space first & allocate it */
    /* Note that 'mode' is treated as a bit field here; it's okay because
     * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */
    if (mode & IGRAPH_OUT) {
        length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
    }
    if (mode & IGRAPH_IN) {
        length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
    }

    IGRAPH_CHECK(igraph_vector_resize(neis, length));

    /* The loops below produce an ordering what is consistent with the
     * ordering returned by igraph_neighbors(), and this should be preserved.
     * We are dealing with two sorted lists; one for the successors and one
     * for the predecessors. If we have requested only one of them, we have
     * an easy job. If we have requested both, we need to merge the two lists
     * to ensure that the output is sorted by the vertex IDs of the "other"
     * endpoint of the affected edges. We don't need to merge if the graph
     * is undirected, because in that case the data structure guarantees that
     * the "out-edges" contain only (u, v) pairs where u <= v and the
     * "in-edges" contains the rest, so the result is sorted even without
     * merging. */
    if (!igraph_is_directed(graph) || mode != IGRAPH_ALL) {
        /* graph is undirected or we did not ask for both directions in a
         * directed graph; this is the easy case */

        should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE &&
                ((!igraph_is_directed(graph) && loops == IGRAPH_LOOPS_TWICE) ||
                 (igraph_is_directed(graph) && loops != IGRAPH_NO_LOOPS)));

        if (mode & IGRAPH_OUT) {
            j = (long int) VECTOR(graph->os)[node + 1];
            for (i = (long int) VECTOR(graph->os)[node]; i < j; i++) {
                igraph_real_t to = VECTOR(graph->to)[ (long int)VECTOR(graph->oi)[i] ];
                DEDUPLICATE_IF_NEEDED(to, 1);
                VECTOR(*neis)[idx++] = to;
            }
        }
        if (mode & IGRAPH_IN) {
            j = (long int) VECTOR(graph->is)[node + 1];
            for (i = (long int) VECTOR(graph->is)[node]; i < j; i++) {
                igraph_real_t from = VECTOR(graph->from)[ (long int)VECTOR(graph->ii)[i] ];
                DEDUPLICATE_IF_NEEDED(from, 1);
                VECTOR(*neis)[idx++] = from;
            }
        }
    } else {
        /* Both in- and out- neighbors in a directed graph,
           we need to merge the two 'vectors' so the result is
           correctly ordered. */
        long int j1 = (long int) VECTOR(graph->os)[node + 1];
        long int j2 = (long int) VECTOR(graph->is)[node + 1];
        long int i1 = (long int) VECTOR(graph->os)[node];
        long int i2 = (long int) VECTOR(graph->is)[node];
        long int eid1, eid2;
        long int n1, n2;

        should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE &&
                loops == IGRAPH_LOOPS_TWICE);

        while (i1 < j1 && i2 < j2) {
            eid1 = (long int) VECTOR(graph->oi)[i1];
            eid2 = (long int) VECTOR(graph->ii)[i2];
            n1 = (long int) VECTOR(graph->to)[eid1];
            n2 = (long int) VECTOR(graph->from)[eid2];
            if (n1 < n2) {
                i1++;
                DEDUPLICATE_IF_NEEDED(n1, 1);
                VECTOR(*neis)[idx++] = n1;
            } else if (n1 > n2) {
                i2++;
                DEDUPLICATE_IF_NEEDED(n2, 1);
                VECTOR(*neis)[idx++] = n2;
            } else {
                i1++;
                i2++;
                DEDUPLICATE_IF_NEEDED(n1, 2);
                VECTOR(*neis)[idx++] = n1;
                if (should_filter_duplicates && ((loops == IGRAPH_LOOPS_ONCE && n1 == pnode && last_added == pnode) ||
                        (multiple == IGRAPH_NO_MULTIPLE))) {
                    length--;
                    continue;
                }
                VECTOR(*neis)[idx++] = n2;
            }
        }

        while (i1 < j1) {
            eid1 = (long int) VECTOR(graph->oi)[i1++];
            igraph_real_t to = (long int) VECTOR(graph->to)[eid1];
            DEDUPLICATE_IF_NEEDED(to, 1);
            VECTOR(*neis)[idx++] = to;
        }

        while (i2 < j2) {
            eid2 = (long int) VECTOR(graph->ii)[i2++];
            igraph_real_t from =  (long int) VECTOR(graph->from)[eid2];
            DEDUPLICATE_IF_NEEDED(from, 1);
            VECTOR(*neis)[idx++] = from;
        }

    }
    IGRAPH_CHECK(igraph_vector_resize(neis, length));

    return IGRAPH_SUCCESS;
#undef DEDUPLICATE_IF_NEEDED
}
/**
 * \ingroup internal
 *
 */

static int igraph_i_create_start(
        igraph_vector_t *res, igraph_vector_t *el,
        igraph_vector_t *iindex, igraph_integer_t nodes) {

# define EDGE(i) (VECTOR(*el)[ (long int) VECTOR(*iindex)[(i)] ])

    long int no_of_nodes;
    long int no_of_edges;
    long int i, j, idx;

    no_of_nodes = nodes;
    no_of_edges = igraph_vector_size(el);

    /* result */

    IGRAPH_CHECK(igraph_vector_resize(res, nodes + 1));

    /* create the index */

    if (igraph_vector_size(el) == 0) {
        /* empty graph */
        igraph_vector_null(res);
    } else {
        idx = -1;
        for (i = 0; i <= EDGE(0); i++) {
            idx++; VECTOR(*res)[idx] = 0;
        }
        for (i = 1; i < no_of_edges; i++) {
            long int n = (long int) (EDGE(i) - EDGE((long int)VECTOR(*res)[idx]));
            for (j = 0; j < n; j++) {
                idx++; VECTOR(*res)[idx] = i;
            }
        }
        j = (long int) EDGE((long int)VECTOR(*res)[idx]);
        for (i = 0; i < no_of_nodes - j; i++) {
            idx++; VECTOR(*res)[idx] = no_of_edges;
        }
    }

    /* clean */

# undef EDGE
    return 0;
}

/**
 * \ingroup interface
 * \function igraph_is_directed
 * \brief Is this a directed graph?
 *
 * \param graph The graph.
 * \return Logical value, TRUE if the graph is directed,
 * FALSE otherwise.
 *
 * Time complexity: O(1)
 *
 * \example examples/simple/igraph_is_directed.c
 */

igraph_bool_t igraph_is_directed(const igraph_t *graph) {
    return graph->directed;
}

/**
 * \ingroup interface
 * \function igraph_degree
 * \brief The degree of some vertices in a graph.
 *
 * 
 * This function calculates the in-, out- or total degree of the
 * specified vertices.
 * \param graph The graph.
 * \param res Vector, this will contain the result. It should be
 *        initialized and will be resized to be the appropriate size.
 * \param vids Vector, giving the vertex ids of which the degree will
 *        be calculated.
 * \param mode Defines the type of the degree. Valid modes are:
 *        \c IGRAPH_OUT, out-degree;
 *        \c IGRAPH_IN, in-degree;
 *        \c IGRAPH_ALL, total degree (sum of the
 *        in- and out-degree).
 *        This parameter is ignored for undirected graphs.
 * \param loops Boolean, gives whether the self-loops should be
 *        counted.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *         \c IGRAPH_EINVMODE: invalid mode argument.
 *
 * Time complexity: O(v) if
 * loops is
 * TRUE, and
 * O(v*d)
 * otherwise. v is the number of
 * vertices for which the degree will be calculated, and
 * d is their (average) degree.
 *
 * \sa \ref igraph_strength() for the version that takes into account
 * edge weights.
 *
 * \example examples/simple/igraph_degree.c
 */
int igraph_degree(const igraph_t *graph, igraph_vector_t *res,
                  const igraph_vs_t vids,
                  igraph_neimode_t mode, igraph_bool_t loops) {

    long int nodes_to_calc;
    long int i, j;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) {
        IGRAPH_ERROR("degree calculation failed", IGRAPH_EINVMODE);
    }

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);
    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    if (loops) {
        if (mode & IGRAPH_OUT) {
            for (IGRAPH_VIT_RESET(vit), i = 0;
                 !IGRAPH_VIT_END(vit);
                 IGRAPH_VIT_NEXT(vit), i++) {
                long int vid = IGRAPH_VIT_GET(vit);
                VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]);
            }
        }
        if (mode & IGRAPH_IN) {
            for (IGRAPH_VIT_RESET(vit), i = 0;
                 !IGRAPH_VIT_END(vit);
                 IGRAPH_VIT_NEXT(vit), i++) {
                long int vid = IGRAPH_VIT_GET(vit);
                VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]);
            }
        }
    } else { /* no loops */
        if (mode & IGRAPH_OUT) {
            for (IGRAPH_VIT_RESET(vit), i = 0;
                 !IGRAPH_VIT_END(vit);
                 IGRAPH_VIT_NEXT(vit), i++) {
                long int vid = IGRAPH_VIT_GET(vit);
                VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]);
                for (j = (long int) VECTOR(graph->os)[vid];
                     j < VECTOR(graph->os)[vid + 1]; j++) {
                    if (VECTOR(graph->to)[ (long int)VECTOR(graph->oi)[j] ] == vid) {
                        VECTOR(*res)[i] -= 1;
                    }
                }
            }
        }
        if (mode & IGRAPH_IN) {
            for (IGRAPH_VIT_RESET(vit), i = 0;
                 !IGRAPH_VIT_END(vit);
                 IGRAPH_VIT_NEXT(vit), i++) {
                long int vid = IGRAPH_VIT_GET(vit);
                VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]);
                for (j = (long int) VECTOR(graph->is)[vid];
                     j < VECTOR(graph->is)[vid + 1]; j++) {
                    if (VECTOR(graph->from)[ (long int)VECTOR(graph->ii)[j] ] == vid) {
                        VECTOR(*res)[i] -= 1;
                    }
                }
            }
        }
    }  /* loops */

    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_edge
 * \brief Gives the head and tail vertices of an edge.
 *
 * \param graph The graph object.
 * \param eid The edge id.
 * \param from Pointer to an \type igraph_integer_t. The tail (head) of
 * the edge will be placed here for undirected (directed) graphs.
 * \param to Pointer to an \type igraph_integer_t. The head (tail) of the
 * edge will be placed here for undirected (directed) graphs.
 * \return Error code. The current implementation always returns with
 * success.
 * \sa \ref igraph_get_eid() for the opposite operation;
 *     \ref igraph_edges() to get the endpoints of several edges;
 *     \ref IGRAPH_TO(), \ref IGRAPH_FROM() and \ref IGRAPH_OTHER() for
 *     a faster but non-error-checked version.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(1).
 */

int igraph_edge(const igraph_t *graph, igraph_integer_t eid,
                igraph_integer_t *from, igraph_integer_t *to) {

    if (igraph_is_directed(graph)) {
        *from = IGRAPH_FROM(graph, eid);
        *to   = IGRAPH_TO(graph, eid);
    } else {
        *from = IGRAPH_TO(graph, eid);
        *to   = IGRAPH_FROM(graph, eid);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_edges
 * \brief Gives the head and tail vertices of a series of edges.
 *
 * \param graph The graph object.
 * \param eids  Edge selector, the series of edges.
 * \param edges Pointer to an initialized vector. The start and endpoints of
 *              each edge will be placed here.
 * \return Error code.
 * \sa \ref igraph_get_edgelist() to get the endpoints of all edges;
 *     \ref igraph_get_eids() and \ref igraph_get_eids_multi()
 *     for the opposite operation;
 *     \ref igraph_edge() for getting the endpoints of a single edge;
 *     \ref IGRAPH_TO(), \ref IGRAPH_FROM() and \ref IGRAPH_OTHER() for
 *     a faster but non-error-checked method.
 *
 * Time complexity: O(k) where k is the number of edges in the selector.
 */

int igraph_edges(const igraph_t *graph, igraph_es_t eids,
                 igraph_vector_t *edges) {

    igraph_eit_t eit;
    long int n, ptr = 0;

    IGRAPH_CHECK(igraph_eit_create(graph, eids, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);
    n = IGRAPH_EIT_SIZE(eit);
    IGRAPH_CHECK(igraph_vector_resize(edges, n * 2));
    if (igraph_is_directed(graph)) {
        for (; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
            long int e = IGRAPH_EIT_GET(eit);
            VECTOR(*edges)[ptr++] = IGRAPH_FROM(graph, e);
            VECTOR(*edges)[ptr++] = IGRAPH_TO(graph, e);
        }
    } else {
        for (; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
            long int e = IGRAPH_EIT_GET(eit);
            VECTOR(*edges)[ptr++] = IGRAPH_TO(graph, e);
            VECTOR(*edges)[ptr++] = IGRAPH_FROM(graph, e);
        }
    }

    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/* This is an unsafe macro. Only supply variable names, i.e. no
   expressions as parameters, otherwise nasty things can happen */

#define BINSEARCH(start,end,value,iindex,edgelist,N,pos)     \
    do {                                                      \
        while ((start) < (end)) {                                 \
            long int mid=(start)+((end)-(start))/2;                 \
            long int e=(long int) VECTOR((iindex))[mid];            \
            if (VECTOR((edgelist))[e] < (value)) {                  \
                (start)=mid+1;                                        \
            } else {                                                \
                (end)=mid;                                            \
            }                                                       \
        }                                                         \
        if ((start)<(N)) {                                        \
            long int e=(long int) VECTOR((iindex))[(start)];        \
            if (VECTOR((edgelist))[e] == (value)) {                 \
                *(pos)=(igraph_integer_t) e;              \
            }                                                       \
        } } while(0)

#define FIND_DIRECTED_EDGE(graph,xfrom,xto,eid)                     \
    do {                                                              \
        long int start=(long int) VECTOR(graph->os)[xfrom];         \
        long int end=(long int) VECTOR(graph->os)[xfrom+1];         \
        long int N=end;                                                 \
        long int start2=(long int) VECTOR(graph->is)[xto];          \
        long int end2=(long int) VECTOR(graph->is)[xto+1];          \
        long int N2=end2;                                               \
        if (end-startoi,graph->to,N,eid);           \
        } else {                                                        \
            BINSEARCH(start2,end2,xfrom,graph->ii,graph->from,N2,eid);    \
        }                                                               \
    } while (0)

#define FIND_UNDIRECTED_EDGE(graph,from,to,eid)                     \
    do {                                                              \
        long int xfrom1= from > to ? from : to;                         \
        long int xto1= from > to ? to : from;                           \
        FIND_DIRECTED_EDGE(graph,xfrom1,xto1,eid);                      \
    } while (0)

/**
 * \function igraph_get_eid
 * \brief Get the edge id from the end points of an edge.
 *
 * For undirected graphs \c pfrom and \c pto are exchangeable.
 *
 * \param graph The graph object.
 * \param eid Pointer to an integer, the edge id will be stored here.
 * \param pfrom The starting point of the edge.
 * \param pto The end point of the edge.
 * \param directed Logical constant, whether to search for directed
 *        edges in a directed graph. Ignored for undirected graphs.
 * \param error Logical scalar, whether to report an error if the edge
 *        was not found. If it is false, then -1 will be assigned to \p eid.
 * \return Error code.
 * \sa \ref igraph_edge() for the opposite operation.
 *
 * Time complexity: O(log (d)), where d is smaller of the out-degree
 * of \c pfrom and in-degree of \c pto if \p directed is true. If \p directed
 * is false, then it is O(log(d)+log(d2)), where d is the same as before and
 * d2 is the minimum of the out-degree of \c pto and the in-degree of \c pfrom.
 *
 * \example examples/simple/igraph_get_eid.c
 *
 * Added in version 0.2.
 */

int igraph_get_eid(const igraph_t *graph, igraph_integer_t *eid,
                   igraph_integer_t pfrom, igraph_integer_t pto,
                   igraph_bool_t directed, igraph_bool_t error) {

    long int from = pfrom, to = pto;
    long int nov = igraph_vcount(graph);

    if (from < 0 || to < 0 || from > nov - 1 || to > nov - 1) {
        IGRAPH_ERROR("cannot get edge id", IGRAPH_EINVVID);
    }

    *eid = -1;
    if (igraph_is_directed(graph)) {

        /* Directed graph */
        FIND_DIRECTED_EDGE(graph, from, to, eid);
        if (!directed && *eid < 0) {
            FIND_DIRECTED_EDGE(graph, to, from, eid);
        }

    } else {

        /* Undirected graph, they only have one mode */
        FIND_UNDIRECTED_EDGE(graph, from, to, eid);

    }

    if (*eid < 0) {
        if (error) {
            IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
        }
    }

    return IGRAPH_SUCCESS;
}

int igraph_get_eids_pairs(const igraph_t *graph, igraph_vector_t *eids,
                          const igraph_vector_t *pairs,
                          igraph_bool_t directed, igraph_bool_t error);

int igraph_get_eids_path(const igraph_t *graph, igraph_vector_t *eids,
                         const igraph_vector_t *path,
                         igraph_bool_t directed, igraph_bool_t error);

int igraph_get_eids_pairs(const igraph_t *graph, igraph_vector_t *eids,
                          const igraph_vector_t *pairs,
                          igraph_bool_t directed, igraph_bool_t error) {
    long int n = igraph_vector_size(pairs);
    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    igraph_integer_t eid = -1;

    if (n % 2 != 0) {
        IGRAPH_ERROR("Cannot get edge ids, invalid length of edge ids",
                     IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(pairs, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot get edge ids, invalid vertex id", IGRAPH_EINVVID);
    }

    IGRAPH_CHECK(igraph_vector_resize(eids, n / 2));

    if (igraph_is_directed(graph)) {
        for (i = 0; i < n / 2; i++) {
            long int from = (long int) VECTOR(*pairs)[2 * i];
            long int to = (long int) VECTOR(*pairs)[2 * i + 1];

            eid = -1;
            FIND_DIRECTED_EDGE(graph, from, to, &eid);
            if (!directed && eid < 0) {
                FIND_DIRECTED_EDGE(graph, to, from, &eid);
            }

            VECTOR(*eids)[i] = eid;
            if (eid < 0 && error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    } else {
        for (i = 0; i < n / 2; i++) {
            long int from = (long int) VECTOR(*pairs)[2 * i];
            long int to = (long int) VECTOR(*pairs)[2 * i + 1];

            eid = -1;
            FIND_UNDIRECTED_EDGE(graph, from, to, &eid);
            VECTOR(*eids)[i] = eid;
            if (eid < 0 && error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    }

    return 0;
}

int igraph_get_eids_path(const igraph_t *graph, igraph_vector_t *eids,
                         const igraph_vector_t *path,
                         igraph_bool_t directed, igraph_bool_t error) {

    long int n = igraph_vector_size(path);
    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    igraph_integer_t eid = -1;

    if (!igraph_vector_isininterval(path, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot get edge ids, invalid vertex id", IGRAPH_EINVVID);
    }

    IGRAPH_CHECK(igraph_vector_resize(eids, n == 0 ? 0 : n - 1));

    if (igraph_is_directed(graph)) {
        for (i = 0; i < n - 1; i++) {
            long int from = (long int) VECTOR(*path)[i];
            long int to = (long int) VECTOR(*path)[i + 1];

            eid = -1;
            FIND_DIRECTED_EDGE(graph, from, to, &eid);
            if (!directed && eid < 0) {
                FIND_DIRECTED_EDGE(graph, to, from, &eid);
            }

            VECTOR(*eids)[i] = eid;
            if (eid < 0 && error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    } else {
        for (i = 0; i < n - 1; i++) {
            long int from = (long int) VECTOR(*path)[i];
            long int to = (long int) VECTOR(*path)[i + 1];

            eid = -1;
            FIND_UNDIRECTED_EDGE(graph, from, to, &eid);
            VECTOR(*eids)[i] = eid;
            if (eid < 0 && error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    }

    return 0;
}

/**
 * \function igraph_get_eids
 * Return edge ids based on the adjacent vertices.
 *
 * This function operates in two modes. If the \c pairs argument is
 * not a null pointer, but the \c path argument is, then it searches
 * for the edge ids of all pairs of vertices given in \c pairs. The
 * pairs of vertex ids are taken consecutively from the vector,
 * i.e. VECTOR(pairs)[0] and
 * VECTOR(pairs)[1] give the first
 * pair, VECTOR(pairs)[2] and
 * VECTOR(pairs)[3] the second pair, etc.
 *
 * 
 * If the \c pairs argument is a null pointer, and \c path is not a
 * null pointer, then the \c path is interpreted as a path given by
 * vertex ids and the edges along the path are returned.
 *
 * 
 * If neither \c pairs nor \c path are null pointers, then both are
 * considered (first \c pairs and then \c path), and the results are
 * concatenated.
 *
 * 
 * If the \c error argument is true, then it is an error to give pairs
 * of vertices that are not connected. Otherwise -1 is
 * reported for not connected vertices.
 *
 * 
 * If there are multiple edges in the graph, then these are ignored;
 * i.e. for a given pair of vertex ids, always the same edge id is
 * returned, even if the pair is given multiple time in \c pairs or in
 * \c path. See \ref igraph_get_eids_multi() for a similar function
 * that works differently in case of multiple edges.
 *
 * \param graph The input graph.
 * \param eids Pointer to an initialized vector, the result is stored
 *        here. It will be resized as needed.
 * \param pairs Vector giving pairs of vertices, or a null pointer.
 * \param path Vector giving vertex ids along a path, or a null
 *        pointer.
 * \param directed Logical scalar, whether to consider edge directions
 *        in directed graphs. This is ignored for undirected graphs.
 * \param error Logical scalar, whether it is an error to supply
 *        non-connected vertices. If false, then -1 is
 *        returned for non-connected pairs.
 * \return Error code.
 *
 * Time complexity: O(n log(d)), where n is the number of queried
 * edges and d is the average degree of the vertices.
 *
 * \sa \ref igraph_get_eid() for a single edge, \ref
 * igraph_get_eids_multi() for a version that handles multiple edges
 * better (at a cost).
 *
 * \example examples/simple/igraph_get_eids.c
 */

int igraph_get_eids(const igraph_t *graph, igraph_vector_t *eids,
                    const igraph_vector_t *pairs,
                    const igraph_vector_t *path,
                    igraph_bool_t directed, igraph_bool_t error) {

    if (!pairs && !path) {
        igraph_vector_clear(eids);
        return 0;
    } else if (pairs && !path) {
        return igraph_get_eids_pairs(graph, eids, pairs, directed, error);
    } else if (!pairs && path) {
        return igraph_get_eids_path(graph, eids, path, directed, error);
    } else {
        /* both */
        igraph_vector_t tmp;
        IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
        IGRAPH_CHECK(igraph_get_eids_pairs(graph, eids, pairs, directed, error));
        IGRAPH_CHECK(igraph_get_eids_path(graph, &tmp, path, directed, error));
        IGRAPH_CHECK(igraph_vector_append(eids, &tmp));
        igraph_vector_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
        return 0;
    }
}

#undef BINSEARCH
#undef FIND_DIRECTED_EDGE
#undef FIND_UNDIRECTED_EDGE

#define BINSEARCH(start,end,value,iindex,edgelist,N,pos,seen)    \
    do {                                                      \
        while ((start) < (end)) {                                 \
            long int mid=(start)+((end)-(start))/2;                 \
            long int e=(long int) VECTOR((iindex))[mid];        \
            if (VECTOR((edgelist))[e] < (value)) {                  \
                (start)=mid+1;                                        \
            } else {                                                \
                (end)=mid;                                            \
            }                                                       \
        }                                                         \
        if ((start)<(N)) {                                        \
            long int e=(long int) VECTOR((iindex))[(start)];        \
            while ((start)<(N) && seen[e] && VECTOR(edgelist)[e] == (value)) {  \
                (start)++;                        \
                e=(long int) VECTOR(iindex)[(start)];         \
            }                                           \
            if ((start)<(N) && !(seen[e]) && VECTOR(edgelist)[e] == (value)) {  \
                *(pos)=(igraph_integer_t) e;                  \
            }                                                       \
        } } while(0)

#define FIND_DIRECTED_EDGE(graph,xfrom,xto,eid,seen)            \
    do {                                                              \
        long int start=(long int) VECTOR(graph->os)[xfrom];         \
        long int end=(long int) VECTOR(graph->os)[xfrom+1];         \
        long int N=end;                                                 \
        long int start2=(long int) VECTOR(graph->is)[xto];          \
        long int end2=(long int) VECTOR(graph->is)[xto+1];          \
        long int N2=end2;                                               \
        if (end-startoi,graph->to,N,eid,seen);      \
        } else {                                                        \
            BINSEARCH(start2,end2,xfrom,graph->ii,graph->from,N2,eid,seen);   \
        }                                                               \
    } while (0)

#define FIND_UNDIRECTED_EDGE(graph,from,to,eid,seen)            \
    do {                                                              \
        long int xfrom1= from > to ? from : to;                         \
        long int xto1= from > to ? to : from;                           \
        FIND_DIRECTED_EDGE(graph,xfrom1,xto1,eid,seen);         \
    } while (0)


int igraph_get_eids_multipairs(const igraph_t *graph, igraph_vector_t *eids,
                               const igraph_vector_t *pairs,
                               igraph_bool_t directed, igraph_bool_t error);

int igraph_get_eids_multipath(const igraph_t *graph, igraph_vector_t *eids,
                              const igraph_vector_t *path,
                              igraph_bool_t directed, igraph_bool_t error);

int igraph_get_eids_multipairs(const igraph_t *graph, igraph_vector_t *eids,
                               const igraph_vector_t *pairs,
                               igraph_bool_t directed, igraph_bool_t error) {

    long int n = igraph_vector_size(pairs);
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t *seen;
    long int i;
    igraph_integer_t eid = -1;

    if (n % 2 != 0) {
        IGRAPH_ERROR("Cannot get edge ids, invalid length of edge ids",
                     IGRAPH_EINVAL);
    }
    if (!igraph_vector_isininterval(pairs, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot get edge ids, invalid vertex id", IGRAPH_EINVVID);
    }

    seen = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
    if (seen == 0) {
        IGRAPH_ERROR("Cannot get edge ids", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, seen);
    IGRAPH_CHECK(igraph_vector_resize(eids, n / 2));

    if (igraph_is_directed(graph)) {
        for (i = 0; i < n / 2; i++) {
            long int from = (long int) VECTOR(*pairs)[2 * i];
            long int to = (long int) VECTOR(*pairs)[2 * i + 1];

            eid = -1;
            FIND_DIRECTED_EDGE(graph, from, to, &eid, seen);
            if (!directed && eid < 0) {
                FIND_DIRECTED_EDGE(graph, to, from, &eid, seen);
            }

            VECTOR(*eids)[i] = eid;
            if (eid >= 0) {
                seen[(long int)(eid)] = 1;
            } else if (error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    } else {
        for (i = 0; i < n / 2; i++) {
            long int from = (long int) VECTOR(*pairs)[2 * i];
            long int to = (long int) VECTOR(*pairs)[2 * i + 1];

            eid = -1;
            FIND_UNDIRECTED_EDGE(graph, from, to, &eid, seen);
            VECTOR(*eids)[i] = eid;
            if (eid >= 0) {
                seen[(long int)(eid)] = 1;
            } else if (error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    }

    IGRAPH_FREE(seen);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

int igraph_get_eids_multipath(const igraph_t *graph, igraph_vector_t *eids,
                              const igraph_vector_t *path,
                              igraph_bool_t directed, igraph_bool_t error) {

    long int n = igraph_vector_size(path);
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t *seen;
    long int i;
    igraph_integer_t eid = -1;

    if (!igraph_vector_isininterval(path, 0, no_of_nodes - 1)) {
        IGRAPH_ERROR("Cannot get edge ids, invalid vertex id", IGRAPH_EINVVID);
    }

    seen = IGRAPH_CALLOC(no_of_edges, igraph_bool_t);
    if (!seen) {
        IGRAPH_ERROR("Cannot get edge ids", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, seen);
    IGRAPH_CHECK(igraph_vector_resize(eids, n == 0 ? 0 : n - 1));

    if (igraph_is_directed(graph)) {
        for (i = 0; i < n - 1; i++) {
            long int from = (long int) VECTOR(*path)[i];
            long int to = (long int) VECTOR(*path)[i + 1];

            eid = -1;
            FIND_DIRECTED_EDGE(graph, from, to, &eid, seen);
            if (!directed && eid < 0) {
                FIND_DIRECTED_EDGE(graph, to, from, &eid, seen);
            }

            VECTOR(*eids)[i] = eid;
            if (eid >= 0) {
                seen[(long int)(eid)] = 1;
            } else if (error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    } else {
        for (i = 0; i < n - 1; i++) {
            long int from = (long int) VECTOR(*path)[i];
            long int to = (long int) VECTOR(*path)[i + 1];

            eid = -1;
            FIND_UNDIRECTED_EDGE(graph, from, to, &eid, seen);
            VECTOR(*eids)[i] = eid;
            if (eid >= 0) {
                seen[(long int)(eid)] = 1;
            } else if (error) {
                IGRAPH_ERROR("Cannot get edge id, no such edge", IGRAPH_EINVAL);
            }
        }
    }

    IGRAPH_FREE(seen);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

#undef BINSEARCH
#undef FIND_DIRECTED_EDGE
#undef FIND_UNDIRECTED_EDGE

/**
 * \function igraph_get_eids_multi
 * \brief Query edge ids based on their adjacent vertices, handle multiple edges.
 *
 * This function operates in two modes. If the \c pairs argument is
 * not a null pointer, but the \c path argument is, then it searches
 * for the edge ids of all pairs of vertices given in \c pairs. The
 * pairs of vertex ids are taken consecutively from the vector,
 * i.e. VECTOR(pairs)[0] and
 * VECTOR(pairs)[1] give the first pair,
 * VECTOR(pairs)[2] and VECTOR(pairs)[3] the
 * second pair, etc.
 *
 * 
 * If the \c pairs argument is a null pointer, and \c path is not a
 * null pointer, then the \c path is interpreted as a path given by
 * vertex ids and the edges along the path are returned.
 *
 * 
 * If the \c error argument is true, then it is an error to give pairs of
 * vertices that are not connected. Otherwise -1 is
 * returned for not connected vertex pairs.
 *
 * 
 * An error is triggered if both \c pairs and \c path are non-null
 * pointers.
 *
 * 
 * This function handles multiple edges properly, i.e. if the same
 * pair is given multiple times and they are indeed connected by
 * multiple edges, then each time a different edge id is reported.
 *
 * \param graph The input graph.
 * \param eids Pointer to an initialized vector, the result is stored
 *        here. It will be resized as needed.
 * \param pairs Vector giving pairs of vertices, or a null pointer.
 * \param path Vector giving vertex ids along a path, or a null
 *        pointer.
 * \param directed Logical scalar, whether to consider edge directions
 *        in directed graphs. This is ignored for undirected graphs.
 * \param error Logical scalar, whether to report an error if
 *        non-connected vertices are specified. If false, then -1
 *        is returned for non-connected vertex pairs.
 * \return Error code.
 *
 * Time complexity: O(|E|+n log(d)), where |E| is the number of edges
 * in the graph, n is the number of queried edges and d is the average
 * degree of the vertices.
 *
 * \sa \ref igraph_get_eid() for a single edge, \ref
 * igraph_get_eids() for a faster version that does not handle
 * multiple edges.
 */

int igraph_get_eids_multi(const igraph_t *graph, igraph_vector_t *eids,
                          const igraph_vector_t *pairs,
                          const igraph_vector_t *path,
                          igraph_bool_t directed, igraph_bool_t error) {

    if (!pairs && !path) {
        igraph_vector_clear(eids);
        return 0;
    } else if (pairs && !path) {
        return igraph_get_eids_multipairs(graph, eids, pairs, directed, error);
    } else if (!pairs && path) {
        return igraph_get_eids_multipath(graph, eids, path, directed, error);
    } else { /* both */
        IGRAPH_ERROR("Give `pairs' or `path' but not both", IGRAPH_EINVAL);
    }
}

/**
 * \function igraph_incident
 * \brief Gives the incident edges of a vertex.
 *
 * \param graph The graph object.
 * \param eids An initialized \type vector_t object. It will be resized
 * to hold the result.
 * \param pnode A vertex id.
 * \param mode Specifies what kind of edges to include for directed
 * graphs. \c IGRAPH_OUT means only outgoing edges, \c IGRAPH_IN only
 * incoming edges, \c IGRAPH_ALL both. This parameter is ignored for
 * undirected graphs.
 * \return Error code. \c IGRAPH_EINVVID: invalid \p pnode argument,
 *   \c IGRAPH_EINVMODE: invalid \p mode argument.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(d), the number of incident edges to \p pnode.
 */

int igraph_incident(const igraph_t *graph, igraph_vector_t *eids, igraph_integer_t pnode,
        igraph_neimode_t mode) {
    if (!igraph_is_directed(graph) || mode == IGRAPH_ALL) {
        return igraph_i_incident(graph, eids, pnode, mode, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);
    } else {
        return igraph_i_incident(graph, eids, pnode, mode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    }
}

int igraph_i_incident(const igraph_t *graph, igraph_vector_t *eids, igraph_integer_t pnode,
        igraph_neimode_t mode, igraph_loops_t loops, igraph_multiple_t multiple) {
#define DEDUPLICATE_IF_NEEDED(vertex, n)                                                 \
    if (should_filter_duplicates) {                                                        \
        if ((loops == IGRAPH_NO_LOOPS && vertex == pnode) ||                               \
                (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) ||  \
                (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added)) {                \
            length -= n;                                                                   \
            continue;                                                                      \
        } else {                                                                           \
            last_added = vertex;                                                           \
        }                                                                                  \
    }
    long int length = 0, idx = 0;
    long int i, j;

    long int node = pnode;
    igraph_real_t last_added = -1;

    igraph_bool_t should_filter_duplicates;

    if (node < 0 || node > igraph_vcount(graph) - 1) {
        IGRAPH_ERROR("Given vertex is not in the graph.", IGRAPH_EINVVID);
    }
    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) {
        IGRAPH_ERROR("For a directed graph (with directions not ignored), "
                     "IGRAPH_LOOPS_TWICE does not make sense.\n", IGRAPH_EINVAL);
    }

    /* Calculate needed space first & allocate it */
    /* Note that 'mode' is treated as a bit field here; it's okay because
     * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */
    if (mode & IGRAPH_OUT) {
        length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]);
    }
    if (mode & IGRAPH_IN) {
        length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]);
    }

    IGRAPH_CHECK(igraph_vector_resize(eids, length));

    /* The loops below produce an ordering what is consistent with the
     * ordering returned by igraph_neighbors(), and this should be preserved.
     * We are dealing with two sorted lists; one for the successors and one
     * for the predecessors. If we have requested only one of them, we have
     * an easy job. If we have requested both, we need to merge the two lists
     * to ensure that the output is sorted by the vertex IDs of the "other"
     * endpoint of the affected edges */
    if (!igraph_is_directed(graph) || mode != IGRAPH_ALL) {
        /* We did not ask for both directions; this is the easy case */

        should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE &&
                ((!igraph_is_directed(graph) && loops == IGRAPH_LOOPS_TWICE) ||
                 (igraph_is_directed(graph) && loops != IGRAPH_NO_LOOPS)));

        if (mode & IGRAPH_OUT) {
            j = (long int) VECTOR(graph->os)[node + 1];
            for (i = (long int) VECTOR(graph->os)[node]; i < j; i++) {
                long int edge = VECTOR(graph->oi)[i];
                igraph_real_t other = VECTOR(graph->to)[edge];
                DEDUPLICATE_IF_NEEDED(other, 1);
                VECTOR(*eids)[idx++] = edge;
            }
        }
        if (mode & IGRAPH_IN) {
            j = (long int) VECTOR(graph->is)[node + 1];
            for (i = (long int) VECTOR(graph->is)[node]; i < j; i++) {
                long int edge = VECTOR(graph->ii)[i];
                igraph_real_t other = VECTOR(graph->from)[edge];
                DEDUPLICATE_IF_NEEDED(other, 1);
                VECTOR(*eids)[idx++] = edge;
            }
        }
    } else {
        /* both in- and out- neighbors in a directed graph,
           we need to merge the two 'vectors' */
        long int j1 = (long int) VECTOR(graph->os)[node + 1];
        long int j2 = (long int) VECTOR(graph->is)[node + 1];
        long int i1 = (long int) VECTOR(graph->os)[node];
        long int i2 = (long int) VECTOR(graph->is)[node];
        long int eid1, eid2;
        long int n1, n2;

        should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE &&
                loops == IGRAPH_LOOPS_TWICE);

        while (i1 < j1 && i2 < j2) {
            eid1 = (long int) VECTOR(graph->oi)[i1];
            eid2 = (long int) VECTOR(graph->ii)[i2];
            n1 = (long int) VECTOR(graph->to)[eid1];
            n2 = (long int) VECTOR(graph->from)[eid2];
            if (n1 < n2) {
                i1++;
                DEDUPLICATE_IF_NEEDED(n1, 1);
                VECTOR(*eids)[idx++] = eid1;
            } else if (n1 > n2) {
                i2++;
                DEDUPLICATE_IF_NEEDED(n2, 1);
                VECTOR(*eids)[idx++] = eid2;
            } else {
                i1++;
                i2++;
                DEDUPLICATE_IF_NEEDED(n2, 2);
                VECTOR(*eids)[idx++] = eid1;
                if (should_filter_duplicates && ((loops == IGRAPH_LOOPS_ONCE && n1 == pnode && last_added == pnode) ||
                        (multiple == IGRAPH_NO_MULTIPLE))) {
                    length--;
                    continue;
                }
                VECTOR(*eids)[idx++] = eid2;
            }
        }

        while (i1 < j1) {
            eid1 = VECTOR(graph->oi)[i1++];
            igraph_real_t to = VECTOR(graph->to)[eid1];
            DEDUPLICATE_IF_NEEDED(to, 1);
            VECTOR(*eids)[idx++] = eid1;
        }

        while (i2 < j2) {
            eid2 = VECTOR(graph->ii)[i2++];
            igraph_real_t from = VECTOR(graph->from)[eid2];
            DEDUPLICATE_IF_NEEDED(from, 1);
            VECTOR(*eids)[idx++] = eid2;
        }
    }
    IGRAPH_CHECK(igraph_vector_resize(eids, length));
    return IGRAPH_SUCCESS;
#undef DEDUPLICATE_IF_NEEDED
}


/**
 * \function igraph_is_same_graph
 * \brief Are two graphs identical as labelled graphs?
 *
 * Two graphs are considered to be the same if they have the same vertex and edge sets.
 * Graphs which are the same may have multiple different representations in igraph,
 * hence the need for this function.
 *
 * 
 * This function verifies that the two graphs have the same directedness, the same
 * number of vertices, and that they contain precisely the same edges (regardless of their ordering)
 * when written in terms of vertex indices. Graph attributes are not taken into account.
 *
 * 
 * This concept is different from isomorphism. For example, the graphs
 * 0-1, 2-1 and 1-2, 0-1 are considered the same
 * because they only differ in the ordering of their edge lists and the ordering
 * of vertices in an undirected edge. However, they are not the same as
 * 0-2, 1-2, even though they are isomorphic to it.
 * Note that this latter graph contains the edge 0-2
 * while the former two do not — thus their edge sets differ.
 *
 * \param graph1 The first graph object.
 * \param graph2 The second graph object.
 * \param res The result will be stored here.
 * \return Error code.
 *
 * Time complexity: O(E), the number of edges in the graphs.
 *
 * \sa igraph_isomorphic() to test if two graphs are isomorphic.
 */

int igraph_is_same_graph(const igraph_t *graph1, const igraph_t *graph2, igraph_bool_t *res) {
    long int nv1 = igraph_vcount(graph1);
    long int nv2 = igraph_vcount(graph2);
    long int ne1 = igraph_ecount(graph1);
    long int ne2 = igraph_ecount(graph2);
    long int i, eid1, eid2;

    *res = 0; /* Assume that the graphs differ */

    /* Check for same number of vertices/edges */
    if ((nv1 != nv2) || (ne1 != ne2)) {
        return IGRAPH_SUCCESS;
    }

    /* Check for same directedness */
    if (igraph_is_directed(graph1) != igraph_is_directed(graph2)) {
        return IGRAPH_SUCCESS;
    }

    /* Vertices have no names, so they must be 0 to nv - 1 */

    /* Edges are double sorted in the current representations ii/oi of
     * igraph_t (ii: by incoming, then outgoing, oi: vice versa), so
     * we just need to check them one by one. If that representation
     * changes, this part will need to change too.
     *
     * Furthermore, in the current representation the "source" of undirected
     * edges always has a vertex index that is no larger than that of the
     * "target".
     */
    for (i = 0; i < ne1; i++) {
        eid1 = (long int) VECTOR(graph1->ii)[i];
        eid2 = (long int) VECTOR(graph2->ii)[i];

        /* Check they have the same source */
        if (IGRAPH_FROM(graph1, eid1) != IGRAPH_FROM(graph2, eid2)) {
            return IGRAPH_SUCCESS;
        }

        /* Check they have the same target */
        if (IGRAPH_TO(graph1, eid1) != IGRAPH_TO(graph2, eid2)) {
            return IGRAPH_SUCCESS;
        }
    }

    *res = 1; /* No difference was found, graphs are the same */
    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/graph/visitors.c0000644000175100001710000005667400000000000023612 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R package.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_visitor.h"
#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_dqueue.h"
#include "igraph_stack.h"

/**
 * \function igraph_bfs
 * Breadth-first search
 *
 * A simple breadth-first search, with a lot of different results and
 * the possibility to call a callback whenever a vertex is visited.
 * It is allowed to supply null pointers as the output arguments the
 * user is not interested in, in this case they will be ignored.
 *
 * 
 * If not all vertices can be reached from the supplied root vertex,
 * then additional root vertices will be used, in the order of their
 * vertex ids.
 *
 * 
 * Consider using \ref igraph_bfs_simple instead if you set most of the output
 * arguments provided by this function to a null pointer.
 *
 * \param graph The input graph.
 * \param root The id of the root vertex. It is ignored if the \c
 *        roots argument is not a null pointer.
 * \param roots Pointer to an initialized vector, or a null
 *        pointer. If not a null pointer, then it is a vector
 *        containing root vertices to start the BFS from. The vertices
 *        are considered in the order they appear. If a root vertex
 *        was already found while searching from another one, then no
 *        search is conducted from it.
 * \param mode For directed graphs, it defines which edges to follow.
 *        \c IGRAPH_OUT means following the direction of the edges,
 *        \c IGRAPH_IN means the opposite, and
 *        \c IGRAPH_ALL ignores the direction of the edges.
 *        This parameter is ignored for undirected graphs.
 * \param unreachable Logical scalar, whether the search should visit
 *        the vertices that are unreachable from the given root
 *        node(s). If true, then additional searches are performed
 *        until all vertices are visited.
 * \param restricted If not a null pointer, then it must be a pointer
 *        to a vector containing vertex ids. The BFS is carried out
 *        only on these vertices.
 * \param order If not null pointer, then the vertex ids of the graph are
 *        stored here, in the same order as they were visited.
 * \param rank If not a null pointer, then the rank of each vertex is
 *        stored here.
 * \param father If not a null pointer, then the id of the father of
 *        each vertex is stored here.
 * \param pred If not a null pointer, then the id of vertex that was
 *        visited before the current one is stored here. If there is
 *        no such vertex (the current vertex is the root of a search
 *        tree), then -1 is stored.
 * \param succ If not a null pointer, then the id of the vertex that
 *        was visited after the current one is stored here. If there
 *        is no such vertex (the current one is the last in a search
 *        tree), then -1 is stored.
 * \param dist If not a null pointer, then the distance from the root of
 *        the current search tree is stored here.
 * \param callback If not null, then it should be a pointer to a
 *        function of type \ref igraph_bfshandler_t. This function
 *        will be called, whenever a new vertex is visited.
 * \param extra Extra argument to pass to the callback function.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 *
 * \example examples/simple/igraph_bfs.c
 * \example examples/simple/igraph_bfs_callback.c
 */
int igraph_bfs(const igraph_t *graph,
               igraph_integer_t root, const igraph_vector_t *roots,
               igraph_neimode_t mode, igraph_bool_t unreachable,
               const igraph_vector_t *restricted,
               igraph_vector_t *order, igraph_vector_t *rank,
               igraph_vector_t *father,
               igraph_vector_t *pred, igraph_vector_t *succ,
               igraph_vector_t *dist, igraph_bfshandler_t *callback,
               void *extra) {

    igraph_dqueue_t Q;
    long int no_of_nodes = igraph_vcount(graph);
    long int actroot = 0;
    igraph_vector_char_t added;

    igraph_lazy_adjlist_t adjlist;

    long int act_rank = 0;
    long int pred_vec = -1;

    long int rootpos = 0;
    long int noroots = roots ? igraph_vector_size(roots) : 1;

    if (!roots && (root < 0 || root >= no_of_nodes)) {
        IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
    }

    if (roots) {
        igraph_real_t min, max;
        igraph_vector_minmax(roots, &min, &max);
        if (min < 0 || max >= no_of_nodes) {
            IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
        }
    }

    if (restricted) {
        igraph_real_t min, max;
        igraph_vector_minmax(restricted, &min, &max);
        if (min < 0 || max >= no_of_nodes) {
            IGRAPH_ERROR("Invalid vertex id in restricted set", IGRAPH_EINVAL);
        }
    }

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
    IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);

    /* Mark the vertices that are not in the restricted set, as already
       found. Special care must be taken for vertices that are not in
       the restricted set, but are to be used as 'root' vertices. */
    if (restricted) {
        long int i, n = igraph_vector_size(restricted);
        igraph_vector_char_fill(&added, 1);
        for (i = 0; i < n; i++) {
            long int v = (long int) VECTOR(*restricted)[i];
            VECTOR(added)[v] = 0;
        }
    }

    /* Resize result vectors, and fill them with IGRAPH_NAN */

# define VINIT(v) if (v) {                      \
        igraph_vector_resize((v), no_of_nodes);   \
        igraph_vector_fill((v), IGRAPH_NAN); }

    VINIT(order);
    VINIT(rank);
    VINIT(father);
    VINIT(pred);
    VINIT(succ);
    VINIT(dist);
# undef VINIT

    while (1) {

        /* Get the next root vertex, if any */

        if (roots && rootpos < noroots) {
            /* We are still going through the 'roots' vector */
            actroot = (long int) VECTOR(*roots)[rootpos++];
        } else if (!roots && rootpos == 0) {
            /* We have a single root vertex given, and start now */
            actroot = root;
            rootpos++;
        } else if (rootpos == noroots && unreachable) {
            /* We finished the given root(s), but other vertices are also
            tried as root */
            actroot = 0;
            rootpos++;
        } else if (unreachable && actroot + 1 < no_of_nodes) {
            /* We are already doing the other vertices, take the next one */
            actroot++;
        } else {
            /* No more root nodes to do */
            break;
        }

        /* OK, we have a new root, start BFS */
        if (VECTOR(added)[actroot]) {
            continue;
        }
        IGRAPH_CHECK(igraph_dqueue_push(&Q, actroot));
        IGRAPH_CHECK(igraph_dqueue_push(&Q, 0));
        VECTOR(added)[actroot] = 1;
        if (father) {
            VECTOR(*father)[actroot] = -1;
        }

        pred_vec = -1;

        while (!igraph_dqueue_empty(&Q)) {
            long int actvect = (long int) igraph_dqueue_pop(&Q);
            long int actdist = (long int) igraph_dqueue_pop(&Q);
            long int succ_vec;
            igraph_vector_int_t *neis = igraph_lazy_adjlist_get(&adjlist,
                                    (igraph_integer_t) actvect);
            long int i, n = igraph_vector_int_size(neis);

            if (pred) {
                VECTOR(*pred)[actvect] = pred_vec;
            }
            if (rank) {
                VECTOR(*rank) [actvect] = act_rank;
            }
            if (order) {
                VECTOR(*order)[act_rank++] = actvect;
            }
            if (dist) {
                VECTOR(*dist)[actvect] = actdist;
            }

            for (i = 0; i < n; i++) {
                long int nei = (long int) VECTOR(*neis)[i];
                if (! VECTOR(added)[nei]) {
                    VECTOR(added)[nei] = 1;
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, actdist + 1));
                    if (father) {
                        VECTOR(*father)[nei] = actvect;
                    }
                }
            }

            succ_vec = igraph_dqueue_empty(&Q) ? -1L :
                       (long int) igraph_dqueue_head(&Q);
            if (callback) {
                igraph_bool_t terminate =
                    callback(graph, (igraph_integer_t) actvect, (igraph_integer_t)
                             pred_vec, (igraph_integer_t) succ_vec,
                             (igraph_integer_t) act_rank - 1, (igraph_integer_t) actdist,
                             extra);
                if (terminate) {
                    igraph_lazy_adjlist_destroy(&adjlist);
                    igraph_dqueue_destroy(&Q);
                    igraph_vector_char_destroy(&added);
                    IGRAPH_FINALLY_CLEAN(3);
                    return 0;
                }
            }

            if (succ) {
                VECTOR(*succ)[actvect] = succ_vec;
            }
            pred_vec = actvect;

        } /* while Q !empty */

    } /* for actroot < no_of_nodes */

    igraph_lazy_adjlist_destroy(&adjlist);
    igraph_dqueue_destroy(&Q);
    igraph_vector_char_destroy(&added);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_bfs_simple
 * Breadth-first search, single-source version
 *
 * An alternative breadth-first search implementation to cater for the
 * simpler use-cases when only a single breadth-first search has to be conducted
 * from a source node and most of the output arguments from \ref igraph_bfs
 * are not needed. It is allowed to supply null pointers as
 * the output arguments the user is not interested in, in this case they will
 * be ignored.
 *
 * \param graph The input graph.
 * \param vid The id of the root vertex.
 * \param mode For directed graphs, it defines which edges to follow.
 *        \c IGRAPH_OUT means following the direction of the edges,
 *        \c IGRAPH_IN means the opposite, and
 *        \c IGRAPH_ALL ignores the direction of the edges.
 *        This parameter is ignored for undirected graphs.
 * \param vids If not a null pointer, then an initialized vector must be passed
 *        here. The ids of the vertices visited during the traversal will be
 *        stored here, in the same order as they were visited.
 * \param layers If not a null pointer, then an initialized vector must be
 *        passed here. The i-th element of the vector will contain the index
 *        into \c vids where the vertices that are at distance i from the root
 *        are stored. In other words, if you are interested in the vertices that
 *        are at distance i from the root, you need to look in the \c vids
 *        vector from \c layers[i] to \c layers[i+1].
 * \param parents If not a null pointer, then an initialized vector must be
 *        passed here. The vector will be resized so its length is equal to the
 *        number of nodes, and it will contain the index of the parent node for
 *        each \em visited node. The values in the vector are undefined for
 *        vertices that were \em not visited.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 *
 * \example examples/simple/igraph_bfs_simple.c
 */
int igraph_bfs_simple(igraph_t *graph, igraph_integer_t vid, igraph_neimode_t mode,
                      igraph_vector_t *vids, igraph_vector_t *layers,
                      igraph_vector_t *parents) {

    igraph_dqueue_t q;
    long int num_visited = 0;
    igraph_vector_t neis;
    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    char *added;
    long int lastlayer = -1;

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    /* temporary storage */
    added = IGRAPH_CALLOC(no_of_nodes, char);
    if (added == 0) {
        IGRAPH_ERROR("Cannot calculate BFS", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &q);

    /* results */
    if (vids) {
        igraph_vector_clear(vids);
    }
    if (layers) {
        igraph_vector_clear(layers);
    }
    if (parents) {
        IGRAPH_CHECK(igraph_vector_resize(parents, no_of_nodes));
    }

    /* ok start with vid */
    IGRAPH_CHECK(igraph_dqueue_push(&q, vid));
    IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
    if (layers) {
        IGRAPH_CHECK(igraph_vector_push_back(layers, num_visited));
    }
    if (vids) {
        IGRAPH_CHECK(igraph_vector_push_back(vids, vid));
    }
    if (parents) {
        VECTOR(*parents)[(long int)vid] = vid;
    }
    num_visited++;
    added[(long int)vid] = 1;

    while (!igraph_dqueue_empty(&q)) {
        long int actvect = (long int) igraph_dqueue_pop(&q);
        long int actdist = (long int) igraph_dqueue_pop(&q);
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actvect,
                                      mode));
        for (i = 0; i < igraph_vector_size(&neis); i++) {
            long int neighbor = (long int) VECTOR(neis)[i];
            if (added[neighbor] == 0) {
                added[neighbor] = 1;
                if (parents) {
                    VECTOR(*parents)[neighbor] = actvect;
                }
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                if (layers && lastlayer != actdist + 1) {
                    IGRAPH_CHECK(igraph_vector_push_back(layers, num_visited));
                }
                if (vids) {
                    IGRAPH_CHECK(igraph_vector_push_back(vids, neighbor));
                }
                num_visited++;
                lastlayer = actdist + 1;
            }
        } /* for i in neis */
    } /* while ! dqueue_empty */

    if (layers) {
        IGRAPH_CHECK(igraph_vector_push_back(layers, num_visited));
    }

    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(added);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_dfs
 * Depth-first search
 *
 * A simple depth-first search, with
 * the possibility to call a callback whenever a vertex is discovered
 * and/or whenever a subtree is finished.
 * It is allowed to supply null pointers as the output arguments the
 * user is not interested in, in this case they will be ignored.
 *
 * 
 * If not all vertices can be reached from the supplied root vertex,
 * then additional root vertices will be used, in the order of their
 * vertex ids.
 *
 * \param graph The input graph.
 * \param root The id of the root vertex.
 * \param mode For directed graphs, it defines which edges to follow.
 *        \c IGRAPH_OUT means following the direction of the edges,
 *        \c IGRAPH_IN means the opposite, and
 *        \c IGRAPH_ALL ignores the direction of the edges.
 *        This parameter is ignored for undirected graphs.
 * \param unreachable Logical scalar, whether the search should visit
 *        the vertices that are unreachable from the given root
 *        node(s). If true, then additional searches are performed
 *        until all vertices are visited.
 * \param order If not null pointer, then the vertex ids of the graph are
 *        stored here, in the same order as they were discovered.
 * \param order_out If not a null pointer, then the vertex ids of the
 *        graphs are stored here, in the order of the completion of
 *        their subtree.
 * \param father If not a null pointer, then the id of the father of
 *        each vertex is stored here.
 * \param dist If not a null pointer, then the distance from the root of
 *        the current search tree is stored here.
 * \param in_callback If not null, then it should be a pointer to a
 *        function of type \ref igraph_dfshandler_t. This function
 *        will be called, whenever a new vertex is discovered.
 * \param out_callback If not null, then it should be a pointer to a
 *        function of type \ref igraph_dfshandler_t. This function
 *        will be called, whenever the subtree of a vertex is completed.
 * \param extra Extra argument to pass to the callback function(s).
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 */

int igraph_dfs(const igraph_t *graph, igraph_integer_t root,
               igraph_neimode_t mode, igraph_bool_t unreachable,
               igraph_vector_t *order,
               igraph_vector_t *order_out, igraph_vector_t *father,
               igraph_vector_t *dist, igraph_dfshandler_t *in_callback,
               igraph_dfshandler_t *out_callback,
               void *extra) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_lazy_adjlist_t adjlist;
    igraph_stack_t stack;
    igraph_vector_char_t added;
    igraph_vector_long_t nptr;
    long int actroot;
    long int act_rank = 0;
    long int rank_out = 0;
    long int act_dist = 0;

    if (root < 0 || root >= no_of_nodes) {
        IGRAPH_ERROR("Invalid root vertex for DFS", IGRAPH_EINVAL);
    }

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
    IGRAPH_CHECK(igraph_stack_init(&stack, 100));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
    IGRAPH_CHECK(igraph_vector_long_init(&nptr, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &nptr);

# define FREE_ALL() do {            \
        igraph_vector_long_destroy(&nptr);            \
        igraph_lazy_adjlist_destroy(&adjlist);        \
        igraph_stack_destroy(&stack);                 \
        igraph_vector_char_destroy(&added);           \
        IGRAPH_FINALLY_CLEAN(4); } while (0)

    /* Resize result vectors and fill them with IGRAPH_NAN */

# define VINIT(v) if (v) {                      \
        igraph_vector_resize(v, no_of_nodes);       \
        igraph_vector_fill(v, IGRAPH_NAN); }

    VINIT(order);
    VINIT(order_out);
    VINIT(father);
    VINIT(dist);

# undef VINIT

    IGRAPH_CHECK(igraph_stack_push(&stack, root));
    VECTOR(added)[(long int)root] = 1;
    if (father) {
        VECTOR(*father)[(long int)root] = -1;
    }
    if (order) {
        VECTOR(*order)[act_rank++] = root;
    }
    if (dist) {
        VECTOR(*dist)[(long int)root] = 0;
    }
    if (in_callback) {
        igraph_bool_t terminate = in_callback(graph, root, 0, extra);
        if (terminate) {
            FREE_ALL();
            return 0;
        }
    }

    for (actroot = 0; actroot < no_of_nodes; ) {

        /* 'root' first, then all other vertices */
        if (igraph_stack_empty(&stack)) {
            if (!unreachable) {
                break;
            }
            if (VECTOR(added)[actroot]) {
                actroot++;
                continue;
            }
            IGRAPH_CHECK(igraph_stack_push(&stack, actroot));
            VECTOR(added)[actroot] = 1;
            if (father) {
                VECTOR(*father)[actroot] = -1;
            }
            if (order) {
                VECTOR(*order)[act_rank++] = actroot;
            }
            if (dist) {
                VECTOR(*dist)[actroot] = 0;
            }

            if (in_callback) {
                igraph_bool_t terminate = in_callback(graph, (igraph_integer_t) actroot,
                                                      0, extra);
                if (terminate) {
                    FREE_ALL();
                    return 0;
                }
            }
            actroot++;
        }

        while (!igraph_stack_empty(&stack)) {
            long int actvect = (long int) igraph_stack_top(&stack);
            igraph_vector_int_t *neis =
                igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) actvect);
            long int n = igraph_vector_int_size(neis);
            long int *ptr = igraph_vector_long_e_ptr(&nptr, actvect);

            /* Search for a neighbor that was not yet visited */
            igraph_bool_t any = 0;
            long int nei = 0;
            while (!any && (*ptr) < n) {
                nei = (long int) VECTOR(*neis)[(*ptr)];
                any = !VECTOR(added)[nei];
                (*ptr) ++;
            }
            if (any) {
                /* There is such a neighbor, add it */
                IGRAPH_CHECK(igraph_stack_push(&stack, nei));
                VECTOR(added)[nei] = 1;
                if (father) {
                    VECTOR(*father)[ nei ] = actvect;
                }
                if (order) {
                    VECTOR(*order)[act_rank++] = nei;
                }
                act_dist++;
                if (dist) {
                    VECTOR(*dist)[nei] = act_dist;
                }

                if (in_callback) {
                    igraph_bool_t terminate = in_callback(graph, (igraph_integer_t) nei,
                                                          (igraph_integer_t) act_dist,
                                                          extra);
                    if (terminate) {
                        FREE_ALL();
                        return 0;
                    }
                }

            } else {
                /* There is no such neighbor, finished with the subtree */
                igraph_stack_pop(&stack);
                if (order_out) {
                    VECTOR(*order_out)[rank_out++] = actvect;
                }
                act_dist--;

                if (out_callback) {
                    igraph_bool_t terminate = out_callback(graph, (igraph_integer_t)
                                                           actvect, (igraph_integer_t)
                                                           act_dist, extra);
                    if (terminate) {
                        FREE_ALL();
                        return 0;
                    }
                }
            }
        }
    }

    FREE_ALL();
# undef FREE_ALL

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5111408
igraph-0.9.9/vendor/source/igraph/src/hrg/0000755000175100001710000000000000000000000021221 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/dendro.h0000644000175100001710000002675200000000000022661 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

// ****************************************************************************************************
// *** COPYRIGHT NOTICE *******************************************************************************
// dendro_eq.h - hierarchical random graph (hrg) data structure
// Copyright (C) 2006-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ****************************************************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu | http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science AND Santa Fe Institute
// Created      : 19 April 2006
// Modified     : 19 May 2007
//           : 19 May 2008 (cleaned up for public consumption)
//
// ****************************************************************************************************
//
// Maximum likelihood dendrogram data structure. This is the heart of the HRG algorithm: all
// manipulations are done here and all data is stored here. The data structure uses the separate
// graph data structure to store the basic adjacency information (in a dangerously mutable way).
//
// Note: This version (dendro_eq.h) differs from other versions because it includes methods for
//       doing the consensus dendrogram calculation.
//
// ****************************************************************************************************

#ifndef IGRAPH_HRG_DENDRO
#define IGRAPH_HRG_DENDRO

#include "hrg/graph.h"
#include "hrg/rbtree.h"
#include "hrg/splittree_eq.h"

#include "igraph_hrg.h"

#include 
#include 

using namespace fitHRG;

namespace fitHRG {

// ***********************************************************************
// ******** Basic Structures *********************************************

#ifndef IGRAPH_HRG_LIST
#define IGRAPH_HRG_LIST

class list {
public:
    int x;            // stored elementd in linked-list
    list* next;           // pointer to next elementd
    list::list(): x(-1), next(0) { }
    list::~list() { }
};
#endif

enum {DENDRO, GRAPH, LEFT, RIGHT};
struct block {
    double x;
    int y;
};
struct ipair {
    int    x;
    int y;
    short int t;
    std::string sp;
};
struct child {
    int index;
    short int type;
    child* next;
};

// ***********************************************************************
// ******** Cnode Class **************************************************

#ifndef IGRAPH_HRG_CNODE
#define IGRAPH_HRG_CNODE
class cnode {
public:
    int index;            // array index of this node
    int degree;           // number of children in list
    int parent;           // index of parent node
    double weight;        // sampled posterior weight
    child* children;      // list of children (and their types)
    child* lastChild;     // pointer to last child in list
    cnode(): index(-1), degree(0), parent(-1), weight(0.0),
        children(0), lastChild(0)  { }
    ~cnode() {
        child *curr, *prev;
        curr = children;
        while (curr != NULL) {
            prev = curr;
            curr = curr->next;
            delete prev;
            prev = NULL;
        }
        lastChild = NULL;
    }
};
#endif

// ***********************************************************************
// ******** Split Class **************************************************

class split {
public:
    std::string s;           // partition assignment of leaf vertices
    split(): s("") { }
    ~split() { }
    void initializeSplit(const int n) {
        s = "";
        for (int i = 0; i < n; i++) {
            s += "-";
        }
    }
    bool checkSplit() {
        if (s.empty() || s.find("-", 0) != std::string::npos) {
            return false;
        } else {
            return true;
        }
    }
};

// ***********************************************************************
// ******** Internal Edge Class ******************************************
// The usefulness of this data structure is to provide an easy to way
// maintain the set of internal edges, and the corresponding splits,
// in the dendrogram D. It allows for the selection of a random
// internal edge in O(1) time, and it takes O(1) time to update its
// structure given an internal move. This structure does not provide
// any means to directly manipulate the splits, but does allow them to
// be replaced. A split has the form "int.int...int#int.int...int",
// where all ints on the left side of the # are in the left partition
// and all ints on the right side of the # marker are in the right
// partition defined by the split.

class interns {
private:
    ipair* edgelist;   // list of internal edges represented
    std::string* splitlist; // split representation of the internal edges
    int** indexLUT;    // table of indices of internal edges in edgelist
    int q;         // number of internal edges
    int count;         // (for adding edges) edgelist index of new edge to add
public:
    interns(const int);
    ~interns();

    // add an internal edge, O(1)
    bool addEdge(const int, const int, const short int);
    // returns the ith edge of edgelist, O(1)
    ipair* getEdge(const int);
    // returns a uniformly random internal edge, O(1)
    ipair* getRandomEdge();
    // returns the ith split of the splitlist, O(1)
    std::string getSplit(const int);
    // replace an existing split, O(1)
    bool replaceSplit(const int, const std::string);
    // swaps two edges, O(1)
    bool swapEdges(const int, const int, const short int, const int,
                   const int, const short int);
};

// ***********************************************************************
// ******** Tree elementd Class ******************************************

class elementd {
public:
    short int type; // either DENDRO or GRAPH
    double logL;    // log-likelihood contribution of this internal node
    double p;       // probability p_i that an edge exists between L and
    // R subtrees
    int e;      // number of edges between L and R subtrees
    int n;      // number of leafs in subtree rooted here
    int label;      // subtree label: smallest leaf index
    int index;      // index in containing array

    elementd *M;          // pointer to parent node
    elementd *L;          // pointer for L subtree
    elementd *R;          // pointer for R subtree

    elementd(): type(DENDRO), logL(0.0), p(0.0), e(0), n(0),
        label(-1), index(-1), M(0), L(0), R(0) { }
    ~elementd() { }
};

// ***********************************************************************
// ******** Dendrogram Class *********************************************

class dendro {
private:
    elementd* root;     // root of the dendrogram
    elementd* internal; // array of n-1 internal vertices (the dendrogram D)
    elementd* leaf;     // array of n   leaf vertices (the graph G)
    int n;          // number of leaf vertices to allocate
    interns* d;         // list of internal edges of dendrogram D
    splittree* splithist;       // histogram of cumulative split weights
    list** paths;           // array of path-lists from root to leaf
    double L;        // log-likelihood of graph G given dendrogram D
    rbtree subtreeL, subtreeR;  // trees for computeEdgeCount() function
    cnode* ctree;       // (consensus tree) array of internal tree nodes
    int* cancestor;     // (consensus tree) oldest ancetor's index for
    // each leaf

    // insert node i according to binary search property
    void binarySearchInsert(elementd*, elementd*);
    // return path to root from leaf
    list* binarySearchFind(const double);
    // build split for this internal edge
    std::string buildSplit(elementd*);
    // compute number of edges between two internal subtrees
    int computeEdgeCount(const int, const short int, const int,
                         const short int);
    // (consensus tree) counts children
    int countChildren(const std::string);
    // find internal node of D that is common ancestor of i,j
    elementd* findCommonAncestor(list**, const int, const int);
    // return reverse of path to leaf from root
    list* reversePathToRoot(const int);
// quicksort functions
    void QsortMain(block*, int, int);
    int QsortPartition(block*, int, int, int);

public:
    // underlying G (dangerously accessible)
    graph* g;

    // constructor / destructor
    dendro(); ~dendro();
    // build dendrogram from g
    void buildDendrogram();
    // delete dendrograph in prep for importDendrogramStructure
    void clearDendrograph();
    // read dendrogram structure from HRG structure
    bool importDendrogramStructure(const igraph_hrg_t *hrg);
    // (consensus tree) delete splits with less than 0.5 weight
    void cullSplitHist();
    // return size of consensus split
    int getConsensusSize();
    // return split tree with consensus splits
    splittree* getConsensusSplits();
    // return likelihood of G given D
    double getLikelihood();
    // store splits in this splittree
    void getSplitList(splittree*);
    // return total weight of splittree
    double getSplitTotalWeight();
    // make random G from D
    void makeRandomGraph();
    // make single MCMC move
    bool monteCarloMove(double&, bool&, const double);
    // record consensus tree from splithist
    void recordConsensusTree(igraph_vector_t *parents,
                             igraph_vector_t *weights);
    // record D structure
    void recordDendrogramStructure(igraph_hrg_t *hrg);
    // record G structure to igraph graph
    void recordGraphStructure(igraph_t *graph);
    // force refresh of log-likelihood value
    void refreshLikelihood();
    // sample dendrogram edge likelihoods and update edge histograms
    void sampleAdjacencyLikelihoods();
    // reset the dendrograph structures
    void resetDendrograph();
    // sample dendrogram's splits and update the split histogram
    bool sampleSplitLikelihoods(int&);
    // reset splits histogram
    void resetAllSplits();
};

} // namespace fitHRG

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/graph.h0000644000175100001710000001376200000000000022504 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

// ****************************************************************************************************
// *** COPYRIGHT NOTICE *******************************************************************************
// graph.h - graph data structure for hierarchical random graphs
// Copyright (C) 2005-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ****************************************************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu | http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science AND Santa Fe Institute
// Created      : 8 November 2005
// Modified     : 23 December 2007 (cleaned up for public consumption)
//
// ****************************************************************************************************
//
// Graph data structure for hierarchical random graphs. The basic structure is an adjacency list of
// edges; however, many additional pieces of metadata are stored as well. Each node stores its
// external name, its degree and (if assigned) its group index.
//
// ****************************************************************************************************

#ifndef IGRAPH_HRG_GRAPH
#define IGRAPH_HRG_GRAPH

#include "hrg/rbtree.h"

#include 
#include 
#include 

namespace fitHRG {

// ******** Basic Structures *********************************************

#ifndef IGRAPH_HRG_EDGE
#define IGRAPH_HRG_EDGE
class edge {
public:
    int x;            // stored integer value  (edge terminator)
    double* h;            // (histogram) weights of edge existence
    double total_weight;      // (histogram) total weight observed
    int obs_count;        // number of observations in histogram
    edge* next;           // pointer to next elementd
    edge(): x(-1), h(0), total_weight(0.0), obs_count(0), next(0)  { }
    ~edge() {
        if (h != NULL) {
            delete [] h;
        }
        h = NULL;
    }
};
#endif

#ifndef IGRAPH_HRG_VERT
#define IGRAPH_HRG_VERT
class vert {
public:
    std::string name;           // (external) name of vertex
    int degree;            // degree of this vertex

    vert(): name(""), degree(0) { }
    ~vert() { }
};
#endif

// ******** Graph Class with Edge Statistics *****************************

class graph {
public:
    graph(const int, bool predict = false);
    ~graph();

    // add (i,j) to graph
    bool addLink(const int, const int);
    // add weight to (i,j)'s histogram
    bool addAdjacencyObs(const int, const int, const double, const double);
    // add to obs_count and total_weight
    void addAdjacencyEnd();
    // true if (i,j) is already in graph
    bool doesLinkExist(const int, const int);
    // returns degree of vertex i
    int getDegree(const int);
    // returns name of vertex i
    std::string getName(const int);
    // returns edge list of vertex i
    edge* getNeighborList(const int);
    // return ptr to histogram of edge (i,j)
    double* getAdjacencyHist(const int, const int);
    // return average value of adjacency A(i,j)
    double getAdjacencyAverage(const int, const int);
    // returns bin_resolution
    double getBinResolution();
    // returns num_bins
    int getNumBins();
    // returns m
    int numLinks();
    // returns n
    int numNodes();
    // returns total_weight
    double getTotalWeight();
    // reset edge (i,j)'s histogram
    void resetAdjacencyHistogram(const int, const int);
    // reset all edge histograms
    void resetAllAdjacencies();
    // clear all links from graph
    void resetLinks();
    // allocate edge histograms
    void setAdjacencyHistograms(const int);
    // set name of vertex i
    bool setName(const int, const std::string);

private:
    bool predict;      // do we need prediction?
    vert* nodes;       // list of nodes
    edge** nodeLink;   // linked list of neighbors to vertex
    edge** nodeLinkTail;   // pointers to tail of neighbor list
    double*** A;       // stochastic adjacency matrix for this graph
    int obs_count;     // number of observations in A
    double total_weight;   // total weight added to A
    int n;         // number of vertices
    int m;         // number of directed edges
    int num_bins;      // number of bins in edge histograms
    double bin_resolution; // width of histogram bin
};

} // namespace fitHRG

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/graph_simp.h0000644000175100001710000001252300000000000023526 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

// ****************************************************************************************************
// *** COPYRIGHT NOTICE *******************************************************************************
// graph_simp.h - graph data structure
// Copyright (C) 2006-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ****************************************************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu | http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science AND Santa Fe Institute
// Created      : 21 June 2006
// Modified     : 23 December 2007 (cleaned up for public consumption)
//
// ************************************************************************
//
// Simple graph data structure. The basic structure is an adjacency
// list of edges, along with degree information for the vertices.
//
// ************************************************************************

#ifndef IGRAPH_HRG_SIMPLEGRAPH
#define IGRAPH_HRG_SIMPLEGRAPH

#include "hrg/rbtree.h"
#include "hrg/dendro.h"

#include 
#include 

namespace fitHRG {

// ******** Basic Structures *********************************************

#ifndef IGRAPH_HRG_SIMPLEEDGE
#define IGRAPH_HRG_SIMPLEEDGE
class simpleEdge {
public:
    int x;            // index of edge terminator
    simpleEdge* next;     // pointer to next elementd

    simpleEdge(): x(-1), next(0) { }
    ~simpleEdge() { }
};
#endif

#ifndef IGRAPH_HRG_SIMPLEVERT
#define IGRAPH_HRG_SIMPLEVERT
class simpleVert {
public:
    std::string name;          // (external) name of vertex
    int degree;           // degree of this vertex
    int group_true;       // index of vertex's true group

    simpleVert(): name(""), degree(0), group_true(-1) { }
    ~simpleVert() { }
};
#endif

#ifndef IGRAPH_HRG_TWOEDGE
#define IGRAPH_HRG_TWOEDGE
class twoEdge {
public:
    int o;            // index of edge originator
    int x;            // index of edge terminator

    twoEdge(): o(-1), x(-1) { }
    ~twoEdge() { }
};
#endif

// ******** Graph Class with Edge Statistics *****************************

class simpleGraph {
public:
    simpleGraph(const int); ~simpleGraph();

    // add group label to vertex i
    bool addGroup(const int, const int);
    // add (i,j) to graph
    bool addLink(const int, const int);
    // true if (i,j) is already in graph
    bool doesLinkExist(const int, const int);
    // returns A(i,j)
    double getAdjacency(const int, const int);
    // returns degree of vertex i
    int getDegree(const int);
    // returns group label of vertex i
    int getGroupLabel(const int);
    // returns name of vertex i
    std::string getName(const int);
    // returns edge list of vertex i
    simpleEdge* getNeighborList(const int);
    // return pointer to a node
    simpleVert* getNode(const int);
    // returns num_groups
    int getNumGroups();
    // returns m
    int getNumLinks();
    // returns n
    int getNumNodes();
    // set name of vertex i
    bool setName(const int, const std::string);

private:
    simpleVert* nodes;        // list of nodes
    simpleEdge** nodeLink;    // linked list of neighbors to vertex
    simpleEdge** nodeLinkTail;    // pointers to tail of neighbor list
    double** A;           // adjacency matrix for this graph
    twoEdge* E;           // list of all edges (array)
    int n;            // number of vertices
    int m;            // number of directed edges
    int num_groups;       // number of bins in node histograms

    // quicksort functions
    void QsortMain(block*, int, int);
    int QsortPartition(block*, int, int, int);
};

} // namespace fitHRG

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/hrg.cc0000644000175100001710000010326300000000000022315 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_attributes.h"
#include "igraph_hrg.h"
#include "igraph_random.h"

#include "hrg/dendro.h"
#include "hrg/graph.h"
#include "hrg/graph_simp.h"

using namespace fitHRG;

/**
 * \section hrg_intro Introduction
 *
 * A hierarchical random graph is an ensemble of undirected
 * graphs with \c n vertices. It is defined via a binary tree with \c
 * n leaf and \c n-1 internal vertices, where the
 * internal vertices are labeled with probabilities.
 * The probability that two vertices are connected in the random graph
 * is given by the probability label at their closest common
 * ancestor.
 * 
 *
 * Please read the following two articles for more about
 * hierarchical random graphs: A. Clauset, C. Moore, and M.E.J. Newman.
 * Hierarchical structure and the prediction of missing links in networks.
 * Nature 453, 98 - 101 (2008); and A. Clauset, C. Moore, and M.E.J. Newman.
 * Structural Inference of Hierarchies in Networks. In E. M. Airoldi
 * et al. (Eds.): ICML 2006 Ws, Lecture Notes in Computer Science
 * 4503, 1-13. Springer-Verlag, Berlin Heidelberg (2007).
 * 
 *
 * 
 * igraph contains functions for fitting HRG models to a given network
 * (\ref igraph_hrg_fit), for generating networks from a given HRG
 * ensemble (\ref igraph_hrg_game, \ref igraph_hrg_sample), converting
 * an igraph graph to a HRG and back (\ref igraph_hrg_create, \ref
 * igraph_hrg_dendrogram), for calculating a consensus tree from a
 * set of sampled HRGs (\ref igraph_hrg_consensus) and for predicting
 * missing edges in a network based on its HRG models (\ref
 * igraph_hrg_predict).
 * 
 *
 * The igraph HRG implementation is heavily based on the code
 * published by Aaron Clauset, at his website,
 * http://tuvalu.santafe.edu/~aaronc/hierarchy/
 * 
 */

namespace fitHRG {
struct pblock {
    double L;
    int i;
    int j;
};
}

static int markovChainMonteCarlo(dendro *d, unsigned int period,
                          igraph_hrg_t *hrg) {

    igraph_real_t bestL = d->getLikelihood();
    double  dL;
    bool    flag_taken;

    // Because moves in the dendrogram space are chosen (Monte
    // Carlo) so that we sample dendrograms with probability
    // proportional to their likelihood, a likelihood-proportional
    // sampling of the dendrogram models would be equivalent to a
    // uniform sampling of the walk itself. We would still have to
    // decide how often to sample the walk (at most once every n
    // steps is recommended) but for simplicity, the code here
    // simply runs the MCMC itself. To actually compute something
    // over the set of sampled dendrogram models (in a Bayesian
    // model averaging sense), you'll need to code that yourself.

    // do 'period' MCMC moves before doing anything else
    for (unsigned int i = 0; i < period; i++) {

        // make a MCMC move
        IGRAPH_CHECK(! d->monteCarloMove(dL, flag_taken, 1.0));

        // get likelihood of this D given G
        igraph_real_t cl = d->getLikelihood();
        if (cl > bestL) {
            // store the current best likelihood
            bestL = cl;
            // record the HRG structure
            d->recordDendrogramStructure(hrg);
        }
    }
    // corrects floating-point errors O(n)
    d->refreshLikelihood();

    return 0;
}

static int markovChainMonteCarlo2(dendro *d, int num_samples) {
    bool flag_taken;
    double dL, ptest = 1.0 / (50.0 * (double)(d->g->numNodes()));
    int sample_num = 0, t = 1, thresh = 200 * d->g->numNodes();

    // Since we're sampling uniformly at random over the equilibrium
    // walk, we just need to do a bunch of MCMC moves and let the
    // sampling happen on its own.
    while (sample_num < num_samples) {
        // Make a single MCMC move
        d->monteCarloMove(dL, flag_taken, 1.0);

        // We sample the dendrogram space once every n MCMC moves (on
        // average). Depending on the flags on the command line, we sample
        // different aspects of the dendrograph structure.
        if (t > thresh && RNG_UNIF01() < ptest) {
            sample_num++;
            d->sampleSplitLikelihoods(sample_num);
        }

        t++;

        // correct floating-point errors O(n)
        d->refreshLikelihood(); // TODO: less frequently
    }

    return 0;
}

static int MCMCEquilibrium_Find(dendro *d, igraph_hrg_t *hrg) {

    // We want to run the MCMC until we've found equilibrium; we
    // use the heuristic of the average log-likelihood (which is
    // exactly the entropy) over X steps being very close to the
    // average log-likelihood (entropy) over the X steps that
    // preceded those. In other words, we look for an apparent
    // local convergence of the entropy measure of the MCMC.

    bool flag_taken;
    igraph_real_t dL, Likeli;
    igraph_real_t oldMeanL;
    igraph_real_t newMeanL = -1e-49;

    while (1) {
        oldMeanL = newMeanL;
        newMeanL = 0.0;
        for (int i = 0; i < 65536; i++) {
            IGRAPH_CHECK(! d->monteCarloMove(dL, flag_taken, 1.0));
            Likeli = d->getLikelihood();
            newMeanL += Likeli;
        }
        // corrects floating-point errors O(n)
        d->refreshLikelihood();
        if (fabs(newMeanL - oldMeanL) / 65536.0 < 1.0) {
            break;
        }
    }

    // Record the result
    if (hrg) {
        d->recordDendrogramStructure(hrg);
    }

    return 0;
}

static int igraph_i_hrg_getgraph(const igraph_t *igraph,
                                 dendro *d) {

    int no_of_nodes = igraph_vcount(igraph);
    int no_of_edges = igraph_ecount(igraph);
    int i;

    // Create graph
    d->g = new graph(no_of_nodes);

    // Add edges
    for (i = 0; i < no_of_edges; i++) {
        int from = IGRAPH_FROM(igraph, i);
        int to = IGRAPH_TO(igraph, i);
        if (from == to) {
            continue;
        }
        if (!d->g->doesLinkExist(from, to)) {
            d->g->addLink(from, to);
        }
        if (!d->g->doesLinkExist(to, from)) {
            d->g->addLink(to, from);
        }
    }

    d->buildDendrogram();

    return 0;
}

static int igraph_i_hrg_getsimplegraph(const igraph_t *igraph,
                                       dendro *d, simpleGraph **sg,
                                       int num_bins) {

    int no_of_nodes = igraph_vcount(igraph);
    int no_of_edges = igraph_ecount(igraph);
    int i;

    // Create graphs
    d->g = new graph(no_of_nodes, true);
    d->g->setAdjacencyHistograms(num_bins);
    (*sg) = new simpleGraph(no_of_nodes);

    for (i = 0; i < no_of_edges; i++) {
        int from = IGRAPH_FROM(igraph, i);
        int to = IGRAPH_TO(igraph, i);
        if (from == to) {
            continue;
        }
        if (!d->g->doesLinkExist(from, to)) {
            d->g->addLink(from, to);
        }
        if (!d->g->doesLinkExist(to, from)) {
            d->g->addLink(to, from);
        }
        if (!(*sg)->doesLinkExist(from, to)) {
            (*sg)->addLink(from, to);
        }
        if (!(*sg)->doesLinkExist(to, from)) {
            (*sg)->addLink(to, from);
        }
    }

    d->buildDendrogram();

    return 0;
}

/**
 * \function igraph_hrg_init
 * Allocate memory for a HRG.
 *
 * This function must be called before passing an \ref igraph_hrg_t to
 * an igraph function.
 * \param hrg Pointer to the HRG data structure to initialize.
 * \param n The number of vertices in the graph that is modeled by
 *    this HRG. It can be zero, if this is not yet known.
 * \return Error code.
 *
 * Time complexity: O(n), the number of vertices in the graph.
 */

int igraph_hrg_init(igraph_hrg_t *hrg, int n) {
    IGRAPH_VECTOR_INIT_FINALLY(&hrg->left,      n - 1);
    IGRAPH_VECTOR_INIT_FINALLY(&hrg->right,     n - 1);
    IGRAPH_VECTOR_INIT_FINALLY(&hrg->prob,      n - 1);
    IGRAPH_VECTOR_INIT_FINALLY(&hrg->edges,     n - 1);
    IGRAPH_VECTOR_INIT_FINALLY(&hrg->vertices,  n - 1);
    IGRAPH_FINALLY_CLEAN(5);
    return 0;
}

/**
 * \function igraph_hrg_destroy
 * Deallocate memory for an HRG.
 *
 * The HRG data structure can be reinitialized again with an \ref
 * igraph_hrg_destroy call.
 * \param hrg Pointer to the HRG data structure to deallocate.
 *
 * Time complexity: operating system dependent.
 */

void igraph_hrg_destroy(igraph_hrg_t *hrg) {
    igraph_vector_destroy(&hrg->left);
    igraph_vector_destroy(&hrg->right);
    igraph_vector_destroy(&hrg->prob);
    igraph_vector_destroy(&hrg->edges);
    igraph_vector_destroy(&hrg->vertices);
}

/**
 * \function igraph_hrg_size
 * Returns the size of the HRG, the number of leaf nodes.
 *
 * \param hrg Pointer to the HRG.
 * \return The number of leaf nodes in the HRG.
 *
 * Time complexity: O(1).
 */

int igraph_hrg_size(const igraph_hrg_t *hrg) {
    return igraph_vector_size(&hrg->left) + 1;
}

/**
 * \function igraph_hrg_resize
 * Resize a HRG.
 *
 * \param hrg Pointer to an initialized (see \ref igraph_hrg_init)
 *   HRG.
 * \param newsize The new size, i.e. the number of leaf nodes.
 * \return Error code.
 *
 * Time complexity: O(n), n is the new size.
 */

int igraph_hrg_resize(igraph_hrg_t *hrg, int newsize) {
    int origsize = igraph_hrg_size(hrg);
    int ret = 0;
    igraph_error_handler_t *oldhandler =
        igraph_set_error_handler(igraph_error_handler_ignore);

    ret  = igraph_vector_resize(&hrg->left, newsize - 1);
    ret |= igraph_vector_resize(&hrg->right, newsize - 1);
    ret |= igraph_vector_resize(&hrg->prob, newsize - 1);
    ret |= igraph_vector_resize(&hrg->edges, newsize - 1);
    ret |= igraph_vector_resize(&hrg->vertices, newsize - 1);

    igraph_set_error_handler(oldhandler);

    if (ret) {
        igraph_vector_resize(&hrg->left, origsize);
        igraph_vector_resize(&hrg->right, origsize);
        igraph_vector_resize(&hrg->prob, origsize);
        igraph_vector_resize(&hrg->edges, origsize);
        igraph_vector_resize(&hrg->vertices, origsize);
        IGRAPH_ERROR("Cannot resize HRG", ret);
    }

    return 0;
}

/**
 * \function igraph_hrg_fit
 * Fit a hierarchical random graph model to a network
 *
 * \param graph The igraph graph to fit the model to. Edge directions
 *   are ignored in directed graphs.
 * \param hrg Pointer to an initialized HRG, the result of the fitting
 *   is stored here. It can also be used to pass a HRG to the
 *   function, that can be used as the starting point of the Markov
 *   Chain Monte Carlo fitting, if the \c start argument is true.
 * \param start Logical, whether to start the fitting from the given
 *   HRG.
 * \param steps Integer, the number of MCMC steps to take in the
 *   fitting procedure. If this is zero, then the fitting stop is a
 *   convergence criteria is fulfilled.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_hrg_fit(const igraph_t *graph,
                   igraph_hrg_t *hrg,
                   igraph_bool_t start,
                   int steps) {

    int no_of_nodes = igraph_vcount(graph);
    dendro *d;

    RNG_BEGIN();

    d = new dendro;

    // If we want to start from HRG
    if (start) {
        d->clearDendrograph();
        if (igraph_hrg_size(hrg) != no_of_nodes) {
            delete d;
            IGRAPH_ERROR("Invalid HRG to start from", IGRAPH_EINVAL);
        }
        // Convert the igraph graph
        IGRAPH_CHECK(igraph_i_hrg_getgraph(graph, d));
        d->importDendrogramStructure(hrg);
    } else {
        // Convert the igraph graph
        IGRAPH_CHECK(igraph_i_hrg_getgraph(graph, d));
        IGRAPH_CHECK(igraph_hrg_resize(hrg, no_of_nodes));
    }

    // Run fixed number of steps, or until convergence
    if (steps > 0) {
        IGRAPH_CHECK(markovChainMonteCarlo(d, steps, hrg));
    } else {
        IGRAPH_CHECK(MCMCEquilibrium_Find(d, hrg));
    }

    delete d;

    RNG_END();

    return 0;

}

/**
 * \function igraph_hrg_sample
 * Sample from a hierarchical random graph model
 *
 * Sample from a hierarchical random graph ensemble. The ensemble can
 * be given as a graph (\c input_graph), or as a HRG object (\c hrg).
 * If a graph is given, then first an MCMC optimization is performed
 * to find the optimal fitting model; then the MCMC is used to sample
 * the graph(s).
 * \param input_graph An igraph graph, or a null pointer. If not a
 *   null pointer, then a HRG is first fitted to the graph, possibly
 *   starting from the given HRG, if the \c start argument is true. If
 *   is is a null pointer, then the given HRG is used as a starting
 *   point, to  find the optimum of the Markov chain, before the
 *   sampling.
 * \param sample Pointer to an uninitialized graph, or a null
 *   pointer. If only one sample is requested, and it is not a null
 *   pointer, then the sample is stored here.
 * \param samples An initialized vector of pointers. If more than one
 *   samples are requested, then they are stored here. Note that to
 *   free this data structure, you need to call \ref igraph_destroy() on
 *   each graph first, then \ref igraph_free() on all pointers, and finally
 *   \ref igraph_vector_ptr_destroy.
 * \param no_samples The number of samples to generate.
 * \param hrg A HRG. It is modified during the sampling.
 * \param start Logical, whether to start the MCMC from the given
 *   HRG.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_hrg_sample(const igraph_t *input_graph,
                      igraph_t *sample,
                      igraph_vector_ptr_t *samples,
                      igraph_integer_t no_samples,
                      igraph_hrg_t *hrg,
                      igraph_bool_t start) {

    int i;
    dendro *d;

    if (no_samples < 0) {
        IGRAPH_ERROR("Number of samples must be non-negative", IGRAPH_EINVAL);
    }

    if (!sample && !samples) {
        IGRAPH_ERROR("Give at least one of `sample' and `samples'",
                     IGRAPH_EINVAL);
    }

    if (no_samples != 1 && sample) {
        IGRAPH_ERROR("Number of samples should be one if `sample' is given",
                     IGRAPH_EINVAL);
    }

    if (no_samples > 1 && !samples) {
        IGRAPH_ERROR("`samples' must be non-null if number of samples "
                     "is larger than 1", IGRAPH_EINVAL);
    }

    if (!start && !input_graph) {
        IGRAPH_ERROR("Input graph must be given if initial HRG is not used",
                     IGRAPH_EINVAL);
    }

    if (!start) {
        IGRAPH_CHECK(igraph_hrg_resize(hrg, igraph_vcount(input_graph)));
    }

    if (input_graph && igraph_hrg_size(hrg) != igraph_vcount(input_graph)) {
        IGRAPH_ERROR("Invalid HRG size, should match number of nodes",
                     IGRAPH_EINVAL);
    }

    RNG_BEGIN();

    d = new dendro;

    // Need to find equilibrium first?
    if (start) {
        d->clearDendrograph();
        d->importDendrogramStructure(hrg);
    } else {
        IGRAPH_CHECK(MCMCEquilibrium_Find(d, hrg));
    }

    // TODO: free on error

    if (sample) {
        // A single graph
        d->makeRandomGraph();
        d->recordGraphStructure(sample);
        if (samples) {
            igraph_t *G = IGRAPH_CALLOC(1, igraph_t);
            if (!G) {
                IGRAPH_ERROR("Cannot sample HRG graphs", IGRAPH_ENOMEM);
            }
            d->recordGraphStructure(G);
            IGRAPH_CHECK(igraph_vector_ptr_resize(samples, 1));
            VECTOR(*samples)[0] = G;
        }
    } else {
        // Sample many
        IGRAPH_CHECK(igraph_vector_ptr_resize(samples, no_samples));
        for (i = 0; i < no_samples; i++) {
            igraph_t *G = IGRAPH_CALLOC(1, igraph_t);
            if (!G) {
                IGRAPH_ERROR("Cannot sample HRG graphs", IGRAPH_ENOMEM);
            }
            d->makeRandomGraph();
            d->recordGraphStructure(G);
            VECTOR(*samples)[i] = G;
        }
    }

    delete d;

    RNG_END();

    return 0;
}

/**
 * \function igraph_hrg_game
 * Generate a hierarchical random graph
 *
 * This function is a simple shortcut to \ref igraph_hrg_sample.
 * It creates a single graph, from the given HRG.
 * \param graph Pointer to an uninitialized graph, the new graph is
 *   created here.
 * \param hrg The hierarchical random graph model to sample from. It
 *   is modified during the MCMC process.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_hrg_game(igraph_t *graph,
                    const igraph_hrg_t *hrg) {
    return igraph_hrg_sample(/* input_graph= */ 0, /* sample= */ graph,
            /* samples= */ 0, /* no_samples=*/ 1,
            /* hrg= */ (igraph_hrg_t*) hrg,
            /* start= */ 1);
}

/**
 * \function igraph_hrg_dendrogram
 * Create a dendrogram from a hierarchical random graph.
 *
 * Creates the igraph graph equivalent of an \ref igraph_hrg_t data
 * structure.
 * \param graph Pointer to an uninitialized graph, the result is
 *   stored here.
 * \param hrg The hierarchical random graph to convert.
 * \return Error code.
 *
 * Time complexity: O(n), the number of vertices in the graph.
 */

int igraph_hrg_dendrogram(igraph_t *graph,
                          const igraph_hrg_t *hrg) {

    int orig_nodes = igraph_hrg_size(hrg);
    int no_of_nodes = orig_nodes * 2 - 1;
    int no_of_edges = no_of_nodes - 1;
    igraph_vector_t edges;
    int i, idx = 0;
    igraph_vector_ptr_t vattrs;
    igraph_vector_t prob;
    igraph_attribute_record_t rec = { "probability",
                                      IGRAPH_ATTRIBUTE_NUMERIC,
                                      &prob
                                    };

    // Probability labels, for leaf nodes they are IGRAPH_NAN
    IGRAPH_VECTOR_INIT_FINALLY(&prob, no_of_nodes);
    for (i = 0; i < orig_nodes; i++) {
        VECTOR(prob)[i] = IGRAPH_NAN;
    }
    for (i = 0; i < orig_nodes - 1; i++) {
        VECTOR(prob)[orig_nodes + i] = VECTOR(hrg->prob)[i];
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
    IGRAPH_CHECK(igraph_vector_ptr_init(&vattrs, 1));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vattrs);
    VECTOR(vattrs)[0] = &rec;

    for (i = 0; i < orig_nodes - 1; i++) {
        int left = VECTOR(hrg->left)[i];
        int right = VECTOR(hrg->right)[i];

        VECTOR(edges)[idx++] = orig_nodes + i;
        VECTOR(edges)[idx++] = left < 0 ? orig_nodes - left - 1 : left;
        VECTOR(edges)[idx++] = orig_nodes + i;
        VECTOR(edges)[idx++] = right < 0 ? orig_nodes - right - 1 : right;
    }

    IGRAPH_CHECK(igraph_empty(graph, 0, IGRAPH_DIRECTED));
    IGRAPH_FINALLY(igraph_destroy, graph);
    IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, &vattrs));
    IGRAPH_CHECK(igraph_add_edges(graph, &edges, 0));

    igraph_vector_ptr_destroy(&vattrs);
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&prob);
    IGRAPH_FINALLY_CLEAN(4);  // + 1 for graph

    return 0;
}

/**
 * \function igraph_hrg_consensus
 * Calculate a consensus tree for a HRG.
 *
 * The calculation can be started from the given HRG (\c hrg), or (if
 * \c start is false), a HRG is first fitted to the given graph.
 *
 * \param graph The input graph.
 * \param parents An initialized vector, the results are stored
 *   here. For each vertex, the id of its parent vertex is stored, or
 *   -1, if the vertex is the root vertex in the tree. The first n
 *   vertex ids (from 0) refer to the original vertices of the graph,
 *   the other ids refer to vertex groups.
 * \param weights Numeric vector, counts the number of times a given
 *   tree split occured in the generated network samples, for each
 *   internal vertices. The order is the same as in \c parents.
 * \param hrg A hierarchical random graph. It is used as a starting
 *   point for the sampling, if the \c start argument is true. It is
 *   modified along the MCMC.
 * \param start Logical, whether to use the supplied HRG (in \c hrg)
 *   as a starting point for the MCMC.
 * \param num_samples The number of samples to generate for creating
 *   the consensus tree.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_hrg_consensus(const igraph_t *graph,
                         igraph_vector_t *parents,
                         igraph_vector_t *weights,
                         igraph_hrg_t *hrg,
                         igraph_bool_t start,
                         int num_samples) {

    dendro *d;

    if (start && !hrg) {
        IGRAPH_ERROR("`hrg' must be given is `start' is true", IGRAPH_EINVAL);
    }

    RNG_BEGIN();

    d = new dendro;

    if (start) {
        d->clearDendrograph();
        IGRAPH_CHECK(igraph_i_hrg_getgraph(graph, d));
        d->importDendrogramStructure(hrg);
    } else {
        IGRAPH_CHECK(igraph_i_hrg_getgraph(graph, d));
        if (hrg) {
            igraph_hrg_resize(hrg, igraph_vcount(graph));
        }
        IGRAPH_CHECK(MCMCEquilibrium_Find(d, hrg));
    }

    IGRAPH_CHECK(markovChainMonteCarlo2(d, num_samples));

    d->recordConsensusTree(parents, weights);

    delete d;

    RNG_END();

    return 0;
}

static int MCMCEquilibrium_Sample(dendro *d, int num_samples) {

    // Because moves in the dendrogram space are chosen (Monte
    // Carlo) so that we sample dendrograms with probability
    // proportional to their likelihood, a likelihood-proportional
    // sampling of the dendrogram models would be equivalent to a
    // uniform sampling of the walk itself. We would still have to
    // decide how often to sample the walk (at most once every n steps
    // is recommended) but for simplicity, the code here simply runs the
    // MCMC itself. To actually compute something over the set of
    // sampled dendrogram models (in a Bayesian model averaging sense),
    // you'll need to code that yourself.

    double dL;
    bool flag_taken;
    int sample_num = 0;
    int t = 1, thresh = 100 * d->g->numNodes();
    double ptest = 1.0 / 10.0 / d->g->numNodes();

    while (sample_num < num_samples) {
        d->monteCarloMove(dL, flag_taken, 1.0);
        if (t > thresh && RNG_UNIF01() < ptest) {
            sample_num++;
            d->sampleAdjacencyLikelihoods();
        }
        d->refreshLikelihood(); // TODO: less frequently
        t++;
    }

    return 0;
}

static int QsortPartition (pblock* array, int left, int right, int index) {
    pblock p_value, temp;
    p_value.L = array[index].L;
    p_value.i = array[index].i;
    p_value.j = array[index].j;

    // swap(array[p_value], array[right])
    temp.L = array[right].L;
    temp.i = array[right].i;
    temp.j = array[right].j;
    array[right].L = array[index].L;
    array[right].i = array[index].i;
    array[right].j = array[index].j;
    array[index].L = temp.L;
    array[index].i = temp.i;
    array[index].j = temp.j;

    int stored = left;
    for (int i = left; i < right; i++) {
        if (array[i].L <= p_value.L) {
            // swap(array[stored], array[i])
            temp.L = array[i].L;
            temp.i = array[i].i;
            temp.j = array[i].j;
            array[i].L = array[stored].L;
            array[i].i = array[stored].i;
            array[i].j = array[stored].j;
            array[stored].L = temp.L;
            array[stored].i = temp.i;
            array[stored].j = temp.j;
            stored++;
        }
    }
    // swap(array[right], array[stored])
    temp.L = array[stored].L;
    temp.i = array[stored].i;
    temp.j = array[stored].j;
    array[stored].L = array[right].L;
    array[stored].i = array[right].i;
    array[stored].j = array[right].j;
    array[right].L  = temp.L;
    array[right].i  = temp.i;
    array[right].j  = temp.j;

    return stored;
}

static void QsortMain (pblock* array, int left, int right) {
    if (right > left) {
        int pivot = left;
        int part  = QsortPartition(array, left, right, pivot);
        QsortMain(array, left,   part - 1);
        QsortMain(array, part + 1, right  );
    }
    return;
}

static int rankCandidatesByProbability(simpleGraph *sg, dendro *d,
                                pblock *br_list, int mk) {
    int mkk = 0;
    int n = sg->getNumNodes();
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (sg->getAdjacency(i, j) < 0.5) {
                double temp = d->g->getAdjacencyAverage(i, j);
                br_list[mkk].L = temp * (1.0 + RNG_UNIF01() / 1000.0);
                br_list[mkk].i = i;
                br_list[mkk].j = j;
                mkk++;
            }
        }
    }

    // Sort the candidates by their average probability
    QsortMain(br_list, 0, mk - 1);

    return 0;
}

static int recordPredictions(pblock *br_list, igraph_vector_t *edges,
                      igraph_vector_t *prob, int mk) {

    IGRAPH_CHECK(igraph_vector_resize(edges, mk * 2));
    IGRAPH_CHECK(igraph_vector_resize(prob, mk));

    for (int i = mk - 1, idx = 0, idx2 = 0; i >= 0; i--) {
        VECTOR(*edges)[idx++] = br_list[i].i;
        VECTOR(*edges)[idx++] = br_list[i].j;
        VECTOR(*prob)[idx2++] = br_list[i].L;
    }

    return 0;
}

/**
 * \function igraph_hrg_predict
 * Predict missing edges in a graph, based on HRG models
 *
 * Samples HRG models for a network, and estimated the probability
 * that an edge was falsely observed as non-existent in the network.
 * \param graph The input graph.
 * \param edges The list of missing edges is stored here, the first
 *   two elements are the first edge, the next two the second edge,
 *   etc.
 * \param prob Vector of probabilies for the existence of missing
 *   edges, in the order corresponding to \c edges.
 * \param hrg A HRG, it is used as a starting point if \c start is
 *   true. It is also modified during the MCMC sampling.
 * \param start Logical, whether to start the MCMC from the given HRG.
 * \param num_samples The number of samples to generate.
 * \param num_bins Controls the resolution of the edge
 *   probabilities. Higher numbers result higher resolution.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_hrg_predict(const igraph_t *graph,
                       igraph_vector_t *edges,
                       igraph_vector_t *prob,
                       igraph_hrg_t *hrg,
                       igraph_bool_t start,
                       int num_samples,
                       int num_bins) {

    dendro *d;
    pblock *br_list;
    int mk;
    simpleGraph *sg;

    if (start && !hrg) {
        IGRAPH_ERROR("`hrg' must be given is `start' is true", IGRAPH_EINVAL);
    }

    RNG_BEGIN();

    d = new dendro;

    IGRAPH_CHECK(igraph_i_hrg_getsimplegraph(graph, d, &sg, num_bins));

    mk = sg->getNumNodes() * (sg->getNumNodes() - 1) / 2 - sg->getNumLinks() / 2;
    br_list = new pblock[mk];
    for (int i = 0; i < mk; i++) {
        br_list[i].L = 0.0;
        br_list[i].i = -1;
        br_list[i].j = -1;
    }

    if (start) {
        d->clearDendrograph();
        // this has cleared the graph as well.... bug?
        IGRAPH_CHECK(igraph_i_hrg_getsimplegraph(graph, d, &sg, num_bins));
        d->importDendrogramStructure(hrg);
    } else {
        if (hrg) {
            igraph_hrg_resize(hrg, igraph_vcount(graph));
        }
        IGRAPH_CHECK(MCMCEquilibrium_Find(d, hrg));
    }

    IGRAPH_CHECK(MCMCEquilibrium_Sample(d, num_samples));
    IGRAPH_CHECK(rankCandidatesByProbability(sg, d, br_list, mk));
    IGRAPH_CHECK(recordPredictions(br_list, edges, prob, mk));

    delete d;
    delete sg;
    delete [] br_list;

    RNG_END();

    return 0;
}

/**
 * \function igraph_hrg_create
 * Create a HRG from an igraph graph.
 *
 * \param hrg Pointer to an initialized \ref igraph_hrg_t. The result
 *    is stored here.
 * \param graph The igraph graph to convert. It must be a directed
 *    binary tree, with n-1 internal and n leaf vertices. The root
 *    vertex must have in-degree zero.
 * \param prob The vector of probabilities, this is used to label the
 *    internal nodes of the hierarchical random graph. The values
 *    corresponding to the leaves are ignored.
 * \return Error code.
 *
 * Time complexity: O(n), the number of vertices in the tree.
 */

int igraph_hrg_create(igraph_hrg_t *hrg,
                      const igraph_t *graph,
                      const igraph_vector_t *prob) {

    int no_of_nodes = igraph_vcount(graph);
    int no_of_internal = (no_of_nodes - 1) / 2;
    igraph_vector_t deg, idx;
    int root = 0;
    int d0 = 0, d1 = 0, d2 = 0;
    int ii = 0, il = 0;
    igraph_vector_t neis;
    igraph_vector_t path;

    // --------------------------------------------------------
    // CHECKS
    // --------------------------------------------------------

    // At least three vertices are required
    if (no_of_nodes < 3) {
        IGRAPH_ERROR("HRG tree must have at least three vertices",
                     IGRAPH_EINVAL);
    }

    // Prob vector was given
    if (!prob) {
        IGRAPH_ERROR("Probability vector must be given for HRG",
                     IGRAPH_EINVAL);
    }

    // Length of prob vector
    if (igraph_vector_size(prob) != no_of_nodes) {
        IGRAPH_ERROR("HRG probability vector of wrong size", IGRAPH_EINVAL);
    }

    // Must be a directed graph
    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("HRG graph must be directed", IGRAPH_EINVAL);
    }

    // Number of nodes must be odd
    if (no_of_nodes % 2 == 0) {
        IGRAPH_ERROR("Complete HRG graph must have odd number of vertices",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(°, 0);

    // Every vertex, except for the root must have in-degree one.
    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(), IGRAPH_IN,
                               IGRAPH_LOOPS));
    for (int i = 0; i < no_of_nodes; i++) {
        int d = VECTOR(deg)[i];
        switch (d) {
        case 0: d0++; root = i; break;
        case 1: d1++; break;
        default:
            IGRAPH_ERROR("HRG nodes must have in-degree one, except for the "
                         "root vertex", IGRAPH_EINVAL);
        }
    }
    if (d1 != no_of_nodes - 1 || d0 != 1) {
        IGRAPH_ERROR("HRG nodes must have in-degree one, except for the "
                     "root vertex", IGRAPH_EINVAL);
    }

    // Every internal vertex must have out-degree two,
    // leaves out-degree zero
    d0 = d1 = d2 = 0;
    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(), IGRAPH_OUT,
                               IGRAPH_LOOPS));
    for (int i = 0; i < no_of_nodes; i++) {
        int d = VECTOR(deg)[i];
        switch (d) {
        case 0: d0++; break;
        case 2: d2++; break;
        default:
            IGRAPH_ERROR("HRG nodes must have out-degree 2 (internal nodes) or "
                         "degree 0 (leaves)", IGRAPH_EINVAL);
        }
    }

    // Number of internal and external nodes is correct
    // This basically checks that the graph has one component
    if (d0 != d2 + 1) {
        IGRAPH_ERROR("HRG degrees are incorrect, maybe multiple components?",
                     IGRAPH_EINVAL);
    }

    // --------------------------------------------------------
    // Graph is good, do the conversion
    // --------------------------------------------------------

    // Create an index, that maps the root node as first, then
    // the internal nodes, then the leaf nodes
    IGRAPH_VECTOR_INIT_FINALLY(&idx, no_of_nodes);
    VECTOR(idx)[root] = - (ii++) - 1;
    for (int i = 0; i < no_of_nodes; i++) {
        int d = VECTOR(deg)[i];
        if (i == root) {
            continue;
        }
        if (d == 2) {
            VECTOR(idx)[i] = - (ii++) - 1;
        }
        if (d == 0) {
            VECTOR(idx)[i] = (il++);
        }
    }

    igraph_hrg_resize(hrg, no_of_internal + 1);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    for (int i = 0; i < no_of_nodes; i++) {
        int ri = VECTOR(idx)[i];
        if (ri >= 0) {
            continue;
        }
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, i, IGRAPH_OUT));
        VECTOR(hrg->left )[-ri - 1] = VECTOR(idx)[ (int) VECTOR(neis)[0] ];
        VECTOR(hrg->right)[-ri - 1] = VECTOR(idx)[ (int) VECTOR(neis)[1] ];
        VECTOR(hrg->prob )[-ri - 1] = VECTOR(*prob)[i];
    }

    // Calculate the number of vertices and edges in each subtree
    igraph_vector_null(&hrg->edges);
    igraph_vector_null(&hrg->vertices);
    IGRAPH_VECTOR_INIT_FINALLY(&path, 0);
    IGRAPH_CHECK(igraph_vector_push_back(&path, VECTOR(idx)[root]));
    while (!igraph_vector_empty(&path)) {
        int ri = igraph_vector_tail(&path);
        int lc = VECTOR(hrg->left)[-ri - 1];
        int rc = VECTOR(hrg->right)[-ri - 1];
        if (lc < 0 && VECTOR(hrg->vertices)[-lc - 1] == 0) {
            // Go left
            IGRAPH_CHECK(igraph_vector_push_back(&path, lc));
        } else if (rc < 0 && VECTOR(hrg->vertices)[-rc - 1] == 0) {
            // Go right
            IGRAPH_CHECK(igraph_vector_push_back(&path, rc));
        } else {
            // Subtrees are done, update node and go up
            VECTOR(hrg->vertices)[-ri - 1] +=
                lc < 0 ? VECTOR(hrg->vertices)[-lc - 1] : 1;
            VECTOR(hrg->vertices)[-ri - 1] +=
                rc < 0 ? VECTOR(hrg->vertices)[-rc - 1] : 1;
            VECTOR(hrg->edges)[-ri - 1] += lc < 0 ? VECTOR(hrg->edges)[-lc - 1] + 1 : 1;
            VECTOR(hrg->edges)[-ri - 1] += rc < 0 ? VECTOR(hrg->edges)[-rc - 1] + 1 : 1;
            igraph_vector_pop_back(&path);
        }
    }

    igraph_vector_destroy(&path);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&idx);
    igraph_vector_destroy(°);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/hrg_types.cc0000644000175100001710000036402400000000000023545 0ustar00runnerdocker00000000000000// ***********************************************************************
// *** COPYRIGHT NOTICE **************************************************
// rbtree - red-black tree (self-balancing binary tree data structure)
// Copyright (C) 2004 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ***********************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu |
//                                 http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science
//                AND Santa Fe Institute
// Created      : Spring 2004
// Modified     : many, many times
//
// ***********************************************************************

#include "hrg/rbtree.h"
#include "hrg/dendro.h"
#include "hrg/graph.h"
#include "hrg/splittree_eq.h"
#include "hrg/graph_simp.h"

#include "igraph_hrg.h"
#include "igraph_constructors.h"
#include "igraph_random.h"

using namespace std;
using namespace fitHRG;

// ******** Red-Black Tree Methods ***************************************

rbtree::rbtree() {
    root = new elementrb;
    leaf = new elementrb;

    leaf->parent = root;

    root->left = leaf;
    root->right = leaf;
    support = 0;
}

rbtree::~rbtree() {
    if (root != NULL &&
        (root->left != leaf || root->right != leaf)) {
        deleteSubTree(root);
    }
    if (root) {
        delete root;
    }
    delete leaf;
    support = 0;
    root = 0;
    leaf = 0;
}

void rbtree::deleteTree() {
    if (root != NULL) {
        deleteSubTree(root);
    }
} // does not leak memory

void rbtree::deleteSubTree(elementrb *z) {
    if (z->left  != leaf) {
        deleteSubTree(z->left);
    }
    if (z->right != leaf) {
        deleteSubTree(z->right);
    }
    delete z;
}

// ******** Search Functions *********************************************
// public search function - if there exists a elementrb in the tree
// with key=searchKey, it returns TRUE and foundNode is set to point
// to the found node; otherwise, it sets foundNode=NULL and returns
// FALSE
elementrb* rbtree::findItem(const int searchKey) {
    elementrb *current = root;

    // empty tree; bail out
    if (current->key == -1) {
        return NULL;
    }

    while (current != leaf) {
        // left-or-right?
        if (searchKey < current->key) {
            // try moving down-left
            if (current->left  != leaf) {
                current = current->left;
            } else {
                //   failure; bail out
                return NULL;
            }
        } else {
            // left-or-right?
            if (searchKey > current->key) {
                // try moving down-left
                if (current->right  != leaf) {
                    current = current->right;
                } else {
                    // failure; bail out
                    return NULL;
                }
            } else {
                // found (searchKey==current->key)
                return current;
            }
        }
    }
    return NULL;
}

int rbtree::returnValue(const int searchKey) {
    elementrb* test = findItem(searchKey);
    if (!test) {
        return 0;
    } else {
        return test->value;
    }
}


// ******** Return Item Functions ****************************************

int* rbtree::returnArrayOfKeys() {
    int* array;
    array = new int [support];
    bool flag_go = true;
    int index = 0;
    elementrb *curr;

    if (support == 1) {
        array[0] = root->key;
    } else if (support == 2) {
        array[0] = root->key;
        if (root->left == leaf) {
            array[1] = root->right->key;
        } else {
            array[1] = root->left->key;
        }
    } else {
        for (int i = 0; i < support; i++) {
            array[i] = -1;
        }
        // non-recursive traversal of tree structure
        curr = root;
        curr->mark = 1;
        while (flag_go) {
            // - is it time, and is left child the leaf node?
            if (curr->mark == 1 && curr->left == leaf) {
                curr->mark = 2;
            }
            // - is it time, and is right child the leaf node?
            if (curr->mark == 2 && curr->right == leaf) {
                curr->mark = 3;
            }
            if (curr->mark == 1) {
                // - go left
                curr->mark = 2;
                curr = curr->left;
                curr->mark = 1;
            } else if (curr->mark == 2) {
                // - else go right
                curr->mark = 3;
                curr = curr->right;
                curr->mark = 1;
            } else {
                // - else go up a level
                curr->mark = 0;
                array[index++] = curr->key;
                curr = curr->parent;
                if (curr == NULL) {
                    flag_go = false;
                }
            }
        }
    }

    return array;
}

list* rbtree::returnListOfKeys() {
    keyValuePair *curr, *prev;
    list *head = 0, *tail = 0, *newlist;

    curr = returnTreeAsList();
    while (curr != NULL) {
        newlist = new list;
        newlist->x = curr->x;
        if (head == NULL) {
            head       = newlist; tail = head;
        } else {
            tail->next = newlist; tail = newlist;
        }
        prev = curr;
        curr = curr->next;
        delete prev;
        prev = NULL;
    }
    return head;
}

keyValuePair* rbtree::returnTreeAsList() {
    // pre-order traversal
    keyValuePair  *head, *tail;

    head = new keyValuePair;
    head->x = root->key;
    head->y = root->value;
    tail = head;

    if (root->left  != leaf) {
        tail = returnSubtreeAsList(root->left,  tail);
    }
    if (root->right != leaf) {
        tail = returnSubtreeAsList(root->right, tail);
    }

    if (head->x == -1) {
        return NULL; /* empty tree */
    } else {
        return head;
    }
}

keyValuePair* rbtree::returnSubtreeAsList(elementrb *z, keyValuePair *head) {
    keyValuePair *newnode, *tail;

    newnode = new keyValuePair;
    newnode->x = z->key;
    newnode->y = z->value;
    head->next = newnode;
    tail = newnode;

    if (z->left  != leaf) {
        tail = returnSubtreeAsList(z->left,  tail);
    }
    if (z->right != leaf) {
        tail = returnSubtreeAsList(z->right, tail);
    }

    return tail;
}

keyValuePair rbtree::returnMaxKey() {
    keyValuePair themax;
    elementrb *current;
    current  = root;

    // search to bottom-right corner of tree
    while (current->right != leaf) {
        current  = current->right;
    }
    themax.x = current->key;
    themax.y = current->value;

    return themax;
}

keyValuePair rbtree::returnMinKey() {
    keyValuePair themin;
    elementrb *current;
    current = root;
    // search to bottom-left corner of tree
    while (current->left != leaf) {
        current = current->left;
    }
    themin.x = current->key;
    themin.y = current->value;

    return themin;
}

// private functions for deleteItem() (although these could easily be
// made public, I suppose)
elementrb* rbtree::returnMinKey(elementrb *z) {
    elementrb *current;

    current = z;
    // search to bottom-right corner of tree
    while (current->left != leaf) {
        current = current->left;
    }
    return current;
}

elementrb* rbtree::returnSuccessor(elementrb *z) {
    elementrb *current, *w;

    w = z;
    // if right-subtree exists, return min of it
    if (w->right != leaf) {
        return returnMinKey(w->right);
    }
    // else search up in tree
    current = w->parent;
    while ((current != NULL) && (w == current->right)) {
        w = current;
        // move up in tree until find a non-right-child
        current = current->parent;
    }
    return current;
}

int rbtree::returnNodecount() {
    return support;
}

// ******** Insert Functions *********************************************
// public insert function
void rbtree::insertItem(int newKey, int newValue) {

    // first we check to see if newKey is already present in the tree;
    // if so, we do nothing; if not, we must find where to insert the
    // key
    elementrb *newNode, *current;

    // find newKey in tree; return pointer to it O(log k)
    current = findItem(newKey);
    if (current == NULL) {
        newNode = new elementrb;    // elementrb for the rbtree
        newNode->key = newKey;
        newNode->value = newValue;
        newNode->color = true;  // new nodes are always RED
        newNode->parent = NULL; // new node initially has no parent
        newNode->left = leaf;   // left leaf
        newNode->right = leaf;  // right leaf
        support++;          // increment node count in rbtree

        // must now search for where to insert newNode, i.e., find the
        // correct parent and set the parent and child to point to each
        // other properly
        current = root;
        if (current->key == -1) {    // insert as root
            delete root;           // delete old root
            root = newNode;            // set root to newNode
            leaf->parent = newNode;        // set leaf's parent
            current = leaf;            // skip next loop
        }

        // search for insertion point
        while (current != leaf) {
            // left-or-right?
            if (newKey < current->key) {
                // try moving down-left
                if (current->left  != leaf) {
                    current = current->left;
                } else {
                    // else found new parent
                    newNode->parent = current; // set parent
                    current->left = newNode;   // set child
                    current = leaf;        // exit search
                }
            } else {
                // try moving down-right
                if (current->right != leaf) {
                    current = current->right;
                } else {
                    // else found new parent
                    newNode->parent = current; // set parent
                    current->right = newNode;  // set child
                    current = leaf;        // exit search
                }
            }
        }

        // now do the house-keeping necessary to preserve the red-black
        // properties
        insertCleanup(newNode);
    }
    return;
}

// private house-keeping function for insertion
void rbtree::insertCleanup(elementrb *z) {

    // fix now if z is root
    if (z->parent == NULL) {
        z->color = false;
        return;
    }

    elementrb *temp;

    // while z is not root and z's parent is RED
    while (z->parent != NULL && z->parent->color) {
        if (z->parent == z->parent->parent->left) {

            // z's parent is LEFT-CHILD

            temp = z->parent->parent->right;   // grab z's uncle
            if (temp->color) {
                z->parent->color = false;        // color z's parent BLACK  (Case 1)
                temp->color = false;             // color z's uncle BLACK   (Case 1)
                z->parent->parent->color = true; // color z's grandpar. RED (Case 1)
                z = z->parent->parent;           // set z = z's grandparent (Case 1)
            } else {
                if (z == z->parent->right) {
                    // z is RIGHT-CHILD
                    z = z->parent;             // set z = z's parent      (Case 2)
                    rotateLeft(z);             // perform left-rotation   (Case 2)
                }
                z->parent->color = false;        // color z's parent BLACK  (Case 3)
                z->parent->parent->color = true; // color z's grandpar. RED (Case 3)
                rotateRight(z->parent->parent);  // perform right-rotation  (Case 3)
            }
        } else {

            // z's parent is RIGHT-CHILD

            temp = z->parent->parent->left;    // grab z's uncle
            if (temp->color) {
                z->parent->color = false;        // color z's parent BLACK  (Case 1)
                temp->color = false;             // color z's uncle BLACK   (Case 1)
                z->parent->parent->color = true; // color z's grandpar. RED (Case 1)
                z = z->parent->parent;           // set z = z's grandparent (Case 1)
            } else {
                if (z == z->parent->left) {
                    // z is LEFT-CHILD
                    z = z->parent;                 // set z = z's parent      (Case 2)
                    rotateRight(z);                // perform right-rotation  (Case 2)
                }
                z->parent->color = false;        // color z's parent BLACK  (Case 3)
                z->parent->parent->color = true; // color z's grandpar. RED (Case 3)
                rotateLeft(z->parent->parent);   // perform left-rotation   (Case 3)
            }
        }
    }

    root->color = false;               // color the root BLACK
    return;
}

// ******** Delete
// ******** Functions *********************************************

void rbtree::replaceItem(int key, int newValue) {
    elementrb* ptr;
    ptr = findItem(key);
    ptr->value = newValue;
    return;
}

void rbtree::incrementValue(int key) {
    elementrb* ptr;
    ptr = findItem(key);
    ptr->value = 1 + ptr->value;
    return;
}

// public delete function
void rbtree::deleteItem(int killKey) {
    elementrb *x, *y, *z;

    z = findItem(killKey);
    if (z == NULL) {
        return;    // item not present; bail out
    }

    if (support == 1) {     // attempt to delete the root
        root->key = -1;       // restore root node to default state
        root->value = -1;
        root->color = false;
        root->parent = NULL;
        root->left = leaf;
        root->right = leaf;
        support--;            // set support to zero
        return;           // exit - no more work to do
    }

    if (z != NULL) {
        support--;            // decrement node count
        if ((z->left == leaf) || (z->right == leaf)) {
            y = z;                      // case of less than two children,
            // set y to be z
        } else {
            y = returnSuccessor(z);     // set y to be z's key-successor
        }

        if (y->left != leaf) {
            x = y->left;        // pick y's one child (left-child)
        } else {
            x = y->right;       // (right-child)
        }
        x->parent = y->parent;        // make y's child's parent be y's parent

        if (y->parent == NULL) {
            root = x;           // if y is the root, x is now root
        } else {
            if (y == y->parent->left) { // decide y's relationship with y's parent
                y->parent->left  = x;     // replace x as y's parent's left child
            } else {
                y->parent->right = x;     // replace x as y's parent's left child
            }
        }

        if (y != z) {         // insert y into z's spot
            z->key = y->key;        // copy y data into z
            z->value = y->value;
        }

        // do house-keeping to maintain balance
        if (y->color == false) {
            deleteCleanup(x);
        }

        delete y;
        y = NULL;
    }

    return;
}

void rbtree::deleteCleanup(elementrb *x) {
    elementrb *w, *t;

    // until x is the root, or x is RED
    while ((x != root) && (x->color == false)) {
        if (x == x->parent->left) {   // branch on x being a LEFT-CHILD
            w = x->parent->right;   // grab x's sibling
            if (w->color == true) { // if x's sibling is RED
                w->color = false;     // color w BLACK (case 1)
                x->parent->color = true;  // color x's parent RED            (case 1)
                rotateLeft(x->parent);    // left rotation on x's parent     (case 1)
                w = x->parent->right;     // make w be x's right sibling     (case 1)
            }
            if ((w->left->color == false) && (w->right->color == false)) {
                w->color = true;      // color w RED                     (case 2)
                x = x->parent;        // examine x's parent              (case 2)
            } else {
                if (w->right->color == false) {
                    w->left->color = false; // color w's left child BLACK      (case 3)
                    w->color = true;    // color w RED                     (case 3)
                    t = x->parent;      // store x's parent                (case 3)
                    rotateRight(w);     // right rotation on w             (case 3)
                    x->parent = t;      // restore x's parent              (case 3)
                    w = x->parent->right;   // make w be x's right sibling     (case 3)
                }
                w->color = x->parent->color; // w's color := x's parent's    (case 4)
                x->parent->color = false; // color x's parent BLACK          (case 4)
                w->right->color = false;  // color w's right child BLACK     (case 4)
                rotateLeft(x->parent);    // left rotation on x's parent     (case 4)
                x = root;                 // finished work. bail out         (case 4)
            }
        } else {                // x is RIGHT-CHILD
            w = x->parent->left;      // grab x's sibling
            if (w->color == true) {   // if x's sibling is RED
                w->color = false;       // color w BLACK                 (case 1)
                x->parent->color    = true; // color x's parent RED          (case 1)
                rotateRight(x->parent);     // right rotation on x's parent  (case 1)
                w = x->parent->left;        // make w be x's left sibling    (case 1)
            }
            if ((w->right->color == false) && (w->left->color == false)) {
                w->color = true;        // color w RED                   (case 2)
                x = x->parent;          // examine x's parent            (case 2)
            } else {
                if (w->left->color == false) {
                    w->right->color = false;  // color w's right child BLACK   (case 3)
                    w->color = true;      // color w RED                   (case 3)
                    t = x->parent;        // store x's parent              (case 3)
                    rotateLeft(w);        // left rotation on w            (case 3)
                    x->parent = t;        // restore x's parent            (case 3)
                    w = x->parent->left;      // make w be x's left sibling    (case 3)
                }
                w->color = x->parent->color; // w's color := x's parent's    (case 4)
                x->parent->color    = false; // color x's parent BLACK       (case 4)
                w->left->color = false;      // color w's left child BLACK   (case 4)
                rotateRight(x->parent);      // right rotation on x's parent (case 4)
                x = root;            // x is now the root            (case 4)
            }
        }
    }
    x->color = false;          // color x (the root) BLACK (exit)

    return;
}

// ******** Rotation Functions ******************************************

void rbtree::rotateLeft(elementrb *x) {
    elementrb *y;
    // do pointer-swapping operations for left-rotation
    y = x->right;          // grab right child
    x->right = y->left;        // make x's RIGHT-CHILD be y's LEFT-CHILD
    y->left->parent = x;       // make x be y's LEFT-CHILD's parent
    y->parent = x->parent;     // make y's new parent be x's old parent

    if (x->parent == NULL) {
        root = y;           // if x was root, make y root
    } else {
        // if x is LEFT-CHILD, make y be x's parent's
        if (x == x->parent->left) {
            x->parent->left  = y; // left-child
        } else {
            x->parent->right = y; //  right-child
        }
    }
    y->left   = x;        // make x be y's LEFT-CHILD
    x->parent = y;        // make y be x's parent

    return;
}

void rbtree::rotateRight(elementrb *y) {
    elementrb *x;
    // do pointer-swapping operations for right-rotation
    x = y->left;        // grab left child
    y->left = x->right;     // replace left child yith x's right subtree
    x->right->parent = y;   // replace y as x's right subtree's parent

    x->parent = y->parent;  // make x's new parent be y's old parent

    // if y was root, make x root
    if (y->parent == NULL) {
        root = x;
    } else {
        // if y is RIGHT-CHILD, make x be y's parent's
        if (y == y->parent->right) {
            // right-child
            y->parent->right = x;
        } else {
            // left-child
            y->parent->left = x;
        }
    }
    x->right  = y;        // make y be x's RIGHT-CHILD
    y->parent = x;        // make x be y's parent

    return;
}

// ***********************************************************************
// *** COPYRIGHT NOTICE **************************************************
// dendro.h - hierarchical random graph (hrg) data structure
// Copyright (C) 2005-2009 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ***********************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu |
//                                 http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science
//                AND Santa Fe Institute
// Created      : 26 October 2005 - 7 December 2005
// Modified     : 23 December 2007 (cleaned up for public consumption)
//
// ***********************************************************************
//
// Maximum likelihood dendrogram data structure. This is the heart of
// the HRG algorithm: all manipulations are done here and all data is
// stored here. The data structure uses the separate graph data
// structure to store the basic adjacency information (in a
// dangerously mutable way).
//
// ***********************************************************************

// ******** Dendrogram Methods *******************************************

dendro::dendro(): root(0), internal(0), leaf(0), d(0), splithist(0),
    paths(0), ctree(0), cancestor(0), g(0) { }
dendro::~dendro() {
    list *curr, *prev;

    if (g)        {
        delete    g;            // O(m)
        g        = 0;
    }
    if (internal) {
        delete [] internal;     // O(n)
        internal = 0;
    }
    if (leaf)     {
        delete [] leaf;         // O(n)
        leaf     = 0;
    }
    if (d)        {
        delete    d;            // O(n)
        d        = 0;
    }
    if (splithist) {
        delete    splithist;    // potentially long
        splithist = 0;
    }

    if (paths) {
        for (int i = 0; i < n; i++) {
            curr = paths[i];
            while (curr) {
                prev = curr;
                curr = curr->next;
                delete prev;
                prev = 0;
            }
            paths[i] = 0;
        }
        delete [] paths;
    }
    paths = 0;

    if (ctree)    {
        delete [] ctree;        // O(n)
        ctree     = 0;
    }
    if (cancestor) {
        delete [] cancestor;    // O(n)
        cancestor = 0;
    }
}

// *********************************************************************

void dendro::binarySearchInsert(elementd* x, elementd* y) {
    if (y->p < x->p) {        // go to left subtree
        if (x->L == NULL) {     // check if left subtree is empty
            x->L = y;         // make x left child
            y->M = x;         // make y parent of child
            return;
        } else {
            binarySearchInsert(x->L, y);
        }
    } else {          // go to right subtree
        if (x->R == NULL) {     // check if right subtree is empty
            x->R = y;         // make x right child
            y->M = x;         // make y parent of child
            return;
        } else {
            binarySearchInsert(x->R, y);
        }
    }
    return;
}

// **********************************************************************

list* dendro::binarySearchFind(const double v) {
    list *head = NULL, *tail = NULL, *newlist;
    elementd *current = root;
    bool flag_stopSearch = false;

    while (!flag_stopSearch) {    // continue until we're finished
        newlist    = new list;  // add this node to the path
        newlist->x = current->label;
        if (current == root) {
            head = newlist; tail = head;
        } else {
            tail->next = newlist; tail = newlist;
        }
        if (v < current->p) {   // now try left subtree
            if (current->L->type == GRAPH) {
                flag_stopSearch = true;
            } else {
                current = current->L;
            }
        } else {            // else try right subtree
            if (current->R->type == GRAPH) {
                flag_stopSearch = true;
            } else  {
                current = current->R;
            }
        }
    }
    return head;
}

// ***********************************************************************

string dendro::buildSplit(elementd* thisNode) {
    // A "split" is defined as the bipartition of vertices into the sets
    // of leaves below the internal vertex in the tree (denoted by "C"),
    // and those above it (denoted as "M"). For simplicity, we represent
    // this bipartition as a character string of length n, where the ith
    // character denotes the partition membership (C,M) of the ith leaf
    // node.

    bool flag_go = true;
    const short int k = 1 + DENDRO + GRAPH;
    elementd* curr;
    split sp;

    sp.initializeSplit(n);      // default split string O(n)

    curr = thisNode;        // - set start node as top this sub-tree
    curr->type = k + 1;     // - initialize in-order tree traversal
    while (flag_go) {

        // - is it time, and is left child a graph node?
        if (curr->type == k + 1 && curr->L->type == GRAPH) {
            sp.s[curr->L->index] = 'C'; // - mark this leaf
            curr->type = k + 2;
        }

        // - is it time, and is right child a graph node?
        if (curr->type == k + 2 && curr->R->type == GRAPH) {
            sp.s[curr->R->index] = 'C'; // - mark this leaf
            curr->type           = k + 3;
        }
        if (curr->type == k + 1) {    // - go left
            curr->type = k + 2;
            curr       = curr->L;
            curr->type = k + 1;
        } else if (curr->type == k + 2) { // - else go right
            curr->type = k + 3;
            curr       = curr->R;
            curr->type = k + 1;
        } else {              // - else go up a level
            curr->type = DENDRO;
            if (curr->index == thisNode->index || curr->M == NULL) {
                flag_go = false; curr = NULL;
            } else {
                curr = curr->M;
            }
        }
    }

    // any leaf that was not already marked must be in the remainder of
    // the tree
    for (int i = 0; i < n; i++) {
        if (sp.s[i] != 'C') {
            sp.s[i] = 'M';
        }
    }

    return sp.s;
}

// **********************************************************************

void dendro::buildDendrogram() {

    /* the initialization of the dendrogram structure goes like this:
     * 1) we allocate space for the n-1 internal nodes of the
     *    dendrogram, and then the n leaf nodes
     * 2) we build a random binary tree structure out of the internal
     *    nodes by assigning each a uniformly random value over [0,1] and
     *    then inserting it into the tree according to the
     *    binary-search rule.
     * 3) next, we make a random permutation of the n leaf nodes and add
     *    them to the dendrogram D by replacing the emptpy spots in-order
     * 4) then, we compute the path from the root to each leaf and store
     *    that in each leaf (this is prep work for the next step)
     * 5) finally, we compute the values for nL, nR, e (and thus p) and
     *    the label for each internal node by allocating each of the m
     *    edges in g to the appropriate internal node
     */

    // --- Initialization and memory allocation for data structures
    // After allocating the memory for D and G, we need to mark the
    // nodes for G as being non-internal vertices, and then insert them
    // into a random binary tree structure. For simplicity, we make the
    // first internal node in the array the root.

    n = g->numNodes();          // size of graph
    leaf = new elementd [n];    // allocate memory for G, O(n)
    internal  = new elementd [n - 1]; // allocate memory for D, O(n)
    d = new interns(n - 2);         // allocate memory for internal
    // edges of D, O(n)
    for (int i = 0; i < n; i++) { // initialize leaf nodes
        leaf[i].type   = GRAPH;
        leaf[i].label  = i;
        leaf[i].index  = i;
        leaf[i].n = 1;
    }

// initialize internal nodes
    root = &internal[0];
    root->label = 0;
    root->index = 0;
    root->p = RNG_UNIF01();

    // insert remaining internal vertices, O(n log n)
    for (int i = 1; i < (n - 1); i++) {
        internal[i].label = i;
        internal[i].index = i;
        internal[i].p = RNG_UNIF01();
        binarySearchInsert(root, &internal[i]);
    }

    // --- Hang leaf nodes off end of dendrogram O(n log n)
    // To impose this random hierarchical relationship on G, we first
    // take a random permutation of the leaf vertices and then replace
    // the NULLs at the bottom of the tree in-order with the leafs. As a
    // hack to ensure that we can find the leafs later using a binary
    // search, we assign each of them the p value of their parent,
    // perturbed slightly so as to preserve the binary search property.

    block* array; array = new block [n];
    for (int i = 0; i < n; i++) {
        array[i].x = RNG_UNIF01();
        array[i].y = i;
    }
    QsortMain(array, 0, n - 1);

    int k = 0;        // replace NULLs with leaf nodes, and
    for (int i = 0; i < (n - 1); i++) { // maintain binary search property, O(n)
        if (internal[i].L == NULL) {
            internal[i].L = &leaf[array[k].y];
            leaf[array[k].y].M = &internal[i];
            leaf[array[k++].y].p = internal[i].p - 0.0000000000001;
        }
        if (internal[i].R == NULL) {
            internal[i].R = &leaf[array[k].y];
            leaf[array[k].y].M = &internal[i];
            leaf[array[k++].y].p = internal[i].p + 0.0000000000001;
        }
    }
    delete [] array;

    // --- Compute the path from root -> leaf for each leaf O(n log n)
    // Using the binary search property, we can find each leaf node in
    // O(log n) time. The binarySearchFind() function returns the list
    // of internal node indices that the search crossed, in the order of
    // root -> ... -> leaf, for use in the subsequent few operations.

    if (paths != NULL) {
        list *curr, *prev;
        for (int i = 0; i < n; i++) {
            curr = paths[i];
            while (curr != NULL) {
                prev = curr;
                curr = curr->next;
                delete prev;
                prev = NULL;
            }
            paths[i] = NULL;
        }
        delete [] paths;
    }
    paths = NULL;
    paths = new list* [n];
    for (int i = 0; i < n; i++) {
        paths[i] = binarySearchFind(leaf[i].p);
    }

    // --- Count e for each internal node O(m)
    // To count the number of edges that span the L and R subtrees for
    // each internal node, we use the path information we just
    // computed. Then, we loop over all edges in G and find the common
    // ancestor in D of the two endpoints and increment that internal
    // node's e count. This process takes O(m) time because in a roughly
    // balanced binary tree (given by our random dendrogram), the vast
    // majority of vertices take basically constant time to find their
    // common ancestor. Note that because our adjacency list is
    // symmetric, we overcount each e by a factor of 2, so we need to
    // correct this after.

    elementd* ancestor; edge* curr;
    for (int i = 0; i < (n - 1); i++) {
        internal[i].e = 0;
        internal[i].label = -1;
    }
    for (int i = 0; i < n; i++) {
        curr = g->getNeighborList(i);
        while (curr != NULL) {
            ancestor = findCommonAncestor(paths, i, curr->x);
            ancestor->e += 1;
            curr = curr->next;
        }
    }
    for (int i = 0; i < (n - 1); i++) {
        internal[i].e /= 2;
    }

    // --- Count n for each internal node O(n log n)
    // To tabulate the number of leafs in each subtree rooted at an
    // internal node, we use the path information computed above.
    for (int i = 0; i < n; i++) {
        ancestor = &leaf[i];
        ancestor = ancestor->M;
        while (ancestor != NULL) {
            ancestor->n++;
            ancestor = ancestor->M;
        }
    }

    // --- Label all internal vertices O(n log n)
    // We want to label each internal vertex with the smallest leaf
    // index of its children. This will allow us to collapse many
    // leaf-orderings into a single dendrogram structure that is
    // independent of child-exhanges (since these have no impact on the
    // likelihood of the hierarchical structure). To do this, we loop
    // over the leaf vertices from smallest to largest and walk along
    // that leaf's path from the root. If we find an unlabeled internal
    // node, then we mark it with this leaf's index.

    for (int i = 0; i < n; i++) {
        ancestor = &leaf[i];
        while (ancestor != NULL) {
            if (ancestor->label == -1 || ancestor->label > leaf[i].label) {
                ancestor->label = leaf[i].label;
            }
            ancestor = ancestor->M;
        }
    }

    // --- Exchange children to enforce order-property O(n)
    // We state that the order-property requires that an internal node's
    // label is the smallest index of its left subtree. The dendrogram
    // so far doesn't reflect this, so we need to step through each
    // internal vertex and make that adjustment (swapping nL and nR if
    // we make a change).

    elementd *tempe;
    for (int i = 0; i < (n - 1); i++) {
        if (internal[i].L->label > internal[i].label) {
            tempe = internal[i].L;
            internal[i].L = internal[i].R;
            internal[i].R = tempe;
        }
    }

    // --- Tabulate internal dendrogram edges O(n^2)
    // For the MCMC moves later on, we'll need to be able to choose,
    // uniformly at random, an internal edge of the dendrogram to
    // manipulate. There are always n-2 of them, and we can find them
    // simply by scanning across the internal vertices and observing
    // which have children that are also internal vertices. Note: very
    // important that the order property be enforced before this step is
    // taken; otherwise, the internal edges wont reflect the actual
    // dendrogram structure.

    for (int i = 0; i < (n - 1); i++) {
        if (internal[i].L->type == DENDRO) {
            d->addEdge(i, internal[i].L->index, LEFT);
        }
        if (internal[i].R->type == DENDRO) {
            d->addEdge(i, internal[i].R->index, RIGHT);
        }
    }

    // --- Clear memory for paths O(n log n)
    // Now that we're finished using the paths, we need to deallocate
    // them manually.

    list *current, *previous;
    for (int i = 0; i < n; i++) {
        current = paths[i];
        while (current) {
            previous = current;
            current = current->next;
            delete previous;
            previous = NULL;
        }
        paths[i] = NULL;
    }
    delete [] paths;
    paths = NULL;

    // --- Compute p_i for each internal node O(n)
    // Each internal node's p_i = e_i / (nL_i*nR_i), and now that we
    // have each of those pieces, we may calculate this value for each
    // internal node. Given these, we can then calculate the
    // log-likelihood of the entire dendrogram structure \log(L) =
    // \sum_{i=1}^{n} ( ( e_i \log[p_i] ) + ( (nL_i*nR_i - e_i)
    // \log[1-p_i] ) )

    L = 0.0; double dL;
    int nL_nR, ei;
    for (int i = 0; i < (n - 1); i++) {
        nL_nR = internal[i].L->n * internal[i].R->n;
        ei = internal[i].e;
        internal[i].p = (double)(ei) / (double)(nL_nR);
        if (ei == 0 || ei == nL_nR) {
            dL = 0.0;
        } else {
            dL = ei * log(internal[i].p) + (nL_nR - ei) * log(1.0 - internal[i].p);
        }
        internal[i].logL = dL;
        L += dL;
    }

    for (int i = 0; i < (n - 1); i++) {
        if (internal[i].label > internal[i].L->label) {
            tempe = internal[i].L;
            internal[i].L = internal[i].R;
            internal[i].R = tempe;
        }
    }

    // Dendrogram is now built

    return;
}

// ***********************************************************************

void dendro::clearDendrograph() {
    // Clear out the memory and references used by the dendrograph
    // structure - this is  intended to be called just before an
    // importDendrogramStructure call so as to avoid memory leaks and
    // overwriting the references therein.

    if (g        != NULL) {
        delete    g;           // O(m)
        g        = NULL;
    }
    if (leaf     != NULL) {
        delete [] leaf;        // O(n)
        leaf     = NULL;
    }
    if (internal != NULL) {
        delete [] internal;    // O(n)
        internal = NULL;
    }
    if (d        != NULL) {
        delete    d;        // O(n)
        d           = NULL;
    }
    root = NULL;

    return;
}

// **********************************************************************

int dendro::computeEdgeCount(const int a, const short int atype,
                             const int b, const short int btype) {
    // This function computes the number of edges that cross between the
    // subtree internal[a] and the subtree internal[b]. To do this, we
    // use an array A[1..n] integers which take values -1 if A[i] is in
    // the subtree defined by internal[a], +1 if A[i] is in the subtree
    // internal[b], and 0 otherwise. Taking the smaller of the two sets,
    // we then scan over the edges attached  to that set of vertices and
    // count the number of endpoints we see in the other set.

    bool flag_go    = true;
    int nA, nB;
    int         count = 0;
    const short int k = 1 + DENDRO + GRAPH;

    elementd* curr;

    // First, we push the leaf nodes in the L and R subtrees into
    // balanced binary tree structures so that we can search them
    // quickly later on.

    if (atype == GRAPH) {
        // default case, subtree A is size 1
        // insert single node as member of left subtree
        subtreeL.insertItem(a, -1);
        nA = 1; //
    } else {
        // explore subtree A, O(|A|)
        curr  = &internal[a];
        curr->type = k + 1;
        nA = 0;
        while (flag_go) {
            if (curr->index == internal[a].M->index) {
                internal[a].type = DENDRO;
                flag_go = false;
            } else {
                // - is it time, and is left child a graph node?
                if (curr->type == k + 1 && curr->L->type == GRAPH) {
                    subtreeL.insertItem(curr->L->index, -1);
                    curr->type = k + 2;
                    nA++;
                }
                // - is it time, and is right child a graph node?
                if (curr->type == k + 2 && curr->R->type == GRAPH) {
                    subtreeL.insertItem(curr->R->index, -1);
                    curr->type = k + 3;
                    nA++;
                }
                if (curr->type == k + 1) {    // - go left
                    curr->type = k + 2;
                    curr       = curr->L;
                    curr->type = k + 1;
                } else if (curr->type == k + 2) { // - else go right
                    curr->type = k + 3;
                    curr       = curr->R;
                    curr->type = k + 1;
                } else {              // - else go up a level
                    curr->type = DENDRO;
                    curr       = curr->M;
                    if (curr == NULL) {
                        flag_go = false;
                    }
                }
            }
        }
    }

    if (btype == GRAPH) {
        // default case, subtree A is size 1
        // insert node as single member of right subtree
        subtreeR.insertItem(b, 1);
        nB = 1;
    } else {
        flag_go = true;
        // explore subtree B, O(|B|)
        curr = &internal[b];
        curr->type = k + 1;
        nB  = 0;
        while (flag_go) {
            if (curr->index == internal[b].M->index) {
                internal[b].type = DENDRO;
                flag_go = false;
            } else {
                // - is it time, and is left child a graph node?
                if (curr->type == k + 1 && curr->L->type == GRAPH) {
                    subtreeR.insertItem(curr->L->index, 1);
                    curr->type = k + 2;
                    nB++;
                }
                // - is it time, and is right child a graph node?
                if (curr->type == k + 2 && curr->R->type == GRAPH) {
                    subtreeR.insertItem(curr->R->index, 1);
                    curr->type = k + 3;
                    nB++;
                }
                if (curr->type == k + 1) {    // - look left
                    curr->type = k + 2;
                    curr       = curr->L;
                    curr->type = k + 1;
                } else if (curr->type == k + 2) { // - look right
                    curr->type = k + 3;
                    curr       = curr->R;
                    curr->type = k + 1;
                } else {              // - else go up a level
                    curr->type = DENDRO;
                    curr       = curr->M;
                    if (curr == NULL) {
                        flag_go = false;
                    }
                }
            }
        }
    }

    // Now, we take the smaller subtree and ask how many of its
    // emerging edges have their partner in the other subtree. O(|A| log
    // |A|) time

    edge* current;
    int*  treeList;
    if (nA < nB) {
        // subtreeL is smaller
        treeList = subtreeL.returnArrayOfKeys();
        for (int i = 0; i < nA; i++) {
            current = g->getNeighborList(treeList[i]);
            // loop over each of its neighbors v_j
            while (current != NULL) {
                // to see if v_j is in A
                if (subtreeR.findItem(current->x) != NULL) {
                    count++;
                }
                current = current->next;
            }
            subtreeL.deleteItem(treeList[i]);
        }
        delete [] treeList;
        treeList = subtreeR.returnArrayOfKeys();
        for (int i = 0; i < nB; i++) {
            subtreeR.deleteItem(treeList[i]);
        }
        delete [] treeList;
    } else {
        // subtreeR is smaller
        treeList = subtreeR.returnArrayOfKeys();
        for (int i = 0; i < nB; i++) {
            current = g->getNeighborList(treeList[i]);
            // loop over each of its neighbors v_j
            while (current != NULL) {
                // to see if v_j is in B
                if (subtreeL.findItem(current->x) != NULL) {
                    count++;
                }
                current = current->next;
            }
            subtreeR.deleteItem(treeList[i]);
        }
        delete [] treeList;
        treeList = subtreeL.returnArrayOfKeys();
        for (int i = 0; i < nA; i++) {
            subtreeL.deleteItem(treeList[i]);
        }
        delete [] treeList;
    }

    return count;
}

// ***********************************************************************

int dendro::countChildren(const string s) {
    int len = s.size();
    int numC = 0;
    for (int i = 0; i < len; i++) {
        if (s[i] == 'C') {
            numC++;
        }
    }
    return numC;
}

// ***********************************************************************

void dendro::cullSplitHist() {
    string* array;
    int tot, leng;

    array = splithist->returnArrayOfKeys();
    tot   = splithist->returnTotal();
    leng  = splithist->returnNodecount();
    for (int i = 0; i < leng; i++) {
        if ((splithist->returnValue(array[i]) / tot) < 0.5) {
            splithist->deleteItem(array[i]);
        }
    }
    delete [] array; array = NULL;

    return;
}

// **********************************************************************

elementd* dendro::findCommonAncestor(list** paths_, const int i, const int j) {
    list* headOne = paths_[i];
    list* headTwo = paths_[j];
    elementd* lastStep = NULL;
    while (headOne->x == headTwo->x) {
        lastStep = &internal[headOne->x];
        headOne  = headOne->next;
        headTwo  = headTwo->next;
        if (headOne == NULL || headTwo == NULL) {
            break;
        }
    }
    return lastStep; // Returns address of an internal node; do not deallocate
}

// **********************************************************************

int dendro::getConsensusSize() {
    string    *array;
    double     value, tot;
    int  numSplits, numCons;
    numSplits = splithist->returnNodecount();
    array     = splithist->returnArrayOfKeys();
    tot       = splithist->returnTotal();
    numCons = 0;
    for (int i = 0; i < numSplits; i++) {
        value = splithist->returnValue(array[i]);
        if (value / tot > 0.5) {
            numCons++;
        }
    }
    delete [] array; array = NULL;
    return numCons;
}

// **********************************************************************

splittree* dendro::getConsensusSplits() {
    string    *array;
    splittree *consensusTree;
    double     value, tot;
    consensusTree  = new splittree;
    int numSplits;

    // We look at all of the splits in our split histogram and add any
    // one that's in the majority to our consensusTree, which we then
    // return (note that consensusTree needs to be deallocated by the
    // user).
    numSplits = splithist->returnNodecount();
    array     = splithist->returnArrayOfKeys();
    tot       = splithist->returnTotal();
    for (int i = 0; i < numSplits; i++) {
        value = splithist->returnValue(array[i]);
        if (value / tot > 0.5) {
            consensusTree->insertItem(array[i], value / tot);
        }
    }
    delete [] array; array = NULL;
    return consensusTree;
}

// ***********************************************************************

double dendro::getLikelihood() {
    return L;
}

// ***********************************************************************

void dendro::getSplitList(splittree* split_tree) {
    string sp;
    for (int i = 0; i < (n - 1); i++) {
        sp = d->getSplit(i);
        if (!sp.empty() && sp[1] != '-') {
            split_tree->insertItem(sp, 0.0);
        }
    }
    return;
}

// ***********************************************************************

double dendro::getSplitTotalWeight() {
    if (splithist) {
        return splithist->returnTotal();
    } else {
        return 0;
    }
}

// ***********************************************************************

bool dendro::importDendrogramStructure(const igraph_hrg_t *hrg) {
    n = igraph_hrg_size(hrg);

    // allocate memory for G, O(n)
    leaf = new elementd[n];
    // allocate memory for D, O(n)
    internal = new elementd[n - 1];
    // allocate memory for internal edges of D, O(n)
    d = new interns(n - 2);

    // initialize leaf nodes
    for (int i = 0; i < n; i++) {
        leaf[i].type  = GRAPH;
        leaf[i].label = i;
        leaf[i].index = i;
        leaf[i].n     = 1;
    }

    // initialize internal nodes
    root = &internal[0];
    root->label = 0;
    for (int i = 1; i < n - 1; i++) {
        internal[i].index = i;
        internal[i].label = -1;
    }

    // import basic structure from hrg object, O(n)
    for (int i = 0; i < n - 1; i++) {
        int left_index = VECTOR(hrg->left)[i];
        int right_index = VECTOR(hrg->right)[i];

        if (left_index < 0) {
            internal[i].L = &internal[-left_index - 1];
            internal[-left_index - 1].M = &internal[i];
        } else {
            internal[i].L = &leaf[left_index];
            leaf[left_index].M = &internal[i];
        }

        if (right_index < 0) {
            internal[i].R = &internal[-right_index - 1];
            internal[-right_index - 1].M = &internal[i];
        } else {
            internal[i].R = &leaf[right_index];
            leaf[right_index].M = &internal[i];
        }

        internal[i].p = VECTOR(hrg->prob)[i];
        internal[i].e = VECTOR(hrg->edges)[i];
        internal[i].n = VECTOR(hrg->vertices)[i];
        internal[i].index = i;
    }

    // --- Label all internal vertices O(n log n)
    elementd *curr;
    for (int i = 0; i < n; i++) {
        curr = &leaf[i];
        while (curr) {
            if (curr->label == -1 || curr->label > leaf[i].label) {
                curr->label = leaf[i].label;
            }
            curr = curr -> M;
        }
    }

    // --- Exchange children to enforce order-property O(n)
    elementd *tempe;
    for (int i = 0; i < n - 1; i++) {
        if (internal[i].L->label > internal[i].label) {
            tempe          = internal[i].L;
            internal[i].L  = internal[i].R;
            internal[i].R  = tempe;
        }
    }

    // --- Tabulate internal dendrogram edges O(n)
    for (int i = 0; i < (n - 1); i++) {
        if (internal[i].L->type == DENDRO) {
            d->addEdge(i, internal[i].L->index, LEFT);
        }
        if (internal[i].R->type == DENDRO) {
            d->addEdge(i, internal[i].R->index, RIGHT);
        }
    }

    // --- Compute p_i for each internal node O(n)
    // Each internal node's p_i = e_i / (nL_i*nR_i), and now that we
    // have each of those pieces, we may calculate this value for each
    // internal node. Given these, we can then calculate the
    // log-likelihood of the entire dendrogram structure
    // \log(L) = \sum_{i=1}^{n} ( ( e_i \log[p_i] ) +
    // ( (nL_i*nR_i - e_i) \log[1-p_i] ) )
    L = 0.0; double dL;
    int nL_nR, ei;
    for (int i = 0; i < (n - 1); i++) {
        nL_nR = internal[i].L->n * internal[i].R->n;
        ei    = internal[i].e;
        if (ei == 0 || ei == nL_nR) {
            dL = 0.0;
        } else {
            dL = (double)(ei) * log(internal[i].p) +
                 (double)(nL_nR - ei) * log(1.0 - internal[i].p);
        }
        internal[i].logL = dL;
        L += dL;
    }

    return true;
}

// ***********************************************************************

void dendro::makeRandomGraph() {
    if (g != NULL) {
        delete g;
    } g = NULL; g = new graph(n);

    list *curr, *prev;
    if (paths) {
        for (int i = 0; i < n; i++) {
            curr = paths[i];
            while (curr != NULL) {
                prev = curr;
                curr = curr->next;
                delete prev;
                prev = NULL;
            }
            paths[i] = NULL;
        }
        delete [] paths;
    }
// build paths from root O(n d)
    paths = new list* [n];
    for (int i = 0; i < n; i++) {
        paths[i] = reversePathToRoot(i);
    }

    elementd* commonAncestor;
// O((h+d)*n^2) - h: height of D; d: average degree in G
    for (int i = 0; i < n; i++) {
        // decide neighbors of v_i
        for (int j = (i + 1); j < n; j++) {
            commonAncestor = findCommonAncestor(paths, i, j);
            if (RNG_UNIF01() < commonAncestor->p) {
                if (!(g->doesLinkExist(i, j))) {
                    g->addLink(i, j);
                }
                if (!(g->doesLinkExist(j, i))) {
                    g->addLink(j, i);
                }
            }
        }
    }

    for (int i = 0; i < n; i++) {
        curr = paths[i];
        while (curr != NULL) {
            prev = curr;
            curr = curr->next;
            delete prev;
            prev = NULL;
        }
        paths[i] = NULL;
    }
    delete [] paths; // delete paths data structure O(n log n)
    paths = NULL;

    return;
}

// **********************************************************************

bool dendro::monteCarloMove(double& delta, bool& ftaken, const double T) {
    // A single MC move begins with the selection of a random internal
    // edge (a,b) of the dendrogram. This also determines the three
    // subtrees i, j, k that we will rearrange, and we choose uniformly
    // from among the options.
    //
    // If (a,b) is a left-edge, then we have ((i,j),k), and moves
    // ((i,j),k) -> ((i,k),j) (alpha move)
    //           -> (i,(j,k)) + enforce order-property for (j,k) (beta move)
    //
    // If (a,b) is a right-edge, then we have (i,(j,k)), and moves
    // (i,(j,k)) -> ((i,k),j) (alpha move)
    //           -> ((i,j),k) (beta move)
    //
    // For each of these moves, we need to know what the change in
    // likelihood will be, so that we can determine with what
    // probability we execute the move.

    elementd *temp;
    ipair *tempPair;
    int x, y, e_x, e_y, n_i, n_j, n_k, n_x, n_y;
    short int t;
    double p_x, p_y, L_x, L_y, dLogL;
    string new_split;

    // The remainder of the code executes a single MCMC move, where we
    // sample the dendrograms proportionally to their likelihoods (i.e.,
    // temperature=1, if you're comparing it to the usual MCMC
    // framework).

    delta    = 0.0;
    ftaken   = false;
    tempPair = d->getRandomEdge(); // returns address; no need to deallocate
    x        = tempPair->x;        // copy contents of referenced random edge
    y        = tempPair->y;        // into local variables
    t        = tempPair->t;

    if (t == LEFT) {
        if (RNG_UNIF01() < 0.5) { // ## LEFT ALPHA move: ((i,j),k) -> ((i,k),j)
            // We need to calculate the change in the likelihood (dLogL)
            // that would result from this move. Most of the information
            // needed to do this is already available, the exception being
            // e_ik, the number of edges that span the i and k subtrees. I
            // use a slow algorithm O(n) to do this, since I don't know of a
            // better way at this point. (After several attempts to find a
            // faster method, no luck.)

            n_i = internal[y].L->n;
            n_j = internal[y].R->n;
            n_k = internal[x].R->n;

            n_y = n_i * n_k;
            e_y = computeEdgeCount(internal[y].L->index, internal[y].L->type,
                                   internal[x].R->index, internal[x].R->type);
            p_y  = (double)(e_y) / (double)(n_y);
            if (e_y == 0 || e_y == n_y) {
                L_y = 0.0;
            } else {
                L_y = (double)(e_y) * log(p_y) + (double)(n_y - e_y) * log(1.0 - p_y);
            }

            n_x  = (n_i + n_k) * n_j;
            e_x  = internal[x].e + internal[y].e - e_y; // e_yj
            p_x  = (double)(e_x) / (double)(n_x);
            if (e_x == 0 || e_x == n_x) {
                L_x = 0.0;
            } else {
                L_x = (double)(e_x) * log(p_x) + (double)(n_x - e_x) * log(1.0 - p_x);
            }

            dLogL = (L_x - internal[x].logL) + (L_y - internal[y].logL);
            if ((dLogL > 0.0) || (RNG_UNIF01() < exp(T * dLogL))) {

                // make LEFT ALPHA move

                ftaken = true;
                d->swapEdges(x, internal[x].R->index, RIGHT, y,
                             internal[y].R->index, RIGHT);
                temp             = internal[x].R; // - swap j and k
                internal[x].R    = internal[y].R;
                internal[y].R    = temp;
                internal[x].R->M = &internal[x];  // - adjust parent pointers
                internal[y].R->M = &internal[y];
                internal[y].n    = n_i + n_k;     // - update n for [y]
                internal[x].e    = e_x;           // - update e_i for [x] and [y]
                internal[y].e    = e_y;
                internal[x].p    = p_x;           // - update p_i for [x] and [y]
                internal[y].p    = p_y;
                internal[x].logL = L_x;           // - update L_i for [x] and [y]
                internal[y].logL = L_y;
                // - order-property maintained
                L  += dLogL;                  // - update LogL
                delta            = dLogL;

            }
        } else {

            // ## LEFT BETA move:  ((i,j),k) -> (i,(j,k))

            n_i = internal[y].L->n;
            n_j = internal[y].R->n;
            n_k = internal[x].R->n;

            n_y  = n_j * n_k;
            e_y  = computeEdgeCount(internal[y].R->index, internal[y].R->type,
                                    internal[x].R->index, internal[x].R->type);
            p_y  = (double)(e_y) / (double)(n_y);
            if (e_y == 0 || e_y == n_y)   {
                L_y = 0.0;
            } else {
                L_y = (double)(e_y) * log(p_y) +
                      (double)(n_y - e_y) * log(1.0 - p_y);
            }

            n_x  = (n_j + n_k) * n_i;
            e_x  = internal[x].e + internal[y].e - e_y; // e_yj
            p_x  = (double)(e_x) / (double)(n_x);
            if (e_x == 0 || e_x == n_x) {
                L_x = 0.0;
            } else {
                L_x = (double)(e_x) * log(p_x) + (double)(n_x - e_x) * log(1.0 - p_x);
            }

            dLogL = (L_x - internal[x].logL) + (L_y - internal[y].logL);
            if ((dLogL > 0.0) || (RNG_UNIF01() < exp(T * dLogL))) {

                // make LEFT BETA move

                ftaken = true;
                d->swapEdges(y, internal[y].L->index, LEFT, y,
                             internal[y].R->index, RIGHT);
                temp   = internal[y].L;       // - swap L and R of [y]
                internal[y].L    = internal[y].R;
                internal[y].R    = temp;
                d->swapEdges(x, internal[x].R->index, RIGHT,
                             y, internal[y].R->index, RIGHT);
                temp   = internal[x].R;       // - swap i and k
                internal[x].R    = internal[y].R;
                internal[y].R    = temp;
                internal[x].R->M = &internal[x];  // - adjust parent pointers
                internal[y].R->M = &internal[y];
                d->swapEdges(x, internal[x].L->index, LEFT,
                             x, internal[x].R->index, RIGHT);
                temp   = internal[x].L;       // - swap L and R of [x]
                internal[x].L    = internal[x].R;
                internal[x].R    = temp;
                internal[y].n    = n_j + n_k;     // - update n
                internal[x].e    = e_x;       // - update e_i
                internal[y].e    = e_y;
                internal[x].p    = p_x;           // - update p_i
                internal[y].p    = p_y;
                internal[x].logL = L_x;           // - update logL_i
                internal[y].logL = L_y;
                if (internal[y].R->label < internal[y].L->label) {
                    // - enforce order-property if necessary
                    d->swapEdges(y, internal[y].L->index, LEFT,
                                 y, internal[y].R->index, RIGHT);
                    temp = internal[y].L;
                    internal[y].L = internal[y].R;
                    internal[y].R = temp;
                } //
                internal[y].label = internal[y].L->label;
                L += dLogL;        // - update LogL
                delta = dLogL;
            }
        }
    } else {

        // right-edge: t == RIGHT

        if (RNG_UNIF01() < 0.5) {

            // alpha move: (i,(j,k)) -> ((i,k),j)

            n_i = internal[x].L->n;
            n_j = internal[y].L->n;
            n_k = internal[y].R->n;

            n_y  = n_i * n_k;
            e_y  = computeEdgeCount(internal[x].L->index, internal[x].L->type,
                                    internal[y].R->index, internal[y].R->type);
            p_y  = (double)(e_y) / (double)(n_y);
            if (e_y == 0 || e_y == n_y)   {
                L_y = 0.0;
            } else {
                L_y = (double)(e_y) * log(p_y) + (double)(n_y - e_y) * log(1.0 - p_y);
            }

            n_x  = (n_i + n_k) * n_j;
            e_x  = internal[x].e + internal[y].e - e_y; // e_yj
            p_x  = (double)(e_x) / (double)(n_x);
            if (e_x == 0 || e_x == n_x) {
                L_x = 0.0;
            } else {
                L_x = (double)(e_x) * log(p_x) + (double)(n_x - e_x) * log(1.0 - p_x);
            }

            dLogL = (L_x - internal[x].logL) + (L_y - internal[y].logL);
            if ((dLogL > 0.0) || (RNG_UNIF01() < exp(T * dLogL))) {

                // make RIGHT ALPHA move

                ftaken = true;
                d->swapEdges(x, internal[x].L->index, LEFT,
                             x, internal[x].R->index, RIGHT);
                temp    = internal[x].L;       // - swap L and R of [x]
                internal[x].L     = internal[x].R;
                internal[x].R     = temp;
                d->swapEdges(y, internal[y].L->index, LEFT,
                             x, internal[x].R->index, RIGHT);
                temp    = internal[y].L;       // - swap i and j
                internal[y].L     = internal[x].R;
                internal[x].R     = temp;
                internal[x].R->M  = &internal[x];  // - adjust parent pointers
                internal[y].L->M  = &internal[y];
                internal[y].n     = n_i + n_k;     // - update n
                internal[x].e     = e_x;       // - update e_i
                internal[y].e     = e_y;
                internal[x].p     = p_x;           // - update p_i
                internal[y].p     = p_y;
                internal[x].logL  = L_x;           // - update logL_i
                internal[y].logL  = L_y;
                internal[y].label = internal[x].label; // - update order property
                L   += dLogL;                  // - update LogL
                delta             = dLogL;
            }
        } else {

            // beta move:  (i,(j,k)) -> ((i,j),k)

            n_i = internal[x].L->n;
            n_j = internal[y].L->n;
            n_k = internal[y].R->n;

            n_y  = n_i * n_j;
            e_y  = computeEdgeCount(internal[x].L->index, internal[x].L->type,
                                    internal[y].L->index, internal[y].L->type);
            p_y  = (double)(e_y) / (double)(n_y);
            if (e_y == 0 || e_y == n_y)   {
                L_y = 0.0;
            } else {
                L_y = (double)(e_y) * log(p_y) + (double)(n_y - e_y) * log(1.0 - p_y);
            }

            n_x  = (n_i + n_j) * n_k;
            e_x  = internal[x].e + internal[y].e - e_y; // e_yk
            p_x  = (double)(e_x) / (double)(n_x);
            if (e_x == 0 || e_x == n_x) {
                L_x = 0.0;
            } else {
                L_x = (double)(e_x) * log(p_x) + (double)(n_x - e_x) * log(1.0 - p_x);
            }

            dLogL = (L_x - internal[x].logL) + (L_y - internal[y].logL);
            if ((dLogL > 0.0) || (RNG_UNIF01() < exp(T * dLogL))) {

                // make RIGHT BETA move

                ftaken = true;
                d->swapEdges(x, internal[x].L->index, LEFT,
                             x, internal[x].R->index, RIGHT);
                temp    = internal[x].L;       // - swap L and R of [x]
                internal[x].L     = internal[x].R;
                internal[x].R     = temp;
                d->swapEdges(x, internal[x].R->index, RIGHT,
                             y, internal[y].R->index, RIGHT);
                temp    = internal[x].R;       // - swap i and k
                internal[x].R     = internal[y].R;
                internal[y].R     = temp;
                internal[x].R->M  = &internal[x];  // - adjust parent pointers
                internal[y].R->M  = &internal[y];
                d->swapEdges(y, internal[y].L->index, LEFT,
                             y, internal[y].R->index, RIGHT);
                temp    = internal[y].L;       // - swap L and R of [y]
                internal[y].L     = internal[y].R;
                internal[y].R     = temp;
                internal[y].n     = n_i + n_j;     // - update n
                internal[x].e     = e_x;       // - update e_i
                internal[y].e     = e_y;
                internal[x].p     = p_x;       // - update p_i
                internal[y].p     = p_y;
                internal[x].logL  = L_x;       // - update logL_i
                internal[y].logL  = L_y;
                internal[y].label = internal[x].label; // - order-property
                L   += dLogL;                  // - update LogL
                delta             = dLogL;
            }
        }
    }
    return true;
}

// **********************************************************************

void dendro::refreshLikelihood() {
    // recalculates the log-likelihood of the dendrogram structure
    L = 0.0; double dL;
    int nL_nR, ei;
    for (int i = 0; i < (n - 1); i++) {
        nL_nR = internal[i].L->n * internal[i].R->n;
        ei    = internal[i].e;
        internal[i].p = (double)(ei) / (double)(nL_nR);
        if (ei == 0 || ei == nL_nR) {
            dL = 0.0;
        } else {
            dL = ei * log(internal[i].p) + (nL_nR - ei) * log(1.0 - internal[i].p);
        }
        internal[i].logL = dL;
        L += dL;
    }
    return;
}

// **********************************************************************

void dendro::QsortMain (block* array, int left, int right) {
    if (right > left) {
        int pivot = left;
        int part  = QsortPartition(array, left, right, pivot);
        QsortMain(array, left,   part - 1);
        QsortMain(array, part + 1, right  );
    }
    return;
}

int dendro::QsortPartition (block* array, int left, int right, int index) {
    block p_value, temp;
    p_value.x = array[index].x;
    p_value.y = array[index].y;

    // swap(array[p_value], array[right])
    temp.x = array[right].x;
    temp.y = array[right].y;
    array[right].x = array[index].x;
    array[right].y = array[index].y;
    array[index].x = temp.x;
    array[index].y = temp.y;

    int stored = left;
    for (int i = left; i < right; i++) {
        if (array[i].x <= p_value.x) {
            // swap(array[stored], array[i])
            temp.x = array[i].x;
            temp.y = array[i].y;
            array[i].x = array[stored].x;
            array[i].y = array[stored].y;
            array[stored].x = temp.x;
            array[stored].y = temp.y;
            stored++;
        }
    }
    // swap(array[right], array[stored])
    temp.x = array[stored].x;
    temp.y = array[stored].y;
    array[stored].x = array[right].x;
    array[stored].y = array[right].y;
    array[right].x = temp.x;
    array[right].y  = temp.y;

    return stored;
}

void dendro::recordConsensusTree(igraph_vector_t *parents,
                                 igraph_vector_t *weights) {

    keyValuePairSplit *curr, *prev;
    child *newChild;
    int orig_nodes = g->numNodes();

    // First, cull the split hist so that only splits with weight >= 0.5
    // remain
    cullSplitHist();
    int treesize = splithist->returnNodecount();

    // Now, initialize the various arrays we use to keep track of the
    // internal structure of the consensus tree.
    ctree  = new cnode[treesize];
    cancestor = new int[n];
    for (int i = 0; i < treesize; i++) {
        ctree[i].index = i;
    }
    for (int i = 0; i < n; i++)        {
        cancestor[i]   = -1;
    }
    int ii = 0;

    // To build the majority consensus tree, we do the following: For
    // each possible number of Ms in the split string (a number that
    // ranges from n-2 down to 0), and for each split with that number
    // of Ms, we create a new internal node of the tree, and connect the
    // oldest ancestor of each C to that node (at most once). Then, we
    // update our list of oldest ancestors to reflect this new join, and
    // proceed.
    for (int i = n - 2; i >= 0; i--) {
        // First, we get a list of all the splits with this exactly i Ms
        curr = splithist->returnTheseSplits(i);

        // Now we loop over that list
        while (curr != NULL) {
            splithist->deleteItem(curr->x);
            // add weight to this internal node
            ctree[ii].weight = curr->y;
            // examine each letter of this split
            for (int j = 0; j < n; j++) {
                if (curr->x[j] == 'C') {
                    // - node is child of this internal node
                    if (cancestor[j] == -1) {
                        // - first time this leaf has ever been seen
                        newChild        = new child;
                        newChild->type  = GRAPH;
                        newChild->index = j;
                        newChild->next  = NULL;
                        // - attach child to list
                        if (ctree[ii].lastChild == NULL) {
                            ctree[ii].children  = newChild;
                            ctree[ii].lastChild = newChild;
                            ctree[ii].degree    = 1;
                        } else {
                            ctree[ii].lastChild->next = newChild;
                            ctree[ii].lastChild       = newChild;
                            ctree[ii].degree   += 1;
                        }
                    } else {
                        // - this leaf has been seen before
                        // If the parent of the ancestor of this leaf is the
                        // current internal node then this leaf is already a
                        // descendant of this internal node, and we can move on;
                        // otherwise, we need to add that ancestor to this
                        // internal node's child list, and update various
                        // relations
                        if (ctree[cancestor[j]].parent != ii) {
                            ctree[cancestor[j]].parent = ii;
                            newChild        = new child;
                            newChild->type  = DENDRO;
                            newChild->index = cancestor[j];
                            newChild->next  = NULL;
                            // - attach child to list
                            if (ctree[ii].lastChild == NULL) {
                                ctree[ii].children  = newChild;
                                ctree[ii].lastChild = newChild;
                                ctree[ii].degree    = 1;
                            } else {
                                ctree[ii].lastChild->next = newChild;
                                ctree[ii].lastChild       = newChild;
                                ctree[ii].degree   += 1;
                            }
                        }
                    }
                    // note new ancestry for this leaf
                    cancestor[j] = ii;
                }
            }
            // update internal node index
            ii++;
            prev = curr;
            curr = curr->next;
            delete prev;
        }
    }

    // Return the consensus tree
    igraph_vector_resize(parents, ii + orig_nodes);
    if (weights) {
        igraph_vector_resize(weights, ii);
    }

    for (int i = 0; i < ii; i++) {
        child *sat, *sit = ctree[i].children;
        while (sit) {
            VECTOR(*parents)[orig_nodes + i] =
                ctree[i].parent < 0 ? -1 : orig_nodes + ctree[i].parent;
            if (sit->type == GRAPH) {
                VECTOR(*parents)[sit->index] = orig_nodes + i;
            }
            sat = sit;
            sit = sit->next;
            delete sat;
        }
        if (weights) {
            VECTOR(*weights)[i] = ctree[i].weight;
        }
        ctree[i].children = 0;
    }

    // Plus the isolate nodes
    for (int i = 0; i < n; i++) {
        if (cancestor[i] == -1) {
            VECTOR(*parents)[i] = -1;
        }
    }


}

// **********************************************************************

void dendro::recordDendrogramStructure(igraph_hrg_t *hrg) {
    for (int i = 0; i < n - 1; i++) {
        int li = internal[i].L->index;
        int ri = internal[i].R->index;
        VECTOR(hrg->left )[i] = internal[i].L->type == DENDRO ? -li - 1 : li;
        VECTOR(hrg->right)[i] = internal[i].R->type == DENDRO ? -ri - 1 : ri;
        VECTOR(hrg->prob )[i] = internal[i].p;
        VECTOR(hrg->edges)[i] = internal[i].e;
        VECTOR(hrg->vertices)[i] = internal[i].n;
    }
}

void dendro::recordGraphStructure(igraph_t *graph) {
    igraph_vector_t edges;
    int no_of_nodes = g->numNodes();
    int no_of_edges = g->numLinks() / 2;
    int idx = 0;

    igraph_vector_init(&edges, no_of_edges * 2);
    IGRAPH_FINALLY(igraph_vector_destroy, &edges);

    for (int i = 0; i < n; i++) {
        edge *curr = g->getNeighborList(i);
        while (curr) {
            if (i < curr->x) {
                VECTOR(edges)[idx++] = i;
                VECTOR(edges)[idx++] = curr->x;
            }
            curr = curr->next;
        }
    }

    igraph_create(graph, &edges, no_of_nodes, /* directed= */ 0);

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
}

// **********************************************************************

list* dendro::reversePathToRoot(const int leafIndex) {
    list *head, *subhead, *newlist;
    head = subhead = newlist = NULL;
    elementd *current = &leaf[leafIndex];

    // continue until we're finished
    while (current != NULL) {
        // add this node to the path
        newlist = new list;
        newlist->x = current->index;
        newlist->next = NULL;
        if (head == NULL) {
            head    = newlist;
        } else {
            subhead = head;
            head = newlist;
            head->next = subhead;
        }
        current = current->M;
    }
    return head;
}

// ***********************************************************************

bool dendro::sampleSplitLikelihoods(int &sample_num) {
    // In order to compute the majority agreement dendrogram at
    // equilibrium, we need to calculate the leaf partition defined by
    // each split (internal edge) of the tree. Because splits are only
    // defined on a Cayley tree, the buildSplit() function returns the
    // default "--...--"  string for the root and the root's left
    // child. When tabulating the frequency of splits, one of these
    // needs to be excluded.

    IGRAPH_UNUSED(sample_num);

    string* array;
    int     k;
    double  tot;

    string new_split;
    // To decompose the tree into its splits, we simply loop over all
    // the internal nodes and replace the old split for the ith internal
    // node with its new split. This is a bit time consuming to do
    // O(n^2), so try not to do this very often. Once the decomposition
    // is had, we insert them into the split histogram, which tracks the
    // cumulative weight for each respective split observed.

    if (splithist == NULL) {
        splithist = new splittree;
    }
    for (int i = 0; i < (n - 1); i++) {
        new_split = buildSplit(&internal[i]);
        d->replaceSplit(i, new_split);
        if (!new_split.empty() && new_split[1] != '-') {
            if (!splithist->insertItem(new_split, 1.0)) {
                return false;
            }
        }
    }
    splithist->finishedThisRound();

    // For large graphs, the split histogram can get extremely large, so
    // we need to employ some measures to prevent it from swamping the
    // available memory. When the number of splits exceeds  a threshold
    // (say, a million), we progressively delete splits that have a
    // weight less than  a rising (k*0.001 of the total weight) fraction
    // of the splits, on the assumption that losing such weight is
    // unlikely to effect the ultimate split statistics. This deletion
    // procedure is slow O(m lg m), but should only happen very rarely.

    int split_max = n * 500;
    int leng;
    if (splithist->returnNodecount() > split_max) {
        k = 1;
        while (splithist->returnNodecount() > split_max) {
            array = splithist->returnArrayOfKeys();
            tot   = splithist->returnTotal();
            leng  = splithist->returnNodecount();
            for (int i = 0; i < leng; i++) {
                if ((splithist->returnValue(array[i]) / tot) < k * 0.001) {
                    splithist->deleteItem(array[i]);
                }
            }
            delete [] array; array = NULL;
            k++;
        }
    }

    return true;
}

void dendro::sampleAdjacencyLikelihoods() {
    // Here, we sample the probability values associated with every
    // adjacency in A, weighted by their likelihood. The weighted
    // histogram is stored in the graph data structure, so we simply
    // need to add an observation to each node-pair that corresponds to
    // the associated branch point's probability and the dendrogram's
    // overall likelihood.

    double nn;
    double norm = ((double)(n) * (double)(n)) / 4.0;

    if (L > 0.0) {
        L = 0.0;
    }
    elementd* ancestor;
    list *currL, *prevL;
    if (paths != NULL) {
        for (int i = 0; i < n; i++) {
            currL = paths[i];
            while (currL != NULL) {
                prevL = currL;
                currL = currL->next;
                delete prevL;
                prevL = NULL;
            }
            paths[i] = NULL;
        }
        delete [] paths;
    }
    paths = NULL;
    paths = new list* [n];
    for (int i = 0; i < n; i++) {
        // construct paths from root, O(n^2) at worst
        paths[i] = reversePathToRoot(i);
    }

    // add obs for every node-pair, always O(n^2)
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // find internal node, O(n) at worst
            ancestor = findCommonAncestor(paths, i, j);
            nn = ((double)(ancestor->L->n) * (double)(ancestor->R->n)) / norm;
            // add obs of ->p to (i,j) histogram, and
            g->addAdjacencyObs(i, j, ancestor->p, nn);
            // add obs of ->p to (j,i) histogram
            g->addAdjacencyObs(j, i, ancestor->p, nn);
        }
    }

    // finish-up: upate total weight in histograms
    g->addAdjacencyEnd();

    return;
}

void dendro::resetDendrograph() {
    // Reset the dendrograph structure for the next trial
    if (leaf      != NULL) {
        delete [] leaf;        // O(n)
        leaf      = NULL;
    }
    if (internal  != NULL) {
        delete [] internal;    // O(n)
        internal  = NULL;
    }
    if (d         != NULL) {
        delete d;              // O(n)
        d         = NULL;
    }
    root = NULL;
    if (paths != NULL) {
        list *curr, *prev;
        for (int i = 0; i < n; i++) {
            curr = paths[i];
            while (curr != NULL) {
                prev = curr;
                curr = curr->next;
                delete prev;
                prev = NULL;
            }
            paths[i] = NULL;
        }
        delete [] paths;
    }
    paths = NULL;
    L = 1.0;

    return;
}

// **********************************************************************
// *** COPYRIGHT NOTICE *************************************************
// graph.h - graph data structure for hierarchical random graphs
// Copyright (C) 2005-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// **********************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu |
//                                 http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science
//                AND Santa Fe Institute
// Created      : 8 November 2005
// Modified     : 23 December 2007 (cleaned up for public consumption)
//
// ***********************************************************************
//
// Graph data structure for hierarchical random graphs. The basic
// structure is an adjacency list of edges; however, many additional
// pieces of metadata are stored as well. Each node stores its
// external name, its degree and (if assigned) its group index.
//
// ***********************************************************************

// ******** Constructor / Destructor *************************************

graph::graph(const int size, bool predict) : predict(predict)  {
    n = size;
    m = 0;
    nodes = new vert  [n];
    nodeLink = new edge* [n];
    nodeLinkTail   = new edge* [n];
    for (int i = 0; i < n; i++) {
        nodeLink[i] = NULL;
        nodeLinkTail[i] = NULL;
    }
    if (predict) {
        A = new double** [n];
        for (int i = 0; i < n; i++) {
            A[i] = new double* [n];
        }
        obs_count = 0;
        total_weight = 0.0;
        bin_resolution = 0.0;
        num_bins = 0;
    }
}

graph::~graph() {
    edge *curr, *prev;
    for (int i = 0; i < n; i++) {
        curr = nodeLink[i];
        while (curr != NULL) {
            prev = curr;
            curr = curr->next;
            delete prev;
        }
    }
    delete [] nodeLink; nodeLink = NULL;
    delete [] nodeLinkTail;  nodeLinkTail   = NULL;
    delete [] nodes; nodes = NULL;

    if (predict) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                delete [] A[i][j];
            }
            delete [] A[i];
        }
        delete [] A; A = NULL;
    }
}

// **********************************************************************

bool graph::addLink(const int i, const int j) {
    // Adds the directed edge (i,j) to the adjacency list for v_i
    edge* newedge;
    if (i >= 0 && i < n && j >= 0 && j < n) {
        newedge  = new edge;
        newedge->x = j;
        if (nodeLink[i] == NULL) {
            // first neighbor
            nodeLink[i]  = newedge;
            nodeLinkTail[i] = newedge;
            nodes[i].degree = 1;
        } else {
            // subsequent neighbor
            nodeLinkTail[i]->next = newedge;
            nodeLinkTail[i]       = newedge;
            nodes[i].degree++;
        }
        // increment edge count
        m++;
        return true;
    } else {
        return false;
    }
}

// ***********************************************************************

bool graph::addAdjacencyObs(const int i, const int j,
                            const double probability, const double size) {
    // Adds the observation obs to the histogram of the edge (i,j)
    // Note: user must manually add observation to edge (j,i) by calling
    // this function with that argument
    if (bin_resolution > 0.0 && probability >= 0.0 && probability <= 1.0
        && size >= 0.0 && size <= 1.0
        && i >= 0 && i < n && j >= 0 && j < n) {
        int index = (int)(probability / bin_resolution + 0.5);
        if (index < 0) {
            index = 0;
        } else if (index > num_bins) {
            index = num_bins;
        }

        // Add the weight to the proper probability bin
        if (A[i][j][index] < 0.5) {
            A[i][j][index] = 1.0;
        } else {
            A[i][j][index] += 1.0;
        }
        return true;
    }
    return false;
}

// **********************************************************************

void graph::addAdjacencyEnd() {
    // We need to also keep a running total of how much weight has been added
    // to the histogram, and the number of observations in the histogram.
    if (obs_count == 0) {
        total_weight  = 1.0; obs_count = 1;
    } else {
        total_weight += 1.0; obs_count++;
    }
    return;
}

bool graph::doesLinkExist(const int i, const int j) {
    // This function determines if the edge (i,j) already exists in the
    // adjacency list of v_i
    edge* curr;
    if (i >= 0 && i < n && j >= 0 && j < n) {
        curr = nodeLink[i];
        while (curr != NULL) {
            if (curr->x == j) {
                return true;
            }
            curr = curr->next;
        }
    }
    return false;
}

// **********************************************************************

int graph::getDegree(const int i) {
    if (i >= 0 && i < n) {
        return nodes[i].degree;
    } else {
        return -1;
    }
}

string graph::getName(const int i)  {
    if (i >= 0 && i < n) {
        return nodes[i].name;
    } else {
        return "";
    }
}

// NOTE: Returns address; deallocation of returned object is dangerous
edge* graph::getNeighborList(const int i) {
    if (i >= 0 && i < n) {
        return nodeLink[i];
    } else {
        return NULL;
    }
}

double* graph::getAdjacencyHist(const int i, const int j) {
    if (i >= 0 && i < n && j >= 0 && j < n) {
        return A[i][j];
    } else {
        return NULL;
    }
}

// **********************************************************************

double graph::getAdjacencyAverage(const int i, const int j) {
    double average = 0.0;
    if (i != j) {
        for (int k = 0; k < num_bins; k++) {
            if (A[i][j][k] > 0.0) {
                average += (A[i][j][k] / total_weight) * ((double)(k) * bin_resolution);
            }
        }
    }
    return average;
}

int graph::numLinks() {
    return m;
}

int graph::numNodes() {
    return n;
}

double graph::getBinResolution() {
    return bin_resolution;
}

int graph::getNumBins() {
    return num_bins;
}

double graph::getTotalWeight() {
    return total_weight;
}

// ***********************************************************************

void graph::resetAllAdjacencies() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < num_bins; k++) {
                A[i][j][k] = 0.0;
            }
        }
    }
    obs_count    = 0;
    total_weight = 0.0;
    return;
}

// **********************************************************************

void graph::resetAdjacencyHistogram(const int i, const int j) {
    if (i >= 0 && i < n && j >= 0 && j < n) {
        for (int k = 0; k < num_bins; k++) {
            A[i][j][k] = 0.0;
        }
    }
    return;
}

// **********************************************************************

void graph::resetLinks() {
    edge *curr, *prev;
    for (int i = 0; i < n; i++) {
        curr = nodeLink[i];
        while (curr != NULL) {
            prev = curr;
            curr = curr->next;
            delete prev;
        }
        nodeLink[i]     = NULL;
        nodeLinkTail[i] = NULL;
        nodes[i].degree = 0;
    }
    m = 0;
    return;
}

// **********************************************************************

void graph::setAdjacencyHistograms(const int bin_count) {
    // For all possible adjacencies, setup an edge histograms
    num_bins = bin_count + 1;
    bin_resolution = 1.0 / (double)(bin_count);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            A[i][j] = new double [num_bins];
            for (int k = 0; k < num_bins; k++) {
                A[i][j][k] = 0.0;
            }
        }
    }
    return;
}

bool graph::setName(const int i, const string text) {
    if (i >= 0 && i < n) {
        nodes[i].name = text;
        return true;
    } else {
        return false;
    }
}

// **********************************************************************

interns::interns(const int n)  {
    q         = n;
    count     = 0;
    edgelist  = new ipair  [q];
    splitlist = new string [q + 1];
    indexLUT  = new int*   [q + 1];
    for (int i = 0; i < (q + 1); i++) {
        indexLUT[i]    = new int [2];
        indexLUT[i][0] = indexLUT[i][1] = -1;
    }
}
interns::~interns() {
    delete [] edgelist;
    delete [] splitlist;
    for (int i = 0; i < (q + 1); i++) {
        delete [] indexLUT[i];
    }
    delete [] indexLUT;
}

// ***********************************************************************

// NOTE: Returns an address to another object -- do not deallocate
ipair* interns::getEdge(const int i) {
    return &edgelist[i];
}

// ***********************************************************************

// NOTE: Returns an address to another object -- do not deallocate
ipair* interns::getRandomEdge() {
    return &edgelist[(int)(floor((double)(q) * RNG_UNIF01()))];
}

// ***********************************************************************

string interns::getSplit(const int i) {
    if (i >= 0 && i <= q) {
        return splitlist[i];
    } else {
        return "";
    }
}

// **********************************************************************

bool interns::addEdge(const int new_x, const int new_y,
                      const short int new_type) {
    // This function adds a new edge (i,j,t,sp) to the list of internal
    // edges. After checking that the inputs fall in the appropriate
    // range of values, it records the new edgelist index in the
    // indexLUT and then puts the input values into that edgelist
    // location.

    if (count < q && new_x >= 0 && new_x < (q + 1) && new_y >= 0 &&
        new_y < (q + 2) && (new_type == LEFT || new_type == RIGHT)) {
        if (new_type == LEFT) {
            indexLUT[new_x][0] = count;
        } else {
            indexLUT[new_x][1] = count;
        }
        edgelist[count].x = new_x;
        edgelist[count].y = new_y;
        edgelist[count].t = new_type;
        count++;
        return true;
    } else {
        return false;
    }
}

// **********************************************************************

bool interns::replaceSplit(const int i, const string sp) {
    // When an internal edge is changed, its split must be replaced as
    // well. This function provides that access; it stores the split
    // defined by an internal edge (x,y) at the location [y], which
    // is unique.

    if (i >= 0 && i <= q) {
        splitlist[i] = sp;
        return true;
    }
    return false;
}

// ***********************************************************************

bool interns::swapEdges(const int one_x, const int one_y,
                        const short int one_type, const int two_x,
                        const int two_y, const short int two_type) {
    // The moves on the dendrogram always swap edges, either of which
    // (or both, or neither) can by internal edges. So, this function
    // mirrors that operation for the internal edgelist and indexLUT.

    int index, jndex, temp;
    bool one_isInternal = false;
    bool two_isInternal = false;

    if (one_x >= 0 && one_x < (q + 1) && two_x >= 0 && two_x < (q + 1) &&
        (two_type == LEFT || two_type == RIGHT) &&
        one_y >= 0 && one_y < (q + 2) && two_y >= 0 &&
        two_y < (q + 2) && (one_type == LEFT || one_type == RIGHT)) {

        if (one_type == LEFT) {
            temp = 0;
        } else {
            temp = 1;
        }
        if (indexLUT[one_x][temp] > -1) {
            one_isInternal = true;
        }
        if (two_type == LEFT) {
            temp = 0;
        } else {
            temp = 1;
        }
        if (indexLUT[two_x][temp] > -1) {
            two_isInternal = true;
        }

        if (one_isInternal && two_isInternal) {
            if (one_type == LEFT)  {
                index = indexLUT[one_x][0];
            } else {
                index = indexLUT[one_x][1];
            }
            if (two_type == LEFT)  {
                jndex = indexLUT[two_x][0];
            } else {
                jndex = indexLUT[two_x][1];
            }
            temp              = edgelist[index].y;
            edgelist[index].y = edgelist[jndex].y;
            edgelist[jndex].y = temp;

        } else if (one_isInternal) {
            if (one_type == LEFT)  {
                index = indexLUT[one_x][0]; indexLUT[one_x][0] = -1;
            } else {
                index = indexLUT[one_x][1]; indexLUT[one_x][1] = -1;
            }
            edgelist[index].x = two_x;
            edgelist[index].t = two_type;
            if (two_type == LEFT) {
                indexLUT[two_x][0] = index;
            } else {
                indexLUT[two_x][1] = index;
            } // add new

        } else if (two_isInternal) {
            if (two_type == LEFT)  {
                index = indexLUT[two_x][0]; indexLUT[two_x][0] = -1;
            } else {
                index = indexLUT[two_x][1]; indexLUT[two_x][1] = -1;
            }
            edgelist[index].x = one_x;
            edgelist[index].t = one_type;
            if (one_type == LEFT) {
                indexLUT[one_x][0] = index;
            } else {
                indexLUT[one_x][1] = index;
            } // add new
        } else {
            ;
        } // else neither is internal

        return true;
    } else {
        return false;
    }
}

// ******** Red-Black Tree Methods ***************************************

splittree::splittree() {
    root = new elementsp;
    leaf = new elementsp;

    leaf->parent   = root;

    root->left = leaf;
    root->right    = leaf;
    support = 0;
    total_weight = 0.0;
    total_count = 0;
}

splittree::~splittree() {
    if (root != NULL && (root->left != leaf || root->right != leaf)) {
        deleteSubTree(root); root = NULL;
    }
    support      = 0;
    total_weight = 0.0;
    total_count  = 0;
    if (root) {
        delete root;
    }
    delete leaf;
    root    = NULL;
    leaf    = NULL;
}

void splittree::deleteTree() {
    if (root != NULL) {
        deleteSubTree(root);
        root = NULL;
    }
    return;
}

void splittree::deleteSubTree(elementsp *z) {
    if (z->left  != leaf) {
        deleteSubTree(z->left);
        z->left = NULL;
    }
    if (z->right != leaf) {
        deleteSubTree(z->right);
        z->right = NULL;
    }
    delete z;
    /* No point in setting z to NULL here because z is passed by value */
    /* z = NULL; */
    return;
}

// ******** Reset Functions *********************************************

// O(n lg n)
void splittree::clearTree() {
    string *array = returnArrayOfKeys();
    for (int i = 0; i < support; i++) {
        deleteItem(array[i]);
    }
    delete [] array;
    return;
}

// ******** Search Functions *********************************************
// public search function - if there exists a elementsp in the tree
// with key=searchKey, it returns TRUE and foundNode is set to point
// to the found node; otherwise, it sets foundNode=NULL and returns
// FALSE
elementsp* splittree::findItem(const string searchKey) {

    elementsp *current = root;
    if (current->split.empty()) {
        return NULL;    // empty tree; bail out
    }
    while (current != leaf) {
        if (searchKey.compare(current->split) < 0) { // left-or-right?
            // try moving down-left
            if (current->left  != leaf) {
                current = current->left;
            } else {
                // failure; bail out
                return NULL;
            }
        } else {
            if (searchKey.compare(current->split) > 0) {
                // left-or-right?
                if (current->right != leaf) {
                    // try moving down-left
                    current = current->right;
                } else {
                    //   failure; bail out
                    return NULL;
                }
            } else {
                // found (searchKey==current->split)
                return current;
            }
        }
    }
    return NULL;
}

double splittree::returnValue(const string searchKey) {
    elementsp* test = findItem(searchKey);
    if (test == NULL) {
        return 0.0;
    } else {
        return test->weight;
    }
}


// ******** Return Item Functions ***************************************
// public function which returns the tree, via pre-order traversal, as
// a linked list

string* splittree::returnArrayOfKeys() {
    string* array;
    array = new string [support];
    bool flag_go = true;
    int index = 0;
    elementsp *curr;

    if (support == 1) {
        array[0] = root->split;
    } else if (support == 2) {
        array[0] = root->split;
        if (root->left == leaf) {
            array[1] = root->right->split;
        } else {
            array[1] = root->left->split;
        }
    } else {
        for (int i = 0; i < support; i++) {
            array[i] = -1;
        }
        // non-recursive traversal of tree structure
        curr  = root;
        curr->mark = 1;
        while (flag_go) {

            // - is it time, and is left child the leaf node?
            if (curr->mark == 1 && curr->left == leaf) {
                curr->mark = 2;
            }
            // - is it time, and is right child the leaf node?
            if (curr->mark == 2 && curr->right == leaf) {
                curr->mark = 3;
            }
            if (curr->mark == 1) {               // - go left
                curr->mark = 2;
                curr = curr->left;
                curr->mark = 1;
            } else if (curr->mark == 2) {        // - else go right
                curr->mark = 3;
                curr = curr->right;
                curr->mark = 1;
            } else {                     // - else go up a level
                curr->mark = 0;
                array[index++] = curr->split;
                curr = curr->parent;
                if (curr == NULL) {
                    flag_go = false;
                }
            }
        }
    }

    return array;
}

slist* splittree::returnListOfKeys() {
    keyValuePairSplit *curr, *prev;
    slist *head = NULL, *tail = NULL, *newlist;

    curr = returnTreeAsList();
    while (curr != NULL) {
        newlist = new slist;
        newlist->x = curr->x;
        if (head == NULL) {
            head = newlist; tail = head;
        } else {
            tail->next = newlist; tail = newlist;
        }
        prev = curr;
        curr = curr->next;
        delete prev;
        prev = NULL;
    }
    return head;
}

// pre-order traversal
keyValuePairSplit* splittree::returnTreeAsList() {
    keyValuePairSplit  *head, *tail;

    head    = new keyValuePairSplit;
    head->x = root->split;
    head->y = root->weight;
    head->c = root->count;
    tail    = head;

    if (root->left  != leaf) {
        tail = returnSubtreeAsList(root->left,  tail);
    }
    if (root->right != leaf) {
        tail = returnSubtreeAsList(root->right, tail);
    }

    if (head->x.empty()) {
        return NULL; /* empty tree */
    } else {
        return head;
    }
}

keyValuePairSplit* splittree::returnSubtreeAsList(elementsp *z,
        keyValuePairSplit *head) {
    keyValuePairSplit *newnode, *tail;

    newnode    = new keyValuePairSplit;
    newnode->x = z->split;
    newnode->y = z->weight;
    newnode->c = z->count;
    head->next = newnode;
    tail       = newnode;

    if (z->left  != leaf) {
        tail = returnSubtreeAsList(z->left,  tail);
    }
    if (z->right != leaf) {
        tail = returnSubtreeAsList(z->right, tail);
    }

    return tail;
}

keyValuePairSplit splittree::returnMaxKey() {
    keyValuePairSplit themax;
    elementsp *current;
    current = root;
    // search to bottom-right corner of tree
    while (current->right != leaf) {
        current = current->right;
    }
    themax.x = current->split;
    themax.y = current->weight;

    return themax;
}

keyValuePairSplit splittree::returnMinKey() {
    keyValuePairSplit themin;
    elementsp *current;
    current = root;
    // search to bottom-left corner of tree
    while (current->left != leaf) {
        current = current->left;
    }
    themin.x = current->split;
    themin.y = current->weight;

    return themin;
}

// private functions for deleteItem() (although these could easily be
// made public, I suppose)
elementsp* splittree::returnMinKey(elementsp *z) {
    elementsp *current;

    current = z;
    // search to bottom-right corner of tree
    while (current->left != leaf) {
        current = current->left;
    }
    // return pointer to the minimum
    return current;
}

elementsp* splittree::returnSuccessor(elementsp *z) {
    elementsp *current, *w;

    w = z;
// if right-subtree exists, return min of it
    if (w->right != leaf) {
        return returnMinKey(w->right);
    }
    // else search up in tree
    // move up in tree until find a non-right-child
    current = w->parent;
    while ((current != NULL) && (w == current->right)) {
        w = current;
        current = current->parent;
    }
    return current;
}

int splittree::returnNodecount() {
    return support;
}

keyValuePairSplit* splittree::returnTheseSplits(const int target) {
    keyValuePairSplit *head, *curr, *prev, *newhead, *newtail, *newpair;
    int count, len;

    head = returnTreeAsList();
    prev = newhead = newtail = newpair = NULL;
    curr = head;

    while (curr != NULL) {
        count = 0;
        len   = curr->x.size();
        for (int i = 0; i < len; i++) {
            if (curr->x[i] == 'M') {
                count++;
            }
        }
        if (count == target && curr->x[1] != '*') {
            newpair       = new keyValuePairSplit;
            newpair->x    = curr->x;
            newpair->y    = curr->y;
            newpair->next = NULL;
            if (newhead == NULL) {
                newhead = newpair; newtail = newpair;
            } else {
                newtail->next = newpair; newtail = newpair;
            }
        }
        prev = curr;
        curr = curr->next;
        delete prev;
        prev = NULL;
    }

    return newhead;
}

double splittree::returnTotal() {
    return total_weight;
}

// ******** Insert Functions *********************************************

void splittree::finishedThisRound() {
    // We need to also keep a running total of how much weight has been
    // added to the histogram.
    if (total_count == 0) {
        total_weight  = 1.0; total_count = 1;
    } else {
        total_weight += 1.0; total_count++;
    }
    return;
}

// public insert function
bool splittree::insertItem(string newKey, double newValue) {

    // first we check to see if newKey is already present in the tree;
    // if so, we do nothing; if not, we must find where to insert the
    // key
    elementsp *newNode, *current;

// find newKey in tree; return pointer to it O(log k)
    current = findItem(newKey);
    if (current != NULL) {
        current->weight += 1.0;
        // And finally, we keep track of how many observations went into
        // the histogram
        current->count++;
        return true;
    } else {
        newNode = new elementsp;    // elementsp for the splittree
        newNode->split = newKey;    //  store newKey
        newNode->weight = newValue; //  store newValue
        newNode->color = true;  //  new nodes are always RED
        newNode->parent = NULL; //  new node initially has no parent
        newNode->left = leaf;   //  left leaf
        newNode->right = leaf;  //  right leaf
        newNode->count = 1;
        support++;          // increment node count in splittree

        // must now search for where to insert newNode, i.e., find the
        // correct parent and set the parent and child to point to each
        // other properly
        current = root;
        if (current->split.empty()) {   // insert as root
            delete root;      //   delete old root
            root = newNode;       //   set root to newNode
            leaf->parent   = newNode; //   set leaf's parent
            current = leaf;       //   skip next loop
        }

        // search for insertion point
        while (current != leaf) {
            // left-or-right?
            if (newKey.compare(current->split) < 0) {
                // try moving down-left
                if (current->left  != leaf) {
                    current = current->left;
                } else {
                    // else found new parent
                    newNode->parent = current; // set parent
                    current->left = newNode;   // set child
                    current = leaf;        // exit search
                }
            } else { //
                if (current->right != leaf) {
                    // try moving down-right
                    current = current->right;
                } else {
                    // else found new parent
                    newNode->parent = current; // set parent
                    current->right = newNode;  // set child
                    current = leaf;        // exit search
                }
            }
        }

        // now do the house-keeping necessary to preserve the red-black
        // properties
        insertCleanup(newNode);

    }
    return true;
}

// private house-keeping function for insertion
void splittree::insertCleanup(elementsp *z) {

    // fix now if z is root
    if (z->parent == NULL) {
        z->color = false; return;
    }
    elementsp *temp;
    // while z is not root and z's parent is RED
    while (z->parent != NULL && z->parent->color) {
        if (z->parent == z->parent->parent->left) {  // z's parent is LEFT-CHILD
            temp = z->parent->parent->right;       // grab z's uncle
            if (temp->color) {
                z->parent->color = false;          // color z's parent BLACK (Case 1)
                temp->color = false;               // color z's uncle BLACK  (Case 1)
                z->parent->parent->color = true;   // color z's grandpa  RED (Case 1)
                z = z->parent->parent;             // set z = z's grandpa    (Case 1)
            } else {
                if (z == z->parent->right) {       // z is RIGHT-CHILD
                    z = z->parent;                   // set z = z's parent     (Case 2)
                    rotateLeft(z);                   // perform left-rotation  (Case 2)
                }
                z->parent->color = false;          // color z's parent BLACK (Case 3)
                z->parent->parent->color = true;   // color z's grandpa RED  (Case 3)
                rotateRight(z->parent->parent);    // perform right-rotation (Case 3)
            }
        } else {                       // z's parent is RIGHT-CHILD
            temp = z->parent->parent->left;      // grab z's uncle
            if (temp->color) {
                z->parent->color = false;          // color z's parent BLACK (Case 1)
                temp->color = false;               // color z's uncle BLACK  (Case 1)
                z->parent->parent->color = true;   // color z's grandpa RED  (Case 1)
                z = z->parent->parent;             // set z = z's grandpa    (Case 1)
            } else {
                if (z == z->parent->left) {        // z is LEFT-CHILD
                    z = z->parent;                   // set z = z's parent     (Case 2)
                    rotateRight(z);                  // perform right-rotation (Case 2)
                }
                z->parent->color = false;          // color z's parent BLACK (Case 3)
                z->parent->parent->color = true;   // color z's grandpa RED  (Case 3)
                rotateLeft(z->parent->parent);     // perform left-rotation  (Case 3)
            }
        }
    }

    root->color = false; // color the root BLACK
    return;
}

// ******** Delete Functions ********************************************
// public delete function
void splittree::deleteItem(string killKey) {
    elementsp *x, *y, *z;

    z = findItem(killKey);
    if (z == NULL) {
        return;    // item not present; bail out
    }

    if (support == 1) {   // -- attempt to delete the root
        root->split = "";       // restore root node to default state
        root->weight = 0.0;     //
        root->color = false;    //
        root->parent = NULL;    //
        root->left = leaf;      //
        root->right = leaf;     //
        support--;          // set support to zero
        total_weight = 0.0;     // set total weight to zero
        total_count--;      //
        return;         // exit - no more work to do
    }

    if (z != NULL) {
        support--;          // decrement node count
        if ((z->left == leaf) || (z->right == leaf)) {
            // case of less than two children
            y = z;             // set y to be z
        } else {
            y = returnSuccessor(z);    // set y to be z's key-successor
        }

        if (y->left != leaf) {
            x = y->left;       // pick y's one child (left-child)
        } else {
            x = y->right;              // (right-child)
        }
        x->parent = y->parent;       // make y's child's parent be y's parent

        if (y->parent == NULL) {
            root = x;          // if y is the root, x is now root
        } else {
            if (y == y->parent->left) {// decide y's relationship with y's parent
                y->parent->left  = x;    // replace x as y's parent's left child
            } else {
                y->parent->right = x;
            }  // replace x as y's parent's left child
        }

        if (y != z) {        // insert y into z's spot
            z->split = y->split;   // copy y data into z
            z->weight = y->weight;     //
            z->count = y->count;   //
        }                //

        // do house-keeping to maintain balance
        if (y->color == false) {
            deleteCleanup(x);
        }
        delete y;            // deallocate y
        y = NULL;            // point y to NULL for safety
    }              //

    return;
}

void splittree::deleteCleanup(elementsp *x) {
    elementsp *w, *t;
    // until x is the root, or x is RED
    while ((x != root) && (x->color == false)) {
        if (x == x->parent->left) {      // branch on x being a LEFT-CHILD
            w = x->parent->right;      // grab x's sibling
            if (w->color == true) {    // if x's sibling is RED
                w->color = false;        // color w BLACK                (case 1)
                x->parent->color = true;     // color x's parent RED         (case 1)
                rotateLeft(x->parent);       // left rotation on x's parent  (case 1)
                w = x->parent->right;        // make w be x's right sibling  (case 1)
            }
            if ((w->left->color == false) && (w->right->color == false)) {
                w->color = true;         // color w RED                  (case 2)
                x = x->parent;           // examine x's parent           (case 2)
            } else {               //
                if (w->right->color == false) {
                    w->left->color = false;    // color w's left child BLACK   (case 3)
                    w->color = true;       // color w RED                  (case 3)
                    t = x->parent;         // store x's parent
                    rotateRight(w);        // right rotation on w          (case 3)
                    x->parent = t;         // restore x's parent
                    w = x->parent->right;      // make w be x's right sibling  (case 3)
                } //
                w->color = x->parent->color; // w's color := x's parent's    (case 4)
                x->parent->color    = false; // color x's parent BLACK       (case 4)
                w->right->color = false;     // color w's right child BLACK  (case 4)
                rotateLeft(x->parent);       // left rotation on x's parent  (case 4)
                x = root;            // finished work. bail out      (case 4)
            }                  //
        } else {                 // x is RIGHT-CHILD
            w = x->parent->left;       // grab x's sibling
            if (w->color == true) {    // if x's sibling is RED
                w->color = false;        // color w BLACK                (case 1)
                x->parent->color    = true;  // color x's parent RED         (case 1)
                rotateRight(x->parent);      // right rotation on x's parent (case 1)
                w = x->parent->left;         // make w be x's left sibling   (case 1)
            }
            if ((w->right->color == false) && (w->left->color == false)) {
                w->color = true;         // color w RED                  (case 2)
                x = x->parent;           // examine x's parent           (case 2)
            } else { //
                if (w->left->color == false) { //
                    w->right->color = false;   // color w's right child BLACK  (case 3)
                    w->color = true;       // color w RED                  (case 3)
                    t = x->parent;         // store x's parent
                    rotateLeft(w);         // left rotation on w           (case 3)
                    x->parent = t;         // restore x's parent
                    w = x->parent->left;       // make w be x's left sibling   (case 3)
                } //
                w->color = x->parent->color; // w's color := x's parent's    (case 4)
                x->parent->color    = false; // color x's parent BLACK       (case 4)
                w->left->color = false;      // color w's left child BLACK   (case 4)
                rotateRight(x->parent);      // right rotation on x's parent (case 4)
                x = root;                    // x is now the root            (case 4)
            }
        }
    }
    x->color = false;          // color x (the root) BLACK (exit)

    return;
}

// ******** Rotation Functions *******************************************

void splittree::rotateLeft(elementsp *x) {
    elementsp *y;
    // do pointer-swapping operations for left-rotation
    y = x->right;             // grab right child
    x->right = y->left;           // make x's RIGHT-CHILD be y's LEFT-CHILD
    y->left->parent = x;          // make x be y's LEFT-CHILD's parent
    y->parent = x->parent;        // make y's new parent be x's old parent

    if (x->parent == NULL) {
        root = y;               // if x was root, make y root
    } else {              //
        if (x == x->parent->left) { // if x is LEFT-CHILD, make y be x's parent's
            x->parent->left  = y; // left-child
        } else {
            x->parent->right = y; // right-child
        }
    }
    y->left   = x;        // make x be y's LEFT-CHILD
    x->parent = y;        // make y be x's parent

    return;
}

void splittree::rotateRight(elementsp *y) {
    elementsp *x;
    // do pointer-swapping operations for right-rotation
    x = y->left;               // grab left child
    y->left = x->right;            // replace left child yith x's right subtree
    x->right->parent = y;          // replace y as x's right subtree's parent

    x->parent = y->parent;         // make x's new parent be y's old parent
    if (y->parent == NULL) {
        root = x;            // if y was root, make x root
    } else {
        if (y == y->parent->right) { // if y is R-CHILD, make x be y's parent's
            y->parent->right = x;  // right-child
        } else {
            y->parent->left = x;   // left-child
        }
    }
    x->right  = y;         // make y be x's RIGHT-CHILD
    y->parent = x;         // make x be y's parent

    return;
}

// ***********************************************************************
// *** COPYRIGHT NOTICE **************************************************
// graph_simp.h - graph data structure
// Copyright (C) 2006-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ***********************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu |
//                                 http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science
//                AND Santa Fe Institute
// Created      : 21 June 2006
// Modified     : 23 December 2007 (cleaned up for public consumption)
//
// ************************************************************************

// ******** Constructor / Destructor *************************************

simpleGraph::simpleGraph(const int size): n(size), m(0), num_groups(0) {
    nodes = new simpleVert  [n];
    nodeLink = new simpleEdge* [n];
    nodeLinkTail = new simpleEdge* [n];
    A = new double* [n];
    for (int i = 0; i < n; i++) {
        nodeLink[i] = NULL; nodeLinkTail[i] = NULL;
        A[i] = new double [n];
        for (int j = 0; j < n; j++) {
            A[i][j] = 0.0;
        }
    }
    E = NULL;
}

simpleGraph::~simpleGraph() {
    simpleEdge *curr, *prev;
    for (int i = 0; i < n; i++) {
        curr = nodeLink[i];
        delete [] A[i];
        while (curr != NULL) {
            prev = curr;
            curr = curr->next;
            delete prev;
        }
    }
    curr = NULL; prev = NULL;
    if (E != NULL) {
        delete [] E;
        E = NULL;
    }
    delete [] A; A = NULL;
    delete [] nodeLink; nodeLink = NULL;
    delete [] nodeLinkTail;  nodeLinkTail   = NULL;
    delete [] nodes; nodes = NULL;
}

// ***********************************************************************

bool simpleGraph::addGroup(const int i, const int group_index) {
    if (i >= 0 && i < n) {
        nodes[i].group_true = group_index;
        return true;
    } else {
        return false;
    }
}

// ***********************************************************************

bool simpleGraph::addLink(const int i, const int j) {
    // Adds the directed edge (i,j) to the adjacency list for v_i
    simpleEdge* newedge;
    if (i >= 0 && i < n && j >= 0 && j < n) {
        A[i][j] = 1.0;
        newedge  = new simpleEdge;
        newedge->x = j;
        if (nodeLink[i] == NULL) {  // first neighbor
            nodeLink[i]  = newedge;
            nodeLinkTail[i] = newedge;
            nodes[i].degree = 1;
        } else {            // subsequent neighbor
            nodeLinkTail[i]->next = newedge;
            nodeLinkTail[i]       = newedge;
            nodes[i].degree++;
        }
        m++;            // increment edge count
        newedge = NULL;
        return true;
    } else {
        return false;
    }
}

// ***********************************************************************

bool simpleGraph::doesLinkExist(const int i, const int j) {
    // This function determines if the edge (i,j) already exists in the
    // adjacency list of v_i
    if (i >= 0 && i < n && j >= 0 && j < n) {
        if (A[i][j] > 0.1) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

// **********************************************************************

double simpleGraph::getAdjacency(const int i, const int j) {
    if (i >= 0 && i < n && j >= 0 && j < n) {
        return A[i][j];
    } else {
        return -1.0;
    }
}

int simpleGraph::getDegree(const int i) {
    if (i >= 0 && i < n) {
        return nodes[i].degree;
    } else {
        return -1;
    }
}

int simpleGraph::getGroupLabel(const int i) {
    if (i >= 0 && i < n) {
        return nodes[i].group_true;
    } else {
        return -1;
    }
}

string simpleGraph::getName(const int i) {
    if (i >= 0 && i < n) {
        return nodes[i].name;
    } else {
        return "";
    }
}

// NOTE: The following three functions return addresses; deallocation
// of returned object is dangerous
simpleEdge* simpleGraph::getNeighborList(const int i) {
    if (i >= 0 && i < n) {
        return nodeLink[i];
    } else {
        return NULL;
    }
}
// END-NOTE

// *********************************************************************

int simpleGraph::getNumGroups() {
    return num_groups;
}
int simpleGraph::getNumLinks()  {
    return m;
}
int simpleGraph::getNumNodes()  {
    return n;
}
simpleVert* simpleGraph::getNode(const int i) {
    if (i >= 0 && i < n) {
        return &nodes[i];
    } else {
        return NULL;
    }
}

// **********************************************************************

bool simpleGraph::setName(const int i, const string text) {
    if (i >= 0 && i < n) {
        nodes[i].name = text;
        return true;
    } else {
        return false;
    }
}

// **********************************************************************

void simpleGraph::QsortMain (block* array, int left, int right) {
    if (right > left) {
        int pivot = left;
        int part  = QsortPartition(array, left, right, pivot);
        QsortMain(array, left,   part - 1);
        QsortMain(array, part + 1, right  );
    }
    return;
}

int simpleGraph::QsortPartition (block* array, int left, int right,
                                 int index) {
    block p_value, temp;
    p_value.x = array[index].x;
    p_value.y = array[index].y;

    // swap(array[p_value], array[right])
    temp.x = array[right].x;
    temp.y = array[right].y;
    array[right].x = array[index].x;
    array[right].y = array[index].y;
    array[index].x = temp.x;
    array[index].y = temp.y;

    int stored = left;
    for (int i = left; i < right; i++) {
        if (array[i].x <= p_value.x) {
            // swap(array[stored], array[i])
            temp.x = array[i].x;
            temp.y = array[i].y;
            array[i].x = array[stored].x;
            array[i].y = array[stored].y;
            array[stored].x = temp.x;
            array[stored].y = temp.y;
            stored++;
        }
    }
    // swap(array[right], array[stored])
    temp.x = array[stored].x;
    temp.y = array[stored].y;
    array[stored].x = array[right].x;
    array[stored].y = array[right].y;
    array[right].x = temp.x;
    array[right].y = temp.y;

    return stored;
}

// ***********************************************************************
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/rbtree.h0000644000175100001710000001370700000000000022665 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

// ****************************************************************************************************
// *** COPYRIGHT NOTICE *******************************************************************************
// rbtree - red-black tree (self-balancing binary tree data structure)
// Copyright (C) 2004 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ****************************************************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu | http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science AND Santa Fe Institute
// Created      : Spring 2004
// Modified     : many, many times
//
// ****************************************************************************************************

#ifndef IGRAPH_HRG_RBTREE
#define IGRAPH_HRG_RBTREE

namespace fitHRG {

// ******** Basic Structures *********************************************

#ifndef IGRAPH_HRG_LIST
#define IGRAPH_HRG_LIST

class list {
public:
    int x;            // stored elementd in linked-list
    list* next;           // pointer to next elementd
    list(): x(-1), next(0) { }
    ~list() { }
};
#endif

class keyValuePair {
public:
    int x;            // elementrb key (int)
    int y;            // stored value (int)
    keyValuePair* next;       // linked-list pointer
    keyValuePair(): x(-1), y(-1), next(0) { }
    ~keyValuePair() { }
};

// ******** Tree elementrb Class *****************************************

class elementrb {
public:
    int key;          // search key (int)
    int value;            // stored value (int)

    bool color;           // F: BLACK, T: RED
    short int mark;       // marker

    elementrb *parent;        // pointer to parent node
    elementrb *left;      // pointer for left subtree
    elementrb *right;     // pointer for right subtree

    elementrb(): key(-1), value(-1), color(false), mark(0), parent(0),
        left(0), right(0) { }
    ~elementrb() { }
};

// ******** Red-Black Tree Class *****************************************
// This vector implementation is a red-black balanced binary tree data
// structure. It provides find a stored elementrb in time O(log n),
// find the maximum elementrb in time O(1), delete an elementrb in
// time O(log n), and insert an elementrb in time O(log n).
//
// Note that the key=0 is assumed to be a special value, and thus you
// cannot insert such an item. Beware of this limitation.

class rbtree {
private:
    elementrb* root;      // binary tree root
    elementrb* leaf;      // all leaf nodes
    int support;          // number of nodes in the tree

    void rotateLeft(elementrb *x);    // left-rotation operator
    void rotateRight(elementrb *y);   // right-rotation operator
    void insertCleanup(elementrb *z); // house-keeping after insertion
    void deleteCleanup(elementrb *x); // house-keeping after deletion
    keyValuePair* returnSubtreeAsList(elementrb *z, keyValuePair *head);
    void deleteSubTree(elementrb *z); // delete subtree rooted at z
    elementrb* returnMinKey(elementrb *z); // returns minimum of subtree
    // rooted at z
    elementrb* returnSuccessor(elementrb *z); // returns successor of z's key

public:
    rbtree(); ~rbtree(); // default constructor/destructor

    // returns value associated with searchKey
    int returnValue(const int searchKey);
    // returns T if searchKey found, and points foundNode at the
    // corresponding node
    elementrb* findItem(const int searchKey);
    // insert a new key with stored value
    void insertItem(int newKey, int newValue);
    // selete a node with given key
    void deleteItem(int killKey);
    // replace value of a node with given key
    void replaceItem(int key, int newValue);
    // increment the value of the given key
    void incrementValue(int key);
    // delete the entire tree
    void deleteTree();
    // return array of keys in tree
    int* returnArrayOfKeys();
    // return list of keys in tree
    list* returnListOfKeys();
    // return the tree as a list of keyValuePairs
    keyValuePair* returnTreeAsList();
    // returns the maximum key in the tree
    keyValuePair returnMaxKey();
    // returns the minimum key in the tree
    keyValuePair returnMinKey();
    // returns number of items in tree
    int returnNodecount();
};

}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/hrg/splittree_eq.h0000644000175100001710000001545100000000000024100 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

// ****************************************************************************************************
// *** COPYRIGHT NOTICE *******************************************************************************
// splittree_eq.h - a binary search tree data structure for storing dendrogram split frequencies
// Copyright (C) 2006-2008 Aaron Clauset
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// See http://www.gnu.org/licenses/gpl.txt for more details.
//
// ****************************************************************************************************
// Author       : Aaron Clauset  ( aaronc@santafe.edu | http://www.santafe.edu/~aaronc/ )
// Collaborators: Cristopher Moore and Mark E.J. Newman
// Project      : Hierarchical Random Graphs
// Location     : University of New Mexico, Dept. of Computer Science AND Santa Fe Institute
// Created      : 19 April 2006
// Modified     : 19 May 2007
//           : 20 May 2008 (cleaned up for public consumption)
//
// ***********************************************************************
//
// Data structure for storing the split frequences in the sampled
// dendrograms. Data is stored efficiently as a red-black binary
// search tree (this is a modified version of the rbtree.h file).
//
// ***********************************************************************

#ifndef IGRAPH_HRG_SPLITTREE
#define IGRAPH_HRG_SPLITTREE

#include 

namespace fitHRG {

// ******** Basic Structures *********************************************

#ifndef IGRAPH_HRG_SLIST
#define IGRAPH_HRG_SLIST
class slist {
public:
    std::string x;         // stored elementd in linked-list
    slist* next;          // pointer to next elementd
    slist(): x(""), next(0) { }
    ~slist() { }
};
#endif

class keyValuePairSplit {
public:
    std::string x;         // elementsp split (string)
    double y;         // stored weight   (double)
    int c;            // stored count    (int)
    keyValuePairSplit* next;  // linked-list pointer
    keyValuePairSplit(): x(""), y(0.0), c(0), next(0) { }
    ~keyValuePairSplit() { }
};

// ******** Tree elementsp Class *****************************************

class elementsp {
public:
    std::string split;             // split represented as a string
    double weight;            // total weight of this split
    int count;                // number of observations of this split

    bool color;           // F: BLACK, T: RED
    short int mark;       // marker

    elementsp *parent;        // pointer to parent node
    elementsp *left;      // pointer for left subtree
    elementsp *right;     // pointer for right subtree

    elementsp(): split(""), weight(0.0), count(0), color(false), mark(0),
        parent(0), left(0), right(0) { }
    ~elementsp() { }
};

// ******** Red-Black Tree Class *****************************************
// This vector implementation is a red-black balanced binary tree data
// structure. It provides find a stored elementsp in time O(log n),
// find the maximum elementsp in time O(1), delete an elementsp in
// time O(log n), and insert an elementsp in time O(log n).
//
// Note that the split="" is assumed to be a special value, and thus
// you cannot insert such an item. Beware of this limitation.
//

class splittree {
private:
    elementsp* root;      // binary tree root
    elementsp* leaf;      // all leaf nodes
    int support;          // number of nodes in the tree
    double total_weight;      // total weight stored
    int total_count;      // total number of observations stored

    // left-rotation operator
    void rotateLeft(elementsp*);
    // right-rotation operator
    void rotateRight(elementsp*);
    // house-keeping after insertion
    void insertCleanup(elementsp*);
    // house-keeping after deletion
    void deleteCleanup(elementsp*);
    keyValuePairSplit* returnSubtreeAsList(elementsp*, keyValuePairSplit*);
    // delete subtree rooted at z
    void deleteSubTree(elementsp*);
    // returns minimum of subtree rooted at z
    elementsp* returnMinKey(elementsp*);
    // returns successor of z's key
    elementsp* returnSuccessor(elementsp*);

public:
    // default constructor/destructor
    splittree(); ~splittree();
    // returns value associated with searchKey
    double returnValue(const std::string);
    // returns T if searchKey found, and points foundNode at the
    // corresponding node
    elementsp* findItem(const std::string);
    // update total_count and total_weight
    void finishedThisRound();
    // insert a new key with stored value
    bool insertItem(std::string, double);
    void clearTree();
    // delete a node with given key
    void deleteItem(std::string);
    // delete the entire tree
    void deleteTree();
    // return array of keys in tree
    std::string* returnArrayOfKeys();
    // return list of keys in tree
    slist* returnListOfKeys();
    // return the tree as a list of keyValuePairSplits
    keyValuePairSplit* returnTreeAsList();
    // returns the maximum key in the tree
    keyValuePairSplit returnMaxKey();
    // returns the minimum key in the tree
    keyValuePairSplit returnMinKey();
    // returns number of items in tree
    int returnNodecount();
    // returns list of splits with given number of Ms
    keyValuePairSplit* returnTheseSplits(const int);
    // returns sum of stored values
    double returnTotal();
};

} // namespace fitHRG

#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5151408
igraph-0.9.9/vendor/source/igraph/src/internal/0000755000175100001710000000000000000000000022255 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/glpk_support.c0000644000175100001710000001235400000000000025157 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "internal/glpk_support.h"

#ifdef HAVE_GLPK

#include "igraph_error.h"

#include "core/interruption.h"

#include 

IGRAPH_THREAD_LOCAL igraph_i_glpk_error_info_t igraph_i_glpk_error_info;

int igraph_i_glpk_terminal_hook(void *info, const char *s) {
    IGRAPH_UNUSED(info);

    if (igraph_i_interruption_handler &&
        !igraph_i_glpk_error_info.is_interrupted &&
        igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) {
        /* If an interruption has already occurred, do not set another error,
           to avoid an infinite loop between the term_hook (this function)
           and the error_hook. */
        igraph_i_glpk_error_info.is_interrupted = 1;
        glp_error("GLPK was interrupted."); /* This dummy message is never printed */
    } else if (glp_at_error()) {
        /* Copy the error messages into a buffer for later reporting */
        /* We must use glp_at_error() instead of igraph_i_glpk_error_info.is_error
         * to determine if a message is an error message, as the reporting function is
         * called before the error function. */
        const size_t n = sizeof(igraph_i_glpk_error_info.msg) / sizeof(char) - 1;
        while (*s != '\0' && igraph_i_glpk_error_info.msg_ptr < igraph_i_glpk_error_info.msg + n) {
            *(igraph_i_glpk_error_info.msg_ptr++) = *(s++);
        }
        *igraph_i_glpk_error_info.msg_ptr = '\0';
    }

    return 1; /* Non-zero return value signals to GLPK not to print to the terminal */
}

void igraph_i_glpk_error_hook(void *info) {
    IGRAPH_UNUSED(info);
    igraph_i_glpk_error_info.is_error = 1;
    glp_free_env();
    longjmp(igraph_i_glpk_error_info.jmp, 1);
}

void igraph_i_glpk_interruption_hook(glp_tree *tree, void *info) {
    IGRAPH_UNUSED(info);

    /* This is a callback function meant to be used with glp_intopt(),
       in order to support interruption. It is essentially a GLPK-compatible
       replacement for IGRAPH_ALLOW_INTERRUPTION().
       Calling glp_ios_terminate() from glp_intopt()'s callback function
       signals to GLPK that it should terminate the optimization and return
       with the code GLP_ESTOP.
    */
    if (igraph_i_interruption_handler) {
        if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) {
            glp_ios_terminate(tree);
        }
    }
}

/**
 * \ingroup internal
 * \function igraph_i_glp_delete_prob
 * \brief Safe replacement for glp_delete_prob().
 *
 * This function is meant to be used with IGRAPH_FINALLY()
 * in conjunction with glp_create_prob().
 *
 * When using GLPK, normally glp_delete_prob() is used to free
 * problems created with glp_create_prob(). However, when GLPK
 * encounters an error, the error handler installed by igraph
 * will call glp_free_env() which invalidates all problems.
 * Calling glp_delete_prob() would then lead to a crash.
 * This replacement function avoids this situation by first
 * checking if GLPK is at an error state.
 */
void igraph_i_glp_delete_prob(glp_prob *p) {
    if (! igraph_i_glpk_error_info.is_error) {
        glp_delete_prob(p);
    }
}

int igraph_i_glpk_check(int retval, const char* message) {
    char* code = "none";
    char message_and_code[4096];

    if (retval == IGRAPH_SUCCESS) {
        return IGRAPH_SUCCESS;
    }

    /* handle errors */
#define HANDLE_CODE(c) case c: code = #c; retval = IGRAPH_##c; break;
#define HANDLE_CODE2(c) case c: code = #c; retval = IGRAPH_FAILURE; break;
#define HANDLE_CODE3(c) case c: code = #c; retval = IGRAPH_INTERRUPTED; break;
    switch (retval) {
        HANDLE_CODE(GLP_EBOUND);
        HANDLE_CODE(GLP_EROOT);
        HANDLE_CODE(GLP_ENOPFS);
        HANDLE_CODE(GLP_ENODFS);
        HANDLE_CODE(GLP_EFAIL);
        HANDLE_CODE(GLP_EMIPGAP);
        HANDLE_CODE(GLP_ETMLIM);

        HANDLE_CODE3(GLP_ESTOP);

        HANDLE_CODE2(GLP_EBADB);
        HANDLE_CODE2(GLP_ESING);
        HANDLE_CODE2(GLP_ECOND);
        HANDLE_CODE2(GLP_EOBJLL);
        HANDLE_CODE2(GLP_EOBJUL);
        HANDLE_CODE2(GLP_EITLIM);

    default:
        IGRAPH_ERROR("Unknown GLPK error", IGRAPH_FAILURE);
    }
#undef HANDLE_CODE
#undef HANDLE_CODE2
#undef HANDLE_CODE3

    sprintf(message_and_code, "%s (%s)", message, code);
    IGRAPH_ERROR(message_and_code, retval);
}

#else

int igraph_glpk_dummy() {
    /* get rid of "ISO C requires a translation unit to contain at least one
     * declaration" warning */
    return 'd' + 'u' + 'm' + 'm' + 'y';
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/glpk_support.h0000644000175100001710000001271500000000000025165 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_GLPK_SUPPORT_H
#define IGRAPH_GLPK_SUPPORT_H

#include "config.h"

/* Note: only files calling the GLPK routines directly need to
   include this header.
*/

#ifdef HAVE_GLPK

#include 
#include 

typedef struct igraph_i_glpk_error_info_s {
    jmp_buf jmp;            /* used for bailing when there is a GLPK error */
    int     is_interrupted; /* Boolean; true if there was an interruption */
    int     is_error;       /* Boolean; true if the error hook was called */
    char    msg[4096];      /* GLPK error messages are collected here */
    char   *msg_ptr;        /* Points to the end (null terminator) of msg */
} igraph_i_glpk_error_info_t;

extern IGRAPH_THREAD_LOCAL igraph_i_glpk_error_info_t igraph_i_glpk_error_info;

int igraph_i_glpk_check(int retval, const char* message);
void igraph_i_glpk_interruption_hook(glp_tree *tree, void *info);
void igraph_i_glpk_error_hook(void *info);
int igraph_i_glpk_terminal_hook(void *info, const char *s);
void igraph_i_glp_delete_prob(glp_prob *p);

#define IGRAPH_GLPK_CHECK(func, message) do { \
        int igraph_i_ret = igraph_i_glpk_check(func, message); \
        if (IGRAPH_UNLIKELY(igraph_i_ret != 0)) { \
            return igraph_i_ret; \
        } } while (0)

/**
 * \ingroup internal
 * \define IGRAPH_GLPK_SETUP
 *
 * Use this macro at the start of igraph functions that use GLPK routines
 * directly.
 *
 *  - IGRAPH_GLPK_SETUP() must be called in all top-level functions that
 *    use GLPK, before beginning to use any GLPK functions.
 *
 *  - Do NOT call glp_term_out(OFF) as interruption support relies on
 *    the terminal hook being called.
 *
 *  - This must be a macro and not a function, as jumping into a function
 *    that has already returned with longjmp() is not possible.
 *
 * This setup step is necessary in order to support interruption, as
 * well as to handle fatal GLPK errors gracefully. See here for details:
 *
 * https://lists.gnu.org/archive/html/help-glpk/2019-10/msg00000.html
 *
 * Interruption support for GLPK is essential because it is practically
 * impossible to predict how long it will take to solve a problem. It
 * may take less than a second or it may never finish in practice.
 *
 * It does the following:
 *
 *  - Initialize the data structure where we keep track of GLPK's current
 *    error and interruption state, \c igraph_i_glpk_error_info.
 *  - Set an error hook and a terminal hook for GLPK.
 *  - Provide a return point for the longjmp() called from the error hook.
 *
 * There are two interruption mechanisms we can use with GLPK. glp_intopt()
 * supports a callback function which can signal a request for interruption.
 * However, glp_intopt() internally calls glp_simplex(), which may again
 * take a very long time.
 *
 * The recommended way to interrupt glp_simplex() is to check for interruption
 * from the terminal hook, which is normally meant for intercepting output.
 * This interruption is possible only as often as there is output, which may
 * be at intervals of a few seconds in practice.
 *
 * Interruption is achieved by setting an error with glp_error(), which
 * triggers a call to the error hook. From the error hook, we free all
 * GLPK resources using glp_free_env() and do a longjmp().
 *
 * The use of these mechanisms makes it unsafe to use igraph's GLPK-reliant
 * functions from a process which also uses GLPK for other purposes.
 * To avoid this problem, GLPK should ideally be linked to igraph statically.
 */
#define IGRAPH_GLPK_SETUP() \
    do { \
        glp_error_hook(igraph_i_glpk_error_hook, NULL); \
        glp_term_hook(igraph_i_glpk_terminal_hook, NULL); \
        igraph_i_glpk_error_info.is_interrupted = 0; \
        igraph_i_glpk_error_info.is_error = 0; \
        igraph_i_glpk_error_info.msg_ptr = igraph_i_glpk_error_info.msg; \
        if (setjmp(igraph_i_glpk_error_info.jmp)) { \
            if (igraph_i_glpk_error_info.is_interrupted) { \
                return IGRAPH_INTERRUPTED; \
            } else { \
                if (igraph_i_glpk_error_info.msg_ptr != igraph_i_glpk_error_info.msg) { \
                    while ( *(igraph_i_glpk_error_info.msg_ptr - 1) == '\n' && \
                            igraph_i_glpk_error_info.msg_ptr > igraph_i_glpk_error_info.msg ) { \
                        igraph_i_glpk_error_info.msg_ptr--; \
                    } \
                    *igraph_i_glpk_error_info.msg_ptr = '\0'; \
                    igraph_error(igraph_i_glpk_error_info.msg, IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_EGLP); \
                } \
                return IGRAPH_EGLP; \
            } \
        } \
    } while (0)

#endif

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/gmp_internal.h0000644000175100001710000000164300000000000025111 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2020 The igraph development team

   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_GMP_H
#define IGRAPH_GMP_H

#include "config.h"

#ifdef INTERNAL_GMP
#include "mini-gmp/mini-gmp.h"
#else
#include 
#endif

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/hacks.c0000644000175100001710000000313700000000000023516 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "internal/hacks.h"

#include 
#include 

/* These are implementations of common C functions that may be missing from some
 * compilers; for instance, icc does not provide stpcpy so we implement it
 * here. */

/**
 * Drop-in replacement for strdup.
 * Used only in compilers that do not have strdup or _strdup
 */
char* igraph_i_strdup(const char *s) {
    size_t n = strlen(s) + 1;
    char* result = (char*)malloc(sizeof(char) * n);
    if (result) {
        memcpy(result, s, n);
    }
    return result;
}

/**
 * Drop-in replacement for stpcpy.
 * Used only in compilers that do not have stpcpy
 */
char* igraph_i_stpcpy(char* s1, const char* s2) {
    char* result = strcpy(s1, s2);
    return result + strlen(s1);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/hacks.h0000644000175100001710000000310500000000000023516 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2003-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_HACKS_INTERNAL_H
#define IGRAPH_HACKS_INTERNAL_H

#include "config.h"

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
    #define __BEGIN_DECLS extern "C" {
    #define __END_DECLS }
#else
    #define __BEGIN_DECLS /* empty */
    #define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

#ifndef HAVE_STRDUP
    #define strdup igraph_i_strdup
    char* igraph_i_strdup(const char *s);
#endif

#ifndef HAVE_STPCPY
    #define stpcpy igraph_i_stpcpy
    char* igraph_i_stpcpy(char* s1, const char* s2);
#endif

#ifndef HAVE_STRCASECMP
    #ifdef HAVE__STRICMP
        #define strcasecmp _stricmp
    #else
        #error "igraph needs strcasecmp() or _stricmp()"
    #endif
#endif

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/lsap.c0000644000175100001710000003730300000000000023366 0ustar00runnerdocker00000000000000
#include "igraph_lsap.h"
#include "igraph_error.h"

/* #include  */
#include 
#include      /* INT_MAX */
#include       /* DBL_MAX */
#include 

/* constants used for improving readability of code */

#define COVERED       1
#define UNCOVERED     0
#define ASSIGNED      1
#define UNASSIGNED    0
#define TRUE          1
#define FALSE         0

#define MARKED        1
#define UNMARKED      0

#define REDUCE        1
#define NOREDUCE      0

typedef struct {
    int        n;            /* order of problem             */
    double   **C;            /* cost matrix          */
    double   **c;            /* reduced cost matrix      */
    int       *s;            /* assignment                   */
    int       *f;            /* column i is assigned to f[i] */
    int       na;            /* number of assigned items;    */
    int     runs;            /* number of iterations     */
    double  cost;            /* minimum cost         */
    time_t rtime;            /* time                         */
} AP;

/* public interface */

/* constructors and destructor */
static AP     *ap_create_problem(double *t, int n);
/* static AP     *ap_create_problem_from_matrix(double **t, int n); */
/* static AP     *ap_read_problem(char *file); */
static void    ap_free(AP *p);

static int     ap_assignment(AP *p, int *res);
/* static int     ap_costmatrix(AP *p, double **m); */
/* static int     ap_datamatrix(AP *p, double **m); */
/* static int     ap_iterations(AP *p); */
static int     ap_hungarian(AP *p);
/* static double  ap_mincost(AP *p); */
/* static void    ap_print_solution(AP *p); */
/* static void    ap_show_data(AP *p); */
/* static int     ap_size(AP *p); */
/* static int     ap_time(AP *p); */

/* error reporting */
/* static void ap_error(char *message); */

/* private functions */
static void    preprocess(AP *p);
static void    preassign(AP *p);
static int     cover(AP *p, int *ri, int *ci);
static void    reduce(AP *p, int *ri, int *ci);

int ap_hungarian(AP *p) {
    int      n;            /* size of problem */
    int    *ri;            /* covered rows    */
    int    *ci;            /* covered columns */
    time_t start, end;     /* timer           */
    int i, j, ok;

    start = time(0);

    n = p->n;
    p->runs = 0;

    /* allocate memory */
    p->s = calloc(1 + n, sizeof(int));
    p->f = calloc(1 + n, sizeof(int));

    ri = calloc(1 + n, sizeof(int));
    ci = calloc(1 + n, sizeof(int));

    if (ri == NULL || ci == NULL || p->s == NULL || p->f == NULL) {
        IGRAPH_ERROR("ap_hungarian: could not allocate memory", IGRAPH_ENOMEM);
    }

    preprocess(p);
    preassign(p);

    while (p->na < n) {
        if (REDUCE == cover(p, ri, ci)) {
            reduce(p, ri, ci);
        }
        ++p->runs;
    }

    end = time(0);

    p->rtime = end - start;

    /* check if assignment is a permutation of (1..n) */
    for (i = 1; i <= n; i++) {
        ok = 0;
        for (j = 1; j <= n; j++)
            if (p->s[j] == i) {
                ++ok;
            }
        if (ok != 1)
            IGRAPH_ERROR("ap_hungarian: error in assignment, is not a permutation",
                         IGRAPH_EINVAL);
    }

    /* calculate cost of assignment */
    p->cost = 0;
    for (i = 1; i <= n; i++) {
        p->cost += p->C[i][p->s[i]];
    }

    /* reset result back to base-0 indexing */
    for (i = 1; i <= n; i++) {
        p->s[i - 1] = p->s[i] - 1;
    }

    /* free memory */

    free(ri);
    free(ci);

    return 0;
}

/* abbreviated interface */
int ap_assignment(AP *p, int *res) {
    int i;

    if (p->s == NULL) {
        ap_hungarian(p);
    }

    for (i = 0; i < p->n; i++) {
        res[i] = p->s[i];
    }

    return p->n;
}


/*******************************************************************/
/* constructors                                                    */
/* read data from file                                             */
/*******************************************************************/

#if 0
AP *ap_read_problem(char *file) {
    FILE *f;
    int i, j, c;
    int m, n;
    double x;
    double **t;
    int nrow, ncol;
    AP *p;

    f = fopen(file, "r");
    if (f == NULL) {
        return NULL;
    }

    t = (double **)malloc(sizeof(double*));

    m = 0;
    n = 0;

    nrow = 0;
    ncol = 0;

    while (EOF != (i = fscanf(f, "%lf", &x))) {
        if (i == 1) {
            if (n == 0) {
                t = (double **) realloc(t, (m + 1) * sizeof(double *));
                t[m] = (double *) malloc(sizeof(double));
            } else {
                t[m] = (double *) realloc(t[m], (n + 1) * sizeof(double));
            }

            t[m][n++] = x;

            ncol = (ncol < n) ? n : ncol;
            c = fgetc(f);
            if (c == '\n') {
                n = 0;
                ++m;
                nrow = (nrow < m) ? m : nrow;
            }
        }
    }
    fclose(f);

    /* prepare data */

    if (nrow != ncol) {
        /*
          fprintf(stderr,"ap_read_problem: problem not quadratic\nrows =%d, cols = %d\n",nrow,ncol);
        */
        IGRAPH_WARNINGF("ap_read_problem: problem not quadratic; rows = %d, cols = %d.", nrow, ncol);
        return NULL;
    }

    p = (AP*) malloc(sizeof(AP));
    p->n = ncol;

    p->C  = (double **) malloc((1 + nrow) * sizeof(double *));
    p->c  = (double **) malloc((1 + nrow) * sizeof(double *));
    if (p->C == NULL || p->c == NULL) {
        return NULL;
    }

    for (i = 1; i <= nrow; i++) {
        p->C[i] = (double *) calloc(ncol + 1, sizeof(double));
        p->c[i] = (double *) calloc(ncol + 1, sizeof(double));
        if (p->C[i] == NULL || p->c[i] == NULL) {
            return NULL;
        }
    }

    for (i = 1; i <= nrow; i++)
        for ( j = 1; j <= ncol; j++) {
            p->C[i][j] = t[i - 1][j - 1];
            p->c[i][j] = t[i - 1][j - 1];
        }

    for (i = 0; i < nrow; i++) {
        free(t[i]);
    }
    free(t);

    p->cost = 0;
    p->s = NULL;
    p->f = NULL;
    return p;
}
#endif

#if 0
AP     *ap_create_problem_from_matrix(double **t, int n) {
    int i, j;
    AP *p;

    p = (AP*) malloc(sizeof(AP));
    if (p == NULL) {
        return NULL;
    }

    p->n = n;

    p->C  = (double **) malloc((n + 1) * sizeof(double *));
    p->c  = (double **) malloc((n + 1) * sizeof(double *));
    if (p->C == NULL || p->c == NULL) {
        return NULL;
    }

    for (i = 1; i <= n; i++) {
        p->C[i] = (double *) calloc(n + 1, sizeof(double));
        p->c[i] = (double *) calloc(n + 1, sizeof(double));
        if (p->C[i] == NULL || p->c[i] == NULL) {
            return NULL;
        }
    }


    for (i = 1; i <= n; i++)
        for ( j = 1; j <= n; j++) {
            p->C[i][j] = t[i - 1][j - 1];
            p->c[i][j] = t[i - 1][j - 1];
        }
    p->cost = 0;
    p->s = NULL;
    p->f = NULL;
    return p;
}
#endif

/* read data from vector */
AP *ap_create_problem(double *t, int n) {
    int i, j;
    AP *p;

    p = (AP*) malloc(sizeof(AP));
    if (p == NULL) {
        return NULL;
    }

    p->n = n;

    p->C  = (double **) malloc((n + 1) * sizeof(double *));
    p->c  = (double **) malloc((n + 1) * sizeof(double *));
    if (p->C == NULL || p->c == NULL) {
        return NULL;
    }

    for (i = 1; i <= n; i++) {
        p->C[i] = (double *) calloc(n + 1, sizeof(double));
        p->c[i] = (double *) calloc(n + 1, sizeof(double));
        if (p->C[i] == NULL || p->c[i] == NULL) {
            return NULL;
        }
    }


    for (i = 1; i <= n; i++)
        for ( j = 1; j <= n; j++) {
            p->C[i][j] = t[n * (j - 1) + i - 1];
            p->c[i][j] = t[n * (j - 1) + i - 1];
        }
    p->cost = 0;
    p->s = NULL;
    p->f = NULL;
    return p;
}

/* destructor */
void ap_free(AP *p) {
    int i;

    free(p->s);
    free(p->f);

    for (i = 1; i <= p->n; i++) {
        free(p->C[i]);
        free(p->c[i]);
    }

    free(p->C);
    free(p->c);
    free(p);
}

/* set + get functions */

/*
void ap_show_data(AP *p)
{
    int i, j;

    for(i = 1; i <= p->n; i++){
    for(j = 1; j <= p->n; j++)
        printf("%6.2f ", p->c[i][j]);
    printf("\n");
    }
}

double ap_mincost(AP *p) {
    if (p->s == NULL) {
        ap_hungarian(p);
    }

    return p->cost;
}

int ap_size(AP *p) {
    return p->n;
}

int ap_time(AP *p) {
    return (int) p->rtime;
}

int ap_iterations(AP *p) {
    return p->runs;
}

void ap_print_solution(AP *p)
{
    int i;

    printf("%d itertations, %d secs.\n",p->runs, (int)p->rtime);
    printf("Min Cost: %10.4f\n",p->cost);

    for(i = 0; i < p->n; i++)
    printf("%4d",p->s[i]);
    printf("\n");
}

int ap_costmatrix(AP *p, double **m) {
    int i, j;

    for (i = 0; i < p->n; i++)
        for (j = 0; j < p->n; j++) {
            m[i][j] = p->C[i + 1][j + 1];
        }

    return p->n;
}

int ap_datamatrix(AP *p, double **m) {
    int i, j;

    for (i = 0; i < p->n; i++)
        for (j = 0; j < p->n; j++) {
            m[i][j] = p->c[i + 1][j + 1];
        }

    return p->n;
}
*/

/* error reporting */

/*
void ap_error(char *message)
{
    fprintf(stderr,"%s\n",message);
    exit(1);
}
*/

/*************************************************************/
/* these functions are used internally                       */
/* by ap_hungarian                                           */
/*************************************************************/

int cover(AP *p, int *ri, int *ci) {
    int *mr, i, r;
    int n;

    n = p->n;
    mr = calloc(1 + p->n, sizeof(int));

    /* reset cover indices */
    for (i = 1; i <= n; i++) {
        if (p->s[i] == UNASSIGNED) {
            ri[i] = UNCOVERED;
            mr[i] = MARKED;
        } else {
            ri[i] = COVERED;
        }
        ci[i] = UNCOVERED;
    }

    while (TRUE) {
        /* find marked row */
        r = 0;
        for (i = 1; i <= n; i++)
            if (mr[i] == MARKED) {
                r = i;
                break;
            }

        if (r == 0) {
            break;
        }
        for (i = 1; i <= n; i++)
            if (p->c[r][i] == 0 && ci[i] == UNCOVERED) {
                if (p->f[i]) {
                    ri[p->f[i]] = UNCOVERED;
                    mr[p->f[i]] = MARKED;
                    ci[i] = COVERED;
                } else {
                    if (p->s[r] == UNASSIGNED) {
                        ++p->na;
                    }

                    p->f[p->s[r]] = 0;
                    p->f[i] = r;
                    p->s[r] = i;

                    free(mr);
                    return NOREDUCE;
                }
            }
        mr[r] = UNMARKED;
    }
    free(mr);
    return REDUCE;
}

void reduce(AP *p, int *ri, int *ci) {
    int i, j, n;
    double min;

    n = p->n;

    /* find minimum in uncovered c-matrix */
    min = DBL_MAX;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
            if (ri[i] == UNCOVERED && ci[j] == UNCOVERED) {
                if (p->c[i][j] < min) {
                    min = p->c[i][j];
                }
            }

    /* subtract min from each uncovered element and add it to each element */
    /* which is covered twice                                              */
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++) {
            if (ri[i] == UNCOVERED && ci[j] == UNCOVERED) {
                p->c[i][j] -= min;
            }
            if (ri[i] == COVERED && ci[j] == COVERED) {
                p->c[i][j] += min;
            }
        }
}

void preassign(AP *p) {
    int i, j, min, r, c, n, count;
    int *ri, *ci, *rz, *cz;

    n = p->n;
    p->na = 0;

    /* row and column markers */
    ri = calloc(1 + n, sizeof(int));
    ci = calloc(1 + n, sizeof(int));

    /* row and column counts of zeroes */
    rz = calloc(1 + n, sizeof(int));
    cz = calloc(1 + n, sizeof(int));

    for (i = 1; i <= n; i++) {
        count = 0;
        for (j = 1; j <= n; j++)
            if (p->c[i][j] == 0) {
                ++count;
            }
        rz[i] = count;
    }

    for (i = 1; i <= n; i++) {
        count = 0;
        for (j = 1; j <= n; j++)
            if (p->c[j][i] == 0) {
                ++count;
            }
        cz[i] = count;
    }

    while (TRUE) {
        /* find unassigned row with least number of zeroes > 0 */
        min = INT_MAX;
        r = 0;
        for (i = 1; i <= n; i++)
            if (rz[i] > 0 && rz[i] < min && ri[i] == UNASSIGNED) {
                min = rz[i];
                r = i;
            }
        /* check if we are done */
        if (r == 0) {
            break;
        }

        /* find unassigned column in row r with least number of zeroes */
        c = 0;
        min = INT_MAX;
        for (i = 1; i <= n; i++)
            if (p->c[r][i] == 0 && cz[i] < min && ci[i] == UNASSIGNED) {
                min = cz[i];
                c = i;
            }

        if (c) {
            ++p->na;
            p->s[r] = c;
            p->f[c] = r;

            ri[r] = ASSIGNED;
            ci[c] = ASSIGNED;

            /* adjust zero counts */
            cz[c] = 0;
            for (i = 1; i <= n; i++)
                if (p->c[i][c] == 0) {
                    --rz[i];
                }
        }
    }

    /* free memory */
    free(ri);
    free(ci);
    free(rz);
    free(cz);
}

void preprocess(AP *p) {
    int i, j, n;
    double min;

    n = p->n;

    /* subtract column minima in each row */
    for (i = 1; i <= n; i++) {
        min = p->c[i][1];
        for (j = 2; j <= n; j++)
            if (p->c[i][j] < min) {
                min = p->c[i][j];
            }
        for (j = 1; j <= n; j++) {
            p->c[i][j] -= min;
        }
    }

    /* subtract row minima in each column */
    for (i = 1; i <= n; i++) {
        min = p->c[1][i];
        for (j = 2; j <= n; j++)
            if (p->c[j][i] < min) {
                min = p->c[j][i];
            }
        for (j = 1; j <= n; j++) {
            p->c[j][i] -= min;
        }
    }
}

/**
 * \function igraph_solve_lsap
 * \brief Solve a balanced linear assignment problem.
 *
 * This functions solves a linear assinment problem using the Hungarian
 * method. A number of tasks, an equal number of agents, and the cost
 * of each agent to perform the tasks is given. This function then
 * assigns one task to each agent in such a way that the total cost is
 * minimized.
 *
 * 
 * If the cost should be maximized instead of minimized, the cost matrix
 * should be negated.
 *
 * 
 * To solve an unbalanced assignment problem, where the number of agents
 * is greater than the number of tasks, an extra task with zero cost
 * should be added.
 *
 * \param c The assignment problem, where the number of rows is the
 *          number of agents, the number of columns is the number of
 *          tasks, and each element is the cost of an agent to perform
 *          the task.
 * \param n The number of rows and columns of \p c.
 * \param p An initialized vector which will store the result. The nth
 *          entry gives the task the nth agent is assigned to minimize
 *          the total cost.
 * \return Error code.
 *
 * Time complexity: O(n^3), where n is the number of agents.
 */
int igraph_solve_lsap(igraph_matrix_t *c, igraph_integer_t n,
                      igraph_vector_int_t *p) {
    AP *ap;

    if(n != igraph_matrix_nrow(c)) {
        IGRAPH_ERRORF("n (%" IGRAPH_PRId ") "
                      "not equal to number of agents (%ld).", IGRAPH_EINVAL,
                      n, igraph_matrix_nrow(c));
    }
    if(n != igraph_matrix_ncol(c)) {
        IGRAPH_ERRORF("n (%" IGRAPH_PRId ") "
                      "not equal to number of tasks (%ld).", IGRAPH_EINVAL,
                      n, igraph_matrix_ncol(c));
    }
    IGRAPH_CHECK(igraph_vector_int_resize(p, n));
    igraph_vector_int_null(p);

    ap = ap_create_problem(&MATRIX(*c, 0, 0), n);
    ap_hungarian(ap);
    ap_assignment(ap, VECTOR(*p));
    ap_free(ap);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/pstdint.h0000644000175100001710000007244200000000000024124 0ustar00runnerdocker00000000000000/*  A portable stdint.h
 ****************************************************************************
 *  BSD License:
 ****************************************************************************
 *
 *  Copyright (c) 2005-2007 Paul Hsieh
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************
 *
 *  Version 0.1.11
 *
 *  The ANSI C standard committee, for the C99 standard, specified the
 *  inclusion of a new standard include file called stdint.h.  This is
 *  a very useful and long desired include file which contains several
 *  very precise definitions for integer scalar types that is
 *  critically important for making portable several classes of
 *  applications including cryptography, hashing, variable length
 *  integer libraries and so on.  But for most developers its likely
 *  useful just for programming sanity.
 *
 *  The problem is that most compiler vendors have decided not to
 *  implement the C99 standard, and the next C++ language standard
 *  (which has a lot more mindshare these days) will be a long time in
 *  coming and its unknown whether or not it will include stdint.h or
 *  how much adoption it will have.  Either way, it will be a long time
 *  before all compilers come with a stdint.h and it also does nothing
 *  for the extremely large number of compilers available today which
 *  do not include this file, or anything comparable to it.
 *
 *  So that's what this file is all about.  Its an attempt to build a
 *  single universal include file that works on as many platforms as
 *  possible to deliver what stdint.h is supposed to.  A few things
 *  that should be noted about this file:
 *
 *    1) It is not guaranteed to be portable and/or present an identical
 *       interface on all platforms.  The extreme variability of the
 *       ANSI C standard makes this an impossibility right from the
 *       very get go. Its really only meant to be useful for the vast
 *       majority of platforms that possess the capability of
 *       implementing usefully and precisely defined, standard sized
 *       integer scalars.  Systems which are not intrinsically 2s
 *       complement may produce invalid constants.
 *
 *    2) There is an unavoidable use of non-reserved symbols.
 *
 *    3) Other standard include files are invoked.
 *
 *    4) This file may come in conflict with future platforms that do
 *       include stdint.h.  The hope is that one or the other can be
 *       used with no real difference.
 *
 *    5) In the current verison, if your platform can't represent
 *       int32_t, int16_t and int8_t, it just dumps out with a compiler
 *       error.
 *
 *    6) 64 bit integers may or may not be defined.  Test for their
 *       presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX.
 *       Note that this is different from the C99 specification which
 *       requires the existence of 64 bit support in the compiler.  If
 *       this is not defined for your platform, yet it is capable of
 *       dealing with 64 bits then it is because this file has not yet
 *       been extended to cover all of your system's capabilities.
 *
 *    7) (u)intptr_t may or may not be defined.  Test for its presence
 *       with the test: #ifdef PTRDIFF_MAX.  If this is not defined
 *       for your platform, then it is because this file has not yet
 *       been extended to cover all of your system's capabilities, not
 *       because its optional.
 *
 *    8) The following might not been defined even if your platform is
 *       capable of defining it:
 *
 *       WCHAR_MIN
 *       WCHAR_MAX
 *       (u)int64_t
 *       PTRDIFF_MIN
 *       PTRDIFF_MAX
 *       (u)intptr_t
 *
 *    9) The following have not been defined:
 *
 *       WINT_MIN
 *       WINT_MAX
 *
 *   10) The criteria for defining (u)int_least(*)_t isn't clear,
 *       except for systems which don't have a type that precisely
 *       defined 8, 16, or 32 bit types (which this include file does
 *       not support anyways). Default definitions have been given.
 *
 *   11) The criteria for defining (u)int_fast(*)_t isn't something I
 *       would trust to any particular compiler vendor or the ANSI C
 *       committee.  It is well known that "compatible systems" are
 *       commonly created that have very different performance
 *       characteristics from the systems they are compatible with,
 *       especially those whose vendors make both the compiler and the
 *       system.  Default definitions have been given, but its strongly
 *       recommended that users never use these definitions for any
 *       reason (they do *NOT* deliver any serious guarantee of
 *       improved performance -- not in this file, nor any vendor's
 *       stdint.h).
 *
 *   12) The following macros:
 *
 *       PRINTF_INTMAX_MODIFIER
 *       PRINTF_INT64_MODIFIER
 *       PRINTF_INT32_MODIFIER
 *       PRINTF_INT16_MODIFIER
 *       PRINTF_LEAST64_MODIFIER
 *       PRINTF_LEAST32_MODIFIER
 *       PRINTF_LEAST16_MODIFIER
 *       PRINTF_INTPTR_MODIFIER
 *
 *       are strings which have been defined as the modifiers required
 *       for the "d", "u" and "x" printf formats to correctly output
 *       (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t,
 *       (u)least32_t, (u)least16_t and (u)intptr_t types respectively.
 *       PRINTF_INTPTR_MODIFIER is not defined for some systems which
 *       provide their own stdint.h.  PRINTF_INT64_MODIFIER is not
 *       defined if INT64_MAX is not defined.  These are an extension
 *       beyond what C99 specifies must be in stdint.h.
 *
 *       In addition, the following macros are defined:
 *
 *       PRINTF_INTMAX_HEX_WIDTH
 *       PRINTF_INT64_HEX_WIDTH
 *       PRINTF_INT32_HEX_WIDTH
 *       PRINTF_INT16_HEX_WIDTH
 *       PRINTF_INT8_HEX_WIDTH
 *       PRINTF_INTMAX_DEC_WIDTH
 *       PRINTF_INT64_DEC_WIDTH
 *       PRINTF_INT32_DEC_WIDTH
 *       PRINTF_INT16_DEC_WIDTH
 *       PRINTF_INT8_DEC_WIDTH
 *
 *       Which specifies the maximum number of characters required to
 *       print the number of that type in either hexadecimal or decimal.
 *       These are an extension beyond what C99 specifies must be in
 *       stdint.h.
 *
 *  Compilers tested (all with 0 warnings at their highest respective
 *  settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32
 *  bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio
 *  .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3
 *
 *  This file should be considered a work in progress.  Suggestions for
 *  improvements, especially those which increase coverage are strongly
 *  encouraged.
 *
 *  Acknowledgements
 *
 *  The following people have made significant contributions to the
 *  development and testing of this file:
 *
 *  Chris Howie
 *  John Steele Scott
 *  Dave Thorup
 *
 */

#include 
#include 
#include 

/*
 *  For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and
 *  do nothing else.  On the Mac OS X version of gcc this is _STDINT_H_.
 */

#if ((defined(__STDC__) && __STDC__ && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (defined(_STDINT_H) || defined(_STDINT_H_)) )) && !defined (_PSTDINT_H_INCLUDED)
    #include 
    #define _PSTDINT_H_INCLUDED
    #ifndef PRINTF_INT64_MODIFIER
        #define PRINTF_INT64_MODIFIER "ll"
    #endif
    #ifndef PRINTF_INT32_MODIFIER
        #define PRINTF_INT32_MODIFIER "l"
    #endif
    #ifndef PRINTF_INT16_MODIFIER
        #define PRINTF_INT16_MODIFIER "h"
    #endif
    #ifndef PRINTF_INTMAX_MODIFIER
        #define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
    #endif
    #ifndef PRINTF_INT64_HEX_WIDTH
        #define PRINTF_INT64_HEX_WIDTH "16"
    #endif
    #ifndef PRINTF_INT32_HEX_WIDTH
        #define PRINTF_INT32_HEX_WIDTH "8"
    #endif
    #ifndef PRINTF_INT16_HEX_WIDTH
        #define PRINTF_INT16_HEX_WIDTH "4"
    #endif
    #ifndef PRINTF_INT8_HEX_WIDTH
        #define PRINTF_INT8_HEX_WIDTH "2"
    #endif
    #ifndef PRINTF_INT64_DEC_WIDTH
        #define PRINTF_INT64_DEC_WIDTH "20"
    #endif
    #ifndef PRINTF_INT32_DEC_WIDTH
        #define PRINTF_INT32_DEC_WIDTH "10"
    #endif
    #ifndef PRINTF_INT16_DEC_WIDTH
        #define PRINTF_INT16_DEC_WIDTH "5"
    #endif
    #ifndef PRINTF_INT8_DEC_WIDTH
        #define PRINTF_INT8_DEC_WIDTH "3"
    #endif
    #ifndef PRINTF_INTMAX_HEX_WIDTH
        #define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
    #endif
    #ifndef PRINTF_INTMAX_DEC_WIDTH
        #define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
    #endif

    /*
    *  Something really weird is going on with Open Watcom.  Just pull some of
    *  these duplicated definitions from Open Watcom's stdint.h file for now.
    */

    #if defined (__WATCOMC__) && __WATCOMC__ >= 1250
        #if !defined (INT64_C)
            #define INT64_C(x)   (x + (INT64_MAX - INT64_MAX))
        #endif
        #if !defined (UINT64_C)
            #define UINT64_C(x)  (x + (UINT64_MAX - UINT64_MAX))
        #endif
        #if !defined (INT32_C)
            #define INT32_C(x)   (x + (INT32_MAX - INT32_MAX))
        #endif
        #if !defined (UINT32_C)
            #define UINT32_C(x)  (x + (UINT32_MAX - UINT32_MAX))
        #endif
        #if !defined (INT16_C)
            #define INT16_C(x)   (x)
        #endif
        #if !defined (UINT16_C)
            #define UINT16_C(x)  (x)
        #endif
        #if !defined (INT8_C)
            #define INT8_C(x)   (x)
        #endif
        #if !defined (UINT8_C)
            #define UINT8_C(x)  (x)
        #endif
        #if !defined (UINT64_MAX)
            #define UINT64_MAX  18446744073709551615ULL
        #endif
        #if !defined (INT64_MAX)
            #define INT64_MAX  9223372036854775807LL
        #endif
        #if !defined (UINT32_MAX)
            #define UINT32_MAX  4294967295UL
        #endif
        #if !defined (INT32_MAX)
            #define INT32_MAX  2147483647L
        #endif
        #if !defined (INTMAX_MAX)
            #define INTMAX_MAX INT64_MAX
        #endif
        #if !defined (INTMAX_MIN)
            #define INTMAX_MIN INT64_MIN
        #endif
    #endif
#endif

#ifndef _PSTDINT_H_INCLUDED
    #define _PSTDINT_H_INCLUDED

    #ifndef SIZE_MAX
        #define SIZE_MAX (~(size_t)0)
    #endif

    /*
    *  Deduce the type assignments from limits.h under the assumption that
    *  integer sizes in bits are powers of 2, and follow the ANSI
    *  definitions.
    */

    #ifndef UINT8_MAX
        #define UINT8_MAX 0xff
    #endif
    #ifndef uint8_t
        #if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S)
            typedef unsigned char uint8_t;
            #define UINT8_C(v) ((uint8_t) v)
        #else
            #   error "Platform not supported"
        #endif
    #endif

    #ifndef INT8_MAX
        #define INT8_MAX 0x7f
    #endif
    #ifndef INT8_MIN
        #define INT8_MIN INT8_C(0x80)
    #endif
    #ifndef int8_t
        #if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S)
            typedef signed char int8_t;
            #define INT8_C(v) ((int8_t) v)
        #else
            #   error "Platform not supported"
        #endif
    #endif

    #ifndef UINT16_MAX
        #define UINT16_MAX 0xffff
    #endif
    #ifndef uint16_t
        #if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S)
            typedef unsigned int uint16_t;
            #ifndef PRINTF_INT16_MODIFIER
                #define PRINTF_INT16_MODIFIER ""
            #endif
            #define UINT16_C(v) ((uint16_t) (v))
        #elif (USHRT_MAX == UINT16_MAX)
            typedef unsigned short uint16_t;
            #define UINT16_C(v) ((uint16_t) (v))
            #ifndef PRINTF_INT16_MODIFIER
                #define PRINTF_INT16_MODIFIER "h"
            #endif
        #else
            #error "Platform not supported"
        #endif
    #endif

    #ifndef INT16_MAX
        #define INT16_MAX 0x7fff
    #endif
    #ifndef INT16_MIN
        #define INT16_MIN INT16_C(0x8000)
    #endif
    #ifndef int16_t
        #if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S)
            typedef signed int int16_t;
            #define INT16_C(v) ((int16_t) (v))
            #ifndef PRINTF_INT16_MODIFIER
                #define PRINTF_INT16_MODIFIER ""
            #endif
        #elif (SHRT_MAX == INT16_MAX)
            typedef signed short int16_t;
            #define INT16_C(v) ((int16_t) (v))
            #ifndef PRINTF_INT16_MODIFIER
                #define PRINTF_INT16_MODIFIER "h"
            #endif
        #else
            #error "Platform not supported"
        #endif
    #endif

    #ifndef UINT32_MAX
        #define UINT32_MAX (0xffffffffUL)
    #endif
    #ifndef uint32_t
        #if (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S)
            typedef unsigned long uint32_t;
            #define UINT32_C(v) v ## UL
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER "l"
            #endif
        #elif (UINT_MAX == UINT32_MAX)
            typedef unsigned int uint32_t;
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER ""
            #endif
            #define UINT32_C(v) v ## U
        #elif (USHRT_MAX == UINT32_MAX)
            typedef unsigned short uint32_t;
            #define UINT32_C(v) ((unsigned short) (v))
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER ""
            #endif
        #else
            #error "Platform not supported"
        #endif
    #endif

    #ifndef INT32_MAX
        #define INT32_MAX (0x7fffffffL)
    #endif
    #ifndef INT32_MIN
        #define INT32_MIN INT32_C(0x80000000)
    #endif
    #ifndef int32_t
        #if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S)
            typedef signed long int32_t;
            #define INT32_C(v) v ## L
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER "l"
            #endif
        #elif (INT_MAX == INT32_MAX)
            typedef signed int int32_t;
            #define INT32_C(v) v
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER ""
            #endif
        #elif (SHRT_MAX == INT32_MAX)
            typedef signed short int32_t;
            #define INT32_C(v) ((short) (v))
            #ifndef PRINTF_INT32_MODIFIER
                #define PRINTF_INT32_MODIFIER ""
            #endif
        #else
            #error "Platform not supported"
        #endif
    #endif

    /*
    *  The macro stdint_int64_defined is temporarily used to record
    *  whether or not 64 integer support is available.  It must be
    *  defined for any 64 integer extensions for new platforms that are
    *  added.
    */

    #undef stdint_int64_defined
    #if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S)
        #if (__STDC__ && __STDC_VERSION >= 199901L) || defined (S_SPLINT_S)
            #define stdint_int64_defined
            typedef long long int64_t;
            typedef unsigned long long uint64_t;
            #define UINT64_C(v) v ## ULL
            #define  INT64_C(v) v ## LL
            #ifndef PRINTF_INT64_MODIFIER
                #define PRINTF_INT64_MODIFIER "ll"
            #endif
        #endif
    #endif

    #if !defined (stdint_int64_defined)
        #if defined(__GNUC__)
            #define stdint_int64_defined
            __extension__ typedef long long int64_t;
            __extension__ typedef unsigned long long uint64_t;
            #define UINT64_C(v) v ## ULL
            #define  INT64_C(v) v ## LL
            #ifndef PRINTF_INT64_MODIFIER
                #define PRINTF_INT64_MODIFIER "ll"
            #endif
        #elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S)
            #define stdint_int64_defined
            typedef long long int64_t;
            typedef unsigned long long uint64_t;
            #define UINT64_C(v) v ## ULL
            #define  INT64_C(v) v ## LL
            #ifndef PRINTF_INT64_MODIFIER
                #define PRINTF_INT64_MODIFIER "ll"
            #endif
        #elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC)
            #define stdint_int64_defined
            typedef __int64 int64_t;
            typedef unsigned __int64 uint64_t;
            #define UINT64_C(v) v ## UI64
            #define  INT64_C(v) v ## I64
            #ifndef PRINTF_INT64_MODIFIER
                #define PRINTF_INT64_MODIFIER "I64"
            #endif
        #endif
    #endif

    #if !defined (LONG_LONG_MAX) && defined (INT64_C)
        #define LONG_LONG_MAX INT64_C (9223372036854775807)
    #endif
    #ifndef ULONG_LONG_MAX
        #define ULONG_LONG_MAX UINT64_C (18446744073709551615)
    #endif

    #if !defined (INT64_MAX) && defined (INT64_C)
        #define INT64_MAX INT64_C (9223372036854775807)
    #endif
    #if !defined (INT64_MIN) && defined (INT64_C)
        #define INT64_MIN INT64_C (-9223372036854775808)
    #endif
    #if !defined (UINT64_MAX) && defined (INT64_C)
        #define UINT64_MAX UINT64_C (18446744073709551615)
    #endif

    /*
    *  Width of hexadecimal for number field.
    */

    #ifndef PRINTF_INT64_HEX_WIDTH
        #define PRINTF_INT64_HEX_WIDTH "16"
    #endif
    #ifndef PRINTF_INT32_HEX_WIDTH
        #define PRINTF_INT32_HEX_WIDTH "8"
    #endif
    #ifndef PRINTF_INT16_HEX_WIDTH
        #define PRINTF_INT16_HEX_WIDTH "4"
    #endif
    #ifndef PRINTF_INT8_HEX_WIDTH
        #define PRINTF_INT8_HEX_WIDTH "2"
    #endif

    #ifndef PRINTF_INT64_DEC_WIDTH
        #define PRINTF_INT64_DEC_WIDTH "20"
    #endif
    #ifndef PRINTF_INT32_DEC_WIDTH
        #define PRINTF_INT32_DEC_WIDTH "10"
    #endif
    #ifndef PRINTF_INT16_DEC_WIDTH
        #define PRINTF_INT16_DEC_WIDTH "5"
    #endif
    #ifndef PRINTF_INT8_DEC_WIDTH
        #define PRINTF_INT8_DEC_WIDTH "3"
    #endif

    /*
    *  Ok, lets not worry about 128 bit integers for now.  Moore's law says
    *  we don't need to worry about that until about 2040 at which point
    *  we'll have bigger things to worry about.
    */

    #ifdef stdint_int64_defined
        typedef int64_t intmax_t;
        typedef uint64_t uintmax_t;
        #define  INTMAX_MAX   INT64_MAX
        #define  INTMAX_MIN   INT64_MIN
        #define UINTMAX_MAX  UINT64_MAX
        #define UINTMAX_C(v) UINT64_C(v)
        #define  INTMAX_C(v)  INT64_C(v)
        #ifndef PRINTF_INTMAX_MODIFIER
            #define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
        #endif
        #ifndef PRINTF_INTMAX_HEX_WIDTH
            #define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
        #endif
        #ifndef PRINTF_INTMAX_DEC_WIDTH
            #define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
        #endif
    #else
        typedef int32_t intmax_t;
        typedef uint32_t uintmax_t;
        #define  INTMAX_MAX   INT32_MAX
        #define UINTMAX_MAX  UINT32_MAX
        #define UINTMAX_C(v) UINT32_C(v)
        #define  INTMAX_C(v)  INT32_C(v)
        #ifndef PRINTF_INTMAX_MODIFIER
            #define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER
        #endif
        #ifndef PRINTF_INTMAX_HEX_WIDTH
            #define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH
        #endif
        #ifndef PRINTF_INTMAX_DEC_WIDTH
            #define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH
        #endif
    #endif

    /*
    *  Because this file currently only supports platforms which have
    *  precise powers of 2 as bit sizes for the default integers, the
    *  least definitions are all trivial.  Its possible that a future
    *  version of this file could have different definitions.
    */

    #ifndef stdint_least_defined
        typedef   int8_t   int_least8_t;
        typedef  uint8_t  uint_least8_t;
        typedef  int16_t  int_least16_t;
        typedef uint16_t uint_least16_t;
        typedef  int32_t  int_least32_t;
        typedef uint32_t uint_least32_t;
        #define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER
        #define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER
        #define  UINT_LEAST8_MAX  UINT8_MAX
        #define   INT_LEAST8_MAX   INT8_MAX
        #define UINT_LEAST16_MAX UINT16_MAX
        #define  INT_LEAST16_MAX  INT16_MAX
        #define UINT_LEAST32_MAX UINT32_MAX
        #define  INT_LEAST32_MAX  INT32_MAX
        #define   INT_LEAST8_MIN   INT8_MIN
        #define  INT_LEAST16_MIN  INT16_MIN
        #define  INT_LEAST32_MIN  INT32_MIN
        #ifdef stdint_int64_defined
            typedef  int64_t  int_least64_t;
            typedef uint64_t uint_least64_t;
            #define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER
            #define UINT_LEAST64_MAX UINT64_MAX
            #define  INT_LEAST64_MAX  INT64_MAX
            #define  INT_LEAST64_MIN  INT64_MIN
        #endif
    #endif
    #undef stdint_least_defined

    /*
    *  The ANSI C committee pretending to know or specify anything about
    *  performance is the epitome of misguided arrogance.  The mandate of
    *  this file is to *ONLY* ever support that absolute minimum
    *  definition of the fast integer types, for compatibility purposes.
    *  No extensions, and no attempt to suggest what may or may not be a
    *  faster integer type will ever be made in this file.  Developers are
    *  warned to stay away from these types when using this or any other
    *  stdint.h.
    */

    typedef   int_least8_t   int_fast8_t;
    typedef  uint_least8_t  uint_fast8_t;
    typedef  int_least16_t  int_fast16_t;
    typedef uint_least16_t uint_fast16_t;
    typedef  int_least32_t  int_fast32_t;
    typedef uint_least32_t uint_fast32_t;
    #define  UINT_FAST8_MAX  UINT_LEAST8_MAX
    #define   INT_FAST8_MAX   INT_LEAST8_MAX
    #define UINT_FAST16_MAX UINT_LEAST16_MAX
    #define  INT_FAST16_MAX  INT_LEAST16_MAX
    #define UINT_FAST32_MAX UINT_LEAST32_MAX
    #define  INT_FAST32_MAX  INT_LEAST32_MAX
    #define   INT_FAST8_MIN   INT_LEAST8_MIN
    #define  INT_FAST16_MIN  INT_LEAST16_MIN
    #define  INT_FAST32_MIN  INT_LEAST32_MIN
    #ifdef stdint_int64_defined
        typedef  int_least64_t  int_fast64_t;
        typedef uint_least64_t uint_fast64_t;
        #define UINT_FAST64_MAX UINT_LEAST64_MAX
        #define  INT_FAST64_MAX  INT_LEAST64_MAX
        #define  INT_FAST64_MIN  INT_LEAST64_MIN
    #endif

    #undef stdint_int64_defined

    /*
    *  Whatever piecemeal, per compiler thing we can do about the wchar_t
    *  type limits.
    */

    #if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__)
        #include 
        #ifndef WCHAR_MIN
            #define WCHAR_MIN 0
        #endif
        #ifndef WCHAR_MAX
            #define WCHAR_MAX ((wchar_t)-1)
        #endif
    #endif

    /*
    *  Whatever piecemeal, per compiler/platform thing we can do about the
    *  (u)intptr_t types and limits.
    */

    #if defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED)
        #define STDINT_H_UINTPTR_T_DEFINED
    #endif

    #ifndef STDINT_H_UINTPTR_T_DEFINED
        #if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64)
            #define stdint_intptr_bits 64
        #elif defined (__WATCOMC__) || defined (__TURBOC__)
            #if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
                #define stdint_intptr_bits 16
            #else
                #define stdint_intptr_bits 32
            #endif
        #elif defined (__i386__) || defined (_WIN32) || defined (WIN32)
            #define stdint_intptr_bits 32
        #elif defined (__INTEL_COMPILER)
            /* TODO -- what will Intel do about x86-64? */
        #endif

        #ifdef stdint_intptr_bits
            #define stdint_intptr_glue3_i(a,b,c)  a##b##c
            #define stdint_intptr_glue3(a,b,c)    stdint_intptr_glue3_i(a,b,c)
            #ifndef PRINTF_INTPTR_MODIFIER
                #define PRINTF_INTPTR_MODIFIER      stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER)
            #endif
            #ifndef PTRDIFF_MAX
                #define PTRDIFF_MAX                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
            #endif
            #ifndef PTRDIFF_MIN
                #define PTRDIFF_MIN                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
            #endif
            #ifndef UINTPTR_MAX
                #define UINTPTR_MAX                 stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX)
            #endif
            #ifndef INTPTR_MAX
                #define INTPTR_MAX                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
            #endif
            #ifndef INTPTR_MIN
                #define INTPTR_MIN                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
            #endif
            #ifndef INTPTR_C
                #define INTPTR_C(x)                 stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x)
            #endif
            #ifndef UINTPTR_C
                #define UINTPTR_C(x)                stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x)
            #endif
            typedef stdint_intptr_glue3(uint, stdint_intptr_bits, _t) uintptr_t;
            typedef stdint_intptr_glue3( int, stdint_intptr_bits, _t)  intptr_t;
        #else
            /* TODO -- This following is likely wrong for some platforms, and does
            nothing for the definition of uintptr_t. */
            typedef ptrdiff_t intptr_t;
        #endif
        #define STDINT_H_UINTPTR_T_DEFINED
    #endif

    /*
    *  Assumes sig_atomic_t is signed and we have a 2s complement machine.
    */

    #ifndef SIG_ATOMIC_MAX
        #define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1)
    #endif

#endif

#if defined (__TEST_PSTDINT_FOR_CORRECTNESS)

/*
 *  Please compile with the maximum warning settings to make sure macros are not
 *  defined more than once.
 */

#include 
#include 
#include 

#define glue3_aux(x,y,z) x ## y ## z
#define glue3(x,y,z) glue3_aux(x,y,z)

#define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,=) glue3(UINT,bits,_C) (0);
#define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,=) glue3(INT,bits,_C) (0);

#define DECL(us,bits) glue3(DECL,us,) (bits)

#define TESTUMAX(bits) glue3(u,bits,=) glue3(~,u,bits); if (glue3(UINT,bits,_MAX) glue3(!=,u,bits)) printf ("Something wrong with UINT%d_MAX\n", bits)

int main () {
    DECL(I, 8)
    DECL(U, 8)
    DECL(I, 16)
    DECL(U, 16)
    DECL(I, 32)
    DECL(U, 32)
#ifdef INT64_MAX
    DECL(I, 64)
    DECL(U, 64)
#endif
    intmax_t imax = INTMAX_C(0);
    uintmax_t umax = UINTMAX_C(0);
    char str0[256], str1[256];

    sprintf (str0, "%d %x\n", 0, ~0);

    sprintf (str1, "%d %x\n",  i8, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with i8 : %s\n", str1);
    }
    sprintf (str1, "%u %x\n",  u8, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with u8 : %s\n", str1);
    }
    sprintf (str1, "%d %x\n",  i16, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with i16 : %s\n", str1);
    }
    sprintf (str1, "%u %x\n",  u16, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with u16 : %s\n", str1);
    }
    sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n",  i32, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with i32 : %s\n", str1);
    }
    sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n",  u32, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with u32 : %s\n", str1);
    }
#ifdef INT64_MAX
    sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n",  i64, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with i64 : %s\n", str1);
    }
#endif
    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n",  imax, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with imax : %s\n", str1);
    }
    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n",  umax, ~0);
    if (0 != strcmp (str0, str1)) {
        printf ("Something wrong with umax : %s\n", str1);
    }

    TESTUMAX(8);
    TESTUMAX(16);
    TESTUMAX(32);
#ifdef INT64_MAX
    TESTUMAX(64);
#endif

    return EXIT_SUCCESS;
}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/qsort.c0000644000175100001710000001573500000000000023604 0ustar00runnerdocker00000000000000/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/* This file originates from the following URL:
 *
 * https://cgit.freebsd.org/src/commit/lib/libc/stdlib/qsort.c?id=7f8f79a5c444a565a32b0c6578b07f8d496f6c49
 *
 * Create a diff against the revision given above to see what we have changed
 * to facilitate inclusion into igraph
 */

#include "igraph_qsort.h"

#ifdef _MSC_VER
    /* MSVC does not have inline when compiling C source files */
    #define inline __inline
    #define __unused
#endif

#ifndef __unused
  #define __unused    __attribute__ ((unused))
#endif

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)qsort.c	8.1 (Berkeley) 6/4/93";
#endif /* LIBC_SCCS and not lint */

#include 

#if defined(I_AM_QSORT_R)
typedef int		 cmp_t(void *, const void *, const void *);
#elif defined(I_AM_QSORT_S)
typedef int		 cmp_t(const void *, const void *, void *);
#else
typedef int		 cmp_t(const void *, const void *);
#endif
static inline char	*med3(char *, char *, char *, cmp_t *, void *);

#define	MIN(a, b)	((a) < (b) ? a : b)

/*
 * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
 */

static inline void
swapfunc(char *a, char *b, size_t es)
{
	char t;

	do {
		t = *a;
		*a++ = *b;
		*b++ = t;
	} while (--es > 0);
}

#define	vecswap(a, b, n)				\
	if ((n) > 0) swapfunc(a, b, n)

#if defined(I_AM_QSORT_R)
#define	CMP(t, x, y) (cmp((t), (x), (y)))
#elif defined(I_AM_QSORT_S)
#define	CMP(t, x, y) (cmp((x), (y), (t)))
#else
#define	CMP(t, x, y) (cmp((x), (y)))
#endif

static inline char *
med3(char *a, char *b, char *c, cmp_t *cmp, void *thunk
#if !defined(I_AM_QSORT_R) && !defined(I_AM_QSORT_S)
__unused
#endif
)
{
	return CMP(thunk, a, b) < 0 ?
	       (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a ))
	      :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
}

/*
 * The actual qsort() implementation is static to avoid preemptible calls when
 * recursing. Also give them different names for improved debugging.
 */
#if defined(I_AM_QSORT_R)
#define local_qsort local_qsort_r
#elif defined(I_AM_QSORT_S)
#define local_qsort local_qsort_s
#endif
static void
local_qsort(void *a, size_t n, size_t es, cmp_t *cmp, void *thunk)
{
	char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
	size_t d1, d2;
	int cmp_result;
	int swap_cnt;

loop:
	swap_cnt = 0;
	if (n < 7) {
		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
			for (pl = pm;
			     pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
			     pl -= es)
				swapfunc(pl, pl - es, es);
		return;
	}
	pm = (char *)a + (n / 2) * es;
	if (n > 7) {
		pl = a;
		pn = (char *)a + (n - 1) * es;
		if (n > 40) {
			size_t d = (n / 8) * es;

			pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
			pm = med3(pm - d, pm, pm + d, cmp, thunk);
			pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);
		}
		pm = med3(pl, pm, pn, cmp, thunk);
	}
	swapfunc(a, pm, es);
	pa = pb = (char *)a + es;

	pc = pd = (char *)a + (n - 1) * es;
	for (;;) {
		while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
			if (cmp_result == 0) {
				swap_cnt = 1;
				swapfunc(pa, pb, es);
				pa += es;
			}
			pb += es;
		}
		while (pb <= pc && (cmp_result = CMP(thunk, pc, a)) >= 0) {
			if (cmp_result == 0) {
				swap_cnt = 1;
				swapfunc(pc, pd, es);
				pd -= es;
			}
			pc -= es;
		}
		if (pb > pc)
			break;
		swapfunc(pb, pc, es);
		swap_cnt = 1;
		pb += es;
		pc -= es;
	}
	if (swap_cnt == 0) {  /* Switch to insertion sort */
		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
			for (pl = pm;
			     pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
			     pl -= es)
				swapfunc(pl, pl - es, es);
		return;
	}

	pn = (char *)a + n * es;
	d1 = MIN(pa - (char *)a, pb - pa);
	vecswap(a, pb - d1, d1);
	/*
	 * Cast es to preserve signedness of right-hand side of MIN()
	 * expression, to avoid sign ambiguity in the implied comparison.  es
	 * is safely within [0, SSIZE_MAX].
	 */
	d1 = MIN(pd - pc, pn - pd - (ptrdiff_t)es);
	vecswap(pb, pn - d1, d1);

	d1 = pb - pa;
	d2 = pd - pc;
	if (d1 <= d2) {
		/* Recurse on left partition, then iterate on right partition */
		if (d1 > es) {
			local_qsort(a, d1 / es, es, cmp, thunk);
		}
		if (d2 > es) {
			/* Iterate rather than recurse to save stack space */
			/* qsort(pn - d2, d2 / es, es, cmp); */
			a = pn - d2;
			n = d2 / es;
			goto loop;
		}
	} else {
		/* Recurse on right partition, then iterate on left partition */
		if (d2 > es) {
			local_qsort(pn - d2, d2 / es, es, cmp, thunk);
		}
		if (d1 > es) {
			/* Iterate rather than recurse to save stack space */
			/* qsort(a, d1 / es, es, cmp); */
			n = d1 / es;
			goto loop;
		}
	}
}

#if defined(I_AM_QSORT_R)
void
igraph_qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp)
{
	local_qsort_r(a, n, es, cmp, thunk);
}
#elif defined(I_AM_QSORT_S)
errno_t
igraph_qsort_s(void *a, rsize_t n, rsize_t es, cmp_t *cmp, void *thunk)
{
	if (n > RSIZE_MAX) {
		__throw_constraint_handler_s("qsort_s : n > RSIZE_MAX", EINVAL);
		return (EINVAL);
	} else if (es > RSIZE_MAX) {
		__throw_constraint_handler_s("qsort_s : es > RSIZE_MAX",
		    EINVAL);
		return (EINVAL);
	} else if (n != 0) {
		if (a == NULL) {
			__throw_constraint_handler_s("qsort_s : a == NULL",
			    EINVAL);
			return (EINVAL);
		} else if (cmp == NULL) {
			__throw_constraint_handler_s("qsort_s : cmp == NULL",
			    EINVAL);
			return (EINVAL);
		}
	}

	local_qsort_s(a, n, es, cmp, thunk);
	return (0);
}
#else
void
igraph_qsort(void *a, size_t n, size_t es, cmp_t *cmp)
{
	local_qsort(a, n, es, cmp, NULL);
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/qsort_r.c0000644000175100001710000000033100000000000024107 0ustar00runnerdocker00000000000000/*
 * This file is in the public domain.  Originally written by Garrett
 * A. Wollman.
 *
 * $FreeBSD: src/lib/libc/stdlib/qsort_r.c,v 1.1 2002/09/10 02:04:49 wollman Exp $
 */
#define I_AM_QSORT_R
#include "qsort.c"
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/internal/zeroin.c0000644000175100001710000001743200000000000023736 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* from GNU R's zeroin.c, minor modifications by Gabor Csardi */

/* from NETLIB c/brent.shar with max.iter, add'l info and convergence
   details hacked in by Peter Dalgaard */

/*************************************************************************
 *              C math library
 * function ZEROIN - obtain a function zero within the given range
 *
 * Input
 *  double zeroin(ax,bx,f,info,Tol,Maxit)
 *  double ax;          Root will be seeked for within
 *  double bx;          a range [ax,bx]
 *  double (*f)(double x, void *info); Name of the function whose zero
 *                  will be seeked for
 *  void *info;         Add'l info passed to f
 *  double *Tol;            Acceptable tolerance for the root
 *                  value.
 *                  May be specified as 0.0 to cause
 *                  the program to find the root as
 *                  accurate as possible
 *
 *  int *Maxit;         Max. iterations
 *
 *
 * Output
 *  Zeroin returns an estimate for the root with accuracy
 *  4*EPSILON*abs(x) + tol
 *  *Tol returns estimated precision
 *  *Maxit returns actual # of iterations, or -1 if maxit was
 *      reached without convergence.
 *
 * Algorithm
 *  G.Forsythe, M.Malcolm, C.Moler, Computer methods for mathematical
 *  computations. M., Mir, 1980, p.180 of the Russian edition
 *
 *  The function makes use of the bisection procedure combined with
 *  the linear or quadric inverse interpolation.
 *  At every step program operates on three abscissae - a, b, and c.
 *  b - the last and the best approximation to the root
 *  a - the last but one approximation
 *  c - the last but one or even earlier approximation than a that
 *      1) |f(b)| <= |f(c)|
 *      2) f(b) and f(c) have opposite signs, i.e. b and c confine
 *         the root
 *  At every step Zeroin selects one of the two new approximations, the
 *  former being obtained by the bisection procedure and the latter
 *  resulting in the interpolation (if a,b, and c are all different
 *  the quadric interpolation is utilized, otherwise the linear one).
 *  If the latter (i.e. obtained by the interpolation) point is
 *  reasonable (i.e. lies within the current interval [b,c] not being
 *  too close to the boundaries) it is accepted. The bisection result
 *  is used in the other case. Therefore, the range of uncertainty is
 *  ensured to be reduced at least by the factor 1.6
 *
 ************************************************************************
 */

#include "igraph_nongraph.h"
#include "igraph_types.h"

#include "core/interruption.h"

#include 
#include 

#define EPSILON DBL_EPSILON

int igraph_zeroin(              /* An estimate of the root */
    igraph_real_t *ax,          /* Left border | of the range   */
    igraph_real_t *bx,          /* Right border| the root is seeked*/
    igraph_real_t (*f)(igraph_real_t x, void *info),    /* Function under investigation */
    void *info,             /* Add'l info passed on to f    */
    igraph_real_t *Tol,         /* Acceptable tolerance     */
    int *Maxit,             /* Max # of iterations */
    igraph_real_t *res) {               /* Result is stored here */
    igraph_real_t a, b, c,      /* Abscissae, descr. see above  */
                  fa, fb, fc;         /* f(a), f(b), f(c) */
    igraph_real_t tol;
    int maxit;

    a = *ax;  b = *bx;  fa = (*f)(a, info);  fb = (*f)(b, info);
    c = a;   fc = fa;
    maxit = *Maxit + 1; tol = * Tol;

    /* First test if we have found a root at an endpoint */
    if (fa == 0.0) {
        *Tol = 0.0;
        *Maxit = 0;
        *res = a;
        return 0;
    }
    if (fb ==  0.0) {
        *Tol = 0.0;
        *Maxit = 0;
        *res = b;
        return 0;
    }

    while (maxit--) {   /* Main iteration loop  */
        igraph_real_t prev_step = b - a;  /* Distance from the last but one
                       to the last approximation    */
        igraph_real_t tol_act;      /* Actual tolerance     */
        igraph_real_t p;        /* Interpolation step is calcu- */
        igraph_real_t q;        /* lated in the form p/q; divi-
                     * sion operations is delayed
                     * until the last moment    */
        igraph_real_t new_step;     /* Step at this iteration   */

        IGRAPH_ALLOW_INTERRUPTION();

        if ( fabs(fc) < fabs(fb) ) {
            /* Swap data for b to be the    */
            a = b;  b = c;  c = a;  /* best approximation       */
            fa = fb;  fb = fc;  fc = fa;
        }
        tol_act = 2 * EPSILON * fabs(b) + tol / 2;
        new_step = (c - b) / 2;

        if ( fabs(new_step) <= tol_act || fb == (igraph_real_t)0 ) {
            *Maxit -= maxit;
            *Tol = fabs(c - b);
            *res = b;
            return 0;           /* Acceptable approx. is found  */
        }

        /* Decide if the interpolation can be tried */
        if ( fabs(prev_step) >= tol_act /* If prev_step was large enough*/
             && fabs(fa) > fabs(fb) ) {
            /* and was in true direction,
                         * Interpolation may be tried   */
            register igraph_real_t t1, cb, t2;
            cb = c - b;
            if ( a == c ) {     /* If we have only two distinct */
                /* points linear interpolation  */
                t1 = fb / fa;   /* can only be applied      */
                p = cb * t1;
                q = 1.0 - t1;
            } else {        /* Quadric inverse interpolation*/

                q = fa / fc;  t1 = fb / fc;  t2 = fb / fa;
                p = t2 * ( cb * q * (q - t1) - (b - a) * (t1 - 1.0) );
                q = (q - 1.0) * (t1 - 1.0) * (t2 - 1.0);
            }
            if ( p > (igraph_real_t)0 ) { /* p was calculated with the */
                q = -q;    /* opposite sign; make p positive */
            } else {        /* and assign possible minus to */
                p = -p;    /* q              */
            }

            if ( p < (0.75 * cb * q - fabs(tol_act * q) / 2) /* If b+p/q falls in [b,c]*/
                 && p < fabs(prev_step * q / 2) ) { /* and isn't too large  */
                new_step = p / q;
            }         /* it is accepted
                         * If p/q is too large then the
                         * bisection procedure can
                         * reduce [b,c] range to more
                         * extent */
        }

        if ( fabs(new_step) < tol_act) { /* Adjust the step to be not less*/
            if ( new_step > (igraph_real_t)0 ) { /* than tolerance       */
                new_step = tol_act;
            } else {
                new_step = -tol_act;
            }
        }
        a = b;  fa = fb;            /* Save the previous approx. */
        b += new_step;  fb = (*f)(b, info); /* Do step to a new approxim. */
        if ( (fb > 0 && fc > 0) || (fb < 0 && fc < 0) ) {
            /* Adjust c for it to have a sign opposite to that of b */
            c = a;  fc = fa;
        }

    }
    /* failed! */
    *Tol = fabs(c - b);
    *Maxit = -1;
    *res = b;
    return IGRAPH_DIVERGED;
}
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.519141
igraph-0.9.9/vendor/source/igraph/src/io/0000755000175100001710000000000000000000000021050 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dimacs.c0000644000175100001710000002626400000000000022466 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"

#include "core/interruption.h"

#include 

/**
 * \function igraph_read_graph_dimacs
 * \brief Read a graph in DIMACS format.
 *
 * This function reads the DIMACS file format, more specifically the
 * version for network flow problems, see the files at
 * ftp://dimacs.rutgers.edu/pub/netflow/general-info/
 *
 * 
 * This is a line-oriented text file (ASCII) format. The first
 * character of each line defines the type of the line. If the first
 * character is c the line is a comment line and it is
 * ignored. There is one problem line (p in the file, it
 * must appear before any node and arc descriptor lines. The problem
 * line has three fields separated by spaces: the problem type
 * (min, max or asn), the
 * number of vertices and number of edges in the graph.
 * Exactly two node identification lines are expected
 * (n), one for the source, one for the target vertex.
 * These have two fields: the id of the vertex and the type of the
 * vertex, either s (=source) or t
 * (=target). Arc lines start with a and have three
 * fields: the source vertex, the target vertex and the edge capacity.
 *
 * 
 * Vertex ids are numbered from 1.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream The file to read from.
 * \param source Pointer to an integer, the id of the source node will
 *    be stored here. (The igraph vertex id, which is one less than
 *    the actual number in the file.) It is ignored if
 *    NULL.
 * \param target Pointer to an integer, the (igraph) id of the target
 *    node will be stored here. It is ignored if NULL.
 * \param capacity Pointer to an initialized vector, the capacity of
 *    the edges will be stored here if not NULL.
 * \param directed Boolean, whether to create a directed graph.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|+c), the number of vertices plus the
 * number of edges, plus the size of the file in characters.
 *
 * \sa \ref igraph_write_graph_dimacs()
 */
int igraph_read_graph_dimacs(igraph_t *graph, FILE *instream,
                             igraph_strvector_t *problem,
                             igraph_vector_t *label,
                             igraph_integer_t *source,
                             igraph_integer_t *target,
                             igraph_vector_t *capacity,
                             igraph_bool_t directed) {

    igraph_vector_t edges;
    long int no_of_nodes = -1;
    long int no_of_edges = -1;
    long int tsource = -1;
    long int ttarget = -1;
    char prob[21];
    char c;
    int problem_type = 0;

#define PROBLEM_EDGE  1
#define PROBLEM_MAX   2

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    if (capacity) {
        igraph_vector_clear(capacity);
    }

    while (!feof(instream)) {
        int read;
        char str[3];

        IGRAPH_ALLOW_INTERRUPTION();

        read = fscanf(instream, "%2c", str);
        if (feof(instream)) {
            break;
        }
        if (read != 1) {
            IGRAPH_ERROR("parsing dimacs file failed", IGRAPH_PARSEERROR);
        }
        switch (str[0]) {
            long int tmp, tmp2;
            long int from, to;
            igraph_real_t cap;

        case 'c':
            /* comment */
            break;

        case 'p':
            if (no_of_nodes != -1) {
                IGRAPH_ERROR("reading dimacs file failed, double 'p' line",
                             IGRAPH_PARSEERROR);
            }
            read = fscanf(instream, "%20s %li %li", prob,
                          &no_of_nodes, &no_of_edges);
            if (read != 3) {
                IGRAPH_ERROR("reading dimacs file failed", IGRAPH_PARSEERROR);
            }
            if (!strcmp(prob, "edge")) {
                /* edge list */
                problem_type = PROBLEM_EDGE;
                if (label) {
                    long int i;
                    IGRAPH_CHECK(igraph_vector_resize(label, no_of_nodes));
                    for (i = 0; i < no_of_nodes; i++) {
                        VECTOR(*label)[i] = i + 1;
                    }
                }
            } else if (!strcmp(prob, "max")) {
                /* maximum flow problem */
                problem_type = PROBLEM_MAX;
                if (capacity) {
                    IGRAPH_CHECK(igraph_vector_reserve(capacity, no_of_edges));
                }
            } else {
                IGRAPH_ERROR("Unknown problem type, should be 'edge' or 'max'",
                             IGRAPH_PARSEERROR);
            }
            if (problem) {
                igraph_strvector_clear(problem);
                IGRAPH_CHECK(igraph_strvector_add(problem, prob));
            }
            IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));
            break;

        case 'n':
            /* for MAX this is either the source or target vertex,
            for EDGE this is a vertex label */
            if (problem_type == PROBLEM_MAX) {
                str[0] = 'x';
                read = fscanf(instream, "%li %1s", &tmp, str);
                if (str[0] == 's') {
                    if (tsource != -1) {
                        IGRAPH_ERROR("reading dimacsfile: multiple source vertex line",
                                     IGRAPH_PARSEERROR);
                    } else {
                        tsource = tmp;
                    }
                } else if (str[0] == 't') {
                    if (ttarget != -1) {
                        IGRAPH_ERROR("reading dimacsfile: multiple target vertex line",
                                     IGRAPH_PARSEERROR);
                    } else {
                        ttarget = tmp;
                    }
                } else {
                    IGRAPH_ERROR("invalid node descriptor line in dimacs file",
                                 IGRAPH_PARSEERROR);
                }
            } else {
                read = fscanf(instream, "%li %li", &tmp, &tmp2);
                if (label) {
                    VECTOR(*label)[tmp] = tmp2;
                }
            }

            break;

        case 'a':
            /* This is valid only for MAX, a weighted edge */
            if (problem_type != PROBLEM_MAX) {
                IGRAPH_ERROR("'a' lines are allowed only in MAX problem files",
                             IGRAPH_PARSEERROR);
            }
            read = fscanf(instream, "%li %li %lf", &from, &to, &cap);
            if (read != 3) {
                IGRAPH_ERROR("reading dimacs file", IGRAPH_PARSEERROR);
            }
            IGRAPH_CHECK(igraph_vector_push_back(&edges, from - 1));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, to - 1));
            if (capacity) {
                IGRAPH_CHECK(igraph_vector_push_back(capacity, cap));
            }
            break;

        case 'e':
            /* Edge line, only in EDGE */
            if (problem_type != PROBLEM_EDGE) {
                IGRAPH_ERROR("'e' lines are allowed only in EDGE problem files",
                             IGRAPH_PARSEERROR);
            }
            read = fscanf(instream, "%li %li", &from, &to);
            if (read != 2) {
                IGRAPH_ERROR("reading dimacs file", IGRAPH_PARSEERROR);
            }
            IGRAPH_CHECK(igraph_vector_push_back(&edges, from - 1));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, to - 1));
            break;

        default:
            IGRAPH_ERROR("unknown line type in dimacs file", IGRAPH_PARSEERROR);
        }

        /* Go to next line */
        while (!feof(instream) && (c = (char) getc(instream)) != '\n') ;
    }

    if (source) {
        *source = (igraph_integer_t) tsource - 1;
    }
    if (target) {
        *target = (igraph_integer_t) ttarget - 1;
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);

    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_write_graph_dimacs
 * \brief Write a graph in DIMACS format.
 *
 * This function writes a graph to an output stream in DIMACS format,
 * describing a maximum flow problem.
 * See ftp://dimacs.rutgers.edu/pub/netflow/general-info/
 *
 * 
 * This file format is discussed in the documentation of \ref
 * igraph_read_graph_dimacs(), see that for more information.
 *
 * \param graph The graph to write to the stream.
 * \param outstream The stream.
 * \param source Integer, the id of the source vertex for the maximum
 *     flow.
 * \param target Integer, the id of the target vertex.
 * \param capacity Pointer to an initialized vector containing the
 *     edge capacity values.
 * \return Error code.
 *
 * Time complexity: O(|E|), the number of edges in the graph.
 *
 * \sa igraph_read_graph_dimacs()
 */
int igraph_write_graph_dimacs(const igraph_t *graph, FILE *outstream,
                              long int source, long int target,
                              const igraph_vector_t *capacity) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_eit_t it;
    long int i = 0;
    int ret, ret1, ret2, ret3;

    if (igraph_vector_size(capacity) != no_of_edges) {
        IGRAPH_ERROR("invalid capacity vector length", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
                                   &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);

    ret = fprintf(outstream,
                  "c created by igraph\np max %li %li\nn %li s\nn %li t\n",
                  no_of_nodes, no_of_edges, source + 1, target + 1);
    if (ret < 0) {
        IGRAPH_ERROR("Write error", IGRAPH_EFILE);
    }


    while (!IGRAPH_EIT_END(it)) {
        igraph_integer_t from, to;
        igraph_real_t cap;
        igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to);
        cap = VECTOR(*capacity)[i++];
        ret1 = fprintf(outstream, "a %li %li ",
                       (long int) from + 1, (long int) to + 1);
        ret2 = igraph_real_fprintf_precise(outstream, cap);
        ret3 = fputc('\n', outstream);
        if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
            IGRAPH_ERROR("Write error", IGRAPH_EFILE);
        }
        IGRAPH_EIT_NEXT(it);
    }

    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dl-header.h0000644000175100001710000000250600000000000023051 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_types.h"

#include "core/trie.h"

typedef enum { IGRAPH_DL_MATRIX,
               IGRAPH_DL_EDGELIST1, IGRAPH_DL_NODELIST1
             } igraph_i_dl_type_t;

typedef struct {
    void *scanner;
    int eof;
    int mode;
    long int n;
    long int from, to;
    igraph_vector_t edges;
    igraph_vector_t weights;
    igraph_strvector_t labels;
    igraph_trie_t trie;
    igraph_i_dl_type_t type;
    char errmsg[300];
} igraph_i_dl_parsedata_t;
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dl-lexer.l0000644000175100001710000001060100000000000022737 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 
#include 

#include "io/dl-header.h"
#include "io/parsers/dl-parser.h"

#define YY_EXTRA_TYPE igraph_i_dl_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
%}

%option noyywrap
%option prefix="igraph_dl_yy"
%option nounput
%option noinput
%option nodefault
%option reentrant
%option bison-bridge
%option bison-locations

digit      [0-9]
whitespace [ \t\v\f]

%x LABELM FULLMATRIX EDGELIST NODELIST

%%

<*>\n\r|\r\n|\r|\n         { return NEWLINE; }

[dD][lL]{whitespace}+      { return DL; }
[nN]{whitespace}*[=]{whitespace}* {
  return NEQ; }
{digit}+                   { return NUM; }

[dD][aA][tT][aA][:]        {
  switch (yyextra->mode) {
  case 0: BEGIN(FULLMATRIX);
    break;
  case 1: BEGIN(EDGELIST);
    break;
  case 2: BEGIN(NODELIST);
    break;
  }
  return DATA; }

[lL][aA][bB][eE][lL][sS]:  { BEGIN(LABELM); return LABELS; }
[lL][aA][bB][eE][lL][sS]{whitespace}+[eE][mM][bB][eE][dD][dD][eE][dD]:?{whitespace}* {
  return LABELSEMBEDDED; }
[fF][oO][rR][mM][aA][tT]{whitespace}*[=]{whitespace}*[fF][uU][lL][lL][mM][aA][tT][rR][iI][xX]{whitespace}* {
  yyextra->mode=0; return FORMATFULLMATRIX; }
[fF][oO][rR][mM][aA][tT]{whitespace}*[=]{whitespace}*[eE][dD][gG][eE][lL][iI][sS][tT][1]{whitespace}* {
  yyextra->mode=1; return FORMATEDGELIST1; }
[fF][oO][rR][mM][aA][tT]{whitespace}*[=]{whitespace}*[nN][oO][dD][eE][lL][iI][sS][tT][1]{whitespace}* {
  yyextra->mode=2; return FORMATNODELIST1; }

[, ]                               { /* eaten up */ }
[^, \t\n\r\f\v]+{whitespace}*      { return LABEL; }

{digit}{whitespace}*          { return DIGIT; }
[^ \t\n\r\v\f,]+              { return LABEL; }
{whitespace}                  { }

\-?{digit}+(\.{digit}+)?([eE](\+|\-)?{digit}+)?  { return NUM; }
[^ \t\n\r\v\f,]+                                 { return LABEL; }
{whitespace}*                                    { }

{digit}+                      { return NUM; }
[^ \t\r\n\v\f,]+              { return LABEL; }
{whitespace}*                 { }

{whitespace}+                      { /* eaten up */ }

<>                 {
                          if (yyextra->eof) {
                            yyterminate();
                          } else {
                            yyextra->eof=1;
                            BEGIN(INITIAL);
                            return EOFF;
                          }
                        }

<*>. { return 0; }
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dl-parser.y0000644000175100001710000002333000000000000023134 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"

#include "core/math.h"
#include "internal/hacks.h"
#include "io/dl-header.h"
#include "io/parsers/dl-parser.h"
#include "io/parsers/dl-lexer.h"

#include 

int igraph_dl_yyerror(YYLTYPE* locp, igraph_i_dl_parsedata_t* context,
                      const char *s);
int igraph_i_dl_add_str(char *newstr, int length,
                        igraph_i_dl_parsedata_t *context);
int igraph_i_dl_add_edge(long int from, long int to,
                         igraph_i_dl_parsedata_t *context);
int igraph_i_dl_add_edge_w(long int from, long int to,
                           igraph_real_t weight,
                           igraph_i_dl_parsedata_t *context);

extern igraph_real_t igraph_pajek_get_number(const char *str, long int len);

#define scanner context->scanner

%}

%pure-parser
/* bison: do not remove the equals sign; macOS XCode ships with bison 2.3, which
 * needs the equals sign */
%name-prefix="igraph_dl_yy"
%defines
%locations
%error-verbose
%parse-param { igraph_i_dl_parsedata_t* context }
%lex-param { void* scanner }

%union {
  long int integer;
  igraph_real_t real;
};

%type  integer elabel;
%type  weight;

%token NUM
%token NEWLINE
%token DL
%token NEQ
%token DATA
%token LABELS
%token LABELSEMBEDDED
%token FORMATFULLMATRIX
%token FORMATEDGELIST1
%token FORMATNODELIST1
%token DIGIT
%token LABEL
%token EOFF
%token ERROR

%%

input: DL NEQ integer NEWLINE rest trail eof { context->n=$3; };

trail: | trail newline;

eof: | EOFF;

rest:    formfullmatrix { context->type=IGRAPH_DL_MATRIX; }
      |  edgelist1      { context->type=IGRAPH_DL_EDGELIST1; }
      |  nodelist1      { context->type=IGRAPH_DL_NODELIST1; }
;

formfullmatrix:  FORMATFULLMATRIX newline fullmatrix {} | fullmatrix {} ;

newline: | NEWLINE ;

fullmatrix:   DATA newline fullmatrixdata { }
            | LABELS newline labels newline DATA newline fullmatrixdata { }
            | LABELSEMBEDDED newline DATA newline labeledfullmatrixdata { }
;

labels:       {} /* nothing, empty matrix */
            | labels newline LABEL {
              igraph_i_dl_add_str(igraph_dl_yyget_text(scanner),
                                  igraph_dl_yyget_leng(scanner),
                                  context); }
;

fullmatrixdata: {} | fullmatrixdata zerooneseq NEWLINE {
  context->from += 1;
  context->to = 0;
 } ;

zerooneseq: | zerooneseq zeroone { } ;

zeroone: DIGIT {
  if (igraph_dl_yyget_text(scanner)[0]=='1') {
    IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                         context->from));
    IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                         context->to));
  }
  context->to += 1;
} ;

labeledfullmatrixdata: reallabeledfullmatrixdata {} ;

reallabeledfullmatrixdata: labelseq NEWLINE labeledmatrixlines {} ;

labelseq: | labelseq newline label ;

label: LABEL { igraph_i_dl_add_str(igraph_dl_yyget_text(scanner),
                                   igraph_dl_yyget_leng(scanner),
                                   context); };

labeledmatrixlines: labeledmatrixline {
                 context->from += 1;
                 context->to = 0;
               }
             | labeledmatrixlines labeledmatrixline {
                 context->from += 1;
                 context->to = 0;
               };

labeledmatrixline: LABEL zerooneseq NEWLINE { } ;

/*-----------------------------------------------------------*/

edgelist1: FORMATEDGELIST1 newline edgelist1rest {} ;

edgelist1rest:   DATA newline edgelist1data {}
             | LABELS newline labels newline DATA newline edgelist1data {}
             | LABELSEMBEDDED newline DATA newline labelededgelist1data {}
             | LABELS newline labels newline LABELSEMBEDDED newline DATA newline labelededgelist1data {}
             | LABELSEMBEDDED newline LABELS newline labels newline DATA newline labelededgelist1data {}
;

edgelist1data: {} /* nothing, empty graph */
             | edgelist1data edgelist1dataline {}
;

edgelist1dataline: integer integer weight NEWLINE {
                   igraph_i_dl_add_edge_w($1-1, $2-1, $3, context); }
                 | integer integer NEWLINE {
                   igraph_i_dl_add_edge($1-1, $2-1, context);
} ;

integer: NUM { $$=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                          igraph_dl_yyget_leng(scanner)); };

labelededgelist1data: {} /* nothing, empty graph */
                    | labelededgelist1data labelededgelist1dataline {}
;

labelededgelist1dataline: elabel elabel weight NEWLINE {
                          igraph_i_dl_add_edge_w($1, $2, $3, context); }
                        | elabel elabel NEWLINE {
                          igraph_i_dl_add_edge($1, $2, context);
 };

weight: NUM { $$=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                         igraph_dl_yyget_leng(scanner)); };

elabel: LABEL {
  /* Copy label list to trie, if needed */
  if (igraph_strvector_size(&context->labels) != 0) {
    long int i, id, n=igraph_strvector_size(&context->labels);
    for (i=0; itrie,
                      STR(context->labels, i), &id);
    }
    igraph_strvector_clear(&context->labels);
  }
  igraph_trie_get2(&context->trie, igraph_dl_yyget_text(scanner),
                   igraph_dl_yyget_leng(scanner), &$$);
 };

/*-----------------------------------------------------------*/

nodelist1: FORMATNODELIST1 newline nodelist1rest {} ;

nodelist1rest:   DATA nodelist1data {}
             | LABELS newline labels newline DATA newline nodelist1data {}
             | LABELSEMBEDDED newline DATA newline labelednodelist1data {}
             | LABELS newline labels newline LABELSEMBEDDED newline DATA newline labelednodelist1data {}
             | LABELSEMBEDDED newline LABELS newline labels newline DATA newline labelednodelist1data {}
;

nodelist1data: {} /* nothing, empty graph */
             | nodelist1data nodelist1dataline {}
;

nodelist1dataline: from tolist NEWLINE {} ;

from: NUM { context->from=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                                          igraph_dl_yyget_leng(scanner)); } ;

tolist: {} | tolist integer {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                       context->from-1));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, $2-1));
 } ;

labelednodelist1data: {} /* nothing, empty graph */
                    | labelednodelist1data labelednodelist1dataline {}
;

labelednodelist1dataline: fromelabel labeltolist NEWLINE { } ;

fromelabel: elabel {
  context->from=$1;
 };

labeltolist: | labeltolist elabel {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                       context->from));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, $2));
 } ;

%%

int igraph_dl_yyerror(YYLTYPE* locp, igraph_i_dl_parsedata_t* context,
                      const char *s) {
  snprintf(context->errmsg,
           sizeof(context->errmsg)/sizeof(char)-1,
           "%s in line %i", s, locp->first_line);
  return 0;
}

int igraph_i_dl_add_str(char *newstr, int length,
                        igraph_i_dl_parsedata_t *context) {
  int tmp=newstr[length];
  newstr[length]='\0';
  IGRAPH_CHECK(igraph_strvector_add(&context->labels, newstr));
  newstr[length]=tmp;
  return 0;
}

int igraph_i_dl_add_edge(long int from, long int to,
                         igraph_i_dl_parsedata_t *context) {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, from));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, to));
  return 0;
}

int igraph_i_dl_add_edge_w(long int from, long int to,
                           igraph_real_t weight,
                           igraph_i_dl_parsedata_t *context) {
  long int n=igraph_vector_size(&context->weights);
  long int n2=igraph_vector_size(&context->edges)/2;
  if (n != n2) {
    igraph_vector_resize(&context->weights, n2);
    for (; nweights)[n]=IGRAPH_NAN;
    }
  }
  IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context));
  IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight));
  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dl.c0000644000175100001710000001341500000000000021617 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_interface.h"

#include "io/dl-header.h"

int igraph_dl_yylex_init_extra (igraph_i_dl_parsedata_t* user_defined,
                                void* scanner);
void igraph_dl_yylex_destroy (void *scanner );
int igraph_dl_yyparse (igraph_i_dl_parsedata_t* context);
void igraph_dl_yyset_in  (FILE * in_str, void* yyscanner );

/**
 * \function igraph_read_graph_dl
 * \brief Read a file in the DL format of UCINET
 *
 * This is a simple textual file format used by UCINET. See
 * http://www.analytictech.com/networks/dataentry.htm for
 * examples. All the forms described here are supported by
 * igraph. Vertex names and edge weights are also supported and they
 * are added as attributes. (If an attribute handler is attached.)
 *
 *  Note the specification does not mention whether the
 * format is case sensitive or not. For igraph DL files are case
 * sensitive, i.e. \c Larry and \c larry are not the same.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream The stream to read the DL file from.
 * \param directed Logical scalar, whether to create a directed file.
 * \return Error code.
 *
 * Time complexity: linear in terms of the number of edges and
 * vertices, except for the matrix format, which is quadratic in the
 * number of vertices.
 *
 * \example examples/simple/igraph_read_graph_dl.c
 */

int igraph_read_graph_dl(igraph_t *graph, FILE *instream,
                         igraph_bool_t directed) {

    int i;
    long int n, n2;
    const igraph_strvector_t *namevec = 0;
    igraph_vector_ptr_t name, weight;
    igraph_vector_ptr_t *pname = 0, *pweight = 0;
    igraph_attribute_record_t namerec, weightrec;
    const char *namestr = "name", *weightstr = "weight";
    igraph_i_dl_parsedata_t context;

    context.eof = 0;
    context.mode = 0;
    context.n = -1;
    context.from = 0;
    context.to = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&context.edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0);
    IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0));
    IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels);
    IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1);

    igraph_dl_yylex_init_extra(&context, &context.scanner);
    IGRAPH_FINALLY(igraph_dl_yylex_destroy, context.scanner);

    igraph_dl_yyset_in(instream, context.scanner);

    i = igraph_dl_yyparse(&context);
    if (i != 0) {
        if (context.errmsg[0] != 0) {
            IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Cannot read DL file", IGRAPH_PARSEERROR);
        }
    }

    /* Extend the weight vector, if needed */
    n = igraph_vector_size(&context.weights);
    n2 = igraph_vector_size(&context.edges) / 2;
    if (n != 0) {
        igraph_vector_resize(&context.weights, n2);
        for (; n < n2; n++) {
            VECTOR(context.weights)[n] = IGRAPH_NAN;
        }
    }

    /* Check number of vertices */
    if (n2 > 0) {
        n = (long int) igraph_vector_max(&context.edges);
    } else {
        n = 0;
    }
    if (n >= context.n) {
        IGRAPH_WARNING("More vertices than specified in `DL' file");
        context.n = n;
    }

    /* OK, everything is ready, create the graph */
    IGRAPH_CHECK(igraph_empty(graph, 0, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);

    /* Labels */
    if (igraph_strvector_size(&context.labels) != 0) {
        namevec = (const igraph_strvector_t*) &context.labels;
    } else if (igraph_trie_size(&context.trie) != 0) {
        igraph_trie_getkeys(&context.trie, &namevec);
    }
    if (namevec) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&name, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &name);
        pname = &name;
        namerec.name = namestr;
        namerec.type = IGRAPH_ATTRIBUTE_STRING;
        namerec.value = namevec;
        VECTOR(name)[0] = &namerec;
    }

    /* Weights */
    if (igraph_vector_size(&context.weights) != 0) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&weight, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &weight);
        pweight = &weight;
        weightrec.name = weightstr;
        weightrec.type = IGRAPH_ATTRIBUTE_NUMERIC;
        weightrec.value = &context.weights;
        VECTOR(weight)[0] = &weightrec;
    }

    IGRAPH_CHECK(igraph_add_vertices(graph, (igraph_integer_t) context.n, pname));
    IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight));

    if (pweight) {
        igraph_vector_ptr_destroy(pweight);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (pname) {
        igraph_vector_ptr_destroy(pname);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* don't destroy the graph itself but pop it from the finally stack */
    IGRAPH_FINALLY_CLEAN(1);

    igraph_trie_destroy(&context.trie);
    igraph_strvector_destroy(&context.labels);
    igraph_vector_destroy(&context.edges);
    igraph_vector_destroy(&context.weights);
    igraph_dl_yylex_destroy(context.scanner);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/dot.c0000644000175100001710000003175300000000000022013 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_version.h"

#include "graph/attributes.h"
#include "internal/hacks.h" /* strcasecmp */

#include 
#include 

#define CHECK(cmd) do { ret=cmd; if (ret<0) IGRAPH_ERROR("Write DOT format failed.", IGRAPH_EFILE); } while (0)

static int igraph_i_dot_escape(const char *orig, char **result) {
    /* do we have to escape the string at all? */
    long int i, j, len = (long int) strlen(orig), newlen = 0;
    igraph_bool_t need_quote = 0, is_number = 1;

    /* first, check whether the string is equal to some reserved word */
    if (!strcasecmp(orig, "graph") || !strcasecmp(orig, "digraph") ||
        !strcasecmp(orig, "node") || !strcasecmp(orig, "edge") ||
        !strcasecmp(orig, "strict") || !strcasecmp(orig, "subgraph")) {
        need_quote = 1;
        is_number = 0;
    }

    /* next, check whether we need to escape the string for any other reason.
     * Also update is_number and newlen */
    for (i = 0; i < len; i++) {
        if (isdigit(orig[i])) {
            newlen++;
        } else if (orig[i] == '-' && i == 0) {
            newlen++;
        } else if (orig[i] == '.') {
            if (is_number) {
                newlen++;
            } else {
                need_quote = 1;
                newlen++;
            }
        } else if (orig[i] == '_') {
            is_number = 0; newlen++;
        } else if (orig[i] == '\\' || orig[i] == '"' || orig[i] == '\n') {
            need_quote = 1; is_number = 0; newlen += 2; /* will be escaped */
        } else if (isalpha(orig[i])) {
            is_number = 0; newlen++;
        } else {
            is_number = 0; need_quote = 1; newlen++;
        }
    }
    if (is_number && orig[len - 1] == '.') {
        is_number = 0;
    }
    if (!is_number && isdigit(orig[0])) {
        need_quote = 1;
    }

    if (is_number || !need_quote) {
        *result = strdup(orig);
        if (!*result) {
            IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_ENOMEM);
        }
    } else {
        *result = IGRAPH_CALLOC(newlen + 3, char);
        if (!*result) {
            IGRAPH_ERROR("Writing DOT format failed.", IGRAPH_ENOMEM);
        }
        (*result)[0] = '"';
        (*result)[newlen + 1] = '"';
        (*result)[newlen + 2] = '\0';
        for (i = 0, j = 1; i < len; i++) {
            if (orig[i] == '\n') {
                (*result)[j++] = '\\';
                (*result)[j++] = 'n';
                continue;
            }
            if (orig[i] == '\\' || orig[i] == '"') {
                (*result)[j++] = '\\';
            }
            (*result)[j++] = orig[i];
        }
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_write_graph_dot
 * \brief Write the graph to a stream in DOT format
 *
 * DOT is the format used by the widely known GraphViz software, see
 * http://www.graphviz.org for details. The grammar of the DOT format
 * can be found here: http://www.graphviz.org/doc/info/lang.html
 *
 * This is only a preliminary implementation, only the vertices
 * and the edges are written but not the attributes or any visualization
 * information.
 *
 * \param graph The graph to write to the stream.
 * \param outstream The stream to write the file to.
 *
 * Time complexity: should be proportional to the number of characters written
 * to the file.
 *
 * \sa \ref igraph_write_graph_graphml() for a more modern format.
 *
 * \example examples/simple/dot.c
 */
int igraph_write_graph_dot(const igraph_t *graph, FILE* outstream) {
    int ret;
    long int i, j;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    char edgeop[3];
    igraph_strvector_t gnames, vnames, enames;
    igraph_vector_t gtypes, vtypes, etypes;
    igraph_vector_t numv;
    igraph_strvector_t strv;
    igraph_vector_bool_t boolv;

    IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
    IGRAPH_VECTOR_INIT_FINALLY(>ypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vtypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&etypes, 0);
    IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
                 &gnames, >ypes,
                 &vnames, &vtypes,
                 &enames, &etypes));

    IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
    IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);

    CHECK(fprintf(outstream, "/* Created by igraph %s */\n",
                  IGRAPH_VERSION));

    if (igraph_is_directed(graph)) {
        CHECK(fprintf(outstream, "digraph {\n"));
        strcpy(edgeop, "->");
    } else {
        CHECK(fprintf(outstream, "graph {\n"));
        strcpy(edgeop, "--");
    }

    /* Write the graph attributes */
    if (igraph_vector_size(>ypes) > 0) {
        CHECK(fprintf(outstream, "  graph [\n"));
        for (i = 0; i < igraph_vector_size(>ypes); i++) {
            char *name, *newname;
            igraph_strvector_get(&gnames, i, &name);
            IGRAPH_CHECK(igraph_i_dot_escape(name, &newname));
            IGRAPH_FINALLY(igraph_free, newname);
            if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
                IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
                if (VECTOR(numv)[0] == (long)VECTOR(numv)[0]) {
                    CHECK(fprintf(outstream, "    %s=%ld\n", newname, (long)VECTOR(numv)[0]));
                } else {
                    CHECK(fprintf(outstream, "    %s=", newname));
                    CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
                    CHECK(fputc('\n', outstream));
                }
            } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
                char *s, *news;
                IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_dot_escape(s, &news));
                CHECK(fprintf(outstream, "    %s=%s\n", newname, news));
                IGRAPH_FREE(news);
            } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
                IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
                CHECK(fprintf(outstream, "    %s=%d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
                IGRAPH_WARNING("A boolean graph attribute was converted to numeric");
            } else {
                IGRAPH_WARNING("A non-numeric, non-string, non-boolean graph attribute ignored");
            }
            IGRAPH_FREE(newname);
            IGRAPH_FINALLY_CLEAN(1);
        }
        CHECK(fprintf(outstream, "  ];\n"));
    }

    /* Write the vertices */
    if (igraph_vector_size(&vtypes) > 0) {
        for (i = 0; i < no_of_nodes; i++) {
            CHECK(fprintf(outstream, "  %ld [\n", i));
            for (j = 0; j < igraph_vector_size(&vtypes); j++) {
                char *name, *newname;
                igraph_strvector_get(&vnames, j, &name);
                IGRAPH_CHECK(igraph_i_dot_escape(name, &newname));
                IGRAPH_FINALLY(igraph_free, newname);
                if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                    IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name, igraph_vss_1((igraph_integer_t) i), &numv));
                    if (VECTOR(numv)[0] == (long)VECTOR(numv)[0]) {
                        CHECK(fprintf(outstream, "    %s=%ld\n", newname, (long)VECTOR(numv)[0]));
                    } else {
                        CHECK(fprintf(outstream, "    %s=", newname));
                        CHECK(igraph_real_fprintf_precise(outstream,
                                                          VECTOR(numv)[0]));
                        CHECK(fputc('\n', outstream));
                    }
                } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
                    char *s, *news;
                    IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name, igraph_vss_1((igraph_integer_t) i), &strv));
                    igraph_strvector_get(&strv, 0, &s);
                    IGRAPH_CHECK(igraph_i_dot_escape(s, &news));
                    CHECK(fprintf(outstream, "    %s=%s\n", newname, news));
                    IGRAPH_FREE(news);
                } else if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
                    IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name, igraph_vss_1((igraph_integer_t) i), &boolv));
                    CHECK(fprintf(outstream, "    %s=%d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
                    IGRAPH_WARNING("A boolean vertex attribute was converted to numeric");
                } else {
                    IGRAPH_WARNING("A non-numeric, non-string, non-boolean vertex attribute was ignored");
                }
                IGRAPH_FREE(newname);
                IGRAPH_FINALLY_CLEAN(1);
            }
            CHECK(fprintf(outstream, "  ];\n"));
        }
    } else {
        for (i = 0; i < no_of_nodes; i++) {
            CHECK(fprintf(outstream, "  %ld;\n", i));
        }
    }
    CHECK(fprintf(outstream, "\n"));

    /* Write the edges */
    if (igraph_vector_size(&etypes) > 0) {
        for (i = 0; i < no_of_edges; i++) {
            long int from = IGRAPH_FROM(graph, i);
            long int to = IGRAPH_TO(graph, i);
            CHECK(fprintf(outstream, "  %ld %s %ld [\n", from, edgeop, to));
            for (j = 0; j < igraph_vector_size(&etypes); j++) {
                char *name, *newname;
                igraph_strvector_get(&enames, j, &name);
                IGRAPH_CHECK(igraph_i_dot_escape(name, &newname));
                IGRAPH_FINALLY(igraph_free, newname);
                if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                    IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph,
                                 name, igraph_ess_1((igraph_integer_t) i), &numv));
                    if (VECTOR(numv)[0] == (long)VECTOR(numv)[0]) {
                        CHECK(fprintf(outstream, "    %s=%ld\n", newname, (long)VECTOR(numv)[0]));
                    } else {
                        CHECK(fprintf(outstream, "    %s=", newname));
                        CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
                        CHECK(fputc('\n', outstream));
                    }
                } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_STRING) {
                    char *s, *news;
                    IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph,
                                 name, igraph_ess_1((igraph_integer_t) i), &strv));
                    igraph_strvector_get(&strv, 0, &s);
                    IGRAPH_CHECK(igraph_i_dot_escape(s, &news));
                    CHECK(fprintf(outstream, "    %s=%s\n", newname, news));
                    IGRAPH_FREE(news);
                } else if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_BOOLEAN) {
                    IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph,
                                 name, igraph_ess_1((igraph_integer_t) i), &boolv));
                    CHECK(fprintf(outstream, "    %s=%d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
                    IGRAPH_WARNING("A boolean edge attribute was converted to numeric");
                } else {
                    IGRAPH_WARNING("A non-numeric, non-string graph attribute ignored");
                }
                IGRAPH_FREE(newname);
                IGRAPH_FINALLY_CLEAN(1);
            }
            CHECK(fprintf(outstream, "  ];\n"));
        }
    } else {
        for (i = 0; i < no_of_edges; i++) {
            long int from = IGRAPH_FROM(graph, i);
            long int to = IGRAPH_TO(graph, i);
            CHECK(fprintf(outstream, "  %ld %s %ld;\n", from, edgeop, to));
        }
    }
    CHECK(fprintf(outstream, "}\n"));

    igraph_vector_bool_destroy(&boolv);
    igraph_strvector_destroy(&strv);
    igraph_vector_destroy(&numv);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(>ypes);
    igraph_strvector_destroy(&enames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&gnames);
    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

#undef CHECK
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/edgelist.c0000644000175100001710000001201700000000000023015 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"

#include "core/interruption.h"

#include 

/**
 * \section about_loadsave
 *
 * These functions can write a graph to a file, or read a graph
 * from a file.
 *
 * Note that as \a igraph uses the traditional C streams, it is
 * possible to read/write files from/to memory, at least on GNU
 * operating systems supporting \quote non-standard\endquote streams.
 */

/**
 * \ingroup loadsave
 * \function igraph_read_graph_edgelist
 * \brief Reads an edge list from a file and creates a graph.
 *
 * 
 * This format is simply a series of an even number of non-negative integers separated by
 * whitespace. The integers represent vertex IDs. Placing each edge (i.e. pair of integers)
 * on a separate line is not required, but it is recommended for readability.
 * Edges of directed graphs are assumed to be in "from, to" order.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream Pointer to a stream, it should be readable.
 * \param n The number of vertices in the graph. If smaller than the
 *        largest integer in the file it will be ignored. It is thus
 *        safe to supply zero here.
 * \param directed Logical, if true the graph is directed, if false it
 *        will be undirected.
 * \return Error code:
 *         \c IGRAPH_PARSEERROR: if there is a
 *         problem reading the file, or the file is syntactically
 *         incorrect.
 *
 * Time complexity: O(|V|+|E|), the
 * number of vertices plus the number of edges. It is assumed that
 * reading an integer requires O(1)
 * time.
 */
int igraph_read_graph_edgelist(igraph_t *graph, FILE *instream,
                               igraph_integer_t n, igraph_bool_t directed) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int from, to;
    int c;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, 100));

    /* skip all whitespace */
    do {
        c = getc (instream);
    } while (isspace (c));
    ungetc (c, instream);

    while (!feof(instream)) {
        int read;

        IGRAPH_ALLOW_INTERRUPTION();

        read = fscanf(instream, "%li", &from);
        if (read != 1) {
            IGRAPH_ERROR("parsing edgelist file failed", IGRAPH_PARSEERROR);
        }
        read = fscanf(instream, "%li", &to);
        if (read != 1) {
            IGRAPH_ERROR("parsing edgelist file failed", IGRAPH_PARSEERROR);
        }
        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));

        /* skip all whitespace */
        do {
            c = getc (instream);
        } while (isspace (c));
        ungetc (c, instream);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, n, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \ingroup loadsave
 * \function igraph_write_graph_edgelist
 * \brief Writes the edge list of a graph to a file.
 *
 * 
 * One edge is written per line, separated by a single space.
 * For directed graphs edges are written in from, to order.
 * \param graph The graph object to write.
 * \param outstream Pointer to a stream, it should be writable.
 * \return Error code:
 *         \c IGRAPH_EFILE if there is an error writing the
 *         file.
 *
 * Time complexity: O(|E|), the
 * number of edges in the  graph. It is assumed that writing an
 * integer to the file requires O(1)
 * time.
 */
int igraph_write_graph_edgelist(const igraph_t *graph, FILE *outstream) {

    igraph_eit_t it;

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
                                   &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);

    while (!IGRAPH_EIT_END(it)) {
        igraph_integer_t from, to;
        int ret;
        igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to);
        ret = fprintf(outstream, "%li %li\n",
                      (long int) from,
                      (long int) to);
        if (ret < 0) {
            IGRAPH_ERROR("Write error", IGRAPH_EFILE);
        }
        IGRAPH_EIT_NEXT(it);
    }

    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml-header.h0000644000175100001710000000246400000000000023234 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"

#include "io/gml-tree.h"

typedef struct {
    void *scanner;
    int eof;
    int depth;
    char errmsg[300];
    igraph_gml_tree_t *tree;
} igraph_i_gml_parsedata_t;

/**
 * Initializes a GML parser context.
 */
int igraph_i_gml_parsedata_init(igraph_i_gml_parsedata_t* context);

/**
 * Destroys a GML parser context, freeing all memory currently used by the
 * context.
 */
void igraph_i_gml_parsedata_destroy(igraph_i_gml_parsedata_t* context);
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml-lexer.l0000644000175100001710000000675100000000000023132 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/gml-header.h"
#include "io/parsers/gml-parser.h"

#define YY_EXTRA_TYPE igraph_i_gml_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
%}

%option noyywrap
%option prefix="igraph_gml_yy"
%option nounput
%option noinput
%option nodefault
%option reentrant
%option bison-bridge
%option bison-locations

digit       [0-9]
whitespace  [ \r\n\t]

%%

^#[^\n\r]*[\n]|[\r]     { /* comments ignored */ }

\"[^\x00\"]*\"                                  { return STRING; }
\-?{digit}+(\.{digit}+)?([eE](\+|\-)?{digit}+)? { return NUM; }
[a-zA-Z_][a-zA-Z_0-9]*  { return KEYWORD; }
\[                      {
                          yyextra->depth++;
                          if (yyextra->depth >= 32) {
                            return ERROR;
                          } else {
                            return LISTOPEN;
                          }
                        }
\]                      {
                          yyextra->depth--;
                          if (yyextra->depth < 0) {
                            return ERROR;
                          } else {
                            return LISTCLOSE;
                          }
                        }
\n\r|\r\n|\r|\n         { }
{whitespace}            { /* other whitespace ignored */ }

<>                 {
                          if (yyextra->eof) {
                            yyterminate();
                          } else {
                            yyextra->eof=1;
                            return EOFF;
                          }
                        }
.                       { return ERROR; }
%%
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml-parser.y0000644000175100001710000002066100000000000023320 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "igraph_error.h"
#include "igraph_memory.h"
#include "config.h"

#include "core/math.h"
#include "io/gml-header.h"
#include "io/gml-tree.h"
#include "io/parsers/gml-parser.h"
#include "io/parsers/gml-lexer.h"
#include "internal/hacks.h" /* strcasecmp */

int igraph_gml_yyerror(YYLTYPE* locp, igraph_i_gml_parsedata_t *context,
                       const char *s);
void igraph_i_gml_get_keyword(char *s, int len, void *res);
void igraph_i_gml_get_string(char *s, int len, void *res);
double igraph_i_gml_get_real(char *s, int len);
igraph_gml_tree_t *igraph_i_gml_make_numeric(char* s, int len, double value);
igraph_gml_tree_t *igraph_i_gml_make_numeric2(char* s, int len,
                                              char *v, int vlen);
igraph_gml_tree_t *igraph_i_gml_make_string(char* s, int len,
                                            char *value, int valuelen);
igraph_gml_tree_t *igraph_i_gml_make_list(char* s, int len,
                                          igraph_gml_tree_t *list);
igraph_gml_tree_t *igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2);

#define scanner context->scanner
#define USE(x) /*(x)*/

%}

%pure-parser
/* bison: do not remove the equals sign; macOS XCode ships with bison 2.3, which
 * needs the equals sign */
%name-prefix="igraph_gml_yy"
%defines
%locations
%error-verbose
%parse-param { igraph_i_gml_parsedata_t* context }
%lex-param { void *scanner }

%union {
   struct {
      char *s;
      int len;
   } str;
   void *tree;
   double real;
}

%type     list;
%type     keyvalue;
%type      key;
%type     num;
%type      string;

%token STRING
%token NUM
%token     KEYWORD
%token LISTOPEN
%token LISTCLOSE
%token EOFF
%token ERROR

%destructor { IGRAPH_FREE($$.s); } string key KEYWORD;
%destructor { igraph_gml_tree_destroy($$); } list keyvalue;

%%

input:   list      { context->tree=$1; }
       | list EOFF { context->tree=$1; }
;

list:   keyvalue      { $$=$1; }
      | list keyvalue { $$=igraph_i_gml_merge($1, $2); };

keyvalue:   key num
            { $$=igraph_i_gml_make_numeric($1.s, $1.len, $2); }
          | key string
            { $$=igraph_i_gml_make_string($1.s, $1.len, $2.s, $2.len); }
          | key LISTOPEN list LISTCLOSE
            { $$=igraph_i_gml_make_list($1.s, $1.len, $3); }
          | key key
            { $$=igraph_i_gml_make_numeric2($1.s, $1.len, $2.s, $2.len); }
;

key: KEYWORD { igraph_i_gml_get_keyword(igraph_gml_yyget_text(scanner),
                                        igraph_gml_yyget_leng(scanner),
                                        &$$); USE($1); };
num : NUM { $$=igraph_i_gml_get_real(igraph_gml_yyget_text(scanner),
                                     igraph_gml_yyget_leng(scanner)); };

string: STRING { igraph_i_gml_get_string(igraph_gml_yyget_text(scanner),
                                         igraph_gml_yyget_leng(scanner),
                                         &$$); };

%%

int igraph_gml_yyerror(YYLTYPE* locp, igraph_i_gml_parsedata_t *context,
                       const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
           "Parse error in GML file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

void igraph_i_gml_get_keyword(char *s, int len, void *res) {
  struct { char *s; int len; } *p=res;
  p->s=IGRAPH_CALLOC(len+1, char);
  if (!p->s) {
    igraph_error("Cannot read GML file", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
  }
  memcpy(p->s, s, sizeof(char)*len);
  p->s[len]='\0';
  p->len=len;
}

void igraph_i_gml_get_string(char *s, int len, void *res) {
  struct { char *s; int len; } *p=res;
  p->s=IGRAPH_CALLOC(len-1, char);
  if (!p->s) {
    igraph_error("Cannot read GML file", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
  }
  memcpy(p->s, s+1, sizeof(char)*(len-2));
  p->s[len-2]='\0';
  p->len=len-2;
}

double igraph_i_gml_get_real(char *s, int len) {
  igraph_real_t num;
  char tmp=s[len];
  s[len]='\0';
  sscanf(s, "%lf", &num);
  s[len]=tmp;
  return num;
}

igraph_gml_tree_t *igraph_i_gml_make_numeric(char* s, int len, double value) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  if (floor(value)==value) {
    if (igraph_gml_tree_init_integer(t, s, len, value)) {
          free(t);
          return 0;
        }
  } else {
    if (igraph_gml_tree_init_real(t, s, len, value)) {
      free(t);
          return 0;
        }
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_numeric2(char* s, int len,
                                              char* v, int vlen) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
  char tmp = v[vlen];

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  v[vlen]='\0';

  /* if v == "inf" or v == "nan", the newly created tree node will take ownership
   * of s. If the creation fails, we need to free s and v as well in order not
   * to leak memory */
  if (strcasecmp(v, "inf")) {
    if (igraph_gml_tree_init_real(t, s, len, IGRAPH_INFINITY)) {
      free(t);
      t = 0;
    }
  } else if (strcasecmp(v, "nan")) {
    if (igraph_gml_tree_init_real(t, s, len, IGRAPH_NAN)) {
      free(t);
      t = 0;
    }
  } else {
    igraph_error("Parse error", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
    free(t);
    t = 0;
  }

  v[vlen]=tmp;
  free(v);

  if (t == 0) {
    /* no new tree node was created so s has no owner any more */
    free(s);
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_string(char* s, int len,
                                            char *value, int valuelen) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  /* if igraph_gml_tree_init_string succeeds, the newly created tree node takes
   * ownership of 'value'. If it fails, we need to free 'value' ourselves in order
   * not to leak memory */
  if (igraph_gml_tree_init_string(t, s, len, value, valuelen)) {
    free(t);
    free(value);
    t = 0;
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_list(char* s, int len,
                                          igraph_gml_tree_t *list) {

  igraph_gml_tree_t *t=IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  if (igraph_gml_tree_init_tree(t, s, len, list)) {
    free(t);
    return 0;
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2) {

  igraph_gml_tree_mergedest(t1, t2);
  IGRAPH_FREE(t2);

  return t1;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml-tree.c0000644000175100001710000001717100000000000022737 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"
#include "igraph_error.h"

#include "io/gml-tree.h"

#include 

int igraph_gml_tree_init_integer(igraph_gml_tree_t *t,
                                 const char *name, int namelen,
                                 igraph_integer_t value) {

    igraph_integer_t *p;

    IGRAPH_UNUSED(namelen);

    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
    IGRAPH_CHECK(igraph_vector_char_init(&t->types, 1));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &t->types);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);

    /* names */
    VECTOR(t->names)[0] = (void*)name;

    /* types */
    VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_INTEGER;

    /* children */
    p = IGRAPH_CALLOC(1, igraph_integer_t);
    if (!p) {
        IGRAPH_ERROR("Cannot create integer GML tree node", IGRAPH_ENOMEM);
    }
    *p = value;
    VECTOR(t->children)[0] = p;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

int igraph_gml_tree_init_real(igraph_gml_tree_t *t,
                              const char *name, int namelen,
                              igraph_real_t value) {

    igraph_real_t *p;

    IGRAPH_UNUSED(namelen);

    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
    IGRAPH_CHECK(igraph_vector_char_init(&t->types, 1));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &t->types);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);

    /* names */
    VECTOR(t->names)[0] = (void*) name;

    /* types */
    VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_REAL;

    /* children */
    p = IGRAPH_CALLOC(1, igraph_real_t);
    if (!p) {
        IGRAPH_ERROR("Cannot create real GML tree node", IGRAPH_ENOMEM);
    }
    *p = value;
    VECTOR(t->children)[0] = p;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

int igraph_gml_tree_init_string(igraph_gml_tree_t *t,
                                const char *name, int namelen,
                                const char *value, int valuelen) {

    IGRAPH_UNUSED(namelen);
    IGRAPH_UNUSED(valuelen);

    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
    IGRAPH_CHECK(igraph_vector_char_init(&t->types, 1));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &t->types);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);

    /* names */
    VECTOR(t->names)[0] = (void*) name;

    /* types */
    VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_STRING;

    /* children */
    VECTOR(t->children)[0] = (void*)value;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

int igraph_gml_tree_init_tree(igraph_gml_tree_t *t,
                              const char *name, int namelen,
                              igraph_gml_tree_t *value) {

    IGRAPH_UNUSED(namelen);

    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->names, 1);
    IGRAPH_CHECK(igraph_vector_char_init(&t->types, 1));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &t->types);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 1);

    /* names */
    VECTOR(t->names)[0] = (void*)name;

    /* types */
    VECTOR(t->types)[0] = IGRAPH_I_GML_TREE_TREE;

    /* children */
    VECTOR(t->children)[0] = value;

    IGRAPH_FINALLY_CLEAN(3);
    return 0;

}

/* merge is destructive, the _second_ tree is destroyed */
int igraph_gml_tree_mergedest(igraph_gml_tree_t *t1, igraph_gml_tree_t *t2) {
    long int i, n = igraph_vector_ptr_size(&t2->children);
    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->names, VECTOR(t2->names)[i]));
        IGRAPH_CHECK(igraph_vector_char_push_back(&t1->types, VECTOR(t2->types)[i]));
        IGRAPH_CHECK(igraph_vector_ptr_push_back(&t1->children,
                     VECTOR(t2->children)[i]));
    }

    igraph_vector_ptr_destroy(&t2->names);
    igraph_vector_char_destroy(&t2->types);
    igraph_vector_ptr_destroy(&t2->children);
    return 0;
}

void igraph_gml_tree_destroy(igraph_gml_tree_t *t) {

    long int i, n = igraph_vector_ptr_size(&t->children);
    for (i = 0; i < n; i++) {
        int type = VECTOR(t->types)[i];
        switch (type) {
        case IGRAPH_I_GML_TREE_TREE:
            igraph_gml_tree_destroy(VECTOR(t->children)[i]);
            IGRAPH_FREE(VECTOR(t->names)[i]);
            break;
        case IGRAPH_I_GML_TREE_INTEGER:
            IGRAPH_FREE(VECTOR(t->children)[i]);
            IGRAPH_FREE(VECTOR(t->names)[i]);
            break;
        case IGRAPH_I_GML_TREE_REAL:
            IGRAPH_FREE(VECTOR(t->children)[i]);
            IGRAPH_FREE(VECTOR(t->names)[i]);
            break;
        case IGRAPH_I_GML_TREE_STRING:
            IGRAPH_FREE(VECTOR(t->children)[i]);
            IGRAPH_FREE(VECTOR(t->names)[i]);
            break;
        case IGRAPH_I_GML_TREE_DELETED:
            break;
        }
    }
    igraph_vector_ptr_destroy(&t->names);
    igraph_vector_char_destroy(&t->types);
    igraph_vector_ptr_destroy(&t->children);
    IGRAPH_FREE(t);
}

long int igraph_gml_tree_length(const igraph_gml_tree_t *t) {
    return igraph_vector_ptr_size(&t->names);
}

long int igraph_gml_tree_find(const igraph_gml_tree_t *t,
                              const char *name, long int from) {

    long int size = igraph_vector_ptr_size(&t->names);
    while ( from < size && (! VECTOR(t->names)[from] ||
                            strcmp(VECTOR(t->names)[from], name)) ) {
        from++;
    }

    if (from == size) {
        from = -1;
    }
    return from;
}

long int igraph_gml_tree_findback(const igraph_gml_tree_t *t,
                                  const char *name, long int from) {
    while ( from >= 0 && (! VECTOR(t->names)[from] ||
                          strcmp(VECTOR(t->names)[from], name)) ) {
        from--;
    }

    return from;
}

int igraph_gml_tree_type(const igraph_gml_tree_t *t, long int pos) {
    return VECTOR(t->types)[pos];
}

const char *igraph_gml_tree_name(const igraph_gml_tree_t *t, long int pos) {
    return VECTOR(t->names)[pos];
}

igraph_integer_t igraph_gml_tree_get_integer(const igraph_gml_tree_t *t,
        long int pos) {
    igraph_integer_t *i = VECTOR(t->children)[pos];
    return *i;
}

igraph_real_t igraph_gml_tree_get_real(const igraph_gml_tree_t *t,
                                       long int pos) {
    igraph_real_t *d = VECTOR(t->children)[pos];
    return *d;
}

const char *igraph_gml_tree_get_string(const igraph_gml_tree_t *t,
                                       long int pos) {
    const char *s = VECTOR(t->children)[pos];
    return s;
}

igraph_gml_tree_t *igraph_gml_tree_get_tree(const igraph_gml_tree_t *t,
        long int pos) {
    igraph_gml_tree_t *tree = VECTOR(t->children)[pos];
    return tree;
}

void igraph_gml_tree_delete(igraph_gml_tree_t *t, long int pos) {
    if (VECTOR(t->types)[pos] == IGRAPH_I_GML_TREE_TREE) {
        igraph_gml_tree_destroy(VECTOR(t->children)[pos]);
    }
    IGRAPH_FREE(VECTOR(t->names)[pos]);
    IGRAPH_FREE(VECTOR(t->children)[pos]);
    VECTOR(t->children)[pos] = 0;
    VECTOR(t->names)[pos] = 0;
    VECTOR(t->types)[pos] = IGRAPH_I_GML_TREE_DELETED;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml-tree.h0000644000175100001710000000624500000000000022744 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef REST_GML_TREE_H
#define REST_GML_TREE_H

#include "igraph_decls.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

typedef enum { IGRAPH_I_GML_TREE_TREE = 0,
               IGRAPH_I_GML_TREE_INTEGER,
               IGRAPH_I_GML_TREE_REAL,
               IGRAPH_I_GML_TREE_STRING,
               IGRAPH_I_GML_TREE_DELETED
             } igraph_i_gml_tree_type_t;

typedef struct igraph_gml_tree_t {
    igraph_vector_ptr_t names;
    igraph_vector_char_t types;
    igraph_vector_ptr_t children;
} igraph_gml_tree_t;

int igraph_gml_tree_init_integer(igraph_gml_tree_t *t,
                                 const char *name, int namelen,
                                 igraph_integer_t value);
int igraph_gml_tree_init_real(igraph_gml_tree_t *t,
                              const char *name, int namelen,
                              igraph_real_t value);
int igraph_gml_tree_init_string(igraph_gml_tree_t *t,
                                const char *name, int namelen,
                                const char *value, int valuelen);
int igraph_gml_tree_init_tree(igraph_gml_tree_t *t,
                              const char *name, int namelen,
                              igraph_gml_tree_t *value);
void igraph_gml_tree_destroy(igraph_gml_tree_t *t);

void igraph_gml_tree_delete(igraph_gml_tree_t *t, long int pos);
int igraph_gml_tree_mergedest(igraph_gml_tree_t *t1, igraph_gml_tree_t *t2);

long int igraph_gml_tree_length(const igraph_gml_tree_t *t);
long int igraph_gml_tree_find(const igraph_gml_tree_t *t,
                              const char *name, long int from);
long int igraph_gml_tree_findback(const igraph_gml_tree_t *t,
                                  const char *name, long int from);
int igraph_gml_tree_type(const igraph_gml_tree_t *t, long int pos);
const char *igraph_gml_tree_name(const igraph_gml_tree_t *t, long int pos);
igraph_integer_t igraph_gml_tree_get_integer(const igraph_gml_tree_t *t,
        long int pos);
igraph_real_t igraph_gml_tree_get_real(const igraph_gml_tree_t *t,
                                       long int pos);
const char *igraph_gml_tree_get_string(const igraph_gml_tree_t *t,
                                       long int pos);

igraph_gml_tree_t *igraph_gml_tree_get_tree(const igraph_gml_tree_t *t,
        long int pos);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/gml.c0000644000175100001710000007775400000000000022017 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_version.h"

#include "core/trie.h"
#include "graph/attributes.h"
#include "io/gml-header.h"

#include 
#include 
#include 

int igraph_gml_yylex_init_extra (igraph_i_gml_parsedata_t* user_defined,
                                 void* scanner);
void igraph_gml_yylex_destroy (void *scanner );
int igraph_gml_yyparse (igraph_i_gml_parsedata_t* context);
void igraph_gml_yyset_in  (FILE * in_str, void* yyscanner );

static void igraph_i_gml_destroy_attrs(igraph_vector_ptr_t **ptr) {
    long int i;
    igraph_vector_ptr_t *vec;
    for (i = 0; i < 3; i++) {
        long int j;
        vec = ptr[i];
        for (j = 0; j < igraph_vector_ptr_size(vec); j++) {
            igraph_attribute_record_t *atrec = VECTOR(*vec)[j];
            if (atrec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_vector_t *value = (igraph_vector_t*)atrec->value;
                if (value != 0) {
                    igraph_vector_destroy(value);
                    IGRAPH_FREE(value);
                }
            } else {
                igraph_strvector_t *value = (igraph_strvector_t*)atrec->value;
                if (value != 0) {
                    igraph_strvector_destroy(value);
                    IGRAPH_FREE(value);
                }
            }
            IGRAPH_FREE(atrec->name);
            IGRAPH_FREE(atrec);
        }
        igraph_vector_ptr_destroy(vec);
    }
}

static int igraph_i_gml_toreal(igraph_gml_tree_t *node, long int pos, igraph_real_t *result) {

    igraph_real_t value = 0.0;
    int type = igraph_gml_tree_type(node, pos);

    switch (type) {
    case IGRAPH_I_GML_TREE_INTEGER:
        value = igraph_gml_tree_get_integer(node, pos);
        break;
    case IGRAPH_I_GML_TREE_REAL:
        value = igraph_gml_tree_get_real(node, pos);
        break;
    default:
        IGRAPH_ERROR("Internal error while parsing GML file.", IGRAPH_FAILURE);
        break;
    }

    *result = value;
    return IGRAPH_SUCCESS;
}

static const char *igraph_i_gml_tostring(igraph_gml_tree_t *node, long int pos) {

    int type = igraph_gml_tree_type(node, pos);
    static char tmp[256];
    const char *p = tmp;
    long int i;
    igraph_real_t d;

    switch (type) {
    case IGRAPH_I_GML_TREE_INTEGER:
        i = igraph_gml_tree_get_integer(node, pos);
        snprintf(tmp, sizeof(tmp) / sizeof(char), "%li", i);
        break;
    case IGRAPH_I_GML_TREE_REAL:
        d = igraph_gml_tree_get_real(node, pos);
        igraph_real_snprintf_precise(tmp, sizeof(tmp) / sizeof(char), d);
        break;
    case IGRAPH_I_GML_TREE_STRING:
        p = igraph_gml_tree_get_string(node, pos);
        break;
    default:
        break;
    }

    return p;
}

int igraph_i_gml_parsedata_init(igraph_i_gml_parsedata_t* context) {
    context->eof = 0;
    context->depth = 0;
    context->scanner = 0;
    context->tree = 0;
    context->errmsg[0] = 0;

    return IGRAPH_SUCCESS;
}

void igraph_i_gml_parsedata_destroy(igraph_i_gml_parsedata_t* context) {
    if (context->tree != 0) {
        igraph_gml_tree_destroy(context->tree);
        context->tree = 0;
    }

    if (context->scanner != 0) {
        igraph_gml_yylex_destroy(context->scanner);
        context->scanner = 0;
    }
}

/**
 * \function igraph_read_graph_gml
 * \brief Read a graph in GML format.
 *
 * GML is a simple textual format, see
 * http://www.fim.uni-passau.de/en/fim/faculty/chairs/theoretische-informatik/projects.html for details.
 *
 * 
 * Although all syntactically correct GML can be parsed,
 * we implement only a subset of this format, some attributes might be
 * ignored. Here is a list of all the differences:
 * \olist
 * \oli Only node and edge attributes are
 *      used, and only if they have a simple type: integer, real or
 *      string. So if an attribute is an array or a record, then it is
 *      ignored. This is also true if only some values of the
 *      attribute are complex.
 * \oli Top level attributes except for Version and the
 *      first graph attribute are completely ignored.
 * \oli Graph attributes except for node and
 *      edge are completely ignored.
 * \oli There is no maximum line length.
 * \oli There is no maximum keyword length.
 * \oli Character entities in strings are not interpreted.
 * \oli We allow inf (infinity) and nan
 *      (not a number) as a real number. This is case insensitive, so
 *      nan, NaN and NAN are equal.
 * \endolist
 *
 *  Please contact us if you cannot live with these
 * limitations of the GML parser.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream The stream to read the GML file from.
 * \return Error code.
 *
 * Time complexity: should be proportional to the length of the file.
 *
 * \sa \ref igraph_read_graph_graphml() for a more modern format,
 * \ref igraph_write_graph_gml() for writing GML files.
 *
 * \example examples/simple/gml.c
 */
int igraph_read_graph_gml(igraph_t *graph, FILE *instream) {

    long int i, p;
    long int no_of_nodes = 0, no_of_edges = 0;
    igraph_trie_t trie;
    igraph_vector_t edges;
    igraph_bool_t directed = IGRAPH_UNDIRECTED;
    igraph_gml_tree_t *gtree;
    long int gidx;
    igraph_trie_t vattrnames;
    igraph_trie_t eattrnames;
    igraph_trie_t gattrnames;
    igraph_vector_ptr_t gattrs = IGRAPH_VECTOR_PTR_NULL,
                        vattrs = IGRAPH_VECTOR_PTR_NULL, eattrs = IGRAPH_VECTOR_PTR_NULL;
    igraph_vector_ptr_t *attrs[3];
    long int edgeptr = 0;
    igraph_i_gml_parsedata_t context;

    attrs[0] = &gattrs; attrs[1] = &vattrs; attrs[2] = &eattrs;

    IGRAPH_CHECK(igraph_i_gml_parsedata_init(&context));
    IGRAPH_FINALLY(igraph_i_gml_parsedata_destroy, &context);

    igraph_gml_yylex_init_extra(&context, &context.scanner);

    igraph_gml_yyset_in(instream, context.scanner);

    i = igraph_gml_yyparse(&context);
    if (i != 0) {
        if (context.errmsg[0] != 0) {
            IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Cannot read GML file.", IGRAPH_PARSEERROR);
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    /* Check version, if present, integer and not '1' then ignored */
    i = igraph_gml_tree_find(context.tree, "Version", 0);
    if (i >= 0 &&
        igraph_gml_tree_type(context.tree, i) == IGRAPH_I_GML_TREE_INTEGER &&
        igraph_gml_tree_get_integer(context.tree, i) != 1) {
        IGRAPH_ERROR("Unknown GML version.", IGRAPH_UNIMPLEMENTED);
        /* RETURN HERE!!!! */
    }

    /* get the graph */
    gidx = igraph_gml_tree_find(context.tree, "graph", 0);
    if (gidx == -1) {
        IGRAPH_ERROR("No 'graph' object in GML file.", IGRAPH_PARSEERROR);
    }
    if (igraph_gml_tree_type(context.tree, gidx) !=
        IGRAPH_I_GML_TREE_TREE) {
        IGRAPH_ERROR("Invalid type for 'graph' object in GML file.", IGRAPH_PARSEERROR);
    }
    gtree = igraph_gml_tree_get_tree(context.tree, gidx);

    IGRAPH_FINALLY(igraph_i_gml_destroy_attrs, attrs);
    igraph_vector_ptr_init(&gattrs, 0);
    igraph_vector_ptr_init(&vattrs, 0);
    igraph_vector_ptr_init(&eattrs, 0);

    IGRAPH_TRIE_INIT_FINALLY(&trie, 0);
    IGRAPH_TRIE_INIT_FINALLY(&vattrnames, 0);
    IGRAPH_TRIE_INIT_FINALLY(&eattrnames, 0);
    IGRAPH_TRIE_INIT_FINALLY(&gattrnames, 0);

    /* Is is directed? */
    i = igraph_gml_tree_find(gtree, "directed", 0);
    if (i >= 0 && igraph_gml_tree_type(gtree, i) == IGRAPH_I_GML_TREE_INTEGER) {
        if (igraph_gml_tree_get_integer(gtree, i) == 1) {
            directed = IGRAPH_DIRECTED;
        }
    }

    /* Now we go over all objects in the graph and collect the attribute names and
       types. Plus we collect node ids. We also do some checks. */
    for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
        long int j;
        char cname[100];
        const char *name = igraph_gml_tree_name(gtree, i);
        if (!strcmp(name, "node")) {
            igraph_gml_tree_t *node;
            igraph_bool_t hasid;
            no_of_nodes++;
            if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
                IGRAPH_ERROR("'node' is not a list in GML file.", IGRAPH_PARSEERROR);
            }
            node = igraph_gml_tree_get_tree(gtree, i);
            hasid = 0;
            for (j = 0; j < igraph_gml_tree_length(node); j++) {
                const char *name = igraph_gml_tree_name(node, j);
                long int trieid, triesize = igraph_trie_size(&vattrnames);
                IGRAPH_CHECK(igraph_trie_get(&vattrnames, name, &trieid));
                if (trieid == triesize) {
                    /* new attribute */
                    igraph_attribute_record_t *atrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
                    int type = igraph_gml_tree_type(node, j);
                    if (!atrec) {
                        IGRAPH_ERROR("Cannot read GML file.", IGRAPH_ENOMEM);
                    }
                    IGRAPH_CHECK(igraph_vector_ptr_push_back(&vattrs, atrec));
                    atrec->name = strdup(name);
                    if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
                        atrec->type = IGRAPH_ATTRIBUTE_NUMERIC;
                    } else {
                        atrec->type = IGRAPH_ATTRIBUTE_STRING;
                    }
                } else {
                    /* already seen, should we update type? */
                    igraph_attribute_record_t *atrec = VECTOR(vattrs)[trieid];
                    int type1 = atrec->type;
                    int type2 = igraph_gml_tree_type(node, j);
                    if (type1 == IGRAPH_ATTRIBUTE_NUMERIC && type2 == IGRAPH_I_GML_TREE_STRING) {
                        atrec->type = IGRAPH_ATTRIBUTE_STRING;
                    }
                }
                /* check id */
                if (!hasid && !strcmp(name, "id")) {
                    long int id;
                    if (igraph_gml_tree_type(node, j) != IGRAPH_I_GML_TREE_INTEGER) {
                        IGRAPH_ERROR("Non-integer node id in GML file.", IGRAPH_PARSEERROR);
                    }
                    id = igraph_gml_tree_get_integer(node, j);
                    snprintf(cname, sizeof(cname) / sizeof(char) -1, "%li", id);
                    IGRAPH_CHECK(igraph_trie_get(&trie, cname, &id));
                    hasid = 1;
                }
            }
            if (!hasid) {
                IGRAPH_ERROR("Node without 'id' while parsing GML file.", IGRAPH_PARSEERROR);
            }
        } else if (!strcmp(name, "edge")) {
            igraph_gml_tree_t *edge;
            igraph_bool_t has_source = 0, has_target = 0;
            no_of_edges++;
            if (igraph_gml_tree_type(gtree, i) != IGRAPH_I_GML_TREE_TREE) {
                IGRAPH_ERROR("'edge' is not a list in GML file.", IGRAPH_PARSEERROR);
            }
            edge = igraph_gml_tree_get_tree(gtree, i);
            has_source = has_target = 0;
            for (j = 0; j < igraph_gml_tree_length(edge); j++) {
                const char *name = igraph_gml_tree_name(edge, j);
                if (!strcmp(name, "source")) {
                    has_source = 1;
                    if (igraph_gml_tree_type(edge, j) != IGRAPH_I_GML_TREE_INTEGER) {
                        IGRAPH_ERROR("Non-integer 'source' for an edge in GML file.",
                                     IGRAPH_PARSEERROR);
                    }
                } else if (!strcmp(name, "target")) {
                    has_target = 1;
                    if (igraph_gml_tree_type(edge, j) != IGRAPH_I_GML_TREE_INTEGER) {
                        IGRAPH_ERROR("Non-integer 'source' for an edge in GML file.",
                                     IGRAPH_PARSEERROR);
                    }
                } else {
                    long int trieid, triesize = igraph_trie_size(&eattrnames);
                    IGRAPH_CHECK(igraph_trie_get(&eattrnames, name, &trieid));
                    if (trieid == triesize) {
                        /* new attribute */
                        igraph_attribute_record_t *atrec = IGRAPH_CALLOC(1, igraph_attribute_record_t);
                        int type = igraph_gml_tree_type(edge, j);
                        if (!atrec) {
                            IGRAPH_ERROR("Cannot read GML file.", IGRAPH_ENOMEM);
                        }
                        IGRAPH_CHECK(igraph_vector_ptr_push_back(&eattrs, atrec));
                        atrec->name = strdup(name);
                        if (type == IGRAPH_I_GML_TREE_INTEGER || type == IGRAPH_I_GML_TREE_REAL) {
                            atrec->type = IGRAPH_ATTRIBUTE_NUMERIC;
                        } else {
                            atrec->type = IGRAPH_ATTRIBUTE_STRING;
                        }
                    } else {
                        /* already seen, should we update type? */
                        igraph_attribute_record_t *atrec = VECTOR(eattrs)[trieid];
                        int type1 = atrec->type;
                        int type2 = igraph_gml_tree_type(edge, j);
                        if (type1 == IGRAPH_ATTRIBUTE_NUMERIC && type2 == IGRAPH_I_GML_TREE_STRING) {
                            atrec->type = IGRAPH_ATTRIBUTE_STRING;
                        }
                    }
                }
            } /* for */
            if (!has_source) {
                IGRAPH_ERROR("No 'source' for edge in GML file.", IGRAPH_PARSEERROR);
            }
            if (!has_target) {
                IGRAPH_ERROR("No 'target' for edge in GML file.", IGRAPH_PARSEERROR);
            }
        } else {
            /* anything to do? Maybe add as graph attribute.... */
        }
    }

    /* check vertex id uniqueness */
    if (igraph_trie_size(&trie) != no_of_nodes) {
        IGRAPH_ERROR("Node 'id' not unique in GML file.", IGRAPH_PARSEERROR);
    }

    /* now we allocate the vectors and strvectors for the attributes */
    for (i = 0; i < igraph_vector_ptr_size(&vattrs); i++) {
        igraph_attribute_record_t *atrec = VECTOR(vattrs)[i];
        int type = atrec->type;
        if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *p = IGRAPH_CALLOC(1, igraph_vector_t);
            atrec->value = p;
            IGRAPH_CHECK(igraph_vector_init(p, no_of_nodes));
        } else if (type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *p = IGRAPH_CALLOC(1, igraph_strvector_t);
            atrec->value = p;
            IGRAPH_CHECK(igraph_strvector_init(p, no_of_nodes));
        } else {
            IGRAPH_WARNING("A composite attribute was ignored in the GML file.");
        }
    }

    for (i = 0; i < igraph_vector_ptr_size(&eattrs); i++) {
        igraph_attribute_record_t *atrec = VECTOR(eattrs)[i];
        int type = atrec->type;
        if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *p = IGRAPH_CALLOC(1, igraph_vector_t);
            atrec->value = p;
            IGRAPH_CHECK(igraph_vector_init(p, no_of_edges));
        } else if (type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *p = IGRAPH_CALLOC(1, igraph_strvector_t);
            atrec->value = p;
            IGRAPH_CHECK(igraph_strvector_init(p, no_of_edges));
        } else {
            IGRAPH_WARNING("A composite attribute was ignored in the GML file.");
        }
    }

    /* Ok, now the edges, attributes too */
    IGRAPH_CHECK(igraph_vector_resize(&edges, no_of_edges * 2));
    p = -1;
    while ( (p = igraph_gml_tree_find(gtree, "edge", p + 1)) != -1) {
        igraph_gml_tree_t *edge;
        long int from, to, fromidx = 0, toidx = 0;
        char name[100];
        long int j;
        edge = igraph_gml_tree_get_tree(gtree, p);
        for (j = 0; j < igraph_gml_tree_length(edge); j++) {
            const char *n = igraph_gml_tree_name(edge, j);
            if (!strcmp(n, "source")) {
                fromidx = igraph_gml_tree_find(edge, "source", 0);
            } else if (!strcmp(n, "target")) {
                toidx = igraph_gml_tree_find(edge, "target", 0);
            } else {
                long int edgeid = edgeptr / 2;
                long int trieidx;
                igraph_attribute_record_t *atrec;
                int type;
                igraph_trie_get(&eattrnames, n, &trieidx);
                atrec = VECTOR(eattrs)[trieidx];
                type = atrec->type;
                if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                    igraph_vector_t *v = (igraph_vector_t *)atrec->value;
                    IGRAPH_CHECK(igraph_i_gml_toreal(edge, j, VECTOR(*v) + edgeid));
                } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                    igraph_strvector_t *v = (igraph_strvector_t *)atrec->value;
                    const char *value = igraph_i_gml_tostring(edge, j);
                    IGRAPH_CHECK(igraph_strvector_set(v, edgeid, value));
                }
            }
        }
        from = igraph_gml_tree_get_integer(edge, fromidx);
        to = igraph_gml_tree_get_integer(edge, toidx);
        snprintf(name, sizeof(name) / sizeof(char) -1, "%li", from);
        IGRAPH_CHECK(igraph_trie_get(&trie, name, &from));
        snprintf(name, sizeof(name) / sizeof(char) -1, "%li", to);
        IGRAPH_CHECK(igraph_trie_get(&trie, name, &to));
        if (igraph_trie_size(&trie) != no_of_nodes) {
            IGRAPH_ERROR("Unknown node id found in an edge in GML file.", IGRAPH_PARSEERROR);
        }
        VECTOR(edges)[edgeptr++] = from;
        VECTOR(edges)[edgeptr++] = to;
    }

    /* and add vertex attributes */
    for (i = 0; i < igraph_gml_tree_length(gtree); i++) {
        const char *n;
        char name[100];
        long int j, k;
        n = igraph_gml_tree_name(gtree, i);
        if (!strcmp(n, "node")) {
            igraph_gml_tree_t *node = igraph_gml_tree_get_tree(gtree, i);
            long int iidx = igraph_gml_tree_find(node, "id", 0);
            long int id = igraph_gml_tree_get_integer(node, iidx);
            snprintf(name, sizeof(name) / sizeof(char) -1, "%li", id);
            igraph_trie_get(&trie, name, &id);
            for (j = 0; j < igraph_gml_tree_length(node); j++) {
                const char *aname = igraph_gml_tree_name(node, j);
                igraph_attribute_record_t *atrec;
                int type;
                igraph_trie_get(&vattrnames, aname, &k);
                atrec = VECTOR(vattrs)[k];
                type = atrec->type;
                if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                    igraph_vector_t *v = (igraph_vector_t *)atrec->value;
                    IGRAPH_CHECK(igraph_i_gml_toreal(node, j, VECTOR(*v) + id));
                } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                    igraph_strvector_t *v = (igraph_strvector_t *)atrec->value;
                    const char *value = igraph_i_gml_tostring(node, j);
                    IGRAPH_CHECK(igraph_strvector_set(v, id, value));
                }
            }
        }
    }

    igraph_trie_destroy(&trie);
    igraph_trie_destroy(&gattrnames);
    igraph_trie_destroy(&vattrnames);
    igraph_trie_destroy(&eattrnames);
    IGRAPH_FINALLY_CLEAN(4);

    IGRAPH_CHECK(igraph_empty_attrs(graph, 0, directed, 0)); /* TODO */
    IGRAPH_CHECK(igraph_add_vertices(graph, (igraph_integer_t) no_of_nodes,
                                     &vattrs));
    IGRAPH_CHECK(igraph_add_edges(graph, &edges, &eattrs));

    igraph_i_gml_destroy_attrs(attrs);
    igraph_vector_destroy(&edges);
    igraph_i_gml_parsedata_destroy(&context);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

static int igraph_i_gml_convert_to_key(const char *orig, char **key) {
    int no = 1;
    char strno[50];
    size_t i, len = strlen(orig), newlen = 0, plen = 0;

    /* do we need a prefix? */
    if (len == 0 || !isalpha(orig[0])) {
        no++;
        snprintf(strno, sizeof(strno) - 1, "igraph");
        plen = newlen = strlen(strno);
    }
    for (i = 0; i < len; i++) {
        if (isalnum(orig[i])) {
            newlen++;
        }
    }
    *key = IGRAPH_CALLOC(newlen + 1, char);
    if (! *key) {
        IGRAPH_ERROR("Writing GML format failed.", IGRAPH_ENOMEM);
    }
    memcpy(*key, strno, plen * sizeof(char));
    for (i = 0; i < len; i++) {
        if (isalnum(orig[i])) {
            (*key)[plen++] = orig[i];
        }
    }
    (*key)[newlen] = '\0';

    return IGRAPH_SUCCESS;
}

#define CHECK(cmd) do { ret=cmd; if (ret<0) IGRAPH_ERROR("Writing GML format failed.", IGRAPH_EFILE); } while (0)

/**
 * \function igraph_write_graph_gml
 * \brief Write the graph to a stream in GML format
 *
 * GML is a quite general textual format, see
 * http://www.fim.uni-passau.de/en/fim/faculty/chairs/theoretische-informatik/projects.html for details.
 *
 *  The graph, vertex and edges attributes are written to the
 * file as well, if they are numeric or string.
 *
 *  As igraph is more forgiving about attribute names, it might
 * be necessary to simplify the them before writing to the GML file.
 * This way we'll have a syntactically correct GML file. The following
 * simple procedure is performed on each attribute name: first the alphanumeric
 * characters are extracted, the others are ignored. Then if the first character
 * is not a letter then the attribute name is prefixed with igraph.
 * Note that this might result identical names for two attributes, igraph
 * does not check this.
 *
 *  The id vertex attribute is treated specially.
 * If the id argument is not 0 then it should be a numeric
 * vector with the vertex ids and the id vertex attribute is
 * ignored (if there is one). If id is 0 and there is a
 * numeric id vertex attribute that is used instead. If ids
 * are not specified in either way then the regular igraph vertex ids are used.
 *
 *  Note that whichever way vertex ids are specified, their
 * uniqueness is not checked.
 *
 *  If the graph has edge attributes named source
 * or target they're silently ignored. GML uses these attributes
 * to specify the edges, so we cannot write them to the file. Rename them
 * before calling this function if you want to preserve them.
 * \param graph The graph to write to the stream.
 * \param outstream The stream to write the file to.
 * \param id Either NULL or a numeric vector with the vertex ids.
 *        See details above.
 * \param creator An optional string to write to the stream in the creator line.
 *        If this is 0 then the current date and time is added.
 * \return Error code.
 *
 * Time complexity: should be proportional to the number of characters written
 * to the file.
 *
 * \sa \ref igraph_read_graph_gml() for reading GML files,
 * \ref igraph_read_graph_graphml() for a more modern format.
 *
 * \example examples/simple/gml.c
 */

int igraph_write_graph_gml(const igraph_t *graph, FILE *outstream,
                           const igraph_vector_t *id, const char *creator) {
    int ret;
    igraph_strvector_t gnames, vnames, enames;
    igraph_vector_t gtypes, vtypes, etypes;
    igraph_vector_t numv;
    igraph_strvector_t strv;
    igraph_vector_bool_t boolv;
    long int i;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);

    igraph_vector_t v_myid;
    const igraph_vector_t *myid = id;

    time_t curtime = time(0);
    char *timestr = ctime(&curtime);
    timestr[strlen(timestr) - 1] = '\0'; /* nicely remove \n */

    CHECK(fprintf(outstream,
                  "Creator \"igraph version %s %s\"\nVersion 1\ngraph\n[\n",
                  IGRAPH_VERSION, creator ? creator : timestr));

    IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
    IGRAPH_VECTOR_INIT_FINALLY(>ypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vtypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&etypes, 0);
    IGRAPH_CHECK(igraph_i_attribute_get_info(graph,
                 &gnames, >ypes,
                 &vnames, &vtypes,
                 &enames, &etypes));

    IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
    IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);

    /* Check whether there is an 'id' node attribute if the supplied is 0 */
    if (!id) {
        igraph_bool_t found = 0;
        for (i = 0; i < igraph_vector_size(&vtypes); i++) {
            char *n;
            igraph_strvector_get(&vnames, i, &n);
            if (!strcmp(n, "id") && VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
                found = 1; break;
            }
        }
        if (found) {
            IGRAPH_VECTOR_INIT_FINALLY(&v_myid, no_of_nodes);
            IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, "id",
                         igraph_vss_all(),
                         &v_myid));
            myid = &v_myid;
        }
    }

    /* directedness */
    CHECK(fprintf(outstream, "  directed %i\n", igraph_is_directed(graph) ? 1 : 0));

    /* Graph attributes first */
    for (i = 0; i < igraph_vector_size(>ypes); i++) {
        char *name, *newname;
        igraph_strvector_get(&gnames, i, &name);
        IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
        IGRAPH_FINALLY(igraph_free, newname);
        if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
            CHECK(fprintf(outstream, "  %s ", newname));
            CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
            CHECK(fputc('\n', outstream));
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
            char *s;
            IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
            igraph_strvector_get(&strv, 0, &s);
            CHECK(fprintf(outstream, "  %s \"%s\"\n", newname, s));
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
            IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
            CHECK(fprintf(outstream, "  %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
            IGRAPH_WARNING("A boolean graph attribute was converted to numeric");
        } else {
            IGRAPH_WARNING("A non-numeric, non-string, non-boolean graph attribute ignored");
        }
        IGRAPH_FREE(newname);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* Now come the vertices */
    for (i = 0; i < no_of_nodes; i++) {
        long int j;
        CHECK(fprintf(outstream, "  node\n  [\n"));
        /* id */
        CHECK(fprintf(outstream, "    id %li\n", myid ? (long int)VECTOR(*myid)[i] : i));
        /* other attributes */
        for (j = 0; j < igraph_vector_size(&vtypes); j++) {
            int type = (int) VECTOR(vtypes)[j];
            char *name, *newname;
            igraph_strvector_get(&vnames, j, &name);
            if (!strcmp(name, "id")) {
                continue;
            }
            IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
            IGRAPH_FINALLY(igraph_free, newname);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
                             igraph_vss_1((igraph_integer_t) i), &numv));
                CHECK(fprintf(outstream, "    %s ", newname));
                CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
                CHECK(fputc('\n', outstream));
            } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                char *s;
                IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
                             igraph_vss_1((igraph_integer_t) i), &strv));
                igraph_strvector_get(&strv, 0, &s);
                CHECK(fprintf(outstream, "    %s \"%s\"\n", newname, s));
            } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
                             igraph_vss_1((igraph_integer_t) i), &boolv));
                CHECK(fprintf(outstream, "    %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
                IGRAPH_WARNING("A boolean vertex attribute was converted to numeric");
            } else {
                IGRAPH_WARNING("A non-numeric, non-string, non-boolean edge attribute was ignored");
            }
            IGRAPH_FREE(newname);
            IGRAPH_FINALLY_CLEAN(1);
        }
        CHECK(fprintf(outstream, "  ]\n"));
    }

    /* The edges too */
    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);
        long int j;
        CHECK(fprintf(outstream, "  edge\n  [\n"));
        /* source and target */
        CHECK(fprintf(outstream, "    source %li\n",
                      myid ? (long int)VECTOR(*myid)[from] : from));
        CHECK(fprintf(outstream, "    target %li\n",
                      myid ? (long int)VECTOR(*myid)[to] : to));

        /* other attributes */
        for (j = 0; j < igraph_vector_size(&etypes); j++) {
            int type = (int) VECTOR(etypes)[j];
            char *name, *newname;
            igraph_strvector_get(&enames, j, &name);
            if (!strcmp(name, "source") || !strcmp(name, "target")) {
                continue;
            }
            IGRAPH_CHECK(igraph_i_gml_convert_to_key(name, &newname));
            IGRAPH_FINALLY(igraph_free, newname);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) i), &numv));
                CHECK(fprintf(outstream, "    %s ", newname));
                CHECK(igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]));
                CHECK(fputc('\n', outstream));
            } else if (type == IGRAPH_ATTRIBUTE_STRING) {
                char *s;
                IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) i), &strv));
                igraph_strvector_get(&strv, 0, &s);
                CHECK(fprintf(outstream, "    %s \"%s\"\n", newname, s));
            } else if (type == IGRAPH_ATTRIBUTE_BOOLEAN) {
                IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) i), &boolv));
                CHECK(fprintf(outstream, "    %s %d\n", newname, VECTOR(boolv)[0] ? 1 : 0));
                IGRAPH_WARNING("A boolean edge attribute was converted to numeric");
            } else {
                IGRAPH_WARNING("A non-numeric, non-string, non-boolean edge attribute was ignored");
            }
            IGRAPH_FREE(newname);
            IGRAPH_FINALLY_CLEAN(1);
        }
        CHECK(fprintf(outstream, "  ]\n"));
    }

    CHECK(fprintf(outstream, "]\n"));

    if (&v_myid == myid) {
        igraph_vector_destroy(&v_myid);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_bool_destroy(&boolv);
    igraph_strvector_destroy(&strv);
    igraph_vector_destroy(&numv);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(>ypes);
    igraph_strvector_destroy(&enames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&gnames);
    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

#undef CHECK
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/graphdb.c0000644000175100001710000000720500000000000022627 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_constructors.h"

#include "core/trie.h"

static int igraph_i_read_graph_graphdb_getword(FILE *instream) {
    int b1, b2;
    unsigned char c1, c2;
    b1 = fgetc(instream);
    b2 = fgetc(instream);
    if (b1 != EOF) {
        c1 = (unsigned char) b1; c2 = (unsigned char) b2;
        return c1 | (c2 << 8);
    } else {
        return -1;
    }
}

/**
 * \function igraph_read_graph_graphdb
 * \brief Read a graph in the binary graph database format.
 *
 * This is a binary format, used in the graph database
 * for isomorphism testing. From the (now defunct) graph database
 * homepage:
 * 
 *
 * \blockquote 
 * The graphs are stored in a compact binary format, one graph per
 * file. The file is composed of 16 bit words, which are represented
 * using the so-called little-endian convention, i.e. the least
 * significant byte of the word is stored first.
 *
 * 
 * Then, for each node, the file contains the list of edges coming
 * out of the node itself. The list is represented by a word encoding
 * its length, followed by a word for each edge, representing the
 * destination node of the edge. Node numeration is 0-based, so the
 * first node of the graph has index 0. \endblockquote
 *
 * 
 * Only unlabelled graphs are implemented.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream The stream to read from.
 * \param directed Logical scalar, whether to create a directed graph.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the
 * number of edges.
 *
 * \example examples/simple/igraph_read_graph_graphdb.c
 */

int igraph_read_graph_graphdb(igraph_t *graph, FILE *instream,
                              igraph_bool_t directed) {

    igraph_vector_t edges;
    long int nodes;
    long int i, j;
    igraph_bool_t end = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    nodes = igraph_i_read_graph_graphdb_getword(instream);
    if (nodes < 0) {
        IGRAPH_ERROR("Can't read from file", IGRAPH_EFILE);
    }
    for (i = 0; !end && i < nodes; i++) {
        long int len = igraph_i_read_graph_graphdb_getword(instream);
        if (len < 0) {
            end = 1;
            break;
        }
        for (j = 0; ! end && j < len; j++) {
            long int to = igraph_i_read_graph_graphdb_getword(instream);
            if (to < 0) {
                end = 1;
                break;
            }
            IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
        }
    }

    if (end) {
        IGRAPH_ERROR("Truncated graphdb file", IGRAPH_EFILE);
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) nodes,
                               directed));
    igraph_vector_destroy(&edges);

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/graphml.c0000644000175100001710000021276400000000000022662 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R package.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"
#include "igraph_attributes.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "core/math.h"
#include "core/trie.h"
#include "graph/attributes.h"
#include "internal/hacks.h" /* strcasecmp */

#include "config.h"

#include 
#include     /* isnan */
#include 
#include   /* va_start & co */

#define GRAPHML_NAMESPACE_URI "http://graphml.graphdrawing.org/xmlns"

#if HAVE_LIBXML == 1
#include 
#include 

xmlEntity blankEntityStruct = {
#ifndef XML_WITHOUT_CORBA
    0,
#endif
    XML_ENTITY_DECL,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    XML_EXTERNAL_GENERAL_PARSED_ENTITY,
    0,
    0,
    0,
    0,
    0,
    1
};

xmlEntityPtr blankEntity = &blankEntityStruct;

#define GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code) do {  \
        if (state->successful) {                                    \
            igraph_i_graphml_sax_handler_error(state, msg);           \
        }                                                           \
    } while (0)
#define GRAPHML_PARSE_ERROR(state, msg) \
    GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, IGRAPH_PARSEERROR)
#define RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code) do {  \
        GRAPHML_PARSE_ERROR_WITH_CODE(state, msg, code);            \
        return;                                                     \
    } while (1)
#define RETURN_GRAPHML_PARSE_ERROR(state, msg) do {           \
        GRAPHML_PARSE_ERROR(state, msg);                            \
        return;                                                     \
    } while (1)

/* TODO: proper error handling */

typedef struct igraph_i_graphml_attribute_record_t {
    const char *id;           /* GraphML id */
    enum { I_GRAPHML_BOOLEAN, I_GRAPHML_INTEGER, I_GRAPHML_LONG,
           I_GRAPHML_FLOAT, I_GRAPHML_DOUBLE, I_GRAPHML_STRING,
           I_GRAPHML_UNKNOWN_TYPE
         } type; /* GraphML type */
    union {
        igraph_real_t as_numeric;
        igraph_bool_t as_boolean;
        char* as_string;
    } default_value;   /* Default value of the attribute, if any */
    igraph_attribute_record_t record;
} igraph_i_graphml_attribute_record_t;

struct igraph_i_graphml_parser_state {
    enum { START, INSIDE_GRAPHML, INSIDE_GRAPH, INSIDE_NODE, INSIDE_EDGE,
           INSIDE_KEY, INSIDE_DEFAULT, INSIDE_DATA, FINISH, UNKNOWN, ERROR
         } st;
    igraph_t *g;
    igraph_trie_t node_trie;
    igraph_strvector_t edgeids;
    igraph_vector_t edgelist;
    igraph_vector_int_t prev_state_stack;
    unsigned int unknown_depth;
    int index;
    igraph_bool_t successful;
    igraph_bool_t edges_directed;
    igraph_trie_t v_names;
    igraph_vector_ptr_t v_attrs;
    igraph_trie_t e_names;
    igraph_vector_ptr_t e_attrs;
    igraph_trie_t g_names;
    igraph_vector_ptr_t g_attrs;
    igraph_i_graphml_attribute_record_t* current_attr_record;
    xmlChar *data_key;
    igraph_attribute_elemtype_t data_type;
    char *error_message;
    char *data_char;
    long int act_node;
    igraph_bool_t ignore_namespaces;
};

static void igraph_i_report_unhandled_attribute_target(const char* target,
        const char* file, int line) {
    igraph_warningf("Attribute target '%s' is not handled; ignoring corresponding "
                    "attribute specifications", file, line, 0, target);
}

static igraph_real_t igraph_i_graphml_parse_numeric(const char* char_data,
                                                    igraph_real_t default_value) {
    double result;

    if (char_data == 0) {
        return default_value;
    }

    if (sscanf(char_data, "%lf", &result) == 0) {
        return default_value;
    }

    return result;
}

static igraph_bool_t igraph_i_graphml_parse_boolean(const char* char_data,
                                                    igraph_bool_t default_value) {
    int value;
    if (char_data == 0) {
        return default_value;
    }
    if (!strcasecmp("true", char_data)) {
        return 1;
    }
    if (!strcasecmp("yes", char_data)) {
        return 1;
    }
    if (!strcasecmp("false", char_data)) {
        return 0;
    }
    if (!strcasecmp("no", char_data)) {
        return 0;
    }
    if (sscanf(char_data, "%d", &value) == 0) {
        return default_value;
    }
    return value != 0;
}

static void igraph_i_graphml_attribute_record_destroy(igraph_i_graphml_attribute_record_t* rec) {
    if (rec->record.type == IGRAPH_ATTRIBUTE_NUMERIC) {
        if (rec->record.value != 0) {
            igraph_vector_destroy((igraph_vector_t*)rec->record.value);
            IGRAPH_FREE(rec->record.value);
        }
    } else if (rec->record.type == IGRAPH_ATTRIBUTE_STRING) {
        if (rec->record.value != 0) {
            igraph_strvector_destroy((igraph_strvector_t*)rec->record.value);
            IGRAPH_FREE(rec->record.value);
        }
        if (rec->default_value.as_string != 0) {
            IGRAPH_FREE(rec->default_value.as_string);
        }
    } else if (rec->record.type == IGRAPH_ATTRIBUTE_BOOLEAN) {
        if (rec->record.value != 0) {
            igraph_vector_bool_destroy((igraph_vector_bool_t*)rec->record.value);
            IGRAPH_FREE(rec->record.value);
        }
    }
    if (rec->id != 0) {
        IGRAPH_FREE(rec->id);
    }
    if (rec->record.name != 0) {
        IGRAPH_FREE(rec->record.name);
    }
}

static int igraph_i_graphml_parser_state_init(struct igraph_i_graphml_parser_state* state, igraph_t* graph, int index) {
    memset(state, 0, sizeof(struct igraph_i_graphml_parser_state));

    state->g = graph;
    state->index = index < 0 ? 0 : index;
    state->successful = 1;
    state->error_message = NULL;

    IGRAPH_CHECK(igraph_vector_int_init(&state->prev_state_stack, 0));
    IGRAPH_CHECK(igraph_vector_int_reserve(&state->prev_state_stack, 32));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &state->prev_state_stack);

    IGRAPH_CHECK(igraph_vector_ptr_init(&state->v_attrs, 0));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->v_attrs,
                                          igraph_i_graphml_attribute_record_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->v_attrs);

    IGRAPH_CHECK(igraph_vector_ptr_init(&state->e_attrs, 0));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->e_attrs,
                                          igraph_i_graphml_attribute_record_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->e_attrs);

    IGRAPH_CHECK(igraph_vector_ptr_init(&state->g_attrs, 0));
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&state->g_attrs,
                                          igraph_i_graphml_attribute_record_destroy);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &state->g_attrs);

    IGRAPH_CHECK(igraph_vector_init(&state->edgelist, 0));
    IGRAPH_FINALLY(igraph_vector_destroy, &state->edgelist);

    IGRAPH_CHECK(igraph_trie_init(&state->node_trie, 1));
    IGRAPH_FINALLY(igraph_trie_destroy, &state->node_trie);

    IGRAPH_CHECK(igraph_strvector_init(&state->edgeids, 0));
    IGRAPH_FINALLY(igraph_strvector_destroy, &state->edgeids);

    IGRAPH_CHECK(igraph_trie_init(&state->v_names, 0));
    IGRAPH_FINALLY(igraph_trie_destroy, &state->v_names);

    IGRAPH_CHECK(igraph_trie_init(&state->e_names, 0));
    IGRAPH_FINALLY(igraph_trie_destroy, &state->e_names);

    IGRAPH_CHECK(igraph_trie_init(&state->g_names, 0));

    IGRAPH_FINALLY_CLEAN(9);

    return IGRAPH_SUCCESS;
}

static void igraph_i_graphml_parser_state_destroy(struct igraph_i_graphml_parser_state* state) {
    igraph_trie_destroy(&state->node_trie);
    igraph_strvector_destroy(&state->edgeids);
    igraph_trie_destroy(&state->v_names);
    igraph_trie_destroy(&state->e_names);
    igraph_trie_destroy(&state->g_names);
    igraph_vector_destroy(&state->edgelist);
    igraph_vector_int_destroy(&state->prev_state_stack);

    igraph_vector_ptr_destroy_all(&state->v_attrs);
    igraph_vector_ptr_destroy_all(&state->e_attrs);
    igraph_vector_ptr_destroy_all(&state->g_attrs);

    if (state->data_key) {
        free(state->data_key);
        state->data_key = NULL;
    }
    if (state->data_char) {
        free(state->data_char);
        state->data_char = NULL;
    }

    if (state->error_message) {
        free(state->error_message);
        state->error_message = NULL;
    }
}

static void igraph_i_graphml_sax_handler_error(void *state0, const char* msg, ...) {
    struct igraph_i_graphml_parser_state *state =
        (struct igraph_i_graphml_parser_state*)state0;
    const size_t max_error_message_length = 4096;

    va_list ap;

    va_start(ap, msg);

    if (state->error_message == 0) {
        /* ownership of state->error_message passed on immediately to
         * state so the state destructor is responsible for freeing it */
        state->error_message = IGRAPH_CALLOC(max_error_message_length, char);
    }

    state->successful = 0;
    state->st = ERROR;
    vsnprintf(state->error_message, max_error_message_length, msg, ap);

    va_end(ap);
}

static xmlEntityPtr igraph_i_graphml_sax_handler_get_entity(void *state0,
        const xmlChar* name) {
    xmlEntityPtr predef = xmlGetPredefinedEntity(name);
    IGRAPH_UNUSED(state0);
    if (predef != NULL) {
        return predef;
    }
    IGRAPH_WARNING("unknown XML entity found\n");
    return blankEntity;
}

static void igraph_i_graphml_handle_unknown_start_tag(struct igraph_i_graphml_parser_state *state) {
    if (state->st != UNKNOWN) {
        igraph_vector_int_push_back(&state->prev_state_stack, state->st);
        state->st = UNKNOWN;
        state->unknown_depth = 1;
    } else {
        state->unknown_depth++;
    }
}

static void igraph_i_graphml_sax_handler_start_document(void *state0) {
    struct igraph_i_graphml_parser_state *state =
        (struct igraph_i_graphml_parser_state*)state0;

    state->st = START;
    state->successful = 1;
    state->edges_directed = 0;
    state->data_key = NULL;
    state->data_char = NULL;
    state->unknown_depth = 0;
    state->ignore_namespaces = 0;
}

static int igraph_i_graphml_parser_state_finish_parsing(struct igraph_i_graphml_parser_state *state) {
    long i, l;
    igraph_attribute_record_t idrec, eidrec;
    const char *idstr = "id";
    igraph_bool_t already_has_vertex_id = 0, already_has_edge_id = 0;
    igraph_vector_ptr_t vattr, eattr, gattr;
    long int esize;
    const void **tmp;

    IGRAPH_ASSERT(state->successful);

    /* check that we have found and parsed the graph the user is interested in */
    IGRAPH_ASSERT(state->index < 0);

    IGRAPH_CHECK(igraph_vector_ptr_init(&vattr, igraph_vector_ptr_size(&state->v_attrs) + 1));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vattr);

    esize = igraph_vector_ptr_size(&state->e_attrs);
    if (igraph_strvector_size(&state->edgeids) != 0) {
        esize++;
    }
    IGRAPH_CHECK(igraph_vector_ptr_init(&eattr, esize));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &eattr);

    IGRAPH_CHECK(igraph_vector_ptr_init(&gattr, igraph_vector_ptr_size(&state->g_attrs)));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy, &gattr);

    for (i = 0; i < igraph_vector_ptr_size(&state->v_attrs); i++) {
        igraph_i_graphml_attribute_record_t *graphmlrec =
            VECTOR(state->v_attrs)[i];
        igraph_attribute_record_t *rec = &graphmlrec->record;

        /* Check that the name of the vertex attribute is not 'id'.
        If it is then we cannot the complimentary 'id' attribute. */
        if (! strcmp(rec->name, idstr)) {
            already_has_vertex_id = 1;
        }

        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*)rec->value;
            long int origsize = igraph_vector_size(vec);
            long int nodes = igraph_trie_size(&state->node_trie);
            IGRAPH_CHECK(igraph_vector_resize(vec, nodes));
            for (l = origsize; l < nodes; l++) {
                VECTOR(*vec)[l] = graphmlrec->default_value.as_numeric;
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t*)rec->value;
            long int origsize = igraph_strvector_size(strvec);
            long int nodes = igraph_trie_size(&state->node_trie);
            IGRAPH_CHECK(igraph_strvector_resize(strvec, nodes));
            for (l = origsize; l < nodes; l++) {
                IGRAPH_CHECK(igraph_strvector_set(strvec, l, graphmlrec->default_value.as_string));
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            igraph_vector_bool_t *boolvec = (igraph_vector_bool_t*)rec->value;
            long int origsize = igraph_vector_bool_size(boolvec);
            long int nodes = igraph_trie_size(&state->node_trie);
            IGRAPH_CHECK(igraph_vector_bool_resize(boolvec, nodes));
            for (l = origsize; l < nodes; l++) {
                VECTOR(*boolvec)[l] = graphmlrec->default_value.as_boolean;
            }
        }
        VECTOR(vattr)[i] = rec;
    }
    if (!already_has_vertex_id) {
        idrec.name = idstr;
        idrec.type = IGRAPH_ATTRIBUTE_STRING;
        tmp = &idrec.value;
        IGRAPH_CHECK(igraph_trie_getkeys(&state->node_trie, (const igraph_strvector_t **)tmp));
        VECTOR(vattr)[i] = &idrec;
    } else {
        igraph_vector_ptr_pop_back(&vattr);
    }

    for (i = 0; i < igraph_vector_ptr_size(&state->e_attrs); i++) {
        igraph_i_graphml_attribute_record_t *graphmlrec =
            VECTOR(state->e_attrs)[i];
        igraph_attribute_record_t *rec = &graphmlrec->record;

        if (! strcmp(rec->name, idstr)) {
            already_has_edge_id = 1;
        }

        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*)rec->value;
            long int origsize = igraph_vector_size(vec);
            long int edges = igraph_vector_size(&state->edgelist) / 2;
            IGRAPH_CHECK(igraph_vector_resize(vec, edges));
            for (l = origsize; l < edges; l++) {
                VECTOR(*vec)[l] = graphmlrec->default_value.as_numeric;
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t*)rec->value;
            long int origsize = igraph_strvector_size(strvec);
            long int edges = igraph_vector_size(&state->edgelist) / 2;
            IGRAPH_CHECK(igraph_strvector_resize(strvec, edges));
            for (l = origsize; l < edges; l++) {
                IGRAPH_CHECK(igraph_strvector_set(strvec, l, graphmlrec->default_value.as_string));
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            igraph_vector_bool_t *boolvec = (igraph_vector_bool_t*)rec->value;
            long int origsize = igraph_vector_bool_size(boolvec);
            long int edges = igraph_vector_size(&state->edgelist) / 2;
            IGRAPH_CHECK(igraph_vector_bool_resize(boolvec, edges));
            for (l = origsize; l < edges; l++) {
                VECTOR(*boolvec)[l] = graphmlrec->default_value.as_boolean;
            }
        }
        VECTOR(eattr)[i] = rec;
    }
    if (igraph_strvector_size(&state->edgeids) != 0) {
        if (!already_has_edge_id) {
            long int origsize = igraph_strvector_size(&state->edgeids);
            eidrec.name = idstr;
            eidrec.type = IGRAPH_ATTRIBUTE_STRING;
            IGRAPH_CHECK(igraph_strvector_resize(&state->edgeids, igraph_vector_size(&state->edgelist) / 2));
            for (; origsize < igraph_strvector_size(&state->edgeids); origsize++) {
                IGRAPH_CHECK(igraph_strvector_set(&state->edgeids, origsize, ""));
            }
            eidrec.value = &state->edgeids;
            VECTOR(eattr)[(long int)igraph_vector_ptr_size(&eattr) - 1] = &eidrec;
        } else {
            igraph_vector_ptr_pop_back(&eattr);
            IGRAPH_WARNING("Could not add edge ids, "
                            "there is already an 'id' edge attribute");
        }
    }

    for (i = 0; i < igraph_vector_ptr_size(&state->g_attrs); i++) {
        igraph_i_graphml_attribute_record_t *graphmlrec =
            VECTOR(state->g_attrs)[i];
        igraph_attribute_record_t *rec = &graphmlrec->record;
        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*)rec->value;
            long int origsize = igraph_vector_size(vec);
            IGRAPH_CHECK(igraph_vector_resize(vec, 1));
            for (l = origsize; l < 1; l++) {
                VECTOR(*vec)[l] = graphmlrec->default_value.as_numeric;
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t*)rec->value;
            long int origsize = igraph_strvector_size(strvec);
            IGRAPH_CHECK(igraph_strvector_resize(strvec, 1));
            for (l = origsize; l < 1; l++) {
                IGRAPH_CHECK(igraph_strvector_set(strvec, l, graphmlrec->default_value.as_string));
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            igraph_vector_bool_t *boolvec = (igraph_vector_bool_t*)rec->value;
            long int origsize = igraph_vector_bool_size(boolvec);
            IGRAPH_CHECK(igraph_vector_bool_resize(boolvec, 1));
            for (l = origsize; l < 1; l++) {
                VECTOR(*boolvec)[l] = graphmlrec->default_value.as_boolean;
            }
        }
        VECTOR(gattr)[i] = rec;
    }

    IGRAPH_CHECK(igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr));
    IGRAPH_CHECK(igraph_add_vertices(state->g, (igraph_integer_t) igraph_trie_size(&state->node_trie), &vattr));
    IGRAPH_CHECK(igraph_add_edges(state->g, &state->edgelist, &eattr));

    igraph_vector_ptr_destroy(&vattr);
    igraph_vector_ptr_destroy(&eattr);
    igraph_vector_ptr_destroy(&gattr);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

#define toXmlChar(a)   (BAD_CAST(a))
#define fromXmlChar(a) ((char *)(a)) /* not the most elegant way... */

#define XML_ATTR_LOCALNAME(it) (*(it))
#define XML_ATTR_PREFIX(it) (*(it+1))
#define XML_ATTR_URI(it) (*(it+2))
#define XML_ATTR_VALUE_START(it) (*(it+3))
#define XML_ATTR_VALUE_END(it) (*(it+4))
#define XML_ATTR_VALUE(it) *(it+3), (*(it+4))-(*(it+3))

static igraph_i_graphml_attribute_record_t* igraph_i_graphml_add_attribute_key(
        const xmlChar** attrs, int nb_attrs,
        struct igraph_i_graphml_parser_state *state) {
    xmlChar **it;
    xmlChar *localname;
    igraph_trie_t *trie = NULL;
    igraph_vector_ptr_t *ptrvector = NULL;
    long int id;
    unsigned short int skip = 0;
    int i, ret;
    igraph_i_graphml_attribute_record_t *rec;

    if (!state->successful) {
        return 0;
    }

    rec = IGRAPH_CALLOC(1, igraph_i_graphml_attribute_record_t);
    if (rec == 0) {
        GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", IGRAPH_ENOMEM);
        return 0;
    }
    IGRAPH_FINALLY(igraph_free, rec);
    IGRAPH_FINALLY(igraph_i_graphml_attribute_record_destroy, rec);

    rec->type = I_GRAPHML_UNKNOWN_TYPE;

    for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
        if (XML_ATTR_URI(it) != 0 &&
            !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
            continue;
        }

        localname = XML_ATTR_LOCALNAME(it);

        if (xmlStrEqual(localname, toXmlChar("id"))) {
            rec->id = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
        } else if (xmlStrEqual(localname, toXmlChar("attr.name"))) {
            rec->record.name = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
        } else if (xmlStrEqual(localname, toXmlChar("attr.type"))) {
            if (!xmlStrncmp(toXmlChar("boolean"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_BOOLEAN;
                rec->record.type = IGRAPH_ATTRIBUTE_BOOLEAN;
                rec->default_value.as_boolean = 0;
            } else if (!xmlStrncmp(toXmlChar("string"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_STRING;
                rec->record.type = IGRAPH_ATTRIBUTE_STRING;
                rec->default_value.as_string = strdup("");
            } else if (!xmlStrncmp(toXmlChar("float"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_FLOAT;
                rec->record.type = IGRAPH_ATTRIBUTE_NUMERIC;
                rec->default_value.as_numeric = IGRAPH_NAN;
            } else if (!xmlStrncmp(toXmlChar("double"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_DOUBLE;
                rec->record.type = IGRAPH_ATTRIBUTE_NUMERIC;
                rec->default_value.as_numeric = IGRAPH_NAN;
            } else if (!xmlStrncmp(toXmlChar("int"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_INTEGER;
                rec->record.type = IGRAPH_ATTRIBUTE_NUMERIC;
                rec->default_value.as_numeric = IGRAPH_NAN;
            } else if (!xmlStrncmp(toXmlChar("long"), XML_ATTR_VALUE(it))) {
                rec->type = I_GRAPHML_LONG;
                rec->record.type = IGRAPH_ATTRIBUTE_NUMERIC;
                rec->default_value.as_numeric = IGRAPH_NAN;
            } else {
                GRAPHML_PARSE_ERROR(state,
                                    "Cannot parse GraphML file, unknown attribute type");
                return 0;
            }
        } else if (xmlStrEqual(*it, toXmlChar("for"))) {
            /* graph, vertex or edge attribute? */
            if (!xmlStrncmp(toXmlChar("graph"), XML_ATTR_VALUE(it))) {
                trie = &state->g_names;
                ptrvector = &state->g_attrs;
            } else if (!xmlStrncmp(toXmlChar("node"), XML_ATTR_VALUE(it))) {
                trie = &state->v_names;
                ptrvector = &state->v_attrs;
            } else if (!xmlStrncmp(toXmlChar("edge"), XML_ATTR_VALUE(it))) {
                trie = &state->e_names;
                ptrvector = &state->e_attrs;
            } else if (!xmlStrncmp(toXmlChar("graphml"), XML_ATTR_VALUE(it))) {
                igraph_i_report_unhandled_attribute_target("graphml", IGRAPH_FILE_BASENAME, __LINE__);
                skip = 1;
            } else if (!xmlStrncmp(toXmlChar("hyperedge"), XML_ATTR_VALUE(it))) {
                igraph_i_report_unhandled_attribute_target("hyperedge", IGRAPH_FILE_BASENAME, __LINE__);
                skip = 1;
            } else if (!xmlStrncmp(toXmlChar("port"), XML_ATTR_VALUE(it))) {
                igraph_i_report_unhandled_attribute_target("port", IGRAPH_FILE_BASENAME, __LINE__);
                skip = 1;
            } else if (!xmlStrncmp(toXmlChar("endpoint"), XML_ATTR_VALUE(it))) {
                igraph_i_report_unhandled_attribute_target("endpoint", IGRAPH_FILE_BASENAME, __LINE__);
                skip = 1;
            } else if (!xmlStrncmp(toXmlChar("all"), XML_ATTR_VALUE(it))) {
                /* TODO: we should handle this */
                igraph_i_report_unhandled_attribute_target("all", IGRAPH_FILE_BASENAME, __LINE__);
                skip = 1;
            } else {
                GRAPHML_PARSE_ERROR(state,
                                    "Cannot parse GraphML file, unknown value in the 'for' attribute of a  tag");
                return 0;
            }
        }
    }

    /* throw an error if there is no ID; this is a clear violation of the GraphML
     * DTD */
    if (rec->id == 0) {
        GRAPHML_PARSE_ERROR(state, "Found  tag with no 'id' attribute");
        return 0;
    }

    /* in case of a missing attr.name attribute, use the id as the attribute name */
    if (rec->record.name == 0) {
        rec->record.name = strdup(rec->id);
    }

    /* if the attribute type is missing, throw an error */
    if (!skip && rec->type == I_GRAPHML_UNKNOWN_TYPE) {
        igraph_warningf("Ignoring  because of a missing or unknown 'attr.type' attribute", IGRAPH_FILE_BASENAME, __LINE__, 0, rec->id);
        skip = 1;
    }

    /* if the value of the 'for' attribute was unknown, throw an error */
    if (!skip && trie == 0) {
        GRAPHML_PARSE_ERROR(state,
                            "Cannot parse GraphML file, missing 'for' attribute in a  tag");
        return 0;
    }

    /* if the code above requested skipping the attribute, free everything and
     * return */
    if (skip) {
        igraph_i_graphml_attribute_record_destroy(rec);
        igraph_free(rec);
        IGRAPH_FINALLY_CLEAN(2);
        return 0;
    }

    /* add to trie, attribues */
    igraph_trie_get(trie, rec->id, &id);
    if (id != igraph_trie_size(trie) - 1) {
        GRAPHML_PARSE_ERROR(state, "Cannot parse GraphML file, duplicate attribute");
        return 0;
    }

    ret = igraph_vector_ptr_push_back(ptrvector, rec);
    if (ret) {
        GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot read GraphML file", ret);
        return 0;
    }

    /* Ownership of 'rec' is now taken by ptrvector so we can clean the
     * finally stack */
    IGRAPH_FINALLY_CLEAN(2);  /* rec, destructor + igraph_free */

    /* create the attribute values */
    switch (rec->record.type) {
        igraph_vector_t *vec;
        igraph_vector_bool_t *boolvec;
        igraph_strvector_t *strvec;
    case IGRAPH_ATTRIBUTE_BOOLEAN:
        boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t);
        if (boolvec == 0) {
            GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", IGRAPH_ENOMEM);
            return 0;
        }
        rec->record.value = boolvec;
        igraph_vector_bool_init(boolvec, 0);
        break;
    case IGRAPH_ATTRIBUTE_NUMERIC:
        vec = IGRAPH_CALLOC(1, igraph_vector_t);
        if (vec == 0) {
            GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", IGRAPH_ENOMEM);
            return 0;
        }
        rec->record.value = vec;
        igraph_vector_init(vec, 0);
        break;
    case IGRAPH_ATTRIBUTE_STRING:
        strvec = IGRAPH_CALLOC(1, igraph_strvector_t);
        if (strvec == 0) {
            GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", IGRAPH_ENOMEM);
            return 0;
        }
        rec->record.value = strvec;
        igraph_strvector_init(strvec, 0);
        break;
    default: break;
    }

    return rec;
}

static void igraph_i_graphml_attribute_data_setup(struct igraph_i_graphml_parser_state *state,
                                                  const xmlChar **attrs,
                                                  int nb_attrs,
                                                  igraph_attribute_elemtype_t type) {
    xmlChar **it;
    int i;

    if (!state->successful) {
        return;
    }

    for (i = 0, it = (xmlChar**)attrs; i < nb_attrs; i++, it += 5) {
        if (XML_ATTR_URI(it) != 0 &&
            !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
            continue;
        }

        if (xmlStrEqual(*it, toXmlChar("key"))) {
            if (state->data_key) {
                free(state->data_key);
            }
            state->data_key = xmlStrndup(XML_ATTR_VALUE(it));
            if (state->data_char) {
                free(state->data_char);
            }
            state->data_char = NULL;
            state->data_type = type;
        } else {
            /* ignore */
        }
    }
}

static void igraph_i_graphml_append_to_data_char(struct igraph_i_graphml_parser_state *state,
                                                 const xmlChar *data, int len) {
    long int data_char_new_start = 0;

    if (!state->successful) {
        return;
    }

    if (state->data_char) {
        data_char_new_start = (long int) strlen(state->data_char);
        state->data_char = IGRAPH_REALLOC(state->data_char,
                                          (size_t)(data_char_new_start + len + 1), char);
    } else {
        state->data_char = IGRAPH_CALLOC((size_t) len + 1, char);
    }
    if (state->data_char == 0) {
        RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", IGRAPH_ENOMEM);
    }
    memcpy(state->data_char + data_char_new_start, data,
           (size_t) len * sizeof(xmlChar));
    state->data_char[data_char_new_start + len] = '\0';
}

static void igraph_i_graphml_attribute_data_finish(struct igraph_i_graphml_parser_state *state) {
    const char *key = fromXmlChar(state->data_key);
    igraph_attribute_elemtype_t type = state->data_type;
    igraph_trie_t *trie = NULL;
    igraph_vector_ptr_t *ptrvector = NULL;
    igraph_i_graphml_attribute_record_t *graphmlrec;
    igraph_attribute_record_t *rec;
    long int recid, id = 0;
    int ret;

    switch (type) {
    case IGRAPH_ATTRIBUTE_GRAPH:
        trie = &state->g_names;
        ptrvector = &state->g_attrs;
        id = 0;
        break;
    case IGRAPH_ATTRIBUTE_VERTEX:
        trie = &state->v_names;
        ptrvector = &state->v_attrs;
        id = state->act_node;
        break;
    case IGRAPH_ATTRIBUTE_EDGE:
        trie = &state->e_names;
        ptrvector = &state->e_attrs;
        id = igraph_vector_size(&state->edgelist) / 2 - 1; /* hack */
        break;
    default:
        /* impossible */
        break;
    }

    if (key == 0) {
        /* no key specified, issue a warning */
        IGRAPH_WARNING("missing attribute key in a  tag, ignoring attribute");
        IGRAPH_FREE(state->data_char);
        return;
    }

    igraph_trie_check(trie, key, &recid);
    if (recid < 0) {
        /* no such attribute key, issue a warning */
        igraph_warningf(
            "unknown attribute key '%s' in a  tag, ignoring attribute",
            IGRAPH_FILE_BASENAME, __LINE__, 0,
            key
        );
        IGRAPH_FREE(state->data_char);
        return;
    }

    graphmlrec = VECTOR(*ptrvector)[recid];
    rec = &graphmlrec->record;

    switch (rec->type) {
        igraph_vector_bool_t *boolvec;
        igraph_vector_t *vec;
        igraph_strvector_t *strvec;
        long int s, i;
        const char* strvalue;
    case IGRAPH_ATTRIBUTE_BOOLEAN:
        boolvec = (igraph_vector_bool_t *)rec->value;
        s = igraph_vector_bool_size(boolvec);
        if (id >= s) {
            ret = igraph_vector_bool_resize(boolvec, id + 1);
            if (ret) {
                RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", ret);
            }
            for (i = s; i < id; i++) {
                VECTOR(*boolvec)[i] = graphmlrec->default_value.as_boolean;
            }
        }
        VECTOR(*boolvec)[id] = igraph_i_graphml_parse_boolean(state->data_char,
                               graphmlrec->default_value.as_boolean);
        break;
    case IGRAPH_ATTRIBUTE_NUMERIC:
        vec = (igraph_vector_t *)rec->value;
        s = igraph_vector_size(vec);
        if (id >= s) {
            ret = igraph_vector_resize(vec, id + 1);
            if (ret) {
                RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", ret);
            }
            for (i = s; i < id; i++) {
                VECTOR(*vec)[i] = graphmlrec->default_value.as_numeric;
            }
        }
        VECTOR(*vec)[id] = igraph_i_graphml_parse_numeric(state->data_char,
                           graphmlrec->default_value.as_numeric);
        break;
    case IGRAPH_ATTRIBUTE_STRING:
        strvec = (igraph_strvector_t *)rec->value;
        s = igraph_strvector_size(strvec);
        if (id >= s) {
            ret = igraph_strvector_resize(strvec, id + 1);
            if (ret) {
                RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", ret);
            }
            strvalue = graphmlrec->default_value.as_string;
            for (i = s; i < id; i++) {
                igraph_strvector_set(strvec, i, strvalue);
            }
        }
        if (state->data_char) {
            strvalue = state->data_char;
        } else {
            strvalue = graphmlrec->default_value.as_string;
        }
        ret = igraph_strvector_set(strvec, id, strvalue);
        if (ret) {
            RETURN_GRAPHML_PARSE_ERROR_WITH_CODE(state, "Cannot parse GraphML file", ret);
        }
        break;
    default:
        break;
    }

    if (state->data_char) {
        IGRAPH_FREE(state->data_char);
    }
}

static void igraph_i_graphml_attribute_default_value_finish(
        struct igraph_i_graphml_parser_state *state) {
    igraph_i_graphml_attribute_record_t *graphmlrec = state->current_attr_record;

    if (graphmlrec == 0) {
        IGRAPH_FATAL(
            "state->current_attr_record was null where it should have been "
            "non-null; please report as a bug."
        );
        return;
    }

    if (state->data_char == 0) {
        return;
    }

    switch (graphmlrec->record.type) {
    case IGRAPH_ATTRIBUTE_BOOLEAN:
        graphmlrec->default_value.as_boolean = igraph_i_graphml_parse_boolean(
                state->data_char, 0);
        break;
    case IGRAPH_ATTRIBUTE_NUMERIC:
        graphmlrec->default_value.as_numeric = igraph_i_graphml_parse_numeric(
                state->data_char, IGRAPH_NAN);
        break;
    case IGRAPH_ATTRIBUTE_STRING:
        if (state->data_char) {
            if (graphmlrec->default_value.as_string != 0) {
                free(graphmlrec->default_value.as_string);
            }
            graphmlrec->default_value.as_string = strdup(state->data_char);
        }
        break;
    default:
        break;
    }

    if (state->data_char) {
        IGRAPH_FREE(state->data_char);
    }
}

static void igraph_i_graphml_sax_handler_start_element_ns(
        void *state0, const xmlChar* localname, const xmlChar* prefix,
        const xmlChar* uri, int nb_namespaces, const xmlChar** namespaces,
        int nb_attributes, int nb_defaulted, const xmlChar** attributes) {
    struct igraph_i_graphml_parser_state *state =
        (struct igraph_i_graphml_parser_state*)state0;
    xmlChar** it;
    char* attr_value;
    long int id1, id2;
    int i;
    igraph_bool_t tag_is_unknown = 0;

    IGRAPH_UNUSED(prefix);
    IGRAPH_UNUSED(nb_namespaces);
    IGRAPH_UNUSED(namespaces);
    IGRAPH_UNUSED(nb_defaulted);

    if (!state->successful) {
        return;
    }

    if (uri) {
        if (!xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), uri)) {
            /* Tag is in a different namespace, so treat it as an unknown start
             * tag irrespectively of our state */
            tag_is_unknown = 1;
        }
    } else {
        /* No namespace URI. If we are in lenient mode, accept it and proceed
         * as if we are in the GraphML namespace to handle lots of naive
         * non-namespace-aware GraphML files floating out there. If we are not
         * in lenient mode _but_ we are in the START state, accept it as well
         * and see whether the root tag is  (in which case we will
         * enter lenient mode). Otherwise, reject the tag */
        if (!state->ignore_namespaces && state->st != START) {
            tag_is_unknown = 1;
        }
    }

    if (tag_is_unknown) {
        igraph_i_graphml_handle_unknown_start_tag(state);
        return;
    }

    switch (state->st) {
    case START:
        /* If we are in the START state and received a graphml tag,
         * change to INSIDE_GRAPHML state. Otherwise, change to UNKNOWN. */
        if (xmlStrEqual(localname, toXmlChar("graphml"))) {
            if (uri == 0) {
                state->ignore_namespaces = 1;
            }
            state->st = INSIDE_GRAPHML;
        } else {
            igraph_i_graphml_handle_unknown_start_tag(state);
        }
        break;

    case INSIDE_GRAPHML:
        /* If we are in the INSIDE_GRAPHML state and received a graph tag,
         * change to INSIDE_GRAPH state if the state->index counter reached
         * zero (this is to handle multiple graphs in the same file).
         * Otherwise, change to UNKNOWN. */
        if (xmlStrEqual(localname, toXmlChar("graph"))) {
            if (state->index == 0) {
                state->st = INSIDE_GRAPH;
                for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
                    if (XML_ATTR_URI(it) != 0 &&
                        !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
                        /* Attribute is from a different namespace, so skip it */
                        continue;
                    }
                    if (xmlStrEqual(*it, toXmlChar("edgedefault"))) {
                        if (!xmlStrncmp(toXmlChar("directed"), XML_ATTR_VALUE(it))) {
                            state->edges_directed = 1;
                        } else if (!xmlStrncmp(toXmlChar("undirected"), XML_ATTR_VALUE(it))) {
                            state->edges_directed = 0;
                        }
                    }
                }
            }
            state->index--;
        } else if (xmlStrEqual(localname, toXmlChar("key"))) {
            state->current_attr_record =
                igraph_i_graphml_add_attribute_key(attributes, nb_attributes, state);
            state->st = INSIDE_KEY;
        } else {
            igraph_i_graphml_handle_unknown_start_tag(state);
        }
        break;

    case INSIDE_KEY:
        /* If we are in the INSIDE_KEY state and we are not skipping the current
         * attribute, check for default tag */
        if (state->current_attr_record != NULL && xmlStrEqual(localname, toXmlChar("default"))) {
            state->st = INSIDE_DEFAULT;
        } else {
            igraph_i_graphml_handle_unknown_start_tag(state);
        }
        break;

    case INSIDE_DEFAULT:
        /* If we are in the INSIDE_DEFAULT state, every further tag will be unknown */
        igraph_i_graphml_handle_unknown_start_tag(state);
        break;

    case INSIDE_GRAPH:
        /* If we are in the INSIDE_GRAPH state, check for node and edge tags */
        if (xmlStrEqual(localname, toXmlChar("edge"))) {
            id1 = -1; id2 = -1;
            for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
                if (XML_ATTR_URI(it) != 0 &&
                    !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
                    /* Attribute is from a different namespace, so skip it */
                    continue;
                }
                if (xmlStrEqual(*it, toXmlChar("source"))) {
                    attr_value = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
                    igraph_trie_get(&state->node_trie, attr_value, &id1);
                    free(attr_value);
                } else if (xmlStrEqual(*it, toXmlChar("target"))) {
                    attr_value = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
                    igraph_trie_get(&state->node_trie, attr_value, &id2);
                    free(attr_value);
                } else if (xmlStrEqual(*it, toXmlChar("id"))) {
                    long int edges = igraph_vector_size(&state->edgelist) / 2 + 1;
                    long int origsize = igraph_strvector_size(&state->edgeids);
                    attr_value = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
                    igraph_strvector_resize(&state->edgeids, edges);
                    for (; origsize < edges - 1; origsize++) {
                        igraph_strvector_set(&state->edgeids, origsize, "");
                    }
                    igraph_strvector_set(&state->edgeids, edges - 1, attr_value);
                    free(attr_value);
                }
            }
            if (id1 >= 0 && id2 >= 0) {
                igraph_vector_push_back(&state->edgelist, id1);
                igraph_vector_push_back(&state->edgelist, id2);
            } else {
                igraph_i_graphml_sax_handler_error(state, "Edge with missing source or target encountered");
                return;
            }
            state->st = INSIDE_EDGE;
        } else if (xmlStrEqual(localname, toXmlChar("node"))) {
            id1 = -1;
            for (i = 0, it = (xmlChar**)attributes; i < nb_attributes; i++, it += 5) {
                if (XML_ATTR_URI(it) != 0 &&
                    !xmlStrEqual(toXmlChar(GRAPHML_NAMESPACE_URI), XML_ATTR_URI(it))) {
                    /* Attribute is from a different namespace, so skip it */
                    continue;
                }
                if (xmlStrEqual(XML_ATTR_LOCALNAME(it), toXmlChar("id"))) {
                    attr_value = fromXmlChar(xmlStrndup(XML_ATTR_VALUE(it)));
                    igraph_trie_get(&state->node_trie, attr_value, &id1);
                    free(attr_value);
                    break;
                }
            }
            if (id1 >= 0) {
                state->act_node = id1;
            } else {
                state->act_node = -1;
                igraph_i_graphml_sax_handler_error(state, "Node with missing id encountered");
                return;
            }
            state->st = INSIDE_NODE;
        } else if (xmlStrEqual(localname, toXmlChar("data"))) {
            igraph_i_graphml_attribute_data_setup(state, attributes, nb_attributes,
                                                  IGRAPH_ATTRIBUTE_GRAPH);
            igraph_vector_int_push_back(&state->prev_state_stack, state->st);
            state->st = INSIDE_DATA;
        } else {
            igraph_i_graphml_handle_unknown_start_tag(state);
        }
        break;

    case INSIDE_NODE:
        if (xmlStrEqual(localname, toXmlChar("data"))) {
            igraph_i_graphml_attribute_data_setup(state, attributes, nb_attributes,
                                                  IGRAPH_ATTRIBUTE_VERTEX);
            igraph_vector_int_push_back(&state->prev_state_stack, state->st);
            state->st = INSIDE_DATA;
        }
        break;

    case INSIDE_EDGE:
        if (xmlStrEqual(localname, toXmlChar("data"))) {
            igraph_i_graphml_attribute_data_setup(state, attributes, nb_attributes,
                                                  IGRAPH_ATTRIBUTE_EDGE);
            igraph_vector_int_push_back(&state->prev_state_stack, state->st);
            state->st = INSIDE_DATA;
        }
        break;

    case INSIDE_DATA:
        /* We do not expect any new tags within a  tag */
        igraph_i_graphml_handle_unknown_start_tag(state);
        break;

    case UNKNOWN:
        igraph_i_graphml_handle_unknown_start_tag(state);
        break;

    default:
        break;
    }
}

static void igraph_i_graphml_sax_handler_end_element_ns(
        void *state0,
        const xmlChar* localname, const xmlChar* prefix,
        const xmlChar* uri) {
    struct igraph_i_graphml_parser_state *state =
        (struct igraph_i_graphml_parser_state*)state0;

    if (!state->successful) {
        return;
    }

    IGRAPH_UNUSED(localname);
    IGRAPH_UNUSED(prefix);
    IGRAPH_UNUSED(uri);

    switch (state->st) {
    case INSIDE_GRAPHML:
        state->st = FINISH;
        break;

    case INSIDE_GRAPH:
        state->st = INSIDE_GRAPHML;
        break;

    case INSIDE_KEY:
        state->current_attr_record = NULL;
        state->st = INSIDE_GRAPHML;
        break;

    case INSIDE_DEFAULT:
        igraph_i_graphml_attribute_default_value_finish(state);
        state->st = INSIDE_KEY;
        break;

    case INSIDE_NODE:
        state->st = INSIDE_GRAPH;
        break;

    case INSIDE_EDGE:
        state->st = INSIDE_GRAPH;
        break;

    case INSIDE_DATA:
        igraph_i_graphml_attribute_data_finish(state);
        state->st = igraph_vector_int_pop_back(&state->prev_state_stack);
        break;

    case UNKNOWN:
        state->unknown_depth--;
        if (!state->unknown_depth) {
            state->st = igraph_vector_int_pop_back(&state->prev_state_stack);
        }
        break;

    default:
        break;
    }
}

static void igraph_i_graphml_sax_handler_chars(void* state0, const xmlChar* ch, int len) {
    struct igraph_i_graphml_parser_state *state =
        (struct igraph_i_graphml_parser_state*)state0;

    if (!state->successful) {
        return;
    }

    switch (state->st) {
    case INSIDE_KEY:
        break;

    case INSIDE_DATA:
    case INSIDE_DEFAULT:
        igraph_i_graphml_append_to_data_char(state, ch, len);
        break;

    default:
        /* just ignore it */
        break;
    }
}

static xmlSAXHandler igraph_i_graphml_sax_handler = {
    /* internalSubset = */ 0,
    /* isStandalone = */ 0,
    /* hasInternalSubset = */ 0,
    /* hasExternalSubset = */ 0,
    /* resolveEntity = */ 0,
    /* getEntity = */ igraph_i_graphml_sax_handler_get_entity,
    /* entityDecl = */ 0,
    /* notationDecl = */ 0,
    /* attributeDecl = */ 0,
    /* elementDecl = */ 0,
    /* unparsedEntityDecl = */ 0,
    /* setDocumentLocator = */ 0,
    /* startDocument = */ igraph_i_graphml_sax_handler_start_document,
    /* endDocument = */ 0,
    /* startElement = */ 0,
    /* endElement = */ 0,
    /* reference = */ 0,
    /* characters = */ igraph_i_graphml_sax_handler_chars,
    /* ignorableWhitespaceFunc = */ 0,
    /* processingInstruction = */ 0,
    /* comment = */ 0,
    /* warning = */ igraph_i_graphml_sax_handler_error,
    /* error = */ igraph_i_graphml_sax_handler_error,
    /* fatalError = */ igraph_i_graphml_sax_handler_error,
    /* getParameterEntity = */ 0,
    /* cdataBlock = */ 0,
    /* externalSubset = */ 0,
    /* initialized = */ XML_SAX2_MAGIC,
    /* _private = */ 0,
    /* startElementNs = */ igraph_i_graphml_sax_handler_start_element_ns,
    /* endElementNs = */ igraph_i_graphml_sax_handler_end_element_ns,
    /* serror = */ 0
};

#endif

#define IS_FORBIDDEN_CONTROL_CHAR(x) ((x) < ' ' && (x) != '\t' && (x) != '\r' && (x) != '\n')

static int igraph_i_xml_escape(char* src, char** dest) {
    long int destlen = 0;
    char *s, *d;
    unsigned char ch;

    for (s = src; *s; s++, destlen++) {
        ch = (unsigned char)(*s);
        if (ch == '&') {
            destlen += 4;
        } else if (ch == '<') {
            destlen += 3;
        } else if (ch == '>') {
            destlen += 3;
        } else if (ch == '"') {
            destlen += 5;
        } else if (ch == '\'') {
            destlen += 5;
        } else if (IS_FORBIDDEN_CONTROL_CHAR(ch)) {
            char msg[4096];
            snprintf(msg, 4096, "Forbidden control character 0x%02X found in igraph_i_xml_escape",
                     ch);
            IGRAPH_ERROR(msg, IGRAPH_EINVAL);
        }
    }
    *dest = IGRAPH_CALLOC(destlen + 1, char);
    if (!*dest) {
        IGRAPH_ERROR("Not enough memory", IGRAPH_ENOMEM);
    }
    for (s = src, d = *dest; *s; s++, d++) {
        ch = (unsigned char)(*s);
        switch (ch) {
        case '&':
            strcpy(d, "&"); d += 4; break;
        case '<':
            strcpy(d, "<"); d += 3; break;
        case '>':
            strcpy(d, ">"); d += 3; break;
        case '"':
            strcpy(d, """); d += 5; break;
        case '\'':
            strcpy(d, "'"); d += 5; break;
        default:
            *d = ch;
        }
    }
    *d = 0;
    return 0;
}

/**
 * \ingroup loadsave
 * \function igraph_read_graph_graphml
 * \brief Reads a graph from a GraphML file.
 *
 * 
 * GraphML is an XML-based file format for representing various types of
 * graphs. Currently only the most basic import functionality is implemented
 * in igraph: it can read GraphML files without nested graphs and hyperedges.
 * Attributes of the graph are loaded only if an attribute interface
 * is attached, i.e. if you use igraph from R or Python.
 *
 * 
 * Graph attribute names are taken from the attr.name attributes of the
 * \c key tags in the GraphML file. Since attr.name is not mandatory,
 * igraph will fall back to the \c id attribute of the \c key tag if
 * attr.name is missing.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param instream A stream, it should be readable.
 * \param index If the GraphML file contains more than one graph, the one
 *              specified by this index will be loaded. Indices start from
 *              zero, so supply zero here if your GraphML file contains only
 *              a single graph.
 *
 * \return Error code:
 *         \c IGRAPH_PARSEERROR: if there is a
 *         problem reading the file, or the file is syntactically
 *         incorrect.
 *         \c IGRAPH_UNIMPLEMENTED: the GraphML functionality was disabled
 *         at compile-time
 *
 * \example examples/simple/graphml.c
 */
int igraph_read_graph_graphml(igraph_t *graph, FILE *instream, int index) {

#if HAVE_LIBXML == 1
    xmlParserCtxtPtr ctxt;
    struct igraph_i_graphml_parser_state state;
    int res;
    char buffer[4096];
    igraph_bool_t parsing_successful;
    char* error_message;

    if (index < 0) {
        IGRAPH_ERROR("Graph index must be non-negative", IGRAPH_EINVAL);
    }

    xmlInitParser();
    IGRAPH_CHECK(igraph_i_graphml_parser_state_init(&state, graph, index));
    IGRAPH_FINALLY(igraph_i_graphml_parser_state_destroy, &state);

    /* Create a progressive parser context */
    res = (int) fread(buffer, 1, 4096, instream);
    ctxt = xmlCreatePushParserCtxt(&igraph_i_graphml_sax_handler,
                                   &state,
                                   buffer,
                                   res,
                                   NULL);
    /*   ctxt=xmlCreateIOParserCtxt(&igraph_i_graphml_sax_handler, &state, */
    /*               igraph_i_libxml2_read_callback, */
    /*               igraph_i_libxml2_close_callback, */
    /*               instream, XML_CHAR_ENCODING_NONE); */
    if (ctxt == NULL) {
        IGRAPH_ERROR("Can't create progressive parser context", IGRAPH_PARSEERROR);
    }

    /* Set parsing options */
    if (xmlCtxtUseOptions(ctxt,
                          XML_PARSE_NOENT | XML_PARSE_NOBLANKS |
                          XML_PARSE_NONET | XML_PARSE_NSCLEAN |
                          XML_PARSE_NOCDATA | XML_PARSE_HUGE
                         )) {
        xmlFreeParserCtxt(ctxt);
        IGRAPH_ERROR("Cannot set options for the parser context", IGRAPH_EINVAL);
    }

    /* Okay, parsing will start now. The parser might do things that eventually
     * trigger the igraph error handler, but we want the parser state to
     * survive whatever happens here. So, we need to pop off
     * igraph_i_graphml_parser_state_destroy() from the stack and temporarily
     * assume responsibility for calling it ourselves until we are back from the
     * parser */
    IGRAPH_FINALLY_CLEAN(1);

    /* Do the parsing */
    while ((res = (int) fread(buffer, 1, 4096, instream)) > 0) {
        xmlParseChunk(ctxt, buffer, res, 0);
        if (!state.successful) {
            break;
        }
    }
    xmlParseChunk(ctxt, buffer, res, 1);

    /* Free the context */
    xmlFreeParserCtxt(ctxt);

    /* Extract the error message from the parser state (if any), and make a
     * copy so we can safely destroy the parser state before triggering the
     * error */
    parsing_successful = state.successful;
    error_message = parsing_successful || state.error_message == NULL ? NULL : strdup(state.error_message);

    /* Now that we have lifted error_message out of the parser state, we can
     * put the destructor of the parser state back on the FINALLY stack */
    IGRAPH_FINALLY(igraph_i_graphml_parser_state_destroy, &state);

    /* ...and we can also put the error message pointer on the FINALLY stack */
    if (error_message != NULL) {
        IGRAPH_FINALLY(free, error_message);
    }

    /* Trigger the stored error if needed */
    if (!parsing_successful) {
        if (error_message != NULL) {
            IGRAPH_ERROR(error_message, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Malformed GraphML file", IGRAPH_PARSEERROR);
        }
    }

    /* Did we actually manage to reach the graph to be parsed, given its index?
     * If not, that's an error as well. */
    if (state.index >= 0) {
        IGRAPH_ERROR("Graph index was too large", IGRAPH_EINVAL);
    }

    /* Okay, everything seems good. We can now take the parser state and
     * construct our graph from the data gathered during the parsing */
    IGRAPH_CHECK(igraph_i_graphml_parser_state_finish_parsing(&state));

    igraph_i_graphml_parser_state_destroy(&state);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
#else
    IGRAPH_UNUSED(graph);
    IGRAPH_UNUSED(instream);
    IGRAPH_UNUSED(index);

    IGRAPH_ERROR("GraphML support is disabled", IGRAPH_UNIMPLEMENTED);
#endif
}

/**
 * \ingroup loadsave
 * \function igraph_write_graph_graphml
 * \brief Writes the graph to a file in GraphML format
 *
 * 
 * GraphML is an XML-based file format for representing various types of
 * graphs. See the GraphML Primer (http://graphml.graphdrawing.org/primer/graphml-primer.html)
 * for detailed format description.
 *
 * \param graph The graph to write.
 * \param outstream The stream object to write to, it should be
 *        writable.
 * \param prefixattr Logical value, whether to put a prefix in front of the
 *        attribute names to ensure uniqueness if the graph has vertex and
 *        edge (or graph) attributes with the same name.
 * \return Error code:
 *         \c IGRAPH_EFILE if there is an error
 *         writing the file.
 *
 * Time complexity: O(|V|+|E|) otherwise. All
 * file operations are expected to have time complexity
 * O(1).
 *
 * \example examples/simple/graphml.c
 */
int igraph_write_graph_graphml(const igraph_t *graph, FILE *outstream,
                               igraph_bool_t prefixattr) {
    int ret;
    igraph_integer_t l, vc;
    igraph_eit_t it;
    igraph_strvector_t gnames, vnames, enames;
    igraph_vector_t gtypes, vtypes, etypes;
    long int i;
    igraph_vector_t numv;
    igraph_strvector_t strv;
    igraph_vector_bool_t boolv;
    const char *gprefix = prefixattr ? "g_" : "";
    const char *vprefix = prefixattr ? "v_" : "";
    const char *eprefix = prefixattr ? "e_" : "";

    /* set standard C locale lest we sometimes get commas instead of dots */
    char *saved_locale = strdup(setlocale(LC_NUMERIC, NULL));
    if (saved_locale == NULL) {
        IGRAPH_ERROR("Not enough memory", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, saved_locale);
    setlocale(LC_NUMERIC, "C");

    ret = fprintf(outstream, "\n");
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }
    ret = fprintf(outstream, "\n", GRAPHML_NAMESPACE_URI);
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }
    ret = fprintf(outstream, "\n");
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }

    /* dump the  elements if any */

    IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
    IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);
    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&boolv, 1);

    IGRAPH_STRVECTOR_INIT_FINALLY(&gnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&vnames, 0);
    IGRAPH_STRVECTOR_INIT_FINALLY(&enames, 0);
    IGRAPH_VECTOR_INIT_FINALLY(>ypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vtypes, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&etypes, 0);
    igraph_i_attribute_get_info(graph,
                                &gnames, >ypes,
                                &vnames, &vtypes,
                                &enames, &etypes);

    /* graph attributes */
    for (i = 0; i < igraph_vector_size(>ypes); i++) {
        char *name, *name_escaped;
        igraph_strvector_get(&gnames, i, &name);
        IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
        if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
            ret = fprintf(outstream, "  \n", gprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            ret = fprintf(outstream, "  \n", gprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
            ret = fprintf(outstream, "  \n", gprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        }
        IGRAPH_FREE(name_escaped);
    }

    /* vertex attributes */
    for (i = 0; i < igraph_vector_size(&vtypes); i++) {
        char *name, *name_escaped;
        igraph_strvector_get(&vnames, i, &name);
        IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
        if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
            ret = fprintf(outstream, "  \n", vprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            ret = fprintf(outstream, "  \n", vprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
            ret = fprintf(outstream, "  \n", vprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        }
        IGRAPH_FREE(name_escaped);
    }

    /* edge attributes */
    for (i = 0; i < igraph_vector_size(&etypes); i++) {
        char *name, *name_escaped;
        igraph_strvector_get(&enames, i, &name);
        IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
        if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
            ret = fprintf(outstream, "  \n", eprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            ret = fprintf(outstream, "  \n", eprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
            ret = fprintf(outstream, "  \n", eprefix, name_escaped, name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        }
        IGRAPH_FREE(name_escaped);
    }

    ret = fprintf(outstream, "  \n", (igraph_is_directed(graph) ? "directed" : "undirected"));
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }

    /* Write the graph atributes before anything else */

    for (i = 0; i < igraph_vector_size(>ypes); i++) {
        char *name, *name_escaped;
        if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_strvector_get(&gnames, i, &name);
            IGRAPH_CHECK(igraph_i_attribute_get_numeric_graph_attr(graph, name, &numv));
            if (!isnan(VECTOR(numv)[0])) {
                IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                ret = fprintf(outstream, "    ", gprefix, name_escaped);
                IGRAPH_FREE(name_escaped);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
                ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
                ret = fprintf(outstream, "\n");
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
            }
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
            char *s, *s_escaped;
            igraph_strvector_get(&gnames, i, &name);
            IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
            ret = fprintf(outstream, "    ", gprefix,
                          name_escaped);
            IGRAPH_FREE(name_escaped);
            IGRAPH_CHECK(igraph_i_attribute_get_string_graph_attr(graph, name, &strv));
            igraph_strvector_get(&strv, 0, &s);
            IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped));
            ret = fprintf(outstream, "%s", s_escaped);
            IGRAPH_FREE(s_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            ret = fprintf(outstream, "\n");
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        } else if (VECTOR(gtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
            igraph_strvector_get(&gnames, i, &name);
            IGRAPH_CHECK(igraph_i_attribute_get_bool_graph_attr(graph, name, &boolv));
            IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
            ret = fprintf(outstream, "    %s\n",
                          gprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
            IGRAPH_FREE(name_escaped);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        }
    }

    /* Let's dump the nodes first */
    vc = igraph_vcount(graph);
    for (l = 0; l < vc; l++) {
        char *name, *name_escaped;
        ret = fprintf(outstream, "    \n", (long)l);

        if (ret < 0) {
            IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
        }

        for (i = 0; i < igraph_vector_size(&vtypes); i++) {
            if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_strvector_get(&vnames, i, &name);
                IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(graph, name,
                             igraph_vss_1(l), &numv));
                if (!isnan(VECTOR(numv)[0])) {
                    IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                    ret = fprintf(outstream, "      ", vprefix, name_escaped);
                    IGRAPH_FREE(name_escaped);
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                    ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                    ret = fprintf(outstream, "\n");
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                }
            } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
                char *s, *s_escaped;
                igraph_strvector_get(&vnames, i, &name);
                IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                ret = fprintf(outstream, "      ", vprefix,
                              name_escaped);
                IGRAPH_FREE(name_escaped);
                IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, name,
                             igraph_vss_1(l), &strv));
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped));
                ret = fprintf(outstream, "%s", s_escaped);
                IGRAPH_FREE(s_escaped);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
                ret = fprintf(outstream, "\n");
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
            } else if (VECTOR(vtypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
                igraph_strvector_get(&vnames, i, &name);
                IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph, name,
                             igraph_vss_1(l), &boolv));
                IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                ret = fprintf(outstream, "      %s\n",
                              vprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
                IGRAPH_FREE(name_escaped);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
            }
        }

        ret = fprintf(outstream, "    \n");
        if (ret < 0) {
            IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
        }
    }

    /* Now the edges */
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);
    while (!IGRAPH_EIT_END(it)) {
        igraph_integer_t from, to;
        char *name, *name_escaped;
        long int edge = IGRAPH_EIT_GET(it);
        igraph_edge(graph, (igraph_integer_t) edge, &from, &to);
        ret = fprintf(outstream, "    \n",
                      (long int)from, (long int)to);
        if (ret < 0) {
            IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
        }

        for (i = 0; i < igraph_vector_size(&etypes); i++) {
            if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_strvector_get(&enames, i, &name);
                IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) edge), &numv));
                if (!isnan(VECTOR(numv)[0])) {
                    IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                    ret = fprintf(outstream, "      ", eprefix, name_escaped);
                    IGRAPH_FREE(name_escaped);
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                    ret = igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                    ret = fprintf(outstream, "\n");
                    if (ret < 0) {
                        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                    }
                }
            } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_STRING) {
                char *s, *s_escaped;
                igraph_strvector_get(&enames, i, &name);
                IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                ret = fprintf(outstream, "      ", eprefix,
                              name_escaped);
                IGRAPH_FREE(name_escaped);
                IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) edge), &strv));
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_xml_escape(s, &s_escaped));
                ret = fprintf(outstream, "%s", s_escaped);
                IGRAPH_FREE(s_escaped);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
                ret = fprintf(outstream, "\n");
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
            } else if (VECTOR(etypes)[i] == IGRAPH_ATTRIBUTE_BOOLEAN) {
                igraph_strvector_get(&enames, i, &name);
                IGRAPH_CHECK(igraph_i_attribute_get_bool_edge_attr(graph, name,
                             igraph_ess_1((igraph_integer_t) edge), &boolv));
                IGRAPH_CHECK(igraph_i_xml_escape(name, &name_escaped));
                ret = fprintf(outstream, "      %s\n",
                              eprefix, name_escaped, VECTOR(boolv)[0] ? "true" : "false");
                IGRAPH_FREE(name_escaped);
                if (ret < 0) {
                    IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
                }
            }
        }

        ret = fprintf(outstream, "    \n");
        if (ret < 0) {
            IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
        }
        IGRAPH_EIT_NEXT(it);
    }
    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);

    ret = fprintf(outstream, "  \n");
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }
    fprintf(outstream, "\n");
    if (ret < 0) {
        IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
    }

    /* reset locale to whatever was before this function */
    setlocale(LC_NUMERIC, saved_locale);

    igraph_free(saved_locale);
    igraph_strvector_destroy(&gnames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&enames);
    igraph_vector_destroy(>ypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&numv);
    igraph_strvector_destroy(&strv);
    igraph_vector_bool_destroy(&boolv);
    IGRAPH_FINALLY_CLEAN(10);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/leda.c0000644000175100001710000002336100000000000022126 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"

#include "graph/attributes.h"

#include 

#define CHECK(cmd) do { ret=cmd; if (ret<0) IGRAPH_ERROR("Write failed", IGRAPH_EFILE); } while (0)

/**
 * \function igraph_write_graph_leda
 * \brief Write a graph in LEDA native graph format.
 *
 * This function writes a graph to an output stream in LEDA format.
 * See http://www.algorithmic-solutions.info/leda_guide/graphs/leda_native_graph_fileformat.html
 *
 * 
 * The support for the LEDA format is very basic at the moment; igraph
 * writes only the LEDA graph section which supports one selected vertex
 * and edge attribute and no layout information or visual attributes.
 *
 * \param graph The graph to write to the stream.
 * \param outstream The stream.
 * \param vertex_attr_name The name of the vertex attribute whose values
 *                         are to be stored in the output or \c NULL if no
 *                         vertex attribute has to be stored.
 * \param edge_attr_name   The name of the edge attribute whose values
 *                         are to be stored in the output or \c NULL if no
 *                         edge attribute has to be stored.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of vertices and edges in the
 * graph.
 *
 * \example examples/simple/igraph_write_graph_leda.c
 */

int igraph_write_graph_leda(const igraph_t *graph, FILE *outstream,
                            const char* vertex_attr_name,
                            const char* edge_attr_name) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_eit_t it;
    long int i = 0;
    int ret;
    igraph_attribute_type_t vertex_attr_type = IGRAPH_ATTRIBUTE_DEFAULT;
    igraph_attribute_type_t edge_attr_type = IGRAPH_ATTRIBUTE_DEFAULT;
    igraph_integer_t from, to, rev;

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
                                   &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);

    /* Check if we have the vertex attribute */
    if (vertex_attr_name &&
        !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name)) {
        vertex_attr_name = 0;
        IGRAPH_WARNING("specified vertex attribute does not exist");
    }
    if (vertex_attr_name) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &vertex_attr_type,
                                                IGRAPH_ATTRIBUTE_VERTEX, vertex_attr_name));
        if (vertex_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
            vertex_attr_type != IGRAPH_ATTRIBUTE_STRING) {
            vertex_attr_name = 0; vertex_attr_type = IGRAPH_ATTRIBUTE_DEFAULT;
            IGRAPH_WARNING("specified vertex attribute must be numeric or string");
        }
    }

    /* Check if we have the edge attribute */
    if (edge_attr_name &&
        !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, edge_attr_name)) {
        edge_attr_name = 0;
        IGRAPH_WARNING("specified edge attribute does not exist");
    }
    if (edge_attr_name) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &edge_attr_type,
                                                IGRAPH_ATTRIBUTE_EDGE, edge_attr_name));
        if (edge_attr_type != IGRAPH_ATTRIBUTE_NUMERIC &&
            edge_attr_type != IGRAPH_ATTRIBUTE_STRING) {
            edge_attr_name = 0; edge_attr_type = IGRAPH_ATTRIBUTE_DEFAULT;
            IGRAPH_WARNING("specified edge attribute must be numeric or string");
        }
    }

    /* Start writing header */
    CHECK(fprintf(outstream, "LEDA.GRAPH\n"));

    switch (vertex_attr_type) {
    case IGRAPH_ATTRIBUTE_NUMERIC:
        CHECK(fprintf(outstream, "float\n"));
        break;
    case IGRAPH_ATTRIBUTE_STRING:
        CHECK(fprintf(outstream, "string\n"));
        break;
    default:
        CHECK(fprintf(outstream, "void\n"));
    }

    switch (edge_attr_type) {
    case IGRAPH_ATTRIBUTE_NUMERIC:
        CHECK(fprintf(outstream, "float\n"));
        break;
    case IGRAPH_ATTRIBUTE_STRING:
        CHECK(fprintf(outstream, "string\n"));
        break;
    default:
        CHECK(fprintf(outstream, "void\n"));
    }

    CHECK(fprintf(outstream, "%d\n", (igraph_is_directed(graph) ? -1 : -2)));

    /* Start writing vertices */
    CHECK(fprintf(outstream, "# Vertices\n"));
    CHECK(fprintf(outstream, "%ld\n", no_of_nodes));

    if (vertex_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
        /* Vertices with numeric attributes */
        igraph_vector_t values;

        IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
        IGRAPH_CHECK(igraph_i_attribute_get_numeric_vertex_attr(
                         graph, vertex_attr_name, igraph_vss_all(), &values));

        for (i = 0; i < no_of_nodes; i++) {
            CHECK(fprintf(outstream, "|{"));
            CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[i]));
            CHECK(fprintf(outstream, "}|\n"));
        }

        igraph_vector_destroy(&values);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (vertex_attr_type == IGRAPH_ATTRIBUTE_STRING) {
        /* Vertices with string attributes */
        igraph_strvector_t values;

        IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
        IGRAPH_FINALLY(igraph_strvector_destroy, &values);

        IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(
                         graph, vertex_attr_name, igraph_vss_all(), &values));

        for (i = 0; i < no_of_nodes; i++) {
            const char* str = STR(values, i);
            if (strchr(str, '\n') != 0) {
                IGRAPH_ERROR("edge attribute values cannot contain newline characters",
                             IGRAPH_EINVAL);
            }
            CHECK(fprintf(outstream, "|{%s}|\n", str));
        }

        igraph_strvector_destroy(&values);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Vertices with no attributes */
        for (i = 0; i < no_of_nodes; i++) {
            CHECK(fprintf(outstream, "|{}|\n"));
        }
    }

    CHECK(fprintf(outstream, "# Edges\n"));
    CHECK(fprintf(outstream, "%ld\n", no_of_edges));

    if (edge_attr_type == IGRAPH_ATTRIBUTE_NUMERIC) {
        /* Edges with numeric attributes */
        igraph_vector_t values;
        IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
        IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(
                         graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
        while (!IGRAPH_EIT_END(it)) {
            long int eid = IGRAPH_EIT_GET(it);
            igraph_edge(graph, (igraph_integer_t) eid, &from, &to);
            igraph_get_eid(graph, &rev, to, from, 1, 0);
            if (rev == IGRAPH_EIT_GET(it)) {
                rev = -1;
            }
            CHECK(fprintf(outstream, "%ld %ld %ld |{",
                          (long int) from + 1, (long int) to + 1,
                          (long int) rev + 1));
            CHECK(igraph_real_fprintf_precise(outstream, VECTOR(values)[eid]));
            CHECK(fprintf(outstream, "}|\n"));
            IGRAPH_EIT_NEXT(it);
        }
        igraph_vector_destroy(&values);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (edge_attr_type == IGRAPH_ATTRIBUTE_STRING) {
        /* Edges with string attributes */
        igraph_strvector_t values;
        IGRAPH_CHECK(igraph_strvector_init(&values, no_of_nodes));
        IGRAPH_FINALLY(igraph_strvector_destroy, &values);
        IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(
                         graph, edge_attr_name, igraph_ess_all(IGRAPH_EDGEORDER_ID), &values));
        while (!IGRAPH_EIT_END(it)) {
            long int eid = IGRAPH_EIT_GET(it);
            const char* str = STR(values, eid);
            igraph_edge(graph, (igraph_integer_t) eid, &from, &to);
            igraph_get_eid(graph, &rev, to, from, 1, 0);
            if (rev == IGRAPH_EIT_GET(it)) {
                rev = -1;
            }
            if (strchr(str, '\n') != 0) {
                IGRAPH_ERROR("edge attribute values cannot contain newline characters",
                             IGRAPH_EINVAL);
            }
            CHECK(fprintf(outstream, "%ld %ld %ld |{%s}|\n",
                          (long int) from + 1, (long int) to + 1,
                          (long int) rev + 1, str));
            IGRAPH_EIT_NEXT(it);
        }
        igraph_strvector_destroy(&values);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Edges with no attributes */
        while (!IGRAPH_EIT_END(it)) {
            igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to);
            igraph_get_eid(graph, &rev, to, from, 1, 0);
            if (rev == IGRAPH_EIT_GET(it)) {
                rev = -1;
            }
            CHECK(fprintf(outstream, "%ld %ld %ld |{}|\n",
                          (long int) from + 1, (long int) to + 1,
                          (long int) rev + 1));
            IGRAPH_EIT_NEXT(it);
        }
    }

    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

#undef CHECK
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/lgl-header.h0000644000175100001710000000220300000000000023222 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_vector.h"

#include "core/trie.h"

typedef struct {
    void *scanner;
    int eof;
    char errmsg[300];
    int has_weights;
    igraph_vector_t *vector;
    igraph_vector_t *weights;
    igraph_trie_t *trie;
    int actvertex;
} igraph_i_lgl_parsedata_t;
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/lgl-lexer.l0000644000175100001710000000566000000000000023127 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/lgl-header.h"
#include "io/parsers/lgl-parser.h"

#define YY_EXTRA_TYPE igraph_i_lgl_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
%}

%option noyywrap
%option prefix="igraph_lgl_yy"
%option nounput
%option noinput
%option nodefault
%option reentrant
%option bison-bridge
%option bison-locations

alnum [^ \t\r\n\0#]

%%

 /* --------------------------------------------------hashmark------*/
#                    { return HASH; }

 /* ------------------------------------------------whitespace------*/
[ \t]+               { }

 /* ---------------------------------------------------newline------*/
\n\r|\r\n|\n|\r      { return NEWLINE; }

 /* ----------------------------------------------alphanumeric------*/
{alnum}+             { return ALNUM; }

<>           { if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }

.                 { return ERROR; }

%%
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/lgl-parser.y0000644000175100001710000001032100000000000023307 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include "core/math.h"
#include "io/lgl-header.h"
#include "io/parsers/lgl-parser.h"
#include "io/parsers/lgl-lexer.h"
#include "internal/hacks.h"

int igraph_lgl_yyerror(YYLTYPE* locp, igraph_i_lgl_parsedata_t *context,
                       const char *s);
igraph_real_t igraph_lgl_get_number(const char *str, long int len);

#define scanner context->scanner
%}

%pure-parser
/* bison: do not remove the equals sign; macOS XCode ships with bison 2.3, which
 * needs the equals sign */
%name-prefix="igraph_lgl_yy"
%defines
%locations
%error-verbose
%parse-param { igraph_i_lgl_parsedata_t* context }
%lex-param { void *scanner }

%union {
  long int edgenum;
  double weightnum;
}

%type    edgeid
%type  weight

%token ALNUM
%token NEWLINE
%token HASH
%token ERROR

%%

input :    /* empty */
         | input NEWLINE
         | input vertex
;

vertex : vertexdef edges ;

vertexdef : HASH edgeid NEWLINE       { context->actvertex=$2; } ;

edges :   /* empty */ | edges edge ;

edge :   edgeid NEWLINE             {
             igraph_vector_push_back(context->vector, context->actvertex);
             igraph_vector_push_back(context->vector, $1);
             igraph_vector_push_back(context->weights, 0);
           }
       | edgeid weight NEWLINE      {
             igraph_vector_push_back(context->vector, context->actvertex);
             igraph_vector_push_back(context->vector, $1);
             igraph_vector_push_back(context->weights, $2);
             context->has_weights = 1;
           }
;


edgeid : ALNUM  { igraph_trie_get2(context->trie,
                                   igraph_lgl_yyget_text(scanner),
                                   igraph_lgl_yyget_leng(scanner),
                                   &$$); };

weight : ALNUM  { $$=igraph_lgl_get_number(igraph_lgl_yyget_text(scanner),
                                           igraph_lgl_yyget_leng(scanner)); } ;

%%

int igraph_lgl_yyerror(YYLTYPE* locp, igraph_i_lgl_parsedata_t *context,
                       const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char),
           "Parse error in LGL file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

igraph_real_t igraph_lgl_get_number(const char *str, long int length) {
  igraph_real_t num;
  char *tmp=IGRAPH_CALLOC(length+1, char);

  strncpy(tmp, str, length);
  tmp[length]='\0';
  sscanf(tmp, "%lf", &num);
  IGRAPH_FREE(tmp);
  return num;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/lgl.c0000644000175100001710000003651200000000000022001 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_interface.h"

#include "graph/attributes.h"

#include "lgl-header.h"

int igraph_lgl_yylex_init_extra (igraph_i_lgl_parsedata_t* user_defined,
                                 void* scanner);
void igraph_lgl_yylex_destroy (void *scanner );
int igraph_lgl_yyparse (igraph_i_lgl_parsedata_t* context);
void igraph_lgl_yyset_in  (FILE * in_str, void* yyscanner );

/**
 * \ingroup loadsave
 * \function igraph_read_graph_lgl
 * \brief Reads a graph from an .lgl file
 *
 * 
 * The .lgl format is used by the Large Graph
 * Layout visualization software
 * (http://lgl.sourceforge.net), it can
 * describe undirected optionally weighted graphs. From the LGL
 * manual:
 *
 * \blockquote The second format is the LGL file format
 * (.lgl file
 * suffix). This is yet another graph file format that tries to be as
 * stingy as possible with space, yet keeping the edge file in a human
 * readable (not binary) format. The format itself is like the
 * following:
 * \verbatim # vertex1name
vertex2name [optionalWeight]
vertex3name [optionalWeight] \endverbatim
 * Here, the first vertex of an edge is preceded with a pound sign
 * '#'.  Then each vertex that shares an edge with that vertex is
 * listed one per line on subsequent lines. \endblockquote
 *
 * 
 * LGL cannot handle loop and multiple edges or directed graphs, but
 * in \a igraph it is not an error to have multiple and loop edges.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream A stream, it should be readable.
 * \param names Logical value, if TRUE the symbolic names of the
 *        vertices will be added to the graph as a vertex attribute
 *        called \quote name\endquote.
 * \param weights Whether to add the weights of the edges to the
 *        graph as an edge attribute called \quote weight\endquote.
 *        \c IGRAPH_ADD_WEIGHTS_YES adds the weights (even if they
 *        are not present in the file, in this case they are assumed
 *        to be zero). \c IGRAPH_ADD_WEIGHTS_NO does not add any
 *        edge attribute. \c IGRAPH_ADD_WEIGHTS_IF_PRESENT adds the
 *        attribute if and only if there is at least one explicit
 *        edge weight in the input file.
 * \param directed Whether to create a directed graph. As this format
 *        was originally used only for undirected graphs there is no
 *        information in the file about the directedness of the graph.
 *        Set this parameter to \c IGRAPH_DIRECTED or \c
 *        IGRAPH_UNDIRECTED to create a directed or undirected graph.
 * \return Error code:
 *         \c IGRAPH_PARSEERROR: if there is a
 *         problem reading the file, or the file is syntactically
 *         incorrect.
 *
 * Time complexity:
 * O(|V|+|E|log(|V|)) if we neglect
 * the time required by the parsing. As usual
 * |V| is the number of vertices,
 * while |E| is the number of edges.
 *
 * \sa \ref igraph_read_graph_ncol(), \ref igraph_write_graph_lgl()
 *
 * \example examples/simple/igraph_read_graph_lgl.c
 */
int igraph_read_graph_lgl(igraph_t *graph, FILE *instream,
                          igraph_bool_t names,
                          igraph_add_weights_t weights,
                          igraph_bool_t directed) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL, ws = IGRAPH_VECTOR_NULL;
    igraph_trie_t trie = IGRAPH_TRIE_NULL;
    igraph_vector_ptr_t name, weight;
    igraph_vector_ptr_t *pname = 0, *pweight = 0;
    igraph_attribute_record_t namerec, weightrec;
    const char *namestr = "name", *weightstr = "weight";
    igraph_i_lgl_parsedata_t context;

    IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_TRIE_INIT_FINALLY(&trie, names);

    context.has_weights = 0;
    context.vector = &edges;
    context.weights = &ws;
    context.trie = ≜
    context.eof = 0;

    igraph_lgl_yylex_init_extra(&context, &context.scanner);
    IGRAPH_FINALLY(igraph_lgl_yylex_destroy, context.scanner);

    igraph_lgl_yyset_in(instream, context.scanner);

    if (igraph_lgl_yyparse(&context)) {
        if (context.errmsg[0] != 0) {
            IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Cannot read LGL file", IGRAPH_PARSEERROR);
        }
    }

    IGRAPH_CHECK(igraph_empty(graph, 0, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);

    if (names) {
        const igraph_strvector_t *namevec;
        IGRAPH_CHECK(igraph_vector_ptr_init(&name, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &name);
        pname = &name;
        igraph_trie_getkeys(&trie, &namevec); /* dirty */
        namerec.name = namestr;
        namerec.type = IGRAPH_ATTRIBUTE_STRING;
        namerec.value = namevec;
        VECTOR(name)[0] = &namerec;
    }

    if (weights == IGRAPH_ADD_WEIGHTS_YES ||
        (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&weight, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &weight);
        pweight = &weight;
        weightrec.name = weightstr;
        weightrec.type = IGRAPH_ATTRIBUTE_NUMERIC;
        weightrec.value = &ws;
        VECTOR(weight)[0] = &weightrec;
    }

    IGRAPH_CHECK(igraph_add_vertices(graph, (igraph_integer_t)
                                     igraph_trie_size(&trie), pname));
    IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));

    if (pweight) {
        igraph_vector_ptr_destroy(pweight);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (pname) {
        igraph_vector_ptr_destroy(pname);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_trie_destroy(&trie);
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&ws);
    igraph_lgl_yylex_destroy(context.scanner);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup loadsave
 * \function igraph_write_graph_lgl
 * \brief Writes the graph to a file in .lgl format
 *
 * 
 * .lgl is a format used by LGL, see \ref
 * igraph_read_graph_lgl() for details.
 *
 * 
 * Note that having multiple or loop edges in an
 * .lgl file breaks the  LGL software but \a igraph
 * does not check for this condition.
 * \param graph The graph to write.
 * \param outstream The stream object to write to, it should be
 *        writable.
 * \param names The name of the vertex attribute, if symbolic names
 *        are written to the file. If not supply 0 here.
 * \param weights The name of the edge attribute, if they are also
 *        written to the file. If you don't want weights supply 0
 *        here.
 * \param isolates Logical, if TRUE isolated vertices are also written
 *        to the file. If FALSE they will be omitted.
 * \return Error code:
 *         \c IGRAPH_EFILE if there is an error
 *         writing the file.
 *
 * Time complexity: O(|E|), the
 * number of edges if \p isolates is
 * FALSE, O(|V|+|E|) otherwise. All
 * file operations are expected to have time complexity
 * O(1).
 *
 * \sa \ref igraph_read_graph_lgl(), \ref igraph_write_graph_ncol()
 *
 * \example examples/simple/igraph_write_graph_lgl.c
 */
int igraph_write_graph_lgl(const igraph_t *graph, FILE *outstream,
                           const char *names, const char *weights,
                           igraph_bool_t isolates) {
    igraph_eit_t it;
    long int actvertex = -1;
    igraph_attribute_type_t nametype, weighttype;

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
                                   &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);

    /* Check if we have the names attribute */
    if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
            names)) {
        names = 0;
        IGRAPH_WARNING("names attribute does not exists");
    }
    if (names) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &nametype,
                                                IGRAPH_ATTRIBUTE_VERTEX, names));
        if (nametype != IGRAPH_ATTRIBUTE_NUMERIC && nametype != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_WARNING("ignoring names attribute, unknown attribute type");
            names = 0;
        }
    }

    /* Check the weights as well */
    if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE,
            weights)) {
        weights = 0;
        IGRAPH_WARNING("weights attribute does not exists");
    }
    if (weights) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &weighttype,
                                                IGRAPH_ATTRIBUTE_EDGE, weights));
        if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC && weighttype != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_WARNING("ignoring weights attribute, unknown attribute type");
            weights = 0;
        }
    }

    if (names == 0 && weights == 0) {
        /* No names, no weights */
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t from, to;
            int ret;
            igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to);
            if (from == actvertex) {
                ret = fprintf(outstream, "%li\n", (long int)to);
            } else {
                actvertex = from;
                ret = fprintf(outstream, "# %li\n%li\n", (long int)from, (long int)to);
            }
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
    } else if (weights == 0) {
        /* No weights but use names */
        igraph_strvector_t nvec;
        IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
        IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
                     igraph_vss_all(),
                     &nvec));
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret = 0;
            char *str1, *str2;
            igraph_edge(graph, edge, &from, &to);
            igraph_strvector_get(&nvec, to, &str2);

            if (from == actvertex) {
                ret = fprintf(outstream, "%s\n", str2);
            } else {
                actvertex = from;
                igraph_strvector_get(&nvec, from, &str1);
                ret = fprintf(outstream, "# %s\n%s\n", str1, str2);
            }
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        IGRAPH_FINALLY_CLEAN(1);
    } else if (names == 0) {
        igraph_strvector_t wvec;
        IGRAPH_CHECK(igraph_strvector_init(&wvec, igraph_ecount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &wvec);
        IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, weights,
                     igraph_ess_all(IGRAPH_EDGEORDER_ID),
                     &wvec));
        /* No names but weights */
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret = 0;
            char *str1;
            igraph_edge(graph, edge, &from, &to);
            igraph_strvector_get(&wvec, edge, &str1);
            if (from == actvertex) {
                ret = fprintf(outstream, "%li %s\n", (long)to, str1);
            } else {
                actvertex = from;
                ret = fprintf(outstream, "# %li\n%li %s\n", (long)from, (long)to, str1);
            }
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        igraph_strvector_destroy(&wvec);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Both names and weights */
        igraph_strvector_t nvec, wvec;
        IGRAPH_CHECK(igraph_strvector_init(&wvec, igraph_ecount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &wvec);
        IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
        IGRAPH_CHECK(igraph_i_attribute_get_string_edge_attr(graph, weights,
                     igraph_ess_all(IGRAPH_EDGEORDER_ID),
                     &wvec));
        IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
                     igraph_vss_all(),
                     &nvec));
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret = 0;
            char *str1, *str2, *str3;
            igraph_edge(graph, edge, &from, &to);
            igraph_strvector_get(&nvec, to, &str2);
            igraph_strvector_get(&wvec, edge, &str3);
            if (from == actvertex) {
                ret = fprintf(outstream, "%s ", str2);
            } else {
                actvertex = from;
                igraph_strvector_get(&nvec, from, &str1);
                ret = fprintf(outstream, "# %s\n%s ", str1, str2);
            }
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            ret = fprintf(outstream, "%s\n", str3);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        igraph_strvector_destroy(&nvec);
        igraph_strvector_destroy(&wvec);
        IGRAPH_FINALLY_CLEAN(2);
    }

    if (isolates) {
        long int nov = igraph_vcount(graph);
        long int i;
        int ret = 0;
        igraph_vector_t deg;
        igraph_strvector_t nvec;
        char *str;

        IGRAPH_VECTOR_INIT_FINALLY(°, 1);
        IGRAPH_CHECK(igraph_strvector_init(&nvec, 1));
        IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
        for (i = 0; i < nov; i++) {
            igraph_degree(graph, °, igraph_vss_1((igraph_integer_t) i),
                          IGRAPH_ALL, IGRAPH_LOOPS);
            if (VECTOR(deg)[0] == 0) {
                if (names == 0) {
                    ret = fprintf(outstream, "# %li\n", i);
                } else {
                    IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
                                 igraph_vss_1((igraph_integer_t) i), &nvec));
                    igraph_strvector_get(&nvec, 0, &str);
                    ret = fprintf(outstream, "# %s\n", str);
                }
            }
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
        }
        igraph_strvector_destroy(&nvec);
        igraph_vector_destroy(°);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/ncol-header.h0000644000175100001710000000216100000000000023402 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_vector.h"

#include "core/trie.h"

typedef struct {
    void *scanner;
    int eof;
    char errmsg[300];
    int has_weights;
    igraph_vector_t *vector;
    igraph_vector_t *weights;
    igraph_trie_t *trie;
} igraph_i_ncol_parsedata_t;
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/ncol-lexer.l0000644000175100001710000000562000000000000023300 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/ncol-header.h"
#include "io/parsers/ncol-parser.h"

#define YY_EXTRA_TYPE igraph_i_ncol_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
%}

%option noyywrap
%option prefix="igraph_ncol_yy"
%option nounput
%option noinput
%option nodefault
%option reentrant
%option bison-bridge
%option bison-locations

alnum [^ \t\n\r\0]

%%

 /* ------------------------------------------------whitespace------*/
[ \t]+               { }

 /* ---------------------------------------------------newline------*/
\n\r|\r\n|\n|\r      { return NEWLINE; }

 /* ----------------------------------------------alphanumeric------*/
{alnum}+             { return ALNUM; }

<>           { if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }

 /* ---------------------------------------------anything else------*/
.                    { return ERROR; }

%%
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/ncol-parser.y0000644000175100001710000001000500000000000023463 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include "core/math.h"
#include "io/ncol-header.h"
#include "io/parsers/ncol-parser.h"
#include "io/parsers/ncol-lexer.h"
#include "internal/hacks.h"

int igraph_ncol_yyerror(YYLTYPE* locp,
                        igraph_i_ncol_parsedata_t *context,
                        const char *s);
igraph_real_t igraph_ncol_get_number(const char *str, long int len);

#define scanner context->scanner
%}

%pure-parser
/* bison: do not remove the equals sign; macOS XCode ships with bison 2.3, which
 * needs the equals sign */
%name-prefix="igraph_ncol_yy"
%defines
%locations
%error-verbose
%parse-param { igraph_i_ncol_parsedata_t* context }
%lex-param { void *scanner }

%union {
  long int edgenum;
  double weightnum;
}

%type    edgeid
%type  weight

%token ALNUM
%token NEWLINE
%token ERROR

%%

input :    /* empty */
         | input NEWLINE
         | input edge
;

edge :   edgeid edgeid NEWLINE        {
           igraph_vector_push_back(context->vector, $1);
           igraph_vector_push_back(context->vector, $2);
           igraph_vector_push_back(context->weights, 0);
       }
       | edgeid edgeid weight NEWLINE {
           igraph_vector_push_back(context->vector, $1);
           igraph_vector_push_back(context->vector, $2);
           igraph_vector_push_back(context->weights, $3);
           context->has_weights = 1;
       }
;

edgeid : ALNUM  { igraph_trie_get2(context->trie,
                  igraph_ncol_yyget_text(scanner),
                  igraph_ncol_yyget_leng(scanner),
                  &$$); };

weight : ALNUM  { $$=igraph_ncol_get_number(igraph_ncol_yyget_text(scanner),
                        igraph_ncol_yyget_leng(scanner)); } ;

%%

int igraph_ncol_yyerror(YYLTYPE* locp,
            igraph_i_ncol_parsedata_t *context,
            const char *s) {
    snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
            "Parse error in NCOL file, line %i (%s)",
            locp->first_line, s);
    return 0;
}

igraph_real_t igraph_ncol_get_number(const char *str, long int length) {
    igraph_real_t num;
    char *tmp=IGRAPH_CALLOC(length+1, char);

    strncpy(tmp, str, length);
    tmp[length]='\0';
    sscanf(tmp, "%lf", &num);
    IGRAPH_FREE(tmp);
    return num;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/ncol.c0000644000175100001710000003417500000000000022161 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_interface.h"

#include "graph/attributes.h"

#include "ncol-header.h"

int igraph_ncol_yylex_init_extra (igraph_i_ncol_parsedata_t* user_defined,
                                  void* scanner);
void igraph_ncol_yylex_destroy (void *scanner );
int igraph_ncol_yyparse (igraph_i_ncol_parsedata_t* context);
void igraph_ncol_yyset_in  (FILE * in_str, void* yyscanner );

/**
 * \ingroup loadsave
 * \function igraph_read_graph_ncol
 * \brief Reads a .ncol file used by LGL.
 *
 * Also useful for creating graphs from \quote named\endquote (and
 * optionally weighted) edge lists.
 *
 * 
 * This format is used by the Large Graph Layout program
 * (http://lgl.sourceforge.net), and it is simply a
 * symbolic weighted edge list. It is a simple text file with one edge
 * per line. An edge is defined by two symbolic vertex names separated
 * by whitespace. (The symbolic vertex names themselves cannot contain
 * whitespace. They might follow by an optional number, this will be
 * the weight of the edge; the number can be negative and can be in
 * scientific notation. If there is no weight specified to an edge it
 * is assumed to be zero.
 *
 * 
 * The resulting graph is always undirected.
 * LGL cannot deal with files which contain multiple or loop edges,
 * this is however not checked here, as \a igraph is happy with
 * these.
 * \param graph Pointer to an uninitialized graph object.
 * \param instream Pointer to a stream, it should be readable.
 * \param predefnames Pointer to the symbolic names of the vertices in
 *        the file. If \c NULL is given here then vertex ids will be
 *        assigned to vertex names in the order of their appearance in
 *        the \c .ncol file. If it is not \c NULL and some unknown
 *        vertex names are found in the \c .ncol file then new vertex
 *        ids will be assigned to them.
 * \param names Logical value, if TRUE the symbolic names of the
 *        vertices will be added to the graph as a vertex attribute
 *        called \quote name\endquote.
 * \param weights Whether to add the weights of the edges to the
 *        graph as an edge attribute called \quote weight\endquote.
 *        \c IGRAPH_ADD_WEIGHTS_YES adds the weights (even if they
 *        are not present in the file, in this case they are assumed
 *        to be zero). \c IGRAPH_ADD_WEIGHTS_NO does not add any
 *        edge attribute. \c IGRAPH_ADD_WEIGHTS_IF_PRESENT adds the
 *        attribute if and only if there is at least one explicit
 *        edge weight in the input file.
 * \param directed Whether to create a directed graph. As this format
 *        was originally used only for undirected graphs there is no
 *        information in the file about the directedness of the graph.
 *        Set this parameter to \c IGRAPH_DIRECTED or \c
 *        IGRAPH_UNDIRECTED to create a directed or undirected graph.
 * \return Error code:
 *         \c IGRAPH_PARSEERROR: if there is a
 *          problem reading
 *         the file, or the file is syntactically incorrect.
 *
 * Time complexity:
 * O(|V|+|E|log(|V|)) if we neglect
 * the time required by the parsing. As usual
 * |V| is the number of vertices,
 * while |E| is the number of edges.
 *
 * \sa \ref igraph_read_graph_lgl(), \ref igraph_write_graph_ncol()
 */
int igraph_read_graph_ncol(igraph_t *graph, FILE *instream,
                           const igraph_strvector_t *predefnames,
                           igraph_bool_t names,
                           igraph_add_weights_t weights,
                           igraph_bool_t directed) {

    igraph_vector_t edges, ws;
    igraph_trie_t trie = IGRAPH_TRIE_NULL;
    igraph_integer_t no_of_nodes;
    long int no_predefined = 0;
    igraph_vector_ptr_t name, weight;
    igraph_vector_ptr_t *pname = 0, *pweight = 0;
    igraph_attribute_record_t namerec, weightrec;
    const char *namestr = "name", *weightstr = "weight";
    igraph_i_ncol_parsedata_t context;

    IGRAPH_CHECK(igraph_empty(graph, 0, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    IGRAPH_TRIE_INIT_FINALLY(&trie, names);
    IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);

    /* Add the predefined names, if any */
    if (predefnames != 0) {
        long int i, id, n;
        char *key;
        n = no_predefined = igraph_strvector_size(predefnames);
        for (i = 0; i < n; i++) {
            igraph_strvector_get(predefnames, i, &key);
            igraph_trie_get(&trie, key, &id);
            if (id != i) {
                IGRAPH_WARNING("reading NCOL file, duplicate entry in predefnames");
                no_predefined--;
            }
        }
    }

    context.has_weights = 0;
    context.vector = &edges;
    context.weights = &ws;
    context.trie = ≜
    context.eof = 0;

    igraph_ncol_yylex_init_extra(&context, &context.scanner);
    IGRAPH_FINALLY(igraph_ncol_yylex_destroy, context.scanner);

    igraph_ncol_yyset_in(instream, context.scanner);

    if (igraph_ncol_yyparse(&context)) {
        if (context.errmsg[0] != 0) {
            IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Cannot read NCOL file", IGRAPH_PARSEERROR);
        }
    }

    if (predefnames != 0 &&
        igraph_trie_size(&trie) != no_predefined) {
        IGRAPH_WARNING("unknown vertex/vertices found, predefnames extended");
    }

    if (names) {
        const igraph_strvector_t *namevec;
        IGRAPH_CHECK(igraph_vector_ptr_init(&name, 1));
        pname = &name;
        igraph_trie_getkeys(&trie, &namevec); /* dirty */
        namerec.name = namestr;
        namerec.type = IGRAPH_ATTRIBUTE_STRING;
        namerec.value = namevec;
        VECTOR(name)[0] = &namerec;
    }

    if (weights == IGRAPH_ADD_WEIGHTS_YES ||
        (weights == IGRAPH_ADD_WEIGHTS_IF_PRESENT && context.has_weights)) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&weight, 1));
        pweight = &weight;
        weightrec.name = weightstr;
        weightrec.type = IGRAPH_ATTRIBUTE_NUMERIC;
        weightrec.value = &ws;
        VECTOR(weight)[0] = &weightrec;
    }

    if (igraph_vector_empty(&edges)) {
        no_of_nodes = 0;
    } else {
        no_of_nodes = igraph_vector_max(&edges) + 1;
    }

    IGRAPH_CHECK(igraph_add_vertices(graph, no_of_nodes, pname));
    IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));

    if (pname) {
        igraph_vector_ptr_destroy(pname);
    }
    if (pweight) {
        igraph_vector_ptr_destroy(pweight);
    }
    igraph_vector_destroy(&ws);
    igraph_trie_destroy(&trie);
    igraph_vector_destroy(&edges);
    igraph_ncol_yylex_destroy(context.scanner);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup loadsave
 * \function igraph_write_graph_ncol
 * \brief Writes the graph to a file in .ncol format
 *
 * 
 * .ncol is a format used by LGL, see \ref
 * igraph_read_graph_ncol() for details.
 *
 * 
 * Note that having multiple or loop edges in an
 * .ncol file breaks the  LGL software but
 * \a igraph does not check for this condition.
 * \param graph The graph to write.
 * \param outstream The stream object to write to, it should be
 *        writable.
 * \param names The name of the vertex attribute, if symbolic names
 *        are written to the file. If not, supply 0 here.
 * \param weights The name of the edge attribute, if they are also
 *        written to the file. If you don't want weights, supply 0
 *        here.
 * \return Error code:
 *         \c IGRAPH_EFILE if there is an error writing the
 *         file.
 *
 * Time complexity: O(|E|), the
 * number of edges. All file operations are expected to have time
 * complexity O(1).
 *
 * \sa \ref igraph_read_graph_ncol(), \ref igraph_write_graph_lgl()
 */
int igraph_write_graph_ncol(const igraph_t *graph, FILE *outstream,
                            const char *names, const char *weights) {
    igraph_eit_t it;
    igraph_attribute_type_t nametype, weighttype;

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_FROM),
                                   &it));
    IGRAPH_FINALLY(igraph_eit_destroy, &it);

    /* Check if we have the names attribute */
    if (names && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
            names)) {
        names = 0;
        IGRAPH_WARNING("names attribute does not exists");
    }
    if (names) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &nametype,
                                                IGRAPH_ATTRIBUTE_VERTEX, names));
        if (nametype != IGRAPH_ATTRIBUTE_NUMERIC && nametype != IGRAPH_ATTRIBUTE_STRING) {
            IGRAPH_WARNING("ignoring names attribute, unknown attribute type");
            names = 0;
        }
    }

    /* Check the weights as well */
    if (weights && !igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE,
            weights)) {
        weights = 0;
        IGRAPH_WARNING("weights attribute does not exists");
    }
    if (weights) {
        IGRAPH_CHECK(igraph_i_attribute_gettype(graph, &weighttype,
                                                IGRAPH_ATTRIBUTE_EDGE, weights));
        if (weighttype != IGRAPH_ATTRIBUTE_NUMERIC) {
            IGRAPH_WARNING("ignoring weights attribute, unknown attribute type");
            weights = 0;
        }
    }

    if (names == 0 && weights == 0) {
        /* No names, no weights */
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t from, to;
            int ret;
            igraph_edge(graph, IGRAPH_EIT_GET(it), &from, &to);
            ret = fprintf(outstream, "%li %li\n",
                          (long int) from,
                          (long int) to);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
    } else if (weights == 0) {
        /* No weights, but use names */
        igraph_strvector_t nvec;
        IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
        IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
                     igraph_vss_all(),
                     &nvec));
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret = 0;
            char *str1, *str2;
            igraph_edge(graph, edge, &from, &to);
            igraph_strvector_get(&nvec, from, &str1);
            igraph_strvector_get(&nvec, to, &str2);
            ret = fprintf(outstream, "%s %s\n", str1, str2);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        igraph_strvector_destroy(&nvec);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (names == 0) {
        /* No names but weights */
        igraph_vector_t wvec;
        IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
        IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
                     igraph_ess_all(IGRAPH_EDGEORDER_ID),
                     &wvec));
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret1, ret2, ret3;
            igraph_edge(graph, edge, &from, &to);
            ret1 = fprintf(outstream, "%li %li ",
                           (long int)from, (long int)to);
            ret2 = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[(long int)edge]);
            ret3 = fputc('\n', outstream);
            if (ret1 < 0 || ret2 < 0 || ret3 == EOF) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        igraph_vector_destroy(&wvec);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Both names and weights */
        igraph_strvector_t nvec;
        igraph_vector_t wvec;
        IGRAPH_VECTOR_INIT_FINALLY(&wvec, igraph_ecount(graph));
        IGRAPH_CHECK(igraph_strvector_init(&nvec, igraph_vcount(graph)));
        IGRAPH_FINALLY(igraph_strvector_destroy, &nvec);
        IGRAPH_CHECK(igraph_i_attribute_get_numeric_edge_attr(graph, weights,
                     igraph_ess_all(IGRAPH_EDGEORDER_ID),
                     &wvec));
        IGRAPH_CHECK(igraph_i_attribute_get_string_vertex_attr(graph, names,
                     igraph_vss_all(),
                     &nvec));
        while (!IGRAPH_EIT_END(it)) {
            igraph_integer_t edge = IGRAPH_EIT_GET(it);
            igraph_integer_t from, to;
            int ret = 0, ret2 = 0;
            char *str1, *str2;
            igraph_edge(graph, edge, &from, &to);
            igraph_strvector_get(&nvec, from, &str1);
            igraph_strvector_get(&nvec, to, &str2);
            ret = fprintf(outstream, "%s %s ", str1, str2);
            if (ret < 0) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            ret = igraph_real_fprintf_precise(outstream, VECTOR(wvec)[(long int)edge]);
            ret2 = fputc('\n', outstream);
            if (ret < 0 || ret2 == EOF) {
                IGRAPH_ERROR("Write failed", IGRAPH_EFILE);
            }
            IGRAPH_EIT_NEXT(it);
        }
        igraph_strvector_destroy(&nvec);
        igraph_vector_destroy(&wvec);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_eit_destroy(&it);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/pajek-header.h0000644000175100001710000000265500000000000023551 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

#include "core/trie.h"

typedef struct {
    void *scanner;
    int eof;
    char errmsg[300];
    igraph_vector_t *vector;
    igraph_bool_t directed;
    int vcount, vcount2;
    int actfrom;
    int actto;
    int mode; /* 0: general, 1: vertex, 2: edge */
    igraph_trie_t *vertex_attribute_names;
    igraph_vector_ptr_t *vertex_attributes;
    igraph_trie_t *edge_attribute_names;
    igraph_vector_ptr_t *edge_attributes;
    int vertexid;
    int actvertex;
    int actedge;
} igraph_i_pajek_parsedata_t;
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/pajek-lexer.l0000644000175100001710000001476700000000000023453 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/pajek-header.h"
#include "io/parsers/pajek-parser.h"

#define YY_EXTRA_TYPE igraph_i_pajek_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in Pajek parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
%}

%option noyywrap
%option prefix="igraph_pajek_yy"
%option nounput
%option noinput
%option nodefault
%option reentrant
%option bison-bridge
%option bison-locations

digit [0-9]
word [^ \t\r\n\0]

%%

[ \t]+          { }
%[^\n]*\n[\r]*  { }
%[^\n]*\r[\n]*  { }
\*[Nn][eE][Tt]                         { return NETWORKLINE; }
\*[Nn][Ee][Tt][Ww][Oo][Rr][Kk]         { return NETWORKLINE; }
\*[Vv][Ee][Rr][Tt][Ii][Cc][Ee][Ss]     { return VERTICESLINE; }
\*[Aa][Rr][Cc][Ss]                     { return ARCSLINE; }
\*[Ee][Dd][Gg][Ee][Ss]                 { return EDGESLINE; }
\*[Aa][Rr][Cc][Ss][Ll][Ii][Ss][Tt]     { return ARCSLISTLINE; }
\*[Ee][Dd][Gg][Ee][Ss][Ll][Ii][Ss][Tt] { return EDGESLISTLINE; }
\*[Mm][Aa][Tt][Rr][Ii][Xx]             { return MATRIXLINE; }
\n\r|\r\n|\n|\r   { yyextra->mode=0; return NEWLINE; }
\"[^\"]*\"        { return QSTR; }
\([^\)]*\)        { return PSTR; }
\-?{digit}+(\.{digit}+)?([eE](\+|\-)?{digit}+)? {
                    return NUM; }

[Xx]_[Ff][Aa][Cc][Tt]/[ \t\n\r]  { if (yyextra->mode==1) { return VP_X_FACT; } else { return ALNUM; } }
[Yy]_[Ff][Aa][Cc][Tt]/[ \t\n\r]  { if (yyextra->mode==1) { return VP_Y_FACT; } else { return ALNUM; } }
[Ii][Cc]/[ \t\n\r]               { if (yyextra->mode==1) { return VP_IC; } else { return ALNUM; } }
[Bb][Cc]/[ \t\n\r]               { if (yyextra->mode==1) { return VP_BC; } else { return ALNUM; } }
[Bb][Ww]/[ \t\n\r]               { if (yyextra->mode==1) { return VP_BW; } else { return ALNUM; } }
[Pp][Hh][Ii]/[ \t\n\r]           { if (yyextra->mode==1) { return VP_PHI; } else { return ALNUM; } }
[Rr]/[ \t\n\r]                   { if (yyextra->mode==1) { return VP_R; } else { return ALNUM; } }
[Qq]/[ \t\n\r]                   { if (yyextra->mode==1) { return VP_Q; } else { return ALNUM; } }
[Ff][Oo][Nn][Tt]/[ \t\n\r]       { if (yyextra->mode==1) { return VP_FONT; } else { return ALNUM; } }
[Uu][Rr][Ll]/[ \t\n\r]           { if (yyextra->mode==1) { return VP_URL; } else { return ALNUM; } }

[Cc]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_C; } else { return ALNUM; } }
[Pp]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_P; } else { return ALNUM; } }
[Ss]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_S; } else { return ALNUM; } }
[Aa]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_A; } else { return ALNUM; } }
[Ww]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_W; } else { return ALNUM; } }
[Hh]1/[ \t\n\r]      { if (yyextra->mode==2) { return EP_H1; } else { return ALNUM; } }
[Hh]2/[ \t\n\r]      { if (yyextra->mode==2) { return EP_H2; } else { return ALNUM; } }
[Aa]1/[ \t\n\r]      { if (yyextra->mode==2) { return EP_A1; } else { return ALNUM; } }
[Aa]2/[ \t\n\r]      { if (yyextra->mode==2) { return EP_A2; } else { return ALNUM; } }
[Kk]1/[ \t\n\r]      { if (yyextra->mode==2) { return EP_K1; } else { return ALNUM; } }
[Kk]2/[ \t\n\r]      { if (yyextra->mode==2) { return EP_K2; } else { return ALNUM; } }
[Aa][Pp]/[ \t\n\r]   { if (yyextra->mode==2) { return EP_AP; } else { return ALNUM; } }
[Ll]/[ \t\n\r]       { if (yyextra->mode==2) { return EP_L; } else { return ALNUM; } }
[Ll][Pp]/[ \t\n\r]   { if (yyextra->mode==2) { return EP_LP; } else { return ALNUM; } }

[Ll][Pp][Hh][Ii]/[ \t\n\r] { if (yyextra->mode==1) { return VP_LPHI; } else
                             if (yyextra->mode==2) { return EP_LPHI; } else { return ALNUM; } }
[Ll][Cc]/[ \t\n\r]         { if (yyextra->mode==1) { return VP_LC; } else
                             if (yyextra->mode==2) { return EP_LC; } else { return ALNUM; } }
[Ll][Rr]/[ \t\n\r]         { if (yyextra->mode==1) { return VP_LR; } else
                             if (yyextra->mode==2) { return EP_LR; } else { return ALNUM; } }
[Ll][Aa]/[ \t\n\r]         { if (yyextra->mode==1) { return VP_LA; } else
                             if (yyextra->mode==2) { return EP_LA; } else { return ALNUM; } }
[Ss][Ii][Zz][Ee]/[ \t\n\r] { if (yyextra->mode==1) { return VP_SIZE; } else
                             if (yyextra->mode==2) { return EP_SIZE; } else { return ALNUM; } }
[Ff][Oo][Ss]/[ \t\n\r]     { if (yyextra->mode==1) { return VP_FOS; } else
                             if (yyextra->mode==2) { return EP_FOS; } else { return ALNUM; } }

{word}+           { return ALNUM; }

<>           { if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }

.                 { return ERROR; }

%%
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/pajek-parser.y0000644000175100001710000006003300000000000023630 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

%{

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "igraph_attributes.h"
#include "config.h"

#include "core/math.h"
#include "io/pajek-header.h"
#include "io/parsers/pajek-parser.h" /* it must come first because of YYSTYPE */
#include "io/parsers/pajek-lexer.h"
#include "internal/hacks.h"

int igraph_pajek_yyerror(YYLTYPE* locp,
                         igraph_i_pajek_parsedata_t *context,
                         const char *s);

int igraph_i_pajek_add_string_vertex_attribute(const char *name,
                                               const char *value,
                                               int len,
                                               igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_string_edge_attribute(const char *name,
                                             const char *value,
                                             int len,
                                             igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_vertex_attribute(const char *name,
                                                igraph_real_t value,
                                                igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_edge_attribute(const char *name,
                                              igraph_real_t value,
                                              igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_attribute(igraph_trie_t *names,
                                         igraph_vector_ptr_t *attrs,
                                         long int count,
                                         const char *attrname,
                                         igraph_integer_t vid,
                                         igraph_real_t number);
int igraph_i_pajek_add_string_attribute(igraph_trie_t *names,
                                        igraph_vector_ptr_t *attrs,
                                        long int count,
                                        const char *attrname,
                                        igraph_integer_t vid,
                                        const char *str);

int igraph_i_pajek_add_bipartite_type(igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_check_bipartite(igraph_i_pajek_parsedata_t *context);

extern igraph_real_t igraph_pajek_get_number(const char *str, long int len);
extern long int igraph_i_pajek_actvertex;
extern long int igraph_i_pajek_actedge;

#define scanner context->scanner

%}

%pure-parser
/* bison: do not remove the equals sign; macOS XCode ships with bison 2.3, which
 * needs the equals sign */
%name-prefix="igraph_pajek_yy"
%defines
%locations
%error-verbose
%parse-param { igraph_i_pajek_parsedata_t* context }
%lex-param { void *scanner }

%union {
  long int intnum;
  double   realnum;
  struct {
    char *str;
    int len;
  } string;
}

%type    longint;
%type    arcfrom;
%type    arcto;
%type    edgefrom;
%type    edgeto;
%type   number;
%type    word;
%type    vpwordpar;
%type    epwordpar;
%type    vertex;

%token NEWLINE
%token NUM
%token ALNUM
%token QSTR
%token PSTR
%token NETWORKLINE
%token VERTICESLINE
%token ARCSLINE
%token EDGESLINE
%token ARCSLISTLINE
%token EDGESLISTLINE
%token MATRIXLINE
%token ERROR

%token VP_X_FACT
%token VP_Y_FACT
%token VP_IC
%token VP_BC
%token VP_LC
%token VP_LR
%token VP_LPHI
%token VP_BW
%token VP_FOS
%token VP_PHI
%token VP_R
%token VP_Q
%token VP_LA
%token VP_FONT
%token VP_URL
%token VP_SIZE

%token EP_C
%token EP_S
%token EP_A
%token EP_W
%token EP_H1
%token EP_H2
%token EP_A1
%token EP_A2
%token EP_K1
%token EP_K2
%token EP_AP
%token EP_P
%token EP_L
%token EP_LP
%token EP_LR
%token EP_LPHI
%token EP_LC
%token EP_LA
%token EP_SIZE
%token EP_FOS

%%

input: nethead vertices edgeblock {
  if (context->vcount2 > 0) { igraph_i_pajek_check_bipartite(context); }
 };

nethead: /* empty */ | NETWORKLINE words NEWLINE;

vertices: verticeshead NEWLINE vertdefs;

verticeshead: VERTICESLINE longint {
  context->vcount=$2;
  context->vcount2=0;
            }
            | VERTICESLINE longint longint {
  context->vcount=$2;
  context->vcount2=$3;
  igraph_i_pajek_add_bipartite_type(context);
};

vertdefs: /* empty */  | vertdefs vertexline;

vertexline: NEWLINE |
            vertex NEWLINE |
            vertex { context->actvertex=$1; } vertexid vertexcoords shape params NEWLINE { }
;

vertex: longint { $$=$1; context->mode=1; };

vertexid: word {
  igraph_i_pajek_add_string_vertex_attribute("id", $1.str, $1.len, context);
  igraph_i_pajek_add_string_vertex_attribute("name", $1.str, $1.len, context);
};

vertexcoords: /* empty */
            | number number {
  igraph_i_pajek_add_numeric_vertex_attribute("x", $1, context);
  igraph_i_pajek_add_numeric_vertex_attribute("y", $2, context);
            }
            | number number number {
  igraph_i_pajek_add_numeric_vertex_attribute("x", $1, context);
  igraph_i_pajek_add_numeric_vertex_attribute("y", $2, context);
  igraph_i_pajek_add_numeric_vertex_attribute("z", $3, context);
            };

shape: /* empty */ | word {
  igraph_i_pajek_add_string_vertex_attribute("shape", $1.str, $1.len, context);
};

params: /* empty */ | params param;

param:
       vpword
     | VP_X_FACT number {
         igraph_i_pajek_add_numeric_vertex_attribute("xfact", $2, context);
       }
     | VP_Y_FACT number {
         igraph_i_pajek_add_numeric_vertex_attribute("yfact", $2, context);
       }
     | VP_IC number number number { /* RGB color */
         igraph_i_pajek_add_numeric_vertex_attribute("color-red", $2, context);
         igraph_i_pajek_add_numeric_vertex_attribute("color-green", $3, context);
         igraph_i_pajek_add_numeric_vertex_attribute("color-blue", $4, context);
       }
     | VP_BC number number number {
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-red", $2, context);
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-green", $3, context);
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-blue", $4, context);
       }
     | VP_LC number number number {
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-red", $2, context);
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-green", $3, context);
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-blue", $4, context);
       }
     | VP_LR number {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldist", $2, context);
     }
     | VP_LPHI number {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldegree2", $2, context);
     }
     | VP_BW number {
         igraph_i_pajek_add_numeric_vertex_attribute("framewidth", $2, context);
     }
     | VP_FOS number {
         igraph_i_pajek_add_numeric_vertex_attribute("fontsize", $2, context);
     }
     | VP_PHI number {
         igraph_i_pajek_add_numeric_vertex_attribute("rotation", $2, context);
     }
     | VP_R number {
         igraph_i_pajek_add_numeric_vertex_attribute("radius", $2, context);
     }
     | VP_Q number {
         igraph_i_pajek_add_numeric_vertex_attribute("diamondratio", $2, context);
     }
     | VP_LA number {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldegree", $2, context);
     }
     | VP_SIZE number {
         igraph_i_pajek_add_numeric_vertex_attribute("vertexsize", $2, context);
     }
;

vpword: VP_FONT { context->mode=3; } vpwordpar {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("font", $3.str, $3.len, context);
     }
     | VP_URL { context->mode=3; } vpwordpar {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("url", $3.str, $3.len, context);
     }
     | VP_IC { context->mode=3; } vpwordpar {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("color", $3.str, $3.len, context);
     }
     | VP_BC { context->mode=3; } vpwordpar {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("framecolor",
                                                    $3.str, $3.len, context);
     }
     | VP_LC { context->mode=3; } vpwordpar {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("labelcolor",
                                                    $3.str, $3.len, context);
     }
;

vpwordpar: word { $$=$1; };

edgeblock: /* empty */ | edgeblock arcs | edgeblock edges | edgeblock arcslist | edgeblock edgeslist | edgeblock adjmatrix;

arcs:   ARCSLINE NEWLINE arcsdefs        { context->directed=1; }
      | ARCSLINE number NEWLINE arcsdefs { context->directed=1; };

arcsdefs: /* empty */ | arcsdefs arcsline;

arcsline: NEWLINE |
          arcfrom arcto { context->actedge++;
                          context->mode=2; } weight edgeparams NEWLINE  {
  igraph_vector_push_back(context->vector, $1-1);
  igraph_vector_push_back(context->vector, $2-1); }
;

arcfrom: longint;

arcto: longint;

edges:   EDGESLINE NEWLINE edgesdefs { context->directed=0; }
       | EDGESLINE number NEWLINE edgesdefs { context->directed=0; }

edgesdefs: /* empty */ | edgesdefs edgesline;

edgesline: NEWLINE |
          edgefrom edgeto { context->actedge++;
                            context->mode=2; } weight edgeparams NEWLINE {
  igraph_vector_push_back(context->vector, $1-1);
  igraph_vector_push_back(context->vector, $2-1); }
;

edgefrom: longint;

edgeto: longint;

weight: /* empty */ | number {
  igraph_i_pajek_add_numeric_edge_attribute("weight", $1, context);
};

edgeparams: /* empty */ | edgeparams edgeparam;

edgeparam:
     epword
   | EP_C number number number {
       igraph_i_pajek_add_numeric_edge_attribute("color-red", $2, context);
       igraph_i_pajek_add_numeric_edge_attribute("color-green", $3, context);
       igraph_i_pajek_add_numeric_edge_attribute("color-blue", $4, context);
   }
   | EP_S number {
       igraph_i_pajek_add_numeric_edge_attribute("arrowsize", $2, context);
   }
   | EP_W number {
       igraph_i_pajek_add_numeric_edge_attribute("edgewidth", $2, context);
   }
   | EP_H1 number {
       igraph_i_pajek_add_numeric_edge_attribute("hook1", $2, context);
   }
   | EP_H2 number {
       igraph_i_pajek_add_numeric_edge_attribute("hook2", $2, context);
   }
   | EP_A1 number {
       igraph_i_pajek_add_numeric_edge_attribute("angle1", $2, context);
   }
   | EP_A2 number {
       igraph_i_pajek_add_numeric_edge_attribute("angle2", $2, context);
   }
   | EP_K1 number {
       igraph_i_pajek_add_numeric_edge_attribute("velocity1", $2, context);
   }
   | EP_K2 number {
       igraph_i_pajek_add_numeric_edge_attribute("velocity2", $2, context);
   }
   | EP_AP number {
       igraph_i_pajek_add_numeric_edge_attribute("arrowpos", $2, context);
   }
   | EP_LP number {
       igraph_i_pajek_add_numeric_edge_attribute("labelpos", $2, context);
   }
   | EP_LR number {
       igraph_i_pajek_add_numeric_edge_attribute("labelangle", $2, context);
   }
   | EP_LPHI number {
       igraph_i_pajek_add_numeric_edge_attribute("labelangle2", $2, context);
   }
   | EP_LA number {
       igraph_i_pajek_add_numeric_edge_attribute("labeldegree", $2, context);
   }
   | EP_SIZE number { /* what is this??? */
       igraph_i_pajek_add_numeric_edge_attribute("arrowsize", $2, context);
   }
   | EP_FOS number {
       igraph_i_pajek_add_numeric_edge_attribute("fontsize", $2, context);
   }
;

epword: EP_A { context->mode=4; } epwordpar {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("arrowtype", $3.str, $3.len, context);
    }
    | EP_P { context->mode=4; } epwordpar {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("linepattern", $3.str, $3.len, context);
    }
    | EP_L { context->mode=4; } epwordpar {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("label", $3.str, $3.len, context);
    }
    | EP_LC { context->mode=4; } epwordpar {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("labelcolor", $3.str, $3.len, context);
    }
    | EP_C { context->mode=4; } epwordpar {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("color", $3.str, $3.len, context);
    }
;

epwordpar: word { context->mode=2; $$=$1; };

arcslist: ARCSLISTLINE NEWLINE arcslistlines { context->directed=1; };

arcslistlines: /* empty */ | arcslistlines arclistline;

arclistline: NEWLINE | arclistfrom arctolist NEWLINE;

arctolist: /* empty */ | arctolist arclistto;

arclistfrom: longint { context->mode=0; context->actfrom=labs($1)-1; };

arclistto: longint {
  igraph_vector_push_back(context->vector, context->actfrom);
  igraph_vector_push_back(context->vector, labs($1)-1);
};

edgeslist: EDGESLISTLINE NEWLINE edgelistlines { context->directed=0; };

edgelistlines: /* empty */ | edgelistlines edgelistline;

edgelistline: NEWLINE | edgelistfrom edgetolist NEWLINE;

edgetolist: /* empty */ | edgetolist edgelistto;

edgelistfrom: longint { context->mode=0; context->actfrom=labs($1)-1; };

edgelistto: longint {
  igraph_vector_push_back(context->vector, context->actfrom);
  igraph_vector_push_back(context->vector, labs($1)-1);
};

/* -----------------------------------------------------*/

adjmatrix: matrixline NEWLINE adjmatrixlines;

matrixline: MATRIXLINE { context->actfrom=0;
                         context->actto=0;
                         context->directed=(context->vcount2==0);
                       };

adjmatrixlines: /* empty */ | adjmatrixlines adjmatrixline;

adjmatrixline: adjmatrixnumbers NEWLINE { context->actfrom++; context->actto=0; };

adjmatrixnumbers: /* empty */ | adjmatrixentry adjmatrixnumbers;

adjmatrixentry: number {
  if ($1 != 0) {
    if (context->vcount2==0) {
      context->actedge++;
      igraph_i_pajek_add_numeric_edge_attribute("weight", $1, context);
      igraph_vector_push_back(context->vector, context->actfrom);
      igraph_vector_push_back(context->vector, context->actto);
    } else if (context->vcount2 + context->actto < context->vcount) {
      context->actedge++;
      igraph_i_pajek_add_numeric_edge_attribute("weight", $1, context);
      igraph_vector_push_back(context->vector, context->actfrom);
      igraph_vector_push_back(context->vector,
                              context->vcount2+context->actto);
    }
  }
  context->actto++;
};

/* -----------------------------------------------------*/

longint: NUM { $$=igraph_pajek_get_number(igraph_pajek_yyget_text(scanner),
                                          igraph_pajek_yyget_leng(scanner)); };

number: NUM  { $$=igraph_pajek_get_number(igraph_pajek_yyget_text(scanner),
                                          igraph_pajek_yyget_leng(scanner)); };

words: /* empty */ | words word;

word: ALNUM { $$.str=igraph_pajek_yyget_text(scanner);
              $$.len=igraph_pajek_yyget_leng(scanner); }
      | NUM { $$.str=igraph_pajek_yyget_text(scanner);
              $$.len=igraph_pajek_yyget_leng(scanner); }
      | QSTR { $$.str=igraph_pajek_yyget_text(scanner)+1;
               $$.len=igraph_pajek_yyget_leng(scanner)-2; };

%%

int igraph_pajek_yyerror(YYLTYPE* locp,
                         igraph_i_pajek_parsedata_t *context,
                         const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
           "Parse error in Pajek file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

igraph_real_t igraph_pajek_get_number(const char *str, long int length) {
  igraph_real_t num;
  char *tmp=IGRAPH_CALLOC(length+1, char);

  strncpy(tmp, str, length);
  tmp[length]='\0';
  sscanf(tmp, "%lf", &num);
  IGRAPH_FREE(tmp);
  return num;
}

/* TODO: NA's */

int igraph_i_pajek_add_numeric_attribute(igraph_trie_t *names,
                                         igraph_vector_ptr_t *attrs,
                                         long int count,
                                         const char *attrname,
                                         igraph_integer_t vid,
                                         igraph_real_t number) {
  long int attrsize=igraph_trie_size(names);
  long int id;
  igraph_vector_t *na;
  igraph_attribute_record_t *rec;

  igraph_trie_get(names, attrname, &id);
  if (id == attrsize) {
    /* add a new attribute */
    rec=IGRAPH_CALLOC(1, igraph_attribute_record_t);
    na=IGRAPH_CALLOC(1, igraph_vector_t);
    igraph_vector_init(na, count);
    rec->name=strdup(attrname);
    rec->type=IGRAPH_ATTRIBUTE_NUMERIC;
    rec->value=na;
    igraph_vector_ptr_push_back(attrs, rec);
  }
  rec=VECTOR(*attrs)[id];
  na=(igraph_vector_t*)rec->value;
  if (igraph_vector_size(na) == vid) {
    IGRAPH_CHECK(igraph_vector_push_back(na, number));
  } else if (igraph_vector_size(na) < vid) {
    long int origsize=igraph_vector_size(na);
    IGRAPH_CHECK(igraph_vector_resize(na, (long int)vid+1));
    for (;origsizename=strdup(attrname);
    rec->type=IGRAPH_ATTRIBUTE_STRING;
    rec->value=na;
    igraph_vector_ptr_push_back(attrs, rec);
  }
  rec=VECTOR(*attrs)[id];
  na=(igraph_strvector_t*)rec->value;
  if (igraph_strvector_size(na) <= vid) {
    long int origsize=igraph_strvector_size(na);
    IGRAPH_CHECK(igraph_strvector_resize(na, vid+1));
    for (;origsizevertex_attribute_names,
                                          context->vertex_attributes,
                                          context->vcount,
                                          name, context->actvertex-1,
                                          tmp);

  IGRAPH_FREE(tmp);
  IGRAPH_FINALLY_CLEAN(1);

  return ret;
}

int igraph_i_pajek_add_string_edge_attribute(const char *name,
                                             const char *value,
                                             int len,
                                             igraph_i_pajek_parsedata_t *context) {
  char *tmp;
  int ret;

  tmp=IGRAPH_CALLOC(len+1, char);
  if (tmp==0) {
    IGRAPH_ERROR("cannot add element to hash table", IGRAPH_ENOMEM);
  }
  IGRAPH_FINALLY(igraph_free, tmp);
  strncpy(tmp, value, len);
  tmp[len]='\0';

  ret=igraph_i_pajek_add_string_attribute(context->edge_attribute_names,
                                          context->edge_attributes,
                                          context->actedge,
                                          name, context->actedge-1,
                                          tmp);

  IGRAPH_FREE(tmp);
  IGRAPH_FINALLY_CLEAN(1);

  return ret;
}

int igraph_i_pajek_add_numeric_vertex_attribute(const char *name,
                                                igraph_real_t value,
                                                igraph_i_pajek_parsedata_t *context) {

  return
    igraph_i_pajek_add_numeric_attribute(context->vertex_attribute_names,
                                         context->vertex_attributes,
                                         context->vcount,
                                         name, context->actvertex-1,
                                         value);
}

int igraph_i_pajek_add_numeric_edge_attribute(const char *name,
                                              igraph_real_t value,
                                              igraph_i_pajek_parsedata_t *context) {

  return
    igraph_i_pajek_add_numeric_attribute(context->edge_attribute_names,
                                         context->edge_attributes,
                                         context->actedge,
                                         name, context->actedge-1,
                                         value);
}

int igraph_i_pajek_add_bipartite_type(igraph_i_pajek_parsedata_t *context) {

  const char *attrname="type";
  igraph_trie_t *names=context->vertex_attribute_names;
  igraph_vector_ptr_t *attrs=context->vertex_attributes;
  int i, n=context->vcount, n1=context->vcount2;
  long int attrid, attrsize=igraph_trie_size(names);
  igraph_attribute_record_t *rec;
  igraph_vector_t *na;

  if (n1 > n) {
    IGRAPH_ERROR("Invalid number of vertices in bipartite Pajek file",
                 IGRAPH_PARSEERROR);
  }

  igraph_trie_get(names, attrname, &attrid);
  if (attrid != attrsize) {
    IGRAPH_ERROR("Duplicate 'type' attribute in Pajek file, "
                 "this should not happen", IGRAPH_EINTERNAL);
  }

  /* add a new attribute */
  rec=IGRAPH_CALLOC(1, igraph_attribute_record_t);
  na=IGRAPH_CALLOC(1, igraph_vector_t);
  igraph_vector_init(na, n);
  rec->name=strdup(attrname);
  rec->type=IGRAPH_ATTRIBUTE_NUMERIC;
  rec->value=na;
  igraph_vector_ptr_push_back(attrs, rec);

  for (i=0; ivector;
  int i, n1=context->vcount2;
  int ne=igraph_vector_size(edges);

  for (i=0; i n1 && v2 > n1) ) {
      IGRAPH_WARNING("Invalid edge in bipartite graph");
    }
  }

  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/io/pajek.c0000644000175100001710000007306700000000000022323 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_foreign.h"

#include "igraph_attributes.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "graph/attributes.h"

#include "pajek-header.h"

#include 
#include 

int igraph_pajek_yylex_init_extra(igraph_i_pajek_parsedata_t* user_defined,
                                  void* scanner);
void igraph_pajek_yylex_destroy (void *scanner );
int igraph_pajek_yyparse (igraph_i_pajek_parsedata_t* context);
void igraph_pajek_yyset_in  (FILE * in_str, void* yyscanner );

/**
 * \function igraph_read_graph_pajek
 * \brief Reads a file in Pajek format
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param file An already opened file handler.
 * \return Error code.
 *
 * 
 * Only a subset of the Pajek format is implemented. This is partially
 * because this format is not very well documented, but also because
 * igraph does not support some Pajek features, like
 * multigraphs.
 *
 * 
 * Starting from version 0.6.1 igraph reads bipartite (two-mode)
 * graphs from Pajek files and add the \c type vertex attribute for them.
 * Warnings are given for invalid edges, i.e. edges connecting
 * vertices of the same type.
 *
 * 
 * The list of the current limitations:
 * \olist
 * \oli Only .net files are supported, Pajek
 * project files (.paj) are not. These might be
 * supported in the future if there is need for it.
 * \oli Time events networks are not supported.
 * \oli Hypergraphs (i.e. graphs with non-binary edges) are not
 * supported.
 * \oli Graphs with both directed and non-directed edges are not
 * supported, are they cannot be represented in
 * igraph.
 * \oli Only Pajek networks are supported, permutations, hierarchies,
 * clusters and vectors are not.
 * \oli Graphs with multiple edge sets are not supported.
 * \endolist
 *
 * 
 * If there are attribute handlers installed,
 * igraph also reads the vertex and edge attributes
 * from the file. Most attributes are renamed to be more informative:
 * \c color instead of \c c, \c xfact instead of \c x_fact,
 * \c yfact instead of y_fact, \c labeldist instead of \c lr,
 * \c labeldegree2 instead of \c lphi, \c framewidth instead of \c bw,
 * \c fontsize
 * instead of \c fos, \c rotation instead of \c phi, \c radius instead
 * of \c r,
 * \c diamondratio instead of \c q, \c labeldegree instead of \c la,
 * \c vertexsize
 * instead of \c size, \c color instead of \c ic, \c framecolor instead of
 * \c bc, \c labelcolor instead of \c lc, these belong to vertices.
 *
 * 
 * Edge attributes are also renamed, \c s to \c arrowsize, \c w
 * to \c edgewidth, \c h1 to \c hook1, \c h2 to \c hook2,
 * \c a1 to \c angle1, \c a2 to \c angle2, \c k1 to
 * \c velocity1, \c k2 to \c velocity2, \c ap to \c
 * arrowpos, \c lp to \c labelpos, \c lr to
 * \c labelangle, \c lphi to \c labelangle2, \c la to \c
 * labeldegree, \c fos to
 * \c fontsize, \c a to \c arrowtype, \c p to \c
 * linepattern, \c l to \c label, \c lc to
 * \c labelcolor, \c c to \c color.
 *
 * 
 * In addition the following vertex attributes might be added: \c id
 * if there are vertex ids in the file, \c x and \c y or \c x
 * and \c y and \c z if there are vertex coordinates in the file.
 *
 * The \c weight edge attribute might be
 * added if there are edge weights present.
 *
 * 
 * See the pajek homepage:
 * http://vlado.fmf.uni-lj.si/pub/networks/pajek/ for more info on
 * Pajek and the Pajek manual:
 * http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf for
 * information on the Pajek file format.
 *
 * 
 * Time complexity: O(|V|+|E|+|A|), |V| is the number of vertices, |E|
 * the number of edges, |A| the number of attributes (vertex + edge)
 * in the graph if there are attribute handlers installed.
 *
 * \sa \ref igraph_write_graph_pajek() for writing Pajek files, \ref
 * igraph_read_graph_graphml() for reading GraphML files.
 *
 * \example examples/simple/foreign.c
 */

int igraph_read_graph_pajek(igraph_t *graph, FILE *instream) {

    igraph_vector_t edges;
    igraph_trie_t vattrnames;
    igraph_vector_ptr_t vattrs;
    igraph_trie_t eattrnames;
    igraph_vector_ptr_t eattrs;
    long int i, j;
    igraph_i_pajek_parsedata_t context;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    IGRAPH_TRIE_INIT_FINALLY(&vattrnames, 1);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&vattrs, 0);
    IGRAPH_TRIE_INIT_FINALLY(&eattrnames, 1);
    IGRAPH_VECTOR_PTR_INIT_FINALLY(&eattrs, 0);

    context.vector = &edges;
    context.mode = 0;
    context.vcount = -1;
    context.vertexid = 0;
    context.vertex_attribute_names = &vattrnames;
    context.vertex_attributes = &vattrs;
    context.edge_attribute_names = &eattrnames;
    context.edge_attributes = &eattrs;
    context.actedge = 0;
    context.eof = 0;

    igraph_pajek_yylex_init_extra(&context, &context.scanner);
    IGRAPH_FINALLY(igraph_pajek_yylex_destroy, context.scanner);

    igraph_pajek_yyset_in(instream, context.scanner);

    if (igraph_pajek_yyparse(&context)) {
        if (context.errmsg[0] != 0) {
            IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR);
        } else {
            IGRAPH_ERROR("Cannot read Pajek file", IGRAPH_PARSEERROR);
        }
    }

    if (context.vcount < 0) {
        IGRAPH_ERROR("invalid vertex count in Pajek file", IGRAPH_EINVAL);
    }
    if (context.vcount2 < 0) {
        IGRAPH_ERROR("invalid 2-mode vertex count in Pajek file", IGRAPH_EINVAL);
    }

    for (i = 0; i < igraph_vector_ptr_size(&eattrs); i++) {
        igraph_attribute_record_t *rec = VECTOR(eattrs)[i];
        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*)rec->value;
            long int origsize = igraph_vector_size(vec);
            igraph_vector_resize(vec, context.actedge);
            for (j = origsize; j < context.actedge; j++) {
                VECTOR(*vec)[j] = IGRAPH_NAN;
            }
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t*)rec->value;
            long int origsize = igraph_strvector_size(strvec);
            igraph_strvector_resize(strvec, context.actedge);
            for (j = origsize; j < context.actedge; j++) {
                igraph_strvector_set(strvec, j, "");
            }
        }
    }

    IGRAPH_CHECK(igraph_empty(graph, 0, context.directed));
    IGRAPH_FINALLY(igraph_destroy, graph);
    IGRAPH_CHECK(igraph_add_vertices(graph, context.vcount, &vattrs));
    IGRAPH_CHECK(igraph_add_edges(graph, &edges, &eattrs));

    for (i = 0; i < igraph_vector_ptr_size(&vattrs); i++) {
        igraph_attribute_record_t *rec = VECTOR(vattrs)[i];
        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*) rec->value;
            igraph_vector_destroy(vec);
            IGRAPH_FREE(vec);
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t *)rec->value;
            igraph_strvector_destroy(strvec);
            IGRAPH_FREE(strvec);
        }
        igraph_free( (char*)(rec->name));
        IGRAPH_FREE(rec);
    }

    for (i = 0; i < igraph_vector_ptr_size(&eattrs); i++) {
        igraph_attribute_record_t *rec = VECTOR(eattrs)[i];
        if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_vector_t *vec = (igraph_vector_t*) rec->value;
            igraph_vector_destroy(vec);
            IGRAPH_FREE(vec);
        } else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
            igraph_strvector_t *strvec = (igraph_strvector_t *)rec->value;
            igraph_strvector_destroy(strvec);
            IGRAPH_FREE(strvec);
        }
        igraph_free( (char*)(rec->name));
        IGRAPH_FREE(rec);
    }

    igraph_vector_destroy(&edges);
    igraph_vector_ptr_destroy(&eattrs);
    igraph_trie_destroy(&eattrnames);
    igraph_vector_ptr_destroy(&vattrs);
    igraph_trie_destroy(&vattrnames);
    igraph_pajek_yylex_destroy(context.scanner);

    IGRAPH_FINALLY_CLEAN(7);
    return 0;
}

/* Order matters here! */
#define V_ID                0
#define V_X                 1
#define V_Y                 2
#define V_Z                 3
#define V_SHAPE             4
#define V_XFACT             5
#define V_YFACT             6
#define V_COLOR_RED         7
#define V_COLOR_GREEN       8
#define V_COLOR_BLUE        9
#define V_FRAMECOLOR_RED   10
#define V_FRAMECOLOR_GREEN 11
#define V_FRAMECOLOR_BLUE  12
#define V_LABELCOLOR_RED   13
#define V_LABELCOLOR_GREEN 14
#define V_LABELCOLOR_BLUE  15
#define V_LABELDIST        16
#define V_LABELDEGREE2     17
#define V_FRAMEWIDTH       18
#define V_FONTSIZE         19
#define V_ROTATION         20
#define V_RADIUS           21
#define V_DIAMONDRATIO     22
#define V_LABELDEGREE      23
#define V_VERTEXSIZE       24
#define V_FONT             25
#define V_URL              26
#define V_COLOR            27
#define V_FRAMECOLOR       28
#define V_LABELCOLOR       29
#define V_LAST             30

#define E_WEIGHT            0
#define E_COLOR_RED         1
#define E_COLOR_GREEN       2
#define E_COLOR_BLUE        3
#define E_ARROWSIZE         4
#define E_EDGEWIDTH         5
#define E_HOOK1             6
#define E_HOOK2             7
#define E_ANGLE1            8
#define E_ANGLE2            9
#define E_VELOCITY1        10
#define E_VELOCITY2        11
#define E_ARROWPOS         12
#define E_LABELPOS         13
#define E_LABELANGLE       14
#define E_LABELANGLE2      15
#define E_LABELDEGREE      16
#define E_FONTSIZE         17
#define E_ARROWTYPE        18
#define E_LINEPATTERN      19
#define E_LABEL            20
#define E_LABELCOLOR       21
#define E_COLOR            22
#define E_LAST             23

static int igraph_i_pajek_escape(char* src, char** dest) {
    long int destlen = 0;
    igraph_bool_t need_escape = 0;

    /* Determine whether the string contains characters to be escaped */
    char *s, *d;
    for (s = src; *s; s++, destlen++) {
        if (*s == '\\') {
            need_escape = 1;
            destlen++;
        } else if (*s == '"') {
            need_escape = 1;
            destlen++;
        } else if (!isalnum(*s)) {
            need_escape = 1;
        }
    }

    if (!need_escape) {
        /* At this point, we know that the string does not contain any chars
         * that would warrant escaping. Therefore, we simply quote it and
         * return the quoted string. This is necessary because Pajek uses some
         * reserved words in its format (like 'c' standing for color) and they
         * have to be quoted as well.
         */
        *dest = IGRAPH_CALLOC(destlen + 3, char);
        if (!*dest) {
            IGRAPH_ERROR("Not enough memory", IGRAPH_ENOMEM);
        }

        d = *dest;
        strcpy(d + 1, src);
        d[0] = d[destlen + 1] = '"';
        d[destlen + 2] = 0;
        return IGRAPH_SUCCESS;
    }

    *dest = IGRAPH_CALLOC(destlen + 3, char);
    if (!*dest) {
        IGRAPH_ERROR("Not enough memory", IGRAPH_ENOMEM);
    }

    d = *dest;
    *d = '"'; d++;

    for (s = src; *s; s++, d++) {
        switch (*s) {
        case '\\':
        case '"':
            *d = '\\'; d++;
            *d = *s;
            break;
        default:
            *d = *s;
        }
    }
    *d = '"'; d++; *d = 0;

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_write_graph_pajek
 * \brief Writes a graph to a file in Pajek format.
 *
 * 
 * The Pajek vertex and edge parameters (like color) are determined by
 * the attributes of the vertices and edges, of course this requires
 * an attribute handler to be installed. The names of the
 * corresponding vertex and edge attributes are listed at \ref
 * igraph_read_graph_pajek(), e.g. the \c color vertex attributes
 * determines the color (\c c in Pajek) parameter.
 *
 * 
 * As of version 0.6.1 igraph writes bipartite graphs into Pajek files
 * correctly, i.e. they will be also bipartite when read into Pajek.
 * As Pajek is less flexible for bipartite graphs (the numeric IDs of
 * the vertices must be sorted according to vertex type), igraph might
 * need to reorder the vertices when writing a bipartite Pajek file.
 * This effectively means that numeric vertex IDs usually change when
 * a bipartite graph is written to a Pajek file, and then read back
 * into igraph.
 *
 * 
 * Early versions of Pajek supported only Windows-style line endings
 * in Pajek files, but recent versions support both Windows and Unix
 * line endings. igraph therefore uses the platform-native line endings
 * when the input file is opened in text mode, and uses Unix-style
 * line endings when the input file is opened in binary mode. If you
 * are using an old version of Pajek, you are on Unix and you are having
 * problems reading files written by igraph on a Windows machine, convert the
 * line endings manually with a text editor or with \c unix2dos or \c iconv
 * from the command line).
 *
 * \param graph The graph object to write.
 * \param outstream The file to write to. It should be opened and
 * writable. Make sure that you open the file in binary format if you use MS Windows,
 * otherwise end of line characters will be messed up. (igraph will be able
 * to read back these messed up files, but Pajek won't.)
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|+|A|), |V| is the number of vertices, |E|
 * is the number of edges, |A| the number of attributes (vertex +
 * edge) in the graph if there are attribute handlers installed.
 *
 * \sa \ref igraph_read_graph_pajek() for reading Pajek graphs, \ref
 * igraph_write_graph_graphml() for writing a graph in GraphML format,
 * this suites igraph graphs better.
 *
 * \example examples/simple/igraph_write_graph_pajek.c
 */

int igraph_write_graph_pajek(const igraph_t *graph, FILE *outstream) {
    long int no_of_nodes = igraph_vcount(graph);
    long int i, j;

    igraph_attribute_type_t vtypes[V_LAST], etypes[E_LAST];
    igraph_bool_t write_vertex_attrs = 0;

    /* Same order as the #define's */
    const char *vnames[] = { "id", "x", "y", "z", "shape", "xfact", "yfact",
                             "", "", "", "", "", "", "", "", "",
                             "labeldist", "labeldegree2", "framewidth",
                             "fontsize", "rotation", "radius",
                             "diamondratio", "labeldegree", "vertexsize",
                             "font", "url", "color", "framecolor",
                             "labelcolor"
                           };

    const char *vnumnames[] = { "xfact", "yfact", "labeldist",
                                "labeldegree2", "framewidth", "fontsize",
                                "rotation", "radius", "diamondratio",
                                "labeldegree", "vertexsize"
                              };
    const char *vnumnames2[] = { "x_fact", "y_fact", "lr", "lphi", "bw",
                                 "fos", "phi", "r", "q", "la", "size"
                               };
    const char *vstrnames[] = { "font", "url", "color", "framecolor",
                                "labelcolor"
                              };
    const char *vstrnames2[] = { "font", "url", "ic", "bc", "lc" };

    const char *enames[] = { "weight", "", "", "",
                             "arrowsize", "edgewidth", "hook1", "hook2",
                             "angle1", "angle2", "velocity1", "velocity2",
                             "arrowpos", "labelpos", "labelangle",
                             "labelangle2", "labeldegree", "fontsize",
                             "arrowtype", "linepattern", "label", "labelcolor",
                             "color"
                           };
    const char *enumnames[] = { "arrowsize", "edgewidth", "hook1", "hook2",
                                "angle1", "angle2", "velocity1", "velocity2",
                                "arrowpos", "labelpos", "labelangle",
                                "labelangle2", "labeldegree", "fontsize"
                              };
    const char *enumnames2[] = { "s", "w", "h1", "h2", "a1", "a2", "k1", "k2",
                                 "ap", "lp", "lr", "lphi", "la", "fos"
                               };
    const char *estrnames[] = { "arrowtype", "linepattern", "label",
                                "labelcolor", "color"
                              };
    const char *estrnames2[] = { "a", "p", "l", "lc", "c" };

    /* Newer Pajek versions support both Unix and Windows-style line endings,
     * so we just use Unix style. This will get converted to CRLF on Windows
     * when the file is opened in text mode */
    const char *newline = "\n";

    igraph_es_t es;
    igraph_eit_t eit;

    igraph_vector_t numv;
    igraph_strvector_t strv;

    igraph_vector_t ex_numa;
    igraph_vector_t ex_stra;
    igraph_vector_t vx_numa;
    igraph_vector_t vx_stra;

    char *s, *escaped;

    igraph_bool_t bipartite = 0;
    igraph_vector_int_t bip_index, bip_index2;
    igraph_vector_bool_t bvec;
    long int notop = 0, nobottom = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&numv, 1);
    IGRAPH_STRVECTOR_INIT_FINALLY(&strv, 1);

    IGRAPH_VECTOR_INIT_FINALLY(&ex_numa, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&ex_stra, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vx_numa, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vx_stra, 0);

    /* Check if graph is bipartite */
    if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, "type")) {
        igraph_attribute_type_t type_type;
        igraph_i_attribute_gettype(graph, &type_type, IGRAPH_ATTRIBUTE_VERTEX,
                                   "type");
        if (type_type == IGRAPH_ATTRIBUTE_BOOLEAN) {
            int bptr = 0, tptr = 0;
            bipartite = 1; write_vertex_attrs = 1;
            /* Count top and bottom vertices, we go over them twice,
            because we want to keep their original order */
            IGRAPH_CHECK(igraph_vector_int_init(&bip_index, no_of_nodes));
            IGRAPH_FINALLY(igraph_vector_int_destroy, &bip_index);
            IGRAPH_CHECK(igraph_vector_int_init(&bip_index2, no_of_nodes));
            IGRAPH_FINALLY(igraph_vector_int_destroy, &bip_index2);
            IGRAPH_CHECK(igraph_vector_bool_init(&bvec, 1));
            IGRAPH_FINALLY(igraph_vector_bool_destroy, &bvec);
            for (i = 0; i < no_of_nodes; i++) {
                IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
                             "type", igraph_vss_1((igraph_integer_t) i), &bvec));
                if (VECTOR(bvec)[0]) {
                    notop++;
                } else {
                    nobottom++;
                }
            }
            for (i = 0, bptr = 0, tptr = (int) nobottom; i < no_of_nodes; i++) {
                IGRAPH_CHECK(igraph_i_attribute_get_bool_vertex_attr(graph,
                             "type", igraph_vss_1((igraph_integer_t) i), &bvec));
                if (VECTOR(bvec)[0]) {
                    VECTOR(bip_index)[tptr] = (int) i;
                    VECTOR(bip_index2)[i] = tptr;
                    tptr++;
                } else {
                    VECTOR(bip_index)[bptr] = (int) i;
                    VECTOR(bip_index2)[i] = bptr;
                    bptr++;
                }
            }
            igraph_vector_bool_destroy(&bvec);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    /* Write header */
    if (bipartite) {
        if (fprintf(outstream, "*Vertices %li %li%s", no_of_nodes, nobottom,
                    newline) < 0) {
            IGRAPH_ERROR("Cannot write pajek file", IGRAPH_EFILE);
        }
    } else {
        if (fprintf(outstream, "*Vertices %li%s", no_of_nodes, newline) < 0) {
            IGRAPH_ERROR("Cannot write pajek file", IGRAPH_EFILE);
        }
    }

    /* Check the vertex attributes */
    memset(vtypes, 0, sizeof(vtypes[0])*V_LAST);
    for (i = 0; i < V_LAST; i++) {
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
                                        vnames[i])) {
            igraph_i_attribute_gettype(graph, &vtypes[i], IGRAPH_ATTRIBUTE_VERTEX,
                                       vnames[i]);
            write_vertex_attrs = 1;
        } else {
            vtypes[i] = (igraph_attribute_type_t) -1;
        }
    }
    for (i = 0; i < (long int) (sizeof(vnumnames) / sizeof(const char*)); i++) {
        igraph_attribute_type_t type;
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
                                        vnumnames[i])) {
            igraph_i_attribute_gettype(graph, &type, IGRAPH_ATTRIBUTE_VERTEX,
                                       vnumnames[i]);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                IGRAPH_CHECK(igraph_vector_push_back(&vx_numa, i));
            }
        }
    }
    for (i = 0; i < (long int) (sizeof(vstrnames) / sizeof(const char*)); i++) {
        igraph_attribute_type_t type;
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX,
                                        vstrnames[i])) {
            igraph_i_attribute_gettype(graph, &type, IGRAPH_ATTRIBUTE_VERTEX,
                                       vstrnames[i]);
            if (type == IGRAPH_ATTRIBUTE_STRING) {
                IGRAPH_CHECK(igraph_vector_push_back(&vx_stra, i));
            }
        }
    }

    /* Write vertices */
    if (write_vertex_attrs) {
        for (i = 0; i < no_of_nodes; i++) {
            long int id = bipartite ? VECTOR(bip_index)[i] : i;

            /* vertex id */
            fprintf(outstream, "%li", i + 1);
            if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_i_attribute_get_numeric_vertex_attr(graph, vnames[V_ID],
                        igraph_vss_1((igraph_integer_t) id), &numv);
                fputs(" \"", outstream);
                igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                fputc('"', outstream);
            } else if (vtypes[V_ID] == IGRAPH_ATTRIBUTE_STRING) {
                igraph_i_attribute_get_string_vertex_attr(graph, vnames[V_ID],
                        igraph_vss_1((igraph_integer_t) id), &strv);
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_pajek_escape(s, &escaped));
                fprintf(outstream, " %s", escaped);
                IGRAPH_FREE(escaped);
            } else {
                fprintf(outstream, " \"%li\"", id + 1);
            }

            /* coordinates */
            if (vtypes[V_X] == IGRAPH_ATTRIBUTE_NUMERIC &&
                vtypes[V_Y] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_i_attribute_get_numeric_vertex_attr(graph, vnames[V_X],
                        igraph_vss_1((igraph_integer_t) id), &numv);
                fputc(' ', outstream);
                igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                igraph_i_attribute_get_numeric_vertex_attr(graph, vnames[V_Y],
                        igraph_vss_1((igraph_integer_t) id), &numv);
                fputc(' ', outstream);
                igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                if (vtypes[V_Z] == IGRAPH_ATTRIBUTE_NUMERIC) {
                    igraph_i_attribute_get_numeric_vertex_attr(graph, vnames[V_Z],
                            igraph_vss_1((igraph_integer_t) id), &numv);
                    fputc(' ', outstream);
                    igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
                }
            }

            /* shape */
            if (vtypes[V_SHAPE] == IGRAPH_ATTRIBUTE_STRING) {
                igraph_i_attribute_get_string_vertex_attr(graph, vnames[V_SHAPE],
                        igraph_vss_1((igraph_integer_t) id), &strv);
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_pajek_escape(s, &escaped));
                fprintf(outstream, " %s", escaped);
                IGRAPH_FREE(escaped);
            }

            /* numeric parameters */
            for (j = 0; j < igraph_vector_size(&vx_numa); j++) {
                int idx = (int) VECTOR(vx_numa)[j];
                igraph_i_attribute_get_numeric_vertex_attr(graph, vnumnames[idx],
                        igraph_vss_1((igraph_integer_t) id), &numv);
                fprintf(outstream, " %s ", vnumnames2[idx]);
                igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
            }

            /* string parameters */
            for (j = 0; j < igraph_vector_size(&vx_stra); j++) {
                int idx = (int) VECTOR(vx_stra)[j];
                igraph_i_attribute_get_string_vertex_attr(graph, vstrnames[idx],
                        igraph_vss_1((igraph_integer_t) id), &strv);
                igraph_strvector_get(&strv, 0, &s);
                IGRAPH_CHECK(igraph_i_pajek_escape(s, &escaped));
                fprintf(outstream, " %s %s", vstrnames2[idx], escaped);
                IGRAPH_FREE(escaped);
            }

            /* trailing newline */
            fprintf(outstream, "%s", newline);
        }
    }

    /* edges header */
    if (igraph_is_directed(graph)) {
        fprintf(outstream, "*Arcs%s", newline);
    } else {
        fprintf(outstream, "*Edges%s", newline);
    }

    IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
    IGRAPH_FINALLY(igraph_es_destroy, &es);
    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    /* Check edge attributes */
    for (i = 0; i < E_LAST; i++) {
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE,
                                        enames[i])) {
            igraph_i_attribute_gettype(graph, &etypes[i], IGRAPH_ATTRIBUTE_EDGE,
                                       enames[i]);
        } else {
            etypes[i] = (igraph_attribute_type_t) -1;
        }
    }
    for (i = 0; i < (long int) (sizeof(enumnames) / sizeof(const char*)); i++) {
        igraph_attribute_type_t type;
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE,
                                        enumnames[i])) {
            igraph_i_attribute_gettype(graph, &type, IGRAPH_ATTRIBUTE_EDGE,
                                       enumnames[i]);
            if (type == IGRAPH_ATTRIBUTE_NUMERIC) {
                IGRAPH_CHECK(igraph_vector_push_back(&ex_numa, i));
            }
        }
    }
    for (i = 0; i < (long int) (sizeof(estrnames) / sizeof(const char*)); i++) {
        igraph_attribute_type_t type;
        if (igraph_i_attribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE,
                                        estrnames[i])) {
            igraph_i_attribute_gettype(graph, &type, IGRAPH_ATTRIBUTE_EDGE,
                                       estrnames[i]);
            if (type == IGRAPH_ATTRIBUTE_STRING) {
                IGRAPH_CHECK(igraph_vector_push_back(&ex_stra, i));
            }
        }
    }

    for (i = 0; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit), i++) {
        long int edge = IGRAPH_EIT_GET(eit);
        igraph_integer_t from, to;
        igraph_edge(graph, (igraph_integer_t) edge, &from,  &to);
        if (bipartite) {
            from = VECTOR(bip_index2)[from];
            to  = VECTOR(bip_index2)[to];
        }
        fprintf(outstream, "%li %li", (long int) from + 1, (long int) to + 1);

        /* Weights */
        if (etypes[E_WEIGHT] == IGRAPH_ATTRIBUTE_NUMERIC) {
            igraph_i_attribute_get_numeric_edge_attr(graph, enames[E_WEIGHT],
                    igraph_ess_1((igraph_integer_t) edge), &numv);
            fputc(' ', outstream);
            igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
        }

        /* numeric parameters */
        for (j = 0; j < igraph_vector_size(&ex_numa); j++) {
            int idx = (int) VECTOR(ex_numa)[j];
            igraph_i_attribute_get_numeric_edge_attr(graph, enumnames[idx],
                    igraph_ess_1((igraph_integer_t) edge), &numv);
            fprintf(outstream, " %s ", enumnames2[idx]);
            igraph_real_fprintf_precise(outstream, VECTOR(numv)[0]);
        }

        /* string parameters */
        for (j = 0; j < igraph_vector_size(&ex_stra); j++) {
            int idx = (int) VECTOR(ex_stra)[j];
            igraph_i_attribute_get_string_edge_attr(graph, estrnames[idx],
                                                    igraph_ess_1((igraph_integer_t) edge), &strv);
            igraph_strvector_get(&strv, 0, &s);
            IGRAPH_CHECK(igraph_i_pajek_escape(s, &escaped));
            fprintf(outstream, " %s %s", estrnames2[idx], escaped);
            IGRAPH_FREE(escaped);
        }

        /* trailing newline */
        fprintf(outstream, "%s", newline);
    }

    igraph_eit_destroy(&eit);
    igraph_es_destroy(&es);
    IGRAPH_FINALLY_CLEAN(2);

    if (bipartite) {
        igraph_vector_int_destroy(&bip_index2);
        igraph_vector_int_destroy(&bip_index);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vector_destroy(&ex_numa);
    igraph_vector_destroy(&ex_stra);
    igraph_vector_destroy(&vx_numa);
    igraph_vector_destroy(&vx_stra);
    igraph_strvector_destroy(&strv);
    igraph_vector_destroy(&numv);
    IGRAPH_FINALLY_CLEAN(6);
    return 0;
}
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.523141
igraph-0.9.9/vendor/source/igraph/src/io/parsers/0000755000175100001710000000000000000000000022527 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/dl-lexer.c0000644000175100001710000020570200000000000024415 0ustar00runnerdocker00000000000000
#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_dl_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_dl_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_dl_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_dl_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_dl_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_dl_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_dl_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_dl_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_dl_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_dl_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_dl_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_dl_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_dl_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_dl_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_dl_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_dl_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_dl_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_dl_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_dl_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_dl_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_dl_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_dl_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_dl_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_dl_yylex_ALREADY_DEFINED
#else
#define yylex igraph_dl_yylex
#endif

#ifdef yyrestart
#define igraph_dl_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_dl_yyrestart
#endif

#ifdef yylex_init
#define igraph_dl_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_dl_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_dl_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_dl_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_dl_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_dl_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_dl_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_dl_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_dl_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_dl_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_dl_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_dl_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_dl_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_dl_yyset_extra
#endif

#ifdef yyget_in
#define igraph_dl_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_dl_yyget_in
#endif

#ifdef yyset_in
#define igraph_dl_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_dl_yyset_in
#endif

#ifdef yyget_out
#define igraph_dl_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_dl_yyget_out
#endif

#ifdef yyset_out
#define igraph_dl_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_dl_yyset_out
#endif

#ifdef yyget_leng
#define igraph_dl_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_dl_yyget_leng
#endif

#ifdef yyget_text
#define igraph_dl_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_dl_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_dl_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_dl_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_dl_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_dl_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_dl_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_dl_yyget_column
#endif

#ifdef yyset_column
#define igraph_dl_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_dl_yyset_column
#endif

#ifdef yywrap
#define igraph_dl_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_dl_yywrap
#endif

#ifdef yyget_lval
#define igraph_dl_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_dl_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_dl_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_dl_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_dl_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_dl_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_dl_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_dl_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_dl_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_dl_yyalloc
#endif

#ifdef yyrealloc
#define igraph_dl_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_dl_yyrealloc
#endif

#ifdef yyfree
#define igraph_dl_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_dl_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yyg->yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yyg->yy_start - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = yyg->yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

static void yyensure_buffer_stack ( yyscan_t yyscanner );
static void yy_load_buffer_state ( yyscan_t yyscanner );
static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}
#define yy_set_bol(at_bol) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef flex_uint8_t YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
static int yy_get_next_buffer ( yyscan_t yyscanner );
static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yyg->yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yyg->yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 24
#define YY_END_OF_BUFFER 25
/* This struct is not used in this scanner,
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static const flex_int16_t yy_accept[129] =
    {   0,
        0,    0,    0,    0,    0,    0,   18,   18,   21,   21,
       25,   23,   22,    1,    1,    4,   23,   23,   23,   23,
       12,   11,   12,   12,   14,   15,   13,   17,   18,   17,
       16,   20,   21,   19,   22,    1,    4,    0,    0,    0,
        0,    0,    3,   12,   12,   12,   12,   14,   13,   17,
       18,   16,   17,   17,   20,   21,   19,    0,    2,    0,
        0,    3,   12,   12,   16,   17,   16,    0,    0,    0,
       12,   12,    5,    0,    0,    5,   12,    0,    0,   12,
        0,    0,    0,    6,   12,    0,    0,    0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,    7,    9,    0,
       10,    7,    7,    9,    8,   10,    8,    0
    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    5,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    6,    7,    8,    9,    1,   10,   11,   10,
       10,   10,   10,   10,   10,   10,   10,   12,    1,    1,
       13,    1,    1,    1,   14,   15,    1,   16,   17,   18,
       19,    1,   20,    1,    1,   21,   22,   23,   24,    1,
        1,   25,   26,   27,   28,    1,    1,   29,    1,    1,
        1,    1,    1,    1,    1,    1,   14,   15,    1,   16,

       17,   18,   19,    1,   20,    1,    1,   21,   22,   23,
       24,    1,    1,   25,   26,   27,   28,    1,    1,   29,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1
    } ;

static const YY_CHAR yy_meta[30] =
    {   0,
        1,    2,    3,    3,    2,    1,    3,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1
    } ;

static const flex_int16_t yy_base[138] =
    {   0,
        0,   22,   44,   64,   84,   94,  104,  114,  124,  134,
      287,  288,    4,  282,  282,    2,    1,  260,  269,   15,
       29,  288,   39,   50,    0,  288,   34,    0,   52,   19,
       64,    0,   54,   51,   74,  288,   67,  255,   88,  256,
      265,  138,   98,  108,  118,  128,  144,    0,  145,    0,
      151,  151,   72,  159,    0,  152,  153,  265,  169,  256,
      260,  170,  171,  175,  171,  168,  173,  264,  261,  253,
      184,  185,  288,  246,  246,  189,  193,  195,  197,  199,
      205,  218,  209,  288,  210,    0,  255,  242,  245,  246,
      248,  245,  249,  231,  228,  217,  211,  200,  184,  181,

      172,  150,  138,  138,  128,  126,  106,   75,   66,   67,
       45,   45,   36,   42,   39,   22,   26,  219,  211,    6,
      220,  227,  228,  232,  237,  238,  242,  288,  247,  250,
      253,  256,  259,  262,    7,    6,    0
    } ;

static const flex_int16_t yy_def[138] =
    {   0,
      129,  129,  130,  130,  131,  131,  132,  132,  133,  133,
      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
      134,  128,  134,  134,  135,  128,  135,  136,  128,  136,
      136,  137,  128,  137,  128,  128,  128,  128,  128,  128,
      128,  128,  128,  134,  128,  134,  134,  135,  128,  136,
      128,  136,  136,  136,  137,  128,  137,  128,  128,  128,
      128,  128,  134,  134,  136,  136,  136,  128,  128,  128,
      134,  134,  128,  128,  128,  134,  134,  128,  128,  134,
      128,  128,  128,  128,  128,   82,  128,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,

      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128,    0,  128,  128,
      128,  128,  128,  128,  128,  128,  128
    } ;

static const flex_int16_t yy_nxt[318] =
    {   0,
       55,   13,   14,   15,   13,   35,   50,   48,   35,   16,
       16,   37,   37,  128,   38,   17,   42,   18,  128,   42,
       19,   39,   20,   13,   14,   15,   13,   43,   52,   52,
       45,   16,   16,   45,  125,   49,  121,   17,   49,   18,
       45,  120,   19,   45,   20,   12,   14,   15,   22,  119,
       22,   45,   46,   51,   45,   56,   51,  118,   56,   23,
       57,   57,  117,   47,   24,   12,   14,   15,   22,  116,
       22,  115,   53,   52,   52,   35,   37,   37,   35,   23,
       54,   65,   65,  114,   24,   26,   14,   15,   26,   59,
       12,  113,   59,   27,   27,   26,   14,   15,   26,   62,

       12,  112,   62,   27,   27,   29,   14,   15,   29,   45,
       12,   30,   45,   31,   31,   29,   14,   15,   29,   45,
       12,   30,   45,   31,   31,   33,   14,   15,   33,   45,
       12,  111,   45,   34,   34,   33,   14,   15,   33,   42,
       12,  110,   42,   34,   34,   45,   49,  109,   45,   49,
       43,  108,   51,   56,   63,   51,   56,  107,   64,   53,
       52,   52,   57,   57,   66,  106,   66,   54,   67,   67,
       59,   62,   45,   59,   62,   45,   45,   67,   67,   45,
       65,   65,   67,   67,   71,   45,   45,   54,   45,   45,
       45,   72,  105,   45,   45,   76,   81,   45,   83,   81,

       85,   83,  104,   85,  103,   77,   81,   82,   84,   81,
       83,   85,  124,   83,   85,  124,  102,   82,   80,   86,
      122,  126,   86,  122,  126,   90,   90,  101,  122,  122,
      123,  122,  122,  124,   87,   88,  124,  100,  127,  126,
       89,  127,  126,  127,   99,   98,  127,   12,   12,   12,
       21,   21,   21,   25,   25,   25,   28,   28,   28,   32,
       32,   32,   44,   44,   97,   96,   95,   94,   93,   92,
       91,   79,   78,   75,   74,   73,   70,   69,   68,   61,
       60,   58,   41,   40,   36,   36,  128,   11,  128,  128,
      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,

      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128
    } ;

static const flex_int16_t yy_chk[318] =
    {   0,
      137,    1,    1,    1,    1,   13,  136,  135,   13,    1,
        1,   16,   16,    0,   17,    1,   20,    1,    0,   20,
        1,   17,    1,    2,    2,    2,    2,   20,   30,   30,
       21,    2,    2,   21,  120,   27,  117,    2,   27,    2,
       23,  116,    2,   23,    2,    3,    3,    3,    3,  115,
        3,   24,   23,   29,   24,   33,   29,  114,   33,    3,
       34,   34,  113,   24,    3,    4,    4,    4,    4,  112,
        4,  111,   31,   31,   31,   35,   37,   37,   35,    4,
       31,   53,   53,  110,    4,    5,    5,    5,    5,   39,
        5,  109,   39,    5,    5,    6,    6,    6,    6,   43,

        6,  108,   43,    6,    6,    7,    7,    7,    7,   44,
        7,    7,   44,    7,    7,    8,    8,    8,    8,   45,
        8,    8,   45,    8,    8,    9,    9,    9,    9,   46,
        9,  107,   46,    9,    9,   10,   10,   10,   10,   42,
       10,  106,   42,   10,   10,   47,   49,  105,   47,   49,
       42,  104,   51,   56,   46,   51,   56,  103,   47,   52,
       52,   52,   57,   57,   54,  102,   54,   52,   54,   54,
       59,   62,   63,   59,   62,   63,   64,   66,   66,   64,
       65,   65,   67,   67,   63,   71,   72,   65,   71,   72,
       76,   64,  101,   76,   77,   71,   78,   77,   79,   78,

       80,   79,  100,   80,   99,   72,   81,   78,   79,   81,
       83,   85,  119,   83,   85,  119,   98,   81,   77,   82,
      118,  121,   82,  118,  121,   83,   85,   97,  122,  123,
      118,  122,  123,  124,   82,   82,  124,   96,  125,  126,
       82,  125,  126,  127,   95,   94,  127,  129,  129,  129,
      130,  130,  130,  131,  131,  131,  132,  132,  132,  133,
      133,  133,  134,  134,   93,   92,   91,   90,   89,   88,
       87,   75,   74,   70,   69,   68,   61,   60,   58,   41,
       40,   38,   19,   18,   15,   14,   11,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,

      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
      128,  128,  128,  128,  128,  128,  128
    } ;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 
#include 

#include "io/dl-header.h"
#include "io/parsers/dl-parser.h"

#define YY_EXTRA_TYPE igraph_i_dl_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
#define YY_NO_INPUT 1

#define INITIAL 0
#define LABELM 1
#define FULLMATRIX 2
#define EDGELIST 3
#define NODELIST 4

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    YYSTYPE * yylval_r;

    YYLTYPE * yylloc_r;

    }; /* end struct yyguts_t */

static int yy_init_globals ( yyscan_t yyscanner );

    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval yyg->yylval_r
    
    #    define yylloc yyg->yylloc_r
    
int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef YY_NO_UNPUT
    
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput ( yyscan_t yyscanner );
#else
static int input ( yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    yylval = yylval_param;

    yylloc = yylloc_param;

	if ( !yyg->yy_init )
		{
		yyg->yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yyg->yy_start )
			yyg->yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			yyensure_buffer_stack (yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
		}

		yy_load_buffer_state( yyscanner );
		}

	{

	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yyg->yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yyg->yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yyg->yy_start;
yy_match:
		do
			{
			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
			if ( yy_accept[yy_current_state] )
				{
				yyg->yy_last_accepting_state = yy_current_state;
				yyg->yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 129 )
					yy_c = yy_meta[yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 288 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

do_action:	/* This label is used only to access EOF actions. */

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yyg->yy_hold_char;
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			goto yy_find_action;

case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
{ return NEWLINE; }
	YY_BREAK
case 2:
YY_RULE_SETUP
{ return DL; }
	YY_BREAK
case 3:
YY_RULE_SETUP
{
  return NEQ; }
	YY_BREAK
case 4:
YY_RULE_SETUP
{ return NUM; }
	YY_BREAK
case 5:
YY_RULE_SETUP
{
  switch (yyextra->mode) {
  case 0: BEGIN(FULLMATRIX);
    break;
  case 1: BEGIN(EDGELIST);
    break;
  case 2: BEGIN(NODELIST);
    break;
  }
  return DATA; }
	YY_BREAK
case 6:
YY_RULE_SETUP
{ BEGIN(LABELM); return LABELS; }
	YY_BREAK
case 7:
YY_RULE_SETUP
{
  return LABELSEMBEDDED; }
	YY_BREAK
case 8:
YY_RULE_SETUP
{
  yyextra->mode=0; return FORMATFULLMATRIX; }
	YY_BREAK
case 9:
YY_RULE_SETUP
{
  yyextra->mode=1; return FORMATEDGELIST1; }
	YY_BREAK
case 10:
YY_RULE_SETUP
{
  yyextra->mode=2; return FORMATNODELIST1; }
	YY_BREAK
case 11:
YY_RULE_SETUP
{ /* eaten up */ }
	YY_BREAK
case 12:
YY_RULE_SETUP
{ return LABEL; }
	YY_BREAK
case 13:
YY_RULE_SETUP
{ return DIGIT; }
	YY_BREAK
case 14:
YY_RULE_SETUP
{ return LABEL; }
	YY_BREAK
case 15:
YY_RULE_SETUP
{ }
	YY_BREAK
case 16:
YY_RULE_SETUP
{ return NUM; }
	YY_BREAK
case 17:
YY_RULE_SETUP
{ return LABEL; }
	YY_BREAK
case 18:
YY_RULE_SETUP
{ }
	YY_BREAK
case 19:
YY_RULE_SETUP
{ return NUM; }
	YY_BREAK
case 20:
YY_RULE_SETUP
{ return LABEL; }
	YY_BREAK
case 21:
YY_RULE_SETUP
{ }
	YY_BREAK
case 22:
YY_RULE_SETUP
{ /* eaten up */ }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(LABELM):
case YY_STATE_EOF(FULLMATRIX):
case YY_STATE_EOF(EDGELIST):
case YY_STATE_EOF(NODELIST):
{
                          if (yyextra->eof) {
                            yyterminate();
                          } else {
                            yyextra->eof=1;
                            BEGIN(INITIAL);
                            return EOFF;
                          }
                        }
	YY_BREAK
case 23:
YY_RULE_SETUP
{ return 0; }
	YY_BREAK
case 24:
YY_RULE_SETUP
YY_FATAL_ERROR( "flex scanner jammed" );
	YY_BREAK

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yyg->yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between YY_CURRENT_BUFFER and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state( yyscanner );

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yyg->yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yyg->yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer( yyscanner ) )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yyg->yy_did_buffer_switch_on_eof = 0;

				if ( yywrap( yyscanner ) )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yyg->yy_c_buf_p =
					yyg->yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yyg->yy_c_buf_p =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
static int yy_get_next_buffer (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = yyg->yytext_ptr;
	int number_to_move, i;
	int ret_val;

	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

	else
		{
			int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
				}
			else
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			yyg->yy_n_chars, num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	if ( yyg->yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  , yyscanner);
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	yyg->yy_n_chars += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}

/* yy_get_previous_state - get the state just before the EOB char was reached */

    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 129 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 129 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 128);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_UNPUT

#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
	int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	*yyg->yy_c_buf_p = yyg->yy_hold_char;

	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			/* This was really a NUL. */
			*yyg->yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
			++yyg->yy_c_buf_p;

			switch ( yy_get_next_buffer( yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin , yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap( yyscanner ) )
						return 0;

					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput(yyscanner);
#else
					return input(yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
	yyg->yy_hold_char = *++yyg->yy_c_buf_p;

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * @param yyscanner The scanner object.
 */
    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param yyscanner The scanner object.
 */
    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param yyscanner The scanner object.
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (yyscan_t yyscanner)
{
	yy_size_t num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if (!yyg->yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		yyg->yy_buffer_stack_max = num_to_alloc;
		yyg->yy_buffer_stack_top = 0;
		return;
	}

	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
								(yyg->yy_buffer_stack,
								num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		yyg->yy_buffer_stack_max = num_to_alloc;
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b , yyscanner );

	return b;
}

/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
    
	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n , yyscanner );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n , yyscanner);
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		*yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int yyget_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *yyget_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param _line_number line number
 * @param yyscanner The scanner object.
 */
void yyset_lineno (int  _line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
    
    yylineno = _line_number;
}

/** Set the current column.
 * @param _column_no column number
 * @param yyscanner The scanner object.
 */
void yyset_column (int  _column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_column called with no buffer" );
    
    yycolumn = _column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = _in_str ;
}

void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = _out_str ;
}

int yyget_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void yyset_debug (int  _bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = _bdebug ;
}

/* Accessor methods for yylval and yylloc */

YYSTYPE * yyget_lval  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}
    
void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}
    
/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
    struct yyguts_t dummy_yyguts;

    yyset_extra (yy_user_defined, &dummy_yyguts);

    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    yyset_extra (yy_user_defined, *ptr_yy_globals);

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = NULL;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = NULL;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = NULL;
    yyout = NULL;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(yyscanner);
	}

	/* Destroy the stack itself. */
	yyfree(yyg->yy_buffer_stack , yyscanner);
	yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        yyfree( yyg->yy_start_stack , yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif

void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	return malloc(size);
}

void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}

void yyfree (void * ptr , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/dl-lexer.h0000644000175100001710000004157700000000000024432 0ustar00runnerdocker00000000000000#ifndef igraph_dl_yyHEADER_H
#define igraph_dl_yyHEADER_H 1
#define igraph_dl_yyIN_HEADER 1

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_dl_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_dl_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_dl_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_dl_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_dl_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_dl_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_dl_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_dl_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_dl_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_dl_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_dl_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_dl_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_dl_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_dl_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_dl_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_dl_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_dl_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_dl_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_dl_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_dl_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_dl_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_dl_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_dl_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_dl_yylex_ALREADY_DEFINED
#else
#define yylex igraph_dl_yylex
#endif

#ifdef yyrestart
#define igraph_dl_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_dl_yyrestart
#endif

#ifdef yylex_init
#define igraph_dl_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_dl_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_dl_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_dl_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_dl_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_dl_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_dl_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_dl_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_dl_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_dl_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_dl_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_dl_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_dl_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_dl_yyset_extra
#endif

#ifdef yyget_in
#define igraph_dl_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_dl_yyget_in
#endif

#ifdef yyset_in
#define igraph_dl_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_dl_yyset_in
#endif

#ifdef yyget_out
#define igraph_dl_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_dl_yyget_out
#endif

#ifdef yyset_out
#define igraph_dl_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_dl_yyset_out
#endif

#ifdef yyget_leng
#define igraph_dl_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_dl_yyget_leng
#endif

#ifdef yyget_text
#define igraph_dl_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_dl_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_dl_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_dl_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_dl_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_dl_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_dl_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_dl_yyget_column
#endif

#ifdef yyset_column
#define igraph_dl_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_dl_yyset_column
#endif

#ifdef yywrap
#define igraph_dl_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_dl_yywrap
#endif

#ifdef yyget_lval
#define igraph_dl_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_dl_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_dl_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_dl_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_dl_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_dl_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_dl_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_dl_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_dl_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_dl_yyalloc
#endif

#ifdef yyrealloc
#define igraph_dl_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_dl_yyrealloc
#endif

#ifdef yyfree
#define igraph_dl_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_dl_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP

#define yytext_ptr yytext_r

#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0
#define LABELM 1
#define FULLMATRIX 2
#define EDGELIST 3
#define NODELIST 4

#endif

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* yy_get_previous_state - get the state just before the EOB char was reached */

#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif

#ifndef igraph_dl_yy_create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef igraph_dl_yy_delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef igraph_dl_yy_scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef igraph_dl_yy_scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef igraph_dl_yy_scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef igraph_dl_yy_init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef igraph_dl_yy_flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef igraph_dl_yy_load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef igraph_dl_yy_switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef igraph_dl_yypush_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef igraph_dl_yypop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef igraph_dl_yyensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef igraph_dl_yylex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef igraph_dl_yyrestart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef igraph_dl_yylex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef igraph_dl_yylex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef igraph_dl_yylex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef igraph_dl_yyget_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef igraph_dl_yyset_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef igraph_dl_yyget_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef igraph_dl_yyset_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef igraph_dl_yyget_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef igraph_dl_yyset_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef igraph_dl_yyget_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef igraph_dl_yyset_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef igraph_dl_yyget_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef igraph_dl_yyget_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef igraph_dl_yyget_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef igraph_dl_yyset_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef igraph_dl_yyget_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef igraph_dl_yyset_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef igraph_dl_yywrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef igraph_dl_yyget_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef igraph_dl_yyset_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef igraph_dl_yyget_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef igraph_dl_yyset_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef igraph_dl_yyalloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef igraph_dl_yyrealloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef igraph_dl_yyfree_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef igraph_dl_yytext_ALREADY_DEFINED
#undef yytext
#endif
#ifndef igraph_dl_yyleng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef igraph_dl_yyin_ALREADY_DEFINED
#undef yyin
#endif
#ifndef igraph_dl_yyout_ALREADY_DEFINED
#undef yyout
#endif
#ifndef igraph_dl_yy_flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef igraph_dl_yylineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef igraph_dl_yytables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef igraph_dl_yytables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef igraph_dl_yyTABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif

#undef igraph_dl_yyIN_HEADER
#endif /* igraph_dl_yyHEADER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/dl-parser.c0000644000175100001710000020701000000000000024564 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "3.5.1"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 1

/* Push parsers.  */
#define YYPUSH 0

/* Pull parsers.  */
#define YYPULL 1


/* Substitute the variable and function names.  */
#define yyparse         igraph_dl_yyparse
#define yylex           igraph_dl_yylex
#define yyerror         igraph_dl_yyerror
#define yydebug         igraph_dl_yydebug
#define yynerrs         igraph_dl_yynerrs

/* First part of user prologue.  */


/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"

#include "core/math.h"
#include "internal/hacks.h"
#include "io/dl-header.h"
#include "io/parsers/dl-parser.h"
#include "io/parsers/dl-lexer.h"

#include 

int igraph_dl_yyerror(YYLTYPE* locp, igraph_i_dl_parsedata_t* context,
                      const char *s);
int igraph_i_dl_add_str(char *newstr, int length,
                        igraph_i_dl_parsedata_t *context);
int igraph_i_dl_add_edge(long int from, long int to,
                         igraph_i_dl_parsedata_t *context);
int igraph_i_dl_add_edge_w(long int from, long int to,
                           igraph_real_t weight,
                           igraph_i_dl_parsedata_t *context);

extern igraph_real_t igraph_pajek_get_number(const char *str, long int len);

#define scanner context->scanner



# ifndef YY_CAST
#  ifdef __cplusplus
#   define YY_CAST(Type, Val) static_cast (Val)
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val)
#  else
#   define YY_CAST(Type, Val) ((Type) (Val))
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
#  endif
# endif
# ifndef YY_NULLPTR
#  if defined __cplusplus
#   if 201103L <= __cplusplus
#    define YY_NULLPTR nullptr
#   else
#    define YY_NULLPTR 0
#   endif
#  else
#   define YY_NULLPTR ((void*)0)
#  endif
# endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif

/* Use api.header.include to #include this header
   instead of duplicating it here.  */
#ifndef YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED
# define YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_dl_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    NUM = 258,
    NEWLINE = 259,
    DL = 260,
    NEQ = 261,
    DATA = 262,
    LABELS = 263,
    LABELSEMBEDDED = 264,
    FORMATFULLMATRIX = 265,
    FORMATEDGELIST1 = 266,
    FORMATNODELIST1 = 267,
    DIGIT = 268,
    LABEL = 269,
    EOFF = 270,
    ERROR = 271
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int integer;
  igraph_real_t real;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_dl_yyparse (igraph_i_dl_parsedata_t* context);

#endif /* !YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED  */



#ifdef short
# undef short
#endif

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
    and (if available)  are included
   so that the code can choose integer types of a good width.  */

#ifndef __PTRDIFF_MAX__
# include  /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YY_STDINT_H
# endif
#endif

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif

#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif

#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif

#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif

#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
#  ifndef ptrdiff_t
#   include  /* INFRINGES ON USER NAME SPACE */
#  endif
#  define YYPTRDIFF_T ptrdiff_t
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
#  define YYPTRDIFF_T long
#  define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned
# endif
#endif

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))

/* Stored state numbers (used for stacks). */
typedef yytype_uint8 yy_state_t;

/* State numbers in computations.  */
typedef int yy_state_fast_t;

#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
#  if ENABLE_NLS
#   include  /* INFRINGES ON USER NAME SPACE */
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(Msgid) Msgid
# endif
#endif

#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define YY_ATTRIBUTE_PURE
# endif
#endif

#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
#  define YY_ATTRIBUTE_UNUSED
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif

#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
    _Pragma ("GCC diagnostic push")                                     \
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
    _Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif

#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
    _Pragma ("GCC diagnostic push")                            \
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END            \
    _Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif


#define YY_ASSERT(E) ((void) (0 && (E)))

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include  /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include  /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
#     include  /* INFRINGES ON USER NAME SPACE */
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
#     ifndef EXIT_SUCCESS
#      define EXIT_SUCCESS 0
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's 'empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
       && ! ((defined YYMALLOC || defined malloc) \
             && (defined YYFREE || defined free)))
#   include  /* INFRINGES ON USER NAME SPACE */
#   ifndef EXIT_SUCCESS
#    define EXIT_SUCCESS 0
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yy_state_t yyss_alloc;
  YYSTYPE yyvs_alloc;
  YYLTYPE yyls_alloc;
};

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
             + YYSIZEOF (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(Dst, Src, Count) \
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  else
#   define YYCOPY(Dst, Src, Count)              \
      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)
#  endif
# endif
#endif /* !YYCOPY_NEEDED */

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  4
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   118

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  17
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  37
/* YYNRULES -- Number of rules.  */
#define YYNRULES  66
/* YYNSTATES -- Number of states.  */
#define YYNSTATES  138

#define YYUNDEFTOK  2
#define YYMAXUTOK   271


/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */
#define YYTRANSLATE(YYX)                                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex.  */
static const yytype_int8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16
};

#if YYDEBUG
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
static const yytype_int16 yyrline[] =
{
       0,   108,   108,   110,   110,   112,   112,   114,   115,   116,
     119,   119,   121,   121,   123,   124,   125,   128,   129,   135,
     135,   140,   140,   142,   152,   154,   156,   156,   158,   162,
     166,   171,   175,   177,   178,   179,   180,   181,   184,   185,
     188,   190,   194,   197,   198,   201,   203,   207,   210,   226,
     228,   229,   230,   231,   232,   235,   236,   239,   241,   244,
     244,   250,   251,   254,   256,   260,   260
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "NUM", "NEWLINE", "DL", "NEQ", "DATA",
  "LABELS", "LABELSEMBEDDED", "FORMATFULLMATRIX", "FORMATEDGELIST1",
  "FORMATNODELIST1", "DIGIT", "LABEL", "EOFF", "ERROR", "$accept", "input",
  "trail", "eof", "rest", "formfullmatrix", "newline", "fullmatrix",
  "labels", "fullmatrixdata", "zerooneseq", "zeroone",
  "labeledfullmatrixdata", "reallabeledfullmatrixdata", "labelseq",
  "label", "labeledmatrixlines", "labeledmatrixline", "edgelist1",
  "edgelist1rest", "edgelist1data", "edgelist1dataline", "integer",
  "labelededgelist1data", "labelededgelist1dataline", "weight", "elabel",
  "nodelist1", "nodelist1rest", "nodelist1data", "nodelist1dataline",
  "from", "tolist", "labelednodelist1data", "labelednodelist1dataline",
  "fromelabel", "labeltolist", YY_NULLPTR
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
   (internal) symbol number NUM (which must be that of a token).  */
static const yytype_int16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271
};
# endif

#define YYPACT_NINF (-114)

#define yypact_value_is_default(Yyn) \
  ((Yyn) == YYPACT_NINF)

#define YYTABLE_NINF (-22)

#define yytable_value_is_error(Yyn) \
  0

  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
static const yytype_int8 yypact[] =
{
       8,    38,    11,    43,  -114,  -114,    44,    57,    46,    46,
      46,    46,    46,    46,  -114,  -114,  -114,  -114,  -114,  -114,
    -114,  -114,    69,    53,    63,    66,     6,    65,    46,    46,
    -114,    46,    46,    46,  -114,  -114,    46,    46,  -114,  -114,
    -114,  -114,     5,    19,  -114,  -114,  -114,    76,    84,  -114,
      82,  -114,  -114,  -114,    46,  -114,  -114,  -114,    93,    43,
      46,    46,    46,  -114,  -114,  -114,    46,    46,    46,  -114,
      85,    86,  -114,    43,    23,  -114,  -114,    88,    33,  -114,
    -114,    65,  -114,    85,  -114,  -114,  -114,    90,    46,    46,
      87,    46,  -114,  -114,    46,    46,    87,    46,    25,  -114,
    -114,  -114,    94,  -114,    95,  -114,  -114,    87,    29,  -114,
      96,  -114,  -114,  -114,    49,  -114,  -114,    43,    46,    92,
      46,    84,    46,     2,    46,  -114,  -114,   100,  -114,  -114,
    -114,  -114,  -114,    87,  -114,    87,    87,    87
};

  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     Performed when YYTABLE does not specify something else to do.  Zero
     means the default is an error.  */
static const yytype_int8 yydefact[] =
{
       0,     0,     0,     0,     1,    42,     0,     0,    12,    12,
      12,    12,    12,    12,     3,     7,    11,     8,     9,    13,
      19,    17,     0,     0,     0,     0,     5,    14,    12,    12,
      10,    12,    12,    12,    32,    55,    12,    12,    49,     6,
       2,     4,     0,     0,    26,    38,    17,     0,    50,    17,
       0,    20,    23,    22,    12,    18,    16,    24,    12,    33,
      12,    12,    12,    58,    56,    59,    12,    12,    12,    19,
       0,     0,    39,     0,     0,    43,    17,     0,     0,    61,
      17,    15,    21,    25,    29,    28,    27,     0,    12,    12,
      35,    12,    57,    60,    12,    12,    52,    12,     0,    30,
      47,    41,     0,    38,     0,    48,    44,     0,     0,    55,
       0,    64,    62,    65,     0,    31,    40,    34,    12,     0,
      12,    51,    12,     0,    12,    43,    46,     0,    43,    61,
      63,    66,    61,    36,    45,    37,    53,    54
};

  /* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
    -114,  -114,  -114,  -114,  -114,  -114,    -9,    83,   -41,    36,
      26,  -114,  -114,  -114,  -114,  -114,  -114,    24,  -114,  -114,
       7,  -114,     4,  -113,  -114,    -7,   -82,  -114,  -114,     9,
    -114,  -114,  -114,   -98,  -114,  -114,  -114
};

  /* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int8 yydefgoto[] =
{
      -1,     2,    26,    40,    14,    15,    20,    16,    28,    27,
      42,    53,    56,    57,    58,    86,    83,    84,    17,    34,
      59,    72,    73,    90,   106,   102,   107,    18,    38,    48,
      64,    65,    77,    96,   112,   113,   123
};

  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule whose
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
static const yytype_int16 yytable[] =
{
      21,    22,    23,    24,    25,    60,   130,     6,    66,    51,
      19,     4,   133,     1,   111,   135,   105,    41,    52,    43,
      44,    39,    45,    46,    47,   119,    54,    49,    50,   115,
      88,   136,    89,    55,   137,    91,   120,    55,    52,    97,
      94,   131,    95,    55,     3,    69,     5,    55,     7,    71,
      19,    74,    75,    76,   111,   111,   124,    78,    79,    80,
       8,     9,    10,    55,     8,     9,    10,    11,    12,    13,
      31,    32,    33,    35,    36,    37,    29,    87,   -21,   103,
     104,    93,   108,    61,    62,   109,   110,    63,   114,    67,
      68,     5,    92,   100,   101,   100,   126,    70,   116,    82,
      85,   105,   118,   122,   134,    81,    30,    99,    98,   125,
     117,   128,   127,   129,     0,   132,     0,     0,   121
};

static const yytype_int16 yycheck[] =
{
       9,    10,    11,    12,    13,    46,     4,     3,    49,     4,
       4,     0,   125,     5,    96,   128,    14,    26,    13,    28,
      29,    15,    31,    32,    33,   107,     7,    36,    37,     4,
       7,   129,     9,    14,   132,    76,     7,    14,    13,    80,
       7,   123,     9,    14,     6,    54,     3,    14,     4,    58,
       4,    60,    61,    62,   136,   137,     7,    66,    67,    68,
       7,     8,     9,    14,     7,     8,     9,    10,    11,    12,
       7,     8,     9,     7,     8,     9,     7,    73,    13,    88,
      89,    77,    91,     7,     8,    94,    95,     3,    97,     7,
       8,     3,     4,     3,     4,     3,     4,     4,     4,    14,
      14,    14,     7,     7,     4,    69,    23,    83,    82,   118,
     103,   120,   119,   122,    -1,   124,    -1,    -1,   109
};

  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
static const yytype_int8 yystos[] =
{
       0,     5,    18,     6,     0,     3,    39,     4,     7,     8,
       9,    10,    11,    12,    21,    22,    24,    35,    44,     4,
      23,    23,    23,    23,    23,    23,    19,    26,    25,     7,
      24,     7,     8,     9,    36,     7,     8,     9,    45,    15,
      20,    23,    27,    23,    23,    23,    23,    23,    46,    23,
      23,     4,    13,    28,     7,    14,    29,    30,    31,    37,
      25,     7,     8,     3,    47,    48,    25,     7,     8,    23,
       4,    23,    38,    39,    23,    23,    23,    49,    23,    23,
      23,    26,    14,    33,    34,    14,    32,    39,     7,     9,
      40,    25,     4,    39,     7,     9,    50,    25,    27,    34,
       3,     4,    42,    23,    23,    14,    41,    43,    23,    23,
      23,    43,    51,    52,    23,     4,     4,    37,     7,    43,
       7,    46,     7,    53,     7,    23,     4,    42,    23,    23,
       4,    43,    23,    40,     4,    40,    50,    50
};

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_int8 yyr1[] =
{
       0,    17,    18,    19,    19,    20,    20,    21,    21,    21,
      22,    22,    23,    23,    24,    24,    24,    25,    25,    26,
      26,    27,    27,    28,    29,    30,    31,    31,    32,    33,
      33,    34,    35,    36,    36,    36,    36,    36,    37,    37,
      38,    38,    39,    40,    40,    41,    41,    42,    43,    44,
      45,    45,    45,    45,    45,    46,    46,    47,    48,    49,
      49,    50,    50,    51,    52,    53,    53
};

  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
static const yytype_int8 yyr2[] =
{
       0,     2,     7,     0,     2,     0,     1,     1,     1,     1,
       3,     1,     0,     1,     3,     7,     5,     0,     3,     0,
       3,     0,     2,     1,     1,     3,     0,     3,     1,     1,
       2,     3,     3,     3,     7,     5,     9,     9,     0,     2,
       4,     3,     1,     0,     2,     4,     3,     1,     1,     3,
       2,     7,     5,     9,     9,     0,     2,     3,     1,     0,
       2,     0,     2,     3,     1,     0,     2
};


#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         (-2)
#define YYEOF           0

#define YYACCEPT        goto yyacceptlab
#define YYABORT         goto yyabortlab
#define YYERROR         goto yyerrorlab


#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

/* Error token number */
#define YYTERROR        1
#define YYERRCODE       256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    do                                                                  \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)
#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K])


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)                        \
do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL

/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */

YY_ATTRIBUTE_UNUSED
static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
  int res = 0;
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
  if (0 <= yylocp->first_line)
    {
      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
      if (0 <= yylocp->first_column)
        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
    }
  if (0 <= yylocp->last_line)
    {
      if (yylocp->first_line < yylocp->last_line)
        {
          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
          if (0 <= end_col)
            res += YYFPRINTF (yyo, ".%d", end_col);
        }
      else if (0 <= end_col && yylocp->first_column < end_col)
        res += YYFPRINTF (yyo, "-%d", end_col);
    }
  return res;
 }

#  define YY_LOCATION_PRINT(File, Loc)          \
  yy_location_print_ (File, &(Loc))

# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Type, Value, Location, context); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)


/*-----------------------------------.
| Print this symbol's value on YYO.  |
`-----------------------------------*/

static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_dl_parsedata_t* context)
{
  FILE *yyoutput = yyo;
  YYUSE (yyoutput);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}


/*---------------------------.
| Print this symbol on YYO.  |
`---------------------------*/

static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_dl_parsedata_t* context)
{
  YYFPRINTF (yyo, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  YY_LOCATION_PRINT (yyo, *yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, context);
  YYFPRINTF (yyo, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)                            \
do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, igraph_i_dl_parsedata_t* context)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[+yyssp[yyi + 1 - yynrhs]],
                       &yyvsp[(yyi + 1) - (yynrhs)]
                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , context);
      YYFPRINTF (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)          \
do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif


#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
#  else
/* Return the length of YYSTR.  */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}
# endif

/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
                yy_state_t *yyssp, int yytoken)
{
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
     one per "expected"). */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Actual size of YYARG. */
  int yycount = 0;
  /* Cumulated lengths of YYARG.  */
  YYPTRDIFF_T yysize = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[+*yyssp];
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
      yysize = yysize0;
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYPTRDIFF_T yysize1
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                    yysize = yysize1;
                  else
                    return 2;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
    default: /* Avoid compiler warnings. */
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    /* Don't count the "%s"s in the final size, but reserve room for
       the terminator.  */
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
      yysize = yysize1;
    else
      return 2;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          ++yyp;
          ++yyformat;
        }
  }
  return 0;
}
#endif /* YYERROR_VERBOSE */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, igraph_i_dl_parsedata_t* context)
{
  YYUSE (yyvaluep);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}




/*----------.
| yyparse.  |
`----------*/

int
yyparse (igraph_i_dl_parsedata_t* context)
{
/* The lookahead symbol.  */
int yychar;


/* The semantic value of the lookahead symbol.  */
/* Default value used for initialization, for pacifying older GCCs
   or non-GCC compilers.  */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Location data for the lookahead symbol.  */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
  = { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;

    /* Number of syntax errors so far.  */
    int yynerrs;

    yy_state_fast_t yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       'yyss': related to states.
       'yyvs': related to semantic values.
       'yyls': related to locations.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss;
    yy_state_t *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    /* The location stack.  */
    YYLTYPE yylsa[YYINITDEPTH];
    YYLTYPE *yyls;
    YYLTYPE *yylsp;

    /* The locations where the error started and ended.  */
    YYLTYPE yyerror_range[3];

    YYPTRDIFF_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yylsp = yyls = yylsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  yylsp[0] = yylloc;
  goto yysetstate;


/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;


/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END

  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    goto yyexhaustedlab;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;

# if defined yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
        YYLTYPE *yyls1 = yyls;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yyls1, yysize * YYSIZEOF (*yylsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
        yyls = yyls1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
        YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
      yylsp = yyls + yysize - 1;

      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:
  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = yylex (&yylval, &yylloc, scanner);
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
  *++yylsp = yylloc;

  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     '$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  yyerror_range[1] = yyloc;
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
  case 2:
                                             { context->n=(yyvsp[-4].integer); }
    break;

  case 7:
                        { context->type=IGRAPH_DL_MATRIX; }
    break;

  case 8:
                        { context->type=IGRAPH_DL_EDGELIST1; }
    break;

  case 9:
                        { context->type=IGRAPH_DL_NODELIST1; }
    break;

  case 10:
                                                     {}
    break;

  case 11:
                                                                     {}
    break;

  case 14:
                                          { }
    break;

  case 15:
                                                                        { }
    break;

  case 16:
                                                                        { }
    break;

  case 17:
              {}
    break;

  case 18:
                                   {
              igraph_i_dl_add_str(igraph_dl_yyget_text(scanner),
                                  igraph_dl_yyget_leng(scanner),
                                  context); }
    break;

  case 19:
                {}
    break;

  case 20:
                                                       {
  context->from += 1;
  context->to = 0;
 }
    break;

  case 22:
                                 { }
    break;

  case 23:
               {
  if (igraph_dl_yyget_text(scanner)[0]=='1') {
    IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                         context->from));
    IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                         context->to));
  }
  context->to += 1;
}
    break;

  case 24:
                                                 {}
    break;

  case 25:
                                                               {}
    break;

  case 28:
             { igraph_i_dl_add_str(igraph_dl_yyget_text(scanner),
                                   igraph_dl_yyget_leng(scanner),
                                   context); }
    break;

  case 29:
                                      {
                 context->from += 1;
                 context->to = 0;
               }
    break;

  case 30:
                                                    {
                 context->from += 1;
                 context->to = 0;
               }
    break;

  case 31:
                                            { }
    break;

  case 32:
                                                 {}
    break;

  case 33:
                                            {}
    break;

  case 34:
                                                                        {}
    break;

  case 35:
                                                                        {}
    break;

  case 36:
                                                                                                      {}
    break;

  case 37:
                                                                                                      {}
    break;

  case 38:
               {}
    break;

  case 39:
                                               {}
    break;

  case 40:
                                                  {
                   igraph_i_dl_add_edge_w((yyvsp[-3].integer)-1, (yyvsp[-2].integer)-1, (yyvsp[-1].real), context); }
    break;

  case 41:
                                           {
                   igraph_i_dl_add_edge((yyvsp[-2].integer)-1, (yyvsp[-1].integer)-1, context);
}
    break;

  case 42:
             { (yyval.integer)=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                          igraph_dl_yyget_leng(scanner)); }
    break;

  case 43:
                      {}
    break;

  case 44:
                                                                    {}
    break;

  case 45:
                                                       {
                          igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context); }
    break;

  case 46:
                                                {
                          igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context);
 }
    break;

  case 47:
            { (yyval.real)=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                         igraph_dl_yyget_leng(scanner)); }
    break;

  case 48:
              {
  /* Copy label list to trie, if needed */
  if (igraph_strvector_size(&context->labels) != 0) {
    long int i, id, n=igraph_strvector_size(&context->labels);
    for (i=0; itrie,
                      STR(context->labels, i), &id);
    }
    igraph_strvector_clear(&context->labels);
  }
  igraph_trie_get2(&context->trie, igraph_dl_yyget_text(scanner),
                   igraph_dl_yyget_leng(scanner), &(yyval.integer));
 }
    break;

  case 49:
                                                 {}
    break;

  case 50:
                                    {}
    break;

  case 51:
                                                                        {}
    break;

  case 52:
                                                                        {}
    break;

  case 53:
                                                                                                      {}
    break;

  case 54:
                                                                                                      {}
    break;

  case 55:
               {}
    break;

  case 56:
                                               {}
    break;

  case 57:
                                       {}
    break;

  case 58:
          { context->from=igraph_pajek_get_number(igraph_dl_yyget_text(scanner),
                                                          igraph_dl_yyget_leng(scanner)); }
    break;

  case 59:
        {}
    break;

  case 60:
                            {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                       context->from-1));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, (yyvsp[0].integer)-1));
 }
    break;

  case 61:
                      {}
    break;

  case 62:
                                                                    {}
    break;

  case 63:
                                                         { }
    break;

  case 64:
                   {
  context->from=(yyvsp[0].integer);
 }
    break;

  case 66:
                                  {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges,
                                       context->from));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, (yyvsp[0].integer)));
 }
    break;



      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;
  *++yylsp = yyloc;

  /* Now 'shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }

  goto yynewstate;


/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (&yylloc, context, YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (&yylloc, context, yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }

  yyerror_range[1] = yylloc;

  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval, &yylloc, context);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:
  /* Pacify compilers when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;

  /* Do not reclaim the symbols of the rule whose action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;

      yyerror_range[1] = *yylsp;
      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp, yylsp, context);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  yyerror_range[2] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the lookahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
  *++yylsp = yyloc;

  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;


/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;


#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (&yylloc, context, YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif


/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result.  |
`-----------------------------------------------------*/
yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval, &yylloc, context);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[+*yyssp], yyvsp, yylsp, context);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  return yyresult;
}


int igraph_dl_yyerror(YYLTYPE* locp, igraph_i_dl_parsedata_t* context,
                      const char *s) {
  snprintf(context->errmsg,
           sizeof(context->errmsg)/sizeof(char)-1,
           "%s in line %i", s, locp->first_line);
  return 0;
}

int igraph_i_dl_add_str(char *newstr, int length,
                        igraph_i_dl_parsedata_t *context) {
  int tmp=newstr[length];
  newstr[length]='\0';
  IGRAPH_CHECK(igraph_strvector_add(&context->labels, newstr));
  newstr[length]=tmp;
  return 0;
}

int igraph_i_dl_add_edge(long int from, long int to,
                         igraph_i_dl_parsedata_t *context) {
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, from));
  IGRAPH_CHECK(igraph_vector_push_back(&context->edges, to));
  return 0;
}

int igraph_i_dl_add_edge_w(long int from, long int to,
                           igraph_real_t weight,
                           igraph_i_dl_parsedata_t *context) {
  long int n=igraph_vector_size(&context->weights);
  long int n2=igraph_vector_size(&context->edges)/2;
  if (n != n2) {
    igraph_vector_resize(&context->weights, n2);
    for (; nweights)[n]=IGRAPH_NAN;
    }
  }
  IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context));
  IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight));
  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/dl-parser.h0000644000175100001710000000603000000000000024570 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

#ifndef YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED
# define YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_dl_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    NUM = 258,
    NEWLINE = 259,
    DL = 260,
    NEQ = 261,
    DATA = 262,
    LABELS = 263,
    LABELSEMBEDDED = 264,
    FORMATFULLMATRIX = 265,
    FORMATEDGELIST1 = 266,
    FORMATNODELIST1 = 267,
    DIGIT = 268,
    LABEL = 269,
    EOFF = 270,
    ERROR = 271
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int integer;
  igraph_real_t real;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_dl_yyparse (igraph_i_dl_parsedata_t* context);

#endif /* !YY_IGRAPH_DL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_DL_PARSER_H_INCLUDED  */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/gml-lexer.c0000644000175100001710000017255500000000000024606 0ustar00runnerdocker00000000000000
#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_gml_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_gml_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_gml_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_gml_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_gml_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_gml_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_gml_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_gml_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_gml_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_gml_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_gml_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_gml_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_gml_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_gml_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_gml_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_gml_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_gml_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_gml_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_gml_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_gml_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_gml_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_gml_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_gml_yylex_ALREADY_DEFINED
#else
#define yylex igraph_gml_yylex
#endif

#ifdef yyrestart
#define igraph_gml_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_gml_yyrestart
#endif

#ifdef yylex_init
#define igraph_gml_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_gml_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_gml_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_gml_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_gml_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_gml_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_gml_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_gml_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_gml_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_gml_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_gml_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_gml_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_gml_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_gml_yyset_extra
#endif

#ifdef yyget_in
#define igraph_gml_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_gml_yyget_in
#endif

#ifdef yyset_in
#define igraph_gml_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_gml_yyset_in
#endif

#ifdef yyget_out
#define igraph_gml_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_gml_yyget_out
#endif

#ifdef yyset_out
#define igraph_gml_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_gml_yyset_out
#endif

#ifdef yyget_leng
#define igraph_gml_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_gml_yyget_leng
#endif

#ifdef yyget_text
#define igraph_gml_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_gml_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_gml_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_gml_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_gml_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_gml_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_gml_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_gml_yyget_column
#endif

#ifdef yyset_column
#define igraph_gml_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_gml_yyset_column
#endif

#ifdef yywrap
#define igraph_gml_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_gml_yywrap
#endif

#ifdef yyget_lval
#define igraph_gml_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_gml_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_gml_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_gml_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_gml_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_gml_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_gml_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_gml_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_gml_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_gml_yyalloc
#endif

#ifdef yyrealloc
#define igraph_gml_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_gml_yyrealloc
#endif

#ifdef yyfree
#define igraph_gml_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_gml_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yyg->yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yyg->yy_start - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = yyg->yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

static void yyensure_buffer_stack ( yyscan_t yyscanner );
static void yy_load_buffer_state ( yyscan_t yyscanner );
static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}
#define yy_set_bol(at_bol) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

#define igraph_gml_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef flex_uint8_t YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
static int yy_get_next_buffer ( yyscan_t yyscanner );
static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yyg->yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yyg->yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 10
#define YY_END_OF_BUFFER 11
/* This struct is not used in this scanner,
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static const flex_int16_t yy_accept[29] =
    {   0,
        0,    0,   11,    9,    8,    7,    7,    9,    9,    3,
        4,    5,    6,    1,    9,    7,    0,    2,    3,    0,
        0,    4,    0,    1,    3,    0,    3,    0
    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    5,    6,    1,    1,    1,    1,    1,
        1,    1,    7,    1,    8,    9,    1,   10,   10,   10,
       10,   10,   10,   10,   10,   10,   10,    1,    1,    1,
        1,    1,    1,    1,   11,   11,   11,   11,   12,   11,
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
       13,    1,   14,    1,   11,    1,   11,   11,   11,   11,

       12,   11,   11,   11,   11,   11,   11,   11,   11,   11,
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
       11,   11,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1
    } ;

static const YY_CHAR yy_meta[16] =
    {   0,
        1,    1,    1,    2,    1,    1,    1,    1,    1,    3,
        3,    3,    1,    1,    4
    } ;

static const flex_int16_t yy_base[32] =
    {   0,
        0,   12,   44,   45,   45,   39,   39,   36,   30,   10,
        0,   45,   45,   36,   35,   45,   32,   45,    0,   26,
       16,    0,   32,   45,   15,   22,   11,   45,   27,   14,
       30
    } ;

static const flex_int16_t yy_def[32] =
    {   0,
       28,    1,   28,   28,   28,   28,   28,   29,   28,   28,
       30,   28,   28,   28,   31,   28,   29,   28,   10,   28,
       28,   30,   31,   28,   28,   28,   28,    0,   28,   28,
       28
    } ;

static const flex_int16_t yy_nxt[61] =
    {   0,
        4,    5,    6,    7,    8,    4,    4,    9,    4,   10,
       11,   11,   12,   13,    4,   14,   22,   15,   20,   19,
       27,   21,   26,   26,   25,   27,   21,   17,   17,   17,
       23,   27,   23,   23,   24,   25,   18,   24,   16,   19,
       18,   16,   16,   28,    3,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28
    } ;

static const flex_int16_t yy_chk[61] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    2,   30,    2,   10,   10,
       27,   10,   21,   21,   25,   21,   25,   29,   29,   29,
       31,   26,   31,   31,   23,   20,   17,   15,   14,    9,
        8,    7,    6,    3,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28
    } ;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/gml-header.h"
#include "io/parsers/gml-parser.h"

#define YY_EXTRA_TYPE igraph_i_gml_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in GML parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
#define YY_NO_INPUT 1

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    YYSTYPE * yylval_r;

    YYLTYPE * yylloc_r;

    }; /* end struct yyguts_t */

static int yy_init_globals ( yyscan_t yyscanner );

    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval yyg->yylval_r
    
    #    define yylloc yyg->yylloc_r
    
int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef YY_NO_UNPUT
    
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput ( yyscan_t yyscanner );
#else
static int input ( yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif

#define YY_RULE_SETUP \
	if ( yyleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
				(yytext[yyleng - 1] == '\n'); \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    yylval = yylval_param;

    yylloc = yylloc_param;

	if ( !yyg->yy_init )
		{
		yyg->yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yyg->yy_start )
			yyg->yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			yyensure_buffer_stack (yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
		}

		yy_load_buffer_state( yyscanner );
		}

	{

	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yyg->yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yyg->yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yyg->yy_start;
		yy_current_state += YY_AT_BOL();
yy_match:
		do
			{
			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
			if ( yy_accept[yy_current_state] )
				{
				yyg->yy_last_accepting_state = yy_current_state;
				yyg->yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 29 )
					yy_c = yy_meta[yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 45 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

do_action:	/* This label is used only to access EOF actions. */

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yyg->yy_hold_char;
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			goto yy_find_action;

case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
{ /* comments ignored */ }
	YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
{ return STRING; }
	YY_BREAK
case 3:
YY_RULE_SETUP
{ return NUM; }
	YY_BREAK
case 4:
YY_RULE_SETUP
{ return KEYWORD; }
	YY_BREAK
case 5:
YY_RULE_SETUP
{
                          yyextra->depth++;
                          if (yyextra->depth >= 32) {
                            return ERROR;
                          } else {
                            return LISTOPEN;
                          }
                        }
	YY_BREAK
case 6:
YY_RULE_SETUP
{
                          yyextra->depth--;
                          if (yyextra->depth < 0) {
                            return ERROR;
                          } else {
                            return LISTCLOSE;
                          }
                        }
	YY_BREAK
case 7:
/* rule 7 can match eol */
YY_RULE_SETUP
{ }
	YY_BREAK
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
{ /* other whitespace ignored */ }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
{
                          if (yyextra->eof) {
                            yyterminate();
                          } else {
                            yyextra->eof=1;
                            return EOFF;
                          }
                        }
	YY_BREAK
case 9:
YY_RULE_SETUP
{ return ERROR; }
	YY_BREAK
case 10:
YY_RULE_SETUP
YY_FATAL_ERROR( "flex scanner jammed" );
	YY_BREAK

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yyg->yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between YY_CURRENT_BUFFER and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state( yyscanner );

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yyg->yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yyg->yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer( yyscanner ) )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yyg->yy_did_buffer_switch_on_eof = 0;

				if ( yywrap( yyscanner ) )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yyg->yy_c_buf_p =
					yyg->yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yyg->yy_c_buf_p =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
static int yy_get_next_buffer (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = yyg->yytext_ptr;
	int number_to_move, i;
	int ret_val;

	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

	else
		{
			int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
				}
			else
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			yyg->yy_n_chars, num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	if ( yyg->yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  , yyscanner);
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	yyg->yy_n_chars += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}

/* yy_get_previous_state - get the state just before the EOB char was reached */

    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;
	yy_current_state += YY_AT_BOL();

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 15);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 29 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 15;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 29 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 28);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_UNPUT

#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
	int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	*yyg->yy_c_buf_p = yyg->yy_hold_char;

	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			/* This was really a NUL. */
			*yyg->yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
			++yyg->yy_c_buf_p;

			switch ( yy_get_next_buffer( yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin , yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap( yyscanner ) )
						return 0;

					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput(yyscanner);
#else
					return input(yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
	yyg->yy_hold_char = *++yyg->yy_c_buf_p;

	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * @param yyscanner The scanner object.
 */
    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param yyscanner The scanner object.
 */
    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param yyscanner The scanner object.
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (yyscan_t yyscanner)
{
	yy_size_t num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if (!yyg->yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		yyg->yy_buffer_stack_max = num_to_alloc;
		yyg->yy_buffer_stack_top = 0;
		return;
	}

	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
								(yyg->yy_buffer_stack,
								num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		yyg->yy_buffer_stack_max = num_to_alloc;
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b , yyscanner );

	return b;
}

/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
    
	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n , yyscanner );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n , yyscanner);
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		*yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int yyget_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *yyget_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param _line_number line number
 * @param yyscanner The scanner object.
 */
void yyset_lineno (int  _line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
    
    yylineno = _line_number;
}

/** Set the current column.
 * @param _column_no column number
 * @param yyscanner The scanner object.
 */
void yyset_column (int  _column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_column called with no buffer" );
    
    yycolumn = _column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = _in_str ;
}

void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = _out_str ;
}

int yyget_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void yyset_debug (int  _bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = _bdebug ;
}

/* Accessor methods for yylval and yylloc */

YYSTYPE * yyget_lval  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}
    
void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}
    
/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
    struct yyguts_t dummy_yyguts;

    yyset_extra (yy_user_defined, &dummy_yyguts);

    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    yyset_extra (yy_user_defined, *ptr_yy_globals);

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = NULL;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = NULL;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = NULL;
    yyout = NULL;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(yyscanner);
	}

	/* Destroy the stack itself. */
	yyfree(yyg->yy_buffer_stack , yyscanner);
	yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        yyfree( yyg->yy_start_stack , yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif

void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	return malloc(size);
}

void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}

void yyfree (void * ptr , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/gml-lexer.h0000644000175100001710000004171700000000000024606 0ustar00runnerdocker00000000000000#ifndef igraph_gml_yyHEADER_H
#define igraph_gml_yyHEADER_H 1
#define igraph_gml_yyIN_HEADER 1

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_gml_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_gml_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_gml_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_gml_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_gml_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_gml_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_gml_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_gml_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_gml_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_gml_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_gml_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_gml_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_gml_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_gml_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_gml_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_gml_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_gml_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_gml_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_gml_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_gml_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_gml_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_gml_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_gml_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_gml_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_gml_yylex_ALREADY_DEFINED
#else
#define yylex igraph_gml_yylex
#endif

#ifdef yyrestart
#define igraph_gml_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_gml_yyrestart
#endif

#ifdef yylex_init
#define igraph_gml_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_gml_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_gml_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_gml_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_gml_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_gml_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_gml_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_gml_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_gml_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_gml_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_gml_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_gml_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_gml_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_gml_yyset_extra
#endif

#ifdef yyget_in
#define igraph_gml_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_gml_yyget_in
#endif

#ifdef yyset_in
#define igraph_gml_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_gml_yyset_in
#endif

#ifdef yyget_out
#define igraph_gml_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_gml_yyget_out
#endif

#ifdef yyset_out
#define igraph_gml_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_gml_yyset_out
#endif

#ifdef yyget_leng
#define igraph_gml_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_gml_yyget_leng
#endif

#ifdef yyget_text
#define igraph_gml_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_gml_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_gml_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_gml_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_gml_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_gml_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_gml_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_gml_yyget_column
#endif

#ifdef yyset_column
#define igraph_gml_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_gml_yyset_column
#endif

#ifdef yywrap
#define igraph_gml_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_gml_yywrap
#endif

#ifdef yyget_lval
#define igraph_gml_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_gml_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_gml_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_gml_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_gml_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_gml_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_gml_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_gml_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_gml_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_gml_yyalloc
#endif

#ifdef yyrealloc
#define igraph_gml_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_gml_yyrealloc
#endif

#ifdef yyfree
#define igraph_gml_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_gml_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

/* Begin user sect3 */

#define igraph_gml_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP

#define yytext_ptr yytext_r

#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0

#endif

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* yy_get_previous_state - get the state just before the EOB char was reached */

#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif

#ifndef igraph_gml_yy_create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef igraph_gml_yy_delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef igraph_gml_yy_scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef igraph_gml_yy_scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef igraph_gml_yy_scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef igraph_gml_yy_init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef igraph_gml_yy_flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef igraph_gml_yy_load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef igraph_gml_yy_switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef igraph_gml_yypush_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef igraph_gml_yypop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef igraph_gml_yyensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef igraph_gml_yylex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef igraph_gml_yyrestart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef igraph_gml_yylex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef igraph_gml_yylex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef igraph_gml_yylex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef igraph_gml_yyget_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef igraph_gml_yyset_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef igraph_gml_yyget_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef igraph_gml_yyset_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef igraph_gml_yyget_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef igraph_gml_yyset_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef igraph_gml_yyget_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef igraph_gml_yyset_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef igraph_gml_yyget_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef igraph_gml_yyget_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef igraph_gml_yyget_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef igraph_gml_yyset_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef igraph_gml_yyget_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef igraph_gml_yyset_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef igraph_gml_yywrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef igraph_gml_yyget_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef igraph_gml_yyset_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef igraph_gml_yyget_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef igraph_gml_yyset_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef igraph_gml_yyalloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef igraph_gml_yyrealloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef igraph_gml_yyfree_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef igraph_gml_yytext_ALREADY_DEFINED
#undef yytext
#endif
#ifndef igraph_gml_yyleng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef igraph_gml_yyin_ALREADY_DEFINED
#undef yyin
#endif
#ifndef igraph_gml_yyout_ALREADY_DEFINED
#undef yyout
#endif
#ifndef igraph_gml_yy_flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef igraph_gml_yylineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef igraph_gml_yytables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef igraph_gml_yytables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef igraph_gml_yyTABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif

#undef igraph_gml_yyIN_HEADER
#endif /* igraph_gml_yyHEADER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/gml-parser.c0000644000175100001710000016701400000000000024755 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "3.5.1"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 1

/* Push parsers.  */
#define YYPUSH 0

/* Pull parsers.  */
#define YYPULL 1


/* Substitute the variable and function names.  */
#define yyparse         igraph_gml_yyparse
#define yylex           igraph_gml_yylex
#define yyerror         igraph_gml_yyerror
#define yydebug         igraph_gml_yydebug
#define yynerrs         igraph_gml_yynerrs

/* First part of user prologue.  */


/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "igraph_error.h"
#include "igraph_memory.h"
#include "config.h"

#include "core/math.h"
#include "io/gml-header.h"
#include "io/gml-tree.h"
#include "io/parsers/gml-parser.h"
#include "io/parsers/gml-lexer.h"
#include "internal/hacks.h" /* strcasecmp */

int igraph_gml_yyerror(YYLTYPE* locp, igraph_i_gml_parsedata_t *context,
                       const char *s);
void igraph_i_gml_get_keyword(char *s, int len, void *res);
void igraph_i_gml_get_string(char *s, int len, void *res);
double igraph_i_gml_get_real(char *s, int len);
igraph_gml_tree_t *igraph_i_gml_make_numeric(char* s, int len, double value);
igraph_gml_tree_t *igraph_i_gml_make_numeric2(char* s, int len,
                                              char *v, int vlen);
igraph_gml_tree_t *igraph_i_gml_make_string(char* s, int len,
                                            char *value, int valuelen);
igraph_gml_tree_t *igraph_i_gml_make_list(char* s, int len,
                                          igraph_gml_tree_t *list);
igraph_gml_tree_t *igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2);

#define scanner context->scanner
#define USE(x) /*(x)*/



# ifndef YY_CAST
#  ifdef __cplusplus
#   define YY_CAST(Type, Val) static_cast (Val)
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val)
#  else
#   define YY_CAST(Type, Val) ((Type) (Val))
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
#  endif
# endif
# ifndef YY_NULLPTR
#  if defined __cplusplus
#   if 201103L <= __cplusplus
#    define YY_NULLPTR nullptr
#   else
#    define YY_NULLPTR 0
#   endif
#  else
#   define YY_NULLPTR ((void*)0)
#  endif
# endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif

/* Use api.header.include to #include this header
   instead of duplicating it here.  */
#ifndef YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED
# define YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_gml_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    STRING = 258,
    NUM = 259,
    KEYWORD = 260,
    LISTOPEN = 261,
    LISTCLOSE = 262,
    EOFF = 263,
    ERROR = 264
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

   struct {
      char *s;
      int len;
   } str;
   void *tree;
   double real;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_gml_yyparse (igraph_i_gml_parsedata_t* context);

#endif /* !YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED  */



#ifdef short
# undef short
#endif

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
    and (if available)  are included
   so that the code can choose integer types of a good width.  */

#ifndef __PTRDIFF_MAX__
# include  /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YY_STDINT_H
# endif
#endif

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif

#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif

#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif

#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif

#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
#  ifndef ptrdiff_t
#   include  /* INFRINGES ON USER NAME SPACE */
#  endif
#  define YYPTRDIFF_T ptrdiff_t
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
#  define YYPTRDIFF_T long
#  define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned
# endif
#endif

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))

/* Stored state numbers (used for stacks). */
typedef yytype_int8 yy_state_t;

/* State numbers in computations.  */
typedef int yy_state_fast_t;

#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
#  if ENABLE_NLS
#   include  /* INFRINGES ON USER NAME SPACE */
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(Msgid) Msgid
# endif
#endif

#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define YY_ATTRIBUTE_PURE
# endif
#endif

#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
#  define YY_ATTRIBUTE_UNUSED
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif

#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
    _Pragma ("GCC diagnostic push")                                     \
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
    _Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif

#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
    _Pragma ("GCC diagnostic push")                            \
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END            \
    _Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif


#define YY_ASSERT(E) ((void) (0 && (E)))

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include  /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include  /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
#     include  /* INFRINGES ON USER NAME SPACE */
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
#     ifndef EXIT_SUCCESS
#      define EXIT_SUCCESS 0
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's 'empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
       && ! ((defined YYMALLOC || defined malloc) \
             && (defined YYFREE || defined free)))
#   include  /* INFRINGES ON USER NAME SPACE */
#   ifndef EXIT_SUCCESS
#    define EXIT_SUCCESS 0
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yy_state_t yyss_alloc;
  YYSTYPE yyvs_alloc;
  YYLTYPE yyls_alloc;
};

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
             + YYSIZEOF (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(Dst, Src, Count) \
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  else
#   define YYCOPY(Dst, Src, Count)              \
      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)
#  endif
# endif
#endif /* !YYCOPY_NEEDED */

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  6
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   14

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  10
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  7
/* YYNRULES -- Number of rules.  */
#define YYNRULES  12
/* YYNSTATES -- Number of states.  */
#define YYNSTATES  17

#define YYUNDEFTOK  2
#define YYMAXUTOK   264


/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */
#define YYTRANSLATE(YYX)                                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex.  */
static const yytype_int8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9
};

#if YYDEBUG
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
static const yytype_uint8 yyrline[] =
{
       0,   119,   119,   120,   123,   124,   126,   128,   130,   132,
     136,   139,   142
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "STRING", "NUM", "KEYWORD", "LISTOPEN",
  "LISTCLOSE", "EOFF", "ERROR", "$accept", "input", "list", "keyvalue",
  "key", "num", "string", YY_NULLPTR
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
   (internal) symbol number NUM (which must be that of a token).  */
static const yytype_int16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264
};
# endif

#define YYPACT_NINF (-4)

#define yypact_value_is_default(Yyn) \
  ((Yyn) == YYPACT_NINF)

#define YYTABLE_NINF (-1)

#define yytable_value_is_error(Yyn) \
  0

  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
static const yytype_int8 yypact[] =
{
       1,    -4,    10,     0,    -4,    -2,    -4,    -4,    -4,    -4,
      -4,     1,    -4,    -4,    -4,     2,    -4
};

  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     Performed when YYTABLE does not specify something else to do.  Zero
     means the default is an error.  */
static const yytype_int8 yydefact[] =
{
       0,    10,     0,     2,     4,     0,     1,     3,     5,    12,
      11,     0,     9,     6,     7,     0,     8
};

  /* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
      -4,    -4,     3,    -3,     6,    -4,    -4
};

  /* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int8 yydefgoto[] =
{
      -1,     2,     3,     4,     5,    13,    14
};

  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule whose
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
static const yytype_int8 yytable[] =
{
       8,     9,    10,     1,    11,     1,     1,     1,     7,    16,
       6,    12,     8,     0,    15
};

static const yytype_int8 yycheck[] =
{
       3,     3,     4,     5,     6,     5,     5,     5,     8,     7,
       0,     5,    15,    -1,    11
};

  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
static const yytype_int8 yystos[] =
{
       0,     5,    11,    12,    13,    14,     0,     8,    13,     3,
       4,     6,    14,    15,    16,    12,     7
};

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_int8 yyr1[] =
{
       0,    10,    11,    11,    12,    12,    13,    13,    13,    13,
      14,    15,    16
};

  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
static const yytype_int8 yyr2[] =
{
       0,     2,     1,     2,     1,     2,     2,     2,     4,     2,
       1,     1,     1
};


#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         (-2)
#define YYEOF           0

#define YYACCEPT        goto yyacceptlab
#define YYABORT         goto yyabortlab
#define YYERROR         goto yyerrorlab


#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

/* Error token number */
#define YYTERROR        1
#define YYERRCODE       256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    do                                                                  \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)
#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K])


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)                        \
do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL

/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */

YY_ATTRIBUTE_UNUSED
static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
  int res = 0;
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
  if (0 <= yylocp->first_line)
    {
      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
      if (0 <= yylocp->first_column)
        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
    }
  if (0 <= yylocp->last_line)
    {
      if (yylocp->first_line < yylocp->last_line)
        {
          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
          if (0 <= end_col)
            res += YYFPRINTF (yyo, ".%d", end_col);
        }
      else if (0 <= end_col && yylocp->first_column < end_col)
        res += YYFPRINTF (yyo, "-%d", end_col);
    }
  return res;
 }

#  define YY_LOCATION_PRINT(File, Loc)          \
  yy_location_print_ (File, &(Loc))

# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Type, Value, Location, context); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)


/*-----------------------------------.
| Print this symbol's value on YYO.  |
`-----------------------------------*/

static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_gml_parsedata_t* context)
{
  FILE *yyoutput = yyo;
  YYUSE (yyoutput);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}


/*---------------------------.
| Print this symbol on YYO.  |
`---------------------------*/

static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_gml_parsedata_t* context)
{
  YYFPRINTF (yyo, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  YY_LOCATION_PRINT (yyo, *yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, context);
  YYFPRINTF (yyo, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)                            \
do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, igraph_i_gml_parsedata_t* context)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[+yyssp[yyi + 1 - yynrhs]],
                       &yyvsp[(yyi + 1) - (yynrhs)]
                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , context);
      YYFPRINTF (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)          \
do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif


#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
#  else
/* Return the length of YYSTR.  */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}
# endif

/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
                yy_state_t *yyssp, int yytoken)
{
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
     one per "expected"). */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Actual size of YYARG. */
  int yycount = 0;
  /* Cumulated lengths of YYARG.  */
  YYPTRDIFF_T yysize = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[+*yyssp];
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
      yysize = yysize0;
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYPTRDIFF_T yysize1
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                    yysize = yysize1;
                  else
                    return 2;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
    default: /* Avoid compiler warnings. */
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    /* Don't count the "%s"s in the final size, but reserve room for
       the terminator.  */
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
      yysize = yysize1;
    else
      return 2;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          ++yyp;
          ++yyformat;
        }
  }
  return 0;
}
#endif /* YYERROR_VERBOSE */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, igraph_i_gml_parsedata_t* context)
{
  YYUSE (yyvaluep);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  switch (yytype)
    {
    case 5: /* KEYWORD  */
            { IGRAPH_FREE(((*yyvaluep).str).s); }
        break;

    case 12: /* list  */
            { igraph_gml_tree_destroy(((*yyvaluep).tree)); }
        break;

    case 13: /* keyvalue  */
            { igraph_gml_tree_destroy(((*yyvaluep).tree)); }
        break;

    case 14: /* key  */
            { IGRAPH_FREE(((*yyvaluep).str).s); }
        break;

    case 16: /* string  */
            { IGRAPH_FREE(((*yyvaluep).str).s); }
        break;

      default:
        break;
    }
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}




/*----------.
| yyparse.  |
`----------*/

int
yyparse (igraph_i_gml_parsedata_t* context)
{
/* The lookahead symbol.  */
int yychar;


/* The semantic value of the lookahead symbol.  */
/* Default value used for initialization, for pacifying older GCCs
   or non-GCC compilers.  */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Location data for the lookahead symbol.  */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
  = { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;

    /* Number of syntax errors so far.  */
    int yynerrs;

    yy_state_fast_t yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       'yyss': related to states.
       'yyvs': related to semantic values.
       'yyls': related to locations.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss;
    yy_state_t *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    /* The location stack.  */
    YYLTYPE yylsa[YYINITDEPTH];
    YYLTYPE *yyls;
    YYLTYPE *yylsp;

    /* The locations where the error started and ended.  */
    YYLTYPE yyerror_range[3];

    YYPTRDIFF_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yylsp = yyls = yylsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  yylsp[0] = yylloc;
  goto yysetstate;


/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;


/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END

  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    goto yyexhaustedlab;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;

# if defined yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
        YYLTYPE *yyls1 = yyls;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yyls1, yysize * YYSIZEOF (*yylsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
        yyls = yyls1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
        YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
      yylsp = yyls + yysize - 1;

      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:
  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = yylex (&yylval, &yylloc, scanner);
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
  *++yylsp = yylloc;

  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     '$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  yyerror_range[1] = yyloc;
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
  case 2:
                   { context->tree=(yyvsp[0].tree); }
    break;

  case 3:
                   { context->tree=(yyvsp[-1].tree); }
    break;

  case 4:
                      { (yyval.tree)=(yyvsp[0].tree); }
    break;

  case 5:
                      { (yyval.tree)=igraph_i_gml_merge((yyvsp[-1].tree), (yyvsp[0].tree)); }
    break;

  case 6:
            { (yyval.tree)=igraph_i_gml_make_numeric((yyvsp[-1].str).s, (yyvsp[-1].str).len, (yyvsp[0].real)); }
    break;

  case 7:
            { (yyval.tree)=igraph_i_gml_make_string((yyvsp[-1].str).s, (yyvsp[-1].str).len, (yyvsp[0].str).s, (yyvsp[0].str).len); }
    break;

  case 8:
            { (yyval.tree)=igraph_i_gml_make_list((yyvsp[-3].str).s, (yyvsp[-3].str).len, (yyvsp[-1].tree)); }
    break;

  case 9:
            { (yyval.tree)=igraph_i_gml_make_numeric2((yyvsp[-1].str).s, (yyvsp[-1].str).len, (yyvsp[0].str).s, (yyvsp[0].str).len); }
    break;

  case 10:
             { igraph_i_gml_get_keyword(igraph_gml_yyget_text(scanner),
                                        igraph_gml_yyget_leng(scanner),
                                        &(yyval.str)); USE((yyvsp[0].str)); }
    break;

  case 11:
          { (yyval.real)=igraph_i_gml_get_real(igraph_gml_yyget_text(scanner),
                                     igraph_gml_yyget_leng(scanner)); }
    break;

  case 12:
               { igraph_i_gml_get_string(igraph_gml_yyget_text(scanner),
                                         igraph_gml_yyget_leng(scanner),
                                         &(yyval.str)); }
    break;



      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;
  *++yylsp = yyloc;

  /* Now 'shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }

  goto yynewstate;


/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (&yylloc, context, YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (&yylloc, context, yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }

  yyerror_range[1] = yylloc;

  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval, &yylloc, context);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:
  /* Pacify compilers when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;

  /* Do not reclaim the symbols of the rule whose action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;

      yyerror_range[1] = *yylsp;
      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp, yylsp, context);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  yyerror_range[2] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the lookahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
  *++yylsp = yyloc;

  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;


/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;


#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (&yylloc, context, YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif


/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result.  |
`-----------------------------------------------------*/
yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval, &yylloc, context);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[+*yyssp], yyvsp, yylsp, context);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  return yyresult;
}


int igraph_gml_yyerror(YYLTYPE* locp, igraph_i_gml_parsedata_t *context,
                       const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
           "Parse error in GML file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

void igraph_i_gml_get_keyword(char *s, int len, void *res) {
  struct { char *s; int len; } *p=res;
  p->s=IGRAPH_CALLOC(len+1, char);
  if (!p->s) {
    igraph_error("Cannot read GML file", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
  }
  memcpy(p->s, s, sizeof(char)*len);
  p->s[len]='\0';
  p->len=len;
}

void igraph_i_gml_get_string(char *s, int len, void *res) {
  struct { char *s; int len; } *p=res;
  p->s=IGRAPH_CALLOC(len-1, char);
  if (!p->s) {
    igraph_error("Cannot read GML file", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
  }
  memcpy(p->s, s+1, sizeof(char)*(len-2));
  p->s[len-2]='\0';
  p->len=len-2;
}

double igraph_i_gml_get_real(char *s, int len) {
  igraph_real_t num;
  char tmp=s[len];
  s[len]='\0';
  sscanf(s, "%lf", &num);
  s[len]=tmp;
  return num;
}

igraph_gml_tree_t *igraph_i_gml_make_numeric(char* s, int len, double value) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  if (floor(value)==value) {
    if (igraph_gml_tree_init_integer(t, s, len, value)) {
          free(t);
          return 0;
        }
  } else {
    if (igraph_gml_tree_init_real(t, s, len, value)) {
      free(t);
          return 0;
        }
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_numeric2(char* s, int len,
                                              char* v, int vlen) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);
  char tmp = v[vlen];

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  v[vlen]='\0';

  /* if v == "inf" or v == "nan", the newly created tree node will take ownership
   * of s. If the creation fails, we need to free s and v as well in order not
   * to leak memory */
  if (strcasecmp(v, "inf")) {
    if (igraph_gml_tree_init_real(t, s, len, IGRAPH_INFINITY)) {
      free(t);
      t = 0;
    }
  } else if (strcasecmp(v, "nan")) {
    if (igraph_gml_tree_init_real(t, s, len, IGRAPH_NAN)) {
      free(t);
      t = 0;
    }
  } else {
    igraph_error("Parse error", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_PARSEERROR);
    free(t);
    t = 0;
  }

  v[vlen]=tmp;
  free(v);

  if (t == 0) {
    /* no new tree node was created so s has no owner any more */
    free(s);
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_string(char* s, int len,
                                            char *value, int valuelen) {
  igraph_gml_tree_t *t = IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  /* if igraph_gml_tree_init_string succeeds, the newly created tree node takes
   * ownership of 'value'. If it fails, we need to free 'value' ourselves in order
   * not to leak memory */
  if (igraph_gml_tree_init_string(t, s, len, value, valuelen)) {
    free(t);
    free(value);
    t = 0;
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_make_list(char* s, int len,
                                          igraph_gml_tree_t *list) {

  igraph_gml_tree_t *t=IGRAPH_CALLOC(1, igraph_gml_tree_t);

  if (!t) {
    igraph_error("Cannot build GML tree", IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    return 0;
  }

  if (igraph_gml_tree_init_tree(t, s, len, list)) {
    free(t);
    return 0;
  }

  return t;
}

igraph_gml_tree_t *igraph_i_gml_merge(igraph_gml_tree_t *t1, igraph_gml_tree_t* t2) {

  igraph_gml_tree_mergedest(t1, t2);
  IGRAPH_FREE(t2);

  return t1;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/gml-parser.h0000644000175100001710000000567000000000000024761 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

#ifndef YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED
# define YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_gml_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    STRING = 258,
    NUM = 259,
    KEYWORD = 260,
    LISTOPEN = 261,
    LISTCLOSE = 262,
    EOFF = 263,
    ERROR = 264
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

   struct {
      char *s;
      int len;
   } str;
   void *tree;
   double real;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_gml_yyparse (igraph_i_gml_parsedata_t* context);

#endif /* !YY_IGRAPH_GML_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_GML_PARSER_H_INCLUDED  */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/lgl-lexer.c0000644000175100001710000016730000000000000024575 0ustar00runnerdocker00000000000000
#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_lgl_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_lgl_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_lgl_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_lgl_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_lgl_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_lgl_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_lgl_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_lgl_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_lgl_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_lgl_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_lgl_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_lgl_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_lgl_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_lgl_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_lgl_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_lgl_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_lgl_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_lgl_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_lgl_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_lgl_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_lgl_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_lgl_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_lgl_yylex_ALREADY_DEFINED
#else
#define yylex igraph_lgl_yylex
#endif

#ifdef yyrestart
#define igraph_lgl_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_lgl_yyrestart
#endif

#ifdef yylex_init
#define igraph_lgl_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_lgl_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_lgl_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_lgl_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_lgl_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_lgl_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_lgl_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_lgl_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_lgl_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_lgl_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_lgl_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_lgl_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_lgl_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_lgl_yyset_extra
#endif

#ifdef yyget_in
#define igraph_lgl_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_lgl_yyget_in
#endif

#ifdef yyset_in
#define igraph_lgl_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_lgl_yyset_in
#endif

#ifdef yyget_out
#define igraph_lgl_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_lgl_yyget_out
#endif

#ifdef yyset_out
#define igraph_lgl_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_lgl_yyset_out
#endif

#ifdef yyget_leng
#define igraph_lgl_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_lgl_yyget_leng
#endif

#ifdef yyget_text
#define igraph_lgl_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_lgl_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_lgl_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_lgl_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_lgl_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_lgl_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_lgl_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_lgl_yyget_column
#endif

#ifdef yyset_column
#define igraph_lgl_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_lgl_yyset_column
#endif

#ifdef yywrap
#define igraph_lgl_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_lgl_yywrap
#endif

#ifdef yyget_lval
#define igraph_lgl_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_lgl_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_lgl_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_lgl_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_lgl_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_lgl_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_lgl_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_lgl_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_lgl_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_lgl_yyalloc
#endif

#ifdef yyrealloc
#define igraph_lgl_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_lgl_yyrealloc
#endif

#ifdef yyfree
#define igraph_lgl_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_lgl_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yyg->yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yyg->yy_start - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = yyg->yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

static void yyensure_buffer_stack ( yyscan_t yyscanner );
static void yy_load_buffer_state ( yyscan_t yyscanner );
static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}
#define yy_set_bol(at_bol) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

#define igraph_lgl_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef flex_uint8_t YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
static int yy_get_next_buffer ( yyscan_t yyscanner );
static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yyg->yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yyg->yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 6
#define YY_END_OF_BUFFER 7
/* This struct is not used in this scanner,
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static const flex_int16_t yy_accept[14] =
    {   0,
        0,    0,    7,    4,    2,    3,    3,    1,    5,    4,
        2,    3,    0
    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    1,    5,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1
    } ;

static const YY_CHAR yy_meta[7] =
    {   0,
        1,    2,    3,    4,    5,    5
    } ;

static const flex_int16_t yy_base[18] =
    {   0,
        0,    0,   11,    0,    0,    0,    0,   12,   12,    0,
        0,   12,   12,    9,    7,    4,    4
    } ;

static const flex_int16_t yy_def[18] =
    {   0,
       13,    1,   13,   14,   15,   16,   17,   13,   13,   14,
       15,   13,    0,   13,   13,   13,   13
    } ;

static const flex_int16_t yy_nxt[19] =
    {   0,
        4,    5,    6,    7,    8,    9,   12,   12,   11,   10,
       13,    3,   13,   13,   13,   13,   13,   13
    } ;

static const flex_int16_t yy_chk[19] =
    {   0,
        1,    1,    1,    1,    1,    1,   17,   16,   15,   14,
        3,   13,   13,   13,   13,   13,   13,   13
    } ;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/lgl-header.h"
#include "io/parsers/lgl-parser.h"

#define YY_EXTRA_TYPE igraph_i_lgl_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in LGL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
#define YY_NO_INPUT 1

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    YYSTYPE * yylval_r;

    YYLTYPE * yylloc_r;

    }; /* end struct yyguts_t */

static int yy_init_globals ( yyscan_t yyscanner );

    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval yyg->yylval_r
    
    #    define yylloc yyg->yylloc_r
    
int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef YY_NO_UNPUT
    
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput ( yyscan_t yyscanner );
#else
static int input ( yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    yylval = yylval_param;

    yylloc = yylloc_param;

	if ( !yyg->yy_init )
		{
		yyg->yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yyg->yy_start )
			yyg->yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			yyensure_buffer_stack (yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
		}

		yy_load_buffer_state( yyscanner );
		}

	{

 /* --------------------------------------------------hashmark------*/

	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yyg->yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yyg->yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yyg->yy_start;
yy_match:
		do
			{
			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
			if ( yy_accept[yy_current_state] )
				{
				yyg->yy_last_accepting_state = yy_current_state;
				yyg->yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 14 )
					yy_c = yy_meta[yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 12 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

do_action:	/* This label is used only to access EOF actions. */

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yyg->yy_hold_char;
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			goto yy_find_action;

case 1:
YY_RULE_SETUP
{ return HASH; }
	YY_BREAK
/* ------------------------------------------------whitespace------*/
case 2:
YY_RULE_SETUP
{ }
	YY_BREAK
/* ---------------------------------------------------newline------*/
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
{ return NEWLINE; }
	YY_BREAK
/* ----------------------------------------------alphanumeric------*/
case 4:
YY_RULE_SETUP
{ return ALNUM; }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
{ if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }
	YY_BREAK
case 5:
YY_RULE_SETUP
{ return ERROR; }
	YY_BREAK
case 6:
YY_RULE_SETUP
YY_FATAL_ERROR( "flex scanner jammed" );
	YY_BREAK

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yyg->yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between YY_CURRENT_BUFFER and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state( yyscanner );

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yyg->yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yyg->yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer( yyscanner ) )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yyg->yy_did_buffer_switch_on_eof = 0;

				if ( yywrap( yyscanner ) )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yyg->yy_c_buf_p =
					yyg->yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yyg->yy_c_buf_p =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
static int yy_get_next_buffer (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = yyg->yytext_ptr;
	int number_to_move, i;
	int ret_val;

	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

	else
		{
			int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
				}
			else
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			yyg->yy_n_chars, num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	if ( yyg->yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  , yyscanner);
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	yyg->yy_n_chars += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}

/* yy_get_previous_state - get the state just before the EOB char was reached */

    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 6);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 14 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 6;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 14 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 13);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_UNPUT

#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
	int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	*yyg->yy_c_buf_p = yyg->yy_hold_char;

	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			/* This was really a NUL. */
			*yyg->yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
			++yyg->yy_c_buf_p;

			switch ( yy_get_next_buffer( yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin , yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap( yyscanner ) )
						return 0;

					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput(yyscanner);
#else
					return input(yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
	yyg->yy_hold_char = *++yyg->yy_c_buf_p;

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * @param yyscanner The scanner object.
 */
    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param yyscanner The scanner object.
 */
    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param yyscanner The scanner object.
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (yyscan_t yyscanner)
{
	yy_size_t num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if (!yyg->yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		yyg->yy_buffer_stack_max = num_to_alloc;
		yyg->yy_buffer_stack_top = 0;
		return;
	}

	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
								(yyg->yy_buffer_stack,
								num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		yyg->yy_buffer_stack_max = num_to_alloc;
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b , yyscanner );

	return b;
}

/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
    
	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n , yyscanner );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n , yyscanner);
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		*yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int yyget_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *yyget_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param _line_number line number
 * @param yyscanner The scanner object.
 */
void yyset_lineno (int  _line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
    
    yylineno = _line_number;
}

/** Set the current column.
 * @param _column_no column number
 * @param yyscanner The scanner object.
 */
void yyset_column (int  _column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_column called with no buffer" );
    
    yycolumn = _column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = _in_str ;
}

void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = _out_str ;
}

int yyget_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void yyset_debug (int  _bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = _bdebug ;
}

/* Accessor methods for yylval and yylloc */

YYSTYPE * yyget_lval  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}
    
void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}
    
/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
    struct yyguts_t dummy_yyguts;

    yyset_extra (yy_user_defined, &dummy_yyguts);

    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    yyset_extra (yy_user_defined, *ptr_yy_globals);

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = NULL;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = NULL;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = NULL;
    yyout = NULL;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(yyscanner);
	}

	/* Destroy the stack itself. */
	yyfree(yyg->yy_buffer_stack , yyscanner);
	yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        yyfree( yyg->yy_start_stack , yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif

void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	return malloc(size);
}

void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}

void yyfree (void * ptr , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/lgl-lexer.h0000644000175100001710000004171700000000000024605 0ustar00runnerdocker00000000000000#ifndef igraph_lgl_yyHEADER_H
#define igraph_lgl_yyHEADER_H 1
#define igraph_lgl_yyIN_HEADER 1

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_lgl_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_lgl_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_lgl_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_lgl_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_lgl_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_lgl_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_lgl_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_lgl_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_lgl_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_lgl_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_lgl_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_lgl_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_lgl_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_lgl_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_lgl_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_lgl_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_lgl_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_lgl_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_lgl_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_lgl_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_lgl_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_lgl_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_lgl_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_lgl_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_lgl_yylex_ALREADY_DEFINED
#else
#define yylex igraph_lgl_yylex
#endif

#ifdef yyrestart
#define igraph_lgl_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_lgl_yyrestart
#endif

#ifdef yylex_init
#define igraph_lgl_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_lgl_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_lgl_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_lgl_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_lgl_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_lgl_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_lgl_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_lgl_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_lgl_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_lgl_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_lgl_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_lgl_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_lgl_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_lgl_yyset_extra
#endif

#ifdef yyget_in
#define igraph_lgl_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_lgl_yyget_in
#endif

#ifdef yyset_in
#define igraph_lgl_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_lgl_yyset_in
#endif

#ifdef yyget_out
#define igraph_lgl_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_lgl_yyget_out
#endif

#ifdef yyset_out
#define igraph_lgl_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_lgl_yyset_out
#endif

#ifdef yyget_leng
#define igraph_lgl_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_lgl_yyget_leng
#endif

#ifdef yyget_text
#define igraph_lgl_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_lgl_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_lgl_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_lgl_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_lgl_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_lgl_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_lgl_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_lgl_yyget_column
#endif

#ifdef yyset_column
#define igraph_lgl_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_lgl_yyset_column
#endif

#ifdef yywrap
#define igraph_lgl_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_lgl_yywrap
#endif

#ifdef yyget_lval
#define igraph_lgl_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_lgl_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_lgl_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_lgl_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_lgl_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_lgl_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_lgl_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_lgl_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_lgl_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_lgl_yyalloc
#endif

#ifdef yyrealloc
#define igraph_lgl_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_lgl_yyrealloc
#endif

#ifdef yyfree
#define igraph_lgl_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_lgl_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

/* Begin user sect3 */

#define igraph_lgl_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP

#define yytext_ptr yytext_r

#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0

#endif

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* yy_get_previous_state - get the state just before the EOB char was reached */

#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif

#ifndef igraph_lgl_yy_create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef igraph_lgl_yy_delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef igraph_lgl_yy_scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef igraph_lgl_yy_scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef igraph_lgl_yy_scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef igraph_lgl_yy_init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef igraph_lgl_yy_flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef igraph_lgl_yy_load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef igraph_lgl_yy_switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef igraph_lgl_yypush_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef igraph_lgl_yypop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef igraph_lgl_yyensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef igraph_lgl_yylex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef igraph_lgl_yyrestart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef igraph_lgl_yylex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef igraph_lgl_yylex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef igraph_lgl_yylex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef igraph_lgl_yyget_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef igraph_lgl_yyset_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef igraph_lgl_yyget_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef igraph_lgl_yyset_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef igraph_lgl_yyget_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef igraph_lgl_yyset_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef igraph_lgl_yyget_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef igraph_lgl_yyset_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef igraph_lgl_yyget_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef igraph_lgl_yyget_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef igraph_lgl_yyget_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef igraph_lgl_yyset_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef igraph_lgl_yyget_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef igraph_lgl_yyset_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef igraph_lgl_yywrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef igraph_lgl_yyget_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef igraph_lgl_yyset_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef igraph_lgl_yyget_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef igraph_lgl_yyset_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef igraph_lgl_yyalloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef igraph_lgl_yyrealloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef igraph_lgl_yyfree_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef igraph_lgl_yytext_ALREADY_DEFINED
#undef yytext
#endif
#ifndef igraph_lgl_yyleng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef igraph_lgl_yyin_ALREADY_DEFINED
#undef yyin
#endif
#ifndef igraph_lgl_yyout_ALREADY_DEFINED
#undef yyout
#endif
#ifndef igraph_lgl_yy_flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef igraph_lgl_yylineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef igraph_lgl_yytables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef igraph_lgl_yytables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef igraph_lgl_yyTABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif

#undef igraph_lgl_yyIN_HEADER
#endif /* igraph_lgl_yyHEADER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/lgl-parser.c0000644000175100001710000015470700000000000024761 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "3.5.1"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 1

/* Push parsers.  */
#define YYPUSH 0

/* Pull parsers.  */
#define YYPULL 1


/* Substitute the variable and function names.  */
#define yyparse         igraph_lgl_yyparse
#define yylex           igraph_lgl_yylex
#define yyerror         igraph_lgl_yyerror
#define yydebug         igraph_lgl_yydebug
#define yynerrs         igraph_lgl_yynerrs

/* First part of user prologue.  */


/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include "core/math.h"
#include "io/lgl-header.h"
#include "io/parsers/lgl-parser.h"
#include "io/parsers/lgl-lexer.h"
#include "internal/hacks.h"

int igraph_lgl_yyerror(YYLTYPE* locp, igraph_i_lgl_parsedata_t *context,
                       const char *s);
igraph_real_t igraph_lgl_get_number(const char *str, long int len);

#define scanner context->scanner


# ifndef YY_CAST
#  ifdef __cplusplus
#   define YY_CAST(Type, Val) static_cast (Val)
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val)
#  else
#   define YY_CAST(Type, Val) ((Type) (Val))
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
#  endif
# endif
# ifndef YY_NULLPTR
#  if defined __cplusplus
#   if 201103L <= __cplusplus
#    define YY_NULLPTR nullptr
#   else
#    define YY_NULLPTR 0
#   endif
#  else
#   define YY_NULLPTR ((void*)0)
#  endif
# endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif

/* Use api.header.include to #include this header
   instead of duplicating it here.  */
#ifndef YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED
# define YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_lgl_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    ALNUM = 258,
    NEWLINE = 259,
    HASH = 260,
    ERROR = 261
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int edgenum;
  double weightnum;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_lgl_yyparse (igraph_i_lgl_parsedata_t* context);

#endif /* !YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED  */



#ifdef short
# undef short
#endif

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
    and (if available)  are included
   so that the code can choose integer types of a good width.  */

#ifndef __PTRDIFF_MAX__
# include  /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YY_STDINT_H
# endif
#endif

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif

#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif

#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif

#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif

#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
#  ifndef ptrdiff_t
#   include  /* INFRINGES ON USER NAME SPACE */
#  endif
#  define YYPTRDIFF_T ptrdiff_t
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
#  define YYPTRDIFF_T long
#  define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned
# endif
#endif

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))

/* Stored state numbers (used for stacks). */
typedef yytype_int8 yy_state_t;

/* State numbers in computations.  */
typedef int yy_state_fast_t;

#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
#  if ENABLE_NLS
#   include  /* INFRINGES ON USER NAME SPACE */
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(Msgid) Msgid
# endif
#endif

#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define YY_ATTRIBUTE_PURE
# endif
#endif

#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
#  define YY_ATTRIBUTE_UNUSED
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif

#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
    _Pragma ("GCC diagnostic push")                                     \
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
    _Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif

#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
    _Pragma ("GCC diagnostic push")                            \
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END            \
    _Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif


#define YY_ASSERT(E) ((void) (0 && (E)))

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include  /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include  /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
#     include  /* INFRINGES ON USER NAME SPACE */
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
#     ifndef EXIT_SUCCESS
#      define EXIT_SUCCESS 0
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's 'empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
       && ! ((defined YYMALLOC || defined malloc) \
             && (defined YYFREE || defined free)))
#   include  /* INFRINGES ON USER NAME SPACE */
#   ifndef EXIT_SUCCESS
#    define EXIT_SUCCESS 0
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yy_state_t yyss_alloc;
  YYSTYPE yyvs_alloc;
  YYLTYPE yyls_alloc;
};

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
             + YYSIZEOF (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(Dst, Src, Count) \
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  else
#   define YYCOPY(Dst, Src, Count)              \
      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)
#  endif
# endif
#endif /* !YYCOPY_NEEDED */

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  2
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   10

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  7
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  8
/* YYNRULES -- Number of rules.  */
#define YYNRULES  12
/* YYNSTATES -- Number of states.  */
#define YYNSTATES  17

#define YYUNDEFTOK  2
#define YYMAXUTOK   261


/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */
#define YYTRANSLATE(YYX)                                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex.  */
static const yytype_int8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6
};

#if YYDEBUG
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
static const yytype_int8 yyrline[] =
{
       0,    93,    93,    94,    95,    98,   100,   102,   102,   104,
     109,   118,   123
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "ALNUM", "NEWLINE", "HASH", "ERROR",
  "$accept", "input", "vertex", "vertexdef", "edges", "edge", "edgeid",
  "weight", YY_NULLPTR
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
   (internal) symbol number NUM (which must be that of a token).  */
static const yytype_int16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261
};
# endif

#define YYPACT_NINF (-3)

#define yypact_value_is_default(Yyn) \
  ((Yyn) == YYPACT_NINF)

#define YYTABLE_NINF (-1)

#define yytable_value_is_error(Yyn) \
  0

  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
static const yytype_int8 yypact[] =
{
      -3,     0,    -3,    -3,     3,    -3,    -3,    -3,    -1,     3,
      -3,    -3,    -2,    -3,    -3,     4,    -3
};

  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     Performed when YYTABLE does not specify something else to do.  Zero
     means the default is an error.  */
static const yytype_int8 yydefact[] =
{
       2,     0,     1,     3,     0,     4,     7,    11,     0,     5,
       6,     8,     0,    12,     9,     0,    10
};

  /* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
      -3,    -3,    -3,    -3,    -3,    -3,     1,    -3
};

  /* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int8 yydefgoto[] =
{
      -1,     1,     5,     6,     9,    11,     8,    15
};

  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule whose
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
static const yytype_int8 yytable[] =
{
       2,    13,    14,    10,     3,     4,     7,     0,    16,     0,
      12
};

static const yytype_int8 yycheck[] =
{
       0,     3,     4,     4,     4,     5,     3,    -1,     4,    -1,
       9
};

  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
static const yytype_int8 yystos[] =
{
       0,     8,     0,     4,     5,     9,    10,     3,    13,    11,
       4,    12,    13,     3,     4,    14,     4
};

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_int8 yyr1[] =
{
       0,     7,     8,     8,     8,     9,    10,    11,    11,    12,
      12,    13,    14
};

  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
static const yytype_int8 yyr2[] =
{
       0,     2,     0,     2,     2,     2,     3,     0,     2,     2,
       3,     1,     1
};


#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         (-2)
#define YYEOF           0

#define YYACCEPT        goto yyacceptlab
#define YYABORT         goto yyabortlab
#define YYERROR         goto yyerrorlab


#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

/* Error token number */
#define YYTERROR        1
#define YYERRCODE       256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    do                                                                  \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)
#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K])


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)                        \
do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL

/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */

YY_ATTRIBUTE_UNUSED
static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
  int res = 0;
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
  if (0 <= yylocp->first_line)
    {
      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
      if (0 <= yylocp->first_column)
        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
    }
  if (0 <= yylocp->last_line)
    {
      if (yylocp->first_line < yylocp->last_line)
        {
          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
          if (0 <= end_col)
            res += YYFPRINTF (yyo, ".%d", end_col);
        }
      else if (0 <= end_col && yylocp->first_column < end_col)
        res += YYFPRINTF (yyo, "-%d", end_col);
    }
  return res;
 }

#  define YY_LOCATION_PRINT(File, Loc)          \
  yy_location_print_ (File, &(Loc))

# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Type, Value, Location, context); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)


/*-----------------------------------.
| Print this symbol's value on YYO.  |
`-----------------------------------*/

static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_lgl_parsedata_t* context)
{
  FILE *yyoutput = yyo;
  YYUSE (yyoutput);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}


/*---------------------------.
| Print this symbol on YYO.  |
`---------------------------*/

static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_lgl_parsedata_t* context)
{
  YYFPRINTF (yyo, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  YY_LOCATION_PRINT (yyo, *yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, context);
  YYFPRINTF (yyo, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)                            \
do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, igraph_i_lgl_parsedata_t* context)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[+yyssp[yyi + 1 - yynrhs]],
                       &yyvsp[(yyi + 1) - (yynrhs)]
                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , context);
      YYFPRINTF (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)          \
do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif


#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
#  else
/* Return the length of YYSTR.  */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}
# endif

/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
                yy_state_t *yyssp, int yytoken)
{
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
     one per "expected"). */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Actual size of YYARG. */
  int yycount = 0;
  /* Cumulated lengths of YYARG.  */
  YYPTRDIFF_T yysize = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[+*yyssp];
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
      yysize = yysize0;
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYPTRDIFF_T yysize1
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                    yysize = yysize1;
                  else
                    return 2;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
    default: /* Avoid compiler warnings. */
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    /* Don't count the "%s"s in the final size, but reserve room for
       the terminator.  */
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
      yysize = yysize1;
    else
      return 2;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          ++yyp;
          ++yyformat;
        }
  }
  return 0;
}
#endif /* YYERROR_VERBOSE */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, igraph_i_lgl_parsedata_t* context)
{
  YYUSE (yyvaluep);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}




/*----------.
| yyparse.  |
`----------*/

int
yyparse (igraph_i_lgl_parsedata_t* context)
{
/* The lookahead symbol.  */
int yychar;


/* The semantic value of the lookahead symbol.  */
/* Default value used for initialization, for pacifying older GCCs
   or non-GCC compilers.  */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Location data for the lookahead symbol.  */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
  = { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;

    /* Number of syntax errors so far.  */
    int yynerrs;

    yy_state_fast_t yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       'yyss': related to states.
       'yyvs': related to semantic values.
       'yyls': related to locations.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss;
    yy_state_t *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    /* The location stack.  */
    YYLTYPE yylsa[YYINITDEPTH];
    YYLTYPE *yyls;
    YYLTYPE *yylsp;

    /* The locations where the error started and ended.  */
    YYLTYPE yyerror_range[3];

    YYPTRDIFF_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yylsp = yyls = yylsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  yylsp[0] = yylloc;
  goto yysetstate;


/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;


/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END

  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    goto yyexhaustedlab;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;

# if defined yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
        YYLTYPE *yyls1 = yyls;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yyls1, yysize * YYSIZEOF (*yylsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
        yyls = yyls1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
        YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
      yylsp = yyls + yysize - 1;

      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:
  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = yylex (&yylval, &yylloc, scanner);
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
  *++yylsp = yylloc;

  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     '$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  yyerror_range[1] = yyloc;
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
  case 6:
                                      { context->actvertex=(yyvsp[-1].edgenum); }
    break;

  case 9:
                                    {
             igraph_vector_push_back(context->vector, context->actvertex);
             igraph_vector_push_back(context->vector, (yyvsp[-1].edgenum));
             igraph_vector_push_back(context->weights, 0);
           }
    break;

  case 10:
                                    {
             igraph_vector_push_back(context->vector, context->actvertex);
             igraph_vector_push_back(context->vector, (yyvsp[-2].edgenum));
             igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum));
             context->has_weights = 1;
           }
    break;

  case 11:
                { igraph_trie_get2(context->trie,
                                   igraph_lgl_yyget_text(scanner),
                                   igraph_lgl_yyget_leng(scanner),
                                   &(yyval.edgenum)); }
    break;

  case 12:
                { (yyval.weightnum)=igraph_lgl_get_number(igraph_lgl_yyget_text(scanner),
                                           igraph_lgl_yyget_leng(scanner)); }
    break;



      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;
  *++yylsp = yyloc;

  /* Now 'shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }

  goto yynewstate;


/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (&yylloc, context, YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (&yylloc, context, yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }

  yyerror_range[1] = yylloc;

  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval, &yylloc, context);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:
  /* Pacify compilers when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;

  /* Do not reclaim the symbols of the rule whose action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;

      yyerror_range[1] = *yylsp;
      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp, yylsp, context);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  yyerror_range[2] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the lookahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
  *++yylsp = yyloc;

  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;


/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;


#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (&yylloc, context, YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif


/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result.  |
`-----------------------------------------------------*/
yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval, &yylloc, context);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[+*yyssp], yyvsp, yylsp, context);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  return yyresult;
}


int igraph_lgl_yyerror(YYLTYPE* locp, igraph_i_lgl_parsedata_t *context,
                       const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char),
           "Parse error in LGL file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

igraph_real_t igraph_lgl_get_number(const char *str, long int length) {
  igraph_real_t num;
  char *tmp=IGRAPH_CALLOC(length+1, char);

  strncpy(tmp, str, length);
  tmp[length]='\0';
  sscanf(tmp, "%lf", &num);
  IGRAPH_FREE(tmp);
  return num;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/lgl-parser.h0000644000175100001710000000552400000000000024756 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

#ifndef YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED
# define YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_lgl_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    ALNUM = 258,
    NEWLINE = 259,
    HASH = 260,
    ERROR = 261
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int edgenum;
  double weightnum;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_lgl_yyparse (igraph_i_lgl_parsedata_t* context);

#endif /* !YY_IGRAPH_LGL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_LGL_PARSER_H_INCLUDED  */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/ncol-lexer.c0000644000175100001710000016726200000000000024761 0ustar00runnerdocker00000000000000
#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_ncol_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_ncol_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_ncol_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_ncol_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_ncol_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_ncol_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_ncol_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_ncol_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_ncol_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_ncol_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_ncol_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_ncol_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_ncol_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_ncol_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_ncol_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_ncol_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_ncol_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_ncol_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_ncol_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_ncol_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_ncol_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_ncol_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_ncol_yylex_ALREADY_DEFINED
#else
#define yylex igraph_ncol_yylex
#endif

#ifdef yyrestart
#define igraph_ncol_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_ncol_yyrestart
#endif

#ifdef yylex_init
#define igraph_ncol_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_ncol_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_ncol_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_ncol_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_ncol_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_ncol_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_ncol_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_ncol_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_ncol_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_ncol_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_ncol_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_ncol_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_ncol_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_ncol_yyset_extra
#endif

#ifdef yyget_in
#define igraph_ncol_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_ncol_yyget_in
#endif

#ifdef yyset_in
#define igraph_ncol_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_ncol_yyset_in
#endif

#ifdef yyget_out
#define igraph_ncol_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_ncol_yyget_out
#endif

#ifdef yyset_out
#define igraph_ncol_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_ncol_yyset_out
#endif

#ifdef yyget_leng
#define igraph_ncol_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_ncol_yyget_leng
#endif

#ifdef yyget_text
#define igraph_ncol_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_ncol_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_ncol_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_ncol_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_ncol_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_ncol_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_ncol_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_ncol_yyget_column
#endif

#ifdef yyset_column
#define igraph_ncol_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_ncol_yyset_column
#endif

#ifdef yywrap
#define igraph_ncol_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_ncol_yywrap
#endif

#ifdef yyget_lval
#define igraph_ncol_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_ncol_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_ncol_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_ncol_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_ncol_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_ncol_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_ncol_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_ncol_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_ncol_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_ncol_yyalloc
#endif

#ifdef yyrealloc
#define igraph_ncol_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_ncol_yyrealloc
#endif

#ifdef yyfree
#define igraph_ncol_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_ncol_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yyg->yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yyg->yy_start - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = yyg->yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

static void yyensure_buffer_stack ( yyscan_t yyscanner );
static void yy_load_buffer_state ( yyscan_t yyscanner );
static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}
#define yy_set_bol(at_bol) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

#define igraph_ncol_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef flex_uint8_t YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
static int yy_get_next_buffer ( yyscan_t yyscanner );
static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yyg->yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yyg->yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 5
#define YY_END_OF_BUFFER 6
/* This struct is not used in this scanner,
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static const flex_int16_t yy_accept[13] =
    {   0,
        0,    0,    6,    3,    1,    2,    2,    4,    3,    1,
        2,    0
    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1
    } ;

static const YY_CHAR yy_meta[6] =
    {   0,
        1,    2,    3,    4,    5
    } ;

static const flex_int16_t yy_base[17] =
    {   0,
        0,    0,   10,    0,    0,    0,    0,   11,    0,    0,
       11,   11,    8,    6,    3,    3
    } ;

static const flex_int16_t yy_def[17] =
    {   0,
       12,    1,   12,   13,   14,   15,   16,   12,   13,   14,
       12,    0,   12,   12,   12,   12
    } ;

static const flex_int16_t yy_nxt[17] =
    {   0,
        4,    5,    6,    7,    8,   11,   11,   10,    9,   12,
        3,   12,   12,   12,   12,   12
    } ;

static const flex_int16_t yy_chk[17] =
    {   0,
        1,    1,    1,    1,    1,   16,   15,   14,   13,    3,
       12,   12,   12,   12,   12,   12
    } ;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/ncol-header.h"
#include "io/parsers/ncol-parser.h"

#define YY_EXTRA_TYPE igraph_i_ncol_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in NCOL parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
#define YY_NO_INPUT 1

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    YYSTYPE * yylval_r;

    YYLTYPE * yylloc_r;

    }; /* end struct yyguts_t */

static int yy_init_globals ( yyscan_t yyscanner );

    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval yyg->yylval_r
    
    #    define yylloc yyg->yylloc_r
    
int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef YY_NO_UNPUT
    
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput ( yyscan_t yyscanner );
#else
static int input ( yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    yylval = yylval_param;

    yylloc = yylloc_param;

	if ( !yyg->yy_init )
		{
		yyg->yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yyg->yy_start )
			yyg->yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			yyensure_buffer_stack (yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
		}

		yy_load_buffer_state( yyscanner );
		}

	{

 /* ------------------------------------------------whitespace------*/

	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yyg->yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yyg->yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yyg->yy_start;
yy_match:
		do
			{
			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
			if ( yy_accept[yy_current_state] )
				{
				yyg->yy_last_accepting_state = yy_current_state;
				yyg->yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 13 )
					yy_c = yy_meta[yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 11 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

do_action:	/* This label is used only to access EOF actions. */

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yyg->yy_hold_char;
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			goto yy_find_action;

case 1:
YY_RULE_SETUP
{ }
	YY_BREAK
/* ---------------------------------------------------newline------*/
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
{ return NEWLINE; }
	YY_BREAK
/* ----------------------------------------------alphanumeric------*/
case 3:
YY_RULE_SETUP
{ return ALNUM; }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
{ if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }
	YY_BREAK
/* ---------------------------------------------anything else------*/
case 4:
YY_RULE_SETUP
{ return ERROR; }
	YY_BREAK
case 5:
YY_RULE_SETUP
YY_FATAL_ERROR( "flex scanner jammed" );
	YY_BREAK

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yyg->yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between YY_CURRENT_BUFFER and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state( yyscanner );

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yyg->yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yyg->yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer( yyscanner ) )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yyg->yy_did_buffer_switch_on_eof = 0;

				if ( yywrap( yyscanner ) )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yyg->yy_c_buf_p =
					yyg->yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yyg->yy_c_buf_p =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
static int yy_get_next_buffer (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = yyg->yytext_ptr;
	int number_to_move, i;
	int ret_val;

	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

	else
		{
			int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
				}
			else
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			yyg->yy_n_chars, num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	if ( yyg->yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  , yyscanner);
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	yyg->yy_n_chars += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}

/* yy_get_previous_state - get the state just before the EOB char was reached */

    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 5);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 13 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 5;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 13 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 12);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_UNPUT

#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
	int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	*yyg->yy_c_buf_p = yyg->yy_hold_char;

	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			/* This was really a NUL. */
			*yyg->yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
			++yyg->yy_c_buf_p;

			switch ( yy_get_next_buffer( yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin , yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap( yyscanner ) )
						return 0;

					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput(yyscanner);
#else
					return input(yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
	yyg->yy_hold_char = *++yyg->yy_c_buf_p;

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * @param yyscanner The scanner object.
 */
    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param yyscanner The scanner object.
 */
    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param yyscanner The scanner object.
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (yyscan_t yyscanner)
{
	yy_size_t num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if (!yyg->yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		yyg->yy_buffer_stack_max = num_to_alloc;
		yyg->yy_buffer_stack_top = 0;
		return;
	}

	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
								(yyg->yy_buffer_stack,
								num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		yyg->yy_buffer_stack_max = num_to_alloc;
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b , yyscanner );

	return b;
}

/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
    
	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n , yyscanner );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n , yyscanner);
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		*yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int yyget_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *yyget_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param _line_number line number
 * @param yyscanner The scanner object.
 */
void yyset_lineno (int  _line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
    
    yylineno = _line_number;
}

/** Set the current column.
 * @param _column_no column number
 * @param yyscanner The scanner object.
 */
void yyset_column (int  _column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_column called with no buffer" );
    
    yycolumn = _column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = _in_str ;
}

void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = _out_str ;
}

int yyget_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void yyset_debug (int  _bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = _bdebug ;
}

/* Accessor methods for yylval and yylloc */

YYSTYPE * yyget_lval  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}
    
void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}
    
/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
    struct yyguts_t dummy_yyguts;

    yyset_extra (yy_user_defined, &dummy_yyguts);

    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    yyset_extra (yy_user_defined, *ptr_yy_globals);

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = NULL;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = NULL;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = NULL;
    yyout = NULL;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(yyscanner);
	}

	/* Destroy the stack itself. */
	yyfree(yyg->yy_buffer_stack , yyscanner);
	yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        yyfree( yyg->yy_start_stack , yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif

void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	return malloc(size);
}

void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}

void yyfree (void * ptr , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/ncol-lexer.h0000644000175100001710000004212300000000000024752 0ustar00runnerdocker00000000000000#ifndef igraph_ncol_yyHEADER_H
#define igraph_ncol_yyHEADER_H 1
#define igraph_ncol_yyIN_HEADER 1

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_ncol_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_ncol_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_ncol_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_ncol_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_ncol_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_ncol_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_ncol_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_ncol_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_ncol_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_ncol_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_ncol_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_ncol_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_ncol_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_ncol_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_ncol_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_ncol_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_ncol_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_ncol_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_ncol_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_ncol_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_ncol_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_ncol_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_ncol_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_ncol_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_ncol_yylex_ALREADY_DEFINED
#else
#define yylex igraph_ncol_yylex
#endif

#ifdef yyrestart
#define igraph_ncol_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_ncol_yyrestart
#endif

#ifdef yylex_init
#define igraph_ncol_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_ncol_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_ncol_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_ncol_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_ncol_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_ncol_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_ncol_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_ncol_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_ncol_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_ncol_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_ncol_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_ncol_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_ncol_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_ncol_yyset_extra
#endif

#ifdef yyget_in
#define igraph_ncol_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_ncol_yyget_in
#endif

#ifdef yyset_in
#define igraph_ncol_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_ncol_yyset_in
#endif

#ifdef yyget_out
#define igraph_ncol_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_ncol_yyget_out
#endif

#ifdef yyset_out
#define igraph_ncol_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_ncol_yyset_out
#endif

#ifdef yyget_leng
#define igraph_ncol_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_ncol_yyget_leng
#endif

#ifdef yyget_text
#define igraph_ncol_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_ncol_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_ncol_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_ncol_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_ncol_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_ncol_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_ncol_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_ncol_yyget_column
#endif

#ifdef yyset_column
#define igraph_ncol_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_ncol_yyset_column
#endif

#ifdef yywrap
#define igraph_ncol_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_ncol_yywrap
#endif

#ifdef yyget_lval
#define igraph_ncol_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_ncol_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_ncol_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_ncol_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_ncol_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_ncol_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_ncol_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_ncol_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_ncol_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_ncol_yyalloc
#endif

#ifdef yyrealloc
#define igraph_ncol_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_ncol_yyrealloc
#endif

#ifdef yyfree
#define igraph_ncol_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_ncol_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

/* Begin user sect3 */

#define igraph_ncol_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP

#define yytext_ptr yytext_r

#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0

#endif

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* yy_get_previous_state - get the state just before the EOB char was reached */

#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif

#ifndef igraph_ncol_yy_create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef igraph_ncol_yy_delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef igraph_ncol_yy_scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef igraph_ncol_yy_scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef igraph_ncol_yy_scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef igraph_ncol_yy_init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef igraph_ncol_yy_flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef igraph_ncol_yy_load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef igraph_ncol_yy_switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef igraph_ncol_yypush_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef igraph_ncol_yypop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef igraph_ncol_yyensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef igraph_ncol_yylex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef igraph_ncol_yyrestart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef igraph_ncol_yylex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef igraph_ncol_yylex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef igraph_ncol_yylex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef igraph_ncol_yyget_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef igraph_ncol_yyset_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef igraph_ncol_yyget_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef igraph_ncol_yyset_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef igraph_ncol_yyget_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef igraph_ncol_yyset_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef igraph_ncol_yyget_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef igraph_ncol_yyset_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef igraph_ncol_yyget_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef igraph_ncol_yyget_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef igraph_ncol_yyget_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef igraph_ncol_yyset_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef igraph_ncol_yyget_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef igraph_ncol_yyset_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef igraph_ncol_yywrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef igraph_ncol_yyget_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef igraph_ncol_yyset_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef igraph_ncol_yyget_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef igraph_ncol_yyset_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef igraph_ncol_yyalloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef igraph_ncol_yyrealloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef igraph_ncol_yyfree_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef igraph_ncol_yytext_ALREADY_DEFINED
#undef yytext
#endif
#ifndef igraph_ncol_yyleng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef igraph_ncol_yyin_ALREADY_DEFINED
#undef yyin
#endif
#ifndef igraph_ncol_yyout_ALREADY_DEFINED
#undef yyout
#endif
#ifndef igraph_ncol_yy_flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef igraph_ncol_yylineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef igraph_ncol_yytables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef igraph_ncol_yytables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef igraph_ncol_yyTABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif

#undef igraph_ncol_yyIN_HEADER
#endif /* igraph_ncol_yyHEADER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/ncol-parser.c0000644000175100001710000015403700000000000025132 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "3.5.1"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 1

/* Push parsers.  */
#define YYPUSH 0

/* Pull parsers.  */
#define YYPULL 1


/* Substitute the variable and function names.  */
#define yyparse         igraph_ncol_yyparse
#define yylex           igraph_ncol_yylex
#define yyerror         igraph_ncol_yyerror
#define yydebug         igraph_ncol_yydebug
#define yynerrs         igraph_ncol_yynerrs

/* First part of user prologue.  */


/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "config.h"

#include "core/math.h"
#include "io/ncol-header.h"
#include "io/parsers/ncol-parser.h"
#include "io/parsers/ncol-lexer.h"
#include "internal/hacks.h"

int igraph_ncol_yyerror(YYLTYPE* locp,
                        igraph_i_ncol_parsedata_t *context,
                        const char *s);
igraph_real_t igraph_ncol_get_number(const char *str, long int len);

#define scanner context->scanner


# ifndef YY_CAST
#  ifdef __cplusplus
#   define YY_CAST(Type, Val) static_cast (Val)
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val)
#  else
#   define YY_CAST(Type, Val) ((Type) (Val))
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
#  endif
# endif
# ifndef YY_NULLPTR
#  if defined __cplusplus
#   if 201103L <= __cplusplus
#    define YY_NULLPTR nullptr
#   else
#    define YY_NULLPTR 0
#   endif
#  else
#   define YY_NULLPTR ((void*)0)
#  endif
# endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif

/* Use api.header.include to #include this header
   instead of duplicating it here.  */
#ifndef YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED
# define YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_ncol_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    ALNUM = 258,
    NEWLINE = 259,
    ERROR = 260
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int edgenum;
  double weightnum;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_ncol_yyparse (igraph_i_ncol_parsedata_t* context);

#endif /* !YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED  */



#ifdef short
# undef short
#endif

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
    and (if available)  are included
   so that the code can choose integer types of a good width.  */

#ifndef __PTRDIFF_MAX__
# include  /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YY_STDINT_H
# endif
#endif

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif

#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif

#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif

#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif

#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
#  ifndef ptrdiff_t
#   include  /* INFRINGES ON USER NAME SPACE */
#  endif
#  define YYPTRDIFF_T ptrdiff_t
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
#  define YYPTRDIFF_T long
#  define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned
# endif
#endif

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))

/* Stored state numbers (used for stacks). */
typedef yytype_int8 yy_state_t;

/* State numbers in computations.  */
typedef int yy_state_fast_t;

#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
#  if ENABLE_NLS
#   include  /* INFRINGES ON USER NAME SPACE */
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(Msgid) Msgid
# endif
#endif

#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define YY_ATTRIBUTE_PURE
# endif
#endif

#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
#  define YY_ATTRIBUTE_UNUSED
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif

#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
    _Pragma ("GCC diagnostic push")                                     \
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
    _Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif

#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
    _Pragma ("GCC diagnostic push")                            \
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END            \
    _Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif


#define YY_ASSERT(E) ((void) (0 && (E)))

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include  /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include  /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
#     include  /* INFRINGES ON USER NAME SPACE */
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
#     ifndef EXIT_SUCCESS
#      define EXIT_SUCCESS 0
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's 'empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
       && ! ((defined YYMALLOC || defined malloc) \
             && (defined YYFREE || defined free)))
#   include  /* INFRINGES ON USER NAME SPACE */
#   ifndef EXIT_SUCCESS
#    define EXIT_SUCCESS 0
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yy_state_t yyss_alloc;
  YYSTYPE yyvs_alloc;
  YYLTYPE yyls_alloc;
};

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
             + YYSIZEOF (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(Dst, Src, Count) \
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  else
#   define YYCOPY(Dst, Src, Count)              \
      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)
#  endif
# endif
#endif /* !YYCOPY_NEEDED */

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  2
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   10

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  6
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  5
/* YYNRULES -- Number of rules.  */
#define YYNRULES  8
/* YYNSTATES -- Number of states.  */
#define YYNSTATES  12

#define YYUNDEFTOK  2
#define YYMAXUTOK   260


/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */
#define YYTRANSLATE(YYX)                                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex.  */
static const yytype_int8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5
};

#if YYDEBUG
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
static const yytype_int8 yyrline[] =
{
       0,    93,    93,    94,    95,    98,   103,   111,   116
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "ALNUM", "NEWLINE", "ERROR", "$accept",
  "input", "edge", "edgeid", "weight", YY_NULLPTR
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
   (internal) symbol number NUM (which must be that of a token).  */
static const yytype_int16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260
};
# endif

#define YYPACT_NINF (-3)

#define yypact_value_is_default(Yyn) \
  ((Yyn) == YYPACT_NINF)

#define YYTABLE_NINF (-1)

#define yytable_value_is_error(Yyn) \
  0

  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
static const yytype_int8 yypact[] =
{
      -3,     0,    -3,    -3,    -3,    -3,     2,    -2,    -3,    -3,
       3,    -3
};

  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     Performed when YYTABLE does not specify something else to do.  Zero
     means the default is an error.  */
static const yytype_int8 yydefact[] =
{
       2,     0,     1,     7,     3,     4,     0,     0,     8,     5,
       0,     6
};

  /* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
      -3,    -3,    -3,     4,    -3
};

  /* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int8 yydefgoto[] =
{
      -1,     1,     5,     6,    10
};

  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule whose
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
static const yytype_int8 yytable[] =
{
       2,     8,     9,     3,     4,     3,     0,    11,     0,     0,
       7
};

static const yytype_int8 yycheck[] =
{
       0,     3,     4,     3,     4,     3,    -1,     4,    -1,    -1,
       6
};

  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
static const yytype_int8 yystos[] =
{
       0,     7,     0,     3,     4,     8,     9,     9,     3,     4,
      10,     4
};

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_int8 yyr1[] =
{
       0,     6,     7,     7,     7,     8,     8,     9,    10
};

  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
static const yytype_int8 yyr2[] =
{
       0,     2,     0,     2,     2,     3,     4,     1,     1
};


#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         (-2)
#define YYEOF           0

#define YYACCEPT        goto yyacceptlab
#define YYABORT         goto yyabortlab
#define YYERROR         goto yyerrorlab


#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

/* Error token number */
#define YYTERROR        1
#define YYERRCODE       256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    do                                                                  \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)
#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K])


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)                        \
do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL

/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */

YY_ATTRIBUTE_UNUSED
static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
  int res = 0;
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
  if (0 <= yylocp->first_line)
    {
      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
      if (0 <= yylocp->first_column)
        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
    }
  if (0 <= yylocp->last_line)
    {
      if (yylocp->first_line < yylocp->last_line)
        {
          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
          if (0 <= end_col)
            res += YYFPRINTF (yyo, ".%d", end_col);
        }
      else if (0 <= end_col && yylocp->first_column < end_col)
        res += YYFPRINTF (yyo, "-%d", end_col);
    }
  return res;
 }

#  define YY_LOCATION_PRINT(File, Loc)          \
  yy_location_print_ (File, &(Loc))

# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Type, Value, Location, context); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)


/*-----------------------------------.
| Print this symbol's value on YYO.  |
`-----------------------------------*/

static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_ncol_parsedata_t* context)
{
  FILE *yyoutput = yyo;
  YYUSE (yyoutput);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}


/*---------------------------.
| Print this symbol on YYO.  |
`---------------------------*/

static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_ncol_parsedata_t* context)
{
  YYFPRINTF (yyo, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  YY_LOCATION_PRINT (yyo, *yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, context);
  YYFPRINTF (yyo, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)                            \
do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, igraph_i_ncol_parsedata_t* context)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[+yyssp[yyi + 1 - yynrhs]],
                       &yyvsp[(yyi + 1) - (yynrhs)]
                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , context);
      YYFPRINTF (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)          \
do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif


#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
#  else
/* Return the length of YYSTR.  */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}
# endif

/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
                yy_state_t *yyssp, int yytoken)
{
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
     one per "expected"). */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Actual size of YYARG. */
  int yycount = 0;
  /* Cumulated lengths of YYARG.  */
  YYPTRDIFF_T yysize = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[+*yyssp];
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
      yysize = yysize0;
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYPTRDIFF_T yysize1
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                    yysize = yysize1;
                  else
                    return 2;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
    default: /* Avoid compiler warnings. */
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    /* Don't count the "%s"s in the final size, but reserve room for
       the terminator.  */
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
      yysize = yysize1;
    else
      return 2;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          ++yyp;
          ++yyformat;
        }
  }
  return 0;
}
#endif /* YYERROR_VERBOSE */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, igraph_i_ncol_parsedata_t* context)
{
  YYUSE (yyvaluep);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}




/*----------.
| yyparse.  |
`----------*/

int
yyparse (igraph_i_ncol_parsedata_t* context)
{
/* The lookahead symbol.  */
int yychar;


/* The semantic value of the lookahead symbol.  */
/* Default value used for initialization, for pacifying older GCCs
   or non-GCC compilers.  */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Location data for the lookahead symbol.  */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
  = { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;

    /* Number of syntax errors so far.  */
    int yynerrs;

    yy_state_fast_t yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       'yyss': related to states.
       'yyvs': related to semantic values.
       'yyls': related to locations.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss;
    yy_state_t *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    /* The location stack.  */
    YYLTYPE yylsa[YYINITDEPTH];
    YYLTYPE *yyls;
    YYLTYPE *yylsp;

    /* The locations where the error started and ended.  */
    YYLTYPE yyerror_range[3];

    YYPTRDIFF_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yylsp = yyls = yylsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  yylsp[0] = yylloc;
  goto yysetstate;


/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;


/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END

  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    goto yyexhaustedlab;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;

# if defined yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
        YYLTYPE *yyls1 = yyls;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yyls1, yysize * YYSIZEOF (*yylsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
        yyls = yyls1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
        YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
      yylsp = yyls + yysize - 1;

      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:
  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = yylex (&yylval, &yylloc, scanner);
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
  *++yylsp = yylloc;

  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     '$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  yyerror_range[1] = yyloc;
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
  case 5:
                                      {
           igraph_vector_push_back(context->vector, (yyvsp[-2].edgenum));
           igraph_vector_push_back(context->vector, (yyvsp[-1].edgenum));
           igraph_vector_push_back(context->weights, 0);
       }
    break;

  case 6:
                                      {
           igraph_vector_push_back(context->vector, (yyvsp[-3].edgenum));
           igraph_vector_push_back(context->vector, (yyvsp[-2].edgenum));
           igraph_vector_push_back(context->weights, (yyvsp[-1].weightnum));
           context->has_weights = 1;
       }
    break;

  case 7:
                { igraph_trie_get2(context->trie,
                  igraph_ncol_yyget_text(scanner),
                  igraph_ncol_yyget_leng(scanner),
                  &(yyval.edgenum)); }
    break;

  case 8:
                { (yyval.weightnum)=igraph_ncol_get_number(igraph_ncol_yyget_text(scanner),
                        igraph_ncol_yyget_leng(scanner)); }
    break;



      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;
  *++yylsp = yyloc;

  /* Now 'shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }

  goto yynewstate;


/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (&yylloc, context, YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (&yylloc, context, yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }

  yyerror_range[1] = yylloc;

  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval, &yylloc, context);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:
  /* Pacify compilers when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;

  /* Do not reclaim the symbols of the rule whose action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;

      yyerror_range[1] = *yylsp;
      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp, yylsp, context);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  yyerror_range[2] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the lookahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
  *++yylsp = yyloc;

  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;


/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;


#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (&yylloc, context, YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif


/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result.  |
`-----------------------------------------------------*/
yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval, &yylloc, context);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[+*yyssp], yyvsp, yylsp, context);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  return yyresult;
}


int igraph_ncol_yyerror(YYLTYPE* locp,
            igraph_i_ncol_parsedata_t *context,
            const char *s) {
    snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
            "Parse error in NCOL file, line %i (%s)",
            locp->first_line, s);
    return 0;
}

igraph_real_t igraph_ncol_get_number(const char *str, long int length) {
    igraph_real_t num;
    char *tmp=IGRAPH_CALLOC(length+1, char);

    strncpy(tmp, str, length);
    tmp[length]='\0';
    sscanf(tmp, "%lf", &num);
    IGRAPH_FREE(tmp);
    return num;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/ncol-parser.h0000644000175100001710000000551500000000000025133 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

#ifndef YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED
# define YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_ncol_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    ALNUM = 258,
    NEWLINE = 259,
    ERROR = 260
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int edgenum;
  double weightnum;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_ncol_yyparse (igraph_i_ncol_parsedata_t* context);

#endif /* !YY_IGRAPH_NCOL_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_NCOL_PARSER_H_INCLUDED  */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/pajek-lexer.c0000644000175100001710000023210400000000000025104 0ustar00runnerdocker00000000000000
#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_pajek_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_pajek_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_pajek_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_pajek_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_pajek_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_pajek_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_pajek_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_pajek_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_pajek_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_pajek_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_pajek_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_pajek_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_pajek_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_pajek_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_pajek_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_pajek_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_pajek_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_pajek_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_pajek_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_pajek_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_pajek_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_pajek_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_pajek_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_pajek_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_pajek_yylex_ALREADY_DEFINED
#else
#define yylex igraph_pajek_yylex
#endif

#ifdef yyrestart
#define igraph_pajek_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_pajek_yyrestart
#endif

#ifdef yylex_init
#define igraph_pajek_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_pajek_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_pajek_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_pajek_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_pajek_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_pajek_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_pajek_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_pajek_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_pajek_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_pajek_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_pajek_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_pajek_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_pajek_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_pajek_yyset_extra
#endif

#ifdef yyget_in
#define igraph_pajek_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_pajek_yyget_in
#endif

#ifdef yyset_in
#define igraph_pajek_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_pajek_yyset_in
#endif

#ifdef yyget_out
#define igraph_pajek_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_pajek_yyget_out
#endif

#ifdef yyset_out
#define igraph_pajek_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_pajek_yyset_out
#endif

#ifdef yyget_leng
#define igraph_pajek_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_pajek_yyget_leng
#endif

#ifdef yyget_text
#define igraph_pajek_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_pajek_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_pajek_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_pajek_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_pajek_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_pajek_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_pajek_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_pajek_yyget_column
#endif

#ifdef yyset_column
#define igraph_pajek_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_pajek_yyset_column
#endif

#ifdef yywrap
#define igraph_pajek_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_pajek_yywrap
#endif

#ifdef yyget_lval
#define igraph_pajek_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_pajek_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_pajek_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_pajek_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_pajek_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_pajek_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_pajek_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_pajek_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_pajek_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_pajek_yyalloc
#endif

#ifdef yyrealloc
#define igraph_pajek_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_pajek_yyrealloc
#endif

#ifdef yyfree
#define igraph_pajek_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_pajek_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an
 *   integer in range [0..255] for use as an array index.
 */
#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yyg->yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 * compatibility.
 */
#define YY_START ((yyg->yy_start - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

/* The state buf must be large enough to hold one state per character in the main buffer.
 */
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
    
    #define YY_LESS_LINENO(n)
    #define YY_LINENO_REWIND_TO(ptr)
    
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		*yy_cp = yyg->yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
	/* When an EOF's been seen but there's still some text to process
	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	 * shouldn't try reading from the input source any more.  We might
	 * still have a bunch of tokens to match, though, because of
	 * possible backing-up.
	 *
	 * When we actually see the EOF, we change the status to "new"
	 * (via yyrestart()), so that the user can continue scanning by
	 * just pointing yyin at a new input file.
	 */
#define YY_BUFFER_EOF_PENDING 2

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 *
 * Returns the top of the stack, or NULL.
 */
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
 * NULL or when we need an lvalue. For internal use only.
 */
#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

static void yyensure_buffer_stack ( yyscan_t yyscanner );
static void yy_load_buffer_state ( yyscan_t yyscanner );
static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
	}
#define yy_set_bol(at_bol) \
	{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
	} \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
	}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */

#define igraph_pajek_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
typedef flex_uint8_t YY_CHAR;

typedef int yy_state_type;

#define yytext_ptr yytext_r

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
static int yy_get_next_buffer ( yyscan_t yyscanner );
static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yyg->yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yyg->yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 48
#define YY_END_OF_BUFFER 49
/* This struct is not used in this scanner,
   but its presence is necessary. */
struct yy_trans_info
	{
	flex_int32_t yy_verify;
	flex_int32_t yy_nxt;
	};
static const flex_int16_t yy_accept[161] =
    {   0,
        0,    0,   49,   46,    1,   12,   12,   46,   46,   46,
       46,   46,   15,   46,   46,   46,   46,   46,   46,   46,
       46,   46,   46,   46,   46,   46,   46,   46,   46,   47,
       46,    1,   12,   46,    0,   13,   46,    0,    2,    3,
       46,    0,   14,   46,   46,   46,   46,   46,   15,   46,
       46,   29,   46,   46,   46,   46,   46,   26,   46,   46,
       46,   46,   46,   46,   38,   46,   46,   46,   46,   27,
       46,   23,   22,   28,   46,   46,   30,   46,   46,   13,
        2,    2,   14,   46,   46,   46,   46,   46,   15,   46,
       15,   33,   34,   37,   19,   20,   46,   46,   31,   32,

       18,   35,   36,   43,   41,   39,   46,   42,   46,   46,
       46,   46,   46,    3,   46,   46,   46,    4,   46,   46,
       45,   46,   21,   46,   25,   46,   46,    7,   46,   46,
       46,   46,   24,   40,   44,   46,   46,   46,    8,   46,
       46,   46,   46,   46,   46,   46,   11,   46,   46,   16,
       17,   46,   46,    5,   46,    9,   46,    6,   10,    0
    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    5,    1,    1,    6,    1,    1,    7,
        8,    9,   10,    1,   11,   12,    1,   13,   14,   15,
       13,   13,   13,   13,   13,   13,   13,    1,    1,    1,
        1,    1,    1,    1,   16,   17,   18,   19,   20,   21,
       22,   23,   24,    1,   25,   26,   27,   28,   29,   30,
       31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
        1,    1,    1,    1,   41,    1,   16,   17,   18,   19,

       20,   21,   22,   23,   24,    1,   25,   26,   27,   28,
       29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
       39,   40,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1
    } ;

static const YY_CHAR yy_meta[43] =
    {   0,
        1,    2,    2,    2,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2
    } ;

static const flex_int16_t yy_base[168] =
    {   0,
        0,    0,  295,    0,  292,  289,  289,   41,   45,   48,
       37,   45,   54,   74,   43,   68,  262,   40,  272,   48,
      103,   89,   82,   92,   96,  257,   99,  247,  246,  296,
        0,  284,  296,  106,  280,    0,  111,   78,  280,  113,
      120,  275,    0,  250,  262,  264,  259,  258,  117,  112,
      128,  296,  142,  147,  152,  155,  161,  296,  119,  164,
      167,  170,  173,  176,  296,  179,  182,  185,  188,  296,
      253,  296,  296,  296,  236,  249,  296,  253,  252,  296,
      268,  157,  296,  253,  248,  235,  234,  235,  180,  183,
      188,  296,  296,  296,  296,  296,  232,  202,  296,  296,

      296,  296,  296,  296,  296,  296,  241,  296,  207,  244,
      210,  247,  246,  258,  227,  239,  226,  220,  222,  213,
      296,  216,  296,  219,  296,  237,  236,  227,  219,  227,
      221,  225,  296,  296,  296,  214,  213,  222,  219,  206,
      211,  224,  222,  225,  174,  175,    0,  115,  116,  296,
      296,  100,   85,    0,   64,    0,   45,    0,    0,  296,
       74,  229,  231,  233,  235,  237,  239
    } ;

static const flex_int16_t yy_def[168] =
    {   0,
      160,    1,  160,  161,  160,  160,  160,  162,  163,  164,
      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
      161,  161,  161,  161,  161,  161,  161,  161,  161,  160,
      161,  160,  160,  162,  165,  161,  163,  166,  160,  166,
      164,  167,  161,  161,  161,  161,  161,  161,  161,  161,
      161,  160,  161,  161,  161,  161,  161,  160,  161,  161,
      161,  161,  161,  161,  160,  161,  161,  161,  161,  160,
      161,  160,  160,  160,  161,  161,  160,  161,  161,  160,
      160,  160,  160,  161,  161,  161,  161,  161,  161,  161,
      161,  160,  160,  160,  160,  160,  161,  161,  160,  160,

      160,  160,  160,  160,  160,  160,  161,  160,  161,  161,
      161,  161,  161,  160,  161,  161,  161,  161,  161,  161,
      160,  161,  160,  161,  160,  161,  161,  161,  161,  161,
      161,  161,  160,  160,  160,  161,  161,  161,  161,  161,
      161,  161,  161,  161,  161,  161,  161,  161,  161,  160,
      160,  161,  161,  161,  161,  161,  161,  161,  161,    0,
      160,  160,  160,  160,  160,  160,  160
    } ;

static const flex_int16_t yy_nxt[339] =
    {   0,
        4,    5,    6,    7,    8,    9,   10,    4,   11,    4,
       12,    4,   13,   13,   13,   14,   15,   16,    4,    4,
       17,    4,   18,   19,   20,   21,    4,    4,    4,   22,
       23,   24,   25,    4,   26,    4,   27,   28,   29,    4,
        4,   30,   35,   35,   35,   36,   38,   39,   40,   42,
       42,   42,   44,   60,   61,   43,   45,   49,   49,   49,
       56,   63,   64,   46,   47,   50,   49,   49,   49,   58,
       58,   58,   48,   51,   31,   52,   52,   52,  159,   57,
       39,   40,   35,   72,   72,   72,   38,   53,   54,   42,
       70,   70,   70,   73,   73,   73,  158,   74,   74,   74,

       77,   77,   77,   55,   65,   65,   65,   35,   35,   35,
       36,   71,   38,   39,   40,   82,   40,  157,   66,   75,
       67,   42,   42,   42,   89,   89,   89,   43,   50,   49,
       49,   49,   68,  156,   69,  155,   51,   90,   90,  154,
       91,   91,   91,   92,   92,   92,   97,   35,   93,   93,
       93,   98,   38,   94,   94,   94,   95,   95,   95,  114,
       81,   42,   96,   96,   96,   99,   99,   99,  100,  100,
      100,  101,  101,  101,  102,  102,  102,  103,  103,  103,
      104,  104,  104,  105,  105,  105,  106,  106,  106,  108,
      108,  108,   89,   89,   89,   91,   91,   91,  153,   51,

       91,   91,   91,  121,  121,  121,  152,  107,  123,  123,
      123,  125,  125,  125,  133,  133,  133,  134,  134,  134,
      135,  135,  135,  150,  150,  150,  151,  151,  151,   34,
       34,   37,   37,   41,   41,   35,   35,   38,   38,   42,
       42,  149,  148,  147,  146,  145,  144,  143,  142,  141,
      140,  139,  138,  137,  136,  132,  131,  130,  129,  128,
      114,  127,  126,  124,  122,  120,  119,  118,  117,  116,
      115,   81,  113,  112,  111,  110,  109,   88,   87,   86,
       85,   84,   83,   81,   80,   32,   79,   78,   76,   62,
       59,   33,   33,   32,  160,    3,  160,  160,  160,  160,

      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160
    } ;

static const flex_int16_t yy_chk[339] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    8,    8,    8,    8,    9,    9,    9,   10,
       10,   10,   11,   18,   18,   10,   11,   12,   12,   12,
       15,   20,   20,   11,   11,   13,   13,   13,   13,   16,
       16,   16,   11,   13,  161,   14,   14,   14,  157,   15,
       38,   38,    8,   23,   23,   23,    9,   14,   14,   10,
       22,   22,   22,   24,   24,   24,  155,   25,   25,   25,

       27,   27,   27,   14,   21,   21,   21,   34,   34,   34,
       34,   22,   37,   37,   37,   40,   40,  153,   21,   25,
       21,   41,   41,   41,   50,   50,   50,   41,   49,   49,
       49,   49,   21,  152,   21,  149,   49,   51,   51,  148,
       51,   51,   51,   53,   53,   53,   59,   34,   54,   54,
       54,   59,   37,   55,   55,   55,   56,   56,   56,   82,
       82,   41,   57,   57,   57,   60,   60,   60,   61,   61,
       61,   62,   62,   62,   63,   63,   63,   64,   64,   64,
       66,   66,   66,   67,   67,   67,   68,   68,   68,   69,
       69,   69,   89,   89,   89,   90,   90,   90,  146,   89,

       91,   91,   91,   98,   98,   98,  145,   68,  109,  109,
      109,  111,  111,  111,  120,  120,  120,  122,  122,  122,
      124,  124,  124,  143,  143,  143,  144,  144,  144,  162,
      162,  163,  163,  164,  164,  165,  165,  166,  166,  167,
      167,  142,  141,  140,  139,  138,  137,  136,  132,  131,
      130,  129,  128,  127,  126,  119,  118,  117,  116,  115,
      114,  113,  112,  110,  107,   97,   88,   87,   86,   85,
       84,   81,   79,   78,   76,   75,   71,   48,   47,   46,
       45,   44,   42,   39,   35,   32,   29,   28,   26,   19,
       17,    7,    6,    5,    3,  160,  160,  160,  160,  160,

      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
      160,  160,  160,  160,  160,  160,  160,  160
    } ;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "config.h"
#include 

#include "io/pajek-header.h"
#include "io/parsers/pajek-parser.h"

#define YY_EXTRA_TYPE igraph_i_pajek_parsedata_t*
#define YY_USER_ACTION yylloc->first_line = yylineno;
#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in Pajek parser: " # msg)
#ifdef USING_R
#define fprintf(file, msg, ...) (1)
#ifdef stdout
#  undef stdout
#endif
#define stdout 0
#endif
#define YY_NO_INPUT 1

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Holds the entire state of the reentrant scanner. */
struct yyguts_t
    {

    /* User-defined. Not touched by flex. */
    YY_EXTRA_TYPE yyextra_r;

    /* The rest are the same as the globals declared in the non-reentrant scanner. */
    FILE *yyin_r, *yyout_r;
    size_t yy_buffer_stack_top; /**< index of top of stack. */
    size_t yy_buffer_stack_max; /**< capacity of stack. */
    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
    char yy_hold_char;
    int yy_n_chars;
    int yyleng_r;
    char *yy_c_buf_p;
    int yy_init;
    int yy_start;
    int yy_did_buffer_switch_on_eof;
    int yy_start_stack_ptr;
    int yy_start_stack_depth;
    int *yy_start_stack;
    yy_state_type yy_last_accepting_state;
    char* yy_last_accepting_cpos;

    int yylineno_r;
    int yy_flex_debug_r;

    char *yytext_r;
    int yy_more_flag;
    int yy_more_len;

    YYSTYPE * yylval_r;

    YYLTYPE * yylloc_r;

    }; /* end struct yyguts_t */

static int yy_init_globals ( yyscan_t yyscanner );

    /* This must go here because YYSTYPE and YYLTYPE are included
     * from bison output in section 1.*/
    #    define yylval yyg->yylval_r
    
    #    define yylloc yyg->yylloc_r
    
int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef YY_NO_UNPUT
    
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput ( yyscan_t yyscanner );
#else
static int input ( yyscan_t yyscanner );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	yy_state_type yy_current_state;
	char *yy_cp, *yy_bp;
	int yy_act;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    yylval = yylval_param;

    yylloc = yylloc_param;

	if ( !yyg->yy_init )
		{
		yyg->yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yyg->yy_start )
			yyg->yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			yyensure_buffer_stack (yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
		}

		yy_load_buffer_state( yyscanner );
		}

	{

	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yyg->yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yyg->yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yyg->yy_start;
yy_match:
		do
			{
			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
			if ( yy_accept[yy_current_state] )
				{
				yyg->yy_last_accepting_state = yy_current_state;
				yyg->yy_last_accepting_cpos = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 161 )
					yy_c = yy_meta[yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 296 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

do_action:	/* This label is used only to access EOF actions. */

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yyg->yy_hold_char;
			yy_cp = yyg->yy_last_accepting_cpos;
			yy_current_state = yyg->yy_last_accepting_state;
			goto yy_find_action;

case 1:
YY_RULE_SETUP
{ }
	YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
{ }
	YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
{ }
	YY_BREAK
case 4:
YY_RULE_SETUP
{ return NETWORKLINE; }
	YY_BREAK
case 5:
YY_RULE_SETUP
{ return NETWORKLINE; }
	YY_BREAK
case 6:
YY_RULE_SETUP
{ return VERTICESLINE; }
	YY_BREAK
case 7:
YY_RULE_SETUP
{ return ARCSLINE; }
	YY_BREAK
case 8:
YY_RULE_SETUP
{ return EDGESLINE; }
	YY_BREAK
case 9:
YY_RULE_SETUP
{ return ARCSLISTLINE; }
	YY_BREAK
case 10:
YY_RULE_SETUP
{ return EDGESLISTLINE; }
	YY_BREAK
case 11:
YY_RULE_SETUP
{ return MATRIXLINE; }
	YY_BREAK
case 12:
/* rule 12 can match eol */
YY_RULE_SETUP
{ yyextra->mode=0; return NEWLINE; }
	YY_BREAK
case 13:
/* rule 13 can match eol */
YY_RULE_SETUP
{ return QSTR; }
	YY_BREAK
case 14:
/* rule 14 can match eol */
YY_RULE_SETUP
{ return PSTR; }
	YY_BREAK
case 15:
YY_RULE_SETUP
{
                    return NUM; }
	YY_BREAK
case 16:
/* rule 16 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 6);
yyg->yy_c_buf_p = yy_cp = yy_bp + 6;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_X_FACT; } else { return ALNUM; } }
	YY_BREAK
case 17:
/* rule 17 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 6);
yyg->yy_c_buf_p = yy_cp = yy_bp + 6;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_Y_FACT; } else { return ALNUM; } }
	YY_BREAK
case 18:
/* rule 18 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_IC; } else { return ALNUM; } }
	YY_BREAK
case 19:
/* rule 19 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_BC; } else { return ALNUM; } }
	YY_BREAK
case 20:
/* rule 20 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_BW; } else { return ALNUM; } }
	YY_BREAK
case 21:
/* rule 21 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 3);
yyg->yy_c_buf_p = yy_cp = yy_bp + 3;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_PHI; } else { return ALNUM; } }
	YY_BREAK
case 22:
/* rule 22 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_R; } else { return ALNUM; } }
	YY_BREAK
case 23:
/* rule 23 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_Q; } else { return ALNUM; } }
	YY_BREAK
case 24:
/* rule 24 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 4);
yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_FONT; } else { return ALNUM; } }
	YY_BREAK
case 25:
/* rule 25 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 3);
yyg->yy_c_buf_p = yy_cp = yy_bp + 3;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_URL; } else { return ALNUM; } }
	YY_BREAK
case 26:
/* rule 26 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_C; } else { return ALNUM; } }
	YY_BREAK
case 27:
/* rule 27 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_P; } else { return ALNUM; } }
	YY_BREAK
case 28:
/* rule 28 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_S; } else { return ALNUM; } }
	YY_BREAK
case 29:
/* rule 29 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_A; } else { return ALNUM; } }
	YY_BREAK
case 30:
/* rule 30 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_W; } else { return ALNUM; } }
	YY_BREAK
case 31:
/* rule 31 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_H1; } else { return ALNUM; } }
	YY_BREAK
case 32:
/* rule 32 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_H2; } else { return ALNUM; } }
	YY_BREAK
case 33:
/* rule 33 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_A1; } else { return ALNUM; } }
	YY_BREAK
case 34:
/* rule 34 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_A2; } else { return ALNUM; } }
	YY_BREAK
case 35:
/* rule 35 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_K1; } else { return ALNUM; } }
	YY_BREAK
case 36:
/* rule 36 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_K2; } else { return ALNUM; } }
	YY_BREAK
case 37:
/* rule 37 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_AP; } else { return ALNUM; } }
	YY_BREAK
case 38:
/* rule 38 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 1);
yyg->yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_L; } else { return ALNUM; } }
	YY_BREAK
case 39:
/* rule 39 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==2) { return EP_LP; } else { return ALNUM; } }
	YY_BREAK
case 40:
/* rule 40 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 4);
yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_LPHI; } else
                             if (yyextra->mode==2) { return EP_LPHI; } else { return ALNUM; } }
	YY_BREAK
case 41:
/* rule 41 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_LC; } else
                             if (yyextra->mode==2) { return EP_LC; } else { return ALNUM; } }
	YY_BREAK
case 42:
/* rule 42 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_LR; } else
                             if (yyextra->mode==2) { return EP_LR; } else { return ALNUM; } }
	YY_BREAK
case 43:
/* rule 43 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 2);
yyg->yy_c_buf_p = yy_cp = yy_bp + 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_LA; } else
                             if (yyextra->mode==2) { return EP_LA; } else { return ALNUM; } }
	YY_BREAK
case 44:
/* rule 44 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 4);
yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_SIZE; } else
                             if (yyextra->mode==2) { return EP_SIZE; } else { return ALNUM; } }
	YY_BREAK
case 45:
/* rule 45 can match eol */
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
YY_LINENO_REWIND_TO(yy_bp + 3);
yyg->yy_c_buf_p = yy_cp = yy_bp + 3;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
{ if (yyextra->mode==1) { return VP_FOS; } else
                             if (yyextra->mode==2) { return EP_FOS; } else { return ALNUM; } }
	YY_BREAK
case 46:
YY_RULE_SETUP
{ return ALNUM; }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
{ if (yyextra->eof) {
                       yyterminate();
                    } else {
                       yyextra->eof=1;
                       return NEWLINE;
                    }
                  }
	YY_BREAK
case 47:
YY_RULE_SETUP
{ return ERROR; }
	YY_BREAK
case 48:
YY_RULE_SETUP
YY_FATAL_ERROR( "flex scanner jammed" );
	YY_BREAK

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yyg->yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between YY_CURRENT_BUFFER and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state( yyscanner );

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yyg->yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yyg->yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer( yyscanner ) )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yyg->yy_did_buffer_switch_on_eof = 0;

				if ( yywrap( yyscanner ) )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yyg->yy_c_buf_p =
					yyg->yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yyg->yy_c_buf_p =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

				yy_current_state = yy_get_previous_state( yyscanner );

				yy_cp = yyg->yy_c_buf_p;
				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of user's declarations */
} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */
static int yy_get_next_buffer (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
	char *source = yyg->yytext_ptr;
	int number_to_move, i;
	int ret_val;

	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

	else
		{
			int num_to_read =
			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

			int yy_c_buf_p_offset =
				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					/* Include room in for 2 EOB chars. */
					yyrealloc( (void *) b->yy_ch_buf,
							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
				}
			else
				/* Can't grow it, we don't own it. */
				b->yy_ch_buf = NULL;

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
			yyg->yy_n_chars, num_to_read );

		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	if ( yyg->yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin  , yyscanner);
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
		/* Extend the array by 50%, plus the number we really need. */
		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		/* "- 2" to take care of EOB's */
		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
	}

	yyg->yy_n_chars += number_to_move;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

	return ret_val;
}

/* yy_get_previous_state - get the state just before the EOB char was reached */

    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 42);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 161 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 42;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 161 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 160);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

#ifndef YY_NO_UNPUT

#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int yyinput (yyscan_t yyscanner)
#else
    static int input  (yyscan_t yyscanner)
#endif

{
	int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	*yyg->yy_c_buf_p = yyg->yy_hold_char;

	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
			/* This was really a NUL. */
			*yyg->yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
			++yyg->yy_c_buf_p;

			switch ( yy_get_next_buffer( yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin , yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap( yyscanner ) )
						return 0;

					if ( ! yyg->yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput(yyscanner);
#else
					return input(yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
	yyg->yy_hold_char = *++yyg->yy_c_buf_p;

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param yyscanner The scanner object.
 */
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with yy_create_buffer()
 * @param yyscanner The scanner object.
 */
    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a yyrestart() or at EOF.
 */
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param yyscanner The scanner object.
 */
    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param yyscanner The scanner object.
 */
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param yyscanner The scanner object.
 */
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void yyensure_buffer_stack (yyscan_t yyscanner)
{
	yy_size_t num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if (!yyg->yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		yyg->yy_buffer_stack_max = num_to_alloc;
		yyg->yy_buffer_stack_top = 0;
		return;
	}

	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
								(yyg->yy_buffer_stack,
								num_to_alloc * sizeof(struct yy_buffer_state*)
								, yyscanner);
		if ( ! yyg->yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		yyg->yy_buffer_stack_max = num_to_alloc;
	}
}

/** Setup the input buffer state to scan directly from a user-specified character buffer.
 * @param base the character buffer
 * @param size the size in bytes of the character buffer
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b , yyscanner );

	return b;
}

/** Setup the input buffer state to scan a string. The next call to yylex() will
 * scan from a @e copy of @a str.
 * @param yystr a NUL-terminated string to scan
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 * @note If you want to scan bytes that may contain NUL values, then use
 *       yy_scan_bytes() instead.
 */
YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
    
	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 * scan from a @e copy of @a bytes.
 * @param yybytes the byte buffer to scan
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 * @param yyscanner The scanner object.
 * @return the newly allocated buffer state object.
 */
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n , yyscanner );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n , yyscanner);
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
}

/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		*yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
		} \
	while ( 0 )

/* Accessor  methods (get/set functions) to struct members. */

/** Get the user-defined data for this scanner.
 * @param yyscanner The scanner object.
 */
YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

/** Get the current line number.
 * @param yyscanner The scanner object.
 */
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

/** Get the current column number.
 * @param yyscanner The scanner object.
 */
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

/** Get the input stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_in  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

/** Get the output stream.
 * @param yyscanner The scanner object.
 */
FILE *yyget_out  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

/** Get the length of the current token.
 * @param yyscanner The scanner object.
 */
int yyget_leng  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

/** Get the current token.
 * @param yyscanner The scanner object.
 */

char *yyget_text  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

/** Set the user-defined data. This data is never touched by the scanner.
 * @param user_defined The data to be associated with this scanner.
 * @param yyscanner The scanner object.
 */
void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

/** Set the current line number.
 * @param _line_number line number
 * @param yyscanner The scanner object.
 */
void yyset_lineno (int  _line_number , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
    
    yylineno = _line_number;
}

/** Set the current column.
 * @param _column_no column number
 * @param yyscanner The scanner object.
 */
void yyset_column (int  _column_no , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           YY_FATAL_ERROR( "yyset_column called with no buffer" );
    
    yycolumn = _column_no;
}

/** Set the input stream. This does not discard the current
 * input buffer.
 * @param _in_str A readable stream.
 * @param yyscanner The scanner object.
 * @see yy_switch_to_buffer
 */
void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = _in_str ;
}

void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = _out_str ;
}

int yyget_debug  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

void yyset_debug (int  _bdebug , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = _bdebug ;
}

/* Accessor methods for yylval and yylloc */

YYSTYPE * yyget_lval  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}
    
void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}
    
/* User-visible API */

/* yylex_init is special because it creates the scanner itself, so it is
 * the ONLY reentrant function that doesn't take the scanner as the last argument.
 * That's why we explicitly handle the declaration, instead of using our macros.
 */
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

/* yylex_init_extra has the same functionality as yylex_init, but follows the
 * convention of taking the scanner as the last argument. Note however, that
 * this is a *pointer* to a scanner, as it will be allocated by this call (and
 * is the reason, too, why this function also must handle its own declaration).
 * The user defined value in the first argument will be available to yyalloc in
 * the yyextra field.
 */
int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
    struct yyguts_t dummy_yyguts;

    yyset_extra (yy_user_defined, &dummy_yyguts);

    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    yyset_extra (yy_user_defined, *ptr_yy_globals);

    return yy_init_globals ( *ptr_yy_globals );
}

static int yy_init_globals (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    yyg->yy_buffer_stack = NULL;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = NULL;
    yyg->yy_init = 0;
    yyg->yy_start = 0;

    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = NULL;
    yyout = NULL;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state(yyscanner);
	}

	/* Destroy the stack itself. */
	yyfree(yyg->yy_buffer_stack , yyscanner);
	yyg->yy_buffer_stack = NULL;

    /* Destroy the start condition stack. */
        yyfree( yyg->yy_start_stack , yyscanner );
        yyg->yy_start_stack = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);

    /* Destroy the main struct (reentrant only). */
    yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

/*
 * Internal utility routines.
 */

#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
}
#endif

void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	return malloc(size);
}

void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;

	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return realloc(ptr, size);
}

void yyfree (void * ptr , yyscan_t yyscanner)
{
	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	(void)yyg;
	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
}

#define YYTABLES_NAME "yytables"

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/pajek-lexer.h0000644000175100001710000004232700000000000025117 0ustar00runnerdocker00000000000000#ifndef igraph_pajek_yyHEADER_H
#define igraph_pajek_yyHEADER_H 1
#define igraph_pajek_yyIN_HEADER 1

#define  YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif

#ifdef yy_create_buffer
#define igraph_pajek_yy_create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer igraph_pajek_yy_create_buffer
#endif

#ifdef yy_delete_buffer
#define igraph_pajek_yy_delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer igraph_pajek_yy_delete_buffer
#endif

#ifdef yy_scan_buffer
#define igraph_pajek_yy_scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer igraph_pajek_yy_scan_buffer
#endif

#ifdef yy_scan_string
#define igraph_pajek_yy_scan_string_ALREADY_DEFINED
#else
#define yy_scan_string igraph_pajek_yy_scan_string
#endif

#ifdef yy_scan_bytes
#define igraph_pajek_yy_scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes igraph_pajek_yy_scan_bytes
#endif

#ifdef yy_init_buffer
#define igraph_pajek_yy_init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer igraph_pajek_yy_init_buffer
#endif

#ifdef yy_flush_buffer
#define igraph_pajek_yy_flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer igraph_pajek_yy_flush_buffer
#endif

#ifdef yy_load_buffer_state
#define igraph_pajek_yy_load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state igraph_pajek_yy_load_buffer_state
#endif

#ifdef yy_switch_to_buffer
#define igraph_pajek_yy_switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer igraph_pajek_yy_switch_to_buffer
#endif

#ifdef yypush_buffer_state
#define igraph_pajek_yypush_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state igraph_pajek_yypush_buffer_state
#endif

#ifdef yypop_buffer_state
#define igraph_pajek_yypop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state igraph_pajek_yypop_buffer_state
#endif

#ifdef yyensure_buffer_stack
#define igraph_pajek_yyensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack igraph_pajek_yyensure_buffer_stack
#endif

#ifdef yylex
#define igraph_pajek_yylex_ALREADY_DEFINED
#else
#define yylex igraph_pajek_yylex
#endif

#ifdef yyrestart
#define igraph_pajek_yyrestart_ALREADY_DEFINED
#else
#define yyrestart igraph_pajek_yyrestart
#endif

#ifdef yylex_init
#define igraph_pajek_yylex_init_ALREADY_DEFINED
#else
#define yylex_init igraph_pajek_yylex_init
#endif

#ifdef yylex_init_extra
#define igraph_pajek_yylex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra igraph_pajek_yylex_init_extra
#endif

#ifdef yylex_destroy
#define igraph_pajek_yylex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy igraph_pajek_yylex_destroy
#endif

#ifdef yyget_debug
#define igraph_pajek_yyget_debug_ALREADY_DEFINED
#else
#define yyget_debug igraph_pajek_yyget_debug
#endif

#ifdef yyset_debug
#define igraph_pajek_yyset_debug_ALREADY_DEFINED
#else
#define yyset_debug igraph_pajek_yyset_debug
#endif

#ifdef yyget_extra
#define igraph_pajek_yyget_extra_ALREADY_DEFINED
#else
#define yyget_extra igraph_pajek_yyget_extra
#endif

#ifdef yyset_extra
#define igraph_pajek_yyset_extra_ALREADY_DEFINED
#else
#define yyset_extra igraph_pajek_yyset_extra
#endif

#ifdef yyget_in
#define igraph_pajek_yyget_in_ALREADY_DEFINED
#else
#define yyget_in igraph_pajek_yyget_in
#endif

#ifdef yyset_in
#define igraph_pajek_yyset_in_ALREADY_DEFINED
#else
#define yyset_in igraph_pajek_yyset_in
#endif

#ifdef yyget_out
#define igraph_pajek_yyget_out_ALREADY_DEFINED
#else
#define yyget_out igraph_pajek_yyget_out
#endif

#ifdef yyset_out
#define igraph_pajek_yyset_out_ALREADY_DEFINED
#else
#define yyset_out igraph_pajek_yyset_out
#endif

#ifdef yyget_leng
#define igraph_pajek_yyget_leng_ALREADY_DEFINED
#else
#define yyget_leng igraph_pajek_yyget_leng
#endif

#ifdef yyget_text
#define igraph_pajek_yyget_text_ALREADY_DEFINED
#else
#define yyget_text igraph_pajek_yyget_text
#endif

#ifdef yyget_lineno
#define igraph_pajek_yyget_lineno_ALREADY_DEFINED
#else
#define yyget_lineno igraph_pajek_yyget_lineno
#endif

#ifdef yyset_lineno
#define igraph_pajek_yyset_lineno_ALREADY_DEFINED
#else
#define yyset_lineno igraph_pajek_yyset_lineno
#endif

#ifdef yyget_column
#define igraph_pajek_yyget_column_ALREADY_DEFINED
#else
#define yyget_column igraph_pajek_yyget_column
#endif

#ifdef yyset_column
#define igraph_pajek_yyset_column_ALREADY_DEFINED
#else
#define yyset_column igraph_pajek_yyset_column
#endif

#ifdef yywrap
#define igraph_pajek_yywrap_ALREADY_DEFINED
#else
#define yywrap igraph_pajek_yywrap
#endif

#ifdef yyget_lval
#define igraph_pajek_yyget_lval_ALREADY_DEFINED
#else
#define yyget_lval igraph_pajek_yyget_lval
#endif

#ifdef yyset_lval
#define igraph_pajek_yyset_lval_ALREADY_DEFINED
#else
#define yyset_lval igraph_pajek_yyset_lval
#endif

#ifdef yyget_lloc
#define igraph_pajek_yyget_lloc_ALREADY_DEFINED
#else
#define yyget_lloc igraph_pajek_yyget_lloc
#endif

#ifdef yyset_lloc
#define igraph_pajek_yyset_lloc_ALREADY_DEFINED
#else
#define yyset_lloc igraph_pajek_yyset_lloc
#endif

#ifdef yyalloc
#define igraph_pajek_yyalloc_ALREADY_DEFINED
#else
#define yyalloc igraph_pajek_yyalloc
#endif

#ifdef yyrealloc
#define igraph_pajek_yyrealloc_ALREADY_DEFINED
#else
#define yyrealloc igraph_pajek_yyrealloc
#endif

#ifdef yyfree
#define igraph_pajek_yyfree_ALREADY_DEFINED
#else
#define yyfree igraph_pajek_yyfree
#endif

/* First, we deal with  platform-specific or compiler-specific issues. */

/* begin standard C headers. */
#include 
#include 
#include 
#include 

/* end standard C headers. */

/* flex integer type definitions */

#ifndef FLEXINT_H
#define FLEXINT_H

/* C99 systems have . Non-C99 systems may or may not. */

#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 * if you want the limit (max/min) macros for int types. 
 */
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif

#include 
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t; 
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;

/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN               (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN              (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN              (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX               (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX              (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX              (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX              (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX             (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX             (4294967295U)
#endif

#ifndef SIZE_MAX
#define SIZE_MAX               (~(size_t)0)
#endif

#endif /* ! C99 */

#endif /* ! FLEXINT_H */

/* begin standard C++ headers. */

/* TODO: this is always defined, so inline it */
#define yyconst const

#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif

/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif

/* For convenience, these vars (plus the bison vars far below)
   are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r

/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 * Ditto for the __ia64__ case accordingly.
 */
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif

#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether we "own" the buffer - i.e., we know we created it,
	 * and can realloc() it to grow it, and should free() it to
	 * delete it.
	 */
	int yy_is_our_buffer;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int yy_is_interactive;

	/* Whether we're considered to be at the beginning of a line.
	 * If so, '^' rules will be active on the next match, otherwise
	 * not.
	 */
	int yy_at_bol;

    int yy_bs_lineno; /**< The line count. */
    int yy_bs_column; /**< The column count. */

	/* Whether to try to fill the input buffer when we reach the
	 * end of it.
	 */
	int yy_fill_buffer;

	int yy_buffer_status;

	};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */

void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );

YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );

void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );

/* Begin user sect3 */

#define igraph_pajek_yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP

#define yytext_ptr yytext_r

#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0

#endif

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include 
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

int yylex_init (yyscan_t* scanner);

int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);

/* Accessor methods to globals.
   These are made visible to non-reentrant scanners for convenience. */

int yylex_destroy ( yyscan_t yyscanner );

int yyget_debug ( yyscan_t yyscanner );

void yyset_debug ( int debug_flag , yyscan_t yyscanner );

YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );

void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );

FILE *yyget_in ( yyscan_t yyscanner );

void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );

FILE *yyget_out ( yyscan_t yyscanner );

void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );

			int yyget_leng ( yyscan_t yyscanner );

char *yyget_text ( yyscan_t yyscanner );

int yyget_lineno ( yyscan_t yyscanner );

void yyset_lineno ( int _line_number , yyscan_t yyscanner );

int yyget_column  ( yyscan_t yyscanner );

void yyset_column ( int _column_no , yyscan_t yyscanner );

YYSTYPE * yyget_lval ( yyscan_t yyscanner );

void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );

       YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
    
        void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
    
/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif

#ifndef YY_NO_INPUT

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);

#define YY_DECL int yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
#endif /* !YY_DECL */

/* yy_get_previous_state - get the state just before the EOB char was reached */

#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION

#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif

#ifndef igraph_pajek_yy_create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef igraph_pajek_yy_delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef igraph_pajek_yy_scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef igraph_pajek_yy_scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef igraph_pajek_yy_scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef igraph_pajek_yy_init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef igraph_pajek_yy_flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef igraph_pajek_yy_load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef igraph_pajek_yy_switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef igraph_pajek_yypush_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef igraph_pajek_yypop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef igraph_pajek_yyensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef igraph_pajek_yylex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef igraph_pajek_yyrestart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef igraph_pajek_yylex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef igraph_pajek_yylex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef igraph_pajek_yylex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef igraph_pajek_yyget_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef igraph_pajek_yyset_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef igraph_pajek_yyget_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef igraph_pajek_yyset_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef igraph_pajek_yyget_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef igraph_pajek_yyset_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef igraph_pajek_yyget_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef igraph_pajek_yyset_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef igraph_pajek_yyget_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef igraph_pajek_yyget_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef igraph_pajek_yyget_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef igraph_pajek_yyset_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef igraph_pajek_yyget_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef igraph_pajek_yyset_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef igraph_pajek_yywrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef igraph_pajek_yyget_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef igraph_pajek_yyset_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef igraph_pajek_yyget_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef igraph_pajek_yyset_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef igraph_pajek_yyalloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef igraph_pajek_yyrealloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef igraph_pajek_yyfree_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef igraph_pajek_yytext_ALREADY_DEFINED
#undef yytext
#endif
#ifndef igraph_pajek_yyleng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef igraph_pajek_yyin_ALREADY_DEFINED
#undef yyin
#endif
#ifndef igraph_pajek_yyout_ALREADY_DEFINED
#undef yyout
#endif
#ifndef igraph_pajek_yy_flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef igraph_pajek_yylineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef igraph_pajek_yytables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef igraph_pajek_yytables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef igraph_pajek_yyTABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif

#undef igraph_pajek_yyIN_HEADER
#endif /* igraph_pajek_yyHEADER_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/pajek-parser.c0000644000175100001710000026300500000000000025265 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */
#define YYBISON 1

/* Bison version.  */
#define YYBISON_VERSION "3.5.1"

/* Skeleton name.  */
#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define YYPURE 1

/* Push parsers.  */
#define YYPUSH 0

/* Pull parsers.  */
#define YYPULL 1


/* Substitute the variable and function names.  */
#define yyparse         igraph_pajek_yyparse
#define yylex           igraph_pajek_yylex
#define yyerror         igraph_pajek_yyerror
#define yydebug         igraph_pajek_yydebug
#define yynerrs         igraph_pajek_yynerrs

/* First part of user prologue.  */


/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "igraph_types.h"
#include "igraph_memory.h"
#include "igraph_error.h"
#include "igraph_attributes.h"
#include "config.h"

#include "core/math.h"
#include "io/pajek-header.h"
#include "io/parsers/pajek-parser.h" /* it must come first because of YYSTYPE */
#include "io/parsers/pajek-lexer.h"
#include "internal/hacks.h"

int igraph_pajek_yyerror(YYLTYPE* locp,
                         igraph_i_pajek_parsedata_t *context,
                         const char *s);

int igraph_i_pajek_add_string_vertex_attribute(const char *name,
                                               const char *value,
                                               int len,
                                               igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_string_edge_attribute(const char *name,
                                             const char *value,
                                             int len,
                                             igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_vertex_attribute(const char *name,
                                                igraph_real_t value,
                                                igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_edge_attribute(const char *name,
                                              igraph_real_t value,
                                              igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_add_numeric_attribute(igraph_trie_t *names,
                                         igraph_vector_ptr_t *attrs,
                                         long int count,
                                         const char *attrname,
                                         igraph_integer_t vid,
                                         igraph_real_t number);
int igraph_i_pajek_add_string_attribute(igraph_trie_t *names,
                                        igraph_vector_ptr_t *attrs,
                                        long int count,
                                        const char *attrname,
                                        igraph_integer_t vid,
                                        const char *str);

int igraph_i_pajek_add_bipartite_type(igraph_i_pajek_parsedata_t *context);
int igraph_i_pajek_check_bipartite(igraph_i_pajek_parsedata_t *context);

extern igraph_real_t igraph_pajek_get_number(const char *str, long int len);
extern long int igraph_i_pajek_actvertex;
extern long int igraph_i_pajek_actedge;

#define scanner context->scanner



# ifndef YY_CAST
#  ifdef __cplusplus
#   define YY_CAST(Type, Val) static_cast (Val)
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val)
#  else
#   define YY_CAST(Type, Val) ((Type) (Val))
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
#  endif
# endif
# ifndef YY_NULLPTR
#  if defined __cplusplus
#   if 201103L <= __cplusplus
#    define YY_NULLPTR nullptr
#   else
#    define YY_NULLPTR 0
#   endif
#  else
#   define YY_NULLPTR ((void*)0)
#  endif
# endif

/* Enabling verbose error messages.  */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif

/* Use api.header.include to #include this header
   instead of duplicating it here.  */
#ifndef YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED
# define YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_pajek_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    NEWLINE = 258,
    NUM = 259,
    ALNUM = 260,
    QSTR = 261,
    PSTR = 262,
    NETWORKLINE = 263,
    VERTICESLINE = 264,
    ARCSLINE = 265,
    EDGESLINE = 266,
    ARCSLISTLINE = 267,
    EDGESLISTLINE = 268,
    MATRIXLINE = 269,
    ERROR = 270,
    VP_X_FACT = 271,
    VP_Y_FACT = 272,
    VP_IC = 273,
    VP_BC = 274,
    VP_LC = 275,
    VP_LR = 276,
    VP_LPHI = 277,
    VP_BW = 278,
    VP_FOS = 279,
    VP_PHI = 280,
    VP_R = 281,
    VP_Q = 282,
    VP_LA = 283,
    VP_FONT = 284,
    VP_URL = 285,
    VP_SIZE = 286,
    EP_C = 287,
    EP_S = 288,
    EP_A = 289,
    EP_W = 290,
    EP_H1 = 291,
    EP_H2 = 292,
    EP_A1 = 293,
    EP_A2 = 294,
    EP_K1 = 295,
    EP_K2 = 296,
    EP_AP = 297,
    EP_P = 298,
    EP_L = 299,
    EP_LP = 300,
    EP_LR = 301,
    EP_LPHI = 302,
    EP_LC = 303,
    EP_LA = 304,
    EP_SIZE = 305,
    EP_FOS = 306
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int intnum;
  double   realnum;
  struct {
    char *str;
    int len;
  } string;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_pajek_yyparse (igraph_i_pajek_parsedata_t* context);

#endif /* !YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED  */



#ifdef short
# undef short
#endif

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
    and (if available)  are included
   so that the code can choose integer types of a good width.  */

#ifndef __PTRDIFF_MAX__
# include  /* INFRINGES ON USER NAME SPACE */
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YY_STDINT_H
# endif
#endif

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

#ifdef __INT_LEAST8_MAX__
typedef __INT_LEAST8_TYPE__ yytype_int8;
#elif defined YY_STDINT_H
typedef int_least8_t yytype_int8;
#else
typedef signed char yytype_int8;
#endif

#ifdef __INT_LEAST16_MAX__
typedef __INT_LEAST16_TYPE__ yytype_int16;
#elif defined YY_STDINT_H
typedef int_least16_t yytype_int16;
#else
typedef short yytype_int16;
#endif

#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST8_MAX <= INT_MAX)
typedef uint_least8_t yytype_uint8;
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
typedef unsigned char yytype_uint8;
#else
typedef short yytype_uint8;
#endif

#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
       && UINT_LEAST16_MAX <= INT_MAX)
typedef uint_least16_t yytype_uint16;
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
typedef unsigned short yytype_uint16;
#else
typedef int yytype_uint16;
#endif

#ifndef YYPTRDIFF_T
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
# elif defined PTRDIFF_MAX
#  ifndef ptrdiff_t
#   include  /* INFRINGES ON USER NAME SPACE */
#  endif
#  define YYPTRDIFF_T ptrdiff_t
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
# else
#  define YYPTRDIFF_T long
#  define YYPTRDIFF_MAXIMUM LONG_MAX
# endif
#endif

#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
#  define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
#  define YYSIZE_T size_t
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# else
#  define YYSIZE_T unsigned
# endif
#endif

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))

/* Stored state numbers (used for stacks). */
typedef yytype_uint8 yy_state_t;

/* State numbers in computations.  */
typedef int yy_state_fast_t;

#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
#  if ENABLE_NLS
#   include  /* INFRINGES ON USER NAME SPACE */
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
#  endif
# endif
# ifndef YY_
#  define YY_(Msgid) Msgid
# endif
#endif

#ifndef YY_ATTRIBUTE_PURE
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define YY_ATTRIBUTE_PURE
# endif
#endif

#ifndef YY_ATTRIBUTE_UNUSED
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
# else
#  define YY_ATTRIBUTE_UNUSED
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif

#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
    _Pragma ("GCC diagnostic push")                                     \
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
    _Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif

#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
    _Pragma ("GCC diagnostic push")                            \
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
# define YY_IGNORE_USELESS_CAST_END            \
    _Pragma ("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_BEGIN
# define YY_IGNORE_USELESS_CAST_END
#endif


#define YY_ASSERT(E) ((void) (0 && (E)))

#if ! defined yyoverflow || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef YYSTACK_USE_ALLOCA
#  if YYSTACK_USE_ALLOCA
#   ifdef __GNUC__
#    define YYSTACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include  /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define YYSTACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include  /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define YYSTACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
#     include  /* INFRINGES ON USER NAME SPACE */
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
#     ifndef EXIT_SUCCESS
#      define EXIT_SUCCESS 0
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's 'empty if-body' warning.  */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
#  ifndef YYSTACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define YYSTACK_ALLOC YYMALLOC
#  define YYSTACK_FREE YYFREE
#  ifndef YYSTACK_ALLOC_MAXIMUM
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
       && ! ((defined YYMALLOC || defined malloc) \
             && (defined YYFREE || defined free)))
#   include  /* INFRINGES ON USER NAME SPACE */
#   ifndef EXIT_SUCCESS
#    define EXIT_SUCCESS 0
#   endif
#  endif
#  ifndef YYMALLOC
#   define YYMALLOC malloc
#   if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef YYFREE
#   define YYFREE free
#   if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */


#if (! defined yyoverflow \
     && (! defined __cplusplus \
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  yy_state_t yyss_alloc;
  YYSTYPE yyvs_alloc;
  YYLTYPE yyls_alloc;
};

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
             + YYSIZEOF (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

# define YYCOPY_NEEDED 1

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

#endif

#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(Dst, Src, Count) \
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
#  else
#   define YYCOPY(Dst, Src, Count)              \
      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)
#  endif
# endif
#endif /* !YYCOPY_NEEDED */

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  5
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   250

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  52
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  66
/* YYNRULES -- Number of rules.  */
#define YYNRULES  137
/* YYNSTATES -- Number of states.  */
#define YYNSTATES  207

#define YYUNDEFTOK  2
#define YYMAXUTOK   306


/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */
#define YYTRANSLATE(YYX)                                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex.  */
static const yytype_int8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
      45,    46,    47,    48,    49,    50,    51
};

#if YYDEBUG
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
static const yytype_int16 yyrline[] =
{
       0,   189,   189,   193,   193,   195,   197,   201,   207,   207,
     209,   210,   211,   211,   214,   216,   221,   222,   226,   232,
     232,   236,   236,   239,   240,   243,   246,   251,   256,   261,
     264,   267,   270,   273,   276,   279,   282,   285,   290,   290,
     294,   294,   298,   298,   302,   302,   307,   307,   314,   316,
     316,   316,   316,   316,   316,   318,   319,   321,   321,   323,
     324,   324,   330,   332,   334,   335,   337,   337,   339,   340,
     340,   346,   348,   350,   350,   354,   354,   357,   358,   363,
     366,   369,   372,   375,   378,   381,   384,   387,   390,   393,
     396,   399,   402,   405,   410,   410,   414,   414,   418,   418,
     422,   422,   426,   426,   432,   434,   436,   436,   438,   438,
     440,   440,   442,   444,   449,   451,   451,   453,   453,   455,
     455,   457,   459,   466,   468,   473,   473,   475,   477,   477,
     479,   499,   502,   505,   505,   507,   509,   511
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "NEWLINE", "NUM", "ALNUM", "QSTR",
  "PSTR", "NETWORKLINE", "VERTICESLINE", "ARCSLINE", "EDGESLINE",
  "ARCSLISTLINE", "EDGESLISTLINE", "MATRIXLINE", "ERROR", "VP_X_FACT",
  "VP_Y_FACT", "VP_IC", "VP_BC", "VP_LC", "VP_LR", "VP_LPHI", "VP_BW",
  "VP_FOS", "VP_PHI", "VP_R", "VP_Q", "VP_LA", "VP_FONT", "VP_URL",
  "VP_SIZE", "EP_C", "EP_S", "EP_A", "EP_W", "EP_H1", "EP_H2", "EP_A1",
  "EP_A2", "EP_K1", "EP_K2", "EP_AP", "EP_P", "EP_L", "EP_LP", "EP_LR",
  "EP_LPHI", "EP_LC", "EP_LA", "EP_SIZE", "EP_FOS", "$accept", "input",
  "nethead", "vertices", "verticeshead", "vertdefs", "vertexline", "$@1",
  "vertex", "vertexid", "vertexcoords", "shape", "params", "param",
  "vpword", "$@2", "$@3", "$@4", "$@5", "$@6", "vpwordpar", "edgeblock",
  "arcs", "arcsdefs", "arcsline", "$@7", "arcfrom", "arcto", "edges",
  "edgesdefs", "edgesline", "$@8", "edgefrom", "edgeto", "weight",
  "edgeparams", "edgeparam", "epword", "$@9", "$@10", "$@11", "$@12",
  "$@13", "epwordpar", "arcslist", "arcslistlines", "arclistline",
  "arctolist", "arclistfrom", "arclistto", "edgeslist", "edgelistlines",
  "edgelistline", "edgetolist", "edgelistfrom", "edgelistto", "adjmatrix",
  "matrixline", "adjmatrixlines", "adjmatrixline", "adjmatrixnumbers",
  "adjmatrixentry", "longint", "number", "words", "word", YY_NULLPTR
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
   (internal) symbol number NUM (which must be that of a token).  */
static const yytype_int16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
     305,   306
};
# endif

#define YYPACT_NINF (-167)

#define yypact_value_is_default(Yyn) \
  ((Yyn) == YYPACT_NINF)

#define YYTABLE_NINF (-129)

#define yytable_value_is_error(Yyn) \
  0

  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     STATE-NUM.  */
static const yytype_int16 yypact[] =
{
      -4,  -167,     7,    36,    22,  -167,    44,  -167,    49,  -167,
    -167,  -167,  -167,  -167,  -167,    44,    10,  -167,  -167,    12,
      27,    51,    56,  -167,  -167,  -167,  -167,  -167,  -167,    58,
      29,  -167,  -167,    59,  -167,    60,  -167,  -167,  -167,  -167,
    -167,    61,  -167,    31,  -167,    33,  -167,    35,    37,    39,
    -167,     5,  -167,  -167,    44,  -167,    31,  -167,  -167,    44,
    -167,    33,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
    -167,    62,    65,  -167,    65,  -167,  -167,  -167,  -167,  -167,
      47,    53,  -167,  -167,     5,    65,    65,    65,  -167,  -167,
    -167,  -167,  -167,  -167,  -167,  -167,    65,  -167,  -167,  -167,
     219,  -167,   150,   170,  -167,    65,    65,    65,    65,    65,
      65,    65,    65,    65,    65,    65,    65,    65,  -167,  -167,
      65,  -167,  -167,  -167,    65,    65,  -167,    65,    65,    65,
      65,    65,    65,    65,    65,  -167,  -167,    65,    65,    65,
    -167,    65,    65,    65,  -167,  -167,  -167,  -167,  -167,     5,
      65,     5,    65,     5,    65,  -167,  -167,  -167,  -167,  -167,
    -167,  -167,  -167,     5,     5,  -167,     5,    65,  -167,     5,
    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,     5,     5,
    -167,  -167,  -167,     5,  -167,  -167,  -167,  -167,  -167,    65,
    -167,    65,  -167,    65,  -167,  -167,  -167,  -167,    65,  -167,
    -167,  -167,  -167,  -167,  -167,  -167,  -167
};

  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     Performed when YYTABLE does not specify something else to do.  Zero
     means the default is an error.  */
static const yytype_uint8 yydefact[] =
{
       3,   133,     0,     0,     0,     1,     0,    49,     0,     4,
     136,   135,   137,   134,   131,     6,     2,     8,     7,     0,
       0,     0,     0,   124,    50,    51,    52,    53,    54,     0,
       5,    57,   132,     0,    66,     0,   106,   115,   125,    10,
       9,    12,    14,    55,    57,    64,    66,   105,   114,   123,
      11,     0,    59,    58,     0,    62,    56,    68,    67,     0,
      71,    65,   108,   107,   110,   112,   117,   116,   119,   121,
     126,     0,   128,   130,    16,    15,    60,    63,    69,    72,
       0,     0,   127,   129,    19,     0,    73,    73,   109,   111,
     113,   118,   120,   122,    21,    20,    17,    75,    74,    75,
       0,    18,     0,     0,    13,     0,     0,    42,    44,    46,
       0,     0,     0,     0,     0,     0,     0,     0,    38,    40,
       0,    22,    23,    61,   102,     0,    94,     0,     0,     0,
       0,     0,     0,     0,     0,    96,    98,     0,     0,     0,
     100,     0,     0,     0,    76,    77,    70,    24,    25,     0,
       0,     0,     0,     0,     0,    29,    30,    31,    32,    33,
      34,    35,    36,     0,     0,    37,     0,     0,    79,     0,
      80,    81,    82,    83,    84,    85,    86,    87,     0,     0,
      88,    89,    90,     0,    91,    92,    93,    43,    48,     0,
      45,     0,    47,     0,    39,    41,   103,   104,     0,    95,
      97,    99,   101,    26,    27,    28,    78
};

  /* YYPGOTO[NTERM-NUM].  */
static const yytype_int16 yypgoto[] =
{
    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
    -145,  -167,  -167,    26,  -167,  -167,  -167,  -167,  -167,    25,
    -167,  -167,  -167,  -167,   -15,   -26,  -167,  -167,  -167,  -167,
    -167,  -167,  -167,  -166,  -167,  -167,  -167,  -167,  -167,  -167,
    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
       2,  -167,    -1,   -19,  -167,    -2
};

  /* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int16 yydefgoto[] =
{
      -1,     2,     3,     7,     8,    30,    40,    51,    41,    74,
      84,    94,   100,   121,   122,   163,   164,   149,   151,   153,
     187,    16,    24,    43,    53,    86,    54,    76,    25,    45,
      58,    87,    59,    78,    97,   102,   144,   145,   169,   178,
     179,   183,   166,   196,    26,    47,    63,    80,    64,    89,
      27,    48,    67,    81,    68,    92,    28,    29,    49,    70,
      71,    72,    55,    73,     4,   188
};

  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     positive, shift that token.  If negative, reduce the rule whose
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
static const yytype_int16 yytable[] =
{
      33,    35,    13,   199,     1,    15,   190,     5,   192,    10,
      11,    12,   200,   201,    18,    31,    32,   202,   194,   195,
      19,    20,    21,    22,    23,     9,    10,    11,    12,    42,
      34,    32,    39,    14,    52,    14,    57,    14,    62,    14,
      66,    14,  -128,    32,    60,     6,    65,    69,    14,    75,
      88,    14,    17,    77,    36,    85,    91,    14,    79,    37,
      60,    38,    44,    46,    50,    82,    96,    98,    98,    32,
      56,    61,    99,   103,    83,     0,     0,   101,     0,    90,
      93,     0,    95,     0,     0,     0,   147,   148,   150,   152,
     154,   155,   156,   157,   158,   159,   160,   161,   162,     0,
       0,   165,     0,     0,     0,   167,   168,     0,   170,   171,
     172,   173,   174,   175,   176,   177,     0,     0,   180,   181,
     182,     0,   184,   185,   186,     0,     0,     0,     0,     0,
       0,   189,     0,   191,     0,   193,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,   198,     0,
       0,     0,     0,   123,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,   197,     0,     0,   197,     0,     0,
     203,     0,   204,   146,   205,     0,   197,   197,     0,   206,
       0,   197,   124,   125,   126,   127,   128,   129,   130,   131,
     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
     142,   143,   124,   125,   126,   127,   128,   129,   130,   131,
     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
     142,   143,   104,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,   105,   106,   107,   108,   109,
     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
     120
};

static const yytype_int16 yycheck[] =
{
      19,    20,     4,   169,     8,     6,   151,     0,   153,     4,
       5,     6,   178,   179,    15,     3,     4,   183,   163,   164,
      10,    11,    12,    13,    14,     3,     4,     5,     6,    30,
       3,     4,     3,     4,     3,     4,     3,     4,     3,     4,
       3,     4,     3,     4,    45,     9,    47,    48,     4,    51,
       3,     4,     3,    54,     3,    74,     3,     4,    59,     3,
      61,     3,     3,     3,     3,     3,    85,    86,    87,     4,
      44,    46,    87,    99,    72,    -1,    -1,    96,    -1,    80,
      81,    -1,    84,    -1,    -1,    -1,   105,   106,   107,   108,
     109,   110,   111,   112,   113,   114,   115,   116,   117,    -1,
      -1,   120,    -1,    -1,    -1,   124,   125,    -1,   127,   128,
     129,   130,   131,   132,   133,   134,    -1,    -1,   137,   138,
     139,    -1,   141,   142,   143,    -1,    -1,    -1,    -1,    -1,
      -1,   150,    -1,   152,    -1,   154,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   167,    -1,
      -1,    -1,    -1,     3,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,   166,    -1,    -1,   169,    -1,    -1,
     189,    -1,   191,     3,   193,    -1,   178,   179,    -1,   198,
      -1,   183,    32,    33,    34,    35,    36,    37,    38,    39,
      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
      50,    51,    32,    33,    34,    35,    36,    37,    38,    39,
      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
      50,    51,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,
      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
      31
};

  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     symbol of state STATE-NUM.  */
static const yytype_int8 yystos[] =
{
       0,     8,    53,    54,   116,     0,     9,    55,    56,     3,
       4,     5,     6,   117,     4,   114,    73,     3,   114,    10,
      11,    12,    13,    14,    74,    80,    96,   102,   108,   109,
      57,     3,     4,   115,     3,   115,     3,     3,     3,     3,
      58,    60,   114,    75,     3,    81,     3,    97,   103,   110,
       3,    59,     3,    76,    78,   114,    75,     3,    82,    84,
     114,    81,     3,    98,   100,   114,     3,   104,   106,   114,
     111,   112,   113,   115,    61,   117,    79,   114,    85,   114,
      99,   105,     3,   112,    62,   115,    77,    83,     3,   101,
     114,     3,   107,   114,    63,   117,   115,    86,   115,    86,
      64,   115,    87,    87,     3,    16,    17,    18,    19,    20,
      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
      31,    65,    66,     3,    32,    33,    34,    35,    36,    37,
      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
      48,    49,    50,    51,    88,    89,     3,   115,   115,    69,
     115,    70,   115,    71,   115,   115,   115,   115,   115,   115,
     115,   115,   115,    67,    68,   115,    94,   115,   115,    90,
     115,   115,   115,   115,   115,   115,   115,   115,    91,    92,
     115,   115,   115,    93,   115,   115,   115,    72,   117,   115,
      72,   115,    72,   115,    72,    72,    95,   117,   115,    95,
      95,    95,    95,   115,   115,   115,   115
};

  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_int8 yyr1[] =
{
       0,    52,    53,    54,    54,    55,    56,    56,    57,    57,
      58,    58,    59,    58,    60,    61,    62,    62,    62,    63,
      63,    64,    64,    65,    65,    65,    65,    65,    65,    65,
      65,    65,    65,    65,    65,    65,    65,    65,    67,    66,
      68,    66,    69,    66,    70,    66,    71,    66,    72,    73,
      73,    73,    73,    73,    73,    74,    74,    75,    75,    76,
      77,    76,    78,    79,    80,    80,    81,    81,    82,    83,
      82,    84,    85,    86,    86,    87,    87,    88,    88,    88,
      88,    88,    88,    88,    88,    88,    88,    88,    88,    88,
      88,    88,    88,    88,    90,    89,    91,    89,    92,    89,
      93,    89,    94,    89,    95,    96,    97,    97,    98,    98,
      99,    99,   100,   101,   102,   103,   103,   104,   104,   105,
     105,   106,   107,   108,   109,   110,   110,   111,   112,   112,
     113,   114,   115,   116,   116,   117,   117,   117
};

  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
static const yytype_int8 yyr2[] =
{
       0,     2,     3,     0,     3,     3,     2,     3,     0,     2,
       1,     2,     0,     7,     1,     1,     0,     2,     3,     0,
       1,     0,     2,     1,     2,     2,     4,     4,     4,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     0,     3,
       0,     3,     0,     3,     0,     3,     0,     3,     1,     0,
       2,     2,     2,     2,     2,     3,     4,     0,     2,     1,
       0,     6,     1,     1,     3,     4,     0,     2,     1,     0,
       6,     1,     1,     0,     1,     0,     2,     1,     4,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     0,     3,     0,     3,     0,     3,
       0,     3,     0,     3,     1,     3,     0,     2,     1,     3,
       0,     2,     1,     1,     3,     0,     2,     1,     3,     0,
       2,     1,     1,     3,     1,     0,     2,     2,     0,     2,
       1,     1,     1,     0,     2,     1,     1,     1
};


#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         (-2)
#define YYEOF           0

#define YYACCEPT        goto yyacceptlab
#define YYABORT         goto yyabortlab
#define YYERROR         goto yyerrorlab


#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

/* Error token number */
#define YYTERROR        1
#define YYERRCODE       256


/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    do                                                                  \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)
#endif

#define YYRHSLOC(Rhs, K) ((Rhs)[K])


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include  /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)                        \
do {                                            \
  if (yydebug)                                  \
    YYFPRINTF Args;                             \
} while (0)


/* YY_LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL

/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */

YY_ATTRIBUTE_UNUSED
static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
  int res = 0;
  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
  if (0 <= yylocp->first_line)
    {
      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
      if (0 <= yylocp->first_column)
        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
    }
  if (0 <= yylocp->last_line)
    {
      if (yylocp->first_line < yylocp->last_line)
        {
          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
          if (0 <= end_col)
            res += YYFPRINTF (yyo, ".%d", end_col);
        }
      else if (0 <= end_col && yylocp->first_column < end_col)
        res += YYFPRINTF (yyo, "-%d", end_col);
    }
  return res;
 }

#  define YY_LOCATION_PRINT(File, Loc)          \
  yy_location_print_ (File, &(Loc))

# else
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
do {                                                                      \
  if (yydebug)                                                            \
    {                                                                     \
      YYFPRINTF (stderr, "%s ", Title);                                   \
      yy_symbol_print (stderr,                                            \
                  Type, Value, Location, context); \
      YYFPRINTF (stderr, "\n");                                           \
    }                                                                     \
} while (0)


/*-----------------------------------.
| Print this symbol's value on YYO.  |
`-----------------------------------*/

static void
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_pajek_parsedata_t* context)
{
  FILE *yyoutput = yyo;
  YYUSE (yyoutput);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yyvaluep)
    return;
# ifdef YYPRINT
  if (yytype < YYNTOKENS)
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
# endif
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}


/*---------------------------.
| Print this symbol on YYO.  |
`---------------------------*/

static void
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, igraph_i_pajek_parsedata_t* context)
{
  YYFPRINTF (yyo, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  YY_LOCATION_PRINT (yyo, *yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, context);
  YYFPRINTF (yyo, ")");
}

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)                            \
do {                                                            \
  if (yydebug)                                                  \
    yy_stack_print ((Bottom), (Top));                           \
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, igraph_i_pajek_parsedata_t* context)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[+yyssp[yyi + 1 - yynrhs]],
                       &yyvsp[(yyi + 1) - (yynrhs)]
                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , context);
      YYFPRINTF (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)          \
do {                                    \
  if (yydebug)                          \
    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif


#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
#  else
/* Return the length of YYSTR.  */
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif

# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}
# endif

/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
static int
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
                yy_state_t *yyssp, int yytoken)
{
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
     one per "expected"). */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Actual size of YYARG. */
  int yycount = 0;
  /* Cumulated lengths of YYARG.  */
  YYPTRDIFF_T yysize = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[+*yyssp];
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
      yysize = yysize0;
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYPTRDIFF_T yysize1
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                    yysize = yysize1;
                  else
                    return 2;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
    default: /* Avoid compiler warnings. */
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    /* Don't count the "%s"s in the final size, but reserve room for
       the terminator.  */
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
      yysize = yysize1;
    else
      return 2;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          ++yyp;
          ++yyformat;
        }
  }
  return 0;
}
#endif /* YYERROR_VERBOSE */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, igraph_i_pajek_parsedata_t* context)
{
  YYUSE (yyvaluep);
  YYUSE (yylocationp);
  YYUSE (context);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YYUSE (yytype);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}




/*----------.
| yyparse.  |
`----------*/

int
yyparse (igraph_i_pajek_parsedata_t* context)
{
/* The lookahead symbol.  */
int yychar;


/* The semantic value of the lookahead symbol.  */
/* Default value used for initialization, for pacifying older GCCs
   or non-GCC compilers.  */
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);

/* Location data for the lookahead symbol.  */
static YYLTYPE yyloc_default
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
  = { 1, 1, 1, 1 }
# endif
;
YYLTYPE yylloc = yyloc_default;

    /* Number of syntax errors so far.  */
    int yynerrs;

    yy_state_fast_t yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       'yyss': related to states.
       'yyvs': related to semantic values.
       'yyls': related to locations.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss;
    yy_state_t *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    /* The location stack.  */
    YYLTYPE yylsa[YYINITDEPTH];
    YYLTYPE *yyls;
    YYLTYPE *yylsp;

    /* The locations where the error started and ended.  */
    YYLTYPE yyerror_range[3];

    YYPTRDIFF_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yylsp = yyls = yylsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  yylsp[0] = yylloc;
  goto yysetstate;


/*------------------------------------------------------------.
| yynewstate -- push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;


/*--------------------------------------------------------------------.
| yysetstate -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END

  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    goto yyexhaustedlab;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;

# if defined yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
        YYLTYPE *yyls1 = yyls;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yyls1, yysize * YYSIZEOF (*yylsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
        yyls = yyls1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
        YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
      yylsp = yyls + yysize - 1;

      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:
  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = yylex (&yylval, &yylloc, scanner);
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
  *++yylsp = yylloc;

  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     '$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  yyerror_range[1] = yyloc;
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
  case 2:
                                  {
  if (context->vcount2 > 0) { igraph_i_pajek_check_bipartite(context); }
 }
    break;

  case 6:
                                   {
  context->vcount=(yyvsp[0].intnum);
  context->vcount2=0;
            }
    break;

  case 7:
                                           {
  context->vcount=(yyvsp[-1].intnum);
  context->vcount2=(yyvsp[0].intnum);
  igraph_i_pajek_add_bipartite_type(context);
}
    break;

  case 12:
                   { context->actvertex=(yyvsp[0].intnum); }
    break;

  case 13:
                                                                                         { }
    break;

  case 14:
                { (yyval.intnum)=(yyvsp[0].intnum); context->mode=1; }
    break;

  case 15:
               {
  igraph_i_pajek_add_string_vertex_attribute("id", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
  igraph_i_pajek_add_string_vertex_attribute("name", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
}
    break;

  case 17:
                            {
  igraph_i_pajek_add_numeric_vertex_attribute("x", (yyvsp[-1].realnum), context);
  igraph_i_pajek_add_numeric_vertex_attribute("y", (yyvsp[0].realnum), context);
            }
    break;

  case 18:
                                   {
  igraph_i_pajek_add_numeric_vertex_attribute("x", (yyvsp[-2].realnum), context);
  igraph_i_pajek_add_numeric_vertex_attribute("y", (yyvsp[-1].realnum), context);
  igraph_i_pajek_add_numeric_vertex_attribute("z", (yyvsp[0].realnum), context);
            }
    break;

  case 20:
                          {
  igraph_i_pajek_add_string_vertex_attribute("shape", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
}
    break;

  case 24:
                        {
         igraph_i_pajek_add_numeric_vertex_attribute("xfact", (yyvsp[0].realnum), context);
       }
    break;

  case 25:
                        {
         igraph_i_pajek_add_numeric_vertex_attribute("yfact", (yyvsp[0].realnum), context);
       }
    break;

  case 26:
                                  { /* RGB color */
         igraph_i_pajek_add_numeric_vertex_attribute("color-red", (yyvsp[-2].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("color-green", (yyvsp[-1].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("color-blue", (yyvsp[0].realnum), context);
       }
    break;

  case 27:
                                  {
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-red", (yyvsp[-2].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-green", (yyvsp[-1].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("framecolor-blue", (yyvsp[0].realnum), context);
       }
    break;

  case 28:
                                  {
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-red", (yyvsp[-2].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-green", (yyvsp[-1].realnum), context);
         igraph_i_pajek_add_numeric_vertex_attribute("labelcolor-blue", (yyvsp[0].realnum), context);
       }
    break;

  case 29:
                    {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldist", (yyvsp[0].realnum), context);
     }
    break;

  case 30:
                      {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldegree2", (yyvsp[0].realnum), context);
     }
    break;

  case 31:
                    {
         igraph_i_pajek_add_numeric_vertex_attribute("framewidth", (yyvsp[0].realnum), context);
     }
    break;

  case 32:
                     {
         igraph_i_pajek_add_numeric_vertex_attribute("fontsize", (yyvsp[0].realnum), context);
     }
    break;

  case 33:
                     {
         igraph_i_pajek_add_numeric_vertex_attribute("rotation", (yyvsp[0].realnum), context);
     }
    break;

  case 34:
                   {
         igraph_i_pajek_add_numeric_vertex_attribute("radius", (yyvsp[0].realnum), context);
     }
    break;

  case 35:
                   {
         igraph_i_pajek_add_numeric_vertex_attribute("diamondratio", (yyvsp[0].realnum), context);
     }
    break;

  case 36:
                    {
         igraph_i_pajek_add_numeric_vertex_attribute("labeldegree", (yyvsp[0].realnum), context);
     }
    break;

  case 37:
                      {
         igraph_i_pajek_add_numeric_vertex_attribute("vertexsize", (yyvsp[0].realnum), context);
     }
    break;

  case 38:
                { context->mode=3; }
    break;

  case 39:
                                               {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("font", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
     }
    break;

  case 40:
              { context->mode=3; }
    break;

  case 41:
                                             {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("url", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
     }
    break;

  case 42:
             { context->mode=3; }
    break;

  case 43:
                                            {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("color", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
     }
    break;

  case 44:
             { context->mode=3; }
    break;

  case 45:
                                            {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("framecolor",
                                                    (yyvsp[0].string).str, (yyvsp[0].string).len, context);
     }
    break;

  case 46:
             { context->mode=3; }
    break;

  case 47:
                                            {
         context->mode=1;
         igraph_i_pajek_add_string_vertex_attribute("labelcolor",
                                                    (yyvsp[0].string).str, (yyvsp[0].string).len, context);
     }
    break;

  case 48:
                { (yyval.string)=(yyvsp[0].string); }
    break;

  case 55:
                                         { context->directed=1; }
    break;

  case 56:
                                         { context->directed=1; }
    break;

  case 60:
                        { context->actedge++;
                          context->mode=2; }
    break;

  case 61:
                                                                        {
  igraph_vector_push_back(context->vector, (yyvsp[-5].intnum)-1);
  igraph_vector_push_back(context->vector, (yyvsp[-4].intnum)-1); }
    break;

  case 64:
                                     { context->directed=0; }
    break;

  case 65:
                                            { context->directed=0; }
    break;

  case 69:
                          { context->actedge++;
                            context->mode=2; }
    break;

  case 70:
                                                                         {
  igraph_vector_push_back(context->vector, (yyvsp[-5].intnum)-1);
  igraph_vector_push_back(context->vector, (yyvsp[-4].intnum)-1); }
    break;

  case 74:
                             {
  igraph_i_pajek_add_numeric_edge_attribute("weight", (yyvsp[0].realnum), context);
}
    break;

  case 78:
                               {
       igraph_i_pajek_add_numeric_edge_attribute("color-red", (yyvsp[-2].realnum), context);
       igraph_i_pajek_add_numeric_edge_attribute("color-green", (yyvsp[-1].realnum), context);
       igraph_i_pajek_add_numeric_edge_attribute("color-blue", (yyvsp[0].realnum), context);
   }
    break;

  case 79:
                 {
       igraph_i_pajek_add_numeric_edge_attribute("arrowsize", (yyvsp[0].realnum), context);
   }
    break;

  case 80:
                 {
       igraph_i_pajek_add_numeric_edge_attribute("edgewidth", (yyvsp[0].realnum), context);
   }
    break;

  case 81:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("hook1", (yyvsp[0].realnum), context);
   }
    break;

  case 82:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("hook2", (yyvsp[0].realnum), context);
   }
    break;

  case 83:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("angle1", (yyvsp[0].realnum), context);
   }
    break;

  case 84:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("angle2", (yyvsp[0].realnum), context);
   }
    break;

  case 85:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("velocity1", (yyvsp[0].realnum), context);
   }
    break;

  case 86:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("velocity2", (yyvsp[0].realnum), context);
   }
    break;

  case 87:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("arrowpos", (yyvsp[0].realnum), context);
   }
    break;

  case 88:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("labelpos", (yyvsp[0].realnum), context);
   }
    break;

  case 89:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("labelangle", (yyvsp[0].realnum), context);
   }
    break;

  case 90:
                    {
       igraph_i_pajek_add_numeric_edge_attribute("labelangle2", (yyvsp[0].realnum), context);
   }
    break;

  case 91:
                  {
       igraph_i_pajek_add_numeric_edge_attribute("labeldegree", (yyvsp[0].realnum), context);
   }
    break;

  case 92:
                    { /* what is this??? */
       igraph_i_pajek_add_numeric_edge_attribute("arrowsize", (yyvsp[0].realnum), context);
   }
    break;

  case 93:
                   {
       igraph_i_pajek_add_numeric_edge_attribute("fontsize", (yyvsp[0].realnum), context);
   }
    break;

  case 94:
             { context->mode=4; }
    break;

  case 95:
                                            {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("arrowtype", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
    }
    break;

  case 96:
           { context->mode=4; }
    break;

  case 97:
                                          {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("linepattern", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
    }
    break;

  case 98:
           { context->mode=4; }
    break;

  case 99:
                                          {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("label", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
    }
    break;

  case 100:
            { context->mode=4; }
    break;

  case 101:
                                           {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("labelcolor", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
    }
    break;

  case 102:
           { context->mode=4; }
    break;

  case 103:
                                          {
      context->mode=2;
      igraph_i_pajek_add_string_edge_attribute("color", (yyvsp[0].string).str, (yyvsp[0].string).len, context);
    }
    break;

  case 104:
                { context->mode=2; (yyval.string)=(yyvsp[0].string); }
    break;

  case 105:
                                             { context->directed=1; }
    break;

  case 112:
                     { context->mode=0; context->actfrom=labs((yyvsp[0].intnum))-1; }
    break;

  case 113:
                   {
  igraph_vector_push_back(context->vector, context->actfrom);
  igraph_vector_push_back(context->vector, labs((yyvsp[0].intnum))-1);
}
    break;

  case 114:
                                               { context->directed=0; }
    break;

  case 121:
                      { context->mode=0; context->actfrom=labs((yyvsp[0].intnum))-1; }
    break;

  case 122:
                    {
  igraph_vector_push_back(context->vector, context->actfrom);
  igraph_vector_push_back(context->vector, labs((yyvsp[0].intnum))-1);
}
    break;

  case 124:
                       { context->actfrom=0;
                         context->actto=0;
                         context->directed=(context->vcount2==0);
                       }
    break;

  case 127:
                                        { context->actfrom++; context->actto=0; }
    break;

  case 130:
                       {
  if ((yyvsp[0].realnum) != 0) {
    if (context->vcount2==0) {
      context->actedge++;
      igraph_i_pajek_add_numeric_edge_attribute("weight", (yyvsp[0].realnum), context);
      igraph_vector_push_back(context->vector, context->actfrom);
      igraph_vector_push_back(context->vector, context->actto);
    } else if (context->vcount2 + context->actto < context->vcount) {
      context->actedge++;
      igraph_i_pajek_add_numeric_edge_attribute("weight", (yyvsp[0].realnum), context);
      igraph_vector_push_back(context->vector, context->actfrom);
      igraph_vector_push_back(context->vector,
                              context->vcount2+context->actto);
    }
  }
  context->actto++;
}
    break;

  case 131:
             { (yyval.intnum)=igraph_pajek_get_number(igraph_pajek_yyget_text(scanner),
                                          igraph_pajek_yyget_leng(scanner)); }
    break;

  case 132:
             { (yyval.realnum)=igraph_pajek_get_number(igraph_pajek_yyget_text(scanner),
                                          igraph_pajek_yyget_leng(scanner)); }
    break;

  case 135:
            { (yyval.string).str=igraph_pajek_yyget_text(scanner);
              (yyval.string).len=igraph_pajek_yyget_leng(scanner); }
    break;

  case 136:
            { (yyval.string).str=igraph_pajek_yyget_text(scanner);
              (yyval.string).len=igraph_pajek_yyget_leng(scanner); }
    break;

  case 137:
             { (yyval.string).str=igraph_pajek_yyget_text(scanner)+1;
               (yyval.string).len=igraph_pajek_yyget_leng(scanner)-2; }
    break;



      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;
  *++yylsp = yyloc;

  /* Now 'shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }

  goto yynewstate;


/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (&yylloc, context, YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (&yylloc, context, yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }

  yyerror_range[1] = yylloc;

  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval, &yylloc, context);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:
  /* Pacify compilers when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;

  /* Do not reclaim the symbols of the rule whose action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;

      yyerror_range[1] = *yylsp;
      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp, yylsp, context);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  yyerror_range[2] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the lookahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
  *++yylsp = yyloc;

  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;


/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;


#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (&yylloc, context, YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif


/*-----------------------------------------------------.
| yyreturn -- parsing is finished, return the result.  |
`-----------------------------------------------------*/
yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval, &yylloc, context);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[+*yyssp], yyvsp, yylsp, context);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  return yyresult;
}


int igraph_pajek_yyerror(YYLTYPE* locp,
                         igraph_i_pajek_parsedata_t *context,
                         const char *s) {
  snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1,
           "Parse error in Pajek file, line %i (%s)",
           locp->first_line, s);
  return 0;
}

igraph_real_t igraph_pajek_get_number(const char *str, long int length) {
  igraph_real_t num;
  char *tmp=IGRAPH_CALLOC(length+1, char);

  strncpy(tmp, str, length);
  tmp[length]='\0';
  sscanf(tmp, "%lf", &num);
  IGRAPH_FREE(tmp);
  return num;
}

/* TODO: NA's */

int igraph_i_pajek_add_numeric_attribute(igraph_trie_t *names,
                                         igraph_vector_ptr_t *attrs,
                                         long int count,
                                         const char *attrname,
                                         igraph_integer_t vid,
                                         igraph_real_t number) {
  long int attrsize=igraph_trie_size(names);
  long int id;
  igraph_vector_t *na;
  igraph_attribute_record_t *rec;

  igraph_trie_get(names, attrname, &id);
  if (id == attrsize) {
    /* add a new attribute */
    rec=IGRAPH_CALLOC(1, igraph_attribute_record_t);
    na=IGRAPH_CALLOC(1, igraph_vector_t);
    igraph_vector_init(na, count);
    rec->name=strdup(attrname);
    rec->type=IGRAPH_ATTRIBUTE_NUMERIC;
    rec->value=na;
    igraph_vector_ptr_push_back(attrs, rec);
  }
  rec=VECTOR(*attrs)[id];
  na=(igraph_vector_t*)rec->value;
  if (igraph_vector_size(na) == vid) {
    IGRAPH_CHECK(igraph_vector_push_back(na, number));
  } else if (igraph_vector_size(na) < vid) {
    long int origsize=igraph_vector_size(na);
    IGRAPH_CHECK(igraph_vector_resize(na, (long int)vid+1));
    for (;origsizename=strdup(attrname);
    rec->type=IGRAPH_ATTRIBUTE_STRING;
    rec->value=na;
    igraph_vector_ptr_push_back(attrs, rec);
  }
  rec=VECTOR(*attrs)[id];
  na=(igraph_strvector_t*)rec->value;
  if (igraph_strvector_size(na) <= vid) {
    long int origsize=igraph_strvector_size(na);
    IGRAPH_CHECK(igraph_strvector_resize(na, vid+1));
    for (;origsizevertex_attribute_names,
                                          context->vertex_attributes,
                                          context->vcount,
                                          name, context->actvertex-1,
                                          tmp);

  IGRAPH_FREE(tmp);
  IGRAPH_FINALLY_CLEAN(1);

  return ret;
}

int igraph_i_pajek_add_string_edge_attribute(const char *name,
                                             const char *value,
                                             int len,
                                             igraph_i_pajek_parsedata_t *context) {
  char *tmp;
  int ret;

  tmp=IGRAPH_CALLOC(len+1, char);
  if (tmp==0) {
    IGRAPH_ERROR("cannot add element to hash table", IGRAPH_ENOMEM);
  }
  IGRAPH_FINALLY(igraph_free, tmp);
  strncpy(tmp, value, len);
  tmp[len]='\0';

  ret=igraph_i_pajek_add_string_attribute(context->edge_attribute_names,
                                          context->edge_attributes,
                                          context->actedge,
                                          name, context->actedge-1,
                                          tmp);

  IGRAPH_FREE(tmp);
  IGRAPH_FINALLY_CLEAN(1);

  return ret;
}

int igraph_i_pajek_add_numeric_vertex_attribute(const char *name,
                                                igraph_real_t value,
                                                igraph_i_pajek_parsedata_t *context) {

  return
    igraph_i_pajek_add_numeric_attribute(context->vertex_attribute_names,
                                         context->vertex_attributes,
                                         context->vcount,
                                         name, context->actvertex-1,
                                         value);
}

int igraph_i_pajek_add_numeric_edge_attribute(const char *name,
                                              igraph_real_t value,
                                              igraph_i_pajek_parsedata_t *context) {

  return
    igraph_i_pajek_add_numeric_attribute(context->edge_attribute_names,
                                         context->edge_attributes,
                                         context->actedge,
                                         name, context->actedge-1,
                                         value);
}

int igraph_i_pajek_add_bipartite_type(igraph_i_pajek_parsedata_t *context) {

  const char *attrname="type";
  igraph_trie_t *names=context->vertex_attribute_names;
  igraph_vector_ptr_t *attrs=context->vertex_attributes;
  int i, n=context->vcount, n1=context->vcount2;
  long int attrid, attrsize=igraph_trie_size(names);
  igraph_attribute_record_t *rec;
  igraph_vector_t *na;

  if (n1 > n) {
    IGRAPH_ERROR("Invalid number of vertices in bipartite Pajek file",
                 IGRAPH_PARSEERROR);
  }

  igraph_trie_get(names, attrname, &attrid);
  if (attrid != attrsize) {
    IGRAPH_ERROR("Duplicate 'type' attribute in Pajek file, "
                 "this should not happen", IGRAPH_EINTERNAL);
  }

  /* add a new attribute */
  rec=IGRAPH_CALLOC(1, igraph_attribute_record_t);
  na=IGRAPH_CALLOC(1, igraph_vector_t);
  igraph_vector_init(na, n);
  rec->name=strdup(attrname);
  rec->type=IGRAPH_ATTRIBUTE_NUMERIC;
  rec->value=na;
  igraph_vector_ptr_push_back(attrs, rec);

  for (i=0; ivector;
  int i, n1=context->vcount2;
  int ne=igraph_vector_size(edges);

  for (i=0; i n1 && v2 > n1) ) {
      IGRAPH_WARNING("Invalid edge in bipartite graph");
    }
  }

  return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641368733.0
igraph-0.9.9/vendor/source/igraph/src/io/parsers/pajek-parser.h0000644000175100001710000000731000000000000025265 0ustar00runnerdocker00000000000000/* A Bison parser, made by GNU Bison 3.5.1.  */

/* Bison interface for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
   Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* Undocumented macros, especially those whose name start with YY_,
   are private implementation details.  Do not rely on them.  */

#ifndef YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED
# define YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED
/* Debug traces.  */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int igraph_pajek_yydebug;
#endif

/* Token type.  */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
  enum yytokentype
  {
    NEWLINE = 258,
    NUM = 259,
    ALNUM = 260,
    QSTR = 261,
    PSTR = 262,
    NETWORKLINE = 263,
    VERTICESLINE = 264,
    ARCSLINE = 265,
    EDGESLINE = 266,
    ARCSLISTLINE = 267,
    EDGESLISTLINE = 268,
    MATRIXLINE = 269,
    ERROR = 270,
    VP_X_FACT = 271,
    VP_Y_FACT = 272,
    VP_IC = 273,
    VP_BC = 274,
    VP_LC = 275,
    VP_LR = 276,
    VP_LPHI = 277,
    VP_BW = 278,
    VP_FOS = 279,
    VP_PHI = 280,
    VP_R = 281,
    VP_Q = 282,
    VP_LA = 283,
    VP_FONT = 284,
    VP_URL = 285,
    VP_SIZE = 286,
    EP_C = 287,
    EP_S = 288,
    EP_A = 289,
    EP_W = 290,
    EP_H1 = 291,
    EP_H2 = 292,
    EP_A1 = 293,
    EP_A2 = 294,
    EP_K1 = 295,
    EP_K2 = 296,
    EP_AP = 297,
    EP_P = 298,
    EP_L = 299,
    EP_LP = 300,
    EP_LR = 301,
    EP_LPHI = 302,
    EP_LC = 303,
    EP_LA = 304,
    EP_SIZE = 305,
    EP_FOS = 306
  };
#endif

/* Value type.  */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{

  long int intnum;
  double   realnum;
  struct {
    char *str;
    int len;
  } string;


};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

/* Location type.  */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif



int igraph_pajek_yyparse (igraph_i_pajek_parsedata_t* context);

#endif /* !YY_IGRAPH_PAJEK_YY_HOME_RUNNER_WORK_PYTHON_IGRAPH_PYTHON_IGRAPH_VENDOR_BUILD_IGRAPH_SRC_IO_PARSERS_PAJEK_PARSER_H_INCLUDED  */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.523141
igraph-0.9.9/vendor/source/igraph/src/isomorphism/0000755000175100001710000000000000000000000023012 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.527141
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/0000755000175100001710000000000000000000000024126 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/CMakeLists.txt0000644000175100001710000000215300000000000026667 0ustar00runnerdocker00000000000000# Declare the files needed to compile bliss
add_library(
  bliss
  OBJECT
  EXCLUDE_FROM_ALL
  defs.cc
  graph.cc
  heap.cc
  orbit.cc
  partition.cc
  uintseqhash.cc
  utils.cc
)

target_include_directories(
  bliss
  PRIVATE
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_SOURCE_DIR}/src
  ${PROJECT_SOURCE_DIR}/vendor
  ${PROJECT_BINARY_DIR}/include
  ${PROJECT_BINARY_DIR}/src
  $<$:${GMP_INCLUDE_DIR}>
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET bliss PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# If we are linking igraph to GMP, then Bliss will use GMP for bignums
if(NOT GMP_IS_VENDORED)
  target_link_libraries(
    bliss
    PUBLIC
    ${GMP_LIBRARY}
  )
endif()

# Since these are included as object files, they should call the
# function as is (without visibility specification)
target_compile_definitions(bliss PRIVATE IGRAPH_STATIC)

use_all_warnings(bliss)

if (MSVC)
  target_compile_options(bliss PRIVATE /wd4100) # disable unreferenced parameter warning
else()
  target_compile_options(
    bliss PRIVATE
    $<$:-Wno-unused-variable>
  )
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/bignum.hh0000644000175100001710000000441300000000000025732 0ustar00runnerdocker00000000000000#ifndef BLISS_BIGNUM_HH
#define BLISS_BIGNUM_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

#define BLISS_USE_GMP

#if defined(BLISS_USE_GMP)
#include "internal/gmp_internal.h"
#endif

#include 
#include "defs.hh"

namespace bliss {

/**
 * \brief A simple wrapper class for big integers (or approximation of them).
 *
 * If the compile time flag BLISS_USE_GMP is set,
 * then the GNU Multiple Precision Arithmetic library (GMP) is used to
 * obtain arbitrary precision, otherwise "long double" is used to
 * approximate big integers.
 */

#if defined(BLISS_USE_GMP)

class BigNum
{
  mpz_t v;
public:
  /**
   * \brief Create a new big number and set it to zero.
   */
  BigNum() {mpz_init(v); }

  /**
   * \brief Destroy the number.
   */
  ~BigNum() {mpz_clear(v); }

  /**
   * \brief Set the number to \a n.
   */
  void assign(const int n) {mpz_set_si(v, n); }

  /**
   * \brief Multiply the number with \a n.
   */
  void multiply(const int n) {mpz_mul_si(v, v, n); }

  /**
   * Get a copy of the internal GNU GMP integer.
   * The caller is responsible for calling mpz_init before,
   * and mpz_clear afterwards on the \a result variable.
   */
  void get(mpz_t& result) const {mpz_set(result, v); }
};

#else

class BigNum
{
  long double v;
public:
  /**
   * \brief Create a new big number and set it to zero.
   */
  BigNum(): v(0.0) {}

  /**
   * \brief Set the number to \a n.
   */
  void assign(const int n) {v = (long double)n; }

  /**
   * \brief Multiply the number with \a n.
   */
  void multiply(const int n) {v *= (long double)n; }
};

#endif

} //namespace bliss

#endif // BLISS_BIGNUM_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/defs.cc0000644000175100001710000000154000000000000025356 0ustar00runnerdocker00000000000000#include "igraph_error.h"

#include "defs.hh"

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

void
fatal_error(const char* reason)
{
  IGRAPH_FATAL(reason);
}

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/defs.hh0000644000175100001710000000472100000000000025374 0ustar00runnerdocker00000000000000#ifndef BLISS_DEFS_HH
#define BLISS_DEFS_HH

#include 
#include 

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

/** \file
 * \brief Some common definitions.
 */

namespace bliss {

/** \brief The version number of bliss. */
static const char * const version = "0.75";

/**
 * If a fatal internal error is encountered,
 * this function is called.
 * There should no return from this function, but an exit or
 * a jump/throw to code that deallocates the AbstractGraph instance calling this.
 */
void fatal_error(const char* fmt);


#if defined(BLISS_DEBUG)
#define BLISS_CONSISTENCY_CHECKS
#define BLISS_EXPENSIVE_CONSISTENCY_CHECKS
#endif


#if defined(BLISS_CONSISTENCY_CHECKS)
/* Force a check that the found automorphisms are valid */
#define BLISS_VERIFY_AUTOMORPHISMS
#endif


#if defined(BLISS_CONSISTENCY_CHECKS)
/* Force a check that the generated partitions are equitable */
#define BLISS_VERIFY_EQUITABLEDNESS
#endif

} // namespace bliss


/*! \mainpage Outline
 *
 * This is the C++ API documentation of bliss,
 * produced by running doxygen in
 * the source directory.
 *
 * The algorithms and data structures used in bliss,
 * the graph file format, as well as the compilation process
 * can be found at the
 * bliss web site.
 *
 * The C++ language API is the main API to bliss.
 * It basically consists of the public methods in the classes
 * * bliss::Graph and
 * * bliss::Digraph.
 *
 * For an example of its use,
 * see the \ref executable "source of the bliss executable".
 *
 * \section capi_sec The C language API
 *
 * The C language API is given in the file bliss_C.h.
 * It is currently only a subset of the C++ API,
 * so consider using the C++ API whenever possible.
 */

#endif // BLISS_DEFS_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/graph.cc0000644000175100001710000044263300000000000025552 0ustar00runnerdocker00000000000000#include "igraph_error.h"

#include 
#include 
#include 
#include 
#include 
// #include 
#include 
#include 

#include "defs.hh"
#include "graph.hh"
#include "partition.hh"
#include "utils.hh"

/* Allow using 'and' instead of '&&' with MSVC */
#if _MSC_VER
#include 
#endif

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/


namespace bliss {

#define _INTERNAL_ERROR() IGRAPH_FATAL("Bliss internal error")

/*-------------------------------------------------------------------------
 *
 * Constructor and destructor routines for the abstract graph class
 *
 *-------------------------------------------------------------------------*/


AbstractGraph::AbstractGraph()
{
  /* Initialize stuff */
  first_path_labeling = nullptr;
  first_path_labeling_inv = nullptr;
  best_path_labeling = nullptr;
  best_path_labeling_inv = nullptr;
  first_path_automorphism = nullptr;
  best_path_automorphism = nullptr;
  in_search = false;

  /* Default value for using "long prune" */
  opt_use_long_prune = true;
  /* Default value for using failure recording */
  opt_use_failure_recording = true;
  /* Default value for using component recursion */
  opt_use_comprec = true;


  /*
  verbose_level = 0;
  verbstr = stdout;
  */
}


AbstractGraph::~AbstractGraph()
{
  delete[] first_path_labeling; first_path_labeling = nullptr;
  delete[] first_path_labeling_inv; first_path_labeling_inv = nullptr;
  delete[] first_path_automorphism; first_path_automorphism = nullptr;

  delete[] best_path_labeling; best_path_labeling = nullptr;
  delete[] best_path_labeling_inv; best_path_labeling_inv = nullptr;
  delete[] best_path_automorphism; best_path_automorphism = nullptr;
}



/*-------------------------------------------------------------------------
 *
 * Verbose output management routines
 *
 *-------------------------------------------------------------------------*/

/*
void
AbstractGraph::set_verbose_level(const unsigned int level)
{
  verbose_level = level;
}

void
AbstractGraph::set_verbose_file(FILE* const fp)
{
  verbstr = fp;
}
*/



/*-------------------------------------------------------------------------
 *
 * Routines for refinement to equitable partition
 *
 *-------------------------------------------------------------------------*/

void
AbstractGraph::refine_to_equitable()
{

  /* Start refinement from all cells -> push 'em all in the splitting queue */
  for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next)
    p.splitting_queue_add(cell);

  do_refine_to_equitable();

}

void
AbstractGraph::refine_to_equitable(Partition::Cell* const unit_cell)
{

  p.splitting_queue_add(unit_cell);

  do_refine_to_equitable();
}



void
AbstractGraph::refine_to_equitable(Partition::Cell* const unit_cell1,
                                   Partition::Cell* const unit_cell2)
{

  p.splitting_queue_add(unit_cell1);
  p.splitting_queue_add(unit_cell2);

  do_refine_to_equitable();
}



bool
AbstractGraph::do_refine_to_equitable()
{

  eqref_hash.reset();

  while(!p.splitting_queue_is_empty())
    {
      Partition::Cell* const cell = p.splitting_queue_pop();

      if(cell->is_unit())
        {
          if(in_search) {
            const unsigned int index = cell->first;
            if(first_path_automorphism)
              {
                /* Build the (potential) automorphism on-the-fly */
                first_path_automorphism[first_path_labeling_inv[index]] =
                  p.elements[index];
              }
            if(best_path_automorphism)
              {
                /* Build the (potential) automorphism on-the-fly */
                best_path_automorphism[best_path_labeling_inv[index]] =
                  p.elements[index];
              }
          }
          const bool worse = split_neighbourhood_of_unit_cell(cell);
          if(in_search and worse)
            goto worse_exit;
        }
      else
        {
          const bool worse = split_neighbourhood_of_cell(cell);
          if(in_search and worse)
            goto worse_exit;
        }
    }

  return true;

 worse_exit:
  /* Clear splitting_queue */
  p.splitting_queue_clear();
  return false;
}
















/*-------------------------------------------------------------------------
 *
 * Routines for handling the canonical labeling
 *
 *-------------------------------------------------------------------------*/

/** \internal
 * Assign the labeling induced by the current partition 'this.p' to
 * \a labeling.
 * That is, if the partition is [[2,0],[1]],
 * then \a labeling will map 0 to 1, 1 to 2, and 2 to 0.
 */
void
AbstractGraph::update_labeling(unsigned int* const labeling)
{
  const unsigned int N = get_nof_vertices();
  unsigned int* ep = p.elements;
  for(unsigned int i = 0; i < N; i++, ep++)
    labeling[*ep] = i;
}

/** \internal
 * The same as update_labeling() except that the inverse of the labeling
 * is also produced and assigned to \a labeling_inv.
 */
void
AbstractGraph::update_labeling_and_its_inverse(unsigned int* const labeling,
                                               unsigned int* const labeling_inv)
{
  const unsigned int N = get_nof_vertices();
  unsigned int* ep = p.elements;
  unsigned int* clip = labeling_inv;

  for(unsigned int i = 0; i < N; ) {
    labeling[*ep] = i;
    i++;
    *clip = *ep;
    ep++;
    clip++;
  }
}





/*-------------------------------------------------------------------------
 *
 * Routines for handling automorphisms
 *
 *-------------------------------------------------------------------------*/


/** \internal
 * Reset the permutation \a perm to the identity permutation.
 */
void
AbstractGraph::reset_permutation(unsigned int* perm)
{
  const unsigned int N = get_nof_vertices();
  for(unsigned int i = 0; i < N; i++, perm++)
    *perm = i;
}

/*
bool
AbstractGraph::is_automorphism(unsigned int* const perm)
{
  _INTERNAL_ERROR();
  return false;
}
*/

/*
bool
AbstractGraph::is_automorphism(const std::vector& perm) const
{
  _INTERNAL_ERROR();
  return false;
}
*/



/*-------------------------------------------------------------------------
 *
 * Certificate building
 *
 *-------------------------------------------------------------------------*/

void
AbstractGraph::cert_add(const unsigned int v1,
                        const unsigned int v2,
                        const unsigned int v3)
{
  if(refine_compare_certificate)
    {
      if(refine_equal_to_first)
        {
          /* So far equivalent to the first path... */
          unsigned int index = certificate_current_path.size();
          if(index >= refine_first_path_subcertificate_end)
            {
              refine_equal_to_first = false;
            }
          else if(certificate_first_path[index] != v1)
            {
              refine_equal_to_first = false;
            }
          else if(certificate_first_path[++index] != v2)
            {
              refine_equal_to_first = false;
            }
          else if(certificate_first_path[++index] != v3)
            {
              refine_equal_to_first = false;
            }
          if(opt_use_failure_recording and !refine_equal_to_first)
            {
              /* We just became different from the first path,
               * remember the deviation point tree-specific invariant
               * for the use of failure recording */
              UintSeqHash h;
              h.update(v1);
              h.update(v2);
              h.update(v3);
              h.update(index);
              h.update(eqref_hash.get_value());
              failure_recording_fp_deviation = h.get_value();
            }
        }
      if(refine_cmp_to_best == 0)
        {
          /* So far equivalent to the current best path... */
          unsigned int index = certificate_current_path.size();
          if(index >= refine_best_path_subcertificate_end)
            {
              refine_cmp_to_best = 1;
            }
          else if(v1 > certificate_best_path[index])
            {
              refine_cmp_to_best = 1;
            }
          else if(v1 < certificate_best_path[index])
            {
              refine_cmp_to_best = -1;
            }
          else if(v2 > certificate_best_path[++index])
            {
              refine_cmp_to_best = 1;
            }
          else if(v2 < certificate_best_path[index])
            {
              refine_cmp_to_best = -1;
            }
          else if(v3 > certificate_best_path[++index])
            {
              refine_cmp_to_best = 1;
            }
          else if(v3 < certificate_best_path[index])
            {
              refine_cmp_to_best = -1;
            }
        }
      if((refine_equal_to_first == false) and
         (refine_cmp_to_best < 0))
        return;
    }
  /* Update the current path certificate */
  certificate_current_path.push_back(v1);
  certificate_current_path.push_back(v2);
  certificate_current_path.push_back(v3);
}


void
AbstractGraph::cert_add_redundant(const unsigned int v1,
                                  const unsigned int v2,
                                  const unsigned int v3)
{
  return cert_add(v1, v2, v3);
}











/*-------------------------------------------------------------------------
 *
 * Long prune code
 *
 *-------------------------------------------------------------------------*/

void
AbstractGraph::long_prune_init()
{
  const unsigned int N = get_nof_vertices();
  long_prune_temp.clear();
  long_prune_temp.resize(N);
  /* Of how many automorphisms we can store information in
     the predefined, fixed amount of memory? */
  const unsigned int nof_fitting_in_max_mem =
    (long_prune_options_max_mem * 1024 * 1024) / (((N * 2) / 8)+1);
  long_prune_max_stored_autss = long_prune_options_max_stored_auts;
  /* Had some problems with g++ in using (a* tmp = long_prune_fixed[real_i];
  long_prune_fixed[real_i] = long_prune_fixed[real_j];
  long_prune_fixed[real_j] = tmp;
  tmp = long_prune_mcrs[real_i];
  long_prune_mcrs[real_i] = long_prune_mcrs[real_j];
  long_prune_mcrs[real_j] = tmp;
}

std::vector&
AbstractGraph::long_prune_allocget_fixed(const unsigned int index)
{
  const unsigned int i = index % long_prune_max_stored_autss;
  if(!long_prune_fixed[i])
    long_prune_fixed[i] = new std::vector(get_nof_vertices());
  return *long_prune_fixed[i];
}

std::vector&
AbstractGraph::long_prune_get_fixed(const unsigned int index)
{
  return *long_prune_fixed[index % long_prune_max_stored_autss];
}

std::vector&
AbstractGraph::long_prune_allocget_mcrs(const unsigned int index)
{
  const unsigned int i = index % long_prune_max_stored_autss;
  if(!long_prune_mcrs[i])
    long_prune_mcrs[i] = new std::vector(get_nof_vertices());
  return *long_prune_mcrs[i];
}

std::vector&
AbstractGraph::long_prune_get_mcrs(const unsigned int index)
{
  return *long_prune_mcrs[index % long_prune_max_stored_autss];
}

void
AbstractGraph::long_prune_add_automorphism(const unsigned int* aut)
{
  if(long_prune_max_stored_autss == 0)
    return;

  const unsigned int N = get_nof_vertices();


  /* If the buffer of stored auts is full, remove the oldest aut */
  if(long_prune_end - long_prune_begin == long_prune_max_stored_autss)
    {
      long_prune_begin++;
    }
  long_prune_end++;
  std::vector& fixed = long_prune_allocget_fixed(long_prune_end-1);
  std::vector& mcrs = long_prune_allocget_mcrs(long_prune_end-1);
  /* Mark nodes that are (i) fixed or (ii) minimal orbit representatives
   * under the automorphism 'aut' */
  for(unsigned int i = 0; i < N; i++)
    {
      fixed[i] = (aut[i] == i);
      if(long_prune_temp[i] == false)
        {
          mcrs[i] = true;
          unsigned int j = aut[i];
          while(j != i)
            {
              long_prune_temp[j] = true;
              j = aut[j];
            }
        }
      else
        {
          mcrs[i] = false;
        }
      /* Clear the temp array on-the-fly... */
      long_prune_temp[i] = false;
    }


}



/*-------------------------------------------------------------------------
 *
 * Routines for handling orbit information
 *
 *-------------------------------------------------------------------------*/

void
AbstractGraph::update_orbit_information(Orbit& o, const unsigned int* perm)
{
  const unsigned int N = get_nof_vertices();
  for(unsigned int i = 0; i < N; i++)
    if(perm[i] != i)
      o.merge_orbits(i, perm[i]);
}








/*-------------------------------------------------------------------------
 *
 * The actual backtracking search
 *
 *-------------------------------------------------------------------------*/

/** \internal \brief Search tree node information.
 */
class TreeNode
{
  //friend class AbstractGraph;
public:
  unsigned int split_cell_first;

  int split_element;
  static const int SPLIT_START = -1;
  static const int SPLIT_END   = -2;

  Partition::BacktrackPoint partition_bt_point;

  unsigned int certificate_index;

  static const char NO = -1;
  static const char MAYBE = 0;
  static const char YES = 1;

  /* First path stuff */
  bool fp_on;
  bool fp_cert_equal;
  char fp_extendable;

  /* Best path stuff */
  bool in_best_path;
  int cmp_to_best_path;

  unsigned int failure_recording_ival;

  /* Component recursion related data */
  unsigned int cr_cep_stack_size;
  unsigned int cr_cep_index;
  unsigned int cr_level;

  bool needs_long_prune;
  unsigned int long_prune_begin;
  std::set > long_prune_redundant;

  UintSeqHash eqref_hash;
  unsigned int subcertificate_length;
};





void
AbstractGraph::search(const bool canonical,
                      Stats& stats,
                      const std::function& report,
                      const std::function& terminate)
{
  const unsigned int N = get_nof_vertices();

  unsigned int all_same_level = UINT_MAX;

  p.graph = this;

  /*
   * Must be done!
   */
  remove_duplicate_edges();

  /*
   * Reset search statistics
   */
  stats.reset();
  stats.nof_nodes = 1;
  stats.nof_leaf_nodes = 1;

  /* Free old first path data structures */
  delete[] first_path_labeling; first_path_labeling = nullptr;
  delete[] first_path_labeling_inv; first_path_labeling_inv = nullptr;
  delete[] first_path_automorphism; first_path_automorphism = nullptr;

  /* Free old best path data structures */
  delete[] best_path_labeling; best_path_labeling = nullptr;
  delete[] best_path_labeling_inv; best_path_labeling_inv = nullptr;
  delete[] best_path_automorphism; best_path_automorphism = nullptr;

  if(N == 0)
    {
      /* Nothing to do, return... */
      return;
    }

  /* Initialize the partition ... */
  p.init(N);
  /* ... and the component recursion data structures in the partition */
  if(opt_use_comprec)
    p.cr_init();

  neighbour_heap.init(N);

  in_search = false;
  /* Do not compute certificate when building the initial partition */
  refine_compare_certificate = false;
  /* The 'eqref_hash' hash value is not computed when building
   * the initial partition as it is not used for anything at the moment.
   * This saves some cycles. */
  compute_eqref_hash = false;

  make_initial_equitable_partition();

  /*
   * Allocate space for the "first path" and "best path" labelings
   */
  delete[] first_path_labeling;
  first_path_labeling = new unsigned int[N];

  delete[] best_path_labeling;
  best_path_labeling = new unsigned int[N];
  for(unsigned int i = 0; i < N; i++) best_path_labeling[i] = i;

  /*
   * Is the initial partition discrete?
   */
  if(p.is_discrete())
    {
      /* Make the best path labeling i.e. the canonical labeling */
      update_labeling(best_path_labeling);
      /* Update statistics */
      stats.nof_leaf_nodes = 1;
      /* Release component recursion data in partition */
      if(opt_use_comprec)
        p.cr_free();
      return;
    }

  /*
   * Allocate the inverses of the "first path" and "best path" labelings
   */
  delete[] first_path_labeling_inv;
  first_path_labeling_inv = new unsigned int[N];
  std::fill_n(first_path_labeling_inv, N, 0);
  delete[] best_path_labeling_inv;
  best_path_labeling_inv = new unsigned int[N];
  std::fill_n(best_path_labeling_inv, N, 0);

  /*
   * Allocate space for the automorphisms
   */
  delete[] first_path_automorphism;
  first_path_automorphism = new unsigned int[N];
  delete[] best_path_automorphism;
  best_path_automorphism = new unsigned int[N];

  /*
   * Initialize orbit information so that all vertices are in their own orbits
   */
  first_path_orbits.init(N);
  best_path_orbits.init(N);

  /*
   * Initialize certificate memory
   */
  initialize_certificate();

  std::vector search_stack;
  std::vector first_path_info;
  std::vector best_path_info;

  search_stack.clear();

  /* Initialize "long prune" data structures */
  if(opt_use_long_prune)
    long_prune_init();

  /*
   * Initialize failure recording data structures
   */
  typedef std::set > FailureRecordingSet;
  std::vector failure_recording_hashes;

  /*
   * Initialize component recursion data structures
   */
  cr_cep_stack.clear();
  unsigned int cr_cep_index = 0;
  {
    /* Inset a sentinel "component end point" */
    CR_CEP sentinel;
    sentinel.creation_level = 0;
    sentinel.discrete_cell_limit = get_nof_vertices();
    sentinel.next_cr_level = 0;
    sentinel.next_cep_index = 0;
    sentinel.first_checked = false;
    sentinel.best_checked = false;
    cr_cep_index = 0;
    cr_cep_stack.push_back(sentinel);
  }
  cr_level = 0;
  if(opt_use_comprec and
     nucr_find_first_component(cr_level) == true and
     p.nof_discrete_cells() + cr_component_elements <
     cr_cep_stack[cr_cep_index].discrete_cell_limit)
    {
      cr_level = p.cr_split_level(0, cr_component);
      CR_CEP cep;
      cep.creation_level = 0;
      cep.discrete_cell_limit = p.nof_discrete_cells() + cr_component_elements;
      cep.next_cr_level = 0;
      cep.next_cep_index = cr_cep_index;
      cep.first_checked = false;
      cep.best_checked = false;
      cr_cep_index = cr_cep_stack.size();
      cr_cep_stack.push_back(cep);
    }

  /*
   * Build the root node of the search tree
   */
  {
    TreeNode root;
    Partition::Cell* split_cell = find_next_cell_to_be_splitted(p.first_cell);
    root.split_cell_first = split_cell->first;
    root.split_element = TreeNode::SPLIT_START;
    root.partition_bt_point = p.set_backtrack_point();
    root.certificate_index = 0;
    root.fp_on = true;
    root.fp_cert_equal = true;
    root.fp_extendable = TreeNode::MAYBE;
    root.in_best_path = false;
    root.cmp_to_best_path = 0;
    root.long_prune_begin = 0;

    root.failure_recording_ival = 0;

    /* Save component recursion info for backtracking */
    root.cr_level = cr_level;
    root.cr_cep_stack_size = cr_cep_stack.size();
    root.cr_cep_index = cr_cep_index;
    search_stack.push_back(root);
  }

  /*
   * Set status and global flags for search related procedures
   */
  in_search = true;
  /* Do not compare certificates during refinement until the first path has been traversed to the leaf */
  refine_compare_certificate = false;




  /*
   * The actual backtracking search
   */
  while(!search_stack.empty())
    {
      if(terminate and terminate()) {
        break;
      }
      TreeNode&          current_node  = search_stack.back();
      const unsigned int current_level = (unsigned int)search_stack.size()-1;


      if(opt_use_comprec)
        {
          CR_CEP& cep = cr_cep_stack[current_node.cr_cep_index];
          if(cep.first_checked == true and
             current_node.fp_extendable == TreeNode::MAYBE and
             !search_stack[cep.creation_level].fp_on)
            {
              current_node.fp_extendable = TreeNode::NO;
            }
        }

      if(current_node.fp_on)
        {
          if(current_node.split_element == TreeNode::SPLIT_END)
            {
              search_stack.pop_back();
              continue;
            }
        }
      else
        {
          if(current_node.fp_extendable == TreeNode::YES)
            {
              search_stack.pop_back();
              continue;
            }
          if(current_node.split_element == TreeNode::SPLIT_END)
            {
              if(opt_use_failure_recording)
                {
                  TreeNode& parent_node = search_stack[current_level-1];
                  if(parent_node.fp_on)
                    failure_recording_hashes[current_level-1].insert(current_node.failure_recording_ival);
                }
              search_stack.pop_back();
              continue;
            }
          if(current_node.fp_extendable == TreeNode::NO and
             (!canonical or current_node.cmp_to_best_path < 0))
            {
              if(opt_use_failure_recording)
                {
                  TreeNode& parent_node = search_stack[current_level-1];
                  if(parent_node.fp_on)
                    failure_recording_hashes[current_level-1].insert(current_node.failure_recording_ival);
                }
              search_stack.pop_back();
              continue;
            }
        }

      /* Restore partition ... */
      p.goto_backtrack_point(current_node.partition_bt_point);
      /* ... and re-remember backtracking point */
      current_node.partition_bt_point = p.set_backtrack_point();

      /* Restore current path certificate */
      certificate_index = current_node.certificate_index;
      refine_current_path_certificate_index = current_node.certificate_index;
      certificate_current_path.resize(certificate_index);

      /* Fetch split cell information */
      Partition::Cell * const cell =
        p.get_cell(p.elements[current_node.split_cell_first]);

      /* Restore component recursion information */
      cr_level = current_node.cr_level;
      cr_cep_stack.resize(current_node.cr_cep_stack_size);
      cr_cep_index = current_node.cr_cep_index;


      /*
       * Update long prune redundancy sets
       */
      if(opt_use_long_prune and current_level >= 1 and !current_node.fp_on)
        {
          unsigned int begin = (current_node.long_prune_begin>long_prune_begin)?current_node.long_prune_begin:long_prune_begin;
          for(unsigned int i = begin; i < long_prune_end; i++)
            {
              const std::vector& fixed = long_prune_get_fixed(i);
#if defined(BLISS_CONSISTENCY_CHECKS)
              for(unsigned int l = 0; l < search_stack.size()-2; l++)
                assert(fixed[search_stack[l].split_element]);
#endif
              if(fixed[search_stack[search_stack.size()-1-1].split_element] ==
                 false)
                {
                  long_prune_swap(begin, i);
                  begin++;
                  current_node.long_prune_begin = begin;
                  continue;
                }
            }

          if(current_node.split_element == TreeNode::SPLIT_START)
            {
              current_node.needs_long_prune = true;
            }
          else if(current_node.needs_long_prune)
            {
              current_node.needs_long_prune = false;
              unsigned int begin = (current_node.long_prune_begin>long_prune_begin)?current_node.long_prune_begin:long_prune_begin;
              for(unsigned int i = begin; i < long_prune_end; i++)
                {
                  const std::vector& fixed = long_prune_get_fixed(i);
#if defined(BLISS_CONSISTENCY_CHECKS)
                  for(unsigned int l = 0; l < search_stack.size()-2; l++)
                    assert(fixed[search_stack[l].split_element]);
#endif
                  assert(fixed[search_stack[current_level-1].split_element] == true);
                  if(fixed[search_stack[current_level-1].split_element] == false)
                    {
                      long_prune_swap(begin, i);
                      begin++;
                      current_node.long_prune_begin = begin;
                      continue;
                    }
                  const std::vector& mcrs = long_prune_get_mcrs(i);
                  unsigned int* ep = p.elements + cell->first;
                  for(unsigned int j = cell->length; j > 0; j--, ep++) {
                    if(mcrs[*ep] == false)
                      current_node.long_prune_redundant.insert(*ep);
                  }
                }
            }
        }


      /*
       * Find the next smallest, non-isomorphic element in the cell and
       * store it in current_node.split_element
       */
      {
        unsigned int  next_split_element = UINT_MAX;
        //unsigned int* next_split_element_pos = 0;
        unsigned int* ep = p.elements + cell->first;
        if(current_node.fp_on)
          {
            /* Find the next larger splitting element that is
             * a minimal orbit representative w.r.t. first_path_orbits */
            for(unsigned int i = cell->length; i > 0; i--, ep++) {
              if((int)(*ep) > current_node.split_element and
                 *ep < next_split_element and
                 first_path_orbits.is_minimal_representative(*ep)) {
                next_split_element = *ep;
                //next_split_element_pos = ep;
              }
            }
          }
        else if(current_node.in_best_path)
          {
            /* Find the next larger splitting element that is
             * a minimal orbit representative w.r.t. best_path_orbits */
            for(unsigned int i = cell->length; i > 0; i--, ep++) {
              if((int)(*ep) > current_node.split_element and
                 *ep < next_split_element and
                 best_path_orbits.is_minimal_representative(*ep) and
                 (!opt_use_long_prune or
                  current_node.long_prune_redundant.find(*ep) ==
                  current_node.long_prune_redundant.end())) {
                next_split_element = *ep;
                //next_split_element_pos = ep;
              }
            }
          }
        else
          {
            /* Find the next larger splitting element */
            for(unsigned int i = cell->length; i > 0; i--, ep++) {
              if((int)(*ep) > current_node.split_element and
                 *ep < next_split_element and
                 (!opt_use_long_prune or
                  current_node.long_prune_redundant.find(*ep) ==
                  current_node.long_prune_redundant.end())) {
                next_split_element = *ep;
                //next_split_element_pos = ep;
              }
            }
          }
        if(next_split_element == UINT_MAX)
          {
            /* No more (unexplored children) in the cell */
            current_node.split_element = TreeNode::SPLIT_END;
            if(current_node.fp_on)
              {
                /* Update group size */
                const unsigned int index = first_path_orbits.orbit_size(first_path_info[search_stack.size()-1].splitting_element);
                stats.group_size.multiply(index);
                stats.group_size_approx *= (long double)index;
                /*
                 * Update all_same_level
                 */
                if(index == cell->length and all_same_level == current_level+1)
                  all_same_level = current_level;
                /*
                if(verbstr and verbose_level >= 2) {
                  fprintf(verbstr,
                          "Level %u: orbits=%u, index=%u/%u, all_same_level=%u\n",
                          current_level,
                          first_path_orbits.nof_orbits(),
                          index, cell->length,
                          all_same_level);
                  fflush(verbstr);
                }
                */
              }
            continue;
          }

        /* Split on smallest */
        current_node.split_element = next_split_element;
      }

      const unsigned int child_level = current_level+1;
      /* Update some statistics */
      stats.nof_nodes++;
      if(search_stack.size() > stats.max_level)
        stats.max_level = search_stack.size();



      /* Set flags and indices for the refiner certificate builder */
      refine_equal_to_first = current_node.fp_cert_equal;
      refine_cmp_to_best = current_node.cmp_to_best_path;
      if(!first_path_info.empty())
        {
          if(refine_equal_to_first)
            refine_first_path_subcertificate_end =
              first_path_info[search_stack.size()-1].certificate_index +
              first_path_info[search_stack.size()-1].subcertificate_length;
          if(canonical)
            {
              if(refine_cmp_to_best == 0)
                refine_best_path_subcertificate_end =
                  best_path_info[search_stack.size()-1].certificate_index +
                  best_path_info[search_stack.size()-1].subcertificate_length;
            }
          else
            refine_cmp_to_best = -1;
        }

      const bool was_fp_cert_equal = current_node.fp_cert_equal;

      /* Individualize, i.e. split the cell in two, the latter new cell
       * will be a unit one containing info.split_element */
      Partition::Cell* const new_cell =
        p.individualize(cell, current_node.split_element);

      /*
       * Refine the new partition to equitable
       */
      if(cell->is_unit())
        refine_to_equitable(cell, new_cell);
      else
        refine_to_equitable(new_cell);




      /* Update statistics */
      if(p.is_discrete())
        stats.nof_leaf_nodes++;


      if(!first_path_info.empty())
        {
          /* We are no longer on the first path */
          const unsigned int subcertificate_length =
            certificate_current_path.size() - certificate_index;
          if(refine_equal_to_first)
            {
              /* Was equal to the first path so far */
              PathInfo& first_pinfo = first_path_info[current_level];
              assert(first_pinfo.certificate_index == certificate_index);
              if(subcertificate_length != first_pinfo.subcertificate_length)
                {
                  refine_equal_to_first = false;
                  if(opt_use_failure_recording)
                    failure_recording_fp_deviation = subcertificate_length;
                }
              else if(first_pinfo.eqref_hash.cmp(eqref_hash) != 0)
                {
                  refine_equal_to_first = false;
                  if(opt_use_failure_recording)
                    failure_recording_fp_deviation = eqref_hash.get_value();
                }
            }
          if(canonical and (refine_cmp_to_best == 0))
            {
              /* Was equal to the best path so far */
              PathInfo& bestp_info = best_path_info[current_level];
              assert(bestp_info.certificate_index == certificate_index);
              if(subcertificate_length < bestp_info.subcertificate_length)
                {
                  refine_cmp_to_best = -1;
                }
              else if(subcertificate_length > bestp_info.subcertificate_length)
                {
                  refine_cmp_to_best = 1;
                }
              else if(bestp_info.eqref_hash.cmp(eqref_hash) > 0)
                {
                  refine_cmp_to_best = -1;
                }
              else if(bestp_info.eqref_hash.cmp(eqref_hash) < 0)
                {
                  refine_cmp_to_best = 1;
                }
            }

          if(opt_use_failure_recording and
             was_fp_cert_equal and
             !refine_equal_to_first)
            {
              UintSeqHash k;
              k.update(failure_recording_fp_deviation);
              k.update(eqref_hash.get_value());
              failure_recording_fp_deviation = k.get_value();

              if(current_node.fp_on)
                failure_recording_hashes[current_level].insert(failure_recording_fp_deviation);
              else
                {
                  for(unsigned int i = current_level; i > 0; i--)
                    {
                      if(search_stack[i].fp_on)
                        break;
                      const FailureRecordingSet& s = failure_recording_hashes[i];
                      if(i == current_level and
                         s.find(failure_recording_fp_deviation) != s.end())
                        break;
                      if(s.find(0) != s.end())
                        break;
                      search_stack[i].fp_extendable = TreeNode::NO;
                    }
                }
            }


          /* Check if no longer equal to the first path and,
           * if canonical labeling is desired, also worse than the
           * current best path */
          if(refine_equal_to_first == false and
             (!canonical or (refine_cmp_to_best < 0)))
            {
              /* Yes, backtrack */
              stats.nof_bad_nodes++;
              if(current_node.fp_cert_equal == true and
                 current_level+1 > all_same_level)
                {
                  assert(all_same_level >= 1);
                  for(unsigned int i = all_same_level;
                      i < search_stack.size();
                      i++)
                    {
                      search_stack[i].fp_extendable = TreeNode::NO;
                    }
                }

              continue;
            }
        }

#if defined(BLISS_VERIFY_EQUITABLEDNESS)
      /* The new partition should be equitable */
      if(!is_equitable())
        fatal_error("consistency check failed - partition after refinement is not equitable");
#endif

      /*
       * Next level search tree node info
       */
      TreeNode child_node;

      /* No more in the first path */
      child_node.fp_on = false;
      /* No more in the best path */
      child_node.in_best_path = false;

      child_node.fp_cert_equal = refine_equal_to_first;
      if(current_node.fp_extendable == TreeNode::NO or
         (current_node.fp_extendable == TreeNode::MAYBE and
          child_node.fp_cert_equal == false))
        child_node.fp_extendable = TreeNode::NO;
      else
        child_node.fp_extendable = TreeNode::MAYBE;
      child_node.cmp_to_best_path = refine_cmp_to_best;

      child_node.failure_recording_ival = 0;
      child_node.cr_cep_stack_size = current_node.cr_cep_stack_size;
      child_node.cr_cep_index = current_node.cr_cep_index;
      child_node.cr_level = current_node.cr_level;

      certificate_index = certificate_current_path.size();

      current_node.eqref_hash = eqref_hash;
      current_node.subcertificate_length =
        certificate_index - current_node.certificate_index;


      /*
       * The first encountered leaf node at the end of the "first path"?
       */
      if(p.is_discrete() and first_path_info.empty())
        {
          //fprintf(stdout, "Level %u: FIRST\n", child_level); fflush(stdout);
          stats.nof_canupdates++;
          /*
           * Update labelings and their inverses
           */
          update_labeling_and_its_inverse(first_path_labeling,
                                          first_path_labeling_inv);
          update_labeling_and_its_inverse(best_path_labeling,
                                          best_path_labeling_inv);
          /*
           * Reset automorphism array
           */
          reset_permutation(first_path_automorphism);
          reset_permutation(best_path_automorphism);
          /*
           * Reset orbit information
           */
          first_path_orbits.reset();
          best_path_orbits.reset();
          /*
           * Reset group size
           */
          stats.group_size.assign(1);
          stats.group_size_approx = 1.0;
          /*
           * Reset all_same_level
           */
          all_same_level = child_level;
          /*
           * Mark the current path to be the first and best one and save it
           */
          const unsigned int base_size = search_stack.size();
          best_path_info.clear();
          //fprintf(stdout, " New base is: ");
          for(unsigned int i = 0; i < base_size; i++) {
            search_stack[i].fp_on = true;
            search_stack[i].fp_cert_equal = true;
            search_stack[i].fp_extendable = TreeNode::YES;
            search_stack[i].in_best_path = true;
            search_stack[i].cmp_to_best_path = 0;
            PathInfo path_info;
            path_info.splitting_element = search_stack[i].split_element;
            path_info.certificate_index = search_stack[i].certificate_index;
            path_info.eqref_hash = search_stack[i].eqref_hash;
            path_info.subcertificate_length = search_stack[i].subcertificate_length;
            first_path_info.push_back(path_info);
            best_path_info.push_back(path_info);
            //fprintf(stdout, "%u ", search_stack[i].split_element);
          }
          //fprintf(stdout, "\n"); fflush(stdout);
          /* Copy certificates */
          certificate_first_path = certificate_current_path;
          certificate_best_path = certificate_current_path;

          /* From now on, compare certificates when refining */
          refine_compare_certificate = true;

          if(opt_use_failure_recording)
            failure_recording_hashes.resize(base_size);

          /*
          for(unsigned int j = 0; j < search_stack.size(); j++)
            fprintf(stderr, "%u ", search_stack[j].split_element);
          fprintf(stderr, "\n");
          p.print(stderr); fprintf(stderr, "\n");
          */

          /*
           * Backtrack to the previous level
           */
          continue;
        }


      if(p.is_discrete() and child_node.fp_cert_equal)
        {
          /*
           * A leaf node that is equal to the first one.
           * An automorphism found: aut[i] = elements[first_path_labeling[i]]
           */
          goto handle_first_path_automorphism;
        }


      if(!p.is_discrete())
        {
          Partition::Cell* next_split_cell = 0;
          /*
           * An internal, non-leaf node
           */
          if(opt_use_comprec)
            {
              assert(p.nof_discrete_cells() <=
                     cr_cep_stack[cr_cep_index].discrete_cell_limit);
              assert(cr_level == child_node.cr_level);


              if(p.nof_discrete_cells() ==
                 cr_cep_stack[cr_cep_index].discrete_cell_limit)
                {
                  /* We have reached the end of a component */
                  assert(cr_cep_index != 0);
                  CR_CEP& cep = cr_cep_stack[cr_cep_index];

                  /* First, compare with respect to the first path */
                  if(first_path_info.empty() or child_node.fp_cert_equal) {
                    if(cep.first_checked == false)
                      {
                        /* First time, go to the next component */
                        cep.first_checked = true;
                      }
                    else
                      {
                        assert(!first_path_info.empty());
                        assert(cep.creation_level < search_stack.size());
                        TreeNode& old_info = search_stack[cep.creation_level];
                        /* If the component was found when on the first path,
                         * handle the found automorphism as the other
                         * first path automorphisms */
                        if(old_info.fp_on)
                          goto handle_first_path_automorphism;
                      }
                  }

                  if(canonical and
                     !first_path_info.empty() and
                     child_node.cmp_to_best_path >= 0) {
                    if(cep.best_checked == false)
                      {
                        /* First time, go to the next component */
                        cep.best_checked = true;
                      }
                    else
                      {
                        assert(cep.creation_level < search_stack.size());
                        TreeNode& old_info = search_stack[cep.creation_level];
                        if(child_node.cmp_to_best_path == 0) {
                          /* If the component was found when on the best path,
                           * handle the found automorphism as the other
                           * best path automorphisms */
                          if(old_info.in_best_path)
                            goto handle_best_path_automorphism;
                          /* Otherwise, we do not remember the automorhism as
                           * we didn't memorize the path that was invariant
                           * equal to the best one and passed through the
                           * component.
                           * Thus we can only backtrack to the previous level */
                          child_node.cmp_to_best_path = -1;
                          if(!child_node.fp_cert_equal)
                            {
                              continue;
                            }
                        }
                        else {
                          assert(child_node.cmp_to_best_path > 0);
                          if(old_info.in_best_path)
                            {
                              stats.nof_canupdates++;
                              /*
                               * Update canonical labeling and its inverse
                               */
                              for(unsigned int i = 0; i < N; i++) {
                                if(p.get_cell(p.elements[i])->is_unit()) {
                                  best_path_labeling[p.elements[i]] = i;
                                  best_path_labeling_inv[i] = p.elements[i];
                                }
                              }
                              //update_labeling_and_its_inverse(best_path_labeling, best_path_labeling_inv);
                              /* Reset best path automorphism */
                              reset_permutation(best_path_automorphism);
                              /* Reset best path orbit structure */
                              best_path_orbits.reset();
                              /* Mark to be the best one and save prefix */
                              unsigned int postfix_start = cep.creation_level;
                              assert(postfix_start < best_path_info.size());
                              while(p.get_cell(best_path_info[postfix_start].splitting_element)->is_unit()) {
                                postfix_start++;
                                assert(postfix_start < best_path_info.size());
                              }
                              unsigned int postfix_start_cert = best_path_info[postfix_start].certificate_index;
                              std::vector best_path_temp = best_path_info;
                              best_path_info.clear();
                              for(unsigned int i = 0; i < search_stack.size(); i++) {
                                TreeNode& ss_info = search_stack[i];
                                PathInfo  bp_info;
                                ss_info.cmp_to_best_path = 0;
                                ss_info.in_best_path = true;
                                bp_info.splitting_element = ss_info.split_element;
                                bp_info.certificate_index = ss_info.certificate_index;
                                bp_info.subcertificate_length = ss_info.subcertificate_length;
                                bp_info.eqref_hash = ss_info.eqref_hash;
                                best_path_info.push_back(bp_info);
                              }
                              /* Copy the postfix of the previous best path */
                              for(unsigned int i = postfix_start;
                                  i < best_path_temp.size();
                                  i++)
                                {
                                  best_path_info.push_back(best_path_temp[i]);
                                  best_path_info[best_path_info.size()-1].certificate_index =
                                    best_path_info[best_path_info.size()-2].certificate_index +
                                    best_path_info[best_path_info.size()-2].subcertificate_length;
                                }
                              std::vector certificate_best_path_old = certificate_best_path;
                              certificate_best_path = certificate_current_path;
                              for(unsigned int i = postfix_start_cert;  i < certificate_best_path_old.size(); i++)
                                certificate_best_path.push_back(certificate_best_path_old[i]);
                              assert(certificate_best_path.size() == best_path_info.back().certificate_index + best_path_info.back().subcertificate_length);
                              /* Backtrack to the previous level */
                              continue;
                            }
                        }
                      }
                  }

                  /* No backtracking performed, go to next componenet */
                  cr_level = cep.next_cr_level;
                  cr_cep_index = cep.next_cep_index;
                }

              /* Check if the current component has been split into
               * new non-uniformity subcomponents */
              //if(nucr_find_first_component(cr_level) == true and
              // p.nof_discrete_cells() + cr_component_elements <
              // cr_cep_stack[cr_cep_index].discrete_cell_limit)
              if(nucr_find_first_component(cr_level, cr_component,
                                           cr_component_elements,
                                           next_split_cell) == true and
                 p.nof_discrete_cells() + cr_component_elements <
                 cr_cep_stack[cr_cep_index].discrete_cell_limit)
                {
                  const unsigned int next_cr_level =
                    p.cr_split_level(cr_level, cr_component);
                  CR_CEP cep;
                  cep.creation_level = search_stack.size();
                  cep.discrete_cell_limit =
                    p.nof_discrete_cells() + cr_component_elements;
                  cep.next_cr_level = cr_level;
                  cep.next_cep_index = cr_cep_index;
                  cep.first_checked = false;
                  cep.best_checked = false;
                  cr_cep_index = cr_cep_stack.size();
                  cr_cep_stack.push_back(cep);
                  cr_level = next_cr_level;
                }
            }


          /*
           * Build the next node info
           */
          /* Find the next cell to be splitted */
          if(!next_split_cell)
            next_split_cell = find_next_cell_to_be_splitted(p.get_cell(p.elements[current_node.split_cell_first]));
          //Partition::Cell * const next_split_cell = find_next_cell_to_be_splitted(p.get_cell(p.elements[current_node.split_cell_first]));
          child_node.split_cell_first = next_split_cell->first;
          child_node.split_element = TreeNode::SPLIT_START;
          child_node.certificate_index = certificate_index;
          child_node.partition_bt_point = p.set_backtrack_point();
          child_node.long_prune_redundant.clear();
          child_node.long_prune_begin = current_node.long_prune_begin;

          /* Save component recursion info for backtracking */
          child_node.cr_level = cr_level;
          child_node.cr_cep_stack_size = cr_cep_stack.size();
          child_node.cr_cep_index = cr_cep_index;

          /* Initialize needs_long_prune to prevent a gcc-ubsan warning */
          child_node.needs_long_prune = true;

          search_stack.push_back(child_node);
          continue;
        }

      /*
       * A leaf node not in the first path or equivalent to the first path
       */



      if(child_node.cmp_to_best_path > 0)
        {
          /*
           * A new, better representative found
           */
          //fprintf(stdout, "Level %u: NEW BEST\n", child_level); fflush(stdout);
          stats.nof_canupdates++;
          /*
           * Update canonical labeling and its inverse
           */
          update_labeling_and_its_inverse(best_path_labeling,
                                          best_path_labeling_inv);
          /* Reset best path automorphism */
          reset_permutation(best_path_automorphism);
          /* Reset best path orbit structure */
          best_path_orbits.reset();
          /*
           * Mark the current path to be the best one and save it
           */
          const unsigned int base_size = search_stack.size();
          assert(current_level+1 == base_size);
          best_path_info.clear();
          for(unsigned int i = 0; i < base_size; i++) {
            search_stack[i].cmp_to_best_path = 0;
            search_stack[i].in_best_path = true;
            PathInfo path_info;
            path_info.splitting_element = search_stack[i].split_element;
            path_info.certificate_index = search_stack[i].certificate_index;
            path_info.subcertificate_length = search_stack[i].subcertificate_length;
            path_info.eqref_hash = search_stack[i].eqref_hash;
            best_path_info.push_back(path_info);
          }
          certificate_best_path = certificate_current_path;
          /*
           * Backtrack to the previous level
           */
          continue;
        }


    handle_best_path_automorphism:
      /*
       *
       * Best path automorphism handling
       *
       */
      {

        /*
         * Equal to the previous best path
         */
        if(p.is_discrete())
          {
#if defined(BLISS_CONSISTENCY_CHECKS)
            /* Verify that the automorphism is correctly built */
            for(unsigned int i = 0; i < N; i++)
              assert(best_path_automorphism[i] ==
                     p.elements[best_path_labeling[i]]);
#endif
          }
        else
          {
            /* An automorphism that was found before the partition was discrete.
             * Set the image of all elements in non-disrete cells accordingly */
            for(Partition::Cell* c = p.first_nonsingleton_cell; c;
                c = c->next_nonsingleton) {
              for(unsigned int i = c->first; i < c->first+c->length; i++)
                if(p.get_cell(p.elements[best_path_labeling[p.elements[i]]])->is_unit())
                  best_path_automorphism[p.elements[best_path_labeling[p.elements[i]]]] = p.elements[i];
                else
                  best_path_automorphism[p.elements[i]] = p.elements[i];
            }
          }

#if defined(BLISS_VERIFY_AUTOMORPHISMS)
        /* Verify that it really is an automorphism */
        if(!is_automorphism(best_path_automorphism))
          fatal_error("Best path automorhism validation check failed");
#endif

        unsigned int gca_level_with_first = 0;
        for(unsigned int i = search_stack.size(); i > 0; i--) {
          if((int)first_path_info[gca_level_with_first].splitting_element !=
             search_stack[gca_level_with_first].split_element)
            break;
          gca_level_with_first++;
        }

        unsigned int gca_level_with_best = 0;
        for(unsigned int i = search_stack.size(); i > 0; i--) {
          if((int)best_path_info[gca_level_with_best].splitting_element !=
             search_stack[gca_level_with_best].split_element)
            break;
          gca_level_with_best++;
        }

        if(opt_use_long_prune)
          {
            /* Record automorphism */
            long_prune_add_automorphism(best_path_automorphism);
          }

        /*
         * Update orbit information
         */
        update_orbit_information(best_path_orbits, best_path_automorphism);

        /*
         * Update orbit information
         */
        const unsigned int nof_old_orbits = first_path_orbits.nof_orbits();
        update_orbit_information(first_path_orbits, best_path_automorphism);
        if(nof_old_orbits != first_path_orbits.nof_orbits())
          {
            /* Some orbits were merged */
            /* Report automorphism */
            if(report)
              report(get_nof_vertices(), best_path_automorphism);
            /* Update statistics */
            stats.nof_generators++;
          }

        /*
         * Compute backjumping level
         */
        unsigned int backjumping_level = current_level+1-1;
        if(!first_path_orbits.is_minimal_representative(search_stack[gca_level_with_first].split_element))
          {
            backjumping_level = gca_level_with_first;
          }
        else
          {
            assert(!best_path_orbits.is_minimal_representative(search_stack[gca_level_with_best].split_element));
            backjumping_level = gca_level_with_best;
          }
        /* Backtrack */
        search_stack.resize(backjumping_level + 1);
        continue;
      }


      _INTERNAL_ERROR();


    handle_first_path_automorphism:
      /*
       *
       * A first-path automorphism: aut[i] = elements[first_path_labeling[i]]
       *
       */


      if(p.is_discrete())
        {
#if defined(BLISS_CONSISTENCY_CHECKS)
          /* Verify that the complete automorphism is correctly built */
          for(unsigned int i = 0; i < N; i++)
            assert(first_path_automorphism[i] ==
                   p.elements[first_path_labeling[i]]);
#endif
        }
      else
        {
          /* An automorphism that was found before the partition was discrete.
           * Set the image of all elements in non-disrete cells accordingly */
          for(Partition::Cell* c = p.first_nonsingleton_cell; c;
              c = c->next_nonsingleton) {
            for(unsigned int i = c->first; i < c->first+c->length; i++)
              if(p.get_cell(p.elements[first_path_labeling[p.elements[i]]])->is_unit())
                first_path_automorphism[p.elements[first_path_labeling[p.elements[i]]]] = p.elements[i];
              else
                first_path_automorphism[p.elements[i]] = p.elements[i];
          }
        }

#if defined(BLISS_VERIFY_AUTOMORPHISMS)
      /* Verify that it really is an automorphism */
      if(!is_automorphism(first_path_automorphism))
        fatal_error("First path automorphism validation check failed");
#endif

      if(opt_use_long_prune)
        {
          long_prune_add_automorphism(first_path_automorphism);
        }

      /*
       * Update orbit information
       */
      update_orbit_information(first_path_orbits, first_path_automorphism);

      /*
       * Compute backjumping level
       */
      for(unsigned int i = 0; i < search_stack.size(); i++) {
        TreeNode& n = search_stack[i];
        if(n.fp_on) {
          ;
        } else {
          n.fp_extendable = TreeNode::YES;
        }
      }

      /* Report automorphism by calling the user defined hook function */
      if(report)
        report(get_nof_vertices(), first_path_automorphism);
      /* Update statistics */
      stats.nof_generators++;
      continue;

    } /* while(!search_stack.empty()) */




  /* Free "long prune" technique memory */
  if(opt_use_long_prune)
    long_prune_deallocate();

  /* Release component recursion data in partition */
  if(opt_use_comprec)
    p.cr_free();
}




void
AbstractGraph::find_automorphisms(Stats& stats,
                                  const std::function& report,
                                  const std::function& terminate)
{
  search(false, stats, report, terminate);

  delete[] first_path_labeling; first_path_labeling = nullptr;
  delete[] best_path_labeling; best_path_labeling = nullptr;
}


const unsigned int *
AbstractGraph::canonical_form(Stats& stats,
                              const std::function& report,
                              const std::function& terminate)
{
  search(true, stats, report, terminate);

  return best_path_labeling;
}




/*-------------------------------------------------------------------------
 *
 * Routines for directed graphs
 *
 *-------------------------------------------------------------------------*/

Digraph::Vertex::Vertex()
{
  color = 0;
}


Digraph::Vertex::~Vertex()
{
  ;
}


void
Digraph::Vertex::add_edge_to(const unsigned int other_vertex)
{
  edges_out.push_back(other_vertex);
}


void
Digraph::Vertex::add_edge_from(const unsigned int other_vertex)
{
  edges_in.push_back(other_vertex);
}


void
Digraph::Vertex::remove_duplicate_edges(std::vector& tmp)
{
#if defined(BLISS_CONSISTENCY_CHECKS)
  /* Pre-conditions  */
  for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
  for(std::vector::iterator iter = edges_out.begin();
      iter != edges_out.end(); )
    {
      const unsigned int dest_vertex = *iter;
      if(tmp[dest_vertex] == true)
        {
          /* A duplicate edge found! */
          iter = edges_out.erase(iter);
        }
      else
        {
          /* Not seen earlier, mark as seen */
          tmp[dest_vertex] = true;
          iter++;
        }
    }

  /* Clear tmp */
  for(std::vector::iterator iter = edges_out.begin();
      iter != edges_out.end();
      iter++)
    {
      tmp[*iter] = false;
    }

  for(std::vector::iterator iter = edges_in.begin();
      iter != edges_in.end(); )
    {
      const unsigned int dest_vertex = *iter;
      if(tmp[dest_vertex] == true)
        {
          /* A duplicate edge found! */
          iter = edges_in.erase(iter);
        }
      else
        {
          /* Not seen earlier, mark as seen */
          tmp[dest_vertex] = true;
          iter++;
        }
    }

  /* Clear tmp */
  for(std::vector::iterator iter = edges_in.begin();
      iter != edges_in.end();
      iter++)
    {
      tmp[*iter] = false;
    }
#if defined(BLISS_CONSISTENCY_CHECKS)
  /* Post-conditions  */
  for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
}


/**
 * Sort the edges entering and leaving the vertex according to
 * the vertex number of the other edge end.
 * Time complexity: O(e log(e)), where e is the number of edges
 * entering/leaving the vertex.
 */
void
Digraph::Vertex::sort_edges()
{
  std::sort(edges_in.begin(), edges_in.end());
  std::sort(edges_out.begin(), edges_out.end());
}





/*-------------------------------------------------------------------------
 *
 * Constructor and destructor for directed graphs
 *
 *-------------------------------------------------------------------------*/


Digraph::Digraph(const unsigned int nof_vertices)
{
  vertices.resize(nof_vertices);
  sh = shs_flm;
}


Digraph::~Digraph()
{
  ;
}


unsigned int
Digraph::add_vertex(const unsigned int color)
{
  const unsigned int new_vertex_num = vertices.size();
  vertices.resize(new_vertex_num + 1);
  vertices.back().color = color;
  return new_vertex_num;
}


void
Digraph::add_edge(const unsigned int vertex1, const unsigned int vertex2)
{
  if(vertex1 >= vertices.size() or vertex2 >= vertices.size())
    throw std::runtime_error("out of bounds vertex number");
  //assert(vertex1 < get_nof_vertices());
  //assert(vertex2 < get_nof_vertices());
  vertices[vertex1].add_edge_to(vertex2);
  vertices[vertex2].add_edge_from(vertex1);
}


void
Digraph::change_color(const unsigned int vertex, const unsigned int new_color)
{
  assert(vertex < get_nof_vertices());
  vertices[vertex].color = new_color;
}


void
Digraph::sort_edges()
{
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    vertices[i].sort_edges();
}


int
Digraph::cmp(Digraph& other)
{
  /* Compare the numbers of vertices */
  if(get_nof_vertices() < other.get_nof_vertices())
    return -1;
  if(get_nof_vertices() > other.get_nof_vertices())
    return 1;
  /* Compare vertex colors */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      if(vertices[i].color < other.vertices[i].color)
        return -1;
      if(vertices[i].color > other.vertices[i].color)
        return 1;
    }
  /* Compare vertex degrees */
  remove_duplicate_edges();
  other.remove_duplicate_edges();
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      if(vertices[i].nof_edges_in() < other.vertices[i].nof_edges_in())
        return -1;
      if(vertices[i].nof_edges_in() > other.vertices[i].nof_edges_in())
        return 1;
      if(vertices[i].nof_edges_out() < other.vertices[i].nof_edges_out())
        return -1;
      if(vertices[i].nof_edges_out() > other.vertices[i].nof_edges_out())
        return 1;
    }
  /* Compare edges */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      Vertex& v1 = vertices[i];
      Vertex& v2 = other.vertices[i];
      v1.sort_edges();
      v2.sort_edges();
      std::vector::const_iterator ei1 = v1.edges_in.begin();
      std::vector::const_iterator ei2 = v2.edges_in.begin();
      while(ei1 != v1.edges_in.end())
        {
          if(*ei1 < *ei2)
            return -1;
          if(*ei1 > *ei2)
            return 1;
          ei1++;
          ei2++;
        }
      ei1 = v1.edges_out.begin();
      ei2 = v2.edges_out.begin();
      while(ei1 != v1.edges_out.end())
        {
          if(*ei1 < *ei2)
            return -1;
          if(*ei1 > *ei2)
            return 1;
          ei1++;
          ei2++;
        }
    }
  return 0;
}




Digraph*
Digraph::permute(const std::vector& perm) const
{
  Digraph* const g = new Digraph(get_nof_vertices());
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v = vertices[i];
      g->change_color(perm[i], v.color);
      for(std::vector::const_iterator ei = v.edges_out.begin();
          ei != v.edges_out.end();
          ei++)
        {
          g->add_edge(perm[i], perm[*ei]);
        }
    }
  g->sort_edges();
  return g;
}


Digraph*
Digraph::permute(const unsigned int* const perm) const
{
  Digraph* const g = new Digraph(get_nof_vertices());
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex &v = vertices[i];
      g->change_color(perm[i], v.color);
      for(std::vector::const_iterator ei = v.edges_out.begin();
          ei != v.edges_out.end();
          ei++)
        {
          g->add_edge(perm[i], perm[*ei]);
        }
    }
  g->sort_edges();
  return g;
}


void
Digraph::remove_duplicate_edges()
{
  std::vector tmp(get_nof_vertices(), false);

  for(std::vector::iterator vi = vertices.begin();
      vi != vertices.end();
      vi++)
    {
#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)
      for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
      (*vi).remove_duplicate_edges(tmp);
    }
}





/*-------------------------------------------------------------------------
 *
 * Get a hash value for the graph.
 *
 *-------------------------------------------------------------------------*/

unsigned int
Digraph::get_hash()
{
  remove_duplicate_edges();
  sort_edges();

  UintSeqHash h;

  h.update(get_nof_vertices());

  /* Hash the color of each vertex */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      h.update(vertices[i].color);
    }

  /* Hash the edges */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      Vertex &v = vertices[i];
      for(std::vector::const_iterator ei = v.edges_out.begin();
          ei != v.edges_out.end();
          ei++)
        {
          h.update(i);
          h.update(*ei);
        }
    }

  return h.get_value();
}


/*-------------------------------------------------------------------------
 *
 * Partition independent invariants
 *
 *-------------------------------------------------------------------------*/

unsigned int
Digraph::vertex_color_invariant(const Digraph* const g, const unsigned int vnum)
{
  return g->vertices[vnum].color;
}

unsigned int
Digraph::indegree_invariant(const Digraph* const g, const unsigned int vnum)
{
  return g->vertices[vnum].nof_edges_in();
}

unsigned int
Digraph::outdegree_invariant(const Digraph* const g, const unsigned int vnum)
{
  return g->vertices[vnum].nof_edges_out();
}

unsigned int
Digraph::selfloop_invariant(const Digraph* const g, const unsigned int vnum)
{
  /* Quite inefficient but luckily not in the critical path */
  const Vertex& v = g->vertices[vnum];
  for(std::vector::const_iterator ei = v.edges_out.begin();
      ei != v.edges_out.end();
      ei++)
    {
      if(*ei == vnum)
        return 1;
    }
  return 0;
}





/*-------------------------------------------------------------------------
 *
 * Refine the partition p according to a partition independent invariant
 *
 *-------------------------------------------------------------------------*/

bool
Digraph::refine_according_to_invariant(unsigned int (*inv)(const Digraph* const g,
                                                           const unsigned int v))
{
  bool refined = false;

  for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; )
    {

      Partition::Cell* const next_cell = cell->next_nonsingleton;
      const unsigned int* ep = p.elements + cell->first;
      for(unsigned int i = cell->length; i > 0; i--, ep++)
        {
          unsigned int ival = inv(this, *ep);
          p.invariant_values[*ep] = ival;
          if(ival > cell->max_ival) {
            cell->max_ival = ival;
            cell->max_ival_count = 1;
          }
          else if(ival == cell->max_ival) {
            cell->max_ival_count++;
          }
        }
      Partition::Cell* const last_new_cell = p.zplit_cell(cell, true);
      refined |= (last_new_cell != cell);
      cell = next_cell;
    }

  return refined;
}





/*-------------------------------------------------------------------------
 *
 * Split the neighbourhood of a cell according to the equitable invariant
 *
 *-------------------------------------------------------------------------*/

bool
Digraph::split_neighbourhood_of_cell(Partition::Cell* const cell)
{


  const bool was_equal_to_first = refine_equal_to_first;

  if(compute_eqref_hash)
    {
      eqref_hash.update(cell->first);
      eqref_hash.update(cell->length);
    }

  const unsigned int* ep = p.elements + cell->first;
  for(unsigned int i = cell->length; i > 0; i--)
    {
      const Vertex& v = vertices[*ep++];

      std::vector::const_iterator ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j != 0; j--)
        {
          const unsigned int dest_vertex = *ei++;
          Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex);
          if(neighbour_cell->is_unit())
            continue;
          const unsigned int ival = ++p.invariant_values[dest_vertex];
          if(ival > neighbour_cell->max_ival) {
            neighbour_cell->max_ival = ival;
            neighbour_cell->max_ival_count = 1;
            if(ival == 1)
              neighbour_heap.insert(neighbour_cell->first);
          }
          else if(ival == neighbour_cell->max_ival) {
            neighbour_cell->max_ival_count++;
          }
        }
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]);

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }


      Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true);

      /* Update certificate and hash if needed */
      const Partition::Cell* c = neighbour_cell;
      while(1)
        {
          if(in_search)
            {
              /* Build certificate */
              cert_add_redundant(CERT_SPLIT, c->first, c->length);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
          if(compute_eqref_hash)
            {
              eqref_hash.update(c->first);
              eqref_hash.update(c->length);
            }
          if(c == last_new_cell)
            break;
          c = c->next;
        }
    }

  if(cell->is_in_splitting_queue())
    {
      return false;
    }


  ep = p.elements + cell->first;
  for(unsigned int i = cell->length; i > 0; i--)
    {
      const Vertex& v = vertices[*ep++];

      std::vector::const_iterator ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          const unsigned int dest_vertex = *ei++;
          Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex);
          if(neighbour_cell->is_unit())
            continue;
          const unsigned int ival = ++p.invariant_values[dest_vertex];
          if(ival > neighbour_cell->max_ival)
            {
              neighbour_cell->max_ival = ival;
              neighbour_cell->max_ival_count = 1;
              if(ival == 1)
                neighbour_heap.insert(neighbour_cell->first);
            }
          else if(ival == neighbour_cell->max_ival) {
            neighbour_cell->max_ival_count++;
          }
        }
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]);

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }

      Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true);

      /* Update certificate and hash if needed */
      const Partition::Cell* c = neighbour_cell;
      while(1)
        {
          if(in_search)
            {
              /* Build certificate */
              cert_add_redundant(CERT_SPLIT, c->first, c->length);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
          if(compute_eqref_hash)
            {
              eqref_hash.update(c->first);
              eqref_hash.update(c->length);
            }
          if(c == last_new_cell)
            break;
          c = c->next;
        }
    }


  if(refine_compare_certificate and
     (refine_equal_to_first == false) and
     (refine_cmp_to_best < 0))
    return true;

  return false;

 worse_exit:
  /* Clear neighbour heap */
  UintSeqHash rest;
  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]);
      if(opt_use_failure_recording and was_equal_to_first)
        {
          rest.update(neighbour_cell->first);
          rest.update(neighbour_cell->length);
          rest.update(neighbour_cell->max_ival);
          rest.update(neighbour_cell->max_ival_count);
        }
      neighbour_cell->max_ival = 0;
      neighbour_cell->max_ival_count = 0;
      p.clear_ivs(neighbour_cell);
    }
  if(opt_use_failure_recording and was_equal_to_first)
    {
      for(unsigned int i = p.splitting_queue.size(); i > 0; i--)
        {
          Partition::Cell* const cell = p.splitting_queue.pop_front();
          rest.update(cell->first);
          rest.update(cell->length);
          p.splitting_queue.push_back(cell);
        }
      rest.update(failure_recording_fp_deviation);
      failure_recording_fp_deviation = rest.get_value();
    }

   return true;
}


bool
Digraph::split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell)
{


  const bool was_equal_to_first = refine_equal_to_first;

  if(compute_eqref_hash)
    {
      eqref_hash.update(0x87654321);
      eqref_hash.update(unit_cell->first);
      eqref_hash.update(1);
    }

  const Vertex& v = vertices[p.elements[unit_cell->first]];

  /*
   * Phase 1
   * Refine neighbours according to the edges that leave the vertex v
   */
  std::vector::const_iterator ei = v.edges_out.begin();
  for(unsigned int j = v.nof_edges_out(); j > 0; j--)
    {
      const unsigned int dest_vertex = *ei++;
      Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex);

      if(neighbour_cell->is_unit()) {
        if(in_search) {
          /* Remember neighbour in order to generate certificate */
          neighbour_heap.insert(neighbour_cell->first);
        }
        continue;
      }
      if(neighbour_cell->max_ival_count == 0)
        {
          neighbour_heap.insert(neighbour_cell->first);
        }
      neighbour_cell->max_ival_count++;

      unsigned int* const swap_position =
        p.elements + neighbour_cell->first + neighbour_cell->length -
        neighbour_cell->max_ival_count;
      *p.in_pos[dest_vertex] = *swap_position;
      p.in_pos[*swap_position] = p.in_pos[dest_vertex];
      *swap_position = dest_vertex;
      p.in_pos[dest_vertex] = swap_position;
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]);

#if defined(BLISS_CONSISTENCY_CHECKS)
      assert(neighbour_cell->first == start);
      if(neighbour_cell->is_unit()) {
        assert(neighbour_cell->max_ival_count == 0);
      } else {
        assert(neighbour_cell->max_ival_count > 0);
        assert(neighbour_cell->max_ival_count <= neighbour_cell->length);
      }
#endif

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }

      if(neighbour_cell->length > 1 and
         neighbour_cell->max_ival_count != neighbour_cell->length)
        {

          Partition::Cell* const new_cell =
            p.aux_split_in_two(neighbour_cell,
                               neighbour_cell->length -
                               neighbour_cell->max_ival_count);
          unsigned int* ep = p.elements + new_cell->first;
          unsigned int* const lp = p.elements+new_cell->first+new_cell->length;
          while(ep < lp)
            {
              p.element_to_cell_map[*ep] = new_cell;
              ep++;
            }
          neighbour_cell->max_ival_count = 0;


          if(compute_eqref_hash)
            {
              /* Update hash */
              eqref_hash.update(neighbour_cell->first);
              eqref_hash.update(neighbour_cell->length);
              eqref_hash.update(0);
              eqref_hash.update(new_cell->first);
              eqref_hash.update(new_cell->length);
              eqref_hash.update(1);
            }

          /* Add cells in splitting_queue */
          if(neighbour_cell->is_in_splitting_queue()) {
            /* Both cells must be included in splitting_queue in order
               to have refinement to equitable partition */
            p.splitting_queue_add(new_cell);
          } else {
            Partition::Cell *min_cell, *max_cell;
          if(neighbour_cell->length <= new_cell->length) {
            min_cell = neighbour_cell;
            max_cell = new_cell;
          } else {
            min_cell = new_cell;
            max_cell = neighbour_cell;
          }
          /* Put the smaller cell in splitting_queue */
           p.splitting_queue_add(min_cell);
          if(max_cell->is_unit()) {
            /* Put the "larger" cell also in splitting_queue */
            p.splitting_queue_add(max_cell);
          }
        }
        /* Update pointer for certificate generation */
        neighbour_cell = new_cell;
      }
      else
        {
          neighbour_cell->max_ival_count = 0;
        }

      /*
       * Build certificate if required
       */
      if(in_search)
        {
          for(unsigned int i = neighbour_cell->first,
                j = neighbour_cell->length;
              j > 0;
              j--, i++)
            {
              /* Build certificate */
              cert_add(CERT_EDGE, unit_cell->first, i);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
        } /* if(in_search) */
    } /* while(!neighbour_heap.is_empty()) */

  /*
   * Phase 2
   * Refine neighbours according to the edges that enter the vertex v
   */
  ei = v.edges_in.begin();
  for(unsigned int j = v.nof_edges_in(); j > 0; j--)
    {
      const unsigned int dest_vertex = *ei++;
      Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex);

      if(neighbour_cell->is_unit()) {
        if(in_search) {
          neighbour_heap.insert(neighbour_cell->first);
        }
        continue;
      }
      if(neighbour_cell->max_ival_count == 0)
        {
          neighbour_heap.insert(neighbour_cell->first);
        }
      neighbour_cell->max_ival_count++;

      unsigned int* const swap_position =
        p.elements + neighbour_cell->first + neighbour_cell->length -
        neighbour_cell->max_ival_count;
      *p.in_pos[dest_vertex] = *swap_position;
      p.in_pos[*swap_position] = p.in_pos[dest_vertex];
      *swap_position = dest_vertex;
      p.in_pos[dest_vertex] = swap_position;
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]);

#if defined(BLISS_CONSISTENCY_CHECKS)
      assert(neighbour_cell->first == start);
      if(neighbour_cell->is_unit()) {
        assert(neighbour_cell->max_ival_count == 0);
      } else {
        assert(neighbour_cell->max_ival_count > 0);
        assert(neighbour_cell->max_ival_count <= neighbour_cell->length);
      }
#endif

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }

      if(neighbour_cell->length > 1 and
         neighbour_cell->max_ival_count != neighbour_cell->length)
        {
          Partition::Cell* const new_cell =
            p.aux_split_in_two(neighbour_cell,
                               neighbour_cell->length -
                               neighbour_cell->max_ival_count);
          unsigned int* ep = p.elements + new_cell->first;
          unsigned int* const lp = p.elements+new_cell->first+new_cell->length;
          while(ep < lp) {
            p.element_to_cell_map[*ep] = new_cell;
            ep++;
          }
          neighbour_cell->max_ival_count = 0;


          if(compute_eqref_hash)
            {
              eqref_hash.update(neighbour_cell->first);
              eqref_hash.update(neighbour_cell->length);
              eqref_hash.update(0);
              eqref_hash.update(new_cell->first);
              eqref_hash.update(new_cell->length);
              eqref_hash.update(1);
            }

          /* Add cells in splitting_queue */
          if(neighbour_cell->is_in_splitting_queue()) {
            /* Both cells must be included in splitting_queue in order
               to have refinement to equitable partition */
            p.splitting_queue_add(new_cell);
          } else {
            Partition::Cell *min_cell, *max_cell;
            if(neighbour_cell->length <= new_cell->length) {
              min_cell = neighbour_cell;
              max_cell = new_cell;
            } else {
              min_cell = new_cell;
              max_cell = neighbour_cell;
            }
            /* Put the smaller cell in splitting_queue */
            p.splitting_queue_add(min_cell);
            if(max_cell->is_unit()) {
              /* Put the "larger" cell also in splitting_queue */
              p.splitting_queue_add(max_cell);
            }
          }
          /* Update pointer for certificate generation */
          neighbour_cell = new_cell;
        }
      else
        {
          neighbour_cell->max_ival_count = 0;
        }

      /*
       * Build certificate if required
       */
      if(in_search)
        {
          for(unsigned int i = neighbour_cell->first,
                j = neighbour_cell->length;
              j > 0;
              j--, i++)
            {
              /* Build certificate */
              cert_add(CERT_EDGE, i, unit_cell->first);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
        } /* if(in_search) */
    } /* while(!neighbour_heap.is_empty()) */

  if(refine_compare_certificate and
     (refine_equal_to_first == false) and
     (refine_cmp_to_best < 0))
    return true;

  return false;

 worse_exit:
  /* Clear neighbour heap */
  UintSeqHash rest;
  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]);
      if(opt_use_failure_recording and was_equal_to_first)
        {
          rest.update(neighbour_cell->first);
          rest.update(neighbour_cell->length);
          rest.update(neighbour_cell->max_ival_count);
        }
      neighbour_cell->max_ival_count = 0;
    }
  if(opt_use_failure_recording and was_equal_to_first)
    {
      rest.update(failure_recording_fp_deviation);
      failure_recording_fp_deviation = rest.get_value();
    }
  return true;
}





/*-------------------------------------------------------------------------
 *
 * Check whether the current partition p is equitable.
 * Performance: very slow, use only for debugging purposes.
 *
 *-------------------------------------------------------------------------*/

bool
Digraph::is_equitable() const
{
  const unsigned int N = get_nof_vertices();
  if(N == 0)
    return true;

  std::vector first_count = std::vector(N, 0);
  std::vector other_count = std::vector(N, 0);

  /*
   * Check equitabledness w.r.t. outgoing edges
   */
  for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next)
    {
      if(cell->is_unit())
        continue;

      unsigned int* ep = p.elements + cell->first;
      const Vertex& first_vertex = vertices[*ep++];

      /* Count outgoing edges of the first vertex for cells */
      for(std::vector::const_iterator ei =
            first_vertex.edges_out.begin();
          ei != first_vertex.edges_out.end();
          ei++)
        {
          first_count[p.get_cell(*ei)->first]++;
        }

      /* Count and compare outgoing edges of the other vertices */
      for(unsigned int i = cell->length; i > 1; i--)
        {
          const Vertex &vertex = vertices[*ep++];
          for(std::vector::const_iterator ei =
                vertex.edges_out.begin();
              ei != vertex.edges_out.end();
              ei++)
            {
              other_count[p.get_cell(*ei)->first]++;
            }
          for(Partition::Cell *cell2 = p.first_cell;
              cell2;
              cell2 = cell2->next)
            {
              if(first_count[cell2->first] != other_count[cell2->first])
                {
                  /* Not equitable */
                  return false;
                }
              other_count[cell2->first] = 0;
            }
        }
      /* Reset first_count */
      for(unsigned int i = 0; i < N; i++)
        first_count[i] = 0;
    }


  /*
   * Check equitabledness w.r.t. incoming edges
   */
  for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next)
    {
      if(cell->is_unit())
        continue;

      unsigned int* ep = p.elements + cell->first;
      const Vertex& first_vertex = vertices[*ep++];

      /* Count incoming edges of the first vertex for cells */
      for(std::vector::const_iterator ei =
            first_vertex.edges_in.begin();
          ei != first_vertex.edges_in.end();
          ei++)
        {
          first_count[p.get_cell(*ei)->first]++;
        }

      /* Count and compare incoming edges of the other vertices */
      for(unsigned int i = cell->length; i > 1; i--)
        {
          const Vertex &vertex = vertices[*ep++];
          for(std::vector::const_iterator ei =
                vertex.edges_in.begin();
              ei != vertex.edges_in.end();
              ei++)
            {
              other_count[p.get_cell(*ei)->first]++;
            }
          for(Partition::Cell *cell2 = p.first_cell;
              cell2;
              cell2 = cell2->next)
            {
              if(first_count[cell2->first] != other_count[cell2->first])
                {
                  /* Not equitable */
                  return false;
                }
              other_count[cell2->first] = 0;
            }
        }
      /* Reset first_count */
      for(unsigned int i = 0; i < N; i++)
        first_count[i] = 0;
    }
  return true;
}





/*-------------------------------------------------------------------------
 *
 * Build the initial equitable partition
 *
 *-------------------------------------------------------------------------*/

void
Digraph::make_initial_equitable_partition()
{
  refine_according_to_invariant(&vertex_color_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_according_to_invariant(&selfloop_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_according_to_invariant(&outdegree_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_according_to_invariant(&indegree_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_to_equitable();
  //p.print_signature(stderr); fprintf(stderr, "\n");
}





/*-------------------------------------------------------------------------
 *
 * Find the next cell to be splitted
 *
 *-------------------------------------------------------------------------*/

Partition::Cell*
Digraph::find_next_cell_to_be_splitted(Partition::Cell* cell)
{
  switch(sh) {
  case shs_f:   return sh_first();
  case shs_fs:  return sh_first_smallest();
  case shs_fl:  return sh_first_largest();
  case shs_fm:  return sh_first_max_neighbours();
  case shs_fsm: return sh_first_smallest_max_neighbours();
  case shs_flm: return sh_first_largest_max_neighbours();
  default:
    fatal_error("Internal error - unknown splitting heuristics");
    return 0;
  }
}

/** \internal
 * A splitting heuristic.
 * Returns the first nonsingleton cell in the current partition.
 * The argument \a cell is ignored.
 */
Partition::Cell*
Digraph::sh_first()
{
  Partition::Cell* best_cell = 0;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      best_cell = cell;
      break;
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first smallest nonsingleton cell in the current partition.
 * The argument \a cell is ignored.
 */
Partition::Cell*
Digraph::sh_first_smallest()
{
  Partition::Cell* best_cell = 0;
  unsigned int best_size = UINT_MAX;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      if(cell->length < best_size)
        {
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first largest nonsingleton cell in the current partition.
 * The argument \a cell is ignored.
 */
Partition::Cell*
Digraph::sh_first_largest()
{
  Partition::Cell* best_cell = 0;
  unsigned int best_size = 0;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      if(cell->length > best_size)
        {
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first nonsingleton cell with max number of neighbouring
 * nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Digraph::sh_first_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      int value = 0;
      const Vertex &v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei;
      ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          Partition::Cell * const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j > 0; j--)
        {
          Partition::Cell * const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      if(value > best_value)
        {
          best_value = value;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first smallest nonsingleton cell with max number of neighbouring
 * nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Digraph::sh_first_smallest_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  unsigned int best_size = UINT_MAX;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {

      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;

      int value = 0;
      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei;

      ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          Partition::Cell * const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell * const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j > 0; j--)
        {
          Partition::Cell * const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell * const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      if((value > best_value) or
         (value == best_value and cell->length < best_size))
        {
          best_value = value;
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first largest nonsingleton cell with max number of neighbouring
 * nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Digraph::sh_first_largest_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  unsigned int best_size = 0;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {

      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;

      int value = 0;
      const Vertex &v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei;

      ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          Partition::Cell* const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j > 0; j--)
        {
          Partition::Cell* const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }

      if((value > best_value) ||
         (value == best_value && cell->length > best_size))
        {
          best_value = value;
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}






/*------------------------------------------------------------------------
 *
 * Initialize the certificate size and memory
 *
 *-------------------------------------------------------------------------*/

void
Digraph::initialize_certificate()
{
  certificate_index = 0;
  certificate_current_path.clear();
  certificate_first_path.clear();
  certificate_best_path.clear();
}



/*
 * Check whether perm is an automorphism.
 * Slow, mainly for debugging and validation purposes.
 */
bool
Digraph::is_automorphism(unsigned int* const perm) const
{
  std::set > edges1;
  std::set > edges2;

#if defined(BLISS_CONSISTENCY_CHECKS)
  if(!is_permutation(get_nof_vertices(), perm))
    _INTERNAL_ERROR();
#endif

  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v1 = vertices[i];
      const Vertex& v2 = vertices[perm[i]];

      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges_in.cbegin();
          ei != v1.edges_in.cend();
          ei++)
        edges1.insert(perm[*ei]);
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges_in.cbegin();
          ei != v2.edges_in.cend();
          ei++)
        edges2.insert(*ei);
      if(!(edges1 == edges2))
        return false;

      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges_out.cbegin();
          ei != v1.edges_out.cend();
          ei++)
        edges1.insert(perm[*ei]);
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges_out.cbegin();
          ei != v2.edges_out.cend();
          ei++)
        edges2.insert(*ei);
      if(!(edges1 == edges2))
        return false;
    }

  return true;
}

bool
Digraph::is_automorphism(const std::vector& perm) const
{

  if(!(perm.size() == get_nof_vertices() and is_permutation(perm)))
    return false;

  std::set > edges1;
  std::set > edges2;

  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v1 = vertices[i];
      const Vertex& v2 = vertices[perm[i]];

      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges_in.begin();
          ei != v1.edges_in.end();
          ei++)
        edges1.insert(perm[*ei]);
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges_in.begin();
          ei != v2.edges_in.end();
          ei++)
        edges2.insert(*ei);
      if(!(edges1 == edges2))
        return false;

      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges_out.begin();
          ei != v1.edges_out.end();
          ei++)
        edges1.insert(perm[*ei]);
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges_out.begin();
          ei != v2.edges_out.end();
          ei++)
        edges2.insert(*ei);
      if(!(edges1 == edges2))
        return false;
    }

  return true;
}




bool
Digraph::nucr_find_first_component(const unsigned int level)
{

  cr_component.clear();
  cr_component_elements = 0;

  /* Find first non-discrete cell in the component level */
  Partition::Cell* first_cell = p.first_nonsingleton_cell;
  while(first_cell)
    {
      if(p.cr_get_level(first_cell->first) == level)
        break;
      first_cell = first_cell->next_nonsingleton;
    }

  /* The component is discrete, return false */
  if(!first_cell)
    return false;

  std::vector component;
  first_cell->max_ival = 1;
  component.push_back(first_cell);

  for(unsigned int i = 0; i < component.size(); i++)
    {
      Partition::Cell* const cell = component[i];

      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei;

      ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;
          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);

          /* Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Already marked to be in the same component? */
          if(neighbour_cell->max_ival == 1)
            continue;
          /* Is the neighbour at the same component recursion level? */
          if(p.cr_get_level(neighbour_cell->first) != level)
            continue;

          if(neighbour_cell->max_ival_count == 0)
            neighbour_heap.insert(neighbour_cell->first);
          neighbour_cell->max_ival_count++;
        }
      while(!neighbour_heap.is_empty())
        {
          const unsigned int start = neighbour_heap.remove();
          Partition::Cell* const neighbour_cell =
            p.get_cell(p.elements[start]);

          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          neighbour_cell->max_ival_count = 0;
          neighbour_cell->max_ival = 1;
          component.push_back(neighbour_cell);
        }

      ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;

          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);

          /* Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Already marked to be in the same component? */
          if(neighbour_cell->max_ival == 1)
            continue;
          /* Is the neighbour at the same component recursion level? */
          if(p.cr_get_level(neighbour_cell->first) != level)
            continue;

          if(neighbour_cell->max_ival_count == 0)
            neighbour_heap.insert(neighbour_cell->first);
          neighbour_cell->max_ival_count++;
        }
      while(!neighbour_heap.is_empty())
        {
          const unsigned int start = neighbour_heap.remove();
          Partition::Cell* const neighbour_cell =
            p.get_cell(p.elements[start]);

          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          neighbour_cell->max_ival_count = 0;
          neighbour_cell->max_ival = 1;
          component.push_back(neighbour_cell);
        }
    }

  for(unsigned int i = 0; i < component.size(); i++)
    {
      Partition::Cell* const cell = component[i];
      cell->max_ival = 0;
      cr_component.push_back(cell->first);
      cr_component_elements += cell->length;
    }

  /*
  if(verbstr and verbose_level > 2) {
    fprintf(verbstr, "NU-component with %lu cells and %u vertices\n",
            (long unsigned)cr_component.size(), cr_component_elements);
    fflush(verbstr);
  }
  */

  return true;
}





bool
Digraph::nucr_find_first_component(const unsigned int level,
                                 std::vector& component,
                                 unsigned int& component_elements,
                                 Partition::Cell*& sh_return)
{

  component.clear();
  component_elements = 0;
  sh_return = 0;
  unsigned int sh_first  = 0;
  unsigned int sh_size   = 0;
  unsigned int sh_nuconn = 0;

  /* Find first non-discrete cell in the component level */
  Partition::Cell* first_cell = p.first_nonsingleton_cell;
  while(first_cell)
    {
      if(p.cr_get_level(first_cell->first) == level)
        break;
      first_cell = first_cell->next_nonsingleton;
    }

  if(!first_cell)
    {
      /* The component is discrete, return false */
      return false;
    }

  std::vector comp;
  KStack neighbours;
  neighbours.init(get_nof_vertices());

  first_cell->max_ival = 1;
  comp.push_back(first_cell);

  for(unsigned int i = 0; i < comp.size(); i++)
    {
      Partition::Cell* const cell = comp[i];

      unsigned int nuconn = 1;

      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei;

      /*| Phase 1: outgoing edges */
      ei = v.edges_out.begin();
      for(unsigned int j = v.nof_edges_out(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;

          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);

          /* Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Is the neighbour at the same component recursion level? */
          //if(p.cr_get_level(neighbour_cell->first) != level)
          //  continue;
          if(neighbour_cell->max_ival_count == 0)
            neighbours.push(neighbour_cell);
          neighbour_cell->max_ival_count++;
        }
      while(!neighbours.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbours.pop();
          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          nuconn++;
          neighbour_cell->max_ival_count = 0;
          if(neighbour_cell->max_ival == 0) {
            comp.push_back(neighbour_cell);
            neighbour_cell->max_ival = 1;
          }
        }

      /*| Phase 2: incoming edges */
      ei = v.edges_in.begin();
      for(unsigned int j = v.nof_edges_in(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;
          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);
          /*| Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Is the neighbour at the same component recursion level? */
          //if(p.cr_get_level(neighbour_cell->first) != level)
          //  continue;
          if(neighbour_cell->max_ival_count == 0)
            neighbours.push(neighbour_cell);
          neighbour_cell->max_ival_count++;
        }
      while(!neighbours.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbours.pop();
          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          nuconn++;
          neighbour_cell->max_ival_count = 0;
          if(neighbour_cell->max_ival == 0) {
            comp.push_back(neighbour_cell);
            neighbour_cell->max_ival = 1;
          }
        }

      /*| Phase 3: splitting heuristics */
      switch(sh) {
      case shs_f:
        if(sh_return == 0 or
           cell->first <= sh_first) {
          sh_return = cell;
          sh_first = cell->first;
        }
        break;
      case shs_fs:
        if(sh_return == 0 or
           cell->length < sh_size or
           (cell->length == sh_size and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
        }
        break;
      case shs_fl:
        if(sh_return == 0 or
           cell->length > sh_size or
           (cell->length == sh_size and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
        }
        break;
      case shs_fm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_nuconn = nuconn;
        }
        break;
      case shs_fsm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and
            (cell->length < sh_size or
             (cell->length == sh_size and cell->first <= sh_first)))) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
          sh_nuconn = nuconn;
        }
        break;
      case shs_flm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and
            (cell->length > sh_size or
             (cell->length == sh_size and cell->first <= sh_first)))) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
          sh_nuconn = nuconn;
        }
        break;
      default:
        fatal_error("Internal error - unknown splitting heuristics");
        return 0;
      }
    }
  assert(sh_return);

  for(unsigned int i = 0; i < comp.size(); i++)
    {
      Partition::Cell* const cell = comp[i];
      cell->max_ival = 0;
      component.push_back(cell->first);
      component_elements += cell->length;
    }

  /*
  if(verbstr and verbose_level > 2) {
    fprintf(verbstr, "NU-component with %lu cells and %u vertices\n",
            (long unsigned)component.size(), component_elements);
    fflush(verbstr);
  }
  */

  return true;
}




/*-------------------------------------------------------------------------
 *
 * Routines for undirected graphs
 *
 *-------------------------------------------------------------------------*/

Graph::Vertex::Vertex()
{
  color = 0;
}


Graph::Vertex::~Vertex()
{
  ;
}


void
Graph::Vertex::add_edge(const unsigned int other_vertex)
{
  edges.push_back(other_vertex);
}


void
Graph::Vertex::remove_duplicate_edges(std::vector& tmp)
{
#if defined(BLISS_CONSISTENCY_CHECKS)
  /* Pre-conditions  */
  for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
  for(std::vector::iterator iter = edges.begin();
      iter != edges.end(); )
    {
      const unsigned int dest_vertex = *iter;
      if(tmp[dest_vertex] == true)
        {
          /* A duplicate edge found! */
          iter = edges.erase(iter);
        }
      else
        {
          /* Not seen earlier, mark as seen */
          tmp[dest_vertex] = true;
          iter++;
        }
    }

  /* Clear tmp */
  for(std::vector::iterator iter = edges.begin();
      iter != edges.end();
      iter++)
    {
      tmp[*iter] = false;
    }
#if defined(BLISS_CONSISTENCY_CHECKS)
  /* Post-conditions  */
  for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
}


/**
 * Sort the edges leaving the vertex according to
 * the vertex number of the other edge end.
 * Time complexity: O(e log(e)), where e is the number of edges
 * leaving the vertex.
 */
void
Graph::Vertex::sort_edges()
{
  std::sort(edges.begin(), edges.end());
}



/*-------------------------------------------------------------------------
 *
 * Constructor and destructor for undirected graphs
 *
 *-------------------------------------------------------------------------*/


Graph::Graph(const unsigned int nof_vertices)
{
  vertices.resize(nof_vertices);
  sh = shs_flm;
}


Graph::~Graph()
{
  ;
}


unsigned int
Graph::add_vertex(const unsigned int color)
{
  const unsigned int vertex_num = vertices.size();
  vertices.resize(vertex_num + 1);
  vertices.back().color = color;
  return vertex_num;
}


void
Graph::add_edge(const unsigned int vertex1, const unsigned int vertex2)
{
  //fprintf(stderr, "(%u,%u) ", vertex1, vertex2);
  if(vertex1 >= vertices.size() or vertex2 >= vertices.size())
    throw std::runtime_error("out of bounds vertex number");
  vertices[vertex1].add_edge(vertex2);
  vertices[vertex2].add_edge(vertex1);
}


void
Graph::change_color(const unsigned int vertex, const unsigned int color)
{
  vertices[vertex].color = color;
}


void
Graph::sort_edges()
{
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    vertices[i].sort_edges();
}


int
Graph::cmp(Graph& other)
{
  /* Compare the numbers of vertices */
  if(get_nof_vertices() < other.get_nof_vertices())
    return -1;
  if(get_nof_vertices() > other.get_nof_vertices())
    return 1;
  /* Compare vertex colors */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      if(vertices[i].color < other.vertices[i].color)
        return -1;
      if(vertices[i].color > other.vertices[i].color)
        return 1;
    }
  /* Compare vertex degrees */
  remove_duplicate_edges();
  other.remove_duplicate_edges();
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      if(vertices[i].nof_edges() < other.vertices[i].nof_edges())
        return -1;
      if(vertices[i].nof_edges() > other.vertices[i].nof_edges())
        return 1;
    }
  /* Compare edges */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      Vertex &v1 = vertices[i];
      Vertex &v2 = other.vertices[i];
      v1.sort_edges();
      v2.sort_edges();
      std::vector::const_iterator ei1 = v1.edges.begin();
      std::vector::const_iterator ei2 = v2.edges.begin();
      while(ei1 != v1.edges.end())
        {
          if(*ei1 < *ei2)
            return -1;
          if(*ei1 > *ei2)
            return 1;
          ei1++;
          ei2++;
        }
    }
  return 0;
}


Graph*
Graph::permute(const std::vector& perm) const
{
#if defined(BLISS_CONSISTENCY_CHECKS)
#endif

  Graph* const g = new Graph(get_nof_vertices());
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v = vertices[i];
      Vertex& permuted_v = g->vertices[perm[i]];
      permuted_v.color = v.color;
      for(std::vector::const_iterator ei = v.edges.begin();
          ei != v.edges.end();
          ei++)
        {
          const unsigned int dest_v = *ei;
          permuted_v.add_edge(perm[dest_v]);
        }
      permuted_v.sort_edges();
    }
  return g;
}

Graph*
Graph::permute(const unsigned int* perm) const
{
#if defined(BLISS_CONSISTENCY_CHECKS)
  if(!is_permutation(get_nof_vertices(), perm))
    _INTERNAL_ERROR();
#endif

  Graph* const g = new Graph(get_nof_vertices());
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v = vertices[i];
      Vertex& permuted_v = g->vertices[perm[i]];
      permuted_v.color = v.color;
      for(std::vector::const_iterator ei = v.edges.begin();
          ei != v.edges.end();
          ei++)
        {
          const unsigned int dest_v = *ei;
          permuted_v.add_edge(perm[dest_v]);
        }
      permuted_v.sort_edges();
    }
  return g;
}


/*-------------------------------------------------------------------------
 *
 * Get a hash value for the graph.
 *
 *-------------------------------------------------------------------------*/

unsigned int
Graph::get_hash()
{
  remove_duplicate_edges();
  sort_edges();

  UintSeqHash h;

  h.update(get_nof_vertices());

  /* Hash the color of each vertex */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      h.update(vertices[i].color);
    }

  /* Hash the edges */
  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      Vertex &v = vertices[i];
      for(std::vector::const_iterator ei = v.edges.begin();
          ei != v.edges.end();
          ei++)
        {
          const unsigned int dest_i = *ei;
          if(dest_i < i)
            continue;
          h.update(i);
          h.update(dest_i);
        }
    }

  return h.get_value();
}





void
Graph::remove_duplicate_edges()
{
  std::vector tmp(vertices.size(), false);

  for(std::vector::iterator vi = vertices.begin();
      vi != vertices.end();
      vi++)
    {
#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)
      for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false);
#endif
      (*vi).remove_duplicate_edges(tmp);
    }
}





/*-------------------------------------------------------------------------
 *
 * Partition independent invariants
 *
 *-------------------------------------------------------------------------*/

/*
 * Return the color of the vertex.
 * Time complexity: O(1)
 */
unsigned int
Graph::vertex_color_invariant(const Graph* const g, const unsigned int v)
{
  return g->vertices[v].color;
}

/*
 * Return the degree of the vertex.
 * Time complexity: O(1)
 */
unsigned int
Graph::degree_invariant(const Graph* const g, const unsigned int v)
{
  return g->vertices[v].nof_edges();
}

/*
 * Return 1 if the vertex v has a self-loop, 0 otherwise
 * Time complexity: O(E_v), where E_v is the number of edges leaving v
 */
unsigned int
Graph::selfloop_invariant(const Graph* const g, const unsigned int v)
{
  const Vertex& vertex = g->vertices[v];
  for(std::vector::const_iterator ei = vertex.edges.begin();
      ei != vertex.edges.end();
      ei++)
    {
      if(*ei == v)
        return 1;
    }
  return 0;
}



/*-------------------------------------------------------------------------
 *
 * Refine the partition p according to a partition independent invariant
 *
 *-------------------------------------------------------------------------*/

bool
Graph::refine_according_to_invariant(unsigned int (*inv)(const Graph* const g,
                                                         const unsigned int v))
{
  bool refined = false;

  for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; )
    {

      Partition::Cell* const next_cell = cell->next_nonsingleton;

      const unsigned int* ep = p.elements + cell->first;
      for(unsigned int i = cell->length; i > 0; i--, ep++)
        {
          const unsigned int ival = inv(this, *ep);
          p.invariant_values[*ep] = ival;
          if(ival > cell->max_ival)
            {
              cell->max_ival = ival;
              cell->max_ival_count = 1;
            }
          else if(ival == cell->max_ival)
            {
              cell->max_ival_count++;
            }
        }
      Partition::Cell* const last_new_cell = p.zplit_cell(cell, true);
      refined |= (last_new_cell != cell);
      cell = next_cell;
    }

  return refined;
}












/*-------------------------------------------------------------------------
 *
 * Split the neighbourhood of a cell according to the equitable invariant
 *
 *-------------------------------------------------------------------------*/

bool
Graph::split_neighbourhood_of_cell(Partition::Cell* const cell)
{


  const bool was_equal_to_first = refine_equal_to_first;

  if(compute_eqref_hash)
    {
      eqref_hash.update(cell->first);
      eqref_hash.update(cell->length);
    }

  const unsigned int* ep = p.elements + cell->first;
  for(unsigned int i = cell->length; i > 0; i--)
    {
      const Vertex& v = vertices[*ep++];

      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j != 0; j--)
        {
          const unsigned int dest_vertex = *ei++;
          Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex);
          if(neighbour_cell->is_unit())
            continue;
          const unsigned int ival = ++p.invariant_values[dest_vertex];
          if(ival > neighbour_cell->max_ival)
            {
              neighbour_cell->max_ival = ival;
              neighbour_cell->max_ival_count = 1;
              if(ival == 1) {
                neighbour_heap.insert(neighbour_cell->first);
              }
            }
          else if(ival == neighbour_cell->max_ival) {
            neighbour_cell->max_ival_count++;
          }
        }
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }


      Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true);

      /* Update certificate and hash if needed */
      const Partition::Cell* c = neighbour_cell;
      while(1)
        {
          if(in_search)
            {
              /* Build certificate */
              cert_add_redundant(CERT_SPLIT, c->first, c->length);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
          if(compute_eqref_hash)
            {
              eqref_hash.update(c->first);
              eqref_hash.update(c->length);
            }
          if(c == last_new_cell)
            break;
          c = c->next;
        }
    }

  if(refine_compare_certificate and
     (refine_equal_to_first == false) and
     (refine_cmp_to_best < 0))
    return true;

  return false;

 worse_exit:
  /* Clear neighbour heap */
  UintSeqHash rest;
  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);
      if(opt_use_failure_recording and was_equal_to_first)
        {
          rest.update(neighbour_cell->first);
          rest.update(neighbour_cell->length);
          rest.update(neighbour_cell->max_ival);
          rest.update(neighbour_cell->max_ival_count);
        }
      neighbour_cell->max_ival = 0;
      neighbour_cell->max_ival_count = 0;
     p.clear_ivs(neighbour_cell);
    }
  if(opt_use_failure_recording and was_equal_to_first)
    {
      for(unsigned int i = p.splitting_queue.size(); i > 0; i--)
        {
          Partition::Cell* const cell = p.splitting_queue.pop_front();
          rest.update(cell->first);
          rest.update(cell->length);
          p.splitting_queue.push_back(cell);
        }
      rest.update(failure_recording_fp_deviation);
      failure_recording_fp_deviation = rest.get_value();
    }

  return true;
}



bool
Graph::split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell)
{


  const bool was_equal_to_first = refine_equal_to_first;

  if(compute_eqref_hash)
    {
      eqref_hash.update(0x87654321);
      eqref_hash.update(unit_cell->first);
      eqref_hash.update(1);
    }

  const Vertex& v = vertices[p.elements[unit_cell->first]];

  std::vector::const_iterator ei = v.edges.begin();
  for(unsigned int j = v.nof_edges(); j > 0; j--)
    {
      const unsigned int dest_vertex = *ei++;
      Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex);

      if(neighbour_cell->is_unit()) {
        if(in_search) {
          /* Remember neighbour in order to generate certificate */
          neighbour_heap.insert(neighbour_cell->first);
        }
        continue;
      }
      if(neighbour_cell->max_ival_count == 0)
        {
          neighbour_heap.insert(neighbour_cell->first);
        }
      neighbour_cell->max_ival_count++;

      unsigned int * const swap_position =
        p.elements + neighbour_cell->first + neighbour_cell->length -
        neighbour_cell->max_ival_count;
      *p.in_pos[dest_vertex] = *swap_position;
      p.in_pos[*swap_position] = p.in_pos[dest_vertex];
      *swap_position = dest_vertex;
      p.in_pos[dest_vertex] = swap_position;
    }

  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]);

#if defined(BLISS_CONSISTENCY_CHECKS)
      if(neighbour_cell->is_unit()) {
      } else {
      }
#endif

      if(compute_eqref_hash)
        {
          eqref_hash.update(neighbour_cell->first);
          eqref_hash.update(neighbour_cell->length);
          eqref_hash.update(neighbour_cell->max_ival_count);
        }

      if(neighbour_cell->length > 1 and
         neighbour_cell->max_ival_count != neighbour_cell->length)
        {
          Partition::Cell * const new_cell =
            p.aux_split_in_two(neighbour_cell,
                               neighbour_cell->length -
                               neighbour_cell->max_ival_count);
          unsigned int *ep = p.elements + new_cell->first;
          unsigned int * const lp = p.elements+new_cell->first+new_cell->length;
          while(ep < lp)
            {
              p.element_to_cell_map[*ep] = new_cell;
              ep++;
            }
          neighbour_cell->max_ival_count = 0;


          if(compute_eqref_hash)
            {
              /* Update hash */
              eqref_hash.update(neighbour_cell->first);
              eqref_hash.update(neighbour_cell->length);
              eqref_hash.update(0);
              eqref_hash.update(new_cell->first);
              eqref_hash.update(new_cell->length);
              eqref_hash.update(1);
            }

          /* Add cells in splitting_queue */
          if(neighbour_cell->is_in_splitting_queue()) {
            /* Both cells must be included in splitting_queue in order
               to ensure refinement into equitable partition */
            p.splitting_queue_add(new_cell);
          } else {
            Partition::Cell *min_cell, *max_cell;
            if(neighbour_cell->length <= new_cell->length) {
              min_cell = neighbour_cell;
              max_cell = new_cell;
            } else {
              min_cell = new_cell;
              max_cell = neighbour_cell;
            }
            /* Put the smaller cell in splitting_queue */
            p.splitting_queue_add(min_cell);
            if(max_cell->is_unit()) {
              /* Put the "larger" cell also in splitting_queue */
              p.splitting_queue_add(max_cell);
            }
          }
          /* Update pointer for certificate generation */
          neighbour_cell = new_cell;
        }
      else
        {
          /* neighbour_cell->length == 1 ||
             neighbour_cell->max_ival_count == neighbour_cell->length */
          neighbour_cell->max_ival_count = 0;
        }

      /*
       * Build certificate if required
       */
      if(in_search)
        {
          for(unsigned int i = neighbour_cell->first,
                j = neighbour_cell->length;
              j > 0;
              j--, i++)
            {
              /* Build certificate */
              cert_add(CERT_EDGE, unit_cell->first, i);
              /* No need to continue? */
              if(refine_compare_certificate and
                 (refine_equal_to_first == false) and
                 (refine_cmp_to_best < 0))
                goto worse_exit;
            }
        } /* if(in_search) */
    } /* while(!neighbour_heap.is_empty()) */

  if(refine_compare_certificate and
     (refine_equal_to_first == false) and
     (refine_cmp_to_best < 0))
    return true;

  return false;

 worse_exit:
  /* Clear neighbour heap */
  UintSeqHash rest;
  while(!neighbour_heap.is_empty())
    {
      const unsigned int start = neighbour_heap.remove();
      Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]);
      if(opt_use_failure_recording and was_equal_to_first)
        {
          rest.update(neighbour_cell->first);
          rest.update(neighbour_cell->length);
          rest.update(neighbour_cell->max_ival_count);
        }
      neighbour_cell->max_ival_count = 0;
    }
  if(opt_use_failure_recording and was_equal_to_first)
    {
      rest.update(failure_recording_fp_deviation);
      failure_recording_fp_deviation = rest.get_value();
    }
  return true;
}









/*-------------------------------------------------------------------------
 *
 * Check whether the current partition p is equitable.
 * Performance: very slow, use only for debugging purposes.
 *
 *-------------------------------------------------------------------------*/

bool Graph::is_equitable() const
{
  const unsigned int N = get_nof_vertices();
  if(N == 0)
    return true;

  std::vector first_count = std::vector(N, 0);
  std::vector other_count = std::vector(N, 0);

  for(Partition::Cell *cell = p.first_cell; cell; cell = cell->next)
    {
      if(cell->is_unit())
        continue;

      unsigned int *ep = p.elements + cell->first;
      const Vertex &first_vertex = vertices[*ep++];

      /* Count how many edges lead from the first vertex to
       * the neighbouring cells */
      for(std::vector::const_iterator ei =
            first_vertex.edges.begin();
          ei != first_vertex.edges.end();
          ei++)
        {
          first_count[p.get_cell(*ei)->first]++;
        }

      /* Count and compare to the edges of the other vertices */
      for(unsigned int i = cell->length; i > 1; i--)
        {
          const Vertex &vertex = vertices[*ep++];
          for(std::vector::const_iterator ei =
                vertex.edges.begin();
              ei != vertex.edges.end();
              ei++)
            {
              other_count[p.get_cell(*ei)->first]++;
            }
          for(Partition::Cell *cell2 = p.first_cell;
              cell2;
              cell2 = cell2->next)
            {
              if(first_count[cell2->first] != other_count[cell2->first])
                {
                  /* Not equitable */
                  return false;
                }
              other_count[cell2->first] = 0;
            }
        }
      /* Reset first_count */
      for(unsigned int i = 0; i < N; i++)
        first_count[i] = 0;
    }
  return true;
}





/*-------------------------------------------------------------------------
 *
 * Build the initial equitable partition
 *
 *-------------------------------------------------------------------------*/

void Graph::make_initial_equitable_partition()
{
  refine_according_to_invariant(&vertex_color_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_according_to_invariant(&selfloop_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_according_to_invariant(°ree_invariant);
  p.splitting_queue_clear();
  //p.print_signature(stderr); fprintf(stderr, "\n");

  refine_to_equitable();
  //p.print_signature(stderr); fprintf(stderr, "\n");


}







/*-------------------------------------------------------------------------
 *
 * Find the next cell to be splitted
 *
 *-------------------------------------------------------------------------*/


Partition::Cell*
Graph::find_next_cell_to_be_splitted(Partition::Cell* cell)
{
  switch(sh) {
  case shs_f:   return sh_first();
  case shs_fs:  return sh_first_smallest();
  case shs_fl:  return sh_first_largest();
  case shs_fm:  return sh_first_max_neighbours();
  case shs_fsm: return sh_first_smallest_max_neighbours();
  case shs_flm: return sh_first_largest_max_neighbours();
  default:
    fatal_error("Internal error - unknown splitting heuristics");
    return 0;
  }
}

/** \internal
 * A splitting heuristic.
 * Returns the first nonsingleton cell in the current partition.
 */
Partition::Cell*
Graph::sh_first()
{
  Partition::Cell* best_cell = 0;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      best_cell = cell;
      break;
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first smallest nonsingleton cell in the current partition.
 */
Partition::Cell*
Graph::sh_first_smallest()
{
  Partition::Cell* best_cell = 0;
  unsigned int best_size = UINT_MAX;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      if(cell->length < best_size)
        {
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first largest nonsingleton cell in the current partition.
 */
Partition::Cell*
Graph::sh_first_largest()
{
  Partition::Cell* best_cell = 0;
  unsigned int best_size = 0;
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      if(cell->length > best_size)
        {
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first nonsingleton cell with max number of neighbouring
 *   nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Graph::sh_first_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {
      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j > 0; j--)
        {
          Partition::Cell * const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      int value = 0;
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }
      if(value > best_value)
        {
          best_value = value;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first smallest nonsingleton cell with max number of neighbouring
 * nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Graph::sh_first_smallest_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  unsigned int best_size = UINT_MAX;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {

      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;

      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j > 0; j--)
        {
          Partition::Cell* const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      int value = 0;
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }
      if((value > best_value) or
         (value == best_value and cell->length < best_size))
        {
          best_value = value;
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}

/** \internal
 * A splitting heuristic.
 * Returns the first largest nonsingleton cell with max number of neighbouring
 * nonsingleton cells.
 * Assumes that the partition p is equitable.
 * Assumes that the max_ival fields of the cells are all 0.
 */
Partition::Cell*
Graph::sh_first_largest_max_neighbours()
{
  Partition::Cell* best_cell = 0;
  int best_value = -1;
  unsigned int best_size = 0;
  KStack neighbour_cells_visited;
  neighbour_cells_visited.init(get_nof_vertices());
  for(Partition::Cell* cell = p.first_nonsingleton_cell;
      cell;
      cell = cell->next_nonsingleton)
    {

      if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level)
        continue;
      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j > 0; j--)
        {
          Partition::Cell* const neighbour_cell = p.get_cell(*ei++);
          if(neighbour_cell->is_unit())
            continue;
          neighbour_cell->max_ival++;
          if(neighbour_cell->max_ival == 1)
            neighbour_cells_visited.push(neighbour_cell);
        }
      int value = 0;
      while(!neighbour_cells_visited.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop();
          if(neighbour_cell->max_ival != neighbour_cell->length)
            value++;
          neighbour_cell->max_ival = 0;
        }
      if((value > best_value) or
         (value == best_value and cell->length > best_size))
        {
          best_value = value;
          best_size = cell->length;
          best_cell = cell;
        }
    }
  return best_cell;
}




















/*-------------------------------------------------------------------------
 *
 * Initialize the certificate size and memory
 *
 *-------------------------------------------------------------------------*/

void
Graph::initialize_certificate()
{
  certificate_index = 0;
  certificate_current_path.clear();
  certificate_first_path.clear();
  certificate_best_path.clear();
}





/*-------------------------------------------------------------------------
 *
 * Check whether perm is an automorphism.
 * Slow, mainly for debugging and validation purposes.
 *
 *-------------------------------------------------------------------------*/

bool
Graph::is_automorphism(unsigned int* const perm) const
{
  std::set > edges1;
  std::set > edges2;

#if defined(BLISS_CONSISTENCY_CHECKS)
  if(!is_permutation(get_nof_vertices(), perm))
    _INTERNAL_ERROR();
#endif

  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v1 = vertices[i];
      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges.cbegin();
          ei != v1.edges.cend();
          ei++)
        edges1.insert(perm[*ei]);

      const Vertex& v2 = vertices[perm[i]];
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges.cbegin();
          ei != v2.edges.cend();
          ei++)
        edges2.insert(*ei);

      if(!(edges1 == edges2))
        return false;
    }

  return true;
}




bool
Graph::is_automorphism(const std::vector& perm) const
{

  if(!(perm.size() == get_nof_vertices() and is_permutation(perm)))
    return false;

  std::set > edges1;
  std::set > edges2;

  for(unsigned int i = 0; i < get_nof_vertices(); i++)
    {
      const Vertex& v1 = vertices[i];
      edges1.clear();
      for(std::vector::const_iterator ei = v1.edges.begin();
          ei != v1.edges.end();
          ei++)
        edges1.insert(perm[*ei]);

      const Vertex& v2 = vertices[perm[i]];
      edges2.clear();
      for(std::vector::const_iterator ei = v2.edges.begin();
          ei != v2.edges.end();
          ei++)
        edges2.insert(*ei);

      if(!(edges1 == edges2))
        return false;
    }

  return true;
}







bool
Graph::nucr_find_first_component(const unsigned int level)
{

  cr_component.clear();
  cr_component_elements = 0;

  /* Find first non-discrete cell in the component level */
  Partition::Cell* first_cell = p.first_nonsingleton_cell;
  while(first_cell)
    {
      if(p.cr_get_level(first_cell->first) == level)
        break;
      first_cell = first_cell->next_nonsingleton;
    }

  /* The component is discrete, return false */
  if(!first_cell)
    return false;

  std::vector component;
  first_cell->max_ival = 1;
  component.push_back(first_cell);

  for(unsigned int i = 0; i < component.size(); i++)
    {
      Partition::Cell* const cell = component[i];

      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;

          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);

          /* Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Already marked to be in the same component? */
          if(neighbour_cell->max_ival == 1)
            continue;
          /* Is the neighbour at the same component recursion level? */
          if(p.cr_get_level(neighbour_cell->first) != level)
            continue;

          if(neighbour_cell->max_ival_count == 0)
            neighbour_heap.insert(neighbour_cell->first);
          neighbour_cell->max_ival_count++;
        }
      while(!neighbour_heap.is_empty())
        {
          const unsigned int start = neighbour_heap.remove();
          Partition::Cell* const neighbour_cell =
            p.get_cell(p.elements[start]);

          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          neighbour_cell->max_ival_count = 0;
          neighbour_cell->max_ival = 1;
          component.push_back(neighbour_cell);
        }
    }

  for(unsigned int i = 0; i < component.size(); i++)
    {
      Partition::Cell* const cell = component[i];
      cell->max_ival = 0;
      cr_component.push_back(cell->first);
      cr_component_elements += cell->length;
    }

  /*
  if(verbstr and verbose_level > 2) {
    fprintf(verbstr, "NU-component with %lu cells and %u vertices\n",
            (long unsigned)cr_component.size(), cr_component_elements);
    fflush(verbstr);
  }
  */

  return true;
}




bool
Graph::nucr_find_first_component(const unsigned int level,
                                 std::vector& component,
                                 unsigned int& component_elements,
                                 Partition::Cell*& sh_return)
{

  component.clear();
  component_elements = 0;
  sh_return = 0;
  unsigned int sh_first  = 0;
  unsigned int sh_size   = 0;
  unsigned int sh_nuconn = 0;

  /* Find first non-discrete cell in the component level */
  Partition::Cell* first_cell = p.first_nonsingleton_cell;
  while(first_cell)
    {
      if(p.cr_get_level(first_cell->first) == level)
        break;
      first_cell = first_cell->next_nonsingleton;
    }

  if(!first_cell)
    {
      /* The component is discrete, return false */
      return false;
    }

  std::vector comp;
  KStack neighbours;
  neighbours.init(get_nof_vertices());

  first_cell->max_ival = 1;
  comp.push_back(first_cell);

  for(unsigned int i = 0; i < comp.size(); i++)
    {
      Partition::Cell* const cell = comp[i];

      const Vertex& v = vertices[p.elements[cell->first]];
      std::vector::const_iterator ei = v.edges.begin();
      for(unsigned int j = v.nof_edges(); j > 0; j--)
        {
          const unsigned int neighbour = *ei++;

          Partition::Cell* const neighbour_cell = p.get_cell(neighbour);

          /* Skip unit neighbours */
          if(neighbour_cell->is_unit())
            continue;
          /* Is the neighbour at the same component recursion level? */
          //if(p.cr_get_level(neighbour_cell->first) != level)
          //  continue;
          if(neighbour_cell->max_ival_count == 0)
            neighbours.push(neighbour_cell);
          neighbour_cell->max_ival_count++;
        }
      unsigned int nuconn = 1;
      while(!neighbours.is_empty())
        {
          Partition::Cell* const neighbour_cell = neighbours.pop();
          //neighbours.pop_back();

          /* Skip saturated neighbour cells */
          if(neighbour_cell->max_ival_count == neighbour_cell->length)
            {
              neighbour_cell->max_ival_count = 0;
              continue;
            }
          nuconn++;
          neighbour_cell->max_ival_count = 0;
          if(neighbour_cell->max_ival == 0) {
            comp.push_back(neighbour_cell);
            neighbour_cell->max_ival = 1;
          }
        }

      switch(sh) {
      case shs_f:
        if(sh_return == 0 or
           cell->first <= sh_first) {
          sh_return = cell;
          sh_first = cell->first;
        }
        break;
      case shs_fs:
        if(sh_return == 0 or
           cell->length < sh_size or
           (cell->length == sh_size and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
        }
        break;
      case shs_fl:
        if(sh_return == 0 or
           cell->length > sh_size or
           (cell->length == sh_size and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
        }
        break;
      case shs_fm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and cell->first <= sh_first)) {
          sh_return = cell;
          sh_first = cell->first;
          sh_nuconn = nuconn;
        }
        break;
      case shs_fsm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and
            (cell->length < sh_size or
             (cell->length == sh_size and cell->first <= sh_first)))) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
          sh_nuconn = nuconn;
        }
        break;
      case shs_flm:
        if(sh_return == 0 or
           nuconn > sh_nuconn or
           (nuconn == sh_nuconn and
            (cell->length > sh_size or
             (cell->length == sh_size and cell->first <= sh_first)))) {
          sh_return = cell;
          sh_first = cell->first;
          sh_size = cell->length;
          sh_nuconn = nuconn;
        }
        break;
      default:
        fatal_error("Internal error - unknown splitting heuristics");
        return 0;
      }
    }
  assert(sh_return);

  for(unsigned int i = 0; i < comp.size(); i++)
    {
      Partition::Cell* const cell = comp[i];
      cell->max_ival = 0;
      component.push_back(cell->first);
      component_elements += cell->length;
    }

  /*
  if(verbstr and verbose_level > 2) {
    fprintf(verbstr, "NU-component with %lu cells and %u vertices\n",
            (long unsigned)component.size(), component_elements);
    fflush(verbstr);
  }
  */

  return true;
}




}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/graph.hh0000644000175100001710000007172400000000000025563 0ustar00runnerdocker00000000000000#ifndef BLISS_GRAPH_HH
#define BLISS_GRAPH_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

/**
 * \namespace bliss
 * The namespace bliss contains all the classes and functions of the bliss
 * tool except for the C programming language API.
 */
namespace bliss {
  class AbstractGraph;
}

// #include 
#include 
#include 
#include "stats.hh"
#include "kstack.hh"
#include "kqueue.hh"
#include "heap.hh"
#include "orbit.hh"
#include "partition.hh"
#include "uintseqhash.hh"

namespace bliss {





/**
 * \brief An abstract base class for different types of graphs.
 */
class AbstractGraph
{
  friend class Partition;

public:
  AbstractGraph();
  virtual ~AbstractGraph();

#if 0
  /**
   * Set the verbose output level for the algorithms.
   * \param level  the level of verbose output, 0 means no verbose output
   */
  void set_verbose_level(const unsigned int level);

  /**
   * Set the file stream for the verbose output.
   * \param fp  the file stream; if null, no verbose output is written
   */
  void set_verbose_file(FILE * const fp);
#endif

  /**
   * Add a new vertex with color \a color in the graph and return its index.
   */
  virtual unsigned int add_vertex(const unsigned int color = 0) = 0;

  /**
   * Add an edge between vertices \a source and \a target.
   * Duplicate edges between vertices are ignored but try to avoid introducing
   * them in the first place as they are not ignored immediately but will
   * consume memory and computation resources for a while.
   */
  virtual void add_edge(const unsigned int source, const unsigned int target) = 0;

  /**
   * Change the color of the vertex \a vertex to \a color.
   */
  virtual void change_color(const unsigned int vertex, const unsigned int color) = 0;

  /**
   * Check whether \a perm is an automorphism of this graph.
   * Unoptimized, mainly for debugging purposes.
   */
  virtual bool is_automorphism(const std::vector& perm) const = 0;


  /** Activate/deactivate failure recording.
   * May not be called during the search, i.e. from an automorphism reporting
   * hook function.
   * \param active  if true, activate failure recording, deactivate otherwise
   */
  void set_failure_recording(const bool active) {assert(!in_search); opt_use_failure_recording = active;}

  /** Activate/deactivate component recursion.
   * The choice affects the computed canonical labelings;
   * therefore, if you want to compare whether two graphs are isomorphic by
   * computing and comparing (for equality) their canonical versions,
   * be sure to use the same choice for both graphs.
   * May not be called during the search, i.e. from an automorphism reporting
   * hook function.
   * \param active  if true, activate component recursion, deactivate otherwise
   */
  void set_component_recursion(const bool active) {assert(!in_search); opt_use_comprec = active;}



  /**
   * Return the number of vertices in the graph.
   */
  virtual unsigned int get_nof_vertices() const = 0;

  /**
   * Return a new graph that is the result of applying the permutation \a perm
   * to this graph. This graph is not modified.
   * \a perm must contain N=this.get_nof_vertices() elements and be a bijection
   * on {0,1,...,N-1}, otherwise the result is undefined or a segfault.
   */
  virtual AbstractGraph* permute(const unsigned int* const perm) const = 0;
  virtual AbstractGraph* permute(const std::vector& perm) const = 0;

  /**
   * Find a set of generators for the automorphism group of the graph.
   * The function \a report (if non-null) is called each time a new generator
   * for the automorphism group is found.
   * The first argument \a n for the function
   * is the length of the automorphism (equal to get_nof_vertices()), and
   * the second argument \a aut is the automorphism
   * (a bijection on {0,...,get_nof_vertices()-1}).
   * The memory for the automorphism \a aut will be invalidated immediately
   * after the return from the \a report function;
   * if you want to use the automorphism later, you have to take a copy of it.
   * Do not call any member functions from the \a report function.
   *
   * The search statistics are copied in \a stats.
   *
   * If the \a terminate function argument is given,
   * it is called in each search tree node: if the function returns true,
   * then the search is terminated and thus not all the automorphisms
   * may have been generated.
   * The \a terminate function may be used to limit the time spent in bliss
   * in case the graph is too difficult under the available time constraints.
   * If used, keep the function simple to evaluate so that
   * it does not consume too much time.
   */
  void find_automorphisms(Stats& stats,
                          const std::function& report = nullptr,
                          const std::function& terminate = nullptr);

  /**
   * Otherwise the same as find_automorphisms() except that
   * a canonical labeling of the graph (a bijection on
   * {0,...,get_nof_vertices()-1}) is returned.
   * The memory allocated for the returned canonical labeling will remain
   * valid only until the next call to a member function with the exception
   * that constant member functions (for example, bliss::Graph::permute()) can
   * be called without invalidating the labeling.
   * To compute the canonical version of an undirected graph, call this
   * function and then bliss::Graph::permute() with the returned canonical
   * labeling.
   * Note that the computed canonical version may depend on the applied version
   * of bliss as well as on some other options (for instance, the splitting
   * heuristic selected with bliss::Graph::set_splitting_heuristic()).
   *
   * If the \a terminate function argument is given,
   * it is called in each search tree node: if the function returns true,
   * then the search is terminated and thus (i) not all the automorphisms
   * may have been generated and (ii) the returned labeling may not
   * be canonical.
   * The \a terminate function may be used to limit the time spent in bliss
   * in case the graph is too difficult under the available time constraints.
   * If used, keep the function simple to evaluate so that
   * it does not consume too much time.
   */
  const unsigned int* canonical_form(Stats& stats,
                                     const std::function& report = nullptr,
                                     const std::function& terminate = nullptr);

  /**
   * Get a hash value for the graph.
   * \return  the hash value
   */
  virtual unsigned int get_hash() = 0;

  /**
   * Disable/enable the "long prune" method.
   * The choice affects the computed canonical labelings;
   * therefore, if you want to compare whether two graphs are isomorphic by
   * computing and comparing (for equality) their canonical versions,
   * be sure to use the same choice for both graphs.
   * May not be called during the search, i.e. from an automorphism reporting
   * hook function.
   * \param active  if true, activate "long prune", deactivate otherwise
   */
  void set_long_prune_activity(const bool active) {
    assert(!in_search);
    opt_use_long_prune = active;
  }



protected:
  /** \internal
   * How much verbose output is produced (0 means none) */
  /* unsigned int verbose_level; */
  /** \internal
   * The output stream for verbose output. */
  /* FILE *verbstr; */
protected:

  /** \internal
   * The ordered partition used in the search algorithm. */
  Partition p;

  /** \internal
   * Whether the search for automorphisms and a canonical labeling is
   * in progress.
   */
  bool in_search;

  /** \internal
   * Is failure recording in use?
   */
  bool opt_use_failure_recording;
  /* The "tree-specific" invariant value for the point when current path
   * got different from the first path */
  unsigned int failure_recording_fp_deviation;

  /** \internal
   * Is component recursion in use?
   */
  bool opt_use_comprec;


  unsigned int refine_current_path_certificate_index;
  bool refine_compare_certificate = false;
  bool refine_equal_to_first = false;
  unsigned int refine_first_path_subcertificate_end;
  int refine_cmp_to_best;
  unsigned int refine_best_path_subcertificate_end;

  static const unsigned int CERT_SPLIT = 0; //UINT_MAX;
  static const unsigned int CERT_EDGE  = 1; //UINT_MAX-1;
  /** \internal
   * Add a triple (v1,v2,v3) in the certificate.
   * May modify refine_equal_to_first and refine_cmp_to_best.
   * May also update eqref_hash and failure_recording_fp_deviation. */
  void cert_add(const unsigned int v1,
                const unsigned int v2,
                const unsigned int v3);

  /** \internal
   * Add a redundant triple (v1,v2,v3) in the certificate.
   * Can also just dicard the triple.
   * May modify refine_equal_to_first and refine_cmp_to_best.
   * May also update eqref_hash and failure_recording_fp_deviation. */
  void cert_add_redundant(const unsigned int x,
                          const unsigned int y,
                          const unsigned int z);

  /**\internal
   * Is the long prune method in use?
   */
  bool opt_use_long_prune;
  /**\internal
   * Maximum amount of memory (in megabytes) available for
   * the long prune method
   */
  static const unsigned int long_prune_options_max_mem = 50;
  /**\internal
   * Maximum amount of automorphisms stored for the long prune method;
   * less than this is stored if the memory limit above is reached first
   */
  static const unsigned int long_prune_options_max_stored_auts = 100;

  unsigned int long_prune_max_stored_autss;
  std::vector *> long_prune_fixed;
  std::vector *> long_prune_mcrs;
  std::vector long_prune_temp;
  unsigned int long_prune_begin;
  unsigned int long_prune_end;
  /** \internal
   * Initialize the "long prune" data structures.
   */
  void long_prune_init();
  /** \internal
   * Release the memory allocated for "long prune" data structures.
   */
  void long_prune_deallocate();
  void long_prune_add_automorphism(const unsigned int *aut);
  std::vector& long_prune_get_fixed(const unsigned int index);
  std::vector& long_prune_allocget_fixed(const unsigned int index);
  std::vector& long_prune_get_mcrs(const unsigned int index);
  std::vector& long_prune_allocget_mcrs(const unsigned int index);
  /** \internal
   * Swap the i:th and j:th stored automorphism information;
   * i and j must be "in window, i.e. in [long_prune_begin,long_prune_end[
   */
  void long_prune_swap(const unsigned int i, const unsigned int j);

  /*
   * Data structures and routines for refining the partition p into equitable
   */
  Heap neighbour_heap;
  virtual bool split_neighbourhood_of_unit_cell(Partition::Cell * const) = 0;
  virtual bool split_neighbourhood_of_cell(Partition::Cell * const) = 0;
  void refine_to_equitable();
  void refine_to_equitable(Partition::Cell * const unit_cell);
  void refine_to_equitable(Partition::Cell * const unit_cell1,
                           Partition::Cell * const unit_cell2);


  /** \internal
   * \return false if it was detected that the current certificate
   *         is different from the first and/or best (whether this is checked
   *         depends on in_search and refine_compare_certificate flags.
   */
  bool do_refine_to_equitable();

  unsigned int eqref_max_certificate_index;
  /** \internal
   * Whether eqref_hash is updated during equitable refinement process.
   */
  bool compute_eqref_hash;
  UintSeqHash eqref_hash;


  /** \internal
   * Check whether the current partition p is equitable.
   * Performance: very slow, use only for debugging purposes.
   */
  virtual bool is_equitable() const = 0;

  unsigned int *first_path_labeling;
  unsigned int *first_path_labeling_inv;
  Orbit         first_path_orbits;
  unsigned int *first_path_automorphism;

  unsigned int *best_path_labeling;
  unsigned int *best_path_labeling_inv;
  Orbit         best_path_orbits;
  unsigned int *best_path_automorphism;

  void update_labeling(unsigned int * const lab);
  void update_labeling_and_its_inverse(unsigned int * const lab,
                                       unsigned int * const lab_inv);
  void update_orbit_information(Orbit &o, const unsigned int *perm);

  void reset_permutation(unsigned int *perm);

  /* Mainly for debugging purposes */
  virtual bool is_automorphism(unsigned int* const perm) const = 0;

  std::vector certificate_current_path;
  std::vector certificate_first_path;
  std::vector certificate_best_path;

  unsigned int certificate_index;
  virtual void initialize_certificate() = 0;

  virtual void remove_duplicate_edges() = 0;
  virtual void make_initial_equitable_partition() = 0;
  virtual Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell) = 0;


  /** \struct PathInfo
   *
   * A structure for holding first, current, and best path information.
   */
  typedef struct {
    unsigned int splitting_element;
    unsigned int certificate_index;
    unsigned int subcertificate_length;
    UintSeqHash eqref_hash;
  } PathInfo;

  void search(const bool canonical, Stats &stats,
              const std::function& report_function = nullptr,
              const std::function& terminate = nullptr);


  void (*report_hook)(void *user_param,
                      unsigned int n,
                      const unsigned int *aut);
  void *report_user_param;


  /*
   *
   * Nonuniform component recursion (NUCR)
   *
   */

  /* The currently traversed component */
  unsigned int cr_level;

  /** @internal @class CR_CEP
   * The "Component End Point" data structure
   */
  class CR_CEP {
  public:
    /** At which level in the search was this CEP created */
    unsigned int creation_level;
    /** The current component has been fully traversed when the partition has
     * this many discrete cells left */
    unsigned int discrete_cell_limit;
    /** The component to be traversed after the current one */
    unsigned int next_cr_level;
    /** The next component end point */
    unsigned int next_cep_index;
    bool first_checked;
    bool best_checked;
  };
  /** \internal
   * A stack for storing Component End Points
   */
  std::vector cr_cep_stack;

  /** \internal
   * Find the first non-uniformity component at the component recursion
   * level \a level.
   * The component is stored in \a cr_component.
   * If no component is found, \a cr_component is empty.
   * Returns false if all the cells in the component recursion level \a level
   * were discrete.
   * Modifies the max_ival and max_ival_count fields of Partition:Cell
   * (assumes that they are 0 when called and
   *  quarantees that they are 0 when returned).
   */
  virtual bool nucr_find_first_component(const unsigned int level) = 0;
  virtual bool nucr_find_first_component(const unsigned int level,
                                         std::vector& component,
                                         unsigned int& component_elements,
                                         Partition::Cell*& sh_return) = 0;
  /** \internal
   * The non-uniformity component found by nucr_find_first_component()
   * is stored here.
   */
  std::vector cr_component;
  /** \internal
   * The number of vertices in the component \a cr_component
   */
  unsigned int cr_component_elements;






};



/**
 * \brief The class for undirected, vertex colored graphs.
 *
 * Multiple edges between vertices are not allowed (i.e., are ignored).
 */
class Graph : public AbstractGraph
{
public:
  /**
   * The possible splitting heuristics.
   * The selected splitting heuristics affects the computed canonical
   * labelings; therefore, if you want to compare whether two graphs
   * are isomorphic by computing and comparing (for equality) their
   * canonical versions, be sure to use the same splitting heuristics
   * for both graphs.
   */
  typedef enum {
    /** First non-unit cell.
     * Very fast but may result in large search spaces on difficult graphs.
     * Use for large but easy graphs. */
    shs_f = 0,
    /** First smallest non-unit cell.
     * Fast, should usually produce smaller search spaces than shs_f. */
    shs_fs,
    /** First largest non-unit cell.
     * Fast, should usually produce smaller search spaces than shs_f. */
    shs_fl,
    /** First maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_fm,
    /** First smallest maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_fsm,
    /** First largest maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_flm
  } SplittingHeuristic;

protected:
  class Vertex {
  public:
    Vertex();
    ~Vertex();
    void add_edge(const unsigned int other_vertex);
    void remove_duplicate_edges(std::vector& tmp);
    void sort_edges();

    unsigned int color;
    std::vector edges;
    unsigned int nof_edges() const {return edges.size(); }
  };
  std::vector vertices;
  void sort_edges();
  void remove_duplicate_edges();

  /** \internal
   * Partition independent invariant.
   * Returns the color of the vertex.
   * Time complexity: O(1).
   */
  static unsigned int vertex_color_invariant(const Graph* const g,
                                             const unsigned int v);
  /** \internal
   * Partition independent invariant.
   * Returns the degree of the vertex.
   * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE.
   * Time complexity: O(1).
   */
  static unsigned int degree_invariant(const Graph* const g,
                                       const unsigned int v);
  /** \internal
   * Partition independent invariant.
   * Returns 1 if there is an edge from the vertex to itself, 0 if not.
   * Time complexity: O(k), where k is the number of edges leaving the vertex.
   */
  static unsigned int selfloop_invariant(const Graph* const g,
                                         const unsigned int v);


  bool refine_according_to_invariant(unsigned int (*inv)(const Graph* const g,
                                                         const unsigned int v));

  /*
   * Routines needed when refining the partition p into equitable
   */
  bool split_neighbourhood_of_unit_cell(Partition::Cell * const);
  bool split_neighbourhood_of_cell(Partition::Cell * const);

  /** \internal
   * \copydoc AbstractGraph::is_equitable() const
   */
  bool is_equitable() const;

  /* Splitting heuristics, documented in more detail in graph.cc */
  SplittingHeuristic sh;
  Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell);
  Partition::Cell* sh_first();
  Partition::Cell* sh_first_smallest();
  Partition::Cell* sh_first_largest();
  Partition::Cell* sh_first_max_neighbours();
  Partition::Cell* sh_first_smallest_max_neighbours();
  Partition::Cell* sh_first_largest_max_neighbours();


  void make_initial_equitable_partition();

  void initialize_certificate();

  bool is_automorphism(unsigned int* const perm) const;


  bool nucr_find_first_component(const unsigned int level);
  bool nucr_find_first_component(const unsigned int level,
                                 std::vector& component,
                                 unsigned int& component_elements,
                                 Partition::Cell*& sh_return);




public:
  /**
   * Create a new graph with \a N vertices and no edges.
   */
  Graph(const unsigned int N = 0);

  /**
   * Destroy the graph.
   */
  ~Graph();

  /**
   * \copydoc AbstractGraph::is_automorphism(const std::vector& perm) const
   */
  bool is_automorphism(const std::vector& perm) const;


  /**
   * \copydoc AbstractGraph::get_hash()
   */
  virtual unsigned int get_hash();

  /**
   * Return the number of vertices in the graph.
   */
  unsigned int get_nof_vertices() const {return vertices.size(); }

  /**
   * \copydoc AbstractGraph::permute(const unsigned int* const perm) const
   */
  Graph* permute(const unsigned int* const perm) const;
  Graph* permute(const std::vector& perm) const;

  /**
   * Add a new vertex with color \a color in the graph and return its index.
   */
  unsigned int add_vertex(const unsigned int color = 0);

  /**
   * Add an edge between vertices \a v1 and \a v2.
   * Duplicate edges between vertices are ignored but try to avoid introducing
   * them in the first place as they are not ignored immediately but will
   * consume memory and computation resources for a while.
   */
  void add_edge(const unsigned int v1, const unsigned int v2);

  /**
   * Change the color of the vertex \a vertex to \a color.
   */
  void change_color(const unsigned int vertex, const unsigned int color);

  /**
   * Compare this graph with the graph \a other.
   * Returns 0 if the graphs are equal, and a negative (positive) integer
   * if this graph is "smaller than" ("greater than", resp.) than \a other.
   */
  int cmp(Graph& other);

  /**
   * Set the splitting heuristic used by the automorphism and canonical
   * labeling algorithm.
   * The selected splitting heuristics affects the computed canonical
   * labelings; therefore, if you want to compare whether two graphs
   * are isomorphic by computing and comparing (for equality) their
   * canonical versions, be sure to use the same splitting heuristics
   * for both graphs.
   */
  void set_splitting_heuristic(const SplittingHeuristic shs) {sh = shs; }


};



/**
 * \brief The class for directed, vertex colored graphs.
 *
 * Multiple edges between vertices are not allowed (i.e., are ignored).
 */
class Digraph : public AbstractGraph
{
public:
  /**
   * The possible splitting heuristics.
   * The selected splitting heuristics affects the computed canonical
   * labelings; therefore, if you want to compare whether two graphs
   * are isomorphic by computing and comparing (for equality) their
   * canonical versions, be sure to use the same splitting heuristics
   * for both graphs.
   */
  typedef enum {
    /** First non-unit cell.
     * Very fast but may result in large search spaces on difficult graphs.
     * Use for large but easy graphs. */
    shs_f = 0,
    /** First smallest non-unit cell.
     * Fast, should usually produce smaller search spaces than shs_f. */
    shs_fs,
    /** First largest non-unit cell.
     * Fast, should usually produce smaller search spaces than shs_f. */
    shs_fl,
    /** First maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_fm,
    /** First smallest maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_fsm,
    /** First largest maximally non-trivially connected non-unit cell.
     * Not so fast, should usually produce smaller search spaces than shs_f,
     * shs_fs, and shs_fl. */
    shs_flm
  } SplittingHeuristic;

protected:
  class Vertex {
  public:
    Vertex();
    ~Vertex();
    void add_edge_to(const unsigned int dest_vertex);
    void add_edge_from(const unsigned int source_vertex);
    void remove_duplicate_edges(std::vector& tmp);
    void sort_edges();
    unsigned int color;
    std::vector edges_out;
    std::vector edges_in;
    unsigned int nof_edges_in() const {return edges_in.size(); }
    unsigned int nof_edges_out() const {return edges_out.size(); }
  };
  std::vector vertices;
  void remove_duplicate_edges();

  /** \internal
   * Partition independent invariant.
   * Returns the color of the vertex.
   * Time complexity: O(1).
   */
  static unsigned int vertex_color_invariant(const Digraph* const g,
                                             const unsigned int v);
  /** \internal
   * Partition independent invariant.
   * Returns the indegree of the vertex.
   * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE.
   * Time complexity: O(1).
   */
  static unsigned int indegree_invariant(const Digraph* const g,
                                         const unsigned int v);
  /** \internal
   * Partition independent invariant.
   * Returns the outdegree of the vertex.
   * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE.
   * Time complexity: O(1).
   */
  static unsigned int outdegree_invariant(const Digraph* const g,
                                          const unsigned int v);
  /** \internal
   * Partition independent invariant.
   * Returns 1 if there is an edge from the vertex to itself, 0 if not.
   * Time complexity: O(k), where k is the number of edges leaving the vertex.
   */
  static unsigned int selfloop_invariant(const Digraph* const g,
                                         const unsigned int v);

  /** \internal
   * Refine the partition \a p according to
   * the partition independent invariant \a inv.
   */
  bool refine_according_to_invariant(unsigned int (*inv)(const Digraph* const g,
                                                         const unsigned int v));

  /*
   * Routines needed when refining the partition p into equitable
   */
  bool split_neighbourhood_of_unit_cell(Partition::Cell* const);
  bool split_neighbourhood_of_cell(Partition::Cell* const);


  /** \internal
   * \copydoc AbstractGraph::is_equitable() const
   */
  bool is_equitable() const;

  /* Splitting heuristics, documented in more detail in the cc-file. */
  SplittingHeuristic sh;
  Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell);
  Partition::Cell* sh_first();
  Partition::Cell* sh_first_smallest();
  Partition::Cell* sh_first_largest();
  Partition::Cell* sh_first_max_neighbours();
  Partition::Cell* sh_first_smallest_max_neighbours();
  Partition::Cell* sh_first_largest_max_neighbours();

  void make_initial_equitable_partition();

  void initialize_certificate();

  bool is_automorphism(unsigned int* const perm) const;

  void sort_edges();

  bool nucr_find_first_component(const unsigned int level);
  bool nucr_find_first_component(const unsigned int level,
                                 std::vector& component,
                                 unsigned int& component_elements,
                                 Partition::Cell*& sh_return);

public:
  /**
   * Create a new directed graph with \a N vertices and no edges.
   */
  Digraph(const unsigned int N = 0);

  /**
   * Destroy the graph.
   */
  ~Digraph();


  /**
   * \copydoc AbstractGraph::is_automorphism(const std::vector& perm) const
   */
  bool is_automorphism(const std::vector& perm) const;



  /**
   * \copydoc AbstractGraph::get_hash()
   */
  virtual unsigned int get_hash();

  /**
   * Return the number of vertices in the graph.
   */
  unsigned int get_nof_vertices() const {return vertices.size(); }

  /**
   * Add a new vertex with color 'color' in the graph and return its index.
   */
  unsigned int add_vertex(const unsigned int color = 0);

  /**
   * Add an edge from the vertex \a source to the vertex \a target.
   * Duplicate edges are ignored but try to avoid introducing
   * them in the first place as they are not ignored immediately but will
   * consume memory and computation resources for a while.
   */
  void add_edge(const unsigned int source, const unsigned int target);

  /**
   * Change the color of the vertex 'vertex' to 'color'.
   */
  void change_color(const unsigned int vertex, const unsigned int color);

  /**
   * Compare this graph with the graph \a other.
   * Returns 0 if the graphs are equal, and a negative (positive) integer
   * if this graph is "smaller than" ("greater than", resp.) than \a other.
   */
  int cmp(Digraph& other);

  /**
   * Set the splitting heuristic used by the automorphism and canonical
   * labeling algorithm.
   * The selected splitting heuristics affects the computed canonical
   * labelings; therefore, if you want to compare whether two graphs
   * are isomorphic by computing and comparing (for equality) their
   * canonical versions, be sure to use the same splitting heuristics
   * for both graphs.
   */
  void set_splitting_heuristic(SplittingHeuristic shs) {sh = shs; }

  /**
   * \copydoc AbstractGraph::permute(const unsigned int* const perm) const
   */
  Digraph* permute(const unsigned int* const perm) const;
  Digraph* permute(const std::vector& perm) const;
};




} // namespace bliss

#endif // BLISS_GRAPH_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/heap.cc0000644000175100001710000000431000000000000025350 0ustar00runnerdocker00000000000000#include "heap.hh"

#include 
#include 

/* Allow using 'and' instead of '&&' with MSVC */
#if _MSC_VER
#include 
#endif

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

Heap::Heap() {
  array = nullptr;
  n = 0;
  N = 0;
}

Heap::~Heap()
{
  delete[] array;
  array = nullptr;
  n = 0;
  N = 0;
}

void Heap::upheap(unsigned int index)
{
  assert(n >= 1);
  assert(index >= 1 and index <= n);
  const unsigned int v = array[index];
  array[0] = 0;
  while(array[index/2] > v)
    {
      array[index] = array[index/2];
      index = index/2;
    }
  array[index] = v;
}

void Heap::downheap(unsigned int index)
{
  const unsigned int v = array[index];
  const unsigned int lim = n/2;
  while(index <= lim)
    {
      unsigned int new_index = index + index;
      if((new_index < n) and (array[new_index] > array[new_index+1]))
        new_index++;
      if(v <= array[new_index])
        break;
      array[index] = array[new_index];
      index = new_index;
    }
  array[index] = v;
}

void Heap::init(const unsigned int size)
{
  assert(size > 0);
  if(size > N)
    {
      delete[] array;
      array = new unsigned int[size + 1];
      N = size;
    }
  n = 0;
}

void Heap::insert(const unsigned int v)
{
  assert(n < N);
  array[++n] = v;
  upheap(n);
}

unsigned int Heap::smallest() const
{
  assert(n >= 1 and n <= N);
  return array[1];
}

unsigned int Heap::remove()
{
  assert(n >= 1 and n <= N);
  const unsigned int v = array[1];
  array[1] = array[n--];
  downheap(1);
  return v;
}

} // namespace bliss
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/heap.hh0000644000175100001710000000404700000000000025371 0ustar00runnerdocker00000000000000#ifndef BLISS_HEAP_HH
#define BLISS_HEAP_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

/**
 * \brief A capacity bounded heap data structure.
 */

class Heap
{
  unsigned int N;
  unsigned int n;
  unsigned int *array;
  void upheap(unsigned int k);
  void downheap(unsigned int k);
public:
  /**
   * Create a new heap.
   * init() must be called after this.
   */
  Heap();
  ~Heap();

  /**
   * Initialize the heap to have the capacity to hold \e size elements.
   */
  void init(const unsigned int size);

  /**
   * Is the heap empty?
   * Time complexity is O(1).
   */
  bool is_empty() const {return n == 0; }

  /**
   * Remove all the elements in the heap.
   * Time complexity is O(1).
   */
  void clear() {n = 0; }

  /**
   * Insert the element \a e in the heap.
   * Time complexity is O(log(N)), where N is the number of elements
   * currently in the heap.
   */
  void insert(const unsigned int e);

  /**
   * Return the smallest element in the heap.
   * Time complexity is O(1).
   */
  unsigned int smallest() const;

  /**
   * Remove and return the smallest element in the heap.
   * Time complexity is O(log(N)), where N is the number of elements
   * currently in the heap.
   */
  unsigned int remove();

  /**
   * Get the number of elements in the heap.
   */
  unsigned int size() const {return n; }
};

} // namespace bliss

#endif // BLISS_HEAP_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/igraph-changes.md0000644000175100001710000000236300000000000027334 0ustar00runnerdocker00000000000000This file lists changes that were made to the original Bliss package (version 0.75) to integrate it into igraph.

Exclude `CMakeLists.txt`, `Doxyfile`, `Makefile-manual`, `readme.txt`. Make sure not to accidentally overwrite igraph's own `bliss/CMakeLists.txt`.

Removed `bliss.cc`, `bliss_C.cc`, `bliss_C.h`.

Remove `timer.hh`. Remove references to `timer.hh` and `Timer` class in `graph.cc`.

Replace `#pragma once` by traditional header guards in all headers.

### In `bignum.hh`:

Replace `#include ` by `#include "internal/gmp_internal.h"`.

At the beginning, add `#define BLISS_USE_GMP`. Verify that this macro is only used in this file.

### In `defs.cc` and `defs.hh`:

Remove the `...` argument from `fatal_error` for simplicity, and make the function simply invoke `IGRAPH_FATAL`.

### In `graph.cc`:

Define `_INTERNAL_ERROR` in terms of `IGRAPH_FATAL`.

### MSVC compatibility

Bliss uses `and`, `or`, etc. instead of `&&`, `||`, etc. These are not supported by MSVC by default. Bliss 0.74 uses the `/permissive` option to enable support in MSVC, but this option is only supported wit VS2019. Instead, in igraph we add the following where relevant:

```
/* Allow using 'and' instead of '&&' with MSVC */
#if _MSC_VER
#include 
#endif
```
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/kqueue.hh0000644000175100001710000000636500000000000025760 0ustar00runnerdocker00000000000000#ifndef BLISS_KQUEUE_HH
#define BLISS_KQUEUE_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

#include 
#include 

namespace bliss {

/**
 * \brief A simple implementation of queues with fixed maximum capacity.
 */
template 
class KQueue
{
public:
  /**
   * Create a new queue with capacity zero.
   * The function init() should be called next.
   */
  KQueue();

  ~KQueue();

  /**
   * Initialize the queue to have the capacity to hold at most \a N elements.
   */
  void init(const unsigned int N);

  /** Is the queue empty? */
  bool is_empty() const;

  /** Return the number of elements in the queue. */
  unsigned int size() const;

  /** Remove all the elements in the queue. */
  void clear();

  /** Return (but don't remove) the first element in the queue. */
  Type front() const;

  /** Remove and return the first element of the queue. */
  Type pop_front();

  /** Push the element \a e in the front of the queue. */
  void push_front(Type e);

  /** Remove and return the last element of the queue. */
  Type pop_back();

  /** Push the element \a e in the back of the queue. */
  void push_back(Type e);
private:
  Type *entries, *end;
  Type *head, *tail;
};

template 
KQueue::KQueue()
{
  entries = nullptr;
  end = nullptr;
  head = nullptr;
  tail = nullptr;
}

template 
KQueue::~KQueue()
{
  delete[] entries;
  entries = nullptr;
  end = nullptr;
  head = nullptr;
  tail = nullptr;
}

template 
void KQueue::init(const unsigned int k)
{
  assert(k > 0);
  delete[] entries;
  entries = new Type[k+1];
  end = entries + k + 1;
  head = entries;
  tail = head;
}

template 
void KQueue::clear()
{
  head = entries;
  tail = head;
}

template 
bool KQueue::is_empty() const
{
  return head == tail;
}

template 
unsigned int KQueue::size() const
{
  if(tail >= head)
    return(tail - head);
  return (end - head) + (tail - entries);
}

template 
Type KQueue::front() const
{
  assert(head != tail);
  return *head;
}

template 
Type KQueue::pop_front()
{
  assert(head != tail);
  Type *old_head = head;
  head++;
  if(head == end)
    head = entries;
  return *old_head;
}

template 
void KQueue::push_front(Type e)
{
  if(head == entries)
    head = end - 1;
  else
    head--;
  assert(head != tail);
  *head = e;
}

template 
void KQueue::push_back(Type e)
{
  *tail = e;
  tail++;
  if(tail == end)
    tail = entries;
  assert(head != tail);
}

} // namespace bliss

#endif // BLISS_KQUEUE_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/kstack.hh0000644000175100001710000000571600000000000025740 0ustar00runnerdocker00000000000000#ifndef BLISS_KSTACK_HH
#define BLISS_KSTACK_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

#include 
#include 

namespace bliss {

/**
 * \brief A simple implementation of a stack with fixed maximum capacity.
 */
template 
class KStack {
public:
  /**
   * Create a new stack with zero capacity.
   * The function init() should be called next.
   */
  KStack();

  /**
   * Create a new stack with the capacity to hold at most \a N elements.
   */
  KStack(int N);

  ~KStack();

  /**
   * Initialize the stack to have the capacity to hold at most \a N elements.
   */
  void init(int N);

  /**
   * Is the stack empty?
   */
  bool is_empty() const {return cursor == entries; }

  /**
   * Return (but don't remove) the top element of the stack.
   */
  Type top() const {assert(cursor > entries); return *cursor; }

  /**
   * Pop (remove) the top element of the stack.
   */
  Type pop()
  {
    assert(cursor > entries);
    return *cursor--;
  }

  /**
   * Push the element \a e in the stack.
   */
  void push(Type e)
  {
    assert(cursor < entries + kapacity);
    *(++cursor) = e;
  }

  /** Remove all the elements in the stack. */
  void clean() {cursor = entries; }

  /**
   * Get the number of elements in the stack.
   */
  unsigned int size() const {return cursor - entries; }

  /**
   * Return the i:th element in the stack, where \a i is in the range
   * 0,...,this.size()-1; the 0:th element is the bottom element
   * in the stack.
   */
  Type element_at(unsigned int i)
  {
    assert(i < size());
    return entries[i+1];
  }

  /** Return the capacity (NOT the number of elements) of the stack. */
  int capacity() const {return kapacity; }
private:
  int kapacity;
  Type *entries;
  Type *cursor;
};

template 
KStack::KStack()
{
  kapacity = 0;
  entries = nullptr;
  cursor = nullptr;
}

template 
KStack::KStack(int k)
{
  assert(k > 0);
  kapacity = k;
  entries = new Type[k+1];
  cursor = entries;
}

template 
void KStack::init(int k)
{
  assert(k > 0);
  delete[] entries;
  kapacity = k;
  entries = new Type[k+1];
  cursor = entries;
}

template 
KStack::~KStack()
{
  delete[] entries;
  kapacity = 0;
  entries = nullptr;
  cursor = nullptr;
}

} // namespace bliss

#endif // BLISS_KSTACK_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/orbit.cc0000644000175100001710000000601300000000000025554 0ustar00runnerdocker00000000000000#include 
#include "orbit.hh"

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

Orbit::Orbit()
{
  orbits = 0;
  in_orbit = 0;
  nof_elements = 0;
}


Orbit::~Orbit()
{
  delete[] orbits;
  orbits = 0;
  /*
  if(orbits)
    {
      free(orbits);
      orbits = 0;
    }
  */
  delete[] in_orbit;
  in_orbit = 0;
  /*
  if(in_orbit)
    {
      free(in_orbit);
      in_orbit = 0;
    }
  */
  nof_elements = 0;
  _nof_orbits = 0;
}


void Orbit::init(const unsigned int n)
{
  assert(n > 0);
  if(orbits) delete[] orbits;
  orbits = new OrbitEntry[n];
  delete[] in_orbit;
  in_orbit = new OrbitEntry*[n];
  nof_elements = n;

  reset();
}


void Orbit::reset()
{
  assert(orbits);
  assert(in_orbit);

  for(unsigned int i = 0; i < nof_elements; i++)
    {
      orbits[i].element = i;
      orbits[i].next = 0;
      orbits[i].size = 1;
      in_orbit[i] = &orbits[i];
    }
  _nof_orbits = nof_elements;
}


void Orbit::merge_orbits(OrbitEntry *orbit1, OrbitEntry *orbit2)
{

  if(orbit1 != orbit2)
    {
      _nof_orbits--;
      /* Only update the elements in the smaller orbit */
      if(orbit1->size > orbit2->size)
        {
          OrbitEntry * const temp = orbit2;
          orbit2 = orbit1;
          orbit1 = temp;
        }
      /* Link the elements of orbit1 to the almost beginning of orbit2 */
      OrbitEntry *e = orbit1;
      while(e->next)
        {
          in_orbit[e->element] = orbit2;
          e = e->next;
        }
      in_orbit[e->element] = orbit2;
      e->next = orbit2->next;
      orbit2->next = orbit1;
      /* Keep the minimal orbit representative in the beginning */
      if(orbit1->element < orbit2->element)
        {
          const unsigned int temp = orbit1->element;
          orbit1->element = orbit2->element;
          orbit2->element = temp;
        }
      orbit2->size += orbit1->size;
    }
}


void Orbit::merge_orbits(unsigned int e1, unsigned int e2)
{

  merge_orbits(in_orbit[e1], in_orbit[e2]);
}


bool Orbit::is_minimal_representative(unsigned int element) const
{
  return(get_minimal_representative(element) == element);
}


unsigned int Orbit::get_minimal_representative(unsigned int element) const
{

  OrbitEntry * const orbit = in_orbit[element];

  return(orbit->element);
}


unsigned int Orbit::orbit_size(unsigned int element) const
{

  return(in_orbit[element]->size);
}


} // namespace bliss
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/orbit.hh0000644000175100001710000000602400000000000025570 0ustar00runnerdocker00000000000000#ifndef BLISS_ORBIT_HH
#define BLISS_ORBIT_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

/**
 * \brief A class for representing orbit information.
 *
 * Given a set {0,...,N-1} of N elements, represent equivalence
 * classes (that is, unordered partitions) of the elements.
 * Supports only equivalence class merging, not splitting.
 * Merging two classes requires time O(k), where k is the number of
 * the elements in the smaller of the merged classes.
 * Getting the smallest representative in a class
 * (and thus testing whether two elements belong to the same class)
 * is a constant time operation.
 */
class Orbit
{
  class OrbitEntry
  {
  public:
    unsigned int element;
    OrbitEntry *next;
    unsigned int size;
  };

  OrbitEntry *orbits;
  OrbitEntry **in_orbit;
  unsigned int nof_elements;
  unsigned int _nof_orbits;
  void merge_orbits(OrbitEntry *o1, OrbitEntry *o2);

public:
  /**
   * Create a new orbit information object.
   * The init() function must be called next to actually initialize
   * the object.
   */
  Orbit();
  ~Orbit();

  /**
   * Initialize the orbit information to consider sets of \a N elements.
   * It is required that \a N > 0.
   * The orbit information is reset so that each element forms
   * an orbit of its own.
   * Time complexity is O(N).
   * \sa reset()
   */
  void init(const unsigned int N);

  /**
   * Reset the orbits so that each element forms an orbit of its own.
   * Time complexity is O(N).
   */
  void reset();

  /**
   * Merge the orbits of the elements \a e1 and \a e2.
   * Time complexity is O(k), where k is the number of elements in
   * the smaller of the merged orbits.
   */
  void merge_orbits(unsigned int e1, unsigned int e2);

  /**
   * Is the element \a e the smallest element in its orbit?
   * Time complexity is O(1).
   */
  bool is_minimal_representative(unsigned int e) const;

  /**
   * Get the smallest element in the orbit of the element \a e.
   * Time complexity is O(1).
   */
  unsigned int get_minimal_representative(unsigned int e) const;

  /**
   * Get the number of elements in the orbit of the element \a e.
   * Time complexity is O(1).
   */
  unsigned int orbit_size(unsigned int e) const;

  /**
   * Get the number of orbits.
   * Time complexity is O(1).
   */
  unsigned int nof_orbits() const {return _nof_orbits; }
};

} // namespace bliss

#endif // BLISS_ORBIT_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/partition.cc0000644000175100001710000007212700000000000026457 0ustar00runnerdocker00000000000000#include 
#include 

#include "graph.hh"
#include "partition.hh"

/* Allow using 'and' instead of '&&' with MSVC */
#if _MSC_VER
#include 
#endif

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

Partition::Partition()
{
  N = 0;
  elements = 0;
  in_pos = 0;
  invariant_values = 0;
  cells = 0;
  free_cells = 0;
  element_to_cell_map = 0;
  graph = 0;
  discrete_cell_count = 0;
  /* Initialize a distribution count sorting array. */
  for(unsigned int i = 0; i < 256; i++)
    dcs_count[i] = 0;

  cr_enabled = false;
  cr_cells = 0;
  cr_levels = 0;
}



Partition::~Partition()
{
  delete[] elements; elements = nullptr;
  delete[] cells; cells = nullptr;
  delete[] element_to_cell_map; element_to_cell_map = nullptr;
  delete[] in_pos; in_pos = nullptr;
  delete[] invariant_values; invariant_values = nullptr;
  N = 0;
}



void Partition::init(const unsigned int M)
{
  assert(M > 0);
  N = M;

  delete[] elements;
  elements = new unsigned int[N];
  for(unsigned int i = 0; i < N; i++)
    elements[i] = i;

  delete[] in_pos;
  in_pos = new unsigned int*[N];
  for(unsigned int i = 0; i < N; i++)
    in_pos[i] = elements + i;

  delete[] invariant_values;
  invariant_values = new unsigned int[N];
  for(unsigned int i = 0; i < N; i++)
    invariant_values[i] = 0;

  delete[] cells;
  cells = new Cell[N];

  cells[0].first = 0;
  cells[0].length = N;
  cells[0].max_ival = 0;
  cells[0].max_ival_count = 0;
  cells[0].in_splitting_queue = false;
  cells[0].in_neighbour_heap = false;
  cells[0].prev = 0;
  cells[0].next = 0;
  cells[0].next_nonsingleton = 0;
  cells[0].prev_nonsingleton = 0;
  cells[0].split_level = 0;
  first_cell = &cells[0];
  if(N == 1)
    {
      first_nonsingleton_cell = 0;
      discrete_cell_count = 1;
    }
  else
    {
      first_nonsingleton_cell = &cells[0];
      discrete_cell_count = 0;
    }

  for(unsigned int i = 1; i < N; i++)
    {
      cells[i].first = 0;
      cells[i].length = 0;
      cells[i].max_ival = 0;
      cells[i].max_ival_count = 0;
      cells[i].in_splitting_queue = false;
      cells[i].in_neighbour_heap = false;
      cells[i].prev = 0;
      cells[i].next = (i < N-1)?&cells[i+1]:0;
      cells[i].next_nonsingleton = 0;
      cells[i].prev_nonsingleton = 0;
    }
  if(N > 1)
    free_cells = &cells[1];
  else
    free_cells = 0;

  delete[] element_to_cell_map;
  element_to_cell_map = new Cell*[N];
  for(unsigned int i = 0; i < N; i++)
    element_to_cell_map[i] = first_cell;

  splitting_queue.init(N);
  refinement_stack.init(N);

  /* Reset the main backtracking stack */
  bt_stack.clear();
}






Partition::BacktrackPoint
Partition::set_backtrack_point()
{
  BacktrackInfo info;
  info.refinement_stack_size = refinement_stack.size();
  if(cr_enabled)
    info.cr_backtrack_point = cr_get_backtrack_point();
  BacktrackPoint p = bt_stack.size();
  bt_stack.push_back(info);
  return p;
}



void
Partition::goto_backtrack_point(BacktrackPoint p)
{
  assert(p < bt_stack.size());
  BacktrackInfo info = bt_stack[p];
  bt_stack.resize(p);

  if(cr_enabled)
    cr_goto_backtrack_point(info.cr_backtrack_point);

  const unsigned int dest_refinement_stack_size = info.refinement_stack_size;

  assert(refinement_stack.size() >= dest_refinement_stack_size);
  while(refinement_stack.size() > dest_refinement_stack_size)
    {
      RefInfo i = refinement_stack.pop();
      const unsigned int first = i.split_cell_first;
      Cell* cell = get_cell(elements[first]);

      if(cell->first != first)
        {
          assert(cell->first < first);
          assert(cell->split_level <= dest_refinement_stack_size);
          goto done;
        }
      assert(cell->split_level > dest_refinement_stack_size);

      while(cell->split_level > dest_refinement_stack_size)
        {
          assert(cell->prev);
          cell = cell->prev;
        }
      while(cell->next and
            cell->next->split_level > dest_refinement_stack_size)
        {
          /* Merge next cell */
          Cell* const next_cell = cell->next;
          if(cell->length == 1)
            discrete_cell_count--;
          if(next_cell->length == 1)
            discrete_cell_count--;
          /* Update element_to_cell_map values of elements added in cell */
          unsigned int* ep = elements + next_cell->first;
          unsigned int* const lp = ep + next_cell->length;
          for( ; ep < lp; ep++)
            element_to_cell_map[*ep] = cell;
          /* Update cell parameters */
          cell->length += next_cell->length;
          if(next_cell->next)
            next_cell->next->prev = cell;
          cell->next = next_cell->next;
          /* (Pseudo)free next_cell */
          next_cell->first = 0;
          next_cell->length = 0;
          next_cell->prev = 0;
          next_cell->next = free_cells;
          free_cells = next_cell;
        }

    done:
      if(i.prev_nonsingleton_first >= 0)
        {
          Cell* const prev_cell = get_cell(elements[i.prev_nonsingleton_first]);
          assert(prev_cell->length > 1);
          cell->prev_nonsingleton = prev_cell;
          prev_cell->next_nonsingleton = cell;
        }
      else
        {
          //assert(cell->prev_nonsingleton == 0);
          cell->prev_nonsingleton = 0;
          first_nonsingleton_cell = cell;
        }

      if(i.next_nonsingleton_first >= 0)
        {
          Cell* const next_cell = get_cell(elements[i.next_nonsingleton_first]);
          assert(next_cell->length > 1);
          cell->next_nonsingleton = next_cell;
          next_cell->prev_nonsingleton = cell;
        }
      else
        {
          //assert(cell->next_nonsingleton == 0);
          cell->next_nonsingleton = 0;
        }
    }

}



Partition::Cell*
Partition::individualize(Partition::Cell * const cell,
                         const unsigned int element)
{
  assert(!cell->is_unit());

  unsigned int * const pos = in_pos[element];
  assert((unsigned int)(pos - elements) >= cell->first);
  assert((unsigned int)(pos - elements) < cell->first + cell->length);
  assert(*pos == element);

  const unsigned int last = cell->first + cell->length - 1;
  *pos = elements[last];
  in_pos[*pos] = pos;
  elements[last] = element;
  in_pos[element] = elements + last;

  Partition::Cell * const new_cell = aux_split_in_two(cell, cell->length-1);
  assert(elements[new_cell->first] == element);
  element_to_cell_map[element] = new_cell;

  return new_cell;
}



Partition::Cell*
Partition::aux_split_in_two(Partition::Cell* const cell,
                            const unsigned int first_half_size)
{
  RefInfo i;

  assert(0 < first_half_size && first_half_size < cell->length);

  /* (Pseudo)allocate new cell */
  Cell * const new_cell = free_cells;
  assert(new_cell != 0);
  free_cells = new_cell->next;
  /* Update new cell parameters */
  new_cell->first = cell->first + first_half_size;
  new_cell->length = cell->length - first_half_size;
  new_cell->next = cell->next;
  if(new_cell->next)
    new_cell->next->prev = new_cell;
  new_cell->prev = cell;
  new_cell->split_level = refinement_stack.size()+1;
  /* Update old, splitted cell parameters */
  cell->length = first_half_size;
  cell->next = new_cell;
  /* CR */
  if(cr_enabled)
    cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));

  /* Add cell in refinement_stack for backtracking */
  i.split_cell_first = new_cell->first;
  if(cell->prev_nonsingleton)
    i.prev_nonsingleton_first = cell->prev_nonsingleton->first;
  else
    i.prev_nonsingleton_first = -1;
  if(cell->next_nonsingleton)
    i.next_nonsingleton_first = cell->next_nonsingleton->first;
  else
    i.next_nonsingleton_first = -1;
  refinement_stack.push(i);

  /* Modify nonsingleton cell list */
  if(new_cell->length > 1)
    {
      new_cell->prev_nonsingleton = cell;
      new_cell->next_nonsingleton = cell->next_nonsingleton;
      if(new_cell->next_nonsingleton)
        new_cell->next_nonsingleton->prev_nonsingleton = new_cell;
      cell->next_nonsingleton = new_cell;
    }
  else
    {
      new_cell->next_nonsingleton = 0;
      new_cell->prev_nonsingleton = 0;
      discrete_cell_count++;
    }

  if(cell->is_unit())
    {
      if(cell->prev_nonsingleton)
        cell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton;
      else
        first_nonsingleton_cell = cell->next_nonsingleton;
      if(cell->next_nonsingleton)
        cell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton;
      cell->next_nonsingleton = 0;
      cell->prev_nonsingleton = 0;
      discrete_cell_count++;
    }

  return new_cell;
}



void
Partition::splitting_queue_add(Cell* const cell)
{
  static const unsigned int smallish_cell_threshold = 1;
  assert(!cell->in_splitting_queue);
  cell->in_splitting_queue = true;
  if(cell->length <= smallish_cell_threshold)
    splitting_queue.push_front(cell);
  else
    splitting_queue.push_back(cell);
}



void
Partition::splitting_queue_clear()
{
  while(!splitting_queue_is_empty())
    splitting_queue_pop();
}





/*
 * Assumes that the invariant values are NOT the same
 * and that the cell contains more than one element
 */
Partition::Cell*
Partition::sort_and_split_cell1(Partition::Cell* const cell)
{
#if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS)
  assert(cell->length > 1);
  assert(cell->first + cell->length <= N);
  unsigned int nof_0_found = 0;
  unsigned int nof_1_found = 0;
  for(unsigned int i = cell->first; i < cell->first + cell->length; i++)
    {
      const unsigned int ival = invariant_values[elements[i]];
      assert(ival == 0 or ival == 1);
      if(ival == 0) nof_0_found++;
      else nof_1_found++;
    }
  assert(nof_0_found > 0);
  assert(nof_1_found > 0);
  assert(nof_1_found == cell->max_ival_count);
  assert(nof_0_found + nof_1_found == cell->length);
  assert(cell->max_ival == 1);
#endif


  /* (Pseudo)allocate new cell */
  Cell* const new_cell = free_cells;
  assert(new_cell != 0);
  free_cells = new_cell->next;

#define NEW_SORT1
#ifdef NEW_SORT1
      unsigned int *ep0 = elements + cell->first;
      unsigned int *ep1 = ep0 + cell->length - cell->max_ival_count;
      if(cell->max_ival_count > cell->length / 2)
        {
          /* There are more ones than zeros, only move zeros */
          unsigned int * const end = ep0 + cell->length;
          while(ep1 < end)
            {
              while(invariant_values[*ep1] == 0)
                {
                  const unsigned int tmp = *ep1;
                  *ep1 = *ep0;
                  *ep0 = tmp;
                  in_pos[tmp] = ep0;
                  in_pos[*ep1] = ep1;
                  ep0++;
                }
              element_to_cell_map[*ep1] = new_cell;
              invariant_values[*ep1] = 0;
              ep1++;
            }
        }
      else
        {
          /* There are more zeros than ones, only move ones */
          unsigned int * const end = ep1;
          while(ep0 < end)
            {
              while(invariant_values[*ep0] != 0)
                {
                  const unsigned int tmp = *ep0;
                  *ep0 = *ep1;
                  *ep1 = tmp;
                  in_pos[tmp] = ep1;
                  in_pos[*ep0] = ep0;
                  ep1++;
                }
              ep0++;
            }
          ep1 = end;
          while(ep1 < elements + cell->first + cell->length)
            {
              element_to_cell_map[*ep1] = new_cell;
              invariant_values[*ep1] = 0;
              ep1++;
            }
        }
  /* Update new cell parameters */
  new_cell->first = cell->first + cell->length - cell->max_ival_count;
  new_cell->length = cell->length - (new_cell->first - cell->first);
  new_cell->next = cell->next;
  if(new_cell->next)
    new_cell->next->prev = new_cell;
  new_cell->prev = cell;
  new_cell->split_level = refinement_stack.size()+1;
  /* Update old, splitted cell parameters */
  cell->length = new_cell->first - cell->first;
  cell->next = new_cell;
  /* CR */
  if(cr_enabled)
    cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));

#else
  /* Sort vertices in the cell according to the invariant values */
  unsigned int *ep0 = elements + cell->first;
  unsigned int *ep1 = ep0 + cell->length;
  while(ep1 > ep0)
    {
      const unsigned int element = *ep0;
      const unsigned int ival = invariant_values[element];
      invariant_values[element] = 0;
      assert(ival <= 1);
      assert(element_to_cell_map[element] == cell);
      assert(in_pos[element] == ep0);
      if(ival == 0)
        {
          ep0++;
        }
      else
        {
          ep1--;
          *ep0 = *ep1;
          *ep1 = element;
          element_to_cell_map[element] = new_cell;
          in_pos[element] = ep1;
          in_pos[*ep0] = ep0;
        }
    }

  assert(ep1 != elements + cell->first);
  assert(ep0 != elements + cell->first + cell->length);

  /* Update new cell parameters */
  new_cell->first = ep1 - elements;
  new_cell->length = cell->length - (new_cell->first - cell->first);
  new_cell->next = cell->next;
  if(new_cell->next)
    new_cell->next->prev = new_cell;
  new_cell->prev = cell;
  new_cell->split_level = cell->split_level;
  /* Update old, splitted cell parameters */
  cell->length = new_cell->first - cell->first;
  cell->next = new_cell;
  cell->split_level = refinement_stack.size()+1;
  /* CR */
  if(cr_enabled)
    cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first));

#endif /* ifdef NEW_SORT1*/

  /* Add cell in refinement stack for backtracking */
  {
    RefInfo i;
    i.split_cell_first = new_cell->first;
    if(cell->prev_nonsingleton)
      i.prev_nonsingleton_first = cell->prev_nonsingleton->first;
    else
      i.prev_nonsingleton_first = -1;
    if(cell->next_nonsingleton)
      i.next_nonsingleton_first = cell->next_nonsingleton->first;
    else
      i.next_nonsingleton_first = -1;
    /* Modify nonsingleton cell list */
    if(new_cell->length > 1)
      {
        new_cell->prev_nonsingleton = cell;
        new_cell->next_nonsingleton = cell->next_nonsingleton;
        if(new_cell->next_nonsingleton)
          new_cell->next_nonsingleton->prev_nonsingleton = new_cell;
        cell->next_nonsingleton = new_cell;
      }
    else
      {
        new_cell->next_nonsingleton = 0;
        new_cell->prev_nonsingleton = 0;
        discrete_cell_count++;
      }
    if(cell->is_unit())
      {
        if(cell->prev_nonsingleton)
          cell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton;
        else
          first_nonsingleton_cell = cell->next_nonsingleton;
        if(cell->next_nonsingleton)
          cell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton;
        cell->next_nonsingleton = 0;
        cell->prev_nonsingleton = 0;
        discrete_cell_count++;
      }
    refinement_stack.push(i);
  }


  /* Add cells in splitting queue */
  assert(!new_cell->in_splitting_queue);
  if(cell->in_splitting_queue) {
    /* Both cells must be included in splitting_queue in order to have
       refinement to equitable partition */
    splitting_queue_add(new_cell);
  } else {
    Cell *min_cell, *max_cell;
    if(cell->length <= new_cell->length) {
      min_cell = cell;
      max_cell = new_cell;
    } else {
      min_cell = new_cell;
      max_cell = cell;
    }
    /* Put the smaller cell in splitting_queue */
    splitting_queue_add(min_cell);
    if(max_cell->is_unit()) {
      /* Put the "larger" cell also in splitting_queue */
      splitting_queue_add(max_cell);
    }
  }


  return new_cell;
}





/**
 * An auxiliary function for distribution count sorting.
 * Build start array so that
 * dcs_start[0] = 0 and dcs_start[i+1] = dcs_start[i] + dcs_count[i].
 */
void
Partition::dcs_cumulate_count(const unsigned int max)
{
  assert(max <= 255);
  unsigned int* count_p = dcs_count;
  unsigned int* start_p = dcs_start;
  unsigned int sum = 0;
  for(unsigned int i = max+1; i > 0; i--)
    {
      *start_p = sum;
      start_p++;
      sum += *count_p;
      count_p++;
    }
}


/**
 * Distribution count sorting of cells with invariant values less than 256.
 */
Partition::Cell*
Partition::sort_and_split_cell255(Partition::Cell* const cell,
                                  const unsigned int max_ival)
{
  assert(max_ival <= 255);

  if(cell->is_unit())
    {
      /* Reset invariant value */
      invariant_values[elements[cell->first]] = 0;
      return cell;
    }

#ifdef BLISS_CONSISTENCY_CHECKS
  for(unsigned int i = 0; i < 256; i++)
    assert(dcs_count[i] == 0);
#endif

  /*
   * Compute the distribution of invariant values to the count array
   */
  {
    const unsigned int *ep = elements + cell->first;
    assert(element_to_cell_map[*ep] == cell);
    const unsigned int ival = invariant_values[*ep];
    assert(ival <= 255);
    dcs_count[ival]++;
    ep++;
#if defined(BLISS_CONSISTENCY_CHECKS)
    bool equal_invariant_values = true;
#endif
    for(unsigned int i = cell->length - 1; i != 0; i--)
      {
        assert(element_to_cell_map[*ep] == cell);
        const unsigned int ival2 = invariant_values[*ep];
        assert(ival2 <= 255);
        assert(ival2 <= max_ival);
        dcs_count[ival2]++;
#if defined(BLISS_CONSISTENCY_CHECKS)
        if(ival2 != ival) {
          equal_invariant_values = false;
        }
#endif
        ep++;
      }
#if defined(BLISS_CONSISTENCY_CHECKS)
    assert(!equal_invariant_values);
    if(equal_invariant_values) {
      assert(dcs_count[ival] == cell->length);
      dcs_count[ival] = 0;
      clear_ivs(cell);
      return cell;
    }
#endif
  }

  /* Build start array */
  dcs_cumulate_count(max_ival);

  //assert(dcs_start[255] + dcs_count[255] == cell->length);
  assert(dcs_start[max_ival] + dcs_count[max_ival] == cell->length);

  /* Do the sorting */
  for(unsigned int i = 0; i <= max_ival; i++)
    {
      unsigned int *ep = elements + cell->first + dcs_start[i];
      for(unsigned int j = dcs_count[i]; j > 0; j--)
        {
          while(true)
            {
              const unsigned int element = *ep;
              const unsigned int ival = invariant_values[element];
              if(ival == i)
                break;
              assert(ival > i);
              assert(dcs_count[ival] > 0);
              *ep = elements[cell->first + dcs_start[ival]];
              elements[cell->first + dcs_start[ival]] = element;
              dcs_start[ival]++;
              dcs_count[ival]--;
            }
          ep++;
        }
      dcs_count[i] = 0;
    }

#if defined(BLISS_CONSISTENCY_CHECKS)
  for(unsigned int i = 0; i < 256; i++)
    assert(dcs_count[i] == 0);
#endif

  /* split cell */
  Cell* const new_cell = split_cell(cell);
  assert(new_cell != cell);
  return new_cell;
}



/*
 * Sort the elements in a cell according to their invariant values.
 * The invariant values are not cleared.
 * Warning: the in_pos array is left in incorrect state.
 */
bool
Partition::shellsort_cell(Partition::Cell* const cell)
{
  unsigned int h;
  unsigned int* ep;

  //assert(cell->first + cell->length <= N);

  if(cell->is_unit())
    return false;

  /* Check whether all the elements have the same invariant value */
  bool equal_invariant_values = true;
  {
    ep = elements + cell->first;
    const unsigned int ival = invariant_values[*ep];
    assert(element_to_cell_map[*ep] == cell);
    ep++;
    for(unsigned int i = cell->length - 1; i > 0; i--)
      {
        assert(element_to_cell_map[*ep] == cell);
        if(invariant_values[*ep] != ival) {
          equal_invariant_values = false;
          break;
        }
        ep++;
      }
  }
  if(equal_invariant_values)
    return false;

  ep = elements + cell->first;

  for(h = 1; h <= cell->length/9; h = 3*h + 1)
    ;
  for( ; h > 0; h = h/3) {
    for(unsigned int i = h; i < cell->length; i++) {
      const unsigned int element = ep[i];
      const unsigned int ival = invariant_values[element];
      unsigned int j = i;
      while(j >= h and invariant_values[ep[j-h]] > ival) {
        ep[j] = ep[j-h];
        j -= h;
      }
      ep[j] = element;
    }
  }
  return true;
}



void
Partition::clear_ivs(Cell* const cell)
{
  unsigned int* ep = elements + cell->first;
  for(unsigned int i = cell->length; i > 0; i--, ep++)
    invariant_values[*ep] = 0;
}


/*
 * Assumes that the elements in the cell are sorted according to their
 * invariant values.
 */
Partition::Cell*
Partition::split_cell(Partition::Cell* const original_cell)
{
  Cell* cell = original_cell;
  const bool original_cell_was_in_splitting_queue =
    original_cell->in_splitting_queue;
  Cell* largest_new_cell = 0;

  while(true)
    {
      unsigned int* ep = elements + cell->first;
      const unsigned int* const lp = ep + cell->length;
      const unsigned int ival = invariant_values[*ep];
      invariant_values[*ep] = 0;
      element_to_cell_map[*ep] = cell;
      in_pos[*ep] = ep;
      ep++;
      while(ep < lp)
        {
          const unsigned int e = *ep;
          if(invariant_values[e] != ival)
            break;
          invariant_values[e] = 0;
          in_pos[e] = ep;
          ep++;
          element_to_cell_map[e] = cell;
        }
      if(ep == lp)
        break;

      Cell* const new_cell = aux_split_in_two(cell,
                                              (ep - elements) - cell->first);

      if(graph and graph->compute_eqref_hash)
        {
          graph->eqref_hash.update(new_cell->first);
          graph->eqref_hash.update(new_cell->length);
          graph->eqref_hash.update(ival);
        }

      /* Add cells in splitting_queue */
      assert(!new_cell->is_in_splitting_queue());
      if(original_cell_was_in_splitting_queue)
        {
          /* In this case, all new cells are inserted in splitting_queue */
          assert(cell->is_in_splitting_queue());
          splitting_queue_add(new_cell);
        }
      else
        {
          /* Otherwise, we can omit one new cell from splitting_queue */
          assert(!cell->is_in_splitting_queue());
          if(largest_new_cell == 0) {
            largest_new_cell = cell;
          } else {
            assert(!largest_new_cell->is_in_splitting_queue());
            if(cell->length > largest_new_cell->length) {
              splitting_queue_add(largest_new_cell);
              largest_new_cell = cell;
            } else {
              splitting_queue_add(cell);
            }
          }
        }
      /* Process the rest of the cell */
      cell = new_cell;
    }


  if(original_cell == cell) {
    /* All the elements in cell had the same invariant value */
    return cell;
  }

  /* Add cells in splitting_queue */
  if(!original_cell_was_in_splitting_queue)
    {
      /* Also consider the last new cell */
      assert(largest_new_cell);
      if(cell->length > largest_new_cell->length)
        {
          splitting_queue_add(largest_new_cell);
          largest_new_cell = cell;
        }
      else
        {
          splitting_queue_add(cell);
        }
      if(largest_new_cell->is_unit())
        {
          /* Needed in certificate computation */
          splitting_queue_add(largest_new_cell);
        }
    }

  return cell;
}


Partition::Cell*
Partition::zplit_cell(Partition::Cell* const cell,
                      const bool max_ival_info_ok)
{
  assert(cell != 0);

  Cell* last_new_cell = cell;

  if(!max_ival_info_ok)
    {
      /* Compute max_ival info */
      assert(cell->max_ival == 0);
      assert(cell->max_ival_count == 0);
      unsigned int *ep = elements + cell->first;
      for(unsigned int i = cell->length; i > 0; i--, ep++)
        {
          const unsigned int ival = invariant_values[*ep];
          if(ival > cell->max_ival)
            {
              cell->max_ival = ival;
              cell->max_ival_count = 1;
            }
          else if(ival == cell->max_ival)
            {
              cell->max_ival_count++;
            }
        }
    }

#ifdef BLISS_CONSISTENCY_CHECKS
  /* Verify max_ival info */
  {
    unsigned int nof_zeros = 0;
    unsigned int max_ival = 0;
    unsigned int max_ival_count = 0;
    unsigned int *ep = elements + cell->first;
    for(unsigned int i = cell->length; i > 0; i--, ep++)
      {
        const unsigned int ival = invariant_values[*ep];
        if(ival == 0)
          nof_zeros++;
        if(ival > max_ival)
          {
            max_ival = ival;
            max_ival_count = 1;
          }
        else if(ival == max_ival)
          max_ival_count++;
      }
    assert(max_ival == cell->max_ival);
    assert(max_ival_count == cell->max_ival_count);
  }
#endif

  /* max_ival info has been computed */

  if(cell->max_ival_count == cell->length)
    {
      /* All invariant values are the same, clear 'em */
      if(cell->max_ival > 0)
        clear_ivs(cell);
    }
  else
    {
      /* All invariant values are not the same */
      if(cell->max_ival == 1)
        {
          /* Specialized splitting for cells with binary invariant values */
          last_new_cell = sort_and_split_cell1(cell);
        }
      else if(cell->max_ival < 256)
        {
          /* Specialized splitting for cells with invariant values < 256 */
          last_new_cell = sort_and_split_cell255(cell, cell->max_ival);
        }
      else
        {
          /* Generic sorting and splitting */
          const bool sorted = shellsort_cell(cell);
          assert(sorted);
          last_new_cell = split_cell(cell);
        }
    }
  cell->max_ival = 0;
  cell->max_ival_count = 0;
  return last_new_cell;
}



/*
 *
 * Component recursion specific code
 *
 */
void
Partition::cr_init()
{
  assert(bt_stack.empty());

  cr_enabled = true;

  delete[] cr_cells;
  cr_cells = new CRCell[N];

  delete[] cr_levels;
  cr_levels = new CRCell*[N];

  for(unsigned int i = 0; i < N; i++) {
    cr_levels[i] = 0;
    cr_cells[i].level = UINT_MAX;
    cr_cells[i].next = 0;
    cr_cells[i].prev_next_ptr = 0;
  }

  for(const Cell *cell = first_cell; cell; cell = cell->next)
    cr_create_at_level_trailed(cell->first, 0);

  cr_max_level = 0;
}


void
Partition::cr_free()
{
  delete[] cr_cells; cr_cells = nullptr;
  delete[] cr_levels; cr_levels = nullptr;

  cr_created_trail.clear();
  cr_splitted_level_trail.clear();
  cr_bt_info.clear();
  cr_max_level = 0;

  cr_enabled = false;
}


unsigned int
Partition::cr_split_level(const unsigned int level,
                          const std::vector& splitted_cells)
{
  assert(cr_enabled);
  assert(level <= cr_max_level);
  cr_levels[++cr_max_level] = 0;
  cr_splitted_level_trail.push_back(level);

  for(unsigned int i = 0; i < splitted_cells.size(); i++)
    {
      const unsigned int cell_index = splitted_cells[i];
      assert(cell_index < N);
      CRCell& cr_cell = cr_cells[cell_index];
      assert(cr_cell.level == level);
      cr_cell.detach();
      cr_create_at_level(cell_index, cr_max_level);
    }

  return cr_max_level;
}


unsigned int
Partition::cr_get_backtrack_point()
{
  assert(cr_enabled);
  CR_BTInfo info;
  info.created_trail_index = cr_created_trail.size();
  info.splitted_level_trail_index = cr_splitted_level_trail.size();
  cr_bt_info.push_back(info);
  return cr_bt_info.size()-1;
}


void
Partition::cr_goto_backtrack_point(const unsigned int btpoint)
{
  assert(cr_enabled);
  assert(btpoint < cr_bt_info.size());
  while(cr_created_trail.size() > cr_bt_info[btpoint].created_trail_index)
    {
      const unsigned int cell_index = cr_created_trail.back();
      cr_created_trail.pop_back();
      CRCell& cr_cell = cr_cells[cell_index];
      assert(cr_cell.level != UINT_MAX);
      assert(cr_cell.prev_next_ptr);
      cr_cell.detach();
    }

  while(cr_splitted_level_trail.size() >
        cr_bt_info[btpoint].splitted_level_trail_index)
    {
      const unsigned int dest_level = cr_splitted_level_trail.back();
      cr_splitted_level_trail.pop_back();
      assert(cr_max_level > 0);
      assert(dest_level < cr_max_level);
      while(cr_levels[cr_max_level]) {
        CRCell *cr_cell = cr_levels[cr_max_level];
        cr_cell->detach();
        cr_create_at_level(cr_cell - cr_cells, dest_level);
      }
      cr_max_level--;
    }
  cr_bt_info.resize(btpoint);
}


void
Partition::cr_create_at_level(const unsigned int cell_index,
                              const unsigned int level)
{
  assert(cr_enabled);
  assert(cell_index < N);
  assert(level < N);
  CRCell& cr_cell = cr_cells[cell_index];
  assert(cr_cell.level == UINT_MAX);
  assert(cr_cell.next == 0);
  assert(cr_cell.prev_next_ptr == 0);
  if(cr_levels[level])
    cr_levels[level]->prev_next_ptr = &(cr_cell.next);
  cr_cell.next = cr_levels[level];
  cr_levels[level] = &cr_cell;
  cr_cell.prev_next_ptr = &cr_levels[level];
  cr_cell.level = level;
}


void
Partition::cr_create_at_level_trailed(const unsigned int cell_index,
                                      const unsigned int level)
{
  assert(cr_enabled);
  cr_create_at_level(cell_index, level);
  cr_created_trail.push_back(cell_index);
}


} // namespace bliss
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/partition.hh0000644000175100001710000002020300000000000026455 0ustar00runnerdocker00000000000000#ifndef BLISS_PARTITION_HH
#define BLISS_PARTITION_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {
  class Partition;
}

#include 
#include 
#include "kstack.hh"
#include "kqueue.hh"
#include "graph.hh"


namespace bliss {

/**
 * \brief A class for refinable, backtrackable ordered partitions.
 *
 * This is rather a data structure with some helper functions than
 * a proper self-contained class.
 * That is, for efficiency reasons the fields of this class are directly
 * manipulated from bliss::AbstractGraph and its subclasses.
 * Conversely, some methods of this class modify the fields of
 * bliss::AbstractGraph, too.
 */
class Partition
{
public:
  /**
   * \brief Data structure for holding information about a cell in a Partition.
   */
  class Cell
  {
    friend class Partition;
  public:
    unsigned int length;
    /* Index of the first element of the cell in
       the Partition::elements array */
    unsigned int first;
    unsigned int max_ival;
    unsigned int max_ival_count;
  private:
    bool in_splitting_queue;
  public:
    bool in_neighbour_heap;
    /* Pointer to the next cell, null if this is the last one. */
    Cell* next;
    Cell* prev;
    Cell* next_nonsingleton;
    Cell* prev_nonsingleton;
    unsigned int split_level;
    /** Is this a unit cell? */
    bool is_unit() const {return(length == 1); }
    /** Is this cell in splitting queue? */
    bool is_in_splitting_queue() const {return(in_splitting_queue); }
  };


private:

  /** \internal
   * Data structure for remembering information about splits in order to
   * perform efficient backtracking over the splits.
   */
  class RefInfo {
  public:
    unsigned int split_cell_first;
    int prev_nonsingleton_first;
    int next_nonsingleton_first;
  };
  /** \internal
   * A stack for remembering the splits, used for backtracking.
   */
  KStack refinement_stack;

  class BacktrackInfo {
  public:
    unsigned int refinement_stack_size;
    unsigned int cr_backtrack_point;
  };

  /** \internal
   * The main stack for enabling backtracking.
   */
  std::vector bt_stack;

public:
  AbstractGraph* graph;

  /* Used during equitable partition refinement */
  KQueue splitting_queue;
  void  splitting_queue_add(Cell* const cell);
  Cell* splitting_queue_pop();
  bool  splitting_queue_is_empty() const;
  void  splitting_queue_clear();


  /** Type for backtracking points. */
  typedef unsigned int BacktrackPoint;

  /**
   * Get a new backtrack point for the current partition
   */
  BacktrackPoint set_backtrack_point();

  /**
   * Backtrack to the point \a p and remove it.
   */
  void goto_backtrack_point(BacktrackPoint p);

  /**
   * Split the non-unit Cell \a cell = {\a element,e1,e2,...,en} containing
   * the element \a element in two:
   * \a cell = {e1,...,en} and \a newcell = {\a element}.
   * @param cell     a non-unit Cell
   * @param element  an element in \a cell
   * @return         the new unit Cell \a newcell
   */
  Cell* individualize(Cell* const cell,
                      const unsigned int element);

  Cell* aux_split_in_two(Cell* const cell,
                         const unsigned int first_half_size);


private:
  unsigned int N;
  Cell* cells;
  Cell* free_cells;
  unsigned int discrete_cell_count;
public:
  Cell* first_cell;
  Cell* first_nonsingleton_cell;
  unsigned int *elements;
  /* invariant_values[e] gives the invariant value of the element e */
  unsigned int *invariant_values;
  /* element_to_cell_map[e] gives the cell of the element e */
  Cell **element_to_cell_map;
  /** Get the cell of the element \a e */
  Cell* get_cell(const unsigned int e) const {
    assert(e < N);
    return element_to_cell_map[e];
  }
  /* in_pos[e] points to the elements array s.t. *in_pos[e] = e  */
  unsigned int **in_pos;

  Partition();
  ~Partition();

  /**
   * Initialize the partition to the unit partition (all elements in one cell)
   * over the \a N > 0 elements {0,...,\a N-1}.
   */
  void init(const unsigned int N);

  /**
   * Returns true iff the partition is discrete, meaning that all
   * the elements are in their own cells.
   */
  bool is_discrete() const {return(free_cells == 0); }

  unsigned int nof_discrete_cells() const {return(discrete_cell_count); }

  /*
   * Splits the Cell \a cell into [cell_1,...,cell_n]
   * according to the invariant_values of the elements in \a cell.
   * After splitting, cell_1 == \a cell.
   * Returns the pointer to the Cell cell_n;
   * cell_n != cell iff the Cell \a cell was actually splitted.
   * The flag \a max_ival_info_ok indicates whether the max_ival and
   * max_ival_count fields of the Cell \a cell have consistent values
   * when the method is called.
   * Clears the invariant values of elements in the Cell \a cell as well as
   * the max_ival and max_ival_count fields of the Cell \a cell.
   */
  Cell *zplit_cell(Cell * const cell, const bool max_ival_info_ok);

  /*
   * Routines for component recursion
   */
  void cr_init();
  void cr_free();
  unsigned int cr_get_level(const unsigned int cell_index) const;
  unsigned int cr_split_level(const unsigned int level,
                              const std::vector& cells);

  /** Clear the invariant_values of the elements in the Cell \a cell. */
  void clear_ivs(Cell* const cell);

private:
  /*
   * Component recursion data structures
   */

  /* Is component recursion support in use? */
  bool cr_enabled;

  class CRCell {
  public:
    unsigned int level;
    CRCell* next;
    CRCell** prev_next_ptr;
    void detach() {
      if(next)
        next->prev_next_ptr = prev_next_ptr;
      *(prev_next_ptr) = next;
      level = UINT_MAX;
      next = 0;
      prev_next_ptr = 0;
    }
  };
  CRCell* cr_cells;
  CRCell** cr_levels;
  class CR_BTInfo {
  public:
    unsigned int created_trail_index;
    unsigned int splitted_level_trail_index;
  };
  std::vector cr_created_trail;
  std::vector cr_splitted_level_trail;
  std::vector cr_bt_info;
  unsigned int cr_max_level;
  void cr_create_at_level(const unsigned int cell_index, unsigned int level);
  void cr_create_at_level_trailed(const unsigned int cell_index, unsigned int level);
  unsigned int cr_get_backtrack_point();
  void cr_goto_backtrack_point(const unsigned int btpoint);


  /*
   *
   * Auxiliary routines for sorting and splitting cells
   *
   */
  Cell* sort_and_split_cell1(Cell* cell);
  Cell* sort_and_split_cell255(Cell* const cell, const unsigned int max_ival);
  bool shellsort_cell(Cell* cell);
  Cell* split_cell(Cell* const cell);

  /*
   * Some auxiliary stuff needed for distribution count sorting.
   * To make the code thread-safe (modulo the requirement that each graph is
   * only accessed in one thread at a time), the arrays are owned by
   * the partition instance, not statically defined.
   */
  unsigned int dcs_count[256];
  unsigned int dcs_start[256];
  void dcs_cumulate_count(const unsigned int max);
};


inline Partition::Cell*
Partition::splitting_queue_pop()
{
  assert(!splitting_queue.is_empty());
  Cell* const cell = splitting_queue.pop_front();
  assert(cell->in_splitting_queue);
  cell->in_splitting_queue = false;
  return cell;
}

inline bool
Partition::splitting_queue_is_empty() const
{
  return splitting_queue.is_empty();
}


inline unsigned int
Partition::cr_get_level(const unsigned int cell_index) const
{
  assert(cr_enabled);
  assert(cell_index < N);
  assert(cr_cells[cell_index].level != UINT_MAX);
  return(cr_cells[cell_index].level);
}

} // namespace bliss

#endif // BLISS_PARTITION_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/stats.hh0000644000175100001710000000601300000000000025605 0ustar00runnerdocker00000000000000#ifndef BLISS_STATS_HH
#define BLISS_STATS_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

#include "graph.hh"
#include "bignum.hh"

namespace bliss {

/**
 * \brief Statistics returned by the bliss search algorithm.
 */
class Stats
{
  friend class AbstractGraph;
  /** \internal The size of the automorphism group. */
  BigNum group_size;
  /** \internal An approximation (due to possible overflows) of
   * the size of the automorphism group. */
  long double group_size_approx;
  /** \internal The number of nodes in the search tree. */
  long unsigned int nof_nodes;
  /** \internal The number of leaf nodes in the search tree. */
  long unsigned int nof_leaf_nodes;
  /** \internal The number of bad nodes in the search tree. */
  long unsigned int nof_bad_nodes;
  /** \internal The number of canonical representative updates. */
  long unsigned int nof_canupdates;
  /** \internal The number of generator permutations. */
  long unsigned int nof_generators;
  /** \internal The maximal depth of the search tree. */
  unsigned long int max_level;
  /** \internal Reset the statistics. */
  void reset()
  {
    group_size.assign(1);
    group_size_approx = 1.0;
    nof_nodes = 0;
    nof_leaf_nodes = 0;
    nof_bad_nodes = 0;
    nof_canupdates = 0;
    nof_generators = 0;
    max_level = 0;
  }
public:
  Stats() { reset(); }

  /** The size of the automorphism group. */
  const BigNum& get_group_size() const {return group_size;}
  /** An approximation (due to possible overflows/rounding errors) of
   * the size of the automorphism group. */
  long double get_group_size_approx() const {return group_size_approx;}
  /** The number of nodes in the search tree. */
  long unsigned int get_nof_nodes() const {return nof_nodes;}
  /** The number of leaf nodes in the search tree. */
  long unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;}
  /** The number of bad nodes in the search tree. */
  long unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;}
  /** The number of canonical representative updates. */
  long unsigned int get_nof_canupdates() const {return nof_canupdates;}
  /** The number of generator permutations. */
  long unsigned int get_nof_generators() const {return nof_generators;}
  /** The maximal depth of the search tree. */
  unsigned long int get_max_level() const {return max_level;}
};

} // namespace bliss

#endif // BLISS_STATS_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/uintseqhash.cc0000644000175100001710000001052700000000000026776 0ustar00runnerdocker00000000000000#include "uintseqhash.hh"

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

/*
 * Random bits generated by
 * http://www.fourmilab.ch/hotbits/
 */
static unsigned int rtab[256] = {
  0xAEAA35B8, 0x65632E16, 0x155EDBA9, 0x01349B39,
  0x8EB8BD97, 0x8E4C5367, 0x8EA78B35, 0x2B1B4072,
  0xC1163893, 0x269A8642, 0xC79D7F6D, 0x6A32DEA0,
  0xD4D2DA56, 0xD96D4F47, 0x47B5F48A, 0x2587C6BF,
  0x642B71D8, 0x5DBBAF58, 0x5C178169, 0xA16D9279,
  0x75CDA063, 0x291BC48B, 0x01AC2F47, 0x5416DF7C,
  0x45307514, 0xB3E1317B, 0xE1C7A8DE, 0x3ACDAC96,
  0x11B96831, 0x32DE22DD, 0x6A1DA93B, 0x58B62381,
  0x283810E2, 0xBC30E6A6, 0x8EE51705, 0xB06E8DFB,
  0x729AB12A, 0xA9634922, 0x1A6E8525, 0x49DD4E19,
  0xE5DB3D44, 0x8C5B3A02, 0xEBDE2864, 0xA9146D9F,
  0x736D2CB4, 0xF5229F42, 0x712BA846, 0x20631593,
  0x89C02603, 0xD5A5BF6A, 0x823F4E18, 0x5BE5DEFF,
  0x1C4EBBFA, 0x5FAB8490, 0x6E559B0C, 0x1FE528D6,
  0xB3198066, 0x4A965EB5, 0xFE8BB3D5, 0x4D2F6234,
  0x5F125AA4, 0xBCC640FA, 0x4F8BC191, 0xA447E537,
  0xAC474D3C, 0x703BFA2C, 0x617DC0E7, 0xF26299D7,
  0xC90FD835, 0x33B71C7B, 0x6D83E138, 0xCBB1BB14,
  0x029CF5FF, 0x7CBD093D, 0x4C9825EF, 0x845C4D6D,
  0x124349A5, 0x53942D21, 0x800E60DA, 0x2BA6EB7F,
  0xCEBF30D3, 0xEB18D449, 0xE281F724, 0x58B1CB09,
  0xD469A13D, 0x9C7495C3, 0xE53A7810, 0xA866C08E,
  0x832A038B, 0xDDDCA484, 0xD5FE0DDE, 0x0756002B,
  0x2FF51342, 0x60FEC9C8, 0x061A53E3, 0x47B1884E,
  0xDC17E461, 0xA17A6A37, 0x3158E7E2, 0xA40D873B,
  0x45AE2140, 0xC8F36149, 0x63A4EE2D, 0xD7107447,
  0x6F90994F, 0x5006770F, 0xC1F3CA9A, 0x91B317B2,
  0xF61B4406, 0xA8C9EE8F, 0xC6939B75, 0xB28BBC3B,
  0x36BF4AEF, 0x3B12118D, 0x4D536ECF, 0x9CF4B46B,
  0xE8AB1E03, 0x8225A360, 0x7AE4A130, 0xC4EE8B50,
  0x50651797, 0x5BB4C59F, 0xD120EE47, 0x24F3A386,
  0xBE579B45, 0x3A378EFC, 0xC5AB007B, 0x3668942B,
  0x2DBDCC3A, 0x6F37F64C, 0xC24F862A, 0xB6F97FCF,
  0x9E4FA23D, 0x551AE769, 0x46A8A5A6, 0xDC1BCFDD,
  0x8F684CF9, 0x501D811B, 0x84279F80, 0x2614E0AC,
  0x86445276, 0xAEA0CE71, 0x0812250F, 0xB586D18A,
  0xC68D721B, 0x44514E1D, 0x37CDB99A, 0x24731F89,
  0xFA72E589, 0x81E6EBA2, 0x15452965, 0x55523D9D,
  0x2DC47E14, 0x2E7FA107, 0xA7790F23, 0x40EBFDBB,
  0x77E7906B, 0x6C1DB960, 0x1A8B9898, 0x65FA0D90,
  0xED28B4D8, 0x34C3ED75, 0x768FD2EC, 0xFAB60BCB,
  0x962C75F4, 0x304F0498, 0x0A41A36B, 0xF7DE2A4A,
  0xF4770FE2, 0x73C93BBB, 0xD21C82C5, 0x6C387447,
  0x8CDB4CB9, 0x2CC243E8, 0x41859E3D, 0xB667B9CB,
  0x89681E8A, 0x61A0526C, 0x883EDDDC, 0x539DE9A4,
  0xC29E1DEC, 0x97C71EC5, 0x4A560A66, 0xBD7ECACF,
  0x576AE998, 0x31CE5616, 0x97172A6C, 0x83D047C4,
  0x274EA9A8, 0xEB31A9DA, 0x327209B5, 0x14D1F2CB,
  0x00FE1D96, 0x817DBE08, 0xD3E55AED, 0xF2D30AFC,
  0xFB072660, 0x866687D6, 0x92552EB9, 0xEA8219CD,
  0xF7927269, 0xF1948483, 0x694C1DF5, 0xB7D8B7BF,
  0xFFBC5D2F, 0x2E88B849, 0x883FD32B, 0xA0331192,
  0x8CB244DF, 0x41FAF895, 0x16902220, 0x97FB512A,
  0x2BEA3CC4, 0xAF9CAE61, 0x41ACD0D5, 0xFD2F28FF,
  0xE780ADFA, 0xB3A3A76E, 0x7112AD87, 0x7C3D6058,
  0x69E64FFF, 0xE5F8617C, 0x8580727C, 0x41F54F04,
  0xD72BE498, 0x653D1795, 0x1275A327, 0x14B499D4,
  0x4E34D553, 0x4687AA39, 0x68B64292, 0x5C18ABC3,
  0x41EABFCC, 0x92A85616, 0x82684CF8, 0x5B9F8A4E,
  0x35382FFE, 0xFB936318, 0x52C08E15, 0x80918B2E,
  0x199EDEE0, 0xA9470163, 0xEC44ACDD, 0x612D6735,
  0x8F88EA7D, 0x759F5EA4, 0xE5CC7240, 0x68CFEB8B,
  0x04725601, 0x0C22C23E, 0x5BC97174, 0x89965841,
  0x5D939479, 0x690F338A, 0x3C2D4380, 0xDAE97F2B
};


void UintSeqHash::update(unsigned int i)
{
  i++;
  while(i > 0)
    {
      h ^= rtab[i & 0xff];
#if 1
      const unsigned int b = (h & 0x80000000) >> 31;
      i = i >> 8;
      h = (h << 1) | b;
#else
      const unsigned int b = h & 0x80000000;
      h = h << 1;
      if(b != 0)
        h++;
      i = i >> 8;
#endif
    }
}


} // namespace bliss
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/uintseqhash.hh0000644000175100001710000000371500000000000027011 0ustar00runnerdocker00000000000000#ifndef BLISS_UINTSEQHASH_HH
#define BLISS_UINTSEQHASH_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

/**
 * \brief A updatable hash for sequences of unsigned ints.
 */
class UintSeqHash
{
protected:
  unsigned int h;
public:
  UintSeqHash() {h = 0; }
  UintSeqHash(const UintSeqHash &other) {h = other.h; }
  UintSeqHash& operator=(const UintSeqHash &other) {h = other.h; return *this; }

  /** Reset the hash value. */
  void reset() {h = 0; }

  /** Add the unsigned int \a n to the sequence. */
  void update(unsigned int n);

  /** Get the hash value of the sequence seen so far. */
  unsigned int get_value() const {return h; }

  /** Compare the hash values of this and \a other.
   * Return -1/0/1 if the value of this is smaller/equal/greater than
   * that of \a other. */
  int cmp(const UintSeqHash &other) const {
    return (h < other.h)?-1:((h == other.h)?0:1);
  }
  /** An abbreviation for cmp(other) < 0 */
  bool is_lt(const UintSeqHash &other) const {return cmp(other) < 0; }
  /** An abbreviation for cmp(other) <= 0 */
  bool is_le(const UintSeqHash &other) const {return cmp(other) <= 0; }
  /** An abbreviation for cmp(other) == 0 */
  bool is_equal(const UintSeqHash &other) const {return cmp(other) == 0; }
};


} // namespace bliss

#endif // BLISS_UINTSEQHASH_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/utils.cc0000644000175100001710000000273500000000000025604 0ustar00runnerdocker00000000000000#include 
#include "utils.hh"

/* Allow using 'and' instead of '&&' with MSVC */
#if _MSC_VER
#include 
#endif

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

namespace bliss {

bool
is_permutation(const unsigned int N, const unsigned int* perm)
{
  if(N == 0)
    return true;
  std::vector m(N, false);
  for(unsigned int i = 0; i < N; i++) {
    if(perm[i] >= N) return false;
    if(m[perm[i]]) return false;
    m[perm[i]] = true;
  }
  return true;
}

bool
is_permutation(const std::vector& perm)
{
  const unsigned int N = perm.size();
  if(N == 0)
    return true;
  std::vector m(N, false);
  for(unsigned int i = 0; i < N; i++) {
    if(perm[i] >= N) return false;
    if(m[perm[i]]) return false;
    m[perm[i]] = true;
  }
  return true;
}


} // namespace bliss
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss/utils.hh0000644000175100001710000000242100000000000025606 0ustar00runnerdocker00000000000000#ifndef BLISS_UTILS_HH
#define BLISS_UTILS_HH

/*
  Copyright (c) 2003-2021 Tommi Junttila
  Released under the GNU Lesser General Public License version 3.

  This file is part of bliss.

  bliss is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, version 3 of the License.

  bliss is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with bliss.  If not, see .
*/

/**
 * \file
 * \brief Some small utilities.
 */

#include 

namespace bliss {

/**
 * Check whether \a perm is a valid permutation on {0,...,N-1}.
 * Slow, mainly for debugging and validation purposes.
 */
bool is_permutation(const unsigned int N, const unsigned int* perm);

/**
 * Check whether \a perm is a valid permutation on {0,...,N-1}.
 * Slow, mainly for debugging and validation purposes.
 */
bool is_permutation(const std::vector& perm);

} // namespace bliss

#endif // BLISS_UTILS_HH
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/bliss.cc0000644000175100001710000005265200000000000024447 0ustar00runnerdocker00000000000000/*
 Copyright (C) 2003-2006 Tommi Junttila

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License version 2
 as published by the Free Software Foundation.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/

/* FSF address fixed in the above notice on 1 Oct 2009 by Tamas Nepusz */

#include "bliss/graph.hh"

#include "igraph_topology.h"
#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_interrupt.h"
#include "igraph_memory.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

#include "core/exceptions.h"

using namespace bliss;
using namespace std;

/**
 * \section about_bliss
 *
 * 
 * Bliss is a successor of the famous NAUTY algorithm and
 * implementation. While using the same ideas in general, with better
 * heuristics and data structures Bliss outperforms NAUTY on most
 * graphs.
 * 
 *
 * 
 * Bliss was developed and implemented by Tommi Junttila and Petteri Kaski at
 * Helsinki University of Technology, Finland. For more information,
 * see the Bliss homepage at https://users.aalto.fi/~tjunttil/bliss/ and the following
 * publication:
 * 
 *
 * 
 * Tommi Junttila and Petteri Kaski: "Engineering an Efficient Canonical Labeling
 * Tool for Large and Sparse Graphs" In ALENEX 2007, pages 135–149, 2007
 * https://doi.org/10.1137/1.9781611972870.13
 * 
 *
 * 
 * Tommi Junttila and Petteri Kaski: "Conflict Propagation and Component Recursion
 * for Canonical Labeling" in TAPAS 2011, pages 151–162, 2011.
 * https://doi.org/10.1007/978-3-642-19754-3_16
 * 
 *
 * 
 * Bliss works with both directed graphs and undirected graphs. It supports graphs with
 * self-loops, but not graphs with multi-edges.
 * 
 *
 * 
 * Bliss version 0.75 is included in igraph.
 * 
 */

namespace { // unnamed namespace

inline AbstractGraph *bliss_from_igraph(const igraph_t *graph) {
    unsigned int nof_vertices = (unsigned int)igraph_vcount(graph);
    unsigned int nof_edges = (unsigned int)igraph_ecount(graph);

    AbstractGraph *g;

    if (igraph_is_directed(graph)) {
        g = new Digraph(nof_vertices);
    } else {
        g = new Graph(nof_vertices);
    }

    /* g->set_verbose_level(0); */

    for (unsigned int i = 0; i < nof_edges; i++) {
        g->add_edge((unsigned int)IGRAPH_FROM(graph, i), (unsigned int)IGRAPH_TO(graph, i));
    }

    return g;
}


void bliss_free_graph(AbstractGraph *g) {
    delete g;
}


inline int bliss_set_sh(AbstractGraph *g, igraph_bliss_sh_t sh, bool directed) {
    if (directed) {
        Digraph::SplittingHeuristic gsh = Digraph::shs_fsm;
        switch (sh) {
        case IGRAPH_BLISS_F:    gsh = Digraph::shs_f;   break;
        case IGRAPH_BLISS_FL:   gsh = Digraph::shs_fl;  break;
        case IGRAPH_BLISS_FS:   gsh = Digraph::shs_fs;  break;
        case IGRAPH_BLISS_FM:   gsh = Digraph::shs_fm;  break;
        case IGRAPH_BLISS_FLM:  gsh = Digraph::shs_flm; break;
        case IGRAPH_BLISS_FSM:  gsh = Digraph::shs_fsm; break;
        default: IGRAPH_ERROR("Invalid splitting heuristic.", IGRAPH_EINVAL);
        }
        static_cast(g)->set_splitting_heuristic(gsh);
    } else {
        Graph::SplittingHeuristic gsh = Graph::shs_fsm;
        switch (sh) {
        case IGRAPH_BLISS_F:    gsh = Graph::shs_f;   break;
        case IGRAPH_BLISS_FL:   gsh = Graph::shs_fl;  break;
        case IGRAPH_BLISS_FS:   gsh = Graph::shs_fs;  break;
        case IGRAPH_BLISS_FM:   gsh = Graph::shs_fm;  break;
        case IGRAPH_BLISS_FLM:  gsh = Graph::shs_flm; break;
        case IGRAPH_BLISS_FSM:  gsh = Graph::shs_fsm; break;
        default: IGRAPH_ERROR("Invalid splitting heuristic.", IGRAPH_EINVAL);
        }
        static_cast(g)->set_splitting_heuristic(gsh);
    }
    return IGRAPH_SUCCESS;
}


inline int bliss_set_colors(AbstractGraph *g, const igraph_vector_int_t *colors) {
    if (colors == NULL) {
        return IGRAPH_SUCCESS;
    }
    const int n = g->get_nof_vertices();
    if (n != igraph_vector_int_size(colors)) {
        IGRAPH_ERROR("Invalid vertex color vector length.", IGRAPH_EINVAL);
    }
    for (int i = 0; i < n; ++i) {
        g->change_color(i, VECTOR(*colors)[i]);
    }
    return IGRAPH_SUCCESS;
}


inline int bliss_info_to_igraph(igraph_bliss_info_t *info, const Stats &stats) {
    if (info) {
        size_t group_size_strlen;

        info->max_level      = stats.get_max_level();
        info->nof_nodes      = stats.get_nof_nodes();
        info->nof_leaf_nodes = stats.get_nof_leaf_nodes();
        info->nof_bad_nodes  = stats.get_nof_bad_nodes();
        info->nof_canupdates = stats.get_nof_canupdates();
        info->nof_generators = stats.get_nof_generators();

        mpz_t group_size;
        mpz_init(group_size);
        stats.get_group_size().get(group_size);
        group_size_strlen = mpz_sizeinbase(group_size, /* base */ 10) + 2;
        info->group_size = IGRAPH_CALLOC(group_size_strlen, char);
        if (! info->group_size) {
            IGRAPH_ERROR("Insufficient memory to retrieve automotphism group size.", IGRAPH_ENOMEM);
        }
        mpz_get_str(info->group_size, /* base */ 10, group_size);
        mpz_clear(group_size);
    }

    return IGRAPH_SUCCESS;
}


// This is the callback function that can tell Bliss to terminate early.
struct AbortChecker {
    bool aborted;

    AbortChecker() : aborted(false) { }
    bool operator()() {
        if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) {
            aborted = true;
            return true;
        }
        return false;
    }
};


// This is the callback function used with AbstractGraph::find_automorphisms().
// It collects the automorphism group generators into a pointer vector.
class AutCollector {
    igraph_vector_ptr_t *generators;

public:
    AutCollector(igraph_vector_ptr_t *generators_) : generators(generators_) { }

    void operator ()(unsigned int n, const unsigned int *aut) {
        int err;
        igraph_vector_t *newvector = IGRAPH_CALLOC(1, igraph_vector_t);
        if (! newvector) {
            throw bad_alloc();
        }
        err = igraph_vector_init(newvector, n);
        if (err) {
            throw bad_alloc();
        }
        copy(aut, aut + n, newvector->stor_begin); // takes care of unsigned int -> double conversion
        err = igraph_vector_ptr_push_back(generators, newvector);
        if (err) {
            throw bad_alloc();
        }
    }
};

} // end unnamed namespace


/**
 * \function igraph_canonical_permutation
 * \brief Canonical permutation using Bliss.
 *
 * This function computes the vertex permutation which transforms
 * the graph into a canonical form, using the Bliss algorithm.
 * Two graphs have the same canonical form if and only if they
 * are isomorphic. Use \ref igraph_is_same_graph() to compare
 * two canonical forms.
 *
 * \param graph The input graph. Multiple edges between the same nodes
 *   are not supported and will cause an incorrect result to be returned.
 * \param colors An optional vertex color vector for the graph. Supply a
 *   null pointer is the graph is not colored.
 * \param labeling Pointer to a vector, the result is stored here. The
 *    permutation takes vertex 0 to the first element of the vector,
 *    vertex 1 to the second, etc. The vector will be resized as
 *    needed.
 * \param sh The splitting heuristics to be used in Bliss. See \ref
 *    igraph_bliss_sh_t.
 * \param info If not \c NULL then information on Bliss internals is
 *    stored here. The memory used by this structure must to be freed
 *    when no longer needed, see \ref igraph_bliss_info_t.
 * \return Error code.
 *
 * \sa igraph_is_same_graph()
 *
 * Time complexity: exponential, in practice it is fast for many graphs.
 */
int igraph_canonical_permutation(const igraph_t *graph, const igraph_vector_int_t *colors,
                                 igraph_vector_t *labeling, igraph_bliss_sh_t sh, igraph_bliss_info_t *info) {
    IGRAPH_HANDLE_EXCEPTIONS(
        AbstractGraph *g = bliss_from_igraph(graph);
        IGRAPH_FINALLY(bliss_free_graph, g);
        const unsigned int N = g->get_nof_vertices();

        IGRAPH_CHECK(bliss_set_sh(g, sh, igraph_is_directed(graph)));
        IGRAPH_CHECK(bliss_set_colors(g, colors));

        Stats stats;
        AbortChecker checker;
        const unsigned int *cl = g->canonical_form(stats, /* report */ nullptr, /* terminate */ checker);
        if (checker.aborted) {
            return IGRAPH_INTERRUPTED;
        }

        IGRAPH_CHECK(igraph_vector_resize(labeling, N));
        for (unsigned int i = 0; i < N; i++) {
            VECTOR(*labeling)[i] = cl[i];
        }

        IGRAPH_CHECK(bliss_info_to_igraph(info, stats));

        delete g;
        IGRAPH_FINALLY_CLEAN(1);
    );

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_automorphisms
 * \brief Number of automorphisms using Bliss.
 *
 * The number of automorphisms of a graph is computed using Bliss. The
 * result is returned as part of the \p info structure, in tag \c
 * group_size. It is returned as a string, as it can be very high even
 * for relatively small graphs. If the GNU MP library is used then
 * this number is exact, otherwise a long double is used
 * and it is only approximate. See also \ref igraph_bliss_info_t.
 *
 * \param graph The input graph. Multiple edges between the same nodes
 *   are not supported and will cause an incorrect result to be returned.
 * \param colors An optional vertex color vector for the graph. Supply a
 *   null pointer is the graph is not colored.
 * \param sh The splitting heuristics to be used in Bliss. See \ref
 *    igraph_bliss_sh_t.
 * \param info The result is stored here, in particular in the \c
 *    group_size tag of \p info. The memory used by this structure must be
 *    released when no longer needed, see \ref igraph_bliss_info_t.
 * \return Error code.
 *
 * Time complexity: exponential, in practice it is fast for many graphs.
 */
int igraph_automorphisms(const igraph_t *graph, const igraph_vector_int_t *colors,
                         igraph_bliss_sh_t sh, igraph_bliss_info_t *info) {
    IGRAPH_HANDLE_EXCEPTIONS(
        AbstractGraph *g = bliss_from_igraph(graph);
        IGRAPH_FINALLY(bliss_free_graph, g);

        IGRAPH_CHECK(bliss_set_sh(g, sh, igraph_is_directed(graph)));
        IGRAPH_CHECK(bliss_set_colors(g, colors));

        Stats stats;
        AbortChecker checker;
        g->find_automorphisms(stats, /* report */ nullptr, /* terminate */ checker);
        if (checker.aborted) {
            return IGRAPH_INTERRUPTED;
        }

        IGRAPH_CHECK(bliss_info_to_igraph(info, stats));

        delete g;
        IGRAPH_FINALLY_CLEAN(1);
    );

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_automorphism_group
 * \brief Automorphism group generators using Bliss.
 *
 * The generators of the automorphism group of a graph are computed
 * using Bliss. The generator set may not be minimal and may depend on
 * the splitting heuristics. The generators are permutations represented
 * using zero-based indexing.
 *
 * \param graph The input graph. Multiple edges between the same nodes
 *   are not supported and will cause an incorrect result to be returned.
 * \param colors An optional vertex color vector for the graph. Supply a
 *   null pointer is the graph is not colored.
 * \param generators Must be an initialized pointer vector. It will
 *    contain pointers to \ref igraph_vector_t objects
 *    representing generators of the automorphism group.
 * \param sh The splitting heuristics to be used in Bliss. See \ref
 *    igraph_bliss_sh_t.
 * \param info If not \c NULL then information on Bliss internals is
 *    stored here. The memory used by this structure must to be freed
 *    when no longer needed, see \ref igraph_bliss_info_t.
 * \return Error code.
 *
 * Time complexity: exponential, in practice it is fast for many graphs.
 */
int igraph_automorphism_group(
    const igraph_t *graph, const igraph_vector_int_t *colors, igraph_vector_ptr_t *generators,
    igraph_bliss_sh_t sh, igraph_bliss_info_t *info) {
    IGRAPH_HANDLE_EXCEPTIONS(
        AbstractGraph *g = bliss_from_igraph(graph);
        IGRAPH_FINALLY(bliss_free_graph, g);

        IGRAPH_CHECK(bliss_set_sh(g, sh, igraph_is_directed(graph)));
        IGRAPH_CHECK(bliss_set_colors(g, colors));

        Stats stats;
        igraph_vector_ptr_resize(generators, 0);
        AutCollector collector(generators);
        AbortChecker checker;
        g->find_automorphisms(stats, collector, checker);
        if (checker.aborted) {
            return IGRAPH_INTERRUPTED;
        }
        IGRAPH_CHECK(bliss_info_to_igraph(info, stats));

        delete g;
        IGRAPH_FINALLY_CLEAN(1);
    );

    return IGRAPH_SUCCESS;
}


/* The following license notice applies to the rest of this file */

/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

/**
 * \function igraph_isomorphic_bliss
 * \brief Graph isomorphism via Bliss.
 *
 * This function uses the Bliss graph isomorphism algorithm, a
 * successor of the famous NAUTY algorithm and implementation. Bliss
 * is open source and licensed according to the GNU LGPL. See
 * https://users.aalto.fi/~tjunttil/bliss/ for
 * details. Currently the 0.75 version of Bliss is included in igraph.
 *
 * 
 * Isomorphism testing is implemented by producing the canonical form
 * of both graphs using \ref igraph_canonical_permutation() and
 * comparing them.
 *
 * \param graph1 The first input graph. Multiple edges between the same nodes
 *   are not supported and will cause an incorrect result to be returned.
 * \param graph2 The second input graph. Multiple edges between the same nodes
 *   are not supported and will cause an incorrect result to be returned.
 * \param colors1 An optional vertex color vector for the first graph. Supply a
 *   null pointer if your graph is not colored.
 * \param colors2 An optional vertex color vector for the second graph. Supply a
 *   null pointer if your graph is not colored.
 * \param iso Pointer to a boolean, the result is stored here.
 * \param map12 A vector or \c NULL pointer. If not \c NULL then an
 *   isomorphic mapping from \p graph1 to \p graph2 is stored here.
 *   If the input graphs are not isomorphic then this vector is
 *   cleared, i.e. it will have length zero.
 * \param map21 Similar to \p map12, but for the mapping from \p
 *   graph2 to \p graph1.
 * \param sh Splitting heuristics to be used for the graphs. See
 *   \ref igraph_bliss_sh_t.
 * \param info1 If not \c NULL, information about the canonization of
 *    the first input graph is stored here. Note that if the two graphs
 *    have different number of vertices or edges, then this is only
 *    partially filled. The memory used by this structure should be
 *    released when no longer needed, see \ref igraph_bliss_info_t
 *    for details.
 * \param info2 Same as \p info1, but for the second graph.
 * \return Error code.
 *
 * Time complexity: exponential, but in practice it is quite fast.
 */
int igraph_isomorphic_bliss(const igraph_t *graph1, const igraph_t *graph2,
                            const igraph_vector_int_t *colors1, const igraph_vector_int_t *colors2,
                            igraph_bool_t *iso, igraph_vector_t *map12,
                            igraph_vector_t *map21, igraph_bliss_sh_t sh,
                            igraph_bliss_info_t *info1, igraph_bliss_info_t *info2) {

    long int no_of_nodes = igraph_vcount(graph1);
    long int no_of_edges = igraph_ecount(graph1);
    igraph_vector_t perm1, perm2;
    igraph_vector_t vmap12, *mymap12 = &vmap12;
    igraph_vector_t from, to, index;
    igraph_vector_t from2, to2, index2;
    igraph_bool_t directed;
    long int i, j;

    *iso = 0;
    if (info1) {
        info1->nof_nodes = info1->nof_leaf_nodes = info1->nof_bad_nodes =
                               info1->nof_canupdates = info1->max_level = info1->nof_generators = 0;
        info1->group_size = 0;
    }
    if (info2) {
        info2->nof_nodes = info2->nof_leaf_nodes = info2->nof_bad_nodes =
                               info2->nof_canupdates = info2->max_level = info2->nof_generators = 0;
        info2->group_size = 0;
    }

    directed = igraph_is_directed(graph1);
    if (igraph_is_directed(graph2) != directed) {
        IGRAPH_ERROR("Cannot compare directed and undirected graphs.",
                     IGRAPH_EINVAL);
    }
    if ((colors1 == NULL || colors2 == NULL) && colors1 != colors2) {
        IGRAPH_WARNING("Only one of the graphs is vertex colored, colors will be ignored.");
        colors1 = NULL; colors2 = NULL;
    }

    if (no_of_nodes != igraph_vcount(graph2) ||
        no_of_edges != igraph_ecount(graph2)) {
        if (map12) {
            igraph_vector_clear(map12);
        }
        if (map21) {
            igraph_vector_clear(map21);
        }
        return 0;
    }

    if (map12) {
        mymap12 = map12;
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(mymap12, 0);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&perm1, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&perm2, no_of_nodes);

    IGRAPH_CHECK(igraph_canonical_permutation(graph1, colors1, &perm1, sh, info1));
    IGRAPH_CHECK(igraph_canonical_permutation(graph2, colors2, &perm2, sh, info2));

    IGRAPH_CHECK(igraph_vector_resize(mymap12, no_of_nodes));

    /* The inverse of perm2 is produced in mymap12 */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(*mymap12)[ (long int)VECTOR(perm2)[i] ] = i;
    }
    /* Now we produce perm2^{-1} o perm1 in perm2 */
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(perm2)[i] = VECTOR(*mymap12)[ (long int) VECTOR(perm1)[i] ];
    }
    /* Copy it to mymap12 */
    igraph_vector_update(mymap12, &perm2);

    igraph_vector_destroy(&perm1);
    igraph_vector_destroy(&perm2);
    IGRAPH_FINALLY_CLEAN(2);

    /* Check isomorphism, we apply the permutation in mymap12 to graph1
       and should get graph2 */

    IGRAPH_VECTOR_INIT_FINALLY(&from, no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&to, no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&index, no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&from2, no_of_edges * 2);
    IGRAPH_VECTOR_INIT_FINALLY(&to2, no_of_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&index2, no_of_edges);

    for (i = 0; i < no_of_edges; i++) {
        VECTOR(from)[i] = VECTOR(*mymap12)[ (long int) IGRAPH_FROM(graph1, i) ];
        VECTOR(to)[i]   = VECTOR(*mymap12)[ (long int) IGRAPH_TO  (graph1, i) ];
        if (! directed && VECTOR(from)[i] < VECTOR(to)[i]) {
            igraph_real_t tmp = VECTOR(from)[i];
            VECTOR(from)[i] = VECTOR(to)[i];
            VECTOR(to)[i] = tmp;
        }
    }
    igraph_vector_order(&from, &to, &index, no_of_nodes);

    igraph_get_edgelist(graph2, &from2, /*bycol=*/ 1);
    for (i = 0, j = no_of_edges; i < no_of_edges; i++, j++) {
        VECTOR(to2)[i] = VECTOR(from2)[j];
        if (! directed && VECTOR(from2)[i] < VECTOR(to2)[i]) {
            igraph_real_t tmp = VECTOR(from2)[i];
            VECTOR(from2)[i] = VECTOR(to2)[i];
            VECTOR(to2)[i] = tmp;
        }
    }
    igraph_vector_resize(&from2, no_of_edges);
    igraph_vector_order(&from2, &to2, &index2, no_of_nodes);

    *iso = 1;
    for (i = 0; i < no_of_edges; i++) {
        long int i1 = (long int) VECTOR(index)[i];
        long int i2 = (long int) VECTOR(index2)[i];
        if (VECTOR(from)[i1] != VECTOR(from2)[i2] ||
            VECTOR(to)[i1] != VECTOR(to2)[i2]) {
            *iso = 0;
            break;
        }
    }

    /* If the graphs are coloured, we also need to check that applying the
       permutation mymap12 to colors1 gives colors2. */

    if (*iso && colors1 != NULL) {
        for (i = 0; i < no_of_nodes; i++) {
            if (VECTOR(*colors1)[i] != VECTOR(*colors2)[(long int) VECTOR(*mymap12)[i] ]) {
                *iso = 0;
                break;
            }
        }
    }

    igraph_vector_destroy(&index2);
    igraph_vector_destroy(&to2);
    igraph_vector_destroy(&from2);
    igraph_vector_destroy(&index);
    igraph_vector_destroy(&to);
    igraph_vector_destroy(&from);
    IGRAPH_FINALLY_CLEAN(6);

    if (*iso) {
        /* The inverse of mymap12 */
        if (map21) {
            IGRAPH_CHECK(igraph_vector_resize(map21, no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                VECTOR(*map21)[ (long int) VECTOR(*mymap12)[i] ] = i;
            }
        }
    } else {
        if (map12) {
            igraph_vector_clear(map12);
        }
        if (map21) {
            igraph_vector_clear(map21);
        }
    }

    if (!map12) {
        igraph_vector_destroy(mymap12);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/isoclasses.c0000644000175100001710000057162400000000000025345 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include "igraph_topology.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "isomorphism/isoclasses.h"

/*
 * Small labelled graphs are encoded into a compact representation, a "code",
 * that fits into a single integer value. Each non-loop edge corresponds to
 * a specific bit of the integer. The edge-to-bit mappings are stored in
 * the "isoclass_idx" arrays while the bit-to-edge mappings are in the "classedges"
 * arrays.
 *
 * The "isoclass2" array is a mapping from the code of each possible labelled
 * graph to its isomorphism class. A canonical representative of each isomorphism
 * class is stored in "isographs".
 *
 * In the names of arrays, the number refers to the vertex count, while "u"
 * indicates undirected graphs (the other arrays store directed ones).
 *
 * Description of each array for graphs of size n:
 *
 * isosclass_idx represents an n-by-n matrix stored in column-major order.
 * Element i,j of the matrix is an integer with a single bit set. This bit,
 * if set, represents edge i-j in the graph code.
 *
 * isoclass2[code] gives the isomorphism class of the graph represented by code.
 * Classes are labelled by integers starting at 0, after ordering them by the
 * graph code of their smallest-code representative.
 *
 * isographs[class] is the code of a graph belonging to the given class. For each
 * class, the representative with the smallest code is chosen.
 *
 * classedges[2*i] - classedges[2*i+1] are the endpoints of the edge represented
 * by bit i in the code. Bits are numbered from most to least significant, thus
 * the most significant one has index i=0.
 */

const unsigned int igraph_i_isoclass_3_idx[] = { 0, 4, 16, 1, 0, 32, 2, 8, 0 };

const unsigned int igraph_i_isoclass_4_idx[] = {
    0, 8, 64, 512, 1, 0, 128, 1024, 2, 16, 0, 2048, 4, 32, 256, 0
};

const unsigned int igraph_i_isoclass_3u_idx[] = { 0, 1, 2, 1, 0, 4, 2, 4, 0 };

const unsigned int igraph_i_isoclass_4u_idx[] = {
    0, 1, 2, 8, 1, 0, 4, 16, 2, 4, 0, 32, 8, 16, 32, 0
};

const unsigned int igraph_i_isoclass_5u_idx[] = {
    0, 1, 2, 8, 64, 1, 0, 4, 16, 128, 2, 4, 0, 32, 256, 8, 16, 32, 0, 512, 64, 128, 256, 512, 0
};

const unsigned int igraph_i_isoclass_6u_idx[] = {
    0, 1, 2, 8, 64, 1024, 1, 0, 4, 16, 128, 2048, 2, 4, 0, 32, 256, 4096,
    8, 16, 32, 0, 512, 8192, 64, 128, 256, 512, 0, 16384, 1024, 2048,
    4096, 8192, 16384, 0
};

const unsigned int igraph_i_isoclass2_3[] = {
    0, 1, 1, 2, 1, 3, 4, 5, 1, 4, 6, 7, 2, 5, 7, 8, 1, 4, 3, 5, 6, 9, 9, 10, 4, 11,
    9, 12, 7, 12, 13, 14, 1, 6, 4, 7, 4, 9, 11, 12, 3, 9, 9, 13, 5, 10, 12, 14, 2, 7, 5, 8,
    7, 13, 12, 14, 5, 12, 10, 14, 8, 14, 14, 15
};

const unsigned int igraph_i_isoclass2_3u[] = {
    0, 1, 1, 2, 1, 2, 2, 3
};

const unsigned int igraph_i_isoclass2_4u[] = {
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 4, 5, 6, 6, 7, 1, 2, 5, 6, 2, 4, 6, 7, 2, 3,
    6, 7, 6, 7, 8, 9, 1, 5, 2, 6, 2, 6, 4, 7, 2, 6, 3, 7, 6, 8, 7, 9, 2, 6, 6, 8,
    3, 7, 7, 9, 4, 7, 7, 9, 7, 9, 9, 10
};

const unsigned int igraph_i_isoclass2_4[] = {
    0,  1,  1,  2,  1,  2,  2,  3,  1,  4,  5,  6,  5,  6,  7,  8,  1,  5,  9, 10,
    11, 12, 13, 14,  2,  6, 10, 15, 12, 16, 17, 18,  1,  5, 11, 12,  9, 10, 13, 14,
    2,  6, 12, 16, 10, 15, 17, 18,  2,  7, 13, 17, 13, 17, 19, 20,  3,  8, 14, 18,
    14, 18, 20, 21,  1,  5,  4,  6,  5,  7,  6,  8,  9, 22, 22, 23, 24, 25, 25, 26,
    5, 27, 22, 28, 29, 30, 31, 32, 10, 28, 33, 34, 35, 36, 37, 38, 11, 29, 39, 40,
    41, 42, 43, 44, 13, 31, 45, 46, 47, 48, 49, 50, 12, 30, 45, 51, 52, 53, 54, 55,
    14, 32, 56, 57, 58, 59, 60, 61,  1,  9,  5, 10, 11, 13, 12, 14,  5, 22, 27, 28,
    29, 31, 30, 32,  4, 22, 22, 33, 39, 45, 45, 56,  6, 23, 28, 34, 40, 46, 51, 57,
    5, 24, 29, 35, 41, 47, 52, 58,  7, 25, 30, 36, 42, 48, 53, 59,  6, 25, 31, 37,
    43, 49, 54, 60,  8, 26, 32, 38, 44, 50, 55, 61,  2, 10,  6, 15, 12, 17, 16, 18,
    10, 33, 28, 34, 35, 37, 36, 38,  6, 28, 23, 34, 40, 51, 46, 57, 15, 34, 34, 62,
    63, 64, 64, 65, 12, 35, 40, 63, 66, 67, 68, 69, 17, 37, 51, 64, 67, 70, 71, 72,
    16, 36, 46, 64, 68, 71, 73, 74, 18, 38, 57, 65, 69, 72, 74, 75,  1, 11,  5, 12,
    9, 13, 10, 14, 11, 39, 29, 40, 41, 43, 42, 44,  5, 29, 24, 35, 41, 52, 47, 58,
    12, 40, 35, 63, 66, 68, 67, 69,  9, 41, 41, 66, 76, 77, 77, 78, 13, 43, 52, 68,
    77, 79, 80, 81, 10, 42, 47, 67, 77, 80, 82, 83, 14, 44, 58, 69, 78, 81, 83, 84,
    2, 12,  6, 16, 10, 17, 15, 18, 13, 45, 31, 46, 47, 49, 48, 50,  7, 30, 25, 36,
    42, 53, 48, 59, 17, 51, 37, 64, 67, 71, 70, 72, 13, 52, 43, 68, 77, 80, 79, 81,
    19, 54, 54, 73, 82, 85, 85, 86, 17, 53, 49, 71, 80, 87, 85, 88, 20, 55, 60, 74,
    83, 88, 89, 90,  2, 13,  7, 17, 13, 19, 17, 20, 12, 45, 30, 51, 52, 54, 53, 55,
    6, 31, 25, 37, 43, 54, 49, 60, 16, 46, 36, 64, 68, 73, 71, 74, 10, 47, 42, 67,
    77, 82, 80, 83, 17, 49, 53, 71, 80, 85, 87, 88, 15, 48, 48, 70, 79, 85, 85, 89,
    18, 50, 59, 72, 81, 86, 88, 90,  3, 14,  8, 18, 14, 20, 18, 21, 14, 56, 32, 57,
    58, 60, 59, 61,  8, 32, 26, 38, 44, 55, 50, 61, 18, 57, 38, 65, 69, 74, 72, 75,
    14, 58, 44, 69, 78, 83, 81, 84, 20, 60, 55, 74, 83, 89, 88, 90, 18, 59, 50, 72,
    81, 88, 86, 90, 21, 61, 61, 75, 84, 90, 90, 91,  1,  5,  5,  7,  4,  6,  6,  8,
    9, 22, 24, 25, 22, 23, 25, 26, 11, 29, 41, 42, 39, 40, 43, 44, 13, 31, 47, 48,
    45, 46, 49, 50,  5, 27, 29, 30, 22, 28, 31, 32, 10, 28, 35, 36, 33, 34, 37, 38,
    12, 30, 52, 53, 45, 51, 54, 55, 14, 32, 58, 59, 56, 57, 60, 61,  9, 24, 22, 25,
    22, 25, 23, 26, 76, 92, 92, 93, 92, 93, 93, 94, 41, 95, 96, 97, 98, 99, 100, 101,
    77, 102, 103, 104, 105, 106, 107, 108, 41, 95, 98, 99, 96, 97, 100, 101, 77, 102, 105, 106,
    103, 104, 107, 108, 66, 109, 110, 111, 110, 111, 112, 113, 78, 114, 115, 116, 115, 116, 117, 118,
    11, 41, 29, 42, 39, 43, 40, 44, 41, 96, 95, 97, 98, 100, 99, 101, 39, 98, 98, 119,
    120, 121, 121, 122, 43, 100, 123, 124, 121, 125, 126, 127, 29, 95, 128, 129, 98, 123, 130, 131,
    42, 97, 129, 132, 119, 124, 133, 134, 40, 99, 130, 133, 121, 126, 135, 136, 44, 101, 131, 134,
    122, 127, 136, 137, 13, 47, 31, 48, 45, 49, 46, 50, 77, 103, 102, 104, 105, 107, 106, 108,
    43, 123, 100, 124, 121, 126, 125, 127, 79, 138, 138, 139, 140, 141, 141, 142, 52, 143, 130, 144,
    110, 145, 146, 147, 80, 148, 149, 150, 151, 152, 153, 154, 68, 155, 146, 156, 157, 158, 159, 160,
    81, 161, 162, 163, 164, 165, 166, 167,  5, 29, 27, 30, 22, 31, 28, 32, 41, 98, 95, 99,
    96, 100, 97, 101, 29, 128, 95, 129, 98, 130, 123, 131, 52, 130, 143, 144, 110, 146, 145, 147,
    24, 95, 95, 109, 92, 102, 102, 114, 47, 123, 143, 155, 103, 138, 148, 161, 35, 129, 143, 168,
    105, 149, 169, 170, 58, 131, 171, 172, 115, 162, 173, 174, 10, 35, 28, 36, 33, 37, 34, 38,
    77, 105, 102, 106, 103, 107, 104, 108, 42, 129, 97, 132, 119, 133, 124, 134, 80, 149, 148, 150,
    151, 153, 152, 154, 47, 143, 123, 155, 103, 148, 138, 161, 82, 169, 169, 175, 176, 177, 177, 178,
    67, 168, 145, 179, 151, 180, 181, 182, 83, 170, 173, 183, 184, 185, 186, 187, 12, 52, 30, 53,
    45, 54, 51, 55, 66, 110, 109, 111, 110, 112, 111, 113, 40, 130, 99, 133, 121, 135, 126, 136,
    68, 146, 155, 156, 157, 159, 158, 160, 35, 143, 129, 168, 105, 169, 149, 170, 67, 145, 168, 179,
    151, 181, 180, 182, 63, 144, 144, 188, 140, 189, 189, 190, 69, 147, 172, 191, 164, 192, 193, 194,
    14, 58, 32, 59, 56, 60, 57, 61, 78, 115, 114, 116, 115, 117, 116, 118, 44, 131, 101, 134,
    122, 136, 127, 137, 81, 162, 161, 163, 164, 166, 165, 167, 58, 171, 131, 172, 115, 173, 162, 174,
    83, 173, 170, 183, 184, 186, 185, 187, 69, 172, 147, 191, 164, 193, 192, 194, 84, 174, 174, 195,
    196, 197, 197, 198,  1,  9, 11, 13,  5, 10, 12, 14,  5, 22, 29, 31, 27, 28, 30, 32,
    5, 24, 41, 47, 29, 35, 52, 58,  7, 25, 42, 48, 30, 36, 53, 59,  4, 22, 39, 45,
    22, 33, 45, 56,  6, 23, 40, 46, 28, 34, 51, 57,  6, 25, 43, 49, 31, 37, 54, 60,
    8, 26, 44, 50, 32, 38, 55, 61, 11, 41, 39, 43, 29, 42, 40, 44, 41, 96, 98, 100,
    95, 97, 99, 101, 29, 95, 98, 123, 128, 129, 130, 131, 42, 97, 119, 124, 129, 132, 133, 134,
    39, 98, 120, 121, 98, 119, 121, 122, 43, 100, 121, 125, 123, 124, 126, 127, 40, 99, 121, 126,
    130, 133, 135, 136, 44, 101, 122, 127, 131, 134, 136, 137,  9, 76, 41, 77, 41, 77, 66, 78,
    24, 92, 95, 102, 95, 102, 109, 114, 22, 92, 96, 103, 98, 105, 110, 115, 25, 93, 97, 104,
    99, 106, 111, 116, 22, 92, 98, 105, 96, 103, 110, 115, 25, 93, 99, 106, 97, 104, 111, 116,
    23, 93, 100, 107, 100, 107, 112, 117, 26, 94, 101, 108, 101, 108, 113, 118, 13, 77, 43, 79,
    52, 80, 68, 81, 47, 103, 123, 138, 143, 148, 155, 161, 31, 102, 100, 138, 130, 149, 146, 162,
    48, 104, 124, 139, 144, 150, 156, 163, 45, 105, 121, 140, 110, 151, 157, 164, 49, 107, 126, 141,
    145, 152, 158, 165, 46, 106, 125, 141, 146, 153, 159, 166, 50, 108, 127, 142, 147, 154, 160, 167,
    5, 41, 29, 52, 24, 47, 35, 58, 29, 98, 128, 130, 95, 123, 129, 131, 27, 95, 95, 143,
    95, 143, 143, 171, 30, 99, 129, 144, 109, 155, 168, 172, 22, 96, 98, 110, 92, 103, 105, 115,
    31, 100, 130, 146, 102, 138, 149, 162, 28, 97, 123, 145, 102, 148, 169, 173, 32, 101, 131, 147,
    114, 161, 170, 174, 12, 66, 40, 68, 35, 67, 63, 69, 52, 110, 130, 146, 143, 145, 144, 147,
    30, 109, 99, 155, 129, 168, 144, 172, 53, 111, 133, 156, 168, 179, 188, 191, 45, 110, 121, 157,
    105, 151, 140, 164, 54, 112, 135, 159, 169, 181, 189, 192, 51, 111, 126, 158, 149, 180, 189, 193,
    55, 113, 136, 160, 170, 182, 190, 194, 10, 77, 42, 80, 47, 82, 67, 83, 35, 105, 129, 149,
    143, 169, 168, 170, 28, 102, 97, 148, 123, 169, 145, 173, 36, 106, 132, 150, 155, 175, 179, 183,
    33, 103, 119, 151, 103, 176, 151, 184, 37, 107, 133, 153, 148, 177, 180, 185, 34, 104, 124, 152,
    138, 177, 181, 186, 38, 108, 134, 154, 161, 178, 182, 187, 14, 78, 44, 81, 58, 83, 69, 84,
    58, 115, 131, 162, 171, 173, 172, 174, 32, 114, 101, 161, 131, 170, 147, 174, 59, 116, 134, 163,
    172, 183, 191, 195, 56, 115, 122, 164, 115, 184, 164, 196, 60, 117, 136, 166, 173, 186, 193, 197,
    57, 116, 127, 165, 162, 185, 192, 197, 61, 118, 137, 167, 174, 187, 194, 198,  2, 10, 12, 17,
    6, 15, 16, 18, 10, 33, 35, 37, 28, 34, 36, 38, 12, 35, 66, 67, 40, 63, 68, 69,
    17, 37, 67, 70, 51, 64, 71, 72,  6, 28, 40, 51, 23, 34, 46, 57, 15, 34, 63, 64,
    34, 62, 64, 65, 16, 36, 68, 71, 46, 64, 73, 74, 18, 38, 69, 72, 57, 65, 74, 75,
    13, 47, 45, 49, 31, 48, 46, 50, 77, 103, 105, 107, 102, 104, 106, 108, 52, 143, 110, 145,
    130, 144, 146, 147, 80, 148, 151, 152, 149, 150, 153, 154, 43, 123, 121, 126, 100, 124, 125, 127,
    79, 138, 140, 141, 138, 139, 141, 142, 68, 155, 157, 158, 146, 156, 159, 160, 81, 161, 164, 165,
    162, 163, 166, 167, 13, 77, 52, 80, 43, 79, 68, 81, 47, 103, 143, 148, 123, 138, 155, 161,
    45, 105, 110, 151, 121, 140, 157, 164, 49, 107, 145, 152, 126, 141, 158, 165, 31, 102, 130, 149,
    100, 138, 146, 162, 48, 104, 144, 150, 124, 139, 156, 163, 46, 106, 146, 153, 125, 141, 159, 166,
    50, 108, 147, 154, 127, 142, 160, 167, 19, 82, 54, 85, 54, 85, 73, 86, 82, 176, 169, 177,
    169, 177, 175, 178, 54, 169, 112, 181, 135, 189, 159, 192, 85, 177, 181, 199, 189, 200, 201, 202,
    54, 169, 135, 189, 112, 181, 159, 192, 85, 177, 189, 200, 181, 199, 201, 202, 73, 175, 159, 201,
    159, 201, 203, 204, 86, 178, 192, 202, 192, 202, 204, 205,  7, 42, 30, 53, 25, 48, 36, 59,
    42, 119, 129, 133, 97, 124, 132, 134, 30, 129, 109, 168, 99, 144, 155, 172, 53, 133, 168, 188,
    111, 156, 179, 191, 25, 97, 99, 111, 93, 104, 106, 116, 48, 124, 144, 156, 104, 139, 150, 163,
    36, 132, 155, 179, 106, 150, 175, 183, 59, 134, 172, 191, 116, 163, 183, 195, 17, 67, 51, 71,
    37, 70, 64, 72, 80, 151, 149, 153, 148, 152, 150, 154, 53, 168, 111, 179, 133, 188, 156, 191,
    87, 180, 180, 206, 180, 206, 206, 207, 49, 145, 126, 158, 107, 152, 141, 165, 85, 181, 189, 201,
    177, 199, 200, 202, 71, 179, 158, 208, 153, 206, 201, 209, 88, 182, 193, 209, 185, 210, 211, 212,
    17, 80, 53, 87, 49, 85, 71, 88, 67, 151, 168, 180, 145, 181, 179, 182, 51, 149, 111, 180,
    126, 189, 158, 193, 71, 153, 179, 206, 158, 201, 208, 209, 37, 148, 133, 180, 107, 177, 153, 185,
    70, 152, 188, 206, 152, 199, 206, 210, 64, 150, 156, 206, 141, 200, 201, 211, 72, 154, 191, 207,
    165, 202, 209, 212, 20, 83, 55, 88, 60, 89, 74, 90, 83, 184, 170, 185, 173, 186, 183, 187,
    55, 170, 113, 182, 136, 190, 160, 194, 88, 185, 182, 210, 193, 211, 209, 212, 60, 173, 136, 193,
    117, 186, 166, 197, 89, 186, 190, 211, 186, 213, 211, 214, 74, 183, 160, 209, 166, 211, 204, 215,
    90, 187, 194, 212, 197, 214, 215, 216,  1, 11,  9, 13,  5, 12, 10, 14, 11, 39, 41, 43,
    29, 40, 42, 44,  9, 41, 76, 77, 41, 66, 77, 78, 13, 43, 77, 79, 52, 68, 80, 81,
    5, 29, 41, 52, 24, 35, 47, 58, 12, 40, 66, 68, 35, 63, 67, 69, 10, 42, 77, 80,
    47, 67, 82, 83, 14, 44, 78, 81, 58, 69, 83, 84,  5, 29, 22, 31, 27, 30, 28, 32,
    41, 98, 96, 100, 95, 99, 97, 101, 24, 95, 92, 102, 95, 109, 102, 114, 47, 123, 103, 138,
    143, 155, 148, 161, 29, 128, 98, 130, 95, 129, 123, 131, 52, 130, 110, 146, 143, 144, 145, 147,
    35, 129, 105, 149, 143, 168, 169, 170, 58, 131, 115, 162, 171, 172, 173, 174,  5, 41, 24, 47,
    29, 52, 35, 58, 29, 98, 95, 123, 128, 130, 129, 131, 22, 96, 92, 103, 98, 110, 105, 115,
    31, 100, 102, 138, 130, 146, 149, 162, 27, 95, 95, 143, 95, 143, 143, 171, 30, 99, 109, 155,
    129, 144, 168, 172, 28, 97, 102, 148, 123, 145, 169, 173, 32, 101, 114, 161, 131, 147, 170, 174,
    7, 42, 25, 48, 30, 53, 36, 59, 42, 119, 97, 124, 129, 133, 132, 134, 25, 97, 93, 104,
    99, 111, 106, 116, 48, 124, 104, 139, 144, 156, 150, 163, 30, 129, 99, 144, 109, 168, 155, 172,
    53, 133, 111, 156, 168, 188, 179, 191, 36, 132, 106, 150, 155, 179, 175, 183, 59, 134, 116, 163,
    172, 191, 183, 195,  4, 39, 22, 45, 22, 45, 33, 56, 39, 120, 98, 121, 98, 121, 119, 122,
    22, 98, 92, 105, 96, 110, 103, 115, 45, 121, 105, 140, 110, 157, 151, 164, 22, 98, 96, 110,
    92, 105, 103, 115, 45, 121, 110, 157, 105, 140, 151, 164, 33, 119, 103, 151, 103, 151, 176, 184,
    56, 122, 115, 164, 115, 164, 184, 196,  6, 40, 23, 46, 28, 51, 34, 57, 43, 121, 100, 125,
    123, 126, 124, 127, 25, 99, 93, 106, 97, 111, 104, 116, 49, 126, 107, 141, 145, 158, 152, 165,
    31, 130, 100, 146, 102, 149, 138, 162, 54, 135, 112, 159, 169, 189, 181, 192, 37, 133, 107, 153,
    148, 180, 177, 185, 60, 136, 117, 166, 173, 193, 186, 197,  6, 43, 25, 49, 31, 54, 37, 60,
    40, 121, 99, 126, 130, 135, 133, 136, 23, 100, 93, 107, 100, 112, 107, 117, 46, 125, 106, 141,
    146, 159, 153, 166, 28, 123, 97, 145, 102, 169, 148, 173, 51, 126, 111, 158, 149, 189, 180, 193,
    34, 124, 104, 152, 138, 181, 177, 186, 57, 127, 116, 165, 162, 192, 185, 197,  8, 44, 26, 50,
    32, 55, 38, 61, 44, 122, 101, 127, 131, 136, 134, 137, 26, 101, 94, 108, 101, 113, 108, 118,
    50, 127, 108, 142, 147, 160, 154, 167, 32, 131, 101, 147, 114, 170, 161, 174, 55, 136, 113, 160,
    170, 190, 182, 194, 38, 134, 108, 154, 161, 182, 178, 187, 61, 137, 118, 167, 174, 194, 187, 198,
    2, 12, 10, 17,  6, 16, 15, 18, 13, 45, 47, 49, 31, 46, 48, 50, 13, 52, 77, 80,
    43, 68, 79, 81, 19, 54, 82, 85, 54, 73, 85, 86,  7, 30, 42, 53, 25, 36, 48, 59,
    17, 51, 67, 71, 37, 64, 70, 72, 17, 53, 80, 87, 49, 71, 85, 88, 20, 55, 83, 88,
    60, 74, 89, 90, 10, 35, 33, 37, 28, 36, 34, 38, 77, 105, 103, 107, 102, 106, 104, 108,
    47, 143, 103, 148, 123, 155, 138, 161, 82, 169, 176, 177, 169, 175, 177, 178, 42, 129, 119, 133,
    97, 132, 124, 134, 80, 149, 151, 153, 148, 150, 152, 154, 67, 168, 151, 180, 145, 179, 181, 182,
    83, 170, 184, 185, 173, 183, 186, 187, 12, 66, 35, 67, 40, 68, 63, 69, 52, 110, 143, 145,
    130, 146, 144, 147, 45, 110, 105, 151, 121, 157, 140, 164, 54, 112, 169, 181, 135, 159, 189, 192,
    30, 109, 129, 168, 99, 155, 144, 172, 53, 111, 168, 179, 133, 156, 188, 191, 51, 111, 149, 180,
    126, 158, 189, 193, 55, 113, 170, 182, 136, 160, 190, 194, 17, 67, 37, 70, 51, 71, 64, 72,
    80, 151, 148, 152, 149, 153, 150, 154, 49, 145, 107, 152, 126, 158, 141, 165, 85, 181, 177, 199,
    189, 201, 200, 202, 53, 168, 133, 188, 111, 179, 156, 191, 87, 180, 180, 206, 180, 206, 206, 207,
    71, 179, 153, 206, 158, 208, 201, 209, 88, 182, 185, 210, 193, 209, 211, 212,  6, 40, 28, 51,
    23, 46, 34, 57, 43, 121, 123, 126, 100, 125, 124, 127, 31, 130, 102, 149, 100, 146, 138, 162,
    54, 135, 169, 189, 112, 159, 181, 192, 25, 99, 97, 111, 93, 106, 104, 116, 49, 126, 145, 158,
    107, 141, 152, 165, 37, 133, 148, 180, 107, 153, 177, 185, 60, 136, 173, 193, 117, 166, 186, 197,
    15, 63, 34, 64, 34, 64, 62, 65, 79, 140, 138, 141, 138, 141, 139, 142, 48, 144, 104, 150,
    124, 156, 139, 163, 85, 189, 177, 200, 181, 201, 199, 202, 48, 144, 124, 156, 104, 150, 139, 163,
    85, 189, 181, 201, 177, 200, 199, 202, 70, 188, 152, 206, 152, 206, 199, 210, 89, 190, 186, 211,
    186, 211, 213, 214, 16, 68, 36, 71, 46, 73, 64, 74, 68, 157, 155, 158, 146, 159, 156, 160,
    46, 146, 106, 153, 125, 159, 141, 166, 73, 159, 175, 201, 159, 203, 201, 204, 36, 155, 132, 179,
    106, 175, 150, 183, 71, 158, 179, 208, 153, 201, 206, 209, 64, 156, 150, 206, 141, 201, 200, 211,
    74, 160, 183, 209, 166, 204, 211, 215, 18, 69, 38, 72, 57, 74, 65, 75, 81, 164, 161, 165,
    162, 166, 163, 167, 50, 147, 108, 154, 127, 160, 142, 167, 86, 192, 178, 202, 192, 204, 202, 205,
    59, 172, 134, 191, 116, 183, 163, 195, 88, 193, 182, 209, 185, 211, 210, 212, 72, 191, 154, 207,
    165, 209, 202, 212, 90, 194, 187, 212, 197, 215, 214, 216,  2, 13, 13, 19,  7, 17, 17, 20,
    12, 45, 52, 54, 30, 51, 53, 55, 10, 47, 77, 82, 42, 67, 80, 83, 17, 49, 80, 85,
    53, 71, 87, 88,  6, 31, 43, 54, 25, 37, 49, 60, 16, 46, 68, 73, 36, 64, 71, 74,
    15, 48, 79, 85, 48, 70, 85, 89, 18, 50, 81, 86, 59, 72, 88, 90, 12, 52, 45, 54,
    30, 53, 51, 55, 66, 110, 110, 112, 109, 111, 111, 113, 35, 143, 105, 169, 129, 168, 149, 170,
    67, 145, 151, 181, 168, 179, 180, 182, 40, 130, 121, 135, 99, 133, 126, 136, 68, 146, 157, 159,
    155, 156, 158, 160, 63, 144, 140, 189, 144, 188, 189, 190, 69, 147, 164, 192, 172, 191, 193, 194,
    10, 77, 47, 82, 42, 80, 67, 83, 35, 105, 143, 169, 129, 149, 168, 170, 33, 103, 103, 176,
    119, 151, 151, 184, 37, 107, 148, 177, 133, 153, 180, 185, 28, 102, 123, 169, 97, 148, 145, 173,
    36, 106, 155, 175, 132, 150, 179, 183, 34, 104, 138, 177, 124, 152, 181, 186, 38, 108, 161, 178,
    134, 154, 182, 187, 17, 80, 49, 85, 53, 87, 71, 88, 67, 151, 145, 181, 168, 180, 179, 182,
    37, 148, 107, 177, 133, 180, 153, 185, 70, 152, 152, 199, 188, 206, 206, 210, 51, 149, 126, 189,
    111, 180, 158, 193, 71, 153, 158, 201, 179, 206, 208, 209, 64, 150, 141, 200, 156, 206, 201, 211,
    72, 154, 165, 202, 191, 207, 209, 212,  6, 43, 31, 54, 25, 49, 37, 60, 40, 121, 130, 135,
    99, 126, 133, 136, 28, 123, 102, 169, 97, 145, 148, 173, 51, 126, 149, 189, 111, 158, 180, 193,
    23, 100, 100, 112, 93, 107, 107, 117, 46, 125, 146, 159, 106, 141, 153, 166, 34, 124, 138, 181,
    104, 152, 177, 186, 57, 127, 162, 192, 116, 165, 185, 197, 16, 68, 46, 73, 36, 71, 64, 74,
    68, 157, 146, 159, 155, 158, 156, 160, 36, 155, 106, 175, 132, 179, 150, 183, 71, 158, 153, 201,
    179, 208, 206, 209, 46, 146, 125, 159, 106, 153, 141, 166, 73, 159, 159, 203, 175, 201, 201, 204,
    64, 156, 141, 201, 150, 206, 200, 211, 74, 160, 166, 204, 183, 209, 211, 215, 15, 79, 48, 85,
    48, 85, 70, 89, 63, 140, 144, 189, 144, 189, 188, 190, 34, 138, 104, 177, 124, 181, 152, 186,
    64, 141, 150, 200, 156, 201, 206, 211, 34, 138, 124, 181, 104, 177, 152, 186, 64, 141, 156, 201,
    150, 200, 206, 211, 62, 139, 139, 199, 139, 199, 199, 213, 65, 142, 163, 202, 163, 202, 210, 214,
    18, 81, 50, 86, 59, 88, 72, 90, 69, 164, 147, 192, 172, 193, 191, 194, 38, 161, 108, 178,
    134, 182, 154, 187, 72, 165, 154, 202, 191, 209, 207, 212, 57, 162, 127, 192, 116, 185, 165, 197,
    74, 166, 160, 204, 183, 211, 209, 215, 65, 163, 142, 202, 163, 210, 202, 214, 75, 167, 167, 205,
    195, 212, 212, 216,  3, 14, 14, 20,  8, 18, 18, 21, 14, 56, 58, 60, 32, 57, 59, 61,
    14, 58, 78, 83, 44, 69, 81, 84, 20, 60, 83, 89, 55, 74, 88, 90,  8, 32, 44, 55,
    26, 38, 50, 61, 18, 57, 69, 74, 38, 65, 72, 75, 18, 59, 81, 88, 50, 72, 86, 90,
    21, 61, 84, 90, 61, 75, 90, 91, 14, 58, 56, 60, 32, 59, 57, 61, 78, 115, 115, 117,
    114, 116, 116, 118, 58, 171, 115, 173, 131, 172, 162, 174, 83, 173, 184, 186, 170, 183, 185, 187,
    44, 131, 122, 136, 101, 134, 127, 137, 81, 162, 164, 166, 161, 163, 165, 167, 69, 172, 164, 193,
    147, 191, 192, 194, 84, 174, 196, 197, 174, 195, 197, 198, 14, 78, 58, 83, 44, 81, 69, 84,
    58, 115, 171, 173, 131, 162, 172, 174, 56, 115, 115, 184, 122, 164, 164, 196, 60, 117, 173, 186,
    136, 166, 193, 197, 32, 114, 131, 170, 101, 161, 147, 174, 59, 116, 172, 183, 134, 163, 191, 195,
    57, 116, 162, 185, 127, 165, 192, 197, 61, 118, 174, 187, 137, 167, 194, 198, 20, 83, 60, 89,
    55, 88, 74, 90, 83, 184, 173, 186, 170, 185, 183, 187, 60, 173, 117, 186, 136, 193, 166, 197,
    89, 186, 186, 213, 190, 211, 211, 214, 55, 170, 136, 190, 113, 182, 160, 194, 88, 185, 193, 211,
    182, 210, 209, 212, 74, 183, 166, 211, 160, 209, 204, 215, 90, 187, 197, 214, 194, 212, 215, 216,
    8, 44, 32, 55, 26, 50, 38, 61, 44, 122, 131, 136, 101, 127, 134, 137, 32, 131, 114, 170,
    101, 147, 161, 174, 55, 136, 170, 190, 113, 160, 182, 194, 26, 101, 101, 113, 94, 108, 108, 118,
    50, 127, 147, 160, 108, 142, 154, 167, 38, 134, 161, 182, 108, 154, 178, 187, 61, 137, 174, 194,
    118, 167, 187, 198, 18, 69, 57, 74, 38, 72, 65, 75, 81, 164, 162, 166, 161, 165, 163, 167,
    59, 172, 116, 183, 134, 191, 163, 195, 88, 193, 185, 211, 182, 209, 210, 212, 50, 147, 127, 160,
    108, 154, 142, 167, 86, 192, 192, 204, 178, 202, 202, 205, 72, 191, 165, 209, 154, 207, 202, 212,
    90, 194, 197, 215, 187, 212, 214, 216, 18, 81, 59, 88, 50, 86, 72, 90, 69, 164, 172, 193,
    147, 192, 191, 194, 57, 162, 116, 185, 127, 192, 165, 197, 74, 166, 183, 211, 160, 204, 209, 215,
    38, 161, 134, 182, 108, 178, 154, 187, 72, 165, 191, 209, 154, 202, 207, 212, 65, 163, 163, 210,
    142, 202, 202, 214, 75, 167, 195, 212, 167, 205, 212, 216, 21, 84, 61, 90, 61, 90, 75, 91,
    84, 196, 174, 197, 174, 197, 195, 198, 61, 174, 118, 187, 137, 194, 167, 198, 90, 197, 187, 214,
    194, 215, 212, 216, 61, 174, 137, 194, 118, 187, 167, 198, 90, 197, 194, 215, 187, 214, 212, 216,
    75, 195, 167, 212, 167, 212, 205, 216, 91, 198, 198, 216, 198, 216, 216, 217
};

const unsigned int igraph_i_isoclass2_5u[] = {
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 4, 5, 6, 6, 7, 1, 2, 5, 6, 2, 4, 6,
    7, 2, 3, 6, 7, 6, 7, 8, 9, 1, 5, 2, 6, 2, 6, 4, 7, 2, 6, 3, 7, 6, 8,
    7, 9, 2, 6, 6, 8, 3, 7, 7, 9, 4, 7, 7, 9, 7, 9, 9, 10, 1, 2, 2, 4, 5,
    6, 6, 7, 2, 4, 4, 11, 12, 13, 13, 14, 5, 6, 12, 13, 12, 13, 15, 16,
    6, 7, 13, 14, 15, 16, 17, 18, 5, 12, 6, 13, 12, 15, 13, 16, 6, 13, 7,
    14, 15, 17, 16, 18, 12, 15, 15, 17, 19, 20, 20, 21, 13, 16, 16, 18,
    20, 21, 21, 22, 1, 2, 5, 6, 2, 4, 6, 7, 5, 6, 12, 13, 12, 13, 15, 16,
    2, 4, 12, 13, 4, 11, 13, 14, 6, 7, 15, 16, 13, 14, 17, 18, 5, 12, 12,
    15, 6, 13, 13, 16, 12, 15, 19, 20, 15, 17, 20, 21, 6, 13, 15, 17, 7,
    14, 16, 18, 13, 16, 20, 21, 16, 18, 21, 22, 2, 3, 6, 7, 6, 7, 8, 9,
    6, 7, 13, 14, 15, 16, 17, 18, 6, 7, 15, 16, 13, 14, 17, 18, 8, 9, 17,
    18, 17, 18, 23, 24, 12, 19, 15, 20, 15, 20, 17, 21, 15, 20, 20, 25,
    26, 27, 27, 28, 15, 20, 26, 27, 20, 25, 27, 28, 17, 21, 27, 28, 27,
    28, 29, 30, 1, 5, 2, 6, 2, 6, 4, 7, 5, 12, 6, 13, 12, 15, 13, 16, 5,
    12, 12, 15, 6, 13, 13, 16, 12, 19, 15, 20, 15, 20, 17, 21, 2, 12, 4,
    13, 4, 13, 11, 14, 6, 15, 7, 16, 13, 17, 14, 18, 6, 15, 13, 17, 7,
    16, 14, 18, 13, 20, 16, 21, 16, 21, 18, 22, 2, 6, 3, 7, 6, 8, 7, 9,
    6, 13, 7, 14, 15, 17, 16, 18, 12, 15, 19, 20, 15, 17, 20, 21, 15, 20,
    20, 25, 26, 27, 27, 28, 6, 15, 7, 16, 13, 17, 14, 18, 8, 17, 9, 18,
    17, 23, 18, 24, 15, 26, 20, 27, 20, 27, 25, 28, 17, 27, 21, 28, 27,
    29, 28, 30, 2, 6, 6, 8, 3, 7, 7, 9, 12, 15, 15, 17, 19, 20, 20, 21,
    6, 13, 15, 17, 7, 14, 16, 18, 15, 20, 26, 27, 20, 25, 27, 28, 6, 15,
    13, 17, 7, 16, 14, 18, 15, 26, 20, 27, 20, 27, 25, 28, 8, 17, 17, 23,
    9, 18, 18, 24, 17, 27, 27, 29, 21, 28, 28, 30, 4, 7, 7, 9, 7, 9, 9,
    10, 13, 16, 16, 18, 20, 21, 21, 22, 13, 16, 20, 21, 16, 18, 21, 22,
    17, 21, 27, 28, 27, 28, 29, 30, 13, 20, 16, 21, 16, 21, 18, 22, 17,
    27, 21, 28, 27, 29, 28, 30, 17, 27, 27, 29, 21, 28, 28, 30, 23, 29,
    29, 31, 29, 31, 31, 32, 1, 5, 5, 12, 5, 12, 12, 19, 2, 6, 6, 13, 12,
    15, 15, 20, 2, 6, 12, 15, 6, 13, 15, 20, 4, 7, 13, 16, 13, 16, 17,
    21, 2, 12, 6, 15, 6, 15, 13, 20, 4, 13, 7, 16, 13, 17, 16, 21, 4, 13,
    13, 17, 7, 16, 16, 21, 11, 14, 14, 18, 14, 18, 18, 22, 2, 6, 6, 13,
    12, 15, 15, 20, 3, 7, 7, 14, 19, 20, 20, 25, 6, 8, 15, 17, 15, 17,
    26, 27, 7, 9, 16, 18, 20, 21, 27, 28, 6, 15, 8, 17, 15, 26, 17, 27,
    7, 16, 9, 18, 20, 27, 21, 28, 13, 17, 17, 23, 20, 27, 27, 29, 14, 18,
    18, 24, 25, 28, 28, 30, 2, 6, 12, 15, 6, 13, 15, 20, 6, 8, 15, 17,
    15, 17, 26, 27, 3, 7, 19, 20, 7, 14, 20, 25, 7, 9, 20, 21, 16, 18,
    27, 28, 6, 15, 15, 26, 8, 17, 17, 27, 13, 17, 20, 27, 17, 23, 27, 29,
    7, 16, 20, 27, 9, 18, 21, 28, 14, 18, 25, 28, 18, 24, 28, 30, 4, 7,
    13, 16, 13, 16, 17, 21, 7, 9, 16, 18, 20, 21, 27, 28, 7, 9, 20, 21,
    16, 18, 27, 28, 9, 10, 21, 22, 21, 22, 29, 30, 13, 20, 17, 27, 17,
    27, 23, 29, 16, 21, 21, 28, 27, 29, 29, 31, 16, 21, 27, 29, 21, 28,
    29, 31, 18, 22, 28, 30, 28, 30, 31, 32, 2, 12, 6, 15, 6, 15, 13, 20,
    6, 15, 8, 17, 15, 26, 17, 27, 6, 15, 15, 26, 8, 17, 17, 27, 13, 20,
    17, 27, 17, 27, 23, 29, 3, 19, 7, 20, 7, 20, 14, 25, 7, 20, 9, 21,
    16, 27, 18, 28, 7, 20, 16, 27, 9, 21, 18, 28, 14, 25, 18, 28, 18, 28,
    24, 30, 4, 13, 7, 16, 13, 17, 16, 21, 7, 16, 9, 18, 20, 27, 21, 28,
    13, 17, 20, 27, 17, 23, 27, 29, 16, 21, 21, 28, 27, 29, 29, 31, 7,
    20, 9, 21, 16, 27, 18, 28, 9, 21, 10, 22, 21, 29, 22, 30, 16, 27, 21,
    29, 21, 29, 28, 31, 18, 28, 22, 30, 28, 31, 30, 32, 4, 13, 13, 17, 7,
    16, 16, 21, 13, 17, 17, 23, 20, 27, 27, 29, 7, 16, 20, 27, 9, 18, 21,
    28, 16, 21, 27, 29, 21, 28, 29, 31, 7, 20, 16, 27, 9, 21, 18, 28, 16,
    27, 21, 29, 21, 29, 28, 31, 9, 21, 21, 29, 10, 22, 22, 30, 18, 28,
    28, 31, 22, 30, 30, 32, 11, 14, 14, 18, 14, 18, 18, 22, 14, 18, 18,
    24, 25, 28, 28, 30, 14, 18, 25, 28, 18, 24, 28, 30, 18, 22, 28, 30,
    28, 30, 31, 32, 14, 25, 18, 28, 18, 28, 24, 30, 18, 28, 22, 30, 28,
    31, 30, 32, 18, 28, 28, 31, 22, 30, 30, 32, 24, 30, 30, 32, 30, 32,
    32, 33
};

const unsigned int igraph_i_isoclass2_6u[] = {
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 4, 5, 6, 6, 7, 1, 2, 5, 6, 2, 4, 6,
    7, 2, 3, 6, 7, 6, 7, 8, 9, 1, 5, 2, 6, 2, 6, 4, 7, 2, 6, 3, 7, 6, 8,
    7, 9, 2, 6, 6, 8, 3, 7, 7, 9, 4, 7, 7, 9, 7, 9, 9, 10, 1, 2, 2, 4, 5,
    6, 6, 7, 2, 4, 4, 11, 12, 13, 13, 14, 5, 6, 12, 13, 12, 13, 15, 16,
    6, 7, 13, 14, 15, 16, 17, 18, 5, 12, 6, 13, 12, 15, 13, 16, 6, 13, 7,
    14, 15, 17, 16, 18, 12, 15, 15, 17, 19, 20, 20, 21, 13, 16, 16, 18,
    20, 21, 21, 22, 1, 2, 5, 6, 2, 4, 6, 7, 5, 6, 12, 13, 12, 13, 15, 16,
    2, 4, 12, 13, 4, 11, 13, 14, 6, 7, 15, 16, 13, 14, 17, 18, 5, 12, 12,
    15, 6, 13, 13, 16, 12, 15, 19, 20, 15, 17, 20, 21, 6, 13, 15, 17, 7,
    14, 16, 18, 13, 16, 20, 21, 16, 18, 21, 22, 2, 3, 6, 7, 6, 7, 8, 9,
    6, 7, 13, 14, 15, 16, 17, 18, 6, 7, 15, 16, 13, 14, 17, 18, 8, 9, 17,
    18, 17, 18, 23, 24, 12, 19, 15, 20, 15, 20, 17, 21, 15, 20, 20, 25,
    26, 27, 27, 28, 15, 20, 26, 27, 20, 25, 27, 28, 17, 21, 27, 28, 27,
    28, 29, 30, 1, 5, 2, 6, 2, 6, 4, 7, 5, 12, 6, 13, 12, 15, 13, 16, 5,
    12, 12, 15, 6, 13, 13, 16, 12, 19, 15, 20, 15, 20, 17, 21, 2, 12, 4,
    13, 4, 13, 11, 14, 6, 15, 7, 16, 13, 17, 14, 18, 6, 15, 13, 17, 7,
    16, 14, 18, 13, 20, 16, 21, 16, 21, 18, 22, 2, 6, 3, 7, 6, 8, 7, 9,
    6, 13, 7, 14, 15, 17, 16, 18, 12, 15, 19, 20, 15, 17, 20, 21, 15, 20,
    20, 25, 26, 27, 27, 28, 6, 15, 7, 16, 13, 17, 14, 18, 8, 17, 9, 18,
    17, 23, 18, 24, 15, 26, 20, 27, 20, 27, 25, 28, 17, 27, 21, 28, 27,
    29, 28, 30, 2, 6, 6, 8, 3, 7, 7, 9, 12, 15, 15, 17, 19, 20, 20, 21,
    6, 13, 15, 17, 7, 14, 16, 18, 15, 20, 26, 27, 20, 25, 27, 28, 6, 15,
    13, 17, 7, 16, 14, 18, 15, 26, 20, 27, 20, 27, 25, 28, 8, 17, 17, 23,
    9, 18, 18, 24, 17, 27, 27, 29, 21, 28, 28, 30, 4, 7, 7, 9, 7, 9, 9,
    10, 13, 16, 16, 18, 20, 21, 21, 22, 13, 16, 20, 21, 16, 18, 21, 22,
    17, 21, 27, 28, 27, 28, 29, 30, 13, 20, 16, 21, 16, 21, 18, 22, 17,
    27, 21, 28, 27, 29, 28, 30, 17, 27, 27, 29, 21, 28, 28, 30, 23, 29,
    29, 31, 29, 31, 31, 32, 1, 5, 5, 12, 5, 12, 12, 19, 2, 6, 6, 13, 12,
    15, 15, 20, 2, 6, 12, 15, 6, 13, 15, 20, 4, 7, 13, 16, 13, 16, 17,
    21, 2, 12, 6, 15, 6, 15, 13, 20, 4, 13, 7, 16, 13, 17, 16, 21, 4, 13,
    13, 17, 7, 16, 16, 21, 11, 14, 14, 18, 14, 18, 18, 22, 2, 6, 6, 13,
    12, 15, 15, 20, 3, 7, 7, 14, 19, 20, 20, 25, 6, 8, 15, 17, 15, 17,
    26, 27, 7, 9, 16, 18, 20, 21, 27, 28, 6, 15, 8, 17, 15, 26, 17, 27,
    7, 16, 9, 18, 20, 27, 21, 28, 13, 17, 17, 23, 20, 27, 27, 29, 14, 18,
    18, 24, 25, 28, 28, 30, 2, 6, 12, 15, 6, 13, 15, 20, 6, 8, 15, 17,
    15, 17, 26, 27, 3, 7, 19, 20, 7, 14, 20, 25, 7, 9, 20, 21, 16, 18,
    27, 28, 6, 15, 15, 26, 8, 17, 17, 27, 13, 17, 20, 27, 17, 23, 27, 29,
    7, 16, 20, 27, 9, 18, 21, 28, 14, 18, 25, 28, 18, 24, 28, 30, 4, 7,
    13, 16, 13, 16, 17, 21, 7, 9, 16, 18, 20, 21, 27, 28, 7, 9, 20, 21,
    16, 18, 27, 28, 9, 10, 21, 22, 21, 22, 29, 30, 13, 20, 17, 27, 17,
    27, 23, 29, 16, 21, 21, 28, 27, 29, 29, 31, 16, 21, 27, 29, 21, 28,
    29, 31, 18, 22, 28, 30, 28, 30, 31, 32, 2, 12, 6, 15, 6, 15, 13, 20,
    6, 15, 8, 17, 15, 26, 17, 27, 6, 15, 15, 26, 8, 17, 17, 27, 13, 20,
    17, 27, 17, 27, 23, 29, 3, 19, 7, 20, 7, 20, 14, 25, 7, 20, 9, 21,
    16, 27, 18, 28, 7, 20, 16, 27, 9, 21, 18, 28, 14, 25, 18, 28, 18, 28,
    24, 30, 4, 13, 7, 16, 13, 17, 16, 21, 7, 16, 9, 18, 20, 27, 21, 28,
    13, 17, 20, 27, 17, 23, 27, 29, 16, 21, 21, 28, 27, 29, 29, 31, 7,
    20, 9, 21, 16, 27, 18, 28, 9, 21, 10, 22, 21, 29, 22, 30, 16, 27, 21,
    29, 21, 29, 28, 31, 18, 28, 22, 30, 28, 31, 30, 32, 4, 13, 13, 17, 7,
    16, 16, 21, 13, 17, 17, 23, 20, 27, 27, 29, 7, 16, 20, 27, 9, 18, 21,
    28, 16, 21, 27, 29, 21, 28, 29, 31, 7, 20, 16, 27, 9, 21, 18, 28, 16,
    27, 21, 29, 21, 29, 28, 31, 9, 21, 21, 29, 10, 22, 22, 30, 18, 28,
    28, 31, 22, 30, 30, 32, 11, 14, 14, 18, 14, 18, 18, 22, 14, 18, 18,
    24, 25, 28, 28, 30, 14, 18, 25, 28, 18, 24, 28, 30, 18, 22, 28, 30,
    28, 30, 31, 32, 14, 25, 18, 28, 18, 28, 24, 30, 18, 28, 22, 30, 28,
    31, 30, 32, 18, 28, 28, 31, 22, 30, 30, 32, 24, 30, 30, 32, 30, 32,
    32, 33, 1, 2, 2, 4, 5, 6, 6, 7, 2, 4, 4, 11, 12, 13, 13, 14, 5, 6,
    12, 13, 12, 13, 15, 16, 6, 7, 13, 14, 15, 16, 17, 18, 5, 12, 6, 13,
    12, 15, 13, 16, 6, 13, 7, 14, 15, 17, 16, 18, 12, 15, 15, 17, 19, 20,
    20, 21, 13, 16, 16, 18, 20, 21, 21, 22, 2, 4, 4, 11, 12, 13, 13, 14,
    4, 11, 11, 34, 35, 36, 36, 37, 12, 13, 35, 36, 38, 39, 40, 41, 13,
    14, 36, 37, 40, 41, 42, 43, 12, 35, 13, 36, 38, 40, 39, 41, 13, 36,
    14, 37, 40, 42, 41, 43, 38, 40, 40, 42, 44, 45, 45, 46, 39, 41, 41,
    43, 45, 46, 46, 47, 5, 6, 12, 13, 12, 13, 15, 16, 12, 13, 35, 36, 38,
    39, 40, 41, 12, 13, 38, 39, 35, 36, 40, 41, 15, 16, 40, 41, 40, 41,
    48, 49, 50, 51, 51, 52, 51, 52, 52, 53, 51, 52, 54, 55, 56, 57, 58,
    59, 51, 52, 56, 57, 54, 55, 58, 59, 52, 53, 58, 59, 58, 59, 60, 61,
    6, 7, 13, 14, 15, 16, 17, 18, 13, 14, 36, 37, 40, 41, 42, 43, 15, 16,
    40, 41, 40, 41, 48, 49, 17, 18, 42, 43, 48, 49, 62, 63, 51, 54, 52,
    55, 56, 58, 57, 59, 52, 55, 55, 64, 65, 66, 66, 67, 56, 58, 65, 66,
    68, 69, 70, 71, 57, 59, 66, 67, 70, 71, 72, 73, 5, 12, 6, 13, 12, 15,
    13, 16, 12, 35, 13, 36, 38, 40, 39, 41, 50, 51, 51, 52, 51, 52, 52,
    53, 51, 54, 52, 55, 56, 58, 57, 59, 12, 38, 13, 39, 35, 40, 36, 41,
    15, 40, 16, 41, 40, 48, 41, 49, 51, 56, 52, 57, 54, 58, 55, 59, 52,
    58, 53, 59, 58, 60, 59, 61, 6, 13, 7, 14, 15, 17, 16, 18, 13, 36, 14,
    37, 40, 42, 41, 43, 51, 52, 54, 55, 56, 57, 58, 59, 52, 55, 55, 64,
    65, 66, 66, 67, 15, 40, 16, 41, 40, 48, 41, 49, 17, 42, 18, 43, 48,
    62, 49, 63, 56, 65, 58, 66, 68, 70, 69, 71, 57, 66, 59, 67, 70, 72,
    71, 73, 12, 15, 15, 17, 19, 20, 20, 21, 38, 40, 40, 42, 44, 45, 45,
    46, 51, 52, 56, 57, 54, 55, 58, 59, 56, 58, 65, 66, 68, 69, 70, 71,
    51, 56, 52, 57, 54, 58, 55, 59, 56, 65, 58, 66, 68, 70, 69, 71, 74,
    75, 75, 76, 77, 78, 78, 79, 75, 80, 80, 81, 82, 83, 83, 84, 13, 16,
    16, 18, 20, 21, 21, 22, 39, 41, 41, 43, 45, 46, 46, 47, 52, 53, 58,
    59, 58, 59, 60, 61, 57, 59, 66, 67, 70, 71, 72, 73, 52, 58, 53, 59,
    58, 60, 59, 61, 57, 66, 59, 67, 70, 72, 71, 73, 75, 80, 80, 81, 82,
    83, 83, 84, 76, 81, 81, 85, 86, 87, 87, 88, 5, 12, 12, 35, 50, 51,
    51, 54, 6, 13, 13, 36, 51, 52, 52, 55, 12, 15, 38, 40, 51, 52, 56,
    58, 13, 16, 39, 41, 52, 53, 57, 59, 12, 38, 15, 40, 51, 56, 52, 58,
    13, 39, 16, 41, 52, 57, 53, 59, 35, 40, 40, 48, 54, 58, 58, 60, 36,
    41, 41, 49, 55, 59, 59, 61, 6, 13, 13, 36, 51, 52, 52, 55, 7, 14, 14,
    37, 54, 55, 55, 64, 15, 17, 40, 42, 56, 57, 65, 66, 16, 18, 41, 43,
    58, 59, 66, 67, 15, 40, 17, 42, 56, 65, 57, 66, 16, 41, 18, 43, 58,
    66, 59, 67, 40, 48, 48, 62, 68, 70, 70, 72, 41, 49, 49, 63, 69, 71,
    71, 73, 12, 15, 38, 40, 51, 52, 56, 58, 15, 17, 40, 42, 56, 57, 65,
    66, 19, 20, 44, 45, 54, 55, 68, 69, 20, 21, 45, 46, 58, 59, 70, 71,
    51, 56, 56, 65, 74, 75, 75, 80, 52, 57, 58, 66, 75, 76, 80, 81, 54,
    58, 68, 70, 77, 78, 82, 83, 55, 59, 69, 71, 78, 79, 83, 84, 13, 16,
    39, 41, 52, 53, 57, 59, 16, 18, 41, 43, 58, 59, 66, 67, 20, 21, 45,
    46, 58, 59, 70, 71, 21, 22, 46, 47, 60, 61, 72, 73, 52, 58, 57, 66,
    75, 80, 76, 81, 53, 59, 59, 67, 80, 81, 81, 85, 58, 60, 70, 72, 82,
    83, 86, 87, 59, 61, 71, 73, 83, 84, 87, 88, 12, 38, 15, 40, 51, 56,
    52, 58, 15, 40, 17, 42, 56, 65, 57, 66, 51, 56, 56, 65, 74, 75, 75,
    80, 52, 58, 57, 66, 75, 80, 76, 81, 19, 44, 20, 45, 54, 68, 55, 69,
    20, 45, 21, 46, 58, 70, 59, 71, 54, 68, 58, 70, 77, 82, 78, 83, 55,
    69, 59, 71, 78, 83, 79, 84, 13, 39, 16, 41, 52, 57, 53, 59, 16, 41,
    18, 43, 58, 66, 59, 67, 52, 57, 58, 66, 75, 76, 80, 81, 53, 59, 59,
    67, 80, 81, 81, 85, 20, 45, 21, 46, 58, 70, 59, 71, 21, 46, 22, 47,
    60, 72, 61, 73, 58, 70, 60, 72, 82, 86, 83, 87, 59, 71, 61, 73, 83,
    87, 84, 88, 35, 40, 40, 48, 54, 58, 58, 60, 40, 48, 48, 62, 68, 70,
    70, 72, 54, 58, 68, 70, 77, 78, 82, 83, 58, 60, 70, 72, 82, 83, 86,
    87, 54, 68, 58, 70, 77, 82, 78, 83, 58, 70, 60, 72, 82, 86, 83, 87,
    77, 82, 82, 86, 89, 90, 90, 91, 78, 83, 83, 87, 90, 91, 91, 92, 36,
    41, 41, 49, 55, 59, 59, 61, 41, 49, 49, 63, 69, 71, 71, 73, 55, 59,
    69, 71, 78, 79, 83, 84, 59, 61, 71, 73, 83, 84, 87, 88, 55, 69, 59,
    71, 78, 83, 79, 84, 59, 71, 61, 73, 83, 87, 84, 88, 78, 83, 83, 87,
    90, 91, 91, 92, 79, 84, 84, 88, 91, 92, 92, 93, 1, 2, 5, 6, 2, 4, 6,
    7, 5, 6, 12, 13, 12, 13, 15, 16, 2, 4, 12, 13, 4, 11, 13, 14, 6, 7,
    15, 16, 13, 14, 17, 18, 5, 12, 12, 15, 6, 13, 13, 16, 12, 15, 19, 20,
    15, 17, 20, 21, 6, 13, 15, 17, 7, 14, 16, 18, 13, 16, 20, 21, 16, 18,
    21, 22, 5, 6, 12, 13, 12, 13, 15, 16, 12, 13, 35, 36, 38, 39, 40, 41,
    12, 13, 38, 39, 35, 36, 40, 41, 15, 16, 40, 41, 40, 41, 48, 49, 50,
    51, 51, 52, 51, 52, 52, 53, 51, 52, 54, 55, 56, 57, 58, 59, 51, 52,
    56, 57, 54, 55, 58, 59, 52, 53, 58, 59, 58, 59, 60, 61, 2, 4, 12, 13,
    4, 11, 13, 14, 12, 13, 38, 39, 35, 36, 40, 41, 4, 11, 35, 36, 11, 34,
    36, 37, 13, 14, 40, 41, 36, 37, 42, 43, 12, 35, 38, 40, 13, 36, 39,
    41, 38, 40, 44, 45, 40, 42, 45, 46, 13, 36, 40, 42, 14, 37, 41, 43,
    39, 41, 45, 46, 41, 43, 46, 47, 6, 7, 15, 16, 13, 14, 17, 18, 15, 16,
    40, 41, 40, 41, 48, 49, 13, 14, 40, 41, 36, 37, 42, 43, 17, 18, 48,
    49, 42, 43, 62, 63, 51, 54, 56, 58, 52, 55, 57, 59, 56, 58, 68, 69,
    65, 66, 70, 71, 52, 55, 65, 66, 55, 64, 66, 67, 57, 59, 70, 71, 66,
    67, 72, 73, 5, 12, 12, 15, 6, 13, 13, 16, 50, 51, 51, 52, 51, 52, 52,
    53, 12, 35, 38, 40, 13, 36, 39, 41, 51, 54, 56, 58, 52, 55, 57, 59,
    12, 38, 35, 40, 13, 39, 36, 41, 51, 56, 54, 58, 52, 57, 55, 59, 15,
    40, 40, 48, 16, 41, 41, 49, 52, 58, 58, 60, 53, 59, 59, 61, 12, 15,
    19, 20, 15, 17, 20, 21, 51, 52, 54, 55, 56, 57, 58, 59, 38, 40, 44,
    45, 40, 42, 45, 46, 56, 58, 68, 69, 65, 66, 70, 71, 51, 56, 54, 58,
    52, 57, 55, 59, 74, 75, 77, 78, 75, 76, 78, 79, 56, 65, 68, 70, 58,
    66, 69, 71, 75, 80, 82, 83, 80, 81, 83, 84, 6, 13, 15, 17, 7, 14, 16,
    18, 51, 52, 56, 57, 54, 55, 58, 59, 13, 36, 40, 42, 14, 37, 41, 43,
    52, 55, 65, 66, 55, 64, 66, 67, 15, 40, 40, 48, 16, 41, 41, 49, 56,
    65, 68, 70, 58, 66, 69, 71, 17, 42, 48, 62, 18, 43, 49, 63, 57, 66,
    70, 72, 59, 67, 71, 73, 13, 16, 20, 21, 16, 18, 21, 22, 52, 53, 58,
    59, 58, 59, 60, 61, 39, 41, 45, 46, 41, 43, 46, 47, 57, 59, 70, 71,
    66, 67, 72, 73, 52, 58, 58, 60, 53, 59, 59, 61, 75, 80, 82, 83, 80,
    81, 83, 84, 57, 66, 70, 72, 59, 67, 71, 73, 76, 81, 86, 87, 81, 85,
    87, 88, 5, 12, 50, 51, 12, 35, 51, 54, 12, 15, 51, 52, 38, 40, 56,
    58, 6, 13, 51, 52, 13, 36, 52, 55, 13, 16, 52, 53, 39, 41, 57, 59,
    12, 38, 51, 56, 15, 40, 52, 58, 35, 40, 54, 58, 40, 48, 58, 60, 13,
    39, 52, 57, 16, 41, 53, 59, 36, 41, 55, 59, 41, 49, 59, 61, 12, 15,
    51, 52, 38, 40, 56, 58, 19, 20, 54, 55, 44, 45, 68, 69, 15, 17, 56,
    57, 40, 42, 65, 66, 20, 21, 58, 59, 45, 46, 70, 71, 51, 56, 74, 75,
    56, 65, 75, 80, 54, 58, 77, 78, 68, 70, 82, 83, 52, 57, 75, 76, 58,
    66, 80, 81, 55, 59, 78, 79, 69, 71, 83, 84, 6, 13, 51, 52, 13, 36,
    52, 55, 15, 17, 56, 57, 40, 42, 65, 66, 7, 14, 54, 55, 14, 37, 55,
    64, 16, 18, 58, 59, 41, 43, 66, 67, 15, 40, 56, 65, 17, 42, 57, 66,
    40, 48, 68, 70, 48, 62, 70, 72, 16, 41, 58, 66, 18, 43, 59, 67, 41,
    49, 69, 71, 49, 63, 71, 73, 13, 16, 52, 53, 39, 41, 57, 59, 20, 21,
    58, 59, 45, 46, 70, 71, 16, 18, 58, 59, 41, 43, 66, 67, 21, 22, 60,
    61, 46, 47, 72, 73, 52, 58, 75, 80, 57, 66, 76, 81, 58, 60, 82, 83,
    70, 72, 86, 87, 53, 59, 80, 81, 59, 67, 81, 85, 59, 61, 83, 84, 71,
    73, 87, 88, 12, 38, 51, 56, 15, 40, 52, 58, 51, 56, 74, 75, 56, 65,
    75, 80, 15, 40, 56, 65, 17, 42, 57, 66, 52, 58, 75, 80, 57, 66, 76,
    81, 19, 44, 54, 68, 20, 45, 55, 69, 54, 68, 77, 82, 58, 70, 78, 83,
    20, 45, 58, 70, 21, 46, 59, 71, 55, 69, 78, 83, 59, 71, 79, 84, 35,
    40, 54, 58, 40, 48, 58, 60, 54, 58, 77, 78, 68, 70, 82, 83, 40, 48,
    68, 70, 48, 62, 70, 72, 58, 60, 82, 83, 70, 72, 86, 87, 54, 68, 77,
    82, 58, 70, 78, 83, 77, 82, 89, 90, 82, 86, 90, 91, 58, 70, 82, 86,
    60, 72, 83, 87, 78, 83, 90, 91, 83, 87, 91, 92, 13, 39, 52, 57, 16,
    41, 53, 59, 52, 57, 75, 76, 58, 66, 80, 81, 16, 41, 58, 66, 18, 43,
    59, 67, 53, 59, 80, 81, 59, 67, 81, 85, 20, 45, 58, 70, 21, 46, 59,
    71, 58, 70, 82, 86, 60, 72, 83, 87, 21, 46, 60, 72, 22, 47, 61, 73,
    59, 71, 83, 87, 61, 73, 84, 88, 36, 41, 55, 59, 41, 49, 59, 61, 55,
    59, 78, 79, 69, 71, 83, 84, 41, 49, 69, 71, 49, 63, 71, 73, 59, 61,
    83, 84, 71, 73, 87, 88, 55, 69, 78, 83, 59, 71, 79, 84, 78, 83, 90,
    91, 83, 87, 91, 92, 59, 71, 83, 87, 61, 73, 84, 88, 79, 84, 91, 92,
    84, 88, 92, 93, 2, 3, 6, 7, 6, 7, 8, 9, 6, 7, 13, 14, 15, 16, 17, 18,
    6, 7, 15, 16, 13, 14, 17, 18, 8, 9, 17, 18, 17, 18, 23, 24, 12, 19,
    15, 20, 15, 20, 17, 21, 15, 20, 20, 25, 26, 27, 27, 28, 15, 20, 26,
    27, 20, 25, 27, 28, 17, 21, 27, 28, 27, 28, 29, 30, 6, 7, 13, 14, 15,
    16, 17, 18, 13, 14, 36, 37, 40, 41, 42, 43, 15, 16, 40, 41, 40, 41,
    48, 49, 17, 18, 42, 43, 48, 49, 62, 63, 51, 54, 52, 55, 56, 58, 57,
    59, 52, 55, 55, 64, 65, 66, 66, 67, 56, 58, 65, 66, 68, 69, 70, 71,
    57, 59, 66, 67, 70, 71, 72, 73, 6, 7, 15, 16, 13, 14, 17, 18, 15, 16,
    40, 41, 40, 41, 48, 49, 13, 14, 40, 41, 36, 37, 42, 43, 17, 18, 48,
    49, 42, 43, 62, 63, 51, 54, 56, 58, 52, 55, 57, 59, 56, 58, 68, 69,
    65, 66, 70, 71, 52, 55, 65, 66, 55, 64, 66, 67, 57, 59, 70, 71, 66,
    67, 72, 73, 8, 9, 17, 18, 17, 18, 23, 24, 17, 18, 42, 43, 48, 49, 62,
    63, 17, 18, 48, 49, 42, 43, 62, 63, 23, 24, 62, 63, 62, 63, 94, 95,
    74, 77, 75, 78, 75, 78, 76, 79, 75, 78, 96, 97, 98, 99, 100, 101, 75,
    78, 98, 99, 96, 97, 100, 101, 76, 79, 100, 101, 100, 101, 102, 103,
    12, 19, 15, 20, 15, 20, 17, 21, 51, 54, 52, 55, 56, 58, 57, 59, 51,
    54, 56, 58, 52, 55, 57, 59, 74, 77, 75, 78, 75, 78, 76, 79, 38, 44,
    40, 45, 40, 45, 42, 46, 56, 68, 58, 69, 65, 70, 66, 71, 56, 68, 65,
    70, 58, 69, 66, 71, 75, 82, 80, 83, 80, 83, 81, 84, 15, 20, 20, 25,
    26, 27, 27, 28, 52, 55, 55, 64, 65, 66, 66, 67, 56, 58, 68, 69, 65,
    66, 70, 71, 75, 78, 96, 97, 98, 99, 100, 101, 56, 68, 58, 69, 65, 70,
    66, 71, 75, 96, 78, 97, 98, 100, 99, 101, 104, 105, 105, 106, 105,
    106, 106, 107, 108, 109, 109, 110, 111, 112, 112, 113, 15, 20, 26,
    27, 20, 25, 27, 28, 56, 58, 65, 66, 68, 69, 70, 71, 52, 55, 65, 66,
    55, 64, 66, 67, 75, 78, 98, 99, 96, 97, 100, 101, 56, 68, 65, 70, 58,
    69, 66, 71, 104, 105, 105, 106, 105, 106, 106, 107, 75, 96, 98, 100,
    78, 97, 99, 101, 108, 109, 111, 112, 109, 110, 112, 113, 17, 21, 27,
    28, 27, 28, 29, 30, 57, 59, 66, 67, 70, 71, 72, 73, 57, 59, 70, 71,
    66, 67, 72, 73, 76, 79, 100, 101, 100, 101, 102, 103, 75, 82, 80, 83,
    80, 83, 81, 84, 108, 109, 109, 110, 111, 112, 112, 113, 108, 109,
    111, 112, 109, 110, 112, 113, 114, 115, 116, 117, 116, 117, 118, 119,
    12, 19, 51, 54, 51, 54, 74, 77, 15, 20, 52, 55, 56, 58, 75, 78, 15,
    20, 56, 58, 52, 55, 75, 78, 17, 21, 57, 59, 57, 59, 76, 79, 38, 44,
    56, 68, 56, 68, 75, 82, 40, 45, 58, 69, 65, 70, 80, 83, 40, 45, 65,
    70, 58, 69, 80, 83, 42, 46, 66, 71, 66, 71, 81, 84, 15, 20, 52, 55,
    56, 58, 75, 78, 20, 25, 55, 64, 68, 69, 96, 97, 26, 27, 65, 66, 65,
    66, 98, 99, 27, 28, 66, 67, 70, 71, 100, 101, 56, 68, 75, 96, 104,
    105, 108, 109, 58, 69, 78, 97, 105, 106, 109, 110, 65, 70, 98, 100,
    105, 106, 111, 112, 66, 71, 99, 101, 106, 107, 112, 113, 15, 20, 56,
    58, 52, 55, 75, 78, 26, 27, 65, 66, 65, 66, 98, 99, 20, 25, 68, 69,
    55, 64, 96, 97, 27, 28, 70, 71, 66, 67, 100, 101, 56, 68, 104, 105,
    75, 96, 108, 109, 65, 70, 105, 106, 98, 100, 111, 112, 58, 69, 105,
    106, 78, 97, 109, 110, 66, 71, 106, 107, 99, 101, 112, 113, 17, 21,
    57, 59, 57, 59, 76, 79, 27, 28, 66, 67, 70, 71, 100, 101, 27, 28, 70,
    71, 66, 67, 100, 101, 29, 30, 72, 73, 72, 73, 102, 103, 75, 82, 108,
    109, 108, 109, 114, 115, 80, 83, 109, 110, 111, 112, 116, 117, 80,
    83, 111, 112, 109, 110, 116, 117, 81, 84, 112, 113, 112, 113, 118,
    119, 38, 44, 56, 68, 56, 68, 75, 82, 56, 68, 75, 96, 104, 105, 108,
    109, 56, 68, 104, 105, 75, 96, 108, 109, 75, 82, 108, 109, 108, 109,
    114, 115, 44, 120, 68, 121, 68, 121, 96, 122, 68, 121, 82, 122, 105,
    123, 109, 124, 68, 121, 105, 123, 82, 122, 109, 124, 96, 122, 109,
    124, 109, 124, 115, 125, 40, 45, 58, 69, 65, 70, 80, 83, 58, 69, 78,
    97, 105, 106, 109, 110, 65, 70, 105, 106, 98, 100, 111, 112, 80, 83,
    109, 110, 111, 112, 116, 117, 68, 121, 82, 122, 105, 123, 109, 124,
    82, 122, 90, 126, 127, 128, 129, 130, 105, 123, 127, 128, 127, 128,
    131, 132, 109, 124, 129, 130, 131, 132, 133, 134, 40, 45, 65, 70, 58,
    69, 80, 83, 65, 70, 98, 100, 105, 106, 111, 112, 58, 69, 105, 106,
    78, 97, 109, 110, 80, 83, 111, 112, 109, 110, 116, 117, 68, 121, 105,
    123, 82, 122, 109, 124, 105, 123, 127, 128, 127, 128, 131, 132, 82,
    122, 127, 128, 90, 126, 129, 130, 109, 124, 131, 132, 129, 130, 133,
    134, 42, 46, 66, 71, 66, 71, 81, 84, 66, 71, 99, 101, 106, 107, 112,
    113, 66, 71, 106, 107, 99, 101, 112, 113, 81, 84, 112, 113, 112, 113,
    118, 119, 96, 122, 109, 124, 109, 124, 115, 125, 109, 124, 129, 130,
    131, 132, 133, 134, 109, 124, 131, 132, 129, 130, 133, 134, 115, 125,
    133, 134, 133, 134, 135, 136, 1, 5, 2, 6, 2, 6, 4, 7, 5, 12, 6, 13,
    12, 15, 13, 16, 5, 12, 12, 15, 6, 13, 13, 16, 12, 19, 15, 20, 15, 20,
    17, 21, 2, 12, 4, 13, 4, 13, 11, 14, 6, 15, 7, 16, 13, 17, 14, 18, 6,
    15, 13, 17, 7, 16, 14, 18, 13, 20, 16, 21, 16, 21, 18, 22, 5, 12, 6,
    13, 12, 15, 13, 16, 12, 35, 13, 36, 38, 40, 39, 41, 50, 51, 51, 52,
    51, 52, 52, 53, 51, 54, 52, 55, 56, 58, 57, 59, 12, 38, 13, 39, 35,
    40, 36, 41, 15, 40, 16, 41, 40, 48, 41, 49, 51, 56, 52, 57, 54, 58,
    55, 59, 52, 58, 53, 59, 58, 60, 59, 61, 5, 12, 12, 15, 6, 13, 13, 16,
    50, 51, 51, 52, 51, 52, 52, 53, 12, 35, 38, 40, 13, 36, 39, 41, 51,
    54, 56, 58, 52, 55, 57, 59, 12, 38, 35, 40, 13, 39, 36, 41, 51, 56,
    54, 58, 52, 57, 55, 59, 15, 40, 40, 48, 16, 41, 41, 49, 52, 58, 58,
    60, 53, 59, 59, 61, 12, 19, 15, 20, 15, 20, 17, 21, 51, 54, 52, 55,
    56, 58, 57, 59, 51, 54, 56, 58, 52, 55, 57, 59, 74, 77, 75, 78, 75,
    78, 76, 79, 38, 44, 40, 45, 40, 45, 42, 46, 56, 68, 58, 69, 65, 70,
    66, 71, 56, 68, 65, 70, 58, 69, 66, 71, 75, 82, 80, 83, 80, 83, 81,
    84, 2, 12, 4, 13, 4, 13, 11, 14, 12, 38, 13, 39, 35, 40, 36, 41, 12,
    38, 35, 40, 13, 39, 36, 41, 38, 44, 40, 45, 40, 45, 42, 46, 4, 35,
    11, 36, 11, 36, 34, 37, 13, 40, 14, 41, 36, 42, 37, 43, 13, 40, 36,
    42, 14, 41, 37, 43, 39, 45, 41, 46, 41, 46, 43, 47, 6, 15, 7, 16, 13,
    17, 14, 18, 15, 40, 16, 41, 40, 48, 41, 49, 51, 56, 54, 58, 52, 57,
    55, 59, 56, 68, 58, 69, 65, 70, 66, 71, 13, 40, 14, 41, 36, 42, 37,
    43, 17, 48, 18, 49, 42, 62, 43, 63, 52, 65, 55, 66, 55, 66, 64, 67,
    57, 70, 59, 71, 66, 72, 67, 73, 6, 15, 13, 17, 7, 16, 14, 18, 51, 56,
    52, 57, 54, 58, 55, 59, 15, 40, 40, 48, 16, 41, 41, 49, 56, 68, 65,
    70, 58, 69, 66, 71, 13, 40, 36, 42, 14, 41, 37, 43, 52, 65, 55, 66,
    55, 66, 64, 67, 17, 48, 42, 62, 18, 49, 43, 63, 57, 70, 66, 72, 59,
    71, 67, 73, 13, 20, 16, 21, 16, 21, 18, 22, 52, 58, 53, 59, 58, 60,
    59, 61, 52, 58, 58, 60, 53, 59, 59, 61, 75, 82, 80, 83, 80, 83, 81,
    84, 39, 45, 41, 46, 41, 46, 43, 47, 57, 70, 59, 71, 66, 72, 67, 73,
    57, 70, 66, 72, 59, 71, 67, 73, 76, 86, 81, 87, 81, 87, 85, 88, 5,
    50, 12, 51, 12, 51, 35, 54, 12, 51, 15, 52, 38, 56, 40, 58, 12, 51,
    38, 56, 15, 52, 40, 58, 35, 54, 40, 58, 40, 58, 48, 60, 6, 51, 13,
    52, 13, 52, 36, 55, 13, 52, 16, 53, 39, 57, 41, 59, 13, 52, 39, 57,
    16, 53, 41, 59, 36, 55, 41, 59, 41, 59, 49, 61, 12, 51, 15, 52, 38,
    56, 40, 58, 19, 54, 20, 55, 44, 68, 45, 69, 51, 74, 56, 75, 56, 75,
    65, 80, 54, 77, 58, 78, 68, 82, 70, 83, 15, 56, 17, 57, 40, 65, 42,
    66, 20, 58, 21, 59, 45, 70, 46, 71, 52, 75, 57, 76, 58, 80, 66, 81,
    55, 78, 59, 79, 69, 83, 71, 84, 12, 51, 38, 56, 15, 52, 40, 58, 51,
    74, 56, 75, 56, 75, 65, 80, 19, 54, 44, 68, 20, 55, 45, 69, 54, 77,
    68, 82, 58, 78, 70, 83, 15, 56, 40, 65, 17, 57, 42, 66, 52, 75, 58,
    80, 57, 76, 66, 81, 20, 58, 45, 70, 21, 59, 46, 71, 55, 78, 69, 83,
    59, 79, 71, 84, 35, 54, 40, 58, 40, 58, 48, 60, 54, 77, 58, 78, 68,
    82, 70, 83, 54, 77, 68, 82, 58, 78, 70, 83, 77, 89, 82, 90, 82, 90,
    86, 91, 40, 68, 48, 70, 48, 70, 62, 72, 58, 82, 60, 83, 70, 86, 72,
    87, 58, 82, 70, 86, 60, 83, 72, 87, 78, 90, 83, 91, 83, 91, 87, 92,
    6, 51, 13, 52, 13, 52, 36, 55, 15, 56, 17, 57, 40, 65, 42, 66, 15,
    56, 40, 65, 17, 57, 42, 66, 40, 68, 48, 70, 48, 70, 62, 72, 7, 54,
    14, 55, 14, 55, 37, 64, 16, 58, 18, 59, 41, 66, 43, 67, 16, 58, 41,
    66, 18, 59, 43, 67, 41, 69, 49, 71, 49, 71, 63, 73, 13, 52, 16, 53,
    39, 57, 41, 59, 20, 58, 21, 59, 45, 70, 46, 71, 52, 75, 58, 80, 57,
    76, 66, 81, 58, 82, 60, 83, 70, 86, 72, 87, 16, 58, 18, 59, 41, 66,
    43, 67, 21, 60, 22, 61, 46, 72, 47, 73, 53, 80, 59, 81, 59, 81, 67,
    85, 59, 83, 61, 84, 71, 87, 73, 88, 13, 52, 39, 57, 16, 53, 41, 59,
    52, 75, 57, 76, 58, 80, 66, 81, 20, 58, 45, 70, 21, 59, 46, 71, 58,
    82, 70, 86, 60, 83, 72, 87, 16, 58, 41, 66, 18, 59, 43, 67, 53, 80,
    59, 81, 59, 81, 67, 85, 21, 60, 46, 72, 22, 61, 47, 73, 59, 83, 71,
    87, 61, 84, 73, 88, 36, 55, 41, 59, 41, 59, 49, 61, 55, 78, 59, 79,
    69, 83, 71, 84, 55, 78, 69, 83, 59, 79, 71, 84, 78, 90, 83, 91, 83,
    91, 87, 92, 41, 69, 49, 71, 49, 71, 63, 73, 59, 83, 61, 84, 71, 87,
    73, 88, 59, 83, 71, 87, 61, 84, 73, 88, 79, 91, 84, 92, 84, 92, 88,
    93, 2, 6, 3, 7, 6, 8, 7, 9, 6, 13, 7, 14, 15, 17, 16, 18, 12, 15, 19,
    20, 15, 17, 20, 21, 15, 20, 20, 25, 26, 27, 27, 28, 6, 15, 7, 16, 13,
    17, 14, 18, 8, 17, 9, 18, 17, 23, 18, 24, 15, 26, 20, 27, 20, 27, 25,
    28, 17, 27, 21, 28, 27, 29, 28, 30, 6, 13, 7, 14, 15, 17, 16, 18, 13,
    36, 14, 37, 40, 42, 41, 43, 51, 52, 54, 55, 56, 57, 58, 59, 52, 55,
    55, 64, 65, 66, 66, 67, 15, 40, 16, 41, 40, 48, 41, 49, 17, 42, 18,
    43, 48, 62, 49, 63, 56, 65, 58, 66, 68, 70, 69, 71, 57, 66, 59, 67,
    70, 72, 71, 73, 12, 15, 19, 20, 15, 17, 20, 21, 51, 52, 54, 55, 56,
    57, 58, 59, 38, 40, 44, 45, 40, 42, 45, 46, 56, 58, 68, 69, 65, 66,
    70, 71, 51, 56, 54, 58, 52, 57, 55, 59, 74, 75, 77, 78, 75, 76, 78,
    79, 56, 65, 68, 70, 58, 66, 69, 71, 75, 80, 82, 83, 80, 81, 83, 84,
    15, 20, 20, 25, 26, 27, 27, 28, 52, 55, 55, 64, 65, 66, 66, 67, 56,
    58, 68, 69, 65, 66, 70, 71, 75, 78, 96, 97, 98, 99, 100, 101, 56, 68,
    58, 69, 65, 70, 66, 71, 75, 96, 78, 97, 98, 100, 99, 101, 104, 105,
    105, 106, 105, 106, 106, 107, 108, 109, 109, 110, 111, 112, 112, 113,
    6, 15, 7, 16, 13, 17, 14, 18, 15, 40, 16, 41, 40, 48, 41, 49, 51, 56,
    54, 58, 52, 57, 55, 59, 56, 68, 58, 69, 65, 70, 66, 71, 13, 40, 14,
    41, 36, 42, 37, 43, 17, 48, 18, 49, 42, 62, 43, 63, 52, 65, 55, 66,
    55, 66, 64, 67, 57, 70, 59, 71, 66, 72, 67, 73, 8, 17, 9, 18, 17, 23,
    18, 24, 17, 42, 18, 43, 48, 62, 49, 63, 74, 75, 77, 78, 75, 76, 78,
    79, 75, 96, 78, 97, 98, 100, 99, 101, 17, 48, 18, 49, 42, 62, 43, 63,
    23, 62, 24, 63, 62, 94, 63, 95, 75, 98, 78, 99, 96, 100, 97, 101, 76,
    100, 79, 101, 100, 102, 101, 103, 15, 26, 20, 27, 20, 27, 25, 28, 56,
    65, 58, 66, 68, 70, 69, 71, 56, 65, 68, 70, 58, 66, 69, 71, 104, 105,
    105, 106, 105, 106, 106, 107, 52, 65, 55, 66, 55, 66, 64, 67, 75, 98,
    78, 99, 96, 100, 97, 101, 75, 98, 96, 100, 78, 99, 97, 101, 108, 111,
    109, 112, 109, 112, 110, 113, 17, 27, 21, 28, 27, 29, 28, 30, 57, 66,
    59, 67, 70, 72, 71, 73, 75, 80, 82, 83, 80, 81, 83, 84, 108, 109,
    109, 110, 111, 112, 112, 113, 57, 70, 59, 71, 66, 72, 67, 73, 76,
    100, 79, 101, 100, 102, 101, 103, 108, 111, 109, 112, 109, 112, 110,
    113, 114, 116, 115, 117, 116, 118, 117, 119, 12, 51, 19, 54, 51, 74,
    54, 77, 15, 52, 20, 55, 56, 75, 58, 78, 38, 56, 44, 68, 56, 75, 68,
    82, 40, 58, 45, 69, 65, 80, 70, 83, 15, 56, 20, 58, 52, 75, 55, 78,
    17, 57, 21, 59, 57, 76, 59, 79, 40, 65, 45, 70, 58, 80, 69, 83, 42,
    66, 46, 71, 66, 81, 71, 84, 15, 52, 20, 55, 56, 75, 58, 78, 20, 55,
    25, 64, 68, 96, 69, 97, 56, 75, 68, 96, 104, 108, 105, 109, 58, 78,
    69, 97, 105, 109, 106, 110, 26, 65, 27, 66, 65, 98, 66, 99, 27, 66,
    28, 67, 70, 100, 71, 101, 65, 98, 70, 100, 105, 111, 106, 112, 66,
    99, 71, 101, 106, 112, 107, 113, 38, 56, 44, 68, 56, 75, 68, 82, 56,
    75, 68, 96, 104, 108, 105, 109, 44, 68, 120, 121, 68, 96, 121, 122,
    68, 82, 121, 122, 105, 109, 123, 124, 56, 104, 68, 105, 75, 108, 96,
    109, 75, 108, 82, 109, 108, 114, 109, 115, 68, 105, 121, 123, 82,
    109, 122, 124, 96, 109, 122, 124, 109, 115, 124, 125, 40, 58, 45, 69,
    65, 80, 70, 83, 58, 78, 69, 97, 105, 109, 106, 110, 68, 82, 121, 122,
    105, 109, 123, 124, 82, 90, 122, 126, 127, 129, 128, 130, 65, 105,
    70, 106, 98, 111, 100, 112, 80, 109, 83, 110, 111, 116, 112, 117,
    105, 127, 123, 128, 127, 131, 128, 132, 109, 129, 124, 130, 131, 133,
    132, 134, 15, 56, 20, 58, 52, 75, 55, 78, 26, 65, 27, 66, 65, 98, 66,
    99, 56, 104, 68, 105, 75, 108, 96, 109, 65, 105, 70, 106, 98, 111,
    100, 112, 20, 68, 25, 69, 55, 96, 64, 97, 27, 70, 28, 71, 66, 100,
    67, 101, 58, 105, 69, 106, 78, 109, 97, 110, 66, 106, 71, 107, 99,
    112, 101, 113, 17, 57, 21, 59, 57, 76, 59, 79, 27, 66, 28, 67, 70,
    100, 71, 101, 75, 108, 82, 109, 108, 114, 109, 115, 80, 109, 83, 110,
    111, 116, 112, 117, 27, 70, 28, 71, 66, 100, 67, 101, 29, 72, 30, 73,
    72, 102, 73, 103, 80, 111, 83, 112, 109, 116, 110, 117, 81, 112, 84,
    113, 112, 118, 113, 119, 40, 65, 45, 70, 58, 80, 69, 83, 65, 98, 70,
    100, 105, 111, 106, 112, 68, 105, 121, 123, 82, 109, 122, 124, 105,
    127, 123, 128, 127, 131, 128, 132, 58, 105, 69, 106, 78, 109, 97,
    110, 80, 111, 83, 112, 109, 116, 110, 117, 82, 127, 122, 128, 90,
    129, 126, 130, 109, 131, 124, 132, 129, 133, 130, 134, 42, 66, 46,
    71, 66, 81, 71, 84, 66, 99, 71, 101, 106, 112, 107, 113, 96, 109,
    122, 124, 109, 115, 124, 125, 109, 129, 124, 130, 131, 133, 132, 134,
    66, 106, 71, 107, 99, 112, 101, 113, 81, 112, 84, 113, 112, 118, 113,
    119, 109, 131, 124, 132, 129, 133, 130, 134, 115, 133, 125, 134, 133,
    135, 134, 136, 2, 6, 6, 8, 3, 7, 7, 9, 12, 15, 15, 17, 19, 20, 20,
    21, 6, 13, 15, 17, 7, 14, 16, 18, 15, 20, 26, 27, 20, 25, 27, 28, 6,
    15, 13, 17, 7, 16, 14, 18, 15, 26, 20, 27, 20, 27, 25, 28, 8, 17, 17,
    23, 9, 18, 18, 24, 17, 27, 27, 29, 21, 28, 28, 30, 12, 15, 15, 17,
    19, 20, 20, 21, 38, 40, 40, 42, 44, 45, 45, 46, 51, 52, 56, 57, 54,
    55, 58, 59, 56, 58, 65, 66, 68, 69, 70, 71, 51, 56, 52, 57, 54, 58,
    55, 59, 56, 65, 58, 66, 68, 70, 69, 71, 74, 75, 75, 76, 77, 78, 78,
    79, 75, 80, 80, 81, 82, 83, 83, 84, 6, 13, 15, 17, 7, 14, 16, 18, 51,
    52, 56, 57, 54, 55, 58, 59, 13, 36, 40, 42, 14, 37, 41, 43, 52, 55,
    65, 66, 55, 64, 66, 67, 15, 40, 40, 48, 16, 41, 41, 49, 56, 65, 68,
    70, 58, 66, 69, 71, 17, 42, 48, 62, 18, 43, 49, 63, 57, 66, 70, 72,
    59, 67, 71, 73, 15, 20, 26, 27, 20, 25, 27, 28, 56, 58, 65, 66, 68,
    69, 70, 71, 52, 55, 65, 66, 55, 64, 66, 67, 75, 78, 98, 99, 96, 97,
    100, 101, 56, 68, 65, 70, 58, 69, 66, 71, 104, 105, 105, 106, 105,
    106, 106, 107, 75, 96, 98, 100, 78, 97, 99, 101, 108, 109, 111, 112,
    109, 110, 112, 113, 6, 15, 13, 17, 7, 16, 14, 18, 51, 56, 52, 57, 54,
    58, 55, 59, 15, 40, 40, 48, 16, 41, 41, 49, 56, 68, 65, 70, 58, 69,
    66, 71, 13, 40, 36, 42, 14, 41, 37, 43, 52, 65, 55, 66, 55, 66, 64,
    67, 17, 48, 42, 62, 18, 49, 43, 63, 57, 70, 66, 72, 59, 71, 67, 73,
    15, 26, 20, 27, 20, 27, 25, 28, 56, 65, 58, 66, 68, 70, 69, 71, 56,
    65, 68, 70, 58, 66, 69, 71, 104, 105, 105, 106, 105, 106, 106, 107,
    52, 65, 55, 66, 55, 66, 64, 67, 75, 98, 78, 99, 96, 100, 97, 101, 75,
    98, 96, 100, 78, 99, 97, 101, 108, 111, 109, 112, 109, 112, 110, 113,
    8, 17, 17, 23, 9, 18, 18, 24, 74, 75, 75, 76, 77, 78, 78, 79, 17, 42,
    48, 62, 18, 43, 49, 63, 75, 96, 98, 100, 78, 97, 99, 101, 17, 48, 42,
    62, 18, 49, 43, 63, 75, 98, 96, 100, 78, 99, 97, 101, 23, 62, 62, 94,
    24, 63, 63, 95, 76, 100, 100, 102, 79, 101, 101, 103, 17, 27, 27, 29,
    21, 28, 28, 30, 75, 80, 80, 81, 82, 83, 83, 84, 57, 66, 70, 72, 59,
    67, 71, 73, 108, 109, 111, 112, 109, 110, 112, 113, 57, 70, 66, 72,
    59, 71, 67, 73, 108, 111, 109, 112, 109, 112, 110, 113, 76, 100, 100,
    102, 79, 101, 101, 103, 114, 116, 116, 118, 115, 117, 117, 119, 12,
    51, 51, 74, 19, 54, 54, 77, 38, 56, 56, 75, 44, 68, 68, 82, 15, 52,
    56, 75, 20, 55, 58, 78, 40, 58, 65, 80, 45, 69, 70, 83, 15, 56, 52,
    75, 20, 58, 55, 78, 40, 65, 58, 80, 45, 70, 69, 83, 17, 57, 57, 76,
    21, 59, 59, 79, 42, 66, 66, 81, 46, 71, 71, 84, 38, 56, 56, 75, 44,
    68, 68, 82, 44, 68, 68, 96, 120, 121, 121, 122, 56, 75, 104, 108, 68,
    96, 105, 109, 68, 82, 105, 109, 121, 122, 123, 124, 56, 104, 75, 108,
    68, 105, 96, 109, 68, 105, 82, 109, 121, 123, 122, 124, 75, 108, 108,
    114, 82, 109, 109, 115, 96, 109, 109, 115, 122, 124, 124, 125, 15,
    52, 56, 75, 20, 55, 58, 78, 56, 75, 104, 108, 68, 96, 105, 109, 20,
    55, 68, 96, 25, 64, 69, 97, 58, 78, 105, 109, 69, 97, 106, 110, 26,
    65, 65, 98, 27, 66, 66, 99, 65, 98, 105, 111, 70, 100, 106, 112, 27,
    66, 70, 100, 28, 67, 71, 101, 66, 99, 106, 112, 71, 101, 107, 113,
    40, 58, 65, 80, 45, 69, 70, 83, 68, 82, 105, 109, 121, 122, 123, 124,
    58, 78, 105, 109, 69, 97, 106, 110, 82, 90, 127, 129, 122, 126, 128,
    130, 65, 105, 98, 111, 70, 106, 100, 112, 105, 127, 127, 131, 123,
    128, 128, 132, 80, 109, 111, 116, 83, 110, 112, 117, 109, 129, 131,
    133, 124, 130, 132, 134, 15, 56, 52, 75, 20, 58, 55, 78, 56, 104, 75,
    108, 68, 105, 96, 109, 26, 65, 65, 98, 27, 66, 66, 99, 65, 105, 98,
    111, 70, 106, 100, 112, 20, 68, 55, 96, 25, 69, 64, 97, 58, 105, 78,
    109, 69, 106, 97, 110, 27, 70, 66, 100, 28, 71, 67, 101, 66, 106, 99,
    112, 71, 107, 101, 113, 40, 65, 58, 80, 45, 70, 69, 83, 68, 105, 82,
    109, 121, 123, 122, 124, 65, 98, 105, 111, 70, 100, 106, 112, 105,
    127, 127, 131, 123, 128, 128, 132, 58, 105, 78, 109, 69, 106, 97,
    110, 82, 127, 90, 129, 122, 128, 126, 130, 80, 111, 109, 116, 83,
    112, 110, 117, 109, 131, 129, 133, 124, 132, 130, 134, 17, 57, 57,
    76, 21, 59, 59, 79, 75, 108, 108, 114, 82, 109, 109, 115, 27, 66, 70,
    100, 28, 67, 71, 101, 80, 109, 111, 116, 83, 110, 112, 117, 27, 70,
    66, 100, 28, 71, 67, 101, 80, 111, 109, 116, 83, 112, 110, 117, 29,
    72, 72, 102, 30, 73, 73, 103, 81, 112, 112, 118, 84, 113, 113, 119,
    42, 66, 66, 81, 46, 71, 71, 84, 96, 109, 109, 115, 122, 124, 124,
    125, 66, 99, 106, 112, 71, 101, 107, 113, 109, 129, 131, 133, 124,
    130, 132, 134, 66, 106, 99, 112, 71, 107, 101, 113, 109, 131, 129,
    133, 124, 132, 130, 134, 81, 112, 112, 118, 84, 113, 113, 119, 115,
    133, 133, 135, 125, 134, 134, 136, 4, 7, 7, 9, 7, 9, 9, 10, 13, 16,
    16, 18, 20, 21, 21, 22, 13, 16, 20, 21, 16, 18, 21, 22, 17, 21, 27,
    28, 27, 28, 29, 30, 13, 20, 16, 21, 16, 21, 18, 22, 17, 27, 21, 28,
    27, 29, 28, 30, 17, 27, 27, 29, 21, 28, 28, 30, 23, 29, 29, 31, 29,
    31, 31, 32, 13, 16, 16, 18, 20, 21, 21, 22, 39, 41, 41, 43, 45, 46,
    46, 47, 52, 53, 58, 59, 58, 59, 60, 61, 57, 59, 66, 67, 70, 71, 72,
    73, 52, 58, 53, 59, 58, 60, 59, 61, 57, 66, 59, 67, 70, 72, 71, 73,
    75, 80, 80, 81, 82, 83, 83, 84, 76, 81, 81, 85, 86, 87, 87, 88, 13,
    16, 20, 21, 16, 18, 21, 22, 52, 53, 58, 59, 58, 59, 60, 61, 39, 41,
    45, 46, 41, 43, 46, 47, 57, 59, 70, 71, 66, 67, 72, 73, 52, 58, 58,
    60, 53, 59, 59, 61, 75, 80, 82, 83, 80, 81, 83, 84, 57, 66, 70, 72,
    59, 67, 71, 73, 76, 81, 86, 87, 81, 85, 87, 88, 17, 21, 27, 28, 27,
    28, 29, 30, 57, 59, 66, 67, 70, 71, 72, 73, 57, 59, 70, 71, 66, 67,
    72, 73, 76, 79, 100, 101, 100, 101, 102, 103, 75, 82, 80, 83, 80, 83,
    81, 84, 108, 109, 109, 110, 111, 112, 112, 113, 108, 109, 111, 112,
    109, 110, 112, 113, 114, 115, 116, 117, 116, 117, 118, 119, 13, 20,
    16, 21, 16, 21, 18, 22, 52, 58, 53, 59, 58, 60, 59, 61, 52, 58, 58,
    60, 53, 59, 59, 61, 75, 82, 80, 83, 80, 83, 81, 84, 39, 45, 41, 46,
    41, 46, 43, 47, 57, 70, 59, 71, 66, 72, 67, 73, 57, 70, 66, 72, 59,
    71, 67, 73, 76, 86, 81, 87, 81, 87, 85, 88, 17, 27, 21, 28, 27, 29,
    28, 30, 57, 66, 59, 67, 70, 72, 71, 73, 75, 80, 82, 83, 80, 81, 83,
    84, 108, 109, 109, 110, 111, 112, 112, 113, 57, 70, 59, 71, 66, 72,
    67, 73, 76, 100, 79, 101, 100, 102, 101, 103, 108, 111, 109, 112,
    109, 112, 110, 113, 114, 116, 115, 117, 116, 118, 117, 119, 17, 27,
    27, 29, 21, 28, 28, 30, 75, 80, 80, 81, 82, 83, 83, 84, 57, 66, 70,
    72, 59, 67, 71, 73, 108, 109, 111, 112, 109, 110, 112, 113, 57, 70,
    66, 72, 59, 71, 67, 73, 108, 111, 109, 112, 109, 112, 110, 113, 76,
    100, 100, 102, 79, 101, 101, 103, 114, 116, 116, 118, 115, 117, 117,
    119, 23, 29, 29, 31, 29, 31, 31, 32, 76, 81, 81, 85, 86, 87, 87, 88,
    76, 81, 86, 87, 81, 85, 87, 88, 114, 115, 116, 117, 116, 117, 118,
    119, 76, 86, 81, 87, 81, 87, 85, 88, 114, 116, 115, 117, 116, 118,
    117, 119, 114, 116, 116, 118, 115, 117, 117, 119, 137, 138, 138, 139,
    138, 139, 139, 140, 35, 54, 54, 77, 54, 77, 77, 89, 40, 58, 58, 78,
    68, 82, 82, 90, 40, 58, 68, 82, 58, 78, 82, 90, 48, 60, 70, 83, 70,
    83, 86, 91, 40, 68, 58, 82, 58, 82, 78, 90, 48, 70, 60, 83, 70, 86,
    83, 91, 48, 70, 70, 86, 60, 83, 83, 91, 62, 72, 72, 87, 72, 87, 87,
    92, 40, 58, 58, 78, 68, 82, 82, 90, 45, 69, 69, 97, 121, 122, 122,
    126, 65, 80, 105, 109, 105, 109, 127, 129, 70, 83, 106, 110, 123,
    124, 128, 130, 65, 105, 80, 109, 105, 127, 109, 129, 70, 106, 83,
    110, 123, 128, 124, 130, 98, 111, 111, 116, 127, 131, 131, 133, 100,
    112, 112, 117, 128, 132, 132, 134, 40, 58, 68, 82, 58, 78, 82, 90,
    65, 80, 105, 109, 105, 109, 127, 129, 45, 69, 121, 122, 69, 97, 122,
    126, 70, 83, 123, 124, 106, 110, 128, 130, 65, 105, 105, 127, 80,
    109, 109, 129, 98, 111, 127, 131, 111, 116, 131, 133, 70, 106, 123,
    128, 83, 110, 124, 130, 100, 112, 128, 132, 112, 117, 132, 134, 48,
    60, 70, 83, 70, 83, 86, 91, 70, 83, 106, 110, 123, 124, 128, 130, 70,
    83, 123, 124, 106, 110, 128, 130, 86, 91, 128, 130, 128, 130, 141,
    142, 98, 127, 111, 131, 111, 131, 116, 133, 111, 131, 131, 143, 144,
    145, 145, 146, 111, 131, 144, 145, 131, 143, 145, 146, 116, 133, 145,
    146, 145, 146, 147, 148, 40, 68, 58, 82, 58, 82, 78, 90, 65, 105, 80,
    109, 105, 127, 109, 129, 65, 105, 105, 127, 80, 109, 109, 129, 98,
    127, 111, 131, 111, 131, 116, 133, 45, 121, 69, 122, 69, 122, 97,
    126, 70, 123, 83, 124, 106, 128, 110, 130, 70, 123, 106, 128, 83,
    124, 110, 130, 100, 128, 112, 132, 112, 132, 117, 134, 48, 70, 60,
    83, 70, 86, 83, 91, 70, 106, 83, 110, 123, 128, 124, 130, 98, 111,
    127, 131, 111, 116, 131, 133, 111, 131, 131, 143, 144, 145, 145, 146,
    70, 123, 83, 124, 106, 128, 110, 130, 86, 128, 91, 130, 128, 141,
    130, 142, 111, 144, 131, 145, 131, 145, 143, 146, 116, 145, 133, 146,
    145, 147, 146, 148, 48, 70, 70, 86, 60, 83, 83, 91, 98, 111, 111,
    116, 127, 131, 131, 133, 70, 106, 123, 128, 83, 110, 124, 130, 111,
    131, 144, 145, 131, 143, 145, 146, 70, 123, 106, 128, 83, 124, 110,
    130, 111, 144, 131, 145, 131, 145, 143, 146, 86, 128, 128, 141, 91,
    130, 130, 142, 116, 145, 145, 147, 133, 146, 146, 148, 62, 72, 72,
    87, 72, 87, 87, 92, 100, 112, 112, 117, 128, 132, 132, 134, 100, 112,
    128, 132, 112, 117, 132, 134, 116, 133, 145, 146, 145, 146, 147, 148,
    100, 128, 112, 132, 112, 132, 117, 134, 116, 145, 133, 146, 145, 147,
    146, 148, 116, 145, 145, 147, 133, 146, 146, 148, 138, 149, 149, 150,
    149, 150, 150, 151, 1, 5, 5, 12, 5, 12, 12, 19, 2, 6, 6, 13, 12, 15,
    15, 20, 2, 6, 12, 15, 6, 13, 15, 20, 4, 7, 13, 16, 13, 16, 17, 21, 2,
    12, 6, 15, 6, 15, 13, 20, 4, 13, 7, 16, 13, 17, 16, 21, 4, 13, 13,
    17, 7, 16, 16, 21, 11, 14, 14, 18, 14, 18, 18, 22, 5, 12, 12, 35, 50,
    51, 51, 54, 6, 13, 13, 36, 51, 52, 52, 55, 12, 15, 38, 40, 51, 52,
    56, 58, 13, 16, 39, 41, 52, 53, 57, 59, 12, 38, 15, 40, 51, 56, 52,
    58, 13, 39, 16, 41, 52, 57, 53, 59, 35, 40, 40, 48, 54, 58, 58, 60,
    36, 41, 41, 49, 55, 59, 59, 61, 5, 12, 50, 51, 12, 35, 51, 54, 12,
    15, 51, 52, 38, 40, 56, 58, 6, 13, 51, 52, 13, 36, 52, 55, 13, 16,
    52, 53, 39, 41, 57, 59, 12, 38, 51, 56, 15, 40, 52, 58, 35, 40, 54,
    58, 40, 48, 58, 60, 13, 39, 52, 57, 16, 41, 53, 59, 36, 41, 55, 59,
    41, 49, 59, 61, 12, 19, 51, 54, 51, 54, 74, 77, 15, 20, 52, 55, 56,
    58, 75, 78, 15, 20, 56, 58, 52, 55, 75, 78, 17, 21, 57, 59, 57, 59,
    76, 79, 38, 44, 56, 68, 56, 68, 75, 82, 40, 45, 58, 69, 65, 70, 80,
    83, 40, 45, 65, 70, 58, 69, 80, 83, 42, 46, 66, 71, 66, 71, 81, 84,
    5, 50, 12, 51, 12, 51, 35, 54, 12, 51, 15, 52, 38, 56, 40, 58, 12,
    51, 38, 56, 15, 52, 40, 58, 35, 54, 40, 58, 40, 58, 48, 60, 6, 51,
    13, 52, 13, 52, 36, 55, 13, 52, 16, 53, 39, 57, 41, 59, 13, 52, 39,
    57, 16, 53, 41, 59, 36, 55, 41, 59, 41, 59, 49, 61, 12, 51, 19, 54,
    51, 74, 54, 77, 15, 52, 20, 55, 56, 75, 58, 78, 38, 56, 44, 68, 56,
    75, 68, 82, 40, 58, 45, 69, 65, 80, 70, 83, 15, 56, 20, 58, 52, 75,
    55, 78, 17, 57, 21, 59, 57, 76, 59, 79, 40, 65, 45, 70, 58, 80, 69,
    83, 42, 66, 46, 71, 66, 81, 71, 84, 12, 51, 51, 74, 19, 54, 54, 77,
    38, 56, 56, 75, 44, 68, 68, 82, 15, 52, 56, 75, 20, 55, 58, 78, 40,
    58, 65, 80, 45, 69, 70, 83, 15, 56, 52, 75, 20, 58, 55, 78, 40, 65,
    58, 80, 45, 70, 69, 83, 17, 57, 57, 76, 21, 59, 59, 79, 42, 66, 66,
    81, 46, 71, 71, 84, 35, 54, 54, 77, 54, 77, 77, 89, 40, 58, 58, 78,
    68, 82, 82, 90, 40, 58, 68, 82, 58, 78, 82, 90, 48, 60, 70, 83, 70,
    83, 86, 91, 40, 68, 58, 82, 58, 82, 78, 90, 48, 70, 60, 83, 70, 86,
    83, 91, 48, 70, 70, 86, 60, 83, 83, 91, 62, 72, 72, 87, 72, 87, 87,
    92, 2, 12, 12, 38, 12, 38, 38, 44, 4, 13, 13, 39, 35, 40, 40, 45, 4,
    13, 35, 40, 13, 39, 40, 45, 11, 14, 36, 41, 36, 41, 42, 46, 4, 35,
    13, 40, 13, 40, 39, 45, 11, 36, 14, 41, 36, 42, 41, 46, 11, 36, 36,
    42, 14, 41, 41, 46, 34, 37, 37, 43, 37, 43, 43, 47, 6, 15, 15, 40,
    51, 56, 56, 68, 7, 16, 16, 41, 54, 58, 58, 69, 13, 17, 40, 48, 52,
    57, 65, 70, 14, 18, 41, 49, 55, 59, 66, 71, 13, 40, 17, 48, 52, 65,
    57, 70, 14, 41, 18, 49, 55, 66, 59, 71, 36, 42, 42, 62, 55, 66, 66,
    72, 37, 43, 43, 63, 64, 67, 67, 73, 6, 15, 51, 56, 15, 40, 56, 68,
    13, 17, 52, 57, 40, 48, 65, 70, 7, 16, 54, 58, 16, 41, 58, 69, 14,
    18, 55, 59, 41, 49, 66, 71, 13, 40, 52, 65, 17, 48, 57, 70, 36, 42,
    55, 66, 42, 62, 66, 72, 14, 41, 55, 66, 18, 49, 59, 71, 37, 43, 64,
    67, 43, 63, 67, 73, 13, 20, 52, 58, 52, 58, 75, 82, 16, 21, 53, 59,
    58, 60, 80, 83, 16, 21, 58, 60, 53, 59, 80, 83, 18, 22, 59, 61, 59,
    61, 81, 84, 39, 45, 57, 70, 57, 70, 76, 86, 41, 46, 59, 71, 66, 72,
    81, 87, 41, 46, 66, 72, 59, 71, 81, 87, 43, 47, 67, 73, 67, 73, 85,
    88, 6, 51, 15, 56, 15, 56, 40, 68, 13, 52, 17, 57, 40, 65, 48, 70,
    13, 52, 40, 65, 17, 57, 48, 70, 36, 55, 42, 66, 42, 66, 62, 72, 7,
    54, 16, 58, 16, 58, 41, 69, 14, 55, 18, 59, 41, 66, 49, 71, 14, 55,
    41, 66, 18, 59, 49, 71, 37, 64, 43, 67, 43, 67, 63, 73, 13, 52, 20,
    58, 52, 75, 58, 82, 16, 53, 21, 59, 58, 80, 60, 83, 39, 57, 45, 70,
    57, 76, 70, 86, 41, 59, 46, 71, 66, 81, 72, 87, 16, 58, 21, 60, 53,
    80, 59, 83, 18, 59, 22, 61, 59, 81, 61, 84, 41, 66, 46, 72, 59, 81,
    71, 87, 43, 67, 47, 73, 67, 85, 73, 88, 13, 52, 52, 75, 20, 58, 58,
    82, 39, 57, 57, 76, 45, 70, 70, 86, 16, 53, 58, 80, 21, 59, 60, 83,
    41, 59, 66, 81, 46, 71, 72, 87, 16, 58, 53, 80, 21, 60, 59, 83, 41,
    66, 59, 81, 46, 72, 71, 87, 18, 59, 59, 81, 22, 61, 61, 84, 43, 67,
    67, 85, 47, 73, 73, 88, 36, 55, 55, 78, 55, 78, 78, 90, 41, 59, 59,
    79, 69, 83, 83, 91, 41, 59, 69, 83, 59, 79, 83, 91, 49, 61, 71, 84,
    71, 84, 87, 92, 41, 69, 59, 83, 59, 83, 79, 91, 49, 71, 61, 84, 71,
    87, 84, 92, 49, 71, 71, 87, 61, 84, 84, 92, 63, 73, 73, 88, 73, 88,
    88, 93, 2, 6, 6, 13, 12, 15, 15, 20, 3, 7, 7, 14, 19, 20, 20, 25, 6,
    8, 15, 17, 15, 17, 26, 27, 7, 9, 16, 18, 20, 21, 27, 28, 6, 15, 8,
    17, 15, 26, 17, 27, 7, 16, 9, 18, 20, 27, 21, 28, 13, 17, 17, 23, 20,
    27, 27, 29, 14, 18, 18, 24, 25, 28, 28, 30, 6, 13, 13, 36, 51, 52,
    52, 55, 7, 14, 14, 37, 54, 55, 55, 64, 15, 17, 40, 42, 56, 57, 65,
    66, 16, 18, 41, 43, 58, 59, 66, 67, 15, 40, 17, 42, 56, 65, 57, 66,
    16, 41, 18, 43, 58, 66, 59, 67, 40, 48, 48, 62, 68, 70, 70, 72, 41,
    49, 49, 63, 69, 71, 71, 73, 12, 15, 51, 52, 38, 40, 56, 58, 19, 20,
    54, 55, 44, 45, 68, 69, 15, 17, 56, 57, 40, 42, 65, 66, 20, 21, 58,
    59, 45, 46, 70, 71, 51, 56, 74, 75, 56, 65, 75, 80, 54, 58, 77, 78,
    68, 70, 82, 83, 52, 57, 75, 76, 58, 66, 80, 81, 55, 59, 78, 79, 69,
    71, 83, 84, 15, 20, 52, 55, 56, 58, 75, 78, 20, 25, 55, 64, 68, 69,
    96, 97, 26, 27, 65, 66, 65, 66, 98, 99, 27, 28, 66, 67, 70, 71, 100,
    101, 56, 68, 75, 96, 104, 105, 108, 109, 58, 69, 78, 97, 105, 106,
    109, 110, 65, 70, 98, 100, 105, 106, 111, 112, 66, 71, 99, 101, 106,
    107, 112, 113, 12, 51, 15, 52, 38, 56, 40, 58, 19, 54, 20, 55, 44,
    68, 45, 69, 51, 74, 56, 75, 56, 75, 65, 80, 54, 77, 58, 78, 68, 82,
    70, 83, 15, 56, 17, 57, 40, 65, 42, 66, 20, 58, 21, 59, 45, 70, 46,
    71, 52, 75, 57, 76, 58, 80, 66, 81, 55, 78, 59, 79, 69, 83, 71, 84,
    15, 52, 20, 55, 56, 75, 58, 78, 20, 55, 25, 64, 68, 96, 69, 97, 56,
    75, 68, 96, 104, 108, 105, 109, 58, 78, 69, 97, 105, 109, 106, 110,
    26, 65, 27, 66, 65, 98, 66, 99, 27, 66, 28, 67, 70, 100, 71, 101, 65,
    98, 70, 100, 105, 111, 106, 112, 66, 99, 71, 101, 106, 112, 107, 113,
    38, 56, 56, 75, 44, 68, 68, 82, 44, 68, 68, 96, 120, 121, 121, 122,
    56, 75, 104, 108, 68, 96, 105, 109, 68, 82, 105, 109, 121, 122, 123,
    124, 56, 104, 75, 108, 68, 105, 96, 109, 68, 105, 82, 109, 121, 123,
    122, 124, 75, 108, 108, 114, 82, 109, 109, 115, 96, 109, 109, 115,
    122, 124, 124, 125, 40, 58, 58, 78, 68, 82, 82, 90, 45, 69, 69, 97,
    121, 122, 122, 126, 65, 80, 105, 109, 105, 109, 127, 129, 70, 83,
    106, 110, 123, 124, 128, 130, 65, 105, 80, 109, 105, 127, 109, 129,
    70, 106, 83, 110, 123, 128, 124, 130, 98, 111, 111, 116, 127, 131,
    131, 133, 100, 112, 112, 117, 128, 132, 132, 134, 6, 15, 15, 40, 51,
    56, 56, 68, 7, 16, 16, 41, 54, 58, 58, 69, 13, 17, 40, 48, 52, 57,
    65, 70, 14, 18, 41, 49, 55, 59, 66, 71, 13, 40, 17, 48, 52, 65, 57,
    70, 14, 41, 18, 49, 55, 66, 59, 71, 36, 42, 42, 62, 55, 66, 66, 72,
    37, 43, 43, 63, 64, 67, 67, 73, 8, 17, 17, 42, 74, 75, 75, 96, 9, 18,
    18, 43, 77, 78, 78, 97, 17, 23, 48, 62, 75, 76, 98, 100, 18, 24, 49,
    63, 78, 79, 99, 101, 17, 48, 23, 62, 75, 98, 76, 100, 18, 49, 24, 63,
    78, 99, 79, 101, 42, 62, 62, 94, 96, 100, 100, 102, 43, 63, 63, 95,
    97, 101, 101, 103, 15, 26, 56, 65, 56, 65, 104, 105, 20, 27, 58, 66,
    68, 70, 105, 106, 20, 27, 68, 70, 58, 66, 105, 106, 25, 28, 69, 71,
    69, 71, 106, 107, 52, 65, 75, 98, 75, 98, 108, 111, 55, 66, 78, 99,
    96, 100, 109, 112, 55, 66, 96, 100, 78, 99, 109, 112, 64, 67, 97,
    101, 97, 101, 110, 113, 17, 27, 57, 66, 75, 80, 108, 109, 21, 28, 59,
    67, 82, 83, 109, 110, 27, 29, 70, 72, 80, 81, 111, 112, 28, 30, 71,
    73, 83, 84, 112, 113, 57, 70, 76, 100, 108, 111, 114, 116, 59, 71,
    79, 101, 109, 112, 115, 117, 66, 72, 100, 102, 109, 112, 116, 118,
    67, 73, 101, 103, 110, 113, 117, 119, 15, 56, 26, 65, 56, 104, 65,
    105, 20, 58, 27, 66, 68, 105, 70, 106, 52, 75, 65, 98, 75, 108, 98,
    111, 55, 78, 66, 99, 96, 109, 100, 112, 20, 68, 27, 70, 58, 105, 66,
    106, 25, 69, 28, 71, 69, 106, 71, 107, 55, 96, 66, 100, 78, 109, 99,
    112, 64, 97, 67, 101, 97, 110, 101, 113, 17, 57, 27, 66, 75, 108, 80,
    109, 21, 59, 28, 67, 82, 109, 83, 110, 57, 76, 70, 100, 108, 114,
    111, 116, 59, 79, 71, 101, 109, 115, 112, 117, 27, 70, 29, 72, 80,
    111, 81, 112, 28, 71, 30, 73, 83, 112, 84, 113, 66, 100, 72, 102,
    109, 116, 112, 118, 67, 101, 73, 103, 110, 117, 113, 119, 40, 65, 65,
    98, 68, 105, 105, 127, 45, 70, 70, 100, 121, 123, 123, 128, 58, 80,
    105, 111, 82, 109, 127, 131, 69, 83, 106, 112, 122, 124, 128, 132,
    58, 105, 80, 111, 82, 127, 109, 131, 69, 106, 83, 112, 122, 128, 124,
    132, 78, 109, 109, 116, 90, 129, 129, 133, 97, 110, 110, 117, 126,
    130, 130, 134, 42, 66, 66, 99, 96, 109, 109, 129, 46, 71, 71, 101,
    122, 124, 124, 130, 66, 81, 106, 112, 109, 115, 131, 133, 71, 84,
    107, 113, 124, 125, 132, 134, 66, 106, 81, 112, 109, 131, 115, 133,
    71, 107, 84, 113, 124, 132, 125, 134, 99, 112, 112, 118, 129, 133,
    133, 135, 101, 113, 113, 119, 130, 134, 134, 136, 2, 6, 12, 15, 6,
    13, 15, 20, 6, 8, 15, 17, 15, 17, 26, 27, 3, 7, 19, 20, 7, 14, 20,
    25, 7, 9, 20, 21, 16, 18, 27, 28, 6, 15, 15, 26, 8, 17, 17, 27, 13,
    17, 20, 27, 17, 23, 27, 29, 7, 16, 20, 27, 9, 18, 21, 28, 14, 18, 25,
    28, 18, 24, 28, 30, 12, 15, 38, 40, 51, 52, 56, 58, 15, 17, 40, 42,
    56, 57, 65, 66, 19, 20, 44, 45, 54, 55, 68, 69, 20, 21, 45, 46, 58,
    59, 70, 71, 51, 56, 56, 65, 74, 75, 75, 80, 52, 57, 58, 66, 75, 76,
    80, 81, 54, 58, 68, 70, 77, 78, 82, 83, 55, 59, 69, 71, 78, 79, 83,
    84, 6, 13, 51, 52, 13, 36, 52, 55, 15, 17, 56, 57, 40, 42, 65, 66, 7,
    14, 54, 55, 14, 37, 55, 64, 16, 18, 58, 59, 41, 43, 66, 67, 15, 40,
    56, 65, 17, 42, 57, 66, 40, 48, 68, 70, 48, 62, 70, 72, 16, 41, 58,
    66, 18, 43, 59, 67, 41, 49, 69, 71, 49, 63, 71, 73, 15, 20, 56, 58,
    52, 55, 75, 78, 26, 27, 65, 66, 65, 66, 98, 99, 20, 25, 68, 69, 55,
    64, 96, 97, 27, 28, 70, 71, 66, 67, 100, 101, 56, 68, 104, 105, 75,
    96, 108, 109, 65, 70, 105, 106, 98, 100, 111, 112, 58, 69, 105, 106,
    78, 97, 109, 110, 66, 71, 106, 107, 99, 101, 112, 113, 12, 51, 38,
    56, 15, 52, 40, 58, 51, 74, 56, 75, 56, 75, 65, 80, 19, 54, 44, 68,
    20, 55, 45, 69, 54, 77, 68, 82, 58, 78, 70, 83, 15, 56, 40, 65, 17,
    57, 42, 66, 52, 75, 58, 80, 57, 76, 66, 81, 20, 58, 45, 70, 21, 59,
    46, 71, 55, 78, 69, 83, 59, 79, 71, 84, 38, 56, 44, 68, 56, 75, 68,
    82, 56, 75, 68, 96, 104, 108, 105, 109, 44, 68, 120, 121, 68, 96,
    121, 122, 68, 82, 121, 122, 105, 109, 123, 124, 56, 104, 68, 105, 75,
    108, 96, 109, 75, 108, 82, 109, 108, 114, 109, 115, 68, 105, 121,
    123, 82, 109, 122, 124, 96, 109, 122, 124, 109, 115, 124, 125, 15,
    52, 56, 75, 20, 55, 58, 78, 56, 75, 104, 108, 68, 96, 105, 109, 20,
    55, 68, 96, 25, 64, 69, 97, 58, 78, 105, 109, 69, 97, 106, 110, 26,
    65, 65, 98, 27, 66, 66, 99, 65, 98, 105, 111, 70, 100, 106, 112, 27,
    66, 70, 100, 28, 67, 71, 101, 66, 99, 106, 112, 71, 101, 107, 113,
    40, 58, 68, 82, 58, 78, 82, 90, 65, 80, 105, 109, 105, 109, 127, 129,
    45, 69, 121, 122, 69, 97, 122, 126, 70, 83, 123, 124, 106, 110, 128,
    130, 65, 105, 105, 127, 80, 109, 109, 129, 98, 111, 127, 131, 111,
    116, 131, 133, 70, 106, 123, 128, 83, 110, 124, 130, 100, 112, 128,
    132, 112, 117, 132, 134, 6, 15, 51, 56, 15, 40, 56, 68, 13, 17, 52,
    57, 40, 48, 65, 70, 7, 16, 54, 58, 16, 41, 58, 69, 14, 18, 55, 59,
    41, 49, 66, 71, 13, 40, 52, 65, 17, 48, 57, 70, 36, 42, 55, 66, 42,
    62, 66, 72, 14, 41, 55, 66, 18, 49, 59, 71, 37, 43, 64, 67, 43, 63,
    67, 73, 15, 26, 56, 65, 56, 65, 104, 105, 20, 27, 58, 66, 68, 70,
    105, 106, 20, 27, 68, 70, 58, 66, 105, 106, 25, 28, 69, 71, 69, 71,
    106, 107, 52, 65, 75, 98, 75, 98, 108, 111, 55, 66, 78, 99, 96, 100,
    109, 112, 55, 66, 96, 100, 78, 99, 109, 112, 64, 67, 97, 101, 97,
    101, 110, 113, 8, 17, 74, 75, 17, 42, 75, 96, 17, 23, 75, 76, 48, 62,
    98, 100, 9, 18, 77, 78, 18, 43, 78, 97, 18, 24, 78, 79, 49, 63, 99,
    101, 17, 48, 75, 98, 23, 62, 76, 100, 42, 62, 96, 100, 62, 94, 100,
    102, 18, 49, 78, 99, 24, 63, 79, 101, 43, 63, 97, 101, 63, 95, 101,
    103, 17, 27, 75, 80, 57, 66, 108, 109, 27, 29, 80, 81, 70, 72, 111,
    112, 21, 28, 82, 83, 59, 67, 109, 110, 28, 30, 83, 84, 71, 73, 112,
    113, 57, 70, 108, 111, 76, 100, 114, 116, 66, 72, 109, 112, 100, 102,
    116, 118, 59, 71, 109, 112, 79, 101, 115, 117, 67, 73, 110, 113, 101,
    103, 117, 119, 15, 56, 56, 104, 26, 65, 65, 105, 52, 75, 75, 108, 65,
    98, 98, 111, 20, 58, 68, 105, 27, 66, 70, 106, 55, 78, 96, 109, 66,
    99, 100, 112, 20, 68, 58, 105, 27, 70, 66, 106, 55, 96, 78, 109, 66,
    100, 99, 112, 25, 69, 69, 106, 28, 71, 71, 107, 64, 97, 97, 110, 67,
    101, 101, 113, 40, 65, 68, 105, 65, 98, 105, 127, 58, 80, 82, 109,
    105, 111, 127, 131, 45, 70, 121, 123, 70, 100, 123, 128, 69, 83, 122,
    124, 106, 112, 128, 132, 58, 105, 82, 127, 80, 111, 109, 131, 78,
    109, 90, 129, 109, 116, 129, 133, 69, 106, 122, 128, 83, 112, 124,
    132, 97, 110, 126, 130, 110, 117, 130, 134, 17, 57, 75, 108, 27, 66,
    80, 109, 57, 76, 108, 114, 70, 100, 111, 116, 21, 59, 82, 109, 28,
    67, 83, 110, 59, 79, 109, 115, 71, 101, 112, 117, 27, 70, 80, 111,
    29, 72, 81, 112, 66, 100, 109, 116, 72, 102, 112, 118, 28, 71, 83,
    112, 30, 73, 84, 113, 67, 101, 110, 117, 73, 103, 113, 119, 42, 66,
    96, 109, 66, 99, 109, 129, 66, 81, 109, 115, 106, 112, 131, 133, 46,
    71, 122, 124, 71, 101, 124, 130, 71, 84, 124, 125, 107, 113, 132,
    134, 66, 106, 109, 131, 81, 112, 115, 133, 99, 112, 129, 133, 112,
    118, 133, 135, 71, 107, 124, 132, 84, 113, 125, 134, 101, 113, 130,
    134, 113, 119, 134, 136, 4, 7, 13, 16, 13, 16, 17, 21, 7, 9, 16, 18,
    20, 21, 27, 28, 7, 9, 20, 21, 16, 18, 27, 28, 9, 10, 21, 22, 21, 22,
    29, 30, 13, 20, 17, 27, 17, 27, 23, 29, 16, 21, 21, 28, 27, 29, 29,
    31, 16, 21, 27, 29, 21, 28, 29, 31, 18, 22, 28, 30, 28, 30, 31, 32,
    13, 16, 39, 41, 52, 53, 57, 59, 16, 18, 41, 43, 58, 59, 66, 67, 20,
    21, 45, 46, 58, 59, 70, 71, 21, 22, 46, 47, 60, 61, 72, 73, 52, 58,
    57, 66, 75, 80, 76, 81, 53, 59, 59, 67, 80, 81, 81, 85, 58, 60, 70,
    72, 82, 83, 86, 87, 59, 61, 71, 73, 83, 84, 87, 88, 13, 16, 52, 53,
    39, 41, 57, 59, 20, 21, 58, 59, 45, 46, 70, 71, 16, 18, 58, 59, 41,
    43, 66, 67, 21, 22, 60, 61, 46, 47, 72, 73, 52, 58, 75, 80, 57, 66,
    76, 81, 58, 60, 82, 83, 70, 72, 86, 87, 53, 59, 80, 81, 59, 67, 81,
    85, 59, 61, 83, 84, 71, 73, 87, 88, 17, 21, 57, 59, 57, 59, 76, 79,
    27, 28, 66, 67, 70, 71, 100, 101, 27, 28, 70, 71, 66, 67, 100, 101,
    29, 30, 72, 73, 72, 73, 102, 103, 75, 82, 108, 109, 108, 109, 114,
    115, 80, 83, 109, 110, 111, 112, 116, 117, 80, 83, 111, 112, 109,
    110, 116, 117, 81, 84, 112, 113, 112, 113, 118, 119, 35, 54, 40, 58,
    40, 58, 48, 60, 54, 77, 58, 78, 68, 82, 70, 83, 54, 77, 68, 82, 58,
    78, 70, 83, 77, 89, 82, 90, 82, 90, 86, 91, 40, 68, 48, 70, 48, 70,
    62, 72, 58, 82, 60, 83, 70, 86, 72, 87, 58, 82, 70, 86, 60, 83, 72,
    87, 78, 90, 83, 91, 83, 91, 87, 92, 40, 58, 45, 69, 65, 80, 70, 83,
    58, 78, 69, 97, 105, 109, 106, 110, 68, 82, 121, 122, 105, 109, 123,
    124, 82, 90, 122, 126, 127, 129, 128, 130, 65, 105, 70, 106, 98, 111,
    100, 112, 80, 109, 83, 110, 111, 116, 112, 117, 105, 127, 123, 128,
    127, 131, 128, 132, 109, 129, 124, 130, 131, 133, 132, 134, 40, 58,
    65, 80, 45, 69, 70, 83, 68, 82, 105, 109, 121, 122, 123, 124, 58, 78,
    105, 109, 69, 97, 106, 110, 82, 90, 127, 129, 122, 126, 128, 130, 65,
    105, 98, 111, 70, 106, 100, 112, 105, 127, 127, 131, 123, 128, 128,
    132, 80, 109, 111, 116, 83, 110, 112, 117, 109, 129, 131, 133, 124,
    130, 132, 134, 48, 60, 70, 83, 70, 83, 86, 91, 70, 83, 106, 110, 123,
    124, 128, 130, 70, 83, 123, 124, 106, 110, 128, 130, 86, 91, 128,
    130, 128, 130, 141, 142, 98, 127, 111, 131, 111, 131, 116, 133, 111,
    131, 131, 143, 144, 145, 145, 146, 111, 131, 144, 145, 131, 143, 145,
    146, 116, 133, 145, 146, 145, 146, 147, 148, 13, 20, 52, 58, 52, 58,
    75, 82, 16, 21, 53, 59, 58, 60, 80, 83, 16, 21, 58, 60, 53, 59, 80,
    83, 18, 22, 59, 61, 59, 61, 81, 84, 39, 45, 57, 70, 57, 70, 76, 86,
    41, 46, 59, 71, 66, 72, 81, 87, 41, 46, 66, 72, 59, 71, 81, 87, 43,
    47, 67, 73, 67, 73, 85, 88, 17, 27, 57, 66, 75, 80, 108, 109, 21, 28,
    59, 67, 82, 83, 109, 110, 27, 29, 70, 72, 80, 81, 111, 112, 28, 30,
    71, 73, 83, 84, 112, 113, 57, 70, 76, 100, 108, 111, 114, 116, 59,
    71, 79, 101, 109, 112, 115, 117, 66, 72, 100, 102, 109, 112, 116,
    118, 67, 73, 101, 103, 110, 113, 117, 119, 17, 27, 75, 80, 57, 66,
    108, 109, 27, 29, 80, 81, 70, 72, 111, 112, 21, 28, 82, 83, 59, 67,
    109, 110, 28, 30, 83, 84, 71, 73, 112, 113, 57, 70, 108, 111, 76,
    100, 114, 116, 66, 72, 109, 112, 100, 102, 116, 118, 59, 71, 109,
    112, 79, 101, 115, 117, 67, 73, 110, 113, 101, 103, 117, 119, 23, 29,
    76, 81, 76, 81, 114, 115, 29, 31, 81, 85, 86, 87, 116, 117, 29, 31,
    86, 87, 81, 85, 116, 117, 31, 32, 87, 88, 87, 88, 118, 119, 76, 86,
    114, 116, 114, 116, 137, 138, 81, 87, 115, 117, 116, 118, 138, 139,
    81, 87, 116, 118, 115, 117, 138, 139, 85, 88, 117, 119, 117, 119,
    139, 140, 40, 68, 65, 105, 65, 105, 98, 127, 58, 82, 80, 109, 105,
    127, 111, 131, 58, 82, 105, 127, 80, 109, 111, 131, 78, 90, 109, 129,
    109, 129, 116, 133, 45, 121, 70, 123, 70, 123, 100, 128, 69, 122, 83,
    124, 106, 128, 112, 132, 69, 122, 106, 128, 83, 124, 112, 132, 97,
    126, 110, 130, 110, 130, 117, 134, 48, 70, 70, 106, 98, 111, 111,
    131, 60, 83, 83, 110, 127, 131, 131, 143, 70, 86, 123, 128, 111, 116,
    144, 145, 83, 91, 124, 130, 131, 133, 145, 146, 70, 123, 86, 128,
    111, 144, 116, 145, 83, 124, 91, 130, 131, 145, 133, 146, 106, 128,
    128, 141, 131, 145, 145, 147, 110, 130, 130, 142, 143, 146, 146, 148,
    48, 70, 98, 111, 70, 106, 111, 131, 70, 86, 111, 116, 123, 128, 144,
    145, 60, 83, 127, 131, 83, 110, 131, 143, 83, 91, 131, 133, 124, 130,
    145, 146, 70, 123, 111, 144, 86, 128, 116, 145, 106, 128, 131, 145,
    128, 141, 145, 147, 83, 124, 131, 145, 91, 130, 133, 146, 110, 130,
    143, 146, 130, 142, 146, 148, 62, 72, 100, 112, 100, 112, 116, 133,
    72, 87, 112, 117, 128, 132, 145, 146, 72, 87, 128, 132, 112, 117,
    145, 146, 87, 92, 132, 134, 132, 134, 147, 148, 100, 128, 116, 145,
    116, 145, 138, 149, 112, 132, 133, 146, 145, 147, 149, 150, 112, 132,
    145, 147, 133, 146, 149, 150, 117, 134, 146, 148, 146, 148, 150, 151,
    2, 12, 6, 15, 6, 15, 13, 20, 6, 15, 8, 17, 15, 26, 17, 27, 6, 15, 15,
    26, 8, 17, 17, 27, 13, 20, 17, 27, 17, 27, 23, 29, 3, 19, 7, 20, 7,
    20, 14, 25, 7, 20, 9, 21, 16, 27, 18, 28, 7, 20, 16, 27, 9, 21, 18,
    28, 14, 25, 18, 28, 18, 28, 24, 30, 12, 38, 15, 40, 51, 56, 52, 58,
    15, 40, 17, 42, 56, 65, 57, 66, 51, 56, 56, 65, 74, 75, 75, 80, 52,
    58, 57, 66, 75, 80, 76, 81, 19, 44, 20, 45, 54, 68, 55, 69, 20, 45,
    21, 46, 58, 70, 59, 71, 54, 68, 58, 70, 77, 82, 78, 83, 55, 69, 59,
    71, 78, 83, 79, 84, 12, 38, 51, 56, 15, 40, 52, 58, 51, 56, 74, 75,
    56, 65, 75, 80, 15, 40, 56, 65, 17, 42, 57, 66, 52, 58, 75, 80, 57,
    66, 76, 81, 19, 44, 54, 68, 20, 45, 55, 69, 54, 68, 77, 82, 58, 70,
    78, 83, 20, 45, 58, 70, 21, 46, 59, 71, 55, 69, 78, 83, 59, 71, 79,
    84, 38, 44, 56, 68, 56, 68, 75, 82, 56, 68, 75, 96, 104, 105, 108,
    109, 56, 68, 104, 105, 75, 96, 108, 109, 75, 82, 108, 109, 108, 109,
    114, 115, 44, 120, 68, 121, 68, 121, 96, 122, 68, 121, 82, 122, 105,
    123, 109, 124, 68, 121, 105, 123, 82, 122, 109, 124, 96, 122, 109,
    124, 109, 124, 115, 125, 6, 51, 13, 52, 13, 52, 36, 55, 15, 56, 17,
    57, 40, 65, 42, 66, 15, 56, 40, 65, 17, 57, 42, 66, 40, 68, 48, 70,
    48, 70, 62, 72, 7, 54, 14, 55, 14, 55, 37, 64, 16, 58, 18, 59, 41,
    66, 43, 67, 16, 58, 41, 66, 18, 59, 43, 67, 41, 69, 49, 71, 49, 71,
    63, 73, 15, 56, 20, 58, 52, 75, 55, 78, 26, 65, 27, 66, 65, 98, 66,
    99, 56, 104, 68, 105, 75, 108, 96, 109, 65, 105, 70, 106, 98, 111,
    100, 112, 20, 68, 25, 69, 55, 96, 64, 97, 27, 70, 28, 71, 66, 100,
    67, 101, 58, 105, 69, 106, 78, 109, 97, 110, 66, 106, 71, 107, 99,
    112, 101, 113, 15, 56, 52, 75, 20, 58, 55, 78, 56, 104, 75, 108, 68,
    105, 96, 109, 26, 65, 65, 98, 27, 66, 66, 99, 65, 105, 98, 111, 70,
    106, 100, 112, 20, 68, 55, 96, 25, 69, 64, 97, 58, 105, 78, 109, 69,
    106, 97, 110, 27, 70, 66, 100, 28, 71, 67, 101, 66, 106, 99, 112, 71,
    107, 101, 113, 40, 68, 58, 82, 58, 82, 78, 90, 65, 105, 80, 109, 105,
    127, 109, 129, 65, 105, 105, 127, 80, 109, 109, 129, 98, 127, 111,
    131, 111, 131, 116, 133, 45, 121, 69, 122, 69, 122, 97, 126, 70, 123,
    83, 124, 106, 128, 110, 130, 70, 123, 106, 128, 83, 124, 110, 130,
    100, 128, 112, 132, 112, 132, 117, 134, 6, 51, 15, 56, 15, 56, 40,
    68, 13, 52, 17, 57, 40, 65, 48, 70, 13, 52, 40, 65, 17, 57, 48, 70,
    36, 55, 42, 66, 42, 66, 62, 72, 7, 54, 16, 58, 16, 58, 41, 69, 14,
    55, 18, 59, 41, 66, 49, 71, 14, 55, 41, 66, 18, 59, 49, 71, 37, 64,
    43, 67, 43, 67, 63, 73, 15, 56, 26, 65, 56, 104, 65, 105, 20, 58, 27,
    66, 68, 105, 70, 106, 52, 75, 65, 98, 75, 108, 98, 111, 55, 78, 66,
    99, 96, 109, 100, 112, 20, 68, 27, 70, 58, 105, 66, 106, 25, 69, 28,
    71, 69, 106, 71, 107, 55, 96, 66, 100, 78, 109, 99, 112, 64, 97, 67,
    101, 97, 110, 101, 113, 15, 56, 56, 104, 26, 65, 65, 105, 52, 75, 75,
    108, 65, 98, 98, 111, 20, 58, 68, 105, 27, 66, 70, 106, 55, 78, 96,
    109, 66, 99, 100, 112, 20, 68, 58, 105, 27, 70, 66, 106, 55, 96, 78,
    109, 66, 100, 99, 112, 25, 69, 69, 106, 28, 71, 71, 107, 64, 97, 97,
    110, 67, 101, 101, 113, 40, 68, 65, 105, 65, 105, 98, 127, 58, 82,
    80, 109, 105, 127, 111, 131, 58, 82, 105, 127, 80, 109, 111, 131, 78,
    90, 109, 129, 109, 129, 116, 133, 45, 121, 70, 123, 70, 123, 100,
    128, 69, 122, 83, 124, 106, 128, 112, 132, 69, 122, 106, 128, 83,
    124, 112, 132, 97, 126, 110, 130, 110, 130, 117, 134, 8, 74, 17, 75,
    17, 75, 42, 96, 17, 75, 23, 76, 48, 98, 62, 100, 17, 75, 48, 98, 23,
    76, 62, 100, 42, 96, 62, 100, 62, 100, 94, 102, 9, 77, 18, 78, 18,
    78, 43, 97, 18, 78, 24, 79, 49, 99, 63, 101, 18, 78, 49, 99, 24, 79,
    63, 101, 43, 97, 63, 101, 63, 101, 95, 103, 17, 75, 27, 80, 57, 108,
    66, 109, 27, 80, 29, 81, 70, 111, 72, 112, 57, 108, 70, 111, 76, 114,
    100, 116, 66, 109, 72, 112, 100, 116, 102, 118, 21, 82, 28, 83, 59,
    109, 67, 110, 28, 83, 30, 84, 71, 112, 73, 113, 59, 109, 71, 112, 79,
    115, 101, 117, 67, 110, 73, 113, 101, 117, 103, 119, 17, 75, 57, 108,
    27, 80, 66, 109, 57, 108, 76, 114, 70, 111, 100, 116, 27, 80, 70,
    111, 29, 81, 72, 112, 66, 109, 100, 116, 72, 112, 102, 118, 21, 82,
    59, 109, 28, 83, 67, 110, 59, 109, 79, 115, 71, 112, 101, 117, 28,
    83, 71, 112, 30, 84, 73, 113, 67, 110, 101, 117, 73, 113, 103, 119,
    42, 96, 66, 109, 66, 109, 99, 129, 66, 109, 81, 115, 106, 131, 112,
    133, 66, 109, 106, 131, 81, 115, 112, 133, 99, 129, 112, 133, 112,
    133, 118, 135, 46, 122, 71, 124, 71, 124, 101, 130, 71, 124, 84, 125,
    107, 132, 113, 134, 71, 124, 107, 132, 84, 125, 113, 134, 101, 130,
    113, 134, 113, 134, 119, 136, 4, 13, 7, 16, 13, 17, 16, 21, 7, 16, 9,
    18, 20, 27, 21, 28, 13, 17, 20, 27, 17, 23, 27, 29, 16, 21, 21, 28,
    27, 29, 29, 31, 7, 20, 9, 21, 16, 27, 18, 28, 9, 21, 10, 22, 21, 29,
    22, 30, 16, 27, 21, 29, 21, 29, 28, 31, 18, 28, 22, 30, 28, 31, 30,
    32, 13, 39, 16, 41, 52, 57, 53, 59, 16, 41, 18, 43, 58, 66, 59, 67,
    52, 57, 58, 66, 75, 76, 80, 81, 53, 59, 59, 67, 80, 81, 81, 85, 20,
    45, 21, 46, 58, 70, 59, 71, 21, 46, 22, 47, 60, 72, 61, 73, 58, 70,
    60, 72, 82, 86, 83, 87, 59, 71, 61, 73, 83, 87, 84, 88, 35, 40, 54,
    58, 40, 48, 58, 60, 54, 58, 77, 78, 68, 70, 82, 83, 40, 48, 68, 70,
    48, 62, 70, 72, 58, 60, 82, 83, 70, 72, 86, 87, 54, 68, 77, 82, 58,
    70, 78, 83, 77, 82, 89, 90, 82, 86, 90, 91, 58, 70, 82, 86, 60, 72,
    83, 87, 78, 83, 90, 91, 83, 87, 91, 92, 40, 45, 58, 69, 65, 70, 80,
    83, 58, 69, 78, 97, 105, 106, 109, 110, 65, 70, 105, 106, 98, 100,
    111, 112, 80, 83, 109, 110, 111, 112, 116, 117, 68, 121, 82, 122,
    105, 123, 109, 124, 82, 122, 90, 126, 127, 128, 129, 130, 105, 123,
    127, 128, 127, 128, 131, 132, 109, 124, 129, 130, 131, 132, 133, 134,
    13, 52, 16, 53, 39, 57, 41, 59, 20, 58, 21, 59, 45, 70, 46, 71, 52,
    75, 58, 80, 57, 76, 66, 81, 58, 82, 60, 83, 70, 86, 72, 87, 16, 58,
    18, 59, 41, 66, 43, 67, 21, 60, 22, 61, 46, 72, 47, 73, 53, 80, 59,
    81, 59, 81, 67, 85, 59, 83, 61, 84, 71, 87, 73, 88, 17, 57, 21, 59,
    57, 76, 59, 79, 27, 66, 28, 67, 70, 100, 71, 101, 75, 108, 82, 109,
    108, 114, 109, 115, 80, 109, 83, 110, 111, 116, 112, 117, 27, 70, 28,
    71, 66, 100, 67, 101, 29, 72, 30, 73, 72, 102, 73, 103, 80, 111, 83,
    112, 109, 116, 110, 117, 81, 112, 84, 113, 112, 118, 113, 119, 40,
    65, 58, 80, 45, 70, 69, 83, 68, 105, 82, 109, 121, 123, 122, 124, 65,
    98, 105, 111, 70, 100, 106, 112, 105, 127, 127, 131, 123, 128, 128,
    132, 58, 105, 78, 109, 69, 106, 97, 110, 82, 127, 90, 129, 122, 128,
    126, 130, 80, 111, 109, 116, 83, 112, 110, 117, 109, 131, 129, 133,
    124, 132, 130, 134, 48, 70, 60, 83, 70, 86, 83, 91, 70, 106, 83, 110,
    123, 128, 124, 130, 98, 111, 127, 131, 111, 116, 131, 133, 111, 131,
    131, 143, 144, 145, 145, 146, 70, 123, 83, 124, 106, 128, 110, 130,
    86, 128, 91, 130, 128, 141, 130, 142, 111, 144, 131, 145, 131, 145,
    143, 146, 116, 145, 133, 146, 145, 147, 146, 148, 13, 52, 20, 58, 52,
    75, 58, 82, 16, 53, 21, 59, 58, 80, 60, 83, 39, 57, 45, 70, 57, 76,
    70, 86, 41, 59, 46, 71, 66, 81, 72, 87, 16, 58, 21, 60, 53, 80, 59,
    83, 18, 59, 22, 61, 59, 81, 61, 84, 41, 66, 46, 72, 59, 81, 71, 87,
    43, 67, 47, 73, 67, 85, 73, 88, 17, 57, 27, 66, 75, 108, 80, 109, 21,
    59, 28, 67, 82, 109, 83, 110, 57, 76, 70, 100, 108, 114, 111, 116,
    59, 79, 71, 101, 109, 115, 112, 117, 27, 70, 29, 72, 80, 111, 81,
    112, 28, 71, 30, 73, 83, 112, 84, 113, 66, 100, 72, 102, 109, 116,
    112, 118, 67, 101, 73, 103, 110, 117, 113, 119, 40, 65, 68, 105, 65,
    98, 105, 127, 58, 80, 82, 109, 105, 111, 127, 131, 45, 70, 121, 123,
    70, 100, 123, 128, 69, 83, 122, 124, 106, 112, 128, 132, 58, 105, 82,
    127, 80, 111, 109, 131, 78, 109, 90, 129, 109, 116, 129, 133, 69,
    106, 122, 128, 83, 112, 124, 132, 97, 110, 126, 130, 110, 117, 130,
    134, 48, 70, 70, 106, 98, 111, 111, 131, 60, 83, 83, 110, 127, 131,
    131, 143, 70, 86, 123, 128, 111, 116, 144, 145, 83, 91, 124, 130,
    131, 133, 145, 146, 70, 123, 86, 128, 111, 144, 116, 145, 83, 124,
    91, 130, 131, 145, 133, 146, 106, 128, 128, 141, 131, 145, 145, 147,
    110, 130, 130, 142, 143, 146, 146, 148, 17, 75, 27, 80, 57, 108, 66,
    109, 27, 80, 29, 81, 70, 111, 72, 112, 57, 108, 70, 111, 76, 114,
    100, 116, 66, 109, 72, 112, 100, 116, 102, 118, 21, 82, 28, 83, 59,
    109, 67, 110, 28, 83, 30, 84, 71, 112, 73, 113, 59, 109, 71, 112, 79,
    115, 101, 117, 67, 110, 73, 113, 101, 117, 103, 119, 23, 76, 29, 81,
    76, 114, 81, 115, 29, 81, 31, 85, 86, 116, 87, 117, 76, 114, 86, 116,
    114, 137, 116, 138, 81, 115, 87, 117, 116, 138, 118, 139, 29, 86, 31,
    87, 81, 116, 85, 117, 31, 87, 32, 88, 87, 118, 88, 119, 81, 116, 87,
    118, 115, 138, 117, 139, 85, 117, 88, 119, 117, 139, 119, 140, 48,
    98, 70, 111, 70, 111, 106, 131, 70, 111, 86, 116, 123, 144, 128, 145,
    70, 111, 123, 144, 86, 116, 128, 145, 106, 131, 128, 145, 128, 145,
    141, 147, 60, 127, 83, 131, 83, 131, 110, 143, 83, 131, 91, 133, 124,
    145, 130, 146, 83, 131, 124, 145, 91, 133, 130, 146, 110, 143, 130,
    146, 130, 146, 142, 148, 62, 100, 72, 112, 100, 116, 112, 133, 72,
    112, 87, 117, 128, 145, 132, 146, 100, 116, 128, 145, 116, 138, 145,
    149, 112, 133, 132, 146, 145, 149, 147, 150, 72, 128, 87, 132, 112,
    145, 117, 146, 87, 132, 92, 134, 132, 147, 134, 148, 112, 145, 132,
    147, 133, 149, 146, 150, 117, 146, 134, 148, 146, 150, 148, 151, 4,
    13, 13, 17, 7, 16, 16, 21, 13, 17, 17, 23, 20, 27, 27, 29, 7, 16, 20,
    27, 9, 18, 21, 28, 16, 21, 27, 29, 21, 28, 29, 31, 7, 20, 16, 27, 9,
    21, 18, 28, 16, 27, 21, 29, 21, 29, 28, 31, 9, 21, 21, 29, 10, 22,
    22, 30, 18, 28, 28, 31, 22, 30, 30, 32, 35, 40, 40, 48, 54, 58, 58,
    60, 40, 48, 48, 62, 68, 70, 70, 72, 54, 58, 68, 70, 77, 78, 82, 83,
    58, 60, 70, 72, 82, 83, 86, 87, 54, 68, 58, 70, 77, 82, 78, 83, 58,
    70, 60, 72, 82, 86, 83, 87, 77, 82, 82, 86, 89, 90, 90, 91, 78, 83,
    83, 87, 90, 91, 91, 92, 13, 39, 52, 57, 16, 41, 53, 59, 52, 57, 75,
    76, 58, 66, 80, 81, 16, 41, 58, 66, 18, 43, 59, 67, 53, 59, 80, 81,
    59, 67, 81, 85, 20, 45, 58, 70, 21, 46, 59, 71, 58, 70, 82, 86, 60,
    72, 83, 87, 21, 46, 60, 72, 22, 47, 61, 73, 59, 71, 83, 87, 61, 73,
    84, 88, 40, 45, 65, 70, 58, 69, 80, 83, 65, 70, 98, 100, 105, 106,
    111, 112, 58, 69, 105, 106, 78, 97, 109, 110, 80, 83, 111, 112, 109,
    110, 116, 117, 68, 121, 105, 123, 82, 122, 109, 124, 105, 123, 127,
    128, 127, 128, 131, 132, 82, 122, 127, 128, 90, 126, 129, 130, 109,
    124, 131, 132, 129, 130, 133, 134, 13, 52, 39, 57, 16, 53, 41, 59,
    52, 75, 57, 76, 58, 80, 66, 81, 20, 58, 45, 70, 21, 59, 46, 71, 58,
    82, 70, 86, 60, 83, 72, 87, 16, 58, 41, 66, 18, 59, 43, 67, 53, 80,
    59, 81, 59, 81, 67, 85, 21, 60, 46, 72, 22, 61, 47, 73, 59, 83, 71,
    87, 61, 84, 73, 88, 40, 65, 45, 70, 58, 80, 69, 83, 65, 98, 70, 100,
    105, 111, 106, 112, 68, 105, 121, 123, 82, 109, 122, 124, 105, 127,
    123, 128, 127, 131, 128, 132, 58, 105, 69, 106, 78, 109, 97, 110, 80,
    111, 83, 112, 109, 116, 110, 117, 82, 127, 122, 128, 90, 129, 126,
    130, 109, 131, 124, 132, 129, 133, 130, 134, 17, 57, 57, 76, 21, 59,
    59, 79, 75, 108, 108, 114, 82, 109, 109, 115, 27, 66, 70, 100, 28,
    67, 71, 101, 80, 109, 111, 116, 83, 110, 112, 117, 27, 70, 66, 100,
    28, 71, 67, 101, 80, 111, 109, 116, 83, 112, 110, 117, 29, 72, 72,
    102, 30, 73, 73, 103, 81, 112, 112, 118, 84, 113, 113, 119, 48, 70,
    70, 86, 60, 83, 83, 91, 98, 111, 111, 116, 127, 131, 131, 133, 70,
    106, 123, 128, 83, 110, 124, 130, 111, 131, 144, 145, 131, 143, 145,
    146, 70, 123, 106, 128, 83, 124, 110, 130, 111, 144, 131, 145, 131,
    145, 143, 146, 86, 128, 128, 141, 91, 130, 130, 142, 116, 145, 145,
    147, 133, 146, 146, 148, 13, 52, 52, 75, 20, 58, 58, 82, 39, 57, 57,
    76, 45, 70, 70, 86, 16, 53, 58, 80, 21, 59, 60, 83, 41, 59, 66, 81,
    46, 71, 72, 87, 16, 58, 53, 80, 21, 60, 59, 83, 41, 66, 59, 81, 46,
    72, 71, 87, 18, 59, 59, 81, 22, 61, 61, 84, 43, 67, 67, 85, 47, 73,
    73, 88, 40, 65, 65, 98, 68, 105, 105, 127, 45, 70, 70, 100, 121, 123,
    123, 128, 58, 80, 105, 111, 82, 109, 127, 131, 69, 83, 106, 112, 122,
    124, 128, 132, 58, 105, 80, 111, 82, 127, 109, 131, 69, 106, 83, 112,
    122, 128, 124, 132, 78, 109, 109, 116, 90, 129, 129, 133, 97, 110,
    110, 117, 126, 130, 130, 134, 17, 57, 75, 108, 27, 66, 80, 109, 57,
    76, 108, 114, 70, 100, 111, 116, 21, 59, 82, 109, 28, 67, 83, 110,
    59, 79, 109, 115, 71, 101, 112, 117, 27, 70, 80, 111, 29, 72, 81,
    112, 66, 100, 109, 116, 72, 102, 112, 118, 28, 71, 83, 112, 30, 73,
    84, 113, 67, 101, 110, 117, 73, 103, 113, 119, 48, 70, 98, 111, 70,
    106, 111, 131, 70, 86, 111, 116, 123, 128, 144, 145, 60, 83, 127,
    131, 83, 110, 131, 143, 83, 91, 131, 133, 124, 130, 145, 146, 70,
    123, 111, 144, 86, 128, 116, 145, 106, 128, 131, 145, 128, 141, 145,
    147, 83, 124, 131, 145, 91, 130, 133, 146, 110, 130, 143, 146, 130,
    142, 146, 148, 17, 75, 57, 108, 27, 80, 66, 109, 57, 108, 76, 114,
    70, 111, 100, 116, 27, 80, 70, 111, 29, 81, 72, 112, 66, 109, 100,
    116, 72, 112, 102, 118, 21, 82, 59, 109, 28, 83, 67, 110, 59, 109,
    79, 115, 71, 112, 101, 117, 28, 83, 71, 112, 30, 84, 73, 113, 67,
    110, 101, 117, 73, 113, 103, 119, 48, 98, 70, 111, 70, 111, 106, 131,
    70, 111, 86, 116, 123, 144, 128, 145, 70, 111, 123, 144, 86, 116,
    128, 145, 106, 131, 128, 145, 128, 145, 141, 147, 60, 127, 83, 131,
    83, 131, 110, 143, 83, 131, 91, 133, 124, 145, 130, 146, 83, 131,
    124, 145, 91, 133, 130, 146, 110, 143, 130, 146, 130, 146, 142, 148,
    23, 76, 76, 114, 29, 81, 81, 115, 76, 114, 114, 137, 86, 116, 116,
    138, 29, 81, 86, 116, 31, 85, 87, 117, 81, 115, 116, 138, 87, 117,
    118, 139, 29, 86, 81, 116, 31, 87, 85, 117, 81, 116, 115, 138, 87,
    118, 117, 139, 31, 87, 87, 118, 32, 88, 88, 119, 85, 117, 117, 139,
    88, 119, 119, 140, 62, 100, 100, 116, 72, 112, 112, 133, 100, 116,
    116, 138, 128, 145, 145, 149, 72, 112, 128, 145, 87, 117, 132, 146,
    112, 133, 145, 149, 132, 146, 147, 150, 72, 128, 112, 145, 87, 132,
    117, 146, 112, 145, 133, 149, 132, 147, 146, 150, 87, 132, 132, 147,
    92, 134, 134, 148, 117, 146, 146, 150, 134, 148, 148, 151, 11, 14,
    14, 18, 14, 18, 18, 22, 14, 18, 18, 24, 25, 28, 28, 30, 14, 18, 25,
    28, 18, 24, 28, 30, 18, 22, 28, 30, 28, 30, 31, 32, 14, 25, 18, 28,
    18, 28, 24, 30, 18, 28, 22, 30, 28, 31, 30, 32, 18, 28, 28, 31, 22,
    30, 30, 32, 24, 30, 30, 32, 30, 32, 32, 33, 36, 41, 41, 49, 55, 59,
    59, 61, 41, 49, 49, 63, 69, 71, 71, 73, 55, 59, 69, 71, 78, 79, 83,
    84, 59, 61, 71, 73, 83, 84, 87, 88, 55, 69, 59, 71, 78, 83, 79, 84,
    59, 71, 61, 73, 83, 87, 84, 88, 78, 83, 83, 87, 90, 91, 91, 92, 79,
    84, 84, 88, 91, 92, 92, 93, 36, 41, 55, 59, 41, 49, 59, 61, 55, 59,
    78, 79, 69, 71, 83, 84, 41, 49, 69, 71, 49, 63, 71, 73, 59, 61, 83,
    84, 71, 73, 87, 88, 55, 69, 78, 83, 59, 71, 79, 84, 78, 83, 90, 91,
    83, 87, 91, 92, 59, 71, 83, 87, 61, 73, 84, 88, 79, 84, 91, 92, 84,
    88, 92, 93, 42, 46, 66, 71, 66, 71, 81, 84, 66, 71, 99, 101, 106,
    107, 112, 113, 66, 71, 106, 107, 99, 101, 112, 113, 81, 84, 112, 113,
    112, 113, 118, 119, 96, 122, 109, 124, 109, 124, 115, 125, 109, 124,
    129, 130, 131, 132, 133, 134, 109, 124, 131, 132, 129, 130, 133, 134,
    115, 125, 133, 134, 133, 134, 135, 136, 36, 55, 41, 59, 41, 59, 49,
    61, 55, 78, 59, 79, 69, 83, 71, 84, 55, 78, 69, 83, 59, 79, 71, 84,
    78, 90, 83, 91, 83, 91, 87, 92, 41, 69, 49, 71, 49, 71, 63, 73, 59,
    83, 61, 84, 71, 87, 73, 88, 59, 83, 71, 87, 61, 84, 73, 88, 79, 91,
    84, 92, 84, 92, 88, 93, 42, 66, 46, 71, 66, 81, 71, 84, 66, 99, 71,
    101, 106, 112, 107, 113, 96, 109, 122, 124, 109, 115, 124, 125, 109,
    129, 124, 130, 131, 133, 132, 134, 66, 106, 71, 107, 99, 112, 101,
    113, 81, 112, 84, 113, 112, 118, 113, 119, 109, 131, 124, 132, 129,
    133, 130, 134, 115, 133, 125, 134, 133, 135, 134, 136, 42, 66, 66,
    81, 46, 71, 71, 84, 96, 109, 109, 115, 122, 124, 124, 125, 66, 99,
    106, 112, 71, 101, 107, 113, 109, 129, 131, 133, 124, 130, 132, 134,
    66, 106, 99, 112, 71, 107, 101, 113, 109, 131, 129, 133, 124, 132,
    130, 134, 81, 112, 112, 118, 84, 113, 113, 119, 115, 133, 133, 135,
    125, 134, 134, 136, 62, 72, 72, 87, 72, 87, 87, 92, 100, 112, 112,
    117, 128, 132, 132, 134, 100, 112, 128, 132, 112, 117, 132, 134, 116,
    133, 145, 146, 145, 146, 147, 148, 100, 128, 112, 132, 112, 132, 117,
    134, 116, 145, 133, 146, 145, 147, 146, 148, 116, 145, 145, 147, 133,
    146, 146, 148, 138, 149, 149, 150, 149, 150, 150, 151, 36, 55, 55,
    78, 55, 78, 78, 90, 41, 59, 59, 79, 69, 83, 83, 91, 41, 59, 69, 83,
    59, 79, 83, 91, 49, 61, 71, 84, 71, 84, 87, 92, 41, 69, 59, 83, 59,
    83, 79, 91, 49, 71, 61, 84, 71, 87, 84, 92, 49, 71, 71, 87, 61, 84,
    84, 92, 63, 73, 73, 88, 73, 88, 88, 93, 42, 66, 66, 99, 96, 109, 109,
    129, 46, 71, 71, 101, 122, 124, 124, 130, 66, 81, 106, 112, 109, 115,
    131, 133, 71, 84, 107, 113, 124, 125, 132, 134, 66, 106, 81, 112,
    109, 131, 115, 133, 71, 107, 84, 113, 124, 132, 125, 134, 99, 112,
    112, 118, 129, 133, 133, 135, 101, 113, 113, 119, 130, 134, 134, 136,
    42, 66, 96, 109, 66, 99, 109, 129, 66, 81, 109, 115, 106, 112, 131,
    133, 46, 71, 122, 124, 71, 101, 124, 130, 71, 84, 124, 125, 107, 113,
    132, 134, 66, 106, 109, 131, 81, 112, 115, 133, 99, 112, 129, 133,
    112, 118, 133, 135, 71, 107, 124, 132, 84, 113, 125, 134, 101, 113,
    130, 134, 113, 119, 134, 136, 62, 72, 100, 112, 100, 112, 116, 133,
    72, 87, 112, 117, 128, 132, 145, 146, 72, 87, 128, 132, 112, 117,
    145, 146, 87, 92, 132, 134, 132, 134, 147, 148, 100, 128, 116, 145,
    116, 145, 138, 149, 112, 132, 133, 146, 145, 147, 149, 150, 112, 132,
    145, 147, 133, 146, 149, 150, 117, 134, 146, 148, 146, 148, 150, 151,
    42, 96, 66, 109, 66, 109, 99, 129, 66, 109, 81, 115, 106, 131, 112,
    133, 66, 109, 106, 131, 81, 115, 112, 133, 99, 129, 112, 133, 112,
    133, 118, 135, 46, 122, 71, 124, 71, 124, 101, 130, 71, 124, 84, 125,
    107, 132, 113, 134, 71, 124, 107, 132, 84, 125, 113, 134, 101, 130,
    113, 134, 113, 134, 119, 136, 62, 100, 72, 112, 100, 116, 112, 133,
    72, 112, 87, 117, 128, 145, 132, 146, 100, 116, 128, 145, 116, 138,
    145, 149, 112, 133, 132, 146, 145, 149, 147, 150, 72, 128, 87, 132,
    112, 145, 117, 146, 87, 132, 92, 134, 132, 147, 134, 148, 112, 145,
    132, 147, 133, 149, 146, 150, 117, 146, 134, 148, 146, 150, 148, 151,
    62, 100, 100, 116, 72, 112, 112, 133, 100, 116, 116, 138, 128, 145,
    145, 149, 72, 112, 128, 145, 87, 117, 132, 146, 112, 133, 145, 149,
    132, 146, 147, 150, 72, 128, 112, 145, 87, 132, 117, 146, 112, 145,
    133, 149, 132, 147, 146, 150, 87, 132, 132, 147, 92, 134, 134, 148,
    117, 146, 146, 150, 134, 148, 148, 151, 94, 102, 102, 118, 102, 118,
    118, 135, 102, 118, 118, 139, 141, 147, 147, 150, 102, 118, 141, 147,
    118, 139, 147, 150, 118, 135, 147, 150, 147, 150, 152, 153, 102, 141,
    118, 147, 118, 147, 139, 150, 118, 147, 135, 150, 147, 152, 150, 153,
    118, 147, 147, 152, 135, 150, 150, 153, 139, 150, 150, 153, 150, 153,
    153, 154, 1, 5, 5, 12, 5, 12, 12, 19, 5, 12, 12, 35, 50, 51, 51, 54,
    5, 12, 50, 51, 12, 35, 51, 54, 12, 19, 51, 54, 51, 54, 74, 77, 5, 50,
    12, 51, 12, 51, 35, 54, 12, 51, 19, 54, 51, 74, 54, 77, 12, 51, 51,
    74, 19, 54, 54, 77, 35, 54, 54, 77, 54, 77, 77, 89, 2, 6, 6, 13, 12,
    15, 15, 20, 6, 13, 13, 36, 51, 52, 52, 55, 12, 15, 51, 52, 38, 40,
    56, 58, 15, 20, 52, 55, 56, 58, 75, 78, 12, 51, 15, 52, 38, 56, 40,
    58, 15, 52, 20, 55, 56, 75, 58, 78, 38, 56, 56, 75, 44, 68, 68, 82,
    40, 58, 58, 78, 68, 82, 82, 90, 2, 6, 12, 15, 6, 13, 15, 20, 12, 15,
    38, 40, 51, 52, 56, 58, 6, 13, 51, 52, 13, 36, 52, 55, 15, 20, 56,
    58, 52, 55, 75, 78, 12, 51, 38, 56, 15, 52, 40, 58, 38, 56, 44, 68,
    56, 75, 68, 82, 15, 52, 56, 75, 20, 55, 58, 78, 40, 58, 68, 82, 58,
    78, 82, 90, 4, 7, 13, 16, 13, 16, 17, 21, 13, 16, 39, 41, 52, 53, 57,
    59, 13, 16, 52, 53, 39, 41, 57, 59, 17, 21, 57, 59, 57, 59, 76, 79,
    35, 54, 40, 58, 40, 58, 48, 60, 40, 58, 45, 69, 65, 80, 70, 83, 40,
    58, 65, 80, 45, 69, 70, 83, 48, 60, 70, 83, 70, 83, 86, 91, 2, 12, 6,
    15, 6, 15, 13, 20, 12, 38, 15, 40, 51, 56, 52, 58, 12, 38, 51, 56,
    15, 40, 52, 58, 38, 44, 56, 68, 56, 68, 75, 82, 6, 51, 13, 52, 13, 52,
      36, 55, 15, 56, 20, 58, 52, 75, 55, 78, 15, 56, 52, 75, 20, 58, 55,
    78, 40, 68, 58, 82, 58, 82, 78, 90, 4, 13, 7, 16, 13, 17, 16, 21, 13,
    39, 16, 41, 52, 57, 53, 59, 35, 40, 54, 58, 40, 48, 58, 60, 40, 45,
    58, 69, 65, 70, 80, 83, 13, 52, 16, 53, 39, 57, 41, 59, 17, 57, 21,
    59, 57, 76, 59, 79, 40, 65, 58, 80, 45, 70, 69, 83, 48, 70, 60, 83,
    70, 86, 83, 91, 4, 13, 13, 17, 7, 16, 16, 21, 35, 40, 40, 48, 54, 58,
    58, 60, 13, 39, 52, 57, 16, 41, 53, 59, 40, 45, 65, 70, 58, 69, 80,
    83, 13, 52, 39, 57, 16, 53, 41, 59, 40, 65, 45, 70, 58, 80, 69, 83,
    17, 57, 57, 76, 21, 59, 59, 79, 48, 70, 70, 86, 60, 83, 83, 91, 11,
    14, 14, 18, 14, 18, 18, 22, 36, 41, 41, 49, 55, 59, 59, 61, 36, 41,
    55, 59, 41, 49, 59, 61, 42, 46, 66, 71, 66, 71, 81, 84, 36, 55, 41,
    59, 41, 59, 49, 61, 42, 66, 46, 71, 66, 81, 71, 84, 42, 66, 66, 81,
    46, 71, 71, 84, 62, 72, 72, 87, 72, 87, 87, 92, 2, 12, 12, 38, 12,
    38, 38, 44, 6, 15, 15, 40, 51, 56, 56, 68, 6, 15, 51, 56, 15, 40, 56,
    68, 13, 20, 52, 58, 52, 58, 75, 82, 6, 51, 15, 56, 15, 56, 40, 68,
    13, 52, 20, 58, 52, 75, 58, 82, 13, 52, 52, 75, 20, 58, 58, 82, 36,
    55, 55, 78, 55, 78, 78, 90, 4, 13, 13, 39, 35, 40, 40, 45, 7, 16, 16,
    41, 54, 58, 58, 69, 13, 17, 52, 57, 40, 48, 65, 70, 16, 21, 53, 59,
    58, 60, 80, 83, 13, 52, 17, 57, 40, 65, 48, 70, 16, 53, 21, 59, 58,
    80, 60, 83, 39, 57, 57, 76, 45, 70, 70, 86, 41, 59, 59, 79, 69, 83,
    83, 91, 4, 13, 35, 40, 13, 39, 40, 45, 13, 17, 40, 48, 52, 57, 65,
    70, 7, 16, 54, 58, 16, 41, 58, 69, 16, 21, 58, 60, 53, 59, 80, 83,
    13, 52, 40, 65, 17, 57, 48, 70, 39, 57, 45, 70, 57, 76, 70, 86, 16,
    53, 58, 80, 21, 59, 60, 83, 41, 59, 69, 83, 59, 79, 83, 91, 11, 14,
    36, 41, 36, 41, 42, 46, 14, 18, 41, 49, 55, 59, 66, 71, 14, 18, 55,
    59, 41, 49, 66, 71, 18, 22, 59, 61, 59, 61, 81, 84, 36, 55, 42, 66,
    42, 66, 62, 72, 41, 59, 46, 71, 66, 81, 72, 87, 41, 59, 66, 81, 46,
    71, 72, 87, 49, 61, 71, 84, 71, 84, 87, 92, 4, 35, 13, 40, 13, 40,
    39, 45, 13, 40, 17, 48, 52, 65, 57, 70, 13, 40, 52, 65, 17, 48, 57,
    70, 39, 45, 57, 70, 57, 70, 76, 86, 7, 54, 16, 58, 16, 58, 41, 69,
    16, 58, 21, 60, 53, 80, 59, 83, 16, 58, 53, 80, 21, 60, 59, 83, 41,
    69, 59, 83, 59, 83, 79, 91, 11, 36, 14, 41, 36, 42, 41, 46, 14, 41,
    18, 49, 55, 66, 59, 71, 36, 42, 55, 66, 42, 62, 66, 72, 41, 46, 59,
    71, 66, 72, 81, 87, 14, 55, 18, 59, 41, 66, 49, 71, 18, 59, 22, 61,
    59, 81, 61, 84, 41, 66, 59, 81, 46, 72, 71, 87, 49, 71, 61, 84, 71,
    87, 84, 92, 11, 36, 36, 42, 14, 41, 41, 46, 36, 42, 42, 62, 55, 66,
    66, 72, 14, 41, 55, 66, 18, 49, 59, 71, 41, 46, 66, 72, 59, 71, 81,
    87, 14, 55, 41, 66, 18, 59, 49, 71, 41, 66, 46, 72, 59, 81, 71, 87,
    18, 59, 59, 81, 22, 61, 61, 84, 49, 71, 71, 87, 61, 84, 84, 92, 34,
    37, 37, 43, 37, 43, 43, 47, 37, 43, 43, 63, 64, 67, 67, 73, 37, 43,
    64, 67, 43, 63, 67, 73, 43, 47, 67, 73, 67, 73, 85, 88, 37, 64, 43,
    67, 43, 67, 63, 73, 43, 67, 47, 73, 67, 85, 73, 88, 43, 67, 67, 85,
    47, 73, 73, 88, 63, 73, 73, 88, 73, 88, 88, 93, 2, 6, 6, 13, 12, 15,
    15, 20, 6, 13, 13, 36, 51, 52, 52, 55, 12, 15, 51, 52, 38, 40, 56,
    58, 15, 20, 52, 55, 56, 58, 75, 78, 12, 51, 15, 52, 38, 56, 40, 58,
    15, 52, 20, 55, 56, 75, 58, 78, 38, 56, 56, 75, 44, 68, 68, 82, 40,
    58, 58, 78, 68, 82, 82, 90, 3, 7, 7, 14, 19, 20, 20, 25, 7, 14, 14,
    37, 54, 55, 55, 64, 19, 20, 54, 55, 44, 45, 68, 69, 20, 25, 55, 64,
    68, 69, 96, 97, 19, 54, 20, 55, 44, 68, 45, 69, 20, 55, 25, 64, 68,
    96, 69, 97, 44, 68, 68, 96, 120, 121, 121, 122, 45, 69, 69, 97, 121,
    122, 122, 126, 6, 8, 15, 17, 15, 17, 26, 27, 15, 17, 40, 42, 56, 57,
    65, 66, 15, 17, 56, 57, 40, 42, 65, 66, 26, 27, 65, 66, 65, 66, 98,
    99, 51, 74, 56, 75, 56, 75, 65, 80, 56, 75, 68, 96, 104, 108, 105,
    109, 56, 75, 104, 108, 68, 96, 105, 109, 65, 80, 105, 109, 105, 109,
    127, 129, 7, 9, 16, 18, 20, 21, 27, 28, 16, 18, 41, 43, 58, 59, 66,
    67, 20, 21, 58, 59, 45, 46, 70, 71, 27, 28, 66, 67, 70, 71, 100, 101,
    54, 77, 58, 78, 68, 82, 70, 83, 58, 78, 69, 97, 105, 109, 106, 110,
    68, 82, 105, 109, 121, 122, 123, 124, 70, 83, 106, 110, 123, 124,
    128, 130, 6, 15, 8, 17, 15, 26, 17, 27, 15, 40, 17, 42, 56, 65, 57,
    66, 51, 56, 74, 75, 56, 65, 75, 80, 56, 68, 75, 96, 104, 105, 108,
    109, 15, 56, 17, 57, 40, 65, 42, 66, 26, 65, 27, 66, 65, 98, 66, 99,
    56, 104, 75, 108, 68, 105, 96, 109, 65, 105, 80, 109, 105, 127, 109,
    129, 7, 16, 9, 18, 20, 27, 21, 28, 16, 41, 18, 43, 58, 66, 59, 67,
    54, 58, 77, 78, 68, 70, 82, 83, 58, 69, 78, 97, 105, 106, 109, 110,
    20, 58, 21, 59, 45, 70, 46, 71, 27, 66, 28, 67, 70, 100, 71, 101, 68,
    105, 82, 109, 121, 123, 122, 124, 70, 106, 83, 110, 123, 128, 124,
    130, 13, 17, 17, 23, 20, 27, 27, 29, 40, 48, 48, 62, 68, 70, 70, 72,
    52, 57, 75, 76, 58, 66, 80, 81, 65, 70, 98, 100, 105, 106, 111, 112,
    52, 75, 57, 76, 58, 80, 66, 81, 65, 98, 70, 100, 105, 111, 106, 112,
    75, 108, 108, 114, 82, 109, 109, 115, 98, 111, 111, 116, 127, 131,
    131, 133, 14, 18, 18, 24, 25, 28, 28, 30, 41, 49, 49, 63, 69, 71, 71,
    73, 55, 59, 78, 79, 69, 71, 83, 84, 66, 71, 99, 101, 106, 107, 112,
    113, 55, 78, 59, 79, 69, 83, 71, 84, 66, 99, 71, 101, 106, 112, 107,
    113, 96, 109, 109, 115, 122, 124, 124, 125, 100, 112, 112, 117, 128,
    132, 132, 134, 6, 15, 15, 40, 51, 56, 56, 68, 8, 17, 17, 42, 74, 75,
    75, 96, 15, 26, 56, 65, 56, 65, 104, 105, 17, 27, 57, 66, 75, 80,
    108, 109, 15, 56, 26, 65, 56, 104, 65, 105, 17, 57, 27, 66, 75, 108,
    80, 109, 40, 65, 65, 98, 68, 105, 105, 127, 42, 66, 66, 99, 96, 109,
    109, 129, 7, 16, 16, 41, 54, 58, 58, 69, 9, 18, 18, 43, 77, 78, 78,
    97, 20, 27, 58, 66, 68, 70, 105, 106, 21, 28, 59, 67, 82, 83, 109,
    110, 20, 58, 27, 66, 68, 105, 70, 106, 21, 59, 28, 67, 82, 109, 83,
    110, 45, 70, 70, 100, 121, 123, 123, 128, 46, 71, 71, 101, 122, 124,
    124, 130, 13, 17, 40, 48, 52, 57, 65, 70, 17, 23, 48, 62, 75, 76, 98,
    100, 20, 27, 68, 70, 58, 66, 105, 106, 27, 29, 70, 72, 80, 81, 111,
    112, 52, 75, 65, 98, 75, 108, 98, 111, 57, 76, 70, 100, 108, 114,
    111, 116, 58, 80, 105, 111, 82, 109, 127, 131, 66, 81, 106, 112, 109,
    115, 131, 133, 14, 18, 41, 49, 55, 59, 66, 71, 18, 24, 49, 63, 78,
    79, 99, 101, 25, 28, 69, 71, 69, 71, 106, 107, 28, 30, 71, 73, 83,
    84, 112, 113, 55, 78, 66, 99, 96, 109, 100, 112, 59, 79, 71, 101,
    109, 115, 112, 117, 69, 83, 106, 112, 122, 124, 128, 132, 71, 84,
    107, 113, 124, 125, 132, 134, 13, 40, 17, 48, 52, 65, 57, 70, 17, 48,
    23, 62, 75, 98, 76, 100, 52, 65, 75, 98, 75, 98, 108, 111, 57, 70,
    76, 100, 108, 111, 114, 116, 20, 68, 27, 70, 58, 105, 66, 106, 27,
    70, 29, 72, 80, 111, 81, 112, 58, 105, 80, 111, 82, 127, 109, 131,
    66, 106, 81, 112, 109, 131, 115, 133, 14, 41, 18, 49, 55, 66, 59, 71,
    18, 49, 24, 63, 78, 99, 79, 101, 55, 66, 78, 99, 96, 100, 109, 112,
    59, 71, 79, 101, 109, 112, 115, 117, 25, 69, 28, 71, 69, 106, 71,
    107, 28, 71, 30, 73, 83, 112, 84, 113, 69, 106, 83, 112, 122, 128,
    124, 132, 71, 107, 84, 113, 124, 132, 125, 134, 36, 42, 42, 62, 55,
    66, 66, 72, 42, 62, 62, 94, 96, 100, 100, 102, 55, 66, 96, 100, 78,
    99, 109, 112, 66, 72, 100, 102, 109, 112, 116, 118, 55, 96, 66, 100,
    78, 109, 99, 112, 66, 100, 72, 102, 109, 116, 112, 118, 78, 109, 109,
    116, 90, 129, 129, 133, 99, 112, 112, 118, 129, 133, 133, 135, 37,
    43, 43, 63, 64, 67, 67, 73, 43, 63, 63, 95, 97, 101, 101, 103, 64,
    67, 97, 101, 97, 101, 110, 113, 67, 73, 101, 103, 110, 113, 117, 119,
    64, 97, 67, 101, 97, 110, 101, 113, 67, 101, 73, 103, 110, 117, 113,
    119, 97, 110, 110, 117, 126, 130, 130, 134, 101, 113, 113, 119, 130,
    134, 134, 136, 2, 6, 12, 15, 6, 13, 15, 20, 12, 15, 38, 40, 51, 52,
    56, 58, 6, 13, 51, 52, 13, 36, 52, 55, 15, 20, 56, 58, 52, 55, 75,
    78, 12, 51, 38, 56, 15, 52, 40, 58, 38, 56, 44, 68, 56, 75, 68, 82,
    15, 52, 56, 75, 20, 55, 58, 78, 40, 58, 68, 82, 58, 78, 82, 90, 6, 8,
    15, 17, 15, 17, 26, 27, 15, 17, 40, 42, 56, 57, 65, 66, 15, 17, 56,
    57, 40, 42, 65, 66, 26, 27, 65, 66, 65, 66, 98, 99, 51, 74, 56, 75,
    56, 75, 65, 80, 56, 75, 68, 96, 104, 108, 105, 109, 56, 75, 104, 108,
    68, 96, 105, 109, 65, 80, 105, 109, 105, 109, 127, 129, 3, 7, 19, 20,
    7, 14, 20, 25, 19, 20, 44, 45, 54, 55, 68, 69, 7, 14, 54, 55, 14, 37,
    55, 64, 20, 25, 68, 69, 55, 64, 96, 97, 19, 54, 44, 68, 20, 55, 45,
    69, 44, 68, 120, 121, 68, 96, 121, 122, 20, 55, 68, 96, 25, 64, 69,
    97, 45, 69, 121, 122, 69, 97, 122, 126, 7, 9, 20, 21, 16, 18, 27, 28,
    20, 21, 45, 46, 58, 59, 70, 71, 16, 18, 58, 59, 41, 43, 66, 67, 27,
    28, 70, 71, 66, 67, 100, 101, 54, 77, 68, 82, 58, 78, 70, 83, 68, 82,
    121, 122, 105, 109, 123, 124, 58, 78, 105, 109, 69, 97, 106, 110, 70,
    83, 123, 124, 106, 110, 128, 130, 6, 15, 15, 26, 8, 17, 17, 27, 51,
    56, 56, 65, 74, 75, 75, 80, 15, 40, 56, 65, 17, 42, 57, 66, 56, 68,
    104, 105, 75, 96, 108, 109, 15, 56, 40, 65, 17, 57, 42, 66, 56, 104,
    68, 105, 75, 108, 96, 109, 26, 65, 65, 98, 27, 66, 66, 99, 65, 105,
    105, 127, 80, 109, 109, 129, 13, 17, 20, 27, 17, 23, 27, 29, 52, 57,
    58, 66, 75, 76, 80, 81, 40, 48, 68, 70, 48, 62, 70, 72, 65, 70, 105,
    106, 98, 100, 111, 112, 52, 75, 58, 80, 57, 76, 66, 81, 75, 108, 82,
    109, 108, 114, 109, 115, 65, 98, 105, 111, 70, 100, 106, 112, 98,
    111, 127, 131, 111, 116, 131, 133, 7, 16, 20, 27, 9, 18, 21, 28, 54,
    58, 68, 70, 77, 78, 82, 83, 16, 41, 58, 66, 18, 43, 59, 67, 58, 69,
    105, 106, 78, 97, 109, 110, 20, 58, 45, 70, 21, 59, 46, 71, 68, 105,
    121, 123, 82, 109, 122, 124, 27, 66, 70, 100, 28, 67, 71, 101, 70,
    106, 123, 128, 83, 110, 124, 130, 14, 18, 25, 28, 18, 24, 28, 30, 55,
    59, 69, 71, 78, 79, 83, 84, 41, 49, 69, 71, 49, 63, 71, 73, 66, 71,
    106, 107, 99, 101, 112, 113, 55, 78, 69, 83, 59, 79, 71, 84, 96, 109,
    122, 124, 109, 115, 124, 125, 66, 99, 106, 112, 71, 101, 107, 113,
    100, 112, 128, 132, 112, 117, 132, 134, 6, 15, 51, 56, 15, 40, 56,
    68, 15, 26, 56, 65, 56, 65, 104, 105, 8, 17, 74, 75, 17, 42, 75, 96,
    17, 27, 75, 80, 57, 66, 108, 109, 15, 56, 56, 104, 26, 65, 65, 105,
    40, 65, 68, 105, 65, 98, 105, 127, 17, 57, 75, 108, 27, 66, 80, 109,
    42, 66, 96, 109, 66, 99, 109, 129, 13, 17, 52, 57, 40, 48, 65, 70,
    20, 27, 58, 66, 68, 70, 105, 106, 17, 23, 75, 76, 48, 62, 98, 100,
    27, 29, 80, 81, 70, 72, 111, 112, 52, 75, 75, 108, 65, 98, 98, 111,
    58, 80, 82, 109, 105, 111, 127, 131, 57, 76, 108, 114, 70, 100, 111,
    116, 66, 81, 109, 115, 106, 112, 131, 133, 7, 16, 54, 58, 16, 41, 58,
    69, 20, 27, 68, 70, 58, 66, 105, 106, 9, 18, 77, 78, 18, 43, 78, 97,
    21, 28, 82, 83, 59, 67, 109, 110, 20, 58, 68, 105, 27, 66, 70, 106,
    45, 70, 121, 123, 70, 100, 123, 128, 21, 59, 82, 109, 28, 67, 83,
    110, 46, 71, 122, 124, 71, 101, 124, 130, 14, 18, 55, 59, 41, 49, 66,
    71, 25, 28, 69, 71, 69, 71, 106, 107, 18, 24, 78, 79, 49, 63, 99,
    101, 28, 30, 83, 84, 71, 73, 112, 113, 55, 78, 96, 109, 66, 99, 100,
    112, 69, 83, 122, 124, 106, 112, 128, 132, 59, 79, 109, 115, 71, 101,
    112, 117, 71, 84, 124, 125, 107, 113, 132, 134, 13, 40, 52, 65, 17,
    48, 57, 70, 52, 65, 75, 98, 75, 98, 108, 111, 17, 48, 75, 98, 23, 62,
    76, 100, 57, 70, 108, 111, 76, 100, 114, 116, 20, 68, 58, 105, 27,
    70, 66, 106, 58, 105, 82, 127, 80, 111, 109, 131, 27, 70, 80, 111,
    29, 72, 81, 112, 66, 106, 109, 131, 81, 112, 115, 133, 36, 42, 55,
    66, 42, 62, 66, 72, 55, 66, 78, 99, 96, 100, 109, 112, 42, 62, 96,
    100, 62, 94, 100, 102, 66, 72, 109, 112, 100, 102, 116, 118, 55, 96,
    78, 109, 66, 100, 99, 112, 78, 109, 90, 129, 109, 116, 129, 133, 66,
    100, 109, 116, 72, 102, 112, 118, 99, 112, 129, 133, 112, 118, 133,
    135, 14, 41, 55, 66, 18, 49, 59, 71, 55, 66, 96, 100, 78, 99, 109,
    112, 18, 49, 78, 99, 24, 63, 79, 101, 59, 71, 109, 112, 79, 101, 115,
    117, 25, 69, 69, 106, 28, 71, 71, 107, 69, 106, 122, 128, 83, 112,
    124, 132, 28, 71, 83, 112, 30, 73, 84, 113, 71, 107, 124, 132, 84,
    113, 125, 134, 37, 43, 64, 67, 43, 63, 67, 73, 64, 67, 97, 101, 97,
    101, 110, 113, 43, 63, 97, 101, 63, 95, 101, 103, 67, 73, 110, 113,
    101, 103, 117, 119, 64, 97, 97, 110, 67, 101, 101, 113, 97, 110, 126,
    130, 110, 117, 130, 134, 67, 101, 110, 117, 73, 103, 113, 119, 101,
    113, 130, 134, 113, 119, 134, 136, 4, 7, 13, 16, 13, 16, 17, 21, 13,
    16, 39, 41, 52, 53, 57, 59, 13, 16, 52, 53, 39, 41, 57, 59, 17, 21,
    57, 59, 57, 59, 76, 79, 35, 54, 40, 58, 40, 58, 48, 60, 40, 58, 45,
    69, 65, 80, 70, 83, 40, 58, 65, 80, 45, 69, 70, 83, 48, 60, 70, 83,
    70, 83, 86, 91, 7, 9, 16, 18, 20, 21, 27, 28, 16, 18, 41, 43, 58, 59,
    66, 67, 20, 21, 58, 59, 45, 46, 70, 71, 27, 28, 66, 67, 70, 71, 100,
    101, 54, 77, 58, 78, 68, 82, 70, 83, 58, 78, 69, 97, 105, 109, 106,
    110, 68, 82, 105, 109, 121, 122, 123, 124, 70, 83, 106, 110, 123,
    124, 128, 130, 7, 9, 20, 21, 16, 18, 27, 28, 20, 21, 45, 46, 58, 59,
    70, 71, 16, 18, 58, 59, 41, 43, 66, 67, 27, 28, 70, 71, 66, 67, 100,
    101, 54, 77, 68, 82, 58, 78, 70, 83, 68, 82, 121, 122, 105, 109, 123,
    124, 58, 78, 105, 109, 69, 97, 106, 110, 70, 83, 123, 124, 106, 110,
    128, 130, 9, 10, 21, 22, 21, 22, 29, 30, 21, 22, 46, 47, 60, 61, 72,
    73, 21, 22, 60, 61, 46, 47, 72, 73, 29, 30, 72, 73, 72, 73, 102, 103,
    77, 89, 82, 90, 82, 90, 86, 91, 82, 90, 122, 126, 127, 129, 128, 130,
    82, 90, 127, 129, 122, 126, 128, 130, 86, 91, 128, 130, 128, 130,
    141, 142, 13, 20, 17, 27, 17, 27, 23, 29, 52, 58, 57, 66, 75, 80, 76,
    81, 52, 58, 75, 80, 57, 66, 76, 81, 75, 82, 108, 109, 108, 109, 114,
    115, 40, 68, 48, 70, 48, 70, 62, 72, 65, 105, 70, 106, 98, 111, 100,
    112, 65, 105, 98, 111, 70, 106, 100, 112, 98, 127, 111, 131, 111,
    131, 116, 133, 16, 21, 21, 28, 27, 29, 29, 31, 53, 59, 59, 67, 80,
    81, 81, 85, 58, 60, 82, 83, 70, 72, 86, 87, 80, 83, 109, 110, 111,
    112, 116, 117, 58, 82, 60, 83, 70, 86, 72, 87, 80, 109, 83, 110, 111,
    116, 112, 117, 105, 127, 127, 131, 123, 128, 128, 132, 111, 131, 131,
    143, 144, 145, 145, 146, 16, 21, 27, 29, 21, 28, 29, 31, 58, 60, 70,
    72, 82, 83, 86, 87, 53, 59, 80, 81, 59, 67, 81, 85, 80, 83, 111, 112,
    109, 110, 116, 117, 58, 82, 70, 86, 60, 83, 72, 87, 105, 127, 123,
    128, 127, 131, 128, 132, 80, 109, 111, 116, 83, 110, 112, 117, 111,
    131, 144, 145, 131, 143, 145, 146, 18, 22, 28, 30, 28, 30, 31, 32,
    59, 61, 71, 73, 83, 84, 87, 88, 59, 61, 83, 84, 71, 73, 87, 88, 81,
    84, 112, 113, 112, 113, 118, 119, 78, 90, 83, 91, 83, 91, 87, 92,
    109, 129, 124, 130, 131, 133, 132, 134, 109, 129, 131, 133, 124, 130,
    132, 134, 116, 133, 145, 146, 145, 146, 147, 148, 13, 20, 52, 58, 52,
    58, 75, 82, 17, 27, 57, 66, 75, 80, 108, 109, 17, 27, 75, 80, 57, 66,
    108, 109, 23, 29, 76, 81, 76, 81, 114, 115, 40, 68, 65, 105, 65, 105,
    98, 127, 48, 70, 70, 106, 98, 111, 111, 131, 48, 70, 98, 111, 70,
    106, 111, 131, 62, 72, 100, 112, 100, 112, 116, 133, 16, 21, 53, 59,
    58, 60, 80, 83, 21, 28, 59, 67, 82, 83, 109, 110, 27, 29, 80, 81, 70,
    72, 111, 112, 29, 31, 81, 85, 86, 87, 116, 117, 58, 82, 80, 109, 105,
    127, 111, 131, 60, 83, 83, 110, 127, 131, 131, 143, 70, 86, 111, 116,
    123, 128, 144, 145, 72, 87, 112, 117, 128, 132, 145, 146, 16, 21, 58,
    60, 53, 59, 80, 83, 27, 29, 70, 72, 80, 81, 111, 112, 21, 28, 82, 83,
    59, 67, 109, 110, 29, 31, 86, 87, 81, 85, 116, 117, 58, 82, 105, 127,
    80, 109, 111, 131, 70, 86, 123, 128, 111, 116, 144, 145, 60, 83, 127,
    131, 83, 110, 131, 143, 72, 87, 128, 132, 112, 117, 145, 146, 18, 22,
    59, 61, 59, 61, 81, 84, 28, 30, 71, 73, 83, 84, 112, 113, 28, 30, 83,
    84, 71, 73, 112, 113, 31, 32, 87, 88, 87, 88, 118, 119, 78, 90, 109,
    129, 109, 129, 116, 133, 83, 91, 124, 130, 131, 133, 145, 146, 83,
    91, 131, 133, 124, 130, 145, 146, 87, 92, 132, 134, 132, 134, 147,
    148, 39, 45, 57, 70, 57, 70, 76, 86, 57, 70, 76, 100, 108, 111, 114,
    116, 57, 70, 108, 111, 76, 100, 114, 116, 76, 86, 114, 116, 114, 116,
    137, 138, 45, 121, 70, 123, 70, 123, 100, 128, 70, 123, 86, 128, 111,
    144, 116, 145, 70, 123, 111, 144, 86, 128, 116, 145, 100, 128, 116,
    145, 116, 145, 138, 149, 41, 46, 59, 71, 66, 72, 81, 87, 59, 71, 79,
    101, 109, 112, 115, 117, 66, 72, 109, 112, 100, 102, 116, 118, 81,
    87, 115, 117, 116, 118, 138, 139, 69, 122, 83, 124, 106, 128, 112,
    132, 83, 124, 91, 130, 131, 145, 133, 146, 106, 128, 131, 145, 128,
    141, 145, 147, 112, 132, 133, 146, 145, 147, 149, 150, 41, 46, 66,
    72, 59, 71, 81, 87, 66, 72, 100, 102, 109, 112, 116, 118, 59, 71,
    109, 112, 79, 101, 115, 117, 81, 87, 116, 118, 115, 117, 138, 139,
    69, 122, 106, 128, 83, 124, 112, 132, 106, 128, 128, 141, 131, 145,
    145, 147, 83, 124, 131, 145, 91, 130, 133, 146, 112, 132, 145, 147,
    133, 146, 149, 150, 43, 47, 67, 73, 67, 73, 85, 88, 67, 73, 101, 103,
    110, 113, 117, 119, 67, 73, 110, 113, 101, 103, 117, 119, 85, 88,
    117, 119, 117, 119, 139, 140, 97, 126, 110, 130, 110, 130, 117, 134,
    110, 130, 130, 142, 143, 146, 146, 148, 110, 130, 143, 146, 130, 142,
    146, 148, 117, 134, 146, 148, 146, 148, 150, 151, 2, 12, 6, 15, 6,
    15, 13, 20, 12, 38, 15, 40, 51, 56, 52, 58, 12, 38, 51, 56, 15, 40,
    52, 58, 38, 44, 56, 68, 56, 68, 75, 82, 6, 51, 13, 52, 13, 52, 36,
    55, 15, 56, 20, 58, 52, 75, 55, 78, 15, 56, 52, 75, 20, 58, 55, 78,
    40, 68, 58, 82, 58, 82, 78, 90, 6, 15, 8, 17, 15, 26, 17, 27, 15, 40,
    17, 42, 56, 65, 57, 66, 51, 56, 74, 75, 56, 65, 75, 80, 56, 68, 75,
    96, 104, 105, 108, 109, 15, 56, 17, 57, 40, 65, 42, 66, 26, 65, 27,
    66, 65, 98, 66, 99, 56, 104, 75, 108, 68, 105, 96, 109, 65, 105, 80,
    109, 105, 127, 109, 129, 6, 15, 15, 26, 8, 17, 17, 27, 51, 56, 56,
    65, 74, 75, 75, 80, 15, 40, 56, 65, 17, 42, 57, 66, 56, 68, 104, 105,
    75, 96, 108, 109, 15, 56, 40, 65, 17, 57, 42, 66, 56, 104, 68, 105,
    75, 108, 96, 109, 26, 65, 65, 98, 27, 66, 66, 99, 65, 105, 105, 127,
    80, 109, 109, 129, 13, 20, 17, 27, 17, 27, 23, 29, 52, 58, 57, 66,
    75, 80, 76, 81, 52, 58, 75, 80, 57, 66, 76, 81, 75, 82, 108, 109,
    108, 109, 114, 115, 40, 68, 48, 70, 48, 70, 62, 72, 65, 105, 70, 106,
    98, 111, 100, 112, 65, 105, 98, 111, 70, 106, 100, 112, 98, 127, 111,
    131, 111, 131, 116, 133, 3, 19, 7, 20, 7, 20, 14, 25, 19, 44, 20, 45,
    54, 68, 55, 69, 19, 44, 54, 68, 20, 45, 55, 69, 44, 120, 68, 121, 68,
    121, 96, 122, 7, 54, 14, 55, 14, 55, 37, 64, 20, 68, 25, 69, 55, 96,
    64, 97, 20, 68, 55, 96, 25, 69, 64, 97, 45, 121, 69, 122, 69, 122,
    97, 126, 7, 20, 9, 21, 16, 27, 18, 28, 20, 45, 21, 46, 58, 70, 59,
    71, 54, 68, 77, 82, 58, 70, 78, 83, 68, 121, 82, 122, 105, 123, 109,
    124, 16, 58, 18, 59, 41, 66, 43, 67, 27, 70, 28, 71, 66, 100, 67,
    101, 58, 105, 78, 109, 69, 106, 97, 110, 70, 123, 83, 124, 106, 128,
    110, 130, 7, 20, 16, 27, 9, 21, 18, 28, 54, 68, 58, 70, 77, 82, 78,
    83, 20, 45, 58, 70, 21, 46, 59, 71, 68, 121, 105, 123, 82, 122, 109,
    124, 16, 58, 41, 66, 18, 59, 43, 67, 58, 105, 69, 106, 78, 109, 97,
    110, 27, 70, 66, 100, 28, 71, 67, 101, 70, 123, 106, 128, 83, 124,
    110, 130, 14, 25, 18, 28, 18, 28, 24, 30, 55, 69, 59, 71, 78, 83, 79,
    84, 55, 69, 78, 83, 59, 71, 79, 84, 96, 122, 109, 124, 109, 124, 115,
    125, 41, 69, 49, 71, 49, 71, 63, 73, 66, 106, 71, 107, 99, 112, 101,
    113, 66, 106, 99, 112, 71, 107, 101, 113, 100, 128, 112, 132, 112,
    132, 117, 134, 6, 51, 15, 56, 15, 56, 40, 68, 15, 56, 26, 65, 56,
    104, 65, 105, 15, 56, 56, 104, 26, 65, 65, 105, 40, 68, 65, 105, 65,
    105, 98, 127, 8, 74, 17, 75, 17, 75, 42, 96, 17, 75, 27, 80, 57, 108,
    66, 109, 17, 75, 57, 108, 27, 80, 66, 109, 42, 96, 66, 109, 66, 109,
    99, 129, 13, 52, 17, 57, 40, 65, 48, 70, 20, 58, 27, 66, 68, 105, 70,
    106, 52, 75, 75, 108, 65, 98, 98, 111, 58, 82, 80, 109, 105, 127,
    111, 131, 17, 75, 23, 76, 48, 98, 62, 100, 27, 80, 29, 81, 70, 111,
    72, 112, 57, 108, 76, 114, 70, 111, 100, 116, 66, 109, 81, 115, 106,
    131, 112, 133, 13, 52, 40, 65, 17, 57, 48, 70, 52, 75, 65, 98, 75,
    108, 98, 111, 20, 58, 68, 105, 27, 66, 70, 106, 58, 82, 105, 127, 80,
    109, 111, 131, 17, 75, 48, 98, 23, 76, 62, 100, 57, 108, 70, 111, 76,
    114, 100, 116, 27, 80, 70, 111, 29, 81, 72, 112, 66, 109, 106, 131,
    81, 115, 112, 133, 36, 55, 42, 66, 42, 66, 62, 72, 55, 78, 66, 99,
    96, 109, 100, 112, 55, 78, 96, 109, 66, 99, 100, 112, 78, 90, 109,
    129, 109, 129, 116, 133, 42, 96, 62, 100, 62, 100, 94, 102, 66, 109,
    72, 112, 100, 116, 102, 118, 66, 109, 100, 116, 72, 112, 102, 118,
    99, 129, 112, 133, 112, 133, 118, 135, 7, 54, 16, 58, 16, 58, 41, 69,
    20, 68, 27, 70, 58, 105, 66, 106, 20, 68, 58, 105, 27, 70, 66, 106,
    45, 121, 70, 123, 70, 123, 100, 128, 9, 77, 18, 78, 18, 78, 43, 97,
    21, 82, 28, 83, 59, 109, 67, 110, 21, 82, 59, 109, 28, 83, 67, 110,
    46, 122, 71, 124, 71, 124, 101, 130, 14, 55, 18, 59, 41, 66, 49, 71,
    25, 69, 28, 71, 69, 106, 71, 107, 55, 96, 78, 109, 66, 100, 99, 112,
    69, 122, 83, 124, 106, 128, 112, 132, 18, 78, 24, 79, 49, 99, 63,
    101, 28, 83, 30, 84, 71, 112, 73, 113, 59, 109, 79, 115, 71, 112,
    101, 117, 71, 124, 84, 125, 107, 132, 113, 134, 14, 55, 41, 66, 18,
    59, 49, 71, 55, 96, 66, 100, 78, 109, 99, 112, 25, 69, 69, 106, 28,
    71, 71, 107, 69, 122, 106, 128, 83, 124, 112, 132, 18, 78, 49, 99,
    24, 79, 63, 101, 59, 109, 71, 112, 79, 115, 101, 117, 28, 83, 71,
    112, 30, 84, 73, 113, 71, 124, 107, 132, 84, 125, 113, 134, 37, 64,
    43, 67, 43, 67, 63, 73, 64, 97, 67, 101, 97, 110, 101, 113, 64, 97,
    97, 110, 67, 101, 101, 113, 97, 126, 110, 130, 110, 130, 117, 134,
    43, 97, 63, 101, 63, 101, 95, 103, 67, 110, 73, 113, 101, 117, 103,
    119, 67, 110, 101, 117, 73, 113, 103, 119, 101, 130, 113, 134, 113,
    134, 119, 136, 4, 13, 7, 16, 13, 17, 16, 21, 13, 39, 16, 41, 52, 57,
    53, 59, 35, 40, 54, 58, 40, 48, 58, 60, 40, 45, 58, 69, 65, 70, 80,
    83, 13, 52, 16, 53, 39, 57, 41, 59, 17, 57, 21, 59, 57, 76, 59, 79,
    40, 65, 58, 80, 45, 70, 69, 83, 48, 70, 60, 83, 70, 86, 83, 91, 7,
    16, 9, 18, 20, 27, 21, 28, 16, 41, 18, 43, 58, 66, 59, 67, 54, 58,
    77, 78, 68, 70, 82, 83, 58, 69, 78, 97, 105, 106, 109, 110, 20, 58,
    21, 59, 45, 70, 46, 71, 27, 66, 28, 67, 70, 100, 71, 101, 68, 105,
    82, 109, 121, 123, 122, 124, 70, 106, 83, 110, 123, 128, 124, 130,
    13, 17, 20, 27, 17, 23, 27, 29, 52, 57, 58, 66, 75, 76, 80, 81, 40,
    48, 68, 70, 48, 62, 70, 72, 65, 70, 105, 106, 98, 100, 111, 112, 52,
    75, 58, 80, 57, 76, 66, 81, 75, 108, 82, 109, 108, 114, 109, 115, 65,
    98, 105, 111, 70, 100, 106, 112, 98, 111, 127, 131, 111, 116, 131,
    133, 16, 21, 21, 28, 27, 29, 29, 31, 53, 59, 59, 67, 80, 81, 81, 85,
    58, 60, 82, 83, 70, 72, 86, 87, 80, 83, 109, 110, 111, 112, 116, 117,
    58, 82, 60, 83, 70, 86, 72, 87, 80, 109, 83, 110, 111, 116, 112, 117,
    105, 127, 127, 131, 123, 128, 128, 132, 111, 131, 131, 143, 144, 145,
    145, 146, 7, 20, 9, 21, 16, 27, 18, 28, 20, 45, 21, 46, 58, 70, 59,
    71, 54, 68, 77, 82, 58, 70, 78, 83, 68, 121, 82, 122, 105, 123, 109,
    124, 16, 58, 18, 59, 41, 66, 43, 67, 27, 70, 28, 71, 66, 100, 67,
    101, 58, 105, 78, 109, 69, 106, 97, 110, 70, 123, 83, 124, 106, 128,
    110, 130, 9, 21, 10, 22, 21, 29, 22, 30, 21, 46, 22, 47, 60, 72, 61,
    73, 77, 82, 89, 90, 82, 86, 90, 91, 82, 122, 90, 126, 127, 128, 129,
    130, 21, 60, 22, 61, 46, 72, 47, 73, 29, 72, 30, 73, 72, 102, 73,
    103, 82, 127, 90, 129, 122, 128, 126, 130, 86, 128, 91, 130, 128,
    141, 130, 142, 16, 27, 21, 29, 21, 29, 28, 31, 58, 70, 60, 72, 82,
    86, 83, 87, 58, 70, 82, 86, 60, 72, 83, 87, 105, 123, 127, 128, 127,
    128, 131, 132, 53, 80, 59, 81, 59, 81, 67, 85, 80, 111, 83, 112, 109,
    116, 110, 117, 80, 111, 109, 116, 83, 112, 110, 117, 111, 144, 131,
    145, 131, 145, 143, 146, 18, 28, 22, 30, 28, 31, 30, 32, 59, 71, 61,
    73, 83, 87, 84, 88, 78, 83, 90, 91, 83, 87, 91, 92, 109, 124, 129,
    130, 131, 132, 133, 134, 59, 83, 61, 84, 71, 87, 73, 88, 81, 112, 84,
    113, 112, 118, 113, 119, 109, 131, 129, 133, 124, 132, 130, 134, 116,
    145, 133, 146, 145, 147, 146, 148, 13, 52, 20, 58, 52, 75, 58, 82,
    17, 57, 27, 66, 75, 108, 80, 109, 40, 65, 68, 105, 65, 98, 105, 127,
    48, 70, 70, 106, 98, 111, 111, 131, 17, 75, 27, 80, 57, 108, 66, 109,
    23, 76, 29, 81, 76, 114, 81, 115, 48, 98, 70, 111, 70, 111, 106, 131,
    62, 100, 72, 112, 100, 116, 112, 133, 16, 53, 21, 59, 58, 80, 60, 83,
    21, 59, 28, 67, 82, 109, 83, 110, 58, 80, 82, 109, 105, 111, 127,
    131, 60, 83, 83, 110, 127, 131, 131, 143, 27, 80, 29, 81, 70, 111,
    72, 112, 29, 81, 31, 85, 86, 116, 87, 117, 70, 111, 86, 116, 123,
    144, 128, 145, 72, 112, 87, 117, 128, 145, 132, 146, 39, 57, 45, 70,
    57, 76, 70, 86, 57, 76, 70, 100, 108, 114, 111, 116, 45, 70, 121,
    123, 70, 100, 123, 128, 70, 86, 123, 128, 111, 116, 144, 145, 57,
    108, 70, 111, 76, 114, 100, 116, 76, 114, 86, 116, 114, 137, 116,
    138, 70, 111, 123, 144, 86, 116, 128, 145, 100, 116, 128, 145, 116,
    138, 145, 149, 41, 59, 46, 71, 66, 81, 72, 87, 59, 79, 71, 101, 109,
    115, 112, 117, 69, 83, 122, 124, 106, 112, 128, 132, 83, 91, 124,
    130, 131, 133, 145, 146, 66, 109, 72, 112, 100, 116, 102, 118, 81,
    115, 87, 117, 116, 138, 118, 139, 106, 131, 128, 145, 128, 145, 141,
    147, 112, 133, 132, 146, 145, 149, 147, 150, 16, 58, 21, 60, 53, 80,
    59, 83, 27, 70, 29, 72, 80, 111, 81, 112, 58, 105, 82, 127, 80, 111,
    109, 131, 70, 123, 86, 128, 111, 144, 116, 145, 21, 82, 28, 83, 59,
    109, 67, 110, 29, 86, 31, 87, 81, 116, 85, 117, 60, 127, 83, 131, 83,
    131, 110, 143, 72, 128, 87, 132, 112, 145, 117, 146, 18, 59, 22, 61,
    59, 81, 61, 84, 28, 71, 30, 73, 83, 112, 84, 113, 78, 109, 90, 129,
    109, 116, 129, 133, 83, 124, 91, 130, 131, 145, 133, 146, 28, 83, 30,
    84, 71, 112, 73, 113, 31, 87, 32, 88, 87, 118, 88, 119, 83, 131, 91,
    133, 124, 145, 130, 146, 87, 132, 92, 134, 132, 147, 134, 148, 41,
    66, 46, 72, 59, 81, 71, 87, 66, 100, 72, 102, 109, 116, 112, 118, 69,
    106, 122, 128, 83, 112, 124, 132, 106, 128, 128, 141, 131, 145, 145,
    147, 59, 109, 71, 112, 79, 115, 101, 117, 81, 116, 87, 118, 115, 138,
    117, 139, 83, 131, 124, 145, 91, 133, 130, 146, 112, 145, 132, 147,
    133, 149, 146, 150, 43, 67, 47, 73, 67, 85, 73, 88, 67, 101, 73, 103,
    110, 117, 113, 119, 97, 110, 126, 130, 110, 117, 130, 134, 110, 130,
    130, 142, 143, 146, 146, 148, 67, 110, 73, 113, 101, 117, 103, 119,
    85, 117, 88, 119, 117, 139, 119, 140, 110, 143, 130, 146, 130, 146,
    142, 148, 117, 146, 134, 148, 146, 150, 148, 151, 4, 13, 13, 17, 7,
    16, 16, 21, 35, 40, 40, 48, 54, 58, 58, 60, 13, 39, 52, 57, 16, 41,
    53, 59, 40, 45, 65, 70, 58, 69, 80, 83, 13, 52, 39, 57, 16, 53, 41,
    59, 40, 65, 45, 70, 58, 80, 69, 83, 17, 57, 57, 76, 21, 59, 59, 79,
    48, 70, 70, 86, 60, 83, 83, 91, 13, 17, 17, 23, 20, 27, 27, 29, 40,
    48, 48, 62, 68, 70, 70, 72, 52, 57, 75, 76, 58, 66, 80, 81, 65, 70,
    98, 100, 105, 106, 111, 112, 52, 75, 57, 76, 58, 80, 66, 81, 65, 98,
    70, 100, 105, 111, 106, 112, 75, 108, 108, 114, 82, 109, 109, 115,
    98, 111, 111, 116, 127, 131, 131, 133, 7, 16, 20, 27, 9, 18, 21, 28,
    54, 58, 68, 70, 77, 78, 82, 83, 16, 41, 58, 66, 18, 43, 59, 67, 58,
    69, 105, 106, 78, 97, 109, 110, 20, 58, 45, 70, 21, 59, 46, 71, 68,
    105, 121, 123, 82, 109, 122, 124, 27, 66, 70, 100, 28, 67, 71, 101,
    70, 106, 123, 128, 83, 110, 124, 130, 16, 21, 27, 29, 21, 28, 29, 31,
    58, 60, 70, 72, 82, 83, 86, 87, 53, 59, 80, 81, 59, 67, 81, 85, 80,
    83, 111, 112, 109, 110, 116, 117, 58, 82, 70, 86, 60, 83, 72, 87,
    105, 127, 123, 128, 127, 131, 128, 132, 80, 109, 111, 116, 83, 110,
    112, 117, 111, 131, 144, 145, 131, 143, 145, 146, 7, 20, 16, 27, 9,
    21, 18, 28, 54, 68, 58, 70, 77, 82, 78, 83, 20, 45, 58, 70, 21, 46,
    59, 71, 68, 121, 105, 123, 82, 122, 109, 124, 16, 58, 41, 66, 18, 59,
    43, 67, 58, 105, 69, 106, 78, 109, 97, 110, 27, 70, 66, 100, 28, 71,
    67, 101, 70, 123, 106, 128, 83, 124, 110, 130, 16, 27, 21, 29, 21,
    29, 28, 31, 58, 70, 60, 72, 82, 86, 83, 87, 58, 70, 82, 86, 60, 72,
    83, 87, 105, 123, 127, 128, 127, 128, 131, 132, 53, 80, 59, 81, 59,
    81, 67, 85, 80, 111, 83, 112, 109, 116, 110, 117, 80, 111, 109, 116,
    83, 112, 110, 117, 111, 144, 131, 145, 131, 145, 143, 146, 9, 21, 21,
    29, 10, 22, 22, 30, 77, 82, 82, 86, 89, 90, 90, 91, 21, 46, 60, 72,
    22, 47, 61, 73, 82, 122, 127, 128, 90, 126, 129, 130, 21, 60, 46, 72,
    22, 61, 47, 73, 82, 127, 122, 128, 90, 129, 126, 130, 29, 72, 72,
    102, 30, 73, 73, 103, 86, 128, 128, 141, 91, 130, 130, 142, 18, 28,
    28, 31, 22, 30, 30, 32, 78, 83, 83, 87, 90, 91, 91, 92, 59, 71, 83,
    87, 61, 73, 84, 88, 109, 124, 131, 132, 129, 130, 133, 134, 59, 83,
    71, 87, 61, 84, 73, 88, 109, 131, 124, 132, 129, 133, 130, 134, 81,
    112, 112, 118, 84, 113, 113, 119, 116, 145, 145, 147, 133, 146, 146,
    148, 13, 52, 52, 75, 20, 58, 58, 82, 40, 65, 65, 98, 68, 105, 105,
    127, 17, 57, 75, 108, 27, 66, 80, 109, 48, 70, 98, 111, 70, 106, 111,
    131, 17, 75, 57, 108, 27, 80, 66, 109, 48, 98, 70, 111, 70, 111, 106,
    131, 23, 76, 76, 114, 29, 81, 81, 115, 62, 100, 100, 116, 72, 112,
    112, 133, 39, 57, 57, 76, 45, 70, 70, 86, 45, 70, 70, 100, 121, 123,
    123, 128, 57, 76, 108, 114, 70, 100, 111, 116, 70, 86, 111, 116, 123,
    128, 144, 145, 57, 108, 76, 114, 70, 111, 100, 116, 70, 111, 86, 116,
    123, 144, 128, 145, 76, 114, 114, 137, 86, 116, 116, 138, 100, 116,
    116, 138, 128, 145, 145, 149, 16, 53, 58, 80, 21, 59, 60, 83, 58, 80,
    105, 111, 82, 109, 127, 131, 21, 59, 82, 109, 28, 67, 83, 110, 60,
    83, 127, 131, 83, 110, 131, 143, 27, 80, 70, 111, 29, 81, 72, 112,
    70, 111, 123, 144, 86, 116, 128, 145, 29, 81, 86, 116, 31, 85, 87,
    117, 72, 112, 128, 145, 87, 117, 132, 146, 41, 59, 66, 81, 46, 71,
    72, 87, 69, 83, 106, 112, 122, 124, 128, 132, 59, 79, 109, 115, 71,
    101, 112, 117, 83, 91, 131, 133, 124, 130, 145, 146, 66, 109, 100,
    116, 72, 112, 102, 118, 106, 131, 128, 145, 128, 145, 141, 147, 81,
    115, 116, 138, 87, 117, 118, 139, 112, 133, 145, 149, 132, 146, 147,
    150, 16, 58, 53, 80, 21, 60, 59, 83, 58, 105, 80, 111, 82, 127, 109,
    131, 27, 70, 80, 111, 29, 72, 81, 112, 70, 123, 111, 144, 86, 128,
    116, 145, 21, 82, 59, 109, 28, 83, 67, 110, 60, 127, 83, 131, 83,
    131, 110, 143, 29, 86, 81, 116, 31, 87, 85, 117, 72, 128, 112, 145,
    87, 132, 117, 146, 41, 66, 59, 81, 46, 72, 71, 87, 69, 106, 83, 112,
    122, 128, 124, 132, 66, 100, 109, 116, 72, 102, 112, 118, 106, 128,
    131, 145, 128, 141, 145, 147, 59, 109, 79, 115, 71, 112, 101, 117,
    83, 131, 91, 133, 124, 145, 130, 146, 81, 116, 115, 138, 87, 118,
    117, 139, 112, 145, 133, 149, 132, 147, 146, 150, 18, 59, 59, 81, 22,
    61, 61, 84, 78, 109, 109, 116, 90, 129, 129, 133, 28, 71, 83, 112,
    30, 73, 84, 113, 83, 124, 131, 145, 91, 130, 133, 146, 28, 83, 71,
    112, 30, 84, 73, 113, 83, 131, 124, 145, 91, 133, 130, 146, 31, 87,
    87, 118, 32, 88, 88, 119, 87, 132, 132, 147, 92, 134, 134, 148, 43,
    67, 67, 85, 47, 73, 73, 88, 97, 110, 110, 117, 126, 130, 130, 134,
    67, 101, 110, 117, 73, 103, 113, 119, 110, 130, 143, 146, 130, 142,
    146, 148, 67, 110, 101, 117, 73, 113, 103, 119, 110, 143, 130, 146,
    130, 146, 142, 148, 85, 117, 117, 139, 88, 119, 119, 140, 117, 146,
    146, 150, 134, 148, 148, 151, 11, 14, 14, 18, 14, 18, 18, 22, 36, 41,
    41, 49, 55, 59, 59, 61, 36, 41, 55, 59, 41, 49, 59, 61, 42, 46, 66,
    71, 66, 71, 81, 84, 36, 55, 41, 59, 41, 59, 49, 61, 42, 66, 46, 71,
    66, 81, 71, 84, 42, 66, 66, 81, 46, 71, 71, 84, 62, 72, 72, 87, 72,
    87, 87, 92, 14, 18, 18, 24, 25, 28, 28, 30, 41, 49, 49, 63, 69, 71,
    71, 73, 55, 59, 78, 79, 69, 71, 83, 84, 66, 71, 99, 101, 106, 107,
    112, 113, 55, 78, 59, 79, 69, 83, 71, 84, 66, 99, 71, 101, 106, 112,
    107, 113, 96, 109, 109, 115, 122, 124, 124, 125, 100, 112, 112, 117,
    128, 132, 132, 134, 14, 18, 25, 28, 18, 24, 28, 30, 55, 59, 69, 71,
    78, 79, 83, 84, 41, 49, 69, 71, 49, 63, 71, 73, 66, 71, 106, 107, 99,
    101, 112, 113, 55, 78, 69, 83, 59, 79, 71, 84, 96, 109, 122, 124,
    109, 115, 124, 125, 66, 99, 106, 112, 71, 101, 107, 113, 100, 112,
    128, 132, 112, 117, 132, 134, 18, 22, 28, 30, 28, 30, 31, 32, 59, 61,
    71, 73, 83, 84, 87, 88, 59, 61, 83, 84, 71, 73, 87, 88, 81, 84, 112,
    113, 112, 113, 118, 119, 78, 90, 83, 91, 83, 91, 87, 92, 109, 129,
    124, 130, 131, 133, 132, 134, 109, 129, 131, 133, 124, 130, 132, 134,
    116, 133, 145, 146, 145, 146, 147, 148, 14, 25, 18, 28, 18, 28, 24,
    30, 55, 69, 59, 71, 78, 83, 79, 84, 55, 69, 78, 83, 59, 71, 79, 84,
    96, 122, 109, 124, 109, 124, 115, 125, 41, 69, 49, 71, 49, 71, 63,
    73, 66, 106, 71, 107, 99, 112, 101, 113, 66, 106, 99, 112, 71, 107,
    101, 113, 100, 128, 112, 132, 112, 132, 117, 134, 18, 28, 22, 30, 28,
    31, 30, 32, 59, 71, 61, 73, 83, 87, 84, 88, 78, 83, 90, 91, 83, 87,
    91, 92, 109, 124, 129, 130, 131, 132, 133, 134, 59, 83, 61, 84, 71,
    87, 73, 88, 81, 112, 84, 113, 112, 118, 113, 119, 109, 131, 129, 133,
    124, 132, 130, 134, 116, 145, 133, 146, 145, 147, 146, 148, 18, 28,
    28, 31, 22, 30, 30, 32, 78, 83, 83, 87, 90, 91, 91, 92, 59, 71, 83,
    87, 61, 73, 84, 88, 109, 124, 131, 132, 129, 130, 133, 134, 59, 83,
    71, 87, 61, 84, 73, 88, 109, 131, 124, 132, 129, 133, 130, 134, 81,
    112, 112, 118, 84, 113, 113, 119, 116, 145, 145, 147, 133, 146, 146,
    148, 24, 30, 30, 32, 30, 32, 32, 33, 79, 84, 84, 88, 91, 92, 92, 93,
    79, 84, 91, 92, 84, 88, 92, 93, 115, 125, 133, 134, 133, 134, 135,
    136, 79, 91, 84, 92, 84, 92, 88, 93, 115, 133, 125, 134, 133, 135,
    134, 136, 115, 133, 133, 135, 125, 134, 134, 136, 138, 149, 149, 150,
    149, 150, 150, 151, 36, 55, 55, 78, 55, 78, 78, 90, 42, 66, 66, 99,
    96, 109, 109, 129, 42, 66, 96, 109, 66, 99, 109, 129, 62, 72, 100,
    112, 100, 112, 116, 133, 42, 96, 66, 109, 66, 109, 99, 129, 62, 100,
    72, 112, 100, 116, 112, 133, 62, 100, 100, 116, 72, 112, 112, 133,
    94, 102, 102, 118, 102, 118, 118, 135, 41, 59, 59, 79, 69, 83, 83,
    91, 46, 71, 71, 101, 122, 124, 124, 130, 66, 81, 109, 115, 106, 112,
    131, 133, 72, 87, 112, 117, 128, 132, 145, 146, 66, 109, 81, 115,
    106, 131, 112, 133, 72, 112, 87, 117, 128, 145, 132, 146, 100, 116,
    116, 138, 128, 145, 145, 149, 102, 118, 118, 139, 141, 147, 147, 150,
    41, 59, 69, 83, 59, 79, 83, 91, 66, 81, 106, 112, 109, 115, 131, 133,
    46, 71, 122, 124, 71, 101, 124, 130, 72, 87, 128, 132, 112, 117, 145,
    146, 66, 109, 106, 131, 81, 115, 112, 133, 100, 116, 128, 145, 116,
    138, 145, 149, 72, 112, 128, 145, 87, 117, 132, 146, 102, 118, 141,
    147, 118, 139, 147, 150, 49, 61, 71, 84, 71, 84, 87, 92, 71, 84, 107,
    113, 124, 125, 132, 134, 71, 84, 124, 125, 107, 113, 132, 134, 87,
    92, 132, 134, 132, 134, 147, 148, 99, 129, 112, 133, 112, 133, 118,
    135, 112, 133, 132, 146, 145, 149, 147, 150, 112, 133, 145, 149, 132,
    146, 147, 150, 118, 135, 147, 150, 147, 150, 152, 153, 41, 69, 59,
    83, 59, 83, 79, 91, 66, 106, 81, 112, 109, 131, 115, 133, 66, 106,
    109, 131, 81, 112, 115, 133, 100, 128, 116, 145, 116, 145, 138, 149,
    46, 122, 71, 124, 71, 124, 101, 130, 72, 128, 87, 132, 112, 145, 117,
    146, 72, 128, 112, 145, 87, 132, 117, 146, 102, 141, 118, 147, 118,
    147, 139, 150, 49, 71, 61, 84, 71, 87, 84, 92, 71, 107, 84, 113, 124,
    132, 125, 134, 99, 112, 129, 133, 112, 118, 133, 135, 112, 132, 133,
    146, 145, 147, 149, 150, 71, 124, 84, 125, 107, 132, 113, 134, 87,
    132, 92, 134, 132, 147, 134, 148, 112, 145, 133, 149, 132, 147, 146,
    150, 118, 147, 135, 150, 147, 152, 150, 153, 49, 71, 71, 87, 61, 84,
    84, 92, 99, 112, 112, 118, 129, 133, 133, 135, 71, 107, 124, 132, 84,
    113, 125, 134, 112, 132, 145, 147, 133, 146, 149, 150, 71, 124, 107,
    132, 84, 125, 113, 134, 112, 145, 132, 147, 133, 149, 146, 150, 87,
    132, 132, 147, 92, 134, 134, 148, 118, 147, 147, 152, 135, 150, 150,
    153, 63, 73, 73, 88, 73, 88, 88, 93, 101, 113, 113, 119, 130, 134,
    134, 136, 101, 113, 130, 134, 113, 119, 134, 136, 117, 134, 146, 148,
    146, 148, 150, 151, 101, 130, 113, 134, 113, 134, 119, 136, 117, 146,
    134, 148, 146, 150, 148, 151, 117, 146, 146, 150, 134, 148, 148, 151,
    139, 150, 150, 153, 150, 153, 153, 154, 2, 12, 12, 38, 12, 38, 38,
    44, 6, 15, 15, 40, 51, 56, 56, 68, 6, 15, 51, 56, 15, 40, 56, 68, 13,
    20, 52, 58, 52, 58, 75, 82, 6, 51, 15, 56, 15, 56, 40, 68, 13, 52,
    20, 58, 52, 75, 58, 82, 13, 52, 52, 75, 20, 58, 58, 82, 36, 55, 55,
    78, 55, 78, 78, 90, 6, 15, 15, 40, 51, 56, 56, 68, 8, 17, 17, 42, 74,
    75, 75, 96, 15, 26, 56, 65, 56, 65, 104, 105, 17, 27, 57, 66, 75, 80,
    108, 109, 15, 56, 26, 65, 56, 104, 65, 105, 17, 57, 27, 66, 75, 108,
    80, 109, 40, 65, 65, 98, 68, 105, 105, 127, 42, 66, 66, 99, 96, 109,
    109, 129, 6, 15, 51, 56, 15, 40, 56, 68, 15, 26, 56, 65, 56, 65, 104,
    105, 8, 17, 74, 75, 17, 42, 75, 96, 17, 27, 75, 80, 57, 66, 108, 109,
    15, 56, 56, 104, 26, 65, 65, 105, 40, 65, 68, 105, 65, 98, 105, 127,
    17, 57, 75, 108, 27, 66, 80, 109, 42, 66, 96, 109, 66, 99, 109, 129,
    13, 20, 52, 58, 52, 58, 75, 82, 17, 27, 57, 66, 75, 80, 108, 109, 17,
    27, 75, 80, 57, 66, 108, 109, 23, 29, 76, 81, 76, 81, 114, 115, 40,
    68, 65, 105, 65, 105, 98, 127, 48, 70, 70, 106, 98, 111, 111, 131,
    48, 70, 98, 111, 70, 106, 111, 131, 62, 72, 100, 112, 100, 112, 116,
    133, 6, 51, 15, 56, 15, 56, 40, 68, 15, 56, 26, 65, 56, 104, 65, 105,
    15, 56, 56, 104, 26, 65, 65, 105, 40, 68, 65, 105, 65, 105, 98, 127,
    8, 74, 17, 75, 17, 75, 42, 96, 17, 75, 27, 80, 57, 108, 66, 109, 17,
    75, 57, 108, 27, 80, 66, 109, 42, 96, 66, 109, 66, 109, 99, 129, 13,
    52, 20, 58, 52, 75, 58, 82, 17, 57, 27, 66, 75, 108, 80, 109, 40, 65,
    68, 105, 65, 98, 105, 127, 48, 70, 70, 106, 98, 111, 111, 131, 17,
    75, 27, 80, 57, 108, 66, 109, 23, 76, 29, 81, 76, 114, 81, 115, 48,
    98, 70, 111, 70, 111, 106, 131, 62, 100, 72, 112, 100, 116, 112, 133,
    13, 52, 52, 75, 20, 58, 58, 82, 40, 65, 65, 98, 68, 105, 105, 127,
    17, 57, 75, 108, 27, 66, 80, 109, 48, 70, 98, 111, 70, 106, 111, 131,
    17, 75, 57, 108, 27, 80, 66, 109, 48, 98, 70, 111, 70, 111, 106, 131,
    23, 76, 76, 114, 29, 81, 81, 115, 62, 100, 100, 116, 72, 112, 112,
    133, 36, 55, 55, 78, 55, 78, 78, 90, 42, 66, 66, 99, 96, 109, 109,
    129, 42, 66, 96, 109, 66, 99, 109, 129, 62, 72, 100, 112, 100, 112,
    116, 133, 42, 96, 66, 109, 66, 109, 99, 129, 62, 100, 72, 112, 100,
    116, 112, 133, 62, 100, 100, 116, 72, 112, 112, 133, 94, 102, 102,
    118, 102, 118, 118, 135, 3, 19, 19, 44, 19, 44, 44, 120, 7, 20, 20,
    45, 54, 68, 68, 121, 7, 20, 54, 68, 20, 45, 68, 121, 14, 25, 55, 69,
    55, 69, 96, 122, 7, 54, 20, 68, 20, 68, 45, 121, 14, 55, 25, 69, 55,
    96, 69, 122, 14, 55, 55, 96, 25, 69, 69, 122, 37, 64, 64, 97, 64, 97,
    97, 126, 7, 20, 20, 45, 54, 68, 68, 121, 9, 21, 21, 46, 77, 82, 82,
    122, 16, 27, 58, 70, 58, 70, 105, 123, 18, 28, 59, 71, 78, 83, 109,
    124, 16, 58, 27, 70, 58, 105, 70, 123, 18, 59, 28, 71, 78, 109, 83,
    124, 41, 66, 66, 100, 69, 106, 106, 128, 43, 67, 67, 101, 97, 110,
    110, 130, 7, 20, 54, 68, 20, 45, 68, 121, 16, 27, 58, 70, 58, 70,
    105, 123, 9, 21, 77, 82, 21, 46, 82, 122, 18, 28, 78, 83, 59, 71,
    109, 124, 16, 58, 58, 105, 27, 70, 70, 123, 41, 66, 69, 106, 66, 100,
    106, 128, 18, 59, 78, 109, 28, 71, 83, 124, 43, 67, 97, 110, 67, 101,
    110, 130, 14, 25, 55, 69, 55, 69, 96, 122, 18, 28, 59, 71, 78, 83,
    109, 124, 18, 28, 78, 83, 59, 71, 109, 124, 24, 30, 79, 84, 79, 84,
    115, 125, 41, 69, 66, 106, 66, 106, 100, 128, 49, 71, 71, 107, 99,
    112, 112, 132, 49, 71, 99, 112, 71, 107, 112, 132, 63, 73, 101, 113,
    101, 113, 117, 134, 7, 54, 20, 68, 20, 68, 45, 121, 16, 58, 27, 70,
    58, 105, 70, 123, 16, 58, 58, 105, 27, 70, 70, 123, 41, 69, 66, 106,
    66, 106, 100, 128, 9, 77, 21, 82, 21, 82, 46, 122, 18, 78, 28, 83,
    59, 109, 71, 124, 18, 78, 59, 109, 28, 83, 71, 124, 43, 97, 67, 110,
    67, 110, 101, 130, 14, 55, 25, 69, 55, 96, 69, 122, 18, 59, 28, 71,
    78, 109, 83, 124, 41, 66, 69, 106, 66, 100, 106, 128, 49, 71, 71,
    107, 99, 112, 112, 132, 18, 78, 28, 83, 59, 109, 71, 124, 24, 79, 30,
    84, 79, 115, 84, 125, 49, 99, 71, 112, 71, 112, 107, 132, 63, 101,
    73, 113, 101, 117, 113, 134, 14, 55, 55, 96, 25, 69, 69, 122, 41, 66,
    66, 100, 69, 106, 106, 128, 18, 59, 78, 109, 28, 71, 83, 124, 49, 71,
    99, 112, 71, 107, 112, 132, 18, 78, 59, 109, 28, 83, 71, 124, 49, 99,
    71, 112, 71, 112, 107, 132, 24, 79, 79, 115, 30, 84, 84, 125, 63,
    101, 101, 117, 73, 113, 113, 134, 37, 64, 64, 97, 64, 97, 97, 126,
    43, 67, 67, 101, 97, 110, 110, 130, 43, 67, 97, 110, 67, 101, 110,
    130, 63, 73, 101, 113, 101, 113, 117, 134, 43, 97, 67, 110, 67, 110,
    101, 130, 63, 101, 73, 113, 101, 117, 113, 134, 63, 101, 101, 117,
    73, 113, 113, 134, 95, 103, 103, 119, 103, 119, 119, 136, 4, 13, 13,
    39, 35, 40, 40, 45, 7, 16, 16, 41, 54, 58, 58, 69, 13, 17, 52, 57,
    40, 48, 65, 70, 16, 21, 53, 59, 58, 60, 80, 83, 13, 52, 17, 57, 40,
    65, 48, 70, 16, 53, 21, 59, 58, 80, 60, 83, 39, 57, 57, 76, 45, 70,
    70, 86, 41, 59, 59, 79, 69, 83, 83, 91, 7, 16, 16, 41, 54, 58, 58,
    69, 9, 18, 18, 43, 77, 78, 78, 97, 20, 27, 58, 66, 68, 70, 105, 106,
    21, 28, 59, 67, 82, 83, 109, 110, 20, 58, 27, 66, 68, 105, 70, 106,
    21, 59, 28, 67, 82, 109, 83, 110, 45, 70, 70, 100, 121, 123, 123,
    128, 46, 71, 71, 101, 122, 124, 124, 130, 13, 17, 52, 57, 40, 48, 65,
    70, 20, 27, 58, 66, 68, 70, 105, 106, 17, 23, 75, 76, 48, 62, 98,
    100, 27, 29, 80, 81, 70, 72, 111, 112, 52, 75, 75, 108, 65, 98, 98,
    111, 58, 80, 82, 109, 105, 111, 127, 131, 57, 76, 108, 114, 70, 100,
    111, 116, 66, 81, 109, 115, 106, 112, 131, 133, 16, 21, 53, 59, 58,
    60, 80, 83, 21, 28, 59, 67, 82, 83, 109, 110, 27, 29, 80, 81, 70, 72,
    111, 112, 29, 31, 81, 85, 86, 87, 116, 117, 58, 82, 80, 109, 105,
    127, 111, 131, 60, 83, 83, 110, 127, 131, 131, 143, 70, 86, 111, 116,
    123, 128, 144, 145, 72, 87, 112, 117, 128, 132, 145, 146, 13, 52, 17,
    57, 40, 65, 48, 70, 20, 58, 27, 66, 68, 105, 70, 106, 52, 75, 75,
    108, 65, 98, 98, 111, 58, 82, 80, 109, 105, 127, 111, 131, 17, 75,
    23, 76, 48, 98, 62, 100, 27, 80, 29, 81, 70, 111, 72, 112, 57, 108,
    76, 114, 70, 111, 100, 116, 66, 109, 81, 115, 106, 131, 112, 133, 16,
    53, 21, 59, 58, 80, 60, 83, 21, 59, 28, 67, 82, 109, 83, 110, 58, 80,
    82, 109, 105, 111, 127, 131, 60, 83, 83, 110, 127, 131, 131, 143, 27,
    80, 29, 81, 70, 111, 72, 112, 29, 81, 31, 85, 86, 116, 87, 117, 70,
    111, 86, 116, 123, 144, 128, 145, 72, 112, 87, 117, 128, 145, 132,
    146, 39, 57, 57, 76, 45, 70, 70, 86, 45, 70, 70, 100, 121, 123, 123,
    128, 57, 76, 108, 114, 70, 100, 111, 116, 70, 86, 111, 116, 123, 128,
    144, 145, 57, 108, 76, 114, 70, 111, 100, 116, 70, 111, 86, 116, 123,
    144, 128, 145, 76, 114, 114, 137, 86, 116, 116, 138, 100, 116, 116,
    138, 128, 145, 145, 149, 41, 59, 59, 79, 69, 83, 83, 91, 46, 71, 71,
    101, 122, 124, 124, 130, 66, 81, 109, 115, 106, 112, 131, 133, 72,
    87, 112, 117, 128, 132, 145, 146, 66, 109, 81, 115, 106, 131, 112,
    133, 72, 112, 87, 117, 128, 145, 132, 146, 100, 116, 116, 138, 128,
    145, 145, 149, 102, 118, 118, 139, 141, 147, 147, 150, 7, 20, 20, 45,
    54, 68, 68, 121, 9, 21, 21, 46, 77, 82, 82, 122, 16, 27, 58, 70, 58,
    70, 105, 123, 18, 28, 59, 71, 78, 83, 109, 124, 16, 58, 27, 70, 58,
    105, 70, 123, 18, 59, 28, 71, 78, 109, 83, 124, 41, 66, 66, 100, 69,
    106, 106, 128, 43, 67, 67, 101, 97, 110, 110, 130, 9, 21, 21, 46, 77,
    82, 82, 122, 10, 22, 22, 47, 89, 90, 90, 126, 21, 29, 60, 72, 82, 86,
    127, 128, 22, 30, 61, 73, 90, 91, 129, 130, 21, 60, 29, 72, 82, 127,
    86, 128, 22, 61, 30, 73, 90, 129, 91, 130, 46, 72, 72, 102, 122, 128,
    128, 141, 47, 73, 73, 103, 126, 130, 130, 142, 16, 27, 58, 70, 58,
    70, 105, 123, 21, 29, 60, 72, 82, 86, 127, 128, 21, 29, 82, 86, 60,
    72, 127, 128, 28, 31, 83, 87, 83, 87, 131, 132, 53, 80, 80, 111, 80,
    111, 111, 144, 59, 81, 83, 112, 109, 116, 131, 145, 59, 81, 109, 116,
    83, 112, 131, 145, 67, 85, 110, 117, 110, 117, 143, 146, 18, 28, 59,
    71, 78, 83, 109, 124, 22, 30, 61, 73, 90, 91, 129, 130, 28, 31, 83,
    87, 83, 87, 131, 132, 30, 32, 84, 88, 91, 92, 133, 134, 59, 83, 81,
    112, 109, 131, 116, 145, 61, 84, 84, 113, 129, 133, 133, 146, 71, 87,
    112, 118, 124, 132, 145, 147, 73, 88, 113, 119, 130, 134, 146, 148,
    16, 58, 27, 70, 58, 105, 70, 123, 21, 60, 29, 72, 82, 127, 86, 128,
    53, 80, 80, 111, 80, 111, 111, 144, 59, 83, 81, 112, 109, 131, 116,
    145, 21, 82, 29, 86, 60, 127, 72, 128, 28, 83, 31, 87, 83, 131, 87,
    132, 59, 109, 81, 116, 83, 131, 112, 145, 67, 110, 85, 117, 110, 143,
    117, 146, 18, 59, 28, 71, 78, 109, 83, 124, 22, 61, 30, 73, 90, 129,
    91, 130, 59, 81, 83, 112, 109, 116, 131, 145, 61, 84, 84, 113, 129,
    133, 133, 146, 28, 83, 31, 87, 83, 131, 87, 132, 30, 84, 32, 88, 91,
    133, 92, 134, 71, 112, 87, 118, 124, 145, 132, 147, 73, 113, 88, 119,
    130, 146, 134, 148, 41, 66, 66, 100, 69, 106, 106, 128, 46, 72, 72,
    102, 122, 128, 128, 141, 59, 81, 109, 116, 83, 112, 131, 145, 71, 87,
    112, 118, 124, 132, 145, 147, 59, 109, 81, 116, 83, 131, 112, 145,
    71, 112, 87, 118, 124, 145, 132, 147, 79, 115, 115, 138, 91, 133,
    133, 149, 101, 117, 117, 139, 130, 146, 146, 150, 43, 67, 67, 101,
    97, 110, 110, 130, 47, 73, 73, 103, 126, 130, 130, 142, 67, 85, 110,
    117, 110, 117, 143, 146, 73, 88, 113, 119, 130, 134, 146, 148, 67,
    110, 85, 117, 110, 143, 117, 146, 73, 113, 88, 119, 130, 146, 134,
    148, 101, 117, 117, 139, 130, 146, 146, 150, 103, 119, 119, 140, 142,
    148, 148, 151, 4, 13, 35, 40, 13, 39, 40, 45, 13, 17, 40, 48, 52, 57,
    65, 70, 7, 16, 54, 58, 16, 41, 58, 69, 16, 21, 58, 60, 53, 59, 80,
    83, 13, 52, 40, 65, 17, 57, 48, 70, 39, 57, 45, 70, 57, 76, 70, 86,
    16, 53, 58, 80, 21, 59, 60, 83, 41, 59, 69, 83, 59, 79, 83, 91, 13,
    17, 40, 48, 52, 57, 65, 70, 17, 23, 48, 62, 75, 76, 98, 100, 20, 27,
    68, 70, 58, 66, 105, 106, 27, 29, 70, 72, 80, 81, 111, 112, 52, 75,
    65, 98, 75, 108, 98, 111, 57, 76, 70, 100, 108, 114, 111, 116, 58,
    80, 105, 111, 82, 109, 127, 131, 66, 81, 106, 112, 109, 115, 131,
    133, 7, 16, 54, 58, 16, 41, 58, 69, 20, 27, 68, 70, 58, 66, 105, 106,
    9, 18, 77, 78, 18, 43, 78, 97, 21, 28, 82, 83, 59, 67, 109, 110, 20,
    58, 68, 105, 27, 66, 70, 106, 45, 70, 121, 123, 70, 100, 123, 128,
    21, 59, 82, 109, 28, 67, 83, 110, 46, 71, 122, 124, 71, 101, 124,
    130, 16, 21, 58, 60, 53, 59, 80, 83, 27, 29, 70, 72, 80, 81, 111,
    112, 21, 28, 82, 83, 59, 67, 109, 110, 29, 31, 86, 87, 81, 85, 116,
    117, 58, 82, 105, 127, 80, 109, 111, 131, 70, 86, 123, 128, 111, 116,
    144, 145, 60, 83, 127, 131, 83, 110, 131, 143, 72, 87, 128, 132, 112,
    117, 145, 146, 13, 52, 40, 65, 17, 57, 48, 70, 52, 75, 65, 98, 75,
    108, 98, 111, 20, 58, 68, 105, 27, 66, 70, 106, 58, 82, 105, 127, 80,
    109, 111, 131, 17, 75, 48, 98, 23, 76, 62, 100, 57, 108, 70, 111, 76,
    114, 100, 116, 27, 80, 70, 111, 29, 81, 72, 112, 66, 109, 106, 131,
    81, 115, 112, 133, 39, 57, 45, 70, 57, 76, 70, 86, 57, 76, 70, 100,
    108, 114, 111, 116, 45, 70, 121, 123, 70, 100, 123, 128, 70, 86, 123,
    128, 111, 116, 144, 145, 57, 108, 70, 111, 76, 114, 100, 116, 76,
    114, 86, 116, 114, 137, 116, 138, 70, 111, 123, 144, 86, 116, 128,
    145, 100, 116, 128, 145, 116, 138, 145, 149, 16, 53, 58, 80, 21, 59,
    60, 83, 58, 80, 105, 111, 82, 109, 127, 131, 21, 59, 82, 109, 28, 67,
    83, 110, 60, 83, 127, 131, 83, 110, 131, 143, 27, 80, 70, 111, 29,
    81, 72, 112, 70, 111, 123, 144, 86, 116, 128, 145, 29, 81, 86, 116,
    31, 85, 87, 117, 72, 112, 128, 145, 87, 117, 132, 146, 41, 59, 69,
    83, 59, 79, 83, 91, 66, 81, 106, 112, 109, 115, 131, 133, 46, 71,
    122, 124, 71, 101, 124, 130, 72, 87, 128, 132, 112, 117, 145, 146,
    66, 109, 106, 131, 81, 115, 112, 133, 100, 116, 128, 145, 116, 138,
    145, 149, 72, 112, 128, 145, 87, 117, 132, 146, 102, 118, 141, 147,
    118, 139, 147, 150, 7, 20, 54, 68, 20, 45, 68, 121, 16, 27, 58, 70,
    58, 70, 105, 123, 9, 21, 77, 82, 21, 46, 82, 122, 18, 28, 78, 83, 59,
    71, 109, 124, 16, 58, 58, 105, 27, 70, 70, 123, 41, 66, 69, 106, 66,
    100, 106, 128, 18, 59, 78, 109, 28, 71, 83, 124, 43, 67, 97, 110, 67,
    101, 110, 130, 16, 27, 58, 70, 58, 70, 105, 123, 21, 29, 60, 72, 82,
    86, 127, 128, 21, 29, 82, 86, 60, 72, 127, 128, 28, 31, 83, 87, 83,
    87, 131, 132, 53, 80, 80, 111, 80, 111, 111, 144, 59, 81, 83, 112,
    109, 116, 131, 145, 59, 81, 109, 116, 83, 112, 131, 145, 67, 85, 110,
    117, 110, 117, 143, 146, 9, 21, 77, 82, 21, 46, 82, 122, 21, 29, 82,
    86, 60, 72, 127, 128, 10, 22, 89, 90, 22, 47, 90, 126, 22, 30, 90,
    91, 61, 73, 129, 130, 21, 60, 82, 127, 29, 72, 86, 128, 46, 72, 122,
    128, 72, 102, 128, 141, 22, 61, 90, 129, 30, 73, 91, 130, 47, 73,
    126, 130, 73, 103, 130, 142, 18, 28, 78, 83, 59, 71, 109, 124, 28,
    31, 83, 87, 83, 87, 131, 132, 22, 30, 90, 91, 61, 73, 129, 130, 30,
    32, 91, 92, 84, 88, 133, 134, 59, 83, 109, 131, 81, 112, 116, 145,
    71, 87, 124, 132, 112, 118, 145, 147, 61, 84, 129, 133, 84, 113, 133,
    146, 73, 88, 130, 134, 113, 119, 146, 148, 16, 58, 58, 105, 27, 70,
    70, 123, 53, 80, 80, 111, 80, 111, 111, 144, 21, 60, 82, 127, 29, 72,
    86, 128, 59, 83, 109, 131, 81, 112, 116, 145, 21, 82, 60, 127, 29,
    86, 72, 128, 59, 109, 83, 131, 81, 116, 112, 145, 28, 83, 83, 131,
    31, 87, 87, 132, 67, 110, 110, 143, 85, 117, 117, 146, 41, 66, 69,
    106, 66, 100, 106, 128, 59, 81, 83, 112, 109, 116, 131, 145, 46, 72,
    122, 128, 72, 102, 128, 141, 71, 87, 124, 132, 112, 118, 145, 147,
    59, 109, 83, 131, 81, 116, 112, 145, 79, 115, 91, 133, 115, 138, 133,
    149, 71, 112, 124, 145, 87, 118, 132, 147, 101, 117, 130, 146, 117,
    139, 146, 150, 18, 59, 78, 109, 28, 71, 83, 124, 59, 81, 109, 116,
    83, 112, 131, 145, 22, 61, 90, 129, 30, 73, 91, 130, 61, 84, 129,
    133, 84, 113, 133, 146, 28, 83, 83, 131, 31, 87, 87, 132, 71, 112,
    124, 145, 87, 118, 132, 147, 30, 84, 91, 133, 32, 88, 92, 134, 73,
    113, 130, 146, 88, 119, 134, 148, 43, 67, 97, 110, 67, 101, 110, 130,
    67, 85, 110, 117, 110, 117, 143, 146, 47, 73, 126, 130, 73, 103, 130,
    142, 73, 88, 130, 134, 113, 119, 146, 148, 67, 110, 110, 143, 85,
    117, 117, 146, 101, 117, 130, 146, 117, 139, 146, 150, 73, 113, 130,
    146, 88, 119, 134, 148, 103, 119, 142, 148, 119, 140, 148, 151, 11,
    14, 36, 41, 36, 41, 42, 46, 14, 18, 41, 49, 55, 59, 66, 71, 14, 18,
    55, 59, 41, 49, 66, 71, 18, 22, 59, 61, 59, 61, 81, 84, 36, 55, 42,
    66, 42, 66, 62, 72, 41, 59, 46, 71, 66, 81, 72, 87, 41, 59, 66, 81,
    46, 71, 72, 87, 49, 61, 71, 84, 71, 84, 87, 92, 14, 18, 41, 49, 55,
    59, 66, 71, 18, 24, 49, 63, 78, 79, 99, 101, 25, 28, 69, 71, 69, 71,
    106, 107, 28, 30, 71, 73, 83, 84, 112, 113, 55, 78, 66, 99, 96, 109,
    100, 112, 59, 79, 71, 101, 109, 115, 112, 117, 69, 83, 106, 112, 122,
    124, 128, 132, 71, 84, 107, 113, 124, 125, 132, 134, 14, 18, 55, 59,
    41, 49, 66, 71, 25, 28, 69, 71, 69, 71, 106, 107, 18, 24, 78, 79, 49,
    63, 99, 101, 28, 30, 83, 84, 71, 73, 112, 113, 55, 78, 96, 109, 66,
    99, 100, 112, 69, 83, 122, 124, 106, 112, 128, 132, 59, 79, 109, 115,
    71, 101, 112, 117, 71, 84, 124, 125, 107, 113, 132, 134, 18, 22, 59,
    61, 59, 61, 81, 84, 28, 30, 71, 73, 83, 84, 112, 113, 28, 30, 83, 84,
    71, 73, 112, 113, 31, 32, 87, 88, 87, 88, 118, 119, 78, 90, 109, 129,
    109, 129, 116, 133, 83, 91, 124, 130, 131, 133, 145, 146, 83, 91,
    131, 133, 124, 130, 145, 146, 87, 92, 132, 134, 132, 134, 147, 148,
    36, 55, 42, 66, 42, 66, 62, 72, 55, 78, 66, 99, 96, 109, 100, 112,
    55, 78, 96, 109, 66, 99, 100, 112, 78, 90, 109, 129, 109, 129, 116,
    133, 42, 96, 62, 100, 62, 100, 94, 102, 66, 109, 72, 112, 100, 116,
    102, 118, 66, 109, 100, 116, 72, 112, 102, 118, 99, 129, 112, 133,
    112, 133, 118, 135, 41, 59, 46, 71, 66, 81, 72, 87, 59, 79, 71, 101,
    109, 115, 112, 117, 69, 83, 122, 124, 106, 112, 128, 132, 83, 91,
    124, 130, 131, 133, 145, 146, 66, 109, 72, 112, 100, 116, 102, 118,
    81, 115, 87, 117, 116, 138, 118, 139, 106, 131, 128, 145, 128, 145,
    141, 147, 112, 133, 132, 146, 145, 149, 147, 150, 41, 59, 66, 81, 46,
    71, 72, 87, 69, 83, 106, 112, 122, 124, 128, 132, 59, 79, 109, 115,
    71, 101, 112, 117, 83, 91, 131, 133, 124, 130, 145, 146, 66, 109,
    100, 116, 72, 112, 102, 118, 106, 131, 128, 145, 128, 145, 141, 147,
    81, 115, 116, 138, 87, 117, 118, 139, 112, 133, 145, 149, 132, 146,
    147, 150, 49, 61, 71, 84, 71, 84, 87, 92, 71, 84, 107, 113, 124, 125,
    132, 134, 71, 84, 124, 125, 107, 113, 132, 134, 87, 92, 132, 134,
    132, 134, 147, 148, 99, 129, 112, 133, 112, 133, 118, 135, 112, 133,
    132, 146, 145, 149, 147, 150, 112, 133, 145, 149, 132, 146, 147, 150,
    118, 135, 147, 150, 147, 150, 152, 153, 14, 25, 55, 69, 55, 69, 96,
    122, 18, 28, 59, 71, 78, 83, 109, 124, 18, 28, 78, 83, 59, 71, 109,
    124, 24, 30, 79, 84, 79, 84, 115, 125, 41, 69, 66, 106, 66, 106, 100,
    128, 49, 71, 71, 107, 99, 112, 112, 132, 49, 71, 99, 112, 71, 107,
    112, 132, 63, 73, 101, 113, 101, 113, 117, 134, 18, 28, 59, 71, 78,
    83, 109, 124, 22, 30, 61, 73, 90, 91, 129, 130, 28, 31, 83, 87, 83,
    87, 131, 132, 30, 32, 84, 88, 91, 92, 133, 134, 59, 83, 81, 112, 109,
    131, 116, 145, 61, 84, 84, 113, 129, 133, 133, 146, 71, 87, 112, 118,
    124, 132, 145, 147, 73, 88, 113, 119, 130, 134, 146, 148, 18, 28, 78,
    83, 59, 71, 109, 124, 28, 31, 83, 87, 83, 87, 131, 132, 22, 30, 90,
    91, 61, 73, 129, 130, 30, 32, 91, 92, 84, 88, 133, 134, 59, 83, 109,
    131, 81, 112, 116, 145, 71, 87, 124, 132, 112, 118, 145, 147, 61, 84,
    129, 133, 84, 113, 133, 146, 73, 88, 130, 134, 113, 119, 146, 148,
    24, 30, 79, 84, 79, 84, 115, 125, 30, 32, 84, 88, 91, 92, 133, 134,
    30, 32, 91, 92, 84, 88, 133, 134, 32, 33, 92, 93, 92, 93, 135, 136,
    79, 91, 115, 133, 115, 133, 138, 149, 84, 92, 125, 134, 133, 135,
    149, 150, 84, 92, 133, 135, 125, 134, 149, 150, 88, 93, 134, 136,
    134, 136, 150, 151, 41, 69, 66, 106, 66, 106, 100, 128, 59, 83, 81,
    112, 109, 131, 116, 145, 59, 83, 109, 131, 81, 112, 116, 145, 79, 91,
    115, 133, 115, 133, 138, 149, 46, 122, 72, 128, 72, 128, 102, 141,
    71, 124, 87, 132, 112, 145, 118, 147, 71, 124, 112, 145, 87, 132,
    118, 147, 101, 130, 117, 146, 117, 146, 139, 150, 49, 71, 71, 107,
    99, 112, 112, 132, 61, 84, 84, 113, 129, 133, 133, 146, 71, 87, 124,
    132, 112, 118, 145, 147, 84, 92, 125, 134, 133, 135, 149, 150, 71,
    124, 87, 132, 112, 145, 118, 147, 84, 125, 92, 134, 133, 149, 135,
    150, 107, 132, 132, 147, 132, 147, 147, 152, 113, 134, 134, 148, 146,
    150, 150, 153, 49, 71, 99, 112, 71, 107, 112, 132, 71, 87, 112, 118,
    124, 132, 145, 147, 61, 84, 129, 133, 84, 113, 133, 146, 84, 92, 133,
    135, 125, 134, 149, 150, 71, 124, 112, 145, 87, 132, 118, 147, 107,
    132, 132, 147, 132, 147, 147, 152, 84, 125, 133, 149, 92, 134, 135,
    150, 113, 134, 146, 150, 134, 148, 150, 153, 63, 73, 101, 113, 101,
    113, 117, 134, 73, 88, 113, 119, 130, 134, 146, 148, 73, 88, 130,
    134, 113, 119, 146, 148, 88, 93, 134, 136, 134, 136, 150, 151, 101,
    130, 117, 146, 117, 146, 139, 150, 113, 134, 134, 148, 146, 150, 150,
    153, 113, 134, 146, 150, 134, 148, 150, 153, 119, 136, 148, 151, 148,
    151, 153, 154, 4, 35, 13, 40, 13, 40, 39, 45, 13, 40, 17, 48, 52, 65,
    57, 70, 13, 40, 52, 65, 17, 48, 57, 70, 39, 45, 57, 70, 57, 70, 76,
    86, 7, 54, 16, 58, 16, 58, 41, 69, 16, 58, 21, 60, 53, 80, 59, 83,
    16, 58, 53, 80, 21, 60, 59, 83, 41, 69, 59, 83, 59, 83, 79, 91, 13,
    40, 17, 48, 52, 65, 57, 70, 17, 48, 23, 62, 75, 98, 76, 100, 52, 65,
    75, 98, 75, 98, 108, 111, 57, 70, 76, 100, 108, 111, 114, 116, 20,
    68, 27, 70, 58, 105, 66, 106, 27, 70, 29, 72, 80, 111, 81, 112, 58,
    105, 80, 111, 82, 127, 109, 131, 66, 106, 81, 112, 109, 131, 115,
    133, 13, 40, 52, 65, 17, 48, 57, 70, 52, 65, 75, 98, 75, 98, 108,
    111, 17, 48, 75, 98, 23, 62, 76, 100, 57, 70, 108, 111, 76, 100, 114,
    116, 20, 68, 58, 105, 27, 70, 66, 106, 58, 105, 82, 127, 80, 111,
    109, 131, 27, 70, 80, 111, 29, 72, 81, 112, 66, 106, 109, 131, 81,
    112, 115, 133, 39, 45, 57, 70, 57, 70, 76, 86, 57, 70, 76, 100, 108,
    111, 114, 116, 57, 70, 108, 111, 76, 100, 114, 116, 76, 86, 114, 116,
    114, 116, 137, 138, 45, 121, 70, 123, 70, 123, 100, 128, 70, 123, 86,
    128, 111, 144, 116, 145, 70, 123, 111, 144, 86, 128, 116, 145, 100,
    128, 116, 145, 116, 145, 138, 149, 7, 54, 16, 58, 16, 58, 41, 69, 20,
    68, 27, 70, 58, 105, 66, 106, 20, 68, 58, 105, 27, 70, 66, 106, 45,
    121, 70, 123, 70, 123, 100, 128, 9, 77, 18, 78, 18, 78, 43, 97, 21,
    82, 28, 83, 59, 109, 67, 110, 21, 82, 59, 109, 28, 83, 67, 110, 46,
    122, 71, 124, 71, 124, 101, 130, 16, 58, 21, 60, 53, 80, 59, 83, 27,
    70, 29, 72, 80, 111, 81, 112, 58, 105, 82, 127, 80, 111, 109, 131,
    70, 123, 86, 128, 111, 144, 116, 145, 21, 82, 28, 83, 59, 109, 67,
    110, 29, 86, 31, 87, 81, 116, 85, 117, 60, 127, 83, 131, 83, 131,
    110, 143, 72, 128, 87, 132, 112, 145, 117, 146, 16, 58, 53, 80, 21,
    60, 59, 83, 58, 105, 80, 111, 82, 127, 109, 131, 27, 70, 80, 111, 29,
    72, 81, 112, 70, 123, 111, 144, 86, 128, 116, 145, 21, 82, 59, 109,
    28, 83, 67, 110, 60, 127, 83, 131, 83, 131, 110, 143, 29, 86, 81,
    116, 31, 87, 85, 117, 72, 128, 112, 145, 87, 132, 117, 146, 41, 69,
    59, 83, 59, 83, 79, 91, 66, 106, 81, 112, 109, 131, 115, 133, 66,
    106, 109, 131, 81, 112, 115, 133, 100, 128, 116, 145, 116, 145, 138,
    149, 46, 122, 71, 124, 71, 124, 101, 130, 72, 128, 87, 132, 112, 145,
    117, 146, 72, 128, 112, 145, 87, 132, 117, 146, 102, 141, 118, 147,
    118, 147, 139, 150, 7, 54, 20, 68, 20, 68, 45, 121, 16, 58, 27, 70,
    58, 105, 70, 123, 16, 58, 58, 105, 27, 70, 70, 123, 41, 69, 66, 106,
    66, 106, 100, 128, 9, 77, 21, 82, 21, 82, 46, 122, 18, 78, 28, 83,
    59, 109, 71, 124, 18, 78, 59, 109, 28, 83, 71, 124, 43, 97, 67, 110,
    67, 110, 101, 130, 16, 58, 27, 70, 58, 105, 70, 123, 21, 60, 29, 72,
    82, 127, 86, 128, 53, 80, 80, 111, 80, 111, 111, 144, 59, 83, 81,
    112, 109, 131, 116, 145, 21, 82, 29, 86, 60, 127, 72, 128, 28, 83,
    31, 87, 83, 131, 87, 132, 59, 109, 81, 116, 83, 131, 112, 145, 67,
    110, 85, 117, 110, 143, 117, 146, 16, 58, 58, 105, 27, 70, 70, 123,
    53, 80, 80, 111, 80, 111, 111, 144, 21, 60, 82, 127, 29, 72, 86, 128,
    59, 83, 109, 131, 81, 112, 116, 145, 21, 82, 60, 127, 29, 86, 72,
    128, 59, 109, 83, 131, 81, 116, 112, 145, 28, 83, 83, 131, 31, 87,
    87, 132, 67, 110, 110, 143, 85, 117, 117, 146, 41, 69, 66, 106, 66,
    106, 100, 128, 59, 83, 81, 112, 109, 131, 116, 145, 59, 83, 109, 131,
    81, 112, 116, 145, 79, 91, 115, 133, 115, 133, 138, 149, 46, 122, 72,
    128, 72, 128, 102, 141, 71, 124, 87, 132, 112, 145, 118, 147, 71,
    124, 112, 145, 87, 132, 118, 147, 101, 130, 117, 146, 117, 146, 139,
    150, 9, 77, 21, 82, 21, 82, 46, 122, 21, 82, 29, 86, 60, 127, 72,
    128, 21, 82, 60, 127, 29, 86, 72, 128, 46, 122, 72, 128, 72, 128,
    102, 141, 10, 89, 22, 90, 22, 90, 47, 126, 22, 90, 30, 91, 61, 129,
    73, 130, 22, 90, 61, 129, 30, 91, 73, 130, 47, 126, 73, 130, 73, 130,
    103, 142, 18, 78, 28, 83, 59, 109, 71, 124, 28, 83, 31, 87, 83, 131,
    87, 132, 59, 109, 83, 131, 81, 116, 112, 145, 71, 124, 87, 132, 112,
    145, 118, 147, 22, 90, 30, 91, 61, 129, 73, 130, 30, 91, 32, 92, 84,
    133, 88, 134, 61, 129, 84, 133, 84, 133, 113, 146, 73, 130, 88, 134,
    113, 146, 119, 148, 18, 78, 59, 109, 28, 83, 71, 124, 59, 109, 81,
    116, 83, 131, 112, 145, 28, 83, 83, 131, 31, 87, 87, 132, 71, 124,
    112, 145, 87, 132, 118, 147, 22, 90, 61, 129, 30, 91, 73, 130, 61,
    129, 84, 133, 84, 133, 113, 146, 30, 91, 84, 133, 32, 92, 88, 134,
    73, 130, 113, 146, 88, 134, 119, 148, 43, 97, 67, 110, 67, 110, 101,
    130, 67, 110, 85, 117, 110, 143, 117, 146, 67, 110, 110, 143, 85,
    117, 117, 146, 101, 130, 117, 146, 117, 146, 139, 150, 47, 126, 73,
    130, 73, 130, 103, 142, 73, 130, 88, 134, 113, 146, 119, 148, 73,
    130, 113, 146, 88, 134, 119, 148, 103, 142, 119, 148, 119, 148, 140,
    151, 11, 36, 14, 41, 36, 42, 41, 46, 14, 41, 18, 49, 55, 66, 59, 71,
    36, 42, 55, 66, 42, 62, 66, 72, 41, 46, 59, 71, 66, 72, 81, 87, 14,
    55, 18, 59, 41, 66, 49, 71, 18, 59, 22, 61, 59, 81, 61, 84, 41, 66,
    59, 81, 46, 72, 71, 87, 49, 71, 61, 84, 71, 87, 84, 92, 14, 41, 18,
    49, 55, 66, 59, 71, 18, 49, 24, 63, 78, 99, 79, 101, 55, 66, 78, 99,
    96, 100, 109, 112, 59, 71, 79, 101, 109, 112, 115, 117, 25, 69, 28,
    71, 69, 106, 71, 107, 28, 71, 30, 73, 83, 112, 84, 113, 69, 106, 83,
    112, 122, 128, 124, 132, 71, 107, 84, 113, 124, 132, 125, 134, 36,
    42, 55, 66, 42, 62, 66, 72, 55, 66, 78, 99, 96, 100, 109, 112, 42,
    62, 96, 100, 62, 94, 100, 102, 66, 72, 109, 112, 100, 102, 116, 118,
    55, 96, 78, 109, 66, 100, 99, 112, 78, 109, 90, 129, 109, 116, 129,
    133, 66, 100, 109, 116, 72, 102, 112, 118, 99, 112, 129, 133, 112,
    118, 133, 135, 41, 46, 59, 71, 66, 72, 81, 87, 59, 71, 79, 101, 109,
    112, 115, 117, 66, 72, 109, 112, 100, 102, 116, 118, 81, 87, 115,
    117, 116, 118, 138, 139, 69, 122, 83, 124, 106, 128, 112, 132, 83,
    124, 91, 130, 131, 145, 133, 146, 106, 128, 131, 145, 128, 141, 145,
    147, 112, 132, 133, 146, 145, 147, 149, 150, 14, 55, 18, 59, 41, 66,
    49, 71, 25, 69, 28, 71, 69, 106, 71, 107, 55, 96, 78, 109, 66, 100,
    99, 112, 69, 122, 83, 124, 106, 128, 112, 132, 18, 78, 24, 79, 49,
    99, 63, 101, 28, 83, 30, 84, 71, 112, 73, 113, 59, 109, 79, 115, 71,
    112, 101, 117, 71, 124, 84, 125, 107, 132, 113, 134, 18, 59, 22, 61,
    59, 81, 61, 84, 28, 71, 30, 73, 83, 112, 84, 113, 78, 109, 90, 129,
    109, 116, 129, 133, 83, 124, 91, 130, 131, 145, 133, 146, 28, 83, 30,
    84, 71, 112, 73, 113, 31, 87, 32, 88, 87, 118, 88, 119, 83, 131, 91,
    133, 124, 145, 130, 146, 87, 132, 92, 134, 132, 147, 134, 148, 41,
    66, 59, 81, 46, 72, 71, 87, 69, 106, 83, 112, 122, 128, 124, 132, 66,
    100, 109, 116, 72, 102, 112, 118, 106, 128, 131, 145, 128, 141, 145,
    147, 59, 109, 79, 115, 71, 112, 101, 117, 83, 131, 91, 133, 124, 145,
    130, 146, 81, 116, 115, 138, 87, 118, 117, 139, 112, 145, 133, 149,
    132, 147, 146, 150, 49, 71, 61, 84, 71, 87, 84, 92, 71, 107, 84, 113,
    124, 132, 125, 134, 99, 112, 129, 133, 112, 118, 133, 135, 112, 132,
    133, 146, 145, 147, 149, 150, 71, 124, 84, 125, 107, 132, 113, 134,
    87, 132, 92, 134, 132, 147, 134, 148, 112, 145, 133, 149, 132, 147,
    146, 150, 118, 147, 135, 150, 147, 152, 150, 153, 14, 55, 25, 69, 55,
    96, 69, 122, 18, 59, 28, 71, 78, 109, 83, 124, 41, 66, 69, 106, 66,
    100, 106, 128, 49, 71, 71, 107, 99, 112, 112, 132, 18, 78, 28, 83,
    59, 109, 71, 124, 24, 79, 30, 84, 79, 115, 84, 125, 49, 99, 71, 112,
    71, 112, 107, 132, 63, 101, 73, 113, 101, 117, 113, 134, 18, 59, 28,
    71, 78, 109, 83, 124, 22, 61, 30, 73, 90, 129, 91, 130, 59, 81, 83,
    112, 109, 116, 131, 145, 61, 84, 84, 113, 129, 133, 133, 146, 28, 83,
    31, 87, 83, 131, 87, 132, 30, 84, 32, 88, 91, 133, 92, 134, 71, 112,
    87, 118, 124, 145, 132, 147, 73, 113, 88, 119, 130, 146, 134, 148,
    41, 66, 69, 106, 66, 100, 106, 128, 59, 81, 83, 112, 109, 116, 131,
    145, 46, 72, 122, 128, 72, 102, 128, 141, 71, 87, 124, 132, 112, 118,
    145, 147, 59, 109, 83, 131, 81, 116, 112, 145, 79, 115, 91, 133, 115,
    138, 133, 149, 71, 112, 124, 145, 87, 118, 132, 147, 101, 117, 130,
    146, 117, 139, 146, 150, 49, 71, 71, 107, 99, 112, 112, 132, 61, 84,
    84, 113, 129, 133, 133, 146, 71, 87, 124, 132, 112, 118, 145, 147,
    84, 92, 125, 134, 133, 135, 149, 150, 71, 124, 87, 132, 112, 145,
    118, 147, 84, 125, 92, 134, 133, 149, 135, 150, 107, 132, 132, 147,
    132, 147, 147, 152, 113, 134, 134, 148, 146, 150, 150, 153, 18, 78,
    28, 83, 59, 109, 71, 124, 28, 83, 31, 87, 83, 131, 87, 132, 59, 109,
    83, 131, 81, 116, 112, 145, 71, 124, 87, 132, 112, 145, 118, 147, 22,
    90, 30, 91, 61, 129, 73, 130, 30, 91, 32, 92, 84, 133, 88, 134, 61,
    129, 84, 133, 84, 133, 113, 146, 73, 130, 88, 134, 113, 146, 119,
    148, 24, 79, 30, 84, 79, 115, 84, 125, 30, 84, 32, 88, 91, 133, 92,
    134, 79, 115, 91, 133, 115, 138, 133, 149, 84, 125, 92, 134, 133,
    149, 135, 150, 30, 91, 32, 92, 84, 133, 88, 134, 32, 92, 33, 93, 92,
    135, 93, 136, 84, 133, 92, 135, 125, 149, 134, 150, 88, 134, 93, 136,
    134, 150, 136, 151, 49, 99, 71, 112, 71, 112, 107, 132, 71, 112, 87,
    118, 124, 145, 132, 147, 71, 112, 124, 145, 87, 118, 132, 147, 107,
    132, 132, 147, 132, 147, 147, 152, 61, 129, 84, 133, 84, 133, 113,
    146, 84, 133, 92, 135, 125, 149, 134, 150, 84, 133, 125, 149, 92,
    135, 134, 150, 113, 146, 134, 150, 134, 150, 148, 153, 63, 101, 73,
    113, 101, 117, 113, 134, 73, 113, 88, 119, 130, 146, 134, 148, 101,
    117, 130, 146, 117, 139, 146, 150, 113, 134, 134, 148, 146, 150, 150,
    153, 73, 130, 88, 134, 113, 146, 119, 148, 88, 134, 93, 136, 134,
    150, 136, 151, 113, 146, 134, 150, 134, 150, 148, 153, 119, 148, 136,
    151, 148, 153, 151, 154, 11, 36, 36, 42, 14, 41, 41, 46, 36, 42, 42,
    62, 55, 66, 66, 72, 14, 41, 55, 66, 18, 49, 59, 71, 41, 46, 66, 72,
    59, 71, 81, 87, 14, 55, 41, 66, 18, 59, 49, 71, 41, 66, 46, 72, 59,
    81, 71, 87, 18, 59, 59, 81, 22, 61, 61, 84, 49, 71, 71, 87, 61, 84,
    84, 92, 36, 42, 42, 62, 55, 66, 66, 72, 42, 62, 62, 94, 96, 100, 100,
    102, 55, 66, 96, 100, 78, 99, 109, 112, 66, 72, 100, 102, 109, 112,
    116, 118, 55, 96, 66, 100, 78, 109, 99, 112, 66, 100, 72, 102, 109,
    116, 112, 118, 78, 109, 109, 116, 90, 129, 129, 133, 99, 112, 112,
    118, 129, 133, 133, 135, 14, 41, 55, 66, 18, 49, 59, 71, 55, 66, 96,
    100, 78, 99, 109, 112, 18, 49, 78, 99, 24, 63, 79, 101, 59, 71, 109,
    112, 79, 101, 115, 117, 25, 69, 69, 106, 28, 71, 71, 107, 69, 106,
    122, 128, 83, 112, 124, 132, 28, 71, 83, 112, 30, 73, 84, 113, 71,
    107, 124, 132, 84, 113, 125, 134, 41, 46, 66, 72, 59, 71, 81, 87, 66,
    72, 100, 102, 109, 112, 116, 118, 59, 71, 109, 112, 79, 101, 115,
    117, 81, 87, 116, 118, 115, 117, 138, 139, 69, 122, 106, 128, 83,
    124, 112, 132, 106, 128, 128, 141, 131, 145, 145, 147, 83, 124, 131,
    145, 91, 130, 133, 146, 112, 132, 145, 147, 133, 146, 149, 150, 14,
    55, 41, 66, 18, 59, 49, 71, 55, 96, 66, 100, 78, 109, 99, 112, 25,
    69, 69, 106, 28, 71, 71, 107, 69, 122, 106, 128, 83, 124, 112, 132,
    18, 78, 49, 99, 24, 79, 63, 101, 59, 109, 71, 112, 79, 115, 101, 117,
    28, 83, 71, 112, 30, 84, 73, 113, 71, 124, 107, 132, 84, 125, 113,
    134, 41, 66, 46, 72, 59, 81, 71, 87, 66, 100, 72, 102, 109, 116, 112,
    118, 69, 106, 122, 128, 83, 112, 124, 132, 106, 128, 128, 141, 131,
    145, 145, 147, 59, 109, 71, 112, 79, 115, 101, 117, 81, 116, 87, 118,
    115, 138, 117, 139, 83, 131, 124, 145, 91, 133, 130, 146, 112, 145,
    132, 147, 133, 149, 146, 150, 18, 59, 59, 81, 22, 61, 61, 84, 78,
    109, 109, 116, 90, 129, 129, 133, 28, 71, 83, 112, 30, 73, 84, 113,
    83, 124, 131, 145, 91, 130, 133, 146, 28, 83, 71, 112, 30, 84, 73,
    113, 83, 131, 124, 145, 91, 133, 130, 146, 31, 87, 87, 118, 32, 88,
    88, 119, 87, 132, 132, 147, 92, 134, 134, 148, 49, 71, 71, 87, 61,
    84, 84, 92, 99, 112, 112, 118, 129, 133, 133, 135, 71, 107, 124, 132,
    84, 113, 125, 134, 112, 132, 145, 147, 133, 146, 149, 150, 71, 124,
    107, 132, 84, 125, 113, 134, 112, 145, 132, 147, 133, 149, 146, 150,
    87, 132, 132, 147, 92, 134, 134, 148, 118, 147, 147, 152, 135, 150,
    150, 153, 14, 55, 55, 96, 25, 69, 69, 122, 41, 66, 66, 100, 69, 106,
    106, 128, 18, 59, 78, 109, 28, 71, 83, 124, 49, 71, 99, 112, 71, 107,
    112, 132, 18, 78, 59, 109, 28, 83, 71, 124, 49, 99, 71, 112, 71, 112,
    107, 132, 24, 79, 79, 115, 30, 84, 84, 125, 63, 101, 101, 117, 73,
    113, 113, 134, 41, 66, 66, 100, 69, 106, 106, 128, 46, 72, 72, 102,
    122, 128, 128, 141, 59, 81, 109, 116, 83, 112, 131, 145, 71, 87, 112,
    118, 124, 132, 145, 147, 59, 109, 81, 116, 83, 131, 112, 145, 71,
    112, 87, 118, 124, 145, 132, 147, 79, 115, 115, 138, 91, 133, 133,
    149, 101, 117, 117, 139, 130, 146, 146, 150, 18, 59, 78, 109, 28, 71,
    83, 124, 59, 81, 109, 116, 83, 112, 131, 145, 22, 61, 90, 129, 30,
    73, 91, 130, 61, 84, 129, 133, 84, 113, 133, 146, 28, 83, 83, 131,
    31, 87, 87, 132, 71, 112, 124, 145, 87, 118, 132, 147, 30, 84, 91,
    133, 32, 88, 92, 134, 73, 113, 130, 146, 88, 119, 134, 148, 49, 71,
    99, 112, 71, 107, 112, 132, 71, 87, 112, 118, 124, 132, 145, 147, 61,
    84, 129, 133, 84, 113, 133, 146, 84, 92, 133, 135, 125, 134, 149,
    150, 71, 124, 112, 145, 87, 132, 118, 147, 107, 132, 132, 147, 132,
    147, 147, 152, 84, 125, 133, 149, 92, 134, 135, 150, 113, 134, 146,
    150, 134, 148, 150, 153, 18, 78, 59, 109, 28, 83, 71, 124, 59, 109,
    81, 116, 83, 131, 112, 145, 28, 83, 83, 131, 31, 87, 87, 132, 71,
    124, 112, 145, 87, 132, 118, 147, 22, 90, 61, 129, 30, 91, 73, 130,
    61, 129, 84, 133, 84, 133, 113, 146, 30, 91, 84, 133, 32, 92, 88,
    134, 73, 130, 113, 146, 88, 134, 119, 148, 49, 99, 71, 112, 71, 112,
    107, 132, 71, 112, 87, 118, 124, 145, 132, 147, 71, 112, 124, 145,
    87, 118, 132, 147, 107, 132, 132, 147, 132, 147, 147, 152, 61, 129,
    84, 133, 84, 133, 113, 146, 84, 133, 92, 135, 125, 149, 134, 150, 84,
    133, 125, 149, 92, 135, 134, 150, 113, 146, 134, 150, 134, 150, 148,
    153, 24, 79, 79, 115, 30, 84, 84, 125, 79, 115, 115, 138, 91, 133,
    133, 149, 30, 84, 91, 133, 32, 88, 92, 134, 84, 125, 133, 149, 92,
    134, 135, 150, 30, 91, 84, 133, 32, 92, 88, 134, 84, 133, 125, 149,
    92, 135, 134, 150, 32, 92, 92, 135, 33, 93, 93, 136, 88, 134, 134,
    150, 93, 136, 136, 151, 63, 101, 101, 117, 73, 113, 113, 134, 101,
    117, 117, 139, 130, 146, 146, 150, 73, 113, 130, 146, 88, 119, 134,
    148, 113, 134, 146, 150, 134, 148, 150, 153, 73, 130, 113, 146, 88,
    134, 119, 148, 113, 146, 134, 150, 134, 150, 148, 153, 88, 134, 134,
    150, 93, 136, 136, 151, 119, 148, 148, 153, 136, 151, 151, 154, 34,
    37, 37, 43, 37, 43, 43, 47, 37, 43, 43, 63, 64, 67, 67, 73, 37, 43,
    64, 67, 43, 63, 67, 73, 43, 47, 67, 73, 67, 73, 85, 88, 37, 64, 43,
    67, 43, 67, 63, 73, 43, 67, 47, 73, 67, 85, 73, 88, 43, 67, 67, 85,
    47, 73, 73, 88, 63, 73, 73, 88, 73, 88, 88, 93, 37, 43, 43, 63, 64,
    67, 67, 73, 43, 63, 63, 95, 97, 101, 101, 103, 64, 67, 97, 101, 97,
    101, 110, 113, 67, 73, 101, 103, 110, 113, 117, 119, 64, 97, 67, 101,
    97, 110, 101, 113, 67, 101, 73, 103, 110, 117, 113, 119, 97, 110,
    110, 117, 126, 130, 130, 134, 101, 113, 113, 119, 130, 134, 134, 136,
    37, 43, 64, 67, 43, 63, 67, 73, 64, 67, 97, 101, 97, 101, 110, 113,
    43, 63, 97, 101, 63, 95, 101, 103, 67, 73, 110, 113, 101, 103, 117,
    119, 64, 97, 97, 110, 67, 101, 101, 113, 97, 110, 126, 130, 110, 117,
    130, 134, 67, 101, 110, 117, 73, 103, 113, 119, 101, 113, 130, 134,
    113, 119, 134, 136, 43, 47, 67, 73, 67, 73, 85, 88, 67, 73, 101, 103,
    110, 113, 117, 119, 67, 73, 110, 113, 101, 103, 117, 119, 85, 88,
    117, 119, 117, 119, 139, 140, 97, 126, 110, 130, 110, 130, 117, 134,
    110, 130, 130, 142, 143, 146, 146, 148, 110, 130, 143, 146, 130, 142,
    146, 148, 117, 134, 146, 148, 146, 148, 150, 151, 37, 64, 43, 67, 43,
    67, 63, 73, 64, 97, 67, 101, 97, 110, 101, 113, 64, 97, 97, 110, 67,
    101, 101, 113, 97, 126, 110, 130, 110, 130, 117, 134, 43, 97, 63,
    101, 63, 101, 95, 103, 67, 110, 73, 113, 101, 117, 103, 119, 67, 110,
    101, 117, 73, 113, 103, 119, 101, 130, 113, 134, 113, 134, 119, 136,
    43, 67, 47, 73, 67, 85, 73, 88, 67, 101, 73, 103, 110, 117, 113, 119,
    97, 110, 126, 130, 110, 117, 130, 134, 110, 130, 130, 142, 143, 146,
    146, 148, 67, 110, 73, 113, 101, 117, 103, 119, 85, 117, 88, 119,
    117, 139, 119, 140, 110, 143, 130, 146, 130, 146, 142, 148, 117, 146,
    134, 148, 146, 150, 148, 151, 43, 67, 67, 85, 47, 73, 73, 88, 97,
    110, 110, 117, 126, 130, 130, 134, 67, 101, 110, 117, 73, 103, 113,
    119, 110, 130, 143, 146, 130, 142, 146, 148, 67, 110, 101, 117, 73,
    113, 103, 119, 110, 143, 130, 146, 130, 146, 142, 148, 85, 117, 117,
    139, 88, 119, 119, 140, 117, 146, 146, 150, 134, 148, 148, 151, 63,
    73, 73, 88, 73, 88, 88, 93, 101, 113, 113, 119, 130, 134, 134, 136,
    101, 113, 130, 134, 113, 119, 134, 136, 117, 134, 146, 148, 146, 148,
    150, 151, 101, 130, 113, 134, 113, 134, 119, 136, 117, 146, 134, 148,
    146, 150, 148, 151, 117, 146, 146, 150, 134, 148, 148, 151, 139, 150,
    150, 153, 150, 153, 153, 154, 37, 64, 64, 97, 64, 97, 97, 126, 43,
    67, 67, 101, 97, 110, 110, 130, 43, 67, 97, 110, 67, 101, 110, 130,
    63, 73, 101, 113, 101, 113, 117, 134, 43, 97, 67, 110, 67, 110, 101,
    130, 63, 101, 73, 113, 101, 117, 113, 134, 63, 101, 101, 117, 73,
    113, 113, 134, 95, 103, 103, 119, 103, 119, 119, 136, 43, 67, 67,
    101, 97, 110, 110, 130, 47, 73, 73, 103, 126, 130, 130, 142, 67, 85,
    110, 117, 110, 117, 143, 146, 73, 88, 113, 119, 130, 134, 146, 148,
    67, 110, 85, 117, 110, 143, 117, 146, 73, 113, 88, 119, 130, 146,
    134, 148, 101, 117, 117, 139, 130, 146, 146, 150, 103, 119, 119, 140,
    142, 148, 148, 151, 43, 67, 97, 110, 67, 101, 110, 130, 67, 85, 110,
    117, 110, 117, 143, 146, 47, 73, 126, 130, 73, 103, 130, 142, 73, 88,
    130, 134, 113, 119, 146, 148, 67, 110, 110, 143, 85, 117, 117, 146,
    101, 117, 130, 146, 117, 139, 146, 150, 73, 113, 130, 146, 88, 119,
    134, 148, 103, 119, 142, 148, 119, 140, 148, 151, 63, 73, 101, 113,
    101, 113, 117, 134, 73, 88, 113, 119, 130, 134, 146, 148, 73, 88,
    130, 134, 113, 119, 146, 148, 88, 93, 134, 136, 134, 136, 150, 151,
    101, 130, 117, 146, 117, 146, 139, 150, 113, 134, 134, 148, 146, 150,
    150, 153, 113, 134, 146, 150, 134, 148, 150, 153, 119, 136, 148, 151,
    148, 151, 153, 154, 43, 97, 67, 110, 67, 110, 101, 130, 67, 110, 85,
    117, 110, 143, 117, 146, 67, 110, 110, 143, 85, 117, 117, 146, 101,
    130, 117, 146, 117, 146, 139, 150, 47, 126, 73, 130, 73, 130, 103,
    142, 73, 130, 88, 134, 113, 146, 119, 148, 73, 130, 113, 146, 88,
    134, 119, 148, 103, 142, 119, 148, 119, 148, 140, 151, 63, 101, 73,
    113, 101, 117, 113, 134, 73, 113, 88, 119, 130, 146, 134, 148, 101,
    117, 130, 146, 117, 139, 146, 150, 113, 134, 134, 148, 146, 150, 150,
    153, 73, 130, 88, 134, 113, 146, 119, 148, 88, 134, 93, 136, 134,
    150, 136, 151, 113, 146, 134, 150, 134, 150, 148, 153, 119, 148, 136,
    151, 148, 153, 151, 154, 63, 101, 101, 117, 73, 113, 113, 134, 101,
    117, 117, 139, 130, 146, 146, 150, 73, 113, 130, 146, 88, 119, 134,
    148, 113, 134, 146, 150, 134, 148, 150, 153, 73, 130, 113, 146, 88,
    134, 119, 148, 113, 146, 134, 150, 134, 150, 148, 153, 88, 134, 134,
    150, 93, 136, 136, 151, 119, 148, 148, 153, 136, 151, 151, 154, 95,
    103, 103, 119, 103, 119, 119, 136, 103, 119, 119, 140, 142, 148, 148,
    151, 103, 119, 142, 148, 119, 140, 148, 151, 119, 136, 148, 151, 148,
    151, 153, 154, 103, 142, 119, 148, 119, 148, 140, 151, 119, 148, 136,
    151, 148, 153, 151, 154, 119, 148, 148, 153, 136, 151, 151, 154, 140,
    151, 151, 154, 151, 154, 154, 155
};

const unsigned int igraph_i_isographs_3[] =  { 0, 1, 3, 5, 6, 7, 10, 11, 15, 21,
                                               23, 25, 27, 30, 31, 63
                                             };
const unsigned int igraph_i_isographs_3u[] = { 0, 1, 3, 7 };
const unsigned int igraph_i_isographs_4[] = {
    0,    1,    3,    7,    9,   10,   11,   14,   15,   18,   19,   20,   21,
    22,   23,   27,   29,   30,   31,   54,   55,   63,   73,   75,   76,   77,
    79,   81,   83,   84,   85,   86,   87,   90,   91,   92,   93,   94,   95,
    98,   99,  100,  101,  102,  103,  106,  107,  108,  109,  110,  111,  115,
    116,  117,  118,  119,  122,  123,  124,  125,  126,  127,  219,  220,  221,
    223,  228,  229,  230,  231,  237,  238,  239,  246,  247,  255,  292,  293,
    295,  301,  302,  303,  310,  311,  319,  365,  367,  373,  375,  382,  383,
    511,  585,  587,  591,  593,  594,  595,  596,  597,  598,  599,  601,  602,
    603,  604,  605,  606,  607,  625,  626,  627,  630,  631,  633,  634,  635,
    638,  639,  659,  660,  661,  663,  666,  667,  669,  670,  671,  674,  675,
    678,  679,  683,  686,  687,  694,  695,  703,  729,  731,  732,  733,  735,
    737,  739,  741,  742,  743,  745,  746,  747,  748,  749,  750,  751,  753,
    755,  756,  757,  758,  759,  761,  762,  763,  764,  765,  766,  767,  819,
    822,  823,  826,  827,  830,  831,  875,  876,  877,  879,  883,  885,  886,
    887,  891,  892,  893,  894,  895,  947,  949,  951,  955,  957,  958,  959,
    1019, 1020, 1021, 1023, 1755, 1757, 1758, 1759, 1782, 1783, 1791, 1883, 1887,
    1907, 1911, 1917, 1918, 1919, 2029, 2031, 2039, 2047, 4095
};
const unsigned int igraph_i_isographs_4u[] = { 0, 1, 3, 7, 11, 12, 13,
                                               15, 30, 31, 63
                                             };
const unsigned int igraph_i_isographs_5u[] = {
    0, 1, 3, 7, 11, 12, 13, 15, 30, 31, 63, 75, 76, 77, 79, 86, 87, 94,
    95, 116, 117, 119, 127, 222, 223, 235, 236, 237, 239, 254, 255, 507,
    511, 1023
};
const unsigned int igraph_i_isographs_6u[] = {
    0, 1, 3, 7, 11, 12, 13, 15, 30, 31, 63, 75, 76, 77, 79, 86, 87, 94,
    95, 116, 117, 119, 127, 222, 223, 235, 236, 237, 239, 254, 255, 507,
    511, 1023, 1099, 1100, 1101, 1103, 1108, 1109, 1110, 1111, 1118,
    1119, 1140, 1141, 1143, 1151, 1182, 1183, 1184, 1185, 1187, 1191,
    1194, 1195, 1196, 1197, 1198, 1199, 1214, 1215, 1246, 1247, 1259,
    1260, 1261, 1263, 1268, 1269, 1270, 1271, 1278, 1279, 1456, 1457,
    1459, 1460, 1461, 1463, 1465, 1467, 1468, 1469, 1471, 1531, 1532,
    1533, 1535, 1972, 1973, 1975, 1983, 2047, 3294, 3295, 3306, 3307,
    3308, 3309, 3310, 3311, 3326, 3327, 3440, 3441, 3443, 3447, 3448,
    3449, 3451, 3452, 3453, 3455, 3576, 3577, 3578, 3579, 3582, 3583,
    3873, 3875, 3879, 3885, 3887, 3903, 3947, 3948, 3949, 3950, 3951,
    3958, 3959, 3966, 3967, 4094, 4095, 7672, 7673, 7675, 7679, 7902,
    7903, 7915, 7916, 7917, 7919, 7934, 7935, 8185, 8187, 8191, 16350,
    16351, 16383, 32767
};

const unsigned int igraph_i_classedges_3[] = { 1, 2, 0, 2, 2, 1, 0, 1, 2, 0, 1, 0 };
const unsigned int igraph_i_classedges_3u[] = { 1, 2, 0, 2, 0, 1 };
const unsigned int igraph_i_classedges_4[] = { 2, 3, 1, 3, 0, 3, 3, 2, 1, 2, 0, 2,
                                               3, 1, 2, 1, 0, 1, 3, 0, 2, 0, 1, 0
                                             };
const unsigned int igraph_i_classedges_4u[] = { 2, 3, 1, 3, 0, 3, 1, 2, 0, 2, 0, 1 };
const unsigned int igraph_i_classedges_5u[] = { 3, 4, 2, 4, 1, 4, 0, 4, 2, 3, 1, 3,
                                                0, 3, 1, 2, 0, 2, 0, 1 };
const unsigned int igraph_i_classedges_6u[] = { 4, 5, 3, 5, 2, 5, 1, 5, 0, 5, 3, 4,
                                                2, 4, 1, 4, 0, 4, 2, 3, 1, 3, 0, 3,
                                                1, 2, 0, 2, 0, 1 };

/**
 * \function igraph_isoclass
 * \brief Determine the isomorphism class of small graphs.
 *
 * 
 * All graphs with a given number of vertices belong to a number of
 * isomorphism classes, with every graph in a given class being
 * isomorphic to each other.
 *
 * 
 * This function gives the isomorphism class (a number) of a
 * graph. Two graphs have the same isomorphism class if and only if
 * they are isomorphic.
 *
 * 
 * The first isomorphism class is numbered zero and it contains the edgeless
 * graph. The last isomorphism class contains the full graph. The number of
 * isomorphism classes for directed graphs with three vertices is 16
 * (between 0 and 15), for undirected graph it is only 4. For graphs
 * with four vertices it is 218 (directed) and 11 (undirected).
 * For 5 and 6 vertex undirected graphs, it is 34 and 156, respectively.
 * For more information, see https://oeis.org/A000273 and https://oeis.org/A000088.
 *
 * 
 * At the moment, 3- and 4-vertex directed graphs and 3 to 6 vertex
 * undirected graphs are supported.
 *
 * 
 * Multi-edges and self-loops are ignored by this function.
 *
 * \param graph The graph object.
 * \param isoclass Pointer to an integer, the isomorphism class will
 *        be stored here.
 * \return Error code.
 * \sa \ref igraph_isomorphic(), \ref igraph_isoclass_subgraph(),
 * \ref igraph_isoclass_create(), \ref igraph_motifs_randesu().
 *
 * Because of some limitations this function works only for graphs
 * with three of four vertices.
 *
 * 
 * Time complexity: O(|E|), the number of edges in the graph.
 */
int igraph_isoclass(const igraph_t *graph, igraph_integer_t *isoclass) {
    long int e;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    unsigned int idx, mul;
    const unsigned int *arr_idx, *arr_code;
    unsigned int code;

    if (igraph_is_directed(graph)) {
        switch (no_of_nodes) {
        case 3:
            arr_idx = igraph_i_isoclass_3_idx;
            arr_code = igraph_i_isoclass2_3;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4_idx;
            arr_code = igraph_i_isoclass2_4;
            mul = 4;
            break;
        default:
            IGRAPH_ERROR("Directed isoclass is only implemented for graphs with 3 or 4 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }
    } else {
        switch (no_of_nodes) {
        case 3:
            arr_idx = igraph_i_isoclass_3u_idx;
            arr_code = igraph_i_isoclass2_3u;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4u_idx;
            arr_code = igraph_i_isoclass2_4u;
            mul = 4;
            break;
        case 5:
            arr_idx = igraph_i_isoclass_5u_idx;
            arr_code = igraph_i_isoclass2_5u;
            mul = 5;
            break;
        case 6:
            arr_idx = igraph_i_isoclass_6u_idx;
            arr_code = igraph_i_isoclass2_6u;
            mul = 6;
            break;
        default:
            IGRAPH_ERROR("Undirected isoclass is only implemented for graphs with 3 to 6 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }
    }

    code = 0;
    for (e = 0; e < no_of_edges; e++) {
        idx = mul * IGRAPH_FROM(graph, e) + IGRAPH_TO(graph, e);
        code |= arr_idx[idx];
    }

    *isoclass = (igraph_integer_t) arr_code[code];

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_isoclass_subgraph
 * \brief The isomorphism class of a subgraph of a graph.
 *
 * This function identifies the isomorphism class of the subgraph
 * induced the vertices specified in \p vids.
 *
 * 
 * At the moment, 3- and 4-vertex directed graphs and 3 to 6 vertex
 * undirected graphs are supported.
 *
 * 
 * Multi-edges and self-loops are ignored by this function.
 *
 * \param graph The graph object.
 * \param vids A vector containing the vertex ids to be considered as
 *        a subgraph. Each vertex id should be included at most once.
 * \param isoclass Pointer to an integer, this will be set to the
 *        isomorphism class.
 * \return Error code.
 * \sa \ref igraph_isoclass(), \ref igraph_isomorphic(),
 * \ref igraph_isoclass_create().
 *
 * Time complexity: O((d+n)*n), d is the average degree in the network,
 * and n is the number of vertices in \c vids.
 */
int igraph_isoclass_subgraph(const igraph_t *graph, const igraph_vector_t *vids,
                             igraph_integer_t *isoclass) {
    int subgraph_size = (int) igraph_vector_size(vids);
    igraph_vector_t neis;

    unsigned int mul, idx;
    const unsigned int *arr_idx, *arr_code;
    unsigned int code = 0;

    long int i, j, s;

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    if (igraph_is_directed(graph)) {
        switch (subgraph_size) {
        case 3:
            arr_idx = igraph_i_isoclass_3_idx;
            arr_code = igraph_i_isoclass2_3;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4_idx;
            arr_code = igraph_i_isoclass2_4;
            mul = 4;
            break;
        default:
            IGRAPH_ERROR("Directed isoclass is only implemented for graphs with 3 or 4 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }
    } else {
        switch (subgraph_size) {
        case 3:
            arr_idx = igraph_i_isoclass_3u_idx;
            arr_code = igraph_i_isoclass2_3u;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4u_idx;
            arr_code = igraph_i_isoclass2_4u;
            mul = 4;
            break;
        case 5:
            arr_idx = igraph_i_isoclass_5u_idx;
            arr_code = igraph_i_isoclass2_5u;
            mul = 5;
            break;
        case 6:
            arr_idx = igraph_i_isoclass_6u_idx;
            arr_code = igraph_i_isoclass2_6u;
            mul = 6;
            break;
        default:
            IGRAPH_ERROR("Undirected isoclass is only implemented for graphs with 3 to 6 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }
    }

    for (i = 0; i < subgraph_size; i++) {
        long int from = (long int) VECTOR(*vids)[i];
        igraph_neighbors(graph, &neis, (igraph_integer_t) from, IGRAPH_OUT);
        s = igraph_vector_size(&neis);
        for (j = 0; j < s; j++) {
            long int nei = (long int) VECTOR(neis)[j], to;
            if (igraph_vector_search(vids, 0, nei, &to)) {
                idx = (mul * i + to);
                code |= arr_idx[idx];
            }
        }
    }

    *isoclass = (igraph_integer_t) arr_code[code];
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_isoclass_create
 * \brief Creates a graph from the given isomorphism class.
 *
 * 
 * This function creates the canonical representative graph of the
 * given isomorphism class.
 *
 * 
 * The isomorphism class is an integer between 0 and the number of
 * unique unlabeled (i.e. non-isomorphic) graphs on the given number
 * of vertices and give directedness. See https://oeis.org/A000273
 * and https://oeis.org/A000088 for the number of directed and
 * undirected graphs on \p size nodes.
 *
 * 
 * At the moment, 3- and 4-vertex directed graphs and 3 to 6 vertex
 * undirected graphs are supported.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param size The number of vertices to add to the graph.
 * \param number The isomorphism class.
 * \param directed Logical constant, whether to create a directed
 *        graph.
 * \return Error code.
 * \sa \ref igraph_isoclass(),
 * \ref igraph_isoclass_subgraph(),
 * \ref igraph_isomorphic().
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges in the graph to create.
 */
int igraph_isoclass_create(igraph_t *graph, igraph_integer_t size,
                           igraph_integer_t number, igraph_bool_t directed) {
    igraph_vector_t edges;
    const unsigned int *classedges;
    long int graphcount;
    long int power;
    long int pos;
    unsigned int code;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

#define CHECK_ISOCLASS(number, directed, size, graphcount) \
    IGRAPH_ERRORF( \
        "Isoclass %" IGRAPH_PRId " requested, but there are only %ld" \
        " %s graphs of size %" IGRAPH_PRId ".", IGRAPH_EINVAL, \
        (igraph_integer_t) number, graphcount, directed ? "directed" : "undirected", size)

    if (directed) {
        switch (size) {
        case 3: {
            classedges = igraph_i_classedges_3;
            graphcount = sizeof(igraph_i_isographs_3) / sizeof(igraph_i_isographs_3[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_3[ (long int) number];
            power = 32;

            break;
        }
        case 4: {
            classedges = igraph_i_classedges_4;
            graphcount = sizeof(igraph_i_isographs_4) / sizeof(igraph_i_isographs_4[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_4[ (long int) number];
            power = 2048;

            break;
        }
        default:
            IGRAPH_ERROR("Directed isoclasses are supported only for graphs with 3 or 4 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }

    } else {
        switch (size) {
        case 3: {
            classedges = igraph_i_classedges_3u;
            graphcount = sizeof(igraph_i_isographs_3u) / sizeof(igraph_i_isographs_3u[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_3u[ (long int) number];
            power = 4;

            break;
        }
        case 4: {
            classedges = igraph_i_classedges_4u;
            graphcount = sizeof(igraph_i_isographs_4u) / sizeof(igraph_i_isographs_4u[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_4u[ (long int) number];
            power = 32;

            break;
        }
        case 5: {
            classedges = igraph_i_classedges_5u;
            graphcount = sizeof(igraph_i_isographs_5u) / sizeof(igraph_i_isographs_5u[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_5u[ (long int) number];
            power = 512;

            break;
        }
        case 6: {
            classedges = igraph_i_classedges_6u;
            graphcount = sizeof(igraph_i_isographs_6u) / sizeof(igraph_i_isographs_6u[0]);

            if (number < 0 || number >= graphcount) {
                CHECK_ISOCLASS(number, directed, size, graphcount);
            }

            code = igraph_i_isographs_6u[ (long int) number];
            power = 16384;

            break;
        }
        default:
            IGRAPH_ERROR("Undirected isoclasses are supported only for graphs with 3 to 6 vertices.",
                         IGRAPH_UNIMPLEMENTED);
        }
    }

#undef CHECK_ISOCLASS

    pos = 0;
    while (code > 0) {
        if (code >= power) {
            IGRAPH_CHECK(igraph_vector_push_back(&edges, classedges[2 * pos]));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, classedges[2 * pos + 1]));
            code -= power;
        }
        power /= 2;
        pos++;
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, size, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/isoclasses.h0000644000175100001710000000312000000000000025327 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2020  The igraph development team
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_ISOCLASSES_H
#define IGRAPH_ISOCLASSES_H

#include "igraph_decls.h"

__BEGIN_DECLS

extern const unsigned int igraph_i_isoclass2_3[];
extern const unsigned int igraph_i_isoclass2_4[];
extern const unsigned int igraph_i_isoclass2_3u[];
extern const unsigned int igraph_i_isoclass2_4u[];
extern const unsigned int igraph_i_isoclass2_5u[];
extern const unsigned int igraph_i_isoclass2_6u[];
extern const unsigned int igraph_i_isoclass_3_idx[];
extern const unsigned int igraph_i_isoclass_4_idx[];
extern const unsigned int igraph_i_isoclass_3u_idx[];
extern const unsigned int igraph_i_isoclass_4u_idx[];
extern const unsigned int igraph_i_isoclass_5u_idx[];
extern const unsigned int igraph_i_isoclass_6u_idx[];

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/isomorphism_misc.c0000644000175100001710000000762300000000000026552 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_topology.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"

/**
 * \function igraph_simplify_and_colorize
 * \brief Simplify the graph and compute self-loop and edge multiplicities.
 *
 * 
 * This function creates a vertex and edge colored simple graph from the input
 * graph. The vertex colors are computed as the number of incident self-loops
 * to each vertex in the input graph. The edge colors are computed as the number of
 * parallel edges in the input graph that were merged to create each edge
 * in the simple graph.
 *
 * 
 * The resulting colored simple graph is suitable for use by isomorphism checking
 * algorithms such as VF2, which only support simple graphs, but can consider
 * vertex and edge colors.
 *
 * \param graph The graph object, typically having self-loops or multi-edges.
 * \param res An uninitialized graph object. The result will be stored here
 * \param vertex_color Computed vertex colors corresponding to self-loop multiplicities.
 * \param edge_color Computed edge colors corresponding to edge multiplicities
 * \return Error code.
 *
 * \sa \ref igraph_simplify(), \ref igraph_isomorphic_vf2(), \ref igraph_subisomorphic_vf2()
 *
 */
int igraph_simplify_and_colorize(
    const igraph_t *graph, igraph_t *res,
    igraph_vector_int_t *vertex_color, igraph_vector_int_t *edge_color) {
    igraph_es_t es;
    igraph_eit_t eit;
    igraph_vector_t edges;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int pto = -1, pfrom = -1;
    long int i;

    IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_FROM));
    IGRAPH_FINALLY(igraph_es_destroy, &es);
    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    IGRAPH_CHECK(igraph_vector_int_resize(vertex_color, no_of_nodes));
    igraph_vector_int_null(vertex_color);

    IGRAPH_CHECK(igraph_vector_int_resize(edge_color, no_of_edges));
    igraph_vector_int_null(edge_color);

    i = -1;
    for (; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        long int edge = IGRAPH_EIT_GET(eit);
        long int from = IGRAPH_FROM(graph, edge);
        long int to   = IGRAPH_TO(graph, edge);

        if (to == from) {
            VECTOR(*vertex_color)[to]++;
            continue;
        }

        if (to == pto && from == pfrom) {
            VECTOR(*edge_color)[i]++;
        } else {
            igraph_vector_push_back(&edges, from);
            igraph_vector_push_back(&edges, to);
            i++;
            VECTOR(*edge_color)[i] = 1;
        }

        pfrom = from; pto = to;
    }

    igraph_vector_int_resize(edge_color, i + 1);

    igraph_eit_destroy(&eit);
    igraph_es_destroy(&es);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(res, &edges, no_of_nodes, igraph_is_directed(graph)));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/lad.c0000644000175100001710000017641100000000000023730 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
  The contents of this file was originally taken from the LAD
  homepage: http://liris.cnrs.fr/csolnon/LAD.html and then
  modified to fit better into igraph.

  Unfortunately LAD seems to have no version numbers. The files
  were apparently last changed on the 29th of June, 2010.

  The original copyright message follows here. The CeCILL-B V1 license
  is GPL compatible, because instead of V1, one can freely choose to
  use V2, and V2 is explicitly GPL compatible.
*/

/* This software has been written by Christine Solnon.
   It is distributed under the CeCILL-B FREE SOFTWARE LICENSE
   see http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
   for more details
*/

/* Several modifications had to be made to the original LAD implementation
   to make it compile with non-C99-compliant compilers such as MSVC. In
   particular, I had to remove all the variable-sized arrays.
   -- Tamas Nepusz, 11 July 2013
*/

#include "igraph_topology.h"
#include "igraph_interface.h"
#include "igraph_adjlist.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"
#include "igraph_memory.h"
#include "igraph_matrix.h"
#include "igraph_qsort.h"

#include "core/interruption.h"

#include 
#include 
#include 
#include 


/* define boolean type as char */
#define true 1
#define false 0
#define bool char

/* helper to allocate an array of given size and free it using IGRAPH_FINALLY
 * when needed */
#define ALLOC_ARRAY(VAR, SIZE, TYPE) { \
        VAR = IGRAPH_CALLOC(SIZE, TYPE);   \
        if (VAR == 0) {                    \
            IGRAPH_ERROR("cannot allocate '" #VAR "' array in LAD isomorphism search", IGRAPH_ENOMEM); \
        }  \
        IGRAPH_FINALLY(igraph_free, VAR);  \
    }

/* helper to allocate an array of given size and store its address in a
 * pointer array */
#define ALLOC_ARRAY_IN_HISTORY(VAR, SIZE, TYPE, HISTORY) { \
        VAR = IGRAPH_CALLOC(SIZE, TYPE);   \
        if (VAR == 0) {                    \
            IGRAPH_ERROR("cannot allocate '" #VAR "' array in LAD isomorphism search", IGRAPH_ENOMEM); \
        }  \
        IGRAPH_FINALLY(igraph_free, VAR);  \
        IGRAPH_CHECK(igraph_vector_ptr_push_back(HISTORY, VAR));  \
        IGRAPH_FINALLY_CLEAN(1);           \
    }

/* ---------------------------------------------------------*/
/* Coming from graph.c                                      */
/* ---------------------------------------------------------*/

typedef struct {
    long int nbVertices; /* Number of vertices */
    igraph_vector_t nbSucc;
    igraph_adjlist_t succ;
    igraph_matrix_char_t isEdge;
} Tgraph;

static int igraph_i_lad_createGraph(const igraph_t *igraph, Tgraph* graph) {
    long int i, j, n;
    long int no_of_nodes = igraph_vcount(igraph);
    igraph_vector_int_t *neis;

    graph->nbVertices = no_of_nodes;

    IGRAPH_CHECK(igraph_adjlist_init(igraph, &graph->succ, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &graph->succ);

    IGRAPH_VECTOR_INIT_FINALLY(&graph->nbSucc, no_of_nodes);
    for (i=0; i < no_of_nodes; ++i) {
        VECTOR(graph->nbSucc)[i] = igraph_vector_int_size(igraph_adjlist_get(&graph->succ, i));
    }

    IGRAPH_CHECK(igraph_matrix_char_init(&graph->isEdge, no_of_nodes, no_of_nodes));
    IGRAPH_FINALLY(igraph_matrix_char_destroy, &graph->isEdge);

    for (i = 0; i < no_of_nodes; i++) {
        neis = igraph_adjlist_get(&graph->succ, i);
        n = igraph_vector_int_size(neis);
        for (j = 0; j < n; j++) {
            int v = (int)VECTOR(*neis)[j];
            if (MATRIX(graph->isEdge, i, v)) {
                IGRAPH_ERROR("LAD functions do not support graphs with multi-edges.", IGRAPH_EINVAL);
            }
            MATRIX(graph->isEdge, i, v) = 1;
        }
    }

    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

static void igraph_i_lad_destroyGraph(Tgraph *graph) {
    igraph_matrix_char_destroy(&graph->isEdge);
    igraph_adjlist_destroy(&graph->succ);
    igraph_vector_destroy(&graph->nbSucc);
}


/* ---------------------------------------------------------*/
/* Coming from domains.c                                    */
/* ---------------------------------------------------------*/

typedef struct {
    igraph_vector_int_t nbVal;    /* nbVal[u] = number of values in D[u] */
    igraph_vector_int_t firstVal; /* firstVal[u] = pos in val of the
                                   first value of D[u] */
    igraph_vector_int_t val;      /* val[firstVal[u]..firstVal[u]+nbVal[u]-1] =
                                   values of D[u] */
    igraph_matrix_int_t posInVal;
    /* If v in D[u] then firstVal[u] <= posInVal[u][v] < firstVal[u]+nbVal[u]
       and val[posInVal[u][v]] = v
       otherwise posInVal[u][v] >= firstVal[u]+nbVal[u] */
    int valSize;    /* size of val */
    igraph_matrix_int_t firstMatch;
    /* firstMatch[u][v] = pos in match of the first vertex
       of the covering matching of G_(u, v) */
    igraph_vector_int_t matching;
    /* matching[firstMatch[u][v]..firstMatch[u][v]+nbSucc[u]-1]
       = covering matching of G_(u, v) */
    int nextOutToFilter; /* position in toFilter of the next pattern node whose
                          domain should be filtered (-1 if no domain to
                          filter) */
    int lastInToFilter; /* position in toFilter of the last pattern node whose
                         domain should be filtered */
    igraph_vector_int_t toFilter;  /* contain all pattern nodes whose
                                    domain should be filtered */
    igraph_vector_char_t markedToFilter;  /* markedToFilter[u]=true if u
                                           is in toFilter; false otherwise */
    igraph_vector_int_t globalMatchingP; /* globalMatchingP[u] = node of Gt
                                          matched to u in globalAllDiff(Np) */
    igraph_vector_int_t globalMatchingT;
    /* globalMatchingT[v] = node of Gp matched to v in globalAllDiff(Np)
       or -1 if v is not matched */
} Tdomain;

static bool igraph_i_lad_toFilterEmpty(Tdomain* D) {
    /* return true if there is no more nodes in toFilter */
    return (D->nextOutToFilter < 0);
}

static void igraph_i_lad_resetToFilter(Tdomain *D) {
    /* empty to filter and unmark the vertices that are marked to be filtered */
    igraph_vector_char_null(&D->markedToFilter);
    D->nextOutToFilter = -1;
}


static int igraph_i_lad_nextToFilter(Tdomain* D, int size) {
    /* precondition: emptyToFilter = false
       remove a node from toFilter (FIFO)
       unmark this node and return it */
    int u = VECTOR(D->toFilter)[D->nextOutToFilter];
    VECTOR(D->markedToFilter)[u] = false;
    if (D->nextOutToFilter == D->lastInToFilter) {
        /* u was the last node in tofilter */
        D->nextOutToFilter = -1;
    } else if (D->nextOutToFilter == size - 1) {
        D->nextOutToFilter = 0;
    } else {
        D->nextOutToFilter++;
    }
    return u;
}

static void igraph_i_lad_addToFilter(int u, Tdomain* D, int size) {
    /* if u is not marked, then add it to toFilter and mark it */
    if (VECTOR(D->markedToFilter)[u]) {
        return;
    }
    VECTOR(D->markedToFilter)[u] = true;
    if (D->nextOutToFilter < 0) {
        D->lastInToFilter = 0;
        D->nextOutToFilter = 0;
    } else if (D->lastInToFilter == size - 1) {
        D->lastInToFilter = 0;
    } else {
        D->lastInToFilter++;
    }
    VECTOR(D->toFilter)[D->lastInToFilter] = u;
}

static bool igraph_i_lad_isInD(int u, int v, Tdomain* D) {
    /* returns true if v belongs to D(u); false otherwise */
    return (MATRIX(D->posInVal, u, v) <
            VECTOR(D->firstVal)[u] + VECTOR(D->nbVal)[u]);
}

static int igraph_i_lad_augmentingPath(int u, Tdomain* D, int nbV, bool* result) {
    /* return true if there exists an augmenting path starting from u and
       ending on a free vertex v in the bipartite directed graph G=(U,
       V, E) such that U=pattern nodes, V=target nodes, and
       E={(u, v), v in D(u)} U {(v, u), D->globalMatchingP[u]=v}
       update D-globalMatchingP and D->globalMatchingT consequently */
    int *fifo, *pred;
    bool *marked;
    int nextIn = 0;
    int nextOut = 0;
    int i, v, v2, u2;

    *result = false;

    /* Allocate memory */
    ALLOC_ARRAY(fifo, nbV, int);
    ALLOC_ARRAY(pred, nbV, int);
    ALLOC_ARRAY(marked, nbV, bool);

    for (i = 0; i < VECTOR(D->nbVal)[u]; i++) {
        v = VECTOR(D->val)[ VECTOR(D->firstVal)[u] + i ]; /* v in D(u) */
        if (VECTOR(D->globalMatchingT)[v] < 0) {
            /* v is free => augmenting path found */
            VECTOR(D->globalMatchingP)[u] = v;
            VECTOR(D->globalMatchingT)[v] = u;
            *result = true;
            goto cleanup;
        }
        /* v is not free => add it to fifo */
        pred[v] = u;
        fifo[nextIn++] = v;
        marked[v] = true;
    }
    while (nextOut < nextIn) {
        u2 = VECTOR(D->globalMatchingT)[fifo[nextOut++]];
        for (i = 0; i < VECTOR(D->nbVal)[u2]; i++) {
            v = VECTOR(D->val)[ VECTOR(D->firstVal)[u2] + i ]; /* v in D(u2) */
            if (VECTOR(D->globalMatchingT)[v] < 0) {
                /* v is free => augmenting path found */
                while (u2 != u) { /* update global matching wrt path */
                    v2 = VECTOR(D->globalMatchingP)[u2];
                    VECTOR(D->globalMatchingP)[u2] = v;
                    VECTOR(D->globalMatchingT)[v] = u2;
                    v = v2;
                    u2 = pred[v];
                }
                VECTOR(D->globalMatchingP)[u] = v;
                VECTOR(D->globalMatchingT)[v] = u;
                *result = true;
                goto cleanup;
            }
            if (!marked[v]) { /* v is not free and not marked => add it to fifo */
                pred[v] = u2;
                fifo[nextIn++] = v;
                marked[v] = true;
            }
        }
    }

cleanup:
    igraph_free(fifo);
    igraph_free(pred);
    igraph_free(marked);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

static int igraph_i_lad_removeAllValuesButOne(int u, int v, Tdomain* D, Tgraph* Gp,
                                       Tgraph* Gt, bool* result) {
    /* remove all values but v from D(u) and add all successors of u in
       toFilter return false if an inconsistency is detected wrt to
       global all diff */
    int j, oldPos, newPos;
    igraph_vector_int_t *uneis = igraph_adjlist_get(&Gp->succ, u);
    int n = (int) igraph_vector_int_size(uneis);
    /* add all successors of u in toFilter */
    for (j = 0; j < n; j++) {
        igraph_i_lad_addToFilter((int) VECTOR(*uneis)[j], D,
                                 (int) (Gp->nbVertices));
    }
    /* remove all values but v from D[u] */
    oldPos = MATRIX(D->posInVal, u, v);
    newPos = VECTOR(D->firstVal)[u];
    VECTOR(D->val)[oldPos] = VECTOR(D->val)[newPos];
    VECTOR(D->val)[newPos] = v;
    MATRIX(D->posInVal, u, VECTOR(D->val)[newPos]) = newPos;
    MATRIX(D->posInVal, u, VECTOR(D->val)[oldPos]) = oldPos;
    VECTOR(D->nbVal)[u] = 1;
    /* update global matchings that support the global all different
       constraint */
    if (VECTOR(D->globalMatchingP)[u] != v) {
        VECTOR(D->globalMatchingT)[ VECTOR(D->globalMatchingP)[u] ] = -1;
        VECTOR(D->globalMatchingP)[u] = -1;
        IGRAPH_CHECK(igraph_i_lad_augmentingPath(u, D, (int) (Gt->nbVertices), result));
    } else {
        *result = true;
    }
    return 0;
}


static int igraph_i_lad_removeValue(int u, int v, Tdomain* D, Tgraph* Gp,
                             Tgraph* Gt, bool* result) {
    /* remove v from D(u) and add all successors of u in toFilter
       return false if an inconsistency is detected wrt global all diff */
    int j;
    igraph_vector_int_t *uneis = igraph_adjlist_get(&Gp->succ, u);
    int n = (int) igraph_vector_int_size(uneis);
    int oldPos, newPos;

    /* add all successors of u in toFilter */
    for (j = 0; j < n; j++) {
        igraph_i_lad_addToFilter((int) VECTOR(*uneis)[j], D,
                                 (int) (Gp->nbVertices));
    }
    /* remove v from D[u] */
    oldPos = MATRIX(D->posInVal, u, v);
    VECTOR(D->nbVal)[u]--;
    newPos = VECTOR(D->firstVal)[u] + VECTOR(D->nbVal)[u];
    VECTOR(D->val)[oldPos] = VECTOR(D->val)[newPos];
    VECTOR(D->val)[newPos] = v;
    MATRIX(D->posInVal, u, VECTOR(D->val)[oldPos]) = oldPos;
    MATRIX(D->posInVal, u, VECTOR(D->val)[newPos]) = newPos;
    /* update global matchings that support the global all different
       constraint */
    if (VECTOR(D->globalMatchingP)[u] == v) {
        VECTOR(D->globalMatchingP)[u] = -1;
        VECTOR(D->globalMatchingT)[v] = -1;
        IGRAPH_CHECK(igraph_i_lad_augmentingPath(u, D, (int) (Gt->nbVertices), result));
    } else {
        *result = true;
    }
    return 0;
}


static int igraph_i_lad_matchVertices(int nb, igraph_vector_int_t* toBeMatched,
                               bool induced, Tdomain* D, Tgraph* Gp,
                               Tgraph* Gt, int *invalid) {
    /* for each u in toBeMatched[0..nb-1], match u to
       D->val[D->firstVal[u] and filter domains of other non matched
       vertices wrt FC(Edges) and FC(diff) (this is not mandatory, as
       LAD is stronger than FC(Edges) and GAC(allDiff) is stronger than
       FC(diff), but this speeds up the solution process).
       return false if an inconsistency is detected by FC(Edges) or
       FC(diff); true otherwise; */
    int j, u, v, u2, oldNbVal;
    igraph_vector_int_t *vneis;
    bool result = false;

    while (nb > 0) {
        u = VECTOR(*toBeMatched)[--nb];
        v = VECTOR(D->val)[ VECTOR(D->firstVal)[u] ];
        vneis = igraph_adjlist_get(&Gt->succ, v);
        /* match u to v */
        for (u2 = 0; u2 < Gp->nbVertices; u2++) {
            if (u != u2) {
                oldNbVal = VECTOR(D->nbVal)[u2];
                if (igraph_i_lad_isInD(u2, v, D)) {
                    IGRAPH_CHECK(igraph_i_lad_removeValue(u2, v, D, Gp, Gt, &result));
                    if (!result) {
                        *invalid = 1 ; return 0;
                    }
                }
                if (MATRIX(Gp->isEdge, u, u2)) {
                    /* remove from D[u2] vertices which are not adjacent to v */
                    j = VECTOR(D->firstVal)[u2];
                    while (j < VECTOR(D->firstVal)[u2] + VECTOR(D->nbVal)[u2]) {
                        if (MATRIX(Gt->isEdge, v, VECTOR(D->val)[j])) {
                            j++;
                        } else {
                            IGRAPH_CHECK(igraph_i_lad_removeValue(u2, VECTOR(D->val)[j], D, Gp, Gt, &result));
                            if (!result) {
                                *invalid = 1; return 0;
                            }
                        }
                    }
                } else if (induced) {
                    /* (u, u2) is not an edge => remove neighbors of v from D[u2] */
                    if (VECTOR(D->nbVal)[u2] < VECTOR(Gt->nbSucc)[v]) {
                        j = VECTOR(D->firstVal)[u2];
                        while (j < VECTOR(D->firstVal)[u2] + VECTOR(D->nbVal)[u2]) {
                            if (!MATRIX(Gt->isEdge, v, VECTOR(D->val)[j])) {
                                j++;
                            } else {
                                IGRAPH_CHECK(igraph_i_lad_removeValue(u2, VECTOR(D->val)[j], D, Gp, Gt, &result));
                                if (!result) {
                                    *invalid = 1; return 0;
                                }
                            }
                        }
                    } else {
                        for (j = 0; j < VECTOR(Gt->nbSucc)[v]; j++) {
                            if (igraph_i_lad_isInD(u2, (int) VECTOR(*vneis)[j], D)) {
                                IGRAPH_CHECK(igraph_i_lad_removeValue(u2, (int) VECTOR(*vneis)[j], D, Gp, Gt, &result));
                                if (!result) {
                                    *invalid = 1; return 0;
                                }
                            }
                        }
                    }
                }
                if (VECTOR(D->nbVal)[u2] == 0) {
                    *invalid = 1; /* D[u2] is empty */
                    return 0;
                }
                if ((VECTOR(D->nbVal)[u2] == 1) && (oldNbVal > 1)) {
                    VECTOR(*toBeMatched)[nb++] = u2;
                }
            }
        }
    }
    *invalid = 0;
    return 0;
}


static bool igraph_i_lad_matchVertex(int u, bool induced, Tdomain* D, Tgraph* Gp,
                              Tgraph *Gt) {
    int invalid;
    /* match u to D->val[D->firstVal[u]] and filter domains of other non
       matched vertices wrt FC(Edges) and FC(diff) (this is not
       mandatory, as LAD is stronger than FC(Edges) and GAC(allDiff)
       is stronger than FC(diff), but this speeds up the solution process).
       return false if an inconsistency is detected by FC(Edges) or
       FC(diff); true otherwise; */
    igraph_vector_int_t toBeMatched;
    igraph_vector_int_init(&toBeMatched, Gp->nbVertices);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &toBeMatched);
    VECTOR(toBeMatched)[0] = u;
    IGRAPH_CHECK(igraph_i_lad_matchVertices(1, &toBeMatched, induced, D, Gp, Gt,
                               &invalid));
    igraph_vector_int_destroy(&toBeMatched);
    IGRAPH_FINALLY_CLEAN(1);

    return invalid ? false : true;
}


static int igraph_i_lad_qcompare (void const *a, void const *b) {
    /* function used by the qsort function */
    int pa = *((int*)a) - *((int*)b);
    return pa;
}

static bool igraph_i_lad_compare(int size_mu, int* mu, int size_mv, int* mv) {
    /* return true if for every element u of mu there exists
       a different element v of mv such that u <= v;
       return false otherwise */
    int i, j;
    igraph_qsort(mu, (size_t) size_mu, sizeof(int), igraph_i_lad_qcompare);
    igraph_qsort(mv, (size_t) size_mv, sizeof(int), igraph_i_lad_qcompare);
    i = size_mv - 1;
    for (j = size_mu - 1; j >= 0; j--) {
        if (mu[j] > mv[i]) {
            return false;
        }
        i--;
    }
    return true;
}

static int igraph_i_lad_initDomains(bool initialDomains,
                                    const igraph_vector_ptr_t *domains, Tdomain *D,
                                    const Tgraph *Gp, const Tgraph *Gt, int *empty) {
    /* for every pattern node u, initialize D(u) with every vertex v
       such that for every neighbor u' of u there exists a different
       neighbor v' of v such that degree(u) <= degree(v)
       if initialDomains, then filter initial domains wrt
       compatibilities given in file
       return false if a domain is empty and true otherwise */
    int *val;
    bool *dom;
    int *mu, *mv;
    int matchingSize, u, v, i, j;
    igraph_vector_t *vec;

    ALLOC_ARRAY(val, Gp->nbVertices * Gt->nbVertices, int);
    ALLOC_ARRAY(dom, Gt->nbVertices, bool);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->globalMatchingP, Gp->nbVertices);
    igraph_vector_int_fill(&D->globalMatchingP, -1L);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->globalMatchingT, Gt->nbVertices);
    igraph_vector_int_fill(&D->globalMatchingT, -1L);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->nbVal, Gp->nbVertices);

    IGRAPH_CHECK(igraph_vector_int_init(&D->firstVal, Gp->nbVertices));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &D->firstVal);

    IGRAPH_CHECK(igraph_matrix_int_init(&D->posInVal,
                                        Gp->nbVertices, Gt->nbVertices));
    IGRAPH_FINALLY(igraph_matrix_int_destroy, &D->posInVal);

    IGRAPH_CHECK(igraph_matrix_int_init(&D->firstMatch,
                                        Gp->nbVertices, Gt->nbVertices));
    IGRAPH_FINALLY(igraph_matrix_int_destroy, &D->firstMatch);

    IGRAPH_CHECK(igraph_vector_char_init(&D->markedToFilter, Gp->nbVertices));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &D->markedToFilter);

    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->toFilter, Gp->nbVertices);

    D->valSize = 0;
    matchingSize = 0;

    for (u = 0; u < Gp->nbVertices; u++) {
        igraph_vector_int_t *Gp_uneis = igraph_adjlist_get(&Gp->succ, u);
        if (initialDomains) {
            /* read the list of target vertices which are compatible with u */
            vec = VECTOR(*domains)[u];
            i = (int) igraph_vector_size(vec);
            memset(dom, false, sizeof(bool) * (size_t)(Gt->nbVertices));
            for (j = 0; j < i; j++) {
                v = (int) VECTOR(*vec)[j];
                dom[v] = true;
            }
        }
        VECTOR(D->markedToFilter)[u] = true;
        VECTOR(D->toFilter)[u] = u;
        VECTOR(D->nbVal)[u] = 0;
        VECTOR(D->firstVal)[u] = D->valSize;
        for (v = 0; v < Gt->nbVertices; v++) {
            igraph_vector_int_t *Gt_vneis = igraph_adjlist_get(&Gt->succ, v);
            if ((initialDomains) && (!dom[v])) { /* v not in D(u) */
                MATRIX(D->posInVal, u, v) = (int) (VECTOR(D->firstVal)[u] +
                                                   Gt->nbVertices);
            } else {
                MATRIX(D->firstMatch, u, v) = matchingSize;
                matchingSize += VECTOR(Gp->nbSucc)[u];
                if (VECTOR(Gp->nbSucc)[u] <= VECTOR(Gt->nbSucc)[v]) {
                    mu = IGRAPH_CALLOC((long int) VECTOR(Gp->nbSucc)[u], int);
                    if (mu == 0) {
                        igraph_free(val); igraph_free(dom);
                        IGRAPH_ERROR("cannot allocate 'mu' array in igraph_i_lad_initDomains", IGRAPH_ENOMEM);
                    }
                    mv = IGRAPH_CALLOC((long int) VECTOR(Gt->nbSucc)[v], int);
                    if (mv == 0) {
                        igraph_free(mu); igraph_free(val); igraph_free(dom);
                        IGRAPH_ERROR("cannot allocate 'mv' array in igraph_i_lad_initDomains", IGRAPH_ENOMEM);
                    }
                    for (i = 0; i < VECTOR(Gp->nbSucc)[u]; i++) {
                        mu[i] = (int) VECTOR(Gp->nbSucc)[(long int) VECTOR(*Gp_uneis)[i]];
                    }
                    for (i = 0; i < VECTOR(Gt->nbSucc)[v]; i++) {
                        mv[i] = (int) VECTOR(Gt->nbSucc)[(long int) VECTOR(*Gt_vneis)[i]];
                    }
                    if (igraph_i_lad_compare((int) VECTOR(Gp->nbSucc)[u], mu,
                                             (int) VECTOR(Gt->nbSucc)[v], mv) == 1) {
                        val[D->valSize] = v;
                        VECTOR(D->nbVal)[u]++;
                        MATRIX(D->posInVal, u, v) = D->valSize++;
                    } else {  /* v not in D(u) */
                        MATRIX(D->posInVal, u, v) =
                            (int)(VECTOR(D->firstVal)[u] + Gt->nbVertices);
                    }
                    igraph_free(mu); mu = 0;
                    igraph_free(mv); mv = 0;
                } else {  /* v not in D(u) */
                    MATRIX(D->posInVal, u, v) =
                        (int) (VECTOR(D->firstVal)[u] + Gt->nbVertices);
                }
            }
        }
        if (VECTOR(D->nbVal)[u] == 0) {
            *empty = 1;  /* empty domain */

            igraph_free(val);
            igraph_free(dom);

            /* On this branch, 'val' and 'matching' are unused.
             * We init them anyway so that we can have a consistent destructor. */
            IGRAPH_VECTOR_INT_INIT_FINALLY(&D->val, 0);
            IGRAPH_VECTOR_INT_INIT_FINALLY(&D->matching, 0);
            IGRAPH_FINALLY_CLEAN(12);

            return IGRAPH_SUCCESS;
        }
    }
    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->val, D->valSize);
    for (i = 0; i < D->valSize; i++) {
        VECTOR(D->val)[i] = val[i];
    }

    IGRAPH_VECTOR_INT_INIT_FINALLY(&D->matching, matchingSize);
    igraph_vector_int_fill(&D->matching, -1);

    D->nextOutToFilter = 0;
    D->lastInToFilter = (int) (Gp->nbVertices - 1);

    *empty = 0;

    igraph_free(val);
    igraph_free(dom);

    IGRAPH_FINALLY_CLEAN(12);

    return IGRAPH_SUCCESS;
}

static void igraph_i_lad_destroyDomains(Tdomain *D) {
    igraph_vector_int_destroy(&D->globalMatchingP);
    igraph_vector_int_destroy(&D->globalMatchingT);
    igraph_vector_int_destroy(&D->nbVal);
    igraph_vector_int_destroy(&D->firstVal);
    igraph_matrix_int_destroy(&D->posInVal);
    igraph_matrix_int_destroy(&D->firstMatch);
    igraph_vector_char_destroy(&D->markedToFilter);
    igraph_vector_int_destroy(&D->toFilter);

    igraph_vector_int_destroy(&D->val);
    igraph_vector_int_destroy(&D->matching);
}


/* ---------------------------------------------------------*/
/* Coming from allDiff.c                                    */
/* ---------------------------------------------------------*/

#define white 0
#define grey 1
#define black 2
#define toBeDeleted 3
#define deleted 4

static void igraph_i_lad_addToDelete(int u, int* list, int* nb, int* marked) {
    if (marked[u] < toBeDeleted) {
        list[(*nb)++] = u;
        marked[u] = toBeDeleted;
    }
}

static int igraph_i_lad_updateMatching(int sizeOfU, int sizeOfV,
                                igraph_vector_int_t *degree,
                                igraph_vector_int_t *firstAdj,
                                igraph_vector_int_t *adj,
                                igraph_vector_int_t * matchedWithU,
                                int *invalid) {
    /* input:
       sizeOfU = number of vertices in U
       sizeOfV = number of vertices in V
       degree[u] = number of vertices of V which are adjacent to u
       firstAdj[u] = pos in adj of the first vertex of V adjacent to u
       adj[firstAdj[u]..firstAdj[u]+sizeOfU[u]-1] = vertices of V adjacent to u

       input/output:
       matchedWithU[u] = vertex of V matched with u

       returns true if there exists a matching that covers U, i.e., if
       for every u in 0..nbU-1, there exists a different v in 0..nb-1
       such that v is adjacent to u; returns false otherwise */

    int *matchedWithV; /* matchedWithV[matchedWithU[u]]=u */
    int *nbPred; /* nbPred[i] = nb of predecessors of the ith
                  vertex of V in the DAG */
    int *pred; /* pred[i][j] = jth predecessor the ith
                 vertex of V in the DAG */
    int *nbSucc; /* nbSucc[i] = nb of successors of the ith
                  vertex of U in the DAG */
    int *succ; /* succ[i][j] = jth successor of the ith
                 vertex of U in the DAG */
    int *listV, *listU, *listDV, *listDU;
    int nbV, nbU, nbDV, nbDU;
    int i, j, k, stop, u, v;
    int *markedV, *markedU;
    /* markedX[i]=white if X[i] is not in the DAG
       markedX[i]=grey if X[i] has been added to the DAG, but not its successors
       markedX[i]=black if X[i] and its successors have been added to the DAG
       markedX[i]=toBeDeleted if X[i] must be deleted from the DAG
       markedX[i]=deleted if X[i] has been deleted from the DAG */
    int nbUnmatched = 0; /* number of vertices of U that are not matched */
    int *unmatched;      /* vertices of U that are not matched */
    int *posInUnmatched; /* unmatched[posInUnmatched[u]]=u */
    igraph_vector_int_t path;

    if (sizeOfU > sizeOfV) {
        *invalid = 1; /* trivial case of infeasibility */
        return 0;
    }

    ALLOC_ARRAY(matchedWithV, sizeOfV, int);
    ALLOC_ARRAY(nbPred, sizeOfV, int);
    ALLOC_ARRAY(pred, sizeOfV * sizeOfU, int);
    ALLOC_ARRAY(nbSucc, sizeOfU, int);
    ALLOC_ARRAY(succ, sizeOfU * sizeOfV, int);
    ALLOC_ARRAY(listV, sizeOfV, int);
    ALLOC_ARRAY(listU, sizeOfU, int);
    ALLOC_ARRAY(listDV, sizeOfV, int);
    ALLOC_ARRAY(listDU, sizeOfU, int);
    ALLOC_ARRAY(markedV, sizeOfV, int);
    ALLOC_ARRAY(markedU, sizeOfU, int);
    ALLOC_ARRAY(unmatched, sizeOfU, int);
    ALLOC_ARRAY(posInUnmatched, sizeOfU, int);

    IGRAPH_CHECK(igraph_vector_int_init(&path, 0));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &path);

    /* initialize matchedWithV and unmatched */
    memset(matchedWithV, -1, (size_t)sizeOfV * sizeof(int));
    for (u = 0; u < sizeOfU; u++) {
        if (VECTOR(*matchedWithU)[u] >= 0) {
            matchedWithV[VECTOR(*matchedWithU)[u]] = u;
        } else {
            posInUnmatched[u] = nbUnmatched;
            unmatched[nbUnmatched++] = u;
        }
    }
    /* try to match unmatched vertices of U with free vertices of V */
    j = 0;
    while (j < nbUnmatched) {
        u = unmatched[j];
        for (i = VECTOR(*firstAdj)[u];
             ((i < VECTOR(*firstAdj)[u] + VECTOR(*degree)[u]) &&
              (matchedWithV[VECTOR(*adj)[i]] >= 0)); i++) { }
        if (i == VECTOR(*firstAdj)[u] + VECTOR(*degree)[u]) {
            j++; /* no free vertex for u */
        } else {
            v = VECTOR(*adj)[i]; /* v is free => match u with v */
            VECTOR(*matchedWithU)[u] = v;
            matchedWithV[v] = u;
            unmatched[j] = unmatched[--nbUnmatched];
            posInUnmatched[unmatched[j]] = j;
        }
    }

    while (nbUnmatched > 0) {
        /* Try to increase the number of matched vertices */
        /* step 1 : build the DAG */
        memset(markedU, white, (size_t) sizeOfU * sizeof(int));
        memset(nbSucc, 0, (size_t) sizeOfU * sizeof(int));
        memset(markedV, white, (size_t) sizeOfV * sizeof(int));
        memset(nbPred, 0, (size_t) sizeOfV * sizeof(int));
        /* first layer of the DAG from the free nodes of U */
        nbV = 0;
        for (j = 0; j < nbUnmatched; j++) {
            u = unmatched[j]; /* u is a free node of U */
            markedU[u] = black;
            for (i = VECTOR(*firstAdj)[u];
                 i < VECTOR(*firstAdj)[u] + VECTOR(*degree)[u]; i++) {
                v = VECTOR(*adj)[i]; /* add edge (u, v) to the DAG */
                pred[v * sizeOfU + (nbPred[v]++)] = u;
                succ[u * sizeOfV + (nbSucc[u]++)] = v;
                if (markedV[v] == white) { /* first time v is added to the DAG*/
                    markedV[v] = grey;
                    listV[nbV++] = v;
                }
            }
        }
        stop = 0;
        while ((stop == 0) && (nbV > 0)) {
            /* build next layer from nodes of V to nodes of U */
            nbU = 0;
            for (i = 0; i < nbV; i++) {
                v = listV[i];
                markedV[v] = black;
                u = matchedWithV[v];
                if (markedU[u] == white) { /* edge (v, u) belongs to the DAG */
                    markedU[u] = grey;
                    listU[nbU++] = u;
                }
            }
            /* build next layer from nodes of U to nodes of V */
            nbV = 0;
            for (j = 0; j < nbU; j++) {
                u = listU[j];
                markedU[u] = black;
                for (i = VECTOR(*firstAdj)[u];
                     i < VECTOR(*firstAdj)[u] + VECTOR(*degree)[u]; i++) {
                    v = VECTOR(*adj)[i];
                    if (markedV[v] != black) { /* add edge (u, v) to the DAG */
                        pred[v * sizeOfU + (nbPred[v]++)] = u;
                        succ[u * sizeOfV + (nbSucc[u]++)] = v;
                        if (markedV[v] == white) { /* first time v is added to the DAG */
                            markedV[v] = grey;
                            listV[nbV++] = v;
                        }
                        if (matchedWithV[v] == -1) { /* we have found a free node ! */
                            stop = 1;
                        }
                    }
                }
            }
        }
        if (nbV == 0) {
            *invalid = 1;
            /* I know it's ugly. */
            goto cleanup;
        }

        /* step 2: look for augmenting paths */
        for (k = 0; k < nbV; k++) {
            v = listV[k];
            if ((matchedWithV[v] == -1) && (nbPred[v] > 0)) {
                /* v is the final node of an augmenting path */
                IGRAPH_CHECK(igraph_vector_int_resize(&path, 1));
                VECTOR(path)[0] = v;
                nbDV = 0;
                nbDU = 0;
                igraph_i_lad_addToDelete(v, listDV, &nbDV, markedV);
                do {
                    u = pred[v * sizeOfU + 0]; /* (u, v) belongs to the augmenting path */
                    IGRAPH_CHECK(igraph_vector_int_push_back(&path, u));
                    igraph_i_lad_addToDelete(u, listDU, &nbDU, markedU);
                    if (VECTOR(*matchedWithU)[u] != -1) {
                        /* u is not the initial node of the augmenting path */
                        v = VECTOR(*matchedWithU)[u]; /* (v, u) belongs to the
                                           augmenting path */
                        IGRAPH_CHECK(igraph_vector_int_push_back(&path, v));
                        igraph_i_lad_addToDelete(v, listDV, &nbDV, markedV);
                    }
                } while (VECTOR(*matchedWithU)[u] != -1);

                /* delete nodes of listDV and listDU */
                while ((nbDV > 0) || (nbDU > 0)) {
                    while (nbDV > 0) { /* delete v */
                        v = listDV[--nbDV]; markedV[v] = deleted;
                        u = matchedWithV[v];
                        if (u != -1) {
                            igraph_i_lad_addToDelete(u, listDU, &nbDU, markedU);
                        }
                        for (i = 0; i < nbPred[v]; i++) {
                            u = pred[v * sizeOfU + i]; /* delete edge (u, v) */
                            for (j = 0; ((j < nbSucc[u]) && (v != succ[u * sizeOfV + j])); j++) { }
                            succ[u * sizeOfV + j] = succ[u * sizeOfV + (--nbSucc[u])];
                            if (nbSucc[u] == 0) {
                                igraph_i_lad_addToDelete(u, listDU, &nbDU, markedU);
                            }
                        }
                    }
                    while (nbDU > 0) { /* delete u */
                        u = listDU[--nbDU]; markedU[u] = deleted;
                        v = VECTOR(*matchedWithU)[u];
                        if (v != -1) {
                            igraph_i_lad_addToDelete(v, listDV, &nbDV, markedV);
                        }
                        j = 0;
                        for (i = 0; i < nbSucc[u]; i++) { /* delete edge (u, v) */
                            v = succ[u * sizeOfV + i];
                            for (j = 0; ((j < nbPred[v]) && (u != pred[v * sizeOfU + j])); j++) { }
                            pred[v * sizeOfU + j] = pred[v * sizeOfU + (--nbPred[v])];
                            if (nbPred[v] == 0) {
                                igraph_i_lad_addToDelete(v, listDV, &nbDV, markedV);
                            }
                        }
                    }
                }
                /* Remove the last node of the augmenting path from the set of
                   unmatched vertices */
                u = VECTOR(path)[igraph_vector_int_size(&path) - 1];
                i = posInUnmatched[u];
                unmatched[i] = unmatched[--nbUnmatched];
                posInUnmatched[unmatched[i]] = i;
                /* Update the matching wrt the augmenting path */
                while (igraph_vector_int_size(&path) > 1) {
                    u = igraph_vector_int_pop_back(&path);
                    v = igraph_vector_int_pop_back(&path);
                    VECTOR(*matchedWithU)[u] = v;
                    matchedWithV[v] = u;
                }
            }
        }
    }
    *invalid = 0;

cleanup:
    /* Free the allocated arrays */
    igraph_vector_int_destroy(&path);
    igraph_free(posInUnmatched);
    igraph_free(unmatched);
    igraph_free(markedU);
    igraph_free(markedV);
    igraph_free(listDU);
    igraph_free(listDV);
    igraph_free(listU);
    igraph_free(listV);
    igraph_free(succ);
    igraph_free(nbSucc);
    igraph_free(pred);
    igraph_free(nbPred);
    igraph_free(matchedWithV);
    IGRAPH_FINALLY_CLEAN(14);
    return 0;
}

static void igraph_i_lad_DFS(int nbU, int nbV, int u, bool* marked, int* nbSucc,
                      int* succ, igraph_vector_int_t * matchedWithU,
                      int* order, int* nb) {
    /* perform a depth first search, starting from u, in the bipartite
       graph Go=(U, V, E) such that
       U = vertices of Gp
       V = vertices of Gt
       E = { (u, matchedWithU[u]) / u is a vertex of Gp } U
           { (v, u) / v is a vertex of D[u] which is not matched to v}

       Given a vertex v of Gt, nbSucc[v]=number of successors of v and
       succ[v]=list of successors of v. order[nb^out+1..nb^in] contains
       the vertices discovered by the DFS */
    int i;
    int v = VECTOR(*matchedWithU)[u]; /* the only one predecessor of v is u */
    marked[u] = true;
    if (v >= 0) {
        for (i = 0; i < nbSucc[v]; i++) {
            if (!marked[succ[v * nbU + i]]) {
                igraph_i_lad_DFS(nbU, nbV, succ[v * nbU + i], marked, nbSucc, succ,
                                 matchedWithU, order, nb);
            }
        }
    }
    /* we have finished with u => number it */
    order[*nb] = u; (*nb)--;
}

static int igraph_i_lad_SCC(int nbU, int nbV, int* numV, int* numU,
                     int* nbSucc, int* succ,
                     int* nbPred, int* pred,
                     igraph_vector_int_t * matchedWithU,
                     igraph_vector_int_t * matchedWithV) {
    /* postrelation: numV[v]==numU[u] iff they belong to the same
       strongly connected component in the bipartite graph Go=(U, V, E)
       such that
       U = vertices of Gp
       V = vertices of Gt
       E = { (u, matchedWithU[u]) / u is a vertex of Gp } U
           { (v, u) / v is a vertex of D[u] which is not matched to v}

       Given a vertex v of Gt, nbSucc[v]=number of sucessors of v and
       succ[v]=list of successors of v */
    int *order;
    bool *marked;
    int *fifo;
    int u, v, i, j, k, nbSCC, nb;

    /* Allocate memory */
    ALLOC_ARRAY(order, nbU, int);
    ALLOC_ARRAY(marked, nbU, bool);
    ALLOC_ARRAY(fifo, nbV, int);

    /* Order vertices of Gp wrt DFS */
    nb = nbU - 1;
    for (u = 0; u < nbU; u++) {
        if (!marked[u]) {
            igraph_i_lad_DFS(nbU, nbV, u, marked, nbSucc, succ, matchedWithU,
                             order, &nb);
        }
    }

    /* traversal starting from order[0], then order[1], ... */
    nbSCC = 0;
    memset(numU, -1, (size_t) nbU * sizeof(int));
    memset(numV, -1, (size_t) nbV * sizeof(int));
    for (i = 0; i < nbU; i++) {
        u = order[i];
        v = VECTOR(*matchedWithU)[u];
        if (v == -1) {
            continue;
        }
        if (numV[v] == -1) { /* v belongs to a new SCC */
            nbSCC++;
            k = 1; fifo[0] = v;
            numV[v] = nbSCC;
            while (k > 0) {
                v = fifo[--k];
                u = VECTOR(*matchedWithV)[v];
                if (u != -1) {
                    numU[u] = nbSCC;
                    for (j = 0; j < nbPred[u]; j++) {
                        v = pred[u * nbV + j];
                        if (numV[v] == -1) {
                            numV[v] = nbSCC;
                            fifo[k++] = v;
                        }
                    }
                }
            }
        }
    }

    /* Free memory */
    igraph_free(fifo);
    igraph_free(marked);
    igraph_free(order);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}


static int igraph_i_lad_ensureGACallDiff(bool induced, Tgraph* Gp, Tgraph* Gt,
                                  Tdomain* D, int *invalid) {
    /* precondition: D->globalMatchingP is an all different matching of
       the pattern vertices
       postcondition: filter domains wrt GAC(allDiff)
       return false if an inconsistency is detected; true otherwise

       Build the bipartite directed graph Go=(U, V, E) such that
       E = { (u, v) / u is a vertex of Gp which is matched to v (i.e.,
              v=D->globalMatchingP[u])} U
           { (v, u) / v is a vertex of Gt which is in D(u) but is not
             matched to u} */
    int *nbPred;                 /* nbPred[u] = nb of predecessors of u in Go */
    int *pred;                                /* pred[u][i] = ith
                                               predecessor of u in Go */
    int *nbSucc;                 /* nbSucc[v] = nb of successors of v in Go */
    int *succ;                                /* succ[v][i] = ith
                                               successor of v in Go */
    int u, v, i, w, oldNbVal, nbToMatch;
    int *numV, *numU;
    igraph_vector_int_t toMatch;
    bool *used;
    int *list;
    int nb = 0;
    bool result;

    /* Allocate memory */
    ALLOC_ARRAY(nbPred, Gp->nbVertices, int);
    ALLOC_ARRAY(pred, Gp->nbVertices * Gt->nbVertices, int);
    ALLOC_ARRAY(nbSucc, Gt->nbVertices, int);
    ALLOC_ARRAY(succ, Gt->nbVertices * Gp->nbVertices, int);
    ALLOC_ARRAY(numV, Gt->nbVertices, int);
    ALLOC_ARRAY(numU, Gp->nbVertices, int);
    ALLOC_ARRAY(used, Gp->nbVertices * Gt->nbVertices, bool);
    ALLOC_ARRAY(list, Gt->nbVertices, int);
    IGRAPH_CHECK(igraph_vector_int_init(&toMatch, Gp->nbVertices));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &toMatch);

    for (u = 0; u < Gp->nbVertices; u++) {
        for (i = 0; i < VECTOR(D->nbVal)[u]; i++) {
            v = VECTOR(D->val)[ VECTOR(D->firstVal)[u] + i ]; /* v in D(u) */
            used[u * Gt->nbVertices + v] = false;
            if (v != VECTOR(D->globalMatchingP)[u]) {
                pred[u * Gt->nbVertices + (nbPred[u]++)] = v;
                succ[v * Gp->nbVertices + (nbSucc[v]++)] = u;
            }
        }
    }

    /* mark as used all edges of paths starting from free vertices */
    for (v = 0; v < Gt->nbVertices; v++) {
        if (VECTOR(D->globalMatchingT)[v] < 0) { /* v is free */
            list[nb++] = v;
            numV[v] = true;
        }
    }
    while (nb > 0) {
        v = list[--nb];
        for (i = 0; i < nbSucc[v]; i++) {
            u = succ[v * Gp->nbVertices + i];
            used[u * Gt->nbVertices + v] = true;
            if (numU[u] == false) {
                numU[u] = true;
                w = VECTOR(D->globalMatchingP)[u];
                used[u * Gt->nbVertices + w] = true;
                if (numV[w] == false) {
                    list[nb++] = w;
                    numV[w] = true;
                }
            }
        }
    }

    /* look for strongly connected components in Go */
    IGRAPH_CHECK(
        igraph_i_lad_SCC((int)(Gp->nbVertices), (int)(Gt->nbVertices), numV, numU,
                         nbSucc, succ, nbPred, pred, &D->globalMatchingP, &D->globalMatchingT));

    /* remove v from D[u] if (u, v) is not marked as used
                          and u and v are not in the same SCC
                          and D->globalMatchingP[u] != v */
    nbToMatch = 0;
    for (u = 0; u < Gp->nbVertices; u++) {
        oldNbVal = VECTOR(D->nbVal)[u];
        for (i = 0; i < VECTOR(D->nbVal)[u]; i++) {
            v = VECTOR(D->val)[ VECTOR(D->firstVal)[u] + i ]; /* v in D(u) */
            if ((!used[u * Gt->nbVertices + v]) && (numV[v] != numU[u]) &&
                (VECTOR(D->globalMatchingP)[u] != v)) {
                IGRAPH_CHECK(igraph_i_lad_removeValue(u, v, D, Gp, Gt, &result));
                if (!result) {
                    *invalid = 1;
                    /* Yes, this is ugly. */
                    goto cleanup;
                }
            }
        }
        if (VECTOR(D->nbVal)[u] == 0) {
            *invalid = 1;
            /* Yes, this is ugly. */
            goto cleanup;
        }
        if ((oldNbVal > 1) && (VECTOR(D->nbVal)[u] == 1)) {
            VECTOR(toMatch)[nbToMatch++] = u;
        }
    }
    IGRAPH_CHECK(igraph_i_lad_matchVertices(nbToMatch, &toMatch, induced,
                                            D, Gp, Gt, invalid));

cleanup:
    igraph_vector_int_destroy(&toMatch);
    igraph_free(list);
    igraph_free(used);
    igraph_free(numU);
    igraph_free(numV);
    igraph_free(succ);
    igraph_free(nbSucc);
    igraph_free(pred);
    igraph_free(nbPred);
    IGRAPH_FINALLY_CLEAN(9);

    return 0;
}

/* ---------------------------------------------------------*/
/* Coming from lad.c                                        */
/* ---------------------------------------------------------*/

static int igraph_i_lad_checkLAD(int u, int v, Tdomain* D, Tgraph* Gp, Tgraph* Gt,
                          bool *result) {
    /* return true if G_(u, v) has a adj(u)-covering matching; false
       otherwise */
    int u2, v2, i, j;
    int nbMatched = 0;
    igraph_vector_int_t *Gp_uneis = igraph_adjlist_get(&Gp->succ, u);

    int *num, *numInv;
    igraph_vector_int_t nbComp;
    igraph_vector_int_t firstComp;
    igraph_vector_int_t comp;
    int nbNum = 0;
    int posInComp = 0;
    igraph_vector_int_t matchedWithU;
    int invalid;

    /* special case when u has only 1 adjacent node => no need to call
       Hopcroft and Karp */
    if (VECTOR(Gp->nbSucc)[u] == 1) {
        u2 = (int) VECTOR(*Gp_uneis)[0]; /* u2 is the only node adjacent to u */
        v2 = VECTOR(D->matching)[ MATRIX(D->firstMatch, u, v) ];
        if ((v2 != -1) && (igraph_i_lad_isInD(u2, v2, D))) {
            *result = true;
            return 0;
        }
        /* look for a support of edge (u, u2) for v */
        for (i = VECTOR(D->firstVal)[u2];
             i < VECTOR(D->firstVal)[u2] + VECTOR(D->nbVal)[u2]; i++) {
            if (MATRIX(Gt->isEdge, v, VECTOR(D->val)[i])) {
                VECTOR(D->matching)[ MATRIX(D->firstMatch, u, v) ] =
                    VECTOR(D->val)[i];
                *result = true;
                return 0;
            }
        }
        *result = false;
        return 0;
    }

    /* general case (when u has more than 1 adjacent node) */
    for (i = 0; i < VECTOR(Gp->nbSucc)[u]; i++) {
        /* remove from the matching of G_(u, v) edges which no longer
           belong to G_(u, v) */
        u2 = (int) VECTOR(*Gp_uneis)[i];
        v2 = VECTOR(D->matching)[ MATRIX(D->firstMatch, u, v) + i];
        if ((v2 != -1) && (igraph_i_lad_isInD(u2, v2, D))) {
            nbMatched++;
        }
    }
    if (nbMatched == VECTOR(Gp->nbSucc)[u]) {
        *result = true;
        return 0;
    } /* The matching still covers adj(u) */

    /* Allocate memory */
    ALLOC_ARRAY(num, Gt->nbVertices, int);
    ALLOC_ARRAY(numInv, Gt->nbVertices, int);

    /* Build the bipartite graph
       let U be the set of nodes adjacent to u
       let V be the set of nodes that are adjacent to v, and that belong
       to domains of nodes of U */
    /* nbComp[u]=number of elements of V that are compatible with u */
    IGRAPH_CHECK(igraph_vector_int_init(&nbComp, (long int) VECTOR(Gp->nbSucc)[u]));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &nbComp);
    IGRAPH_CHECK(igraph_vector_int_init(&firstComp, (long int) VECTOR(Gp->nbSucc)[u]));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &firstComp);
    /* comp[firstComp[u]..firstComp[u]+nbComp[u]-1] = nodes of Gt that
       are compatible with u */
    IGRAPH_CHECK(igraph_vector_int_init(&comp, (long int) (VECTOR(Gp->nbSucc)[u] *
                                        Gt->nbVertices)));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &comp);
    IGRAPH_CHECK(igraph_vector_int_init(&matchedWithU, (long int) VECTOR(Gp->nbSucc)[u]));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &matchedWithU);
    memset(num, -1, (size_t) (Gt->nbVertices) * sizeof(int));
    for (i = 0; i < VECTOR(Gp->nbSucc)[u]; i++) {
        u2 = (int) VECTOR(*Gp_uneis)[i]; /* u2 is adjacent to u */
        /* search for all nodes v2 in D[u2] which are adjacent to v */
        VECTOR(nbComp)[i] = 0;
        VECTOR(firstComp)[i] = posInComp;
        if (VECTOR(D->nbVal)[u2] > VECTOR(Gt->nbSucc)[v]) {
            for (j = VECTOR(D->firstVal)[u2];
                 j < VECTOR(D->firstVal)[u2] + VECTOR(D->nbVal)[u2]; j++) {
                v2 = VECTOR(D->val)[j]; /* v2 belongs to D[u2] */
                if (MATRIX(Gt->isEdge, v, v2)) { /* v2 is a successor of v */
                    if (num[v2] < 0) { /* v2 has not yet been added to V */
                        num[v2] = nbNum;
                        numInv[nbNum++] = v2;
                    }
                    VECTOR(comp)[posInComp++] = num[v2];
                    VECTOR(nbComp)[i]++;
                }
            }
        } else {
            igraph_vector_int_t *Gt_vneis = igraph_adjlist_get(&Gt->succ, v);
            for (j = 0; j < VECTOR(Gt->nbSucc)[v]; j++) {
                v2 = (int) VECTOR(*Gt_vneis)[j]; /* v2 is a successor of v */
                if (igraph_i_lad_isInD(u2, v2, D)) { /* v2 belongs to D[u2] */
                    if (num[v2] < 0) { /* v2 has not yet been added to V */
                        num[v2] = nbNum;
                        numInv[nbNum++] = v2;
                    }
                    VECTOR(comp)[posInComp++] = num[v2];
                    VECTOR(nbComp)[i]++;
                }
            }
        }
        if (VECTOR(nbComp)[i] == 0) {
            *result = false; /* u2 has no compatible vertex in succ[v] */
            goto cleanup;
        }
        /* u2 is matched to v2 in the matching that supports (u, v) */
        v2 = VECTOR(D->matching)[ MATRIX(D->firstMatch, u, v) + i];
        if ((v2 != -1) && (igraph_i_lad_isInD(u2, v2, D))) {
            VECTOR(matchedWithU)[i] = num[v2];
        } else {
            VECTOR(matchedWithU)[i] = -1;
        }
    }
    /* Call Hopcroft Karp to update the matching */
    IGRAPH_CHECK(
        igraph_i_lad_updateMatching((int) VECTOR(Gp->nbSucc)[u], nbNum, &nbComp,
                                    &firstComp, &comp, &matchedWithU, &invalid)
    );
    if (invalid) {
        *result = false;
        goto cleanup;
    }
    for (i = 0; i < VECTOR(Gp->nbSucc)[u]; i++) {
        VECTOR(D->matching)[ MATRIX(D->firstMatch, u, v) + i] =
            numInv[ VECTOR(matchedWithU)[i] ];
    }
    *result = true;

cleanup:
    igraph_free(numInv);
    igraph_free(num);
    igraph_vector_int_destroy(&matchedWithU);
    igraph_vector_int_destroy(&comp);
    igraph_vector_int_destroy(&firstComp);
    igraph_vector_int_destroy(&nbComp);
    IGRAPH_FINALLY_CLEAN(6);

    return 0;
}

/* ---------------------------------------------------------*/
/* Coming from main.c                                      */
/* ---------------------------------------------------------*/

static int igraph_i_lad_filter(bool induced, Tdomain* D, Tgraph* Gp, Tgraph* Gt,
                        bool *result) {
    /* filter domains of all vertices in D->toFilter wrt LAD and ensure
       GAC(allDiff)
       return false if some domain becomes empty; true otherwise */
    int u, v, i, oldNbVal;
    int invalid;
    bool result2;
    while (!igraph_i_lad_toFilterEmpty(D)) {
        while (!igraph_i_lad_toFilterEmpty(D)) {
            u = igraph_i_lad_nextToFilter(D, (int) (Gp->nbVertices));
            oldNbVal = VECTOR(D->nbVal)[u];
            i = VECTOR(D->firstVal)[u];
            while (i < VECTOR(D->firstVal)[u] + VECTOR(D->nbVal)[u]) {
                /* for every target node v in D(u), check if G_(u, v) has a
                   covering matching */
                v = VECTOR(D->val)[i];
                IGRAPH_CHECK(igraph_i_lad_checkLAD(u, v, D, Gp, Gt, &result2));
                if (result2) {
                    i++;
                } else {
                    IGRAPH_CHECK(igraph_i_lad_removeValue(u, v, D, Gp, Gt, &result2));
                    if (!result2) {
                        *result = false;
                        return 0;
                    }
                }
            }
            if ((VECTOR(D->nbVal)[u] == 1) && (oldNbVal > 1) &&
                (!igraph_i_lad_matchVertex(u, induced, D, Gp, Gt))) {
                *result = false; return 0;
            }
            if (VECTOR(D->nbVal)[u] == 0) {
                *result = false;
                return 0;
            }
        }
        igraph_i_lad_ensureGACallDiff(induced, Gp, Gt, D, &invalid);
        if (invalid) {
            *result = false;
            return 0;
        }
    }
    *result = true;
    return 0;
}



static int igraph_i_lad_solve(int timeLimit, bool firstSol, bool induced,
                       Tdomain* D, Tgraph* Gp, Tgraph* Gt,
                       int *invalid, igraph_bool_t *iso,
                       igraph_vector_t *map, igraph_vector_ptr_t *maps,
                       int *nbNodes, int *nbFail, int *nbSol,
                       clock_t *begin, igraph_vector_ptr_t *alloc_history) {
    /* if firstSol then search for the first solution; otherwise search
       for all solutions if induced then search for induced subgraphs;
       otherwise search for partial subgraphs
       return false if CPU time limit exceeded before the search is
       completed, return true otherwise */

    int u, v, minDom, i;
    int* nbVal;
    int* globalMatching;
    clock_t end = clock();
    igraph_vector_t *vec;
    int* val;
    bool result;

    (*nbNodes)++;

    if ( (double)(end - *begin) / CLOCKS_PER_SEC >= timeLimit) {
        /* CPU time limit exceeded */
        IGRAPH_ERROR("LAD CPU time exceeded", IGRAPH_CPUTIME);
    }

    /* Allocate memory */
    ALLOC_ARRAY_IN_HISTORY(nbVal, Gp->nbVertices, int, alloc_history);
    ALLOC_ARRAY_IN_HISTORY(globalMatching, Gp->nbVertices, int, alloc_history);

    IGRAPH_CHECK(igraph_i_lad_filter(induced, D, Gp, Gt, &result));
    if (!result) {
        /* filtering has detected an inconsistency */
        (*nbFail)++;
        igraph_i_lad_resetToFilter(D);
        *invalid = 0;
        goto cleanup;
    }

    /* The current node of the search tree is consistent wrt to LAD and
       GAC(allDiff) Save domain sizes and global all different matching
       and search for the non matched vertex minDom with smallest domain */
    minDom = -1;
    for (u = 0; u < Gp->nbVertices; u++) {
        nbVal[u] = VECTOR(D->nbVal)[u];
        if ((nbVal[u] > 1) && ((minDom < 0) || (nbVal[u] < nbVal[minDom]))) {
            minDom = u;
        }
        globalMatching[u] = VECTOR(D->globalMatchingP)[u];
    }

    if (minDom == -1) {
        /* All vertices are matched => Solution found */
        if (iso) {
            *iso = 1;
        }
        (*nbSol)++;
        if (map && igraph_vector_size(map) == 0) {
            IGRAPH_CHECK(igraph_vector_resize(map, Gp->nbVertices));
            for (u = 0; u < Gp->nbVertices; u++) {
                VECTOR(*map)[u] = VECTOR(D->val)[ VECTOR(D->firstVal)[u] ];
            }
        }
        if (maps) {
            vec = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!vec) {
                IGRAPH_ERROR("LAD failed", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, vec);
            IGRAPH_CHECK(igraph_vector_init(vec, Gp->nbVertices));
            IGRAPH_FINALLY(igraph_vector_destroy, vec);
            for (u = 0; u < Gp->nbVertices; u++) {
                VECTOR(*vec)[u] = VECTOR(D->val)[ VECTOR(D->firstVal)[u] ];
            }
            IGRAPH_CHECK(igraph_vector_ptr_push_back(maps, vec));
            IGRAPH_FINALLY_CLEAN(2);
        }
        igraph_i_lad_resetToFilter(D);
        *invalid = 0;
        goto cleanup;
    }

    /* save the domain of minDom to iterate on its values */
    ALLOC_ARRAY_IN_HISTORY(val, VECTOR(D->nbVal)[minDom], int, alloc_history);
    for (i = 0; i < VECTOR(D->nbVal)[minDom]; i++) {
        val[i] = VECTOR(D->val)[ VECTOR(D->firstVal)[minDom] + i ];
    }

    /* branch on minDom=v, for every target node v in D(u) */
    for (i = 0; ((i < nbVal[minDom]) && ((firstSol == 0) || (*nbSol == 0))); i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        v = val[i];
        IGRAPH_CHECK(igraph_i_lad_removeAllValuesButOne(minDom, v, D, Gp, Gt, &result));
        if (!result || (!igraph_i_lad_matchVertex(minDom, induced, D, Gp, Gt))) {
            (*nbFail)++;
            (*nbNodes)++;
            igraph_i_lad_resetToFilter(D);
        } else {
            IGRAPH_CHECK(igraph_i_lad_solve(timeLimit, firstSol, induced,
                                            D, Gp, Gt, invalid, iso, map, maps,
                                            nbNodes, nbFail, nbSol, begin,
                                            alloc_history));
        }
        /* restore domain sizes and global all different matching */
        igraph_vector_int_fill(&D->globalMatchingT, -1);
        for (u = 0; u < Gp->nbVertices; u++) {
            VECTOR(D->nbVal)[u] = nbVal[u];
            VECTOR(D->globalMatchingP)[u] = globalMatching[u];
            VECTOR(D->globalMatchingT)[globalMatching[u]] = u;
        }
    }
    *invalid = 0;

    igraph_free(val);
    igraph_vector_ptr_pop_back(alloc_history);

cleanup:
    igraph_free(globalMatching);
    igraph_vector_ptr_pop_back(alloc_history);
    igraph_free(nbVal);
    igraph_vector_ptr_pop_back(alloc_history);

    return 0;
}

/**
 * \section about_lad
 *
 * 
 * The LAD algorithm can search for a subgraph in a larger graph, or check
 * if two graphs are isomorphic.
 * See Christine Solnon: AllDifferent-based Filtering for Subgraph
 * Isomorphism. Artificial Intelligence, 174(12-13):850-864, 2010.
 * https://doi.org/10.1016/j.artint.2010.05.002
 * as well as the homepage of the LAD library at http://liris.cnrs.fr/csolnon/LAD.html
 * The implementation in igraph is based on LADv1, but it is
 * modified to use igraph's own memory allocation and error handling.
 * 
 *
 * 
 * LAD uses the concept of domains to indicate vertex compatibility when matching the
 * pattern graph. Domains can be used to implement matching of colored vertices.
 * 
 *
 * 
 * LAD works with both directed and undirected graphs. Graphs with multi-edges are not supported.
 * 
 */

/**
 * \function igraph_subisomorphic_lad
 * Check subgraph isomorphism with the LAD algorithm
 *
 * Check whether \p pattern is isomorphic to a subgraph os \p target.
 * The original LAD implementation by Christine Solnon was used as the
 * basis of this code.
 *
 * 
 * See more about LAD at http://liris.cnrs.fr/csolnon/LAD.html and in
 * Christine Solnon: AllDifferent-based Filtering for Subgraph
 * Isomorphism. Artificial Intelligence, 174(12-13):850-864, 2010.
 * https://doi.org/10.1016/j.artint.2010.05.002
 *
 * \param pattern The smaller graph, it can be directed or undirected.
 * \param target The bigger graph, it can be directed or undirected.
 * \param domains A pointer vector, or a null pointer. If a pointer
 *    vector, then it must contain pointers to \c igraph_vector_t
 *    objects and the length of the vector must match the number of
 *    vertices in the \p pattern graph. For each vertex, the ids of
 *    the compatible vertices in the target graph are listed.
 * \param iso Pointer to a boolean, or a null pointer. If not a null
 *    pointer, then the boolean is set to TRUE (1) if a subgraph
 *    isomorphism is found, and to FALSE (0) otherwise.
 * \param map Pointer to a vector or a null pointer. If not a null
 *    pointer and a subgraph isomorphism is found, the matching
 *    vertices from the target graph are listed here, for each vertex
 *    (in vertex id order) from the pattern graph.
 * \param maps Pointer vector or a null pointer. If not a null
 *    pointer, then all subgraph isomorphisms are stored in the
 *    pointer vector, in \c igraph_vector_t objects.
 * \param induced Boolean, whether to search for induced matching
 *    subgraphs.
 * \param time_limit Processor time limit in seconds. Supply zero
 *    here for no limit. If the time limit is over, then the function
 *    signals an error.
 * \return Error code
 *
 * \sa \ref igraph_subisomorphic_vf2() for the VF2 algorithm.
 *
 * Time complexity: exponential.
 *
 * \example examples/simple/igraph_subisomorphic_lad.c
 */

int igraph_subisomorphic_lad(const igraph_t *pattern, const igraph_t *target,
                             const igraph_vector_ptr_t *domains,
                             igraph_bool_t *iso, igraph_vector_t *map,
                             igraph_vector_ptr_t *maps,
                             igraph_bool_t induced, int time_limit) {

    bool firstSol = maps == 0;
    bool initialDomains = domains != 0;
    Tgraph Gp, Gt;
    Tdomain D;
    int invalidDomain;
    int u, nbToMatch = 0;
    igraph_vector_int_t toMatch;
    /* Number of nodes in the search tree */
    int nbNodes = 0;
    /* number of failed nodes in the search tree */
    int nbFail = 0;
    /* number of solutions found */
    int nbSol = 0;
    /* reusable structure to get CPU time usage */
    clock_t begin = clock();
    /* Stack to store memory blocks that are allocated during igraph_i_lad_solve */
    igraph_vector_ptr_t alloc_history;

    if (!iso && !map && !maps) {
        IGRAPH_ERROR("Please give least one of `iso', `map' or `maps'",
                     IGRAPH_EINVAL);
    }

    if (igraph_is_directed(pattern) != igraph_is_directed(target)) {
        IGRAPH_ERROR("Cannot search for a directed pattern in an undirected target "
                     "or vice versa", IGRAPH_EINVAL);
    }
    if (time_limit <= 0) {
        time_limit = INT_MAX;
    }

    if (iso)  {
        *iso = (igraph_vcount(pattern) == 0);
    }
    if (map)  {
        igraph_vector_clear(map);
    }
    if (maps) {
        igraph_vector_ptr_clear(maps);
    }

    if (igraph_vcount(pattern) == 0) {
        /* Special case for empty graphs */
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_i_lad_createGraph(pattern, &Gp));
    IGRAPH_FINALLY(igraph_i_lad_destroyGraph, &Gp);

    IGRAPH_CHECK(igraph_i_lad_createGraph(target, &Gt));
    IGRAPH_FINALLY(igraph_i_lad_destroyGraph, &Gt);

    if (Gp.nbVertices > Gt.nbVertices) {
        goto exit3;
    }

    IGRAPH_CHECK(igraph_i_lad_initDomains(initialDomains, domains, &D, &Gp, &Gt, &invalidDomain));
    IGRAPH_FINALLY(igraph_i_lad_destroyDomains, &D);

    if (invalidDomain) {
        goto exit2;
    }

    IGRAPH_CHECK(igraph_i_lad_updateMatching((int) (Gp.nbVertices),
                 (int) (Gt.nbVertices),
                 &D.nbVal, &D.firstVal, &D.val,
                 &D.globalMatchingP,
                 &invalidDomain));
    if (invalidDomain) {
        goto exit;
    }

    IGRAPH_CHECK(igraph_i_lad_ensureGACallDiff((char) induced, &Gp, &Gt, &D,
                 &invalidDomain));
    if (invalidDomain) {
        goto exit;
    }

    for (u = 0; u < Gp.nbVertices; u++) {
        VECTOR(D.globalMatchingT)[ VECTOR(D.globalMatchingP)[u] ] = u;
    }

    IGRAPH_CHECK(igraph_vector_int_init(&toMatch, Gp.nbVertices));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &toMatch);

    for (u = 0; u < Gp.nbVertices; u++) {
        if (VECTOR(D.nbVal)[u] == 1) {
            VECTOR(toMatch)[nbToMatch++] = u;
        }
    }
    IGRAPH_CHECK(igraph_i_lad_matchVertices(nbToMatch, &toMatch, (char) induced,
                                            &D, &Gp, &Gt, &invalidDomain));
    igraph_vector_int_destroy(&toMatch);
    IGRAPH_FINALLY_CLEAN(1);
    if (invalidDomain) {
        goto exit;
    }

    IGRAPH_CHECK(igraph_vector_ptr_init(&alloc_history, 0));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &alloc_history);

    IGRAPH_CHECK(igraph_i_lad_solve(time_limit, firstSol, (char) induced, &D,
                                    &Gp, &Gt, &invalidDomain, iso, map, maps,
                                    &nbNodes, &nbFail, &nbSol, &begin,
                                    &alloc_history));

    igraph_vector_ptr_destroy_all(&alloc_history);
    IGRAPH_FINALLY_CLEAN(1);

exit:
exit2:

    igraph_i_lad_destroyDomains(&D);
    IGRAPH_FINALLY_CLEAN(1);

exit3:

    igraph_i_lad_destroyGraph(&Gt);
    igraph_i_lad_destroyGraph(&Gp);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/queries.c0000644000175100001710000001600500000000000024635 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_topology.h"

#include "igraph_interface.h"
#include "igraph_structural.h"

/**
 * \section about_graph_isomorphism
 *
 * igraph provides four set of functions to deal with graph
 * isomorphism problems.
 *
 * The \ref igraph_isomorphic() and \ref igraph_subisomorphic()
 * functions make up the first set (in addition with the \ref
 * igraph_permute_vertices() function). These functions choose the
 * algorithm which is best for the supplied input graph. (The choice is
 * not very sophisticated though, see their documentation for
 * details.)
 *
 * The VF2 graph (and subgraph) isomorphism algorithm is implemented in
 * igraph, these functions are the second set. See \ref
 * igraph_isomorphic_vf2() and \ref igraph_subisomorphic_vf2() for
 * starters.
 *
 * Functions for the Bliss algorithm constitute the third set,
 * see \ref igraph_isomorphic_bliss().
 *
 * Finally, the isomorphism classes of all graphs with three and
 * four vertices are precomputed and stored in igraph, so for these
 * small graphs there is a very simple fast way to decide isomorphism.
 * See \ref igraph_isomorphic_34().
 * 
 */

/**
 * \function igraph_isomorphic
 * \brief Decides whether two graphs are isomorphic
 *
 * 
 * In simple terms, two graphs are isomorphic if they become indistinguishable
 * from each other once their vertex labels are removed (rendering the vertices
 * within each graph indistiguishable). More precisely, two graphs are isomorphic
 * if there is a one-to-one mapping from the vertices of the first one
 * to the vertices of the second such that it transforms the edge set of the
 * first graph into the edge set of the second. This mapping is called
 * an \em isomorphism.
 *
 * Currently, this function supports simple graphs and graphs
 * with self-loops, but does not support multigraphs.
 *
 * This function decides which graph isomorphism algorithm to be
 * used based on the input graphs. Right now it does the following:
 * \olist
 * \oli If one graph is directed and the other undirected then an
 *    error is triggered.
 * \oli If one of the graphs has multi-edges then an error is triggered.
 * \oli If the two graphs does not have the same number of vertices
 *    and edges it returns with \c FALSE.
 * \oli Otherwise, if the graphs have three or four vertices then an O(1)
 *    algorithm is used with precomputed data.
 * \oli Otherwise Bliss is used, see \ref igraph_isomorphic_bliss().
 * \endolist
 *
 * Please call the VF2 and Bliss functions directly if you need
 * something more sophisticated, e.g. you need the isomorphic mapping.
 *
 * \param graph1 The first graph.
 * \param graph2 The second graph.
 * \param iso Pointer to a logical variable, will be set to TRUE (1)
 *        if the two graphs are isomorphic, and FALSE (0) otherwise.
 * \return Error code.
 * \sa \ref igraph_isoclass(), \ref igraph_isoclass_subgraph(),
 * \ref igraph_isoclass_create().
 *
 * Time complexity: exponential.
 */
int igraph_isomorphic(const igraph_t *graph1, const igraph_t *graph2,
                      igraph_bool_t *iso) {

    long int nodes1 = igraph_vcount(graph1), nodes2 = igraph_vcount(graph2);
    long int edges1 = igraph_ecount(graph1), edges2 = igraph_ecount(graph2);
    igraph_bool_t dir1 = igraph_is_directed(graph1), dir2 = igraph_is_directed(graph2);
    igraph_bool_t loop1, loop2, multi1, multi2;

    IGRAPH_CHECK(igraph_has_multiple(graph1, &multi1));
    IGRAPH_CHECK(igraph_has_multiple(graph2, &multi2));

    if (multi1 || multi2) {
        IGRAPH_ERROR("Isomorphism testing is not implemented for multigraphs", IGRAPH_UNIMPLEMENTED);
    }

    if (dir1 != dir2) {
        IGRAPH_ERROR("Cannot compare directed and undirected graphs", IGRAPH_EINVAL);
    } else if (nodes1 != nodes2 || edges1 != edges2) {
        *iso = 0;
    } else if (nodes1 == 3 || nodes1 == 4) {
        IGRAPH_CHECK(igraph_has_loop(graph1, &loop1));
        IGRAPH_CHECK(igraph_has_loop(graph2, &loop2));
        if (!loop1 && !loop2) {
            IGRAPH_CHECK(igraph_isomorphic_34(graph1, graph2, iso));
        } else {
            IGRAPH_CHECK(igraph_isomorphic_bliss(graph1, graph2, NULL, NULL, iso,
                                                 0, 0, /*sh=*/ IGRAPH_BLISS_FL, 0, 0));
        }
    } else {
        IGRAPH_CHECK(igraph_isomorphic_bliss(graph1, graph2, NULL, NULL, iso,
                                             0, 0, /*sh=*/ IGRAPH_BLISS_FL, 0, 0));
    }

    return 0;
}

/**
 * \function igraph_isomorphic_34
 * Graph isomorphism for 3-4 vertices
 *
 * This function uses precomputed indices to decide isomorphism
 * problems for graphs with only 3 or 4 vertices. Multi-edges
 * and self-loops are ignored by this function.
 * \param graph1 The first input graph.
 * \param graph2 The second input graph. Must have the same
 *   directedness as \p graph1.
 * \param iso Pointer to a boolean, the result is stored here.
 * \return Error code.
 *
 * Time complexity: O(1).
 */
int igraph_isomorphic_34(const igraph_t *graph1, const igraph_t *graph2,
                         igraph_bool_t *iso) {

    igraph_integer_t class1, class2;
    IGRAPH_CHECK(igraph_isoclass(graph1, &class1));
    IGRAPH_CHECK(igraph_isoclass(graph2, &class2));
    *iso = (class1 == class2);
    return 0;
}

/**
 * \function igraph_subisomorphic
 * \brief Decide subgraph isomorphism.
 *
 * Check whether \p graph2 is isomorphic to a subgraph of \p graph1.
 * Currently this function just calls \ref igraph_subisomorphic_vf2()
 * for all graphs.
 *
 * 
 * Currently this function does not support non-simple graphs.
 *
 * \param graph1 The first input graph, may be directed or
 *   undirected. This is supposed to be the bigger graph.
 * \param graph2 The second input graph, it must have the same
 *   directedness as \p graph2, or an error is triggered. This is
 *   supposed to be the smaller graph.
 * \param iso Pointer to a boolean, the result is stored here.
 * \return Error code.
 *
 * Time complexity: exponential.
 */
int igraph_subisomorphic(const igraph_t *graph1, const igraph_t *graph2,
                         igraph_bool_t *iso) {

    return igraph_subisomorphic_vf2(graph1, graph2, NULL, NULL, NULL, NULL, iso, NULL, NULL, NULL, NULL, NULL);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/isomorphism/vf2.c0000644000175100001710000022536100000000000023664 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_topology.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_stack.h"

#include "core/interruption.h"

/**
 * \section about_vf2
 *
 * 
 * The VF2 algorithm can search for a subgraph in a larger graph, or check if two
 * graphs are isomorphic. See P. Foggia, C. Sansone, M. Vento, An Improved algorithm for
 * matching large graphs, Proc. of the 3rd IAPR-TC-15 International
 * Workshop on Graph-based Representations, Italy, 2001.
 * 
 *
 * 
 * VF2 supports both vertex and edge-colored graphs, as well as custom vertex or edge
 * compatibility functions.
 * 
 *
 * 
 * VF2 works with both directed and undirected graphs. Only simple graphs are supported.
 * Self-loops or multi-edges must not be present in the graphs. Currently, the VF2
 * functions do not check that the input graph is simple: it is the responsibility
 * of the user to pass in valid input.
 * 
 */

/**
 * \function igraph_isomorphic_function_vf2
 * The generic VF2 interface
 *
 * 
 * This function is an implementation of the VF2 isomorphism algorithm,
 * see P. Foggia, C. Sansone, M. Vento, An Improved algorithm for
 * matching large graphs, Proc. of the 3rd IAPR-TC-15 International
 * Workshop on Graph-based Representations, Italy, 2001.
 *
 * For using it you need to define a callback function of type
 * \ref igraph_isohandler_t. This function will be called whenever VF2
 * finds an isomorphism between the two graphs. The mapping between
 * the two graphs will be also provided to this function. If the
 * callback returns a nonzero value then the search is continued,
 * otherwise it stops. The callback function must not destroy the
 * mapping vectors that are passed to it.
 * \param graph1 The first input graph.
 * \param graph2 The second input graph.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param map12 Pointer to an initialized vector or \c NULL. If not \c
 *   NULL and the supplied graphs are isomorphic then the permutation
 *   taking \p graph1 to \p graph is stored here. If not \c NULL and the
 *   graphs are not isomorphic then a zero-length vector is returned.
 * \param map21 This is the same as \p map12, but for the permutation
 *   taking \p graph2 to \p graph1.
 * \param isohandler_fn The callback function to be called if an
 *   isomorphism is found. See also \ref igraph_isohandler_t.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p isohandler_fn, \p
 *   node_compat_fn and \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_isomorphic_function_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                   const igraph_vector_int_t *vertex_color1,
                                   const igraph_vector_int_t *vertex_color2,
                                   const igraph_vector_int_t *edge_color1,
                                   const igraph_vector_int_t *edge_color2,
                                   igraph_vector_t *map12,
                                   igraph_vector_t *map21,
                                   igraph_isohandler_t *isohandler_fn,
                                   igraph_isocompat_t *node_compat_fn,
                                   igraph_isocompat_t *edge_compat_fn,
                                   void *arg) {

    long int no_of_nodes = igraph_vcount(graph1);
    long int no_of_edges = igraph_ecount(graph1);
    igraph_vector_t mycore_1, mycore_2, *core_1 = &mycore_1, *core_2 = &mycore_2;
    igraph_vector_t in_1, in_2, out_1, out_2;
    long int in_1_size = 0, in_2_size = 0, out_1_size = 0, out_2_size = 0;
    igraph_vector_int_t *inneis_1, *inneis_2, *outneis_1, *outneis_2;
    long int matched_nodes = 0;
    long int depth;
    long int cand1, cand2;
    long int last1, last2;
    igraph_stack_t path;
    igraph_lazy_adjlist_t inadj1, inadj2, outadj1, outadj2;
    igraph_vector_t indeg1, indeg2, outdeg1, outdeg2;
    long int vsize;

    if (igraph_is_directed(graph1) != igraph_is_directed(graph2)) {
        IGRAPH_ERROR("Cannot compare directed and undirected graphs",
                     IGRAPH_EINVAL);
    }

    if ( (vertex_color1 && !vertex_color2) || (!vertex_color1 && vertex_color2) ) {
        IGRAPH_WARNING("Only one graph is vertex-colored, vertex colors will be ignored");
        vertex_color1 = vertex_color2 = 0;
    }

    if ( (edge_color1 && !edge_color2) || (!edge_color1 && edge_color2)) {
        IGRAPH_WARNING("Only one graph is edge-colored, edge colors will be ignored");
        edge_color1 = edge_color2 = 0;
    }

    if (no_of_nodes != igraph_vcount(graph2) ||
        no_of_edges != igraph_ecount(graph2)) {
        return 0;
    }

    if (vertex_color1) {
        if (igraph_vector_int_size(vertex_color1) != no_of_nodes ||
            igraph_vector_int_size(vertex_color2) != no_of_nodes) {
            IGRAPH_ERROR("Invalid vertex color vector length", IGRAPH_EINVAL);
        }
    }

    if (edge_color1) {
        if (igraph_vector_int_size(edge_color1) != no_of_edges ||
            igraph_vector_int_size(edge_color2) != no_of_edges) {
            IGRAPH_ERROR("Invalid edge color vector length", IGRAPH_EINVAL);
        }
    }

    /* Check color distribution */
    if (vertex_color1) {
        int ret = 0;
        igraph_vector_int_t tmp1, tmp2;
        IGRAPH_CHECK(igraph_vector_int_copy(&tmp1, vertex_color1));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &tmp1);
        IGRAPH_CHECK(igraph_vector_int_copy(&tmp2, vertex_color2));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &tmp2);
        igraph_vector_int_sort(&tmp1);
        igraph_vector_int_sort(&tmp2);
        ret = !igraph_vector_int_all_e(&tmp1, &tmp2);
        igraph_vector_int_destroy(&tmp1);
        igraph_vector_int_destroy(&tmp2);
        IGRAPH_FINALLY_CLEAN(2);
        if (ret) {
            return 0;
        }
    }

    /* Check edge color distribution */
    if (edge_color1) {
        int ret = 0;
        igraph_vector_int_t tmp1, tmp2;
        IGRAPH_CHECK(igraph_vector_int_copy(&tmp1, edge_color1));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &tmp1);
        IGRAPH_CHECK(igraph_vector_int_copy(&tmp2, edge_color2));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &tmp2);
        igraph_vector_int_sort(&tmp1);
        igraph_vector_int_sort(&tmp2);
        ret = !igraph_vector_int_all_e(&tmp1, &tmp2);
        igraph_vector_int_destroy(&tmp1);
        igraph_vector_int_destroy(&tmp2);
        IGRAPH_FINALLY_CLEAN(2);
        if (ret) {
            return 0;
        }
    }

    if (map12) {
        core_1 = map12;
        IGRAPH_CHECK(igraph_vector_resize(core_1, no_of_nodes));
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(core_1, no_of_nodes);
    }
    igraph_vector_fill(core_1, -1);
    if (map21) {
        core_2 = map21;
        IGRAPH_CHECK(igraph_vector_resize(core_2, no_of_nodes));
        igraph_vector_null(core_2);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(core_2, no_of_nodes);
    }
    igraph_vector_fill(core_2, -1);

    IGRAPH_VECTOR_INIT_FINALLY(&in_1, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&in_2, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&out_1, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&out_2, no_of_nodes);
    IGRAPH_CHECK(igraph_stack_init(&path, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph1, &inadj1, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &inadj1);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph1, &outadj1, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &outadj1);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph2, &inadj2, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &inadj2);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph2, &outadj2, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &outadj2);
    IGRAPH_VECTOR_INIT_FINALLY(&indeg1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&indeg2, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outdeg1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outdeg2, 0);

    IGRAPH_CHECK(igraph_stack_reserve(&path, no_of_nodes * 2));
    IGRAPH_CHECK(igraph_degree(graph1, &indeg1, igraph_vss_all(),
                               IGRAPH_IN, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph2, &indeg2, igraph_vss_all(),
                               IGRAPH_IN, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph1, &outdeg1, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph2, &outdeg2, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_LOOPS));

    depth = 0; last1 = -1; last2 = -1;
    while (depth >= 0) {
        long int i;

        IGRAPH_ALLOW_INTERRUPTION();

        cand1 = -1; cand2 = -1;
        /* Search for the next pair to try */
        if ((in_1_size != in_2_size) ||
            (out_1_size != out_2_size)) {
            /* step back, nothing to do */
        } else if (out_1_size > 0 && out_2_size > 0) {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes) {
                    if (VECTOR(out_2)[i] > 0 && VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1 now, it should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes) {
                if (VECTOR(out_1)[i] > 0 && VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        } else if (in_1_size > 0 && in_2_size > 0) {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes) {
                    if (VECTOR(in_2)[i] > 0 && VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1 now, should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes) {
                if (VECTOR(in_1)[i] > 0 && VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        } else {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes) {
                    if (VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1, should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes) {
                if (VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        }

        /* Ok, we have cand1, cand2 as candidates. Or not? */
        if (cand1 < 0 || cand2 < 0) {
            /**************************************************************/
            /* dead end, step back, if possible. Otherwise we'll terminate */
            if (depth >= 1) {
                last2 = (long int) igraph_stack_pop(&path);
                last1 = (long int) igraph_stack_pop(&path);
                matched_nodes -= 1;
                VECTOR(*core_1)[last1] = -1;
                VECTOR(*core_2)[last2] = -1;

                if (VECTOR(in_1)[last1] != 0) {
                    in_1_size += 1;
                }
                if (VECTOR(out_1)[last1] != 0) {
                    out_1_size += 1;
                }
                if (VECTOR(in_2)[last2] != 0) {
                    in_2_size += 1;
                }
                if (VECTOR(out_2)[last2] != 0) {
                    out_2_size += 1;
                }

                inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) last1);
                vsize = igraph_vector_int_size(inneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_1)[i];
                    if (VECTOR(in_1)[node] == depth) {
                        VECTOR(in_1)[node] = 0;
                        in_1_size -= 1;
                    }
                }
                outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) last1);
                vsize = igraph_vector_int_size(outneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_1)[i];
                    if (VECTOR(out_1)[node] == depth) {
                        VECTOR(out_1)[node] = 0;
                        out_1_size -= 1;
                    }
                }
                inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) last2);
                vsize = igraph_vector_int_size(inneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_2)[i];
                    if (VECTOR(in_2)[node] == depth) {
                        VECTOR(in_2)[node] = 0;
                        in_2_size -= 1;
                    }
                }
                outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) last2);
                vsize = igraph_vector_int_size(outneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_2)[i];
                    if (VECTOR(out_2)[node] == depth) {
                        VECTOR(out_2)[node] = 0;
                        out_2_size -= 1;
                    }
                }

            } /* end of stepping back */

            depth -= 1;

        } else {
            /**************************************************************/
            /* step forward if worth, check if worth first */
            long int xin1 = 0, xin2 = 0, xout1 = 0, xout2 = 0;
            igraph_bool_t end = 0;
            inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) cand1);
            outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) cand1);
            inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) cand2);
            outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) cand2);
            if (VECTOR(indeg1)[cand1] != VECTOR(indeg2)[cand2] ||
                VECTOR(outdeg1)[cand1] != VECTOR(outdeg2)[cand2]) {
                end = 1;
            }
            if (vertex_color1 && VECTOR(*vertex_color1)[cand1] != VECTOR(*vertex_color2)[cand2]) {
                end = 1;
            }
            if (node_compat_fn && !node_compat_fn(graph1, graph2,
                                                  (igraph_integer_t) cand1,
                                                  (igraph_integer_t) cand2, arg)) {
                end = 1;
            }

            vsize = igraph_vector_int_size(inneis_1);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*inneis_1)[i];
                if (VECTOR(*core_1)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_1)[node];
                    /* check if there is a node2->cand2 edge */
                    if (!igraph_vector_int_binsearch2(inneis_2, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) node,
                                       (igraph_integer_t) cand1, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) node2,
                                       (igraph_integer_t) cand2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_1)[node] != 0) {
                        xin1++;
                    }
                    if (VECTOR(out_1)[node] != 0) {
                        xout1++;
                    }
                }
            }
            vsize = igraph_vector_int_size(outneis_1);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*outneis_1)[i];
                if (VECTOR(*core_1)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_1)[node];
                    /* check if there is a cand2->node2 edge */
                    if (!igraph_vector_int_binsearch2(outneis_2, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) cand1,
                                       (igraph_integer_t) node, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) cand2,
                                       (igraph_integer_t) node2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_1)[node] != 0) {
                        xin1++;
                    }
                    if (VECTOR(out_1)[node] != 0) {
                        xout1++;
                    }
                }
            }
            vsize = igraph_vector_int_size(inneis_2);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*inneis_2)[i];
                if (VECTOR(*core_2)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_2)[node];
                    /* check if there is a node2->cand1 edge */
                    if (!igraph_vector_int_binsearch2(inneis_1, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) node2,
                                       (igraph_integer_t) cand1, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) node,
                                       (igraph_integer_t) cand2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_2)[node] != 0) {
                        xin2++;
                    }
                    if (VECTOR(out_2)[node] != 0) {
                        xout2++;
                    }
                }
            }
            vsize = igraph_vector_int_size(outneis_2);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*outneis_2)[i];
                if (VECTOR(*core_2)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_2)[node];
                    /* check if there is a cand1->node2 edge */
                    if (!igraph_vector_int_binsearch2(outneis_1, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) cand1,
                                       (igraph_integer_t) node2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) cand2,
                                       (igraph_integer_t) node, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_2)[node] != 0) {
                        xin2++;
                    }
                    if (VECTOR(out_2)[node] != 0) {
                        xout2++;
                    }
                }
            }

            if (!end && (xin1 == xin2 && xout1 == xout2)) {
                /* Ok, we add the (cand1, cand2) pair to the mapping */
                depth += 1;
                IGRAPH_CHECK(igraph_stack_push(&path, cand1));
                IGRAPH_CHECK(igraph_stack_push(&path, cand2));
                matched_nodes += 1;
                VECTOR(*core_1)[cand1] = cand2;
                VECTOR(*core_2)[cand2] = cand1;

                /* update in_*, out_* */
                if (VECTOR(in_1)[cand1] != 0) {
                    in_1_size -= 1;
                }
                if (VECTOR(out_1)[cand1] != 0) {
                    out_1_size -= 1;
                }
                if (VECTOR(in_2)[cand2] != 0) {
                    in_2_size -= 1;
                }
                if (VECTOR(out_2)[cand2] != 0) {
                    out_2_size -= 1;
                }

                inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) cand1);
                vsize = igraph_vector_int_size(inneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_1)[i];
                    if (VECTOR(in_1)[node] == 0 && VECTOR(*core_1)[node] < 0) {
                        VECTOR(in_1)[node] = depth;
                        in_1_size += 1;
                    }
                }
                outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) cand1);
                vsize = igraph_vector_int_size(outneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_1)[i];
                    if (VECTOR(out_1)[node] == 0 && VECTOR(*core_1)[node] < 0) {
                        VECTOR(out_1)[node] = depth;
                        out_1_size += 1;
                    }
                }
                inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) cand2);
                vsize = igraph_vector_int_size(inneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_2)[i];
                    if (VECTOR(in_2)[node] == 0 && VECTOR(*core_2)[node] < 0) {
                        VECTOR(in_2)[node] = depth;
                        in_2_size += 1;
                    }
                }
                outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) cand2);
                vsize = igraph_vector_int_size(outneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_2)[i];
                    if (VECTOR(out_2)[node] == 0 && VECTOR(*core_2)[node] < 0) {
                        VECTOR(out_2)[node] = depth;
                        out_2_size += 1;
                    }
                }
                last1 = -1; last2 = -1;       /* this the first time here */
            } else {
                last1 = cand1;
                last2 = cand2;
            }

        }

        if (matched_nodes == no_of_nodes && isohandler_fn) {
            if (!isohandler_fn(core_1, core_2, arg)) {
                break;
            }
        }
    }

    igraph_vector_destroy(&outdeg2);
    igraph_vector_destroy(&outdeg1);
    igraph_vector_destroy(&indeg2);
    igraph_vector_destroy(&indeg1);
    igraph_lazy_adjlist_destroy(&outadj2);
    igraph_lazy_adjlist_destroy(&inadj2);
    igraph_lazy_adjlist_destroy(&outadj1);
    igraph_lazy_adjlist_destroy(&inadj1);
    igraph_stack_destroy(&path);
    igraph_vector_destroy(&out_2);
    igraph_vector_destroy(&out_1);
    igraph_vector_destroy(&in_2);
    igraph_vector_destroy(&in_1);
    IGRAPH_FINALLY_CLEAN(13);
    if (!map21) {
        igraph_vector_destroy(core_2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!map12) {
        igraph_vector_destroy(core_1);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

typedef struct {
    igraph_isocompat_t *node_compat_fn, *edge_compat_fn;
    void *arg, *carg;
} igraph_i_iso_cb_data_t;

static igraph_bool_t igraph_i_isocompat_node_cb(
        const igraph_t *graph1,
        const igraph_t *graph2,
        const igraph_integer_t g1_num,
        const igraph_integer_t g2_num,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    return data->node_compat_fn(graph1, graph2, g1_num, g2_num, data->carg);
}

static igraph_bool_t igraph_i_isocompat_edge_cb(
        const igraph_t *graph1,
        const igraph_t *graph2,
        const igraph_integer_t g1_num,
        const igraph_integer_t g2_num,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    return data->edge_compat_fn(graph1, graph2, g1_num, g2_num, data->carg);
}

static igraph_bool_t igraph_i_isomorphic_vf2(igraph_vector_t *map12,
                                             igraph_vector_t *map21,
                                             void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_bool_t *iso = data->arg;
    IGRAPH_UNUSED(map12); IGRAPH_UNUSED(map21);
    *iso = 1;
    return 0;         /* don't need to continue */
}

/**
 * \function igraph_isomorphic_vf2
 * \brief Isomorphism via VF2
 *
 * 
 * This function performs the VF2 algorithm via calling \ref
 * igraph_isomorphic_function_vf2().
 *
 *  Note that this function cannot be used for
 * deciding subgraph isomorphism, use \ref igraph_subisomorphic_vf2()
 * for that.
 * \param graph1 The first graph, may be directed or undirected.
 * \param graph2 The second graph. It must have the same directedness
 *    as \p graph1, otherwise an error is reported.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param iso Pointer to a logical constant, the result of the
 *    algorithm will be placed here.
 * \param map12 Pointer to an initialized vector or a NULL pointer. If not
 *    a NULL pointer then the mapping from \p graph1 to \p graph2 is
 *    stored here. If the graphs are not isomorphic then the vector is
 *    cleared (i.e. has zero elements).
 * \param map21 Pointer to an initialized vector or a NULL pointer. If not
 *    a NULL pointer then the mapping from \p graph2 to \p graph1 is
 *    stored here. If the graphs are not isomorphic then the vector is
 *    cleared (i.e. has zero elements).
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn
 *   and \p edge_compat_fn.
 * \return Error code.
 *
 * \sa \ref igraph_subisomorphic_vf2(),
 * \ref igraph_count_isomorphisms_vf2(),
 * \ref igraph_get_isomorphisms_vf2(),
 *
 * Time complexity: exponential, what did you expect?
 *
 * \example examples/simple/igraph_isomorphic_vf2.c
 */

int igraph_isomorphic_vf2(const igraph_t *graph1, const igraph_t *graph2,
                          const igraph_vector_int_t *vertex_color1,
                          const igraph_vector_int_t *vertex_color2,
                          const igraph_vector_int_t *edge_color1,
                          const igraph_vector_int_t *edge_color2,
                          igraph_bool_t *iso, igraph_vector_t *map12,
                          igraph_vector_t *map21,
                          igraph_isocompat_t *node_compat_fn,
                          igraph_isocompat_t *edge_compat_fn,
                          void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn, iso, arg };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : 0;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : 0;
    *iso = 0;
    IGRAPH_CHECK(igraph_isomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 map12, map21,
                 (igraph_isohandler_t*)
                 igraph_i_isomorphic_vf2,
                 ncb, ecb, &data));
    if (! *iso) {
        if (map12) {
            igraph_vector_clear(map12);
        }
        if (map21) {
            igraph_vector_clear(map21);
        }
    }
    return 0;
}

static igraph_bool_t igraph_i_count_isomorphisms_vf2(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_integer_t *count = data->arg;
    IGRAPH_UNUSED(map12); IGRAPH_UNUSED(map21);
    *count += 1;
    return 1;         /* always continue */
}

/**
 * \function igraph_count_isomorphisms_vf2
 * Number of isomorphisms via VF2
 *
 * This function counts the number of isomorphic mappings between two
 * graphs. It uses the generic \ref igraph_isomorphic_function_vf2()
 * function.
 * \param graph1 The first input graph, may be directed or undirected.
 * \param graph2 The second input graph, it must have the same
 *   directedness as \p graph1, or an error will be reported.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param count Point to an integer, the result will be stored here.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn and
 *   \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_count_isomorphisms_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                  const igraph_vector_int_t *vertex_color1,
                                  const igraph_vector_int_t *vertex_color2,
                                  const igraph_vector_int_t *edge_color1,
                                  const igraph_vector_int_t *edge_color2,
                                  igraph_integer_t *count,
                                  igraph_isocompat_t *node_compat_fn,
                                  igraph_isocompat_t *edge_compat_fn,
                                  void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn,
                                    count, arg
                                  };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : 0;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : 0;
    *count = 0;
    IGRAPH_CHECK(igraph_isomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 0, 0,
                 (igraph_isohandler_t*)
                 igraph_i_count_isomorphisms_vf2,
                 ncb, ecb, &data));
    return 0;
}

static void igraph_i_get_isomorphisms_free(igraph_vector_ptr_t *data) {
    long int i, n = igraph_vector_ptr_size(data);
    for (i = 0; i < n; i++) {
        igraph_vector_t *vec = VECTOR(*data)[i];
        igraph_vector_destroy(vec);
        igraph_free(vec);
    }
}

static int igraph_i_get_isomorphisms_vf2_inner(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_vector_ptr_t *ptrvector = data->arg;
    igraph_vector_t *newvector = IGRAPH_CALLOC(1, igraph_vector_t);
    IGRAPH_UNUSED(map12);
    if (!newvector) {
        IGRAPH_ERROR("", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newvector);
    IGRAPH_CHECK(igraph_vector_copy(newvector, map21));
    IGRAPH_FINALLY(igraph_vector_destroy, newvector);
    IGRAPH_CHECK(igraph_vector_ptr_push_back(ptrvector, newvector));
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

static igraph_bool_t igraph_i_get_isomorphisms_vf2(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    return igraph_i_get_isomorphisms_vf2_inner(map12, map21, arg) == IGRAPH_SUCCESS;
}

/**
 * \function igraph_get_isomorphisms_vf2
 * \brief Collect all isomorphic mappings of two graphs.
 *
 * This function finds all the isomorphic mappings between two simple
 * graphs. It uses the \ref igraph_isomorphic_function_vf2()
 * function. Call the function with the same graph as \p graph1 and \p
 * graph2 to get automorphisms.
 * \param graph1 The first input graph, may be directed or undirected.
 * \param graph2 The second input graph, it must have the same
 *   directedness as \p graph1, or an error will be reported.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param maps Pointer vector. On return it is empty if the input graphs
 *   are not isomorphic. Otherwise it contains pointers to
 *   \ref igraph_vector_t objects, each vector is an
 *   isomorphic mapping of \p graph2 to \p graph1. Please note that
 *   you need to 1) Destroy the vectors via \ref
 *   igraph_vector_destroy(), 2) free them via
 *   \ref igraph_free() and then 3) call \ref
 *   igraph_vector_ptr_destroy() on the pointer vector to deallocate all
 *   memory when \p maps is no longer needed.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn
 *   and \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_get_isomorphisms_vf2(const igraph_t *graph1,
                                const igraph_t *graph2,
                                const igraph_vector_int_t *vertex_color1,
                                const igraph_vector_int_t *vertex_color2,
                                const igraph_vector_int_t *edge_color1,
                                const igraph_vector_int_t *edge_color2,
                                igraph_vector_ptr_t *maps,
                                igraph_isocompat_t *node_compat_fn,
                                igraph_isocompat_t *edge_compat_fn,
                                void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn, maps, arg };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : NULL;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : NULL;

    igraph_vector_ptr_clear(maps);
    IGRAPH_FINALLY(igraph_i_get_isomorphisms_free, maps);
    IGRAPH_CHECK(igraph_isomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 NULL, NULL,
                 (igraph_isohandler_t*)
                 igraph_i_get_isomorphisms_vf2,
                 ncb, ecb, &data));
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_subisomorphic_function_vf2
 * Generic VF2 function for subgraph isomorphism problems
 *
 * This function is the pair of \ref igraph_isomorphic_function_vf2(),
 * for subgraph isomorphism problems. It searches for subgraphs of \p
 * graph1 which are isomorphic to \p graph2. When it founds an
 * isomorphic mapping it calls the supplied callback \p isohandler_fn.
 * The mapping (and its inverse) and the additional \p arg argument
 * are supplied to the callback.
 * \param graph1 The first input graph, may be directed or
 *    undirected. This is supposed to be the larger graph.
 * \param graph2 The second input graph, it must have the same
 *    directedness as \p graph1. This is supposed to be the smaller
 *    graph.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the subgraph isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param map12 Pointer to a vector or \c NULL. If not \c NULL, then an
 *    isomorphic mapping from \p graph1 to \p graph2 is stored here.
 * \param map21 Pointer to a vector ot \c NULL. If not \c NULL, then
 *    an isomorphic mapping from \p graph2 to \p graph1 is stored
 *    here.
 * \param isohandler_fn A pointer to a function of type \ref
 *   igraph_isohandler_t. This will be called whenever a subgraph
 *   isomorphism is found. If the function returns with a non-zero value
 *   then the search is continued, otherwise it stops and the function
 *   returns.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p isohandler_fn, \p
 *   node_compat_fn and \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_subisomorphic_function_vf2(const igraph_t *graph1,
                                      const igraph_t *graph2,
                                      const igraph_vector_int_t *vertex_color1,
                                      const igraph_vector_int_t *vertex_color2,
                                      const igraph_vector_int_t *edge_color1,
                                      const igraph_vector_int_t *edge_color2,
                                      igraph_vector_t *map12,
                                      igraph_vector_t *map21,
                                      igraph_isohandler_t *isohandler_fn,
                                      igraph_isocompat_t *node_compat_fn,
                                      igraph_isocompat_t *edge_compat_fn,
                                      void *arg) {

    long int no_of_nodes1 = igraph_vcount(graph1),
             no_of_nodes2 = igraph_vcount(graph2);
    long int no_of_edges1 = igraph_ecount(graph1),
             no_of_edges2 = igraph_ecount(graph2);
    igraph_vector_t mycore_1, mycore_2, *core_1 = &mycore_1, *core_2 = &mycore_2;
    igraph_vector_t in_1, in_2, out_1, out_2;
    long int in_1_size = 0, in_2_size = 0, out_1_size = 0, out_2_size = 0;
    igraph_vector_int_t *inneis_1, *inneis_2, *outneis_1, *outneis_2;
    long int matched_nodes = 0;
    long int depth;
    long int cand1, cand2;
    long int last1, last2;
    igraph_stack_t path;
    igraph_lazy_adjlist_t inadj1, inadj2, outadj1, outadj2;
    igraph_vector_t indeg1, indeg2, outdeg1, outdeg2;
    long int vsize;

    if (igraph_is_directed(graph1) != igraph_is_directed(graph2)) {
        IGRAPH_ERROR("Cannot compare directed and undirected graphs",
                     IGRAPH_EINVAL);
    }

    if (no_of_nodes1 < no_of_nodes2 ||
        no_of_edges1 < no_of_edges2) {
        return 0;
    }

    if ( (vertex_color1 && !vertex_color2) || (!vertex_color1 && vertex_color2) ) {
        IGRAPH_WARNING("Only one graph is vertex colored, colors will be ignored");
        vertex_color1 = vertex_color2 = 0;
    }

    if ( (edge_color1 && !edge_color2) || (!edge_color1 && edge_color2) ) {
        IGRAPH_WARNING("Only one graph is edge colored, colors will be ignored");
        edge_color1 = edge_color2 = 0;
    }

    if (vertex_color1) {
        if (igraph_vector_int_size(vertex_color1) != no_of_nodes1 ||
            igraph_vector_int_size(vertex_color2) != no_of_nodes2) {
            IGRAPH_ERROR("Invalid vertex color vector length", IGRAPH_EINVAL);
        }
    }

    if (edge_color1) {
        if (igraph_vector_int_size(edge_color1) != no_of_edges1 ||
            igraph_vector_int_size(edge_color2) != no_of_edges2) {
            IGRAPH_ERROR("Invalid edge color vector length", IGRAPH_EINVAL);
        }
    }

    /* Check color distribution */
    if (vertex_color1) {
        /* TODO */
    }

    /* Check edge color distribution */
    if (edge_color1) {
        /* TODO */
    }

    if (map12) {
        core_1 = map12;
        IGRAPH_CHECK(igraph_vector_resize(core_1, no_of_nodes1));
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(core_1, no_of_nodes1);
    }
    igraph_vector_fill(core_1, -1);
    if (map21) {
        core_2 = map21;
        IGRAPH_CHECK(igraph_vector_resize(core_2, no_of_nodes2));
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(core_2, no_of_nodes2);
    }
    igraph_vector_fill(core_2, -1);
    IGRAPH_VECTOR_INIT_FINALLY(&in_1, no_of_nodes1);
    IGRAPH_VECTOR_INIT_FINALLY(&in_2, no_of_nodes2);
    IGRAPH_VECTOR_INIT_FINALLY(&out_1, no_of_nodes1);
    IGRAPH_VECTOR_INIT_FINALLY(&out_2, no_of_nodes2);
    IGRAPH_CHECK(igraph_stack_init(&path, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph1, &inadj1, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &inadj1);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph1, &outadj1, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &outadj1);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph2, &inadj2, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &inadj2);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph2, &outadj2, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &outadj2);
    IGRAPH_VECTOR_INIT_FINALLY(&indeg1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&indeg2, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outdeg1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outdeg2, 0);

    IGRAPH_CHECK(igraph_stack_reserve(&path, no_of_nodes2 * 2));
    IGRAPH_CHECK(igraph_degree(graph1, &indeg1, igraph_vss_all(),
                               IGRAPH_IN, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph2, &indeg2, igraph_vss_all(),
                               IGRAPH_IN, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph1, &outdeg1, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_degree(graph2, &outdeg2, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_LOOPS));

    depth = 0; last1 = -1; last2 = -1;
    while (depth >= 0) {
        long int i;

        IGRAPH_ALLOW_INTERRUPTION();

        cand1 = -1; cand2 = -1;
        /* Search for the next pair to try */
        if ((in_1_size < in_2_size) ||
            (out_1_size < out_2_size)) {
            /* step back, nothing to do */
        } else if (out_1_size > 0 && out_2_size > 0) {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes2) {
                    if (VECTOR(out_2)[i] > 0 && VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1 now, it should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes1) {
                if (VECTOR(out_1)[i] > 0 && VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        } else if (in_1_size > 0 && in_2_size > 0) {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes2) {
                    if (VECTOR(in_2)[i] > 0 && VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1 now, should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes1) {
                if (VECTOR(in_1)[i] > 0 && VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        } else {
            /**************************************************************/
            /* cand2, search not always needed */
            if (last2 >= 0) {
                cand2 = last2;
            } else {
                i = 0;
                while (cand2 < 0 && i < no_of_nodes2) {
                    if (VECTOR(*core_2)[i] < 0) {
                        cand2 = i;
                    }
                    i++;
                }
            }
            /* search for cand1, should be bigger than last1 */
            i = last1 + 1;
            while (cand1 < 0 && i < no_of_nodes1) {
                if (VECTOR(*core_1)[i] < 0) {
                    cand1 = i;
                }
                i++;
            }
        }

        /* Ok, we have cand1, cand2 as candidates. Or not? */
        if (cand1 < 0 || cand2 < 0) {
            /**************************************************************/
            /* dead end, step back, if possible. Otherwise we'll terminate */
            if (depth >= 1) {
                last2 = (long int) igraph_stack_pop(&path);
                last1 = (long int) igraph_stack_pop(&path);
                matched_nodes -= 1;
                VECTOR(*core_1)[last1] = -1;
                VECTOR(*core_2)[last2] = -1;

                if (VECTOR(in_1)[last1] != 0) {
                    in_1_size += 1;
                }
                if (VECTOR(out_1)[last1] != 0) {
                    out_1_size += 1;
                }
                if (VECTOR(in_2)[last2] != 0) {
                    in_2_size += 1;
                }
                if (VECTOR(out_2)[last2] != 0) {
                    out_2_size += 1;
                }

                inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) last1);
                vsize = igraph_vector_int_size(inneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_1)[i];
                    if (VECTOR(in_1)[node] == depth) {
                        VECTOR(in_1)[node] = 0;
                        in_1_size -= 1;
                    }
                }
                outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) last1);
                vsize = igraph_vector_int_size(outneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_1)[i];
                    if (VECTOR(out_1)[node] == depth) {
                        VECTOR(out_1)[node] = 0;
                        out_1_size -= 1;
                    }
                }
                inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) last2);
                vsize = igraph_vector_int_size(inneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_2)[i];
                    if (VECTOR(in_2)[node] == depth) {
                        VECTOR(in_2)[node] = 0;
                        in_2_size -= 1;
                    }
                }
                outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) last2);
                vsize = igraph_vector_int_size(outneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_2)[i];
                    if (VECTOR(out_2)[node] == depth) {
                        VECTOR(out_2)[node] = 0;
                        out_2_size -= 1;
                    }
                }

            } /* end of stepping back */

            depth -= 1;

        } else {
            /**************************************************************/
            /* step forward if worth, check if worth first */
            long int xin1 = 0, xin2 = 0, xout1 = 0, xout2 = 0;
            igraph_bool_t end = 0;
            inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) cand1);
            outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) cand1);
            inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) cand2);
            outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) cand2);
            if (VECTOR(indeg1)[cand1] < VECTOR(indeg2)[cand2] ||
                VECTOR(outdeg1)[cand1] < VECTOR(outdeg2)[cand2]) {
                end = 1;
            }
            if (vertex_color1 && VECTOR(*vertex_color1)[cand1] != VECTOR(*vertex_color2)[cand2]) {
                end = 1;
            }
            if (node_compat_fn && !node_compat_fn(graph1, graph2,
                                                  (igraph_integer_t) cand1,
                                                  (igraph_integer_t) cand2, arg)) {
                end = 1;
            }

            vsize = igraph_vector_int_size(inneis_1);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*inneis_1)[i];
                if (VECTOR(*core_1)[node] < 0) {
                    if (VECTOR(in_1)[node] != 0) {
                        xin1++;
                    }
                    if (VECTOR(out_1)[node] != 0) {
                        xout1++;
                    }
                }
            }
            vsize = igraph_vector_int_size(outneis_1);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*outneis_1)[i];
                if (VECTOR(*core_1)[node] < 0) {
                    if (VECTOR(in_1)[node] != 0) {
                        xin1++;
                    }
                    if (VECTOR(out_1)[node] != 0) {
                        xout1++;
                    }
                }
            }
            vsize = igraph_vector_int_size(inneis_2);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*inneis_2)[i];
                if (VECTOR(*core_2)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_2)[node];
                    /* check if there is a node2->cand1 edge */
                    if (!igraph_vector_int_binsearch2(inneis_1, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) node2,
                                       (igraph_integer_t) cand1, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) node,
                                       (igraph_integer_t) cand2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_2)[node] != 0) {
                        xin2++;
                    }
                    if (VECTOR(out_2)[node] != 0) {
                        xout2++;
                    }
                }
            }
            vsize = igraph_vector_int_size(outneis_2);
            for (i = 0; !end && i < vsize; i++) {
                long int node = (long int) VECTOR(*outneis_2)[i];
                if (VECTOR(*core_2)[node] >= 0) {
                    long int node2 = (long int) VECTOR(*core_2)[node];
                    /* check if there is a cand1->node2 edge */
                    if (!igraph_vector_int_binsearch2(outneis_1, node2)) {
                        end = 1;
                    } else if (edge_color1 || edge_compat_fn) {
                        igraph_integer_t eid1, eid2;
                        igraph_get_eid(graph1, &eid1, (igraph_integer_t) cand1,
                                       (igraph_integer_t) node2, /*directed=*/ 1,
                                       /*error=*/ 1);
                        igraph_get_eid(graph2, &eid2, (igraph_integer_t) cand2,
                                       (igraph_integer_t) node, /*directed=*/ 1,
                                       /*error=*/ 1);
                        if (edge_color1 && VECTOR(*edge_color1)[(long int)eid1] !=
                            VECTOR(*edge_color2)[(long int)eid2]) {
                            end = 1;
                        }
                        if (edge_compat_fn && !edge_compat_fn(graph1, graph2,
                                                              eid1, eid2, arg)) {
                            end = 1;
                        }
                    }
                } else {
                    if (VECTOR(in_2)[node] != 0) {
                        xin2++;
                    }
                    if (VECTOR(out_2)[node] != 0) {
                        xout2++;
                    }
                }
            }

            if (!end && (xin1 >= xin2 && xout1 >= xout2)) {
                /* Ok, we add the (cand1, cand2) pair to the mapping */
                depth += 1;
                IGRAPH_CHECK(igraph_stack_push(&path, cand1));
                IGRAPH_CHECK(igraph_stack_push(&path, cand2));
                matched_nodes += 1;
                VECTOR(*core_1)[cand1] = cand2;
                VECTOR(*core_2)[cand2] = cand1;

                /* update in_*, out_* */
                if (VECTOR(in_1)[cand1] != 0) {
                    in_1_size -= 1;
                }
                if (VECTOR(out_1)[cand1] != 0) {
                    out_1_size -= 1;
                }
                if (VECTOR(in_2)[cand2] != 0) {
                    in_2_size -= 1;
                }
                if (VECTOR(out_2)[cand2] != 0) {
                    out_2_size -= 1;
                }

                inneis_1 = igraph_lazy_adjlist_get(&inadj1, (igraph_integer_t) cand1);
                vsize = igraph_vector_int_size(inneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_1)[i];
                    if (VECTOR(in_1)[node] == 0 && VECTOR(*core_1)[node] < 0) {
                        VECTOR(in_1)[node] = depth;
                        in_1_size += 1;
                    }
                }
                outneis_1 = igraph_lazy_adjlist_get(&outadj1, (igraph_integer_t) cand1);
                vsize = igraph_vector_int_size(outneis_1);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_1)[i];
                    if (VECTOR(out_1)[node] == 0 && VECTOR(*core_1)[node] < 0) {
                        VECTOR(out_1)[node] = depth;
                        out_1_size += 1;
                    }
                }
                inneis_2 = igraph_lazy_adjlist_get(&inadj2, (igraph_integer_t) cand2);
                vsize = igraph_vector_int_size(inneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*inneis_2)[i];
                    if (VECTOR(in_2)[node] == 0 && VECTOR(*core_2)[node] < 0) {
                        VECTOR(in_2)[node] = depth;
                        in_2_size += 1;
                    }
                }
                outneis_2 = igraph_lazy_adjlist_get(&outadj2, (igraph_integer_t) cand2);
                vsize = igraph_vector_int_size(outneis_2);
                for (i = 0; i < vsize; i++) {
                    long int node = (long int) VECTOR(*outneis_2)[i];
                    if (VECTOR(out_2)[node] == 0 && VECTOR(*core_2)[node] < 0) {
                        VECTOR(out_2)[node] = depth;
                        out_2_size += 1;
                    }
                }
                last1 = -1; last2 = -1;       /* this the first time here */
            } else {
                last1 = cand1;
                last2 = cand2;
            }

        }

        if (matched_nodes == no_of_nodes2 && isohandler_fn) {
            if (!isohandler_fn(core_1, core_2, arg)) {
                break;
            }
        }
    }

    igraph_vector_destroy(&outdeg2);
    igraph_vector_destroy(&outdeg1);
    igraph_vector_destroy(&indeg2);
    igraph_vector_destroy(&indeg1);
    igraph_lazy_adjlist_destroy(&outadj2);
    igraph_lazy_adjlist_destroy(&inadj2);
    igraph_lazy_adjlist_destroy(&outadj1);
    igraph_lazy_adjlist_destroy(&inadj1);
    igraph_stack_destroy(&path);
    igraph_vector_destroy(&out_2);
    igraph_vector_destroy(&out_1);
    igraph_vector_destroy(&in_2);
    igraph_vector_destroy(&in_1);
    IGRAPH_FINALLY_CLEAN(13);
    if (!map21) {
        igraph_vector_destroy(core_2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!map12) {
        igraph_vector_destroy(core_1);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static igraph_bool_t igraph_i_subisomorphic_vf2(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_bool_t *iso = data->arg;
    IGRAPH_UNUSED(map12); IGRAPH_UNUSED(map21);
    *iso = 1;
    return 0; /* stop */
}

/**
 * \function igraph_subisomorphic_vf2
 * Decide subgraph isomorphism using VF2
 *
 * Decides whether a subgraph of \p graph1 is isomorphic to \p
 * graph2. It uses \ref igraph_subisomorphic_function_vf2().
 * \param graph1 The first input graph, may be directed or
 *    undirected. This is supposed to be the larger graph.
 * \param graph2 The second input graph, it must have the same
 *    directedness as \p graph1. This is supposed to be the smaller
 *    graph.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the subgraph isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param iso Pointer to a boolean. The result of the decision problem
 *    is stored here.
 * \param map12 Pointer to a vector or \c NULL. If not \c NULL, then an
 *    isomorphic mapping from \p graph1 to \p graph2 is stored here.
 * \param map21 Pointer to a vector ot \c NULL. If not \c NULL, then
 *    an isomorphic mapping from \p graph2 to \p graph1 is stored
 *    here.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn
 *   and \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_subisomorphic_vf2(const igraph_t *graph1, const igraph_t *graph2,
                             const igraph_vector_int_t *vertex_color1,
                             const igraph_vector_int_t *vertex_color2,
                             const igraph_vector_int_t *edge_color1,
                             const igraph_vector_int_t *edge_color2,
                             igraph_bool_t *iso, igraph_vector_t *map12,
                             igraph_vector_t *map21,
                             igraph_isocompat_t *node_compat_fn,
                             igraph_isocompat_t *edge_compat_fn,
                             void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn, iso, arg };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : 0;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : 0;

    *iso = 0;
    IGRAPH_CHECK(igraph_subisomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 map12, map21,
                 (igraph_isohandler_t *)
                 igraph_i_subisomorphic_vf2,
                 ncb, ecb, &data));
    if (! *iso) {
        if (map12) {
            igraph_vector_clear(map12);
        }
        if (map21) {
            igraph_vector_clear(map21);
        }
    }
    return 0;
}

static igraph_bool_t igraph_i_count_subisomorphisms_vf2(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_integer_t *count = data->arg;
    IGRAPH_UNUSED(map12); IGRAPH_UNUSED(map21);
    *count += 1;
    return 1;         /* always continue */
}

/**
 * \function igraph_count_subisomorphisms_vf2
 * Number of subgraph isomorphisms using VF2
 *
 * Count the number of isomorphisms between subgraphs of \p graph1 and
 * \p graph2. This function uses \ref
 * igraph_subisomorphic_function_vf2().
 * \param graph1 The first input graph, may be directed or
 *    undirected. This is supposed to be the larger graph.
 * \param graph2 The second input graph, it must have the same
 *    directedness as \p graph1. This is supposed to be the smaller
 *    graph.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the subgraph isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param count Pointer to an integer. The number of subgraph
 *    isomorphisms is stored here.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn and
 *   \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_count_subisomorphisms_vf2(const igraph_t *graph1, const igraph_t *graph2,
                                     const igraph_vector_int_t *vertex_color1,
                                     const igraph_vector_int_t *vertex_color2,
                                     const igraph_vector_int_t *edge_color1,
                                     const igraph_vector_int_t *edge_color2,
                                     igraph_integer_t *count,
                                     igraph_isocompat_t *node_compat_fn,
                                     igraph_isocompat_t *edge_compat_fn,
                                     void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn,
                                    count, arg
                                  };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : 0;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : 0;
    *count = 0;
    IGRAPH_CHECK(igraph_subisomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 0, 0,
                 (igraph_isohandler_t*)
                 igraph_i_count_subisomorphisms_vf2,
                 ncb, ecb, &data));
    return 0;
}

static void igraph_i_get_subisomorphisms_free(igraph_vector_ptr_t *data) {
    long int i, n = igraph_vector_ptr_size(data);
    for (i = 0; i < n; i++) {
        igraph_vector_t *vec = VECTOR(*data)[i];
        igraph_vector_destroy(vec);
        igraph_free(vec);
    }
}

static int igraph_i_get_subisomorphisms_vf2_inner(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    igraph_i_iso_cb_data_t *data = arg;
    igraph_vector_ptr_t *vector = data->arg;
    igraph_vector_t *newvector = IGRAPH_CALLOC(1, igraph_vector_t);
    IGRAPH_UNUSED(map12);
    if (!newvector) {
        IGRAPH_ERROR("", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, newvector);
    IGRAPH_CHECK(igraph_vector_copy(newvector, map21));
    IGRAPH_FINALLY(igraph_vector_destroy, newvector);
    IGRAPH_CHECK(igraph_vector_ptr_push_back(vector, newvector));
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

static igraph_bool_t igraph_i_get_subisomorphisms_vf2(
        const igraph_vector_t *map12,
        const igraph_vector_t *map21,
        void *arg) {
    return igraph_i_get_subisomorphisms_vf2_inner(map12, map21, arg) == IGRAPH_SUCCESS;
}

/**
 * \function igraph_get_subisomorphisms_vf2
 * \brief Return all subgraph isomorphic mappings.
 *
 * This function collects all isomorphic mappings of \p graph2 to a
 * subgraph of \p graph1. It uses the \ref
 * igraph_subisomorphic_function_vf2() function. The graphs should be simple.
 * \param graph1 The first input graph, may be directed or
 *    undirected. This is supposed to be the larger graph.
 * \param graph2 The second input graph, it must have the same
 *    directedness as \p graph1. This is supposed to be the smaller
 *    graph.
 * \param vertex_color1 An optional color vector for the first graph. If
 *   color vectors are given for both graphs, then the subgraph isomorphism is
 *   calculated on the colored graphs; i.e. two vertices can match
 *   only if their color also matches. Supply a null pointer here if
 *   your graphs are not colored.
 * \param vertex_color2 An optional color vector for the second graph. See
 *   the previous argument for explanation.
 * \param edge_color1 An optional edge color vector for the first
 *   graph. The matching edges in the two graphs must have matching
 *   colors as well. Supply a null pointer here if your graphs are not
 *   edge-colored.
 * \param edge_color2 The edge color vector for the second graph.
 * \param maps Pointer vector. On return it contains pointers to
 *   \ref igraph_vector_t objects, each vector is an
 *   isomorphic mapping of \p graph2 to a subgraph of \p graph1. Please note that
 *   you need to 1) Destroy the vectors via \ref
 *   igraph_vector_destroy(), 2) free them via
 *   \ref igraph_free() and then 3) call \ref
 *   igraph_vector_ptr_destroy() on the pointer vector to deallocate all
 *   memory when \p maps is no longer needed.
 * \param node_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two nodes are compatible.
 * \param edge_compat_fn A pointer to a function of type \ref
 *   igraph_isocompat_t. This function will be called by the algorithm to
 *   determine whether two edges are compatible.
 * \param arg Extra argument to supply to functions \p node_compat_fn
 *   and \p edge_compat_fn.
 * \return Error code.
 *
 * Time complexity: exponential.
 */

int igraph_get_subisomorphisms_vf2(const igraph_t *graph1,
                                   const igraph_t *graph2,
                                   const igraph_vector_int_t *vertex_color1,
                                   const igraph_vector_int_t *vertex_color2,
                                   const igraph_vector_int_t *edge_color1,
                                   const igraph_vector_int_t *edge_color2,
                                   igraph_vector_ptr_t *maps,
                                   igraph_isocompat_t *node_compat_fn,
                                   igraph_isocompat_t *edge_compat_fn,
                                   void *arg) {

    igraph_i_iso_cb_data_t data = { node_compat_fn, edge_compat_fn, maps, arg };
    igraph_isocompat_t *ncb = node_compat_fn ? igraph_i_isocompat_node_cb : NULL;
    igraph_isocompat_t *ecb = edge_compat_fn ? igraph_i_isocompat_edge_cb : NULL;

    igraph_vector_ptr_clear(maps);
    IGRAPH_FINALLY(igraph_i_get_subisomorphisms_free, maps);
    IGRAPH_CHECK(igraph_subisomorphic_function_vf2(graph1, graph2,
                 vertex_color1, vertex_color2,
                 edge_color1, edge_color2,
                 NULL, NULL,
                 (igraph_isohandler_t*)
                 igraph_i_get_subisomorphisms_vf2,
                 ncb, ecb, &data));
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.527141
igraph-0.9.9/vendor/source/igraph/src/layout/0000755000175100001710000000000000000000000021756 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/circular.c0000644000175100001710000001417100000000000023732 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"

#include "core/interruption.h"
#include "core/math.h"

/**
 * \ingroup layout
 * \function igraph_layout_circle
 * \brief Places the vertices uniformly on a circle, in the order of vertex ids.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param order The order of the vertices on the circle. The vertices
 *        not included here, will be placed at (0,0). Supply
 *        \ref igraph_vss_all() here for all vertices, in the order of
 *        their vertex ids.
 * \return Error code.
 *
 * Time complexity: O(|V|), the
 * number of vertices.
 */
int igraph_layout_circle(const igraph_t *graph, igraph_matrix_t *res,
                         igraph_vs_t order) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_integer_t vs_size;
    long int i;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vs_size(graph, &order, &vs_size));

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));
    igraph_matrix_null(res);

    igraph_vit_create(graph, order, &vit);
    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        igraph_real_t phi = 2 * M_PI / vs_size * i;
        int idx = IGRAPH_VIT_GET(vit);
        MATRIX(*res, idx, 0) = cos(phi);
        MATRIX(*res, idx, 1) = sin(phi);
    }
    igraph_vit_destroy(&vit);

    return 0;
}

/**
 * \function igraph_layout_star
 * \brief Generates a star-like layout.
 *
 * \param graph The input graph. Its edges are ignored by this function.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param center The id of the vertex to put in the center.
 * \param order A numeric vector giving the order of the vertices
 *      (including the center vertex!). If a null pointer, then the
 *      vertices are placed in increasing vertex id order.
 * \return Error code.
 *
 * Time complexity: O(|V|), linear in the number of vertices.
 *
 * \sa \ref igraph_layout_circle() and other layout generators.
 */
int igraph_layout_star(const igraph_t *graph, igraph_matrix_t *res,
                       igraph_integer_t center, const igraph_vector_t *order) {

    long int no_of_nodes = igraph_vcount(graph);
    long int c = center;
    long int i;
    igraph_real_t step;
    igraph_real_t phi;

    if (center < 0 || center >= no_of_nodes) {
        IGRAPH_ERROR("The given center is not a vertex of the graph.", IGRAPH_EINVAL);
    }
    if (order && igraph_vector_size(order) != no_of_nodes) {
        IGRAPH_ERROR("Invalid order vector length.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));

    if (no_of_nodes == 1) {
        MATRIX(*res, 0, 0) = MATRIX(*res, 0, 1) = 0.0;
    } else {
        for (i = 0, step = 2 * M_PI / (no_of_nodes - 1), phi = 0;
             i < no_of_nodes; i++) {
            long int node = order ? (long int) VECTOR(*order)[i] : i;
            if (order && (node < 0 || node >= no_of_nodes)) {
                IGRAPH_ERROR("Elements in the order vector are not all vertices of the graph.", IGRAPH_EINVAL);
            }
            if (node != c) {
                MATRIX(*res, node, 0) = cos(phi);
                MATRIX(*res, node, 1) = sin(phi);
                phi += step;
            } else {
                MATRIX(*res, node, 0) = MATRIX(*res, node, 1) = 0.0;
            }
        }
    }

    return 0;
}

/**
 * \function igraph_layout_sphere
 * \brief Places vertices (more or less) uniformly on a sphere.
 *
 * 
 * The algorithm was described in the following paper:
 * Distributing many points on a sphere by E.B. Saff and
 * A.B.J. Kuijlaars, \emb Mathematical Intelligencer \eme 19.1 (1997)
 * 5--11.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \return Error code. The current implementation always returns with
 * success.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|), the number of vertices in the graph.
 */
int igraph_layout_sphere(const igraph_t *graph, igraph_matrix_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    igraph_real_t h;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 3));

    if (no_of_nodes != 0) {
        MATRIX(*res, 0, 0) = M_PI;
        MATRIX(*res, 0, 1) = 0;
    }
    for (i = 1; i < no_of_nodes - 1; i++) {
        h = -1 + 2 * i / (double)(no_of_nodes - 1);
        MATRIX(*res, i, 0) = acos(h);
        MATRIX(*res, i, 1) = fmod((MATRIX(*res, i - 1, 1) +
                                   3.6 / sqrt(no_of_nodes * (1 - h * h))), 2 * M_PI);
        IGRAPH_ALLOW_INTERRUPTION();
    }
    if (no_of_nodes >= 2) {
        MATRIX(*res, no_of_nodes - 1, 0) = 0;
        MATRIX(*res, no_of_nodes - 1, 1) = 0;
    }

    for (i = 0; i < no_of_nodes; i++) {
        igraph_real_t x = cos(MATRIX(*res, i, 1)) * sin(MATRIX(*res, i, 0));
        igraph_real_t y = sin(MATRIX(*res, i, 1)) * sin(MATRIX(*res, i, 0));
        igraph_real_t z = cos(MATRIX(*res, i, 0));
        MATRIX(*res, i, 0) = x;
        MATRIX(*res, i, 1) = y;
        MATRIX(*res, i, 2) = z;
        IGRAPH_ALLOW_INTERRUPTION();
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/davidson_harel.c0000644000175100001710000004507500000000000025117 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"
#include "igraph_random.h"

#include "core/math.h"
#include "core/interruption.h"
#include "layout/layout_internal.h"

#include 

/* not 'static', used in tests */
igraph_bool_t igraph_i_layout_segments_intersect(float p0_x, float p0_y,
        float p1_x, float p1_y,
        float p2_x, float p2_y,
        float p3_x, float p3_y) {
    float s1_x = p1_x - p0_x;
    float s1_y = p1_y - p0_y;
    float s2_x = p3_x - p2_x;
    float s2_y = p3_y - p2_y;

    float s1, s2, t1, t2, s, t;
    s1 = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y));
    s2 = (-s2_x * s1_y + s1_x * s2_y);
    if (s2 == 0) {
        return 0;
    }
    t1 = ( s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x));
    t2 = (-s2_x * s1_y + s1_x * s2_y);
    s = s1 / s2;
    t = t1 / t2;

    return s >= 0 && s <= 1 && t >= 0 && t <= 1 ? 1 : 0;
}

/* not 'static', used in tests */
float igraph_i_layout_point_segment_dist2(float v_x, float v_y,
                                   float u1_x, float u1_y,
                                   float u2_x, float u2_y) {

    float dx = u2_x - u1_x;
    float dy = u2_y - u1_y;
    float l2 = dx * dx + dy * dy;
    float t, p_x, p_y;
    if (l2 == 0) {
        return (v_x - u1_x) * (v_x - u1_x) + (v_y - u1_y) * (v_y - u1_y);
    }
    t = ((v_x - u1_x) * dx + (v_y - u1_y) * dy) / l2;
    if (t < 0.0) {
        return (v_x - u1_x) * (v_x - u1_x) + (v_y - u1_y) * (v_y - u1_y);
    } else if (t > 1.0) {
        return (v_x - u2_x) * (v_x - u2_x) + (v_y - u2_y) * (v_y - u2_y);
    }
    p_x = u1_x + t * dx;
    p_y = u1_y + t * dy;
    return (v_x - p_x) * (v_x - p_x) + (v_y - p_y) * (v_y - p_y);
}

/**
 * \function igraph_layout_davidson_harel
 * Davidson-Harel layout algorithm
 *
 * This function implements the algorithm by Davidson and Harel,
 * see Ron Davidson, David Harel: Drawing Graphs Nicely Using
 * Simulated Annealing. ACM Transactions on Graphics 15(4),
 * pp. 301-331, 1996.
 *
 * 
 * The algorithm uses simulated annealing and a sophisticated
 * energy function, which is unfortunately hard to parameterize
 * for different graphs. The original publication did not disclose any
 * parameter values, and the ones below were determined by
 * experimentation.
 *
 * 
 * The algorithm consists of two phases, an annealing phase, and a
 * fine-tuning phase. There is no simulated annealing in the second
 * phase.
 *
 * 
 * Our implementation tries to follow the original publication, as
 * much as possible. The only major difference is that coordinates are
 * explicitly kept within the bounds of the rectangle of the layout.
 *
 * \param graph The input graph, edge directions are ignored.
 * \param res A matrix, the result is stored here. It can be used to
 *     supply start coordinates, see \p use_seed.
 * \param use_seed Boolean, whether to use the supplied \p res as
 *     start coordinates.
 * \param maxiter The maximum number of annealing iterations. A
 *     reasonable value for smaller graphs is 10.
 * \param fineiter The number of fine tuning iterations. A reasonable
 *     value is max(10, log2(n)) where n is the number of vertices.
 * \param cool_fact Cooling factor. A reasonable value is 0.75.
 * \param weight_node_dist Weight for the node-node distances
 *     component of the energy function. Reasonable value: 1.0.
 * \param weight_border Weight for the distance from the border
 *     component of the energy function. It can be set to zero, if
 *     vertices are allowed to sit on the border.
 * \param weight_edge_lengths Weight for the edge length component
 *     of the energy function, a reasonable value is the density of
 *     the graph divided by 10.
 * \param weight_edge_crossings Weight for the edge crossing component
 *     of the energy function, a reasonable default is 1 minus the
 *     square root of the density of the graph.
 * \param weight_node_edge_dist Weight for the node-edge distance
 *     component of the energy function. A reasonable value is
 *     1 minus the density, divided by 5.
 * \return Error code.
 *
 * Time complexity: one first phase iteration has time complexity
 * O(n^2+m^2), one fine tuning iteration has time complexity O(mn).
 * Time complexity might be smaller if some of the weights of the
 * components of the energy function are set to zero.
 *
 */

int igraph_layout_davidson_harel(const igraph_t *graph, igraph_matrix_t *res,
                                 igraph_bool_t use_seed, igraph_integer_t maxiter,
                                 igraph_integer_t fineiter, igraph_real_t cool_fact,
                                 igraph_real_t weight_node_dist, igraph_real_t weight_border,
                                 igraph_real_t weight_edge_lengths,
                                 igraph_real_t weight_edge_crossings,
                                 igraph_real_t weight_node_edge_dist) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    float width = sqrt(no_nodes) * 10, height = width;
    igraph_vector_int_t perm;
    igraph_bool_t fine_tuning = 0;
    igraph_integer_t round, i;
    igraph_vector_float_t try_x, try_y;
    igraph_vector_int_t try_idx;
    float move_radius = width / 2;
    float fine_tuning_factor = 0.01f;
    igraph_vector_t neis;
    float min_x = width / 2, max_x = -width / 2, min_y = height / 2, max_y = -height / 2;

    igraph_integer_t no_tries = 30;
    float w_node_dist = weight_node_dist ;          /* 1.0 */
    float w_borderlines = weight_border;            /* 0.0 */
    float w_edge_lengths = weight_edge_lengths;     /* 0.0001; */
    float w_edge_crossings = weight_edge_crossings; /* 1.0 */
    float w_node_edge_dist = weight_node_edge_dist; /* 0.2 */

    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 2)) {
        IGRAPH_ERROR("Invalid start position matrix size in "
                     "Davidson-Harel layout", IGRAPH_EINVAL);
    }
    if (maxiter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negative in "
                     "Davidson-Harel layout", IGRAPH_EINVAL);
    }
    if (fineiter < 0) {
        IGRAPH_ERROR("Number of fine tuning iterations must be non-negative in "
                     "Davidson-Harel layout", IGRAPH_EINVAL);
    }
    if (cool_fact <= 0 || cool_fact >= 1) {
        IGRAPH_ERROR("Cooling factor must be in (0,1) in "
                     "Davidson-Harel layout", IGRAPH_EINVAL);
    }

    if (no_nodes == 0) {
        return 0;
    }

    IGRAPH_CHECK(igraph_vector_int_init_seq(&perm, 0, no_nodes - 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &perm);
    IGRAPH_CHECK(igraph_vector_float_init(&try_x, no_tries));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &try_x);
    IGRAPH_CHECK(igraph_vector_float_init(&try_y, no_tries));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &try_y);
    IGRAPH_CHECK(igraph_vector_int_init_seq(&try_idx, 0, no_tries - 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &try_idx);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 100);

    RNG_BEGIN();

    if (!use_seed) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 2));
        for (i = 0; i < no_nodes; i++) {
            float x, y;
            x = MATRIX(*res, i, 0) = RNG_UNIF(-width / 2, width / 2);
            y = MATRIX(*res, i, 1) = RNG_UNIF(-height / 2, height / 2);
            if (x < min_x) {
                min_x = x;
            } else if (x > max_x) {
                max_x = x;
            }
            if (y < min_y) {
                min_y = y;
            } else if (y > max_y) {
                max_y = y;
            }
        }
    } else {
        min_x = IGRAPH_INFINITY; max_x = IGRAPH_NEGINFINITY;
        min_y = IGRAPH_INFINITY; max_y = IGRAPH_NEGINFINITY;
        for (i = 0; i < no_nodes; i++) {
            float x = MATRIX(*res, i, 0);
            float y = MATRIX(*res, i, 1);
            if (x < min_x) {
                min_x = x;
            } else if (x > max_x) {
                max_x = x;
            }
            if (y < min_y) {
                min_y = y;
            } else if (y > max_y) {
                max_y = y;
            }
        }
    }

    for (i = 0; i < no_tries; i++) {
        float phi = 2 * M_PI / no_tries * i;
        VECTOR(try_x)[i] = cos(phi);
        VECTOR(try_y)[i] = sin(phi);
    }

    for (round = 0; round < maxiter + fineiter; round++) {
        igraph_integer_t p;
        igraph_vector_int_shuffle(&perm);

        IGRAPH_ALLOW_INTERRUPTION();

        fine_tuning = round >= maxiter;
        if (fine_tuning) {
            float fx = fine_tuning_factor * (max_x - min_x);
            float fy = fine_tuning_factor * (max_y - min_y);
            move_radius = fx < fy ? fx : fy;
        }

        for (p = 0; p < no_nodes; p++) {
            igraph_integer_t t;
            igraph_integer_t v = VECTOR(perm)[p];
            igraph_vector_int_shuffle(&try_idx);

            for (t = 0; t < no_tries; t++) {
                float diff_energy = 0.0;
                int ti = VECTOR(try_idx)[t];

                /* Try moving it */
                float old_x = MATRIX(*res, v, 0);
                float old_y = MATRIX(*res, v, 1);
                float new_x = old_x + move_radius * VECTOR(try_x)[ti];
                float new_y = old_y + move_radius * VECTOR(try_y)[ti];

                if (new_x < -width / 2) {
                    new_x = -width / 2 - 1e-6;
                }
                if (new_x >  width / 2) {
                    new_x =  width / 2 - 1e-6;
                }
                if (new_y < -height / 2) {
                    new_y = -height / 2 - 1e-6;
                }
                if (new_y >  height / 2) {
                    new_y =  height / 2 - 1e-6;
                }

                if (w_node_dist != 0) {
                    igraph_integer_t u;
                    for (u = 0; u < no_nodes; u++) {
                        float odx, ody, odist2, dx, dy, dist2;
                        if (u == v) {
                            continue;
                        }
                        odx = old_x - MATRIX(*res, u, 0);
                        ody = old_y - MATRIX(*res, u, 1);
                        dx = new_x - MATRIX(*res, u, 0);
                        dy = new_y - MATRIX(*res, u, 1);
                        odist2 = odx * odx + ody * ody;
                        dist2 = dx * dx + dy * dy;
                        diff_energy += w_node_dist / dist2 - w_node_dist / odist2;
                    }
                }

                if (w_borderlines != 0) {
                    float odx1 = width / 2 - old_x, odx2 = old_x + width / 2;
                    float ody1 = height / 2 - old_y, ody2 = old_y + height / 2;
                    float dx1 = width / 2 - new_x, dx2 = new_x + width / 2;
                    float dy1 = height / 2 - new_y, dy2 = new_y + height / 2;
                    if (odx1 < 0) {
                        odx1 = 2;
                    } if (odx2 < 0) {
                        odx2 = 2;
                    }
                    if (ody1 < 0) {
                        ody1 = 2;
                    } if (ody2 < 0) {
                        ody2 = 2;
                    }
                    if (dx1 < 0) {
                        dx1 = 2;
                    } if (dx2 < 0) {
                        dx2 = 2;
                    }
                    if (dy1 < 0) {
                        dy1 = 2;
                    } if (dy2 < 0) {
                        dy2 = 2;
                    }
                    diff_energy -= w_borderlines *
                                   (1.0 / (odx1 * odx1) + 1.0 / (odx2 * odx2) +
                                    1.0 / (ody1 * ody1) + 1.0 / (ody2 * ody2));
                    diff_energy += w_borderlines *
                                   (1.0 / (dx1 * dx1) + 1.0 / (dx2 * dx2) +
                                    1.0 / (dy1 * dy1) + 1.0 / (dy2 * dy2));
                }

                if (w_edge_lengths != 0) {
                    igraph_integer_t len, j;
                    igraph_neighbors(graph, &neis, v, IGRAPH_ALL);
                    len = igraph_vector_size(&neis);
                    for (j = 0; j < len; j++) {
                        igraph_integer_t u = VECTOR(neis)[j];
                        float odx = old_x - MATRIX(*res, u, 0);
                        float ody = old_y - MATRIX(*res, u, 1);
                        float odist2 = odx * odx + ody * ody;
                        float dx = new_x - MATRIX(*res, u, 0);
                        float dy = new_y - MATRIX(*res, u, 1);
                        float dist2 = dx * dx + dy * dy;
                        diff_energy += w_edge_lengths * (dist2 - odist2);
                    }
                }

                if (w_edge_crossings != 0) {
                    igraph_integer_t len, j, no = 0;
                    igraph_neighbors(graph, &neis, v, IGRAPH_ALL);
                    len = igraph_vector_size(&neis);
                    for (j = 0; j < len; j++) {
                        igraph_integer_t u = VECTOR(neis)[j];
                        float u_x = MATRIX(*res, u, 0);
                        float u_y = MATRIX(*res, u, 1);
                        igraph_integer_t e;
                        for (e = 0; e < no_edges; e++) {
                            igraph_integer_t u1 = IGRAPH_FROM(graph, e);
                            igraph_integer_t u2 = IGRAPH_TO(graph, e);
                            float u1_x, u1_y, u2_x, u2_y;
                            if (u1 == v || u2 == v || u1 == u || u2 == u) {
                                continue;
                            }
                            u1_x = MATRIX(*res, u1, 0);
                            u1_y = MATRIX(*res, u1, 1);
                            u2_x = MATRIX(*res, u2, 0);
                            u2_y = MATRIX(*res, u2, 1);
                            no -= igraph_i_layout_segments_intersect(old_x, old_y, u_x, u_y,
                                                              u1_x, u1_y, u2_x, u2_y);
                            no += igraph_i_layout_segments_intersect(new_x, new_y, u_x, u_y,
                                                              u1_x, u1_y, u2_x, u2_y);
                        }
                    }
                    diff_energy += w_edge_crossings * no;
                }

                if (w_node_edge_dist != 0 && fine_tuning) {
                    igraph_integer_t e, no;

                    /* All non-incident edges from the moved 'v' */
                    for (e = 0; e < no_edges; e++) {
                        igraph_integer_t u1 = IGRAPH_FROM(graph, e);
                        igraph_integer_t u2 = IGRAPH_TO(graph, e);
                        float u1_x, u1_y, u2_x, u2_y, d_ev;
                        if (u1 == v || u2 == v) {
                            continue;
                        }
                        u1_x = MATRIX(*res, u1, 0);
                        u1_y = MATRIX(*res, u1, 1);
                        u2_x = MATRIX(*res, u2, 0);
                        u2_y = MATRIX(*res, u2, 1);
                        d_ev = igraph_i_layout_point_segment_dist2(old_x, old_y, u1_x, u1_y,
                                                            u2_x, u2_y);
                        diff_energy -= w_node_edge_dist / d_ev;
                        d_ev = igraph_i_layout_point_segment_dist2(new_x, new_y, u1_x, u1_y,
                                                            u2_x, u2_y);
                        diff_energy += w_node_edge_dist / d_ev;
                    }

                    /* All other nodes from all of v's incident edges */
                    igraph_incident(graph, &neis, v, IGRAPH_ALL);
                    no = igraph_vector_size(&neis);
                    for (e = 0; e < no; e++) {
                        igraph_integer_t mye = VECTOR(neis)[e];
                        igraph_integer_t u = IGRAPH_OTHER(graph, mye, v);
                        float u_x = MATRIX(*res, u, 0);
                        float u_y = MATRIX(*res, u, 1);
                        igraph_integer_t w;
                        for (w = 0; w < no_nodes; w++) {
                            float w_x, w_y, d_ev;
                            if (w == v || w == u) {
                                continue;
                            }
                            w_x = MATRIX(*res, w, 0);
                            w_y = MATRIX(*res, w, 1);
                            d_ev = igraph_i_layout_point_segment_dist2(w_x, w_y, old_x,
                                                                old_y, u_x, u_y);
                            diff_energy -= w_node_edge_dist / d_ev;
                            d_ev = igraph_i_layout_point_segment_dist2(w_x, w_y, new_x, new_y,
                                                                u_x, u_y);
                            diff_energy += w_node_edge_dist / d_ev;
                        }
                    }
                } /* w_node_edge_dist != 0 && fine_tuning */

                if (diff_energy < 0 ||
                    (!fine_tuning && RNG_UNIF01() < exp(-diff_energy / move_radius))) {
                    MATRIX(*res, v, 0) = new_x;
                    MATRIX(*res, v, 1) = new_y;
                    if (new_x < min_x) {
                        min_x = new_x;
                    } else if (new_x > max_x) {
                        max_x = new_x;
                    }
                    if (new_y < min_y) {
                        min_y = new_y;
                    } else if (new_y > max_y) {
                        max_y = new_y;
                    }
                }

            } /* t < no_tries */

        } /* p < no_nodes  */

        move_radius *= cool_fact;

    } /* round < maxiter */

    RNG_END();

    igraph_vector_destroy(&neis);
    igraph_vector_int_destroy(&try_idx);
    igraph_vector_float_destroy(&try_x);
    igraph_vector_float_destroy(&try_y);
    igraph_vector_int_destroy(&perm);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.531141
igraph-0.9.9/vendor/source/igraph/src/layout/drl/0000755000175100001710000000000000000000000022537 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/DensityGrid.cpp0000644000175100001710000002162400000000000025475 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains the member definitions of the DensityGrid.h class
// This code is modified from the original code by B.N. Wylie

#include "drl_Node.h"
#include "DensityGrid.h"
#include "igraph_error.h"

#include 
#include 

using namespace std;

#define GET_BIN(y, x) (Bins[y*GRID_SIZE+x])

namespace drl {

//*******************************************************
// Density Grid Destructor -- deallocates memory used
// for Density matrix, fall_off matrix, and node deque.

DensityGrid::~DensityGrid () {
    delete[] Density;
    delete[] fall_off;
    delete[] Bins;
}

/*********************************************
* Function: Density_Grid::Reset              *
* Description: Reset the density grid        *
*********************************************/
// changed from reset to init since we will only
// call this once in the parallel version of layout

void DensityGrid::Init() {

    try {
        Density = new float[GRID_SIZE][GRID_SIZE];
        fall_off = new float[RADIUS * 2 + 1][RADIUS * 2 + 1];
        Bins = new deque[GRID_SIZE * GRID_SIZE];
    } catch (bad_alloc&) {
        // cout << "Error: Out of memory! Program stopped." << endl;
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("DrL is out of memory", IGRAPH_FILE_BASENAME, __LINE__,
                     IGRAPH_ENOMEM);
        return;
#endif
    }

    // Clear Grid
    int i;
    for (i = 0; i < GRID_SIZE; i++)
        for (int j = 0; j < GRID_SIZE; j++) {
            Density[i][j] = 0;
            GET_BIN(i, j).erase(GET_BIN(i, j).begin(), GET_BIN(i, j).end());
        }

    // Compute fall off
    for (i = -RADIUS; i <= RADIUS; i++)
        for (int j = -RADIUS; j <= RADIUS; j++) {
            fall_off[i + RADIUS][j + RADIUS] = (float)((RADIUS - fabs((float)i)) / RADIUS) *
                                               (float)((RADIUS - fabs((float)j)) / RADIUS);
        }

}

/***************************************************
 * Function: DensityGrid::GetDensity               *
 * Description: Get_Density from density grid      *
 **************************************************/
float DensityGrid::GetDensity(float Nx, float Ny, bool fineDensity) {
    deque::iterator BI;
    int x_grid, y_grid;
    float x_dist, y_dist, distance, density = 0;
    int boundary = 10;  // boundary around plane


    /* Where to look */
    x_grid = (int)((Nx + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((Ny + HALF_VIEW + .5) * VIEW_TO_GRID);

    // Check for edges of density grid (10000 is arbitrary high density)
    if (x_grid > GRID_SIZE - boundary || x_grid < boundary) {
        return 10000;
    }
    if (y_grid > GRID_SIZE - boundary || y_grid < boundary) {
        return 10000;
    }

    // Fine density?
    if (fineDensity) {

        // Go through nearest bins
        for (int i = y_grid - 1; i <= y_grid + 1; i++)
            for (int j = x_grid - 1; j <= x_grid + 1; j++) {

                // Look through bin and add fine repulsions
                for (BI = GET_BIN(i, j).begin(); BI != GET_BIN(i, j).end(); ++BI) {
                    x_dist =  Nx - (BI->x);
                    y_dist =  Ny - (BI->y);
                    distance = x_dist * x_dist + y_dist * y_dist;
                    density += 1e-4 / (distance + 1e-50);
                }
            }
        // Course density
    } else {

        // Add rough estimate
        density = Density[y_grid][x_grid];
        density *= density;
    }

    return density;
}

/// Wrapper functions for the Add and subtract methods
/// Nodes should all be passed by constant ref

void DensityGrid::Add(Node &n, bool fineDensity) {
    if (fineDensity) {
        fineAdd(n);
    } else {
        Add(n);
    }
}

void DensityGrid::Subtract( Node &n, bool first_add,
                            bool fine_first_add, bool fineDensity) {
    if ( fineDensity && !fine_first_add ) {
        fineSubtract (n);
    } else if ( !first_add ) {
        Subtract(n);
    }
}


/***************************************************
 * Function: DensityGrid::Subtract                *
 * Description: Subtract a node from density grid  *
 **************************************************/
void DensityGrid::Subtract(Node &N) {
    int x_grid, y_grid, diam;
    float *den_ptr, *fall_ptr;

    /* Where to subtract */
    x_grid = (int)((N.sub_x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.sub_y + HALF_VIEW + .5) * VIEW_TO_GRID);
    x_grid -= RADIUS;
    y_grid -= RADIUS;
    diam = 2 * RADIUS;

    // check to see that we are inside grid
    if ( (x_grid >= GRID_SIZE) || (x_grid < 0) ||
         (y_grid >= GRID_SIZE) || (y_grid < 0) ) {
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("Exceeded density grid in DrL", IGRAPH_FILE_BASENAME,
                     __LINE__, IGRAPH_EDRL);
        return;
#endif
    }

    /* Subtract density values */
    den_ptr = &Density[y_grid][x_grid];
    fall_ptr = &fall_off[0][0];
    for (int i = 0; i <= diam; i++) {
        for (int j = 0; j <= diam; j++) {
            *den_ptr++ -= *fall_ptr++;
        }
        den_ptr += GRID_SIZE - (diam + 1);
    }
}

/***************************************************
 * Function: DensityGrid::Add                     *
 * Description: Add a node to the density grid     *
 **************************************************/
void DensityGrid::Add(Node &N) {

    int x_grid, y_grid, diam;
    float *den_ptr, *fall_ptr;


    /* Where to add */
    x_grid = (int)((N.x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.y + HALF_VIEW + .5) * VIEW_TO_GRID);

    N.sub_x = N.x;
    N.sub_y = N.y;

    x_grid -= RADIUS;
    y_grid -= RADIUS;
    diam = 2 * RADIUS;

    // check to see that we are inside grid
    if ( (x_grid >= GRID_SIZE) || (x_grid < 0) ||
         (y_grid >= GRID_SIZE) || (y_grid < 0) ) {
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("Exceeded density grid in DrL", IGRAPH_FILE_BASENAME,
                     __LINE__, IGRAPH_EDRL);
        return;
#endif
    }

    /* Add density values */
    den_ptr = &Density[y_grid][x_grid];
    fall_ptr = &fall_off[0][0];
    for (int i = 0; i <= diam; i++) {
        for (int j = 0; j <= diam; j++) {
            *den_ptr++ += *fall_ptr++;
        }
        den_ptr += GRID_SIZE - (diam + 1);
    }

}

/***************************************************
 * Function: DensityGrid::fineSubtract             *
 * Description: Subtract a node from bins          *
 **************************************************/
void DensityGrid::fineSubtract(Node &N) {
    int x_grid, y_grid;

    /* Where to subtract */
    x_grid = (int)((N.sub_x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.sub_y + HALF_VIEW + .5) * VIEW_TO_GRID);
    GET_BIN(y_grid, x_grid).pop_front();
}

/***************************************************
 * Function: DensityGrid::fineAdd                  *
 * Description: Add a node to the bins             *
 **************************************************/
void DensityGrid::fineAdd(Node &N) {
    int x_grid, y_grid;

    /* Where to add */
    x_grid = (int)((N.x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.y + HALF_VIEW + .5) * VIEW_TO_GRID);
    N.sub_x = N.x;
    N.sub_y = N.y;
    GET_BIN(y_grid, x_grid).push_back(N);
}

} // namespace drl
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/DensityGrid.h0000644000175100001710000000532500000000000025142 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __DENSITY_GRID_H__
#define __DENSITY_GRID_H__


// Compile time adjustable parameters

#include "drl_layout.h"
#include "drl_Node.h"
#ifdef MUSE_MPI
    #include 
#endif

#include 

namespace drl {

class DensityGrid {

public:

    // Methods
    void Init();
    void Subtract(Node &n, bool first_add, bool fine_first_add, bool fineDensity);
    void Add(Node &n, bool fineDensity );
    float GetDensity(float Nx, float Ny, bool fineDensity);

    // Contructor/Destructor
    DensityGrid() {};
    ~DensityGrid();

private:

    // Private Members
    void Subtract( Node &N );
    void Add( Node &N );
    void fineSubtract( Node &N );
    void fineAdd( Node &N );

    // new dynamic variables -- SBM
    float (*fall_off)[RADIUS * 2 + 1];
    float (*Density)[GRID_SIZE];
    std::deque* Bins;

    // old static variables
    //float fall_off[RADIUS*2+1][RADIUS*2+1];
    //float Density[GRID_SIZE][GRID_SIZE];
    //deque Bins[GRID_SIZE][GRID_SIZE];
};

} // namespace drl

#endif // __DENSITY_GRID_H__
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/DensityGrid_3d.cpp0000644000175100001710000002412700000000000026064 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains the member definitions of the DensityGrid.h class
// This code is modified from the original code by B.N. Wylie

#include "drl_Node_3d.h"
#include "DensityGrid_3d.h"
#include "igraph_error.h"

#include 
#include 

using namespace std;

#define GET_BIN(z, y, x) (Bins[(z*GRID_SIZE+y)*GRID_SIZE+x])

namespace drl3d {

//*******************************************************
// Density Grid Destructor -- deallocates memory used
// for Density matrix, fall_off matrix, and node deque.

DensityGrid::~DensityGrid () {
    delete[] Density;
    delete[] fall_off;
    delete[] Bins;
}

/*********************************************
* Function: Density_Grid::Reset              *
* Description: Reset the density grid        *
*********************************************/
// changed from reset to init since we will only
// call this once in the parallel version of layout

void DensityGrid::Init() {

    try {
        Density = new float[GRID_SIZE][GRID_SIZE][GRID_SIZE];
        fall_off = new float[RADIUS * 2 + 1][RADIUS * 2 + 1][RADIUS * 2 + 1];
        Bins = new deque[GRID_SIZE * GRID_SIZE * GRID_SIZE];
    } catch (bad_alloc&) {
        // cout << "Error: Out of memory! Program stopped." << endl;
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("DrL is out of memory", IGRAPH_FILE_BASENAME, __LINE__,
                     IGRAPH_ENOMEM);
        return;
#endif
    }

    // Clear Grid
    int i;
    for (i = 0; i < GRID_SIZE; i++)
        for (int j = 0; j < GRID_SIZE; j++)
            for (int k = 0; k < GRID_SIZE; k++) {
                Density[i][j][k] = 0;
                GET_BIN(i, j, k).erase(GET_BIN(i, j, k).begin(), GET_BIN(i, j, k).end());
            }

    // Compute fall off
    for (i = -RADIUS; i <= RADIUS; i++)
        for (int j = -RADIUS; j <= RADIUS; j++)
            for (int k = -RADIUS; k <= RADIUS; k++) {
                fall_off[i + RADIUS][j + RADIUS][k + RADIUS] =
                    (float)((RADIUS - fabs((float)i)) / RADIUS) *
                    (float)((RADIUS - fabs((float)j)) / RADIUS) *
                    (float)((RADIUS - fabs((float)k)) / RADIUS);
            }

}


/***************************************************
 * Function: DensityGrid::GetDensity               *
 * Description: Get_Density from density grid      *
 **************************************************/
float DensityGrid::GetDensity(float Nx, float Ny, float Nz, bool fineDensity) {
    deque::iterator BI;
    int x_grid, y_grid, z_grid;
    float x_dist, y_dist, z_dist, distance, density = 0;
    int boundary = 10;  // boundary around plane


    /* Where to look */
    x_grid = (int)((Nx + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((Ny + HALF_VIEW + .5) * VIEW_TO_GRID);
    z_grid = (int)((Nz + HALF_VIEW + .5) * VIEW_TO_GRID);

    // Check for edges of density grid (10000 is arbitrary high density)
    if (x_grid > GRID_SIZE - boundary || x_grid < boundary) {
        return 10000;
    }
    if (y_grid > GRID_SIZE - boundary || y_grid < boundary) {
        return 10000;
    }
    if (z_grid > GRID_SIZE - boundary || z_grid < boundary) {
        return 10000;
    }

    // Fine density?
    if (fineDensity) {

        // Go through nearest bins
        for (int k = z_grid - 1; k <= z_grid + 1; k++)
            for (int i = y_grid - 1; i <= y_grid + 1; i++)
                for (int j = x_grid - 1; j <= x_grid + 1; j++) {

                    // Look through bin and add fine repulsions
                    for (BI = GET_BIN(k, i, j).begin(); BI < GET_BIN(k, i, j).end(); ++BI) {
                        x_dist =  Nx - (BI->x);
                        y_dist =  Ny - (BI->y);
                        z_dist =  Nz - (BI->z);
                        distance = x_dist * x_dist + y_dist * y_dist + z_dist * z_dist;
                        density += 1e-4 / (distance + 1e-50);
                    }
                }

        // Course density
    } else {

        // Add rough estimate
        density = Density[z_grid][y_grid][x_grid];
        density *= density;
    }

    return density;
}

/// Wrapper functions for the Add and subtract methods
/// Nodes should all be passed by constant ref

void DensityGrid::Add(Node &n, bool fineDensity) {
    if (fineDensity) {
        fineAdd(n);
    } else {
        Add(n);
    }
}

void DensityGrid::Subtract( Node &n, bool first_add,
                            bool fine_first_add, bool fineDensity) {
    if ( fineDensity && !fine_first_add ) {
        fineSubtract (n);
    } else if ( !first_add ) {
        Subtract(n);
    }
}


/***************************************************
 * Function: DensityGrid::Subtract                *
 * Description: Subtract a node from density grid  *
 **************************************************/
void DensityGrid::Subtract(Node &N) {
    int x_grid, y_grid, z_grid, diam;
    float *den_ptr, *fall_ptr;

    /* Where to subtract */
    x_grid = (int)((N.sub_x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.sub_y + HALF_VIEW + .5) * VIEW_TO_GRID);
    z_grid = (int)((N.sub_z + HALF_VIEW + .5) * VIEW_TO_GRID);
    x_grid -= RADIUS;
    y_grid -= RADIUS;
    z_grid -= RADIUS;
    diam = 2 * RADIUS;

    // check to see that we are inside grid
    if ( (x_grid >= GRID_SIZE) || (x_grid < 0) ||
         (y_grid >= GRID_SIZE) || (y_grid < 0) ||
         (z_grid >= GRID_SIZE) || (z_grid < 0) ) {
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("Exceeded density grid in DrL", IGRAPH_FILE_BASENAME,
                     __LINE__, IGRAPH_EDRL);
        return;
#endif
    }

    /* Subtract density values */
    den_ptr = &Density[z_grid][y_grid][x_grid];
    fall_ptr = &fall_off[0][0][0];
    for (int i = 0; i <= diam; i++) {
        for (int j = 0; j <= diam; j++)
            for (int k = 0; k <= diam; k++) {
                *den_ptr++ -= *fall_ptr++;
            }
        den_ptr += GRID_SIZE - (diam + 1);
    }
}

/***************************************************
 * Function: DensityGrid::Add                     *
 * Description: Add a node to the density grid     *
 **************************************************/
void DensityGrid::Add(Node &N) {

    int x_grid, y_grid, z_grid, diam;
    float *den_ptr, *fall_ptr;


    /* Where to add */
    x_grid = (int)((N.x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.y + HALF_VIEW + .5) * VIEW_TO_GRID);
    z_grid = (int)((N.z + HALF_VIEW + .5) * VIEW_TO_GRID);

    N.sub_x = N.x;
    N.sub_y = N.y;
    N.sub_z = N.z;

    x_grid -= RADIUS;
    y_grid -= RADIUS;
    z_grid -= RADIUS;
    diam = 2 * RADIUS;

    // check to see that we are inside grid
    if ( (x_grid >= GRID_SIZE) || (x_grid < 0) ||
         (y_grid >= GRID_SIZE) || (y_grid < 0) ||
         (z_grid >= GRID_SIZE) || (z_grid < 0) ) {
#ifdef MUSE_MPI
        MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
        igraph_error("Exceeded density grid in DrL", IGRAPH_FILE_BASENAME,
                     __LINE__, IGRAPH_EDRL);
        return;
#endif
    }

    /* Add density values */
    den_ptr = &Density[z_grid][y_grid][x_grid];
    fall_ptr = &fall_off[0][0][0];
    for (int i = 0; i <= diam; i++) {
        for (int j = 0; j <= diam; j++)
            for (int k = 0; k <= diam; k++) {
                *den_ptr++ += *fall_ptr++;
            }
        den_ptr += GRID_SIZE - (diam + 1);
    }

}

/***************************************************
 * Function: DensityGrid::fineSubtract             *
 * Description: Subtract a node from bins          *
 **************************************************/
void DensityGrid::fineSubtract(Node &N) {
    int x_grid, y_grid, z_grid;

    /* Where to subtract */
    x_grid = (int)((N.sub_x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.sub_y + HALF_VIEW + .5) * VIEW_TO_GRID);
    z_grid = (int)((N.sub_z + HALF_VIEW + .5) * VIEW_TO_GRID);
    GET_BIN(z_grid, y_grid, x_grid).pop_front();
}

/***************************************************
 * Function: DensityGrid::fineAdd                  *
 * Description: Add a node to the bins             *
 **************************************************/
void DensityGrid::fineAdd(Node &N) {
    int x_grid, y_grid, z_grid;

    /* Where to add */
    x_grid = (int)((N.x + HALF_VIEW + .5) * VIEW_TO_GRID);
    y_grid = (int)((N.y + HALF_VIEW + .5) * VIEW_TO_GRID);
    z_grid = (int)((N.z + HALF_VIEW + .5) * VIEW_TO_GRID);
    N.sub_x = N.x;
    N.sub_y = N.y;
    N.sub_z = N.z;
    GET_BIN(z_grid, y_grid, x_grid).push_back(N);
}

} // namespace drl3d
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/DensityGrid_3d.h0000644000175100001710000000540400000000000025526 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __DENSITY_GRID_H__
#define __DENSITY_GRID_H__


// Compile time adjustable parameters

#include "drl_layout_3d.h"
#include "drl_Node_3d.h"
#ifdef MUSE_MPI
    #include 
#endif

#include 

namespace drl3d {

class DensityGrid {

public:

    // Methods
    void Init();
    void Subtract(Node &n, bool first_add, bool fine_first_add, bool fineDensity);
    void Add(Node &n, bool fineDensity );
    float GetDensity(float Nx, float Ny, float Nz, bool fineDensity);

    // Contructor/Destructor
    DensityGrid() {};
    ~DensityGrid();

private:

    // Private Members
    void Subtract( Node &N );
    void Add( Node &N );
    void fineSubtract( Node &N );
    void fineAdd( Node &N );

    // new dynamic variables -- SBM
    float (*fall_off)[RADIUS * 2 + 1][RADIUS * 2 + 1];
    float (*Density)[GRID_SIZE][GRID_SIZE];
    std::deque* Bins;

    // old static variables
    //float fall_off[RADIUS*2+1][RADIUS*2+1];
    //float Density[GRID_SIZE][GRID_SIZE];
    //deque Bins[GRID_SIZE][GRID_SIZE];
};

} // namespace drl3d

#endif // __DENSITY_GRID_H__
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_Node.h0000644000175100001710000000440500000000000024441 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __NODE_H__
#define __NODE_H__

// The node class contains information about a given node for
// use by the density server process.

// structure coord used to pass position information between
// density server and graph class

namespace drl {

class Node {

public:

    bool fixed;   // if true do not change the
    // position of this node
    int id;

    float x, y;
    float sub_x, sub_y;
    float energy;

public:

    Node( int node_id ) {
        x = y = 0.0; fixed = false;
        id = node_id;
    }
    ~Node() { }

};

} // namespace drl

#endif //__NODE_H__
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_Node_3d.h0000644000175100001710000000442700000000000025033 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __NODE_H__
#define __NODE_H__

// The node class contains information about a given node for
// use by the density server process.

// structure coord used to pass position information between
// density server and graph class

namespace drl3d {

class Node {

public:

    bool fixed;   // if true do not change the
    // position of this node
    int id;

    float x, y, z;
    float sub_x, sub_y, sub_z;
    float energy;

public:

    Node( int node_id ) {
        x = y = z = 0.0; fixed = false;
        id = node_id;
    }
    ~Node() { }

};

} // namespace drl3d

#endif //__NODE_H__
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_graph.cpp0000644000175100001710000012066400000000000025216 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains the member definitions of the master class


#include 
#include 
#include 

using namespace std;

#include "drl_graph.h"
#include "igraph_random.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "core/interruption.h"
#ifdef MUSE_MPI
    #include 
#endif

namespace drl {

// constructor -- initializes the schedule variables (as in
// graph constructor)

// graph::graph ( int proc_id, int tot_procs, char *int_file )
// {

//        // MPI parameters
//        myid = proc_id;
//        num_procs = tot_procs;

//        // initial annealing parameters
//        STAGE = 0;
//        iterations = 0;
//        temperature = 2000;
//        attraction = 10;
//        damping_mult = 1.0;
//        min_edges = 20;
//        first_add = fine_first_add = true;
//        fineDensity = false;

//        // Brian's original Vx schedule
//        liquid.iterations = 200;
//        liquid.temperature = 2000;
//        liquid.attraction = 2;
//        liquid.damping_mult = 1.0;
//        liquid.time_elapsed = 0;

//        expansion.iterations = 200;
//        expansion.temperature = 2000;
//        expansion.attraction = 10;
//        expansion.damping_mult = 1.0;
//        expansion.time_elapsed = 0;

//        cooldown.iterations = 200;
//        cooldown.temperature = 2000;
//        cooldown.attraction = 1;
//        cooldown.damping_mult = .1;
//        cooldown.time_elapsed = 0;

//        crunch.iterations = 50;
//        crunch.temperature = 250;
//        crunch.attraction = 1;
//        crunch. damping_mult = .25;
//        crunch.time_elapsed = 0;

//        simmer.iterations = 100;
//        simmer.temperature = 250;
//        simmer.attraction = .5;
//        simmer.damping_mult = 0.0;
//        simmer.time_elapsed = 0;

//        // scan .int file for node info
//        scan_int ( int_file );

//        // populate node positions and ids
//        positions.reserve ( num_nodes );
//        map < int, int >::iterator cat_iter;
//        for ( cat_iter = id_catalog.begin();
//              cat_iter != id_catalog.end();
//              cat_iter++ )
//          positions.push_back ( Node( cat_iter->first ) );

//        /*
//        // output positions .ids for debugging
//        for ( int id = 0; id < num_nodes; id++ )
//          cout << positions[id].id << endl;
//        */

//        // read .int file for graph info
//        read_int ( int_file );

//        // initialize density server
//        density_server.Init();

// }

graph::graph(const igraph_t *igraph,
             const igraph_layout_drl_options_t *options,
             const igraph_vector_t *weights) {
    myid = 0;
    num_procs = 1;

    STAGE = 0;
    iterations = options->init_iterations;
    temperature = options->init_temperature;
    attraction = options->init_attraction;
    damping_mult = options->init_damping_mult;
    min_edges = 20;
    first_add = fine_first_add = true;
    fineDensity = false;

    // Brian's original Vx schedule
    liquid.iterations = options->liquid_iterations;
    liquid.temperature = options->liquid_temperature;
    liquid.attraction = options->liquid_attraction;
    liquid.damping_mult = options->liquid_damping_mult;
    liquid.time_elapsed = 0;

    expansion.iterations = options->expansion_iterations;
    expansion.temperature = options->expansion_temperature;
    expansion.attraction = options->expansion_attraction;
    expansion.damping_mult = options->expansion_damping_mult;
    expansion.time_elapsed = 0;

    cooldown.iterations = options->cooldown_iterations;
    cooldown.temperature = options->cooldown_temperature;
    cooldown.attraction = options->cooldown_attraction;
    cooldown.damping_mult = options->cooldown_damping_mult;
    cooldown.time_elapsed = 0;

    crunch.iterations = options->crunch_iterations;
    crunch.temperature = options->crunch_temperature;
    crunch.attraction = options->crunch_attraction;
    crunch.damping_mult = options->crunch_damping_mult;
    crunch.time_elapsed = 0;

    simmer.iterations = options->simmer_iterations;
    simmer.temperature = options->simmer_temperature;
    simmer.attraction = options->simmer_attraction;
    simmer.damping_mult = options->simmer_damping_mult;
    simmer.time_elapsed = 0;

    // scan .int file for node info
    highest_sim = 1.0;
    num_nodes = igraph_vcount(igraph);
    long int no_of_edges = igraph_ecount(igraph);
    for (long int i = 0; i < num_nodes; i++) {
        id_catalog[i] = 1;
    }
    map< int, int>::iterator cat_iter;
    for ( cat_iter = id_catalog.begin();
          cat_iter != id_catalog.end(); cat_iter++) {
        cat_iter->second = cat_iter->first;
    }

    // populate node positions and ids
    positions.reserve ( num_nodes );
    for ( cat_iter = id_catalog.begin();
          cat_iter != id_catalog.end();
          cat_iter++ ) {
        positions.push_back ( Node( cat_iter->first ) );
    }

    // read .int file for graph info
    long int node_1, node_2;
    double weight;
    for (long int i = 0; i < no_of_edges; i++) {
        node_1 = IGRAPH_FROM(igraph, i);
        node_2 = IGRAPH_TO(igraph, i);
        weight = weights ? VECTOR(*weights)[i] : 1.0 ;
        (neighbors[id_catalog[node_1]])[id_catalog[node_2]] = weight;
        (neighbors[id_catalog[node_2]])[id_catalog[node_1]] = weight;
    }

    // initialize density server
    density_server.Init();

}

// The following subroutine scans the .int file for the following
// information: number nodes, node ids, and highest similarity.  The
// corresponding graph globals are populated: num_nodes, id_catalog,
// and highest_sim.

// void graph::scan_int ( char *filename )
// {

//   cout << "Proc. " << myid << " scanning .int file ..." << endl;

//   // Open (sim) File
//   ifstream fp ( filename );
//   if ( !fp )
//   {
//  cout << "Error: could not open " << filename << ".  Program terminated." << endl;
//  #ifdef MUSE_MPI
//    MPI_Abort ( MPI_COMM_WORLD, 1 );
//  #else
//    exit (1);
//     #endif
//   }

//   // Read file, parse, and add into data structure
//   int id1, id2;
//   float edge_weight;
//   highest_sim = -1.0;
//   while ( !fp.eof () )
//  {
//    fp >> id1 >> id2 >> edge_weight;

//    // ignore negative weights!
//    if ( edge_weight <= 0 )
//    {
//       cout << "Error: found negative edge weight in " << filename << ".  Program stopped." << endl;
//       #ifdef MUSE_MPI
//         MPI_Abort ( MPI_COMM_WORLD, 1 );
//       #else
//         exit (1);
//          #endif
//     }

//     if ( highest_sim < edge_weight )
//        highest_sim = edge_weight;

//     id_catalog[id1] = 1;
//     id_catalog[id2] = 1;
//  }

//   fp.close();

//   if ( id_catalog.size() == 0 )
//   {
//     cout << "Error: Proc. " << myid << ": " << filename << " is empty.  Program terminated." << endl;
//  #ifdef MUSE_MPI
//    MPI_Abort ( MPI_COMM_WORLD, 1 );
//  #else
//    exit (1);
//  #endif
//   }

//   // label nodes with sequential integers starting at 0
//   map< int, int>::iterator cat_iter;
//   int id_label;
//   for ( cat_iter = id_catalog.begin(), id_label = 0;
//      cat_iter != id_catalog.end(); cat_iter++, id_label++ )
//     cat_iter->second = id_label;

//   /*
//   // output id_catalog for debugging:
//   for ( cat_iter = id_catalog.begin();
//      cat_iter != id_catalog.end();
//      cat_iter++ )
//  cout << cat_iter->first << "\t" << cat_iter->second << endl;
//   */

//   num_nodes = id_catalog.size();
// }

// read in .parms file, if present

/*
void graph::read_parms ( char *parms_file )
{

          // read from .parms file
          ifstream parms_in ( parms_file );
          if ( !parms_in )
          {
            cout << "Error: could not open .parms file!  Program stopped." << endl;
            #ifdef MUSE_MPI
              MPI_Abort ( MPI_COMM_WORLD, 1 );
            #else
              exit (1);
            #endif
          }

          cout << "Processor " << myid << " reading .parms file." << endl;

          // read in stage parameters
          string parm_label;    // this is ignored in the .parms file

          // initial parameters
          parms_in >> parm_label >> iterations;
          parms_in >> parm_label >> temperature;
          parms_in >> parm_label >> attraction;
          parms_in >> parm_label >> damping_mult;

          // liquid stage
          parms_in >> parm_label >> liquid.iterations;
          parms_in >> parm_label >> liquid.temperature;
          parms_in >> parm_label >> liquid.attraction;
          parms_in >> parm_label >> liquid.damping_mult;

          // expansion stage
          parms_in >> parm_label >> expansion.iterations;
          parms_in >> parm_label >> expansion.temperature;
          parms_in >> parm_label >> expansion.attraction;
          parms_in >> parm_label >> expansion.damping_mult;

          // cooldown stage
          parms_in >> parm_label >> cooldown.iterations;
          parms_in >> parm_label >> cooldown.temperature;
          parms_in >> parm_label >> cooldown.attraction;
          parms_in >> parm_label >> cooldown.damping_mult;

          // crunch stage
          parms_in >> parm_label >> crunch.iterations;
          parms_in >> parm_label >> crunch.temperature;
          parms_in >> parm_label >> crunch.attraction;
          parms_in >> parm_label >> crunch.damping_mult;

          // simmer stage
          parms_in >> parm_label >> simmer.iterations;
          parms_in >> parm_label >> simmer.temperature;
          parms_in >> parm_label >> simmer.attraction;
          parms_in >> parm_label >> simmer.damping_mult;

          parms_in.close();

          // print out parameters for double checking
          if ( myid == 0 )
          {
            cout << "Processor 0 reports the following inputs:" << endl;
            cout << "inital.iterations = " << iterations << endl;
            cout << "initial.temperature = " << temperature << endl;
            cout << "initial.attraction = " << attraction << endl;
            cout << "initial.damping_mult = " << damping_mult << endl;
            cout << " ..." << endl;
            cout << "liquid.iterations = " << liquid.iterations << endl;
            cout << "liquid.temperature = " << liquid.temperature << endl;
            cout << "liquid.attraction = " << liquid.attraction << endl;
            cout << "liquid.damping_mult = " << liquid.damping_mult << endl;
            cout << " ..." << endl;
            cout << "simmer.iterations = " << simmer.iterations << endl;
            cout << "simmer.temperature = " << simmer.temperature << endl;
            cout << "simmer.attraction = " << simmer.attraction << endl;
            cout << "simmer.damping_mult = " << simmer.damping_mult << endl;
          }

}
*/

// init_parms -- this subroutine initializes the edge_cut variables
// used in the original VxOrd starting with the edge_cut parameter.
// In our version, edge_cut = 0 means no cutting, 1 = maximum cut.
// We also set the random seed here.

void graph::init_parms ( int rand_seed, float edge_cut, float real_parm ) {
    IGRAPH_UNUSED(rand_seed);

    // first we translate edge_cut the former tcl sliding scale
    //CUT_END = cut_length_end = 39000.0 * (1.0 - edge_cut) + 1000.0;
    CUT_END = cut_length_end = 40000.0 * (1.0 - edge_cut);

    // cut_length_end cannot actually be 0
    if ( cut_length_end <= 1.0 ) {
        cut_length_end = 1.0;
    }

    float cut_length_start = 4.0 * cut_length_end;

    // now we set the parameters used by ReCompute
    cut_off_length = cut_length_start;
    cut_rate = ( cut_length_start - cut_length_end ) / 400.0;

    // finally set the number of iterations to leave .real coords fixed
    int full_comp_iters;
    full_comp_iters = liquid.iterations + expansion.iterations +
                      cooldown.iterations + crunch.iterations + 3;

    // adjust real parm to iterations (do not enter simmer halfway)
    if ( real_parm < 0 ) {
        real_iterations = (int)real_parm;
    } else if ( real_parm == 1) {
        real_iterations = full_comp_iters + simmer.iterations + 100;
    } else {
        real_iterations = (int)(real_parm * full_comp_iters);
    }

    tot_iterations = 0;
    if ( real_iterations > 0 ) {
        real_fixed = true;
    } else {
        real_fixed = false;
    }

    // calculate total expected iterations (for progress bar display)
    tot_expected_iterations = liquid.iterations +
                              expansion.iterations + cooldown.iterations +
                              crunch.iterations + simmer.iterations;

    /*
    // output edge_cutting parms (for debugging)
    cout << "Processor " << myid << ": "
         << "cut_length_end = CUT_END = " << cut_length_end
         << ", cut_length_start = " << cut_length_start
         << ", cut_rate = " << cut_rate << endl;
    */

    // set random seed
    // srand ( rand_seed ); // Don't need this in igraph

}

void graph::init_parms(const igraph_layout_drl_options_t *options) {
    double rand_seed = 0.0;
    double real_in = -1.0;
    init_parms(rand_seed, options->edge_cut, real_in);
}

// The following subroutine reads a .real file to obtain initial
// coordinates.  If a node is missing coordinates the coordinates
// are computed

// void graph::read_real ( char *real_file )
// {
//   cout << "Processor " << myid << " reading .real file ..." << endl;

//   // read in .real file and mark as fixed
//   ifstream real_in ( real_file );
//   if ( !real_in )
//   {
//     cout << "Error: proc. " << myid << " could not open .real file." << endl;
//     #ifdef MUSE_MPI
//    MPI_Abort ( MPI_COMM_WORLD, 1 );
//  #else
//    exit (1);
//  #endif
//   }

//   int real_id;
//   float real_x, real_y;
//   while ( !real_in.eof () )
//   {
//     real_id = -1;
//     real_in >> real_id >> real_x >> real_y;
//  if ( real_id >= 0 )
//  {
//    positions[id_catalog[real_id]].x = real_x;
//    positions[id_catalog[real_id]].y = real_y;
//    positions[id_catalog[real_id]].fixed = true;

//    /*
//    // output positions read (for debugging)
//       cout << id_catalog[real_id] << " (" << positions[id_catalog[real_id]].x
//         << ", " << positions[id_catalog[real_id]].y << ") "
//         << positions[id_catalog[real_id]].fixed << endl;
//    */

//    // add node to density grid
//    if ( real_iterations > 0 )
//      density_server.Add ( positions[id_catalog[real_id]], fineDensity );
//  }

//   }

//   real_in.close();
// }

int graph::read_real ( const igraph_matrix_t *real_mat,
                       const igraph_vector_bool_t *fixed) {
    long int n = igraph_matrix_nrow(real_mat);
    for (long int i = 0; i < n; i++) {
        positions[id_catalog[i]].x = MATRIX(*real_mat, i, 0);
        positions[id_catalog[i]].y = MATRIX(*real_mat, i, 1);
        positions[id_catalog[i]].fixed = fixed ? VECTOR(*fixed)[i] : false;

        if ( real_iterations > 0 ) {
            density_server.Add ( positions[id_catalog[i]], fineDensity );
        }
    }

    return 0;
}

// The read_part_int subroutine reads the .int
// file produced by convert_sim and gathers the nodes and their
// neighbors in the range start_ind to end_ind.

// void graph::read_int ( char *file_name )
// {

//  ifstream int_file;

//  int_file.open ( file_name );
//  if ( !int_file )
//  {
//      cout << "Error (worker process " << myid << "): could not open .int file." << endl;
//      #ifdef MUSE_MPI
//        MPI_Abort ( MPI_COMM_WORLD, 1 );
//      #else
//        exit (1);
//      #endif
//  }

//  cout << "Processor " << myid << " reading .int file ..." << endl;

//  int node_1, node_2;
//  float weight;

//     while ( !int_file.eof() )
//  {
//      weight = 0;     // all weights should be >= 0
//      int_file >> node_1 >> node_2 >> weight;
//      if ( weight )       // otherwise we are at end of file
//                              // or it is a self-connected node
//      {
//              // normalization from original vxord
//              weight /= highest_sim;
//              weight = weight*fabs(weight);

//              // initialize graph
//              if ( ( node_1 % num_procs ) == myid )
//                  (neighbors[id_catalog[node_1]])[id_catalog[node_2]] = weight;
//              if ( ( node_2 % num_procs ) == myid )
//                  (neighbors[id_catalog[node_2]])[id_catalog[node_1]] = weight;
//      }
//  }
//  int_file.close();

//  /*
//  // the following code outputs the contents of the neighbors structure
//  // (to be used for debugging)

//  map >::iterator i;
//  map::iterator j;

//  for ( i = neighbors.begin(); i != neighbors.end(); i++ ) {
//    cout << myid << ": " << i->first << " ";
//      for (j = (i->second).begin(); j != (i->second).end(); j++ )
//          cout << j->first << " (" << j->second << ") ";
//      cout << endl;
//      }
//  */

// }

/*********************************************
 * Function: ReCompute                       *
 * Description: Compute the graph locations  *
 * Modified from original code by B. Wylie   *
 ********************************************/

int graph::ReCompute( ) {

    // carryover from original VxOrd
    int MIN = 1;

    /*
    // output parameters (for debugging)
    cout << "ReCompute is using the following parameters: "<< endl;
    cout << "STAGE: " << STAGE << ", iter: " << iterations << ", temp = " << temperature
         << ", attract = " << attraction << ", damping_mult = " << damping_mult
       << ", min_edges = " << min_edges << ", cut_off_length = " << cut_off_length
       << ", fineDensity = " << fineDensity << endl;
    */

    /* igraph progress report */
    float progress = (tot_iterations * 100.0 / tot_expected_iterations);

    switch (STAGE) {
    case 0:
        if (iterations == 0) {
            IGRAPH_PROGRESS("DrL layout (initialization stage)", progress, 0);
        } else {
            IGRAPH_PROGRESS("DrL layout (liquid stage)", progress, 0);
        }
        break;
    case 1:
        IGRAPH_PROGRESS("DrL layout (expansion stage)", progress, 0); break;
    case 2:
        IGRAPH_PROGRESS("DrL layout (cooldown and cluster phase)", progress, 0); break;
    case 3:
        IGRAPH_PROGRESS("DrL layout (crunch phase)", progress, 0); break;
    case 5:
        IGRAPH_PROGRESS("DrL layout (simmer phase)", progress, 0); break;
    case 6:
        IGRAPH_PROGRESS("DrL layout (final phase)", 100.0, 0); break;
    default:
        IGRAPH_PROGRESS("DrL layout (unknown phase)", 0.0, 0); break;
    }

    /* Compute Energies for individual nodes */
    update_nodes ();

    // check to see if we need to free fixed nodes
    tot_iterations++;
    if ( tot_iterations >= real_iterations ) {
        real_fixed = false;
    }


    // ****************************************
    // AUTOMATIC CONTROL SECTION
    // ****************************************

    // STAGE 0: LIQUID
    if (STAGE == 0) {

        if ( iterations == 0 ) {
            start_time = time( NULL );
//          if ( myid == 0 )
//              cout << "Entering liquid stage ...";
        }

        if (iterations < liquid.iterations) {
            temperature = liquid.temperature;
            attraction = liquid.attraction;
            damping_mult = liquid.damping_mult;
            iterations++;
//          if ( myid == 0 )
//              cout << "." << flush;

        } else {

            stop_time = time( NULL );
            liquid.time_elapsed = liquid.time_elapsed + (stop_time - start_time);
            temperature = expansion.temperature;
            attraction = expansion.attraction;
            damping_mult = expansion.damping_mult;
            iterations = 0;

            // go to next stage
            STAGE = 1;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering expansion stage ...";
        }
    }

    // STAGE 1: EXPANSION
    if (STAGE == 1) {

        if (iterations < expansion.iterations) {

            // Play with vars
            if (attraction > 1) {
                attraction -= .05f;
            }
            if (min_edges > 12) {
                min_edges -= .05f;
            }
            cut_off_length -= cut_rate;
            if (damping_mult > .1) {
                damping_mult -= .005f;
            }
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;

        } else {

            stop_time = time( NULL );
            expansion.time_elapsed = expansion.time_elapsed + (stop_time - start_time);
            min_edges = 12;
            damping_mult = cooldown.damping_mult;

            STAGE = 2;
            attraction = cooldown.attraction;
            temperature = cooldown.temperature;
            iterations = 0;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering cool-down stage ...";
        }
    }

    // STAGE 2: Cool down and cluster
    else if (STAGE == 2) {

        if (iterations < cooldown.iterations) {

            // Reduce temperature
            if (temperature > 50) {
                temperature -= 10;
            }

            // Reduce cut length
            if (cut_off_length > cut_length_end) {
                cut_off_length -= cut_rate * 2;
            }
            if (min_edges > MIN) {
                min_edges -= .2f;
            }
            //min_edges = 99;
            iterations++;
//          if ( myid == 0 )
//              cout << "." << flush;

        } else {

            stop_time = time( NULL );
            cooldown.time_elapsed = cooldown.time_elapsed + (stop_time - start_time);
            cut_off_length = cut_length_end;
            temperature = crunch.temperature;
            damping_mult = crunch.damping_mult;
            min_edges = MIN;
            //min_edges = 99; // In other words: no more cutting

            STAGE = 3;
            iterations = 0;
            attraction = crunch.attraction;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering crunch stage ...";
        }
    }

    // STAGE 3: Crunch
    else if (STAGE == 3) {

        if (iterations < crunch.iterations) {
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;
        } else {

            stop_time = time( NULL );
            crunch.time_elapsed = crunch.time_elapsed + (stop_time - start_time);
            iterations = 0;
            temperature = simmer.temperature;
            attraction = simmer.attraction;
            damping_mult = simmer.damping_mult;
            min_edges = 99;
            fineDensity = true;

            STAGE = 5;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering simmer stage ...";
        }
    }

    // STAGE 5: Simmer
    else if ( STAGE == 5 ) {

        if (iterations < simmer.iterations) {
            if (temperature > 50) {
                temperature -= 2;
            }
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;
        } else {
            stop_time = time( NULL );
            simmer.time_elapsed = simmer.time_elapsed + (stop_time - start_time);

            STAGE = 6;

//          if ( myid == 0 )
//              cout << "Layout calculation completed in " <<
//                ( liquid.time_elapsed + expansion.time_elapsed +
//                  cooldown.time_elapsed + crunch.time_elapsed +
//                  simmer.time_elapsed )
//                   << " seconds (not including I/O)."
//                   << endl;
        }
    }

    // STAGE 6: All Done!
    else if ( STAGE == 6) {

        /*
        // output parameters (for debugging)
        cout << "ReCompute is using the following parameters: "<< endl;
        cout << "STAGE: " << STAGE << ", iter: " << iterations << ", temp = " << temperature
             << ", attract = " << attraction << ", damping_mult = " << damping_mult
             << ", min_edges = " << min_edges << ", cut_off_length = " << cut_off_length
             << ", fineDensity = " << fineDensity << endl;
        */

        return 0;
    }

    // ****************************************
    // END AUTOMATIC CONTROL SECTION
    // ****************************************

    // Still need more recomputation
    return 1;

}

// update_nodes -- this function will complete the primary node update
// loop in layout's recompute routine.  It follows exactly the same
// sequence to ensure similarity of parallel layout to the standard layout

void graph::update_nodes ( ) {

    vector node_indices;           // node list of nodes currently being updated
    float old_positions[2 * MAX_PROCS]; // positions before update
    float new_positions[2 * MAX_PROCS]; // positions after update

    bool all_fixed;                     // check if all nodes are fixed

    // initial node list consists of 0,1,...,num_procs
    for ( int i = 0; i < num_procs; i++ ) {
        node_indices.push_back( i );
    }

    // next we calculate the number of nodes there would be if the
    // num_nodes by num_procs schedule grid were perfectly square
    int square_num_nodes = (int)(num_procs + num_procs * floor ((float)(num_nodes - 1) / (float)num_procs ));

    for ( int i = myid; i < square_num_nodes; i += num_procs ) {

        // get old positions
        get_positions ( node_indices, old_positions );

        // default new position is old position
        get_positions ( node_indices, new_positions );

        if ( i < num_nodes ) {

            // advance random sequence according to myid
            for ( int j = 0; j < 2 * myid; j++ ) {
                RNG_UNIF01();
            }
            // rand();

            // calculate node energy possibilities
            if ( !(positions[i].fixed && real_fixed) ) {
                update_node_pos ( i, old_positions, new_positions );
            }

            // advance random sequence for next iteration
            for ( unsigned int j = 2 * myid; j < 2 * (node_indices.size() - 1); j++ ) {
                RNG_UNIF01();
            }
            // rand();

        } else {
            // advance random sequence according to use by
            // the other processors
            for ( unsigned int j = 0; j < 2 * (node_indices.size()); j++ ) {
                RNG_UNIF01();
            }
            //rand();
        }

        // check if anything was actually updated (e.g. everything was fixed)
        all_fixed = true;
        for ( unsigned int j = 0; j < node_indices.size (); j++ )
            if ( !(positions [ node_indices[j] ].fixed && real_fixed) ) {
                all_fixed = false;
            }

        // update positions across processors (if not all fixed)
        if ( !all_fixed ) {
#ifdef MUSE_MPI
            MPI_Allgather ( &new_positions[2 * myid], 2, MPI_FLOAT,
                            new_positions, 2, MPI_FLOAT, MPI_COMM_WORLD );
#endif

            // update positions (old to new)
            update_density ( node_indices, old_positions, new_positions );
        }

        /*
        if ( myid == 0 )
          {
            // output node list (for debugging)
            for ( unsigned int j = 0; j < node_indices.size(); j++ )
              cout << node_indices[j] << " ";
            cout << endl;
          }
        */

        // compute node list for next update
        for ( unsigned int j = 0; j < node_indices.size(); j++ ) {
            node_indices [j] += num_procs;
        }

        while ( !node_indices.empty() && node_indices.back() >= num_nodes ) {
            node_indices.pop_back ( );
        }

    }

    // update first_add and fine_first_add
    first_add = false;
    if ( fineDensity ) {
        fine_first_add = false;
    }

}

// The get_positions function takes the node_indices list
// and returns the corresponding positions in an array.

void graph::get_positions ( vector &node_indices,
                            float return_positions[2 * MAX_PROCS]  ) {

    // fill positions
    for (unsigned int i = 0; i < node_indices.size(); i++) {
        return_positions[2 * i] = positions[ node_indices[i] ].x;
        return_positions[2 * i + 1] = positions[ node_indices[i] ].y;
    }

}

// update_node_pos -- this subroutine does the actual work of computing
// the new position of a given node.  num_act_proc gives the number
// of active processes at this level for use by the random number
// generators.

void graph::update_node_pos ( int node_ind,
                              float old_positions[2 * MAX_PROCS],
                              float new_positions[2 * MAX_PROCS] ) {

    float energies[2];          // node energies for possible positions
    float updated_pos[2][2];    // possible positions
    float pos_x, pos_y;

    // old VxOrd parameter
    float jump_length = .010 * temperature;

    // subtract old node
    density_server.Subtract ( positions[node_ind], first_add, fine_first_add, fineDensity );

    // compute node energy for old solution
    energies[0] = Compute_Node_Energy ( node_ind );

    // move node to centroid position
    Solve_Analytic ( node_ind, pos_x, pos_y );
    positions[node_ind].x = updated_pos[0][0] = pos_x;
    positions[node_ind].y = updated_pos[0][1] = pos_y;

    /*
    // ouput random numbers (for debugging)
    int rand_0, rand_1;
    rand_0 = rand();
    rand_1 = rand();
    cout << myid << ": " << rand_0 << ", " << rand_1 << endl;
    */

    // Do random method (RAND_MAX is C++ maximum random number)
    updated_pos[1][0] = updated_pos[0][0] + (.5 - RNG_UNIF01()) * jump_length;
    updated_pos[1][1] = updated_pos[0][1] + (.5 - RNG_UNIF01()) * jump_length;

    // compute node energy for random position
    positions[node_ind].x = updated_pos[1][0];
    positions[node_ind].y = updated_pos[1][1];
    energies[1] = Compute_Node_Energy ( node_ind );

    /*
    // output update possiblities (debugging):
    cout << node_ind << ": (" << updated_pos[0][0] << "," << updated_pos[0][1]
         << "), " << energies[0] << "; (" << updated_pos[1][0] << ","
         << updated_pos[1][1] << "), " << energies[1] << endl;
    */

    // add back old position
    positions[node_ind].x = old_positions[2 * myid];
    positions[node_ind].y = old_positions[2 * myid + 1];
    if ( !fineDensity && !first_add ) {
        density_server.Add ( positions[node_ind], fineDensity );
    } else if ( !fine_first_add ) {
        density_server.Add ( positions[node_ind], fineDensity );
    }

    // choose updated node position with lowest energy
    if ( energies[0] < energies[1] ) {
        new_positions[2 * myid] = updated_pos[0][0];
        new_positions[2 * myid + 1] = updated_pos[0][1];
        positions[node_ind].energy = energies[0];
    } else {
        new_positions[2 * myid] = updated_pos[1][0];
        new_positions[2 * myid + 1] = updated_pos[1][1];
        positions[node_ind].energy = energies[1];
    }

}

// update_density takes a sequence of node_indices and their positions and
// updates the positions by subtracting the old positions and adding the
// new positions to the density grid.

void graph::update_density ( vector &node_indices,
                             float old_positions[2 * MAX_PROCS],
                             float new_positions[2 * MAX_PROCS] ) {

    // go through each node and subtract old position from
    // density grid before adding new position
    for ( unsigned int i = 0; i < node_indices.size(); i++ ) {
        positions[node_indices[i]].x = old_positions[2 * i];
        positions[node_indices[i]].y = old_positions[2 * i + 1];
        density_server.Subtract ( positions[node_indices[i]],
                                  first_add, fine_first_add, fineDensity );

        positions[node_indices[i]].x = new_positions[2 * i];
        positions[node_indices[i]].y = new_positions[2 * i + 1];
        density_server.Add ( positions[node_indices[i]], fineDensity );
    }

}

/********************************************
* Function: Compute_Node_Energy             *
* Description: Compute the node energy      *
* This code has been modified from the      *
* original code by B. Wylie.                *
*********************************************/

float graph::Compute_Node_Energy( int node_ind ) {

    /* Want to expand 4th power range of attraction */
    float attraction_factor = attraction * attraction *
                              attraction * attraction * 2e-2;

    map ::iterator EI;
    float x_dis, y_dis;
    float energy_distance, weight;
    float node_energy = 0;

    // Add up all connection energies
    for (EI = neighbors[node_ind].begin(); EI != neighbors[node_ind].end(); ++EI) {

        // Get edge weight
        weight = EI->second;

        // Compute x,y distance
        x_dis = positions[ node_ind ].x - positions[ EI->first ].x;
        y_dis = positions[ node_ind ].y - positions[ EI->first ].y;

        // Energy Distance
        energy_distance = x_dis * x_dis + y_dis * y_dis;
        if (STAGE < 2) {
            energy_distance *= energy_distance;
        }

        // In the liquid phase we want to discourage long link distances
        if (STAGE == 0) {
            energy_distance *= energy_distance;
        }

        node_energy += weight * attraction_factor * energy_distance;
    }

    // output effect of density (debugging)
    //cout << "[before: " << node_energy;

    // add density
    node_energy += density_server.GetDensity ( positions[ node_ind ].x, positions[ node_ind ].y,
                   fineDensity );

    // after calling density server (debugging)
    //cout << ", after: " << node_energy << "]" << endl;

    // return computated energy
    return node_energy;
}


/*********************************************
* Function: Solve_Analytic                   *
* Description: Compute the node position     *
* This is a modified version of the function *
* originally written by B. Wylie             *
*********************************************/

void graph::Solve_Analytic( int node_ind, float &pos_x, float &pos_y ) {

    map ::iterator EI;
    float total_weight = 0;
    float x_dis, y_dis, x_cen = 0, y_cen = 0;
    float x = 0, y = 0, dis;
    float damping, weight;

    // Sum up all connections
    for (EI = neighbors[node_ind].begin(); EI != neighbors[node_ind].end(); ++EI) {
        weight = EI->second;
        total_weight += weight;
        x +=  weight * positions[ EI->first ].x;
        y +=  weight * positions[ EI->first ].y;
    }

    // Now set node position
    if (total_weight > 0) {

        // Compute centriod
        x_cen = x / total_weight;
        y_cen = y / total_weight;
        damping = 1.0 - damping_mult;
        pos_x = damping * positions[ node_ind ].x + (1.0 - damping) * x_cen;
        pos_y = damping * positions[ node_ind ].y + (1.0 - damping) * y_cen;
    } else {
        pos_x = positions[ node_ind ].x;
        pos_y = positions[ node_ind ].y;
    }

    // No cut edge flag (?)
    if (min_edges == 99) {
        return;
    }

    // Don't cut at end of scale
    if ( CUT_END >= 39500 ) {
        return;
    }

    float num_connections = sqrt((double)neighbors[node_ind].size());
    float maxLength = 0;

    map::iterator maxIndex;

    // Go through nodes edges... cutting if necessary
    for (EI = maxIndex = neighbors[node_ind].begin();
         EI != neighbors[node_ind].end(); ++EI) {

        // Check for at least min edges
        if (neighbors[node_ind].size() < min_edges) {
            continue;
        }

        x_dis = x_cen - positions[ EI->first ].x;
        y_dis = y_cen - positions[ EI->first ].y;
        dis = x_dis * x_dis + y_dis * y_dis;
        dis *= num_connections;

        // Store maximum edge
        if (dis > maxLength) {
            maxLength = dis;
            maxIndex = EI;
        }
    }

    // If max length greater than cut_length then cut
    if (maxLength > cut_off_length) {
        neighbors[ node_ind ].erase( maxIndex );
    }

}


// write_coord writes out the coordinate file of the final solutions

// void graph::write_coord( const char *file_name )
// {

//   ofstream coordOUT( file_name );
//   if ( !coordOUT )
//   {
//  cout << "Could not open " << file_name << ".  Program terminated." << endl;
//  #ifdef MUSE_MPI
//    MPI_Abort ( MPI_COMM_WORLD, 1 );
//  #else
//    exit (1);
//  #endif
//   }

//   cout << "Writing out solution to " << file_name << " ..." << endl;

//   for (unsigned int i = 0; i < positions.size(); i++) {
//     coordOUT << positions[i].id << "\t" << positions[i].x << "\t" << positions[i].y < >::iterator i;
  map::iterator j;

  for ( i = neighbors.begin(); i != neighbors.end(); i++ )
    for (j = (i->second).begin(); j != (i->second).end(); j++ )
    simOUT << positions[i->first].id << "\t"
           << positions[j->first].id << "\t"
           << j->second << endl;

  simOUT.close();

}
*/

// get_tot_energy adds up the energy for each node to give an estimate of the
// quality of the minimization.

float graph::get_tot_energy ( ) {

    float my_tot_energy, tot_energy;
    my_tot_energy = 0;
    for ( int i = myid; i < num_nodes; i += num_procs ) {
        my_tot_energy += positions[i].energy;
    }

    //vector::iterator i;
    //for ( i = positions.begin(); i != positions.end(); i++ )
    //  tot_energy += i->energy;

#ifdef MUSE_MPI
    MPI_Reduce ( &my_tot_energy, &tot_energy, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD );
#else
    tot_energy = my_tot_energy;
#endif

    return tot_energy;

}


// The following subroutine draws the graph with possible intermediate
// output (int_out is set to 0 if not proc. 0).  int_out is the parameter
// passed by the user, and coord_file is the .coord file.

// void graph::draw_graph ( int int_out, char *coord_file )
// {

//  // layout graph (with possible intermediate output)
//  int count_iter = 0, count_file = 1;
//  char int_coord_file [MAX_FILE_NAME + MAX_INT_LENGTH];
//  while ( ReCompute( ) )
//      if ( (int_out > 0) && (count_iter == int_out) )
//      {
//          // output intermediate solution
//          sprintf ( int_coord_file, "%s.%d", coord_file, count_file );
//          write_coord ( int_coord_file );

//          count_iter = 0;
//          count_file++;
//      }
//      else
//          count_iter++;

// }

int graph::draw_graph(igraph_matrix_t *res) {
    int count_iter = 0;
    while (ReCompute()) {
        IGRAPH_ALLOW_INTERRUPTION();
        count_iter++;
    }
    long int n = positions.size();
    IGRAPH_CHECK(igraph_matrix_resize(res, n, 2));
    for (long int i = 0; i < n; i++) {
        MATRIX(*res, i, 0) = positions[i].x;
        MATRIX(*res, i, 1) = positions[i].y;
    }
    return 0;
}

} // namespace drl
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_graph.h0000644000175100001710000001146100000000000024655 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// The graph class contains the methods necessary to draw the
// graph.  It calls on the density server class to obtain
// position and density information

#include "DensityGrid.h"
#include "igraph_layout.h"

#include 
#include 
#include 

namespace drl {

// layout schedule information
struct layout_schedule {
    int iterations;
    float temperature;
    float attraction;
    float damping_mult;
    time_t time_elapsed;
};

class graph {

public:

    // Methods
    void init_parms ( int rand_seed, float edge_cut, float real_parm );
    void init_parms ( const igraph_layout_drl_options_t *options );
    void read_parms ( char *parms_file );
    void read_real ( char *real_file );
    int read_real ( const igraph_matrix_t *real_mat,
                    const igraph_vector_bool_t *fixed);
    void scan_int ( char *filename );
    void read_int ( char *file_name );
    void draw_graph ( int int_out, char *coord_file );
    int draw_graph (igraph_matrix_t *res);
    void write_coord ( const char *file_name );
    void write_sim ( const char *file_name );
    float get_tot_energy ( );

    // Con/Decon
    graph( int proc_id, int tot_procs, char *int_file );
    ~graph( ) { }
    graph( const igraph_t *igraph,
           const igraph_layout_drl_options_t *options,
           const igraph_vector_t *weights);

private:

    // Methods
    int ReCompute ( );
    void update_nodes ( );
    float Compute_Node_Energy ( int node_ind );
    void Solve_Analytic ( int node_ind, float &pos_x, float &pos_y );
    void get_positions ( std::vector &node_indices, float return_positions[2 * MAX_PROCS] );
    void update_density ( std::vector &node_indices,
                          float old_positions[2 * MAX_PROCS],
                          float new_positions[2 * MAX_PROCS] );
    void update_node_pos ( int node_ind,
                           float old_positions[2 * MAX_PROCS],
                           float new_positions[2 * MAX_PROCS] );

    // MPI information
    int myid, num_procs;

    // graph decomposition information
    int num_nodes;                  // number of nodes in graph
    float highest_sim;              // highest sim for normalization
    std::map  id_catalog;      // id_catalog[file id] = internal id
    std::map  > neighbors;     // neighbors of nodes on this proc.

    // graph layout information
    std::vector positions;
    DensityGrid density_server;

    // original VxOrd information
    int STAGE, iterations;
    float temperature, attraction, damping_mult;
    float min_edges, CUT_END, cut_length_end, cut_off_length, cut_rate;
    bool first_add, fine_first_add, fineDensity;

    // scheduling variables
    layout_schedule liquid;
    layout_schedule expansion;
    layout_schedule cooldown;
    layout_schedule crunch;
    layout_schedule simmer;

    // timing statistics
    time_t start_time, stop_time;

    // online clustering information
    int real_iterations;    // number of iterations to hold .real input fixed
    int tot_iterations;
    int tot_expected_iterations; // for progress bar
    bool real_fixed;
};

} // namespace drl
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_graph_3d.cpp0000644000175100001710000007057500000000000025611 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains the member definitions of the master class

#include 
#include 
#include 

using namespace std;

#include "drl_graph_3d.h"
#include "igraph_random.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "core/interruption.h"
#ifdef MUSE_MPI
    #include 
#endif

namespace drl3d {

graph::graph(const igraph_t *igraph,
             const igraph_layout_drl_options_t *options,
             const igraph_vector_t *weights) {
    myid = 0;
    num_procs = 1;

    STAGE = 0;
    iterations = options->init_iterations;
    temperature = options->init_temperature;
    attraction = options->init_attraction;
    damping_mult = options->init_damping_mult;
    min_edges = 20;
    first_add = fine_first_add = true;
    fineDensity = false;

    // Brian's original Vx schedule
    liquid.iterations = options->liquid_iterations;
    liquid.temperature = options->liquid_temperature;
    liquid.attraction = options->liquid_attraction;
    liquid.damping_mult = options->liquid_damping_mult;
    liquid.time_elapsed = 0;

    expansion.iterations = options->expansion_iterations;
    expansion.temperature = options->expansion_temperature;
    expansion.attraction = options->expansion_attraction;
    expansion.damping_mult = options->expansion_damping_mult;
    expansion.time_elapsed = 0;

    cooldown.iterations = options->cooldown_iterations;
    cooldown.temperature = options->cooldown_temperature;
    cooldown.attraction = options->cooldown_attraction;
    cooldown.damping_mult = options->cooldown_damping_mult;
    cooldown.time_elapsed = 0;

    crunch.iterations = options->crunch_iterations;
    crunch.temperature = options->crunch_temperature;
    crunch.attraction = options->crunch_attraction;
    crunch.damping_mult = options->crunch_damping_mult;
    crunch.time_elapsed = 0;

    simmer.iterations = options->simmer_iterations;
    simmer.temperature = options->simmer_temperature;
    simmer.attraction = options->simmer_attraction;
    simmer.damping_mult = options->simmer_damping_mult;
    simmer.time_elapsed = 0;

    // scan .int file for node info
    highest_sim = 1.0;
    num_nodes = igraph_vcount(igraph);
    long int no_of_edges = igraph_ecount(igraph);
    for (long int i = 0; i < num_nodes; i++) {
        id_catalog[i] = 1;
    }
    map< int, int>::iterator cat_iter;
    for ( cat_iter = id_catalog.begin();
          cat_iter != id_catalog.end(); cat_iter++) {
        cat_iter->second = cat_iter->first;
    }

    // populate node positions and ids
    positions.reserve ( num_nodes );
    for ( cat_iter = id_catalog.begin();
          cat_iter != id_catalog.end();
          cat_iter++ ) {
        positions.push_back ( Node( cat_iter->first ) );
    }

    // read .int file for graph info
    long int node_1, node_2;
    double weight;
    for (long int i = 0; i < no_of_edges; i++) {
        node_1 = IGRAPH_FROM(igraph, i);
        node_2 = IGRAPH_TO(igraph, i);
        weight = weights ? VECTOR(*weights)[i] : 1.0 ;
        (neighbors[id_catalog[node_1]])[id_catalog[node_2]] = weight;
        (neighbors[id_catalog[node_2]])[id_catalog[node_1]] = weight;
    }

    // initialize density server
    density_server.Init();

}

// init_parms -- this subroutine initializes the edge_cut variables
// used in the original VxOrd starting with the edge_cut parameter.
// In our version, edge_cut = 0 means no cutting, 1 = maximum cut.
// We also set the random seed here.

void graph::init_parms ( int rand_seed, float edge_cut, float real_parm ) {

    IGRAPH_UNUSED(rand_seed);
    // first we translate edge_cut the former tcl sliding scale
    //CUT_END = cut_length_end = 39000.0 * (1.0 - edge_cut) + 1000.0;
    CUT_END = cut_length_end = 40000.0 * (1.0 - edge_cut);

    // cut_length_end cannot actually be 0
    if ( cut_length_end <= 1.0 ) {
        cut_length_end = 1.0;
    }

    float cut_length_start = 4.0 * cut_length_end;

    // now we set the parameters used by ReCompute
    cut_off_length = cut_length_start;
    cut_rate = ( cut_length_start - cut_length_end ) / 400.0;

    // finally set the number of iterations to leave .real coords fixed
    int full_comp_iters;
    full_comp_iters = liquid.iterations + expansion.iterations +
                      cooldown.iterations + crunch.iterations + 3;

    // adjust real parm to iterations (do not enter simmer halfway)
    if ( real_parm < 0 ) {
        real_iterations = (int)real_parm;
    } else if ( real_parm == 1) {
        real_iterations = full_comp_iters + simmer.iterations + 100;
    } else {
        real_iterations = (int)(real_parm * full_comp_iters);
    }

    tot_iterations = 0;
    if ( real_iterations > 0 ) {
        real_fixed = true;
    } else {
        real_fixed = false;
    }

    // calculate total expected iterations (for progress bar display)
    tot_expected_iterations = liquid.iterations +
                              expansion.iterations + cooldown.iterations +
                              crunch.iterations + simmer.iterations;

    /*
    // output edge_cutting parms (for debugging)
    cout << "Processor " << myid << ": "
         << "cut_length_end = CUT_END = " << cut_length_end
         << ", cut_length_start = " << cut_length_start
         << ", cut_rate = " << cut_rate << endl;
    */

    // set random seed
    // srand ( rand_seed ); // Don't need this in igraph

}

void graph::init_parms(const igraph_layout_drl_options_t *options) {
    double rand_seed = 0.0;
    double real_in = -1.0;
    init_parms(rand_seed, options->edge_cut, real_in);
}

int graph::read_real ( const igraph_matrix_t *real_mat,
                       const igraph_vector_bool_t *fixed) {
    long int n = igraph_matrix_nrow(real_mat);
    for (long int i = 0; i < n; i++) {
        positions[id_catalog[i]].x = MATRIX(*real_mat, i, 0);
        positions[id_catalog[i]].y = MATRIX(*real_mat, i, 1);
        positions[id_catalog[i]].z = MATRIX(*real_mat, i, 2);
        positions[id_catalog[i]].fixed = fixed ? VECTOR(*fixed)[i] : false;

        if ( real_iterations > 0 ) {
            density_server.Add ( positions[id_catalog[i]], fineDensity );
        }
    }

    return 0;
}

/*********************************************
 * Function: ReCompute                       *
 * Description: Compute the graph locations  *
 * Modified from original code by B. Wylie   *
 ********************************************/

int graph::ReCompute( ) {

    // carryover from original VxOrd
    int MIN = 1;

    /*
    // output parameters (for debugging)
    cout << "ReCompute is using the following parameters: "<< endl;
    cout << "STAGE: " << STAGE << ", iter: " << iterations << ", temp = " << temperature
         << ", attract = " << attraction << ", damping_mult = " << damping_mult
       << ", min_edges = " << min_edges << ", cut_off_length = " << cut_off_length
       << ", fineDensity = " << fineDensity << endl;
    */

    /* igraph progress report */
    float progress = (tot_iterations * 100.0 / tot_expected_iterations);

    switch (STAGE) {
    case 0:
        if (iterations == 0) {
            IGRAPH_PROGRESS("DrL layout (initialization stage)", progress, 0);
        } else {
            IGRAPH_PROGRESS("DrL layout (liquid stage)", progress, 0);
        }
        break;
    case 1:
        IGRAPH_PROGRESS("DrL layout (expansion stage)", progress, 0); break;
    case 2:
        IGRAPH_PROGRESS("DrL layout (cooldown and cluster phase)", progress, 0); break;
    case 3:
        IGRAPH_PROGRESS("DrL layout (crunch phase)", progress, 0); break;
    case 5:
        IGRAPH_PROGRESS("DrL layout (simmer phase)", progress, 0); break;
    case 6:
        IGRAPH_PROGRESS("DrL layout (final phase)", 100.0, 0); break;
    default:
        IGRAPH_PROGRESS("DrL layout (unknown phase)", 0.0, 0); break;
    }

    /* Compute Energies for individual nodes */
    update_nodes ();

    // check to see if we need to free fixed nodes
    tot_iterations++;
    if ( tot_iterations >= real_iterations ) {
        real_fixed = false;
    }


    // ****************************************
    // AUTOMATIC CONTROL SECTION
    // ****************************************

    // STAGE 0: LIQUID
    if (STAGE == 0) {

        if ( iterations == 0 ) {
            start_time = time( NULL );
//          if ( myid == 0 )
//              cout << "Entering liquid stage ...";
        }

        if (iterations < liquid.iterations) {
            temperature = liquid.temperature;
            attraction = liquid.attraction;
            damping_mult = liquid.damping_mult;
            iterations++;
//          if ( myid == 0 )
//              cout << "." << flush;

        } else {

            stop_time = time( NULL );
            liquid.time_elapsed = liquid.time_elapsed + (stop_time - start_time);
            temperature = expansion.temperature;
            attraction = expansion.attraction;
            damping_mult = expansion.damping_mult;
            iterations = 0;

            // go to next stage
            STAGE = 1;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering expansion stage ...";
        }
    }

    // STAGE 1: EXPANSION
    if (STAGE == 1) {

        if (iterations < expansion.iterations) {

            // Play with vars
            if (attraction > 1) {
                attraction -= .05f;
            }
            if (min_edges > 12) {
                min_edges -= .05f;
            }
            cut_off_length -= cut_rate;
            if (damping_mult > .1) {
                damping_mult -= .005f;
            }
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;

        } else {

            stop_time = time( NULL );
            expansion.time_elapsed = expansion.time_elapsed + (stop_time - start_time);
            min_edges = 12;
            damping_mult = cooldown.damping_mult;

            STAGE = 2;
            attraction = cooldown.attraction;
            temperature = cooldown.temperature;
            iterations = 0;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering cool-down stage ...";
        }
    }

    // STAGE 2: Cool down and cluster
    else if (STAGE == 2) {

        if (iterations < cooldown.iterations) {

            // Reduce temperature
            if (temperature > 50) {
                temperature -= 10;
            }

            // Reduce cut length
            if (cut_off_length > cut_length_end) {
                cut_off_length -= cut_rate * 2;
            }
            if (min_edges > MIN) {
                min_edges -= .2f;
            }
            //min_edges = 99;
            iterations++;
//          if ( myid == 0 )
//              cout << "." << flush;

        } else {

            stop_time = time( NULL );
            cooldown.time_elapsed = cooldown.time_elapsed + (stop_time - start_time);
            cut_off_length = cut_length_end;
            temperature = crunch.temperature;
            damping_mult = crunch.damping_mult;
            min_edges = MIN;
            //min_edges = 99; // In other words: no more cutting

            STAGE = 3;
            iterations = 0;
            attraction = crunch.attraction;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering crunch stage ...";
        }
    }

    // STAGE 3: Crunch
    else if (STAGE == 3) {

        if (iterations < crunch.iterations) {
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;
        } else {

            stop_time = time( NULL );
            crunch.time_elapsed = crunch.time_elapsed + (stop_time - start_time);
            iterations = 0;
            temperature = simmer.temperature;
            attraction = simmer.attraction;
            damping_mult = simmer.damping_mult;
            min_edges = 99;
            fineDensity = true;

            STAGE = 5;
            start_time = time( NULL );

//          if ( myid == 0 )
//              cout << "Entering simmer stage ...";
        }
    }

    // STAGE 5: Simmer
    else if ( STAGE == 5 ) {

        if (iterations < simmer.iterations) {
            if (temperature > 50) {
                temperature -= 2;
            }
            iterations++;
//          if ( myid == 0 ) cout << "." << flush;
        } else {
            stop_time = time( NULL );
            simmer.time_elapsed = simmer.time_elapsed + (stop_time - start_time);

            STAGE = 6;

//          if ( myid == 0 )
//              cout << "Layout calculation completed in " <<
//                ( liquid.time_elapsed + expansion.time_elapsed +
//                  cooldown.time_elapsed + crunch.time_elapsed +
//                  simmer.time_elapsed )
//                   << " seconds (not including I/O)."
//                   << endl;
        }
    }

    // STAGE 6: All Done!
    else if ( STAGE == 6) {

        /*
        // output parameters (for debugging)
        cout << "ReCompute is using the following parameters: "<< endl;
        cout << "STAGE: " << STAGE << ", iter: " << iterations << ", temp = " << temperature
             << ", attract = " << attraction << ", damping_mult = " << damping_mult
             << ", min_edges = " << min_edges << ", cut_off_length = " << cut_off_length
             << ", fineDensity = " << fineDensity << endl;
        */

        return 0;
    }

    // ****************************************
    // END AUTOMATIC CONTROL SECTION
    // ****************************************

    // Still need more recomputation
    return 1;

}

// update_nodes -- this function will complete the primary node update
// loop in layout's recompute routine.  It follows exactly the same
// sequence to ensure similarity of parallel layout to the standard layout

void graph::update_nodes ( ) {

    vector node_indices;           // node list of nodes currently being updated
    float old_positions[2 * MAX_PROCS]; // positions before update
    float new_positions[2 * MAX_PROCS]; // positions after update

    bool all_fixed;                     // check if all nodes are fixed

    // initial node list consists of 0,1,...,num_procs
    for ( int i = 0; i < num_procs; i++ ) {
        node_indices.push_back( i );
    }

    // next we calculate the number of nodes there would be if the
    // num_nodes by num_procs schedule grid were perfectly square
    int square_num_nodes = (int)(num_procs + num_procs * floor ((float)(num_nodes - 1) / (float)num_procs ));

    for ( int i = myid; i < square_num_nodes; i += num_procs ) {

        // get old positions
        get_positions ( node_indices, old_positions );

        // default new position is old position
        get_positions ( node_indices, new_positions );

        if ( i < num_nodes ) {

            // advance random sequence according to myid
            for ( int j = 0; j < 2 * myid; j++ ) {
                RNG_UNIF01();
            }
            // rand();

            // calculate node energy possibilities
            if ( !(positions[i].fixed && real_fixed) ) {
                update_node_pos ( i, old_positions, new_positions );
            }

            // advance random sequence for next iteration
            for ( unsigned int j = 2 * myid; j < 2 * (node_indices.size() - 1); j++ ) {
                RNG_UNIF01();
            }
            // rand();

        } else {
            // advance random sequence according to use by
            // the other processors
            for ( unsigned int j = 0; j < 2 * (node_indices.size()); j++ ) {
                RNG_UNIF01();
            }
            //rand();
        }

        // check if anything was actually updated (e.g. everything was fixed)
        all_fixed = true;
        for ( unsigned int j = 0; j < node_indices.size (); j++ )
            if ( !(positions [ node_indices[j] ].fixed && real_fixed) ) {
                all_fixed = false;
            }

        // update positions across processors (if not all fixed)
        if ( !all_fixed ) {
#ifdef MUSE_MPI
            MPI_Allgather ( &new_positions[2 * myid], 2, MPI_FLOAT,
                            new_positions, 2, MPI_FLOAT, MPI_COMM_WORLD );
#endif

            // update positions (old to new)
            update_density ( node_indices, old_positions, new_positions );
        }

        /*
        if ( myid == 0 )
          {
            // output node list (for debugging)
            for ( unsigned int j = 0; j < node_indices.size(); j++ )
              cout << node_indices[j] << " ";
            cout << endl;
          }
        */

        // compute node list for next update
        for ( unsigned int j = 0; j < node_indices.size(); j++ ) {
            node_indices [j] += num_procs;
        }

        while ( !node_indices.empty() && node_indices.back() >= num_nodes ) {
            node_indices.pop_back ( );
        }

    }

    // update first_add and fine_first_add
    first_add = false;
    if ( fineDensity ) {
        fine_first_add = false;
    }

}

// The get_positions function takes the node_indices list
// and returns the corresponding positions in an array.

void graph::get_positions ( vector &node_indices,
                            float return_positions[3 * MAX_PROCS]  ) {

    // fill positions
    for (unsigned int i = 0; i < node_indices.size(); i++) {
        return_positions[3 * i] = positions[ node_indices[i] ].x;
        return_positions[3 * i + 1] = positions[ node_indices[i] ].y;
        return_positions[3 * i + 2] = positions[ node_indices[i] ].z;
    }

}

// update_node_pos -- this subroutine does the actual work of computing
// the new position of a given node.  num_act_proc gives the number
// of active processes at this level for use by the random number
// generators.

void graph::update_node_pos ( int node_ind,
                              float old_positions[3 * MAX_PROCS],
                              float new_positions[3 * MAX_PROCS] ) {

    float energies[2];          // node energies for possible positions
    float updated_pos[2][3];    // possible positions
    float pos_x, pos_y, pos_z;

    // old VxOrd parameter
    float jump_length = .010 * temperature;

    // subtract old node
    density_server.Subtract ( positions[node_ind], first_add, fine_first_add, fineDensity );

    // compute node energy for old solution
    energies[0] = Compute_Node_Energy ( node_ind );

    // move node to centroid position
    Solve_Analytic ( node_ind, pos_x, pos_y, pos_z );
    positions[node_ind].x = updated_pos[0][0] = pos_x;
    positions[node_ind].y = updated_pos[0][1] = pos_y;
    positions[node_ind].z = updated_pos[0][2] = pos_z;

    /*
    // ouput random numbers (for debugging)
    int rand_0, rand_1;
    rand_0 = rand();
    rand_1 = rand();
    cout << myid << ": " << rand_0 << ", " << rand_1 << endl;
    */

    // Do random method (RAND_MAX is C++ maximum random number)
    updated_pos[1][0] = updated_pos[0][0] + (.5 - RNG_UNIF01()) * jump_length;
    updated_pos[1][1] = updated_pos[0][1] + (.5 - RNG_UNIF01()) * jump_length;
    updated_pos[1][2] = updated_pos[0][2] + (.5 - RNG_UNIF01()) * jump_length;

    // compute node energy for random position
    positions[node_ind].x = updated_pos[1][0];
    positions[node_ind].y = updated_pos[1][1];
    positions[node_ind].z = updated_pos[1][2];
    energies[1] = Compute_Node_Energy ( node_ind );

    /*
    // output update possiblities (debugging):
    cout << node_ind << ": (" << updated_pos[0][0] << "," << updated_pos[0][1]
         << "), " << energies[0] << "; (" << updated_pos[1][0] << ","
         << updated_pos[1][1] << "), " << energies[1] << endl;
    */

    // add back old position
    positions[node_ind].x = old_positions[3 * myid];
    positions[node_ind].y = old_positions[3 * myid + 1];
    positions[node_ind].z = old_positions[3 * myid + 2];
    if ( !fineDensity && !first_add ) {
        density_server.Add ( positions[node_ind], fineDensity );
    } else if ( !fine_first_add ) {
        density_server.Add ( positions[node_ind], fineDensity );
    }

    // choose updated node position with lowest energy
    if ( energies[0] < energies[1] ) {
        new_positions[3 * myid] = updated_pos[0][0];
        new_positions[3 * myid + 1] = updated_pos[0][1];
        new_positions[3 * myid + 2] = updated_pos[0][2];
        positions[node_ind].energy = energies[0];
    } else {
        new_positions[3 * myid] = updated_pos[1][0];
        new_positions[3 * myid + 1] = updated_pos[1][1];
        new_positions[3 * myid + 2] = updated_pos[1][2];
        positions[node_ind].energy = energies[1];
    }

}

// update_density takes a sequence of node_indices and their positions and
// updates the positions by subtracting the old positions and adding the
// new positions to the density grid.

void graph::update_density ( vector &node_indices,
                             float old_positions[3 * MAX_PROCS],
                             float new_positions[3 * MAX_PROCS] ) {

    // go through each node and subtract old position from
    // density grid before adding new position
    for ( unsigned int i = 0; i < node_indices.size(); i++ ) {
        positions[node_indices[i]].x = old_positions[3 * i];
        positions[node_indices[i]].y = old_positions[3 * i + 1];
        positions[node_indices[i]].z = old_positions[3 * i + 2];
        density_server.Subtract ( positions[node_indices[i]],
                                  first_add, fine_first_add, fineDensity );

        positions[node_indices[i]].x = new_positions[3 * i];
        positions[node_indices[i]].y = new_positions[3 * i + 1];
        positions[node_indices[i]].z = new_positions[3 * i + 2];
        density_server.Add ( positions[node_indices[i]], fineDensity );
    }

}

/********************************************
* Function: Compute_Node_Energy             *
* Description: Compute the node energy      *
* This code has been modified from the      *
* original code by B. Wylie.                *
*********************************************/

float graph::Compute_Node_Energy( int node_ind ) {

    /* Want to expand 4th power range of attraction */
    float attraction_factor = attraction * attraction *
                              attraction * attraction * 2e-2;

    map ::iterator EI;
    float x_dis, y_dis, z_dis;
    float energy_distance, weight;
    float node_energy = 0;

    // Add up all connection energies
    for (EI = neighbors[node_ind].begin(); EI != neighbors[node_ind].end(); ++EI) {

        // Get edge weight
        weight = EI->second;

        // Compute x,y distance
        x_dis = positions[ node_ind ].x - positions[ EI->first ].x;
        y_dis = positions[ node_ind ].y - positions[ EI->first ].y;
        z_dis = positions[ node_ind ].z - positions[ EI->first ].z;

        // Energy Distance
        energy_distance = x_dis * x_dis + y_dis * y_dis + z_dis * z_dis;
        if (STAGE < 2) {
            energy_distance *= energy_distance;
        }

        // In the liquid phase we want to discourage long link distances
        if (STAGE == 0) {
            energy_distance *= energy_distance;
        }

        node_energy += weight * attraction_factor * energy_distance;
    }

    // output effect of density (debugging)
    //cout << "[before: " << node_energy;

    // add density
    node_energy += density_server.GetDensity ( positions[ node_ind ].x, positions[ node_ind ].y,
                   positions[ node_ind ].z, fineDensity );

    // after calling density server (debugging)
    //cout << ", after: " << node_energy << "]" << endl;

    // return computated energy
    return node_energy;
}


/*********************************************
* Function: Solve_Analytic                   *
* Description: Compute the node position     *
* This is a modified version of the function *
* originally written by B. Wylie             *
*********************************************/

void graph::Solve_Analytic( int node_ind, float &pos_x, float &pos_y,
                            float &pos_z) {

    map ::iterator EI;
    float total_weight = 0;
    float x_dis, y_dis, z_dis, x_cen = 0, y_cen = 0, z_cen = 0;
    float x = 0, y = 0, z = 0, dis;
    float damping, weight;

    // Sum up all connections
    for (EI = neighbors[node_ind].begin(); EI != neighbors[node_ind].end(); ++EI) {
        weight = EI->second;
        total_weight += weight;
        x +=  weight * positions[ EI->first ].x;
        y +=  weight * positions[ EI->first ].y;
        z +=  weight * positions[ EI->first ].z;
    }

    // Now set node position
    if (total_weight > 0) {

        // Compute centriod
        x_cen = x / total_weight;
        y_cen = y / total_weight;
        z_cen = z / total_weight;
        damping = 1.0 - damping_mult;
        pos_x = damping * positions[ node_ind ].x + (1.0 - damping) * x_cen;
        pos_y = damping * positions[ node_ind ].y + (1.0 - damping) * y_cen;
        pos_z = damping * positions[ node_ind ].z + (1.0 - damping) * z_cen;
    }

    // No cut edge flag (?)
    if (min_edges == 99) {
        return;
    }

    // Don't cut at end of scale
    if ( CUT_END >= 39500 ) {
        return;
    }

    float num_connections = (float)sqrt((float)neighbors[node_ind].size());
    float maxLength = 0;

    map::iterator maxIndex;

    // Go through nodes edges... cutting if necessary
    for (EI = maxIndex = neighbors[node_ind].begin();
         EI != neighbors[node_ind].end(); ++EI) {

        // Check for at least min edges
        if (neighbors[node_ind].size() < min_edges) {
            continue;
        }

        x_dis = x_cen - positions[ EI->first ].x;
        y_dis = y_cen - positions[ EI->first ].y;
        z_dis = z_cen - positions[ EI->first ].z;
        dis = x_dis * x_dis + y_dis * y_dis + z_dis * z_dis;
        dis *= num_connections;

        // Store maximum edge
        if (dis > maxLength) {
            maxLength = dis;
            maxIndex = EI;
        }
    }

    // If max length greater than cut_length then cut
    if (maxLength > cut_off_length) {
        neighbors[ node_ind ].erase( maxIndex );
    }

}


// get_tot_energy adds up the energy for each node to give an estimate of the
// quality of the minimization.

float graph::get_tot_energy ( ) {

    float my_tot_energy, tot_energy;
    my_tot_energy = 0;
    for ( int i = myid; i < num_nodes; i += num_procs ) {
        my_tot_energy += positions[i].energy;
    }

    //vector::iterator i;
    //for ( i = positions.begin(); i != positions.end(); i++ )
    //  tot_energy += i->energy;

#ifdef MUSE_MPI
    MPI_Reduce ( &my_tot_energy, &tot_energy, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD );
#else
    tot_energy = my_tot_energy;
#endif

    return tot_energy;

}


int graph::draw_graph(igraph_matrix_t *res) {
    int count_iter = 0;
    while (ReCompute()) {
        IGRAPH_ALLOW_INTERRUPTION();
        count_iter++;
    }
    long int n = positions.size();
    IGRAPH_CHECK(igraph_matrix_resize(res, n, 3));
    for (long int i = 0; i < n; i++) {
        MATRIX(*res, i, 0) = positions[i].x;
        MATRIX(*res, i, 1) = positions[i].y;
        MATRIX(*res, i, 2) = positions[i].z;
    }
    return 0;
}

} // namespace drl3d
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_graph_3d.h0000644000175100001710000001073100000000000025242 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// The graph class contains the methods necessary to draw the
// graph.  It calls on the density server class to obtain
// position and density information

#include "DensityGrid_3d.h"
#include "igraph_layout.h"

#include 
#include 
#include 

namespace drl3d {

// layout schedule information
struct layout_schedule {
    int iterations;
    float temperature;
    float attraction;
    float damping_mult;
    time_t time_elapsed;
};

class graph {

public:

    // Methods
    void init_parms ( int rand_seed, float edge_cut, float real_parm );
    void init_parms ( const igraph_layout_drl_options_t *options );
    int read_real ( const igraph_matrix_t *real_mat,
                    const igraph_vector_bool_t *fixed);
    int draw_graph (igraph_matrix_t *res);
    float get_tot_energy ( );

    // Con/Decon
    graph( const igraph_t *igraph,
           const igraph_layout_drl_options_t *options,
           const igraph_vector_t *weights);
    ~graph( ) { }

private:

    // Methods
    int ReCompute ( );
    void update_nodes ( );
    float Compute_Node_Energy ( int node_ind );
    void Solve_Analytic ( int node_ind, float &pos_x, float &pos_y, float &pos_z );
    void get_positions ( std::vector &node_indices, float return_positions[3 * MAX_PROCS] );
    void update_density ( std::vector &node_indices,
                          float old_positions[3 * MAX_PROCS],
                          float new_positions[3 * MAX_PROCS] );
    void update_node_pos ( int node_ind,
                           float old_positions[3 * MAX_PROCS],
                           float new_positions[3 * MAX_PROCS] );

    // MPI information
    int myid, num_procs;

    // graph decomposition information
    int num_nodes;                  // number of nodes in graph
    float highest_sim;              // highest sim for normalization
    std::map  id_catalog;      // id_catalog[file id] = internal id
    std::map  > neighbors;     // neighbors of nodes on this proc.

    // graph layout information
    std::vector positions;
    DensityGrid density_server;

    // original VxOrd information
    int STAGE, iterations;
    float temperature, attraction, damping_mult;
    float min_edges, CUT_END, cut_length_end, cut_off_length, cut_rate;
    bool first_add, fine_first_add, fineDensity;

    // scheduling variables
    layout_schedule liquid;
    layout_schedule expansion;
    layout_schedule cooldown;
    layout_schedule crunch;
    layout_schedule simmer;

    // timing statistics
    time_t start_time, stop_time;

    // online clustering information
    int real_iterations;    // number of iterations to hold .real input fixed
    int tot_iterations;
    int tot_expected_iterations; // for progress bar
    bool real_fixed;
};

} // namespace drl3d
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_layout.cpp0000644000175100001710000004071400000000000025427 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// Layout
//
// This program implements a parallel force directed graph drawing
// algorithm.  The algorithm used is based upon a random decomposition
// of the graph and simulated shared memory of node position and density.
// In this version, the simulated shared memory is spread among all processors
//
// The structure of the inputs and outputs of this code will be displayed
// if the program is called without parameters, or if an erroneous
// parameter is passed to the program.
//
// S. Martin
// 5/6/2005

// C++ library routines
#include 
#include 

using namespace std;

// layout routines and constants
#include "drl_layout.h"
#include "drl_parse.h"
#include "drl_graph.h"

// MPI
#ifdef MUSE_MPI
    #include 
#endif

using namespace drl;
#include "igraph_layout.h"
#include "igraph_random.h"
#include "igraph_interface.h"

#include "core/exceptions.h"

namespace drl {

// int main(int argc, char **argv) {


//   // initialize MPI
//   int myid, num_procs;

//   #ifdef MUSE_MPI
//     MPI_Init ( &argc, &argv );
//     MPI_Comm_size ( MPI_COMM_WORLD, &num_procs );
//     MPI_Comm_rank ( MPI_COMM_WORLD, &myid );
//   #else
//     myid = 0;
//  num_procs = 1;
//   #endif

//   // parameters that must be broadcast to all processors
//   int rand_seed;
//   float edge_cut;

//   char int_file[MAX_FILE_NAME];
//   char coord_file[MAX_FILE_NAME];
//   char real_file[MAX_FILE_NAME];
//   char parms_file[MAX_FILE_NAME];

//   int int_out = 0;
//   int edges_out = 0;
//   int parms_in = 0;
//   float real_in = -1.0;

//   // user interaction is handled by processor 0
//   if ( myid == 0 )
//   {
//     if ( num_procs > MAX_PROCS )
//  {
//      cout << "Error: Maximum number of processors is " << MAX_PROCS << "." << endl;
//      cout << "Adjust compile time parameter." << endl;
//      #ifdef MUSE_MPI
//        MPI_Abort ( MPI_COMM_WORLD, 1 );
//      #else
//        exit (1);
//      #endif
//  }

//  // get user input
//     parse command_line ( argc, argv );
//  rand_seed = command_line.rand_seed;
//  edge_cut = command_line.edge_cut;
//  int_out = command_line.int_out;
//  edges_out = command_line.edges_out;
//  parms_in = command_line.parms_in;
//  real_in = command_line.real_in;
//  strcpy ( coord_file, command_line.coord_file.c_str() );
//  strcpy ( int_file, command_line.sim_file.c_str() );
//  strcpy ( real_file, command_line.real_file.c_str() );
//  strcpy ( parms_file, command_line.parms_file.c_str() );

//   }

//   // now we initialize all processors by reading .int file
//   #ifdef MUSE_MPI
//     MPI_Bcast ( &int_file, MAX_FILE_NAME, MPI_CHAR, 0, MPI_COMM_WORLD );
//   #endif
//   graph neighbors ( myid, num_procs, int_file );

//   // check for user supplied parameters
//   #ifdef MUSE_MPI
//     MPI_Bcast ( &parms_in, 1, MPI_INT, 0, MPI_COMM_WORLD );
//   #endif
//   if ( parms_in )
//   {
//     #ifdef MUSE_MPI
//    MPI_Bcast ( &parms_file, MAX_FILE_NAME, MPI_CHAR, 0, MPI_COMM_WORLD );
//  #endif
//  neighbors.read_parms ( parms_file );
//   }

//   // set random seed, edge cutting, and real iterations parameters
//   #ifdef MUSE_MPI
//     MPI_Bcast ( &rand_seed, 1, MPI_INT, 0, MPI_COMM_WORLD );
//     MPI_Bcast ( &edge_cut, 1, MPI_FLOAT, 0, MPI_COMM_WORLD );
//  MPI_Bcast ( &real_in, 1, MPI_INT, 0, MPI_COMM_WORLD );
//   #endif
//   neighbors.init_parms ( rand_seed, edge_cut, real_in );

//   // check for .real file with existing coordinates
//   if ( real_in >= 0 )
//   {
//     #ifdef MUSE_MPI
//    MPI_Bcast ( &real_file, MAX_FILE_NAME, MPI_CHAR, 0, MPI_COMM_WORLD );
//  #endif
//  neighbors.read_real ( real_file );
//   }

//   neighbors.draw_graph ( int_out, coord_file );

//   // do we have to write out the edges?
//   #ifdef MUSE_MPI
//     MPI_Bcast ( &edges_out, 1, MPI_INT, 0, MPI_COMM_WORLD );
//   #endif
//   if ( edges_out )
//     {
//    #ifdef MUSE_MPI
//         MPI_Bcast ( &coord_file, MAX_FILE_NAME, MPI_CHAR, 0, MPI_COMM_WORLD );
//    #endif
//       for ( int i = 0; i < num_procs; i++ )
//    {
//      if ( myid == i )
//        neighbors.write_sim ( coord_file );
//      #ifdef MUSE_MPI
//            MPI_Barrier ( MPI_COMM_WORLD );
//      #endif
//    }
//     }

//   // finally we output file and quit
//   float tot_energy;
//   tot_energy = neighbors.get_tot_energy ();
//   if ( myid == 0 )
//   {
//  neighbors.write_coord ( coord_file );
//  cout << "Total Energy: " << tot_energy << "." << endl
//       << "Program terminated successfully." << endl;
//   }

//   // MPI finalize
//   #ifdef MUSE_MPI
//     MPI_Finalize ();
//   #endif

//   return 0;
// }

} // namespace drl

/**
 * \section about_drl
 *
 * 
 * DrL is a sophisticated layout generator developed and implemented by
 * Shawn Martin et al. As of October 2012 the original DrL homepage is
 * unfortunately not available. You can read more about this algorithm
 * in the following technical report: Martin, S., Brown, W.M.,
 * Klavans, R., Boyack, K.W., DrL: Distributed Recursive (Graph)
 * Layout. SAND Reports, 2008. 2936: p. 1-10.
 * 
 *
 * 
 * Only a subset of the complete DrL functionality is
 * included in igraph, parallel runs and recursive, multi-level
 * layouting is not supported.
 * 
 *
 * 
 * The parameters of the layout are stored in an \ref
 * igraph_layout_drl_options_t structure, this can be initialized by
 * calling the function \ref igraph_layout_drl_options_init().
 * The fields of this structure can then be adjusted by hand if needed.
 * The layout is calculated by an \ref igraph_layout_drl() call.
 * 
 */

/**
 * \function igraph_layout_drl_options_init
 * Initialize parameters for the DrL layout generator
 *
 * This function can be used to initialize the struct holding the
 * parameters for the DrL layout generator. There are a number of
 * predefined templates available, it is a good idea to start from one
 * of these by modifying some parameters.
 * \param options The struct to initialize.
 * \param templ The template to use. Currently the following templates
 *     are supplied: \c IGRAPH_LAYOUT_DRL_DEFAULT, \c
 *     IGRAPH_LAYOUT_DRL_COARSEN, \c IGRAPH_LAYOUT_DRL_COARSEST,
 *     \c IGRAPH_LAYOUT_DRL_REFINE and \c IGRAPH_LAYOUT_DRL_FINAL.
 * \return Error code.
 *
 * Time complexity: O(1).
 */

int igraph_layout_drl_options_init(igraph_layout_drl_options_t *options,
                                   igraph_layout_drl_default_t templ) {

    options->edge_cut = 32.0 / 40.0;

    switch (templ) {
    case IGRAPH_LAYOUT_DRL_DEFAULT:
        options->init_iterations   = 0;
        options->init_temperature  = 2000;
        options->init_attraction   = 10;
        options->init_damping_mult = 1.0;

        options->liquid_iterations   = 200;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 10;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 200;
        options->expansion_temperature  = 2000;
        options->expansion_attraction   = 2;
        options->expansion_damping_mult = 1.0;

        options->cooldown_iterations   = 200;
        options->cooldown_temperature  = 2000;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 50;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 100;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 0;

        break;
    case IGRAPH_LAYOUT_DRL_COARSEN:
        options->init_iterations   = 0;
        options->init_temperature  = 2000;
        options->init_attraction   = 10;
        options->init_damping_mult = 1.0;

        options->liquid_iterations   = 200;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 2;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 200;
        options->expansion_temperature  = 2000;
        options->expansion_attraction   = 10;
        options->expansion_damping_mult = 1.0;

        options->cooldown_iterations   = 200;
        options->cooldown_temperature  = 2000;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 50;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 100;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 0;

        break;
    case IGRAPH_LAYOUT_DRL_COARSEST:
        options->init_iterations   = 0;
        options->init_temperature  = 2000;
        options->init_attraction   = 10;
        options->init_damping_mult = 1.0;

        options->liquid_iterations   = 200;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 2;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 200;
        options->expansion_temperature  = 2000;
        options->expansion_attraction   = 10;
        options->expansion_damping_mult = 1.0;

        options->cooldown_iterations   = 200;
        options->cooldown_temperature  = 2000;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 200;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 100;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 0;

        break;
    case IGRAPH_LAYOUT_DRL_REFINE:
        options->init_iterations   = 0;
        options->init_temperature  = 50;
        options->init_attraction   = .5;
        options->init_damping_mult = 0;

        options->liquid_iterations   = 0;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 2;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 50;
        options->expansion_temperature  = 500;
        options->expansion_attraction   = .1;
        options->expansion_damping_mult = .25;

        options->cooldown_iterations   = 50;
        options->cooldown_temperature  = 200;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 50;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 0;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 0;

        break;
    case IGRAPH_LAYOUT_DRL_FINAL:
        options->init_iterations   = 0;
        options->init_temperature  = 50;
        options->init_attraction   = .5;
        options->init_damping_mult = 0;

        options->liquid_iterations   = 0;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 2;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 50;
        options->expansion_temperature  = 50;
        options->expansion_attraction   = .1;
        options->expansion_damping_mult = .25;

        options->cooldown_iterations   = 50;
        options->cooldown_temperature  = 200;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 50;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 25;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 0;

        break;
    default:
        IGRAPH_ERROR("Unknown DrL template", IGRAPH_EINVAL);
        break;
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_layout_drl
 * The DrL layout generator
 *
 * This function implements the force-directed DrL layout generator.
 * Please see more in the following technical report: Martin, S.,
 * Brown, W.M., Klavans, R., Boyack, K.W., DrL: Distributed Recursive
 * (Graph) Layout. SAND Reports, 2008. 2936: p. 1-10.
 * \param graph The input graph.
 * \param use_seed Logical scalar, if true, then the coordinates
 *    supplied in the \p res argument are used as starting points.
 * \param res Pointer to a matrix, the result layout is stored
 *    here. It will be resized as needed.
 * \param options The parameters to pass to the layout generator.
 * \param weights Edge weights, pointer to a vector. If this is a null
 *    pointer then every edge will have the same weight.
 * \param fixed Pointer to a logical vector, or a null pointer. Originally,
 *    this argument was used in the DrL algorithm to keep the nodes marked
 *    with this argument as fixed; fixed nodes would then keep their
 *    positions in the initial stages of the algorithm. However, due to how
 *    the DrL code imported into igraph is organized, it seems that the
 *    argument does not do anything and we are not sure whether this is a
 *    bug or a feature in DrL. We are leaving the argument here in order not
 *    to break the API, but note that at the present stage it has no effect.
 * \return Error code.
 *
 * Time complexity: ???.
 */

int igraph_layout_drl(const igraph_t *graph, igraph_matrix_t *res,
                      igraph_bool_t use_seed,
                      const igraph_layout_drl_options_t *options,
                      const igraph_vector_t *weights,
                      const igraph_vector_bool_t *fixed) {
    const char msg[] = "Damping multipliers cannot be negative, got %f.";

    if (options->init_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->init_damping_mult);
    }
    if (options->liquid_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->liquid_damping_mult);
    }
    if (options->expansion_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->expansion_damping_mult);
    }
    if (options->cooldown_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->cooldown_damping_mult);
    }
    if (options->crunch_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->crunch_damping_mult);
    }
    if (options->simmer_damping_mult < 0) {
        IGRAPH_ERRORF(msg, IGRAPH_EINVAL, options->simmer_damping_mult);
    }

    IGRAPH_HANDLE_EXCEPTIONS(
        RNG_BEGIN();

        drl::graph neighbors(graph, options, weights);
        neighbors.init_parms(options);
        if (use_seed) {
            IGRAPH_CHECK(igraph_matrix_resize(res, igraph_vcount(graph), 2));
            neighbors.read_real(res, fixed);
        }
        neighbors.draw_graph(res);

        RNG_END();
    );

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_layout.h0000644000175100001710000000564200000000000025075 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains compile time parameters which affect the entire
// DrL program.

#define DRL_VERSION "3.2 5/5/2006"

// compile time parameters for MPI message passing
#define MAX_PROCS 256      // maximum number of processors
#define MAX_FILE_NAME 250   // max length of filename
#define MAX_INT_LENGTH 4   // max length of integer suffix of intermediate .coord file

// Compile time adjustable parameters for the Density grid

#define GRID_SIZE 1000          // size of Density grid
#define VIEW_SIZE 4000.0        // actual physical size of layout plane
// these values use more memory but have
// little effect on performance or layout

#define RADIUS 10               // radius for density fall-off:
// larger values tends to slow down
// the program and clump the data

#define HALF_VIEW 2000          // 1/2 of VIEW_SIZE
#define VIEW_TO_GRID .25        // ratio of GRID_SIZE to VIEW_SIZE

/*
// original values for VxOrd
#define GRID_SIZE 400           // size of VxOrd Density grid
#define VIEW_SIZE 1600.0        // actual physical size of VxOrd plane
#define RADIUS 10               // radius for density fall-off

#define HALF_VIEW 800           // 1/2 of VIEW_SIZE
#define VIEW_TO_GRID .25        // ratio of GRID_SIZE to VIEW_SIZE
*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_layout_3d.cpp0000644000175100001710000001106200000000000026007 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// Layout
//
// This program implements a parallel force directed graph drawing
// algorithm.  The algorithm used is based upon a random decomposition
// of the graph and simulated shared memory of node position and density.
// In this version, the simulated shared memory is spread among all processors
//
// The structure of the inputs and outputs of this code will be displayed
// if the program is called without parameters, or if an erroneous
// parameter is passed to the program.
//
// S. Martin
// 5/6/2005

// C++ library routines
#include 
#include 

using namespace std;

// layout routines and constants
#include "drl_layout_3d.h"
#include "drl_parse.h"
#include "drl_graph_3d.h"

// MPI
#ifdef MUSE_MPI
    #include 
#endif

using namespace drl3d;
#include "igraph_layout.h"
#include "igraph_random.h"
#include "igraph_interface.h"

#include "core/exceptions.h"

/**
 * \function igraph_layout_drl_3d
 * The DrL layout generator, 3d version.
 *
 * This function implements the force-directed DrL layout generator.
 * Please see more in the technical report: Martin, S., Brown, W.M.,
 * Klavans, R., Boyack, K.W., DrL: Distributed Recursive (Graph)
 * Layout. SAND Reports, 2008. 2936: p. 1-10.
 *
 *  This function uses a modified DrL generator that does
 * the layout in three dimensions.
 * \param graph The input graph.
 * \param use_seed Logical scalar, if true, then the coordinates
 *    supplied in the \p res argument are used as starting points.
 * \param res Pointer to a matrix, the result layout is stored
 *    here. It will be resized as needed.
 * \param options The parameters to pass to the layout generator.
 * \param weights Edge weights, pointer to a vector. If this is a null
 *    pointer then every edge will have the same weight.
 * \param fixed Pointer to a logical vector, or a null pointer. This
 *    can be used to fix the position of some vertices. Vertices for
 *    which it is true will not be moved, but stay at the coordinates
 *    given in the \p res matrix. This argument is ignored if it is a
 *    null pointer or if use_seed is false.
 * \return Error code.
 *
 * Time complexity: ???.
 *
 * \sa \ref igraph_layout_drl() for the standard 2d version.
 */

int igraph_layout_drl_3d(const igraph_t *graph, igraph_matrix_t *res,
                         igraph_bool_t use_seed,
                         const igraph_layout_drl_options_t *options,
                         const igraph_vector_t *weights,
                         const igraph_vector_bool_t *fixed) {
    IGRAPH_HANDLE_EXCEPTIONS(
        RNG_BEGIN();

        drl3d::graph neighbors(graph, options, weights);
        neighbors.init_parms(options);
        if (use_seed) {
            IGRAPH_CHECK(igraph_matrix_resize(res, igraph_vcount(graph), 3));
            neighbors.read_real(res, fixed);
        }
        neighbors.draw_graph(res);

        RNG_END();
    );

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_layout_3d.h0000644000175100001710000000563600000000000025466 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains compile time parameters which affect the entire
// DrL program.

#define DRL_VERSION "3.2 5/5/2006"

// compile time parameters for MPI message passing
#define MAX_PROCS 256      // maximum number of processors
#define MAX_FILE_NAME 250   // max length of filename
#define MAX_INT_LENGTH 4   // max length of integer suffix of intermediate .coord file

// Compile time adjustable parameters for the Density grid

#define GRID_SIZE 100           // size of Density grid
#define VIEW_SIZE 250.0     // actual physical size of layout plane
// these values use more memory but have
// little effect on performance or layout

#define RADIUS 10               // radius for density fall-off:
// larger values tends to slow down
// the program and clump the data

#define HALF_VIEW 125.0         // 1/2 of VIEW_SIZE
#define VIEW_TO_GRID .4         // ratio of GRID_SIZE to VIEW_SIZE

/*
// original values for VxOrd
#define GRID_SIZE 400           // size of VxOrd Density grid
#define VIEW_SIZE 1600.0        // actual physical size of VxOrd plane
#define RADIUS 10               // radius for density fall-off

#define HALF_VIEW 800           // 1/2 of VIEW_SIZE
#define VIEW_TO_GRID .25        // ratio of GRID_SIZE to VIEW_SIZE
*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_parse.cpp0000644000175100001710000001627200000000000025226 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// This file contains the methods for the parse.h class

#include "drl_layout.h"
#include "drl_parse.h"

namespace drl {

// void parse::print_syntax( const char *error_string )
// {
//   cout << endl << "Error: " << error_string << endl;
//   cout << endl << "Layout" << endl
//     <<     "------" << endl
//     << "S. Martin" << endl
//     << "Version " << DRL_VERSION << endl << endl
//     << "This program provides a parallel adaptation of a force directed" << endl
//     << "graph layout algorithm for use with large datasets." << endl << endl
//     << "Usage: layout [options] root_file" << endl << endl
//     << "root_file -- the root name of the file being processed." << endl << endl
//     << "INPUT" << endl
//     << "-----" << endl
//     << "root_file.int -- the input file containing the graph to draw using layout." << endl
//     << "  The .int file must have the suffix \".int\" and each line of .int file" << endl
//     << "  should have the form" << endl
//     << "\tnode_id  node_id  weight" << endl
//     << "  where node_id's are integers in sequence starting from 0, and" << endl
//     << "  weight is a float > 0." << endl << endl
//     << "OUTPUT" << endl
//     << "------" << endl
//     << "root_file.icoord -- the resulting output file, containing an ordination" << endl
//     << "  of the graph.  The .icoord file will have the suffix \".icoord\" and" << endl
//     << "  each line of the .icoord file will be of the form" << endl
//     << "\tnode_id  x-coord  y-coord" << endl << endl
//     << "Options:" << endl << endl
//     << "\t-s {int>=0} random seed (default value is 0)" << endl
//     << "\t-c {real[0,1]} edge cutting (default 32/40 = .8)" << endl
//     << "\t   (old max was 39/40 = .975)" << endl
//     << "\t-p input parameters from .parms file" << endl
//     << "\t-r {real[0,1]} input coordinates from .real file" << endl
//     << "\t   (hold fixed until fraction of optimization schedule reached)" << endl
//     << "\t-i {int>=0} intermediate output interval (default 0: no output)" << endl
//     << "\t-e output .iedges file (same prefix as .coord file)" << endl << endl;

//   #ifdef MUSE_MPI
//     MPI_Abort ( MPI_COMM_WORLD, 1 );
//   #else
//     exit (1);
//   #endif
// }

// parse::parse ( int argc, char** argv)
// {
//   map m;

//   // make sure there is at least one argument
//   if ( argc < 2)
//  print_syntax ( "not enough arguments!" );

//   // make sure coord_file ends in ".coord"
//   parms_file = real_file = sim_file = coord_file = argv[argc-1];
//   parms_file = parms_file + ".parms";
//   real_file = real_file + ".real";
//   sim_file = sim_file + ".int";
//   coord_file = coord_file + ".icoord";

//   char error_string[200];
//   sprintf ( error_string, "%s %d %s", "root file name cannot be longer than", MAX_FILE_NAME-7,
//                 "characters.");
//   if ( coord_file.length() > MAX_FILE_NAME )
//  print_syntax ( error_string );

//   // echo sim_file and coord_file
//   cout << "Using " << sim_file << " for .int file, and " << coord_file << " for .icoord file." << endl;

//   // set defaults
//   rand_seed = 0;
//   //edge_cut = 32.0/39.0; // (old default)
//   edge_cut = 32.0/40.0;
//   int_out = 0;
//   edges_out = 0;
//   parms_in = 0;
//   real_in = -1.0;

//   // now check for optional arguments
//   string arg;
//   for( int i = 1; i= (argc-1) )
//          print_syntax ( "-s flag has no argument." );
//      else
//      {
//          rand_seed = atoi ( argv[i] );
//          if ( rand_seed < 0 )
//              print_syntax ( "random seed must be >= 0." );
//      }
//  }
//  // check for edge cutting
//  else if ( arg == "-c" )
//  {
//      i++;
//      if ( i >= (argc-1) )
//          print_syntax ( "-c flag has no argument." );
//      else
//      {
//          edge_cut = atof ( argv[i] );
//          if ( (edge_cut < 0) || (edge_cut > 1) )
//              print_syntax ( "edge cut must be between 0 and 1." );
//      }
//  }
//  // check for intermediate output
//  else if ( arg == "-i" )
//  {
//      i++;
//      if ( i >= (argc-1) )
//          print_syntax ( "-i flag has no argument." );
//      else
//      {
//          int_out = atoi ( argv[i] );
//          if ( int_out < 0 )
//              print_syntax ( "intermediate output must be >= 0." );
//      }
//  }
//  // check for .real input
//  else if ( arg == "-r" )
//  {
//      i++;
//      if ( i >= (argc-1) )
//          print_syntax ( "-r flag has no argument." );
//      else
//      {
//          real_in = atof ( argv[i] );
//          if ( (real_in < 0) || (real_in > 1) )
//              print_syntax ( "real iteration fraction must be from 0 to 1." );
//      }
//  }
//  else if ( arg == "-e" )
//      edges_out = 1;
//  else if ( arg == "-p" )
//      parms_in = 1;
//  else
//      print_syntax ( "unrecongized option!" );
//   }

//   if ( parms_in )
//     cout << "Using " << parms_file << " for .parms file." << endl;

//   if ( real_in >= 0 )
//     cout << "Using " << real_file << " for .real file." << endl;

//   // echo arguments input or default
//   cout << "Using random seed = " << rand_seed << endl
//        << "      edge_cutting = " << edge_cut << endl
//        << "      intermediate output = " << int_out << endl
//        << "      output .iedges file = " << edges_out << endl;
//   if ( real_in >= 0 )
//  cout << "      holding .real fixed until iterations = " << real_in << endl;

// }

} // namespace drl
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/drl/drl_parse.h0000644000175100001710000000517100000000000024667 0ustar00runnerdocker00000000000000/*
 * Copyright 2007 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *     * Neither the name of Sandia National Laboratories nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
// The parse class contains the methods necessary to parse
// the command line, print help, and do error checking

#ifdef MUSE_MPI
    #include 
#endif

#include 

namespace drl {

class parse {

public:

    // Methods

    parse ( int argc, char **argv );
    ~parse () {}

    // user parameters
    std::string sim_file;        // .sim file
    std::string coord_file;      // .coord file
    std::string parms_file;      // .parms file
    std::string real_file;       // .real file

    int rand_seed;      // random seed int >= 0
    float edge_cut;         // edge cutting real [0,1]
    int int_out;            // intermediate output, int >= 1
    int edges_out;                  // true if .edges file is requested
    int parms_in;           // true if .parms file is to be read
    float real_in;          // true if .real file is to be read

private:

    void print_syntax ( const char *error_string );

};

} // namespace drl
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/fruchterman_reingold.c0000644000175100001710000006772000000000000026337 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_random.h"
#include "igraph_interface.h"
#include "igraph_components.h"

#include "core/grid.h"
#include "core/interruption.h"

static int igraph_layout_i_fr(const igraph_t *graph,
                              igraph_matrix_t *res,
                              igraph_bool_t use_seed,
                              igraph_integer_t niter,
                              igraph_real_t start_temp,
                              const igraph_vector_t *weight,
                              const igraph_vector_t *minx,
                              const igraph_vector_t *maxx,
                              const igraph_vector_t *miny,
                              const igraph_vector_t *maxy) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    igraph_integer_t i;
    igraph_vector_float_t dispx, dispy;
    igraph_real_t temp = start_temp;
    igraph_real_t difftemp = start_temp / niter;
    float width = sqrtf(no_nodes), height = width;
    igraph_bool_t conn = 1;
    float C = 0;

    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
    if (!conn) {
        C = no_nodes * sqrtf(no_nodes);
    }

    RNG_BEGIN();

    if (!use_seed) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 2));
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t x1 = minx ? VECTOR(*minx)[i] : -width / 2;
            igraph_real_t x2 = maxx ? VECTOR(*maxx)[i] :  width / 2;
            igraph_real_t y1 = miny ? VECTOR(*miny)[i] : -height / 2;
            igraph_real_t y2 = maxy ? VECTOR(*maxy)[i] :  height / 2;
            if (!igraph_finite(x1)) {
                x1 = -sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(x2)) {
                x2 =  sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(y1)) {
                y1 = -sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(y2)) {
                y2 =  sqrt(no_nodes) / 2;
            }
            MATRIX(*res, i, 0) = RNG_UNIF(x1, x2);
            MATRIX(*res, i, 1) = RNG_UNIF(y1, y2);
        }
    }

    IGRAPH_CHECK(igraph_vector_float_init(&dispx, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispx);
    IGRAPH_CHECK(igraph_vector_float_init(&dispy, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispy);

    for (i = 0; i < niter; i++) {
        igraph_integer_t v, u, e;

        IGRAPH_ALLOW_INTERRUPTION();

        /* calculate repulsive forces, we have a special version
           for unconnected graphs */
        igraph_vector_float_null(&dispx);
        igraph_vector_float_null(&dispy);
        if (conn) {
            for (v = 0; v < no_nodes; v++) {
                for (u = v + 1; u < no_nodes; u++) {
                    float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
                    float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
                    float dlen = dx * dx + dy * dy;

                    if (dlen == 0) {
                        dx = RNG_UNIF01() * 1e-9;
                        dy = RNG_UNIF01() * 1e-9;
                        dlen = dx * dx + dy * dy;
                    }

                    VECTOR(dispx)[v] += dx / dlen;
                    VECTOR(dispy)[v] += dy / dlen;
                    VECTOR(dispx)[u] -= dx / dlen;
                    VECTOR(dispy)[u] -= dy / dlen;
                }
            }
        } else {
            for (v = 0; v < no_nodes; v++) {
                for (u = v + 1; u < no_nodes; u++) {
                    float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
                    float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
                    float dlen, rdlen;

                    dlen = dx * dx + dy * dy;
                    if (dlen == 0) {
                        dx = RNG_UNIF(0, 1e-6);
                        dy = RNG_UNIF(0, 1e-6);
                        dlen = dx * dx + dy * dy;
                    }

                    rdlen = sqrt(dlen);

                    VECTOR(dispx)[v] += dx * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispy)[v] += dy * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispx)[u] -= dx * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispy)[u] -= dy * (C - dlen * rdlen) / (dlen * C);
                }
            }
        }

        /* calculate attractive forces */
        for (e = 0; e < no_edges; e++) {
            /* each edges is an ordered pair of vertices v and u */
            igraph_integer_t v = IGRAPH_FROM(graph, e);
            igraph_integer_t u = IGRAPH_TO(graph, e);
            igraph_real_t dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
            igraph_real_t dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
            igraph_real_t w = weight ? VECTOR(*weight)[e] : 1.0;
            igraph_real_t dlen = sqrt(dx * dx + dy * dy) * w;
            VECTOR(dispx)[v] -= (dx * dlen);
            VECTOR(dispy)[v] -= (dy * dlen);
            VECTOR(dispx)[u] += (dx * dlen);
            VECTOR(dispy)[u] += (dy * dlen);
        }

        /* limit max displacement to temperature t and prevent from
           displacement outside frame */
        for (v = 0; v < no_nodes; v++) {
            igraph_real_t dx = VECTOR(dispx)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t dy = VECTOR(dispy)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t displen = sqrt(dx * dx + dy * dy);
            igraph_real_t mx = fabs(dx) < temp ? dx : temp;
            igraph_real_t my = fabs(dy) < temp ? dy : temp;
            if (displen > 0) {
                MATRIX(*res, v, 0) += (dx / displen) * mx;
                MATRIX(*res, v, 1) += (dy / displen) * my;
            }
            if (minx && MATRIX(*res, v, 0) < VECTOR(*minx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*minx)[v];
            }
            if (maxx && MATRIX(*res, v, 0) > VECTOR(*maxx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*maxx)[v];
            }
            if (miny && MATRIX(*res, v, 1) < VECTOR(*miny)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*miny)[v];
            }
            if (maxy && MATRIX(*res, v, 1) > VECTOR(*maxy)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*maxy)[v];
            }
        }

        temp -= difftemp;
    }

    RNG_END();

    igraph_vector_float_destroy(&dispx);
    igraph_vector_float_destroy(&dispy);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_layout_i_grid_fr(
        const igraph_t *graph,
        igraph_matrix_t *res, igraph_bool_t use_seed,
        igraph_integer_t niter, igraph_real_t start_temp,
        const igraph_vector_t *weight, const igraph_vector_t *minx,
        const igraph_vector_t *maxx, const igraph_vector_t *miny,
        const igraph_vector_t *maxy) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    float width = sqrtf(no_nodes), height = width;
    igraph_2dgrid_t grid;
    igraph_vector_float_t dispx, dispy;
    igraph_real_t temp = start_temp;
    igraph_real_t difftemp = start_temp / niter;
    igraph_2dgrid_iterator_t vidit;
    igraph_integer_t i;
    const float cellsize = 2.0;

    RNG_BEGIN();

    if (!use_seed) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 2));
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t x1 = minx ? VECTOR(*minx)[i] : -width / 2;
            igraph_real_t x2 = maxx ? VECTOR(*maxx)[i] :  width / 2;
            igraph_real_t y1 = miny ? VECTOR(*miny)[i] : -height / 2;
            igraph_real_t y2 = maxy ? VECTOR(*maxy)[i] :  height / 2;
            if (!igraph_finite(x1)) {
                x1 = -sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(x2)) {
                x2 =  sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(y1)) {
                y1 = -sqrt(no_nodes) / 2;
            }
            if (!igraph_finite(y2)) {
                y2 =  sqrt(no_nodes) / 2;
            }
            MATRIX(*res, i, 0) = RNG_UNIF(x1, x2);
            MATRIX(*res, i, 1) = RNG_UNIF(y1, y2);
        }
    }

    /* make grid */
    IGRAPH_CHECK(igraph_2dgrid_init(&grid, res, -width / 2, width / 2, cellsize,
                                    -height / 2, height / 2, cellsize));
    IGRAPH_FINALLY(igraph_2dgrid_destroy, &grid);

    /* place vertices on grid */
    for (i = 0; i < no_nodes; i++) {
        igraph_2dgrid_add2(&grid, i);
    }

    IGRAPH_CHECK(igraph_vector_float_init(&dispx, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispx);
    IGRAPH_CHECK(igraph_vector_float_init(&dispy, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispy);

    for (i = 0; i < niter; i++) {
        igraph_integer_t v, u, e;

        IGRAPH_ALLOW_INTERRUPTION();

        igraph_vector_float_null(&dispx);
        igraph_vector_float_null(&dispy);

        /* repulsion */
        igraph_2dgrid_reset(&grid, &vidit);
        while ( (v = igraph_2dgrid_next(&grid, &vidit) - 1) != -1) {
            while ( (u = igraph_2dgrid_next_nei(&grid, &vidit) - 1) != -1) {
                float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
                float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
                float dlen = dx * dx + dy * dy;
                if (dlen < cellsize * cellsize) {
                    VECTOR(dispx)[v] += dx / dlen;
                    VECTOR(dispy)[v] += dy / dlen;
                    VECTOR(dispx)[u] -= dx / dlen;
                    VECTOR(dispy)[u] -= dy / dlen;
                }
            }
        }

        /* attraction */
        for (e = 0; e < no_edges; e++) {
            igraph_integer_t v = IGRAPH_FROM(graph, e);
            igraph_integer_t u = IGRAPH_TO(graph, e);
            igraph_real_t dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
            igraph_real_t dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
            igraph_real_t w = weight ? VECTOR(*weight)[e] : 1.0;
            igraph_real_t dlen = sqrt(dx * dx + dy * dy) * w;
            VECTOR(dispx)[v] -= (dx * dlen);
            VECTOR(dispy)[v] -= (dy * dlen);
            VECTOR(dispx)[u] += (dx * dlen);
            VECTOR(dispy)[u] += (dy * dlen);
        }

        /* update */
        for (v = 0; v < no_nodes; v++) {
            igraph_real_t dx = VECTOR(dispx)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t dy = VECTOR(dispy)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t displen = sqrt(dx * dx + dy * dy);
            igraph_real_t mx = fabs(dx) < temp ? dx : temp;
            igraph_real_t my = fabs(dy) < temp ? dy : temp;
            if (displen > 0) {
                MATRIX(*res, v, 0) += (dx / displen) * mx;
                MATRIX(*res, v, 1) += (dy / displen) * my;
            }
            if (minx && MATRIX(*res, v, 0) < VECTOR(*minx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*minx)[v];
            }
            if (maxx && MATRIX(*res, v, 0) > VECTOR(*maxx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*maxx)[v];
            }
            if (miny && MATRIX(*res, v, 1) < VECTOR(*miny)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*miny)[v];
            }
            if (maxy && MATRIX(*res, v, 1) > VECTOR(*maxy)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*maxy)[v];
            }
        }

        temp -= difftemp;
    }

    igraph_vector_float_destroy(&dispx);
    igraph_vector_float_destroy(&dispy);
    igraph_2dgrid_destroy(&grid);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

/**
 * \ingroup layout
 * \function igraph_layout_fruchterman_reingold
 * \brief Places the vertices on a plane according to the Fruchterman-Reingold algorithm.
 *
 * 
 * This is a force-directed layout, see Fruchterman, T.M.J. and
 * Reingold, E.M.: Graph Drawing by Force-directed Placement.
 * Software -- Practice and Experience, 21/11, 1129--1164,
 * 1991.
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param use_seed Logical, if true the supplied values in the
 *        \p res argument are used as an initial layout, if
 *        false a random initial layout is used.
 * \param niter The number of iterations to do. A reasonable
 *        default value is 500.
 * \param start_temp Start temperature. This is the maximum amount
 *        of movement allowed along one axis, within one step, for a
 *        vertex. Currently it is decreased linearly to zero during
 *        the iteration.
 * \param grid Whether to use the (fast but less accurate) grid based
 *        version of the algorithm. Possible values: \c
 *        IGRAPH_LAYOUT_GRID, \c IGRAPH_LAYOUT_NOGRID, \c
 *        IGRAPH_LAYOUT_AUTOGRID. The last one uses the grid based
 *        version only for large graphs, currently the ones with
 *        more than 1000 vertices.
 * \param weight Pointer to a vector containing edge weights,
 *        the attraction along the edges will be multiplied by these.
 *        It will be ignored if it is a null-pointer.
 * \param minx Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote x \endquote coordinate for every vertex.
 * \param maxx Same as \p minx, but the maximum \quote x \endquote
 *        coordinates.
 * \param miny Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote y \endquote coordinate for every vertex.
 * \param maxy Same as \p miny, but the maximum \quote y \endquote
 *        coordinates.
 * \return Error code.
 *
 * Time complexity: O(|V|^2) in each
 * iteration, |V| is the number of
 * vertices in the graph.
 */

int igraph_layout_fruchterman_reingold(const igraph_t *graph,
                                       igraph_matrix_t *res,
                                       igraph_bool_t use_seed,
                                       igraph_integer_t niter,
                                       igraph_real_t start_temp,
                                       igraph_layout_grid_t grid,
                                       const igraph_vector_t *weight,
                                       const igraph_vector_t *minx,
                                       const igraph_vector_t *maxx,
                                       const igraph_vector_t *miny,
                                       const igraph_vector_t *maxy) {

    igraph_integer_t no_nodes = igraph_vcount(graph);

    if (niter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negative in "
                     "Fruchterman-Reingold layout.", IGRAPH_EINVAL);
    }

    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 2)) {
        IGRAPH_ERROR("Invalid start position matrix size in "
                     "Fruchterman-Reingold layout.", IGRAPH_EINVAL);
    }

    if (weight && igraph_vector_size(weight) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length.", IGRAPH_EINVAL);
    }

    if (minx && igraph_vector_size(minx) != no_nodes) {
        IGRAPH_ERROR("Invalid minx vector length.", IGRAPH_EINVAL);
    }
    if (maxx && igraph_vector_size(maxx) != no_nodes) {
        IGRAPH_ERROR("Invalid maxx vector length.", IGRAPH_EINVAL);
    }
    if (minx && maxx && !igraph_vector_all_le(minx, maxx)) {
        IGRAPH_ERROR("minx must not be greater than maxx.", IGRAPH_EINVAL);
    }
    if (miny && igraph_vector_size(miny) != no_nodes) {
        IGRAPH_ERROR("Invalid miny vector length.", IGRAPH_EINVAL);
    }
    if (maxy && igraph_vector_size(maxy) != no_nodes) {
        IGRAPH_ERROR("Invalid maxy vector length.", IGRAPH_EINVAL);
    }
    if (miny && maxy && !igraph_vector_all_le(miny, maxy)) {
        IGRAPH_ERROR("miny must not be greater than maxy.", IGRAPH_EINVAL);
    }

    if (grid == IGRAPH_LAYOUT_AUTOGRID) {
        if (no_nodes > 1000) {
            grid = IGRAPH_LAYOUT_GRID;
        } else {
            grid = IGRAPH_LAYOUT_NOGRID;
        }
    }

    if (grid == IGRAPH_LAYOUT_GRID) {
        return igraph_layout_i_grid_fr(graph, res, use_seed, niter, start_temp,
                                       weight, minx, maxx, miny, maxy);
    } else {
        return igraph_layout_i_fr(graph, res, use_seed, niter, start_temp,
                                  weight, minx, maxx, miny, maxy);
    }
}

/**
 * \function igraph_layout_fruchterman_reingold_3d
 * \brief 3D Fruchterman-Reingold algorithm.
 *
 * This is the 3D version of the force based
 * Fruchterman-Reingold layout (see \ref
 * igraph_layout_fruchterman_reingold for the 2D version
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param use_seed Logical, if true the supplied values in the
 *        \p res argument are used as an initial layout, if
 *        false a random initial layout is used.
 * \param niter The number of iterations to do. A reasonable
 *        default value is 500.
 * \param start_temp Start temperature. This is the maximum amount
 *        of movement alloved along one axis, within one step, for a
 *        vertex. Currently it is decreased linearly to zero during
 *        the iteration.
 * \param weight Pointer to a vector containing edge weights,
 *        the attraction along the edges will be multiplied by these.
 *        It will be ignored if it is a null-pointer.
 * \param minx Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote x \endquote coordinate for every vertex.
 * \param maxx Same as \p minx, but the maximum \quote x \endquote
 *        coordinates.
 * \param miny Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote y \endquote coordinate for every vertex.
 * \param maxy Same as \p miny, but the maximum \quote y \endquote
 *        coordinates.
 * \param minz Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote z \endquote coordinate for every vertex.
 * \param maxz Same as \p minz, but the maximum \quote z \endquote
 *        coordinates.
 * \return Error code.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|^2) in each
 * iteration, |V| is the number of
 * vertices in the graph.
 *
 */

int igraph_layout_fruchterman_reingold_3d(const igraph_t *graph,
        igraph_matrix_t *res,
        igraph_bool_t use_seed,
        igraph_integer_t niter,
        igraph_real_t start_temp,
        const igraph_vector_t *weight,
        const igraph_vector_t *minx,
        const igraph_vector_t *maxx,
        const igraph_vector_t *miny,
        const igraph_vector_t *maxy,
        const igraph_vector_t *minz,
        const igraph_vector_t *maxz) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    igraph_integer_t i;
    igraph_vector_float_t dispx, dispy, dispz;
    igraph_real_t temp = start_temp;
    igraph_real_t difftemp = start_temp / niter;
    float width = sqrtf(no_nodes), height = width, depth = width;
    igraph_bool_t conn = 1;
    float C = 0;

    if (niter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negative in "
                     "Fruchterman-Reingold layout", IGRAPH_EINVAL);
    }

    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 3)) {
        IGRAPH_ERROR("Invalid start position matrix size in "
                     "Fruchterman-Reingold layout", IGRAPH_EINVAL);
    }

    if (weight && igraph_vector_size(weight) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    if (minx && igraph_vector_size(minx) != no_nodes) {
        IGRAPH_ERROR("Invalid minx vector length", IGRAPH_EINVAL);
    }
    if (maxx && igraph_vector_size(maxx) != no_nodes) {
        IGRAPH_ERROR("Invalid maxx vector length", IGRAPH_EINVAL);
    }
    if (minx && maxx && !igraph_vector_all_le(minx, maxx)) {
        IGRAPH_ERROR("minx must not be greater than maxx", IGRAPH_EINVAL);
    }
    if (miny && igraph_vector_size(miny) != no_nodes) {
        IGRAPH_ERROR("Invalid miny vector length", IGRAPH_EINVAL);
    }
    if (maxy && igraph_vector_size(maxy) != no_nodes) {
        IGRAPH_ERROR("Invalid maxy vector length", IGRAPH_EINVAL);
    }
    if (miny && maxy && !igraph_vector_all_le(miny, maxy)) {
        IGRAPH_ERROR("miny must not be greater than maxy", IGRAPH_EINVAL);
    }
    if (minz && igraph_vector_size(minz) != no_nodes) {
        IGRAPH_ERROR("Invalid minz vector length", IGRAPH_EINVAL);
    }
    if (maxz && igraph_vector_size(maxz) != no_nodes) {
        IGRAPH_ERROR("Invalid maxz vector length", IGRAPH_EINVAL);
    }
    if (minz && maxz && !igraph_vector_all_le(minz, maxz)) {
        IGRAPH_ERROR("minz must not be greater than maxz", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
    if (!conn) {
        C = no_nodes * sqrtf(no_nodes);
    }

    RNG_BEGIN();

    if (!use_seed) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 3));
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t x1 = minx ? VECTOR(*minx)[i] : -width / 2;
            igraph_real_t x2 = maxx ? VECTOR(*maxx)[i] :  width / 2;
            igraph_real_t y1 = miny ? VECTOR(*miny)[i] : -height / 2;
            igraph_real_t y2 = maxy ? VECTOR(*maxy)[i] :  height / 2;
            igraph_real_t z1 = minz ? VECTOR(*minz)[i] : -depth / 2;
            igraph_real_t z2 = maxz ? VECTOR(*maxz)[i] :  depth / 2;
            MATRIX(*res, i, 0) = RNG_UNIF(x1, x2);
            MATRIX(*res, i, 1) = RNG_UNIF(y1, y2);
            MATRIX(*res, i, 2) = RNG_UNIF(z1, z2);
        }
    }

    IGRAPH_CHECK(igraph_vector_float_init(&dispx, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispx);
    IGRAPH_CHECK(igraph_vector_float_init(&dispy, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispy);
    IGRAPH_CHECK(igraph_vector_float_init(&dispz, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &dispz);

    for (i = 0; i < niter; i++) {
        igraph_integer_t v, u, e;

        IGRAPH_ALLOW_INTERRUPTION();

        /* calculate repulsive forces, we have a special version
           for unconnected graphs */
        igraph_vector_float_null(&dispx);
        igraph_vector_float_null(&dispy);
        igraph_vector_float_null(&dispz);
        if (conn) {
            for (v = 0; v < no_nodes; v++) {
                for (u = v + 1; u < no_nodes; u++) {
                    float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
                    float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
                    float dz = MATRIX(*res, v, 2) - MATRIX(*res, u, 2);
                    float dlen = dx * dx + dy * dy + dz * dz;

                    if (dlen == 0) {
                        dx = RNG_UNIF01() * 1e-9;
                        dy = RNG_UNIF01() * 1e-9;
                        dz = RNG_UNIF01() * 1e-9;
                        dlen = dx * dx + dy * dy + dz * dz;
                    }

                    VECTOR(dispx)[v] += dx / dlen;
                    VECTOR(dispy)[v] += dy / dlen;
                    VECTOR(dispz)[v] += dz / dlen;
                    VECTOR(dispx)[u] -= dx / dlen;
                    VECTOR(dispy)[u] -= dy / dlen;
                    VECTOR(dispz)[u] -= dz / dlen;
                }
            }
        } else {
            for (v = 0; v < no_nodes; v++) {
                for (u = v + 1; u < no_nodes; u++) {
                    float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
                    float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
                    float dz = MATRIX(*res, v, 2) - MATRIX(*res, u, 2);
                    float dlen, rdlen;

                    dlen = dx * dx + dy * dy + dz * dz;
                    if (dlen == 0) {
                        dx = RNG_UNIF01() * 1e-9;
                        dy = RNG_UNIF01() * 1e-9;
                        dz = RNG_UNIF01() * 1e-9;
                        dlen = dx * dx + dy * dy + dz * dz;
                    }

                    rdlen = sqrt(dlen);

                    VECTOR(dispx)[v] += dx * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispy)[v] += dy * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispy)[v] += dz * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispx)[u] -= dx * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispy)[u] -= dy * (C - dlen * rdlen) / (dlen * C);
                    VECTOR(dispz)[u] -= dz * (C - dlen * rdlen) / (dlen * C);
                }
            }
        }

        /* calculate attractive forces */
        for (e = 0; e < no_edges; e++) {
            /* each edges is an ordered pair of vertices v and u */
            igraph_integer_t v = IGRAPH_FROM(graph, e);
            igraph_integer_t u = IGRAPH_TO(graph, e);
            igraph_real_t dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
            igraph_real_t dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
            igraph_real_t dz = MATRIX(*res, v, 2) - MATRIX(*res, u, 2);
            igraph_real_t w = weight ? VECTOR(*weight)[e] : 1.0;
            igraph_real_t dlen = sqrt(dx * dx + dy * dy + dz * dz) * w;
            VECTOR(dispx)[v] -= (dx * dlen);
            VECTOR(dispy)[v] -= (dy * dlen);
            VECTOR(dispz)[v] -= (dz * dlen);
            VECTOR(dispx)[u] += (dx * dlen);
            VECTOR(dispy)[u] += (dy * dlen);
            VECTOR(dispz)[u] += (dz * dlen);
        }

        /* limit max displacement to temperature t and prevent from
           displacement outside frame */
        for (v = 0; v < no_nodes; v++) {
            igraph_real_t dx = VECTOR(dispx)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t dy = VECTOR(dispy)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t dz = VECTOR(dispz)[v] + RNG_UNIF01() * 1e-9;
            igraph_real_t displen = sqrt(dx * dx + dy * dy + dz * dz);
            igraph_real_t mx = fabs(dx) < temp ? dx : temp;
            igraph_real_t my = fabs(dy) < temp ? dy : temp;
            igraph_real_t mz = fabs(dz) < temp ? dz : temp;
            if (displen > 0) {
                MATRIX(*res, v, 0) += (dx / displen) * mx;
                MATRIX(*res, v, 1) += (dy / displen) * my;
                MATRIX(*res, v, 2) += (dz / displen) * mz;
            }
            if (minx && MATRIX(*res, v, 0) < VECTOR(*minx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*minx)[v];
            }
            if (maxx && MATRIX(*res, v, 0) > VECTOR(*maxx)[v]) {
                MATRIX(*res, v, 0) = VECTOR(*maxx)[v];
            }
            if (miny && MATRIX(*res, v, 1) < VECTOR(*miny)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*miny)[v];
            }
            if (maxy && MATRIX(*res, v, 1) > VECTOR(*maxy)[v]) {
                MATRIX(*res, v, 1) = VECTOR(*maxy)[v];
            }
            if (minz && MATRIX(*res, v, 2) < VECTOR(*minz)[v]) {
                MATRIX(*res, v, 2) = VECTOR(*minz)[v];
            }
            if (maxz && MATRIX(*res, v, 2) > VECTOR(*maxz)[v]) {
                MATRIX(*res, v, 2) = VECTOR(*maxz)[v];
            }
        }

        temp -= difftemp;
    }

    RNG_END();

    igraph_vector_float_destroy(&dispx);
    igraph_vector_float_destroy(&dispy);
    igraph_vector_float_destroy(&dispz);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/gem.c0000644000175100001710000002257400000000000022704 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"
#include "igraph_random.h"

#include "core/math.h"
#include "core/interruption.h"

/**
 * \ingroup layout
 * \function igraph_layout_gem
 *
 * The GEM layout algorithm, as described in Arne Frick, Andreas Ludwig,
 * Heiko Mehldau: A Fast Adaptive Layout Algorithm for Undirected Graphs,
 * Proc. Graph Drawing 1994, LNCS 894, pp. 388-403, 1995.
 * \param graph The input graph. Edge directions are ignored in
 *        directed graphs.
 * \param res The result is stored here. If the \p use_seed argument
 *        is true (non-zero), then this matrix is also used as the
 *        starting point of the algorithm.
 * \param use_seed Boolean, whether to use the supplied coordinates in
 *        \p res as the starting point. If false (zero), then a
 *        uniform random starting point is used.
 * \param maxiter The maximum number of iterations to
 *        perform. Updating a single vertex counts as an iteration.
 *        A reasonable default is 40 * n * n, where n is the number of
 *        vertices. The original paper suggests 4 * n * n, but this
 *        usually only works if the other parameters are set up carefully.
 * \param temp_max The maximum allowed local temperature. A reasonable
 *        default is the number of vertices.
 * \param temp_min The global temperature at which the algorithm
 *        terminates (even before reaching \p maxiter iterations). A
 *        reasonable default is 1/10.
 * \param temp_init Initial local temperature of all vertices. A
 *        reasonable default is the square root of the number of
 *        vertices.
 * \return Error code.
 *
 * Time complexity: O(t * n * (n+e)), where n is the number of vertices,
 * e is the number of edges and t is the number of time steps
 * performed.
 */

int igraph_layout_gem(const igraph_t *graph, igraph_matrix_t *res,
                      igraph_bool_t use_seed, igraph_integer_t maxiter,
                      igraph_real_t temp_max, igraph_real_t temp_min,
                      igraph_real_t temp_init) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_vector_int_t perm;
    igraph_vector_float_t impulse_x, impulse_y, temp, skew_gauge;
    igraph_integer_t i;
    float temp_global;
    igraph_integer_t perm_pointer = 0;
    float barycenter_x = 0, barycenter_y = 0;
    igraph_vector_t phi;
    igraph_vector_t neis;
    const float elen_des2 = 128 * 128;
    const float gamma = 1 / 16.0f;
    const float alpha_o = (float)M_PI;
    const float alpha_r = (float)M_PI / 3.0f;
    const float sigma_o = 1.0f / 3.0f;
    const float sigma_r = 1.0f / 2.0f / no_nodes;

    if (maxiter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negative in GEM layout",
                     IGRAPH_EINVAL);
    }
    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 2)) {
        IGRAPH_ERROR("Invalid start position matrix size in GEM layout",
                     IGRAPH_EINVAL);
    }
    if (temp_max <= 0) {
        IGRAPH_ERROR("Maximum temperature should be positive in GEM layout",
                     IGRAPH_EINVAL);
    }
    if (temp_min <= 0) {
        IGRAPH_ERROR("Minimum temperature should be positive in GEM layout",
                     IGRAPH_EINVAL);
    }
    if (temp_init <= 0) {
        IGRAPH_ERROR("Initial temperature should be positive in GEM layout",
                     IGRAPH_EINVAL);
    }
    if (temp_max < temp_init || temp_init < temp_min) {
        IGRAPH_ERROR("Minimum <= Initial <= Maximum temperature is required "
                     "in GEM layout", IGRAPH_EINVAL);
    }

    if (no_nodes == 0) {
        return 0;
    }

    IGRAPH_CHECK(igraph_vector_float_init(&impulse_x, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &impulse_x);
    IGRAPH_CHECK(igraph_vector_float_init(&impulse_y, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &impulse_y);
    IGRAPH_CHECK(igraph_vector_float_init(&temp, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &temp);
    IGRAPH_CHECK(igraph_vector_float_init(&skew_gauge, no_nodes));
    IGRAPH_FINALLY(igraph_vector_float_destroy, &skew_gauge);
    IGRAPH_CHECK(igraph_vector_int_init_seq(&perm, 0, no_nodes - 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &perm);
    IGRAPH_VECTOR_INIT_FINALLY(&phi, no_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 10);

    RNG_BEGIN();

    /* Initialization */
    igraph_degree(graph, &phi, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    if (!use_seed) {
        const igraph_real_t width_half = no_nodes * 100, height_half = width_half;
        IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 2));
        for (i = 0; i < no_nodes; i++) {
            MATRIX(*res, i, 0) = RNG_UNIF(-width_half, width_half);
            MATRIX(*res, i, 1) = RNG_UNIF(-height_half, height_half);
            barycenter_x += MATRIX(*res, i, 0);
            barycenter_y += MATRIX(*res, i, 1);
            VECTOR(phi)[i] *= (VECTOR(phi)[i] / 2.0 + 1.0);
        }
    } else {
        for (i = 0; i < no_nodes; i++) {
            barycenter_x += MATRIX(*res, i, 0);
            barycenter_y += MATRIX(*res, i, 1);
            VECTOR(phi)[i] *= (VECTOR(phi)[i] / 2.0 + 1.0);
        }
    }
    igraph_vector_float_fill(&temp, temp_init);
    temp_global = temp_init * no_nodes;

    while (temp_global > temp_min * no_nodes && maxiter > 0) {
        igraph_integer_t u, v, nlen, j;
        float px, py, pvx, pvy;

        IGRAPH_ALLOW_INTERRUPTION();

        /* choose a vertex v to update */
        if (!perm_pointer) {
            igraph_vector_int_shuffle(&perm);
            perm_pointer = no_nodes - 1;
        }
        v = VECTOR(perm)[perm_pointer--];

        /* compute v's impulse */
        px = (barycenter_x / no_nodes - MATRIX(*res, v, 0)) * gamma * VECTOR(phi)[v];
        py = (barycenter_y / no_nodes - MATRIX(*res, v, 1)) * gamma * VECTOR(phi)[v];
        px += RNG_UNIF(-32.0, 32.0);
        py += RNG_UNIF(-32.0, 32.0);

        for (u = 0; u < no_nodes; u++) {
            float dx, dy, dist2;
            if (u == v) {
                continue;
            }
            dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
            dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
            dist2 = dx * dx + dy * dy;
            if (dist2 != 0) {
                px += dx * elen_des2 / dist2;
                py += dy * elen_des2 / dist2;
            }
        }

        IGRAPH_CHECK(igraph_neighbors(graph, &neis, v, IGRAPH_ALL));
        nlen = igraph_vector_size(&neis);
        for (j = 0; j < nlen; j++) {
            igraph_integer_t u = VECTOR(neis)[j];
            float dx = MATRIX(*res, v, 0) - MATRIX(*res, u, 0);
            float dy = MATRIX(*res, v, 1) - MATRIX(*res, u, 1);
            float dist2 = dx * dx + dy * dy;
            px -= dx * dist2 / (elen_des2 * VECTOR(phi)[v]);
            py -= dy * dist2 / (elen_des2 * VECTOR(phi)[v]);
        }

        /* update v's position and temperature */
        if (px != 0 || py != 0) {
            float plen = sqrtf(px * px + py * py);
            px *= VECTOR(temp)[v] / plen;
            py *= VECTOR(temp)[v] / plen;
            MATRIX(*res, v, 0) += px;
            MATRIX(*res, v, 1) += py;
            barycenter_x += px;
            barycenter_y += py;
        }

        pvx = VECTOR(impulse_x)[v]; pvy = VECTOR(impulse_y)[v];
        if (pvx != 0 || pvy != 0) {
            float beta = atan2f(pvy - py, pvx - px);
            float sin_beta = sinf(beta);
            float sign_sin_beta = (sin_beta > 0) ? 1 : ((sin_beta < 0) ? -1 : 0);
            float cos_beta = cosf(beta);
            float abs_cos_beta = fabsf(cos_beta);
            float old_temp = VECTOR(temp)[v];
            if (sin(beta) >= sin(M_PI_2 + alpha_r / 2.0)) {
                VECTOR(skew_gauge)[v] += sigma_r * sign_sin_beta;
            }
            if (abs_cos_beta >= cosf(alpha_o / 2.0)) {
                VECTOR(temp)[v] *= sigma_o * cos_beta;
            }
            VECTOR(temp)[v] *= (1 - fabsf(VECTOR(skew_gauge)[v]));
            if (VECTOR(temp)[v] > temp_max) {
                VECTOR(temp)[v] = temp_max;
            }
            VECTOR(impulse_x)[v] = px;
            VECTOR(impulse_y)[v] = py;
            temp_global += VECTOR(temp)[v] - old_temp;
        }

        maxiter--;

    } /* while temp && iter */


    RNG_END();

    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&phi);
    igraph_vector_int_destroy(&perm);
    igraph_vector_float_destroy(&skew_gauge);
    igraph_vector_float_destroy(&temp);
    igraph_vector_float_destroy(&impulse_y);
    igraph_vector_float_destroy(&impulse_x);
    IGRAPH_FINALLY_CLEAN(7);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/graphopt.c0000644000175100001710000004162600000000000023757 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"
#include "igraph_progress.h"

#include "core/interruption.h"

#define COULOMBS_CONSTANT 8987500000.0


static igraph_real_t igraph_i_distance_between(
        const igraph_matrix_t *c,
        long int a, long int b);

static int igraph_i_determine_electric_axal_forces(
        const igraph_matrix_t *pos,
        igraph_real_t *x,
        igraph_real_t *y,
        igraph_real_t directed_force,
        igraph_real_t distance,
        long int other_node,
        long int this_node);

static int igraph_i_apply_electrical_force(
        const igraph_matrix_t *pos,
        igraph_vector_t *pending_forces_x,
        igraph_vector_t *pending_forces_y,
        long int other_node, long int this_node,
        igraph_real_t node_charge,
        igraph_real_t distance);

static int igraph_i_determine_spring_axal_forces(
        const igraph_matrix_t *pos,
        igraph_real_t *x, igraph_real_t *y,
        igraph_real_t directed_force,
        igraph_real_t distance,
        igraph_real_t spring_length,
        long int other_node,
        long int this_node);

static int igraph_i_apply_spring_force(
        const igraph_matrix_t *pos,
        igraph_vector_t *pending_forces_x,
        igraph_vector_t *pending_forces_y,
        long int other_node,
        long int this_node, igraph_real_t spring_length,
        igraph_real_t spring_constant);

static int igraph_i_move_nodes(
        igraph_matrix_t *pos,
        const igraph_vector_t *pending_forces_x,
        const igraph_vector_t *pending_forces_y,
        igraph_real_t node_mass,
        igraph_real_t max_sa_movement);

static igraph_real_t igraph_i_distance_between(
        const igraph_matrix_t *c,
        long int a, long int b) {
    igraph_real_t diffx = MATRIX(*c, a, 0) - MATRIX(*c, b, 0);
    igraph_real_t diffy = MATRIX(*c, a, 1) - MATRIX(*c, b, 1);
    return sqrt( diffx * diffx + diffy * diffy );
}

static int igraph_i_determine_electric_axal_forces(const igraph_matrix_t *pos,
        igraph_real_t *x,
        igraph_real_t *y,
        igraph_real_t directed_force,
        igraph_real_t distance,
        long int other_node,
        long int this_node) {

    // We know what the directed force is.  We now need to translate it
    // into the appropriate x and y components.
    // First, assume:
    //                 other_node
    //                    /|
    //  directed_force  /  |
    //                /    | y
    //              /______|
    //    this_node     x
    //
    // other_node.x > this_node.x
    // other_node.y > this_node.y
    // the force will be on this_node away from other_node

    // the proportion (distance/y_distance) is equal to the proportion
    // (directed_force/y_force), as the two triangles are similar.
    // therefore, the magnitude of y_force = (directed_force*y_distance)/distance
    // the sign of y_force is negative, away from other_node

    igraph_real_t x_distance, y_distance;
    y_distance = MATRIX(*pos, other_node, 1) - MATRIX(*pos, this_node, 1);
    if (y_distance < 0) {
        y_distance = -y_distance;
    }
    *y = -1 * ((directed_force * y_distance) / distance);

    // the x component works in exactly the same way.
    x_distance = MATRIX(*pos, other_node, 0) - MATRIX(*pos, this_node, 0);
    if (x_distance < 0) {
        x_distance = -x_distance;
    }
    *x = -1 * ((directed_force * x_distance) / distance);

    // Now we need to reverse the polarity of our answers based on the falsness
    // of our assumptions.
    if (MATRIX(*pos, other_node, 0) < MATRIX(*pos, this_node, 0)) {
        *x = *x * -1;
    }
    if (MATRIX(*pos, other_node, 1) < MATRIX(*pos, this_node, 1)) {
        *y = *y * -1;
    }

    return 0;
}

static int igraph_i_apply_electrical_force(
        const igraph_matrix_t *pos,
        igraph_vector_t *pending_forces_x,
        igraph_vector_t *pending_forces_y,
        long int other_node, long int this_node,
        igraph_real_t node_charge,
        igraph_real_t distance) {

    igraph_real_t directed_force = COULOMBS_CONSTANT *
                                   ((node_charge * node_charge) / (distance * distance));

    igraph_real_t x_force, y_force;
    igraph_i_determine_electric_axal_forces(pos, &x_force, &y_force,
                                            directed_force, distance,
                                            other_node, this_node);

    VECTOR(*pending_forces_x)[this_node] += x_force;
    VECTOR(*pending_forces_y)[this_node] += y_force;
    VECTOR(*pending_forces_x)[other_node] -= x_force;
    VECTOR(*pending_forces_y)[other_node] -= y_force;

    return 0;
}

static int igraph_i_determine_spring_axal_forces(
        const igraph_matrix_t *pos,
        igraph_real_t *x, igraph_real_t *y,
        igraph_real_t directed_force,
        igraph_real_t distance,
        igraph_real_t spring_length,
        long int other_node, long int this_node) {

    // if the spring is just the right size, the forces will be 0, so we can
    // skip the computation.
    //
    // if the spring is too long, our forces will be identical to those computed
    // by determine_electrical_axal_forces() (this_node will be pulled toward
    // other_node).
    //
    // if the spring is too short, our forces will be the opposite of those
    // computed by determine_electrical_axal_forces() (this_node will be pushed
    // away from other_node)
    //
    // finally, since both nodes are movable, only one-half of the total force
    // should be applied to each node, so half the forces for our answer.

    if (distance == spring_length) {
        *x = 0.0;
        *y = 0.0;
    } else {
        igraph_i_determine_electric_axal_forces(pos, x, y, directed_force, distance,
                                                other_node, this_node);
        if (distance < spring_length) {
            *x = -1 * *x;
            *y = -1 * *y;
        }
        *x = 0.5 * *x;
        *y = 0.5 * *y;
    }

    return 0;
}

static int igraph_i_apply_spring_force(
        const igraph_matrix_t *pos,
        igraph_vector_t *pending_forces_x,
        igraph_vector_t *pending_forces_y,
        long int other_node,
        long int this_node, igraph_real_t spring_length,
        igraph_real_t spring_constant) {

    // determined using Hooke's Law:
    //   force = -kx
    // where:
    //   k = spring constant
    //   x = displacement from ideal length in meters

    igraph_real_t distance, displacement, directed_force, x_force, y_force;
    distance = igraph_i_distance_between(pos, other_node, this_node);
    // let's protect ourselves from division by zero by ignoring two nodes that
    // happen to be in the same place.  Since we separate all nodes before we
    // work on any of them, this will only happen in extremely rare circumstances,
    // and when it does, electrical force will probably push one or both of them
    // one way or another anyway.
    if (distance == 0.0) {
        return 0;
    }

    displacement = distance - spring_length;
    if (displacement < 0) {
        displacement = -displacement;
    }
    directed_force = -1 * spring_constant * displacement;
    // remember, this is force directed away from the spring;
    // a negative number is back towards the spring (or, in our case, back towards
    // the other node)

    // get the force that should be applied to >this< node
    igraph_i_determine_spring_axal_forces(pos, &x_force, &y_force,
                                          directed_force, distance, spring_length,
                                          other_node, this_node);

    VECTOR(*pending_forces_x)[this_node] += x_force;
    VECTOR(*pending_forces_y)[this_node] += y_force;
    VECTOR(*pending_forces_x)[other_node] -= x_force;
    VECTOR(*pending_forces_y)[other_node] -= y_force;

    return 0;
}

static int igraph_i_move_nodes(
        igraph_matrix_t *pos,
        const igraph_vector_t *pending_forces_x,
        const igraph_vector_t *pending_forces_y,
        igraph_real_t node_mass,
        igraph_real_t max_sa_movement) {

    // Since each iteration is isolated, time is constant at 1.
    // Therefore:
    //   Force effects acceleration.
    //   acceleration (d(velocity)/time) = velocity
    //   velocity (d(displacement)/time) = displacement
    //   displacement = acceleration

    // determined using Newton's second law:
    //   sum(F) = ma
    // therefore:
    //   acceleration = force / mass
    //   velocity     = force / mass
    //   displacement = force / mass

    long int this_node, no_of_nodes = igraph_vector_size(pending_forces_x);

    for (this_node = 0; this_node < no_of_nodes; this_node++) {

        igraph_real_t x_movement, y_movement;

        x_movement = VECTOR(*pending_forces_x)[this_node] / node_mass;
        if (x_movement > max_sa_movement) {
            x_movement = max_sa_movement;
        } else if (x_movement < -max_sa_movement) {
            x_movement = -max_sa_movement;
        }

        y_movement = VECTOR(*pending_forces_y)[this_node] / node_mass;
        if (y_movement > max_sa_movement) {
            y_movement = max_sa_movement;
        } else if (y_movement < -max_sa_movement) {
            y_movement = -max_sa_movement;
        }

        MATRIX(*pos, this_node, 0) += x_movement;
        MATRIX(*pos, this_node, 1) += y_movement;

    }
    return 0;
}

/**
 * \function igraph_layout_graphopt
 * \brief Optimizes vertex layout via the graphopt algorithm.
 *
 * 
 * This is a port of the graphopt layout algorithm by Michael Schmuhl.
 * graphopt version 0.4.1 was rewritten in C and the support for
 * layers was removed (might be added later) and a code was a bit
 * reorganized to avoid some unnecessary steps is the node charge (see below)
 * is zero.
 *
 * 
 * Graphopt uses physical analogies for defining attracting and repelling
 * forces among the vertices and then the physical system is simulated
 * until it reaches an equilibrium. (There is no simulated annealing or
 * anything like that, so a stable fixed point is not guaranteed.)
 *
 * 
 * See also http://www.schmuhl.org/graphopt/ for the original graphopt.
 * \param graph The input graph.
 * \param res Pointer to an initialized matrix, the result will be stored here
 *    and its initial contents are used as the starting point of the simulation
 *    if the \p use_seed argument is true. Note that in this case the
 *    matrix should have the proper size, otherwise a warning is issued and
 *    the supplied values are ignored. If no starting positions are given
 *    (or they are invalid) then a random starting position is used.
 *    The matrix will be resized if needed.
 * \param niter Integer constant, the number of iterations to perform.
 *    Should be a couple of hundred in general. If you have a large graph
 *    then you might want to only do a few iterations and then check the
 *    result. If it is not good enough you can feed it in again in
 *    the \p res argument. The original graphopt default is 500.
 * \param node_charge The charge of the vertices, used to calculate electric
 *    repulsion. The original graphopt default is 0.001.
 * \param node_mass The mass of the vertices, used for the spring forces.
 *    The original graphopt defaults to 30.
 * \param spring_length The length of the springs.
 *    The original graphopt defaults to zero.
 * \param spring_constant The spring constant, the original graphopt defaults
 *    to one.
 * \param max_sa_movement Real constant, it gives the maximum amount of movement
 *    allowed in a single step along a single axis. The original graphopt
 *    default is 5.
 * \param use_seed Logical scalar, whether to use the positions in \p res as
 *    a starting configuration. See also \p res above.
 * \return Error code.
 *
 * Time complexity: O(n (|V|^2+|E|) ), n is the number of iterations,
 * |V| is the number of vertices, |E| the number
 * of edges. If \p node_charge is zero then it is only O(n|E|).
 */
int igraph_layout_graphopt(const igraph_t *graph, igraph_matrix_t *res,
                           igraph_integer_t niter,
                           igraph_real_t node_charge, igraph_real_t node_mass,
                           igraph_real_t spring_length,
                           igraph_real_t spring_constant,
                           igraph_real_t max_sa_movement,
                           igraph_bool_t use_seed) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t pending_forces_x, pending_forces_y;
    /* Set a flag to calculate (or not) the electrical forces that the nodes */
    /* apply on each other based on if both node types' charges are zero. */
    igraph_bool_t apply_electric_charges = (node_charge != 0);

    long int this_node, other_node, edge;
    igraph_real_t distance;
    long int i;

    IGRAPH_VECTOR_INIT_FINALLY(&pending_forces_x, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&pending_forces_y, no_of_nodes);

    if (use_seed) {
        if (igraph_matrix_nrow(res) != no_of_nodes ||
            igraph_matrix_ncol(res) != 2) {
            IGRAPH_WARNING("Invalid size for initial matrix, starting from random layout.");
            IGRAPH_CHECK(igraph_layout_random(graph, res));
        }
    } else {
        IGRAPH_CHECK(igraph_layout_random(graph, res));
    }

    IGRAPH_PROGRESS("Graphopt layout", 0, NULL);
    for (i = niter; i > 0; i--) {
        /* Report progress in approx. every 100th step */
        if (i % 10 == 0) {
            IGRAPH_PROGRESS("Graphopt layout", 100.0 - 100.0 * i / niter, NULL);
        }

        /* Clear pending forces on all nodes */
        igraph_vector_null(&pending_forces_x);
        igraph_vector_null(&pending_forces_y);

        // Apply electrical force applied by all other nodes
        if (apply_electric_charges) {
            // Iterate through all nodes
            for (this_node = 0; this_node < no_of_nodes; this_node++) {
                IGRAPH_ALLOW_INTERRUPTION();
                for (other_node = this_node + 1;
                     other_node < no_of_nodes;
                     other_node++) {
                    distance = igraph_i_distance_between(res, this_node, other_node);
                    // let's protect ourselves from division by zero by ignoring
                    // two nodes that happen to be in the same place.  Since we
                    // separate all nodes before we work on any of them, this
                    // will only happen in extremely rare circumstances, and when
                    // it does, springs will probably pull them apart anyway.
                    // also, if we are more than 50 away, the electric force
                    // will be negligible.
                    // ***** may not always be desirable ****
                    if ((distance != 0.0) && (distance < 500.0)) {
                        //    if (distance != 0.0) {
                        // Apply electrical force from node(counter2) on
                        // node(counter)
                        igraph_i_apply_electrical_force(res, &pending_forces_x,
                                                        &pending_forces_y,
                                                        other_node, this_node,
                                                        node_charge,
                                                        distance);
                    }
                }
            }
        }

        // Apply force from springs
        for (edge = 0; edge < no_of_edges; edge++) {
            long int tthis_node = IGRAPH_FROM(graph, edge);
            long int oother_node = IGRAPH_TO(graph, edge);
            // Apply spring force on both nodes
            igraph_i_apply_spring_force(res, &pending_forces_x, &pending_forces_y,
                                        oother_node, tthis_node, spring_length,
                                        spring_constant);
        }

        // Effect the movement of the nodes based on all pending forces
        igraph_i_move_nodes(res, &pending_forces_x, &pending_forces_y, node_mass,
                            max_sa_movement);
    }
    IGRAPH_PROGRESS("Graphopt layout", 100, NULL);

    igraph_vector_destroy(&pending_forces_y);
    igraph_vector_destroy(&pending_forces_x);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/kamada_kawai.c0000644000175100001710000006742200000000000024527 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"
#include "igraph_paths.h"
#include "igraph_random.h"

#include "core/interruption.h"

/**
 * \ingroup layout
 * \function igraph_layout_kamada_kawai
 * \brief Places the vertices on a plane according to the Kamada-Kawai algorithm.
 *
 * This is a force-directed layout. A spring is inserted between all pairs
 * of vertices, both those which are directly connected and those that are not.
 * The unstretched length of springs is chosen based on the graph distance
 * between the corresponding pair of vertices. Thus, in a weighted graph, increasing
 * the weight between two vertices pushes them apart. The Young modulus of springs
 * is inversely proportional to the graph distance, ensuring that springs between
 * far-apart veritces will have a smaller effect on the layout.
 *
 * 
 * This layout algorithm is not suitable for large graphs. The memory
 * requirements are of the order O(|V|^2).
 *
 * 
 * Reference:
 *
 * 
 * Kamada, T. and Kawai, S.:
 * An Algorithm for Drawing General Undirected Graphs.
 * Information Processing Letters, 31/1, 7--15, 1989.
 * https://doi.org/10.1016/0020-0190(89)90102-6
 *
 * \param graph A graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result (x-positions in column zero and
 *        y-positions in column one) and will be resized if needed.
 * \param use_seed Boolean, whether to use the values supplied in the
 *        \p res argument as the initial configuration. If zero and there
 *        are any limits on the X or Y coordinates, then a random initial
 *        configuration is used. Otherwise the vertices are placed on a
 *        circle of radius 1 as the initial configuration.
 * \param maxiter The maximum number of iterations to perform. A reasonable
 *        default value is at least ten (or more) times the number of
 *        vertices.
 * \param epsilon Stop the iteration, if the maximum delta value of the
 *        algorithm is smaller than still. It is safe to leave it at zero,
 *        and then \p maxiter iterations are performed.
 * \param kkconst The Kamada-Kawai vertex attraction constant.
 *        Typical value: number of vertices.
 * \param weights Edge weights, larger values will result longer edges.
 * \param minx Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote x \endquote coordinate for every vertex.
 * \param maxx Same as \p minx, but the maximum \quote x \endquote
 *        coordinates.
 * \param miny Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote y \endquote coordinate for every vertex.
 * \param maxy Same as \p miny, but the maximum \quote y \endquote
 *        coordinates.
 * \return Error code.
 *
 * Time complexity: O(|V|) for each iteration, after an O(|V|^2
 * log|V|) initialization step. |V| is the number of vertices in the
 * graph.
 */

int igraph_layout_kamada_kawai(const igraph_t *graph, igraph_matrix_t *res,
                               igraph_bool_t use_seed, igraph_integer_t maxiter,
                               igraph_real_t epsilon, igraph_real_t kkconst,
                               const igraph_vector_t *weights,
                               const igraph_vector_t *minx, const igraph_vector_t *maxx,
                               const igraph_vector_t *miny, const igraph_vector_t *maxy) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    igraph_real_t L, L0 = sqrt(no_nodes);
    igraph_matrix_t dij, lij, kij;
    igraph_real_t max_dij;
    igraph_vector_t D1, D2;
    igraph_integer_t i, j, m;

    if (maxiter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negatice in "
                     "Kamada-Kawai layout", IGRAPH_EINVAL);
    }
    if (kkconst <= 0) {
        IGRAPH_ERROR("`K' constant must be positive in Kamada-Kawai layout",
                     IGRAPH_EINVAL);
    }

    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 2)) {
        IGRAPH_ERROR("Invalid start position matrix size in "
                     "Kamada-Kawai layout", IGRAPH_EINVAL);
    }
    if (weights && igraph_vector_size(weights) != no_edges) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    if (minx && igraph_vector_size(minx) != no_nodes) {
        IGRAPH_ERROR("Invalid minx vector length", IGRAPH_EINVAL);
    }
    if (maxx && igraph_vector_size(maxx) != no_nodes) {
        IGRAPH_ERROR("Invalid maxx vector length", IGRAPH_EINVAL);
    }
    if (minx && maxx && !igraph_vector_all_le(minx, maxx)) {
        IGRAPH_ERROR("minx must not be greater than maxx", IGRAPH_EINVAL);
    }
    if (miny && igraph_vector_size(miny) != no_nodes) {
        IGRAPH_ERROR("Invalid miny vector length", IGRAPH_EINVAL);
    }
    if (maxy && igraph_vector_size(maxy) != no_nodes) {
        IGRAPH_ERROR("Invalid maxy vector length", IGRAPH_EINVAL);
    }
    if (miny && maxy && !igraph_vector_all_le(miny, maxy)) {
        IGRAPH_ERROR("miny must not be greater than maxy", IGRAPH_EINVAL);
    }

    if (!use_seed) {
        if (minx || maxx || miny || maxy) {
            const igraph_real_t width = sqrt(no_nodes), height = width;
            IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 2));
            RNG_BEGIN();
            for (i = 0; i < no_nodes; i++) {
                igraph_real_t x1 = minx ? VECTOR(*minx)[i] : -width / 2;
                igraph_real_t x2 = maxx ? VECTOR(*maxx)[i] :  width / 2;
                igraph_real_t y1 = miny ? VECTOR(*miny)[i] : -height / 2;
                igraph_real_t y2 = maxy ? VECTOR(*maxy)[i] :  height / 2;
                if (!igraph_finite(x1)) {
                    x1 = -width / 2;
                }
                if (!igraph_finite(x2)) {
                    x2 =  width / 2;
                }
                if (!igraph_finite(y1)) {
                    y1 = -height / 2;
                }
                if (!igraph_finite(y2)) {
                    y2 =  height / 2;
                }
                MATRIX(*res, i, 0) = RNG_UNIF(x1, x2);
                MATRIX(*res, i, 1) = RNG_UNIF(y1, y2);
            }
            RNG_END();
        } else {
            igraph_layout_circle(graph, res, /* order= */ igraph_vss_all());
        }
    }

    if (no_nodes <= 1) {
        return 0;
    }

    IGRAPH_MATRIX_INIT_FINALLY(&dij, no_nodes, no_nodes);
    IGRAPH_MATRIX_INIT_FINALLY(&kij, no_nodes, no_nodes);
    IGRAPH_MATRIX_INIT_FINALLY(&lij, no_nodes, no_nodes);

    if (weights && no_edges > 0 && igraph_vector_min(weights) < 0) {
        IGRAPH_CHECK(igraph_shortest_paths_bellman_ford(graph, &dij, igraph_vss_all(),
                     igraph_vss_all(), weights,
                     IGRAPH_ALL));
    } else {

        IGRAPH_CHECK(igraph_shortest_paths_dijkstra(graph, &dij, igraph_vss_all(),
                     igraph_vss_all(), weights,
                     IGRAPH_ALL));
    }

    max_dij = 0.0;
    for (i = 0; i < no_nodes; i++) {
        for (j = i + 1; j < no_nodes; j++) {
            if (!igraph_finite(MATRIX(dij, i, j))) {
                continue;
            }
            if (MATRIX(dij, i, j) > max_dij) {
                max_dij = MATRIX(dij, i, j);
            }
        }
    }
    for (i = 0; i < no_nodes; i++) {
        for (j = 0; j < no_nodes; j++) {
            if (MATRIX(dij, i, j) > max_dij) {
                MATRIX(dij, i, j) = max_dij;
            }
        }
    }

    L = L0 / max_dij;
    for (i = 0; i < no_nodes; i++) {
        for (j = 0; j < no_nodes; j++) {
            igraph_real_t tmp = MATRIX(dij, i, j) * MATRIX(dij, i, j);
            if (i == j) {
                continue;
            }
            MATRIX(kij, i, j) = kkconst / tmp;
            MATRIX(lij, i, j) = L * MATRIX(dij, i, j);
        }
    }

    /* Initialize delta */
    IGRAPH_VECTOR_INIT_FINALLY(&D1, no_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&D2, no_nodes);
    for (m = 0; m < no_nodes; m++) {
        igraph_real_t myD1 = 0.0, myD2 = 0.0;
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t dx, dy, mi_dist;
            if (i == m) {
                continue;
            }
            dx = MATRIX(*res, m, 0) - MATRIX(*res, i, 0);
            dy = MATRIX(*res, m, 1) - MATRIX(*res, i, 1);
            mi_dist = sqrt(dx * dx + dy * dy);
            myD1 += MATRIX(kij, m, i) * (dx - MATRIX(lij, m, i) * dx / mi_dist);
            myD2 += MATRIX(kij, m, i) * (dy - MATRIX(lij, m, i) * dy / mi_dist);
        }
        VECTOR(D1)[m] = myD1;
        VECTOR(D2)[m] = myD2;
    }

    for (j = 0; j < maxiter; j++) {
        igraph_real_t myD1, myD2, A, B, C;
        igraph_real_t max_delta, delta_x, delta_y;
        igraph_real_t old_x, old_y, new_x, new_y;

        IGRAPH_ALLOW_INTERRUPTION();

        myD1 = 0.0, myD2 = 0.0, A = 0.0, B = 0.0, C = 0.0;

        /* Select maximal delta */
        m = 0; max_delta = -1;
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t delta = (VECTOR(D1)[i] * VECTOR(D1)[i] +
                                   VECTOR(D2)[i] * VECTOR(D2)[i]);
            if (delta > max_delta) {
                m = i; max_delta = delta;
            }
        }
        if (max_delta < epsilon) {
            break;
        }
        old_x = MATRIX(*res, m, 0);
        old_y = MATRIX(*res, m, 1);

        /* Calculate D1 and D2, A, B, C */
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t dx, dy, dist, den;
            if (i == m) {
                continue;
            }
            dx = old_x - MATRIX(*res, i, 0);
            dy = old_y - MATRIX(*res, i, 1);
            dist = sqrt(dx * dx + dy * dy);
            den = dist * (dx * dx + dy * dy);
            A += MATRIX(kij, m, i) * (1 - MATRIX(lij, m, i) * dy * dy / den);
            B += MATRIX(kij, m, i) * MATRIX(lij, m, i) * dx * dy / den;
            C += MATRIX(kij, m, i) * (1 - MATRIX(lij, m, i) * dx * dx / den);
        }
        myD1 = VECTOR(D1)[m];
        myD2 = VECTOR(D2)[m];

        /* Need to solve some linear equations */
        delta_y = (B * myD1 - myD2 * A) / (C * A - B * B);
        delta_x = - (myD1 + B * delta_y) / A;

        new_x = old_x + delta_x;
        new_y = old_y + delta_y;

        /* Limits, if given */
        if (minx && new_x < VECTOR(*minx)[m]) {
            new_x = VECTOR(*minx)[m];
        }
        if (maxx && new_x > VECTOR(*maxx)[m]) {
            new_x = VECTOR(*maxx)[m];
        }
        if (miny && new_y < VECTOR(*miny)[m]) {
            new_y = VECTOR(*miny)[m];
        }
        if (maxy && new_y > VECTOR(*maxy)[m]) {
            new_y = VECTOR(*maxy)[m];
        }

        /* Update delta, only with/for the affected node */
        VECTOR(D1)[m] = VECTOR(D2)[m] = 0.0;
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t old_dx, old_dy, new_dx, new_dy, new_mi_dist, old_mi_dist;
            if (i == m) {
                continue;
            }
            old_dx = old_x - MATRIX(*res, i, 0);
            old_dy = old_y - MATRIX(*res, i, 1);
            old_mi_dist = sqrt(old_dx * old_dx + old_dy * old_dy);
            new_dx = new_x - MATRIX(*res, i, 0);
            new_dy = new_y - MATRIX(*res, i, 1);
            new_mi_dist = sqrt(new_dx * new_dx + new_dy * new_dy);

            VECTOR(D1)[i] -= MATRIX(kij, m, i) *
                             (-old_dx + MATRIX(lij, m, i) * old_dx / old_mi_dist);
            VECTOR(D2)[i] -= MATRIX(kij, m, i) *
                             (-old_dy + MATRIX(lij, m, i) * old_dy / old_mi_dist);
            VECTOR(D1)[i] += MATRIX(kij, m, i) *
                             (-new_dx + MATRIX(lij, m, i) * new_dx / new_mi_dist);
            VECTOR(D2)[i] += MATRIX(kij, m, i) *
                             (-new_dy + MATRIX(lij, m, i) * new_dy / new_mi_dist);

            VECTOR(D1)[m] += MATRIX(kij, m, i) *
                             (new_dx - MATRIX(lij, m, i) * new_dx / new_mi_dist);
            VECTOR(D2)[m] += MATRIX(kij, m, i) *
                             (new_dy - MATRIX(lij, m, i) * new_dy / new_mi_dist);
        }

        /* Update coordinates*/
        MATRIX(*res, m, 0) = new_x;
        MATRIX(*res, m, 1) = new_y;
    }

    igraph_vector_destroy(&D2);
    igraph_vector_destroy(&D1);
    igraph_matrix_destroy(&lij);
    igraph_matrix_destroy(&kij);
    igraph_matrix_destroy(&dij);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \ingroup layout
 * \function igraph_layout_kamada_kawai_3d
 * \brief 3D version of the Kamada-Kawai layout generator.
 *
 * This is the 3D version of igraph_layout_kamada_kawai().
 * See the documentation of that function for more information.
 *
 * 
 * This layout algorithm is not suitable for large graphs. The memory
 * requirements are of the order O(|V|^2).
 *
 * \param graph A graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result (x-, y- and z-positions in columns one
 *        through three) and will be resized if needed.
 * \param use_seed Boolean, whether to use the values supplied in the
 *        \p res argument as the initial configuration. If zero and there
 *        are any limits on the z, y or z coordinates, then a random initial
 *        configuration is used. Otherwise the vertices are placed uniformly
 *        on a sphere of radius 1 as the initial configuration.
 * \param maxiter The maximum number of iterations to perform. A reasonable
 *        default value is at least ten (or more) times the number of
 *        vertices.
 * \param epsilon Stop the iteration, if the maximum delta value of the
 *        algorithm is smaller than still. It is safe to leave it at zero,
 *        and then \p maxiter iterations are performed.
 * \param kkconst The Kamada-Kawai vertex attraction constant.
 *        Typical value: number of vertices.
 * \param weights Edge weights, larger values will result longer edges.
 * \param minx Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote x \endquote coordinate for every vertex.
 * \param maxx Same as \p minx, but the maximum \quote x \endquote
 *        coordinates.
 * \param miny Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote y \endquote coordinate for every vertex.
 * \param maxy Same as \p miny, but the maximum \quote y \endquote
 *        coordinates.
 * \param minz Pointer to a vector, or a \c NULL pointer. If not a
 *        \c NULL pointer then the vector gives the minimum
 *        \quote z \endquote coordinate for every vertex.
 * \param maxz Same as \p minz, but the maximum \quote z \endquote
 *        coordinates.
 * \return Error code.
 *
 * Time complexity: O(|V|) for each iteration, after an O(|V|^2
 * log|V|) initialization step. |V| is the number of vertices in the
 * graph.
 */

int igraph_layout_kamada_kawai_3d(const igraph_t *graph, igraph_matrix_t *res,
                                  igraph_bool_t use_seed, igraph_integer_t maxiter,
                                  igraph_real_t epsilon, igraph_real_t kkconst,
                                  const igraph_vector_t *weights,
                                  const igraph_vector_t *minx, const igraph_vector_t *maxx,
                                  const igraph_vector_t *miny, const igraph_vector_t *maxy,
                                  const igraph_vector_t *minz, const igraph_vector_t *maxz) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_integer_t no_edges = igraph_ecount(graph);
    igraph_real_t L, L0 = sqrt(no_nodes);
    igraph_matrix_t dij, lij, kij;
    igraph_real_t max_dij;
    igraph_vector_t D1, D2, D3;
    igraph_integer_t i, j, m;

    if (maxiter < 0) {
        IGRAPH_ERROR("Number of iterations must be non-negatice in "
                     "Kamada-Kawai layout", IGRAPH_EINVAL);
    }
    if (kkconst <= 0) {
        IGRAPH_ERROR("`K' constant must be positive in Kamada-Kawai layout",
                     IGRAPH_EINVAL);
    }

    if (use_seed && (igraph_matrix_nrow(res) != no_nodes ||
                     igraph_matrix_ncol(res) != 3)) {
        IGRAPH_ERROR("Invalid start position matrix size in "
                     "3d Kamada-Kawai layout", IGRAPH_EINVAL);
    }
    if (weights && igraph_vector_size(weights) != no_edges) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    if (minx && igraph_vector_size(minx) != no_nodes) {
        IGRAPH_ERROR("Invalid minx vector length", IGRAPH_EINVAL);
    }
    if (maxx && igraph_vector_size(maxx) != no_nodes) {
        IGRAPH_ERROR("Invalid maxx vector length", IGRAPH_EINVAL);
    }
    if (minx && maxx && !igraph_vector_all_le(minx, maxx)) {
        IGRAPH_ERROR("minx must not be greater than maxx", IGRAPH_EINVAL);
    }
    if (miny && igraph_vector_size(miny) != no_nodes) {
        IGRAPH_ERROR("Invalid miny vector length", IGRAPH_EINVAL);
    }
    if (maxy && igraph_vector_size(maxy) != no_nodes) {
        IGRAPH_ERROR("Invalid maxy vector length", IGRAPH_EINVAL);
    }
    if (miny && maxy && !igraph_vector_all_le(miny, maxy)) {
        IGRAPH_ERROR("miny must not be greater than maxy", IGRAPH_EINVAL);
    }
    if (minz && igraph_vector_size(minz) != no_nodes) {
        IGRAPH_ERROR("Invalid minz vector length", IGRAPH_EINVAL);
    }
    if (maxz && igraph_vector_size(maxz) != no_nodes) {
        IGRAPH_ERROR("Invalid maxz vector length", IGRAPH_EINVAL);
    }
    if (minz && maxz && !igraph_vector_all_le(minz, maxz)) {
        IGRAPH_ERROR("minz must not be greater than maxz", IGRAPH_EINVAL);
    }

    if (!use_seed) {
        if (minx || maxx || miny || maxy || minz || maxz) {
            const igraph_real_t width = sqrt(no_nodes), height = width, depth = width;
            IGRAPH_CHECK(igraph_matrix_resize(res, no_nodes, 3));
            RNG_BEGIN();
            for (i = 0; i < no_nodes; i++) {
                igraph_real_t x1 = minx ? VECTOR(*minx)[i] : -width / 2;
                igraph_real_t x2 = maxx ? VECTOR(*maxx)[i] :  width / 2;
                igraph_real_t y1 = miny ? VECTOR(*miny)[i] : -height / 2;
                igraph_real_t y2 = maxy ? VECTOR(*maxy)[i] :  height / 2;
                igraph_real_t z1 = minz ? VECTOR(*minz)[i] : -depth / 2;
                igraph_real_t z2 = maxz ? VECTOR(*maxz)[i] :  depth / 2;
                if (!igraph_finite(x1)) {
                    x1 = -width / 2;
                }
                if (!igraph_finite(x2)) {
                    x2 =  width / 2;
                }
                if (!igraph_finite(y1)) {
                    y1 = -height / 2;
                }
                if (!igraph_finite(y2)) {
                    y2 =  height / 2;
                }
                if (!igraph_finite(z1)) {
                    z1 = -depth / 2;
                }
                if (!igraph_finite(z2)) {
                    z2 =  depth / 2;
                }
                MATRIX(*res, i, 0) = RNG_UNIF(x1, x2);
                MATRIX(*res, i, 1) = RNG_UNIF(y1, y2);
                MATRIX(*res, i, 2) = RNG_UNIF(z1, z2);
            }
            RNG_END();
        } else {
            igraph_layout_sphere(graph, res);
        }
    }

    if (no_nodes <= 1) {
        return 0;
    }

    IGRAPH_MATRIX_INIT_FINALLY(&dij, no_nodes, no_nodes);
    IGRAPH_MATRIX_INIT_FINALLY(&kij, no_nodes, no_nodes);
    IGRAPH_MATRIX_INIT_FINALLY(&lij, no_nodes, no_nodes);
    IGRAPH_CHECK(igraph_shortest_paths_dijkstra(graph, &dij, igraph_vss_all(),
                 igraph_vss_all(), weights,
                 IGRAPH_ALL));

    max_dij = 0.0;
    for (i = 0; i < no_nodes; i++) {
        for (j = i + 1; j < no_nodes; j++) {
            if (!igraph_finite(MATRIX(dij, i, j))) {
                continue;
            }
            if (MATRIX(dij, i, j) > max_dij) {
                max_dij = MATRIX(dij, i, j);
            }
        }
    }
    for (i = 0; i < no_nodes; i++) {
        for (j = 0; j < no_nodes; j++) {
            if (MATRIX(dij, i, j) > max_dij) {
                MATRIX(dij, i, j) = max_dij;
            }
        }
    }

    L = L0 / max_dij;
    for (i = 0; i < no_nodes; i++) {
        for (j = 0; j < no_nodes; j++) {
            igraph_real_t tmp = MATRIX(dij, i, j) * MATRIX(dij, i, j);
            if (i == j) {
                continue;
            }
            MATRIX(kij, i, j) = kkconst / tmp;
            MATRIX(lij, i, j) = L * MATRIX(dij, i, j);
        }
    }

    /* Initialize delta */
    IGRAPH_VECTOR_INIT_FINALLY(&D1, no_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&D2, no_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&D3, no_nodes);
    for (m = 0; m < no_nodes; m++) {
        igraph_real_t dx, dy, dz, mi_dist;
        igraph_real_t myD1 = 0.0, myD2 = 0.0, myD3 = 0.0;
        for (i = 0; i < no_nodes; i++) {
            if (i == m) {
                continue;
            }
            dx = MATRIX(*res, m, 0) - MATRIX(*res, i, 0);
            dy = MATRIX(*res, m, 1) - MATRIX(*res, i, 1);
            dz = MATRIX(*res, m, 2) - MATRIX(*res, i, 2);
            mi_dist = sqrt(dx * dx + dy * dy + dz * dz);
            myD1 += MATRIX(kij, m, i) * (dx - MATRIX(lij, m, i) * dx / mi_dist);
            myD2 += MATRIX(kij, m, i) * (dy - MATRIX(lij, m, i) * dy / mi_dist);
            myD3 += MATRIX(kij, m, i) * (dz - MATRIX(lij, m, i) * dz / mi_dist);
        }
        VECTOR(D1)[m] = myD1;
        VECTOR(D2)[m] = myD2;
        VECTOR(D3)[m] = myD3;
    }

    for (j = 0; j < maxiter; j++) {

        igraph_real_t Ax = 0.0, Ay = 0.0, Az = 0.0;
        igraph_real_t Axx = 0.0, Axy = 0.0, Axz = 0.0, Ayy = 0.0, Ayz = 0.0, Azz = 0.0;
        igraph_real_t max_delta, delta_x, delta_y, delta_z;
        igraph_real_t old_x, old_y, old_z, new_x, new_y, new_z;
        igraph_real_t detnum;

        IGRAPH_ALLOW_INTERRUPTION();

        /* Select maximal delta */
        m = 0; max_delta = -1;
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t delta = (VECTOR(D1)[i] * VECTOR(D1)[i] +
                                   VECTOR(D2)[i] * VECTOR(D2)[i] +
                                   VECTOR(D3)[i] * VECTOR(D3)[i]);
            if (delta > max_delta) {
                m = i; max_delta = delta;
            }
        }
        if (max_delta < epsilon) {
            break;
        }
        old_x = MATRIX(*res, m, 0);
        old_y = MATRIX(*res, m, 1);
        old_z = MATRIX(*res, m, 2);

        /* Calculate D1, D2 and D3, and other coefficients */
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t dx, dy, dz, dist, den, k_mi, l_mi;
            if (i == m) {
                continue;
            }
            dx = old_x - MATRIX(*res, i, 0);
            dy = old_y - MATRIX(*res, i, 1);
            dz = old_z - MATRIX(*res, i, 2);
            dist = sqrt(dx * dx + dy * dy + dz * dz);
            den = dist * (dx * dx + dy * dy + dz * dz);

            k_mi = MATRIX(kij, m, i);
            l_mi = MATRIX(lij, m, i);
            Axx += k_mi * (1 - l_mi * (dy * dy + dz * dz) / den);
            Ayy += k_mi * (1 - l_mi * (dx * dx + dz * dz) / den);
            Azz += k_mi * (1 - l_mi * (dx * dx + dy * dy) / den);
            Axy += k_mi * l_mi * dx * dy / den;
            Axz += k_mi * l_mi * dx * dz / den;
            Ayz += k_mi * l_mi * dy * dz / den;
        }
        Ax = -VECTOR(D1)[m];
        Ay = -VECTOR(D2)[m];
        Az = -VECTOR(D3)[m];

        /* Need to solve some linear equations, we just use Cramer's rule */
#define DET(a,b,c,d,e,f,g,h,i) ((a*e*i+b*f*g+c*d*h)-(c*e*g+b*d*i+a*f*h))

        detnum  = DET(Axx, Axy, Axz, Axy, Ayy, Ayz, Axz, Ayz, Azz);
        if (detnum != 0) {
            delta_x = DET(Ax, Ay, Az, Axy, Ayy, Ayz, Axz, Ayz, Azz) / detnum;
            delta_y = DET(Axx, Axy, Axz, Ax, Ay, Az, Axz, Ayz, Azz) / detnum;
            delta_z = DET(Axx, Axy, Axz, Axy, Ayy, Ayz, Ax, Ay, Az ) / detnum;
        } else {
            /* No new stable position for node m; this can happen in rare
             * cases, e.g., if the graph has two nodes only. It's best to leave
             * the node where it is. */
            delta_x = delta_y = delta_z = 0;
        }

        new_x = old_x + delta_x;
        new_y = old_y + delta_y;
        new_z = old_z + delta_z;

        /* Limits, if given */
        if (minx && new_x < VECTOR(*minx)[m]) {
            new_x = VECTOR(*minx)[m];
        }
        if (maxx && new_x > VECTOR(*maxx)[m]) {
            new_x = VECTOR(*maxx)[m];
        }
        if (miny && new_y < VECTOR(*miny)[m]) {
            new_y = VECTOR(*miny)[m];
        }
        if (maxy && new_y > VECTOR(*maxy)[m]) {
            new_y = VECTOR(*maxy)[m];
        }
        if (minz && new_z < VECTOR(*minz)[m]) {
            new_z = VECTOR(*minz)[m];
        }
        if (maxz && new_z > VECTOR(*maxz)[m]) {
            new_z = VECTOR(*maxz)[m];
        }

        /* Update delta, only with/for the affected node */
        VECTOR(D1)[m] = VECTOR(D2)[m] = VECTOR(D3)[m] = 0.0;
        for (i = 0; i < no_nodes; i++) {
            igraph_real_t old_dx, old_dy, old_dz, old_mi_dist, new_dx, new_dy, new_dz, new_mi_dist;
            if (i == m) {
                continue;
            }
            old_dx = old_x - MATRIX(*res, i, 0);
            old_dy = old_y - MATRIX(*res, i, 1);
            old_dz = old_z - MATRIX(*res, i, 2);
            old_mi_dist = sqrt(old_dx * old_dx + old_dy * old_dy +
                               old_dz * old_dz);
            new_dx = new_x - MATRIX(*res, i, 0);
            new_dy = new_y - MATRIX(*res, i, 1);
            new_dz = new_z - MATRIX(*res, i, 2);
            new_mi_dist = sqrt(new_dx * new_dx + new_dy * new_dy +
                               new_dz * new_dz);

            VECTOR(D1)[i] -= MATRIX(kij, m, i) *
                             (-old_dx + MATRIX(lij, m, i) * old_dx / old_mi_dist);
            VECTOR(D2)[i] -= MATRIX(kij, m, i) *
                             (-old_dy + MATRIX(lij, m, i) * old_dy / old_mi_dist);
            VECTOR(D3)[i] -= MATRIX(kij, m, i) *
                             (-old_dz + MATRIX(lij, m, i) * old_dz / old_mi_dist);

            VECTOR(D1)[i] += MATRIX(kij, m, i) *
                             (-new_dx + MATRIX(lij, m, i) * new_dx / new_mi_dist);
            VECTOR(D2)[i] += MATRIX(kij, m, i) *
                             (-new_dy + MATRIX(lij, m, i) * new_dy / new_mi_dist);
            VECTOR(D3)[i] += MATRIX(kij, m, i) *
                             (-new_dz + MATRIX(lij, m, i) * new_dz / new_mi_dist);

            VECTOR(D1)[m] += MATRIX(kij, m, i) *
                             (new_dx - MATRIX(lij, m, i) * new_dx / new_mi_dist);
            VECTOR(D2)[m] += MATRIX(kij, m, i) *
                             (new_dy - MATRIX(lij, m, i) * new_dy / new_mi_dist);
            VECTOR(D3)[m] += MATRIX(kij, m, i) *
                             (new_dz - MATRIX(lij, m, i) * new_dz / new_mi_dist);
        }

        /* Update coordinates*/
        MATRIX(*res, m, 0) = new_x;
        MATRIX(*res, m, 1) = new_y;
        MATRIX(*res, m, 2) = new_z;
    }

    igraph_vector_destroy(&D3);
    igraph_vector_destroy(&D2);
    igraph_vector_destroy(&D1);
    igraph_matrix_destroy(&lij);
    igraph_matrix_destroy(&kij);
    igraph_matrix_destroy(&dij);
    IGRAPH_FINALLY_CLEAN(6);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/large_graph.c0000644000175100001710000003255000000000000024402 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_progress.h"
#include "igraph_random.h"
#include "igraph_structural.h"
#include "igraph_visitor.h"

#include "core/grid.h"
#include "core/interruption.h"
#include "core/math.h"

static void igraph_i_norm2d(igraph_real_t *x, igraph_real_t *y) {
    igraph_real_t len = sqrt((*x) * (*x) + (*y) * (*y));
    if (len != 0) {
        *x /= len;
        *y /= len;
    }
}

/**
 * \function igraph_layout_lgl
 * \brief Force based layout algorithm for large graphs.
 *
 * 
 * This is a layout generator similar to the Large Graph Layout
 * algorithm and program
 * (http://lgl.sourceforge.net/). But unlike LGL, this
 * version uses a Fruchterman-Reingold style simulated annealing
 * algorithm for placing the vertices. The speedup is achieved by
 * placing the vertices on a grid and calculating the repulsion only
 * for vertices which are closer to each other than a limit.
 *
 * \param graph The (initialized) graph object to place.
 * \param res Pointer to an initialized matrix object to hold the
 *   result. It will be resized if needed.
 * \param maxit The maximum number of cooling iterations to perform
 *   for each layout step. A reasonable default is 150.
 * \param maxdelta The maximum length of the move allowed for a vertex
 *   in a single iteration. A reasonable default is the number of
 *   vertices.
 * \param area This parameter gives the area of the square on which
 *   the vertices will be placed. A reasonable default value is the
 *   number of vertices squared.
 * \param coolexp The cooling exponent. A reasonable default value is
 *   1.5.
 * \param repulserad Determines the radius at which vertex-vertex
 *   repulsion cancels out attraction of adjacent vertices. A
 *   reasonable default value is \p area times the number of vertices.
 * \param cellsize The size of the grid cells, one side of the
 *   square. A reasonable default value is the fourth root of
 *   \p area (or the square root of the number of vertices if \p area
 *   is also left at its default value).
 * \param proot The root vertex, this is placed first, its neighbors
 *   in the first iteration, second neighbors in the second, etc. If
 *   negative then a random vertex is chosen.
 * \return Error code.
 *
 * Added in version 0.2.
 *
 * Time complexity: ideally O(dia*maxit*(|V|+|E|)), |V| is the number
 * of vertices,
 * dia is the diameter of the graph, worst case complexity is still
 * O(dia*maxit*(|V|^2+|E|)), this is the case when all vertices happen to be
 * in the same grid cell.
 */

int igraph_layout_lgl(const igraph_t *graph, igraph_matrix_t *res,
                      igraph_integer_t maxit, igraph_real_t maxdelta,
                      igraph_real_t area, igraph_real_t coolexp,
                      igraph_real_t repulserad, igraph_real_t cellsize,
                      igraph_integer_t proot) {


    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_t mst;
    long int root;
    long int no_of_layers, actlayer = 0;
    igraph_vector_t vids;
    igraph_vector_t layers;
    igraph_vector_t parents;
    igraph_vector_t edges;
    igraph_2dgrid_t grid;
    igraph_vector_t eids;
    igraph_vector_t forcex;
    igraph_vector_t forcey;

    igraph_real_t frk = sqrt(area / no_of_nodes);
    igraph_real_t H_n = 0;

    IGRAPH_CHECK(igraph_minimum_spanning_tree_unweighted(graph, &mst));
    IGRAPH_FINALLY(igraph_destroy, &mst);

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));

    /* Determine the root vertex, random pick right now */
    if (proot < 0) {
        root = RNG_INTEGER(0, no_of_nodes - 1);
    } else {
        root = proot;
    }

    /* Assign the layers */
    IGRAPH_VECTOR_INIT_FINALLY(&vids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&layers, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&parents, 0);
    IGRAPH_CHECK(igraph_bfs_simple(&mst, (igraph_integer_t) root, IGRAPH_ALL, &vids,
                                   &layers, &parents));
    no_of_layers = igraph_vector_size(&layers) - 1;

    /* We don't need the mst any more */
    igraph_destroy(&mst);
    igraph_empty(&mst, 0, IGRAPH_UNDIRECTED); /* to make finalization work */

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges));
    IGRAPH_VECTOR_INIT_FINALLY(&eids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&forcex, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&forcey, no_of_nodes);

    /* Place the vertices randomly */
    IGRAPH_CHECK(igraph_layout_random(graph, res));
    igraph_matrix_scale(res, 1e6);

    /* This is the grid for calculating the vertices near to a given vertex */
    IGRAPH_CHECK(igraph_2dgrid_init(&grid, res,
                                    -sqrt(area / M_PI), sqrt(area / M_PI), cellsize,
                                    -sqrt(area / M_PI), sqrt(area / M_PI), cellsize));
    IGRAPH_FINALLY(igraph_2dgrid_destroy, &grid);

    /* Place the root vertex */
    igraph_2dgrid_add(&grid, root, 0, 0);

    for (actlayer = 1; actlayer < no_of_layers; actlayer++) {
        H_n += 1.0 / actlayer;
    }

    for (actlayer = 1; actlayer < no_of_layers; actlayer++) {

        igraph_real_t c = 1;
        long int i, j;
        igraph_real_t massx, massy;
        igraph_real_t px, py;
        igraph_real_t sx, sy;

        long int it = 0;
        igraph_real_t epsilon = 10e-6;
        igraph_real_t maxchange = epsilon + 1;
        long int pairs;
        igraph_real_t sconst = sqrt(area / M_PI) / H_n;
        igraph_2dgrid_iterator_t vidit;

        /*     printf("Layer %li:\n", actlayer); */

        /*-----------------------------------------*/
        /* Step 1: place the next layer on spheres */
        /*-----------------------------------------*/

        RNG_BEGIN();

        j = (long int) VECTOR(layers)[actlayer];
        for (i = (long int) VECTOR(layers)[actlayer - 1];
             i < VECTOR(layers)[actlayer]; i++) {

            long int vid = (long int) VECTOR(vids)[i];
            long int par = (long int) VECTOR(parents)[vid];
            IGRAPH_ALLOW_INTERRUPTION();
            igraph_2dgrid_getcenter(&grid, &massx, &massy);
            igraph_i_norm2d(&massx, &massy);
            px = MATRIX(*res, vid, 0) - MATRIX(*res, par, 0);
            py = MATRIX(*res, vid, 1) - MATRIX(*res, par, 1);
            igraph_i_norm2d(&px, &py);
            sx = c * (massx + px) + MATRIX(*res, vid, 0);
            sy = c * (massy + py) + MATRIX(*res, vid, 1);

            /* The neighbors of 'vid' */
            while (j < VECTOR(layers)[actlayer + 1] &&
                   VECTOR(parents)[(long int)VECTOR(vids)[j]] == vid) {
                igraph_real_t rx, ry;
                if (actlayer == 1) {
                    igraph_real_t phi = 2 * M_PI / (VECTOR(layers)[2] - 1) * (j - 1);
                    rx = cos(phi);
                    ry = sin(phi);
                } else {
                    rx = RNG_UNIF(-1, 1);
                    ry = RNG_UNIF(-1, 1);
                }
                igraph_i_norm2d(&rx, &ry);
                rx = rx / actlayer * sconst;
                ry = ry / actlayer * sconst;
                igraph_2dgrid_add(&grid, (long int) VECTOR(vids)[j], sx + rx, sy + ry);
                j++;
            }
        }

        RNG_END();

        /*-----------------------------------------*/
        /* Step 2: add the edges of the next layer */
        /*-----------------------------------------*/

        for (j = (long int) VECTOR(layers)[actlayer];
             j < VECTOR(layers)[actlayer + 1]; j++) {
            long int vid = (long int) VECTOR(vids)[j];
            long int k;
            IGRAPH_ALLOW_INTERRUPTION();
            IGRAPH_CHECK(igraph_incident(graph, &eids, (igraph_integer_t) vid,
                                         IGRAPH_ALL));
            for (k = 0; k < igraph_vector_size(&eids); k++) {
                long int eid = (long int) VECTOR(eids)[k];
                igraph_integer_t from, to;
                igraph_edge(graph, (igraph_integer_t) eid, &from, &to);
                if ((from != vid && igraph_2dgrid_in(&grid, from)) ||
                    (to   != vid && igraph_2dgrid_in(&grid, to))) {
                    igraph_vector_push_back(&edges, eid);
                }
            }
        }

        /*-----------------------------------------*/
        /* Step 3: let the springs spring          */
        /*-----------------------------------------*/

        maxchange = epsilon + 1;
        while (it < maxit && maxchange > epsilon) {
            long int jj;
            igraph_real_t t = maxdelta * pow((maxit - it) / (double)maxit, coolexp);
            long int vid, nei;

            IGRAPH_PROGRESS("Large graph layout",
                            100.0 * ((actlayer - 1.0) / (no_of_layers - 1.0) + ((float)it) / (maxit * (no_of_layers - 1.0))),
                            0);

            /* init */
            igraph_vector_null(&forcex);
            igraph_vector_null(&forcey);
            maxchange = 0;

            /* attractive "forces" along the edges */
            for (jj = 0; jj < igraph_vector_size(&edges); jj++) {
                igraph_integer_t from, to;
                igraph_real_t xd, yd, dist, force;
                IGRAPH_ALLOW_INTERRUPTION();
                igraph_edge(graph, (igraph_integer_t) VECTOR(edges)[jj], &from, &to);
                xd = MATRIX(*res, (long int)from, 0) - MATRIX(*res, (long int)to, 0);
                yd = MATRIX(*res, (long int)from, 1) - MATRIX(*res, (long int)to, 1);
                dist = sqrt(xd * xd + yd * yd);
                if (dist != 0) {
                    xd /= dist;
                    yd /= dist;
                }
                force = dist * dist / frk;
                VECTOR(forcex)[(long int)from] -= xd * force;
                VECTOR(forcex)[(long int)to]   += xd * force;
                VECTOR(forcey)[(long int)from] -= yd * force;
                VECTOR(forcey)[(long int)to]   += yd * force;
            }

            /* repulsive "forces" of the vertices nearby */
            pairs = 0;
            igraph_2dgrid_reset(&grid, &vidit);
            while ( (vid = igraph_2dgrid_next(&grid, &vidit) - 1) != -1) {
                while ( (nei = igraph_2dgrid_next_nei(&grid, &vidit) - 1) != -1) {
                    igraph_real_t xd = MATRIX(*res, (long int)vid, 0) -
                                       MATRIX(*res, (long int)nei, 0);
                    igraph_real_t yd = MATRIX(*res, (long int)vid, 1) -
                                       MATRIX(*res, (long int)nei, 1);
                    igraph_real_t dist = sqrt(xd * xd + yd * yd);
                    igraph_real_t force;
                    if (dist < cellsize) {
                        pairs++;
                        if (dist == 0) {
                            dist = epsilon;
                        };
                        xd /= dist; yd /= dist;
                        force = frk * frk * (1.0 / dist - dist * dist / repulserad);
                        VECTOR(forcex)[(long int)vid] += xd * force;
                        VECTOR(forcex)[(long int)nei] -= xd * force;
                        VECTOR(forcey)[(long int)vid] += yd * force;
                        VECTOR(forcey)[(long int)nei] -= yd * force;
                    }
                }
            }

            /*       printf("verties: %li iterations: %li\n",  */
            /*       (long int) VECTOR(layers)[actlayer+1], pairs); */

            /* apply the changes */
            for (jj = 0; jj < VECTOR(layers)[actlayer + 1]; jj++) {
                long int vvid = (long int) VECTOR(vids)[jj];
                igraph_real_t fx = VECTOR(forcex)[vvid];
                igraph_real_t fy = VECTOR(forcey)[vvid];
                igraph_real_t ded = sqrt(fx * fx + fy * fy);
                if (ded > t) {
                    ded = t / ded;
                    fx *= ded; fy *= ded;
                }
                igraph_2dgrid_move(&grid, vvid, fx, fy);
                if (fx > maxchange) {
                    maxchange = fx;
                }
                if (fy > maxchange) {
                    maxchange = fy;
                }
            }
            it++;
            /*       printf("%li iterations, maxchange: %f\n", it, (double)maxchange); */
        }
    }

    IGRAPH_PROGRESS("Large graph layout", 100.0, 0);
    igraph_destroy(&mst);
    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&layers);
    igraph_vector_destroy(&parents);
    igraph_vector_destroy(&edges);
    igraph_2dgrid_destroy(&grid);
    igraph_vector_destroy(&eids);
    igraph_vector_destroy(&forcex);
    igraph_vector_destroy(&forcey);
    IGRAPH_FINALLY_CLEAN(9);
    return 0;

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/layout_bipartite.c0000644000175100001710000000606400000000000025510 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"

/**
 * \function igraph_layout_bipartite
 * Simple layout for bipartite graphs.
 *
 * The layout is created by first placing the vertices in two rows,
 * according to their types. Then the positions within the rows are
 * optimized to minimize edge crossings, by calling \ref
 * igraph_layout_sugiyama().
 *
 * \param graph The input graph.
 * \param types A boolean vector containing ones and zeros, the vertex
 *     types. Its length must match the number of vertices in the graph.
 * \param res Pointer to an initialized matrix, the result, the x and
 *     y coordinates are stored here.
 * \param hgap The preferred minimum horizontal gap between vertices
 *     in the same layer (i.e. vertices of the same type).
 * \param vgap  The distance between layers.
 * \param maxiter Maximum number of iterations in the crossing
 *     minimization stage. 100 is a reasonable default; if you feel
 *     that you have too many edge crossings, increase this.
 * \return Error code.
 *
 * \sa \ref igraph_layout_sugiyama().
 */
int igraph_layout_bipartite(const igraph_t *graph,
                            const igraph_vector_bool_t *types,
                            igraph_matrix_t *res, igraph_real_t hgap,
                            igraph_real_t vgap, long int maxiter) {

    long int i, no_of_nodes = igraph_vcount(graph);
    igraph_vector_t layers;

    if (igraph_vector_bool_size(types) != no_of_nodes) {
        IGRAPH_ERRORF("The vertex type vector size (%ld) should be equal to the number of nodes (%ld).",
                      IGRAPH_EINVAL, igraph_vector_bool_size(types), no_of_nodes);
    }
    if (hgap < 0) {
        IGRAPH_ERRORF("The horizontal gap cannot be negative, got %f.", IGRAPH_EINVAL, hgap);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&layers, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(layers)[i] = VECTOR(*types)[i] ? 0 : 1;
    }

    IGRAPH_CHECK(igraph_layout_sugiyama(graph, res, /*extd_graph=*/ 0,
                                        /*extd_to_orig_eids=*/ 0, &layers, hgap,
                                        vgap, maxiter, /*weights=*/ 0));

    igraph_vector_destroy(&layers);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/layout_grid.c0000644000175100001710000000723200000000000024450 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"

/**
 * \ingroup layout
 * \function igraph_layout_grid
 * \brief Places the vertices on a regular grid on the plane.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param width The number of vertices in a single row of the grid.
 *        When zero or negative, the width of the grid will be the
 *        square root of the number of vertices, rounded up if needed.
 * \return Error code. The current implementation always returns with
 *         success.
 *
 * Time complexity: O(|V|), the number of vertices.
 */
int igraph_layout_grid(const igraph_t *graph, igraph_matrix_t *res, long int width) {
    long int i, no_of_nodes = igraph_vcount(graph);
    igraph_real_t x, y;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));

    if (width <= 0) {
        width = (long int) ceil(sqrt(no_of_nodes));
    }

    x = y = 0;
    for (i = 0; i < no_of_nodes; i++) {
        MATRIX(*res, i, 0) = x++;
        MATRIX(*res, i, 1) = y;
        if (x == width) {
            x = 0; y++;
        }
    }

    return 0;
}

/**
 * \ingroup layout
 * \function igraph_layout_grid_3d
 * \brief Places the vertices on a regular grid in the 3D space.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \param width  The number of vertices in a single row of the grid. When
 *               zero or negative, the width is determined automatically.
 * \param height The number of vertices in a single column of the grid. When
 *               zero or negative, the height is determined automatically.
 *
 * \return Error code. The current implementation always returns with
 *         success.
 *
 * Time complexity: O(|V|), the number of vertices.
 */
int igraph_layout_grid_3d(const igraph_t *graph, igraph_matrix_t *res,
                          long int width, long int height) {
    long int i, no_of_nodes = igraph_vcount(graph);
    igraph_real_t x, y, z;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 3));

    if (width <= 0 && height <= 0) {
        width = height = (long int) ceil(pow(no_of_nodes, 1.0 / 3));
    } else if (width <= 0) {
        width = (long int) ceil(sqrt(no_of_nodes / (double)height));
    } else if (height <= 0) {
        height = (long int) ceil(sqrt(no_of_nodes / (double)width));
    }

    x = y = z = 0;
    for (i = 0; i < no_of_nodes; i++) {
        MATRIX(*res, i, 0) = x++;
        MATRIX(*res, i, 1) = y;
        MATRIX(*res, i, 2) = z;
        if (x == width) {
            x = 0; y++;
            if (y == height) {
                y = 0; z++;
            }
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/layout_internal.h0000644000175100001710000000463000000000000025343 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_LAYOUT_INTERNAL_H
#define IGRAPH_LAYOUT_INTERNAL_H

#include "igraph_types.h"

#include "layout/merge_grid.h"

__BEGIN_DECLS

IGRAPH_PRIVATE_EXPORT int igraph_i_layout_merge_dla(igraph_i_layout_mergegrid_t *grid,
                                                    long int actg, igraph_real_t *x, igraph_real_t *y, igraph_real_t r,
                                                    igraph_real_t cx, igraph_real_t cy, igraph_real_t startr,
                                                    igraph_real_t killr);

IGRAPH_PRIVATE_EXPORT int igraph_i_layout_sphere_2d(igraph_matrix_t *coords, igraph_real_t *x,
                                                    igraph_real_t *y, igraph_real_t *r);

IGRAPH_PRIVATE_EXPORT int igraph_i_layout_sphere_3d(igraph_matrix_t *coords, igraph_real_t *x,
                                                    igraph_real_t *y, igraph_real_t *z,
                                                    igraph_real_t *r);

IGRAPH_PRIVATE_EXPORT float igraph_i_layout_point_segment_dist2(float v_x, float v_y,
                                                                float u1_x, float u1_y,
                                                                float u2_x, float u2_y);

IGRAPH_PRIVATE_EXPORT igraph_bool_t igraph_i_layout_segments_intersect(float p0_x, float p0_y,
                                                                       float p1_x, float p1_y,
                                                                       float p2_x, float p2_y,
                                                                       float p3_x, float p3_y);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/layout_random.c0000644000175100001710000000533400000000000025004 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_interface.h"
#include "igraph_random.h"

/**
 * \ingroup layout
 * \function igraph_layout_random
 * \brief Places the vertices uniform randomly on a plane.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized as needed.
 * \return Error code. The current implementation always returns with
 * success.
 *
 * Time complexity: O(|V|), the
 * number of vertices.
 */
int igraph_layout_random(const igraph_t *graph, igraph_matrix_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));

    RNG_BEGIN();

    for (i = 0; i < no_of_nodes; i++) {
        MATRIX(*res, i, 0) = RNG_UNIF(-1, 1);
        MATRIX(*res, i, 1) = RNG_UNIF(-1, 1);
    }

    RNG_END();

    return 0;
}

/**
 * \function igraph_layout_random_3d
 * \brief Places the vertices uniform randomly in a cube.
 *
 * 
 * Vertex coordinates range from -1 to 1, and are placed in 3 columns
 * of a matrix, with a row for each vertex.
 *
 * \param graph The graph to place.
 * \param res Pointer to an initialized matrix object. It will be
 * resized to hold the result.
 * \return Error code. The current implementation always returns with
 * success.
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|), the number of vertices.
 */
int igraph_layout_random_3d(const igraph_t *graph, igraph_matrix_t *res) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 3));

    RNG_BEGIN();

    for (i = 0; i < no_of_nodes; i++) {
        MATRIX(*res, i, 0) = RNG_UNIF(-1, 1);
        MATRIX(*res, i, 1) = RNG_UNIF(-1, 1);
        MATRIX(*res, i, 2) = RNG_UNIF(-1, 1);
    }

    RNG_END();

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/mds.c0000644000175100001710000002726200000000000022716 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_blas.h"
#include "igraph_components.h"
#include "igraph_eigen.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_paths.h"
#include "igraph_random.h"
#include "igraph_structural.h"

static int igraph_i_layout_mds_step(igraph_real_t *to, const igraph_real_t *from,
                                    int n, void *extra);

static int igraph_i_layout_mds_single(const igraph_t* graph, igraph_matrix_t *res,
                                      igraph_matrix_t *dist, long int dim);

static int igraph_i_layout_mds_step(igraph_real_t *to, const igraph_real_t *from,
                                    int n, void *extra) {
    igraph_matrix_t* matrix = (igraph_matrix_t*)extra;
    IGRAPH_UNUSED(n);
    igraph_blas_dgemv_array(0, 1, matrix, from, 0, to);
    return 0;
}

/* MDS layout for a connected graph, with no error checking on the
 * input parameters. The distance matrix will be modified in-place. */
int igraph_i_layout_mds_single(const igraph_t* graph, igraph_matrix_t *res,
                               igraph_matrix_t *dist, long int dim) {

    long int no_of_nodes = igraph_vcount(graph);
    long int nev = dim;
    igraph_matrix_t vectors;
    igraph_vector_t values, row_means;
    igraph_real_t grand_mean;
    long int i, j, k;
    igraph_eigen_which_t which;

    /* Handle the trivial cases */
    if (no_of_nodes == 1) {
        IGRAPH_CHECK(igraph_matrix_resize(res, 1, dim));
        igraph_matrix_fill(res, 0);
        return IGRAPH_SUCCESS;
    }
    if (no_of_nodes == 2) {
        IGRAPH_CHECK(igraph_matrix_resize(res, 2, dim));
        igraph_matrix_fill(res, 0);
        for (j = 0; j < dim; j++) {
            MATRIX(*res, 1, j) = 1;
        }
        return IGRAPH_SUCCESS;
    }

    /* Initialize some stuff */
    IGRAPH_VECTOR_INIT_FINALLY(&values, no_of_nodes);
    IGRAPH_CHECK(igraph_matrix_init(&vectors, no_of_nodes, dim));
    IGRAPH_FINALLY(igraph_matrix_destroy, &vectors);

    /* Take the square of the distance matrix */
    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j < no_of_nodes; j++) {
            MATRIX(*dist, i, j) *= MATRIX(*dist, i, j);
        }
    }

    /* Double centering of the distance matrix */
    IGRAPH_VECTOR_INIT_FINALLY(&row_means, no_of_nodes);
    igraph_vector_fill(&values, 1.0 / no_of_nodes);
    igraph_blas_dgemv(0, 1, dist, &values, 0, &row_means);
    grand_mean = igraph_vector_sum(&row_means) / no_of_nodes;
    igraph_matrix_add_constant(dist, grand_mean);
    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0; j < no_of_nodes; j++) {
            MATRIX(*dist, i, j) -= VECTOR(row_means)[i] + VECTOR(row_means)[j];
            MATRIX(*dist, i, j) *= -0.5;
        }
    }
    igraph_vector_destroy(&row_means);
    IGRAPH_FINALLY_CLEAN(1);

    /* Calculate the top `dim` eigenvectors. */
    which.pos = IGRAPH_EIGEN_LA;
    which.howmany = (int) nev;
    IGRAPH_CHECK(igraph_eigen_matrix_symmetric(/*A=*/ 0, /*sA=*/ 0,
                 /*fun=*/ igraph_i_layout_mds_step,
                 /*n=*/ (int) no_of_nodes, /*extra=*/ dist,
                 /*algorithm=*/ IGRAPH_EIGEN_LAPACK,
                 &which, /*options=*/ 0, /*storage=*/ 0,
                 &values, &vectors));

    /* Calculate and normalize the final coordinates */
    for (j = 0; j < nev; j++) {
        VECTOR(values)[j] = sqrt(fabs(VECTOR(values)[j]));
    }
    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, dim));
    for (i = 0; i < no_of_nodes; i++) {
        for (j = 0, k = nev - 1; j < nev; j++, k--) {
            MATRIX(*res, i, k) = VECTOR(values)[j] * MATRIX(vectors, i, j);
        }
    }

    igraph_matrix_destroy(&vectors);
    igraph_vector_destroy(&values);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_layout_mds
 * \brief Place the vertices on a plane using multidimensional scaling.
 *
 * 
 * This layout requires a distance matrix, where the intersection of
 * row i and column j specifies the desired distance between vertex i
 * and vertex j. The algorithm will try to place the vertices in a
 * space having a given number of dimensions in a way that approximates
 * the distance relations prescribed in the distance matrix. igraph
 * uses the classical multidimensional scaling by Torgerson; for more
 * details, see Cox & Cox: Multidimensional Scaling (1994), Chapman
 * and Hall, London.
 *
 * 
 * If the input graph is disconnected, igraph will decompose it
 * first into its subgraphs, lay out the subgraphs one by one
 * using the appropriate submatrices of the distance matrix, and
 * then merge the layouts using \ref igraph_layout_merge_dla.
 * Since \ref igraph_layout_merge_dla works for 2D layouts only,
 * you cannot run the MDS layout on disconnected graphs for
 * more than two dimensions.
 *
 * 
 * Warning: if the graph is symmetric to the exchange of two vertices
 * (as is the case with leaves of a tree connecting to the same parent),
 * classical multidimensional scaling may assign the same coordinates to
 * these vertices.
 *
 * \param graph A graph object.
 * \param res Pointer to an initialized matrix object. This will
 *        contain the result and will be resized if needed.
 * \param dist The distance matrix. It must be symmetric and this
 *        function does not check whether the matrix is indeed
 *        symmetric. Results are unspecified if you pass a non-symmetric
 *        matrix here. You can set this parameter to null; in this
 *        case, the shortest path lengths between vertices will be
 *        used as distances.
 * \param dim The number of dimensions in the embedding space. For
 *        2D layouts, supply 2 here.
 * \return Error code.
 *
 * Added in version 0.6.
 *
 * 
 * Time complexity: usually around O(|V|^2 dim).
 */

int igraph_layout_mds(const igraph_t* graph, igraph_matrix_t *res,
                      const igraph_matrix_t *dist, long int dim) {
    long int i, no_of_nodes = igraph_vcount(graph);
    igraph_matrix_t m;
    igraph_bool_t conn;

    RNG_BEGIN();

    /* Check the distance matrix */
    if (dist && (igraph_matrix_nrow(dist) != no_of_nodes ||
                 igraph_matrix_ncol(dist) != no_of_nodes)) {
        IGRAPH_ERROR("invalid distance matrix size", IGRAPH_EINVAL);
    }

    /* Check the number of dimensions */
    if (dim <= 1) {
        IGRAPH_ERROR("dim must be positive", IGRAPH_EINVAL);
    }
    if (dim > no_of_nodes) {
        IGRAPH_ERROR("dim must be less than the number of nodes", IGRAPH_EINVAL);
    }

    /* Copy or obtain the distance matrix */
    if (dist == 0) {
        IGRAPH_CHECK(igraph_matrix_init(&m, no_of_nodes, no_of_nodes));
        IGRAPH_FINALLY(igraph_matrix_destroy, &m);
        IGRAPH_CHECK(igraph_shortest_paths(graph, &m,
                                           igraph_vss_all(), igraph_vss_all(), IGRAPH_ALL));
    } else {
        IGRAPH_CHECK(igraph_matrix_copy(&m, dist));
        IGRAPH_FINALLY(igraph_matrix_destroy, &m);
        /* Make sure that the diagonal contains zeroes only */
        for (i = 0; i < no_of_nodes; i++) {
            MATRIX(m, i, i) = 0.0;
        }
    }

    /* Check whether the graph is connected */
    IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
    if (conn) {
        /* Yes, it is, just do the MDS */
        IGRAPH_CHECK(igraph_i_layout_mds_single(graph, res, &m, dim));
    } else {
        /* The graph is not connected, lay out the components one by one */
        igraph_vector_ptr_t layouts;
        igraph_vector_t comp, vertex_order;
        igraph_t subgraph;
        igraph_matrix_t *layout;
        igraph_matrix_t dist_submatrix;
        igraph_bool_t *seen_vertices;
        long int j, n, processed_vertex_count = 0;

        IGRAPH_VECTOR_INIT_FINALLY(&comp, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&vertex_order, no_of_nodes);

        IGRAPH_CHECK(igraph_vector_ptr_init(&layouts, 0));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &layouts);
        igraph_vector_ptr_set_item_destructor(&layouts, (igraph_finally_func_t*)igraph_matrix_destroy);

        IGRAPH_CHECK(igraph_matrix_init(&dist_submatrix, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &dist_submatrix);

        seen_vertices = IGRAPH_CALLOC(no_of_nodes, igraph_bool_t);
        if (seen_vertices == 0) {
            IGRAPH_ERROR("cannot calculate MDS layout", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, seen_vertices);

        for (i = 0; i < no_of_nodes; i++) {
            if (seen_vertices[i]) {
                continue;
            }

            /* This is a vertex whose component we did not lay out so far */
            IGRAPH_CHECK(igraph_subcomponent(graph, &comp, i, IGRAPH_ALL));
            /* Take the subgraph */
            IGRAPH_CHECK(igraph_induced_subgraph(graph, &subgraph, igraph_vss_vector(&comp),
                                                 IGRAPH_SUBGRAPH_AUTO));
            IGRAPH_FINALLY(igraph_destroy, &subgraph);
            /* Calculate the submatrix of the distances */
            IGRAPH_CHECK(igraph_matrix_select_rows_cols(&m, &dist_submatrix,
                         &comp, &comp));
            /* Allocate a new matrix for storing the layout */
            layout = IGRAPH_CALLOC(1, igraph_matrix_t);
            if (layout == 0) {
                IGRAPH_ERROR("cannot calculate MDS layout", IGRAPH_ENOMEM);
            }
            IGRAPH_FINALLY(igraph_free, layout);
            IGRAPH_CHECK(igraph_matrix_init(layout, 0, 0));
            IGRAPH_FINALLY(igraph_matrix_destroy, layout);
            /* Lay out the subgraph */
            IGRAPH_CHECK(igraph_i_layout_mds_single(&subgraph, layout, &dist_submatrix, dim));
            /* Store the layout */
            IGRAPH_CHECK(igraph_vector_ptr_push_back(&layouts, layout));
            IGRAPH_FINALLY_CLEAN(2);  /* ownership of layout taken by layouts */
            /* Free the newly created subgraph */
            igraph_destroy(&subgraph);
            IGRAPH_FINALLY_CLEAN(1);
            /* Mark all the vertices in the component as visited */
            n = igraph_vector_size(&comp);
            for (j = 0; j < n; j++) {
                seen_vertices[(long int)VECTOR(comp)[j]] = 1;
                VECTOR(vertex_order)[(long int)VECTOR(comp)[j]] = processed_vertex_count++;
            }
        }
        /* Merge the layouts - reusing dist_submatrix here */
        IGRAPH_CHECK(igraph_layout_merge_dla(0, &layouts, &dist_submatrix));
        /* Reordering the rows of res to match the original graph */
        IGRAPH_CHECK(igraph_matrix_select_rows(&dist_submatrix, res, &vertex_order));

        igraph_free(seen_vertices);
        igraph_matrix_destroy(&dist_submatrix);
        igraph_vector_ptr_destroy_all(&layouts);
        igraph_vector_destroy(&vertex_order);
        igraph_vector_destroy(&comp);
        IGRAPH_FINALLY_CLEAN(5);
    }

    RNG_END();

    igraph_matrix_destroy(&m);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/merge_dla.c0000644000175100001710000002324500000000000024047 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"
#include "igraph_progress.h"
#include "igraph_random.h"

#include "core/grid.h"
#include "core/interruption.h"
#include "core/math.h"
#include "layout/merge_grid.h"
#include "layout/layout_internal.h"

/**
 * \function igraph_layout_merge_dla
 * \brief Merge multiple layouts by using a DLA algorithm
 *
 * 
 * First each layout is covered by a circle. Then the layout of the
 * largest graph is placed at the origin. Then the other layouts are
 * placed by the DLA algorithm, larger ones first and smaller ones
 * last.
 * \param thegraphs Pointer vector containing the graph objects of
 *        which the layouts will be merged.
 * \param coords Pointer vector containing matrix objects with the 2d
 *        layouts of the graphs in \p thegraphs.
 * \param res Pointer to an initialized matrix object, the result will
 *        be stored here. It will be resized if needed.
 * \return Error code.
 *
 * Added in version 0.2. This function is experimental.
 *
 * 
 * Time complexity: TODO.
 */

int igraph_layout_merge_dla(const igraph_vector_ptr_t *thegraphs,
                            const igraph_vector_ptr_t *coords,
                            igraph_matrix_t *res) {
    long int graphs = igraph_vector_ptr_size(coords);
    igraph_vector_t sizes;
    igraph_vector_t x, y, r;
    igraph_vector_t nx, ny, nr;
    long int allnodes = 0;
    long int i, j;
    long int actg;
    igraph_i_layout_mergegrid_t grid;
    long int jpos = 0;
    igraph_real_t minx, maxx, miny, maxy;
    igraph_real_t area = 0;
    igraph_real_t maxr = 0;
    long int respos;

    /* Graphs are currently not used, only the coordinates */
    IGRAPH_UNUSED(thegraphs);

    IGRAPH_VECTOR_INIT_FINALLY(&sizes, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&x, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&y, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&r, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&nx, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&ny, graphs);
    IGRAPH_VECTOR_INIT_FINALLY(&nr, graphs);

    RNG_BEGIN();

    for (i = 0; i < igraph_vector_ptr_size(coords); i++) {
        igraph_matrix_t *mat = VECTOR(*coords)[i];
        long int size = igraph_matrix_nrow(mat);

        if (igraph_matrix_ncol(mat) != 2) {
            IGRAPH_ERROR("igraph_layout_merge_dla works for 2D layouts only",
                         IGRAPH_EINVAL);
        }

        IGRAPH_ALLOW_INTERRUPTION();
        allnodes += size;
        VECTOR(sizes)[i] = size;
        VECTOR(r)[i] = pow(size, .75);
        area += VECTOR(r)[i] * VECTOR(r)[i];
        if (VECTOR(r)[i] > maxr) {
            maxr = VECTOR(r)[i];
        }

        igraph_i_layout_sphere_2d(mat,
                                  igraph_vector_e_ptr(&nx, i),
                                  igraph_vector_e_ptr(&ny, i),
                                  igraph_vector_e_ptr(&nr, i));

    }
    igraph_vector_order2(&sizes); /* largest first */

    /* 0. create grid */
    minx = miny = -sqrt(5 * area);
    maxx = maxy = sqrt(5 * area);
    igraph_i_layout_mergegrid_init(&grid, minx, maxx, 200,
                                   miny, maxy, 200);
    IGRAPH_FINALLY(igraph_i_layout_mergegrid_destroy, &grid);

    /*   fprintf(stderr, "Ok, starting DLA\n"); */

    /* 1. place the largest  */
    actg = (long int) VECTOR(sizes)[jpos++];
    igraph_i_layout_merge_place_sphere(&grid, 0, 0, VECTOR(r)[actg], actg);

    IGRAPH_PROGRESS("Merging layouts via DLA", 0.0, NULL);
    while (jpos < graphs) {
        IGRAPH_ALLOW_INTERRUPTION();
        /*     fprintf(stderr, "comp: %li", jpos); */
        IGRAPH_PROGRESS("Merging layouts via DLA", (100.0 * jpos) / graphs, NULL);

        actg = (long int) VECTOR(sizes)[jpos++];
        /* 2. random walk, TODO: tune parameters */
        igraph_i_layout_merge_dla(&grid, actg,
                                  igraph_vector_e_ptr(&x, actg),
                                  igraph_vector_e_ptr(&y, actg),
                                  VECTOR(r)[actg], 0, 0,
                                  maxx, maxx + 5);

        /* 3. place sphere */
        igraph_i_layout_merge_place_sphere(&grid, VECTOR(x)[actg], VECTOR(y)[actg],
                                           VECTOR(r)[actg], actg);
    }
    IGRAPH_PROGRESS("Merging layouts via DLA", 100.0, NULL);

    /* Create the result */
    IGRAPH_CHECK(igraph_matrix_resize(res, allnodes, 2));
    respos = 0;
    for (i = 0; i < graphs; i++) {
        long int size = igraph_matrix_nrow(VECTOR(*coords)[i]);
        igraph_real_t xx = VECTOR(x)[i];
        igraph_real_t yy = VECTOR(y)[i];
        igraph_real_t rr = VECTOR(r)[i] / VECTOR(nr)[i];
        igraph_matrix_t *mat = VECTOR(*coords)[i];
        IGRAPH_ALLOW_INTERRUPTION();
        if (VECTOR(nr)[i] == 0) {
            rr = 1;
        }
        for (j = 0; j < size; j++) {
            MATRIX(*res, respos, 0) = rr * (MATRIX(*mat, j, 0) - VECTOR(nx)[i]);
            MATRIX(*res, respos, 1) = rr * (MATRIX(*mat, j, 1) - VECTOR(ny)[i]);
            MATRIX(*res, respos, 0) += xx;
            MATRIX(*res, respos, 1) += yy;
            ++respos;
        }
    }

    RNG_END();

    igraph_i_layout_mergegrid_destroy(&grid);
    igraph_vector_destroy(&sizes);
    igraph_vector_destroy(&x);
    igraph_vector_destroy(&y);
    igraph_vector_destroy(&r);
    igraph_vector_destroy(&nx);
    igraph_vector_destroy(&ny);
    igraph_vector_destroy(&nr);
    IGRAPH_FINALLY_CLEAN(8);
    return 0;
}

int igraph_i_layout_sphere_2d(igraph_matrix_t *coords,
                              igraph_real_t *x, igraph_real_t *y,
                              igraph_real_t *r) {
    long int nodes = igraph_matrix_nrow(coords);
    long int i;
    igraph_real_t xmin, xmax, ymin, ymax;

    xmin = xmax = MATRIX(*coords, 0, 0);
    ymin = ymax = MATRIX(*coords, 0, 1);
    for (i = 1; i < nodes; i++) {

        if (MATRIX(*coords, i, 0) < xmin) {
            xmin = MATRIX(*coords, i, 0);
        } else if (MATRIX(*coords, i, 0) > xmax) {
            xmax = MATRIX(*coords, i, 0);
        }

        if (MATRIX(*coords, i, 1) < ymin) {
            ymin = MATRIX(*coords, i, 1);
        } else if (MATRIX(*coords, i, 1) > ymax) {
            ymax = MATRIX(*coords, i, 1);
        }

    }

    *x = (xmin + xmax) / 2;
    *y = (ymin + ymax) / 2;
    *r = sqrt( (xmax - xmin) * (xmax - xmin) + (ymax - ymin) * (ymax - ymin) ) / 2;

    return 0;
}

int igraph_i_layout_sphere_3d(igraph_matrix_t *coords,
                              igraph_real_t *x, igraph_real_t *y,
                              igraph_real_t *z, igraph_real_t *r) {
    long int nodes = igraph_matrix_nrow(coords);
    long int i;
    igraph_real_t xmin, xmax, ymin, ymax, zmin, zmax;

    xmin = xmax = MATRIX(*coords, 0, 0);
    ymin = ymax = MATRIX(*coords, 0, 1);
    zmin = zmax = MATRIX(*coords, 0, 2);
    for (i = 1; i < nodes; i++) {

        if (MATRIX(*coords, i, 0) < xmin) {
            xmin = MATRIX(*coords, i, 0);
        } else if (MATRIX(*coords, i, 0) > xmax) {
            xmax = MATRIX(*coords, i, 0);
        }

        if (MATRIX(*coords, i, 1) < ymin) {
            ymin = MATRIX(*coords, i, 1);
        } else if (MATRIX(*coords, i, 1) > ymax) {
            ymax = MATRIX(*coords, i, 1);
        }

        if (MATRIX(*coords, i, 2) < zmin) {
            zmin = MATRIX(*coords, i, 2);
        } else if (MATRIX(*coords, i, 2) > zmax) {
            zmax = MATRIX(*coords, i, 2);
        }

    }

    *x = (xmin + xmax) / 2;
    *y = (ymin + ymax) / 2;
    *z = (zmin + zmax) / 2;
    *r = sqrt( (xmax - xmin) * (xmax - xmin) + (ymax - ymin) * (ymax - ymin) +
               (zmax - zmin) * (zmax - zmin) ) / 2;

    return 0;
}

#define DIST(x,y) (sqrt(pow((x)-cx,2)+pow((y)-cy,2)))

int igraph_i_layout_merge_dla(igraph_i_layout_mergegrid_t *grid,
                              long int actg, igraph_real_t *x, igraph_real_t *y, igraph_real_t r,
                              igraph_real_t cx, igraph_real_t cy, igraph_real_t startr,
                              igraph_real_t killr) {
    long int sp = -1;
    igraph_real_t angle, len;
    long int steps = 0;

    /* The graph is not used, only its coordinates */
    IGRAPH_UNUSED(actg);

    while (sp < 0) {
        /* start particle */
        do {
            steps++;
            angle = RNG_UNIF(0, 2 * M_PI);
            len = RNG_UNIF(.5 * startr, startr);
            *x = cx + len * cos(angle);
            *y = cy + len * sin(angle);
            sp = igraph_i_layout_mergegrid_get_sphere(grid, *x, *y, r);
        } while (sp >= 0);

        while (sp < 0 && DIST(*x, *y) < killr) {
            igraph_real_t nx, ny;
            steps++;
            angle = RNG_UNIF(0, 2 * M_PI);
            len = RNG_UNIF(0, startr / 100);
            nx = *x + len * cos(angle);
            ny = *y + len * sin(angle);
            sp = igraph_i_layout_mergegrid_get_sphere(grid, nx, ny, r);
            if (sp < 0) {
                *x = nx; *y = ny;
            }
        }
    }

    /*   fprintf(stderr, "%li ", steps); */
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/merge_grid.c0000644000175100001710000001502600000000000024232 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph package.
   Copyright (C) 2006-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_memory.h"

#include "layout/merge_grid.h"

static int igraph_i_layout_mergegrid_which(igraph_i_layout_mergegrid_t *grid,
                                    igraph_real_t xc, igraph_real_t yc,
                                    long int *x, long int *y) {
    if (xc <= grid->minx) {
        *x = 0;
    } else if (xc >= grid->maxx) {
        *x = grid->stepsx - 1;
    } else {
        *x = (long int) floor((xc - (grid->minx)) / (grid->deltax));
    }

    if (yc <= grid->miny) {
        *y = 0;
    } else if (yc >= grid->maxy) {
        *y = grid->stepsy - 1;
    } else {
        *y = (long int) floor((yc - (grid->miny)) / (grid->deltay));
    }

    return 0;
}

int igraph_i_layout_mergegrid_init(igraph_i_layout_mergegrid_t *grid,
                                   igraph_real_t minx, igraph_real_t maxx, long int stepsx,
                                   igraph_real_t miny, igraph_real_t maxy, long int stepsy) {
    grid->minx = minx;
    grid->maxx = maxx;
    grid->stepsx = stepsx;
    grid->deltax = (maxx - minx) / stepsx;
    grid->miny = miny;
    grid->maxy = maxy;
    grid->stepsy = stepsy;
    grid->deltay = (maxy - miny) / stepsy;

    grid->data = IGRAPH_CALLOC(stepsx * stepsy, long int);
    if (grid->data == 0) {
        IGRAPH_ERROR("Cannot create grid", IGRAPH_ENOMEM);
    }
    return 0;
}

void igraph_i_layout_mergegrid_destroy(igraph_i_layout_mergegrid_t *grid) {
    IGRAPH_FREE(grid->data);
}

#define MAT(i,j) (grid->data[(grid->stepsy)*(j)+(i)])
#define DIST2(x2,y2) (sqrt(pow(x-(x2),2)+pow(y-(y2), 2)))

int igraph_i_layout_merge_place_sphere(igraph_i_layout_mergegrid_t *grid,
                                       igraph_real_t x, igraph_real_t y, igraph_real_t r,
                                       long int id) {
    long int cx, cy;
    long int i, j;

    igraph_i_layout_mergegrid_which(grid, x, y, &cx, &cy);

    MAT(cx, cy) = id + 1;

#define DIST(i,j) (DIST2(grid->minx+(cx+(i))*grid->deltax, \
                         grid->miny+(cy+(j))*grid->deltay))

    for (i = 0; cx + i < grid->stepsx && DIST(i, 0) < r; i++) {
        for (j = 0; cy + j < grid->stepsy && DIST(i, j) < r; j++) {
            MAT(cx + i, cy + j) = id + 1;
        }
    }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx+(i))*grid->deltax, \
                         grid->miny+(cy-(j)+1)*grid->deltay))

    for (i = 0; cx + i < grid->stepsx && DIST(i, 0) < r; i++) {
        for (j = 1; cy - j > 0 && DIST(i, j) < r; j++) {
            MAT(cx + i, cy - j) = id + 1;
        }
    }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx-(i)+1)*grid->deltax, \
                         grid->miny+(cy+(j))*grid->deltay))

    for (i = 1; cx - i > 0 && DIST(i, 0) < r; i++) {
        for (j = 0; cy + j < grid->stepsy && DIST(i, j) < r; j++) {
            MAT(cx - i, cy + j) = id + 1;
        }
    }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx-(i)+1)*grid->deltax, \
                         grid->miny+(cy-(j)+1)*grid->deltay))

    for (i = 1; cx - i > 0 && DIST(i, 0) < r; i++) {
        for (j = 1; cy - j > 0 && DIST(i, j) < r; j++) {
            MAT(cx - i, cy - j) = id + 1;
        }
    }

#undef DIST
#undef DIST2

    return 0;
}

long int igraph_i_layout_mergegrid_get(igraph_i_layout_mergegrid_t *grid,
                                       igraph_real_t x, igraph_real_t y) {
    long int cx, cy;
    long int res;

    if (x <= grid->minx || x >= grid->maxx ||
        y <= grid->miny || y >= grid->maxy) {
        res = -1;
    } else {
        igraph_i_layout_mergegrid_which(grid, x, y, &cx, &cy);
        res = MAT(cx, cy) - 1;
    }

    return res;
}

#define DIST2(x2,y2) (sqrt(pow(x-(x2),2)+pow(y-(y2), 2)))

long int igraph_i_layout_mergegrid_get_sphere(igraph_i_layout_mergegrid_t *grid,
        igraph_real_t x, igraph_real_t y, igraph_real_t r) {
    long int cx, cy;
    long int i, j;
    long int ret;

    if (x - r <= grid->minx || x + r >= grid->maxx ||
        y - r <= grid->miny || y + r >= grid->maxy) {
        ret = -1;
    } else {
        igraph_i_layout_mergegrid_which(grid, x, y, &cx, &cy);

        ret = MAT(cx, cy) - 1;

#define DIST(i,j) (DIST2(grid->minx+(cx+(i))*grid->deltax, \
                         grid->miny+(cy+(j))*grid->deltay))

        for (i = 0; ret < 0 && cx + i < grid->stepsx && DIST(i, 0) < r; i++) {
            for (j = 0; ret < 0 && cy + j < grid->stepsy && DIST(i, j) < r; j++) {
                ret = MAT(cx + i, cy + j) - 1;
            }
        }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx+(i))*grid->deltax, \
                         grid->miny+(cy-(j)+1)*grid->deltay))

        for (i = 0; ret < 0 && cx + i < grid->stepsx && DIST(i, 0) < r; i++) {
            for (j = 1; ret < 0 && cy - j > 0 && DIST(i, j) < r; j++) {
                ret = MAT(cx + i, cy - j) - 1;
            }
        }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx-(i)+1)*grid->deltax, \
                         grid->miny+(cy+(j))*grid->deltay))

        for (i = 1; ret < 0 && cx - i > 0 && DIST(i, 0) < r; i++) {
            for (j = 0; ret < 0 && cy + j < grid->stepsy && DIST(i, j) < r; j++) {
                ret = MAT(cx - i, cy + j) - 1;
            }
        }

#undef DIST
#define DIST(i,j) (DIST2(grid->minx+(cx-(i)+1)*grid->deltax, \
                         grid->miny+(cy-(j)+1)*grid->deltay))

        for (i = 1; ret < 0 && cx + i > 0 && DIST(i, 0) < r; i++) {
            for (j = 1; ret < 0 && cy + i > 0 && DIST(i, j) < r; j++) {
                ret = MAT(cx - i, cy - j) - 1;
            }
        }

#undef DIST

    }

    return ret;
}

/* int print_grid(igraph_i_layout_mergegrid_t *grid) { */
/*   long int i,j; */

/*   for (i=0; istepsx; i++) { */
/*     for (j=0; jstepsy; j++) { */
/*       printf("%li ", MAT(i,j)-1); */
/*     } */
/*     printf("\n"); */
/*   } */
/* } */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/merge_grid.h0000644000175100001710000000437600000000000024245 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_LAYOUT_MERGE_GRID_H
#define IGRAPH_LAYOUT_MERGE_GRID_H

#include "igraph_decls.h"
#include "igraph_types.h"

__BEGIN_DECLS

/* A type of grid used for merging layouts; each cell is owned by exactly one graph */

typedef struct igraph_i_layout_mergegrid_t {
    long int *data;
    long int stepsx, stepsy;
    igraph_real_t minx, maxx, deltax;
    igraph_real_t miny, maxy, deltay;
} igraph_i_layout_mergegrid_t;

IGRAPH_PRIVATE_EXPORT int igraph_i_layout_mergegrid_init(igraph_i_layout_mergegrid_t *grid,
                                                         igraph_real_t minx, igraph_real_t maxx, long int stepsx,
                                                         igraph_real_t miny, igraph_real_t maxy, long int stepsy);

IGRAPH_PRIVATE_EXPORT void igraph_i_layout_mergegrid_destroy(igraph_i_layout_mergegrid_t *grid);

IGRAPH_PRIVATE_EXPORT int igraph_i_layout_merge_place_sphere(igraph_i_layout_mergegrid_t *grid,
                                                             igraph_real_t x, igraph_real_t y, igraph_real_t r,
                                                             long int id);

long int igraph_i_layout_mergegrid_get(igraph_i_layout_mergegrid_t *grid,
                                       igraph_real_t x, igraph_real_t y);

long int igraph_i_layout_mergegrid_get_sphere(igraph_i_layout_mergegrid_t *g,
                                              igraph_real_t x, igraph_real_t y, igraph_real_t r);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/reingold_tilford.c0000644000175100001710000011517400000000000025461 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_paths.h"
#include "igraph_progress.h"
#include "igraph_structural.h"

#include "core/math.h"

static int igraph_i_layout_reingold_tilford_unreachable(
    const igraph_t *graph,
    igraph_neimode_t mode,
    long int real_root,
    long int no_of_nodes,
    igraph_vector_t *pnewedges) {

    long int no_of_newedges;
    igraph_vector_t visited;
    long int i, j, n;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_adjlist_t allneis;
    igraph_vector_int_t *neis;

    igraph_vector_resize(pnewedges, 0);

    /* traverse from real_root and see what nodes you cannot reach */
    no_of_newedges = 0;
    IGRAPH_VECTOR_INIT_FINALLY(&visited, no_of_nodes);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    /* start from real_root and go BFS */
    IGRAPH_CHECK(igraph_dqueue_push(&q, real_root));
    while (!igraph_dqueue_empty(&q)) {
        long int actnode = (long int) igraph_dqueue_pop(&q);
        neis = igraph_adjlist_get(&allneis, actnode);
        n = igraph_vector_int_size(neis);
        VECTOR(visited)[actnode] = 1;
        for (j = 0; j < n; j++) {
            long int neighbor = (long int) VECTOR(*neis)[j];
            if (!(long int)VECTOR(visited)[neighbor]) {
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
            }
        }
    }

    for (j = 0; j < no_of_nodes; j++) {
        no_of_newedges += 1 - VECTOR(visited)[j];
    }

    /* if any nodes are unreachable, add edges between them and real_root */
    if (no_of_newedges != 0) {

        igraph_vector_resize(pnewedges, no_of_newedges * 2);
        j = 0;
        for (i = 0; i < no_of_nodes; i++) {
            if (!VECTOR(visited)[i]) {
                if (mode != IGRAPH_IN) {
                    VECTOR(*pnewedges)[2 * j] = real_root;
                    VECTOR(*pnewedges)[2 * j + 1] = i;
                } else {
                    VECTOR(*pnewedges)[2 * j] = i;
                    VECTOR(*pnewedges)[2 * j + 1] = real_root;
                }
                j++;
            }
        }
    }

    igraph_dqueue_destroy(&q);
    igraph_adjlist_destroy(&allneis);
    igraph_vector_destroy(&visited);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}


/* Internal structure for Reingold-Tilford layout */
struct igraph_i_reingold_tilford_vertex {
    long int parent;        /* Parent node index */
    long int level;         /* Level of the node */
    igraph_real_t offset;     /* X offset from parent node */
    long int left_contour;  /* Next left node of the contour
              of the subtree rooted at this node */
    long int right_contour; /* Next right node of the contour
              of the subtree rooted at this node */
    igraph_real_t offset_to_left_contour;  /* X offset when following the left contour */
    igraph_real_t offset_to_right_contour;  /* X offset when following the right contour */
    long int left_extreme;  /* Leftmost node on the deepest layer of the subtree rooted at this node */
    long int right_extreme; /* Rightmost node on the deepest layer of the subtree rooted at this node */
    igraph_real_t offset_to_left_extreme;  /* X offset when jumping to the left extreme node */
    igraph_real_t offset_to_right_extreme;  /* X offset when jumping to the right extreme node */
};

static int igraph_i_layout_reingold_tilford_postorder(struct igraph_i_reingold_tilford_vertex *vdata,
                                                      long int node, long int vcount);
static int igraph_i_layout_reingold_tilford_calc_coords(struct igraph_i_reingold_tilford_vertex *vdata,
                                                        igraph_matrix_t *res, long int node,
                                                        long int vcount, igraph_real_t xpos);

/* uncomment the next line for debugging the Reingold-Tilford layout */
/* #define LAYOUT_RT_DEBUG 1 */

static int igraph_i_layout_reingold_tilford(const igraph_t *graph,
                                            igraph_matrix_t *res,
                                            igraph_neimode_t mode,
                                            long int root) {
    long int no_of_nodes = igraph_vcount(graph);
    long int i, n, j;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_adjlist_t allneis;
    igraph_vector_int_t *neis;
    struct igraph_i_reingold_tilford_vertex *vdata;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    vdata = IGRAPH_CALLOC(no_of_nodes, struct igraph_i_reingold_tilford_vertex);
    if (vdata == 0) {
        IGRAPH_ERROR("igraph_layout_reingold_tilford failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, vdata);

    for (i = 0; i < no_of_nodes; i++) {
        vdata[i].parent = -1;
        vdata[i].level = -1;
        vdata[i].offset = 0.0;
        vdata[i].left_contour = -1;
        vdata[i].right_contour = -1;
        vdata[i].offset_to_left_contour = 0.0;
        vdata[i].offset_to_right_contour = 0.0;
        vdata[i].left_extreme = i;
        vdata[i].right_extreme = i;
        vdata[i].offset_to_left_extreme = 0.0;
        vdata[i].offset_to_right_extreme = 0.0;
    }
    vdata[root].parent = root;
    vdata[root].level = 0;
    MATRIX(*res, root, 1) = 0;

    /* Step 1: assign Y coordinates based on BFS and setup parents vector */
    IGRAPH_CHECK(igraph_dqueue_push(&q, root));
    IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
    while (!igraph_dqueue_empty(&q)) {
        long int actnode = (long int) igraph_dqueue_pop(&q);
        long int actdist = (long int) igraph_dqueue_pop(&q);
        neis = igraph_adjlist_get(&allneis, actnode);
        n = igraph_vector_int_size(neis);

        for (j = 0; j < n; j++) {
            long int neighbor = (long int) VECTOR(*neis)[j];
            if (vdata[neighbor].parent >= 0) {
                continue;
            }
            MATRIX(*res, neighbor, 1) = actdist + 1;
            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
            IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            vdata[neighbor].parent = actnode;
            vdata[neighbor].level = actdist + 1;
        }
    }

    /* Step 2: postorder tree traversal, determines the appropriate X
     * offsets for every node */
    igraph_i_layout_reingold_tilford_postorder(vdata, root, no_of_nodes);

    /* Step 3: calculate real coordinates based on X offsets */
    igraph_i_layout_reingold_tilford_calc_coords(vdata, res, root, no_of_nodes, vdata[root].offset);

    igraph_dqueue_destroy(&q);
    igraph_adjlist_destroy(&allneis);
    igraph_free(vdata);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_PROGRESS("Reingold-Tilford tree layout", 100.0, NULL);

#ifdef LAYOUT_RT_DEBUG
    for (i = 0; i < no_of_nodes; i++) {
        printf(
            "%3ld: offset = %.2f, contours = [%ld, %ld], contour offsets = [%.2f, %.2f]\n",
            i, vdata[i].offset,
            vdata[i].left_contour, vdata[i].right_contour,
            vdata[i].offset_to_left_contour, vdata[i].offset_to_right_contour
        );
        if (vdata[i].left_extreme != i || vdata[i].right_extreme != i) {
            printf(
                "     extrema = [%ld, %ld], offsets to extrema = [%.2f, %.2f]\n",
                vdata[i].left_extreme, vdata[i].right_extreme,
                vdata[i].offset_to_left_extreme, vdata[i].offset_to_right_extreme
            );
        }
    }
#endif

    return 0;
}

static int igraph_i_layout_reingold_tilford_calc_coords(
        struct igraph_i_reingold_tilford_vertex *vdata,
        igraph_matrix_t *res, long int node,
        long int vcount, igraph_real_t xpos) {
    long int i;
    MATRIX(*res, node, 0) = xpos;
    for (i = 0; i < vcount; i++) {
        if (i == node) {
            continue;
        }
        if (vdata[i].parent == node) {
            igraph_i_layout_reingold_tilford_calc_coords(vdata, res, i, vcount,
                    xpos + vdata[i].offset);
        }
    }
    return 0;
}

static int igraph_i_layout_reingold_tilford_postorder(
        struct igraph_i_reingold_tilford_vertex *vdata,
        long int node, long int vcount) {
    long int i, j, childcount, leftroot, leftrootidx;
    const igraph_real_t minsep = 1;
    igraph_real_t avg;

#ifdef LAYOUT_RT_DEBUG
    printf("Starting visiting node %ld\n", node);
#endif

    /* Check whether this node is a leaf node */
    childcount = 0;
    for (i = 0; i < vcount; i++) {
        if (i == node) {
            continue;
        }
        if (vdata[i].parent == node) {
            /* Node i is a child, so visit it recursively */
            childcount++;
            igraph_i_layout_reingold_tilford_postorder(vdata, i, vcount);
        }
    }

    if (childcount == 0) {
        return 0;
    }

    /* Here we can assume that all of the subtrees have been placed and their
     * left and right contours are calculated. Let's place them next to each
     * other as close as we can.
     * We will take each subtree in an arbitrary order. The root of the
     * first one will be placed at offset 0, the next ones will be placed
     * as close to each other as possible. leftroot stores the root of the
     * rightmost subtree of the already placed subtrees - its right contour
     * will be checked against the left contour of the next subtree */
    leftroot = leftrootidx = -1;
    avg = 0.0;
#ifdef LAYOUT_RT_DEBUG
    printf("Visited node %ld and arranged its subtrees\n", node);
#endif
    for (i = 0, j = 0; i < vcount; i++) {
        if (i == node) {
            continue;
        }
        if (vdata[i].parent == node) {
            if (leftroot >= 0) {
                /* Now we will follow the right contour of leftroot and the
                 * left contour of the subtree rooted at i */
                long lnode, rnode, auxnode;
                igraph_real_t loffset, roffset, rootsep, newoffset;

#ifdef LAYOUT_RT_DEBUG
                printf("  Placing child %ld on level %ld, to the right of %ld\n", i, vdata[i].level, leftroot);
#endif
                lnode = leftroot; rnode = i;
                rootsep = vdata[leftroot].offset + minsep;
                loffset = vdata[leftroot].offset; roffset = loffset + minsep;

                /* Keep on updating the right contour now that we have attached
                 * a new node to the subtree being built */
                vdata[node].right_contour = i;
                vdata[node].offset_to_right_contour = rootsep;

#ifdef LAYOUT_RT_DEBUG
                printf("    Contour: [%ld, %ld], offsets: [%lf, %lf], rootsep: %lf\n",
                       lnode, rnode, loffset, roffset, rootsep);
#endif
                while ((lnode >= 0) && (rnode >= 0)) {
                    /* Step to the next level on the right contour of the left subtree */
                    if (vdata[lnode].right_contour >= 0) {
                        loffset += vdata[lnode].offset_to_right_contour;
                        lnode = vdata[lnode].right_contour;
                    } else {
                        /* Left subtree ended there. The left and right contour
                         * of the left subtree will continue to the next step
                         * on the right subtree. */
                        if (vdata[rnode].left_contour >= 0) {
                            auxnode = vdata[node].left_extreme;

                            /* this is the "threading" step that the original
                             * paper is talking about */
                            newoffset = (vdata[node].offset_to_right_extreme - vdata[node].offset_to_left_extreme) + minsep + vdata[rnode].offset_to_left_contour;
                            vdata[auxnode].left_contour = vdata[rnode].left_contour;
                            vdata[auxnode].right_contour = vdata[rnode].left_contour;
                            vdata[auxnode].offset_to_left_contour = vdata[auxnode].offset_to_right_contour = newoffset;

                            /* since we attached a larger subtree to the
                             * already placed left subtree, we need to update
                             * the extrema of the subtree rooted at 'node' */
                            vdata[node].left_extreme = vdata[i].left_extreme;
                            vdata[node].right_extreme = vdata[i].right_extreme;
                            vdata[node].offset_to_left_extreme = vdata[i].offset_to_left_extreme + rootsep;
                            vdata[node].offset_to_right_extreme = vdata[i].offset_to_right_extreme + rootsep;
#ifdef LAYOUT_RT_DEBUG
                            printf("      Left subtree ended earlier, continuing left subtree's left and right contour on right subtree (node %ld gets connected to node %ld)\n", auxnode, vdata[rnode].left_contour);
                            printf("      New contour following offset for node %ld is %lf\n", auxnode, vdata[auxnode].offset_to_left_contour);
#endif
                        } else {
                            /* Both subtrees are ending at the same time; the
                             * left extreme node of the subtree rooted at
                             * 'node' remains the same but the right extreme
                             * will change */
                            vdata[node].right_extreme = vdata[i].right_extreme;
                            vdata[node].offset_to_right_extreme = vdata[i].offset_to_right_extreme + rootsep;
                        }
                        lnode = -1;
                    }
                    /* Step to the next level on the left contour of the right subtree */
                    if (vdata[rnode].left_contour >= 0) {
                        roffset += vdata[rnode].offset_to_left_contour;
                        rnode = vdata[rnode].left_contour;
                    } else {
                        /* Right subtree ended here. The right contour of the right
                         * subtree will continue to the next step on the left subtree.
                         * Note that lnode has already been advanced here */
                        if (lnode >= 0) {
                            auxnode = vdata[i].right_extreme;

                            /* this is the "threading" step that the original
                             * paper is talking about */
                            newoffset = loffset - rootsep - vdata[i].offset_to_right_extreme;
                            vdata[auxnode].left_contour = lnode;
                            vdata[auxnode].right_contour = lnode;
                            vdata[auxnode].offset_to_left_contour = vdata[auxnode].offset_to_right_contour = newoffset;

                            /* no need to update the extrema of the subtree
                             * rooted at 'node' because the right subtree was
                             * smaller */
#ifdef LAYOUT_RT_DEBUG
                            printf("      Right subtree ended earlier, continuing right subtree's left and right contour on left subtree (node %ld gets connected to node %ld)\n", auxnode, lnode);
                            printf("      New contour following offset for node %ld is %lf\n", auxnode, vdata[auxnode].offset_to_left_contour);
#endif
                        }
                        rnode = -1;
                    }
#ifdef LAYOUT_RT_DEBUG
                    printf("    Contour: [%ld, %ld], offsets: [%lf, %lf], rootsep: %lf\n",
                           lnode, rnode, loffset, roffset, rootsep);
#endif

                    /* Push subtrees away if necessary */
                    if ((lnode >= 0) && (rnode >= 0) && (roffset - loffset < minsep)) {
#ifdef LAYOUT_RT_DEBUG
                        printf("    Pushing right subtree away by %lf\n", minsep-roffset+loffset);
#endif
                        rootsep += minsep - roffset + loffset;
                        roffset = loffset + minsep;
                        vdata[node].offset_to_right_contour = rootsep;
                    }
                }

#ifdef LAYOUT_RT_DEBUG
                printf("  Offset of subtree with root node %ld will be %lf\n", i, rootsep);
#endif
                vdata[i].offset = rootsep;
                vdata[node].offset_to_right_contour = rootsep;
                avg = (avg * j) / (j + 1) + rootsep / (j + 1);
                leftrootidx = j;
                leftroot = i;
            } else {
                /* This is the first child of the node being considered so we
                 * can simply place the subtree on our virtual canvas */
#ifdef LAYOUT_RT_DEBUG
                printf("  Placing child %ld on level %ld as first child\n", i, vdata[i].level);
#endif
                leftrootidx = j;
                leftroot = i;
                vdata[node].left_contour = i;
                vdata[node].right_contour = i;
                vdata[node].offset_to_left_contour = 0.0;
                vdata[node].offset_to_right_contour = 0.0;
                vdata[node].left_extreme = vdata[i].left_extreme;
                vdata[node].right_extreme = vdata[i].right_extreme;
                vdata[node].offset_to_left_extreme = vdata[i].offset_to_left_extreme;
                vdata[node].offset_to_right_extreme = vdata[i].offset_to_right_extreme;
                avg = vdata[i].offset;
            }
            j++;
        }
    }
#ifdef LAYOUT_RT_DEBUG
    printf("Shifting node %ld to be centered above children. Shift amount: %lf\n", node, avg);
#endif
    vdata[node].offset_to_left_contour -= avg;
    vdata[node].offset_to_right_contour -= avg;
    vdata[node].offset_to_left_extreme -= avg;
    vdata[node].offset_to_right_extreme -= avg;
    for (i = 0, j = 0; i < vcount; i++) {
        if (i == node) {
            continue;
        }
        if (vdata[i].parent == node) {
            vdata[i].offset -= avg;
        }
    }

    return 0;
}

/* This function computes the number of outgoing (or incoming) connections
 * of clusters, represented as a membership vector. It only works with
 * directed graphs. */
int igraph_i_layout_reingold_tilford_cluster_degrees_directed(
        const igraph_t *graph,
        const igraph_vector_t *membership,
        igraph_integer_t no_comps,
        igraph_neimode_t mode,
        igraph_vector_t *degrees) {

    igraph_eit_t eit;

    if (! igraph_is_directed(graph) || (mode != IGRAPH_OUT && mode != IGRAPH_IN)) {
        IGRAPH_ERROR("Directed graph expected.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_resize(degrees, no_comps));
    igraph_vector_null(degrees);

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    for (; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        igraph_integer_t eid = IGRAPH_EIT_GET(eit);

        igraph_integer_t from = IGRAPH_FROM(graph, eid);
        igraph_integer_t to   = IGRAPH_TO(graph, eid);

        igraph_integer_t from_cl = VECTOR(*membership)[from];
        igraph_integer_t to_cl   = VECTOR(*membership)[to];

        igraph_integer_t cl = mode == IGRAPH_OUT ? from_cl : to_cl;

        if (from_cl != to_cl) {
            VECTOR(*degrees)[cl] += 1;
        }
    }

    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/* Heuristic method to choose "nice" roots for the Reingold-Tilford layout algorithm.
 *
 * The principle is to select a minimal set of roots so that all other vertices
 * will be reachable from them.
 *
 * In the undirected case, one root is chosen from each connected component.
 * In the directed case, one root is chosen from each strongly connected component
 * that has no incoming (or outgoing) edges (depending on 'mode').
 * When more than one root choice is possible, nodes are prioritized based on
 * either lowest ecccentricity (if 'use_ecccentricity' is true) or based on
 * highest degree (out- or in-degree in directed mode).
 */
int igraph_i_layout_reingold_tilford_select_roots(
        const igraph_t *graph,
        igraph_neimode_t mode,
        igraph_vector_t *roots,
        igraph_bool_t use_eccentricity) {

    igraph_integer_t no_of_nodes = igraph_vcount(graph);
    igraph_vector_t order, membership;
    igraph_integer_t no_comps;
    long int i, j;

    if (! igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    if (use_eccentricity) {
        /* Sort vertices by decreasing eccenticity. */

        igraph_vector_t ecc;

        IGRAPH_VECTOR_INIT_FINALLY(&ecc, no_of_nodes);
        IGRAPH_CHECK(igraph_eccentricity(graph, &ecc, igraph_vss_all(), mode));
        IGRAPH_CHECK(igraph_vector_qsort_ind(&ecc, &order, /* descending= */ 0));

        igraph_vector_destroy(&ecc);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Sort vertices by decreasing degree (out- or in-degree in directed case). */

        IGRAPH_CHECK(igraph_sort_vertex_ids_by_degree(graph, &order,
                     igraph_vss_all(), mode, 0, IGRAPH_DESCENDING, 0));
    }

    IGRAPH_VECTOR_INIT_FINALLY(&membership, no_of_nodes);    
    IGRAPH_CHECK(igraph_clusters(graph, &membership, /*csize=*/ NULL,
                                 &no_comps, mode == IGRAPH_ALL ? IGRAPH_WEAK : IGRAPH_STRONG));

    IGRAPH_CHECK(igraph_vector_resize(roots, no_comps));
    igraph_vector_fill(roots, -1); /* -1 signifies a not-yet-determined root for a component */

    if (mode != IGRAPH_ALL) {
        /* Directed case:
         *
         * We break the graph into strongly-connected components and find those components
         * which have no incoming (outgoing) edges. The largest out-degree (in-degree)
         * nodes from these components will be chosen as roots. When the graph is a DAG,
         * these will simply be the source (sink) nodes. */

        igraph_vector_t cluster_degrees;

        IGRAPH_VECTOR_INIT_FINALLY(&cluster_degrees, no_of_nodes);
        IGRAPH_CHECK(igraph_i_layout_reingold_tilford_cluster_degrees_directed(
                         graph, &membership, no_comps,
                         mode == IGRAPH_OUT ? IGRAPH_IN : IGRAPH_OUT, /* reverse direction */
                         &cluster_degrees));

        /* Iterate through nodes in decreasing out-degree (or in-degree) order
         * and record largest degree node in each strongly-connected component
         * which has no incoming (outgoing) edges. */
        for (i = 0; i < no_of_nodes; ++i) {
            long int v  = (long int) VECTOR(order)[i];
            long int cl = VECTOR(membership)[v];
            if (VECTOR(cluster_degrees)[cl] == 0 && VECTOR(*roots)[cl] == -1) {
                VECTOR(*roots)[cl] = v;
            }
        }

        igraph_vector_destroy(&cluster_degrees);
        IGRAPH_FINALLY_CLEAN(1);

        /* Remove remaining -1 indices. These correspond to components that
         * did have some incoming edges. */
        for (i=0, j=0; i < no_comps; ++i) {
            if (VECTOR(*roots)[i] == -1) {
                continue;
            }
            VECTOR(*roots)[j++] = VECTOR(*roots)[i];
        }
        igraph_vector_resize(roots, j);

    } else {
        /* Undirected case:
         *
         * Select the highest degree node from each component.
         */

        long int no_seen = 0;

        for (i=0; i < no_of_nodes; ++i) {
            long int v  = VECTOR(order)[i];
            long int cl = VECTOR(membership)[v];
            if (VECTOR(*roots)[cl] == -1) {
                no_seen += 1;
                VECTOR(*roots)[cl] = v;
            }
            if (no_seen == no_comps) {
                /* All components have roots now. */
                break;
            }
        }
    }

    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_layout_reingold_tilford
 * \brief Reingold-Tilford layout for tree graphs
 *
 * 
 * Arranges the nodes in a tree where the given node is used as the root.
 * The tree is directed downwards and the parents are centered above its
 * children. For the exact algorithm, see:
 *
 * 
 * Reingold, E and Tilford, J: Tidier drawing of trees.
 * IEEE Trans. Softw. Eng., SE-7(2):223--228, 1981.
 * https://doi.org/10.1109/TSE.1981.234519
 *
 * 
 * If the given graph is not a tree, a breadth-first search is executed
 * first to obtain a possible spanning tree.
 *
 * \param graph The graph object.
 * \param res The result, the coordinates in a matrix. The parameter
 *   should point to an initialized matrix object and will be resized.
 * \param mode Specifies which edges to consider when building the tree.
 *   If it is \c IGRAPH_OUT then only the outgoing, if it is \c IGRAPH_IN
 *   then only the incoming edges of a parent are considered. If it is
 *   \c IGRAPH_ALL then all edges are used (this was the behavior in
 *   igraph 0.5 and before). This parameter also influences how the root
 *   vertices are calculated, if they are not given. See the \p roots parameter.
 * \param roots The index of the root vertex or root vertices. The set of roots
 *   should be specified so that all vertices of the graph are reachable from them.
 *   Simply put, in the udirected case, one root should be given from each
 *   connected component. If \p roots is \c NULL or a pointer to an empty vector,
 *   then the roots will be selected automatically. Currently, automatic root
 *   selection prefers low ecccentricity vertices in graphs with fewer than
 *   500 vertices, and high degree vertices (acording to \p mode) in larger graphs.
 *   The root selecton heuristic may change without notice. To ensure a consistent
 *   output, please specify the roots manually.
 * \param rootlevel This argument can be useful when drawing forests which are
 *   not trees (i.e. they are unconnected and have tree components). It specifies
 *   the level of the root vertices for every tree in the forest. It is only
 *   considered if not a null pointer and the \p roots argument is also given
 *   (and it is not a null pointer of an empty vector).
 * \return Error code.
 *
 * Added in version 0.2.
 *
 * \sa \ref igraph_layout_reingold_tilford_circular().
 *
 * \example examples/simple/igraph_layout_reingold_tilford.c
 */
int igraph_layout_reingold_tilford(const igraph_t *graph,
                                   igraph_matrix_t *res,
                                   igraph_neimode_t mode,
                                   const igraph_vector_t *roots,
                                   const igraph_vector_t *rootlevel) {

    long int no_of_nodes_orig = igraph_vcount(graph);
    long int no_of_nodes = no_of_nodes_orig;
    long int real_root;
    igraph_t extended;
    const igraph_t *pextended = graph;
    igraph_vector_t myroots;
    const igraph_vector_t *proots = roots;

    long int i;
    igraph_vector_t newedges;

    /* TODO: possible speedup could be achieved if we use a table for storing
     * the children of each node in the tree. (Now the implementation uses a
     * single array containing the parent of each node and a node's children
     * are determined by looking for other nodes that have this node as parent)
     */

    /* at various steps it might be necessary to add edges to the graph */
    IGRAPH_VECTOR_INIT_FINALLY(&newedges, 0);

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    if ( (!roots || igraph_vector_size(roots) == 0) &&
         rootlevel && igraph_vector_size(rootlevel) != 0 ) {
        IGRAPH_WARNING("Reingold-Tilford layout: 'rootlevel' ignored");
    }

    /* ----------------------------------------------------------------------- */
    /* If root vertices are not given, perform automated root selection. */

    if (!roots || igraph_vector_size(roots) == 0) {

        IGRAPH_VECTOR_INIT_FINALLY(&myroots, 0);
        igraph_i_layout_reingold_tilford_select_roots(graph, mode, &myroots, no_of_nodes < 500);
        proots = &myroots;

    } else if (rootlevel && igraph_vector_size(rootlevel) > 0 &&
               igraph_vector_size(roots) > 1) {

        /* ----------------------------------------------------------------------- */
        /* Many roots were given to us, check 'rootlevel' */

        long int plus_levels = 0;
        long int i;

        if (igraph_vector_size(roots) != igraph_vector_size(rootlevel)) {
            IGRAPH_ERROR("Reingold-Tilford: 'roots' and 'rootlevel' lengths differ",
                         IGRAPH_EINVAL);
        }

        /* count the rootlevels that are not zero */
        for (i = 0; i < igraph_vector_size(roots); i++) {
            plus_levels += VECTOR(*rootlevel)[i];
        }

        /* make copy of graph, add vertices/edges */
        if (plus_levels != 0) {
            long int edgeptr = 0;

            pextended = &extended;
            IGRAPH_CHECK(igraph_copy(&extended, graph));
            IGRAPH_FINALLY(igraph_destroy, &extended);
            IGRAPH_CHECK(igraph_add_vertices(&extended,
                                             (igraph_integer_t) plus_levels, 0));

            igraph_vector_resize(&newedges, plus_levels * 2);

            for (i = 0; i < igraph_vector_size(roots); i++) {
                long int rl = (long int) VECTOR(*rootlevel)[i];
                long int rn = (long int) VECTOR(*roots)[i];
                long int j;

                /* zero-level roots don't get anything special */
                if (rl == 0) {
                    continue;
                }

                /* for each nonzero-level root, add vertices
                   and edges at all levels [1, 2, .., rl]
                   piercing through the graph. If mode=="in"
                   they pierce the other way */
                if (mode != IGRAPH_IN) {
                    VECTOR(newedges)[edgeptr++] = no_of_nodes;
                    VECTOR(newedges)[edgeptr++] = rn;
                    for (j = 0; j < rl - 1; j++) {
                        VECTOR(newedges)[edgeptr++] = no_of_nodes + 1;
                        VECTOR(newedges)[edgeptr++] = no_of_nodes;
                        no_of_nodes++;
                    }
                } else {
                    VECTOR(newedges)[edgeptr++] = rn;
                    VECTOR(newedges)[edgeptr++] = no_of_nodes;
                    for (j = 0; j < rl - 1; j++) {
                        VECTOR(newedges)[edgeptr++] = no_of_nodes;
                        VECTOR(newedges)[edgeptr++] = no_of_nodes + 1;
                        no_of_nodes++;
                    }
                }

                /* move on to the next root */
                VECTOR(*roots)[i] = no_of_nodes++;
            }

            /* actually add the edges to the graph */
            IGRAPH_CHECK(igraph_add_edges(&extended, &newedges, 0));
        }
    }

    /* We have root vertices now. If one or more nonzero-level roots were
       chosen by the user, we have copied the graph and added a few vertices
       and (directed) edges to connect those floating roots to nonfloating,
       zero-level equivalent roots.

       Below, the function

       igraph_i_layout_reingold_tilford(pextended, res, mode, real_root)

       calculates the actual rt coordinates of the graph. However, for
       simplicity that function requires a connected graph and a single root.
       For directed graphs, it needs not be strongly connected, however all
       nodes must be reachable from the root following the stream (i.e. the
       root must be a "mother vertex").

       So before we call that function we have to make sure the (copied) graph
       satisfies that condition. That requires:
         1. if there is more than one root, defining a single real_root
         2. if a real_root is defined, adding edges to connect all roots to it
         3. ensure real_root is mother of the whole graph. If it is not,
            add shortcut edges from real_root to any disconnected node for now.

      NOTE: 3. could be done better, e.g. by topological sorting of some kind.
      But for now it's ok like this.
    */
    /* if there is only one root, no need for real_root */
    if (igraph_vector_size(proots) == 1) {
        real_root = (long int) VECTOR(*proots)[0];
        if (real_root < 0 || real_root >= no_of_nodes) {
            IGRAPH_ERROR("Invalid vertex id.", IGRAPH_EINVVID);
        }

        /* else, we need to make real_root */
    } else {
        long int no_of_newedges;

        /* Make copy of the graph unless it exists already */
        if (pextended == graph) {
            pextended = &extended;
            IGRAPH_CHECK(igraph_copy(&extended, graph));
            IGRAPH_FINALLY(igraph_destroy, &extended);
        }

        /* add real_root to the vertices */
        real_root = no_of_nodes;
        IGRAPH_CHECK(igraph_add_vertices(&extended, 1, 0));
        no_of_nodes++;

        /* add edges from the roots to real_root */
        no_of_newedges = igraph_vector_size(proots);
        igraph_vector_resize(&newedges, no_of_newedges * 2);
        for (i = 0; i < no_of_newedges; i++) {
            VECTOR(newedges)[2 * i] = no_of_nodes - 1;
            VECTOR(newedges)[2 * i + 1] = VECTOR(*proots)[i];
        }

        IGRAPH_CHECK(igraph_add_edges(&extended, &newedges, 0));
    }

    /* prepare edges to unreachable parts of the graph */
    IGRAPH_CHECK(igraph_i_layout_reingold_tilford_unreachable(pextended, mode, real_root, no_of_nodes, &newedges));

    if (igraph_vector_size(&newedges) != 0) {
        /* Make copy of the graph unless it exists already */
        if (pextended == graph) {
            pextended = &extended;
            IGRAPH_CHECK(igraph_copy(&extended, graph));
            IGRAPH_FINALLY(igraph_destroy, &extended);
        }

        IGRAPH_CHECK(igraph_add_edges(&extended, &newedges, 0));
    }
    igraph_vector_destroy(&newedges);
    IGRAPH_FINALLY_CLEAN(1);

    /* ----------------------------------------------------------------------- */
    /* Layout */
    IGRAPH_CHECK(igraph_i_layout_reingold_tilford(pextended, res, mode, real_root));

    /* Remove the new vertices from the layout */
    if (no_of_nodes != no_of_nodes_orig) {
        if (no_of_nodes - 1 == no_of_nodes_orig) {
            IGRAPH_CHECK(igraph_matrix_remove_row(res, no_of_nodes_orig));
        } else {
            igraph_matrix_t tmp;
            long int i;
            IGRAPH_MATRIX_INIT_FINALLY(&tmp, no_of_nodes_orig, 2);
            for (i = 0; i < no_of_nodes_orig; i++) {
                MATRIX(tmp, i, 0) = MATRIX(*res, i, 0);
                MATRIX(tmp, i, 1) = MATRIX(*res, i, 1);
            }
            IGRAPH_CHECK(igraph_matrix_update(res, &tmp));
            igraph_matrix_destroy(&tmp);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    if (pextended != graph) {
        igraph_destroy(&extended);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* Remove the roots vector if it was created by us */
    if (proots != roots) {
        igraph_vector_destroy(&myroots);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_layout_reingold_tilford_circular
 * \brief Circular Reingold-Tilford layout for trees
 *
 * 
 * This layout is almost the same as \ref igraph_layout_reingold_tilford(), but
 * the tree is drawn in a circular way, with the root vertex in the center.
 *
 * \param graph The graph object.
 * \param res The result, the coordinates in a matrix. The parameter
 *   should point to an initialized matrix object and will be resized.
 * \param mode Specifies which edges to consider when building the tree.
 *   If it is \c IGRAPH_OUT then only the outgoing, if it is \c IGRAPH_IN
 *   then only the incoming edges of a parent are considered. If it is
 *   \c IGRAPH_ALL then all edges are used (this was the behavior in
 *   igraph 0.5 and before). This parameter also influences how the root
 *   vertices are calculated, if they are not given. See the \p roots parameter.
 * \param roots The index of the root vertex or root vertices. The set of roots
 *   should be specified so that all vertices of the graph are reachable from them.
 *   Simply put, in the udirected case, one root should be given from each
 *   connected component. If \p roots is \c NULL or a pointer to an empty vector,
 *   then the roots will be selected automatically. Currently, automatic root
 *   selection prefers low ecccentricity vertices in graphs with fewer than
 *   500 vertices, and high degree vertices (acording to \p mode) in larger graphs.
 *   The root selecton heuristic may change without notice. To ensure a consistent
 *   output, please specify the roots manually.
 * \param rootlevel This argument can be useful when drawing forests which are
 *   not trees (i.e. they are unconnected and have tree components). It specifies
 *   the level of the root vertices for every tree in the forest. It is only
 *   considered if not a null pointer and the \p roots argument is also given
 *   (and it is not a null pointer or an empty vector).
 * \return Error code.
 *
 * \sa \ref igraph_layout_reingold_tilford().
 */
int igraph_layout_reingold_tilford_circular(const igraph_t *graph,
        igraph_matrix_t *res,
        igraph_neimode_t mode,
        const igraph_vector_t *roots,
        const igraph_vector_t *rootlevel) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i;
    igraph_real_t ratio;
    igraph_real_t minx, maxx;

    IGRAPH_CHECK(igraph_layout_reingold_tilford(graph, res, mode, roots, rootlevel));

    if (no_of_nodes == 0) {
        return IGRAPH_SUCCESS;
    }

    ratio = 2 * M_PI * (no_of_nodes - 1.0) / no_of_nodes;

    minx = maxx = MATRIX(*res, 0, 0);
    for (i = 1; i < no_of_nodes; i++) {
        if (MATRIX(*res, i, 0) > maxx) {
            maxx = MATRIX(*res, i, 0);
        }
        if (MATRIX(*res, i, 0) < minx) {
            minx = MATRIX(*res, i, 0);
        }
    }
    if (maxx > minx) {
        ratio /= (maxx - minx);
    }
    for (i = 0; i < no_of_nodes; i++) {
        igraph_real_t phi = (MATRIX(*res, i, 0) - minx) * ratio;
        igraph_real_t r = MATRIX(*res, i, 1);
        MATRIX(*res, i, 0) = r * cos(phi);
        MATRIX(*res, i, 1) = r * sin(phi);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/layout/sugiyama.c0000644000175100001710000015173400000000000023754 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_layout.h"
#include "igraph_centrality.h"
#include "igraph_components.h"
#include "igraph_constants.h"
#include "igraph_constructors.h"
#include "igraph_datatype.h"
#include "igraph_error.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_structural.h"
#include "igraph_types.h"

#include "internal/glpk_support.h"
#include "misc/feedback_arc_set.h"

#include "config.h"

#include 

/* #define SUGIYAMA_DEBUG */

#ifdef _MSC_VER
/* MSVC does not support variadic macros */
#include 
static void debug(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
#ifdef SUGIYAMA_DEBUG
    vfprintf(stderr, fmt, args);
#endif
    va_end(args);
}
#else
#ifdef SUGIYAMA_DEBUG
    #define debug(...) fprintf(stderr, __VA_ARGS__)
#else
    #define debug(...)
#endif
#endif

/* MSVC uses __forceinline instead of inline */
#ifdef _MSC_VER
    #define INLINE __forceinline
#else
    #define INLINE inline
#endif

/*
 * Implementation of the Sugiyama layout algorithm as described in:
 *
 * [1] K. Sugiyama, S. Tagawa and M. Toda, "Methods for Visual Understanding of
 * Hierarchical Systems". IEEE Transactions on Systems, Man and Cybernetics
 * 11(2):109-125, 1981.
 *
 * The layering (if not given in advance) is calculated by ... TODO
 *
 * [2] TODO
 *
 * The X coordinates of nodes within a layer are calculated using the method of
 * Brandes & Köpf:
 *
 * [3] U. Brandes and B. Köpf, "Fast and Simple Horizontal Coordinate
 * Assignment".  In: Lecture Notes in Computer Science 2265:31-44, 2002.
 *
 * Layer compaction is done according to:
 *
 * [4] N.S. Nikolov and A. Tarassov, "Graph layering by promotion of nodes".
 * Journal of Discrete Applied Mathematics, special issue: IV ALIO/EURO
 * workshop on applied combinatorial optimization, 154(5).
 *
 * The steps of the algorithm are as follows:
 *
 *   1. Cycle removal by finding an approximately minimal feedback arc set
 *      and reversing the direction of edges in the set.  Algorithms for
 *      finding minimal feedback arc sets are as follows:
 *
 *        - Find a cycle and find its minimum weight edge. Decrease the weight
 *          of all the edges by w. Remove those edges whose weight became zero.
 *          Repeat until there are no cycles. Re-introduce removed edges in
 *          decreasing order of weights, ensuring that no cycles are created.
 *
 *        - Order the vertices somehow and remove edges which point backwards
 *          in the ordering. Eades et al proposed the following procedure:
 *
 *            1. Iteratively remove sinks and prepend them to a vertex sequence
 *               s2.
 *
 *            2. Iteratively remove sources and append them to a vertex sequence
 *               s1.
 *
 *            3. Choose a vertex u s.t. the difference between the number of
 *               rightward arcs and the number of leftward arcs is the largest,
 *               remove u and append it to s1. Goto step 1 if there are still
 *               more vertices.
 *
 *            4. Concatenate s1 with s2.
 *
 *          This algorithm is known to produce feedback arc sets at most the
 *          size of m/2 - n/6, where m is the number of edges. Further
 *          improvements are possible in step 3 which bring down the size of
 *          the set to at most m/4 for cubic directed graphs, see Eades (1995).
 *
 *        - For undirected graphs, find a maximum weight spanning tree and
 *          remove all the edges not in the spanning tree. For directed graphs,
 *          find minimal cuts iteratively and remove edges pointing from A to
 *          B or from B to A in the cut, depending on which one is smaller. Yes,
 *          this is time-consuming.
 *
 *   2. Assigning vertices to layers according to [2].
 *
 *   3. Extracting weakly connected components. The remaining steps are
 *      executed for each component.
 *
 *   4. Compacting the layering using the method of [4]. TODO
 *      Steps 2-4 are performed only when no layering is given in advance.
 *
 *   5. Adding dummy nodes to ensure that each edge spans at most one layer
 *      only.
 *
 *   6. Finding an optimal ordering of vertices within a layer using the
 *      Sugiyama framework [1].
 *
 *   7. Assigning horizontal coordinates to each vertex using [3].
 *
 *   8. ???
 *
 *   9. Profit!
 */

/**
 * Data structure to store a layering of the graph.
 */
typedef struct {
    igraph_vector_ptr_t layers;
} igraph_i_layering_t;

/**
 * Initializes a layering.
 */
static int igraph_i_layering_init(igraph_i_layering_t* layering,
                                  const igraph_vector_t* membership) {
    long int i, n, num_layers;

    if (igraph_vector_size(membership) == 0) {
        num_layers = 0;
    } else {
        num_layers = (long int) igraph_vector_max(membership) + 1;
    }

    IGRAPH_CHECK(igraph_vector_ptr_init(&layering->layers, num_layers));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &layering->layers);

    for (i = 0; i < num_layers; i++) {
        igraph_vector_t* vec = IGRAPH_CALLOC(1, igraph_vector_t);
        IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
        VECTOR(layering->layers)[i] = vec;
        IGRAPH_FINALLY_CLEAN(1);
    }
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&layering->layers, igraph_vector_destroy);

    n = igraph_vector_size(membership);
    for (i = 0; i < n; i++) {
        long int l = (long int) VECTOR(*membership)[i];
        igraph_vector_t* vec = VECTOR(layering->layers)[l];
        IGRAPH_CHECK(igraph_vector_push_back(vec, i));
    }

    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * Destroys a layering.
 */
static void igraph_i_layering_destroy(igraph_i_layering_t* layering) {
    igraph_vector_ptr_destroy_all(&layering->layers);
}

/**
 * Returns the number of layers in a layering.
 */
static int igraph_i_layering_num_layers(const igraph_i_layering_t* layering) {
    return (int) igraph_vector_ptr_size(&layering->layers);
}

/**
 * Returns the list of vertices in a given layer
 */
static igraph_vector_t* igraph_i_layering_get(const igraph_i_layering_t* layering,
                                       long int index) {
    return (igraph_vector_t*)VECTOR(layering->layers)[index];
}


/**
 * Forward declarations
 */

static int igraph_i_layout_sugiyama_place_nodes_vertically(const igraph_t* graph,
        const igraph_vector_t* weights, igraph_vector_t* membership);
static int igraph_i_layout_sugiyama_order_nodes_horizontally(const igraph_t* graph,
        igraph_matrix_t* layout, const igraph_i_layering_t* layering,
        long int maxiter);
static int igraph_i_layout_sugiyama_place_nodes_horizontally(const igraph_t* graph,
        igraph_matrix_t* layout, const igraph_i_layering_t* layering,
        igraph_real_t hgap, igraph_integer_t no_of_real_nodes);

/**
 * Calculated the median of four numbers (not necessarily sorted).
 */
static INLINE igraph_real_t igraph_i_median_4(igraph_real_t x1,
        igraph_real_t x2, igraph_real_t x3, igraph_real_t x4) {
    igraph_real_t arr[4] = { x1, x2, x3, x4 };
    igraph_vector_t vec;
    igraph_vector_view(&vec, arr, 4);
    igraph_vector_sort(&vec);
    return (arr[1] + arr[2]) / 2.0;
}


/**
 * \ingroup layout
 * \function igraph_layout_sugiyama
 * \brief Sugiyama layout algorithm for layered directed acyclic graphs.
 *
 * 
 * This layout algorithm is designed for directed acyclic graphs where each
 * vertex is assigned to a layer. Layers are indexed from zero, and vertices
 * of the same layer will be placed on the same horizontal line. The X coordinates
 * of vertices within each layer are decided by the heuristic proposed by
 * Sugiyama et al to minimize edge crossings.
 *
 * 
 * You can also try to lay out undirected graphs, graphs containing cycles, or
 * graphs without an a priori layered assignment with this algorithm. igraph
 * will try to eliminate cycles and assign vertices to layers, but there is no
 * guarantee on the quality of the layout in such cases.
 *
 * 
 * The Sugiyama layout may introduce "bends" on the edges in order to obtain a
 * visually more pleasing layout. This is achieved by adding dummy nodes to
 * edges spanning more than one layer. The resulting layout assigns coordinates
 * not only to the nodes of the original graph but also to the dummy nodes.
 * The layout algorithm will also return the extended graph with the dummy nodes.
 * An edge in the original graph may either be mapped to a single edge in the
 * extended graph or a \em path that starts and ends in the original
 * source and target vertex and passes through multiple dummy vertices. In
 * such cases, the user may also request the mapping of the edges of the extended
 * graph back to the edges of the original graph.
 *
 * 
 * For more details, see K. Sugiyama, S. Tagawa and M. Toda, "Methods for Visual
 * Understanding of Hierarchical Systems". IEEE Transactions on Systems, Man and
 * Cybernetics 11(2):109-125, 1981.
 *
 * \param graph Pointer to an initialized graph object.
 * \param res   Pointer to an initialized matrix object. This will contain
 *              the result and will be resized as needed. The first |V| rows
 *              of the layout will contain the coordinates of the original graph,
 *              the remaining rows contain the positions of the dummy nodes.
 *              Therefore, you can use the result both with \p graph or with
 *              \p extended_graph.
 * \param extended_graph Pointer to an uninitialized graph object or \c NULL.
 *                       The extended graph with the added dummy nodes will be
 *                       returned here. In this graph, each edge points downwards
 *                       to lower layers, spans exactly one layer and the first
 *                       |V| vertices coincide with the vertices of the
 *                       original graph.
 * \param extd_to_orig_eids Pointer to a vector or \c NULL. If not \c NULL, the
 *                          mapping from the edge IDs of the extended graph back
 *                          to the edge IDs of the original graph will be stored
 *                          here.
 * \param layers  The layer index for each vertex or \c NULL if the layers should
 *                be determined automatically by igraph.
 * \param hgap  The preferred minimum horizontal gap between vertices in the same
 *              layer.
 * \param vgap  The distance between layers.
 * \param maxiter Maximum number of iterations in the crossing minimization stage.
 *                100 is a reasonable default; if you feel that you have too
 *                many edge crossings, increase this.
 * \param weights Weights of the edges. These are used only if the graph contains
 *                cycles; igraph will tend to reverse edges with smaller
 *                weights when breaking the cycles.
 */
int igraph_layout_sugiyama(const igraph_t *graph, igraph_matrix_t *res,
                           igraph_t *extd_graph, igraph_vector_t *extd_to_orig_eids,
                           const igraph_vector_t* layers, igraph_real_t hgap, igraph_real_t vgap,
                           long int maxiter, const igraph_vector_t *weights) {
    long int i, j, k, l, m, nei;
    long int no_of_nodes = (long int)igraph_vcount(graph);
    long int comp_idx;
    long int next_extd_vertex_id = no_of_nodes;
    igraph_bool_t directed = igraph_is_directed(graph);
    igraph_integer_t no_of_components;  /* number of components of the original graph */
    igraph_vector_t membership;         /* components of the original graph */
    igraph_vector_t extd_edgelist;   /* edge list of the extended graph */
    igraph_vector_t layers_own;  /* layer indices after having eliminated empty layers */
    igraph_real_t dx = 0, dx2 = 0; /* displacement of the current component on the X axis */
    igraph_vector_t layer_to_y; /* mapping from layer indices to final Y coordinates */

    if (layers && igraph_vector_size(layers) != no_of_nodes) {
        IGRAPH_ERROR("layer vector too short or too long", IGRAPH_EINVAL);
    }

    if (extd_graph != 0) {
        IGRAPH_VECTOR_INIT_FINALLY(&extd_edgelist, 0);
        if (extd_to_orig_eids != 0) {
            igraph_vector_clear(extd_to_orig_eids);
        }
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, 2));
    IGRAPH_VECTOR_INIT_FINALLY(&membership, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&layer_to_y, 0);

    /* 1. Find a feedback arc set if we don't have a layering yet. If we do have
     *    a layering, we can leave all the edges as is as they will be re-oriented
     *    to point downwards only anyway. */
    if (layers == 0) {
        IGRAPH_VECTOR_INIT_FINALLY(&layers_own, no_of_nodes);
        IGRAPH_CHECK(igraph_i_layout_sugiyama_place_nodes_vertically(
                         graph, weights, &layers_own));
    } else {
        IGRAPH_CHECK(igraph_vector_copy(&layers_own, layers));
        IGRAPH_FINALLY(igraph_vector_destroy, &layers_own);
    }

    /* Normalize layering, eliminate empty layers */
    if (no_of_nodes > 0) {
        igraph_vector_t inds;
        IGRAPH_VECTOR_INIT_FINALLY(&inds, 0);
        IGRAPH_CHECK((int) igraph_vector_qsort_ind(&layers_own, &inds, 0));
        j = -1; dx = VECTOR(layers_own)[(long int)VECTOR(inds)[0]] - 1;
        for (i = 0; i < no_of_nodes; i++) {
            k = (long int)VECTOR(inds)[i];
            if (VECTOR(layers_own)[k] > dx) {
                /* New layer starts here */
                dx = VECTOR(layers_own)[k];
                j++;
                IGRAPH_CHECK(igraph_vector_push_back(&layer_to_y, dx * vgap));
            }
            VECTOR(layers_own)[k] = j;
        }
        igraph_vector_destroy(&inds);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* 2. Find the connected components. */
    IGRAPH_CHECK(igraph_clusters(graph, &membership, 0, &no_of_components,
                                 IGRAPH_WEAK));

    /* 3. For each component... */
    dx = 0;
    for (comp_idx = 0; comp_idx < no_of_components; comp_idx++) {
        /* Extract the edges of the comp_idx'th component and add dummy nodes for edges
         * spanning more than one layer. */
        long int component_size, next_new_vertex_id;
        igraph_vector_t old2new_vertex_ids;
        igraph_vector_t new2old_vertex_ids;
        igraph_vector_t new_layers;
        igraph_vector_t edgelist;
        igraph_vector_t neis;

        IGRAPH_VECTOR_INIT_FINALLY(&edgelist, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&new2old_vertex_ids, no_of_nodes);
        IGRAPH_VECTOR_INIT_FINALLY(&old2new_vertex_ids, no_of_nodes);
        IGRAPH_VECTOR_INIT_FINALLY(&new_layers, 0);

        igraph_vector_fill(&old2new_vertex_ids, -1);

        /* Construct a mapping from the old vertex ids to the new ones */
        for (i = 0, next_new_vertex_id = 0; i < no_of_nodes; i++) {
            if (VECTOR(membership)[i] == comp_idx) {
                IGRAPH_CHECK(igraph_vector_push_back(&new_layers, VECTOR(layers_own)[i]));
                VECTOR(new2old_vertex_ids)[next_new_vertex_id] = i;
                VECTOR(old2new_vertex_ids)[i] = next_new_vertex_id;
                next_new_vertex_id++;
            }
        }
        component_size = next_new_vertex_id;

        /* Construct a proper layering of the component in new_graph where each edge
         * points downwards and spans exactly one layer. */
        for (i = 0; i < no_of_nodes; i++) {
            if (VECTOR(membership)[i] != comp_idx) {
                continue;
            }

            /* Okay, this vertex is in the component we are considering.
             * Add the neighbors of this vertex, excluding loops */
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) i,
                                         IGRAPH_OUT));
            j = igraph_vector_size(&neis);
            for (k = 0; k < j; k++) {
                long int eid = (long int) VECTOR(neis)[k];
                if (directed) {
                    nei = IGRAPH_TO(graph, eid);
                } else {
                    nei = IGRAPH_OTHER(graph, eid, i);
                    if (nei < i) { /* to avoid considering edges twice */
                        continue;
                    }
                }
                if (VECTOR(layers_own)[i] == VECTOR(layers_own)[nei]) {
                    /* Edge goes within the same layer, we don't need this in the
                     * layered graph, but we need it in the extended graph */
                    if (extd_graph != 0) {
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, i));
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, nei));
                        if (extd_to_orig_eids != 0) {
                            IGRAPH_CHECK(igraph_vector_push_back(extd_to_orig_eids, eid));
                        }
                    }
                } else if (VECTOR(layers_own)[i] > VECTOR(layers_own)[nei]) {
                    /* Edge goes upwards, we have to flip it */
                    IGRAPH_CHECK(igraph_vector_push_back(&edgelist,
                                                         VECTOR(old2new_vertex_ids)[nei]));
                    for (l = (long int) VECTOR(layers_own)[nei] + 1;
                         l < VECTOR(layers_own)[i]; l++) {
                        IGRAPH_CHECK(igraph_vector_push_back(&new_layers, l));
                        IGRAPH_CHECK(igraph_vector_push_back(&edgelist, next_new_vertex_id));
                        IGRAPH_CHECK(igraph_vector_push_back(&edgelist, next_new_vertex_id++));
                    }
                    IGRAPH_CHECK(igraph_vector_push_back(&edgelist,
                                                         VECTOR(old2new_vertex_ids)[i]));
                    /* Also add the edge to the extended graph if needed, but this time
                     * with the proper orientation */
                    if (extd_graph != 0) {
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, i));
                        next_extd_vertex_id += VECTOR(layers_own)[i] - VECTOR(layers_own)[nei] - 1;
                        for (l = (long int) VECTOR(layers_own)[i] - 1, m = 1;
                             l > VECTOR(layers_own)[nei]; l--, m++) {
                            IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, next_extd_vertex_id - m));
                            IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, next_extd_vertex_id - m));
                            if (extd_to_orig_eids != 0) {
                                IGRAPH_CHECK(igraph_vector_push_back(extd_to_orig_eids, eid));
                            }
                        }
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, nei));
                        if (extd_to_orig_eids != 0) {
                            IGRAPH_CHECK(igraph_vector_push_back(extd_to_orig_eids, eid));
                        }
                    }
                } else {
                    /* Edge goes downwards */
                    IGRAPH_CHECK(igraph_vector_push_back(&edgelist,
                                                         VECTOR(old2new_vertex_ids)[i]));
                    for (l = (long int) VECTOR(layers_own)[i] + 1;
                         l < VECTOR(layers_own)[nei]; l++) {
                        IGRAPH_CHECK(igraph_vector_push_back(&new_layers, l));
                        IGRAPH_CHECK(igraph_vector_push_back(&edgelist, next_new_vertex_id));
                        IGRAPH_CHECK(igraph_vector_push_back(&edgelist, next_new_vertex_id++));
                    }
                    IGRAPH_CHECK(igraph_vector_push_back(&edgelist,
                                                         VECTOR(old2new_vertex_ids)[nei]));
                    /* Also add the edge to the extended graph */
                    if (extd_graph != 0) {
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, i));
                        for (l = (long int) VECTOR(layers_own)[i] + 1;
                             l < VECTOR(layers_own)[nei]; l++) {
                            IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, next_extd_vertex_id));
                            IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, next_extd_vertex_id++));
                            if (extd_to_orig_eids != 0) {
                                IGRAPH_CHECK(igraph_vector_push_back(extd_to_orig_eids, eid));
                            }
                        }
                        IGRAPH_CHECK(igraph_vector_push_back(&extd_edgelist, nei));
                        if (extd_to_orig_eids != 0) {
                            IGRAPH_CHECK(igraph_vector_push_back(extd_to_orig_eids, eid));
                        }
                    }
                }
            }
        }

        /* At this point, we have the subgraph with the dummy nodes and
         * edges, so we can run Sugiyama's algorithm on it. */
        {
            igraph_matrix_t layout;
            igraph_i_layering_t layering;
            igraph_t subgraph;

            IGRAPH_CHECK(igraph_matrix_init(&layout, next_new_vertex_id, 2));
            IGRAPH_FINALLY(igraph_matrix_destroy, &layout);
            IGRAPH_CHECK(igraph_create(&subgraph, &edgelist, (igraph_integer_t)
                                       next_new_vertex_id, 1));
            IGRAPH_FINALLY(igraph_destroy, &subgraph);

            /*
            igraph_vector_print(&edgelist);
            igraph_vector_print(&new_layers);
            */

            /* Assign the vertical coordinates */
            for (i = 0; i < next_new_vertex_id; i++) {
                MATRIX(layout, i, 1) = VECTOR(new_layers)[i];
            }

            /* Create a layering */
            IGRAPH_CHECK(igraph_i_layering_init(&layering, &new_layers));
            IGRAPH_FINALLY(igraph_i_layering_destroy, &layering);

            /* Find the order in which the nodes within a layer should be placed */
            IGRAPH_CHECK(igraph_i_layout_sugiyama_order_nodes_horizontally(&subgraph, &layout,
                         &layering, maxiter));

            /* Assign the horizontal coordinates. This is according to the algorithm
             * of Brandes & Köpf */
            IGRAPH_CHECK(igraph_i_layout_sugiyama_place_nodes_horizontally(&subgraph, &layout,
                         &layering, hgap, (igraph_integer_t) component_size));

            /* Re-assign rows into the result matrix, and at the same time, */
            /* adjust dx so that the next component does not overlap this one */
            j = next_new_vertex_id - component_size;
            k = igraph_matrix_nrow(res);
            IGRAPH_CHECK(igraph_matrix_add_rows(res, j));
            dx2 = dx;
            for (i = 0; i < component_size; i++) {
                l = (long int)VECTOR(new2old_vertex_ids)[i];
                MATRIX(*res, l, 0) = MATRIX(layout, i, 0) + dx;
                MATRIX(*res, l, 1) = VECTOR(layer_to_y)[(long)MATRIX(layout, i, 1)];
                if (dx2 < MATRIX(*res, l, 0)) {
                    dx2 = MATRIX(*res, l, 0);
                }
            }
            for (i = component_size; i < next_new_vertex_id; i++) {
                MATRIX(*res, k, 0) = MATRIX(layout, i, 0) + dx;
                MATRIX(*res, k, 1) = VECTOR(layer_to_y)[(long)MATRIX(layout, i, 1)];
                if (dx2 < MATRIX(*res, k, 0)) {
                    dx2 = MATRIX(*res, k, 0);
                }
                k++;
            }
            dx = dx2 + hgap;

            igraph_destroy(&subgraph);
            igraph_i_layering_destroy(&layering);
            igraph_matrix_destroy(&layout);
            IGRAPH_FINALLY_CLEAN(3);
        }

        igraph_vector_destroy(&new_layers);
        igraph_vector_destroy(&old2new_vertex_ids);
        igraph_vector_destroy(&new2old_vertex_ids);
        igraph_vector_destroy(&edgelist);
        igraph_vector_destroy(&neis);
        IGRAPH_FINALLY_CLEAN(5);
    }

    igraph_vector_destroy(&layers_own);
    igraph_vector_destroy(&layer_to_y);
    igraph_vector_destroy(&membership);
    IGRAPH_FINALLY_CLEAN(3);

    if (extd_graph != 0) {
        IGRAPH_CHECK(igraph_create(extd_graph, &extd_edgelist, (igraph_integer_t)
                                   next_extd_vertex_id, igraph_is_directed(graph)));
        igraph_vector_destroy(&extd_edgelist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return IGRAPH_SUCCESS;
}

static int igraph_i_layout_sugiyama_place_nodes_vertically(const igraph_t* graph,
        const igraph_vector_t* weights, igraph_vector_t* membership) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));

    if (no_of_edges == 0) {
        igraph_vector_fill(membership, 0);
        return IGRAPH_SUCCESS;
    }

#ifdef HAVE_GLPK
    if (igraph_is_directed(graph) && no_of_nodes <= 1000) {
        /* Network simplex algorithm of Gansner et al, using the original linear
         * programming formulation */
        long int i, j;
        igraph_vector_t outdegs, indegs, feedback_edges;
        glp_prob *ip;
        glp_smcp parm;

        /* Allocate storage and create the problem */
        ip = glp_create_prob();
        IGRAPH_FINALLY(glp_delete_prob, ip);
        IGRAPH_VECTOR_INIT_FINALLY(&feedback_edges, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&outdegs, no_of_nodes);
        IGRAPH_VECTOR_INIT_FINALLY(&indegs, no_of_nodes);

        /* Find an approximate feedback edge set */
        IGRAPH_CHECK(igraph_i_feedback_arc_set_eades(graph, &feedback_edges, weights, 0));
        igraph_vector_sort(&feedback_edges);

        /* Calculate in- and out-strengths for the remaining edges */
        IGRAPH_CHECK(igraph_strength(graph, &indegs, igraph_vss_all(),
                                     IGRAPH_IN, 1, weights));
        IGRAPH_CHECK(igraph_strength(graph, &outdegs, igraph_vss_all(),
                                     IGRAPH_IN, 1, weights));
        j = igraph_vector_size(&feedback_edges);
        for (i = 0; i < j; i++) {
            long int eid = (long int) VECTOR(feedback_edges)[i];
            long int from = IGRAPH_FROM(graph, eid);
            long int to = IGRAPH_TO(graph, eid);
            VECTOR(outdegs)[from] -= weights ? VECTOR(*weights)[eid] : 1;
            VECTOR(indegs)[to] -= weights ? VECTOR(*weights)[eid] : 1;
        }

        /* Configure GLPK */
        glp_term_out(GLP_OFF);
        glp_init_smcp(&parm);
        parm.msg_lev = GLP_MSG_OFF;
        parm.presolve = GLP_OFF;

        /* Set up variables and objective function coefficients */
        glp_set_obj_dir(ip, GLP_MIN);
        glp_add_cols(ip, (int) no_of_nodes);
        IGRAPH_CHECK(igraph_vector_sub(&outdegs, &indegs));
        for (i = 1; i <= no_of_nodes; i++) {
            glp_set_col_kind(ip, (int) i, GLP_IV);
            glp_set_col_bnds(ip, (int) i, GLP_LO, 0.0, 0.0);
            glp_set_obj_coef(ip, (int) i, VECTOR(outdegs)[i - 1]);
        }
        igraph_vector_destroy(&indegs);
        igraph_vector_destroy(&outdegs);
        IGRAPH_FINALLY_CLEAN(2);

        /* Add constraints */
        glp_add_rows(ip, (int) no_of_edges);
        IGRAPH_CHECK(igraph_vector_push_back(&feedback_edges, -1));
        j = 0;
        for (i = 0; i < no_of_edges; i++) {
            int ind[3];
            double val[3] = {0, -1, 1};
            ind[1] = IGRAPH_FROM(graph, i) + 1;
            ind[2] = IGRAPH_TO(graph, i) + 1;

            if (ind[1] == ind[2]) {
                if (VECTOR(feedback_edges)[j] == i) {
                    j++;
                }
                continue;
            }

            if (VECTOR(feedback_edges)[j] == i) {
                /* This is a feedback edge, add it reversed */
                glp_set_row_bnds(ip, (int) i + 1, GLP_UP, -1, -1);
                j++;
            } else {
                glp_set_row_bnds(ip, (int) i + 1, GLP_LO, 1, 1);
            }
            glp_set_mat_row(ip, (int) i + 1, 2, ind, val);
        }

        /* Solve the problem */
        IGRAPH_GLPK_CHECK(glp_simplex(ip, &parm),
                          "Vertical arrangement step using IP failed");

        /* The problem is totally unimodular, therefore the output of the simplex
         * solver can be converted to an integer solution easily */
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*membership)[i] = floor(glp_get_col_prim(ip, (int) i + 1));
        }

        glp_delete_prob(ip);
        igraph_vector_destroy(&feedback_edges);
        IGRAPH_FINALLY_CLEAN(2);
    } else if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_feedback_arc_set_eades(graph, 0, weights, membership));
    } else {
        IGRAPH_CHECK(igraph_i_feedback_arc_set_undirected(graph, 0, weights, membership));
    }
#else
    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_feedback_arc_set_eades(graph, 0, weights, membership));
    } else {
        IGRAPH_CHECK(igraph_i_feedback_arc_set_undirected(graph, 0, weights, membership));
    }
#endif

    return IGRAPH_SUCCESS;
}

static int igraph_i_layout_sugiyama_calculate_barycenters(const igraph_t* graph,
        const igraph_i_layering_t* layering, long int layer_index,
        igraph_neimode_t direction, const igraph_matrix_t* layout,
        igraph_vector_t* barycenters) {
    long int i, j, m, n;
    igraph_vector_t* layer_members = igraph_i_layering_get(layering, layer_index);
    igraph_vector_t neis;

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    n = igraph_vector_size(layer_members);
    IGRAPH_CHECK(igraph_vector_resize(barycenters, n));
    igraph_vector_null(barycenters);

    for (i = 0; i < n; i++) {
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t)
                                      VECTOR(*layer_members)[i], direction));
        m = igraph_vector_size(&neis);
        if (m == 0) {
            /* No neighbors in this direction. Just use the current X coordinate */
            VECTOR(*barycenters)[i] = MATRIX(*layout, i, 0);
        } else {
            for (j = 0; j < m; j++) {
                VECTOR(*barycenters)[i] += MATRIX(*layout, (long)VECTOR(neis)[j], 0);
            }
            VECTOR(*barycenters)[i] /= m;
        }
    }

    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * Given a properly layered graph where each edge points downwards and spans
 * exactly one layer, arranges the nodes in each layer horizontally in a way
 * that strives to minimize edge crossings.
 */
static int igraph_i_layout_sugiyama_order_nodes_horizontally(const igraph_t* graph,
        igraph_matrix_t* layout, const igraph_i_layering_t* layering,
        long int maxiter) {
    long int i, n, nei;
    long int no_of_vertices = igraph_vcount(graph);
    long int no_of_layers = igraph_i_layering_num_layers(layering);
    long int iter, layer_index;
    igraph_vector_t* layer_members;
    igraph_vector_t neis, barycenters, sort_indices;
    igraph_bool_t changed;

    /* The first column of the matrix will serve as the ordering */
    /* Start with a first-seen ordering within each layer */
    {
        long int *xs = IGRAPH_CALLOC(no_of_layers, long int);
        if (xs == 0) {
            IGRAPH_ERROR("cannot order nodes horizontally", IGRAPH_ENOMEM);
        }
        for (i = 0; i < no_of_vertices; i++) {
            MATRIX(*layout, i, 0) = xs[(long int)MATRIX(*layout, i, 1)]++;
        }
        free(xs);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&barycenters, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&sort_indices, 0);

    /* Start the effective part of the Sugiyama algorithm */
    iter = 0; changed = 1;
    while (changed && iter < maxiter) {
        changed = 0;

        /* Phase 1 */

        /* Moving downwards and sorting by upper barycenters */
        for (layer_index = 1; layer_index < no_of_layers; layer_index++) {
            layer_members = igraph_i_layering_get(layering, layer_index);
            n = igraph_vector_size(layer_members);

            igraph_i_layout_sugiyama_calculate_barycenters(graph,
                    layering, layer_index, IGRAPH_IN, layout, &barycenters);

#ifdef SUGIYAMA_DEBUG
            printf("Layer %ld, aligning to upper barycenters\n", layer_index);
            printf("Vertices: "); igraph_vector_print(layer_members);
            printf("Barycenters: "); igraph_vector_print(&barycenters);
#endif
            IGRAPH_CHECK((int) igraph_vector_qsort_ind(&barycenters,
                         &sort_indices, 0));
            for (i = 0; i < n; i++) {
                nei = (long)VECTOR(*layer_members)[(long)VECTOR(sort_indices)[i]];
                VECTOR(barycenters)[i] = nei;
                MATRIX(*layout, nei, 0) = i;
            }
            if (!igraph_vector_all_e(layer_members, &barycenters)) {
                IGRAPH_CHECK(igraph_vector_update(layer_members, &barycenters));
#ifdef SUGIYAMA_DEBUG
                printf("New vertex order: "); igraph_vector_print(layer_members);
#endif
                changed = 1;
            } else {
#ifdef SUGIYAMA_DEBUG
                printf("Order did not change.\n");
#endif
            }
        }

        /* Moving upwards and sorting by lower barycenters */
        for (layer_index = no_of_layers - 2; layer_index >= 0; layer_index--) {
            layer_members = igraph_i_layering_get(layering, layer_index);
            n = igraph_vector_size(layer_members);

            igraph_i_layout_sugiyama_calculate_barycenters(graph,
                    layering, layer_index, IGRAPH_OUT, layout, &barycenters);

#ifdef SUGIYAMA_DEBUG
            printf("Layer %ld, aligning to lower barycenters\n", layer_index);
            printf("Vertices: "); igraph_vector_print(layer_members);
            printf("Barycenters: "); igraph_vector_print(&barycenters);
#endif

            IGRAPH_CHECK((int) igraph_vector_qsort_ind(&barycenters,
                         &sort_indices, 0));
            for (i = 0; i < n; i++) {
                nei = (long)VECTOR(*layer_members)[(long)VECTOR(sort_indices)[i]];
                VECTOR(barycenters)[i] = nei;
                MATRIX(*layout, nei, 0) = i;
            }
            if (!igraph_vector_all_e(layer_members, &barycenters)) {
                IGRAPH_CHECK(igraph_vector_update(layer_members, &barycenters));
#ifdef SUGIYAMA_DEBUG
                printf("New vertex order: "); igraph_vector_print(layer_members);
#endif
                changed = 1;
            } else {
#ifdef SUGIYAMA_DEBUG
                printf("Order did not change.\n");
#endif
            }
        }

#ifdef SUGIYAMA_DEBUG
        printf("==== Finished iteration %ld\n", iter);
#endif

        iter++;
    }

    igraph_vector_destroy(&barycenters);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&sort_indices);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

#define IS_DUMMY(v) ((v >= no_of_real_nodes))
#define IS_INNER_SEGMENT(u, v) (IS_DUMMY(u) && IS_DUMMY(v))
#define X_POS(v) (MATRIX(*layout, v, 0))

static int igraph_i_layout_sugiyama_vertical_alignment(const igraph_t* graph,
        const igraph_i_layering_t* layering, const igraph_matrix_t* layout,
        const igraph_vector_bool_t* ignored_edges,
        igraph_bool_t reverse, igraph_bool_t align_right,
        igraph_vector_t* roots, igraph_vector_t* align);
static int igraph_i_layout_sugiyama_horizontal_compaction(const igraph_t* graph,
        const igraph_vector_t* vertex_to_the_left,
        const igraph_vector_t* roots, const igraph_vector_t* align,
        igraph_real_t hgap, igraph_vector_t* xs);
static int igraph_i_layout_sugiyama_horizontal_compaction_place_block(long int v,
        const igraph_vector_t* vertex_to_the_left,
        const igraph_vector_t* roots, const igraph_vector_t* align,
        igraph_vector_t* sinks, igraph_vector_t* shifts,
        igraph_real_t hgap, igraph_vector_t* xs);

static int igraph_i_layout_sugiyama_place_nodes_horizontally(const igraph_t* graph,
        igraph_matrix_t* layout, const igraph_i_layering_t* layering,
        igraph_real_t hgap, igraph_integer_t no_of_real_nodes) {

    long int i, j, k, l, n;
    long int no_of_layers = igraph_i_layering_num_layers(layering);
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t neis1, neis2;
    igraph_vector_t xs[4];
    igraph_vector_t roots, align;
    igraph_vector_t vertex_to_the_left;
    igraph_vector_bool_t ignored_edges;

    /*
    {
      igraph_vector_t edgelist;
      IGRAPH_VECTOR_INIT_FINALLY(&edgelist, 0);
      IGRAPH_CHECK(igraph_get_edgelist(graph, &edgelist, 0));
      igraph_vector_print(&edgelist);
      igraph_vector_destroy(&edgelist);
      IGRAPH_FINALLY_CLEAN(1);

      for (i = 0; i < no_of_layers; i++) {
        igraph_vector_t* layer = igraph_i_layering_get(layering, i);
        igraph_vector_print(layer);
      }
    }
    */

    IGRAPH_CHECK(igraph_vector_bool_init(&ignored_edges, no_of_edges));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &ignored_edges);

    IGRAPH_VECTOR_INIT_FINALLY(&vertex_to_the_left, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis2, 0);

    /* First, find all type 1 conflicts and mark one of the edges participating
     * in the conflict as being ignored. If one of the edges in the conflict
     * is a non-inner segment and the other is an inner segment, we ignore the
     * non-inner segment as we want to keep inner segments vertical.
     */
    for (i = 0; i < no_of_layers - 1; i++) {
        igraph_vector_t* vertices = igraph_i_layering_get(layering, i);
        n = igraph_vector_size(vertices);

        /* Find all the edges from this layer to the next */
        igraph_vector_clear(&neis1);
        for (j = 0; j < n; j++) {
            IGRAPH_CHECK(igraph_neighbors(graph, &neis2, (igraph_integer_t)
                                          VECTOR(*vertices)[j], IGRAPH_OUT));
            IGRAPH_CHECK(igraph_vector_append(&neis1, &neis2));
        }

        /* Consider all pairs of edges and check whether they are in a type 1
         * conflict */
        n = igraph_vector_size(&neis1);
        for (j = 0; j < n; j++) {
            long int u = IGRAPH_FROM(graph, j);
            long int v = IGRAPH_TO(graph, j);
            igraph_bool_t j_inner = IS_INNER_SEGMENT(u, v);
            igraph_bool_t crossing;

            for (k = j + 1; k < n; k++) {
                long int w = IGRAPH_FROM(graph, k);
                long int x = IGRAPH_TO(graph, k);
                if (IS_INNER_SEGMENT(w, x) == j_inner) {
                    continue;
                }
                /* Do the u --> v and w --> x edges cross? */
                crossing = (u == w || v == x);
                if (!crossing) {
                    if (X_POS(u) <= X_POS(w)) {
                        crossing = X_POS(v) >= X_POS(x);
                    } else {
                        crossing = X_POS(v) <= X_POS(x);
                    }
                }
                if (crossing) {
                    if (j_inner) {
                        VECTOR(ignored_edges)[k] = 1;
                    } else {
                        VECTOR(ignored_edges)[j] = 1;
                    }
                }
            }
        }
    }

    igraph_vector_destroy(&neis1);
    igraph_vector_destroy(&neis2);
    IGRAPH_FINALLY_CLEAN(2);

    /*
     * Prepare vertex_to_the_left where the ith element stores
     * the index of the vertex to the left of vertex i, or i itself if the
     * vertex is the leftmost vertex in a layer.
     */
    for (i = 0; i < no_of_layers; i++) {
        igraph_vector_t* vertices = igraph_i_layering_get(layering, i);
        n = igraph_vector_size(vertices);
        if (n == 0) {
            continue;
        }

        k = l = (long int)VECTOR(*vertices)[0];
        VECTOR(vertex_to_the_left)[k] = k;
        for (j = 1; j < n; j++) {
            k = (long int)VECTOR(*vertices)[j];
            VECTOR(vertex_to_the_left)[k] = l;
            l = k;
        }
    }

    /* Type 1 conflicts found, ignored edges chosen, vertex_to_the_left
     * prepared. Run vertical alignment for all four combinations */
    for (i = 0; i < 4; i++) {
        IGRAPH_VECTOR_INIT_FINALLY(&xs[i], no_of_nodes);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&roots, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&align, no_of_nodes);

    for (i = 0; i < 4; i++) {
        IGRAPH_CHECK(igraph_i_layout_sugiyama_vertical_alignment(graph,
                     layering, layout, &ignored_edges,
                     /* reverse = */ (igraph_bool_t) i / 2, /* align_right = */ i % 2,
                     &roots, &align));
        IGRAPH_CHECK(igraph_i_layout_sugiyama_horizontal_compaction(graph,
                     &vertex_to_the_left, &roots, &align, hgap, &xs[i]));
    }

    {
        igraph_real_t width, min_width, mins[4], maxs[4], diff;
        /* Find the alignment with the minimum width */
        min_width = IGRAPH_INFINITY; j = 0;
        for (i = 0; i < 4; i++) {
            mins[i] = igraph_vector_min(&xs[i]);
            maxs[i] = igraph_vector_max(&xs[i]);
            width = maxs[i] - mins[i];
            if (width < min_width) {
                min_width = width;
                j = i;
            }
        }

        /* Leftmost alignments: align them s.t. the min X coordinate is equal to
         * the minimum X coordinate of the alignment with the smallest width.
         * Rightmost alignments: align them s.t. the max X coordinate is equal to
         * the max X coordinate of the alignment with the smallest width.
         */
        for (i = 0; i < 4; i++) {
            if (j == i) {
                continue;
            }
            if (i % 2 == 0) {
                /* Leftmost alignment */
                diff = mins[j] - mins[i];
            } else {
                /* Rightmost alignment */
                diff = maxs[j] - maxs[i];
            }
            igraph_vector_add_constant(&xs[i], diff);
        }
    }

    /* For every vertex, find the median of the X coordinates in the four
     * alignments */
    for (i = 0; i < no_of_nodes; i++) {
        X_POS(i) = igraph_i_median_4(VECTOR(xs[0])[i], VECTOR(xs[1])[i],
                                     VECTOR(xs[2])[i], VECTOR(xs[3])[i]);
    }

    igraph_vector_destroy(&roots);
    igraph_vector_destroy(&align);
    IGRAPH_FINALLY_CLEAN(2);

    for (i = 0; i < 4; i++) {
        igraph_vector_destroy(&xs[i]);
    }
    IGRAPH_FINALLY_CLEAN(4);

    igraph_vector_destroy(&vertex_to_the_left);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_vector_bool_destroy(&ignored_edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

static int igraph_i_layout_sugiyama_vertical_alignment(const igraph_t* graph,
        const igraph_i_layering_t* layering, const igraph_matrix_t* layout,
        const igraph_vector_bool_t* ignored_edges,
        igraph_bool_t reverse, igraph_bool_t align_right,
        igraph_vector_t* roots, igraph_vector_t* align) {
    long int i, j, k, n, di, dj, i_limit, j_limit, r;
    long int no_of_layers = igraph_i_layering_num_layers(layering);
    long int no_of_nodes = igraph_vcount(graph);
    igraph_neimode_t neimode = (reverse ? IGRAPH_OUT : IGRAPH_IN);
    igraph_vector_t neis, xs, inds;

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&xs, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&inds, 0);

    IGRAPH_CHECK(igraph_vector_resize(roots, no_of_nodes));
    IGRAPH_CHECK(igraph_vector_resize(align, no_of_nodes));

    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(*roots)[i] = VECTOR(*align)[i] = i;
    }

    /* When reverse = False, we are aligning "upwards" in the tree, hence we
     * have to loop i from 1 to no_of_layers-1 (inclusive) and use neimode=IGRAPH_IN.
     * When reverse = True, we are aligning "downwards", hence we have to loop
     * i from no_of_layers-2 to 0 (inclusive) and use neimode=IGRAPH_OUT.
     */
    i       = reverse ? (no_of_layers - 2) : 1;
    di      = reverse ? -1 : 1;
    i_limit = reverse ? -1 : no_of_layers;
    for (; i != i_limit; i += di) {
        igraph_vector_t *layer = igraph_i_layering_get(layering, i);

        /* r = 0 in the paper, but C arrays are indexed from 0 */
        r = align_right ? LONG_MAX : -1;

        /* If align_right is 1, we have to process the layer in reverse order */
        j       = align_right ? (igraph_vector_size(layer) - 1) : 0;
        dj      = align_right ? -1 : 1;
        j_limit = align_right ? -1 : igraph_vector_size(layer);
        for (; j != j_limit; j += dj) {
            long int medians[2];
            long int vertex = (long int) VECTOR(*layer)[j];
            long int pos;

            if (VECTOR(*align)[vertex] != vertex)
                /* This vertex is already aligned with some other vertex,
                 * so there's nothing to do */
            {
                continue;
            }

            /* Find the neighbors of vertex j in layer i */
            IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) vertex,
                                          neimode));

            n = igraph_vector_size(&neis);
            if (n == 0)
                /* No neighbors in this direction, continue */
            {
                continue;
            }
            if (n == 1) {
                /* Just one neighbor; the median is trivial */
                medians[0] = (long int) VECTOR(neis)[0];
                medians[1] = -1;
            } else {
                /* Sort the neighbors by their X coordinates */
                IGRAPH_CHECK(igraph_vector_resize(&xs, n));
                for (k = 0; k < n; k++) {
                    VECTOR(xs)[k] = X_POS((long int)VECTOR(neis)[k]);
                }
                IGRAPH_CHECK((int) igraph_vector_qsort_ind(&xs, &inds, 0));

                if (n % 2 == 1) {
                    /* Odd number of neighbors, so the median is unique */
                    medians[0] = (long int) VECTOR(neis)[(long int)VECTOR(inds)[n / 2]];
                    medians[1] = -1;
                } else {
                    /* Even number of neighbors, so we have two medians. The order
                     * depends on whether we are processing the layer in leftmost
                     * or rightmost fashion. */
                    if (align_right) {
                        medians[0] = (long int) VECTOR(neis)[(long int)VECTOR(inds)[n / 2]];
                        medians[1] = (long int) VECTOR(neis)[(long int)VECTOR(inds)[n / 2 - 1]];
                    } else {
                        medians[0] = (long int) VECTOR(neis)[(long int)VECTOR(inds)[n / 2 - 1]];
                        medians[1] = (long int) VECTOR(neis)[(long int)VECTOR(inds)[n / 2]];
                    }
                }
            }

            /* Try aligning with the medians */
            for (k = 0; k < 2; k++) {
                igraph_integer_t eid;
                if (medians[k] < 0) {
                    continue;
                }
                if (VECTOR(*align)[vertex] != vertex) {
                    /* Vertex already aligned, continue */
                    continue;
                }
                /* Is the edge between medians[k] and vertex ignored
                 * because of a type 1 conflict? */
                IGRAPH_CHECK(igraph_get_eid(graph, &eid, (igraph_integer_t) vertex,
                                            (igraph_integer_t) medians[k], 0, 1));
                if (VECTOR(*ignored_edges)[(long int)eid]) {
                    continue;
                }
                /* Okay, align with the median if possible */
                pos = (long int) X_POS(medians[k]);
                if ((align_right && r > pos) || (!align_right && r < pos)) {
                    VECTOR(*align)[medians[k]] = vertex;
                    VECTOR(*roots)[vertex] = VECTOR(*roots)[medians[k]];
                    VECTOR(*align)[vertex] = VECTOR(*roots)[medians[k]];
                    r = pos;
                }
            }
        }
    }

    igraph_vector_destroy(&inds);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&xs);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/*
 * Runs a horizontal compaction given a vertical alignment (in `align`)
 * and the roots (in `roots`). These come out directly from
 * igraph_i_layout_sugiyama_vertical_alignment.
 *
 * Returns the X coordinates for each vertex in `xs`.
 *
 * `graph` is the input graph, `layering` is the layering on which we operate.
 * `hgap` is the preferred horizontal gap between vertices.
 */
static int igraph_i_layout_sugiyama_horizontal_compaction(const igraph_t* graph,
        const igraph_vector_t* vertex_to_the_left,
        const igraph_vector_t* roots, const igraph_vector_t* align,
        igraph_real_t hgap, igraph_vector_t* xs) {
    long int i;
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t sinks, shifts, old_xs;
    igraph_real_t shift;

    /* Initialization */

    IGRAPH_VECTOR_INIT_FINALLY(&sinks, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&shifts, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&old_xs, no_of_nodes);

    IGRAPH_CHECK(igraph_vector_resize(xs, no_of_nodes));

    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(sinks)[i] = i;
    }
    igraph_vector_fill(&shifts, IGRAPH_INFINITY);
    igraph_vector_fill(xs, -1);

    /* Calculate the coordinates of the vertices relative to their sinks
     * in their own class. At the end of this for loop, xs will contain the
     * relative displacement of a vertex from its sink, while the shifts list
     * will contain the absolute displacement of the sinks.
     * (For the sinks only, of course, the rest is undefined and unused)
     */
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*roots)[i] == i) {
            IGRAPH_CHECK(
                igraph_i_layout_sugiyama_horizontal_compaction_place_block(i,
                        vertex_to_the_left, roots, align, &sinks, &shifts, hgap, xs)
            );
        }
    }

    /* In "sinks", only those indices `i` matter for which `i` is in `roots`.
     * All the other values will never be touched.
     */

    /* Calculate the absolute coordinates */
    IGRAPH_CHECK(igraph_vector_update(&old_xs, xs));
    for (i = 0; i < no_of_nodes; i++) {
        long int root = (long int) VECTOR(*roots)[i];
        VECTOR(*xs)[i] = VECTOR(old_xs)[root];
        shift = VECTOR(shifts)[(long int)VECTOR(sinks)[root]];
        if (shift < IGRAPH_INFINITY) {
            VECTOR(*xs)[i] += shift;
        }
    }

    igraph_vector_destroy(&sinks);
    igraph_vector_destroy(&shifts);
    igraph_vector_destroy(&old_xs);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

static int igraph_i_layout_sugiyama_horizontal_compaction_place_block(long int v,
        const igraph_vector_t* vertex_to_the_left,
        const igraph_vector_t* roots, const igraph_vector_t* align,
        igraph_vector_t* sinks, igraph_vector_t* shifts,
        igraph_real_t hgap, igraph_vector_t* xs) {
    long int u, w;
    long int u_sink, v_sink;

    if (VECTOR(*xs)[v] >= 0) {
        return IGRAPH_SUCCESS;
    }

    VECTOR(*xs)[v] = 0;

    w = v;
    do {
        /* Check whether vertex w is the leftmost in its own layer */
        u = (long int) VECTOR(*vertex_to_the_left)[w];
        if (u != w) {
            /* Get the root of u (proceeding all the way upwards in the block) */
            u = (long int) VECTOR(*roots)[u];
            /* Place the block of u recursively */
            IGRAPH_CHECK(
                igraph_i_layout_sugiyama_horizontal_compaction_place_block(u,
                        vertex_to_the_left, roots, align, sinks, shifts, hgap, xs)
            );

            u_sink = (long int) VECTOR(*sinks)[u];
            v_sink = (long int) VECTOR(*sinks)[v];
            /* If v is its own sink yet, set its sink to the sink of u */
            if (v_sink == v) {
                VECTOR(*sinks)[v] = v_sink = u_sink;
            }
            /* If v and u have different sinks (i.e. they are in different classes),
             * shift the sink of u so that the two blocks are separated by the
             * preferred gap
             */
            if (v_sink != u_sink) {
                if (VECTOR(*shifts)[u_sink] > VECTOR(*xs)[v] - VECTOR(*xs)[u] - hgap) {
                    VECTOR(*shifts)[u_sink] = VECTOR(*xs)[v] - VECTOR(*xs)[u] - hgap;
                }
            } else {
                /* v and u have the same sink, i.e. they are in the same class. Make sure
                 * that v is separated from u by at least hgap.
                 */
                if (VECTOR(*xs)[v] < VECTOR(*xs)[u] + hgap) {
                    VECTOR(*xs)[v] = VECTOR(*xs)[u] + hgap;
                }
            }
        }

        /* Follow the alignment */
        w = (long int) VECTOR(*align)[w];
    } while (w != v);

    return IGRAPH_SUCCESS;
}

#undef IS_INNER_SEGMENT
#undef IS_DUMMY
#undef X_POS

#ifdef SUGIYAMA_DEBUG
    #undef SUGIYAMA_DEBUG
#endif
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.531141
igraph-0.9.9/vendor/source/igraph/src/linalg/0000755000175100001710000000000000000000000021707 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/arpack.c0000644000175100001710000014602200000000000023321 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 noet: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_arpack.h"
#include "igraph_memory.h"

#include "linalg/arpack_internal.h"

#include 
#include 
#include 

/* The ARPACK example file dssimp.f is used as a template */

static int igraph_i_arpack_err_dsaupd(int error) {
    switch (error) {
    case  1:      return IGRAPH_ARPACK_MAXIT;
    case  3:      return IGRAPH_ARPACK_NOSHIFT;
    case -1:      return IGRAPH_ARPACK_NPOS;
    case -2:      return IGRAPH_ARPACK_NEVNPOS;
    case -3:      return IGRAPH_ARPACK_NCVSMALL;
    case -4:      return IGRAPH_ARPACK_NONPOSI;
    case -5:      return IGRAPH_ARPACK_WHICHINV;
    case -6:      return IGRAPH_ARPACK_BMATINV;
    case -7:      return IGRAPH_ARPACK_WORKLSMALL;
    case -8:      return IGRAPH_ARPACK_TRIDERR;
    case -9:      return IGRAPH_ARPACK_ZEROSTART;
    case -10:     return IGRAPH_ARPACK_MODEINV;
    case -11:     return IGRAPH_ARPACK_MODEBMAT;
    case -12:     return IGRAPH_ARPACK_ISHIFT;
    case -13:     return IGRAPH_ARPACK_NEVBE;
    case -9999:   return IGRAPH_ARPACK_NOFACT;
    default:      return IGRAPH_ARPACK_UNKNOWN;
    }
}

static int igraph_i_arpack_err_dseupd(int error) {
    switch (error) {
    case -1:      return IGRAPH_ARPACK_NPOS;
    case -2:      return IGRAPH_ARPACK_NEVNPOS;
    case -3:      return IGRAPH_ARPACK_NCVSMALL;
    case -5:      return IGRAPH_ARPACK_WHICHINV;
    case -6:      return IGRAPH_ARPACK_BMATINV;
    case -7:      return IGRAPH_ARPACK_WORKLSMALL;
    case -8:      return IGRAPH_ARPACK_TRIDERR;
    case -9:      return IGRAPH_ARPACK_ZEROSTART;
    case -10:     return IGRAPH_ARPACK_MODEINV;
    case -11:     return IGRAPH_ARPACK_MODEBMAT;
    case -12:     return IGRAPH_ARPACK_NEVBE;
    case -14:     return IGRAPH_ARPACK_FAILED;
    case -15:     return IGRAPH_ARPACK_HOWMNY;
    case -16:     return IGRAPH_ARPACK_HOWMNYS;
    case -17:     return IGRAPH_ARPACK_EVDIFF;
    default:      return IGRAPH_ARPACK_UNKNOWN;
    }

}

static int igraph_i_arpack_err_dnaupd(int error) {
    switch (error) {
    case  1:      return IGRAPH_ARPACK_MAXIT;
    case  3:      return IGRAPH_ARPACK_NOSHIFT;
    case -1:      return IGRAPH_ARPACK_NPOS;
    case -2:      return IGRAPH_ARPACK_NEVNPOS;
    case -3:      return IGRAPH_ARPACK_NCVSMALL;
    case -4:      return IGRAPH_ARPACK_NONPOSI;
    case -5:      return IGRAPH_ARPACK_WHICHINV;
    case -6:      return IGRAPH_ARPACK_BMATINV;
    case -7:      return IGRAPH_ARPACK_WORKLSMALL;
    case -8:      return IGRAPH_ARPACK_TRIDERR;
    case -9:      return IGRAPH_ARPACK_ZEROSTART;
    case -10:     return IGRAPH_ARPACK_MODEINV;
    case -11:     return IGRAPH_ARPACK_MODEBMAT;
    case -12:     return IGRAPH_ARPACK_ISHIFT;
    case -9999:   return IGRAPH_ARPACK_NOFACT;
    default:      return IGRAPH_ARPACK_UNKNOWN;
    }
}

static int igraph_i_arpack_err_dneupd(int error) {
    switch (error) {
    case  1:      return IGRAPH_ARPACK_REORDER;
    case -1:      return IGRAPH_ARPACK_NPOS;
    case -2:      return IGRAPH_ARPACK_NEVNPOS;
    case -3:      return IGRAPH_ARPACK_NCVSMALL;
    case -5:      return IGRAPH_ARPACK_WHICHINV;
    case -6:      return IGRAPH_ARPACK_BMATINV;
    case -7:      return IGRAPH_ARPACK_WORKLSMALL;
    case -8:      return IGRAPH_ARPACK_SHUR;
    case -9:      return IGRAPH_ARPACK_LAPACK;
    case -10:     return IGRAPH_ARPACK_MODEINV;
    case -11:     return IGRAPH_ARPACK_MODEBMAT;
    case -12:     return IGRAPH_ARPACK_HOWMNYS;
    case -13:     return IGRAPH_ARPACK_HOWMNY;
    case -14:     return IGRAPH_ARPACK_FAILED;
    case -15:     return IGRAPH_ARPACK_EVDIFF;
    default:      return IGRAPH_ARPACK_UNKNOWN;
    }
}

/**
 * \function igraph_arpack_options_init
 * Initialize ARPACK options
 *
 * Initializes ARPACK options, set them to default values.
 * You can always pass the initialized \ref igraph_arpack_options_t
 * object to built-in igraph functions without any modification. The
 * built-in igraph functions modify the options to perform their
 * calculation, e.g. \ref igraph_pagerank() always searches for the
 * eigenvalue with the largest magnitude, regardless of the supplied
 * value.
 * 
 * If you want to implement your own function involving eigenvalue
 * calculation using ARPACK, however, you will likely need to set up
 * the fields for yourself.
 * \param o The \ref igraph_arpack_options_t object to initialize.
 *
 * Time complexity: O(1).
 */

void igraph_arpack_options_init(igraph_arpack_options_t *o) {
    o->bmat[0] = 'I';
    o->n = 0;         /* needs to be updated! */
    o->which[0] = 'X'; o->which[1] = 'X';
    o->nev = 1;
    o->tol = 0;
    o->ncv = 0;       /* 0 means "automatic" */
    o->ldv = o->n;        /* will be updated to (real) n */
    o->ishift = 1;
    o->mxiter = 3000;
    o->nb = 1;
    o->mode = 1;
    o->start = 0;
    o->lworkl = 0;
    o->sigma = 0;
    o->sigmai = 0;
    o->info = o->start;

    o->iparam[0] = o->ishift; o->iparam[1] = 0; o->iparam[2] = o->mxiter; o->iparam[3] = o->nb;
    o->iparam[4] = 0; o->iparam[5] = 0; o->iparam[6] = o->mode; o->iparam[7] = 0;
    o->iparam[8] = 0; o->iparam[9] = 0; o->iparam[10] = 0;
}

/**
 * \function igraph_arpack_storage_init
 * Initialize ARPACK storage
 *
 * You only need this function if you want to run multiple eigenvalue
 * calculations using ARPACK, and want to spare the memory
 * allocation/deallocation between each two runs. Otherwise it is safe
 * to supply a null pointer as the \c storage argument of both \ref
 * igraph_arpack_rssolve() and \ref igraph_arpack_rnsolve() to make
 * memory allocated and deallocated automatically.
 *
 * Don't forget to call the \ref
 * igraph_arpack_storage_destroy() function on the storage object if
 * you don't need it any more.
 * \param s The \ref igraph_arpack_storage_t object to initialize.
 * \param maxn The maximum order of the matrices.
 * \param maxncv The maximum NCV parameter intended to use.
 * \param maxldv The maximum LDV parameter intended to use.
 * \param symm Whether symmetric or non-symmetric problems will be
 *    solved using this \ref igraph_arpack_storage_t. (You cannot use
 *    the same storage both with symmetric and non-symmetric solvers.)
 * \return Error code.
 *
 * Time complexity: O(maxncv*(maxldv+maxn)).
 */

int igraph_arpack_storage_init(igraph_arpack_storage_t *s, long int maxn,
                               long int maxncv, long int maxldv,
                               igraph_bool_t symm) {

    /* TODO: check arguments */
    s->maxn = (int) maxn;
    s->maxncv = (int) maxncv;
    s->maxldv = (int) maxldv;

#define CHECKMEM(x) \
    if (!x) { \
        IGRAPH_ERROR("Cannot allocate memory for ARPACK", IGRAPH_ENOMEM); \
    } \
    IGRAPH_FINALLY(igraph_free, x);

    s->v = IGRAPH_CALLOC(maxldv * maxncv, igraph_real_t); CHECKMEM(s->v);
    s->workd = IGRAPH_CALLOC(3 * maxn, igraph_real_t); CHECKMEM(s->workd);
    s->d = IGRAPH_CALLOC(2 * maxncv, igraph_real_t); CHECKMEM(s->d);
    s->resid = IGRAPH_CALLOC(maxn, igraph_real_t); CHECKMEM(s->resid);
    s->ax = IGRAPH_CALLOC(maxn, igraph_real_t); CHECKMEM(s->ax);
    s->select = IGRAPH_CALLOC(maxncv, int); CHECKMEM(s->select);

    if (symm) {
        s->workl = IGRAPH_CALLOC(maxncv * (maxncv + 8), igraph_real_t); CHECKMEM(s->workl);
        s->di = 0;
        s->workev = 0;
    } else {
        s->workl = IGRAPH_CALLOC(3 * maxncv * (maxncv + 2), igraph_real_t); CHECKMEM(s->workl);
        s->di = IGRAPH_CALLOC(2 * maxncv, igraph_real_t); CHECKMEM(s->di);
        s->workev = IGRAPH_CALLOC(3 * maxncv, igraph_real_t); CHECKMEM(s->workev);
        IGRAPH_FINALLY_CLEAN(2);
    }

#undef CHECKMEM

    IGRAPH_FINALLY_CLEAN(7);
    return 0;
}

/**
 * \function igraph_arpack_storage_destroy
 * Deallocate ARPACK storage
 *
 * \param s The \ref igraph_arpack_storage_t object for which the
 *    memory will be deallocated.
 *
 * Time complexity: operating system dependent.
 */

void igraph_arpack_storage_destroy(igraph_arpack_storage_t *s) {

    if (s->di) {
        IGRAPH_FREE(s->di);
    }
    if (s->workev) {
        IGRAPH_FREE(s->workev);
    }

    IGRAPH_FREE(s->workl);
    IGRAPH_FREE(s->select);
    IGRAPH_FREE(s->ax);
    IGRAPH_FREE(s->resid);
    IGRAPH_FREE(s->d);
    IGRAPH_FREE(s->workd);
    IGRAPH_FREE(s->v);
}

/**
 * "Solver" for 1x1 eigenvalue problems since ARPACK sometimes blows up with
 * these.
 */
static int igraph_i_arpack_rssolve_1x1(igraph_arpack_function_t *fun, void *extra,
                                       igraph_arpack_options_t* options,
                                       igraph_vector_t* values, igraph_matrix_t* vectors) {
    igraph_real_t a, b;
    int nev = options->nev;

    if (nev <= 0) {
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_NEVNPOS);
    }

    /* Probe the value in the matrix */
    a = 1;
    if (fun(&b, &a, 1, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }

    options->nconv = nev;

    if (values != 0) {
        IGRAPH_CHECK(igraph_vector_resize(values, 1));
        VECTOR(*values)[0] = b;
    }

    if (vectors != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, 1, 1));
        MATRIX(*vectors, 0, 0) = 1;
    }

    return IGRAPH_SUCCESS;
}

/**
 * "Solver" for 1x1 eigenvalue problems since ARPACK sometimes blows up with
 * these.
 */
static int igraph_i_arpack_rnsolve_1x1(igraph_arpack_function_t *fun, void *extra,
                                       igraph_arpack_options_t* options,
                                       igraph_matrix_t* values, igraph_matrix_t* vectors) {
    igraph_real_t a, b;
    int nev = options->nev;

    if (nev <= 0) {
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_NEVNPOS);
    }

    /* Probe the value in the matrix */
    a = 1;
    if (fun(&b, &a, 1, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }

    options->nconv = nev;

    if (values != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(values, 1, 2));
        MATRIX(*values, 0, 0) = b; MATRIX(*values, 0, 1) = 0;
    }

    if (vectors != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, 1, 1));
        MATRIX(*vectors, 0, 0) = 1;
    }

    return IGRAPH_SUCCESS;
}

/**
 * "Solver" for 2x2 nonsymmetric eigenvalue problems since ARPACK sometimes
 * blows up with these.
 */
static int igraph_i_arpack_rnsolve_2x2(igraph_arpack_function_t *fun, void *extra,
                                       igraph_arpack_options_t* options, igraph_matrix_t* values,
                                       igraph_matrix_t* vectors) {
    igraph_real_t vec[2], mat[4];
    igraph_real_t a, b, c, d;
    igraph_real_t trace, det, tsq4_minus_d;
    igraph_complex_t eval1, eval2;
    igraph_complex_t evec1[2], evec2[2];
    igraph_bool_t swap_evals = 0;
    igraph_bool_t complex_evals = 0;
    int nev = options->nev;

    if (nev <= 0) {
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_NEVNPOS);
    }
    if (nev > 2) {
        nev = 2;
    }

    /* Probe the values in the matrix */
    vec[0] = 1; vec[1] = 0;
    if (fun(mat, vec, 2, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }
    vec[0] = 0; vec[1] = 1;
    if (fun(mat + 2, vec, 2, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }
    a = mat[0]; b = mat[2]; c = mat[1]; d = mat[3];

    /* Get the trace and the determinant */
    trace = a + d;
    det = a * d - b * c;
    tsq4_minus_d = trace * trace / 4 - det;

    /* Calculate the eigenvalues */
    complex_evals = tsq4_minus_d < 0;
    eval1 = igraph_complex_sqrt_real(tsq4_minus_d);
    if (complex_evals) {
        eval2 = igraph_complex_mul_real(eval1, -1);
    } else {
        /* to avoid having -0 in the imaginary part */
        eval2 = igraph_complex(-IGRAPH_REAL(eval1), 0);
    }
    eval1 = igraph_complex_add_real(eval1, trace / 2);
    eval2 = igraph_complex_add_real(eval2, trace / 2);

    if (c != 0) {
        evec1[0] = igraph_complex_sub_real(eval1, d);
        evec1[1] = igraph_complex(c, 0);
        evec2[0] = igraph_complex_sub_real(eval2, d);
        evec2[1] = igraph_complex(c, 0);
    } else if (b != 0) {
        evec1[0] = igraph_complex(b, 0);
        evec1[1] = igraph_complex_sub_real(eval1, a);
        evec2[0] = igraph_complex(b, 0);
        evec2[1] = igraph_complex_sub_real(eval2, a);
    } else {
        evec1[0] = igraph_complex(1, 0);
        evec1[1] = igraph_complex(0, 0);
        evec2[0] = igraph_complex(0, 0);
        evec2[1] = igraph_complex(1, 0);
    }

    /* Sometimes we have to swap eval1 with eval2 and evec1 with eval2;
     * determine whether we have to do it now */
    if (options->which[0] == 'S') {
        if (options->which[1] == 'M') {
            /* eval1 must be the one with the smallest magnitude */
            swap_evals = (igraph_complex_mod(eval1) > igraph_complex_mod(eval2));
        } else if (options->which[1] == 'R') {
            /* eval1 must be the one with the smallest real part */
            swap_evals = (IGRAPH_REAL(eval1) > IGRAPH_REAL(eval2));
        } else if (options->which[1] == 'I') {
            /* eval1 must be the one with the smallest imaginary part */
            swap_evals = (IGRAPH_IMAG(eval1) > IGRAPH_IMAG(eval2));
        } else {
            IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_WHICHINV);
        }
    } else if (options->which[0] == 'L') {
        if (options->which[1] == 'M') {
            /* eval1 must be the one with the largest magnitude */
            swap_evals = (igraph_complex_mod(eval1) < igraph_complex_mod(eval2));
        } else if (options->which[1] == 'R') {
            /* eval1 must be the one with the largest real part */
            swap_evals = (IGRAPH_REAL(eval1) < IGRAPH_REAL(eval2));
        } else if (options->which[1] == 'I') {
            /* eval1 must be the one with the largest imaginary part */
            swap_evals = (IGRAPH_IMAG(eval1) < IGRAPH_IMAG(eval2));
        } else {
            IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_WHICHINV);
        }
    } else if (options->which[0] == 'X' && options->which[1] == 'X') {
        /* No preference on the ordering of eigenvectors */
    } else {
        /* fprintf(stderr, "%c%c\n", options->which[0], options->which[1]); */
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_WHICHINV);
    }

    options->nconv = nev;

    if (swap_evals) {
        igraph_complex_t dummy;
        dummy = eval1; eval1 = eval2; eval2 = dummy;
        dummy = evec1[0]; evec1[0] = evec2[0]; evec2[0] = dummy;
        dummy = evec1[1]; evec1[1] = evec2[1]; evec2[1] = dummy;
    }

    if (complex_evals) {
        /* The eigenvalues are conjugate pairs, so we store only the
         * one with positive imaginary part */
        if (IGRAPH_IMAG(eval1) < 0) {
            eval1 = eval2;
            evec1[0] = evec2[0]; evec1[1] = evec2[1];
        }
    }

    if (values != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(values, nev, 2));
        MATRIX(*values, 0, 0) = IGRAPH_REAL(eval1);
        MATRIX(*values, 0, 1) = IGRAPH_IMAG(eval1);
        if (nev > 1) {
            MATRIX(*values, 1, 0) = IGRAPH_REAL(eval2);
            MATRIX(*values, 1, 1) = IGRAPH_IMAG(eval2);
        }
    }

    if (vectors != 0) {
        if (complex_evals) {
            IGRAPH_CHECK(igraph_matrix_resize(vectors, 2, 2));
            MATRIX(*vectors, 0, 0) = IGRAPH_REAL(evec1[0]);
            MATRIX(*vectors, 1, 0) = IGRAPH_REAL(evec1[1]);
            MATRIX(*vectors, 0, 1) = IGRAPH_IMAG(evec1[0]);
            MATRIX(*vectors, 1, 1) = IGRAPH_IMAG(evec1[1]);
        } else {
            IGRAPH_CHECK(igraph_matrix_resize(vectors, 2, nev));
            MATRIX(*vectors, 0, 0) = IGRAPH_REAL(evec1[0]);
            MATRIX(*vectors, 1, 0) = IGRAPH_REAL(evec1[1]);
            if (nev > 1) {
                MATRIX(*vectors, 0, 1) = IGRAPH_REAL(evec2[0]);
                MATRIX(*vectors, 1, 1) = IGRAPH_REAL(evec2[1]);
            }
        }
    }

    return IGRAPH_SUCCESS;
}

/**
 * "Solver" for symmetric 2x2 eigenvalue problems since ARPACK sometimes blows
 * up with these.
 */
static int igraph_i_arpack_rssolve_2x2(igraph_arpack_function_t *fun, void *extra,
                                       igraph_arpack_options_t* options, igraph_vector_t* values,
                                       igraph_matrix_t* vectors) {
    igraph_real_t vec[2], mat[4];
    igraph_real_t a, b, c, d;
    igraph_real_t trace, det, tsq4_minus_d;
    igraph_real_t eval1, eval2;
    int nev = options->nev;

    if (nev <= 0) {
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_NEVNPOS);
    }
    if (nev > 2) {
        nev = 2;
    }

    /* Probe the values in the matrix */
    vec[0] = 1; vec[1] = 0;
    if (fun(mat, vec, 2, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }
    vec[0] = 0; vec[1] = 1;
    if (fun(mat + 2, vec, 2, extra)) {
        IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                     IGRAPH_ARPACK_PROD);
    }
    a = mat[0]; b = mat[2]; c = mat[1]; d = mat[3];

    /* Get the trace and the determinant */
    trace = a + d;
    det = a * d - b * c;
    tsq4_minus_d = trace * trace / 4 - det;

    if (tsq4_minus_d >= 0) {
        /* Both eigenvalues are real */
        eval1 = trace / 2 + sqrt(tsq4_minus_d);
        eval2 = trace / 2 - sqrt(tsq4_minus_d);
        if (c != 0) {
            mat[0] = eval1 - d; mat[2] = eval2 - d;
            mat[1] = c;       mat[3] = c;
        } else if (b != 0) {
            mat[0] = b;       mat[2] = b;
            mat[1] = eval1 - a; mat[3] = eval2 - a;
        } else {
            mat[0] = 1; mat[2] = 0;
            mat[1] = 0; mat[3] = 1;
        }
    } else {
        /* Both eigenvalues are complex. Should not happen with symmetric
         * matrices. */
        IGRAPH_ERROR("ARPACK error, 2x2 matrix is not symmetric", IGRAPH_EINVAL);
    }

    /* eval1 is always the larger eigenvalue. If we want the smaller
     * one, we have to swap eval1 with eval2 and also the columns of mat */
    if (options->which[0] == 'S') {
        trace = eval1; eval1 = eval2; eval2 = trace;
        trace = mat[0]; mat[0] = mat[2]; mat[2] = trace;
        trace = mat[1]; mat[1] = mat[3]; mat[3] = trace;
    } else if (options->which[0] == 'L' || options->which[0] == 'B') {
        /* Nothing to do here */
    } else if (options->which[0] == 'X' && options->which[1] == 'X') {
        /* No preference on the ordering of eigenvectors */
    } else {
        IGRAPH_ERROR("ARPACK error", IGRAPH_ARPACK_WHICHINV);
    }

    options->nconv = nev;

    if (values != 0) {
        IGRAPH_CHECK(igraph_vector_resize(values, nev));
        VECTOR(*values)[0] = eval1;
        if (nev > 1) {
            VECTOR(*values)[1] = eval2;
        }
    }

    if (vectors != 0) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, 2, nev));
        MATRIX(*vectors, 0, 0) = mat[0];
        MATRIX(*vectors, 1, 0) = mat[1];
        if (nev > 1) {
            MATRIX(*vectors, 0, 1) = mat[2];
            MATRIX(*vectors, 1, 1) = mat[3];
        }
    }

    return IGRAPH_SUCCESS;
}

int igraph_arpack_rssort(igraph_vector_t *values, igraph_matrix_t *vectors,
                         const igraph_arpack_options_t *options,
                         igraph_real_t *d, const igraph_real_t *v) {

    igraph_vector_t order;
    char sort[2];
    int apply = 1;
    unsigned int n = (unsigned int) options->n;
    int nconv = options->nconv;
    int nev = options->nev;
    unsigned int nans = (unsigned int) (nconv < nev ? nconv : nev);
    unsigned int i;

#define which(a,b) (options->which[0]==a && options->which[1]==b)

    if (which('L', 'A')) {
        sort[0] = 'S'; sort[1] = 'A';
    } else if (which('S', 'A')) {
        sort[0] = 'L'; sort[1] = 'A';
    } else if (which('L', 'M')) {
        sort[0] = 'S'; sort[1] = 'M';
    } else if (which('S', 'M')) {
        sort[0] = 'L'; sort[1] = 'M';
    } else if (which('B', 'E')) {
        sort[0] = 'L'; sort[1] = 'A';
    }

    IGRAPH_CHECK(igraph_vector_init_seq(&order, 0, nconv - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &order);
#ifdef HAVE_GFORTRAN
    igraphdsortr_(sort, &apply, &nconv, d, VECTOR(order), /*which_len=*/ 2);
#else
    igraphdsortr_(sort, &apply, &nconv, d, VECTOR(order));
#endif

    /* BE is special */
    if (which('B', 'E')) {
        int w = 0, l1 = 0, l2 = nev - 1;
        igraph_vector_t order2, d2;
        IGRAPH_VECTOR_INIT_FINALLY(&order2, nev);
        IGRAPH_VECTOR_INIT_FINALLY(&d2, nev);
        while (l1 <= l2) {
            VECTOR(order2)[w] = VECTOR(order)[l1];
            VECTOR(d2)[w] = d[l1];
            w++; l1++;
            if (l1 <= l2) {
                VECTOR(order2)[w] = VECTOR(order)[l2];
                VECTOR(d2)[w] = d[l2];
                w++; l2--;
            }
        }
        igraph_vector_update(&order, &order2);
        igraph_vector_copy_to(&d2, d);
        igraph_vector_destroy(&order2);
        igraph_vector_destroy(&d2);
        IGRAPH_FINALLY_CLEAN(2);
    }

#undef which

    /* Copy values */
    if (values) {
        IGRAPH_CHECK(igraph_vector_resize(values, nans));
        memcpy(VECTOR(*values), d, sizeof(igraph_real_t) * nans);
    }

    /* Reorder vectors */
    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, nans));
        for (i = 0; i < nans; i++) {
            unsigned int idx = (unsigned int) VECTOR(order)[i];
            const igraph_real_t *ptr = v + n * idx;
            memcpy(&MATRIX(*vectors, 0, i), ptr, sizeof(igraph_real_t) * n);
        }
    }

    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

int igraph_arpack_rnsort(igraph_matrix_t *values, igraph_matrix_t *vectors,
                         const igraph_arpack_options_t *options,
                         igraph_real_t *dr, igraph_real_t *di,
                         igraph_real_t *v) {

    igraph_vector_t order;
    char sort[2];
    int apply = 1;
    unsigned int n = (unsigned int) options->n;
    int nconv = options->nconv;
    int nev = options->nev;
    unsigned int nans = (unsigned int) (nconv < nev ? nconv : nev);
    unsigned int i;

#define which(a,b) (options->which[0]==a && options->which[1]==b)

    if (which('L', 'M')) {
        sort[0] = 'S'; sort[1] = 'M';
    } else if (which('S', 'M')) {
        sort[0] = 'L'; sort[1] = 'M';
    } else if (which('L', 'R')) {
        sort[0] = 'S'; sort[1] = 'R';
    } else if (which('S', 'R')) {
        sort[0] = 'L'; sort[1] = 'R';
    } else if (which('L', 'I')) {
        sort[0] = 'S'; sort[1] = 'I';
    } else if (which('S', 'I')) {
        sort[0] = 'L'; sort[1] = 'I';
    }

#undef which

    IGRAPH_CHECK(igraph_vector_init_seq(&order, 0, nconv - 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &order);
#ifdef HAVE_GFORTRAN
    igraphdsortc_(sort, &apply, &nconv, dr, di, VECTOR(order), /*which_len=*/ 2);
#else
    igraphdsortc_(sort, &apply, &nconv, dr, di, VECTOR(order));
#endif

    if (values) {
        IGRAPH_CHECK(igraph_matrix_resize(values, nans, 2));
        memcpy(&MATRIX(*values, 0, 0), dr, sizeof(igraph_real_t) * nans);
        memcpy(&MATRIX(*values, 0, 1), di, sizeof(igraph_real_t) * nans);
    }

    if (vectors) {
        int nc = 0, nr = 0, ncol, vx = 0;
        for (i = 0; i < nans; i++) {
            if (di[i] == 0) {
                nr++;
            } else {
                nc++;
            }
        }
        ncol = (nc / 2) * 2 + (nc % 2) * 2 + nr;
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, ncol));

        for (i = 0; i < nans; i++) {
            unsigned int idx;

            idx = (unsigned int) VECTOR(order)[i];

            if (di[i] == 0) {
                /* real eigenvalue, single eigenvector */
                memcpy(&MATRIX(*vectors, 0, vx), v + n * idx, sizeof(igraph_real_t) * n);
                vx++;
            } else if (di[i] > 0) {
                /* complex eigenvalue, positive imaginary part encountered first.
                 * ARPACK stores its eigenvector directly in two consecutive columns.
                 * The complex conjugate pair of the eigenvalue (if any) will be in
                 * the next column and we will skip it because we advance 'i' below */
                memcpy(&MATRIX(*vectors, 0, vx), v + n * idx, sizeof(igraph_real_t) * 2 * n);
                vx += 2;
                i++;
            } else {
                /* complex eigenvalue, negative imaginary part encountered first.
                     * The positive one will be the next one, but we need to copy the
                     * eigenvector corresponding to the eigenvalue with the positive
                     * imaginary part. */
                idx = (unsigned int) VECTOR(order)[i + 1];
                memcpy(&MATRIX(*vectors, 0, vx), v + n * idx, sizeof(igraph_real_t) * 2 * n);
                vx += 2;
                i++;
            }
        }
    }

    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(1);

    if (values) {
        /* Strive to include complex conjugate eigenvalue pairs in a way that the
         * positive imaginary part comes first */
        for (i = 0; i < nans; i++) {
            if (MATRIX(*values, i, 1) == 0) {
                /* Real eigenvalue, nothing to do */
            } else if (MATRIX(*values, i, 1) < 0) {
                /* Negative imaginary part came first; negate the imaginary part for
                 * this eigenvalue and the next one (which is the complex conjugate
                 * pair), and skip it */
                MATRIX(*values, i, 1) *= -1;
                i++;
                if (i < nans) {
                    MATRIX(*values, i, 1) *= -1;
                }
            } else {
                /* Positive imaginary part; skip the next eigenvalue, which is the
                 * complex conjugate pair */
                i++;
            }
        }
    }

    return 0;
}

/**
 * \function igraph_i_arpack_auto_ncv
 * \brief Tries to set up the value of \c ncv in an \c igraph_arpack_options_t
 *        automagically.
 */
static void igraph_i_arpack_auto_ncv(igraph_arpack_options_t* options) {
    /* This is similar to how Octave determines the value of ncv, with some
     * modifications. */
    int min_ncv = options->nev * 2 + 1;

    /* Use twice the number of desired eigenvectors plus one by default */
    options->ncv = min_ncv;
    /* ...but use at least 20 Lanczos vectors... */
    if (options->ncv < 20) {
        options->ncv = 20;
    }
    /* ...but having ncv close to n leads to some problems with small graphs
     * (example: PageRank of "A <--> C, D <--> E, B"), so we don't let it
     * to be larger than n / 2...
     */
    if (options->ncv > options->n / 2) {
        options->ncv = options->n / 2;
    }
    /* ...but we need at least min_ncv. */
    if (options->ncv < min_ncv) {
        options->ncv = min_ncv;
    }
    /* ...but at most n */
    if (options->ncv > options->n) {
        options->ncv = options->n;
    }
}

/**
 * \function igraph_i_arpack_report_no_convergence
 * \brief Prints a warning that informs the user that the ARPACK solver
 *        did not converge.
 */
static void igraph_i_arpack_report_no_convergence(const igraph_arpack_options_t* options) {
    char buf[1024];
    snprintf(buf, sizeof(buf), "ARPACK solver failed to converge (%d iterations, "
             "%d/%d eigenvectors converged)", options->iparam[2],
             options->iparam[4], options->nev);
    IGRAPH_WARNING(buf);
}

/**
 * \function igraph_arpack_rssolve
 * \brief ARPACK solver for symmetric matrices
 *
 * This is the ARPACK solver for symmetric matrices. Please use
 * \ref igraph_arpack_rnsolve() for non-symmetric matrices.
 * \param fun Pointer to an \ref igraph_arpack_function_t object,
 *     the function that performs the matrix-vector multiplication.
 * \param extra An extra argument to be passed to \c fun.
 * \param options An \ref igraph_arpack_options_t object.
 * \param storage An \ref igraph_arpack_storage_t object, or a null
 *     pointer. In the latter case memory allocation and deallocation
 *     is performed automatically. Either this or the \p vectors argument
 *     must be non-null if the ARPACK iteration is started from a
 *     given starting vector. If both are given \p vectors take
 *     precedence.
 * \param values If not a null pointer, then it should be a pointer to an
 *     initialized vector. The eigenvalues will be stored here. The
 *     vector will be resized as needed.
 * \param vectors If not a null pointer, then it must be a pointer to
 *     an initialized matrix. The eigenvectors will be stored in the
 *     columns of the matrix. The matrix will be resized as needed.
 *     Either this or the \p vectors argument must be non-null if the
 *     ARPACK iteration is started from a given starting vector. If
 *     both are given \p vectors take precedence.
 * \return Error code.
 *
 * Time complexity: depends on the matrix-vector
 * multiplication. Usually a small number of iterations is enough, so
 * if the matrix is sparse and the matrix-vector multiplication can be
 * done in O(n) time (the number of vertices), then the eigenvalues
 * are found in O(n) time as well.
 */

int igraph_arpack_rssolve(igraph_arpack_function_t *fun, void *extra,
                          igraph_arpack_options_t *options,
                          igraph_arpack_storage_t *storage,
                          igraph_vector_t *values, igraph_matrix_t *vectors) {

    igraph_real_t *v, *workl, *workd, *d, *resid, *ax;
    igraph_bool_t free_them = 0;
    int *select, i;

    int ido = 0;
    int rvec = vectors || storage ? 1 : 0; /* calculate eigenvectors? */
    char *all = "All";

    int origldv = options->ldv, origlworkl = options->lworkl,
        orignev = options->nev, origncv = options->ncv;
    igraph_real_t origtol = options->tol;
    char origwhich[2];

    origwhich[0] = options->which[0];
    origwhich[1] = options->which[1];

    /* Special case for 1x1 and 2x2 matrices in mode 1 */
    if (options->mode == 1 && options->n == 1) {
        return igraph_i_arpack_rssolve_1x1(fun, extra, options, values, vectors);
    } else if (options->mode == 1 && options->n == 2) {
        return igraph_i_arpack_rssolve_2x2(fun, extra, options, values, vectors);
    }

    /* Brush up options if needed */
    if (options->ldv == 0) {
        options->ldv = options->n;
    }
    if (options->ncv == 0) {
        igraph_i_arpack_auto_ncv(options);
    }
    if (options->lworkl == 0) {
        options->lworkl = options->ncv * (options->ncv + 8);
    }
    if (options->which[0] == 'X') {
        options->which[0] = 'L';
        options->which[1] = 'M';
    }

    if (storage) {
        /* Storage provided */
        if (storage->maxn < options->n) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`n')", IGRAPH_EINVAL);
        }
        if (storage->maxncv < options->ncv) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`ncv')", IGRAPH_EINVAL);
        }
        if (storage->maxldv < options->ldv) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`ldv')", IGRAPH_EINVAL);
        }

        v      = storage->v;
        workl  = storage->workl;
        workd  = storage->workd;
        d      = storage->d;
        resid  = storage->resid;
        ax     = storage->ax;
        select = storage->select;

    } else {
        /* Storage not provided */
        free_them = 1;

#define CHECKMEM(x) \
    if (!x) { \
        IGRAPH_ERROR("Cannot allocate memory for ARPACK", IGRAPH_ENOMEM); \
    } \
    IGRAPH_FINALLY(igraph_free, x);

        v = IGRAPH_CALLOC(options->ldv * options->ncv, igraph_real_t); CHECKMEM(v);
        workl = IGRAPH_CALLOC(options->lworkl, igraph_real_t); CHECKMEM(workl);
        workd = IGRAPH_CALLOC(3 * options->n, igraph_real_t); CHECKMEM(workd);
        d = IGRAPH_CALLOC(2 * options->ncv, igraph_real_t); CHECKMEM(d);
        resid = IGRAPH_CALLOC(options->n, igraph_real_t); CHECKMEM(resid);
        ax = IGRAPH_CALLOC(options->n, igraph_real_t); CHECKMEM(ax);
        select = IGRAPH_CALLOC(options->ncv, int); CHECKMEM(select);

#undef CHECKMEM

    }

    /* Set final bits */
    options->bmat[0] = 'I';
    options->iparam[0] = options->ishift;
    options->iparam[1] = 0;   // not referenced
    options->iparam[2] = options->mxiter;
    options->iparam[3] = 1;   // currently dsaupd() works only for nb=1
    options->iparam[4] = 0;
    options->iparam[5] = 0;   // not referenced
    options->iparam[6] = options->mode;
    options->iparam[7] = 0;   // return value
    options->iparam[8] = 0;   // return value
    options->iparam[9] = 0;   // return value
    options->iparam[10] = 0;  // return value
    options->info = options->start;
    if (options->start) {
        if (!storage && !vectors) {
            IGRAPH_ERROR("Starting vector not given", IGRAPH_EINVAL);
        }
        if (vectors && (igraph_matrix_nrow(vectors) != options->n ||
                        igraph_matrix_ncol(vectors) != 1)) {
            IGRAPH_ERROR("Invalid starting vector size", IGRAPH_EINVAL);
        }
        if (vectors) {
            for (i = 0; i < options->n; i++) {
                resid[i] = MATRIX(*vectors, i, 0);
            }
        }
    }

    /* Ok, we have everything */
    while (1) {
#ifdef HAVE_GFORTRAN
        igraphdsaupd_(&ido, options->bmat, &options->n, options->which,
                      &options->nev, &options->tol,
                      resid, &options->ncv, v, &options->ldv,
                      options->iparam, options->ipntr,
                      workd, workl, &options->lworkl, &options->info,
                      /*bmat_len=*/ 1, /*which_len=*/ 2);
#else
        igraphdsaupd_(&ido, options->bmat, &options->n, options->which,
                      &options->nev, &options->tol,
                      resid, &options->ncv, v, &options->ldv,
                      options->iparam, options->ipntr,
                      workd, workl, &options->lworkl, &options->info);
#endif

        if (ido == -1 || ido == 1) {
            igraph_real_t *from = workd + options->ipntr[0] - 1;
            igraph_real_t *to = workd + options->ipntr[1] - 1;
            if (fun(to, from, options->n, extra) != 0) {
                IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                             IGRAPH_ARPACK_PROD);
            }

        } else {
            break;
        }
    }

    if (options->info == 1) {
        igraph_i_arpack_report_no_convergence(options);
    }
    if (options->info != 0) {
        IGRAPH_ERROR("ARPACK error", igraph_i_arpack_err_dsaupd(options->info));
    }

    options->ierr = 0;
#ifdef HAVE_GFORTRAN
    igraphdseupd_(&rvec, all, select, d, v, &options->ldv,
                  &options->sigma, options->bmat, &options->n,
                  options->which, &options->nev, &options->tol,
                  resid, &options->ncv, v, &options->ldv, options->iparam,
                  options->ipntr, workd, workl, &options->lworkl,
                  &options->ierr, /*howmny_len=*/ 1, /*bmat_len=*/ 1,
                  /*which_len=*/ 2);
#else
    igraphdseupd_(&rvec, all, select, d, v, &options->ldv,
                  &options->sigma, options->bmat, &options->n,
                  options->which, &options->nev, &options->tol,
                  resid, &options->ncv, v, &options->ldv, options->iparam,
                  options->ipntr, workd, workl, &options->lworkl,
                  &options->ierr);
#endif

    if (options->ierr != 0) {
        IGRAPH_ERROR("ARPACK error", igraph_i_arpack_err_dseupd(options->ierr));
    }

    /* Save the result */

    options->noiter = options->iparam[2];
    options->nconv = options->iparam[4];
    options->numop = options->iparam[8];
    options->numopb = options->iparam[9];
    options->numreo = options->iparam[10];

    if (options->nconv < options->nev) {
        IGRAPH_WARNING("Not enough eigenvalues/vectors in symmetric ARPACK "
                       "solver");
    }

    if (values || vectors) {
        IGRAPH_CHECK(igraph_arpack_rssort(values, vectors, options, d, v));
    }

    options->ldv = origldv;
    options->ncv = origncv;
    options->lworkl = origlworkl;
    options->which[0] = origwhich[0]; options->which[1] = origwhich[1];
    options->tol = origtol;
    options->nev = orignev;

    /* Clean up if needed */
    if (free_them) {
        IGRAPH_FREE(select);
        IGRAPH_FREE(ax);
        IGRAPH_FREE(resid);
        IGRAPH_FREE(d);
        IGRAPH_FREE(workd);
        IGRAPH_FREE(workl);
        IGRAPH_FREE(v);
        IGRAPH_FINALLY_CLEAN(7);
    }
    return 0;
}

/**
 * \function igraph_arpack_rnsolve
 * \brief ARPACK solver for non-symmetric matrices
 *
 * Please always consider calling \ref igraph_arpack_rssolve() if your
 * matrix is symmetric, it is much faster.
 * \ref igraph_arpack_rnsolve() for non-symmetric matrices.
 * 
 * Note that ARPACK is not called for 2x2 matrices as an exact algebraic
 * solution exists in these cases.
 *
 * \param fun Pointer to an \ref igraph_arpack_function_t object,
 *     the function that performs the matrix-vector multiplication.
 * \param extra An extra argument to be passed to \c fun.
 * \param options An \ref igraph_arpack_options_t object.
 * \param storage An \ref igraph_arpack_storage_t object, or a null
 *     pointer. In the latter case memory allocation and deallocation
 *     is performed automatically.
 * \param values If not a null pointer, then it should be a pointer to an
 *     initialized matrix. The (possibly complex) eigenvalues will be
 *     stored here. The matrix will have two columns, the first column
 *     contains the real, the second the imaginary parts of the
 *     eigenvalues.
 *     The matrix will be resized as needed.
 * \param vectors If not a null pointer, then it must be a pointer to
 *     an initialized matrix. The eigenvectors will be stored in the
 *     columns of the matrix. The matrix will be resized as needed.
 *     Note that real eigenvalues will have real eigenvectors in a single
 *     column in this matrix; however, complex eigenvalues come in conjugate
 *     pairs and the result matrix will store the eigenvector corresponding to
 *     the eigenvalue with \em positive imaginary part only. Since in this case
 *     the eigenvector is also complex, it will occupy \em two columns in the
 *     eigenvector matrix (the real and the imaginary parts, in this order).
 *     Caveat: if the eigenvalue vector returns only the eigenvalue with the
 *     \em negative imaginary part for a complex conjugate eigenvalue pair, the
 *     result vector will \em still store the eigenvector corresponding to the
 *     eigenvalue with the positive imaginary part (since this is how ARPACK
 *     works).
 * \return Error code.
 *
 * Time complexity: depends on the matrix-vector
 * multiplication. Usually a small number of iterations is enough, so
 * if the matrix is sparse and the matrix-vector multiplication can be
 * done in O(n) time (the number of vertices), then the eigenvalues
 * are found in O(n) time as well.
 */

int igraph_arpack_rnsolve(igraph_arpack_function_t *fun, void *extra,
                          igraph_arpack_options_t *options,
                          igraph_arpack_storage_t *storage,
                          igraph_matrix_t *values, igraph_matrix_t *vectors) {

    igraph_real_t *v, *workl, *workd, *dr, *di, *resid, *workev;
    igraph_bool_t free_them = 0;
    int *select, i;

    int ido = 0;
    int rvec = vectors || storage ? 1 : 0;
    char *all = "All";

    int origldv = options->ldv, origlworkl = options->lworkl,
        orignev = options->nev, origncv = options->ncv;
    igraph_real_t origtol = options->tol;
    int d_size;
    char origwhich[2];

    origwhich[0] = options->which[0];
    origwhich[1] = options->which[1];

    /* Special case for 1x1 and 2x2 matrices in mode 1 */
    if (options->mode == 1 && options->n == 1) {
        return igraph_i_arpack_rnsolve_1x1(fun, extra, options, values, vectors);
    } else if (options->mode == 1 && options->n == 2) {
        return igraph_i_arpack_rnsolve_2x2(fun, extra, options, values, vectors);
    }

    /* Brush up options if needed */
    if (options->ldv == 0) {
        options->ldv = options->n;
    }
    if (options->ncv == 0) {
        igraph_i_arpack_auto_ncv(options);
    }
    if (options->lworkl == 0) {
        options->lworkl = 3 * options->ncv * (options->ncv + 2);
    }
    if (options->which[0] == 'X') {
        options->which[0] = 'L';
        options->which[1] = 'M';
    }

    if (storage) {
        /* Storage provided */
        if (storage->maxn < options->n) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`n')", IGRAPH_EINVAL);
        }
        if (storage->maxncv < options->ncv) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`ncv')", IGRAPH_EINVAL);
        }
        if (storage->maxldv < options->ldv) {
            IGRAPH_ERROR("Not enough storage for ARPACK (`ldv')", IGRAPH_EINVAL);
        }

        v      = storage->v;
        workl  = storage->workl;
        workd  = storage->workd;
        workev = storage->workev;
        dr     = storage->d;
        di     = storage->di;
        d_size = options->n;
        resid  = storage->resid;
        select = storage->select;

    } else {
        /* Storage not provided */
        free_them = 1;

#define CHECKMEM(x) \
    if (!x) { \
        IGRAPH_ERROR("Cannot allocate memory for ARPACK", IGRAPH_ENOMEM); \
    } \
    IGRAPH_FINALLY(igraph_free, x);

        v = IGRAPH_CALLOC(options->n * options->ncv, igraph_real_t); CHECKMEM(v);
        workl = IGRAPH_CALLOC(options->lworkl, igraph_real_t); CHECKMEM(workl);
        workd = IGRAPH_CALLOC(3 * options->n, igraph_real_t); CHECKMEM(workd);
        d_size = 2 * options->nev + 1 > options->ncv ? 2 * options->nev + 1 : options->ncv;
        dr = IGRAPH_CALLOC(d_size, igraph_real_t); CHECKMEM(dr);
        di = IGRAPH_CALLOC(d_size, igraph_real_t); CHECKMEM(di);
        resid = IGRAPH_CALLOC(options->n, igraph_real_t); CHECKMEM(resid);
        select = IGRAPH_CALLOC(options->ncv, int); CHECKMEM(select);
        workev = IGRAPH_CALLOC(3 * options->ncv, igraph_real_t); CHECKMEM(workev);

#undef CHECKMEM

    }

    /* Set final bits */
    options->bmat[0] = 'I';
    options->iparam[0] = options->ishift;
    options->iparam[1] = 0;   // not referenced
    options->iparam[2] = options->mxiter;
    options->iparam[3] = 1;   // currently dnaupd() works only for nb=1
    options->iparam[4] = 0;
    options->iparam[5] = 0;   // not referenced
    options->iparam[6] = options->mode;
    options->iparam[7] = 0;   // return value
    options->iparam[8] = 0;   // return value
    options->iparam[9] = 0;   // return value
    options->iparam[10] = 0;  // return value
    options->info = options->start;
    if (options->start) {
        if (!storage && !vectors) {
            IGRAPH_ERROR("Starting vector not given", IGRAPH_EINVAL);
        }
        if (vectors && (igraph_matrix_nrow(vectors) != options->n ||
                        igraph_matrix_ncol(vectors) != 1)) {
            IGRAPH_ERROR("Invalid starting vector size", IGRAPH_EINVAL);
        }
        if (vectors) {
            for (i = 0; i < options->n; i++) {
                resid[i] = MATRIX(*vectors, i, 0);
            }
        }
    }

    /* Ok, we have everything */
    while (1) {
#ifdef HAVE_GFORTRAN
        igraphdnaupd_(&ido, options->bmat, &options->n, options->which,
                      &options->nev, &options->tol,
                      resid, &options->ncv, v, &options->ldv,
                      options->iparam, options->ipntr,
                      workd, workl, &options->lworkl, &options->info,
                      /*bmat_len=*/ 1, /*which_len=*/ 2);
#else
        igraphdnaupd_(&ido, options->bmat, &options->n, options->which,
                      &options->nev, &options->tol,
                      resid, &options->ncv, v, &options->ldv,
                      options->iparam, options->ipntr,
                      workd, workl, &options->lworkl, &options->info);
#endif

        if (ido == -1 || ido == 1) {
            igraph_real_t *from = workd + options->ipntr[0] - 1;
            igraph_real_t *to = workd + options->ipntr[1] - 1;
            if (fun(to, from, options->n, extra) != 0) {
                IGRAPH_ERROR("ARPACK error while evaluating matrix-vector product",
                             IGRAPH_ARPACK_PROD);
            }
        } else {
            break;
        }
    }

    if (options->info == 1) {
        igraph_i_arpack_report_no_convergence(options);
    }
    if (options->info != 0 && options->info != -9999) {
        IGRAPH_ERROR("ARPACK error", igraph_i_arpack_err_dnaupd(options->info));
    }

    options->ierr = 0;
#ifdef HAVE_GFORTRAN
    igraphdneupd_(&rvec, all, select, dr, di, v, &options->ldv,
                  &options->sigma, &options->sigmai, workev, options->bmat,
                  &options->n, options->which, &options->nev, &options->tol,
                  resid, &options->ncv, v, &options->ldv, options->iparam,
                  options->ipntr, workd, workl, &options->lworkl,
                  &options->ierr, /*howmny_len=*/ 1, /*bmat_len=*/ 1,
                  /*which_len=*/ 2);
#else
    igraphdneupd_(&rvec, all, select, dr, di, v, &options->ldv,
                  &options->sigma, &options->sigmai, workev, options->bmat,
                  &options->n, options->which, &options->nev, &options->tol,
                  resid, &options->ncv, v, &options->ldv, options->iparam,
                  options->ipntr, workd, workl, &options->lworkl,
                  &options->ierr);
#endif

    if (options->ierr != 0) {
        IGRAPH_ERROR("ARPACK error", igraph_i_arpack_err_dneupd(options->info));
    }

    /* Save the result */

    options->noiter = options->iparam[2];
    options->nconv = options->iparam[4];
    options->numop = options->iparam[8];
    options->numopb = options->iparam[9];
    options->numreo = options->iparam[10];

    if (options->nconv < options->nev) {
        IGRAPH_WARNING("Not enough eigenvalues/vectors in ARPACK "
                       "solver");
    }

    /* ARPACK might modify stuff in 'options' so reset everything that could
     * potentially get modified */
    options->ldv = origldv;
    options->ncv = origncv;
    options->lworkl = origlworkl;
    options->which[0] = origwhich[0]; options->which[1] = origwhich[1];
    options->tol = origtol;
    options->nev = orignev;

    if (values || vectors) {
        IGRAPH_CHECK(igraph_arpack_rnsort(values, vectors, options,
                                          dr, di, v));
    }

    /* Clean up if needed */
    if (free_them) {
        IGRAPH_FREE(workev);
        IGRAPH_FREE(select);
        IGRAPH_FREE(resid);
        IGRAPH_FREE(di);
        IGRAPH_FREE(dr);
        IGRAPH_FREE(workd);
        IGRAPH_FREE(workl);
        IGRAPH_FREE(v);
        IGRAPH_FINALLY_CLEAN(8);
    }
    return 0;
}

/**
 * \function igraph_arpack_unpack_complex
 * \brief Make the result of the non-symmetric ARPACK solver more readable
 *
 * This function works on the output of \ref igraph_arpack_rnsolve and
 * brushes it up a bit: it only keeps \p nev eigenvalues/vectors and
 * every eigenvector is stored in two columns of the \p vectors
 * matrix.
 *
 * 
 * The output of the non-symmetric ARPACK solver is somewhat hard to
 * parse, as real eigenvectors occupy only one column in the matrix,
 * and the complex conjugate eigenvectors are not stored at all
 * (usually). The other problem is that the solver might return more
 * eigenvalues than requested. The common use of this function is to
 * call it directly after \ref igraph_arpack_rnsolve with its \p
 * vectors and \p values argument and \c options->nev as \p nev.
 * This will add the vectors for eigenvalues with a negative imaginary
 * part and return all vectors as 2 columns, a real and imaginary part.
 * \param vectors The eigenvector matrix, as returned by \ref
 *   igraph_arpack_rnsolve. It will be resized, typically it will be
 *   larger.
 * \param values The eigenvalue matrix, as returned by \ref
 *   igraph_arpack_rnsolve. It will be resized, typically extra,
 *   unneeded rows (=eigenvalues) will be removed.
 * \param nev The number of eigenvalues/vectors to keep. Can be less
 *   or equal than the number originally requested from ARPACK.
 * \return Error code.
 *
 * Time complexity: linear in the number of elements in the \p vectors
 * matrix.
 */

int igraph_arpack_unpack_complex(igraph_matrix_t *vectors, igraph_matrix_t *values,
                                 long int nev) {

    long int nodes = igraph_matrix_nrow(vectors);
    long int no_evs = igraph_matrix_nrow(values);
    long int i, j;
    long int new_vector_pos;
    long int vector_pos;
    igraph_matrix_t new_vectors;

    /* Error checks */
    if (nev < 0) {
        IGRAPH_ERROR("`nev' cannot be negative", IGRAPH_EINVAL);
    }
    if (nev > no_evs) {
        IGRAPH_ERROR("`nev' too large, we don't have that many in `values'",
                     IGRAPH_EINVAL);
    }

    for (i = no_evs -1; i >= nev; i--) {
        IGRAPH_CHECK(igraph_matrix_remove_row(values, i));
    }

    IGRAPH_CHECK(igraph_matrix_init(&new_vectors, nodes, nev * 2));
    IGRAPH_FINALLY(igraph_matrix_destroy, &new_vectors);

    new_vector_pos = 0;
    vector_pos = 0;
    for (i = 0; i < nev && vector_pos < igraph_matrix_ncol(vectors); i++) {
        if (MATRIX(*values, i, 1) == 0) {
            /* Real eigenvalue */
            for (j = 0; j < nodes; j++) {
                MATRIX(new_vectors, j, new_vector_pos) = MATRIX(*vectors, j, vector_pos);
            }
            new_vector_pos += 2;
            vector_pos += 1;
        } else {
            /* complex eigenvalue */
            for (j = 0; j < nodes; j++) {
                MATRIX(new_vectors, j, new_vector_pos) = MATRIX(*vectors, j, vector_pos);
                MATRIX(new_vectors, j, new_vector_pos + 1) = MATRIX(*vectors, j, vector_pos + 1);
            }

            /* handle the conjugate */

            /* first check if the conjugate eigenvalue is there */
            i++;
            if (i >= nev) {
                break;
            }

            if (MATRIX(*values, i, 1) != -MATRIX(*values, i-1, 1)) {
                IGRAPH_ERROR("Complex eigenvalue not followed by its conjugate.", IGRAPH_EINVAL);
            }

            /* then copy and negate */
            for (j = 0; j < nodes; j++) {
                MATRIX(new_vectors, j, new_vector_pos + 2) = MATRIX(*vectors, j, vector_pos);
                MATRIX(new_vectors, j, new_vector_pos + 3) = -MATRIX(*vectors, j, vector_pos + 1);
            }
            new_vector_pos += 4;
            vector_pos += 2;
        }
    }
    igraph_matrix_destroy(vectors);
    IGRAPH_CHECK(igraph_matrix_copy(vectors, &new_vectors));
    igraph_matrix_destroy(&new_vectors);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/arpack_internal.h0000644000175100001710000002134300000000000025220 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef ARPACK_INTERNAL_H
#define ARPACK_INTERNAL_H

/* Note: only files calling the arpack routines directly need to
   include this header.
*/

#include "igraph_types.h"
#include "config.h"

#ifndef INTERNAL_ARPACK
    #define igraphdsaupd_   dsaupd_
    #define igraphdseupd_   dseupd_
    #define igraphdsaup2_   dsaup2_
    #define igraphdstats_   dstats_
    #define igraphdsesrt_   dsesrt_
    #define igraphdsortr_   dsortr_
    #define igraphdsortc_   dsortc_
    #define igraphdgetv0_   dgetv0_
    #define igraphdsaitr_   dsaitr_
    #define igraphdsapps_   dsapps_
    #define igraphdsconv_   dsconv_
    #define igraphdseigt_   dseigt_
    #define igraphdsgets_   dsgets_
    #define igraphdstqrb_   dstqrb_
    #define igraphdmout_    dmout_
    #define igraphivout_    ivout_
    #define igraphsecond_   second_
    #define igraphdvout_    dvout_
    #define igraphdnaitr_   dnaitr_
    #define igraphdnapps_   dnapps_
    #define igraphdnaup2_   dnaup2_
    #define igraphdnaupd_   dnaupd_
    #define igraphdnconv_   dnconv_
    #define igraphdlabad_   dlabad_
    #define igraphdlanhs_   dlanhs_
    #define igraphdsortc_   dsortc_
    #define igraphdneigh_   dneigh_
    #define igraphdngets_   dngets_
    #define igraphdstatn_   dstatn_
    #define igraphdlaqrb_   dlaqrb_

    #define igraphdsaupd_   dsaupd_
    #define igraphdseupd_   dseupd_
    #define igraphdnaupd_   dnaupd_
    #define igraphdneupd_   dneupd_
#endif

#ifndef INTERNAL_LAPACK
    #define igraphdlarnv_   dlarnv_
    #define igraphdlascl_   dlascl_
    #define igraphdlartg_   dlartg_
    #define igraphdlaset_   dlaset_
    #define igraphdlae2_    dlae2_
    #define igraphdlaev2_   dlaev2_
    #define igraphdlasr_    dlasr_
    #define igraphdlasrt_   dlasrt_
    #define igraphdgeqr2_   dgeqr2_
    #define igraphdlacpy_   dlacpy_
    #define igraphdorm2r_   dorm2r_
    #define igraphdsteqr_   dsteqr_
    #define igraphdlanst_   dlanst_
    #define igraphdlapy2_   dlapy2_
    #define igraphdlamch_   dlamch_
    #define igraphdlaruv_   dlaruv_
    #define igraphdlarfg_   dlarfg_
    #define igraphdlarf_    dlarf_
    #define igraphdlassq_   dlassq_
    #define igraphdlamc2_   dlamc2_
    #define igraphdlamc1_   dlamc1_
    #define igraphdlamc2_   dlamc2_
    #define igraphdlamc3_   dlamc3_
    #define igraphdlamc4_   dlamc4_
    #define igraphdlamc5_   dlamc5_
    #define igraphdlabad_   dlabad_
    #define igraphdlanhs_   dlanhs_
    #define igraphdtrevc_   dtrevc_
    #define igraphdlanv2_   dlanv2_
    #define igraphdlaln2_   dlaln2_
    #define igraphdladiv_   dladiv_
    #define igraphdtrsen_   dtrsen_
    #define igraphdlahqr_   dlahqr_
    #define igraphdtrsen_   dtrsen_
    #define igraphdlacon_   dlacon_
    #define igraphdtrsyl_   dtrsyl_
    #define igraphdtrexc_   dtrexc_
    #define igraphdlange_   dlange_
    #define igraphdlaexc_   dlaexc_
    #define igraphdlasy2_   dlasy2_
    #define igraphdlarfx_   dlarfx_
#endif

#if 0               /* internal f2c functions always used */
    #define igraphd_sign    d_sign
    #define igraphetime_    etime_
    #define igraphpow_dd    pow_dd
    #define igraphpow_di    pow_di
    #define igraphs_cmp s_cmp
    #define igraphs_copy    s_copy
    #define igraphd_lg10_   d_lg10_
    #define igraphi_dnnt_   i_dnnt_
#endif

#ifdef HAVE_GFORTRAN

/* GFortran-specific calling conventions, used when compiling the R interface.
 * Derived with "gfortran -fc-prototypes-external", applied on the original
 * Fortran sources of these functions.
 *
 * Caveats:
 *
 * 1) gfortran prints size_t for the "_len" arguments, but in fact they must be
 *    long int
 * 2) gofrtran maps Fortran LOGICAL types to int_least32_t, but in fact they
 *    must be void* (anything else doesn't work, not even _Bool*)
 * */

void igraphdsaupd_(int *ido, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info,
                  long int bmat_len, long int which_len);

void igraphdseupd_(void *rvec, char *howmny, void *select,
                  igraph_real_t *d, igraph_real_t *z, int *ldz,
                  igraph_real_t *sigma, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info,
                  long int howmny_len, long int bmat_len, long int which_len);

void igraphdnaupd_(int *ido, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info,
                  long int bmat_len, long int which_len);

void igraphdneupd_(void *rvec, char *howmny, void *select,
                  igraph_real_t *dr, igraph_real_t *di,
                  igraph_real_t *z, int *ldz,
                  igraph_real_t *sigmar, igraph_real_t *sigmai,
                  igraph_real_t *workev, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info,
                  long int howmny_len, long int bmat_len, long int which_len);

void igraphdsortr_(char *which, void *apply, int* n, igraph_real_t *x1,
                  igraph_real_t *x2, long int which_len);

void igraphdsortc_(char *which, void *apply, int* n, igraph_real_t *xreal,
                  igraph_real_t *ximag, igraph_real_t *y, long int which_len);

#else

int igraphdsaupd_(int *ido, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info);

int igraphdseupd_(int *rvec, char *howmny, int *select,
                  igraph_real_t *d, igraph_real_t *z, int *ldz,
                  igraph_real_t *sigma, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info);

int igraphdnaupd_(int *ido, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info);

int igraphdneupd_(int *rvec, char *howmny, int *select,
                  igraph_real_t *dr, igraph_real_t *di,
                  igraph_real_t *z, int *ldz,
                  igraph_real_t *sigmar, igraph_real_t *sigmai,
                  igraph_real_t *workev, char *bmat, int *n,
                  char *which, int *nev, igraph_real_t *tol,
                  igraph_real_t *resid, int *ncv, igraph_real_t *v,
                  int *ldv, int *iparam, int *ipntr,
                  igraph_real_t *workd, igraph_real_t *workl,
                  int *lworkl, int *info);

int igraphdsortr_(char *which, int *apply, int* n, igraph_real_t *x1,
                  igraph_real_t *x2);

int igraphdsortc_(char *which, int *apply, int* n, igraph_real_t *xreal,
                  igraph_real_t *ximag, igraph_real_t *y);

#endif

#endif  /* ARPACK_INTERNAL_H */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/blas.c0000644000175100001710000001164700000000000023005 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_error.h"
#include "igraph_blas.h"

#include "linalg/blas_internal.h"

/**
 * \function igraph_blas_dgemv
 * \brief Matrix-vector multiplication using BLAS, vector version.
 *
 * This function is a somewhat more user-friendly interface to
 * the \c dgemv function in BLAS. \c dgemv performs the operation
 * y = alpha*A*x + beta*y, where x and y are vectors and A is an
 * appropriately sized matrix (symmetric or non-symmetric).
 *
 * \param transpose whether to transpose the matrix \p A
 * \param alpha     the constant \p alpha
 * \param a         the matrix \p A
 * \param x         the vector \p x
 * \param beta      the constant \p beta
 * \param y         the vector \p y (which will be modified in-place)
 *
 * Time complexity: O(nk) if the matrix is of size n x k
 *
 * \sa \ref igraph_blas_dgemv_array if you have arrays instead of
 *     vectors.
 *
 * \example examples/simple/blas.c
 */
void igraph_blas_dgemv(igraph_bool_t transpose, igraph_real_t alpha,
                       const igraph_matrix_t* a, const igraph_vector_t* x,
                       igraph_real_t beta, igraph_vector_t* y) {
    char trans = transpose ? 'T' : 'N';
    int m, n;
    int inc = 1;

    m = (int) igraph_matrix_nrow(a);
    n = (int) igraph_matrix_ncol(a);

    IGRAPH_ASSERT(igraph_vector_size(x) == transpose ? m : n);
    IGRAPH_ASSERT(igraph_vector_size(y) == transpose ? n : m);

#ifdef HAVE_GFORTRAN
    igraphdgemv_(&trans, &m, &n, &alpha, VECTOR(a->data), &m,
                 VECTOR(*x), &inc, &beta, VECTOR(*y), &inc, /* trans_len = */ 1);
#else
    igraphdgemv_(&trans, &m, &n, &alpha, VECTOR(a->data), &m,
                 VECTOR(*x), &inc, &beta, VECTOR(*y), &inc);
#endif
}

/**
 * \function igraph_blas_dgemv_array
 * \brief Matrix-vector multiplication using BLAS, array version.
 *
 * This function is a somewhat more user-friendly interface to
 * the \c dgemv function in BLAS. \c dgemv performs the operation
 * y = alpha*A*x + beta*y, where x and y are vectors and A is an
 * appropriately sized matrix (symmetric or non-symmetric).
 *
 * \param transpose whether to transpose the matrix \p A
 * \param alpha     the constant \p alpha
 * \param a         the matrix \p A
 * \param x         the vector \p x as a regular C array
 * \param beta      the constant \p beta
 * \param y         the vector \p y as a regular C array
 *                  (which will be modified in-place)
 *
 * Time complexity: O(nk) if the matrix is of size n x k
 *
 * \sa \ref igraph_blas_dgemv if you have vectors instead of
 *     arrays.
 */
void igraph_blas_dgemv_array(igraph_bool_t transpose, igraph_real_t alpha,
                             const igraph_matrix_t* a, const igraph_real_t* x,
                             igraph_real_t beta, igraph_real_t* y) {
    char trans = transpose ? 'T' : 'N';
    int m, n;
    int inc = 1;

    m = (int) igraph_matrix_nrow(a);
    n = (int) igraph_matrix_ncol(a);

#ifdef HAVE_GFORTRAN
    igraphdgemv_(&trans, &m, &n, &alpha, VECTOR(a->data), &m,
                 (igraph_real_t*)x, &inc, &beta, y, &inc, /* trans_len = */ 1);
#else
    igraphdgemv_(&trans, &m, &n, &alpha, VECTOR(a->data), &m,
                 (igraph_real_t*)x, &inc, &beta, y, &inc);
#endif
}

igraph_real_t igraph_blas_dnrm2(const igraph_vector_t *v) {
    int n = igraph_vector_size(v);
    int one = 1;
    return igraphdnrm2_(&n, VECTOR(*v), &one);
}

/**
 * \function igraph_blas_ddot
 * \brief Dot product of two vectors.
 *
 * \param v1 The first vector.
 * \param v2 The second vector.
 * \param res Pointer to a real, the result will be stored here.
 *
 * Time complexity: O(n) where n is the length of the vectors.
 *
 * \example examples/simple/blas.c
 */
int igraph_blas_ddot(const igraph_vector_t *v1, const igraph_vector_t *v2,
                       igraph_real_t *res) {

    int n = igraph_vector_size(v1);
    int one = 1;

    if (igraph_vector_size(v2) != n) {
        IGRAPH_ERROR("Dot product of vectors with different dimensions.",
                     IGRAPH_EINVAL);
    }

    *res = igraphddot_(&n, VECTOR(*v1), &one, VECTOR(*v2), &one);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/blas_internal.h0000644000175100001710000000612000000000000024674 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef BLAS_INTERNAL_H
#define BLAS_INTERNAL_H

/* Note: only files calling the BLAS routines directly need to
   include this header.
*/

#include "igraph_types.h"
#include "config.h"

#ifndef INTERNAL_BLAS
    #define igraphdaxpy_    daxpy_
    #define igraphdger_     dger_
    #define igraphdcopy_    dcopy_
    #define igraphdscal_    dscal_
    #define igraphdswap_    dswap_
    #define igraphdgemm_    dgemm_
    #define igraphdgemv_    dgemv_
    #define igraphddot_     ddot_
    #define igraphdnrm2_    dnrm2_
    #define igraphlsame_    lsame_
    #define igraphdrot_     drot_
    #define igraphidamax_   idamax_
    #define igraphdtrmm_    dtrmm_
    #define igraphdasum_    dasum_
    #define igraphdtrsm_    dtrsm_
    #define igraphdtrsv_    dtrsv_
    #define igraphdnrm2_    dnrm2_
    #define igraphdsymv_    dsymv_
    #define igraphdsyr2_    dsyr2_
    #define igraphdsyr2k_   dsyr2k_
    #define igraphdtrmv_    dtrmv_
    #define igraphdsyrk_    dsyrk_
#endif

#ifdef HAVE_GFORTRAN

/* GFortran-specific calling conventions, used when compiling the R interface.
 * Derived with "gfortran -fc-prototypes-external", applied on the original
 * Fortran sources of these functions. */

void igraphdgemv_(char *trans, int *m, int *n, igraph_real_t *alpha,
                 igraph_real_t *a, int *lda, igraph_real_t *x, int *incx,
                 igraph_real_t *beta, igraph_real_t *y, int *incy, long int trans_len);

void igraphdgemm_(char *transa, char *transb, int *m, int *n, int *k,
                 double *alpha, double *a, int *lda, double *b, int *ldb,
                 double *beta, double *c__, int *ldc, long int transa_len, long int transb_len);

#else

int igraphdgemv_(char *trans, int *m, int *n, igraph_real_t *alpha,
                 igraph_real_t *a, int *lda, igraph_real_t *x, int *incx,
                 igraph_real_t *beta, igraph_real_t *y, int *incy);

int igraphdgemm_(char *transa, char *transb, int *m, int *n, int *k,
                 double *alpha, double *a, int *lda, double *b, int *ldb,
                 double *beta, double *c__, int *ldc);

#endif

double igraphdnrm2_(int *n, double *x, int *incx);

double igraphddot_(int *n, double *dx, int *incx, double *dy, int *incy);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/eigen.c0000644000175100001710000014415600000000000023155 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_eigen.h"

#include "igraph_qsort.h"
#include "igraph_blas.h"
#include "igraph_interface.h"
#include "igraph_adjlist.h"

#include 
#include 
#include 

static int igraph_i_eigen_arpackfun_to_mat(igraph_arpack_function_t *fun,
                                    int n, void *extra,
                                    igraph_matrix_t *res) {

    int i;
    igraph_vector_t v;

    IGRAPH_CHECK(igraph_matrix_init(res, n, n));
    IGRAPH_FINALLY(igraph_matrix_destroy, res);
    IGRAPH_VECTOR_INIT_FINALLY(&v, n);
    VECTOR(v)[0] = 1;
    IGRAPH_CHECK(fun(/*to=*/ &MATRIX(*res, 0, 0), /*from=*/ VECTOR(v), n,
                             extra));
    for (i = 1; i < n; i++) {
        VECTOR(v)[i - 1] = 0;
        VECTOR(v)[i  ] = 1;
        IGRAPH_CHECK(fun(/*to=*/ &MATRIX(*res, 0, i), /*from=*/ VECTOR(v), n,
                                 extra));
    }
    igraph_vector_destroy(&v);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_lm(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    igraph_matrix_t vec1, vec2;
    igraph_vector_t val1, val2;
    int n = (int) igraph_matrix_nrow(A);
    int p1 = 0, p2 = which->howmany - 1, pr = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&val1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&val2, 0);

    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_init(&vec1, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &vec1);
        IGRAPH_CHECK(igraph_matrix_init(&vec2, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &vec1);
    }

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ 1, /*iu=*/ which->howmany,
                                      /*abstol=*/ 1e-14, &val1,
                                      vectors ? &vec1 : 0,
                                      /*support=*/ 0));

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ n - which->howmany + 1, /*iu=*/ n,
                                      /*abstol=*/ 1e-14, &val2,
                                      vectors ? &vec2 : 0,
                                      /*support=*/ 0));

    if (values) {
        IGRAPH_CHECK(igraph_vector_resize(values, which->howmany));
    }
    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, which->howmany));
    }

    while (pr < which->howmany) {
        if (p2 < 0 || fabs(VECTOR(val1)[p1]) > fabs(VECTOR(val2)[p2])) {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val1)[p1];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec1, 0, p1),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p1++;
            pr++;
        } else {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val2)[p2];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec2, 0, p2),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p2--;
            pr++;
        }
    }


    if (vectors) {
        igraph_matrix_destroy(&vec2);
        igraph_matrix_destroy(&vec1);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_vector_destroy(&val2);
    igraph_vector_destroy(&val1);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_sm(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    igraph_vector_t val;
    igraph_matrix_t vec;
    int i, w = 0, n = (int) igraph_matrix_nrow(A);
    igraph_real_t small;
    int p1, p2, pr = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&val, 0);

    if (vectors) {
        IGRAPH_MATRIX_INIT_FINALLY(&vec, 0, 0);
    }

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_ALL, /*vl=*/ 0,
                                      /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ 0, /*iu=*/ 0,
                                      /*abstol=*/ 1e-14, &val,
                                      vectors ? &vec : 0,
                                      /*support=*/ 0));

    /* Look for smallest value */
    small = fabs(VECTOR(val)[0]);
    for (i = 1; i < n; i++) {
        igraph_real_t v = fabs(VECTOR(val)[i]);
        if (v < small) {
            small = v;
            w = i;
        }
    }
    p1 = w - 1; p2 = w;

    if (values) {
        IGRAPH_CHECK(igraph_vector_resize(values, which->howmany));
    }
    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, which->howmany));
    }

    while (pr < which->howmany) {
        if (p2 == n - 1 || fabs(VECTOR(val)[p1]) < fabs(VECTOR(val)[p2])) {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val)[p1];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec, 0, p1),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p1--;
            pr++;
        } else {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val)[p2];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec, 0, p2),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p2++;
            pr++;
        }
    }

    if (vectors) {
        igraph_matrix_destroy(&vec);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_destroy(&val);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_la(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    /* TODO: ordering? */

    int n = (int) igraph_matrix_nrow(A);
    int il = n - which->howmany + 1;
    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ il, /*iu=*/ n,
                                      /*abstol=*/ 1e-14, values, vectors,
                                      /*support=*/ 0));
    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_sa(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    /* TODO: ordering? */

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ 1, /*iu=*/ which->howmany,
                                      /*abstol=*/ 1e-14, values, vectors,
                                      /*support=*/ 0));

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_be(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    /* TODO: ordering? */

    igraph_matrix_t vec1, vec2;
    igraph_vector_t val1, val2;
    int n = (int) igraph_matrix_nrow(A);
    int p1 = 0, p2 = which->howmany / 2, pr = 0;

    IGRAPH_VECTOR_INIT_FINALLY(&val1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&val2, 0);

    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_init(&vec1, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &vec1);
        IGRAPH_CHECK(igraph_matrix_init(&vec2, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &vec1);
    }

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ 1, /*iu=*/ (which->howmany) / 2,
                                      /*abstol=*/ 1e-14, &val1,
                                      vectors ? &vec1 : 0,
                                      /*support=*/ 0));

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ n - (which->howmany) / 2, /*iu=*/ n,
                                      /*abstol=*/ 1e-14, &val2,
                                      vectors ? &vec2 : 0,
                                      /*support=*/ 0));

    if (values) {
        IGRAPH_CHECK(igraph_vector_resize(values, which->howmany));
    }
    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, which->howmany));
    }

    while (pr < which->howmany) {
        if (pr % 2) {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val1)[p1];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec1, 0, p1),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p1++;
            pr++;
        } else {
            if (values) {
                VECTOR(*values)[pr] = VECTOR(val2)[p2];
            }
            if (vectors) {
                memcpy(&MATRIX(*vectors, 0, pr), &MATRIX(vec2, 0, p2),
                       sizeof(igraph_real_t) * (size_t) n);
            }
            p2--;
            pr++;
        }
    }

    if (vectors) {
        igraph_matrix_destroy(&vec2);
        igraph_matrix_destroy(&vec1);
        IGRAPH_FINALLY_CLEAN(2);
    }
    igraph_vector_destroy(&val2);
    igraph_vector_destroy(&val1);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_all(const igraph_matrix_t *A,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_ALL, /*vl=*/ 0,
                                      /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ 0, /*iu=*/ 0,
                                      /*abstol=*/ 1e-14, values, vectors,
                                      /*support=*/ 0));

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_iv(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_INTERVAL,
                                      /*vl=*/ which->vl, /*vu=*/ which->vu,
                                      /*vestimate=*/ which->vestimate,
                                      /*il=*/ 0, /*iu=*/ 0,
                                      /*abstol=*/ 1e-14, values, vectors,
                                      /*support=*/ 0));

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack_sel(const igraph_matrix_t *A,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    IGRAPH_CHECK(igraph_lapack_dsyevr(A, IGRAPH_LAPACK_DSYEV_SELECT,
                                      /*vl=*/ 0, /*vu=*/ 0, /*vestimate=*/ 0,
                                      /*il=*/ which->il, /*iu=*/ which->iu,
                                      /*abstol=*/ 1e-14, values, vectors,
                                      /*support=*/ 0));

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_lapack(const igraph_matrix_t *A,
        const igraph_sparsemat_t *sA,
        igraph_arpack_function_t *fun,
        int n, void *extra,
        const igraph_eigen_which_t *which,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    const igraph_matrix_t *myA = A;
    igraph_matrix_t mA;

    /* First we need to create a dense square matrix */

    if (A) {
        n = (int) igraph_matrix_nrow(A);
    } else if (sA) {
        n = (int) igraph_sparsemat_nrow(sA);
        IGRAPH_CHECK(igraph_matrix_init(&mA, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &mA);
        IGRAPH_CHECK(igraph_sparsemat_as_matrix(&mA, sA));
        myA = &mA;
    } else if (fun) {
        IGRAPH_CHECK(igraph_i_eigen_arpackfun_to_mat(fun, n, extra, &mA));
        IGRAPH_FINALLY(igraph_matrix_destroy, &mA);
        myA = &mA;
    }

    switch (which->pos) {
    case IGRAPH_EIGEN_LM:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_lm(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SM:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_sm(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_LA:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_la(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SA:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_sa(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_BE:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_be(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_ALL:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_all(myA,
                     values,
                     vectors));
        break;
    case IGRAPH_EIGEN_INTERVAL:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_iv(myA, which,
                     values,
                     vectors));
        break;
    case IGRAPH_EIGEN_SELECT:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack_sel(myA, which,
                     values,
                     vectors));
        break;
    default:
        /* This cannot happen */
        break;
    }

    if (!A) {
        igraph_matrix_destroy(&mA);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

typedef struct igraph_i_eigen_matrix_sym_arpack_data_t {
    const igraph_matrix_t *A;
    const igraph_sparsemat_t *sA;
} igraph_i_eigen_matrix_sym_arpack_data_t;

static int igraph_i_eigen_matrix_sym_arpack_cb(igraph_real_t *to,
                                        const igraph_real_t *from,
                                        int n, void *extra) {

    igraph_i_eigen_matrix_sym_arpack_data_t *data =
        (igraph_i_eigen_matrix_sym_arpack_data_t *) extra;

    if (data->A) {
        igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0,
                                               data->A, from, /*beta=*/ 0.0, to);
    } else { /* data->sA */
        igraph_vector_t vto, vfrom;
        igraph_vector_view(&vto, to, n);
        igraph_vector_view(&vfrom, from, n);
        igraph_vector_null(&vto);
        igraph_sparsemat_gaxpy(data->sA, &vfrom, &vto);
    }
    return 0;
}

static int igraph_i_eigen_matrix_symmetric_arpack_be(const igraph_matrix_t *A,
        const igraph_sparsemat_t *sA,
        igraph_arpack_function_t *fun,
        int n, void *extra,
        const igraph_eigen_which_t *which,
        igraph_arpack_options_t *options,
        igraph_arpack_storage_t *storage,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    igraph_vector_t tmpvalues, tmpvalues2;
    igraph_matrix_t tmpvectors, tmpvectors2;

    int low = (int) floor(which->howmany / 2.0), high = (int) ceil(which->howmany / 2.0);
    int l1, l2, w;

    igraph_i_eigen_matrix_sym_arpack_data_t myextra;
    myextra.A = A;
    myextra.sA = sA;

    if (low + high >= n) {
        IGRAPH_ERROR("Requested too many eigenvalues/vectors", IGRAPH_EINVAL);
    }

    if (!fun) {
        fun = igraph_i_eigen_matrix_sym_arpack_cb;
        extra = (void*) &myextra;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&tmpvalues, high);
    IGRAPH_MATRIX_INIT_FINALLY(&tmpvectors, n, high);
    IGRAPH_VECTOR_INIT_FINALLY(&tmpvalues2, low);
    IGRAPH_MATRIX_INIT_FINALLY(&tmpvectors2, n, low);

    options->n = n;
    options->nev = high;
    options->ncv = 2 * options->nev < n ? 2 * options->nev : n;
    options->which[0] = 'L'; options->which[1] = 'A';

    IGRAPH_CHECK(igraph_arpack_rssolve(fun, extra, options, storage,
                                       &tmpvalues, &tmpvectors));

    options->nev = low;
    options->ncv = 2 * options->nev < n ? 2 * options->nev : n;
    options->which[0] = 'S'; options->which[1] = 'A';

    IGRAPH_CHECK(igraph_arpack_rssolve(fun, extra, options, storage,
                                       &tmpvalues2, &tmpvectors2));

    IGRAPH_CHECK(igraph_vector_resize(values, low + high));
    IGRAPH_CHECK(igraph_matrix_resize(vectors, n, low + high));

    l1 = 0; l2 = 0; w = 0;
    while (w < which->howmany) {
        VECTOR(*values)[w] = VECTOR(tmpvalues)[l1];
        memcpy(&MATRIX(*vectors, 0, w), &MATRIX(tmpvectors, 0, l1),
               (size_t) n * sizeof(igraph_real_t));
        w++; l1++;
        if (w < which->howmany) {
            VECTOR(*values)[w] = VECTOR(tmpvalues2)[l2];
            memcpy(&MATRIX(*vectors, 0, w), &MATRIX(tmpvectors2, 0, l2),
                   (size_t) n * sizeof(igraph_real_t));
            w++; l2++;
        }
    }

    igraph_matrix_destroy(&tmpvectors2);
    igraph_vector_destroy(&tmpvalues2);
    igraph_matrix_destroy(&tmpvectors);
    igraph_vector_destroy(&tmpvalues);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

static int igraph_i_eigen_matrix_symmetric_arpack(const igraph_matrix_t *A,
        const igraph_sparsemat_t *sA,
        igraph_arpack_function_t *fun,
        int n, void *extra,
        const igraph_eigen_which_t *which,
        igraph_arpack_options_t *options,
        igraph_arpack_storage_t *storage,
        igraph_vector_t *values,
        igraph_matrix_t *vectors) {

    /* For ARPACK we need a matrix multiplication operation.
       This can be done in any format, so everything is fine,
       we don't have to convert. */

    igraph_i_eigen_matrix_sym_arpack_data_t myextra;

    myextra.A = A;
    myextra.sA = sA;

    if (!options) {
        IGRAPH_ERROR("`options' must be given for ARPACK algorithm",
                     IGRAPH_EINVAL);
    }

    if (which->pos == IGRAPH_EIGEN_BE) {
        return igraph_i_eigen_matrix_symmetric_arpack_be(A, sA, fun, n, extra,
                which, options, storage,
                values, vectors);
    } else {

        switch (which->pos) {
        case IGRAPH_EIGEN_LM:
            options->which[0] = 'L'; options->which[1] = 'M';
            options->nev = which->howmany;
            break;
        case IGRAPH_EIGEN_SM:
            options->which[0] = 'S'; options->which[1] = 'M';
            options->nev = which->howmany;
            break;
        case IGRAPH_EIGEN_LA:
            options->which[0] = 'L'; options->which[1] = 'A';
            options->nev = which->howmany;
            break;
        case IGRAPH_EIGEN_SA:
            options->which[0] = 'S'; options->which[1] = 'A';
            options->nev = which->howmany;
            break;
        case IGRAPH_EIGEN_ALL:
            options->which[0] = 'L'; options->which[1] = 'M';
            options->nev = n;
            break;
        case IGRAPH_EIGEN_INTERVAL:
            IGRAPH_ERROR("Interval of eigenvectors with ARPACK",
                         IGRAPH_UNIMPLEMENTED);
            /* TODO */
            break;
        case IGRAPH_EIGEN_SELECT:
            IGRAPH_ERROR("Selected eigenvalues with ARPACK",
                         IGRAPH_UNIMPLEMENTED);
            /* TODO */
            break;
        default:
            /* This cannot happen */
            break;
        }

        options->n = n;
        options->ncv = 2 * options->nev < n ? 2 * options->nev : n;

        if (!fun) {
            fun = igraph_i_eigen_matrix_sym_arpack_cb;
            extra = (void*) &myextra;
        }

        IGRAPH_CHECK(igraph_arpack_rssolve(fun, extra, options, storage,
                                           values, vectors));
        return 0;
    }
}

/* Get the eigenvalues and the eigenvectors from the compressed
   form. Order them according to the ordering criteria.
   Comparison functions for the reordering first */

typedef int (*igraph_i_eigen_matrix_lapack_cmp_t)(void*, const void*,
        const void *);

typedef struct igraph_i_eml_cmp_t {
    const igraph_vector_t *mag, *real, *imag;
} igraph_i_eml_cmp_t;

/* TODO: these should be defined in some header */

#define EPS        (DBL_EPSILON*100)
#define LESS(a,b)  ((a) < (b)-EPS)
#define MORE(a,b)  ((a) > (b)+EPS)
#define ZERO(a)    ((a) > -EPS && (a) < EPS)
#define NONZERO(a) ((a) < -EPS || (a) > EPS)

/* Largest magnitude. Ordering is according to
   1 Larger magnitude
   2 Real eigenvalues before complex ones
   3 Larger real part
   4 Larger imaginary part */

static int igraph_i_eigen_matrix_lapack_cmp_lm(void *extra, const void *a,
                                        const void *b) {
    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_m = VECTOR(*myextra->mag)[*aa];
    igraph_real_t b_m = VECTOR(*myextra->mag)[*bb];

    if (LESS(a_m, b_m)) {
        return 1;
    } else if (MORE(a_m, b_m)) {
        return -1;
    } else {
        igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
        igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
        igraph_real_t b_r = VECTOR(*myextra->real)[*bb];
        igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];
        if (ZERO(a_i)    && NONZERO(b_i))  {
            return -1;
        }
        if (NONZERO(a_i) && ZERO(b_i))     {
            return  1;
        }
        if (MORE(a_r, b_r)) {
            return -1;
        }
        if (LESS(a_r, b_r)) {
            return  1;
        }
        if (MORE(a_i, b_i)) {
            return -1;
        }
        if (LESS(a_i, b_i)) {
            return  1;
        }
    }
    return 0;
}

/* Smallest marginude. Ordering is according to
   1 Magnitude (smaller first)
   2 Complex eigenvalues before real ones
   3 Smaller real part
   4 Smaller imaginary part
   This ensures that lm has exactly the opposite order to sm */

static int igraph_i_eigen_matrix_lapack_cmp_sm(void *extra, const void *a,
                                        const void *b) {
    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_m = VECTOR(*myextra->mag)[*aa];
    igraph_real_t b_m = VECTOR(*myextra->mag)[*bb];

    if (MORE(a_m, b_m)) {
        return 1;
    } else if (LESS(a_m, b_m)) {
        return -1;
    } else {
        igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
        igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
        igraph_real_t b_r = VECTOR(*myextra->real)[*bb];
        igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];
        if (NONZERO(a_i) && ZERO(b_i))    {
            return -1;
        }
        if (ZERO(a_i)    && NONZERO(b_i)) {
            return  1;
        }
        if (LESS(a_r, b_r)) {
            return -1;
        }
        if (MORE(a_r, b_r)) {
            return  1;
        }
        if (LESS(a_i, b_i)) {
            return -1;
        }
        if (MORE(a_i, b_i)) {
            return  1;
        }
    }
    return 0;
}

/* Largest real part. Ordering is according to
   1 Larger real part
   2 Real eigenvalues come before complex ones
   3 Larger complex part */

static int igraph_i_eigen_matrix_lapack_cmp_lr(void *extra, const void *a,
                                        const void *b) {

    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
    igraph_real_t b_r = VECTOR(*myextra->real)[*bb];

    if (MORE(a_r, b_r)) {
        return -1;
    } else if (LESS(a_r, b_r)) {
        return 1;
    } else {
        igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
        igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];
        if (ZERO(a_i) && NONZERO(b_i)) {
            return -1;
        }
        if (NONZERO(a_i) && ZERO(b_i)) {
            return  1;
        }
        if (MORE(a_i, b_i)) {
            return -1;
        }
        if (LESS(a_i, b_i)) {
            return  1;
        }
    }

    return 0;
}

/* Largest real part. Ordering is according to
   1 Smaller real part
   2 Complex eigenvalues come before real ones
   3 Smaller complex part
   This is opposite to LR
*/

static int igraph_i_eigen_matrix_lapack_cmp_sr(void *extra, const void *a,
                                        const void *b) {

    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
    igraph_real_t b_r = VECTOR(*myextra->real)[*bb];

    if (LESS(a_r, b_r)) {
        return -1;
    } else if (MORE(a_r, b_r)) {
        return 1;
    } else {
        igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
        igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];
        if (NONZERO(a_i) && ZERO(b_i)) {
            return -1;
        }
        if (ZERO(a_i) && NONZERO(b_i)) {
            return  1;
        }
        if (LESS(a_i, b_i)) {
            return -1;
        }
        if (MORE(a_i, b_i)) {
            return  1;
        }
    }

    return 0;
}

/* Order:
   1 Larger imaginary part
   2 Real eigenvalues before complex ones
   3 Larger real part */

static int igraph_i_eigen_matrix_lapack_cmp_li(void *extra, const void *a,
                                        const void *b) {

    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
    igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];

    if (MORE(a_i, b_i)) {
        return -1;
    } else if (LESS(a_i, b_i)) {
        return 1;
    } else {
        igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
        igraph_real_t b_r = VECTOR(*myextra->real)[*bb];
        if (ZERO(a_i) && NONZERO(b_i)) {
            return -1;
        }
        if (NONZERO(a_i) && ZERO(b_i)) {
            return  1;
        }
        if (MORE(a_r, b_r)) {
            return -1;
        }
        if (LESS(a_r, b_r)) {
            return  1;
        }
    }

    return 0;
}

/* Order:
   1 Smaller imaginary part
   2 Complex eigenvalues before real ones
   3 Smaller real part
   Order is opposite to LI */

static int igraph_i_eigen_matrix_lapack_cmp_si(void *extra, const void *a,
                                        const void *b) {

    igraph_i_eml_cmp_t *myextra = (igraph_i_eml_cmp_t *) extra;
    int *aa = (int*) a, *bb = (int*) b;
    igraph_real_t a_i = VECTOR(*myextra->imag)[*aa];
    igraph_real_t b_i = VECTOR(*myextra->imag)[*bb];

    if (LESS(a_i, b_i)) {
        return -1;
    } else if (MORE(a_i, b_i)) {
        return 1;
    } else {
        igraph_real_t a_r = VECTOR(*myextra->real)[*aa];
        igraph_real_t b_r = VECTOR(*myextra->real)[*bb];
        if (NONZERO(a_i) && ZERO(b_i)) {
            return -1;
        }
        if (ZERO(a_i) && NONZERO(b_i)) {
            return  1;
        }
        if (LESS(a_r, b_r)) {
            return -1;
        }
        if (MORE(a_r, b_r)) {
            return  1;
        }
    }

    return 0;
}

#undef EPS
#undef LESS
#undef MORE
#undef ZERO
#undef NONZERO

#define INITMAG()                           \
    do {                                  \
        int i;                              \
        IGRAPH_VECTOR_INIT_FINALLY(&mag, nev);              \
        hasmag=1;                               \
        for (i=0; ipos) {
    case IGRAPH_EIGEN_LM:
        INITMAG();
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_lm;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_ALL:
        INITMAG();
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_sm;
        howmany = nev;
        break;
    case IGRAPH_EIGEN_SM:
        INITMAG();
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_sm;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_LR:
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_lr;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_SR:
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_sr;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_SELECT:
        INITMAG();
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_sm;
        start = which->il - 1;
        howmany = which->iu - which->il + 1;
        break;
    case IGRAPH_EIGEN_LI:
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_li;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_SI:
        cmpfunc = igraph_i_eigen_matrix_lapack_cmp_si;
        howmany = which->howmany;
        break;
    case IGRAPH_EIGEN_INTERVAL:
    case IGRAPH_EIGEN_BE:
    default:
        IGRAPH_ERROR("Unimplemented eigenvalue ordering", IGRAPH_UNIMPLEMENTED);
        break;
    }

    for (i = 0; i < nev; i++) {
        VECTOR(idx)[i] = i;
    }

    igraph_qsort_r(VECTOR(idx), (size_t) nev, sizeof(VECTOR(idx)[0]), extra,
                   cmpfunc);

    if (hasmag) {
        igraph_vector_destroy(&mag);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (values) {
        IGRAPH_CHECK(igraph_vector_complex_resize(values, howmany));
        for (i = 0; i < howmany; i++) {
            int x = VECTOR(idx)[start + i];
            VECTOR(*values)[i] = igraph_complex(VECTOR(*real)[x],
                                                VECTOR(*imag)[x]);
        }
    }

    if (vectors) {
        int n = (int) igraph_matrix_nrow(compressed);
        IGRAPH_CHECK(igraph_matrix_complex_resize(vectors, n, howmany));
        for (i = 0; i < howmany; i++) {
            int j, x = VECTOR(idx)[start + i];
            if (VECTOR(*imag)[x] == 0) {
                /* real eigenvalue */
                for (j = 0; j < n; j++) {
                    MATRIX(*vectors, j, i) = igraph_complex(MATRIX(*compressed, j, x),
                                                            0.0);
                }
            } else {
                /* complex eigenvalue */
                int neg = 1, co = 0;
                if (VECTOR(*imag)[x] < 0) {
                    neg = -1;
                    co = 1;
                }
                for (j = 0; j < n; j++) {
                    MATRIX(*vectors, j, i) =
                        igraph_complex(MATRIX(*compressed, j, x - co),
                                       neg * MATRIX(*compressed, j, x + 1 - co));
                }
            }
        }
    }

    igraph_vector_int_destroy(&idx);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_eigen_matrix_lapack_common(const igraph_matrix_t *A,
                                        const igraph_eigen_which_t *which,
                                        igraph_vector_complex_t *values,
                                        igraph_matrix_complex_t *vectors) {

    igraph_vector_t valuesreal, valuesimag;
    igraph_matrix_t vectorsright, *myvectors = vectors ? &vectorsright : 0;
    int n = (int) igraph_matrix_nrow(A);
    int info = 1;

    IGRAPH_VECTOR_INIT_FINALLY(&valuesreal, n);
    IGRAPH_VECTOR_INIT_FINALLY(&valuesimag, n);
    if (vectors) {
        IGRAPH_MATRIX_INIT_FINALLY(&vectorsright, n, n);
    }
    IGRAPH_CHECK(igraph_lapack_dgeev(A, &valuesreal, &valuesimag,
                                     /*vectorsleft=*/ 0, myvectors, &info));

    IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_reorder(&valuesreal,
                 &valuesimag,
                 myvectors, which, values,
                 vectors));

    if (vectors) {
        igraph_matrix_destroy(&vectorsright);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&valuesimag);
    igraph_vector_destroy(&valuesreal);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;

}

static int igraph_i_eigen_matrix_lapack_lm(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_sm(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_lr(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}


static int igraph_i_eigen_matrix_lapack_sr(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_li(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_si(const igraph_matrix_t *A,
                                    const igraph_eigen_which_t *which,
                                    igraph_vector_complex_t *values,
                                    igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_select(const igraph_matrix_t *A,
                                        const igraph_eigen_which_t *which,
                                        igraph_vector_complex_t *values,
                                        igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack_all(const igraph_matrix_t *A,
                                     const igraph_eigen_which_t *which,
                                     igraph_vector_complex_t *values,
                                     igraph_matrix_complex_t *vectors) {
    return igraph_i_eigen_matrix_lapack_common(A, which, values, vectors);
}

static int igraph_i_eigen_matrix_lapack(const igraph_matrix_t *A,
                                 const igraph_sparsemat_t *sA,
                                 igraph_arpack_function_t *fun,
                                 int n, void *extra,
                                 const igraph_eigen_which_t *which,
                                 igraph_vector_complex_t *values,
                                 igraph_matrix_complex_t *vectors) {

    const igraph_matrix_t *myA = A;
    igraph_matrix_t mA;

    /* We need to create a dense square matrix first */

    if (A) {
        n = (int) igraph_matrix_nrow(A);
    } else if (sA) {
        n = (int) igraph_sparsemat_nrow(sA);
        IGRAPH_CHECK(igraph_matrix_init(&mA, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &mA);
        IGRAPH_CHECK(igraph_sparsemat_as_matrix(&mA, sA));
        myA = &mA;
    } else if (fun) {
        IGRAPH_CHECK(igraph_i_eigen_arpackfun_to_mat(fun, n, extra, &mA));
        IGRAPH_FINALLY(igraph_matrix_destroy, &mA);
    }

    switch (which->pos) {
    case IGRAPH_EIGEN_LM:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_lm(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SM:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_sm(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_LR:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_lr(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SR:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_sr(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_LI:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_li(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SI:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_si(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_SELECT:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_select(myA, which,
                     values, vectors));
        break;
    case IGRAPH_EIGEN_ALL:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack_all(myA, which,
                     values,
                     vectors));
        break;
    default:
        /* This cannot happen */
        break;
    }

    if (!A) {
        igraph_matrix_destroy(&mA);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

static int igraph_i_eigen_checks(const igraph_matrix_t *A,
                          const igraph_sparsemat_t *sA,
                          igraph_arpack_function_t *fun, int n) {

    if ( (A ? 1 : 0) + (sA ? 1 : 0) + (fun ? 1 : 0) != 1) {
        IGRAPH_ERROR("Exactly one of 'A', 'sA' and 'fun' must be given",
                     IGRAPH_EINVAL);
    }

    if (A) {
        if (n != igraph_matrix_ncol(A) || n != igraph_matrix_nrow(A)) {
            IGRAPH_ERROR("Invalid matrix", IGRAPH_NONSQUARE);
        }
    } else if (sA) {
        if (n != igraph_sparsemat_ncol(sA) || n != igraph_sparsemat_nrow(sA)) {
            IGRAPH_ERROR("Invalid matrix", IGRAPH_NONSQUARE);
        }
    }

    return 0;
}

/**
 * \function igraph_eigen_matrix_symmetric
 *
 * \example examples/simple/igraph_eigen_matrix_symmetric.c
 */

int igraph_eigen_matrix_symmetric(const igraph_matrix_t *A,
                                  const igraph_sparsemat_t *sA,
                                  igraph_arpack_function_t *fun, int n,
                                  void *extra,
                                  igraph_eigen_algorithm_t algorithm,
                                  const igraph_eigen_which_t *which,
                                  igraph_arpack_options_t *options,
                                  igraph_arpack_storage_t *storage,
                                  igraph_vector_t *values,
                                  igraph_matrix_t *vectors) {

    IGRAPH_CHECK(igraph_i_eigen_checks(A, sA, fun, n));

    if (which->pos != IGRAPH_EIGEN_LM &&
        which->pos != IGRAPH_EIGEN_SM &&
        which->pos != IGRAPH_EIGEN_LA &&
        which->pos != IGRAPH_EIGEN_SA &&
        which->pos != IGRAPH_EIGEN_BE &&
        which->pos != IGRAPH_EIGEN_ALL &&
        which->pos != IGRAPH_EIGEN_INTERVAL &&
        which->pos != IGRAPH_EIGEN_SELECT) {
        IGRAPH_ERROR("Invalid 'pos' position in 'which'", IGRAPH_EINVAL);
    }

    switch (algorithm) {
    case IGRAPH_EIGEN_AUTO:
        if (which->howmany == n || n < 100) {
            IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack(A, sA, fun, n,
                         extra, which,
                         values, vectors));
        } else {
            IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_arpack(A, sA, fun, n,
                         extra, which,
                         options, storage,
                         values, vectors));
        }
        break;
    case IGRAPH_EIGEN_LAPACK:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_lapack(A, sA, fun, n, extra,
                     which, values,
                     vectors));
        break;
    case IGRAPH_EIGEN_ARPACK:
        IGRAPH_CHECK(igraph_i_eigen_matrix_symmetric_arpack(A, sA, fun, n, extra,
                     which, options,
                     storage,
                     values, vectors));
        break;
    default:
        IGRAPH_ERROR("Unknown 'algorithm'", IGRAPH_EINVAL);
    }

    return 0;
}

/**
 * \function igraph_eigen_matrix
 *
 */

int igraph_eigen_matrix(const igraph_matrix_t *A,
                        const igraph_sparsemat_t *sA,
                        igraph_arpack_function_t *fun, int n,
                        void *extra,
                        igraph_eigen_algorithm_t algorithm,
                        const igraph_eigen_which_t *which,
                        igraph_arpack_options_t *options,
                        igraph_arpack_storage_t *storage,
                        igraph_vector_complex_t *values,
                        igraph_matrix_complex_t *vectors) {

    IGRAPH_UNUSED(options);
    IGRAPH_UNUSED(storage);

    IGRAPH_CHECK(igraph_i_eigen_checks(A, sA, fun, n));

    if (which->pos != IGRAPH_EIGEN_LM &&
        which->pos != IGRAPH_EIGEN_SM &&
        which->pos != IGRAPH_EIGEN_LR &&
        which->pos != IGRAPH_EIGEN_SR &&
        which->pos != IGRAPH_EIGEN_LI &&
        which->pos != IGRAPH_EIGEN_SI &&
        which->pos != IGRAPH_EIGEN_SELECT &&
        which->pos != IGRAPH_EIGEN_ALL) {
        IGRAPH_ERROR("Invalid 'pos' position in 'which'", IGRAPH_EINVAL);
    }

    switch (algorithm) {
    case IGRAPH_EIGEN_AUTO:
        IGRAPH_ERROR("'AUTO' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_LAPACK:
        IGRAPH_CHECK(igraph_i_eigen_matrix_lapack(A, sA, fun, n, extra, which,
                     values, vectors));
        /* TODO */
        break;
    case IGRAPH_EIGEN_ARPACK:
        IGRAPH_ERROR("'ARPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_COMP_AUTO:
        IGRAPH_ERROR("'COMP_AUTO' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_COMP_LAPACK:
        IGRAPH_ERROR("'COMP_LAPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_COMP_ARPACK:
        IGRAPH_ERROR("'COMP_ARPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    default:
        IGRAPH_ERROR("Unknown `algorithm'", IGRAPH_EINVAL);
    }

    return 0;
}

static int igraph_i_eigen_adjacency_arpack_sym_cb(igraph_real_t *to,
        const igraph_real_t *from,
        int n, void *extra) {
    igraph_adjlist_t *adjlist = (igraph_adjlist_t *) extra;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(adjlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int nei = VECTOR(*neis)[j];
            to[i] += from[nei];
        }
    }

    return 0;
}

static int igraph_i_eigen_adjacency_arpack(const igraph_t *graph,
                                    const igraph_eigen_which_t *which,
                                    igraph_arpack_options_t *options,
                                    igraph_arpack_storage_t* storage,
                                    igraph_vector_t *values,
                                    igraph_matrix_t *vectors,
                                    igraph_vector_complex_t *cmplxvalues,
                                    igraph_matrix_complex_t *cmplxvectors) {

    IGRAPH_UNUSED(cmplxvalues);
    IGRAPH_UNUSED(cmplxvectors);

    igraph_adjlist_t adjlist;
    void *extra = (void*) &adjlist;
    int n = igraph_vcount(graph);

    if (!options) {
        IGRAPH_ERROR("`options' must be given for ARPACK algorithm",
                     IGRAPH_EINVAL);
    }

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("ARPACK adjacency eigensolver not implemented for "
                     "directed graphs", IGRAPH_UNIMPLEMENTED);
    }
    if (which->pos == IGRAPH_EIGEN_INTERVAL) {
        IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
                     "`INTERNAL' eigenvalues", IGRAPH_UNIMPLEMENTED);
    }
    if (which->pos == IGRAPH_EIGEN_SELECT) {
        IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
                     "`SELECT' eigenvalues", IGRAPH_UNIMPLEMENTED);
    }
    if (which->pos == IGRAPH_EIGEN_ALL) {
        IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
                     "`ALL' eigenvalues", IGRAPH_UNIMPLEMENTED);
    }

    switch (which->pos) {
    case IGRAPH_EIGEN_LM:
        options->which[0] = 'L'; options->which[1] = 'M';
        options->nev = which->howmany;
        break;
    case IGRAPH_EIGEN_SM:
        options->which[0] = 'S'; options->which[1] = 'M';
        options->nev = which->howmany;
        break;
    case IGRAPH_EIGEN_LA:
        options->which[0] = 'L'; options->which[1] = 'A';
        options->nev = which->howmany;
        break;
    case IGRAPH_EIGEN_SA:
        options->which[0] = 'S'; options->which[1] = 'A';
        options->nev = which->howmany;
        break;
    case IGRAPH_EIGEN_ALL:
        options->which[0] = 'L'; options->which[1] = 'M';
        options->nev = n;
        break;
    case IGRAPH_EIGEN_BE:
        IGRAPH_ERROR("Eigenvectors from both ends with ARPACK",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_INTERVAL:
        IGRAPH_ERROR("Interval of eigenvectors with ARPACK",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_SELECT:
        IGRAPH_ERROR("Selected eigenvalues with ARPACK",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    default:
        /* This cannot happen */
        break;
    }

    options->n = n;
    options->ncv = 2 * options->nev < n ? 2 * options->nev : n;

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigen_adjacency_arpack_sym_cb,
                                       extra, options, storage, values, vectors));

    igraph_adjlist_destroy(&adjlist);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_eigen_adjacency
 *
 */

int igraph_eigen_adjacency(const igraph_t *graph,
                           igraph_eigen_algorithm_t algorithm,
                           const igraph_eigen_which_t *which,
                           igraph_arpack_options_t *options,
                           igraph_arpack_storage_t *storage,
                           igraph_vector_t *values,
                           igraph_matrix_t *vectors,
                           igraph_vector_complex_t *cmplxvalues,
                           igraph_matrix_complex_t *cmplxvectors) {

    if (which->pos != IGRAPH_EIGEN_LM &&
        which->pos != IGRAPH_EIGEN_SM &&
        which->pos != IGRAPH_EIGEN_LA &&
        which->pos != IGRAPH_EIGEN_SA &&
        which->pos != IGRAPH_EIGEN_BE &&
        which->pos != IGRAPH_EIGEN_SELECT &&
        which->pos != IGRAPH_EIGEN_INTERVAL &&
        which->pos != IGRAPH_EIGEN_ALL) {
        IGRAPH_ERROR("Invalid 'pos' position in 'which'", IGRAPH_EINVAL);
    }

    switch (algorithm) {
    case IGRAPH_EIGEN_AUTO:
        IGRAPH_ERROR("'AUTO' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_LAPACK:
        IGRAPH_ERROR("'LAPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_ARPACK:
        IGRAPH_CHECK(igraph_i_eigen_adjacency_arpack(graph, which, options,
                     storage, values, vectors,
                     cmplxvalues,
                     cmplxvectors));
        break;
    case IGRAPH_EIGEN_COMP_AUTO:
        IGRAPH_ERROR("'COMP_AUTO' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_COMP_LAPACK:
        IGRAPH_ERROR("'COMP_LAPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    case IGRAPH_EIGEN_COMP_ARPACK:
        IGRAPH_ERROR("'COMP_ARPACK' algorithm not implemented yet",
                     IGRAPH_UNIMPLEMENTED);
        /* TODO */
        break;
    default:
        IGRAPH_ERROR("Unknown `algorithm'", IGRAPH_EINVAL);
    }


    return 0;
}

/**
 * \function igraph_eigen_laplacian
 *
 */

int igraph_eigen_laplacian(const igraph_t *graph,
                           igraph_eigen_algorithm_t algorithm,
                           const igraph_eigen_which_t *which,
                           igraph_arpack_options_t *options,
                           igraph_arpack_storage_t *storage,
                           igraph_vector_t *values,
                           igraph_matrix_t *vectors,
                           igraph_vector_complex_t *cmplxvalues,
                           igraph_matrix_complex_t *cmplxvectors) {

    IGRAPH_UNUSED(graph);
    IGRAPH_UNUSED(algorithm);
    IGRAPH_UNUSED(which);
    IGRAPH_UNUSED(options);
    IGRAPH_UNUSED(storage);
    IGRAPH_UNUSED(values);
    IGRAPH_UNUSED(vectors);
    IGRAPH_UNUSED(cmplxvalues);
    IGRAPH_UNUSED(cmplxvectors);

    /* TODO */

    IGRAPH_ERROR("'igraph_eigen_laplacian'", IGRAPH_UNIMPLEMENTED);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/lapack.c0000644000175100001710000010551500000000000023315 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_lapack.h"

#include "linalg/lapack_internal.h"

/**
 * \function igraph_lapack_dgetrf
 * \brief LU factorization of a general M-by-N matrix.
 *
 * The factorization has the form
 *      A = P * L * U
 * where P is a permutation matrix, L is lower triangular with unit
 * diagonal elements (lower trapezoidal if m > n), and U is upper
 * triangular (upper trapezoidal if m < n).
 * \param a The input/output matrix. On entry, the M-by-N matrix to be
 *      factored. On exit, the factors L and U from the factorization
 *      A = P * L * U; the unit diagonal elements of L are not
 *      stored.
 * \param ipiv An integer vector, the pivot indices are stored here,
 *      unless it is a null pointer. Row \c i of the matrix was
 *      interchanged with row ipiv[i].
 * \param info LAPACK error code. Zero on successful exit. If its value is
 *      a positive number i, it indicates that U(i,i) is exactly zero.
 *      The factorization has been
 *      completed, but the factor U is exactly singular, and division
 *      by zero will occur if it is used to solve a system of
 *      equations. If LAPACK returns an error, i.e. a negative info
 *      value, then an igraph error is generated as well.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_lapack_dgetrf(igraph_matrix_t *a, igraph_vector_int_t *ipiv,
                         int *info) {
    int m = (int) igraph_matrix_nrow(a);
    int n = (int) igraph_matrix_ncol(a);
    int lda = m > 0 ? m : 1;
    igraph_vector_int_t *myipiv = ipiv, vipiv;

    if (!ipiv) {
        IGRAPH_CHECK(igraph_vector_int_init(&vipiv, m < n ? m : n));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &vipiv);
        myipiv = &vipiv;
    } else {
        IGRAPH_CHECK(igraph_vector_int_resize(ipiv, m < n ? m : n));
    }

    igraphdgetrf_(&m, &n, VECTOR(a->data), &lda, VECTOR(*myipiv), info);

    if (*info > 0) {
        IGRAPH_WARNING("LU: factor is exactly singular.");
    } else if (*info < 0) {
        switch (*info) {
        case -1:
            IGRAPH_ERROR("Invalid number of rows.", IGRAPH_ELAPACK);
            break;
        case -2:
            IGRAPH_ERROR("Invalid number of columns.", IGRAPH_ELAPACK);
            break;
        case -3:
            IGRAPH_ERROR("Invalid input matrix.", IGRAPH_ELAPACK);
            break;
        case -4:
            IGRAPH_ERROR("Invalid LDA parameter.", IGRAPH_ELAPACK);
            break;
        case -5:
            IGRAPH_ERROR("Invalid pivot vector.", IGRAPH_ELAPACK);
            break;
        case -6:
            IGRAPH_ERROR("Invalid info argument.", IGRAPH_ELAPACK);
            break;
        default:
            IGRAPH_ERROR("Unknown LAPACK error.", IGRAPH_ELAPACK);
            break;
        }
    }

    if (!ipiv) {
        igraph_vector_int_destroy(&vipiv);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_lapack_dgetrs
 * \brief Solve general system of linear equations using LU factorization.
 *
 * This function calls LAPACK to solve a system of linear equations
 *      A * X = B  or  A' * X = B
 * with a general N-by-N matrix A using the LU factorization
 * computed by \ref igraph_lapack_dgetrf.
 * \param transpose Logical scalar, whether to transpose the input
 *      matrix.
 * \param a A matrix containing the L and U factors from the
 *      factorization A = P*L*U. L is expected to be unitriangular,
 *      diagonal entries are those of U. If A is singular, no warning or
 *      error wil be given and random output will be returned.
 * \param ipiv An integer vector, the pivot indices from \ref
 *      igraph_lapack_dgetrf() must be given here. Row \c i of A was
 *      interchanged with row ipiv[i].
 * \param b The right hand side matrix must be given here. The solution
            will also be placed here.
 * \return Error code.
 *
 * Time complexity: TODO.
 */

int igraph_lapack_dgetrs(igraph_bool_t transpose, const igraph_matrix_t *a,
                         const igraph_vector_int_t *ipiv, igraph_matrix_t *b) {
    char trans = transpose ? 'T' : 'N';
    int n = (int) igraph_matrix_nrow(a);
    int nrhs = (int) igraph_matrix_ncol(b);
    int lda = n > 0 ? n : 1;
    int ldb = n > 0 ? n : 1;
    int info;

    if (n != igraph_matrix_ncol(a)) {
        IGRAPH_ERROR("Cannot LU solve matrix.", IGRAPH_NONSQUARE);
    }
    if (n != igraph_matrix_nrow(b)) {
        IGRAPH_ERROR("Cannot LU solve matrix, RHS of wrong size.", IGRAPH_EINVAL);
    }
    if (igraph_vector_int_size(ipiv) > 0) {
        igraph_integer_t min, max;
        igraph_vector_int_minmax(ipiv, &min, &max);
        if (max > n || min < 1) {
            IGRAPH_ERROR("Pivot index out of range.", IGRAPH_EINVAL);
        }
    }
    if (igraph_vector_int_size(ipiv) != n) {
        IGRAPH_ERROR("Pivot vector length must match number of matrix rows.", IGRAPH_EINVAL);
    }
    igraphdgetrs_(&trans, &n, &nrhs, VECTOR(a->data), &lda, VECTOR(*ipiv),
                  VECTOR(b->data), &ldb, &info);

    if (info < 0) {
        switch (info) {
        case -1:
            IGRAPH_ERROR("Invalid transpose argument.", IGRAPH_ELAPACK);
            break;
        case -2:
            IGRAPH_ERROR("Invalid number of rows/columns.", IGRAPH_ELAPACK);
            break;
        case -3:
            IGRAPH_ERROR("Invalid number of RHS vectors.", IGRAPH_ELAPACK);
            break;
        case -4:
            IGRAPH_ERROR("Invalid LU matrix.", IGRAPH_ELAPACK);
            break;
        case -5:
            IGRAPH_ERROR("Invalid LDA parameter.", IGRAPH_ELAPACK);
            break;
        case -6:
            IGRAPH_ERROR("Invalid pivot vector.", IGRAPH_ELAPACK);
            break;
        case -7:
            IGRAPH_ERROR("Invalid RHS matrix.", IGRAPH_ELAPACK);
            break;
        case -8:
            IGRAPH_ERROR("Invalid LDB parameter.", IGRAPH_ELAPACK);
            break;
        case -9:
            IGRAPH_ERROR("Invalid info argument.", IGRAPH_ELAPACK);
            break;
        default:
            IGRAPH_ERROR("Unknown LAPACK error.", IGRAPH_ELAPACK);
            break;
        }
    }

    return 0;
}

/**
 * \function igraph_lapack_dgesv
 * Solve system of linear equations with LU factorization
 *
 * This function computes the solution to a real system of linear
 * equations A * X = B, where A is an N-by-N matrix and X and B are
 * N-by-NRHS matrices.
 *
 * The LU decomposition with partial pivoting and row
 * interchanges is used to factor A as
 *    A = P * L * U,
 * where P is a permutation matrix, L is unit lower triangular, and U is
 * upper triangular.  The factored form of A is then used to solve the
 * system of equations A * X = B.
 * \param a Matrix. On entry the N-by-N coefficient matrix, on exit,
 *        the factors L and U from the factorization A=P*L*U; the unit
 *        diagonal elements of L are not stored.
 * \param ipiv An integer vector or a null pointer. If not a null
 *        pointer, then the pivot indices that define the permutation
 *        matrix P, are stored here. Row i of the matrix was
 *        interchanged with row IPIV(i).
 * \param b Matrix, on entry the right hand side matrix should be
 *        stored here. On exit, if there was no error, and the info
 *        argument is zero, then it contains the solution matrix X.
 * \param info The LAPACK info code. If it is positive, then
 *        U(info,info) is exactly zero. In this case the factorization
 *        has been completed, but the factor U is exactly
 *        singular, so the solution could not be computed.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_lapack_dgesv.c
 */

int igraph_lapack_dgesv(igraph_matrix_t *a, igraph_vector_int_t *ipiv,
                        igraph_matrix_t *b, int *info) {

    int n = (int) igraph_matrix_nrow(a);
    int nrhs = (int) igraph_matrix_ncol(b);
    int lda = n > 0 ? n : 1;
    int ldb = n > 0 ? n : 1;
    igraph_vector_int_t *myipiv = ipiv, vipiv;

    if (n != igraph_matrix_ncol(a)) {
        IGRAPH_ERROR("Cannot LU solve matrix.", IGRAPH_NONSQUARE);
    }
    if (n != igraph_matrix_nrow(b)) {
        IGRAPH_ERROR("Cannot LU solve matrix, RHS of wrong size.", IGRAPH_EINVAL);
    }

    if (!ipiv) {
        IGRAPH_CHECK(igraph_vector_int_init(&vipiv, n));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &vipiv);
        myipiv = &vipiv;
    }

    igraphdgesv_(&n, &nrhs, VECTOR(a->data), &lda, VECTOR(*myipiv),
                 VECTOR(b->data), &ldb, info);

    if (*info > 0) {
        IGRAPH_WARNING("LU: factor is exactly singular.");
    } else if (*info < 0) {
        switch (*info) {
        case -1:
            IGRAPH_ERROR("Invalid number of rows/column.", IGRAPH_ELAPACK);
            break;
        case -2:
            IGRAPH_ERROR("Invalid number of RHS vectors.", IGRAPH_ELAPACK);
            break;
        case -3:
            IGRAPH_ERROR("Invalid input matrix.", IGRAPH_ELAPACK);
            break;
        case -4:
            IGRAPH_ERROR("Invalid LDA parameter.", IGRAPH_ELAPACK);
            break;
        case -5:
            IGRAPH_ERROR("Invalid pivot vector.", IGRAPH_ELAPACK);
            break;
        case -6:
            IGRAPH_ERROR("Invalid RHS matrix.", IGRAPH_ELAPACK);
            break;
        case -7:
            IGRAPH_ERROR("Invalid LDB parameter.", IGRAPH_ELAPACK);
            break;
        case -8:
            IGRAPH_ERROR("Invalid info argument.", IGRAPH_ELAPACK);
            break;
        default:
            IGRAPH_ERROR("Unknown LAPACK error.", IGRAPH_ELAPACK);
            break;
        }
    }

    if (!ipiv) {
        igraph_vector_int_destroy(&vipiv);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_lapack_dsyevr
 * Selected eigenvalues and optionally eigenvectors of a symmetric matrix
 *
 * Calls the DSYEVR LAPACK function to compute selected eigenvalues
 * and, optionally, eigenvectors of a real symmetric matrix A.
 * Eigenvalues and eigenvectors can be selected by specifying either
 * a range of values or a range of indices for the desired eigenvalues.
 *
 * See more in the LAPACK documentation.
 * \param A Matrix, on entry it contains the symmetric input
 *        matrix. Only the leading N-by-N upper triangular part is
 *        used for the computation.
 * \param which Constant that gives which eigenvalues (and possibly
 *        the corresponding eigenvectors) to calculate. Possible
 *        values are \c IGRAPH_LAPACK_DSYEV_ALL, all eigenvalues;
 *        \c IGRAPH_LAPACK_DSYEV_INTERVAL, all eigenvalues in the
 *        half-open interval (vl,vu];
 *        \c IGRAPH_LAPACK_DSYEV_SELECT, the il-th through iu-th
 *        eigenvalues.
 * \param vl If \p which is \c IGRAPH_LAPACK_DSYEV_INTERVAL, then
 *        this is the lower bound of the interval to be searched for
 *        eigenvalues. See also the \p vestimate argument.
 * \param vu If \p which is \c IGRAPH_LAPACK_DSYEV_INTERVAL, then
 *        this is the upper bound of the interval to be searched for
 *        eigenvalues. See also the \p vestimate argument.
 * \param vestimate An upper bound for the number of eigenvalues in
 *        the (vl,vu] interval, if \p which is \c
 *        IGRAPH_LAPACK_DSYEV_INTERVAL. Memory is allocated only for
 *        the given number of eigenvalues (and eigenvectors), so this
 *        upper bound must be correct.
 * \param il The index of the smallest eigenvalue to return, if \p
 *        which is \c IGRAPH_LAPACK_DSYEV_SELECT.
 * \param iu The index of the largets eigenvalue to return, if \p
 *        which is \c IGRAPH_LAPACK_DSYEV_SELECT.
 * \param abstol The absolute error tolerance for the eigevalues. An
 *        approximate eigenvalue is accepted as converged when it is
 *        determined to lie in an interval [a,b] of width less than or
 *        equal to abstol + EPS * max(|a|,|b|), where EPS is the
 *        machine precision.
 * \param values An initialized vector, the eigenvalues are stored
 *        here, unless it is a null pointer. It will be resized as
 *        needed.
 * \param vectors An initialized matrix, the eigenvectors are stored
 *        in its columns, unless it is a null pointer. It will be
 *        resized as needed.
 * \param support An integer vector. If not a null pointer, then it
 *        will be resized to (2*max(1,M)) (M is a the total number of
 *        eigenvalues found). Then the support of the eigenvectors in
 *        \p vectors is stored here, i.e., the indices
 *        indicating the nonzero elements in \p vectors.
 *        The i-th eigenvector is nonzero only in elements
 *        support(2*i-1) through support(2*i).
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_lapack_dsyevr.c
 */

int igraph_lapack_dsyevr(const igraph_matrix_t *A,
                         igraph_lapack_dsyev_which_t which,
                         igraph_real_t vl, igraph_real_t vu, int vestimate,
                         int il, int iu, igraph_real_t abstol,
                         igraph_vector_t *values, igraph_matrix_t *vectors,
                         igraph_vector_int_t *support) {

    igraph_matrix_t Acopy;
    char jobz = vectors ? 'V' : 'N', range, uplo = 'U';
    int n = (int) igraph_matrix_nrow(A), lda = n, ldz = n;
    int m, info;
    igraph_vector_t *myvalues = values, vvalues;
    igraph_vector_int_t *mysupport = support, vsupport;
    igraph_vector_t work;
    igraph_vector_int_t iwork;
    int lwork = -1, liwork = -1;

    if (n != igraph_matrix_ncol(A)) {
        IGRAPH_ERROR("Cannot find eigenvalues/vectors.", IGRAPH_NONSQUARE);
    }
    if (which == IGRAPH_LAPACK_DSYEV_INTERVAL &&
        (vestimate < 1 || vestimate > n)) {
        IGRAPH_ERROR("Estimated (upper bound) number of eigenvalues must be "
                     "between 1 and n.", IGRAPH_EINVAL);
    }
    if (which == IGRAPH_LAPACK_DSYEV_SELECT && iu - il < 0) {
        IGRAPH_ERROR("Invalid 'il' and/or 'iu' values.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
    IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);

    IGRAPH_VECTOR_INIT_FINALLY(&work, 1);
    IGRAPH_CHECK(igraph_vector_int_init(&iwork, 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &iwork);

    if (!values) {
        IGRAPH_VECTOR_INIT_FINALLY(&vvalues, 0);
        myvalues = &vvalues;
    }
    if (!support) {
        IGRAPH_CHECK(igraph_vector_int_init(&vsupport, 0));
        IGRAPH_FINALLY(igraph_vector_int_destroy, &vsupport);
        mysupport = &vsupport;
    }

    IGRAPH_CHECK(igraph_vector_resize(myvalues, n));

    switch (which) {
    case IGRAPH_LAPACK_DSYEV_ALL:
        range = 'A';
        IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2 * n));
        if (vectors) {
            IGRAPH_CHECK(igraph_matrix_resize(vectors, n, n));
        }
        break;
    case IGRAPH_LAPACK_DSYEV_INTERVAL:
        range = 'V';
        IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2 * vestimate));
        if (vectors) {
            IGRAPH_CHECK(igraph_matrix_resize(vectors, n, vestimate));
        }
        break;
    case IGRAPH_LAPACK_DSYEV_SELECT:
        range = 'I';
        IGRAPH_CHECK(igraph_vector_int_resize(mysupport, 2 * (iu - il + 1)));
        if (vectors) {
            IGRAPH_CHECK(igraph_matrix_resize(vectors, n, iu - il + 1));
        }
        break;
    }

    igraphdsyevr_(&jobz, &range, &uplo, &n, &MATRIX(Acopy, 0, 0), &lda,
                  &vl, &vu, &il, &iu, &abstol, &m, VECTOR(*myvalues),
                  vectors ? &MATRIX(*vectors, 0, 0) : 0, &ldz, VECTOR(*mysupport),
                  VECTOR(work), &lwork, VECTOR(iwork), &liwork, &info);

    if (info != 0) {
        IGRAPH_ERROR("Invalid argument to dsyevr in workspace query.", IGRAPH_EINVAL);
    }

    lwork = (int) VECTOR(work)[0];
    liwork = VECTOR(iwork)[0];
    IGRAPH_CHECK(igraph_vector_resize(&work, lwork));
    IGRAPH_CHECK(igraph_vector_int_resize(&iwork, liwork));

    igraphdsyevr_(&jobz, &range, &uplo, &n, &MATRIX(Acopy, 0, 0), &lda,
                  &vl, &vu, &il, &iu, &abstol, &m, VECTOR(*myvalues),
                  vectors ? &MATRIX(*vectors, 0, 0) : 0, &ldz, VECTOR(*mysupport),
                  VECTOR(work), &lwork, VECTOR(iwork), &liwork, &info);

    if (info != 0) {
        IGRAPH_ERROR("Invalid argument to dsyevr in calculation.", IGRAPH_EINVAL);
    }

    if (values) {
        IGRAPH_CHECK(igraph_vector_resize(values, m));
    }
    if (vectors) {
        IGRAPH_CHECK(igraph_matrix_resize(vectors, n, m));
    }
    if (support) {
        IGRAPH_CHECK(igraph_vector_int_resize(support, m));
    }

    if (!support) {
        igraph_vector_int_destroy(&vsupport);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!values) {
        igraph_vector_destroy(&vvalues);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_int_destroy(&iwork);
    igraph_vector_destroy(&work);
    igraph_matrix_destroy(&Acopy);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_lapack_dgeev
 * Eigenvalues and optionally eigenvectors of a non-symmetric matrix
 *
 * This function calls LAPACK to compute, for an N-by-N real
 * nonsymmetric matrix A, the eigenvalues and, optionally, the left
 * and/or right eigenvectors.
 *
 * 
 * The right eigenvector v(j) of A satisfies
 *                    A * v(j) = lambda(j) * v(j)
 * where lambda(j) is its eigenvalue.
 * The left eigenvector u(j) of A satisfies
 *                u(j)**H * A = lambda(j) * u(j)**H
 * where u(j)**H denotes the conjugate transpose of u(j).
 *
 * 
 * The computed eigenvectors are normalized to have Euclidean norm
 * equal to 1 and largest component real.
 *
 * \param A matrix. On entry it contains the N-by-N input matrix.
 * \param valuesreal Pointer to an initialized vector, or a null
 *        pointer. If not a null pointer, then the real parts of the
 *        eigenvalues are stored here. The vector will be resized as
 *        needed.
 * \param valuesimag Pointer to an initialized vector, or a null
 *        pointer. If not a null pointer, then the imaginary parts of
 *        the eigenvalues are stored here. The vector will be resized
 *        as needed.
 * \param vectorsleft Pointer to an initialized matrix, or a null
 *        pointer. If not a null pointer, then the left eigenvectors
 *        are stored in the columns of the matrix. The matrix will be
 *        resized as needed.
 * \param vectorsright Pointer to an initialized matrix, or a null
 *        pointer. If not a null pointer, then the right eigenvectors
 *        are stored in the columns of the matrix. The matrix will be
 *        resized as needed.
 * \param info This argument is used for two purposes. As an input
 *        argument it gives whether an igraph error should be
 *        generated if the QR algorithm fails to compute all
 *        eigenvalues. If \p info is non-zero, then an error is
 *        generated, otherwise only a warning is given.
 *        On exit it contains the LAPACK error code.
 *        Zero means successful exit.
 *        A negative values means that some of the arguments had an
 *        illegal value, this always triggers an igraph error. An i
 *        positive  value means that the QR algorithm failed to
 *        compute all the eigenvalues, and no eigenvectors have been
 *        computed; element i+1:N of \p valuesreal and \p valuesimag
 *        contain eigenvalues which have converged. This case only
 *        generates an igraph error, if \p info was non-zero on entry.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_lapack_dgeev.c
 */

int igraph_lapack_dgeev(const igraph_matrix_t *A,
                        igraph_vector_t *valuesreal,
                        igraph_vector_t *valuesimag,
                        igraph_matrix_t *vectorsleft,
                        igraph_matrix_t *vectorsright,
                        int *info) {

    char jobvl = vectorsleft  ? 'V' : 'N';
    char jobvr = vectorsright ? 'V' : 'N';
    int n = (int) igraph_matrix_nrow(A);
    int lda = n, ldvl = n, ldvr = n, lwork = -1;
    igraph_vector_t work;
    igraph_vector_t *myreal = valuesreal, *myimag = valuesimag, vreal, vimag;
    igraph_matrix_t Acopy;
    int error = *info;

    if (igraph_matrix_ncol(A) != n) {
        IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev).", IGRAPH_NONSQUARE);
    }

    IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
    IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);

    IGRAPH_VECTOR_INIT_FINALLY(&work, 1);

    if (!valuesreal) {
        IGRAPH_VECTOR_INIT_FINALLY(&vreal, n);
        myreal = &vreal;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(myreal, n));
    }
    if (!valuesimag) {
        IGRAPH_VECTOR_INIT_FINALLY(&vimag, n);
        myimag = &vimag;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(myimag, n));
    }
    if (vectorsleft) {
        IGRAPH_CHECK(igraph_matrix_resize(vectorsleft, n, n));
    }
    if (vectorsright) {
        IGRAPH_CHECK(igraph_matrix_resize(vectorsright, n, n));
    }

    igraphdgeev_(&jobvl, &jobvr, &n, &MATRIX(Acopy, 0, 0), &lda,
                 VECTOR(*myreal), VECTOR(*myimag),
                 vectorsleft  ? &MATRIX(*vectorsleft, 0, 0) : 0, &ldvl,
                 vectorsright ? &MATRIX(*vectorsright, 0, 0) : 0, &ldvr,
                 VECTOR(work), &lwork, info);

    lwork = (int) VECTOR(work)[0];
    IGRAPH_CHECK(igraph_vector_resize(&work, lwork));

    igraphdgeev_(&jobvl, &jobvr, &n, &MATRIX(Acopy, 0, 0), &lda,
                 VECTOR(*myreal), VECTOR(*myimag),
                 vectorsleft  ? &MATRIX(*vectorsleft, 0, 0) : 0, &ldvl,
                 vectorsright ? &MATRIX(*vectorsright, 0, 0) : 0, &ldvr,
                 VECTOR(work), &lwork, info);

    if (*info < 0) {
        IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev).", IGRAPH_ELAPACK);
    } else if (*info > 0) {
        if (error) {
            IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev).", IGRAPH_ELAPACK);
        } else {
            IGRAPH_WARNING("Cannot calculate eigenvalues (dgeev).");
        }
    }

    if (!valuesimag) {
        igraph_vector_destroy(&vimag);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!valuesreal) {
        igraph_vector_destroy(&vreal);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&work);
    igraph_matrix_destroy(&Acopy);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_lapack_dgeevx
 * Eigenvalues/vectors of nonsymmetric matrices, expert mode
 *
 * This function calculates the eigenvalues and optionally the left
 * and/or right eigenvectors of a nonsymmetric N-by-N real matrix.
 *
 * 
 * Optionally also, it computes a balancing transformation to improve
 * the conditioning of the eigenvalues and eigenvectors (\p ilo, \p ihi,
 * \p scale, and \p abnrm), reciprocal condition numbers for the
 * eigenvalues (\p rconde), and reciprocal condition numbers for the
 * right eigenvectors (\p rcondv).
 *
 * 
 * The right eigenvector v(j) of A satisfies
 *                   A * v(j) = lambda(j) * v(j)
 * where lambda(j) is its eigenvalue.
 * The left eigenvector u(j) of A satisfies
 *               u(j)^H * A = lambda(j) * u(j)^H
 * where u(j)^H denotes the conjugate transpose of u(j).
 *
 * 
 * The computed eigenvectors are normalized to have Euclidean norm
 * equal to 1 and largest component real.
 *
 * 
 * Balancing a matrix means permuting the rows and columns to make it
 * more nearly upper triangular, and applying a diagonal similarity
 * transformation D * A * D^(-1), where D is a diagonal matrix, to
 * make its rows and columns closer in norm and the condition numbers
 * of its eigenvalues and eigenvectors smaller.  The computed
 * reciprocal condition numbers correspond to the balanced matrix.
 * Permuting rows and columns will not change the condition numbers
 * (in exact arithmetic) but diagonal scaling will.  For further
 * explanation of balancing, see section 4.10.2 of the LAPACK
 * Users' Guide.
 *
 * \param balance Scalar that indicated, whether the input matrix
 *   should be balanced. Possible values:
 *   \clist
 *     \cli IGRAPH_LAPACK_DGEEVX_BALANCE_NONE
 *          no not diagonally scale or permute.
 *     \cli IGRAPH_LAPACK_DGEEVX_BALANCE_PERM
 *          perform permutations to make the matrix more nearly upper
 *          triangular. Do not diagonally scale.
 *     \cli IGRAPH_LAPACK_DGEEVX_BALANCE_SCALE
 *          diagonally scale the matrix, i.e. replace A by
 *          D*A*D^(-1), where D is a diagonal matrix, chosen to make
 *          the rows and columns of A more equal in norm. Do not
 *          permute.
 *     \cli IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH
 *          both diagonally scale and permute A.
 *   \endclist
 * \param A The input matrix, must be square.
 * \param valuesreal An initialized vector, or a NULL pointer. If not
 *   a NULL pointer, then the real parts of the eigenvalues are stored
 *   here. The vector will be resized, as needed.
 * \param valuesimag An initialized vector, or a NULL pointer. If not
 *   a NULL pointer, then the imaginary parts of the eigenvalues are stored
 *   here. The vector will be resized, as needed.
 * \param vectorsleft An initialized matrix or a NULL pointer. If not
 *   a null pointer, then the left eigenvectors are stored here. The
 *   order corresponds to the eigenvalues and the eigenvectors are
 *   stored in a compressed form. If the j-th eigenvalue is real then
 *   column j contains the corresponding eigenvector. If the j-th and
 *   (j+1)-th eigenvalues form a complex conjugate pair, then the j-th
 *   and (j+1)-th columns contain their corresponding eigenvectors.
 * \param vectorsright An initialized matrix or a NULL pointer. If not
 *   a null pointer, then the right eigenvectors are stored here. The
 *   format is the same, as for the \p vectorsleft argument.
 * \param ilo
 * \param ihi \p ilo and \p ihi are integer values determined when A was
 *   balanced.  The balanced A(i,j) = 0 if I>J and
 *   J=1,...,ilo-1 or I=ihi+1,...,N.
 * \param scale Pointer to an initialized vector or a NULL pointer. If
 *   not a NULL pointer, then details of the permutations and scaling
 *   factors applied when balancing \p A, are stored here.
 *   If P(j) is the index of the row and column
 *   interchanged with row and column j, and D(j) is the scaling
 *   factor applied to row and column j, then
 *   \clist
 *      \cli scale(J) = P(J),    for J = 1,...,ilo-1
 *      \cli scale(J) = D(J),    for J = ilo,...,ihi
 *      \cli scale(J) = P(J)     for J = ihi+1,...,N.
 *   \endclist
 *   The order in which the interchanges are made is N to \p ihi+1,
 *   then 1 to \p ilo-1.
 * \param abnrm Pointer to a real variable, the one-norm of the
 *   balanced matrix is stored here. (The one-norm is the maximum of
 *   the sum of absolute values of elements in any column.)
 * \param rconde An initialized vector or a NULL pointer. If not a
 *   null pointer, then the reciprocal condition numbers of the
 *   eigenvalues are stored here.
 * \param rcondv An initialized vector or a NULL pointer. If not a
 *   null pointer, then the reciprocal condition numbers of the right
 *   eigenvectors are stored here.
 * \param info This argument is used for two purposes. As an input
 *        argument it gives whether an igraph error should be
 *        generated if the QR algorithm fails to compute all
 *        eigenvalues. If \p info is non-zero, then an error is
 *        generated, otherwise only a warning is given.
 *        On exit it contains the LAPACK error code.
 *        Zero means successful exit.
 *        A negative values means that some of the arguments had an
 *        illegal value, this always triggers an igraph error. An i
 *        positive  value means that the QR algorithm failed to
 *        compute all the eigenvalues, and no eigenvectors have been
 *        computed; element i+1:N of \p valuesreal and \p valuesimag
 *        contain eigenvalues which have converged. This case only
 *        generated an igraph error, if \p info was non-zero on entry.
 * \return Error code.
 *
 * Time complexity: TODO
 *
 * \example examples/simple/igraph_lapack_dgeevx.c
 */

int igraph_lapack_dgeevx(igraph_lapack_dgeevx_balance_t balance,
                         const igraph_matrix_t *A,
                         igraph_vector_t *valuesreal,
                         igraph_vector_t *valuesimag,
                         igraph_matrix_t *vectorsleft,
                         igraph_matrix_t *vectorsright,
                         int *ilo, int *ihi, igraph_vector_t *scale,
                         igraph_real_t *abnrm,
                         igraph_vector_t *rconde,
                         igraph_vector_t *rcondv,
                         int *info) {

    char balanc;
    char jobvl = vectorsleft  ? 'V' : 'N';
    char jobvr = vectorsright ? 'V' : 'N';
    char sense;
    int n = (int) igraph_matrix_nrow(A);
    int lda = n, ldvl = n, ldvr = n, lwork = -1;
    igraph_vector_t work;
    igraph_vector_int_t iwork;
    igraph_matrix_t Acopy;
    int error = *info;
    igraph_vector_t *myreal = valuesreal, *myimag = valuesimag, vreal, vimag;
    igraph_vector_t *myscale = scale, vscale;

    if (igraph_matrix_ncol(A) != n) {
        IGRAPH_ERROR("Cannot calculate eigenvalues (dgeevx).", IGRAPH_NONSQUARE);
    }

    switch (balance) {
    case IGRAPH_LAPACK_DGEEVX_BALANCE_NONE:
        balanc = 'N';
        break;
    case IGRAPH_LAPACK_DGEEVX_BALANCE_PERM:
        balanc = 'P';
        break;
    case IGRAPH_LAPACK_DGEEVX_BALANCE_SCALE:
        balanc = 'S';
        break;
    case IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH:
        balanc = 'B';
        break;
    default:
        IGRAPH_ERROR("Invalid 'balance' argument.", IGRAPH_EINVAL);
        break;
    }

    if (!rconde && !rcondv) {
        sense = 'N';
    } else if (rconde && !rcondv) {
        sense = 'E';
    } else if (!rconde && rcondv) {
        sense = 'V';
    } else {
        sense = 'B';
    }

    IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
    IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);

    IGRAPH_VECTOR_INIT_FINALLY(&work, 1);
    IGRAPH_CHECK(igraph_vector_int_init(&iwork, n));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &iwork);

    if (!valuesreal) {
        IGRAPH_VECTOR_INIT_FINALLY(&vreal, n);
        myreal = &vreal;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(myreal, n));
    }
    if (!valuesimag) {
        IGRAPH_VECTOR_INIT_FINALLY(&vimag, n);
        myimag = &vimag;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(myimag, n));
    }
    if (!scale) {
        IGRAPH_VECTOR_INIT_FINALLY(&vscale, n);
        myscale = &vscale;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(scale, n));
    }
    if (vectorsleft) {
        IGRAPH_CHECK(igraph_matrix_resize(vectorsleft, n, n));
    }
    if (vectorsright) {
        IGRAPH_CHECK(igraph_matrix_resize(vectorsright, n, n));
    }

    igraphdgeevx_(&balanc, &jobvl, &jobvr, &sense, &n, &MATRIX(Acopy, 0, 0),
                  &lda, VECTOR(*myreal), VECTOR(*myimag),
                  vectorsleft  ? &MATRIX(*vectorsleft, 0, 0) : 0, &ldvl,
                  vectorsright ? &MATRIX(*vectorsright, 0, 0) : 0, &ldvr,
                  ilo, ihi, VECTOR(*myscale), abnrm,
                  rconde ? VECTOR(*rconde) : 0,
                  rcondv ? VECTOR(*rcondv) : 0,
                  VECTOR(work), &lwork, VECTOR(iwork), info);

    lwork = (int) VECTOR(work)[0];
    IGRAPH_CHECK(igraph_vector_resize(&work, lwork));

    igraphdgeevx_(&balanc, &jobvl, &jobvr, &sense, &n, &MATRIX(Acopy, 0, 0),
                  &lda, VECTOR(*myreal), VECTOR(*myimag),
                  vectorsleft  ? &MATRIX(*vectorsleft, 0, 0) : 0, &ldvl,
                  vectorsright ? &MATRIX(*vectorsright, 0, 0) : 0, &ldvr,
                  ilo, ihi, VECTOR(*myscale), abnrm,
                  rconde ? VECTOR(*rconde) : 0,
                  rcondv ? VECTOR(*rcondv) : 0,
                  VECTOR(work), &lwork, VECTOR(iwork), info);

    if (*info < 0) {
        IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev).", IGRAPH_ELAPACK);
    } else if (*info > 0) {
        if (error) {
            IGRAPH_ERROR("Cannot calculate eigenvalues (dgeev).", IGRAPH_ELAPACK);
        } else {
            IGRAPH_WARNING("Cannot calculate eigenvalues (dgeev).");
        }
    }

    if (!scale) {
        igraph_vector_destroy(&vscale);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (!valuesimag) {
        igraph_vector_destroy(&vimag);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (!valuesreal) {
        igraph_vector_destroy(&vreal);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_int_destroy(&iwork);
    igraph_vector_destroy(&work);
    igraph_matrix_destroy(&Acopy);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

int igraph_lapack_dgehrd(const igraph_matrix_t *A,
                         int ilo, int ihi,
                         igraph_matrix_t *result) {

    int n = (int) igraph_matrix_nrow(A);
    int lda = n;
    int lwork = -1;
    igraph_vector_t work;
    igraph_real_t optwork;
    igraph_vector_t tau;
    igraph_matrix_t Acopy;
    int info = 0;
    int i;

    if (igraph_matrix_ncol(A) != n) {
        IGRAPH_ERROR("Hessenberg reduction failed.", IGRAPH_NONSQUARE);
    }

    if (ilo < 1 || ihi > n || ilo > ihi) {
        IGRAPH_ERROR("Invalid `ilo' and/or `ihi'.", IGRAPH_EINVAL);
    }

    if (n <= 1) {
        IGRAPH_CHECK(igraph_matrix_update(result, A));
        return 0;
    }

    IGRAPH_CHECK(igraph_matrix_copy(&Acopy, A));
    IGRAPH_FINALLY(igraph_matrix_destroy, &Acopy);
    IGRAPH_VECTOR_INIT_FINALLY(&tau, n - 1);

    igraphdgehrd_(&n, &ilo, &ihi, &MATRIX(Acopy, 0, 0), &lda, VECTOR(tau),
                  &optwork, &lwork, &info);

    if (info != 0) {
        IGRAPH_ERROR("Internal Hessenberg transformation error.",
                     IGRAPH_EINTERNAL);
    }

    lwork = (int) optwork;
    IGRAPH_VECTOR_INIT_FINALLY(&work, lwork);

    igraphdgehrd_(&n, &ilo, &ihi, &MATRIX(Acopy, 0, 0), &lda, VECTOR(tau),
                  VECTOR(work), &lwork, &info);

    if (info != 0) {
        IGRAPH_ERROR("Internal Hessenberg transformation error.",
                     IGRAPH_EINTERNAL);
    }

    igraph_vector_destroy(&work);
    igraph_vector_destroy(&tau);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_matrix_update(result, &Acopy));

    igraph_matrix_destroy(&Acopy);
    IGRAPH_FINALLY_CLEAN(1);

    for (i = 0; i < n - 2; i++) {
        int j;
        for (j = i + 2; j < n; j++) {
            MATRIX(*result, j, i) = 0.0;
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/linalg/lapack_internal.h0000644000175100001710000001542400000000000025215 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef LAPACK_INTERNAL_H
#define LAPACK_INTERNAL_H

/* Note: only files calling the LAPACK routines directly need to
   include this header.
*/

#include "igraph_types.h"
#include "config.h"

#ifndef INTERNAL_LAPACK
    #define igraphdgeevx_   dgeevx_
    #define igraphdgeev_    dgeev_
    #define igraphdgebak_   dgebak_
    #define igraphxerbla_   xerbla_
    #define igraphdgebal_   dgebal_
    #define igraphdisnan_   disnan_
    #define igraphdlaisnan_ dlaisnan_
    #define igraphdgehrd_   dgehrd_
    #define igraphdgehd2_   dgehd2_
    #define igraphdlarf_    dlarf_
    #define igraphiladlc_   iladlc_
    #define igraphiladlr_   iladlr_
    #define igraphdlarfg_   dlarfg_
    #define igraphdlapy2_   dlapy2_
    #define igraphdlahr2_   dlahr2_
    #define igraphdlacpy_   dlacpy_
    #define igraphdlarfb_   dlarfb_
    #define igraphilaenv_   ilaenv_
    #define igraphieeeck_   ieeeck_
    #define igraphiparmq_   iparmq_
    #define igraphdhseqr_   dhseqr_
    #define igraphdlahqr_   dlahqr_
    #define igraphdlabad_   dlabad_
    #define igraphdlanv2_   dlanv2_
    #define igraphdlaqr0_   dlaqr0_
    #define igraphdlaqr3_   dlaqr3_
    #define igraphdlaqr4_   dlaqr4_
    #define igraphdlaqr2_   dlaqr2_
    #define igraphdlaset_   dlaset_
    #define igraphdormhr_   dormhr_
    #define igraphdormqr_   dormqr_
    #define igraphdlarft_   dlarft_
    #define igraphdorm2r_   dorm2r_
    #define igraphdtrexc_   dtrexc_
    #define igraphdlaexc_   dlaexc_
    #define igraphdlange_   dlange_
    #define igraphdlassq_   dlassq_
    #define igraphdlarfx_   dlarfx_
    #define igraphdlartg_   dlartg_
    #define igraphdlasy2_   dlasy2_
    #define igraphdlaqr5_   dlaqr5_
    #define igraphdlaqr1_   dlaqr1_
    #define igraphdlascl_   dlascl_
    #define igraphdorghr_   dorghr_
    #define igraphdorgqr_   dorgqr_
    #define igraphdorg2r_   dorg2r_
    #define igraphdtrevc_   dtrevc_
    #define igraphdlaln2_   dlaln2_
    #define igraphdladiv_   dladiv_
    #define igraphdsyevr_   dsyevr_
    #define igraphdsyrk_    dsyrk_
    #define igraphdlansy_   dlansy_
    #define igraphdormtr_   dormtr_
    #define igraphdormql_   dormql_
    #define igraphdorm2l_   dorm2l_
    #define igraphdstebz_   dstebz_
    #define igraphdlaebz_   dlaebz_
    #define igraphdstein_   dstein_
    #define igraphdlagtf_   dlagtf_
    #define igraphdlagts_   dlagts_
    #define igraphdlarnv_   dlarnv_
    #define igraphdlaruv_   dlaruv_
    #define igraphdstemr_   dstemr_
    #define igraphdlae2_    dlae2_
    #define igraphdlaev2_   dlaev2_
    #define igraphdlanst_   dlanst_
    #define igraphdlarrc_   dlarrc_
    #define igraphdlarre_   dlarre_
    #define igraphdlarra_   dlarra_
    #define igraphdlarrb_   dlarrb_
    #define igraphdlaneg_   dlaneg_
    #define igraphdlarrd_   dlarrd_
    #define igraphdlarrk_   dlarrk_
    #define igraphdlasq2_   dlasq2_
    #define igraphdlasq3_   dlasq3_
    #define igraphdlasq4_   dlasq4_
    #define igraphdlasq5_   dlasq5_
    #define igraphdlasq6_   dlasq6_
    #define igraphdlasrt_   dlasrt_
    #define igraphdlarrj_   dlarrj_
    #define igraphdlarrr_   dlarrr_
    #define igraphdlarrv_   dlarrv_
    #define igraphdlar1v_   dlar1v_
    #define igraphdlarrf_   dlarrf_
    #define igraphdpotrf_   dpotrf_
    #define igraphdsterf_   dsterf_
    #define igraphdsytrd_   dsytrd_
    #define igraphdlatrd_   dlatrd_
    #define igraphdsytd2_   dsytd2_
    #define igraphdlanhs_   dlanhs_
    #define igraphdgeqr2_   dgeqr2_
    #define igraphdtrsen_   dtrsen_
    #define igraphdlacn2_   dlacn2_
    #define igraphdtrsyl_   dtrsyl_
    #define igraphdlasr_    dlasr_
    #define igraphdsteqr_   dsteqr_
    #define igraphdgesv_    dgesv_
    #define igraphdgetrf_   dgetrf_
    #define igraphdgetf2_   dgetf2_
    #define igraphdlaswp_   dlaswp_
    #define igraphdgetrs_   dgetrs_
    #define igraphlen_trim_ len_trim_
    #define igraph_dlamc1_  dlamc1_
    #define igraph_dlamc2_  dlamc2_
    #define igraph_dlamc3_  dlamc3_
    #define igraph_dlamc4_  dlamc4_
    #define igraph_dlamc5_  dlamc5_
#endif

int igraphdgetrf_(int *m, int *n, igraph_real_t *a, int *lda, int *ipiv,
                  int *info);
int igraphdgetrs_(char *trans, int *n, int *nrhs, igraph_real_t *a,
                  int *lda, int *ipiv, igraph_real_t *b, int *ldb,
                  int *info);
int igraphdgesv_(int *n, int *nrhs, igraph_real_t *a, int *lda,
                 int *ipiv, igraph_real_t *b, int *ldb, int *info);

igraph_real_t igraphdlapy2_(igraph_real_t *x, igraph_real_t *y);

int igraphdsyevr_(char *jobz, char *range, char *uplo, int *n,
                  igraph_real_t *a, int *lda, igraph_real_t *vl,
                  igraph_real_t *vu, int * il, int *iu,
                  igraph_real_t *abstol, int *m, igraph_real_t *w,
                  igraph_real_t *z, int *ldz, int *isuppz,
                  igraph_real_t *work, int *lwork, int *iwork,
                  int *liwork, int *info);

int igraphdgeev_(char *jobvl, char *jobvr, int *n, igraph_real_t *a,
                 int *lda, igraph_real_t *wr, igraph_real_t *wi,
                 igraph_real_t *vl, int *ldvl, igraph_real_t *vr, int *ldvr,
                 igraph_real_t *work, int *lwork, int *info);

int igraphdgeevx_(char *balanc, char *jobvl, char *jobvr, char *sense,
                  int *n, igraph_real_t *a, int *lda, igraph_real_t *wr,
                  igraph_real_t *wi, igraph_real_t *vl, int *ldvl,
                  igraph_real_t *vr, int *ldvr, int *ilo, int *ihi,
                  igraph_real_t *scale, igraph_real_t *abnrm,
                  igraph_real_t *rconde, igraph_real_t *rcondv,
                  igraph_real_t *work, int *lwork, int *iwork, int *info);

int igraphdgehrd_(int *n, int *ilo, int *ihi, igraph_real_t *A, int *lda,
                  igraph_real_t *tau, igraph_real_t *work, int *lwork,
                  int *info);

igraph_real_t igraphddot_(int *n, igraph_real_t *dx, int *incx,
                          igraph_real_t *dy, int *incy);

#endif
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.531141
igraph-0.9.9/vendor/source/igraph/src/math/0000755000175100001710000000000000000000000021372 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/math/bfgs.c0000644000175100001710000001644600000000000022472 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_nongraph.h"
#include "core/interruption.h"
#include "igraph_statusbar.h"

#include 

/* This is from GNU R's optim.c, slightly adapted to igraph */

#define stepredn    0.2
#define acctol      0.0001
#define reltest     10.0
#define FALSE           0
#define TRUE            1

/*  BFGS variable-metric method, based on Pascal code
in J.C. Nash, `Compact Numerical Methods for Computers', 2nd edition,
converted by p2c then re-crafted by B.D. Ripley */

int
igraph_bfgs(igraph_vector_t *b, igraph_real_t *Fmin,
            igraph_scalar_function_t fminfn, igraph_vector_function_t fmingr,
            int maxit, int trace,
            igraph_real_t abstol, igraph_real_t reltol, int nREPORT, void *ex,
            igraph_integer_t *fncount, igraph_integer_t *grcount) {
    int n = (int) igraph_vector_size(b);
    igraph_bool_t accpoint, enough;
    igraph_vector_t g, t, X, c;
    igraph_matrix_t B;        /* Lmatrix really */
    int   count, funcount, gradcount;
    igraph_real_t f, gradproj;
    int   i, j, ilast, iter = 0;
    igraph_real_t s, steplength;
    igraph_real_t D1, D2;

    if (maxit <= 0) {
        *Fmin = fminfn(b, 0, ex);
        *fncount = 1;
        *grcount = 0;
        return 0;
    }

    if (nREPORT <= 0) {
        IGRAPH_ERROR("REPORT must be > 0 (method = \"BFGS\")", IGRAPH_EINVAL);
    }
    IGRAPH_VECTOR_INIT_FINALLY(&g, n);
    IGRAPH_VECTOR_INIT_FINALLY(&t, n);
    IGRAPH_VECTOR_INIT_FINALLY(&X, n);
    IGRAPH_VECTOR_INIT_FINALLY(&c, n);
    IGRAPH_MATRIX_INIT_FINALLY(&B, n, n);
    f = fminfn(b, 0, ex);
    if (!IGRAPH_FINITE(f)) {
        IGRAPH_ERROR("initial value in 'BFGS' is not finite", IGRAPH_DIVERGED);
    }
    if (trace) {
        igraph_statusf("initial  value %f ", 0, f);
    }
    *Fmin = f;
    funcount = gradcount = 1;
    fmingr(b, 0, &g, ex);
    iter++;
    ilast = gradcount;

    do {

        IGRAPH_ALLOW_INTERRUPTION();

        if (ilast == gradcount) {
            for (i = 0; i < n; i++) {
                for (j = 0; j < i; j++) {
                    MATRIX(B, i, j) = 0.0;
                }
                MATRIX(B, i, i) = 1.0;
            }
        }
        for (i = 0; i < n; i++) {
            VECTOR(X)[i] = VECTOR(*b)[i];
            VECTOR(c)[i] = VECTOR(g)[i];
        }
        gradproj = 0.0;
        for (i = 0; i < n; i++) {
            s = 0.0;
            for (j = 0; j <= i; j++) {
                s -= MATRIX(B, i, j) * VECTOR(g)[j];
            }
            for (j = i + 1; j < n; j++) {
                s -= MATRIX(B, j, i) * VECTOR(g)[j];
            }
            VECTOR(t)[i] = s;
            gradproj += s * VECTOR(g)[i];
        }

        if (gradproj < 0.0) {   /* search direction is downhill */
            steplength = 1.0;
            accpoint = FALSE;
            do {
                count = 0;
                for (i = 0; i < n; i++) {
                    VECTOR(*b)[i] = VECTOR(X)[i] + steplength * VECTOR(t)[i];
                    if (reltest + VECTOR(X)[i] == reltest + VECTOR(*b)[i]) { /* no change */
                        count++;
                    }
                }
                if (count < n) {
                    f = fminfn(b, 0, ex);
                    funcount++;
                    accpoint = IGRAPH_FINITE(f) &&
                               (f <= *Fmin + gradproj * steplength * acctol);
                    if (!accpoint) {
                        steplength *= stepredn;
                    }
                }
            } while (!(count == n || accpoint));
            enough = (f > abstol) &&
                     fabs(f - *Fmin) > reltol * (fabs(*Fmin) + reltol);
            /* stop if value if small or if relative change is low */
            if (!enough) {
                count = n;
                *Fmin = f;
            }
            if (count < n) {/* making progress */
                *Fmin = f;
                fmingr(b, 0, &g, ex);
                gradcount++;
                iter++;
                D1 = 0.0;
                for (i = 0; i < n; i++) {
                    VECTOR(t)[i] = steplength * VECTOR(t)[i];
                    VECTOR(c)[i] = VECTOR(g)[i] - VECTOR(c)[i];
                    D1 += VECTOR(t)[i] * VECTOR(c)[i];
                }
                if (D1 > 0) {
                    D2 = 0.0;
                    for (i = 0; i < n; i++) {
                        s = 0.0;
                        for (j = 0; j <= i; j++) {
                            s += MATRIX(B, i, j) * VECTOR(c)[j];
                        }
                        for (j = i + 1; j < n; j++) {
                            s += MATRIX(B, j, i) * VECTOR(c)[j];
                        }
                        VECTOR(X)[i] = s;
                        D2 += s * VECTOR(c)[i];
                    }
                    D2 = 1.0 + D2 / D1;
                    for (i = 0; i < n; i++) {
                        for (j = 0; j <= i; j++)
                            MATRIX(B, i, j) += (D2 * VECTOR(t)[i] * VECTOR(t)[j]
                                                - VECTOR(X)[i] * VECTOR(t)[j]
                                                - VECTOR(t)[i] * VECTOR(X)[j]) / D1;
                    }
                } else {    /* D1 < 0 */
                    ilast = gradcount;
                }
            } else {  /* no progress */
                if (ilast < gradcount) {
                    count = 0;
                    ilast = gradcount;
                }
            }
        } else {        /* uphill search */
            count = 0;
            if (ilast == gradcount) {
                count = n;
            } else {
                ilast = gradcount;
            }
            /* Resets unless has just been reset */
        }
        if (trace && (iter % nREPORT == 0)) {
            igraph_statusf("iter%4d value %f", 0, iter, f);
        }
        if (iter >= maxit) {
            break;
        }
        if (gradcount - ilast > 2 * n) {
            ilast = gradcount;    /* periodic restart */
        }
    } while (count != n || ilast != gradcount);
    if (trace) {
        igraph_statusf("final  value %f ", 0, *Fmin);
        if (iter < maxit) {
            igraph_status("converged", 0);
        } else {
            igraph_statusf("stopped after %i iterations", 0, iter);
        }
    }
    *fncount = funcount;
    *grcount = gradcount;

    igraph_matrix_destroy(&B);
    igraph_vector_destroy(&c);
    igraph_vector_destroy(&X);
    igraph_vector_destroy(&t);
    igraph_vector_destroy(&g);
    IGRAPH_FINALLY_CLEAN(5);

    return (iter < maxit) ? 0 : IGRAPH_DIVERGED;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/math/complex.c0000644000175100001710000002740500000000000023215 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_complex.h"
#include "core/math.h"
#include 

/**
 * \example igraph_complex.c
 */

igraph_complex_t igraph_complex(igraph_real_t x, igraph_real_t y) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = x;
    IGRAPH_IMAG(res) = y;
    return res;
}

igraph_complex_t igraph_complex_polar(igraph_real_t r, igraph_real_t theta) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = r * cos(theta);
    IGRAPH_IMAG(res) = r * sin(theta);
    return res;
}

igraph_bool_t igraph_complex_eq_tol(igraph_complex_t z1,
                                    igraph_complex_t z2,
                                    igraph_real_t tol) {
    if (fabs(IGRAPH_REAL(z1) - IGRAPH_REAL(z2)) > tol ||
        fabs(IGRAPH_IMAG(z1) - IGRAPH_IMAG(z2)) > tol) {
        return 0;
    }
    return 1;
}

igraph_real_t igraph_complex_mod(igraph_complex_t z) {
    igraph_real_t x = IGRAPH_REAL(z);
    igraph_real_t y = IGRAPH_IMAG(z);
    return hypot(x, y);
}

igraph_real_t igraph_complex_arg(igraph_complex_t z) {
    igraph_real_t x = IGRAPH_REAL(z);
    igraph_real_t y = IGRAPH_IMAG(z);
    if (x == 0.0 && y == 0.0) {
        return 0.0;
    }
    return atan2(y, x);
}

igraph_complex_t igraph_complex_add(igraph_complex_t z1,
                                    igraph_complex_t z2) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z1) + IGRAPH_REAL(z2);
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z1) + IGRAPH_IMAG(z2);
    return res;
}

igraph_complex_t igraph_complex_sub(igraph_complex_t z1,
                                    igraph_complex_t z2) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z1) - IGRAPH_REAL(z2);
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z1) - IGRAPH_IMAG(z2);
    return res;
}

igraph_complex_t igraph_complex_mul(igraph_complex_t z1,
                                    igraph_complex_t z2) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z1) * IGRAPH_REAL(z2) -
                       IGRAPH_IMAG(z1) * IGRAPH_IMAG(z2);
    IGRAPH_IMAG(res) = IGRAPH_REAL(z1) * IGRAPH_IMAG(z2) +
                       IGRAPH_IMAG(z1) * IGRAPH_REAL(z2);
    return res;
}

igraph_complex_t igraph_complex_div(igraph_complex_t z1,
                                    igraph_complex_t z2) {
    igraph_complex_t res;
    igraph_real_t z1r = IGRAPH_REAL(z1), z1i = IGRAPH_IMAG(z1);
    igraph_real_t z2r = IGRAPH_REAL(z2), z2i = IGRAPH_IMAG(z2);
    igraph_real_t s = 1.0 / igraph_complex_abs(z2);
    igraph_real_t sz2r = s * z2r;
    igraph_real_t sz2i = s * z2i;
    IGRAPH_REAL(res) = (z1r * sz2r + z1i * sz2i) * s;
    IGRAPH_IMAG(res) = (z1i * sz2r - z1r * sz2i) * s;
    return res;
}

igraph_complex_t igraph_complex_add_real(igraph_complex_t z,
        igraph_real_t x) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z) + x;
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z);
    return res;
}

igraph_complex_t igraph_complex_add_imag(igraph_complex_t z,
        igraph_real_t y) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z);
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z) + y;
    return res;
}

igraph_complex_t igraph_complex_sub_real(igraph_complex_t z,
        igraph_real_t x) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z) - x;
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z);
    return res;
}

igraph_complex_t igraph_complex_sub_imag(igraph_complex_t z,
        igraph_real_t y) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z);
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z) - y;
    return res;
}

igraph_complex_t igraph_complex_mul_real(igraph_complex_t z,
        igraph_real_t x) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z) * x;
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z) * x;
    return res;
}

igraph_complex_t igraph_complex_mul_imag(igraph_complex_t z,
        igraph_real_t y) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = - IGRAPH_IMAG(z) * y;
    IGRAPH_IMAG(res) =   IGRAPH_REAL(z) * y;
    return res;
}

igraph_complex_t igraph_complex_div_real(igraph_complex_t z,
        igraph_real_t x) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = IGRAPH_REAL(z) / x;
    IGRAPH_IMAG(res) = IGRAPH_IMAG(z) / x;
    return res;
}

igraph_complex_t igraph_complex_div_imag(igraph_complex_t z,
        igraph_real_t y) {
    igraph_complex_t res;
    IGRAPH_REAL(res) =   IGRAPH_IMAG(z) / y;
    IGRAPH_IMAG(res) = - IGRAPH_REAL(z) / y;
    return res;
}

igraph_complex_t igraph_complex_conj(igraph_complex_t z) {
    igraph_complex_t res;
    IGRAPH_REAL(res) =   IGRAPH_REAL(z);
    IGRAPH_IMAG(res) = - IGRAPH_IMAG(z);
    return res;
}

igraph_complex_t igraph_complex_neg(igraph_complex_t z) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = - IGRAPH_REAL(z);
    IGRAPH_IMAG(res) = - IGRAPH_IMAG(z);
    return res;
}

igraph_complex_t igraph_complex_inv(igraph_complex_t z) {
    igraph_complex_t res;
    igraph_real_t s = 1.0 / igraph_complex_abs(z);
    IGRAPH_REAL(res) =   (IGRAPH_REAL(z) * s) * s;
    IGRAPH_IMAG(res) = - (IGRAPH_IMAG(z) * s) * s;
    return res;
}

igraph_real_t igraph_complex_abs(igraph_complex_t z) {
    return hypot(IGRAPH_REAL(z), IGRAPH_IMAG(z));
}

igraph_real_t igraph_complex_logabs(igraph_complex_t z) {
    igraph_real_t xabs = fabs(IGRAPH_REAL(z));
    igraph_real_t yabs = fabs(IGRAPH_IMAG(z));
    igraph_real_t max, u;
    if (xabs >= yabs) {
        max = xabs;
        u = yabs / xabs;
    } else {
        max = yabs;
        u = xabs / yabs;
    }
    return log (max) + 0.5 * log1p (u * u);
}

igraph_complex_t igraph_complex_sqrt(igraph_complex_t z) {
    igraph_complex_t res;

    if (IGRAPH_REAL(z) == 0.0 && IGRAPH_IMAG(z) == 0.0) {
        IGRAPH_REAL(res) = IGRAPH_IMAG(res) = 0.0;
    } else {
        igraph_real_t x = fabs (IGRAPH_REAL(z));
        igraph_real_t y = fabs (IGRAPH_IMAG(z));
        igraph_real_t w;
        if (x >= y)  {
            igraph_real_t t = y / x;
            w = sqrt (x) * sqrt (0.5 * (1.0 + sqrt (1.0 + t * t)));
        } else {
            igraph_real_t t = x / y;
            w = sqrt (y) * sqrt (0.5 * (t + sqrt (1.0 + t * t)));
        }

        if (IGRAPH_REAL(z) >= 0.0) {
            igraph_real_t ai = IGRAPH_IMAG(z);
            IGRAPH_REAL(res) = w;
            IGRAPH_IMAG(res) = ai / (2.0 * w);
        } else {
            igraph_real_t ai = IGRAPH_IMAG(z);
            igraph_real_t vi = (ai >= 0) ? w : -w;
            IGRAPH_REAL(res) = ai / (2.0 * vi);
            IGRAPH_IMAG(res) = vi;
        }
    }

    return res;
}

igraph_complex_t igraph_complex_sqrt_real(igraph_real_t x) {
    igraph_complex_t res;
    if (x >= 0) {
        IGRAPH_REAL(res) = sqrt(x);
        IGRAPH_IMAG(res) = 0.0;
    } else {
        IGRAPH_REAL(res) = 0.0;
        IGRAPH_IMAG(res) = sqrt(-x);
    }
    return res;
}

igraph_complex_t igraph_complex_exp(igraph_complex_t z) {
    igraph_real_t rho   = exp(IGRAPH_REAL(z));
    igraph_real_t theta = IGRAPH_IMAG(z);
    igraph_complex_t res;
    IGRAPH_REAL(res) = rho * cos(theta);
    IGRAPH_IMAG(res) = rho * sin(theta);
    return res;
}

igraph_complex_t igraph_complex_pow(igraph_complex_t z1,
                                    igraph_complex_t z2) {
    igraph_complex_t res;

    if (IGRAPH_REAL(z1) == 0 && IGRAPH_IMAG(z1) == 0.0) {
        if (IGRAPH_REAL(z2) == 0 && IGRAPH_IMAG(z2) == 0.0) {
            IGRAPH_REAL(res) = 1.0;
            IGRAPH_IMAG(res) = 0.0;
        } else {
            IGRAPH_REAL(res) = IGRAPH_IMAG(res) = 0.0;
        }
    } else if (IGRAPH_REAL(z2) == 1.0 && IGRAPH_IMAG(z2) == 0.0) {
        IGRAPH_REAL(res) = IGRAPH_REAL(z1);
        IGRAPH_IMAG(res) = IGRAPH_IMAG(z1);
    } else if (IGRAPH_REAL(z2) == -1.0 && IGRAPH_IMAG(z2) == 0.0) {
        res = igraph_complex_inv(z1);
    } else {
        igraph_real_t logr = igraph_complex_logabs (z1);
        igraph_real_t theta = igraph_complex_arg (z1);
        igraph_real_t z2r = IGRAPH_REAL(z2), z2i = IGRAPH_IMAG(z2);
        igraph_real_t rho = exp (logr * z2r - z2i * theta);
        igraph_real_t beta = theta * z2r + z2i * logr;
        IGRAPH_REAL(res) = rho * cos(beta);
        IGRAPH_IMAG(res) = rho * sin(beta);
    }

    return res;
}

igraph_complex_t igraph_complex_pow_real(igraph_complex_t z,
        igraph_real_t x) {
    igraph_complex_t res;
    if (IGRAPH_REAL(z) == 0.0 && IGRAPH_IMAG(z) == 0.0) {
        if (x == 0) {
            IGRAPH_REAL(res) = 1.0;
            IGRAPH_IMAG(res) = 0.0;
        } else {
            IGRAPH_REAL(res) = IGRAPH_IMAG(res) = 0.0;
        }
    } else {
        igraph_real_t logr = igraph_complex_logabs(z);
        igraph_real_t theta = igraph_complex_arg(z);
        igraph_real_t rho = exp (logr * x);
        igraph_real_t beta = theta * x;
        IGRAPH_REAL(res) = rho * cos(beta);
        IGRAPH_IMAG(res) = rho * sin(beta);
    }
    return res;
}

igraph_complex_t igraph_complex_log(igraph_complex_t z) {
    igraph_complex_t res;
    IGRAPH_REAL(res) = igraph_complex_logabs(z);
    IGRAPH_IMAG(res) = igraph_complex_arg(z);
    return res;
}

igraph_complex_t igraph_complex_log10(igraph_complex_t z) {
    return igraph_complex_mul_real(igraph_complex_log(z), 1 / log(10.0));
}

igraph_complex_t igraph_complex_log_b(igraph_complex_t z,
                                      igraph_complex_t b) {
    return igraph_complex_div (igraph_complex_log(z), igraph_complex_log(b));
}

igraph_complex_t igraph_complex_sin(igraph_complex_t z) {
    igraph_real_t zr = IGRAPH_REAL(z);
    igraph_real_t zi = IGRAPH_IMAG(z);
    igraph_complex_t res;
    if (zi == 0.0) {
        IGRAPH_REAL(res) = sin(zr);
        IGRAPH_IMAG(res) = 0.0;
    } else {
        IGRAPH_REAL(res) = sin(zr) * cosh(zi);
        IGRAPH_IMAG(res) = cos(zr) * sinh(zi);
    }
    return res;
}

igraph_complex_t igraph_complex_cos(igraph_complex_t z) {
    igraph_real_t zr = IGRAPH_REAL(z);
    igraph_real_t zi = IGRAPH_IMAG(z);
    igraph_complex_t res;
    if (zi == 0.0) {
        IGRAPH_REAL(res) = cos(zr);
        IGRAPH_IMAG(res) = 0.0;
    } else {
        IGRAPH_REAL(res) = cos(zr) * cosh(zi);
        IGRAPH_IMAG(res) = sin(zr) * sinh(-zi);
    }
    return res;
}

igraph_complex_t igraph_complex_tan(igraph_complex_t z) {
    igraph_real_t zr = IGRAPH_REAL(z);
    igraph_real_t zi = IGRAPH_IMAG(z);
    igraph_complex_t res;
    if (fabs (zi) < 1) {
        igraph_real_t D = pow (cos (zr), 2.0) + pow (sinh (zi), 2.0);
        IGRAPH_REAL(res) = 0.5 * sin (2 * zr) / D;
        IGRAPH_IMAG(res) = 0.5 * sinh (2 * zi) / D;
    } else {
        igraph_real_t u = exp (-zi);
        igraph_real_t C = 2 * u / (1 - pow (u, 2.0));
        igraph_real_t D = 1 + pow (cos (zr), 2.0) * pow (C, 2.0);
        igraph_real_t S = pow (C, 2.0);
        igraph_real_t T = 1.0 / tanh (zi);
        IGRAPH_REAL(res) = 0.5 * sin (2 * zr) * S / D;
        IGRAPH_IMAG(res) = T / D;
    }
    return res;
}

igraph_complex_t igraph_complex_sec(igraph_complex_t z) {
    return igraph_complex_inv(igraph_complex_cos(z));
}

igraph_complex_t igraph_complex_csc(igraph_complex_t z) {
    return igraph_complex_inv(igraph_complex_sin(z));
}

igraph_complex_t igraph_complex_cot(igraph_complex_t z) {
    return igraph_complex_inv(igraph_complex_tan(z));
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/math/utils.c0000644000175100001710000002417300000000000022705 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_types.h"

#include "core/math.h"

#include "config.h"

#include 
#include 

#ifdef _MSC_VER
#  ifndef isinf
#    define isinf(x) (!_finite(x) && !_isnan(x))
#  endif
#endif

int igraph_finite(double x) {
#if HAVE_ISFINITE
    return isfinite(x);
#elif HAVE_FINITE
    return finite(x);
#else
    return (!isnan(x) & (x != IGRAPH_POSINFINITY) & (x != IGRAPH_NEGINFINITY));
#endif
}

double igraph_log2(const double a) {
    return log(a) / log(2.0);
}

int igraph_chebyshev_init(const double *dos, int nos, double eta) {
    int i, ii;
    double err;

    if (nos < 1) {
        return 0;
    }

    err = 0.0;
    i = 0;          /* just to avoid compiler warnings */
    for (ii = 1; ii <= nos; ii++) {
        i = nos - ii;
        err += fabs(dos[i]);
        if (err > eta) {
            return i;
        }
    }
    return i;
}

double igraph_chebyshev_eval(double x, const double *a, const int n) {
    double b0, b1, b2, twox;
    int i;

    if (n < 1 || n > 1000) {
        IGRAPH_WARNING("chebyshev_eval: argument out of domain");
        return IGRAPH_NAN;
    }

    if (x < -1.1 || x > 1.1) {
        IGRAPH_WARNING("chebyshev_eval: argument out of domain");
        return IGRAPH_NAN;
    }

    twox = x * 2;
    b2 = b1 = 0;
    b0 = 0;
    for (i = 1; i <= n; i++) {
        b2 = b1;
        b1 = b0;
        b0 = twox * b1 - b2 + a[n - i];
    }
    return (b0 - b2) * 0.5;
}

double igraph_log1p(double x) {
    /* series for log1p on the interval -.375 to .375
     *                   with weighted error   6.35e-32
     *                    log weighted error  31.20
     *              significant figures required  30.93
     *               decimal places required  32.01
     */
    static const double alnrcs[43] = {
        +.10378693562743769800686267719098e+1,
            -.13364301504908918098766041553133e+0,
            +.19408249135520563357926199374750e-1,
            -.30107551127535777690376537776592e-2,
            +.48694614797154850090456366509137e-3,
            -.81054881893175356066809943008622e-4,
            +.13778847799559524782938251496059e-4,
            -.23802210894358970251369992914935e-5,
            +.41640416213865183476391859901989e-6,
            -.73595828378075994984266837031998e-7,
            +.13117611876241674949152294345011e-7,
            -.23546709317742425136696092330175e-8,
            +.42522773276034997775638052962567e-9,
            -.77190894134840796826108107493300e-10,
            +.14075746481359069909215356472191e-10,
            -.25769072058024680627537078627584e-11,
            +.47342406666294421849154395005938e-12,
            -.87249012674742641745301263292675e-13,
            +.16124614902740551465739833119115e-13,
            -.29875652015665773006710792416815e-14,
            +.55480701209082887983041321697279e-15,
            -.10324619158271569595141333961932e-15,
            +.19250239203049851177878503244868e-16,
            -.35955073465265150011189707844266e-17,
            +.67264542537876857892194574226773e-18,
            -.12602624168735219252082425637546e-18,
            +.23644884408606210044916158955519e-19,
            -.44419377050807936898878389179733e-20,
            +.83546594464034259016241293994666e-21,
            -.15731559416479562574899253521066e-21,
            +.29653128740247422686154369706666e-22,
            -.55949583481815947292156013226666e-23,
            +.10566354268835681048187284138666e-23,
            -.19972483680670204548314999466666e-24,
            +.37782977818839361421049855999999e-25,
            -.71531586889081740345038165333333e-26,
            +.13552488463674213646502024533333e-26,
            -.25694673048487567430079829333333e-27,
            +.48747756066216949076459519999999e-28,
            -.92542112530849715321132373333333e-29,
            +.17578597841760239233269760000000e-29,
            -.33410026677731010351377066666666e-30,
            +.63533936180236187354180266666666e-31,
        };

    static IGRAPH_THREAD_LOCAL int nlnrel = 0;
    static IGRAPH_THREAD_LOCAL double xmin = 0.0;

    if (xmin == 0.0) {
        xmin = -1 + sqrt(DBL_EPSILON);    /*was sqrt(d1mach(4)); */
    }
    if (nlnrel == 0) { /* initialize chebychev coefficients */
        nlnrel = igraph_chebyshev_init(alnrcs, 43, DBL_EPSILON / 20);    /*was .1*d1mach(3)*/
    }

    if (x == 0.) {
        return 0.;    /* speed */
    }
    if (x == -1) {
        return (IGRAPH_NEGINFINITY);
    }
    if (x  < -1) {
        return (IGRAPH_NAN);
    }

    if (fabs(x) <= .375) {
        /* Improve on speed (only);
        again give result accurate to IEEE double precision: */
        if (fabs(x) < .5 * DBL_EPSILON) {
            return x;
        }

        if ( (0 < x && x < 1e-8) || (-1e-9 < x && x < 0)) {
            return x * (1 - .5 * x);
        }
        /* else */
        return x * (1 - x * igraph_chebyshev_eval(x / .375, alnrcs, nlnrel));
    }
    /* else */
    /*     if (x < xmin) { */
    /*  /\* answer less than half precision because x too near -1 *\/ */
    /*         ML_ERROR(ME_PRECISION, "log1p"); */
    /*     } */
    return log(1 + x);
}

double igraph_fmin(double a, double b) {
    if (b < a) {
        return b;
    } else {
        return a;
    }
}

double igraph_i_round(double X) {

    /* NaN */
    if (X != X) {
        return X;
    }

    if (X < 0.0) {
        return floor(X);
    }

    return ceil(X);
}

#ifdef _MSC_VER
/**
 * Internal function, replacement for snprintf
 * Used only in case of the Microsoft Visual C compiler which does not
 * provide a proper sprintf implementation.
 *
 * This implementation differs from the standard in the value returned
 * when the number of characters needed by the output, excluding the
 * terminating '\0' is larger than count
 */
int igraph_i_snprintf(char *buffer, size_t count, const char *format, ...) {
    int n;
    va_list args;
    if (count > 0) {
        va_start(args, format);
        n = _vsnprintf(buffer, count, format, args);
        buffer[count - 1] = 0;
        va_end(args);
    } else {
        n = 0;
    }
    return n;
}

#endif

int igraph_is_nan(double x) {
    return isnan(x);
}

int igraph_is_inf(double x) {
    return isinf(x) != 0;
}

int igraph_is_posinf(double x) {
    return isinf(x) && x > 0;
}

int igraph_is_neginf(double x) {
    return isinf(x) && x < 0;
}

/**
 * \function igraph_almost_equals
 * Compare two double-precision floats with a tolerance
 *
 * Determines whether two double-precision floats are "almost equal"
 * to each other with a given level of tolerance on the relative error.
 *
 * \param  a  the first float
 * \param  b  the second float
 * \param  eps  the level of tolerance on the relative error. The relative
 *         error is defined as \c "abs(a-b) / (abs(a) + abs(b))". The
 *         two numbers are considered equal if this is less than \c eps.
 *
 * \return nonzero if the two floats are nearly equal to each other within
 *         the given level of tolerance, zero otherwise
 */
int igraph_almost_equals(double a, double b, double eps) {
    return igraph_cmp_epsilon(a, b, eps) == 0 ? 1 : 0;
}

/* Use value-safe floating point math for igraph_cmp_epsilon() with
 * the Intel compiler.
 *
 * The Intel compiler rewrites arithmetic expressions for faster
 * evaluation by default. In the below function, it will evaluate
 * (eps * fabs(a) + eps * fabs(b)) as eps*(fabs(a) + fabs(b)).
 * However, this code path is taken precisely when fabs(a) + fabs(b)
 * overflows, thus this rearrangement of the expression causes
 * the function to return incorrect results, and some test failures.
 * To avoid this, we switch the Intel compiler to "precise" mode.
 */
#ifdef __INTEL_COMPILER
#pragma float_control(push)
#pragma float_control (precise, on)
#endif

/**
 * \function igraph_cmp_epsilon
 * Compare two double-precision floats with a tolerance
 *
 * Determines whether two double-precision floats are "almost equal"
 * to each other with a given level of tolerance on the relative error.
 *
 * \param  a  the first float
 * \param  b  the second float
 * \param  eps  the level of tolerance on the relative error. The relative
 *         error is defined as \c "abs(a-b) / (abs(a) + abs(b))". The
 *         two numbers are considered equal if this is less than \c eps.
 *
 * \return zero if the two floats are nearly equal to each other within
 *         the given level of tolerance, positive number if the first float is
 *         larger, negative number if the second float is larger
 */
int igraph_cmp_epsilon(double a, double b, double eps) {
    double diff;
    double abs_diff;
    double sum;

    if (a == b) {
        /* shortcut, handles infinities */
        return 0;
    }

    diff = a - b;
    abs_diff = fabs(diff);
    sum = fabs(a) + fabs(b);

    if (a == 0 || b == 0 || sum < DBL_MIN) {
        /* a or b is zero or both are extremely close to it; relative
         * error is less meaningful here so just compare it with
         * epsilon */
        return abs_diff < (eps * DBL_MIN) ? 0 : (diff < 0 ? -1 : 1);
    } else if (!isfinite(sum)) {
        /* addition overflow, so presumably |a| and |b| are both large; use a
         * different formulation */
        return (abs_diff < (eps * fabs(a) + eps * fabs(b))) ? 0 : (diff < 0 ? -1 : 1);
    } else {
        return (abs_diff / sum < eps) ? 0 : (diff < 0 ? -1 : 1);
    }
}

#ifdef __INTEL_COMPILER
#pragma float_control(pop)
#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5351412
igraph-0.9.9/vendor/source/igraph/src/misc/0000755000175100001710000000000000000000000021374 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/bipartite.c0000644000175100001710000012150400000000000023526 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_bipartite.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_random.h"
#include "igraph_nongraph.h"

#include "graph/attributes.h"

/**
 * \section about_bipartite Bipartite networks in igraph
 *
 * 
 * A bipartite network contains two kinds of vertices and connections
 * are only possible between two vertices of different kinds. There are
 * many natural examples, e.g. movies and actors as vertices and a
 * movie is connected to all participating actors, etc.
 *
 * 
 * igraph does not have direct support for bipartite networks, at
 * least not at the C language level. In other words the igraph_t
 * structure does not contain information about the vertex types.
 * The C functions for bipartite networks usually have an additional
 * input argument to graph, called \c types, a boolean vector giving
 * the vertex types.
 *
 * 
 * Most functions creating bipartite networks are able to create this
 * extra vector, you just need to supply an initialized boolean vector
 * to them.
 */

/**
 * \function igraph_bipartite_projection_size
 * \brief Calculate the number of vertices and edges in the bipartite projections.
 *
 * This function calculates the number of vertices and edges in the
 * two projections of a bipartite network. This is useful if you have
 * a big bipartite network and you want to estimate the amount of
 * memory you would need to calculate the projections themselves.
 *
 * \param graph The input graph.
 * \param types Boolean vector giving the vertex types of the graph.
 * \param vcount1 Pointer to an \c igraph_integer_t, the number of
 *     vertices in the first projection is stored here.
 * \param ecount1 Pointer to an \c igraph_integer_t, the number of
 *     edges in the first projection is stored here.
 * \param vcount2 Pointer to an \c igraph_integer_t, the number of
 *     vertices in the second projection is stored here.
 * \param ecount2 Pointer to an \c igraph_integer_t, the number of
 *     edges in the second projection is stored here.
 * \return Error code.
 *
 * \sa \ref igraph_bipartite_projection() to calculate the actual
 * projection.
 *
 * Time complexity: O(|V|*d^2+|E|), |V| is the number of vertices, |E|
 * is the number of edges, d is the average (total) degree of the
 * graphs.
 *
 * \example examples/simple/igraph_bipartite_projection.c
 */

int igraph_bipartite_projection_size(const igraph_t *graph,
                                     const igraph_vector_bool_t *types,
                                     igraph_integer_t *vcount1,
                                     igraph_integer_t *ecount1,
                                     igraph_integer_t *vcount2,
                                     igraph_integer_t *ecount2) {

    long int no_of_nodes = igraph_vcount(graph);
    long int vc1 = 0, ec1 = 0, vc2 = 0, ec2 = 0;
    igraph_adjlist_t adjlist;
    igraph_vector_long_t added;
    long int i;

    IGRAPH_CHECK(igraph_vector_long_init(&added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &added);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_int_t *neis1;
        long int neilen1, j;
        long int *ecptr;
        if (VECTOR(*types)[i]) {
            vc2++;
            ecptr = &ec2;
        } else {
            vc1++;
            ecptr = &ec1;
        }
        neis1 = igraph_adjlist_get(&adjlist, i);
        neilen1 = igraph_vector_int_size(neis1);
        for (j = 0; j < neilen1; j++) {
            long int k, neilen2, nei = (long int) VECTOR(*neis1)[j];
            igraph_vector_int_t *neis2 = igraph_adjlist_get(&adjlist, nei);
            if (IGRAPH_UNLIKELY(VECTOR(*types)[i] == VECTOR(*types)[nei])) {
                IGRAPH_ERROR("Non-bipartite edge found in bipartite projection",
                             IGRAPH_EINVAL);
            }
            neilen2 = igraph_vector_int_size(neis2);
            for (k = 0; k < neilen2; k++) {
                long int nei2 = (long int) VECTOR(*neis2)[k];
                if (nei2 <= i) {
                    continue;
                }
                if (VECTOR(added)[nei2] == i + 1) {
                    continue;
                }
                VECTOR(added)[nei2] = i + 1;
                (*ecptr)++;
            }
        }
    }

    *vcount1 = (igraph_integer_t) vc1;
    *ecount1 = (igraph_integer_t) ec1;
    *vcount2 = (igraph_integer_t) vc2;
    *ecount2 = (igraph_integer_t) ec2;

    igraph_adjlist_destroy(&adjlist);
    igraph_vector_long_destroy(&added);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_bipartite_projection(const igraph_t *graph,
                                         const igraph_vector_bool_t *types,
                                         igraph_t *proj,
                                         int which,
                                         igraph_vector_t *multiplicity) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i, j, k;
    igraph_integer_t remaining_nodes = 0;
    igraph_vector_t vertex_perm, vertex_index;
    igraph_vector_t edges;
    igraph_adjlist_t adjlist;
    igraph_vector_int_t *neis1, *neis2;
    long int neilen1, neilen2;
    igraph_vector_long_t added;
    igraph_vector_t mult;

    if (which < 0) {
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&vertex_perm, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&vertex_perm, no_of_nodes));
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vertex_index, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_long_init(&added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &added);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    /* we won't need the 'mult' vector if 'multiplicity' is NULL, but MSVC will
     * throw warnings in the compiler output if we initialize it conditionally */
    IGRAPH_VECTOR_INIT_FINALLY(&mult, multiplicity ? no_of_nodes : 1);
    if (multiplicity) {
        igraph_vector_clear(multiplicity);
    }

    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i] == which) {
            VECTOR(vertex_index)[i] = ++remaining_nodes;
            igraph_vector_push_back(&vertex_perm, i);
        }
    }

    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i] == which) {
            long int new_i = (long int) VECTOR(vertex_index)[i] - 1;
            long int iedges = 0;
            neis1 = igraph_adjlist_get(&adjlist, i);
            neilen1 = igraph_vector_int_size(neis1);
            for (j = 0; j < neilen1; j++) {
                long int nei = (long int) VECTOR(*neis1)[j];
                if (IGRAPH_UNLIKELY(VECTOR(*types)[i] == VECTOR(*types)[nei])) {
                    IGRAPH_ERROR("Non-bipartite edge found in bipartite projection",
                                 IGRAPH_EINVAL);
                }
                neis2 = igraph_adjlist_get(&adjlist, nei);
                neilen2 = igraph_vector_int_size(neis2);
                for (k = 0; k < neilen2; k++) {
                    long int nei2 = (long int) VECTOR(*neis2)[k], new_nei2;
                    if (nei2 <= i) {
                        continue;
                    }
                    if (VECTOR(added)[nei2] == i + 1) {
                        if (multiplicity) {
                            VECTOR(mult)[nei2] += 1;
                        }
                        continue;
                    }
                    VECTOR(added)[nei2] = i + 1;
                    if (multiplicity) {
                        VECTOR(mult)[nei2] = 1;
                    }
                    iedges++;

                    IGRAPH_CHECK(igraph_vector_push_back(&edges, new_i));
                    if (multiplicity) {
                        /* If we need the multiplicity as well, then we put in the
                           old vertex ids here and rewrite it later */
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, nei2));
                    } else {
                        new_nei2 = (long int) VECTOR(vertex_index)[nei2] - 1;
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, new_nei2));
                    }
                }
            }
            if (multiplicity) {
                /* OK, we need to go through all the edges added for vertex new_i
                   and check their multiplicity */
                long int now = igraph_vector_size(&edges);
                long int from = now - iedges * 2;
                for (j = from; j < now; j += 2) {
                    long int nei2 = (long int) VECTOR(edges)[j + 1];
                    long int new_nei2 = (long int) VECTOR(vertex_index)[nei2] - 1;
                    long int m = (long int) VECTOR(mult)[nei2];
                    VECTOR(edges)[j + 1] = new_nei2;
                    IGRAPH_CHECK(igraph_vector_push_back(multiplicity, m));
                }
            }
        } /* if VECTOR(*type)[i] == which */
    }

    igraph_vector_destroy(&mult);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_long_destroy(&added);
    igraph_vector_destroy(&vertex_index);
    IGRAPH_FINALLY_CLEAN(4);

    IGRAPH_CHECK(igraph_create(proj, &edges, remaining_nodes,
                               /*directed=*/ 0));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, proj);

    IGRAPH_I_ATTRIBUTE_DESTROY(proj);
    IGRAPH_I_ATTRIBUTE_COPY(proj, graph, 1, 0, 0);
    IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, proj, &vertex_perm));
    igraph_vector_destroy(&vertex_perm);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_bipartite_projection
 * \brief Create one or both projections of a bipartite (two-mode) network.
 *
 * Creates one or both projections of a bipartite graph.
 *
 * \param graph The bipartite input graph. Directedness of the edges
 *   is ignored.
 * \param types Boolean vector giving the vertex types of the graph.
 * \param proj1 Pointer to an uninitialized graph object, the first
 *   projection will be created here. It a null pointer, then it is
 *   ignored, see also the \p probe1 argument.
 * \param proj2 Pointer to an uninitialized graph object, the second
 *   projection is created here, if it is not a null pointer. See also
 *   the \p probe1 argument.
 * \param multiplicity1 Pointer to a vector, or a null pointer. If not
 *   the latter, then the multiplicity of the edges is stored
 *   here. E.g. if there is an A-C-B and also an A-D-B triple in the
 *   bipartite graph (but no more X, such that A-X-B is also in the
 *   graph), then the multiplicity of the A-B edge in the projection
 *   will be 2.
 * \param multiplicity2 The same as \c multiplicity1, but for the
 *   other projection.
 * \param probe1 This argument can be used to specify the order of the
 *   projections in the resulting list. When it is non-negative, then
 *   it is considered as a vertex ID and the projection containing
 *   this vertex will be the first one in the result. Setting this
 *   argument to a non-negative value implies that \c proj1 must be
 *   a non-null pointer. If you don't care about the ordering of the
 *   projections, pass -1 here.
 * \return Error code.
 *
 * \sa \ref igraph_bipartite_projection_size() to calculate the number
 * of vertices and edges in the projections, without creating the
 * projection graphs themselves.
 *
 * Time complexity: O(|V|*d^2+|E|), |V| is the number of vertices, |E|
 * is the number of edges, d is the average (total) degree of the
 * graphs.
 *
 * \example examples/simple/igraph_bipartite_projection.c
 */

int igraph_bipartite_projection(const igraph_t *graph,
                                const igraph_vector_bool_t *types,
                                igraph_t *proj1,
                                igraph_t *proj2,
                                igraph_vector_t *multiplicity1,
                                igraph_vector_t *multiplicity2,
                                igraph_integer_t probe1) {

    long int no_of_nodes = igraph_vcount(graph);

    /* t1 is -1 if proj1 is omitted, it is 0 if it belongs to type zero,
       it is 1 if it belongs to type one. The same for t2 */
    int t1, t2;

    if (igraph_vector_bool_size(types) != no_of_nodes) {
        IGRAPH_ERROR("Invalid bipartite type vector size", IGRAPH_EINVAL);
    }

    if (probe1 >= no_of_nodes) {
        IGRAPH_ERROR("No such vertex to probe", IGRAPH_EINVAL);
    }

    if (probe1 >= 0 && !proj1) {
        IGRAPH_ERROR("`probe1' given, but `proj1' is a null pointer", IGRAPH_EINVAL);
    }

    if (probe1 >= 0) {
        t1 = VECTOR(*types)[(long int)probe1];
        if (proj2) {
            t2 = 1 - t1;
        } else {
            t2 = -1;
        }
    } else {
        t1 = proj1 ? 0 : -1;
        t2 = proj2 ? 1 : -1;
    }

    IGRAPH_CHECK(igraph_i_bipartite_projection(graph, types, proj1, t1, multiplicity1));
    IGRAPH_FINALLY(igraph_destroy, proj1);
    IGRAPH_CHECK(igraph_i_bipartite_projection(graph, types, proj2, t2, multiplicity2));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}


/**
 * \function igraph_full_bipartite
 * \brief Create a full bipartite network.
 *
 * A bipartite network contains two kinds of vertices and connections
 * are only possible between two vertices of different kind. There are
 * many natural examples, e.g. movies and actors as vertices and a
 * movie is connected to all participating actors, etc.
 *
 * 
 * igraph does not have direct support for bipartite networks, at
 * least not at the C language level. In other words the igraph_t
 * structure does not contain information about the vertex types.
 * The C functions for bipartite networks usually have an additional
 * input argument to graph, called \c types, a boolean vector giving
 * the vertex types.
 *
 * 
 * Most functions creating bipartite networks are able to create this
 * extra vector, you just need to supply an initialized boolean vector
 * to them.
 *
 * \param graph Pointer to an igraph_t object, the graph will be
 *   created here.
 * \param types Pointer to a boolean vector. If not a null pointer,
 *   then the vertex types will be stored here.
 * \param n1 Integer, the number of vertices of the first kind.
 * \param n2 Integer, the number of vertices of the second kind.
 * \param directed Boolean, whether to create a directed graph.
 * \param mode A constant that gives the type of connections for
 *   directed graphs. If \c IGRAPH_OUT, then edges point from vertices
 *   of the first kind to vertices of the second kind; if \c
 *   IGRAPH_IN, then the opposite direction is realized; if \c
 *   IGRAPH_ALL, then mutual edges will be created.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 *
 * \sa \ref igraph_full() for non-bipartite full graphs.
 */

int igraph_full_bipartite(igraph_t *graph,
                          igraph_vector_bool_t *types,
                          igraph_integer_t n1, igraph_integer_t n2,
                          igraph_bool_t directed,
                          igraph_neimode_t mode) {

    igraph_integer_t nn1 = n1, nn2 = n2;
    igraph_integer_t no_of_nodes = nn1 + nn2;
    igraph_vector_t edges;
    long int no_of_edges;
    long int ptr = 0;
    long int i, j;

    if (!directed) {
        no_of_edges = nn1 * nn2;
    } else if (mode == IGRAPH_OUT || mode == IGRAPH_IN) {
        no_of_edges = nn1 * nn2;
    } else { /* mode==IGRAPH_ALL */
        no_of_edges = nn1 * nn2 * 2;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    if (!directed || mode == IGRAPH_OUT) {

        for (i = 0; i < nn1; i++) {
            for (j = 0; j < nn2; j++) {
                VECTOR(edges)[ptr++] = i;
                VECTOR(edges)[ptr++] = nn1 + j;
            }
        }

    } else if (mode == IGRAPH_IN) {

        for (i = 0; i < nn1; i++) {
            for (j = 0; j < nn2; j++) {
                VECTOR(edges)[ptr++] = nn1 + j;
                VECTOR(edges)[ptr++] = i;
            }
        }

    } else {

        for (i = 0; i < nn1; i++) {
            for (j = 0; j < nn2; j++) {
                VECTOR(edges)[ptr++] = i;
                VECTOR(edges)[ptr++] = nn1 + j;
                VECTOR(edges)[ptr++] = nn1 + j;
                VECTOR(edges)[ptr++] = i;
            }
        }
    }

    IGRAPH_CHECK(igraph_create(graph, &edges, no_of_nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, graph);

    if (types) {
        IGRAPH_CHECK(igraph_vector_bool_resize(types, no_of_nodes));
        igraph_vector_bool_null(types);
        for (i = nn1; i < no_of_nodes; i++) {
            VECTOR(*types)[i] = 1;
        }
    }

    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_create_bipartite
 * \brief Create a bipartite graph.
 *
 * This is a simple wrapper function to create a bipartite graph. It
 * does a little more than \ref igraph_create(), e.g. it checks that
 * the graph is indeed bipartite with respect to the given \p types
 * vector. If there is an edge connecting two vertices of the same
 * kind, then an error is reported.
 *
 * \param graph Pointer to an uninitialized graph object, the result is
 *   created here.
 * \param types Boolean vector giving the vertex types. The length of
 *   the vector defines the number of vertices in the graph.
 * \param edges Vector giving the edges of the graph. The highest
 *   vertex id in this vector must be smaller than the length of the
 *   \p types vector.
 * \param directed Boolean scalar, whether to create a directed
 *   graph.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 *
 * \example examples/simple/igraph_bipartite_create.c
 */

int igraph_create_bipartite(igraph_t *graph, const igraph_vector_bool_t *types,
                            const igraph_vector_t *edges,
                            igraph_bool_t directed) {

    igraph_integer_t no_of_nodes =
        (igraph_integer_t) igraph_vector_bool_size(types);
    long int no_of_edges = igraph_vector_size(edges);
    igraph_real_t min_edge = 0, max_edge = 0;
    long int i;

    if (no_of_edges % 2 != 0) {
        IGRAPH_ERROR("Invalid (odd) edges vector", IGRAPH_EINVEVECTOR);
    }
    no_of_edges /= 2;

    if (no_of_edges != 0) {
        igraph_vector_minmax(edges, &min_edge, &max_edge);
    }
    if (min_edge < 0 || max_edge >= no_of_nodes) {
        IGRAPH_ERROR("Invalid (negative) vertex id", IGRAPH_EINVVID);
    }

    /* Check bipartiteness */
    for (i = 0; i < no_of_edges * 2; i += 2) {
        long int from = (long int) VECTOR(*edges)[i];
        long int to = (long int) VECTOR(*edges)[i + 1];
        long int t1 = VECTOR(*types)[from];
        long int t2 = VECTOR(*types)[to];
        if ( (t1 && t2) || (!t1 && !t2) ) {
            IGRAPH_ERROR("Invalid edges, not a bipartite graph", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_empty(graph, no_of_nodes, directed));
    IGRAPH_FINALLY(igraph_destroy, graph);
    IGRAPH_CHECK(igraph_add_edges(graph, edges, 0));

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_incidence
 * \brief Creates a bipartite graph from an incidence matrix.
 *
 * A bipartite (or two-mode) graph contains two types of vertices and
 * edges always connect vertices of different types. An incidence
 * matrix is an nxm matrix, n and m are the number of vertices of the
 * two types, respectively. Nonzero elements in the matrix denote
 * edges between the two corresponding vertices.
 *
 * 
 * Note that this function can operate in two modes, depending on the
 * \p multiple argument. If it is FALSE (i.e. 0), then a single edge is
 * created for every non-zero element in the incidence matrix. If \p
 * multiple is TRUE (i.e. 1), then the matrix elements are rounded up
 * to the closest non-negative integer to get the number of edges to
 * create between a pair of vertices.
 *
 * 
 * This function does not create multiple edges if \p multiple is
 * \c FALSE, but might create some if it is \c TRUE.
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param types Pointer to an initialized boolean vector, or a null
 *   pointer. If not a null pointer, then the vertex types are stored
 *   here. It is resized as needed.
 * \param incidence The incidence matrix.
 * \param directed Gives whether to create an undirected or a directed
 *   graph.
 * \param mode Specifies the direction of the edges in a directed
 *   graph. If \c IGRAPH_OUT, then edges point from vertices
 *   of the first kind (corresponding to rows) to vertices of the
 *   second kind (corresponding to columns); if \c
 *   IGRAPH_IN, then the opposite direction is realized; if \c
 *   IGRAPH_ALL, then mutual edges will be created.
 * \param multiple How to interpret the incidence matrix elements. See
 *   details below.
 * \return Error code.
 *
 * Time complexity: O(n*m), the size of the incidence matrix.
 */

int igraph_incidence(igraph_t *graph, igraph_vector_bool_t *types,
                     const igraph_matrix_t *incidence,
                     igraph_bool_t directed,
                     igraph_neimode_t mode, igraph_bool_t multiple) {

    igraph_integer_t n1 = (igraph_integer_t) igraph_matrix_nrow(incidence);
    igraph_integer_t n2 = (igraph_integer_t) igraph_matrix_ncol(incidence);
    igraph_integer_t no_of_nodes = n1 + n2;
    igraph_vector_t edges;
    long int i, j, k;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    if (multiple) {

        for (i = 0; i < n1; i++) {
            for (j = 0; j < n2; j++) {
                long int elem = (long int) MATRIX(*incidence, i, j);
                long int from, to;

                if (!elem) {
                    continue;
                }

                if (mode == IGRAPH_IN) {
                    from = n1 + j;
                    to = i;
                } else {
                    from = i;
                    to = n1 + j;
                }

                if (mode != IGRAPH_ALL || !directed) {
                    for (k = 0; k < elem; k++) {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                    }
                } else {
                    for (k = 0; k < elem; k++) {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                    }
                }
            }
        }

    } else {

        for (i = 0; i < n1; i++) {
            for (j = 0; j < n2; j++) {
                long int from, to;

                if (MATRIX(*incidence, i, j) != 0) {
                    if (mode == IGRAPH_IN) {
                        from = n1 + j;
                        to = i;
                    } else {
                        from = i;
                        to = n1 + j;
                    }
                    if (mode != IGRAPH_ALL || !directed) {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                    } else {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
                    }
                }
            }
        }

    }

    IGRAPH_CHECK(igraph_create(graph, &edges, no_of_nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_destroy, graph);

    if (types) {
        IGRAPH_CHECK(igraph_vector_bool_resize(types, no_of_nodes));
        igraph_vector_bool_null(types);
        for (i = n1; i < no_of_nodes; i++) {
            VECTOR(*types)[i] = 1;
        }
    }

    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_get_incidence
 * \brief Convert a bipartite graph into an incidence matrix.
 *
 * \param graph The input graph, edge directions are ignored.
 * \param types Boolean vector containing the vertex types. All vertices
 *   in one part of the graph should have type 0, the others type 1.
 * \param res Pointer to an initialized matrix, the result is stored
 *   here. An element of the matrix gives the number of edges
 *   (irrespectively of their direction) between the two corresponding
 *   vertices. The rows will correspond to vertices with type 0,
 *   the columns correspond to vertices with type 1.
 * \param row_ids Pointer to an initialized vector or a null
 *   pointer. If not a null pointer, then the vertex ids (in the
 *   graph) corresponding to the rows of the result matrix are stored
 *   here.
 * \param col_ids Pointer to an initialized vector or a null
 *   pointer. If not a null pointer, then the vertex ids corresponding
 *   to the columns of the result matrix are stored here.
 * \return Error code.
 *
 * Time complexity: O(n*m), n and m are number of vertices of the two
 * different kind.
 *
 * \sa \ref igraph_incidence() for the opposite operation.
 */

int igraph_get_incidence(const igraph_t *graph,
                         const igraph_vector_bool_t *types,
                         igraph_matrix_t *res,
                         igraph_vector_t *row_ids,
                         igraph_vector_t *col_ids) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int n1 = 0, n2 = 0, i;
    igraph_vector_t perm;
    long int p1, p2;
    long int ignored_edges = 0;

    if (igraph_vector_bool_size(types) != no_of_nodes) {
        IGRAPH_ERRORF("Vertex type vector size (%ld) not equal to number of vertices (%ld).",
                      IGRAPH_EINVAL, igraph_vector_bool_size(types), no_of_nodes);
    }

    for (i = 0; i < no_of_nodes; i++) {
        n1 += VECTOR(*types)[i] == 0 ? 1 : 0;
    }
    n2 = no_of_nodes - n1;

    IGRAPH_VECTOR_INIT_FINALLY(&perm, no_of_nodes);

    for (i = 0, p1 = 0, p2 = n1; i < no_of_nodes; i++) {
        VECTOR(perm)[i] = VECTOR(*types)[i] ? p2++ : p1++;
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, n1, n2));
    igraph_matrix_null(res);
    for (i = 0; i < no_of_edges; i++) {
        long int from = IGRAPH_FROM(graph, i);
        long int to = IGRAPH_TO(graph, i);
        long int from2 = (long int) VECTOR(perm)[from];
        long int to2 = (long int) VECTOR(perm)[to];
        if (VECTOR(*types)[from] == VECTOR(*types)[to]) {
            ignored_edges++;
        } else if (! VECTOR(*types)[from]) {
            MATRIX(*res, from2, to2 - n1) += 1;
        } else {
            MATRIX(*res, to2, from2 - n1) += 1;
        }
    }
    if (ignored_edges) {
            IGRAPH_WARNINGF("%ld edges running within partitions were ignored.", ignored_edges);
    }

    if (row_ids) {
        IGRAPH_CHECK(igraph_vector_resize(row_ids, n1));
    }
    if (col_ids) {
        IGRAPH_CHECK(igraph_vector_resize(col_ids, n2));
    }
    if (row_ids || col_ids) {
        for (i = 0; i < no_of_nodes; i++) {
            if (! VECTOR(*types)[i]) {
                if (row_ids) {
                    long int i2 = (long int) VECTOR(perm)[i];
                    VECTOR(*row_ids)[i2] = i;
                }
            } else {
                if (col_ids) {
                    long int i2 = (long int) VECTOR(perm)[i];
                    VECTOR(*col_ids)[i2 - n1] = i;
                }
            }
        }
    }

    igraph_vector_destroy(&perm);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_is_bipartite
 * \brief Check whether a graph is bipartite.
 *
 * This function checks whether a graph is bipartite. It tries
 * to find a mapping that gives a possible division of the vertices into two
 * classes, such that no two vertices of the same class are connected by an
 * edge.
 *
 * 
 * The existence of such a mapping is equivalent of having no circuits of
 * odd length in the graph. A graph with loop edges cannot be bipartite.
 *
 * 
 * Note that the mapping is not necessarily unique, e.g. if the graph has
 * at least two components, then the vertices in the separate components
 * can be mapped independently.
 *
 * \param graph The input graph.
 * \param res Pointer to a boolean, the result is stored here.
 * \param types Pointer to an initialized boolean vector, or a null
 *   pointer. If not a null pointer and a mapping was found, then it
 *   is stored here. If not a null pointer, but no mapping was found,
 *   the contents of this vector is invalid.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 */

int igraph_is_bipartite(const igraph_t *graph,
                        igraph_bool_t *res,
                        igraph_vector_bool_t *types) {

    /* We basically do a breadth first search and label the
       vertices along the way. We stop as soon as we can find a
       contradiction.

       In the 'seen' vector 0 means 'not seen yet', 1 means type 1,
       2 means type 2.
    */

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_char_t seen;
    igraph_dqueue_t Q;
    igraph_vector_t neis;
    igraph_bool_t bi = 1;
    long int i;

    IGRAPH_CHECK(igraph_vector_char_init(&seen, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &seen);
    IGRAPH_DQUEUE_INIT_FINALLY(&Q, 100);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    for (i = 0; bi && i < no_of_nodes; i++) {

        if (VECTOR(seen)[i]) {
            continue;
        }

        IGRAPH_CHECK(igraph_dqueue_push(&Q, i));
        VECTOR(seen)[i] = 1;

        while (bi && !igraph_dqueue_empty(&Q)) {
            long int n, j;
            igraph_integer_t actnode = (igraph_integer_t) igraph_dqueue_pop(&Q);
            char acttype = VECTOR(seen)[actnode];

            IGRAPH_CHECK(igraph_neighbors(graph, &neis, actnode, IGRAPH_ALL));
            n = igraph_vector_size(&neis);
            for (j = 0; j < n; j++) {
                long int nei = (long int) VECTOR(neis)[j];
                if (VECTOR(seen)[nei]) {
                    long int neitype = VECTOR(seen)[nei];
                    if (neitype == acttype) {
                        bi = 0;
                        break;
                    }
                } else {
                    VECTOR(seen)[nei] = 3 - acttype;
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
                }
            }
        }
    }

    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(2);

    if (res) {
        *res = bi;
    }

    if (types && bi) {
        IGRAPH_CHECK(igraph_vector_bool_resize(types, no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*types)[i] = VECTOR(seen)[i] - 1;
        }
    }

    igraph_vector_char_destroy(&seen);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

int igraph_bipartite_game_gnp(igraph_t *graph, igraph_vector_bool_t *types,
                              igraph_integer_t n1, igraph_integer_t n2,
                              igraph_real_t p, igraph_bool_t directed,
                              igraph_neimode_t mode) {

    int retval = 0;
    igraph_vector_t edges, s;
    int i;

    if (p < 0.0 || p > 1.0) {
        IGRAPH_ERROR("Invalid connection probability", IGRAPH_EINVAL);
    }

    if (types) {
        IGRAPH_CHECK(igraph_vector_bool_resize(types, n1 + n2));
        igraph_vector_bool_null(types);
        for (i = n1; i < n1 + n2; i++) {
            VECTOR(*types)[i] = 1;
        }
    }

    if (p == 0 || n1 * n2 < 1) {
        IGRAPH_CHECK(retval = igraph_empty(graph, n1 + n2, directed));
    } else if (p == 1.0) {
        IGRAPH_CHECK(retval = igraph_full_bipartite(graph, types, n1, n2, directed,
                              mode));
    } else {

        long int to, from, slen;
        double maxedges, last;
        if (!directed || mode != IGRAPH_ALL) {
            maxedges = (double) n1 * (double) n2;
        } else {
            maxedges = 2.0 * (double) n1 * (double) n2;
        }

        IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&s, (long) (maxedges * p * 1.1)));

        RNG_BEGIN();

        last = RNG_GEOM(p);
        while (last < maxedges) {
            IGRAPH_CHECK(igraph_vector_push_back(&s, last));
            last += RNG_GEOM(p);
            last += 1;
        }

        RNG_END();

        slen = igraph_vector_size(&s);
        IGRAPH_CHECK(igraph_vector_reserve(&edges, slen * 2));

        for (i = 0; i < slen; i++) {
            if (!directed || mode != IGRAPH_ALL) {
                to = (long) floor(VECTOR(s)[i] / n1);
                from = (long) (VECTOR(s)[i] - ((igraph_real_t) to) * n1);
                to += n1;
            } else {
                long int n1n2 = n1 * n2;
                if (VECTOR(s)[i] < n1n2) {
                    to = (long) floor(VECTOR(s)[i] / n1);
                    from = (long) (VECTOR(s)[i] - ((igraph_real_t) to) * n1);
                    to += n1;
                } else {
                    to = (long) floor( (VECTOR(s)[i] - n1n2) / n2);
                    from = (long) (VECTOR(s)[i] - n1n2 - ((igraph_real_t) to) * n2);
                    from += n1;
                }
            }

            if (mode != IGRAPH_IN) {
                igraph_vector_push_back(&edges, from);
                igraph_vector_push_back(&edges, to);
            } else {
                igraph_vector_push_back(&edges, to);
                igraph_vector_push_back(&edges, from);
            }
        }

        igraph_vector_destroy(&s);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_CHECK(retval = igraph_create(graph, &edges, n1 + n2, directed));
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return retval;
}

int igraph_bipartite_game_gnm(igraph_t *graph, igraph_vector_bool_t *types,
                              igraph_integer_t n1, igraph_integer_t n2,
                              igraph_integer_t m, igraph_bool_t directed,
                              igraph_neimode_t mode) {
    igraph_vector_t edges;
    igraph_vector_t s;
    int retval = 0;

    if (n1 < 0 || n2 < 0) {
        IGRAPH_ERROR("Invalid number of vertices", IGRAPH_EINVAL);
    }
    if (m < 0) {
        IGRAPH_ERROR("Invalid number of edges", IGRAPH_EINVAL);
    }

    if (types) {
        long int i;
        IGRAPH_CHECK(igraph_vector_bool_resize(types, n1 + n2));
        igraph_vector_bool_null(types);
        for (i = n1; i < n1 + n2; i++) {
            VECTOR(*types)[i] = 1;
        }
    }

    if (m == 0 || n1 * n2 == 0) {
        if (m > 0) {
            IGRAPH_ERROR("Invalid number (too large) of edges", IGRAPH_EINVAL);
        }
        IGRAPH_CHECK(retval = igraph_empty(graph, n1 + n2, directed));
    } else {


        long int i;
        double maxedges;
        if (!directed || mode != IGRAPH_ALL) {
            maxedges = (double) n1 * (double) n2;
        } else {
            maxedges = 2.0 * (double) n1 * (double) n2;
        }

        if (m > maxedges) {
            IGRAPH_ERROR("Invalid number (too large) of edges", IGRAPH_EINVAL);
        }

        if (maxedges == m) {
            IGRAPH_CHECK(retval = igraph_full_bipartite(graph, types, n1, n2,
                                  directed, mode));
        } else {

            long int to, from;
            IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
            IGRAPH_VECTOR_INIT_FINALLY(&s, 0);
            IGRAPH_CHECK(igraph_random_sample(&s, 0, maxedges - 1, m));
            IGRAPH_CHECK(igraph_vector_reserve(&edges, igraph_vector_size(&s) * 2));

            for (i = 0; i < m; i++) {
                if (!directed || mode != IGRAPH_ALL) {
                    to = (long) floor(VECTOR(s)[i] / n1);
                    from = (long) (VECTOR(s)[i] - ((igraph_real_t) to) * n1);
                    to += n1;
                } else {
                    long int n1n2 = n1 * n2;
                    if (VECTOR(s)[i] < n1n2) {
                        to = (long) floor(VECTOR(s)[i] / n1);
                        from = (long) (VECTOR(s)[i] - ((igraph_real_t) to) * n1);
                        to += n1;
                    } else {
                        to = (long) floor( (VECTOR(s)[i] - n1n2) / n2);
                        from = (long) (VECTOR(s)[i] - n1n2 - ((igraph_real_t) to) * n2);
                        from += n1;
                    }
                }

                if (mode != IGRAPH_IN) {
                    igraph_vector_push_back(&edges, from);
                    igraph_vector_push_back(&edges, to);
                } else {
                    igraph_vector_push_back(&edges, to);
                    igraph_vector_push_back(&edges, from);
                }
            }

            igraph_vector_destroy(&s);
            IGRAPH_FINALLY_CLEAN(1);
            IGRAPH_CHECK(retval = igraph_create(graph, &edges, n1 + n2, directed));
            igraph_vector_destroy(&edges);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    return retval;
}

/**
 * \function igraph_bipartite_game
 * \brief Generate a bipartite random graph (similar to Erdős-Rényi).
 *
 * Similarly to unipartite (one-mode) networks, we can define the
 * G(n,p), and G(n,m) graph classes for bipartite graphs, via their
 * generating process. In G(n,p) every possible edge between top and
 * bottom vertices is realized with probablity p, independently of the
 * rest of the edges. In G(n,m), we uniformly choose m edges to
 * realize.
 *
 * \param graph Pointer to an uninitialized igraph graph, the result
 *    is stored here.
 * \param types Pointer to an initialized boolean vector, or a null
 *    pointer. If not a null pointer, then the vertex types are stored
 *    here. Bottom vertices come first, n1 of them, then n2 top
 *    vertices.
 * \param type The type of the random graph, possible values:
 *        \clist
 *        \cli IGRAPH_ERDOS_RENYI_GNM
 *          G(n,m) graph,
 *          m edges are
 *          selected uniformly randomly in a graph with
 *          n vertices.
 *        \cli IGRAPH_ERDOS_RENYI_GNP
 *          G(n,p) graph,
 *          every possible edge is included in the graph with
 *          probability p.
 *        \endclist
 * \param n1 The number of bottom vertices.
 * \param n2 The number of top verices.
 * \param p The connection probability for G(n,p) graphs. It is
 *     ignored for G(n,m) graphs.
 * \param m The number of edges for G(n,m) graphs. It is ignored for
 *     G(n,p) graphs.
 * \param directed Boolean, whether to generate a directed graph. See
 *     also the \p mode argument.
 * \param mode Specifies how to direct the edges in directed
 *     graphs. If it is \c IGRAPH_OUT, then directed edges point from
 *     bottom vertices to top vertices. If it is \c IGRAPH_IN, edges
 *     point from top vertices to bottom vertices. \c IGRAPH_OUT and
 *     \c IGRAPH_IN do not generate mutual edges. If this argument is
 *     \c IGRAPH_ALL, then each edge direction is considered
 *     independently and mutual edges might be generated. This
 *     argument is ignored for undirected graphs.
 * \return Error code.
 *
 * \sa \ref igraph_erdos_renyi_game.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 */

int igraph_bipartite_game(igraph_t *graph, igraph_vector_bool_t *types,
                          igraph_erdos_renyi_t type,
                          igraph_integer_t n1, igraph_integer_t n2,
                          igraph_real_t p, igraph_integer_t m,
                          igraph_bool_t directed, igraph_neimode_t mode) {

    if (n1 < 0 || n2 < 0) {
        IGRAPH_ERROR("Invalid number of vertices for bipartite game.", IGRAPH_EINVAL);
    }

    if (type == IGRAPH_ERDOS_RENYI_GNP) {
        return igraph_bipartite_game_gnp(graph, types, n1, n2, p, directed, mode);
    } else if (type == IGRAPH_ERDOS_RENYI_GNM) {
        return igraph_bipartite_game_gnm(graph, types, n1, n2, m, directed, mode);
    } else {
        IGRAPH_ERROR("Invalid bipartite game type.", IGRAPH_EINVAL);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/chordality.c0000644000175100001710000003746600000000000023722 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_structural.h"
#include "igraph_error.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"

/**
 * \function igraph_maximum_cardinality_search
 * \brief Maximum cardinality search.
 *
 * This function implements the maximum cardinality search algorithm.
 * It computes a rank \p alpha for each vertex, such that visiting
 * vertices in decreasing rank order corresponds to always choosing
 * the vertex with the most already visited neighbors as the next one
 * to visit.
 *
 * 
 * Maximum cardinality search is useful in deciding the chordality
 * of a graph. A graph is chordal if and only if any two neighbors
 * of a vertex which are higher in rank than it are connected to
 * each other.
 *
 * 
 * References:
 *
 * 
 * Robert E Tarjan and Mihalis Yannakakis: Simple linear-time
 * algorithms to test chordality of graphs, test acyclicity of
 * hypergraphs, and selectively reduce acyclic hypergraphs.
 * SIAM Journal of Computation 13, 566--579, 1984.
 * https://doi.org/10.1137/0213035
 *
 * \param graph The input graph. Edge directions will be ignored.
 * \param alpha Pointer to an initialized vector, the result is stored here.
 *   It will be resized, as needed. Upon return it contains
 *   the rank of the each vertex in the range 0 to n - 1,
 *   where \c n is the number of vertices.
 * \param alpham1 Pointer to an initialized vector or a \c NULL
 *   pointer. If not \c NULL, then the inverse of \p alpha is stored
 *   here. In other words, the elements of \p alpham1 are vertex IDs
 *   in reverse maximum cardinality search order.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in terms of the number of
 * vertices and edges.
 *
 * \sa \ref igraph_is_chordal().
 */

int igraph_maximum_cardinality_search(const igraph_t *graph,
                                      igraph_vector_t *alpha,
                                      igraph_vector_t *alpham1) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_long_t size;
    igraph_vector_long_t head, next, prev; /* doubly linked list with head */
    long int i;
    igraph_adjlist_t adjlist;

    /***************/
    /* local j, v; */
    /***************/

    long int j, v;

    if (no_of_nodes == 0) {
        igraph_vector_clear(alpha);
        if (alpham1) {
            igraph_vector_clear(alpham1);
        }
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_vector_long_init(&size, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &size);
    IGRAPH_CHECK(igraph_vector_long_init(&head, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &head);
    IGRAPH_CHECK(igraph_vector_long_init(&next, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &next);
    IGRAPH_CHECK(igraph_vector_long_init(&prev, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &prev);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    IGRAPH_CHECK(igraph_vector_resize(alpha, no_of_nodes));
    if (alpham1) {
        IGRAPH_CHECK(igraph_vector_resize(alpham1, no_of_nodes));
    }

    /***********************************************/
    /* for i in [0,n-1] -> set(i) := emptyset rof; */
    /***********************************************/

    /* nothing to do, 'head' contains all zeros */

    /*********************************************************/
    /* for v in vertices -> size(v):=0; add v to set(0) rof; */
    /*********************************************************/

    VECTOR(head)[0] = 1;
    for (v = 0; v < no_of_nodes; v++) {
        VECTOR(next)[v] = v + 2;
        VECTOR(prev)[v] = v;
    }
    VECTOR(next)[no_of_nodes - 1] = 0;
    /* size is already all zero */

    /***************/
    /* i:=n; j:=0; */
    /***************/

    i = no_of_nodes; j = 0;

    /**************/
    /* do i>=1 -> */
    /**************/

    while (i >= 1) {
        long int x, k, len;
        igraph_vector_int_t *neis;

        /********************************/
        /* v :=  delete any from set(j) */
        /********************************/

        v = VECTOR(head)[j] - 1;
        x = VECTOR(next)[v];
        VECTOR(head)[j] = x;
        if (x != 0) {
            VECTOR(prev)[x - 1] = 0;
        }

        /*************************************************/
        /* alpha(v) := i; alpham1(i) := v; size(v) := -1 */
        /*************************************************/

        VECTOR(*alpha)[v] = i - 1;
        if (alpham1) {
            VECTOR(*alpham1)[i - 1] = v;
        }
        VECTOR(size)[v] = -1;

        /********************************************/
        /* for {v,w} in E such that size(w) >= 0 -> */
        /********************************************/

        neis = igraph_adjlist_get(&adjlist, v);
        len = igraph_vector_int_size(neis);
        for (k = 0; k < len; k++) {
            long int w = (long int) VECTOR(*neis)[k];
            long int ws = VECTOR(size)[w];
            if (ws >= 0) {

                /******************************/
                /* delete w from set(size(w)) */
                /******************************/

                long int nw = VECTOR(next)[w];
                long int pw = VECTOR(prev)[w];
                if (nw != 0) {
                    VECTOR(prev)[nw - 1] = pw;
                }
                if (pw != 0) {
                    VECTOR(next)[pw - 1] = nw;
                } else {
                    VECTOR(head)[ws] = nw;
                }

                /******************************/
                /* size(w) := size(w)+1       */
                /******************************/

                VECTOR(size)[w] += 1;

                /******************************/
                /* add w to set(size(w))      */
                /******************************/

                ws = VECTOR(size)[w];
                nw = VECTOR(head)[ws];
                VECTOR(next)[w] = nw;
                VECTOR(prev)[w] = 0;
                if (nw != 0) {
                    VECTOR(prev)[nw - 1] = w + 1;
                }
                VECTOR(head)[ws] = w + 1;

            }
        }

        /***********************/
        /* i := i-1; j := j+1; */
        /***********************/

        i -= 1;
        j += 1;

        /*********************************************/
        /* do j>=0 and set(j)=emptyset -> j:=j-1; od */
        /*********************************************/

        if (j < no_of_nodes) {
            while (j >= 0 && VECTOR(head)[j] == 0) {
                j--;
            }
        }
    }

    igraph_adjlist_destroy(&adjlist);
    igraph_vector_long_destroy(&prev);
    igraph_vector_long_destroy(&next);
    igraph_vector_long_destroy(&head);
    igraph_vector_long_destroy(&size);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_is_chordal
 * \brief Decides whether a graph is chordal.
 *
 * A graph is chordal if each of its cycles of four or more nodes
 * has a chord, i.e. an edge joining two nodes that are not
 * adjacent in the cycle. An equivalent definition is that any
 * chordless cycles have at most three nodes.
 *
 * If either \p alpha or \p alpham1 is given, then the other is
 * calculated by taking simply the inverse. If neither are given,
 * then \ref igraph_maximum_cardinality_search() is called to calculate
 * them.
 *
 * \param graph The input graph. Edge directions will be ignored.
 * \param alpha Either an alpha vector coming from
 *    \ref igraph_maximum_cardinality_search() (on the same graph), or a
 *    \c NULL pointer.
 * \param alpham1 Either an inverse alpha vector coming from \ref
 *    igraph_maximum_cardinality_search() (on the same graph) or a \c NULL
 *    pointer.
 * \param chordal Pointer to a boolean. If not NULL the result is stored here.
 * \param fill_in Pointer to an initialized vector, or a \c NULL
 *    pointer. If not a \c NULL pointer, then the fill-in, also called the
 *    chordal completion of the graph is stored here.
 *    The chordal completion is a set of edges that are needed to
 *    make the graph chordal. The vector is resized as needed.
 *    Note that the chordal completion returned by this function may not
 *    be minimal, i.e. some of the returned fill-in edges may not be needed
 *    to make the graph chordal.
 * \param newgraph Pointer to an uninitialized graph, or a \c NULL
 *   pointer. If not a null pointer, then a new triangulated graph is
 *   created here. This essentially means adding the fill-in edges to
 *   the original graph.
 * \return Error code.
 *
 * Time complexity: O(n).
 *
 * \sa \ref igraph_maximum_cardinality_search().
 */

int igraph_is_chordal(const igraph_t *graph,
                      const igraph_vector_t *alpha,
                      const igraph_vector_t *alpham1,
                      igraph_bool_t *chordal,
                      igraph_vector_t *fill_in,
                      igraph_t *newgraph) {

    long int no_of_nodes = igraph_vcount(graph);
    const igraph_vector_t *my_alpha = alpha, *my_alpham1 = alpham1;
    igraph_vector_t v_alpha, v_alpham1;
    igraph_vector_long_t f, index;
    long int i;
    igraph_adjlist_t adjlist;
    igraph_vector_long_t mark;
    igraph_bool_t calc_edges = fill_in || newgraph;
    igraph_vector_t *my_fill_in = fill_in, v_fill_in;

    /*****************/
    /* local v, w, x */
    /*****************/

    long int v, w, x;

    if (alpha && (igraph_vector_size(alpha) != no_of_nodes)) {
        IGRAPH_ERRORF("Alpha vector size (%ld) not equal to number of nodes (%ld).",
                      IGRAPH_EINVAL, igraph_vector_size(alpha), no_of_nodes);
    }

    if (alpham1 && (igraph_vector_size(alpham1) != no_of_nodes)) {
        IGRAPH_ERRORF("Inverse alpha vector size (%ld) not equal to number of nodes (%ld).",
                      IGRAPH_EINVAL, igraph_vector_size(alpham1), no_of_nodes);
    }

    if (!chordal && !calc_edges) {
        /* Nothing to calculate */
        return IGRAPH_SUCCESS;
    }

    if (!alpha && !alpham1) {
        IGRAPH_VECTOR_INIT_FINALLY(&v_alpha, no_of_nodes);
        my_alpha = &v_alpha;
        IGRAPH_VECTOR_INIT_FINALLY(&v_alpham1, no_of_nodes);
        my_alpham1 = &v_alpham1;
        IGRAPH_CHECK(igraph_maximum_cardinality_search(graph,
                     (igraph_vector_t*) my_alpha,
                     (igraph_vector_t*) my_alpham1));
    } else if (alpha && !alpham1) {
        long int v;
        IGRAPH_VECTOR_INIT_FINALLY(&v_alpham1, no_of_nodes);
        my_alpham1 = &v_alpham1;
        for (v = 0; v < no_of_nodes; v++) {
            long int i = (long int) VECTOR(*my_alpha)[v];
            VECTOR(*my_alpham1)[i] = v;
        }
    } else if (!alpha && alpham1) {
        long int i;
        IGRAPH_VECTOR_INIT_FINALLY(&v_alpha, no_of_nodes);
        my_alpha = &v_alpha;
        for (i = 0; i < no_of_nodes; i++) {
            long int v = (long int) VECTOR(*my_alpham1)[i];
            VECTOR(*my_alpha)[v] = i;
        }
    }

    if (!fill_in && newgraph) {
        IGRAPH_VECTOR_INIT_FINALLY(&v_fill_in, 0);
        my_fill_in = &v_fill_in;
    }

    IGRAPH_CHECK(igraph_vector_long_init(&f, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &f);
    IGRAPH_CHECK(igraph_vector_long_init(&index, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &index);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
    IGRAPH_CHECK(igraph_vector_long_init(&mark, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &mark);
    if (my_fill_in) {
        igraph_vector_clear(my_fill_in);
    }

    if (chordal) {
        *chordal = 1;
    }

    /*********************/
    /* for i in [1,n] -> */
    /*********************/

    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_int_t *neis;
        long int j, len;

        /**********************************************/
        /* w := alpham1(i); f(w) := w; index(w) := i; */
        /**********************************************/

        w = (long int) VECTOR(*my_alpham1)[i];
        VECTOR(f)[w] = w;
        VECTOR(index)[w] = i;

        /******************************************/
        /* for {v,w} in E such that alpha(v) */
        /******************************************/

        neis = igraph_adjlist_get(&adjlist, w);
        len = igraph_vector_int_size(neis);
        for (j = 0; j < len; j++) {
            v = (long int) VECTOR(*neis)[j];
            VECTOR(mark)[v] = w + 1;
        }

        for (j = 0; j < len; j++) {
            v = (long int) VECTOR(*neis)[j];
            if (VECTOR(*my_alpha)[v] >= i) {
                continue;
            }

            /**********/
            /* x := v */
            /**********/

            x = v;

            /********************/
            /* do index(x) */
            /********************/

            while (VECTOR(index)[x] < i) {

                /******************/
                /* index(x) := i; */
                /******************/

                VECTOR(index)[x] = i;

                /**********************************/
                /* add {x,w} to E union F(alpha); */
                /**********************************/

                if (VECTOR(mark)[x] != w + 1) {

                    if (chordal) {
                        *chordal = 0;
                    }

                    if (my_fill_in) {
                        IGRAPH_CHECK(igraph_vector_push_back(my_fill_in, x));
                        IGRAPH_CHECK(igraph_vector_push_back(my_fill_in, w));
                    }

                    if (!calc_edges) {
                        /* make sure that we exit from all loops */
                        i = no_of_nodes;
                        j = len;
                        break;
                    }
                }

                /*************/
                /* x := f(x) */
                /*************/

                x = VECTOR(f)[x];

            } /* while (VECTOR(index)[x] < i) */

            /*****************************/
            /* if (f(x)=x -> f(x):=w; fi */
            /*****************************/

            if (VECTOR(f)[x] == x) {
                VECTOR(f)[x] = w;
            }
        }
    }

    igraph_vector_long_destroy(&mark);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_long_destroy(&index);
    igraph_vector_long_destroy(&f);
    IGRAPH_FINALLY_CLEAN(4);

    if (newgraph) {
        IGRAPH_CHECK(igraph_copy(newgraph, graph));
        IGRAPH_FINALLY(igraph_destroy, newgraph);
        IGRAPH_CHECK(igraph_add_edges(newgraph, my_fill_in, 0));
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (!fill_in && newgraph) {
        igraph_vector_destroy(&v_fill_in);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (!alpha && !alpham1) {
        igraph_vector_destroy(&v_alpham1);
        igraph_vector_destroy(&v_alpha);
        IGRAPH_FINALLY_CLEAN(2);
    } else if (alpha && !alpham1) {
        igraph_vector_destroy(&v_alpham1);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (!alpha && alpham1) {
        igraph_vector_destroy(&v_alpha);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/cocitation.c0000644000175100001710000007045100000000000023703 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph R package.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_cocitation.h"
#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"

#include "core/interruption.h"

#include 

int igraph_cocitation_real(const igraph_t *graph, igraph_matrix_t *res,
                           igraph_vs_t vids, igraph_neimode_t mode,
                           igraph_vector_t *weights);

/**
 * \ingroup structural
 * \function igraph_cocitation
 * \brief Cocitation coupling.
 *
 * 
 * Two vertices are cocited if there is another vertex citing both of
 * them. \ref igraph_cocitation() simply counts how many times two vertices are
 * cocited.
 * The cocitation score for each given vertex and all other vertices
 * in the graph will be calculated.
 * \param graph The graph object to analyze.
 * \param res Pointer to a matrix, the result of the calculation will
 *        be stored here. The number of its rows is the same as the
 *        number of vertex ids in \p vids, the number of
 *        columns is the number of vertices in the graph.
 * \param vids The vertex ids of the vertices for which the
 *        calculation will be done.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *
 * Time complexity: O(|V|d^2), |V| is
 * the number of vertices in the graph,
 * d is the (maximum) degree of
 * the vertices in the graph.
 *
 * \sa \ref igraph_bibcoupling()
 *
 * \example examples/simple/igraph_cocitation.c
 */

int igraph_cocitation(const igraph_t *graph, igraph_matrix_t *res,
                      const igraph_vs_t vids) {
    return igraph_cocitation_real(graph, res, vids, IGRAPH_OUT, 0);
}

/**
 * \ingroup structural
 * \function igraph_bibcoupling
 * \brief Bibliographic coupling.
 *
 * 
 * The bibliographic coupling of two vertices is the number
 * of other vertices they both cite, \ref igraph_bibcoupling() calculates
 * this.
 * The bibliographic coupling  score for each given vertex and all
 * other vertices in the graph will be calculated.
 * \param graph The graph object to analyze.
 * \param res Pointer to a matrix, the result of the calculation will
 *        be stored here. The number of its rows is the same as the
 *        number of vertex ids in \p vids, the number of
 *        columns is the number of vertices in the graph.
 * \param vids The vertex ids of the vertices for which the
 *        calculation will be done.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *
 * Time complexity: O(|V|d^2),
 * |V| is the number of vertices in
 * the graph, d is the (maximum)
 * degree of the vertices in the graph.
 *
 * \sa \ref igraph_cocitation()
 *
 * \example examples/simple/igraph_cocitation.c
 */

int igraph_bibcoupling(const igraph_t *graph, igraph_matrix_t *res,
                       const igraph_vs_t vids) {
    return igraph_cocitation_real(graph, res, vids, IGRAPH_IN, 0);
}

/**
 * \ingroup structural
 * \function igraph_similarity_inverse_log_weighted
 * \brief Vertex similarity based on the inverse logarithm of vertex degrees.
 *
 * 
 * The inverse log-weighted similarity of two vertices is the number of
 * their common neighbors, weighted by the inverse logarithm of their degrees.
 * It is based on the assumption that two vertices should be considered
 * more similar if they share a low-degree common neighbor, since high-degree
 * common neighbors are more likely to appear even by pure chance.
 *
 * 
 * Isolated vertices will have zero similarity to any other vertex.
 * Self-similarities are not calculated.
 *
 * 
 * See the following paper for more details: Lada A. Adamic and Eytan Adar:
 * Friends and neighbors on the Web. Social Networks, 25(3):211-230, 2003.
 *
 * \param graph The graph object to analyze.
 * \param res Pointer to a matrix, the result of the calculation will
 *        be stored here. The number of its rows is the same as the
 *        number of vertex ids in \p vids, the number of
 *        columns is the number of vertices in the graph.
 * \param vids The vertex ids of the vertices for which the
 *        calculation will be done.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node. Nodes
 *          will be weighted according to their in-degree.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node. Nodes
 *          will be weighted according to their out-degree.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation. Every node is weighted according to its undirected
 *          degree.
 *        \endclist
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *
 * Time complexity: O(|V|d^2),
 * |V| is the number of vertices in
 * the graph, d is the (maximum)
 * degree of the vertices in the graph.
 *
 * \example examples/simple/igraph_similarity.c
 */

int igraph_similarity_inverse_log_weighted(const igraph_t *graph,
        igraph_matrix_t *res, const igraph_vs_t vids, igraph_neimode_t mode) {
    igraph_vector_t weights;
    igraph_neimode_t mode0;
    long int i, no_of_nodes;

    switch (mode) {
    case IGRAPH_OUT: mode0 = IGRAPH_IN; break;
    case IGRAPH_IN: mode0 = IGRAPH_OUT; break;
    default: mode0 = IGRAPH_ALL;
    }

    no_of_nodes = igraph_vcount(graph);

    IGRAPH_VECTOR_INIT_FINALLY(&weights, no_of_nodes);
    IGRAPH_CHECK(igraph_degree(graph, &weights, igraph_vss_all(), mode0, 1));
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(weights)[i] > 1) {
            VECTOR(weights)[i] = 1.0 / log(VECTOR(weights)[i]);
        }
    }

    IGRAPH_CHECK(igraph_cocitation_real(graph, res, vids, mode0, &weights));
    igraph_vector_destroy(&weights);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

int igraph_cocitation_real(const igraph_t *graph, igraph_matrix_t *res,
                           igraph_vs_t vids,
                           igraph_neimode_t mode,
                           igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_vids;
    long int from, i, j, k, l, u, v;
    igraph_vector_t neis = IGRAPH_VECTOR_NULL;
    igraph_vector_t vid_reverse_index;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    no_of_vids = IGRAPH_VIT_SIZE(vit);

    /* Create a mapping from vertex IDs to the row of the matrix where
     * the result for this vertex will appear */
    IGRAPH_VECTOR_INIT_FINALLY(&vid_reverse_index, no_of_nodes);
    igraph_vector_fill(&vid_reverse_index, -1);
    for (IGRAPH_VIT_RESET(vit), i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        v = IGRAPH_VIT_GET(vit);
        if (v < 0 || v >= no_of_nodes) {
            IGRAPH_ERROR("invalid vertex ID in vertex selector", IGRAPH_EINVAL);
        }
        VECTOR(vid_reverse_index)[v] = i;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_vids, no_of_nodes));
    igraph_matrix_null(res);

    /* The result */

    for (from = 0; from < no_of_nodes; from++) {
        igraph_real_t weight = 1;

        IGRAPH_ALLOW_INTERRUPTION();
        IGRAPH_CHECK(igraph_neighbors(graph, &neis,
                                      (igraph_integer_t) from, mode));
        if (weights) {
            weight = VECTOR(*weights)[from];
        }

        for (i = 0; i < igraph_vector_size(&neis) - 1; i++) {
            u = (long int) VECTOR(neis)[i];
            k = (long int) VECTOR(vid_reverse_index)[u];
            for (j = i + 1; j < igraph_vector_size(&neis); j++) {
                v = (long int) VECTOR(neis)[j];
                l = (long int) VECTOR(vid_reverse_index)[v];
                if (k != -1) {
                    MATRIX(*res, k, v) += weight;
                }
                if (l != -1) {
                    MATRIX(*res, l, u) += weight;
                }
            }
        }
    }

    /* Clean up */
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&vid_reverse_index);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}


static int igraph_i_neisets_intersect(const igraph_vector_int_t *v1,
                                      const igraph_vector_int_t *v2, long int *len_union,
                                      long int *len_intersection) {
    /* ASSERT: v1 and v2 are sorted */
    long int i, j, i0, jj0;
    i0 = igraph_vector_int_size(v1); jj0 = igraph_vector_int_size(v2);
    *len_union = i0 + jj0; *len_intersection = 0;
    i = 0; j = 0;
    while (i < i0 && j < jj0) {
        if (VECTOR(*v1)[i] == VECTOR(*v2)[j]) {
            (*len_intersection)++; (*len_union)--;
            i++; j++;
        } else if (VECTOR(*v1)[i] < VECTOR(*v2)[j]) {
            i++;
        } else {
            j++;
        }
    }
    return 0;
}

/**
 * \ingroup structural
 * \function igraph_similarity_jaccard
 * \brief Jaccard similarity coefficient for the given vertices.
 *
 * 
 * The Jaccard similarity coefficient of two vertices is the number of common
 * neighbors divided by the number of vertices that are neighbors of at
 * least one of the two vertices being considered. This function calculates
 * the pairwise Jaccard similarities for some (or all) of the vertices.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a matrix, the result of the calculation will
 *        be stored here. The number of its rows and columns is the same
 *        as the number of vertex ids in \p vids.
 * \param vids The vertex ids of the vertices for which the
 *        calculation will be done.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves in the neighbor
 *        sets.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(|V|^2 d),
 * |V| is the number of vertices in the vertex iterator given, d is the
 * (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_dice(), a measure very similar to the Jaccard
 *   coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_jaccard(const igraph_t *graph, igraph_matrix_t *res,
                              const igraph_vs_t vids, igraph_neimode_t mode, igraph_bool_t loops) {
    igraph_lazy_adjlist_t al;
    igraph_vit_t vit, vit2;
    long int i, j, k;
    long int len_union, len_intersection;
    igraph_vector_int_t *v1, *v2;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit2));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit2);

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &al, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &al);

    IGRAPH_CHECK(igraph_matrix_resize(res, IGRAPH_VIT_SIZE(vit), IGRAPH_VIT_SIZE(vit)));

    if (loops) {
        for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
            i = IGRAPH_VIT_GET(vit);
            v1 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) i);
            if (!igraph_vector_int_binsearch(v1, i, &k)) {
                igraph_vector_int_insert(v1, k, i);
            }
        }
    }

    for (IGRAPH_VIT_RESET(vit), i = 0;
         !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        MATRIX(*res, i, i) = 1.0;
        for (IGRAPH_VIT_RESET(vit2), j = 0;
             !IGRAPH_VIT_END(vit2); IGRAPH_VIT_NEXT(vit2), j++) {
            if (j <= i) {
                continue;
            }
            v1 = igraph_lazy_adjlist_get(&al, IGRAPH_VIT_GET(vit));
            v2 = igraph_lazy_adjlist_get(&al, IGRAPH_VIT_GET(vit2));
            igraph_i_neisets_intersect(v1, v2, &len_union, &len_intersection);
            if (len_union > 0) {
                MATRIX(*res, i, j) = ((igraph_real_t)len_intersection) / len_union;
            } else {
                MATRIX(*res, i, j) = 0.0;
            }
            MATRIX(*res, j, i) = MATRIX(*res, i, j);
        }
    }

    igraph_lazy_adjlist_destroy(&al);
    igraph_vit_destroy(&vit);
    igraph_vit_destroy(&vit2);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_similarity_jaccard_pairs
 * \brief Jaccard similarity coefficient for given vertex pairs.
 *
 * 
 * The Jaccard similarity coefficient of two vertices is the number of common
 * neighbors divided by the number of vertices that are neighbors of at
 * least one of the two vertices being considered. This function calculates
 * the pairwise Jaccard similarities for a list of vertex pairs.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a vector, the result of the calculation will
 *        be stored here. The number of elements is the same as the number
 *        of pairs in \p pairs.
 * \param pairs A vector that contains the pairs for which the similarity
 *        will be calculated. Each pair is defined by two consecutive elements,
 *        i.e. the first and second element of the vector specifies the first
 *        pair, the third and fourth element specifies the second pair and so on.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves in the neighbor
 *        sets.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(nd), n is the number of pairs in the given vector, d is
 * the (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_jaccard() to calculate the Jaccard similarity
 *   between all pairs of a vertex set, or \ref igraph_similarity_dice() and
 *   \ref igraph_similarity_dice_pairs() for a measure very similar to the
 *   Jaccard coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_jaccard_pairs(const igraph_t *graph, igraph_vector_t *res,
                                    const igraph_vector_t *pairs, igraph_neimode_t mode, igraph_bool_t loops) {
    igraph_lazy_adjlist_t al;
    long int i, j, k, u, v;
    long int len_union, len_intersection;
    igraph_vector_int_t *v1, *v2;
    igraph_bool_t *seen;

    k = igraph_vector_size(pairs);
    if (k % 2 != 0) {
        IGRAPH_ERROR("number of elements in `pairs' must be even", IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(igraph_vector_resize(res, k / 2));

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &al, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &al);

    if (loops) {
        /* Add the loop edges */
        i = igraph_vcount(graph);
        seen = IGRAPH_CALLOC(i, igraph_bool_t);
        if (seen == 0) {
            IGRAPH_ERROR("cannot calculate Jaccard similarity", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, seen);

        for (i = 0; i < k; i++) {
            j = (long int) VECTOR(*pairs)[i];
            if (seen[j]) {
                continue;
            }
            seen[j] = 1;
            v1 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) j);
            if (!igraph_vector_int_binsearch(v1, j, &u)) {
                igraph_vector_int_insert(v1, u, j);
            }
        }

        IGRAPH_FREE(seen);
        IGRAPH_FINALLY_CLEAN(1);
    }

    for (i = 0, j = 0; i < k; i += 2, j++) {
        u = (long int) VECTOR(*pairs)[i];
        v = (long int) VECTOR(*pairs)[i + 1];

        if (u == v) {
            VECTOR(*res)[j] = 1.0;
            continue;
        }

        v1 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) u);
        v2 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) v);
        igraph_i_neisets_intersect(v1, v2, &len_union, &len_intersection);
        if (len_union > 0) {
            VECTOR(*res)[j] = ((igraph_real_t)len_intersection) / len_union;
        } else {
            VECTOR(*res)[j] = 0.0;
        }
    }

    igraph_lazy_adjlist_destroy(&al);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_similarity_jaccard_es
 * \brief Jaccard similarity coefficient for a given edge selector.
 *
 * 
 * The Jaccard similarity coefficient of two vertices is the number of common
 * neighbors divided by the number of vertices that are neighbors of at
 * least one of the two vertices being considered. This function calculates
 * the pairwise Jaccard similarities for the endpoints of edges in a given edge
 * selector.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a vector, the result of the calculation will
 *        be stored here. The number of elements is the same as the number
 *        of edges in \p es.
 * \param es An edge selector that specifies the edges to be included in the
 *        result.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves in the neighbor
 *        sets.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(nd), n is the number of edges in the edge selector, d is
 * the (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_jaccard() and \ref igraph_similarity_jaccard_pairs()
 *   to calculate the Jaccard similarity between all pairs of a vertex set or
 *   some selected vertex pairs, or \ref igraph_similarity_dice(),
 *   \ref igraph_similarity_dice_pairs() and \ref igraph_similarity_dice_es() for a
 *   measure very similar to the Jaccard coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_jaccard_es(const igraph_t *graph, igraph_vector_t *res,
                                 const igraph_es_t es, igraph_neimode_t mode, igraph_bool_t loops) {
    igraph_vector_t v;
    igraph_eit_t eit;

    IGRAPH_VECTOR_INIT_FINALLY(&v, 0);

    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    while (!IGRAPH_EIT_END(eit)) {
        long int eid = IGRAPH_EIT_GET(eit);
        igraph_vector_push_back(&v, IGRAPH_FROM(graph, eid));
        igraph_vector_push_back(&v, IGRAPH_TO(graph, eid));
        IGRAPH_EIT_NEXT(eit);
    }

    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_similarity_jaccard_pairs(graph, res, &v, mode, loops));
    igraph_vector_destroy(&v);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_similarity_dice
 * \brief Dice similarity coefficient.
 *
 * 
 * The Dice similarity coefficient of two vertices is twice the number of common
 * neighbors divided by the sum of the degrees of the vertices. This function
 * calculates the pairwise Dice similarities for some (or all) of the vertices.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a matrix, the result of the calculation will
 *        be stored here. The number of its rows and columns is the same
 *        as the number of vertex ids in \p vids.
 * \param vids The vertex ids of the vertices for which the
 *        calculation will be done.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves as their own
 *        neighbors.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(|V|^2 d),
 * |V| is the number of vertices in the vertex iterator given, d is the
 * (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_jaccard(), a measure very similar to the Dice
 *   coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_dice(const igraph_t *graph, igraph_matrix_t *res,
                           const igraph_vs_t vids, igraph_neimode_t mode, igraph_bool_t loops) {
    long int i, j, nr, nc;

    IGRAPH_CHECK(igraph_similarity_jaccard(graph, res, vids, mode, loops));

    nr = igraph_matrix_nrow(res);
    nc = igraph_matrix_ncol(res);
    for (i = 0; i < nr; i++) {
        for (j = 0; j < nc; j++) {
            igraph_real_t x = MATRIX(*res, i, j);
            MATRIX(*res, i, j) = 2 * x / (1 + x);
        }
    }

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_similarity_dice_pairs
 * \brief Dice similarity coefficient for given vertex pairs.
 *
 * 
 * The Dice similarity coefficient of two vertices is twice the number of common
 * neighbors divided by the sum of the degrees of the vertices. This function
 * calculates the pairwise Dice similarities for a list of vertex pairs.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a vector, the result of the calculation will
 *        be stored here. The number of elements is the same as the number
 *        of pairs in \p pairs.
 * \param pairs A vector that contains the pairs for which the similarity
 *        will be calculated. Each pair is defined by two consecutive elements,
 *        i.e. the first and second element of the vector specifies the first
 *        pair, the third and fourth element specifies the second pair and so on.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves as their own
 *        neighbors.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(nd), n is the number of pairs in the given vector, d is
 * the (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_dice() to calculate the Dice similarity
 *   between all pairs of a vertex set, or \ref igraph_similarity_jaccard(),
 *   \ref igraph_similarity_jaccard_pairs() and \ref igraph_similarity_jaccard_es()
 *   for a measure very similar to the Dice coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_dice_pairs(const igraph_t *graph, igraph_vector_t *res,
                                 const igraph_vector_t *pairs, igraph_neimode_t mode, igraph_bool_t loops) {
    long int i, n;

    IGRAPH_CHECK(igraph_similarity_jaccard_pairs(graph, res, pairs, mode, loops));
    n = igraph_vector_size(res);
    for (i = 0; i < n; i++) {
        igraph_real_t x = VECTOR(*res)[i];
        VECTOR(*res)[i] = 2 * x / (1 + x);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_similarity_dice_es
 * \brief Dice similarity coefficient for a given edge selector.
 *
 * 
 * The Dice similarity coefficient of two vertices is twice the number of common
 * neighbors divided by the sum of the degrees of the vertices. This function
 * calculates the pairwise Dice similarities for the endpoints of edges in a given
 * edge selector.
 *
 * \param graph The graph object to analyze
 * \param res Pointer to a vector, the result of the calculation will
 *        be stored here. The number of elements is the same as the number
 *        of edges in \p es.
 * \param es An edge selector that specifies the edges to be included in the
 *        result.
 * \param mode The type of neighbors to be used for the calculation in
 *        directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing edges will be considered for each node.
 *        \cli IGRAPH_IN
 *          the incoming edges will be considered for each node.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for the
 *          computation.
 *        \endclist
 * \param loops Whether to include the vertices themselves as their own
 *        neighbors.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(nd), n is the number of pairs in the given vector, d is
 * the (maximum) degree of the vertices in the graph.
 *
 * \sa \ref igraph_similarity_dice() and \ref igraph_similarity_dice_pairs()
 *   to calculate the Dice similarity between all pairs of a vertex set or
 *   some selected vertex pairs, or \ref igraph_similarity_jaccard(),
 *   \ref igraph_similarity_jaccard_pairs() and \ref igraph_similarity_jaccard_es()
 *   for a measure very similar to the Dice coefficient
 *
 * \example examples/simple/igraph_similarity.c
 */
int igraph_similarity_dice_es(const igraph_t *graph, igraph_vector_t *res,
                              const igraph_es_t es, igraph_neimode_t mode, igraph_bool_t loops) {
    long int i, n;

    IGRAPH_CHECK(igraph_similarity_jaccard_es(graph, res, es, mode, loops));
    n = igraph_vector_size(res);
    for (i = 0; i < n; i++) {
        igraph_real_t x = VECTOR(*res)[i];
        VECTOR(*res)[i] = 2 * x / (1 + x);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/coloring.c0000644000175100001710000001300300000000000023351 0ustar00runnerdocker00000000000000/*
  Heuristic graph coloring algorithms.
  Copyright (C) 2017 Szabolcs Horvat 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include "igraph_coloring.h"
#include "igraph_interface.h"
#include "igraph_adjlist.h"

#include "core/indheap.h"
#include "core/interruption.h"

static int igraph_i_vertex_coloring_greedy_cn(const igraph_t *graph, igraph_vector_int_t *colors) {
    long i, vertex, maxdeg;
    long vc = igraph_vcount(graph);
    igraph_2wheap_t cn; /* indexed heap storing number of already coloured neighbours */
    igraph_vector_int_t neigh_colors;
    igraph_adjlist_t adjlist;

    IGRAPH_CHECK(igraph_vector_int_resize(colors, vc));
    igraph_vector_int_fill(colors, 0);

    /* Nothing to do for 0 or 1 vertices.
     * Remember that colours are integers starting from 0,
     * and the 'colors' vector is already 0-initialized above.
     */
    if (vc <= 1) {
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    /* find maximum degree and a corresponding vertex */
    {
        igraph_vector_t degree;

        IGRAPH_CHECK(igraph_vector_init(°ree, 0));
        IGRAPH_FINALLY(igraph_vector_destroy, °ree);
        IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, 0));

        vertex = igraph_vector_which_max(°ree);
        maxdeg = VECTOR(degree)[vertex];

        igraph_vector_destroy(°ree);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_CHECK(igraph_vector_int_init(&neigh_colors, 0));
    IGRAPH_CHECK(igraph_vector_int_reserve(&neigh_colors, maxdeg));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &neigh_colors);

    IGRAPH_CHECK(igraph_2wheap_init(&cn, vc));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &cn);
    for (i = 0; i < vc; ++i)
        if (i != vertex) {
            igraph_2wheap_push_with_index(&cn, i, 0);    /* should not fail since memory was already reserved */
        }

    while (1) {
        igraph_vector_int_t *neighbors = igraph_adjlist_get(&adjlist, vertex);
        long neigh_count = igraph_vector_int_size(neighbors);

        /* colour current vertex */
        {
            igraph_integer_t col;

            IGRAPH_CHECK(igraph_vector_int_resize(&neigh_colors, neigh_count));
            for (i = 0; i < neigh_count; ++i) {
                VECTOR(neigh_colors)[i] = VECTOR(*colors)[ VECTOR(*neighbors)[i] ];
            }
            igraph_vector_int_sort(&neigh_colors);

            i = 0;
            col = 0;
            do {
                while (i < neigh_count && VECTOR(neigh_colors)[i] == col) {
                    i++;
                }
                col++;
            } while (i < neigh_count && VECTOR(neigh_colors)[i] == col);

            VECTOR(*colors)[vertex] = col;
        }

        /* increment number of coloured neighbours for each neighbour of vertex */
        for (i = 0; i < neigh_count; ++i) {
            long idx = VECTOR(*neighbors)[i];
            if (igraph_2wheap_has_elem(&cn, idx)) {
                igraph_2wheap_modify(&cn, idx, igraph_2wheap_get(&cn, idx) + 1);
            }
        }

        /* stop if no more vertices left to colour */
        if (igraph_2wheap_empty(&cn)) {
            break;
        }

        igraph_2wheap_delete_max_index(&cn, &vertex);

        IGRAPH_ALLOW_INTERRUPTION();
    }

    /* subtract 1 from each colour value, so that colours start at 0 */
    igraph_vector_int_add_constant(colors, -1);

    /* free data structures */
    igraph_vector_int_destroy(&neigh_colors);
    igraph_adjlist_destroy(&adjlist);
    igraph_2wheap_destroy(&cn);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}


/**
 * \function igraph_vertex_coloring_greedy
 * \brief Computes a vertex coloring using a greedy algorithm.
 *
 * 
 * This function assigns a "color"—represented as a non-negative integer—to
 * each vertex of the graph in such a way that neighboring vertices never have
 * the same color. The obtained coloring is not necessarily minimal.
 *
 * 
 * Vertices are colored one by one, choosing the smallest color index that
 * differs from that of already colored neighbors.
 * Colors are represented with non-negative integers 0, 1, 2, ...
 *
 * \param graph The input graph.
 * \param colors Pointer to an initialized integer vector. The vertex colors will be stored here.
 * \param heuristic The vertex ordering heuristic to use during greedy coloring. See \ref igraph_coloring_greedy_t
 *
 * \return Error code.
 *
 * \example examples/simple/igraph_coloring.c
 */
int igraph_vertex_coloring_greedy(const igraph_t *graph, igraph_vector_int_t *colors, igraph_coloring_greedy_t heuristic) {
    switch (heuristic) {
    case IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS:
        return igraph_i_vertex_coloring_greedy_cn(graph, colors);
    default:
        return IGRAPH_EINVAL;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/conversion.c0000644000175100001710000010377100000000000023736 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_conversion.h"

#include "igraph_iterators.h"
#include "igraph_interface.h"
#include "igraph_attributes.h"
#include "igraph_constructors.h"
#include "igraph_structural.h"
#include "igraph_sparsemat.h"
#include "igraph_random.h"

#include "core/fixed_vectorlist.h"
#include "graph/attributes.h"
#include "misc/conversion_internal.h"

/**
 * \ingroup conversion
 * \function igraph_get_adjacency
 * \brief Returns the adjacency matrix of a graph
 *
 * 
 * The result is an adjacency matrix. Entry i, j of the matrix
 * contains the number of edges connecting vertex i to vertex j.
 * \param graph Pointer to the graph to convert
 * \param res Pointer to an initialized matrix object, it will be
 *        resized if needed.
 * \param type Constant giving the type of the adjacency matrix to
 *        create for undirected graphs. It is ignored for directed
 *        graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_GET_ADJACENCY_UPPER
 *          the upper right triangle of the matrix is used.
 *        \cli IGRAPH_GET_ADJACENCY_LOWER
 *          the lower left triangle of the matrix is used.
 *        \cli IGRAPH_GET_ADJACENCY_BOTH
 *          the whole matrix is used, a symmetric matrix is returned
 *          if the graph is undirected.
 *        \endclist
 * \param type eids Logical, if true, then the edges ids plus one
 *        are stored in the adjacency matrix, instead of the number of
 *        edges between the two vertices. (The plus one is needed, since
 *        edge ids start from zero, and zero means no edge in this case.)
 * \return Error code:
 *        \c IGRAPH_EINVAL invalid type argument.
 *
 * \sa igraph_get_adjacency_sparse if you want a sparse matrix representation
 *
 * Time complexity: O(|V||V|),
 * |V| is the
 * number of vertices in the graph.
 */

int igraph_get_adjacency(const igraph_t *graph, igraph_matrix_t *res,
                         igraph_get_adjacency_t type, igraph_bool_t eids) {

    igraph_eit_t edgeit;
    long int no_of_nodes = igraph_vcount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    int retval = 0;
    long int from, to;
    igraph_integer_t ffrom, fto;

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, no_of_nodes));
    igraph_matrix_null(res);
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    if (directed) {
        while (!IGRAPH_EIT_END(edgeit)) {
            long int edge = IGRAPH_EIT_GET(edgeit);
            igraph_edge(graph, (igraph_integer_t) edge, &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (eids) {
                MATRIX(*res, from, to) = edge + 1;
            } else {
                MATRIX(*res, from, to) += 1;
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_UPPER) {
        while (!IGRAPH_EIT_END(edgeit)) {
            long int edge = IGRAPH_EIT_GET(edgeit);
            igraph_edge(graph, (igraph_integer_t) edge, &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (to < from) {
                if (eids) {
                    MATRIX(*res, to, from) = edge + 1;
                } else {
                    MATRIX(*res, to, from) += 1;
                }
            } else {
                if (eids) {
                    MATRIX(*res, from, to) = edge + 1;
                } else {
                    MATRIX(*res, from, to) += 1;
                }
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_LOWER) {
        while (!IGRAPH_EIT_END(edgeit)) {
            long int edge = IGRAPH_EIT_GET(edgeit);
            igraph_edge(graph, (igraph_integer_t) edge, &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (to < from) {
                if (eids) {
                    MATRIX(*res, from, to) = edge + 1;
                } else {
                    MATRIX(*res, from, to) += 1;
                }
            } else {
                if (eids) {
                    MATRIX(*res, to, from) = edge + 1;
                } else {
                    MATRIX(*res, to, from) += 1;
                }
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_BOTH) {
        while (!IGRAPH_EIT_END(edgeit)) {
            long int edge = IGRAPH_EIT_GET(edgeit);
            igraph_edge(graph, (igraph_integer_t) edge, &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (eids) {
                MATRIX(*res, from, to) = edge + 1;
            } else {
                MATRIX(*res, from, to) += 1;
            }
            if (from != to) {
                if (eids) {
                    MATRIX(*res, to, from) = edge + 1;
                } else {
                    MATRIX(*res, to, from) += 1;
                }
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else {
        IGRAPH_ERROR("Invalid type argument", IGRAPH_EINVAL);
    }

    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(1);
    return retval;
}

/**
 * \ingroup conversion
 * \function igraph_get_adjacency_sparse
 * \brief Returns the adjacency matrix of a graph in sparse matrix format.
 *
 * 
 * The result is an adjacency matrix. Entry i, j of the matrix
 * contains the number of edges connecting vertex i to vertex j.
 * \param graph Pointer to the graph to convert.
 * \param res Pointer to an initialized sparse matrix object, it will be
 *        resized if needed.
 * \param type Constant giving the type of the adjacency matrix to
 *        create for undirected graphs. It is ignored for directed
 *        graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_GET_ADJACENCY_UPPER
 *          the upper right triangle of the matrix is used.
 *        \cli IGRAPH_GET_ADJACENCY_LOWER
 *          the lower left triangle of the matrix is used.
 *        \cli IGRAPH_GET_ADJACENCY_BOTH
 *          the whole matrix is used, a symmetric matrix is returned.
 *        \endclist
 * \return Error code:
 *        \c IGRAPH_EINVAL invalid type argument.
 *
 * \sa igraph_get_adjacency if you would like to get a normal matrix
 *   ( \type igraph_matrix_t )
 *
 * Time complexity: O(|V||V|),
 * |V| is the
 * number of vertices in the graph.
 */

int igraph_get_adjacency_sparse(const igraph_t *graph, igraph_spmatrix_t *res,
                                igraph_get_adjacency_t type) {

    igraph_eit_t edgeit;
    long int no_of_nodes = igraph_vcount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    long int from, to;
    igraph_integer_t ffrom, fto;

    igraph_spmatrix_null(res);
    IGRAPH_CHECK(igraph_spmatrix_resize(res, no_of_nodes, no_of_nodes));
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    if (directed) {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
            from = ffrom;
            to = fto;
            igraph_spmatrix_add_e(res, from, to, 1);
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_UPPER) {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (to < from) {
                igraph_spmatrix_add_e(res, to, from, 1);
            } else {
                igraph_spmatrix_add_e(res, from, to, 1);
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_LOWER) {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
            from = ffrom;
            to = fto;
            if (to > from) {
                igraph_spmatrix_add_e(res, to, from, 1);
            } else {
                igraph_spmatrix_add_e(res, from, to, 1);
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else if (type == IGRAPH_GET_ADJACENCY_BOTH) {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
            from = ffrom;
            to = fto;
            igraph_spmatrix_add_e(res, from, to, 1);
            if (from != to) {
                igraph_spmatrix_add_e(res, to, from, 1);
            }
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else {
        IGRAPH_ERROR("Invalid type argument.", IGRAPH_EINVAL);
    }

    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

/**
 * \ingroup conversion
 * \function igraph_get_edgelist
 * \brief Returns the list of edges in a graph
 *
 * The order of the edges is given by the edge ids.
 * \param graph Pointer to the graph object
 * \param res Pointer to an initialized vector object, it will be
 *        resized.
 * \param bycol Logical, if true, the edges will be returned
 *        columnwise, e.g. the first edge is
 *        res[0]->res[|E|], the second is
 *        res[1]->res[|E|+1], etc.
 * \return Error code.
 *
 * \sa \ref igraph_edges() to return the result only for some edge ids.
 *
 * Time complexity: O(|E|), the
 * number of edges in the graph.
 */

int igraph_get_edgelist(const igraph_t *graph, igraph_vector_t *res, igraph_bool_t bycol) {

    igraph_eit_t edgeit;
    long int no_of_edges = igraph_ecount(graph);
    long int vptr = 0;
    igraph_integer_t from, to;

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_edges * 2));
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
                                   &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    if (bycol) {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to);
            VECTOR(*res)[vptr] = from;
            VECTOR(*res)[vptr + no_of_edges] = to;
            vptr++;
            IGRAPH_EIT_NEXT(edgeit);
        }
    } else {
        while (!IGRAPH_EIT_END(edgeit)) {
            igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to);
            VECTOR(*res)[vptr++] = from;
            VECTOR(*res)[vptr++] = to;
            IGRAPH_EIT_NEXT(edgeit);
        }
    }

    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_to_directed
 * \brief Convert an undirected graph to a directed one
 *
 * 
 * If the supplied graph is directed, this function does nothing.
 * \param graph The graph object to convert.
 * \param mode Constant, specifies the details of how exactly the
 *        conversion is done. Possible values:
 *        \clist
 *        \cli IGRAPH_TO_DIRECTED_ARBITRARY
 *        The number of edges in the
 *        graph stays the same, an arbitrarily directed edge is
 *        created for each undirected edge.
 *        \cli IGRAPH_TO_DIRECTED_MUTUAL
 *        Two directed edges are
 *        created for each undirected edge, one in each direction.
 *        \cli IGRAPH_TO_DIRECTED_RANDOM
 *        Each undirected edge is converted to a randomly oriented
 *        directed one.
 *        \cli IGRAPH_TO_DIRECTED_ACYCLIC
 *        Each undirected edge is converted to a directed edge oriented
 *        from a lower index vertex to a higher index one. If no self-loops
 *        were present, then the result is a directed acyclic graph.
 *        \endclist
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 */

int igraph_to_directed(igraph_t *graph,
                       igraph_to_directed_t mode) {
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_nodes = igraph_vcount(graph);

    if (igraph_is_directed(graph)) {
        return IGRAPH_SUCCESS;
    }

    switch (mode) {
    case IGRAPH_TO_DIRECTED_ARBITRARY:
    case IGRAPH_TO_DIRECTED_RANDOM:
    case IGRAPH_TO_DIRECTED_ACYCLIC:
      {
        igraph_t newgraph;
        igraph_vector_t edges;
        long int size = no_of_edges * 2;
        long int i;

        IGRAPH_VECTOR_INIT_FINALLY(&edges, size);
        IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));

        if (mode == IGRAPH_TO_DIRECTED_RANDOM) {
            RNG_BEGIN();

            for (i=0; i < no_of_edges; ++i) {
                if (RNG_INTEGER(0,1)) {
                    igraph_real_t temp = VECTOR(edges)[2*i];
                    VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1];
                    VECTOR(edges)[2*i+1] = temp;
                }
            }

            RNG_END();
        } else if (mode == IGRAPH_TO_DIRECTED_ACYCLIC) {
            /* Currently, the endpoints of undirected edges are ordered in the
               internal graph datastructure, i.e. it is always true that from < to.
               However, it is not guaranteed that this will not be changed in
               the future, and this ordering should not be relied on outside of
               the implementation of the minimal API in type_indexededgelist.c.

               Therefore, we order the edge endpoints anyway in the following loop: */
            for (i=0; i < no_of_edges; ++i) {
                if (VECTOR(edges)[2*i] > VECTOR(edges)[2*i+1]) {
                    igraph_real_t temp = VECTOR(edges)[2*i];
                    VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1];
                    VECTOR(edges)[2*i+1] = temp;
                }
            }
        }

        IGRAPH_CHECK(igraph_create(&newgraph, &edges,
                                   (igraph_integer_t) no_of_nodes,
                                   IGRAPH_DIRECTED));
        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
        IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1, 1);
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(2);

        igraph_destroy(graph);
        *graph = newgraph;

        break;
      }
    case IGRAPH_TO_DIRECTED_MUTUAL:
      {
        igraph_t newgraph;
        igraph_vector_t edges;
        igraph_vector_t index;
        long int size = no_of_edges * 4;
        long int i;
        IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
        IGRAPH_CHECK(igraph_vector_reserve(&edges, size));
        IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
        IGRAPH_CHECK(igraph_vector_resize(&edges, no_of_edges * 4));
        IGRAPH_VECTOR_INIT_FINALLY(&index, no_of_edges * 2);
        for (i = 0; i < no_of_edges; i++) {
            VECTOR(edges)[no_of_edges * 2 + i * 2]  = VECTOR(edges)[i * 2 + 1];
            VECTOR(edges)[no_of_edges * 2 + i * 2 + 1] = VECTOR(edges)[i * 2];
            VECTOR(index)[i] = VECTOR(index)[no_of_edges + i] = i;
        }

        IGRAPH_CHECK(igraph_create(&newgraph, &edges,
                                   (igraph_integer_t) no_of_nodes,
                                   IGRAPH_DIRECTED));
        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
        IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1,/*edges=*/0);
        IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, &newgraph, &index));

        igraph_vector_destroy(&index);
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(3);

        igraph_destroy(graph);
        *graph = newgraph;

        break;
      }
    default:
        IGRAPH_ERROR("Cannot direct graph, invalid mode", IGRAPH_EINVAL);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_to_undirected
 * \brief Convert a directed graph to an undirected one.
 *
 * 
 * If the supplied graph is undirected, this function does nothing.
 *
 * \param graph The graph object to convert.
 * \param mode Constant, specifies the details of how exactly the
 *        conversion is done. Possible values: \c
 *        IGRAPH_TO_UNDIRECTED_EACH: the number of edges remains
 *        constant, an undirected edge is created for each directed
 *        one, this version might create graphs with multiple edges;
 *        \c IGRAPH_TO_UNDIRECTED_COLLAPSE: one undirected edge will
 *        be created for each pair of vertices that are connected
 *        with at least one directed edge, no multiple edges will be
 *        created. \c IGRAPH_TO_UNDIRECTED_MUTUAL creates an undirected
 *        edge for each pair of mutual edges in the directed graph.
 *        Non-mutual edges are lost; loop edges are kept unconditionally.
 *        This mode might create multiple edges.
 * \param edge_comb What to do with the edge attributes. See the igraph
 *        manual section about attributes for details. \c NULL means that
 *        the edge attributes are lost during the conversion, \em except
 *        when \c mode is \c IGRAPH_TO_UNDIRECTED_EACH, in which case the
 *        edge attributes are kept intact.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 *
 * \example examples/simple/igraph_to_undirected.c
 */

int igraph_to_undirected(igraph_t *graph,
                         igraph_to_undirected_t mode,
                         const igraph_attribute_combination_t *edge_comb) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t edges;
    igraph_t newgraph;
    igraph_bool_t attr = edge_comb && igraph_has_attribute_table();

    if (mode != IGRAPH_TO_UNDIRECTED_EACH &&
        mode != IGRAPH_TO_UNDIRECTED_COLLAPSE &&
        mode != IGRAPH_TO_UNDIRECTED_MUTUAL) {
        IGRAPH_ERROR("Cannot undirect graph, invalid mode", IGRAPH_EINVAL);
    }

    if (!igraph_is_directed(graph)) {
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);

    if (mode == IGRAPH_TO_UNDIRECTED_EACH) {
        igraph_es_t es;
        igraph_eit_t eit;

        IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));
        IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
        IGRAPH_FINALLY(igraph_es_destroy, &es);
        IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
        IGRAPH_FINALLY(igraph_eit_destroy, &eit);

        while (!IGRAPH_EIT_END(eit)) {
            long int edge = IGRAPH_EIT_GET(eit);
            igraph_integer_t from, to;
            igraph_edge(graph, (igraph_integer_t) edge, &from, &to);
            IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
            IGRAPH_EIT_NEXT(eit);
        }

        igraph_eit_destroy(&eit);
        igraph_es_destroy(&es);
        IGRAPH_FINALLY_CLEAN(2);

        IGRAPH_CHECK(igraph_create(&newgraph, &edges,
                                   (igraph_integer_t) no_of_nodes,
                                   IGRAPH_UNDIRECTED));
        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        igraph_vector_destroy(&edges);
        IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
        IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1, 1);
        IGRAPH_FINALLY_CLEAN(2);
        igraph_destroy(graph);
        *graph = newgraph;

    } else if (mode == IGRAPH_TO_UNDIRECTED_COLLAPSE) {
        igraph_vector_t inadj, outadj;
        long int i;
        igraph_vector_t mergeinto;
        long int actedge = 0;

        if (attr) {
            IGRAPH_VECTOR_INIT_FINALLY(&mergeinto, no_of_edges);
        }

        IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));
        IGRAPH_VECTOR_INIT_FINALLY(&inadj, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&outadj, 0);

        for (i = 0; i < no_of_nodes; i++) {
            long int n_out, n_in;
            long int p1 = -1, p2 = -1;
            long int e1 = 0, e2 = 0, n1 = 0, n2 = 0, last;
            IGRAPH_CHECK(igraph_incident(graph, &outadj, (igraph_integer_t) i,
                                         IGRAPH_OUT));
            IGRAPH_CHECK(igraph_incident(graph, &inadj, (igraph_integer_t) i,
                                         IGRAPH_IN));
            n_out = igraph_vector_size(&outadj);
            n_in = igraph_vector_size(&inadj);

#define STEPOUT() if ( (++p1) < n_out) {    \
        e1 = (long int) VECTOR(outadj)[p1]; \
        n1 = IGRAPH_TO(graph, e1);      \
    }
#define STEPIN()  if ( (++p2) < n_in) {         \
        e2 = (long int) VECTOR(inadj )[p2]; \
        n2 = IGRAPH_FROM(graph, e2);        \
    }
#define ADD_NEW_EDGE() { \
    IGRAPH_CHECK(igraph_vector_push_back(&edges, i)); \
    IGRAPH_CHECK(igraph_vector_push_back(&edges, last)); \
}
#define MERGE_INTO_CURRENT_EDGE(which) { \
    if (attr) { \
        VECTOR(mergeinto)[which] = actedge; \
    } \
}

            STEPOUT();
            STEPIN();

            while (p1 < n_out && n1 <= i && p2 < n_in && n2 <= i) {
                last = (n1 <= n2) ? n1 : n2;
                ADD_NEW_EDGE();
                while (p1 < n_out && last == n1) {
                    MERGE_INTO_CURRENT_EDGE(e1);
                    STEPOUT();
                }
                while (p2 < n_in && last == n2) {
                    MERGE_INTO_CURRENT_EDGE(e2);
                    STEPIN();
                }
                actedge++;
            }

            while (p1 < n_out && n1 <= i) {
                last = n1;
                ADD_NEW_EDGE();
                while (p1 < n_out && last == n1) {
                    MERGE_INTO_CURRENT_EDGE(e1);
                    STEPOUT();
                }
                actedge++;
            }

            while (p2 < n_in && n2 <= i) {
                last = n2;
                ADD_NEW_EDGE();
                while (p2 < n_in && last == n2) {
                    MERGE_INTO_CURRENT_EDGE(e2);
                    STEPIN();
                }
                actedge++;
            }
        }

#undef MERGE_INTO_CURRENT_EDGE
#undef ADD_NEW_EDGE
#undef STEPOUT
#undef STEPIN

        igraph_vector_destroy(&outadj);
        igraph_vector_destroy(&inadj);
        IGRAPH_FINALLY_CLEAN(2);

        IGRAPH_CHECK(igraph_create(&newgraph, &edges,
                                   (igraph_integer_t) no_of_nodes,
                                   IGRAPH_UNDIRECTED));
        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        igraph_vector_destroy(&edges);
        IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
        IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1, 0); /* no edge attributes */

        if (attr) {
            igraph_fixed_vectorlist_t vl;
            IGRAPH_CHECK(igraph_fixed_vectorlist_convert(&vl, &mergeinto,
                         actedge));
            IGRAPH_FINALLY(igraph_fixed_vectorlist_destroy, &vl);

            IGRAPH_CHECK(igraph_i_attribute_combine_edges(graph, &newgraph, &vl.v,
                         edge_comb));

            igraph_fixed_vectorlist_destroy(&vl);
            IGRAPH_FINALLY_CLEAN(1);
        }

        IGRAPH_FINALLY_CLEAN(2);
        igraph_destroy(graph);
        *graph = newgraph;

        if (attr) {
            igraph_vector_destroy(&mergeinto);
            IGRAPH_FINALLY_CLEAN(1);
        }
    } else if (mode == IGRAPH_TO_UNDIRECTED_MUTUAL) {
        igraph_vector_t inadj, outadj;
        long int i;
        igraph_vector_t mergeinto;
        long int actedge = 0;

        if (attr) {
            IGRAPH_VECTOR_INIT_FINALLY(&mergeinto, no_of_edges);
            igraph_vector_fill(&mergeinto, -1);
        }

        IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));
        IGRAPH_VECTOR_INIT_FINALLY(&inadj, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&outadj, 0);

        for (i = 0; i < no_of_nodes; i++) {
            long int n_out, n_in;
            long int p1 = -1, p2 = -1;
            long int e1 = 0, e2 = 0, n1 = 0, n2 = 0;
            IGRAPH_CHECK(igraph_incident(graph, &outadj, (igraph_integer_t) i,
                                         IGRAPH_OUT));
            IGRAPH_CHECK(igraph_incident(graph, &inadj,  (igraph_integer_t) i,
                                         IGRAPH_IN));
            n_out = igraph_vector_size(&outadj);
            n_in = igraph_vector_size(&inadj);

#define STEPOUT() if ( (++p1) < n_out) {    \
        e1 = (long int) VECTOR(outadj)[p1]; \
        n1 = IGRAPH_TO(graph, e1);      \
    }
#define STEPIN()  if ( (++p2) < n_in) {         \
        e2 = (long int) VECTOR(inadj )[p2]; \
        n2 = IGRAPH_FROM(graph, e2);        \
    }

            STEPOUT();
            STEPIN();

            while (p1 < n_out && n1 <= i && p2 < n_in && n2 <= i) {
                if (n1 == n2) {
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, n1));
                    if (attr) {
                        VECTOR(mergeinto)[e1] = actedge;
                        VECTOR(mergeinto)[e2] = actedge;
                        actedge++;
                    }
                    STEPOUT();
                    STEPIN();
                } else if (n1 < n2) {
                    STEPOUT();
                } else { /* n2= 2 vertices can be represented by a
 * sequence of n-2 integers, each between 0 and n-1 (inclusive).
 *
 * \param graph Pointer to an initialized graph object which
          must be a tree on n >= 2 vertices.
 * \param prufer A pointer to the integer vector that should hold the Prüfer sequence;
                 the vector must be initialized and will be resized to n - 2.
 * \return Error code:
 *          \clist
 *          \cli IGRAPH_ENOMEM
 *             there is not enough memory to perform the operation.
 *          \cli IGRAPH_EINVAL
 *             the graph is not a tree or it is has less than vertices
 *          \endclist
 *
 * \sa \ref igraph_from_prufer()
 *
 */
int igraph_to_prufer(const igraph_t *graph, igraph_vector_int_t* prufer) {
    /* For generating the Prüfer sequence, we enumerate the vertices u of the tree.
       We keep track of the degrees of all vertices, treating vertices
       of degree 0 as removed. We maintain the invariant that all leafs
       that are still contained in the tree are >= u.
       If u is a leaf, we remove it and add its unique neighbor to the prüfer
       sequence. If the removal of u turns the neighbor into a leaf which is < u,
       we repeat the procedure for the new leaf and so on. */
    igraph_integer_t u;
    igraph_vector_t degrees, neighbors;
    igraph_integer_t prufer_index = 0;
    igraph_integer_t n = igraph_vcount(graph);
    igraph_bool_t is_tree = 0;

    IGRAPH_CHECK(igraph_is_tree(graph, &is_tree, NULL, IGRAPH_ALL));

    if (!is_tree) {
        IGRAPH_ERROR("The graph must be a tree", IGRAPH_EINVAL);
    }

    if (n < 2) {
        IGRAPH_ERROR("The tree must have at least 2 vertices", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_int_resize(prufer, n - 2));
    IGRAPH_VECTOR_INIT_FINALLY(°rees, n);
    IGRAPH_VECTOR_INIT_FINALLY(&neighbors, 1);

    IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), IGRAPH_ALL, IGRAPH_NO_LOOPS));

    for (u = 0; u < n; ++u) {
        igraph_integer_t degree = VECTOR(degrees)[u];
        igraph_integer_t leaf = u;

        while (degree == 1 && leaf <= u) {
            igraph_integer_t i;
            igraph_integer_t neighbor = 0;
            igraph_integer_t neighbor_count = 0;

            VECTOR(degrees)[leaf] = 0; /* mark leaf v as deleted */

            IGRAPH_CHECK(igraph_neighbors(graph, &neighbors, leaf, IGRAPH_ALL));

            /* Find the unique remaining neighbor of the leaf */
            neighbor_count = igraph_vector_size(&neighbors);
            for (i = 0; i < neighbor_count; i++) {
                neighbor = VECTOR(neighbors)[i];
                if (VECTOR(degrees)[neighbor] > 0) {
                    break;
                }
            }

            /* remember that we have removed the leaf */
            VECTOR(degrees)[neighbor]--;
            degree = VECTOR(degrees)[neighbor];

            /* Add the neighbor to the prufer sequence unless it is the last vertex
            (i.e. degree == 0) */
            if (degree > 0) {
                VECTOR(*prufer)[prufer_index] = neighbor;
                prufer_index++;
            }
            leaf = neighbor;
        }
    }

    igraph_vector_destroy(°rees);
    igraph_vector_destroy(&neighbors);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/conversion_internal.h0000644000175100001710000000177000000000000025633 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_MISC_CONVERSION_INTERNAL_H
#define IGRAPH_MISC_CONVERSION_INTERNAL_H

#include "igraph_sparsemat.h"
#include "igraph_types.h"

int igraph_i_normalize_sparsemat(igraph_sparsemat_t *sparsemat,
                                 igraph_bool_t column_wise);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/degree_sequence.cpp0000644000175100001710000006700500000000000025233 0ustar00runnerdocker00000000000000/*
  IGraph library.
  Constructing realizations of degree sequences and bi-degree sequences.
  Copyright (C) 2018-2020  The igraph development team 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see .
*/

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include 
#include 
#include 
#include 

#define IGRAPH_I_MULTI_EDGES_SW 0x02 /* 010, more than one edge allowed between distinct vertices */
#define IGRAPH_I_MULTI_LOOPS_SW 0x04 /* 100, more than one self-loop allowed on the same vertex   */

/******************************/
/***** Helper constructs ******/
/******************************/

// (vertex, degree) pair
struct vd_pair {
    long vertex;
    igraph_integer_t degree;

    vd_pair(long vertex, igraph_integer_t degree) : vertex(vertex), degree(degree) {}
};

// (indegree, outdegree)
typedef std::pair bidegree;

// (vertex, bidegree) pair
struct vbd_pair {
    long vertex;
    bidegree degree;

    vbd_pair(long vertex, bidegree degree) : vertex(vertex), degree(degree) {}
};

// Comparison function for vertex-degree pairs.
// Also used for lexicographic sorting of bi-degrees.
template inline bool degree_greater(const T &a, const T &b) {
    return a.degree > b.degree;
}

template inline bool degree_less(const T &a, const T &b) {
    return a.degree < b.degree;
}


/*************************************/
/***** Undirected simple graphs ******/
/*************************************/

// Generate simple undirected realization as edge-list.
// If largest=true, always choose the vertex with the largest remaining degree to connect up next.
// Otherwise, always choose the one with the smallest remaining degree.
static int igraph_i_havel_hakimi(const igraph_vector_t *deg, igraph_vector_t *edges, bool largest) {
    long n = igraph_vector_size(deg);

    long ec = 0; // number of edges added so far

    std::vector vertices;
    vertices.reserve(n);
    for (int i = 0; i < n; ++i) {
        vertices.push_back(vd_pair(i, VECTOR(*deg)[i]));
    }

    while (! vertices.empty()) {
        if (largest) {
            std::stable_sort(vertices.begin(), vertices.end(), degree_less);
        } else {
            std::stable_sort(vertices.begin(), vertices.end(), degree_greater);
        }

        // take the next vertex to be connected up
        vd_pair vd = vertices.back();
        vertices.pop_back();

        if (vd.degree == 0) {
            continue;
        }

        if (vertices.size() < size_t(vd.degree)) {
            goto fail;
        }

        if (largest) {
            for (int i = 0; i < vd.degree; ++i) {
                if (--(vertices[vertices.size() - 1 - i].degree) < 0) {
                    goto fail;
                }

                VECTOR(*edges)[2 * (ec + i)] = vd.vertex;
                VECTOR(*edges)[2 * (ec + i) + 1] = vertices[vertices.size() - 1 - i].vertex;
            }
        } else {
            // this loop can only be reached if all zero-degree nodes have already been removed
            // therefore decrementing remaining degrees is safe
            for (int i = 0; i < vd.degree; ++i) {
                vertices[i].degree--;

                VECTOR(*edges)[2 * (ec + i)] = vd.vertex;
                VECTOR(*edges)[2 * (ec + i) + 1] = vertices[i].vertex;
            }
        }

        ec += vd.degree;
    }

    return IGRAPH_SUCCESS;

fail:
    IGRAPH_ERROR("The given degree sequence cannot be realized as a simple graph.", IGRAPH_EINVAL);
}


// Choose vertices in the order of their IDs.
static int igraph_i_havel_hakimi_index(const igraph_vector_t *deg, igraph_vector_t *edges) {
    long n = igraph_vector_size(deg);

    long ec = 0; // number of edges added so far

    typedef std::list vlist;
    vlist vertices;
    for (int i = 0; i < n; ++i) {
        vertices.push_back(vd_pair(i, VECTOR(*deg)[i]));
    }

    std::vector pointers;
    pointers.reserve(n);
    for (vlist::iterator it = vertices.begin(); it != vertices.end(); ++it) {
        pointers.push_back(it);
    }

    for (std::vector::iterator pt = pointers.begin(); pt != pointers.end(); ++pt) {
        vertices.sort(degree_greater);

        vd_pair vd = **pt;
        vertices.erase(*pt);

        if (vd.degree == 0) {
            continue;
        }

        int k;
        vlist::iterator it;
        for (it = vertices.begin(), k = 0;
             k != vd.degree && it != vertices.end();
             ++it, ++k) {
            if (--(it->degree) < 0) {
                goto fail;
            }

            VECTOR(*edges)[2 * (ec + k)] = vd.vertex;
            VECTOR(*edges)[2 * (ec + k) + 1] = it->vertex;
        }
        if (it == vertices.end() && k < vd.degree) {
            goto fail;
        }

        ec += vd.degree;
    }

    return IGRAPH_SUCCESS;

fail:
    IGRAPH_ERROR("The given degree sequence cannot be realized as a simple graph.", IGRAPH_EINVAL);
}


/***********************************/
/***** Undirected multigraphs ******/
/***********************************/

// Given a sequence that is sorted, except for its first element,
// move the first element to the correct position fully sort the sequence.
template
static void bubble_up(It first, It last, Compare comp) {
    if (first == last)
        return;
    It it = first;
    it++;
    while (it != last) {
        if (comp(*first, *it)) {
            break;
        } else {
            std::swap(*first, *it);
        }
        first = it;
        it++;
    }
}

// In each step, choose a vertex (the largest degree one if largest=true,
// the smallest degree one otherwise) and connect it to the largest remaining degree vertex.
// This will create a connected loopless multigraph, if one exists.
// If loops=true, and a loopless multigraph does not exist, complete the procedure
// by adding loops on the last vertex.
// If largest=false, and the degree sequence was potentially connected, the resulting
// graph will be connected.
static int igraph_i_realize_undirected_multi(const igraph_vector_t *deg, igraph_vector_t *edges, bool loops, bool largest) {
    long vcount = igraph_vector_size(deg);

    if (vcount == 0)
        return IGRAPH_SUCCESS;

    std::vector vertices;
    vertices.reserve(vcount);
    for (int i = 0; i < vcount; ++i) {
        long d = VECTOR(*deg)[i];
        vertices.push_back(vd_pair(i, d));
    }

    // Initial sort in non-increasing order.
    std::stable_sort(vertices.begin(), vertices.end(), degree_greater);

    long ec = 0;
    while (! vertices.empty()) {
        // Remove any zero degrees, and error on negative ones.

        vd_pair &w = vertices.back();

        if (w.degree == 0) {
            vertices.pop_back();
            continue;
        }

        // If only one vertex remains, then the degree sequence cannot be realized as
        // a loopless multigraph. We either complete the graph by adding loops on this vertex
        // or throw an error, depending on the 'loops' setting.
        if (vertices.size() == 1) {
            if (loops) {
                for (long i=0; i < w.degree/2; ++i) {
                    VECTOR(*edges)[2*ec]   = w.vertex;
                    VECTOR(*edges)[2*ec+1] = w.vertex;
                    ec++;
                }
                break;
            } else {
                IGRAPH_ERROR("The given degree sequence cannot be realized as a loopless multigraph.", IGRAPH_EINVAL);
            }
        }

        // At this point we are guaranteed to have at least two remaining vertices.

        vd_pair *u, *v;
        if (largest) {
            u = &vertices[0];
            v = &vertices[1];
        } else {
            u = &vertices.front();
            v = &vertices.back();
        }

        u->degree -= 1;
        v->degree -= 1;

        VECTOR(*edges)[2*ec]   = u->vertex;
        VECTOR(*edges)[2*ec+1] = v->vertex;
        ec++;

        // Now the first element may be out of order.
        // If largest=true, the first two elements may be out of order.
        // Restore the sorted order using a single step of bubble sort.
        if (largest) {
            bubble_up(vertices.begin()+1, vertices.end(), degree_greater);
        }
        bubble_up(vertices.begin(), vertices.end(), degree_greater);
    }

    return IGRAPH_SUCCESS;
}


static int igraph_i_realize_undirected_multi_index(const igraph_vector_t *deg, igraph_vector_t *edges, bool loops) {
    long vcount = igraph_vector_size(deg);

    if (vcount == 0)
        return IGRAPH_SUCCESS;

    typedef std::list vlist;
    vlist vertices;
    for (int i = 0; i < vcount; ++i) {
        vertices.push_back(vd_pair(i, VECTOR(*deg)[i]));
    }

    std::vector pointers;
    pointers.reserve(vcount);
    for (vlist::iterator it = vertices.begin(); it != vertices.end(); ++it) {
        pointers.push_back(it);
    }

    // Initial sort
    vertices.sort(degree_greater);

    long ec = 0;
    for (std::vector::iterator pt = pointers.begin(); pt != pointers.end(); ++pt) {
        vd_pair vd = **pt;
        vertices.erase(*pt);

        while (vd.degree > 0) {
            vlist::iterator uit = vertices.begin();

            if (vertices.empty() || uit->degree == 0) {
                // We are out of non-zero degree vertices to connect to.
                if (loops) {
                    for (long i=0; i < vd.degree/2; ++i) {
                        VECTOR(*edges)[2*ec]   = vd.vertex;
                        VECTOR(*edges)[2*ec+1] = vd.vertex;
                        ec++;
                    }
                    return IGRAPH_SUCCESS;
                } else {
                    IGRAPH_ERROR("The given degree sequence cannot be realized as a loopless multigraph.", IGRAPH_EINVAL);
                }
            }

            vd.degree   -= 1;
            uit->degree -= 1;

            VECTOR(*edges)[2*ec]   = vd.vertex;
            VECTOR(*edges)[2*ec+1] = uit->vertex;
            ec++;

            // If there are at least two elements, and the first two are not in order,
            // re-sort the list. A possible optimization would be a version of
            // bubble_up() that can exchange list nodes instead of swapping their values.
            if (vertices.size() > 1) {
                vlist::iterator wit = uit;
                ++wit;

                if (wit->degree > uit->degree) {
                    vertices.sort(degree_greater);
                }
            }
        }
    }

    return IGRAPH_SUCCESS;
}


/***********************************/
/***** Directed simple graphs ******/
/***********************************/

inline bool is_nonzero_outdeg(const vbd_pair &vd) {
    return (vd.degree.second != 0);
}


// The below implementations of the Kleitman-Wang algorithm follow the description in https://arxiv.org/abs/0905.4913

// Realize bi-degree sequence as edge list
// If smallest=true, always choose the vertex with "smallest" bi-degree for connecting up next,
// otherwise choose the "largest" (based on lexicographic bi-degree ordering).
static int igraph_i_kleitman_wang(const igraph_vector_t *outdeg, const igraph_vector_t *indeg, igraph_vector_t *edges, bool smallest) {
    long n = igraph_vector_size(indeg); // number of vertices

    long ec = 0; // number of edges added so far

    std::vector vertices;
    vertices.reserve(n);
    for (int i = 0; i < n; ++i) {
        vertices.push_back(vbd_pair(i, bidegree(VECTOR(*indeg)[i], VECTOR(*outdeg)[i])));
    }

    while (true) {
        // sort vertices by (in, out) degree pairs in decreasing order
        std::stable_sort(vertices.begin(), vertices.end(), degree_greater);

        // remove (0,0)-degree vertices
        while (!vertices.empty() && vertices.back().degree == bidegree(0, 0)) {
            vertices.pop_back();
        }

        // if no vertices remain, stop
        if (vertices.empty()) {
            break;
        }

        // choose a vertex the out-stubs of which will be connected
        // note: a vertex with non-zero out-degree is guaranteed to exist
        // because there are _some_ non-zero degrees and the sum of in- and out-degrees
        // is the same
        vbd_pair *vdp;
        if (smallest) {
            vdp = &*std::find_if(vertices.rbegin(), vertices.rend(), is_nonzero_outdeg);
        } else {
            vdp = &*std::find_if(vertices.begin(), vertices.end(), is_nonzero_outdeg);
        }

        // are there a sufficient number of other vertices to connect to?
        if (static_cast(vertices.size()) - 1 < vdp->degree.second) {
            goto fail;
        }

        // create the connections
        int k = 0;
        for (std::vector::iterator it = vertices.begin();
             k < vdp->degree.second;
             ++it) {
            if (it->vertex == vdp->vertex) {
                continue;    // do not create a self-loop
            }
            if (--(it->degree.first) < 0) {
                goto fail;
            }

            VECTOR(*edges)[2 * (ec + k)] = vdp->vertex;
            VECTOR(*edges)[2 * (ec + k) + 1] = it->vertex;

            k++;
        }

        ec += vdp->degree.second;
        vdp->degree.second = 0;
    }

    return IGRAPH_SUCCESS;

fail:
    IGRAPH_ERROR("The given directed degree sequences cannot be realized as a simple graph.", IGRAPH_EINVAL);
}


// Choose vertices in the order of their IDs.
static int igraph_i_kleitman_wang_index(const igraph_vector_t *outdeg, const igraph_vector_t *indeg, igraph_vector_t *edges) {
    long n = igraph_vector_size(indeg); // number of vertices

    long ec = 0; // number of edges added so far

    typedef std::list vlist;
    vlist vertices;
    for (int i = 0; i < n; ++i) {
        vertices.push_back(vbd_pair(i, bidegree(VECTOR(*indeg)[i], VECTOR(*outdeg)[i])));
    }

    std::vector pointers;
    pointers.reserve(n);
    for (vlist::iterator it = vertices.begin(); it != vertices.end(); ++it) {
        pointers.push_back(it);
    }

    for (std::vector::iterator pt = pointers.begin(); pt != pointers.end(); ++pt) {
        // sort vertices by (in, out) degree pairs in decreasing order
        // note: std::list::sort does a stable sort
        vertices.sort(degree_greater);

        // choose a vertex the out-stubs of which will be connected
        vbd_pair &vd = **pt;

        if (vd.degree.second == 0) {
            continue;
        }

        int k = 0;
        vlist::iterator it;
        for (it = vertices.begin();
             k != vd.degree.second && it != vertices.end();
             ++it) {
            if (it->vertex == vd.vertex) {
                continue;
            }

            if (--(it->degree.first) < 0) {
                goto fail;
            }

            VECTOR(*edges)[2 * (ec + k)] = vd.vertex;
            VECTOR(*edges)[2 * (ec + k) + 1] = it->vertex;

            ++k;
        }
        if (it == vertices.end() && k < vd.degree.second) {
            goto fail;
        }

        ec += vd.degree.second;
        vd.degree.second = 0;
    }

    return IGRAPH_SUCCESS;

fail:
    IGRAPH_ERROR("The given directed degree sequences cannot be realized as a simple graph.", IGRAPH_EINVAL);
}


/**************************/
/***** Main functions *****/
/**************************/

static int igraph_i_realize_undirected_degree_sequence(
        igraph_t *graph,
        const igraph_vector_t *deg,
        igraph_edge_type_sw_t allowed_edge_types,
        igraph_realize_degseq_t method)
{
    long node_count = igraph_vector_size(deg);
    long deg_sum = long(igraph_vector_sum(deg));

    if (deg_sum % 2 != 0) {
        IGRAPH_ERROR("The sum of degrees must be even for an undirected graph.", IGRAPH_EINVAL);
    }

    if (node_count > 0 && igraph_vector_min(deg) < 0) {
        IGRAPH_ERROR("Vertex degrees must be non-negative.", IGRAPH_EINVAL);
    }

    igraph_vector_t edges;
    IGRAPH_CHECK(igraph_vector_init(&edges, deg_sum));
    IGRAPH_FINALLY(igraph_vector_destroy, &edges);

    if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) && (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW ) )
    {
        switch (method) {
        case IGRAPH_REALIZE_DEGSEQ_SMALLEST:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi(deg, &edges, true, false));
            break;
        case IGRAPH_REALIZE_DEGSEQ_LARGEST:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi(deg, &edges, true, true));
            break;
        case IGRAPH_REALIZE_DEGSEQ_INDEX:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi_index(deg, &edges, true));
            break;
        default:
            IGRAPH_ERROR("Invalid degree sequence realization method.", IGRAPH_EINVAL);
        }
    }
    else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) )
    {
        switch (method) {
        case IGRAPH_REALIZE_DEGSEQ_SMALLEST:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi(deg, &edges, false, false));
            break;
        case IGRAPH_REALIZE_DEGSEQ_LARGEST:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi(deg, &edges, false, true));
            break;
        case IGRAPH_REALIZE_DEGSEQ_INDEX:
            IGRAPH_CHECK(igraph_i_realize_undirected_multi_index(deg, &edges, false));
            break;
        default:
            IGRAPH_ERROR("Invalid degree sequence realization method.", IGRAPH_EINVAL);
        }
    }
    else if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) )
    {
        IGRAPH_ERROR("Graph realization with at most one self-loop per vertex is not implemented.", IGRAPH_UNIMPLEMENTED);
    }
    else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) )
    {
        switch (method) {
        case IGRAPH_REALIZE_DEGSEQ_SMALLEST:
            IGRAPH_CHECK(igraph_i_havel_hakimi(deg, &edges, false));
            break;
        case IGRAPH_REALIZE_DEGSEQ_LARGEST:
            IGRAPH_CHECK(igraph_i_havel_hakimi(deg, &edges, true));
            break;
        case IGRAPH_REALIZE_DEGSEQ_INDEX:
            IGRAPH_CHECK(igraph_i_havel_hakimi_index(deg, &edges));
            break;
        default:
            IGRAPH_ERROR("Invalid degree sequence realization method.", IGRAPH_EINVAL);
        }
    }
    else
    {
        /* Remainig cases:
         *  - At most one self-loop per vertex but multi-edges between distinct vertices allowed.
         *  - At most one edge between distinct vertices but multi-self-loops allowed.
         * These cases cannot currently be requested through the documented API,
         * so no explanatory error message for now. */
        return IGRAPH_UNIMPLEMENTED;
    }

    igraph_create(graph, &edges, igraph_integer_t(node_count), false);

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


static int igraph_i_realize_directed_degree_sequence(
        igraph_t *graph,
        const igraph_vector_t *outdeg,
        const igraph_vector_t *indeg,
        igraph_edge_type_sw_t allowed_edge_types,
        igraph_realize_degseq_t method)
{
    long node_count = igraph_vector_size(outdeg);
    long edge_count = long(igraph_vector_sum(outdeg));

    if (igraph_vector_size(indeg) != node_count) {
        IGRAPH_ERROR("In- and out-degree sequences must have the same length.", IGRAPH_EINVAL);
    }
    if (igraph_vector_sum(indeg) != edge_count) {
        IGRAPH_ERROR("In- and out-degree sequences do not sum to the same value.", IGRAPH_EINVAL);
    }

    if (node_count > 0 && (igraph_vector_min(outdeg) < 0 || igraph_vector_min(indeg) < 0)) {
        IGRAPH_ERROR("Vertex degrees must be non-negative.", IGRAPH_EINVAL);
    }

    /* TODO implement loopless and loopy multigraph case */
    if (allowed_edge_types != IGRAPH_SIMPLE_SW) {
        IGRAPH_ERROR("Realizing directed degree sequences as non-simple graphs is not implemented.", IGRAPH_UNIMPLEMENTED);
    }

    igraph_vector_t edges;
    IGRAPH_CHECK(igraph_vector_init(&edges, 2 * edge_count));
    IGRAPH_FINALLY(igraph_vector_destroy, &edges);

    switch (method) {
    case IGRAPH_REALIZE_DEGSEQ_SMALLEST:
        IGRAPH_CHECK(igraph_i_kleitman_wang(outdeg, indeg, &edges, true));
        break;
    case IGRAPH_REALIZE_DEGSEQ_LARGEST:
        IGRAPH_CHECK(igraph_i_kleitman_wang(outdeg, indeg, &edges, false));
        break;
    case IGRAPH_REALIZE_DEGSEQ_INDEX:
        IGRAPH_CHECK(igraph_i_kleitman_wang_index(outdeg, indeg, &edges));
        break;
    default:
        IGRAPH_ERROR("Invalid directed degree sequence realization method.", IGRAPH_EINVAL);
    }

    igraph_create(graph, &edges, igraph_integer_t(node_count), true);

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup generators
 * \function igraph_realize_degree_sequence
 * \brief Generates a graph with the given degree sequence.
 *
 * This function generates an undirected graph that realizes a given degree sequence,
 * or a directed graph that realized a given pair of out- and in-degree sequences.
 *
 * 
 * Simple undirected graphs are constructed using the Havel-Hakimi algorithm
 * (undirected case), or the analogous Kleitman-Wang algorithm (directed case).
 * These algorithms work by choosing an arbitrary vertex and connecting all its stubs
 * to other vertices of highest degree.  In the directed case, the "highest" (in, out) degree
 * pairs are determined based on lexicographic ordering. This step is repeated until all degrees
 * have been connected up.
 *
 * 
 * Loopless multigraphs are generated using an analogous algorithm: an arbitrary vertex is chosen,
 * and it is connected with a single connection to a highest remaining degee vertex. If self-loops
 * are also allowed, the same algorithm is used, but if a non-zero vertex remains at the end of the
 * procedure, the graph is completed by adding self-loops to it. Thus, the result will contain at most
 * one vertex with self-loops.
 *
 * 
 * The \c method parameter controls the order in which the vertices to be connected are chosen.
 *
 * 
 * References:
 *
 * 
 * V. Havel,
 * Poznámka o existenci koneÄných grafů (A remark on the existence of finite graphs),
 * Časopis pro pěstování matematiky 80, 477-480 (1955).
 * http://eudml.org/doc/19050
 *
 * 
 * S. L. Hakimi,
 * On Realizability of a Set of Integers as Degrees of the Vertices of a Linear Graph,
 * Journal of the SIAM 10, 3 (1962).
 * https://www.jstor.org/stable/2098746
 *
 * 
 * D. J. Kleitman and D. L. Wang,
 * Algorithms for Constructing Graphs and Digraphs with Given Valences and Factors,
 * Discrete Mathematics 6, 1 (1973).
 * https://doi.org/10.1016/0012-365X%2873%2990037-X
 *
 * 
 * Sz. Horvát and C. D. Modes,
 * Connectivity matters: Construction and exact random sampling of connected graphs (2020).
 * https://arxiv.org/abs/2009.03747
 *
 * \param graph Pointer to an uninitialized graph object.
 * \param outdeg The degree sequence of an undirected graph
 *        (if \p indeg is NULL), or the out-degree sequence of
 *        a directed graph (if \p indeg is given).
 * \param indeg The in-degree sequence of a directed graph.
 *        Pass \c NULL to generate an undirected graph.
 * \param allowed_edge_types The types of edges to allow in the graph. For directed graphs,
 *        only \c IGRAPH_SIMPLE_SW is implemented at this moment. For undirected
 *        graphs, the following values are valid:
 *        \clist
 *          \cli IGRAPH_SIMPLE_SW
 *          simple graphs (i.e. no self-loops or multi-edges allowed).
 *          \cli IGRAPH_LOOPS_SW
 *          single self-loops are allowed, but not multi-edges; currently not implemented.
 *          \cli IGRAPH_MULTI_SW
 *          multi-edges are allowed, but not self-loops.
 *          \cli IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW
 *          both self-loops and multi-edges are allowed.
 *        \endclist
 * \param method The method to generate the graph. Possible values:
 *        \clist
 *          \cli IGRAPH_REALIZE_DEGSEQ_SMALLEST
 *          The vertex with smallest remaining degree is selected first. The result is usually
 *          a graph with high negative degree assortativity. In the undirected case, this method
 *          is guaranteed to generate a connected graph, regardless of whether multi-edges are allowed,
 *          provided that a connected realization exists (see Horvát and Modes, 2020, as well as
 *          http://szhorvat.net/pelican/hh-connected-graphs.html).
 *          In the directed case it tends to generate weakly connected graphs, but this is not
 *          guaranteed.
 *          \cli IGRAPH_REALIZE_DEGSEQ_LARGEST
 *          The vertex with the largest remaining degree is selected first. The result
 *          is usually a graph with high positive degree assortativity, and is often disconnected.
 *          \cli IGRAPH_REALIZE_DEGSEQ_INDEX
 *          The vertices are selected in order of their index (i.e. their position in the degree vector).
 *          Note that sorting the degree vector and using the \c INDEX method is not equivalent
 *          to the \c SMALLEST method above, as \c SMALLEST uses the smallest \em remaining
 *          degree for selecting vertices, not the smallest \em initial degree.
 *         \endclist
 * \return Error code:
 *          \clist
 *          \cli IGRAPH_UNIMPLEMENTED
 *           The requested method is not implemented.
 *          \cli IGRAPH_ENOMEM
 *           There is not enough memory to perform the operation.
 *          \cli IGRAPH_EINVAL
 *           Invalid method parameter, or invalid in- and/or out-degree vectors.
 *           The degree vectors should be non-negative, the length
 *           and sum of \p outdeg and \p indeg should match for directed graphs.
 *          \endclist
 *
 * \sa  \ref igraph_is_graphical() to test graphicality without generating a graph;
 *      \ref igraph_degree_sequence_game() to generate random graphs with a given degree sequence;
 *      \ref igraph_k_regular_game() to generate random regular graphs;
 *      \ref igraph_rewire() to randomly rewire the edges of a graph while preserving its degree sequence.
 *
 */

int igraph_realize_degree_sequence(
        igraph_t *graph,
        const igraph_vector_t *outdeg, const igraph_vector_t *indeg,
        igraph_edge_type_sw_t allowed_edge_types,
        igraph_realize_degseq_t method)
{
    long n = igraph_vector_size(outdeg);
    if (n != igraph_integer_t(n)) { // does the vector size fit into an igraph_integer_t ?
        IGRAPH_ERROR("Degree sequence vector too long.", IGRAPH_EINVAL);
    }

    bool directed = indeg != 0;

    try {
        if (directed) {
            return igraph_i_realize_directed_degree_sequence(graph, outdeg, indeg, allowed_edge_types, method);
        } else {
            return igraph_i_realize_undirected_degree_sequence(graph, outdeg, allowed_edge_types, method);
        }
    } catch (const std::bad_alloc &) {
        IGRAPH_ERROR("Cannot realize degree sequence due to insufficient memory.", IGRAPH_ENOMEM);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/embedding.c0000644000175100001710000011653100000000000023465 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_embedding.h"

#include "igraph_adjlist.h"
#include "igraph_blas.h"
#include "igraph_centrality.h"
#include "igraph_interface.h"
#include "igraph_structural.h"

typedef struct {
    const igraph_t *graph;
    const igraph_vector_t *cvec;
    const igraph_vector_t *cvec2;
    igraph_adjlist_t *outlist, *inlist;
    igraph_inclist_t *eoutlist, *einlist;
    igraph_vector_t *tmp;
    const igraph_vector_t *weights;
} igraph_i_asembedding_data_t;

/* Adjacency matrix, unweighted, undirected.
   Eigendecomposition is used */
static int igraph_i_asembeddingu(igraph_real_t *to, const igraph_real_t *from,
                          int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *outlist = data->outlist;
    const igraph_vector_t *cvec = data->cvec;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = (A+cD) from */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Adjacency matrix, weighted, undirected.
   Eigendecomposition is used. */
static int igraph_i_asembeddinguw(igraph_real_t *to, const igraph_real_t *from,
                           int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *outlist = data->eoutlist;
    const igraph_vector_t *cvec = data->cvec;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_int_t *incs;
    int i, j, nlen;

    /* to = (A+cD) from */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(incs);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] += w * from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Adjacency matrix, unweighted, directed. SVD. */
static int igraph_i_asembedding(igraph_real_t *to, const igraph_real_t *from,
                         int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *outlist = data->outlist;
    igraph_adjlist_t *inlist = data->inlist;
    const igraph_vector_t *cvec = data->cvec;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* tmp = (A+cD)' from */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            VECTOR(*tmp)[i] += from[nei];
        }
        VECTOR(*tmp)[i] += VECTOR(*cvec)[i] * from[i];
    }

    /* to = (A+cD) tmp */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += VECTOR(*tmp)[nei];
        }
        to[i] += VECTOR(*cvec)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Adjacency matrix, unweighted, directed. SVD, right eigenvectors */
static int igraph_i_asembedding_right(igraph_real_t *to, const igraph_real_t *from,
                               int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *inlist = data->inlist;
    const igraph_vector_t *cvec = data->cvec;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = (A+cD)' from */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] += from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Adjacency matrix, weighted, directed. SVD. */
static int igraph_i_asembeddingw(igraph_real_t *to, const igraph_real_t *from,
                          int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *outlist = data->eoutlist;
    igraph_inclist_t *inlist = data->einlist;
    const igraph_vector_t *cvec = data->cvec;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *incs;
    int i, j, nlen;

    /* tmp = (A+cD)' from */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(inlist, i);
        nlen = igraph_vector_int_size(incs);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            VECTOR(*tmp)[i] += w * from[nei];
        }
        VECTOR(*tmp)[i] += VECTOR(*cvec)[i] * from[i];
    }

    /* to = (A+cD) tmp */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(incs);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] += w * VECTOR(*tmp)[nei];
        }
        to[i] += VECTOR(*cvec)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Adjacency matrix, weighted, directed. SVD, right eigenvectors. */
static int igraph_i_asembeddingw_right(igraph_real_t *to, const igraph_real_t *from,
                                int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *inlist = data->einlist;
    const igraph_vector_t *cvec = data->cvec;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_int_t *incs;
    int i, j, nlen;

    /* to = (A+cD)' from */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(inlist, i);
        nlen = igraph_vector_int_size(incs);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] += w * from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Laplacian D-A, unweighted, undirected. Eigendecomposition. */
static int igraph_i_lsembedding_da(igraph_real_t *to, const igraph_real_t *from,
                            int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *outlist = data->outlist;
    const igraph_vector_t *cvec = data->cvec;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = (D-A) from */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            to[i] -= from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Laplacian D-A, weighted, undirected. Eigendecomposition. */
static int igraph_i_lsembedding_daw(igraph_real_t *to, const igraph_real_t *from,
                             int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *outlist = data->eoutlist;
    const igraph_vector_t *cvec = data->cvec;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_int_t *incs;
    int i, j, nlen;

    /* to = (D-A) from */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(incs);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] -= w * from[nei];
        }
        to[i] += VECTOR(*cvec)[i] * from[i];
    }

    return 0;
}

/* Laplacian DAD, unweighted, undirected. Eigendecomposition. */
static int igraph_i_lsembedding_dad(igraph_real_t *to, const igraph_real_t *from,
                             int n, void *extra) {

    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *outlist = data->outlist;
    const igraph_vector_t *cvec = data->cvec;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = D^1/2 from */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*cvec)[i] * from[i];
    }

    /* tmp = A to */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            VECTOR(*tmp)[i] += to[nei];
        }
    }

    /* to = D tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*cvec)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

static int igraph_i_lsembedding_dadw(igraph_real_t *to, const igraph_real_t *from,
                              int n, void *extra) {

    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *outlist = data->eoutlist;
    const igraph_vector_t *cvec = data->cvec;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *incs;
    int i, j, nlen;

    /* to = D^-1/2 from */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*cvec)[i] * from[i];
    }

    /* tmp = A' to */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(incs);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            VECTOR(*tmp)[i] += w * to[nei];
        }
    }

    /* to = D tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*cvec)[i] * VECTOR(*cvec)[i] * VECTOR(*tmp)[i];
    }

    /* tmp = A to */
    for (i = 0; i < n; i++) {
        incs = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(incs);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            long int edge = VECTOR(*incs)[j];
            long int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            VECTOR(*tmp)[i] += w * to[nei];
        }
    }

    /* to = D^-1/2 tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*cvec)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Laplacian I-DAD, unweighted, undirected. Eigendecomposition. */
static int igraph_i_lsembedding_idad(igraph_real_t *to, const igraph_real_t *from,
                              int n, void *extra) {

    int i;

    igraph_i_lsembedding_dad(to, from, n, extra);
    for (i = 0; i < n; i++) {
        to[i] = from[i] - to[i];
    }

    return 0;
}

static int igraph_i_lsembedding_idadw(igraph_real_t *to, const igraph_real_t *from,
                               int n, void *extra) {
    int i;

    igraph_i_lsembedding_dadw(to, from, n, extra);
    for (i = 0; i < n; i++) {
        to[i] = from[i] - to[i];
    }

    return 0;
}

/* Laplacian OAP, unweighted, directed. SVD. */
static int igraph_i_lseembedding_oap(igraph_real_t *to, const igraph_real_t *from,
                              int n, void *extra) {

    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *outlist = data->outlist;
    igraph_adjlist_t *inlist = data->inlist;
    const igraph_vector_t *deg_in = data->cvec;
    const igraph_vector_t *deg_out = data->cvec2;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* tmp = O' from */
    for (i = 0; i < n; i++) {
        VECTOR(*tmp)[i] = VECTOR(*deg_out)[i] * from[i];
    }

    /* to = A' tmp */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int nei = VECTOR(*neis)[j];
            to[i] += VECTOR(*tmp)[nei];
        }
    }

    /* tmp = P' to */
    for (i = 0; i < n; i++) {
        VECTOR(*tmp)[i] = VECTOR(*deg_in)[i] * to[i];
    }

    /* to = P tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_in)[i] * VECTOR(*tmp)[i];
    }

    /* tmp = A to */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int nei = VECTOR(*neis)[j];
            VECTOR(*tmp)[i] += to[nei];
        }
    }

    /* to = O tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_out)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Laplacian OAP, unweighted, directed. SVD, right eigenvectors. */
static int igraph_i_lseembedding_oap_right(igraph_real_t *to,
                                    const igraph_real_t *from,
                                    int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_adjlist_t *inlist = data->inlist;
    const igraph_vector_t *deg_in = data->cvec;
    const igraph_vector_t *deg_out = data->cvec2;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = O' from */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_out)[i] * from[i];
    }

    /* tmp = A' to */
    for (i = 0; i < n; i++) {
        neis = igraph_adjlist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int nei = VECTOR(*neis)[j];
            VECTOR(*tmp)[i] += to[nei];
        }
    }

    /* to = P' tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_in)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Laplacian OAP, weighted, directed. SVD. */
static int igraph_i_lseembedding_oapw(igraph_real_t *to, const igraph_real_t *from,
                               int n, void *extra) {

    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *outlist = data->eoutlist;
    igraph_inclist_t *inlist = data->einlist;
    const igraph_vector_t *deg_in = data->cvec;
    const igraph_vector_t *deg_out = data->cvec2;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* tmp = O' from */
    for (i = 0; i < n; i++) {
        VECTOR(*tmp)[i] = VECTOR(*deg_out)[i] * from[i];
    }

    /* to = A' tmp */
    for (i = 0; i < n; i++) {
        neis = igraph_inclist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        to[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int edge = VECTOR(*neis)[j];
            int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            to[i] += w * VECTOR(*tmp)[nei];
        }
    }

    /* tmp = P' to */
    for (i = 0; i < n; i++) {
        VECTOR(*tmp)[i] = VECTOR(*deg_in)[i] * to[i];
    }

    /* to = P tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_in)[i] * VECTOR(*tmp)[i];
    }

    /* tmp = A to */
    for (i = 0; i < n; i++) {
        neis = igraph_inclist_get(outlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int edge = VECTOR(*neis)[j];
            int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            VECTOR(*tmp)[i] += w * to[nei];
        }
    }

    /* to = O tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_out)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

/* Laplacian OAP, weighted, directed. SVD, right eigenvectors. */
static int igraph_i_lseembedding_oapw_right(igraph_real_t *to,
                                     const igraph_real_t *from,
                                     int n, void *extra) {
    igraph_i_asembedding_data_t *data = extra;
    igraph_inclist_t *inlist = data->einlist;
    const igraph_vector_t *deg_in = data->cvec;
    const igraph_vector_t *deg_out = data->cvec2;
    const igraph_vector_t *weights = data->weights;
    const igraph_t *graph = data->graph;
    igraph_vector_t *tmp = data->tmp;
    igraph_vector_int_t *neis;
    int i, j, nlen;

    /* to = O' from */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_out)[i] * from[i];
    }

    /* tmp = A' to */
    for (i = 0; i < n; i++) {
        neis = igraph_inclist_get(inlist, i);
        nlen = igraph_vector_int_size(neis);
        VECTOR(*tmp)[i] = 0.0;
        for (j = 0; j < nlen; j++) {
            int edge = VECTOR(*neis)[j];
            int nei = IGRAPH_OTHER(graph, edge, i);
            igraph_real_t w = VECTOR(*weights)[edge];
            VECTOR(*tmp)[i] += w * to[nei];
        }
    }

    /* to = P' tmp */
    for (i = 0; i < n; i++) {
        to[i] = VECTOR(*deg_in)[i] * VECTOR(*tmp)[i];
    }

    return 0;
}

static int igraph_i_spectral_embedding(const igraph_t *graph,
                                igraph_integer_t no,
                                const igraph_vector_t *weights,
                                igraph_eigen_which_position_t which,
                                igraph_bool_t scaled,
                                igraph_matrix_t *X,
                                igraph_matrix_t *Y,
                                igraph_vector_t *D,
                                const igraph_vector_t *cvec,
                                const igraph_vector_t *cvec2,
                                igraph_arpack_options_t *options,
                                igraph_arpack_function_t *callback,
                                igraph_arpack_function_t *callback_right,
                                igraph_bool_t symmetric,
                                igraph_bool_t eigen,
                                igraph_bool_t zapsmall) {

    igraph_integer_t vc = igraph_vcount(graph);
    igraph_vector_t tmp;
    igraph_adjlist_t outlist, inlist;
    igraph_inclist_t eoutlist, einlist;
    int i, j, cveclen = igraph_vector_size(cvec);
    igraph_i_asembedding_data_t data;
    igraph_vector_t tmpD;

    data.graph = graph;
    data.cvec = cvec;
    data.cvec2 = cvec2;
    data.outlist = &outlist;
    data.inlist = &inlist;
    data.eoutlist = &eoutlist;
    data.einlist = &einlist;
    data.tmp = &tmp;
    data.weights = weights;

    if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    if (which != IGRAPH_EIGEN_LM &&
        which != IGRAPH_EIGEN_LA &&
        which != IGRAPH_EIGEN_SA) {
        IGRAPH_ERROR("Invalid eigenvalue chosen, must be one of "
                     "`largest magnitude', `largest algebraic' or "
                     "`smallest algebraic'", IGRAPH_EINVAL);
    }

    if (no > vc) {
        IGRAPH_ERROR("Too many singular values requested", IGRAPH_EINVAL);
    }
    if (no <= 0) {
        IGRAPH_ERROR("No singular values requested", IGRAPH_EINVAL);
    }

    if (cveclen != 1 && cveclen != vc) {
        IGRAPH_ERROR("Augmentation vector size is invalid, it should be "
                     "the number of vertices or scalar", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(X, vc, no));
    if (Y) {
        IGRAPH_CHECK(igraph_matrix_resize(Y, vc, no));
    }

    /* empty graph */
    if (igraph_ecount(graph) == 0) {
        igraph_matrix_null(X);
        if (Y) {
            igraph_matrix_null(Y);
        }
        return 0;
    }

    igraph_vector_init(&tmp, vc);
    IGRAPH_FINALLY(igraph_vector_destroy, &tmp);
    if (!weights) {
        IGRAPH_CHECK(igraph_adjlist_init(graph, &outlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &outlist);
        if (!symmetric) {
            IGRAPH_CHECK(igraph_adjlist_init(graph, &inlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
            IGRAPH_FINALLY(igraph_adjlist_destroy, &inlist);
        }
    } else {
        IGRAPH_CHECK(igraph_inclist_init(graph, &eoutlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &eoutlist);
        if (!symmetric) {
            IGRAPH_CHECK(igraph_inclist_init(graph, &einlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE));
            IGRAPH_FINALLY(igraph_inclist_destroy, &einlist);
        }
    }
    IGRAPH_VECTOR_INIT_FINALLY(&tmpD, no);

    options->n = vc;
    options->start = 0;   /* random start vector */
    options->nev = no;
    switch (which) {
    case IGRAPH_EIGEN_LM:
        options->which[0] = 'L'; options->which[1] = 'M';
        break;
    case IGRAPH_EIGEN_LA:
        options->which[0] = 'L'; options->which[1] = 'A';
        break;
    case IGRAPH_EIGEN_SA:
        options->which[0] = 'S'; options->which[1] = 'A';
        break;
    default:
        break;
    }
    options->ncv = no + 3;
    if (options->ncv > vc) {
        options->ncv = vc;
    }

    IGRAPH_CHECK(igraph_arpack_rssolve(callback, &data, options, 0, &tmpD, X));

    if (!symmetric) {
        /* calculate left eigenvalues */
        IGRAPH_CHECK(igraph_matrix_resize(Y, vc, no));
        for (i = 0; i < no; i++) {
            igraph_real_t norm;
            igraph_vector_t v;
            callback_right(&MATRIX(*Y, 0, i), &MATRIX(*X, 0, i), vc, &data);
            igraph_vector_view(&v, &MATRIX(*Y, 0, i), vc);
            norm = 1.0 / igraph_blas_dnrm2(&v);
            igraph_vector_scale(&v, norm);
        }
    } else if (Y) {
        IGRAPH_CHECK(igraph_matrix_update(Y, X));
    }

    if (zapsmall) {
        igraph_vector_zapsmall(&tmpD, 0);
        igraph_matrix_zapsmall(X, 0);
        if (Y) {
            igraph_matrix_zapsmall(Y, 0);
        }
    }

    if (D) {
        igraph_vector_update(D, &tmpD);
        if (!eigen) {
            for (i = 0; i < no; i++) {
                VECTOR(*D)[i] = sqrt(VECTOR(*D)[i]);
            }
        }
    }

    if (scaled) {
        if (eigen) {
            /* eigenvalues were calculated */
            for (i = 0; i < no; i++) {
                VECTOR(tmpD)[i] = sqrt(fabs(VECTOR(tmpD)[i]));
            }
        } else {
            /* singular values were calculated */
            for (i = 0; i < no; i++) {
                VECTOR(tmpD)[i] = sqrt(sqrt(VECTOR(tmpD)[i]));
            }
        }

        for (j = 0; j < vc; j++) {
            for (i = 0; i < no; i++) {
                MATRIX(*X, j, i) *= VECTOR(tmpD)[i];
            }
        }

        if (Y) {
            for (j = 0; j < vc; j++) {
                for (i = 0; i < no; i++) {
                    MATRIX(*Y, j, i) *= VECTOR(tmpD)[i];
                }
            }
        }
    }

    igraph_vector_destroy(&tmpD);
    if (!weights) {
        if (!symmetric) {
            igraph_adjlist_destroy(&inlist);
            IGRAPH_FINALLY_CLEAN(1);
        }
        igraph_adjlist_destroy(&outlist);
    } else {
        if (!symmetric) {
            igraph_inclist_destroy(&einlist);
            IGRAPH_FINALLY_CLEAN(1);
        }
        igraph_inclist_destroy(&eoutlist);
    }
    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_adjacency_spectral_embedding
 * Adjacency spectral embedding
 *
 * Spectral decomposition of the adjacency matrices of graphs.
 * This function computes an n-dimensional Euclidean
 * representation of the graph based on its adjacency
 * matrix, A. This representation is computed via the singular value
 * decomposition of the adjacency matrix, A=U D V^T. In the case,
 * where the graph is a random dot product graph generated using latent
 * position vectors in R^n for each vertex, the embedding will
 * provide an estimate of these latent vectors.
 *
 * 
 * For undirected graphs, the latent positions are calculated as
 * X = U^n D^(1/2) where U^n equals to the first no columns of U, and
 * D^(1/2) is a diagonal matrix containing the square root of the selected
 * singular values on the diagonal.
 *
 * 
 * For directed graphs, the embedding is defined as the pair
 * X = U^n D^(1/2), Y = V^n D^(1/2).
 * (For undirected graphs U=V, so it is sufficient to keep one of them.)
 *
 * \param graph The input graph, can be directed or undirected.
 * \param n An integer scalar. This value is the embedding dimension of
 *        the spectral embedding. Should be smaller than the number of
 *        vertices. The largest n-dimensional non-zero
 *        singular values are used for the spectral embedding.
 * \param weights Optional edge weights. Supply a null pointer for
 *        unweighted graphs.
 * \param which Which eigenvalues (or singular values, for directed
 *        graphs) to use, possible values:
 *        \clist
 *          \cli IGRAPH_EIGEN_LM
 *          the ones with the largest magnitude
 *          \cli IGRAPH_EIGEN_LA
 *          the (algebraic) largest ones
 *          \cli IGRAPH_EIGEN_SA
 *          the (algebraic) smallest ones.
 *        \endclist
 *        For directed graphs, IGRAPH_EIGEN_LM and
 *        IGRAPH_EIGEN_LA are the same because singular
 *        values are used for the ordering instead of eigenvalues.
 * \param scaled Whether to return X and Y (if \c scaled is true), or
 *        U and V.
 * \param X Initialized matrix, the estimated latent positions are
 *        stored here.
 * \param Y Initialized matrix or a null pointer. If not a null
 *        pointer, then the second half of the latent positions are
 *        stored here. (For undirected graphs, this always equals X.)
 * \param D Initialized vector or a null pointer. If not a null
 *        pointer, then the eigenvalues (for undirected graphs) or the
 *        singular values (for directed graphs) are stored here.
 * \param cvec A numeric vector, its length is the number vertices in the
 *        graph. This vector is added to the diagonal of the adjacency
 *        matrix, before performing the SVD.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *        for details. Note that the function overwrites the
 *        n (number of vertices), nev and
 *        which parameters and it always starts the
 *        calculation from a random start vector.
 * \return Error code.
 *
 */

int igraph_adjacency_spectral_embedding(const igraph_t *graph,
                                        igraph_integer_t n,
                                        const igraph_vector_t *weights,
                                        igraph_eigen_which_position_t which,
                                        igraph_bool_t scaled,
                                        igraph_matrix_t *X,
                                        igraph_matrix_t *Y,
                                        igraph_vector_t *D,
                                        const igraph_vector_t *cvec,
                                        igraph_arpack_options_t *options) {

    igraph_arpack_function_t *callback, *callback_right;
    igraph_bool_t directed = igraph_is_directed(graph);

    if (directed) {
        callback = weights ? igraph_i_asembeddingw : igraph_i_asembedding;
        callback_right = (weights ? igraph_i_asembeddingw_right :
                          igraph_i_asembedding_right);
    } else {
        callback = weights ? igraph_i_asembeddinguw : igraph_i_asembeddingu;
        callback_right = 0;
    }

    return igraph_i_spectral_embedding(graph, n, weights, which, scaled,
                                       X, Y, D, cvec, /* deg2=*/ 0,
                                       options, callback, callback_right,
                                       /*symmetric=*/ !directed,
                                       /*eigen=*/ !directed, /*zapsmall=*/ 1);
}

static int igraph_i_lse_und(const igraph_t *graph,
                     igraph_integer_t no,
                     const igraph_vector_t *weights,
                     igraph_eigen_which_position_t which,
                     igraph_laplacian_spectral_embedding_type_t type,
                     igraph_bool_t scaled,
                     igraph_matrix_t *X,
                     igraph_matrix_t *Y,
                     igraph_vector_t *D,
                     igraph_arpack_options_t *options) {

    igraph_arpack_function_t *callback;
    igraph_vector_t deg;

    switch (type) {
    case IGRAPH_EMBEDDING_D_A:
        callback = weights ? igraph_i_lsembedding_daw : igraph_i_lsembedding_da;
        break;
    case IGRAPH_EMBEDDING_DAD:
        callback = weights ? igraph_i_lsembedding_dadw : igraph_i_lsembedding_dad;
        break;
    case IGRAPH_EMBEDDING_I_DAD:
        callback = weights ? igraph_i_lsembedding_idadw : igraph_i_lsembedding_idad;
        break;
    default:
        IGRAPH_ERROR("Invalid Laplacian spectral embedding type",
                     IGRAPH_EINVAL);
        break;
    }

    IGRAPH_VECTOR_INIT_FINALLY(°, 0);
    igraph_strength(graph, °, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1,
                    weights);

    switch (type) {
    case IGRAPH_EMBEDDING_D_A:
        break;
    case IGRAPH_EMBEDDING_DAD:
    case IGRAPH_EMBEDDING_I_DAD: {
        int i, n = igraph_vector_size(°);
        for (i = 0; i < n; i++) {
            VECTOR(deg)[i] = 1.0 / sqrt(VECTOR(deg)[i]);
        }
    }
    break;
    default:
        break;
    }

    IGRAPH_CHECK(igraph_i_spectral_embedding(graph, no, weights, which,
                 scaled, X, Y, D, /*cvec=*/ °, /*deg2=*/ 0,
                 options, callback, 0, /*symmetric=*/ 1,
                 /*eigen=*/ 1, /*zapsmall=*/ 1));

    igraph_vector_destroy(°);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_lse_dir(const igraph_t *graph,
                     igraph_integer_t no,
                     const igraph_vector_t *weights,
                     igraph_eigen_which_position_t which,
                     igraph_laplacian_spectral_embedding_type_t type,
                     igraph_bool_t scaled,
                     igraph_matrix_t *X,
                     igraph_matrix_t *Y,
                     igraph_vector_t *D,
                     igraph_arpack_options_t *options) {

    igraph_arpack_function_t *callback =
        weights ? igraph_i_lseembedding_oapw : igraph_i_lseembedding_oap;
    igraph_arpack_function_t *callback_right =
        weights ? igraph_i_lseembedding_oapw_right :
        igraph_i_lseembedding_oap_right;
    igraph_vector_t deg_in, deg_out;
    int i, n = igraph_vcount(graph);

    if (type != IGRAPH_EMBEDDING_OAP) {
        IGRAPH_ERROR("Invalid Laplacian spectral embedding type", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(°_in, n);
    IGRAPH_VECTOR_INIT_FINALLY(°_out, n);
    igraph_strength(graph, °_in, igraph_vss_all(), IGRAPH_IN, /*loops=*/ 1,
                    weights);
    igraph_strength(graph, °_out, igraph_vss_all(), IGRAPH_OUT, /*loops=*/ 1,
                    weights);

    for (i = 0; i < n; i++) {
        VECTOR(deg_in)[i] = 1.0 / sqrt(VECTOR(deg_in)[i]);
        VECTOR(deg_out)[i] = 1.0 / sqrt(VECTOR(deg_out)[i]);
    }

    IGRAPH_CHECK(igraph_i_spectral_embedding(graph, no, weights, which,
                 scaled, X, Y, D, /*cvec=*/ °_in,
                 /*deg2=*/ °_out, options, callback,
                 callback_right, /*symmetric=*/ 0, /*eigen=*/ 0,
                 /*zapsmall=*/ 1));

    igraph_vector_destroy(°_in);
    igraph_vector_destroy(°_out);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_laplacian_spectral_embedding
 * Spectral embedding of the Laplacian of a graph
 *
 * This function essentially does the same as
 * \ref igraph_adjacency_spectral_embedding, but works on the Laplacian
 * of the graph, instead of the adjacency matrix.
 * \param graph The input graph.
 * \param n The number of eigenvectors (or singular vectors if the graph
 *        is directed) to use for the embedding.
 * \param weights Optional edge weights. Supply a null pointer for
 *        unweighted graphs.
 * \param which Which eigenvalues (or singular values, for directed
 *        graphs) to use, possible values:
 *        \clist
 *          \cli IGRAPH_EIGEN_LM
 *          the ones with the largest magnitude
 *          \cli IGRAPH_EIGEN_LA
 *          the (algebraic) largest ones
 *          \cli IGRAPH_EIGEN_SA
 *          the (algebraic) smallest ones.
 *        \endclist
 *        For directed graphs, IGRAPH_EIGEN_LM and
 *        IGRAPH_EIGEN_LA are the same because singular
 *        values are used for the ordering instead of eigenvalues.
 * \param type The type of the Laplacian to use. Various definitions
 *        exist for the Laplacian of a graph, and one can choose
 *        between them with this argument. Possible values:
 *        \clist
 *          \cli IGRAPH_EMBEDDING_D_A
 *           means D - A where D is the
 *           degree matrix and A is the adjacency matrix
 *          \cli IGRAPH_EMBEDDING_DAD
 *           means Di times A times Di,
 *           where Di is the inverse of the square root of the degree matrix;
 *          \cli IGRAPH_EMBEDDING_I_DAD
 *          means I - Di A Di, where I
 *          is the identity matrix.
 *        \endclist
 * \param scaled Whether to return X and Y (if \c scaled is true), or
 *        U and V.
 * \param X Initialized matrix, the estimated latent positions are
 *        stored here.
 * \param Y Initialized matrix or a null pointer. If not a null
 *        pointer, then the second half of the latent positions are
 *        stored here. (For undirected graphs, this always equals X.)
 * \param D Initialized vector or a null pointer. If not a null
 *        pointer, then the eigenvalues (for undirected graphs) or the
 *        singular values (for directed graphs) are stored here.
 * \param options Options to ARPACK. See \ref igraph_arpack_options_t
 *        for details. Note that the function overwrites the
 *        n (number of vertices), nev and
 *        which parameters and it always starts the
 *        calculation from a random start vector.
 * \return Error code.
 *
 * \sa \ref igraph_adjacency_spectral_embedding to embed the adjacency
 * matrix.
 */

int igraph_laplacian_spectral_embedding(const igraph_t *graph,
                                        igraph_integer_t n,
                                        const igraph_vector_t *weights,
                                        igraph_eigen_which_position_t which,
                                        igraph_laplacian_spectral_embedding_type_t type,
                                        igraph_bool_t scaled,
                                        igraph_matrix_t *X,
                                        igraph_matrix_t *Y,
                                        igraph_vector_t *D,
                                        igraph_arpack_options_t *options) {

    if (igraph_is_directed(graph)) {
        return igraph_i_lse_dir(graph, n, weights, which, type, scaled,
                                X, Y, D, options);
    } else {
        return igraph_i_lse_und(graph, n, weights, which, type, scaled,
                                X, Y, D, options);
    }
}

/**
 * \function igraph_dim_select
 * Dimensionality selection
 *
 * Dimensionality selection for singular values using
 * profile likelihood.
 *
 * 
 * The input of the function is a numeric vector which contains
 * the measure of "importance" for each dimension.
 *
 * 
 * For spectral embedding, these are the singular values of the adjacency
 * matrix. The singular values are assumed to be generated from a
 * Gaussian mixture distribution with two components that have different
 * means and same variance. The dimensionality d is chosen to
 * maximize the likelihood when the d largest singular values are
 * assigned to one component of the mixture and the rest of the singular
 * values assigned to the other component.
 *
 * 
 * This function can also be used for the general separation problem,
 * where we assume that the left and the right of the vector are coming
 * from two normal distributions, with different means, and we want
 * to know their border.
 *
 * \param sv A numeric vector, the ordered singular values.
 * \param dim The result is stored here.
 * \return Error code.
 *
 * Time complexity: O(n), n is the number of values in sv.
 *
 * \sa \ref igraph_adjacency_spectral_embedding().
 */

int igraph_dim_select(const igraph_vector_t *sv, igraph_integer_t *dim) {

    int i, n = igraph_vector_size(sv);
    igraph_real_t x, x2, sum1 = 0.0, sum2 = igraph_vector_sum(sv);
    igraph_real_t sumsq1 = 0.0, sumsq2 = 0.0; /* to be set */
    igraph_real_t oldmean1, oldmean2, mean1 = 0.0, mean2 = sum2 / n;
    igraph_real_t varsq1 = 0.0, varsq2 = 0.0; /* to be set */
    igraph_real_t var1, var2, sd, profile, max = IGRAPH_NEGINFINITY;

    if (n == 0) {
        IGRAPH_ERROR("Need at least one singular value for dimensionality "
                     "selection", IGRAPH_EINVAL);
    }

    if (n == 1) {
        *dim = 1;
        return 0;
    }

    for (i = 0; i < n; i++) {
        x = VECTOR(*sv)[i];
        sumsq2 += x * x;
        varsq2 += (mean2 - x) * (mean2 - x);
    }

    for (i = 0; i < n - 1; i++) {
        int n1 = i + 1, n2 = n - i - 1, n1m1 = n1 - 1, n2m1 = n2 - 1;
        x = VECTOR(*sv)[i]; x2 = x * x;
        sum1 += x; sum2 -= x;
        sumsq1 += x2; sumsq2 -= x2;
        oldmean1 = mean1; oldmean2 = mean2;
        mean1 = sum1 / n1; mean2 = sum2 / n2;
        varsq1 += (x - oldmean1) * (x - mean1);
        varsq2 -= (x - oldmean2) * (x - mean2);
        var1 = i == 0 ? 0 : varsq1 / n1m1;
        var2 = i == n - 2 ? 0 : varsq2 / n2m1;
        sd = sqrt(( n1m1 * var1 + n2m1 * var2) / (n - 2));
        profile = /* - n * log(2.0*M_PI)/2.0 */ /* This is redundant */
            - n * log(sd) -
            ((sumsq1 - 2 * mean1 * sum1 + n1 * mean1 * mean1) +
             (sumsq2 - 2 * mean2 * sum2 + n2 * mean2 * mean2)) / 2.0 / sd / sd;
        if (profile > max) {
            max = profile;
            *dim = n1;
        }
    }

    /* Plus the last case, all elements in one group */
    x = VECTOR(*sv)[n - 1];
    sum1 += x;
    oldmean1 = mean1;
    mean1 = sum1 / n;
    sumsq1 += x * x;
    varsq1 += (x - oldmean1) * (x - mean1);
    var1 = varsq1 / (n - 1);
    sd = sqrt(var1);
    profile = /* - n * log(2.0*M_PI)/2.0 */ /* This is redundant */
        - n * log(sd) -
        (sumsq1 - 2 * mean1 * sum1 + n * mean1 * mean1) / 2.0 / sd / sd;
    if (profile > max) {
        max = profile;
        *dim = n;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/feedback_arc_set.c0000644000175100001710000006223600000000000024775 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_structural.h"
#include "igraph_visitor.h"

#include "internal/glpk_support.h"
#include "misc/feedback_arc_set.h"

int igraph_i_feedback_arc_set_ip(const igraph_t *graph, igraph_vector_t *result,
                                 const igraph_vector_t *weights);


/**
 * \ingroup structural
 * \function igraph_feedback_arc_set
 * \brief Calculates a feedback arc set of the graph using different
 *        algorithms.
 *
 * 
 * A feedback arc set is a set of edges whose removal makes the graph acyclic.
 * We are usually interested in \em minimum feedback arc sets, i.e. sets of edges
 * whose total weight is minimal among all the feedback arc sets.
 *
 * 
 * For undirected graphs, the problem is simple: one has to find a maximum weight
 * spanning tree and then remove all the edges not in the spanning tree. For directed
 * graphs, this is an NP-hard problem, and various heuristics are usually used to
 * find an approximate solution to the problem. This function implements a few of
 * these heuristics.
 *
 * \param graph  The graph object.
 * \param result An initialized vector, the result will be returned here.
 * \param weights Weight vector or NULL if no weights are specified.
 * \param algo   The algorithm to use to solve the problem if the graph is directed.
 *        Possible values:
 *        \clist
 *        \cli IGRAPH_FAS_EXACT_IP
 *          Finds a \em minimum feedback arc set using integer programming (IP).
 *          The complexity of this algorithm is exponential of course.
 *        \cli IGRAPH_FAS_APPROX_EADES
 *          Finds a feedback arc set using the heuristic of Eades, Lin and
 *          Smyth (1993). This is guaranteed to be smaller than |E|/2 - |V|/6,
 *          and it is linear in the number of edges (i.e. O(|E|)).
 *          For more details, see Eades P, Lin X and Smyth WF: A fast and effective
 *          heuristic for the feedback arc set problem. In: Proc Inf Process Lett
 *          319-323, 1993.
 *        \endclist
 *
 * \return Error code:
 *         \c IGRAPH_EINVAL if an unknown method was specified or the weight vector
 *            is invalid.
 *
 * \example examples/simple/igraph_feedback_arc_set.c
 * \example examples/simple/igraph_feedback_arc_set_ip.c
 *
 * Time complexity: depends on \p algo, see the time complexities there.
 */
int igraph_feedback_arc_set(const igraph_t *graph, igraph_vector_t *result,
                            const igraph_vector_t *weights, igraph_fas_algorithm_t algo) {

    if (weights && igraph_vector_size(weights) < igraph_ecount(graph))
        IGRAPH_ERROR("cannot calculate feedback arc set, weight vector too short",
                     IGRAPH_EINVAL);

    if (!igraph_is_directed(graph)) {
        return igraph_i_feedback_arc_set_undirected(graph, result, weights, 0);
    }

    switch (algo) {
    case IGRAPH_FAS_EXACT_IP:
        return igraph_i_feedback_arc_set_ip(graph, result, weights);

    case IGRAPH_FAS_APPROX_EADES:
        return igraph_i_feedback_arc_set_eades(graph, result, weights, 0);

    default:
        IGRAPH_ERROR("Invalid algorithm", IGRAPH_EINVAL);
    }
}

/**
 * Solves the feedback arc set problem for undirected graphs.
 */
int igraph_i_feedback_arc_set_undirected(const igraph_t *graph, igraph_vector_t *result,
        const igraph_vector_t *weights, igraph_vector_t *layering) {
    igraph_vector_t edges;
    long int i, j, n, no_of_nodes = igraph_vcount(graph);

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_nodes - 1);
    if (weights) {
        /* Find a maximum weight spanning tree. igraph has a routine for minimum
         * spanning trees, so we negate the weights */
        igraph_vector_t vcopy;
        IGRAPH_CHECK(igraph_vector_copy(&vcopy, weights));
        IGRAPH_FINALLY(igraph_vector_destroy, &vcopy);
        igraph_vector_scale(&vcopy, -1);
        IGRAPH_CHECK(igraph_minimum_spanning_tree(graph, &edges, &vcopy));
        igraph_vector_destroy(&vcopy);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        /* Any spanning tree will do */
        IGRAPH_CHECK(igraph_minimum_spanning_tree(graph, &edges, 0));
    }

    /* Now we have a bunch of edges that constitute a spanning forest. We have
     * to come up with a layering, and return those edges that are not in the
     * spanning forest */
    igraph_vector_sort(&edges);
    IGRAPH_CHECK(igraph_vector_push_back(&edges, -1));  /* guard element */

    if (result != 0) {
        igraph_vector_clear(result);
        n = igraph_ecount(graph);
        for (i = 0, j = 0; i < n; i++) {
            if (i == VECTOR(edges)[j]) {
                j++;
                continue;
            }
            IGRAPH_CHECK(igraph_vector_push_back(result, i));
        }
    }

    if (layering != 0) {
        igraph_vector_t degrees;
        igraph_vector_t roots;

        IGRAPH_VECTOR_INIT_FINALLY(°rees, no_of_nodes);
        IGRAPH_VECTOR_INIT_FINALLY(&roots, no_of_nodes);

        IGRAPH_CHECK(igraph_strength(graph, °rees, igraph_vss_all(),
                                     IGRAPH_ALL, 0, weights));
        IGRAPH_CHECK((int) igraph_vector_qsort_ind(°rees, &roots,
                     /* descending = */ 1));
        IGRAPH_CHECK(igraph_bfs(graph,
                                /* root = */ 0,
                                /* roots = */ &roots,
                                /* mode = */ IGRAPH_OUT,
                                /* unreachable = */ 0,
                                /* restricted = */ 0,
                                /* order = */ 0,
                                /* rank = */ 0,
                                /* father = */ 0,
                                /* pred = */ 0,
                                /* succ = */ 0,
                                /* dist = */ layering,
                                /* callback = */ 0,
                                /* extra = */ 0));

        igraph_vector_destroy(°rees);
        igraph_vector_destroy(&roots);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * Solves the feedback arc set problem using the heuristics of Eades et al.
 */
int igraph_i_feedback_arc_set_eades(const igraph_t *graph, igraph_vector_t *result,
                                    const igraph_vector_t *weights, igraph_vector_t *layers) {
    long int i, j, k, v, eid, no_of_nodes = igraph_vcount(graph), nodes_left;
    igraph_dqueue_t sources, sinks;
    igraph_vector_t neis;
    igraph_vector_t indegrees, outdegrees;
    igraph_vector_t instrengths, outstrengths;
    long int* ordering;
    long int order_next_pos = 0, order_next_neg = -1;
    igraph_real_t diff, maxdiff;

    ordering = IGRAPH_CALLOC(no_of_nodes, long int);
    IGRAPH_FINALLY(igraph_free, ordering);

    IGRAPH_VECTOR_INIT_FINALLY(&indegrees, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&outdegrees, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&instrengths, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&outstrengths, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_init(&sources, 0));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &sources);
    IGRAPH_CHECK(igraph_dqueue_init(&sinks, 0));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &sinks);

    IGRAPH_CHECK(igraph_degree(graph, &indegrees, igraph_vss_all(), IGRAPH_IN, 0));
    IGRAPH_CHECK(igraph_degree(graph, &outdegrees, igraph_vss_all(), IGRAPH_OUT, 0));

    if (weights) {
        IGRAPH_CHECK(igraph_strength(graph, &instrengths, igraph_vss_all(), IGRAPH_IN, 0, weights));
        IGRAPH_CHECK(igraph_strength(graph, &outstrengths, igraph_vss_all(), IGRAPH_OUT, 0, weights));
    } else {
        IGRAPH_CHECK(igraph_vector_update(&instrengths, &indegrees));
        IGRAPH_CHECK(igraph_vector_update(&outstrengths, &outdegrees));
    }

    /* Find initial sources and sinks */
    nodes_left = no_of_nodes;
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(indegrees)[i] == 0) {
            if (VECTOR(outdegrees)[i] == 0) {
                /* Isolated vertex, we simply ignore it */
                nodes_left--;
                ordering[i] = order_next_pos++;
                VECTOR(indegrees)[i] = VECTOR(outdegrees)[i] = -1;
            } else {
                /* This is a source */
                igraph_dqueue_push(&sources, i);
            }
        } else if (VECTOR(outdegrees)[i] == 0) {
            /* This is a sink */
            igraph_dqueue_push(&sinks, i);
        }
    }

    /* While we have any nodes left... */
    while (nodes_left > 0) {
        /* (1) Remove the sources one by one */
        while (!igraph_dqueue_empty(&sources)) {
            i = (long)igraph_dqueue_pop(&sources);
            /* Add the node to the ordering */
            ordering[i] = order_next_pos++;
            /* Exclude the node from further searches */
            VECTOR(indegrees)[i] = VECTOR(outdegrees)[i] = -1;
            /* Get the neighbors and decrease their degrees */
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) i,
                                         IGRAPH_OUT));
            j = igraph_vector_size(&neis);
            for (i = 0; i < j; i++) {
                eid = (long int) VECTOR(neis)[i];
                k = IGRAPH_TO(graph, eid);
                if (VECTOR(indegrees)[k] <= 0) {
                    /* Already removed, continue */
                    continue;
                }
                VECTOR(indegrees)[k]--;
                VECTOR(instrengths)[k] -= (weights ? VECTOR(*weights)[eid] : 1.0);
                if (VECTOR(indegrees)[k] == 0) {
                    IGRAPH_CHECK(igraph_dqueue_push(&sources, k));
                }
            }
            nodes_left--;
        }

        /* (2) Remove the sinks one by one */
        while (!igraph_dqueue_empty(&sinks)) {
            i = (long)igraph_dqueue_pop(&sinks);
            /* Maybe the vertex became sink and source at the same time, hence it
             * was already removed in the previous iteration. Check it. */
            if (VECTOR(indegrees)[i] < 0) {
                continue;
            }
            /* Add the node to the ordering */
            ordering[i] = order_next_neg--;
            /* Exclude the node from further searches */
            VECTOR(indegrees)[i] = VECTOR(outdegrees)[i] = -1;
            /* Get the neighbors and decrease their degrees */
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) i,
                                         IGRAPH_IN));
            j = igraph_vector_size(&neis);
            for (i = 0; i < j; i++) {
                eid = (long int) VECTOR(neis)[i];
                k = IGRAPH_FROM(graph, eid);
                if (VECTOR(outdegrees)[k] <= 0) {
                    /* Already removed, continue */
                    continue;
                }
                VECTOR(outdegrees)[k]--;
                VECTOR(outstrengths)[k] -= (weights ? VECTOR(*weights)[eid] : 1.0);
                if (VECTOR(outdegrees)[k] == 0) {
                    IGRAPH_CHECK(igraph_dqueue_push(&sinks, k));
                }
            }
            nodes_left--;
        }

        /* (3) No more sources or sinks. Find the node with the largest
         * difference between its out-strength and in-strength */
        v = -1; maxdiff = -IGRAPH_INFINITY;
        for (i = 0; i < no_of_nodes; i++) {
            if (VECTOR(outdegrees)[i] < 0) {
                continue;
            }
            diff = VECTOR(outstrengths)[i] - VECTOR(instrengths)[i];
            if (diff > maxdiff) {
                maxdiff = diff;
                v = i;
            }
        }
        if (v >= 0) {
            /* Remove vertex v */
            ordering[v] = order_next_pos++;
            /* Remove outgoing edges */
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) v,
                                         IGRAPH_OUT));
            j = igraph_vector_size(&neis);
            for (i = 0; i < j; i++) {
                eid = (long int) VECTOR(neis)[i];
                k = IGRAPH_TO(graph, eid);
                if (VECTOR(indegrees)[k] <= 0) {
                    /* Already removed, continue */
                    continue;
                }
                VECTOR(indegrees)[k]--;
                VECTOR(instrengths)[k] -= (weights ? VECTOR(*weights)[eid] : 1.0);
                if (VECTOR(indegrees)[k] == 0) {
                    IGRAPH_CHECK(igraph_dqueue_push(&sources, k));
                }
            }
            /* Remove incoming edges */
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) v,
                                         IGRAPH_IN));
            j = igraph_vector_size(&neis);
            for (i = 0; i < j; i++) {
                eid = (long int) VECTOR(neis)[i];
                k = IGRAPH_FROM(graph, eid);
                if (VECTOR(outdegrees)[k] <= 0) {
                    /* Already removed, continue */
                    continue;
                }
                VECTOR(outdegrees)[k]--;
                VECTOR(outstrengths)[k] -= (weights ? VECTOR(*weights)[eid] : 1.0);
                if (VECTOR(outdegrees)[k] == 0 && VECTOR(indegrees)[k] > 0) {
                    IGRAPH_CHECK(igraph_dqueue_push(&sinks, k));
                }
            }

            VECTOR(outdegrees)[v] = -1;
            VECTOR(indegrees)[v] = -1;
            nodes_left--;
        }
    }

    igraph_dqueue_destroy(&sinks);
    igraph_dqueue_destroy(&sources);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&outstrengths);
    igraph_vector_destroy(&instrengths);
    igraph_vector_destroy(&outdegrees);
    igraph_vector_destroy(&indegrees);
    IGRAPH_FINALLY_CLEAN(7);

    /* Tidy up the ordering */
    for (i = 0; i < no_of_nodes; i++) {
        if (ordering[i] < 0) {
            ordering[i] += no_of_nodes;
        }
    }

    /* Find the feedback edges based on the ordering */
    if (result != 0) {
        igraph_vector_clear(result);
        j = igraph_ecount(graph);
        for (i = 0; i < j; i++) {
            long int from = IGRAPH_FROM(graph, i), to = IGRAPH_TO(graph, i);
            if (from == to || ordering[from] > ordering[to]) {
                IGRAPH_CHECK(igraph_vector_push_back(result, i));
            }
        }
    }

    /* If we have also requested a layering, return that as well */
    if (layers != 0) {
        igraph_vector_t ranks;
        igraph_vector_long_t order_vec;

        IGRAPH_CHECK(igraph_vector_resize(layers, no_of_nodes));
        igraph_vector_null(layers);

        igraph_vector_long_view(&order_vec, ordering, no_of_nodes);

        IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&ranks, 0);

        IGRAPH_CHECK((int) igraph_vector_long_qsort_ind(&order_vec, &ranks, 0));

        for (i = 0; i < no_of_nodes; i++) {
            long int from = (long int) VECTOR(ranks)[i];
            IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) from,
                                          IGRAPH_OUT));
            k = igraph_vector_size(&neis);
            for (j = 0; j < k; j++) {
                long int to = (long int) VECTOR(neis)[j];
                if (from == to) {
                    continue;
                }
                if (ordering[from] > ordering[to]) {
                    continue;
                }
                if (VECTOR(*layers)[to] < VECTOR(*layers)[from] + 1) {
                    VECTOR(*layers)[to] = VECTOR(*layers)[from] + 1;
                }
            }
        }

        igraph_vector_destroy(&neis);
        igraph_vector_destroy(&ranks);
        IGRAPH_FINALLY_CLEAN(2);
    }

    /* Free the ordering vector */
    igraph_free(ordering);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * Solves the feedback arc set problem using integer programming.
 */
int igraph_i_feedback_arc_set_ip(const igraph_t *graph, igraph_vector_t *result,
                                 const igraph_vector_t *weights) {
#ifndef HAVE_GLPK
    IGRAPH_ERROR("GLPK is not available", IGRAPH_UNIMPLEMENTED);
#else

    igraph_integer_t no_of_components;
    igraph_integer_t no_of_vertices = igraph_vcount(graph);
    igraph_integer_t no_of_edges = igraph_ecount(graph);
    igraph_vector_t membership, ordering, vertex_remapping;
    igraph_vector_ptr_t vertices_by_components, edges_by_components;
    long int i, j, k, l, m, n, from, to;
    igraph_real_t weight;
    glp_prob *ip;
    glp_iocp parm;

    IGRAPH_VECTOR_INIT_FINALLY(&membership, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&ordering, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vertex_remapping, no_of_vertices);

    igraph_vector_clear(result);

    /* Decompose the graph into connected components */
    IGRAPH_CHECK(igraph_clusters(graph, &membership, 0, &no_of_components,
                                 IGRAPH_WEAK));

    /* Construct vertex and edge lists for each of the components */
    IGRAPH_CHECK(igraph_vector_ptr_init(&vertices_by_components, no_of_components));
    IGRAPH_CHECK(igraph_vector_ptr_init(&edges_by_components, no_of_components));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &vertices_by_components);
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &edges_by_components);
    for (i = 0; i < no_of_components; i++) {
        igraph_vector_t* vptr;
        vptr = IGRAPH_CALLOC(1, igraph_vector_t);
        if (vptr == 0) {
            IGRAPH_ERROR("cannot calculate feedback arc set using IP", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, vptr);
        IGRAPH_CHECK(igraph_vector_init(vptr, 0));
        IGRAPH_FINALLY_CLEAN(1);
        VECTOR(vertices_by_components)[i] = vptr;
    }
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&vertices_by_components, igraph_vector_destroy);
    for (i = 0; i < no_of_components; i++) {
        igraph_vector_t* vptr;
        vptr = IGRAPH_CALLOC(1, igraph_vector_t);
        if (vptr == 0) {
            IGRAPH_ERROR("cannot calculate feedback arc set using IP", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, vptr);
        IGRAPH_CHECK(igraph_vector_init(vptr, 0));
        IGRAPH_FINALLY_CLEAN(1);
        VECTOR(edges_by_components)[i] = vptr;
    }
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&edges_by_components, igraph_vector_destroy);
    for (i = 0; i < no_of_vertices; i++) {
        j = (long int) VECTOR(membership)[i];
        IGRAPH_CHECK(igraph_vector_push_back(VECTOR(vertices_by_components)[j], i));
    }
    for (i = 0; i < no_of_edges; i++) {
        j = (long int) VECTOR(membership)[(long)IGRAPH_FROM(graph, i)];
        IGRAPH_CHECK(igraph_vector_push_back(VECTOR(edges_by_components)[j], i));
    }

#define VAR2IDX(i, j) (i*(n-1)+j-(i+1)*i/2)

    /* Configure GLPK */
    IGRAPH_GLPK_SETUP();
    glp_init_iocp(&parm);
    parm.br_tech = GLP_BR_DTH;
    parm.bt_tech = GLP_BT_BLB;
    parm.pp_tech = GLP_PP_ALL;
    parm.presolve = GLP_ON;
    parm.binarize = GLP_OFF;
    parm.cb_func = igraph_i_glpk_interruption_hook;

    /* Solve an IP for feedback arc sets in each of the components */
    for (i = 0; i < no_of_components; i++) {
        igraph_vector_t* vertices_in_comp = (igraph_vector_t*)VECTOR(vertices_by_components)[i];
        igraph_vector_t* edges_in_comp = (igraph_vector_t*)VECTOR(edges_by_components)[i];

        /*
         * Let x_ij denote whether layer(i) < layer(j).
         *
         * The standard formulation of the problem is as follows:
         *
         * max sum_{i,j} w_ij x_ij
         *
         * subject to
         *
         * (1) x_ij + x_ji = 1   (i.e. either layer(i) < layer(j) or layer(i) > layer(j))
         *     for all i < j
         * (2) x_ij + x_jk + x_ki <= 2 for all i < j, i < k, j != k
         *
         * Note that x_ij = 1 implies that x_ji = 0 and vice versa; in other words,
         * x_ij = 1 - x_ji. Thus, we can get rid of the (1) constraints and half of the
         * x_ij variables (where j < i) if we rewrite constraints of type (2) as follows:
         *
         * (2a) x_ij + x_jk - x_ik <= 1 for all i < j, i < k, j < k
         * (2b) x_ij - x_kj - x_ik <= 0 for all i < j, i < k, j > k
         *
         * The goal function then becomes:
         *
         * max sum_{i 0) {
            glp_add_cols(ip, (int) k);
            for (j = 1; j <= k; j++) {
                glp_set_col_kind(ip, (int) j, GLP_BV);
            }
        }

        /* Set up coefficients in the goal function */
        k = igraph_vector_size(edges_in_comp);
        for (j = 0; j < k; j++) {
            l = (long int) VECTOR(*edges_in_comp)[j];
            from = (long int) VECTOR(vertex_remapping)[(long)IGRAPH_FROM(graph, l)];
            to = (long int) VECTOR(vertex_remapping)[(long)IGRAPH_TO(graph, l)];
            if (from == to) {
                continue;
            }

            weight = weights ? VECTOR(*weights)[l] : 1;

            if (from < to) {
                l = VAR2IDX(from, to);
                glp_set_obj_coef(ip, (int) l, glp_get_obj_coef(ip, (int) l) + weight);
            } else {
                l = VAR2IDX(to, from);
                glp_set_obj_coef(ip, (int) l, glp_get_obj_coef(ip, (int) l) - weight);
            }
        }

        /* Add constraints */
        if (n > 1) {
            glp_add_rows(ip, (int)(n * (n - 1) / 2 + n * (n - 1) * (n - 2) / 3));
            m = 1;
            for (j = 0; j < n; j++) {
                int ind[4];
                double val[4] = {0, 1, 1, -1};
                for (k = j + 1; k < n; k++) {
                    ind[1] = (int) VAR2IDX(j, k);
                    /* Type (2a) */
                    val[2] = 1;
                    for (l = k + 1; l < n; l++, m++) {
                        ind[2] = (int) VAR2IDX(k, l);
                        ind[3] = (int) VAR2IDX(j, l);
                        glp_set_row_bnds(ip, (int) m, GLP_UP, 1, 1);
                        glp_set_mat_row(ip, (int) m, 3, ind, val);
                    }
                    /* Type (2b) */
                    val[2] = -1;
                    for (l = j + 1; l < k; l++, m++) {
                        ind[2] = (int) VAR2IDX(l, k);
                        ind[3] = (int) VAR2IDX(j, l);
                        glp_set_row_bnds(ip, (int) m, GLP_UP, 0, 0);
                        glp_set_mat_row(ip, (int) m, 3, ind, val);
                    }
                }
            }
        }

        /* Solve the problem */
        IGRAPH_GLPK_CHECK(glp_intopt(ip, &parm), "Feedback arc set using IP failed");

        /* Find the ordering of the vertices */
        IGRAPH_CHECK(igraph_vector_resize(&ordering, n));
        igraph_vector_null(&ordering);
        m = n * (n - 1) / 2;
        j = 0; k = 1;
        for (l = 1; l <= m; l++) {
            /* variable l always corresponds to the (j, k) vertex pair */
            /* printf("(%ld, %ld) = %g\n", i, j, glp_mip_col_val(ip, l)); */
            if (glp_mip_col_val(ip, (int) l) > 0) {
                /* j comes earlier in the ordering than k */
                VECTOR(ordering)[j]++;
            } else {
                /* k comes earlier in the ordering than j */
                VECTOR(ordering)[k]++;
            }
            k++;
            if (k == n) {
                j++; k = j + 1;
            }
        }

        /* Find the feedback edges */
        k = igraph_vector_size(edges_in_comp);
        for (j = 0; j < k; j++) {
            l = (long int) VECTOR(*edges_in_comp)[j];
            from = (long int) VECTOR(vertex_remapping)[(long)IGRAPH_FROM(graph, l)];
            to = (long int) VECTOR(vertex_remapping)[(long)IGRAPH_TO(graph, l)];
            if (from == to || VECTOR(ordering)[from] < VECTOR(ordering)[to]) {
                IGRAPH_CHECK(igraph_vector_push_back(result, l));
            }
        }

        /* Clean up */
        glp_delete_prob(ip);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_ptr_destroy_all(&vertices_by_components);
    igraph_vector_ptr_destroy_all(&edges_by_components);
    igraph_vector_destroy(&vertex_remapping);
    igraph_vector_destroy(&ordering);
    igraph_vector_destroy(&membership);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
#endif
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/feedback_arc_set.h0000644000175100001710000000252500000000000024775 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_FEEDBACK_ARC_SET_INTERNAL_H
#define IGRAPH_FEEDBACK_ARC_SET_INTERNAL_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_vector.h"

__BEGIN_DECLS

int igraph_i_feedback_arc_set_undirected(const igraph_t *graph, igraph_vector_t *result,
        const igraph_vector_t *weights, igraph_vector_t *layering);
int igraph_i_feedback_arc_set_eades(const igraph_t *graph, igraph_vector_t *result,
                                    const igraph_vector_t *weights, igraph_vector_t *layering);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/graphicality.c0000644000175100001710000010203200000000000024216 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_graphicality.h"

#include "igraph_qsort.h"

#define IGRAPH_I_MULTI_EDGES_SW 0x02 /* 010, more than one edge allowed between distinct vertices */
#define IGRAPH_I_MULTI_LOOPS_SW 0x04 /* 100, more than one self-loop allowed on the same vertex   */

static int igraph_i_is_graphical_undirected_multi_loops(const igraph_vector_t *degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_undirected_loopless_multi(const igraph_vector_t *degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_undirected_loopy_simple(const igraph_vector_t *degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_undirected_simple(const igraph_vector_t *degrees, igraph_bool_t *res);

static int igraph_i_is_graphical_directed_loopy_multi(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_directed_loopless_multi(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_directed_loopy_simple(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res);
static int igraph_i_is_graphical_directed_simple(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res);

static int igraph_i_is_bigraphical_multi(const igraph_vector_t *degrees1, const igraph_vector_t *degrees2, igraph_bool_t *res);
static int igraph_i_is_bigraphical_simple(const igraph_vector_t *degrees1, const igraph_vector_t *degrees2, igraph_bool_t *res);


/**
 * \function igraph_is_graphical
 * \brief Is there a graph with the given degree sequence?
 *
 * Determines whether a sequence of integers can be the degree sequence of some graph.
 * The classical concept of graphicality assumes simple graphs. This function can perform
 * the check also when either self-loops, multi-edge, or both are allowed in the graph.
 *
 * 
 * For simple undirected graphs, the Erdős-Gallai conditions are checked using the linear-time
 * algorithm of Cloteaux. If both self-loops and multi-edges are allowed,
 * it is sufficient to chek that that sum of degrees is even. If only multi-edges are allowed, but
 * not self-loops, there is an additional condition that the sum of degrees be no smaller than twice
 * the maximum degree. If at most one self-loop is allowed per vertex, but no multi-edges, a modified
 * version of the Erdős-Gallai conditions are used (see Cairns & Mendan).
 *
 * 
 * For simple directed graphs, the Fulkerson-Chen-Anstee theorem is used with the relaxation by Berger.
 * If both self-loops and multi-edges are allowed, then it is sufficient to check that the sum of
 * in- and out-degrees is the same. If only multi-edges are allowed, but not self loops, there is an
 * additional condition that the sum of out-degrees (or equivalently, in-degrees) is no smaller than
 * the maximum total degree. If single self-loops are allowed, but not multi-edges, the problem is equivalent
 * to realizability as a simple bipartite graph, thus the Gale-Ryser theorem can be used; see
 * \ref igraph_is_bigraphical() for more information.
 *
 * 
 * References:
 *
 * 
 * P. Erdős and T. Gallai, Gráfok előírt fokú pontokkal, Matematikai Lapok 11, pp. 264–274 (1960).
 * https://users.renyi.hu/~p_erdos/1961-05.pdf
 *
 * 
 * Z Király, Recognizing graphic degree sequences and generating all realizations.
 * TR-2011-11, Egerváry Research Group, H-1117, Budapest, Hungary. ISSN 1587-4451 (2012).
 * http://bolyai.cs.elte.hu/egres/tr/egres-11-11.pdf
 *
 * 
 * B. Cloteaux, Is This for Real? Fast Graphicality Testing, Comput. Sci. Eng. 17, 91 (2015).
 * https://dx.doi.org/10.1109/MCSE.2015.125
 *
 * 
 * A. Berger, A note on the characterization of digraphic sequences, Discrete Math. 314, 38 (2014).
 * https://dx.doi.org/10.1016/j.disc.2013.09.010
 *
 * 
 * G. Cairns and S. Mendan, Degree Sequence for Graphs with Loops (2013).
 * https://arxiv.org/abs/1303.2145v1
 *
 * \param out_degrees A vector of integers specifying the degree sequence for
 *     undirected graphs or the out-degree sequence for directed graphs.
 * \param in_degrees A vector of integers specifying the in-degree sequence for
 *     directed graphs. For undirected graphs, it must be \c NULL.
 * \param allowed_edge_types The types of edges to allow in the graph:
 *     \clist
 *     \cli IGRAPH_SIMPLE_SW
 *       simple graphs (i.e. no self-loops or multi-edges allowed).
 *     \cli IGRAPH_LOOPS_SW
 *       single self-loops are allowed, but not multi-edges.
 *     \cli IGRAPH_MULTI_SW
 *       multi-edges are allowed, but not self-loops.
 *     \cli IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW
 *       both self-loops and multi-edges are allowed.
 *     \endclist
 * \param res Pointer to a Boolean. The result will be stored here.
 *
 * \return Error code.
 *
 * \sa \ref igraph_is_bigraphical() to check if a bi-degree-sequence can be realized as a bipartite graph;
 * \ref igraph_realize_degree_sequence() to construct a graph with a given degree sequence.
 *
 * Time complexity: O(n^2) for simple directed graphs, O(n log n) for graphs with self-loops,
 * and O(n) for all other cases, where n is the length of the degree sequence(s).
 */
int igraph_is_graphical(const igraph_vector_t *out_degrees,
                        const igraph_vector_t *in_degrees,
                        const igraph_edge_type_sw_t allowed_edge_types,
                        igraph_bool_t *res)
{
    /* Undirected case: */
    if (in_degrees == NULL)
    {
        if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW )) {
            /* Typically this case is used when multiple edges are allowed both as self-loops and
             * between distinct vertices. However, the conditions are the same even if multi-edges
             * are not allowed between distinct vertices (only as self-loops). Therefore, we
             * do not test IGRAPH_I_MULTI_EDGES_SW in the if (...). */
            return igraph_i_is_graphical_undirected_multi_loops(out_degrees, res);
        }
        else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_undirected_loopless_multi(out_degrees, res);
        }
        else if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_undirected_loopy_simple(out_degrees, res);
        }
        else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_undirected_simple(out_degrees, res);
        } else {
            /* Remainig case:
             *  - At most one self-loop per vertex but multi-edges between distinct vertices allowed.
             * These cases cannot currently be requested through the documented API,
             * so no explanatory error message for now. */
            return IGRAPH_UNIMPLEMENTED;
        }
    }
    /* Directed case: */
    else
    {
        if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) && (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW ) ) {
            return igraph_i_is_graphical_directed_loopy_multi(out_degrees, in_degrees, res);
        }
        else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_directed_loopless_multi(out_degrees, in_degrees, res);
        }
        else if ( (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_directed_loopy_simple(out_degrees, in_degrees, res);
        }
        else if ( ! (allowed_edge_types & IGRAPH_LOOPS_SW) && ! (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) ) {
            return igraph_i_is_graphical_directed_simple(out_degrees, in_degrees, res);
        } else {
            /* Remainig cases:
             *  - At most one self-loop per vertex but multi-edges between distinct vertices allowed.
             *  - At most one edge between distinct vertices but multi-self-loops allowed.
             * These cases cannot currently be requested through the documented API,
             * so no explanatory error message for now. */
            return IGRAPH_UNIMPLEMENTED;
        }
    }

    /* can't reach here */
}

/**
 * \function igraph_is_bigraphical
 * \brief Is there a bipartite graph with the given bi-degree-sequence?
 *
 * Determines whether two sequences of integers can be the degree sequences of
 * a bipartite graph. Such a pair of degree sequence is called \em bigraphical.
 *
 * 
 * When multi-edges are allowed, it is sufficient to check that the sum of degrees is the
 * same in the two partitions. For simple graphs, the Gale-Ryser theorem is used
 * with Berger's relaxation.
 *
 * 
 * References:
 *
 * 
 * H. J. Ryser, Combinatorial Properties of Matrices of Zeros and Ones, Can. J. Math. 9, 371 (1957).
 * https://dx.doi.org/10.4153/cjm-1957-044-3
 *
 * 
 * D. Gale, A theorem on flows in networks, Pacific J. Math. 7, 1073 (1957).
 * https://dx.doi.org/10.2140/pjm.1957.7.1073
 *
 * 
 * A. Berger, A note on the characterization of digraphic sequences, Discrete Math. 314, 38 (2014).
 * https://dx.doi.org/10.1016/j.disc.2013.09.010
 *
 * \param degrees1 A vector of integers specifying the degrees in the first partition
 * \param degrees2 A vector of integers specifying the degrees in the second partition
 * \param allowed_edge_types The types of edges to allow in the graph:
 *     \clist
 *     \cli IGRAPH_SIMPLE_SW
 *       simple graphs (i.e. no multi-edges allowed).
 *     \cli IGRAPH_MULTI_SW
 *       multi-edges are allowed.
 *     \endclist
 * \param res Pointer to a Boolean. The result will be stored here.
 *
 * \return Error code.
 *
 * \sa \ref igraph_is_graphical()
 *
 * Time complexity: O(n log n) for simple graphs, O(n) for multigraphs,
 * where n is the length of the larger degree sequence.
 */
int igraph_is_bigraphical(const igraph_vector_t *degrees1,
                          const igraph_vector_t *degrees2,
                          const igraph_edge_type_sw_t allowed_edge_types,
                          igraph_bool_t *res)
{
    /* Note: Bipartite graphs can't have self-loops so we ignore the IGRAPH_LOOPS_SW bit. */
    if (allowed_edge_types & IGRAPH_I_MULTI_EDGES_SW) {
        return igraph_i_is_bigraphical_multi(degrees1, degrees2, res);
    } else {
        return igraph_i_is_bigraphical_simple(degrees1, degrees2, res);
    }
}


/***** Undirected case *****/

/* Undirected graph with multi-self-loops:
 *  - Degrees must be non-negative.
 *  - The sum of degrees must be even.
 *
 * These conditions are valid regardless of whether multi-edges are allowed between distinct vertices.
 */
static int igraph_i_is_graphical_undirected_multi_loops(const igraph_vector_t *degrees, igraph_bool_t *res) {
    long int sum_parity = 0; /* 0 if the degree sum is even, 1 if it is odd */
    long int n = igraph_vector_size(degrees);
    long int i;

    for (i=0; i < n; ++i) {
        long int d = VECTOR(*degrees)[i];

        if (d < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }
        sum_parity = (sum_parity + d) & 1;
    }

    *res = (sum_parity == 0);

    return IGRAPH_SUCCESS;
}


/* Undirected loopless multigraph:
 *  - Degrees must be non-negative.
 *  - The sum of degrees must be even.
 *  - The sum of degrees must be no smaller than 2*d_max.
 */
static int igraph_i_is_graphical_undirected_loopless_multi(const igraph_vector_t *degrees, igraph_bool_t *res) {
    long int i;
    long int n = igraph_vector_size(degrees);
    long int dsum, dmax;

    /* Zero-length sequences are considered graphical. */
    if (n == 0) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    dsum = 0; dmax = 0;
    for (i=0; i < n; ++i) {
        long int d = VECTOR(*degrees)[i];

        if (d < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }
        dsum += d;
        if (d > dmax) {
            dmax = d;
        }
    }

    *res = (dsum % 2 == 0) && (dsum >= 2*dmax);

    return IGRAPH_SUCCESS;
}


/* Undirected graph with no multi-edges and at most one self-loop per vertex:
 *  - Degrees must be non-negative.
 *  - The sum of degrees must be even.
 *  - Use the modification of the Erdős-Gallai theorem due to Cairns and Mendan.
 */
static int igraph_i_is_graphical_undirected_loopy_simple(const igraph_vector_t *degrees, igraph_bool_t *res) {
    igraph_vector_t work;
    long int w, b, s, c, n, k;

    n = igraph_vector_size(degrees);

    /* Zero-length sequences are considered graphical. */
    if (n == 0) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    /* The conditions from the loopy multigraph case are necessary here as well. */
    IGRAPH_CHECK(igraph_i_is_graphical_undirected_multi_loops(degrees, res));
    if (! *res) {
        return IGRAPH_SUCCESS;
    }

    /*
     * We follow this paper:
     *
     * G. Cairns & S. Mendan: Degree Sequences for Graphs with Loops, 2013
     * https://arxiv.org/abs/1303.2145v1
     *
     * They give the following modification of the Erdős-Gallai theorem:
     *
     * A non-increasing degree sequence d_1 >= ... >= d_n has a realization as
     * a simple graph with loops (i.e. at most one self-loop allowed on each vertex)
     * iff
     *
     * \sum_{i=1}^k d_i <= k(k+1) + \sum_{i=k+1}^{n} min(d_i, k)
     *
     * for each k=1..n
     *
     * The difference from Erdős-Gallai is that here we have the term
     * k(k+1) instead of k(k-1).
     *
     * The implementation is analogous to igraph_i_is_graphical_undirected_simple(),
     * which in turn is based on Király 2012. See comments in that function for details.
     * w and k are zero-based here, unlike in the statement of the theorem above.
     */

    IGRAPH_CHECK(igraph_vector_copy(&work, degrees));
    IGRAPH_FINALLY(igraph_vector_destroy, &work);

    igraph_vector_reverse_sort(&work);

    *res = 1;
    w = n - 1; b = 0; s = 0; c = 0;
    for (k = 0; k < n; k++) {
        b += VECTOR(work)[k];
        c += w;
        while (w > k && VECTOR(work)[w] <= k + 1) {
            s += VECTOR(work)[w];
            c -= (k + 1);
            w--;
        }
        if (b > c + s + 2*(k + 1)) {
            *res = 0;
            break;
        }
        if (w == k) {
            break;
        }
    }

    igraph_vector_destroy(&work);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Undirected simple graph:
 *  - Degrees must be non-negative.
 *  - The sum of degrees must be even.
 *  - Use the Erdős-Gallai theorem.
 */
static int igraph_i_is_graphical_undirected_simple(const igraph_vector_t *degrees, igraph_bool_t *res) {
    igraph_vector_int_t num_degs; /* num_degs[d] is the # of vertices with degree d */
    const long int p = igraph_vector_size(degrees);
    long int dmin, dmax, dsum;
    long int n; /* number of non-zero degrees */
    long int k, sum_deg, sum_ni, sum_ini;
    long int i, dk;
    long int zverovich_bound;

    if (p == 0) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    /* The following implementation of the Erdős-Gallai test
     * is mostly a direct translation of the Python code given in
     *
     * Brian Cloteaux, Is This for Real? Fast Graphicality Testing,
     * Computing Prescriptions, pp. 91-95, vol. 17 (2015)
     * https://dx.doi.org/10.1109/MCSE.2015.125
     *
     * It uses counting sort to achieve linear runtime.
     */

    IGRAPH_VECTOR_INT_INIT_FINALLY(&num_degs, p);

    dmin = p; dmax = 0; dsum = 0; n = 0;
    for (i=0; i < p; ++i) {
        long int d = VECTOR(*degrees)[i];

        if (d < 0 || d >= p) {
            *res = 0;
            goto finish;
        }

        if (d > 0) {
            dmax = d > dmax ? d : dmax;
            dmin = d < dmin ? d : dmin;
            dsum += d;
            n++;
            VECTOR(num_degs)[d] += 1;
        }
    }

    if (dsum % 2 != 0) {
        *res = 0;
        goto finish;
    }

    if (n == 0) {
        *res = 1;
        goto finish; /* all degrees are zero => graphical */
    }

    /* According to:
     *
     * G. Cairns, S. Mendan, and Y. Nikolayevsky, A sharp refinement of a result of Zverovich-Zverovich,
     * Discrete Math. 338, 1085 (2015).
     * https://dx.doi.org/10.1016/j.disc.2015.02.001
     *
     * a sufficient but not necessary condition of graphicality for a sequence of
     * n strictly positive integers is that
     *
     * dmin * n >= floor( (dmax + dmin + 1)^2 / 4 ) - 1
     * if dmin is odd or (dmax + dmin) mod 4 == 1
     *
     * or
     *
     * dmin * n >= floor( (dmax + dmin + 1)^2 / 4 )
     * otherwise.
     */

    zverovich_bound = ((dmax + dmin + 1) * (dmax + dmin + 1)) / 4;
    if (dmin % 2 == 1 || (dmax + dmin) % 4 == 1) {
        zverovich_bound -= 1;
    }

    if (dmin*n >= zverovich_bound) {
        *res = 1;
        goto finish;
    }

    k = 0; sum_deg = 0; sum_ni = 0; sum_ini = 0;
    for (dk = dmax; dk >= dmin; --dk) {
        long int run_size, v;

        if (dk < k+1) {
            *res = 1;
            goto finish;
        }

        run_size = VECTOR(num_degs)[dk];
        if (run_size > 0) {
            if (dk < k + run_size) {
                run_size = dk - k;
            }
            sum_deg += run_size * dk;
            for (v=0; v < run_size; ++v) {
                sum_ni += VECTOR(num_degs)[k+v];
                sum_ini += (k+v) * VECTOR(num_degs)[k+v];
            }
            k += run_size;
            if (sum_deg > k*(n-1) - k*sum_ni + sum_ini) {
                *res = 0;
                goto finish;
            }
        }
    }

    *res = 1;

finish:
    igraph_vector_int_destroy(&num_degs);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/***** Directed case *****/

/* Directed loopy multigraph:
 *  - Degrees must be non-negative.
 *  - The sum of in- and out-degrees must be the same.
 */
static int igraph_i_is_graphical_directed_loopy_multi(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    long int sumdiff; /* difference between sum of in- and out-degrees */
    long int n = igraph_vector_size(out_degrees);
    long int i;

    if (igraph_vector_size(in_degrees) != n) {
        IGRAPH_ERROR("The length of out- and in-degree sequences must be the same.", IGRAPH_EINVAL);
    }

    sumdiff = 0;
    for (i=0; i < n; ++i) {
        long int dout = VECTOR(*out_degrees)[i];
        long int din  = VECTOR(*in_degrees)[i];

        if (dout < 0 || din < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }

        sumdiff += din - dout;
    }

    *res = sumdiff == 0;

    return IGRAPH_SUCCESS;
}


/* Directed loopless multigraph:
 *  - Degrees must be non-negative.
 *  - The sum of in- and out-degrees must be the same.
 *  - The sum of out-degrees must be no smaller than d_max,
 *    where d_max is the largest total degree.
 */
static int igraph_i_is_graphical_directed_loopless_multi(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    long int i, sumin, sumout, dmax;
    long int n = igraph_vector_size(out_degrees);

    if (igraph_vector_size(in_degrees) != n) {
        IGRAPH_ERROR("The length of out- and in-degree sequences must be the same.", IGRAPH_EINVAL);
    }

    sumin = 0; sumout = 0;
    dmax = 0;
    for (i=0; i < n; ++i) {
        long int dout = VECTOR(*out_degrees)[i];
        long int din  = VECTOR(*in_degrees)[i];
        long int d = dout + din;

        if (dout < 0 || din < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }

        sumin += din; sumout += dout;

        if (d > dmax) {
            dmax = d;
        }
    }

    *res = (sumin == sumout) && (sumout >= dmax);

    return IGRAPH_SUCCESS;
}


/* Directed graph with no multi-edges and at most one self-loop per vertex:
 *  - Degrees must be non-negative.
 *  - Equivalent to bipartite simple graph.
 */
static int igraph_i_is_graphical_directed_loopy_simple(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    long int n = igraph_vector_size(out_degrees);

    if (igraph_vector_size(in_degrees) != n) {
        IGRAPH_ERROR("The length of out- and in-degree sequences must be the same.", IGRAPH_EINVAL);
    }

    return igraph_i_is_bigraphical_simple(out_degrees, in_degrees, res);
}


/* Directed simple graph:
 *  - Degrees must be non-negative.
 *  - The sum of in- and out-degrees must be the same.
 *  - Use the Fulkerson-Chen-Anstee theorem
 */

typedef struct {
    const igraph_vector_t* first;
    const igraph_vector_t* second;
} igraph_i_qsort_dual_vector_cmp_data_t;

static int igraph_i_qsort_dual_vector_cmp_desc(void* data, const void *p1, const void *p2) {
    igraph_i_qsort_dual_vector_cmp_data_t* sort_data =
        (igraph_i_qsort_dual_vector_cmp_data_t*)data;
    long int index1 = *((long int*)p1);
    long int index2 = *((long int*)p2);
    if (VECTOR(*sort_data->first)[index1] < VECTOR(*sort_data->first)[index2]) {
        return 1;
    }
    if (VECTOR(*sort_data->first)[index1] > VECTOR(*sort_data->first)[index2]) {
        return -1;
    }
    if (VECTOR(*sort_data->second)[index1] < VECTOR(*sort_data->second)[index2]) {
        return 1;
    }
    if (VECTOR(*sort_data->second)[index1] > VECTOR(*sort_data->second)[index2]) {
        return -1;
    }
    return 0;
}

static int igraph_i_is_graphical_directed_simple(const igraph_vector_t *out_degrees, const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    igraph_vector_long_t index_array;
    long int i, j, vcount, lhs, rhs;
    igraph_i_qsort_dual_vector_cmp_data_t sort_data;

    /* The conditions from the loopy multigraph case are necessary here as well. */
    IGRAPH_CHECK(igraph_i_is_graphical_directed_loopy_multi(out_degrees, in_degrees, res));
    if (! *res) {
        return IGRAPH_SUCCESS;
    }

    vcount = igraph_vector_size(out_degrees);
    if (vcount == 0) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    /* Create an index vector that sorts the vertices by decreasing in-degree */
    IGRAPH_CHECK(igraph_vector_long_init_seq(&index_array, 0, vcount - 1));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &index_array);

    /* Set up the auxiliary struct for sorting */
    sort_data.first  = in_degrees;
    sort_data.second = out_degrees;

    /* Sort the index vector */
    igraph_qsort_r(VECTOR(index_array), vcount, sizeof(long int), &sort_data,
                   igraph_i_qsort_dual_vector_cmp_desc);

    /* Be optimistic, then check whether the Fulkerson–Chen–Anstee condition
     * holds for every k. In particular, for every k in [0; n), it must be true
     * that:
     *
     * \sum_{i=0}^k indegree[i] <=
     *     \sum_{i=0}^k min(outdegree[i], k) +
     *     \sum_{i=k+1}^{n-1} min(outdegree[i], k + 1)
     */

#define INDEGREE(x) (VECTOR(*in_degrees)[VECTOR(index_array)[x]])
#define OUTDEGREE(x) (VECTOR(*out_degrees)[VECTOR(index_array)[x]])

    *res = 1;
    lhs = 0;
    for (i = 0; i < vcount; i++) {
        lhs += INDEGREE(i);

        /* It is enough to check for indexes where the in-degree is about to
         * decrease in the next step; see "Stronger condition" in the Wikipedia
         * entry for the Fulkerson-Chen-Anstee condition */
        if (i != vcount - 1 && INDEGREE(i) == INDEGREE(i + 1)) {
            continue;
        }

        rhs = 0;
        for (j = 0; j <= i; j++) {
            rhs += OUTDEGREE(j) < i ? OUTDEGREE(j) : i;
        }
        for (j = i + 1; j < vcount; j++) {
            rhs += OUTDEGREE(j) < (i + 1) ? OUTDEGREE(j) : (i + 1);
        }

        if (lhs > rhs) {
            *res = 0;
            break;
        }
    }

#undef INDEGREE
#undef OUTDEGREE

    igraph_vector_long_destroy(&index_array);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}



/***** Bipartite case *****/

/* Bipartite graph with multi-eges:
 *  - Degrees must be non-negative.
 *  - Sum of degrees must be the same in the two partitions.
 */
static int igraph_i_is_bigraphical_multi(const igraph_vector_t *degrees1, const igraph_vector_t *degrees2, igraph_bool_t *res) {
    long int i;
    long int sum1, sum2;
    long int n1 = igraph_vector_size(degrees1), n2 = igraph_vector_size(degrees2);

    sum1 = 0;
    for (i=0; i < n1; ++i) {
        long int d = VECTOR(*degrees1)[i];

        if (d < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }

        sum1 += d;
    }

    sum2 = 0;
    for (i=0; i < n2; ++i) {
        long int d = VECTOR(*degrees2)[i];

        if (d < 0) {
            *res = 0;
            return IGRAPH_SUCCESS;
        }

        sum2 += d;
    }

    *res = (sum1 == sum2);

    return IGRAPH_SUCCESS;
}


/* Bipartite simple graph:
 *  - Degrees must be non-negative.
 *  - Sum of degrees must be the same in the two partitions.
 *  - Use the Gale-Ryser theorem.
 */
static int igraph_i_is_bigraphical_simple(const igraph_vector_t *degrees1, const igraph_vector_t *degrees2, igraph_bool_t *res) {
    igraph_vector_t sorted_deg1, sorted_deg2;
    long int n1 = igraph_vector_size(degrees1), n2 = igraph_vector_size(degrees2);
    long int i, k;
    long lhs_sum, partial_rhs_sum;

    if (n1 == 0 && n2 == 0) {
        *res = 1;
        return IGRAPH_SUCCESS;
    }

    /* The conditions from the multigraph case are necessary here as well. */
    IGRAPH_CHECK(igraph_i_is_bigraphical_multi(degrees1, degrees2, res));
    if (! *res) {
        return IGRAPH_SUCCESS;
    }

    /* Ensure that degrees1 is the shorter vector as a minor optimization: */
    if (n2 < n1) {
        const igraph_vector_t *tmp;
        long int n;

        tmp = degrees1;
        degrees1 = degrees2;
        degrees2 = tmp;

        n = n1;
        n1 = n2;
        n2 = n;
    }

    /* Copy and sort both vectors: */

    IGRAPH_CHECK(igraph_vector_copy(&sorted_deg1, degrees1));
    IGRAPH_FINALLY(igraph_vector_destroy, &sorted_deg1);
    igraph_vector_reverse_sort(&sorted_deg1); /* decreasing sort */

    IGRAPH_CHECK(igraph_vector_copy(&sorted_deg2, degrees2));
    IGRAPH_FINALLY(igraph_vector_destroy, &sorted_deg2);
    igraph_vector_sort(&sorted_deg2); /* increasing sort */

    /*
     * We follow the description of the Gale-Ryser theorem in:
     *
     * A. Berger, A note on the characterization of digraphic sequences, Discrete Math. 314, 38 (2014).
     * http://dx.doi.org/10.1016/j.disc.2013.09.010
     *
     * Gale-Ryser condition with 0-based indexing:
     *
     * a_i and b_i denote the degree sequences of the two partitions.
     *
     * Assuming that a_0 >= a_1 >= ... >= a_{n_1 - 1},
     *
     * \sum_{i=0}^k a_i <= \sum_{j=0}^{n_2} min(b_i, k+1)
     *
     * for all 0 <= k < n_1
     */

    /* While this formulation does not require sorting degree2,
     * doing so allows for a linear-time incremental computation
     * of the inequality's right-hand-side.
     */

    *res = 1; /* be optimistic */
    lhs_sum = 0;
    partial_rhs_sum = 0; /* the sum of those elements in sorted_deg2 which are <= (k+1) */
    i = 0; /* points past the first element of sorted_deg2 which > (k+1) */
    for (k=0; k < n1; ++k) {
        lhs_sum += VECTOR(sorted_deg1)[k];

        /* Based on Theorem 3 in [Berger 2014], it is sufficient to do the check
         * for k such that a_k > a_{k+1} and for k=(n_1-1).
         */
        if (k < n1-1 && VECTOR(sorted_deg1)[k] == VECTOR(sorted_deg1)[k+1])
            continue;

        while (i < n2 && VECTOR(sorted_deg2)[i] <= k+1) {
            partial_rhs_sum += VECTOR(sorted_deg2)[i];
            i++;
        }

        /* rhs_sum for a given k is partial_rhs_sum + (n2 - i) * (k+1) */
        if (lhs_sum > partial_rhs_sum + (n2 - i) * (k+1) ) {
            *res = 0;
            break;
        }
    }

    igraph_vector_destroy(&sorted_deg2);
    igraph_vector_destroy(&sorted_deg1);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}


/***** Legacy functions *****/

#define SUCCEED {   \
        if (res) {        \
            *res = 1;       \
        }                 \
        return IGRAPH_SUCCESS; \
    }

#define FAIL {   \
        if (res) {     \
            *res = 0;    \
        }              \
        return IGRAPH_SUCCESS; \
    }

/**
 * \function igraph_is_degree_sequence
 * \brief Determines whether a degree sequence is valid.
 *
 * \deprecated-by igraph_is_graphical 0.9
 *
 * 
 * A sequence of n integers is a valid degree sequence if there exists some
 * graph where the degree of the i-th vertex is equal to the i-th element of the
 * sequence. Note that the graph may contain multiple or loop edges; if you are
 * interested in whether the degrees of some \em simple graph may realize the
 * given sequence, use \ref igraph_is_graphical_degree_sequence.
 *
 * 
 * In particular, the function checks whether all the degrees are non-negative.
 * For undirected graphs, it also checks whether the sum of degrees is even.
 * For directed graphs, the function checks whether the lengths of the two
 * degree vectors are equal and whether their sums are also equal. These are
 * known sufficient and necessary conditions for a degree sequence to be
 * valid.
 *
 * \param out_degrees  an integer vector specifying the degree sequence for
 *     undirected graphs or the out-degree sequence for directed graphs.
 * \param in_degrees   an integer vector specifying the in-degrees of the
 *     vertices for directed graphs. For undirected graphs, this must be null.
 * \param res  pointer to a boolean variable, the result will be stored here
 * \return Error code.
 *
 * Time complexity: O(n), where n is the length of the degree sequence.
 */
int igraph_is_degree_sequence(const igraph_vector_t *out_degrees,
                              const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    IGRAPH_WARNING("igraph_is_degree_sequence is deprecated, use igraph_is_graphical.");

    /* degrees must be non-negative */
    if (igraph_vector_any_smaller(out_degrees, 0)) {
        FAIL;
    }
    if (in_degrees && igraph_vector_any_smaller(in_degrees, 0)) {
        FAIL;
    }

    if (in_degrees == 0) {
        /* sum of degrees must be even */
        if (((long int)igraph_vector_sum(out_degrees) % 2) != 0) {
            FAIL;
        }
    } else {
        /* length of the two degree vectors must be equal */
        if (igraph_vector_size(out_degrees) != igraph_vector_size(in_degrees)) {
            FAIL;
        }
        /* sum of in-degrees must be equal to sum of out-degrees */
        if (igraph_vector_sum(out_degrees) != igraph_vector_sum(in_degrees)) {
            FAIL;
        }
    }

    SUCCEED;
}

#undef SUCCEED
#undef FAIL


/**
 * \function igraph_is_graphical_degree_sequence
 * \brief Determines whether a sequence of integers can be the degree sequence of some simple graph.
 *
 * \deprecated-by igraph_is_graphical 0.9
 *
 * 
 * References:
 *
 * 
 * Hakimi SL: On the realizability of a set of integers as degrees of the
 * vertices of a simple graph. J SIAM Appl Math 10:496-506, 1962.
 *
 * 
 * PL Erdős, I Miklós and Z Toroczkai: A simple Havel-Hakimi type algorithm
 * to realize graphical degree sequences of directed graphs.
 * The Electronic Journal of Combinatorics 17(1):R66, 2010.
 * https://dx.doi.org/10.1017/S0963548317000499
 *
 * 
 * Z Kiraly: Recognizing graphic degree sequences and generating all
 * realizations. TR-2011-11, Egervary Research Group, H-1117, Budapest,
 * Hungary. ISSN 1587-4451, 2012.
 * https://www.cs.elte.hu/egres/tr/egres-11-11.pdf
 *
 * \param out_degrees  an integer vector specifying the degree sequence for
 *     undirected graphs or the out-degree sequence for directed graphs.
 * \param in_degrees   an integer vector specifying the in-degrees of the
 *     vertices for directed graphs. For undirected graphs, this must be null.
 * \param res  pointer to a boolean variable, the result will be stored here
 * \return Error code.
 *
 * Time complexity: O(n log n) for undirected graphs, O(n^2) for directed
 *                  graphs, where n is the length of the degree sequence.
 */
int igraph_is_graphical_degree_sequence(const igraph_vector_t *out_degrees,
                                        const igraph_vector_t *in_degrees, igraph_bool_t *res) {
    IGRAPH_WARNING("igraph_is_graphical_degree_sequence is deprecated, use igraph_is_graphical.");
    return igraph_is_graphical(out_degrees, in_degrees, IGRAPH_SIMPLE_SW, res);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/matching.c0000644000175100001710000012314200000000000023335 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2012  Tamas Nepusz 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_matching.h"

#include "igraph_adjlist.h"
#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_structural.h"

#include 

/* #define MATCHING_DEBUG */

#ifdef _MSC_VER
/* MSVC does not support variadic macros */
#include 
static void debug(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
#ifdef MATCHING_DEBUG
    vfprintf(stderr, fmt, args);
#endif
    va_end(args);
}
#else
#ifdef MATCHING_DEBUG
    #define debug(...) fprintf(stderr, __VA_ARGS__)
#else
    #define debug(...)
#endif
#endif

/**
 * \function igraph_is_matching
 * Checks whether the given matching is valid for the given graph.
 *
 * This function checks a matching vector and verifies whether its length
 * matches the number of vertices in the given graph, its values are between
 * -1 (inclusive) and the number of vertices (exclusive), and whether there
 * exists a corresponding edge in the graph for every matched vertex pair.
 * For bipartite graphs, it also verifies whether the matched vertices are
 * in different parts of the graph.
 *
 * \param graph The input graph. It can be directed but the edge directions
 *              will be ignored.
 * \param types If the graph is bipartite and you are interested in bipartite
 *              matchings only, pass the vertex types here. If the graph is
 *              non-bipartite, simply pass \c NULL.
 * \param matching The matching itself. It must be a vector where element i
 *                 contains the ID of the vertex that vertex i is matched to,
 *                 or -1 if vertex i is unmatched.
 * \param result Pointer to a boolean variable, the result will be returned
 *               here.
 *
 * \sa \ref igraph_is_maximal_matching() if you are also interested in whether
 *     the matching is maximal (i.e. non-extendable).
 *
 * Time complexity: O(|V|+|E|) where |V| is the number of vertices and
 * |E| is the number of edges.
 *
 * \example examples/simple/igraph_maximum_bipartite_matching.c
 */
int igraph_is_matching(const igraph_t* graph,
                       const igraph_vector_bool_t* types, const igraph_vector_long_t* matching,
                       igraph_bool_t* result) {
    long int i, j, no_of_nodes = igraph_vcount(graph);
    igraph_bool_t conn;

    /* Checking match vector length */
    if (igraph_vector_long_size(matching) != no_of_nodes) {
        *result = 0; return IGRAPH_SUCCESS;
    }

    for (i = 0; i < no_of_nodes; i++) {
        j = VECTOR(*matching)[i];

        /* Checking range of each element in the match vector */
        if (j < -1 || j >= no_of_nodes) {
            *result = 0; return IGRAPH_SUCCESS;
        }
        /* When i is unmatched, we're done */
        if (j == -1) {
            continue;
        }
        /* Matches must be mutual */
        if (VECTOR(*matching)[j] != i) {
            *result = 0; return IGRAPH_SUCCESS;
        }
        /* Matched vertices must be connected */
        IGRAPH_CHECK(igraph_are_connected(graph, (igraph_integer_t) i,
                                          (igraph_integer_t) j, &conn));
        if (!conn) {
            /* Try the other direction -- for directed graphs */
            IGRAPH_CHECK(igraph_are_connected(graph, (igraph_integer_t) j,
                                              (igraph_integer_t) i, &conn));
            if (!conn) {
                *result = 0; return IGRAPH_SUCCESS;
            }
        }
    }

    if (types != 0) {
        /* Matched vertices must be of different types */
        for (i = 0; i < no_of_nodes; i++) {
            j = VECTOR(*matching)[i];
            if (j == -1) {
                continue;
            }
            if (VECTOR(*types)[i] == VECTOR(*types)[j]) {
                *result = 0; return IGRAPH_SUCCESS;
            }
        }
    }

    *result = 1;
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_is_maximal_matching
 * Checks whether a matching in a graph is maximal.
 *
 * A matching is maximal if and only if there exists no unmatched vertex in a
 * graph such that one of its neighbors is also unmatched.
 *
 * \param graph The input graph. It can be directed but the edge directions
 *              will be ignored.
 * \param types If the graph is bipartite and you are interested in bipartite
 *              matchings only, pass the vertex types here. If the graph is
 *              non-bipartite, simply pass \c NULL.
 * \param matching The matching itself. It must be a vector where element i
 *                 contains the ID of the vertex that vertex i is matched to,
 *                 or -1 if vertex i is unmatched.
 * \param result Pointer to a boolean variable, the result will be returned
 *               here.
 *
 * \sa \ref igraph_is_matching() if you are only interested in whether a
 *     matching vector is valid for a given graph.
 *
 * Time complexity: O(|V|+|E|) where |V| is the number of vertices and
 * |E| is the number of edges.
 *
 * \example examples/simple/igraph_maximum_bipartite_matching.c
 */
int igraph_is_maximal_matching(const igraph_t* graph,
                               const igraph_vector_bool_t* types, const igraph_vector_long_t* matching,
                               igraph_bool_t* result) {
    long int i, j, n, no_of_nodes = igraph_vcount(graph);
    igraph_vector_t neis;
    igraph_bool_t valid;

    IGRAPH_CHECK(igraph_is_matching(graph, types, matching, &valid));
    if (!valid) {
        *result = 0; return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    valid = 1;
    for (i = 0; i < no_of_nodes; i++) {
        j = VECTOR(*matching)[i];
        if (j != -1) {
            continue;
        }

        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
                                      IGRAPH_ALL));
        n = igraph_vector_size(&neis);
        for (j = 0; j < n; j++) {
            if (VECTOR(*matching)[(long int)VECTOR(neis)[j]] == -1) {
                if (types == 0 ||
                    VECTOR(*types)[i] != VECTOR(*types)[(long int)VECTOR(neis)[j]]) {
                    valid = 0; break;
                }
            }
        }
    }

    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(1);

    *result = valid;
    return IGRAPH_SUCCESS;
}

static int igraph_i_maximum_bipartite_matching_unweighted(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
        igraph_vector_long_t* matching);
static int igraph_i_maximum_bipartite_matching_weighted(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
        igraph_real_t* matching_weight, igraph_vector_long_t* matching,
        const igraph_vector_t* weights, igraph_real_t eps);

#define MATCHED(v) (VECTOR(match)[v] != -1)
#define UNMATCHED(v) (!MATCHED(v))

/**
 * \function igraph_maximum_bipartite_matching
 * Calculates a maximum matching in a bipartite graph.
 *
 * A matching in a bipartite graph is a partial assignment of vertices
 * of the first kind to vertices of the second kind such that each vertex of
 * the first kind is matched to at most one vertex of the second kind and
 * vice versa, and matched vertices must be connected by an edge in the graph.
 * The size (or cardinality) of a matching is the number of edges.
 * A matching is a maximum matching if there exists no other matching with
 * larger cardinality. For weighted graphs, a maximum matching is a matching
 * whose edges have the largest possible total weight among all possible
 * matchings.
 *
 * 
 * Maximum matchings in bipartite graphs are found by the push-relabel algorithm
 * with greedy initialization and a global relabeling after every n/2 steps where
 * n is the number of vertices in the graph.
 *
 * 
 * References: Cherkassky BV, Goldberg AV, Martin P, Setubal JC and Stolfi J:
 * Augment or push: A computational study of bipartite matching and
 * unit-capacity flow algorithms. ACM Journal of Experimental Algorithmics 3,
 * 1998.
 *
 * 
 * Kaya K, Langguth J, Manne F and Ucar B: Experiments on push-relabel-based
 * maximum cardinality matching algorithms for bipartite graphs. Technical
 * Report TR/PA/11/33 of the Centre Europeen de Recherche et de Formation
 * Avancee en Calcul Scientifique, 2011.
 *
 * \param graph The input graph. It can be directed but the edge directions
 *              will be ignored.
 * \param types Boolean vector giving the vertex types of the graph.
 * \param matching_size The size of the matching (i.e. the number of matched
 *                      vertex pairs will be returned here). It may be \c NULL
 *                      if you don't need this.
 * \param matching_weight The weight of the matching if the edges are weighted,
 *                        or the size of the matching again if the edges are
 *                        unweighted. It may be \c NULL if you don't need this.
 * \param matching The matching itself. It must be a vector where element i
 *                 contains the ID of the vertex that vertex i is matched to,
 *                 or -1 if vertex i is unmatched.
 * \param weights A null pointer (=no edge weights), or a vector giving the
 *                weights of the edges. Note that the algorithm is stable
 *                only for integer weights.
 * \param eps A small real number used in equality tests in the weighted
 *            bipartite matching algorithm. Two real numbers are considered
 *            equal in the algorithm if their difference is smaller than
 *            \c eps. This is required to avoid the accumulation of numerical
 *            errors. It is advised to pass a value derived from the
 *            \c DBL_EPSILON constant in \c float.h here. If you are
 *            running the algorithm with no \c weights vector, this argument
 *            is ignored.
 * \return Error code.
 *
 * Time complexity: O(sqrt(|V|) |E|) for unweighted graphs (according to the
 * technical report referenced above), O(|V||E|) for weighted graphs.
 *
 * \example examples/simple/igraph_maximum_bipartite_matching.c
 */
int igraph_maximum_bipartite_matching(const igraph_t* graph,
                                      const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
                                      igraph_real_t* matching_weight, igraph_vector_long_t* matching,
                                      const igraph_vector_t* weights, igraph_real_t eps) {

    /* Sanity checks */
    if (igraph_vector_bool_size(types) < igraph_vcount(graph)) {
        IGRAPH_ERROR("types vector too short", IGRAPH_EINVAL);
    }
    if (weights && igraph_vector_size(weights) < igraph_ecount(graph)) {
        IGRAPH_ERROR("weights vector too short", IGRAPH_EINVAL);
    }

    if (weights == 0) {
        IGRAPH_CHECK(igraph_i_maximum_bipartite_matching_unweighted(graph, types,
                     matching_size, matching));
        if (matching_weight != 0) {
            *matching_weight = *matching_size;
        }
        return IGRAPH_SUCCESS;
    } else {
        IGRAPH_CHECK(igraph_i_maximum_bipartite_matching_weighted(graph, types,
                     matching_size, matching_weight, matching, weights, eps));
        return IGRAPH_SUCCESS;
    }
}

static int igraph_i_maximum_bipartite_matching_unweighted_relabel(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_vector_t* labels,
        igraph_vector_long_t* matching, igraph_bool_t smaller_set);

/**
 * Finding maximum bipartite matchings on bipartite graphs using the
 * push-relabel algorithm.
 *
 * The implementation follows the pseudocode in Algorithm 1 of the
 * following paper:
 *
 * Kaya K, Langguth J, Manne F and Ucar B: Experiments on push-relabel-based
 * maximum cardinality matching algorithms for bipartite graphs. Technical
 * Report TR/PA/11/33 of CERFACS (Centre Européen de Recherche et de Formation
 * Avancée en Calcul Scientifique).
 * http://www.cerfacs.fr/algor/reports/2011/TR_PA_11_33.pdf
 */
static int igraph_i_maximum_bipartite_matching_unweighted(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
        igraph_vector_long_t* matching) {
    long int i, j, k, n, no_of_nodes = igraph_vcount(graph);
    long int num_matched;             /* number of matched vertex pairs */
    igraph_vector_long_t match;       /* will store the matching */
    igraph_vector_t labels;           /* will store the labels */
    igraph_vector_t neis;             /* used to retrieve the neighbors of a node */
    igraph_dqueue_long_t q;           /* a FIFO for push ordering */
    igraph_bool_t smaller_set;        /* denotes which part of the bipartite graph is smaller */
    long int label_changed = 0;       /* Counter to decide when to run a global relabeling */
    long int relabeling_freq = no_of_nodes / 2;

    /* We will use:
     * - FIFO push ordering
     * - global relabeling frequency: n/2 steps where n is the number of nodes
     * - simple greedy matching for initialization
     */

    /* (1) Initialize data structures */
    IGRAPH_CHECK(igraph_vector_long_init(&match, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &match);
    IGRAPH_VECTOR_INIT_FINALLY(&labels, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_long_init(&q, 0));
    IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);

    /* (2) Initially, every node is unmatched */
    igraph_vector_long_fill(&match, -1);

    /* (3) Find an initial matching in a greedy manner.
     *     At the same time, find which side of the graph is smaller. */
    num_matched = 0; j = 0;
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i]) {
            j++;
        }
        if (MATCHED(i)) {
            continue;
        }
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
                                      IGRAPH_ALL));
        n = igraph_vector_size(&neis);
        for (j = 0; j < n; j++) {
            k = (long int) VECTOR(neis)[j];
            if (VECTOR(*types)[k] == VECTOR(*types)[i]) {
                IGRAPH_ERROR("Graph is not bipartite with supplied types vector", IGRAPH_EINVAL);
            }
            if (UNMATCHED(k)) {
                /* We match vertex i to vertex VECTOR(neis)[j] */
                VECTOR(match)[k] = i;
                VECTOR(match)[i] = k;
                num_matched++;
                break;
            }
        }
    }
    smaller_set = (j <= no_of_nodes / 2);

    /* (4) Set the initial labeling -- lines 1 and 2 in the tech report */
    IGRAPH_CHECK(igraph_i_maximum_bipartite_matching_unweighted_relabel(
                     graph, types, &labels, &match, smaller_set));

    /* (5) Fill the push queue with the unmatched nodes from the smaller set. */
    for (i = 0; i < no_of_nodes; i++) {
        if (UNMATCHED(i) && VECTOR(*types)[i] == smaller_set) {
            IGRAPH_CHECK(igraph_dqueue_long_push(&q, i));
        }
    }

    /* (6) Main loop from the referenced tech report -- lines 4--13 */
    label_changed = 0;
    while (!igraph_dqueue_long_empty(&q)) {
        long int v = igraph_dqueue_long_pop(&q);             /* Line 13 */
        long int u = -1, label_u = 2 * no_of_nodes;
        long int w;

        if (label_changed >= relabeling_freq) {
            /* Run global relabeling */
            IGRAPH_CHECK(igraph_i_maximum_bipartite_matching_unweighted_relabel(
                             graph, types, &labels, &match, smaller_set));
            label_changed = 0;
        }

        debug("Considering vertex %ld\n", v);

        /* Line 5: find row u among the neighbors of v s.t. label(u) is minimal */
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v,
                                      IGRAPH_ALL));
        n = igraph_vector_size(&neis);
        for (i = 0; i < n; i++) {
            if (VECTOR(labels)[(long int)VECTOR(neis)[i]] < label_u) {
                u = (long int) VECTOR(neis)[i];
                label_u = (long int) VECTOR(labels)[u];
                label_changed++;
            }
        }

        debug("  Neighbor with smallest label: %ld (label=%ld)\n", u, label_u);

        if (label_u < no_of_nodes) {                         /* Line 6 */
            VECTOR(labels)[v] = VECTOR(labels)[u] + 1;         /* Line 7 */
            if (MATCHED(u)) {                                  /* Line 8 */
                w = VECTOR(match)[u];
                debug("  Vertex %ld is matched to %ld, performing a double push\n", u, w);
                if (w != v) {
                    VECTOR(match)[u] = -1; VECTOR(match)[w] = -1;  /* Line 9 */
                    IGRAPH_CHECK(igraph_dqueue_long_push(&q, w));  /* Line 10 */
                    debug("  Unmatching & activating vertex %ld\n", w);
                    num_matched--;
                }
            }
            VECTOR(match)[u] = v; VECTOR(match)[v] = u;      /* Line 11 */
            num_matched++;
            VECTOR(labels)[u] += 2;                          /* Line 12 */
            label_changed++;
        }
    }

    /* Fill the output parameters */
    if (matching != 0) {
        IGRAPH_CHECK(igraph_vector_long_update(matching, &match));
    }
    if (matching_size != 0) {
        *matching_size = (igraph_integer_t) num_matched;
    }

    /* Release everything */
    igraph_dqueue_long_destroy(&q);
    igraph_vector_destroy(&neis);
    igraph_vector_destroy(&labels);
    igraph_vector_long_destroy(&match);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}

static int igraph_i_maximum_bipartite_matching_unweighted_relabel(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_vector_t* labels,
        igraph_vector_long_t* match, igraph_bool_t smaller_set) {
    long int i, j, n, no_of_nodes = igraph_vcount(graph), matched_to;
    igraph_dqueue_long_t q;
    igraph_vector_t neis;

    debug("Running global relabeling.\n");

    /* Set all the labels to no_of_nodes first */
    igraph_vector_fill(labels, no_of_nodes);

    /* Allocate vector for neighbors */
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    /* Create a FIFO for the BFS and initialize it with the unmatched rows
     * (i.e. members of the larger set) */
    IGRAPH_CHECK(igraph_dqueue_long_init(&q, 0));
    IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i] != smaller_set && VECTOR(*match)[i] == -1) {
            IGRAPH_CHECK(igraph_dqueue_long_push(&q, i));
            VECTOR(*labels)[i] = 0;
        }
    }

    /* Run the BFS */
    while (!igraph_dqueue_long_empty(&q)) {
        long int v = igraph_dqueue_long_pop(&q);
        long int w;

        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v,
                                      IGRAPH_ALL));

        n = igraph_vector_size(&neis);
        for (j = 0; j < n; j++) {
            w = (long int) VECTOR(neis)[j];
            if (VECTOR(*labels)[w] == no_of_nodes) {
                VECTOR(*labels)[w] = VECTOR(*labels)[v] + 1;
                matched_to = VECTOR(*match)[w];
                if (matched_to != -1 && VECTOR(*labels)[matched_to] == no_of_nodes) {
                    IGRAPH_CHECK(igraph_dqueue_long_push(&q, matched_to));
                    VECTOR(*labels)[matched_to] = VECTOR(*labels)[w] + 1;
                }
            }
        }
    }

    igraph_dqueue_long_destroy(&q);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/**
 * Finding maximum bipartite matchings on bipartite graphs using the
 * Hungarian algorithm (a.k.a. Kuhn-Munkres algorithm).
 *
 * The algorithm uses a maximum cardinality matching on a subset of
 * tight edges as a starting point. This is achieved by
 * \c igraph_i_maximum_bipartite_matching_unweighted on the restricted
 * graph.
 *
 * The algorithm works reliably only if the weights are integers. The
 * \c eps parameter should specity a very small number; if the slack on
 * an edge falls below \c eps, it will be considered tight. If all your
 * weights are integers, you can safely set \c eps to zero.
 */
static int igraph_i_maximum_bipartite_matching_weighted(
        const igraph_t* graph,
        const igraph_vector_bool_t* types, igraph_integer_t* matching_size,
        igraph_real_t* matching_weight, igraph_vector_long_t* matching,
        const igraph_vector_t* weights, igraph_real_t eps) {
    long int i, j, k, n, no_of_nodes, no_of_edges;
    igraph_integer_t u, v, w, msize;
    igraph_t newgraph;
    igraph_vector_long_t match;       /* will store the matching */
    igraph_vector_t slack;            /* will store the slack on each edge */
    igraph_vector_t parent;           /* parent vertices during a BFS */
    igraph_vector_t vec1, vec2;       /* general temporary vectors */
    igraph_vector_t labels;           /* will store the labels */
    igraph_dqueue_long_t q;           /* a FIFO for BST */
    igraph_bool_t smaller_set_type;   /* denotes which part of the bipartite graph is smaller */
    igraph_vector_t smaller_set;      /* stores the vertex IDs of the smaller set */
    igraph_vector_t larger_set;       /* stores the vertex IDs of the larger set */
    long int smaller_set_size;        /* size of the smaller set */
    long int larger_set_size;         /* size of the larger set */
    igraph_real_t dual;               /* solution of the dual problem */
    IGRAPH_UNUSED(dual);              /* We mark it as unused to prevent warnings about unused-but-set-variables. */
    igraph_adjlist_t tight_phantom_edges; /* adjacency list to manage tight phantom edges */
    igraph_integer_t alternating_path_endpoint;
    igraph_vector_int_t* neis;
    igraph_vector_int_t *neis2;
    igraph_inclist_t inclist;         /* incidence list of the original graph */

    /* The Hungarian algorithm is originally for complete bipartite graphs.
     * For non-complete bipartite graphs, a phantom edge of weight zero must be
     * added between every pair of non-connected vertices. We don't do this
     * explicitly of course. See the comments below about how phantom edges
     * are taken into account. */

    no_of_nodes = igraph_vcount(graph);
    no_of_edges = igraph_ecount(graph);
    if (eps < 0) {
        IGRAPH_WARNING("negative epsilon given, clamping to zero");
        eps = 0;
    }

    /* (1) Initialize data structures */
    IGRAPH_CHECK(igraph_vector_long_init(&match, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &match);
    IGRAPH_CHECK(igraph_vector_init(&slack, no_of_edges));
    IGRAPH_FINALLY(igraph_vector_destroy, &slack);
    IGRAPH_VECTOR_INIT_FINALLY(&vec1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&vec2, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&labels, no_of_nodes);
    IGRAPH_CHECK(igraph_dqueue_long_init(&q, 0));
    IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);
    IGRAPH_VECTOR_INIT_FINALLY(&parent, no_of_nodes);
    IGRAPH_CHECK(igraph_adjlist_init_empty(&tight_phantom_edges,
                                           (igraph_integer_t) no_of_nodes));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &tight_phantom_edges);
    IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
    IGRAPH_VECTOR_INIT_FINALLY(&smaller_set, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&larger_set, 0);

    /* (2) Find which set is the smaller one */
    j = 0;
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i] == 0) {
            j++;
        }
    }
    smaller_set_type = (j > no_of_nodes / 2);
    smaller_set_size = smaller_set_type ? (no_of_nodes - j) : j;
    larger_set_size = no_of_nodes - smaller_set_size;
    IGRAPH_CHECK(igraph_vector_reserve(&smaller_set, smaller_set_size));
    IGRAPH_CHECK(igraph_vector_reserve(&larger_set, larger_set_size));
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(*types)[i] == smaller_set_type) {
            IGRAPH_CHECK(igraph_vector_push_back(&smaller_set, i));
        } else {
            IGRAPH_CHECK(igraph_vector_push_back(&larger_set, i));
        }
    }

    /* (3) Calculate the initial labeling and the set of tight edges. Use the
     *     smaller set only. Here we can assume that there are no phantom edges
     *     among the tight ones. */
    dual = 0;
    for (i = 0; i < no_of_nodes; i++) {
        igraph_real_t max_weight = 0;

        if (VECTOR(*types)[i] != smaller_set_type) {
            VECTOR(labels)[i] = 0;
            continue;
        }

        neis = igraph_inclist_get(&inclist, i);
        n = igraph_vector_int_size(neis);
        for (j = 0, k = 0; j < n; j++) {
            k = (long int) VECTOR(*neis)[j];
            u = IGRAPH_OTHER(graph, k, i);
            if (VECTOR(*types)[u] == VECTOR(*types)[i]) {
                IGRAPH_ERROR("Graph is not bipartite with supplied types vector", IGRAPH_EINVAL);
            }
            if (VECTOR(*weights)[k] > max_weight) {
                max_weight = VECTOR(*weights)[k];
            }
        }

        VECTOR(labels)[i] = max_weight;
        dual += max_weight;
    }

    igraph_vector_clear(&vec1);
    IGRAPH_CHECK(igraph_get_edgelist(graph, &vec2, 0));
#define IS_TIGHT(i) (VECTOR(slack)[i] <= eps)
    for (i = 0, j = 0; i < no_of_edges; i++, j += 2) {
        u = (igraph_integer_t) VECTOR(vec2)[j];
        v = (igraph_integer_t) VECTOR(vec2)[j + 1];
        VECTOR(slack)[i] = VECTOR(labels)[u] + VECTOR(labels)[v] - VECTOR(*weights)[i];
        if (IS_TIGHT(i)) {
            IGRAPH_CHECK(igraph_vector_push_back(&vec1, u));
            IGRAPH_CHECK(igraph_vector_push_back(&vec1, v));
        }
    }
    igraph_vector_clear(&vec2);

    /* (4) Construct a temporary graph on which the initial maximum matching
     *     will be calculated (only on the subset of tight edges) */
    IGRAPH_CHECK(igraph_create(&newgraph, &vec1,
                               (igraph_integer_t) no_of_nodes, 0));
    IGRAPH_FINALLY(igraph_destroy, &newgraph);
    IGRAPH_CHECK(igraph_maximum_bipartite_matching(&newgraph, types, &msize, 0, &match, 0, 0));
    igraph_destroy(&newgraph);
    IGRAPH_FINALLY_CLEAN(1);

    /* (5) Main loop until the matching becomes maximal */
    while (msize < smaller_set_size) {
        igraph_real_t min_slack, min_slack_2;
        igraph_integer_t min_slack_u, min_slack_v;

        /* mark min_slack_u as unused; it is actually used when debugging, but
         * gcc complains when we are not debugging */
        IGRAPH_UNUSED(min_slack_u);

        /* (7) Fill the push queue with the unmatched nodes from the smaller set. */
        igraph_vector_clear(&vec1);
        igraph_vector_clear(&vec2);
        igraph_vector_fill(&parent, -1);
        for (j = 0; j < smaller_set_size; j++) {
            i = VECTOR(smaller_set)[j];
            if (UNMATCHED(i)) {
                IGRAPH_CHECK(igraph_dqueue_long_push(&q, i));
                VECTOR(parent)[i] = i;
                IGRAPH_CHECK(igraph_vector_push_back(&vec1, i));
            }
        }

#ifdef MATCHING_DEBUG
        debug("Matching:");
        igraph_vector_long_print(&match);
        debug("Unmatched vertices are marked by non-negative numbers:\n");
        igraph_vector_print(&parent);
        debug("Labeling:");
        igraph_vector_print(&labels);
        debug("Slacks:");
        igraph_vector_print(&slack);
#endif

        /* (8) Run the BFS */
        alternating_path_endpoint = -1;
        while (!igraph_dqueue_long_empty(&q)) {
            v = (int) igraph_dqueue_long_pop(&q);

            debug("Considering vertex %ld\n", (long int)v);

            /* v is always in the smaller set. Find the neighbors of v, which
             * are all in the larger set. Find the pairs of these nodes in
             * the smaller set and push them to the queue. Mark the traversed
             * nodes as seen.
             *
             * Here we have to be careful as there are two types of incident
             * edges on v: real edges and phantom ones. Real edges are
             * given by igraph_inclist_get. Phantom edges are not given so we
             * (ab)use an adjacency list data structure that lists the
             * vertices connected to v by phantom edges only. */
            neis = igraph_inclist_get(&inclist, v);
            n = igraph_vector_int_size(neis);
            for (i = 0; i < n; i++) {
                j = (long int) VECTOR(*neis)[i];
                /* We only care about tight edges */
                if (!IS_TIGHT(j)) {
                    continue;
                }
                /* Have we seen the other endpoint already? */
                u = IGRAPH_OTHER(graph, j, v);
                if (VECTOR(parent)[u] >= 0) {
                    continue;
                }
                debug("  Reached vertex %ld via edge %ld\n", (long)u, (long)j);
                VECTOR(parent)[u] = v;
                IGRAPH_CHECK(igraph_vector_push_back(&vec2, u));
                w = (int) VECTOR(match)[u];
                if (w == -1) {
                    /* u is unmatched and it is in the larger set. Therefore, we
                     * could improve the matching by following the parents back
                     * from u to the root.
                     */
                    alternating_path_endpoint = u;
                    break;  /* since we don't need any more endpoints that come from v */
                } else {
                    IGRAPH_CHECK(igraph_dqueue_long_push(&q, w));
                    VECTOR(parent)[w] = u;
                }
                IGRAPH_CHECK(igraph_vector_push_back(&vec1, w));
            }

            /* Now do the same with the phantom edges */
            neis2 = igraph_adjlist_get(&tight_phantom_edges, v);
            n = igraph_vector_int_size(neis2);
            for (i = 0; i < n; i++) {
                u = (igraph_integer_t) VECTOR(*neis2)[i];
                /* Have we seen u already? */
                if (VECTOR(parent)[u] >= 0) {
                    continue;
                }
                /* Check if the edge is really tight; it might have happened that the
                 * edge became non-tight in the meanwhile. We do not remove these from
                 * tight_phantom_edges at the moment, so we check them once again here.
                 */
                if (fabs(VECTOR(labels)[(long int)v] + VECTOR(labels)[(long int)u]) > eps) {
                    continue;
                }
                debug("  Reached vertex %ld via tight phantom edge\n", (long)u);
                VECTOR(parent)[u] = v;
                IGRAPH_CHECK(igraph_vector_push_back(&vec2, u));
                w = (int) VECTOR(match)[u];
                if (w == -1) {
                    /* u is unmatched and it is in the larger set. Therefore, we
                     * could improve the matching by following the parents back
                     * from u to the root.
                     */
                    alternating_path_endpoint = u;
                    break;  /* since we don't need any more endpoints that come from v */
                } else {
                    IGRAPH_CHECK(igraph_dqueue_long_push(&q, w));
                    VECTOR(parent)[w] = u;
                }
                IGRAPH_CHECK(igraph_vector_push_back(&vec1, w));
            }
        }

        /* Okay; did we have an alternating path? */
        if (alternating_path_endpoint != -1) {
#ifdef MATCHING_DEBUG
            debug("BFS parent tree:");
            igraph_vector_print(&parent);
#endif
            /* Increase the size of the matching with the alternating path. */
            v = alternating_path_endpoint;
            u = (igraph_integer_t) VECTOR(parent)[v];
            debug("Extending matching with alternating path ending in %ld.\n", (long int)v);

            while (u != v) {
                w = (int) VECTOR(match)[v];
                if (w != -1) {
                    VECTOR(match)[w] = -1;
                }
                VECTOR(match)[v] = u;

                VECTOR(match)[v] = u;
                w = (int) VECTOR(match)[u];
                if (w != -1) {
                    VECTOR(match)[w] = -1;
                }
                VECTOR(match)[u] = v;

                v = (igraph_integer_t) VECTOR(parent)[u];
                u = (igraph_integer_t) VECTOR(parent)[v];
            }

            msize++;

#ifdef MATCHING_DEBUG
            debug("New matching after update:");
            igraph_vector_long_print(&match);
            debug("Matching size is now: %ld\n", (long)msize);
#endif
            continue;
        }

#ifdef MATCHING_DEBUG
        debug("Vertices reachable from unmatched ones via tight edges:\n");
        igraph_vector_print(&vec1);
        igraph_vector_print(&vec2);
#endif

        /* At this point, vec1 contains the nodes in the smaller set (A)
         * reachable from unmatched nodes in A via tight edges only, while vec2
         * contains the nodes in the larger set (B) reachable from unmatched
         * nodes in A via tight edges only. Also, parent[i] >= 0 if node i
         * is reachable */

        /* Check the edges between reachable nodes in A and unreachable
         * nodes in B, and find the minimum slack on them.
         *
         * Since the weights are positive, we do no harm if we first
         * assume that there are no "real" edges between the two sets
         * mentioned above and determine an upper bound for min_slack
         * based on this. */
        min_slack = IGRAPH_INFINITY;
        min_slack_u = min_slack_v = 0;
        n = igraph_vector_size(&vec1);
        for (j = 0; j < larger_set_size; j++) {
            i = VECTOR(larger_set)[j];
            if (VECTOR(labels)[i] < min_slack) {
                min_slack = VECTOR(labels)[i];
                min_slack_v = (igraph_integer_t) i;
            }
        }
        min_slack_2 = IGRAPH_INFINITY;
        for (i = 0; i < n; i++) {
            u = (igraph_integer_t) VECTOR(vec1)[i];
            /* u is surely from the smaller set, but we are interested in it
             * only if it is reachable from an unmatched vertex */
            if (VECTOR(parent)[u] < 0) {
                continue;
            }
            if (VECTOR(labels)[u] < min_slack_2) {
                min_slack_2 = VECTOR(labels)[u];
                min_slack_u = u;
            }
        }
        min_slack += min_slack_2;
        debug("Starting approximation for min_slack = %.4f (based on vertex pair %ld--%ld)\n",
              min_slack, (long int)min_slack_u, (long int)min_slack_v);

        n = igraph_vector_size(&vec1);
        for (i = 0; i < n; i++) {
            u = (igraph_integer_t) VECTOR(vec1)[i];
            /* u is a reachable node in A; get its incident edges.
             *
             * There are two types of incident edges: 1) real edges,
             * 2) phantom edges. Phantom edges were treated earlier
             * when we determined the initial value for min_slack. */
            debug("Trying to expand along vertex %ld\n", (long int)u);
            neis = igraph_inclist_get(&inclist, u);
            k = igraph_vector_int_size(neis);
            for (j = 0; j < k; j++) {
                /* v is the vertex sitting at the other end of an edge incident
                 * on u; check whether it was reached */
                v = IGRAPH_OTHER(graph, VECTOR(*neis)[j], u);
                debug("  Edge %ld -- %ld (ID=%ld)\n", (long int)u, (long int)v, (long int)VECTOR(*neis)[j]);
                if (VECTOR(parent)[v] >= 0) {
                    /* v was reached, so we are not interested in it */
                    debug("    %ld was reached, so we are not interested in it\n", (long int)v);
                    continue;
                }
                /* v is the ID of the edge from now on */
                v = (igraph_integer_t) VECTOR(*neis)[j];
                if (VECTOR(slack)[v] < min_slack) {
                    min_slack = VECTOR(slack)[v];
                    min_slack_u = u;
                    min_slack_v = IGRAPH_OTHER(graph, v, u);
                }
                debug("    Slack of this edge: %.4f, min slack is now: %.4f\n",
                      VECTOR(slack)[v], min_slack);
            }
        }
        debug("Minimum slack: %.4f on edge %d--%d\n", min_slack, (int)min_slack_u, (int)min_slack_v);

        if (min_slack > 0) {
            /* Decrease the label of reachable nodes in A by min_slack.
             * Also update the dual solution */
            n = igraph_vector_size(&vec1);
            for (i = 0; i < n; i++) {
                u = (igraph_integer_t) VECTOR(vec1)[i];
                VECTOR(labels)[u] -= min_slack;
                neis = igraph_inclist_get(&inclist, u);
                k = igraph_vector_int_size(neis);
                for (j = 0; j < k; j++) {
                    debug("  Decreasing slack of edge %ld (%ld--%ld) by %.4f\n",
                          (long)VECTOR(*neis)[j], (long)u,
                          (long)IGRAPH_OTHER(graph, VECTOR(*neis)[j], u), min_slack);
                    VECTOR(slack)[(long int)VECTOR(*neis)[j]] -= min_slack;
                }
                dual -= min_slack;
            }

            /* Increase the label of reachable nodes in B by min_slack.
             * Also update the dual solution */
            n = igraph_vector_size(&vec2);
            for (i = 0; i < n; i++) {
                u = (igraph_integer_t) VECTOR(vec2)[i];
                VECTOR(labels)[u] += min_slack;
                neis = igraph_inclist_get(&inclist, u);
                k = igraph_vector_int_size(neis);
                for (j = 0; j < k; j++) {
                    debug("  Increasing slack of edge %ld (%ld--%ld) by %.4f\n",
                          (long)VECTOR(*neis)[j], (long)u,
                          (long)IGRAPH_OTHER(graph, (long)VECTOR(*neis)[j], u), min_slack);
                    VECTOR(slack)[(long int)VECTOR(*neis)[j]] += min_slack;
                }
                dual += min_slack;
            }
        }

        /* Update the set of tight phantom edges.
         * Note that we must do it even if min_slack is zero; the reason is that
         * it can happen that min_slack is zero in the first step if there are
         * isolated nodes in the input graph.
         *
         * TODO: this is O(n^2) here. Can we do it faster? */
        for (i = 0; i < smaller_set_size; i++) {
            u = VECTOR(smaller_set)[i];
            for (j = 0; j < larger_set_size; j++) {
                v = VECTOR(larger_set)[j];
                if (VECTOR(labels)[(long int)u] + VECTOR(labels)[(long int)v] <= eps) {
                    /* Tight phantom edge found. Note that we don't have to check whether
                     * u and v are connected; if they were, then the slack of this edge
                     * would be negative. */
                    neis2 = igraph_adjlist_get(&tight_phantom_edges, u);
                    if (!igraph_vector_int_binsearch(neis2, v, &k)) {
                        debug("New tight phantom edge: %ld -- %ld\n", (long)u, (long)v);
                        IGRAPH_CHECK(igraph_vector_int_insert(neis2, k, v));
                    }
                }
            }
        }

#ifdef MATCHING_DEBUG
        debug("New labels:");
        igraph_vector_print(&labels);
        debug("Slacks after updating with min_slack:");
        igraph_vector_print(&slack);
#endif
    }

    /* Cleanup: remove phantom edges from the matching */
    for (i = 0; i < smaller_set_size; i++) {
        u = VECTOR(smaller_set)[i];
        v = VECTOR(match)[u];
        if (v != -1) {
            neis2 = igraph_adjlist_get(&tight_phantom_edges, u);
            if (igraph_vector_int_binsearch(neis2, v, 0)) {
                VECTOR(match)[u] = VECTOR(match)[v] = -1;
                msize--;
            }
        }
    }

    /* Fill the output parameters */
    if (matching != 0) {
        IGRAPH_CHECK(igraph_vector_long_update(matching, &match));
    }
    if (matching_size != 0) {
        *matching_size = msize;
    }
    if (matching_weight != 0) {
        *matching_weight = 0;
        for (i = 0; i < no_of_edges; i++) {
            if (IS_TIGHT(i)) {
                IGRAPH_CHECK(igraph_edge(graph, (igraph_integer_t) i, &u, &v));
                if (VECTOR(match)[u] == v) {
                    *matching_weight += VECTOR(*weights)[i];
                }
            }
        }
    }

    /* Release everything */
#undef IS_TIGHT
    igraph_vector_destroy(&larger_set);
    igraph_vector_destroy(&smaller_set);
    igraph_inclist_destroy(&inclist);
    igraph_adjlist_destroy(&tight_phantom_edges);
    igraph_vector_destroy(&parent);
    igraph_dqueue_long_destroy(&q);
    igraph_vector_destroy(&labels);
    igraph_vector_destroy(&vec1);
    igraph_vector_destroy(&vec2);
    igraph_vector_destroy(&slack);
    igraph_vector_long_destroy(&match);
    IGRAPH_FINALLY_CLEAN(11);

    return IGRAPH_SUCCESS;
}

int igraph_maximum_matching(const igraph_t* graph, igraph_integer_t* matching_size,
                            igraph_real_t* matching_weight, igraph_vector_long_t* matching,
                            const igraph_vector_t* weights) {
    IGRAPH_UNUSED(graph);
    IGRAPH_UNUSED(matching_size);
    IGRAPH_UNUSED(matching_weight);
    IGRAPH_UNUSED(matching);
    IGRAPH_UNUSED(weights);
    IGRAPH_ERROR("maximum matching on general graphs not implemented yet",
                 IGRAPH_UNIMPLEMENTED);
}

#ifdef MATCHING_DEBUG
    #undef MATCHING_DEBUG
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/microscopic_update.c0000644000175100001710000016530200000000000025423 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Microscopic update rules for dealing with agent-level strategy revision.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include "igraph_microscopic_update.h"

#include "igraph_iterators.h"
#include "igraph_interface.h"
#include "igraph_random.h"
#include "igraph_error.h"

/*
 * Internal use only.
 * Compute the cumulative proportionate values of a vector. The vector is
 * assumed to hold values associated with edges.
 *
 * \param graph The graph object representing the game network. No error
 *        checks will be performed on this graph. You are responsible for
 *        ensuring that this is a valid graph for the particular
 *        microscopic update rule at hand.
 * \param U A vector of edge values for which we want to compute cumulative
 *        proportionate values. So U[i] is the value of the edge with ID i.
 *        With a local perspective, we would only compute cumulative
 *        proportionate values for some combination of U. This vector could
 *        be, for example, a vector of weights for edges in \p graph. It is
 *        assumed that each value of U is nonnegative; it is your
 *        responsibility to ensure this. Furthermore, this vector must have a
 *        length the same as the number of edges in \p graph; you are
 *        responsible for ensuring this condition holds.
 * \param V Pointer to an initialized vector. The cumulative proportionate
 *        values will be computed and stored here. No error checks will be
 *        performed on this parameter.
 * \param islocal Boolean; this flag controls which perspective to use. If
 *        true then we use the local perspective; otherwise we use the global
 *        perspective. In the context of this function, the local perspective
 *        for a vertex v consists of all edges incident on v. In contrast, the
 *        global perspective for v consists of all edges in \p graph.
 * \param vid The vertex to use if we are considering a local perspective,
 *        i.e. if \p islocal is true. This vertex will be ignored if
 *        \p islocal is false. That is, if \p islocal is false then it is safe
 *        pass the value -1 here. On the other hand, if \p islocal is true then
 *        it is assumed that this is indeed a vertex of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. This
 *        is only relevant if we are considering the local perspective, i.e. if
 *        \p islocal is true. If we are considering the global perspective,
 *        then this parameter would be ignored. In other words, if \p islocal
 *        is false then it is safe to pass the value \p IGRAPH_ALL here. If
 *        \p graph is undirected, then we use all the immediate neighbours of
 *        \p vid. Thus if you know that \p graph is undirected, then it is
 *        safe to pass the value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a digraph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph and we are considering a local
 *          perspective. Also use this value if \p graph is undirected or we
 *          are considering the global perspective.
 *        \endclist
 * \return Codes:
 *         \clist
 *         \cli IGRAPH_EINVAL
 *           This error code is returned in the following case: The vector
 *           \p U, or some combination of its values, sums to zero.
 *         \cli IGRAPH_SUCCESS
 *           This signal is returned if the cumulative proportionate values
 *           were successfully computed.
 *         \endclist
 *
 * Time complexity: O(2n) where n is the number of edges in the perspective
 * of \p vid.
 */

static int igraph_i_ecumulative_proportionate_values(const igraph_t *graph,
                                                     const igraph_vector_t *U,
                                                     igraph_vector_t *V,
                                                     igraph_bool_t islocal,
                                                     igraph_integer_t vid,
                                                     igraph_neimode_t mode) {
    igraph_eit_t A;   /* all edges in v's perspective */
    igraph_es_t es;
    igraph_integer_t e;
    igraph_real_t C;  /* cumulative probability */
    igraph_real_t P;  /* probability */
    igraph_real_t S;  /* sum of values */
    long int i;

    /* Set the perspective. Let v be the vertex under consideration. The local */
    /* perspective for v consists of edges incident on it. In contrast, the */
    /* global perspective for v are all edges in the given graph. Hence in the */
    /* global perspective, we will ignore the given vertex and the given */
    /* neighbourhood type, but instead consider all edges in the given graph. */
    if (islocal) {
        IGRAPH_CHECK(igraph_es_incident(&es, vid, mode));
    } else {
        IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
    }
    IGRAPH_FINALLY(igraph_es_destroy, &es);

    /* Sum up all the values of vector U in the perspective for v. This sum */
    /* will be used in normalizing each value. */
    /* NOTE: Here we assume that each value to be summed is nonnegative, */
    /* and at least one of the values is nonzero. The behaviour resulting */
    /* from all values being zero would be division by zero later on when */
    /* we normalize each value. We check to see that the values sum to zero. */
    /* NOTE: In this function, the order in which we iterate through the */
    /* edges of interest should be the same as the order in which we do so */
    /* in the caller function. If the caller function doesn't care about the */
    /* order of values in the resulting vector V, then there's no need to take */
    /* special notice of that order. But in some cases the order of values in */
    /* V is taken into account, for example, in the Moran process. */
    S = 0.0;
    IGRAPH_CHECK(igraph_eit_create(graph, es, &A));
    IGRAPH_FINALLY(igraph_eit_destroy, &A);
    while (!IGRAPH_EIT_END(A)) {
        e = (igraph_integer_t)IGRAPH_EIT_GET(A);
        S += (igraph_real_t)VECTOR(*U)[e];
        IGRAPH_EIT_NEXT(A);
    }
    /* avoid division by zero later on */
    if (S == (igraph_real_t)0.0) {
        igraph_eit_destroy(&A);
        igraph_es_destroy(&es);
        IGRAPH_FINALLY_CLEAN(2);
        IGRAPH_ERROR("Vector of values sums to zero", IGRAPH_EINVAL);
    }

    /* Get cumulative probability and relative value for each edge in the */
    /* perspective of v. The vector V holds the cumulative proportionate */
    /* values of all edges in v's perspective. The value V[0] is the */
    /* cumulative proportionate value of the first edge in the edge iterator */
    /* A. The value V[1] is the cumulative proportionate value of the second */
    /* edge in the iterator A. And so on. */
    C = 0.0;
    i = 0;
    IGRAPH_EIT_RESET(A);
    IGRAPH_CHECK(igraph_vector_resize(V, IGRAPH_EIT_SIZE(A)));
    while (!IGRAPH_EIT_END(A)) {
        e = (igraph_integer_t)IGRAPH_EIT_GET(A);
        /* NOTE: Beware of division by zero here. This can happen if the vector */
        /* of values, or the combination of interest, sums to zero. */
        P = (igraph_real_t)VECTOR(*U)[e] / S;
        C += P;
        VECTOR(*V)[i] = C;
        i++;
        IGRAPH_EIT_NEXT(A);
    }

    igraph_eit_destroy(&A);
    igraph_es_destroy(&es);

    /* Pop A and es from the finally stack -- that's three items */
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/*
 * Internal use only.
 * Compute the cumulative proportionate values of a vector. The vector is
 * assumed to hold values associated with vertices.
 *
 * \param graph The graph object representing the game network. No error
 *        checks will be performed on this graph. You are responsible for
 *        ensuring that this is a valid graph for the particular
 *        microscopic update rule at hand.
 * \param U A vector of vertex values for which we want to compute cumulative
 *        proportionate values. The vector could be, for example, a vector of
 *        fitness for vertices of \p graph. It is assumed that each value of U
 *        is nonnegative; it is your responsibility to ensure this. Also U, or
 *        a combination of interest, is assumed to sum to a positive value;
 *        this condition will be checked.
 * \param V Pointer to an initialized vector. The cumulative proportionate
 *        values will be computed and stored here. No error checks will be
 *        performed on this parameter.
 * \param islocal Boolean; this flag controls which perspective to use. If
 *        true then we use the local perspective; otherwise we use the global
 *        perspective. The local perspective for a vertex v is the set of all
 *        immediate neighbours of v. In contrast, the global perspective
 *        for v is the vertex set of \p graph.
 * \param vid The vertex to use if we are considering a local perspective,
 *        i.e. if \p islocal is true. This vertex will be ignored if
 *        \p islocal is false. That is, if \p islocal is false then it is safe
 *        pass the value -1 here. On the other hand, if \p islocal is true then
 *        it is assumed that this is indeed a vertex of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. This
 *        is only relevant if we are considering the local perspective, i.e. if
 *        \p islocal is true. If we are considering the global perspective,
 *        then this parameter would be ignored. In other words, if \p islocal
 *        is false then it is safe to pass the value \p IGRAPH_ALL here. If
 *        \p graph is undirected, then we use all the immediate neighbours of
 *        \p vid. Thus if you know that \p graph is undirected, then it is
 *        safe to pass the value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a digraph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph and we are considering a local
 *          perspective. Also use this value if \p graph is undirected or we
 *          are considering the global perspective.
 *        \endclist
 * \return Codes:
 *         \clist
 *         \cli IGRAPH_EINVAL
 *           This error code is returned in the following case: The vector
 *           \p U, or some combination of its values, sums to zero.
 *         \cli IGRAPH_SUCCESS
 *           This signal is returned if the cumulative proportionate values
 *           were successfully computed.
 *         \endclist
 *
 * Time complexity: O(2n) where n is the number of vertices in the
 * perspective of vid.
 */

static int igraph_i_vcumulative_proportionate_values(const igraph_t *graph,
                                                     const igraph_vector_t *U,
                                                     igraph_vector_t *V,
                                                     igraph_bool_t islocal,
                                                     igraph_integer_t vid,
                                                     igraph_neimode_t mode) {
    igraph_integer_t v;
    igraph_real_t C;  /* cumulative probability */
    igraph_real_t P;  /* probability */
    igraph_real_t S;  /* sum of values */
    igraph_vit_t A;   /* all vertices in v's perspective */
    igraph_vs_t vs;
    long int i;

    /* Set the perspective. Let v be the vertex under consideration; it might */
    /* be that we want to update v's strategy. The local perspective for v */
    /* consists of its immediate neighbours. In contrast, the global */
    /* perspective for v are all the vertices in the given graph. Hence in the */
    /* global perspective, we will ignore the given vertex and the given */
    /* neighbourhood type, but instead consider all vertices in the given */
    /* graph. */
    if (islocal) {
        IGRAPH_CHECK(igraph_vs_adj(&vs, vid, mode));
    } else {
        IGRAPH_CHECK(igraph_vs_all(&vs));
    }
    IGRAPH_FINALLY(igraph_vs_destroy, &vs);

    /* Sum up all the values of vector U in the perspective for v. This */
    /* sum will be used in normalizing each value. If we are using a local */
    /* perspective, then we also need to consider the quantity of v in */
    /* computing the sum. */
    /* NOTE: Here we assume that each value to be summed is nonnegative, */
    /* and at least one of the values is nonzero. The behaviour resulting */
    /* from all values being zero would be division by zero later on when */
    /* we normalize each value. We check to see that the values sum to zero. */
    /* NOTE: In this function, the order in which we iterate through the */
    /* vertices of interest should be the same as the order in which we do so */
    /* in the caller function. If the caller function doesn't care about the */
    /* order of values in the resulting vector V, then there's no need to take */
    /* special notice of that order. But in some cases the order of values in */
    /* V is taken into account, for example, in roulette wheel selection. */
    S = 0.0;
    IGRAPH_CHECK(igraph_vit_create(graph, vs, &A));
    IGRAPH_FINALLY(igraph_vit_destroy, &A);
    while (!IGRAPH_VIT_END(A)) {
        v = (igraph_integer_t)IGRAPH_VIT_GET(A);
        S += (igraph_real_t)VECTOR(*U)[v];
        IGRAPH_VIT_NEXT(A);
    }
    if (islocal) {
        S += (igraph_real_t)VECTOR(*U)[vid];
    }
    /* avoid division by zero later on */
    if (S == (igraph_real_t)0.0) {
        igraph_vit_destroy(&A);
        igraph_vs_destroy(&vs);
        IGRAPH_FINALLY_CLEAN(2);
        IGRAPH_ERROR("Vector of values sums to zero", IGRAPH_EINVAL);
    }

    /* Get cumulative probability and relative value for each vertex in the */
    /* perspective of v. The vector V holds the cumulative proportionate */
    /* values of all vertices in v's perspective. The value V[0] is the */
    /* cumulative proportionate value of the first vertex in the vertex */
    /* iterator A. The value V[1] is the cumulative proportionate value of */
    /* the second vertex in the iterator A. And so on. If we are using the */
    /* local perspective, then we also need to consider the cumulative */
    /* proportionate value of v. In the case of the local perspective, we */
    /* don't need to compute and store v's cumulative proportionate value, */
    /* but we pretend that such value is appended to the vector V. */
    C = 0.0;
    i = 0;
    IGRAPH_VIT_RESET(A);
    IGRAPH_CHECK(igraph_vector_resize(V, IGRAPH_VIT_SIZE(A)));
    while (!IGRAPH_VIT_END(A)) {
        v = (igraph_integer_t)IGRAPH_VIT_GET(A);
        /* NOTE: Beware of division by zero here. This can happen if the vector */
        /* of values, or a combination of interest, sums to zero. */
        P = (igraph_real_t)VECTOR(*U)[v] / S;
        C += P;
        VECTOR(*V)[i] = C;
        i++;
        IGRAPH_VIT_NEXT(A);
    }

    igraph_vit_destroy(&A);
    igraph_vs_destroy(&vs);

    /* Pop A and vs from the finally stack -- that's two items */
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/*
 * Internal use only.
 * A set of standard tests to be performed prior to strategy updates. The
 * tests contained in this function are common to many strategy revision
 * functions in this file. This function is meant to be invoked from within
 * a specific strategy update function in order to perform certain common
 * tests, including sanity checks and conditions under which no strategy
 * updates are necessary.
 *
 * \param graph The graph object representing the game network. This cannot
 *        be the empty or trivial graph, but must have at least two vertices
 *        and one edge. If \p graph has one vertex, then no strategy update
 *        would take place. Furthermore, if \p graph has at least two vertices
 *        but zero edges, then strategy update would also not take place.
 * \param vid The vertex whose strategy is to be updated. It is assumed that
 *        \p vid represents a vertex in \p graph. No checking is performed and
 *        it is your responsibility to ensure that \p vid is indeed a vertex
 *        of \p graph. If an isolated vertex is provided, i.e. the input
 *        vertex has degree 0, then no strategy update would take place and
 *        \p vid would retain its current strategy. Strategy update would also
 *        not take place if the local neighbourhood of \p vid are its
 *        in-neighbours (respectively out-neighbours), but \p vid has zero
 *        in-neighbours (respectively out-neighbours). Loops are ignored in
 *        computing the degree (in, out, all) of \p vid.
 * \param quantities A vector of quantities providing the quantity of each
 *        vertex in \p graph. Think of each entry of the vector as being
 *        generated by a function such as the fitness function for the game.
 *        So if the vector represents fitness quantities, then each vector
 *        entry is the fitness of some vertex. The length of this vector must
 *        be the same as the number of vertices in the vertex set of \p graph.
 * \param strategies A vector of the current strategies for the vertex
 *        population. Each strategy is identified with a nonnegative integer,
 *        whose interpretation depends on the payoff matrix of the game.
 *        Generally we use the strategy ID as a row or column index of the
 *        payoff matrix. The length of this vector must be the same as the
 *        number of vertices in the vertex set of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. If
 *        \p graph is undirected, then we use all the immediate neighbours of
 *        \p vid. Thus if you know that \p graph is undirected, then it is safe
 *        to pass the value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph. Also use this value if
 *          \p graph is undirected.
 *        \endclist
 * \param updates Boolean; at the end of this test suite, this flag
 *        indicates whether to proceed with strategy revision. If true then
 *        strategy revision should proceed; otherwise there is no need to
 *        continue with revising a vertex's strategy. A caller function that
 *        invokes this function would use the value of \p updates to
 *        determine whether to proceed with strategy revision.
 * \param islocal Boolean; this flag controls which perspective to use. If
 *        true then we use the local perspective; otherwise we use the global
 *        perspective. The local perspective for \p vid is the set of all
 *        immediate neighbours of \p vid. In contrast, the global perspective
 *        for \p vid is the vertex set of \p graph.
 * \return Codes:
 *         \clist
 *         \cli IGRAPH_EINVAL
 *           This error code is returned in each of the following cases:
 *           (1) Any of the parameters \p graph, \p quantities, or
 *           \p strategies is a null pointer. (2) The vector \p quantities
 *           or \p strategies has a length different from the number of
 *           vertices in \p graph. (3) The parameter \p graph is the empty
 *           or null graph, i.e. the graph with zero vertices and edges.
 *         \cli IGRAPH_SUCCESS
 *           This signal is returned if no errors were raised. You should use
 *           the value of the boolean \p updates to decide whether to go
 *           ahead with updating a vertex's strategy.
 *         \endclist
 */

static int igraph_i_microscopic_standard_tests(const igraph_t *graph,
                                               igraph_integer_t vid,
                                               const igraph_vector_t *quantities,
                                               const igraph_vector_t *strategies,
                                               igraph_neimode_t mode,
                                               igraph_bool_t *updates,
                                               igraph_bool_t islocal) {

    igraph_integer_t nvert;
    igraph_vector_t degv;
    *updates = 1;

    /* sanity checks */
    if (graph == NULL) {
        IGRAPH_ERROR("Graph is a null pointer", IGRAPH_EINVAL);
    }
    if (quantities == NULL) {
        IGRAPH_ERROR("Quantities vector is a null pointer", IGRAPH_EINVAL);
    }
    if (strategies == NULL) {
        IGRAPH_ERROR("Strategies vector is a null pointer", IGRAPH_EINVAL);
    }

    /* the empty graph */
    nvert = igraph_vcount(graph);
    if (nvert < 1) {
        IGRAPH_ERROR("Graph cannot be the empty graph", IGRAPH_EINVAL);
    }
    /* invalid vector length */
    if (nvert != (igraph_integer_t)igraph_vector_size(quantities)) {
        IGRAPH_ERROR("Size of quantities vector different from number of vertices",
                     IGRAPH_EINVAL);
    }
    if (nvert != (igraph_integer_t)igraph_vector_size(strategies)) {
        IGRAPH_ERROR("Size of strategies vector different from number of vertices",
                     IGRAPH_EINVAL);
    }

    /* Various conditions under which no strategy updates will take place. That
     * is, the vertex retains its current strategy.
     */
    /* given graph has < 2 vertices */
    if (nvert < 2) {
        *updates = 0;
    }
    /* graph has >= 2 vertices, but no edges */
    if (igraph_ecount(graph) < 1) {
        *updates = 0;
    }

    /* Test for vertex isolation, depending on the perspective given. For
     * undirected graphs, a given vertex v is isolated if its degree is zero.
     * If we are considering in-neighbours (respectively out-neighbours), then
     * we say that v is isolated if its in-degree (respectively out-degree) is
     * zero. In general, this vertex isolation test is only relevant if we are
     * using a local perspective, i.e. if we only consider the immediate
     * neighbours (local perspective) of v as opposed to all vertices in the
     * vertex set of the graph (global perspective).
     */
    if (islocal) {
        /* Moving on ahead with vertex isolation test, since local perspective */
        /* is requested. */
        IGRAPH_VECTOR_INIT_FINALLY(°v, 1);
        IGRAPH_CHECK(igraph_degree(graph, °v, igraph_vss_1(vid),
                                   mode, IGRAPH_NO_LOOPS));
        if (VECTOR(degv)[0] < 1) {
            *updates = 0;
        }
        igraph_vector_destroy(°v);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup spatialgames
 * \function igraph_deterministic_optimal_imitation
 * \brief Adopt a strategy via deterministic optimal imitation.
 *
 * A simple deterministic imitation strategy where a vertex revises its
 * strategy to that which yields a local optimal. Here "local" is with
 * respect to the immediate neighbours of the vertex. The vertex retains its
 * current strategy where this strategy yields a locally optimal quantity.
 * The quantity in this case could be a measure such as fitness.
 *
 * \param graph The graph object representing the game network. This cannot
 *        be the empty or trivial graph, but must have at least two vertices
 *        and one edge. If \p graph has one vertex, then no strategy update
 *        would take place. Furthermore, if \p graph has at least two vertices
 *        but zero edges, then strategy update would also not take place.
 * \param vid The vertex whose strategy is to be updated. It is assumed that
 *        \p vid represents a vertex in \p graph. No checking is performed and
 *        it is your responsibility to ensure that \p vid is indeed a vertex
 *        of \p graph. If an isolated vertex is provided, i.e. the input
 *        vertex has degree 0, then no strategy update would take place and
 *        \p vid would retain its current strategy. Strategy update would also
 *        not take place if the local neighbourhood of \p vid are its
 *        in-neighbours (respectively out-neighbours), but \p vid has zero
 *        in-neighbours (respectively out-neighbours). Loops are ignored in
 *        computing the degree (in, out, all) of \p vid.
 * \param optimality Logical; controls the type of optimality to be used.
 *        Supported values are:
 *        \clist
 *        \cli IGRAPH_MAXIMUM
 *          Use maximum deterministic imitation, where the strategy of the
 *          vertex with maximum quantity (e.g. fitness) would be adopted. We
 *          update the strategy of \p vid to that which yields a local
 *          maximum.
 *        \cli IGRAPH_MINIMUM
 *          Use minimum deterministic imitation. That is, the strategy of the
 *          vertex with minimum quantity would be imitated. In other words,
 *          update to the strategy that yields a local minimum.
 *        \endclist
 * \param quantities A vector of quantities providing the quantity of each
 *        vertex in \p graph. Think of each entry of the vector as being
 *        generated by a function such as the fitness function for the game.
 *        So if the vector represents fitness quantities, then each vector
 *        entry is the fitness of some vertex. The length of this vector must
 *        be the same as the number of vertices in the vertex set of \p graph.
 * \param strategies A vector of the current strategies for the vertex
 *        population. The updated strategy for \p vid would be stored here.
 *        Each strategy is identified with a nonnegative integer, whose
 *        interpretation depends on the payoff matrix of the game. Generally
 *        we use the strategy ID as a row or column index of the payoff
 *        matrix. The length of this vector must be the same as the number of
 *        vertices in the vertex set of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. If
 *        \p graph is undirected, then we use all the immediate neighbours of
 *        \p vid. Thus if you know that \p graph is undirected, then it is safe
 *        to pass the value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph. Also use this value if
 *          \p graph is undirected.
 *        \endclist
 * \return The error code \p IGRAPH_EINVAL is returned in each of the
 *         following cases: (1) Any of the parameters \p graph, \p quantities,
 *         or \p strategies is a null pointer. (2) The vector \p quantities
 *         or \p strategies has a length different from the number of vertices
 *         in \p graph. (3) The parameter \p graph is the empty or null graph,
 *         i.e. the graph with zero vertices and edges.
 *
 * Time complexity: O(2d), where d is the degree of the vertex \p vid.
 *
 * \example examples/simple/igraph_deterministic_optimal_imitation.c
 */

int igraph_deterministic_optimal_imitation(const igraph_t *graph,
        igraph_integer_t vid,
        igraph_optimal_t optimality,
        const igraph_vector_t *quantities,
        igraph_vector_t *strategies,
        igraph_neimode_t mode) {
    igraph_integer_t i, k, v;
    igraph_real_t q;
    igraph_vector_t adj;
    igraph_bool_t updates;

    IGRAPH_CHECK(igraph_i_microscopic_standard_tests(graph, vid, quantities,
                 strategies, mode, &updates,
                 /*is local?*/ 1));
    if (!updates) {
        return IGRAPH_SUCCESS;    /* Nothing to do */
    }

    /* Choose a locally optimal strategy to imitate. This can be either maximum
     * or minimum deterministic imitation. By now we know that the given vertex v
     * has degree >= 1 and at least 1 edge. Then within its immediate
     * neighbourhood adj(v) and including v itself, there exists a vertex whose
     * strategy yields a local optimal quantity.
     */
    /* Random permutation of adj(v). This ensures that if there are multiple */
    /* candidates with an optimal strategy, then we choose one such candidate */
    /* at random. */
    IGRAPH_VECTOR_INIT_FINALLY(&adj, 0);
    IGRAPH_CHECK(igraph_neighbors(graph, &adj, vid, mode));
    IGRAPH_CHECK(igraph_vector_shuffle(&adj));
    /* maximum deterministic imitation */
    i = vid;
    q = (igraph_real_t)VECTOR(*quantities)[vid];
    if (optimality == IGRAPH_MAXIMUM) {
        for (k = 0; k < igraph_vector_size(&adj); k++) {
            v = (igraph_integer_t) VECTOR(adj)[k];
            if ((igraph_real_t)VECTOR(*quantities)[v] > q) {
                i = v;
                q = (igraph_real_t)VECTOR(*quantities)[v];
            }
        }
    } else { /* minimum deterministic imitation */
        for (k = 0; k < igraph_vector_size(&adj); k++) {
            v = (igraph_integer_t) VECTOR(adj)[k];
            if ((igraph_real_t)VECTOR(*quantities)[v] < q) {
                i = v;
                q = (igraph_real_t)VECTOR(*quantities)[v];
            }
        }
    }
    /* Now i is a vertex with a locally optimal quantity, the value of which */
    /* is q. Update the strategy of vid to that of i. */
    VECTOR(*strategies)[vid] = VECTOR(*strategies)[i];
    igraph_vector_destroy(&adj);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup spatialgames
 * \function igraph_moran_process
 * \brief The Moran process in a network setting.
 *
 * This is an extension of the classic Moran process to a network setting.
 * The Moran process is a model of haploid (asexual) reproduction within a
 * population having a fixed size. In the network setting, the Moran process
 * operates on a weighted graph. At each time step a vertex a is chosen for
 * reproduction and another vertex b is chosen for death. Vertex a gives birth
 * to an identical clone c, which replaces b. Vertex c is a clone of a in that
 * c inherits both the current quantity (e.g. fitness) and current strategy
 * of a.
 *
 * 
 * The graph G representing the game network is assumed to be simple,
 * i.e. free of loops and without multiple edges. If, on the other hand, G has
 * a loop incident on some vertex v, then it is possible that when v is chosen
 * for reproduction it would forgo this opportunity. In particular, when v is
 * chosen for reproduction and v is also chosen for death, the clone of v
 * would be v itself with its current vertex ID. In effect v forgoes its
 * chance for reproduction.
 *
 * \param graph The graph object representing the game network. This cannot
 *        be the empty or trivial graph, but must have at least two vertices
 *        and one edge. The Moran process will not take place in each of the
 *        following cases: (1) If \p graph has one vertex. (2) If \p graph has
 *        at least two vertices but zero edges.
 * \param weights A vector of all edge weights for \p graph. Thus weights[i]
 *        means the weight of the edge with edge ID i. For the purpose of the
 *        Moran process, each weight is assumed to be positive; it is your
 *        responsibility to ensure this condition holds. The length of this
 *        vector must be the same as the number of edges in \p graph.
 * \param quantities A vector of quantities providing the quantity of each
 *        vertex in \p graph. The quantity of the new clone will be stored
 *        here. Think of each entry of the vector as being generated by a
 *        function such as the fitness function for the game. So if the vector
 *        represents fitness quantities, then each vector entry is the fitness
 *        of some vertex. The length of this vector must be the same as the
 *        number of vertices in the vertex set of \p graph. For the purpose of
 *        the Moran process, each vector entry is assumed to be nonnegative;
 *        no checks will be performed for this. It is your responsibility to
 *        ensure that at least one entry is positive. Furthermore, this vector
 *        cannot be a vector of zeros; this condition will be checked.
 * \param strategies A vector of the current strategies for the vertex
 *        population. The strategy of the new clone will be stored here. Each
 *        strategy is identified with a nonnegative integer, whose
 *        interpretation depends on the payoff matrix of the game. Generally
 *        we use the strategy ID as a row or column index of the payoff
 *        matrix. The length of this vector must be the same as the number of
 *        vertices in the vertex set of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for the vertex a
 *        chosen for reproduction. This is only relevant if \p graph is
 *        directed. If \p graph is undirected, then it is safe to pass the
 *        value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of a. This option is only relevant when
 *          \p graph is directed.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of a. Again this option is only relevant
 *          when \p graph is directed.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of a. This option is only
 *          relevant if \p graph is directed. Also use this value if
 *          \p graph is undirected.
 *        \endclist
 * \return The error code \p IGRAPH_EINVAL is returned in each of the following
 *         cases: (1) Any of the parameters \p graph, \p weights,
 *         \p quantities or \p strategies is a null pointer. (2) The vector
 *         \p quantities or \p strategies has a length different from the
 *         number of vertices in \p graph. (3) The vector \p weights has a
 *         length different from the number of edges in \p graph. (4) The
 *         parameter \p graph is the empty or null graph, i.e. the graph with
 *         zero vertices and edges. (5) The vector \p weights, or the
 *         combination of interest, sums to zero. (6) The vector \p quantities,
 *         or the combination of interest, sums to zero.
 *
 * Time complexity: depends on the random number generator, but is usually
 * O(n) where n is the number of vertices in \p graph.
 *
 * 
 * References:
 * \clist
 * \cli (Lieberman et al. 2005)
 *   E. Lieberman, C. Hauert, and M. A. Nowak. Evolutionary dynamics on
 *   graphs. \emb Nature, \eme 433(7023):312--316, 2005.
 * \cli (Moran 1958)
 *   P. A. P. Moran. Random processes in genetics. \emb Mathematical
 *   Proceedings of the Cambridge Philosophical Society, \eme 54(1):60--71,
 *   1958.
 * \endclist
 */

int igraph_moran_process(const igraph_t *graph,
                         const igraph_vector_t *weights,
                         igraph_vector_t *quantities,
                         igraph_vector_t *strategies,
                         igraph_neimode_t mode) {
    igraph_bool_t updates;
    igraph_integer_t a = -1;  /* vertex chosen for reproduction */
    igraph_integer_t b = -1;  /* vertex chosen for death */
    igraph_integer_t e, nedge, u, v;
    igraph_real_t r;          /* random number */
    igraph_vector_t deg;
    igraph_vector_t V;        /* vector of cumulative proportionate values */
    igraph_vit_t vA;          /* vertex list */
    igraph_eit_t eA;          /* edge list */
    igraph_vs_t vs;
    igraph_es_t es;
    long int i;

    /* don't test for vertex isolation, hence vid = -1 and islocal = 0 */
    IGRAPH_CHECK(igraph_i_microscopic_standard_tests(graph, /*vid*/ -1,
                 quantities, strategies, mode,
                 &updates, /*is local?*/ 0));
    if (!updates) {
        return IGRAPH_SUCCESS;    /* nothing more to do */
    }
    if (weights == NULL) {
        IGRAPH_ERROR("Weights vector is a null pointer", IGRAPH_EINVAL);
    }
    nedge = igraph_ecount(graph);
    if (nedge != (igraph_integer_t)igraph_vector_size(weights)) {
        IGRAPH_ERROR("Size of weights vector different from number of edges",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&V, 0);

    /* Cumulative proportionate quantities. We are using the global */
    /* perspective, hence islocal = 0, vid = -1 and mode = IGRAPH_ALL. */
    IGRAPH_CHECK(igraph_i_vcumulative_proportionate_values(graph, quantities, &V,
                 /*is local?*/ 0,
                 /*vid*/ -1,
                 /*mode*/ IGRAPH_ALL));

    /* Choose a vertex for reproduction from among all vertices in the graph. */
    /* The vertex is chosen proportionate to its quantity and such that its */
    /* degree is >= 1. In case we are considering in-neighbours (respectively */
    /* out-neighbours), the chosen vertex must have in-degree (respectively */
    /* out-degree) >= 1. All loops will be ignored. At this point, we know */
    /* that the graph has at least one edge, which may be directed or not. */
    /* Furthermore the quantities of all vertices sum to a positive value. */
    /* Hence at least one vertex will be chosen for reproduction. */
    IGRAPH_CHECK(igraph_vs_all(&vs));
    IGRAPH_FINALLY(igraph_vs_destroy, &vs);
    IGRAPH_CHECK(igraph_vit_create(graph, vs, &vA));
    IGRAPH_FINALLY(igraph_vit_destroy, &vA);
    RNG_BEGIN();
    r = RNG_UNIF01();
    RNG_END();
    i = 0;
    IGRAPH_VECTOR_INIT_FINALLY(°, 1);
    while (!IGRAPH_VIT_END(vA)) {
        u = (igraph_integer_t)IGRAPH_VIT_GET(vA);
        IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_1(u), mode,
                                   IGRAPH_NO_LOOPS));
        if (VECTOR(deg)[0] < 1) {
            i++;
            IGRAPH_VIT_NEXT(vA);
            continue;
        }
        if (r <= VECTOR(V)[i]) {
            /* we have found our candidate vertex for reproduction */
            a = u;
            break;
        }
        i++;
        IGRAPH_VIT_NEXT(vA);
    }
    /* By now we should have chosen a vertex for reproduction. Check this. */
    IGRAPH_ASSERT(a >= 0);

    /* Cumulative proportionate weights. We are using the local perspective */
    /* with respect to vertex a, which has been chosen for reproduction. */
    /* The degree of a is deg(a) >= 1 with respect to the mode "mode", which */
    /* can flag either the in-degree, out-degree or all degree of a. But it */
    /* still might happen that the edge weights of interest would sum to zero. */
    /* An error would be raised in that case. */
    IGRAPH_CHECK(igraph_i_ecumulative_proportionate_values(graph, weights, &V,
                 /*is local?*/ 1,
                 /*vertex*/ a, mode));

    /* Choose a vertex for death from among all vertices in a's perspective. */
    /* Let E be all the edges in the perspective of a. If (u,v) \in E is any */
    /* such edge, then we have a = u or a = v. That is, any edge in E has a */
    /* for one of its endpoints. As G is assumed to be a simple graph, then */
    /* exactly one of u or v is the vertex a. Without loss of generality, we */
    /* assume that each edge in E has the form (a, v_i). Then the vertex v_j */
    /* chosen for death is chosen proportionate to the weight of the edge */
    /* (a, v_j). */
    IGRAPH_CHECK(igraph_es_incident(&es, a, mode));
    IGRAPH_FINALLY(igraph_es_destroy, &es);
    IGRAPH_CHECK(igraph_eit_create(graph, es, &eA));
    IGRAPH_FINALLY(igraph_eit_destroy, &eA);
    RNG_BEGIN();
    r = RNG_UNIF01();
    RNG_END();
    i = 0;
    while (!IGRAPH_EIT_END(eA)) {
        e = (igraph_integer_t)IGRAPH_EIT_GET(eA);
        if (r <= VECTOR(V)[i]) {
            /* We have found our candidate vertex for death; call this vertex b. */
            /* As G is simple, then a =/= b. Check the latter condition. */
            IGRAPH_CHECK(igraph_edge(graph, /*edge ID*/ e,
                                     /*tail vertex*/ &u, /*head vertex*/ &v));
            if (a == u) {
                b = v;
            } else {
                b = u;
            }
            IGRAPH_ASSERT(a != b);  /* always true if G is simple */
            break;
        }
        i++;
        IGRAPH_EIT_NEXT(eA);
    }

    /* By now a vertex a is chosen for reproduction and a vertex b is chosen */
    /* for death. Check that b has indeed been chosen. Clone vertex a and kill */
    /* vertex b. Let the clone c have the vertex ID of b, and the strategy and */
    /* quantity of a. */
    IGRAPH_ASSERT(b >= 0);
    VECTOR(*quantities)[b] = VECTOR(*quantities)[a];
    VECTOR(*strategies)[b] = VECTOR(*strategies)[a];

    igraph_eit_destroy(&eA);
    igraph_es_destroy(&es);
    igraph_vector_destroy(°);
    igraph_vit_destroy(&vA);
    igraph_vs_destroy(&vs);
    igraph_vector_destroy(&V);
    IGRAPH_FINALLY_CLEAN(6);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup spatialgames
 * \function igraph_roulette_wheel_imitation
 * \brief Adopt a strategy via roulette wheel selection.
 *
 * A simple stochastic imitation strategy where a vertex revises its
 * strategy to that of a vertex u chosen proportionate to u's quantity
 * (e.g. fitness). This is a special case of stochastic imitation, where a
 * candidate is not chosen uniformly at random but proportionate to its
 * quantity.
 *
 * \param graph The graph object representing the game network. This cannot
 *        be the empty or trivial graph, but must have at least two vertices
 *        and one edge. If \p graph has one vertex, then no strategy update
 *        would take place. Furthermore, if \p graph has at least two vertices
 *        but zero edges, then strategy update would also not take place.
 * \param vid The vertex whose strategy is to be updated. It is assumed that
 *        \p vid represents a vertex in \p graph. No checking is performed and
 *        it is your responsibility to ensure that \p vid is indeed a vertex
 *        of \p graph. If an isolated vertex is provided, i.e. the input
 *        vertex has degree 0, then no strategy update would take place and
 *        \p vid would retain its current strategy. Strategy update would also
 *        not take place if the local neighbourhood of \p vid are its
 *        in-neighbours (respectively out-neighbours), but \p vid has zero
 *        in-neighbours (respectively out-neighbours). Loops are ignored in
 *        computing the degree (in, out, all) of \p vid.
 * \param islocal Boolean; this flag controls which perspective to use in
 *        computing the relative quantity. If true then we use the local
 *        perspective; otherwise we use the global perspective. The local
 *        perspective for \p vid is the set of all immediate neighbours of
 *        \p vid. In contrast, the global perspective for \p vid is the
 *        vertex set of \p graph.
 * \param quantities A vector of quantities providing the quantity of each
 *        vertex in \p graph. Think of each entry of the vector as being
 *        generated by a function such as the fitness function for the game.
 *        So if the vector represents fitness quantities, then each vector
 *        entry is the fitness of some vertex. The length of this vector must
 *        be the same as the number of vertices in the vertex set of \p graph.
 *        For the purpose of roulette wheel selection, each vector entry is
 *        assumed to be nonnegative; no checks will be performed for this. It
 *        is your responsibility to ensure that at least one entry is nonzero.
 *        Furthermore, this vector cannot be a vector of zeros; this condition
 *        will be checked.
 * \param strategies A vector of the current strategies for the vertex
 *        population. The updated strategy for \p vid would be stored here.
 *        Each strategy is identified with a nonnegative integer, whose
 *        interpretation depends on the payoff matrix of the game. Generally
 *        we use the strategy ID as a row or column index of the payoff
 *        matrix. The length of this vector must be the same as the number of
 *        vertices in the vertex set of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. This
 *        is only relevant if we are considering the local perspective, i.e. if
 *        \p islocal is true. If we are considering the global perspective,
 *        then it is safe to pass the value \p IGRAPH_ALL here. If \p graph is
 *        undirected, then we use all the immediate neighbours of \p vid. Thus
 *        if you know that \p graph is undirected, then it is safe to pass the
 *        value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a digraph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph and we are considering the local
 *          perspective.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph. Also use this value if
 *          \p graph is undirected or we are considering the global
 *          perspective.
 *        \endclist
 * \return The error code \p IGRAPH_EINVAL is returned in each of the following
 *         cases: (1) Any of the parameters \p graph, \p quantities, or
 *         \p strategies is a null pointer. (2) The vector \p quantities or
 *         \p strategies has a length different from the number of vertices
 *         in \p graph. (3) The parameter \p graph is the empty or null graph,
 *         i.e. the graph with zero vertices and edges. (4) The vector
 *         \p quantities sums to zero.
 *
 * Time complexity: O(n) where n is the number of vertices in the perspective
 * to consider. If we consider the global perspective, then n is the number
 * of vertices in the vertex set of \p graph. On the other hand, for the local
 * perspective n is the degree of \p vid, excluding loops.
 *
 * 
 * Reference:
 * \clist
 * \cli (Yu & Gen 2010)
 *   X. Yu and M. Gen. \emb Introduction to Evolutionary Algorithms. \eme
 *   Springer, 2010, pages 18--20.
 * \endclist
 *
 * \example examples/simple/igraph_roulette_wheel_imitation.c
 */

int igraph_roulette_wheel_imitation(const igraph_t *graph,
                                    igraph_integer_t vid,
                                    igraph_bool_t islocal,
                                    const igraph_vector_t *quantities,
                                    igraph_vector_t *strategies,
                                    igraph_neimode_t mode) {
    igraph_bool_t updates;
    igraph_integer_t u;
    igraph_real_t r;    /* random number */
    igraph_vector_t V;  /* vector of cumulative proportionate quantities */
    igraph_vit_t A;     /* all vertices in v's perspective */
    igraph_vs_t vs;
    long int i;

    IGRAPH_CHECK(igraph_i_microscopic_standard_tests(graph, vid, quantities,
                 strategies, mode, &updates,
                 islocal));
    if (!updates) {
        return IGRAPH_SUCCESS;    /* nothing further to do */
    }

    /* set the perspective */
    if (islocal) {
        IGRAPH_CHECK(igraph_vs_adj(&vs, vid, mode));
    } else {
        IGRAPH_CHECK(igraph_vs_all(&vs));
    }
    IGRAPH_FINALLY(igraph_vs_destroy, &vs);
    IGRAPH_CHECK(igraph_vit_create(graph, vs, &A));
    IGRAPH_FINALLY(igraph_vit_destroy, &A);

    IGRAPH_VECTOR_INIT_FINALLY(&V, 0);

    IGRAPH_CHECK(igraph_i_vcumulative_proportionate_values(graph, quantities, &V,
                 islocal, vid, mode));

    /* Finally, choose a vertex u to imitate. The vertex u is chosen */
    /* proportionate to its quantity. In the case of a local perspective, we */
    /* pretend that v's cumulative proportionate quantity has been appended to */
    /* the vector V. Let V be of length n so that V[n-1] is the last element */
    /* of V, and let r be a real number chosen uniformly at random from the */
    /* unit interval [0,1]. If r > V[i] for all i < n, then v defaults to */
    /* retaining its current strategy. Similarly in the case of the global */
    /* perspective, if r > V[i] for all i < n - 1 then v would adopt the */
    /* strategy of the vertex whose cumulative proportionate quantity is */
    /* V[n-1]. */
    /* NOTE: Here we assume that the order in which we iterate through the */
    /* vertices in A is the same as the order in which we do so in the */
    /* invoked function igraph_vcumulative_proportionate_values(). */
    /* Otherwise we would incorrectly associate each V[i] with a vertex in A. */
    RNG_BEGIN();
    r = RNG_UNIF01();
    RNG_END();
    i = 0;
    while (!IGRAPH_VIT_END(A)) {
        if (r <= VECTOR(V)[i]) {
            /* We have found our candidate vertex for imitation. Update strategy */
            /* of v to that of u, and exit the selection loop. */
            u = (igraph_integer_t)IGRAPH_VIT_GET(A);
            VECTOR(*strategies)[vid] = VECTOR(*strategies)[u];
            break;
        }
        i++;
        IGRAPH_VIT_NEXT(A);
    }

    /* By now, vertex v should either retain its current strategy or it has */
    /* adopted the strategy of a vertex in its perspective. Nothing else to */
    /* do, but clean up. */
    igraph_vector_destroy(&V);
    igraph_vit_destroy(&A);
    igraph_vs_destroy(&vs);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup spatialgames
 * \function igraph_stochastic_imitation
 * \brief Adopt a strategy via stochastic imitation with uniform selection.
 *
 * A simple stochastic imitation strategy where a vertex revises its
 * strategy to that of a vertex chosen uniformly at random from its local
 * neighbourhood. This is called stochastic imitation via uniform selection,
 * where the strategy to imitate is chosen via some random process. For the
 * purposes of this function, we use uniform selection from a pool of
 * candidates.
 *
 * \param graph The graph object representing the game network. This cannot
 *        be the empty or trivial graph, but must have at least two vertices
 *        and one edge. If \p graph has one vertex, then no strategy update
 *        would take place. Furthermore, if \p graph has at least two vertices
 *        but zero edges, then strategy update would also not take place.
 * \param vid The vertex whose strategy is to be updated. It is assumed that
 *        \p vid represents a vertex in \p graph. No checking is performed and
 *        it is your responsibility to ensure that \p vid is indeed a vertex
 *        of \p graph. If an isolated vertex is provided, i.e. the input
 *        vertex has degree 0, then no strategy update would take place and
 *        \p vid would retain its current strategy. Strategy update would also
 *        not take place if the local neighbourhood of \p vid are its
 *        in-neighbours (respectively out-neighbours), but \p vid has zero
 *        in-neighbours (respectively out-neighbours). Loops are ignored in
 *        computing the degree (in, out, all) of \p vid.
 * \param algo This flag controls which algorithm to use in stochastic
 *        imitation. Supported values are:
 *        \clist
 *        \cli IGRAPH_IMITATE_AUGMENTED
 *          Augmented imitation. Vertex \p vid imitates the strategy of the
 *          chosen vertex u provided that doing so would increase the
 *          quantity (e.g. fitness) of \p vid. Augmented imitation can be
 *          thought of as "imitate if better".
 *        \cli IGRAPH_IMITATE_BLIND
 *          Blind imitation. Vertex \p vid blindly imitates the strategy of
 *          the chosen vertex u, regardless of whether doing so would
 *          increase or decrease the quantity of \p vid.
 *        \cli IGRAPH_IMITATE_CONTRACTED
 *          Contracted imitation. Here vertex \p vid imitates the strategy of
 *          the chosen vertex u if doing so would decrease the quantity of
 *          \p vid. Think of contracted imitation as "imitate if worse".
 *        \endclist
 * \param quantities A vector of quantities providing the quantity of each
 *        vertex in \p graph. Think of each entry of the vector as being
 *        generated by a function such as the fitness function for the game.
 *        So if the vector represents fitness quantities, then each vector
 *        entry is the fitness of some vertex. The length of this vector must
 *        be the same as the number of vertices in the vertex set of \p graph.
 * \param strategies A vector of the current strategies for the vertex
 *        population. The updated strategy for \p vid would be stored here.
 *        Each strategy is identified with a nonnegative integer, whose
 *        interpretation depends on the payoff matrix of the game. Generally
 *        we use the strategy ID as a row or column index of the payoff
 *        matrix. The length of this vector must be the same as the number of
 *        vertices in the vertex set of \p graph.
 * \param mode Defines the sort of neighbourhood to consider for \p vid. If
 *        \p graph is undirected, then we use all the immediate neighbours of
 *        \p vid. Thus if you know that \p graph is undirected, then it is safe
 *        to pass the value \p IGRAPH_ALL here. Supported values are:
 *        \clist
 *        \cli IGRAPH_OUT
 *          Use the out-neighbours of \p vid. This option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_IN
 *          Use the in-neighbours of \p vid. Again this option is only relevant
 *          when \p graph is a directed graph.
 *        \cli IGRAPH_ALL
 *          Use both the in- and out-neighbours of \p vid. This option is only
 *          relevant if \p graph is a digraph. Also use this value if
 *          \p graph is undirected.
 *        \endclist
 * \return The error code \p IGRAPH_EINVAL is returned in each of the following
 *         cases: (1) Any of the parameters \p graph, \p quantities, or
 *         \p strategies is a null pointer. (2) The vector \p quantities or
 *         \p strategies has a length different from the number of vertices
 *         in \p graph. (3) The parameter \p graph is the empty or null graph,
 *         i.e. the graph with zero vertices and edges. (4) The parameter
 *         \p algo refers to an unsupported stochastic imitation algorithm.
 *
 * Time complexity: depends on the uniform random number generator, but should
 * usually be O(1).
 *
 * \example examples/simple/igraph_stochastic_imitation.c
 */

int igraph_stochastic_imitation(const igraph_t *graph,
                                igraph_integer_t vid,
                                igraph_imitate_algorithm_t algo,
                                const igraph_vector_t *quantities,
                                igraph_vector_t *strategies,
                                igraph_neimode_t mode) {
    igraph_bool_t updates;
    igraph_integer_t u;
    igraph_vector_t adj;
    int i;

    /* sanity checks */
    if (algo != IGRAPH_IMITATE_AUGMENTED &&
        algo != IGRAPH_IMITATE_BLIND &&
        algo != IGRAPH_IMITATE_CONTRACTED) {
        IGRAPH_ERROR("Unsupported stochastic imitation algorithm",
                     IGRAPH_EINVAL);
    }
    IGRAPH_CHECK(igraph_i_microscopic_standard_tests(graph, vid, quantities,
                 strategies, mode, &updates,
                 /*is local?*/ 1));
    if (!updates) {
        return IGRAPH_SUCCESS;    /* nothing more to do */
    }

    /* immediate neighbours of v */
    IGRAPH_VECTOR_INIT_FINALLY(&adj, 0);
    IGRAPH_CHECK(igraph_neighbors(graph, &adj, vid, mode));

    /* Blind imitation. Let v be the vertex whose strategy we want to revise. */
    /* Choose a vertex u uniformly at random from the immediate neighbours of */
    /* v, including v itself. Then blindly update the strategy of v to that of */
    /* u, irrespective of whether doing so would increase or decrease the */
    /* quantity (e.g. fitness) of v. Here v retains its current strategy if */
    /* the chosen vertex u is indeed v itself. */
    if (algo == IGRAPH_IMITATE_BLIND) {
        IGRAPH_CHECK(igraph_vector_push_back(&adj, vid));
        RNG_BEGIN();
        i = (int) RNG_INTEGER(0, igraph_vector_size(&adj) - 1);
        RNG_END();
        u = (igraph_integer_t) VECTOR(adj)[i];
        VECTOR(*strategies)[vid] = VECTOR(*strategies)[u];
    }
    /* Augmented imitation. Let v be the vertex whose strategy we want to */
    /* revise. Let f be the quantity function for the game. Choose a vertex u */
    /* uniformly at random from the immediate neighbours of v; do not include */
    /* v. Then v imitates the strategy of u if f(u) > f(v). Otherwise v */
    /* retains its current strategy. */
    else if (algo == IGRAPH_IMITATE_AUGMENTED) {
        RNG_BEGIN();
        i = (int) RNG_INTEGER(0, igraph_vector_size(&adj) - 1);
        RNG_END();
        u = (igraph_integer_t) VECTOR(adj)[i];
        if (VECTOR(*quantities)[u] > VECTOR(*quantities)[vid]) {
            VECTOR(*strategies)[vid] = VECTOR(*strategies)[u];
        }
    }
    /* Contracted imitation. Let v be the vertex whose strategy we want to */
    /* update and let f be the quantity function for the game. Choose a vertex */
    /* u uniformly at random from the immediate neighbours of v, excluding v */
    /* itself. Then v imitates the strategy of u provided that f(u) < f(v). */
    /* Otherwise v retains its current strategy. */
    else if (algo == IGRAPH_IMITATE_CONTRACTED) {
        RNG_BEGIN();
        i = (int) RNG_INTEGER(0, igraph_vector_size(&adj) - 1);
        RNG_END();
        u = (igraph_integer_t) VECTOR(adj)[i];
        if (VECTOR(*quantities)[u] < VECTOR(*quantities)[vid]) {
            VECTOR(*strategies)[vid] = VECTOR(*strategies)[u];
        }
    }

    /* clean up */
    igraph_vector_destroy(&adj);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/mixing.c0000644000175100001710000002510200000000000023033 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_mixing.h"

#include "igraph_interface.h"

/**
 * \function igraph_assortativity_nominal
 * Assortativity of a graph based on vertex categories
 *
 * Assuming the vertices of the input graph belong to different
 * categories, this function calculates the assortativity coefficient of
 * the graph. The assortativity coefficient is between minus one and one
 * and it is one if all connections stay within categories, it is
 * minus one, if the network is perfectly disassortative. For a
 * randomly connected network it is (asymptotically) zero.
 *
 * See equation (2) in M. E. J. Newman: Mixing patterns
 * in networks, Phys. Rev. E 67, 026126 (2003)
 * (http://arxiv.org/abs/cond-mat/0209450) for the proper
 * definition.
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param types Vector giving the vertex types. They are assumed to be
 *    integer numbers, starting with zero.
 * \param res Pointer to a real variable, the result is stored here.
 * \param directed Boolean, it gives whether to consider edge
 *    directions in a directed graph. It is ignored for undirected
 *    graphs.
 * \return Error code.
 *
 * Time complexity: O(|E|+t), |E| is the number of edges, t is the
 * number of vertex types.
 *
 * \sa \ref igraph_assortativity if the vertex types are defines by
 * numeric values (e.g. vertex degree), instead of categories.
 *
 * \example examples/simple/assortativity.c
 */

int igraph_assortativity_nominal(const igraph_t *graph,
                                 const igraph_vector_t *types,
                                 igraph_real_t *res,
                                 igraph_bool_t directed) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_types;
    igraph_vector_t ai, bi, eii;
    long int e, i;
    igraph_real_t sumaibi = 0.0, sumeii = 0.0;

    if (igraph_vector_size(types) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `types' vector length", IGRAPH_EINVAL);
    }

    if (igraph_vector_min(types) < 0) {
        IGRAPH_ERROR("Invalid `types' vector", IGRAPH_EINVAL);
    }

    directed = directed && igraph_is_directed(graph);

    no_of_types = (long int) igraph_vector_max(types) + 1;
    IGRAPH_VECTOR_INIT_FINALLY(&ai, no_of_types);
    IGRAPH_VECTOR_INIT_FINALLY(&bi, no_of_types);
    IGRAPH_VECTOR_INIT_FINALLY(&eii, no_of_types);

    for (e = 0; e < no_of_edges; e++) {
        long int from = IGRAPH_FROM(graph, e);
        long int to = IGRAPH_TO(graph, e);
        long int from_type = (long int) VECTOR(*types)[from];
        long int to_type = (long int) VECTOR(*types)[to];

        VECTOR(ai)[from_type] += 1;
        VECTOR(bi)[to_type] += 1;
        if (from_type == to_type) {
            VECTOR(eii)[from_type] += 1;
        }
        if (!directed) {
            if (from_type == to_type) {
                VECTOR(eii)[from_type] += 1;
            }
            VECTOR(ai)[to_type] += 1;
            VECTOR(bi)[from_type] += 1;
        }
    }

    for (i = 0; i < no_of_types; i++) {
        sumaibi += (VECTOR(ai)[i] / no_of_edges) * (VECTOR(bi)[i] / no_of_edges);
        sumeii  += (VECTOR(eii)[i] / no_of_edges);
    }

    if (!directed) {
        sumaibi /= 4.0;
        sumeii  /= 2.0;
    }

    *res = (sumeii - sumaibi) / (1.0 - sumaibi);

    igraph_vector_destroy(&eii);
    igraph_vector_destroy(&bi);
    igraph_vector_destroy(&ai);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_assortativity
 * Assortativity based on numeric properties of vertices
 *
 * This function calculates the assortativity coefficient of the input
 * graph. This coefficient is basically the correlation between the
 * actual connectivity patterns of the vertices and the pattern
 * expected from the distribution of the vertex types.
 *
 * See equation (21) in M. E. J. Newman: Mixing patterns
 * in networks, Phys. Rev. E 67, 026126 (2003)
 * (http://arxiv.org/abs/cond-mat/0209450) for the proper
 * definition. The actual calculation is performed using equation (26)
 * in the same paper for directed graphs, and equation (4) in
 * M. E. J. Newman: Assortative mixing in networks,
 * Phys. Rev. Lett. 89, 208701 (2002)
 * (http://arxiv.org/abs/cond-mat/0205405/) for undirected graphs.
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param types1 The vertex values, these can be arbitrary numeric
 *     values.
 * \param types2 A second value vector to be using for the incoming
 *     edges when calculating assortativity for a directed graph.
 *     Supply a null pointer here if you want to use the same values
 *     for outgoing and incoming edges. This argument is ignored
 *     (with a warning) if it is not a null pointer and undirected
 *     assortativity coefficient is being calculated.
 * \param res Pointer to a real variable, the result is stored here.
 * \param directed Boolean, whether to consider edge directions for
 *     directed graphs. It is ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|E|), linear in the number of edges of the
 * graph.
 *
 * \sa \ref igraph_assortativity_nominal() if you have discrete vertex
 * categories instead of numeric labels, and \ref
 * igraph_assortativity_degree() for the special case of assortativity
 * based on vertex degree.
 *
 * \example examples/simple/assortativity.c
 */

int igraph_assortativity(const igraph_t *graph,
                         const igraph_vector_t *types1,
                         const igraph_vector_t *types2,
                         igraph_real_t *res,
                         igraph_bool_t directed) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int e;

    directed = directed && igraph_is_directed(graph);

    if (!directed && types2) {
        IGRAPH_WARNING("Only `types1' is used for undirected case");
    }

    if (igraph_vector_size(types1) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `types1' vector length", IGRAPH_EINVAL);
    }

    if (types2 && igraph_vector_size(types2) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `types2' vector length", IGRAPH_EINVAL);
    }

    if (!directed) {
        igraph_real_t num1 = 0.0, num2 = 0.0, den1 = 0.0;

        for (e = 0; e < no_of_edges; e++) {
            long int from = IGRAPH_FROM(graph, e);
            long int to = IGRAPH_TO(graph, e);
            igraph_real_t from_type = VECTOR(*types1)[from];
            igraph_real_t to_type = VECTOR(*types1)[to];

            num1 += from_type * to_type;
            num2 += from_type + to_type;
            den1 += from_type * from_type + to_type * to_type;
        }

        num1 /= no_of_edges;
        den1 /= no_of_edges * 2;
        num2 /= no_of_edges * 2;
        num2 = num2 * num2;

        *res = (num1 - num2) / (den1 - num2);

    } else {
        igraph_real_t num1 = 0.0, num2 = 0.0, num3 = 0.0,
                      den1 = 0.0, den2 = 0.0;
        igraph_real_t num, den;

        if (!types2) {
            types2 = types1;
        }

        for (e = 0; e < no_of_edges; e++) {
            long int from = IGRAPH_FROM(graph, e);
            long int to = IGRAPH_TO(graph, e);
            igraph_real_t from_type = VECTOR(*types1)[from];
            igraph_real_t to_type = VECTOR(*types2)[to];

            num1 += from_type * to_type;
            num2 += from_type;
            num3 += to_type;
            den1 += from_type * from_type;
            den2 += to_type * to_type;
        }

        num = num1 - num2 * num3 / no_of_edges;
        den = sqrt(den1 - num2 * num2 / no_of_edges) *
              sqrt(den2 - num3 * num3 / no_of_edges);

        *res = num / den;
    }

    return 0;
}

/**
 * \function igraph_assortativity_degree
 * Assortativity of a graph based on vertex degree
 *
 * Assortativity based on vertex degree, please see the discussion at
 * the documentation of \ref igraph_assortativity() for details.
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param res Pointer to a real variable, the result is stored here.
 * \param directed Boolean, whether to consider edge directions for
 *     directed graphs. This argument is ignored for undirected
 *     graphs. Supply 1 (=TRUE) here to do the natural thing, i.e. use
 *     directed version of the measure for directed graphs and the
 *     undirected version for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|E|+|V|), |E| is the number of edges, |V| is
 * the number of vertices.
 *
 * \sa \ref igraph_assortativity() for the general function
 * calculating assortativity for any kind of numeric vertex values.
 *
 * \example examples/simple/assortativity.c
 */

int igraph_assortativity_degree(const igraph_t *graph,
                                igraph_real_t *res,
                                igraph_bool_t directed) {

    directed = directed && igraph_is_directed(graph);

    if (directed) {
        igraph_vector_t indegree, outdegree;
        igraph_vector_init(&indegree, 0);
        igraph_vector_init(&outdegree, 0);
        igraph_degree(graph, &indegree, igraph_vss_all(), IGRAPH_IN, /*loops=*/ 1);
        igraph_degree(graph, &outdegree, igraph_vss_all(), IGRAPH_OUT, /*loops=*/ 1);
        igraph_vector_add_constant(&indegree, -1);
        igraph_vector_add_constant(&outdegree, -1);
        igraph_assortativity(graph, &outdegree, &indegree, res, /*directed=*/ 1);
        igraph_vector_destroy(&indegree);
        igraph_vector_destroy(&outdegree);
    } else {
        igraph_vector_t degree;
        igraph_vector_init(°ree, 0);
        igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, /*loops=*/ 1);
        igraph_vector_add_constant(°ree, -1);
        igraph_assortativity(graph, °ree, 0, res, /*directed=*/ 0);
        igraph_vector_destroy(°ree);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/motifs.c0000644000175100001710000012541100000000000023045 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_motifs.h"

#include "igraph_memory.h"
#include "igraph_random.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_nongraph.h"
#include "igraph_stack.h"

#include "core/interruption.h"
#include "isomorphism/isoclasses.h"
#include "graph/neighbors.h"

/**
 * Callback function for igraph_motifs_randesu that counts the motifs by
 * isomorphism class in a histogram.
 */
static igraph_bool_t igraph_i_motifs_randesu_update_hist(
        const igraph_t *graph,
        igraph_vector_t *vids, int isoclass, void* extra) {
    igraph_vector_t *hist = (igraph_vector_t*)extra;
    IGRAPH_UNUSED(graph); IGRAPH_UNUSED(vids);
    VECTOR(*hist)[isoclass]++;
    return 0;
}

/**
 * \function igraph_motifs_randesu
 * \brief Count the number of motifs in a graph.
 *
 * 
 * Motifs are small weakly connected induced subgraphs of a given structure in a
 * graph. It is argued that the motif profile (i.e. the number of
 * different motifs in the graph) is characteristic for different
 * types of networks and network function is related to the motifs in
 * the graph.
 *
 * 
 * This function is able to find directed motifs of sizes three
 * and four and undirected motifs of sizes three to six
 * (i.e. the number of different subgraphs with three to six
 * vertices in the network).
 *
 * 
 * In a big network the total number of motifs can be very large, so
 * it takes a lot of time to find all of them, a sampling method can
 * be used. This function is capable of doing sampling via the
 * \p cut_prob argument. This argument gives the probability that
 * a branch of the motif search tree will not be explored. See
 * S. Wernicke and F. Rasche: FANMOD: a tool for fast network motif
 * detection, Bioinformatics 22(9), 1152--1153, 2006 for details.
 * https://doi.org/10.1093/bioinformatics/btl038
 *
 * 
 * Set the \p cut_prob argument to a zero vector for finding all
 * motifs.
 *
 * 
 * Directed motifs will be counted in directed graphs and undirected
 * motifs in undirected graphs.
 *
 * \param graph The graph to find the motifs in.
 * \param hist The result of the computation, it gives the number of
 *        motifs found for each isomorphism class. See
 *        \ref igraph_isoclass() for help about isomorphism classes.
 *        Note that this function does \em not count isomorphism
 *        classes that are not connected and will report NaN (more
 *        precisely \c IGRAPH_NAN) for them.
 * \param size The size of the motifs to search for. For directed graphs,
 *        only 3 and 4 are implemented, for undirected, 3 to 6.
 *        The limitation is not in the motif finding code, but the graph
 *        isomorphism code.
 * \param cut_prob Vector of probabilities for cutting the search tree
 *        at a given level. The first element is the first level, etc.
 *        Supply all zeros here (of length \p size) to find all motifs
 *        in a graph.
 * \return Error code.
 *
 * \sa \ref igraph_motifs_randesu_estimate() for estimating the number
 * of motifs in a graph, this can help to set the \p cut_prob
 * parameter; \ref igraph_motifs_randesu_no() to calculate the total
 * number of motifs of a given size in a graph;
 * \ref igraph_motifs_randesu_callback() for calling a callback function
 * for every motif found; \ref igraph_subisomorphic_lad() for finding
 * subgraphs on more than 4 (directed) or 6 (undirected) vertices.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_motifs_randesu.c
 */
int igraph_motifs_randesu(const igraph_t *graph, igraph_vector_t *hist,
                          int size, const igraph_vector_t *cut_prob) {
    igraph_bool_t directed = igraph_is_directed(graph);
    int histlen;

    if (directed) {
        switch (size) {
        case 3:
            histlen = 16;
            break;
        case 4:
            histlen = 218;
            break;
        default:
            IGRAPH_ERROR("In directed graphs, only 3 and 4 vertex motifs are supported.",
                         IGRAPH_UNIMPLEMENTED);
        }
    } else {
        switch (size) {
        case 3:
            histlen = 4;
            break;
        case 4:
            histlen = 11;
            break;
        case 5:
            histlen = 34;
            break;
        case 6:
            histlen = 156;
            break;
        default:
            IGRAPH_ERROR("In undirected graphs, only 3 to 6 vertex motifs are supported.",
                         IGRAPH_UNIMPLEMENTED);
        }
    }

    if (igraph_vector_size(cut_prob) != size) {
        IGRAPH_ERRORF("Cut probability vector size (%ld) must agree with motif size (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_size(cut_prob), size);
    }

    IGRAPH_CHECK(igraph_vector_resize(hist, histlen));
    igraph_vector_null(hist);

    IGRAPH_CHECK(igraph_motifs_randesu_callback(graph, size, cut_prob,
                 &igraph_i_motifs_randesu_update_hist, hist));

    if (size == 3) {
        if (directed) {
            VECTOR(*hist)[0] = VECTOR(*hist)[1] = VECTOR(*hist)[3] = IGRAPH_NAN;
        } else {
            VECTOR(*hist)[0] = VECTOR(*hist)[1] = IGRAPH_NAN;
        }
    } else if (size == 4) {
        if (directed) {
            int not_connected[] = { 0, 1, 2, 4, 5, 6, 9, 10, 11, 15, 22, 23, 27,
                                    28, 33, 34, 39, 62, 120
                                  };
            int i, n = sizeof(not_connected) / sizeof(int);
            for (i = 0; i < n; i++) {
                VECTOR(*hist)[not_connected[i]] = IGRAPH_NAN;
            }
        } else {
            VECTOR(*hist)[0] = VECTOR(*hist)[1] = VECTOR(*hist)[2] =
                    VECTOR(*hist)[3] = VECTOR(*hist)[5] = IGRAPH_NAN;
        }
    } else if (size == 5) {
        /* undirected only */
        int not_connected[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 19 };
        int i, n = sizeof(not_connected) / sizeof(int);
        for (i = 0; i < n; i++) {
            VECTOR(*hist)[not_connected[i]] = IGRAPH_NAN;
        }
    } else if (size == 6) {
        /* undirected only */
        int not_connected[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
                               19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 38,
                               44, 50, 51, 54, 74, 77, 89, 120};
        int i, n = sizeof(not_connected) / sizeof(int);
        for (i = 0; i < n; i++) {
            VECTOR(*hist)[not_connected[i]] = IGRAPH_NAN;
        }
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_motifs_randesu_callback
 * \brief Finds motifs in a graph and calls a function for each of them.
 *
 * 
 * Similarly to \ref igraph_motifs_randesu(), this function is able to find
 * directed motifs of sizes three and four and undirected motifs of sizes
 * three to six (i.e. the number of different subgraphs with three to six
 * vertices in the network). However, instead of
 * counting them, the function will call a callback function for each motif
 * found to allow further tests or post-processing.
 *
 * 
 * The \p cut_prob argument also allows sampling the motifs, just like for
 * \ref igraph_motifs_randesu(). Set the \p cut_prob argument to a zero vector
 * for finding all motifs.
 *
 * \param graph The graph to find the motifs in.
 * \param size The size of the motifs to search for. Only three and
 *        four are implemented currently. The limitation is not in the
 *        motif finding code, but the graph isomorphism code.
 * \param cut_prob Vector of probabilities for cutting the search tree
 *        at a given level. The first element is the first level, etc.
 *        Supply all zeros here (of length \c size) to find all motifs
 *        in a graph.
 * \param callback A pointer to a function of type \ref igraph_motifs_handler_t.
 *        This function will be called whenever a new motif is found.
 * \param extra Extra argument to pass to the callback function.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \example examples/simple/igraph_motifs_randesu.c
 */

int igraph_motifs_randesu_callback(const igraph_t *graph, int size,
                                   const igraph_vector_t *cut_prob, igraph_motifs_handler_t *callback,
                                   void* extra) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_adjlist_t allneis, alloutneis;
    igraph_vector_int_t *neis;
    long int father;
    long int i, j, s;
    long int motifs = 0;
    IGRAPH_UNUSED(motifs);    /* We mark it as unused to prevent warnings about unused-but-set-variables. */

    igraph_vector_t vids;     /* this is G */
    igraph_vector_t adjverts; /* this is V_E */
    igraph_stack_t stack;     /* this is S */
    long int *added;
    char *subg;

    const unsigned int *arr_idx, *arr_code;
    unsigned int code = 0;
    unsigned int mul, idx;

    igraph_bool_t terminate = 0;

    if (igraph_is_directed(graph)) {
        switch (size) {
        case 3:
            arr_idx = igraph_i_isoclass_3_idx;
            arr_code = igraph_i_isoclass2_3;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4_idx;
            arr_code = igraph_i_isoclass2_4;
            mul = 4;
            break;
        default:
            IGRAPH_ERROR("In directed graphs, only 3 and 4 vertex motifs are supported.",
                         IGRAPH_UNIMPLEMENTED);
        }
    } else {
        switch (size) {
        case 3:
            arr_idx = igraph_i_isoclass_3u_idx;
            arr_code = igraph_i_isoclass2_3u;
            mul = 3;
            break;
        case 4:
            arr_idx = igraph_i_isoclass_4u_idx;
            arr_code = igraph_i_isoclass2_4u;
            mul = 4;
            break;
        case 5:
            arr_idx = igraph_i_isoclass_5u_idx;
            arr_code = igraph_i_isoclass2_5u;
            mul = 5;
            break;
        case 6:
            arr_idx = igraph_i_isoclass_6u_idx;
            arr_code = igraph_i_isoclass2_6u;
            mul = 6;
            break;
        default:
            IGRAPH_ERROR("In undirected graphs, only 3 to 6 vertex motifs are supported.",
                         IGRAPH_UNIMPLEMENTED);
        }
    }

    if (igraph_vector_size(cut_prob) != size) {
        IGRAPH_ERRORF("Cut probability vector size (%ld) must agree with motif size (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_size(cut_prob), size);
    }

    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot find motifs", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);

    subg = IGRAPH_CALLOC(no_of_nodes, char);
    if (subg == 0) {
        IGRAPH_ERROR("Cannot find motifs", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, subg);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &alloutneis, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &alloutneis);

    IGRAPH_VECTOR_INIT_FINALLY(&vids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjverts, 0);
    IGRAPH_CHECK(igraph_stack_init(&stack, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);

    RNG_BEGIN();

    for (father = 0; father < no_of_nodes; father++) {
        long int level;

        IGRAPH_ALLOW_INTERRUPTION();

        if (VECTOR(*cut_prob)[0] == 1 ||
            RNG_UNIF01() < VECTOR(*cut_prob)[0]) {
            continue;
        }

        /* init G */
        igraph_vector_clear(&vids); level = 0;
        IGRAPH_CHECK(igraph_vector_push_back(&vids, father));
        subg[father] = 1; added[father] += 1; level += 1;

        /* init V_E */
        igraph_vector_clear(&adjverts);
        neis = igraph_adjlist_get(&allneis, father);
        s = igraph_vector_int_size(neis);
        for (i = 0; i < s; i++) {
            long int nei = (long int) VECTOR(*neis)[i];
            if (!added[nei] && nei > father) {
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, father));
            }
            added[nei] += 1;
        }

        /* init S */
        igraph_stack_clear(&stack);

        while (level > 1 || !igraph_vector_empty(&adjverts)) {
            igraph_real_t cp = VECTOR(*cut_prob)[level];

            if (level == size - 1) {
                s = igraph_vector_size(&adjverts) / 2;
                for (i = 0; i < s; i++) {
                    long int k, s2;
                    long int last;

                    if (cp != 0 && RNG_UNIF01() < cp) {
                        continue;
                    }
                    motifs += 1;

                    last = (long int) VECTOR(adjverts)[2 * i];
                    IGRAPH_CHECK(igraph_vector_push_back(&vids, last));
                    subg[last] = (char) size;

                    code = 0; idx = 0;
                    for (k = 0; k < size; k++) {
                        long int from = (long int) VECTOR(vids)[k];
                        neis = igraph_adjlist_get(&alloutneis, from);
                        s2 = igraph_vector_int_size(neis);
                        for (j = 0; j < s2; j++) {
                            long int nei = (long int) VECTOR(*neis)[j];
                            if (subg[nei] && k != subg[nei] - 1) {
                                idx = (unsigned char) (mul * k + (subg[nei] - 1));
                                code |= arr_idx[idx];
                            }
                        }
                    }

                    if (callback(graph, &vids, (int) arr_code[code], extra)) {
                        terminate = 1;
                        break;
                    }
                    igraph_vector_pop_back(&vids);
                    subg[last] = 0;
                }
            }

            /* did the callback function asked us to terminate the search? */
            if (terminate) {
                break;
            }

            /* can we step down? */
            if (level < size - 1 &&
                !igraph_vector_empty(&adjverts)) {
                /* we might step down */
                long int neifather = (long int) igraph_vector_pop_back(&adjverts);
                long int nei = (long int) igraph_vector_pop_back(&adjverts);

                if (cp == 0 || RNG_UNIF01() > cp) {
                    /* yes, step down */
                    IGRAPH_CHECK(igraph_vector_push_back(&vids, nei));
                    subg[nei] = (char) level + 1; added[nei] += 1; level += 1;

                    IGRAPH_CHECK(igraph_stack_push(&stack, neifather));
                    IGRAPH_CHECK(igraph_stack_push(&stack, nei));
                    IGRAPH_CHECK(igraph_stack_push(&stack, level));

                    neis = igraph_adjlist_get(&allneis, nei);
                    s = igraph_vector_int_size(neis);
                    for (i = 0; i < s; i++) {
                        long int nei2 = (long int) VECTOR(*neis)[i];
                        if (!added[nei2] && nei2 > father) {
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei2));
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                        }
                        added[nei2] += 1;
                    }
                }
            } else {
                /* no, step back */
                long int nei, neifather;
                while (!igraph_stack_empty(&stack) &&
                       level == igraph_stack_top(&stack) - 1) {
                    igraph_stack_pop(&stack);
                    nei = (long int) igraph_stack_pop(&stack);
                    neifather = (long int) igraph_stack_pop(&stack);
                    igraph_vector_push_back(&adjverts, nei);
                    igraph_vector_push_back(&adjverts, neifather);
                }

                nei = (long int) igraph_vector_pop_back(&vids);
                subg[nei] = 0; added[nei] -= 1; level -= 1;
                neis = igraph_adjlist_get(&allneis, nei);
                s = igraph_vector_int_size(neis);
                for (i = 0; i < s; i++) {
                    added[ (long int) VECTOR(*neis)[i] ] -= 1;
                }
                while (!igraph_vector_empty(&adjverts) &&
                       igraph_vector_tail(&adjverts) == nei) {
                    igraph_vector_pop_back(&adjverts);
                    igraph_vector_pop_back(&adjverts);
                }
            }

        } /* while */

        /* did the callback function asked us to terminate the search? */
        if (terminate) {
            break;
        }

        /* clear the added vector */
        added[father] -= 1;
        subg[father] = 0;
        neis = igraph_adjlist_get(&allneis, father);
        s = igraph_vector_int_size(neis);
        for (i = 0; i < s; i++) {
            added[ (long int) VECTOR(*neis)[i] ] -= 1;
        }

    } /* for father */

    RNG_END();

    IGRAPH_FREE(added);
    IGRAPH_FREE(subg);
    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&adjverts);
    igraph_adjlist_destroy(&alloutneis);
    igraph_adjlist_destroy(&allneis);
    igraph_stack_destroy(&stack);
    IGRAPH_FINALLY_CLEAN(7);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_motifs_randesu_estimate
 * \brief Estimate the total number of motifs in a graph.
 *
 * This function estimates the total number of weakly connected induced
 * subgraphs, called motifs, of a fixed number of vertices. For
 * example, an undirected complete graph on \c n vertices
 * will have one motif of size \c n, and \c n motifs
 * of \p size n - 1. As another example, one triangle
 * and a separate vertex will have zero motifs of size four.
 *
 * 
 * This function is useful for large graphs for which it is not
 * feasible to count all the different motifs, because there are very
 * many of them.
 *
 * 
 * The total number of motifs is estimated by taking a sample of
 * vertices and counts all motifs in which these vertices are
 * included. (There is also a \p cut_prob parameter which gives the
 * probabilities to cut a branch of the search tree.)
 *
 * 
 * Directed motifs will be counted in directed graphs and undirected
 * motifs in undirected graphs.
 *
 * \param graph The graph object to study.
 * \param est Pointer to an integer type, the result will be stored
 *        here.
 * \param size The size of the motifs to look for.
 * \param cut_prob Vector giving the probabilities to cut a branch of
 *        the search tree and omit counting the motifs in that branch.
 *        It contains a probability for each level. Supply \p size
 *        zeros here to count all the motifs in the sample.
 * \param sample_size The number of vertices to use as the
 *        sample. This parameter is only used if the \p parsample
 *        argument is a null pointer.
 * \param parsample Either pointer to an initialized vector or a null
 *        pointer. If a vector then the vertex ids in the vector are
 *        used as a sample. If a null pointer then the \p sample_size
 *        argument is used to create a sample of vertices drawn with
 *        uniform probability.
 * \return Error code.
 * \sa \ref igraph_motifs_randesu(), \ref igraph_motifs_randesu_no().
 *
 * Time complexity: TODO.
 */

int igraph_motifs_randesu_estimate(const igraph_t *graph, igraph_integer_t *est,
                                   int size, const igraph_vector_t *cut_prob,
                                   igraph_integer_t sample_size,
                                   const igraph_vector_t *parsample) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t neis;

    igraph_vector_t vids;     /* this is G */
    igraph_vector_t adjverts; /* this is V_E */
    igraph_stack_t stack;     /* this is S */
    long int *added;
    igraph_vector_t *sample;
    long int sam;
    long int i;

    if (size < 3) {
        IGRAPH_ERRORF("Motif size must be at least 3, received %" IGRAPH_PRId ".",
                      IGRAPH_EINVAL, (igraph_integer_t) size);
    }

    if (igraph_vector_size(cut_prob) != size) {
        IGRAPH_ERRORF("Cut probability vector size (%ld) must agree with motif size (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_size(cut_prob), size);
    }

    if (parsample && igraph_vector_size(parsample) != 0) {
        igraph_real_t min, max;
        igraph_vector_minmax(parsample, &min, &max);
        if (min < 0 || max >= no_of_nodes) {
            IGRAPH_ERROR("Sample vertex id out of range.", IGRAPH_EINVAL);
        }
    }

    if (no_of_nodes == 0) {
        *est = 0;
        return IGRAPH_SUCCESS;
    }

    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot find motifs.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);

    IGRAPH_VECTOR_INIT_FINALLY(&vids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjverts, 0);
    IGRAPH_CHECK(igraph_stack_init(&stack, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    if (parsample == NULL) {
        sample = IGRAPH_CALLOC(1, igraph_vector_t);
        if (sample == NULL) {
            IGRAPH_ERROR("Cannot estimate motifs.", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, sample);
        IGRAPH_VECTOR_INIT_FINALLY(sample, 0);
        IGRAPH_CHECK(igraph_random_sample(sample, 0, no_of_nodes - 1, sample_size));
    } else {
        sample = (igraph_vector_t*)parsample;
        sample_size = (igraph_integer_t) igraph_vector_size(sample);
    }

    *est = 0;

    RNG_BEGIN();

    for (sam = 0; sam < sample_size; sam++) {
        long int father = (long int) VECTOR(*sample)[sam];
        long int level, s;

        IGRAPH_ALLOW_INTERRUPTION();

        if (VECTOR(*cut_prob)[0] == 1 ||
            RNG_UNIF01() < VECTOR(*cut_prob)[0]) {
            continue;
        }

        /* init G */
        igraph_vector_clear(&vids); level = 0;
        IGRAPH_CHECK(igraph_vector_push_back(&vids, father));
        added[father] += 1; level += 1;

        /* init V_E */
        igraph_vector_clear(&adjverts);
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) father,
                                      IGRAPH_ALL));
        s = igraph_vector_size(&neis);
        for (i = 0; i < s; i++) {
            long int nei = (long int) VECTOR(neis)[i];
            if (!added[nei] && nei > father) {
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, father));
            }
            added[nei] += 1;
        }

        /* init S */
        igraph_stack_clear(&stack);

        while (level > 1 || !igraph_vector_empty(&adjverts)) {
            igraph_real_t cp = VECTOR(*cut_prob)[level];

            if (level == size - 1) {
                s = igraph_vector_size(&adjverts) / 2;
                for (i = 0; i < s; i++) {
                    if (cp != 0 && RNG_UNIF01() < cp) {
                        continue;
                    }
                    (*est) += 1;
                }
            }

            if (level < size - 1 &&
                !igraph_vector_empty(&adjverts)) {
                /* We might step down */
                long int neifather = (long int) igraph_vector_pop_back(&adjverts);
                long int nei = (long int) igraph_vector_pop_back(&adjverts);

                if (cp == 0 || RNG_UNIF01() > cp) {
                    /* Yes, step down */
                    IGRAPH_CHECK(igraph_vector_push_back(&vids, nei));
                    added[nei] += 1; level += 1;

                    IGRAPH_CHECK(igraph_stack_push(&stack, neifather));
                    IGRAPH_CHECK(igraph_stack_push(&stack, nei));
                    IGRAPH_CHECK(igraph_stack_push(&stack, level));

                    IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) nei,
                                                  IGRAPH_ALL));
                    s = igraph_vector_size(&neis);
                    for (i = 0; i < s; i++) {
                        long int nei2 = (long int) VECTOR(neis)[i];
                        if (!added[nei2] && nei2 > father) {
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei2));
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                        }
                        added[nei2] += 1;
                    }
                }
            } else {
                /* no, step back */
                long int nei, neifather;
                while (!igraph_stack_empty(&stack) &&
                       level == igraph_stack_top(&stack) - 1) {
                    igraph_stack_pop(&stack);
                    nei = (long int) igraph_stack_pop(&stack);
                    neifather = (long int) igraph_stack_pop(&stack);
                    igraph_vector_push_back(&adjverts, nei);
                    igraph_vector_push_back(&adjverts, neifather);
                }

                nei = (long int) igraph_vector_pop_back(&vids);
                added[nei] -= 1; level -= 1;
                IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) nei,
                                              IGRAPH_ALL));
                s = igraph_vector_size(&neis);
                for (i = 0; i < s; i++) {
                    added[ (long int) VECTOR(neis)[i] ] -= 1;
                }
                while (!igraph_vector_empty(&adjverts) &&
                       igraph_vector_tail(&adjverts) == nei) {
                    igraph_vector_pop_back(&adjverts);
                    igraph_vector_pop_back(&adjverts);
                }
            }

        } /* while */

        /* clear the added vector */
        added[father] -= 1;
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) father,
                                      IGRAPH_ALL));
        s = igraph_vector_size(&neis);
        for (i = 0; i < s; i++) {
            added[ (long int) VECTOR(neis)[i] ] -= 1;
        }

    } /* for father */

    RNG_END();

    (*est) *= ((double)no_of_nodes / sample_size);

    if (parsample == 0) {
        igraph_vector_destroy(sample);
        IGRAPH_FREE(sample);
        IGRAPH_FINALLY_CLEAN(2);
    }

    IGRAPH_FREE(added);
    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&adjverts);
    igraph_stack_destroy(&stack);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(5);
    return 0;
}

/**
 * \function igraph_motifs_randesu_no
 * \brief Count the total number of motifs in a graph.
 *
 * 
 * This function counts the total number of motifs in a graph,
 * i.e. the number of of (weakly) connected triplets or quadruplets,
 * without assigning isomorphism classes to them.
 *
 * \param graph The graph object to study.
 * \param no Pointer to an integer type, the result will be stored
 *        here.
 * \param size The size of the motifs to count.
 * \param cut_prob Vector giving the probabilities that a branch of
 *        the search tree will be cut at a given level.
 * \return Error code.
 * \sa \ref igraph_motifs_randesu(), \ref
 *     igraph_motifs_randesu_estimate().
 *
 * Time complexity: TODO.
 */

int igraph_motifs_randesu_no(const igraph_t *graph, igraph_integer_t *no,
                             int size, const igraph_vector_t *cut_prob) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t neis;

    igraph_vector_t vids;     /* this is G */
    igraph_vector_t adjverts; /* this is V_E */
    igraph_stack_t stack;     /* this is S */
    long int *added;
    long int father;
    long int i;

    if (size < 3) {
        IGRAPH_ERRORF("Motif size must be at least 3, received %" IGRAPH_PRId ".",
                      IGRAPH_EINVAL, (igraph_integer_t) size);
    }

    if (igraph_vector_size(cut_prob) != size) {
        IGRAPH_ERRORF("Cut probability vector size (%ld) must agree with motif size (%" IGRAPH_PRId ").",
                      IGRAPH_EINVAL, igraph_vector_size(cut_prob), size);
    }
    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot find motifs.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);

    IGRAPH_VECTOR_INIT_FINALLY(&vids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&adjverts, 0);
    IGRAPH_CHECK(igraph_stack_init(&stack, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &stack);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    *no = 0;

    RNG_BEGIN();

    for (father = 0; father < no_of_nodes; father++) {
        long int level, s;

        IGRAPH_ALLOW_INTERRUPTION();

        if (VECTOR(*cut_prob)[0] == 1 ||
            RNG_UNIF01() < VECTOR(*cut_prob)[0]) {
            continue;
        }

        /* init G */
        igraph_vector_clear(&vids); level = 0;
        IGRAPH_CHECK(igraph_vector_push_back(&vids, father));
        added[father] += 1; level += 1;

        /* init V_E */
        igraph_vector_clear(&adjverts);
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) father,
                                      IGRAPH_ALL));
        s = igraph_vector_size(&neis);
        for (i = 0; i < s; i++) {
            long int nei = (long int) VECTOR(neis)[i];
            if (!added[nei] && nei > father) {
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                IGRAPH_CHECK(igraph_vector_push_back(&adjverts, father));
            }
            added[nei] += 1;
        }

        /* init S */
        igraph_stack_clear(&stack);

        while (level > 1 || !igraph_vector_empty(&adjverts)) {
            igraph_real_t cp = VECTOR(*cut_prob)[level];

            if (level == size - 1) {
                s = igraph_vector_size(&adjverts) / 2;
                for (i = 0; i < s; i++) {
                    if (cp != 0 && RNG_UNIF01() < cp) {
                        continue;
                    }
                    (*no) += 1;
                }
            }

            if (level < size - 1 &&
                !igraph_vector_empty(&adjverts)) {
                /* We might step down */
                long int neifather = (long int) igraph_vector_pop_back(&adjverts);
                long int nei = (long int) igraph_vector_pop_back(&adjverts);

                if (cp == 0 || RNG_UNIF01() > cp) {
                    /* Yes, step down */
                    IGRAPH_CHECK(igraph_vector_push_back(&vids, nei));
                    added[nei] += 1; level += 1;

                    IGRAPH_CHECK(igraph_stack_push(&stack, neifather));
                    IGRAPH_CHECK(igraph_stack_push(&stack, nei));
                    IGRAPH_CHECK(igraph_stack_push(&stack, level));

                    IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) nei,
                                                  IGRAPH_ALL));
                    s = igraph_vector_size(&neis);
                    for (i = 0; i < s; i++) {
                        long int nei2 = (long int) VECTOR(neis)[i];
                        if (!added[nei2] && nei2 > father) {
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei2));
                            IGRAPH_CHECK(igraph_vector_push_back(&adjverts, nei));
                        }
                        added[nei2] += 1;
                    }
                }
            } else {
                /* no, step back */
                long int nei, neifather;
                while (!igraph_stack_empty(&stack) &&
                       level == igraph_stack_top(&stack) - 1) {
                    igraph_stack_pop(&stack);
                    nei = (long int) igraph_stack_pop(&stack);
                    neifather = (long int) igraph_stack_pop(&stack);
                    igraph_vector_push_back(&adjverts, nei);
                    igraph_vector_push_back(&adjverts, neifather);
                }

                nei = (long int) igraph_vector_pop_back(&vids);
                added[nei] -= 1; level -= 1;
                IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) nei,
                                              IGRAPH_ALL));
                s = igraph_vector_size(&neis);
                for (i = 0; i < s; i++) {
                    added[ (long int) VECTOR(neis)[i] ] -= 1;
                }
                while (!igraph_vector_empty(&adjverts) &&
                       igraph_vector_tail(&adjverts) == nei) {
                    igraph_vector_pop_back(&adjverts);
                    igraph_vector_pop_back(&adjverts);
                }
            }

        } /* while */

        /* clear the added vector */
        added[father] -= 1;
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) father,
                                      IGRAPH_ALL));
        s = igraph_vector_size(&neis);
        for (i = 0; i < s; i++) {
            added[ (long int) VECTOR(neis)[i] ] -= 1;
        }

    } /* for father */

    RNG_END();

    IGRAPH_FREE(added);
    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&adjverts);
    igraph_stack_destroy(&stack);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(5);
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_dyad_census
 * \brief Calculating the dyad census as defined by Holland and Leinhardt.
 *
 * 
 * Dyad census means classifying each pair of vertices of a directed
 * graph into three categories: mutual (there is at least one edge from
 * \c a to \c b and also from \c b to \c a); asymmetric (there is at least
 * one edge either from \c a to \c b or from \c b to \c a, but not the other
 * way) and null (no edges between \c a and \c b in either direction).
 *
 * 
 * Holland, P.W. and Leinhardt, S.  (1970).  A Method for Detecting
 * Structure in Sociometric Data.  American Journal of Sociology,
 * 70, 492-513.
 *
 * \param graph The input graph. For an undirected graph, there are no
 *    asymmetric connections.
 * \param mut Pointer to an integer, the number of mutual dyads is
 *    stored here.
 * \param asym Pointer to an integer, the number of asymmetric dyads
 *    is stored here.
 * \param null Pointer to an integer, the number of null dyads is
 *    stored here. In case of an integer overflow (i.e. too many
 *    null dyads), -1 will be returned.
 * \return Error code.
 *
 * \sa \ref igraph_reciprocity(), \ref igraph_triad_census().
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges.
 */
int igraph_dyad_census(const igraph_t *graph, igraph_integer_t *mut,
                       igraph_integer_t *asym, igraph_integer_t *null) {

    igraph_integer_t nonrec = 0, rec = 0;
    igraph_vector_t inneis, outneis;
    igraph_integer_t vc = igraph_vcount(graph);
    long int i;

    IGRAPH_VECTOR_INIT_FINALLY(&inneis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outneis, 0);

    for (i = 0; i < vc; i++) {
        long int ideg, odeg;
        long int ip, op;

        IGRAPH_CHECK(igraph_i_neighbors(graph, &inneis, i, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
        IGRAPH_CHECK(igraph_i_neighbors(graph, &outneis, i, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));

        ideg = igraph_vector_size(&inneis);
        odeg = igraph_vector_size(&outneis);

        ip = op = 0;
        while (ip < ideg && op < odeg) {
            if (VECTOR(inneis)[ip] < VECTOR(outneis)[op]) {
                nonrec += 1;
                ip++;
            } else if (VECTOR(inneis)[ip] > VECTOR(outneis)[op]) {
                nonrec += 1;
                op++;
            } else {
                rec += 1;
                ip++;
                op++;
            }
        }
        nonrec += (ideg - ip) + (odeg - op);
    }

    igraph_vector_destroy(&inneis);
    igraph_vector_destroy(&outneis);
    IGRAPH_FINALLY_CLEAN(2);

    *mut = rec / 2;
    *asym = nonrec / 2;
    if (vc % 2) {
        *null = vc * ((vc - 1) / 2);
    } else {
        *null = (vc / 2) * (vc - 1);
    }
    if (*null < vc && vc > 2) {
        IGRAPH_WARNING("Integer overflow, returning -1.");
        *null = -1;
    } else {
        *null = *null - (*mut) - (*asym);
    }

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_triad_census_24
 * TODO
 */

int igraph_triad_census_24(const igraph_t *graph, igraph_real_t *res2,
                           igraph_real_t *res4) {

    long int vc = igraph_vcount(graph);
    igraph_vector_long_t seen;
    igraph_vector_int_t *neis, *neis2;
    long int i, j, k, s, neilen, neilen2, ign;
    igraph_adjlist_t adjlist;

    IGRAPH_CHECK(igraph_vector_long_init(&seen, vc));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &seen);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
    *res2 = *res4 = 0;

    for (i = 0; i < vc; i++) {
        IGRAPH_ALLOW_INTERRUPTION();

        neis = igraph_adjlist_get(&adjlist, i);
        neilen = igraph_vector_int_size(neis);
        /* mark neighbors of i & i itself */
        VECTOR(seen)[i] = i + 1;
        ign = 0;
        for (j = 0; j < neilen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            if (VECTOR(seen)[nei] == i + 1 || VECTOR(seen)[nei] == -(i + 1)) {
                /* multiple edges or loop edge */
                VECTOR(seen)[nei] = -(i + 1);
                ign++;
            } else {
                VECTOR(seen)[nei] = i + 1;
            }
        }

        for (j = 0; j < neilen; j++) {
            long int nei = (long int) VECTOR(*neis)[j];
            if (nei <= i || (j > 0 && nei == VECTOR(*neis)[j - 1])) {
                continue;
            }
            neis2 = igraph_adjlist_get(&adjlist, nei);
            neilen2 = igraph_vector_int_size(neis2);
            s = 0;
            for (k = 0; k < neilen2; k++) {
                long int nei2 = (long int) VECTOR(*neis2)[k];
                if (k > 0 && nei2 == VECTOR(*neis2)[k - 1]) {
                    continue;
                }
                if (VECTOR(seen)[nei2] != i + 1 && VECTOR(seen)[nei2] != -(i + 1)) {
                    s++;
                }
            }
            if (VECTOR(seen)[nei] > 0) {
                *res2 += vc - s - neilen + ign - 1;
            } else {
                *res4 += vc - s - neilen + ign - 1;
            }
        }
    }

    igraph_adjlist_destroy(&adjlist);
    igraph_vector_long_destroy(&seen);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_triad_census
 * \brief Triad census, as defined by Davis and Leinhardt
 *
 * 
 * Calculating the triad census means classifying every triple of
 * vertices in a directed graph. A triple can be in one of 16 states:
 * \clist
 * \cli 003
 *      A, B, C, the empty graph.
 * \cli 012
 *      A->B, C, a graph with a single directed edge.
 * \cli 102
 *      A<->B, C, a graph with a mutual connection between two vertices.
 * \cli 021D
 *      A<-B->C, the binary out-tree.
 * \cli 021U
 *      A->B<-C, the binary in-tree.
 * \cli 021C
 *      A->B->C, the directed line.
 * \cli 111D
 *      A<->B<-C.
 * \cli 111U
 *      A<->B->C.
 * \cli 030T
 *      A->B<-C, A->C.
 * \cli 030C
 *      A<-B<-C, A->C.
 * \cli 201
 *      A<->B<->C.
 * \cli 120D
 *      A<-B->C, A<->C.
 * \cli 120U
 *      A->B<-C, A<->C.
 * \cli 120C
 *      A->B->C, A<->C.
 * \cli 210
 *      A->B<->C, A<->C.
 * \cli 300
 *      A<->B<->C, A<->C, the complete graph.
 * \endclist
 *
 * 
 * See also Davis, J.A. and Leinhardt, S.  (1972).  The Structure of
 * Positive Interpersonal Relations in Small Groups.  In J. Berger
 * (Ed.), Sociological Theories in Progress, Volume 2, 218-251.
 * Boston: Houghton Mifflin.
 *
 * 
 * This function calls \ref igraph_motifs_randesu() which is an
 * implementation of the FANMOD motif finder tool, see \ref
 * igraph_motifs_randesu() for details. Note that the order of the
 * triads is not the same for \ref igraph_triad_census() and \ref
 * igraph_motifs_randesu().
 *
 * \param graph The input graph. A warning is given for undirected
 *   graphs, as the result is undefined for those.
 * \param res Pointer to an initialized vector, the result is stored
 *   here in the same order as given in the list above. Note that this
 *   order is different than the one used by \ref igraph_motifs_randesu().
 * \return Error code.
 *
 * \sa \ref igraph_motifs_randesu(), \ref igraph_dyad_census().
 *
 * Time complexity: TODO.
 */

int igraph_triad_census(const igraph_t *graph, igraph_vector_t *res) {

    igraph_vector_t cut_prob;
    igraph_real_t m2, m4;
    igraph_vector_t tmp;
    igraph_integer_t vc = igraph_vcount(graph);
    igraph_real_t total;

    if (!igraph_is_directed(graph)) {
        IGRAPH_WARNING("Triad census called on an undirected graph");
    }

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&cut_prob, 3); /* all zeros */
    IGRAPH_CHECK(igraph_vector_resize(res, 16));
    igraph_vector_null(res);
    IGRAPH_CHECK(igraph_motifs_randesu(graph, &tmp, 3, &cut_prob));
    IGRAPH_CHECK(igraph_triad_census_24(graph, &m2, &m4));

    total = ((igraph_real_t)vc) * (vc - 1);
    total *= (vc - 2);
    total /= 6;

    /* Reorder */
    if (igraph_is_directed(graph)) {
        VECTOR(tmp)[0] = 0;
        VECTOR(tmp)[1] = m2;
        VECTOR(tmp)[3] = m4;
        VECTOR(tmp)[0] = total - igraph_vector_sum(&tmp);

        VECTOR(*res)[0] = VECTOR(tmp)[0];
        VECTOR(*res)[1] = VECTOR(tmp)[1];
        VECTOR(*res)[2] = VECTOR(tmp)[3];
        VECTOR(*res)[3] = VECTOR(tmp)[6];
        VECTOR(*res)[4] = VECTOR(tmp)[2];
        VECTOR(*res)[5] = VECTOR(tmp)[4];
        VECTOR(*res)[6] = VECTOR(tmp)[5];
        VECTOR(*res)[7] = VECTOR(tmp)[9];
        VECTOR(*res)[8] = VECTOR(tmp)[7];
        VECTOR(*res)[9] = VECTOR(tmp)[11];
        VECTOR(*res)[10] = VECTOR(tmp)[10];
        VECTOR(*res)[11] = VECTOR(tmp)[8];
        VECTOR(*res)[12] = VECTOR(tmp)[13];
        VECTOR(*res)[13] = VECTOR(tmp)[12];
        VECTOR(*res)[14] = VECTOR(tmp)[14];
        VECTOR(*res)[15] = VECTOR(tmp)[15];
    } else {
        VECTOR(tmp)[0] = 0;
        VECTOR(tmp)[1] = m2;
        VECTOR(tmp)[0] = total - igraph_vector_sum(&tmp);

        VECTOR(*res)[0] = VECTOR(tmp)[0];
        VECTOR(*res)[2] = VECTOR(tmp)[1];
        VECTOR(*res)[10] = VECTOR(tmp)[2];
        VECTOR(*res)[15] = VECTOR(tmp)[3];
    }

    igraph_vector_destroy(&cut_prob);
    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/other.c0000644000175100001710000004043100000000000022663 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_nongraph.h"
#include "igraph_random.h"
#include "igraph_types.h"

#include "core/interruption.h"
#include "plfit/plfit_error.h"
#include "plfit/plfit.h"

#include 

/**
 * \ingroup nongraph
 * \function igraph_running_mean
 * \brief Calculates the running mean of a vector.
 *
 * 
 * The running mean is defined by the mean of the
 * previous \p binwidth values.
 * \param data The vector containing the data.
 * \param res The vector containing the result. This should be
 *        initialized before calling this function and will be
 *        resized.
 * \param binwidth Integer giving the width of the bin for the running
 *        mean calculation.
 * \return Error code.
 *
 * Time complexity: O(n),
 * n is the length of
 * the data vector.
 */

int igraph_running_mean(const igraph_vector_t *data, igraph_vector_t *res,
                        igraph_integer_t binwidth) {

    double sum = 0;
    long int i;

    /* Check */
    if (igraph_vector_size(data) < binwidth) {
        IGRAPH_ERRORF("Data vector length (%ld) smaller than bin width (%" IGRAPH_PRId ").", IGRAPH_EINVAL, igraph_vector_size(data), binwidth);
    }
    if (binwidth < 1) {
        IGRAPH_ERRORF("Bin width for running mean should be at least 1, got %" IGRAPH_PRId ".", IGRAPH_EINVAL, binwidth);
    }

    /* Memory for result */

    IGRAPH_CHECK(igraph_vector_resize(res, (long int)(igraph_vector_size(data) - binwidth + 1)));

    /* Initial bin */
    for (i = 0; i < binwidth; i++) {
        sum += VECTOR(*data)[i];
    }

    VECTOR(*res)[0] = sum / binwidth;

    for (i = 1; i < igraph_vector_size(data) - binwidth + 1; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        sum -= VECTOR(*data)[i - 1];
        sum += VECTOR(*data)[ (long int)(i + binwidth - 1)];
        VECTOR(*res)[i] = sum / binwidth;
    }

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup nongraph
 * \function igraph_convex_hull
 * \brief Determines the convex hull of a given set of points in the 2D plane
 *
 * 
 * The convex hull is determined by the Graham scan algorithm.
 * See the following reference for details:
 *
 * 
 * Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford
 * Stein. Introduction to Algorithms, Second Edition. MIT Press and
 * McGraw-Hill, 2001. ISBN 0262032937. Pages 949-955 of section 33.3:
 * Finding the convex hull.
 *
 * \param data vector containing the coordinates. The length of the
 *        vector must be even, since it contains X-Y coordinate pairs.
 * \param resverts the vector containing the result, e.g. the vector of
 *        vertex indices used as the corners of the convex hull. Supply
 *        \c NULL here if you are only interested in the coordinates of
 *        the convex hull corners.
 * \param rescoords the matrix containing the coordinates of the selected
 *        corner vertices. Supply \c NULL here if you are only interested in
 *        the vertex indices.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: not enough memory
 *
 * Time complexity: O(n log(n)) where n is the number of vertices
 *
 * \example examples/simple/igraph_convex_hull.c
 */
int igraph_convex_hull(const igraph_matrix_t *data, igraph_vector_t *resverts,
                       igraph_matrix_t *rescoords) {
    igraph_integer_t no_of_nodes;
    long int i, pivot_idx = 0, last_idx, before_last_idx, next_idx, j;
    igraph_vector_t angles, stack, order;
    igraph_real_t px, py, cp;

    no_of_nodes = (igraph_integer_t) igraph_matrix_nrow(data);
    if (igraph_matrix_ncol(data) != 2) {
        IGRAPH_ERROR("matrix must have 2 columns", IGRAPH_EINVAL);
    }
    if (no_of_nodes == 0) {
        if (resverts != 0) {
            IGRAPH_CHECK(igraph_vector_resize(resverts, 0));
        }
        if (rescoords != 0) {
            IGRAPH_CHECK(igraph_matrix_resize(rescoords, 0, 2));
        }
        /**************************** this is an exit here *********/
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&angles, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&stack, 0);

    /* Search for the pivot vertex */
    for (i = 1; i < no_of_nodes; i++) {
        if (MATRIX(*data, i, 1) < MATRIX(*data, pivot_idx, 1)) {
            pivot_idx = i;
        } else if (MATRIX(*data, i, 1) == MATRIX(*data, pivot_idx, 1) &&
                   MATRIX(*data, i, 0) < MATRIX(*data, pivot_idx, 0)) {
            pivot_idx = i;
        }
    }
    px = MATRIX(*data, pivot_idx, 0);
    py = MATRIX(*data, pivot_idx, 1);

    /* Create angle array */
    for (i = 0; i < no_of_nodes; i++) {
        if (i == pivot_idx) {
            /* We can't calculate the angle of the pivot point with itself,
             * so we use 10 here. This way, after sorting the angle vector,
             * the pivot point will always be the first one, since the range
             * of atan2 is -3.14..3.14 */
            VECTOR(angles)[i] = 10;
        } else {
            VECTOR(angles)[i] = atan2(MATRIX(*data, i, 1) - py, MATRIX(*data, i, 0) - px);
        }
    }

    /* Sort points by angles */
    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_qsort_ind(&angles, &order, 0));

    /* Check if two points have the same angle. If so, keep only the point that
     * is farthest from the pivot */
    j = 0;
    last_idx = (long int) VECTOR(order)[0];
    pivot_idx = (long int) VECTOR(order)[no_of_nodes - 1];
    for (i = 1; i < no_of_nodes; i++) {
        next_idx = (long int) VECTOR(order)[i];
        if (VECTOR(angles)[last_idx] == VECTOR(angles)[next_idx]) {
            /* Keep the vertex that is farther from the pivot, drop the one that is
             * closer */
            px = pow(MATRIX(*data, last_idx, 0) - MATRIX(*data, pivot_idx, 0), 2) +
                 pow(MATRIX(*data, last_idx, 1) - MATRIX(*data, pivot_idx, 1), 2);
            py = pow(MATRIX(*data, next_idx, 0) - MATRIX(*data, pivot_idx, 0), 2) +
                 pow(MATRIX(*data, next_idx, 1) - MATRIX(*data, pivot_idx, 1), 2);
            if (px > py) {
                VECTOR(order)[i] = -1;
            } else {
                VECTOR(order)[j] = -1;
                last_idx = next_idx;
                j = i;
            }
        } else {
            last_idx = next_idx;
            j = i;
        }
    }

    j = 0;
    last_idx = -1;
    before_last_idx = -1;
    while (!igraph_vector_empty(&order)) {
        next_idx = (long int)VECTOR(order)[igraph_vector_size(&order) - 1];
        if (next_idx < 0) {
            /* This vertex should be skipped; was excluded in an earlier step */
            igraph_vector_pop_back(&order);
            continue;
        }
        /* Determine whether we are at a left or right turn */
        if (j < 2) {
            /* Pretend that we are turning into the right direction if we have less
             * than two items in the stack */
            cp = -1;
        } else {
            cp = (MATRIX(*data, last_idx, 0) - MATRIX(*data, before_last_idx, 0)) *
                 (MATRIX(*data, next_idx, 1) - MATRIX(*data, before_last_idx, 1)) -
                 (MATRIX(*data, next_idx, 0) - MATRIX(*data, before_last_idx, 0)) *
                 (MATRIX(*data, last_idx, 1) - MATRIX(*data, before_last_idx, 1));
        }
        /*
        printf("B L N cp: %ld, %ld, %ld, %f [", before_last_idx, last_idx, next_idx, (float)cp);
        for (int k=0; k= 2) ? (long int) VECTOR(stack)[j - 2] : -1;
        }
    }

    /* Create result vector */
    if (resverts != 0) {
        igraph_vector_clear(resverts);
        IGRAPH_CHECK(igraph_vector_append(resverts, &stack));
    }
    if (rescoords != 0) {
        igraph_matrix_select_rows(data, rescoords, &stack);
    }

    /* Free everything */
    igraph_vector_destroy(&order);
    igraph_vector_destroy(&stack);
    igraph_vector_destroy(&angles);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}


static const char* igraph_i_plfit_error_message = 0;

static void igraph_i_plfit_error_handler_store(const char *reason, const char *file,
        int line, int plfit_errno) {

    IGRAPH_UNUSED(file);
    IGRAPH_UNUSED(line);
    IGRAPH_UNUSED(plfit_errno);

    igraph_i_plfit_error_message = reason;
}

/**
 * \ingroup nongraph
 * \function igraph_power_law_fit
 * \brief Fits a power-law distribution to a vector of numbers
 *
 * This function fits a power-law distribution to a vector containing samples
 * from a distribution (that is assumed to follow a power-law of course). In
 * a power-law distribution, it is generally assumed that P(X=x) is
 * proportional to x-alpha, where x is a positive number and alpha
 * is greater than 1. In many real-world cases, the power-law behaviour kicks
 * in only above a threshold value \em xmin. The goal of this functions is to
 * determine \em alpha if \em xmin is given, or to determine \em xmin and the
 * corresponding value of \em alpha.
 *
 * 
 * The function uses the maximum likelihood principle to determine \em alpha
 * for a given \em xmin; in other words, the function will return the \em alpha
 * value for which the probability of drawing the given sample is the highest.
 * When \em xmin is not given in advance, the algorithm will attempt to find
 * the optimal \em xmin value for which the p-value of a Kolmogorov-Smirnov
 * test between the fitted distribution and the original sample is the largest.
 * The function uses the method of Clauset, Shalizi and Newman to calculate the
 * parameters of the fitted distribution. See the following reference for
 * details:
 *
 * 
 * Aaron Clauset, Cosma R .Shalizi and Mark E.J. Newman: Power-law
 * distributions in empirical data. SIAM Review 51(4):661-703, 2009.
 *
 * \param data vector containing the samples for which a power-law distribution
 *             is to be fitted. Note that you have to provide the \em samples,
 *             not the probability density function or the cumulative
 *             distribution function. For example, if you wish to fit
 *             a power-law to the degrees of a graph, you can use the output of
 *             \ref igraph_degree directly as an input argument to
 *             \ref igraph_power_law_fit
 * \param result the result of the fitting algorithm. See \ref igraph_plfit_result_t
 *             for more details.
 * \param xmin the minimum value in the sample vector where the power-law
 *             behaviour is expected to kick in. Samples smaller than \c xmin
 *             will be ignored by the algorithm. Pass zero here if you want to
 *             include all the samples. If \c xmin is negative, the algorithm
 *             will attempt to determine its best value automatically.
 * \param force_continuous assume that the samples in the \c data argument come
 *             from a continuous distribution even if the sample vector
 *             contains integer values only (by chance). If this argument is
 *             false, igraph will assume a continuous distribution if at least
 *             one sample is non-integer and assume a discrete distribution
 *             otherwise.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: not enough memory
 *         \c IGRAPH_EINVAL: one of the arguments is invalid
 *         \c IGRAPH_EOVERFLOW: overflow during the fitting process
 *         \c IGRAPH_EUNDERFLOW: underflow during the fitting process
 *         \c IGRAPH_FAILURE: the underlying algorithm signaled a failure
 *         without returning a more specific error code
 *
 * Time complexity: in the continuous case, O(n log(n)) if \c xmin is given.
 * In the discrete case, the time complexity is dominated by the complexity of
 * the underlying L-BFGS algorithm that is used to optimize alpha. If \c xmin
 * is not given, the time complexity is multiplied by the number of unique
 * samples in the input vector (although it should be faster in practice).
 *
 * \example examples/simple/igraph_power_law_fit.c
 */
int igraph_power_law_fit(const igraph_vector_t* data, igraph_plfit_result_t* result,
                         igraph_real_t xmin, igraph_bool_t force_continuous) {
    plfit_error_handler_t* plfit_stored_error_handler;
    plfit_result_t plfit_result;
    plfit_continuous_options_t cont_options;
    plfit_discrete_options_t disc_options;
    igraph_bool_t discrete = force_continuous ? 0 : 1;
    igraph_bool_t finite_size_correction;
    int retval;
    size_t i, n;

    n = (size_t) igraph_vector_size(data);
    finite_size_correction = (n < 50);

    if (discrete) {
        /* Does the vector contain discrete values only? */
        for (i = 0; i < n; i++) {
            if ((long int)(VECTOR(*data)[i]) != VECTOR(*data)[i]) {
                discrete = 0;
                break;
            }
        }
    }

    RNG_BEGIN();

    plfit_stored_error_handler = plfit_set_error_handler(igraph_i_plfit_error_handler_store);
    if (discrete) {
        plfit_discrete_options_init(&disc_options);
        /* TODO: approximation method should be switched to PLFIT_P_VALUE_EXACT in igraph 0.9 */
        disc_options.p_value_method = PLFIT_P_VALUE_APPROXIMATE;
        disc_options.finite_size_correction = (plfit_bool_t) finite_size_correction;

        if (xmin >= 0) {
            retval = plfit_estimate_alpha_discrete(VECTOR(*data), n, xmin,
                                                   &disc_options, &plfit_result);
        } else {
            retval = plfit_discrete(VECTOR(*data), n, &disc_options, &plfit_result);
        }
    } else {
        plfit_continuous_options_init(&cont_options);
        /* TODO: approximation method should be switched to PLFIT_P_VALUE_EXACT in igraph 0.9 */
        cont_options.p_value_method = PLFIT_P_VALUE_APPROXIMATE;
        /* TODO: xmin method should be switched to PLFIT_STRATIFIED_SAMPLING in igraph 0.9 */
        cont_options.xmin_method = PLFIT_GSS_OR_LINEAR;
        cont_options.finite_size_correction = (plfit_bool_t) finite_size_correction;

        if (xmin >= 0) {
            retval = plfit_estimate_alpha_continuous(VECTOR(*data), n, xmin,
                     &cont_options, &plfit_result);
        } else {
            retval = plfit_continuous(VECTOR(*data), n, &cont_options, &plfit_result);
        }
    }
    plfit_set_error_handler(plfit_stored_error_handler);

    RNG_END();

    switch (retval) {
    case PLFIT_FAILURE:
        IGRAPH_ERROR(igraph_i_plfit_error_message, IGRAPH_FAILURE);
        break;

    case PLFIT_EINVAL:
        IGRAPH_ERROR(igraph_i_plfit_error_message, IGRAPH_EINVAL);
        break;

    case PLFIT_UNDRFLOW:
        IGRAPH_ERROR(igraph_i_plfit_error_message, IGRAPH_EUNDERFLOW);
        break;

    case PLFIT_OVERFLOW:
        IGRAPH_ERROR(igraph_i_plfit_error_message, IGRAPH_EOVERFLOW);
        break;

    case PLFIT_ENOMEM:
        IGRAPH_ERROR(igraph_i_plfit_error_message, IGRAPH_ENOMEM);
        break;

    default:
        break;
    }

    if (result) {
        result->continuous = !discrete;
        result->alpha = plfit_result.alpha;
        result->xmin = plfit_result.xmin;
        result->L = plfit_result.L;
        result->D = plfit_result.D;
        result->p = plfit_result.p;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/scan.c0000644000175100001710000007574000000000000022501 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_scan.h"

#include "igraph_adjlist.h"
#include "igraph_arpack.h"
#include "igraph_centrality.h"
#include "igraph_dqueue.h"
#include "igraph_eigen.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_stack.h"
#include "igraph_structural.h"

#include "core/interruption.h"
#include "properties/properties_internal.h"

/**
 * \section about_local_scan
 *
 * 
 * The scan statistic is a summary of the locality statistics that is computed
 * from the local neighborhood of each vertex. For details, see
 * Priebe, C. E., Conroy, J. M., Marchette, D. J., Park, Y. (2005).
 * Scan Statistics on Enron Graphs. Computational and Mathematical Organization Theory.
 * 
 */

/**
 * \function igraph_local_scan_0
 * Local scan-statistics, k=0
 *
 * K=0 scan-statistics is arbitrarily defined as the vertex degree for
 * unweighted, and the vertex strength for weighted graphs. See \ref
 * igraph_degree() and \ref igraph_strength().
 *
 * \param graph The input graph
 * \param res An initialized vector, the results are stored here.
 * \param weights Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 */

int igraph_local_scan_0(const igraph_t *graph, igraph_vector_t *res,
                        const igraph_vector_t *weights,
                        igraph_neimode_t mode) {
    if (weights) {
        igraph_strength(graph, res, igraph_vss_all(), mode, /*loops=*/ 1,
                        weights);
    } else {
        igraph_degree(graph, res, igraph_vss_all(), mode, /*loops=*/ 1);
    }
    return 0;
}

/* This removes loop, multiple edges and edges that point
   "backwards" according to the rank vector. It works on
   edge lists */

static int igraph_i_trans4_il_simplify(const igraph_t *graph, igraph_inclist_t *il,
                                       const igraph_vector_int_t *rank) {

    long int i;
    long int n = il->length;
    igraph_vector_int_t mark;
    igraph_vector_int_init(&mark, n);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &mark);

    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &il->incs[i];
        int j, l = igraph_vector_int_size(v);
        int irank = VECTOR(*rank)[i];
        VECTOR(mark)[i] = i + 1;
        for (j = 0; j < l; /* nothing */) {
            long int edge = (long int) VECTOR(*v)[j];
            long int e = IGRAPH_OTHER(graph, edge, i);
            if (VECTOR(*rank)[e] > irank && VECTOR(mark)[e] != i + 1) {
                VECTOR(mark)[e] = i + 1;
                j++;
            } else {
                VECTOR(*v)[j] = igraph_vector_int_tail(v);
                igraph_vector_int_pop_back(v);
                l--;
            }
        }
    }

    igraph_vector_int_destroy(&mark);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;

}

/* This one handles both weighted and unweighted cases */

static int igraph_i_local_scan_1_directed(const igraph_t *graph,
                                          igraph_vector_t *res,
                                          const igraph_vector_t *weights,
                                          igraph_neimode_t mode) {

    int no_of_nodes = igraph_vcount(graph);
    igraph_inclist_t incs;
    int i, node;

    igraph_vector_int_t neis;

    IGRAPH_CHECK(igraph_inclist_init(graph, &incs, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs);

    igraph_vector_int_init(&neis, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);

    igraph_vector_resize(res, no_of_nodes);
    igraph_vector_null(res);

    for (node = 0; node < no_of_nodes; node++) {
        igraph_vector_int_t *edges1 = igraph_inclist_get(&incs, node);
        int edgeslen1 = igraph_vector_int_size(edges1);

        IGRAPH_ALLOW_INTERRUPTION();

        /* Mark neighbors and self*/
        VECTOR(neis)[node] = node + 1;
        for (i = 0; i < edgeslen1; i++) {
            int e = VECTOR(*edges1)[i];
            int nei = IGRAPH_OTHER(graph, e, node);
            igraph_real_t w = weights ? VECTOR(*weights)[e] : 1;
            VECTOR(neis)[nei] = node + 1;
            VECTOR(*res)[node] += w;
        }

        /* Crawl neighbors */
        for (i = 0; i < edgeslen1; i++) {
            int e2 = VECTOR(*edges1)[i];
            int nei = IGRAPH_OTHER(graph, e2, node);
            if (nei == node) {
                break;
            }
            igraph_vector_int_t *edges2 = igraph_inclist_get(&incs, nei);
            int j, edgeslen2 = igraph_vector_int_size(edges2);
            for (j = 0; j < edgeslen2; j++) {
                int e2 = VECTOR(*edges2)[j];
                int nei2 = IGRAPH_OTHER(graph, e2, nei);
                igraph_real_t w2 = weights ? VECTOR(*weights)[e2] : 1;
                if (VECTOR(neis)[nei2] == node + 1) {
                    VECTOR(*res)[node] += w2;
                }
            }
        }

    } /* node < no_of_nodes */

    igraph_vector_int_destroy(&neis);
    igraph_inclist_destroy(&incs);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_local_scan_1_directed_all(const igraph_t *graph,
                                              igraph_vector_t *res,
                                              const igraph_vector_t *weights) {

    int no_of_nodes = igraph_vcount(graph);
    igraph_inclist_t incs;
    int i, node;

    igraph_vector_int_t neis;

    IGRAPH_CHECK(igraph_inclist_init(graph, &incs, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs);

    igraph_vector_int_init(&neis, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);

    igraph_vector_resize(res, no_of_nodes);
    igraph_vector_null(res);

    for (node = 0; node < no_of_nodes; node++) {
        igraph_vector_int_t *edges1 = igraph_inclist_get(&incs, node);
        int edgeslen1 = igraph_vector_int_size(edges1);

        IGRAPH_ALLOW_INTERRUPTION();

        /* Mark neighbors. We also count the edges that are incident to ego.
           Note that this time we do not mark ego, because we don't want to
           double count its incident edges later, when we are going over the
           incident edges of ego's neighbors. */
        for (i = 0; i < edgeslen1; i++) {
            int e = VECTOR(*edges1)[i];
            int nei = IGRAPH_OTHER(graph, e, node);
            igraph_real_t w = weights ? VECTOR(*weights)[e] : 1;
            VECTOR(neis)[nei] = node + 1;
            VECTOR(*res)[node] += w;
        }

        /* Crawl neighbors. We make sure that each neighbor of 'node' is
           only crawed once. We count all qualifying edges of ego, and
           then unmark ego to avoid double counting. */
        for (i = 0; i < edgeslen1; i++) {
            int e2 = VECTOR(*edges1)[i];
            int nei = IGRAPH_OTHER(graph, e2, node);
            igraph_vector_int_t *edges2;
            int j, edgeslen2;
            if (VECTOR(neis)[nei] != node + 1) {
                continue;
            }
            edges2 = igraph_inclist_get(&incs, nei);
            edgeslen2 = igraph_vector_int_size(edges2);
            for (j = 0; j < edgeslen2; j++) {
                int e2 = VECTOR(*edges2)[j];
                int nei2 = IGRAPH_OTHER(graph, e2, nei);
                igraph_real_t w2 = weights ? VECTOR(*weights)[e2] : 1;
                if (VECTOR(neis)[nei2] == node + 1) {
                    VECTOR(*res)[node] += w2;
                }
            }
            VECTOR(neis)[nei] = 0;
        }

    } /* node < no_of_nodes */

    igraph_vector_int_destroy(&neis);
    igraph_inclist_destroy(&incs);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

static int igraph_i_local_scan_1_sumweights(const igraph_t *graph,
                                            igraph_vector_t *res,
                                            const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int node, i, j, nn;
    igraph_inclist_t allinc;
    igraph_vector_int_t *neis1, *neis2;
    long int neilen1, neilen2;
    long int *neis;
    long int maxdegree;

    igraph_vector_int_t order;
    igraph_vector_int_t rank;
    igraph_vector_t degree, *edge1 = °ree; /* reuse degree as edge1 */

    if (igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    igraph_vector_int_init(&order, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &order);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL,
                               IGRAPH_LOOPS));
    maxdegree = (long int) igraph_vector_max(°ree) + 1;
    igraph_vector_order1_int(°ree, &order, maxdegree);
    igraph_vector_int_init(&rank, no_of_nodes);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &rank);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(rank)[ VECTOR(order)[i] ] = no_of_nodes - i - 1;
    }

    IGRAPH_CHECK(igraph_inclist_init(graph, &allinc, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &allinc);
    IGRAPH_CHECK(igraph_i_trans4_il_simplify(graph, &allinc, &rank));

    neis = IGRAPH_CALLOC(no_of_nodes, long int);
    if (neis == 0) {
        IGRAPH_ERROR("undirected local transitivity failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, neis);

    IGRAPH_CHECK(igraph_strength(graph, res, igraph_vss_all(), IGRAPH_ALL,
                                 IGRAPH_LOOPS, weights));

    for (nn = no_of_nodes - 1; nn >= 0; nn--) {
        node = VECTOR(order)[nn];

        IGRAPH_ALLOW_INTERRUPTION();

        neis1 = igraph_inclist_get(&allinc, node);
        neilen1 = igraph_vector_int_size(neis1);

        /* Mark the neighbors of the node */
        for (i = 0; i < neilen1; i++) {
            int edge = VECTOR(*neis1)[i];
            int nei = IGRAPH_OTHER(graph, edge, node);
            VECTOR(*edge1)[nei] = VECTOR(*weights)[edge];
            neis[nei] = node + 1;
        }

        for (i = 0; i < neilen1; i++) {
            long int edge = VECTOR(*neis1)[i];
            long int nei = IGRAPH_OTHER(graph, edge, node);
            igraph_real_t w = VECTOR(*weights)[edge];
            neis2 = igraph_inclist_get(&allinc, nei);
            neilen2 = igraph_vector_int_size(neis2);
            for (j = 0; j < neilen2; j++) {
                long int edge2 = VECTOR(*neis2)[j];
                long int nei2 = IGRAPH_OTHER(graph, edge2, nei);
                igraph_real_t w2 = VECTOR(*weights)[edge2];
                if (neis[nei2] == node + 1) {
                    VECTOR(*res)[node] += w2;
                    VECTOR(*res)[nei2] += w;
                    VECTOR(*res)[nei] += VECTOR(*edge1)[nei2];
                }
            }
        }
    }

    igraph_free(neis);
    igraph_inclist_destroy(&allinc);
    igraph_vector_int_destroy(&rank);
    igraph_vector_destroy(°ree);
    igraph_vector_int_destroy(&order);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \function igraph_local_scan_1_ecount
 * Local scan-statistics, k=1, edge count and sum of weights
 *
 * Count the number of edges or the sum the edge weights in the
 * 1-neighborhood of vertices.
 *
 * \param graph The input graph
 * \param res An initialized vector, the results are stored here.
 * \param weights Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 */

int igraph_local_scan_1_ecount(const igraph_t *graph, igraph_vector_t *res,
                               const igraph_vector_t *weights,
                               igraph_neimode_t mode) {

    if (igraph_is_directed(graph)) {
        if (mode != IGRAPH_ALL) {
            return igraph_i_local_scan_1_directed(graph, res, weights, mode);
        } else {
            return igraph_i_local_scan_1_directed_all(graph, res, weights);
        }
    } else {
        if (weights) {
            return igraph_i_local_scan_1_sumweights(graph, res, weights);
        } else {
            return igraph_local_scan_k_ecount(graph, 1, res, weights, mode);
        }
    }

    return 0;
}

static int igraph_i_local_scan_0_them_w(const igraph_t *us, const igraph_t *them,
                                        igraph_vector_t *res,
                                        const igraph_vector_t *weights_them,
                                        igraph_neimode_t mode) {

    igraph_t is;
    igraph_vector_t map2;
    int i, m;

    if (!weights_them) {
        IGRAPH_ERROR("Edge weights not given for weighted scan-0",
                     IGRAPH_EINVAL);
    }
    if (igraph_vector_size(weights_them) != igraph_ecount(them)) {
        IGRAPH_ERROR("Invalid weights length for scan-0", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&map2, 0);
    igraph_intersection(&is, us, them, /*map1=*/ 0, &map2);
    IGRAPH_FINALLY(igraph_destroy, &is);

    /* Rewrite the map as edge weights */
    m = igraph_vector_size(&map2);
    for (i = 0; i < m; i++) {
        VECTOR(map2)[i] = VECTOR(*weights_them)[ (int) VECTOR(map2)[i] ];
    }

    igraph_strength(&is, res, igraph_vss_all(), mode, IGRAPH_LOOPS,
                    /*weights=*/ &map2);

    igraph_destroy(&is);
    igraph_vector_destroy(&map2);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_local_scan_0_them
 * Local THEM scan-statistics, k=0
 *
 * K=0 scan-statistics is arbitrarily defined as the vertex degree for
 * unweighted, and the vertex strength for weighted graphs. See \ref
 * igraph_degree() and \ref igraph_strength().
 *
 * \param us The input graph, to use to extract the neighborhoods.
 * \param them The input graph to use for the actually counting.
 * \param res An initialized vector, the results are stored here.
 * \param weights_them Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 */

int igraph_local_scan_0_them(const igraph_t *us, const igraph_t *them,
                             igraph_vector_t *res,
                             const igraph_vector_t *weights_them,
                             igraph_neimode_t mode) {

    igraph_t is;

    if (igraph_vcount(us) != igraph_vcount(them)) {
        IGRAPH_ERROR("Number of vertices don't match in scan-0", IGRAPH_EINVAL);
    }
    if (igraph_is_directed(us) != igraph_is_directed(them)) {
        IGRAPH_ERROR("Directedness don't match in scan-0", IGRAPH_EINVAL);
    }

    if (weights_them) {
        return igraph_i_local_scan_0_them_w(us, them, res, weights_them, mode);
    }

    igraph_intersection(&is, us, them, /*edgemap1=*/ 0, /*edgemap2=*/ 0);
    IGRAPH_FINALLY(igraph_destroy, &is);

    igraph_degree(&is, res, igraph_vss_all(), mode, IGRAPH_LOOPS);

    igraph_destroy(&is);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_local_scan_1_ecount_them
 * Local THEM scan-statistics, k=1, edge count and sum of weights
 *
 * Count the number of edges or the sum the edge weights in the
 * 1-neighborhood of vertices.
 *
 * \param us The input graph to extract the neighborhoods.
 * \param them The input graph to perform the counting.
 * \param weights_them Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 * \sa \ref igraph_local_scan_1_ecount() for the US statistics.
 */

int igraph_local_scan_1_ecount_them(const igraph_t *us, const igraph_t *them,
                                    igraph_vector_t *res,
                                    const igraph_vector_t *weights_them,
                                    igraph_neimode_t mode) {

    int no_of_nodes = igraph_vcount(us);
    igraph_adjlist_t adj_us;
    igraph_inclist_t incs_them;
    igraph_vector_int_t neis;
    int node;

    if (igraph_vcount(them) != no_of_nodes) {
        IGRAPH_ERROR("Number of vertices must match in scan-1", IGRAPH_EINVAL);
    }
    if (igraph_is_directed(us) != igraph_is_directed(them)) {
        IGRAPH_ERROR("Directedness must match in scan-1", IGRAPH_EINVAL);
    }
    if (weights_them &&
        igraph_vector_size(weights_them) != igraph_ecount(them)) {
        IGRAPH_ERROR("Invalid weight vector length in scan-1 (them)",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_adjlist_init(
        us, &adj_us, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE
    ));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adj_us);
    IGRAPH_CHECK(igraph_inclist_init(them, &incs_them, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs_them);

    IGRAPH_CHECK(igraph_vector_int_init(&neis, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);

    for (node = 0; node < no_of_nodes; node++) {
        igraph_vector_int_t *neis_us = igraph_adjlist_get(&adj_us, node);
        igraph_vector_int_t *edges1_them = igraph_inclist_get(&incs_them, node);
        int len1_us = igraph_vector_int_size(neis_us);
        int len1_them = igraph_vector_int_size(edges1_them);
        int i;

        IGRAPH_ALLOW_INTERRUPTION();

        /* Mark neighbors and self in us */
        VECTOR(neis)[node] = node + 1;
        for (i = 0; i < len1_us; i++) {
            int nei = VECTOR(*neis_us)[i];
            VECTOR(neis)[nei] = node + 1;
        }

        /* Crawl neighbors in them, first ego */
        for (i = 0; i < len1_them; i++) {
            int e = VECTOR(*edges1_them)[i];
            int nei = IGRAPH_OTHER(them, e, node);
            if (VECTOR(neis)[nei] == node + 1) {
                igraph_real_t w = weights_them ? VECTOR(*weights_them)[e] : 1;
                VECTOR(*res)[node] += w;
            }
        }
        /* Then the rest */
        for (i = 0; i < len1_us; i++) {
            int nei = VECTOR(*neis_us)[i];
            igraph_vector_int_t *edges2_them = igraph_inclist_get(&incs_them, nei);
            int j, len2_them = igraph_vector_int_size(edges2_them);
            for (j = 0; j < len2_them; j++) {
                int e2 = VECTOR(*edges2_them)[j];
                int nei2 = IGRAPH_OTHER(them, e2, nei);
                if (VECTOR(neis)[nei2] == node + 1) {
                    igraph_real_t w = weights_them ? VECTOR(*weights_them)[e2] : 1;
                    VECTOR(*res)[node] += w;
                }
            }
        }

        /* For undirected, it was double counted */
        if (mode == IGRAPH_ALL || ! igraph_is_directed(us)) {
            VECTOR(*res)[node] /= 2.0;
        }

    } /* node < no_of_nodes */

    igraph_vector_int_destroy(&neis);
    igraph_inclist_destroy(&incs_them);
    igraph_adjlist_destroy(&adj_us);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_local_scan_k_ecount
 * \brief Sum the number of edges or the weights in k-neighborhood of every vertex.
 *
 * \param graph The input graph.
 * \param k The size of the neighborhood, non-negative integer.
 *        The k=0 case is special, see \ref igraph_local_scan_0().
 * \param res An initialized vector, the results are stored here.
 * \param weights Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 */

int igraph_local_scan_k_ecount(const igraph_t *graph, int k,
                               igraph_vector_t *res,
                               const igraph_vector_t *weights,
                               igraph_neimode_t mode) {

    int no_of_nodes = igraph_vcount(graph);
    int node;
    igraph_dqueue_int_t Q;
    igraph_vector_int_t marked;
    igraph_inclist_t incs;

    if (k < 0) {
        IGRAPH_ERROR("k must be non-negative in k-scan.", IGRAPH_EINVAL);
    }
    if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERRORF("The weight vector length (%ld) in k-scan should equal "
                      "the number of edges of the graph (%d).",
                      IGRAPH_EINVAL, igraph_vector_size(weights),
                      igraph_ecount(graph));
    }

    if (k == 0) {
        return igraph_local_scan_0(graph, res, weights, mode);
    }
    if (k == 1 && igraph_is_directed(graph)) {
        return igraph_local_scan_1_ecount(graph, res, weights, mode);
    }

    /* We do a BFS form each node, and simply count the number
       of edges on the way */

    IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q);
    IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
    IGRAPH_CHECK(igraph_inclist_init(graph, &incs, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs);

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);

    for (node = 0 ; node < no_of_nodes ; node++) {
        igraph_dqueue_int_push(&Q, node);
        igraph_dqueue_int_push(&Q, 0);
        VECTOR(marked)[node] = node + 1;
        while (!igraph_dqueue_int_empty(&Q)) {
            int act = igraph_dqueue_int_pop(&Q);
            int dist = igraph_dqueue_int_pop(&Q) + 1;
            igraph_vector_int_t *edges = igraph_inclist_get(&incs, act);
            int i, edgeslen = igraph_vector_int_size(edges);
            for (i = 0; i < edgeslen; i++) {
                int edge = VECTOR(*edges)[i];
                int nei = IGRAPH_OTHER(graph, edge, act);
                if (dist <= k || VECTOR(marked)[nei] == node + 1) {
                    igraph_real_t w = weights ? VECTOR(*weights)[edge] : 1;
                    VECTOR(*res)[node] += w;
                }
                if (dist <= k && VECTOR(marked)[nei] != node + 1) {
                    igraph_dqueue_int_push(&Q, nei);
                    igraph_dqueue_int_push(&Q, dist);
                    VECTOR(marked)[nei] = node + 1;
                }
            }
        }

        if (mode == IGRAPH_ALL || ! igraph_is_directed(graph)) {
            VECTOR(*res)[node] /= 2.0;
        }

    } /* node < no_of_nodes */

    igraph_inclist_destroy(&incs);
    igraph_vector_int_destroy(&marked);
    igraph_dqueue_int_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_local_scan_k_ecount_them
 * Local THEM scan-statistics, general function, edge count and sum of weights
 *
 * Count the number of edges or the sum the edge weights in the
 * k-neighborhood of vertices.
 *
 * \param us The input graph to extract the neighborhoods.
 * \param them The input graph to perform the counting.
 * \param k The size of the neighborhood, non-negative integer.
 *        The k=0 case is special, see \ref igraph_local_scan_0_them().
 * \param weights_them Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param mode Type of the neighborhood, \c IGRAPH_OUT means outgoing,
 *        \c IGRAPH_IN means incoming and \c IGRAPH_ALL means all edges.
 * \return Error code.
 *
 * \sa \ref igraph_local_scan_1_ecount() for the US statistics.
 */

int igraph_local_scan_k_ecount_them(const igraph_t *us, const igraph_t *them,
                                    int k, igraph_vector_t *res,
                                    const igraph_vector_t *weights_them,
                                    igraph_neimode_t mode) {

    int no_of_nodes = igraph_vcount(us);
    int node;
    igraph_dqueue_int_t Q;
    igraph_vector_int_t marked;
    igraph_stack_int_t ST;
    igraph_inclist_t incs_us, incs_them;

    if (igraph_vcount(them) != no_of_nodes) {
        IGRAPH_ERROR("Number of vertices must match in scan-k", IGRAPH_EINVAL);
    }
    if (igraph_is_directed(us) != igraph_is_directed(them)) {
        IGRAPH_ERROR("Directedness must match in scan-k", IGRAPH_EINVAL);
    }
    if (k < 0) {
        IGRAPH_ERROR("k must be non-negative in k-scan", IGRAPH_EINVAL);
    }
    if (weights_them &&
        igraph_vector_size(weights_them) != igraph_ecount(them)) {
        IGRAPH_ERROR("Invalid weight vector length in k-scan (them)",
                     IGRAPH_EINVAL);
    }

    if (k == 0) {
        return igraph_local_scan_0_them(us, them, res, weights_them, mode);
    }
    if (k == 1) {
        return igraph_local_scan_1_ecount_them(us, them, res, weights_them, mode);
    }

    /* We mark the nodes in US in a BFS. Then we check the outgoing edges
       of all marked nodes in THEM. */

    IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100));
    IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q);
    IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
    IGRAPH_CHECK(igraph_inclist_init(us, &incs_us, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs_us);
    IGRAPH_CHECK(igraph_inclist_init(them, &incs_them, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs_them);
    IGRAPH_CHECK(igraph_stack_int_init(&ST, 100));
    IGRAPH_FINALLY(igraph_stack_int_destroy, &ST);

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);

    for (node = 0; node < no_of_nodes; node++) {

        /* BFS to mark the nodes in US */
        IGRAPH_CHECK(igraph_dqueue_int_push(&Q, node));
        IGRAPH_CHECK(igraph_dqueue_int_push(&Q, 0));
        IGRAPH_CHECK(igraph_stack_int_push(&ST, node));
        VECTOR(marked)[node] = node + 1;
        while (!igraph_dqueue_int_empty(&Q)) {
            int act = igraph_dqueue_int_pop(&Q);
            int dist = igraph_dqueue_int_pop(&Q) + 1;
            igraph_vector_int_t *edges = igraph_inclist_get(&incs_us, act);
            int i, edgeslen = igraph_vector_int_size(edges);
            for (i = 0; i < edgeslen; i++) {
                int edge = VECTOR(*edges)[i];
                int nei = IGRAPH_OTHER(us, edge, act);
                if (dist <= k && VECTOR(marked)[nei] != node + 1) {
                    igraph_dqueue_int_push(&Q, nei);
                    igraph_dqueue_int_push(&Q, dist);
                    VECTOR(marked)[nei] = node + 1;
                    igraph_stack_int_push(&ST, nei);
                }
            }
        }

        /* Now check the edges of all nodes in THEM */
        while (!igraph_stack_int_empty(&ST)) {
            int act = igraph_stack_int_pop(&ST);
            igraph_vector_int_t *edges = igraph_inclist_get(&incs_them, act);
            int i, edgeslen = igraph_vector_int_size(edges);
            for (i = 0; i < edgeslen; i++) {
                int edge = VECTOR(*edges)[i];
                int nei = IGRAPH_OTHER(them, edge, act);
                if (VECTOR(marked)[nei] == node + 1) {
                    igraph_real_t w = weights_them ? VECTOR(*weights_them)[edge] : 1;
                    VECTOR(*res)[node] += w;
                }
            }
        }

        if (mode == IGRAPH_ALL || ! igraph_is_directed(us)) {
            VECTOR(*res)[node] /= 2;
        }

    } /* node < no_of_nodes */

    igraph_stack_int_destroy(&ST);
    igraph_inclist_destroy(&incs_them);
    igraph_inclist_destroy(&incs_us);
    igraph_vector_int_destroy(&marked);
    igraph_dqueue_int_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

/**
 * \function igraph_local_scan_neighborhood_ecount
 * Local scan-statistics with pre-calculated neighborhoods
 *
 * Count the number of edges, or sum the edge weigths in
 * neighborhoods given as a parameter.
 *
 * \param graph The graph to perform the counting/summing in.
 * \param res Initialized vector, the result is stored here.
 * \param weights Weight vector for weighted graphs, null pointer for
 *        unweighted graphs.
 * \param neighborhoods List of igraph_vector_int_t
 *        objects, the neighborhoods, one for each vertex in the
 *        graph.
 * \return Error code.
 */

int igraph_local_scan_neighborhood_ecount(const igraph_t *graph,
        igraph_vector_t *res,
        const igraph_vector_t *weights,
        const igraph_vector_ptr_t *neighborhoods) {

    int node, no_of_nodes = igraph_vcount(graph);
    igraph_inclist_t incs;
    igraph_vector_int_t marked;
    igraph_bool_t directed = igraph_is_directed(graph);

    if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length in local scan", IGRAPH_EINVAL);
    }
    if (igraph_vector_ptr_size(neighborhoods) != no_of_nodes) {
        IGRAPH_ERROR("Invalid neighborhood list length in local scan",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
    IGRAPH_CHECK(igraph_inclist_init(graph, &incs, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incs);

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);

    for (node = 0; node < no_of_nodes; node++) {
        igraph_vector_int_t *nei = VECTOR(*neighborhoods)[node];
        int i, neilen = igraph_vector_int_size(nei);
        VECTOR(marked)[node] = node + 1;
        for (i = 0; i < neilen; i++) {
            int vertex = VECTOR(*nei)[i];
            if (vertex < 0 || vertex >= no_of_nodes) {
                IGRAPH_ERROR("Invalid vertex id in neighborhood list in local scan",
                             IGRAPH_EINVAL);
            }
            VECTOR(marked)[vertex] = node + 1;
        }

        for (i = 0; i < neilen; i++) {
            int vertex = VECTOR(*nei)[i];
            igraph_vector_int_t *edges = igraph_inclist_get(&incs, vertex);
            int j, edgeslen = igraph_vector_int_size(edges);
            for (j = 0; j < edgeslen; j++) {
                int edge = VECTOR(*edges)[j];
                int nei2 = IGRAPH_OTHER(graph, edge, vertex);
                if (VECTOR(marked)[nei2] == node + 1) {
                    igraph_real_t w = weights ? VECTOR(*weights)[edge] : 1;
                    VECTOR(*res)[node] += w;
                }
            }
        }
        if (!directed) {
            VECTOR(*res)[node] /= 2.0;
        }
    }

    igraph_inclist_destroy(&incs);
    igraph_vector_int_destroy(&marked);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/sir.c0000644000175100001710000002234100000000000022337 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_epidemics.h"

#include "igraph_random.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_psumtree.h"
#include "igraph_memory.h"
#include "igraph_structural.h"

#include "core/interruption.h"

int igraph_sir_init(igraph_sir_t *sir) {
    IGRAPH_CHECK(igraph_vector_init(&sir->times, 1));
    IGRAPH_FINALLY(igraph_vector_destroy, &sir->times);
    IGRAPH_CHECK(igraph_vector_int_init(&sir->no_s, 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &sir->no_s);
    IGRAPH_CHECK(igraph_vector_int_init(&sir->no_i, 1));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &sir->no_i);
    IGRAPH_CHECK(igraph_vector_int_init(&sir->no_r, 1));
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

/**
 * \function igraph_sir_destroy
 * \brief Deallocates memory associated with a SIR simulation run.
 *
 * \param sir The \ref igraph_sir_t object storing the simulation.
 */

void igraph_sir_destroy(igraph_sir_t *sir) {
    igraph_vector_destroy(&sir->times);
    igraph_vector_int_destroy(&sir->no_s);
    igraph_vector_int_destroy(&sir->no_i);
    igraph_vector_int_destroy(&sir->no_r);
}

static void igraph_i_sir_destroy(igraph_vector_ptr_t *v) {
    int i, n = igraph_vector_ptr_size(v);
    for (i = 0; i < n; i++) {
        if ( VECTOR(*v)[i] ) {
            igraph_sir_destroy( VECTOR(*v)[i]) ;
            IGRAPH_FREE( VECTOR(*v)[i] ); /* this also sets the vector_ptr element to NULL */
        }
    }
}

#define S_S 0
#define S_I 1
#define S_R 2

/**
 * \function igraph_sir
 * \brief Performs a number of SIR epidemics model runs on a graph.
 *
 * The SIR model is a simple model from epidemiology. The individuals
 * of the population might be in three states: susceptible, infected
 * and recovered. Recovered people are assumed to be immune to the
 * disease. Susceptibles become infected with a rate that depends on
 * their number of infected neigbors. Infected people become recovered
 * with a constant rate. See these parameters below.
 *
 * 
 * This function runs multiple simulations, all starting with a
 * single uniformly randomly chosen infected individual. A simulation
 * is stopped when no infected individuals are left.
 *
 * \param graph The graph to perform the model on. For directed graphs
 *        edge directions are ignored and a warning is given.
 * \param beta The rate of infection of an individual that is
 *        susceptible and has a single infected neighbor.
 *        The infection rate of a susceptible individual with n
 *        infected neighbors is n times beta. Formally
 *        this is the rate parameter of an exponential distribution.
 * \param gamma The rate of recovery of an infected individual.
 *        Formally, this is the rate parameter of an exponential
 *        distribution.
 * \param no_sim The number of simulation runs to perform.
 * \param result The result of the simulation is stored here,
 *        in a list of \ref igraph_sir_t objects. To deallocate
 *        memory, the user needs to call \ref igraph_sir_destroy on
 *        each element, before destroying the pointer vector itself
 *        using \ref igraph_vector_ptr_destroy_all().
 * \return Error code.
 *
 * Time complexity: O(no_sim * (|V| + |E| log(|V|))).
 */

int igraph_sir(const igraph_t *graph, igraph_real_t beta,
               igraph_real_t gamma, igraph_integer_t no_sim,
               igraph_vector_ptr_t *result) {

    int infected;
    igraph_vector_int_t status;
    igraph_adjlist_t adjlist;
    int no_of_nodes = igraph_vcount(graph);
    int i, j, ns, ni, nr;
    igraph_vector_int_t *neis;
    igraph_psumtree_t tree;
    igraph_real_t psum;
    int neilen;
    igraph_bool_t simple;

    if (no_of_nodes == 0) {
        IGRAPH_ERROR("Cannot run SIR model on empty graph.", IGRAPH_EINVAL);
    }
    if (igraph_is_directed(graph)) {
        IGRAPH_WARNING("Edge directions are ignored in SIR model.");
    }
    if (beta < 0) {
        IGRAPH_ERROR("The infection rate beta must be non-negative in SIR model.", IGRAPH_EINVAL);
    }
    /* With a recovery rate of zero, the simulation would never stop. */
    if (gamma <= 0) {
        IGRAPH_ERROR("The recovery rate gamma must be positive in SIR model.", IGRAPH_EINVAL);
    }
    if (no_sim <= 0) {
        IGRAPH_ERROR("Number of SIR simulations must be positive.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_is_simple(graph, &simple));
    if (!simple) {
        IGRAPH_ERROR("SIR model only works with simple graphs.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_int_init(&status, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &status);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
    IGRAPH_CHECK(igraph_psumtree_init(&tree, no_of_nodes));
    IGRAPH_FINALLY(igraph_psumtree_destroy, &tree);

    IGRAPH_CHECK(igraph_vector_ptr_resize(result, no_sim));
    igraph_vector_ptr_null(result);
    IGRAPH_FINALLY(igraph_i_sir_destroy, result);
    for (i = 0; i < no_sim; i++) {
        igraph_sir_t *sir = IGRAPH_CALLOC(1, igraph_sir_t);
        if (!sir) {
            IGRAPH_ERROR("Cannot run SIR model.", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_sir_init(sir));
        VECTOR(*result)[i] = sir;
    }

    RNG_BEGIN();

    for (j = 0; j < no_sim; j++) {

        igraph_sir_t *sir = VECTOR(*result)[j];
        igraph_vector_t *times_v = &sir->times;
        igraph_vector_int_t *no_s_v = &sir->no_s;
        igraph_vector_int_t *no_i_v = &sir->no_i;
        igraph_vector_int_t *no_r_v = &sir->no_r;

        infected = RNG_INTEGER(0, no_of_nodes - 1);

        /* Initially infected */
        igraph_vector_int_null(&status);
        VECTOR(status)[infected] = S_I;
        ns = no_of_nodes - 1;
        ni = 1;
        nr = 0;

        VECTOR(*times_v)[0] = 0.0;
        VECTOR(*no_s_v)[0]  = ns;
        VECTOR(*no_i_v)[0]  = ni;
        VECTOR(*no_r_v)[0]  = nr;

        if (igraph_psumtree_sum(&tree) != 0) {
            igraph_psumtree_reset(&tree);
        }

        /* Rates */
        IGRAPH_CHECK(igraph_psumtree_update(&tree, infected, gamma));
        neis = igraph_adjlist_get(&adjlist, infected);
        neilen = igraph_vector_int_size(neis);
        for (i = 0; i < neilen; i++) {
            int nei = VECTOR(*neis)[i];
            IGRAPH_CHECK(igraph_psumtree_update(&tree, nei, beta));
        }

        while (ni > 0) {
            igraph_real_t tt;
            igraph_real_t r;
            long int vchange;

            IGRAPH_ALLOW_INTERRUPTION();

            psum = igraph_psumtree_sum(&tree);
            tt = igraph_rng_get_exp(igraph_rng_default(), psum);
            r = RNG_UNIF(0, psum);

            igraph_psumtree_search(&tree, &vchange, r);
            neis = igraph_adjlist_get(&adjlist, vchange);
            neilen = igraph_vector_int_size(neis);

            if (VECTOR(status)[vchange] == S_I) {
                VECTOR(status)[vchange] = S_R;
                ni--; nr++;
                IGRAPH_CHECK(igraph_psumtree_update(&tree, vchange, 0.0));
                for (i = 0; i < neilen; i++) {
                    int nei = VECTOR(*neis)[i];
                    if (VECTOR(status)[nei] == S_S) {
                        igraph_real_t rate = igraph_psumtree_get(&tree, nei);
                        IGRAPH_CHECK(igraph_psumtree_update(&tree, nei, rate - beta));
                    }
                }

            } else { /* S_S */
                VECTOR(status)[vchange] = S_I;
                ns--; ni++;
                IGRAPH_CHECK(igraph_psumtree_update(&tree, vchange, gamma));
                for (i = 0; i < neilen; i++) {
                    int nei = VECTOR(*neis)[i];
                    if (VECTOR(status)[nei] == S_S) {
                        igraph_real_t rate = igraph_psumtree_get(&tree, nei);
                        IGRAPH_CHECK(igraph_psumtree_update(&tree, nei, rate + beta));
                    }
                }
            }

            IGRAPH_CHECK(igraph_vector_push_back(times_v, tt + igraph_vector_tail(times_v)));
            IGRAPH_CHECK(igraph_vector_int_push_back(no_s_v, ns));
            IGRAPH_CHECK(igraph_vector_int_push_back(no_i_v, ni));
            IGRAPH_CHECK(igraph_vector_int_push_back(no_r_v, nr));

        } /* psum > 0 */

    } /* j < no_sim */

    RNG_END();

    igraph_psumtree_destroy(&tree);
    igraph_adjlist_destroy(&adjlist);
    igraph_vector_int_destroy(&status);
    IGRAPH_FINALLY_CLEAN(4);  /* + result */

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/misc/spanning_trees.c0000644000175100001710000004441000000000000024562 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011  Gabor Csardi 
   Rue de l'Industrie 5, Lausanne 1005, Switzerland

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"
#include "igraph_progress.h"
#include "igraph_random.h"
#include "igraph_structural.h"

#include "core/indheap.h"
#include "core/interruption.h"

static int igraph_i_minimum_spanning_tree_unweighted(const igraph_t *graph,
                                                     igraph_vector_t *result);
static int igraph_i_minimum_spanning_tree_prim(const igraph_t *graph,
                                               igraph_vector_t *result, const igraph_vector_t *weights);

/**
 * \ingroup structural
 * \function igraph_minimum_spanning_tree
 * \brief Calculates one minimum spanning tree of a graph.
 *
 * 
 * If the graph has more minimum spanning trees (this is always the
 * case, except if it is a forest) this implementation returns only
 * the same one.
 *
 * 
 * Directed graphs are considered as undirected for this computation.
 *
 * 
 * If the graph is not connected then its minimum spanning forest is
 * returned. This is the set of the minimum spanning trees of each
 * component.
 *
 * \param graph The graph object.
 * \param res An initialized vector, the IDs of the edges that constitute
 *        a spanning tree will be returned here. Use
 *        \ref igraph_subgraph_edges() to extract the spanning tree as
 *        a separate graph object.
 * \param weights A vector containing the weights of the edges
 *        in the same order as the simple edge iterator visits them
 *        (i.e. in increasing order of edge IDs).
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *
 * Time complexity: O(|V|+|E|) for the unweighted case, O(|E| log |V|)
 * for the weighted case. |V| is the number of vertices, |E| the
 * number of edges in the graph.
 *
 * \sa \ref igraph_minimum_spanning_tree_unweighted() and
 *     \ref igraph_minimum_spanning_tree_prim() if you only need the
 *     tree as a separate graph object.
 *
 * \example examples/simple/igraph_minimum_spanning_tree.c
 */
int igraph_minimum_spanning_tree(const igraph_t* graph,
                                 igraph_vector_t* res, const igraph_vector_t* weights) {
    if (weights == 0) {
        IGRAPH_CHECK(igraph_i_minimum_spanning_tree_unweighted(graph, res));
    } else {
        IGRAPH_CHECK(igraph_i_minimum_spanning_tree_prim(graph, res, weights));
    }
    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_minimum_spanning_tree_unweighted
 * \brief Calculates one minimum spanning tree of an unweighted graph.
 *
 * 
 * If the graph has more minimum spanning trees (this is always the
 * case, except if it is a forest) this implementation returns only
 * the same one.
 *
 * 
 * Directed graphs are considered as undirected for this computation.
 *
 * 
 * If the graph is not connected then its minimum spanning forest is
 * returned. This is the set of the minimum spanning trees of each
 * component.
 * \param graph The graph object.
 * \param mst The minimum spanning tree, another graph object. Do
 *        \em not initialize this object before passing it to
 *        this function, but be sure to call \ref igraph_destroy() on it if
 *        you don't need it any more.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *
 * Time complexity: O(|V|+|E|),
 * |V| is the
 * number of vertices, |E| the number
 * of edges in the graph.
 *
 * \sa \ref igraph_minimum_spanning_tree_prim() for weighted graphs,
 *     \ref igraph_minimum_spanning_tree() if you need the IDs of the
 *     edges that constitute the spanning tree.
 */

int igraph_minimum_spanning_tree_unweighted(const igraph_t *graph,
        igraph_t *mst) {
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, igraph_vcount(graph) - 1);
    IGRAPH_CHECK(igraph_i_minimum_spanning_tree_unweighted(graph, &edges));
    IGRAPH_CHECK(igraph_subgraph_edges(graph, mst,
                                       igraph_ess_vector(&edges), /* delete_vertices = */ 0));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_minimum_spanning_tree_prim
 * \brief Calculates one minimum spanning tree of a weighted graph.
 *
 * 
 * This function uses Prim's method for carrying out the computation,
 * see Prim, R.C.: Shortest connection networks and some
 * generalizations, Bell System Technical
 * Journal, Vol. 36,
 * 1957, 1389--1401.
 *
 * 
 * If the graph has more than one minimum spanning tree, the current
 * implementation returns always the same one.
 *
 * 
 * Directed graphs are considered as undirected for this computation.
 *
 * 
 * If the graph is not connected then its minimum spanning forest is
 * returned. This is the set of the minimum spanning trees of each
 * component.
 *
 * \param graph The graph object.
 * \param mst The result of the computation, a graph object containing
 *        the minimum spanning tree of the graph.
 *        Do \em not initialize this object before passing it to
 *        this function, but be sure to call \ref igraph_destroy() on it if
 *        you don't need it any more.
 * \param weights A vector containing the weights of the edges
 *        in the same order as the simple edge iterator visits them
 *        (i.e. in increasing order of edge IDs).
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory.
 *         \c IGRAPH_EINVAL, length of weight vector does not
 *           match number of edges.
 *
 * Time complexity: O(|E| log |V|),
 * |V| is the number of vertices,
 * |E| the number of edges in the
 * graph.
 *
 * \sa \ref igraph_minimum_spanning_tree_unweighted() for unweighted graphs,
 *     \ref igraph_minimum_spanning_tree() if you need the IDs of the
 *     edges that constitute the spanning tree.
 *
 * \example examples/simple/igraph_minimum_spanning_tree.c
 */

int igraph_minimum_spanning_tree_prim(const igraph_t *graph, igraph_t *mst,
                                      const igraph_vector_t *weights) {
    igraph_vector_t edges = IGRAPH_VECTOR_NULL;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, igraph_vcount(graph) - 1);
    IGRAPH_CHECK(igraph_i_minimum_spanning_tree_prim(graph, &edges, weights));
    IGRAPH_CHECK(igraph_subgraph_edges(graph, mst,
                                       igraph_ess_vector(&edges), /* delete_vertices = */ 0));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}


static int igraph_i_minimum_spanning_tree_unweighted(const igraph_t* graph, igraph_vector_t* res) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    char *already_added;
    char *added_edges;

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_vector_t tmp = IGRAPH_VECTOR_NULL;
    long int i, j;

    igraph_vector_clear(res);

    added_edges = IGRAPH_CALLOC(no_of_edges, char);
    if (added_edges == 0) {
        IGRAPH_ERROR("unweighted spanning tree failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added_edges);
    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("unweighted spanning tree failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    for (i = 0; i < no_of_nodes; i++) {
        if (already_added[i] > 0) {
            continue;
        }

        IGRAPH_ALLOW_INTERRUPTION();

        already_added[i] = 1;
        IGRAPH_CHECK(igraph_dqueue_push(&q, i));
        while (! igraph_dqueue_empty(&q)) {
            long int tmp_size;
            long int act_node = (long int) igraph_dqueue_pop(&q);
            IGRAPH_CHECK(igraph_incident(graph, &tmp, (igraph_integer_t) act_node,
                                         IGRAPH_ALL));
            tmp_size = igraph_vector_size(&tmp);
            for (j = 0; j < tmp_size; j++) {
                long int edge = (long int) VECTOR(tmp)[j];
                if (added_edges[edge] == 0) {
                    igraph_integer_t to = IGRAPH_OTHER(graph, edge, act_node);
                    if (already_added[(long int) to] == 0) {
                        already_added[(long int) to] = 1;
                        added_edges[edge] = 1;
                        IGRAPH_CHECK(igraph_vector_push_back(res, edge));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, to));
                    }
                }
            }
        }
    }

    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(already_added);
    igraph_vector_destroy(&tmp);
    IGRAPH_FREE(added_edges);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}

static int igraph_i_minimum_spanning_tree_prim(
        const igraph_t* graph, igraph_vector_t* res, const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    char *already_added;
    char *added_edges;

    igraph_d_indheap_t heap = IGRAPH_D_INDHEAP_NULL;
    igraph_integer_t mode = IGRAPH_ALL;

    igraph_vector_t adj;

    long int i, j;

    igraph_vector_clear(res);

    if (weights == 0) {
        return igraph_i_minimum_spanning_tree_unweighted(graph, res);
    }

    if (igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weights length", IGRAPH_EINVAL);
    }

    added_edges = IGRAPH_CALLOC(no_of_edges, char);
    if (added_edges == 0) {
        IGRAPH_ERROR("prim spanning tree failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added_edges);
    already_added = IGRAPH_CALLOC(no_of_nodes, char);
    if (already_added == 0) {
        IGRAPH_ERROR("prim spanning tree failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);
    IGRAPH_CHECK(igraph_d_indheap_init(&heap, 0));
    IGRAPH_FINALLY(igraph_d_indheap_destroy, &heap);
    IGRAPH_VECTOR_INIT_FINALLY(&adj, 0);

    for (i = 0; i < no_of_nodes; i++) {
        long int adj_size;
        if (already_added[i] > 0) {
            continue;
        }
        IGRAPH_ALLOW_INTERRUPTION();

        already_added[i] = 1;
        /* add all edges of the first vertex */
        igraph_incident(graph, &adj, (igraph_integer_t) i, (igraph_neimode_t) mode);
        adj_size = igraph_vector_size(&adj);
        for (j = 0; j < adj_size; j++) {
            igraph_integer_t edgeno = (long int) VECTOR(adj)[j];
            igraph_integer_t neighbor = IGRAPH_OTHER(graph, edgeno, i);
            if (already_added[(long int) neighbor] == 0) {
                IGRAPH_CHECK(igraph_d_indheap_push(&heap, -VECTOR(*weights)[edgeno], i,
                                                   edgeno));
            }
        }

        while (! igraph_d_indheap_empty(&heap)) {
            /* Get minimal edge */
            long int from, edge;
            igraph_d_indheap_max_index(&heap, &from, &edge);

            /* Erase it */
            igraph_d_indheap_delete_max(&heap);

            /* Is this edge already included? */
            if (added_edges[edge] == 0) {
                igraph_integer_t to = IGRAPH_OTHER(graph, edge, from);

                /* Does it point to a visited node? */
                if (already_added[(long int)to] == 0) {
                    already_added[(long int)to] = 1;
                    added_edges[edge] = 1;
                    IGRAPH_CHECK(igraph_vector_push_back(res, edge));
                    /* add all outgoing edges */
                    igraph_incident(graph, &adj, to, (igraph_neimode_t) mode);
                    adj_size = igraph_vector_size(&adj);
                    for (j = 0; j < adj_size; j++) {
                        long int edgeno = (long int) VECTOR(adj)[j];
                        long int neighbor = IGRAPH_OTHER(graph, edgeno, to);
                        if (already_added[neighbor] == 0) {
                            IGRAPH_CHECK(igraph_d_indheap_push(&heap, -VECTOR(*weights)[edgeno], to,
                                                               edgeno));
                        }
                    }
                } /* for */
            } /* if !already_added */
        } /* while in the same component */
    } /* for all nodes */

    igraph_d_indheap_destroy(&heap);
    IGRAPH_FREE(already_added);
    igraph_vector_destroy(&adj);
    IGRAPH_FREE(added_edges);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}


/* igraph_random_spanning_tree */

/* Loop-erased random walk (LERW) implementation.
 * res must be an initialized vector. The edge IDs of the spanning tree
 * will be added to the end of it. res will not be cleared before doing this.
 *
 * The walk is started from vertex start. comp_size must be the size of the connected
 * component containing start.
 */
static int igraph_i_lerw(const igraph_t *graph, igraph_vector_t *res, igraph_integer_t start,
                         igraph_integer_t comp_size, igraph_vector_bool_t *visited, const igraph_inclist_t *il) {
    igraph_integer_t visited_count;

    IGRAPH_CHECK(igraph_vector_reserve(res, igraph_vector_size(res) + comp_size - 1));

    RNG_BEGIN();

    VECTOR(*visited)[start] = 1;
    visited_count = 1;

    while (visited_count < comp_size) {
        long degree, edge;
        igraph_vector_int_t *edges;

        edges = igraph_inclist_get(il, start);

        /* choose a random edge */
        degree = igraph_vector_int_size(edges);
        edge = VECTOR(*edges)[ RNG_INTEGER(0, degree - 1) ];

        /* set 'start' to the next vertex */
        start = IGRAPH_OTHER(graph, edge, start);

        /* if the next vertex hasn't been visited yet, register the edge we just traversed */
        if (! VECTOR(*visited)[start]) {
            IGRAPH_CHECK(igraph_vector_push_back(res, edge));
            VECTOR(*visited)[start] = 1;
            visited_count++;
        }

        IGRAPH_ALLOW_INTERRUPTION();
    }

    RNG_END();

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_random_spanning_tree
 * \brief Uniformly sample the spanning trees of a graph
 *
 * Performs a loop-erased random walk on the graph to uniformly sample
 * its spanning trees. Edge directions are ignored.
 * 
 *
 * Multi-graphs are supported, and edge multiplicities will affect the sampling
 * frequency. For example, consider the 3-cycle graph 1=2-3-1, with two edges
 * between vertices 1 and 2. Due to these parallel edges, the trees 1-2-3
 * and 3-1-2 will be sampled with multiplicity 2, while the tree
 * 2-3-1 will be sampled with multiplicity 1.
 *
 * \param graph The input graph. Edge directions are ignored.
 * \param res An initialized vector, the IDs of the edges that constitute
 *        a spanning tree will be returned here. Use
 *        \ref igraph_subgraph_edges() to extract the spanning tree as
 *        a separate graph object.
 * \param vid This parameter is relevant if the graph is not connected.
 *        If negative, a random spanning forest of all components will be
 *        generated. Otherwise, it should be the ID of a vertex. A random
 *        spanning tree of the component containing the vertex will be
 *        generated.
 *
 * \return Error code.
 *
 * \sa \ref igraph_minimum_spanning_tree(), \ref igraph_random_walk()
 *
 */
int igraph_random_spanning_tree(const igraph_t *graph, igraph_vector_t *res, igraph_integer_t vid) {
    igraph_inclist_t il;
    igraph_vector_bool_t visited;
    igraph_integer_t vcount = igraph_vcount(graph);

    if (vid >= vcount) {
        IGRAPH_ERROR("Invalid vertex id given for random spanning tree", IGRAPH_EINVVID);
    }

    IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &il);

    IGRAPH_CHECK(igraph_vector_bool_init(&visited, vcount));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &visited);

    igraph_vector_clear(res);

    if (vid < 0) { /* generate random spanning forest: consider each component separately */
        igraph_vector_t membership, csize;
        igraph_integer_t comp_count;
        igraph_integer_t i;

        IGRAPH_VECTOR_INIT_FINALLY(&membership, 0);
        IGRAPH_VECTOR_INIT_FINALLY(&csize, 0);

        IGRAPH_CHECK(igraph_clusters(graph, &membership, &csize, &comp_count, IGRAPH_WEAK));

        /* for each component ... */
        for (i = 0; i < comp_count; ++i) {
            /* ... find a vertex to start the LERW from */
            igraph_integer_t j = 0;
            while (VECTOR(membership)[j] != i) {
                ++j;
            }

            IGRAPH_CHECK(igraph_i_lerw(graph, res, j, (igraph_integer_t) VECTOR(csize)[i], &visited, &il));
        }

        igraph_vector_destroy(&membership);
        igraph_vector_destroy(&csize);
        IGRAPH_FINALLY_CLEAN(2);
    } else { /* consider the component containing vid */
        igraph_vector_t comp_vertices;
        igraph_integer_t comp_size;

        /* we measure the size of the component */
        IGRAPH_VECTOR_INIT_FINALLY(&comp_vertices, 0);
        IGRAPH_CHECK(igraph_subcomponent(graph, &comp_vertices, vid, IGRAPH_ALL));
        comp_size = (igraph_integer_t) igraph_vector_size(&comp_vertices);
        igraph_vector_destroy(&comp_vertices);
        IGRAPH_FINALLY_CLEAN(1);

        IGRAPH_CHECK(igraph_i_lerw(graph, res, vid, comp_size, &visited, &il));
    }

    igraph_vector_bool_destroy(&visited);
    igraph_inclist_destroy(&il);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5391412
igraph-0.9.9/vendor/source/igraph/src/operators/0000755000175100001710000000000000000000000022457 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/add_edge.c0000644000175100001710000000403700000000000024343 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_interface.h"

/**
 * \function igraph_add_edge
 * \brief Adds a single edge to a graph.
 *
 * 
 * For directed graphs the edge points from \p from to \p to.
 *
 * 
 * Note that if you want to add many edges to a big graph, then it is
 * inefficient to add them one by one, it is better to collect them into
 * a vector and add all of them via a single \ref igraph_add_edges() call.
 * \param igraph The graph.
 * \param from The id of the first vertex of the edge.
 * \param to The id of the second vertex of the edge.
 * \return Error code.
 *
 * \sa \ref igraph_add_edges() to add many edges, \ref
 * igraph_delete_edges() to remove edges and \ref
 * igraph_add_vertices() to add vertices.
 *
 * Time complexity: O(|V|+|E|), the number of edges plus the number of
 * vertices.
 */
int igraph_add_edge(igraph_t *graph, igraph_integer_t from, igraph_integer_t to) {
    igraph_vector_t edges;
    int ret;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 2);

    VECTOR(edges)[0] = from;
    VECTOR(edges)[1] = to;
    IGRAPH_CHECK(ret = igraph_add_edges(graph, &edges, 0));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return ret;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/complementer.c0000644000175100001710000000704200000000000025320 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "graph/attributes.h"
#include "core/interruption.h"

/**
 * \function igraph_complementer
 * \brief Create the complementer of a graph
 *
 * The complementer graph means that all edges which are
 * not part of the original graph will be included in the result.
 *
 * \param res Pointer to an uninitialized graph object.
 * \param graph The original graph.
 * \param loops Whether to add loop edges to the complementer graph.
 * \return Error code.
 * \sa \ref igraph_union(), \ref igraph_intersection() and \ref
 * igraph_difference().
 *
 * Time complexity: O(|V|+|E1|+|E2|), |V| is the number of
 * vertices in the graph, |E1| is the number of edges in the original
 * and |E2| in the complementer graph.
 *
 * \example examples/simple/igraph_complementer.c
 */
int igraph_complementer(igraph_t *res, const igraph_t *graph,
                        igraph_bool_t loops) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t edges;
    igraph_vector_t neis;
    long int i, j;
    long int zero = 0, *limit;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    if (igraph_is_directed(graph)) {
        limit = &zero;
    } else {
        limit = &i;
    }

    for (i = 0; i < no_of_nodes; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
                                      IGRAPH_OUT));
        if (loops) {
            for (j = no_of_nodes - 1; j >= *limit; j--) {
                if (igraph_vector_empty(&neis) || j > igraph_vector_tail(&neis)) {
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                    IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
                } else {
                    igraph_vector_pop_back(&neis);
                }
            }
        } else {
            for (j = no_of_nodes - 1; j >= *limit; j--) {
                if (igraph_vector_empty(&neis) || j > igraph_vector_tail(&neis)) {
                    if (i != j) {
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                        IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
                    }
                } else {
                    igraph_vector_pop_back(&neis);
                }
            }
        }
    }

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               igraph_is_directed(graph)));
    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&neis);
    IGRAPH_I_ATTRIBUTE_DESTROY(res);
    IGRAPH_I_ATTRIBUTE_COPY(res, graph, /*graph=*/1, /*vertex=*/1, /*edge=*/0);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/compose.c0000644000175100001710000001147700000000000024302 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "core/interruption.h"

/**
 * \function igraph_compose
 * \brief Calculates the composition of two graphs
 *
 * The composition of graphs contains the same number of vertices as
 * the bigger graph of the two operands. It contains an (i,j) edge if
 * and only if there is a k vertex, such that the first graphs
 * contains an (i,k) edge and the second graph a (k,j) edge.
 *
 * This is of course exactly the composition of two
 * binary relations.
 *
 * Two two graphs must have the same directedness,
 * otherwise the function returns with an error message.
 * Note that for undirected graphs the two relations are by definition
 * symmetric.
 *
 * \param res Pointer to an uninitialized graph object, the result
 *        will be stored here.
 * \param g1 The firs operand, a graph object.
 * \param g2 The second operand, another graph object.
 * \param edge_map1 If not a null pointer, then it must be a pointer
 *        to an initialized vector, and a mapping from the edges of
 *        the result graph to the edges of the first graph is stored
 *        here.
 * \param edge_map1 If not a null pointer, then it must be a pointer
 *        to an initialized vector, and a mapping from the edges of
 *        the result graph to the edges of the second graph is stored
 *        here.
 * \return Error code.
 *
 * Time complexity: O(|V|*d1*d2), |V| is the number of vertices in the
 * first graph, d1 and d2 the average degree in the first and second
 * graphs.
 *
 * \example examples/simple/igraph_compose.c
 */
int igraph_compose(igraph_t *res, const igraph_t *g1, const igraph_t *g2,
                   igraph_vector_t *edge_map1, igraph_vector_t *edge_map2) {

    long int no_of_nodes_left = igraph_vcount(g1);
    long int no_of_nodes_right = igraph_vcount(g2);
    long int no_of_nodes;
    igraph_bool_t directed = igraph_is_directed(g1);
    igraph_vector_t edges;
    igraph_vector_t neis1, neis2;
    long int i;

    if (directed != igraph_is_directed(g2)) {
        IGRAPH_ERROR("Cannot compose directed and undirected graph",
                     IGRAPH_EINVAL);
    }

    no_of_nodes = no_of_nodes_left > no_of_nodes_right ?
                  no_of_nodes_left : no_of_nodes_right;

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis1, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neis2, 0);

    if (edge_map1) {
        igraph_vector_clear(edge_map1);
    }
    if (edge_map2) {
        igraph_vector_clear(edge_map2);
    }

    for (i = 0; i < no_of_nodes_left; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        IGRAPH_CHECK(igraph_incident(g1, &neis1, (igraph_integer_t) i,
                                     IGRAPH_OUT));
        while (!igraph_vector_empty(&neis1)) {
            long int con = (long int) igraph_vector_pop_back(&neis1);
            long int v1 = IGRAPH_OTHER(g1, con, i);
            if (v1 < no_of_nodes_right) {
                IGRAPH_CHECK(igraph_incident(g2, &neis2, (igraph_integer_t) v1,
                                             IGRAPH_OUT));
            } else {
                continue;
            }
            while (!igraph_vector_empty(&neis2)) {
                long int con2 = igraph_vector_pop_back(&neis2);
                long int v2 = IGRAPH_OTHER(g2, con2, v1);
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, v2));
                if (edge_map1) {
                    IGRAPH_CHECK(igraph_vector_push_back(edge_map1, con));
                }
                if (edge_map2) {
                    IGRAPH_CHECK(igraph_vector_push_back(edge_map2, con2));
                }
            }
        }
    }

    igraph_vector_destroy(&neis1);
    igraph_vector_destroy(&neis2);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               directed));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/connect_neighborhood.c0000644000175100001710000001412300000000000027004 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

/**
 * \function igraph_connect_neighborhood
 * \brief Connects every vertex to its neighborhood
 *
 * This function adds new edges to the input graph. Each vertex is connected
 * to all vertices reachable by at most \p order steps from it
 * (unless a connection already existed).  In other words, the \p order power of
 * the graph is computed.
 *
 *  Note that the input graph is modified in place, no
 * new graph is created. Call \ref igraph_copy() if you want to keep
 * the original graph as well.
 *
 *  For undirected graphs reachability is always
 * symmetric: if vertex A can be reached from vertex B in at
 * most \p order steps, then the opposite is also true. Only one
 * undirected (A,B) edge will be added in this case.
 * \param graph The input graph, this is the output graph as well.
 * \param order Integer constant, it gives the distance within which
 *    the vertices will be connected to the source vertex.
 * \param mode Constant, it specifies how the neighborhood search is
 *    performed for directed graphs. If \c IGRAPH_OUT then vertices
 *    reachable from the source vertex will be connected, \c IGRAPH_IN
 *    is the opposite. If \c IGRAPH_ALL then the directed graph is
 *    considered as an undirected one.
 * \return Error code.
 *
 * \sa \ref igraph_lattice() uses this function to connect the
 * neighborhood of the vertices.
 *
 * Time complexity: O(|V|*d^k), |V| is the number of vertices in the
 * graph, d is the average degree and k is the \p order argument.
 */
int igraph_connect_neighborhood(igraph_t *graph, igraph_integer_t order,
                                igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q;
    igraph_vector_t edges;
    long int i, j, in;
    long int *added;
    igraph_vector_t neis;

    if (order < 0) {
        IGRAPH_ERROR("Negative order, cannot connect neighborhood", IGRAPH_EINVAL);
    }

    if (order < 2) {
        IGRAPH_WARNING("Order smaller than two, graph will be unchanged");
    }

    if (!igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot connect neighborhood", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);

    for (i = 0; i < no_of_nodes; i++) {
        added[i] = i + 1;
        igraph_neighbors(graph, &neis, (igraph_integer_t) i, mode);
        in = igraph_vector_size(&neis);
        if (order > 1) {
            for (j = 0; j < in; j++) {
                long int nei = (long int) VECTOR(neis)[j];
                added[nei] = i + 1;
                igraph_dqueue_push(&q, nei);
                igraph_dqueue_push(&q, 1);
            }
        }

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);
            long int n;
            igraph_neighbors(graph, &neis, (igraph_integer_t) actnode, mode);
            n = igraph_vector_size(&neis);

            if (actdist < order - 1) {
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        IGRAPH_CHECK(igraph_dqueue_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                        if (mode != IGRAPH_ALL || i < nei) {
                            if (mode == IGRAPH_IN) {
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, nei));
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                            } else {
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, nei));
                            }
                        }
                    }
                }
            } else {
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        if (mode != IGRAPH_ALL || i < nei) {
                            if (mode == IGRAPH_IN) {
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, nei));
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                            } else {
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                                IGRAPH_CHECK(igraph_vector_push_back(&edges, nei));
                            }
                        }
                    }
                }
            }

        } /* while q not empty */
    } /* for i < no_of_nodes */

    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&q);
    igraph_free(added);
    IGRAPH_FINALLY_CLEAN(3);

    IGRAPH_CHECK(igraph_add_edges(graph, &edges, 0));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/contract.c0000644000175100001710000001244200000000000024443 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "graph/attributes.h"

static void igraph_i_simplify_free(igraph_vector_ptr_t *p) {
    long int i, n = igraph_vector_ptr_size(p);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*p)[i];
        if (v) {
            igraph_vector_destroy(v);
        }
    }
    igraph_vector_ptr_destroy(p);
}

/**
 * \function igraph_contract_vertices
 * Replace multiple vertices with a single one.
 *
 * This function creates a new graph, by merging several
 * vertices into one. The vertices in the new graph correspond
 * to sets of vertices in the input graph.
 * \param graph The input graph, it can be directed or
 *        undirected.
 * \param mapping A vector giving the mapping. For each
 *        vertex in the original graph, it should contain
 *        its id in the new graph.
 * \param vertex_comb What to do with the vertex attributes.
 *        \c NULL means that vertex attributes are not kept
 *        after the contraction (not even for unaffected
 *        vertices). See the igraph manual section about attributes
 *        for details.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number
 * or vertices plus edges.
 */

int igraph_contract_vertices(igraph_t *graph,
                             const igraph_vector_t *mapping,
                             const igraph_attribute_combination_t *vertex_comb) {
    igraph_vector_t edges;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t vattr = vertex_comb && igraph_has_attribute_table();
    igraph_t res;
    long int e, last = -1;
    long int no_new_vertices;

    if (igraph_vector_size(mapping) != no_of_nodes) {
        IGRAPH_ERROR("Invalid mapping vector length",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    if (no_of_nodes > 0) {
        last = (long int) igraph_vector_max(mapping);
    }

    for (e = 0; e < no_of_edges; e++) {
        long int from = IGRAPH_FROM(graph, e);
        long int to = IGRAPH_TO(graph, e);

        long int nfrom = (long int) VECTOR(*mapping)[from];
        long int nto = (long int) VECTOR(*mapping)[to];

        igraph_vector_push_back(&edges, nfrom);
        igraph_vector_push_back(&edges, nto);

        if (nfrom > last) {
            last = nfrom;
        }
        if (nto   > last) {
            last = nto;
        }
    }

    no_new_vertices = last + 1;

    IGRAPH_CHECK(igraph_create(&res, &edges, (igraph_integer_t) no_new_vertices,
                               igraph_is_directed(graph)));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_FINALLY(igraph_destroy, &res);

    IGRAPH_I_ATTRIBUTE_DESTROY(&res);
    IGRAPH_I_ATTRIBUTE_COPY(&res, graph, /*graph=*/ 1,
                            /*vertex=*/ 0, /*edge=*/ 1);

    if (vattr) {
        long int i;
        igraph_vector_ptr_t merges;
        igraph_vector_t sizes;
        igraph_vector_t *vecs;

        vecs = IGRAPH_CALLOC(no_new_vertices, igraph_vector_t);
        if (!vecs) {
            IGRAPH_ERROR("Cannot combine attributes while contracting"
                         " vertices", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, vecs);
        IGRAPH_CHECK(igraph_vector_ptr_init(&merges, no_new_vertices));
        IGRAPH_FINALLY(igraph_i_simplify_free, &merges);
        IGRAPH_VECTOR_INIT_FINALLY(&sizes, no_new_vertices);

        for (i = 0; i < no_of_nodes; i++) {
            long int to = (long int) VECTOR(*mapping)[i];
            VECTOR(sizes)[to] += 1;
        }
        for (i = 0; i < no_new_vertices; i++) {
            igraph_vector_t *v = &vecs[i];
            IGRAPH_CHECK(igraph_vector_init(v, (long int) VECTOR(sizes)[i]));
            igraph_vector_clear(v);
            VECTOR(merges)[i] = v;
        }
        for (i = 0; i < no_of_nodes; i++) {
            long int to = (long int) VECTOR(*mapping)[i];
            igraph_vector_t *v = &vecs[to];
            igraph_vector_push_back(v, i);
        }

        IGRAPH_CHECK(igraph_i_attribute_combine_vertices(graph, &res,
                     &merges,
                     vertex_comb));

        igraph_vector_destroy(&sizes);
        igraph_i_simplify_free(&merges);
        igraph_free(vecs);
        IGRAPH_FINALLY_CLEAN(3);
    }

    IGRAPH_FINALLY_CLEAN(1);
    igraph_destroy(graph);
    *graph = res;

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/difference.c0000644000175100001710000001443500000000000024724 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_adjlist.h"
#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "graph/attributes.h"
#include "core/interruption.h"

/**
 * \function igraph_difference
 * \brief Calculate the difference of two graphs
 *
 * 
 * The number of vertices in the result is the number of vertices in
 * the original graph, i.e. the left, first operand. In the results
 * graph only edges will be included from \p orig which are not
 * present in \p sub.
 *
 * \param res Pointer to an uninitialized graph object, the result
 * will be stored here.
 * \param orig The left operand of the operator, a graph object.
 * \param sub The right operand of the operator, a graph object.
 * \return Error code.
 * \sa \ref igraph_intersection() and \ref igraph_union() for other
 * operators.
 *
 * Time complexity: O(|V|+|E|), |V| is the number vertices in
 * the smaller graph, |E| is the
 * number of edges in the result graph.
 *
 * \example examples/simple/igraph_difference.c
 */
int igraph_difference(igraph_t *res,
                      const igraph_t *orig, const igraph_t *sub) {

    /* Quite nasty, but we will use that an edge adjacency list
       contains the vertices according to the order of the
       vertex ids at the "other" end of the edge. */

    long int no_of_nodes_orig = igraph_vcount(orig);
    long int no_of_nodes_sub = igraph_vcount(sub);
    long int no_of_nodes = no_of_nodes_orig;
    long int smaller_nodes;
    igraph_bool_t directed = igraph_is_directed(orig);
    igraph_vector_t edges;
    igraph_vector_t edge_ids;
    igraph_vector_int_t *nei1, *nei2;
    igraph_inclist_t inc_orig, inc_sub;
    long int i;
    igraph_integer_t v1, v2;

    if (directed != igraph_is_directed(sub)) {
        IGRAPH_ERROR("Cannot subtract directed and undirected graphs",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edge_ids, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_inclist_init(orig, &inc_orig, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inc_orig);
    IGRAPH_CHECK(igraph_inclist_init(sub, &inc_sub, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inc_sub);

    smaller_nodes = no_of_nodes_orig > no_of_nodes_sub ?
                    no_of_nodes_sub : no_of_nodes_orig;

    for (i = 0; i < smaller_nodes; i++) {
        long int n1, n2, e1, e2;
        IGRAPH_ALLOW_INTERRUPTION();
        nei1 = igraph_inclist_get(&inc_orig, i);
        nei2 = igraph_inclist_get(&inc_sub, i);
        n1 = igraph_vector_int_size(nei1) - 1;
        n2 = igraph_vector_int_size(nei2) - 1;
        while (n1 >= 0 && n2 >= 0) {
            e1 = (long int) VECTOR(*nei1)[n1];
            e2 = (long int) VECTOR(*nei2)[n2];
            v1 = IGRAPH_OTHER(orig, e1, i);
            v2 = IGRAPH_OTHER(sub, e2, i);

            if (!directed && v1 < i) {
                n1--;
            } else if (!directed && v2 < i) {
                n2--;
            } else if (v1 > v2) {
                IGRAPH_CHECK(igraph_vector_push_back(&edge_ids, e1));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, v1));
                n1--;
                /* handle loop edges properly in undirected graphs */
                if (!directed && i == v1) {
                    n1--;
                }
            } else if (v2 > v1) {
                n2--;
            } else {
                n1--;
                n2--;
            }
        }

        /* Copy remaining edges */
        while (n1 >= 0) {
            e1 = (long int) VECTOR(*nei1)[n1];
            v1 = IGRAPH_OTHER(orig, e1, i);
            if (directed || v1 >= i) {
                IGRAPH_CHECK(igraph_vector_push_back(&edge_ids, e1));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, v1));

                /* handle loop edges properly in undirected graphs */
                if (!directed && v1 == i) {
                    n1--;
                }
            }
            n1--;
        }
    }

    /* copy remaining edges, use the previous value of 'i' */
    for (; i < no_of_nodes_orig; i++) {
        long int n1, e1;
        nei1 = igraph_inclist_get(&inc_orig, i);
        n1 = igraph_vector_int_size(nei1) - 1;
        while (n1 >= 0) {
            e1 = (long int) VECTOR(*nei1)[n1];
            v1 = IGRAPH_OTHER(orig, e1, i);
            if (directed || v1 >= i) {
                IGRAPH_CHECK(igraph_vector_push_back(&edge_ids, e1));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, v1));

                /* handle loop edges properly in undirected graphs */
                if (!directed && v1 == i) {
                    n1--;
                }
            }
            n1--;
        }
    }

    igraph_inclist_destroy(&inc_sub);
    igraph_inclist_destroy(&inc_orig);
    IGRAPH_FINALLY_CLEAN(2);
    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    /* Attributes */
    if (orig->attr) {
        IGRAPH_I_ATTRIBUTE_DESTROY(res);
        IGRAPH_I_ATTRIBUTE_COPY(res, orig, /*graph=*/1, /*vertex=*/1, /*edge=*/0);
        IGRAPH_CHECK(igraph_i_attribute_permute_edges(orig, res, &edge_ids));
    }

    igraph_vector_destroy(&edge_ids);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/disjoint_union.c0000644000175100001710000001424200000000000025661 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "operators/misc_internal.h"

/**
 * \function igraph_disjoint_union
 * \brief Creates the union of two disjoint graphs
 *
 * 
 * First the vertices of the second graph will be relabeled with new
 * vertex ids to have two disjoint sets of vertex ids, then the union
 * of the two graphs will be formed.
 * If the two graphs have |V1| and |V2| vertices and |E1| and |E2|
 * edges respectively then the new graph will have |V1|+|V2| vertices
 * and |E1|+|E2| edges.
 *
 * 
 * Both graphs need to have the same directedness, i.e. either both
 * directed or both undirected.
 *
 * 
 * The current version of this function cannot handle graph, vertex
 * and edge attributes, they will be lost.
 *
 * \param res  Pointer to an uninitialized graph object, the result
 *        will stored here.
 * \param left The first graph.
 * \param right The second graph.
 * \return Error code.
 * \sa \ref igraph_disjoint_union_many() for creating the disjoint union
 * of more than two graphs, \ref igraph_union() for non-disjoint
 * union.
 *
 * Time complexity: O(|V1|+|V2|+|E1|+|E2|).
 *
 * \example examples/simple/igraph_disjoint_union.c
 */
int igraph_disjoint_union(igraph_t *res, const igraph_t *left,
                          const igraph_t *right) {

    long int no_of_nodes_left = igraph_vcount(left);
    long int no_of_nodes_right = igraph_vcount(right);
    long int no_of_edges_left = igraph_ecount(left);
    long int no_of_edges_right = igraph_ecount(right);
    igraph_vector_t edges;
    igraph_bool_t directed_left = igraph_is_directed(left);
    igraph_integer_t from, to;
    long int i;

    if (directed_left != igraph_is_directed(right)) {
        IGRAPH_ERROR("Cannot union directed and undirected graphs",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges,
                                       2 * (no_of_edges_left + no_of_edges_right)));
    for (i = 0; i < no_of_edges_left; i++) {
        igraph_edge(left, (igraph_integer_t) i, &from, &to);
        igraph_vector_push_back(&edges, from);
        igraph_vector_push_back(&edges, to);
    }
    for (i = 0; i < no_of_edges_right; i++) {
        igraph_edge(right, (igraph_integer_t) i, &from, &to);
        igraph_vector_push_back(&edges, from + no_of_nodes_left);
        igraph_vector_push_back(&edges, to + no_of_nodes_left);
    }

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t)
                               (no_of_nodes_left + no_of_nodes_right),
                               directed_left));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}

/**
 * \function igraph_disjoint_union_many
 * \brief The disjint union of many graphs.
 *
 * 
 * First the vertices in the graphs will be relabeled with new vertex
 * ids to have pairwise disjoint vertex id sets and then the union of
 * the graphs is formed.
 * The number of vertices and edges in the result is the total number
 * of vertices and edges in the graphs.
 *
 * 
 * All graphs need to have the same directedness, i.e. either all
 * directed or all undirected. If the graph list has length zero,
 * the result will be a \em directed graph with no vertices.
 *
 * 
 * The current version of this function cannot handle graph, vertex
 * and edge attributes, they will be lost.
 *
 * \param res Pointer to an uninitialized graph object, the result of
 *        the operation will be stored here.
 * \param graphs Pointer vector, contains pointers to initialized
 *        graph objects.
 * \return Error code.
 * \sa \ref igraph_disjoint_union() for an easier syntax if you have
 * only two graphs, \ref igraph_union_many() for non-disjoint union.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number
 * of edges in the result.
 */
int igraph_disjoint_union_many(igraph_t *res,
                               const igraph_vector_ptr_t *graphs) {
    long int no_of_graphs = igraph_vector_ptr_size(graphs);
    igraph_bool_t directed = 1;
    igraph_vector_t edges;
    long int no_of_edges = 0;
    long int shift = 0;
    igraph_t *graph;
    long int i, j;
    igraph_integer_t from, to;

    if (no_of_graphs != 0) {
        graph = VECTOR(*graphs)[0];
        directed = igraph_is_directed(graph);
        for (i = 0; i < no_of_graphs; i++) {
            graph = VECTOR(*graphs)[i];
            no_of_edges += igraph_ecount(graph);
            if (directed != igraph_is_directed(graph)) {
                IGRAPH_ERROR("Cannot union directed and undirected graphs",
                             IGRAPH_EINVAL);
            }
        }
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, 2 * no_of_edges));

    for (i = 0; i < no_of_graphs; i++) {
        long int ec;
        graph = VECTOR(*graphs)[i];
        ec = igraph_ecount(graph);
        for (j = 0; j < ec; j++) {
            igraph_edge(graph, (igraph_integer_t) j, &from, &to);
            igraph_vector_push_back(&edges, from + shift);
            igraph_vector_push_back(&edges, to + shift);
        }
        shift += igraph_vcount(graph);
    }

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) shift, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/intersection.c0000644000175100001710000002705400000000000025341 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_qsort.h"

#include "operators/misc_internal.h"

#include 

/**
 * \function igraph_intersection
 * \brief Collect the common edges from two graphs.
 *
 * 
 * The result graph contains only edges present both in the first and
 * the second graph. The number of vertices in the result graph is the
 * same as the larger from the two arguments.
 *
 * \param res Pointer to an uninitialized graph object. This will
 * contain the result of the operation.
 * \param left The first operand, a graph object.
 * \param right The second operand, a graph object.
 * \param edge_map1 Null pointer, or an initialized \type igraph_vector_t.
 *    If the latter, then a mapping from the edges of the result graph, to
 *    the edges of the \p left input graph is stored here.
 * \param edge_map2 Null pointer, or an \type igraph_vector_t. The same
 *    as \p edge_map1, but for the \p right input graph.
 * \return Error code.
 * \sa \ref igraph_intersection_many() to calculate the intersection
 * of many graphs at once, \ref igraph_union(), \ref
 * igraph_difference() for other operators.
 *
 * Time complexity: O(|V|+|E|), |V| is the number of nodes, |E|
 * is the number of edges in the smaller graph of the two. (The one
 * containing less vertices is considered smaller.)
 *
 * \example examples/simple/igraph_intersection.c
 */
int igraph_intersection(igraph_t *res,
                        const igraph_t *left, const igraph_t *right,
                        igraph_vector_t *edge_map1,
                        igraph_vector_t *edge_map2) {
    return igraph_i_merge(res, IGRAPH_MERGE_MODE_INTERSECTION, left, right,
                          edge_map1, edge_map2);
}

/**
 * \function igraph_intersection_many
 * \brief The intersection of more than two graphs.
 *
 * 
 * This function calculates the intersection of the graphs stored in
 * the \p graphs argument. Only those edges will be included in the
 * result graph which are part of every graph in \p graphs.
 *
 * 
 * The number of vertices in the result graph will be the maximum
 * number of vertices in the argument graphs.
 *
 * \param res Pointer to an uninitialized graph object, the result of
 *        the operation will be stored here.
 * \param graphs Pointer vector, contains pointers to graphs objects,
 *        the operands of the intersection operator.
 * \param edgemaps If not a null pointer, then it must be an initialized
 *        pointer vector and the mappings of edges from the graphs to the
 *        result graph will be stored here, in the same order as
 *        \p graphs. Each mapping is stored in a separate
 *        \type igraph_vector_t object. For the edges that are not in
 *        the intersection, -1 is stored.
 * \return Error code.
 * \sa \ref igraph_intersection() for the intersection of two graphs,
 * \ref igraph_union_many(), \ref igraph_union() and \ref
 * igraph_difference() for other operators.
 *
 * Time complexity: O(|V|+|E|), |V| is the number of vertices,
 * |E| is the number of edges in the smallest graph (i.e. the graph having
 * the less vertices).
 */
int igraph_intersection_many(igraph_t *res,
                             const igraph_vector_ptr_t *graphs,
                             igraph_vector_ptr_t *edgemaps) {

    long int no_of_graphs = igraph_vector_ptr_size(graphs);
    long int no_of_nodes = 0;
    igraph_bool_t directed = 1;
    igraph_vector_t edges;
    igraph_vector_ptr_t edge_vects, order_vects;
    long int i, j, tailfrom = no_of_graphs > 0 ? 0 : -1, tailto = -1;
    igraph_vector_long_t no_edges;
    igraph_bool_t allne = no_of_graphs == 0 ? 0 : 1, allsame = 0;
    long int idx = 0;

    /* Check directedness */
    if (no_of_graphs != 0) {
        directed = igraph_is_directed(VECTOR(*graphs)[0]);
    }
    for (i = 1; i < no_of_graphs; i++) {
        if (directed != igraph_is_directed(VECTOR(*graphs)[i])) {
            IGRAPH_ERROR("Cannot intersect directed and undirected graphs",
                         IGRAPH_EINVAL);
        }
    }

    if (edgemaps) {
        IGRAPH_CHECK(igraph_vector_ptr_resize(edgemaps, no_of_graphs));
        igraph_vector_ptr_null(edgemaps);
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vectors, edgemaps);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_long_init(&no_edges, no_of_graphs));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &no_edges);

    /* Calculate number of nodes, query number of edges */
    for (i = 0; i < no_of_graphs; i++) {
        long int n = igraph_vcount(VECTOR(*graphs)[i]);
        if (n > no_of_nodes) {
            no_of_nodes = n;
        }
        VECTOR(no_edges)[i] = igraph_ecount(VECTOR(*graphs)[i]);
        allne = allne && VECTOR(no_edges)[i] > 0;
    }

    if (edgemaps) {
        for (i = 0; i < no_of_graphs; i++) {
            VECTOR(*edgemaps)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!VECTOR(*edgemaps)[i]) {
                IGRAPH_ERROR("Cannot intersect graphs", IGRAPH_ENOMEM);
            }
            IGRAPH_CHECK(igraph_vector_init(VECTOR(*edgemaps)[i],
                                            VECTOR(no_edges)[i]));
            igraph_vector_fill(VECTOR(*edgemaps)[i], -1);
        }
    }

    /* Allocate memory for the edge lists and their index vectors */
    if (no_of_graphs != 0) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&edge_vects, no_of_graphs));
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vectors, &edge_vects);
        IGRAPH_CHECK(igraph_vector_ptr_init(&order_vects, no_of_graphs));
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vector_longs, &order_vects);
    }
    for (i = 0; i < no_of_graphs; i++) {
        VECTOR(edge_vects)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
        VECTOR(order_vects)[i] = IGRAPH_CALLOC(1, igraph_vector_long_t);
        if (! VECTOR(edge_vects)[i] || ! VECTOR(order_vects)[i]) {
            IGRAPH_ERROR("Cannot intersect graphs", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(VECTOR(edge_vects)[i],
                                        2 * VECTOR(no_edges)[i]));
        IGRAPH_CHECK(igraph_vector_long_init(VECTOR(order_vects)[i],
                                             VECTOR(no_edges)[i]));
    }

    /* Query and sort the edge lists */
    for (i = 0; i < no_of_graphs; i++) {
        long int k, j, n = VECTOR(no_edges)[i];
        igraph_vector_t *edges = VECTOR(edge_vects)[i];
        igraph_vector_long_t *order = VECTOR(order_vects)[i];
        IGRAPH_CHECK(igraph_get_edgelist(VECTOR(*graphs)[i], edges, /*bycol=*/0));
        if (!directed) {
            for (k = 0, j = 0; k < n; k++, j += 2) {
                if (VECTOR(*edges)[j] > VECTOR(*edges)[j + 1]) {
                    long int tmp = VECTOR(*edges)[j];
                    VECTOR(*edges)[j] = VECTOR(*edges)[j + 1];
                    VECTOR(*edges)[j + 1] = tmp;
                }
            }
        }
        for (k = 0; k < n; k++) {
            VECTOR(*order)[k] = k;
        }
        igraph_qsort_r(VECTOR(*order), n, sizeof(VECTOR(*order)[0]), edges,
                       igraph_i_order_edgelist_cmp);
    }

    /* Do the merge. We work from the end of the edge lists,
       because then we don't have to keep track of where we are right
       now in the edge and order lists. We find the "largest" edge,
       and if it is present in all graphs, then we copy it to the
       result. We remove all instances of this edge.  */

    while (allne) {

        /* Look for the smallest tail element */
        for (j = 0, tailfrom = LONG_MAX, tailto = LONG_MAX; j < no_of_graphs; j++) {
            long int edge = igraph_vector_long_tail(VECTOR(order_vects)[j]);
            igraph_vector_t *ev = VECTOR(edge_vects)[j];
            long int from = VECTOR(*ev)[2 * edge];
            long int to = VECTOR(*ev)[2 * edge + 1];
            if (from < tailfrom || (from == tailfrom && to < tailto)) {
                tailfrom = from; tailto = to;
            }
        }

        /* OK, now remove all elements from the tail(s) that are bigger
           than the smallest tail element. */
        for (j = 0, allsame = 1; j < no_of_graphs; j++) {
            long int from = -1, to = -1;
            while (1) {
                long int edge = igraph_vector_long_tail(VECTOR(order_vects)[j]);
                igraph_vector_t *ev = VECTOR(edge_vects)[j];
                from = VECTOR(*ev)[2 * edge];
                to = VECTOR(*ev)[2 * edge + 1];
                if (from > tailfrom || (from == tailfrom && to > tailto)) {
                    igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
                    if (igraph_vector_long_empty(VECTOR(order_vects)[j])) {
                        allne = 0;
                        break;
                    }
                } else {
                    break;
                }
            }
            if (from != tailfrom || to != tailto) {
                allsame = 0;
            }
        }

        /* Add the edge, if the smallest tail element was present
           in all graphs. */
        if (allsame) {
            IGRAPH_CHECK(igraph_vector_push_back(&edges, tailfrom));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, tailto));
        }

        /* Drop edges matching the smalles tail elements
           from the order vectors, build edge maps */
        if (allne) {
            for (j = 0; j < no_of_graphs; j++) {
                long int edge = igraph_vector_long_tail(VECTOR(order_vects)[j]);
                igraph_vector_t *ev = VECTOR(edge_vects)[j];
                long int from = VECTOR(*ev)[2 * edge];
                long int to = VECTOR(*ev)[2 * edge + 1];
                if (from == tailfrom && to == tailto) {
                    igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
                    if (igraph_vector_long_empty(VECTOR(order_vects)[j])) {
                        allne = 0;
                    }
                    if (edgemaps && allsame) {
                        igraph_vector_t *map = VECTOR(*edgemaps)[j];
                        VECTOR(*map)[edge] = idx;
                    }
                }
            }
            if (allsame) {
                idx++;
            }
        }

    } /* while allne */

    if (no_of_graphs > 0) {
        igraph_i_union_intersection_destroy_vector_longs(&order_vects);
        igraph_i_union_intersection_destroy_vectors(&edge_vects);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vector_long_destroy(&no_edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    if (edgemaps) {
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/misc_internal.c0000644000175100001710000002214000000000000025451 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "operators/misc_internal.h"

#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_qsort.h"

void igraph_i_union_intersection_destroy_vectors(igraph_vector_ptr_t *v) {
    long int i, n = igraph_vector_ptr_size(v);
    for (i = 0; i < n; i++) {
        if (VECTOR(*v)[i] != 0) {
            igraph_vector_destroy(VECTOR(*v)[i]);
            IGRAPH_FREE(VECTOR(*v)[i]);
        }
    }
    igraph_vector_ptr_destroy(v);
}

void igraph_i_union_intersection_destroy_vector_longs(igraph_vector_ptr_t *v) {
    long int i, n = igraph_vector_ptr_size(v);
    for (i = 0; i < n; i++) {
        if (VECTOR(*v)[i] != 0) {
            igraph_vector_long_destroy(VECTOR(*v)[i]);
            IGRAPH_FREE(VECTOR(*v)[i]);
        }
    }
    igraph_vector_ptr_destroy(v);
}

int igraph_i_order_edgelist_cmp(void *edges, const void *e1, const void *e2) {
    igraph_vector_t *edgelist = edges;
    long int edge1 = (*(const long int*) e1) * 2;
    long int edge2 = (*(const long int*) e2) * 2;
    long int from1 = VECTOR(*edgelist)[edge1];
    long int from2 = VECTOR(*edgelist)[edge2];
    if (from1 < from2) {
        return -1;
    } else if (from1 > from2) {
        return 1;
    } else {
        long int to1 = VECTOR(*edgelist)[edge1 + 1];
        long int to2 = VECTOR(*edgelist)[edge2 + 1];
        if (to1 < to2) {
            return -1;
        } else if (to1 > to2) {
            return 1;
        } else {
            return 0;
        }
    }
}

int igraph_i_merge(igraph_t *res, int mode,
                   const igraph_t *left, const igraph_t *right,
                   igraph_vector_t *edge_map1, igraph_vector_t *edge_map2) {

    long int no_of_nodes_left = igraph_vcount(left);
    long int no_of_nodes_right = igraph_vcount(right);
    long int no_of_nodes;
    long int no_edges_left = igraph_ecount(left);
    long int no_edges_right = igraph_ecount(right);
    igraph_bool_t directed = igraph_is_directed(left);
    igraph_vector_t edges;
    igraph_vector_t edges1, edges2;
    igraph_vector_long_t order1, order2;
    long int i, j, eptr = 0;
    long int idx1, idx2, edge1 = -1, edge2 = -1, from1 = -1, from2 = -1, to1 = -1, to2 = -1;
    igraph_bool_t l;

    if (directed != igraph_is_directed(right)) {
        IGRAPH_ERROR("Cannot make union or intersection of directed "
                     "and undirected graph", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&edges1, no_edges_left * 2);
    IGRAPH_VECTOR_INIT_FINALLY(&edges2, no_edges_right * 2);
    IGRAPH_CHECK(igraph_vector_long_init(&order1, no_edges_left));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &order1);
    IGRAPH_CHECK(igraph_vector_long_init(&order2, no_edges_right));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &order2);

    if (edge_map1) {
        switch (mode) {
        case IGRAPH_MERGE_MODE_UNION:
            IGRAPH_CHECK(igraph_vector_resize(edge_map1, no_edges_left));
            break;
        case IGRAPH_MERGE_MODE_INTERSECTION:
            igraph_vector_clear(edge_map1);
            break;
        }
    }
    if (edge_map2) {
        switch (mode) {
        case IGRAPH_MERGE_MODE_UNION:
            IGRAPH_CHECK(igraph_vector_resize(edge_map2, no_edges_right));
            break;
        case IGRAPH_MERGE_MODE_INTERSECTION:
            igraph_vector_clear(edge_map2);
            break;
        }
    }

    no_of_nodes = no_of_nodes_left > no_of_nodes_right ?
                  no_of_nodes_left : no_of_nodes_right;

    /* We merge the two edge lists. We need to sort them first.
       For undirected graphs, we also need to make sure that
       for every edge, that larger (non-smaller) vertex id is in the
       second column. */

    IGRAPH_CHECK(igraph_get_edgelist(left, &edges1, /*bycol=*/ 0));
    IGRAPH_CHECK(igraph_get_edgelist(right, &edges2, /*bycol=*/ 0));
    if (!directed) {
        for (i = 0, j = 0; i < no_edges_left; i++, j += 2) {
            if (VECTOR(edges1)[j] > VECTOR(edges1)[j + 1]) {
                long int tmp = VECTOR(edges1)[j];
                VECTOR(edges1)[j] = VECTOR(edges1)[j + 1];
                VECTOR(edges1)[j + 1] = tmp;
            }
        }
        for (i = 0, j = 0; i < no_edges_right; i++, j += 2) {
            if (VECTOR(edges2)[j] > VECTOR(edges2)[j + 1]) {
                long int tmp = VECTOR(edges2)[j];
                VECTOR(edges2)[j] = VECTOR(edges2)[j + 1];
                VECTOR(edges2)[j + 1] = tmp;
            }
        }
    }

    for (i = 0; i < no_edges_left; i++) {
        VECTOR(order1)[i] = i;
    }
    for (i = 0; i < no_edges_right; i++) {
        VECTOR(order2)[i] = i;
    }

    igraph_qsort_r(VECTOR(order1), no_edges_left, sizeof(VECTOR(order1)[0]),
                   &edges1, igraph_i_order_edgelist_cmp);
    igraph_qsort_r(VECTOR(order2), no_edges_right, sizeof(VECTOR(order2)[0]),
                   &edges2, igraph_i_order_edgelist_cmp);

#define INC1() if ( (++idx1) < no_edges_left) {          \
        edge1 = VECTOR(order1)[idx1];                    \
        from1 = VECTOR(edges1)[2*edge1];                 \
        to1 = VECTOR(edges1)[2*edge1+1];                 \
    }
#define INC2() if ( (++idx2) < no_edges_right) {         \
        edge2 = VECTOR(order2)[idx2];                    \
        from2 = VECTOR(edges2)[2*edge2];                 \
        to2 = VECTOR(edges2)[2*edge2+1];                 \
    }

    idx1 = idx2 = -1;
    INC1();
    INC2();

#define CONT() switch (mode) {                               \
    case IGRAPH_MERGE_MODE_UNION:                            \
        l = idx1 < no_edges_left || idx2 < no_edges_right;   \
        break;                                               \
    case IGRAPH_MERGE_MODE_INTERSECTION:                     \
        l = idx1 < no_edges_left && idx2 < no_edges_right;   \
        break;                                               \
    default:                                                 \
        IGRAPH_ASSERT(! "Invalid merge mode.");              \
    }

    CONT();
    while (l) {
        if (idx2 >= no_edges_right ||
            (idx1 < no_edges_left && from1 < from2) ||
            (idx1 < no_edges_left && from1 == from2 && to1 < to2)) {
            /* Edge from first graph */
            if (mode == IGRAPH_MERGE_MODE_UNION) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, from1));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, to1));
                if (edge_map1) {
                    VECTOR(*edge_map1)[edge1] = eptr;
                }
                eptr++;
            }
            INC1();
        } else if (idx1 >= no_edges_left ||
                   (idx2 < no_edges_right && from2 < from1) ||
                   (idx2 < no_edges_right && from1 == from2 && to2 < to1)) {
            /* Edge from second graph */
            if (mode == IGRAPH_MERGE_MODE_UNION) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, from2));
                IGRAPH_CHECK(igraph_vector_push_back(&edges, to2));
                if (edge_map2) {
                    VECTOR(*edge_map2)[edge2] = eptr;
                }
                eptr++;
            }
            INC2();
        } else {
            /* Edge from both */
            IGRAPH_CHECK(igraph_vector_push_back(&edges, from1));
            IGRAPH_CHECK(igraph_vector_push_back(&edges, to1));
            if (mode == IGRAPH_MERGE_MODE_UNION) {
                if (edge_map1) {
                    VECTOR(*edge_map1)[edge1] = eptr;
                }
                if (edge_map2) {
                    VECTOR(*edge_map2)[edge2] = eptr;
                }
            } else if (mode == IGRAPH_MERGE_MODE_INTERSECTION) {
                if (edge_map1) {
                    IGRAPH_CHECK(igraph_vector_push_back(edge_map1, edge1));
                }
                if (edge_map2) {
                    IGRAPH_CHECK(igraph_vector_push_back(edge_map2, edge2));
                }
            }
            eptr++;
            INC1();
            INC2();
        }
        CONT();
    }

#undef INC1
#undef INC2

    igraph_vector_long_destroy(&order2);
    igraph_vector_long_destroy(&order1);
    igraph_vector_destroy(&edges2);
    igraph_vector_destroy(&edges1);
    IGRAPH_FINALLY_CLEAN(4);

    IGRAPH_CHECK(igraph_create(res, &edges, no_of_nodes, directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/misc_internal.h0000644000175100001710000000307400000000000025463 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2020  The igraph development team
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_OPERATORS_MISC_INTERNAL_H
#define IGRAPH_OPERATORS_MISC_INTERNAL_H

#include "igraph_decls.h"
#include "igraph_datatype.h"
#include "igraph_vector.h"
#include "igraph_vector_ptr.h"

__BEGIN_DECLS

#define IGRAPH_MERGE_MODE_UNION        1
#define IGRAPH_MERGE_MODE_INTERSECTION 2

int igraph_i_order_edgelist_cmp(void *edges, const void *e1, const void *e2);
int igraph_i_merge(igraph_t *res, int mode,
                   const igraph_t *left, const igraph_t *right,
                   igraph_vector_t *edge_map1, igraph_vector_t *edge_map2);
void igraph_i_union_intersection_destroy_vectors(igraph_vector_ptr_t *v);
void igraph_i_union_intersection_destroy_vector_longs(igraph_vector_ptr_t *v);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/permute.c0000644000175100001710000000675100000000000024315 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "graph/attributes.h"

/**
 * \function igraph_permute_vertices
 * Permute the vertices
 *
 * This function creates a new graph from the input graph by permuting
 * its vertices according to the specified mapping. Call this function
 * with the output of \ref igraph_canonical_permutation() to create
 * the canonical form of a graph.
 * \param graph The input graph.
 * \param res Pointer to an uninitialized graph object. The new graph
 *    is created here.
 * \param permutation The permutation to apply. Vertex 0 is mapped to
 *    the first element of the vector, vertex 1 to the second,
 * etc. Note that it is not checked that the vector contains every
 *    element only once, and no range checking is performed either.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in terms of the number of
 * vertices and edges.
 */
int igraph_permute_vertices(const igraph_t *graph, igraph_t *res,
                            const igraph_vector_t *permutation) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t edges;
    long int i, p = 0;

    if (igraph_vector_size(permutation) != no_of_nodes) {
        IGRAPH_ERROR("Permute vertices: invalid permutation vector size", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);

    for (i = 0; i < no_of_edges; i++) {
        VECTOR(edges)[p++] = VECTOR(*permutation)[ (long int) IGRAPH_FROM(graph, i) ];
        VECTOR(edges)[p++] = VECTOR(*permutation)[ (long int) IGRAPH_TO(graph, i) ];
    }

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               igraph_is_directed(graph)));

    /* Attributes */
    if (graph->attr) {
        igraph_vector_t index;
        igraph_vector_t vtypes;
        IGRAPH_I_ATTRIBUTE_DESTROY(res);
        IGRAPH_I_ATTRIBUTE_COPY(res, graph, /*graph=*/1, /*vertex=*/0, /*edge=*/1);
        IGRAPH_VECTOR_INIT_FINALLY(&vtypes, 0);
        IGRAPH_CHECK(igraph_i_attribute_get_info(graph, 0, 0, 0, &vtypes, 0, 0));
        if (igraph_vector_size(&vtypes) != 0) {
            IGRAPH_VECTOR_INIT_FINALLY(&index, no_of_nodes);
            for (i = 0; i < no_of_nodes; i++) {
                VECTOR(index)[ (long int) VECTOR(*permutation)[i] ] = i;
            }
            IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, res, &index));
            igraph_vector_destroy(&index);
            IGRAPH_FINALLY_CLEAN(1);
        }
        igraph_vector_destroy(&vtypes);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/rewire.c0000644000175100001710000002511500000000000024124 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_adjlist.h"
#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_iterators.h"
#include "igraph_progress.h"
#include "igraph_random.h"
#include "igraph_structural.h"

#include "core/interruption.h"
#include "operators/rewire_internal.h"

/* Threshold that defines when to switch over to using adjacency lists during
 * rewiring */
#define REWIRE_ADJLIST_THRESHOLD 10

/* Not declared static so that the testsuite can use it, but not part of the public API. */
int igraph_i_rewire(igraph_t *graph, igraph_integer_t n, igraph_rewiring_t mode, igraph_bool_t use_adjlist) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    char message[256];
    igraph_integer_t a, b, c, d, dummy, num_swaps, num_successful_swaps;
    igraph_vector_t eids, edgevec, alledges;
    igraph_bool_t directed, loops, ok;
    igraph_es_t es;
    igraph_adjlist_t al;

    if (no_of_nodes < 4) {
        IGRAPH_ERROR("graph unsuitable for rewiring", IGRAPH_EINVAL);
    }

    directed = igraph_is_directed(graph);
    loops = (mode & IGRAPH_REWIRING_SIMPLE_LOOPS);

    RNG_BEGIN();

    IGRAPH_VECTOR_INIT_FINALLY(&eids, 2);

    if (use_adjlist) {
        /* As well as the sorted adjacency list, we maintain an unordered
         * list of edges for picking a random edge in constant time.
         */
        IGRAPH_CHECK(igraph_adjlist_init(graph, &al, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &al);
        IGRAPH_VECTOR_INIT_FINALLY(&alledges, no_of_edges * 2);
        igraph_get_edgelist(graph, &alledges, /*bycol=*/ 0);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&edgevec, 4);
        es = igraph_ess_vector(&eids);
    }

    /* We don't want the algorithm to get stuck in an infinite loop when
     * it can't choose two edges satisfying the conditions. Instead of
     * this, we choose two arbitrary edges and if they have endpoints
     * in common, we just decrease the number of trials left and continue
     * (so unsuccessful rewirings still count as a trial)
     */

    num_swaps = num_successful_swaps = 0;
    while (num_swaps < n) {

        IGRAPH_ALLOW_INTERRUPTION();
        if (num_swaps % 1000 == 0) {
            snprintf(message, sizeof(message),
                     "Random rewiring (%.2f%% of the trials were successful)",
                     num_swaps > 0 ? ((100.0 * num_successful_swaps) / num_swaps) : 0.0);
            IGRAPH_PROGRESS(message, (100.0 * num_swaps) / n, 0);
        }

        switch (mode) {
        case IGRAPH_REWIRING_SIMPLE:
        case IGRAPH_REWIRING_SIMPLE_LOOPS:
            ok = 1;

            /* Choose two edges randomly */
            VECTOR(eids)[0] = RNG_INTEGER(0, no_of_edges - 1);
            do {
                VECTOR(eids)[1] = RNG_INTEGER(0, no_of_edges - 1);
            } while (VECTOR(eids)[0] == VECTOR(eids)[1]);

            /* Get the endpoints */
            if (use_adjlist) {
                a = VECTOR(alledges)[((igraph_integer_t)VECTOR(eids)[0]) * 2];
                b = VECTOR(alledges)[(((igraph_integer_t)VECTOR(eids)[0]) * 2) + 1];
                c = VECTOR(alledges)[((igraph_integer_t)VECTOR(eids)[1]) * 2];
                d = VECTOR(alledges)[(((igraph_integer_t)VECTOR(eids)[1]) * 2) + 1];
            } else {
                IGRAPH_CHECK(igraph_edge(graph, (igraph_integer_t) VECTOR(eids)[0],
                                         &a, &b));
                IGRAPH_CHECK(igraph_edge(graph, (igraph_integer_t) VECTOR(eids)[1],
                                         &c, &d));
            }

            /* For an undirected graph, we have two "variants" of each edge, i.e.
             * a -- b and b -- a. Since some rewirings can be performed only when we
             * "swap" the endpoints, we do it now with probability 0.5 */
            if (!directed && RNG_UNIF01() < 0.5) {
                dummy = c; c = d; d = dummy;
                if (use_adjlist) {
                    /* Flip the edge in the unordered edge-list, so the update later on
                     * hits the correct end. */
                    VECTOR(alledges)[((igraph_integer_t)VECTOR(eids)[1]) * 2] = c;
                    VECTOR(alledges)[(((igraph_integer_t)VECTOR(eids)[1]) * 2) + 1] = d;
                }
            }

            /* If we do not touch loops, check whether a == b or c == d and disallow
             * the swap if needed */
            if (!loops && (a == b || c == d)) {
                ok = 0;
            } else {
                /* Check whether they are suitable for rewiring */
                if (a == c || b == d) {
                    /* Swapping would have no effect */
                    ok = 0;
                } else {
                    /* a != c && b != d */
                    /* If a == d or b == c, the swap would generate at least one loop, so
                     * we disallow them unless we want to have loops */
                    ok = loops || (a != d && b != c);
                    /* Also, if a == b and c == d and we allow loops, doing the swap
                     * would result in a multiple edge if the graph is undirected */
                    ok = ok && (directed || a != b || c != d);
                }
            }

            /* All good so far. Now check for the existence of a --> d and c --> b to
             * disallow the creation of multiple edges */
            if (ok) {
                if (use_adjlist) {
                    if (igraph_adjlist_has_edge(&al, a, d, directed)) {
                        ok = 0;
                    }
                } else {
                    IGRAPH_CHECK(igraph_are_connected(graph, a, d, &ok));
                    ok = !ok;
                }
            }
            if (ok) {
                if (use_adjlist) {
                    if (igraph_adjlist_has_edge(&al, c, b, directed)) {
                        ok = 0;
                    }
                } else {
                    IGRAPH_CHECK(igraph_are_connected(graph, c, b, &ok));
                    ok = !ok;
                }
            }

            /* If we are still okay, we can perform the rewiring */
            if (ok) {
                /* printf("Deleting: %ld -> %ld, %ld -> %ld\n",
                              (long)a, (long)b, (long)c, (long)d); */
                if (use_adjlist) {
                    /* Replace entry in sorted adjlist: */
                    IGRAPH_CHECK(igraph_adjlist_replace_edge(&al, a, b, d, directed));
                    IGRAPH_CHECK(igraph_adjlist_replace_edge(&al, c, d, b, directed));
                    /* Also replace in unsorted edgelist: */
                    VECTOR(alledges)[(((igraph_integer_t)VECTOR(eids)[0]) * 2) + 1] = d;
                    VECTOR(alledges)[(((igraph_integer_t)VECTOR(eids)[1]) * 2) + 1] = b;
                } else {
                    IGRAPH_CHECK(igraph_delete_edges(graph, es));
                    VECTOR(edgevec)[0] = a; VECTOR(edgevec)[1] = d;
                    VECTOR(edgevec)[2] = c; VECTOR(edgevec)[3] = b;
                    /* printf("Adding: %ld -> %ld, %ld -> %ld\n",
                                (long)a, (long)d, (long)c, (long)b); */
                    igraph_add_edges(graph, &edgevec, 0);
                }
                num_successful_swaps++;
            }
            break;
        default:
            RNG_END();
            IGRAPH_ERROR("unknown rewiring mode", IGRAPH_EINVMODE);
        }
        num_swaps++;
    }

    if (use_adjlist) {
        /* Replace graph edges with the adjlist current state */
        IGRAPH_CHECK(igraph_delete_edges(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID)));
        IGRAPH_CHECK(igraph_add_edges(graph, &alledges, 0));
    }

    IGRAPH_PROGRESS("Random rewiring: ", 100.0, 0);

    if (use_adjlist) {
        igraph_vector_destroy(&alledges);
        igraph_adjlist_destroy(&al);
    } else {
        igraph_vector_destroy(&edgevec);
    }

    igraph_vector_destroy(&eids);
    IGRAPH_FINALLY_CLEAN(use_adjlist ? 3 : 2);

    RNG_END();

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_rewire
 * \brief Randomly rewires a graph while preserving the degree distribution.
 *
 * 
 * This function generates a new graph based on the original one by randomly
 * rewiring edges while preserving the original graph's degree distribution.
 * Please note that the rewiring is done "in place", so no new graph will
 * be allocated. If you would like to keep the original graph intact, use
 * \ref igraph_copy() beforehand.
 *
 * \param graph The graph object to be rewired.
 * \param n Number of rewiring trials to perform.
 * \param mode The rewiring algorithm to be used. It can be one of the following flags:
 *         \clist
 *           \cli IGRAPH_REWIRING_SIMPLE
 *                Simple rewiring algorithm which chooses two arbitrary edges
 *                in each step (namely (a,b) and (c,d)) and substitutes them
 *                with (a,d) and (c,b) if they don't exist.  The method will
 *                neither destroy nor create self-loops.
 *           \cli IGRAPH_REWIRING_SIMPLE_LOOPS
 *                Same as \c IGRAPH_REWIRING_SIMPLE but allows the creation or
 *                destruction of self-loops.
 *         \endclist
 *
 * \return Error code:
 *         \clist
 *           \cli IGRAPH_EINVMODE
 *                Invalid rewiring mode.
 *           \cli IGRAPH_EINVAL
 *                Graph unsuitable for rewiring (e.g. it has
 *                less than 4 nodes in case of \c IGRAPH_REWIRING_SIMPLE)
 *           \cli IGRAPH_ENOMEM
 *                Not enough memory for temporary data.
 *         \endclist
 *
 * Time complexity: TODO.
 */
int igraph_rewire(igraph_t *graph, igraph_integer_t n, igraph_rewiring_t mode) {
    igraph_bool_t use_adjlist = n >= REWIRE_ADJLIST_THRESHOLD;
    return igraph_i_rewire(graph, n, mode, use_adjlist);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/rewire_edges.c0000644000175100001710000003246200000000000025276 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_games.h"

#include "igraph_conversion.h"
#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_random.h"

#include "graph/attributes.h"

static int igraph_i_rewire_edges_no_multiple(igraph_t *graph, igraph_real_t prob,
                                             igraph_bool_t loops,
                                             igraph_vector_t *edges) {

    int no_verts = igraph_vcount(graph);
    int no_edges = igraph_ecount(graph);
    igraph_vector_t eorder, tmp;
    igraph_vector_int_t first, next, prev, marked;
    int i, to_rewire, last_other = -1;

    /* Create our special graph representation */

# define ADD_STUB(vertex, stub) do {                \
        if (VECTOR(first)[(vertex)]) {              \
            VECTOR(prev)[(int) VECTOR(first)[(vertex)]-1]=(stub)+1;   \
        }                               \
        VECTOR(next)[(stub)]=VECTOR(first)[(vertex)];       \
        VECTOR(prev)[(stub)]=0;                 \
        VECTOR(first)[(vertex)]=(stub)+1;               \
    } while (0)

# define DEL_STUB(vertex, stub) do {                    \
        if (VECTOR(next)[(stub)]) {                     \
            VECTOR(prev)[VECTOR(next)[(stub)]-1]=VECTOR(prev)[(stub)];    \
        }                                   \
        if (VECTOR(prev)[(stub)]) {                     \
            VECTOR(next)[VECTOR(prev)[(stub)]-1]=VECTOR(next)[(stub)];    \
        } else {                                \
            VECTOR(first)[(vertex)]=VECTOR(next)[(stub)];         \
        }                                   \
    } while (0)

# define MARK_NEIGHBORS(vertex) do {                \
        int xxx_ =VECTOR(first)[(vertex)];              \
        while (xxx_) {                      \
            int o= (int) VECTOR(*edges)[xxx_ % 2 ? xxx_ : xxx_-2];    \
            VECTOR(marked)[o]=other+1;                \
            xxx_=VECTOR(next)[xxx_-1];                \
        }                               \
    } while (0)

    IGRAPH_CHECK(igraph_vector_int_init(&first, no_verts));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &first);
    IGRAPH_CHECK(igraph_vector_int_init(&next, no_edges * 2));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &next);
    IGRAPH_CHECK(igraph_vector_int_init(&prev, no_edges * 2));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &prev);
    IGRAPH_CHECK(igraph_get_edgelist(graph, edges, /*bycol=*/ 0));
    IGRAPH_VECTOR_INIT_FINALLY(&eorder, no_edges);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, no_edges);
    for (i = 0; i < no_edges; i++) {
        int idx1 = 2 * i, idx2 = idx1 + 1,
            from = (int) VECTOR(*edges)[idx1], to = (int) VECTOR(*edges)[idx2];
        VECTOR(tmp)[i] = from;
        ADD_STUB(from, idx1);
        ADD_STUB(to, idx2);
    }
    IGRAPH_CHECK(igraph_vector_order1(&tmp, &eorder, no_verts));
    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_vector_int_init(&marked, no_verts));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);

    /* Rewire the stubs, part I */

    to_rewire = (int) RNG_GEOM(prob);
    while (to_rewire < no_edges) {
        int stub = (int) (2 * VECTOR(eorder)[to_rewire] + 1);
        int v = (int) VECTOR(*edges)[stub];
        int ostub = stub - 1;
        int other = (int) VECTOR(*edges)[ostub];
        int pot;
        if (last_other != other) {
            MARK_NEIGHBORS(other);
        }
        /* Do the rewiring */
        do {
            if (loops) {
                pot = (int) RNG_INTEGER(0, no_verts - 1);
            } else {
                pot = (int) RNG_INTEGER(0, no_verts - 2);
                pot = pot != other ? pot : no_verts - 1;
            }
        } while (VECTOR(marked)[pot] == other + 1 && pot != v);

        if (pot != v) {
            DEL_STUB(v, stub);
            ADD_STUB(pot, stub);
            VECTOR(marked)[v] = 0;
            VECTOR(marked)[pot] = other + 1;
            VECTOR(*edges)[stub] = pot;
        }

        to_rewire += RNG_GEOM(prob) + 1;
        last_other = other;
    }

    /* Create the new index, from the potentially rewired stubs */

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, no_edges);
    for (i = 0; i < no_edges; i++) {
        VECTOR(tmp)[i] = VECTOR(*edges)[2 * i + 1];
    }
    IGRAPH_CHECK(igraph_vector_order1(&tmp, &eorder, no_verts));
    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    /* Rewire the stubs, part II */

    igraph_vector_int_null(&marked);
    last_other = -1;

    to_rewire = (int) RNG_GEOM(prob);
    while (to_rewire < no_edges) {
        int stub = (int) (2 * VECTOR(eorder)[to_rewire]);
        int v = (int) VECTOR(*edges)[stub];
        int ostub = stub + 1;
        int other = (int) VECTOR(*edges)[ostub];
        int pot;
        if (last_other != other) {
            MARK_NEIGHBORS(other);
        }
        /* Do the rewiring */
        do {
            if (loops) {
                pot = (int) RNG_INTEGER(0, no_verts - 1);
            } else {
                pot = (int) RNG_INTEGER(0, no_verts - 2);
                pot = pot != other ? pot : no_verts - 1;
            }
        } while (VECTOR(marked)[pot] == other + 1 && pot != v);
        if (pot != v) {
            DEL_STUB(v, stub);
            ADD_STUB(pot, stub);
            VECTOR(marked)[v] = 0;
            VECTOR(marked)[pot] = other + 1;
            VECTOR(*edges)[stub] = pot;
        }

        to_rewire += RNG_GEOM(prob) + 1;
        last_other = other;
    }

    igraph_vector_int_destroy(&marked);
    igraph_vector_int_destroy(&prev);
    igraph_vector_int_destroy(&next);
    igraph_vector_int_destroy(&first);
    igraph_vector_destroy(&eorder);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}

#undef ADD_STUB
#undef DEL_STUB
#undef MARK_NEIGHBORS

/**
 * \function igraph_rewire_edges
 * \brief Rewires the edges of a graph with constant probability.
 *
 * This function rewires the edges of a graph with a constant
 * probability. More precisely each end point of each edge is rewired
 * to a uniformly randomly chosen vertex with constant probability \p
 * prob.
 *
 *  Note that this function modifies the input \p graph,
 * call \ref igraph_copy() if you want to keep it.
 *
 * \param graph The input graph, this will be rewired, it can be
 *    directed or undirected.
 * \param prob The rewiring probability a constant between zero and
 *    one (inclusive).
 * \param loops Boolean, whether loop edges are allowed in the new
 *    graph, or not.
 * \param multiple Boolean, whether multiple edges are allowed in the
 *    new graph.
 * \return Error code.
 *
 * \sa \ref igraph_watts_strogatz_game() uses this function for the
 * rewiring.
 *
 * Time complexity: O(|V|+|E|).
 */
int igraph_rewire_edges(igraph_t *graph, igraph_real_t prob,
                        igraph_bool_t loops, igraph_bool_t multiple) {

    igraph_t newgraph;
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_nodes = igraph_vcount(graph);
    long int endpoints = no_of_edges * 2;
    long int to_rewire;
    igraph_vector_t edges;

    if (prob < 0 || prob > 1) {
        IGRAPH_ERROR("Rewiring probability should be between zero and one",
                     IGRAPH_EINVAL);
    }

    if (prob == 0) {
        /* This is easy, just leave things as they are */
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, endpoints);

    RNG_BEGIN();

    if (prob != 0 && no_of_edges > 0) {
        if (multiple) {
            /* If multiple edges are allowed, then there is an easy and fast
            method. Each endpoint of an edge is rewired with probability p,
             so the "skips" between the really rewired endpoints follow a
             geometric distribution. */
            IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));
            to_rewire = (long int) RNG_GEOM(prob);
            while (to_rewire < endpoints) {
                if (loops) {
                    VECTOR(edges)[to_rewire] = RNG_INTEGER(0, no_of_nodes - 1);
                } else {
                    long int opos = to_rewire % 2 ? to_rewire - 1 : to_rewire + 1;
                    long int nei = (long int) VECTOR(edges)[opos];
                    long int r = RNG_INTEGER(0, no_of_nodes - 2);
                    VECTOR(edges)[ to_rewire ] = (r != nei ? r : no_of_nodes - 1);
                }
                to_rewire += RNG_GEOM(prob) + 1;
            }

        } else {
            IGRAPH_CHECK(igraph_i_rewire_edges_no_multiple(graph, prob, loops,
                         &edges));
        }
    }

    RNG_END();

    IGRAPH_CHECK(igraph_create(&newgraph, &edges, (igraph_integer_t) no_of_nodes,
                               igraph_is_directed(graph)));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_FINALLY(igraph_destroy, &newgraph);
    IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
    IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1, 1);
    IGRAPH_FINALLY_CLEAN(1);
    igraph_destroy(graph);
    *graph = newgraph;

    return 0;
}

/**
 * \function igraph_rewire_directed_edges
 * \brief Rewires the chosen endpoint of directed edges.
 *
 * This function rewires either the start or end of directed edges in a graph
 * with a constant probability. Correspondingly, either the in-degree sequence
 * or the out-degree sequence of the graph will be preserved.
 *
 *  Note that this function modifies the input \p graph,
 * call \ref igraph_copy() if you want to keep it.
 *
 *  This function can produce multiple edges between two vertices.
 *
 * \param graph The input graph, this will be rewired, it can be
 *    directed or undirected. If it is undirected or \p mode is set to
 *    IGRAPH_ALL, \ref igraph_rewire_edges() will be called.
 * \param prob The rewiring probability, a constant between zero and
 *    one (inclusive).
 * \param loops Boolean, whether loop edges are allowed in the new
 *    graph, or not.
 * \param mode The endpoints of directed edges to rewire. It is ignored for
 *    undirected graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          rewire the end of each directed edge
 *        \cli IGRAPH_IN
 *          rewire the start of each directed edge
 *        \cli IGRAPH_ALL
 *          rewire both endpoints of each edge
 *        \endclist
 * \return Error code.
 *
 * \sa \ref igraph_rewire_edges(), \ref igraph_rewire()
 *
 * Time complexity: O(|E|).
 */
int igraph_rewire_directed_edges(igraph_t *graph, igraph_real_t prob,
                                 igraph_bool_t loops, igraph_neimode_t mode) {

    if (prob < 0 || prob > 1) {
        IGRAPH_ERROR("Rewiring probability should be between zero and one",
                     IGRAPH_EINVAL);
    }

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    if (prob == 0) {
        return IGRAPH_SUCCESS;
    }

    if (igraph_is_directed(graph) && mode != IGRAPH_ALL) {
        igraph_t newgraph;
        long int no_of_edges = igraph_ecount(graph);
        long int no_of_nodes = igraph_vcount(graph);
        long int to_rewire;
        long int offset = 0;
        igraph_vector_t edges;

        IGRAPH_VECTOR_INIT_FINALLY(&edges, 2 * no_of_edges);

        switch (mode) {
        case IGRAPH_IN:
            offset = 0;
            break;
        case IGRAPH_OUT:
            offset = 1;
            break;
        case IGRAPH_ALL:
            break; /* suppress compiler warning */
        }

        IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0));

        RNG_BEGIN();

        to_rewire = RNG_GEOM(prob);
        while (to_rewire < no_of_edges) {
            if (loops) {
                VECTOR(edges)[2 * to_rewire + offset] = RNG_INTEGER(0, no_of_nodes - 1);
            } else {
                long int nei = (long int) VECTOR(edges)[2 * to_rewire + (1 - offset)];
                long int r = RNG_INTEGER(0, no_of_nodes - 2);
                VECTOR(edges)[2 * to_rewire + offset] = (r != nei ? r : no_of_nodes - 1);
            }
            to_rewire += RNG_GEOM(prob) + 1;
        }

        RNG_END();

        IGRAPH_CHECK(igraph_create(&newgraph, &edges, (igraph_integer_t) no_of_nodes,
                                   igraph_is_directed(graph)));
        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);

        IGRAPH_FINALLY(igraph_destroy, &newgraph);
        IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph);
        IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, 1, 1, 1);
        IGRAPH_FINALLY_CLEAN(1);
        igraph_destroy(graph);
        *graph = newgraph;

    } else {
        IGRAPH_CHECK(igraph_rewire_edges(graph, prob, loops, /* multiple = */ 1));
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/rewire_internal.h0000644000175100001710000000040100000000000026014 0ustar00runnerdocker00000000000000#ifndef IGRAPH_OPERATORS_REWIRE_INTERNAL_H
#define IGRAPH_OPERATORS_REWIRE_INTERNAL_H

#include "igraph_interface.h"

IGRAPH_PRIVATE_EXPORT int igraph_i_rewire(igraph_t *graph, igraph_integer_t n, igraph_rewiring_t mode, igraph_bool_t use_adjlist);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/simplify.c0000644000175100001710000001316300000000000024463 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"

#include "core/fixed_vectorlist.h"
#include "graph/attributes.h"

/**
 * \ingroup structural
 * \function igraph_simplify
 * \brief Removes loop and/or multiple edges from the graph.
 *
 * \param graph The graph object.
 * \param multiple Logical, if true, multiple edges will be removed.
 * \param loops Logical, if true, loops (self edges) will be removed.
 * \param edge_comb What to do with the edge attributes. \c NULL means to
 *        discard the edge attributes after the operation, even for edges
 *        that were unaffeccted. See the igraph manual section about attributes
 *        for details.
 * \return Error code:
 *    \c IGRAPH_ENOMEM if we are out of memory.
 *
 * Time complexity: O(|V|+|E|).
 *
 * \example examples/simple/igraph_simplify.c
 */

int igraph_simplify(igraph_t *graph, igraph_bool_t multiple,
                    igraph_bool_t loops,
                    const igraph_attribute_combination_t *edge_comb) {

    igraph_vector_t edges = IGRAPH_VECTOR_NULL;
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int edge;
    igraph_bool_t attr = edge_comb && igraph_has_attribute_table();
    long int from, to, pfrom = -1, pto = -2;
    igraph_t res;
    igraph_es_t es;
    igraph_eit_t eit;
    igraph_vector_t mergeinto;
    long int actedge;

    if (!multiple && !loops)
        /* nothing to do */
    {
        return IGRAPH_SUCCESS;
    }

    if (!multiple) {
        /* removing loop edges only, this is simple. No need to combine anything
         * and the whole process can be done in-place */
        IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
        IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID));
        IGRAPH_FINALLY(igraph_es_destroy, &es);
        IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
        IGRAPH_FINALLY(igraph_eit_destroy, &eit);

        while (!IGRAPH_EIT_END(eit)) {
            edge = IGRAPH_EIT_GET(eit);
            from = IGRAPH_FROM(graph, edge);
            to = IGRAPH_TO(graph, edge);
            if (from == to) {
                IGRAPH_CHECK(igraph_vector_push_back(&edges, edge));
            }
            IGRAPH_EIT_NEXT(eit);
        }

        igraph_eit_destroy(&eit);
        igraph_es_destroy(&es);
        IGRAPH_FINALLY_CLEAN(2);

        if (igraph_vector_size(&edges) > 0) {
            IGRAPH_CHECK(igraph_delete_edges(graph, igraph_ess_vector(&edges)));
        }

        igraph_vector_destroy(&edges);
        IGRAPH_FINALLY_CLEAN(1);

        return IGRAPH_SUCCESS;
    }

    if (attr) {
        IGRAPH_VECTOR_INIT_FINALLY(&mergeinto, no_of_edges);
    }
    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&edges, no_of_edges * 2));

    IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_FROM));
    IGRAPH_FINALLY(igraph_es_destroy, &es);
    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    for (actedge = -1; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        edge = IGRAPH_EIT_GET(eit);
        from = IGRAPH_FROM(graph, edge);
        to = IGRAPH_TO(graph, edge);

        if (loops && from == to) {
            /* Loop edge to be removed */
            if (attr) {
                VECTOR(mergeinto)[edge] = -1;
            }
        } else if (multiple && from == pfrom && to == pto) {
            /* Multiple edge to be contracted */
            if (attr) {
                VECTOR(mergeinto)[edge] = actedge;
            }
        } else {
            /* Edge to be kept */
            igraph_vector_push_back(&edges, from);
            igraph_vector_push_back(&edges, to);
            if (attr) {
                actedge++;
                VECTOR(mergeinto)[edge] = actedge;
            }
        }
        pfrom = from; pto = to;
    }

    igraph_eit_destroy(&eit);
    igraph_es_destroy(&es);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_CHECK(igraph_create(&res, &edges, (igraph_integer_t) no_of_nodes,
                               igraph_is_directed(graph)));

    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_FINALLY(igraph_destroy, &res);

    IGRAPH_I_ATTRIBUTE_DESTROY(&res);
    IGRAPH_I_ATTRIBUTE_COPY(&res, graph, /*graph=*/ 1,
                            /*vertex=*/ 1, /*edge=*/ 0);

    if (attr) {
        igraph_fixed_vectorlist_t vl;
        IGRAPH_CHECK(igraph_fixed_vectorlist_convert(&vl, &mergeinto,
                     actedge + 1));
        IGRAPH_FINALLY(igraph_fixed_vectorlist_destroy, &vl);

        IGRAPH_CHECK(igraph_i_attribute_combine_edges(graph, &res, &vl.v,
                     edge_comb));

        igraph_fixed_vectorlist_destroy(&vl);
        igraph_vector_destroy(&mergeinto);
        IGRAPH_FINALLY_CLEAN(2);
    }

    IGRAPH_FINALLY_CLEAN(1);
    igraph_destroy(graph);
    *graph = res;

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/subgraph.c0000644000175100001710000004231100000000000024437 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "core/interruption.h"
#include "graph/attributes.h"
#include "operators/subgraph.h"

/**
 * Subgraph creation, old version: it copies the graph and then deletes
 * unneeded vertices.
 */
static int igraph_i_induced_subgraph_copy_and_delete(
    const igraph_t *graph, igraph_t *res, const igraph_vs_t vids,
    igraph_vector_t *map, igraph_vector_t *invmap
) {
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t delete = IGRAPH_VECTOR_NULL;
    char *remain;
    long int i;
    igraph_vit_t vit;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    IGRAPH_VECTOR_INIT_FINALLY(&delete, 0);
    remain = IGRAPH_CALLOC(no_of_nodes, char);
    if (remain == 0) {
        IGRAPH_ERROR("subgraph failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, remain);
    IGRAPH_CHECK(igraph_vector_reserve(&delete, no_of_nodes - IGRAPH_VIT_SIZE(vit)));

    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        remain[ (long int) IGRAPH_VIT_GET(vit) ] = 1;
    }

    for (i = 0; i < no_of_nodes; i++) {

        IGRAPH_ALLOW_INTERRUPTION();

        if (remain[i] == 0) {
            IGRAPH_CHECK(igraph_vector_push_back(&delete, i));
        }
    }

    IGRAPH_FREE(remain);
    IGRAPH_FINALLY_CLEAN(1);

    /* must set res->attr to 0 before calling igraph_copy */
    res->attr = 0;         /* Why is this needed? TODO */
    IGRAPH_CHECK(igraph_copy(res, graph));
    IGRAPH_FINALLY(igraph_destroy, res);
    IGRAPH_CHECK(igraph_delete_vertices_idx(res, igraph_vss_vector(&delete),
                                            map, invmap));

    igraph_vector_destroy(&delete);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}

/**
 * Subgraph creation, new version: creates the new graph instead of
 * copying the old one.
 *
 * map_is_prepared is an indicator that the caller has already prepared the
 * 'map' vector and that this function should not resize or clear it. This
 * is used to spare an O(n) operation (where n is the number of vertices in
 * the _original_ graph) in cases when induced_subgraph() is repeatedly
 * called on the same graph; one example is igraph_decompose().
 */
static int igraph_i_induced_subgraph_create_from_scratch(
    const igraph_t *graph, igraph_t *res, const igraph_vs_t vids,
    igraph_vector_t *map, igraph_vector_t *invmap,
    igraph_bool_t map_is_prepared
) {
    igraph_bool_t directed = igraph_is_directed(graph);
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_new_nodes = 0;
    long int i, j, n;
    long int to;
    igraph_integer_t eid;
    igraph_vector_t vids_old2new, vids_new2old;
    igraph_vector_t eids_new2old;
    igraph_vector_t nei_edges;
    igraph_vector_t new_edges;
    igraph_vit_t vit;
    igraph_vector_t *my_vids_old2new = &vids_old2new,
                     *my_vids_new2old = &vids_new2old;

    /* The order of initialization is important here, they will be destroyed in the
     * opposite order */
    IGRAPH_VECTOR_INIT_FINALLY(&eids_new2old, 0);
    if (invmap) {
        my_vids_new2old = invmap;
        igraph_vector_clear(my_vids_new2old);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&vids_new2old, 0);
    }
    IGRAPH_VECTOR_INIT_FINALLY(&new_edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&nei_edges, 0);
    if (map) {
        my_vids_old2new = map;
        if (!map_is_prepared) {
            IGRAPH_CHECK(igraph_vector_resize(map, no_of_nodes));
            igraph_vector_null(map);
        }
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&vids_old2new, no_of_nodes);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    /* Calculate the mapping from the old node IDs to the new ones. The other
     * igraph_simplify implementation in igraph_i_simplify_copy_and_delete
     * ensures that the order of vertex IDs is kept during remapping (i.e.
     * if the old ID of vertex A is less than the old ID of vertex B, then
     * the same will also be true for the new IDs). To ensure compatibility
     * with the other implementation, we have to fetch the vertex IDs into
     * a vector first and then sort it. We temporarily use new_edges for that.
     */
    IGRAPH_CHECK(igraph_vit_as_vector(&vit, &nei_edges));
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_vector_sort(&nei_edges);
    n = igraph_vector_size(&nei_edges);
    for (i = 0; i < n; i++) {
        long int vid = (long int) VECTOR(nei_edges)[i];
        if (VECTOR(*my_vids_old2new)[vid] == 0) {
            IGRAPH_CHECK(igraph_vector_push_back(my_vids_new2old, vid));
            no_of_new_nodes++;
            VECTOR(*my_vids_old2new)[vid] = no_of_new_nodes;
        }
    }

    /* Create the new edge list */
    for (i = 0; i < no_of_new_nodes; i++) {
        long int old_vid = (long int) VECTOR(*my_vids_new2old)[i];
        long int new_vid = i;
        igraph_bool_t skip_loop_edge;

        IGRAPH_CHECK(igraph_incident(graph, &nei_edges, old_vid, IGRAPH_OUT));
        n = igraph_vector_size(&nei_edges);

        if (directed) {
            /* directed graph; this is easier */
            for (j = 0; j < n; j++) {
                eid = (igraph_integer_t) VECTOR(nei_edges)[j];

                to = (long int) VECTOR(*my_vids_old2new)[ (long int)IGRAPH_TO(graph, eid) ];
                if (!to) {
                    continue;
                }

                IGRAPH_CHECK(igraph_vector_push_back(&new_edges, new_vid));
                IGRAPH_CHECK(igraph_vector_push_back(&new_edges, to - 1));
                IGRAPH_CHECK(igraph_vector_push_back(&eids_new2old, eid));
            }
        } else {
            /* undirected graph. We need to be careful with loop edges as each
             * loop edge will appear twice. We use a boolean flag to skip every
             * second loop edge */
            skip_loop_edge = 0;
            for (j = 0; j < n; j++) {
                eid = (igraph_integer_t) VECTOR(nei_edges)[j];

                if (IGRAPH_FROM(graph, eid) != old_vid) {
                    /* avoid processing edges twice */
                    continue;
                }

                to = (long int) VECTOR(*my_vids_old2new)[ (long int)IGRAPH_TO(graph, eid) ];
                if (!to) {
                    continue;
                }
                to -= 1;

                if (new_vid == to) {
                    /* this is a loop edge; check whether we need to skip it */
                    skip_loop_edge = !skip_loop_edge;
                    if (skip_loop_edge) {
                        continue;
                    }
                }

                IGRAPH_CHECK(igraph_vector_push_back(&new_edges, new_vid));
                IGRAPH_CHECK(igraph_vector_push_back(&new_edges, to));
                IGRAPH_CHECK(igraph_vector_push_back(&eids_new2old, eid));
            }
        }
    }

    /* Get rid of some vectors that are not needed anymore */
    if (!map) {
        igraph_vector_destroy(&vids_old2new);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_destroy(&nei_edges);
    IGRAPH_FINALLY_CLEAN(1);

    /* Create the new graph */
    IGRAPH_CHECK(igraph_create(res, &new_edges, (igraph_integer_t)
                               no_of_new_nodes, directed));
    IGRAPH_I_ATTRIBUTE_DESTROY(res);

    /* Now we can also get rid of the new_edges vector */
    igraph_vector_destroy(&new_edges);
    IGRAPH_FINALLY_CLEAN(1);

    /* Make sure that the newly created graph is destroyed if something happens from
     * now on */
    IGRAPH_FINALLY(igraph_destroy, res);

    /* Copy the graph attributes */
    IGRAPH_CHECK(igraph_i_attribute_copy(res, graph,
                                         /* ga = */ 1, /* va = */ 0, /* ea = */ 0));

    /* Copy the vertex attributes */
    IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, res,
                 my_vids_new2old));

    /* Copy the edge attributes */
    IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, res, &eids_new2old));

    if (!invmap) {
        igraph_vector_destroy(my_vids_new2old);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_destroy(&eids_new2old);
    IGRAPH_FINALLY_CLEAN(2);   /* 1 + 1 since we don't need to destroy res */

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_induced_subgraph
 * \brief Creates a subgraph induced by the specified vertices.
 *
 * 
 * This function collects the specified vertices and all edges between
 * them to a new graph.
 * As the vertex ids in a graph always start with zero, this function
 * very likely needs to reassign ids to the vertices.
 * \param graph The graph object.
 * \param res The subgraph, another graph object will be stored here,
 *        do \em not initialize this object before calling this
 *        function, and call \ref igraph_destroy() on it if you don't need
 *        it any more.
 * \param vids A vertex selector describing which vertices to keep.
 * \param impl This parameter selects which implementation should we
 *        use when constructing the new graph. Basically there are two
 *        possibilities: \c IGRAPH_SUBGRAPH_COPY_AND_DELETE copies the
 *        existing graph and deletes the vertices that are not needed
 *        in the new graph, while \c IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH
 *        constructs the new graph from scratch without copying the old
 *        one. The latter is more efficient if you are extracting a
 *        relatively small subpart of a very large graph, while the
 *        former is better if you want to extract a subgraph whose size
 *        is comparable to the size of the whole graph. There is a third
 *        possibility: \c IGRAPH_SUBGRAPH_AUTO will select one of the
 *        two methods automatically based on the ratio of the number
 *        of vertices in the new and the old graph.
 *
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *         \c IGRAPH_EINVVID, invalid vertex id in
 *         \p vids.
 *
 * Time complexity: O(|V|+|E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the original graph.
 *
 * \sa \ref igraph_delete_vertices() to delete the specified set of
 * vertices from a graph, the opposite of this function.
 */
int igraph_induced_subgraph(const igraph_t *graph, igraph_t *res,
                            const igraph_vs_t vids, igraph_subgraph_implementation_t impl) {
    return igraph_induced_subgraph_map(graph, res, vids, impl, /* map= */ 0,
                                       /* invmap= */ 0);
}

static int igraph_i_induced_subgraph_suggest_implementation(
        const igraph_t *graph, const igraph_vs_t vids,
        igraph_subgraph_implementation_t *result) {
    double ratio;
    igraph_integer_t num_vs;

    if (igraph_vs_is_all(&vids)) {
        ratio = 1.0;
    } else {
        IGRAPH_CHECK(igraph_vs_size(graph, &vids, &num_vs));
        ratio = (igraph_real_t) num_vs / igraph_vcount(graph);
    }

    /* TODO: needs benchmarking; threshold was chosen totally arbitrarily */
    if (ratio > 0.5) {
        *result = IGRAPH_SUBGRAPH_COPY_AND_DELETE;
    } else {
        *result = IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH;
    }

    return 0;
}

int igraph_i_induced_subgraph_map(const igraph_t *graph, igraph_t *res,
                                  const igraph_vs_t vids,
                                  igraph_subgraph_implementation_t impl,
                                  igraph_vector_t *map,
                                  igraph_vector_t *invmap,
                                  igraph_bool_t map_is_prepared) {

    if (impl == IGRAPH_SUBGRAPH_AUTO) {
        IGRAPH_CHECK(igraph_i_induced_subgraph_suggest_implementation(graph, vids, &impl));
    }

    switch (impl) {
    case IGRAPH_SUBGRAPH_COPY_AND_DELETE:
        return igraph_i_induced_subgraph_copy_and_delete(graph, res, vids, map, invmap);

    case IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH:
        return igraph_i_induced_subgraph_create_from_scratch(graph, res, vids, map,
                invmap, /* map_is_prepared = */ map_is_prepared);

    default:
        IGRAPH_ERROR("unknown subgraph implementation type", IGRAPH_EINVAL);
    }
}

int igraph_induced_subgraph_map(const igraph_t *graph, igraph_t *res,
                                const igraph_vs_t vids,
                                igraph_subgraph_implementation_t impl,
                                igraph_vector_t *map,
                                igraph_vector_t *invmap) {
    return igraph_i_induced_subgraph_map(graph, res,vids, impl, map, invmap, /* map_is_prepared = */ 0);
}

/**
 * \ingroup structural
 * \function igraph_subgraph_edges
 * \brief Creates a subgraph with the specified edges and their endpoints.
 *
 * 
 * This function collects the specified edges and their endpoints to a new
 * graph.
 * As the vertex ids in a graph always start with zero, this function
 * very likely needs to reassign ids to the vertices.
 * \param graph The graph object.
 * \param res The subgraph, another graph object will be stored here,
 *        do \em not initialize this object before calling this
 *        function, and call \ref igraph_destroy() on it if you don't need
 *        it any more.
 * \param eids An edge selector describing which edges to keep.
 * \param delete_vertices Whether to delete the vertices not incident on any
 *        of the specified edges as well. If \c FALSE, the number of vertices
 *        in the result graph will always be equal to the number of vertices
 *        in the input graph.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *         \c IGRAPH_EINVEID, invalid edge id in
 *         \p eids.
 *
 * Time complexity: O(|V|+|E|),
 * |V| and
 * |E| are the number of vertices and
 * edges in the original graph.
 *
 * \sa \ref igraph_delete_edges() to delete the specified set of
 * edges from a graph, the opposite of this function.
 */

int igraph_subgraph_edges(const igraph_t *graph, igraph_t *res,
                          const igraph_es_t eids, igraph_bool_t delete_vertices) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vector_t delete = IGRAPH_VECTOR_NULL;
    char *vremain, *eremain;
    long int i;
    igraph_eit_t eit;

    IGRAPH_CHECK(igraph_eit_create(graph, eids, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    IGRAPH_VECTOR_INIT_FINALLY(&delete, 0);
    vremain = IGRAPH_CALLOC(no_of_nodes, char);
    if (vremain == 0) {
        IGRAPH_ERROR("subgraph_edges failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, vremain);
    eremain = IGRAPH_CALLOC(no_of_edges, char);
    if (eremain == 0) {
        IGRAPH_ERROR("subgraph_edges failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, eremain);
    IGRAPH_CHECK(igraph_vector_reserve(&delete, no_of_edges - IGRAPH_EIT_SIZE(eit)));

    /* Collect the vertex and edge IDs that will remain */
    for (IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        igraph_integer_t from, to;
        long int eid = (long int) IGRAPH_EIT_GET(eit);
        IGRAPH_CHECK(igraph_edge(graph, (igraph_integer_t) eid, &from, &to));
        eremain[eid] = vremain[(long int)from] = vremain[(long int)to] = 1;
    }

    /* Collect the edge IDs to be deleted */
    for (i = 0; i < no_of_edges; i++) {
        IGRAPH_ALLOW_INTERRUPTION();
        if (eremain[i] == 0) {
            IGRAPH_CHECK(igraph_vector_push_back(&delete, i));
        }
    }

    IGRAPH_FREE(eremain);
    IGRAPH_FINALLY_CLEAN(1);

    /* Delete the unnecessary edges */
    /* must set res->attr to 0 before calling igraph_copy */
    res->attr = 0;         /* Why is this needed? TODO */
    IGRAPH_CHECK(igraph_copy(res, graph));
    IGRAPH_FINALLY(igraph_destroy, res);
    IGRAPH_CHECK(igraph_delete_edges(res, igraph_ess_vector(&delete)));

    if (delete_vertices) {
        /* Collect the vertex IDs to be deleted */
        igraph_vector_clear(&delete);
        for (i = 0; i < no_of_nodes; i++) {
            IGRAPH_ALLOW_INTERRUPTION();
            if (vremain[i] == 0) {
                IGRAPH_CHECK(igraph_vector_push_back(&delete, i));
            }
        }
    }

    IGRAPH_FREE(vremain);
    IGRAPH_FINALLY_CLEAN(1);

    /* Delete the unnecessary vertices */
    if (delete_vertices) {
        IGRAPH_CHECK(igraph_delete_vertices(res, igraph_vss_vector(&delete)));
    }

    igraph_vector_destroy(&delete);
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(3);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/subgraph.h0000644000175100001710000000232300000000000024443 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2003-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifndef IGRAPH_OPERATORS_SUBGRAPH_INTERNAL_H
#define IGRAPH_OPERATORS_SUBGRAPH_INTERNAL_H

#include "igraph_interface.h"

IGRAPH_PRIVATE_EXPORT int igraph_i_induced_subgraph_map(
    const igraph_t *graph, igraph_t *res, const igraph_vs_t vids,
    igraph_subgraph_implementation_t impl, igraph_vector_t *map,
    igraph_vector_t *invmap, igraph_bool_t map_is_prepared
);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/operators/union.c0000644000175100001710000002326600000000000023764 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2020 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "igraph_operators.h"

#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_qsort.h"

#include "operators/misc_internal.h"

/**
 * \function igraph_union
 * \brief Calculates the union of two graphs.
 *
 * 
 * The number of vertices in the result is that of the larger graph
 * from the two arguments. The result graph contains edges which are
 * present in at least one of the operand graphs.
 *
 * \param res Pointer to an uninitialized graph object, the result
 *        will be stored here.
 * \param left The first graph.
 * \param right The second graph.
 * \param edge_map1 Pointer to an initialized vector or a null pointer.
 *     If not a null pointer, it will contain a mapping from the edges
 *     of the first argument graph (\p left) to the edges of the
 *     result graph.
 * \param edge_map2 The same as \p edge_map1, but for the second
 *     graph, \p right.
 * \return Error code.
 * \sa \ref igraph_union_many() for the union of many graphs,
 * \ref igraph_intersection() and \ref igraph_difference() for other
 * operators.
 *
 * Time complexity: O(|V|+|E|), |V| is the number of
 * vertices, |E| the number of edges in the result graph.
 *
 * \example examples/simple/igraph_union.c
 */
int igraph_union(igraph_t *res,
                 const igraph_t *left, const igraph_t *right,
                 igraph_vector_t *edge_map1, igraph_vector_t *edge_map2) {
    return igraph_i_merge(res, IGRAPH_MERGE_MODE_UNION, left, right,
                          edge_map1, edge_map2);
}

/**
 * \function igraph_union_many
 * \brief Creates the union of many graphs.
 *
 * 
 * The result graph will contain as many vertices as the largest graph
 * among the arguments does, and an edge will be included in it if it
 * is part of at least one operand graph.
 *
 * 
 * The directedness of the operand graphs must be the same.
 * If the graph list has length zero, the result will be a \em directed
 * graph with no vertices.
 *
 * \param res Pointer to an uninitialized graph object, this will
 *        contain the result.
 * \param graphs Pointer vector, contains pointers to the operands of
 *        the union operator, graph objects of course.
 * \param edgemaps If not a null pointer, then it must be an initialized
 *        pointer vector and the mappings of edges from the graphs to the
 *        result graph will be stored here, in the same order as
 *        \p graphs. Each mapping is stored in a separate
 *        \type igraph_vector_t object.
 * \return Error code.
 * \sa \ref igraph_union() for the union of two graphs, \ref
 * igraph_intersection_many(), \ref igraph_intersection() and \ref
 * igraph_difference for other operators.
 *
 *
 * Time complexity: O(|V|+|E|), |V| is the number of vertices
 * in largest graph and |E| is the number of edges in the result graph.
 *
 * \example examples/simple/igraph_union.c
 */
int igraph_union_many(igraph_t *res, const igraph_vector_ptr_t *graphs,
                      igraph_vector_ptr_t *edgemaps) {

    long int no_of_graphs = igraph_vector_ptr_size(graphs);
    long int no_of_nodes = 0;
    igraph_bool_t directed = 1;
    igraph_vector_t edges;
    igraph_vector_ptr_t edge_vects, order_vects;
    igraph_vector_long_t no_edges;
    long int i, j, tailfrom = no_of_graphs > 0 ? 0 : -1, tailto = -1;
    long int idx = 0;

    /* Check directedness */
    if (no_of_graphs != 0) {
        directed = igraph_is_directed(VECTOR(*graphs)[0]);
        no_of_nodes = igraph_vcount(VECTOR(*graphs)[0]);
    }
    for (i = 1; i < no_of_graphs; i++) {
        if (directed != igraph_is_directed(VECTOR(*graphs)[i])) {
            IGRAPH_ERROR("Cannot union directed and undirected graphs",
                         IGRAPH_EINVAL);
        }
    }

    if (edgemaps) {
        IGRAPH_CHECK(igraph_vector_ptr_resize(edgemaps, no_of_graphs));
        igraph_vector_ptr_null(edgemaps);
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vectors, edgemaps);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_CHECK(igraph_vector_long_init(&no_edges, no_of_graphs));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &no_edges);

    /* Calculate number of nodes, query number of edges */
    for (i = 0; i < no_of_graphs; i++) {
        long int n = igraph_vcount(VECTOR(*graphs)[i]);
        if (n > no_of_nodes) {
            no_of_nodes = n;
        }
        VECTOR(no_edges)[i] = igraph_ecount(VECTOR(*graphs)[i]);
    }

    if (edgemaps) {
        for (i = 0; i < no_of_graphs; i++) {
            VECTOR(*edgemaps)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
            if (!VECTOR(*edgemaps)[i]) {
                IGRAPH_ERROR("Cannot union graphs", IGRAPH_ENOMEM);
            }
            IGRAPH_CHECK(igraph_vector_init(VECTOR(*edgemaps)[i],
                                            VECTOR(no_edges)[i]));
        }
    }

    /* Allocate memory for the edge lists and their index vectors */
    if (no_of_graphs != 0) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&edge_vects, no_of_graphs));
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vectors, &edge_vects);
        IGRAPH_CHECK(igraph_vector_ptr_init(&order_vects, no_of_graphs));
        IGRAPH_FINALLY(igraph_i_union_intersection_destroy_vector_longs, &order_vects);
    }
    for (i = 0; i < no_of_graphs; i++) {
        VECTOR(edge_vects)[i] = IGRAPH_CALLOC(1, igraph_vector_t);
        VECTOR(order_vects)[i] = IGRAPH_CALLOC(1, igraph_vector_long_t);
        if (! VECTOR(edge_vects)[i] || ! VECTOR(order_vects)[i]) {
            IGRAPH_ERROR("Cannot union graphs", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(VECTOR(edge_vects)[i],
                                        2 * VECTOR(no_edges)[i]));
        IGRAPH_CHECK(igraph_vector_long_init(VECTOR(order_vects)[i],
                                             VECTOR(no_edges)[i]));
    }

    /* Query and sort the edge lists */
    for (i = 0; i < no_of_graphs; i++) {
        long int k, j, n = VECTOR(no_edges)[i];
        igraph_vector_t *edges = VECTOR(edge_vects)[i];
        igraph_vector_long_t *order = VECTOR(order_vects)[i];
        IGRAPH_CHECK(igraph_get_edgelist(VECTOR(*graphs)[i], edges, /*bycol=*/0));
        if (!directed) {
            for (k = 0, j = 0; k < n; k++, j += 2) {
                if (VECTOR(*edges)[j] > VECTOR(*edges)[j + 1]) {
                    long int tmp = VECTOR(*edges)[j];
                    VECTOR(*edges)[j] = VECTOR(*edges)[j + 1];
                    VECTOR(*edges)[j + 1] = tmp;
                }
            }
        }
        for (k = 0; k < n; k++) {
            VECTOR(*order)[k] = k;
        }
        igraph_qsort_r(VECTOR(*order), n, sizeof(VECTOR(*order)[0]), edges,
                       igraph_i_order_edgelist_cmp);
    }

    while (tailfrom >= 0) {

        /* Get the largest tail element */
        tailfrom = tailto = -1;
        for (j = 0; j < no_of_graphs; j++) {
            if (!igraph_vector_long_empty(VECTOR(order_vects)[j])) {
                long int edge = igraph_vector_long_tail(VECTOR(order_vects)[j]);
                igraph_vector_t *ev = VECTOR(edge_vects)[j];
                long int from = VECTOR(*ev)[2 * edge];
                long int to = VECTOR(*ev)[2 * edge + 1];
                if (from > tailfrom || (from == tailfrom && to > tailto)) {
                    tailfrom = from; tailto = to;
                }
            }
        }
        if (tailfrom < 0) {
            continue;
        }

        /* add the edge */
        IGRAPH_CHECK(igraph_vector_push_back(&edges, tailfrom));
        IGRAPH_CHECK(igraph_vector_push_back(&edges, tailto));

        /* update edge lists, we just modify the 'order' vectors */
        for (j = 0; j < no_of_graphs; j++) {
            if (!igraph_vector_long_empty(VECTOR(order_vects)[j])) {
                long int edge = igraph_vector_long_tail(VECTOR(order_vects)[j]);
                igraph_vector_t *ev = VECTOR(edge_vects)[j];
                long int from = VECTOR(*ev)[2 * edge];
                long int to = VECTOR(*ev)[2 * edge + 1];
                if (from == tailfrom && to == tailto) {
                    igraph_vector_long_pop_back(VECTOR(order_vects)[j]);
                    if (edgemaps) {
                        igraph_vector_t *map = VECTOR(*edgemaps)[j];
                        VECTOR(*map)[edge] = idx;
                    }
                }
            }
        }
        idx++;

    }

    if (no_of_graphs > 0) {
        igraph_i_union_intersection_destroy_vector_longs(&order_vects);
        igraph_i_union_intersection_destroy_vectors(&edge_vects);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vector_long_destroy(&no_edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
                               directed));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);
    if (edgemaps) {
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5391412
igraph-0.9.9/vendor/source/igraph/src/paths/0000755000175100001710000000000000000000000021560 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/all_shortest_paths.c0000644000175100001710000002757300000000000025644 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "core/interruption.h"

#include   /* memset */

static void igraph_i_gasp_paths_destroy(igraph_vector_ptr_t *v) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(v); i++) {
        if (VECTOR(*v)[i] != 0) {
            igraph_vector_destroy(VECTOR(*v)[i]);
            IGRAPH_FREE(VECTOR(*v)[i]);
        }
    }
    igraph_vector_ptr_destroy(v);
}

/**
 * \function igraph_get_all_shortest_paths
 * \brief All shortest paths (geodesics) from a vertex.
 *
 * When there is more than one shortest path between two vertices,
 * all of them will be returned.
 *
 * \param graph The graph object.
 * \param res Pointer to an initialized pointer vector, the result
 *   will be stored here in \ref igraph_vector_t objects. Each vector
 *   object contains the vertices along a shortest path from \p from
 *   to another vertex. The vectors are ordered according to their
 *   target vertex: first the shortest paths to vertex 0, then to
 *   vertex 1, etc. No data is included for unreachable vertices.
 * \param nrgeo Pointer to an initialized \ref igraph_vector_t object or
 *   \c NULL. If not \c NULL the number of shortest paths from \p from are
 *   stored here for every vertex in the graph. Note that the values
 *   will be accurate only for those vertices that are in the target
 *   vertex sequence (see \p to), since the search terminates as soon
 *   as all the target vertices have been found.
 * \param from The id of the vertex from/to which the geodesics are
 *        calculated.
 * \param to Vertex sequence with the ids of the vertices to/from which the
 *        shortest paths will be calculated. A vertex might be given multiple
 *        times.
 * \param mode The type of shortest paths to be use for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           \p from is invalid vertex id.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Added in version 0.2.
 *
 * Time complexity: O(|V|+|E|) for most graphs, O(|V|^2) in the worst
 * case.
 */
int igraph_get_all_shortest_paths(const igraph_t *graph,
                                  igraph_vector_ptr_t *res,
                                  igraph_vector_t *nrgeo,
                                  igraph_integer_t from, const igraph_vs_t to,
                                  igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    long int *geodist;
    igraph_vector_ptr_t paths;
    igraph_dqueue_t q;
    igraph_vector_t *vptr;
    igraph_vector_t neis;
    igraph_vector_t ptrlist;
    igraph_vector_t ptrhead;
    long int n, j, i;
    long int to_reach, reached = 0, maxdist = 0;

    igraph_vit_t vit;

    if (from < 0 || from >= no_of_nodes) {
        IGRAPH_ERROR("cannot get shortest paths", IGRAPH_EINVVID);
    }
    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    /* paths will store the shortest paths during the search */
    IGRAPH_CHECK(igraph_vector_ptr_init(&paths, 0));
    IGRAPH_FINALLY(igraph_i_gasp_paths_destroy, &paths);
    /* neis is a temporary vector holding the neighbors of the
     * node being examined */
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    /* ptrlist stores indices into the paths vector, in the order
     * of how they were found. ptrhead is a second-level index that
     * will be used to find paths that terminate in a given vertex */
    IGRAPH_VECTOR_INIT_FINALLY(&ptrlist, 0);
    /* ptrhead contains indices into ptrlist.
     * ptrhead[i] = j means that element #j-1 in ptrlist contains
     * the shortest path from the root to node i. ptrhead[i] = 0
     * means that node i was not reached so far */
    IGRAPH_VECTOR_INIT_FINALLY(&ptrhead, no_of_nodes);
    /* geodist[i] == 0 if i was not reached yet and it is not in the
     * target vertex sequence, or -1 if i was not reached yet and it
     * is in the target vertex sequence. Otherwise it is
     * one larger than the length of the shortest path from the
     * source */
    geodist = IGRAPH_CALLOC(no_of_nodes, long int);
    if (geodist == 0) {
        IGRAPH_ERROR("Cannot calculate shortest paths", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, geodist);
    /* dequeue to store the BFS queue -- odd elements are the vertex indices,
     * even elements are the distances from the root */
    IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &q);

    if (nrgeo) {
        IGRAPH_CHECK(igraph_vector_resize(nrgeo, no_of_nodes));
        igraph_vector_null(nrgeo);
    }

    /* use geodist to count how many vertices we have to reach */
    to_reach = IGRAPH_VIT_SIZE(vit);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        if (geodist[ (long int) IGRAPH_VIT_GET(vit) ] == 0) {
            geodist[ (long int) IGRAPH_VIT_GET(vit) ] = -1;
        } else {
            to_reach--;       /* this node was given multiple times */
        }
    }

    if (geodist[ (long int) from ] < 0) {
        reached++;
    }

    /* from -> from */
    vptr = IGRAPH_CALLOC(1, igraph_vector_t); /* TODO: dirty */
    IGRAPH_CHECK(igraph_vector_ptr_push_back(&paths, vptr));
    IGRAPH_CHECK(igraph_vector_init(vptr, 1));
    VECTOR(*vptr)[0] = from;
    geodist[(long int)from] = 1;
    VECTOR(ptrhead)[(long int)from] = 1;
    IGRAPH_CHECK(igraph_vector_push_back(&ptrlist, 0));
    if (nrgeo) {
        VECTOR(*nrgeo)[(long int)from] = 1;
    }

    /* Init queue */
    IGRAPH_CHECK(igraph_dqueue_push(&q, from));
    IGRAPH_CHECK(igraph_dqueue_push(&q, 0.0));
    while (!igraph_dqueue_empty(&q)) {
        long int actnode = (long int) igraph_dqueue_pop(&q);
        long int actdist = (long int) igraph_dqueue_pop(&q);

        IGRAPH_ALLOW_INTERRUPTION();

        if (reached >= to_reach) {
            /* all nodes were reached. Since we need all the shortest paths
             * to all these nodes, we can stop the search only if the distance
             * of the current node to the root is larger than the distance of
             * any of the nodes we wanted to reach */
            if (actdist > maxdist) {
                /* safety check, maxdist should have been set when we reached the last node */
                if (maxdist < 0) {
                    IGRAPH_ERROR("possible bug in igraph_get_all_shortest_paths, "
                                 "maxdist is negative", IGRAPH_EINVAL);
                }
                break;
            }
        }

        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actnode,
                                      mode));
        n = igraph_vector_size(&neis);
        for (j = 0; j < n; j++) {
            long int neighbor = (long int) VECTOR(neis)[j];
            long int fatherptr;

            if (geodist[neighbor] > 0 &&
                geodist[neighbor] - 1 < actdist + 1) {
                /* this node was reached via a shorter path before */
                continue;
            }

            /* yay, found another shortest path to neighbor */

            if (nrgeo) {
                /* the number of geodesics leading to neighbor must be
                 * increased by the number of geodesics leading to actnode */
                VECTOR(*nrgeo)[neighbor] += VECTOR(*nrgeo)[actnode];
            }
            if (geodist[neighbor] <= 0) {
                /* this node was not reached yet, push it into the queue */
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                if (geodist[neighbor] < 0) {
                    reached++;
                }
                if (reached == to_reach) {
                    maxdist = actdist;
                }
            }
            geodist[neighbor] = actdist + 2;

            /* copy all existing paths to the parent */
            fatherptr = (long int) VECTOR(ptrhead)[actnode];
            while (fatherptr != 0) {
                /* allocate a new igraph_vector_t at the end of paths */
                vptr = IGRAPH_CALLOC(1, igraph_vector_t);
                IGRAPH_CHECK(igraph_vector_ptr_push_back(&paths, vptr));
                IGRAPH_CHECK(igraph_vector_copy(vptr, VECTOR(paths)[fatherptr - 1]));
                IGRAPH_CHECK(igraph_vector_reserve(vptr, actdist + 2));
                IGRAPH_CHECK(igraph_vector_push_back(vptr, neighbor));

                IGRAPH_CHECK(igraph_vector_push_back(&ptrlist,
                                                     VECTOR(ptrhead)[neighbor]));
                VECTOR(ptrhead)[neighbor] = igraph_vector_size(&ptrlist);

                fatherptr = (long int) VECTOR(ptrlist)[fatherptr - 1];
            }
        }
    }

    igraph_dqueue_destroy(&q);
    IGRAPH_FINALLY_CLEAN(1);

    /* mark the nodes for which we need the result */
    memset(geodist, 0, sizeof(long int) * (size_t) no_of_nodes);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        geodist[ (long int) IGRAPH_VIT_GET(vit) ] = 1;
    }

    /* count the number of paths in the result */
    n = 0;
    for (i = 0; i < no_of_nodes; i++) {
        long int fatherptr = (long int) VECTOR(ptrhead)[i];
        if (geodist[i] > 0) {
            while (fatherptr != 0) {
                n++;
                fatherptr = (long int) VECTOR(ptrlist)[fatherptr - 1];
            }
        }
    }

    IGRAPH_CHECK(igraph_vector_ptr_resize(res, n));
    j = 0;
    for (i = 0; i < no_of_nodes; i++) {
        long int fatherptr = (long int) VECTOR(ptrhead)[i];

        IGRAPH_ALLOW_INTERRUPTION();

        /* do we need the paths leading to vertex i? */
        if (geodist[i] > 0) {
            /* yes, copy them to the result vector */
            while (fatherptr != 0) {
                VECTOR(*res)[j++] = VECTOR(paths)[fatherptr - 1];
                fatherptr = (long int) VECTOR(ptrlist)[fatherptr - 1];
            }
        } else {
            /* no, free them */
            while (fatherptr != 0) {
                igraph_vector_destroy(VECTOR(paths)[fatherptr - 1]);
                IGRAPH_FREE(VECTOR(paths)[fatherptr - 1]);
                fatherptr = (long int) VECTOR(ptrlist)[fatherptr - 1];
            }
        }
    }

    IGRAPH_FREE(geodist);
    igraph_vector_destroy(&ptrlist);
    igraph_vector_destroy(&ptrhead);
    igraph_vector_destroy(&neis);
    igraph_vector_ptr_destroy(&paths);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(6);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/bellman_ford.c0000644000175100001710000005457600000000000024371 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_stack.h"

#include "core/indheap.h"
#include "core/interruption.h"

#include 

/**
 * \function igraph_shortest_paths_bellman_ford
 * \brief Weighted shortest path lengths between vertices, allowing negative weights.
 *
 * This function implements the Bellman-Ford algorithm to find the weighted
 * shortest paths to all vertices from a single source, allowing negative weights.
 * It is run independently for the given sources. If there are no negative
 * weights, you are better off with \ref igraph_shortest_paths_dijkstra() .
 *
 * \param graph The input graph, can be directed.
 * \param res The result, a matrix. A pointer to an initialized matrix
 *    should be passed here, the matrix will be resized if needed.
 *    Each row contains the distances from a single source, to all
 *    vertices in the graph, in the order of vertex ids. For unreachable
 *    vertices the matrix contains \c IGRAPH_INFINITY.
 * \param from The source vertices.
 * \param to The target vertices. It is not allowed to include a
 *    vertex twice or more.
 * \param weights The edge weights. There mustn't be any closed loop in
 *    the graph that has a negative total weight (since this would allow
 *    us to decrease the weight of any path containing at least a single
 *    vertex of this loop infinitely). Additionally, no edge weight may
 *    be NaN. If either case does not hold, an error is returned. If this
 *    is a null pointer, then the unweighted version,
 *    \ref igraph_shortest_paths() is called.
 * \param mode For directed graphs; whether to follow paths along edge
 *    directions (\c IGRAPH_OUT), or the opposite (\c IGRAPH_IN), or
 *    ignore edge directions completely (\c IGRAPH_ALL). It is ignored
 *    for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(s*|E|*|V|), where |V| is the number of
 * vertices, |E| the number of edges and s the number of sources.
 *
 * \sa \ref igraph_shortest_paths() for a faster unweighted version
 * or \ref igraph_shortest_paths_dijkstra() if you do not have negative
 * edge weights.
 *
 * \example examples/simple/bellman_ford.c
 */
int igraph_shortest_paths_bellman_ford(const igraph_t *graph,
                                       igraph_matrix_t *res,
                                       const igraph_vs_t from,
                                       const igraph_vs_t to,
                                       const igraph_vector_t *weights,
                                       igraph_neimode_t mode) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_lazy_inclist_t inclist;
    long int i, j, k;
    long int no_of_from, no_of_to;
    igraph_dqueue_t Q;
    igraph_vector_t clean_vertices;
    igraph_vector_t num_queued;
    igraph_vit_t fromvit, tovit;
    igraph_real_t my_infinity = IGRAPH_INFINITY;
    igraph_bool_t all_to;
    igraph_vector_t dist;

    /*
       - speedup: a vertex is marked clean if its distance from the source
         did not change during the last phase. Neighbors of a clean vertex
         are not relaxed again, since it would mean no change in the
         shortest path values. Dirty vertices are queued. Negative loops can
         be detected by checking whether a vertex has been queued at least
         n times.
    */
    if (!weights) {
        return igraph_shortest_paths(graph, res, from, to, mode);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length does not match", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0 && igraph_vector_is_any_nan(weights)) {
        IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, from, &fromvit));
    IGRAPH_FINALLY(igraph_vit_destroy, &fromvit);
    no_of_from = IGRAPH_VIT_SIZE(fromvit);

    IGRAPH_DQUEUE_INIT_FINALLY(&Q, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&clean_vertices, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&num_queued, no_of_nodes);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    all_to = igraph_vs_is_all(&to);
    if (all_to) {
        no_of_to = no_of_nodes;
    } else {
        IGRAPH_CHECK(igraph_vit_create(graph, to, &tovit));
        IGRAPH_FINALLY(igraph_vit_destroy, &tovit);
        no_of_to = IGRAPH_VIT_SIZE(tovit);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&dist, no_of_nodes);
    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_from, no_of_to));

    for (IGRAPH_VIT_RESET(fromvit), i = 0;
         !IGRAPH_VIT_END(fromvit);
         IGRAPH_VIT_NEXT(fromvit), i++) {
        long int source = IGRAPH_VIT_GET(fromvit);

        igraph_vector_fill(&dist, my_infinity);
        VECTOR(dist)[source] = 0;
        igraph_vector_null(&clean_vertices);
        igraph_vector_null(&num_queued);

        /* Fill the queue with vertices to be checked */
        for (j = 0; j < no_of_nodes; j++) {
            IGRAPH_CHECK(igraph_dqueue_push(&Q, j));
        }

        while (!igraph_dqueue_empty(&Q)) {
            igraph_vector_int_t *neis;
            long int nlen;

            j = (long int) igraph_dqueue_pop(&Q);
            VECTOR(clean_vertices)[j] = 1;
            VECTOR(num_queued)[j] += 1;
            if (VECTOR(num_queued)[j] > no_of_nodes) {
                IGRAPH_ERROR("cannot run Bellman-Ford algorithm", IGRAPH_ENEGLOOP);
            }

            /* If we cannot get to j in finite time yet, there is no need to relax
             * its edges */
            if (!IGRAPH_FINITE(VECTOR(dist)[j])) {
                continue;
            }

            neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) j);
            nlen = igraph_vector_int_size(neis);

            for (k = 0; k < nlen; k++) {
                long int nei = (long int) VECTOR(*neis)[k];
                long int target = IGRAPH_OTHER(graph, nei, j);
                if (VECTOR(dist)[target] > VECTOR(dist)[j] + VECTOR(*weights)[nei]) {
                    /* relax the edge */
                    VECTOR(dist)[target] = VECTOR(dist)[j] + VECTOR(*weights)[nei];
                    if (VECTOR(clean_vertices)[target]) {
                        VECTOR(clean_vertices)[target] = 0;
                        IGRAPH_CHECK(igraph_dqueue_push(&Q, target));
                    }
                }
            }
        }

        /* Copy it to the result */
        if (all_to) {
            igraph_matrix_set_row(res, &dist, i);
        } else {
            for (IGRAPH_VIT_RESET(tovit), j = 0; !IGRAPH_VIT_END(tovit);
                 IGRAPH_VIT_NEXT(tovit), j++) {
                long int v = IGRAPH_VIT_GET(tovit);
                MATRIX(*res, i, j) = VECTOR(dist)[v];
            }
        }
    }

    igraph_vector_destroy(&dist);
    IGRAPH_FINALLY_CLEAN(1);

    if (!all_to) {
        igraph_vit_destroy(&tovit);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vit_destroy(&fromvit);
    igraph_dqueue_destroy(&Q);
    igraph_vector_destroy(&clean_vertices);
    igraph_vector_destroy(&num_queued);
    igraph_lazy_inclist_destroy(&inclist);
    IGRAPH_FINALLY_CLEAN(5);

    return 0;
}


/**
 * \ingroup structural
 * \function igraph_get_shortest_paths_bellman_ford
 * \brief Weighted shortest paths from a vertex, allowing negative weights.
 *
 * This function calculates weighted shortest paths from or to a single vertex,
 * and allows negative weights. When there is more than one shortest path between
 * two vertices, only one of them is returned.
 *
 * If there are no negative weights, you are better off with
 * \ref igraph_get_shortest_paths_dijkstra() .
 *
 * \param graph The input graph, can be directed.
 * \param vertices The result, the ids of the vertices along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors. Normally, either this argument, or the \c
 *        edges should be non-null, but no error or warning is given
 *        if they are both null pointers.
 * \param edges The result, the ids of the edges along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors. Normally, either this argument, or the \c
 *        vertices should be non-null, but no error or warning is given
 *        if they are both null pointers.
 * \param from The id of the vertex from/to which the geodesics are
 *        calculated.
 * \param to Vertex sequence with the ids of the vertices to/from which the
 *        shortest paths will be calculated. A vertex might be given multiple
 *        times.
 * \param weights The edge weights. There mustn't be any closed loop in
 *    the graph that has a negative total weight (since this would allow
 *    us to decrease the weight of any path containing at least a single
 *    vertex of this loop infinitely). If this is a null pointer, then the
 *    unweighted version, \ref igraph_shortest_paths() is called.
 * \param mode For directed graphs; whether to follow paths along edge
 *    directions (\c IGRAPH_OUT), or the opposite (\c IGRAPH_IN), or
 *    ignore edge directions completely (\c IGRAPH_ALL). It is ignored
 *    for undirected graphs.
 * \param predecessors A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the predecessor of each vertex in
 *        the single source shortest path tree is returned here. The
 *        predecessor of vertex i in the tree is the vertex from which vertex i
 *        was reached. The predecessor of the start vertex (in the \c from
 *        argument) is itself by definition. If the predecessor is -1, it means
 *        that the given vertex was not reached from the source during the
 *        search. Note that the search terminates if all the vertices in
 *        \c to are reached.
 * \param inbound_edges A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the inbound edge of each vertex in
 *        the single source shortest path tree is returned here. The
 *        inbound edge of vertex i in the tree is the edge via which vertex i
 *        was reached. The start vertex and vertices that were not reached
 *        during the search will have -1 in the corresponding entry of the
 *        vector. Note that the search terminates if all the vertices in
 *        \c to are reached.
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_ENOMEM
 *           Not enough memory for temporary data.
 *         \cli IGRAPH_EINVAL
 *           The weight vector doesn't math the number of edges.
 *         \cli IGRAPH_EINVVID
 *           \p from is invalid vertex id, or the length of \p to is
 *           not the same as the length of \p vertices or \p edges.
 *         \cli IGRAPH_ENEGLOOP
 *           Bellman-ford algorithm encounted a negative loop.
 *         \endclist
 *
 * Time complexity: O(|E|*|V|), where |V| is the number of
 * vertices, |E| the number of edges.
 *
 * \sa \ref igraph_shortest_paths() for a faster unweighted version
 * or \ref igraph_shortest_paths_dijkstra() if you do not have negative
 * edge weights.
 */

int igraph_get_shortest_paths_bellman_ford(const igraph_t *graph,
                                        igraph_vector_ptr_t *vertices,
                                        igraph_vector_ptr_t *edges,
                                        igraph_integer_t from,
                                        igraph_vs_t to,
                                        const igraph_vector_t *weights,
                                        igraph_neimode_t mode,
                                        igraph_vector_long_t *predecessors,
                                        igraph_vector_long_t *inbound_edges) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int *parents;
    igraph_lazy_inclist_t inclist;
    long int i, j, k;
    igraph_dqueue_t Q;
    igraph_vector_t clean_vertices;
    igraph_vector_t num_queued;
    igraph_vit_t tovit;
    igraph_real_t my_infinity = IGRAPH_INFINITY;
    igraph_vector_t dist;

    if (!weights) {
        return  igraph_get_shortest_paths(graph, vertices, edges, from, to, mode,
                                         predecessors, inbound_edges);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length must match number of edges.", IGRAPH_EINVAL);
    }

    IGRAPH_DQUEUE_INIT_FINALLY(&Q, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&clean_vertices, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&num_queued, no_of_nodes);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_CHECK(igraph_vit_create(graph, to, &tovit));
    IGRAPH_FINALLY(igraph_vit_destroy, &tovit);

    if (vertices && IGRAPH_VIT_SIZE(tovit) != igraph_vector_ptr_size(vertices)) {
        IGRAPH_ERROR("Size of `vertices' and `to' should match.", IGRAPH_EINVAL);
    }
    if (edges && IGRAPH_VIT_SIZE(tovit) != igraph_vector_ptr_size(edges)) {
        IGRAPH_ERROR("Size of `edges' and `to' should match.", IGRAPH_EINVAL);
    }

    parents = IGRAPH_CALLOC(no_of_nodes, long int);
    if (parents == 0) {
        IGRAPH_ERROR("Insufficient memory for shortest paths with Bellman-Ford.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, parents);
    IGRAPH_VECTOR_INIT_FINALLY(&dist, no_of_nodes);

    igraph_vector_fill(&dist, my_infinity);
    VECTOR(dist)[from] = 0;
    igraph_vector_null(&clean_vertices);
    igraph_vector_null(&num_queued);

    /* Fill the queue with vertices to be checked */
    for (j = 0; j < no_of_nodes; j++) {
        IGRAPH_CHECK(igraph_dqueue_push(&Q, j));
    }

    while (!igraph_dqueue_empty(&Q)) {
        igraph_vector_int_t *neis;
        long int nlen;

        j = (long int) igraph_dqueue_pop(&Q);
        VECTOR(clean_vertices)[j] = 1;
        VECTOR(num_queued)[j] += 1;
        if (VECTOR(num_queued)[j] > no_of_nodes) {
            IGRAPH_ERROR("cannot run Bellman-Ford algorithm", IGRAPH_ENEGLOOP);
        }

        /* If we cannot get to j in finite time yet, there is no need to relax
            * its edges */
        if (!IGRAPH_FINITE(VECTOR(dist)[j])) {
            continue;
        }

        neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) j);
        nlen = igraph_vector_int_size(neis);

        for (k = 0; k < nlen; k++) {
            long int nei = (long int) VECTOR(*neis)[k];
            long int target = IGRAPH_OTHER(graph, nei, j);
            if (VECTOR(dist)[target] > VECTOR(dist)[j] + VECTOR(*weights)[nei]) {
                /* relax the edge */
                VECTOR(dist)[target] = VECTOR(dist)[j] + VECTOR(*weights)[nei];
                parents[target] = nei + 1;
                if (VECTOR(clean_vertices)[target]) {
                    VECTOR(clean_vertices)[target] = 0;
                    IGRAPH_CHECK(igraph_dqueue_push(&Q, target));
                }
            }
        }
    }

    /* Create `predecessors' if needed */
    if (predecessors) {
        IGRAPH_CHECK(igraph_vector_long_resize(predecessors, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (i == from) {
                /* i is the start vertex */
                VECTOR(*predecessors)[i] = i;
            } else if (parents[i] <= 0) {
                /* i was not reached */
                VECTOR(*predecessors)[i] = -1;
            } else {
                /* i was reached via the edge with ID = parents[i] - 1 */
                VECTOR(*predecessors)[i] = IGRAPH_OTHER(graph, parents[i] - 1, i);
            }
        }
    }

    /* Create `inbound_edges' if needed */
    if (inbound_edges) {
        IGRAPH_CHECK(igraph_vector_long_resize(inbound_edges, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (parents[i] <= 0) {
                /* i was not reached */
                VECTOR(*inbound_edges)[i] = -1;
            } else {
                /* i was reached via the edge with ID = parents[i] - 1 */
                VECTOR(*inbound_edges)[i] = parents[i] - 1;
            }
        }
    }

    /* Reconstruct the shortest paths based on vertex and/or edge IDs */
    if (vertices || edges) {
        for (IGRAPH_VIT_RESET(tovit), i = 0; !IGRAPH_VIT_END(tovit); IGRAPH_VIT_NEXT(tovit), i++) {
            long int node = IGRAPH_VIT_GET(tovit);
            long int size, act, edge;
            igraph_vector_t *vvec = 0, *evec = 0;
            if (vertices) {
                vvec = VECTOR(*vertices)[i];
                igraph_vector_clear(vvec);
            }
            if (edges) {
                evec = VECTOR(*edges)[i];
                igraph_vector_clear(evec);
            }

            IGRAPH_ALLOW_INTERRUPTION();

            size = 0;
            act = node;
            while (parents[act]) {
                size++;
                edge = parents[act] - 1;
                act = IGRAPH_OTHER(graph, edge, act);
            }
            if (vvec && (size > 0 || node == from)) {
                IGRAPH_CHECK(igraph_vector_resize(vvec, size + 1));
                VECTOR(*vvec)[size] = node;
            }
            if (evec) {
                IGRAPH_CHECK(igraph_vector_resize(evec, size));
            }
            act = node;
            while (parents[act]) {
                edge = parents[act] - 1;
                act = IGRAPH_OTHER(graph, edge, act);
                size--;
                if (vvec) {
                    VECTOR(*vvec)[size] = act;
                }
                if (evec) {
                    VECTOR(*evec)[size] = edge;
                }
            }
        }
    }

    igraph_vector_destroy(&dist);
    IGRAPH_FINALLY_CLEAN(1);

    igraph_vit_destroy(&tovit);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_FREE(parents);
    igraph_dqueue_destroy(&Q);
    igraph_vector_destroy(&clean_vertices);
    igraph_vector_destroy(&num_queued);
    igraph_lazy_inclist_destroy(&inclist);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_get_shortest_path_bellman_ford
 * \brief Weighted shortest path from one vertex to another one.
 *
 * Calculates a single (positively) weighted shortest path from
 * a single vertex to another one, using Bellman-Ford algorithm.
 *
 * 
 * This function is a special case (and a wrapper) to
 * \ref igraph_get_shortest_paths_bellman_ford().
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param vertices Pointer to an initialized vector or a null
 *        pointer. If not a null pointer, then the vertex ids along
 *        the path are stored here, including the source and target
 *        vertices.
 * \param edges Pointer to an uninitialized vector or a null
 *        pointer. If not a null pointer, then the edge ids along the
 *        path are stored here.
 * \param from The id of the source vertex.
 * \param to The id of the target vertex.
 * \param weights The edge weights. There mustn't be any closed loop in
 *        the graph that has a negative total weight (since this would allow
 *        us to decrease the weight of any path containing at least a single
 *        vertex of this loop infinitely). If this is a null pointer, then the
 *        unweighted version is called.
 * \param mode A constant specifying how edge directions are
 *        considered in directed graphs. \c IGRAPH_OUT follows edge
 *        directions, \c IGRAPH_IN follows the opposite directions,
 *        and \c IGRAPH_ALL ignores edge directions. This argument is
 *        ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|E|log|E|+|V|), |V| is the number of vertices,
 * |E| is the number of edges in the graph.
 *
 * \sa \ref igraph_get_shortest_paths_bellman_ford() for the version with
 * more target vertices.
 */

int igraph_get_shortest_path_bellman_ford(const igraph_t *graph,
                                          igraph_vector_t *vertices,
                                          igraph_vector_t *edges,
                                          igraph_integer_t from,
                                          igraph_integer_t to,
                                          const igraph_vector_t *weights,
                                          igraph_neimode_t mode) {

    igraph_vector_ptr_t vertices2, *vp = &vertices2;
    igraph_vector_ptr_t edges2, *ep = &edges2;

    if (vertices) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&vertices2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vertices2);
        VECTOR(vertices2)[0] = vertices;
    } else {
        vp = NULL;
    }
    if (edges) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&edges2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &edges2);
        VECTOR(edges2)[0] = edges;
    } else {
        ep = NULL;
    }

    IGRAPH_CHECK(igraph_get_shortest_paths_bellman_ford(graph, vp, ep,
                                                        from, igraph_vss_1(to),
                                                        weights, mode, NULL, NULL));

    if (edges) {
        igraph_vector_ptr_destroy(&edges2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (vertices) {
        igraph_vector_ptr_destroy(&vertices2);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/dijkstra.c0000644000175100001710000012470500000000000023550 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_stack.h"

#include "core/indheap.h"
#include "core/interruption.h"

#include    /* memset */

/**
 * \function igraph_shortest_paths_dijkstra
 * \brief Weighted shortest path lengths between vertices.
 *
 * This function implements Dijkstra's algorithm to find the weighted
 * shortest path lengths to all vertices from a single source. It is run
 * independently for the given sources. It uses a binary heap for
 * efficient implementation.
 *
 * \param graph The input graph, can be directed.
 * \param res The result, a matrix. A pointer to an initialized matrix
 *    should be passed here. The matrix will be resized as needed.
 *    Each row contains the distances from a single source, to the
 *    vertices given in the \c to argument.
 *    Unreachable vertices has distance
 *    \c IGRAPH_INFINITY.
 * \param from The source vertices.
 * \param to The target vertices. It is not allowed to include a
 *    vertex twice or more.
 * \param weights The edge weights. All edge weights must be
 *    non-negative for Dijkstra's algorithm to work. Additionally, no
 *    edge weight may be NaN. If either case does not hold, an error
 *    is returned. If this is a null pointer, then the unweighted
 *    version, \ref igraph_shortest_paths() is called.
 * \param mode For directed graphs; whether to follow paths along edge
 *    directions (\c IGRAPH_OUT), or the opposite (\c IGRAPH_IN), or
 *    ignore edge directions completely (\c IGRAPH_ALL). It is ignored
 *    for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(s*|E|log|E|+|V|), where |V| is the number of
 * vertices, |E| the number of edges and s the number of sources.
 *
 * \sa \ref igraph_shortest_paths() for a (slightly) faster unweighted
 * version or \ref igraph_shortest_paths_bellman_ford() for a weighted
 * variant that works in the presence of negative edge weights (but no
 * negative loops).
 *
 * \example examples/simple/dijkstra.c
 */
int igraph_shortest_paths_dijkstra(const igraph_t *graph,
                                   igraph_matrix_t *res,
                                   const igraph_vs_t from,
                                   const igraph_vs_t to,
                                   const igraph_vector_t *weights,
                                   igraph_neimode_t mode) {

    /* Implementation details. This is the basic Dijkstra algorithm,
       with a binary heap. The heap is indexed, i.e. it stores not only
       the distances, but also which vertex they belong to.

       From now on we use a 2-way heap, so the distances can be queried
       directly from the heap.

       Dirty tricks:
       - the opposite of the distance is stored in the heap, as it is a
         maximum heap and we need a minimum heap.
       - we don't use IGRAPH_INFINITY in the res matrix during the
         computation, as IGRAPH_FINITE() might involve a function call
         and we want to spare that. -1 will denote infinity instead.
    */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_2wheap_t Q;
    igraph_vit_t fromvit, tovit;
    long int no_of_from, no_of_to;
    igraph_lazy_inclist_t inclist;
    long int i, j;
    igraph_real_t my_infinity = IGRAPH_INFINITY;
    igraph_bool_t all_to;
    igraph_vector_t indexv;

    if (!weights) {
        return igraph_shortest_paths(graph, res, from, to, mode);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length does not match", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0) {
        igraph_real_t min = igraph_vector_min(weights);
        if (min < 0) {
            IGRAPH_ERROR("Weight vector must be non-negative", IGRAPH_EINVAL);
        }
        else if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_vit_create(graph, from, &fromvit));
    IGRAPH_FINALLY(igraph_vit_destroy, &fromvit);
    no_of_from = IGRAPH_VIT_SIZE(fromvit);

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    all_to = igraph_vs_is_all(&to);
    if (all_to) {
        no_of_to = no_of_nodes;
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&indexv, no_of_nodes);
        IGRAPH_CHECK(igraph_vit_create(graph, to, &tovit));
        IGRAPH_FINALLY(igraph_vit_destroy, &tovit);
        no_of_to = IGRAPH_VIT_SIZE(tovit);
        for (i = 0; !IGRAPH_VIT_END(tovit); IGRAPH_VIT_NEXT(tovit)) {
            long int v = IGRAPH_VIT_GET(tovit);
            if (VECTOR(indexv)[v]) {
                IGRAPH_ERROR("Duplicate vertices in `to', this is not allowed",
                             IGRAPH_EINVAL);
            }
            VECTOR(indexv)[v] = ++i;
        }
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_from, no_of_to));
    igraph_matrix_fill(res, my_infinity);

    for (IGRAPH_VIT_RESET(fromvit), i = 0;
         !IGRAPH_VIT_END(fromvit);
         IGRAPH_VIT_NEXT(fromvit), i++) {

        long int reached = 0;
        long int source = IGRAPH_VIT_GET(fromvit);
        igraph_2wheap_clear(&Q);
        igraph_2wheap_push_with_index(&Q, source, -1.0);

        while (!igraph_2wheap_empty(&Q)) {
            long int minnei = igraph_2wheap_max_index(&Q);
            igraph_real_t mindist = -igraph_2wheap_deactivate_max(&Q);
            igraph_vector_int_t *neis;
            long int nlen;

            if (all_to) {
                MATRIX(*res, i, minnei) = mindist - 1.0;
            } else {
                if (VECTOR(indexv)[minnei]) {
                    MATRIX(*res, i, (long int)(VECTOR(indexv)[minnei] - 1)) = mindist - 1.0;
                    reached++;
                    if (reached == no_of_to) {
                        igraph_2wheap_clear(&Q);
                        break;
                    }
                }
            }

            /* Now check all neighbors of 'minnei' for a shorter path */
            neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int tto = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_bool_t active = igraph_2wheap_has_active(&Q, tto);
                igraph_bool_t has = igraph_2wheap_has_elem(&Q, tto);
                igraph_real_t curdist = active ? -igraph_2wheap_get(&Q, tto) : 0.0;
                if (!has) {
                    /* This is the first non-infinite distance */
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, tto, -altdist));
                } else if (altdist < curdist) {
                    /* This is a shorter path */
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, tto, -altdist));
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

    } /* !IGRAPH_VIT_END(fromvit) */

    if (!all_to) {
        igraph_vit_destroy(&tovit);
        igraph_vector_destroy(&indexv);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    igraph_vit_destroy(&fromvit);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_get_shortest_paths_dijkstra
 * \brief Weighted shortest paths from a vertex.
 *
 * 
 * If there is more than one path with the smallest weight between two vertices, this
 * function gives only one of them.
 * \param graph The graph object.
 * \param vertices The result, the ids of the vertices along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors. Normally, either this argument, or the \c
 *        edges should be non-null, but no error or warning is given
 *        if they are both null pointers.
 * \param edges The result, the ids of the edges along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors. Normally, either this argument, or the \c
 *        vertices should be non-null, but no error or warning is given
 *        if they are both null pointers.
 * \param from The id of the vertex from/to which the geodesics are
 *        calculated.
 * \param to Vertex sequence with the ids of the vertices to/from which the
 *        shortest paths will be calculated. A vertex might be given multiple
 *        times.
* \param weights The edge weights. All edge weights must be
 *       non-negative for Dijkstra's algorithm to work. Additionally, no
 *       edge weight may be NaN. If either case does not hold, an error
 *       is returned. If this is a null pointer, then the unweighted
 *       version, \ref igraph_get_shortest_paths() is called.
 * \param mode The type of shortest paths to be use for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param predecessors A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the predecessor of each vertex in
 *        the single source shortest path tree is returned here. The
 *        predecessor of vertex i in the tree is the vertex from which vertex i
 *        was reached. The predecessor of the start vertex (in the \c from
 *        argument) is itself by definition. If the predecessor is -1, it means
 *        that the given vertex was not reached from the source during the
 *        search. Note that the search terminates if all the vertices in
 *        \c to are reached.
 * \param inbound_edges A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the inbound edge of each vertex in
 *        the single source shortest path tree is returned here. The
 *        inbound edge of vertex i in the tree is the edge via which vertex i
 *        was reached. The start vertex and vertices that were not reached
 *        during the search will have -1 in the corresponding entry of the
 *        vector. Note that the search terminates if all the vertices in
 *        \c to are reached.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           \p from is invalid vertex id, or the length of \p to is
 *           not the same as the length of \p res.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(|E|log|E|+|V|), where |V| is the number of
 * vertices and |E| is the number of edges
 *
 * \sa \ref igraph_shortest_paths_dijkstra() if you only need the path length but
 * not the paths themselves, \ref igraph_get_shortest_paths() if all edge
 * weights are equal.
 *
 * \example examples/simple/igraph_get_shortest_paths_dijkstra.c
 */
int igraph_get_shortest_paths_dijkstra(const igraph_t *graph,
                                       igraph_vector_ptr_t *vertices,
                                       igraph_vector_ptr_t *edges,
                                       igraph_integer_t from,
                                       igraph_vs_t to,
                                       const igraph_vector_t *weights,
                                       igraph_neimode_t mode,
                                       igraph_vector_long_t *predecessors,
                                       igraph_vector_long_t *inbound_edges) {
    /* Implementation details. This is the basic Dijkstra algorithm,
       with a binary heap. The heap is indexed, i.e. it stores not only
       the distances, but also which vertex they belong to. The other
       mapping, i.e. getting the distance for a vertex is not in the
       heap (that would by the double-indexed heap), but in the result
       matrix.

       Dirty tricks:
       - the opposite of the distance is stored in the heap, as it is a
         maximum heap and we need a minimum heap.
       - we don't use IGRAPH_INFINITY in the distance vector during the
         computation, as IGRAPH_FINITE() might involve a function call
         and we want to spare that. So we store distance+1.0 instead of
         distance, and zero denotes infinity.
       - `parents' assigns the inbound edge IDs of all vertices in the
         shortest path tree to the vertices. In this implementation, the
         edge ID + 1 is stored, zero means unreachable vertices.
    */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vit_t vit;
    igraph_2wheap_t Q;
    igraph_lazy_inclist_t inclist;
    igraph_vector_t dists;
    long int *parents;
    igraph_bool_t *is_target;
    long int i, to_reach;

    if (!weights) {
        return igraph_get_shortest_paths(graph, vertices, edges, from, to, mode,
                                         predecessors, inbound_edges);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length does not match", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0) {
        igraph_real_t min = igraph_vector_min(weights);
        if (min < 0) {
            IGRAPH_ERROR("Weight vector must be non-negative", IGRAPH_EINVAL);
        }
        else if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    if (vertices && IGRAPH_VIT_SIZE(vit) != igraph_vector_ptr_size(vertices)) {
        IGRAPH_ERROR("Size of `vertices' and `to' should match", IGRAPH_EINVAL);
    }
    if (edges && IGRAPH_VIT_SIZE(vit) != igraph_vector_ptr_size(edges)) {
        IGRAPH_ERROR("Size of `edges' and `to' should match", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_VECTOR_INIT_FINALLY(&dists, no_of_nodes);
    igraph_vector_fill(&dists, -1.0);

    parents = IGRAPH_CALLOC(no_of_nodes, long int);
    if (parents == 0) {
        IGRAPH_ERROR("Can't calculate shortest paths", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, parents);
    is_target = IGRAPH_CALLOC(no_of_nodes, igraph_bool_t);
    if (is_target == 0) {
        IGRAPH_ERROR("Can't calculate shortest paths", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, is_target);

    /* Mark the vertices we need to reach */
    to_reach = IGRAPH_VIT_SIZE(vit);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        if (!is_target[ (long int) IGRAPH_VIT_GET(vit) ]) {
            is_target[ (long int) IGRAPH_VIT_GET(vit) ] = 1;
        } else {
            to_reach--;       /* this node was given multiple times */
        }
    }

    VECTOR(dists)[(long int)from] = 0.0;  /* zero distance */
    parents[(long int)from] = 0;
    igraph_2wheap_push_with_index(&Q, from, 0);

    while (!igraph_2wheap_empty(&Q) && to_reach > 0) {
        long int nlen, minnei = igraph_2wheap_max_index(&Q);
        igraph_real_t mindist = -igraph_2wheap_delete_max(&Q);
        igraph_vector_int_t *neis;

        IGRAPH_ALLOW_INTERRUPTION();

        if (is_target[minnei]) {
            is_target[minnei] = 0;
            to_reach--;
        }

        /* Now check all neighbors of 'minnei' for a shorter path */
        neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) minnei);
        nlen = igraph_vector_int_size(neis);
        for (i = 0; i < nlen; i++) {
            long int edge = (long int) VECTOR(*neis)[i];
            long int tto = IGRAPH_OTHER(graph, edge, minnei);
            igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
            igraph_real_t curdist = VECTOR(dists)[tto];
            if (curdist < 0) {
                /* This is the first finite distance */
                VECTOR(dists)[tto] = altdist;
                parents[tto] = edge + 1;
                IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, tto, -altdist));
            } else if (altdist < curdist) {
                /* This is a shorter path */
                VECTOR(dists)[tto] = altdist;
                parents[tto] = edge + 1;
                IGRAPH_CHECK(igraph_2wheap_modify(&Q, tto, -altdist));
            }
        }
    } /* !igraph_2wheap_empty(&Q) */

    if (to_reach > 0) {
        IGRAPH_WARNING("Couldn't reach some vertices");
    }

    /* Create `predecessors' if needed */
    if (predecessors) {
        IGRAPH_CHECK(igraph_vector_long_resize(predecessors, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (i == from) {
                /* i is the start vertex */
                VECTOR(*predecessors)[i] = i;
            } else if (parents[i] <= 0) {
                /* i was not reached */
                VECTOR(*predecessors)[i] = -1;
            } else {
                /* i was reached via the edge with ID = parents[i] - 1 */
                VECTOR(*predecessors)[i] = IGRAPH_OTHER(graph, parents[i] - 1, i);
            }
        }
    }

    /* Create `inbound_edges' if needed */
    if (inbound_edges) {
        IGRAPH_CHECK(igraph_vector_long_resize(inbound_edges, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (parents[i] <= 0) {
                /* i was not reached */
                VECTOR(*inbound_edges)[i] = -1;
            } else {
                /* i was reached via the edge with ID = parents[i] - 1 */
                VECTOR(*inbound_edges)[i] = parents[i] - 1;
            }
        }
    }

    /* Reconstruct the shortest paths based on vertex and/or edge IDs */
    if (vertices || edges) {
        for (IGRAPH_VIT_RESET(vit), i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
            long int node = IGRAPH_VIT_GET(vit);
            long int size, act, edge;
            igraph_vector_t *vvec = 0, *evec = 0;
            if (vertices) {
                vvec = VECTOR(*vertices)[i];
                igraph_vector_clear(vvec);
            }
            if (edges) {
                evec = VECTOR(*edges)[i];
                igraph_vector_clear(evec);
            }

            IGRAPH_ALLOW_INTERRUPTION();

            size = 0;
            act = node;
            while (parents[act]) {
                size++;
                edge = parents[act] - 1;
                act = IGRAPH_OTHER(graph, edge, act);
            }
            if (vvec && (size > 0 || node == from)) {
                IGRAPH_CHECK(igraph_vector_resize(vvec, size + 1));
                VECTOR(*vvec)[size] = node;
            }
            if (evec) {
                IGRAPH_CHECK(igraph_vector_resize(evec, size));
            }
            act = node;
            while (parents[act]) {
                edge = parents[act] - 1;
                act = IGRAPH_OTHER(graph, edge, act);
                size--;
                if (vvec) {
                    VECTOR(*vvec)[size] = act;
                }
                if (evec) {
                    VECTOR(*evec)[size] = edge;
                }
            }
        }
    }

    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    igraph_vector_destroy(&dists);
    IGRAPH_FREE(is_target);
    IGRAPH_FREE(parents);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(6);

    return 0;
}

/**
 * \function igraph_get_shortest_path_dijkstra
 * \brief Weighted shortest path from one vertex to another one.
 *
 * Calculates a single (positively) weighted shortest path from
 * a single vertex to another one, using Dijkstra's algorithm.
 *
 * This function is a special case (and a wrapper) to
 * \ref igraph_get_shortest_paths_dijkstra().
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param vertices Pointer to an initialized vector or a null
 *        pointer. If not a null pointer, then the vertex ids along
 *        the path are stored here, including the source and target
 *        vertices.
 * \param edges Pointer to an uninitialized vector or a null
 *        pointer. If not a null pointer, then the edge ids along the
 *        path are stored here.
 * \param from The id of the source vertex.
 * \param to The id of the target vertex.
 * \param weights The edge weights. All edge weights must be
 *       non-negative for Dijkstra's algorithm to work. Additionally, no
 *       edge weight may be NaN. If either case does not hold, an error
 *       is returned. If this is a null pointer, then the unweighted
 *       version, \ref igraph_get_shortest_paths() is called.
 * \param mode A constant specifying how edge directions are
 *        considered in directed graphs. \c IGRAPH_OUT follows edge
 *        directions, \c IGRAPH_IN follows the opposite directions,
 *        and \c IGRAPH_ALL ignores edge directions. This argument is
 *        ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|E|log|E|+|V|), |V| is the number of vertices,
 * |E| is the number of edges in the graph.
 *
 * \sa \ref igraph_get_shortest_paths_dijkstra() for the version with
 * more target vertices.
 */

int igraph_get_shortest_path_dijkstra(const igraph_t *graph,
                                      igraph_vector_t *vertices,
                                      igraph_vector_t *edges,
                                      igraph_integer_t from,
                                      igraph_integer_t to,
                                      const igraph_vector_t *weights,
                                      igraph_neimode_t mode) {

    igraph_vector_ptr_t vertices2, *vp = &vertices2;
    igraph_vector_ptr_t edges2, *ep = &edges2;

    if (vertices) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&vertices2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vertices2);
        VECTOR(vertices2)[0] = vertices;
    } else {
        vp = 0;
    }
    if (edges) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&edges2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &edges2);
        VECTOR(edges2)[0] = edges;
    } else {
        ep = 0;
    }

    IGRAPH_CHECK(igraph_get_shortest_paths_dijkstra(graph, vp, ep,
                 from, igraph_vss_1(to),
                 weights, mode, 0, 0));

    if (edges) {
        igraph_vector_ptr_destroy(&edges2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (vertices) {
        igraph_vector_ptr_destroy(&vertices2);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/* Compares two paths based on their last elements. Required by
 * igraph_get_all_shortest_paths_dijkstra to put the final result
 * in order. Assumes that both paths are pointers to igraph_vector_t
 * objects and that they are not empty
 */
static int igraph_i_vector_tail_cmp(const void* path1, const void* path2) {
    return (int) (igraph_vector_tail(*(const igraph_vector_t**)path1) -
                  igraph_vector_tail(*(const igraph_vector_t**)path2));
}

/**
 * \ingroup structural
 * \function igraph_get_all_shortest_paths_dijkstra
 * \brief All weighted shortest paths (geodesics) from a vertex.
 *
 * \param graph The graph object.
 * \param res Pointer to an initialized pointer vector, the result
 *   will be stored here in igraph_vector_t objects. Each vector
 *   object contains the vertices along a shortest path from \p from
 *   to another vertex. The vectors are ordered according to their
 *   target vertex: first the shortest paths to vertex 0, then to
 *   vertex 1, etc. No data is included for unreachable vertices.
 * \param nrgeo Pointer to an initialized igraph_vector_t object or
 *   NULL. If not NULL the number of shortest paths from \p from are
 *   stored here for every vertex in the graph. Note that the values
 *   will be accurate only for those vertices that are in the target
 *   vertex sequence (see \p to), since the search terminates as soon
 *   as all the target vertices have been found.
 * \param from The id of the vertex from/to which the geodesics are
 *        calculated.
 * \param to Vertex sequence with the ids of the vertices to/from which the
 *        shortest paths will be calculated. A vertex might be given multiple
 *        times.
 * \param weights The edge weights. All edge weights must be
 *       non-negative for Dijkstra's algorithm to work. Additionally, no
 *       edge weight may be NaN. If either case does not hold, an error
 *       is returned. If this is a null pointer, then the unweighted
 *       version, \ref igraph_get_all_shortest_paths() is called.
 * \param mode The type of shortest paths to be use for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           \p from is invalid vertex id, or the length of \p to is
 *           not the same as the length of \p res.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(|E|log|E|+|V|), where |V| is the number of
 * vertices and |E| is the number of edges
 *
 * \sa \ref igraph_shortest_paths_dijkstra() if you only need the path
 * length but not the paths themselves, \ref igraph_get_all_shortest_paths()
 * if all edge weights are equal.
 *
 * \example examples/simple/igraph_get_all_shortest_paths_dijkstra.c
 */
int igraph_get_all_shortest_paths_dijkstra(const igraph_t *graph,
        igraph_vector_ptr_t *res,
        igraph_vector_t *nrgeo,
        igraph_integer_t from, igraph_vs_t to,
        const igraph_vector_t *weights,
        igraph_neimode_t mode) {
    /* Implementation details: see igraph_get_shortest_paths_dijkstra,
       it's basically the same.
    */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vit_t vit;
    igraph_2wheap_t Q;
    igraph_lazy_inclist_t inclist;
    igraph_vector_t dists, order;
    igraph_vector_ptr_t parents;
    igraph_finally_func_t *res_item_destructor;
    unsigned char *is_target;
    long int i, n, to_reach;

    if (!weights) {
        return igraph_get_all_shortest_paths(graph, res, nrgeo, from, to, mode);
    }

    if (res == 0 && nrgeo == 0) {
        return IGRAPH_SUCCESS;
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length does not match", IGRAPH_EINVAL);
    }
    if (no_of_edges > 0) {
        igraph_real_t min = igraph_vector_min(weights);
        if (min < 0) {
            IGRAPH_ERROR("Weight vector must be non-negative", IGRAPH_EINVAL);
        }
        else if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
        }
    }

    /* parents stores a vector for each vertex, listing the parent vertices
     * of each vertex in the traversal */
    IGRAPH_CHECK(igraph_vector_ptr_init(&parents, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &parents);
    igraph_vector_ptr_set_item_destructor(&parents, (igraph_finally_func_t*)igraph_vector_destroy);
    for (i = 0; i < no_of_nodes; i++) {
        igraph_vector_t* parent_vec;
        parent_vec = IGRAPH_CALLOC(1, igraph_vector_t);
        if (parent_vec == 0) {
            IGRAPH_ERROR("cannot run igraph_get_all_shortest_paths", IGRAPH_ENOMEM);
        }
        IGRAPH_CHECK(igraph_vector_init(parent_vec, 0));
        VECTOR(parents)[i] = parent_vec;
    }

    /* distance of each vertex from the root */
    IGRAPH_VECTOR_INIT_FINALLY(&dists, no_of_nodes);
    igraph_vector_fill(&dists, -1.0);

    /* order lists the order of vertices in which they were found during
     * the traversal */
    IGRAPH_VECTOR_INIT_FINALLY(&order, 0);

    /* boolean array to mark whether a given vertex is a target or not */
    is_target = IGRAPH_CALLOC(no_of_nodes, unsigned char);
    if (is_target == 0) {
        IGRAPH_ERROR("Can't calculate shortest paths", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, is_target);

    /* two-way heap storing vertices and distances */
    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);

    /* lazy adjacency edge list to query neighbours efficiently */
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    /* Mark the vertices we need to reach */
    IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    to_reach = IGRAPH_VIT_SIZE(vit);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        if (!is_target[ (long int) IGRAPH_VIT_GET(vit) ]) {
            is_target[ (long int) IGRAPH_VIT_GET(vit) ] = 1;
        } else {
            to_reach--;       /* this node was given multiple times */
        }
    }
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    VECTOR(dists)[(long int)from] = 0.0;  /* zero distance */
    igraph_2wheap_push_with_index(&Q, from, 0);

    while (!igraph_2wheap_empty(&Q) && to_reach > 0) {
        long int nlen, minnei = igraph_2wheap_max_index(&Q);
        igraph_real_t mindist = -igraph_2wheap_delete_max(&Q);
        igraph_vector_int_t *neis;

        IGRAPH_ALLOW_INTERRUPTION();

        /*
        printf("Reached vertex %ld, is_target[%ld] = %d, %ld to go\n",
            minnei, minnei, (int)is_target[minnei], to_reach - is_target[minnei]);
        */

        if (is_target[minnei]) {
            is_target[minnei] = 0;
            to_reach--;
        }

        /* Mark that we have reached this vertex */
        IGRAPH_CHECK(igraph_vector_push_back(&order, minnei));

        /* Now check all neighbors of 'minnei' for a shorter path */
        neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) minnei);
        nlen = igraph_vector_int_size(neis);
        for (i = 0; i < nlen; i++) {
            long int edge = (long int) VECTOR(*neis)[i];
            long int tto = IGRAPH_OTHER(graph, edge, minnei);
            igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
            igraph_real_t curdist = VECTOR(dists)[tto];
            igraph_vector_t *parent_vec;

            if (curdist < 0) {
                /* This is the first non-infinite distance */
                VECTOR(dists)[tto] = altdist;
                parent_vec = (igraph_vector_t*)VECTOR(parents)[tto];
                IGRAPH_CHECK(igraph_vector_push_back(parent_vec, minnei));
                IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, tto, -altdist));
            } else if (altdist == curdist && VECTOR(*weights)[edge] > 0) {
                /* This is an alternative path with exactly the same length.
                     * Note that we consider this case only if the edge via which we
                     * reached the node has a nonzero weight; otherwise we could create
                     * infinite loops in undirected graphs by traversing zero-weight edges
                     * back-and-forth */
                parent_vec = (igraph_vector_t*)VECTOR(parents)[tto];
                IGRAPH_CHECK(igraph_vector_push_back(parent_vec, minnei));
            } else if (altdist < curdist) {
                /* This is a shorter path */
                VECTOR(dists)[tto] = altdist;
                parent_vec = (igraph_vector_t*)VECTOR(parents)[tto];
                igraph_vector_clear(parent_vec);
                IGRAPH_CHECK(igraph_vector_push_back(parent_vec, minnei));
                IGRAPH_CHECK(igraph_2wheap_modify(&Q, tto, -altdist));
            }
        }
    } /* !igraph_2wheap_empty(&Q) */

    if (to_reach > 0) {
        IGRAPH_WARNING("Couldn't reach some vertices");
    }

    /* we don't need these anymore */
    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(2);

    /*
    printf("Order:\n");
    igraph_vector_print(&order);

    printf("Parent vertices:\n");
    for (i = 0; i < no_of_nodes; i++) {
      if (igraph_vector_size(VECTOR(parents)[i]) > 0) {
        printf("[%ld]: ", (long int)i);
        igraph_vector_print(VECTOR(parents)[i]);
      }
    }
    */

    if (nrgeo) {
        IGRAPH_CHECK(igraph_vector_resize(nrgeo, no_of_nodes));
        igraph_vector_null(nrgeo);

        /* Theoretically, we could calculate nrgeo in parallel with the traversal.
         * However, that way we would have to check whether nrgeo is null or not
         * every time we want to update some element in nrgeo. Since we need the
         * order vector anyway for building the final result, we could just as well
         * build nrgeo here.
         */
        VECTOR(*nrgeo)[(long int)from] = 1;
        n = igraph_vector_size(&order);
        for (i = 1; i < n; i++) {
            long int node, j, k;
            igraph_vector_t *parent_vec;

            node = (long int)VECTOR(order)[i];
            /* now, take the parent vertices */
            parent_vec = (igraph_vector_t*)VECTOR(parents)[node];
            k = igraph_vector_size(parent_vec);
            for (j = 0; j < k; j++) {
                VECTOR(*nrgeo)[node] += VECTOR(*nrgeo)[(long int)VECTOR(*parent_vec)[j]];
            }
        }
    }

    if (res) {
        igraph_vector_t *path, *paths_index, *parent_vec;
        igraph_stack_t stack;
        long int j, node;

        /* a shortest path from the starting vertex to vertex i can be
         * obtained by calculating the shortest paths from the "parents"
         * of vertex i in the traversal. Knowing which of the vertices
         * are "targets" (see is_target), we can collect for which other
         * vertices do we need to calculate the shortest paths. We reuse
         * is_target for that; is_target = 0 means that we don't need the
         * vertex, is_target = 1 means that the vertex is a target (hence
         * we need it), is_target = 2 means that the vertex is not a target
         * but it stands between a shortest path between the root and one
         * of the targets
         */
        if (igraph_vs_is_all(&to)) {
            memset(is_target, 1, sizeof(unsigned char) * (size_t) no_of_nodes);
        } else {
            memset(is_target, 0, sizeof(unsigned char) * (size_t) no_of_nodes);

            IGRAPH_CHECK(igraph_stack_init(&stack, 0));
            IGRAPH_FINALLY(igraph_stack_destroy, &stack);

            /* Add the target vertices to the queue */
            IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
            IGRAPH_FINALLY(igraph_vit_destroy, &vit);
            for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
                i = (long int) IGRAPH_VIT_GET(vit);
                if (!is_target[i]) {
                    is_target[i] = 1;
                    IGRAPH_CHECK(igraph_stack_push(&stack, i));
                }
            }
            igraph_vit_destroy(&vit);
            IGRAPH_FINALLY_CLEAN(1);

            while (!igraph_stack_empty(&stack)) {
                /* For each parent of node i, get its parents */
                igraph_real_t el = igraph_stack_pop(&stack);
                parent_vec = (igraph_vector_t*)VECTOR(parents)[(long int) el];
                i = igraph_vector_size(parent_vec);

                for (j = 0; j < i; j++) {
                    /* For each parent, check if it's already in the stack.
                     * If not, push it and mark it in is_target */
                    n = (long int) VECTOR(*parent_vec)[j];
                    if (!is_target[n]) {
                        is_target[n] = 2;
                        IGRAPH_CHECK(igraph_stack_push(&stack, n));
                    }
                }
            }
            igraph_stack_destroy(&stack);
            IGRAPH_FINALLY_CLEAN(1);
        }

        /* now, reconstruct the shortest paths from the parent list in the
         * order we've found the nodes during the traversal.
         * dists is being re-used as a vector where element i tells the
         * index in res where the shortest paths leading to vertex i
         * start, plus one (so that zero means that there are no paths
         * for a given vertex).
         */
        paths_index = &dists;
        n = igraph_vector_size(&order);
        igraph_vector_null(paths_index);

        /* clear the paths vector */
        igraph_vector_ptr_clear(res);
        res_item_destructor = igraph_vector_ptr_get_item_destructor(res);
        igraph_vector_ptr_set_item_destructor(res,
                                              (igraph_finally_func_t*)igraph_vector_destroy);

        /* by definition, the shortest path leading to the starting vertex
         * consists of the vertex itself only */
        path = IGRAPH_CALLOC(1, igraph_vector_t);
        if (path == 0)
            IGRAPH_ERROR("cannot run igraph_get_all_shortest_paths_dijkstra",
                         IGRAPH_ENOMEM);
        IGRAPH_FINALLY(igraph_free, path);
        IGRAPH_CHECK(igraph_vector_init(path, 1));
        IGRAPH_CHECK(igraph_vector_ptr_push_back(res, path));
        IGRAPH_FINALLY_CLEAN(1);  /* ownership of path passed to res */
        VECTOR(*path)[0] = from;
        VECTOR(*paths_index)[(long int)from] = 1;

        for (i = 1; i < n; i++) {
            long int m, path_count;
            igraph_vector_t *parent_path;

            node = (long int) VECTOR(order)[i];

            /* if we don't need the shortest paths for this node (because
             * it is not standing in a shortest path between the source
             * node and any of the target nodes), skip it */
            if (!is_target[node]) {
                continue;
            }

            IGRAPH_ALLOW_INTERRUPTION();

            /* we are calculating the shortest paths of node now. */
            /* first, we update the paths_index */
            path_count = igraph_vector_ptr_size(res);
            VECTOR(*paths_index)[node] = path_count + 1;
            /* res_end = (igraph_vector_t*)&(VECTOR(*res)[path_count]); */

            /* now, take the parent vertices */
            parent_vec = (igraph_vector_t*)VECTOR(parents)[node];
            m = igraph_vector_size(parent_vec);

            /*
            printf("Calculating shortest paths to vertex %ld\n", node);
            printf("Parents are: ");
            igraph_vector_print(parent_vec);
            */

            for (j = 0; j < m; j++) {
                /* for each parent, copy the shortest paths leading to that parent
                 * and add the current vertex in the end */
                long int parent_node = (long int) VECTOR(*parent_vec)[j];
                long int parent_path_idx = (long int) VECTOR(*paths_index)[parent_node] - 1;
                /*
                printf("  Considering parent: %ld\n", parent_node);
                printf("  Paths to parent start at index %ld in res\n", parent_path_idx);
                */
                IGRAPH_ASSERT(parent_path_idx >= 0);
                for (; parent_path_idx < path_count; parent_path_idx++) {
                    parent_path = (igraph_vector_t*)VECTOR(*res)[parent_path_idx];
                    if (igraph_vector_tail(parent_path) != parent_node) {
                        break;
                    }

                    path = IGRAPH_CALLOC(1, igraph_vector_t);
                    if (path == 0)
                        IGRAPH_ERROR("cannot run igraph_get_all_shortest_paths_dijkstra",
                                     IGRAPH_ENOMEM);
                    IGRAPH_FINALLY(igraph_free, path);
                    IGRAPH_CHECK(igraph_vector_copy(path, parent_path));
                    IGRAPH_CHECK(igraph_vector_ptr_push_back(res, path));
                    IGRAPH_FINALLY_CLEAN(1);  /* ownership of path passed to res */
                    IGRAPH_CHECK(igraph_vector_push_back(path, node));
                }
            }
        }

        /* remove the path vector's original item destructor */
        igraph_vector_ptr_set_item_destructor(res, res_item_destructor);

        /* free those paths from the result vector which we won't need */
        n = igraph_vector_ptr_size(res);
        j = 0;
        for (i = 0; i < n; i++) {
            igraph_real_t tmp;
            path = (igraph_vector_t*)VECTOR(*res)[i];
            tmp = igraph_vector_tail(path);
            if (is_target[(long int)tmp] == 1) {
                /* we need this path, keep it */
                VECTOR(*res)[j] = path;
                j++;
            } else {
                /* we don't need this path, free it */
                igraph_vector_destroy(path); free(path);
            }
        }
        IGRAPH_CHECK(igraph_vector_ptr_resize(res, j));

        /* sort the paths by the target vertices */
        igraph_vector_ptr_sort(res, igraph_i_vector_tail_cmp);
    }

    /* free the allocated memory */
    igraph_vector_destroy(&order);
    IGRAPH_FREE(is_target);
    igraph_vector_destroy(&dists);
    igraph_vector_ptr_destroy_all(&parents);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/distances.c0000644000175100001710000001642600000000000023712 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_paths.h"

#include "igraph_datatype.h"
#include "igraph_dqueue.h"
#include "igraph_iterators.h"
#include "igraph_vector.h"
#include "igraph_interface.h"
#include "igraph_adjlist.h"

#include "core/interruption.h"

static int igraph_i_eccentricity(const igraph_t *graph,
                                 igraph_vector_t *res,
                                 igraph_vs_t vids,
                                 igraph_neimode_t mode,
                                 const igraph_adjlist_t *adjlist) {

    int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_long_t q;
    igraph_vit_t vit;
    igraph_vector_int_t counted;
    int i, mark = 1;
    igraph_vector_t vneis;
    igraph_vector_int_t *neis;

    IGRAPH_CHECK(igraph_dqueue_long_init(&q, 100));
    IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    IGRAPH_CHECK(igraph_vector_int_init(&counted, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &counted);

    if (!adjlist) {
        IGRAPH_VECTOR_INIT_FINALLY(&vneis, 0);
    }

    IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));
    igraph_vector_fill(res, -1);

    for (i = 0, IGRAPH_VIT_RESET(vit);
         !IGRAPH_VIT_END(vit);
         IGRAPH_VIT_NEXT(vit), mark++, i++) {

        long int source;
        source = IGRAPH_VIT_GET(vit);
        IGRAPH_CHECK(igraph_dqueue_long_push(&q, source));
        IGRAPH_CHECK(igraph_dqueue_long_push(&q, 0));
        VECTOR(counted)[source] = mark;

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_long_empty(&q)) {
            long int act = igraph_dqueue_long_pop(&q);
            long int dist = igraph_dqueue_long_pop(&q);
            int j, n;

            if (dist > VECTOR(*res)[i]) {
                VECTOR(*res)[i] = dist;
            }

            if (adjlist) {
                neis = igraph_adjlist_get(adjlist, act);
                n = (int) igraph_vector_int_size(neis);
                for (j = 0; j < n; j++) {
                    int nei = (int) VECTOR(*neis)[j];
                    if (VECTOR(counted)[nei] != mark) {
                        VECTOR(counted)[nei] = mark;
                        IGRAPH_CHECK(igraph_dqueue_long_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_long_push(&q, dist + 1));
                    }
                }
            } else {
                IGRAPH_CHECK(igraph_neighbors(graph, &vneis,
                                              (igraph_integer_t) act, mode));
                n = (int) igraph_vector_size(&vneis);
                for (j = 0; j < n; j++) {
                    int nei = (int) VECTOR(vneis)[j];
                    if (VECTOR(counted)[nei] != mark) {
                        VECTOR(counted)[nei] = mark;
                        IGRAPH_CHECK(igraph_dqueue_long_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_long_push(&q, dist + 1));
                    }
                }
            }
        } /* while !igraph_dqueue_long_empty(dqueue) */

    } /* for IGRAPH_VIT_NEXT(vit) */

    if (!adjlist) {
        igraph_vector_destroy(&vneis);
        IGRAPH_FINALLY_CLEAN(1);
    }
    igraph_vector_int_destroy(&counted);
    igraph_vit_destroy(&vit);
    igraph_dqueue_long_destroy(&q);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_eccentricity
 * \brief Eccentricity of some vertices.
 *
 * The eccentricity of a vertex is calculated by measuring the shortest
 * distance from (or to) the vertex, to (or from) all vertices in the
 * graph, and taking the maximum.
 *
 * 
 * This implementation ignores vertex pairs that are in different
 * components. Isolated vertices have eccentricity zero.
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param res Pointer to an initialized vector, the result is stored
 *    here.
 * \param vids The vertices for which the eccentricity is calculated.
 * \param mode What kind of paths to consider for the calculation:
 *    \c IGRAPH_OUT, paths that follow edge directions;
 *    \c IGRAPH_IN, paths that follow the opposite directions; and
 *    \c IGRAPH_ALL, paths that ignore edge directions. This argument
 *    is ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(v*(|V|+|E|)), where |V| is the number of
 * vertices, |E| is the number of edges and v is the number of
 * vertices for which eccentricity is calculated.
 *
 * \sa \ref igraph_radius().
 *
 * \example examples/simple/igraph_eccentricity.c
 */

int igraph_eccentricity(const igraph_t *graph,
                        igraph_vector_t *res,
                        igraph_vs_t vids,
                        igraph_neimode_t mode) {

    return igraph_i_eccentricity(graph, res, vids, mode, /*adjlist=*/ 0);
}

/**
 * \function igraph_radius
 * \brief Radius of a graph.
 *
 * The radius of a graph is the defined as the minimum eccentricity of
 * its vertices, see \ref igraph_eccentricity().
 *
 * \param graph The input graph, it can be directed or undirected.
 * \param radius Pointer to a real variable, the result is stored
 *   here.
 * \param mode What kind of paths to consider for the calculation:
 *    \c IGRAPH_OUT, paths that follow edge directions;
 *    \c IGRAPH_IN, paths that follow the opposite directions; and
 *    \c IGRAPH_ALL, paths that ignore edge directions. This argument
 *    is ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|V|(|V|+|E|)), where |V| is the number of
 * vertices and |E| is the number of edges.
 *
 * \sa \ref igraph_eccentricity().
 *
 * \example examples/simple/igraph_radius.c
 */

int igraph_radius(const igraph_t *graph, igraph_real_t *radius,
                  igraph_neimode_t mode) {

    int no_of_nodes = igraph_vcount(graph);

    if (no_of_nodes == 0) {
        *radius = IGRAPH_NAN;
    } else {
        igraph_adjlist_t adjlist;
        igraph_vector_t ecc;
        IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
        IGRAPH_VECTOR_INIT_FINALLY(&ecc, igraph_vcount(graph));
        IGRAPH_CHECK(igraph_i_eccentricity(graph, &ecc, igraph_vss_all(),
                                           mode, &adjlist));
        *radius = igraph_vector_min(&ecc);
        igraph_vector_destroy(&ecc);
        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FINALLY_CLEAN(2);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/eulerian.c0000644000175100001710000005415700000000000023544 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include "igraph_eulerian.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_components.h"
#include "igraph_stack.h"

/**
 * \section about_eulerian
 *
 * These functions calculate whether an Eulerian path or cycle exists
 * and if so, can find them.
 */


/* solution adapted from https://www.geeksforgeeks.org/eulerian-path-and-circuit/
The function returns one of the following values
has_path is set to 1 if a path exists, 0 otherwise
has_cycle is set to 1 if a cycle exists, 0 otherwise
*/
static int igraph_i_is_eulerian_undirected(const igraph_t *graph, igraph_bool_t *has_path, igraph_bool_t *has_cycle, igraph_integer_t *start_of_path) {
    igraph_integer_t odd;
    igraph_vector_t degree, csize;
    /* boolean vector to mark singletons: */
    igraph_vector_t nonsingleton;
    long int i, n, vsize;
    long int cluster_count;
    /* number of self-looping singletons: */
    long int es;
    /* will be set to 1 if there are non-isolated vertices, otherwise 0: */
    long int ens;

    n = igraph_vcount(graph);

    if (igraph_ecount(graph) == 0 || n <= 1) {
        start_of_path = 0; /* in case the graph has one vertex with self-loops */
        *has_path = 1;
        *has_cycle = 1;
        return  IGRAPH_SUCCESS;
    }

    /* check for connectedness, but singletons are special since they affect
     * the Eulerian nature only if there is a self-loop AND another edge
     * somewhere else in the graph */
    IGRAPH_VECTOR_INIT_FINALLY(&csize, 0);
    IGRAPH_CHECK(igraph_clusters(graph, NULL, &csize, NULL, IGRAPH_WEAK));
    cluster_count = 0;
    vsize = igraph_vector_size(&csize);
    for (i = 0; i < vsize; i++) {
        if (VECTOR(csize)[i] > 1) {
            cluster_count++;
            if (cluster_count > 1) {
                /* disconnected edges, they'll never reach each other */
                *has_path = 0;
                *has_cycle = 0;
                igraph_vector_destroy(&csize);
                IGRAPH_FINALLY_CLEAN(1);

                return IGRAPH_SUCCESS;
            }
        }
    }

    igraph_vector_destroy(&csize);
    IGRAPH_FINALLY_CLEAN(1);

    /* the graph is connected except for singletons */
    /* find singletons (including those with self-loops) */
    IGRAPH_VECTOR_INIT_FINALLY(&nonsingleton, 0);
    IGRAPH_CHECK(igraph_degree(graph, &nonsingleton, igraph_vss_all(), IGRAPH_ALL, IGRAPH_NO_LOOPS));

    /* check the degrees for odd/even:
     * - >= 2 odd means no cycle (1 odd is impossible)
     * - > 2 odd means no path
     * plus there are a few corner cases with singletons
     */
    IGRAPH_VECTOR_INIT_FINALLY(°ree, 0);
    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS));
    odd = 0;
    es = 0;
    ens = 0;
    for (i = 0; i < n; i++) {
        long int deg = (long int) VECTOR(degree)[i];
        /* Eulerian is about edges, so skip free vertices */
        if (deg == 0) continue;

        if (!VECTOR(nonsingleton)[i]) {
            /* singleton with self loops */
            es++;
        } else {
            /* at least one non-singleton */
            ens = 1;
            /* note: self-loops count for two (in and out) */
            if (deg % 2) odd++;
        }

        if (es + ens > 1) {
            /* 2+ singletons with self loops or singleton with self-loops and
             * 1+ edges in the non-singleton part of the graph. */
            *has_path = 0;
            *has_cycle = 0;
            igraph_vector_destroy(&nonsingleton);
            igraph_vector_destroy(°ree);
            IGRAPH_FINALLY_CLEAN(2);

            return IGRAPH_SUCCESS;
        }
    }

    igraph_vector_destroy(&nonsingleton);
    IGRAPH_FINALLY_CLEAN(1);

    /* this is the usual algorithm on the connected part of the graph */
    if (odd > 2) {
        *has_path = 0;
        *has_cycle = 0;
    } else if (odd == 2) {
        *has_path = 1;
        *has_cycle = 0;
    } else {
        *has_path = 1;
        *has_cycle = 1;
    }

    /* set start of path if there is one but there is no cycle */
    /* note: we cannot do this in the previous loop because at that time we are
     * not sure yet if a path exists */
    for (i = 0; i < n; i++) {
        if ((*has_cycle && ((long int) VECTOR(degree)[i]) > 0) || (!*has_cycle && ((long int) VECTOR(degree)[i]) %2 == 1)) {
            *start_of_path = i;
            break;
        }
    }

    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


static int igraph_i_is_eulerian_directed(const igraph_t *graph, igraph_bool_t *has_path, igraph_bool_t *has_cycle,                                         igraph_integer_t *start_of_path) {
    igraph_integer_t incoming_excess, outgoing_excess, n;
    long int i, vsize;
    long int cluster_count;
    igraph_vector_t out_degree, in_degree, csize;
    /* boolean vector to mark singletons: */
    igraph_vector_t nonsingleton;
    /* number of self-looping singletons: */
    long int es;
    /* will be set to 1 if there are non-isolated vertices, otherwise 0: */
    long int ens;

    n = igraph_vcount(graph);

    if (igraph_ecount(graph) == 0 || n <= 1) {
        start_of_path = 0; /* in case the graph has one vertex with self-loops */
        *has_path = 1;
        *has_cycle = 1;
        return IGRAPH_SUCCESS;
    }

    incoming_excess = 0;
    outgoing_excess = 0;

    /* check for weak connectedness, but singletons are special since they affect
     * the Eulerian nature only if there is a self-loop AND another edge
     * somewhere else in the graph */
    IGRAPH_VECTOR_INIT_FINALLY(&csize, 0);

    IGRAPH_CHECK(igraph_clusters(graph, NULL, &csize, NULL, IGRAPH_WEAK));
    cluster_count = 0;
    vsize = igraph_vector_size(&csize);
    for (i = 0; i < vsize; i++) {
        if (VECTOR(csize)[i] > 1) {
            cluster_count++;
            if (cluster_count > 1) {
                /* weakly disconnected edges, they'll never reach each other */
                *has_path = 0;
                *has_cycle = 0;
                igraph_vector_destroy(&csize);
                IGRAPH_FINALLY_CLEAN(1);

                return IGRAPH_SUCCESS;
            }
        }
    }

    igraph_vector_destroy(&csize);
    IGRAPH_FINALLY_CLEAN(1);

    /* the graph is weakly connected except for singletons */
    /* find the singletons (including those with self-loops) */
    IGRAPH_VECTOR_INIT_FINALLY(&nonsingleton, 0);
    IGRAPH_CHECK(igraph_degree(graph, &nonsingleton, igraph_vss_all(), IGRAPH_ALL, IGRAPH_NO_LOOPS));


    /* checking if no. of incoming edges == outgoing edges
     * plus there are a few corner cases with singletons */
    IGRAPH_VECTOR_INIT_FINALLY(&out_degree, 0);
    IGRAPH_CHECK(igraph_degree(graph, &out_degree, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS));

    IGRAPH_VECTOR_INIT_FINALLY(&in_degree, 0);
    IGRAPH_CHECK(igraph_degree(graph, &in_degree, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS));
    es = 0;
    ens = 0;
    *start_of_path = -1;
    for (i = 0; i < n; i++) {
        long int degin = VECTOR(in_degree)[i];
        long int degout = VECTOR(out_degree)[i];

        /* Eulerian is about edges, so skip free vertices */
        if (degin + degout == 0) continue;

        if (!VECTOR(nonsingleton)[i]) {
            /* singleton with self loops */
            es++;
            /* if we ever want a path, it has to be this self-loop */
            *start_of_path = i;
        } else {
            /* at least one non-singleton */
            ens = 1;
        }

        if (es + ens > 1) {
            /* 2+ singletons with self loops or singleton with self-loops and
             * 1+ edges in the non-singleton part of the graph. */
            *has_path = 0;
            *has_cycle = 0;
            igraph_vector_destroy(&nonsingleton);
            igraph_vector_destroy(&in_degree);
            igraph_vector_destroy(&out_degree);
            IGRAPH_FINALLY_CLEAN(3);

            return IGRAPH_SUCCESS;
        }

        /* as long as we have perfect balance, you can start
         * anywhere with an edge */
        if (*start_of_path == -1 && incoming_excess == 0 && outgoing_excess == 0) {
            *start_of_path = i;
        }

        /* same in and out (including self-loops, even in singletons) */
        if (degin == degout) {
            continue;
        }

        /* non-singleton, in != out */
        if (degin > degout) {
            incoming_excess += degin - degout;
        } else {
            outgoing_excess += degout - degin;
            if (outgoing_excess == 1) {
                *start_of_path = i;
            }
        }

        /* too much imbalance, either of the following:
         * 1. 1+ vertices have 2+ in/out
         * 2. 2+ nodes have 1+ in/out */
        if (incoming_excess > 1 || outgoing_excess > 1) {
            *has_path = 0;
            *has_cycle = 0;
            igraph_vector_destroy(&nonsingleton);
            igraph_vector_destroy(&in_degree);
            igraph_vector_destroy(&out_degree);
            IGRAPH_FINALLY_CLEAN(3);

            return IGRAPH_SUCCESS;
        }
    }

    *has_path = 1;
    /* perfect edge balance -> strong connectivity */
    *has_cycle = (incoming_excess == 0) && (outgoing_excess == 0);
    /* either way, the start was set already */

    igraph_vector_destroy(&nonsingleton);
    igraph_vector_destroy(&in_degree);
    igraph_vector_destroy(&out_degree);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup Eulerian
 * \function igraph_is_eulerian
 * \brief Checks whether an Eulerian path or cycle exists
 *
 * An Eulerian path traverses each edge of the graph precisely once. A closed
 * Eulerian path is referred to as an Eulerian cycle.
 *
 * \param graph The graph object.
 * \param has_path Pointer to a Boolean, will be set to true if an Eulerian path exists.
 * \param has_cycle Pointer to a Boolean, will be set to true if an Eulerian cycle exists.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
 *
 */

int igraph_is_eulerian(const igraph_t *graph, igraph_bool_t *has_path, igraph_bool_t *has_cycle) {
    igraph_integer_t start_of_path = 0;

    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_is_eulerian_directed(graph, has_path, has_cycle, &start_of_path));
    } else {
        IGRAPH_CHECK(igraph_i_is_eulerian_undirected(graph, has_path, has_cycle, &start_of_path));
    }
    return IGRAPH_SUCCESS;
}


static int igraph_i_eulerian_path_undirected(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res, igraph_integer_t start_of_path) {
    long int curr;
    igraph_integer_t n, m;
    igraph_inclist_t il;
    igraph_stack_t path, tracker, edge_tracker, edge_path;
    igraph_vector_bool_t visited_list;
    igraph_vector_t degree;

    n = igraph_vcount(graph);
    m = igraph_ecount(graph);

    if (edge_res) {
        igraph_vector_clear(edge_res);
    }

    if (vertex_res) {
        igraph_vector_clear(vertex_res);
    }

    if (m == 0 || n == 0) {
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(°ree, 0);
    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS));

    IGRAPH_CHECK(igraph_stack_init(&path, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);

    IGRAPH_CHECK(igraph_stack_init(&tracker, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &tracker);

    IGRAPH_CHECK(igraph_stack_init(&edge_path, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &edge_path);

    IGRAPH_CHECK(igraph_stack_init(&edge_tracker, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &edge_tracker);

    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&visited_list, m);

    IGRAPH_CHECK(igraph_stack_push(&tracker, start_of_path));

    IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &il);

    curr = start_of_path;

    while (!igraph_stack_empty(&tracker)) {

        if (VECTOR(degree)[curr] != 0) {
            igraph_vector_int_t *incedges;
            long nc, edge = -1;
            long int j, next;
            IGRAPH_CHECK(igraph_stack_push(&tracker, curr));

            incedges = igraph_inclist_get(&il, curr);
            nc = igraph_vector_int_size(incedges);
            IGRAPH_ASSERT(nc > 0);

            for (j = 0; j < nc; j++) {
                edge = (long) VECTOR(*incedges)[j];
                if (!VECTOR(visited_list)[edge]) {
                    break;
                }
            }

            next = IGRAPH_OTHER(graph, edge, curr);

            IGRAPH_CHECK(igraph_stack_push(&edge_tracker, edge));

            /* remove edge here */
            VECTOR(degree)[curr]--;
            VECTOR(degree)[next]--;
            VECTOR(visited_list)[edge] = 1;

            curr = next;
        } else { /* back track to find remaining circuit */
            igraph_integer_t curr_e;
            IGRAPH_CHECK(igraph_stack_push(&path, curr));
            curr = igraph_stack_pop(&tracker);
            if (!igraph_stack_empty(&edge_tracker)) {
                curr_e = igraph_stack_pop(&edge_tracker);
                IGRAPH_CHECK(igraph_stack_push(&edge_path, curr_e));
            }
        }
    }

    if (edge_res) {
        IGRAPH_CHECK(igraph_vector_reserve(edge_res, m));
        while (!igraph_stack_empty(&edge_path)) {
            IGRAPH_CHECK(igraph_vector_push_back(edge_res, igraph_stack_pop(&edge_path)));
        }
    }
    if (vertex_res) {
        IGRAPH_CHECK(igraph_vector_reserve(vertex_res, m+1));
        while (!igraph_stack_empty(&path)) {
            IGRAPH_CHECK(igraph_vector_push_back(vertex_res, igraph_stack_pop(&path)));
        }
    }

    igraph_stack_destroy(&path);
    igraph_stack_destroy(&tracker);
    igraph_stack_destroy(&edge_path);
    igraph_stack_destroy(&edge_tracker);
    igraph_vector_bool_destroy(&visited_list);
    igraph_inclist_destroy(&il);
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(7);

    return IGRAPH_SUCCESS;
}

/* solution adapted from https://www.geeksforgeeks.org/hierholzers-algorithm-directed-graph/ */
static int igraph_i_eulerian_path_directed(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res, igraph_integer_t start_of_path) {
    long int curr;
    igraph_integer_t n, m;
    igraph_inclist_t il;
    igraph_stack_t path, tracker, edge_tracker, edge_path;
    igraph_vector_bool_t visited_list;
    igraph_vector_t remaining_out_edges;

    n = igraph_vcount(graph);
    m = igraph_ecount(graph);

    if (edge_res) {
        igraph_vector_clear(edge_res);
    }

    if (vertex_res) {
        igraph_vector_clear(vertex_res);
    }

    if (m == 0 || n == 0) {
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_stack_init(&path, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);

    IGRAPH_CHECK(igraph_stack_init(&tracker, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &tracker);

    IGRAPH_CHECK(igraph_stack_init(&edge_path, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &edge_path);

    IGRAPH_CHECK(igraph_stack_init(&edge_tracker, n));
    IGRAPH_FINALLY(igraph_stack_destroy, &edge_tracker);

    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&visited_list, m);

    IGRAPH_CHECK(igraph_stack_push(&tracker, start_of_path));

    IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &il);

    IGRAPH_VECTOR_INIT_FINALLY(&remaining_out_edges, 0);
    IGRAPH_CHECK(igraph_degree(graph, &remaining_out_edges, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS));

    curr = start_of_path;

    while (!igraph_stack_empty(&tracker)) {

        if (VECTOR(remaining_out_edges)[curr] != 0) {
            igraph_vector_int_t *incedges;
            long nc, edge = -1;
            long int j, next;
            IGRAPH_CHECK(igraph_stack_push(&tracker, curr));

            incedges = igraph_inclist_get(&il, curr);
            nc = igraph_vector_int_size(incedges);
            IGRAPH_ASSERT(nc > 0);

            for (j = 0; j < nc; j++) {
                edge = (long) VECTOR(*incedges)[j];
                if (!VECTOR(visited_list)[edge]) {
                    break;
                }
            }

            next = IGRAPH_TO(graph, edge);

            IGRAPH_CHECK(igraph_stack_push(&edge_tracker, edge));

            /* remove edge here */
            VECTOR(remaining_out_edges)[curr]--;
            VECTOR(visited_list)[edge] = 1;

            curr = next;
        } else { /* back track to find remaining circuit */
            igraph_integer_t curr_e;
            IGRAPH_CHECK(igraph_stack_push(&path, curr));
            curr = igraph_stack_pop(&tracker);
            if (!igraph_stack_empty(&edge_tracker)) {
                curr_e = igraph_stack_pop(&edge_tracker);
                IGRAPH_CHECK(igraph_stack_push(&edge_path, curr_e));
            }
        }
    }

    if (edge_res) {
        IGRAPH_CHECK(igraph_vector_reserve(edge_res, m));
        while (!igraph_stack_empty(&edge_path)) {
            IGRAPH_CHECK(igraph_vector_push_back(edge_res, igraph_stack_pop(&edge_path)));
        }
    }
    if (vertex_res) {
        IGRAPH_CHECK(igraph_vector_reserve(vertex_res, m+1));
        while (!igraph_stack_empty(&path)) {
            IGRAPH_CHECK(igraph_vector_push_back(vertex_res, igraph_stack_pop(&path)));
        }
    }

    igraph_stack_destroy(&path);
    igraph_stack_destroy(&tracker);
    igraph_stack_destroy(&edge_path);
    igraph_stack_destroy(&edge_tracker);
    igraph_vector_bool_destroy(&visited_list);
    igraph_inclist_destroy(&il);
    igraph_vector_destroy(&remaining_out_edges);
    IGRAPH_FINALLY_CLEAN(7);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup Eulerian
 * \function igraph_eulerian_cycle
 * \brief Finds an Eulerian cycle
 *
 * Finds an Eulerian cycle, if it exists. An Eulerian cycle is a closed path
 * that traverses each edge precisely once.
 *
 * 
 * This function uses Hierholzer's algorithm.
 *
 * \param graph The graph object.
 * \param edge_res Pointer to an initialised vector. The indices of edges
 *                 belonging to the cycle will be stored here. May be \c NULL
 *                 if it is not needed by the caller.
 * \param vertex_res Pointer to an initialised vector. The indices of vertices
 *                   belonging to the cycle will be stored here. May be \c NULL
 *                   if it is not needed by the caller.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           graph does not have an Eulerian cycle.
 *        \endclist
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
 *
 */

int igraph_eulerian_cycle(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res) {
    igraph_bool_t has_cycle;
    igraph_bool_t has_path;
    igraph_integer_t start_of_path = 0;

    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_is_eulerian_directed(graph, &has_path, &has_cycle, &start_of_path));

        if (!has_cycle) {
            IGRAPH_ERROR("The graph does not have an Eulerian cycle.", IGRAPH_EINVAL);
        }

        IGRAPH_CHECK(igraph_i_eulerian_path_directed(graph, edge_res, vertex_res, start_of_path));
    } else {
        IGRAPH_CHECK(igraph_i_is_eulerian_undirected(graph, &has_path, &has_cycle, &start_of_path));

        if (!has_cycle) {
            IGRAPH_ERROR("The graph does not have an Eulerian cycle.", IGRAPH_EINVAL);
        }

        IGRAPH_CHECK(igraph_i_eulerian_path_undirected(graph, edge_res, vertex_res, start_of_path));
    }

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup Eulerian
 * \function igraph_eulerian_path
 * \brief Finds an Eulerian path
 *
 * Finds an Eulerian path, if it exists. An Eulerian path traverses
 * each edge precisely once.
 *
 * 
 * This function uses Hierholzer's algorithm.
 *
 * \param graph The graph object.
 * \param edge_res Pointer to an initialised vector. The indices of edges
 *                 belonging to the path will be stored here. May be \c NULL
 *                 if it is not needed by the caller.
 * \param vertex_res Pointer to an initialised vector. The indices of vertices
 *                   belonging to the path will be stored here. May be \c NULL
 *                   if it is not needed by the caller.
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           graph does not have an Eulerian path.
 *        \endclist
 *
 * Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
 *
 */

int igraph_eulerian_path(const igraph_t *graph, igraph_vector_t *edge_res, igraph_vector_t *vertex_res) {
    igraph_bool_t has_cycle;
    igraph_bool_t has_path;
    igraph_integer_t start_of_path = 0;

    if (igraph_is_directed(graph)) {
        IGRAPH_CHECK(igraph_i_is_eulerian_directed(graph, &has_path, &has_cycle, &start_of_path));

        if (!has_path) {
            IGRAPH_ERROR("The graph does not have an Eulerian path.", IGRAPH_EINVAL);
        }
        IGRAPH_CHECK(igraph_i_eulerian_path_directed(graph, edge_res, vertex_res, start_of_path));
    } else {
        IGRAPH_CHECK(igraph_i_is_eulerian_undirected(graph, &has_path, &has_cycle, &start_of_path));

        if (!has_path) {
            IGRAPH_ERROR("The graph does not have an Eulerian path.", IGRAPH_EINVAL);
        }

        IGRAPH_CHECK(igraph_i_eulerian_path_undirected(graph, edge_res, vertex_res, start_of_path));
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/histogram.c0000644000175100001710000001201400000000000023717 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_progress.h"

#include "core/interruption.h"

/**
 * \function igraph_path_length_hist
 * Create a histogram of all shortest path lengths.
 *
 * This function calculates a histogram, by calculating the
 * shortest path length between each pair of vertices. For directed
 * graphs both directions might be considered and then every pair of vertices
 * appears twice in the histogram.
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the result is stored
 *     here. The first (i.e. zeroth) element contains the number of
 *     shortest paths of length 1, etc. The supplied vector is resized
 *     as needed.
 * \param unconnected Pointer to a real number, the number of
 *     pairs for which the second vertex is not reachable from the
 *     first is stored here.
 * \param directed Whether to consider directed paths in a directed
 *     graph (if not zero). This argument is ignored for undirected
 *     graphs.
 * \return Error code.
 *
 * Time complexity: O(|V||E|), the number of vertices times the number
 * of edges.
 *
 * \sa \ref igraph_average_path_length() and \ref igraph_shortest_paths()
 */

int igraph_path_length_hist(const igraph_t *graph, igraph_vector_t *res,
                            igraph_real_t *unconnected, igraph_bool_t directed) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i, j, n;
    igraph_vector_long_t already_added;
    long int nodes_reached;

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_vector_int_t *neis;
    igraph_neimode_t dirmode;
    igraph_adjlist_t allneis;
    igraph_real_t unconn = 0;
    long int ressize;

    if (directed) {
        dirmode = IGRAPH_OUT;
    } else {
        dirmode = IGRAPH_ALL;
    }

    IGRAPH_CHECK(igraph_vector_long_init(&already_added, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &already_added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, dirmode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    IGRAPH_CHECK(igraph_vector_resize(res, 0));
    ressize = 0;

    for (i = 0; i < no_of_nodes; i++) {
        nodes_reached = 1;      /* itself */
        IGRAPH_CHECK(igraph_dqueue_push(&q, i));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        VECTOR(already_added)[i] = i + 1;

        IGRAPH_PROGRESS("Path length histogram: ", 100.0 * i / no_of_nodes, NULL);

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);

            neis = igraph_adjlist_get(&allneis, actnode);
            n = igraph_vector_int_size(neis);
            for (j = 0; j < n; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (VECTOR(already_added)[neighbor] == i + 1) {
                    continue;
                }
                VECTOR(already_added)[neighbor] = i + 1;
                nodes_reached++;
                if (actdist + 1 > ressize) {
                    IGRAPH_CHECK(igraph_vector_resize(res, actdist + 1));
                    for (; ressize < actdist + 1; ressize++) {
                        VECTOR(*res)[ressize] = 0;
                    }
                }
                VECTOR(*res)[actdist] += 1;

                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        } /* while !igraph_dqueue_empty */

        unconn += (no_of_nodes - nodes_reached);

    } /* for i
 * If no edge weights are supplied, then the unweighted
 * version, \ref igraph_shortest_paths() is called.
 *
 * 
 * If all the supplied edge weights are non-negative,
 * then Dijkstra's algorithm is used by calling
 * \ref igraph_shortest_paths_dijkstra().
 *
 * \param graph The input graph. If negative weights are present, it
 *   should be directed.
 * \param res Pointer to an initialized matrix, the result will be
 *   stored here, one line for each source vertex, one column for each
 *   target vertex.
 * \param from The source vertices.
 * \param to The target vertices. It is not allowed to include a
 *   vertex twice or more.
 * \param weights Optional edge weights. If it is a null-pointer, then
 *   the unweighted breadth-first search based \ref
 *   igraph_shortest_paths() will be called.
 * \return Error code.
 *
 * Time complexity: O(s|V|log|V|+|V||E|), |V| and |E| are the number
 * of vertices and edges, s is the number of source vertices.
 *
 * \sa \ref igraph_shortest_paths() for a faster unweighted version
 * or \ref igraph_shortest_paths_dijkstra() if you do not have negative
 * edge weights, \ref igraph_shortest_paths_bellman_ford() if you only
 * need to calculate shortest paths from a couple of sources.
 */
int igraph_shortest_paths_johnson(const igraph_t *graph,
                                  igraph_matrix_t *res,
                                  const igraph_vs_t from,
                                  const igraph_vs_t to,
                                  const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_t newgraph;
    igraph_vector_t edges, newweights;
    igraph_matrix_t bfres;
    long int i, ptr;
    long int nr, nc;
    igraph_vit_t fromvit;

    /* If no weights, then we can just run the unweighted version */
    if (!weights) {
        return igraph_shortest_paths(graph, res, from, to, IGRAPH_OUT);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Weight vector length does not match", IGRAPH_EINVAL);
    }

    /* If no edges, then we can just run the unweighted version */
    if (no_of_edges == 0) {
        return igraph_shortest_paths(graph, res, from, to, IGRAPH_OUT);
    }

    /* If no negative weights, then we can run Dijkstra's algorithm */
    {
        igraph_real_t min_weight = igraph_vector_min(weights);
        if (igraph_is_nan(min_weight)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
        }
        if (min_weight >= 0) {
            return igraph_shortest_paths_dijkstra(graph, res, from, to,
                                                  weights, IGRAPH_OUT);
        }
    }

    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("Johnson's shortest path: undirected graph and negative weight",
                     IGRAPH_EINVAL);
    }

    /* ------------------------------------------------------------ */
    /* -------------------- Otherwise proceed --------------------- */

    IGRAPH_MATRIX_INIT_FINALLY(&bfres, 0, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&newweights, 0);

    IGRAPH_CHECK(igraph_empty(&newgraph, (igraph_integer_t) no_of_nodes + 1,
                              igraph_is_directed(graph)));
    IGRAPH_FINALLY(igraph_destroy, &newgraph);

    /* Add a new node to the graph, plus edges from it to all the others. */
    IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2 + no_of_nodes * 2);
    igraph_get_edgelist(graph, &edges, /*bycol=*/ 0);
    igraph_vector_resize(&edges, no_of_edges * 2 + no_of_nodes * 2);
    for (i = 0, ptr = no_of_edges * 2; i < no_of_nodes; i++) {
        VECTOR(edges)[ptr++] = no_of_nodes;
        VECTOR(edges)[ptr++] = i;
    }
    IGRAPH_CHECK(igraph_add_edges(&newgraph, &edges, 0));
    igraph_vector_destroy(&edges);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_vector_reserve(&newweights, no_of_edges + no_of_nodes));
    igraph_vector_update(&newweights, weights);
    igraph_vector_resize(&newweights, no_of_edges + no_of_nodes);
    for (i = no_of_edges; i < no_of_edges + no_of_nodes; i++) {
        VECTOR(newweights)[i] = 0;
    }

    /* Run Bellmann-Ford algorithm on the new graph, starting from the
       new vertex.  */

    IGRAPH_CHECK(igraph_shortest_paths_bellman_ford(&newgraph, &bfres,
                 igraph_vss_1((igraph_integer_t) no_of_nodes),
                 igraph_vss_all(), &newweights, IGRAPH_OUT));

    igraph_destroy(&newgraph);
    IGRAPH_FINALLY_CLEAN(1);

    /* Now the edges of the original graph are reweighted, using the
       values from the BF algorithm. Instead of w(u,v) we will have
       w(u,v) + h(u) - h(v) */

    igraph_vector_resize(&newweights, no_of_edges);
    for (i = 0; i < no_of_edges; i++) {
        long int ffrom = IGRAPH_FROM(graph, i);
        long int tto = IGRAPH_TO(graph, i);
        VECTOR(newweights)[i] += MATRIX(bfres, 0, ffrom) - MATRIX(bfres, 0, tto);
    }

    /* Run Dijkstra's algorithm on the new weights */
    IGRAPH_CHECK(igraph_shortest_paths_dijkstra(graph, res, from,
                 to, &newweights,
                 IGRAPH_OUT));

    igraph_vector_destroy(&newweights);
    IGRAPH_FINALLY_CLEAN(1);

    /* Reweight the shortest paths */
    nr = igraph_matrix_nrow(res);
    nc = igraph_matrix_ncol(res);

    IGRAPH_CHECK(igraph_vit_create(graph, from, &fromvit));
    IGRAPH_FINALLY(igraph_vit_destroy, &fromvit);

    for (i = 0; i < nr; i++, IGRAPH_VIT_NEXT(fromvit)) {
        long int v1 = IGRAPH_VIT_GET(fromvit);
        if (igraph_vs_is_all(&to)) {
            long int v2;
            for (v2 = 0; v2 < nc; v2++) {
                igraph_real_t sub = MATRIX(bfres, 0, v1) - MATRIX(bfres, 0, v2);
                MATRIX(*res, i, v2) -= sub;
            }
        } else {
            long int j;
            igraph_vit_t tovit;
            IGRAPH_CHECK(igraph_vit_create(graph, to, &tovit));
            IGRAPH_FINALLY(igraph_vit_destroy, &tovit);
            for (j = 0, IGRAPH_VIT_RESET(tovit); j < nc; j++, IGRAPH_VIT_NEXT(tovit)) {
                long int v2 = IGRAPH_VIT_GET(tovit);
                igraph_real_t sub = MATRIX(bfres, 0, v1) - MATRIX(bfres, 0, v2);
                MATRIX(*res, i, j) -= sub;
            }
            igraph_vit_destroy(&tovit);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    igraph_vit_destroy(&fromvit);
    igraph_matrix_destroy(&bfres);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/random_walk.c0000644000175100001710000002443000000000000024225 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_random.h"
#include "igraph_memory.h"

#include "core/interruption.h"

/**
 * \function igraph_random_walk
 * Perform a random walk on a graph
 *
 * Performs a random walk with a given length on a graph, from the given
 * start vertex. Edge directions are (potentially) considered, depending on
 * the \p mode argument.
 *
 * \param graph The input graph, it can be directed or undirected.
 *   Multiple edges are respected, so are loop edges.
 * \param walk An allocated vector, the result is stored here.
 *   It will be resized as needed.
 * \param start The start vertex for the walk.
 * \param steps The number of steps to take. If the random walk gets
 *   stuck, then the \p stuck argument specifies what happens.
 * \param mode How to walk along the edges in directed graphs.
 *   \c IGRAPH_OUT means following edge directions, \c IGRAPH_IN means
 *   going opposite the edge directions, \c IGRAPH_ALL means ignoring
 *   edge directions. This argument is ignored for undirected graphs.
 * \param stuck What to do if the random walk gets stuck.
 *   \c IGRAPH_RANDOM_WALK_STUCK_RETURN means that the function returns
 *   with a shorter walk; \c IGRAPH_RANDOM_WALK_STUCK_ERROR means
 *   that an error is reported. In both cases \p walk is truncated
 *   to contain the actual interrupted walk.
 * \return Error code.
 *
 * Time complexity: O(l + d), where \c l is the length of the
 * walk, and \c d is the total degree of the visited nodes.
 */


int igraph_random_walk(const igraph_t *graph, igraph_vector_t *walk,
                       igraph_integer_t start, igraph_neimode_t mode,
                       igraph_integer_t steps,
                       igraph_random_walk_stuck_t stuck) {

    /* TODO:
       - multiple walks potentially from multiple start vertices
       - weights
    */

    igraph_lazy_adjlist_t adj;
    igraph_integer_t vc = igraph_vcount(graph);
    igraph_integer_t i;

    if (start < 0 || start >= vc) {
        IGRAPH_ERROR("Invalid start vertex.", IGRAPH_EINVAL);
    }
    if (steps < 0) {
        IGRAPH_ERROR("Invalid number of steps.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adj, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adj);

    IGRAPH_CHECK(igraph_vector_resize(walk, steps));

    RNG_BEGIN();

    VECTOR(*walk)[0] = start;
    for (i = 1; i < steps; i++) {
        igraph_vector_int_t *neis;
        igraph_integer_t nn;
        neis = igraph_lazy_adjlist_get(&adj, start);
        nn = igraph_vector_int_size(neis);

        if (IGRAPH_UNLIKELY(nn == 0)) {
            igraph_vector_resize(walk, i);
            if (stuck == IGRAPH_RANDOM_WALK_STUCK_RETURN) {
                break;
            } else {
                IGRAPH_ERROR("Random walk got stuck.", IGRAPH_ERWSTUCK);
            }
        }
        start = VECTOR(*walk)[i] = VECTOR(*neis)[ RNG_INTEGER(0, nn - 1) ];
    }

    RNG_END();

    igraph_lazy_adjlist_destroy(&adj);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/* Used as item destructor for 'cdfs' in igraph_random_edge_walk(). */
static void vec_destr(igraph_vector_t *vec) {
    if (vec != NULL) {
        igraph_vector_destroy(vec);
    }
}


/**
 * \function igraph_random_edge_walk
 * \brief Perform a random walk on a graph and return the traversed edges
 *
 * Performs a random walk with a given length on a graph, from the given
 * start vertex. Edge directions are (potentially) considered, depending on
 * the \p mode argument.
 *
 * \param graph The input graph, it can be directed or undirected.
 *   Multiple edges are respected, so are loop edges.
 * \param weights A vector of non-negative edge weights. It is assumed
 *   that at least one strictly positive weight is found among the
 *   outgoing edges of each vertex. Additionally, no edge weight may
 *   be NaN. If either case does not hold, an error is returned. If it
 *   is a NULL pointer, all edges are considered to have equal weight.
 * \param edgewalk An initialized vector; the indices of traversed
 *   edges are stored here. It will be resized as needed.
 * \param start The start vertex for the walk.
 * \param steps The number of steps to take. If the random walk gets
 *   stuck, then the \p stuck argument specifies what happens.
 * \param mode How to walk along the edges in directed graphs.
 *   \c IGRAPH_OUT means following edge directions, \c IGRAPH_IN means
 *   going opposite the edge directions, \c IGRAPH_ALL means ignoring
 *   edge directions. This argument is ignored for undirected graphs.
 * \param stuck What to do if the random walk gets stuck.
 *   \c IGRAPH_RANDOM_WALK_STUCK_RETURN means that the function returns
 *   with a shorter walk; \c IGRAPH_RANDOM_WALK_STUCK_ERROR means
 *   that an error is reported. In both cases, \p edgewalk is truncated
 *   to contain the actual interrupted walk.
 *
 * \return Error code.
 *
 */
int igraph_random_edge_walk(const igraph_t *graph,
                            const igraph_vector_t *weights,
                            igraph_vector_t *edgewalk,
                            igraph_integer_t start, igraph_neimode_t mode,
                            igraph_integer_t steps,
                            igraph_random_walk_stuck_t stuck) {
    igraph_integer_t vc = igraph_vcount(graph);
    igraph_integer_t ec = igraph_ecount(graph);
    igraph_integer_t i;
    igraph_inclist_t il;
    igraph_vector_t weight_temp;
    igraph_vector_ptr_t cdfs; /* cumulative distribution vectors for each node, used for weighted choice */

    if (! (mode == IGRAPH_ALL || mode == IGRAPH_IN || mode == IGRAPH_OUT)) {
        IGRAPH_ERROR("Invalid mode parameter.", IGRAPH_EINVMODE);
    }

    /* ref switch statement at end of main loop */
    if (! igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    if (start < 0 || start >= vc) {
        IGRAPH_ERROR("Invalid start vertex.", IGRAPH_EINVAL);
    }

    if (steps < 0) {
        IGRAPH_ERROR("Invalid number of steps.", IGRAPH_EINVAL);
    }

    if (weights) {
        if (igraph_vector_size(weights) != ec) {
            IGRAPH_ERROR("Invalid weight vector length.", IGRAPH_EINVAL);
        }
        if (ec > 0) {
            igraph_real_t min = igraph_vector_min(weights);
            if (min < 0) {
                IGRAPH_ERROR("Weights must be non-negative.", IGRAPH_EINVAL);
            }
            else if (igraph_is_nan(min)) {
                IGRAPH_ERROR("Weights must not contain NaN values.", IGRAPH_EINVAL);
            }
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(edgewalk, steps));

    IGRAPH_CHECK(igraph_inclist_init(graph, &il, mode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &il);

    IGRAPH_VECTOR_INIT_FINALLY(&weight_temp, 0);

    /* cdf vectors will be computed lazily */
    IGRAPH_CHECK(igraph_vector_ptr_init(&cdfs, vc));
    IGRAPH_FINALLY(igraph_vector_ptr_destroy_all, &cdfs);
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&cdfs, vec_destr);
    for (i = 0; i < vc; ++i) {
        VECTOR(cdfs)[i] = NULL;
    }

    RNG_BEGIN();

    for (i = 0; i < steps; ++i) {
        long degree, edge, idx;
        igraph_vector_int_t *edges = igraph_inclist_get(&il, start);

        degree = igraph_vector_int_size(edges);

        /* are we stuck? */
        if (IGRAPH_UNLIKELY(degree == 0)) {
            igraph_vector_resize(edgewalk, i); /* can't fail since size is reduced, skip IGRAPH_CHECK */
            if (stuck == IGRAPH_RANDOM_WALK_STUCK_RETURN) {
                break;
            } else {
                IGRAPH_ERROR("Random walk got stuck.", IGRAPH_ERWSTUCK);
            }
        }

        if (weights) { /* weighted: choose an out-edge with probability proportional to its weight */
            igraph_real_t r;
            igraph_vector_t **cd = (igraph_vector_t **) & (VECTOR(cdfs)[start]);

            /* compute out-edge cdf for this node if not already done */
            if (IGRAPH_UNLIKELY(! *cd)) {
                long j;

                *cd = IGRAPH_CALLOC(1, igraph_vector_t);
                if (*cd == NULL) {
                    IGRAPH_ERROR("Random edge walk failed.", IGRAPH_ENOMEM);
                }
                IGRAPH_CHECK(igraph_vector_init(*cd, degree));

                IGRAPH_CHECK(igraph_vector_resize(&weight_temp, degree));
                for (j = 0; j < degree; ++j) {
                    VECTOR(weight_temp)[j] = VECTOR(*weights)[ VECTOR(*edges)[j] ];
                }

                IGRAPH_CHECK(igraph_vector_cumsum(*cd, &weight_temp));
            }

            r = RNG_UNIF(0, VECTOR( **cd )[degree - 1]);
            igraph_vector_binsearch(*cd, r, &idx);
        } else { /* unweighted: choose an out-edge at random */
            idx = RNG_INTEGER(0, degree - 1);
        }

        edge = VECTOR(*edges)[idx];
        VECTOR(*edgewalk)[i] = edge;

        /* travel along edge in a direction specified by 'mode' */
        /* note: 'mode' is always set to IGRAPH_ALL for undirected graphs */
        switch (mode) {
        case IGRAPH_OUT:
            start = IGRAPH_TO(graph, edge);
            break;
        case IGRAPH_IN:
            start = IGRAPH_FROM(graph, edge);
            break;
        case IGRAPH_ALL:
            start = IGRAPH_OTHER(graph, edge, start);
            break;
        }

        IGRAPH_ALLOW_INTERRUPTION();
    }

    RNG_END();

    igraph_vector_ptr_destroy_all(&cdfs);
    igraph_vector_destroy(&weight_temp);
    igraph_inclist_destroy(&il);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/shortest_paths.c0000644000175100001710000013247000000000000025005 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2020  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_dqueue.h"
#include "igraph_memory.h"
#include "igraph_progress.h"

#include "core/indheap.h"
#include "core/interruption.h"

#include 

/*****************************************************/
/***** Average path length and global efficiency *****/
/*****************************************************/

/* Computes the average of pairwise distances (used for igraph_average_path_length),
 * or of inverse pairwise distances (used for igraph_global_efficiency), in an unweighted graph. */
static int igraph_i_average_path_length_unweighted(
        const igraph_t *graph,
        igraph_real_t *res,
        igraph_real_t *unconnected_pairs, /* if not NULL, will be set to the no. of non-connected ordered vertex pairs */
        const igraph_bool_t directed,
        const igraph_bool_t invert, /* average inverse distances instead of distances */
        const igraph_bool_t unconn  /* average over connected pairs instead of all pairs */)
{
    long int no_of_nodes = igraph_vcount(graph);
    long int source, j, n;
    long int *already_added;
    igraph_real_t no_of_pairs = no_of_nodes > 0 ? no_of_nodes * (no_of_nodes - 1.0) : 0.0; /* no. of ordered vertex pairs */
    igraph_real_t no_of_conn_pairs = 0.0; /* no. of ordered pairs between which there is a path */

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_vector_int_t *neis;
    igraph_adjlist_t allneis;

    *res = 0;
    already_added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (already_added == 0) {
        IGRAPH_ERROR("Average path length calculation failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(
        graph, &allneis,
        directed ? IGRAPH_OUT : IGRAPH_ALL,
        IGRAPH_LOOPS, IGRAPH_MULTIPLE
    ));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    for (source = 0; source < no_of_nodes; source++) {
        IGRAPH_CHECK(igraph_dqueue_push(&q, source));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        already_added[source] = source + 1;

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);

            neis = igraph_adjlist_get(&allneis, actnode);
            n = igraph_vector_int_size(neis);
            for (j = 0; j < n; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (already_added[neighbor] == source + 1) {
                    continue;
                }
                already_added[neighbor] = source + 1;
                if (invert) {
                    *res += 1.0/(actdist + 1.0);
                } else {
                    *res += actdist + 1.0;
                }
                no_of_conn_pairs += 1;
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        } /* while !igraph_dqueue_empty */
    } /* for source < no_of_nodes */


    if (no_of_pairs == 0) {
        *res = IGRAPH_NAN; /* can't average zero items */
    } else {
        if (unconn) { /* average over connected pairs */
            if (no_of_conn_pairs == 0) {
                *res = IGRAPH_NAN; /* can't average zero items */
            } else {
                *res /= no_of_conn_pairs;
            }
        } else { /* average over all pairs */
            /* no_of_conn_pairs < no_of_pairs implies that the graph is disconnected */
            if (no_of_conn_pairs < no_of_pairs && ! invert) {
                /* When invert=false, assume the distance between non-connected pairs to be infinity */
                *res = IGRAPH_INFINITY;
            } else {
                /* When invert=true, assume the inverse distance between non-connected pairs
                 * to be zero. Therefore, no special treatment is needed for disconnected graphs. */
                *res /= no_of_pairs;
            }
        }
    }

    if (unconnected_pairs)
        *unconnected_pairs = no_of_pairs - no_of_conn_pairs;

    /* clean */
    IGRAPH_FREE(already_added);
    igraph_dqueue_destroy(&q);
    igraph_adjlist_destroy(&allneis);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}


/* Computes the average of pairwise distances (used for igraph_average_path_length_dijkstra),
 * or of inverse pairwise distances (used for igraph_global_efficiency), in an unweighted graph.
 * Uses Dijkstra's algorithm, therefore all weights must be non-negative.
 */
static int igraph_i_average_path_length_dijkstra(
        const igraph_t *graph,
        igraph_real_t *res,
        igraph_real_t *unconnected_pairs,
        const igraph_vector_t *weights,
        const igraph_bool_t directed,
        const igraph_bool_t invert, /* average inverse distances instead of distances */
        const igraph_bool_t unconn  /* average over connected pairs instead of all pairs */)
{

    /* Implementation details. This is the basic Dijkstra algorithm,
       with a binary heap. The heap is indexed, i.e. it stores not only
       the distances, but also which vertex they belong to.

       From now on we use a 2-way heap, so the distances can be queried
       directly from the heap.

       Dirty tricks:
       - the opposite of the distance is stored in the heap, as it is a
         maximum heap and we need a minimum heap.
       - we don't use IGRAPH_INFINITY in the res matrix during the
         computation, as IGRAPH_FINITE() might involve a function call
         and we want to spare that. -1 will denote infinity instead.
    */

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_2wheap_t Q;
    igraph_lazy_inclist_t inclist;
    long int source, j;
    igraph_real_t no_of_pairs;
    igraph_real_t no_of_conn_pairs = 0.0; /* no. of ordered pairs between which there is a path */

    if (!weights) {
        return igraph_i_average_path_length_unweighted(graph, res, unconnected_pairs, directed, invert, unconn);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERRORF("Weight vector length (%ld) does not match the number of edges (%ld).",
                      IGRAPH_EINVAL, igraph_vector_size(weights), no_of_edges);
    }
    if (no_of_edges > 0) {
        igraph_real_t min = igraph_vector_min(weights);
        if (min < 0) {
            IGRAPH_ERRORF("Weight vector must be non-negative, got %g.", IGRAPH_EINVAL, min);
        }
        else if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values.", IGRAPH_EINVAL);
        }
    }

    /* Avoid returning a negative zero, which would be printed as -0 in tests. */
    if (no_of_nodes > 0) {
        no_of_pairs = no_of_nodes * (no_of_nodes - 1.0);
    } else {
        no_of_pairs = 0;
    }

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_lazy_inclist_init(
        graph, &inclist, directed ? IGRAPH_OUT : IGRAPH_ALL, IGRAPH_LOOPS
    ));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    *res = 0.0;

    for (source = 0; source < no_of_nodes; ++source) {

        IGRAPH_ALLOW_INTERRUPTION();

        igraph_2wheap_clear(&Q);
        igraph_2wheap_push_with_index(&Q, source, -1.0);

        while (!igraph_2wheap_empty(&Q)) {
            long int minnei = igraph_2wheap_max_index(&Q);
            igraph_real_t mindist = -igraph_2wheap_deactivate_max(&Q);
            igraph_vector_int_t *neis;
            long int nlen;

            if (minnei != source) {
                if (invert) {
                    *res += 1.0/(mindist - 1.0);
                } else {
                    *res += mindist - 1.0;
                }
                no_of_conn_pairs += 1;
            }

            /* Now check all neighbors of 'minnei' for a shorter path */
            neis = igraph_lazy_inclist_get(&inclist, (igraph_integer_t) minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int tto = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_bool_t active = igraph_2wheap_has_active(&Q, tto);
                igraph_bool_t has = igraph_2wheap_has_elem(&Q, tto);
                igraph_real_t curdist = active ? -igraph_2wheap_get(&Q, tto) : 0.0;
                if (!has) {
                    /* This is the first non-infinite distance */
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, tto, -altdist));
                } else if (altdist < curdist) {
                    /* This is a shorter path */
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, tto, -altdist));
                }
            }
        } /* !igraph_2wheap_empty(&Q) */
    } /* for source < no_of_nodes */

    if (no_of_pairs == 0) {
        *res = IGRAPH_NAN; /* can't average zero items */
    } else {
        if (unconn) { /* average over connected pairs */
            if (no_of_conn_pairs == 0) {
                *res = IGRAPH_NAN; /* can't average zero items */
            } else {
                *res /= no_of_conn_pairs;
            }
        } else { /* average over all pairs */
            /* no_of_conn_pairs < no_of_pairs implies that the graph is disconnected */
            if (no_of_conn_pairs < no_of_pairs && ! invert) {
                *res = IGRAPH_INFINITY;
            } else {
                *res /= no_of_pairs;
            }
        }
    }

    if (unconnected_pairs)
        *unconnected_pairs = no_of_pairs - no_of_conn_pairs;

    igraph_lazy_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup structural
 * \function igraph_average_path_length
 * \brief Calculates the average unweighted shortest path length between all vertex pairs.
 *
 * 
 * If no vertex pairs can be included in the calculation, for example because the graph
 * has fewer than two vertices, or if the graph has no edges and \c unconn is set to \c TRUE,
 * NaN is returned.
 *
 * \param graph The graph object.
 * \param res Pointer to a real number, this will contain the result.
 * \param unconn_pairs Pointer to a real number. If not a null pointer, the number of
 *    ordered vertex pairs where the second vertex is unreachable from the first one
 *    will be stored here.
 * \param directed Boolean, whether to consider directed
 *    paths. Ignored for undirected graphs.
 * \param unconn What to do if the graph is not connected. If
 *    \c TRUE, only those vertex pairs will be included in the calculation
 *    between which there is a path. If \c FALSE, \c IGRAPH_INFINITY is returned
 *    for disconnected graphs.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for data structures
 *
 * Time complexity: O(|V| |E|), the number of vertices times the number of edges.
 *
 * \sa \ref igraph_average_path_length_dijkstra() for the weighted version.
 *
 * \example examples/simple/igraph_average_path_length.c
 */

int igraph_average_path_length(const igraph_t *graph,
                               igraph_real_t *res, igraph_real_t *unconn_pairs,
                               igraph_bool_t directed, igraph_bool_t unconn)
{
    return igraph_i_average_path_length_unweighted(graph, res, unconn_pairs, directed, /* invert= */ 0, unconn);
}


/**
 * \ingroup structural
 * \function igraph_average_path_length_dijkstra
 * \brief Calculates the average weighted shortest path length between all vertex pairs.
 *
 * 
 * If no vertex pairs can be included in the calculation, for example because the graph
 * has fewer than two vertices, or if the graph has no edges and \c unconn is set to \c TRUE,
 * NaN is returned.
 *
 * 
 * All distinct ordered vertex pairs are taken into account.
 *
 * \param graph The graph object.
 * \param res Pointer to a real number, this will contain the result.
 * \param unconn_pairs Pointer to a real number. If not a null pointer, the number of
 *    ordered vertex pairs where the second vertex is unreachable from the first one
 *    will be stored here.
 * \param weights The edge weights. All edge weights must be
 *       non-negative for Dijkstra's algorithm to work. Additionally, no
 *       edge weight may be NaN. If either case does not hold, an error
 *       is returned. If this is a null pointer, then the unweighted
 *       version, \ref igraph_average_path_length() is called.
 * \param directed Boolean, whether to consider directed paths.
 *    Ignored for undirected graphs.
 * \param unconn If \c TRUE, only those pairs are considered for the calculation
 *    between which there is a path. If \c FALSE, \c IGRAPH_INFINITY is returned
 *    for disconnected graphs.
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_ENOMEM
 *              not enough memory for data structures
 *         \cli IGRAPH_EINVAL
 *              invalid weight vector
 *         \endclist
 *
 * Time complexity: O(|V| |E| log|E| + |V|), where |V| is the number of
 * vertices and |E| is the number of edges.
 *
 * \sa \ref igraph_average_path_length() for a slightly faster unweighted version.
 *
 * \example examples/simple/igraph_grg_game.c
 */

int igraph_average_path_length_dijkstra(const igraph_t *graph,
                                        igraph_real_t *res, igraph_real_t *unconn_pairs,
                                        const igraph_vector_t *weights,
                                        igraph_bool_t directed, igraph_bool_t unconn)
{
    return igraph_i_average_path_length_dijkstra(graph, res, unconn_pairs, weights, directed, /* invert= */ 0, unconn);
}


/**
 * \ingroup structural
 * \function igraph_global_efficiency
 * \brief Calculates the global efficiency of a network.
 *
 * 
 * The global efficiency of a network is defined as the average of inverse distances
 * between all pairs of vertices: E_g = 1/(N*(N-1)) sum_{i!=j} 1/d_ij,
 * where N is the number of vertices.
 * The inverse distance between pairs that are not reachable from each other is considered
 * to be zero. For graphs with fewer than 2 vertices, NaN is returned.
 *
 * 
 * Reference:
 * V. Latora and M. Marchiori,
 * Efficient Behavior of Small-World Networks,
 * Phys. Rev. Lett. 87, 198701 (2001).
 * https://dx.doi.org/10.1103/PhysRevLett.87.198701
 *
 * \param graph The graph object.
 * \param res Pointer to a real number, this will contain the result.
 * \param weights The edge weights. All edge weights must be
 *       non-negative for Dijkstra's algorithm to work. Additionally, no
 *       edge weight may be NaN. If either case does not hold, an error
 *       is returned. If this is a null pointer, then the unweighted
 *       version, \ref igraph_average_path_length() is used in calculating
 *       the global efficiency.
 * \param directed Boolean, whether to consider directed paths.
 *    Ignored for undirected graphs.
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_ENOMEM
 *              not enough memory for data structures
 *         \cli IGRAPH_EINVAL
 *              invalid weight vector
 *         \endclist
 *
 * Time complexity: O(|V| |E| log|E| + |V|) for weighted graphs and
 * O(|V| |E|) for unweighted ones. |V| denotes the number of
 * vertices and |E| denotes the number of edges.
 *
 */

int igraph_global_efficiency(const igraph_t *graph, igraph_real_t *res,
                             const igraph_vector_t *weights,
                             igraph_bool_t directed)
{
    return igraph_i_average_path_length_dijkstra(graph, res, NULL, weights, directed, /* invert= */ 1, /* unconn= */ 0);
}


/****************************/
/***** Local efficiency *****/
/****************************/

static int igraph_i_local_efficiency_unweighted(
        const igraph_t *graph,
        const igraph_adjlist_t *adjlist,
        igraph_dqueue_t *q,
        long int *already_counted,
        igraph_vector_t *vertex_neis,
        igraph_vector_char_t *nei_mask,
        igraph_real_t *res,
        igraph_integer_t vertex,
        igraph_neimode_t mode)
{

    long int no_of_nodes = igraph_vcount(graph);
    long int vertex_neis_size;
    long int neighbor_count; /* unlike 'vertex_neis_size', 'neighbor_count' does not count self-loops and multi-edges */
    long int i, j;

    igraph_dqueue_clear(q);

    /* already_counted[i] is 0 iff vertex i was not reached so far, otherwise
     * it is the index of the source vertex in vertex_neis that it was reached
     * from, plus 1 */
    memset(already_counted, 0, no_of_nodes * sizeof(long int));

    IGRAPH_CHECK(igraph_neighbors(graph, vertex_neis, vertex, mode));
    vertex_neis_size = igraph_vector_size(vertex_neis);

    igraph_vector_char_fill(nei_mask, 0);
    neighbor_count = 0;
    for (i=0; i < vertex_neis_size; ++i) {
        long int v = VECTOR(*vertex_neis)[i];
        if (v != vertex && ! VECTOR(*nei_mask)[v]) {
            VECTOR(*nei_mask)[v] = 1; /* mark as unprocessed neighbour */
            neighbor_count++;
        }
    }

    *res = 0.0;

    /* when the neighbor count is smaller than 2, we return 0.0 */
    if (neighbor_count < 2) {
        return IGRAPH_SUCCESS;
    }

    for (i=0; i < vertex_neis_size; ++i) {
        long int source = VECTOR(*vertex_neis)[i];
        long int reached = 0;

        IGRAPH_ALLOW_INTERRUPTION();

        if (source == vertex)
            continue;

        if (VECTOR(*nei_mask)[source] == 2)
            continue;

        VECTOR(*nei_mask)[source] = 2; /* mark neighbour as already processed */

        IGRAPH_CHECK(igraph_dqueue_push(q, source));
        IGRAPH_CHECK(igraph_dqueue_push(q, 0));
        already_counted[source] = i + 1;

        while (!igraph_dqueue_empty(q)) {
            igraph_vector_int_t *act_neis;
            long int act_neis_size;
            long int act = (long int) igraph_dqueue_pop(q);
            long int actdist = (long int) igraph_dqueue_pop(q);

            if (act != source && VECTOR(*nei_mask)[act]) {
                *res += 1.0 / actdist;
                reached++;
                if (reached == neighbor_count) {
                    igraph_dqueue_clear(q);
                    break;
                }
            }

            act_neis      = igraph_adjlist_get(adjlist, act);
            act_neis_size = igraph_vector_int_size(act_neis);
            for (j = 0; j < act_neis_size; j++) {
                long int neighbor = (long int) VECTOR(*act_neis)[j];

                if (neighbor == vertex || already_counted[neighbor] == i + 1)
                    continue;

                already_counted[neighbor] = i + 1;
                IGRAPH_CHECK(igraph_dqueue_push(q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(q, actdist + 1));
            }
        }
    }

    *res /= neighbor_count * (neighbor_count - 1.0);

    return IGRAPH_SUCCESS;
}

static int igraph_i_local_efficiency_dijkstra(
        const igraph_t *graph,
        igraph_lazy_inclist_t *inclist,
        igraph_2wheap_t *Q,
        igraph_vector_t *vertex_neis,
        igraph_vector_char_t *nei_mask, /* true if the corresponding node is a neighbour of 'vertex' */
        igraph_real_t *res,
        igraph_integer_t vertex,
        igraph_neimode_t mode,
        const igraph_vector_t *weights)
{

    /* Implementation details. This is the basic Dijkstra algorithm,
       with a binary heap. The heap is indexed, i.e. it stores not only
       the distances, but also which vertex they belong to.

       From now on we use a 2-way heap, so the distances can be queried
       directly from the heap.

       Dirty tricks:
       - the opposite of the distance is stored in the heap, as it is a
         maximum heap and we need a minimum heap.
       - we don't use IGRAPH_INFINITY in the res matrix during the
         computation, as IGRAPH_FINITE() might involve a function call
         and we want to spare that. -1 will denote infinity instead.
    */

    long int i, j;
    long int vertex_neis_size;
    long int neighbor_count; /* unlike 'inc_edges_size', 'neighbor_count' does not count self-loops or multi-edges */

    IGRAPH_CHECK(igraph_neighbors(graph, vertex_neis, vertex, mode));
    vertex_neis_size = igraph_vector_size(vertex_neis);

    igraph_vector_char_fill(nei_mask, 0);
    neighbor_count = 0;
    for (i=0; i < vertex_neis_size; ++i) {
        long int v = VECTOR(*vertex_neis)[i];
        if (v != vertex && ! VECTOR(*nei_mask)[v]) {
            VECTOR(*nei_mask)[v] = 1; /* mark as unprocessed neighbour */
            neighbor_count++;
        }
    }

    *res = 0.0;

    /* when the neighbor count is smaller than 2, we return 0.0 */
    if (neighbor_count < 2) {
        return IGRAPH_SUCCESS;
    }

    for (i=0; i < vertex_neis_size; ++i) {
        long int source = VECTOR(*vertex_neis)[i];
        long int reached = 0;

        IGRAPH_ALLOW_INTERRUPTION();

        if (source == vertex)
            continue;

        /* avoid processing a neighbour twice in multigraphs */
        if (VECTOR(*nei_mask)[source] == 2)
            continue;
        VECTOR(*nei_mask)[source] = 2; /* mark as already processed */

        igraph_2wheap_clear(Q);
        igraph_2wheap_push_with_index(Q, source, -1.0);

        while (!igraph_2wheap_empty(Q)) {
            long int minnei = igraph_2wheap_max_index(Q);
            igraph_real_t mindist = -igraph_2wheap_deactivate_max(Q);
            igraph_vector_int_t *neis;
            long int nlen;

            if (minnei != source && VECTOR(*nei_mask)[minnei]) {
                *res += 1.0/(mindist - 1.0);
                reached++;
                if (reached == neighbor_count) {
                    igraph_2wheap_clear(Q);
                    break;
                }
            }

            /* Now check all neighbors of 'minnei' for a shorter path */
            neis = igraph_lazy_inclist_get(inclist, (igraph_integer_t) minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                igraph_real_t altdist, curdist;
                igraph_bool_t active, has;
                long int edge = (long int) VECTOR(*neis)[j];
                long int tto = IGRAPH_OTHER(graph, edge, minnei);

                if (tto == vertex)
                    continue;

                altdist = mindist + VECTOR(*weights)[edge];
                active = igraph_2wheap_has_active(Q, tto);
                has = igraph_2wheap_has_elem(Q, tto);
                curdist = active ? -igraph_2wheap_get(Q, tto) : 0.0;
                if (!has) {
                    /* This is the first non-infinite distance */
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(Q, tto, -altdist));
                } else if (altdist < curdist) {
                    /* This is a shorter path */
                    IGRAPH_CHECK(igraph_2wheap_modify(Q, tto, -altdist));
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

    }

    *res /= neighbor_count * (neighbor_count - 1.0);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup structural
 * \function igraph_local_efficiency
 * \brief Calculates the local efficiency around each vertex in a network.
 *
 * 
 * The local efficiency of a network around a vertex is defined as follows:
 * We remove the vertex and compute the distances (shortest path lengths) between
 * its neighbours through the rest of the network. The local efficiency around the
 * removed vertex is the average of the inverse of these distances.
 *
 * 
 * The inverse distance between two vertices which are not reachable from each other
 * is considered to be zero. The local efficiency around a vertex with fewer than two
 * neighbours is taken to be zero by convention.
 *
 * 
 * Reference:
 * I. Vragović, E. Louis, and A. Díaz-Guilera,
 * Efficiency of informational transfer in regular and complex networks,
 * Phys. Rev. E 71, 1 (2005).
 * http://dx.doi.org/10.1103/PhysRevE.71.036122
 *
 * \param graph The graph object.
 * \param res Pointer to an initialized vector, this will contain the result.
 * \param vids The vertices around which the local efficiency will be calculated.
 * \param weights The edge weights. All edge weights must be
 *       non-negative. Additionally, no edge weight may be NaN. If either
 *       case does not hold, an error is returned. If this is a null
 *       pointer, then the unweighted version,
 *       \ref igraph_average_path_length() is called.
 * \param directed Boolean, whether to consider directed paths.
 *    Ignored for undirected graphs.
 * \param mode How to determine the local neighborhood of each vertex
 *    in directed graphs. Ignored in undirected graphs.
 *         \clist
 *         \cli IGRAPH_ALL
 *              take both in- and out-neighbours;
 *              this is a reasonable default for high-level interfaces.
 *         \cli IGRAPH_OUT
 *              take only out-neighbours
 *         \cli IGRAPH_IN
 *              take only in-neighbours
 *         \endclist
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_ENOMEM
 *              not enough memory for data structures
 *         \cli IGRAPH_EINVAL
 *              invalid weight vector
 *         \endclist
 *
 * Time complexity: O(|E|^2 log|E|) for weighted graphs and
 * O(|E|^2) for unweighted ones. |E| denotes the number of edges.
 *
 * \sa \ref igraph_average_local_efficiency()
 *
 */

int igraph_local_efficiency(const igraph_t *graph, igraph_vector_t *res,
                            const igraph_vs_t vids,
                            const igraph_vector_t *weights,
                            igraph_bool_t directed, igraph_neimode_t mode)
{
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int nodes_to_calc; /* no. of vertices includes in computation */
    igraph_vit_t vit;
    igraph_vector_t vertex_neis;
    igraph_vector_char_t nei_mask;
    long int i;

    /* 'nei_mask' is a vector indexed by vertices. The meaning of its values is as follows:
     *   0: not a neighbour of 'vertex'
     *   1: a not-yet-processed neighbour of 'vertex'
     *   2: an already processed neighbour of 'vertex'
     *
     * Marking neighbours of already processed is necessary to avoid processing them more
     * than once in multigraphs.
     */
    IGRAPH_CHECK(igraph_vector_char_init(&nei_mask, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &nei_mask);
    IGRAPH_VECTOR_INIT_FINALLY(&vertex_neis, 0);

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));

    if (! weights) /* unweighted case */
    {
        long int *already_counted;
        igraph_adjlist_t adjlist;
        igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

        already_counted = IGRAPH_CALLOC(no_of_nodes, long int);
        if (already_counted == 0) {
            IGRAPH_ERROR("Local efficiency calculation failed", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, already_counted);

        IGRAPH_CHECK(igraph_adjlist_init(
            graph, &adjlist,
            directed ? IGRAPH_OUT : IGRAPH_ALL,
            IGRAPH_LOOPS, IGRAPH_MULTIPLE
        ));
        IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

        IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

        for (IGRAPH_VIT_RESET(vit), i=0;
             ! IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), i++)
        {
            IGRAPH_CHECK(igraph_i_local_efficiency_unweighted(
                             graph, &adjlist,
                             &q, already_counted, &vertex_neis, &nei_mask,
                             &(VECTOR(*res)[i]), IGRAPH_VIT_GET(vit), mode));
        }

        igraph_dqueue_destroy(&q);
        igraph_adjlist_destroy(&adjlist);
        IGRAPH_FREE(already_counted);
        IGRAPH_FINALLY_CLEAN(3);
    }
    else /* weighted case */
    {
        igraph_lazy_inclist_t inclist;
        igraph_2wheap_t Q;

        if (igraph_vector_size(weights) != no_of_edges) {
            IGRAPH_ERROR("Weight vector length does not match the number of edges", IGRAPH_EINVAL);
        }
        if (no_of_edges > 0) {
            igraph_real_t min = igraph_vector_min(weights);
            if (min < 0) {
                IGRAPH_ERROR("Weight vector must be non-negative", IGRAPH_EINVAL);
            }
            else if (igraph_is_nan(min)) {
                IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
            }
        }

        IGRAPH_CHECK(igraph_lazy_inclist_init(
            graph, &inclist, directed ? IGRAPH_OUT : IGRAPH_ALL, IGRAPH_LOOPS
        ));
        IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);
        IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
        IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);

        for (IGRAPH_VIT_RESET(vit), i=0;
             ! IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), i++)
        {
            IGRAPH_CHECK(igraph_i_local_efficiency_dijkstra(
                             graph, &inclist,
                             &Q, &vertex_neis, &nei_mask,
                             &(VECTOR(*res)[i]), IGRAPH_VIT_GET(vit), mode, weights));
        }

        igraph_2wheap_destroy(&Q);
        igraph_lazy_inclist_destroy(&inclist);
        IGRAPH_FINALLY_CLEAN(2);
    }

    igraph_vit_destroy(&vit);
    igraph_vector_destroy(&vertex_neis);
    igraph_vector_char_destroy(&nei_mask);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}


/**
 * \ingroup structural
 * \function igraph_average_local_efficiency
 * \brief Calculates the average local efficiency in a network.
 *
 * For the null graph, zero is returned by convention.
 *
 * \param graph The graph object.
 * \param res Pointer to a real number, this will contain the result.
 * \param weights The edge weights. They must be all non-negative.
 *    If a null pointer is given, all weights are assumed to be 1.
 * \param directed Boolean, whether to consider directed paths.
 *    Ignored for undirected graphs.
 * \param mode How to determine the local neighborhood of each vertex
 *    in directed graphs. Ignored in undirected graphs.
 *         \clist
 *         \cli IGRAPH_ALL
 *              take both in- and out-neighbours;
 *              this is a reasonable default for high-level interfaces.
 *         \cli IGRAPH_OUT
 *              take only out-neighbours
 *         \cli IGRAPH_IN
 *              take only in-neighbours
 *         \endclist
 * \return Error code:
 *         \clist
 *         \cli IGRAPH_ENOMEM
 *              not enough memory for data structures
 *         \cli IGRAPH_EINVAL
 *              invalid weight vector
 *         \endclist
 *
 * Time complexity: O(|E|^2 log|E|) for weighted graphs and
 * O(|E|^2) for unweighted ones. |E| denotes the number of edges.
 *
 * \sa \ref igraph_local_efficiency()
 *
 */

int igraph_average_local_efficiency(const igraph_t *graph, igraph_real_t *res,
                                    const igraph_vector_t *weights,
                                    igraph_bool_t directed, igraph_neimode_t mode)
{
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t local_eff;

    /* If there are fewer than 3 vertices, no vertex has more than one neighbour, thus all
       local efficiencies are zero. For the null graph, we return zero by convention. */
    if (no_of_nodes < 3) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&local_eff, no_of_nodes);

    IGRAPH_CHECK(igraph_local_efficiency(graph, &local_eff, igraph_vss_all(), weights, directed, mode));

    *res = igraph_vector_sum(&local_eff);
    *res /= no_of_nodes;

    igraph_vector_destroy(&local_eff);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}


/***************************/
/***** Graph diameter ******/
/***************************/

/**
 * \ingroup structural
 * \function igraph_diameter
 * \brief Calculates the diameter of a graph (longest geodesic).
 *
 * The diameter of a graph is the length of the longest shortest path it has.
 * This function computes both the diameter, as well as the corresponding path.
 * The diameter of the null graph is considered be infinity by convention.
 *
 * If the graph has no vertices, \c IGRAPH_NAN is returned.
 *
 * \param graph The graph object.
 * \param pres Pointer to a real number, if not \c NULL then it will contain
 *        the diameter (the actual distance).
 * \param pfrom Pointer to an integer, if not \c NULL it will be set to the
 *        source vertex of the diameter path. If the graph has no diameter path,
 *        it will be set to -1.
 * \param pto Pointer to an integer, if not \c NULL it will be set to the
 *        target vertex of the diameter path. If the graph has no diameter path,
 *        it will be set to -1.
 * \param path Pointer to an initialized vector. If not \c NULL the actual
 *        longest geodesic path will be stored here. The vector will be
 *        resized as needed.
 * \param directed Boolean, whether to consider directed
 *        paths. Ignored for undirected graphs.
 * \param unconn What to do if the graph is not connected. If
 *        \c TRUE the longest geodesic within a component
 *        will be returned, otherwise \c IGRAPH_INFINITY is returned.
 * \return Error code:
 *         \c IGRAPH_ENOMEM, not enough memory for
 *         temporary data.
 *
 * Time complexity: O(|V||E|), the
 * number of vertices times the number of edges.
 *
 * \sa \ref igraph_diameter_dijkstra()
 *
 * \example examples/simple/igraph_diameter.c
 */

int igraph_diameter(const igraph_t *graph, igraph_real_t *pres,
                    igraph_integer_t *pfrom, igraph_integer_t *pto,
                    igraph_vector_t *path,
                    igraph_bool_t directed, igraph_bool_t unconn) {

    long int no_of_nodes = igraph_vcount(graph);
    long int i, j, n;
    long int *already_added;
    long int nodes_reached;
    long int from = 0, to = 0;
    igraph_real_t res = 0;

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_vector_int_t *neis;
    igraph_neimode_t dirmode;
    igraph_adjlist_t allneis;

    /* See https://github.com/igraph/igraph/issues/1538#issuecomment-724071857
     * for why we return NaN for the null graph. */
    if (no_of_nodes == 0) {
        if (pres) {
            *pres = IGRAPH_NAN;
        }
        if (path) {
            igraph_vector_clear(path);
        }
        if (pfrom) {
            *pfrom = -1;
        }
        if (pto) {
            *pto = -1;
        }
        return IGRAPH_SUCCESS;
    }

    if (directed) {
        dirmode = IGRAPH_OUT;
    } else {
        dirmode = IGRAPH_ALL;
    }
    already_added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (already_added == 0) {
        IGRAPH_ERROR("diameter failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, dirmode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    for (i = 0; i < no_of_nodes; i++) {
        nodes_reached = 1;
        IGRAPH_CHECK(igraph_dqueue_push(&q, i));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        already_added[i] = i + 1;

        IGRAPH_PROGRESS("Diameter: ", 100.0 * i / no_of_nodes, NULL);

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);
            if (actdist > res) {
                res = actdist;
                from = i;
                to = actnode;
            }

            neis = igraph_adjlist_get(&allneis, actnode);
            n = igraph_vector_int_size(neis);
            for (j = 0; j < n; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (already_added[neighbor] == i + 1) {
                    continue;
                }
                already_added[neighbor] = i + 1;
                nodes_reached++;
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        } /* while !igraph_dqueue_empty */

        /* not connected, return IGRAPH_INFINITY */
        if (nodes_reached != no_of_nodes && !unconn) {
            res = IGRAPH_INFINITY;
            from = -1;
            to = -1;
            break;
        }
    } /* for i 0) {
        igraph_real_t min = igraph_vector_min(weights);
        if (min < 0) {
            IGRAPH_ERROR("Weight vector must be non-negative", IGRAPH_EINVAL);
        }
        else if (igraph_is_nan(min)) {
            IGRAPH_ERROR("Weight vector must not contain NaN values", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_2wheap_init(&Q, no_of_nodes));
    IGRAPH_FINALLY(igraph_2wheap_destroy, &Q);
    IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, dirmode, IGRAPH_LOOPS));
    IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);

    for (source = 0; source < no_of_nodes; source++) {

        IGRAPH_PROGRESS("Weighted diameter: ", source * 100.0 / no_of_nodes, NULL);
        IGRAPH_ALLOW_INTERRUPTION();

        igraph_2wheap_clear(&Q);
        igraph_2wheap_push_with_index(&Q, source, -1.0);

        nodes_reached = 0.0;

        while (!igraph_2wheap_empty(&Q)) {
            long int minnei = igraph_2wheap_max_index(&Q);
            igraph_real_t mindist = -igraph_2wheap_deactivate_max(&Q);
            igraph_vector_int_t *neis;
            long int nlen;

            if (mindist > res) {
                res = mindist; from = source; to = minnei;
            }
            nodes_reached++;

            /* Now check all neighbors of 'minnei' for a shorter path */
            neis = igraph_inclist_get(&inclist, minnei);
            nlen = igraph_vector_int_size(neis);
            for (j = 0; j < nlen; j++) {
                long int edge = (long int) VECTOR(*neis)[j];
                long int tto = IGRAPH_OTHER(graph, edge, minnei);
                igraph_real_t altdist = mindist + VECTOR(*weights)[edge];
                igraph_bool_t active = igraph_2wheap_has_active(&Q, tto);
                igraph_bool_t has = igraph_2wheap_has_elem(&Q, tto);
                igraph_real_t curdist = active ? -igraph_2wheap_get(&Q, tto) : 0.0;

                if (!has) {
                    /* First finite distance */
                    IGRAPH_CHECK(igraph_2wheap_push_with_index(&Q, tto, -altdist));
                } else if (altdist < curdist) {
                    /* A shorter path */
                    IGRAPH_CHECK(igraph_2wheap_modify(&Q, tto, -altdist));
                }
            }

        } /* !igraph_2wheap_empty(&Q) */

        /* not connected, return infinity */
        if (nodes_reached != no_of_nodes && !unconn) {
            res = IGRAPH_INFINITY;
            from = to = -1;
            break;
        }

    } /* source < no_of_nodes */

    /* Compensate for the +1 that we have added to distances */
    res -= 1;

    igraph_inclist_destroy(&inclist);
    igraph_2wheap_destroy(&Q);
    IGRAPH_FINALLY_CLEAN(2);

    IGRAPH_PROGRESS("Weighted diameter: ", 100.0, NULL);

    if (pres) {
        *pres = res;
    }
    if (pfrom) {
        *pfrom = (igraph_integer_t) from;
    }
    if (pto) {
        *pto = (igraph_integer_t) to;
    }
    if (path) {
        if (!igraph_finite(res)) {
            igraph_vector_clear(path);
        } else {
            igraph_vector_ptr_t tmpptr;
            igraph_vector_ptr_init(&tmpptr, 1);
            IGRAPH_FINALLY(igraph_vector_ptr_destroy, &tmpptr);
            VECTOR(tmpptr)[0] = path;
            IGRAPH_CHECK(igraph_get_shortest_paths_dijkstra(graph,
                         /*vertices=*/ &tmpptr, /*edges=*/ 0,
                         (igraph_integer_t) from,
                         igraph_vss_1((igraph_integer_t) to),
                         weights, dirmode, /*predecessors=*/ 0,
                         /*inbound_edges=*/ 0));
            igraph_vector_ptr_destroy(&tmpptr);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/simple_paths.c0000644000175100001710000001420400000000000024415 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_paths.h"

#include "igraph_interface.h"
#include "igraph_vector_ptr.h"
#include "igraph_iterators.h"
#include "igraph_adjlist.h"
#include "igraph_stack.h"

#include "core/interruption.h"

/**
 * \function igraph_get_all_simple_paths
 * \brief List all simple paths from one source.
 *
 * A path is simple if its vertices are unique, i.e. no vertex
 * is visited more than once.
 *
 * 
 * Note that potentially there are exponentially many
 * paths between two vertices of a graph, and you may
 * run out of memory when using this function, if your
 * graph is lattice-like.
 *
 * 
 * This function currently ignored multiple and loop edges.
 * \param graph The input graph.
 * \param res Initialized integer vector, all paths are
 *        returned here, separated by -1 markers. The paths
 *        are included in arbitrary order, as they are found.
 * \param from The start vertex.
 * \param to The target vertices.
 * \param cutoff Maximum length of path that is considered. If
 *        negative, paths of all lengths are considered.
 * \param mode The type of the paths to consider, it is ignored
 *        for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(n!) in the worst case, n is the number of
 * vertices.
 */

int igraph_get_all_simple_paths(const igraph_t *graph,
                                igraph_vector_int_t *res,
                                igraph_integer_t from,
                                const igraph_vs_t to,
                                igraph_integer_t cutoff,
                                igraph_neimode_t mode) {

    igraph_integer_t no_nodes = igraph_vcount(graph);
    igraph_vit_t vit;
    igraph_bool_t toall = igraph_vs_is_all(&to);
    igraph_vector_char_t markto;
    igraph_lazy_adjlist_t adjlist;
    igraph_vector_int_t stack, dist;
    igraph_vector_char_t added;
    igraph_vector_int_t nptr;
    int iteration = 0;

    if (from < 0 || from >= no_nodes) {
        IGRAPH_ERROR("Invalid starting vertex", IGRAPH_EINVAL);
    }

    if (!toall) {
        igraph_vector_char_init(&markto, no_nodes);
        IGRAPH_FINALLY(igraph_vector_char_destroy, &markto);
        IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);
        for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
            VECTOR(markto)[ IGRAPH_VIT_GET(vit) ] = 1;
        }
        igraph_vit_destroy(&vit);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_CHECK(igraph_vector_char_init(&added, no_nodes));
    IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
    IGRAPH_CHECK(igraph_vector_int_init(&stack, 100));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &stack);
    IGRAPH_CHECK(igraph_vector_int_init(&dist, 100));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &dist);
    IGRAPH_CHECK(igraph_lazy_adjlist_init(
        graph, &adjlist, mode, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE
    ));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
    IGRAPH_CHECK(igraph_vector_int_init(&nptr, no_nodes));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &nptr);

    igraph_vector_int_clear(res);

    igraph_vector_int_clear(&stack);
    igraph_vector_int_clear(&dist);
    igraph_vector_int_push_back(&stack, from);
    igraph_vector_int_push_back(&dist, 0);
    VECTOR(added)[from] = 1;
    while (!igraph_vector_int_empty(&stack)) {
        int act = igraph_vector_int_tail(&stack);
        int curdist = igraph_vector_int_tail(&dist);
        igraph_vector_int_t *neis = igraph_lazy_adjlist_get(&adjlist, act);
        int n = igraph_vector_int_size(neis);
        int *ptr = igraph_vector_int_e_ptr(&nptr, act);
        igraph_bool_t any;
        igraph_bool_t within_dist;
        int nei;

        if (iteration == 0) {
            IGRAPH_ALLOW_INTERRUPTION();
        }

        within_dist = (curdist < cutoff || cutoff < 0);
        if (within_dist) {
            /* Search for a neighbor that was not yet visited */
            any = 0;
            while (!any && (*ptr) < n) {
                nei = (int) VECTOR(*neis)[(*ptr)];
                any = !VECTOR(added)[nei];
                (*ptr) ++;
            }
        }
        if (within_dist && any) {
            /* There is such a neighbor, add it */
            IGRAPH_CHECK(igraph_vector_int_push_back(&stack, nei));
            IGRAPH_CHECK(igraph_vector_int_push_back(&dist, curdist + 1));
            VECTOR(added)[nei] = 1;
            /* Add to results */
            if (toall || VECTOR(markto)[nei]) {
                IGRAPH_CHECK(igraph_vector_int_append(res, &stack));
                IGRAPH_CHECK(igraph_vector_int_push_back(res, -1));
            }
        } else {
            /* There is no such neighbor, finished with the subtree */
            int up = igraph_vector_int_pop_back(&stack);
            igraph_vector_int_pop_back(&dist);
            VECTOR(added)[up] = 0;
            VECTOR(nptr)[up] = 0;
        }

        iteration++;
        if (iteration >= 10000) {
            iteration = 0;
        }
    }

    igraph_vector_int_destroy(&nptr);
    igraph_lazy_adjlist_destroy(&adjlist);
    igraph_vector_int_destroy(&dist);
    igraph_vector_int_destroy(&stack);
    igraph_vector_char_destroy(&added);
    IGRAPH_FINALLY_CLEAN(5);

    if (!toall) {
        igraph_vector_char_destroy(&markto);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/paths/unweighted.c0000644000175100001710000004643700000000000024105 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include "igraph_paths.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "core/interruption.h"

/**
 * \ingroup structural
 * \function igraph_shortest_paths
 * \brief The length of the shortest paths between vertices.
 *
 * \param graph The graph object.
 * \param res The result of the calculation, a matrix. A pointer to an
 *        initialized matrix, to be more precise. The matrix will be
 *        resized if needed. It will have the same
 *        number of rows as the length of the \c from
 *        argument, and its number of columns is the number of
 *        vertices in the \c to argument. One row of the matrix shows the
 *        distances from/to a given vertex to the ones in \c to.
 *        For the unreachable vertices IGRAPH_INFINITY is returned.
 * \param from The source vertices.
 * \param to The target vertices. It is not allowed to include a
 *    vertex twice or more.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the lengths of the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the lengths of the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an undirected one for
 *          the computation.
 *        \endclist
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary
 *           data.
 *        \cli IGRAPH_EINVVID
 *           invalid vertex id passed.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(n(|V|+|E|)),
 * n is the
 * number of vertices to calculate, |V| and
 * |E| are the number of vertices and
 * edges in the graph.
 *
 * \sa \ref igraph_get_shortest_paths() to get the paths themselves,
 * \ref igraph_shortest_paths_dijkstra() for the weighted version.
 */
int igraph_shortest_paths(const igraph_t *graph, igraph_matrix_t *res,
                          const igraph_vs_t from, const igraph_vs_t to,
                          igraph_neimode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_from, no_of_to;
    long int *already_counted;
    igraph_adjlist_t adjlist;
    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;
    igraph_vector_int_t *neis;
    igraph_bool_t all_to;

    long int i, j;
    igraph_vit_t fromvit, tovit;
    igraph_real_t my_infinity = IGRAPH_INFINITY;
    igraph_vector_t indexv;

    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, from, &fromvit));
    IGRAPH_FINALLY(igraph_vit_destroy, &fromvit);
    no_of_from = IGRAPH_VIT_SIZE(fromvit);

    IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);

    already_counted = IGRAPH_CALLOC(no_of_nodes, long int);
    if (already_counted == 0) {
        IGRAPH_ERROR("shortest paths failed", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, already_counted);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    all_to = igraph_vs_is_all(&to);
    if (all_to) {
        no_of_to = no_of_nodes;
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&indexv, no_of_nodes);
        IGRAPH_CHECK(igraph_vit_create(graph, to, &tovit));
        IGRAPH_FINALLY(igraph_vit_destroy, &tovit);
        no_of_to = IGRAPH_VIT_SIZE(tovit);
        for (i = 0; !IGRAPH_VIT_END(tovit); IGRAPH_VIT_NEXT(tovit)) {
            long int v = IGRAPH_VIT_GET(tovit);
            if (VECTOR(indexv)[v]) {
                IGRAPH_ERROR("Duplicate vertices in `to', this is not allowed",
                             IGRAPH_EINVAL);
            }
            VECTOR(indexv)[v] = ++i;
        }
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, no_of_from, no_of_to));
    igraph_matrix_fill(res, my_infinity);

    for (IGRAPH_VIT_RESET(fromvit), i = 0;
         !IGRAPH_VIT_END(fromvit);
         IGRAPH_VIT_NEXT(fromvit), i++) {
        long int reached = 0;
        IGRAPH_CHECK(igraph_dqueue_push(&q, IGRAPH_VIT_GET(fromvit)));
        IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
        already_counted[ (long int) IGRAPH_VIT_GET(fromvit) ] = i + 1;

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int act = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);

            if (all_to) {
                MATRIX(*res, i, act) = actdist;
            } else {
                if (VECTOR(indexv)[act]) {
                    MATRIX(*res, i, (long int)(VECTOR(indexv)[act] - 1)) = actdist;
                    reached++;
                    if (reached == no_of_to) {
                        igraph_dqueue_clear(&q);
                        break;
                    }
                }
            }

            neis = igraph_adjlist_get(&adjlist, act);
            long int nei_count = igraph_vector_int_size(neis);
            for (j = 0; j < nei_count; j++) {
                long int neighbor = (long int) VECTOR(*neis)[j];
                if (already_counted[neighbor] == i + 1) {
                    continue;
                }
                already_counted[neighbor] = i + 1;
                IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
            }
        }
    }

    /* Clean */
    if (!all_to) {
        igraph_vit_destroy(&tovit);
        igraph_vector_destroy(&indexv);
        IGRAPH_FINALLY_CLEAN(2);
    }

    IGRAPH_FREE(already_counted);
    igraph_dqueue_destroy(&q);
    igraph_vit_destroy(&fromvit);
    igraph_adjlist_destroy(&adjlist);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_get_shortest_paths
 * \brief Shortest paths from a vertex.
 *
 * 
 * If there is more than one geodesic between two vertices, this
 * function gives only one of them.
 * \param graph The graph object.
 * \param vertices The result, the ids of the vertices along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors.
 * \param edges The result, the ids of the edges along the paths.
 *        This is a pointer vector, each element points to a vector
 *        object. These should be initialized before passing them to
 *        the function, which will properly clear and/or resize them
 *        and fill the ids of the vertices along the geodesics from/to
 *        the vertices. Supply a null pointer here if you don't need
 *        these vectors.
 * \param from The id of the vertex from/to which the geodesics are
 *        calculated.
 * \param to Vertex sequence with the ids of the vertices to/from which the
 *        shortest paths will be calculated. A vertex might be given multiple
 *        times.
 * \param mode The type of shortest paths to be used for the
 *        calculation in directed graphs. Possible values:
 *        \clist
 *        \cli IGRAPH_OUT
 *          the outgoing paths are calculated.
 *        \cli IGRAPH_IN
 *          the incoming paths are calculated.
 *        \cli IGRAPH_ALL
 *          the directed graph is considered as an
 *          undirected one for the computation.
 *        \endclist
 * \param predecessors A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the predecessor of each vertex in
 *        the single source shortest path tree is returned here. The
 *        predecessor of vertex i in the tree is the vertex from which vertex i
 *        was reached. The predecessor of the start vertex (in the \c from
 *        argument) is itself by definition. If the predecessor is -1, it means
 *        that the given vertex was not reached from the source during the
 *        search. Note that the search terminates if all the vertices in
 *        \c to are reached.
 * \param inbound_edges A pointer to an initialized igraph vector or null.
 *        If not null, a vector containing the inbound edge of each vertex in
 *        the single source shortest path tree is returned here. The
 *        inbound edge of vertex i in the tree is the edge via which vertex i
 *        was reached. The start vertex and vertices that were not reached
 *        during the search will have -1 in the corresponding entry of the
 *        vector. Note that the search terminates if all the vertices in
 *        \c to are reached.
 *
 * \return Error code:
 *        \clist
 *        \cli IGRAPH_ENOMEM
 *           not enough memory for temporary data.
 *        \cli IGRAPH_EINVVID
 *           \p from is invalid vertex id, or the length of \p to is
 *           not the same as the length of \p res.
 *        \cli IGRAPH_EINVMODE
 *           invalid mode argument.
 *        \endclist
 *
 * Time complexity: O(|V|+|E|),
 * |V| is the number of vertices,
 * |E| the number of edges in the
 * graph.
 *
 * \sa \ref igraph_shortest_paths() if you only need the path length but
 * not the paths themselves.
 *
 * \example examples/simple/igraph_get_shortest_paths.c
 */
int igraph_get_shortest_paths(const igraph_t *graph,
                              igraph_vector_ptr_t *vertices,
                              igraph_vector_ptr_t *edges,
                              igraph_integer_t from, const igraph_vs_t to,
                              igraph_neimode_t mode,
                              igraph_vector_long_t *predecessors,
                              igraph_vector_long_t *inbound_edges) {

    /* TODO: use inclist_t if to is long (longer than 1?) */

    long int no_of_nodes = igraph_vcount(graph);
    long int *father;

    igraph_dqueue_t q = IGRAPH_DQUEUE_NULL;

    long int i, j, vsize;
    igraph_vector_t tmp = IGRAPH_VECTOR_NULL;

    igraph_vit_t vit;

    long int to_reach;
    long int reached = 0;

    if (from < 0 || from >= no_of_nodes) {
        IGRAPH_ERROR("cannot get shortest paths", IGRAPH_EINVVID);
    }
    if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
        mode != IGRAPH_ALL) {
        IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, to, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);

    if (vertices && IGRAPH_VIT_SIZE(vit) != igraph_vector_ptr_size(vertices)) {
        IGRAPH_ERROR("Size of the `vertices' and the `to' should match", IGRAPH_EINVAL);
    }
    if (edges && IGRAPH_VIT_SIZE(vit) != igraph_vector_ptr_size(edges)) {
        IGRAPH_ERROR("Size of the `edges' and the `to' should match", IGRAPH_EINVAL);
    }

    father = IGRAPH_CALLOC(no_of_nodes, long int);
    if (father == 0) {
        IGRAPH_ERROR("cannot get shortest paths", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, father);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);

    /* Mark the vertices we need to reach */
    to_reach = IGRAPH_VIT_SIZE(vit);
    for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        if (father[ (long int) IGRAPH_VIT_GET(vit) ] == 0) {
            father[ (long int) IGRAPH_VIT_GET(vit) ] = -1;
        } else {
            to_reach--;       /* this node was given multiple times */
        }
    }

    /* Meaning of father[i]:
     *
     * - If father[i] < 0, it means that vertex i has to be reached and has not
     *   been reached yet.
     *
     * - If father[i] = 0, it means that vertex i does not have to be reached and
     *   it has not been reached yet.
     *
     * - If father[i] = 1, it means that vertex i is the start vertex.
     *
     * - Otherwise, father[i] is the ID of the edge from which vertex i was
     *   reached plus 2.
     */

    IGRAPH_CHECK(igraph_dqueue_push(&q, from + 1));
    if (father[ (long int) from ] < 0) {
        reached++;
    }
    father[ (long int)from ] = 1;

    while (!igraph_dqueue_empty(&q) && reached < to_reach) {
        long int act = (long int) igraph_dqueue_pop(&q) - 1;

        IGRAPH_CHECK(igraph_incident(graph, &tmp, (igraph_integer_t) act, mode));
        vsize = igraph_vector_size(&tmp);
        for (j = 0; j < vsize; j++) {
            long int edge = (long int) VECTOR(tmp)[j];
            long int neighbor = IGRAPH_OTHER(graph, edge, act);
            if (father[neighbor] > 0) {
                continue;
            } else if (father[neighbor] < 0) {
                reached++;
            }
            father[neighbor] = edge + 2;
            IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor + 1));
        }
    }

    if (reached < to_reach) {
        IGRAPH_WARNING("Couldn't reach some vertices");
    }

    /* Create `predecessors' if needed */
    if (predecessors) {
        IGRAPH_CHECK(igraph_vector_long_resize(predecessors, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (father[i] <= 0) {
                /* i was not reached */
                VECTOR(*predecessors)[i] = -1;
            } else if (father[i] == 1) {
                /* i is the start vertex */
                VECTOR(*predecessors)[i] = i;
            } else {
                /* i was reached via the edge with ID = father[i] - 2 */
                VECTOR(*predecessors)[i] = IGRAPH_OTHER(graph, father[i] - 2, i);
            }
        }
    }

    /* Create `inbound_edges' if needed */
    if (inbound_edges) {
        IGRAPH_CHECK(igraph_vector_long_resize(inbound_edges, no_of_nodes));

        for (i = 0; i < no_of_nodes; i++) {
            if (father[i] <= 1) {
                /* i was not reached or i is the start vertex */
                VECTOR(*inbound_edges)[i] = -1;
            } else {
                /* i was reached via the edge with ID = father[i] - 2 */
                VECTOR(*inbound_edges)[i] = father[i] - 2;
            }
        }
    }

    /* Create `vertices' and `edges' if needed */
    if (vertices || edges) {
        for (IGRAPH_VIT_RESET(vit), j = 0;
             !IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), j++) {
            long int node = IGRAPH_VIT_GET(vit);
            igraph_vector_t *vvec = 0, *evec = 0;
            if (vertices) {
                vvec = VECTOR(*vertices)[j];
                igraph_vector_clear(vvec);
            }
            if (edges) {
                evec = VECTOR(*edges)[j];
                igraph_vector_clear(evec);
            }

            IGRAPH_ALLOW_INTERRUPTION();

            if (father[node] > 0) {
                long int act = node;
                long int size = 0;
                long int edge;
                while (father[act] > 1) {
                    size++;
                    edge = father[act] - 2;
                    act = IGRAPH_OTHER(graph, edge, act);
                }
                if (vvec) {
                    IGRAPH_CHECK(igraph_vector_resize(vvec, size + 1));
                    VECTOR(*vvec)[size] = node;
                }
                if (evec) {
                    IGRAPH_CHECK(igraph_vector_resize(evec, size));
                }
                act = node;
                while (father[act] > 1) {
                    size--;
                    edge = father[act] - 2;
                    act = IGRAPH_OTHER(graph, edge, act);
                    if (vvec) {
                        VECTOR(*vvec)[size] = act;
                    }
                    if (evec) {
                        VECTOR(*evec)[size] = edge;
                    }
                }
            }
        }
    }

    /* Clean */
    IGRAPH_FREE(father);
    igraph_dqueue_destroy(&q);
    igraph_vector_destroy(&tmp);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(4);

    return 0;
}

/**
 * \function igraph_get_shortest_path
 * \brief Shortest path from one vertex to another one.
 *
 * Calculates and returns a single unweighted shortest path from a
 * given vertex to another one. If there are more than one shortest
 * paths between the two vertices, then an arbitrary one is returned.
 *
 * This function is a wrapper to \ref
 * igraph_get_shortest_paths(), for the special case when only one
 * target vertex is considered.
 * \param graph The input graph, it can be directed or
 *        undirected. Directed paths are considered in directed
 *        graphs.
 * \param vertices Pointer to an initialized vector or a null
 *        pointer. If not a null pointer, then the vertex ids along
 *        the path are stored here, including the source and target
 *        vertices.
 * \param edges Pointer to an uninitialized vector or a null
 *        pointer. If not a null pointer, then the edge ids along the
 *        path are stored here.
 * \param from The id of the source vertex.
 * \param to The id of the target vertex.
 * \param mode A constant specifying how edge directions are
 *        considered in directed graphs. Valid modes are:
 *        \c IGRAPH_OUT, follows edge directions;
 *        \c IGRAPH_IN, follows the opposite directions; and
 *        \c IGRAPH_ALL, ignores edge directions. This argument is
 *        ignored for undirected graphs.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges in the graph.
 *
 * \sa \ref igraph_get_shortest_paths() for the version with more target
 * vertices.
 */

int igraph_get_shortest_path(const igraph_t *graph,
                             igraph_vector_t *vertices,
                             igraph_vector_t *edges,
                             igraph_integer_t from,
                             igraph_integer_t to,
                             igraph_neimode_t mode) {

    igraph_vector_ptr_t vertices2, *vp = &vertices2;
    igraph_vector_ptr_t edges2, *ep = &edges2;

    if (vertices) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&vertices2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vertices2);
        VECTOR(vertices2)[0] = vertices;
    } else {
        vp = 0;
    }
    if (edges) {
        IGRAPH_CHECK(igraph_vector_ptr_init(&edges2, 1));
        IGRAPH_FINALLY(igraph_vector_ptr_destroy, &edges2);
        VECTOR(edges2)[0] = edges;
    } else {
        ep = 0;
    }

    IGRAPH_CHECK(igraph_get_shortest_paths(graph, vp, ep, from,
                                           igraph_vss_1(to), mode, 0, 0));

    if (edges) {
        igraph_vector_ptr_destroy(&edges2);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (vertices) {
        igraph_vector_ptr_destroy(&vertices2);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5431414
igraph-0.9.9/vendor/source/igraph/src/properties/0000755000175100001710000000000000000000000022635 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/basic_properties.c0000644000175100001710000002510500000000000026341 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_interface.h"

/**
 * \section about_structural
 *
 * These functions usually calculate some structural property
 * of a graph, like its diameter, the degree of the nodes, etc.
 */

/**
 * \function igraph_density
 * Calculate the density of a graph.
 *
 * The density of a graph is simply the ratio number of
 * edges and the number of possible edges. Note that density is
 * ill-defined for graphs with multiple and/or loop edges, so consider
 * calling \ref igraph_simplify() on the graph if you know that it
 * contains multiple or loop edges.
 * \param graph The input graph object.
 * \param res Pointer to a real number, the result will be stored
 *   here.
 * \param loops Logical constant, whether to include loops in the
 *   calculation. If this constant is TRUE then
 *   loop edges are thought to be possible in the graph (this does not
 *   necessarily mean that the graph really contains any loops). If
 *   this is FALSE then the result is only correct if the graph does not
 *   contain loops.
 * \return Error code.
 *
 * Time complexity: O(1).
 */
int igraph_density(const igraph_t *graph, igraph_real_t *res,
                   igraph_bool_t loops) {

    igraph_integer_t no_of_nodes = igraph_vcount(graph);
    igraph_real_t no_of_edges = igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);

    if (no_of_nodes == 0) {
        *res = IGRAPH_NAN;
        return 0;
    }

    if (!loops) {
        if (no_of_nodes == 1) {
            *res = IGRAPH_NAN;
        } else if (directed) {
            *res = no_of_edges / no_of_nodes / (no_of_nodes - 1);
        } else {
            *res = no_of_edges / no_of_nodes * 2.0 / (no_of_nodes - 1);
        }
    } else {
        if (directed) {
            *res = no_of_edges / no_of_nodes / no_of_nodes;
        } else {
            *res = no_of_edges / no_of_nodes * 2.0 / (no_of_nodes + 1);
        }
    }

    return 0;
}

/**
 * \function igraph_diversity
 * Structural diversity index of the vertices
 *
 * This measure was defined in Nathan Eagle, Michael Macy and Rob
 * Claxton: Network Diversity and Economic Development, Science 328,
 * 1029--1031, 2010.
 *
 * 
 * It is simply the (normalized) Shannon entropy of the
 * incident edges' weights. D(i)=H(i)/log(k[i]), and
 * H(i) = -sum(p[i,j] log(p[i,j]), j=1..k[i]),
 * where p[i,j]=w[i,j]/sum(w[i,l], l=1..k[i]),  k[i] is the (total)
 * degree of vertex i, and w[i,j] is the weight of the edge(s) between
 * vertex i and j. The diversity of isolated vertices will be NaN
 * (not-a-number).
 *
 * 
 * The measure works only if the graph is undirected and has no multiple edges.
 * If the graph has multiple edges, simplify it first using \ref
 * igraph_simplify(). If the graph is directed, convert it into an undirected
 * graph with \ref igraph_to_undirected() .
 *
 * \param graph The undirected input graph.
 * \param weights The edge weights, in the order of the edge ids, must
 *    have appropriate length.
 * \param res An initialized vector, the results are stored here.
 * \param vids Vertex selector that specifies the vertices which to calculate
 *    the measure.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear.
 *
 */
int igraph_diversity(const igraph_t *graph, const igraph_vector_t *weights,
                     igraph_vector_t *res, const igraph_vs_t vids) {

    int no_of_nodes = igraph_vcount(graph);
    int no_of_edges = igraph_ecount(graph);
    igraph_vector_t incident;
    igraph_vit_t vit;
    igraph_real_t s, ent, w;
    int i, j, k;
    igraph_bool_t has_multiple;

    if (igraph_is_directed(graph)) {
        IGRAPH_ERROR("Diversity measure works with undirected graphs only.", IGRAPH_EINVAL);
    }

    if (!weights) {
        IGRAPH_ERROR("Edge weights must be given.", IGRAPH_EINVAL);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid edge weight vector length.", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_has_multiple(graph, &has_multiple));
    if (has_multiple) {
        IGRAPH_ERROR("Diversity measure works only if the graph has no multiple edges.", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&incident, 10);

    if (igraph_vs_is_all(&vids)) {
        IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {
            s = ent = 0.0;
            IGRAPH_CHECK(igraph_incident(graph, &incident, i, /*mode=*/ IGRAPH_ALL));
            for (j = 0, k = (int) igraph_vector_size(&incident); j < k; j++) {
                w = VECTOR(*weights)[(long int)VECTOR(incident)[j]];
                s += w;
                ent += (w * log(w));
            }
            VECTOR(*res)[i] = (log(s) - ent / s) / log(k);
        }
    } else {
        IGRAPH_CHECK(igraph_vector_resize(res, 0));
        IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);

        for (IGRAPH_VIT_RESET(vit), i = 0;
             !IGRAPH_VIT_END(vit);
             IGRAPH_VIT_NEXT(vit), i++) {
            long int v = IGRAPH_VIT_GET(vit);
            s = ent = 0.0;
            IGRAPH_CHECK(igraph_incident(graph, &incident, (igraph_integer_t) v,
                                         /*mode=*/ IGRAPH_ALL));
            for (j = 0, k = (int) igraph_vector_size(&incident); j < k; j++) {
                w = VECTOR(*weights)[(long int)VECTOR(incident)[j]];
                s += w;
                ent += (w * log(w));
            }
            IGRAPH_CHECK(igraph_vector_push_back(res, (log(s) - ent / s) / log(k)));
        }

        igraph_vit_destroy(&vit);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&incident);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \ingroup structural
 * \function igraph_reciprocity
 * \brief Calculates the reciprocity of a directed graph.
 *
 * 
 * The measure of reciprocity defines the proportion of mutual
 * connections, in a directed graph. It is most commonly defined as
 * the probability that the opposite counterpart of a directed edge is
 * also included in the graph. In adjacency matrix notation:
 * sum(i, j, (A.*A')ij) / sum(i, j, Aij), where
 * A.*A' is the element-wise product of matrix
 * A and its transpose. This measure is
 * calculated if the \p mode argument is \c
 * IGRAPH_RECIPROCITY_DEFAULT.
 *
 * 
 * Prior to igraph version 0.6, another measure was implemented,
 * defined as the probability of mutual connection between a vertex
 * pair if we know that there is a (possibly non-mutual) connection
 * between them. In other words, (unordered) vertex pairs are
 * classified into three groups: (1) disconnected, (2)
 * non-reciprocally connected, (3) reciprocally connected.
 * The result is the size of group (3), divided by the sum of group
 * sizes (2)+(3). This measure is calculated if \p mode is \c
 * IGRAPH_RECIPROCITY_RATIO.
 *
 * \param graph The graph object.
 * \param res Pointer to an \c igraph_real_t which will contain the result.
 * \param ignore_loops Whether to ignore loop edges.
 * \param mode Type of reciprocity to calculate, possible values are
 *    \c IGRAPH_RECIPROCITY_DEFAULT and \c IGRAPH_RECIPROCITY_RATIO,
 *    please see their description above.
 * \return Error code:
 *         \c IGRAPH_EINVAL: graph has no edges
 *         \c IGRAPH_ENOMEM: not enough memory for
 *         temporary data.
 *
 * Time complexity: O(|V|+|E|), |V| is the number of vertices,
 * |E| is the number of edges.
 *
 * \example examples/simple/igraph_reciprocity.c
 */
int igraph_reciprocity(const igraph_t *graph, igraph_real_t *res,
                       igraph_bool_t ignore_loops,
                       igraph_reciprocity_t mode) {

    igraph_integer_t nonrec = 0, rec = 0, loops = 0;
    igraph_vector_t inneis, outneis;
    long int i;
    long int no_of_nodes = igraph_vcount(graph);

    if (mode != IGRAPH_RECIPROCITY_DEFAULT &&
        mode != IGRAPH_RECIPROCITY_RATIO) {
        IGRAPH_ERROR("Invalid reciprocity type", IGRAPH_EINVAL);
    }

    /* THIS IS AN EXIT HERE !!!!!!!!!!!!!! */
    if (!igraph_is_directed(graph)) {
        *res = 1.0;
        return 0;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&inneis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&outneis, 0);

    for (i = 0; i < no_of_nodes; i++) {
        long int ip, op;
        igraph_neighbors(graph, &inneis, (igraph_integer_t) i, IGRAPH_IN);
        igraph_neighbors(graph, &outneis, (igraph_integer_t) i, IGRAPH_OUT);

        ip = op = 0;
        while (ip < igraph_vector_size(&inneis) &&
               op < igraph_vector_size(&outneis)) {
            if (VECTOR(inneis)[ip] < VECTOR(outneis)[op]) {
                nonrec += 1;
                ip++;
            } else if (VECTOR(inneis)[ip] > VECTOR(outneis)[op]) {
                nonrec += 1;
                op++;
            } else {

                /* loop edge? */
                if (VECTOR(inneis)[ip] == i) {
                    loops += 1;
                    if (!ignore_loops) {
                        rec += 1;
                    }
                } else {
                    rec += 1;
                }

                ip++;
                op++;
            }
        }
        nonrec += (igraph_vector_size(&inneis) - ip) +
                  (igraph_vector_size(&outneis) - op);
    }

    if (mode == IGRAPH_RECIPROCITY_DEFAULT) {
        if (ignore_loops) {
            *res = (igraph_real_t) rec / (igraph_ecount(graph) - loops);
        } else {
            *res = (igraph_real_t) rec / (igraph_ecount(graph));
        }
    } else if (mode == IGRAPH_RECIPROCITY_RATIO) {
        *res = (igraph_real_t) rec / (rec + nonrec);
    }

    igraph_vector_destroy(&inneis);
    igraph_vector_destroy(&outneis);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/constraint.c0000644000175100001710000003015700000000000025173 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_centrality.h"

#include "igraph_interface.h"

/**
 * \function igraph_constraint
 * \brief Burt's constraint scores.
 *
 * 
 * This function calculates Burt's constraint scores for the given
 * vertices, also known as structural holes.
 *
 * 
 * Burt's constraint is higher if ego has less, or mutually stronger
 * related (i.e. more redundant) contacts. Burt's measure of
 * constraint, C[i], of vertex i's ego network V[i], is defined for
 * directed and valued graphs,
 * 

 * C[i] = sum( sum( (p[i,q] p[q,j])^2, q in V[i], q != i,j ), j in
 * V[], j != i)
 * 

 * for a graph of order (i.e. number of vertices) N, where proportional
 * tie strengths are defined as
 * 

 * p[i,j]=(a[i,j]+a[j,i]) / sum(a[i,k]+a[k,i], k in V[i], k != i),
 * 

 * a[i,j] are elements of A and
 * the latter being the graph adjacency matrix. For isolated vertices,
 * constraint is undefined.
 *
 * 
 * Burt, R.S. (2004). Structural holes and good ideas. American
 * Journal of Sociology 110, 349-399.
 *
 * 
 * The first R version of this function was contributed by Jeroen
 * Bruggeman.
 * \param graph A graph object.
 * \param res Pointer to an initialized vector, the result will be
 *        stored here. The vector will be resized to have the
 *        appropriate size for holding the result.
 * \param vids Vertex selector containing the vertices for which the
 *        constraint should be calculated.
 * \param weights Vector giving the weights of the edges. If it is
 *        \c NULL then each edge is supposed to have the same weight.
 * \return Error code.
 *
 * Time complexity: O(|V|+E|+n*d^2), n is the number of vertices for
 * which the constraint is calculated and d is the average degree, |V|
 * is the number of vertices, |E| the number of edges in the
 * graph. If the weights argument is \c NULL then the time complexity
 * is O(|V|+n*d^2).
 */
int igraph_constraint(const igraph_t *graph, igraph_vector_t *res,
                      igraph_vs_t vids, const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_vit_t vit;
    long int nodes_to_calc;
    long int a, b, c, i, j, q, vsize, vsize2;
    igraph_integer_t edge, from, to, edge2;

    igraph_vector_t contrib;
    igraph_vector_t degree;
    igraph_vector_t ineis_in, ineis_out, jneis_in, jneis_out;

    if (weights != 0 && igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid length of weight vector", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&contrib, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&ineis_in, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&ineis_out, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&jneis_in, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&jneis_out, 0);

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    if (weights == 0) {
        IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                                   IGRAPH_ALL, IGRAPH_NO_LOOPS));
    } else {
        for (a = 0; a < no_of_edges; a++) {
            igraph_edge(graph, (igraph_integer_t) a, &from, &to);
            if (from != to) {
                VECTOR(degree)[(long int) from] += VECTOR(*weights)[a];
                VECTOR(degree)[(long int) to  ] += VECTOR(*weights)[a];
            }
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    igraph_vector_null(res);

    for (a = 0; a < nodes_to_calc; a++, IGRAPH_VIT_NEXT(vit)) {
        i = IGRAPH_VIT_GET(vit);

        /* get neighbors of i */
        IGRAPH_CHECK(igraph_incident(graph, &ineis_in, (igraph_integer_t) i,
                                     IGRAPH_IN));
        IGRAPH_CHECK(igraph_incident(graph, &ineis_out, (igraph_integer_t) i,
                                     IGRAPH_OUT));

        /* NaN for isolates */
        if (igraph_vector_size(&ineis_in) == 0 &&
            igraph_vector_size(&ineis_out) == 0) {
            VECTOR(*res)[a] = IGRAPH_NAN;
        }

        /* zero their contribution */
        vsize = igraph_vector_size(&ineis_in);
        for (b = 0; b < vsize; b++) {
            edge = (igraph_integer_t) VECTOR(ineis_in)[b];
            j = (long int) IGRAPH_OTHER(graph, edge, i);
            VECTOR(contrib)[j] = 0.0;
        }
        vsize = igraph_vector_size(&ineis_out);
        for (b = 0; b < vsize; b++) {
            edge = (igraph_integer_t) VECTOR(ineis_out)[b];
            j = (long int) IGRAPH_OTHER(graph, edge, i);
            VECTOR(contrib)[j] = 0.0;
        }

        /* add the direct contributions, in-neighbors and out-neighbors */
        vsize = igraph_vector_size(&ineis_in);
        for (b = 0; b < vsize; b++) {
            edge = (igraph_integer_t) VECTOR(ineis_in)[b];
            j = (long int) IGRAPH_OTHER(graph, edge, i);
            if (i != j) {     /* excluding loops */
                if (weights) {
                    VECTOR(contrib)[j] +=
                        VECTOR(*weights)[(long int)edge] / VECTOR(degree)[i];
                } else {
                    VECTOR(contrib)[j] += 1.0 / VECTOR(degree)[i];
                }
            }
        }
        if (igraph_is_directed(graph)) {
            vsize = igraph_vector_size(&ineis_out);
            for (b = 0; b < vsize; b++) {
                edge = (igraph_integer_t) VECTOR(ineis_out)[b];
                j = (long int) IGRAPH_OTHER(graph, edge, i);
                if (i != j) {
                    if (weights) {
                        VECTOR(contrib)[j] +=
                            VECTOR(*weights)[(long int)edge] / VECTOR(degree)[i];
                    } else {
                        VECTOR(contrib)[j] += 1.0 / VECTOR(degree)[i];
                    }
                }
            }
        }

        /* add the indirect contributions, in-in, in-out, out-in, out-out */
        vsize = igraph_vector_size(&ineis_in);
        for (b = 0; b < vsize; b++) {
            edge = (igraph_integer_t) VECTOR(ineis_in)[b];
            j = (long int) IGRAPH_OTHER(graph, edge, i);
            if (i == j) {
                continue;
            }
            IGRAPH_CHECK(igraph_incident(graph, &jneis_in, (igraph_integer_t) j,
                                         IGRAPH_IN));
            IGRAPH_CHECK(igraph_incident(graph, &jneis_out, (igraph_integer_t) j,
                                         IGRAPH_OUT));
            vsize2 = igraph_vector_size(&jneis_in);
            for (c = 0; c < vsize2; c++) {
                edge2 = (igraph_integer_t) VECTOR(jneis_in)[c];
                q = (long int) IGRAPH_OTHER(graph, edge2, j);
                if (j != q) {
                    if (weights) {
                        VECTOR(contrib)[q] +=
                            VECTOR(*weights)[(long int)edge] *
                            VECTOR(*weights)[(long int)edge2] /
                            VECTOR(degree)[i] / VECTOR(degree)[j];
                    } else {
                        VECTOR(contrib)[q] += 1 / VECTOR(degree)[i] / VECTOR(degree)[j];
                    }
                }
            }
            if (igraph_is_directed(graph)) {
                vsize2 = igraph_vector_size(&jneis_out);
                for (c = 0; c < vsize2; c++) {
                    edge2 = (igraph_integer_t) VECTOR(jneis_out)[c];
                    q = (long int) IGRAPH_OTHER(graph, edge2, j);
                    if (j != q) {
                        if (weights) {
                            VECTOR(contrib)[q] +=
                                VECTOR(*weights)[(long int)edge] *
                                VECTOR(*weights)[(long int)edge2] /
                                VECTOR(degree)[i] / VECTOR(degree)[j];
                        } else {
                            VECTOR(contrib)[q] += 1 / VECTOR(degree)[i] / VECTOR(degree)[j];
                        }
                    }
                }
            }
        }
        if (igraph_is_directed(graph)) {
            vsize = igraph_vector_size(&ineis_out);
            for (b = 0; b < vsize; b++) {
                edge = (igraph_integer_t) VECTOR(ineis_out)[b];
                j = (long int) IGRAPH_OTHER(graph, edge, i);
                if (i == j) {
                    continue;
                }
                IGRAPH_CHECK(igraph_incident(graph, &jneis_in, (igraph_integer_t) j,
                                             IGRAPH_IN));
                IGRAPH_CHECK(igraph_incident(graph, &jneis_out, (igraph_integer_t) j,
                                             IGRAPH_OUT));
                vsize2 = igraph_vector_size(&jneis_in);
                for (c = 0; c < vsize2; c++) {
                    edge2 = (igraph_integer_t) VECTOR(jneis_in)[c];
                    q = (long int) IGRAPH_OTHER(graph, edge2, j);
                    if (j != q) {
                        if (weights) {
                            VECTOR(contrib)[q] +=
                                VECTOR(*weights)[(long int)edge] *
                                VECTOR(*weights)[(long int)edge2] /
                                VECTOR(degree)[i] / VECTOR(degree)[j];
                        } else {
                            VECTOR(contrib)[q] += 1 / VECTOR(degree)[i] / VECTOR(degree)[j];
                        }
                    }
                }
                vsize2 = igraph_vector_size(&jneis_out);
                for (c = 0; c < vsize2; c++) {
                    edge2 = (igraph_integer_t) VECTOR(jneis_out)[c];
                    q = (long int) IGRAPH_OTHER(graph, edge2, j);
                    if (j != q) {
                        if (weights) {
                            VECTOR(contrib)[q] +=
                                VECTOR(*weights)[(long int)edge] *
                                VECTOR(*weights)[(long int)edge2] /
                                VECTOR(degree)[i] / VECTOR(degree)[j];
                        } else {
                            VECTOR(contrib)[q] += 1 / VECTOR(degree)[i] / VECTOR(degree)[j];
                        }
                    }
                }
            }
        }

        /* squared sum of the contributions */
        vsize = igraph_vector_size(&ineis_in);
        for (b = 0; b < vsize; b++) {
            edge = (igraph_integer_t) VECTOR(ineis_in)[b];
            j = (long int) IGRAPH_OTHER(graph, edge, i);
            if (i == j) {
                continue;
            }
            VECTOR(*res)[a] += VECTOR(contrib)[j] * VECTOR(contrib)[j];
            VECTOR(contrib)[j] = 0.0;
        }
        if (igraph_is_directed(graph)) {
            vsize =  igraph_vector_size(&ineis_out);
            for (b = 0; b < vsize; b++) {
                edge = (igraph_integer_t) VECTOR(ineis_out)[b];
                j = (long int) IGRAPH_OTHER(graph, edge, i);
                if (i == j) {
                    continue;
                }
                VECTOR(*res)[a] += VECTOR(contrib)[j] * VECTOR(contrib)[j];
                VECTOR(contrib)[j] = 0.0;
            }
        }
    }

    igraph_vit_destroy(&vit);
    igraph_vector_destroy(&jneis_out);
    igraph_vector_destroy(&jneis_in);
    igraph_vector_destroy(&ineis_out);
    igraph_vector_destroy(&ineis_in);
    igraph_vector_destroy(°ree);
    igraph_vector_destroy(&contrib);
    IGRAPH_FINALLY_CLEAN(7);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/convergence_degree.c0000644000175100001710000002066400000000000026622 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_centrality.h"

#include "igraph_adjlist.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"

#include "core/interruption.h"

#include 

/**
 * \function igraph_convergence_degree
 * \brief Calculates the convergence degree of each edge in a graph.
 *
 * Let us define the input set of an edge (i, j) as the set of vertices where
 * the shortest paths passing through (i, j) originate, and similarly, let us
 * defined the output set of an edge (i, j) as the set of vertices where the
 * shortest paths passing through (i, j) terminate. The convergence degree of
 * an edge is defined as the normalized value of the difference between the
 * size of the input set and the output set, i.e. the difference of them
 * divided by the sum of them. Convergence degrees are in the range (-1, 1); a
 * positive value indicates that the edge is \em convergent since the shortest
 * paths passing through it originate from a larger set and terminate in a
 * smaller set, while a negative value indicates that the edge is \em divergent
 * since the paths originate from a small set and terminate in a larger set.
 *
 * 
 * Note that the convergence degree as defined above does not make sense in
 * undirected graphs as there is no distinction between the input and output
 * set. Therefore, for undirected graphs, the input and output sets of an edge
 * are determined by orienting the edge arbitrarily while keeping the remaining
 * edges undirected, and then taking the absolute value of the convergence
 * degree.
 *
 * \param graph The input graph, it can be either directed or undirected.
 * \param result Pointer to an initialized vector; the convergence degrees of
 *   each edge will be stored here. May be \c NULL if we are not interested in
 *   the exact convergence degrees.
 * \param ins Pointer to an initialized vector; the size of the input set of
 *   each edge will be stored here. May be \c NULL if we are not interested in
 *   the sizes of the input sets.
 * \param outs Pointer to an initialized vector; the size of the output set of
 *   each edge will be stored here. May be \c NULL if we are not interested in
 *   the sizes of the output sets.
 * \return Error code.
 *
 * Time complexity: O(|V||E|), the number of vertices times the number of edges.
 */
int igraph_convergence_degree(const igraph_t *graph, igraph_vector_t *result,
                              igraph_vector_t *ins, igraph_vector_t *outs) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int i, j, k, n;
    long int *geodist;
    igraph_vector_int_t *eids;
    igraph_vector_t *ins_p, *outs_p, ins_v, outs_v;
    igraph_dqueue_t q;
    igraph_inclist_t inclist;
    igraph_bool_t directed = igraph_is_directed(graph);

    if (result != 0) {
        IGRAPH_CHECK(igraph_vector_resize(result, no_of_edges));
    }
    IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &q);

    if (ins == 0) {
        ins_p = &ins_v;
        IGRAPH_VECTOR_INIT_FINALLY(ins_p, no_of_edges);
    } else {
        ins_p = ins;
        IGRAPH_CHECK(igraph_vector_resize(ins_p, no_of_edges));
        igraph_vector_null(ins_p);
    }

    if (outs == 0) {
        outs_p = &outs_v;
        IGRAPH_VECTOR_INIT_FINALLY(outs_p, no_of_edges);
    } else {
        outs_p = outs;
        IGRAPH_CHECK(igraph_vector_resize(outs_p, no_of_edges));
        igraph_vector_null(outs_p);
    }

    geodist = IGRAPH_CALLOC(no_of_nodes, long int);
    if (geodist == 0) {
        IGRAPH_ERROR("Cannot calculate convergence degrees", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, geodist);

    /* Collect shortest paths originating from/to every node to correctly
     * determine input and output field sizes */
    for (k = 0; k < (directed ? 2 : 1); k++) {
        igraph_neimode_t neimode = (k == 0) ? IGRAPH_OUT : IGRAPH_IN;
        igraph_real_t *vec;
        IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, neimode, IGRAPH_LOOPS_ONCE));
        IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
        vec = (k == 0) ? VECTOR(*ins_p) : VECTOR(*outs_p);
        for (i = 0; i < no_of_nodes; i++) {
            igraph_dqueue_clear(&q);
            memset(geodist, 0, sizeof(long int) * (size_t) no_of_nodes);
            geodist[i] = 1;
            IGRAPH_CHECK(igraph_dqueue_push(&q, i));
            IGRAPH_CHECK(igraph_dqueue_push(&q, 0.0));
            while (!igraph_dqueue_empty(&q)) {
                long int actnode = (long int) igraph_dqueue_pop(&q);
                long int actdist = (long int) igraph_dqueue_pop(&q);
                IGRAPH_ALLOW_INTERRUPTION();
                eids = igraph_inclist_get(&inclist, actnode);
                n = igraph_vector_int_size(eids);
                for (j = 0; j < n; j++) {
                    long int neighbor = IGRAPH_OTHER(graph, VECTOR(*eids)[j], actnode);
                    if (geodist[neighbor] != 0) {
                        /* we've already seen this node, another shortest path? */
                        if (geodist[neighbor] - 1 == actdist + 1) {
                            /* Since this edge is in the BFS tree rooted at i, we must
                             * increase either the size of the infield or the outfield */
                            if (!directed) {
                                if (actnode < neighbor) {
                                    VECTOR(*ins_p)[(long int)VECTOR(*eids)[j]] += 1;
                                } else {
                                    VECTOR(*outs_p)[(long int)VECTOR(*eids)[j]] += 1;
                                }
                            } else {
                                vec[(long int)VECTOR(*eids)[j]] += 1;
                            }
                        } else if (geodist[neighbor] - 1 < actdist + 1) {
                            continue;
                        }
                    } else {
                        /* we haven't seen this node yet */
                        IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                        /* Since this edge is in the BFS tree rooted at i, we must
                         * increase either the size of the infield or the outfield */
                        if (!directed) {
                            if (actnode < neighbor) {
                                VECTOR(*ins_p)[(long int)VECTOR(*eids)[j]] += 1;
                            } else {
                                VECTOR(*outs_p)[(long int)VECTOR(*eids)[j]] += 1;
                            }
                        } else {
                            vec[(long int)VECTOR(*eids)[j]] += 1;
                        }
                        geodist[neighbor] = actdist + 2;
                    }
                }
            }
        }

        igraph_inclist_destroy(&inclist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (result != 0) {
        for (i = 0; i < no_of_edges; i++) {
            VECTOR(*result)[i] = (VECTOR(*ins_p)[i] - VECTOR(*outs_p)[i]) /
                                 (VECTOR(*ins_p)[i] + VECTOR(*outs_p)[i]);
        }

        if (!directed) {
            for (i = 0; i < no_of_edges; i++) {
                if (VECTOR(*result)[i] < 0) {
                    VECTOR(*result)[i] = -VECTOR(*result)[i];
                }
            }
        }
    }

    if (ins == 0) {
        igraph_vector_destroy(ins_p);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (outs == 0) {
        igraph_vector_destroy(outs_p);
        IGRAPH_FINALLY_CLEAN(1);
    }

    IGRAPH_FREE(geodist);
    igraph_dqueue_destroy(&q);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/dag.c0000644000175100001710000002475500000000000023551 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_topology.h"

#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_stack.h"

/**
 * \function igraph_topological_sorting
 * \brief Calculate a possible topological sorting of the graph.
 *
 * 
 * A topological sorting of a directed acyclic graph (DAG) is a linear ordering
 * of its vertices where each vertex comes before all nodes to which it has
 * edges. Every DAG has at least one topological sort, and may have many.
 * This function returns one possible topological sort among them. If the
 * graph is not acyclic (it has at least one cycle), an error is raised.
 *
 * \param graph The input graph.
 * \param res Pointer to a vector, the result will be stored here.
 *   It will be resized if needed.
 * \param mode Specifies how to use the direction of the edges.
 *   For \c IGRAPH_OUT, the sorting order ensures that each vertex comes
 *   before all vertices to which it has edges, so vertices with no incoming
 *   edges go first. For \c IGRAPH_IN, it is quite the opposite: each
 *   vertex comes before all vertices from which it receives edges. Vertices
 *   with no outgoing edges go first.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), where |V| and |E| are the number of
 * vertices and edges in the original input graph.
 *
 * \sa \ref igraph_is_dag() if you are only interested in whether a given
 *     graph is a DAG or not, or \ref igraph_feedback_arc_set() to find a
 *     set of edges whose removal makes the graph acyclic.
 *
 * \example examples/simple/igraph_topological_sorting.c
 */
int igraph_topological_sorting(const igraph_t* graph, igraph_vector_t *res,
                               igraph_neimode_t mode) {
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t degrees, neis;
    igraph_dqueue_t sources;
    igraph_neimode_t deg_mode;
    long int node, i, j;

    if (mode == IGRAPH_ALL || !igraph_is_directed(graph)) {
        IGRAPH_ERROR("Topological sorting does not make sense for undirected graphs", IGRAPH_EINVAL);
    } else if (mode == IGRAPH_OUT) {
        deg_mode = IGRAPH_IN;
    } else if (mode == IGRAPH_IN) {
        deg_mode = IGRAPH_OUT;
    } else {
        IGRAPH_ERROR("Invalid mode", IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(°rees, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_init(&sources, 0));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &sources);
    IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), deg_mode, 0));

    igraph_vector_clear(res);

    /* Do we have nodes with no incoming vertices? */
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(degrees)[i] == 0) {
            IGRAPH_CHECK(igraph_dqueue_push(&sources, i));
        }
    }

    /* Take all nodes with no incoming vertices and remove them */
    while (!igraph_dqueue_empty(&sources)) {
        igraph_real_t tmp = igraph_dqueue_pop(&sources); node = (long) tmp;
        /* Add the node to the result vector */
        igraph_vector_push_back(res, node);
        /* Exclude the node from further source searches */
        VECTOR(degrees)[node] = -1;
        /* Get the neighbors and decrease their degrees by one */
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) node, mode));
        j = igraph_vector_size(&neis);
        for (i = 0; i < j; i++) {
            VECTOR(degrees)[(long)VECTOR(neis)[i]]--;
            if (VECTOR(degrees)[(long)VECTOR(neis)[i]] == 0) {
                IGRAPH_CHECK(igraph_dqueue_push(&sources, VECTOR(neis)[i]));
            }
        }
    }

    if (igraph_vector_size(res) < no_of_nodes) {
        IGRAPH_ERROR("The graph has cycles; topological sorting is only possible in acyclic graphs", IGRAPH_EINVAL);
    }

    igraph_vector_destroy(°rees);
    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&sources);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}

/**
 * \function igraph_is_dag
 * Checks whether a graph is a directed acyclic graph (DAG) or not.
 *
 * 
 * A directed acyclic graph (DAG) is a directed graph with no cycles.
 *
 * \param graph The input graph.
 * \param res Pointer to a boolean constant, the result
 *     is stored here.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), where |V| and |E| are the number of
 * vertices and edges in the original input graph.
 *
 * \sa \ref igraph_topological_sorting() to get a possible topological
 *     sorting of a DAG.
 */
int igraph_is_dag(const igraph_t* graph, igraph_bool_t *res) {
    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t degrees, neis;
    igraph_dqueue_t sources;
    long int node, i, j, nei, vertices_left;

    if (!igraph_is_directed(graph)) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(°rees, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_dqueue_init(&sources, 0));
    IGRAPH_FINALLY(igraph_dqueue_destroy, &sources);
    IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), IGRAPH_OUT, 1));

    vertices_left = no_of_nodes;

    /* Do we have nodes with no incoming edges? */
    for (i = 0; i < no_of_nodes; i++) {
        if (VECTOR(degrees)[i] == 0) {
            IGRAPH_CHECK(igraph_dqueue_push(&sources, i));
        }
    }

    /* Take all nodes with no incoming edges and remove them */
    while (!igraph_dqueue_empty(&sources)) {
        igraph_real_t tmp = igraph_dqueue_pop(&sources); node = (long) tmp;
        /* Exclude the node from further source searches */
        VECTOR(degrees)[node] = -1;
        vertices_left--;
        /* Get the neighbors and decrease their degrees by one */
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) node,
                                      IGRAPH_IN));
        j = igraph_vector_size(&neis);
        for (i = 0; i < j; i++) {
            nei = (long)VECTOR(neis)[i];
            if (nei == node) {
                continue;
            }
            VECTOR(degrees)[nei]--;
            if (VECTOR(degrees)[nei] == 0) {
                IGRAPH_CHECK(igraph_dqueue_push(&sources, nei));
            }
        }
    }

    *res = (vertices_left == 0);
    if (vertices_left < 0) {
        IGRAPH_WARNING("vertices_left < 0 in igraph_is_dag, possible bug");
    }

    igraph_vector_destroy(°rees);
    igraph_vector_destroy(&neis);
    igraph_dqueue_destroy(&sources);
    IGRAPH_FINALLY_CLEAN(3);

    return IGRAPH_SUCCESS;
}

/* Create the transitive closure of a tree graph.
   This is fairly simple, we just collect all ancestors of a vertex
   using a depth-first search.
 */
int igraph_transitive_closure_dag(const igraph_t *graph,
                                  igraph_t *closure) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t deg;
    igraph_vector_t new_edges;
    igraph_vector_t ancestors;
    long int root;
    igraph_vector_t neighbors;
    igraph_stack_t path;
    igraph_vector_bool_t done;

    if (!igraph_is_directed(graph)) {
        IGRAPH_ERROR("Tree transitive closure of a directed graph",
                     IGRAPH_EINVAL);
    }

    IGRAPH_VECTOR_INIT_FINALLY(&new_edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(°, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&ancestors, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&neighbors, 0);
    IGRAPH_CHECK(igraph_stack_init(&path, 0));
    IGRAPH_FINALLY(igraph_stack_destroy, &path);
    IGRAPH_CHECK(igraph_vector_bool_init(&done, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_bool_destroy, &done);

    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_LOOPS));

#define STAR (-1)

    for (root = 0; root < no_of_nodes; root++) {
        if (VECTOR(deg)[root] != 0) {
            continue;
        }
        IGRAPH_CHECK(igraph_stack_push(&path, root));

        while (!igraph_stack_empty(&path)) {
            long int node = (long int) igraph_stack_top(&path);
            if (node == STAR) {
                /* Leaving a node */
                long int j, n;
                igraph_stack_pop(&path);
                node = (long int) igraph_stack_pop(&path);
                if (!VECTOR(done)[node]) {
                    igraph_vector_pop_back(&ancestors);
                    VECTOR(done)[node] = 1;
                }
                n = igraph_vector_size(&ancestors);
                for (j = 0; j < n; j++) {
                    IGRAPH_CHECK(igraph_vector_push_back(&new_edges, node));
                    IGRAPH_CHECK(igraph_vector_push_back(&new_edges,
                                                         VECTOR(ancestors)[j]));
                }
            } else {
                /* Getting into a node */
                long int n, j;
                if (!VECTOR(done)[node]) {
                    IGRAPH_CHECK(igraph_vector_push_back(&ancestors, node));
                }
                IGRAPH_CHECK(igraph_neighbors(graph, &neighbors,
                                              (igraph_integer_t) node, IGRAPH_IN));
                n = igraph_vector_size(&neighbors);
                IGRAPH_CHECK(igraph_stack_push(&path, STAR));
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neighbors)[j];
                    IGRAPH_CHECK(igraph_stack_push(&path, nei));
                }
            }
        }
    }

#undef STAR

    igraph_vector_bool_destroy(&done);
    igraph_stack_destroy(&path);
    igraph_vector_destroy(&neighbors);
    igraph_vector_destroy(&ancestors);
    igraph_vector_destroy(°);
    IGRAPH_FINALLY_CLEAN(5);

    IGRAPH_CHECK(igraph_create(closure, &new_edges, (igraph_integer_t)no_of_nodes,
                               IGRAPH_DIRECTED));

    igraph_vector_destroy(&new_edges);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/degrees.c0000644000175100001710000004321400000000000024423 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_interface.h"

/**
 * \function igraph_maxdegree
 * \brief The maximum degree in a graph (or set of vertices).
 *
 * 
 * The largest in-, out- or total degree of the specified vertices is
 * calculated. If the graph has no vertices, or \p vids is empty,
 * 0 is returned, as this is the smallest possible value for degrees.
 *
 * \param graph The input graph.
 * \param res Pointer to an integer (\c igraph_integer_t), the result
 *        will be stored here.
 * \param vids Vector giving the vertex IDs for which the maximum degree will
 *        be calculated.
 * \param mode Defines the type of the degree.
 *        \c IGRAPH_OUT, out-degree,
 *        \c IGRAPH_IN, in-degree,
 *        \c IGRAPH_ALL, total degree (sum of the
 *        in- and out-degree).
 *        This parameter is ignored for undirected graphs.
 * \param loops Boolean, gives whether the self-loops should be
 *        counted.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *         \c IGRAPH_EINVMODE: invalid mode argument.
 *
 * Time complexity: O(v) if loops is TRUE, and O(v*d) otherwise. v is the number
 * of vertices for which the degree will be calculated, and d is their
 * (average) degree.
 */
int igraph_maxdegree(const igraph_t *graph, igraph_integer_t *res,
                     igraph_vs_t vids, igraph_neimode_t mode,
                     igraph_bool_t loops) {

    igraph_vector_t tmp;

    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);

    IGRAPH_CHECK(igraph_degree(graph, &tmp, vids, mode, loops));
    if (igraph_vector_size(&tmp) == 0) {
        *res = 0;
    } else {
        *res = (igraph_integer_t) igraph_vector_max(&tmp);
    }

    igraph_vector_destroy(&tmp);
    IGRAPH_FINALLY_CLEAN(1);

    return IGRAPH_SUCCESS;
}

static int igraph_i_avg_nearest_neighbor_degree_weighted(const igraph_t *graph,
        igraph_vs_t vids,
        igraph_neimode_t mode,
        igraph_neimode_t neighbor_degree_mode,
        igraph_vector_t *knn,
        igraph_vector_t *knnk,
        const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t neis, edge_neis;
    long int i, j, no_vids;
    igraph_vit_t vit;
    igraph_vector_t my_knn_v, *my_knn = knn;
    igraph_vector_t strength, deg;
    igraph_integer_t maxdeg;
    igraph_vector_t deghist;
    igraph_real_t mynan = IGRAPH_NAN;

    if (igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector size", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    no_vids = IGRAPH_VIT_SIZE(vit);

    if (!knn) {
        IGRAPH_VECTOR_INIT_FINALLY(&my_knn_v, no_vids);
        my_knn = &my_knn_v;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(knn, no_vids));
    }

    /* Get degree of neighbours */
    IGRAPH_VECTOR_INIT_FINALLY(°, no_of_nodes);
    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(),
                               neighbor_degree_mode, IGRAPH_LOOPS));
    IGRAPH_VECTOR_INIT_FINALLY(&strength, no_of_nodes);

    /* Get strength of all nodes */
    IGRAPH_CHECK(igraph_strength(graph, &strength, igraph_vss_all(),
                                 mode, IGRAPH_LOOPS, weights));

    /* Get maximum degree for initialization */
    IGRAPH_CHECK(igraph_maxdegree(graph, &maxdeg, igraph_vss_all(),
                                  mode, IGRAPH_LOOPS));
    IGRAPH_VECTOR_INIT_FINALLY(&neis, (long int)maxdeg);
    IGRAPH_VECTOR_INIT_FINALLY(&edge_neis, (long int)maxdeg);
    igraph_vector_resize(&neis, 0);
    igraph_vector_resize(&edge_neis, 0);

    if (knnk) {
        IGRAPH_CHECK(igraph_vector_resize(knnk, (long int)maxdeg));
        igraph_vector_null(knnk);
        IGRAPH_VECTOR_INIT_FINALLY(°hist, (long int)maxdeg);
    }

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        igraph_real_t sum = 0.0;
        long int v = IGRAPH_VIT_GET(vit);
        long int nv;
        igraph_real_t str = VECTOR(strength)[v];
        /* Get neighbours and incident edges */
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v, mode));
        IGRAPH_CHECK(igraph_incident(graph, &edge_neis, (igraph_integer_t) v, mode));
        nv = igraph_vector_size(&neis);
        for (j = 0; j < nv; j++) {
            long int nei = (long int) VECTOR(neis)[j];
            long int e = (long int) VECTOR(edge_neis)[j];
            double w = VECTOR(*weights)[e];
            sum += w * VECTOR(deg)[nei];
        }
        if (str != 0.0) {
            VECTOR(*my_knn)[i] = sum / str;
        } else {
            VECTOR(*my_knn)[i] = mynan;
        }
        if (knnk && nv > 0) {
            VECTOR(*knnk)[nv - 1] += VECTOR(*my_knn)[i];
            VECTOR(deghist)[nv - 1] += 1;
        }
    }

    igraph_vector_destroy(&edge_neis);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(2);

    if (knnk) {
        for (i = 0; i < maxdeg; i++) {
            igraph_real_t dh = VECTOR(deghist)[i];
            if (dh != 0) {
                VECTOR(*knnk)[i] /= dh;
            } else {
                VECTOR(*knnk)[i] = mynan;
            }
        }

        igraph_vector_destroy(°hist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&strength);
    igraph_vector_destroy(°);
    IGRAPH_FINALLY_CLEAN(2);

    if (!knn) {
        igraph_vector_destroy(&my_knn_v);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

/**
 * \function igraph_avg_nearest_neighbor_degree
 * Average neighbor degree.
 *
 * Calculates the average degree of the neighbors for each vertex (\p knn), and
 * optionally, the same quantity as a function of the vertex degree (\p knnk).
 *
 * 
 * For isolated vertices \p knn is set to NaN.
 * The same is done in \p knnk for vertex degrees that
 * don't appear in the graph.
 *
 * 
 * The weighted version computes a weighted average of the neighbor degrees as
 *
 * k_nn_u = 1/s_u sum_v w_uv k_v,
 *
 * where s_u = sum_v w_uv is the sum of the incident edge weights
 * of vertex \c u, i.e. its strength.
 * The sum runs over the neighbors \c v of vertex \c u
 * as indicated by \p mode. w_uv denotes the weighted adjacency matrix
 * and k_v is the neighbors' degree, specified by \p neighbor_degree_mode.
 *
 * 
 * Reference:
 * A. Barrat, M. Barthélemy, R. Pastor-Satorras, and A. Vespignani,
 * The architecture of complex weighted networks,
 * Proc. Natl. Acad. Sci. USA 101, 3747 (2004).
 * https://dx.doi.org/10.1073/pnas.0400087101
 *
 * \param graph The input graph. It may be directed.
 * \param vids The vertices for which the calculation is performed.
 * \param mode The type of neighbors to consider in directed graphs.
 *   \c IGRAPH_OUT considers out-neighbors, \c IGRAPH_IN in-neighbors
 *   and \c IGRAPH_ALL ignores edge directions.
 * \param neighbor_degree_mode The type of degree to average in directed graphs.
 *   \c IGRAPH_OUT averages out-degrees, \c IGRAPH_IN averages in-degrees
 *   and \c IGRAPH_ALL ignores edge directions for the degree calculation.
 * \param vids The vertices for which the calculation is performed.
 * \param knn Pointer to an initialized vector, the result will be
 *   stored here. It will be resized as needed. Supply a \c NULL pointer
 *   here, if you only want to calculate \c knnk.
 * \param knnk Pointer to an initialized vector, the average
 *   neighbor degree as a function of the vertex degree is stored
 *   here. The first (zeroth) element is for degree one vertices,
 *   etc. Supply a \c NULL pointer here if you don't want to calculate
 *   this.
 * \param weights Optional edge weights. Supply a null pointer here
 *   for the non-weighted version.
 *
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number of vertices and
 * edges.
 *
 * \example examples/simple/igraph_knn.c
 */
int igraph_avg_nearest_neighbor_degree(const igraph_t *graph,
                                       igraph_vs_t vids,
                                       igraph_neimode_t mode,
                                       igraph_neimode_t neighbor_degree_mode,
                                       igraph_vector_t *knn,
                                       igraph_vector_t *knnk,
                                       const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t neis;
    long int i, j, no_vids;
    igraph_vit_t vit;
    igraph_vector_t my_knn_v, *my_knn = knn;
    igraph_vector_t deg;
    igraph_integer_t maxdeg;
    igraph_vector_t deghist;
    igraph_real_t mynan = IGRAPH_NAN;
    igraph_bool_t simple;

    IGRAPH_CHECK(igraph_is_simple(graph, &simple));
    if (!simple) {
        IGRAPH_ERROR("Average nearest neighbor degree works only with "
                     "simple graphs", IGRAPH_EINVAL);
    }

    if (weights) {
        return igraph_i_avg_nearest_neighbor_degree_weighted(graph, vids,
                mode, neighbor_degree_mode, knn, knnk, weights);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    no_vids = IGRAPH_VIT_SIZE(vit);

    if (!knn) {
        IGRAPH_VECTOR_INIT_FINALLY(&my_knn_v, no_vids);
        my_knn = &my_knn_v;
    } else {
        IGRAPH_CHECK(igraph_vector_resize(knn, no_vids));
    }

    IGRAPH_VECTOR_INIT_FINALLY(°, no_of_nodes);
    IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(),
                               neighbor_degree_mode, IGRAPH_LOOPS));
    IGRAPH_CHECK(igraph_maxdegree(graph, &maxdeg, igraph_vss_all(), mode, IGRAPH_LOOPS));
    IGRAPH_VECTOR_INIT_FINALLY(&neis, maxdeg);
    igraph_vector_resize(&neis, 0);

    if (knnk) {
        IGRAPH_CHECK(igraph_vector_resize(knnk, (long int)maxdeg));
        igraph_vector_null(knnk);
        IGRAPH_VECTOR_INIT_FINALLY(°hist, (long int)maxdeg);
    }

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        igraph_real_t sum = 0.0;
        long int v = IGRAPH_VIT_GET(vit);
        long int nv;
        IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v, mode));
        nv = igraph_vector_size(&neis);
        for (j = 0; j < nv; j++) {
            long int nei = (long int) VECTOR(neis)[j];
            sum += VECTOR(deg)[nei];
        }
        if (nv != 0) {
            VECTOR(*my_knn)[i] = sum / nv;
        } else {
            VECTOR(*my_knn)[i] = mynan;
        }
        if (knnk && nv > 0) {
            VECTOR(*knnk)[nv - 1] += VECTOR(*my_knn)[i];
            VECTOR(deghist)[nv - 1] += 1;
        }
    }

    if (knnk) {
        for (i = 0; i < maxdeg; i++) {
            long int dh = (long int) VECTOR(deghist)[i];
            if (dh != 0) {
                VECTOR(*knnk)[i] /= dh;
            } else {
                VECTOR(*knnk)[i] = mynan;
            }
        }
        igraph_vector_destroy(°hist);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&neis);
    igraph_vector_destroy(°);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(3);

    if (!knn) {
        igraph_vector_destroy(&my_knn_v);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_strength
 * Strength of the vertices, weighted vertex degree in other words.
 *
 * In a weighted network the strength of a vertex is the sum of the
 * weights of all incident edges. In a non-weighted network this is
 * exactly the vertex degree.
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the result is stored
 *   here. It will be resized as needed.
 * \param vids The vertices for which the calculation is performed.
 * \param mode Gives whether to count only outgoing (\c IGRAPH_OUT),
 *   incoming (\c IGRAPH_IN) edges or both (\c IGRAPH_ALL).
 * \param loops A logical scalar, whether to count loop edges as well.
 * \param weights A vector giving the edge weights. If this is a NULL
 *   pointer, then \ref igraph_degree() is called to perform the
 *   calculation.
 * \return Error code.
 *
 * Time complexity: O(|V|+|E|), linear in the number vertices and
 * edges.
 *
 * \sa \ref igraph_degree() for the traditional, non-weighted version.
 */
int igraph_strength(const igraph_t *graph, igraph_vector_t *res,
                    const igraph_vs_t vids, igraph_neimode_t mode,
                    igraph_bool_t loops, const igraph_vector_t *weights) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vit_t vit;
    long int no_vids;
    igraph_vector_t neis;
    long int i;

    if (!weights) {
        return igraph_degree(graph, res, vids, mode, loops);
    }

    if (igraph_vector_size(weights) != igraph_ecount(graph)) {
        IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    no_vids = IGRAPH_VIT_SIZE(vit);

    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&neis, no_of_nodes));
    IGRAPH_CHECK(igraph_vector_resize(res, no_vids));
    igraph_vector_null(res);

    if (loops) {
        for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
            long int vid = IGRAPH_VIT_GET(vit);
            long int j, n;
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) vid, mode));
            n = igraph_vector_size(&neis);
            for (j = 0; j < n; j++) {
                long int edge = (long int) VECTOR(neis)[j];
                VECTOR(*res)[i] += VECTOR(*weights)[edge];
            }
        }
    } else {
        for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
            long int vid = IGRAPH_VIT_GET(vit);
            long int j, n;
            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) vid, mode));
            n = igraph_vector_size(&neis);
            for (j = 0; j < n; j++) {
                long int edge = (long int) VECTOR(neis)[j];
                long int from = IGRAPH_FROM(graph, edge);
                long int to = IGRAPH_TO(graph, edge);
                if (from != to) {
                    VECTOR(*res)[i] += VECTOR(*weights)[edge];
                }
            }
        }
    }

    igraph_vit_destroy(&vit);
    igraph_vector_destroy(&neis);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}


/**
 * \function igraph_sort_vertex_ids_by_degree
 * \brief Calculate a list of vertex ids sorted by degree of the corresponding vertex.
 *
 * The list of vertex ids is returned in a vector that is sorted
 * in ascending or descending order of vertex degree.
 *
 * \param graph The input graph.
 * \param outvids Pointer to an initialized vector that will be
 *        resized and will contain the ordered vertex ids.
 * \param vids Input vertex selector of vertex ids to include in
 *        calculation.
 * \param mode Defines the type of the degree.
 *        \c IGRAPH_OUT, out-degree,
 *        \c IGRAPH_IN, in-degree,
 *        \c IGRAPH_ALL, total degree (sum of the
 *        in- and out-degree).
 *        This parameter is ignored for undirected graphs.
 * \param loops Boolean, gives whether the self-loops should be
 *        counted.
 * \param order Specifies whether the ordering should be ascending
 *        (\c IGRAPH_ASCENDING) or descending (\c IGRAPH_DESCENDING).
 * \param only_indices If true, then return a sorted list of indices
 *        into a vector corresponding to \c vids, rather than a list
 *        of vertex ids. This parameter is ignored if \c vids is set
 *        to all vertices via igraph_vs_all() or igraph_vss_all(),
 *        because in this case the indices and vertex ids are the
 *        same.
 * \return Error code:
 *         \c IGRAPH_EINVVID: invalid vertex id.
 *         \c IGRAPH_EINVMODE: invalid mode argument.
 *
 */
int igraph_sort_vertex_ids_by_degree(const igraph_t *graph,
                                     igraph_vector_t *outvids,
                                     igraph_vs_t vids,
                                     igraph_neimode_t mode,
                                     igraph_bool_t loops,
                                     igraph_order_t order,
                                     igraph_bool_t only_indices) {
    long int i;
    igraph_vector_t degrees, vs_vec;
    IGRAPH_VECTOR_INIT_FINALLY(°rees, 0);
    IGRAPH_CHECK(igraph_degree(graph, °rees, vids, mode, loops));
    IGRAPH_CHECK((int) igraph_vector_qsort_ind(°rees, outvids,
                 order == IGRAPH_DESCENDING));
    if (only_indices || igraph_vs_is_all(&vids) ) {
        igraph_vector_destroy(°rees);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&vs_vec, 0);
        IGRAPH_CHECK(igraph_vs_as_vector(graph, vids, &vs_vec));
        for (i = 0; i < igraph_vector_size(outvids); i++) {
            VECTOR(*outvids)[i] = VECTOR(vs_vec)[(long int)VECTOR(*outvids)[i]];
        }
        igraph_vector_destroy(&vs_vec);
        igraph_vector_destroy(°rees);
        IGRAPH_FINALLY_CLEAN(2);
    }
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/girth.c0000644000175100001710000001644600000000000024131 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_adjlist.h"
#include "igraph_components.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"

#include "core/interruption.h"

#include 

/**
 * \function igraph_girth
 * \brief The girth of a graph is the length of the shortest cycle in it.
 *
 * 
 * The current implementation works for undirected graphs only,
 * directed graphs are treated as undirected graphs. Self-loops and
 * multiple edges are ignored.
 *
 * 
 * For graphs that contain no cycles, and only for such graphs,
 * zero is returned. Note that in some applications, it is customary
 * to define the girth of acyclic graphs to be infinity. However, infinity
 * is not representable as an \c igraph_integer_t, therefore zero is used
 * for this case.
 *
 * 
 * This implementation is based on Alon Itai and Michael Rodeh:
 * Finding a minimum circuit in a graph
 * \emb Proceedings of the ninth annual ACM symposium on Theory of
 * computing \eme, 1-10, 1977. The first implementation of this
 * function was done by Keith Briggs, thanks Keith.
 * \param graph The input graph.
 * \param girth Pointer to an integer, if not \c NULL then the result
 *     will be stored here.
 * \param circle Pointer to an initialized vector, the vertex ids in
 *     the shortest circle will be stored here. If \c NULL then it is
 *     ignored.
 * \return Error code.
 *
 * Time complexity: O((|V|+|E|)^2), |V| is the number of vertices, |E|
 * is the number of edges in the general case. If the graph has no
 * cycles at all then the function needs O(|V|+|E|) time to realize
 * this and then it stops.
 *
 * \example examples/simple/igraph_girth.c
 */
int igraph_girth(const igraph_t *graph, igraph_integer_t *girth,
                 igraph_vector_t *circle) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q;
    igraph_lazy_adjlist_t adjlist;
    long int mincirc = LONG_MAX, minvertex = 0;
    long int node;
    igraph_bool_t triangle = 0;
    igraph_vector_int_t *neis;
    igraph_vector_long_t level;
    long int stoplevel = no_of_nodes + 1;
    igraph_bool_t anycircle = 0;
    long int t1 = 0, t2 = 0;

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_vector_long_init(&level, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &level);

    for (node = 0; !triangle && node < no_of_nodes; node++) {

        /* Are there circles in this graph at all? */
        if (node == 1 && anycircle == 0) {
            igraph_bool_t conn;
            IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
            if (conn) {
                /* No, there are none */
                break;
            }
        }

        anycircle = 0;
        igraph_dqueue_clear(&q);
        igraph_vector_long_null(&level);
        IGRAPH_CHECK(igraph_dqueue_push(&q, node));
        VECTOR(level)[node] = 1;

        IGRAPH_ALLOW_INTERRUPTION();

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actlevel = VECTOR(level)[actnode];
            long int i, n;

            if (actlevel >= stoplevel) {
                break;
            }

            neis = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) actnode);
            n = igraph_vector_int_size(neis);
            for (i = 0; i < n; i++) {
                long int nei = (long int) VECTOR(*neis)[i];
                long int neilevel = VECTOR(level)[nei];
                if (neilevel != 0) {
                    if (neilevel == actlevel - 1) {
                        continue;
                    } else {
                        /* found circle */
                        stoplevel = neilevel;
                        anycircle = 1;
                        if (actlevel < mincirc) {
                            /* Is it a minimum circle? */
                            mincirc = actlevel + neilevel - 1;
                            minvertex = node;
                            t1 = actnode; t2 = nei;
                            if (neilevel == 2) {
                                /* Is it a triangle? */
                                triangle = 1;
                            }
                        }
                        if (neilevel == actlevel) {
                            break;
                        }
                    }
                } else {
                    igraph_dqueue_push(&q, nei);
                    VECTOR(level)[nei] = actlevel + 1;
                }
            }

        } /* while q !empty */
    } /* node */

    if (girth) {
        if (mincirc == LONG_MAX) {
            *girth = mincirc = 0;
        } else {
            *girth = (igraph_integer_t) mincirc;
        }
    }

    /* Store the actual circle, if needed */
    if (circle) {
        IGRAPH_CHECK(igraph_vector_resize(circle, mincirc));
        if (mincirc != 0) {
            long int i, n, idx = 0;
            igraph_dqueue_clear(&q);
            igraph_vector_long_null(&level); /* used for father pointers */
#define FATHER(x) (VECTOR(level)[(x)])
            IGRAPH_CHECK(igraph_dqueue_push(&q, minvertex));
            FATHER(minvertex) = minvertex;
            while (FATHER(t1) == 0 || FATHER(t2) == 0) {
                long int actnode = (long int) igraph_dqueue_pop(&q);
                neis = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) actnode);
                n = igraph_vector_int_size(neis);
                for (i = 0; i < n; i++) {
                    long int nei = (long int) VECTOR(*neis)[i];
                    if (FATHER(nei) == 0) {
                        FATHER(nei) = actnode + 1;
                        igraph_dqueue_push(&q, nei);
                    }
                }
            }  /* while q !empty */
            /* Ok, now use FATHER to create the path */
            while (t1 != minvertex) {
                VECTOR(*circle)[idx++] = t1;
                t1 = FATHER(t1) - 1;
            }
            VECTOR(*circle)[idx] = minvertex;
            idx = mincirc - 1;
            while (t2 != minvertex) {
                VECTOR(*circle)[idx--] = t2;
                t2 = FATHER(t2) - 1;
            }
        } /* anycircle */
    } /* circle */
#undef FATHER

    igraph_vector_long_destroy(&level);
    igraph_dqueue_destroy(&q);
    igraph_lazy_adjlist_destroy(&adjlist);
    IGRAPH_FINALLY_CLEAN(3);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/loops.c0000644000175100001710000000540700000000000024143 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_interface.h"

/**
 * \function igraph_has_loop
 * \brief Returns whether the graph has at least one loop edge.
 *
 * 
 * A loop edge is an edge from a vertex to itself.
 * \param graph The input graph.
 * \param res Pointer to an initialized boolean vector for storing the result.
 *
 * \sa \ref igraph_simplify() to get rid of loop edges.
 *
 * Time complexity: O(e), the number of edges to check.
 *
 * \example examples/simple/igraph_has_loop.c
 */
int igraph_has_loop(const igraph_t *graph, igraph_bool_t *res) {
    long int i, m = igraph_ecount(graph);

    *res = 0;

    for (i = 0; i < m; i++) {
        if (IGRAPH_FROM(graph, i) == IGRAPH_TO(graph, i)) {
            *res = 1;
            break;
        }
    }

    return 0;
}

/**
 * \function igraph_is_loop
 * \brief Find the loop edges in a graph.
 *
 * 
 * A loop edge is an edge from a vertex to itself.
 * \param graph The input graph.
 * \param res Pointer to an initialized boolean vector for storing the result,
 *         it will be resized as needed.
 * \param es The edges to check, for all edges supply \ref igraph_ess_all() here.
 * \return Error code.
 *
 * \sa \ref igraph_simplify() to get rid of loop edges.
 *
 * Time complexity: O(e), the number of edges to check.
 *
 * \example examples/simple/igraph_is_loop.c
 */
int igraph_is_loop(const igraph_t *graph, igraph_vector_bool_t *res,
                   igraph_es_t es) {
    igraph_eit_t eit;
    long int i;

    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    IGRAPH_CHECK(igraph_vector_bool_resize(res, IGRAPH_EIT_SIZE(eit)));

    for (i = 0; !IGRAPH_EIT_END(eit); i++, IGRAPH_EIT_NEXT(eit)) {
        long int e = IGRAPH_EIT_GET(eit);
        VECTOR(*res)[i] = (IGRAPH_FROM(graph, e) == IGRAPH_TO(graph, e)) ? 1 : 0;
    }

    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/multiplicity.c0000644000175100001710000002757700000000000025553 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_adjlist.h"
#include "igraph_interface.h"

/**
 * \function igraph_is_simple
 * \brief Decides whether the input graph is a simple graph.
 *
 * 
 * A graph is a simple graph if it does not contain loop edges and
 * multiple edges.
 *
 * \param graph The input graph.
 * \param res Pointer to a boolean constant, the result
 *     is stored here.
 * \return Error code.
 *
 * \sa \ref igraph_is_loop() and \ref igraph_is_multiple() to
 * find the loops and multiple edges, \ref igraph_simplify() to
 * get rid of them, or \ref igraph_has_multiple() to decide whether
 * there is at least one multiple edge.
 *
 * Time complexity: O(|V|+|E|).
 */
int igraph_is_simple(const igraph_t *graph, igraph_bool_t *res) {
    long int vc = igraph_vcount(graph);
    long int ec = igraph_ecount(graph);

    if (vc == 0 || ec == 0) {
        *res = 1;
    } else {
        igraph_vector_t neis;
        long int i, j, n;
        igraph_bool_t found = 0;
        IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
        for (i = 0; i < vc; i++) {
            IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i, IGRAPH_OUT));
            n = igraph_vector_size(&neis);
            for (j = 0; j < n; j++) {
                if (VECTOR(neis)[j] == i) {
                    found = 1; break;
                }
                if (j > 0 && VECTOR(neis)[j - 1] == VECTOR(neis)[j]) {
                    found = 1; break;
                }
            }
        }
        *res = !found;
        igraph_vector_destroy(&neis);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}


/**
 * \function igraph_has_multiple
 * \brief Check whether the graph has at least one multiple edge.
 *
 * 
 * An edge is a multiple edge if there is another
 * edge with the same head and tail vertices in the graph.
 *
 * \param graph The input graph.
 * \param res Pointer to a boolean variable, the result will be stored here.
 * \return Error code.
 *
 * \sa \ref igraph_count_multiple(), \ref igraph_is_multiple() and \ref igraph_simplify().
 *
 * Time complexity: O(e*d), e is the number of edges to check and d is the
 * average degree (out-degree in directed graphs) of the vertices at the
 * tail of the edges.
 *
 * \example examples/simple/igraph_has_multiple.c
 */
int igraph_has_multiple(const igraph_t *graph, igraph_bool_t *res) {
    long int vc = igraph_vcount(graph);
    long int ec = igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);

    if (vc == 0 || ec == 0) {
        *res = 0;
    } else {
        igraph_vector_t neis;
        long int i, j, n;
        igraph_bool_t found = 0;
        IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
        for (i = 0; i < vc && !found; i++) {
            IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
                                          IGRAPH_OUT));
            n = igraph_vector_size(&neis);
            for (j = 1; j < n; j++) {
                if (VECTOR(neis)[j - 1] == VECTOR(neis)[j]) {
                    /* If the graph is undirected, loop edges appear twice in the neighbor
                     * list, so check the next item as well */
                    if (directed) {
                        /* Directed, so this is a real multiple edge */
                        found = 1; break;
                    } else if (VECTOR(neis)[j - 1] != i) {
                        /* Undirected, but not a loop edge */
                        found = 1; break;
                    } else if (j < n - 1 && VECTOR(neis)[j] == VECTOR(neis)[j + 1]) {
                        /* Undirected, loop edge, multiple times */
                        found = 1; break;
                    }
                }
            }
        }
        *res = found;
        igraph_vector_destroy(&neis);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_is_multiple
 * \brief Find the multiple edges in a graph.
 *
 * 
 * An edge is a multiple edge if there is another
 * edge with the same head and tail vertices in the graph.
 *
 * 
 * Note that this function returns true only for the second or more
 * appearances of the multiple edges.
 * \param graph The input graph.
 * \param res Pointer to a boolean vector, the result will be stored
 *        here. It will be resized as needed.
 * \param es The edges to check. Supply \ref igraph_ess_all() if you want
 *        to check all edges.
 * \return Error code.
 *
 * \sa \ref igraph_count_multiple(), \ref igraph_has_multiple() and \ref igraph_simplify().
 *
 * Time complexity: O(e*d), e is the number of edges to check and d is the
 * average degree (out-degree in directed graphs) of the vertices at the
 * tail of the edges.
 *
 * \example examples/simple/igraph_is_multiple.c
 */
int igraph_is_multiple(const igraph_t *graph, igraph_vector_bool_t *res,
                       igraph_es_t es) {
    igraph_eit_t eit;
    long int i, j, n;
    igraph_lazy_inclist_t inclist;

    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);

    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_CHECK(igraph_vector_bool_resize(res, IGRAPH_EIT_SIZE(eit)));

    for (i = 0; !IGRAPH_EIT_END(eit); i++, IGRAPH_EIT_NEXT(eit)) {
        long int e = IGRAPH_EIT_GET(eit);
        long int from = IGRAPH_FROM(graph, e);
        long int to = IGRAPH_TO(graph, e);
        igraph_vector_int_t *neis =
            igraph_lazy_inclist_get(&inclist, (igraph_integer_t) from);

        if (neis == 0) {
            /* Most likely out of memory */
            IGRAPH_ERROR("Out of memory while building lazy incidence list", IGRAPH_ENOMEM);
        }

        VECTOR(*res)[i] = 0;

        n = igraph_vector_int_size(neis);
        for (j = 0; j < n; j++) {
            long int e2 = (long int) VECTOR(*neis)[j];
            long int to2 = IGRAPH_OTHER(graph, e2, from);
            if (to2 == to && e2 < e) {
                VECTOR(*res)[i] = 1;
            }
        }
    }

    igraph_lazy_inclist_destroy(&inclist);
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}


/**
 * \function igraph_count_multiple
 * \brief Count the number of appearances of the edges in a graph.
 *
 * 
 * If the graph has no multiple edges then the result vector will be
 * filled with ones.
 * (An edge is a multiple edge if there is another
 * edge with the same head and tail vertices in the graph.)
 *
 * 
 * \param graph The input graph.
 * \param res Pointer to a vector, the result will be stored
 *        here. It will be resized as needed.
 * \param es The edges to check. Supply \ref igraph_ess_all() if you want
 *        to check all edges.
 * \return Error code.
 *
 * \sa \ref igraph_is_multiple() and \ref igraph_simplify().
 *
 * Time complexity: O(E d), E is the number of edges to check and d is the
 * average degree (out-degree in directed graphs) of the vertices at the
 * tail of the edges.
 */
int igraph_count_multiple(const igraph_t *graph, igraph_vector_t *res, igraph_es_t es) {
    igraph_eit_t eit;
    long int i, j, n;
    igraph_lazy_inclist_t inclist;

    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);
    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);

    IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_EIT_SIZE(eit)));

    for (i = 0; !IGRAPH_EIT_END(eit); i++, IGRAPH_EIT_NEXT(eit)) {
        long int e = IGRAPH_EIT_GET(eit);
        long int from = IGRAPH_FROM(graph, e);
        long int to = IGRAPH_TO(graph, e);
        igraph_vector_int_t *neis =
            igraph_lazy_inclist_get(&inclist, (igraph_integer_t) from);

        if (neis == 0) {
            /* Most likely out of memory */
            IGRAPH_ERROR("Out of memory while building lazy incidence list", IGRAPH_ENOMEM);
        }

        VECTOR(*res)[i] = 0;

        n = igraph_vector_int_size(neis);
        for (j = 0; j < n; j++) {
            long int e2 = (long int) VECTOR(*neis)[j];
            long int to2 = IGRAPH_OTHER(graph, e2, from);
            if (to2 == to) {
                VECTOR(*res)[i] += 1;
            }
        }
    }

    igraph_lazy_inclist_destroy(&inclist);
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_is_mutual
 * Check whether the edges of a directed graph are mutual.
 *
 * An (A,B) edge is mutual if the graph contains the (B,A) edge, too.
 * 
 *
 * An undirected graph only has mutual edges, by definition.
 * 
 *
 * Edge multiplicity is not considered here, e.g. if there are two
 * (A,B) edges and one (B,A) edge, then all three are considered to be
 * mutual.
 * 
 *
 * Loops are always mutual.
 *
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the result is stored
 *        here.
 * \param es The sequence of edges to check. Supply
 *        igraph_ess_all() for all edges, see \ref
 *        igraph_ess_all().
 * \return Error code.
 *
 * Time complexity: O(n log(d)), n is the number of edges supplied, d
 * is the maximum in-degree of the vertices that are targets of the
 * supplied edges. An upper limit of the time complexity is O(n log(|E|)),
 * |E| is the number of edges in the graph.
 */
int igraph_is_mutual(const igraph_t *graph, igraph_vector_bool_t *res, igraph_es_t es) {

    igraph_eit_t eit;
    igraph_lazy_adjlist_t adjlist;
    long int i;

    /* How many edges do we have? */
    IGRAPH_CHECK(igraph_eit_create(graph, es, &eit));
    IGRAPH_FINALLY(igraph_eit_destroy, &eit);
    IGRAPH_CHECK(igraph_vector_bool_resize(res, IGRAPH_EIT_SIZE(eit)));

    /* An undirected graph has mutual edges by definition,
       res is already properly resized */
    if (! igraph_is_directed(graph)) {
        igraph_vector_bool_fill(res, 1);
        igraph_eit_destroy(&eit);
        IGRAPH_FINALLY_CLEAN(1);
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);

    for (i = 0; ! IGRAPH_EIT_END(eit); i++, IGRAPH_EIT_NEXT(eit)) {
        long int edge = IGRAPH_EIT_GET(eit);
        long int from = IGRAPH_FROM(graph, edge);
        long int to = IGRAPH_TO(graph, edge);

        /* Check whether there is a to->from edge, search for from in the
           out-list of to. We don't search an empty vector, because
           vector_binsearch seems to have a bug with this. */
        igraph_vector_int_t *neis = igraph_lazy_adjlist_get(&adjlist,
                                (igraph_integer_t) to);
        if (igraph_vector_int_empty(neis)) {
            VECTOR(*res)[i] = 0;
        } else {
            VECTOR(*res)[i] = igraph_vector_int_binsearch2(neis, from);
        }
    }

    igraph_lazy_adjlist_destroy(&adjlist);
    igraph_eit_destroy(&eit);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/neighborhood.c0000644000175100001710000004303400000000000025454 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_neighborhood.h"

#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_memory.h"
#include "igraph_operators.h"

/**
 * \function igraph_neighborhood_size
 * \brief Calculates the size of the neighborhood of a given vertex.
 *
 * The neighborhood of a given order of a vertex includes all vertices
 * which are closer to the vertex than the order. I.e., order 0 is
 * always the vertex itself, order 1 is the vertex plus its immediate
 * neighbors, order 2 is order 1 plus the immediate neighbors of the
 * vertices in order 1, etc.
 *
 * 
 * This function calculates the size of the neighborhood
 * of the given order for the given vertices.
 *
 * \param graph The input graph.
 * \param res Pointer to an initialized vector, the result will be
 *    stored here. It will be resized as needed.
 * \param vids The vertices for which the calculation is performed.
 * \param order Integer giving the order of the neighborhood.
 * \param mode Specifies how to use the direction of the edges if a
 *   directed graph is analyzed. For \c IGRAPH_OUT only the outgoing
 *   edges are followed, so all vertices reachable from the source
 *   vertex in at most \c order steps are counted. For \c IGRAPH_IN
 *   all vertices from which the source vertex is reachable in at most
 *   \c order steps are counted. \c IGRAPH_ALL ignores the direction
 *   of the edges. This argument is ignored for undirected graphs.
 * \param mindist The minimum distance to include a vertex in the counting.
 *   Vertices reachable with a path shorter than this value are excluded.
 *   If this is one, then the starting vertex is not counted. If this is
 *   two, then its neighbors are not counted either, etc.
 * \return Error code.
 *
 * \sa \ref igraph_neighborhood() for calculating the actual neighborhood,
 * \ref igraph_neighborhood_graphs() for creating separate graphs from
 * the neighborhoods.
 *
 * Time complexity: O(n*d*o), where n is the number vertices for which
 * the calculation is performed, d is the average degree, o is the order.
 */
int igraph_neighborhood_size(const igraph_t *graph, igraph_vector_t *res,
                             igraph_vs_t vids, igraph_integer_t order,
                             igraph_neimode_t mode,
                             igraph_integer_t mindist) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q;
    igraph_vit_t vit;
    long int i, j;
    long int *added;
    igraph_vector_t neis;

    if (order < 0) {
        IGRAPH_ERRORF("Negative order in neighborhood size: %" IGRAPH_PRId ".",
                      IGRAPH_EINVAL, order);
    }

    if (mindist < 0 || mindist > order) {
        IGRAPH_ERRORF("Minimum distance should be between 0 and the neighborhood order (%" IGRAPH_PRId "), got %" IGRAPH_PRId ".",
                      IGRAPH_EINVAL, order, mindist);
    }

    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot calculate neighborhood size.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        long int node = IGRAPH_VIT_GET(vit);
        long int size = mindist == 0 ? 1 : 0;
        added[node] = i + 1;
        igraph_dqueue_clear(&q);
        if (order > 0) {
            igraph_dqueue_push(&q, node);
            igraph_dqueue_push(&q, 0);
        }

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);
            long int n;
            igraph_neighbors(graph, &neis, (igraph_integer_t) actnode, mode);
            n = igraph_vector_size(&neis);

            if (actdist < order - 1) {
                /* we add them to the q */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        IGRAPH_CHECK(igraph_dqueue_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                        if (actdist + 1 >= mindist) {
                            size++;
                        }
                    }
                }
            } else {
                /* we just count them, but don't add them */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        if (actdist + 1 >= mindist) {
                            size++;
                        }
                    }
                }
            }

        } /* while q not empty */

        VECTOR(*res)[i] = size;
    } /* for VIT, i */

    igraph_vector_destroy(&neis);
    igraph_vit_destroy(&vit);
    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(added);
    IGRAPH_FINALLY_CLEAN(4);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_neighborhood
 * \brief Calculate the neighborhood of vertices.
 *
 * The neighborhood of a given order of a vertex includes all vertices
 * which are closer to the vertex than the order. I.e., order 0 is
 * always the vertex itself, order 1 is the vertex plus its immediate
 * neighbors, order 2 is order 1 plus the immediate neighbors of the
 * vertices in order 1, etc.
 *
 * 
 * This function calculates the vertices within the
 * neighborhood of the specified vertices.
 *
 * \param graph The input graph.
 * \param res An initialized pointer vector. Note that the objects
 *    (pointers) in the vector will \em not be freed, but the pointer
 *    vector will be resized as needed. The result of the calculation
 *    will be stored here in \ref igraph_vector_t objects.
 * \param vids The vertices for which the calculation is performed.
 * \param order Integer giving the order of the neighborhood.
 * \param mode Specifies how to use the direction of the edges if a
 *   directed graph is analyzed. For \c IGRAPH_OUT only the outgoing
 *   edges are followed, so all vertices reachable from the source
 *   vertex in at most \p order steps are included. For \c IGRAPH_IN
 *   all vertices from which the source vertex is reachable in at most
 *   \p order steps are included. \c IGRAPH_ALL ignores the direction
 *   of the edges. This argument is ignored for undirected graphs.
 * \param mindist The minimum distance to include a vertex in the counting.
 *   Vertices reachable with a path shorter than this value are excluded.
 *   If this is one, then the starting vertex is not counted. If this is
 *   two, then its neighbors are not counted either, etc.
 * \return Error code.
 *
 * \sa \ref igraph_neighborhood_size() to calculate the size of the
 * neighborhood, \ref igraph_neighborhood_graphs() for creating
 * graphs from the neighborhoods.
 *
 * Time complexity: O(n*d*o), n is the number of vertices for which
 * the calculation is performed, d is the average degree, o is the
 * order.
 */
int igraph_neighborhood(const igraph_t *graph, igraph_vector_ptr_t *res,
                        igraph_vs_t vids, igraph_integer_t order,
                        igraph_neimode_t mode, igraph_integer_t mindist) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q;
    igraph_vit_t vit;
    long int i, j;
    long int *added;
    igraph_vector_t neis;
    igraph_vector_t tmp;
    igraph_vector_t *newv;

    if (order < 0) {
        IGRAPH_ERROR("Negative order in neighborhood size", IGRAPH_EINVAL);
    }

    if (mindist < 0 || mindist > order) {
        IGRAPH_ERROR("Minimum distance should be between zero and order",
                     IGRAPH_EINVAL);
    }

    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot calculate neighborhood size", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_CHECK(igraph_vector_ptr_resize(res, IGRAPH_VIT_SIZE(vit)));

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        long int node = IGRAPH_VIT_GET(vit);
        added[node] = i + 1;
        igraph_vector_clear(&tmp);
        if (mindist == 0) {
            IGRAPH_CHECK(igraph_vector_push_back(&tmp, node));
        }
        if (order > 0) {
            igraph_dqueue_push(&q, node);
            igraph_dqueue_push(&q, 0);
        }

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);
            long int n;
            igraph_neighbors(graph, &neis, (igraph_integer_t) actnode, mode);
            n = igraph_vector_size(&neis);

            if (actdist < order - 1) {
                /* we add them to the q */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        IGRAPH_CHECK(igraph_dqueue_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                        if (actdist + 1 >= mindist) {
                            IGRAPH_CHECK(igraph_vector_push_back(&tmp, nei));
                        }
                    }
                }
            } else {
                /* we just count them but don't add them to q */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        if (actdist + 1 >= mindist) {
                            IGRAPH_CHECK(igraph_vector_push_back(&tmp, nei));
                        }
                    }
                }
            }

        } /* while q not empty */

        newv = IGRAPH_CALLOC(1, igraph_vector_t);
        if (newv == 0) {
            IGRAPH_ERROR("Cannot calculate neighborhood", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, newv);
        IGRAPH_CHECK(igraph_vector_copy(newv, &tmp));
        VECTOR(*res)[i] = newv;
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&tmp);
    igraph_vector_destroy(&neis);
    igraph_vit_destroy(&vit);
    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(added);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_neighborhood_graphs
 * \brief Create graphs from the neighborhood(s) of some vertex/vertices.
 *
 * The neighborhood of a given order of a vertex includes all vertices
 * which are closer to the vertex than the order. Ie. order 0 is
 * always the vertex itself, order 1 is the vertex plus its immediate
 * neighbors, order 2 is order 1 plus the immediate neighbors of the
 * vertices in order 1, etc.
 *
 * 
 * This function finds every vertex in the neighborhood
 * of a given parameter vertex and creates the induced subgraph from these
 * vertices.
 *
 * 
 * The first version of this function was written by
 * Vincent Matossian, thanks Vincent.
 * \param graph The input graph.
 * \param res Pointer to a pointer vector, the result will be stored
 *   here, ie. \p res will contain pointers to \c igraph_t
 *   objects. It will be resized if needed but note that the
 *   objects in the pointer vector will not be freed.
 * \param vids The vertices for which the calculation is performed.
 * \param order Integer giving the order of the neighborhood.
 * \param mode Specifies how to use the direction of the edges if a
 *   directed graph is analyzed. For \c IGRAPH_OUT only the outgoing
 *   edges are followed, so all vertices reachable from the source
 *   vertex in at most \p order steps are counted. For \c IGRAPH_IN
 *   all vertices from which the source vertex is reachable in at most
 *   \p order steps are counted. \c IGRAPH_ALL ignores the direction
 *   of the edges. This argument is ignored for undirected graphs.
 * \param mindist The minimum distance to include a vertex in the counting.
 *   Vertices reachable with a path shorter than this value are excluded.
 *   If this is one, then the starting vertex is not counted. If this is
 *   two, then its neighbors are not counted either, etc.
 * \return Error code.
 *
 * \sa \ref igraph_neighborhood_size() for calculating the neighborhood
 * sizes only, \ref igraph_neighborhood() for calculating the
 * neighborhoods (but not creating graphs).
 *
 * Time complexity: O(n*(|V|+|E|)), where n is the number vertices for
 * which the calculation is performed, |V| and |E| are the number of
 * vertices and edges in the original input graph.
 */
int igraph_neighborhood_graphs(const igraph_t *graph, igraph_vector_ptr_t *res,
                               igraph_vs_t vids, igraph_integer_t order,
                               igraph_neimode_t mode,
                               igraph_integer_t mindist) {
    long int no_of_nodes = igraph_vcount(graph);
    igraph_dqueue_t q;
    igraph_vit_t vit;
    long int i, j;
    long int *added;
    igraph_vector_t neis;
    igraph_vector_t tmp;
    igraph_t *newg;

    if (order < 0) {
        IGRAPH_ERROR("Negative order in neighborhood size", IGRAPH_EINVAL);
    }

    if (mindist < 0 || mindist > order) {
        IGRAPH_ERROR("Minimum distance should be between zero and order",
                     IGRAPH_EINVAL);
    }

    added = IGRAPH_CALLOC(no_of_nodes, long int);
    if (added == 0) {
        IGRAPH_ERROR("Cannot calculate neighborhood size", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, added);
    IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
    IGRAPH_CHECK(igraph_vector_ptr_resize(res, IGRAPH_VIT_SIZE(vit)));

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        long int node = IGRAPH_VIT_GET(vit);
        added[node] = i + 1;
        igraph_vector_clear(&tmp);
        if (mindist == 0) {
            IGRAPH_CHECK(igraph_vector_push_back(&tmp, node));
        }
        if (order > 0) {
            igraph_dqueue_push(&q, node);
            igraph_dqueue_push(&q, 0);
        }

        while (!igraph_dqueue_empty(&q)) {
            long int actnode = (long int) igraph_dqueue_pop(&q);
            long int actdist = (long int) igraph_dqueue_pop(&q);
            long int n;
            igraph_neighbors(graph, &neis, (igraph_integer_t) actnode, mode);
            n = igraph_vector_size(&neis);

            if (actdist < order - 1) {
                /* we add them to the q */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        IGRAPH_CHECK(igraph_dqueue_push(&q, nei));
                        IGRAPH_CHECK(igraph_dqueue_push(&q, actdist + 1));
                        if (actdist + 1 >= mindist) {
                            IGRAPH_CHECK(igraph_vector_push_back(&tmp, nei));
                        }
                    }
                }
            } else {
                /* we just count them but don't add them to q */
                for (j = 0; j < n; j++) {
                    long int nei = (long int) VECTOR(neis)[j];
                    if (added[nei] != i + 1) {
                        added[nei] = i + 1;
                        if (actdist + 1 >= mindist) {
                            IGRAPH_CHECK(igraph_vector_push_back(&tmp, nei));
                        }
                    }
                }
            }

        } /* while q not empty */

        newg = IGRAPH_CALLOC(1, igraph_t);
        if (newg == 0) {
            IGRAPH_ERROR("Cannot create neighborhood graph", IGRAPH_ENOMEM);
        }
        IGRAPH_FINALLY(igraph_free, newg);
        if (igraph_vector_size(&tmp) < no_of_nodes) {
            IGRAPH_CHECK(igraph_induced_subgraph(graph, newg,
                                                 igraph_vss_vector(&tmp),
                                                 IGRAPH_SUBGRAPH_AUTO));
        } else {
            IGRAPH_CHECK(igraph_copy(newg, graph));
        }
        VECTOR(*res)[i] = newg;
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_vector_destroy(&tmp);
    igraph_vector_destroy(&neis);
    igraph_vit_destroy(&vit);
    igraph_dqueue_destroy(&q);
    IGRAPH_FREE(added);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/properties_internal.h0000644000175100001710000000207700000000000027104 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_PROPERTIES_INTERNAL_H
#define IGRAPH_PROPERTIES_INTERNAL_H

#include "igraph_adjlist.h"
#include "igraph_constants.h"
#include "igraph_iterators.h"
#include "igraph_types.h"

int igraph_i_trans4_al_simplify(igraph_adjlist_t *al,
                                const igraph_vector_int_t *rank);

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/spectral.c0000644000175100001710000003771000000000000024626 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"
#include "igraph_interface.h"

#include 

static int igraph_i_weighted_laplacian(const igraph_t *graph, igraph_matrix_t *res,
                                       igraph_sparsemat_t *sparseres,
                                       igraph_bool_t normalized,
                                       const igraph_vector_t *weights) {

    igraph_eit_t edgeit;
    int no_of_nodes = (int) igraph_vcount(graph);
    int no_of_edges = (int) igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    igraph_vector_t degree;
    long int i;

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERROR("Invalid edge weight vector length", IGRAPH_EINVAL);
    }

    if (res) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, no_of_nodes));
        igraph_matrix_null(res);
    }
    if (sparseres) {
        int nz = directed ? no_of_edges + no_of_nodes :
                 no_of_edges * 2 + no_of_nodes;
        igraph_sparsemat_resize(sparseres, no_of_nodes, no_of_nodes, nz);
    }

    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    if (directed) {

        if (!normalized) {

            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    if (res) {
                        MATRIX(*res, from, to) -= weight;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) from, (int)to,
                                                            -weight));
                    }
                    VECTOR(degree)[from] += weight;
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

            /* And the diagonal */
            for (i = 0; i < no_of_nodes; i++) {
                if (res) {
                    MATRIX(*res, i, i) = VECTOR(degree)[i];
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) i, (int) i,
                                                        VECTOR(degree)[i]));
                }
            }

        } else { /* normalized */

            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    VECTOR(degree)[from] += weight;
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

            for (i = 0; i < no_of_nodes; i++) {
                int t = VECTOR(degree)[i] > 0 ? 1 : 0;
                if (res) {
                    MATRIX(*res, i, i) = t;
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) i, (int) i, t));
                }
            }

            IGRAPH_EIT_RESET(edgeit);
            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    igraph_real_t t = weight / VECTOR(degree)[from];
                    if (res) {
                        MATRIX(*res, from, to) -= t;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) from, (int) to,
                                                            -t));
                    }
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

        }

    } else { /* undirected */

        if (!normalized) {

            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    if (res) {
                        MATRIX(*res, from, to) -= weight;
                        MATRIX(*res, to, from) -= weight;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) from, (int) to,
                                                            -weight));
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) to, (int) from,
                                                            -weight));
                    }
                    VECTOR(degree)[from] += weight;
                    VECTOR(degree)[to] += weight;
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

            /* And the diagonal */
            for (i = 0; i < no_of_nodes; i++) {
                if (res) {
                    MATRIX(*res, i, i) = VECTOR(degree)[i];
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) i, (int) i,
                                                        VECTOR(degree)[i]));
                }
            }

        } else { /* normalized */

            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    VECTOR(degree)[from] += weight;
                    VECTOR(degree)[to] += weight;
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

            for (i = 0; i < no_of_nodes; i++) {
                int t = VECTOR(degree)[i] > 0 ? 1 : 0;
                if (res) {
                    MATRIX(*res, i, i) = t;
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) i, (int) i, t));
                }
                VECTOR(degree)[i] = sqrt(VECTOR(degree)[i]);
            }

            IGRAPH_EIT_RESET(edgeit);
            while (!IGRAPH_EIT_END(edgeit)) {
                long int edge = IGRAPH_EIT_GET(edgeit);
                long int from = IGRAPH_FROM(graph, edge);
                long int to  = IGRAPH_TO  (graph, edge);
                igraph_real_t weight = VECTOR(*weights)[edge];
                if (from != to) {
                    double diff = weight / (VECTOR(degree)[from] * VECTOR(degree)[to]);
                    if (res) {
                        MATRIX(*res, from, to) -= diff;
                        MATRIX(*res, to, from) -= diff;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) from, (int) to,
                                                            -diff));
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, (int) to, (int) from,
                                                            -diff));
                    }
                }
                IGRAPH_EIT_NEXT(edgeit);
            }

        }

    }

    igraph_vector_destroy(°ree);
    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_laplacian
 * \brief Returns the Laplacian matrix of a graph
 *
 * 
 * The graph Laplacian matrix is similar to an adjacency matrix but
 * contains -1's instead of 1's and the vertex degrees are included in
 * the diagonal. So the result for edge i--j is -1 if i!=j and is equal
 * to the degree of vertex i if i==j. igraph_laplacian will work on a
 * directed graph; in this case, the diagonal will contain the out-degrees.
 * Loop edges will be ignored.
 *
 * 
 * The normalized version of the Laplacian matrix has 1 in the diagonal and
 * -1/sqrt(d[i]d[j]) if there is an edge from i to j.
 *
 * 
 * The first version of this function was written by Vincent Matossian.
 * \param graph Pointer to the graph to convert.
 * \param res Pointer to an initialized matrix object, the result is
 *        stored here. It will be resized if needed.
 *        If it is a null pointer, then it is ignored.
 *        At least one of \p res and \p sparseres must be a non-null pointer.
 * \param sparseres Pointer to an initialized sparse matrix object, the
 *        result is stored here, if it is not a null pointer.
 *        At least one of \p res and \p sparseres must be a non-null pointer.
 * \param normalized Whether to create a normalized Laplacian matrix.
 * \param weights An optional vector containing edge weights, to calculate
 *        the weighted Laplacian matrix. Set it to a null pointer to
 *        calculate the unweighted Laplacian.
 * \return Error code.
 *
 * Time complexity: O(|V||V|),
 * |V| is the
 * number of vertices in the graph.
 *
 * \example examples/simple/igraph_laplacian.c
 */

int igraph_laplacian(const igraph_t *graph, igraph_matrix_t *res,
                     igraph_sparsemat_t *sparseres,
                     igraph_bool_t normalized,
                     const igraph_vector_t *weights) {

    igraph_eit_t edgeit;
    int no_of_nodes = (int) igraph_vcount(graph);
    int no_of_edges = (int) igraph_ecount(graph);
    igraph_bool_t directed = igraph_is_directed(graph);
    int from, to;
    igraph_integer_t ffrom, fto;
    igraph_vector_t degree;
    int i;

    if (!res && !sparseres) {
        IGRAPH_ERROR("Laplacian: give at least one of `res' or `sparseres'",
                     IGRAPH_EINVAL);
    }

    if (weights) {
        return igraph_i_weighted_laplacian(graph, res, sparseres, normalized,
                                           weights);
    }

    if (res) {
        IGRAPH_CHECK(igraph_matrix_resize(res, no_of_nodes, no_of_nodes));
        igraph_matrix_null(res);
    }
    if (sparseres) {
        int nz = directed ? no_of_edges + no_of_nodes :
                 no_of_edges * 2 + no_of_nodes;
        IGRAPH_CHECK(igraph_sparsemat_resize(sparseres, no_of_nodes,
                                             no_of_nodes, nz));
    }
    IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
    IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);

    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
                               IGRAPH_OUT, IGRAPH_NO_LOOPS));

    if (directed) {
        if (!normalized) {
            for (i = 0; i < no_of_nodes; i++) {
                if (res) {
                    MATRIX(*res, i, i) = VECTOR(degree)[i];
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, i, i,
                                                        VECTOR(degree)[i]));
                }
            }
            while (!IGRAPH_EIT_END(edgeit)) {
                igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
                from = ffrom;
                to = fto;
                if (from != to) {
                    if (res) {
                        MATRIX(*res, from, to) -= 1;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, from, to, -1.0));
                    }
                }
                IGRAPH_EIT_NEXT(edgeit);
            }
        } else {
            for (i = 0; i < no_of_nodes; i++) {
                int t = VECTOR(degree)[i] > 0 ? 1 : 0;
                if (res) {
                    MATRIX(*res, i, i) = t;
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, i, i, t));
                }
                if (VECTOR(degree)[i] > 0) {
                    VECTOR(degree)[i] = 1.0 / VECTOR(degree)[i];
                }
            }

            while (!IGRAPH_EIT_END(edgeit)) {
                igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
                from = ffrom; to = fto;
                if (from != to) {
                    if (res) {
                        MATRIX(*res, from, to) -= VECTOR(degree)[from];
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, from, to,
                                                            -VECTOR(degree)[from]));
                    }
                }
                IGRAPH_EIT_NEXT(edgeit);
            }
        }

    } else {

        if (!normalized) {
            for (i = 0; i < no_of_nodes; i++) {
                if (res) {
                    MATRIX(*res, i, i) = VECTOR(degree)[i];
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, i, i,
                                                        VECTOR(degree)[i]));
                }
            }

            while (!IGRAPH_EIT_END(edgeit)) {
                igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
                from = ffrom;
                to = fto;

                if (from != to) {
                    if (res) {
                        MATRIX(*res, to, from) -= 1;
                        MATRIX(*res, from, to) -= 1;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, to, from, -1.0));
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, from, to, -1.0));
                    }
                }

                IGRAPH_EIT_NEXT(edgeit);
            }
        } else {
            for (i = 0; i < no_of_nodes; i++) {
                int t = VECTOR(degree)[i] > 0 ? 1 : 0;
                if (res) {
                    MATRIX(*res, i, i) = t;
                }
                if (sparseres) {
                    IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, i, i, t));
                }
                VECTOR(degree)[i] = sqrt(VECTOR(degree)[i]);
            }

            while (!IGRAPH_EIT_END(edgeit)) {
                igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &ffrom, &fto);
                from = ffrom; to = fto;
                if (from != to) {
                    double diff = 1.0 / (VECTOR(degree)[from] * VECTOR(degree)[to]);
                    if (res) {
                        MATRIX(*res, from, to) -= diff;
                        MATRIX(*res, to, from) -= diff;
                    }
                    if (sparseres) {
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, from, to, -diff));
                        IGRAPH_CHECK(igraph_sparsemat_entry(sparseres, to, from, -diff));
                    }
                }
                IGRAPH_EIT_NEXT(edgeit);
            }
        }

    }

    igraph_vector_destroy(°ree);
    igraph_eit_destroy(&edgeit);
    IGRAPH_FINALLY_CLEAN(2);
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/trees.c0000644000175100001710000002752200000000000024133 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2021 The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_structural.h"

#include "igraph_adjlist.h"
#include "igraph_constructors.h"
#include "igraph_dqueue.h"
#include "igraph_interface.h"
#include "igraph_stack.h"

/**
 * \function igraph_unfold_tree
 * Unfolding a graph into a tree, by possibly multiplicating its vertices.
 *
 * A graph is converted into a tree (or forest, if it is unconnected),
 * by performing a breadth-first search on it, and replicating
 * vertices that were found a second, third, etc. time.
 * \param graph The input graph, it can be either directed or
 *   undirected.
 * \param tree Pointer to an uninitialized graph object, the result is
 *   stored here.
 * \param mode For directed graphs; whether to follow paths along edge
 *    directions (\c IGRAPH_OUT), or the opposite (\c IGRAPH_IN), or
 *    ignore edge directions completely (\c IGRAPH_ALL). It is ignored
 *    for undirected graphs.
 * \param roots A numeric vector giving the root vertex, or vertices
 *   (if the graph is not connected), to start from.
 * \param vertex_index Pointer to an initialized vector, or a null
 *   pointer. If not a null pointer, then a mapping from the vertices
 *   in the new graph to the ones in the original is created here.
 * \return Error code.
 *
 * Time complexity: O(n+m), linear in the number vertices and edges.
 *
 */
int igraph_unfold_tree(const igraph_t *graph, igraph_t *tree,
                       igraph_neimode_t mode, const igraph_vector_t *roots,
                       igraph_vector_t *vertex_index) {

    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    long int no_of_roots = igraph_vector_size(roots);
    long int tree_vertex_count = no_of_nodes;

    igraph_vector_t edges;
    igraph_vector_bool_t seen_vertices;
    igraph_vector_bool_t seen_edges;

    igraph_dqueue_t Q;
    igraph_vector_t neis;

    long int i, n, r, v_ptr = no_of_nodes;

    /* TODO: handle not-connected graphs, multiple root vertices */

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    igraph_vector_reserve(&edges, no_of_edges * 2);
    IGRAPH_DQUEUE_INIT_FINALLY(&Q, 100);
    IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&seen_vertices, no_of_nodes);
    IGRAPH_VECTOR_BOOL_INIT_FINALLY(&seen_edges, no_of_edges);

    if (vertex_index) {
        IGRAPH_CHECK(igraph_vector_resize(vertex_index, no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*vertex_index)[i] = i;
        }
    }

    for (r = 0; r < no_of_roots; r++) {

        long int root = (long int) VECTOR(*roots)[r];
        VECTOR(seen_vertices)[root] = 1;
        igraph_dqueue_push(&Q, root);

        while (!igraph_dqueue_empty(&Q)) {
            long int actnode = (long int) igraph_dqueue_pop(&Q);

            IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t) actnode, mode));
            n = igraph_vector_size(&neis);
            for (i = 0; i < n; i++) {

                long int edge = (long int) VECTOR(neis)[i];
                long int from = IGRAPH_FROM(graph, edge);
                long int to = IGRAPH_TO(graph, edge);
                long int nei = IGRAPH_OTHER(graph, edge, actnode);

                if (! VECTOR(seen_edges)[edge]) {

                    VECTOR(seen_edges)[edge] = 1;

                    if (! VECTOR(seen_vertices)[nei]) {

                        igraph_vector_push_back(&edges, from);
                        igraph_vector_push_back(&edges, to);

                        VECTOR(seen_vertices)[nei] = 1;
                        IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));

                    } else {

                        tree_vertex_count++;
                        if (vertex_index) {
                            IGRAPH_CHECK(igraph_vector_push_back(vertex_index, nei));
                        }

                        if (from == nei) {
                            igraph_vector_push_back(&edges, v_ptr++);
                            igraph_vector_push_back(&edges, to);
                        } else {
                            igraph_vector_push_back(&edges, from);
                            igraph_vector_push_back(&edges, v_ptr++);
                        }
                    }
                }

            } /* for i
 *
 * In the directed case, a possible additional requirement is that all
 * edges are oriented away from a root (out-tree or arborescence) or all edges
 * are oriented towards a root (in-tree or anti-arborescence).
 * This test can be controlled using the \p mode parameter.
 * 
 *
 * By convention, the null graph (i.e. the graph with no vertices) is considered not to be a tree.
 *
 * \param graph The graph object to analyze.
 * \param res Pointer to a logical variable, the result will be stored
 *        here.
 * \param root If not \c NULL, the root node will be stored here. When \p mode
 *        is \c IGRAPH_ALL or the graph is undirected, any vertex can be the root
 *        and \p root is set to 0 (the first vertex). When \p mode is \c IGRAPH_OUT
 *        or \c IGRAPH_IN, the root is set to the vertex with zero in- or out-degree,
 *        respectively.
 * \param mode For a directed graph this specifies whether to test for an
 *        out-tree, an in-tree or ignore edge directions. The respective
 *        possible values are:
 *        \c IGRAPH_OUT, \c IGRAPH_IN, \c IGRAPH_ALL. This argument is
 *        ignored for undirected graphs.
 * \return Error code:
 *        \c IGRAPH_EINVAL: invalid mode argument.
 *
 * Time complexity: At most O(|V|+|E|), the
 * number of vertices plus the number of edges in the graph.
 *
 * \sa igraph_is_weakly_connected()
 *
 * \example examples/simple/igraph_tree.c
 */
int igraph_is_tree(const igraph_t *graph, igraph_bool_t *res, igraph_integer_t *root, igraph_neimode_t mode) {
    igraph_integer_t iroot = 0;
    igraph_integer_t visited_count;
    igraph_integer_t vcount, ecount;

    vcount = igraph_vcount(graph);
    ecount = igraph_ecount(graph);

    /* A tree must have precisely vcount-1 edges. */
    /* By convention, the zero-vertex graph will not be considered a tree. */
    if (ecount != vcount - 1) {
        *res = 0;
        return IGRAPH_SUCCESS;
    }

    /* The single-vertex graph is a tree, provided it has no edges (checked in the previous if (..)) */
    if (vcount == 1) {
        *res = 1;
        if (root) {
            *root = 0;
        }
        return IGRAPH_SUCCESS;
    }

    /* For higher vertex counts we cannot short-circuit due to the possibility
     * of loops or multi-edges even when the edge count is correct. */

    /* Ignore mode for undirected graphs. */
    if (! igraph_is_directed(graph)) {
        mode = IGRAPH_ALL;
    }

    /* The main algorithm:
     * We find a root and check that all other vertices are reachable from it.
     * We have already checked the number of edges, so with the additional
     * reachability condition we can verify if the graph is a tree.
     *
     * For directed graphs, the root is the node with no incoming/outgoing
     * connections, depending on 'mode'. For undirected, it is arbitrary, so
     * we choose 0.
     */

    *res = 1; /* assume success */

    switch (mode) {
    case IGRAPH_ALL:
        iroot = 0;
        break;

    case IGRAPH_IN:
    case IGRAPH_OUT: {
        igraph_vector_t degree;
        igraph_integer_t i;

        IGRAPH_CHECK(igraph_vector_init(°ree, 0));
        IGRAPH_FINALLY(igraph_vector_destroy, °ree);

        IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), mode == IGRAPH_IN ? IGRAPH_OUT : IGRAPH_IN, /* loops = */ 1));

        for (i = 0; i < vcount; ++i) {
            if (VECTOR(degree)[i] == 0) {
                break;
            }
            if (VECTOR(degree)[i] > 1) {
                /* In an out-tree, all vertices have in-degree 1, except for the root,
                 * which has in-degree 0. Thus, if we encounter a larger in-degree,
                 * the graph cannot be an out-tree.
                 * We could perform this check for all degrees, but that would not
                 * improve performance when the graph is indeed a tree, persumably
                 * the most common case. Thus we only check until finding the root.
                 */
                *res = 0;
                break;
            }
        }

        /* If no suitable root is found, the graph is not a tree. */
        if (*res && i == vcount) {
            *res = 0;
        } else {
            iroot = i;
        }

        igraph_vector_destroy(°ree);
        IGRAPH_FINALLY_CLEAN(1);
    }

    break;
    default:
        IGRAPH_ERROR("Invalid mode,", IGRAPH_EINVMODE);
    }

    /* if no suitable root was found, skip visiting vertices */
    if (*res) {
        IGRAPH_CHECK(igraph_i_is_tree_visitor(graph, iroot, mode, &visited_count));
        *res = visited_count == vcount;
    }

    if (root) {
        *root = iroot;
    }

    return IGRAPH_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/triangles.c0000644000175100001710000010202400000000000024770 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_transitivity.h"

#include "igraph_interface.h"
#include "igraph_adjlist.h"
#include "igraph_memory.h"
#include "igraph_motifs.h"
#include "igraph_structural.h"

#include "core/interruption.h"
#include "properties/properties_internal.h"

/**
 * \function igraph_transitivity_avglocal_undirected
 * \brief Average local transitivity (clustering coefficient).
 *
 * The transitivity measures the probability that two neighbors of a
 * vertex are connected. In case of the average local transitivity,
 * this probability is calculated for each vertex and then the average
 * is taken. Vertices with less than two neighbors require special treatment,
 * they will either be left out from the calculation or they will be considered
 * as having zero transitivity, depending on the \c mode argument.
 * Edge directions and edge multiplicities are ignored.
 *
 * 
 * Note that this measure is different from the global transitivity measure
 * (see \ref igraph_transitivity_undirected() ) as it simply takes the
 * average local transitivity across the whole network.
 *
 * 
 * Clustering coefficient is an alternative name for transitivity.
 *
 * 
 * References:
 *
 * 
 * D. J. Watts and S. Strogatz: Collective dynamics of small-world networks.
 * Nature 393(6684):440-442 (1998).
 *
 * \param graph The input graph. Edge directions and multiplicites are ignored.
 * \param res Pointer to a real variable, the result will be stored here.
 * \param mode Defines how to treat vertices with degree less than two.
 *    \c IGRAPH_TRANSITIVITY_NAN leaves them out from averaging,
 *    \c IGRAPH_TRANSITIVITY_ZERO includes them with zero transitivity.
 *    The result will be \c NaN if the mode is \c IGRAPH_TRANSITIVITY_NAN
 *    and there are no vertices with more than one neighbor.
 *
 * \return Error code.
 *
 * \sa \ref igraph_transitivity_undirected(), \ref
 * igraph_transitivity_local_undirected().
 *
 * Time complexity: O(|V|*d^2), |V| is the number of vertices in the
 * graph and d is the average degree.
 */

int igraph_transitivity_avglocal_undirected(const igraph_t *graph,
        igraph_real_t *res,
        igraph_transitivity_mode_t mode) {

    igraph_integer_t i, no_of_nodes = igraph_vcount(graph), nans = 0;
    igraph_real_t sum = 0.0;
    igraph_vector_t vec;

    if (no_of_nodes == 0) {
        if (mode == IGRAPH_TRANSITIVITY_ZERO) {
            *res = 0;
        } else {
            *res = IGRAPH_NAN;
        }
    } else {
        IGRAPH_VECTOR_INIT_FINALLY(&vec, no_of_nodes);

        IGRAPH_CHECK(igraph_transitivity_local_undirected(graph, &vec, igraph_vss_all(), mode));

        for (i = 0, nans = 0; i < no_of_nodes; i++) {
            if (!igraph_is_nan(VECTOR(vec)[i])) {
                sum += VECTOR(vec)[i];
            } else {
                nans++;
            }
        }

        igraph_vector_destroy(&vec);
        IGRAPH_FINALLY_CLEAN(1);

        *res = sum / (no_of_nodes - nans);
    }

    return IGRAPH_SUCCESS;
}

int igraph_transitivity_local_undirected1(const igraph_t *graph,
        igraph_vector_t *res,
        const igraph_vs_t vids,
        igraph_transitivity_mode_t mode) {

#define TRANSIT
#include "properties/triangles_template1.h"
#undef TRANSIT

    return IGRAPH_SUCCESS;
}

int igraph_transitivity_local_undirected2(const igraph_t *graph,
        igraph_vector_t *res,
        const igraph_vs_t vids,
        igraph_transitivity_mode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vit_t vit;
    long int nodes_to_calc, affected_nodes;
    long int maxdegree = 0;
    long int i, j, k, nn;
    igraph_lazy_adjlist_t adjlist;
    igraph_vector_t indexv, avids, rank, order, triangles, degree;
    long int *neis;

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);

    IGRAPH_VECTOR_INIT_FINALLY(&indexv, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(&avids, 0);
    IGRAPH_CHECK(igraph_vector_reserve(&avids, nodes_to_calc));
    k = 0;
    for (i = 0; i < nodes_to_calc; IGRAPH_VIT_NEXT(vit), i++) {
        long int v = IGRAPH_VIT_GET(vit);
        igraph_vector_int_t *neis2;
        long int neilen;
        if (VECTOR(indexv)[v] == 0) {
            VECTOR(indexv)[v] = k + 1; k++;
            IGRAPH_CHECK(igraph_vector_push_back(&avids, v));
        }

        neis2 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) v);
        neilen = igraph_vector_int_size(neis2);
        for (j = 0; j < neilen; j++) {
            long int nei = (long int) VECTOR(*neis2)[j];
            if (VECTOR(indexv)[nei] == 0) {
                VECTOR(indexv)[nei] = k + 1; k++;
                IGRAPH_CHECK(igraph_vector_push_back(&avids, nei));
            }
        }
    }

    /* Degree, ordering, ranking */
    affected_nodes = igraph_vector_size(&avids);
    IGRAPH_VECTOR_INIT_FINALLY(&order, 0);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, affected_nodes);
    for (i = 0; i < affected_nodes; i++) {
        long int v = (long int) VECTOR(avids)[i];
        igraph_vector_int_t *neis2;
        long int deg;
        neis2 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) v);
        VECTOR(degree)[i] = deg = igraph_vector_int_size(neis2);
        if (deg > maxdegree) {
            maxdegree = deg;
        }
    }
    igraph_vector_order1(°ree, &order, maxdegree + 1);
    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_VECTOR_INIT_FINALLY(&rank, affected_nodes);
    for (i = 0; i < affected_nodes; i++) {
        VECTOR(rank)[ (long int) VECTOR(order)[i] ] = affected_nodes - i - 1;
    }

    neis = IGRAPH_CALLOC(no_of_nodes, long int);
    if (neis == 0) {
        IGRAPH_ERROR("Insufficient memory for local transitivity calculation.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, neis);

    IGRAPH_VECTOR_INIT_FINALLY(&triangles, affected_nodes);
    for (nn = affected_nodes - 1; nn >= 0; nn--) {
        long int node = (long int) VECTOR(avids) [ (long int) VECTOR(order)[nn] ];
        igraph_vector_int_t *neis1, *neis2;
        long int neilen1, neilen2;
        long int nodeindex = (long int) VECTOR(indexv)[node];
        long int noderank = (long int) VECTOR(rank) [nodeindex - 1];

        /*     fprintf(stderr, "node %li (indexv %li, rank %li)\n", node, */
        /*      (long int)VECTOR(indexv)[node]-1, noderank); */

        IGRAPH_ALLOW_INTERRUPTION();

        neis1 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) node);
        neilen1 = igraph_vector_int_size(neis1);
        for (i = 0; i < neilen1; i++) {
            long int nei = (long int) VECTOR(*neis1)[i];
            neis[nei] = node + 1;
        }
        for (i = 0; i < neilen1; i++) {
            long int nei = (long int) VECTOR(*neis1)[i];
            long int neiindex = (long int) VECTOR(indexv)[nei];
            long int neirank = (long int) VECTOR(rank)[neiindex - 1];

            /*       fprintf(stderr, "  nei %li (indexv %li, rank %li)\n", nei, */
            /*        neiindex, neirank); */
            if (neirank > noderank) {
                neis2 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) nei);
                neilen2 = igraph_vector_int_size(neis2);
                for (j = 0; j < neilen2; j++) {
                    long int nei2 = (long int) VECTOR(*neis2)[j];
                    long int nei2index = (long int) VECTOR(indexv)[nei2];
                    long int nei2rank = (long int) VECTOR(rank)[nei2index - 1];
                    /*    fprintf(stderr, "    triple %li %li %li\n", node, nei, nei2); */
                    if (nei2rank < neirank) {
                        continue;
                    }
                    if (neis[nei2] == node + 1) {
                        /*      fprintf(stderr, "    triangle\n"); */
                        VECTOR(triangles) [ nei2index - 1 ] += 1;
                        VECTOR(triangles) [ neiindex - 1 ] += 1;
                        VECTOR(triangles) [ nodeindex - 1 ] += 1;
                    }
                }
            }
        }
    }

    /* Ok, for all affected vertices the number of triangles were counted */

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
    IGRAPH_VIT_RESET(vit);
    for (i = 0; i < nodes_to_calc; i++, IGRAPH_VIT_NEXT(vit)) {
        long int node = IGRAPH_VIT_GET(vit);
        long int idx = (long int) VECTOR(indexv)[node] - 1;
        igraph_vector_int_t *neis2 =
            igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) node);
        long int deg = igraph_vector_int_size(neis2);
        if (mode == IGRAPH_TRANSITIVITY_ZERO && deg < 2) {
            VECTOR(*res)[i] = 0.0;
        } else {
            VECTOR(*res)[i] = VECTOR(triangles)[idx] / deg / (deg - 1) * 2.0;
        }
        /*     fprintf(stderr, "%f %f\n", VECTOR(triangles)[idx], triples); */
    }

    igraph_vector_destroy(&triangles);
    igraph_free(neis);
    igraph_vector_destroy(&rank);
    igraph_vector_destroy(&order);
    igraph_vector_destroy(&avids);
    igraph_vector_destroy(&indexv);
    igraph_lazy_adjlist_destroy(&adjlist);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(8);

    return 0;
}

/* We don't use this, it is theoretically good, but practically not.
 */

/* int igraph_transitivity_local_undirected3(const igraph_t *graph, */
/*                    igraph_vector_t *res, */
/*                    const igraph_vs_t vids) { */

/*   igraph_vit_t vit; */
/*   long int nodes_to_calc; */
/*   igraph_lazy_adjlist_t adjlist; */
/*   long int i, j; */

/*   IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit)); */
/*   IGRAPH_FINALLY(igraph_vit_destroy, &vit); */
/*   nodes_to_calc=IGRAPH_VIT_SIZE(vit); */

/*   IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, IGRAPH_ALL, */
/*                    IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE)); */
/*   IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist); */

/*   IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc)); */
/*   for (i=0, IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit);  */
/*        i++, IGRAPH_VIT_NEXT(vit)) { */
/*     long int node=IGRAPH_VIT_GET(vit); */
/*     igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist, node); */
/*     long int n1=igraph_vector_size(neis); */
/*     igraph_real_t triangles=0; */
/*     igraph_real_t triples=(double)n1*(n1-1); */
/*     IGRAPH_ALLOW_INTERRUPTION(); */
/*     for (j=0; j nei2) { */
/*    l2++; */
/*  } else { */
/*    triangles+=1; */
/*    l1++; l2++; */
/*  } */
/*       } */
/*     } */
/*     /\* We're done with 'node' *\/ */
/*     VECTOR(*res)[i] = triangles / triples;   */
/*   } */

/*   igraph_lazy_adjlist_destroy(&adjlist); */
/*   igraph_vit_destroy(&vit); */
/*   IGRAPH_FINALLY_CLEAN(2); */

/*   return 0; */
/* } */

/* This removes loop, multiple edges and edges that point
     "backwards" according to the rank vector. */
/* Note: Also used in scan.c */
int igraph_i_trans4_al_simplify(igraph_adjlist_t *al,
                                const igraph_vector_int_t *rank) {
    long int i;
    long int n = al->length;
    igraph_vector_int_t mark;
    igraph_vector_int_init(&mark, n);
    IGRAPH_FINALLY(igraph_vector_int_destroy, &mark);
    for (i = 0; i < n; i++) {
        igraph_vector_int_t *v = &al->adjs[i];
        int j, l = igraph_vector_int_size(v);
        int irank = VECTOR(*rank)[i];
        VECTOR(mark)[i] = i + 1;
        for (j = 0; j < l; /* nothing */) {
            long int e = (long int) VECTOR(*v)[j];
            if (VECTOR(*rank)[e] > irank && VECTOR(mark)[e] != i + 1) {
                VECTOR(mark)[e] = i + 1;
                j++;
            } else {
                VECTOR(*v)[j] = igraph_vector_int_tail(v);
                igraph_vector_int_pop_back(v);
                l--;
            }
        }
    }

    igraph_vector_int_destroy(&mark);
    IGRAPH_FINALLY_CLEAN(1);
    return 0;

}

int igraph_transitivity_local_undirected4(const igraph_t *graph,
        igraph_vector_t *res,
        igraph_transitivity_mode_t mode) {

#define TRANSIT 1
#include "properties/triangles_template.h"
#undef TRANSIT

    return 0;
}

/**
 * \function igraph_transitivity_local_undirected
 * \brief Calculates the local transitivity (clustering coefficient) of a graph.
 *
 * The transitivity measures the probability that two neighbors of a
 * vertex are connected. In case of the local transitivity, this
 * probability is calculated separately for each vertex.
 *
 * 
 * Note that this measure is different from the global transitivity measure
 * (see \ref igraph_transitivity_undirected() ) as it calculates a transitivity
 * value for each vertex individually.
 *
 * 
 * Clustering coefficient is an alternative name for transitivity.
 *
 * 
 * References:
 *
 * 
 * D. J. Watts and S. Strogatz: Collective dynamics of small-world networks.
 * Nature 393(6684):440-442 (1998).
 *
 * \param graph The input graph. Edge directions and multiplicities are ignored.
 * \param res Pointer to an initialized vector, the result will be
 *   stored here. It will be resized as needed.
 * \param vids Vertex set, the vertices for which the local
 *   transitivity will be calculated.
 * \param mode Defines how to treat vertices with degree less than two.
 *    \c IGRAPH_TRANSITIVITY_NAN returns \c NaN for these vertices,
 *    \c IGRAPH_TRANSITIVITY_ZERO returns zero.
 * \return Error code.
 *
 * \sa \ref igraph_transitivity_undirected(), \ref
 * igraph_transitivity_avglocal_undirected().
 *
 * Time complexity: O(n*d^2), n is the number of vertices for which
 * the transitivity is calculated, d is the average vertex degree.
 */

int igraph_transitivity_local_undirected(const igraph_t *graph,
        igraph_vector_t *res,
        const igraph_vs_t vids,
        igraph_transitivity_mode_t mode) {

    if (igraph_vs_is_all(&vids)) {
        return igraph_transitivity_local_undirected4(graph, res, mode);
    } else {
        igraph_vit_t vit;
        long int size;
        IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
        IGRAPH_FINALLY(igraph_vit_destroy, &vit);
        size = IGRAPH_VIT_SIZE(vit);
        igraph_vit_destroy(&vit);
        IGRAPH_FINALLY_CLEAN(1);
        if (size < 100) {
            return igraph_transitivity_local_undirected1(graph, res, vids, mode);
        } else {
            return igraph_transitivity_local_undirected2(graph, res, vids, mode);
        }
    }
}

static int igraph_adjacent_triangles1(const igraph_t *graph,
                                      igraph_vector_t *res,
                                      const igraph_vs_t vids) {
# include "properties/triangles_template1.h"
    return 0;
}

static int igraph_adjacent_triangles4(const igraph_t *graph,
                                      igraph_vector_t *res) {
# include "properties/triangles_template.h"
    return 0;
}

/**
 * \function igraph_adjacent_triangles
 * \brief Count the number of triangles a vertex is part of.
 *
 * \param graph The input graph. Edge directions and multiplicities are ignored.
 * \param res Initiliazed vector, the results are stored here.
 * \param vids The vertices to perform the calculation for.
 * \return Error mode.
 *
 * \sa \ref igraph_list_triangles() to list them.
 *
 * Time complexity: O(d^2 n), d is the average vertex degree of the
 * queried vertices, n is their number.
 */

int igraph_adjacent_triangles(const igraph_t *graph,
                              igraph_vector_t *res,
                              const igraph_vs_t vids) {
    if (igraph_vs_is_all(&vids)) {
        return igraph_adjacent_triangles4(graph, res);
    } else {
        return igraph_adjacent_triangles1(graph, res, vids);
    }
}

/**
 * \function igraph_list_triangles
 * \brief Find all triangles in a graph.
 *
 * \param graph The input graph, edge directions are ignored.
 *        Multiple edges are ignored.
 * \param res Pointer to an initialized integer vector, the result
 *        is stored here, in a long list of triples of vertex ids.
 *        Each triple is a triangle in the graph. Each triangle is
 *        listed exactly once.
 * \return Error code.
 *
 * \sa \ref igraph_transitivity_undirected() to count the triangles,
 * \ref igraph_adjacent_triangles() to count the triangles a vertex
 * participates in.
 *
 * Time complexity: O(d^2 n), d is the average degree, n is the number
 * of vertices.
 */

int igraph_list_triangles(const igraph_t *graph,
                          igraph_vector_int_t *res) {
# define TRIANGLES
# include "properties/triangles_template.h"
# undef TRIANGLES
    return IGRAPH_SUCCESS;
}

/**
 * \ingroup structural
 * \function igraph_transitivity_undirected
 * \brief Calculates the transitivity (clustering coefficient) of a graph.
 *
 * 
 * The transitivity measures the probability that two neighbors of a
 * vertex are connected. More precisely, this is the ratio of the
 * triangles and connected triples in the graph, the result is a
 * single real number. Directed graphs are considered as undirected ones
 * and multi-edges are ignored.
 *
 * 
 * Note that this measure is different from the local transitivity measure
 * (see \ref igraph_transitivity_local_undirected() ) as it calculates a single
 * value for the whole graph.
 *
 * 
 * Clustering coefficient is an alternative name for transitivity.
 *
 * 
 * References:
 *
 * 
 * S. Wasserman and K. Faust: Social Network Analysis: Methods and
 * Applications. Cambridge: Cambridge University Press, 1994.
 *
 * \param graph The graph object. Edge directions and multiplicites are ignored.
 * \param res Pointer to a real variable, the result will be stored here.
 * \param mode Defines how to treat graphs with no connected triples.
 *   \c IGRAPH_TRANSITIVITY_NAN returns \c NaN in this case,
 *   \c IGRAPH_TRANSITIVITY_ZERO returns zero.
 * \return Error code:
 *         \c IGRAPH_ENOMEM: not enough memory for
 *         temporary data.
 *
 * \sa \ref igraph_transitivity_local_undirected(),
 * \ref igraph_transitivity_avglocal_undirected().
 *
 * Time complexity: O(|V|*d^2), |V| is the number of vertices in
 * the graph, d is the average node degree.
 *
 * \example examples/simple/igraph_transitivity.c
 */

int igraph_transitivity_undirected(const igraph_t *graph,
                                   igraph_real_t *res,
                                   igraph_transitivity_mode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_real_t triples = 0, triangles = 0;
    long int node, nn;
    long int maxdegree;
    long int *neis;
    igraph_vector_t order;
    igraph_vector_t rank;
    igraph_vector_t degree;

    igraph_adjlist_t allneis;
    igraph_vector_int_t *neis1, *neis2;
    long int i, j, neilen1, neilen2;

    if (no_of_nodes == 0) {
        *res = mode == IGRAPH_TRANSITIVITY_ZERO ? 0.0 : IGRAPH_NAN;
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL,
                               IGRAPH_LOOPS));
    maxdegree = (long int) igraph_vector_max(°ree) + 1;
    IGRAPH_CHECK(igraph_vector_order1(°ree, &order, maxdegree));

    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_VECTOR_INIT_FINALLY(&rank, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(rank)[ (long int) VECTOR(order)[i] ] = no_of_nodes - i - 1;
    }

    IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
    IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

    neis = IGRAPH_CALLOC(no_of_nodes, long int);
    if (! neis) {
        IGRAPH_ERROR("Insufficient memory for undirected global transitivity.", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, neis);

    for (nn = no_of_nodes - 1; nn >= 0; nn--) {
        node = (long int) VECTOR(order)[nn];

        IGRAPH_ALLOW_INTERRUPTION();

        neis1 = igraph_adjlist_get(&allneis, node);
        neilen1 = igraph_vector_int_size(neis1);
        triples += (double)neilen1 * (neilen1 - 1);
        /* Mark the neighbors of 'node' */
        for (i = 0; i < neilen1; i++) {
            long int nei = (long int) VECTOR(*neis1)[i];
            neis[nei] = node + 1;
        }
        for (i = 0; i < neilen1; i++) {
            long int nei = (long int) VECTOR(*neis1)[i];
            /* If 'nei' is not ready yet */
            if (VECTOR(rank)[nei] > VECTOR(rank)[node]) {
                neis2 = igraph_adjlist_get(&allneis, nei);
                neilen2 = igraph_vector_int_size(neis2);
                for (j = 0; j < neilen2; j++) {
                    long int nei2 = (long int) VECTOR(*neis2)[j];
                    if (neis[nei2] == node + 1) {
                        triangles += 1.0;
                    }
                }
            }
        }
    }

    IGRAPH_FREE(neis);
    igraph_adjlist_destroy(&allneis);
    igraph_vector_destroy(&rank);
    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(4);

    if (triples == 0 && mode == IGRAPH_TRANSITIVITY_ZERO) {
        *res = 0;
    } else {
        *res = triangles / triples * 2.0;
    }

    return 0;
}

static int igraph_i_transitivity_barrat1(const igraph_t *graph,
                                         igraph_vector_t *res,
                                         const igraph_vs_t vids,
                                         const igraph_vector_t *weights,
                                         igraph_transitivity_mode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vit_t vit;
    long int nodes_to_calc;
    igraph_vector_int_t *adj1, *adj2;
    igraph_vector_long_t neis;
    igraph_vector_t actw;
    igraph_lazy_inclist_t incident;
    long int i;
    igraph_vector_t strength;

    /* Precondition: weight vector is not null, its length equals the number of
     * edges, and the graph has at least one vertex. The graph must not have
     * multi-edges. These must be ensured by the caller.
     */

    IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
    IGRAPH_FINALLY(igraph_vit_destroy, &vit);
    nodes_to_calc = IGRAPH_VIT_SIZE(vit);

    IGRAPH_CHECK(igraph_vector_long_init(&neis, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &neis);

    IGRAPH_VECTOR_INIT_FINALLY(&actw, no_of_nodes);

    IGRAPH_VECTOR_INIT_FINALLY(&strength, 0);
    IGRAPH_CHECK(igraph_strength(graph, &strength, igraph_vss_all(), IGRAPH_ALL,
                                 IGRAPH_LOOPS, weights));

    IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &incident, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &incident);

    IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));

    for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
        long int node = IGRAPH_VIT_GET(vit);
        long int adjlen1, adjlen2, j, k;
        igraph_real_t triples, triangles;

        IGRAPH_ALLOW_INTERRUPTION();

        adj1 = igraph_lazy_inclist_get(&incident, (igraph_integer_t) node);
        adjlen1 = igraph_vector_int_size(adj1);
        /* Mark the neighbors of the node */
        for (j = 0; j < adjlen1; j++) {
            long int edge = (long int) VECTOR(*adj1)[j];
            long int nei = IGRAPH_OTHER(graph, edge, node);
            VECTOR(neis)[nei] = i + 1;
            VECTOR(actw)[nei] = VECTOR(*weights)[edge];
        }
        triples = VECTOR(strength)[node] * (adjlen1 - 1);
        triangles = 0.0;

        for (j = 0; j < adjlen1; j++) {
            long int edge1 = (long int) VECTOR(*adj1)[j];
            igraph_real_t weight1 = VECTOR(*weights)[edge1];
            long int v = IGRAPH_OTHER(graph, edge1, node);
            adj2 = igraph_lazy_inclist_get(&incident, (igraph_integer_t) v);
            adjlen2 = igraph_vector_int_size(adj2);
            for (k = 0; k < adjlen2; k++) {
                long int edge2 = (long int) VECTOR(*adj2)[k];
                long int v2 = IGRAPH_OTHER(graph, edge2, v);
                if (VECTOR(neis)[v2] == i + 1) {
                    triangles += (VECTOR(actw)[v2] + weight1) / 2.0;
                }
            }
        }
        if (mode == IGRAPH_TRANSITIVITY_ZERO && triples == 0) {
            VECTOR(*res)[i] = 0.0;
        } else {
            VECTOR(*res)[i] = triangles / triples;
        }
    }

    igraph_lazy_inclist_destroy(&incident);
    igraph_vector_destroy(&strength);
    igraph_vector_destroy(&actw);
    igraph_vector_long_destroy(&neis);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(5);

    return IGRAPH_SUCCESS;
}

static int igraph_i_transitivity_barrat4(const igraph_t *graph,
                                         igraph_vector_t *res,
                                         const igraph_vs_t vids,
                                         const igraph_vector_t *weights,
                                         igraph_transitivity_mode_t mode) {

    long int no_of_nodes = igraph_vcount(graph);
    igraph_vector_t order, degree, rank;
    long int maxdegree;
    igraph_inclist_t incident;
    igraph_vector_long_t neis;
    igraph_vector_int_t *adj1, *adj2;
    igraph_vector_t actw;
    long int i, nn;

    /* Precondition: weight vector is not null, its length equals the number of
     * edges, and the graph has at least one vertex. The graph must not have
     * multi-edges. These must be ensured by the caller.
     */

    IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
    IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

    IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL,
                               IGRAPH_LOOPS));
    maxdegree = (long int) igraph_vector_max(°ree) + 1;
    IGRAPH_CHECK(igraph_vector_order1(°ree, &order, maxdegree));

    IGRAPH_CHECK(igraph_strength(graph, °ree, igraph_vss_all(), IGRAPH_ALL,
                                 IGRAPH_LOOPS, weights));

    IGRAPH_VECTOR_INIT_FINALLY(&rank, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(rank)[ (long int)VECTOR(order)[i] ] = no_of_nodes - i - 1;
    }

    IGRAPH_CHECK(igraph_inclist_init(graph, &incident, IGRAPH_ALL, IGRAPH_LOOPS_TWICE));
    IGRAPH_FINALLY(igraph_inclist_destroy, &incident);

    IGRAPH_CHECK(igraph_vector_long_init(&neis, no_of_nodes));
    IGRAPH_FINALLY(igraph_vector_long_destroy, &neis);

    IGRAPH_VECTOR_INIT_FINALLY(&actw, no_of_nodes);

    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);

    for (nn = no_of_nodes - 1; nn >= 0; nn--) {
        long int adjlen1, adjlen2;
        igraph_real_t triples;
        long int node = (long int) VECTOR(order)[nn];

        IGRAPH_ALLOW_INTERRUPTION();

        adj1 = igraph_inclist_get(&incident, node);
        adjlen1 = igraph_vector_int_size(adj1);
        triples = VECTOR(degree)[node] * (adjlen1 - 1) / 2.0;
        /* Mark the neighbors of the node */
        for (i = 0; i < adjlen1; i++) {
            long int edge = (long int) VECTOR(*adj1)[i];
            long int nei = IGRAPH_OTHER(graph, edge, node);
            VECTOR(neis)[nei] = node + 1;
            VECTOR(actw)[nei] = VECTOR(*weights)[edge];
        }

        for (i = 0; i < adjlen1; i++) {
            long int edge1 = (long int) VECTOR(*adj1)[i];
            igraph_real_t weight1 = VECTOR(*weights)[edge1];
            long int nei = IGRAPH_OTHER(graph, edge1, node);
            long int j;
            if (VECTOR(rank)[nei] > VECTOR(rank)[node]) {
                adj2 = igraph_inclist_get(&incident, nei);
                adjlen2 = igraph_vector_int_size(adj2);
                for (j = 0; j < adjlen2; j++) {
                    long int edge2 = (long int) VECTOR(*adj2)[j];
                    igraph_real_t weight2 = VECTOR(*weights)[edge2];
                    long int nei2 = IGRAPH_OTHER(graph, edge2, nei);
                    if (VECTOR(rank)[nei2] < VECTOR(rank)[nei]) {
                        continue;
                    }
                    if (VECTOR(neis)[nei2] == node + 1) {
                        VECTOR(*res)[nei2] += (VECTOR(actw)[nei2] + weight2) / 2.0;
                        VECTOR(*res)[nei] += (weight1 + weight2) / 2.0;
                        VECTOR(*res)[node] += (VECTOR(actw)[nei2] + weight1) / 2.0;
                    }
                }
            }
        }

        if (mode == IGRAPH_TRANSITIVITY_ZERO && triples == 0) {
            VECTOR(*res)[node] = 0.0;
        } else {
            VECTOR(*res)[node] /= triples;
        }
    }

    igraph_vector_destroy(&actw);
    igraph_vector_long_destroy(&neis);
    igraph_inclist_destroy(&incident);
    igraph_vector_destroy(&rank);
    igraph_vector_destroy(°ree);
    igraph_vector_destroy(&order);
    IGRAPH_FINALLY_CLEAN(6);

    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_transitivity_barrat
 * Weighted transitivity, as defined by A. Barrat.
 *
 * This is a local transitivity, i.e. a vertex-level index. For a
 * given vertex \c i, from all triangles in which it participates we
 * consider the weight of the edges incident on \c i. The transitivity
 * is the sum of these weights divided by twice the strength of the
 * vertex (see \ref igraph_strength()) and the degree of the vertex
 * minus one. See   Alain Barrat, Marc Barthelemy, Romualdo
 * Pastor-Satorras, Alessandro Vespignani: The architecture of complex
 * weighted networks, Proc. Natl. Acad. Sci. USA 101, 3747 (2004) at
 * http://arxiv.org/abs/cond-mat/0311416 for the exact formula.
 *
 * \param graph The input graph. Edge directions are ignored for
 *   directed graphs. Note that the function does \em not work for
 *   non-simple graphs.
 * \param res Pointer to an initialized vector, the result will be
 *   stored here. It will be resized as needed.
 * \param vids The vertices for which the calculation is performed.
 * \param weights Edge weights. If this is a null pointer, then a
 *   warning is given and \ref igraph_transitivity_local_undirected()
 *   is called.
 * \param mode Defines how to treat vertices with zero strength.
 *   \c IGRAPH_TRANSITIVITY_NAN says that the transitivity of these
 *   vertices is \c NaN, \c IGRAPH_TRANSITIVITY_ZERO says it is zero.
 *
 * \return Error code.
 *
 * Time complexity: O(|V|*d^2), |V| is the number of vertices in
 * the graph, d is the average node degree.
 *
 * \sa \ref igraph_transitivity_undirected(), \ref
 * igraph_transitivity_local_undirected() and \ref
 * igraph_transitivity_avglocal_undirected() for other kinds of
 * (non-weighted) transitivity.
 */

int igraph_transitivity_barrat(const igraph_t *graph,
                               igraph_vector_t *res,
                               const igraph_vs_t vids,
                               const igraph_vector_t *weights,
                               igraph_transitivity_mode_t mode) {
    long int no_of_nodes = igraph_vcount(graph);
    long int no_of_edges = igraph_ecount(graph);
    igraph_bool_t has_multiple;

    /* Handle fallback to unweighted version and common cases */
    if (!weights) {
        if (no_of_edges != 0) {
            IGRAPH_WARNING("No weights given for Barrat's transitivity, unweighted version is used.");
        }
        return igraph_transitivity_local_undirected(graph, res, vids, mode);
    }

    if (igraph_vector_size(weights) != no_of_edges) {
        IGRAPH_ERRORF("Edge weight vector length (%ld) not equal to "
                      "number of edges (%ld).", IGRAPH_EINVAL,
                      igraph_vector_size(weights), no_of_edges);
    }

    if (no_of_nodes == 0) {
        igraph_vector_clear(res);
        return IGRAPH_SUCCESS;
    }

    IGRAPH_CHECK(igraph_has_multiple(graph, &has_multiple));
    if (has_multiple) {
        IGRAPH_ERROR(
            "Barrat's weighted transitivity measure works only if the graph "
            "has no multiple edges.", IGRAPH_EINVAL
        );
    }

    /* Preconditions validated, now we can call the real implementation */

    if (igraph_vs_is_all(&vids)) {
        return igraph_i_transitivity_barrat4(graph, res, vids, weights, mode);
    } else {
        return igraph_i_transitivity_barrat1(graph, res, vids, weights, mode);
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/triangles_template.h0000644000175100001710000001003500000000000026670 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#ifdef TRANSIT
#define TRANSIT_TRIEDGES
#endif

long int no_of_nodes = igraph_vcount(graph);
long int node, i, j, nn;
igraph_adjlist_t allneis;
igraph_vector_int_t *neis1, *neis2;
long int neilen1, neilen2;
long int *neis;
long int maxdegree;

#ifdef TRANSIT_TRIEDGES
long int deg1;
#endif

igraph_vector_int_t order;
igraph_vector_int_t rank;
igraph_vector_t degree;

if (no_of_nodes == 0) {
#ifndef TRIANGLES
    igraph_vector_clear(res);
#else
    igraph_vector_int_clear(res);
#endif
    return IGRAPH_SUCCESS;
}

igraph_vector_int_init(&order, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &order);
IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);

IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);

for (i = 0; i < no_of_nodes; i++) {
    VECTOR(degree)[i] = igraph_vector_int_size(igraph_adjlist_get(&allneis, i));
}

maxdegree = (long int) igraph_vector_max(°ree) + 1;
igraph_vector_order1_int(°ree, &order, maxdegree);
igraph_vector_int_init(&rank, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &rank);
for (i = 0; i < no_of_nodes; i++) {
    VECTOR(rank)[ VECTOR(order)[i] ] = no_of_nodes - i - 1;
}

IGRAPH_CHECK(igraph_i_trans4_al_simplify(&allneis, &rank));

neis = IGRAPH_CALLOC(no_of_nodes, long int);
if (neis == 0) {
    IGRAPH_ERROR("undirected local transitivity failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, neis);

#ifndef TRIANGLES
    IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
    igraph_vector_null(res);
#else
    igraph_vector_int_clear(res);
#endif

for (nn = no_of_nodes - 1; nn >= 0; nn--) {
    node = VECTOR(order)[nn];

    IGRAPH_ALLOW_INTERRUPTION();

    neis1 = igraph_adjlist_get(&allneis, node);
    neilen1 = igraph_vector_int_size(neis1);

#ifdef TRANSIT_TRIEDGES
    deg1 = (long int) VECTOR(degree)[node];
#endif

    /* Mark the neighbors of the node */
    for (i = 0; i < neilen1; i++) {
        neis[ (long int) VECTOR(*neis1)[i] ] = node + 1;
    }

    for (i = 0; i < neilen1; i++) {
        long int nei = (long int) VECTOR(*neis1)[i];
        neis2 = igraph_adjlist_get(&allneis, nei);
        neilen2 = igraph_vector_int_size(neis2);
        for (j = 0; j < neilen2; j++) {
            long int nei2 = (long int) VECTOR(*neis2)[j];
            if (neis[nei2] == node + 1) {
#ifndef TRIANGLES
                VECTOR(*res)[nei2] += 1;
                VECTOR(*res)[nei] += 1;
                VECTOR(*res)[node] += 1;
#else
                IGRAPH_CHECK(igraph_vector_int_push_back(res, node));
                IGRAPH_CHECK(igraph_vector_int_push_back(res, nei));
                IGRAPH_CHECK(igraph_vector_int_push_back(res, nei2));
#endif
            }
        }
    }

#ifdef TRANSIT
    if (mode == IGRAPH_TRANSITIVITY_ZERO && deg1 < 2) {
        VECTOR(*res)[node] = 0.0;
    } else {
        VECTOR(*res)[node] = VECTOR(*res)[node] / deg1 / (deg1 - 1) * 2.0;
    }
#endif
}

igraph_free(neis);
igraph_adjlist_destroy(&allneis);
igraph_vector_int_destroy(&rank);
igraph_vector_destroy(°ree);
igraph_vector_int_destroy(&order);
IGRAPH_FINALLY_CLEAN(5);

#ifdef TRANSIT_TRIEDGES
#undef TRANSIT_TRIEDGES
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/properties/triangles_template1.h0000644000175100001710000000560700000000000026762 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

long int no_of_nodes = igraph_vcount(graph);
igraph_vit_t vit;
long int nodes_to_calc;
igraph_vector_int_t *neis1, *neis2;
igraph_real_t triangles;
long int i, j, k;
long int neilen1, neilen2;
long int *neis;
igraph_lazy_adjlist_t adjlist;

IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
nodes_to_calc = IGRAPH_VIT_SIZE(vit);

if (nodes_to_calc == 0) {
    igraph_vector_clear(res);
    igraph_vit_destroy(&vit);
    IGRAPH_FINALLY_CLEAN(1);
    return IGRAPH_SUCCESS;
}

neis = IGRAPH_CALLOC(no_of_nodes, long int);
if (neis == 0) {
    IGRAPH_ERROR("local undirected transitivity failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, neis);

IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));

IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);

for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
    long int node = IGRAPH_VIT_GET(vit);

    IGRAPH_ALLOW_INTERRUPTION();

    neis1 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) node);
    neilen1 = igraph_vector_int_size(neis1);
    for (j = 0; j < neilen1; j++) {
        neis[ (long int)VECTOR(*neis1)[j] ] = i + 1;
    }
    triangles = 0;

    for (j = 0; j < neilen1; j++) {
        long int v = (long int) VECTOR(*neis1)[j];
        neis2 = igraph_lazy_adjlist_get(&adjlist, (igraph_integer_t) v);
        neilen2 = igraph_vector_int_size(neis2);
        for (k = 0; k < neilen2; k++) {
            long int v2 = (long int) VECTOR(*neis2)[k];
            if (neis[v2] == i + 1) {
                triangles += 1.0;
            }
        }
    }

#ifdef TRANSIT
    if (mode == IGRAPH_TRANSITIVITY_ZERO && neilen1 < 2) {
        VECTOR(*res)[i] = 0.0;
    } else {
        VECTOR(*res)[i] = triangles / neilen1 / (neilen1 - 1);
    }
#else
    VECTOR(*res)[i] = triangles / 2;
#endif
}

igraph_lazy_adjlist_destroy(&adjlist);
IGRAPH_FREE(neis);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(3);
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5431414
igraph-0.9.9/vendor/source/igraph/src/random/0000755000175100001710000000000000000000000021721 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/random/random.c0000644000175100001710000022216200000000000023352 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2005-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_random.h"

#include "igraph_nongraph.h"
#include "igraph_error.h"
#include "igraph_types.h"
#include "igraph_vector.h"
#include "igraph_memory.h"

#include "core/math.h"

#include "config.h"
#include 
#include 

/**
 * \section about_rngs
 *
 * 

 * About random numbers in igraph, use cases
 *
 * 
 * Some algorithms in igraph, e.g. the generation of random graphs,
 * require random number generators (RNGs). Prior to version 0.6
 * igraph did not have a sophisticated way to deal with random number
 * generators at the C level, but this has changed. From version 0.6
 * different and multiple random number generators are supported.
 * 
 * 

 *
 */

/**
 * \section rng_use_cases
 *
 * 
Use cases
 *
 * 
Normal (default) use
 * 
 * If the user does not use any of the RNG functions explicitly, but calls
 * some of the randomized igraph functions, then a default RNG is set
 * up the first time an igraph function needs random numbers. The
 * seed of this RNG is the output of the time(0) function
 * call, using the time function from the standard C
 * library. This ensures that igraph creates a different random graph,
 * each time the C program is called.
 * 
 *
 * 
 * The created default generator is stored internally and can be
 * queried with the \ref igraph_rng_default() function.
 * 
 * 

 *
 * 
Reproducible simulations
 * 
 * If reproducible results are needed, then the user should set the
 * seed of the default random number generator explicitly, using the
 * \ref igraph_rng_seed() function on the default generator, \ref
 * igraph_rng_default(). When setting the seed to the same number,
 * igraph generates exactly the same random graph (or series of random
 * graphs).
 * 
 * 

 *
 * 
Changing the default generator
 * 
 * By default igraph uses the \ref igraph_rng_default() random number
 * generator. This can be changed any time by calling \ref
 * igraph_rng_set_default(), with an already initialized random number
 * generator. Note that the old (replaced) generator is not
 * destroyed, so no memory is deallocated.
 * 
 * 

 *
 * 
Using multiple generators
 * 
 * igraph also provides functions to set up multiple random number
 * generators, using the \ref igraph_rng_init() function, and then
 * generating random numbers from them, e.g. with \ref igraph_rng_get_integer()
 * and/or \ref igraph_rng_get_unif() calls.
 * 
 *
 * 
 * Note that initializing a new random number generator is
 * independent of the generator that the igraph functions themselves
 * use. If you want to replace that, then please use \ref
 * igraph_rng_set_default().
 * 
 * 

 *
 * 
Example
 * 
 * \example examples/simple/random_seed.c
 * 
 * 

 *
 * 

 */

/* ------------------------------------ */

typedef struct {
    int i, j;
    long int x[31];
} igraph_i_rng_glibc2_state_t;

static unsigned long int igraph_i_rng_glibc2_get(int *i, int *j, int n, long int *x) {
    unsigned long int k;

    x[*i] += x[*j];
    k = (x[*i] >> 1) & 0x7FFFFFFF;

    (*i)++;
    if (*i == n) {
        *i = 0;
    }

    (*j)++ ;
    if (*j == n) {
        *j = 0;
    }

    return k;
}

static unsigned long int igraph_rng_glibc2_get(void *vstate) {
    igraph_i_rng_glibc2_state_t *state =
        (igraph_i_rng_glibc2_state_t*) vstate;
    return igraph_i_rng_glibc2_get(&state->i, &state->j, 31, state->x);
}

static igraph_real_t igraph_rng_glibc2_get_real(void *state) {
    return igraph_rng_glibc2_get(state) / 2147483648.0;
}

/* this function is independent of the bit size */

static void igraph_i_rng_glibc2_init(long int *x, int n,
                                     unsigned long int s) {
    int i;

    if (s == 0) {
        s = 1;
    }

    x[0] = (long) s;
    for (i = 1 ; i < n ; i++) {
        const long int h = s / 127773;
        const long int t = 16807 * ((long) s - h * 127773) - h * 2836;
        if (t < 0) {
            s = (unsigned long) t + 2147483647 ;
        } else {
            s = (unsigned long) t ;
        }

        x[i] = (long int) s ;
    }
}

static int igraph_rng_glibc2_seed(void *vstate, unsigned long int seed) {
    igraph_i_rng_glibc2_state_t *state =
        (igraph_i_rng_glibc2_state_t*) vstate;
    int i;

    igraph_i_rng_glibc2_init(state->x, 31, seed);

    state->i = 3;
    state->j = 0;

    for (i = 0; i < 10 * 31; i++) {
        igraph_rng_glibc2_get(state);
    }

    return IGRAPH_SUCCESS;
}

static int igraph_rng_glibc2_init(void **state) {
    igraph_i_rng_glibc2_state_t *st;

    st = IGRAPH_CALLOC(1, igraph_i_rng_glibc2_state_t);
    if (!st) {
        IGRAPH_ERROR("Cannot initialize RNG", IGRAPH_ENOMEM);
    }
    (*state) = st;

    igraph_rng_glibc2_seed(st, 0);

    return IGRAPH_SUCCESS;
}

static void igraph_rng_glibc2_destroy(void *vstate) {
    igraph_i_rng_glibc2_state_t *state =
        (igraph_i_rng_glibc2_state_t*) vstate;
    IGRAPH_FREE(state);
}

/**
 * \var igraph_rngtype_glibc2
 * \brief The random number generator introduced in GNU libc 2.
 *
 * This is a linear feedback shift register generator with a 128-byte
 * buffer. This generator was the default prior to igraph version 0.6,
 * at least on systems relying on GNU libc.
 *
 * This generator was ported from the GNU Scientific Library. It is a
 * reimplementation and does not call the system glibc generator.
 */

const igraph_rng_type_t igraph_rngtype_glibc2 = {
    /* name= */      "LIBC",
    /* min=  */      0,
    /* max=  */      0x7fffffffUL,
    /* init= */      igraph_rng_glibc2_init,
    /* destroy= */   igraph_rng_glibc2_destroy,
    /* seed= */      igraph_rng_glibc2_seed,
    /* get= */       igraph_rng_glibc2_get,
    /* get_real= */  igraph_rng_glibc2_get_real,
    /* get_norm= */  0,
    /* get_geom= */  0,
    /* get_binom= */ 0,
    /* get_exp= */   0,
    /* get_gamma= */ 0
};

/* ------------------------------------ */

typedef struct {
    unsigned long int x;
} igraph_i_rng_rand_state_t;

static unsigned long int igraph_rng_rand_get(void *vstate) {
    igraph_i_rng_rand_state_t *state = vstate;
    state->x = (1103515245 * state->x + 12345) & 0x7fffffffUL;
    return state->x;
}

static igraph_real_t igraph_rng_rand_get_real(void *vstate) {
    return igraph_rng_rand_get (vstate) / 2147483648.0 ;
}

static int igraph_rng_rand_seed(void *vstate, unsigned long int seed) {
    igraph_i_rng_rand_state_t *state = vstate;
    state->x = seed;
    return IGRAPH_SUCCESS;
}

static int igraph_rng_rand_init(void **state) {
    igraph_i_rng_rand_state_t *st;

    st = IGRAPH_CALLOC(1, igraph_i_rng_rand_state_t);
    if (!st) {
        IGRAPH_ERROR("Cannot initialize RNG", IGRAPH_ENOMEM);
    }
    (*state) = st;

    igraph_rng_rand_seed(st, 0);

    return IGRAPH_SUCCESS;
}

static void igraph_rng_rand_destroy(void *vstate) {
    igraph_i_rng_rand_state_t *state =
        (igraph_i_rng_rand_state_t*) vstate;
    IGRAPH_FREE(state);
}

/**
 * \var igraph_rngtype_rand
 * \brief The old BSD rand/srand random number generator.
 *
 * The sequence is
 *     x_{n+1} = (a x_n + c) mod m
 * with a = 1103515245, c = 12345 and
 * m = 2^31 = 2147483648.
 * The seed specifies the initial value, x_1.
 *
 * 
 * The theoretical value of x_{10001} is 1910041713.
 *
 * 
 * The period of this generator is 2^31.
 *
 * 
 * This generator is not very good—the low bits of successive
 * numbers are correlated.
 *
 * 
 * This generator was ported from the GNU Scientific Library.
 */

const igraph_rng_type_t igraph_rngtype_rand = {
    /* name= */      "RAND",
    /* min=  */      0,
    /* max=  */      0x7fffffffUL,
    /* init= */      igraph_rng_rand_init,
    /* destroy= */   igraph_rng_rand_destroy,
    /* seed= */      igraph_rng_rand_seed,
    /* get= */       igraph_rng_rand_get,
    /* get_real= */  igraph_rng_rand_get_real,
    /* get_norm= */  0,
    /* get_geom= */  0,
    /* get_binom= */ 0,
    /* get_exp= */   0,
    /* get_gamma= */ 0
};

/* ------------------------------------ */

#define N 624   /* Period parameters */
#define M 397

/* most significant w-r bits */
static const unsigned long UPPER_MASK = 0x80000000UL;

/* least significant r bits */
static const unsigned long LOWER_MASK = 0x7fffffffUL;

typedef struct {
    unsigned long mt[N];
    int mti;
} igraph_i_rng_mt19937_state_t;

static unsigned long int igraph_rng_mt19937_get(void *vstate) {
    igraph_i_rng_mt19937_state_t *state = vstate;

    unsigned long k ;
    unsigned long int *const mt = state->mt;

#define MAGIC(y) (((y)&0x1) ? 0x9908b0dfUL : 0)

    if (state->mti >= N) {
        /* generate N words at one time */
        int kk;

        for (kk = 0; kk < N - M; kk++) {
            unsigned long y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
            mt[kk] = mt[kk + M] ^ (y >> 1) ^ MAGIC(y);
        }
        for (; kk < N - 1; kk++) {
            unsigned long y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
            mt[kk] = mt[kk + (M - N)] ^ (y >> 1) ^ MAGIC(y);
        }

        {
            unsigned long y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
            mt[N - 1] = mt[M - 1] ^ (y >> 1) ^ MAGIC(y);
        }

        state->mti = 0;
    }

#undef MAGIC

    /* Tempering */

    k = mt[state->mti];
    k ^= (k >> 11);
    k ^= (k << 7) & 0x9d2c5680UL;
    k ^= (k << 15) & 0xefc60000UL;
    k ^= (k >> 18);

    state->mti++;

    return k;
}

static igraph_real_t igraph_rng_mt19937_get_real(void *vstate) {
    return igraph_rng_mt19937_get (vstate) / 4294967296.0 ;
}

static int igraph_rng_mt19937_seed(void *vstate, unsigned long int seed) {
    igraph_i_rng_mt19937_state_t *state = vstate;
    int i;

    memset(state, 0, sizeof(igraph_i_rng_mt19937_state_t));

    if (seed == 0) {
        seed = 4357;   /* the default seed is 4357 */
    }
    state->mt[0] = seed & 0xffffffffUL;

    for (i = 1; i < N; i++) {
        /* See Knuth's "Art of Computer Programming" Vol. 2, 3rd
           Ed. p.106 for multiplier. */
        state->mt[i] =
            (1812433253UL * (state->mt[i - 1] ^ (state->mt[i - 1] >> 30)) +
             (unsigned long) i);
        state->mt[i] &= 0xffffffffUL;
    }

    state->mti = i;
    return IGRAPH_SUCCESS;
}

static int igraph_rng_mt19937_init(void **state) {
    igraph_i_rng_mt19937_state_t *st;

    st = IGRAPH_CALLOC(1, igraph_i_rng_mt19937_state_t);
    if (!st) {
        IGRAPH_ERROR("Cannot initialize RNG", IGRAPH_ENOMEM);
    }
    (*state) = st;

    igraph_rng_mt19937_seed(st, 0);

    return IGRAPH_SUCCESS;
}

static void igraph_rng_mt19937_destroy(void *vstate) {
    igraph_i_rng_mt19937_state_t *state =
        (igraph_i_rng_mt19937_state_t*) vstate;
    IGRAPH_FREE(state);
}

/**
 * \var igraph_rngtype_mt19937
 * \brief The MT19937 random number generator.
 *
 * The MT19937 generator of Makoto Matsumoto and Takuji Nishimura is a
 * variant of the twisted generalized feedback shift-register
 * algorithm, and is known as the “Mersenne Twister†generator. It has
 * a Mersenne prime period of 2^19937 - 1 (about 10^6000) and is
 * equi-distributed in 623 dimensions. It has passed the diehard
 * statistical tests. It uses 624 words of state per generator and is
 * comparable in speed to the other generators. The original generator
 * used a default seed of 4357 and choosing \c s equal to zero in
 * \c gsl_rng_set reproduces this. Later versions switched to 5489 as the
 * default seed, you can choose this explicitly via \ref igraph_rng_seed()
 * instead if you require it.
 *
 * 
 * For more information see,
 * Makoto Matsumoto and Takuji Nishimura, “Mersenne Twister: A
 * 623-dimensionally equidistributed uniform pseudorandom number
 * generatorâ€. ACM Transactions on Modeling and Computer Simulation,
 * Vol. 8, No. 1 (Jan. 1998), Pages 3–30
 *
 * 
 * The generator \c igraph_rngtype_mt19937 uses the second revision of the
 * seeding procedure published by the two authors above in 2002. The
 * original seeding procedures could cause spurious artifacts for some
 * seed values.
 *
 * 
 * This generator was ported from the GNU Scientific Library.
 */

const igraph_rng_type_t igraph_rngtype_mt19937 = {
    /* name= */      "MT19937",
    /* min=  */      0,
    /* max=  */      0xffffffffUL,
    /* init= */      igraph_rng_mt19937_init,
    /* destroy= */   igraph_rng_mt19937_destroy,
    /* seed= */      igraph_rng_mt19937_seed,
    /* get= */       igraph_rng_mt19937_get,
    /* get_real= */  igraph_rng_mt19937_get_real,
    /* get_norm= */  0,
    /* get_geom= */  0,
    /* get_binom= */ 0,
    /* get_exp= */   0,
    /* get_gamma= */ 0
};

#undef N
#undef M

/* ------------------------------------ */

#ifndef USING_R

igraph_i_rng_mt19937_state_t igraph_i_rng_default_state;

#define addr(a) (&a)

/**
 * \var igraph_i_rng_default
 * The default igraph random number generator
 *
 * This generator is used by all builtin igraph functions that need to
 * generate random numbers; e.g. all random graph generators.
 *
 * You can use \ref igraph_i_rng_default with \ref igraph_rng_seed()
 * to set its seed.
 *
 * You can change the default generator using the \ref
 * igraph_rng_set_default() function.
 */

IGRAPH_THREAD_LOCAL igraph_rng_t igraph_i_rng_default = {
    addr(igraph_rngtype_mt19937),
    addr(igraph_i_rng_default_state),
    /* def= */ 1
};

#undef addr

/**
 * \function igraph_rng_set_default
 * \brief Set the default igraph random number generator.
 *
 * \param rng The random number generator to use as default from now
 *    on. Calling \ref igraph_rng_destroy() on it, while it is still
 *    being used as the default will result in crashes and/or
 *    unpredictable results.
 *
 * Time complexity: O(1).
 */

void igraph_rng_set_default(igraph_rng_t *rng) {
    igraph_i_rng_default = (*rng);
}

#endif


/* ------------------------------------ */

#ifdef USING_R

double  unif_rand(void);
double  norm_rand(void);
double  exp_rand(void);
double  Rf_rgeom(double);
double  Rf_rbinom(double, double);
double  Rf_rgamma(double, double);

int igraph_rng_R_init(void **state) {
    IGRAPH_ERROR("R RNG error, unsupported function called",
                 IGRAPH_EINTERNAL);
    return IGRAPH_SUCCESS;
}

void igraph_rng_R_destroy(void *state) {
    igraph_error("R RNG error, unsupported function called",
                 __FILE__, __LINE__, IGRAPH_EINTERNAL);
}

int igraph_rng_R_seed(void *state, unsigned long int seed) {
    IGRAPH_ERROR("R RNG error, unsupported function called",
                 IGRAPH_EINTERNAL);
    return IGRAPH_SUCCESS;
}

unsigned long int igraph_rng_R_get(void *state) {
    return (unsigned long) (unif_rand() * 0x7FFFFFFFUL);
}

igraph_real_t igraph_rng_R_get_real(void *state) {
    return unif_rand();
}

igraph_real_t igraph_rng_R_get_norm(void *state) {
    return norm_rand();
}

igraph_real_t igraph_rng_R_get_geom(void *state, igraph_real_t p) {
    return Rf_rgeom(p);
}

igraph_real_t igraph_rng_R_get_binom(void *state, long int n,
                                     igraph_real_t p) {
    return Rf_rbinom(n, p);
}

igraph_real_t igraph_rng_R_get_gamma(void *state, igraph_real_t shape,
                                     igraph_real_t scale) {
    return Rf_rgamma(shape, scale);
}

igraph_real_t igraph_rng_R_get_exp(void *state, igraph_real_t rate) {
    igraph_real_t scale = 1.0 / rate;
    if (!IGRAPH_FINITE(scale) || scale <= 0.0) {
        if (scale == 0.0) {
            return 0.0;
        }
        return IGRAPH_NAN;
    }
    return scale * exp_rand();
}

igraph_rng_type_t igraph_rngtype_R = {
    /* name= */      "GNU R",
    /* min=  */      0,
    /* max=  */      0x7FFFFFFFUL,
    /* init= */      igraph_rng_R_init,
    /* destroy= */   igraph_rng_R_destroy,
    /* seed= */      igraph_rng_R_seed,
    /* get= */       igraph_rng_R_get,
    /* get_real= */  igraph_rng_R_get_real,
    /* get_norm= */  igraph_rng_R_get_norm,
    /* get_geom= */  igraph_rng_R_get_geom,
    /* get_binom= */ igraph_rng_R_get_binom,
    /* get_exp= */   igraph_rng_R_get_exp
};

IGRAPH_THREAD_LOCAL igraph_rng_t igraph_i_rng_default = {
    &igraph_rngtype_R,
    0,
    /* def= */ 1
};

#endif

/* ------------------------------------ */

/**
 * \function igraph_rng_default
 * Query the default random number generator.
 *
 * \return A pointer to the default random number generator.
 *
 * \sa igraph_rng_set_default()
 */

igraph_rng_t *igraph_rng_default() {
    return &igraph_i_rng_default;
}

/* ------------------------------------ */

static double igraph_norm_rand(igraph_rng_t *rng);
static double igraph_rgeom(igraph_rng_t *rng, double p);
static double igraph_rbinom(igraph_rng_t *rng, double nin, double pp);
static double igraph_rexp(igraph_rng_t *rng, double rate);
static double igraph_rgamma(igraph_rng_t *rng, double shape, double scale);

/**
 * \function igraph_rng_init
 * \brief Initialize a random number generator.
 *
 * This function allocates memory for a random number generator, with
 * the given type, and sets its seed to the default.
 *
 * \param rng Pointer to an uninitialized RNG.
 * \param type The type of the RNG, like \ref igraph_rngtype_glibc2,
 * \ref igraph_rngtype_mt19937 or \ref igraph_rngtype_rand.
 * \return Error code.
 *
 * Time complexity: depends on the type of the generator, but usually
 * it should be O(1).
 */

int igraph_rng_init(igraph_rng_t *rng, const igraph_rng_type_t *type) {
    rng->type = type;
    IGRAPH_CHECK(rng->type->init(&rng->state));
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_rng_destroy
 * \brief Deallocate memory associated with a random number generator.
 *
 * \param rng The RNG to destroy. Do not destroy an RNG that is used
 *    as the default igraph RNG.
 *
 * Time complexity: O(1).
 */

void igraph_rng_destroy(igraph_rng_t *rng) {
    rng->type->destroy(rng->state);
}

/**
 * \function igraph_rng_seed
 * \brief Set the seed of a random number generator.
 *
 * \param rng The RNG.
 * \param seed The new seed.
 * \return Error code.
 *
 * Time complexity: usually O(1), but may depend on the type of the
 * RNG.
 */
int igraph_rng_seed(igraph_rng_t *rng, unsigned long int seed) {
    const igraph_rng_type_t *type = rng->type;
    rng->def = 0;
    IGRAPH_CHECK(type->seed(rng->state, seed));
    return IGRAPH_SUCCESS;
}

/**
 * \function igraph_rng_max
 * \brief Query the maximum possible integer for a random number generator.
 *
 * \param rng The RNG.
 * \return The largest possible integer that can be generated by
 *         calling \ref igraph_rng_get_integer() on the RNG.
 *
 * Time complexity: O(1).
 */

unsigned long int igraph_rng_max(igraph_rng_t *rng) {
    const igraph_rng_type_t *type = rng->type;
    return type->max;
}

/**
 * \function igraph_rng_min
 * \brief Query the minimum possible integer for a random number generator.
 *
 * \param rng The RNG.
 * \return The smallest possible integer that can be generated by
 *         calling \ref igraph_rng_get_integer() on the RNG.
 *
 * Time complexity: O(1).
 */

unsigned long int igraph_rng_min(igraph_rng_t *rng) {
    const igraph_rng_type_t *type = rng->type;
    return type->min;
}

/**
 * \function igraph_rng_name
 * \brief Query the type of a random number generator.
 *
 * \param rng The RNG.
 * \return The name of the type of the generator. Do not deallocate or
 *         change the returned string pointer.
 *
 * Time complexity: O(1).
 */

const char *igraph_rng_name(igraph_rng_t *rng) {
    const igraph_rng_type_t *type = rng->type;
    return type->name;
}

/**
 * \function igraph_rng_get_integer
 * \brief Generate an integer random number from an interval.
 *
 * \param rng Pointer to the RNG to use for the generation. Use \ref
 *        igraph_rng_default() here to use the default igraph RNG.
 * \param l Lower limit, inclusive, it can be negative as well.
 * \param h Upper limit, inclusive, it can be negative as well, but it
 *        should be at least l.
 * \return The generated random integer.
 *
 * Time complexity: depends on the generator, but should be usually
 * O(1).
 */

long int igraph_rng_get_integer(igraph_rng_t *rng,
                                long int l, long int h) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_real) {
        return (long int)(type->get_real(rng->state) * (h - l + 1) + l);
    } else if (type->get) {
        unsigned long int max = type->max;
        return (long int)(type->get(rng->state) / ((double)max + 1) * (h - l + 1) + l);
    }
    IGRAPH_FATAL("Internal random generator error");
}

/**
 * \function igraph_rng_get_normal
 * Normally distributed random numbers
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \param m The mean.
 * \param s Standard deviation.
 * \return The generated normally distributed random number.
 *
 * Time complexity: depends on the type of the RNG.
 */

igraph_real_t igraph_rng_get_normal(igraph_rng_t *rng,
                                    igraph_real_t m, igraph_real_t s) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_norm) {
        return type->get_norm(rng->state) * s + m;
    } else {
        return igraph_norm_rand(rng) * s + m;
    }
}

/**
 * \function igraph_rng_get_unif
 * Generate real, uniform random numbers from an interval
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \param l The lower bound, it can be negative.
 * \param h The upper bound, it can be negative, but it has to be
 *        larger than the lower bound.
 * \return The generated uniformly distributed random number.
 *
 * Time complexity: depends on the type of the RNG.
 */

igraph_real_t igraph_rng_get_unif(igraph_rng_t *rng,
                                  igraph_real_t l, igraph_real_t h) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_real) {
        return type->get_real(rng->state) * (h - l) + l;
    } else if (type->get) {
        unsigned long int max = type->max;
        return type->get(rng->state) / ((double)max + 1) * (double)(h - l) + l;
    }
    IGRAPH_FATAL("Internal random generator error");
}

/**
 * \function igraph_rng_get_unif01
 * Generate real, uniform random number from the unit interval
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \return The generated uniformly distributed random number.
 *
 * Time complexity: depends on the type of the RNG.
 */

igraph_real_t igraph_rng_get_unif01(igraph_rng_t *rng) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_real) {
        return type->get_real(rng->state);
    } else if (type->get) {
        unsigned long int max = type->max;
        return type->get(rng->state) / ((double)max + 1);
    }
    IGRAPH_FATAL("Internal random generator error");
}

/**
 * \function igraph_rng_get_geom
 * Generate geometrically distributed random numbers
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \param p The probability of success in each trial. Must be larger
 *        than zero and smaller or equal to 1.
 * \return The generated geometrically distributed random number.
 *
 * Time complexity: depends on the type of the RNG.
 */

igraph_real_t igraph_rng_get_geom(igraph_rng_t *rng, igraph_real_t p) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_geom) {
        return type->get_geom(rng->state, p);
    } else {
        return igraph_rgeom(rng, p);
    }
}

/**
 * \function igraph_rng_get_binom
 * Generate binomially distributed random numbers
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \param n Number of observations.
 * \param p Probability of an event.
 * \return The generated binomially distributed random number.
 *
 * Time complexity: depends on the type of the RNG.
 */

igraph_real_t igraph_rng_get_binom(igraph_rng_t *rng, long int n,
                                   igraph_real_t p) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_binom) {
        return type->get_binom(rng->state, n, p);
    } else {
        return igraph_rbinom(rng, n, p);
    }
}

/**
 * \function igraph_rng_get_gamma
 * Generate sample from a Gamma distribution
 *
 * \param rng Pointer to the RNG to use. Use \ref igraph_rng_default()
 *        here to use the default igraph RNG.
 * \param shape Shape parameter.
 * \param scale Scale parameter.
 * \return The generated sample
 *
 * Time complexity: depends on RNG.
 */

igraph_real_t igraph_rng_get_gamma(igraph_rng_t *rng, igraph_real_t shape,
                                   igraph_real_t scale) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_gamma) {
        return type->get_gamma(rng->state, shape, scale);
    } else {
        return igraph_rgamma(rng, shape, scale);
    }
}

unsigned long int igraph_rng_get_int31(igraph_rng_t *rng) {
    const igraph_rng_type_t *type = rng->type;
    unsigned long int max = type->max;
    if (type->get && max == 0x7FFFFFFFUL) {
        return type->get(rng->state);
    } else if (type->get_real) {
        return (unsigned long int) (type->get_real(rng->state) * 0x7FFFFFFFUL);
    } else {
        return (unsigned long int) (igraph_rng_get_unif01(rng) * 0x7FFFFFFFUL);
    }
}

igraph_real_t igraph_rng_get_exp(igraph_rng_t *rng, igraph_real_t rate) {
    const igraph_rng_type_t *type = rng->type;
    if (type->get_exp) {
        return type->get_exp(rng->state, rate);
    } else {
        return igraph_rexp(rng, rate);
    }
}


#ifndef HAVE_EXPM1
#ifndef USING_R         /* R provides a replacement */
/* expm1 replacement */
double expm1 (double x) {
    if (fabs(x) < M_LN2) {
        /* Compute the Taylor series S = x + (1/2!) x^2 + (1/3!) x^3 + ... */

        double i = 1.0;
        double sum = x;
        double term = x / 1.0;

        do {
            term *= x / ++i;
            sum += term;
        } while (fabs(term) > fabs(sum) * 2.22e-16);

        return sum;
    }

    return expl(x) - 1.0L;
}
#endif
#endif

#ifndef HAVE_RINT
#ifndef USING_R         /* R provides a replacement */
/* rint replacement */
double rint (double x) {
    return ( (x < 0.) ? -floor(-x + .5) : floor(x + .5) );
}
#endif
#endif

#ifndef HAVE_RINTF
float rintf (float x) {
    return ( (x < (float)0.) ? -(float)floor(-x + .5) : (float)floor(x + .5) );
}
#endif

/*
 * \ingroup internal
 *
 * This function appends the rest of the needed random number to the
 * result vector.
 */

static int igraph_i_random_sample_alga(igraph_vector_t *res,
                                       igraph_integer_t l, igraph_integer_t h,
                                       igraph_integer_t length) {
    igraph_real_t N = h - l + 1;
    igraph_real_t n = length;

    igraph_real_t top = N - n;
    igraph_real_t Nreal = N;
    igraph_real_t S = 0;
    igraph_real_t V, quot;

    l = l - 1;

    while (n >= 2) {
        V = RNG_UNIF01();
        S = 1;
        quot = top / Nreal;
        while (quot > V) {
            S += 1;
            top = -1.0 + top;
            Nreal = -1.0 + Nreal;
            quot = (quot * top) / Nreal;
        }
        l += S;
        igraph_vector_push_back(res, l);    /* allocated */
        Nreal = -1.0 + Nreal; n = -1 + n;
    }

    S = floor(round(Nreal) * RNG_UNIF01());
    l += S + 1;
    igraph_vector_push_back(res, l);  /* allocated */

    return IGRAPH_SUCCESS;
}

/**
 * \ingroup nongraph
 * \function igraph_random_sample
 * \brief Generates an increasing random sequence of integers.
 *
 * 
 * This function generates an increasing sequence of random integer
 * numbers from a given interval. The algorithm is taken literally
 * from (Vitter 1987). This method can be used for generating numbers from a
 * \em very large interval. It is primarily created for randomly
 * selecting some edges from the sometimes huge set of possible edges
 * in a large graph.
 * 
 * Note that the type of the lower and the upper limit is \c igraph_real_t,
 * not \c igraph_integer_t. This does not mean that you can pass fractional
 * numbers there; these values must still be integral, but we need the
 * longer range of \c igraph_real_t in several places in the library
 * (for instance, when generating Erdos-Renyi graphs).
 * \param res Pointer to an initialized vector. This will hold the
 *        result. It will be resized to the proper size.
 * \param l The lower limit of the generation interval (inclusive). This must
 *        be less than or equal to the upper limit, and it must be integral.
 *        Passing a fractional number here results in undefined behaviour.
 * \param h The upper limit of the generation interval (inclusive). This must
 *        be greater than or equal to the lower limit, and it must be integral.
 *        Passing a fractional number here results in undefined behaviour.
 * \param length The number of random integers to generate.
 * \return The error code \c IGRAPH_EINVAL is returned in each of the
 *         following cases: (1) The given lower limit is greater than the
 *         given upper limit, i.e. \c l > \c h. (2) Assuming that
 *         \c l < \c h and N is the sample size, the above error code is
 *         returned if N > |\c h - \c l|, i.e. the sample size exceeds the
 *         size of the candidate pool.
 *
 * Time complexity: according to (Vitter 1987), the expected
 * running time is O(length).
 *
 * 
 * Reference:
 * \clist
 * \cli (Vitter 1987)
 *   J. S. Vitter. An efficient algorithm for sequential random sampling.
 *   \emb ACM Transactions on Mathematical Software, \eme 13(1):58--67, 1987.
 * \endclist
 *
 * \example examples/simple/igraph_random_sample.c
 */

int igraph_random_sample(igraph_vector_t *res, igraph_real_t l, igraph_real_t h,
                         igraph_integer_t length) {
    igraph_real_t N = h - l + 1;
    igraph_real_t n = length;
    int retval;

    igraph_real_t nreal = length;
    igraph_real_t ninv = (nreal != 0) ? 1.0 / nreal : 0.0;
    igraph_real_t Nreal = N;
    igraph_real_t Vprime;
    igraph_real_t qu1 = -n + 1 + N;
    igraph_real_t qu1real = -nreal + 1.0 + Nreal;
    igraph_real_t negalphainv = -13;
    igraph_real_t threshold = -negalphainv * n;
    igraph_real_t S;

    /* getting back some sense of sanity */
    if (l > h) {
        IGRAPH_ERROR("Lower limit is greater than upper limit", IGRAPH_EINVAL);
    }
    /* now we know that l <= h */
    if (length > N) {
        IGRAPH_ERROR("Sample size exceeds size of candidate pool", IGRAPH_EINVAL);
    }

    /* treat rare cases quickly */
    if (l == h) {
        IGRAPH_CHECK(igraph_vector_resize(res, 1));
        VECTOR(*res)[0] = l;
        return IGRAPH_SUCCESS;
    }
    if (length == 0) {
        igraph_vector_clear(res);
        return IGRAPH_SUCCESS;
    }
    if (length == N) {
        long int i = 0;
        IGRAPH_CHECK(igraph_vector_resize(res, length));
        for (i = 0; i < length; i++) {
            VECTOR(*res)[i] = l++;
        }
        return IGRAPH_SUCCESS;
    }

    igraph_vector_clear(res);
    IGRAPH_CHECK(igraph_vector_reserve(res, length));

    RNG_BEGIN();

    Vprime = exp(log(RNG_UNIF01()) * ninv);
    l = l - 1;

    while (n > 1 && threshold < N) {
        igraph_real_t X, U;
        igraph_real_t limit, t;
        igraph_real_t negSreal, y1, y2, top, bottom;
        igraph_real_t nmin1inv = 1.0 / (-1.0 + nreal);
        while (1) {
            while (1) {
                X = Nreal * (-Vprime + 1.0);
                S = floor(X);
                /* if (S==0) { S=1; } */
                if (S < qu1) {
                    break;
                }
                Vprime = exp(log(RNG_UNIF01()) * ninv);
            }
            U = RNG_UNIF01();
            negSreal = -S;

            y1 = exp(log(U * Nreal / qu1real) * nmin1inv);
            Vprime = y1 * (-X / Nreal + 1.0) * (qu1real / (negSreal + qu1real));
            if (Vprime <= 1.0) {
                break;
            }

            y2 = 1.0;
            top = -1.0 + Nreal;
            if (-1 + n > S) {
                bottom = -nreal + Nreal;
                limit = -S + N;
            } else {
                bottom = -1.0 + negSreal + Nreal;
                limit = qu1;
            }
            for (t = -1 + N; t >= limit; t--) {
                y2 = (y2 * top) / bottom;
                top = -1.0 + top;
                bottom = -1.0 + bottom;
            }
            if (Nreal / (-X + Nreal) >= y1 * exp(log(y2)*nmin1inv)) {
                Vprime = exp(log(RNG_UNIF01()) * nmin1inv);
                break;
            }
            Vprime = exp(log(RNG_UNIF01()) * ninv);
        }

        l += S + 1;
        igraph_vector_push_back(res, l);    /* allocated */
        N = -S + (-1 + N);   Nreal = negSreal + (-1.0 + Nreal);
        n = -1 + n;   nreal = -1.0 + nreal; ninv = nmin1inv;
        qu1 = -S + qu1; qu1real = negSreal + qu1real;
        threshold = threshold + negalphainv;
    }

    if (n > 1) {
        retval = igraph_i_random_sample_alga(res, (igraph_integer_t) l + 1,
                                             (igraph_integer_t) h,
                                             (igraph_integer_t) n);
    } else {
        retval = 0;
        S = floor(N * Vprime);
        l += S + 1;
        igraph_vector_push_back(res, l);    /* allocated */
    }

    RNG_END();

    return retval;
}

#ifdef USING_R

/* These are never called. But they are correct, nevertheless */

double igraph_norm_rand(igraph_rng_t *rng) {
    return norm_rand();
}

double igraph_rgeom(igraph_rng_t *rng, double p) {
    return Rf_rgeom(p);
}

double igraph_rbinom(igraph_rng_t *rng, double nin, double pp) {
    return Rf_rbinom(nin, pp);
}

double igraph_rexp(igraph_rng_t *rng, double rate) {
    igraph_real_t scale = 1.0 / rate;
    if (!IGRAPH_FINITE(scale) || scale <= 0.0) {
        if (scale == 0.0) {
            return 0.0;
        }
        return IGRAPH_NAN;
    }
    return scale * exp_rand();
}

double igraph_rgamma(igraph_rng_t *rng, double shape, double scale) {
    return Rf_rgamma(shape, scale);
}

#else

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000 The R Development Core Team
 *  based on AS 111 (C) 1977 Royal Statistical Society
 *  and   on AS 241 (C) 1988 Royal Statistical Society
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA.
 *
 *  SYNOPSIS
 *
 *  double qnorm5(double p, double mu, double sigma,
 *            int lower_tail, int log_p)
 *            {qnorm (..) is synonymous and preferred inside R}
 *
 *  DESCRIPTION
 *
 *  Compute the quantile function for the normal distribution.
 *
 *  For small to moderate probabilities, algorithm referenced
 *  below is used to obtain an initial approximation which is
 *  polished with a final Newton step.
 *
 *  For very large arguments, an algorithm of Wichura is used.
 *
 *  REFERENCE
 *
 *  Beasley, J. D. and S. G. Springer (1977).
 *  Algorithm AS 111: The percentage points of the normal distribution,
 *  Applied Statistics, 26, 118-121.
 *
 *      Wichura, M.J. (1988).
 *      Algorithm AS 241: The Percentage Points of the Normal Distribution.
 *      Applied Statistics, 37, 477-484.
 */

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998-2004  The R Development Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/* Private header file for use during compilation of Mathlib */
#ifndef MATHLIB_PRIVATE_H
#define MATHLIB_PRIVATE_H

#define ML_POSINF IGRAPH_INFINITY
#define ML_NEGINF -IGRAPH_INFINITY
#define ML_NAN    IGRAPH_NAN

#define ML_ERROR(x) /* nothing */
#define ML_UNDERFLOW    (DBL_MIN * DBL_MIN)
#define ML_VALID(x) (!ISNAN(x))

#define ME_NONE     0
/*  no error */
#define ME_DOMAIN   1
/*  argument out of domain */
#define ME_RANGE    2
/*  value out of range */
#define ME_NOCONV   4
/*  process did not converge */
#define ME_PRECISION    8
/*  does not have "full" precision */
#define ME_UNDERFLOW    16
/*  and underflow occurred (important for IEEE)*/

#define ML_ERR_return_NAN { ML_ERROR(ME_DOMAIN); return ML_NAN; }

/* Wilcoxon Rank Sum Distribution */

#define WILCOX_MAX 50

/* Wilcoxon Signed Rank Distribution */

#define SIGNRANK_MAX 50

/* Formerly private part of Mathlib.h */

/* always remap internal functions */
#define bd0             Rf_bd0
#define chebyshev_eval  Rf_chebyshev_eval
#define chebyshev_init  Rf_chebyshev_init
#define i1mach          Rf_i1mach
#define gammalims       Rf_gammalims
#define lfastchoose     Rf_lfastchoose
#define lgammacor       Rf_lgammacor
#define stirlerr        Rf_stirlerr

/* Chebyshev Series */

int chebyshev_init(double*, int, double);
double  chebyshev_eval(double, const double *, const int);

/* Gamma and Related Functions */

void    gammalims(double*, double*);
double  lgammacor(double); /* log(gamma) correction */
double  stirlerr(double);  /* Stirling expansion "error" */

double  lfastchoose(double, double);

double  bd0(double, double);

/* Consider adding these two to the API (Rmath.h): */
double  dbinom_raw(double, double, double, double, int);
double  dpois_raw (double, double, int);
double  pnchisq_raw(double, double, double, double, double, int);

int i1mach(int);

/* From toms708.c */
void bratio(double a, double b, double x, double y,
            double *w, double *w1, int *ierr);


#endif /* MATHLIB_PRIVATE_H */


/* Utilities for `dpq' handling (density/probability/quantile) */

/* give_log in "d";  log_p in "p" & "q" : */
#define give_log log_p
/* "DEFAULT" */
/* --------- */
#define R_D__0  (log_p ? ML_NEGINF : 0.)        /* 0 */
#define R_D__1  (log_p ? 0. : 1.)           /* 1 */
#define R_DT_0  (lower_tail ? R_D__0 : R_D__1)      /* 0 */
#define R_DT_1  (lower_tail ? R_D__1 : R_D__0)      /* 1 */

#define R_D_Lval(p) (lower_tail ? (p) : (1 - (p)))  /*  p  */
#define R_D_Cval(p) (lower_tail ? (1 - (p)) : (p))  /*  1 - p */

#define R_D_val(x)  (log_p  ? log(x) : (x))     /*  x  in pF(x,..) */
#define R_D_qIv(p)  (log_p  ? exp(p) : (p))     /*  p  in qF(p,..) */
#define R_D_exp(x)  (log_p  ?  (x)   : exp(x))  /* exp(x) */
#define R_D_log(p)  (log_p  ?  (p)   : log(p))  /* log(p) */
#define R_D_Clog(p) (log_p  ? log1p(-(p)) : (1 - (p)))/* [log](1-p) */

/* log(1-exp(x)):  R_D_LExp(x) == (log1p(- R_D_qIv(x))) but even more stable:*/
#define R_D_LExp(x)     (log_p ? R_Log1_Exp(x) : log1p(-x))

/*till 1.8.x:
 * #define R_DT_val(x)  R_D_val(R_D_Lval(x))
 * #define R_DT_Cval(x) R_D_val(R_D_Cval(x)) */
#define R_DT_val(x) (lower_tail ? R_D_val(x)  : R_D_Clog(x))
#define R_DT_Cval(x)    (lower_tail ? R_D_Clog(x) : R_D_val(x))

/*#define R_DT_qIv(p)   R_D_Lval(R_D_qIv(p))         *  p  in qF ! */
#define R_DT_qIv(p) (log_p ? (lower_tail ? exp(p) : - expm1(p)) \
                     : R_D_Lval(p))

/*#define R_DT_CIv(p)   R_D_Cval(R_D_qIv(p))         *  1 - p in qF */
#define R_DT_CIv(p) (log_p ? (lower_tail ? -expm1(p) : exp(p)) \
                     : R_D_Cval(p))

#define R_DT_exp(x) R_D_exp(R_D_Lval(x))        /* exp(x) */
#define R_DT_Cexp(x)    R_D_exp(R_D_Cval(x))        /* exp(1 - x) */

#define R_DT_log(p) (lower_tail? R_D_log(p) : R_D_LExp(p))/* log(p) in qF */
#define R_DT_Clog(p)    (lower_tail? R_D_LExp(p): R_D_log(p))/* log(1-p) in qF*/
#define R_DT_Log(p) (lower_tail? (p) : R_Log1_Exp(p))
/* ==   R_DT_log when we already "know" log_p == TRUE :*/

#define R_Q_P01_check(p)            \
    if ((log_p  && p > 0) ||            \
        (!log_p && (p < 0 || p > 1)) )      \
        ML_ERR_return_NAN

/* additions for density functions (C.Loader) */
#define R_D_fexp(f,x)     (give_log ? -0.5*log(f)+(x) : exp(x)/sqrt(f))
#define R_D_forceint(x)   floor((x) + 0.5)
#define R_D_nonint(x)     (fabs((x) - floor((x)+0.5)) > 1e-7)
/* [neg]ative or [non int]eger : */
#define R_D_negInonint(x) (x < 0. || R_D_nonint(x))

#define R_D_nonint_check(x)                 \
    if(R_D_nonint(x)) {                  \
        MATHLIB_WARNING("non-integer x = %f", x);   \
        return R_D__0;                  \
    }

double igraph_qnorm5(double p, double mu, double sigma, int lower_tail, int log_p) {
    double p_, q, r, val;

#ifdef IEEE_754
    if (ISNAN(p) || ISNAN(mu) || ISNAN(sigma)) {
        return p + mu + sigma;
    }
#endif
    if (p == R_DT_0) {
        return ML_NEGINF;
    }
    if (p == R_DT_1) {
        return ML_POSINF;
    }
    R_Q_P01_check(p);

    if (sigma  < 0) {
        ML_ERR_return_NAN;
    }
    if (sigma == 0) {
        return mu;
    }

    p_ = R_DT_qIv(p);/* real lower_tail prob. p */
    q = p_ - 0.5;

    /*-- use AS 241 --- */
    /* double ppnd16_(double *p, long *ifault)*/
    /*      ALGORITHM AS241  APPL. STATIST. (1988) VOL. 37, NO. 3

            Produces the normal deviate Z corresponding to a given lower
            tail area of P; Z is accurate to about 1 part in 10**16.

            (original fortran code used PARAMETER(..) for the coefficients
             and provided hash codes for checking them...)
    */
    if (fabs(q) <= .425) {/* 0.075 <= p <= 0.925 */
        r = .180625 - q * q;
        val =
            q * (((((((r * 2509.0809287301226727 +
                       33430.575583588128105) * r + 67265.770927008700853) * r +
                     45921.953931549871457) * r + 13731.693765509461125) * r +
                   1971.5909503065514427) * r + 133.14166789178437745) * r +
                 3.387132872796366608)
            / (((((((r * 5226.495278852854561 +
                     28729.085735721942674) * r + 39307.89580009271061) * r +
                   21213.794301586595867) * r + 5394.1960214247511077) * r +
                 687.1870074920579083) * r + 42.313330701600911252) * r + 1.);
    } else { /* closer than 0.075 from {0,1} boundary */

        /* r = min(p, 1-p) < 0.075 */
        if (q > 0) {
            r = R_DT_CIv(p);    /* 1-p */
        } else {
            r = p_;    /* = R_DT_Iv(p) ^=  p */
        }

        r = sqrt(- ((log_p &&
                     ((lower_tail && q <= 0) || (!lower_tail && q > 0))) ?
                    p : /* else */ log(r)));
        /* r = sqrt(-log(r))  <==>  min(p, 1-p) = exp( - r^2 ) */

        if (r <= 5.) { /* <==> min(p,1-p) >= exp(-25) ~= 1.3888e-11 */
            r += -1.6;
            val = (((((((r * 7.7454501427834140764e-4 +
                         .0227238449892691845833) * r + .24178072517745061177) *
                       r + 1.27045825245236838258) * r +
                      3.64784832476320460504) * r + 5.7694972214606914055) *
                    r + 4.6303378461565452959) * r +
                   1.42343711074968357734)
                  / (((((((r *
                           1.05075007164441684324e-9 + 5.475938084995344946e-4) *
                          r + .0151986665636164571966) * r +
                         .14810397642748007459) * r + .68976733498510000455) *
                       r + 1.6763848301838038494) * r +
                      2.05319162663775882187) * r + 1.);
        } else { /* very close to  0 or 1 */
            r += -5.;
            val = (((((((r * 2.01033439929228813265e-7 +
                         2.71155556874348757815e-5) * r +
                        .0012426609473880784386) * r + .026532189526576123093) *
                      r + .29656057182850489123) * r +
                     1.7848265399172913358) * r + 5.4637849111641143699) *
                   r + 6.6579046435011037772)
                  / (((((((r *
                           2.04426310338993978564e-15 + 1.4215117583164458887e-7) *
                          r + 1.8463183175100546818e-5) * r +
                         7.868691311456132591e-4) * r + .0148753612908506148525)
                       * r + .13692988092273580531) * r +
                      .59983220655588793769) * r + 1.);
        }

        if (q < 0.0) {
            val = -val;
        }
        /* return (q >= 0.)? r : -r ;*/
    }
    return mu + sigma * val;
}

static double fsign(double x, double y) {
#ifdef IEEE_754
    if (ISNAN(x) || ISNAN(y)) {
        return x + y;
    }
#endif
    return ((y >= 0) ? fabs(x) : -fabs(x));
}

static int imax2(int x, int y) {
    return (x < y) ? y : x;
}

static int imin2(int x, int y) {
    return (x < y) ? x : y;
}

static double igraph_norm_rand(igraph_rng_t *rng) {

    double u1;

#define BIG 134217728 /* 2^27 */
    /* unif_rand() alone is not of high enough precision */
    u1 = igraph_rng_get_unif01(rng);
    u1 = (int)(BIG * u1) + igraph_rng_get_unif01(rng);
    return igraph_qnorm5(u1 / BIG, 0.0, 1.0, 1, 0);
}

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000-2002 the R Development Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA.
 *
 *  SYNOPSIS
 *
 *    #include 
 *    double exp_rand(void);
 *
 *  DESCRIPTION
 *
 *    Random variates from the standard exponential distribution.
 *
 *  REFERENCE
 *
 *    Ahrens, J.H. and Dieter, U. (1972).
 *    Computer methods for sampling from the exponential and
 *    normal distributions.
 *    Comm. ACM, 15, 873-882.
 */

double igraph_exp_rand(igraph_rng_t *rng) {
    /* q[k-1] = sum(log(2)^k / k!)  k=1,..,n, */
    /* The highest n (here 8) is determined by q[n-1] = 1.0 */
    /* within standard precision */
    const double q[] = {
        0.6931471805599453,
        0.9333736875190459,
        0.9888777961838675,
        0.9984959252914960,
        0.9998292811061389,
        0.9999833164100727,
        0.9999985691438767,
        0.9999998906925558,
        0.9999999924734159,
        0.9999999995283275,
        0.9999999999728814,
        0.9999999999985598,
        0.9999999999999289,
        0.9999999999999968,
        0.9999999999999999,
        1.0000000000000000
    };
    double a, u, ustar, umin;
    int i;

    a = 0.;
    /* precaution if u = 0 is ever returned */
    u = igraph_rng_get_unif01(rng);
    while (u <= 0.0 || u >= 1.0) {
        u = igraph_rng_get_unif01(rng);
    }
    for (;;) {
        u += u;
        if (u > 1.0) {
            break;
        }
        a += q[0];
    }
    u -= 1.;

    if (u <= q[0]) {
        return a + u;
    }

    i = 0;
    ustar = igraph_rng_get_unif01(rng);
    umin = ustar;
    do {
        ustar = igraph_rng_get_unif01(rng);
        if (ustar < umin) {
            umin = ustar;
        }
        i++;
    } while (u > q[i]);
    return a + umin * q[0];
}

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000-2001 The R Development Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA.
 *
 *  SYNOPSIS
 *
 *    #include 
 *    double rpois(double lambda)
 *
 *  DESCRIPTION
 *
 *    Random variates from the Poisson distribution.
 *
 *  REFERENCE
 *
 *    Ahrens, J.H. and Dieter, U. (1982).
 *    Computer generation of Poisson deviates
 *    from modified normal distributions.
 *    ACM Trans. Math. Software 8, 163-179.
 */

#define a0  -0.5
#define a1   0.3333333
#define a2  -0.2500068
#define a3   0.2000118
#define a4  -0.1661269
#define a5   0.1421878
#define a6  -0.1384794
#define a7   0.1250060

#define one_7   0.1428571428571428571
#define one_12  0.0833333333333333333
#define one_24  0.0416666666666666667

#define repeat for(;;)

#define FALSE 0
#define TRUE  1
#define M_1_SQRT_2PI    0.398942280401432677939946059934     /* 1/sqrt(2pi) */

static double igraph_rpois(igraph_rng_t *rng, double mu) {
    /* Factorial Table (0:9)! */
    const double fact[10] = {
        1., 1., 2., 6., 24., 120., 720., 5040., 40320., 362880.
    };

    /* These are static --- persistent between calls for same mu : */
    static IGRAPH_THREAD_LOCAL int l, m;

    static IGRAPH_THREAD_LOCAL double b1, b2, c, c0, c1, c2, c3;
    static IGRAPH_THREAD_LOCAL double pp[36], p0, p, q, s, d, omega;
    static IGRAPH_THREAD_LOCAL double big_l;/* integer "w/o overflow" */
    static IGRAPH_THREAD_LOCAL double muprev = 0., muprev2 = 0.;/*, muold    = 0.*/

    /* Local Vars  [initialize some for -Wall]: */
    double del, difmuk = 0., E = 0., fk = 0., fx, fy, g, px, py, t, u = 0., v, x;
    double pois = -1.;
    int k, kflag, big_mu, new_big_mu = FALSE;

    if (!igraph_finite(mu)) {
        ML_ERR_return_NAN;
    }

    if (mu <= 0.) {
        return 0.;
    }

    big_mu = mu >= 10.;
    if (big_mu) {
        new_big_mu = FALSE;
    }

    if (!(big_mu && mu == muprev)) {/* maybe compute new persistent par.s */

        if (big_mu) {
            new_big_mu = TRUE;
            /* Case A. (recalculation of s,d,l  because mu has changed):
             * The Poisson probabilities pk exceed the discrete normal
             * probabilities fk whenever k >= m(mu).
             */
            muprev = mu;
            s = sqrt(mu);
            d = 6. * mu * mu;
            big_l = floor(mu - 1.1484);
            /* = an upper bound to m(mu) for all mu >= 10.*/
        } else { /* Small mu ( < 10) -- not using normal approx. */

            /* Case B. (start new table and calculate p0 if necessary) */

            /*muprev = 0.;-* such that next time, mu != muprev ..*/
            if (mu != muprev) {
                muprev = mu;
                m = imax2(1, (int) mu);
                l = 0; /* pp[] is already ok up to pp[l] */
                q = p0 = p = exp(-mu);
            }

            repeat {
                /* Step U. uniform sample for inversion method */
                u = igraph_rng_get_unif01(rng);
                if (u <= p0) {
                    return 0.;
                }

                /* Step T. table comparison until the end pp[l] of the
                   pp-table of cumulative Poisson probabilities
                   (0.458 > ~= pp[9](= 0.45792971447) for mu=10 ) */
                if (l != 0) {
                    for (k = (u <= 0.458) ? 1 : imin2(l, m);  k <= l; k++)
                        if (u <= pp[k]) {
                            return (double)k;
                        }
                    if (l == 35) { /* u > pp[35] */
                        continue;
                    }
                }
                /* Step C. creation of new Poisson
                   probabilities p[l..] and their cumulatives q =: pp[k] */
                l++;
                for (k = l; k <= 35; k++) {
                    p *= mu / k;
                    q += p;
                    pp[k] = q;
                    if (u <= q) {
                        l = k;
                        return (double)k;
                    }
                }
                l = 35;
            } /* end(repeat) */
        }/* mu < 10 */

    } /* end {initialize persistent vars} */

    /* Only if mu >= 10 : ----------------------- */

    /* Step N. normal sample */
    g = mu + s * igraph_norm_rand(rng);/* norm_rand() ~ N(0,1), standard normal */

    if (g >= 0.) {
        pois = floor(g);
        /* Step I. immediate acceptance if pois is large enough */
        if (pois >= big_l) {
            return pois;
        }
        /* Step S. squeeze acceptance */
        fk = pois;
        difmuk = mu - fk;
        u = igraph_rng_get_unif01(rng); /* ~ U(0,1) - sample */
        if (d * u >= difmuk * difmuk * difmuk) {
            return pois;
        }
    }

    /* Step P. preparations for steps Q and H.
       (recalculations of parameters if necessary) */

    if (new_big_mu || mu != muprev2) {
        /* Careful! muprev2 is not always == muprev
        because one might have exited in step I or S
        */
        muprev2 = mu;
        omega = M_1_SQRT_2PI / s;
        /* The quantities b1, b2, c3, c2, c1, c0 are for the Hermite
         * approximations to the discrete normal probabilities fk. */

        b1 = one_24 / mu;
        b2 = 0.3 * b1 * b1;
        c3 = one_7 * b1 * b2;
        c2 = b2 - 15. * c3;
        c1 = b1 - 6. * b2 + 45. * c3;
        c0 = 1. - b1 + 3. * b2 - 15. * c3;
        c = 0.1069 / mu; /* guarantees majorization by the 'hat'-function. */
    }

    if (g >= 0.) {
        /* 'Subroutine' F is called (kflag=0 for correct return) */
        kflag = 0;
        goto Step_F;
    }


    repeat {
        /* Step E. Exponential Sample */

        E = igraph_exp_rand(rng);/* ~ Exp(1) (standard exponential) */

        /*  sample t from the laplace 'hat'
            (if t <= -0.6744 then pk < fk for all mu >= 10.) */
        u = 2 * igraph_rng_get_unif01(rng) - 1.;
        t = 1.8 + fsign(E, u);
        if (t > -0.6744) {
            pois = floor(mu + s * t);
            fk = pois;
            difmuk = mu - fk;

            /* 'subroutine' F is called (kflag=1 for correct return) */
            kflag = 1;

Step_F: /* 'subroutine' F : calculation of px,py,fx,fy. */

            if (pois < 10) { /* use factorials from table fact[] */
                px = -mu;
                py = pow(mu, pois) / fact[(int)pois];
            } else {
                /* Case pois >= 10 uses polynomial approximation
                   a0-a7 for accuracy when advisable */
                del = one_12 / fk;
                del = del * (1. - 4.8 * del * del);
                v = difmuk / fk;
                if (fabs(v) <= 0.25)
                    px = fk * v * v * (((((((a7 * v + a6) * v + a5) * v + a4) *
                                          v + a3) * v + a2) * v + a1) * v + a0)
                    - del;
                else { /* |v| > 1/4 */
                    px = fk * log(1. + v) - difmuk - del;
                }
                py = M_1_SQRT_2PI / sqrt(fk);
            }
            x = (0.5 - difmuk) / s;
            x *= x;/* x^2 */
            fx = -0.5 * x;
            fy = omega * (((c3 * x + c2) * x + c1) * x + c0);
            if (kflag > 0) {
                /* Step H. Hat acceptance (E is repeated on rejection) */
                if (c * fabs(u) <= py * exp(px + E) - fy * exp(fx + E)) {
                    break;
                }
            } else
                /* Step Q. Quotient acceptance (rare case) */
                if (fy - u * fy <= py * exp(px - fx)) {
                    break;
                }
        }/* t > -.67.. */
    }
    return pois;
}

#undef a1
#undef a2
#undef a3
#undef a4
#undef a5
#undef a6
#undef a7

static double igraph_rgeom(igraph_rng_t *rng, double p) {
    if (igraph_is_nan(p) || p <= 0 || p > 1) {
        ML_ERR_return_NAN;
    }

    return igraph_rpois(rng, igraph_exp_rand(rng) * ((1 - p) / p));
}

/* This is from nmath/rbinom.c */

#define repeat for(;;)

static double igraph_rbinom(igraph_rng_t *rng, double nin, double pp) {
    /* FIXME: These should become THREAD_specific globals : */

    static IGRAPH_THREAD_LOCAL double c, fm, npq, p1, p2, p3, p4, qn;
    static IGRAPH_THREAD_LOCAL double xl, xll, xlr, xm, xr;

    static IGRAPH_THREAD_LOCAL double psave = -1.0;
    static IGRAPH_THREAD_LOCAL int nsave = -1;
    static IGRAPH_THREAD_LOCAL int m;

    double f, f1, f2, u, v, w, w2, x, x1, x2, z, z2;
    double p, q, np, g, r, al, alv, amaxp, ffm, ynorm;
    int i, ix, k, n;

    if (!igraph_finite(nin)) {
        ML_ERR_return_NAN;
    }
    n = floor(nin + 0.5);
    if (n != nin) {
        ML_ERR_return_NAN;
    }

    if (!igraph_finite(pp) ||
        /* n=0, p=0, p=1 are not errors */
        n < 0 || pp < 0. || pp > 1.) {
        ML_ERR_return_NAN;
    }

    if (n == 0 || pp == 0.) {
        return 0;
    }
    if (pp == 1.) {
        return n;
    }

    p = fmin(pp, 1. - pp);
    q = 1. - p;
    np = n * p;
    r = p / q;
    g = r * (n + 1);

    /* Setup, perform only when parameters change [using static (globals): */

    /* FIXING: Want this thread safe
       -- use as little (thread globals) as possible
    */
    if (pp != psave || n != nsave) {
        psave = pp;
        nsave = n;
        if (np < 30.0) {
            /* inverse cdf logic for mean less than 30 */
            qn = pow(q, (double) n);
            goto L_np_small;
        } else {
            ffm = np + p;
            m = ffm;
            fm = m;
            npq = np * q;
            p1 = (int)(2.195 * sqrt(npq) - 4.6 * q) + 0.5;
            xm = fm + 0.5;
            xl = xm - p1;
            xr = xm + p1;
            c = 0.134 + 20.5 / (15.3 + fm);
            al = (ffm - xl) / (ffm - xl * p);
            xll = al * (1.0 + 0.5 * al);
            al = (xr - ffm) / (xr * q);
            xlr = al * (1.0 + 0.5 * al);
            p2 = p1 * (1.0 + c + c);
            p3 = p2 + c / xll;
            p4 = p3 + c / xlr;
        }
    } else if (n == nsave) {
        if (np < 30.0) {
            goto L_np_small;
        }
    }

    /*-------------------------- np = n*p >= 30 : ------------------- */
    repeat {
        u = igraph_rng_get_unif01(rng) * p4;
        v = igraph_rng_get_unif01(rng);
        /* triangular region */
        if (u <= p1) {
            ix = xm - p1 * v + u;
            goto finis;
        }
        /* parallelogram region */
        if (u <= p2) {
            x = xl + (u - p1) / c;
            v = v * c + 1.0 - fabs(xm - x) / p1;
            if (v > 1.0 || v <= 0.) {
                continue;
            }
            ix = x;
        } else {
            if (u > p3) { /* right tail */
                ix = xr - log(v) / xlr;
                if (ix > n) {
                    continue;
                }
                v = v * (u - p3) * xlr;
            } else {/* left tail */
                ix = xl + log(v) / xll;
                if (ix < 0) {
                    continue;
                }
                v = v * (u - p2) * xll;
            }
        }
        /* determine appropriate way to perform accept/reject test */
        k = abs(ix - m);
        if (k <= 20 || k >= npq / 2 - 1) {
            /* explicit evaluation */
            f = 1.0;
            if (m < ix) {
                for (i = m + 1; i <= ix; i++) {
                    f *= (g / i - r);
                }
            } else if (m != ix) {
                for (i = ix + 1; i <= m; i++) {
                    f /= (g / i - r);
                }
            }
            if (v <= f) {
                goto finis;
            }
        } else {
            /* squeezing using upper and lower bounds on log(f(x)) */
            amaxp = (k / npq) * ((k * (k / 3. + 0.625) + 0.1666666666666) / npq + 0.5);
            ynorm = -k * k / (2.0 * npq);
            alv = log(v);
            if (alv < ynorm - amaxp) {
                goto finis;
            }
            if (alv <= ynorm + amaxp) {
                /* Stirling's formula to machine accuracy */
                /* for the final acceptance/rejection test */
                x1 = ix + 1;
                f1 = fm + 1.0;
                z = n + 1 - fm;
                w = n - ix + 1.0;
                z2 = z * z;
                x2 = x1 * x1;
                f2 = f1 * f1;
                w2 = w * w;
                if (alv <= xm * log(f1 / x1) + (n - m + 0.5) * log(z / w) + (ix - m) * log(w * p / (x1 * q)) + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / f2) / f2) / f2) / f2) / f1 / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / z2) / z2) / z2) / z2) / z / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / x2) / x2) / x2) / x2) / x1 / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / w2) / w2) / w2) / w2) / w / 166320.) {
                    goto finis;
                }
            }
        }
    }

L_np_small:
    /*---------------------- np = n*p < 30 : ------------------------- */

    repeat {
        ix = 0;
        f = qn;
        u = igraph_rng_get_unif01(rng);
        repeat {
            if (u < f) {
                goto finis;
            }
            if (ix > 110) {
                break;
            }
            u -= f;
            ix++;
            f *= (g / ix - r);
        }
    }
finis:
    if (psave > 0.5) {
        ix = n - ix;
    }
    return (double)ix;
}

static igraph_real_t igraph_rexp(igraph_rng_t *rng, double rate) {
    igraph_real_t scale = 1.0 / rate;
    if (!IGRAPH_FINITE(scale) || scale <= 0.0) {
        if (scale == 0.0) {
            return 0.0;
        }
        return IGRAPH_NAN;
    }
    return scale * igraph_exp_rand(rng);
}

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000      The R Core Team
 *  Copyright (C) 2003      The R Foundation
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 *
 *  SYNOPSIS
 *
 *      double dnorm4(double x, double mu, double sigma, int give_log)
 *            {dnorm (..) is synonymous and preferred inside R}
 *
 *  DESCRIPTION
 *
 *      Compute the density of the normal distribution.
 */

double igraph_dnorm(double x, double mu, double sigma, int give_log) {
#ifdef IEEE_754
    if (ISNAN(x) || ISNAN(mu) || ISNAN(sigma)) {
        return x + mu + sigma;
    }
#endif
    if (!igraph_finite(sigma)) {
        return R_D__0;
    }
    if (!igraph_finite(x) && mu == x) {
        return ML_NAN;    /* x-mu is NaN */
    }
    if (sigma <= 0) {
        if (sigma < 0) {
            ML_ERR_return_NAN;
        }
        /* sigma == 0 */
        return (x == mu) ? ML_POSINF : R_D__0;
    }
    x = (x - mu) / sigma;

    if (!igraph_finite(x)) {
        return R_D__0;
    }
    return (give_log ?
            -(M_LN_SQRT_2PI  +  0.5 * x * x + log(sigma)) :
            M_1_SQRT_2PI * exp(-0.5 * x * x)  /   sigma);
    /* M_1_SQRT_2PI = 1 / sqrt(2 * pi) */
}

/* This is from nmath/rgamma.c */

/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000--2008 The R Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 *
 *  SYNOPSIS
 *
 *    #include 
 *    double rgamma(double a, double scale);
 *
 *  DESCRIPTION
 *
 *    Random variates from the gamma distribution.
 *
 *  REFERENCES
 *
 *    [1] Shape parameter a >= 1.  Algorithm GD in:
 *
 *    Ahrens, J.H. and Dieter, U. (1982).
 *    Generating gamma variates by a modified
 *    rejection technique.
 *    Comm. ACM, 25, 47-54.
 *
 *
 *    [2] Shape parameter 0 < a < 1. Algorithm GS in:
 *
 *    Ahrens, J.H. and Dieter, U. (1974).
 *    Computer methods for sampling from gamma, beta,
 *    poisson and binomial distributions.
 *    Computing, 12, 223-246.
 *
 *    Input: a = parameter (mean) of the standard gamma distribution.
 *    Output: a variate from the gamma(a)-distribution
 */

static double igraph_rgamma(igraph_rng_t *rng, double a, double scale) {
    /* Constants : */
    static const double sqrt32 = 5.656854;
    static const double exp_m1 = 0.36787944117144232159;/* exp(-1) = 1/e */

    /* Coefficients q[k] - for q0 = sum(q[k]*a^(-k))
     * Coefficients a[k] - for q = q0+(t*t/2)*sum(a[k]*v^k)
     * Coefficients e[k] - for exp(q)-1 = sum(e[k]*q^k)
     */
    static const double q1 = 0.04166669;
    static const double q2 = 0.02083148;
    static const double q3 = 0.00801191;
    static const double q4 = 0.00144121;
    static const double q5 = -7.388e-5;
    static const double q6 = 2.4511e-4;
    static const double q7 = 2.424e-4;

    static const double a1 = 0.3333333;
    static const double a2 = -0.250003;
    static const double a3 = 0.2000062;
    static const double a4 = -0.1662921;
    static const double a5 = 0.1423657;
    static const double a6 = -0.1367177;
    static const double a7 = 0.1233795;

    /* State variables [FIXME for threading!] :*/
    static double aa = 0.;
    static double aaa = 0.;
    static double s, s2, d;    /* no. 1 (step 1) */
    static double q0, b, si, c;/* no. 2 (step 4) */

    double e, p, q, r, t, u, v, w, x, ret_val;

    if (!igraph_finite(a) || !igraph_finite(scale) || a < 0.0 || scale <= 0.0) {
        if (scale == 0.) {
            return 0.;
        }
        ML_ERR_return_NAN;
    }

    if (a < 1.) { /* GS algorithm for parameters a < 1 */
        if (a == 0) {
            return 0.;
        }
        e = 1.0 + exp_m1 * a;
        repeat {
            p = e * igraph_rng_get_unif01(rng);
            if (p >= 1.0) {
                x = -log((e - p) / a);
                if (igraph_exp_rand(rng) >= (1.0 - a) * log(x)) {
                    break;
                }
            } else {
                x = exp(log(p) / a);
                if (igraph_exp_rand(rng) >= x) {
                    break;
                }
            }
        }
        return scale * x;
    }

    /* --- a >= 1 : GD algorithm --- */

    /* Step 1: Recalculations of s2, s, d if a has changed */
    if (a != aa) {
        aa = a;
        s2 = a - 0.5;
        s = sqrt(s2);
        d = sqrt32 - s * 12.0;
    }
    /* Step 2: t = standard normal deviate,
               x = (s,1/2) -normal deviate. */

    /* immediate acceptance (i) */
    t = igraph_norm_rand(rng);
    x = s + 0.5 * t;
    ret_val = x * x;
    if (t >= 0.0) {
        return scale * ret_val;
    }

    /* Step 3: u = 0,1 - uniform sample. squeeze acceptance (s) */
    u = igraph_rng_get_unif01(rng);
    if (d * u <= t * t * t) {
        return scale * ret_val;
    }

    /* Step 4: recalculations of q0, b, si, c if necessary */

    if (a != aaa) {
        aaa = a;
        r = 1.0 / a;
        q0 = ((((((q7 * r + q6) * r + q5) * r + q4) * r + q3) * r
               + q2) * r + q1) * r;

        /* Approximation depending on size of parameter a */
        /* The constants in the expressions for b, si and c */
        /* were established by numerical experiments */

        if (a <= 3.686) {
            b = 0.463 + s + 0.178 * s2;
            si = 1.235;
            c = 0.195 / s - 0.079 + 0.16 * s;
        } else if (a <= 13.022) {
            b = 1.654 + 0.0076 * s2;
            si = 1.68 / s + 0.275;
            c = 0.062 / s + 0.024;
        } else {
            b = 1.77;
            si = 0.75;
            c = 0.1515 / s;
        }
    }
    /* Step 5: no quotient test if x not positive */

    if (x > 0.0) {
        /* Step 6: calculation of v and quotient q */
        v = t / (s + s);
        if (fabs(v) <= 0.25)
            q = q0 + 0.5 * t * t * ((((((a7 * v + a6) * v + a5) * v + a4) * v
                                      + a3) * v + a2) * v + a1) * v;
        else {
            q = q0 - s * t + 0.25 * t * t + (s2 + s2) * log(1.0 + v);
        }


        /* Step 7: quotient acceptance (q) */
        if (log(1.0 - u) <= q) {
            return scale * ret_val;
        }
    }

    repeat {
        /* Step 8: e = standard exponential deviate
         *  u =  0,1 -uniform deviate
         *  t = (b,si)-double exponential (laplace) sample */
        e = igraph_exp_rand(rng);
        u = igraph_rng_get_unif01(rng);
        u = u + u - 1.0;
        if (u < 0.0) {
            t = b - si * e;
        } else {
            t = b + si * e;
        }
        /* Step  9:  rejection if t < tau(1) = -0.71874483771719 */
        if (t >= -0.71874483771719) {
            /* Step 10:  calculation of v and quotient q */
            v = t / (s + s);
            if (fabs(v) <= 0.25)
                q = q0 + 0.5 * t * t *
                ((((((a7 * v + a6) * v + a5) * v + a4) * v + a3) * v
                  + a2) * v + a1) * v;
            else {
                q = q0 - s * t + 0.25 * t * t + (s2 + s2) * log(1.0 + v);
            }
            /* Step 11:  hat acceptance (h) */
            /* (if q not positive go to step 8) */
            if (q > 0.0) {
                w = expm1(q);
                /*  ^^^^^ original code had approximation with rel.err < 2e-7 */
                /* if t is rejected sample again at step 8 */
                if (c * fabs(u) <= w * exp(e - 0.5 * t * t)) {
                    break;
                }
            }
        }
    } /* repeat .. until  `t' is accepted */
    x = s + 0.5 * t;
    return scale * x * x;
}

#endif

int igraph_rng_get_dirichlet(igraph_rng_t *rng,
                             const igraph_vector_t *alpha,
                             igraph_vector_t *result) {

    igraph_integer_t len = igraph_vector_size(alpha);
    igraph_integer_t j;
    igraph_real_t sum = 0.0;

    if (len < 2) {
        IGRAPH_ERROR("Dirichlet parameter vector too short, must "
                     "have at least two entries", IGRAPH_EINVAL);
    }
    if (igraph_vector_min(alpha) <= 0) {
        IGRAPH_ERROR("Dirichlet concentration parameters must be positive",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_resize(result, len));

    RNG_BEGIN();

    for (j = 0; j < len; j++) {
        VECTOR(*result)[j] = igraph_rng_get_gamma(rng, VECTOR(*alpha)[j], 1.0);
        sum += VECTOR(*result)[j];
    }
    for (j = 0; j < len; j++) {
        VECTOR(*result)[j] /= sum;
    }

    RNG_END();

    return IGRAPH_SUCCESS;
}

/**********************************************************
 * Testing purposes                                       *
 *********************************************************/

/* int main() { */

/*   int i; */

/*   RNG_BEGIN(); */

/*   for (i=0; i<1000; i++) { */
/*     printf("%li ", RNG_INTEGER(1,10)); */
/*   } */
/*   printf("\n"); */

/*   for (i=0; i<1000; i++) { */
/*     printf("%f ", RNG_UNIF(0,1)); */
/*   } */
/*   printf("\n"); */

/*   for (i=0; i<1000; i++) { */
/*     printf("%f ", RNG_NORMAL(0,5)); */
/*   } */
/*   printf("\n"); */

/*   RNG_END(); */

/*   return 0; */
/* } */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5431414
igraph-0.9.9/vendor/source/igraph/src/scg/0000755000175100001710000000000000000000000021215 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg.c0000644000175100001710000027053200000000000022146 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-12  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    The grouping function takes as argument 'nev' eigenvectors and
 *    and tries to minimize the eigenpair shifts induced by the coarse
 *    graining (Section 5 of the above reference). The eigenvectors are
 *    stored in a 'nev'x'n' matrix 'v'.
 *    The 'algo' parameter can take the following values
 *      1  ->  Optimal method (sec. 5.3.1)
 *      2  ->  Intervals+k-means (sec. 5.3.3)
 *      3  ->  Intervals (sec. 5.3.2)
 *      4  ->  Exact SCG (sec. 5.4.1--last paragraph)
 *    'nt' is a vector of length 'nev' giving either the size of the
 *    partitions (if algo = 1) or the number of intervals to cut the
 *    eigenvectors if algo = 2 or algo = 3. When algo = 4 this parameter
 *    is ignored. 'maxiter' fixes the maximum number of iterations of
 *    the k-means algorithm, and is only considered when algo = 2.
 *    All the algorithms try to find a minimizing partition of
 *    ||v_i-Pv_i|| where P is a problem-specific projector and v_i denotes
 *    the eigenvectors stored in v. The final partition is worked out
 *    as decribed in Method 1 of Section 5.4.2.
 *    'matrix' provides the type of SCG (i.e. the form of P). So far,
 *    the options are those described in section 6, that is:
 *      1  ->  Symmetric (sec. 6.1)
 *      2  ->  Laplacian (sec. 6.2)
 *      3  ->  Stochastic (sec. 6.3)
 *    In the stochastic case, a valid distribution probability 'p' must be
 *    provided. In all other cases, 'p' is ignored and can be set to NULL.
 *    The group labels in the final partition are given in 'gr' as positive
 *    consecutive integers starting from 0.
 */

#include "igraph_scg.h"

#include "igraph_eigen.h"
#include "igraph_interface.h"
#include "igraph_structural.h"
#include "igraph_community.h"
#include "igraph_constructors.h"
#include "igraph_conversion.h"
#include "igraph_memory.h"
#include "igraph_qsort.h"

#include "misc/conversion_internal.h"

#include "scg_headers.h"

#include "math.h"

/**
 * \section about_scg
 *
 * 
 * The SCG functions provide a framework, called Spectral Coarse Graining
 * (SCG), for reducing large graphs while preserving their
 * spectral-related features, that is features
 * closely related with the eigenvalues and eigenvectors of a graph
 * matrix (which for now can be the adjacency, the stochastic, or the
 * Laplacian matrix).
 * 
 *
 * 
 * Common examples of such features comprise the first-passage-time of
 * random walkers on Markovian graphs, thermodynamic properties of
 * lattice models in statistical physics (e.g. Ising model), and the
 * epidemic threshold of epidemic network models (SIR and SIS models).
 * 
 *
 * 
 * SCG differs from traditional clustering schemes by producing a
 * coarse-grained graph (not just a partition of
 * the vertices), representative of the original one. As shown in [1],
 * Principal Component Analysis can be viewed as a particular SCG,
 * called exact SCG, where the matrix to be
 * coarse-grained is the covariance matrix of some data set.
 * 
 *
 * 
 * SCG should be of interest to practitioners of various
 * fields dealing with problems where matrix eigenpairs play an important
 * role, as for instance is the case of dynamical processes on networks.
 * 
 *
 * 
SCG in brief
 * 
 * The main idea of SCG is to operate on a matrix a shrinkage operation
 * specifically designed to preserve some of the matrix eigenpairs while
 * not altering other important matrix features (such as its structure).
 * Mathematically, this idea was expressed as follows. Consider a
 * (complex) n x n matrix M and form the product
 * 

 *   M'=LMR*,
 * 

 * where n' < n and L, R are from C[n'xn]} and are such
 * that LR*=I[n'] (R* denotes the conjugate transpose of R). Under
 * these assumptions, it can be shown that P=R*L is an n'-rank
 * projector and that, if (lambda, v) is a (right)
 * eigenpair of M (i.e. Mv=lambda v} and P is orthogonal, there exists
 * an eigenvalue lambda' of M' such that
 * 

 *   |lambda-lambda'| <= const ||e[P](v)||
 *   [1+O(||e[P](v)||2)],
 * 

 * where ||e[P](v)||=||v-Pv||. Hence, if P (or equivalently
 * L, R) is chosen so as to make ||e[P](v)|| as small as possible, one
 * can preserve to any desired level the original eigenvalue
 * lambda in the coarse-grained matrix M';
 * under extra assumptions on M, this result can be generalized to
 * eigenvectors [1]. This leads to the following generic definition of a
 * SCG problem.
 * 
 *
 * 
 * Given M (C[nxn]) and (lambda, v), a (right) eigenpair of M to be
 * preserved by the coarse graining, the problem is to find a projector
 * P' solving
 * 

 *   min(||e[P](v)||, p in Omega),
 * 

 * where Omega is a set of projectors in C[nxn] described by some
 * ad hoc constraints c[1], ..., c[r]
 * (e.g. c[1]: P in R[nxn], c[2]: P=t(P), c[3]: P[i,j] >= 0}, etc).
 * 
 *
 * 
 * Choosing pertinent constraints to solve the SCG problem is of great
 * importance in applications. For instance, in the absence of
 * constraints the SCG problem is solved trivially by
 * P'=vv* (v is assumed normalized). We have designed a particular
 * constraint, called homogeneous mixing, which
 * ensures that vertices belonging to the same group are merged
 * consistently from a physical point of view (see [1] for
 * details). Under this constraint the SCG problem reduces to finding
 * the partition of 1, ..., n (labeling the original vertices)
 * minimizing
 * 

 *   ||e[P](v)||2 =
 *   sum([v(i)-(Pv)(i)]2;
 *   alpha=1,...,n', i in alpha),
 * 

 * where alpha denotes a group (i.e. a block) in a partition of
 * {1, ..., n}, and |alpha| is the number of elements in alpha.
 * 
 *
 * 
 * If M is symmetric or stochastic, for instance, then it may be
 * desirable (or mandatory) to choose L, R so that M' is symmetric or
 * stochastic as well. This structural constraint
 * has led to the construction of particular semi-projectors for
 * symmetric [1], stochastic [3] and Laplacian [2] matrices, that are
 * made available.
 * 
 *
 * 
 * In short, the coarse graining of matrices and graphs involves:
 * \olist
 *   \oli Retrieving a matrix or a graph matrix M from the
 *     problem.
 *   \oli Computing the eigenpairs of M to be preserved in the
 *     coarse-grained graph or matrix.
 *   \oli Setting some problem-specific constraints (e.g. dimension of
 *     the coarse-grained object).
 *   \oli Solving the constrained SCG problem, that is finding P'.
 *   \oli Computing from P' two semi-projectors L' and R'
 *     (e.g. following the method proposed in [1]).
 *   \oli Working out the product M'=L'MR'* and, if needed, defining
 *     from M' a coarse-grained graph.
 * \endolist
 * 
 * 

 *
 * 
Functions for performing SCG
 * 
 * The main functions are \ref igraph_scg_adjacency(), \ref
 * igraph_scg_laplacian() and \ref igraph_scg_stochastic().
 * These functions handle all the steps involved in the
 * Spectral Coarse Graining (SCG) of some particular matrices and graphs
 * as described above and in reference [1]. In more details,
 * they compute some prescribed eigenpairs of a matrix or a
 * graph matrix, (for now adjacency, Laplacian and stochastic matrices are
 * available), work out an optimal partition to preserve the eigenpairs,
 * and finally output a coarse-grained matrix or graph along with other
 * useful information.
 * 
 *
 * 
 * These steps can also be carried out independently: (1) Use
 * \ref igraph_get_adjacency(), \ref igraph_get_sparsemat(),
 * \ref igraph_laplacian(), \ref igraph_get_stochastic() or \ref
 * igraph_get_stochastic_sparsemat() to compute a matrix M.
 * (2) Work out some prescribed eigenpairs of M e.g. by
 * means of \ref igraph_arpack_rssolve() or \ref
 * igraph_arpack_rnsolve(). (3) Invoke one the four
 * algorithms of the function \ref igraph_scg_grouping() to get a
 * partition that will preserve the eigenpairs in the coarse-grained
 * matrix. (4) Compute the semi-projectors L and R using
 * \ref igraph_scg_semiprojectors() and from there the coarse-grained
 * matrix M'=LMR*. If necessary, construct a coarse-grained graph from
 * M' (e.g. as in [1]).
 * 
 * 

 *
 * 
References
 * 
 * [1] D. Morton de Lachapelle, D. Gfeller, and P. De Los Rios,
 * Shrinking Matrices while Preserving their Eigenpairs with Application
 * to the Spectral Coarse Graining of Graphs. Submitted to
 * SIAM Journal on Matrix Analysis and
 * Applications, 2008.
 * http://people.epfl.ch/david.morton
 * 
 * 
 * [2] D. Gfeller, and P. De Los Rios, Spectral Coarse Graining and
 * Synchronization in Oscillator Networks.
 * Physical Review Letters,
 * 100(17), 2008.
 * http://arxiv.org/abs/0708.2055
 * 
 * 
 * [3] D. Gfeller, and P. De Los Rios, Spectral Coarse Graining of Complex
 * Networks, Physical Review Letters,
 * 99(3), 2007.
 * http://arxiv.org/abs/0706.0812
 * 
 * 

 */

/**
 * \function igraph_scg_grouping
 * \brief SCG problem solver.
 *
 * This function solves the Spectral Coarse Graining (SCG) problem;
 * either exactly, or approximately but faster.
 *
 * 
 * The algorithm \c IGRAPH_SCG_OPTIMUM solves the SCG problem exactly
 * for each eigenvector in \p V. The running time of this algorithm is
 * O(max(nt) m^2) for the symmetric and Laplacian matrix problems.
 * It is O(m^3) for the stochastic problem. Here m is the number
 * of rows in \p V. In all three cases, the memory usage is O(m^2).
 *
 * 
 * The algorithms \c IGRAPH_SCG_INTERV and \c IGRAPH_SCG_INTERV_KM solve
 * the SCG problem approximately by performing a (for now) constant
 * binning of the components of the eigenvectors, that is nt_vec[i]
 * constant-size bins are used to partition the ith eigenvector in \c V.
 * When \p algo is \c IGRAPH_SCG_INTERV_KM, the (Lloyd) k-means algorithm is
 * run on each partition obtained by \c IGRAPH_SCG_INTERV to improve
 * accuracy.
 *
 * 
 * Once a minimizing partition (either exact or approximate) has been
 * found for each eigenvector, the final grouping is worked out as
 * follows: two vertices are grouped together in the final partition if
 * they are grouped together in each minimizing partition. In general, the
 * size of the final partition is not known in advance when the number
 * of columns in \p V is larger than one.
 *
 * 
 * Finally, the algorithm \c IGRAPH_SCG_EXACT groups the vertices with
 * equal components in each eigenvector. The last three algorithms
 * essentially have linear running time and memory load.
 *
 * \param V The matrix of eigenvectors to be preserved by coarse
 *    graining, each column is an eigenvector.
 * \param groups Pointer to an initialized vector; the result of the
 *    SCG is stored here.
 * \param nt Positive integer. When \p algo is \c IGRAPH_SCG_OPTIMUM,
 *    it gives the number of groups to partition each eigenvector
 *    separately. When \p algo is \c IGRAPH_SCG_INTERV or \c
 *    IGRAPH_SCG_INTERV_KM, it gives the number of intervals to
 *    partition each eigenvector. This is ignored when \p algo is \c
 *    IGRAPH_SCG_EXACT.
 * \param nt_vec May be (1) a numeric vector of length one, or
 *    (2) a vector of the same length as the number of eigenvectors given in \p V, or
 *    (3) a \c NULL pointer.
 *    If not \c NULL, then this argument gives the number of
 *    groups or intervals, and \p nt is ignored. Different number of
 *    groups or intervals can be specified for each eigenvector.
 * \param mtype The type of semi-projectors used in the SCG. Possible
 *    values are \c IGRAPH_SCG_SYMMETRIC, \c IGRAPH_SCG_STOCHASTIC and
 *    \c IGRAPH_SCG_LAPLACIAN.
 * \param algo The algorithm to solve the SCG problem. Possible
 *    values: \c IGRAPH_SCG_OPTIMUM, \c IGRAPH_SCG_INTERV_KM, \c
 *    IGRAPH_SCG_INTERV and \c IGRAPH_SCG_EXACT. Please see the
 *    details about them above.
 * \param p A probability vector, or \c NULL. This argument must be
 *    given if \p mtype is \c IGRAPH_SCG_STOCHASTIC, but it is ignored
 *    otherwise. For the stochastic case it gives the stationary
 *    probability distribution of a Markov chain, the one specified by
 *    the graph/matrix under study.
 * \param maxiter A positive integer giving the number of iterations
 *    of the k-means algorithm when \p algo is \c
 *    IGRAPH_SCG_INTERV_KM. It is ignored in other cases. A reasonable
 *    (initial) value for this argument is 100.
 * \return Error code.
 *
 * Time complexity: see description above.
 *
 * \sa \ref igraph_scg_adjacency(), \ref igraph_scg_laplacian(), \ref
 * igraph_scg_stochastic().
 *
 * \example examples/simple/igraph_scg_grouping.c
 * \example examples/simple/igraph_scg_grouping2.c
 * \example examples/simple/igraph_scg_grouping3.c
 * \example examples/simple/igraph_scg_grouping4.c
 */

int igraph_scg_grouping(const igraph_matrix_t *V,
                        igraph_vector_t *groups,
                        igraph_integer_t nt,
                        const igraph_vector_t *nt_vec,
                        igraph_scg_matrix_t mtype,
                        igraph_scg_algorithm_t algo,
                        const igraph_vector_t *p,
                        igraph_integer_t maxiter) {

    int no_of_nodes = (int) igraph_matrix_nrow(V);
    int nev = (int) igraph_matrix_ncol(V);
    igraph_matrix_int_t gr_mat;
    int i;

    if (nt_vec && igraph_vector_size(nt_vec) != 1 &&
        igraph_vector_size(nt_vec) != nev) {
        IGRAPH_ERROR("Invalid length for interval specification", IGRAPH_EINVAL);
    }
    if (nt_vec && igraph_vector_size(nt_vec) == 1) {
        nt = (igraph_integer_t) VECTOR(*nt_vec)[0];
        nt_vec = 0;
    }

    if (!nt_vec && algo != IGRAPH_SCG_EXACT) {
        if (nt <= 1 || nt >= no_of_nodes) {
            IGRAPH_ERROR("Invalid interval specification", IGRAPH_EINVAL);
        }
    } else if (algo != IGRAPH_SCG_EXACT) {
        igraph_real_t min, max;
        igraph_vector_minmax(nt_vec, &min, &max);
        if (min <= 1 || max >= no_of_nodes) {
            IGRAPH_ERROR("Invalid interval specification", IGRAPH_EINVAL);
        }
    }

    if (mtype == IGRAPH_SCG_STOCHASTIC && !p) {
        IGRAPH_ERROR("The p vector must be given for the stochastic matrix case",
                     IGRAPH_EINVAL);
    }

    if (p) {
        if (igraph_vector_size(p) != no_of_nodes) {
            IGRAPH_ERROR("Invalid p vector size", IGRAPH_EINVAL);
        }

        if (igraph_vector_min(p) < 0) {
            IGRAPH_ERROR("The elements of the p vector must be non-negative", IGRAPH_EINVAL);
        }
    }

    IGRAPH_CHECK(igraph_vector_resize(groups, no_of_nodes));

#define INVEC(i) (nt_vec ? VECTOR(*nt_vec)[i] : nt)

    IGRAPH_CHECK(igraph_matrix_int_init(&gr_mat, no_of_nodes, nev));
    IGRAPH_FINALLY(igraph_matrix_int_destroy, &gr_mat);

    switch (algo) {
    case IGRAPH_SCG_OPTIMUM:
        for (i = 0; i < nev; i++) {
            IGRAPH_CHECK(igraph_i_optimal_partition(&MATRIX(*V, 0, i),
                                                    &MATRIX(gr_mat, 0, i),
                                                    no_of_nodes, (int) INVEC(i),
                                                    mtype,
                                                    p ? VECTOR(*p) : 0, 0));
        }
        break;
    case IGRAPH_SCG_INTERV_KM:
        for (i = 0; i < nev; i++) {
            igraph_vector_t tmpv;
            igraph_vector_view(&tmpv, &MATRIX(*V, 0, i), no_of_nodes);
            IGRAPH_CHECK(igraph_i_intervals_plus_kmeans(&tmpv,
                         &MATRIX(gr_mat, 0, i),
                         no_of_nodes, (int) INVEC(i),
                         maxiter));
        }
        break;
    case IGRAPH_SCG_INTERV:
        for (i = 0; i < nev; i++) {
            igraph_vector_t tmpv;
            igraph_vector_view(&tmpv, &MATRIX(*V, 0, i), no_of_nodes);
            IGRAPH_CHECK(igraph_i_intervals_method(&tmpv,
                                                   &MATRIX(gr_mat, 0, i),
                                                   no_of_nodes, (int) INVEC(i)));
        }
        break;
    case IGRAPH_SCG_EXACT:
        for (i = 0; i < nev; i++) {
            IGRAPH_CHECK(igraph_i_exact_coarse_graining(&MATRIX(*V, 0, i),
                         &MATRIX(gr_mat, 0, i),
                         no_of_nodes));
        }
        break;
    }

#undef INVEC

    if (nev == 1) {
        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*groups)[i] = MATRIX(gr_mat, i, 0);
        }
    } else {
        igraph_i_scg_groups_t *g;
        int gr_nb = 0;

        g = IGRAPH_CALLOC(no_of_nodes, igraph_i_scg_groups_t);
        IGRAPH_FINALLY(igraph_free, g);

        IGRAPH_CHECK(igraph_matrix_int_transpose(&gr_mat));
        for (i = 0; i < no_of_nodes; i++) {
            g[i].ind = i;
            g[i].n = nev;
            g[i].gr = &MATRIX(gr_mat, 0, i);
        }

        igraph_qsort(g, (size_t) no_of_nodes, sizeof(igraph_i_scg_groups_t),
              igraph_i_compare_groups);
        VECTOR(*groups)[g[0].ind] = gr_nb;
        for (i = 1; i < no_of_nodes; i++) {
            if (igraph_i_compare_groups(&g[i], &g[i - 1]) != 0) {
                gr_nb++;
            }
            VECTOR(*groups)[g[i].ind] = gr_nb;
        }

        IGRAPH_FREE(g);
        IGRAPH_FINALLY_CLEAN(1);
    }

    igraph_matrix_int_destroy(&gr_mat);
    IGRAPH_FINALLY_CLEAN(1);

    IGRAPH_CHECK(igraph_reindex_membership(groups, 0, 0));

    return 0;
}

static int igraph_i_scg_semiprojectors_sym(const igraph_vector_t *groups,
                                           igraph_matrix_t *L,
                                           igraph_matrix_t *R,
                                           igraph_sparsemat_t *Lsparse,
                                           igraph_sparsemat_t *Rsparse,
                                           int no_of_groups,
                                           int no_of_nodes) {

    igraph_vector_t tab;
    int i;

    IGRAPH_VECTOR_INIT_FINALLY(&tab, no_of_groups);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(tab)[ (int) VECTOR(*groups)[i] ] += 1;
    }
    for (i = 0; i < no_of_groups; i++) {
        VECTOR(tab)[i] = sqrt(VECTOR(tab)[i]);
    }

    if (L) {
        IGRAPH_CHECK(igraph_matrix_resize(L, no_of_groups, no_of_nodes));
        igraph_matrix_null(L);
        for (i = 0; i < no_of_nodes; i++) {
            int g = (int) VECTOR(*groups)[i];
            MATRIX(*L, g, i) = 1 / VECTOR(tab)[g];
        }
    }

    if (R) {
        if (L) {
            IGRAPH_CHECK(igraph_matrix_update(R, L));
        } else {
            IGRAPH_CHECK(igraph_matrix_resize(R, no_of_groups, no_of_nodes));
            igraph_matrix_null(R);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*R, g, i) = 1 / VECTOR(tab)[g];
            }
        }
    }

    if (Lsparse) {
        IGRAPH_CHECK(igraph_sparsemat_init(Lsparse, no_of_groups, no_of_nodes,
                                           /* nzmax= */ no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {
            int g = (int) VECTOR(*groups)[i];
            IGRAPH_CHECK(igraph_sparsemat_entry(Lsparse, g, i, 1 / VECTOR(tab)[g]));
        }
    }

    if (Rsparse) {
        IGRAPH_CHECK(igraph_sparsemat_init(Rsparse, no_of_groups, no_of_nodes,
                                           /* nzmax= */ no_of_nodes));
        for (i = 0; i < no_of_nodes; i++) {
            int g = (int) VECTOR(*groups)[i];
            IGRAPH_CHECK(igraph_sparsemat_entry(Rsparse, g, i, 1 / VECTOR(tab)[g]));
        }
    }

    igraph_vector_destroy(&tab);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_scg_semiprojectors_lap(const igraph_vector_t *groups,
                                           igraph_matrix_t *L,
                                           igraph_matrix_t *R,
                                           igraph_sparsemat_t *Lsparse,
                                           igraph_sparsemat_t *Rsparse,
                                           int no_of_groups,
                                           int no_of_nodes,
                                           igraph_scg_norm_t norm) {

    igraph_vector_t tab;
    int i;

    IGRAPH_VECTOR_INIT_FINALLY(&tab, no_of_groups);
    for (i = 0; i < no_of_nodes; i++) {
        VECTOR(tab)[ (int) VECTOR(*groups)[i] ] += 1;
    }
    for (i = 0; i < no_of_groups; i++) {
        VECTOR(tab)[i] = VECTOR(tab)[i];
    }

    if (norm == IGRAPH_SCG_NORM_ROW) {
        if (L) {
            IGRAPH_CHECK(igraph_matrix_resize(L, no_of_groups, no_of_nodes));
            igraph_matrix_null(L);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*L, g, i) = 1.0 / VECTOR(tab)[g];
            }
        }
        if (R) {
            IGRAPH_CHECK(igraph_matrix_resize(R, no_of_groups, no_of_nodes));
            igraph_matrix_null(R);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*R, g, i) = 1.0;
            }
        }
        if (Lsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Lsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Lsparse, g, i,
                                                    1.0 / VECTOR(tab)[g]));
            }
        }
        if (Rsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Rsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Rsparse, g, i, 1.0));
            }
        }
    } else {
        if (L) {
            IGRAPH_CHECK(igraph_matrix_resize(L, no_of_groups, no_of_nodes));
            igraph_matrix_null(L);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*L, g, i) = 1.0;
            }
        }
        if (R) {
            IGRAPH_CHECK(igraph_matrix_resize(R, no_of_groups, no_of_nodes));
            igraph_matrix_null(R);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*R, g, i) = 1.0 / VECTOR(tab)[g];
            }
        }
        if (Lsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Lsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Lsparse, g, i, 1.0));
            }
        }
        if (Rsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Rsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Rsparse, g, i,
                                                    1.0 / VECTOR(tab)[g]));
            }
        }

    }

    igraph_vector_destroy(&tab);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_scg_semiprojectors_sto(const igraph_vector_t *groups,
                                           igraph_matrix_t *L,
                                           igraph_matrix_t *R,
                                           igraph_sparsemat_t *Lsparse,
                                           igraph_sparsemat_t *Rsparse,
                                           int no_of_groups,
                                           int no_of_nodes,
                                           const igraph_vector_t *p,
                                           igraph_scg_norm_t norm) {

    igraph_vector_t pgr, pnormed;
    int i;

    IGRAPH_VECTOR_INIT_FINALLY(&pgr, no_of_groups);
    IGRAPH_VECTOR_INIT_FINALLY(&pnormed, no_of_nodes);
    for (i = 0; i < no_of_nodes; i++) {
        int g = (int) VECTOR(*groups)[i];
        VECTOR(pgr)[g] += VECTOR(*p)[i];
    }
    for (i = 0; i < no_of_nodes; i++) {
        int g = (int) VECTOR(*groups)[i];
        VECTOR(pnormed)[i] = VECTOR(*p)[i] / VECTOR(pgr)[g];
    }

    if (norm == IGRAPH_SCG_NORM_ROW) {
        if (L) {
            IGRAPH_CHECK(igraph_matrix_resize(L, no_of_groups, no_of_nodes));
            igraph_matrix_null(L);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*L, g, i) = VECTOR(pnormed)[i];
            }
        }
        if (R) {
            IGRAPH_CHECK(igraph_matrix_resize(R, no_of_groups, no_of_nodes));
            igraph_matrix_null(R);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*R, g, i) = 1.0;
            }
        }
        if (Lsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Lsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Lsparse, g, i,
                                                    VECTOR(pnormed)[i]));
            }
        }
        if (Rsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Rsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Rsparse, g, i, 1.0));
            }
        }
    } else {
        if (L) {
            IGRAPH_CHECK(igraph_matrix_resize(L, no_of_groups, no_of_nodes));
            igraph_matrix_null(L);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int ) VECTOR(*groups)[i];
                MATRIX(*L, g, i) = 1.0;
            }
        }
        if (R) {
            IGRAPH_CHECK(igraph_matrix_resize(R, no_of_groups, no_of_nodes));
            igraph_matrix_null(R);
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                MATRIX(*R, g, i) = VECTOR(pnormed)[i];
            }
        }
        if (Lsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Lsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Lsparse, g, i, 1.0));
            }
        }
        if (Rsparse) {
            IGRAPH_CHECK(igraph_sparsemat_init(Rsparse, no_of_groups, no_of_nodes,
                                               /* nzmax= */ no_of_nodes));
            for (i = 0; i < no_of_nodes; i++) {
                int g = (int) VECTOR(*groups)[i];
                IGRAPH_CHECK(igraph_sparsemat_entry(Rsparse, g, i,
                                                    VECTOR(pnormed)[i]));
            }
        }
    }


    igraph_vector_destroy(&pnormed);
    igraph_vector_destroy(&pgr);
    IGRAPH_FINALLY_CLEAN(2);

    return 0;
}

/**
 * \function igraph_scg_semiprojectors
 * \brief Compute SCG semi-projectors for a given partition.
 *
 * The three types of semi-projectors are defined as follows.
 * Let gamma(j) label the group of vertex j in a partition of all the
 * vertices.
 *
 * 
 * The symmetric semi-projectors are defined as
 * 

 *   L[alpha,j] = R[alpha,j] = 1/sqrt(|alpha|) delta[alpha,gamma(j)],
 * 

 * the (row) Laplacian semi-projectors as
 * 

 *   L[alpha,j] = 1/|alpha| delta[alpha,gamma(j)]
 * 

 * and
 * 

 *   R[alpha,j] = delta[alpha,gamma(j)],
 * 

 * and the (row) stochastic semi-projectors as
 * 

 *     L[alpha,j] = p[1][j] / sum(p[1][k]; k in gamma(j))
 *     delta[alpha,gamma(j)]
 * 

 * and
 * 

 *     R[alpha,j] = delta[alpha,gamma(j)],
 * 

 * where p[1] is the (left) eigenvector associated with the
 * one-eigenvalue of the stochastic matrix. L and R are
 * defined in a symmetric way when \p norm is \c
 * IGRAPH_SCG_NORM_COL. All these semi-projectors verify various
 * properties described in the reference.
 * \param groups A vector of integers, giving the group label of every
 *    vertex in the partition. Group labels should start at zero and
 *    should be sequential.
 * \param mtype The type of semi-projectors. For now \c
 *    IGRAPH_SCG_SYMMETRIC, \c IGRAPH_SCG_STOCHASTIC and \c
 *    IGRAP_SCG_LAPLACIAN are supported.
 * \param L If not a \c NULL pointer, then it must be a pointer to
 *    an initialized matrix. The left semi-projector is stored here.
 * \param R If not a \c NULL pointer, then it must be a pointer to
 *    an initialized matrix. The right semi-projector is stored here.
 * \param Lsparse If not a \c NULL pointer, then it must be a pointer
 *    to an uninitialized sparse matrix. The left semi-projector is
 *    stored here.
 * \param Rsparse If not a \c NULL pointer, then it must be a pointer
 *    to an uninitialized sparse matrix. The right semi-projector is
 *    stored here.
 * \param p \c NULL, or a probability vector of the same length as \p
 *    groups. \p p is the stationary probability distribution of a
 *    Markov chain when \p mtype is \c IGRAPH_SCG_STOCHASTIC. This
 *    argument is ignored in all other cases.
 * \param norm Either \c IGRAPH_SCG_NORM_ROW or \c IGRAPH_SCG_NORM_COL.
 *    Specifies whether the rows or the columns of the Laplacian
 *    matrix sum up to zero, or whether the rows or the columns of the
 *    stochastic matrix sum up to one.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \sa \ref igraph_scg_adjacency(), \ref igraph_scg_stochastic() and
 * \ref igraph_scg_laplacian(), \ref igraph_scg_grouping().
 *
 * \example examples/simple/igraph_scg_semiprojectors.c
 * \example examples/simple/igraph_scg_semiprojectors2.c
 * \example examples/simple/igraph_scg_semiprojectors3.c
 */

int igraph_scg_semiprojectors(const igraph_vector_t *groups,
                              igraph_scg_matrix_t mtype,
                              igraph_matrix_t *L,
                              igraph_matrix_t *R,
                              igraph_sparsemat_t *Lsparse,
                              igraph_sparsemat_t *Rsparse,
                              const igraph_vector_t *p,
                              igraph_scg_norm_t norm) {

    int no_of_nodes = (int) igraph_vector_size(groups);
    int no_of_groups;
    igraph_real_t min, max;

    igraph_vector_minmax(groups, &min, &max);
    no_of_groups = (int) max + 1;

    if (min < 0 || max >= no_of_nodes) {
        IGRAPH_ERROR("Invalid membership vector", IGRAPH_EINVAL);
    }

    if (mtype == IGRAPH_SCG_STOCHASTIC && !p) {
        IGRAPH_ERROR("`p' must be given for the stochastic matrix case",
                     IGRAPH_EINVAL);
    }

    if (p && igraph_vector_size(p) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `p' vector length, should match number of vertices",
                     IGRAPH_EINVAL);
    }

    switch (mtype) {
    case IGRAPH_SCG_SYMMETRIC:
        IGRAPH_CHECK(igraph_i_scg_semiprojectors_sym(groups, L, R, Lsparse,
                     Rsparse, no_of_groups,
                     no_of_nodes));
        break;

    case IGRAPH_SCG_LAPLACIAN:
        IGRAPH_CHECK(igraph_i_scg_semiprojectors_lap(groups, L, R, Lsparse,
                     Rsparse, no_of_groups,
                     no_of_nodes, norm));
        break;

    case IGRAPH_SCG_STOCHASTIC:
        IGRAPH_CHECK(igraph_i_scg_semiprojectors_sto(groups, L, R, Lsparse,
                     Rsparse, no_of_groups,
                     no_of_nodes, p, norm));
        break;
    }

    return 0;
}

/**
 * \function igraph_scg_norm_eps
 * \brief Calculate SCG residuals.
 *
 * Computes |v[i]-Pv[i]|, where v[i] is the i-th eigenvector in \p V
 * and P is the projector corresponding to the \p mtype argument.
 *
 * \param V The matrix of eigenvectors to be preserved by coarse
 *    graining, each column is an eigenvector.
 * \param groups A vector of integers, giving the group label of every
 *    vertex in the partition. Group labels should start at zero and
 *    should be sequential.
 * \param eps Pointer to a real value, the result is stored here.
 * \param mtype The type of semi-projectors. For now \c
 *    IGRAPH_SCG_SYMMETRIC, \c IGRAPH_SCG_STOCHASTIC and \c
 *    IGRAP_SCG_LAPLACIAN are supported.
 * \param p \c NULL, or a probability vector of the same length as \p
 *    groups. \p p is the stationary probability distribution of a
 *    Markov chain when \p mtype is \c IGRAPH_SCG_STOCHASTIC. This
 *    argument is ignored in all other cases.
 * \param norm Either \c IGRAPH_SCG_NORM_ROW or \c IGRAPH_SCG_NORM_COL.
 *    Specifies whether the rows or the columns of the Laplacian
 *    matrix sum up to zero, or whether the rows or the columns of the
 *    stochastic matrix sum up to one.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \sa \ref igraph_scg_adjacency(), \ref igraph_scg_stochastic() and
 * \ref igraph_scg_laplacian(), \ref igraph_scg_grouping(), \ref
 * igraph_scg_semiprojectors().
 */

int igraph_scg_norm_eps(const igraph_matrix_t *V,
                        const igraph_vector_t *groups,
                        igraph_vector_t *eps,
                        igraph_scg_matrix_t mtype,
                        const igraph_vector_t *p,
                        igraph_scg_norm_t norm) {

    int no_of_nodes = (int) igraph_vector_size(groups);
    int no_of_vectors = (int) igraph_matrix_ncol(V);
    igraph_real_t min, max;
    igraph_sparsemat_t Lsparse, Rsparse, Lsparse2, Rsparse2, Rsparse3, proj;
    igraph_vector_t x, res;
    int k, i;

    if (igraph_matrix_nrow(V) != no_of_nodes) {
        IGRAPH_ERROR("Eigenvector length and group vector length do not match",
                     IGRAPH_EINVAL);
    }

    igraph_vector_minmax(groups, &min, &max);

    if (min < 0 || max >= no_of_nodes) {
        IGRAPH_ERROR("Invalid membership vector", IGRAPH_EINVAL);
    }

    if (mtype == IGRAPH_SCG_STOCHASTIC && !p) {
        IGRAPH_ERROR("`p' must be given for the stochastic matrix case",
                     IGRAPH_EINVAL);
    }

    if (p && igraph_vector_size(p) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `p' vector length, should match number of vertices",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_scg_semiprojectors(groups, mtype, /* L= */ 0,
                                           /* R= */ 0, &Lsparse, &Rsparse, p,
                                           norm));

    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Lsparse);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse);

    IGRAPH_CHECK(igraph_sparsemat_compress(&Lsparse, &Lsparse2));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Lsparse2);
    IGRAPH_CHECK(igraph_sparsemat_compress(&Rsparse, &Rsparse2));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse2);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&Rsparse2, &Rsparse3,
                                            /*values=*/ 1));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse3);

    IGRAPH_CHECK(igraph_sparsemat_multiply(&Rsparse3, &Lsparse2, &proj));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &proj);

    IGRAPH_VECTOR_INIT_FINALLY(&res, no_of_nodes);
    IGRAPH_CHECK(igraph_vector_resize(eps, no_of_vectors));

    for (k = 0; k < no_of_vectors; k++) {
        igraph_vector_view(&x, &MATRIX(*V, 0, k), no_of_nodes);
        igraph_vector_null(&res);
        IGRAPH_CHECK(igraph_sparsemat_gaxpy(&proj, &x, &res));
        VECTOR(*eps)[k] = 0.0;
        for (i = 0; i < no_of_nodes; i++) {
            igraph_real_t di = MATRIX(*V, i, k) - VECTOR(res)[i];
            VECTOR(*eps)[k] += di * di;
        }
        VECTOR(*eps)[k] = sqrt(VECTOR(*eps)[k]);
    }

    igraph_vector_destroy(&res);
    igraph_sparsemat_destroy(&proj);
    igraph_sparsemat_destroy(&Rsparse3);
    igraph_sparsemat_destroy(&Rsparse2);
    igraph_sparsemat_destroy(&Lsparse2);
    igraph_sparsemat_destroy(&Rsparse);
    igraph_sparsemat_destroy(&Lsparse);
    IGRAPH_FINALLY_CLEAN(7);

    return 0;
}

static int igraph_i_matrix_laplacian(const igraph_matrix_t *matrix,
                                     igraph_matrix_t *mymatrix,
                                     igraph_scg_norm_t norm) {

    igraph_vector_t degree;
    int i, j, n = (int) igraph_matrix_nrow(matrix);
    IGRAPH_CHECK(igraph_matrix_resize(mymatrix, n, n));

    IGRAPH_VECTOR_INIT_FINALLY(°ree, n);

    if (norm == IGRAPH_SCG_NORM_ROW) {
        IGRAPH_CHECK(igraph_matrix_rowsum(matrix, °ree));
    } else {
        IGRAPH_CHECK(igraph_matrix_colsum(matrix, °ree));
    }
    for (i = 0; i < n; i++) {
        VECTOR(degree)[i] -= MATRIX(*matrix, i, i);
    }

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            MATRIX(*mymatrix, i, j) = - MATRIX(*matrix, i, j);
        }
        MATRIX(*mymatrix, i, i) = VECTOR(degree)[i];
    }

    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_sparsemat_laplacian(const igraph_sparsemat_t *sparse,
                                        igraph_sparsemat_t *mysparse,
                                        igraph_scg_norm_t norm) {

    igraph_vector_t degree;
    int i, n = (int) igraph_sparsemat_nrow(sparse);
    int nzmax = igraph_sparsemat_nzmax(sparse);
    igraph_sparsemat_iterator_t it;

    IGRAPH_CHECK(igraph_sparsemat_init(mysparse, n, n, nzmax + n));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparse);
    igraph_sparsemat_iterator_init(&it, (igraph_sparsemat_t *) sparse);

    IGRAPH_VECTOR_INIT_FINALLY(°ree, n);
    for (igraph_sparsemat_iterator_reset(&it);
         !igraph_sparsemat_iterator_end(&it);
         igraph_sparsemat_iterator_next(&it)) {
        int row = igraph_sparsemat_iterator_row(&it);
        int col = igraph_sparsemat_iterator_col(&it);
        if (row != col) {
            igraph_real_t val = igraph_sparsemat_iterator_get(&it);
            if (norm == IGRAPH_SCG_NORM_ROW) {
                VECTOR(degree)[row] += val;
            } else {
                VECTOR(degree)[col] += val;
            }
        }
    }

    /* Diagonal */
    for (i = 0; i < n; i++) {
        igraph_sparsemat_entry(mysparse, i, i, VECTOR(degree)[i]);
    }

    /* And the rest, filter out diagonal elements */
    for (igraph_sparsemat_iterator_reset(&it);
         !igraph_sparsemat_iterator_end(&it);
         igraph_sparsemat_iterator_next(&it)) {
        int row = igraph_sparsemat_iterator_row(&it);
        int col = igraph_sparsemat_iterator_col(&it);
        if (row != col) {
            igraph_real_t val = igraph_sparsemat_iterator_get(&it);
            igraph_sparsemat_entry(mysparse, row, col, -val);
        }
    }

    igraph_vector_destroy(°ree);
    IGRAPH_FINALLY_CLEAN(2);  /* + mysparse */

    return 0;
}

static int igraph_i_matrix_stochastic(const igraph_matrix_t *matrix,
                                      igraph_matrix_t *mymatrix,
                                      igraph_scg_norm_t norm) {

    int i, j, n = (int) igraph_matrix_nrow(matrix);
    IGRAPH_CHECK(igraph_matrix_copy(mymatrix, matrix));

    if (norm == IGRAPH_SCG_NORM_ROW) {
        for (i = 0; i < n; i++) {
            igraph_real_t sum = 0.0;
            for (j = 0; j < n; j++) {
                sum += MATRIX(*matrix, i, j);
            }
            if (sum == 0) {
                IGRAPH_WARNING("Zero degree vertices");
            }
            for (j = 0; j < n; j++) {
                MATRIX(*mymatrix, i, j) = MATRIX(*matrix, i, j) / sum;
            }
        }
    } else {
        for (i = 0; i < n; i++) {
            igraph_real_t sum = 0.0;
            for (j = 0; j < n; j++) {
                sum += MATRIX(*matrix, j, i);
            }
            if (sum == 0) {
                IGRAPH_WARNING("Zero degree vertices");
            }
            for (j = 0; j < n; j++) {
                MATRIX(*mymatrix, j, i) = MATRIX(*matrix, j, i) / sum;
            }
        }
    }

    return 0;
}

static int igraph_i_sparsemat_stochastic(const igraph_sparsemat_t *sparse,
                                         igraph_sparsemat_t *mysparse,
                                         igraph_scg_norm_t norm) {

    IGRAPH_CHECK(igraph_sparsemat_copy(mysparse, sparse));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparse);
    IGRAPH_CHECK(igraph_i_normalize_sparsemat(mysparse,
                 norm == IGRAPH_SCG_NORM_COL));
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

static int igraph_i_scg_get_result(igraph_scg_matrix_t type,
                                   const igraph_matrix_t *matrix,
                                   const igraph_sparsemat_t *sparsemat,
                                   const igraph_sparsemat_t *Lsparse,
                                   const igraph_sparsemat_t *Rsparse_t,
                                   igraph_t *scg_graph,
                                   igraph_matrix_t *scg_matrix,
                                   igraph_sparsemat_t *scg_sparsemat,
                                   igraph_bool_t directed) {

    /* We need to calculate either scg_matrix (if input is dense), or
       scg_sparsemat (if input is sparse). For the latter we might need
       to temporarily use another matrix. */


    if (matrix) {
        igraph_matrix_t *my_scg_matrix = scg_matrix, v_scg_matrix;
        igraph_matrix_t tmp;
        igraph_sparsemat_t *myLsparse = (igraph_sparsemat_t *) Lsparse, v_Lsparse;

        if (!scg_matrix) {
            my_scg_matrix = &v_scg_matrix;
            IGRAPH_CHECK(igraph_matrix_init(my_scg_matrix, 0, 0));
            IGRAPH_FINALLY(igraph_matrix_destroy, my_scg_matrix);
        }

        if (!igraph_sparsemat_is_cc(Lsparse)) {
            myLsparse = &v_Lsparse;
            IGRAPH_CHECK(igraph_sparsemat_compress(Lsparse, myLsparse));
            IGRAPH_FINALLY(igraph_sparsemat_destroy, myLsparse);
        }

        IGRAPH_CHECK(igraph_matrix_init(&tmp, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_destroy, &tmp);
        IGRAPH_CHECK(igraph_sparsemat_dense_multiply(matrix, Rsparse_t, &tmp));
        IGRAPH_CHECK(igraph_sparsemat_multiply_by_dense(myLsparse, &tmp,
                     my_scg_matrix));
        igraph_matrix_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);

        if (scg_sparsemat) {
            IGRAPH_CHECK(igraph_matrix_as_sparsemat(scg_sparsemat, my_scg_matrix,
                                                    /* tol= */ 0));
            IGRAPH_FINALLY(igraph_sparsemat_destroy, scg_sparsemat);
        }

        if (scg_graph) {
            if (type != IGRAPH_SCG_LAPLACIAN) {
                IGRAPH_CHECK(igraph_weighted_adjacency(scg_graph, my_scg_matrix,
                                                       directed ?
                                                       IGRAPH_ADJ_DIRECTED :
                                                       IGRAPH_ADJ_UNDIRECTED,
                                                       "weight", /*loops=*/ 1));
            } else {
                int i, j, n = (int) igraph_matrix_nrow(my_scg_matrix);
                igraph_matrix_t tmp;
                IGRAPH_MATRIX_INIT_FINALLY(&tmp, n, n);
                for (i = 0; i < n; i++) {
                    for (j = 0; j < n; j++) {
                        MATRIX(tmp, i, j) = -MATRIX(*my_scg_matrix, i, j);
                    }
                    MATRIX(tmp, i, i) = 0;
                }
                IGRAPH_CHECK(igraph_weighted_adjacency(scg_graph, &tmp, directed ?
                                                       IGRAPH_ADJ_DIRECTED :
                                                       IGRAPH_ADJ_UNDIRECTED,
                                                       "weight", /*loops=*/ 0));
                igraph_matrix_destroy(&tmp);
                IGRAPH_FINALLY_CLEAN(1);
            }
            IGRAPH_FINALLY(igraph_destroy, scg_graph);
        }

        if (scg_graph)     {
            IGRAPH_FINALLY_CLEAN(1);
        }
        if (scg_sparsemat) {
            IGRAPH_FINALLY_CLEAN(1);
        }

        if (!igraph_sparsemat_is_cc(Lsparse)) {
            igraph_sparsemat_destroy(myLsparse);
            IGRAPH_FINALLY_CLEAN(1);
        }

        if (!scg_matrix) {
            igraph_matrix_destroy(my_scg_matrix);
            IGRAPH_FINALLY_CLEAN(1);
        }

    } else { /* sparsemat */
        igraph_sparsemat_t *my_scg_sparsemat = scg_sparsemat, v_scg_sparsemat;
        igraph_sparsemat_t tmp, *mysparsemat = (igraph_sparsemat_t *) sparsemat,
                                 v_sparsemat, *myLsparse = (igraph_sparsemat_t *) Lsparse, v_Lsparse;
        if (!scg_sparsemat) {
            my_scg_sparsemat = &v_scg_sparsemat;
        }
        if (!igraph_sparsemat_is_cc(sparsemat)) {
            mysparsemat = &v_sparsemat;
            IGRAPH_CHECK(igraph_sparsemat_compress(sparsemat, mysparsemat));
            IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
        }
        if (!igraph_sparsemat_is_cc(Lsparse)) {
            myLsparse = &v_Lsparse;
            IGRAPH_CHECK(igraph_sparsemat_compress(Lsparse, myLsparse));
            IGRAPH_FINALLY(igraph_sparsemat_destroy, myLsparse);
        }
        IGRAPH_CHECK(igraph_sparsemat_multiply(mysparsemat, Rsparse_t,
                                               &tmp));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
        IGRAPH_CHECK(igraph_sparsemat_multiply(myLsparse, &tmp,
                                               my_scg_sparsemat));
        igraph_sparsemat_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
        IGRAPH_FINALLY(igraph_sparsemat_destroy, my_scg_sparsemat);

        if (scg_matrix) {
            IGRAPH_CHECK(igraph_sparsemat_as_matrix(scg_matrix, my_scg_sparsemat));
        }
        if (scg_graph) {
            if (type != IGRAPH_SCG_LAPLACIAN) {
                IGRAPH_CHECK(igraph_weighted_sparsemat(scg_graph, my_scg_sparsemat,
                                                       directed, "weight",
                                                       /*loops=*/ 1));
            } else {
                igraph_sparsemat_t tmp;
                IGRAPH_CHECK(igraph_sparsemat_copy(&tmp, my_scg_sparsemat));
                IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmp);
                IGRAPH_CHECK(igraph_sparsemat_neg(&tmp));
                IGRAPH_CHECK(igraph_weighted_sparsemat(scg_graph, &tmp, directed,
                                                       "weight", /*loops=*/ 0));
                igraph_sparsemat_destroy(&tmp);
                IGRAPH_FINALLY_CLEAN(1);
            }
            IGRAPH_FINALLY(igraph_destroy, scg_graph);
        }

        if (scg_graph) {
            IGRAPH_FINALLY_CLEAN(1);
        }
        if (!scg_sparsemat) {
            igraph_sparsemat_destroy(my_scg_sparsemat);
        }
        IGRAPH_FINALLY_CLEAN(1);    /* my_scg_sparsemat */
        if (!igraph_sparsemat_is_cc(Lsparse)) {
            igraph_sparsemat_destroy(myLsparse);
            IGRAPH_FINALLY_CLEAN(1);
        }
        if (!igraph_sparsemat_is_cc(sparsemat)) {
            igraph_sparsemat_destroy(mysparsemat);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    return 0;
}

static int igraph_i_scg_common_checks(const igraph_t *graph,
                                      const igraph_matrix_t *matrix,
                                      const igraph_sparsemat_t *sparsemat,
                                      const igraph_vector_t *ev,
                                      igraph_integer_t nt,
                                      const igraph_vector_t *nt_vec,
                                      const igraph_matrix_t *vectors,
                                      const igraph_matrix_complex_t *vectors_cmplx,
                                      const igraph_vector_t *groups,
                                      const igraph_t *scg_graph,
                                      const igraph_matrix_t *scg_matrix,
                                      const igraph_sparsemat_t *scg_sparsemat,
                                      const igraph_vector_t *p,
                                      igraph_real_t *evmin, igraph_real_t *evmax) {

    int no_of_nodes = -1;
    igraph_real_t min, max;
    int no_of_ev = (int) igraph_vector_size(ev);

    if ( (graph ? 1 : 0) + (matrix ? 1 : 0) + (sparsemat ? 1 : 0) != 1 ) {
        IGRAPH_ERROR("Give exactly one of `graph', `matrix' and `sparsemat'",
                     IGRAPH_EINVAL);
    }

    if (graph) {
        no_of_nodes = igraph_vcount(graph);
    } else if (matrix) {
        no_of_nodes = (int) igraph_matrix_nrow(matrix);
    } else if (sparsemat) {
        no_of_nodes = (int) igraph_sparsemat_nrow(sparsemat);
    }

    if ((matrix && igraph_matrix_ncol(matrix) != no_of_nodes) ||
        (sparsemat && igraph_sparsemat_ncol(sparsemat) != no_of_nodes)) {
        IGRAPH_ERROR("Matrix must be square", IGRAPH_NONSQUARE);
    }

    igraph_vector_minmax(ev, evmin, evmax);
    if (*evmin < 0 || *evmax >= no_of_nodes) {
        IGRAPH_ERROR("Invalid eigenvectors given", IGRAPH_EINVAL);
    }

    if (!nt_vec && (nt <= 1 || nt >= no_of_nodes)) {
        IGRAPH_ERROR("Invalid interval specification", IGRAPH_EINVAL);
    }

    if (nt_vec) {
        if (igraph_vector_size(nt_vec) != 1 &&
            igraph_vector_size(nt_vec) != no_of_ev) {
            IGRAPH_ERROR("Invalid length for interval specification",
                         IGRAPH_EINVAL);
        }
        igraph_vector_minmax(nt_vec, &min, &max);
        if (min <= 1 || max >= no_of_nodes) {
            IGRAPH_ERROR("Invalid interval specification", IGRAPH_EINVAL);
        }
    }

    if (vectors && igraph_matrix_size(vectors) != 0 &&
        (igraph_matrix_ncol(vectors) != no_of_ev ||
         igraph_matrix_nrow(vectors) != no_of_nodes)) {
        IGRAPH_ERROR("Invalid eigenvector matrix size", IGRAPH_EINVAL);
    }

    if (vectors_cmplx && igraph_matrix_complex_size(vectors_cmplx) != 0 &&
        (igraph_matrix_complex_ncol(vectors_cmplx) != no_of_ev ||
         igraph_matrix_complex_nrow(vectors_cmplx) != no_of_nodes)) {
        IGRAPH_ERROR("Invalid eigenvector matrix size", IGRAPH_EINVAL);
    }

    if (groups && igraph_vector_size(groups) != 0 &&
        igraph_vector_size(groups) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `groups' vector size", IGRAPH_EINVAL);
    }

    if ( (scg_graph != 0) + (scg_matrix != 0) + (scg_sparsemat != 0) == 0 ) {
        IGRAPH_ERROR("No output is requested, please give at least one of "
                     "`scg_graph', `scg_matrix' and `scg_sparsemat'",
                     IGRAPH_EINVAL);
    }

    if (p && igraph_vector_size(p) != 0 &&
        igraph_vector_size(p) != no_of_nodes) {
        IGRAPH_ERROR("Invalid `p' vector size", IGRAPH_EINVAL);
    }

    return 0;
}

/**
 * \function igraph_scg_adjacency
 * Spectral coarse graining, symmetric case.
 *
 * This function handles all the steps involved in the Spectral Coarse
 * Graining (SCG) of some matrices and graphs as described in the
 * reference below.
 *
 * \param graph The input graph. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param matrix The input matrix. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param sparsemat The input sparse matrix. Exactly one of \p graph,
 *    \p matrix and \p sparsemat must be given, the other two must be
 *    \c NULL pointers.
 * \param ev A vector of positive integers giving the indexes of the
 *   eigenpairs to be preserved. 1 designates the eigenvalue with
 *    largest algebraic value, 2 the one with second largest algebraic
 *    value, etc.
 * \param nt Positive integer. When \p algo is \c IGRAPH_SCG_OPTIMUM,
 *    it gives the number of groups to partition each eigenvector
 *    separately. When \p algo is \c IGRAPH_SCG_INTERV or \c
 *    IGRAPH_SCG_INTERV_KM, it gives the number of intervals to
 *    partition each eigenvector. This is ignored when \p algo is \c
 *    IGRAPH_SCG_EXACT.
 * \param nt_vec A numeric vector of length one or the length must
 *    match the number of eigenvectors given in \p V, or a \c NULL
 *    pointer. If not \c NULL, then this argument gives the number of
 *    groups or intervals, and \p nt is ignored. Different number of
 *    groups or intervals can be specified for each eigenvector.
 * \param algo The algorithm to solve the SCG problem. Possible
 *    values: \c IGRAPH_SCG_OPTIMUM, \c IGRAPH_SCG_INTERV_KM, \c
 *    IGRAPH_SCG_INTERV and \c IGRAPH_SCG_EXACT. Please see the
 *    details about them above.
 * \param values If this is not \c NULL and the eigenvectors are
 *    re-calculated, then the eigenvalues are stored here.
 * \param vectors If this is not \c NULL, and not a zero-length
 *    matrix, then it is interpreted as the eigenvectors to use for
 *    the coarse-graining. Otherwise the eigenvectors are
 *    re-calculated, and they are stored here. (If this is not \c NULL.)
 * \param groups If this is not \c NULL, and not a zero-length vector,
 *    then it is interpreted as the vector of group labels. (Group
 *    labels are integers from zero and are sequential.) Otherwise
 *    group labels are re-calculated and stored here, if this argument
 *    is not a null pointer.
 * \param use_arpack Whether to use ARPACK for solving the
 *    eigenproblem. Currently ARPACK is not implemented.
 * \param maxiter A positive integer giving the number of iterations
 *    of the k-means algorithm when \p algo is \c
 *    IGRAPH_SCG_INTERV_KM. It is ignored in other cases. A reasonable
 *    (initial) value for this argument is 100.
 * \param scg_graph If not a \c NULL pointer, then the coarse-grained
 *    graph is returned here.
 * \param scg_matrix If not a \c NULL pointer, then it must be an
 *    initialied matrix, and the coarse-grained matrix is returned
 *    here.
 * \param scg_sparsemat If not a \c NULL pointer, then the coarse
 *    grained matrix is returned here, in sparse matrix form.
 * \param L If not a \c NULL pointer, then it must be an initialized
 *    matrix and the left semi-projector is returned here.
 * \param R If not a \c NULL pointer, then it must be an initialized
 *    matrix and the right semi-projector is returned here.
 * \param Lsparse If not a \c NULL pointer, then the left
 *    semi-projector is returned here.
 * \param Rsparse If not a \c NULL pointer, then the right
 *    semi-projector is returned here.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \sa \ref igraph_scg_grouping(), \ref igraph_scg_semiprojectors(),
 * \ref igraph_scg_stochastic() and \ref igraph_scg_laplacian().
 *
 * \example examples/simple/scg.c
 */

int igraph_scg_adjacency(const igraph_t *graph,
                         const igraph_matrix_t *matrix,
                         const igraph_sparsemat_t *sparsemat,
                         const igraph_vector_t *ev,
                         igraph_integer_t nt,
                         const igraph_vector_t *nt_vec,
                         igraph_scg_algorithm_t algo,
                         igraph_vector_t *values,
                         igraph_matrix_t *vectors,
                         igraph_vector_t *groups,
                         igraph_bool_t use_arpack,
                         igraph_integer_t maxiter,
                         igraph_t *scg_graph,
                         igraph_matrix_t *scg_matrix,
                         igraph_sparsemat_t *scg_sparsemat,
                         igraph_matrix_t *L,
                         igraph_matrix_t *R,
                         igraph_sparsemat_t *Lsparse,
                         igraph_sparsemat_t *Rsparse) {

    igraph_sparsemat_t *mysparsemat = (igraph_sparsemat_t*) sparsemat,
                        real_sparsemat;
    int no_of_ev = (int) igraph_vector_size(ev);
    /* eigenvectors are calculated and returned */
    igraph_bool_t do_vectors = vectors && igraph_matrix_size(vectors) == 0;
    /* groups are calculated */
    igraph_bool_t do_groups = !groups || igraph_vector_size(groups) == 0;
    /* eigenvectors are not returned but must be calculated for groups */
    igraph_bool_t tmp_vectors = !do_vectors && do_groups;
    /* need temporary vector for groups */
    igraph_bool_t tmp_groups = !groups;
    igraph_matrix_t myvectors;
    igraph_vector_t mygroups;
    igraph_bool_t tmp_lsparse = !Lsparse, tmp_rsparse = !Rsparse;
    igraph_sparsemat_t myLsparse, myRsparse, tmpsparse, Rsparse_t;
    int no_of_nodes;
    igraph_real_t evmin, evmax;
    igraph_bool_t directed;

    /* --------------------------------------------------------------------*/
    /* Argument checks */

    IGRAPH_CHECK(igraph_i_scg_common_checks(graph, matrix, sparsemat,
                                            ev, nt, nt_vec,
                                            vectors, 0, groups, scg_graph,
                                            scg_matrix, scg_sparsemat,
                                            /*p=*/ 0, &evmin, &evmax));

    if (graph) {
        no_of_nodes = igraph_vcount(graph);
        directed = igraph_is_directed(graph);
    } else if (matrix) {
        no_of_nodes = (int) igraph_matrix_nrow(matrix);
        directed = !igraph_matrix_is_symmetric(matrix);
    } else {
        no_of_nodes = (int) igraph_sparsemat_nrow(sparsemat);
        directed = !igraph_sparsemat_is_symmetric(sparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Convert graph, if needed */

    if (graph) {
        mysparsemat = &real_sparsemat;
        IGRAPH_CHECK(igraph_get_sparsemat(graph, mysparsemat));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Compute eigenpairs, if needed */
    if (tmp_vectors) {
        vectors = &myvectors;
        IGRAPH_MATRIX_INIT_FINALLY(vectors, no_of_nodes, no_of_ev);
    }

    if (do_vectors || tmp_vectors) {
        igraph_arpack_options_t options;
        igraph_eigen_which_t which;
        igraph_matrix_t tmp;
        igraph_vector_t tmpev;
        igraph_vector_t tmpeval;
        int i;

        which.pos = IGRAPH_EIGEN_SELECT;
        which.il = (int) (no_of_nodes - evmax + 1);
        which.iu = (int) (no_of_nodes - evmin + 1);

        if (values) {
            IGRAPH_VECTOR_INIT_FINALLY(&tmpeval, 0);
        }
        IGRAPH_CHECK(igraph_matrix_init(&tmp, no_of_nodes,
                                        which.iu - which.il + 1));
        IGRAPH_FINALLY(igraph_matrix_destroy, &tmp);
        IGRAPH_CHECK(igraph_eigen_matrix_symmetric(matrix, mysparsemat,
                     /* fun= */ 0, no_of_nodes,
                     /* extra= */ 0,
                     /* algorithm= */
                     use_arpack ?
                     IGRAPH_EIGEN_ARPACK :
                     IGRAPH_EIGEN_LAPACK, &which,
                     &options, /*storage=*/ 0,
                     values ? &tmpeval : 0,
                     &tmp));
        IGRAPH_VECTOR_INIT_FINALLY(&tmpev, no_of_ev);
        for (i = 0; i < no_of_ev; i++) {
            VECTOR(tmpev)[i] = evmax - VECTOR(*ev)[i];
        }
        if (values) {
            IGRAPH_CHECK(igraph_vector_index(&tmpeval, values, &tmpev));
        }
        IGRAPH_CHECK(igraph_matrix_select_cols(&tmp, vectors, &tmpev));
        igraph_vector_destroy(&tmpev);
        igraph_matrix_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(2);
        if (values) {
            igraph_vector_destroy(&tmpeval);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    /* -------------------------------------------------------------------- */
    /* Work out groups, if needed */
    if (tmp_groups) {
        groups = &mygroups;
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)groups, no_of_nodes);
    }
    if (do_groups) {
        IGRAPH_CHECK(igraph_scg_grouping(vectors, (igraph_vector_t*)groups,
                                         nt, nt_vec,
                                         IGRAPH_SCG_SYMMETRIC, algo,
                                         /*p=*/ 0, maxiter));
    }

    /* -------------------------------------------------------------------- */
    /* Perform coarse graining */
    if (tmp_lsparse) {
        Lsparse = &myLsparse;
    }
    if (tmp_rsparse) {
        Rsparse = &myRsparse;
    }
    IGRAPH_CHECK(igraph_scg_semiprojectors(groups, IGRAPH_SCG_SYMMETRIC,
                                           L, R, Lsparse, Rsparse, /*p=*/ 0,
                                           IGRAPH_SCG_NORM_ROW));
    if (tmp_groups) {
        igraph_vector_destroy((igraph_vector_t*) groups);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (tmp_vectors) {
        igraph_matrix_destroy(vectors);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Rsparse);
    }
    if (Lsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Lsparse);
    }

    /* -------------------------------------------------------------------- */
    /* Compute coarse grained matrix/graph/sparse matrix */
    IGRAPH_CHECK(igraph_sparsemat_compress(Rsparse, &tmpsparse));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmpsparse);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&tmpsparse, &Rsparse_t,
                                            /*values=*/ 1));
    igraph_sparsemat_destroy(&tmpsparse);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse_t);

    IGRAPH_CHECK(igraph_i_scg_get_result(IGRAPH_SCG_SYMMETRIC,
                                         matrix, mysparsemat,
                                         Lsparse, &Rsparse_t,
                                         scg_graph, scg_matrix,
                                         scg_sparsemat, directed));

    /* -------------------------------------------------------------------- */
    /* Clean up */

    igraph_sparsemat_destroy(&Rsparse_t);
    IGRAPH_FINALLY_CLEAN(1);
    if (Lsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (graph) {
        igraph_sparsemat_destroy(mysparsemat);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_scg_stochastic
 * Spectral coarse graining, stochastic case.
 *
 * This function handles all the steps involved in the Spectral Coarse
 * Graining (SCG) of some matrices and graphs as described in the
 * reference below.
 *
 * \param graph The input graph. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param matrix The input matrix. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param sparsemat The input sparse matrix. Exactly one of \p graph,
 *    \p matrix and \p sparsemat must be given, the other two must be
 *    \c NULL pointers.
 * \param ev A vector of positive integers giving the indexes of the
 *   eigenpairs to be preserved. 1 designates the eigenvalue with
 *    largest magnitude, 2 the one with second largest magnitude, etc.
 * \param nt Positive integer. When \p algo is \c IGRAPH_SCG_OPTIMUM,
 *    it gives the number of groups to partition each eigenvector
 *    separately. When \p algo is \c IGRAPH_SCG_INTERV or \c
 *    IGRAPH_SCG_INTERV_KM, it gives the number of intervals to
 *    partition each eigenvector. This is ignored when \p algo is \c
 *    IGRAPH_SCG_EXACT.
 * \param nt_vec A numeric vector of length one or the length must
 *    match the number of eigenvectors given in \p V, or a \c NULL
 *    pointer. If not \c NULL, then this argument gives the number of
 *    groups or intervals, and \p nt is ignored. Different number of
 *    groups or intervals can be specified for each eigenvector.
 * \param algo The algorithm to solve the SCG problem. Possible
 *    values: \c IGRAPH_SCG_OPTIMUM, \c IGRAPH_SCG_INTERV_KM, \c
 *    IGRAPH_SCG_INTERV and \c IGRAPH_SCG_EXACT. Please see the
 *    details about them above.
 * \param norm Either \c IGRAPH_SCG_NORM_ROW or \c IGRAPH_SCG_NORM_COL.
 *    Specifies whether the rows or the columns of the
 *    stochastic matrix sum up to one.
 * \param values If this is not \c NULL and the eigenvectors are
 *    re-calculated, then the eigenvalues are stored here.
 * \param vectors If this is not \c NULL, and not a zero-length
 *    matrix, then it is interpreted as the eigenvectors to use for
 *    the coarse-graining. Otherwise the eigenvectors are
 *    re-calculated, and they are stored here. (If this is not \c NULL.)
 * \param groups If this is not \c NULL, and not a zero-length vector,
 *    then it is interpreted as the vector of group labels. (Group
 *    labels are integers from zero and are sequential.) Otherwise
 *    group labels are re-calculated and stored here, if this argument
 *    is not a null pointer.
 * \param p If this is not \c NULL, and not zero length, then it is
 *    interpreted as the stationary probability distribution of the
 *    Markov chain corresponding to the input matrix/graph. Its length
 *    must match the number of  vertices in the input graph (or number
 *    of rows in the input matrix). If not given, then the stationary
 *    distribution is calculated and stored here. (Unless this
 *    argument is a \c NULL pointer, in which case it is not stored.)
 * \param use_arpack Whether to use ARPACK for solving the
 *    eigenproblem. Currently ARPACK is not implemented.
 * \param maxiter A positive integer giving the number of iterations
 *    of the k-means algorithm when \p algo is \c
 *    IGRAPH_SCG_INTERV_KM. It is ignored in other cases. A reasonable
 *    (initial) value for this argument is 100.
 * \param scg_graph If not a \c NULL pointer, then the coarse-grained
 *    graph is returned here.
 * \param scg_matrix If not a \c NULL pointer, then it must be an
 *    initialied matrix, and the coarse-grained matrix is returned
 *    here.
 * \param scg_sparsemat If not a \c NULL pointer, then the coarse
 *    grained matrix is returned here, in sparse matrix form.
 * \param L If not a \c NULL pointer, then it must be an initialized
 *    matrix and the left semi-projector is returned here.
 * \param R If not a \c NULL pointer, then it must be an initialized
 *    matrix and the right semi-projector is returned here.
 * \param Lsparse If not a \c NULL pointer, then the left
 *    semi-projector is returned here.
 * \param Rsparse If not a \c NULL pointer, then the right
 *    semi-projector is returned here.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \sa \ref igraph_scg_grouping(), \ref igraph_scg_semiprojectors(),
 * \ref igraph_scg_adjacency() and \ref igraph_scg_laplacian().
 */

int igraph_scg_stochastic(const igraph_t *graph,
                          const igraph_matrix_t *matrix,
                          const igraph_sparsemat_t *sparsemat,
                          const igraph_vector_t *ev,
                          igraph_integer_t nt,
                          const igraph_vector_t *nt_vec,
                          igraph_scg_algorithm_t algo,
                          igraph_scg_norm_t norm,
                          igraph_vector_complex_t *values,
                          igraph_matrix_complex_t *vectors,
                          igraph_vector_t *groups,
                          igraph_vector_t *p,
                          igraph_bool_t use_arpack,
                          igraph_integer_t maxiter,
                          igraph_t *scg_graph,
                          igraph_matrix_t *scg_matrix,
                          igraph_sparsemat_t *scg_sparsemat,
                          igraph_matrix_t *L,
                          igraph_matrix_t *R,
                          igraph_sparsemat_t *Lsparse,
                          igraph_sparsemat_t *Rsparse) {

    igraph_matrix_t *mymatrix = (igraph_matrix_t*) matrix, real_matrix;
    igraph_sparsemat_t *mysparsemat = (igraph_sparsemat_t*) sparsemat,
                        real_sparsemat;
    int no_of_nodes;
    igraph_real_t evmin, evmax;
    igraph_arpack_options_t options;
    igraph_eigen_which_t which;
    /* eigenvectors are calculated and returned */
    igraph_bool_t do_vectors = vectors && igraph_matrix_complex_size(vectors) == 0;
    /* groups are calculated */
    igraph_bool_t do_groups = !groups || igraph_vector_size(groups) == 0;
    igraph_bool_t tmp_groups = !groups;
    /* eigenvectors are not returned but must be calculated for groups */
    igraph_bool_t tmp_vectors = !do_vectors && do_groups;
    igraph_matrix_complex_t myvectors;
    igraph_vector_t mygroups;
    igraph_bool_t do_p = !p || igraph_vector_size(p) == 0;
    igraph_vector_t *myp = (igraph_vector_t *) p, real_p;
    int no_of_ev = (int) igraph_vector_size(ev);
    igraph_bool_t tmp_lsparse = !Lsparse, tmp_rsparse = !Rsparse;
    igraph_sparsemat_t myLsparse, myRsparse, tmpsparse, Rsparse_t;

    /* --------------------------------------------------------------------*/
    /* Argument checks */

    IGRAPH_CHECK(igraph_i_scg_common_checks(graph, matrix, sparsemat,
                                            ev, nt, nt_vec,
                                            0, vectors, groups, scg_graph,
                                            scg_matrix, scg_sparsemat, p,
                                            &evmin, &evmax));

    if (graph) {
        no_of_nodes = igraph_vcount(graph);
    } else if (matrix) {
        no_of_nodes = (int) igraph_matrix_nrow(matrix);
    } else {
        no_of_nodes = (int) igraph_sparsemat_nrow(sparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Convert graph, if needed */

    if (graph) {
        mysparsemat = &real_sparsemat;
        IGRAPH_CHECK(igraph_get_stochastic_sparsemat(graph, mysparsemat,
                     norm == IGRAPH_SCG_NORM_COL));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
    } else if (matrix) {
        mymatrix = &real_matrix;
        IGRAPH_CHECK(igraph_i_matrix_stochastic(matrix, mymatrix, norm));
        IGRAPH_FINALLY(igraph_matrix_destroy, mymatrix);
    } else { /* sparsemat */
        mysparsemat = &real_sparsemat;
        IGRAPH_CHECK(igraph_i_sparsemat_stochastic(sparsemat, mysparsemat, norm));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Compute eigenpairs, if needed */

    if (tmp_vectors) {
        vectors = &myvectors;
        IGRAPH_CHECK(igraph_matrix_complex_init(vectors, no_of_nodes, no_of_ev));
        IGRAPH_FINALLY(igraph_matrix_complex_destroy, vectors);
    }

    if (do_vectors || tmp_vectors) {
        igraph_matrix_complex_t tmp;
        igraph_vector_t tmpev;
        igraph_vector_complex_t tmpeval;
        int i;

        which.pos = IGRAPH_EIGEN_SELECT;
        which.il = (int) (no_of_nodes - evmax + 1);
        which.iu = (int) (no_of_nodes - evmin + 1);

        if (values) {
            IGRAPH_CHECK(igraph_vector_complex_init(&tmpeval, 0));
            IGRAPH_FINALLY(igraph_vector_complex_destroy, &tmpeval);
        }
        IGRAPH_CHECK(igraph_matrix_complex_init(&tmp, no_of_nodes,
                                                which.iu - which.il + 1));
        IGRAPH_FINALLY(igraph_matrix_complex_destroy, &tmp);
        IGRAPH_CHECK(igraph_eigen_matrix(mymatrix, mysparsemat, /*fun=*/ 0,
                                         no_of_nodes, /*extra=*/ 0, use_arpack ?
                                         IGRAPH_EIGEN_ARPACK :
                                         IGRAPH_EIGEN_LAPACK, &which, &options,
                                         /*storage=*/ 0,
                                         values ? &tmpeval : 0, &tmp));

        IGRAPH_VECTOR_INIT_FINALLY(&tmpev, no_of_ev);
        for (i = 0; i < no_of_ev; i++) {
            VECTOR(tmpev)[i] = evmax - VECTOR(*ev)[i];
        }
        if (values) {
            IGRAPH_CHECK(igraph_vector_complex_index(&tmpeval, values, &tmpev));
        }
        IGRAPH_CHECK(igraph_matrix_complex_select_cols(&tmp, vectors, &tmpev));
        igraph_vector_destroy(&tmpev);
        igraph_matrix_complex_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(2);
        if (values) {
            igraph_vector_complex_destroy(&tmpeval);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    /* Compute p if not supplied */
    if (do_p) {
        igraph_eigen_which_t w;
        igraph_matrix_complex_t tmp;
        igraph_arpack_options_t o;
        igraph_matrix_t trans, *mytrans = &trans;
        igraph_sparsemat_t sparse_trans, *mysparse_trans = &sparse_trans;
        int i;
        igraph_arpack_options_init(&o);
        if (!p) {
            IGRAPH_VECTOR_INIT_FINALLY(&real_p, no_of_nodes);
            myp = &real_p;
        } else {
            IGRAPH_CHECK(igraph_vector_resize(p, no_of_nodes));
        }
        IGRAPH_CHECK(igraph_matrix_complex_init(&tmp, 0, 0));
        IGRAPH_FINALLY(igraph_matrix_complex_destroy, &tmp);
        w.pos = IGRAPH_EIGEN_LR;
        w.howmany = 1;

        if (mymatrix) {
            IGRAPH_CHECK(igraph_matrix_copy(&trans, mymatrix));
            IGRAPH_FINALLY(igraph_matrix_destroy, &trans);
            IGRAPH_CHECK(igraph_matrix_transpose(&trans));
            mysparse_trans = 0;
        } else {
            IGRAPH_CHECK(igraph_sparsemat_transpose(mysparsemat, &sparse_trans,
                                                    /*values=*/ 1));
            IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparse_trans);
            mytrans = 0;
        }

        IGRAPH_CHECK(igraph_eigen_matrix(mytrans, mysparse_trans, /*fun=*/ 0,
                                         no_of_nodes, /*extra=*/ 0, /*algorith=*/
                                         use_arpack ?
                                         IGRAPH_EIGEN_ARPACK :
                                         IGRAPH_EIGEN_LAPACK, &w, &o,
                                         /*storage=*/ 0, /*values=*/ 0, &tmp));

        if (mymatrix) {
            igraph_matrix_destroy(&trans);
            IGRAPH_FINALLY_CLEAN(1);
        } else {
            igraph_sparsemat_destroy(mysparse_trans);
            IGRAPH_FINALLY_CLEAN(1);
        }

        for (i = 0; i < no_of_nodes; i++) {
            VECTOR(*myp)[i] = fabs(IGRAPH_REAL(MATRIX(tmp, i, 0)));
        }
        igraph_matrix_complex_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* -------------------------------------------------------------------- */
    /* Work out groups, if needed */
    /* TODO: use complex part as well */
    if (tmp_groups) {
        groups = &mygroups;
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)groups, no_of_nodes);
    }
    if (do_groups) {
        igraph_matrix_t tmp;
        IGRAPH_MATRIX_INIT_FINALLY(&tmp, 0, 0);
        IGRAPH_CHECK(igraph_matrix_complex_real(vectors, &tmp));
        IGRAPH_CHECK(igraph_scg_grouping(&tmp, (igraph_vector_t*)groups,
                                         nt, nt_vec,
                                         IGRAPH_SCG_STOCHASTIC, algo,
                                         myp, maxiter));
        igraph_matrix_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* -------------------------------------------------------------------- */
    /* Perform coarse graining */
    if (tmp_lsparse) {
        Lsparse = &myLsparse;
    }
    if (tmp_rsparse) {
        Rsparse = &myRsparse;
    }
    IGRAPH_CHECK(igraph_scg_semiprojectors(groups, IGRAPH_SCG_STOCHASTIC,
                                           L, R, Lsparse, Rsparse, myp, norm));
    if (tmp_groups) {
        igraph_vector_destroy((igraph_vector_t*) groups);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (!p && do_p) {
        igraph_vector_destroy(myp);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (tmp_vectors) {
        igraph_matrix_complex_destroy(vectors);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Rsparse);
    }
    if (Lsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Lsparse);
    }

    /* -------------------------------------------------------------------- */
    /* Compute coarse grained matrix/graph/sparse matrix */
    IGRAPH_CHECK(igraph_sparsemat_compress(Rsparse, &tmpsparse));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmpsparse);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&tmpsparse, &Rsparse_t,
                                            /*values=*/ 1));
    igraph_sparsemat_destroy(&tmpsparse);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse_t);

    IGRAPH_CHECK(igraph_i_scg_get_result(IGRAPH_SCG_STOCHASTIC,
                                         mymatrix, mysparsemat,
                                         Lsparse, &Rsparse_t,
                                         scg_graph, scg_matrix,
                                         scg_sparsemat, /*directed=*/ 1));

    /* -------------------------------------------------------------------- */
    /* Clean up */

    igraph_sparsemat_destroy(&Rsparse_t);
    IGRAPH_FINALLY_CLEAN(1);
    if (Lsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (graph) {
        igraph_sparsemat_destroy(mysparsemat);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (matrix) {
        igraph_matrix_destroy(mymatrix);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        igraph_sparsemat_destroy(mysparsemat);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}

/**
 * \function igraph_scg_laplacian
 * \brief Spectral coarse graining, Laplacian case.
 *
 * This function handles all the steps involved in the Spectral Coarse
 * Graining (SCG) of some matrices and graphs as described in the
 * reference below.
 *
 * \param graph The input graph. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param matrix The input matrix. Exactly one of \p graph, \p matrix
 *    and \p sparsemat must be given, the other two must be \c NULL
 *    pointers.
 * \param sparsemat The input sparse matrix. Exactly one of \p graph,
 *    \p matrix and \p sparsemat must be given, the other two must be
 *    \c NULL pointers.
 * \param ev A vector of positive integers giving the indexes of the
 *   eigenpairs to be preserved. 1 designates the eigenvalue with
 *    largest magnitude, 2 the one with second largest magnitude, etc.
 * \param nt Positive integer. When \p algo is \c IGRAPH_SCG_OPTIMUM,
 *    it gives the number of groups to partition each eigenvector
 *    separately. When \p algo is \c IGRAPH_SCG_INTERV or \c
 *    IGRAPH_SCG_INTERV_KM, it gives the number of intervals to
 *    partition each eigenvector. This is ignored when \p algo is \c
 *    IGRAPH_SCG_EXACT.
 * \param nt_vec A numeric vector of length one or the length must
 *    match the number of eigenvectors given in \p V, or a \c NULL
 *    pointer. If not \c NULL, then this argument gives the number of
 *    groups or intervals, and \p nt is ignored. Different number of
 *    groups or intervals can be specified for each eigenvector.
 * \param algo The algorithm to solve the SCG problem. Possible
 *    values: \c IGRAPH_SCG_OPTIMUM, \c IGRAPH_SCG_INTERV_KM, \c
 *    IGRAPH_SCG_INTERV and \c IGRAPH_SCG_EXACT. Please see the
 *    details about them above.
 * \param norm Either \c IGRAPH_SCG_NORM_ROW or \c IGRAPH_SCG_NORM_COL.
 *    Specifies whether the rows or the columns of the Laplacian
 *    matrix sum up to zero.
 * \param direction Whether to work with left or right eigenvectors.
 *    Possible values: \c IGRAPH_SCG_DIRECTION_DEFAULT, \c
 *    IGRAPH_SCG_DIRECTION_LEFT, \c IGRAPH_SCG_DIRECTION_RIGHT. This
 *    argument is currently ignored and right eigenvectors are always
 *    used.
 * \param values If this is not \c NULL and the eigenvectors are
 *    re-calculated, then the eigenvalues are stored here.
 * \param vectors If this is not \c NULL, and not a zero-length
 *    matrix, then it is interpreted as the eigenvectors to use for
 *    the coarse-graining. Otherwise the eigenvectors are
 *    re-calculated, and they are stored here. (If this is not \c NULL.)
 * \param groups If this is not \c NULL, and not a zero-length vector,
 *    then it is interpreted as the vector of group labels. (Group
 *    labels are integers from zero and are sequential.) Otherwise
 *    group labels are re-calculated and stored here, if this argument
 *    is not a null pointer.
 * \param use_arpack Whether to use ARPACK for solving the
 *    eigenproblem. Currently ARPACK is not implemented.
 * \param maxiter A positive integer giving the number of iterations
 *    of the k-means algorithm when \p algo is \c
 *    IGRAPH_SCG_INTERV_KM. It is ignored in other cases. A reasonable
 *    (initial) value for this argument is 100.
 * \param scg_graph If not a \c NULL pointer, then the coarse-grained
 *    graph is returned here.
 * \param scg_matrix If not a \c NULL pointer, then it must be an
 *    initialied matrix, and the coarse-grained matrix is returned
 *    here.
 * \param scg_sparsemat If not a \c NULL pointer, then the coarse
 *    grained matrix is returned here, in sparse matrix form.
 * \param L If not a \c NULL pointer, then it must be an initialized
 *    matrix and the left semi-projector is returned here.
 * \param R If not a \c NULL pointer, then it must be an initialized
 *    matrix and the right semi-projector is returned here.
 * \param Lsparse If not a \c NULL pointer, then the left
 *    semi-projector is returned here.
 * \param Rsparse If not a \c NULL pointer, then the right
 *    semi-projector is returned here.
 * \return Error code.
 *
 * Time complexity: TODO.
 *
 * \sa \ref igraph_scg_grouping(), \ref igraph_scg_semiprojectors(),
 * \ref igraph_scg_stochastic() and \ref igraph_scg_adjacency().
 */

int igraph_scg_laplacian(const igraph_t *graph,
                         const igraph_matrix_t *matrix,
                         const igraph_sparsemat_t *sparsemat,
                         const igraph_vector_t *ev,
                         igraph_integer_t nt,
                         const igraph_vector_t *nt_vec,
                         igraph_scg_algorithm_t algo,
                         igraph_scg_norm_t norm,
                         igraph_scg_direction_t direction,
                         igraph_vector_complex_t *values,
                         igraph_matrix_complex_t *vectors,
                         igraph_vector_t *groups,
                         igraph_bool_t use_arpack,
                         igraph_integer_t maxiter,
                         igraph_t *scg_graph,
                         igraph_matrix_t *scg_matrix,
                         igraph_sparsemat_t *scg_sparsemat,
                         igraph_matrix_t *L,
                         igraph_matrix_t *R,
                         igraph_sparsemat_t *Lsparse,
                         igraph_sparsemat_t *Rsparse) {

    igraph_matrix_t *mymatrix = (igraph_matrix_t*) matrix, real_matrix;
    igraph_sparsemat_t *mysparsemat = (igraph_sparsemat_t*) sparsemat,
                        real_sparsemat;
    int no_of_nodes;
    igraph_real_t evmin, evmax;
    igraph_arpack_options_t options;
    igraph_eigen_which_t which;
    /* eigenvectors are calculated and returned */
    igraph_bool_t do_vectors = vectors && igraph_matrix_complex_size(vectors) == 0;
    /* groups are calculated */
    igraph_bool_t do_groups = !groups || igraph_vector_size(groups) == 0;
    igraph_bool_t tmp_groups = !groups;
    /* eigenvectors are not returned but must be calculated for groups */
    igraph_bool_t tmp_vectors = !do_vectors && do_groups;
    igraph_matrix_complex_t myvectors;
    igraph_vector_t mygroups;
    int no_of_ev = (int) igraph_vector_size(ev);
    igraph_bool_t tmp_lsparse = !Lsparse, tmp_rsparse = !Rsparse;
    igraph_sparsemat_t myLsparse, myRsparse, tmpsparse, Rsparse_t;

    IGRAPH_UNUSED(direction);

    /* --------------------------------------------------------------------*/
    /* Argument checks */

    IGRAPH_CHECK(igraph_i_scg_common_checks(graph, matrix, sparsemat,
                                            ev, nt, nt_vec,
                                            0, vectors, groups, scg_graph,
                                            scg_matrix, scg_sparsemat, /*p=*/ 0,
                                            &evmin, &evmax));

    if (graph) {
        no_of_nodes = igraph_vcount(graph);
    } else if (matrix) {
        no_of_nodes = (int) igraph_matrix_nrow(matrix);
    } else {
        no_of_nodes = (int) igraph_sparsemat_nrow(sparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Convert graph, if needed, get Laplacian matrix */

    if (graph) {
        mysparsemat = &real_sparsemat;
        IGRAPH_CHECK(igraph_sparsemat_init(mysparsemat, 0, 0, 0));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
        IGRAPH_CHECK(igraph_laplacian(graph, 0, mysparsemat, /*normalized=*/ 0,
                                      /*weights=*/ 0));
    } else if (matrix) {
        mymatrix = &real_matrix;
        IGRAPH_MATRIX_INIT_FINALLY(mymatrix, no_of_nodes, no_of_nodes);
        IGRAPH_CHECK(igraph_i_matrix_laplacian(matrix, mymatrix, norm));
    } else { /* sparsemat */
        mysparsemat = &real_sparsemat;
        IGRAPH_CHECK(igraph_i_sparsemat_laplacian(sparsemat, mysparsemat,
                     norm == IGRAPH_SCG_NORM_COL));
        IGRAPH_FINALLY(igraph_sparsemat_destroy, mysparsemat);
    }

    /* -------------------------------------------------------------------- */
    /* Compute eigenpairs, if needed */

    if (tmp_vectors) {
        vectors = &myvectors;
        IGRAPH_CHECK(igraph_matrix_complex_init(vectors, no_of_nodes, no_of_ev));
        IGRAPH_FINALLY(igraph_matrix_complex_destroy, vectors);
    }

    if (do_vectors || tmp_vectors) {
        igraph_matrix_complex_t tmp;
        igraph_vector_t tmpev;
        igraph_vector_complex_t tmpeval;
        int i;

        which.pos = IGRAPH_EIGEN_SELECT;
        which.il = (int) (no_of_nodes - evmax + 1);
        which.iu = (int) (no_of_nodes - evmin + 1);

        if (values) {
            IGRAPH_CHECK(igraph_vector_complex_init(&tmpeval, 0));
            IGRAPH_FINALLY(igraph_vector_complex_destroy, &tmpeval);
        }
        IGRAPH_CHECK(igraph_matrix_complex_init(&tmp, no_of_nodes,
                                                which.iu - which.il + 1));
        IGRAPH_FINALLY(igraph_matrix_complex_destroy, &tmp);
        IGRAPH_CHECK(igraph_eigen_matrix(mymatrix, mysparsemat, /*fun=*/ 0,
                                         no_of_nodes, /*extra=*/ 0, use_arpack ?
                                         IGRAPH_EIGEN_ARPACK :
                                         IGRAPH_EIGEN_LAPACK, &which, &options,
                                         /*storage=*/ 0,
                                         values ? &tmpeval : 0, &tmp));

        IGRAPH_VECTOR_INIT_FINALLY(&tmpev, no_of_ev);
        for (i = 0; i < no_of_ev; i++) {
            VECTOR(tmpev)[i] = evmax - VECTOR(*ev)[i];
        }
        if (values) {
            IGRAPH_CHECK(igraph_vector_complex_index(&tmpeval, values, &tmpev));
        }
        IGRAPH_CHECK(igraph_matrix_complex_select_cols(&tmp, vectors, &tmpev));
        igraph_vector_destroy(&tmpev);
        igraph_matrix_complex_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(2);
        if (values) {
            igraph_vector_complex_destroy(&tmpeval);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    /* -------------------------------------------------------------------- */
    /* Work out groups, if needed */
    /* TODO: use complex part as well */
    if (tmp_groups) {
        groups = &mygroups;
        IGRAPH_VECTOR_INIT_FINALLY((igraph_vector_t*)groups, no_of_nodes);
    }
    if (do_groups) {
        igraph_matrix_t tmp;
        IGRAPH_MATRIX_INIT_FINALLY(&tmp, 0, 0);
        IGRAPH_CHECK(igraph_matrix_complex_real(vectors, &tmp));
        IGRAPH_CHECK(igraph_scg_grouping(&tmp, (igraph_vector_t*)groups,
                                         nt, nt_vec,
                                         IGRAPH_SCG_LAPLACIAN, algo,
                                         /*p=*/ 0, maxiter));
        igraph_matrix_destroy(&tmp);
        IGRAPH_FINALLY_CLEAN(1);
    }

    /* -------------------------------------------------------------------- */
    /* Perform coarse graining */
    if (tmp_lsparse) {
        Lsparse = &myLsparse;
    }
    if (tmp_rsparse) {
        Rsparse = &myRsparse;
    }
    IGRAPH_CHECK(igraph_scg_semiprojectors(groups, IGRAPH_SCG_LAPLACIAN,
                                           L, R, Lsparse, Rsparse, /*p=*/ 0,
                                           norm));
    if (tmp_groups) {
        igraph_vector_destroy((igraph_vector_t*) groups);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (tmp_vectors) {
        igraph_matrix_complex_destroy(vectors);
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Rsparse);
    }
    if (Lsparse) {
        IGRAPH_FINALLY(igraph_sparsemat_destroy, Lsparse);
    }

    /* -------------------------------------------------------------------- */
    /* Compute coarse grained matrix/graph/sparse matrix */
    IGRAPH_CHECK(igraph_sparsemat_compress(Rsparse, &tmpsparse));
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &tmpsparse);
    IGRAPH_CHECK(igraph_sparsemat_transpose(&tmpsparse, &Rsparse_t,
                                            /*values=*/ 1));
    igraph_sparsemat_destroy(&tmpsparse);
    IGRAPH_FINALLY_CLEAN(1);
    IGRAPH_FINALLY(igraph_sparsemat_destroy, &Rsparse_t);

    IGRAPH_CHECK(igraph_i_scg_get_result(IGRAPH_SCG_LAPLACIAN,
                                         mymatrix, mysparsemat,
                                         Lsparse, &Rsparse_t,
                                         scg_graph, scg_matrix,
                                         scg_sparsemat, /*directed=*/ 1));

    /* -------------------------------------------------------------------- */
    /* Clean up */

    igraph_sparsemat_destroy(&Rsparse_t);
    IGRAPH_FINALLY_CLEAN(1);
    if (Lsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }
    if (Rsparse) {
        IGRAPH_FINALLY_CLEAN(1);
    }

    if (graph) {
        igraph_sparsemat_destroy(mysparsemat);
        IGRAPH_FINALLY_CLEAN(1);
    } else if (matrix) {
        igraph_matrix_destroy(mymatrix);
        IGRAPH_FINALLY_CLEAN(1);
    } else {
        igraph_sparsemat_destroy(mysparsemat);
        IGRAPH_FINALLY_CLEAN(1);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_approximate_methods.c0000644000175100001710000001415500000000000026277 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-12  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    The intervals_method and intervals_plus_kmeans implements the
 *    methods of sec. 5.3.2 and sec. 5.3.3 of the above reference.
 *    They take an eigenvector 'v' as parameter and a vector 'breaks'
 *    of length 'nb', which provide the intervals used to cut 'v'.
 *    Then all components of 'v' that fall into the same interval are
 *    assigned the same group label in 'gr'. The group labels are
 *    positive consecutive integers starting from 0.
 *    The intervals_method function is adapted from bincode of the R
 *    base package.
 *    The intervals_plus_kmeans is initialized with regularly-spaced
 *    breaks, which rougly corresponds to the intervals_method. Then
 *    kmeans minimizes iteratively the objective function until it gets
 *    stuck in a (usually) local minimum, or until 'itermax' is reached.
 *    So far, the breaks_computation function allows computation of
 *    constant bins, as used in intervals_method, and of equidistant
 *    centers as used in intervals_plus_kmeans.
 */

#include "scg_headers.h"

#include "igraph_error.h"
#include "igraph_types.h"
#include "igraph_vector.h"

int igraph_i_intervals_plus_kmeans(const igraph_vector_t *v, int *gr,
                                   int n, int n_interv,
                                   int maxiter) {
    int i;
    igraph_vector_t centers;

    IGRAPH_VECTOR_INIT_FINALLY(¢ers, n_interv);

    igraph_i_breaks_computation(v, ¢ers, n_interv, 2);
    IGRAPH_CHECK(igraph_i_kmeans_Lloyd(v, n, 1, ¢ers, n_interv, gr,
                                       maxiter));

    /*renumber the groups*/
    for (i = 0; i < n; i++) {
        gr[i] = gr[i] - 1;
    }

    igraph_vector_destroy(¢ers);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

int igraph_i_intervals_method(const igraph_vector_t *v, int *gr, int n,
                              int n_interv) {
    int i, lo, hi, new;
    const int lft = 1;
    const int include_border = 1;
    igraph_vector_t breaks;

    IGRAPH_VECTOR_INIT_FINALLY(&breaks, n_interv + 1);

    IGRAPH_CHECK(igraph_i_breaks_computation(v, &breaks, n_interv + 1, 1));

    for (i = 0; i < n; i++) {
        lo = 0;
        hi = n_interv;
        if (VECTOR(*v)[i] <  VECTOR(breaks)[lo] ||
            VECTOR(breaks)[hi] < VECTOR(*v)[i] ||
            (VECTOR(*v)[i] == VECTOR(breaks)[lft ? hi : lo] && !include_border)) {
            /* Do nothing */
        } else {
            while (hi - lo >= 2) {
                new = (hi + lo) / 2;
                if (VECTOR(*v)[i] > VECTOR(breaks)[new] ||
                    (lft && VECTOR(*v)[i] == VECTOR(breaks)[new])) {
                    lo = new;
                } else {
                    hi = new;
                }
            }
            gr[i] = lo;
        }
    }
    igraph_vector_destroy(&breaks);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}

int igraph_i_breaks_computation(const igraph_vector_t *v,
                                igraph_vector_t *breaks,
                                int nb, int method) {
    int i;
    igraph_real_t eps, vmin, vmax;
    igraph_vector_minmax(v, &vmin, &vmax);

    if (vmax == vmin) {
        IGRAPH_ERROR("There is only one (repeated) value in argument 'v' "
                     "of bin_size_computation()", IGRAPH_EINVAL);
    }

    if (nb < 2) {
        IGRAPH_ERROR("'nb' in bin_size_computation() must be >= 2",
                     IGRAPH_EINVAL);
    }

    switch (method) {
    case 1: /* constant bins for fixed-size intervals method */
        eps = (vmax - vmin) / (igraph_real_t)(nb - 1);
        VECTOR(*breaks)[0] = vmin;
        for (i = 1; i < nb - 1; i++) {
            VECTOR(*breaks)[i] = VECTOR(*breaks)[i - 1] + eps;
        }
        VECTOR(*breaks)[nb - 1] = vmax;
        break;
    case 2: /* equidistant centers for kmeans */
        eps = (vmax - vmin) / (igraph_real_t)nb;
        VECTOR(*breaks)[0] = vmin + eps / 2.;
        for (i = 1; i < nb; i++) {
            VECTOR(*breaks)[i] = VECTOR(*breaks)[i - 1] + eps;
        }
        break;
    /* TODO: implement logarithmic binning for power-law-like distributions */
    default:
        IGRAPH_ERROR("Internal SCG error, this should ot happen",
                     IGRAPH_FAILURE);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_exact_scg.c0000644000175100001710000000431200000000000024155 0ustar00runnerdocker00000000000000/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    The exact_coarse_graining function labels all the objects whose
 *    components in 'v' are equal. The result is stored in 'gr'. Labels
 *    are positive consecutive integers starting from 0.
 *    See also Section 5.4.1 (last paragraph) of the above reference.
 */

#include "scg_headers.h"

#include "igraph_memory.h"
#include "igraph_qsort.h"

#include 

int igraph_i_exact_coarse_graining(const igraph_real_t *v,
                                   int *gr, int n) {
    int i, gr_nb;
    igraph_i_scg_indval_t *w = IGRAPH_CALLOC(n, igraph_i_scg_indval_t);

    if (!w) {
        IGRAPH_ERROR("SCG error", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, w);

    for (i = 0; i < n; i++) {
        w[i].val = v[i];
        w[i].ind = i;
    }

    igraph_qsort(w, (size_t) n, sizeof(igraph_i_scg_indval_t), igraph_i_compare_ind_val);

    gr_nb = 0;
    gr[w[0].ind] = gr_nb;
    for (i = 1; i < n; i++) {
        if ( fabs(w[i].val - w[i - 1].val) > 1e-14 ) {
            gr_nb++;
        }
        gr[w[i].ind] = gr_nb;
    }

    IGRAPH_FREE(w);
    IGRAPH_FINALLY_CLEAN(1);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_headers.h0000644000175100001710000001155200000000000023641 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    This file contains the headers of the library SCGlib.
 *    For use with R software  define
 *    the constant R_COMPIL and refer to the R documentation to compile
 *    a dynamic library. The scg_r_wrapper function should be useful.
 */

#ifndef SCG_HEADERS_H
#define SCG_HEADERS_H

#include "igraph_types.h"
#include "igraph_vector.h"

#include 
#include 

typedef struct ind_val {
    int ind;
    igraph_real_t val;
} igraph_i_scg_indval_t;

int igraph_i_compare_ind_val(const void *a, const void *b);

typedef struct groups {
    int ind;
    int n;
    int* gr;
} igraph_i_scg_groups_t;

/*-------------------------------------------------
------------DEFINED IN scg_approximate_methods.c---
---------------------------------------------------*/

int igraph_i_breaks_computation(const igraph_vector_t *v,
                                igraph_vector_t *breaks, int nb,
                                int method);
int igraph_i_intervals_plus_kmeans(const igraph_vector_t *v, int *gr,
                                   int n, int n_interv,
                                   int maxiter);
int igraph_i_intervals_method(const igraph_vector_t *v, int *gr,
                              int n, int n_interv);

/*-------------------------------------------------
------------DEFINED IN scg_optimal_method.c--------
---------------------------------------------------*/

int igraph_i_cost_matrix(igraph_real_t *Cv, const igraph_i_scg_indval_t *vs,
                         int n, int matrix, const igraph_vector_t *ps);
int igraph_i_optimal_partition(const igraph_real_t *v, igraph_integer_t *gr, int n, int nt,
                               int matrix, const igraph_real_t *p,
                               igraph_real_t *value);

/*-------------------------------------------------
------------DEFINED IN scg_kmeans.c----------------
---------------------------------------------------*/

int igraph_i_kmeans_Lloyd(const igraph_vector_t *x, int n,
                          int p, igraph_vector_t *centers,
                          int k, int *cl, int maxiter);

/*-------------------------------------------------
------------DEFINED IN scg_exact_scg.c-------------
---------------------------------------------------*/

int igraph_i_exact_coarse_graining(const igraph_real_t *v, int *gr,
                                   int n);

/*-------------------------------------------------
------------DEFINED IN scg_utils.c-----------------
---------------------------------------------------*/

int igraph_i_compare_groups(const void *a, const void *b);
int igraph_i_compare_real(const void *a, const void *b);
int igraph_i_compare_int(const void *a, const void *b);

igraph_real_t *igraph_i_real_sym_matrix(int size);
#define igraph_i_real_sym_mat_get(S,i,j) S[i+j*(j+1)/2]
#define igraph_i_real_sym_mat_set(S,i,j,val) S[i+j*(j+1)/2] = val
#define igraph_i_free_real_sym_matrix(S) IGRAPH_FREE(S)

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_kmeans.c0000644000175100001710000000656100000000000023503 0ustar00runnerdocker00000000000000/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    The kmeans_Lloyd function is adapted from the R-stats package.
 *    It perfoms Lloyd's k-means clustering on a p x n data matrix
 *    stored row-wise in a vector 'x'. 'cen' contains k initial centers.
 *    The group label to which each object belongs is stored in 'cl'.
 *    Labels are positive consecutive integers starting from 0.
 *    See also Section 5.3.3 of the above reference.
 */

#include "scg_headers.h"

int igraph_i_kmeans_Lloyd(const igraph_vector_t *x, int n, int p,
                          igraph_vector_t *cen, int k, int *cl, int maxiter) {

    int iter, i, j, c, it, inew = 0;
    igraph_real_t best, dd, tmp;
    int updated;
    igraph_vector_int_t nc;

    IGRAPH_CHECK(igraph_vector_int_init(&nc, k));
    IGRAPH_FINALLY(igraph_vector_int_destroy, &nc);

    for (i = 0; i < n; i++) {
        cl[i] = -1;
    }
    for (iter = 0; iter < maxiter; iter++) {
        updated = 0;
        for (i = 0; i < n; i++) {
            /* find nearest centre for each point */
            best = IGRAPH_INFINITY;
            for (j = 0; j < k; j++) {
                dd = 0.0;
                for (c = 0; c < p; c++) {
                    tmp = VECTOR(*x)[i + n * c] - VECTOR(*cen)[j + k * c];
                    dd += tmp * tmp;
                }
                if (dd < best) {
                    best = dd;
                    inew = j + 1;
                }
            }
            if (cl[i] != inew) {
                updated = 1;
                cl[i] = inew;
            }
        }
        if (!updated) {
            break;
        }

        /* update each centre */
        for (j = 0; j < k * p; j++) {
            VECTOR(*cen)[j] = 0.0;
        }
        for (j = 0; j < k; j++) {
            VECTOR(nc)[j] = 0;
        }
        for (i = 0; i < n; i++) {
            it = cl[i] - 1;
            VECTOR(nc)[it]++;
            for (c = 0; c < p; c++) {
                VECTOR(*cen)[it + c * k] += VECTOR(*x)[i + c * n];
            }
        }
        for (j = 0; j < k * p; j++) {
            VECTOR(*cen)[j] /= VECTOR(nc)[j % k];
        }
    }
    igraph_vector_int_destroy(&nc);
    IGRAPH_FINALLY_CLEAN(1);

    /* convervenge check */
    if (iter >= maxiter - 1) {
        IGRAPH_ERROR("Lloyd k-means did not converge", IGRAPH_FAILURE);
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_optimal_method.c0000644000175100001710000001754100000000000025232 0ustar00runnerdocker00000000000000/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    This file implements algorithm 5.8 of the above reference.
 *    The optimal_partition function returns the minimizing partition
 *    with size 'nt' of the objective function ||v-Pv||, where P is
 *    a problem-specific projector. So far, Symmetric (matrix=1),
 *    Laplacian (matrix=2) and Stochastic (matrix=3) projectors
 *    have been implemented (the cost_matrix function below).
 *    In the stochastic case, 'p' is expected to be a valid propability
 *    vector. In all other cases, 'p' is ignored and can be set to NULL.
 *    The group labels are given in 'gr' as positive consecutive integers
 *    starting from 0.
 */

#include "scg_headers.h"

#include "igraph_error.h"
#include "igraph_memory.h"
#include "igraph_matrix.h"
#include "igraph_vector.h"
#include "igraph_qsort.h"

int igraph_i_optimal_partition(const igraph_real_t *v, igraph_integer_t *gr, int n,
                               int nt, int matrix, const igraph_real_t *p,
                               igraph_real_t *value) {

    int i, non_ties, q, j, l, part_ind, col;
    igraph_i_scg_indval_t *vs = IGRAPH_CALLOC(n, igraph_i_scg_indval_t);
    igraph_real_t *Cv, temp, sumOfSquares;
    igraph_vector_t ps;
    igraph_matrix_t F;
    igraph_matrix_int_t Q;

    /*-----------------------------------------------
      -----Sorts v and counts non-ties-----------------
      -----------------------------------------------*/

    if (!vs) {
        IGRAPH_ERROR("SCG error", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, vs);

    for (i = 0; i < n; i++) {
        vs[i].val = v[i];
        vs[i].ind = i;
    }

    igraph_qsort(vs, (size_t) n, sizeof(igraph_i_scg_indval_t),
          igraph_i_compare_ind_val);

    non_ties = 1;
    for (i = 1; i < n; i++) {
        if (vs[i].val < vs[i - 1].val - 1e-14 ||
            vs[i].val > vs[i - 1].val + 1e-14) {
            non_ties++;
        }
    }

    if (nt >= non_ties) {
        IGRAPH_ERROR("`Invalid number of intervals, should be smaller than "
                     "number of unique values in V", IGRAPH_EINVAL);
    }

    /*------------------------------------------------
      ------Computes Cv, the matrix of costs------------
      ------------------------------------------------*/
    Cv = igraph_i_real_sym_matrix(n);
    if (!Cv) {
        IGRAPH_ERROR("SCG error", IGRAPH_ENOMEM);
    }
    IGRAPH_FINALLY(igraph_free, Cv);

    /* if stochastic SCG orders p */
    if (matrix == 3) {
        IGRAPH_VECTOR_INIT_FINALLY(&ps, n);
        for (i = 0; i < n; i++) {
            VECTOR(ps)[i] = p[vs[i].ind];
        }
    }

    IGRAPH_CHECK(igraph_i_cost_matrix(Cv, vs, n, matrix, &ps));
    if (matrix == 3) {
        igraph_vector_destroy(&ps);
        IGRAPH_FINALLY_CLEAN(1);
    }
    /*-------------------------------------------------
      -------Fills up matrices F and Q-------------------
      -------------------------------------------------*/
    /*here j also is a counter but the use of unsigned variables
      is to be proscribed in "for (unsigned int j=...;j>=0;j--)",
      for such loops never ends!*/

    IGRAPH_MATRIX_INIT_FINALLY(&F, nt, n);
    IGRAPH_CHECK(igraph_matrix_int_init(&Q, nt, n));
    IGRAPH_FINALLY(igraph_matrix_int_destroy, &Q);

    for (i = 0; i < n; i++) {
        MATRIX(Q, 0, i)++;
    }
    for (i = 0; i < nt; i++) {
        MATRIX(Q, i, i) = i + 1;
    }

    for (i = 0; i < n; i++) {
        MATRIX(F, 0, i) = igraph_i_real_sym_mat_get(Cv, 0, i);
    }

    for (i = 1; i < nt; i++)
        for (j = i + 1; j < n; j++) {
            MATRIX(F, i, j) = MATRIX(F, i - 1, i - 1) + igraph_i_real_sym_mat_get(Cv, i, j);
            MATRIX(Q, i, j) = 2;

            for (q = i - 1; q <= j - 1; q++) {
                temp = MATRIX(F, i - 1, q) + igraph_i_real_sym_mat_get(Cv, q + 1, j);
                if (temp < MATRIX(F, i, j)) {
                    MATRIX(F, i, j) = temp;
                    MATRIX(Q, i, j) = q + 2;
                }
            }
        }
    igraph_i_free_real_sym_matrix(Cv);
    IGRAPH_FINALLY_CLEAN(1);

    /*--------------------------------------------------
      -------Back-tracks through Q to work out the groups-
      --------------------------------------------------*/
    part_ind = nt;
    col = n - 1;

    for (j = nt - 1; j >= 0; j--) {
        for (i = MATRIX(Q, j, col) - 1; i <= col; i++) {
            gr[vs[i].ind] = part_ind - 1;
        }
        if (MATRIX(Q, j, col) != 2) {
            col = MATRIX(Q, j, col) - 2;
            part_ind -= 1;
        } else {
            if (j > 1) {
                for (l = 0; l <= (j - 1); l++) {
                    gr[vs[l].ind] = l;
                }
                break;
            } else {
                col = MATRIX(Q, j, col) - 2;
                part_ind -= 1;
            }
        }
    }

    sumOfSquares = MATRIX(F, nt - 1, n - 1);

    igraph_matrix_destroy(&F);
    igraph_matrix_int_destroy(&Q);
    IGRAPH_FREE(vs);
    IGRAPH_FINALLY_CLEAN(3);

    if (value) {
        *value = sumOfSquares;
    }
    return 0;
}

int igraph_i_cost_matrix(igraph_real_t*Cv, const igraph_i_scg_indval_t *vs,
                         int n,  int matrix, const igraph_vector_t *ps) {

    /* if symmetric of Laplacian SCG -> same Cv */
    if (matrix == 1 || matrix == 2) {
        int i, j;
        igraph_vector_t w, w2;

        IGRAPH_VECTOR_INIT_FINALLY(&w, n + 1);
        IGRAPH_VECTOR_INIT_FINALLY(&w2, n + 1);

        VECTOR(w)[1] = vs[0].val;
        VECTOR(w2)[1] = vs[0].val * vs[0].val;

        for (i = 2; i <= n; i++) {
            VECTOR(w)[i] = VECTOR(w)[i - 1] + vs[i - 1].val;
            VECTOR(w2)[i] = VECTOR(w2)[i - 1] + vs[i - 1].val * vs[i - 1].val;
        }

        for (i = 0; i < n; i++) {
            for (j = i + 1; j < n; j++) {
                igraph_real_t v = (VECTOR(w2)[j + 1] - VECTOR(w2)[i]) -
                                  (VECTOR(w)[j + 1] - VECTOR(w)[i]) * (VECTOR(w)[j + 1] - VECTOR(w)[i]) /
                                  (j - i + 1);
                igraph_i_real_sym_mat_set(Cv, i, j, v);
            }
        }

        igraph_vector_destroy(&w);
        igraph_vector_destroy(&w2);
        IGRAPH_FINALLY_CLEAN(2);
    }
    /* if stochastic */
    /* TODO: optimize it to O(n^2) instead of O(n^3) (as above) */
    if (matrix == 3) {
        int i, j, k;
        igraph_real_t t1, t2;
        for (i = 0; i < n; i++) {
            for (j = i + 1; j < n; j++) {
                t1 = t2 = 0;
                for (k = i; k < j; k++) {
                    t1 += VECTOR(*ps)[k];
                    t2 += VECTOR(*ps)[k] * vs[k].val;
                }
                t1 = t2 / t1;
                t2 = 0;
                for (k = i; k < j; k++) {
                    t2 += (vs[k].val - t1) * (vs[k].val - t1);
                }
                igraph_i_real_sym_mat_set(Cv, i, j, t2);
            }
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/scg/scg_utils.c0000644000175100001710000000600400000000000023355 0ustar00runnerdocker00000000000000/*
 *  SCGlib : A C library for the spectral coarse graining of matrices
 *  as described in the paper: Shrinking Matrices while preserving their
 *  eigenpairs with Application to the Spectral Coarse Graining of Graphs.
 *  Preprint available at 
 *
 *  Copyright (C) 2008 David Morton de Lachapelle 
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301 USA
 *
 *  DESCRIPTION
 *  -----------
 *    This files contains the data structures and error handing
 *    functions used throughout the SCGlib.
 */

#include "scg_headers.h"

#include "igraph_error.h"
#include "igraph_memory.h"

/*to be used with qsort and struct ind_val arrays */
int igraph_i_compare_ind_val(const void *a, const void *b) {
    igraph_i_scg_indval_t *arg1 = (igraph_i_scg_indval_t *) a;
    igraph_i_scg_indval_t *arg2 = (igraph_i_scg_indval_t *) b;

    if ( arg1->val < arg2->val ) {
        return -1;
    } else if ( arg1->val == arg2->val ) {
        return 0;
    } else {
        return 1;
    }
}

/*to be used with qsort and struct groups*/
int igraph_i_compare_groups(const void *a, const void *b) {
    igraph_i_scg_groups_t *arg1 = (igraph_i_scg_groups_t *) a;
    igraph_i_scg_groups_t *arg2 = (igraph_i_scg_groups_t *) b;
    int i;
    for (i = 0; i < arg1->n; i++) {
        if (arg1->gr[i] > arg2->gr[i]) {
            return 1;
        } else if (arg1->gr[i] < arg2->gr[i]) {
            return -1;
        }
    }
    return 0;
}

/*to be used with qsort and real_vectors */
int igraph_i_compare_real(const void *a, const void *b) {
    igraph_real_t arg1 = * (igraph_real_t *) a;
    igraph_real_t arg2 = * (igraph_real_t *) b;

    if (arg1 < arg2) {
        return -1;
    } else if (arg1 == arg2) {
        return 0;
    } else {
        return 1;
    }
}

/*to be used with qsort and integer vectors */
int igraph_i_compare_int(const void *a, const void *b) {
    int arg1 = * (int *) a;
    int arg2 = * (int *) b;
    return (arg1 - arg2);
}

/* allocate a igraph_real_t symmetrix matrix with dimension size x size
   in vector format*/
igraph_real_t *igraph_i_real_sym_matrix(int size)  {
    igraph_real_t *S = IGRAPH_CALLOC(size * (size + 1) / 2, igraph_real_t);
    if (!S) {
        igraph_error("allocation failure in real_sym_matrix()",
                     IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_ENOMEM);
    }
    return S;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/src/version.c0000644000175100001710000000423500000000000022276 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include "igraph_version.h"

#include 

static const char *igraph_version_string = IGRAPH_VERSION;

/**
 * \function igraph_version
 * Return the version of the igraph C library
 *
 * \param version_string Pointer to a string pointer. If not null, it
 *    is set to the igraph version string, e.g. "0.6" or "0.5.3". This
 *    string should not be modified or deallocated.
 * \param major If not a null pointer, then it is set to the major
 *    igraph version. E.g. for version "0.5.3" this is 0.
 * \param minor If not a null pointer, then it is set to the minor
 *    igraph version. E.g. for version "0.5.3" this is 5.
 * \param subminor If not a null pointer, then it is set to the
 *    subminor igraph version. E.g. for version "0.5.3" this is 3.
 * \return Error code.
 *
 * Time complexity: O(1).
 *
 * \example examples/simple/igraph_version.c
 */

int igraph_version(const char **version_string,
                   int *major,
                   int *minor,
                   int *subminor) {
    int i1, i2, i3;
    int *p1 = major ? major : &i1,
         *p2 = minor ? minor : &i2,
          *p3 = subminor ? subminor : &i3;

    if (version_string) {
        *version_string = igraph_version_string;
    }

    *p1 = *p2 = *p3 = 0;
    sscanf(IGRAPH_VERSION, "%i.%i.%i", p1, p2, p3);

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5431414
igraph-0.9.9/vendor/source/igraph/tests/0000755000175100001710000000000000000000000021014 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/CMakeLists.txt0000644000175100001710000003725400000000000023567 0ustar00runnerdocker00000000000000include(test_helpers)
include(benchmark_helpers)

# Add a compatibility alias to the "test" target so it can also be invoked as
# "make check" - for people who have it in their muscle memories from autotools
add_custom_target(build_tests)
add_custom_target(
  check
  COMMAND ${CMAKE_CTEST_COMMAND} --progress --output-on-failure -C $
  COMMENT "Executing unit tests..."
  USES_TERMINAL
)
add_dependencies(check build_tests)

# Add a custom target for benchmarks and another one for building them
# TODO(ntamas)
add_custom_target(build_benchmarks)
add_custom_target(
  benchmark
  COMMAND true
  COMMENT "Running benchmarks..."
)
add_dependencies(benchmark build_benchmarks)

# Some newer gcc version have --enable-new-dtags on by default. This then leads
# to using RUNPATH instead of RPATH. Since RUNPATH is only considered after
# LD_LIBRARY_PATH, if another version of igraph is installed somewhere it will
# be linked to that library.
include(CheckCCompilerFlag)
set(ORIG_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
set(CMAKE_REQUIRED_FLAGS "-Wl,--enable-new-dtags")
check_c_compiler_flag("" HAVE_ENABLE_NEW_DTAGS)
set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
if (HAVE_ENABLE_NEW_DTAGS AND BUILD_SHARED_LIBS)
  message(STATUS "Disabling new dtags for testing to use RPATH to ensure the correct library is found.")
  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--disable-new-dtags")
endif()

# tutorial examples and other snippets from the documentation
add_examples(
  FOLDER examples/simple NAMES
  igraph_free
)
add_examples(
  FOLDER examples/tutorial NAMES
  tutorial1
  tutorial2
  tutorial3
)

# version.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_version
)

# types.at
add_examples(
  FOLDER examples/simple NAMES
  dqueue
  igraph_sparsemat
  igraph_sparsemat3
  igraph_sparsemat4
  igraph_sparsemat6
  igraph_sparsemat7
  igraph_sparsemat8
  igraph_strvector
  igraph_vector_ptr_sort
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  heap
  igraph_array
  igraph_complex
  igraph_psumtree
  igraph_sparsemat5
  igraph_sparsemat9
  igraph_sparsemat_droptol
  igraph_sparsemat_fkeep
  igraph_sparsemat_getelements_sorted
  igraph_sparsemat_is_symmetric
  igraph_sparsemat_iterator_idx
  igraph_sparsemat_minmax
  igraph_sparsemat_nonzero_storage
  igraph_sparsemat_view
  igraph_sparsemat_which_minmax
  igraph_spmatrix_add_col_values
  igraph_vector_floor
  igraph_vector_lex_cmp
  matrix
  matrix2
  matrix3
  spmatrix
  spmatrix_clear
  stack
  strvector_set2_remove_print
  vector
  vector2
  vector3
  vector_ptr
)

if ((NOT BUILD_SHARED_LIBS) OR (NOT BLAS_IS_VENDORED AND NOT ARPACK_IS_VENDORED))
  add_legacy_tests(
    FOLDER tests/unit NAMES
    igraph_sparsemat2 # Uses ARPACK and BLAS functions which are not publicly available when building with internal ARPACK/BLAS
  )
endif()

add_legacy_tests(
  FOLDER tests/unit NAMES
  2wheap
  cutheap
  d_indheap
  hashtable
  marked_queue
  set
  trie
)

# basic.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_add_edges
  igraph_add_vertices
  igraph_copy
  igraph_degree
  igraph_delete_edges
  igraph_delete_vertices
  igraph_empty
  igraph_get_eid
  igraph_get_eids
  igraph_is_directed
  igraph_neighbors
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_is_same_graph
  igraph_i_incident
  igraph_i_neighbors
)

# iterators.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_es_pairs
#  igraph_es_fromto
  igraph_vs_nonadj
  igraph_vs_seq
  igraph_vs_vector
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  edge_selectors
  igraph_es_path
  vertex_selectors
)

# structure_generators.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_adjacency
  igraph_atlas
  igraph_barabasi_game
  igraph_barabasi_game2
  igraph_create
  igraph_degree_sequence_game
  igraph_erdos_renyi_game
  igraph_full
  igraph_grg_game
  igraph_lcf
  igraph_ring
  igraph_small
  igraph_star
  igraph_tree
  igraph_weighted_adjacency
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  erdos_renyi_game
  full
  igraph_barabasi_aging_game
  igraph_bipartite_game
  igraph_callaway_traits_game
  igraph_cited_type_game
  igraph_citing_cited_type_game
  igraph_correlated_game
  igraph_degree_sequence_game
  igraph_establishment_game
  igraph_extended_chordal_ring
  igraph_forest_fire_game
  igraph_from_prufer
  igraph_full_citation
  igraph_grg_game
  igraph_growing_random_game
  igraph_k_regular_game
  igraph_lastcit_game
  igraph_lattice
  igraph_linegraph
  igraph_kautz
  igraph_preference_game
  igraph_realize_degree_sequence
  igraph_recent_degree_aging_game
  igraph_recent_degree_game
  igraph_sbm_game
  igraph_simple_interconnected_islands_game
  igraph_static_power_law_game
  tree
  tree_game
  ring
  watts_strogatz_game
)

# structural_properties.at
add_examples(
  FOLDER examples/simple NAMES
  assortativity
  bellman_ford
  dijkstra
  igraph_average_path_length
  igraph_cocitation
  igraph_diameter
  igraph_eccentricity
  igraph_feedback_arc_set
  igraph_feedback_arc_set_ip
  igraph_get_all_shortest_paths_dijkstra
  igraph_get_shortest_paths
  igraph_get_shortest_paths_dijkstra
  igraph_girth
  igraph_has_multiple
  igraph_is_loop
  igraph_is_multiple
  igraph_knn
  igraph_minimum_spanning_tree
  igraph_pagerank
  igraph_radius
  igraph_reciprocity
  igraph_similarity
  igraph_simplify
  igraph_topological_sorting
  igraph_transitivity
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_rewire # Uses internal igraph_i_rewire
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  all_shortest_paths
  efficiency
  global_transitivity
  igraph_adjacent_triangles
  igraph_are_connected
  igraph_average_path_length
  igraph_average_path_length_dijkstra
  igraph_betweenness
  igraph_closeness
  igraph_convergence_degree
  igraph_count_multiple
  igraph_density
  igraph_diversity
  igraph_eccentricity
  igraph_edge_betweenness
  igraph_get_all_simple_paths
  igraph_get_shortest_paths2
  igraph_get_shortest_paths_bellman_ford
  igraph_is_bipartite
  igraph_is_connected
  igraph_is_chordal
  igraph_is_mutual
  igraph_is_tree
  igraph_list_triangles
  igraph_local_scan_k_ecount
  igraph_local_transitivity
  igraph_neighborhood
  igraph_neighborhood_graphs
  igraph_neighborhood_size
  igraph_pagerank
  igraph_shortest_paths_johnson
  igraph_transitive_closure_dag
  igraph_transitivity_avglocal_undirected
  igraph_transitivity_barrat
  harmonic_centrality
  random_spanning_tree
  single_target_shortest_path
  topological_sorting
)

add_legacy_tests(
  FOLDER tests/regression NAMES
  bug_1760
  bug_1814
)

# components.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_biconnected_components
  igraph_decompose
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_bridges
  igraph_decompose_strong
  igraph_subcomponent
)

# layout.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_layout_reingold_tilford
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_layout_drl
  igraph_layout_bipartite
  igraph_layout_fruchterman_reingold
  igraph_layout_graphopt
  igraph_layout_grid
  igraph_layout_lgl
  igraph_layout_mds
  igraph_layout_merge2
  igraph_layout_merge3
  igraph_layout_random_3d
  igraph_layout_reingold_tilford_circular
  igraph_layout_reingold_tilford_extended
  igraph_layout_star
  igraph_layout_sugiyama
)
add_legacy_tests(
  FOLDER tests/regression NAMES
  igraph_layout_kamada_kawai_3d_bug_1462
  igraph_layout_reingold_tilford_bug_879
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_i_layout_sphere
  igraph_layout_davidson_harel # Uses igraph_i_layout_segments_intersect and igraph_i_layout_point_segment_dist2
  igraph_layout_merge # Uses igraph_i_layout_merge functions
)

# visitors.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_bfs
  igraph_bfs_callback
  igraph_bfs_simple
)
add_legacy_tests(
  FOLDER tests/unit NAMES
  bfs
  bfs_simple
  igraph_random_walk
)

# topology.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_isomorphic_vf2
  igraph_subisomorphic_lad
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  simplify_and_colorize
  bliss_automorphisms
  igraph_get_isomorphisms_vf2
  igraph_get_subisomorphisms_vf2
  igraph_subisomorphic
  igraph_isomorphic_bliss
  isomorphism_test
  isoclasses
  isoclasses2
  VF2-compat
)

# coloring.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_coloring
)

# motifs.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_motifs_randesu
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_dyad_census
  igraph_motifs_randesu
  igraph_motifs_randesu_estimate
  igraph_motifs_randesu_no
  triad_census
)

# foreign.at
add_examples(
  FOLDER examples/simple NAMES
  dot
  foreign
  gml
  graphml
  igraph_read_graph_dl
  igraph_read_graph_graphdb
  igraph_read_graph_lgl
  igraph_write_graph_lgl
  igraph_write_graph_pajek
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_write_graph_leda
  igraph_write_graph_dimacs
  lineendings
  pajek
  pajek2
  pajek_bipartite
  pajek_bipartite2
  pajek_signed
)

# other.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_convex_hull
  igraph_power_law_fit
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_almost_equals
)

# operators.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_complementer
  igraph_compose
  igraph_difference
  igraph_disjoint_union
  igraph_intersection
  igraph_union
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_induced_subgraph
  igraph_induced_subgraph_map
  igraph_intersection2
  igraph_rewire_directed_edges
)

# conversion.at
add_examples(
  FOLDER examples/simple NAMES
  adjlist
  igraph_laplacian
  igraph_to_undirected
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  adjlist
  igraph_get_adjacency_sparse
  igraph_to_directed
  igraph_to_prufer
  inclist
)

# flow.at
add_examples(
  FOLDER examples/simple NAMES
  dominator_tree
  even_tarjan
  flow
  flow2
  igraph_all_st_mincuts
  igraph_mincut
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_st_mincut_value
  igraph_vertex_disjoint_paths
  igraph_adhesion
  igraph_cohesion
  igraph_residual_graph
  igraph_edge_disjoint_paths
  igraph_st_edge_connectivity
  igraph_st_mincut
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_all_st_cuts # Uses igraph_marked_queue, which is internal.
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_gomory_hu_tree
)

# community.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_community_edge_betweenness
  igraph_community_fastgreedy
  igraph_community_fluid_communities
  igraph_community_label_propagation
  igraph_community_leading_eigenvector
  igraph_community_leiden
  igraph_community_multilevel
  igraph_community_optimal_modularity
  walktrap
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  community_leiden
  community_label_propagation
  community_label_propagation2
  community_label_propagation3
  igraph_community_infomap
  igraph_community_leading_eigenvector2
  igraph_compare_communities
  igraph_le_community_to_membership
  igraph_modularity
  igraph_modularity_matrix
  igraph_split_join_distance
  levc-stress
  spinglass
)
add_legacy_tests(
  FOLDER tests/regression NAMES
  bug-1149658
)

# use a higher test timeout for the Infomap algorithm
set_tests_properties("test::igraph_community_infomap" PROPERTIES TIMEOUT 150)

# cliques.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_cliques
  igraph_independent_sets
  igraph_maximal_cliques
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_clique_size_hist
  igraph_maximal_cliques2
  igraph_maximal_cliques3
  igraph_maximal_cliques4
  igraph_maximal_cliques_file
  igraph_weighted_cliques
  maximal_cliques_callback
  maximal_cliques_hist
)

# eigen.at
add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_eigen_matrix
  igraph_eigen_matrix2
  igraph_eigen_matrix3
  igraph_eigen_matrix4
  igraph_eigen_matrix_symmetric
  igraph_eigen_matrix_symmetric_arpack
)

# attributes.at
add_examples(
  FOLDER examples/simple NAMES
  cattributes
  cattributes2
  cattributes3
  cattributes4
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_attribute_combination_remove
  cattributes5
)
add_legacy_tests(
  FOLDER tests/regression NAMES
  cattr_bool_bug
  cattr_bool_bug2
)

# arpack.at
add_examples(
  FOLDER examples/simple NAMES
  blas
  eigenvector_centrality
  igraph_lapack_dgeev
  igraph_lapack_dgeevx
  igraph_lapack_dgesv
  igraph_lapack_dsyevr
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  dgemv
  igraph_arpack_rnsolve
  igraph_arpack_unpack_complex
  igraph_lapack_dgehrd
  igraph_lapack_dgetrf
  igraph_lapack_dgetrs
)

# bipartite.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_bipartite_create
  igraph_bipartite_projection
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_get_incidence
)

# centralization.at
add_examples(
  FOLDER examples/simple NAMES
  centralization
)

# eulerian.at
add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_is_eulerian
  igraph_eulerian_cycle
  igraph_eulerian_path
)

# separators.at
add_examples(
  FOLDER examples/simple NAMES
  cohesive_blocks
  igraph_is_minimal_separator
  igraph_is_separator
  igraph_minimal_separators
  igraph_minimum_size_separators
)
add_legacy_tests(
  FOLDER tests/regression NAMES
  bug-1033045
)

# hrg.at
add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_hrg
  igraph_hrg2
  igraph_hrg3
)

# microscopic.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_deterministic_optimal_imitation
  igraph_roulette_wheel_imitation
  igraph_stochastic_imitation
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_moran_process
)

# mt.at -- only if we have pthreads
if(CMAKE_USE_PTHREADS_INIT)
  add_legacy_tests(
    FOLDER tests/unit NAMES tls1
    LIBRARIES Threads::Threads
  )

  # tls2 should be added only if we use vendored ARPACK because a non-vendored
  # ARPACK is not guaranteed to be thread-safe
  if(ARPACK_IS_VENDORED AND NOT BUILD_SHARED_LIBS)
    add_legacy_tests(
      FOLDER tests/unit NAMES tls2
      LIBRARIES Threads::Threads
    )
  endif()
endif()

# scg.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_scg_grouping
  igraph_scg_grouping2
  igraph_scg_grouping3
  igraph_scg_grouping4
  igraph_scg_semiprojectors
  igraph_scg_semiprojectors2
  igraph_scg_semiprojectors3
  scg
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  scg2
  scg3
)

# random.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_fisher_yates_shuffle
  igraph_random_sample
  random_seed
)

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_rng_get_exp
  igraph_rng_get_integer
  mt
  rng_reproducibility
  rng_init_destroy_max_min_name_set_default
)

# qsort.at
add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_qsort
  igraph_qsort_r
)

# matching.at
add_examples(
  FOLDER examples/simple NAMES
  igraph_maximum_bipartite_matching
)

# embedding.at
add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_adjacency_spectral_embedding
)

# graphicality

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_is_graphical
  igraph_is_bigraphical
)

# handlers

add_legacy_tests(
  FOLDER tests/unit NAMES
  fatal_handler
  igraph_progress_handler_stderr
  igraph_set_progress_handler
)

# error output

add_legacy_tests(
  FOLDER tests/unit NAMES
  error_macros
)

# GLPK

add_legacy_tests(
  FOLDER tests/unit NAMES
  glpk_error
)

# regression and fuzzing tests

add_legacy_tests(
  FOLDER tests/regression NAMES
  igraph_read_graph_gml_invalid_inputs
  igraph_read_graph_graphml_invalid_inputs
)

# non-graph

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_running_mean
  igraph_solve_lsap
)

# memory allocation

add_legacy_tests(
  FOLDER tests/unit NAMES
  zero_allocs
)

# simulation

add_legacy_tests(
  FOLDER tests/unit NAMES
  igraph_sir
)


# benchmarks
add_benchmarks(
  NAMES
  igraph_average_path_length_unweighted
  igraph_betweenness
  igraph_betweenness_weighted
  igraph_cliques
  igraph_closeness_weighted
  igraph_coloring
  igraph_decompose
  igraph_maximal_cliques
  igraph_pagerank
  igraph_pagerank_weighted
  igraph_power_law_fit
  igraph_random_walk
  igraph_transitivity
)
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5431414
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/0000755000175100001710000000000000000000000023131 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/bench.h0000644000175100001710000000407500000000000024367 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#ifndef IGRAPH_BENCH_H
#define IGRAPH_BENCH_H

#include  /* getrusage */
#include      /* gettimeofday */
#include        /* sleep */

static inline void igraph_get_cpu_time(double *data) {

    struct rusage self;
    struct timeval real;
    gettimeofday(&real, NULL);
    getrusage(RUSAGE_SELF, &self);
    data[0] = (double) real.tv_sec          + 1e-6 * real.tv_usec;          /* real */
    data[1] = (double) self.ru_utime.tv_sec + 1e-6 * self.ru_utime.tv_usec; /* user */
    data[2] = (double) self.ru_stime.tv_sec + 1e-6 * self.ru_stime.tv_usec; /* system */
}

#define BENCH_INIT() \
    do { \
        printf("\n|> Benchmark file: %s\n", IGRAPH_FILE_BASENAME); \
        sleep(1); \
    } while (0)

#define REPEAT(CODE, N) \
    do { \
        long rep_i; \
        for (rep_i=0; rep_i < N; ++rep_i) { CODE; } \
    } while (0)

#define BENCH(NAME, ...)    do { \
        double start[3], stop[3]; \
        double r, u, s; \
        igraph_get_cpu_time(start); \
        { __VA_ARGS__; } \
        igraph_get_cpu_time(stop); \
        r = 1e-3 * round(1e3 * (stop[0] - start[0])); \
        u = 1e-3 * round(1e3 * (stop[1] - start[1])); \
        s = 1e-3 * round(1e3 * (stop[2] - start[2])); \
        printf("| %-80s %5.3gs  %5.3gs  %5.3gs\n", NAME, r, u, s); \
    } while (0)

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_average_path_length_unweighted.c0000644000175100001710000000535200000000000033046 0ustar00runnerdocker00000000000000
#include 

#include "bench.h"

int main() {
    igraph_t graph;
    igraph_real_t avglen;
    igraph_matrix_t mat;

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&mat, 0, 0);

    igraph_kautz(&graph, 4, 5);
    igraph_matrix_resize(&mat, igraph_vcount(&graph), igraph_vcount(&graph)); /* preallocate matrix */

    BENCH(" 1 Kautz(4, 5) average_path_length directed",
          igraph_average_path_length(&graph, &avglen, NULL, IGRAPH_DIRECTED, 1);
    );
    BENCH(" 2 Kautz(4, 5) shortest_paths directed",
          igraph_shortest_paths(&graph, &mat, igraph_vss_all(), igraph_vss_all(), IGRAPH_OUT);
    );
    BENCH(" 3 Kautz(4, 5) average_path_length undirected",
          igraph_average_path_length(&graph, &avglen, NULL, IGRAPH_UNDIRECTED, 1);
    );
    BENCH(" 4 Kautz(4, 5) shortest_paths undirected",
          igraph_shortest_paths(&graph, &mat, igraph_vss_all(), igraph_vss_all(), IGRAPH_ALL);
    );

    igraph_destroy(&graph);

    {
        igraph_vector_t dims;
        igraph_vector_init_int(&dims, 3, 15, 15, 15);
        igraph_lattice(&graph, &dims, 1, IGRAPH_UNDIRECTED, 0, 1);
        igraph_vector_destroy(&dims);
        igraph_rewire(&graph, 100, IGRAPH_REWIRING_SIMPLE);
        igraph_matrix_resize(&mat, igraph_vcount(&graph), igraph_vcount(&graph)); /* preallocate matrix */
    }

    BENCH(" 5 Rewired 15x15x15 lattice average_path_length",
          igraph_average_path_length(&graph, &avglen, NULL, IGRAPH_UNDIRECTED, 1);
    );
    BENCH(" 6 Rewired 15x15x15 lattice shortest_paths undirected",
          igraph_shortest_paths(&graph, &mat, igraph_vss_all(), igraph_vss_all(), IGRAPH_ALL);
    );

    igraph_destroy(&graph);

    igraph_erdos_renyi_game_gnm(&graph, 10000, 12000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    igraph_matrix_resize(&mat, igraph_vcount(&graph), igraph_vcount(&graph)); /* preallocate matrix */

    BENCH(" 7 Erdos-Renyi n=10000 m=12000 average_path_length directed",
          igraph_average_path_length(&graph, &avglen, NULL, IGRAPH_DIRECTED, 1);
    );
    BENCH(" 8 Erdos-Renyi n=10000 m=12000 shortest_paths directed",
          igraph_shortest_paths(&graph, &mat, igraph_vss_all(), igraph_vss_all(), IGRAPH_OUT);
    );

    /* The undirected computation will be much slower on this graph, as the largest weakly connected
     * component is much larger. */
    BENCH(" 9 Erdos-Renyi n=10000 m=12000 average_path_length undirected",
          igraph_average_path_length(&graph, &avglen, NULL, IGRAPH_UNDIRECTED, 1);
    );
    BENCH("10 Erdos-Renyi n=10000 m=12000 shortest_paths undirected",
          igraph_shortest_paths(&graph, &mat, igraph_vss_all(), igraph_vss_all(), IGRAPH_ALL);
    );

    igraph_destroy(&graph);
    igraph_matrix_destroy(&mat);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_betweenness.c0000644000175100001710000000561600000000000027161 0ustar00runnerdocker00000000000000#include 

#include "bench.h"

int main() {
    igraph_t graph;
    igraph_vector_t betweenness;

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&betweenness, 0);

    /* Kautz and De Bruijn graphs are connected, therefore there should not be a dramatic difference
     * in the performance of the directed and undirected calculations. */

    igraph_kautz(&graph, 4, 5);
    BENCH(" 1 Betweenness, Kautz(4,5), directed",
          igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL));
    BENCH(" 2 Betweenness, Kautz(4,5), undirected",
          igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL));
    igraph_destroy(&graph);

    igraph_de_bruijn(&graph, 6, 5);
    BENCH(" 3 Betweenness, DeBruijn(6,5), directed",
          igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL));
    igraph_destroy(&graph);

    {
        igraph_vector_t dims;

        igraph_vector_init_int_end(&dims, -1, 8, 8, 8, 8, -1);
        igraph_lattice(&graph, &dims, 1, IGRAPH_UNDIRECTED, /* mutual */ 0, /* circular */ 0);
        BENCH(" 4 Betweenness, Grid(8,8,8,8), undirected",
              igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL));
        igraph_destroy(&graph);
        igraph_vector_destroy(&dims);

        igraph_vector_init_int_end(&dims, -1, 10, 10, 10, 10, -1);
        igraph_lattice(&graph, &dims, 1, IGRAPH_UNDIRECTED, /* mutual */ 0, /* circular */ 0);
        BENCH(" 5 Betweenness, Grid(10,10,10,10), cutoff 5",
              igraph_betweenness_cutoff(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL, 5));
        BENCH(" 6 Betweenness, Grid(10,10,10,10), cutoff 8",
              igraph_betweenness_cutoff(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL, 8));
        igraph_destroy(&graph);
        igraph_vector_destroy(&dims);
    }

    igraph_barabasi_game(&graph, 8000, 1, 1, NULL, 1, 0, IGRAPH_UNDIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    BENCH(" 7 Betweenness, Barabasi n=8000 m=1, undirected",
          igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL));
    BENCH(" 8 Betweenness, Barabasi n=8000 m=1, undirected, cutoff 6",
          igraph_betweenness_cutoff(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL, 6));
    igraph_destroy(&graph);

    igraph_barabasi_game(&graph, 30000, 1, 5, NULL, 1, 0, IGRAPH_DIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    BENCH(" 9 Betweenness, Barabasi n=30000 m=5, directed",
          igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL));
    BENCH("10 Betweenness, Barabasi n=30000 m=5, directed, cutoff 5",
          igraph_betweenness_cutoff(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL, 5));
    igraph_destroy(&graph);

    igraph_vector_destroy(&betweenness);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_betweenness_weighted.c0000644000175100001710000001235200000000000031034 0ustar00runnerdocker00000000000000#include 

#include "bench.h"

void rand_weight_vec(igraph_vector_t *vec, const igraph_t *graph) {
    long i, n = igraph_ecount(graph);
    igraph_vector_resize(vec, n);
    for (i=0; i < n; ++i) {
        VECTOR(*vec)[i] = RNG_UNIF(1, 10);
    }
}

#define TOSTR1(x) #x
#define TOSTR(x) TOSTR1(x)

int main() {
    igraph_t graph;
    igraph_vector_t betweenness, weight;

    /* These betweenness benchmarks are identical to the weighted closeness ones. */

    /* This benchmark compares directed/undirected and weighted/unweighted calculations
     * on the same graphs. */

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&betweenness, 0);
    igraph_vector_init(&weight, 0);

    igraph_kautz(&graph, 4, 3);

    /* Kautz and De Bruijn graphs are connected, therefore there should not be a dramatic difference
     * in the performance of the directed and undirected calculations. */

#define NAME "Kautz(4,3)"
#define REP 100

    BENCH(" 1 Betweenness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL), REP)
    );
    BENCH(" 2 Betweenness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH(" 3 Betweenness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, &weight), REP)
    );
    BENCH(" 4 Betweenness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, &weight), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

#define NAME "DeBruijn(5,5)"
#define REP 1

    igraph_de_bruijn(&graph, 5, 5);

    BENCH(" 5 Betweenness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL), REP)
    );
    BENCH(" 6 Betweenness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH(" 7 Betweenness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, &weight), REP)
    );
    BENCH(" 8 Betweenness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, &weight), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

    /* Choose the parameters of the Erdős-Rényi model so that the graph will have a large strongly connected
     * giant component. With 3000 vertices and 10000 edges, it is likely to contain over 90% of vertices.
     * If the graph does not have a giant component, then the directed betweenness calculation will be very
     * fast, and not directly comparable to the undirected one. */

#define NAME "GNM(3000,10000)"
#define REP 1

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 3000, 10000, IGRAPH_DIRECTED, IGRAPH_LOOPS);

    BENCH(" 9 Betweenness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL), REP)
    );
    BENCH("10 Betweenness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH("11 Betweenness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, &weight), REP)
    );
    BENCH("12 Betweenness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, &weight), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

    /* Benchmark a much denser Erdős-Rényi graph as well. */

#define NAME "GNM(3000,30000)"
#define REP 1

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 3000, 30000, IGRAPH_DIRECTED, IGRAPH_LOOPS);

    BENCH("13 Betweenness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, NULL), REP)
    );
    BENCH("14 Betweenness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH("15 Betweenness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_DIRECTED, &weight), REP)
    );
    BENCH("16 Betweenness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_betweenness(&graph, &betweenness, igraph_vss_all(), IGRAPH_UNDIRECTED, &weight), REP)
    );

    igraph_destroy(&graph);

    igraph_vector_destroy(&weight);
    igraph_vector_destroy(&betweenness);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_cliques.c0000644000175100001710000000253600000000000026302 0ustar00runnerdocker00000000000000
#include 

#include "bench.h"

void free_result(igraph_vector_ptr_t *res) {
    long int i, n;

    n = igraph_vector_ptr_size(res);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*res)[i];
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    igraph_vector_ptr_resize(res, 0);
}

int main() {
    igraph_t g;
    igraph_vector_ptr_t res;
    igraph_integer_t res_int;

    igraph_rng_seed(igraph_rng_default(), 42);
    BENCH_INIT();

    igraph_vector_ptr_init(&res, 0);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 100, 3000, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    BENCH(" 1 Cliques in random graph with 100 vertices and 3000 edges",
          igraph_cliques(&g, &res, /* min_size= */ 0, /* max_size= */ 0);
         );
    igraph_destroy(&g);
    free_result(&res);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 200, 10000, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    BENCH(" 2 Cliques in random graph with 200 vertices and 10000 edges, up to size 5",
          igraph_cliques(&g, &res, /* min_size= */ 0, /* max_size= */ 5);
         );
    free_result(&res);
    BENCH(" 3 Clique number of the same graph with 200 vertices and 10000 edges",
          igraph_clique_number(&g, &res_int);
         );
    free_result(&res);
    igraph_destroy(&g);

    igraph_vector_ptr_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_closeness_weighted.c0000644000175100001710000001242400000000000030510 0ustar00runnerdocker00000000000000#include 

#include "bench.h"

void rand_weight_vec(igraph_vector_t *vec, const igraph_t *graph) {
    long i, n = igraph_ecount(graph);
    igraph_vector_resize(vec, n);
    for (i=0; i < n; ++i) {
        VECTOR(*vec)[i] = RNG_UNIF(1, 10);
    }
}

#define TOSTR1(x) #x
#define TOSTR(x) TOSTR1(x)

int main() {
    igraph_t graph;
    igraph_vector_t closeness, weight;

    /* These closeness benchmarks are identical to the weighted betweenness ones. */

    /* This benchmark compares directed/undirected and weighted/unweighted calculations
     * on the same graphs. */

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&closeness, 0);
    igraph_vector_init(&weight, 0);

    igraph_kautz(&graph, 4, 3);

    /* Kautz and De Bruijn graphs are connected, therefore there should not be a dramatic difference
     * in the performance of the directed and undirected calculations. */

#define NAME "Kautz(4,3)"
#define REP 100

    BENCH(" 1 Closeness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, NULL, 1), REP)
    );
    BENCH(" 2 Closeness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, NULL, 1), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH(" 3 Closeness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, &weight, 1), REP)
    );
    BENCH(" 4 Closeness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, &weight, 1), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

#define NAME "DeBruijn(5,5)"
#define REP 1

    igraph_de_bruijn(&graph, 5, 5);

    BENCH(" 5 Closeness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, NULL, 1), REP)
    );
    BENCH(" 6 Closeness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, NULL, 1), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH(" 7 Closeness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, &weight, 1), REP)
    );
    BENCH(" 8 Closeness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, &weight, 1), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

    /* Choose the parameters of the Erdős-Rényi model so that the graph will have a large strongly connected
     * giant component. With 3000 vertices and 10000 edges, it is likely to contain over 90% of vertices.
     * If the graph does not have a giant component, then the directed betweenness calculation will be very
     * fast, and not directly comparable to the undirected one. */

#define NAME "GNM(3000,10000)"
#define REP 1

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 3000, 10000, IGRAPH_DIRECTED, IGRAPH_LOOPS);

    BENCH(" 9 Closeness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, NULL, 1), REP)
    );
    BENCH("10 Closeness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, NULL, 1), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH("11 Closeness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, &weight, 1), REP)
    );
    BENCH("12 Closeness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, &weight, 1), REP)
    );

    igraph_destroy(&graph);

#undef NAME
#undef REP

    /* Benchmark a much denser Erdős-Rényi graph as well. */

#define NAME "GNM(3000,30000)"
#define REP 1

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 3000, 30000, IGRAPH_DIRECTED, IGRAPH_LOOPS);

    BENCH("13 Closeness, unweighted, " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, NULL, 1), REP)
    );
    BENCH("14 Closeness, unweighted, " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, NULL, 1), REP)
    );

    rand_weight_vec(&weight, &graph);

    BENCH("15 Closeness, weighted,   " NAME ", directed, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_OUT, &weight, 1), REP)
    );
    BENCH("16 Closeness, weighted,   " NAME ", undirected, " TOSTR(REP) "x",
          REPEAT(igraph_closeness(&graph, &closeness, NULL, NULL, igraph_vss_all(), IGRAPH_ALL, &weight, 1), REP)
    );

    igraph_destroy(&graph);

    igraph_vector_destroy(&weight);
    igraph_vector_destroy(&closeness);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_coloring.c0000644000175100001710000000156700000000000026454 0ustar00runnerdocker00000000000000
#include 

#include "bench.h"

int main() {
    igraph_t g;
    igraph_vector_int_t colors;

    igraph_rng_seed(igraph_rng_default(), 42);
    BENCH_INIT();

    igraph_vector_int_init(&colors, 0);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 50000, 1000000, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    BENCH(" 1 Vertex coloring random graph with 50,000 vertices and 2,000,000 edges",
          igraph_vertex_coloring_greedy(&g, &colors, IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS)
         );
    igraph_destroy(&g);

    igraph_barabasi_game(&g, 100000, 1, 15, NULL, 0, 0, 0, IGRAPH_BARABASI_PSUMTREE, NULL);
    BENCH(" 2 Vertex coloring pref. attach. graph n=100,000 m=15",
          igraph_vertex_coloring_greedy(&g, &colors, IGRAPH_COLORING_GREEDY_COLORED_NEIGHBORS)
         );
    igraph_destroy(&g);

    igraph_vector_int_destroy(&colors);


    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_decompose.c0000644000175100001710000000211300000000000026602 0ustar00runnerdocker00000000000000
#include 

#include "bench.h"

int main() {
    igraph_t g;
    igraph_vector_ptr_t res;

    igraph_rng_seed(igraph_rng_default(), 42);
    BENCH_INIT();

    igraph_vector_ptr_init(&res, 0);

    igraph_empty(&g, 1000, IGRAPH_UNDIRECTED);
    BENCH(" 1 Decompose graph with 1000 isolated vertices",
          igraph_decompose(&g, &res, IGRAPH_WEAK, -1, -1);
         );
    igraph_destroy(&g);
    igraph_decompose_destroy(&res);
    igraph_vector_ptr_resize(&res, 0);

    igraph_empty(&g, 10000, IGRAPH_UNDIRECTED);
    BENCH(" 2 Decompose graph with 10000 isolated vertices",
          igraph_decompose(&g, &res, IGRAPH_WEAK, -1, -1);
         );
    igraph_destroy(&g);
    igraph_decompose_destroy(&res);
    igraph_vector_ptr_resize(&res, 0);

    igraph_empty(&g, 100000, IGRAPH_UNDIRECTED);
    BENCH(" 3 Decompose graph with 100000 isolated vertices",
          igraph_decompose(&g, &res, IGRAPH_WEAK, -1, -1);
         );
    igraph_destroy(&g);
    igraph_decompose_destroy(&res);
    igraph_vector_ptr_resize(&res, 0);

    igraph_vector_ptr_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_maximal_cliques.c0000644000175100001710000000420000000000000030000 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "bench.h"

void free_result(igraph_vector_ptr_t *res) {
    long int i, n;

    n = igraph_vector_ptr_size(res);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*res)[i];
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    igraph_vector_ptr_resize(res, 0);
}

int main() {

    igraph_t g;
    igraph_real_t toremovev[] = {  2609,  2098, 14517,  7540, 19560,  8855,
                                   5939, 14947,   441, 16976, 19642,  4188,
                                   15447, 11837,  2333,  7309, 18539, 14099,
                                   14264,  9240
                                };
    igraph_vector_t toremove;
    igraph_vector_ptr_t res;

    BENCH_INIT();

    igraph_vector_view(&toremove, toremovev,
                       sizeof(toremovev) / sizeof(igraph_real_t));
    igraph_full(&g, 200, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_delete_edges(&g, igraph_ess_vector(&toremove));

    igraph_vector_ptr_init(&res, 0);

    BENCH(" 1 Maximal cliques of almost complete graph",
          igraph_maximal_cliques(&g, &res, /* min_size= */ 0,
                                 /* max_size= */ 0);
         );

    igraph_destroy(&g);

    free_result(&res);
    igraph_vector_ptr_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_pagerank.c0000644000175100001710000001203400000000000026417 0ustar00runnerdocker00000000000000#include 

#include "bench.h"

int main() {
    igraph_t graph;
    igraph_vector_t res;
    igraph_arpack_options_t arpack_opts;

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_arpack_options_init(&arpack_opts);

    igraph_vector_init(&res, 0);

    igraph_barabasi_game(&graph, 100000, 1, 4, NULL, 1, 0, IGRAPH_DIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    BENCH(" 1 PageRank, Barabasi n=100000 m=4, PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 10)
    );
    BENCH(" 2 PageRank, Barabasi n=100000 m=4, ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_barabasi_game(&graph, 100000, 1, 10, NULL, 1, 0, IGRAPH_DIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    BENCH(" 3 PageRank, Barabasi n=100000 m=10, PRPACK, 5x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 5)
    );
    BENCH(" 4 PageRank, Barabasi n=100000 m=10, ARPACK, 5x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 5)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100, 1000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    BENCH(" 5 PageRank, GNM(100,1000), PRPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 1000)
    );
    BENCH(" 6 PageRank, GNM(100,1000), ARPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 1000)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 200, 4000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    BENCH(" 7 PageRank, GNM(200,4000), PRPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 1000)
    );
    BENCH(" 8 PageRank, GNM(200,4000), ARPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 1000)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 10000, 20000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    BENCH(" 9 PageRank, GNM(10000,20000), PRPACK, 100x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 100)
    );
    BENCH("10 PageRank, GNM(10000,20000), ARPACK, 100x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 100)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100000, 100000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    BENCH("11 PageRank, GNM(100000,100000), PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 10)
    );
    BENCH("12 PageRank, GNM(100000,100000), ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100000, 500000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    BENCH("13 PageRank, GNM(100000,500000), PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 10)
    );
    BENCH("14 PageRank, GNM(100000,500000), ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_kautz(&graph, 6, 6);
    BENCH("13 PageRank, Kautz(6,6), PRPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 1)
    );
    BENCH("14 PageRank, Kautz(6,6), ARPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 1)
    );
    igraph_destroy(&graph);

    igraph_de_bruijn(&graph, 7, 7);
    BENCH("13 PageRank, DeBruijn(7,7), PRPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, NULL), 1)
    );
    BENCH("14 PageRank, DeBruijn(7,7), ARPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, NULL, &arpack_opts), 1)
    );
    igraph_destroy(&graph);

    igraph_vector_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_pagerank_weighted.c0000644000175100001710000001362400000000000030305 0ustar00runnerdocker00000000000000#include 

#include "bench.h"

void rand_weight_vec(igraph_vector_t *vec, const igraph_t *graph) {
    long i, n = igraph_ecount(graph);
    igraph_vector_resize(vec, n);
    for (i=0; i < n; ++i) {
        VECTOR(*vec)[i] = RNG_UNIF(1, 10);
    }
}

int main() {
    igraph_t graph;
    igraph_vector_t res, weights;
    igraph_arpack_options_t arpack_opts;

    BENCH_INIT();
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_arpack_options_init(&arpack_opts);

    igraph_vector_init(&res, 0);
    igraph_vector_init(&weights, 0);

    igraph_barabasi_game(&graph, 100000, 1, 4, NULL, 1, 0, IGRAPH_DIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    rand_weight_vec(&weights, &graph);
    BENCH(" 1 PageRank weighted, Barabasi n=100000 m=4, PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 10)
    );
    BENCH(" 2 PageRank weighted, Barabasi n=100000 m=4, ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_barabasi_game(&graph, 100000, 1, 10, NULL, 1, 0, IGRAPH_DIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);
    rand_weight_vec(&weights, &graph);
    BENCH(" 3 PageRank weighted, Barabasi n=100000 m=10, PRPACK, 5x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 5)
    );
    BENCH(" 4 PageRank weighted, Barabasi n=100000 m=10, ARPACK, 5x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 5)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100, 1000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    rand_weight_vec(&weights, &graph);
    BENCH(" 5 PageRank weighted, GNM(100,1000), PRPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 1000)
    );
    BENCH(" 6 PageRank weighted, GNM(100,1000), ARPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 1000)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 200, 4000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    rand_weight_vec(&weights, &graph);
    BENCH(" 7 PageRank weighted, GNM(200,4000), PRPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 1000)
    );
    BENCH(" 8 PageRank weighted, GNM(200,4000), ARPACK, 1000x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 1000)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 10000, 20000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    rand_weight_vec(&weights, &graph);
    BENCH(" 9 PageRank weighted, GNM(10000,20000), PRPACK, 100x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 100)
    );
    BENCH("10 PageRank weighted, GNM(10000,20000), ARPACK, 100x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 100)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100000, 100000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    rand_weight_vec(&weights, &graph);
    BENCH("11 PageRank weighted, GNM(100000,100000), PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 10)
    );
    BENCH("12 PageRank weighted, GNM(100000,100000), ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNM, 100000, 500000, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    rand_weight_vec(&weights, &graph);
    BENCH("13 PageRank weighted, GNM(100000,500000), PRPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 10)
    );
    BENCH("14 PageRank weighted, GNM(100000,500000), ARPACK, 10x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 10)
    );
    igraph_destroy(&graph);

    igraph_kautz(&graph, 6, 6);
    rand_weight_vec(&weights, &graph);
    BENCH("13 PageRank weighted, Kautz(6,6), PRPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 1)
    );
    BENCH("14 PageRank weighted, Kautz(6,6), ARPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 1)
    );
    igraph_destroy(&graph);

    igraph_de_bruijn(&graph, 7, 7);
    rand_weight_vec(&weights, &graph);
    BENCH("13 PageRank weighted, DeBruijn(7,7), PRPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_PRPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, NULL), 1)
    );
    BENCH("14 PageRank weighted, DeBruijn(7,7), ARPACK, 1x",
          REPEAT(igraph_pagerank(&graph, IGRAPH_PAGERANK_ALGO_ARPACK, &res, NULL, igraph_vss_all(), IGRAPH_DIRECTED, 0.85, &weights, &arpack_opts), 1)
    );
    igraph_destroy(&graph);

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&res);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_power_law_fit.c0000644000175100001710000001233700000000000027476 0ustar00runnerdocker00000000000000#include 
#include 

#include "bench.h"

igraph_vector_t data;

double rpareto(double xmin, double alpha) {
    /* 1-u is used in the base here because we want to avoid the case of
     * sampling zero */
    return pow(1 - RNG_UNIF01(), -1.0 / alpha) * xmin;
}

double rzeta(long int xmin, double alpha) {
    double u, v, t;
    long int x;
    double alpha_minus_1 = alpha-1;
    double minus_1_over_alpha_minus_1 = -1.0 / (alpha-1);
    double b;
    double one_over_b_minus_1;

    xmin = (long int) round(xmin);

    /* Rejection sampling for the win. We use Y=floor(U^{-1/alpha} * xmin) as the
     * envelope distribution, similarly to Chapter X.6 of Luc Devroye's book
     * (where xmin is assumed to be 1): http://luc.devroye.org/chapter_ten.pdf
     *
     * Some notes that should help me recover what I was doing:
     *
     * p_i = 1/zeta(alpha, xmin) * i^-alpha
     * q_i = (xmin/i)^{alpha-1} - (xmin/(i+1))^{alpha-1}
     *     = (i/xmin)^{1-alpha} - ((i+1)/xmin)^{1-alpha}
     *     = [i^{1-alpha} - (i+1)^{1-alpha}] / xmin^{1-alpha}
     *
     * p_i / q_i attains its maximum at xmin=i, so the rejection constant is:
     *
     * c = p_xmin / q_xmin
     *
     * We have to accept the sample if V <= (p_i / q_i) * (q_xmin / p_xmin) =
     * (i/xmin)^-alpha * [xmin^{1-alpha} - (xmin+1)^{1-alpha}] / [i^{1-alpha} - (i+1)^{1-alpha}] =
     * [xmin - xmin^alpha / (xmin+1)^{alpha-1}] / [i - i^alpha / (i+1)^{alpha-1}] =
     * xmin/i * [1-(xmin/(xmin+1))^{alpha-1}]/[1-(i/(i+1))^{alpha-1}]
     *
     * In other words (and substituting i with X, which is the same),
     *
     * V * (X/xmin) <= [1 - (1+1/xmin)^{1-alpha}] / [1 - (1+1/i)^{1-alpha}]
     *
     * Let b := (1+1/xmin)^{alpha-1} and let T := (1+1/i)^{alpha-1}. Then:
     *
     * V * (X/xmin) <= [(b-1)/b] / [(T-1)/T]
     * V * (X/xmin) * (T-1) / (b-1) <= T / b
     *
     * which is the same as in Devroye's book, except for the X/xmin term, and
     * the definition of b.
     */
    b = pow(1 + 1.0/xmin, alpha_minus_1);
    one_over_b_minus_1 = 1.0/(b-1);
    do {
        do {
            u = RNG_UNIF01();
            v = RNG_UNIF01();
            /* 1-u is used in the base here because we want to avoid the case of
             * having zero in x */
            x = (long int) floor(pow(1-u, minus_1_over_alpha_minus_1) * xmin);
        } while (x < xmin);
        t = pow((x+1.0)/x, alpha_minus_1);
    } while (v*x*(t-1)*one_over_b_minus_1*b > t*xmin);

    return x;
}

int generate_continuous(double xmin, double alpha, size_t num_samples) {
    IGRAPH_CHECK(igraph_vector_resize(&data, num_samples));

    RNG_BEGIN();
    for (size_t i = 0; i < num_samples; i++) {
        VECTOR(data)[i] = rpareto(xmin, alpha);
    }
    RNG_END();

    return IGRAPH_SUCCESS;
}

int generate_discrete(double xmin, double alpha, size_t num_samples) {
    IGRAPH_CHECK(igraph_vector_resize(&data, num_samples));

    RNG_BEGIN();
    for (size_t i = 0; i < num_samples; i++) {
        VECTOR(data)[i] = rzeta(xmin, alpha);
    }
    RNG_END();

    return IGRAPH_SUCCESS;
}

int fit_continuous(double known_xmin) {
    igraph_plfit_result_t result;
    IGRAPH_CHECK(igraph_power_law_fit(&data, &result, known_xmin, /* force_continuous = */ 1));
    return IGRAPH_SUCCESS;
}

int fit_discrete(double known_xmin) {
    igraph_plfit_result_t result;
    IGRAPH_CHECK(igraph_power_law_fit(&data, &result, known_xmin, 0));
    return IGRAPH_SUCCESS;
}

int main() {
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&data, 0);

    BENCH_INIT();

    generate_continuous(1, 3, 100000);
    BENCH(" 1 Continuous, xmin = 1, alpha = 3, samples = 100K, fitting alpha only", fit_continuous(1));

    generate_continuous(1, 3, 200000);
    BENCH(" 2 Continuous, xmin = 1, alpha = 3, samples = 200K, fitting alpha only", fit_continuous(1));

    generate_continuous(1, 3, 500000);
    BENCH(" 3 Continuous, xmin = 1, alpha = 3, samples = 500K, fitting alpha only", fit_continuous(1));

    generate_continuous(1, 3, 5000);
    BENCH(" 4 Continuous, xmin = 1, alpha = 3, samples = 5K, fitting xmin and alpha", fit_continuous(-1));

    generate_continuous(1, 3, 10000);
    BENCH(" 5 Continuous, xmin = 1, alpha = 3, samples = 10K, fitting xmin and alpha", fit_continuous(-1));

    generate_continuous(1, 3, 15000);
    BENCH(" 6 Continuous, xmin = 1, alpha = 3, samples = 15K, fitting xmin and alpha", fit_continuous(-1));

    generate_discrete(3, 3, 1000000);
    BENCH(" 7 Discrete, xmin = 3, alpha = 3, samples = 1M, fitting alpha only", fit_discrete(3));

    generate_discrete(3, 3, 5000000);
    BENCH(" 8 Discrete, xmin = 3, alpha = 3, samples = 5M, fitting alpha only", fit_discrete(3));

    generate_discrete(3, 3, 10000000);
    BENCH(" 9 Discrete, xmin = 3, alpha = 3, samples = 10M, fitting alpha only", fit_discrete(3));

    generate_discrete(3, 3, 1000000);
    BENCH("10 Discrete, xmin = 3, alpha = 3, samples = 1M, fitting xmin and alpha", fit_discrete(-1));

    generate_discrete(3, 3, 5000000);
    BENCH("11 Discrete, xmin = 3, alpha = 3, samples = 5M, fitting xmin and alpha", fit_discrete(-1));

    generate_discrete(3, 3, 10000000);
    BENCH("12 Discrete, xmin = 3, alpha = 3, samples = 10M, fitting xmin and alpha", fit_discrete(-1));

    igraph_vector_destroy(&data);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_random_walk.c0000644000175100001710000000701600000000000027131 0ustar00runnerdocker00000000000000
#include 
#include "bench.h"

int main() {
    igraph_t graph;
    igraph_vector_t walk, weights;
    igraph_integer_t ec, i;

    igraph_rng_seed(igraph_rng_default(), 137);
    BENCH_INIT();

    igraph_vector_init(&walk, 0);
    igraph_vector_init(&weights, 0);

    /* create a small graph, and a compatible weight vector */
    igraph_de_bruijn(&graph, 3, 2); /* 9 vertices, 27 edges, average degree: 6 */
    ec = igraph_ecount(&graph);

    igraph_vector_resize(&weights, ec);
    for (i = 0; i < ec; ++i) {
        VECTOR(weights)[i] = igraph_rng_get_unif01(igraph_rng_default());
    }

    BENCH(" 1 Random edge walk,   directed,   unweighted, small graph  ",
          igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 2 Random edge walk,   directed,   weighted,   small graph  ",
          igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 3 Random vertex walk, directed,   unweighted, small graph  ",
          igraph_random_walk(&graph, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    igraph_to_undirected(&graph, IGRAPH_TO_UNDIRECTED_EACH, NULL);

    BENCH(" 4 Random edge walk,   undirected, unweighted, small graph  ",
          igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 5 Random edge walk,   undirected, weighted,   small graph  ",
          igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 6 Random vertex walk, undirected, unweighted, small graph  ",
          igraph_random_walk(&graph, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    igraph_destroy(&graph);

    /* create a big graph, and a compatible weight vector */
    igraph_de_bruijn(&graph, 8, 5); /* 32768 vertices, 262144 edges, average degree: 16 */
    ec = igraph_ecount(&graph);

    igraph_vector_resize(&weights, ec);
    for (i = 0; i < ec; ++i) {
        VECTOR(weights)[i] = igraph_rng_get_unif01(igraph_rng_default());
    }

    BENCH(" 7 Random edge walk,   directed,   unweighted, large graph  ",
          igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 8 Random edge walk,   directed,   weighted,   large graph  ",
          igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH(" 9 Random vertex walk, directed,   unweighted, large graph  ",
          igraph_random_walk(&graph, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    igraph_to_undirected(&graph, IGRAPH_TO_UNDIRECTED_EACH, NULL);

    BENCH("10 Random edge walk,   undirected, unweighted, large graph  ",
          igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH("11 Random edge walk,   undirected, weighted,   large graph  ",
          igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    BENCH("12 Random vertex walk, undirected, unweighted, large graph  ",
          igraph_random_walk(&graph, &walk, 0, IGRAPH_OUT, 50000000, IGRAPH_RANDOM_WALK_STUCK_RETURN)
         );

    igraph_destroy(&graph);

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&walk);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/benchmarks/igraph_transitivity.c0000644000175100001710000001257200000000000027407 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "bench.h"

#define N 6000
#define M 2000000

int main() {

    igraph_t g;
    igraph_vector_t trans;
    igraph_vs_t all_vertices;
    igraph_real_t avg_trans, global_trans;

    igraph_rng_seed(igraph_rng_default(), 42);
    BENCH_INIT();

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, N, M,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_vector_init(&trans, igraph_vcount(&g));
    igraph_vs_seq(&all_vertices, 0, igraph_vcount(&g) - 1);

    BENCH(" 1 Local transitivity, all vertices method, GNM",
          igraph_transitivity_local_undirected(&g, &trans, igraph_vss_all(),
                  IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 2 Local transitivity, subset method, GNM",
          igraph_transitivity_local_undirected(&g, &trans, all_vertices,
                  IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 3 Average local transitivity GNM",
          igraph_transitivity_avglocal_undirected(&g, &avg_trans, IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 4 Global transitivity GNM",
          igraph_transitivity_undirected(&g, &global_trans, IGRAPH_TRANSITIVITY_NAN);
         );

    igraph_vs_destroy(&all_vertices);
    igraph_destroy(&g);

    igraph_barabasi_game(&g, N, /*power=*/ 1, M / N, /*outseq=*/ 0,
                         /*outpref=*/ 0, /*A=*/ 1, IGRAPH_UNDIRECTED,
                         IGRAPH_BARABASI_PSUMTREE, /*start_from=*/ 0);
    igraph_vector_resize(&trans, igraph_vcount(&g));
    igraph_vs_seq(&all_vertices, 0, igraph_vcount(&g) - 1);

    BENCH(" 5 Local transitivity, all vertices method, Barabasi",
          igraph_transitivity_local_undirected(&g, &trans, igraph_vss_all(),
                  IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 6 Local transitivity, subset method, Barabasi",
          igraph_transitivity_local_undirected(&g, &trans, all_vertices,
                  IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 7 Average local transitivity, Barabasi",
          igraph_transitivity_avglocal_undirected(&g, &avg_trans, IGRAPH_TRANSITIVITY_NAN);
         );

    BENCH(" 8 Global transitivity, Barabasi",
          igraph_transitivity_undirected(&g, &global_trans, IGRAPH_TRANSITIVITY_NAN);
         );

    igraph_vs_destroy(&all_vertices);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 500, 2000,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_vector_resize(&trans, igraph_vcount(&g));
    igraph_vs_seq(&all_vertices, 0, igraph_vcount(&g) - 1);

#define REPS 1000

    BENCH(" 9 Local transitivity, all vertices method, small GNM",
          REPEAT(igraph_transitivity_local_undirected(&g, &trans, igraph_vss_all(),
                  IGRAPH_TRANSITIVITY_NAN), REPS);
         );

    BENCH("10 Local transitivity, subset method, small GNM",
          REPEAT(igraph_transitivity_local_undirected(&g, &trans, all_vertices,
                  IGRAPH_TRANSITIVITY_NAN), REPS);
         );

    BENCH("11 Average local transitivity, small GNM",
          REPEAT(igraph_transitivity_avglocal_undirected(&g, &avg_trans, IGRAPH_TRANSITIVITY_NAN),
                 REPS);
         );

    BENCH("12 Global transitivity, small GNM",
          REPEAT(igraph_transitivity_undirected(&g, &global_trans, IGRAPH_TRANSITIVITY_NAN),
                 REPS);
         );

    igraph_vs_destroy(&all_vertices);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 50, 300,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_vector_resize(&trans, igraph_vcount(&g));
    igraph_vs_seq(&all_vertices, 0, igraph_vcount(&g) - 1);

#undef REPS

#define REPS 10000

    BENCH("13 Local transitivity, all vertices method, tiny GNM",
          REPEAT(igraph_transitivity_local_undirected(&g, &trans, igraph_vss_all(),
                  IGRAPH_TRANSITIVITY_NAN), REPS);
         );

    BENCH("14 Local transitivity, subset method, tiny GNM",
          REPEAT(igraph_transitivity_local_undirected(&g, &trans, all_vertices,
                  IGRAPH_TRANSITIVITY_NAN), REPS);
         );

    BENCH("15 Average local transitivity, tiny GNM",
          REPEAT(igraph_transitivity_avglocal_undirected(&g, &avg_trans, IGRAPH_TRANSITIVITY_NAN),
                 REPS);
         );

    BENCH("16 Global transitivity, tiny GNM",
          REPEAT(igraph_transitivity_undirected(&g, &global_trans, IGRAPH_TRANSITIVITY_NAN),
                 REPS);
         );

    igraph_vs_destroy(&all_vertices);
    igraph_destroy(&g);

#undef REPS

    igraph_vector_destroy(&trans);

    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.5471413
igraph-0.9.9/vendor/source/igraph/tests/regression/0000755000175100001710000000000000000000000023174 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug-1033045.c0000644000175100001710000000310600000000000024732 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "../unit/test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_vector_ptr_t separators;
    int i, n;

    igraph_small(&graph, 0, /*directed=*/ 0,
                 0, 1, 0, 2, 1, 3, 1, 4, 2, 3, 2, 5, 3, 4, 3, 5, 4, 6, 5, 6, -1);
    igraph_vector_ptr_init(&separators, 0);

    igraph_all_minimal_st_separators(&graph, &separators);

    n = igraph_vector_ptr_size(&separators);
    for (i = 0; i < n; i++) {
        igraph_vector_t *sep = VECTOR(separators)[i];
        igraph_vector_print(sep);
        igraph_vector_destroy(sep);
        igraph_free(sep);
    }

    igraph_vector_ptr_destroy(&separators);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug-1033045.out0000644000175100001710000000006200000000000025315 0ustar00runnerdocker000000000000001 2
0 3 4
0 3 5
4 5
1 3 6
2 3 6
2 3 4
1 3 5
0 3 6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug-1149658.c0000644000175100001710000000264500000000000024763 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "../unit/test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_vector_t mod;

    igraph_empty(&graph, 25, IGRAPH_UNDIRECTED);
    igraph_vector_init(&mod, 0);
    igraph_community_multilevel(&graph, /*weights=*/ 0, /*resolution=*/ 1,
                                /*membership=*/ 0, /*memberships=*/ 0, &mod);

    if (igraph_vector_size(&mod) != 1 ||
        !igraph_is_nan(VECTOR(mod)[0])) {
        return 1;
    }

    igraph_vector_destroy(&mod);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug_1760.c0000644000175100001710000001176600000000000024605 0ustar00runnerdocker00000000000000#include 

#include "../unit/test_utilities.inc"

/* Regression test for https://github.com/igraph/igraph/issues/1760 */

int test_unweighted(const igraph_t* g, igraph_integer_t from, const igraph_vs_t* to) {
    igraph_vector_ptr_t vpath, epath;
    igraph_integer_t i;
    igraph_integer_t num_paths;
    igraph_vector_long_t predecessors;
    igraph_vector_long_t inbound_edges;

    printf("Unweighted case\n");
    printf("---------------\n\n");

    IGRAPH_CHECK(igraph_vs_size(g, to, &num_paths));
    IGRAPH_CHECK(igraph_vector_ptr_init(&vpath, num_paths));
    IGRAPH_CHECK(igraph_vector_ptr_init(&epath, num_paths));
    IGRAPH_CHECK(igraph_vector_long_init(&predecessors, 0));
    IGRAPH_CHECK(igraph_vector_long_init(&inbound_edges, 0));

    for (i = 0; i < igraph_vector_ptr_size(&vpath); i++) {
        VECTOR(vpath)[i] = igraph_Calloc(1, igraph_vector_t);
        VECTOR(epath)[i] = igraph_Calloc(1, igraph_vector_t);
        IGRAPH_CHECK(igraph_vector_init(VECTOR(vpath)[i], 0));
        IGRAPH_CHECK(igraph_vector_init(VECTOR(epath)[i], 0));
    }

    IGRAPH_CHECK(igraph_get_shortest_paths(
        g, &vpath, &epath, from, *to, IGRAPH_IN,
        &predecessors, &inbound_edges
    ));

    printf("Vertices:\n");
    for (i = 0; i < igraph_vector_ptr_size(&vpath); i++) {
        print_vector(VECTOR(vpath)[i]);
        igraph_vector_destroy(VECTOR(vpath)[i]);
    }
    printf("\n");

    printf("Edges:\n");
    for (i = 0; i < igraph_vector_ptr_size(&epath); i++) {
        print_vector(VECTOR(epath)[i]);
        igraph_vector_destroy(VECTOR(epath)[i]);
    }
    printf("\n");

    printf("Predecessors:\n");
    print_vector_long(&predecessors);
    printf("\n");

    printf("Inbound edges:\n");
    print_vector_long(&inbound_edges);
    printf("\n");

    igraph_vector_long_destroy(&inbound_edges);
    igraph_vector_long_destroy(&predecessors);
    igraph_vector_ptr_destroy_all(&epath);
    igraph_vector_ptr_destroy_all(&vpath);

    return IGRAPH_SUCCESS;
}

int test_weighted(
    const igraph_t* g, const igraph_vector_t* weights, igraph_integer_t from,
    const igraph_vs_t* to, igraph_bool_t use_bellman_ford
) {
    igraph_vector_ptr_t vpath, epath;
    igraph_integer_t i;
    igraph_integer_t num_paths;
    igraph_vector_long_t predecessors;
    igraph_vector_long_t inbound_edges;

    printf("Weighted case\n");
    printf("-------------\n\n");

    printf("Algorithm: %s\n\n", use_bellman_ford ? "Bellman-Ford" : "Dijkstra");

    IGRAPH_CHECK(igraph_vs_size(g, to, &num_paths));
    IGRAPH_CHECK(igraph_vector_ptr_init(&vpath, num_paths));
    IGRAPH_CHECK(igraph_vector_ptr_init(&epath, num_paths));
    IGRAPH_CHECK(igraph_vector_long_init(&predecessors, 0));
    IGRAPH_CHECK(igraph_vector_long_init(&inbound_edges, 0));

    for (i = 0; i < igraph_vector_ptr_size(&vpath); i++) {
        VECTOR(vpath)[i] = igraph_Calloc(1, igraph_vector_t);
        VECTOR(epath)[i] = igraph_Calloc(1, igraph_vector_t);
        IGRAPH_CHECK(igraph_vector_init(VECTOR(vpath)[i], 0));
        IGRAPH_CHECK(igraph_vector_init(VECTOR(epath)[i], 0));
    }

    if (use_bellman_ford) {
        IGRAPH_CHECK(igraph_get_shortest_paths_bellman_ford(
            g, &vpath, &epath, from, *to, weights, IGRAPH_IN,
            &predecessors, &inbound_edges
        ));
    } else {
        IGRAPH_CHECK(igraph_get_shortest_paths_dijkstra(
            g, &vpath, &epath, from, *to, weights, IGRAPH_IN,
            &predecessors, &inbound_edges
        ));
    }

    printf("Vertices:\n");
    for (i = 0; i < igraph_vector_ptr_size(&vpath); i++) {
        print_vector(VECTOR(vpath)[i]);
        igraph_vector_destroy(VECTOR(vpath)[i]);
    }
    printf("\n");

    printf("Edges:\n");
    for (i = 0; i < igraph_vector_ptr_size(&epath); i++) {
        print_vector(VECTOR(epath)[i]);
        igraph_vector_destroy(VECTOR(epath)[i]);
    }
    printf("\n");

    printf("Predecessors:\n");
    print_vector_long(&predecessors);
    printf("\n");

    printf("Inbound edges:\n");
    print_vector_long(&inbound_edges);
    printf("\n");

    igraph_vector_long_destroy(&inbound_edges);
    igraph_vector_long_destroy(&predecessors);
    igraph_vector_ptr_destroy_all(&epath);
    igraph_vector_ptr_destroy_all(&vpath);

    return IGRAPH_SUCCESS;
}

int main(int argc, char* argv[]) {
    igraph_t g;
    igraph_vector_t weights;
    igraph_vs_t to;

    igraph_set_warning_handler(igraph_warning_handler_ignore);

    igraph_small(&g, 4, /* directed = */ 1, 0, 1, 1, 2, 1, 3, -1);
    igraph_vs_vector_small(&to, 0, 3, -1);
    igraph_vector_init(&weights, 3);
    VECTOR(weights)[0] = 1;
    VECTOR(weights)[1] = 2;
    VECTOR(weights)[2] = 2;

    /* Test unweighted case */
    if (test_unweighted(&g, 2, &to)) {
        return 1;
    }

    /* Test weighted case */
    if (test_weighted(&g, &weights, 2, &to, /* use_bellman_ford = */ 0)) {
        return 2;
    }
    if (test_weighted(&g, &weights, 2, &to, /* use_bellman_ford = */ 1)) {
        return 3;
    }

    igraph_vector_destroy(&weights);
    igraph_vs_destroy(&to);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug_1760.out0000644000175100001710000000067600000000000025170 0ustar00runnerdocker00000000000000Unweighted case
---------------

Vertices:
( 2 1 0 )
( )

Edges:
( 1 0 )
( )

Predecessors:
( 1 2 2 -1 )

Inbound edges:
( 0 1 -1 -1 )

Weighted case
-------------

Algorithm: Dijkstra

Vertices:
( 2 1 0 )
( )

Edges:
( 1 0 )
( )

Predecessors:
( 1 2 2 -1 )

Inbound edges:
( 0 1 -1 -1 )

Weighted case
-------------

Algorithm: Bellman-Ford

Vertices:
( 2 1 0 )
( )

Edges:
( 1 0 )
( )

Predecessors:
( 1 2 2 -1 )

Inbound edges:
( 0 1 -1 -1 )

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug_1814.c0000644000175100001710000000263400000000000024577 0ustar00runnerdocker00000000000000#include 

#include "../unit/test_utilities.inc"

/* Regression test for https://github.com/igraph/igraph/issues/1814 */

void test_igraph_to_undirected(igraph_to_undirected_t mode) {
    igraph_t g;
    igraph_attribute_combination_t comb;

    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 0,1, 0,1, 1,0,
                 1,1, 1,1,
                 -1);

    SETEAN(&g, "weight", 0, 1);
    SETEAN(&g, "weight", 1, 2);
    SETEAN(&g, "weight", 2, 3);
    SETEAN(&g, "weight", 3, 4);
    SETEAN(&g, "weight", 4, 2);

    igraph_attribute_combination(
        &comb, "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
        IGRAPH_NO_MORE_ATTRIBUTES
    );
    igraph_to_undirected(&g, mode, &comb);
    igraph_attribute_combination_destroy(&comb);

    igraph_write_graph_gml(&g, stdout, 0, "unittest");

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
}

int main() {
    igraph_set_attribute_table(&igraph_cattribute_table);

    printf("to_undirected(COLLAPSE)\n");
    printf("=======================\n\n");
    test_igraph_to_undirected(IGRAPH_TO_UNDIRECTED_COLLAPSE);
    printf("\n");

    printf("to_undirected(MUTUAL)\n");
    printf("=====================\n\n");
    test_igraph_to_undirected(IGRAPH_TO_UNDIRECTED_MUTUAL);
    printf("\n");

    printf("to_undirected(EACH)\n");
    printf("===================\n\n");
    test_igraph_to_undirected(IGRAPH_TO_UNDIRECTED_EACH);
    printf("\n");

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/bug_1814.out0000644000175100001710000000225500000000000025163 0ustar00runnerdocker00000000000000to_undirected(COLLAPSE)
=======================

Creator "igraph version @VERSION@ unittest"
Version 1
graph
[
  directed 0
  node
  [
    id 0
  ]
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  edge
  [
    source 1
    target 0
    weight 6
  ]
  edge
  [
    source 1
    target 1
    weight 6
  ]
]

to_undirected(MUTUAL)
=====================

Creator "igraph version @VERSION@ unittest"
Version 1
graph
[
  directed 0
  node
  [
    id 0
  ]
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  edge
  [
    source 1
    target 0
    weight 5
  ]
  edge
  [
    source 1
    target 1
    weight 2
  ]
  edge
  [
    source 1
    target 1
    weight 4
  ]
]

to_undirected(EACH)
===================

Creator "igraph version @VERSION@ unittest"
Version 1
graph
[
  directed 0
  node
  [
    id 0
  ]
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  edge
  [
    source 1
    target 0
    weight 1
  ]
  edge
  [
    source 1
    target 0
    weight 2
  ]
  edge
  [
    source 1
    target 0
    weight 3
  ]
  edge
  [
    source 1
    target 1
    weight 4
  ]
  edge
  [
    source 1
    target 1
    weight 2
  ]
]

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/cattr_bool_bug.c0000644000175100001710000000313600000000000026330 0ustar00runnerdocker00000000000000
#include 
#include 
#include 

#include "../unit/test_utilities.inc"

void check_attr(igraph_t *graph) {
    IGRAPH_ASSERT(igraph_cattribute_has_attr(graph, IGRAPH_ATTRIBUTE_GRAPH, "name"));
    IGRAPH_ASSERT(igraph_cattribute_has_attr(graph, IGRAPH_ATTRIBUTE_GRAPH, "type"));
    IGRAPH_ASSERT(igraph_cattribute_has_attr(graph, IGRAPH_ATTRIBUTE_GRAPH, "p"));
    IGRAPH_ASSERT(igraph_cattribute_has_attr(graph, IGRAPH_ATTRIBUTE_VERTEX, "name"));
    IGRAPH_ASSERT(igraph_cattribute_has_attr(graph, IGRAPH_ATTRIBUTE_EDGE, "weight"));
}

int main() {

    igraph_t graph;
    igraph_error_handler_t* oldhandler;
    int result;
    FILE *ifile = fopen("cattr_bool_bug.graphml", "r");

    if (!ifile) {
        printf("Cannot open input file\n");
        return 1;
    }

    igraph_set_attribute_table(&igraph_cattribute_table);

    oldhandler = igraph_set_error_handler(igraph_error_handler_ignore);
    if ((result = igraph_read_graph_graphml(&graph, ifile, 0))) {
        /* Maybe it is simply disabled at compile-time. If so, skip test. */
        if (result == IGRAPH_UNIMPLEMENTED) {
            return 77;
        }
        printf("Failed to read GraphML file\n");
        return 1;
    }
    igraph_set_error_handler(oldhandler);

    fclose(ifile);

    printf("Checkng attributes of original graph\n");
    check_attr(&graph);

    printf("Checkng attributes of directed version\n");
    igraph_to_directed(&graph, IGRAPH_TO_DIRECTED_ARBITRARY);
    check_attr(&graph);

    IGRAPH_ASSERT(! GAB(&graph, "loops"));

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/cattr_bool_bug.graphml0000644000175100001710000000444700000000000027546 0ustar00runnerdocker00000000000000


  
  
  
  
  
  
  
    Erdos renyi (gnp) graph
    gnp
    false
    0.2
    
      n0
    
    
      n1
    
    
      n2
    
    
      n3
    
    
      n4
    
    
      n5
    
    
      n6
    
    
      n7
    
    
      n8
    
    
      n9
    
    
      10
    
    
      11
    
    
      12
    
    
      13
    
    
      14
    
    
      15
    
    
      16
    
    
      17
    
    
      18
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/cattr_bool_bug2.c0000644000175100001710000000212200000000000026404 0ustar00runnerdocker00000000000000
#include 
#include 

#include "../unit/test_utilities.inc"

#define FILENAME "mybool.graphml.xml"

int main() {

    igraph_t graph;
    igraph_error_handler_t* oldhandler;
    int result;
    FILE* ifile = fopen("cattr_bool_bug2.graphml", "r");

    if (!ifile) {
        printf("Cannot open input file\n");
        return 1;
    }

    igraph_set_attribute_table(&igraph_cattribute_table);

    oldhandler = igraph_set_error_handler(igraph_error_handler_ignore);
    if ((result = igraph_read_graph_graphml(&graph, ifile, 0))) {
        /* maybe it is simply disabled at compile-time */
        if (result == IGRAPH_UNIMPLEMENTED) {
            return 77;
        }
        printf("Failed to read GraphML file\n");
        return 1;
    }
    igraph_set_error_handler(oldhandler);

    fclose(ifile);

    IGRAPH_ASSERT(igraph_cattribute_has_attr(&graph, IGRAPH_ATTRIBUTE_GRAPH, "mybool"));

    /* Boolean attribute value is expected to be true */
    IGRAPH_ASSERT(igraph_cattribute_GAB(&graph, "mybool"));

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/cattr_bool_bug2.graphml0000644000175100001710000000064300000000000027622 0ustar00runnerdocker00000000000000

  
  
    True
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_layout_kamada_kawai_3d_bug_1462.c0000644000175100001710000000200500000000000032555 0ustar00runnerdocker00000000000000#include 
#include 

#include "../unit/test_utilities.inc"

void snap_to_zero(igraph_real_t* value) {
    if (fabs(*value) < 1e-5) {
        *value = 0.0;
    }
}

int main() {
    igraph_t graph;
    igraph_matrix_t layout;
    igraph_integer_t i;

    if (igraph_empty(&graph, 2, 0)) {
        return 1;
    }

    if (igraph_add_edge(&graph, 0, 1)) {
        return 2;
    }

    if (igraph_matrix_init(&layout, 0, 0)) {
        return 3;
    }

    if (igraph_layout_kamada_kawai_3d(&graph, &layout, 0, 200, 0, 2, 0, 0, 0, 0, 0, 0, 0)) {
        return 4;
    }

    /* Snap numbers close to zero in the layout; there are false failures on
     * MinGW if we don't do so */
    for (i = 0; i < 2; i++) {
        snap_to_zero(&MATRIX(layout, i, 0));
        snap_to_zero(&MATRIX(layout, i, 1));
        snap_to_zero(&MATRIX(layout, i, 2));
    }
    print_matrix_format(&layout, stdout, "%.2f");

    igraph_matrix_destroy(&layout);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_layout_kamada_kawai_3d_bug_1462.out0000644000175100001710000000004500000000000033144 0ustar00runnerdocker00000000000000[ 0.00 0.00 -0.41
  0.00 0.00 1.00 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.c0000644000175100001710000000316200000000000033063 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "../unit/test_utilities.inc"

int main() {

    igraph_t g;
    FILE *f;
    igraph_matrix_t coords;
    igraph_vector_t roots;
    long int i, n;

    f = fopen("igraph_layout_reingold_tilford_bug_879.in", "r");
    igraph_read_graph_edgelist(&g, f, 0, 0);
    igraph_matrix_init(&coords, 0, 0);
    igraph_vector_init(&roots, 0);
    igraph_vector_push_back(&roots, 0);

    igraph_layout_reingold_tilford(&g, &coords, IGRAPH_OUT, &roots, 0);

    n = igraph_vcount(&g);
    for (i = 0; i < n; i++) {
      printf("%6.3f %6.3f\n", MATRIX(coords, i, 0), MATRIX(coords, i, 1));
    }

    igraph_matrix_destroy(&coords);
    igraph_vector_destroy(&roots);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.in0000644000175100001710000000010200000000000033236 0ustar00runnerdocker000000000000000 1
0 2
0 3
1 4
2 5
2 6
3 7
4 8
4 9
4 10
4 11
4 12
7 13
7 14
7 15
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_layout_reingold_tilford_bug_879.out0000644000175100001710000000034000000000000033443 0ustar00runnerdocker00000000000000 0.000  0.000
-1.833  1.000
-0.333  1.000
 2.167  1.000
-1.833  2.000
-0.833  2.000
 0.167  2.000
 2.167  2.000
-3.833  3.000
-2.833  3.000
-1.833  3.000
-0.833  3.000
 0.167  3.000
 1.167  3.000
 2.167  3.000
 3.167  3.000
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_read_graph_gml_invalid_inputs.c0000644000175100001710000000377100000000000032745 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include 
#include 
#include 
#include "igraph.h"
#include 

#include "../unit/test_utilities.inc"

int test_file(const char* fname) {
    FILE *ifile;
    igraph_t g;
    int retval;

    ifile = fopen(fname, "r");
    if (ifile == 0) {
        return 1;
    }

    retval = igraph_read_graph_gml(&g, ifile);
    if (!retval) {
        /* input was accepted, this is a bug; attempt to clean up after
         * ourselves nevertheless */
        igraph_destroy(&g);
        fclose(ifile);
        return 2;
    }

    fclose(ifile);

    return 0;
}

#undef RUN_TEST
#define RUN_TEST(fname) {   \
    index++;                \
    if (test_file(fname)) { \
        return index;       \
    }                       \
    VERIFY_FINALLY_STACK(); \
}

int main(int argc, char* argv[]) {
    int index = 0;

    /* We do not care about errors; all we care about is that the library
     * should not segfault and should not accept invalid input either */
    igraph_set_error_handler(igraph_error_handler_ignore);

    RUN_TEST("invalid1.gml");
    RUN_TEST("invalid2.gml");
    RUN_TEST("invalid3.gml");
    RUN_TEST("invalid4.gml");
    RUN_TEST("invalid5.gml");
    RUN_TEST("invalid6.gml");

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/igraph_read_graph_graphml_invalid_inputs.c0000644000175100001710000000431100000000000033607 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include 
#include 
#include 
#include "igraph.h"
#include 

#include "../unit/test_utilities.inc"

int test_file(const char* fname, igraph_bool_t should_parse) {
    FILE *ifile;
    igraph_t g;
    int retval;

    ifile = fopen(fname, "r");
    if (ifile == 0) {
        return 1;
    }

    retval = igraph_read_graph_graphml(&g, ifile, 0);
    if (retval == IGRAPH_SUCCESS) {
        /* destroy the graph if we managed to parse it */
        igraph_destroy(&g);
    }

    fclose(ifile);

    if (!should_parse && retval == IGRAPH_SUCCESS) {
        /* input was accepted but it should not have been, this is a bug */
        return 2;
    } else {
        return 0;
    }
}

#undef RUN_TEST
#define RUN_TEST(fname, should_parse) {   \
    index++;                              \
    if (test_file(fname, should_parse)) { \
        return index;                     \
    }                                     \
    VERIFY_FINALLY_STACK();               \
}

int main(int argc, char* argv[]) {
    int index = 0;

    /* We do not care about errors; all we care about is that the library
     * should not segfault and should not accept invalid input either */
    igraph_set_error_handler(igraph_error_handler_ignore);

    RUN_TEST("invalid1.graphml", /* should_parse = */ 0);
    RUN_TEST("invalid2.graphml", /* should_parse = */ 1);
    RUN_TEST("invalid3.graphml", /* should_parse = */ 0);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid1.gml0000644000175100001710000000706200000000000025411 0ustar00runnerdocker00000000000000Creator "Mark Newman on Fri Jul 21 12:39:27 2006"
graph
[
  ntde
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  node
  [
    id 4
  ]
  node
  [
    id 5
  ]
  node
  [
    id 6
  ]
  node
  [
    id 7
  ]
  node
  [
    id 8
  ]
  node
  [
    id 9
  ]
  node
  [
    id 10
  ]
  node
  [
    id 11
  ]
  node
  [
    id 12
  ]
  node
  [
    id 13
  ]
  node
  [
    id 14
  ]
  node
  [
    id 15
  ]
  node
  [
    id 16
  ]
  node
  [
    id 17
  ]
  node
  [
    id 18
  ]
  node
  [
    id 19
  ]
  node
  [
    id 20
  ]
  node
  [
    id 21
  ]
  node
  [
    id 22
  ]
  node
  [
    id 23
  ]
  node
  [
    id 24
  ]
  node
  [
    id 25
  ]
  node
  [
    id 26
  ]
  node
  [
    id 27
  ]
  node
  [
    id 28
  ]
  node
  [
    id 29
  ]
  node
  [
    id 30
  ]
  node
  [
    id 31
  ]
  node
  [
    id 32
  ]
  node
  [
    id 33
  ]
  node
  [
    id 34
  ]
  edge
  [
    source 2
    target 1
  ]
  edge
  [
    source 3
    target 1
  ]
  edge
  [
    source 3
    target 2
  ]
  edge
  [
    source 4
    target 1
  ]
  edge
  [
    source 4
    target 2
  ]
  edge
  [
    source 4
    target 3
  ]
  edge
  [
    source 5
    target 1
  ]
  edge
  [
    source 2
    target 1
  ]
  edge
  [
    source 7
    target 1
  ]
  edge
  [
    source 7
    target 5
  ]
  edge
  [
    source 7
    target 6
  ]
  edge
  [
    source 8
    target 1
  ]
  edge
  [
    source 8
    target 2
  ]
  edge
  [
    source 8
    target 3
  ]
  edge
  [
    source 8
    target 4
  ]
  edge
  [
    source 9
    target 1
  ]
  edge
  [
    source 9
    target 3
  ]
  edge
  [
    source 10
    target 3
  ]
  edge
  [
    source 11
    target 1

    source 20
    target 1
  ]
  edge
  [
    source 20
    target 2
  ]
  edge
  [
    source 22
    target 1
  ]
  edge
  [
    source 22
    target 2
  ]
  edge
  [
    source 26
    target 24
  ]
  edge
  [
    source 26
    target 25
  ]
  edge
  [
    source 28
    target 3
  ]
  edge
  [
    source 28
    target 24
  ]
  edge
  [
    source 28
    target 25
  ]
  edge
  [
    source 29
    target 3
  ]
  edge
  [
    source 30
    target 24
  ]
  edge
  [
    source 30
    target 27
  ]
  edge
  [
    source 31
    target 2
  ]
  edge
  [
    source 31
    target 9
  ]
  edge
  [
    source 32
    target 1
  ]
  edge
  [
    source 32
    target 25
  ]
  edge
  [
    source 32
    target 26
  ]
  edge
  [
    source 32
    target 29
  ]
  edge
  [
    source 33
    target 3
  ]
  edge
  [
    source 33
    target 9
  ]
  edge
  [
    source 33
    target 15
  ]
  edge
  [
    source 33
    target 16
  ]
  edge
  [
    source 33
    target 19
  ]
  edge
  [
    source 33
    target 21
  ]
  edge
  [
    source 33
    target 23
  ]
  edge
  [
    source 33
    target 24
  ]
  edge
  [
    source 33
    target 30
  ]
  edge
  [
    source 33
    target 31
  ]
  edge
  [
    source 33
    target 32
  ]
  edge
  [
    source 34
    target 9
  ]
  edge
  [
    source 34
    target 10
  ]
  edge
  [
    source 34
    target 14
  ]
  edge
  [
    source 34
    target 15
  ]
  edge
  [
    source 34
    target 16
  ]
  edge
  [
    source 34
    target 19
  ]
  edge
  [
    source 34
    target 20
  ]
  edge
  [
    source 34
    target 21
  ]
  edge
  [
    source 34
    target 23
  ]
  edge
  [
    source 34
    target 24
  ]
  edge
  [
    source 34
    target 27
  ]
  edge
  [
    source 34
    target 28
  ]
  edge
  [
    source 34
    target 29
  ]
  edge
  [
    source 17
    target 30
  ]
  edge
  [
    source 34
    target 31
  ]
  edge
  [
    source 34
    target 32
  ]
  edge
  [
    source 34
    target 33
  ]
]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid1.graphml0000644000175100001710000000146200000000000026262 0ustar00runnerdocker00000000000000


  
    yellow
  
  
  
  
  
 ,  1
  
  
    2006-11-12*
    blue
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid2.gml0000644000175100001710000000000600000000000025401 0ustar00runnerdocker00000000000000 d  1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid2.graphml0000644000175100001710000000214200000000000026257 0ustar00runnerdocker00000000000000


  
    yellow
  
  
  
 @  yellowwe 
  
"http://graphml.graphdrawingg/2001/XMLrawing.org/xmlns/1.0/graphml.xsd">
  
    yellow
  
  

  
 @  yellowwe 
  
  
    1
  
  
   /edge>
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid3.gml0000644000175100001710000000316600000000000025414 0ustar00runnerdocker00000000000000Creator "Mark Newman on Fri Jul 21 12:39:27 2006"
graph
[
  node
  [
    id 1
  ]
  node
  [
    id 2
  ]
  node
  [
    id 3
  ]
  node
  [
    id 4
  ]
  node
  [
    id 5
  ]
  node
  [
    id 6
  ]
  node
  [
    id 7
  ]
  node
  [
    id 8
  ]
  node
  [
    id 9
  ]
  node
  [
    id 10
  ]
  node
  [
    id 11
  ]
  node
  [
    id 12
  ]
  node
  [
    id 13
  ]
  node
  [
    id 14
  ]
  node
  [
    id 15
  ]
  node
  [
    id 16
  ]
  node
  [
    id 17
  ]
  node
  [
    id 18
  ]
  node
  [
    id 19
  ]
  node
  [
    id 20
  ]
  node
  [
    id 21
  ]
  node
  [
    id 22
  ]
  node
  [
    id 23
  ]
  node
  [
    id 24
  ]
  node
  [
    id 25
  ]
  node
  [
    id 26
  ]
  node
  [
    id 27
  ]
  node
  [
    id 28
  ]
  node
  [
    id 29
  ]
  node
  [
    id 30
  ]
  node
  [
    id 31
  ]
  node

  [   id 32
  ]
  node
  [
    id 33
  ]
  node
  [
    id 34
  ]
  edge
  [
    source 2
    target 1
  ]
  edge
  [
    source 3
    target 1
  ]
  edge
  [
    source 3
    target 2
  ]
  eige
  [
    source 4
    target 1
  ]
  edge
  [
    source 4
    target 2
  ]
  edge
  [
    source 4
    target 3
  ]
  edge
  [
    source 5
    target 1
  ]
  edge
  [
    source 6
    target 1
  ]
  edce
  [
    source 7
    target 1
  ]
  edge
  [
    source 7
    target 5
  ]
  edge
  [
    source 7
    target 6
  ]
  edge
  [
    source 8
    target 1
  ]
  edge
   [
    source 8
    target 3
  ]
  edge
  [
    source 8
    t 3
    target 2
  ]
  eige
  [
    source 4
    target 1
  ]
  edge
  [
    source 4
    target 2
  ]
  edge
  [
    source 4
    t  [
    source 32
    target 29
  ]
 e 34
    target 33
  ]
]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid3.graphml0000644000175100001710000000000000000000000026247 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid4.gml0000644000175100001710000000001200000000000025400 0ustar00runnerdocker00000000000000Version-0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid5.gml0000644000175100001710000000003500000000000025406 0ustar00runnerdocker00000000000000graph[node[a
r
r P p
r d v]]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/regression/invalid6.gml0000644000175100001710000000005500000000000025411 0ustar00runnerdocker00000000000000graph[node[id 2]edge[source 2targetrgett 2]]
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/tests/unit/0000755000175100001710000000000000000000000021773 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/2wheap.c0000644000175100001710000001126100000000000023326 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "core/indheap.h"

#include "test_utilities.inc"

int main() {

    igraph_vector_t elems;
    igraph_2wheap_t Q;
    long int i;
    igraph_real_t prev = IGRAPH_INFINITY;

    srand(42); /* make tests deterministic */

    igraph_vector_init(&elems, 100);
    for (i = 0; i < igraph_vector_size(&elems); i++) {
        VECTOR(elems)[i] = rand() / (double)RAND_MAX;
    }

    igraph_2wheap_init(&Q, igraph_vector_size(&elems));
    for (i = 0; i < igraph_vector_size(&elems); i++) {
        igraph_2wheap_push_with_index(&Q, i, VECTOR(elems)[i]);
    }

    /*****/

    for (i = 0; i < igraph_vector_size(&elems); i++) {
        if (VECTOR(elems)[i] != igraph_2wheap_get(&Q, i)) {
            return 1;
        }
    }

    /*****/

    for (i = 0; i < igraph_vector_size(&elems); i++) {
        long int j;
        igraph_real_t tmp = igraph_2wheap_max(&Q);
        if (tmp > prev) {
            return 2;
        }
        if (tmp != igraph_2wheap_delete_max_index(&Q, &j)) {
            return 3;
        }
        if (VECTOR(elems)[j] != tmp) {
            return 4;
        }
        prev = tmp;
    }

    /*****/

    for (i = 0; i < igraph_vector_size(&elems); i++) {
        igraph_2wheap_push_with_index(&Q, i, VECTOR(elems)[i]);
    }
    if (igraph_2wheap_size(&Q) != igraph_vector_size(&elems)) {
        return 5;
    }
    for (i = 0; i < igraph_vector_size(&elems); i++) {
        VECTOR(elems)[i] = rand() / (double)RAND_MAX;
        igraph_2wheap_modify(&Q, i, VECTOR(elems)[i]);
    }
    for (i = 0; i < igraph_vector_size(&elems); i++) {
        if (VECTOR(elems)[i] != igraph_2wheap_get(&Q, i)) {
            return 6;
        }
    }
    prev = IGRAPH_INFINITY;
    for (i = 0; i < igraph_vector_size(&elems); i++) {
        long int j;
        igraph_real_t tmp = igraph_2wheap_max(&Q);
        if (tmp > prev) {
            return 7;
        }
        if (tmp != igraph_2wheap_delete_max_index(&Q, &j)) {
            return 8;
        }
        if (VECTOR(elems)[j] != tmp) {
            return 9;
        }
        prev = tmp;
    }
    if (!igraph_2wheap_empty(&Q)) {
        return 10;
    }
    if (igraph_2wheap_size(&Q) != 0) {
        return 11;
    }

    igraph_2wheap_destroy(&Q);
    igraph_vector_destroy(&elems);

    /* Hand-made example */

#define MAX       do { igraph_2wheap_delete_max(&Q); igraph_2wheap_check(&Q); } while (0)
#define PUSH(i,e) do { igraph_2wheap_push_with_index(&Q, (i), -(e)); igraph_2wheap_check(&Q); } while (0);
#define MOD(i, e) do { igraph_2wheap_modify(&Q, (i), -(e)); igraph_2wheap_check(&Q); } while (0)

    igraph_2wheap_init(&Q, 21);
    /* 0.00 [ 4] */ PUSH(4, 0);
    /* MAX       */ MAX;
    /* 0.63 [11] */ PUSH(11, 0.63);
    /* 0.05 [15] */ PUSH(15, 0.05);
    /* MAX       */ MAX;
    /* 0.4  [12] */ PUSH(12, 0.4);
    /* 0.4  [13] */ PUSH(13, 0.4);
    /* 0.12 [16] */ PUSH(16, 0.12);
    /* MAX       */ MAX;
    /* 1.1  [ 0] */ PUSH(0, 1.1);
    /* 1.1  [14] */ PUSH(14, 1.1);
    /* MAX       */ MAX;
    /* [11]/0.44 */ MOD(11, 0.44);
    /* MAX       */ MAX;
    /* MAX       */ MAX;
    /* 1.1  [20] */ PUSH(20, 1.1);
    /* MAX       */ MAX;
    /* 1.3  [ 7] */ PUSH(7, 1.3);
    /* 1.7  [ 9] */ PUSH(9, 1.7);
    /* MAX       */ MAX;
    /* 1.6  [19] */ PUSH(19, 1.6);
    /* MAX       */ MAX;
    /* 2.1  [17] */ PUSH(17, 2.1);
    /* 1.3  [18] */ PUSH(18, 1.3);
    /* MAX       */ MAX;
    /* 2.3  [ 1] */ PUSH(1, 2.3);
    /* 2.2  [ 5] */ PUSH(5, 2.2);
    /* 2.3  [10] */ PUSH(10, 2.3);
    /* MAX       */ MAX;
    /* [17]/1.5  */ MOD(17, 1.5);
    /* MAX       */ MAX;
    /* 1.8  [ 6] */ PUSH(6, 1.8);
    /* MAX       */ MAX;
    /* 1.3  [ 3] */ PUSH(3, 1.3);
    /* [ 6]/1.3  */ MOD(6, 1.3);
    /* MAX       */ MAX;
    /* 1.6  [ 8] */ PUSH(8, 1.6);
    /* MAX       */ MAX;

    igraph_2wheap_destroy(&Q);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/VF2-compat.c0000644000175100001710000001710700000000000024023 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

/* ----------------------------------------------------------- */

/* Vertices/edges with the same parity match */
igraph_bool_t compat_parity(const igraph_t *graph1,
                            const igraph_t *graph2,
                            const igraph_integer_t g1_num,
                            const igraph_integer_t g2_num,
                            void *arg) {
    return (g1_num % 2) == (g2_num % 2);
}

/* Nothing vertex/edge 0 in graph1 */
igraph_bool_t compat_not0(const igraph_t *graph1,
                          const igraph_t *graph2,
                          const igraph_integer_t g1_num,
                          const igraph_integer_t g2_num,
                          void *arg) {
    return g1_num != 0;
}

int match_rings() {

    igraph_t r1, r2;
    igraph_bool_t iso;
    igraph_integer_t count;
    igraph_ring(&r1, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_ring(&r2, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);

    igraph_isomorphic_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                          &iso, /*map12=*/ 0, /*map21=*/ 0,
                          /*node_compat_fn=*/ 0, /*edge_compat_fn=*/ 0,
                          /*arg=*/ 0);
    if (!iso) {
        exit(1);
    }

    igraph_isomorphic_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                          &iso, /*map12=*/ 0, /*map21=*/ 0,
                          compat_parity, /*edge_compat_fn=*/ 0, /*arg=*/ 0);
    if (!iso) {
        exit(2);
    }

    igraph_isomorphic_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                          &iso, /*map12=*/ 0, /*map21=*/ 0,
                          compat_not0, /*edge_compat_fn=*/ 0, /*arg=*/ 0);
    if (iso) {
        exit(3);
    }

    /* ------- */

    igraph_isomorphic_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                          &iso, /*map12=*/ 0, /*map21=*/ 0,
                          /*node_compat_fn=*/ 0, compat_parity, /*arg=*/ 0);
    if (!iso) {
        exit(4);
    }

    igraph_isomorphic_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                          &iso, /*map12=*/ 0, /*map21=*/ 0,
                          /*node_compat_fn=*/ 0, compat_not0, /*arg=*/ 0);
    if (iso) {
        exit(5);
    }

    /* ------- */

    igraph_count_isomorphisms_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                                  &count, /*node_compat_fn=*/ 0,
                                  /*edge_compat_fn=*/ 0, /*arg=*/ 0);

    if (count != 20) {
        exit(6);
    }

    igraph_count_isomorphisms_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                                  &count, compat_parity, /*edge_compat_fn=*/ 0,
                                  /*arg=*/ 0);

    if (count != 10) {
        exit(7);
    }

    igraph_count_isomorphisms_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                                  &count, compat_not0, /*edge_compat_fn=*/ 0,
                                  /*arg=*/ 0);

    if (count != 0) {
        exit(8);
    }

    /* ------- */

    igraph_count_isomorphisms_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                                  &count, /*node_compat_fn=*/ 0, compat_parity,
                                  /*arg=*/ 0);

    if (count != 10) {
        exit(9);
    }

    igraph_count_isomorphisms_vf2(&r1, &r2, /*colors(4x)*/ 0, 0, 0, 0,
                                  &count, /*node_compat_fn=*/ 0, compat_not0,
                                  /*arg=*/ 0);

    if (count != 0) {
        exit(10);
    }

    igraph_destroy(&r1);
    igraph_destroy(&r2);
    return 0;
}

int match_rings_open_closed() {
    igraph_t ro, rc;
    igraph_bool_t iso;
    igraph_integer_t count;
    igraph_ring(&ro, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 0);
    igraph_ring(&rc, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);

    igraph_subisomorphic_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                             &iso, /*map12=*/ 0, /*map21=*/ 0,
                             /*node_compat_fn=*/ 0, /*edge_compat_fn=*/ 0,
                             /*arg=*/ 0);
    if (!iso) {
        exit(31);
    }

    igraph_subisomorphic_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                             &iso, /*map12=*/ 0, /*map21=*/ 0,
                             compat_parity, /*edge_compat_fn=*/ 0,
                             /*arg=*/ 0);
    if (!iso) {
        exit(32);
    }

    igraph_subisomorphic_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                             &iso, /*map12=*/ 0, /*map21=*/ 0,
                             compat_not0, /*edge_compat_fn=*/ 0,
                             /*arg=*/ 0);
    if (iso) {
        exit(33);
    }

    /* ------- */

    igraph_subisomorphic_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                             &iso, /*map12=*/ 0, /*map21=*/ 0,
                             /*node_compat_fn=*/ 0, compat_parity,
                             /*arg=*/ 0);
    if (!iso) {
        exit(34);
    }

    igraph_subisomorphic_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                             &iso, /*map12=*/ 0, /*map21=*/ 0,
                             /*node_compat_fn=*/ 0, compat_not0,
                             /*arg=*/ 0);
    if (!iso) {
        exit(35);
    }

    /* ------- */

    igraph_count_subisomorphisms_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                                     &count, /*node_compat_fn=*/ 0,
                                     /*edge_compat_fn=*/ 0, /*arg=*/ 0);

    if (count != 20) {
        exit(36);
    }

    igraph_count_subisomorphisms_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                                     &count, compat_parity,
                                     /*edge_compat_fn=*/ 0, /*arg=*/ 0);

    if (count != 10) {
        exit(37);
    }

    igraph_count_subisomorphisms_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                                     &count, compat_not0, /*edge_compat_fn=*/ 0,
                                     /*arg=*/ 0);

    if (count != 0) {
        exit(38);
    }

    /* ------- */

    igraph_count_subisomorphisms_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                                     &count, /*node_compat_fn=*/ 0,
                                     compat_parity, /*arg=*/ 0);

    if (count != 10) {
        exit(39);
    }

    igraph_count_subisomorphisms_vf2(&rc, &ro, /*colors(4x)*/ 0, 0, 0, 0,
                                     &count, /*node_compat_fn=*/ 0, compat_not0,
                                     /*arg=*/ 0);

    if (count != 2) {
        exit(40);
    }

    igraph_destroy(&ro);
    igraph_destroy(&rc);
    return 0;
}

/* ----------------------------------------------------------- */

int main() {
    match_rings();
    match_rings_open_closed();

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/adjlist.c0000644000175100001710000002603400000000000023576 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int test_simple_trees() {
    igraph_t g, g2;
    igraph_adjlist_t adjlist;
    igraph_bool_t iso;

    /* Directed, out */
    igraph_tree(&g, 42, 3, IGRAPH_TREE_OUT);
    igraph_adjlist_init(&g, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    igraph_adjlist(&g2, &adjlist, IGRAPH_OUT, /*duplicate=*/ 0);
    igraph_isomorphic(&g, &g2, &iso);
    IGRAPH_ASSERT(iso);
    igraph_adjlist_destroy(&adjlist);
    igraph_destroy(&g2);
    igraph_destroy(&g);

    /* Directed, in */
    igraph_tree(&g, 42, 3, IGRAPH_TREE_OUT);
    igraph_adjlist_init(&g, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    igraph_adjlist(&g2, &adjlist, IGRAPH_IN, /*duplicate=*/ 0);
    igraph_isomorphic(&g, &g2, &iso);
    IGRAPH_ASSERT(iso);
    igraph_adjlist_destroy(&adjlist);
    igraph_destroy(&g2);
    igraph_destroy(&g);

    /* Undirected */
    igraph_tree(&g, 42, 3, IGRAPH_TREE_UNDIRECTED);
    igraph_adjlist_init(&g, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);
    igraph_adjlist(&g2, &adjlist, IGRAPH_ALL, /*duplicate=*/ 1);
    igraph_isomorphic(&g, &g2, &iso);
    IGRAPH_ASSERT(iso);
    igraph_adjlist_destroy(&adjlist);
    igraph_destroy(&g2);
    igraph_destroy(&g);

    return 0;
}

#define TEST_ADJLIST(label, mode, loops, multiple) { \
    igraph_adjlist_init(&g, &adjlist, mode, loops, multiple); \
    printf(label ": "); \
    print_adjlist(&adjlist); \
    printf("\n"); \
    igraph_adjlist_destroy(&adjlist); \
}

#define TEST_LAZY_ADJLIST(label, mode, loops, multiple) { \
    igraph_lazy_adjlist_init(&g, &lazy_adjlist, mode, loops, multiple); \
    printf(label ": "); \
    print_lazy_adjlist(&lazy_adjlist); \
    printf("\n"); \
    igraph_lazy_adjlist_destroy(&lazy_adjlist); \
}

int test_loop_elimination_for_undirected_graph() {
    igraph_t g;
    igraph_adjlist_t adjlist;
    igraph_lazy_adjlist_t lazy_adjlist;

    igraph_small(
        &g, 5, /* directed = */ 0,
        0, 1, 0, 3,
        1, 2,
        2, 2, 2, 3,
        3, 0, 3, 4,
        4, 4, 4, 4,
        -1
    );

    printf("Testing loop edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_ADJLIST("Loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_ADJLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_ADJLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("============================================================\n\n");

    printf("Testing lazy loop edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_LAZY_ADJLIST("Loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int test_loop_elimination_for_directed_graph() {
    igraph_t g;
    igraph_adjlist_t adjlist;
    igraph_lazy_adjlist_t lazy_adjlist;

    igraph_small(
        &g, 5, /* directed = */ 1,
        0, 1, 0, 3,
        1, 2,
        2, 2, 2, 3,
        3, 0, 3, 4,
        4, 4, 4, 4,
        -1
    );

    printf("Testing loop edge elimination in directed graph\n\n");

    TEST_ADJLIST("In-edges, loops eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_ADJLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_ADJLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    TEST_ADJLIST("Out-edges, loops eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_ADJLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_ADJLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    TEST_ADJLIST("In- and out-edges, loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_ADJLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_ADJLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("============================================================\n\n");

    printf("Testing lazy loop edge elimination in directed graph\n\n");

    TEST_LAZY_ADJLIST("In-edges, loops eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    TEST_LAZY_ADJLIST("Out-edges, loops eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    TEST_LAZY_ADJLIST("In- and out-edges, loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);
    TEST_LAZY_ADJLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int test_multiedge_elimination_for_undirected_graph() {
    igraph_t g;
    igraph_adjlist_t adjlist;
    igraph_lazy_adjlist_t lazy_adjlist;

    igraph_small(
        &g, 5, /* directed = */ 0,
        0, 1, 0, 3, 0, 8,
        1, 2,
        2, 2, 2, 3,
        3, 0, 3, 4,
        4, 4, 4, 4, 4, 5, 4, 5, 4, 5,
        5, 6,
        6, 7, 6, 8,
        8, 0,
        -1
    );

    printf("Testing multiple edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_ADJLIST("Loops also eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("============================================================\n\n");

    printf("Testing lazy multiple edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_LAZY_ADJLIST("Loops also eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int test_multiedge_elimination_for_directed_graph() {
    igraph_t g;
    igraph_adjlist_t adjlist;
    igraph_lazy_adjlist_t lazy_adjlist;

    igraph_small(
        &g, 5, /* directed = */ 1,
        0, 1, 0, 3, 0, 8,
        1, 2,
        2, 2, 2, 3,
        3, 0, 3, 4,
        4, 4, 4, 4, 4, 5, 4, 5, 4, 5,
        5, 6,
        6, 7, 6, 8,
        8, 0,
        -1
    );

    printf("Testing multiple edge elimination in directed graph\n\n");

    TEST_ADJLIST("In-edges, loops also eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    TEST_ADJLIST("Out-edges, loops also eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    TEST_ADJLIST("In- and out-edges, loops also eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_ADJLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("============================================================\n\n");

    printf("Testing lazy multiple edge elimination in directed graph\n\n");

    TEST_LAZY_ADJLIST("In-edges, loops also eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    TEST_LAZY_ADJLIST("Out-edges, loops also eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    TEST_LAZY_ADJLIST("In- and out-edges, loops also eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);
    TEST_LAZY_ADJLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int main() {
    int retval;

    RUN_TEST(test_simple_trees);

    RUN_TEST(test_loop_elimination_for_undirected_graph);
    RUN_TEST(test_loop_elimination_for_directed_graph);
    RUN_TEST(test_multiedge_elimination_for_undirected_graph);
    RUN_TEST(test_multiedge_elimination_for_directed_graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/adjlist.out0000644000175100001710000001621400000000000024162 0ustar00runnerdocker00000000000000Testing loop edge elimination in undirected graph

Loops eliminated: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 0 2 4 )
  4: ( 3 )
}

Loops listed once: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 )
}

Loops listed twice: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 4 4 )
}

============================================================

Testing lazy loop edge elimination in undirected graph

Loops eliminated: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 0 2 4 )
  4: ( 3 )
}

Loops listed once: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 )
}

Loops listed twice: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 4 4 )
}

============================================================

Testing loop edge elimination in directed graph

In-edges, loops eliminated: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 )
  3: ( 0 2 )
  4: ( 3 )
}

In-edges, loops listed once: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 4 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 4 )
}

Out-edges, loops eliminated: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 3 )
  3: ( 0 4 )
  4: ( )
}

Out-edges, loops listed once: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 4 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 4 )
}

In- and out-edges, loops eliminated: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 0 2 4 )
  4: ( 3 )
}

In- and out-edges, loops listed once: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 )
}

In- and out-edges, loops listed twice: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 4 4 )
}

============================================================

Testing lazy loop edge elimination in directed graph

In-edges, loops eliminated: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 )
  3: ( 0 2 )
  4: ( 3 )
}

In-edges, loops listed once: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 4 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 3 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 4 )
}

Out-edges, loops eliminated: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 3 )
  3: ( 0 4 )
  4: ( )
}

Out-edges, loops listed once: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 4 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 1 3 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 4 )
}

In- and out-edges, loops eliminated: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 0 2 4 )
  4: ( 3 )
}

In- and out-edges, loops listed once: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 )
}

In- and out-edges, loops listed twice: {
  0: ( 1 3 3 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 0 2 4 )
  4: ( 3 4 4 4 4 )
}

============================================================

Testing multiple edge elimination in undirected graph

Loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 2 4 )
  4: ( 3 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

Loops listed once: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

Loops listed twice: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

============================================================

Testing lazy multiple edge elimination in undirected graph

Loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 2 4 )
  4: ( 3 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

Loops listed once: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

Loops listed twice: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

============================================================

Testing multiple edge elimination in directed graph

In-edges, loops also eliminated: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 )
  3: ( 0 2 )
  4: ( 3 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

In-edges, loops listed once: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

Out-edges, loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 3 )
  3: ( 0 4 )
  4: ( 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

Out-edges, loops listed once: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

In- and out-edges, loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 2 4 )
  4: ( 3 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

In- and out-edges, loops listed once: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

In- and out-edges, loops listed twice: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

============================================================

Testing lazy multiple edge elimination in directed graph

In-edges, loops also eliminated: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 )
  3: ( 0 2 )
  4: ( 3 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

In-edges, loops listed once: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 3 8 )
  1: ( 0 )
  2: ( 1 2 )
  3: ( 0 2 )
  4: ( 3 4 )
  5: ( 4 )
  6: ( 5 )
  7: ( 6 )
  8: ( 0 6 )
}

Out-edges, loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 3 )
  3: ( 0 4 )
  4: ( 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

Out-edges, loops listed once: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 1 3 8 )
  1: ( 2 )
  2: ( 2 3 )
  3: ( 0 4 )
  4: ( 4 5 )
  5: ( 6 )
  6: ( 7 8 )
  7: ( )
  8: ( 0 )
}

In- and out-edges, loops also eliminated: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 3 )
  3: ( 0 2 4 )
  4: ( 3 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

In- and out-edges, loops listed once: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

In- and out-edges, loops listed twice: {
  0: ( 1 3 8 )
  1: ( 0 2 )
  2: ( 1 2 2 3 )
  3: ( 0 2 4 )
  4: ( 3 4 4 5 )
  5: ( 4 6 )
  6: ( 5 7 8 )
  7: ( 6 )
  8: ( 0 6 )
}

============================================================

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/all_shortest_paths.c0000644000175100001710000001107100000000000026041 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_ptr_t paths;
    igraph_vector_t nrgeo, weights;
    igraph_integer_t from, to;
    long int i;

    igraph_vector_ptr_init(&paths, 0);
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&paths, igraph_vector_destroy);
    igraph_vector_init(&nrgeo, 0);

    igraph_vector_init(&weights, 0);

    /* Note on the output:
     * get_all_shortest_paths functions sort their output based on the
     * last vertex only. Thus the ordering is not fully defined.
     *
     * This test does not currently canonicalize (i.e. sort)
     * the result before printing it.
     */

    printf("Singleton graph\n");
    igraph_empty(&graph, 1, IGRAPH_UNDIRECTED);

    from = 0; to = 0;

    igraph_get_all_shortest_paths(&graph, &paths, &nrgeo, from, igraph_vss_1(to), IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_free_all(&paths);

    printf("\nSingleton graph, weighted\n");
    igraph_vector_resize(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1);
    igraph_get_all_shortest_paths_dijkstra(&graph, &paths, &nrgeo, from, igraph_vss_1(to), &weights, IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_free_all(&paths);

    igraph_destroy(&graph);

    printf("\nNo paths\n");
    igraph_empty(&graph, 2, IGRAPH_UNDIRECTED);

    from = 0; to = 1;

    igraph_get_all_shortest_paths(&graph, &paths, &nrgeo, from, igraph_vss_1(to), IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_free_all(&paths);

    igraph_destroy(&graph);

    /* This graph has multi-edges (which induce multiple paths of the
     * same length) as well as more paths of the same length between
     * vertices 0 and 4. */
    igraph_small(&graph, 0, IGRAPH_ADJ_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 0, 1, 2, 5, 4, 5, 1, 6, 6, 7, 3, 7,
                 -1);

    from = 0; to = 4;

    printf("\nUnweighted\n");
    igraph_get_all_shortest_paths(&graph, &paths, &nrgeo, from, igraph_vss_1(to), IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_free_all(&paths);

    printf("\nWeighted, uniform weights\n");
    igraph_vector_resize(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1.5); /* constant weights */

    igraph_get_all_shortest_paths_dijkstra(&graph, &paths, &nrgeo, from, igraph_vss_1(to), &weights, IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_free_all(&paths);

    printf("\nWeighted, multiple weighted shortest paths\n");
    VECTOR(weights)[1] = 3.0; /* create path with one more hop, but equal weighted length */
    VECTOR(weights)[4] = 2.0; /* break symmetry on pair of parallel edges */

    igraph_get_all_shortest_paths_dijkstra(&graph, &paths, &nrgeo, from, igraph_vss_1(to), &weights, IGRAPH_ALL);

    for (i=0; i < igraph_vector_ptr_size(&paths); ++i) {
        print_vector(VECTOR(paths)[i]);
    }
    IGRAPH_ASSERT(igraph_vector_ptr_size(&paths) == VECTOR(nrgeo)[to]);

    igraph_vector_ptr_destroy_all(&paths);

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&nrgeo);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/all_shortest_paths.out0000644000175100001710000000046000000000000026426 0ustar00runnerdocker00000000000000Singleton graph
( 0 )

Singleton graph, weighted
( 0 )

No paths

Unweighted
( 0 1 2 5 4 )
( 0 1 2 5 4 )
( 0 1 2 3 4 )
( 0 1 2 3 4 )

Weighted, uniform weights
( 0 1 2 5 4 )
( 0 1 2 5 4 )
( 0 1 2 3 4 )
( 0 1 2 3 4 )

Weighted, multiple weighted shortest paths
( 0 1 2 5 4 )
( 0 1 6 7 3 4 )
( 0 1 2 3 4 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bfs.c0000644000175100001710000001030400000000000022707 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

igraph_bool_t bfs_callback(const igraph_t *graph,
                           igraph_integer_t vid,
                           igraph_integer_t pred,
                           igraph_integer_t succ,
                           igraph_integer_t rank,
                           igraph_integer_t dist,
                           void *extra) {
    printf(" %li", (long int) vid);
    return 0;
}

int main() {

    igraph_t graph, ring;
    igraph_vector_t order, rank, father, pred, succ, dist;
    igraph_vector_t restricted;
    igraph_vector_t roots;
    long int i;

    igraph_ring(&ring, 10, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_disjoint_union(&graph, &ring, &ring);
    igraph_destroy(&ring);

    igraph_vector_init(&order, 0);
    igraph_vector_init(&rank, 0);
    igraph_vector_init(&father, 0);
    igraph_vector_init(&pred, 0);
    igraph_vector_init(&succ, 0);
    igraph_vector_init(&dist, 0);

    igraph_bfs(&graph, /*root=*/0, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, /*restricted=*/ 0,
               &order, &rank, &father, &pred, &succ, &dist,
               /*callback=*/ 0, /*extra=*/ 0);

    print_vector_round(&order);
    print_vector_round(&rank);
    print_vector_round(&father);
    print_vector_round(&pred);
    print_vector_round(&succ);
    print_vector_round(&dist);

    igraph_vector_destroy(&order);
    igraph_vector_destroy(&rank);
    igraph_vector_destroy(&father);
    igraph_vector_destroy(&pred);
    igraph_vector_destroy(&succ);
    igraph_vector_destroy(&dist);

    /* Test the callback */

    printf("(");
    igraph_bfs(&graph, /*root=*/ 0, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, /*restricted=*/ 0,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    /* Test different roots */

    printf("(");
    igraph_bfs(&graph, /*root=*/ 2, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, /*restricted=*/ 0,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    /* Test restricted */

    igraph_vector_init(&restricted, 0);
    for (i = 5; i < igraph_vcount(&graph); i++) {
        igraph_vector_push_back(&restricted, i);
    }
    printf("(");
    igraph_bfs(&graph, /*root=*/ 5, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, &restricted,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    /* Root not in restricted set */

    printf("(");
    igraph_bfs(&graph, /*root=*/ 4, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 1, &restricted,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    printf("(");
    igraph_bfs(&graph, /*root=*/ 3, /*roots=*/ 0, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 0, &restricted,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    /* Multiple root vertices */

    igraph_vector_init(&roots, 3);
    VECTOR(roots)[0] = 3;
    VECTOR(roots)[1] = 4;
    VECTOR(roots)[2] = 6;
    printf("(");
    igraph_bfs(&graph, /*root=*/ -1, &roots, /*neimode=*/ IGRAPH_OUT,
               /*unreachable=*/ 0, &restricted,
               0, 0, 0, 0, 0, 0, &bfs_callback, 0);
    printf(" )\n");

    igraph_vector_destroy(&roots);
    igraph_vector_destroy(&restricted);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bfs.out0000644000175100001710000000102300000000000023272 0ustar00runnerdocker00000000000000( 0 1 9 2 8 3 7 4 6 5 10 11 19 12 18 13 17 14 16 15 )
( 0 1 3 5 7 9 8 6 4 2 10 11 13 15 17 19 18 16 14 12 )
( -1 0 1 2 3 4 7 8 9 0 -1 10 11 12 13 14 17 18 19 10 )
( -1 0 9 8 7 6 4 3 2 1 -1 10 19 18 17 16 14 13 12 11 )
( 1 9 8 7 6 -1 5 4 3 2 11 19 18 17 16 -1 15 14 13 12 )
( 0 1 2 3 4 5 4 3 2 1 0 1 2 3 4 5 4 3 2 1 )
( 0 1 9 2 8 3 7 4 6 5 10 11 19 12 18 13 17 14 16 15 )
( 2 1 3 0 4 9 5 8 6 7 10 11 19 12 18 13 17 14 16 15 )
( 5 6 7 8 9 10 11 19 12 18 13 17 14 16 15 )
( 5 6 7 8 9 10 11 19 12 18 13 17 14 16 15 )
( )
( 6 5 7 8 9 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bfs_simple.c0000644000175100001710000000440000000000000024260 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t vids, layers, parents;

    igraph_vector_init(&vids, 0);
    igraph_vector_init(&layers, 0);
    igraph_vector_init(&parents, 0);

    /* Test a ring graph */
    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 0);
    igraph_bfs_simple(&g, 0, IGRAPH_ALL, &vids, &layers, &parents);
    print_vector_round(&vids);
    print_vector_round(&layers);
    print_vector_round(&parents);
    igraph_destroy(&g);

    /* Test a tree graph */
    igraph_tree(&g, 20, 2, IGRAPH_TREE_UNDIRECTED);
    igraph_bfs_simple(&g, 0, IGRAPH_ALL, &vids, &layers, &parents);
    print_vector_round(&vids);
    print_vector_round(&layers);
    print_vector_round(&parents);
    igraph_destroy(&g);

    /* Test th same graph with all arguments as nulls to see if we tolerate that */
    igraph_tree(&g, 20, 2, IGRAPH_TREE_UNDIRECTED);
    igraph_bfs_simple(&g, 0, IGRAPH_ALL, 0, 0, 0);
    igraph_destroy(&g);

    /* Also test the case when 'layers' is not null and 'vids' is null to ensure
     * that we don't need 'vids' in the internal implementation to populate
     * 'layers' */
    igraph_tree(&g, 20, 2, IGRAPH_TREE_UNDIRECTED);
    igraph_bfs_simple(&g, 0, IGRAPH_ALL, 0, &layers, 0);
    print_vector_round(&layers);
    igraph_destroy(&g);

    igraph_vector_destroy(&vids);
    igraph_vector_destroy(&layers);
    igraph_vector_destroy(&parents);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bfs_simple.out0000644000175100001710000000032100000000000024643 0ustar00runnerdocker00000000000000( 0 1 2 3 4 5 6 7 8 9 )
( 0 1 2 3 4 5 6 7 8 9 10 )
( 0 0 1 2 3 4 5 6 7 8 )
( 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 )
( 0 1 3 7 15 20 )
( 0 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 )
( 0 1 3 7 15 20 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bipartite.net0000644000175100001710000000025100000000000024464 0ustar00runnerdocker00000000000000*Vertices 13 8
1 "A"
2 "B"
3 "C"
4 "D"
5 "E"
6 "F"
7 "G"
8 "H"
9 "x-1"
10 "x-2"
11 "x-3"
12 "x-4"
13 "x-5"
*Edges
1 10
1 13
2 12
3 10
3 11
4 11
5 12
5 13
6 12
8 11
8 13
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bliss_automorphisms.c0000644000175100001710000000162200000000000026246 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

#define TEST_GRAPH(name) \
    igraph_automorphisms(&graph, NULL, IGRAPH_BLISS_F, &info); \
    printf("%s: %s\n", name, info.group_size); \
    igraph_free(info.group_size); \
    igraph_destroy(&graph);

#define TEST_FAMOUS(name) \
    igraph_famous(&graph, name); \
    TEST_GRAPH(name);

int main() {
    igraph_t graph;
    igraph_bliss_info_t info;

    TEST_FAMOUS("Frucht");
    TEST_FAMOUS("Coxeter");
    TEST_FAMOUS("Petersen");
    TEST_FAMOUS("Meredith");

    igraph_full(&graph, 23, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    TEST_GRAPH("Complete 23");

    igraph_star(&graph, 17, IGRAPH_STAR_OUT, 0);
    TEST_GRAPH("Directed star 17");

    igraph_empty(&graph, 0, IGRAPH_UNDIRECTED);
    TEST_GRAPH("Null graph");

    igraph_empty(&graph, 1, IGRAPH_UNDIRECTED);
    TEST_GRAPH("Singleton graph");

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/bliss_automorphisms.out0000644000175100001710000000024200000000000026630 0ustar00runnerdocker00000000000000Frucht: 1
Coxeter: 336
Petersen: 120
Meredith: 38698352640
Complete 23: 25852016738884976640000
Directed star 17: 20922789888000
Null graph: 1
Singleton graph: 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/cattributes5.c0000644000175100001710000001536700000000000024571 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g, g2;
    igraph_attribute_combination_t comb;

    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 0, 1, 0, 1, 0, 1,
                 1, 2, 2, 3,
                 -1);

    SETEAB(&g, "type", 0, 1);
    SETEAB(&g, "type", 1, 1);
    SETEAB(&g, "type", 2, 0);
    SETEAB(&g, "type", 3, 0);
    SETEAB(&g, "type", 4, 1);

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_FIRST,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_LAST,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_LAST,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_PROD,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_MIN,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_MAX,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_MEAN,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    /* ****************************************************** */
    igraph_copy(&g2, &g);
    igraph_attribute_combination(&comb,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_MEDIAN,
                                 IGRAPH_NO_MORE_ATTRIBUTES);
    igraph_simplify(&g2, /*multiple=*/ 1, /*loops=*/ 1, &comb);
    igraph_attribute_combination_destroy(&comb);
    igraph_write_graph_graphml(&g2, stdout, /*prefixattr=*/ 1);
    igraph_destroy(&g2);
    /* ****************************************************** */

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/cattributes5.out0000644000175100001710000001637400000000000025155 0ustar00runnerdocker00000000000000


  
  
    
    
    
    
    
    
    
    
    
      true
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      false
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      false
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      true
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      false
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      false
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      true
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      true
    
    
      false
    
    
      true
    
  




  
  
    
    
    
    
    
    
    
    
    
      true
    
    
      false
    
    
      true
    
  

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_label_propagation.c0000644000175100001710000000755700000000000027743 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t membership, weights, initial;
    igraph_vector_bool_t fixed;
    long int i;

    /* label propagation is a stochastic method */
    igraph_rng_seed(igraph_rng_default(), 765);

    /* Zachary Karate club -- this is just a quick smoke test */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_vector_init(&membership, 0);
    igraph_community_label_propagation(&g, &membership, 0, 0, 0,
                                       /*modularity=*/ 0);

    igraph_destroy(&g);

    /* Simple star graph to test weights */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 2,  3,  2,  4,  3,  4,  3,  5,  4,  5,  -1);
    igraph_vector_init_int_end(&weights, -1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1);
    igraph_vector_init_int_end(&initial, -1, 0, 0, 1, 1, 1, 1, -1);
    igraph_vector_bool_init(&fixed, 6);
    VECTOR(fixed)[3] = 1;
    VECTOR(fixed)[4] = 1;
    VECTOR(fixed)[5] = 1;
    igraph_community_label_propagation(&g, &membership, &weights,
                                       &initial, &fixed, /*modularity=*/ 0);
    for (i = 0; i < igraph_vcount(&g); i++)
        if (VECTOR(membership)[i] != (i < 2 ? 0 : 1)) {
            return 3;
        }
    igraph_community_label_propagation(&g, &membership, 0,
                                       &initial, &fixed, /*modularity=*/ 0);
    for (i = 0; i < igraph_vcount(&g); i++)
        if (VECTOR(membership)[i] != 0) {
            return 4;
        }

    /* Check whether it works with no fixed vertices at all
     * while an initial configuration is given -- see bug
     * #570902 in Launchpad. This is a simple smoke test only. */
    igraph_community_label_propagation(&g, &membership, &weights,
                                       &initial, 0, /*modularity=*/ 0);

    igraph_vector_bool_destroy(&fixed);
    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&initial);
    igraph_destroy(&g);

    igraph_vector_destroy(&membership);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_label_propagation.out0000644000175100001710000000000000000000000030300 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_label_propagation2.c0000644000175100001710000000373600000000000030020 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

/* Test case for bug #1852 */

int main() {
    igraph_t graph;
    igraph_vector_t membership, initial_labels;
    igraph_real_t modularity;

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Undirected graph with unlabelled components */

    igraph_small(&graph, 4, IGRAPH_UNDIRECTED,
                 1,2, -1);

    igraph_vector_init(&membership, 0);
    igraph_vector_init(&initial_labels, igraph_vcount(&graph));
    VECTOR(initial_labels)[0] = 1;
    VECTOR(initial_labels)[1] = -1;
    VECTOR(initial_labels)[2] = -1;
    VECTOR(initial_labels)[3] = -1;

    igraph_community_label_propagation(&graph, &membership, NULL, &initial_labels, NULL, &modularity);
    print_vector(&membership);

    igraph_destroy(&graph);

    /* Directed graph with unlabelled nodes not reachable from any labelled ones. */

    igraph_small(&graph, 8, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 3, 1, 2, 4, 4, 5, 5, 2, 4, 6,
                 -1);

    igraph_vector_resize(&initial_labels, igraph_vcount(&graph));
    igraph_vector_null(&initial_labels);
    VECTOR(initial_labels)[0] = -1;
    VECTOR(initial_labels)[1] = -1;
    VECTOR(initial_labels)[2] = 1;
    VECTOR(initial_labels)[3] = -1;
    VECTOR(initial_labels)[4] = 2;
    VECTOR(initial_labels)[6] = -1;
    VECTOR(initial_labels)[7] = -1;

    igraph_community_label_propagation(&graph, &membership, NULL, &initial_labels, NULL, &modularity);
    print_vector(&membership);

    igraph_destroy(&graph);

    /* None of the nodes are labelled initially */

    igraph_full(&graph, 5, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_vector_resize(&initial_labels, igraph_vcount(&graph));
    igraph_vector_fill(&initial_labels, -1);

    igraph_community_label_propagation(&graph, &membership, NULL, &initial_labels, NULL, &modularity);
    print_vector(&membership);

    igraph_destroy(&graph);

    igraph_vector_destroy(&initial_labels);
    igraph_vector_destroy(&membership);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_label_propagation2.out0000644000175100001710000000005600000000000030375 0ustar00runnerdocker00000000000000( 0 1 1 2 )
( 1 1 0 2 0 0 0 3 )
( 0 0 0 0 0 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_label_propagation3.c0000644000175100001710000000461100000000000030012 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t membership, initial;
    igraph_vector_bool_t fixed;
    long int i;

    /* label propagation is a stochastic method */
    igraph_rng_seed(igraph_rng_default(), 765);

    /* Zachary Karate club -- does not matter, we are simply interested in
     * whether the system handles it correctly if a fixed node is unlabeled */
    igraph_famous(&g, "zachary");


    igraph_vector_init(&initial, igraph_vcount(&g));
    igraph_vector_fill(&initial, -1);
    igraph_vector_bool_init(&fixed, igraph_vcount(&g));
    igraph_vector_bool_fill(&fixed, 0);
    VECTOR(fixed)[7] = 1;
    VECTOR(fixed)[13] = 1;

    igraph_vector_init(&membership, 0);

    igraph_community_label_propagation(&g, &membership, 0, &initial, &fixed,
                                       /*modularity=*/ 0);

    for (i = 0; i < igraph_vcount(&g); i++) {
        /* Check that the "fixed" vector has not been changed */
        if (i == 7 || i == 13) {
            if (!VECTOR(fixed)[i]) {
                return 1;
            }
        } else {
            if (VECTOR(fixed)[i]) {
                return 1;
            }
        }

        /* Check that no vertex remained unlabeled */
        if (VECTOR(membership)[i] < 0) {
            return 2;
        }
    }

    igraph_vector_bool_destroy(&fixed);
    igraph_vector_destroy(&initial);
    igraph_vector_destroy(&membership);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_leiden.c0000644000175100001710000001553700000000000025516 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void run_leiden_CPM(const igraph_t *graph, const igraph_vector_t *edge_weights, const igraph_real_t resolution_parameter) {

    igraph_vector_t membership;
    igraph_integer_t nb_clusters = igraph_vcount(graph);
    igraph_real_t quality;

    /* Initialize with singleton partition. */
    igraph_vector_init(&membership, igraph_vcount(graph));

    igraph_community_leiden(graph, edge_weights, NULL, resolution_parameter, 0.01, 0, &membership, &nb_clusters, &quality);

    printf("Leiden found %" IGRAPH_PRId " clusters using CPM (resolution parameter=%.2f), quality is %.4f.\n", nb_clusters, resolution_parameter, quality);

    printf("Membership: ");
    igraph_vector_print(&membership);
    printf("\n");

    igraph_vector_destroy(&membership);
}

void run_leiden_modularity(igraph_t *graph, igraph_vector_t *edge_weights) {

    igraph_vector_t membership, degree;
    igraph_integer_t nb_clusters = igraph_vcount(graph);
    igraph_real_t quality;
    igraph_real_t m;

    igraph_vector_init(°ree, igraph_vcount(graph));
    if (edge_weights) {
        igraph_strength(graph, °ree, igraph_vss_all(), IGRAPH_ALL, 1, edge_weights);
        m = igraph_vector_sum(edge_weights);
    } else {
        igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, 1);
        m = (igraph_real_t)igraph_ecount(graph);
    }

    /* Initialize with singleton partition. */
    igraph_vector_init(&membership, igraph_vcount(graph));

    igraph_community_leiden(graph, edge_weights, °ree, 1.0 / (2 * m), 0.01, 0, &membership, &nb_clusters, &quality);

    if (isnan(quality)) {
        printf("Leiden found %" IGRAPH_PRId " clusters using modularity, quality is nan.\n", nb_clusters);
    } else {
        printf("Leiden found %" IGRAPH_PRId " clusters using modularity, quality is %.4f.\n", nb_clusters, quality);
    }

    printf("Membership: ");
    igraph_vector_print(&membership);
    printf("\n");

    igraph_vector_destroy(&membership);
    igraph_vector_destroy(°ree);
}

int main() {
    igraph_t graph;
    igraph_vector_t weights;

    igraph_vector_init(&weights, 0);

    /* Set default seed to get reproducible results */
    igraph_rng_seed(igraph_rng_default(), 0);

    /* Simple unweighted graph */
    igraph_small(&graph, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);
    run_leiden_modularity(&graph, NULL);

    /* Same simple graph, with uniform edge weights */
    igraph_vector_resize(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 2);
    run_leiden_modularity(&graph, &weights);
    igraph_destroy(&graph);

    /* Simple nonuniform weighted graph, with and without weights */
    igraph_small(&graph, 6, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5, -1);
    igraph_vector_resize(&weights, 8);
    igraph_vector_fill(&weights, 1);
    VECTOR(weights)[0] = 10;
    VECTOR(weights)[1] = 10;
    run_leiden_modularity(&graph, NULL);
    run_leiden_modularity(&graph, &weights);
    igraph_destroy(&graph);

    /* Zachary Karate club */
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);
    run_leiden_modularity(&graph, NULL);
    run_leiden_CPM(&graph, NULL, 0.06);
    igraph_destroy(&graph);

    /* Simple disconnected graph with isolates */
    igraph_small(&graph, 9, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  1,  2,  1,  3,  2,  3,
                 4,  5,  4,  6,  4,  7,  5,  6,  5,  7,  6,  7,
                 -1);
    run_leiden_modularity(&graph, NULL);
    igraph_destroy(&graph);

    /* Disjoint union of two rings */
    igraph_small(&graph, 20, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 0, 9,
                 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 10, 19, -1);
    run_leiden_modularity(&graph, NULL);
    run_leiden_CPM(&graph, NULL, 0.05);
    igraph_destroy(&graph);

    /* Completely empty graph */
    igraph_small(&graph, 10, IGRAPH_UNDIRECTED, -1);
    run_leiden_modularity(&graph, NULL);
    igraph_destroy(&graph);


    /* Set default seed to get reproducible results */
    igraph_rng_seed(igraph_rng_default(), 0);

    /* Ring graph without loop edges */
    igraph_small(&graph, 6, IGRAPH_UNDIRECTED,
                 0,1, 1,2, 2,3, 3,4, 4,5, 5,0, -1);
    run_leiden_CPM(&graph, NULL, 0.4);
    igraph_destroy(&graph);

    /* Set default seed to get reproducible results */
    igraph_rng_seed(igraph_rng_default(), 0);

    /* Ring graph with loop edges */
    igraph_small(&graph, 6, IGRAPH_UNDIRECTED,
                 0,1, 1,2, 2,3, 3,4, 4,5, 5,0,
                 0,0, 1,1, 2,2, 3,3, 4,4, 5,5,
                 -1);
    run_leiden_CPM(&graph, NULL, 0.4);
    igraph_destroy(&graph);

    /* Regression test -- graph with two vertices and two edges */
    igraph_small(&graph, 2, IGRAPH_UNDIRECTED, 0, 0, 1, 1, -1);
    run_leiden_modularity(&graph, NULL);
    igraph_destroy(&graph);

    igraph_vector_destroy(&weights);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/community_leiden.out0000644000175100001710000000255600000000000026100 0ustar00runnerdocker00000000000000Leiden found 2 clusters using modularity, quality is 0.4524.
Membership: 0 0 0 0 0 1 1 1 1 1

Leiden found 2 clusters using modularity, quality is 0.4524.
Membership: 0 0 0 0 0 1 1 1 1 1

Leiden found 2 clusters using modularity, quality is 0.1797.
Membership: 0 0 1 1 1 1

Leiden found 2 clusters using modularity, quality is 0.1709.
Membership: 0 0 0 1 1 1

Leiden found 4 clusters using modularity, quality is 0.4188.
Membership: 0 0 0 0 1 1 1 0 2 0 1 0 0 0 2 2 1 0 2 0 2 0 2 3 3 3 2 3 3 2 2 3 2 2

Leiden found 2 clusters using CPM (resolution parameter=0.06), quality is 0.6495.
Membership: 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1

Leiden found 3 clusters using modularity, quality is 0.5000.
Membership: 0 0 0 0 1 1 1 1 2

Leiden found 4 clusters using modularity, quality is 0.5450.
Membership: 0 0 0 0 0 1 1 1 1 1 2 2 2 3 3 3 3 2 2 2

Leiden found 2 clusters using CPM (resolution parameter=0.05), quality is 0.7500.
Membership: 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1

Leiden found 10 clusters using modularity, quality is nan.
Membership: 0 1 2 3 4 5 6 7 8 9

Leiden found 3 clusters using CPM (resolution parameter=0.40), quality is 0.1000.
Membership: 0 0 1 1 2 2

Leiden found 3 clusters using CPM (resolution parameter=0.40), quality is 0.5500.
Membership: 0 0 1 1 2 2

Leiden found 2 clusters using modularity, quality is 0.5000.
Membership: 0 1

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/cutheap.c0000644000175100001710000000252100000000000023570 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "core/cutheap.h"

#include "test_utilities.inc"

int main() {
    igraph_i_cutheap_t ch;
    long int i;

    igraph_i_cutheap_init(&ch, 10);

    for (i = 0; i < 10; i++) {
        igraph_i_cutheap_update(&ch, i, i);
    }
    while (!igraph_i_cutheap_empty(&ch)) {
        long int idx = igraph_i_cutheap_popmax(&ch);
        printf("%li ", idx);
    }
    printf("\n");

    igraph_i_cutheap_destroy(&ch);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/cutheap.out0000644000175100001710000000002500000000000024152 0ustar00runnerdocker000000000000009 8 7 6 5 4 3 2 1 0 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/d_indheap.c0000644000175100001710000000616200000000000024057 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "core/indheap.h"

#include "test_utilities.inc"

int main() {

    igraph_d_indheap_t h;
    long int idx1, idx2;

    /* igraph_d_indheap_init, igraph_d_indheap_destroy */
    igraph_d_indheap_init(&h, 0);
    igraph_d_indheap_destroy(&h);
    igraph_d_indheap_init(&h, 100);
    igraph_d_indheap_destroy(&h);

    /* igraph_d_indheap_empty, igraph_d_indheap_size */
    igraph_d_indheap_init(&h, 10);
    if (!igraph_d_indheap_empty(&h)) {
        return 1;
    }
    if (igraph_d_indheap_size(&h) != 0) {
        return 2;
    }
    igraph_d_indheap_push(&h, 10, 0, 0);
    if (igraph_d_indheap_empty(&h)) {
        return 3;
    }
    if (igraph_d_indheap_size(&h) != 1) {
        return 4;
    }

    /* igraph_d_indheap_push */
    igraph_d_indheap_push(&h, 9, 9, 8);
    igraph_d_indheap_push(&h, 3, 3, 2);
    igraph_d_indheap_push(&h, 2, 2, 1);
    igraph_d_indheap_push(&h, 1, 1, 0);
    igraph_d_indheap_push(&h, 7, 7, 6);
    igraph_d_indheap_push(&h, 4, 4, 3);
    igraph_d_indheap_push(&h, 0, 0, 1);
    igraph_d_indheap_push(&h, 6, 6, 5);
    igraph_d_indheap_push(&h, 5, 5, 4);
    igraph_d_indheap_push(&h, 8, 8, 7);

    /* igraph_d_indheap_max, igraph_d_indheap_delete_max */
    while (!igraph_d_indheap_empty(&h)) {
        printf("% li", (long int)igraph_d_indheap_max(&h));
        printf("% li\n", (long int)igraph_d_indheap_delete_max(&h));
    }

    /* igraph_d_indheap_reserve */
    igraph_d_indheap_reserve(&h, 5);
    igraph_d_indheap_reserve(&h, 20);
    igraph_d_indheap_reserve(&h, 0);
    igraph_d_indheap_reserve(&h, 3);

    /* igraph_d_indheap_max_index */
    igraph_d_indheap_push(&h, 0, 0, 1);
    igraph_d_indheap_push(&h, 8, 8, 7);
    igraph_d_indheap_push(&h, 2, 2, 1);
    igraph_d_indheap_push(&h, 7, 7, 6);
    igraph_d_indheap_push(&h, 9, 9, 8);
    igraph_d_indheap_push(&h, 4, 4, 3);
    igraph_d_indheap_push(&h, 3, 3, 2);
    igraph_d_indheap_push(&h, 5, 5, 4);
    igraph_d_indheap_push(&h, 1, 1, 0);
    igraph_d_indheap_push(&h, 6, 6, 5);
    while (!igraph_d_indheap_empty(&h)) {
        igraph_d_indheap_max_index(&h, &idx1, &idx2);
        printf(" %li %li", idx1, idx2);
        igraph_d_indheap_delete_max(&h);
    }
    printf("\n");
    igraph_d_indheap_destroy(&h);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/d_indheap.out0000644000175100001710000000014200000000000024434 0ustar00runnerdocker00000000000000 10 10
 9 9
 8 8
 7 7
 6 6
 5 5
 4 4
 3 3
 2 2
 1 1
 0 0
 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 0 0 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/dgemv.c0000644000175100001710000000405700000000000023247 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

/* Matrix-vector multiplication: y = A.x */
void matmul(const igraph_matrix_t *A, const igraph_vector_t *x, igraph_vector_t *y, igraph_real_t beta) {
    long int i, j, nr = igraph_matrix_nrow(A), nc = igraph_matrix_ncol(A);

    IGRAPH_ASSERT(nc == igraph_vector_size(x));
    IGRAPH_ASSERT(nr == igraph_vector_size(y));

    igraph_vector_scale(y, beta);

    for (i=0; i < nr; ++i) {
        for (j=0; j < nc; ++j) {
            VECTOR(*y)[i] += MATRIX(*A, i, j) * VECTOR(*x)[j];
        }
    }
}

int main() {
    igraph_matrix_t A;
    igraph_vector_t x, y1, y2;
    long int i, j;
    const long int nr = 5, nc = 8;

    igraph_rng_seed(igraph_rng_default(), 54632);

    igraph_matrix_init(&A, nr, nc);
    igraph_vector_init(&x, nc);

    /* Fill with arbitrary values. Should be zeroes by beta. */
    igraph_vector_init_seq(&y1, 1, nr);
    igraph_vector_copy(&y2, &y1);

    for (i=0; i < nr; ++i) {
        for (j=0; j < nc; ++j) {
            MATRIX(A, i, j) = (igraph_real_t) RNG_INTEGER(-10, 10);
        }
    }

    for (j=0; j < nc; ++j) {
        VECTOR(x)[j] = (igraph_real_t) RNG_INTEGER(-10, 10);
    }

    printf("Input matrix A:\n");
    print_matrix(&A);

    printf("\nInput vector x:\n");
    print_vector(&x);

    igraph_blas_dgemv(0, 1, &A, &x, 0, &y1);
    matmul(&A, &x, &y2, 0);

    printf("\nResult vector DGEMV:\n");
    print_vector(&y1);

    printf("\nResult vector naive:\n");
    print_vector(&y2);

    /* Results should be exact since all values are integers */
    IGRAPH_ASSERT(igraph_vector_all_e(&y1, &y2));

    printf("\nAdding to previous result with beta=2:\n");

    igraph_blas_dgemv(0, 1, &A, &x, 2, &y1);
    matmul(&A, &x, &y2, 2);

    printf("\nResult vector DGEMV:\n");
    print_vector(&y1);

    printf("\nResult vector naive:\n");
    print_vector(&y2);

    IGRAPH_ASSERT(igraph_vector_all_e(&y1, &y2));

    igraph_vector_destroy(&y2);
    igraph_vector_destroy(&y1);
    igraph_vector_destroy(&x);
    igraph_matrix_destroy(&A);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/dgemv.out0000644000175100001710000000121200000000000023622 0ustar00runnerdocker00000000000000Input matrix A:
[        2       -6        0       -7        9       -5        7        1
        -7       10        2        8        3        0       -7       -9
         8        0        6       -4       -4       -1        3        3
        -8        7        4        8       -7       -4        9       -6
        -6       10       -1       10       -3        2       -7        5 ]

Input vector x:
( -7 3 2 6 7 -5 1 -6 )

Result vector DGEMV:
( 15 199 -106 149 62 )

Result vector naive:
( 15 199 -106 149 62 )

Adding to previous result with beta=2:

Result vector DGEMV:
( 45 597 -318 447 186 )

Result vector naive:
( 45 597 -318 447 186 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/edge_selectors.c0000644000175100001710000001036000000000000025126 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void check(igraph_t *graph, igraph_es_t *es) {
    igraph_eit_t eit;
    igraph_integer_t edge;
    IGRAPH_ASSERT(igraph_eit_create(graph, *es, &eit) == IGRAPH_SUCCESS);
    for (; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) {
        edge = IGRAPH_EIT_GET(eit);
        printf("%" IGRAPH_PRId " %" IGRAPH_PRId "\n", IGRAPH_FROM(graph, edge), IGRAPH_TO(graph, edge));
    }
    igraph_eit_destroy(&eit);
}

int main() {
    igraph_t g, g_no_vertices, g_no_edges;
    igraph_es_t es;
    igraph_vector_t v, check_as_vector;
    igraph_eit_t eit;

    igraph_small(&g, 5, IGRAPH_DIRECTED, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, -1);
    igraph_small(&g_no_vertices, 0, IGRAPH_UNDIRECTED, -1);
    igraph_small(&g_no_edges, 5, IGRAPH_UNDIRECTED, -1);

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking es_vector:\n");
    igraph_vector_init_int(&v, 3, 2, 3, 4);
    IGRAPH_ASSERT(igraph_es_vector(&es, &v) == IGRAPH_SUCCESS);
    check(&g, &es);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_edges, es, &eit) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_vertices, es, &eit) == IGRAPH_EINVAL);
    igraph_vector_destroy(&v);

    printf("es_vector with negative entry should fail.\n");
    igraph_vector_init_int(&v, 3, -2, 3, 4);
    IGRAPH_ASSERT(igraph_es_vector(&es, &v) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_eit_create(&g, es, &eit) == IGRAPH_EINVAL);
    igraph_vector_destroy(&v);

    printf("Fromto not implemented.\n");
    IGRAPH_ASSERT(igraph_es_fromto(&es, igraph_vss_all(), igraph_vss_all()) == IGRAPH_UNIMPLEMENTED);

    printf("Checking es_seq:\n");
    IGRAPH_ASSERT(igraph_es_seq(&es, 2, 4) == IGRAPH_SUCCESS);
    check(&g, &es);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_edges, es, &eit) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_vertices, es, &eit) == IGRAPH_EINVAL);

    printf("Checking eit_as_vector using seq:\n");
    IGRAPH_ASSERT(igraph_eit_create(&g, es, &eit) == IGRAPH_SUCCESS);
    igraph_vector_init_int(&check_as_vector, 0);
    igraph_eit_as_vector(&eit, &check_as_vector);
    igraph_vector_print(&check_as_vector);
    igraph_vector_destroy(&check_as_vector);

    printf("Checking ess_seq using es_seq parameters:\n");
    es = igraph_ess_seq(2, 4);
    check(&g, &es);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_edges, es, &eit) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_vertices, es, &eit) == IGRAPH_EINVAL);

    printf("Checking es_path:\n");
    igraph_vector_init_int(&v, 3, 4, 3, 2);
    IGRAPH_ASSERT(igraph_es_path(&es, &v, /*directed*/0) == IGRAPH_SUCCESS);
    check(&g, &es);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_vertices, es, &eit) == IGRAPH_EINVVID);
    IGRAPH_ASSERT(igraph_eit_create(&g_no_edges, es, &eit) == IGRAPH_EINVAL);
    igraph_es_destroy(&es);

    IGRAPH_ASSERT(igraph_es_path(&es, &v, /*directed*/1) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_eit_create(&g, es, &eit) == IGRAPH_EINVAL);
    igraph_vector_destroy(&v);
    igraph_es_destroy(&es);

    printf("es_path with negative entry should fail.\n");
    igraph_vector_init_int(&v, 3, -4, 3, 2);
    IGRAPH_ASSERT(igraph_es_path(&es, &v, /*directed*/0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_eit_create(&g, es, &eit) == IGRAPH_EINVVID);

    printf("Checking es_type.\n");
    IGRAPH_ASSERT(igraph_es_type(&es) == IGRAPH_ES_PATH);
    igraph_es_destroy(&es);
    igraph_vector_destroy(&v);

    igraph_destroy(&g);
    igraph_destroy(&g_no_vertices);
    igraph_destroy(&g_no_edges);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/edge_selectors.out0000644000175100001710000000045100000000000025513 0ustar00runnerdocker00000000000000Checking es_vector:
1 1
1 3
2 0
es_vector with negative entry should fail.
Fromto not implemented.
Checking es_seq:
1 1
1 3
Checking eit_as_vector using seq:
2 3
Checking ess_seq using es_seq parameters:
1 1
1 3
Checking es_path:
3 4
2 3
es_path with negative entry should fail.
Checking es_type.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/efficiency.c0000644000175100001710000001106000000000000024241 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int test_graph(const char* name, const igraph_t* graph, const igraph_real_t* weights_array) {
    igraph_real_t eff;
    igraph_vector_t eff_vec;
    igraph_vector_t weights;

    printf("###### Testing graph: %s ######\n\n", name);

    igraph_vector_init(&eff_vec, 0);

    if (weights_array) {
        printf("UNWEIGHTED CASE:\n\n");
    }

    igraph_global_efficiency(graph, &eff, NULL, 0);
    printf("Global efficiency, undirected: %f\n", eff);

    igraph_global_efficiency(graph, &eff, NULL, 1);
    printf("Global efficiency, directed: %f\n", eff);

    igraph_average_local_efficiency(graph, &eff, NULL, 0, IGRAPH_ALL);
    printf("Average local efficiency, undirected: %f\n", eff);

    igraph_average_local_efficiency(graph, &eff, NULL, 1, IGRAPH_ALL);
    printf("Average local efficiency, directed, all neighbors: %f\n", eff);

    igraph_average_local_efficiency(graph, &eff, NULL, 1, IGRAPH_IN);
    printf("Average local efficiency, directed, in-neighbors: %f\n", eff);

    igraph_average_local_efficiency(graph, &eff, NULL, 1, IGRAPH_OUT);
    printf("Average local efficiency, directed, out-neighbors: %f\n", eff);

    printf("\nLocal efficiency, undirected:\n");
    igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), NULL, 0, IGRAPH_ALL);
    print_vector(&eff_vec);

    printf("\nLocal efficiency, directed, all neighbors:\n");
    igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), NULL, 1, IGRAPH_ALL);
    print_vector(&eff_vec);

    printf("\nLocal efficiency, directed, in-neighbors:\n");
    igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), NULL, 1, IGRAPH_IN);
    print_vector(&eff_vec);

    printf("\nLocal efficiency, directed, out-neighbors:\n");
    igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), NULL, 1, IGRAPH_OUT);
    print_vector(&eff_vec);

    if (weights_array) {
        igraph_vector_view(&weights, weights_array, igraph_ecount(graph));
        printf("\nWEIGHTED CASE:\n\n");

        igraph_global_efficiency(graph, &eff, &weights, 0);
        printf("Global efficiency, undirected: %f\n", eff);

        igraph_global_efficiency(graph, &eff, &weights, 1);
        printf("Global efficiency, directed: %f\n", eff);

        igraph_average_local_efficiency(graph, &eff, &weights, 0, IGRAPH_ALL);
        printf("Average local efficiency, undirected: %f\n", eff);

        igraph_average_local_efficiency(graph, &eff, &weights, 1, IGRAPH_ALL);
        printf("Average local efficiency, directed, all neighbors: %f\n", eff);

        igraph_average_local_efficiency(graph, &eff, &weights, 1, IGRAPH_IN);
        printf("Average local efficiency, directed, in-neighbors: %f\n", eff);

        igraph_average_local_efficiency(graph, &eff, &weights, 1, IGRAPH_OUT);
        printf("Average local efficiency, directed, out-neighbors: %f\n", eff);

        printf("\nLocal efficiency, undirected:\n");
        igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), &weights, 0, IGRAPH_ALL);
        print_vector(&eff_vec);

        printf("\nLocal efficiency, directed, all neighbors:\n");
        igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), &weights, 1, IGRAPH_ALL);
        print_vector(&eff_vec);

        printf("\nLocal efficiency, directed, in-neighbors:\n");
        igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), &weights, 1, IGRAPH_IN);
        print_vector(&eff_vec);

        printf("\nLocal efficiency, directed, out-neighbors:\n");
        igraph_local_efficiency(graph, &eff_vec, igraph_vss_all(), &weights, 1, IGRAPH_OUT);
        print_vector(&eff_vec);
    }

    printf("\n\n");

    igraph_vector_destroy(&eff_vec);

    return 0;
}

int test_ring() {
    int result;
    igraph_t graph;
    const igraph_real_t weights_array[] = {1, 1, 1, 1};

    igraph_ring(&graph, 4, IGRAPH_DIRECTED, /* mutual = */ 0, /* circular = */ 1);
    result = test_graph("Ring graph", &graph, weights_array);
    igraph_destroy(&graph);

    return result;
}

int test_small_graph() {
    int result;
    igraph_t graph;
    const igraph_real_t weights_array[] = {4, 4, 4, 3, 1, 5, 1, 2, 4, 5, 3, 5, 5, 4, 1, 1, 5, 4, 1, 1, 2, 1, 3, 5};

    igraph_small(&graph, 13, /* directed= */ 1,
                 0,8, 1,3, 1,4, 1,5, 1,8, 1,10, 2,0, 2,1, 2,4, 3,5, 4,2, 4,7,
                 4,9, 5,3, 5,10, 6,7, 8,2, 8,3, 8,4, 8,9, 9,3, 9,4, 11,9, 11,3,
                 -1);
    result = test_graph("Small test graph", &graph, weights_array);
    igraph_destroy(&graph);

    return result;
}

int main() {
    int retval;

    RUN_TEST(test_ring);
    RUN_TEST(test_small_graph);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/efficiency.out0000644000175100001710000000532000000000000024630 0ustar00runnerdocker00000000000000###### Testing graph: Ring graph ######

UNWEIGHTED CASE:

Global efficiency, undirected: 0.833333
Global efficiency, directed: 0.611111
Average local efficiency, undirected: 0.500000
Average local efficiency, directed, all neighbors: 0.250000
Average local efficiency, directed, in-neighbors: 0.000000
Average local efficiency, directed, out-neighbors: 0.000000

Local efficiency, undirected:
( 0.5 0.5 0.5 0.5 )

Local efficiency, directed, all neighbors:
( 0.25 0.25 0.25 0.25 )

Local efficiency, directed, in-neighbors:
( 0 0 0 0 )

Local efficiency, directed, out-neighbors:
( 0 0 0 0 )

WEIGHTED CASE:

Global efficiency, undirected: 0.833333
Global efficiency, directed: 0.611111
Average local efficiency, undirected: 0.500000
Average local efficiency, directed, all neighbors: 0.250000
Average local efficiency, directed, in-neighbors: 0.000000
Average local efficiency, directed, out-neighbors: 0.000000

Local efficiency, undirected:
( 0.5 0.5 0.5 0.5 )

Local efficiency, directed, all neighbors:
( 0.25 0.25 0.25 0.25 )

Local efficiency, directed, in-neighbors:
( 0 0 0 0 )

Local efficiency, directed, out-neighbors:
( 0 0 0 0 )


###### Testing graph: Small test graph ######

UNWEIGHTED CASE:

Global efficiency, undirected: 0.509615
Global efficiency, directed: 0.274786
Average local efficiency, undirected: 0.605769
Average local efficiency, directed, all neighbors: 0.329936
Average local efficiency, directed, in-neighbors: 0.212115
Average local efficiency, directed, out-neighbors: 0.149466

Local efficiency, undirected:
( 1 0.633333 0.833333 0.641667 0.5 0.833333 0 0 0.711111 0.722222 1 1 0 )

Local efficiency, directed, all neighbors:
( 0.75 0.401111 0.375 0.340833 0.316667 0.333333 0 0 0.466667 0.305556 0.5 0.5 0 )

Local efficiency, directed, in-neighbors:
( 0 0 0.5 0.340833 0.527778 0.5 0 0 0.166667 0.222222 0.5 0 0 )

Local efficiency, directed, out-neighbors:
( 0 0.3875 0.25 0 0.0555556 0 0 0 0.583333 0.166667 0 0.5 0 )

WEIGHTED CASE:

Global efficiency, undirected: 0.247686
Global efficiency, directed: 0.125356
Average local efficiency, undirected: 0.281019
Average local efficiency, directed, all neighbors: 0.150368
Average local efficiency, directed, in-neighbors: 0.122897
Average local efficiency, directed, out-neighbors: 0.068520

Local efficiency, undirected:
( 0.333333 0.306219 0.525 0.419167 0.358333 0.187037 0 0 0.380635 0.310185 0.333333 0.5 0 )

Local efficiency, directed, all neighbors:
( 0.291667 0.16403 0.245833 0.207976 0.204643 0.075 0 0 0.204987 0.143981 0.166667 0.25 0 )

Local efficiency, directed, in-neighbors:
( 0 0 0.5 0.207976 0.341071 0.125 0 0 0.0625 0.194444 0.166667 0 0 )

Local efficiency, directed, out-neighbors:
( 0 0.180711 0.116667 0 0.0416667 0 0 0 0.246164 0.0555556 0 0.25 0 )


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/erdos_renyi_game.c0000644000175100001710000002146200000000000025457 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_bool_t simple;

    /* Ensure that the test is deterministic */
    igraph_rng_seed(igraph_rng_default(), 137);

    /* G(n,p) */

    /* Empty graph */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.0,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.0,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    /* Singleton with loop */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 1, 1.0,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 1);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(! simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 1, 1.0,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 1);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(! simple);
    igraph_destroy(&g);

    /* Complete graph */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 1.0,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9 / 2);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 1.0,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 1.0,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 11 / 2);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(! simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 1.0,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 10);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(! simple);
    igraph_destroy(&g);

    /* Random graph */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.5,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.5,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.5,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 10, 0.5,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_destroy(&g);

    /* Create a couple of large graphs too */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100000, 2.0 / 100000,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100000, 2.0 / 100000,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100000, 2.0 / 100000,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100000, 2.0 / 100000,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    igraph_destroy(&g);


    /* --------------------------------------------------------------------- */
    /* G(n,m) */

    /* singleton with loop */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 1, 1,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);

    IGRAPH_ASSERT(igraph_vcount(&g) == 1);
    IGRAPH_ASSERT(igraph_ecount(&g) == 1);
    IGRAPH_ASSERT(! igraph_is_directed(&g));

    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 1, 1,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);

    IGRAPH_ASSERT(igraph_vcount(&g) == 1);
    IGRAPH_ASSERT(igraph_ecount(&g) == 1);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_destroy(&g);


    /* directed with loops */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 10, 10 * 10 - 1,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 10 - 1);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_simplify(&g, /*multiple=*/0, /*loops=*/1, /*edge_comb=*/ NULL);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9 || igraph_ecount(&g) == 10 * 9 - 1);

    igraph_destroy(&g);

    /* directed without loops */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 10, 10 * 9 - 1,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9 - 1);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    /* undirected with loops */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 10, 10 * 11 / 2 - 1,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 11 / 2 - 1);
    IGRAPH_ASSERT(! igraph_is_directed(&g));

    igraph_simplify(&g, /*multiple=*/0, /*loops=*/1, /*edge_comb=*/ NULL);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9 / 2 || igraph_ecount(&g) == 10 * 9 / 2 - 1);

    igraph_destroy(&g);

    /* undirected without loops */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 10, 10 * 9 / 2 - 1,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10 * 9 / 2 - 1);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);


    /* Create a couple of large graphs too */
    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 100000, 2.0 * 100000,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    IGRAPH_ASSERT(igraph_ecount(&g) == 200000);
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 100000, 2.0 * 100000,
                            IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    igraph_is_simple(&g, &simple); IGRAPH_ASSERT(simple);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    IGRAPH_ASSERT(igraph_ecount(&g) == 200000);
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 100000, 2.0 * 100000,
                            IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    IGRAPH_ASSERT(igraph_ecount(&g) == 200000);
    igraph_simplify(&g, 0, 1, /*edge_comb=*/ 0);  /* only remove loops */
    igraph_destroy(&g);

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNM, 100000, 2.0 * 100000,
                            IGRAPH_DIRECTED, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100000);
    IGRAPH_ASSERT(igraph_ecount(&g) == 200000);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/error_macros.c0000644000175100001710000000366500000000000024646 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int cause_error() {
    IGRAPH_ERRORF("%d %f %ld %c", IGRAPH_EINVAL, 1, 1.0, 1, 'a');
    return IGRAPH_SUCCESS;
}

int cause_warning() {
    IGRAPH_WARNINGF("%d %f %ld %c", 1, 1.0, 1, 'a');
    return IGRAPH_SUCCESS;
}

int cause_fatal() {
    IGRAPH_FATALF("%d %f %ld %c", 1, 1.0, 1, 'a');
}

void error_handler(const char *reason, const char *file, int line, int igraph_errno) {
    printf("Error. Reason: %s\nErrno: %d\n", reason, igraph_errno);
}

void warning_handler(const char *reason, const char *file, int line, int igraph_errno) {
    printf("Warning. Reason: %s\nErrno: %d\n", reason, igraph_errno);
}

void fatal_handler(const char *reason, const char *file, int line) {
    printf("Fatal. Reason: %s\n", reason);
    exit(0);
}

int main() {
    igraph_set_error_handler(&error_handler);
    igraph_set_warning_handler(&warning_handler);
    igraph_set_fatal_handler(&fatal_handler);

    IGRAPH_ASSERT(cause_error() == IGRAPH_EINVAL);
    IGRAPH_ASSERT(cause_warning() == IGRAPH_SUCCESS);
    cause_fatal();

    /* The igraph_fatal() call must not return, so the following lines should not run. */

    printf("This should not be printed.");

    return 1;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/error_macros.out0000644000175100001710000000015700000000000025224 0ustar00runnerdocker00000000000000Error. Reason: 1 1.000000 1 a
Errno: 4
Warning. Reason: 1 1.000000 1 a
Errno: -1
Fatal. Reason: 1 1.000000 1 a
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/fatal_handler.c0000644000175100001710000000103600000000000024723 0ustar00runnerdocker00000000000000
#include 
#include 

igraph_fatal_handler_t hanlder;

void handler(const char *reason, const char *file, int line) {
    printf("Reason: %s\nFile: %s\nLine: %d\n", reason, file, line);
    exit(0); /* We use exit(0) instead of abort() to allow the test to succeed. */
}

int main() {
    igraph_set_fatal_handler(&handler);

    igraph_fatal("REASON", "FILENAME", 123);

    /* The igraph_fatal() call must not return, so the following lines should not run. */

    printf("This should not be printed.");

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/fatal_handler.out0000644000175100001710000000005000000000000025303 0ustar00runnerdocker00000000000000Reason: REASON
File: FILENAME
Line: 123
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/full.c0000644000175100001710000000407500000000000023107 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_integer_t n_vertices = 10;

    printf("Null graph\n");
    igraph_full(&g, 0, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Singleton graph, no loops\n");
    igraph_full(&g, 1, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Singleton graph, loops\n");
    igraph_full(&g, 1, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Undirected, no loops\n");
    igraph_full(&g, n_vertices, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Directed, no loops\n");
    igraph_full(&g, n_vertices, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Undirected, with loops\n");
    igraph_full(&g, n_vertices, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Directed, with loops\n");
    igraph_full(&g, n_vertices, IGRAPH_DIRECTED, IGRAPH_LOOPS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/full.out0000644000175100001710000000304100000000000023464 0ustar00runnerdocker00000000000000Null graph
directed: false
vcount: 0
edges: {
}
Singleton graph, no loops
directed: false
vcount: 1
edges: {
}
Singleton graph, loops
directed: false
vcount: 1
edges: {
0 0
}
Undirected, no loops
directed: false
vcount: 10
edges: {
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 4
3 5
3 6
3 7
3 8
3 9
4 5
4 6
4 7
4 8
4 9
5 6
5 7
5 8
5 9
6 7
6 8
6 9
7 8
7 9
8 9
}
Directed, no loops
directed: true
vcount: 10
edges: {
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 0
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 0
2 1
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 0
3 1
3 2
3 4
3 5
3 6
3 7
3 8
3 9
4 0
4 1
4 2
4 3
4 5
4 6
4 7
4 8
4 9
5 0
5 1
5 2
5 3
5 4
5 6
5 7
5 8
5 9
6 0
6 1
6 2
6 3
6 4
6 5
6 7
6 8
6 9
7 0
7 1
7 2
7 3
7 4
7 5
7 6
7 8
7 9
8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
8 9
9 0
9 1
9 2
9 3
9 4
9 5
9 6
9 7
9 8
}
Undirected, with loops
directed: false
vcount: 10
edges: {
0 0
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 3
3 4
3 5
3 6
3 7
3 8
3 9
4 4
4 5
4 6
4 7
4 8
4 9
5 5
5 6
5 7
5 8
5 9
6 6
6 7
6 8
6 9
7 7
7 8
7 9
8 8
8 9
9 9
}
Directed, with loops
directed: true
vcount: 10
edges: {
0 0
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 0
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 0
2 1
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 0
3 1
3 2
3 3
3 4
3 5
3 6
3 7
3 8
3 9
4 0
4 1
4 2
4 3
4 4
4 5
4 6
4 7
4 8
4 9
5 0
5 1
5 2
5 3
5 4
5 5
5 6
5 7
5 8
5 9
6 0
6 1
6 2
6 3
6 4
6 5
6 6
6 7
6 8
6 9
7 0
7 1
7 2
7 3
7 4
7 5
7 6
7 7
7 8
7 9
8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
8 8
8 9
9 0
9 1
9 2
9 3
9 4
9 5
9 6
9 7
9 8
9 9
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/global_transitivity.c0000644000175100001710000000642400000000000026236 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_real_t global, global2, global3;

    /* Small graphs */

    printf("Null graph: ");
    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nSingleton graph: ");
    igraph_empty(&g, 1, IGRAPH_UNDIRECTED);
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nTwo connected vertices: ");
    igraph_small(&g, 2, IGRAPH_UNDIRECTED, 0,1, -1);
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nTriangle: ");
    igraph_full(&g, 3, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nTwo-star: ");
    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0,2, 0,1, -1);
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nZachary karate club: ");
    igraph_famous(&g, "Zachary");
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%g");
    printf("\n");
    igraph_destroy(&g);

    printf("\nDirected and multigraphs:\n");

    igraph_small(&g, 20, IGRAPH_DIRECTED,
                 15, 12, 12, 10, 15, 0, 11, 10, 2, 8, 8, 6, 13, 17, 10, 10, 17, 2, 14,
                 0, 16, 13, 14, 14, 0, 5, 6, 4, 0, 9, 0, 6, 10, 9, 16, 4, 14, 5, 17,
                 15, 14, 9, 17, 17, 1, 4, 10, 16, 7, 0, 11, 12, 6, 13, 2, 17, 4, 0, 0,
                 14, 4, 0, 6, 16, 16, 14, 13, 13, 12, 11, 3, 11, 11, 3, 6, 7, 4, 14,
                 10, 8, 13, 7, 14, 2, 5, 2, 0, 14, 3, 15, 5, 5, 7, 2, 14, 15, 5, 10,
                 10, 16, 7, 9, 14, 0, 15, 7, 13, 1, 15, 1, 4, 5, 4, 6, 16, 13, 6, 17,
                 8, 6, 9, 3, 8, 6, 6, 14, 11, 14, 6, 10, 10, 5, 1, 0, 16, 17, 9, 1, 5,
                 0, 5, 15, 8, 0, 0, 8, 5, 3, 9, 4, 13, 12, 11, 0, 11, 0, 10, 6, 4, 13,
                 8, 9, 11, 11, 3, 16, 1, 2, 16, 0, 9, 8, 3, 8, 8, 7, 12, 10, 9, 3, 13,
                 5, 3, 9, 6, 2, 11, 10, 1, 16, 0, 2, 10, 17, 16, 8, 11, 5, 13, 0, 19, 19,
                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                 -1);

    printf("\nDirected multi: ");
    igraph_transitivity_undirected(&g, &global, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global, "%.10g");
    printf("\n");

    printf("Undirected multi: ");
    igraph_to_undirected(&g, IGRAPH_TO_UNDIRECTED_COLLAPSE, NULL);
    igraph_transitivity_undirected(&g, &global2, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global2, "%.10g");
    printf("\n");

    printf("Simple: ");
    igraph_simplify(&g, 1, 1, NULL);
    igraph_transitivity_undirected(&g, &global3, IGRAPH_TRANSITIVITY_NAN);
    print_real(stdout, global3, "%.10g");
    printf("\n");

    IGRAPH_ASSERT(global == global2);
    IGRAPH_ASSERT(global == global3);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/global_transitivity.out0000644000175100001710000000035100000000000026614 0ustar00runnerdocker00000000000000Null graph: NaN

Singleton graph: NaN

Two connected vertices: NaN

Triangle: 1

Two-star: 0

Zachary karate club: 0.255682

Directed and multigraphs:

Directed multi: 0.4357541899
Undirected multi: 0.4357541899
Simple: 0.4357541899
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/glpk_error.c0000644000175100001710000000437600000000000024317 0ustar00runnerdocker00000000000000
#include 

#include 

#include "test_utilities.inc"

static clock_t start;

/* Wait for at least a second before attempting interruption */
int interruption_handler(void *data) {
    if ( ((double) (clock() - start)) / CLOCKS_PER_SEC > 1.0 ) {
        IGRAPH_FINALLY_FREE();
        return IGRAPH_INTERRUPTED;
    } else {
        return IGRAPH_SUCCESS;
    }
}

int main() {
    igraph_t graph;
    igraph_vector_t res;
    igraph_error_handler_t *ehandler;

    igraph_vector_init(&res, 0);

    /* Skip test when igraph does not have GLPK support. */
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, -1);
    ehandler = igraph_set_error_handler(igraph_error_handler_ignore);
    if (igraph_feedback_arc_set(&graph, &res, NULL, IGRAPH_FAS_EXACT_IP) == IGRAPH_UNIMPLEMENTED) {
        igraph_destroy(&graph);
        igraph_vector_destroy(&res);
        return 77;
    }
    igraph_set_error_handler(ehandler);
    igraph_destroy(&graph);


    /* Current versions of GLPK will error if more than 100 million rows (MAX_M) are added.
       The graph size of 700 is chosen to just exceed this size. If future GLPK
       versions relax this restriction, the test will need to be updated accordinly. */
    igraph_full(&graph, 700, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);

    ehandler = igraph_set_error_handler(igraph_error_handler_printignore);
    IGRAPH_ASSERT(igraph_feedback_arc_set(&graph, &res, NULL, IGRAPH_FAS_EXACT_IP) == IGRAPH_EGLP);
    igraph_set_error_handler(ehandler);

    igraph_destroy(&graph);
    igraph_vector_destroy(&res);

    VERIFY_FINALLY_STACK();

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&res, 0);
    igraph_erdos_renyi_game(
                      &graph, IGRAPH_ERDOS_RENYI_GNM,
                      100, 200,
                      IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);

    igraph_set_interruption_handler(interruption_handler);
    ehandler = igraph_set_error_handler(igraph_error_handler_printignore);
    start = clock();
    IGRAPH_ASSERT(igraph_feedback_arc_set(&graph, &res, NULL, IGRAPH_FAS_EXACT_IP) == IGRAPH_INTERRUPTED);
    igraph_set_error_handler(ehandler);
    igraph_set_interruption_handler(NULL);

    igraph_destroy(&graph);

    igraph_vector_destroy(&res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/harmonic_centrality.c0000644000175100001710000001141100000000000026173 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_t res;
    igraph_vector_t weights;

    igraph_vector_init(&res, 0);

    /* Path graph */
    igraph_ring(&graph, 7, IGRAPH_DIRECTED, 0, /* circular */ 0);

    printf("Unweighted undirected:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);
    printf("Unweighted directed:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_OUT, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);

    printf("Unweighted undirected, cutoff=0:\n");
    igraph_harmonic_centrality_cutoff(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1, 0);
    print_vector(&res);
    printf("Unweighted undirected, cutoff=1:\n");
    igraph_harmonic_centrality_cutoff(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1, 1);
    print_vector(&res);

    igraph_vector_init(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1.0);

    printf("Unit-weighted undirected:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    printf("Unit-weighted directed:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_OUT, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);

    printf("Unit-weighted undirected, cutoff=0:\n");
    igraph_harmonic_centrality_cutoff(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1, 0);
    print_vector(&res);
    printf("Unit-weighted undirected, cutoff=1:\n");
    igraph_harmonic_centrality_cutoff(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1, 1);
    print_vector(&res);

    igraph_vector_destroy(&weights);

    igraph_vector_init_seq(&weights, 1, igraph_ecount(&graph));
    printf("Weighted undirected:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    printf("Weighted directed:\n");
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_OUT, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    igraph_vector_destroy(&weights);

    igraph_destroy(&graph);

    /* Graphs with no edges */

    igraph_vector_init(&weights, 0);

    /* Null graph */

    printf("Null graph:\n");
    igraph_empty(&graph, 0, IGRAPH_UNDIRECTED);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    igraph_destroy(&graph);

    /* Singleton graph */

    printf("Singleton graph:\n");
    igraph_empty(&graph, 1, IGRAPH_UNDIRECTED);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    igraph_destroy(&graph);

    /* Empty graph with two vertices */

    printf("Empty graph with two vertices:\n");
    igraph_empty(&graph, 2, IGRAPH_UNDIRECTED);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    igraph_destroy(&graph);

    igraph_vector_destroy(&weights);

    /* Graph with multiple connected components and isolated vertices */

    printf("Multiple components, unweighted:\n");
    igraph_small(&graph, 20, IGRAPH_UNDIRECTED,
                 1, 2, 2, 3, 1, 3, 4, 5, 5, 6, 6, 7, 5, 8, 8, 9, 6, 10, 10, 11, 7, 11,
                 9, 13, 9, 14, 9, 15, 9, 16, 13, 14, 13, 15, 13, 16, 14, 15, 14, 16,
                 15, 16, 17, 18, 4, 19, 4, 20,
                 -1);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ NULL, /* normalized= */ 1);
    print_vector(&res);

    printf("Multiple components, constant weight vector:\n");
    igraph_vector_init(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1.0 / 7);
    igraph_harmonic_centrality(&graph, &res, igraph_vss_all(), IGRAPH_ALL, /* weights= */ &weights, /* normalized= */ 1);
    print_vector(&res);
    igraph_vector_destroy(&weights);

    igraph_destroy(&graph);

    igraph_vector_destroy(&res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/harmonic_centrality.out0000644000175100001710000000234700000000000026570 0ustar00runnerdocker00000000000000Unweighted undirected:
( 0.408333 0.547222 0.597222 0.611111 0.597222 0.547222 0.408333 )
Unweighted directed:
( 0.408333 0.380556 0.347222 0.305556 0.25 0.166667 0 )
Unweighted undirected, cutoff=0:
( 0 0 0 0 0 0 0 )
Unweighted undirected, cutoff=1:
( 0.166667 0.333333 0.333333 0.333333 0.333333 0.333333 0.166667 )
Unit-weighted undirected:
( 0.408333 0.547222 0.597222 0.611111 0.597222 0.547222 0.408333 )
Unit-weighted directed:
( 0.408333 0.380556 0.347222 0.305556 0.25 0.166667 0 )
Unit-weighted undirected, cutoff=0:
( 0 0 0 0 0 0 0 )
Unit-weighted undirected, cutoff=1:
( 0.166667 0.333333 0.333333 0.333333 0.333333 0.333333 0.166667 )
Weighted undirected:
( 0.285714 0.32209 0.241402 0.187963 0.149146 0.116534 0.0795695 )
Weighted directed:
( 0.285714 0.155423 0.102513 0.0712963 0.0484848 0.0277778 0 )
Null graph:
( )
( )
Singleton graph:
( 0 )
( 0 )
Empty graph with two vertices:
( 0 0 )
( 0 0 )
Multiple components, unweighted:
( 0 0.1 0.1 0.1 0.3125 0.358333 0.325 0.260833 0.329167 0.368333 0.260833 0.23 0 0.315 0.315 0.315 0.315 0.05 0.05 0.220833 0.220833 )
Multiple components, constant weight vector:
( 0 0.7 0.7 0.7 2.1875 2.50833 2.275 1.82583 2.30417 2.57833 1.82583 1.61 0 2.205 2.205 2.205 2.205 0.35 0.35 1.54583 1.54583 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/hashtable.c0000644000175100001710000001052500000000000024075 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include "core/hashtable.h"

#include "test_utilities.inc"

int main() {

    igraph_hashtable_t ht;
    char *str;
    const igraph_strvector_t *keys;
    long int i;

    /* init and destroy */
    igraph_hashtable_init(&ht);
    igraph_hashtable_destroy(&ht);

    /* init, add some elements and destroy */
    igraph_hashtable_init(&ht);
    igraph_hashtable_addset(&ht, "color", "green", "red");
    igraph_hashtable_addset(&ht, "size", "", "4");
    igraph_hashtable_addset(&ht, "color", "", "grey");
    igraph_hashtable_addset(&ht, "shape", "", "circle");
    igraph_hashtable_addset(&ht, "shape", "", "diamond");
    igraph_hashtable_destroy(&ht);

    /* reset */
    igraph_hashtable_init(&ht);
    igraph_hashtable_addset(&ht, "color", "green", "red");
    igraph_hashtable_addset(&ht, "size", "", "4");
    igraph_hashtable_addset(&ht, "color", "", "grey");
    igraph_hashtable_addset(&ht, "shape", "", "circle");
    igraph_hashtable_addset(&ht, "shape", "", "diamond");
    igraph_hashtable_reset(&ht);
    igraph_hashtable_addset(&ht, "color", "green", "red");
    igraph_hashtable_addset(&ht, "size", "", "4");
    igraph_hashtable_addset(&ht, "color", "", "grey");
    igraph_hashtable_addset(&ht, "shape", "", "circle");
    igraph_hashtable_addset(&ht, "shape", "", "diamond");
    igraph_hashtable_destroy(&ht);

    /* Check semantics */
    igraph_hashtable_init(&ht);
    igraph_hashtable_addset(&ht, "color", "green", "red");
    igraph_hashtable_addset(&ht, "size", "", "4");
    igraph_hashtable_addset(&ht, "color", "", "grey");
    igraph_hashtable_addset(&ht, "shape", "", "circle");
    igraph_hashtable_addset(&ht, "shape", "", "diamond");

    igraph_hashtable_get(&ht, "color", &str);
    printf("color: %s\n", str);
    igraph_hashtable_get(&ht, "size", &str);
    printf("size: %s\n", str);
    igraph_hashtable_get(&ht, "shape", &str);
    printf("shape: %s\n", str);

    igraph_hashtable_reset(&ht);

    igraph_hashtable_get(&ht, "color", &str);
    printf("color: %s\n", str);
    igraph_hashtable_get(&ht, "size", &str);
    printf("size: %s\n", str);
    igraph_hashtable_get(&ht, "shape", &str);
    printf("shape: %s\n", str);

    igraph_hashtable_getkeys(&ht, &keys);
    for (i = 0; i < igraph_strvector_size(keys); i++) {
        igraph_strvector_get(keys, i, &str);
        printf("%s ", str);
    }
    printf("\n");

    igraph_hashtable_destroy(&ht);

    /* addset2 */
    igraph_hashtable_init(&ht);
    igraph_hashtable_addset2(&ht, "color", "green", "redddd", 3);
    igraph_hashtable_addset2(&ht, "size", "", "4111", 1);
    igraph_hashtable_addset2(&ht, "color", "", "greysdsdf", 4);
    igraph_hashtable_addset2(&ht, "shape", "", "circle", 6);
    igraph_hashtable_addset(&ht, "shape", "", "diamond");

    igraph_hashtable_get(&ht, "color", &str);
    printf("color: %s\n", str);
    igraph_hashtable_get(&ht, "size", &str);
    printf("size: %s\n", str);
    igraph_hashtable_get(&ht, "shape", &str);
    printf("shape: %s\n", str);

    igraph_hashtable_reset(&ht);

    igraph_hashtable_get(&ht, "color", &str);
    printf("color: %s\n", str);
    igraph_hashtable_get(&ht, "size", &str);
    printf("size: %s\n", str);
    igraph_hashtable_get(&ht, "shape", &str);
    printf("shape: %s\n", str);

    igraph_hashtable_getkeys(&ht, &keys);
    for (i = 0; i < igraph_strvector_size(keys); i++) {
        igraph_strvector_get(keys, i, &str);
        printf("%s ", str);
    }
    printf("\n");

    igraph_hashtable_destroy(&ht);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/hashtable.out0000644000175100001710000000024200000000000024455 0ustar00runnerdocker00000000000000color: grey
size: 4
shape: diamond
color: green
size: 
shape: 
color size shape 
color: grey
size: 4
shape: diamond
color: green
size: 
shape: 
color size shape 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/heap.c0000644000175100001710000001136100000000000023056 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_heap_t h_max;
    igraph_heap_min_t h_min;
    igraph_integer_t i;
    igraph_real_t list[] = {-2, -9.999, 0, 6, 235, -2, -1000, -1, 4, 2000, 6, 0.5, 1, -9, 10};
    const igraph_integer_t l_size = sizeof(list) / sizeof(igraph_real_t);

    /* max heap init & destroy*/
    printf("Create empty max heap & destroy\n");
    igraph_heap_init(&h_max, 0);
    IGRAPH_ASSERT(igraph_heap_empty(&h_max));
    igraph_heap_destroy(&h_max);
    printf("Create empty max heap but allocate size for some elements\n");
    igraph_heap_init(&h_max, 10);
    IGRAPH_ASSERT(igraph_heap_empty(&h_max));
    igraph_heap_destroy(&h_max);

    /* min heap init & destroy*/
    printf("Create empty min heap & destroy\n");
    igraph_heap_min_init(&h_min, 0);
    IGRAPH_ASSERT(igraph_heap_min_empty(&h_min));
    igraph_heap_min_destroy(&h_min);
    printf("Create empty min heap but allocate size for some elements\n");
    igraph_heap_min_init(&h_min, 10);
    IGRAPH_ASSERT(igraph_heap_min_empty(&h_min));
    igraph_heap_min_destroy(&h_min);

    /*  max heap_reserve, heap_size and heap_empty*/
    printf("Test max heap_reserve, heap_size and heap_empty\n");
    igraph_heap_init(&h_max, 5);
    IGRAPH_ASSERT(igraph_heap_empty(&h_max));
    IGRAPH_ASSERT(igraph_heap_size(&h_max) == 0);
    igraph_heap_reserve(&h_max, 10);
    IGRAPH_ASSERT(igraph_heap_empty(&h_max));
    IGRAPH_ASSERT(igraph_heap_size(&h_max) == 0);
    for (i=0; i < 15; i++){
        igraph_heap_push(&h_max,i);
    }
    IGRAPH_ASSERT(igraph_heap_size(&h_max) == 15);
    IGRAPH_ASSERT(!igraph_heap_empty(&h_max));
    igraph_heap_reserve(&h_max, 5);
    IGRAPH_ASSERT(igraph_heap_size(&h_max) == 15);
    IGRAPH_ASSERT(!igraph_heap_empty(&h_max));
    igraph_heap_destroy(&h_max);

    /*  min heap reserve, heap_size and heap_empty*/
    printf("Test min heap_reserve, heap_size and heap_empty\n");
    igraph_heap_min_init(&h_min, 5);
    IGRAPH_ASSERT(igraph_heap_min_empty(&h_min));
    IGRAPH_ASSERT(igraph_heap_min_size(&h_min) == 0);
    igraph_heap_min_reserve(&h_min, 10);
    IGRAPH_ASSERT(igraph_heap_min_empty(&h_min));
    IGRAPH_ASSERT(igraph_heap_min_size(&h_min) == 0);
    for (i=0; i < 15; i++){
        igraph_heap_min_push(&h_min, i);
    }
    IGRAPH_ASSERT(igraph_heap_min_size(&h_min) == 15);
    IGRAPH_ASSERT(!igraph_heap_min_empty(&h_min));
    igraph_heap_min_reserve(&h_min, 5);
    IGRAPH_ASSERT(igraph_heap_min_size(&h_min) == 15);
    IGRAPH_ASSERT(!igraph_heap_min_empty(&h_min));
    igraph_heap_min_destroy(&h_min);

    /* max heap init_array and delete_top */
    printf("Test max heap_init array and delete_top\n");
    igraph_heap_init_array(&h_max,list,l_size);
    while (igraph_heap_size(&h_max) > 0){
        printf("%g ", igraph_heap_delete_top(&h_max));
    }
    printf("\n");
    igraph_heap_destroy(&h_max);

    /* min heap init_array and delete_top */
    printf("Test min heap init_array and delete_top\n");
    igraph_heap_min_init_array(&h_min, list, l_size);
    while (igraph_heap_min_size(&h_min) > 0) {
        printf("%g ", igraph_heap_min_delete_top(&h_min));
    }
    printf("\n");
    igraph_heap_min_destroy(&h_min);

    /* max heap top and push */
    printf("Test max heap top and push\n");
    igraph_heap_init(&h_max, 0);
    for (i=0; i < l_size; i++){
        igraph_heap_push(&h_max, list[i]);
        printf("%g ", igraph_heap_top(&h_max));
    }
    printf("\n");
    while (igraph_heap_size(&h_max)>0){
        printf("%g ", igraph_heap_delete_top(&h_max));
    }
    printf("\n");

    /* min heap top and push */
    printf("Test min heap top and push\n");
    igraph_heap_min_init(&h_min, 0);
    for (i=0; i < l_size; i++){
        igraph_heap_min_push(&h_min, list[i]);
        printf("%g ", igraph_heap_min_top(&h_min));
    }
    printf("\n");
    while (igraph_heap_min_size(&h_min) > 0){
        printf("%g ", igraph_heap_min_delete_top(&h_min));
    }
    printf("\n");

    igraph_heap_destroy(&h_max);
    igraph_heap_min_destroy(&h_min);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/heap.out0000644000175100001710000000140400000000000023440 0ustar00runnerdocker00000000000000Create empty max heap & destroy
Create empty max heap but allocate size for some elements
Create empty min heap & destroy
Create empty min heap but allocate size for some elements
Test max heap_reserve, heap_size and heap_empty
Test min heap_reserve, heap_size and heap_empty
Test max heap_init array and delete_top
2000 235 10 6 6 4 1 0.5 0 -1 -2 -2 -9 -9.999 -1000 
Test min heap init_array and delete_top
-1000 -9.999 -9 -2 -2 -1 0 0.5 1 4 6 6 10 235 2000 
Test max heap top and push
-2 -2 0 6 235 235 235 235 235 2000 2000 2000 2000 2000 2000 
2000 235 10 6 6 4 1 0.5 0 -1 -2 -2 -9 -9.999 -1000 
Test min heap top and push
-2 -9.999 -9.999 -9.999 -9.999 -9.999 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 
-1000 -9.999 -9 -2 -2 -1 0 0.5 1 4 6 6 10 235 2000 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_adhesion.c0000644000175100001710000000253600000000000025271 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_integer_t value;
    igraph_bool_t checks = 1;

    igraph_small(&g, 7, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, 1, 6, 6, 3, -1);

    igraph_adhesion(&g, &value, checks);

    IGRAPH_ASSERT(value == 0);

    igraph_destroy(&g);

    igraph_small(&g, 7, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, 1, 6, 6, 3, -1);

    igraph_adhesion(&g, &value, checks);

    IGRAPH_ASSERT(value == 2);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_adjacency_spectral_embedding.c0000644000175100001710000000424100000000000031306 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

/*

    R
    library(igraph)
    g <- graph.tree(10, 3, mode="out")
    A <- get.adjacency(g)
    svd(A + .5 * degree(g) * diag(vcount(g)))

*/

int main() {

    igraph_t graph;
    igraph_matrix_t U, V;
    igraph_arpack_options_t options;
    igraph_vector_t cvec;

    igraph_tree(&graph, /*n=*/ 14, /*children=*/ 4, IGRAPH_TREE_OUT);

    igraph_matrix_init(&U, 0, 0);
    igraph_matrix_init(&V, 0, 0);
    igraph_arpack_options_init(&options);

    igraph_vector_init(&cvec, 0);
    igraph_degree(&graph, &cvec, igraph_vss_all(), IGRAPH_ALL,
                  IGRAPH_LOOPS);
    igraph_vector_scale(&cvec, .5);

    igraph_adjacency_spectral_embedding(&graph, 4, /*weights=*/ 0,
                                        IGRAPH_EIGEN_LA,
                                        /*scaled=*/ 0, &U, &V, /*D=*/ 0,
                                        &cvec, &options);

    /* eigenvectors are in the columns of U and V; make sure that the
     * first row contains positive values */
    print_matrix_first_row_positive(&U, "%8.4f");
    printf("--\n");
    print_matrix_first_row_positive(&V, "%8.4f");

    igraph_vector_destroy(&cvec);
    igraph_matrix_destroy(&V);
    igraph_matrix_destroy(&U);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_adjacency_spectral_embedding.out0000644000175100001710000000176300000000000031701 0ustar00runnerdocker00000000000000  0.5897   0.0000   0.7766   0.1946
  0.5678   0.7037  -0.4090  -0.0547
  0.5678  -0.7037  -0.4090  -0.0547
  0.0541   0.0000   0.2133  -0.9350
  0.0233   0.0000   0.0714   0.0576
  0.0224   0.0348  -0.0376  -0.0162
  0.0224   0.0348  -0.0376  -0.0162
  0.0224   0.0348  -0.0376  -0.0162
  0.0224   0.0348  -0.0376  -0.0162
  0.0224  -0.0348  -0.0376  -0.0162
  0.0224  -0.0348  -0.0376  -0.0162
  0.0224  -0.0348  -0.0376  -0.0162
  0.0224  -0.0348  -0.0376  -0.0162
  0.0021   0.0000   0.0196  -0.2767
--
  0.3281   0.0000   0.6513   0.2795
  0.5588   0.5468  -0.1031   0.0416
  0.5588  -0.5468  -0.1031   0.0416
  0.1791   0.0000   0.4151  -0.5316
  0.1673   0.0000   0.3406   0.1604
  0.1610   0.2241  -0.1794  -0.0451
  0.1610   0.2241  -0.1794  -0.0451
  0.1610   0.2241  -0.1794  -0.0451
  0.1610   0.2241  -0.1794  -0.0451
  0.1610  -0.2241  -0.1794  -0.0451
  0.1610  -0.2241  -0.1794  -0.0451
  0.1610  -0.2241  -0.1794  -0.0451
  0.1610  -0.2241  -0.1794  -0.0451
  0.0153   0.0000   0.0935  -0.7706
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_adjacent_triangles.c0000644000175100001710000000374600000000000027324 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t res;
    igraph_vs_t vertices;

    igraph_vector_init(&res, 0);

    igraph_small(&g, 20, IGRAPH_DIRECTED,
                 15, 12, 12, 10, 15, 0, 11, 10, 2, 8, 8, 6, 13, 17, 10, 10, 17, 2, 14,
                 0, 16, 13, 14, 14, 0, 5, 6, 4, 0, 9, 0, 6, 10, 9, 16, 4, 14, 5, 17,
                 15, 14, 9, 17, 17, 1, 4, 10, 16, 7, 0, 11, 12, 6, 13, 2, 17, 4, 0, 0,
                 14, 4, 0, 6, 16, 16, 14, 13, 13, 12, 11, 3, 11, 11, 3, 6, 7, 4, 14,
                 10, 8, 13, 7, 14, 2, 5, 2, 0, 14, 3, 15, 5, 5, 7, 2, 14, 15, 5, 10,
                 10, 16, 7, 9, 14, 0, 15, 7, 13, 1, 15, 1, 4, 5, 4, 6, 16, 13, 6, 17,
                 8, 6, 9, 3, 8, 6, 6, 14, 11, 14, 6, 10, 10, 5, 1, 0, 16, 17, 9, 1, 5,
                 0, 5, 15, 8, 0, 0, 8, 5, 3, 9, 4, 13, 12, 11, 0, 11, 0, 10, 6, 4, 13,
                 8, 9, 11, 11, 3, 16, 1, 2, 16, 0, 9, 8, 3, 8, 8, 7, 12, 10, 9, 3, 13,
                 5, 3, 9, 6, 2, 11, 10, 1, 16, 0, 2, 10, 17, 16, 8, 11, 5, 13, 0, 19, 19,
                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                 -1);

    igraph_vs_seq(&vertices, 0, igraph_vcount(&g) - 1);

    printf("\nDirected multi:\n");
    igraph_adjacent_triangles(&g, &res, igraph_vss_all());
    print_vector(&res);
    igraph_adjacent_triangles(&g, &res, vertices);
    print_vector(&res);

    printf("\nUndirected multi:\n");
    igraph_to_undirected(&g, IGRAPH_TO_UNDIRECTED_COLLAPSE, NULL);
    igraph_adjacent_triangles(&g, &res, igraph_vss_all());
    print_vector(&res);
    igraph_adjacent_triangles(&g, &res, vertices);
    print_vector(&res);

    printf("\nSimple:\n");
    igraph_simplify(&g, 1, 1, NULL);
    igraph_adjacent_triangles(&g, &res, igraph_vss_all());
    print_vector(&res);
    igraph_adjacent_triangles(&g, &res, vertices);
    print_vector(&res);

    igraph_vs_destroy(&vertices);

    igraph_destroy(&g);

    igraph_vector_destroy(&res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_adjacent_triangles.out0000644000175100001710000000057500000000000027706 0ustar00runnerdocker00000000000000
Directed multi:
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )

Undirected multi:
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )

Simple:
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )
( 37 10 12 4 18 14 24 11 15 10 8 6 1 15 17 6 20 6 0 0 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_all_st_cuts.c0000644000175100001710000003207100000000000026010 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "core/marked_queue.h"
#include "core/estack.h"

#include "flow/flow_internal.h"

#include "test_utilities.inc"

int test_all_st_cuts(const igraph_t *graph,
                     long int source,
                     long int target) {
    igraph_vector_ptr_t cuts, partition1s;
    long int n, i;

    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(graph, &cuts, &partition1s,
                       source, target);

    n = igraph_vector_ptr_size(&partition1s);
    printf("Partitions and cuts:\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("P: ");
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    return 0;
}

int main() {
    igraph_t g;
    igraph_vector_ptr_t cuts, partition1s;
    long int i, n;

    igraph_marked_queue_t S;
    igraph_estack_t T;
    long int v;
    igraph_vector_t Isv;

    /* ----------------------------------------------------------- */
    /* This is the example from the Provan-Shier paper,
       for calculating the dominator tree and finding the right pivot
       element */

    igraph_small(&g, 12, IGRAPH_DIRECTED,
                 /* a->b */ 0, 1,
                 /* b->t */ 1, 11,
                 /* c->b */ 2, 1,  /* c->d */ 2, 3,
                 /* d->e */ 3, 4,  /* d->i */ 3, 8,
                 /* e->c */ 4, 2,
                 /* f->c */ 5, 2,  /* f->e */ 5, 4,
                 /* g->d */ 6, 3,  /* g->e */ 6, 4,  /* g->f */ 6, 5,
                 /* g->j */ 6, 9,
                 /* h->g */ 7, 6,  /* h->t */ 7, 11,
                 /* i->a */ 8, 0,
                 /* j->i */ 9, 8,
                 /* s->a */ 10, 0, /* s->c */ 10, 2, /* s->h */ 10, 7,
                 -1);

    /* S={s,a} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));
    igraph_marked_queue_start_batch(&S);
    igraph_marked_queue_push(&S, 10);
    igraph_marked_queue_push(&S, 0);

    /* T={t} */
    igraph_estack_init(&T, igraph_vcount(&g), 1);
    igraph_estack_push(&T, 11);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 10, /*target=*/ 11,
                               &v, &Isv, NULL);

    /* Expected result: v=c, Isv={c,d,e,i} */
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    /* S={}, T={} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));
    igraph_estack_init(&T, igraph_vcount(&g), 3);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 0, /*target=*/ 2,
                               &v, &Isv, NULL);
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    /* S={}, T={0} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));

    igraph_estack_init(&T, igraph_vcount(&g), 3);
    igraph_estack_push(&T, 0);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 0, /*target=*/ 2,
                               &v, &Isv, NULL);
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    /* S={0}, T={} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));
    igraph_marked_queue_push(&S, 0);

    igraph_estack_init(&T, igraph_vcount(&g), 3);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 0, /*target=*/ 2,
                               &v, &Isv, NULL);
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    /* S={0}, T={1} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));
    igraph_marked_queue_push(&S, 0);

    igraph_estack_init(&T, igraph_vcount(&g), 3);
    igraph_estack_push(&T, 1);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 0, /*target=*/ 2,
                               &v, &Isv, NULL);
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    /* S={0,1}, T={} */
    igraph_marked_queue_init(&S, igraph_vcount(&g));
    igraph_marked_queue_push(&S, 0);
    igraph_marked_queue_push(&S, 1);

    igraph_estack_init(&T, igraph_vcount(&g), 3);

    igraph_vector_init(&Isv, 0);
    igraph_i_all_st_cuts_pivot(&g, &S, &T,
                               /*source=*/ 0, /*target=*/ 2,
                               &v, &Isv, NULL);
    printf("%li; ", v);
    igraph_vector_print(&Isv);

    igraph_vector_destroy(&Isv);
    igraph_estack_destroy(&T);
    igraph_marked_queue_destroy(&S);
    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 1, 1, 2,
                 -1);

    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, /*cuts=*/ 0, &partition1s,
                       /*source=*/ 0, /*target=*/ 2);

    n = igraph_vector_ptr_size(&partition1s);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
    igraph_vector_ptr_destroy(&partition1s);

    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 1, 3, 2, 4, 3, 4,
                 -1);

    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, /*cuts=*/ 0, &partition1s,
                       /*source=*/ 0, /*target=*/ 4);

    n = igraph_vector_ptr_size(&partition1s);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
    igraph_vector_ptr_destroy(&partition1s);

    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 1, 3, 2, 4, 3, 4, 1, 5, 5, 4,
                 -1);

    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, &cuts, &partition1s,
                       /*source=*/ 0, /*target=*/ 4);

    n = igraph_vector_ptr_size(&partition1s);
    printf("Partitions and cuts:\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("P: ");
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 3, IGRAPH_DIRECTED,
                 0, 2, 1, 2,
                 -1);

    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, &cuts, &partition1s,
                       /*source=*/ 1, /*target=*/ 2);

    n = igraph_vector_ptr_size(&partition1s);
    printf("Partitions and cuts:\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("P: ");
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 3, 1,
                 -1);

    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, &cuts, &partition1s,
                       /*source=*/ 0, /*target=*/ 4);

    n = igraph_vector_ptr_size(&partition1s);
    printf("Partitions and cuts:\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("P: ");
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    igraph_destroy(&g);

    /* ----------------------------------------------------------- */

    igraph_small(&g, 7, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 3, 2, 3,
                 1, 4, 1, 5, 1, 6,
                 4, 2, 5, 2, 6, 2,
                 -1);

    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, &cuts, &partition1s,
                       /*source=*/ 0, /*target=*/ 3);

    n = igraph_vector_ptr_size(&partition1s);
    printf("Partitions and cuts:\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(partition1s)[i];
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("P: ");
        igraph_vector_print(v);
        igraph_vector_destroy(v);
        igraph_free(v);
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    /* Check whether it also works if we don't provide partition1s */
    igraph_vector_ptr_init(&cuts, 0);
    igraph_vector_ptr_init(&partition1s, 0);
    igraph_all_st_cuts(&g, &cuts, /*partition1s=*/ 0,
                       /*source=*/ 0, /*target=*/ 3);

    n = igraph_vector_ptr_size(&cuts);
    printf("Cuts only (no partitions):\n");
    for (i = 0; i < n; i++) {
        igraph_vector_t *v2 = VECTOR(cuts)[i];
        printf("C: ");
        igraph_vector_print(v2);
        igraph_vector_destroy(v2);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&partition1s);
    igraph_vector_ptr_destroy(&cuts);

    igraph_destroy(&g);

    /* -----------------------------------------------------------
     * Check problematic cases in issue #1102
     * ----------------------------------------------------------- */

    igraph_small(&g, 4, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3,
                 -1);
    test_all_st_cuts(&g, 0, 2);
    igraph_destroy(&g);

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4,
                 -1);
    test_all_st_cuts(&g, 0, 2);
    test_all_st_cuts(&g, 1, 3);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_all_st_cuts.out0000644000175100001710000000156600000000000026402 0ustar00runnerdocker000000000000002; 2 3 4 8
0; 0
0; 
1; 1
1; 
1; 
0
0 1
0
0 1
0 1 3
0 1 2
0 1 2 3
Partitions and cuts:
P: 0
C: 0
P: 0 1
C: 1 2 5
P: 0 1 5
C: 1 2 6
P: 0 1 3
C: 1 4 5
P: 0 1 3 5
C: 1 4 6
P: 0 1 2
C: 2 3 5
P: 0 1 2 5
C: 2 3 6
P: 0 1 2 3
C: 3 4 5
P: 0 1 2 3 5
C: 3 4 6
Partitions and cuts:
P: 1
C: 1
Partitions and cuts:
P: 0
C: 0
P: 0 1
C: 1
P: 0 1 2
C: 2
P: 0 1 2 3
C: 3
Partitions and cuts:
P: 0
C: 0 1
P: 0 2
C: 0 3
P: 0 1
C: 1 2 4 5 6
P: 0 1 6
C: 1 2 4 5 9
P: 0 1 5
C: 1 2 4 6 8
P: 0 1 5 6
C: 1 2 4 8 9
P: 0 1 4
C: 1 2 5 6 7
P: 0 1 4 6
C: 1 2 5 7 9
P: 0 1 4 5
C: 1 2 6 7 8
P: 0 1 4 5 6
C: 1 2 7 8 9
P: 0 1 4 5 6 2
C: 2 3
Cuts only (no partitions):
C: 0 1
C: 0 3
C: 1 2 4 5 6
C: 1 2 4 5 9
C: 1 2 4 6 8
C: 1 2 4 8 9
C: 1 2 5 6 7
C: 1 2 5 7 9
C: 1 2 6 7 8
C: 1 2 7 8 9
C: 2 3
Partitions and cuts:
P: 0
C: 0
P: 0 1
C: 1
Partitions and cuts:
P: 0
C: 0
P: 0 1
C: 1
Partitions and cuts:
P: 1
C: 1
P: 1 2
C: 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_almost_equals.c0000644000175100001710000001546400000000000026354 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "core/math.h"

#include "test_utilities.inc"

/* This file is ported from Java; the original source is here:
   https://floating-point-gui.de/errors/NearlyEqualsTest.java */

const double EPS = 0.00001;

void assert_almost_equal_with_eps(double a, double b, double eps, int line) {
    if (!igraph_almost_equals(a, b, eps)) {
        igraph_fatalf("Assertion failed: %g == %g with eps = %g", IGRAPH_FILE_BASENAME, line, a, b, eps);
    }
}

void assert_not_equal_with_eps(double a, double b, double eps, int line) {
    if (igraph_almost_equals(a, b, eps)) {
        igraph_fatalf("Assertion failed: %g != %g with eps = %g", IGRAPH_FILE_BASENAME, line, a, b, eps);
    }
}

#define ASSERT_ALMOST_EQUAL_WITH_EPS(a, b, eps) assert_almost_equal_with_eps(a, b, eps, __LINE__)
#define ASSERT_ALMOST_EQUAL(a, b) assert_almost_equal_with_eps(a, b, EPS, __LINE__)
#define ASSERT_NOT_EQUAL_WITH_EPS(a, b, eps) assert_not_equal_with_eps(a, b, eps, __LINE__)
#define ASSERT_NOT_EQUAL(a, b) assert_not_equal_with_eps(a, b, EPS, __LINE__)

void test_large_numbers() {
    ASSERT_ALMOST_EQUAL(1000000, 1000001);
    ASSERT_ALMOST_EQUAL(1000001, 1000000);
    ASSERT_NOT_EQUAL(10000, 10001);
    ASSERT_NOT_EQUAL(10001, 10000);
}

void test_large_negative_numbers() {
    ASSERT_ALMOST_EQUAL(-1000000, -1000001);
    ASSERT_ALMOST_EQUAL(-1000001, -1000000);
    ASSERT_NOT_EQUAL(-10000, -10001);
    ASSERT_NOT_EQUAL(-10001, -10000);
}

void test_numbers_around_one() {
    ASSERT_ALMOST_EQUAL(1.0000001, 1.0000002);
    ASSERT_ALMOST_EQUAL(1.0000002, 1.0000001);
    ASSERT_NOT_EQUAL(1.0002, 1.0001);
    ASSERT_NOT_EQUAL(1.0001, 1.0002);
}

void test_numbers_around_minus_one() {
    ASSERT_ALMOST_EQUAL(-1.0000001, -1.0000002);
    ASSERT_ALMOST_EQUAL(-1.0000002, -1.0000001);
    ASSERT_NOT_EQUAL(-1.0002, -1.0001);
    ASSERT_NOT_EQUAL(-1.0001, -1.0002);
}

void test_small_numbers() {
    ASSERT_ALMOST_EQUAL(0.000000001000001, 0.000000001000002);
    ASSERT_ALMOST_EQUAL(0.000000001000002, 0.000000001000001);
    ASSERT_NOT_EQUAL(0.000000000001002, 0.000000000001001);
    ASSERT_NOT_EQUAL(0.000000000001001, 0.000000000001002);
}

void test_small_negative_numbers() {
    ASSERT_ALMOST_EQUAL(-0.000000001000001, -0.000000001000002);
    ASSERT_ALMOST_EQUAL(-0.000000001000002, -0.000000001000001);
    ASSERT_NOT_EQUAL(-0.000000000001002, -0.000000000001001);
    ASSERT_NOT_EQUAL(-0.000000000001001, -0.000000000001002);
}

void test_small_differences_away_from_zero() {
    ASSERT_ALMOST_EQUAL(0.3, 0.30000003);
    ASSERT_ALMOST_EQUAL(-0.3, -0.30000003);
}

void test_comparisons_involving_zero() {
    ASSERT_ALMOST_EQUAL(0, 0);
    ASSERT_ALMOST_EQUAL(0.0, -0.0);
    ASSERT_ALMOST_EQUAL(-0.0, -0.0);
    ASSERT_NOT_EQUAL(0.00000001, 0.0);
    ASSERT_NOT_EQUAL(0.0, 0.00000001);
    ASSERT_NOT_EQUAL(-0.00000001, 0.0);
    ASSERT_NOT_EQUAL(0.0, -0.00000001);

    /* original test contained 1e-40 here, which is a denormalized number in
     * single-precision float world. An equivalent value for doubles is ~1e-320,
     * see : https://docs.oracle.com/javase/8/docs/api/constant-values.html#java.lang.Double.MIN_VALUE
     * The value must be between Double.MIN_VALUE and Double.MIN_NORMAL */
    ASSERT_ALMOST_EQUAL_WITH_EPS(0.0, 1e-320, 0.01);
    ASSERT_ALMOST_EQUAL_WITH_EPS(1e-320, 0.0, 0.01);
}

void test_extreme_values() {
    ASSERT_ALMOST_EQUAL(DBL_MAX, DBL_MAX);
    ASSERT_NOT_EQUAL(DBL_MAX, -DBL_MAX);
    ASSERT_NOT_EQUAL(-DBL_MAX, DBL_MAX);
    ASSERT_NOT_EQUAL(DBL_MAX, DBL_MAX / 2);
    ASSERT_NOT_EQUAL(DBL_MAX, -DBL_MAX / 2);
    ASSERT_NOT_EQUAL(-DBL_MAX, DBL_MAX / 2);
}

void test_infinities() {
    ASSERT_ALMOST_EQUAL(IGRAPH_POSINFINITY, IGRAPH_POSINFINITY);
    ASSERT_ALMOST_EQUAL(IGRAPH_NEGINFINITY, IGRAPH_NEGINFINITY);
    ASSERT_NOT_EQUAL(IGRAPH_NEGINFINITY, IGRAPH_POSINFINITY);
    ASSERT_NOT_EQUAL(IGRAPH_POSINFINITY, DBL_MAX);
    ASSERT_NOT_EQUAL(IGRAPH_NEGINFINITY, -DBL_MAX);
}

void test_nans() {
    ASSERT_NOT_EQUAL(IGRAPH_NAN, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, 0);
    ASSERT_NOT_EQUAL(-0.0, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, -0.0);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, IGRAPH_POSINFINITY);
    ASSERT_NOT_EQUAL(IGRAPH_POSINFINITY, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, IGRAPH_NEGINFINITY);
    ASSERT_NOT_EQUAL(IGRAPH_NEGINFINITY, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, DBL_MAX);
    ASSERT_NOT_EQUAL(DBL_MAX, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, -DBL_MAX);
    ASSERT_NOT_EQUAL(-DBL_MAX, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, DBL_MIN);
    ASSERT_NOT_EQUAL(DBL_MIN, IGRAPH_NAN);
    ASSERT_NOT_EQUAL(IGRAPH_NAN, -DBL_MIN);
    ASSERT_NOT_EQUAL(-DBL_MIN, IGRAPH_NAN);
}

void test_opposite_sides_of_zero() {
    ASSERT_NOT_EQUAL(1.000000001, -1);
    ASSERT_NOT_EQUAL(-1, 1.000000001);
    ASSERT_NOT_EQUAL(-1.000000001, 1);
    ASSERT_NOT_EQUAL(1, -1.000000001);

    /* These tests from NearlyEqualsTest.java involved denormalized numbers in
     * Java world, and they were defined as floats. We use doubles, so I converted
     * the values manually by looking up Double.MIN_VALUE */
    ASSERT_ALMOST_EQUAL(49e-324, -49e-324);
}

void test_very_close_to_zero() {
#define DBL_DENORM_MIN 4.9e-324
    ASSERT_ALMOST_EQUAL(DBL_DENORM_MIN, DBL_DENORM_MIN);
    ASSERT_ALMOST_EQUAL(DBL_DENORM_MIN, -DBL_DENORM_MIN);
    ASSERT_ALMOST_EQUAL(-DBL_DENORM_MIN, DBL_DENORM_MIN);
    ASSERT_ALMOST_EQUAL(DBL_DENORM_MIN, 0);
    ASSERT_ALMOST_EQUAL(0, DBL_DENORM_MIN);
    ASSERT_ALMOST_EQUAL(-DBL_DENORM_MIN, 0);
    ASSERT_ALMOST_EQUAL(0, -DBL_DENORM_MIN);

    ASSERT_NOT_EQUAL(0.000000001, -DBL_DENORM_MIN);
    ASSERT_NOT_EQUAL(0.000000001, DBL_DENORM_MIN);
    ASSERT_NOT_EQUAL(DBL_DENORM_MIN, 0.000000001);
    ASSERT_NOT_EQUAL(-DBL_DENORM_MIN, 0.000000001);
}

int main() {
    test_large_numbers();
    test_large_negative_numbers();
    test_numbers_around_one();
    test_numbers_around_minus_one();
    test_small_numbers();
    test_small_negative_numbers();
    test_small_differences_away_from_zero();
    test_comparisons_involving_zero();
    test_extreme_values();
    test_infinities();
    test_nans();
    test_opposite_sides_of_zero();
    test_very_close_to_zero();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_are_connected.c0000644000175100001710000000413100000000000026261 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_bool_t connected;

    /* Complete graph. Any two distinct vertices are connected. */

    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    igraph_are_connected(&g, 2, 7, &connected);
    IGRAPH_ASSERT(connected);

    igraph_are_connected(&g, 0, 0, &connected);
    IGRAPH_ASSERT(! connected);

    igraph_destroy(&g);

    /* Complete graph with self-loops. */

    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    igraph_are_connected(&g, 1, 7, &connected);
    IGRAPH_ASSERT(connected);

    igraph_are_connected(&g, 2, 2, &connected);
    IGRAPH_ASSERT(connected);

    igraph_destroy(&g);

    /* Graph with no edges. Any two distinct vertices are disconnected. */

    igraph_empty(&g, 10, IGRAPH_DIRECTED);
    igraph_are_connected(&g, 3, 6, &connected);
    IGRAPH_ASSERT(! connected);
    igraph_destroy(&g);

    /* Invalid vertex ID, expecting an error */

    igraph_small(&g, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,0, 2,3, -1);
    igraph_set_error_handler(igraph_error_handler_ignore);
    IGRAPH_ASSERT(igraph_are_connected(&g, 0, igraph_vcount(&g) + 2 /* vertex id out of range */, &connected) == IGRAPH_EINVVID);
    igraph_set_error_handler(igraph_error_handler_abort);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_arpack_rnsolve.c0000644000175100001710000001560100000000000026505 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

typedef struct cb2_data_t {
    igraph_matrix_t *A;
} cb2_data_t;

int cb2(igraph_real_t *to, const igraph_real_t *from, int n, void *extra) {
    cb2_data_t *data = (cb2_data_t*) extra;
    igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0,
                                           data->A, from, /*beta=*/ 0.0, to);
    return 0;
}

int check_eigenvector(
    const char* test_name,
    igraph_matrix_t* A, igraph_matrix_t* values, igraph_matrix_t* vectors,
    int eval_idx, int evec_col_idx
) {
    igraph_complex_t eval, prod;
    igraph_complex_t *evec;
    int i, j, n = igraph_matrix_nrow(A);

    eval = igraph_complex(MATRIX(*values, eval_idx, 0), MATRIX(*values, eval_idx, 1));
    evec = (igraph_complex_t*) calloc(n, sizeof(igraph_complex_t));
    if (IGRAPH_IMAG(eval) == 0) {
        /* Real eigenvalue, so we have a real eigenvector */
        for (i = 0; i < n; i++) {
            evec[i] = igraph_complex(MATRIX(*vectors, i, evec_col_idx), 0);
        }
    } else {
        /* Complex eigenvalue pair, so we have a complex eigenvector pair */
        /* ARPACK always stores the eigenvector corresponding to the eigenvalue
         * with a positive imaginary part. If the imaginary part is negative, we
         * need to multiply the imaginary part of the eigenvector by -1 */
        for (i = 0; i < n; i++) {
            evec[i] = igraph_complex(
                          MATRIX(*vectors, i, evec_col_idx),
                          MATRIX(*vectors, i, evec_col_idx + 1) * (
                              IGRAPH_IMAG(eval) < 0 ? -1 : 1
                          )
                      );
        }
    }

    /* Multiply matrix with eigenvector */
    for (i = 0; i < n; i++) {
        prod = igraph_complex(0, 0);
        for (j = 0; j < n; j++) {
            prod = igraph_complex_add(
                       igraph_complex_mul_real(evec[j], MATRIX(*A, i, j)),
                       prod
                   );
        }
        prod = igraph_complex_div(prod, eval);
        if (!igraph_complex_eq_tol(prod, evec[i], 1e-6)) {
            prod = igraph_complex_sub(prod, evec[i]);
            printf("%s: vector corresponding to eigenvalue (%.4f + %.4f*i) is not an "
                   "eigenvector, coordinate %d differs by %.4f + %.4f*i\n",
                   test_name, IGRAPH_REAL(eval), IGRAPH_IMAG(eval),
                   i, IGRAPH_REAL(prod), IGRAPH_IMAG(prod));

            free(evec);
            return 1;
        }
    }

    /* Free stuff */
    free(evec);

    return 0;
}

int check_eigenvectors(
    const char* test_name,
    igraph_matrix_t* A, igraph_matrix_t* values, igraph_matrix_t* vectors
) {
    int i, j;
    int nev = igraph_matrix_nrow(values);
    int errors = 0;
    igraph_bool_t conjugate_pair_will_come = 0;

    for (i = 0, j = 0; i < nev; i++) {
        errors += check_eigenvector(test_name, A, values, vectors, i, j);
        if (MATRIX(*values, i, 1) != 0) {
            /* Complex eigenvalue */
            if (conjugate_pair_will_come) {
                j += 2;
                conjugate_pair_will_come = 0;
            } else {
                conjugate_pair_will_come = 1;
            }
        } else {
            /* Real eigenvalue */
            j++;
        }
    }
    return (errors > 0) ? 1 : 0;
}

#define DIM 10

int main() {
    igraph_matrix_t A;
    igraph_matrix_t values, vectors;
    igraph_arpack_options_t options;
    cb2_data_t data = { &A };
    int i, j;

    igraph_rng_seed(igraph_rng_default(), 42 * 42);

    igraph_matrix_init(&A, DIM, DIM);

    for (i = 0; i < DIM; i++) {
        for (j = 0; j < DIM; j++) {
            MATRIX(A, i, j) = igraph_rng_get_integer(igraph_rng_default(), -10, 10);
        }
    }

    printf("Input matrix:\n");
    igraph_matrix_print(&A);
    printf("\n");

    printf("\n4 largest eigenvalues by magnitude:\n");

    igraph_arpack_options_init(&options);
    options.n = DIM;
    options.start = 0;
    options.nev = 4;
    options.ncv = 9;
    options.which[0] = 'L' ;
    options.which[1] = 'M';

    igraph_matrix_init(&values, 0, 0);
    igraph_matrix_init(&vectors, options.n, 1);

    igraph_arpack_rnsolve(cb2, /*extra=*/ &data, &options, /*storage=*/ 0,
                          &values, &vectors);
    printf("\nEigenvalues:\n");
    igraph_matrix_print(&values);
    if (check_eigenvectors("LM #1", &A, &values, &vectors)) {
        printf("\nEigenvectors:\n");
        igraph_matrix_print(&vectors);
    }

    /* -------------- */

    printf("\n3 largest eigenvalues by magnitude:\n");

    options.nev = 3;
    options.which[0] = 'L' ;
    options.which[1] = 'M';

    igraph_arpack_rnsolve(cb2, /*extra=*/ &data, &options, /*storage=*/ 0,
                          &values, &vectors);
    printf("\nEigenvalues:\n");
    igraph_matrix_print(&values);
    if (check_eigenvectors("LM #2", &A, &values, &vectors)) {
        printf("\nEigenvectors:\n");
        igraph_matrix_print(&vectors);
    }

    /* -------------- */

    printf("\n3 smallest eigenvalues by real part:\n");

    options.nev = 3;
    options.which[0] = 'S' ;
    options.which[1] = 'R';

    igraph_arpack_rnsolve(cb2, /*extra=*/ &data, &options, /*storage=*/ 0,
                          &values, &vectors);
    printf("\nEigenvalues:\n");
    igraph_matrix_print(&values);
    if (check_eigenvectors("SR", &A, &values, &vectors)) {
        printf("\nEigenvectors:\n");
        igraph_matrix_print(&vectors);
    }

    /* -------------- */

    printf("\n3 smallest eigenvalues by imaginary part:\n");

    options.nev = 3;
    options.which[0] = 'L' ;
    options.which[1] = 'I';

    igraph_arpack_rnsolve(cb2, /*extra=*/ &data, &options, /*storage=*/ 0,
                          &values, &vectors);
    printf("\nEigenvalues:\n");
    igraph_matrix_print(&values);
    if (check_eigenvectors("LI", &A, &values, &vectors)) {
        printf("\nEigenvectors:\n");
        igraph_matrix_print(&vectors);
    }

    /* -------------- */

    igraph_matrix_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&A);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_arpack_rnsolve.out0000644000175100001710000000122600000000000027070 0ustar00runnerdocker00000000000000Input matrix:
-6 0 10 3 8 1 -4 10 -8 0
-6 1 0 8 -4 4 -7 1 1 6
7 -7 8 6 -4 -8 -1 -7 -3 -7
6 8 -4 -1 10 3 7 7 -3 -8
1 -7 -4 9 0 5 5 6 -8 10
-9 10 -5 -9 5 3 -5 7 -7 10
-3 0 8 -6 -2 -7 1 -3 -8 1
2 0 9 -3 0 -9 -4 0 10 0
-9 1 -6 -1 7 10 9 9 8 -2
-7 1 9 -7 10 -1 -2 -5 7 6


4 largest eigenvalues by magnitude:

Eigenvalues:
22.0483 0
-21.3281 0
-3.00735 19.2957
-3.00735 -19.2957

3 largest eigenvalues by magnitude:

Eigenvalues:
22.0483 0
-21.3281 0
-3.00735 19.2957

3 smallest eigenvalues by real part:

Eigenvalues:
-21.3281 0
-12.4527 0
-3.00735 19.2957

3 smallest eigenvalues by imaginary part:

Eigenvalues:
-3.00735 19.2957
-3.00735 -19.2957
12.1099 6.27293
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_arpack_unpack_complex.c0000644000175100001710000001060500000000000030024 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_matrix_t *vectors, igraph_matrix_t *values, int nev, igraph_error_type_t error) {
    printf("vectors in:\n");
    print_matrix_format(vectors, stdout, "%6.2f");
    printf("values in:\n");
    print_matrix_format(values, stdout, "%6.2f");
    IGRAPH_ASSERT(igraph_arpack_unpack_complex(vectors, values, nev) == (int)error);
    printf("vectors out:\n");
    print_matrix_format(vectors, stdout, "%6.2f");
    printf("values out:\n");
    print_matrix_format(values, stdout, "%6.2f");
    igraph_matrix_destroy(vectors);
    igraph_matrix_destroy(values);
    printf("\n");
}

int main() {
    igraph_matrix_t vectors;
    igraph_matrix_t values;

    printf("Empty vectors and values:\n");
    matrix_init_int_row_major(&vectors, 0, 0, NULL);
    matrix_init_int_row_major(&values, 0, 0, NULL);
    print_and_destroy(&vectors, &values, 0, IGRAPH_SUCCESS);

    {
        printf("Real vectors and values:\n");
        int vectors_elem[4] = {-1, 0, 9, 10};
        int values_elem[4] = {-6, 0, 3, 0};
        matrix_init_int_row_major(&vectors, 2, 2, vectors_elem);
        matrix_init_int_row_major(&values, 2, 2, values_elem);
        print_and_destroy(&vectors, &values, 2, IGRAPH_SUCCESS);
    }
    {
        printf("Complex vectors and values:\n");
        igraph_real_t vectors_elem[36] = {
            0.123938, 0.3411, 0.114301, -0.134822, -0.421672, -0.484969,
            -0.268889, 0.00766665, 0.413844, 0.200565, -0.0336028, -0.133362,
            -0.192782, -0.140134, 0.579782, -0.0853149, -0.0684855, 0.117105,
            0.175547, 0.1833, 0.156218, 0.0623488, 0.422265, -0.257261,
            -0.266691, 0.404647, -0.462498, -0.0885737, 0.203893, -0.135195,
            0.662813, -0.022972, -0.193704, 0.355354, -0.0405741, 0.493652};
        igraph_real_t values_elem[12] = {
            -2.58338, 9.66092, -2.58338, -9.66092, 7.07998, 6.51033,
            7.07998, -6.51033, -7.9966, 2.74368, -7.9966, -2.74368};
        matrix_init_real_row_major(&vectors, 6, 6, vectors_elem);
        matrix_init_real_row_major(&values, 6, 2, values_elem);
        print_and_destroy(&vectors, &values, 6, IGRAPH_SUCCESS);
    }
    {
        printf("Both complex and real vectors and values:\n");
        int vectors_elem[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        int values_elem[8] = {1, 0, 2, 1, 2, -1, 3, 0};
        matrix_init_int_row_major(&vectors, 4, 4, vectors_elem);
        matrix_init_int_row_major(&values, 4, 2, values_elem);
        print_and_destroy(&vectors, &values, 4, IGRAPH_SUCCESS);
    }
    {
        printf("Both complex and real vectors and values, but nev = 2:\n");
        int vectors_elem[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        int values_elem[8] = {1, 0, 2, 1, 2, -1, 3, 0};
        matrix_init_int_row_major(&vectors, 4, 4, vectors_elem);
        matrix_init_int_row_major(&values, 4, 2, values_elem);
        print_and_destroy(&vectors, &values, 2, IGRAPH_SUCCESS);
    }
    {
        printf("No vectors but there are values:\n");
        int values_elem[8] = {1, 0, 2, 1, 2, -1, 3, 0};
        matrix_init_int_row_major(&vectors, 0, 0, NULL);
        matrix_init_int_row_major(&values, 4, 2, values_elem);
        print_and_destroy(&vectors, &values, 4, IGRAPH_SUCCESS);
    }
    {
        printf("No values, but there are vectors:\n");
        int vectors_elem[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        matrix_init_int_row_major(&vectors, 4, 4, vectors_elem);
        matrix_init_int_row_major(&values, 0, 0, NULL);
        print_and_destroy(&vectors, &values, 0, IGRAPH_SUCCESS);
    }

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_arpack_unpack_complex.out0000644000175100001710000000541200000000000030411 0ustar00runnerdocker00000000000000Empty vectors and values:
vectors in:
values in:
vectors out:
values out:

Real vectors and values:
vectors in:
[  -1.00   0.00
    9.00  10.00 ]
values in:
[  -6.00   0.00
    3.00   0.00 ]
vectors out:
[  -1.00   0.00   0.00   0.00
    9.00   0.00  10.00   0.00 ]
values out:
[  -6.00   0.00
    3.00   0.00 ]

Complex vectors and values:
vectors in:
[   0.12   0.34   0.11  -0.13  -0.42  -0.48
   -0.27   0.01   0.41   0.20  -0.03  -0.13
   -0.19  -0.14   0.58  -0.09  -0.07   0.12
    0.18   0.18   0.16   0.06   0.42  -0.26
   -0.27   0.40  -0.46  -0.09   0.20  -0.14
    0.66  -0.02  -0.19   0.36  -0.04   0.49 ]
values in:
[  -2.58   9.66
   -2.58  -9.66
    7.08   6.51
    7.08  -6.51
   -8.00   2.74
   -8.00  -2.74 ]
vectors out:
[   0.12   0.34   0.12  -0.34   0.11  -0.13   0.11   0.13  -0.42  -0.48  -0.42   0.48
   -0.27   0.01  -0.27  -0.01   0.41   0.20   0.41  -0.20  -0.03  -0.13  -0.03   0.13
   -0.19  -0.14  -0.19   0.14   0.58  -0.09   0.58   0.09  -0.07   0.12  -0.07  -0.12
    0.18   0.18   0.18  -0.18   0.16   0.06   0.16  -0.06   0.42  -0.26   0.42   0.26
   -0.27   0.40  -0.27  -0.40  -0.46  -0.09  -0.46   0.09   0.20  -0.14   0.20   0.14
    0.66  -0.02   0.66   0.02  -0.19   0.36  -0.19  -0.36  -0.04   0.49  -0.04  -0.49 ]
values out:
[  -2.58   9.66
   -2.58  -9.66
    7.08   6.51
    7.08  -6.51
   -8.00   2.74
   -8.00  -2.74 ]

Both complex and real vectors and values:
vectors in:
[   1.00   2.00   3.00   4.00
    5.00   6.00   7.00   8.00
    9.00  10.00  11.00  12.00
   13.00  14.00  15.00  16.00 ]
values in:
[   1.00   0.00
    2.00   1.00
    2.00  -1.00
    3.00   0.00 ]
vectors out:
[   1.00   0.00   2.00   3.00   2.00  -3.00   4.00   0.00
    5.00   0.00   6.00   7.00   6.00  -7.00   8.00   0.00
    9.00   0.00  10.00  11.00  10.00 -11.00  12.00   0.00
   13.00   0.00  14.00  15.00  14.00 -15.00  16.00   0.00 ]
values out:
[   1.00   0.00
    2.00   1.00
    2.00  -1.00
    3.00   0.00 ]

Both complex and real vectors and values, but nev = 2:
vectors in:
[   1.00   2.00   3.00   4.00
    5.00   6.00   7.00   8.00
    9.00  10.00  11.00  12.00
   13.00  14.00  15.00  16.00 ]
values in:
[   1.00   0.00
    2.00   1.00
    2.00  -1.00
    3.00   0.00 ]
vectors out:
[   1.00   0.00   2.00   3.00
    5.00   0.00   6.00   7.00
    9.00   0.00  10.00  11.00
   13.00   0.00  14.00  15.00 ]
values out:
[   1.00   0.00
    2.00   1.00 ]

No vectors but there are values:
vectors in:
values in:
[   1.00   0.00
    2.00   1.00
    2.00  -1.00
    3.00   0.00 ]
vectors out:
values out:
[   1.00   0.00
    2.00   1.00
    2.00  -1.00
    3.00   0.00 ]

No values, but there are vectors:
vectors in:
[   1.00   2.00   3.00   4.00
    5.00   6.00   7.00   8.00
    9.00  10.00  11.00  12.00
   13.00  14.00  15.00  16.00 ]
values in:
vectors out:
[
 
 
  ]
values out:

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_array.c0000644000175100001710000000411700000000000024612 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

void print_array(const igraph_array3_t *a) {
    long int i, j, k;
    for (k = 0; k < igraph_array3_n(a, 3); k++) {
        for (i = 0; i < igraph_array3_n(a, 1); i++) {
            for (j = 0; j < igraph_array3_n(a, 2); j++) {
                printf(" %g", (double) ARRAY3(*a, i, j, k));
            }
            printf("\n");
        }
            printf("\n");
    }
}

int main() {
    igraph_array3_t a;
    long int i, j, k;
    long int s = 1;

    igraph_array3_init(&a, 5, 4, 3);
    igraph_array3_destroy(&a);

    igraph_array3_init(&a, 5, 4, 3);
    print_array(&a);
    IGRAPH_ASSERT(igraph_array3_n(&a, 1) == 5);
    IGRAPH_ASSERT(igraph_array3_n(&a, 2) == 4);
    IGRAPH_ASSERT(igraph_array3_n(&a, 3) == 3);
    igraph_array3_destroy(&a);

    igraph_array3_init(&a, 5, 4, 3);
    for (k = 0; k < igraph_array3_n(&a, 3); k++) {
        for (j = 0; j < igraph_array3_n(&a, 2); j++) {
            for (i = 0; i < igraph_array3_n(&a, 1); i++) {
                ARRAY3(a, i, j, k) = s++;
            }
        }
    }
    print_array(&a);
    print_vector_format(&a.data, stdout, "%g");
    igraph_array3_destroy(&a);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_array.out0000644000175100001710000000076600000000000025205 0ustar00runnerdocker00000000000000 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0

 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0

 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0

 1 6 11 16
 2 7 12 17
 3 8 13 18
 4 9 14 19
 5 10 15 20

 21 26 31 36
 22 27 32 37
 23 28 33 38
 24 29 34 39
 25 30 35 40

 41 46 51 56
 42 47 52 57
 43 48 53 58
 44 49 54 59
 45 50 55 60

( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_attribute_combination_remove.c0000644000175100001710000000450500000000000031437 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_comb(igraph_attribute_combination_t *comb) {
    int i;
    igraph_attribute_combination_record_t *r;
    for (i = 0; i < igraph_vector_ptr_size(&comb->list); i++) {
        r = VECTOR(comb->list)[i];
        if (r->name) {
            printf("name: %s", r->name);
        } else {
            printf("name: NULL");
        }
        printf(", type: %d\n", r->type);
    }
    printf("\n");
}

int main() {
    igraph_attribute_combination_t comb;

    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 "type",   IGRAPH_ATTRIBUTE_COMBINE_FIRST,
                                 "",       IGRAPH_ATTRIBUTE_COMBINE_IGNORE,
                                 IGRAPH_NO_MORE_ATTRIBUTES);

    printf("starting combinations:\n");
    print_comb(&comb);

    printf("Removing nonexistent combination:\n");
    igraph_attribute_combination_remove(&comb, "nonexistent_name");
    print_comb(&comb);

    printf("Removing weight:\n");
    igraph_attribute_combination_remove(&comb, "weight");
    print_comb(&comb);

    printf("Removing type and NULL:\n");
    igraph_attribute_combination_remove(&comb, "type");
    igraph_attribute_combination_remove(&comb, NULL);
    print_comb(&comb);

    printf("Removing nonexistent combination again:\n");
    igraph_attribute_combination_remove(&comb, "nonexistent_name");
    igraph_attribute_combination_remove(&comb, NULL);
    print_comb(&comb);

    igraph_attribute_combination_destroy(&comb);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_attribute_combination_remove.out0000644000175100001710000000046300000000000032023 0ustar00runnerdocker00000000000000starting combinations:
name: weight, type: 3
name: type, type: 8
name: NULL, type: 0

Removing nonexistent combination:
name: weight, type: 3
name: type, type: 8
name: NULL, type: 0

Removing weight:
name: type, type: 8
name: NULL, type: 0

Removing type and NULL:

Removing nonexistent combination again:

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_average_path_length.c0000644000175100001710000000475700000000000027475 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 

#include "test_utilities.inc"

void print_and_destroy(igraph_t *graph, igraph_bool_t unconn) {
    igraph_real_t res, unconn_pairs;

    igraph_average_path_length(graph, &res, &unconn_pairs, IGRAPH_DIRECTED, unconn);
    printf("Average shortest path length: ");
    print_real(stdout, res, "%g");
    printf("\nNo. of unconnected pairs: %g\n", unconn_pairs);

    igraph_destroy(graph);
}

int main() {
    igraph_t graph;

    printf("Null graph:\n");
    igraph_empty(&graph, 0, IGRAPH_UNDIRECTED);
    print_and_destroy(&graph, 1);

    printf("\nSingleton graph:\n");
    igraph_empty(&graph, 1, IGRAPH_DIRECTED);
    print_and_destroy(&graph, 1);

    printf("\n2-vertex empty graph, unconn=true:\n");
    igraph_empty(&graph, 2, IGRAPH_UNDIRECTED);
    print_and_destroy(&graph, 1);

    printf("\n2-vertex empty graph, unconn=false:\n");
    igraph_empty(&graph, 2, IGRAPH_UNDIRECTED);
    print_and_destroy(&graph, 0);

    printf("\nSmallest bifurcating directed tree, unconn=true:\n");
    igraph_small(&graph, 2, IGRAPH_DIRECTED,
                 0,1, 0,2, -1);
    print_and_destroy(&graph, 1);

    printf("\nSmallest bifurcating directed tree, unconn=false:\n");
    igraph_small(&graph, 2, IGRAPH_DIRECTED,
                 0,1, 0,2, -1);
    print_and_destroy(&graph, 1);

    printf("\nUndirected 11-cycle:\n");
    igraph_ring(&graph, 11, IGRAPH_UNDIRECTED, 0, 1);
    print_and_destroy(&graph, 1);

    printf("\nDirected 6-cycle:\n");
    igraph_ring(&graph, 11, IGRAPH_DIRECTED, 0, 1);
    print_and_destroy(&graph, 1);

    /* Result verified by szhorvat on 2021-03-04. */
    printf("\nDe Bruijn graph, n=3 and m=5:\n");
    igraph_de_bruijn(&graph, 3, 5);
    print_and_destroy(&graph, 1);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_average_path_length.out0000644000175100001710000000150000000000000030041 0ustar00runnerdocker00000000000000Null graph:
Average shortest path length: NaN
No. of unconnected pairs: 0

Singleton graph:
Average shortest path length: NaN
No. of unconnected pairs: 0

2-vertex empty graph, unconn=true:
Average shortest path length: NaN
No. of unconnected pairs: 2

2-vertex empty graph, unconn=false:
Average shortest path length: Inf
No. of unconnected pairs: 2

Smallest bifurcating directed tree, unconn=true:
Average shortest path length: 1
No. of unconnected pairs: 4

Smallest bifurcating directed tree, unconn=false:
Average shortest path length: 1
No. of unconnected pairs: 4

Undirected 11-cycle:
Average shortest path length: 3
No. of unconnected pairs: 0

Directed 6-cycle:
Average shortest path length: 5.5
No. of unconnected pairs: 0

De Bruijn graph, n=3 and m=5:
Average shortest path length: 4.34405
No. of unconnected pairs: 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_average_path_length_dijkstra.c0000644000175100001710000000665600000000000031370 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void compute_and_print(igraph_t *graph, igraph_vector_t *weights, igraph_bool_t directed, igraph_bool_t unconn) {
    igraph_real_t result;
    igraph_real_t unconn_pairs;

    IGRAPH_ASSERT(igraph_average_path_length_dijkstra(graph, &result, &unconn_pairs, weights,
                  directed, unconn) == IGRAPH_SUCCESS);

    printf("Result: ");
    print_real(stdout, result, "%8g");
    printf("\nUnconnected pairs: ");
    print_real(stdout, unconn_pairs, "%8g");
    printf("\n\n");
}

int main() {
    igraph_t g_0, g_1, g_2, g_3, g_lm;
    igraph_vector_t weights_0, weights_3, weights_lm, weights_lm_neg;
    igraph_real_t result;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_2, 2, 0, -1);
    igraph_small(&g_3, 2, 1, 0,1, 0,2, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    igraph_vector_init(&weights_0, 0);
    igraph_vector_init_int(&weights_3, 2, 1, 1);
    igraph_vector_init_int(&weights_lm, 8, 0, 1, 2, 3, 4, 5, 6, 7);
    igraph_vector_init_int(&weights_lm_neg, 8, -10, 1, 2, 3, 4, 5, 6, 7);

    printf("No vertices:\n");
    compute_and_print(&g_0, &weights_0, 1, 1);

    printf("One vertex:\n");
    compute_and_print(&g_1, &weights_0, 1, 1);

    printf("Two vertices:\n");
    compute_and_print(&g_2, &weights_0, 1, 1);

    printf("Two vertices, inf for unconnected pairs:\n");
    compute_and_print(&g_2, &weights_0, 1, 0);

    printf("Smallest bifurcating directed tree:\n");
    compute_and_print(&g_3, &weights_3, 1, 1);

    printf("Smallest bifurcating directed tree, inf for unconnected pairs:\n");
    compute_and_print(&g_3, &weights_3, 1, 0);

    printf("Graph with loops and multiple edges:\n");
    compute_and_print(&g_lm, &weights_lm, 1, 1);

    printf("Graph with loops and multiple edges, ignoring direction:\n");
    compute_and_print(&g_lm, &weights_lm, 0, 1);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking incorrect weight length error handling.\n");
    IGRAPH_ASSERT(igraph_average_path_length_dijkstra(&g_lm, &result, NULL, &weights_0,
                  1, 1) == IGRAPH_EINVAL);

    printf("Checking negative weight error handling.\n");
    IGRAPH_ASSERT(igraph_average_path_length_dijkstra(&g_lm, &result, NULL, &weights_lm_neg,
                  1, 1) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_2);
    igraph_destroy(&g_3);
    igraph_destroy(&g_lm);
    igraph_vector_destroy(&weights_0);
    igraph_vector_destroy(&weights_3);
    igraph_vector_destroy(&weights_lm);
    igraph_vector_destroy(&weights_lm_neg);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_average_path_length_dijkstra.out0000644000175100001710000000133300000000000031740 0ustar00runnerdocker00000000000000No vertices:
Result:      NaN
Unconnected pairs:        0

One vertex:
Result:      NaN
Unconnected pairs:        0

Two vertices:
Result:      NaN
Unconnected pairs:        2

Two vertices, inf for unconnected pairs:
Result:      Inf
Unconnected pairs:        2

Smallest bifurcating directed tree:
Result:        1
Unconnected pairs:        4

Smallest bifurcating directed tree, inf for unconnected pairs:
Result:      Inf
Unconnected pairs:        4

Graph with loops and multiple edges:
Result:        5
Unconnected pairs:       19

Graph with loops and multiple edges, ignoring direction:
Result:      4.6
Unconnected pairs:       10

Checking incorrect weight length error handling.
Checking negative weight error handling.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_barabasi_aging_game.c0000644000175100001710000001443400000000000027401 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t outseq;
    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_bool_t tree;

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 0, /*m: edges_per_step*/ 1,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1, /*aging_exp*/ 1, /*aging_bin*/ 1,
        /*zero_deg_appeal*/ 0, /*zero_age_appeal*/ 0, /*deg_coef*/ 1.0,
        /*age_coef */ 1.0, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph(&g);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    igraph_destroy(&g);

    printf("No edges:\n");
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 0,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1, /*aging_exp*/ 1, /*aging_bin*/ 1,
        /*zero_deg_appeal*/ 0, /*zero_age_appeal*/ 0, /*deg_coef*/ 1.0,
        /*age_coef */ 1.0, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph(&g);
    IGRAPH_ASSERT(igraph_vcount(&g) == 5);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    igraph_destroy(&g);

    /*one edge per step makes a tree*/
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
           &g, /*nodes*/ 10, /*m: edges_per_step*/ 1,
           /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
           /*pa_exp*/ 0.5, /*aging_exp*/ -0.5, /*aging_bin*/ 2,
           /*zero_deg_appeal*/ 0.1, /*zero_age_appeal*/ 0, /*deg_coef*/ 0.1,
           /*age_coef */ 0.1, /*directed*/ 1) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 9);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_is_tree(&g, &tree, /* root*/ NULL, IGRAPH_IN);
    IGRAPH_ASSERT(tree);
    igraph_destroy(&g);

    printf("Prefer old vertices to make a star of triple edges:\n");
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 3,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 1,
        /*pa_exp*/ 0.0, /*aging_exp*/ 10, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 1.0, /*zero_age_appeal*/ 0, /*deg_coef*/ 0.0,
        /*age_coef */ 1, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Prefer new vertices to make a line of double edges:\n");
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 0.0, /*aging_exp*/ -10, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 0.1, /*zero_age_appeal*/ 0, /*deg_coef*/ 0.1,
        /*age_coef */ 1, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Increasing thickness of the line using outseq:\n");
    igraph_vector_init_int(&outseq, 5, 1, 2, 3, 4, 5);
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ &outseq, /*outpref*/ 0,
        /*pa_exp*/ 0.1, /*aging_exp*/ -10, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 0.1, /*zero_age_appeal*/ 0, /*deg_coef*/ 0.1,
        /*age_coef */ 10, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&outseq);

    printf("Prefer more edges to make a star:\n");
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 10.0, /*aging_exp*/ 0.0, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 0.0, /*zero_age_appeal*/ 1.0, /*deg_coef*/ 1.0,
        /*age_coef */ 0.0, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /* Non-negative age coefficients are required*/
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1.0, /*aging_exp*/ 0.0, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 1.0, /*zero_age_appeal*/ 1.0, /*deg_coef*/ 1.0,
        /*age_coef */ -1.0, /*directed*/ 1) == IGRAPH_EINVAL);

    /* Non-negative degree coefficients are required*/
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1.0, /*aging_exp*/ 0.0, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 1.0, /*zero_age_appeal*/ 1.0, /*deg_coef*/ -1.0,
        /*age_coef */ 0.0, /*directed*/ 1) == IGRAPH_EINVAL);

    /* Non negative zero degree appeals are required*/
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1.0, /*aging_exp*/ 0.0, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ -1.0, /*zero_age_appeal*/ 1.0, /*deg_coef*/ 1.0,
        /*age_coef */ 0.0, /*directed*/ 1) == IGRAPH_EINVAL);

    /* Non negative zero age appeals are required*/
    IGRAPH_ASSERT(igraph_barabasi_aging_game(
        &g, /*nodes*/ 5, /*m: edges_per_step*/ 2,
        /*outseq: edges per step as vector*/ NULL, /*outpref*/ 0,
        /*pa_exp*/ 1.0, /*aging_exp*/ 0.0, /*aging_bin*/ 6,
        /*zero_deg_appeal*/ 1.0, /*zero_age_appeal*/ -1.0, /*deg_coef*/ 1.0,
        /*age_coef */ 0.0, /*directed*/ 1) == IGRAPH_EINVAL);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_barabasi_aging_game.out0000644000175100001710000000112200000000000027754 0ustar00runnerdocker00000000000000No vertices:
directed: false
vcount: 0
edges: {
}
No edges:
directed: false
vcount: 5
edges: {
}
Prefer old vertices to make a star of triple edges:
directed: true
vcount: 5
edges: {
1 0
1 0
1 0
2 0
2 0
2 0
3 0
3 0
3 0
4 0
4 0
4 0
}
Prefer new vertices to make a line of double edges:
directed: true
vcount: 5
edges: {
1 0
1 0
2 1
2 1
3 2
3 2
4 3
4 3
}
Increasing thickness of the line using outseq:
directed: true
vcount: 5
edges: {
1 0
1 0
2 1
2 1
2 1
3 2
3 2
3 2
3 2
4 3
4 3
4 3
4 3
4 3
}
Prefer more edges to make a star:
directed: true
vcount: 5
edges: {
1 0
1 0
2 0
2 0
3 0
3 0
4 0
4 0
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_betweenness.c0000644000175100001710000002531000000000000026014 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2008-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t bet, bet2, weights, edges;

    igraph_real_t cutoff = 0.0;

    igraph_real_t nontriv[] = { 0, 19, 0, 16, 0, 20, 1, 19, 2, 5, 3, 7, 3, 8,
                                4, 15, 4, 11, 5, 8, 5, 19, 6, 7, 6, 10, 6, 8,
                                6, 9, 7, 20, 9, 10, 9, 20, 10, 19,
                                11, 12, 11, 20, 12, 15, 13, 15,
                                14, 18, 14, 16, 14, 17, 15, 16, 17, 18
                              };

    igraph_real_t nontriv_weights[] = { 0.5249, 1, 0.1934, 0.6274, 0.5249,
                                        0.0029, 0.3831, 0.05, 0.6274, 0.3831,
                                        0.5249, 0.0587, 0.0579, 0.0562, 0.0562,
                                        0.1934, 0.6274, 0.6274, 0.6274, 0.0418,
                                        0.6274, 0.3511, 0.3511, 0.1486, 1, 1,
                                        0.0711, 0.2409
                                      };

    igraph_real_t nontriv_res[] = { 20, 0, 0, 0, 0, 19, 80, 85, 32, 0, 10,
                                    75, 70, 0, 36, 81, 60, 0, 19, 19, 86
                                  };

    /*******************************************************/

    printf("BA graph\n");
    printf("==========================================================\n");
    igraph_barabasi_game(/* graph= */    &g,
                                         /* n= */        1000,
                                         /* power= */    1,
                                         /* m= */        3,
                                         /* outseq= */   0,
                                         /* outpref= */  0,
                                         /* A= */        1,
                                         /* directed= */ 0,
                                         /* algo= */     IGRAPH_BARABASI_BAG,
                                         /* start_from= */ 0);

    igraph_simplify(&g, /* multiple= */ 1, /* loops= */ 1, /*edge_comb=*/ 0);

    igraph_vector_init(&bet, 0);

    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ 0,
            /* cutoff=    */ 2);

    igraph_vector_destroy(&bet);
    igraph_destroy(&g);

    printf("\nTree\n");
    printf("==========================================================\n");
    igraph_tree(&g, 20000, 10, IGRAPH_TREE_UNDIRECTED);

    igraph_vector_init(&bet, 0);

    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ 0,
            /* cutoff=    */ 3);

    printf("Max betweenness: %f\n", igraph_vector_max(&bet));

    igraph_vector_init(&bet2, 0);
    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 1.0);

    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet2,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ &weights,
            /* cutoff=    */ 3);

    IGRAPH_ASSERT(igraph_vector_all_e(&bet, &bet2));

    igraph_vector_destroy(&bet);
    igraph_vector_destroy(&bet2);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    printf("\nNon-trivial weighted graph\n");
    printf("==========================================================\n");
    igraph_vector_view(&edges, nontriv, sizeof(nontriv) / sizeof(igraph_real_t));
    igraph_create(&g, &edges, 0, /* directed= */ 0);
    igraph_vector_view(&weights, nontriv_weights,
                       sizeof(nontriv_weights) / sizeof(igraph_real_t));
    igraph_vector_init(&bet, 0);

    igraph_betweenness(/*graph=*/ &g, /*res=*/ &bet, /*vids=*/ igraph_vss_all(),
                                  /*directed=*/0, /*weights=*/ &weights);

    printf("Max betweenness: %f\n", igraph_vector_max(&bet));

    igraph_vector_view(&bet2, nontriv_res,
                       sizeof(nontriv_res) / sizeof(igraph_real_t));

    IGRAPH_ASSERT(igraph_vector_all_e(&bet, &bet2));

    igraph_vector_destroy(&bet);
    igraph_destroy(&g);


    printf("\nCorner case cutoff 0.0\n");
    printf("==========================================================\n");
    igraph_tree(&g, 20, 3, IGRAPH_TREE_UNDIRECTED);

    /* unweighted */
    igraph_vector_init(&bet, 0);
    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ 0,
            /* cutoff=    */ 0);

    igraph_vector_init(&bet2, 0);
    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet2,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ 0,
            /* cutoff=    */ -1);

    igraph_vector_print(&bet);
    igraph_vector_print(&bet2);

    igraph_vector_destroy(&bet);
    igraph_vector_destroy(&bet2);

    /* weighted */
    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 2.0);

    igraph_vector_init(&bet, 0);
    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ &weights,
            /* cutoff=    */ 0);

    igraph_vector_init(&bet2, 0);
    igraph_betweenness_cutoff(/* graph=     */ &g,
            /* res=       */ &bet2,
            /* vids=      */ igraph_vss_all(),
            /* directed = */ 0,
            /* weights=   */ &weights,
            /* cutoff=    */ -1);

    igraph_vector_print(&bet);
    igraph_vector_print(&bet2);

    igraph_vector_destroy(&bet);
    igraph_vector_destroy(&bet2);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    printf("\nSingle path graph\n");
    printf("==========================================================\n");
    igraph_small(&g, 5, IGRAPH_UNDIRECTED,
                            0, 1,
                            1, 2,
                            2, 3,
                            3, 4, -1);
    igraph_vector_init(&bet, igraph_vcount(&g));
    igraph_vector_init(&bet2, igraph_vcount(&g));
    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 1);

    for (cutoff = -1.0; cutoff < 5.0; cutoff += 1)
    {
        printf("Cutoff %.0f\n", cutoff);
        printf("Unweighted\n");
        igraph_betweenness_cutoff(&g, &bet,
                                  igraph_vss_all(), IGRAPH_UNDIRECTED,
                /* weights */ NULL,
                /* cutoff */ cutoff);
        igraph_vector_print(&bet);

        printf("Weighted\n");
        igraph_betweenness_cutoff(&g, &bet2,
                                  igraph_vss_all(), IGRAPH_UNDIRECTED,
                /* weights */ &weights,
                /* cutoff */ cutoff);
        igraph_vector_print(&bet2);
        printf("\n");

        IGRAPH_ASSERT(igraph_vector_all_e(&bet, &bet2));
    }

    igraph_vector_destroy(&bet);
    igraph_vector_destroy(&bet2);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    printf("\nCycle graph\n");
    printf("==========================================================\n");
    igraph_small(&g, 4, IGRAPH_UNDIRECTED,
                            0, 1,
                            0, 2,
                            1, 3,
                            2, 3, -1);
    igraph_vector_init(&bet, igraph_vcount(&g));
    igraph_vector_init(&bet2, igraph_vcount(&g));
    igraph_vector_init(&weights, igraph_ecount(&g));
    VECTOR(weights)[0] = 1.01;
    VECTOR(weights)[1] = 2;
    VECTOR(weights)[2] = 0.99;
    VECTOR(weights)[3] = 2;

    for (cutoff = -1.0; cutoff < 5.0; cutoff += 1)
    {
        printf("Cutoff %.0f\n", cutoff);
        printf("Unweighted\n");
        igraph_betweenness_cutoff(&g, &bet,
                                  igraph_vss_all(), IGRAPH_UNDIRECTED,
                /* weights */ NULL,
                /* cutoff */ cutoff);
        igraph_vector_print(&bet);

        printf("Weighted\n");
        igraph_betweenness_cutoff(&g, &bet2,
                                  igraph_vss_all(), IGRAPH_UNDIRECTED,
                /* weights */ &weights,
                /* cutoff */ cutoff);
        igraph_vector_print(&bet2);
        printf("\n");
    }

    igraph_vector_destroy(&bet);
    igraph_vector_destroy(&bet2);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    printf("\nNull graph\n");
    printf("==========================================================\n");

    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_vector_init(&bet, 3); /* purposefully larger than zero, as igraph_betweenness must resize it */
    igraph_betweenness(&g, &bet, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL);
    print_vector(&bet);

    igraph_vector_destroy(&bet);
    igraph_destroy(&g);

    printf("\nEmpty graph\n");
    printf("==========================================================\n");

    igraph_empty(&g, 2, IGRAPH_UNDIRECTED);
    igraph_vector_init(&bet, 0);
    igraph_betweenness(&g, &bet, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL);
    print_vector(&bet);

    igraph_vector_destroy(&bet);
    igraph_destroy(&g);

    printf("\n37x37 grid graph\n");
    printf("==========================================================\n");

    {
        igraph_vector_t dims;

        igraph_vector_init(&dims, 2);
        VECTOR(dims)[0] = 37;
        VECTOR(dims)[1] = 37;

        igraph_lattice(&g, &dims, 1, IGRAPH_UNDIRECTED, 0, 0);

        igraph_vector_init(&bet, 0);
        igraph_betweenness(&g, &bet, igraph_vss_all(), IGRAPH_UNDIRECTED, NULL);
        printf("Max betweenness: %f\n", igraph_vector_max(&bet));

        igraph_vector_destroy(&bet);
        igraph_destroy(&g);
        igraph_vector_destroy(&dims);
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_betweenness.out0000644000175100001710000000302700000000000026402 0ustar00runnerdocker00000000000000BA graph
==========================================================

Tree
==========================================================
Max betweenness: 1155.000000

Non-trivial weighted graph
==========================================================
Max betweenness: 86.000000

Corner case cutoff 0.0
==========================================================
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
104 122 51 51 51 51 18 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
104 122 51 51 51 51 18 0 0 0 0 0 0 0 0 0 0 0 0 0

Single path graph
==========================================================
Cutoff -1
Unweighted
0 3 4 3 0
Weighted
0 3 4 3 0

Cutoff 0
Unweighted
0 0 0 0 0
Weighted
0 0 0 0 0

Cutoff 1
Unweighted
0 0 0 0 0
Weighted
0 0 0 0 0

Cutoff 2
Unweighted
0 1 1 1 0
Weighted
0 1 1 1 0

Cutoff 3
Unweighted
0 2 3 2 0
Weighted
0 2 3 2 0

Cutoff 4
Unweighted
0 3 4 3 0
Weighted
0 3 4 3 0


Cycle graph
==========================================================
Cutoff -1
Unweighted
0.5 0.5 0.5 0.5
Weighted
0 1 0 1

Cutoff 0
Unweighted
0 0 0 0
Weighted
0 0 0 0

Cutoff 1
Unweighted
0 0 0 0
Weighted
0 0 0 0

Cutoff 2
Unweighted
0.5 0.5 0.5 0.5
Weighted
0 1 0 0

Cutoff 3
Unweighted
0.5 0.5 0.5 0.5
Weighted
0 1 0 1

Cutoff 4
Unweighted
0.5 0.5 0.5 0.5
Weighted
0 1 0 1


Null graph
==========================================================
( )

Empty graph
==========================================================
( 0 0 )

37x37 grid graph
==========================================================
Max betweenness: 36094.891693
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_bipartite_game.c0000644000175100001710000000224600000000000026451 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_bool_t bipartite;
    igraph_integer_t n1, n2, m;

    igraph_rng_seed(igraph_rng_default(), 947);

    n1 = 10; n2 = 20; m = 80;
    igraph_bipartite_game(&graph, NULL, IGRAPH_ERDOS_RENYI_GNM,
                          n1, n2, /* p */ 0, m,
                          IGRAPH_UNDIRECTED, IGRAPH_ALL);

    igraph_is_bipartite(&graph, &bipartite, NULL);

    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(! igraph_is_directed(&graph));
    IGRAPH_ASSERT(igraph_vcount(&graph) == n1 + n2);
    IGRAPH_ASSERT(igraph_ecount(&graph) == m);

    igraph_destroy(&graph);

    n1 = 8; n2 = 15;
    igraph_bipartite_game(&graph, NULL, IGRAPH_ERDOS_RENYI_GNP,
                          n1, n2, 0.8, /* m */ 0,
                          IGRAPH_UNDIRECTED, IGRAPH_ALL);

    igraph_is_bipartite(&graph, &bipartite, NULL);

    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(! igraph_is_directed(&graph));
    IGRAPH_ASSERT(igraph_vcount(&graph) == n1 + n2);
    IGRAPH_ASSERT(igraph_ecount(&graph) > 0); /* 0 is exceedingly unlikely */

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_bridges.c0000644000175100001710000000165200000000000025114 0ustar00runnerdocker00000000000000
#include 
#include 

#include "test_utilities.inc"

void sort_and_print_vector(igraph_vector_t *v) {
    long int i, n = igraph_vector_size(v);
    igraph_vector_sort(v);
    for (i = 0; i < n; i++) {
        printf(" %li", (long int) VECTOR(*v)[i]);
    }
    printf("\n");
}

int main() {
    igraph_t graph;
    igraph_vector_t bridges;

    igraph_vector_init(&bridges, 0);

    igraph_small(&graph, /* num_nodes = */ 7, /* directed = */ 0,
                 0, 1, 1, 2, 0, 2, 0, 3, 3, 4, 4, 5, 3, 5, 4, 6, -1);
    igraph_bridges(&graph, &bridges);
    sort_and_print_vector(&bridges);
    igraph_destroy(&graph);

    igraph_small(&graph, /* num_nodes = */ 3, /* directed = */ 0,
                 0, 1, 0, 1, 1, 2, 2, 2, -1);
    igraph_bridges(&graph, &bridges);
    sort_and_print_vector(&bridges);
    igraph_destroy(&graph);

    igraph_vector_destroy(&bridges);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_bridges.out0000644000175100001710000000001000000000000025464 0ustar00runnerdocker00000000000000 3 7
 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_callaway_traits_game.c0000644000175100001710000001011500000000000027643 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void init_vm(igraph_vector_t *type_dist,
             int v0, int v1,
             igraph_matrix_t *pref_matrix,
             int m00, int m10, int m01, int m11) {
    igraph_vector_init_int_end(type_dist, -1, v0, v1, -1);
    igraph_matrix_init(pref_matrix, 2, 2);
    MATRIX(*pref_matrix, 0, 0) = m00;
    MATRIX(*pref_matrix, 1, 0) = m10;
    MATRIX(*pref_matrix, 0, 1) = m01;
    MATRIX(*pref_matrix, 1, 1) = m11;
}

#define DESTROY_GVM() do {               \
    igraph_destroy(&g);                  \
    igraph_vector_destroy(&type_dist);   \
    igraph_matrix_destroy(&pref_matrix); \
    } while(0)

int main() {
    igraph_t g;
    igraph_vector_t type_dist, node_types;
    igraph_matrix_t pref_matrix;
    igraph_bool_t bipartite;

    igraph_rng_seed(igraph_rng_default(), 42);

    /*Zero matrix elements for only possible vertex type means no edges*/
    init_vm(&type_dist, 1, 0, &pref_matrix, 0, 0, 0, 1);
    IGRAPH_ASSERT(igraph_callaway_traits_game(&g, /*nodes*/ 20, /*types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 0, NULL) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(igraph_vcount(&g) == 20);
    DESTROY_GVM();

    /*No vertices*/
    init_vm(&type_dist, 1, 0, &pref_matrix, 0, 0, 0, 1);
    IGRAPH_ASSERT(igraph_callaway_traits_game(&g, /*nodes*/ 0, /*types*/ 2, /*edges_per_step*/ 0, &type_dist, &pref_matrix, /*directed*/ 0, NULL) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    DESTROY_GVM();

    /*Two types with only cross terms makes a bipartite graph*/
    init_vm(&type_dist, 2, 1, &pref_matrix, 0, 1, 1, 0);
    igraph_vector_init(&node_types, 0);
    IGRAPH_ASSERT(igraph_callaway_traits_game(&g, /*nodes*/ 20, /*types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 1, &node_types) == IGRAPH_SUCCESS);
    igraph_is_bipartite(&g, &bipartite, NULL);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vector_size(&node_types) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_min(&node_types) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&node_types) == 1);
    igraph_vector_destroy(&node_types);
    DESTROY_GVM();

    /*Automatically determined type_dist*/
    init_vm(&type_dist, 0, 0, &pref_matrix, 0, 1, 1, 0);
    igraph_vector_init(&node_types, 0);
    IGRAPH_ASSERT(igraph_callaway_traits_game(&g, /*nodes*/ 20, /*types*/ 2, /*edges_per_step*/ 3, /*type_dist*/ NULL, &pref_matrix, /*directed*/ 0, &node_types) == IGRAPH_SUCCESS);
    igraph_is_bipartite(&g, &bipartite, NULL);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vector_size(&node_types) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_min(&node_types) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&node_types) == 1);
    igraph_vector_destroy(&node_types);
    DESTROY_GVM();

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /*Distribution of types should have at least one positive value*/
    init_vm(&type_dist, 0, 0, &pref_matrix, 0, 1, 1, 0);
    IGRAPH_ASSERT(igraph_callaway_traits_game(&g, /*nodes*/ 20, /* types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 0, NULL) == IGRAPH_EINVAL);
    DESTROY_GVM();

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_cited_type_game.c0000644000175100001710000001147200000000000026620 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t pref, types;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No nodes:\n");
    igraph_vector_init_int(&pref, 2, 1, 1);
    igraph_vector_init_int(&types, 0);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 0, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("No edges:\n");
    igraph_vector_init_int(&pref, 2, 1, 1);
    igraph_vector_init_int(&types, 3, 1, 1, 1);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 3, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 0, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Make a star of double edges:\n");
    igraph_vector_init_real(&pref, 3, 1.0, 0.0, 0.0);
    igraph_vector_init_int(&types, 5, 0, 1, 1, 1, 1);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 5, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 2, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Make a line:\n");
    igraph_vector_init_real(&pref, 7, 1.0e-30, 1.0e-20, 1.0e-10, 1.0, 1.0e+10, 1.0e+20, 0.0);
    igraph_vector_init_int(&types, 7, 0, 1, 2, 3, 4, 5, 6);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 7, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 1, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking negative number of nodes error handling.\n");
    igraph_vector_init_real(&pref, 2, 1.0, 1.0);
    igraph_vector_init_int(&types, 2, 0, 1);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ -5, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Checking too few types error handling.\n");
    igraph_vector_init_real(&pref, 1, 1.0);
    igraph_vector_init_int(&types, 0);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 1, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Checking too many types error handling.\n");
    igraph_vector_init_real(&pref, 3, 1.0, 1.0, 1.0);
    igraph_vector_init_int(&types, 2, 0, 1);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 1, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Checking negative type for error handling.\n");
    igraph_vector_init_real(&pref, 2, 1.0, 1.0);
    igraph_vector_init_int(&types, 2, 0, -5);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 2, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Checking too big type for error handling.\n");
    igraph_vector_init_real(&pref, 2, 1.0, 1.0);
    igraph_vector_init_int(&types, 2, 0, 5);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 2, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    printf("Checking negative preference error handling.\n");
    igraph_vector_init_real(&pref, 2, 1.0, -1.0);
    igraph_vector_init_int(&types, 2, 0, 1);
    IGRAPH_ASSERT(igraph_cited_type_game(&g, /*nodes*/ 2, /*types*/ &types, /*pref*/ &pref, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&pref);
    igraph_vector_destroy(&types);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_cited_type_game.out0000644000175100001710000000101300000000000027173 0ustar00runnerdocker00000000000000No nodes:
directed: false
vcount: 0
edges: {
}
No edges:
directed: false
vcount: 3
edges: {
}
Make a star of double edges:
directed: true
vcount: 5
edges: {
1 0
1 0
2 0
2 0
3 0
3 0
4 0
4 0
}
Make a line:
directed: true
vcount: 7
edges: {
1 0
2 1
3 2
4 3
5 4
6 5
}
Checking negative number of nodes error handling.
Checking too few types error handling.
Checking too many types error handling.
Checking negative type for error handling.
Checking too big type for error handling.
Checking negative preference error handling.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_citing_cited_type_game.c0000644000175100001710000000667700000000000030170 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_matrix_t pref_empty, pref_bipartite, pref_line;
    igraph_vector_t types_empty, types_bipartite, types_line;
    igraph_bool_t bipartite;
    int bipartite_elem[] = {0, 1, 1, 0};
    int line_elem[] = {0, 0, 1, 0, 0,
                       1, 0, 0, 0, 0,
                       0, 1, 0, 0, 0,
                       0, 0, 1, 0, 0,
                       0, 0, 0, 1, 0,
    };

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_matrix_init(&pref_empty, 0, 0);
    igraph_vector_init(&types_empty, 0);

    matrix_init_int_row_major(&pref_bipartite, 2, 2, bipartite_elem);
    igraph_vector_init_int(&types_bipartite, 10, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0);

    matrix_init_int_row_major(&pref_line, 5, 5, line_elem);
    igraph_vector_init_int(&types_line, 5, 0, 1, 2, 3, 4);

    printf("No nodes.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 0, &types_empty, &pref_empty, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);

    printf("Bipartite graph.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 10, &types_bipartite, &pref_bipartite, /*edges_per_step*/ 5, /*directed*/ 0) == IGRAPH_SUCCESS);
    igraph_is_bipartite(&g, &bipartite, NULL);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 45);
    igraph_destroy(&g);

    printf("No edges.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 10, &types_bipartite, &pref_bipartite, /*edges_per_step*/ 0, /*directed*/ 0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    igraph_destroy(&g);

    printf("A line.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 5, &types_line, &pref_line, /*edges_per_step*/ 1, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Too few types for nodes.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 5, &types_empty, &pref_empty, /*edges_per_step*/ 1, /*directed*/ 1) == IGRAPH_EINVAL);

    printf("Too few prefs.\n");
    IGRAPH_ASSERT(igraph_citing_cited_type_game(&g, /*nodes*/ 5, &types_line, &pref_empty, /*edges_per_step*/ 1, /*directed*/ 1) == IGRAPH_EINVAL);

    igraph_matrix_destroy(&pref_empty);
    igraph_vector_destroy(&types_empty);
    igraph_matrix_destroy(&pref_bipartite);
    igraph_vector_destroy(&types_bipartite);
    igraph_matrix_destroy(&pref_line);
    igraph_vector_destroy(&types_line);
    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_citing_cited_type_game.out0000644000175100001710000000021100000000000030527 0ustar00runnerdocker00000000000000No nodes.
Bipartite graph.
No edges.
A line.
directed: true
vcount: 5
edges: {
1 0
2 1
3 2
4 3
}
Too few types for nodes.
Too few prefs.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_clique_size_hist.c0000644000175100001710000000335100000000000027036 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_t *g, int min, int max) {
    igraph_vector_t result;
    igraph_vector_init(&result, 0);
    IGRAPH_ASSERT(igraph_clique_size_hist(g, &result, min, max) == IGRAPH_SUCCESS);
    print_vector(&result);
    igraph_vector_destroy(&result);
}


int main() {
    igraph_t g_empty, g_lm;

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,2, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    print_and_destroy(&g_empty, 0, 0);

    printf("Graph with loops and multiple edges:\n");
    print_and_destroy(&g_lm, 0, 0);

    printf("Same graph, minimum clique size 2:\n");
    print_and_destroy(&g_lm, 2, 0);

    printf("Same graph, maximum clique size 2:\n");
    print_and_destroy(&g_lm, 0, 2);

    printf("Same graph, minimum and maximum clique size 10:\n");
    print_and_destroy(&g_lm, 10, 10);

    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_clique_size_hist.out0000644000175100001710000000031400000000000027417 0ustar00runnerdocker00000000000000No vertices:
( )
Graph with loops and multiple edges:
( 6 6 2 )
Same graph, minimum clique size 2:
( 0 6 2 )
Same graph, maximum clique size 2:
( 6 6 )
Same graph, minimum and maximum clique size 10:
( )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_closeness.c0000644000175100001710000002545600000000000025503 0ustar00runnerdocker00000000000000#include 
#include 
#include "test_utilities.inc"


void simple_test_case_no_weights_undirected() {

    igraph_t g;
    igraph_vector_t vector_actual_results;

    printf("Simple test case, no weights, undirected\n");

    igraph_vector_init(&vector_actual_results, 0);

    igraph_small(&g, 0, IGRAPH_DIRECTED, 0,1 , 1,2, -1);

    /* NOT NORMALISED TEST BELOW */

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      NULL /*unweighted*/, /*not normalised*/ 0);

    printf("Non normalised results below\n");
    print_vector(&vector_actual_results);

    /* NORMALISED TEST BELOW */

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      NULL, /*normalised*/ 1);

    printf("\nNormalised results below\n");
    print_vector(&vector_actual_results);

    igraph_vector_destroy(&vector_actual_results);
    igraph_destroy(&g);
}

void simple_test_case_with_weights_undirected() {

    igraph_t g;
    igraph_vector_t vector_edges, vector_weights, vector_actual_results;

    igraph_real_t real_edges[] = {0,1 , 1,2};
    igraph_real_t real_weights[] = {3, 5};

    printf("\nSimple test case, with weights, undirected\n");

    igraph_vector_init(&vector_actual_results, 0);
    igraph_vector_view(&vector_edges, real_edges, sizeof(real_edges)/sizeof(igraph_real_t));
    igraph_create(&g, &vector_edges, /*number of vertices*/ 2, IGRAPH_DIRECTED);

    igraph_vector_view(&vector_weights, real_weights,
                       sizeof(real_weights)/sizeof(igraph_real_t));

    /* NOT NORMALISED TEST BELOW */

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      &vector_weights, /*not normalised*/ 0);

    printf("Non normalised test below\n");

    print_vector(&vector_actual_results);

    /* NORMALISED TEST BELOW */

    printf("\nNormalised test below\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      &vector_weights, /*normalised*/ 1);

    print_vector(&vector_actual_results);

    igraph_vector_destroy(&vector_actual_results);
    igraph_destroy(&g);
}

void advanced_test_case_no_weights_undirected() {

    igraph_t g;
    igraph_vector_t vector_actual_results;

    /* note, denominatory calculated as (shortest dist)*(n-1) for no normalisation
    normalisation excludes n-1 as part of the denominator */

    printf("\nAdvanced test case, no weights, undirected\n");

    igraph_vector_init(&vector_actual_results, 0);

    igraph_small(&g, 0, IGRAPH_DIRECTED, 1,0 , 0,5 , 5,6 , 5,4, 4,1 , 1,2 , 2,4 , 4,6 ,
                                 2,3 , 3,7 , 7,6 , 2,6 , -1);

    /* NOT NORMALISED TEST BELOW*/

    printf("Non normalised test below\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      NULL, /*not normalised*/ 0);

    print_vector(&vector_actual_results);

    /* NORMALISED TEST BELOW*/

    printf("\nNormalised test below\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      NULL, /*normalised*/ 1);

    print_vector(&vector_actual_results);

    igraph_vector_destroy(&vector_actual_results);
    igraph_destroy(&g);
}

void advanced_test_case_with_weights() {

    igraph_t g;
    igraph_vector_t vector_edges, vector_weights, vector_actual_results;

    igraph_real_t real_edges[] = {1,0 , 0,5 , 5,6 , 5,4, 4,1 , 1,2 , 2,4 , 4,6 ,
                                 2,3 , 3,7 , 7,6 , 6,2};

    igraph_real_t real_weights[] = {4, 9, 2, 2, 2, 3, 1, 1, 8, 7, 5, 5};

    printf("\nAdvanced test case, with weights\n");


    igraph_vector_init(&vector_actual_results, 0);
    igraph_vector_view(&vector_edges, real_edges, sizeof(real_edges)/sizeof(igraph_real_t));
    igraph_create(&g, &vector_edges, /*number of vertices*/ 2, IGRAPH_DIRECTED);

    igraph_vector_view(&vector_weights, real_weights, sizeof(real_weights)/sizeof(igraph_real_t));

    /* TEST FOR UNDIRECTED GRAPH */

    printf("Undirected graph test below\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_ALL  /*graph is "undirected"*/,
                      &vector_weights, /*not normalised*/ 0);

    print_vector(&vector_actual_results);

    /* TEST FOR DIRECTED GRAPH
    OUT means the min distance from the curr node to the other node */

    printf("\nDirected graph test below for OUT\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_OUT  /*graph is "out directed"*/,
                      &vector_weights, /*not normalised*/ 0);

    print_vector(&vector_actual_results);

    /* IN means the min distance from a node to the curr node */

    printf("\nDirected graph test below for IN\n");

    igraph_closeness(&g, &vector_actual_results /*store results here*/,
                      NULL, NULL,
                      /*calculating for all vectors in the graph*/ igraph_vss_all(),
                      IGRAPH_IN  /*graph is "in directed"*/,
                      &vector_weights, /*not normalised*/ 0);

    print_vector(&vector_actual_results);

    igraph_vector_destroy(&vector_actual_results);
    igraph_destroy(&g);
}

void test_cutoff() {

    igraph_t g;
    igraph_vector_t closeness, reachable;
    igraph_bool_t all_reachable;
    size_t i;
    igraph_real_t cutoff_vec[] = { -1.0, 0.0, 1.0, 2.9, 3.0, 3.1 };

    printf("\n\nUnweighted undirected with cutoff\n");

    igraph_ring(&g, 4, IGRAPH_UNDIRECTED, 0, 0);

    igraph_vector_init(&closeness, 0);
    igraph_vector_init(&reachable, 0);

    for (i=0; i < sizeof(cutoff_vec) / sizeof(igraph_real_t); ++i) {
        printf("\nRange-limited closeness with cutoff %g\n", cutoff_vec[i]);
        igraph_closeness_cutoff(&g, &closeness, &reachable, &all_reachable,
                                igraph_vss_all(), IGRAPH_ALL, NULL, /* normalized */ 1,
                                cutoff_vec[i]);
        printf("Closeness: ");
        print_vector(&closeness);
        printf("Reachable: ");
        print_vector_round(&reachable);
        printf("All reachable: %s\n", all_reachable ? "true" : "false");
    }

    igraph_vector_destroy(&reachable);
    igraph_vector_destroy(&closeness);

    igraph_destroy(&g);
}

void test_cutoff_directed() {

    igraph_t g;
    igraph_vector_t closeness, reachable;
    igraph_bool_t all_reachable;
    size_t i;
    igraph_real_t cutoff_vec[] = { -1.0, 0.0, 1.0, 2.9, 3.0, 3.1 };

    printf("\n\nUnweighted directed with cutoff\n");

    igraph_ring(&g, 4, IGRAPH_DIRECTED, 0, 0);

    igraph_vector_init(&closeness, 0);
    igraph_vector_init(&reachable, 0);

    for (i=0; i < sizeof(cutoff_vec) / sizeof(igraph_real_t); ++i) {
        printf("\nRange-limited directed closeness with cutoff %g\n", cutoff_vec[i]);
        igraph_closeness_cutoff(&g, &closeness, &reachable, &all_reachable,
                                igraph_vss_all(), IGRAPH_OUT, NULL, /* normalized */ 1,
                                cutoff_vec[i]);
        printf("Closeness: ");
        print_vector(&closeness);
        printf("Reachable: ");
        print_vector_round(&reachable);
        printf("All reachable: %s\n", all_reachable ? "true" : "false");
    }

    igraph_vector_destroy(&reachable);
    igraph_vector_destroy(&closeness);

    igraph_destroy(&g);
}

void test_cutoff_weighted() {

    igraph_t g;
    igraph_vector_t closeness, reachable;
    igraph_bool_t all_reachable;
    size_t i;
    igraph_real_t cutoff_vec[] = { -1.0, 0.0, 1.0, 2.9, 3.0, 5.0, 6.0 };
    igraph_vector_t weights;

    printf("\n\nWeighted undirected with cutoff\n");

    igraph_ring(&g, 4, IGRAPH_UNDIRECTED, 0, 0);

    igraph_vector_init(&closeness, 0);
    igraph_vector_init(&reachable, 0);
    igraph_vector_init_seq(&weights, 1, 3);

    for (i=0; i < sizeof(cutoff_vec) / sizeof(igraph_real_t); ++i) {
        printf("\nRange-limited weighted closeness with cutoff %g\n", cutoff_vec[i]);
        igraph_closeness_cutoff(&g, &closeness, &reachable, &all_reachable,
                                igraph_vss_all(), IGRAPH_ALL, &weights, /* normalized */ 1,
                                cutoff_vec[i]);
        printf("Closeness: ");
        print_vector(&closeness);
        printf("Reachable: ");
        print_vector_round(&reachable);
        printf("All reachable: %s\n", all_reachable ? "true" : "false");
    }

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&reachable);
    igraph_vector_destroy(&closeness);

    igraph_destroy(&g);
}

void test_edge_cases() {

    igraph_t g;
    igraph_vector_t closeness, reachable;
    igraph_bool_t all_reachable;
    int n;

    printf("\n\nEdgeless graphs\n");

    igraph_vector_init(&closeness, 0);
    igraph_vector_init(&reachable, 0);

    for (n=0; n <= 2; ++n) {
        printf("\nEdgeless graph with %d vertices\n", n);
        igraph_empty(&g, n, IGRAPH_UNDIRECTED);

        igraph_closeness(&g, &closeness, &reachable, &all_reachable, igraph_vss_all(), IGRAPH_ALL, NULL, 1);
        printf("Closeness: ");
        print_vector(&closeness);
        printf("Reachable: ");
        print_vector_round(&reachable);
        printf("All reachable: %s\n", all_reachable ? "true" : "false");

        igraph_destroy(&g);
    }

    igraph_vector_destroy(&reachable);
    igraph_vector_destroy(&closeness);

}

int main() {

    simple_test_case_no_weights_undirected();
    simple_test_case_with_weights_undirected();
    advanced_test_case_no_weights_undirected();
    advanced_test_case_with_weights();

    test_cutoff();
    test_cutoff_directed();
    test_cutoff_weighted();

    test_edge_cases();

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_closeness.out0000644000175100001710000000703200000000000026056 0ustar00runnerdocker00000000000000Simple test case, no weights, undirected
Non normalised results below
( 0.333333 0.5 0.333333 )

Normalised results below
( 0.666667 1 0.666667 )

Simple test case, with weights, undirected
Non normalised test below
( 0.0909091 0.125 0.0769231 )

Normalised test below
( 0.181818 0.25 0.153846 )

Advanced test case, no weights, undirected
Non normalised test below
( 0.0714286 0.0833333 0.1 0.0714286 0.1 0.0833333 0.1 0.0714286 )

Normalised test below
( 0.5 0.583333 0.7 0.5 0.7 0.583333 0.7 0.5 )

Advanced test case, with weights
Undirected graph test below
( 0.0169492 0.0285714 0.0322581 0.0140845 0.037037 0.027027 0.0333333 0.0192308 )

Directed graph test below for OUT
( 0.00869565 0.0172414 0.0192308 0.00763359 0.016129 0.0166667 0.0117647 0.01 )

Directed graph test below for IN
( 0.0128205 0.015873 0.015873 0.00980392 0.0188679 0.0075188 0.0263158 0.0075188 )


Unweighted undirected with cutoff

Range-limited closeness with cutoff -1
Closeness: ( 0.5 0.75 0.75 0.5 )
Reachable: ( 3 3 3 3 )
All reachable: true

Range-limited closeness with cutoff 0
Closeness: ( NaN NaN NaN NaN )
Reachable: ( 0 0 0 0 )
All reachable: false

Range-limited closeness with cutoff 1
Closeness: ( 1 1 1 1 )
Reachable: ( 1 2 2 1 )
All reachable: false

Range-limited closeness with cutoff 2.9
Closeness: ( 0.666667 0.75 0.75 0.666667 )
Reachable: ( 2 3 3 2 )
All reachable: false

Range-limited closeness with cutoff 3
Closeness: ( 0.5 0.75 0.75 0.5 )
Reachable: ( 3 3 3 3 )
All reachable: true

Range-limited closeness with cutoff 3.1
Closeness: ( 0.5 0.75 0.75 0.5 )
Reachable: ( 3 3 3 3 )
All reachable: true


Unweighted directed with cutoff

Range-limited directed closeness with cutoff -1
Closeness: ( 0.5 0.666667 1 NaN )
Reachable: ( 3 2 1 0 )
All reachable: false

Range-limited directed closeness with cutoff 0
Closeness: ( NaN NaN NaN NaN )
Reachable: ( 0 0 0 0 )
All reachable: false

Range-limited directed closeness with cutoff 1
Closeness: ( 1 1 1 NaN )
Reachable: ( 1 1 1 0 )
All reachable: false

Range-limited directed closeness with cutoff 2.9
Closeness: ( 0.666667 0.666667 1 NaN )
Reachable: ( 2 2 1 0 )
All reachable: false

Range-limited directed closeness with cutoff 3
Closeness: ( 0.5 0.666667 1 NaN )
Reachable: ( 3 2 1 0 )
All reachable: false

Range-limited directed closeness with cutoff 3.1
Closeness: ( 0.5 0.666667 1 NaN )
Reachable: ( 3 2 1 0 )
All reachable: false


Weighted undirected with cutoff

Range-limited weighted closeness with cutoff -1
Closeness: ( 0.3 0.375 0.375 0.214286 )
Reachable: ( 3 3 3 3 )
All reachable: true

Range-limited weighted closeness with cutoff 0
Closeness: ( NaN NaN NaN NaN )
Reachable: ( 0 0 0 0 )
All reachable: false

Range-limited weighted closeness with cutoff 1
Closeness: ( 1 1 NaN NaN )
Reachable: ( 1 1 0 0 )
All reachable: false

Range-limited weighted closeness with cutoff 2.9
Closeness: ( 1 0.666667 0.5 NaN )
Reachable: ( 1 2 1 0 )
All reachable: false

Range-limited weighted closeness with cutoff 3
Closeness: ( 0.5 0.666667 0.375 0.333333 )
Reachable: ( 2 2 3 1 )
All reachable: false

Range-limited weighted closeness with cutoff 5
Closeness: ( 0.5 0.375 0.375 0.25 )
Reachable: ( 2 3 3 2 )
All reachable: false

Range-limited weighted closeness with cutoff 6
Closeness: ( 0.3 0.375 0.375 0.214286 )
Reachable: ( 3 3 3 3 )
All reachable: true


Edgeless graphs

Edgeless graph with 0 vertices
Closeness: ( )
Reachable: ( )
All reachable: true

Edgeless graph with 1 vertices
Closeness: ( NaN )
Reachable: ( 0 )
All reachable: true

Edgeless graph with 2 vertices
Closeness: ( NaN NaN )
Reachable: ( 0 0 )
All reachable: false
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_cohesion.c0000644000175100001710000000254400000000000025305 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_integer_t value;
    igraph_bool_t checks = 1;

    igraph_small(&g, 7, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, 1, 6, 6, 3, 5, 0, -1);

    igraph_cohesion(&g, &value, checks);

    IGRAPH_ASSERT(value == 1);

    igraph_destroy(&g);

    igraph_small(&g, 7, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, 1, 6, 6, 3, -1);

    igraph_cohesion(&g, &value, checks);

    IGRAPH_ASSERT(value == 2);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_community_infomap.c0000644000175100001710000003165400000000000027237 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"


void gsummary(const igraph_t * g) {
    printf("|V|=%d |E|=%d directed=%d\n", (int)igraph_vcount(g), (int)igraph_ecount(g), (int)igraph_is_directed(g));
}

void show_results(igraph_vector_t * membership, igraph_real_t codelength) {
    int i;
    printf("Codelength: %0.5f (in %d modules)\n", codelength, (int)igraph_vector_max(membership) + 1 );
    printf("Membership: ");
    for (i = 0; i < igraph_vector_size(membership); i++) {
        printf("%li ", (long)VECTOR(*membership)[i] );
    }
    printf("\n");
}

void show_results_lite(igraph_vector_t * membership, igraph_real_t codelength) {
    int i;
    printf("Codelength: %0.5f (in %d modules)\n", codelength, (int)igraph_vector_max(membership) + 1 );
    printf("Membership (1/100 of vertices): ");
    for (i = 0; i < igraph_vector_size(membership); i += 100) {
        printf("%li ", (long)VECTOR(*membership)[i] );
    }
    printf("\n");
}

igraph_real_t infomap_weighted_test(const igraph_t * g, const igraph_vector_t *weights, igraph_bool_t smoke_test) {
    igraph_vector_t membership;
    igraph_real_t codelength = 1000;
    igraph_vector_init(&membership, 0);

    igraph_community_infomap(/*in */ g, /*e_weight=*/ weights, NULL, /*nb_trials=*/5,
                                     /*out*/ &membership, &codelength);
    if (!smoke_test) {
        if (igraph_vcount(g) > 500) {
            show_results_lite(&membership, codelength);
        } else {
            show_results(&membership, codelength);
        }
    }

    igraph_vector_destroy(&membership);

    return codelength;
}


igraph_real_t infomap_test(const igraph_t * g, igraph_bool_t smoke_test) {
    return infomap_weighted_test(g, 0, smoke_test);
}


int main() {
    igraph_t g;
    igraph_vector_t weights;
    igraph_real_t codelength;
    FILE *wikt;

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Two triangles connected by one edge */
    printf("# Two triangles connected by one edge\n");
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 0,
                 3, 4, 4, 5, 5, 3,
                 0, 5,
                 -1);
    infomap_test(&g, /* smoke_test = */ 0);
    igraph_destroy(&g);

    /* Two 4-cliques with one commun vertex (vertex 3) */
    printf("# Two 4-cliques (0123 and 4567) connected by two edges (0-4 and 1-5)\n");
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1,  0, 2,  0, 3,  1, 2,  1, 3,  2, 3, /* 4-clique 0,1,2,3 */
                 7, 4,  7, 5,  7, 6,  4, 5,  4, 6,  5, 6, /* 4-clique 4,5,6,7 */
                 0, 4,  1, 5, /* 8, 0, 8, 4, */
                 -1);
    infomap_test(&g, /* smoke_test = */ 0);

    printf("# Two 4-cliques (0123 and 4567) connected by two edges (0-4 and 1-5)\n");
    igraph_add_edge(&g, 0, 4);
    igraph_add_edge(&g, 1, 5);
    infomap_test(&g, /* smoke_test = */ 0);
    igraph_destroy(&g);

    /* Zachary Karate club -- this is just a quick smoke test */
    printf("# Zachary Karate club\n");
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5, /* 0,  5, 0,  5, 0,  5, */
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);
    infomap_test(&g, /* smoke_test = */ 0);
    igraph_destroy(&g);

    /* Flow.net that come in infomap_dir.tgz  */
    printf("# Flow (from infomap_dir.tgz)\n");
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0, 1,     1, 2,    2, 3,    3, 0,    1, 4,
                 4, 5,     5, 6,    6, 7,    7, 4,    5, 8,
                 8, 9,     9, 10,  10, 11,  11, 8,    9, 12,
                 12, 13,  13, 14,  14, 15,  15, 12,  13, 0,
                 -1);
    infomap_test(&g, /* smoke_test = */ 0);
    igraph_destroy(&g);

    /* MultiphysChemBioEco40W_weighted_dir.net */
    printf("# MultiphysChemBioEco40W_weighted_dir.net (from infomap_dir.tgz)\n");
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 1, 0,  2, 0,  3, 0,  4, 0,  5, 0,  6, 0,  7, 0,
                 8, 0,  9, 0,  16, 0,  18, 0,  0, 1,  2, 1,  3, 1,
                 5, 1,  6, 1,  7, 1,  9, 1,  10, 1,  16, 1,  18, 1,
                 0, 2,  3, 2,  4, 2,  5, 2,  6, 2,  7, 2,  0, 3,
                 1, 3,  2, 3,  4, 3,  5, 3,  6, 3,  7, 3,  8, 3,
                 9, 3,  10, 3,  11, 3,  13, 3,  14, 3,  16, 3,  17, 3,
                 18, 3,  19, 3,  26, 3,  30, 3,  1, 4,  3, 4,  5, 4,
                 6, 4,  13, 4,  18, 4,  0, 5,  1, 5,  2, 5,  3, 5,
                 6, 5,  7, 5,  9, 5,  1, 6,  3, 6,  7, 6,  9, 6,
                 16, 6,  0, 7,  1, 7,  2, 7,  3, 7,  5, 7,  6, 7,
                 9, 7,  3, 8,  5, 8,  3, 9,  7, 9,  12, 10,  13, 10,
                 14, 10,  15, 10,  16, 10,  17, 10,  18, 10,  19, 10,
                 21, 10,  3, 11,  18, 11,  10, 12,  14, 12,  16, 12,
                 17, 12,  18, 12,  3, 13,  10, 13,  14, 13,  16, 13,
                 10, 14,  12, 14,  13, 14,  15, 14,  16, 14,  17, 14,
                 18, 14,  10, 15,  14, 15,  18, 15,  0, 16,  2, 16,
                 3, 16,  6, 16,  10, 16,  12, 16,  13, 16,  14, 16,
                 17, 16,  18, 16,  10, 17,  12, 17,  14, 17,  18, 17,
                 3, 18,  10, 18,  12, 18,  14, 18,  15, 18,  16, 18,
                 17, 18,  19, 18,  21, 18,  11, 19,  16, 19,  17, 19,
                 16, 20,  18, 20,  21, 20,  22, 20,  23, 20,  24, 20,
                 25, 20,  26, 20,  27, 20,  28, 20,  29, 20,  3, 21,
                 14, 21,  18, 21,  20, 21,  22, 21,  23, 21,  24, 21,
                 25, 21,  26, 21,  27, 21,  28, 21,  29, 21,  35, 21,
                 36, 21,  38, 21,  18, 22,  20, 22,  21, 22,  23, 22,
                 24, 22,  25, 22,  26, 22,  27, 22,  29, 22,  3, 23,
                 20, 23,  21, 23,  22, 23,  24, 23,  25, 23,  26, 23,
                 27, 23,  28, 23,  29, 23,  35, 23,  38, 23,  39, 23,
                 20, 24,  21, 24,  23, 24,  25, 24,  26, 24,  27, 24,
                 28, 24,  29, 24,  9, 25,  20, 25,  21, 25,  22, 25,
                 23, 25,  24, 25,  26, 25,  27, 25,  28, 25,  29, 25,
                 18, 26,  20, 26,  21, 26,  22, 26,  23, 26,  25, 26,
                 27, 26,  28, 26,  29, 26,  30, 26,  32, 26,  35, 26,
                 36, 26,  38, 26,  39, 26,  3, 27,  14, 27,  20, 27,
                 21, 27,  22, 27,  23, 27,  24, 27,  25, 27,  26, 27,
                 28, 27,  29, 27,  38, 27,  3, 28,  18, 28,  20, 28,
                 21, 28,  23, 28,  24, 28,  25, 28,  26, 28,  27, 28,
                 29, 28,  35, 28,  14, 29,  16, 29,  18, 29,  20, 29,
                 21, 29,  22, 29,  23, 29,  24, 29,  25, 29,  26, 29,
                 27, 29,  28, 29,  31, 30,  32, 30,  33, 30,  34, 30,
                 35, 30,  36, 30,  38, 30,  39, 30,  30, 31,  32, 31,
                 34, 31,  36, 31,  30, 32,  34, 32,  35, 32,  36, 32,
                 30, 33,  32, 33,  34, 33,  35, 33,  36, 33,  38, 33,
                 30, 34,  31, 34,  32, 34,  33, 34,  35, 34,  36, 34,
                 38, 34,  39, 34,  26, 35,  30, 35,  32, 35,  33, 35,
                 34, 35,  36, 35,  38, 35,  39, 35,  30, 36,  34, 36,
                 35, 36,  38, 36,  39, 36,  34, 37,  26, 38,  30, 38,
                 32, 38,  33, 38,  34, 38,  35, 38,  36, 38,  39, 38,
                 26, 39,  30, 39,  33, 39,  34, 39,  35, 39,  36, 39,
                 38, 39,
                 -1);
    igraph_vector_init_real(&weights, 306,
                            5.0,  3.0,  130.0,  4.0,  15.0,  9.0,
                            7.0,  1.0,  1.0,  3.0,  1.0,  1.0,
                            1.0,  34.0,  38.0,  2.0,  23.0,  1.0,
                            1.0,  3.0,  2.0,  2.0,  16.0,  1.0,
                            3.0,  1.0,  3.0,  63.0,  92.0,  72.0,
                            25.0,  447.0,  121.0,  65.0,  4.0,  16.0,
                            35.0,  1.0,  19.0,  1.0,  78.0,  1.0,
                            45.0,  1.0,  3.0,  1.0,  1.0,  25.0,
                            1.0,  3.0,  1.0,  1.0,  3.0,  36.0,
                            19.0,  136.0,  41.0,  96.0,  1.0,  7.0,
                            26.0,  1.0,  2.0,  2.0,  3.0,  2.0,  2.0,
                            23.0,  52.0,  4.0,  1.0,  2.0,  1.0,  3.0,
                            1.0,  11.0,  2.0,  17.0,  1.0,  5.0,  18.0,
                            86.0,  5.0,  1.0,  1.0,  1.0,  6.0,  1.0,
                            2.0,  2.0,  20.0,  4.0,  5.0,  1.0,  5.0,
                            12.0,  4.0,  1.0,  1.0,  4.0,  9.0,  40.0,
                            2.0,  1.0,  4.0,  1.0,  1.0,  48.0,  2.0,
                            18.0,  1.0,  7.0,  2.0,  2.0,  53.0,  25.0,
                            9.0,  1.0,  23.0,  8.0,  62.0,  29.0,  35.0,
                            4.0,  34.0,  35.0,  3.0,  1.0,  24.0,  1.0,
                            6.0,  2.0,  2.0,  22.0,  7.0,  2.0,  5.0,
                            14.0,  3.0,  28.0,  14.0,  20.0,  3.0,  1.0,
                            5.0,  77.0,  20.0,  25.0,  35.0,  55.0,  35.0,
                            115.0,  68.0,  105.0,  2.0,  2.0,  2.0,  4.0,
                            2.0,  17.0,  12.0,  3.0,  3.0,  11.0,  10.0,
                            7.0,  2.0,  12.0,  31.0,  11.0,  5.0,  11.0,
                            65.0,  39.0,  17.0,  26.0,  3.0,  4.0,  2.0,
                            3.0,  6.0,  4.0,  8.0,  1.0,  7.0,  7.0,
                            6.0,  1.0,  39.0,  42.0,  9.0,  6.0,  9.0,
                            5.0,  45.0,  43.0,  26.0,  1.0,  2.0,  6.0,
                            2.0,  15.0,  3.0,  9.0,  2.0,  1.0,  1.0,
                            1.0,  4.0,  2.0,  9.0,  2.0,  1.0,  2.0,
                            28.0,  80.0,  10.0,  18.0,  13.0,  17.0,
                            28.0,  40.0,  76.0,  1.0,  2.0,  1.0,  11.0,
                            37.0,  5.0,  11.0,  14.0,  4.0,  14.0,  10.0,
                            1.0,  1.0,  1.0,  1.0,  41.0,  121.0,  6.0,
                            21.0,  12.0,  30.0,  6.0,  141.0,  43.0,  2.0,
                            12.0,  6.0,  35.0,  10.0,  7.0,  2.0,  12.0,
                            6.0,  2.0,  11.0,  1.0,  7.0,  6.0,  5.0,  3.0,
                            1.0,  2.0,  1.0,  1.0,  1.0,  1.0,  67.0,  9.0,
                            9.0,  11.0,  10.0,  21.0,  7.0,  12.0,  9.0,
                            16.0,  7.0,  4.0,  11.0,  17.0,  37.0,  32.0,
                            9.0,  2.0,  2.0,  5.0,  4.0,  2.0,  7.0,  3.0,
                            3.0,  5.0,  8.0,  14.0,  3.0,  38.0,  3.0,  9.0,
                            2.0,  8.0,  21.0,  18.0,  58.0);
    infomap_weighted_test(&g, &weights, /* smoke_test = */ 0);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* Wiktionary English verbs -- this one is a bit flaky, igraph reports
     * 1444 or 1445 modules, depending on the platform, so let's just run it as
     * a quick smoke test but don't check the results too thoroughly as some
     * changes are expected. We only check the codelength of the partition,
     * this is more reliable. */
    printf("# Wiktionary english verbs (synonymy 2008)\n");
    wikt = fopen("wikti_en_V_syn.elist", "r");
    igraph_read_graph_edgelist(&g, wikt, 0, 0);
    fclose(wikt);
    gsummary(&g);
    codelength = infomap_test(&g, /* smoke_test = */ 1);
    if (fabs(codelength - 5.708) >= 1e-3) {
        printf("Codelength was %0.5f, expected %0.5f\n", codelength, 5.708);
    } else {
        printf("Codelength OK.\n");
    }
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_community_infomap.out0000644000175100001710000000157400000000000027622 0ustar00runnerdocker00000000000000# Two triangles connected by one edge
Codelength: 2.51787 (in 2 modules)
Membership: 0 0 0 1 1 1 
# Two 4-cliques (0123 and 4567) connected by two edges (0-4 and 1-5)
Codelength: 2.94884 (in 2 modules)
Membership: 0 0 0 0 1 1 1 1 
# Two 4-cliques (0123 and 4567) connected by two edges (0-4 and 1-5)
Codelength: 2.96655 (in 2 modules)
Membership: 0 1 0 0 0 1 1 1 
# Zachary Karate club
Codelength: 4.60606 (in 3 modules)
Membership: 0 0 0 0 1 1 1 0 2 0 1 0 0 0 2 2 1 0 2 0 2 0 2 2 2 2 2 2 2 2 2 2 2 2 
# Flow (from infomap_dir.tgz)
Codelength: 3.32773 (in 4 modules)
Membership: 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 
# MultiphysChemBioEco40W_weighted_dir.net (from infomap_dir.tgz)
Codelength: 3.87095 (in 5 modules)
Membership: 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 4 3 3 
# Wiktionary english verbs (synonymy 2008)
|V|=7339 |E|=8293 directed=0
Codelength OK.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_community_leading_eigenvector2.c0000644000175100001710000000715200000000000031661 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"


int main() {

    igraph_t g;
    igraph_matrix_t merges;
    igraph_vector_t membership;
    igraph_vector_t x;
    igraph_arpack_options_t options;
    igraph_vector_t weights;

    /* Zachary Karate club */
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
                 0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
                 0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
                 0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
                 1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
                 2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
                 2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
                 4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
                 6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
                 13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
                 18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
                 22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
                 23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
                 25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
                 28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
                 31, 32, 31, 33, 32, 33,
                 -1);

    igraph_matrix_init(&merges, 0, 0);
    igraph_vector_init(&membership, 0);
    igraph_vector_init(&x, 0);
    igraph_arpack_options_init(&options);
    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 1);

    igraph_community_leading_eigenvector(&g, &weights, &merges,
                                         &membership, 1,
                                         &options, /*modularity=*/ 0,
                                         /*start=*/ 0, /*eigenvalues=*/ 0,
                                         /*eigenvectors=*/ 0, /*history=*/ 0,
                                         /*callback=*/ 0,
                                         /*callback_extra=*/ 0);

    print_matrix_round(&merges);
    print_vector_round(&membership);

    printf("\n");

    /* Make all the steps */
    igraph_community_leading_eigenvector(&g, &weights, &merges,
                                         &membership, igraph_vcount(&g),
                                         &options, /*modularity=*/ 0,
                                         /*start=*/ 0, /*eigenvalues=*/ 0,
                                         /*eigenvectors=*/ 0, /*history=*/ 0,
                                         /*callback=*/ 0,
                                         /*callback_extra=*/ 0);

    print_matrix_round(&merges);
    print_vector_round(&membership);

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&x);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_community_leading_eigenvector2.out0000644000175100001710000000030500000000000032237 0ustar00runnerdocker00000000000000[    0    1 ]
( 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 )

[    1    3
     0    2
     5    4 ]
( 0 2 2 2 0 0 0 2 1 1 0 0 2 2 1 1 0 2 1 2 1 2 1 3 3 3 1 3 3 1 1 3 1 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_compare_communities.c0000644000175100001710000001001300000000000027526 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

char *names[] = {
    [IGRAPH_COMMCMP_VI] = "VI",
    [IGRAPH_COMMCMP_NMI] = "NMI",
    [IGRAPH_COMMCMP_SPLIT_JOIN] = "Split-join",
    [IGRAPH_COMMCMP_RAND] = "Rand",
    [IGRAPH_COMMCMP_ADJUSTED_RAND] = "Adjusted Rand",
};


void compare_and_print(igraph_vector_t *comm1, igraph_vector_t *comm2, igraph_community_comparison_t t, igraph_error_type_t e) {
    igraph_real_t result;
    printf("%s result: ", names[t]);
    IGRAPH_ASSERT(igraph_compare_communities(comm1, comm2, &result, t) == e);
    if (e == IGRAPH_EINVAL) {
        printf("failed as expected\n");
    } else {
        print_real(stdout, result, "%g");
        printf("\n");
    }
}


int main() {
    igraph_vector_t comm1, comm2;

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Only one member, both partitions equal to whole set:\n");
    igraph_vector_init_int(&comm1, 1, 0);
    igraph_vector_init_int(&comm2, 1, 0);


    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_VI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_RAND, IGRAPH_EINVAL);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_ADJUSTED_RAND, IGRAPH_EINVAL);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_NMI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_SPLIT_JOIN, IGRAPH_SUCCESS);

    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("\nEmpty sets:\n");
    igraph_vector_init(&comm1, 0);
    igraph_vector_init(&comm2, 0);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_VI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_RAND, IGRAPH_EINVAL);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_ADJUSTED_RAND, IGRAPH_EINVAL);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_NMI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_SPLIT_JOIN, IGRAPH_SUCCESS);

    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("\nTwo equal, differenly labeled partitions:\n");
    igraph_vector_init_int(&comm1, 2, 0, 1);
    igraph_vector_init_int(&comm2, 2, 1, 0);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_VI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_RAND, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_ADJUSTED_RAND, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_NMI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_SPLIT_JOIN, IGRAPH_SUCCESS);

    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("\nTwo different partitions: ((5,1), (8,3,4), (0,6,7,2,9)) and ((5,8), (1,3,4,0), (6,7,2,9))\n");
    igraph_vector_init_int(&comm1, 10, 2, 0, 2, 1, 1, 0, 2, 2, 1, 2);
    igraph_vector_init_int(&comm2, 10, 1, 1, 2, 1, 1, 0, 2, 2, 0, 2);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_VI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_RAND, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_ADJUSTED_RAND, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_NMI, IGRAPH_SUCCESS);
    compare_and_print(&comm1, &comm2, IGRAPH_COMMCMP_SPLIT_JOIN, IGRAPH_SUCCESS);

    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_compare_communities.out0000644000175100001710000000120400000000000030115 0ustar00runnerdocker00000000000000Only one member, both partitions equal to whole set:
VI result: 0
Rand result: failed as expected
Adjusted Rand result: failed as expected
NMI result: 1
Split-join result: 0

Empty sets:
VI result: 0
Rand result: failed as expected
Adjusted Rand result: failed as expected
NMI result: 1
Split-join result: 0

Two equal, differenly labeled partitions:
VI result: 0
Rand result: 1
Adjusted Rand result: NaN
NMI result: 1
Split-join result: 0

Two different partitions: ((5,1), (8,3,4), (0,6,7,2,9)) and ((5,8), (1,3,4,0), (6,7,2,9))
VI result: 1.1343
Rand result: 0.711111
Adjusted Rand result: 0.312573
NMI result: 0.455859
Split-join result: 6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_complex.c0000644000175100001710000001425200000000000025144 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
/* This definition ensures math symbols are also available when
 * compiling with MSVC.
 */
#define _USE_MATH_DEFINES
#include 

#include "test_utilities.inc"

#define ARE 4
#define AIM 5
#define BRE 6
#define BIM 2

int main() {

    igraph_complex_t a = igraph_complex(ARE, AIM);
    igraph_complex_t b = igraph_complex(BRE, BIM);
    igraph_complex_t c, d, e;

    /* polar, mod, arg */
    c = igraph_complex_polar(igraph_complex_mod(a), igraph_complex_arg(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, c, 1e-14));

    /* add */
    c = igraph_complex_add(a, b);
    IGRAPH_ASSERT(IGRAPH_REAL(c) == ARE + BRE && IGRAPH_IMAG(c) == AIM + BIM);

    /* sub */
    c = igraph_complex_sub(a, b);
    IGRAPH_ASSERT(IGRAPH_REAL(c) == ARE - BRE && IGRAPH_IMAG(c) == AIM - BIM);

    /* mul */
    c = igraph_complex_mul(a, b);
    IGRAPH_ASSERT(IGRAPH_REAL(c) == ARE * BRE - AIM * BIM);
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == ARE * BIM + AIM * BRE);

    /* div */
    c = igraph_complex_div(a, b);
    c = igraph_complex_mul(c, b);
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, c, 1e-14));

    /* add_real */
    c = igraph_complex_add_real(a, IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_REAL(a) + IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_IMAG(a));

    /* add_imag */
    c = igraph_complex_add_imag(a, IGRAPH_IMAG(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_REAL(a));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_IMAG(a) + IGRAPH_IMAG(b));

    /* sub_real */
    c = igraph_complex_sub_real(a, IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_REAL(a) - IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_IMAG(a));

    /* sub_imag */
    c = igraph_complex_sub_imag(a, IGRAPH_IMAG(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_REAL(a));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_IMAG(a) - IGRAPH_IMAG(b));

    /* mul_real */
    c = igraph_complex_mul_real(a, IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_REAL(a) * IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_IMAG(a) * IGRAPH_REAL(b));

    /* mul_imag */
    c = igraph_complex_mul_imag(a, IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == - IGRAPH_IMAG(a) * IGRAPH_REAL(b));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == IGRAPH_REAL(a) * IGRAPH_REAL(b));

    /* div_real */
    c = igraph_complex_div_real(a, IGRAPH_REAL(b));
    IGRAPH_ASSERT(fabs(IGRAPH_REAL(c) - IGRAPH_REAL(a) / IGRAPH_REAL(b)) < 1e-15);
    IGRAPH_ASSERT(fabs(IGRAPH_IMAG(c) - IGRAPH_IMAG(a) / IGRAPH_REAL(b)) < 1e-15);

    /* div_imag */
    c = igraph_complex_div_imag(a, IGRAPH_IMAG(b));
    IGRAPH_ASSERT(IGRAPH_REAL(c) == IGRAPH_IMAG(a) / IGRAPH_IMAG(b));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == - IGRAPH_REAL(a) / IGRAPH_IMAG(b));

    /* conj */
    c = igraph_complex_conj(a);
    IGRAPH_ASSERT(IGRAPH_REAL(c) == ARE && IGRAPH_IMAG(c) == -AIM);

    /* neg */
    c = igraph_complex_neg(a);
    IGRAPH_ASSERT(IGRAPH_REAL(c) == - IGRAPH_REAL(a));
    IGRAPH_ASSERT(IGRAPH_IMAG(c) == - IGRAPH_IMAG(a));

    /* inv */
    c = igraph_complex_inv(a);
    d = igraph_complex(1.0, 0.0);
    e = igraph_complex_div(d, a);
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, e, 1e-14));

    /* abs */
    IGRAPH_ASSERT(igraph_complex_abs(a) == igraph_complex_mod(a));

    /* logabs */

    /* sqrt */
    c = igraph_complex_sqrt(a);
    d = igraph_complex_mul(c, c);
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, d, 1e-14));

    /* sqrt_real */
    c = igraph_complex_sqrt(igraph_complex(-1.0, 0.0));
    d = igraph_complex_sqrt_real(-1.0);
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, d, 1e-14));

    /* exp */
    c = igraph_complex_exp(igraph_complex(0.0, M_PI));
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, igraph_complex(-1.0, 0.0), 1e-14));

    /* pow */
    c = igraph_complex_pow(igraph_complex(M_E, 0.0), igraph_complex(0.0, M_PI));
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, igraph_complex(-1.0, 0.0), 1e-14));

    /* pow_real */
    c = igraph_complex_pow_real(a, 2.0);
    d = igraph_complex_mul(a, a);
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, d, 1e-12));

    /* log */
    c = igraph_complex_exp(igraph_complex_log(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, c, 1e-14));

    /* log10 */
    c = igraph_complex_pow(igraph_complex(10.0, 0), igraph_complex_log10(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, c, 1e-14));

    /* log_b */
    c = igraph_complex_pow(b, igraph_complex_log_b(a, b));
    IGRAPH_ASSERT(igraph_complex_eq_tol(a, c, 1e-14));

    /* sin, cos */
    c = igraph_complex_sin(a);
    d = igraph_complex_cos(a);
    e = igraph_complex_add(igraph_complex_mul(c, c), igraph_complex_mul(d, d));
    IGRAPH_ASSERT(igraph_complex_eq_tol(e, igraph_complex(1.0, 0.0), 1e-11));

    /* tan */
    c = igraph_complex_tan(a);
    d = igraph_complex_div(igraph_complex_sin(a), igraph_complex_cos(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, d, 1e-14));

    /* sec */
    c = igraph_complex_sec(a);
    d = igraph_complex_inv(igraph_complex_cos(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, d, 1e-14));

    /* csc */
    c = igraph_complex_csc(a);
    d = igraph_complex_inv(igraph_complex_sin(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(c, d, 1e-14));

    /* cot */
    c = igraph_complex_tan(a);
    d = igraph_complex_div(igraph_complex_sin(a), igraph_complex_cos(a));
    IGRAPH_ASSERT(igraph_complex_eq_tol(d, c, 1e-14));

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_convergence_degree.c0000644000175100001710000000323000000000000027300 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t result;
    long i;

    igraph_vector_init(&result, 0);

    igraph_small(&g, 7, 0, 0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3, 3, 4, 4, 5, 4, 6, 5, 6, -1);
    igraph_convergence_degree(&g, &result, 0, 0);
    for (i = 0; i < igraph_ecount(&g); i++) {
        printf("%.4f ", (float)igraph_vector_e(&result, i));
    }
    printf("\n");
    igraph_destroy(&g);

    igraph_small(&g, 6, 1, 1, 0, 2, 0, 3, 0, 4, 0, 0, 5, -1);
    igraph_convergence_degree(&g, &result, 0, 0);
    for (i = 0; i < igraph_ecount(&g); i++) {
        printf("%.4f ", (float)igraph_vector_e(&result, i));
    }
    printf("\n");
    igraph_destroy(&g);

    igraph_vector_destroy(&result);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_convergence_degree.out0000644000175100001710000000015700000000000027672 0ustar00runnerdocker000000000000000.0000 0.0000 0.6000 0.0000 0.6000 0.6000 0.1429 0.6667 0.6667 0.0000 
-0.3333 -0.3333 -0.3333 -0.3333 0.6667 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_correlated_game.c0000644000175100001710000000260000000000000026604 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph R library.
   Copyright (C) 2003-2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g1, g2;

    igraph_rng_seed(igraph_rng_default(), 9275);

    igraph_erdos_renyi_game(&g1, IGRAPH_ERDOS_RENYI_GNP, 10, .3,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_correlated_game(&g1, &g2, .9, .3, /* permutation=*/ 0);

    IGRAPH_ASSERT(igraph_vcount(&g1) == igraph_vcount(&g2));

    igraph_destroy(&g2);
    igraph_destroy(&g1);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_count_multiple.c0000644000175100001710000000144400000000000026537 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_t counts;

    igraph_vector_init(&counts, 0);

    /* undirected case */
    igraph_small(&graph, 2, IGRAPH_UNDIRECTED,
                 0,1, 0,1, 0,1, 0,0, 1,1, 1,1,
                 -1);

    igraph_count_multiple(&graph, &counts, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector_round(&counts);

    igraph_destroy(&graph);

    /* directed case */
    igraph_small(&graph, 2, IGRAPH_DIRECTED,
                 0,1, 0,1, 0,1, 0,0, 1,1, 1,1,
                 -1);

    igraph_count_multiple(&graph, &counts, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    print_vector_round(&counts);

    igraph_destroy(&graph);

    igraph_vector_destroy(&counts);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_count_multiple.out0000644000175100001710000000004000000000000027113 0ustar00runnerdocker00000000000000( 3 3 3 1 2 2 )
( 3 3 3 1 2 2 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_decompose_strong.c0000644000175100001710000000427600000000000027054 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

void free_complist(igraph_vector_ptr_t *complist) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(complist); i++) {
        igraph_destroy(VECTOR(*complist)[i]);
        igraph_free(VECTOR(*complist)[i]);
    }
}

int main() {

    igraph_t ring, g;
    igraph_vector_ptr_t complist;
    long int i;

    /* A directed ring, a single strongly connected component */
    igraph_ring(&ring, 10, IGRAPH_DIRECTED, 0, 1);

    igraph_vector_ptr_init(&complist, 0);
    igraph_decompose(&ring, &complist, IGRAPH_STRONG, -1, 0);
    igraph_write_graph_edgelist(VECTOR(complist)[0], stdout);
    free_complist(&complist);
    igraph_destroy(&ring);

    /* a toy graph, three components maximum, with at least 2 vertices each */
    /* 0 >->  1 >-> 3 >-> 4
       ^      v
       \< 2 < /           */
    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 0,
                 1, 3,
                 3, 4,
                 -1);
    igraph_decompose(&g, &complist, IGRAPH_STRONG, 3, 2);
    for (i = 0; i < igraph_vector_ptr_size(&complist); i++) {
        igraph_write_graph_edgelist(VECTOR(complist)[i], stdout);
    }
    free_complist(&complist);
    igraph_destroy(&g);

    igraph_vector_ptr_destroy(&complist);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_decompose_strong.out0000644000175100001710000000006400000000000027430 0ustar00runnerdocker000000000000000 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 0
0 1
1 2
2 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_degree_sequence_game.c0000644000175100001710000001450100000000000027606 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t outdeg, indeg, degrees, empty;
    igraph_bool_t is_simple, is_connected;

    igraph_real_t outarr[] = {2, 3, 2, 3, 3, 3, 3, 1, 4, 4};
    igraph_real_t inarr[]  = {3, 6, 2, 0, 2, 2, 4, 3, 3, 3};

    long int n = sizeof(outarr) / sizeof(igraph_real_t);

    igraph_rng_seed(igraph_rng_default(), 333);

    igraph_vector_view(&outdeg, outarr, n);
    igraph_vector_view(&indeg,  inarr,  n);

    igraph_vector_init(&empty, 0);

    /* This vector is used to check that the degrees of the result
     * match the requested degrees. */
    igraph_vector_init(°rees, 0);

    /* Configuration model, undirected non-simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, NULL, IGRAPH_DEGSEQ_SIMPLE);

    IGRAPH_ASSERT(! igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, NULL, IGRAPH_DEGSEQ_SIMPLE);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Configuration model, directed non-simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_SIMPLE);

    IGRAPH_ASSERT(igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&indeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, &empty, IGRAPH_DEGSEQ_SIMPLE);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Configuration model, undirected simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, NULL, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM);

    IGRAPH_ASSERT(! igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_is_simple(&g, &is_simple);
    IGRAPH_ASSERT(is_simple);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, NULL, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Configuration model, directed simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM);

    IGRAPH_ASSERT(igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_is_simple(&g, &is_simple);
    IGRAPH_ASSERT(is_simple);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&indeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, &empty, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE_UNIFORM);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Fast heuristic method, undirected simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, NULL, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);

    IGRAPH_ASSERT(! igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_is_simple(&g, &is_simple);
    IGRAPH_ASSERT(is_simple);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, NULL, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Fast heuristic method, directed simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);

    IGRAPH_ASSERT(igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_is_simple(&g, &is_simple);
    IGRAPH_ASSERT(is_simple);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&indeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, &empty, IGRAPH_DEGSEQ_SIMPLE_NO_MULTIPLE);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);


    /* Viger-Latapy method, undirected connected simple graphs */

    igraph_degree_sequence_game(&g, &outdeg, NULL, IGRAPH_DEGSEQ_VL);

    IGRAPH_ASSERT(! igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == n);

    igraph_is_simple(&g, &is_simple);
    IGRAPH_ASSERT(is_simple);

    igraph_is_connected(&g, &is_connected, IGRAPH_WEAK);
    IGRAPH_ASSERT(is_connected);

    igraph_degree(&g, °rees, igraph_vss_all(), IGRAPH_ALL, IGRAPH_LOOPS);
    IGRAPH_ASSERT(igraph_vector_all_e(&outdeg, °rees));

    igraph_destroy(&g);

    igraph_degree_sequence_game(&g, &empty, NULL, IGRAPH_DEGSEQ_VL);
    IGRAPH_ASSERT(! igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    /* This degree sequence contains a zero degree, so it cannot be realized by a connected graph. */
    CHECK_ERROR(igraph_degree_sequence_game(&g, &indeg, NULL, IGRAPH_DEGSEQ_VL), IGRAPH_EINVAL);

    igraph_vector_destroy(°rees);
    igraph_vector_destroy(&empty);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_density.c0000644000175100001710000001025300000000000025151 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2013  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void test_density(const igraph_t *graph, igraph_bool_t loops) {
    igraph_real_t density;

    if (igraph_density(graph, &density, loops)) {
        printf("FAILED!\n");
        return;
    }

    if (igraph_is_nan(density)) {
        printf("nan\n");
    } else {
        printf("%.4f\n", density);
    }
}

int main() {

    igraph_t g;
    igraph_vector_t v;

    igraph_vector_init(&v, 0);

    /* Test graphs with no vertices and no edges */
    igraph_create(&g, &v, 0, IGRAPH_UNDIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 0, IGRAPH_DIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with one vertex and no edges */
    igraph_create(&g, &v, 1, IGRAPH_UNDIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with one vertex and a loop edge */
    igraph_vector_resize(&v, 2);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 0;
    igraph_create(&g, &v, 1, IGRAPH_UNDIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with one vertex and two loop edges */
    igraph_vector_resize(&v, 4);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 0;
    VECTOR(v)[2] = 0;
    VECTOR(v)[3] = 0;
    igraph_create(&g, &v, 1, IGRAPH_UNDIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with two vertices and one edge between them */
    igraph_vector_resize(&v, 2);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    igraph_create(&g, &v, 2, IGRAPH_UNDIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with two vertices, one edge between them and a loop on one
     * of them */
    igraph_vector_resize(&v, 4);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 1;
    igraph_create(&g, &v, 2, IGRAPH_UNDIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Test graphs with two vertices, one edge between them and a loop on both
     * of them */
    igraph_vector_resize(&v, 6);
    VECTOR(v)[0] = 0;
    VECTOR(v)[1] = 1;
    VECTOR(v)[2] = 1;
    VECTOR(v)[3] = 1;
    VECTOR(v)[4] = 0;
    VECTOR(v)[5] = 0;
    igraph_create(&g, &v, 2, IGRAPH_UNDIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    igraph_create(&g, &v, 1, IGRAPH_DIRECTED);
    test_density(&g, 1);
    igraph_destroy(&g);
    printf("======\n");

    /* Zachary karate club graph */
    igraph_famous(&g, "zachary");
    test_density(&g, 0);
    test_density(&g, 1);
    igraph_destroy(&g);

    igraph_vector_destroy(&v);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_density.out0000644000175100001710000000027100000000000025535 0ustar00runnerdocker00000000000000nan
nan
nan
nan
======
nan
0.0000
nan
0.0000
======
1.0000
1.0000
======
2.0000
2.0000
======
1.0000
0.3333
0.5000
0.2500
======
0.6667
0.5000
======
1.0000
0.7500
======
0.1390
0.1311
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_diversity.c0000644000175100001710000000367600000000000025527 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=4 sts=4 et: */

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t result;
    igraph_vector_t weights;

    igraph_vector_init(&result, 0);

    /* null graph */
    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_vector_init(&weights, 0);

    printf("Null graph:\n");
    igraph_diversity(&g, &weights, &result, igraph_vss_all());
    print_vector(&result);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* graph with no edges */
    igraph_empty(&g, 5, IGRAPH_UNDIRECTED);
    igraph_vector_init(&weights, 0);

    printf("Empty graph:\n");
    igraph_diversity(&g, &weights, &result, igraph_vss_all());
    print_vector(&result);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* real graph */
    igraph_small(&g, 4, IGRAPH_UNDIRECTED, 0,1, 0,2, 1,2, 1,3, 2,3, -1);
    igraph_vector_init_int_end(&weights, -1, 3, 2, 8, 1, 1, -1);

    printf("Graph with 4 nodes and 5 edges:\n");
    igraph_diversity(&g, &weights, &result, igraph_vss_all());
    print_vector(&result);

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* error conditions are tested from now on */
    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /* graph with multiple edges */
    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0,1, 0,2, 2,0, -1);
    igraph_vector_init_int_end(&weights, -1, 3, 2, 8, -1);
    IGRAPH_ASSERT(igraph_diversity(&g, &weights, &result, igraph_vss_all()) == IGRAPH_EINVAL);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* directed graph */
    igraph_small(&g, 3, IGRAPH_DIRECTED, 0,1, 0,2, -1);
    igraph_vector_init_int_end(&weights, -1, 3, 2, -1);
    IGRAPH_ASSERT(igraph_diversity(&g, &weights, &result, igraph_vss_all()) == IGRAPH_EINVAL);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    igraph_vector_destroy(&result);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_diversity.out0000644000175100001710000000016100000000000026076 0ustar00runnerdocker00000000000000Null graph:
( )
Empty graph:
( NaN NaN NaN NaN NaN )
Graph with 4 nodes and 5 edges:
( 0.970951 0.75 0.69137 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_dyad_census.c0000644000175100001710000000372300000000000025777 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph) {
    igraph_integer_t mut, asym, null;
    IGRAPH_ASSERT(igraph_dyad_census(graph, &mut, &asym, &null) == IGRAPH_SUCCESS);
    printf("Mutual: %" IGRAPH_PRId " ", mut);
    printf("asymmetric: %" IGRAPH_PRId " ", asym);
    printf("null: %" IGRAPH_PRId "\n\n", null);
}


int main() {
    igraph_t g_0, g_1, g_2, g_lm, g_lmu;

    igraph_small(&g_0, 0, IGRAPH_DIRECTED, -1);
    igraph_small(&g_1, 1, IGRAPH_DIRECTED, -1);
    igraph_small(&g_2, 2, IGRAPH_DIRECTED, 0,1, -1);
    igraph_small(&g_lm, 6, IGRAPH_DIRECTED, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, IGRAPH_UNDIRECTED, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    call_and_print(&g_0);

    printf("One vertex:\n");
    call_and_print(&g_1);

    printf("Two vertices:\n");
    call_and_print(&g_2);

    printf("Graph with loops and multiple edges:\n");
    call_and_print(&g_lm);

    printf("Same graph, but undirected:\n");
    call_and_print(&g_lmu);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_2);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lmu);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_dyad_census.out0000644000175100001710000000041700000000000026361 0ustar00runnerdocker00000000000000No vertices:
Mutual: 0 asymmetric: 0 null: 0

One vertex:
Mutual: 0 asymmetric: 0 null: 0

Two vertices:
Mutual: 0 asymmetric: 1 null: 0

Graph with loops and multiple edges:
Mutual: 1 asymmetric: 4 null: 10

Same graph, but undirected:
Mutual: 5 asymmetric: 0 null: 10

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eccentricity.c0000644000175100001710000000510600000000000026160 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/


#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t ecc;

    igraph_vector_init(&ecc, 0);

    printf("Null graph:\n");
    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nSingleton graph:\n");
    igraph_empty(&g, 1, IGRAPH_UNDIRECTED);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nPath with isolated vertex:\n");
    igraph_small(&g, 3, IGRAPH_UNDIRECTED,
                 0,2,
                 -1);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nUndirected path graph:\n");
    igraph_ring(&g, 5, IGRAPH_UNDIRECTED, /* mutual */ 0, /* circular */ 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nDirected path graph:\n");
    igraph_ring(&g, 5, IGRAPH_DIRECTED, /* mutual */ 0, /* circular */ 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nUndirected star:\n");
    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nOut-star:\n");
    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_ALL);
    print_vector(&ecc);
    igraph_destroy(&g);

    printf("\nIn-star:\n");
    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);
    igraph_eccentricity(&g, &ecc, igraph_vss_all(), IGRAPH_OUT);
    print_vector(&ecc);
    igraph_destroy(&g);

    igraph_vector_destroy(&ecc);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eccentricity.out0000644000175100001710000000040700000000000026544 0ustar00runnerdocker00000000000000Null graph:
( )

Singleton graph:
( 0 )

Path with isolated vertex:
( 1 0 1 )

Undirected path graph:
( 4 3 2 3 4 )

Directed path graph:
( 4 3 2 1 0 )

Undirected star:
( 1 2 2 2 2 2 2 2 2 2 )

Out-star:
( 1 2 2 2 2 2 2 2 2 2 )

In-star:
( 1 0 0 0 0 0 0 0 0 0 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_edge_betweenness.c0000644000175100001710000001557500000000000027014 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"


/* https://github.com/igraph/igraph/issues/950 */
void test_bug950() {
    /* Testing the case of weighted graphs with multiple alternate
     * paths to the same node with slightly different weights due to
     * floating point inaccuracies. */
    igraph_t g;
    igraph_vector_t eb;
    igraph_vector_t weights;
    igraph_integer_t from, to;
    long int no_of_edges, i;

    igraph_full(&g, 6, 0, 0);
    no_of_edges = igraph_ecount(&g);

    igraph_vector_init(&weights, no_of_edges);

    for (i = 0; i < no_of_edges; i++) {
        igraph_edge(&g, i, &from, &to);
        if((from < 3 && to < 3) || (from >= 3 && to >= 3))
            VECTOR(weights)[i] = 1;
        else
            VECTOR(weights)[i] = 0.1;
    }

    igraph_vector_init(&eb, 0);

    igraph_edge_betweenness(&g, &eb, IGRAPH_UNDIRECTED, &weights);
    print_vector(&eb);

    igraph_vector_destroy(&eb);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);
}


/* https://github.com/igraph/igraph/issues/1050 */
void test_bug1050() {
    /* compare cutoff = -1 with cutoff = 0 */
    igraph_t g;
    igraph_vector_t eb, eb2;
    igraph_vector_t weights;

    igraph_full(&g, 6, 0, 0);

    /* unweighted */
    igraph_vector_init(&eb, igraph_ecount(&g));
    igraph_vector_init(&eb2, igraph_ecount(&g));

    igraph_edge_betweenness_cutoff(&g, &eb, IGRAPH_UNDIRECTED, /* weights */ 0, /* cutoff */ -1);
    igraph_edge_betweenness_cutoff(&g, &eb2, IGRAPH_UNDIRECTED, /* weights */ 0, /* cutoff */ 0);

    /* results must differ */
    IGRAPH_ASSERT(! igraph_vector_all_e(&eb, &eb2));

    igraph_vector_destroy(&eb);
    igraph_vector_destroy(&eb2);

    /* weighted */
    igraph_vector_init(&eb, igraph_ecount(&g));
    igraph_vector_init(&eb2, igraph_ecount(&g));

    igraph_vector_init(&weights, igraph_ecount(&g));
    igraph_vector_fill(&weights, 1);
    VECTOR(weights)[0] = 2;

    igraph_edge_betweenness_cutoff(&g, &eb, IGRAPH_UNDIRECTED, &weights, /* cutoff */ -1);
    igraph_edge_betweenness_cutoff(&g, &eb2, IGRAPH_UNDIRECTED, &weights, /* cutoff */ 0);

    /* results must differ */
    IGRAPH_ASSERT(! igraph_vector_all_e(&eb, &eb2));

    igraph_vector_destroy(&eb);
    igraph_vector_destroy(&eb2);
    igraph_vector_destroy(&weights);
    igraph_destroy(&g);
}


int main() {
    igraph_t g;
    igraph_vector_t eb, eb2;
    igraph_vector_t weights;

    igraph_vector_init(&eb, 0);

    printf("Null graph\n");
    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_edge_betweenness(&g, &eb, IGRAPH_UNDIRECTED, NULL);
    print_vector(&eb);
    igraph_destroy(&g);

    printf("\nEdgeless graph on 3 vertices\n");
    igraph_empty(&g, 3, IGRAPH_DIRECTED);
    igraph_edge_betweenness(&g, &eb, IGRAPH_DIRECTED, NULL);
    print_vector(&eb);
    igraph_destroy(&g);

    igraph_vector_destroy(&eb);

    {
        /* We use igraph_create() instead of igraph_small() as some MSVC versions
           will choke on an overlong argument list with "internal error C1001". */
        igraph_real_t edge_array[] = {
            0,  1,  0,  2,  0,  3,  0,  4,  0,  5,
            0,  6,  0,  7,  0,  8,  0, 10,  0, 11,
            0, 12,  0, 13,  0, 17,  0, 19,  0, 21,
            0, 31,  1,  2,  1,  3,  1,  7,  1, 13,
            1, 17,  1, 19,  1, 21,  1, 30,  2,  3,
            2,  7,  2,  8,  2,  9,  2, 13,  2, 27,
            2, 28,  2, 32,  3,  7,  3, 12,  3, 13,
            4,  6,  4, 10,  5,  6,  5, 10,  5, 16,
            6, 16,  8, 30,  8, 32,  8, 33,  9, 33,
            13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
            18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
            22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
            23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
            25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
            28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
            31, 32, 31, 33, 32, 33
        };
        igraph_vector_t edges;

        printf("\nNo cutoff, undirected, unweighted\n");
        igraph_create(&g, igraph_vector_view(&edges, edge_array, sizeof(edge_array) / sizeof(igraph_real_t)), 0, IGRAPH_UNDIRECTED);
        igraph_vector_init(&eb, 0);
        igraph_edge_betweenness(&g, &eb, IGRAPH_UNDIRECTED, /*weights=*/ 0);
        print_vector(&eb);

        printf("\nNo cutoff, undirected, unit weighted\n");
        igraph_vector_init(&eb2, 0);
        igraph_vector_init(&weights, igraph_ecount(&g));
        igraph_vector_fill(&weights, 1.0);
        igraph_edge_betweenness(&g, &eb2, IGRAPH_UNDIRECTED, &weights);
        print_vector(&eb2);

        /* check that weighted and unweighted calculations give the same result */
        igraph_vector_scale(&eb2, -1);
        igraph_vector_add(&eb, &eb2);
        igraph_vector_abs(&eb);
        IGRAPH_ASSERT(igraph_vector_max(&eb) < 1e-13);

        igraph_vector_destroy(&weights);
        igraph_vector_destroy(&eb2);
        igraph_vector_destroy(&eb);
        igraph_destroy(&g);
    }

    printf("\nSmall directed graph, unweighted\n");
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 1,0, 2,0, 0,3, 3,4, 4,5, 5,0, 5,6,
                 -1);
    igraph_vector_init(&eb, 0);
    igraph_edge_betweenness(&g, &eb, IGRAPH_DIRECTED, /* weights */ NULL);
    print_vector(&eb);
    igraph_vector_destroy(&eb);
    igraph_destroy(&g);

    printf("\nSmall undirected graph 1, unweighted, cutoff=2\n");
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 1, 4, -1);
    igraph_vector_init(&eb, 0);
    igraph_edge_betweenness_cutoff(&g, &eb, IGRAPH_UNDIRECTED, /*weights=*/ 0, /*cutoff=*/2);
    print_vector(&eb);
    igraph_vector_destroy(&eb);
    igraph_destroy(&g);

    printf("\nSmall undirected graph 2, unweighted, cutoff=2\n");
    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0, 1, 0, 3, 1, 2, 1, 4, 2, 5, 3, 4, 3, 6, 4, 5, 4, 7, 5, 8,
                 6, 7, 7, 8, -1);
    igraph_vector_init(&eb, 0);
    igraph_edge_betweenness_cutoff(&g, &eb, IGRAPH_UNDIRECTED, /*weights=*/ 0, /*cutoff=*/2);
    print_vector(&eb);
    igraph_vector_destroy(&eb);
    igraph_destroy(&g);

    printf("\nTesting bug 950, tolerances\n");
    test_bug950();

    printf("\nTesting bug 1050, cutoff values\n");
    test_bug1050();

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_edge_betweenness.out0000644000175100001710000000316500000000000027371 0ustar00runnerdocker00000000000000Null graph
( )

Edgeless graph on 3 vertices
( )

No cutoff, undirected, unweighted
( 14.1667 43.6389 11.5 29.3333 43.8333 43.8333 12.8024 41.6484 29.3333 33 26.1 23.7706 22.5095 25.7706 22.5095 71.3929 13.0333 4.33333 4.16429 6.95952 10.4905 8.20952 10.4905 18.1095 12.5833 14.1452 5.14762 17.281 4.28095 23.1087 12.781 38.7016 1.8881 6.9 8.37143 2.66667 1.66667 1.66667 2.66667 16.5 16.5 5.5 17.0778 22.6849 16.6143 38.0492 13.5111 19.4889 13.5111 19.4889 13.5111 19.4889 33.3135 13.5111 19.4889 13.5111 19.4889 11.0944 5.91111 3.73333 12.5333 18.3278 2.36667 10.4667 22.5 23.5944 2.54286 30.4571 17.0976 8.33333 13.781 13.0873 16.7222 9.56667 15.0429 23.2444 29.954 4.61429 )

No cutoff, undirected, unit weighted
( 14.1667 43.6389 11.5 29.3333 43.8333 43.8333 12.8024 41.6484 29.3333 33 26.1 23.7706 22.5095 25.7706 22.5095 71.3929 13.0333 4.33333 4.16429 6.95952 10.4905 8.20952 10.4905 18.1095 12.5833 14.1452 5.14762 17.281 4.28095 23.1087 12.781 38.7016 1.8881 6.9 8.37143 2.66667 1.66667 1.66667 2.66667 16.5 16.5 5.5 17.0778 22.6849 16.6143 38.0492 13.5111 19.4889 13.5111 19.4889 13.5111 19.4889 33.3135 13.5111 19.4889 13.5111 19.4889 11.0944 5.91111 3.73333 12.5333 18.3278 2.36667 10.4667 22.5 23.5944 2.54286 30.4571 17.0976 8.33333 13.781 13.0873 16.7222 9.56667 15.0429 23.2444 29.954 4.61429 )

Small directed graph, unweighted
( 5 5 15 14 13 6 6 )

Small undirected graph 1, unweighted, cutoff=2
( 4 3 3 2 )

Small undirected graph 2, unweighted, cutoff=2
( 3 3 3 4 3 4 3 4 4 3 3 3 )

Testing bug 950, tolerances
( 0 0 2.33333 2.33333 2.33333 0 2.33333 2.33333 2.33333 2.33333 2.33333 2.33333 0 0 0 )

Testing bug 1050, cutoff values
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_edge_disjoint_paths.c0000644000175100001710000000213400000000000027477 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_integer_t value;

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, -1);

    igraph_edge_disjoint_paths(&g, &value, 0, 5);

    igraph_destroy(&g);

    IGRAPH_ASSERT(value == 2);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix.c0000644000175100001710000001131500000000000026145 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    int nodes = 10;
    igraph_real_t triplets[] = { 1, 0, 1 / 4.0,       0, 1, 1 / 3.0,
                                 2, 0, 1 / 4.0,       0, 2, 1 / 3.0,
                                 3, 0, 1.0,         0, 3, 1 / 3.0,
                                 4, 1, 1.0,         1, 4, 1 / 4.0,
                                 5, 1, 1.0,         1, 5, 1 / 4.0,
                                 6, 1, 1.0,         1, 6, 1 / 4.0,
                                 7, 2, 1.0,         2, 7, 1 / 4.0,
                                 8, 2, 1.0,         2, 8, 1 / 4.0,
                                 9, 2, 1.0,         2, 9, 1 / 4.0
                               };

    igraph_sparsemat_t mat;
    int i, n = sizeof(triplets) / sizeof(igraph_real_t);
    igraph_eigen_which_t which;
    igraph_vector_complex_t values, values2;
    igraph_matrix_complex_t vectors, vectors2;
    igraph_matrix_t mat2;

    igraph_sparsemat_init(&mat, nodes, nodes, n / 3);
    for (i = 0; i < n; i += 3) {
        igraph_sparsemat_entry(&mat, triplets[i], triplets[i + 1], triplets[i + 2]);
    }

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 1;

    igraph_vector_complex_init(&values, 0);
    igraph_matrix_complex_init(&vectors, 0, 0);

    igraph_eigen_matrix(/*matrix=*/ 0, /*sparsemat=*/ &mat, /*fun=*/ 0,
                                    nodes, /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                                    /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    if (IGRAPH_REAL(MATRIX(vectors, 0, 0)) < 0) {
        igraph_matrix_complex_scale(&vectors, igraph_complex(-1.0, -0.0 ));
    }

    igraph_vector_complex_print(&values);
    igraph_matrix_complex_print(&vectors);

    igraph_sparsemat_destroy(&mat);

    /* Calcualate all eigenvalues, using SM and LM and then check that they
       are the same, in opposite order. We use a random matrix this time. */

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_matrix_init(&mat2, nodes, nodes);
    for (i = 0; i < nodes; i++) {
        int j;
        for (j = 0; j < nodes; j++) {
            MATRIX(mat2, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = nodes;
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    which.pos = IGRAPH_EIGEN_SM;
    which.howmany = nodes;
    igraph_vector_complex_init(&values2, 0);
    igraph_matrix_complex_init(&vectors2, 0, 0);
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values2, &vectors2);

#define DUMP() do {             \
        igraph_vector_complex_print(&values);   \
        igraph_vector_complex_print(&values2);  \
    } while(0)

    for (i = 0; i < nodes; i++) {
        int j;
        igraph_real_t d =
            igraph_complex_abs(igraph_complex_sub(VECTOR(values)[i],
                               VECTOR(values2)[nodes - i - 1]));
        if (d > 1e-15) {
            DUMP();
            return 2;
        }
        for (j = 0; j < nodes; j++) {
            igraph_real_t d =
                igraph_complex_abs(igraph_complex_sub(MATRIX(vectors, j, i),
                                   MATRIX(vectors2, j,
                                          nodes - i - 1)));
            if (d > 1e-15) {
                DUMP();
                return 3;
            }
        }
    }

    igraph_vector_complex_destroy(&values);
    igraph_matrix_complex_destroy(&vectors);
    igraph_vector_complex_destroy(&values2);
    igraph_matrix_complex_destroy(&vectors2);

    igraph_matrix_destroy(&mat2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix.out0000644000175100001710000000017500000000000026534 0ustar00runnerdocker000000000000001+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix2.c0000644000175100001710000000737000000000000026235 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DUMP() do {             \
        igraph_vector_complex_print(&values);   \
        igraph_vector_complex_print(&values2);  \
    } while(0)

int main() {

    const int nodes = 10;
    igraph_matrix_t mat2;
    igraph_vector_complex_t values, values2;
    igraph_matrix_complex_t vectors, vectors2;
    igraph_eigen_which_t which;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_matrix_init(&mat2, nodes, nodes);
    for (i = 0; i < nodes; i++) {
        int j;
        for (j = 0; j < nodes; j++) {
            MATRIX(mat2, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    /* Test LR, a single eigenvalue first */

    igraph_vector_complex_init(&values, 0);
    igraph_matrix_complex_init(&vectors, 0, 0);
    which.pos = IGRAPH_EIGEN_LR;
    which.howmany = 1;

    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    igraph_vector_complex_print(&values);
    igraph_matrix_complex_print(&vectors);

    igraph_vector_complex_destroy(&values);
    igraph_matrix_complex_destroy(&vectors);

    /* LR, and SR, all eigenvalues */

    igraph_vector_complex_init(&values, 0);
    igraph_matrix_complex_init(&vectors, 0, 0);
    which.pos = IGRAPH_EIGEN_LR;
    which.howmany = nodes;
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    igraph_vector_complex_init(&values2, 0);
    igraph_matrix_complex_init(&vectors2, 0, 0);
    which.pos = IGRAPH_EIGEN_SR;
    which.howmany = nodes;
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values2, &vectors2);

    for (i = 0; i < nodes; i++) {
        int j;
        igraph_real_t d =
            igraph_complex_abs(igraph_complex_sub(VECTOR(values)[i],
                               VECTOR(values2)[nodes - i - 1]));
        if (d > 1e-15) {
            DUMP();
            return 2;
        }
        for (j = 0; j < nodes; j++) {
            igraph_real_t d =
                igraph_complex_abs(igraph_complex_sub(MATRIX(vectors, j, i),
                                   MATRIX(vectors2, j,
                                          nodes - i - 1)));
            if (d > 1e-15) {
                DUMP();
                return 3;
            }
        }
    }

    igraph_vector_complex_destroy(&values);
    igraph_matrix_complex_destroy(&vectors);
    igraph_vector_complex_destroy(&values2);
    igraph_matrix_complex_destroy(&vectors2);

    igraph_matrix_destroy(&mat2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix2.out0000644000175100001710000000020300000000000026606 0ustar00runnerdocker0000000000000049.9655+0i
0.376489+0i
0.280558+0i
0.344153+0i
0.252112+0i
0.265478+0i
0.372991+0i
0.367542+0i
0.289639+0i
0.280074+0i
0.300868+0i
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix3.c0000644000175100001710000000617100000000000026234 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DUMP() do {             \
        igraph_vector_complex_print(&values);   \
        igraph_vector_complex_print(&values2);  \
    } while(0)

int main() {

    const int nodes = 10, skip = 3;
    igraph_matrix_t mat2;
    igraph_vector_complex_t values, values2;
    igraph_matrix_complex_t vectors, vectors2;
    igraph_eigen_which_t which;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_matrix_init(&mat2, nodes, nodes);
    for (i = 0; i < nodes; i++) {
        int j;
        for (j = 0; j < nodes; j++) {
            MATRIX(mat2, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    which.pos = IGRAPH_EIGEN_SELECT;
    which.il = skip;
    which.iu = nodes - skip;

    igraph_vector_complex_init(&values, 0);
    igraph_matrix_complex_init(&vectors, 0, 0);
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    which.pos = IGRAPH_EIGEN_ALL;

    igraph_vector_complex_init(&values2, 0);
    igraph_matrix_complex_init(&vectors2, 0, 0);
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values2, &vectors2);

    for (i = 0; i < nodes - skip * 2 + 1; i++) {
        int j;
        igraph_real_t d =
            igraph_complex_abs(igraph_complex_sub(VECTOR(values)[i],
                               VECTOR(values2)[i + skip - 1]));
        if (d > 1e-15) {
            DUMP();
            return 2;
        }
        for (j = 0; j < nodes; j++) {
            igraph_real_t d =
                igraph_complex_abs(igraph_complex_sub(MATRIX(vectors, j, i),
                                   MATRIX(vectors2, j, i + skip - 1)));
            if (d > 1e-15) {
                DUMP();
                return 3;
            }
        }
    }

    igraph_vector_complex_destroy(&values);
    igraph_matrix_complex_destroy(&vectors);
    igraph_vector_complex_destroy(&values2);
    igraph_matrix_complex_destroy(&vectors2);
    igraph_matrix_destroy(&mat2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix3.out0000644000175100001710000000000000000000000026602 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix4.c0000644000175100001710000000633700000000000026241 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DUMP() do {             \
        igraph_vector_complex_print(&values);   \
        igraph_vector_complex_print(&values2);  \
    } while(0)

int main() {

    const int nodes = 10;
    igraph_matrix_t mat2;
    igraph_vector_complex_t values, values2;
    igraph_matrix_complex_t vectors, vectors2;
    igraph_eigen_which_t which;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_matrix_init(&mat2, nodes, nodes);
    for (i = 0; i < nodes; i++) {
        int j;
        for (j = 0; j < nodes; j++) {
            MATRIX(mat2, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    igraph_vector_complex_init(&values, 0);
    igraph_matrix_complex_init(&vectors, 0, 0);
    which.pos = IGRAPH_EIGEN_LI;
    which.howmany = nodes;
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values, &vectors);

    igraph_vector_complex_init(&values2, 0);
    igraph_matrix_complex_init(&vectors2, 0, 0);
    which.pos = IGRAPH_EIGEN_SI;
    which.howmany = nodes;
    igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes,
                        /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
                        /*options=*/ 0, /*storage=*/ 0, &values2, &vectors2);

    igraph_vector_complex_print(&values);
    igraph_vector_complex_print(&values2);

    for (i = 0; i < nodes; i++) {
        int j;
        igraph_real_t d =
            igraph_complex_abs(igraph_complex_sub(VECTOR(values)[i],
                               VECTOR(values2)[nodes - i - 1]));
        if (d > 1e-15) {
            DUMP();
            return 2;
        }
        for (j = 0; j < nodes; j++) {
            igraph_real_t d =
                igraph_complex_abs(igraph_complex_sub(MATRIX(vectors, j, i),
                                   MATRIX(vectors2, j,
                                          nodes - i - 1)));
            if (d > 1e-15) {
                DUMP();
                return 3;
            }
        }
    }

    igraph_vector_complex_destroy(&values);
    igraph_matrix_complex_destroy(&vectors);
    igraph_vector_complex_destroy(&values2);
    igraph_matrix_complex_destroy(&vectors2);
    igraph_matrix_destroy(&mat2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix4.out0000644000175100001710000000046400000000000026621 0ustar00runnerdocker00000000000000-0.533366+6.22277i 6.77236+3.96835i -5.06056+2.90197i 49.9655+0i 12.0702+0i -3.82636+0i -8.56628+0i -5.06056-2.90197i 6.77236-3.96835i -0.533366-6.22277i
-0.533366-6.22277i 6.77236-3.96835i -5.06056-2.90197i -8.56628+0i -3.82636+0i 12.0702+0i 49.9655+0i -5.06056+2.90197i 6.77236+3.96835i -0.533366+6.22277i
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric.c0000644000175100001710000001003400000000000030236 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DIM 10

int check_ev(const igraph_matrix_t *A, const igraph_vector_t *values,
             const igraph_matrix_t *vectors) {

    int i, n = igraph_matrix_nrow(A);
    int ne = igraph_matrix_ncol(vectors);
    igraph_vector_t v, lhs, rhs;

    if (ne != igraph_vector_size(values)) {
        printf("'values' and 'vectors' sizes do not match\n");
        exit(1);
    }

    igraph_vector_init(&lhs, n);
    igraph_vector_init(&rhs, n);

    for (i = 0; i < ne; i++) {
        igraph_vector_view(&v, &MATRIX(*vectors, 0, i), n);
        igraph_blas_dgemv(/*transpose=*/ 0, /*alpha=*/ 1, A, &v,
                                         /*beta=*/ 0, &lhs);
        igraph_vector_update(&rhs, &v);
        igraph_vector_scale(&rhs, VECTOR(*values)[i]);
        if (igraph_vector_maxdifference(&lhs, &rhs) > 1e-10) {
            printf("LHS: ");
            igraph_vector_print(&lhs);
            printf("RHS: ");
            igraph_vector_print(&rhs);
            exit(2);
        }
    }

    igraph_vector_destroy(&rhs);
    igraph_vector_destroy(&lhs);

    return 0;
}

int main() {

    igraph_matrix_t A;
    igraph_vector_t values;
    igraph_matrix_t vectors;
    int i, j;
    igraph_eigen_which_t which;

    igraph_rng_seed(igraph_rng_default(), 42 * 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&vectors, 0, 0);
    igraph_vector_init(&values, 0);

    /* All eigenvalues and eigenvectors */

    for (i = 0; i < DIM; i++) {
        for (j = i; j < DIM; j++) {
            MATRIX(A, i, j) = MATRIX(A, j, i) =
                                  igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 5;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors);

    which.howmany = 8;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors);

    which.pos = IGRAPH_EIGEN_BE;
    which.howmany = 5;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors);

    which.pos = IGRAPH_EIGEN_SM;
    which.howmany = 5;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors);

    igraph_vector_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&A);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric.out0000644000175100001710000000030000000000000030616 0ustar00runnerdocker0000000000000056.5915 14.2507 -12.9906 11.1434 -10.4525
56.5915 14.2507 -12.9906 11.1434 -10.4525 -8.0168 7.44269 -4.93995
56.5915 -12.9906 14.2507 -10.4525 11.1434
1.36756 4.60399 -4.93995 7.44269 -8.0168
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric_arpack.c0000644000175100001710000001014300000000000031560 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DIM 10

int check_ev(const igraph_matrix_t *A, const igraph_vector_t *values,
             const igraph_matrix_t *vectors, int err_off) {

    int i, n = igraph_matrix_nrow(A);
    int ne = igraph_matrix_ncol(vectors);
    igraph_vector_t v, lhs, rhs;

    if (ne != igraph_vector_size(values)) {
        printf("'values' and 'vectors' sizes do not match\n");
        exit(err_off + 1);
    }

    igraph_vector_init(&lhs, n);
    igraph_vector_init(&rhs, n);

    for (i = 0; i < ne; i++) {
        igraph_vector_view(&v, &MATRIX(*vectors, 0, i), n);
        igraph_blas_dgemv(/*transpose=*/ 0, /*alpha=*/ 1, A, &v,
                                         /*beta=*/ 0, &lhs);
        igraph_vector_update(&rhs, &v);
        igraph_vector_scale(&rhs, VECTOR(*values)[i]);
        if (igraph_vector_maxdifference(&lhs, &rhs) > 1e-10) {
            printf("LHS %i: ", i);
            igraph_vector_print(&lhs);
            printf("RHS %i: ", i);
            igraph_vector_print(&rhs);
            exit(err_off + 2);
        }
    }

    igraph_vector_destroy(&rhs);
    igraph_vector_destroy(&lhs);

    return 0;
}

int main() {

    igraph_matrix_t A;
    igraph_vector_t values;
    igraph_matrix_t vectors;
    int i, j;
    igraph_eigen_which_t which;
    igraph_arpack_options_t options;

    igraph_rng_seed(igraph_rng_default(), 42 * 42);

    igraph_matrix_init(&A, DIM, DIM);
    igraph_matrix_init(&vectors, 0, 0);
    igraph_vector_init(&values, 0);

    igraph_arpack_options_init(&options);

    for (i = 0; i < DIM; i++) {
        for (j = i; j < DIM; j++) {
            MATRIX(A, i, j) = MATRIX(A, j, i) =
                                  igraph_rng_get_integer(igraph_rng_default(), 1, 10);
        }
    }

    which.pos = IGRAPH_EIGEN_LM;
    which.howmany = 2;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_ARPACK, &which, &options,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors, 0);

    which.howmany = 8;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_ARPACK, &which, &options,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors, 10);

    which.pos = IGRAPH_EIGEN_BE;
    which.howmany = 5;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_ARPACK, &which, &options,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors, 20);

    which.pos = IGRAPH_EIGEN_SM;
    which.howmany = 5;
    igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
                                  IGRAPH_EIGEN_ARPACK, &which, &options,
                                  /*storage=*/ 0, &values, &vectors);
    igraph_vector_print(&values);
    check_ev(&A, &values, &vectors, 30);

    igraph_vector_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_matrix_destroy(&A);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eigen_matrix_symmetric_arpack.out0000644000175100001710000000024600000000000032150 0ustar00runnerdocker0000000000000056.5915 14.2507
56.5915 14.2507 -12.9906 11.1434 -10.4525 -8.0168 7.44269 -4.93995
56.5915 -12.9906 14.2507 -10.4525 11.1434
1.36756 4.60399 -4.93995 7.44269 -8.0168
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_es_path.c0000644000175100001710000000420600000000000025116 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_es_t es;
    igraph_eit_t eit;
    igraph_integer_t size;

    /* DIRECTED */

    igraph_ring(&g, 10, IGRAPH_DIRECTED, 0, 1);
    igraph_es_path_small(&es, IGRAPH_DIRECTED, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, -1);
    igraph_eit_create(&g, es, &eit);
    igraph_es_size(&g, &es, &size);
    while (!IGRAPH_EIT_END(eit)) {
        long int edge = IGRAPH_EIT_GET(eit);
        igraph_integer_t from, to;
        igraph_edge(&g, edge, &from, &to);
        IGRAPH_EIT_NEXT(eit);
        size--;
    }
    IGRAPH_ASSERT(size == 0);

    igraph_eit_destroy(&eit);
    igraph_es_destroy(&es);
    igraph_destroy(&g);

    /* UNDIRECTED */

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_es_path_small(&es, IGRAPH_DIRECTED,
                         0, 1, 2, 3, 4, 3, 2, 3, 4, 5, 6, 5, 4, 5, 6, 7, 8, 9, 0, 1, 0, 9, -1);
    igraph_eit_create(&g, es, &eit);
    while (!IGRAPH_EIT_END(eit)) {
        long int edge = IGRAPH_EIT_GET(eit);
        igraph_integer_t from, to;
        igraph_edge(&g, edge, &from, &to);
        IGRAPH_EIT_NEXT(eit);
    }

    igraph_eit_destroy(&eit);
    igraph_es_destroy(&es);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_establishment_game.c0000644000175100001710000000700000000000000027321 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void init_vm(igraph_vector_t *type_dist,
             int v0, int v1,
             igraph_matrix_t *pref_matrix,
             int m00, int m10, int m01, int m11) {
    igraph_vector_init_int_end(type_dist, -1, v0, v1, -1);
    igraph_matrix_init(pref_matrix, 2, 2);
    MATRIX(*pref_matrix, 0, 0) = m00;
    MATRIX(*pref_matrix, 1, 0) = m10;
    MATRIX(*pref_matrix, 0, 1) = m01;
    MATRIX(*pref_matrix, 1, 1) = m11;
}

#define DESTROY_GVM() do {               \
    igraph_destroy(&g);                  \
    igraph_vector_destroy(&type_dist);   \
    igraph_matrix_destroy(&pref_matrix); \
    } while(0)

int main() {
    igraph_t g;
    igraph_vector_t type_dist;
    igraph_vector_t node_type_vec;
    igraph_matrix_t pref_matrix;
    igraph_bool_t bipartite;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&node_type_vec, 0);
    /*No vertices*/
    init_vm(&type_dist, 1, 0, &pref_matrix, 0, 0, 0, 1);
    IGRAPH_ASSERT(igraph_establishment_game(&g, /*nodes*/ 0, /*types*/ 2, /*edges_per_step*/ 0, &type_dist, &pref_matrix, /*directed*/ 0, /*node_type_vec*/ NULL) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    DESTROY_GVM();

    /*Zero matrix elements for only possible vertex type means no edges*/
    init_vm(&type_dist, 1, 0, &pref_matrix, 0, 0, 0, 1);
    IGRAPH_ASSERT(igraph_establishment_game(&g, /*nodes*/ 20, /*types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 0, /*node_type_vec*/ NULL) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(igraph_vcount(&g) == 20);
    DESTROY_GVM();

    /*Two types with only cross terms makes a bipartite graph*/
    init_vm(&type_dist, 1, 1, &pref_matrix, 0, 1, 1, 0);
    IGRAPH_ASSERT(igraph_establishment_game(&g, /*nodes*/ 20, /*types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 1, &node_type_vec) == IGRAPH_SUCCESS);
    igraph_is_bipartite(&g, &bipartite, NULL);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_is_directed(&g));
    IGRAPH_ASSERT(igraph_vector_min(&node_type_vec) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&node_type_vec) == 1);
    IGRAPH_ASSERT(igraph_vector_size(&node_type_vec) == 20);
    DESTROY_GVM();

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /*Distribution of types should have at least one possible value*/
    igraph_vector_init(&type_dist, 0);
    igraph_matrix_init(&pref_matrix, 0, 0);
    IGRAPH_ASSERT(igraph_establishment_game(&g, /*nodes*/ 20, /* types*/ 2, /*edges_per_step*/ 5, &type_dist, &pref_matrix, /*directed*/ 0, /*node_type_vec*/ NULL) == IGRAPH_EINVAL);
    DESTROY_GVM();

    igraph_vector_destroy(&node_type_vec);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eulerian_cycle.c0000644000175100001710000001316500000000000026462 0ustar00runnerdocker00000000000000
#include 
#include 
#include "test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_vector_t edge_res, vertex_res;
    igraph_es_t es;
    igraph_vs_t vs;

    igraph_vector_init(&edge_res, 0);
    igraph_vector_init(&vertex_res, 0);
/*
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
*/
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_vs_1(&vs, 0);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&edge_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,3, 3,4, 4,5, 5,2,
                2,6, 6,4, 4,8, 2,8, 2,7, 0,7, -1);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,0, 0,0, 0,0, -1);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_vs_1(&vs, 0);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, -1);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,3, 3,4, 4,0, 0,2, 2,1, 1,0, -1);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,6, 6,4, 4,5, 5,0, 0,1, 1,2,
                2,3, 3,4, 4,2, 2,0, -1);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vertex_res);
    igraph_vector_init(&vertex_res, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_cycle(&graph, &edge_res, &vertex_res);
    print_vector_round(&edge_res);
    print_vector_round(&vertex_res);

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_destroy(&vertex_res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eulerian_cycle.out0000644000175100001710000000036600000000000027046 0ustar00runnerdocker00000000000000( )
( )

( 0 1 2 3 4 5 6 7 8 9 10 11 )
( 0 1 2 3 4 5 2 6 4 8 2 7 0 )

( 2 1 0 )
( 0 0 0 0 )

( )
( )

( )
( )

( )
( )

( 0 1 2 )
( 0 1 2 0 )

( 3 4 5 0 1 2 )
( 0 2 1 0 3 4 0 )

( 4 5 9 0 1 8 6 7 2 3 )
( 0 1 2 0 6 4 2 3 4 5 0 )

( )
( )

( )
( )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eulerian_path.c0000644000175100001710000003505400000000000026320 0ustar00runnerdocker00000000000000
#include 
#include 
#include "test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_vector_t edge_res, vector_res;
    igraph_es_t es;
    igraph_vs_t vs;

    igraph_vector_init(&edge_res, 0);
    igraph_vector_init(&vector_res, 0);
    /*
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    printf("\n");
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    */

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_vs_1(&vs, 0);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,0 , -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,0 ,
                                            1,5, 5,4, 4,1, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,1, 1,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,0 , 1,2, 2,3, 3,4, 4,1 ,-1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,3, 3,4, 4,5, 5,2,
                2,6, 6,4, 4,8, 2,8, 2,7, 0,7, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, 2,3, 3,4 , 2,4 , 1,5,
                0,5 , -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,4, 3,4, 1,3, 2,5, 4,5, 2,6, 1,6, 0,4, 6,5, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 7,8, 8,9, 9,7, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 1,2, 2,3, 3,4, 4,5, 5,6, 6,3,
                3,7, 7,5, 5,9, 3,9, 3,8, 1,8, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2 , 2,0 , 0,3 , 3,2 ,
                                               2,5 , 5,3 , 3,4 , 4,5 , 1,4 , 0,4 ,-1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 2,3 , 3,4 , 4,2 , 2,5 , 5,4 ,
                                               4,7 , 7,5 , 5,6 , 6,7 , 3,6 , 2,6 ,-1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, 2,5 , 5,4 , 5,6 , 6,2 ,
                                            2,3 , 3,4 , 4,8, 8,2 , 2,7, 7,0 , -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  0,1, 1,4 , 4,0, 1,2 , 2,3 , 3,5, 5,2, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_vs_1(&vs, 0);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1 , 1,2, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,0, 0,0, 0,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1 , 1,3, 3,2, 2,0 , 2,1, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,3, 3,4, 4,0, 0,2, 2,1, 1,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,6, 6,4, 4,5, 5,0, 0,1, 1,2,
                2,3, 3,4, 4,2, 2,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 3,4, 1,3, 2,1, 1,2, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 3,4, 1,3, 2,1, 1,2, 0,0, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,2 , 2,4 , 4,5 , 5,2 , 2,0 , 0,1 ,
                                        1,1 , 1,3 , 1,3 , 3,2 , 2,1 , 3,5 , -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 1,3 , 3,5 , 5,6 , 6,3 , 3,1 , 1,2 ,
                                        2,2 , 2,4 , 2,4 , 4,3 , 3,2 , 4,6 , -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 7,8, 8,9, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 7,8, 8,9, 9,7, -1);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_vector_destroy(&edge_res);
    igraph_vector_init(&edge_res, 0);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);
    printf("\n");

    igraph_destroy(&graph);
    igraph_vector_destroy(&edge_res);
    igraph_vector_destroy(&vector_res);
    igraph_vector_init(&vector_res, 0);
    igraph_vector_init(&edge_res, 0);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0, 1, -1);
    igraph_es_1(&es, 0);
    igraph_delete_edges(&graph, es);
    igraph_vs_1(&vs, 1);
    igraph_delete_vertices(&graph, vs);
    igraph_eulerian_path(&graph, &edge_res, &vector_res);
    print_vector_round(&edge_res);
    print_vector_round(&vector_res);

    igraph_destroy(&graph);
    igraph_vector_destroy(&vector_res);
    igraph_vector_destroy(&edge_res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_eulerian_path.out0000644000175100001710000000204000000000000026672 0ustar00runnerdocker00000000000000( )
( )

( 0 1 )
( 0 1 2 )

( 0 1 2 )
( 0 1 2 0 )

( 0 5 4 3 1 2 )
( 0 1 4 5 1 2 0 )

( 3 2 1 0 )
( 0 1 2 1 0 )

( 1 2 3 4 5 0 )
( 0 1 2 3 4 1 0 )

( 0 1 2 3 4 5 6 7 8 9 10 11 )
( 0 1 2 3 4 5 2 6 4 8 2 7 0 )

( 0 6 5 1 2 3 4 )
( 1 0 5 1 2 3 4 2 )

( 5 1 0 9 2 7 8 4 3 6 10 )
( 5 2 1 0 4 2 6 1 3 4 5 6 )

( 0 1 2 )
( 7 8 9 7 )

( 0 1 2 3 4 5 6 7 8 9 10 11 )
( 1 2 3 4 5 6 3 7 5 9 3 8 1 )

( 0 2 1 9 10 3 4 5 6 7 8 )
( 1 0 2 1 4 0 3 2 5 3 4 5 )

( 0 2 1 9 10 3 4 5 6 7 8 )
( 3 2 4 3 6 2 5 4 7 5 6 7 )

( 7 6 1 0 11 10 2 3 8 9 5 4 )
( 4 3 2 1 0 7 2 5 4 8 2 6 5 )

( 0 2 1 3 4 5 6 )
( 1 0 4 1 2 3 5 2 )

( )
( )

( )
( )

( )
( )

( 0 1 )
( 0 1 2 )

( 2 1 0 )
( 0 0 0 0 )

( 0 1 2 )
( 0 1 2 0 )

( 3 0 1 2 4 )
( 2 0 1 3 2 1 )

( 3 4 5 0 1 2 )
( 0 2 1 0 3 4 0 )

( 4 5 9 0 1 8 6 7 2 3 )
( 0 1 2 0 6 4 2 3 4 5 0 )

( 0 4 3 2 1 )
( 0 1 2 1 3 4 )

( 5 0 4 3 2 1 )
( 0 0 1 2 1 3 4 )

( 5 6 8 9 4 0 10 7 11 3 1 2 )
( 0 1 1 3 2 0 2 1 3 5 2 4 5 )

( 5 6 8 9 4 0 10 7 11 3 1 2 )
( 1 2 2 4 3 1 3 2 4 6 3 5 6 )

( 0 1 )
( 7 8 9 )

( 0 1 2 )
( 7 8 9 7 )

( )
( )

( )
( )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_extended_chordal_ring.c0000644000175100001710000000535500000000000030014 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, g_rev, g_test;
    igraph_bool_t same;
    igraph_matrix_t W;
    int i, j;

    /*    Directed, pentagram with ring, both clockwise    */
    igraph_matrix_init(&W, 1, 1);
    igraph_matrix_set(&W, 0, 0, 2);
    IGRAPH_ASSERT(igraph_extended_chordal_ring(&g, /* nodes */ 5, &W, 1 /*directed*/) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 5, IGRAPH_DIRECTED, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0, 2, 1, 3, 2, 4, 3, 0, 4, 1, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);

    /*     Use negative matrix value for same specification    */
    igraph_matrix_set(&W, 0, 0, -3);
    IGRAPH_ASSERT(igraph_extended_chordal_ring(&g_rev, /* nodes */ 5, &W, 1 /*directed*/) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_same_graph(&g_rev, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_rev);
    igraph_destroy(&g_test);
    igraph_matrix_destroy(&W);


    /*    From article, should give double edges for chords in igraph   */
    igraph_matrix_init(&W, 2, 2);
    int m[2][2] = {{4, 2},
                   {8, 10}};
    for (i=0; i < 2; i++) {
        for (j=0; j < 2; j++) {
            MATRIX(W, i, j) = m[i][j];
        }
    }
    IGRAPH_ASSERT(igraph_extended_chordal_ring(&g, /* nodes */ 12, &W, 0 /*undirected*/) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 12, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 3, 3, 4,
                 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 0,
                 0, 4, 2, 6,  4, 8, 6, 10, 8, 0, 10, 2,
                 0, 4, 2, 6,  4, 8, 6, 10, 8, 0, 10, 2,
                 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 1,
                 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 1,
                 -1);

    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);
    igraph_matrix_destroy(&W);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_forest_fire_game.c0000644000175100001710000000525100000000000026774 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/0, /*fw_prob*/ 0.0,
                  /*bw_factor*/ 0.0, /*pambs*/1, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("No ambassadors:\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/10, /*fw_prob*/ 0.0,
                  /*bw_factor*/ 0.0, /*pambs*/0, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("More ambassadors than nodes:\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/5, /*fw_prob*/ 0.0,
                  /*bw_factor*/ 0.0, /*pambs*/100, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Some normal inputs, just to check for memory problems, no output checking.\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/50, /*fw_prob*/ 0.5,
                  /*bw_factor*/ 0.5, /*pambs*/3, /*directed*/ 1) == IGRAPH_SUCCESS);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative fw_prob.\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/5, /*fw_prob*/ -0.5,
                  /*bw_factor*/ 0.0, /*pambs*/100, /*directed*/ 1) == IGRAPH_EINVAL);

    printf("Negative bw_factor.\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/5, /*fw_prob*/ 0.5,
                  /*bw_factor*/ -0.5, /*pambs*/100, /*directed*/ 0) == IGRAPH_EINVAL);

    printf("Negative number of ambassadors.\n");
    IGRAPH_ASSERT(igraph_forest_fire_game(&g, /*number of vertices*/5, /*fw_prob*/ 0.5,
                  /*bw_factor*/ 0.5, /*pambs*/-100, /*directed*/ 1) == IGRAPH_EINVAL);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_forest_fire_game.out0000644000175100001710000000054200000000000027357 0ustar00runnerdocker00000000000000No vertices:
directed: false
vcount: 0
edges: {
}
No ambassadors:
directed: false
vcount: 10
edges: {
}
More ambassadors than nodes:
directed: true
vcount: 5
edges: {
1 0
2 0
2 1
3 0
3 1
3 2
4 0
4 1
4 2
4 3
}
Some normal inputs, just to check for memory problems, no output checking.
Negative fw_prob.
Negative bw_factor.
Negative number of ambassadors.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_from_prufer.c0000644000175100001710000000231300000000000026016 0ustar00runnerdocker00000000000000
#include 
#include 

#include "test_utilities.inc"


int main() {
    igraph_t graph;
    igraph_integer_t prufer1[] = {2, 3, 2, 3};
    igraph_integer_t prufer2[] = {0, 2, 4, 1, 1, 0};
    igraph_vector_int_t prufer;
    igraph_bool_t tree;

    igraph_vector_int_view(&prufer, prufer1, sizeof(prufer1) / sizeof(igraph_integer_t));
    igraph_from_prufer(&graph, &prufer);
    igraph_is_tree(&graph, &tree, NULL, IGRAPH_ALL);
    IGRAPH_ASSERT(tree);
    print_graph(&graph);
    igraph_destroy(&graph);

    igraph_vector_int_view(&prufer, prufer2, sizeof(prufer2) / sizeof(igraph_integer_t));
    igraph_from_prufer(&graph, &prufer);
    igraph_is_tree(&graph, &tree, NULL, IGRAPH_ALL);
    IGRAPH_ASSERT(tree);
    print_graph(&graph);
    igraph_destroy(&graph);

    /* For a zero-length array, we cannot use the same pattern as above because
       standard C does not allow raw zero-length arrays. */
    igraph_vector_int_init(&prufer, 0);
    igraph_from_prufer(&graph, &prufer);
    igraph_is_tree(&graph, &tree, NULL, IGRAPH_ALL);
    IGRAPH_ASSERT(tree);
    print_graph(&graph);
    igraph_destroy(&graph);
    igraph_vector_int_destroy(&prufer);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_from_prufer.out0000644000175100001710000000024300000000000026403 0ustar00runnerdocker00000000000000directed: false
vcount: 6
edges: {
2 0
3 1
4 2
3 2
5 3
}
directed: false
vcount: 8
edges: {
3 0
5 2
4 2
4 1
6 1
1 0
7 0
}
directed: false
vcount: 2
edges: {
1 0
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_full_citation.c0000644000175100001710000000414300000000000026327 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, g_test;
    igraph_bool_t same;
    long int n_vertices = 4;

    /*    Undirected, should be a full graph    */
    IGRAPH_ASSERT(igraph_full_citation(&g, n_vertices, 0 /*undirected*/) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 4, IGRAPH_UNDIRECTED, 0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    /*    Directed, only edges from i->j if i > j    */
    IGRAPH_ASSERT(igraph_full_citation(&g, n_vertices, 1 /*directed*/) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 4, IGRAPH_DIRECTED, 1, 0, 2, 0, 3, 0, 2, 1, 3, 1, 3, 2, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    /*    Directed, 1 vertex, should be edgeless    */
    IGRAPH_ASSERT(igraph_full_citation(&g, 1 /*n_vertices*/, 1 /*directed*/) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    igraph_destroy(&g);

    /*    Directed, 0 vertices, empty graph    */
    IGRAPH_ASSERT(igraph_full_citation(&g, 0 /*n_vertices*/, 1 /*directed*/) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;

}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_adjacency_sparse.c0000644000175100001710000000431000000000000027624 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_t *g, igraph_get_adjacency_t type) {
    igraph_spmatrix_t result;
    igraph_spmatrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_get_adjacency_sparse(g, &result, type) == IGRAPH_SUCCESS);
    print_spmatrix(&result);
    igraph_spmatrix_destroy(&result);
    printf("\n");
}

int main() {
    igraph_t g_null, g_lm, g_lm_undir, g_empty;

    igraph_small(&g_null, 0, 0, -1);
    igraph_small(&g_empty, 3, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lm_undir, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    print_and_destroy(&g_null, IGRAPH_GET_ADJACENCY_BOTH);

    printf("No edges:\n");
    print_and_destroy(&g_empty, IGRAPH_GET_ADJACENCY_BOTH);

    printf("Disconnected graph with loops and multiple edges:\n");
    print_and_destroy(&g_lm, IGRAPH_GET_ADJACENCY_BOTH);

    printf("Same graph, undirected, symmetric matrix:\n");
    print_and_destroy(&g_lm_undir, IGRAPH_GET_ADJACENCY_BOTH);

    printf("Same graph, undirected, upper triangular matrix:\n");
    print_and_destroy(&g_lm_undir, IGRAPH_GET_ADJACENCY_UPPER);

    printf("Same graph, undirected, lower triangular matrix:\n");
    print_and_destroy(&g_lm_undir, IGRAPH_GET_ADJACENCY_LOWER);

    igraph_destroy(&g_null);
    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lm_undir);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_adjacency_sparse.out0000644000175100001710000000312700000000000030216 0ustar00runnerdocker00000000000000No vertices:

No edges:
        0        0        0
        0        0        0
        0        0        0

Disconnected graph with loops and multiple edges:
        0        1        1        0        0        0
        0        1        0        1        0        0
        1        0        0        1        0        0
        0        0        0        0        2        0
        0        0        0        0        0        0
        0        0        0        0        0        0

Same graph, undirected, symmetric matrix:
        0        1        2        0        0        0
        1        1        0        1        0        0
        2        0        0        1        0        0
        0        1        1        0        2        0
        0        0        0        2        0        0
        0        0        0        0        0        0

Same graph, undirected, upper triangular matrix:
        0        1        2        0        0        0
        0        1        0        1        0        0
        0        0        0        1        0        0
        0        0        0        0        2        0
        0        0        0        0        0        0
        0        0        0        0        0        0

Same graph, undirected, lower triangular matrix:
        0        0        0        0        0        0
        1        1        0        0        0        0
        2        0        0        0        0        0
        0        1        1        0        0        0
        0        0        0        2        0        0
        0        0        0        0        0        0

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_all_simple_paths.c0000644000175100001710000000344300000000000027654 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_int_t res, res_all;
    long int i;

    igraph_small(&g, 6, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 5,
                 0, 3, 3, 4, 4, 5,
                 3, 2, 3, 5,
                 -1);

    igraph_vector_int_init(&res, 0);

    for (i = 0; i <= 5; i++) {
        igraph_get_all_simple_paths(&g, &res, 0, igraph_vss_1(5), i, IGRAPH_ALL);

        printf("Paths for cutoff %li:\n", i);
        igraph_vector_int_print(&res);
    }

    igraph_vector_int_init(&res_all, 0);

    igraph_get_all_simple_paths(&g, &res_all, 0, igraph_vss_1(5), -1, IGRAPH_ALL);

    IGRAPH_ASSERT(igraph_vector_int_all_e(&res, &res_all) && "Paths of all lengths does not equal result for maximum cutoff.");

    igraph_vector_int_destroy(&res_all);
    igraph_vector_int_destroy(&res);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_all_simple_paths.out0000644000175100001710000000045200000000000030236 0ustar00runnerdocker00000000000000Paths for cutoff 0:

Paths for cutoff 1:

Paths for cutoff 2:
0 3 5 -1
Paths for cutoff 3:
0 1 2 5 -1 0 3 2 5 -1 0 3 4 5 -1 0 3 5 -1
Paths for cutoff 4:
0 1 2 3 5 -1 0 1 2 5 -1 0 3 2 5 -1 0 3 4 5 -1 0 3 5 -1
Paths for cutoff 5:
0 1 2 3 4 5 -1 0 1 2 3 5 -1 0 1 2 5 -1 0 3 2 5 -1 0 3 4 5 -1 0 3 5 -1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_incidence.c0000644000175100001710000000533400000000000026256 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, igraph_vector_bool_t *types) {
    igraph_matrix_t result;
    igraph_vector_t row_ids;
    igraph_vector_t col_ids;
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init(&row_ids, 0);
    igraph_vector_init(&col_ids, 0);
    IGRAPH_ASSERT(igraph_get_incidence(graph, types, &result, &row_ids, &col_ids) == IGRAPH_SUCCESS);
    printf("Incidence matrix:\n");
    print_matrix(&result);
    printf("Row ids:\n");
    print_vector(&row_ids);
    printf("Col ids:\n");
    print_vector(&col_ids);
    printf("\n");
    igraph_vector_destroy(&row_ids);
    igraph_vector_destroy(&col_ids);
    igraph_matrix_destroy(&result);
}


int main() {
    igraph_t g_0, g_1, g_mu, g_mun;
    igraph_vector_bool_t t_0, t_1, t_mu;
    igraph_matrix_t result;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_mu, 6, 0, 0,1, 0,2, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_mun, 6, 0, 0,1, 0,2, 0,3, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);

    igraph_vector_bool_init(&t_0, 0);
    igraph_vector_bool_init_int(&t_1, 1, 1);
    igraph_vector_bool_init_int(&t_mu, 6, 0, 1, 1, 0, 1, 0);

    igraph_matrix_init(&result, 0, 0);

    printf("No vertices:\n");
    call_and_print(&g_0, &t_0);

    printf("One vertex:\n");
    call_and_print(&g_1, &t_1);

    printf("Disconnected graph with multiple edges:\n");
    call_and_print(&g_mu, &t_mu);

    printf("Checking non-bipartite graph.\n");
    call_and_print(&g_mun, &t_mu);

    VERIFY_FINALLY_STACK();

    printf("Checking wrong type vector size error handling.\n");
    CHECK_ERROR(igraph_get_incidence(&g_mu, &t_0, &result, NULL, NULL), IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_mu);
    igraph_destroy(&g_mun);

    igraph_vector_bool_destroy(&t_0);
    igraph_vector_bool_destroy(&t_1);
    igraph_vector_bool_destroy(&t_mu);

    igraph_matrix_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_incidence.out0000644000175100001710000000101700000000000026635 0ustar00runnerdocker00000000000000No vertices:
Incidence matrix:
Row ids:
( )
Col ids:
( )

One vertex:
Incidence matrix:
Row ids:
( )
Col ids:
( 0 )

Disconnected graph with multiple edges:
Incidence matrix:
[        1        3        0
         1        1        2
         0        0        0 ]
Row ids:
( 0 3 5 )
Col ids:
( 1 2 4 )

Checking non-bipartite graph.
Incidence matrix:
[        1        3        0
         1        1        2
         0        0        0 ]
Row ids:
( 0 3 5 )
Col ids:
( 1 2 4 )

Checking wrong type vector size error handling.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_isomorphisms_vf2.c0000644000175100001710000001203300000000000027640 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

/* Vertices/edges with the same parity match */
igraph_bool_t compat_parity(const igraph_t *graph1,
                            const igraph_t *graph2,
                            const igraph_integer_t g1_num,
                            const igraph_integer_t g2_num,
                            void *arg) {
    IGRAPH_UNUSED(graph1);
    IGRAPH_UNUSED(graph2);
    IGRAPH_UNUSED(arg);
    return (g1_num % 2) == (g2_num % 2);
}

igraph_bool_t compat_not_arg(const igraph_t *graph1,
                             const igraph_t *graph2,
                             const igraph_integer_t g1_num,
                             const igraph_integer_t g2_num,
                             void *arg) {
    IGRAPH_UNUSED(graph1);
    IGRAPH_UNUSED(graph2);
    IGRAPH_UNUSED(arg);
    return g1_num != *(int*)arg + g2_num;
}

void print_and_destroy_maps(igraph_vector_ptr_t *vp) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(vp); i++) {
        print_vector(VECTOR(*vp)[i]);
        igraph_vector_destroy(VECTOR(*vp)[i]);
        igraph_free(VECTOR(*vp)[i]);
    }
    igraph_vector_ptr_destroy(vp);
}

void check_print_destroy(igraph_t *g1,
                         igraph_t *g2,
                         igraph_vector_int_t *vertex_color1,
                         igraph_vector_int_t *vertex_color2,
                         igraph_vector_int_t *edge_color1,
                         igraph_vector_int_t *edge_color2,
                         igraph_isocompat_t *node_compat_fn,
                         igraph_isocompat_t *edge_compat_fn,
                         void *arg,
                         int error) {
    igraph_vector_ptr_t maps;
    igraph_vector_ptr_init(&maps, 0);
    IGRAPH_ASSERT(igraph_get_isomorphisms_vf2(g1, g2, vertex_color1, vertex_color2, edge_color1, edge_color2, &maps, node_compat_fn, edge_compat_fn, arg) == error);
    print_and_destroy_maps(&maps);
    printf("\n");
}

void check_print_destroy_simple(igraph_t *g1, igraph_t *g2) {
    check_print_destroy(g1, g2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);
}

int main() {
    igraph_t ring, ring_dir;
    igraph_t g_0, g_1;
    igraph_vector_int_t coloring;
    int three = 3;

    igraph_vector_int_init_int(&coloring, 5, 0, 1, 0, 1, 0);
    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_ring(&ring, 5, /*directed*/ 0, /*mutual*/ 0, /*circular*/ 1);
    igraph_ring(&ring_dir, 5, /*directed*/ 1, /*mutual*/ 0, /*circular*/ 1);

    printf("Two empty graphs:\n");
    check_print_destroy_simple(&g_0, &g_0);

    printf("Two singleton graphs:\n");
    check_print_destroy_simple(&g_1, &g_1);

    printf("Empty and singleton graphs:\n");
    check_print_destroy_simple(&g_0, &g_1);

    printf("Two rings:\n");
    check_print_destroy_simple(&ring, &ring);

    printf("Two directed rings:\n");
    check_print_destroy_simple(&ring_dir, &ring_dir);

    printf("Two rings where node parity should be equal:\n");
    check_print_destroy(&ring, &ring, NULL, NULL, NULL, NULL, &compat_parity, NULL, NULL, IGRAPH_SUCCESS);

    printf("Two rings where edge parity should be equal:\n");
    check_print_destroy(&ring, &ring, NULL, NULL, NULL, NULL, NULL, &compat_parity, NULL, IGRAPH_SUCCESS);

    printf("Two rings with only one vertex coloring:\n");
    check_print_destroy(&ring, &ring, &coloring, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Two rings with vertex coloring:\n");
    check_print_destroy(&ring, &ring, &coloring, &coloring, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Two rings with edge coloring:\n");
    check_print_destroy(&ring, &ring, NULL, NULL, &coloring, &coloring, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Two rings where node of graph 1 should not be 3 higher than node of graph 2:\n");
    check_print_destroy(&ring, &ring, NULL, NULL, NULL, NULL, &compat_not_arg, NULL, &three, IGRAPH_SUCCESS);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Two rings with different directedness.\n");
    check_print_destroy(&ring, &ring_dir, NULL, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&ring);
    igraph_destroy(&ring_dir);
    igraph_vector_int_destroy(&coloring);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_isomorphisms_vf2.out0000644000175100001710000000173600000000000030235 0ustar00runnerdocker00000000000000Two empty graphs:
( )

Two singleton graphs:
( 0 )

Empty and singleton graphs:

Two rings:
( 0 1 2 3 4 )
( 0 4 3 2 1 )
( 1 0 4 3 2 )
( 1 2 3 4 0 )
( 2 1 0 4 3 )
( 2 3 4 0 1 )
( 3 2 1 0 4 )
( 3 4 0 1 2 )
( 4 0 1 2 3 )
( 4 3 2 1 0 )

Two directed rings:
( 0 1 2 3 4 )
( 1 2 3 4 0 )
( 2 3 4 0 1 )
( 3 4 0 1 2 )
( 4 0 1 2 3 )

Two rings where node parity should be equal:
( 0 1 2 3 4 )
( 4 3 2 1 0 )

Two rings where edge parity should be equal:
( 0 1 2 3 4 )
( 0 4 3 2 1 )

Two rings with only one vertex coloring:
( 0 1 2 3 4 )
( 0 4 3 2 1 )
( 1 0 4 3 2 )
( 1 2 3 4 0 )
( 2 1 0 4 3 )
( 2 3 4 0 1 )
( 3 2 1 0 4 )
( 3 4 0 1 2 )
( 4 0 1 2 3 )
( 4 3 2 1 0 )

Two rings with vertex coloring:
( 0 1 2 3 4 )
( 4 3 2 1 0 )

Two rings with edge coloring:
( 0 1 2 3 4 )
( 0 4 3 2 1 )

Two rings where node of graph 1 should not be 3 higher than node of graph 2:
( 0 1 2 3 4 )
( 1 0 4 3 2 )
( 1 2 3 4 0 )
( 2 1 0 4 3 )
( 2 3 4 0 1 )
( 4 0 1 2 3 )
( 4 3 2 1 0 )

Two rings with different directedness.

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_shortest_paths2.c0000644000175100001710000000610700000000000027470 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    const igraph_real_t edges[] = { 0, 1, 0, 2, 1, 6, 2, 6, 1, 3, 1, 4, 1, 5,
                                    3, 2, 4, 2, 5, 2
                                  };
    igraph_t g;
    igraph_vector_t edgev;
    igraph_vector_ptr_t resvertices, resedges;
    igraph_vector_long_t predecessors, inbound_edges;
    int vcount, i;

    igraph_vector_view(&edgev, edges, sizeof(edges) / sizeof(igraph_real_t));
    vcount = igraph_vector_max(&edgev) + 1;
    igraph_create(&g, &edgev, vcount, IGRAPH_DIRECTED);

    igraph_vector_ptr_init(&resvertices, vcount);
    igraph_vector_ptr_init(&resedges, vcount);
    igraph_vector_long_init(&predecessors, 0);
    igraph_vector_long_init(&inbound_edges, 0);

    for (i = 0; i < vcount; i++) {
        igraph_vector_t *v1 = malloc(sizeof(igraph_vector_t));
        igraph_vector_t *v2 = malloc(sizeof(igraph_vector_t));
        if (!v1 || !v2) {
            exit(2);
        }
        igraph_vector_init(v1, 0);
        igraph_vector_init(v2, 0);
        VECTOR(resvertices)[i] = v1;
        VECTOR(resedges)[i] = v2;
    }

    igraph_get_shortest_paths(&g, &resvertices, &resedges, /*from=*/ 0,
                              /*to=*/ igraph_vss_all(), /*mode=*/ IGRAPH_OUT,
                              &predecessors, &inbound_edges);

    for (i = 0; i < vcount; i++) {
        igraph_vector_t *v1 = VECTOR(resvertices)[i];
        igraph_vector_t *v2 = VECTOR(resedges)[i];
        printf("%i V: ", i);
        igraph_vector_print(v1);
        printf("%i E: ", i);
        igraph_vector_print(v2);
    }
    printf("pred: ");
    igraph_vector_long_print(&predecessors);
    printf("inbe: ");
    igraph_vector_long_print(&inbound_edges);

    igraph_vector_long_destroy(&inbound_edges);
    igraph_vector_long_destroy(&predecessors);
    for (i = 0; i < vcount; i++) {
        igraph_vector_t *v1 = VECTOR(resvertices)[i];
        igraph_vector_t *v2 = VECTOR(resedges)[i];
        igraph_vector_destroy(v1);
        igraph_vector_destroy(v2);
        igraph_free(v1);
        igraph_free(v2);
    }
    igraph_vector_ptr_destroy(&resedges);
    igraph_vector_ptr_destroy(&resvertices);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_shortest_paths2.out0000644000175100001710000000024600000000000030053 0ustar00runnerdocker000000000000000 V: 0
0 E: 
1 V: 0 1
1 E: 0
2 V: 0 2
2 E: 1
3 V: 0 1 3
3 E: 0 4
4 V: 0 1 4
4 E: 0 5
5 V: 0 1 5
5 E: 0 6
6 V: 0 1 6
6 E: 0 2
pred: 0 0 0 1 1 1 1
inbe: -1 0 1 4 5 6 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_shortest_paths_bellman_ford.c0000644000175100001710000002256100000000000032114 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   (C) 2006-2021 The igraph development team  Gabor Csardi 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include "test_utilities.inc"
#include 

void check_evecs(const igraph_t *graph, const igraph_vector_ptr_t *vecs,
                 const igraph_vector_ptr_t *evecs) {

    igraph_bool_t directed = igraph_is_directed(graph);
    long int i, n = igraph_vector_ptr_size(vecs);

    IGRAPH_ASSERT(igraph_vector_ptr_size(evecs) == n);

    for (i = 0; i < n; i++) {
        igraph_vector_t *vvec = VECTOR(*vecs)[i];
        igraph_vector_t *evec = VECTOR(*evecs)[i];
        long int j, n2 = igraph_vector_size(evec);
        if (igraph_vector_size(vvec) == 0 && n2 == 0) {
            continue;
        }
        IGRAPH_ASSERT(igraph_vector_size(vvec) == n2 + 1);

        for (j = 0; j < n2; j++) {
            long int edge = VECTOR(*evec)[j];
            long int from = VECTOR(*vvec)[j];
            long int to = VECTOR(*vvec)[j + 1];
            if (directed) {
                IGRAPH_ASSERT(from == IGRAPH_FROM(graph, edge) &&
                              to == IGRAPH_TO(graph, edge));
            } else {
                long int from2 = IGRAPH_FROM(graph, edge);
                long int to2 = IGRAPH_TO(graph, edge);
                long int min1 = from < to ? from : to;
                long int max1 = from < to ? to : from;
                long int min2 = from2 < to2 ? from2 : to2;
                long int max2 = from2 < to2 ? to2 : from2;
                IGRAPH_ASSERT(min1 == min2 && max1 == max2);
            }
        }
    }
}

void check_pred_inbound(const igraph_t* graph, const igraph_vector_long_t* pred,
                        const igraph_vector_long_t* inbound, int start) {

    long int i, n = igraph_vcount(graph);

    IGRAPH_ASSERT(igraph_vector_long_size(pred) == n);
    IGRAPH_ASSERT(igraph_vector_long_size(inbound) == n);

    IGRAPH_ASSERT(VECTOR(*pred)[start] == start && VECTOR(*inbound)[start] == -1);

    for (i = 0; i < n; i++) {
        if (VECTOR(*pred)[i] == -1) {
            IGRAPH_ASSERT(VECTOR(*inbound)[i] == -1);

        } else if (VECTOR(*pred)[i] == i) {
            IGRAPH_ASSERT(i == start);

            IGRAPH_ASSERT(VECTOR(*inbound)[i] == -1);

        } else {
            long int eid = VECTOR(*inbound)[i];
            long int u = IGRAPH_FROM(graph, eid), v = IGRAPH_TO(graph, eid);
            if (v != i && !igraph_is_directed(graph)) {
                long int dummy = u;
                u = v;
                v = dummy;
            }
            IGRAPH_ASSERT(v == i);
            IGRAPH_ASSERT(u == VECTOR(*pred)[i]);
        }
    }
}

int main() {
    igraph_t g;
    igraph_vector_ptr_t vecs, evecs;
    igraph_vector_long_t pred, inbound;
    long int i;
    igraph_real_t weights_data_0[] = { 0, 2, 1, 0, 5, 2, 1, 1, 0, 2, 2, 8, 1, 1, 3, 1, 1, 4, 2, 1 };
    igraph_real_t weights_data_1[] = { 6, 7, 8, -4, -2, -3, 9, 2, 7 };
    igraph_real_t weights_data_2[] = { 6, 7, 2, -4, -2, -3, 9, 2, 7 };
    igraph_vector_t weights_vec;
    igraph_vs_t vs;
    igraph_integer_t vs_size;

    igraph_small(&g, 10, IGRAPH_DIRECTED,
                0, 1, 0, 2, 0, 3,    1, 2, 1, 4, 1, 5,
                2, 3, 2, 6,         3, 2, 3, 6,
                4, 5, 4, 7,         5, 6, 5, 8, 5, 9,
                7, 5, 7, 8,         8, 9,
                5, 2,
                2, 1,
                -1);

    igraph_vector_long_init(&pred, 0);
    igraph_vector_long_init(&inbound, 0);

    printf("Paths to only some vertices\n");

    igraph_vs_vector_small(&vs, 0, 1, 3, 5, 2, 1,  -1);
    igraph_vs_size(&g, &vs, &vs_size);

    igraph_vector_ptr_init(&vecs, vs_size);
    igraph_vector_ptr_init(&evecs, vs_size);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(vecs)[i], 0);
        VECTOR(evecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(evecs)[i], 0);
    }

    igraph_vector_view(&weights_vec, weights_data_0, sizeof(weights_data_0) / sizeof(igraph_real_t));
    igraph_get_shortest_paths_bellman_ford(&g, /*vertices=*/ &vecs, /*edges=*/ &evecs,
                                           /*from=*/ 0, /*to=*/ vs,
                                           &weights_vec, IGRAPH_OUT,
                                           /*predecessors=*/ &pred,
                                           /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector_round(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(vecs)[i]);
        free(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(evecs)[i]);
        free(VECTOR(evecs)[i]);
    }

    printf("\nPaths to all vertices\n");

    vs_size = igraph_vcount(&g);

    igraph_vector_ptr_resize(&vecs, vs_size);
    igraph_vector_ptr_resize(&evecs, vs_size);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(vecs)[i], 0);
        VECTOR(evecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(evecs)[i], 0);
    }

    igraph_get_shortest_paths_bellman_ford(&g, /*vertices=*/ &vecs, /*edges=*/ &evecs,
                                           /*from=*/ 0, /*to=*/ igraph_vss_all(),
                                           &weights_vec, IGRAPH_OUT,
                                           /*predecessors=*/ &pred,
                                           /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector_round(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(vecs)[i]);
        free(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(evecs)[i]);
        free(VECTOR(evecs)[i]);
    }

    igraph_vector_ptr_destroy(&vecs);
    igraph_vector_ptr_destroy(&evecs);

    igraph_vector_long_destroy(&pred);
    igraph_vector_long_destroy(&inbound);

    igraph_vs_destroy(&vs);
    igraph_destroy(&g);


    printf("\nGraph with negative weights\n");

    /***************************************/

    /* Graph with negative weights */

    igraph_vector_ptr_init(&vecs, 5);
    igraph_vector_ptr_init(&evecs, 5);
    igraph_vector_long_init(&pred, 0);
    igraph_vector_long_init(&inbound, 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(vecs)[i], 0);
        VECTOR(evecs)[i] = calloc(1, sizeof(igraph_vector_t));
        igraph_vector_init(VECTOR(evecs)[i], 0);
    }
    igraph_vs_vector_small(&vs, 0, 1, 3, 2, 1,  -1);
    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 0, 3, 1, 3, 1, 4, 2, 1, 3, 2, 3, 4, 4, 0, 4, 2,
                 -1);

    igraph_vector_view(&weights_vec, weights_data_1, sizeof(weights_data_1) / sizeof(igraph_real_t));
    igraph_get_shortest_paths_bellman_ford(&g, /*vertices=*/ &vecs, /*edges=*/ &evecs,
                                           /*from=*/ 0, /*to=*/ vs,
                                           &weights_vec, IGRAPH_OUT,
                                           /*predecessors=*/ &pred,
                                           /*inbound_edges=*/ &inbound);

    check_evecs(&g, &vecs, &evecs);
    check_pred_inbound(&g, &pred, &inbound, /* from= */ 0);

    for (i = 0; i < igraph_vector_ptr_size(&vecs); i++) {
        print_vector_round(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(vecs)[i]);
        free(VECTOR(vecs)[i]);
        igraph_vector_destroy(VECTOR(evecs)[i]);
        free(VECTOR(evecs)[i]);
    }

    /***************************************/

    /* Same graph with negative loop */
    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_view(&weights_vec, weights_data_2,
                       sizeof(weights_data_2) / sizeof(igraph_real_t));
    IGRAPH_ASSERT(igraph_get_shortest_paths_bellman_ford(&g, /*vertices=*/ &vecs, /*edges=*/ &evecs,
                                                         /*from=*/ 0, /*to=*/ vs,
                                                         &weights_vec, IGRAPH_OUT,
                                                         /*predecessors=*/ &pred,
                                                         /*inbound_edges=*/ &inbound) == IGRAPH_ENEGLOOP);

    igraph_vector_ptr_destroy(&vecs);
    igraph_vector_ptr_destroy(&evecs);
    igraph_vector_long_destroy(&pred);
    igraph_vector_long_destroy(&inbound);

    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_shortest_paths_bellman_ford.out0000644000175100001710000000042600000000000032475 0ustar00runnerdocker00000000000000Paths to only some vertices
( 0 )
( 0 1 )
( 0 3 )
( 0 1 5 )
( 0 1 2 )
( 0 1 )

Paths to all vertices
( 0 )
( 0 1 )
( 0 1 2 )
( 0 3 )
( 0 1 4 )
( 0 1 5 )
( 0 1 2 6 )
( 0 1 4 7 )
( 0 1 5 8 )
( 0 1 5 9 )

Graph with negative weights
( 0 )
( 0 3 2 1 )
( 0 3 )
( 0 3 2 )
( 0 3 2 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_subisomorphisms_vf2.c0000644000175100001710000001353600000000000030363 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

/* Vertices/edges with the same parity match */
igraph_bool_t compat_parity(const igraph_t *graph1,
                            const igraph_t *graph2,
                            const igraph_integer_t g1_num,
                            const igraph_integer_t g2_num,
                            void *arg) {
    IGRAPH_UNUSED(graph1);
    IGRAPH_UNUSED(graph2);
    IGRAPH_UNUSED(arg);
    return (g1_num % 2) == (g2_num % 2);
}

igraph_bool_t compat_not_arg(const igraph_t *graph1,
                             const igraph_t *graph2,
                             const igraph_integer_t g1_num,
                             const igraph_integer_t g2_num,
                             void *arg) {
    IGRAPH_UNUSED(graph1);
    IGRAPH_UNUSED(graph2);
    IGRAPH_UNUSED(arg);
    return g1_num != *(int*)arg + g2_num;
}

void print_and_destroy_maps(igraph_vector_ptr_t *vp) {
    long int i;
    for (i = 0; i < igraph_vector_ptr_size(vp); i++) {
        print_vector(VECTOR(*vp)[i]);
        igraph_vector_destroy(VECTOR(*vp)[i]);
        igraph_free(VECTOR(*vp)[i]);
    }
    igraph_vector_ptr_destroy(vp);
}

void check_print_destroy(igraph_t *g1,
                         igraph_t *g2,
                         igraph_vector_int_t *vertex_color1,
                         igraph_vector_int_t *vertex_color2,
                         igraph_vector_int_t *edge_color1,
                         igraph_vector_int_t *edge_color2,
                         igraph_isocompat_t *node_compat_fn,
                         igraph_isocompat_t *edge_compat_fn,
                         void *arg,
                         int error) {
    igraph_vector_ptr_t maps;
    igraph_vector_ptr_init(&maps, 0);
    IGRAPH_ASSERT(igraph_get_subisomorphisms_vf2(g1, g2, vertex_color1, vertex_color2, edge_color1, edge_color2, &maps, node_compat_fn, edge_compat_fn, arg) == error);
    print_and_destroy_maps(&maps);
    printf("\n");
}

void check_print_destroy_simple(igraph_t *g1, igraph_t *g2) {
    check_print_destroy(g1, g2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);
}

int main() {
    igraph_t ring, ring_dir;
    igraph_t ring_plus, ring_plus_dir;
    igraph_t g_0, g_1;
    igraph_vector_int_t coloring;
    igraph_vector_int_t plus_edge_coloring;
    igraph_vector_int_t plus_vertex_coloring;
    int three = 3;

    igraph_vector_int_init_int(&plus_vertex_coloring, 6, 0, 1, 0, 1, 1, 0);
    igraph_vector_int_init_int(&coloring, 5, 0, 1, 0, 1, 0);
    igraph_vector_int_init_int(&plus_edge_coloring, 6, 0, 0, 1, 0, 1, 0);
    igraph_small(&ring_plus, 6, 0, 0,1, 0,3, 2,1, 2,3, 3,5, 5,0, -1);
    igraph_small(&ring_plus_dir, 6, 1, 0,1, 0,3, 1,2, 2,3, 3,5, 5,0, -1);
    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_ring(&ring, 5, /*directed*/ 0, /*mutual*/ 0, /*circular*/ 1);
    igraph_ring(&ring_dir, 5, /*directed*/ 1, /*mutual*/ 0, /*circular*/ 1);

    printf("Two empty graphs:\n");
    check_print_destroy_simple(&g_0, &g_0);

    printf("Two singleton graphs:\n");
    check_print_destroy_simple(&g_1, &g_1);

    printf("Empty and singleton graphs:\n");
    check_print_destroy_simple(&g_0, &g_1);

    printf("Singleton and empty graphs:\n");
    check_print_destroy_simple(&g_1, &g_0);

    printf("Ring with add vertex and edge (ring+) and ring:\n");
    check_print_destroy_simple(&ring_plus, &ring);

    printf("Ring+ and ring, directed:\n");
    check_print_destroy_simple(&ring_plus_dir, &ring_dir);

    printf("Ring+ and ring where node parity should be equal:\n");
    check_print_destroy(&ring_plus, &ring, NULL, NULL, NULL, NULL, &compat_parity, NULL, NULL, IGRAPH_SUCCESS);

    printf("Ring+ and ring where edge parity should be equal:\n");
    check_print_destroy(&ring_plus, &ring, NULL, NULL, NULL, NULL, NULL, &compat_parity, NULL, IGRAPH_SUCCESS);

    printf("Ring+ and ring with only one vertex coloring:\n");
    check_print_destroy(&ring_plus, &ring, &coloring, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Ring+ and ring with vertex coloring:\n");
    check_print_destroy(&ring_plus, &ring, &plus_vertex_coloring, &coloring, NULL, NULL, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Ring+ and ring with edge coloring:\n");
    check_print_destroy(&ring_plus, &ring, NULL, NULL, &plus_edge_coloring, &coloring, NULL, NULL, NULL, IGRAPH_SUCCESS);

    printf("Ring+ and ring where node of graph 1 should not be 3 higher than node of graph 2:\n");
    check_print_destroy(&ring_plus, &ring, NULL, NULL, NULL, NULL, &compat_not_arg, NULL, &three, IGRAPH_SUCCESS);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Ring+ and ring with different directedness.\n");
    check_print_destroy(&ring_plus_dir, &ring, NULL, NULL, NULL, NULL, NULL, NULL, NULL, IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&ring);
    igraph_destroy(&ring_dir);
    igraph_destroy(&ring_plus);
    igraph_destroy(&ring_plus_dir);
    igraph_vector_int_destroy(&coloring);
    igraph_vector_int_destroy(&plus_edge_coloring);
    igraph_vector_int_destroy(&plus_vertex_coloring);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_get_subisomorphisms_vf2.out0000644000175100001710000000204300000000000030737 0ustar00runnerdocker00000000000000Two empty graphs:
( )

Two singleton graphs:
( 0 )

Empty and singleton graphs:

Singleton and empty graphs:
( )

Ring with add vertex and edge (ring+) and ring:
( 0 1 2 3 5 )
( 0 5 3 2 1 )
( 1 0 5 3 2 )
( 1 2 3 5 0 )
( 2 1 0 5 3 )
( 2 3 5 0 1 )
( 3 2 1 0 5 )
( 3 5 0 1 2 )
( 5 0 1 2 3 )
( 5 3 2 1 0 )

Ring+ and ring, directed:
( 0 1 2 3 5 )
( 1 2 3 5 0 )
( 2 3 5 0 1 )
( 3 5 0 1 2 )
( 5 0 1 2 3 )

Ring+ and ring where node parity should be equal:

Ring+ and ring where edge parity should be equal:
( 1 0 5 3 2 )
( 1 2 3 5 0 )

Ring+ and ring with only one vertex coloring:
( 0 1 2 3 5 )
( 0 5 3 2 1 )
( 1 0 5 3 2 )
( 1 2 3 5 0 )
( 2 1 0 5 3 )
( 2 3 5 0 1 )
( 3 2 1 0 5 )
( 3 5 0 1 2 )
( 5 0 1 2 3 )
( 5 3 2 1 0 )

Ring+ and ring with vertex coloring:
( 0 1 2 3 5 )
( 5 3 2 1 0 )

Ring+ and ring with edge coloring:
( 0 1 2 3 5 )
( 0 5 3 2 1 )

Ring+ and ring where node of graph 1 should not be 3 higher than node of graph 2:
( 0 1 2 3 5 )
( 0 5 3 2 1 )
( 1 2 3 5 0 )
( 2 1 0 5 3 )
( 5 0 1 2 3 )
( 5 3 2 1 0 )

Ring+ and ring with different directedness.

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_gomory_hu_tree.c0000644000175100001710000002046100000000000026523 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int validate_tree(const igraph_t *graph, const igraph_t *tree,
                  const igraph_vector_t *flow, const igraph_vector_t *capacity) {
    igraph_integer_t n = igraph_vcount(graph);
    igraph_integer_t no_of_clusters, min_weight_edge_index;
    igraph_vector_t edges;
    igraph_vector_t membership;
    igraph_real_t min_weight, flow_value;
    igraph_t copy;
    long int i, j, k, m;

    if (igraph_vcount(tree) != n) {
        printf("Gomory-Hu tree should have %ld vertices\n", (long int)n);
        return IGRAPH_EINVAL;
    }

    if (igraph_ecount(tree) != n - 1) {
        printf("Gomory-Hu tree should have %ld edges\n", (long int)n - 1);
        return IGRAPH_EINVAL;
    }

    if (igraph_is_directed(tree)) {
        printf("Gomory-Hu tree should be undirected\n");
        return IGRAPH_EINVAL;
    }

    if (n < 2) {
        return IGRAPH_SUCCESS;
    }

    IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
    IGRAPH_VECTOR_INIT_FINALLY(&membership, 0);

    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            IGRAPH_CHECK(igraph_get_shortest_path(tree, 0, &edges, i, j, IGRAPH_ALL));
            m = igraph_vector_size(&edges);
            if (m == 0) {
                continue;
            }

            /* first, check whether the minimum weight along the shortest path
             * from i to j is the same as the maximum flow between i and j in
             * the original graph */
            min_weight = VECTOR(*flow)[(long int)VECTOR(edges)[0]];
            min_weight_edge_index = VECTOR(edges)[0];
            for (k = 1; k < m; k++) {
                if (VECTOR(*flow)[(long int)VECTOR(edges)[k]] < min_weight) {
                    min_weight = VECTOR(*flow)[(long int)VECTOR(edges)[k]];
                    min_weight_edge_index = VECTOR(edges)[k];
                }
            }

            IGRAPH_CHECK(igraph_maxflow(graph, &flow_value, 0, 0, 0, 0, i, j, capacity, 0));
            if (flow_value != min_weight) {
                printf("Min weight of path %ld --> %ld in Gomory-Hu tree is %.4f, "
                       "expected %.4f from flow calculation\n", i, j, min_weight, flow_value);
                return IGRAPH_EINVAL;
            }

            /* next, check whether removing an edge s-t from the Gomory-Hu tree would
             * partition it exactly the same way as a minimum cut between s and t in
             * the original graph */
            IGRAPH_CHECK(igraph_copy(©, tree));
            IGRAPH_FINALLY(igraph_destroy, ©);

            IGRAPH_CHECK(igraph_delete_edges(©, igraph_ess_1(min_weight_edge_index)));
            IGRAPH_CHECK(igraph_clusters(©, &membership, 0, &no_of_clusters, IGRAPH_WEAK));

            if (no_of_clusters != 2) {
                printf(
                    "Removing edge %ld -- %ld (index %ld) from the Gomory-Hu tree cuts it "
                    "in %ld clusters, expected 2\n",
                    (long int) IGRAPH_FROM(tree, min_weight_edge_index),
                    (long int) IGRAPH_TO(tree, min_weight_edge_index),
                    (long int) min_weight_edge_index,
                    (long int) no_of_clusters
                );
                return IGRAPH_EINVAL;
            }

            /* finally, check the total capacity of the edges that go between the
             * partitions in the original graph; it should be the same as the
             * weight of the edge in the Gomory-Hu tree that corresponds to the
             * minimum weight along the path we found above */
            m = igraph_ecount(graph);
            flow_value = 0.0;
            for (j = 0; j < m; j++) {
                if (VECTOR(membership)[IGRAPH_FROM(graph, j)] != VECTOR(membership)[IGRAPH_TO(graph, j)]) {
                    flow_value += capacity ? VECTOR(*capacity)[j] : 1;
                }
            }

            if (flow_value != VECTOR(*flow)[min_weight_edge_index]) {
                printf(
                    "Edge %ld -- %ld (index %ld) in the Gomory-Hu tree has weight = %.2f, but "
                    "the corresponding flow in the original graph has value = %.2f\n",
                    (long int) IGRAPH_FROM(tree, min_weight_edge_index),
                    (long int) IGRAPH_TO(tree, min_weight_edge_index),
                    (long int) min_weight_edge_index,
                    VECTOR(*flow)[min_weight_edge_index], flow_value
                );
                printf("Edge list of original graph:\n");
                print_graph(graph);
                if (capacity) {
                    printf("Capacities of original graph: ");
                    print_vector(capacity);
                } else {
                    printf("All edges have capacity = 1\n");
                }
                printf("Edge list of Gomory-Hu tree:\n");
                print_graph(tree);
                printf("Weights of the Gomory-Hu tree: ");
                print_vector(flow);
                printf("Partition of original graph corresponding to this cut:\n");
                print_vector(&membership);
                return IGRAPH_EINVAL;
            }

            igraph_destroy(©);
            IGRAPH_FINALLY_CLEAN(1);
        }
    }

    igraph_vector_destroy(&edges);
    igraph_vector_destroy(&membership);
    IGRAPH_FINALLY_CLEAN(2);

    return IGRAPH_SUCCESS;
}

int main() {

    igraph_t g;
    igraph_t tree;
    igraph_vector_t flow;
    igraph_vector_t capacity;

    /* initialize flow and capacity vectors */
    igraph_vector_init(&capacity, 0);
    igraph_vector_init(&flow, 0);

    /* empty undirected graph */
    igraph_empty(&g, 0, 0);
    IGRAPH_ASSERT(igraph_gomory_hu_tree(&g, &tree, &flow, &capacity) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&tree) == 0);
    IGRAPH_ASSERT(igraph_vector_size(&flow) == 0);
    igraph_destroy(&tree);
    igraph_destroy(&g);

    /* simple undirected graph */
    igraph_small(&g, 6, 0, 0, 1, 0, 2, 1, 2, 1, 3, 1, 4, 2, 4, 3, 4, 3, 5, 4, 5, -1);
    igraph_vector_resize(&capacity, 9);
    VECTOR(capacity)[0] = 1;
    VECTOR(capacity)[1] = 7;
    VECTOR(capacity)[2] = 1;
    VECTOR(capacity)[3] = 3;
    VECTOR(capacity)[4] = 2;
    VECTOR(capacity)[5] = 4;
    VECTOR(capacity)[6] = 1;
    VECTOR(capacity)[7] = 6;
    VECTOR(capacity)[8] = 2;
    IGRAPH_ASSERT(igraph_gomory_hu_tree(&g, &tree, &flow, &capacity) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(validate_tree(&g, &tree, &flow, &capacity) == IGRAPH_SUCCESS);
    igraph_destroy(&tree);

    /* Make sure we don't blow up without an outgoing flow vector */
    IGRAPH_ASSERT(igraph_gomory_hu_tree(&g, &tree, 0, &capacity) == IGRAPH_SUCCESS);
    igraph_destroy(&tree);
    igraph_destroy(&g);

    /* example from Github issue #1810 */
    igraph_full(&g, 4, /* directed = */ 0, /* loops = */ 0);
    IGRAPH_ASSERT(igraph_gomory_hu_tree(&g, &tree, &flow, 0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(validate_tree(&g, &tree, &flow, 0) == IGRAPH_SUCCESS);
    igraph_destroy(&tree);
    igraph_destroy(&g);

    /* simple directed graph - should throw an error */
    igraph_small(&g, 6, 1, 0, 1, 0, 2, 1, 2, 1, 3, 1, 4, 2, 4, 3, 4, 3, 5, 4, 5, -1);
    igraph_set_error_handler(igraph_error_handler_ignore);
    VERIFY_FINALLY_STACK();
    IGRAPH_ASSERT(igraph_gomory_hu_tree(&g, &tree, &flow, &capacity) == IGRAPH_EINVAL);
    igraph_set_error_handler(igraph_error_handler_abort);
    igraph_destroy(&g);

    /* destroy flow and capacity vectors */
    igraph_vector_destroy(&flow);
    igraph_vector_destroy(&capacity);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_grg_game.c0000644000175100001710000000233300000000000025242 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;

    igraph_rng_seed(igraph_rng_default(), 137);

    /* Empty graph */
    igraph_grg_game(&g, 100, 0, 0, 0, 0);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    igraph_destroy(&g);

    /* Full graph */
    igraph_grg_game(&g, 10, sqrt(2.0) / 2, 1, 0, 0);
    IGRAPH_ASSERT(igraph_ecount(&g) == igraph_vcount(&g) * (igraph_vcount(&g) - 1) / 2);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_growing_random_game.c0000644000175100001710000000432600000000000027503 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"


int main() {
    igraph_t g;
    igraph_vector_t degree;
    igraph_bool_t tree;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    /* no vertices */

    igraph_growing_random_game(&g, /* n: vertices */ 0, /* m: edges_per_vertex */ 3, /* directed */ 0, /* citation */ 0);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    IGRAPH_ASSERT(!igraph_is_directed(&g));
    igraph_destroy(&g);

    /* 1 edge per vertex with citation makes a tree */

    igraph_growing_random_game(&g, /* n: vertices */ 20, /* m: edges_per_vertex */ 1, /* directed */ 0, /* citation */ 1);
    igraph_is_tree(&g, &tree, /* root*/ NULL, /*unused mode*/ 0);
    IGRAPH_ASSERT(tree);
    igraph_destroy(&g);

    /* out degree of citation equals edges per vertex */

    igraph_growing_random_game(&g, /* n: vertices */ 10, /* m: edges_per_vertex */ 7, /* directed */ 1, /* citation */ 1);
    igraph_vector_init(°ree, 0);
    igraph_degree(&g, °ree, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    for(i = 1; i < 10; i++) {
        IGRAPH_ASSERT(VECTOR(degree)[i] == 7);
    }
    IGRAPH_ASSERT(igraph_is_directed(&g));
    igraph_vector_destroy(°ree);
    igraph_destroy(&g);

    /* total number of edges is (vertices - 1) * edges */

    igraph_growing_random_game(&g, /* n: vertices */ 10, /* m: edges_per_vertex */ 7, /* directed */ 1, /* citation */ 0);
    IGRAPH_ASSERT(igraph_ecount(&g) == 63);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_hrg.c0000644000175100001710000000452000000000000024252 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_t full, tree;
    igraph_hrg_t hrg;
    igraph_t dendrogram;
    // int i, j;
    // igraph_vector_t neis;

    igraph_rng_seed(igraph_rng_default(), 42);

    // We need attributes
    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_full(&full, 10, /*directed=*/ 0, /*loops=*/ 0);
    igraph_tree(&tree, 15, /*children=*/ 2, /*type=*/ IGRAPH_TREE_UNDIRECTED);
    igraph_disjoint_union(&graph, &full, &tree);
    igraph_add_edge(&graph, 0, 10);

    igraph_destroy(&full);
    igraph_destroy(&tree);

    // Fit
    igraph_hrg_init(&hrg, igraph_vcount(&graph));
    igraph_hrg_fit(&graph, &hrg, /*start=*/ 0, /*steps=*/ 0);

    // Create a graph from it
    igraph_hrg_dendrogram(&dendrogram, &hrg);

    // Print the tree, with labels
    // igraph_vector_init(&neis, 0);
    // for (i=0; i
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t karate;
    igraph_vector_t parents, weights;
    long int i, n;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&karate, 34, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 10, 0, 11, 0, 12, 0, 13,
                 0, 17, 0, 19, 0, 21, 0, 31,
                 1, 2, 1, 3, 1, 7, 1, 13, 1, 17, 1, 19, 1, 21, 1, 30,
                 2, 3, 2, 7, 2, 27, 2, 28, 2, 32, 2, 9, 2, 8, 2, 13,
                 3, 7, 3, 12, 3, 13,
                 4, 6, 4, 10,
                 5, 6, 5, 10, 5, 16,
                 6, 16,
                 8, 30, 8, 32, 8, 33,
                 9, 33,
                 13, 33,
                 14, 32, 14, 33,
                 15, 32, 15, 33,
                 18, 32, 18, 33,
                 19, 33,
                 20, 32, 20, 33,
                 22, 32, 22, 33,
                 23, 25, 23, 27, 23, 32, 23, 33, 23, 29,
                 24, 25, 24, 27, 24, 31,
                 25, 31,
                 26, 29, 26, 33,
                 27, 33,
                 28, 31, 28, 33,
                 29, 32, 29, 33,
                 30, 32, 30, 33,
                 31, 32, 31, 33,
                 32, 33,
                 -1);

    igraph_vector_init(&parents, 0);
    igraph_vector_init(&weights, 0);
    igraph_hrg_consensus(&karate, &parents, &weights, /* hrg= */ 0,
                         /* start= */ 0, /* num_samples= */ 100);

    /* We do some simple validity tests on the results only; the exact results
     * are different on i386 vs other platforms due to numerical inaccuracies */
    if (igraph_vector_size(&weights) + igraph_vcount(&karate) != igraph_vector_size(&parents)) {
        printf("Vector length mismatch: %ld + %ld != %ld\n",
            (long int) igraph_vector_size(&weights), (long int) igraph_vcount(&karate),
            (long int) igraph_vector_size(&parents)
        );
        abort();
    }

    n = igraph_vector_size(&parents);
    for (i = 0; i < n; i++) {
        if (VECTOR(parents)[i] < -1 || VECTOR(parents)[i] >= igraph_vcount(&karate) + igraph_vector_size(&weights)) {
            printf("Invalid parents vector:\n");
            igraph_vector_print(&parents);
            abort();
        }
    }

    igraph_vector_destroy(&parents);
    igraph_vector_destroy(&weights);
    igraph_destroy(&karate);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_hrg3.c0000644000175100001710000000622100000000000024335 0ustar00runnerdocker00000000000000/* -*- mode: C++ -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t karate;
    igraph_vector_t edges, prob;
    long int i, n;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&karate, 34, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 10, 0, 11, 0, 12, 0, 13,
                 0, 17, 0, 19, 0, 21, 0, 31,
                 1, 2, 1, 3, 1, 7, 1, 13, 1, 17, 1, 19, 1, 21, 1, 30,
                 2, 3, 2, 7, 2, 27, 2, 28, 2, 32, 2, 9, 2, 8, 2, 13,
                 3, 7, 3, 12, 3, 13,
                 4, 6, 4, 10,
                 5, 6, 5, 10, 5, 16,
                 6, 16,
                 8, 30, 8, 32, 8, 33,
                 9, 33,
                 13, 33,
                 14, 32, 14, 33,
                 15, 32, 15, 33,
                 18, 32, 18, 33,
                 19, 33,
                 20, 32, 20, 33,
                 22, 32, 22, 33,
                 23, 25, 23, 27, 23, 32, 23, 33, 23, 29,
                 24, 25, 24, 27, 24, 31,
                 25, 31,
                 26, 29, 26, 33,
                 27, 33,
                 28, 31, 28, 33,
                 29, 32, 29, 33,
                 30, 32, 30, 33,
                 31, 32, 31, 33,
                 32, 33,
                 -1);

    igraph_vector_init(&edges, 0);
    igraph_vector_init(&prob, 0);
    igraph_hrg_predict(&karate, &edges, &prob, /* hrg= */ 0, /* start= */ 0,
                       /* num_samples= */ 100, /* num_bins= */ 25);

    /* We do some simple validity tests on the resolts only; the exact results
     * are different on i386 vs other platforms due to numerical inaccuracies */
    n = igraph_vector_size(&edges);
    for (i = 0; i < n; i++) {
        if (VECTOR(edges)[i] < 0 || VECTOR(edges)[i] >= igraph_vcount(&karate)) {
            printf("Invalid edges vector:\n");
            igraph_vector_print(&edges);
            return 1;
        }
    }
    n = igraph_vector_size(&prob);
    for (i = 0; i < n; i++) {
        if (VECTOR(prob)[i] < 0 || VECTOR(prob)[i] > 1) {
            printf("Invalid prob vector:\n");
            igraph_vector_print(&prob);
            return 2;
        }
    }

    igraph_vector_destroy(&prob);
    igraph_vector_destroy(&edges);

    igraph_destroy(&karate);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_i_incident.c0000644000175100001710000001225000000000000025576 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"
#include "../../src/graph/neighbors.h"

void call_and_print(igraph_t *graph, igraph_integer_t pnode, igraph_neimode_t mode, igraph_loops_t loops, igraph_multiple_t multiple) {
    igraph_vector_t eids;
    igraph_vector_init(&eids, 0);
    IGRAPH_ASSERT(igraph_i_incident(graph, &eids, pnode, mode, loops, multiple) == IGRAPH_SUCCESS);
    print_vector(&eids);
    igraph_vector_destroy(&eids);
}


int main() {
    igraph_t g_1, g_lm, g_lmu, g_s1, g_s2;

    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_s1, 2, 1, 0,1, 0,1, 1,0, 1,0, -1);
    igraph_small(&g_s2, 2, 1, 0,1, 1,0, 1,0, -1);

    igraph_vector_t eids;
    igraph_vector_init(&eids, 0);

    printf("One vertex:\n");
    call_and_print(&g_1, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_IN, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_OUT, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, undirected, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lmu, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_IN, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_OUT, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_ALL, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, undirected, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lmu, 0, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_OUT, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lm, 1, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_OUT, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lm, 1, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_TWICE:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_LOOPS_TWICE:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Graph with 2 edges from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_s1, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Graph with 1 edge from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_s2, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Trying IGRAPH_LOOPS_TWICE with IGRAPH_OUT:\n");
    IGRAPH_ASSERT(igraph_i_incident(&g_lm, &eids, 0, IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE) == IGRAPH_EINVAL);

    printf("Vertex not in graph:\n");
    IGRAPH_ASSERT(igraph_i_neighbors(&g_lm, &eids, 100, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE) == IGRAPH_EINVVID);

    printf("Non-existent mode:\n");
    IGRAPH_ASSERT(igraph_i_neighbors(&g_lm, &eids, 0, 100, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE) == IGRAPH_EINVMODE);

    igraph_destroy(&g_1);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lmu);
    igraph_destroy(&g_s1);
    igraph_destroy(&g_s2);
    igraph_vector_destroy(&eids);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_i_incident.out0000644000175100001710000000241600000000000026166 0ustar00runnerdocker00000000000000One vertex:
( )
Vertex with multiple edges, IGRAPH_IN, IGRAPH_MULTIPLE:
( 5 4 )
Vertex with multiple edges, IGRAPH_OUT, IGRAPH_MULTIPLE:
( 0 1 )
Vertex with multiple edges, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 0 1 5 4 )
Vertex with multiple edges, undirected, IGRAPH_MULTIPLE:
( 0 5 4 1 )
Vertex with multiple edges, IGRAPH_IN, IGRAPH_NO_MULTIPLE:
( 5 )
Vertex with multiple edges, IGRAPH_OUT, IGRAPH_NO_MULTIPLE:
( 0 1 )
Vertex with multiple edges, IGRAPH_ALL, IGRAPH_NO_MULTIPLE:
( 0 1 )
Vertex with multiple edges, undirected, IGRAPH_NO_MULTIPLE:
( 0 5 )
Vertex 1 with loop, IGRAPH_OUT, IGRAPH_NO_LOOPS:
( 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_NO_LOOPS:
( 0 3 )
Vertex 1 with loop, undirected, IGRAPH_NO_LOOPS:
( 0 3 )
Vertex 1 with loop, IGRAPH_OUT, IGRAPH_LOOPS_ONCE:
( 2 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_ONCE:
( 0 2 3 )
Vertex 1 with loop, undirected, IGRAPH_LOOPS_ONCE:
( 0 2 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_TWICE:
( 0 2 2 3 )
Vertex 1 with loop, undirected, IGRAPH_LOOPS_TWICE:
( 0 2 2 3 )
Graph with 2 edges from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 1 3 0 2 )
Graph with 1 edge from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 0 2 1 )
Trying IGRAPH_LOOPS_TWICE with IGRAPH_OUT:
Vertex not in graph:
Non-existent mode:
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_i_layout_sphere.c0000644000175100001710000000540600000000000026671 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "layout/layout_internal.h"

#include "test_utilities.inc"

int main () {
    long int i;
    igraph_matrix_t m;
    igraph_real_t x, y, z, r;

    srand(42); /* make tests deterministic */

    /* 2D */
    igraph_matrix_init(&m, 1000, 2);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        MATRIX(m, i, 0) = rand() / (double)RAND_MAX;
        MATRIX(m, i, 1) = rand() / (double)RAND_MAX;
    }
    igraph_i_layout_sphere_2d(&m, &x, &y, &r);

    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        igraph_real_t dist = sqrt((MATRIX(m, i, 0) - x) * (MATRIX(m, i, 0) - x) +
                                  (MATRIX(m, i, 1) - y) * (MATRIX(m, i, 1) - y));
        if (dist > r) {
            printf("x: %f y: %f r: %f\n", x, y, r);
            printf("x: %f y: %f dist: %f (%li)\n",
                   MATRIX(m, i, 0), MATRIX(m, i, 1), dist, i);
            return 1;
        }
    }
    igraph_matrix_destroy(&m);

    /* 3D */
    igraph_matrix_init(&m, 1000, 3);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        MATRIX(m, i, 0) = rand() / (double)RAND_MAX;
        MATRIX(m, i, 1) = rand() / (double)RAND_MAX;
        MATRIX(m, i, 2) = rand() / (double)RAND_MAX;
    }
    igraph_i_layout_sphere_3d(&m, &x, &y, &z, &r);

    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        igraph_real_t dist = sqrt((MATRIX(m, i, 0) - x) * (MATRIX(m, i, 0) - x) +
                                  (MATRIX(m, i, 1) - y) * (MATRIX(m, i, 1) - y) +
                                  (MATRIX(m, i, 2) - z) * (MATRIX(m, i, 2) - z));
        if (dist > r) {
            printf("x: %f y: %f z: %f r: %f\n", x, y, z, r);
            printf("x: %f y: %f z: %f dist: %f (%li)\n",
                   MATRIX(m, i, 0), MATRIX(m, i, 1), MATRIX(m, i, 2), dist, i);
            return 1;
        }
    }
    igraph_matrix_destroy(&m);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_i_neighbors.c0000644000175100001710000001227600000000000025771 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"
#include "../../src/graph/neighbors.h"

void call_and_print(igraph_t *graph, igraph_integer_t pnode, igraph_neimode_t mode, igraph_loops_t loops, igraph_multiple_t multiple) {
    igraph_vector_t neis;
    igraph_vector_init(&neis, 0);
    IGRAPH_ASSERT(igraph_i_neighbors(graph, &neis, pnode, mode, loops, multiple) == IGRAPH_SUCCESS);
    print_vector(&neis);
    igraph_vector_destroy(&neis);
}


int main() {
    igraph_t g_1, g_lm, g_lmu, g_s1, g_s2;

    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_s1, 2, 1, 0,1, 0,1, 1,0, 1,0, -1);
    igraph_small(&g_s2, 2, 1, 0,1, 1,0, 1,0, -1);

    igraph_vector_t neis;
    igraph_vector_init(&neis, 0);

    printf("One vertex:\n");
    call_and_print(&g_1, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_IN, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_OUT, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, undirected, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_lmu, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_IN, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_OUT, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, IGRAPH_ALL, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lm, 0, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE);

    printf("Vertex with multiple edges, undirected, IGRAPH_NO_MULTIPLE:\n");
    call_and_print(&g_lmu, 0, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_OUT, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lm, 1, IGRAPH_OUT, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_NO_LOOPS:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_NO_LOOPS, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_OUT, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lm, 1, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_LOOPS_ONCE:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_TWICE:\n");
    call_and_print(&g_lm, 1, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Vertex 1 with loop, undirected, IGRAPH_LOOPS_TWICE:\n");
    call_and_print(&g_lmu, 1, IGRAPH_IN, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE);

    printf("Graph with 2 edges from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_s1, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    printf("Graph with 1 edge from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:\n");
    call_and_print(&g_s2, 0, IGRAPH_ALL, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Trying IGRAPH_LOOPS_TWICE with IGRAPH_OUT:\n");
    IGRAPH_ASSERT(igraph_i_neighbors(&g_lm, &neis, 0, IGRAPH_OUT, IGRAPH_LOOPS_TWICE, IGRAPH_NO_MULTIPLE) == IGRAPH_EINVAL);

    printf("Trying invalid vertex ID:\n");
    IGRAPH_ASSERT(igraph_i_neighbors(&g_lm, &neis, 42, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE) == IGRAPH_EINVVID);

    printf("Trying invalid mode:\n");
    IGRAPH_ASSERT(igraph_i_neighbors(&g_lm, &neis, 0, (igraph_neimode_t) 42, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE) == IGRAPH_EINVMODE);

    igraph_destroy(&g_1);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lmu);
    igraph_destroy(&g_s1);
    igraph_destroy(&g_s2);
    igraph_vector_destroy(&neis);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_i_neighbors.out0000644000175100001710000000242500000000000026351 0ustar00runnerdocker00000000000000One vertex:
( )
Vertex with multiple edges, IGRAPH_IN, IGRAPH_MULTIPLE:
( 2 2 )
Vertex with multiple edges, IGRAPH_OUT, IGRAPH_MULTIPLE:
( 1 2 )
Vertex with multiple edges, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 1 2 2 2 )
Vertex with multiple edges, undirected, IGRAPH_MULTIPLE:
( 1 2 2 2 )
Vertex with multiple edges, IGRAPH_IN, IGRAPH_NO_MULTIPLE:
( 2 )
Vertex with multiple edges, IGRAPH_OUT, IGRAPH_NO_MULTIPLE:
( 1 2 )
Vertex with multiple edges, IGRAPH_ALL, IGRAPH_NO_MULTIPLE:
( 1 2 )
Vertex with multiple edges, undirected, IGRAPH_NO_MULTIPLE:
( 1 2 )
Vertex 1 with loop, IGRAPH_OUT, IGRAPH_NO_LOOPS:
( 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_NO_LOOPS:
( 0 3 )
Vertex 1 with loop, undirected, IGRAPH_NO_LOOPS:
( 0 3 )
Vertex 1 with loop, IGRAPH_OUT, IGRAPH_LOOPS_ONCE:
( 1 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_ONCE:
( 0 1 3 )
Vertex 1 with loop, undirected, IGRAPH_LOOPS_ONCE:
( 0 1 3 )
Vertex 1 with loop, IGRAPH_ALL, IGRAPH_LOOPS_TWICE:
( 0 1 1 3 )
Vertex 1 with loop, undirected, IGRAPH_LOOPS_TWICE:
( 0 1 1 3 )
Graph with 2 edges from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 1 1 1 1 )
Graph with 1 edge from 0 to 1, and 2 from 1 to 0, IGRAPH_ALL, IGRAPH_MULTIPLE:
( 1 1 1 )
Trying IGRAPH_LOOPS_TWICE with IGRAPH_OUT:
Trying invalid vertex ID:
Trying invalid mode:
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_induced_subgraph.c0000644000175100001710000000632200000000000027002 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2020  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, sub;
    igraph_vector_t keep;

    /* test with a simple directed graph, copy-and-delete implementation */
    igraph_small(&g, 9, IGRAPH_DIRECTED, 0, 1, 0, 2, 1, 3, 2, 3,
                 1, 4, 4, 2, 1, 5, 5, 2, 1, 6, 6, 2, 1, 7, 7, 2, 1, 8, 8, 2,
                 -1);
    igraph_vector_init_int_end(&keep, -1, 0, 1, 2, 4, -1);
    igraph_induced_subgraph(&g, &sub,
                            igraph_vss_vector(&keep),
                            IGRAPH_SUBGRAPH_COPY_AND_DELETE);
    igraph_write_graph_edgelist(&sub, stdout);
    igraph_vector_destroy(&keep);
    igraph_destroy(&sub);
    igraph_destroy(&g);

    printf("==============\n");

    /* test with a simple directed graph, create-from-scratch implementation */
    igraph_small(&g, 9, IGRAPH_DIRECTED, 0, 1, 0, 2, 1, 3, 2, 3,
                 1, 4, 4, 2, 1, 5, 5, 2, 1, 6, 6, 2, 1, 7, 7, 2, 1, 8, 8, 2,
                 -1);
    igraph_vector_init_int_end(&keep, -1, 0, 1, 2, 4, -1);
    igraph_induced_subgraph(&g, &sub,
                            igraph_vss_vector(&keep),
                            IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);
    igraph_write_graph_edgelist(&sub, stdout);
    igraph_vector_destroy(&keep);
    igraph_destroy(&sub);
    igraph_destroy(&g);

    printf("==============\n");

    /* test with a graph that has loop edges, copy-and-delete implementation */
    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0, 1, 0, 2, 1, 1, -1);
    igraph_vector_init_int_end(&keep, -1, 0, 1, -1);
    igraph_induced_subgraph(&g, &sub,
                            igraph_vss_vector(&keep),
                            IGRAPH_SUBGRAPH_COPY_AND_DELETE);
    igraph_write_graph_edgelist(&sub, stdout);
    igraph_vector_destroy(&keep);
    igraph_destroy(&sub);
    igraph_destroy(&g);

    printf("==============\n");

    /* test with a graph that has loop edges, create-from-scratch implementation */
    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0, 1, 0, 2, 1, 1, -1);
    igraph_vector_init_int_end(&keep, -1, 0, 1, -1);
    igraph_induced_subgraph(&g, &sub,
                            igraph_vss_vector(&keep),
                            IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);
    igraph_write_graph_edgelist(&sub, stdout);
    igraph_vector_destroy(&keep);
    igraph_destroy(&sub);
    igraph_destroy(&g);

    printf("==============\n");

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_induced_subgraph.out0000644000175100001710000000015400000000000027364 0ustar00runnerdocker000000000000000 1
0 2
1 3
3 2
==============
0 1
0 2
1 3
3 2
==============
0 1
1 1
==============
0 1
1 1
==============
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_induced_subgraph_map.c0000644000175100001710000000373600000000000027645 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, sub;
    igraph_vector_t map, invmap;
    igraph_vector_t keep;
    long int i;

    igraph_small(&g, 9, IGRAPH_DIRECTED, 0, 1, 0, 2, 1, 3, 2, 3,
                 1, 4, 4, 2, 1, 5, 5, 2, 1, 6, 6, 2, 1, 7, 7, 2, 1, 8, 8, 2,
                 -1);
    igraph_vector_init(&map, 0);
    igraph_vector_init(&invmap, 0);
    igraph_vector_init(&keep, igraph_vcount(&g));
    for (i = 0; i < igraph_vector_size(&keep); i++) {
        VECTOR(keep)[i] = i;
    }

    igraph_induced_subgraph_map(&g, &sub,
                                igraph_vss_vector(&keep),
                                IGRAPH_SUBGRAPH_COPY_AND_DELETE,
                                &map, &invmap);

    printf("Map:         ");
    igraph_vector_print(&map);
    printf("Inverse map: ");
    igraph_vector_print(&invmap);
    igraph_write_graph_edgelist(&sub, stdout);

    igraph_vector_destroy(&keep);
    igraph_vector_destroy(&map);
    igraph_vector_destroy(&invmap);

    igraph_destroy(&sub);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_intersection2.c0000644000175100001710000000356000000000000026265 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_t star, ring, uni, result;
    igraph_vector_ptr_t glist;

    igraph_star(&star, 11, IGRAPH_STAR_UNDIRECTED, /*center=*/ 10);
    igraph_ring(&ring, 10, IGRAPH_UNDIRECTED, /*mutual=*/ 0, /*circular=*/ 1);

    igraph_union(&uni, &star, &ring, /*edge_map1=*/ 0, /*edge_map2=*/ 0);

    igraph_intersection(&result, &uni, &star, /*edge_map1*/ 0,
                        /*edge_map2=*/ 0);
    igraph_write_graph_edgelist(&result, stdout);

    igraph_destroy(&result);

    /* ---------------------------- */

    igraph_vector_ptr_init(&glist, 2);
    VECTOR(glist)[0] = &uni;
    VECTOR(glist)[1] = ☆

    igraph_intersection_many(&result, &glist, /*edgemaps=*/ 0);
    printf("--\n");
    igraph_write_graph_edgelist(&result, stdout);

    igraph_vector_ptr_destroy(&glist);
    igraph_destroy(&result);
    igraph_destroy(&uni);
    igraph_destroy(&ring);
    igraph_destroy(&star);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_intersection2.out0000644000175100001710000000014700000000000026650 0ustar00runnerdocker000000000000000 10
1 10
2 10
3 10
4 10
5 10
6 10
7 10
8 10
9 10
--
0 10
1 10
2 10
3 10
4 10
5 10
6 10
7 10
8 10
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_bigraphical.c0000644000175100001710000000274300000000000026437 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

#define BIGRAPHICAL_PRINT_DESTROY(deg1, deg2) \
    igraph_is_bigraphical(&(deg1), &(deg2), IGRAPH_SIMPLE_SW, &simple); \
    igraph_is_bigraphical(&(deg1), &(deg2), IGRAPH_MULTI_SW, &multi); \
    print_vector_round(&(deg1)); \
    print_vector_round(&(deg2)); \
    printf("simple: %s, multi: %s\n\n", simple ? "true" : "false", multi ? "true" : "false"); \
    igraph_vector_destroy(&(deg1)); \
    igraph_vector_destroy(&(deg2));

int main() {
    igraph_vector_t deg1, deg2;
    igraph_bool_t simple, multi;

    igraph_vector_init(°1, 0);
    igraph_vector_init(°2, 0);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    igraph_vector_init_int_end(°1, -1, 3, 3, -1);
    igraph_vector_init_int_end(°2, -1, 1, 2, 3, -1);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    igraph_vector_init_int_end(°1, -1, 3, 2, 1, -1);
    igraph_vector_init_int_end(°2, -1, 1, 2, 3, -1);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    igraph_vector_init_int_end(°1, -1, 1, 1, 1, 1, -1);
    igraph_vector_init_int_end(°2, -1, 2, 3, -1);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    igraph_vector_init_int_end(°1, -1, 1, 1, 1, 1, -1);
    igraph_vector_init_int_end(°2, -1, 2, 2, -1);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    igraph_vector_init_int_end(°1, -1, 1, 2, 0, 3, 0, -1);
    igraph_vector_init_int_end(°2, -1, 2, 3, 1, -1);
    BIGRAPHICAL_PRINT_DESTROY(deg1, deg2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_bigraphical.out0000644000175100001710000000042300000000000027015 0ustar00runnerdocker00000000000000( )
( )
simple: true, multi: true

( 3 3 )
( 1 2 3 )
simple: false, multi: true

( 3 2 1 )
( 1 2 3 )
simple: true, multi: true

( 1 1 1 1 )
( 2 3 )
simple: false, multi: false

( 1 1 1 1 )
( 2 2 )
simple: true, multi: true

( 1 2 0 3 0 )
( 2 3 1 )
simple: true, multi: true

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_bipartite.c0000644000175100001710000000246600000000000026157 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_bool_t bipartite;
    igraph_vector_bool_t types;

    igraph_vector_bool_init(&types, 5);

    /* Null graph */
    igraph_empty(&graph, 0, IGRAPH_UNDIRECTED);
    igraph_is_bipartite(&graph, &bipartite, &types);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_vector_bool_size(&types) == igraph_vcount(&graph));
    igraph_destroy(&graph);

    /* Singleton graph */
    igraph_empty(&graph, 1, IGRAPH_UNDIRECTED);
    igraph_is_bipartite(&graph, &bipartite, &types);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_vector_bool_size(&types) == igraph_vcount(&graph));
    igraph_destroy(&graph);

    /* Directed path */
    igraph_small(&graph, 0, IGRAPH_DIRECTED,
                 0,1, 1,2,
                 -1);

    igraph_is_bipartite(&graph, &bipartite, &types);
    IGRAPH_ASSERT(bipartite);
    IGRAPH_ASSERT(igraph_vector_bool_size(&types) == igraph_vcount(&graph));

    /* Odd directed cycle */
    igraph_add_edge(&graph, 2, 0);

    igraph_is_bipartite(&graph, &bipartite, &types);
    IGRAPH_ASSERT(! bipartite);
    IGRAPH_ASSERT(igraph_vector_bool_size(&types) == igraph_vcount(&graph));

    igraph_destroy(&graph);

    igraph_vector_bool_destroy(&types);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_chordal.c0000644000175100001710000000655200000000000025610 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, igraph_vector_t *alpha, igraph_vector_t *alpham1,
                    igraph_bool_t fill, igraph_bool_t ng) {
    igraph_bool_t chordal;
    igraph_vector_t fill_in;
    igraph_t newgraph;
    igraph_vector_init(&fill_in, 0);
    IGRAPH_ASSERT(igraph_is_chordal(graph, alpha, alpham1, &chordal,
                  fill ? &fill_in : NULL, ng? &newgraph : NULL) == IGRAPH_SUCCESS);
    printf("Is chordal: %d\nFill in:\n", chordal);
    print_vector(&fill_in);
    if (ng) {
        printf("New graph:\n");
        print_graph_canon(&newgraph);
        igraph_destroy(&newgraph);
    }
    printf("\n");
    igraph_vector_destroy(&fill_in);
}


int main() {
    igraph_t g_0, g_1, g_lmu;
    igraph_bool_t chordal;
    igraph_vector_t alpha, alpham1;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    call_and_print(&g_0, NULL, NULL, 1, 1);

    printf("One vertex:\n");
    call_and_print(&g_1, NULL, NULL, 1, 1);

    printf("One vertex, don't calculate anything.\n\n");
    IGRAPH_ASSERT(igraph_is_chordal(&g_1, NULL, NULL, NULL, NULL, NULL) == IGRAPH_SUCCESS);

    printf("Disconnected graph with loops and multiple edges:\n");
    call_and_print(&g_lmu, NULL, NULL, 1, 1);

    printf("Same graph, don't ask for fill_in vector:\n");
    call_and_print(&g_lmu, NULL, NULL, 0, 1);

    printf("Same graph, don't ask for fill_in vector or newgraph:\n");
    call_and_print(&g_lmu, NULL, NULL, 0, 0);

    printf("Same graph, own calculation of alpha and its inverse:\n");
    igraph_vector_init(&alpha, 0);
    igraph_vector_init(&alpham1, 0);
    igraph_maximum_cardinality_search(&g_lmu, &alpha, &alpham1);
    call_and_print(&g_lmu, &alpha, &alpham1, 1, 1);

    printf("Same graph, own calculation of alpha:\n");
    call_and_print(&g_lmu, &alpha, NULL, 1, 1);

    printf("Same graph, own calculation of inverse alpha:\n");
    call_and_print(&g_lmu, NULL, &alpham1, 1, 1);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Wrong size alpha.\n");
    igraph_vector_clear(&alpha);
    IGRAPH_ASSERT(igraph_is_chordal(&g_lmu, &alpha, NULL, &chordal, NULL, NULL) == IGRAPH_EINVAL);

    printf("Wrong size alpham1.\n");
    IGRAPH_ASSERT(igraph_is_chordal(&g_lmu, NULL, &alpha, &chordal, NULL, NULL) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_lmu);
    igraph_vector_destroy(&alpha);
    igraph_vector_destroy(&alpham1);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_chordal.out0000644000175100001710000000221200000000000026162 0ustar00runnerdocker00000000000000No vertices:
Is chordal: 1
Fill in:
( )
New graph:
directed: false
vcount: 0
edges: {
}

One vertex:
Is chordal: 1
Fill in:
( )
New graph:
directed: false
vcount: 1
edges: {
}

One vertex, don't calculate anything.

Disconnected graph with loops and multiple edges:
Is chordal: 0
Fill in:
( 3 0 )
New graph:
directed: false
vcount: 6
edges: {
0 1
0 2
0 2
0 2
0 3
1 1
1 3
2 3
3 4
3 4
}

Same graph, don't ask for fill_in vector:
Is chordal: 0
Fill in:
( )
New graph:
directed: false
vcount: 6
edges: {
0 1
0 2
0 2
0 2
0 3
1 1
1 3
2 3
3 4
3 4
}

Same graph, don't ask for fill_in vector or newgraph:
Is chordal: 0
Fill in:
( )

Same graph, own calculation of alpha and its inverse:
Is chordal: 0
Fill in:
( 3 0 )
New graph:
directed: false
vcount: 6
edges: {
0 1
0 2
0 2
0 2
0 3
1 1
1 3
2 3
3 4
3 4
}

Same graph, own calculation of alpha:
Is chordal: 0
Fill in:
( 3 0 )
New graph:
directed: false
vcount: 6
edges: {
0 1
0 2
0 2
0 2
0 3
1 1
1 3
2 3
3 4
3 4
}

Same graph, own calculation of inverse alpha:
Is chordal: 0
Fill in:
( 3 0 )
New graph:
directed: false
vcount: 6
edges: {
0 1
0 2
0 2
0 2
0 3
1 1
1 3
2 3
3 4
3 4
}

Wrong size alpha.
Wrong size alpham1.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_connected.c0000644000175100001710000000367000000000000026134 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_bool_t conn;

    /* Null graph */
    igraph_empty(&graph, 0, IGRAPH_DIRECTED);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(! conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(! conn);

    igraph_destroy(&graph);

    /* Singleton graph */
    igraph_empty(&graph, 1, IGRAPH_DIRECTED);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(conn);

    igraph_destroy(&graph);

    /* Two isolated vertices, one with a self-loop */
    igraph_small(&graph, 2, IGRAPH_DIRECTED,
                 0,0, -1);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(! conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(! conn);

    igraph_destroy(&graph);

    /* Two isolated vertices, three self-loops */
    igraph_small(&graph, 2, IGRAPH_DIRECTED,
                 0,0, 0,0, 1,1, -1);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(! conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(! conn);

    igraph_destroy(&graph);

    /* Weakly connected directed */
    igraph_small(&graph, 4, IGRAPH_DIRECTED,
                 0,1, 2,0, 1,2, 3,2,
                 -1);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(! conn);

    igraph_destroy(&graph);

    /* Directed cycle */
    igraph_small(&graph, 4, IGRAPH_DIRECTED,
                 0,1, 2,0, 1,3, 3,2,
                 -1);

    igraph_is_connected(&graph, &conn, IGRAPH_WEAK);
    IGRAPH_ASSERT(conn);

    igraph_is_connected(&graph, &conn, IGRAPH_STRONG);
    IGRAPH_ASSERT(conn);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_eulerian.c0000644000175100001710000001760300000000000025777 0ustar00runnerdocker00000000000000
#include 
#include 
#include "test_utilities.inc"

int main() {

    igraph_t graph;
    igraph_bool_t has_path, has_cycle;

    /* undirected cases */
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 1,2 , 2,3, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 1,2 , 2,3, 3,1, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 0,1,0,1,-1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,0, 0,0,0,0,-1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,3, 3,4, 4,5, 5,2,
                2,6, 6,4, 4,8, 2,8, 2,7, 0,7, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, 2,3, 2,4 , 3,5 , 4,5,
                4,6, 0,6, 6,7, 1,7, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1 , 1,2, 2,3, 3,4 , 2,4 , 1,5,
                0,5 , -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 0,1, 1,2, 2,4, 3,4, 1,3, 2,5, 4,5, 2,6, 1,6, 0,4, 6,5, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, 1,3 , 3,5 , 5,6 , 6,3 , 3,1 , 1,2 ,
                                        2,2 , 2,4 , 2,4 , 4,3 , 3,2 , 4,6 , -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  7,8, 8,9, 9,7, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  0,1, 2,3, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  0,1, 2,3, 3,1, 4,5, 5,6, 6,4, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* two disconnected self loops */
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  1,1, 2,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* one self loop and one disconnected multiedge selfloop */
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  1,1, 1,1, 2,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* multiple self-loop singletons */
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED,  0,0 , 1,1 , 1,1 , -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* no edges, multiple vertices */
    igraph_small(&graph, 4, IGRAPH_UNDIRECTED, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* no edges except one self loop, multiple vertices */
    igraph_small(&graph, 4, IGRAPH_UNDIRECTED, 0,0, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* directed cases*/
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1 , 1,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1 , 1,2, 1,3, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1 , 1,3, 3,2, 2,0 , 2,1, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,3, 3,4, 4,0, 0,2, 2,1, 1,0, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,6, 6,4, 4,5, 5,0, 0,1, 1,2,
                2,3, 3,4, 4,2, 2,0, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* multiedges */
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 0,1, 1,2, 2,1, 1,3, 3,4, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* one self loop */
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 0,0, 1,2, 2,1, 1,3, 3,4, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* multiedges and one self loop */
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,2 , 2,4 , 4,5 , 5,2 , 2,0 , 0,1 ,
                                        1,1 , 1,3 , 1,3 , 3,2 , 2,1 , 3,5 , -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 1,3 , 3,5 , 5,6 , 6,3 , 3,1 , 1,2 ,
                                        2,2 , 2,4 , 2,4 , 4,3 , 3,2 , 4,6 , -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    igraph_small(&graph, 0, IGRAPH_DIRECTED, 0,1, 0,1 , 0,1, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* disconnected graphs and self loops, both undirected and directed */
    /* disconnected with singleton vertices */
    igraph_small(&graph, 0, IGRAPH_DIRECTED, 8,9, 9,10, 10,8, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* two disconnected self loops, directed */
    igraph_small(&graph, 0, IGRAPH_DIRECTED,  1,1, 2,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* one self loop and one disconnected multiedge selfloop, directed */
    igraph_small(&graph, 0, IGRAPH_DIRECTED,  1,1, 1,1, 2,2, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* no edges, multiple vertices, directed */
    igraph_small(&graph, 4, IGRAPH_DIRECTED, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    /* no edges except one self loop, multiple vertices, directed */
    igraph_small(&graph, 4, IGRAPH_DIRECTED, 0,0, -1);
    igraph_is_eulerian(&graph, &has_path, &has_cycle);
    printf("%d %d\n", has_path, has_cycle);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_eulerian.out0000644000175100001710000000021000000000000026346 0ustar00runnerdocker000000000000001 0
1 0
1 1
1 0
1 1
1 1
0 0
1 0
1 0
1 0
1 1
0 0
0 0
0 0
0 0
0 0
1 1
1 1
1 0
1 1
0 0
1 0
1 1
1 1
0 0
1 0
1 0
1 0
0 0
1 1
0 0
0 0
1 1
1 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_graphical.c0000644000175100001710000001726300000000000026127 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

/* Undirected case */
void graphical_print_destroy(igraph_vector_t *ds) {
    int err;
    igraph_bool_t simple, loops, multi, multiloops;

    print_vector_round(ds);

    err = igraph_is_graphical(ds, NULL, IGRAPH_SIMPLE_SW, &simple);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ds, NULL, IGRAPH_LOOPS_SW, &loops);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ds, NULL, IGRAPH_MULTI_SW, &multi);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ds, NULL, IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW, &multiloops);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }

    printf("simple: %s, loops: %s, multi: %s, multiloops: %s\n\n",
           simple     ? " true" : "false",
           loops      ? " true" : "false",
           multi      ? " true" : "false",
           multiloops ? " true" : "false");

cleanup:
    igraph_vector_destroy(ds);
}


/* Directed case */
void digraphical_print_destroy(igraph_vector_t *ods, igraph_vector_t *ids) {
    int err;
    igraph_bool_t simple, loops, multi, multiloops;

    print_vector_round(ods);
    print_vector_round(ids);

    err = igraph_is_graphical(ods, ids, IGRAPH_SIMPLE_SW, &simple);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ods, ids, IGRAPH_LOOPS_SW, &loops);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ods, ids, IGRAPH_MULTI_SW, &multi);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }
    err = igraph_is_graphical(ods, ids, IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW, &multiloops);
    if (err != IGRAPH_SUCCESS) {
        printf("error!\n\n"); goto cleanup;
    }

    printf("simple: %s, loops: %s, multi: %s, multiloops: %s\n\n",
           simple     ? " true" : "false",
           loops      ? " true" : "false",
           multi      ? " true" : "false",
           multiloops ? " true" : "false");

cleanup:
    igraph_vector_destroy(ods);
    igraph_vector_destroy(ids);
}


int main() {
    igraph_vector_t ds, ods, ids;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    /* Undirected case: */

    /* Empty */
    igraph_vector_init(&ds, 0);
    graphical_print_destroy(&ds);

    /* All zeros */
    igraph_vector_init_int_end(&ds, -1, 0, 0, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 3, 3, 3, 3, 3, 3, 3, 3, -1);
    graphical_print_destroy(&ds);

    /* Undirected degree sequence with negative degree */
    igraph_vector_init_int_end(&ds, -1, 3, -2, 3, 3, 3, 3, 3, 3, -1);
    graphical_print_destroy(&ds);

    /* Undirected degree sequence with uneven sum */
    igraph_vector_init_int_end(&ds, -1, 3, 3, 3, 3, 3, 3, 3, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 5, 3, 6, 2, 2, 8, 1, 1, 10, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 3, 3, 2, 4, 1, 5, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 7, 4, 7, 7, 8, 9, 9, 4, 6, 5, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 4, 4, 4, 1, 1, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 4, 4, 4, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 4, 4, 4, 4, 1, 1, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 3, 3, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 4, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 2, 2, 3, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 2, 3, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 2, 5, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 1, 4, -1);
    graphical_print_destroy(&ds);

    /* The following two sequences are realizable as simple graphs.
     * The algorithm that checks this exits the last loop with these
     * two sequences. An earlier buggy version of the function failed
     * to set the result in this case. */
    igraph_vector_init_int_end(&ds, -1, 2, 2, 2, 2, 4, -1);
    graphical_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 3, 0, 5, 3, 5, 3, 3, -1);
    graphical_print_destroy(&ds);


    /* Directed case: */

    /* Empty */
    igraph_vector_init(&ods, 0);
    igraph_vector_init(&ids, 0);
    digraphical_print_destroy(&ods, &ids);

    /* All zeros */
    igraph_vector_init_int_end(&ods, -1, 0, -1);
    igraph_vector_init_int_end(&ids, -1, 0, -1);
    digraphical_print_destroy(&ods, &ids);

    /* Different length, must throw an error */
    igraph_vector_init_int_end(&ods, -1, 1, 1, -1);
    igraph_vector_init_int_end(&ids, -1, 2, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ods, -1, 0, 2, 3, 0, 4, 3, 1, 3, 4, 2, -1);
    igraph_vector_init_int_end(&ids, -1, 0, 3, 1, 3, 2, 4, 4, 1, 3, 1, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ods, -1, 0, 2, 3, 0, 4, 3, 1, 3, 4, 2, -1);
    igraph_vector_init_int_end(&ids, -1, 0, 3, 1, -7, 2, 4, 4, 1, 3, 1, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ods, -1, 0, 2, 3, 0, 4, 3, 1, 3, 4, 2, -1);
    igraph_vector_init_int_end(&ids, -1, 0, 3, 1, 2, 2, 4, 4, 1, 3, 1, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1);
    igraph_vector_init_int_end(&ods, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 1, 3, 2, 1, 3, 4, 3, 3, 1, 3, -1);
    igraph_vector_init_int_end(&ods, -1, 4, 1, 2, 3, 2, 3, 2, 3, 2, 2, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 7, 4, 6, 4, 7, 8, 8, 8, 7, 4, -1);
    igraph_vector_init_int_end(&ods, -1, 8, 5, 6, 8, 6, 6, 5, 7, 5, 7, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 3, 3, 1, 0, 2, 3, 0, 7, -1);
    igraph_vector_init_int_end(&ods, -1, 2, 2, 4, 3, 4, 3, 1, 0, -1);
    digraphical_print_destroy(&ods, &ids);

    /* Only one vertex with a non-zero out-degree. Regression test for bug #851 */
    igraph_vector_init_int_end(&ids, -1, 1, -1);
    igraph_vector_init_int_end(&ods, -1, 1, -1);
    digraphical_print_destroy(&ods, &ids);

    /* Another degree sequence when there is only
     * one vertex with a non-zero out-degree. Regression test for bug #851 */
    igraph_vector_init_int_end(&ids, -1, 2, 0, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 2, -1);
    digraphical_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 2, 2, -1);
    igraph_vector_init_int_end(&ods, -1, 2, 2, -1);
    digraphical_print_destroy(&ods, &ids);

    /* Valid directed graphical degree sequence. Regression test for bug #1092 */
    igraph_vector_init_int_end(&ids, -1, 1, 0, 1, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 2, 0, -1);
    digraphical_print_destroy(&ods, &ids);

    /* Same as above, ids & ods exchanged. */
    igraph_vector_init_int_end(&ids, -1, 1, 0, 1, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 2, 0, -1);
    digraphical_print_destroy(&ids, &ods);

    /* single loops: graphical, but multi-eges only: non-graphical */
    igraph_vector_init_int_end(&ids, -1, 1, 0, 2, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 1, 2, -1);
    digraphical_print_destroy(&ids, &ods);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_graphical.out0000644000175100001710000000545700000000000026516 0ustar00runnerdocker00000000000000( )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 0 0 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 3 3 3 3 3 3 3 3 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 3 -2 3 3 3 3 3 3 )
simple: false, loops: false, multi: false, multiloops: false

( 3 3 3 3 3 3 3 )
simple: false, loops: false, multi: false, multiloops: false

( 4 4 5 3 6 2 2 8 1 1 10 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 3 3 2 4 1 5 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 4 7 4 7 7 8 9 9 4 6 5 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 4 4 4 4 4 1 1 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 4 4 4 4 4 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 4 4 4 4 4 4 1 1 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 3 3 )
simple: false, loops:  true, multi:  true, multiloops:  true

( 4 4 4 )
simple: false, loops:  true, multi:  true, multiloops:  true

( 1 2 2 3 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 1 2 3 )
simple: false, loops:  true, multi:  true, multiloops:  true

( 1 2 5 )
simple: false, loops: false, multi: false, multiloops:  true

( 1 1 4 )
simple: false, loops:  true, multi: false, multiloops:  true

( 2 2 2 2 4 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 3 0 5 3 5 3 3 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( )
( )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 0 )
( 0 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 1 1 )
( 2 )
error!

( 0 2 3 0 4 3 1 3 4 2 )
( 0 3 1 3 2 4 4 1 3 1 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 0 2 3 0 4 3 1 3 4 2 )
( 0 3 1 -7 2 4 4 1 3 1 )
simple: false, loops: false, multi: false, multiloops: false

( 0 2 3 0 4 3 1 3 4 2 )
( 0 3 1 2 2 4 4 1 3 1 )
simple: false, loops: false, multi: false, multiloops: false

( 3 3 3 3 3 3 3 3 3 )
( 3 3 3 3 3 3 3 3 3 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 4 1 2 3 2 3 2 3 2 2 )
( 1 3 2 1 3 4 3 3 1 3 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 8 5 6 8 6 6 5 7 5 7 )
( 7 4 6 4 7 8 8 8 7 4 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 2 2 4 3 4 3 1 0 )
( 3 3 1 0 2 3 0 7 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 1 )
( 1 )
simple: false, loops:  true, multi: false, multiloops:  true

( 0 2 )
( 2 0 )
simple: false, loops: false, multi:  true, multiloops:  true

( 2 2 )
( 2 2 )
simple: false, loops:  true, multi:  true, multiloops:  true

( 0 2 0 )
( 1 0 1 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 1 0 1 )
( 0 2 0 )
simple:  true, loops:  true, multi:  true, multiloops:  true

( 1 0 2 )
( 0 1 2 )
simple: false, loops:  true, multi: false, multiloops:  true

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_mutual.c0000644000175100001710000000424300000000000025476 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, igraph_es_t es) {
    igraph_vector_bool_t result;
    igraph_vector_bool_init(&result, 0);
    IGRAPH_ASSERT(igraph_is_mutual(graph, &result, es) == IGRAPH_SUCCESS);
    igraph_vector_bool_print(&result);
    printf("\n");
    igraph_vector_bool_destroy(&result);
}


int main() {
    igraph_t g_0, g_lm, g_lmu;
    igraph_vector_bool_t result;

    igraph_vector_bool_init(&result, 0);

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    call_and_print(&g_0, igraph_ess_all(IGRAPH_EDGEORDER_ID));

    printf("Graph with loops and multiple edges:\n");
    call_and_print(&g_lm, igraph_ess_all(IGRAPH_EDGEORDER_ID));

    printf("Same graph, selecting edge 4:\n");
    call_and_print(&g_lm, igraph_ess_1(4));

    printf("Same graph, but undirected:\n");
    call_and_print(&g_lmu, igraph_ess_all(IGRAPH_EDGEORDER_ID));

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Edge out of range.\n");
    IGRAPH_ASSERT(igraph_is_mutual(&g_lm, &result, igraph_ess_1(100)) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lmu);
    igraph_vector_bool_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_mutual.out0000644000175100001710000000025200000000000026057 0ustar00runnerdocker00000000000000No vertices:


Graph with loops and multiple edges:
0 1 1 0 1 1 0 0 0

Same graph, selecting edge 4:
1

Same graph, but undirected:
1 1 1 1 1 1 1 1 1

Edge out of range.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_same_graph.c0000644000175100001710000000505200000000000026274 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g1, g2;
    igraph_bool_t res;
    int err;

    /* undirected graphs */
    igraph_small(&g1, 4, 0,
                 0, 1, 1, 2, 2, 3, 3, 0, -1);
    igraph_small(&g2, 4, 0,
                 1, 0, 1, 2, 2, 3, 3, 0, -1);

    /* a graph is always same as itself */
    err = igraph_is_same_graph(&g1, &g1, &res);
    IGRAPH_ASSERT(!err);
    IGRAPH_ASSERT(res);

    /* undirected graphs should be the same no matter
     * the direction of the edges (one is swapped in g2 */
    err = igraph_is_same_graph(&g1, &g2, &res);
    IGRAPH_ASSERT(!err);
    IGRAPH_ASSERT(res);

    /* end of undirected */
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    /* directed graphs */
    igraph_small(&g1, 4, 1,
                 0, 1, 1, 2, 2, 3, 3, 0, -1);
    igraph_small(&g2, 4, 1,
                 1, 0, 1, 2, 2, 3, 3, 0, -1);

    /* directed graphs should not be the same if an
     * edge has the opposite direction */
    err = igraph_is_same_graph(&g1, &g2, &res);
    IGRAPH_ASSERT(!err);
    IGRAPH_ASSERT(!res);

    igraph_destroy(&g2);

    /* change order of edges, they should be reordered by graph->ii */
    igraph_small(&g2, 4, 1,
                 1, 2, 0, 1, 2, 3, 3, 0, -1);
    err = igraph_is_same_graph(&g1, &g2, &res);
    IGRAPH_ASSERT(!err);
    IGRAPH_ASSERT(res);

    /* end of directed */
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    /* undirected vs directed */
    igraph_small(&g1, 4, 0,
                 0, 1, 1, 2, 2, 3, 3, 0, -1);
    igraph_small(&g2, 4, 1,
                 0, 1, 1, 2, 2, 3, 3, 0, -1);
    err = igraph_is_same_graph(&g1, &g2, &res);
    IGRAPH_ASSERT(!err);
    IGRAPH_ASSERT(!res);

    /* end of undirected vs directed */
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_is_tree.c0000644000175100001710000000636300000000000025133 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_bool_t res;
    igraph_integer_t root;

    /* the null graph is not a tree */
    igraph_empty(&g, 0, 0);

    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    /* the single-vertex graph is a tree */
    igraph_empty(&g, 1, 0);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_destroy(&g);

    /* undirected 4-cycle, not a tree */
    igraph_small(&g, 4, 0,
                 0, 1, 1, 2, 2, 3, 3, 0, -1);

    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    /* disconnected graph with the same number of edges a tree would have */
    igraph_small(&g, 4, 0,
                 0, 1, 1, 2, 0, 2, 3, 4, -1);

    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    /* disjoint union of an out-tree and two cycles, with the same number
     * of edges as a tree would have, and the same in-degrees as an out-tree
     * would have */
    igraph_small(&g, 11, IGRAPH_DIRECTED,
                 10, 0, 0, 2, 0, 6, 9, 1, 1, 8, 8, 4, 4, 9, 3, 7, 7, 5, 5, 3,
                 -1);

    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    /* 3-star, tree */
    igraph_small(&g, 4, 0,
                 0, 1, 0, 2, 0, 3, -1);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_destroy(&g);

    /* out-tree */
    igraph_small(&g, 4, 1,
                 0, 1, 1, 2, 1, 3, -1);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_OUT);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_is_tree(&g, &res, &root, IGRAPH_IN);
    IGRAPH_ASSERT(! res);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_destroy(&g);

    /* in-tree */
    igraph_small(&g, 4, 1,
                 0, 1, 2, 1, 1, 3, -1);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_IN);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 3);

    igraph_is_tree(&g, &res, &root, IGRAPH_OUT);
    IGRAPH_ASSERT(! res);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_destroy(&g);

    /* neither an in-tree, nor an out-ree, but still a tree when ignoring edge-directions */
    igraph_small(&g, 6, 1,
                 0, 1, 1, 2, 2, 3, 4, 1, 2, 5, -1);

    root = -1;
    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(res);
    IGRAPH_ASSERT(root == 0);

    igraph_is_tree(&g, &res, &root, IGRAPH_IN);
    IGRAPH_ASSERT(! res);

    igraph_is_tree(&g, &res, &root, IGRAPH_OUT);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    /* Regression test, see:
     * https://github.com/szhorvat/IGraphM/issues/90
     * https://github.com/igraph/igraph/pull/1160
     */
    igraph_small(&g, 5, 0,
                 0, 3, 0, 4, 1, 3, 1, 4, -1);

    igraph_is_tree(&g, &res, &root, IGRAPH_ALL);
    IGRAPH_ASSERT(! res);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_isomorphic_bliss.c0000644000175100001710000001123400000000000027042 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_t g1, g2;
    igraph_t ring1, ring2;
    igraph_vector_int_t color1, color2;
    igraph_vector_t perm;
    igraph_bool_t iso;

    igraph_bliss_sh_t sh_values[] = {
        IGRAPH_BLISS_F, IGRAPH_BLISS_FL,
        IGRAPH_BLISS_FS, IGRAPH_BLISS_FM,
        IGRAPH_BLISS_FLM, IGRAPH_BLISS_FSM
    };

    const char *sh_names[] = {
        "F", "FL", "FS", "FM", "FLM", "FSM"
    };

    size_t i;

    /* necessary because of igraph_vector_shuffle() below */
    igraph_rng_seed(igraph_rng_default(), 137);

    for (i=0; i < sizeof(sh_values) / sizeof(igraph_bliss_sh_t); ++i) {

        igraph_bliss_sh_t sh = sh_values[i];
        printf("Splitting heuristic: %s\n", sh_names[i]);

        igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/1);
        igraph_vector_init_seq(&perm, 0, igraph_vcount(&ring1) - 1);
        igraph_vector_shuffle(&perm);
        igraph_permute_vertices(&ring1, &ring2, &perm);

        /* Without colors */
        printf("Without vertex colors: ");
        iso = 0;
        igraph_isomorphic_bliss(&ring1, &ring2, 0, 0, &iso, 0, 0, sh, 0, 0);
        printf("%s\n", iso ? "YES" : "NO");

        /* Everything has the same colors */
        printf("All vertices having the same color: ");
        igraph_vector_int_init(&color1, igraph_vcount(&ring1));
        igraph_vector_int_init(&color2, igraph_vcount(&ring2));
        igraph_vector_int_fill(&color1, 1);
        igraph_vector_int_fill(&color2, 1);

        iso = 0;
        igraph_isomorphic_bliss(&ring1, &ring2, &color1, &color2, &iso, 0, 0, sh, 0, 0);
        printf("%s\n", iso ? "YES" : "NO");

        /* Try a negative result */
        printf("Non-matching colors 1: ");
        igraph_vector_int_fill(&color1, 0);
        igraph_vector_int_fill(&color2, 0);
        VECTOR(color1)[0] = 1;

        iso = 1;
        igraph_isomorphic_bliss(&ring1, &ring2, &color1, &color2, &iso, 0, 0, sh, 0, 0);
        printf("%s\n", iso ? "YES" : "NO");

        /* Another negative, same color distribution, different topology */
        printf("Non-matching colors 2: ");
        igraph_vector_int_fill(&color1, 0);
        igraph_vector_int_fill(&color2, 0);
        VECTOR(color1)[0] = 1;
        VECTOR(color1)[1] = 1;
        VECTOR(color2)[0] = 1;
        VECTOR(color2)[2] = 1;

        iso = 1;
        igraph_isomorphic_bliss(&ring1, &ring2, &color1, &color2, &iso, 0, 0, sh, 0, 0);
        printf("%s\n", iso ? "YES" : "NO");

        igraph_vector_int_destroy(&color1);
        igraph_vector_int_destroy(&color2);

        igraph_vector_destroy(&perm);
        igraph_destroy(&ring2);
        igraph_destroy(&ring1);

        /* More complicated test with colors */
        printf("Isomorphic colored graphs: ");

        igraph_small(&g1, 8, IGRAPH_DIRECTED,
                     0, 4, 0, 5, 0, 6, 1, 4, 1, 5, 1, 7, 2, 4, 2, 6, 2, 7, 3, 5, 3, 6, 3, 7, -1
                    );
        igraph_small(&g2, 8, IGRAPH_DIRECTED,
                     0, 1, 0, 3, 0, 4, 2, 3, 2, 1, 2, 6, 5, 1, 5, 4, 5, 6, 7, 3, 7, 6, 7, 4, -1
                    );

        igraph_vector_int_init(&color1, 8);
        igraph_vector_int_init(&color2, 8);

        VECTOR(color1)[1] = 1;
        VECTOR(color1)[3] = 1;
        VECTOR(color1)[5] = 1;
        VECTOR(color1)[7] = 1;

        VECTOR(color2)[2] = 1;
        VECTOR(color2)[3] = 1;
        VECTOR(color2)[6] = 1;
        VECTOR(color2)[7] = 1;

        iso = 0;
        igraph_isomorphic_bliss(&g1, &g2, &color1, &color2, &iso, 0, 0, sh, 0, 0);
        printf("%s\n", iso ? "YES" : "NO");

        igraph_vector_int_destroy(&color1);
        igraph_vector_int_destroy(&color2);

        igraph_destroy(&g2);
        igraph_destroy(&g1);

        printf("\n");

        VERIFY_FINALLY_STACK();

    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_isomorphic_bliss.out0000644000175100001710000000203300000000000027424 0ustar00runnerdocker00000000000000Splitting heuristic: F
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

Splitting heuristic: FL
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

Splitting heuristic: FS
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

Splitting heuristic: FM
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

Splitting heuristic: FLM
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

Splitting heuristic: FSM
Without vertex colors: YES
All vertices having the same color: YES
Non-matching colors 1: NO
Non-matching colors 2: NO
Isomorphic colored graphs: YES

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_k_regular_game.c0000644000175100001710000001416500000000000026444 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t deg;
    igraph_bool_t is_simple;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    igraph_vector_init(°, 0);

    /* k-regular undirected graph, even degrees, no multiple edges */
    igraph_k_regular_game(&g, 10, 4, 0, 0);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1);
    igraph_vector_print(°);
    igraph_is_simple(&g, &is_simple);
    if (!is_simple) {
        return 1;
    }
    if (igraph_is_directed(&g)) {
        return 1;
    }
    igraph_destroy(&g);

    /* k-regular undirected graph, odd degrees, even number of vertices, no multiple edges */
    igraph_k_regular_game(&g, 10, 3, 0, 0);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1);
    igraph_vector_print(°);
    igraph_is_simple(&g, &is_simple);
    if (!is_simple) {
        return 2;
    }
    if (igraph_is_directed(&g)) {
        return 2;
    }
    igraph_destroy(&g);

    /* k-regular undirected graph, odd degrees, odd number of vertices, no multiple edges */
    if (!igraph_k_regular_game(&g, 9, 3, 0, 0)) {
        return 3;
    }

    /* k-regular undirected graph, even degrees, multiple edges */
    igraph_k_regular_game(&g, 10, 4, 0, 1);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1);
    igraph_vector_print(°);
    if (igraph_is_directed(&g)) {
        return 14;
    }
    igraph_destroy(&g);

    /* k-regular undirected graph, odd degrees, even number of vertices, multiple edges */
    igraph_k_regular_game(&g, 10, 3, 0, 1);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1);
    igraph_vector_print(°);
    if (igraph_is_directed(&g)) {
        return 15;
    }
    igraph_destroy(&g);

    /* k-regular undirected graph, odd degrees, odd number of vertices, multiple edges */
    if (!igraph_k_regular_game(&g, 9, 3, 0, 1)) {
        return 4;
    }

    /* k-regular directed graph, even degrees, no multiple edges */
    igraph_k_regular_game(&g, 10, 4, 1, 0);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    igraph_is_simple(&g, &is_simple);
    if (!is_simple) {
        return 5;
    }
    if (!igraph_is_directed(&g)) {
        return 5;
    }
    igraph_destroy(&g);

    /* k-regular directed graph, odd degrees, even number of vertices, no multiple edges */
    igraph_k_regular_game(&g, 10, 3, 1, 0);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    igraph_is_simple(&g, &is_simple);
    if (!is_simple) {
        return 6;
    }
    if (!igraph_is_directed(&g)) {
        return 6;
    }
    igraph_destroy(&g);

    /* k-regular directed graph, odd degrees, odd number of vertices, no multiple edges */
    igraph_k_regular_game(&g, 9, 3, 1, 0);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    igraph_is_simple(&g, &is_simple);
    if (!is_simple) {
        return 7;
    }
    if (!igraph_is_directed(&g)) {
        return 7;
    }
    igraph_destroy(&g);

    /* k-regular directed graph, even degrees, multiple edges */
    igraph_k_regular_game(&g, 10, 4, 1, 1);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    if (!igraph_is_directed(&g)) {
        return 16;
    }
    igraph_destroy(&g);

    /* k-regular directed graph, odd degrees, even number of vertices, multiple edges */
    igraph_k_regular_game(&g, 10, 3, 1, 1);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    if (!igraph_is_directed(&g)) {
        return 17;
    }
    igraph_destroy(&g);

    /* k-regular directed graph, odd degrees, odd number of vertices, multiple edges */
    igraph_k_regular_game(&g, 9, 3, 1, 1);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_vector_print(°);
    igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1);
    igraph_vector_print(°);
    if (!igraph_is_directed(&g)) {
        return 18;
    }
    igraph_destroy(&g);

    /* k-regular undirected graph, too large degree, no multiple edges */
    if (!igraph_k_regular_game(&g, 10, 10, 0, 0)) {
        return 8;
    }

    /* k-regular directed graph, too large degree, no multiple edges */
    if (!igraph_k_regular_game(&g, 10, 10, 1, 0)) {
        return 9;
    }

    /* empty graph */
    if (igraph_k_regular_game(&g, 0, 0, 0, 0)) {
        return 10;
    }
    if (igraph_vcount(&g) != 0 || igraph_ecount(&g) != 0 || igraph_is_directed(&g)) {
        return 11;
    }
    igraph_destroy(&g);
    if (igraph_k_regular_game(&g, 0, 0, 1, 0)) {
        return 12;
    }
    if (igraph_vcount(&g) != 0 || igraph_ecount(&g) != 0 || !igraph_is_directed(&g)) {
        return 13;
    }
    igraph_destroy(&g);

    igraph_vector_destroy(°);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_k_regular_game.out0000644000175100001710000000047000000000000027023 0ustar00runnerdocker000000000000004 4 4 4 4 4 4 4 4 4
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
4 4 4 4 4 4 4 4 4 4
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
4 4 4 4 4 4 4 4 4 4
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_kautz.c0000644000175100001710000000443500000000000024635 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, g_test;
    igraph_bool_t iso, same;

    /*   BA, AB, CB, etc.     */
    IGRAPH_ASSERT(igraph_kautz(&g, /* m */ 2, /* n */ 1) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 6, IGRAPH_DIRECTED, 0, 1, 0, 5, 1, 0, 1, 4, 2, 0, 2, 4, 3, 1, 3, 5, 4, 2, 4, 3, 5, 3, 5, 2, -1);
    IGRAPH_ASSERT(igraph_isomorphic(&g, &g_test, &iso) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(iso);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    /*  1 symbol, string length 11, should be empty graph   */
    IGRAPH_ASSERT(igraph_kautz(&g, /* m */ 0, /* n */ 10) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 0, IGRAPH_DIRECTED, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    /*  1 symbol, string length 1 should be single vertex   */
    IGRAPH_ASSERT(igraph_kautz(&g, /* m */ 0, /* n */ 0) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 1, IGRAPH_DIRECTED, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    /*  String length 1 should be full graph   */
    IGRAPH_ASSERT(igraph_kautz(&g, /* m */ 5, /* n */ 0) == IGRAPH_SUCCESS);
    igraph_full(&g_test, 6, IGRAPH_DIRECTED, /*loops*/ 0);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g);
    igraph_destroy(&g_test);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgehrd.c0000644000175100001710000000474200000000000026250 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    int nodes = 10;
    igraph_t tree;
    igraph_matrix_t sto;
    igraph_matrix_t hess;
    igraph_matrix_complex_t evec1, evec2;
    igraph_vector_complex_t eval1, eval2;
    igraph_eigen_which_t which;
    int i;

    igraph_tree(&tree, nodes, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_matrix_init(&sto, nodes, nodes);
    igraph_get_stochastic(&tree, &sto, /*column_wise=*/ 0);
    igraph_matrix_transpose(&sto);

    igraph_matrix_init(&hess, nodes, nodes);
    igraph_lapack_dgehrd(&sto, 1, nodes, &hess);

    igraph_matrix_complex_init(&evec1, 0, 0);
    igraph_vector_complex_init(&eval1, 0);
    which.pos = IGRAPH_EIGEN_ALL;
    igraph_eigen_matrix(&sto, 0, 0, nodes, 0, IGRAPH_EIGEN_LAPACK, &which, 0, 0,
                        &eval1, &evec1);

    igraph_matrix_complex_init(&evec2, 0, 0);
    igraph_vector_complex_init(&eval2, 0);
    igraph_eigen_matrix(&hess, 0, 0, nodes, 0, IGRAPH_EIGEN_LAPACK, &which, 0,
                        0, &eval2, &evec2);

    for (i = 0; i < nodes; i++) {
        igraph_real_t d = igraph_complex_abs(igraph_complex_sub(VECTOR(eval1)[i],
                                             VECTOR(eval2)[i]));
        if (d > 1e-14) {
            printf("Difference: %g\n", d);
            return 1;
        }
    }

    igraph_matrix_complex_destroy(&evec2);
    igraph_vector_complex_destroy(&eval2);

    igraph_matrix_complex_destroy(&evec1);
    igraph_vector_complex_destroy(&eval1);

    igraph_matrix_destroy(&hess);
    igraph_matrix_destroy(&sto);
    igraph_destroy(&tree);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgehrd.out0000644000175100001710000000000000000000000026614 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgetrf.c0000644000175100001710000000465000000000000026264 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void check_and_destroy(igraph_matrix_t *matrix, igraph_bool_t pivot) {
    igraph_vector_int_t pivot_indices;
    int info;
    igraph_vector_int_init(&pivot_indices, 0);
    printf("Starting matrix:\n");
    igraph_matrix_print(matrix);
    if (pivot) {
        IGRAPH_ASSERT(igraph_lapack_dgetrf(matrix, &pivot_indices, &info) == IGRAPH_SUCCESS);
    } else {
        IGRAPH_ASSERT(igraph_lapack_dgetrf(matrix, NULL, &info) == IGRAPH_SUCCESS);
    }
    printf("Returned matrix:\n");
    igraph_matrix_print(matrix);
    if (pivot) {
        printf("Returned pivot indices:\n");
        igraph_vector_int_print(&pivot_indices);
    }
    printf("info: %d\n", info);
    igraph_vector_int_destroy(&pivot_indices);
    igraph_matrix_destroy(matrix);
    printf("\n");
}

int main() {
    igraph_matrix_t matrix;

    printf("Empty matrix:\n");
    igraph_matrix_init(&matrix, 0, 0);
    check_and_destroy(&matrix, 1);

    int elements_1[9] = {7, 8, 9, 2, 2, 3, 1, 1, 1};
    matrix_init_int_row_major(&matrix, 3, 3, elements_1);
    check_and_destroy(&matrix, 1);

    int elements_2[9] = {1, 1, 1, 2, 2, 3, 7, 8, 9};
    matrix_init_int_row_major(&matrix, 3, 3, elements_2);
    check_and_destroy(&matrix, 1);

    int elements_3[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    matrix_init_int_row_major(&matrix, 3, 3, elements_3);
    check_and_destroy(&matrix, 0);

    int elements_4[6] = {1, 2, 3, 4, 5, 6};
    matrix_init_int_row_major(&matrix, 2, 3, elements_4);
    check_and_destroy(&matrix, 1);

    int elements_5[6] = {1, 2, 3, 4, 5, 6};
    matrix_init_int_row_major(&matrix, 3, 2, elements_5);
    check_and_destroy(&matrix, 1);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgetrf.out0000644000175100001710000000122100000000000026640 0ustar00runnerdocker00000000000000Empty matrix:
Starting matrix:
Returned matrix:
Returned pivot indices:

info: 0

Starting matrix:
7 8 9
2 2 3
1 1 1
Returned matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Returned pivot indices:
1 2 3
info: 0

Starting matrix:
1 1 1
2 2 3
7 8 9
Returned matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Returned pivot indices:
3 2 3
info: 0

Starting matrix:
0 1 2
3 4 5
6 7 8
Returned matrix:
6 7 8
0 1 2
0.5 0.5 0
info: 3

Starting matrix:
1 2 3
4 5 6
Returned matrix:
4 5 6
0.25 0.75 1.5
Returned pivot indices:
2 2
info: 0

Starting matrix:
1 2
3 4
5 6
Returned matrix:
5 6
0.2 0.8
0.6 0.5
Returned pivot indices:
3 3
info: 0

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgetrs.c0000644000175100001710000001145300000000000026300 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void check_and_destroy(igraph_matrix_t *a, igraph_matrix_t *b, igraph_vector_int_t *ipiv,
                       igraph_bool_t transpose, igraph_error_type_t error) {
    printf("LU matrix:\n");
    igraph_matrix_print(a);
    printf("Pivot vector:\n");
    igraph_vector_int_print(ipiv);
    printf("B matrix:\n");
    igraph_matrix_print(b);
    IGRAPH_ASSERT(igraph_lapack_dgetrs(transpose, a, ipiv, b) == error);
    if (error == IGRAPH_SUCCESS) {
        printf("Returned matrix:\n");
        igraph_matrix_print(b);
    }
    igraph_vector_int_destroy(ipiv);
    igraph_matrix_destroy(a);
    igraph_matrix_destroy(b);
    printf("\n");
}

int main() {
    igraph_matrix_t a, b;
    igraph_vector_int_t ipiv;

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking empty matrices:\n");
    igraph_matrix_init(&a, 0, 0);
    igraph_matrix_init(&b, 0, 0);
    igraph_vector_int_init_int(&ipiv, 0);
    check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_SUCCESS);

    {
        printf("Checking 3x3 matrix:\n");
        double a_elements[] = {7, 8, 9, 2./7., -2./7., 3./7., 1./7., 1./2., -1./2.};
        int b_elements[] = {1, 1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 3, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 3, 1, 2, 3);
        check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_SUCCESS);
    }
    {
        printf("Checking transpose and pivot:\n");
        double a_elements[] = {9, 3, 1, 8./9., -2./3., 1./9., 7./9., 1./2., 1./6.};
        int b_elements[] = {1, 1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 3, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 3, 3, 2, 3);
        check_and_destroy(&a, &b, &ipiv, 1, IGRAPH_SUCCESS);
    }
    {
        printf("Checking 2x3 matrix, expected to fail:\n");
        double a_elements[] = {4, 5, 6, 1./4., 3./4., 3./2.};
        int b_elements[] = {1, 1};
        matrix_init_real_row_major(&a, 2, 3, a_elements);
        matrix_init_int_row_major(&b, 2, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 2, 2, 2);
        check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_NONSQUARE);
    }
    {
        printf("Checking singular matrix, this gives random output, so we just check for memory problems.\n\n");
        double a_elements[] = {6, 8, 7, 0, 1, 2, 0.5, 0.5, 0};
        int b_elements[] = {1, 1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 3, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 3, 1, 2, 3);
        IGRAPH_ASSERT(igraph_lapack_dgetrs(0, &a, &ipiv, &b) == IGRAPH_SUCCESS);
        igraph_vector_int_destroy(&ipiv);
        igraph_matrix_destroy(&a);
        igraph_matrix_destroy(&b);
    }
    {
        printf("Checking wrong size of B matrix, should fail:\n");
        double a_elements[] = {7, 8, 9, 2./7., -2./7., 3./7., 1./7., 1./2., -1./2.};
        int b_elements[] = {1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 2, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 3, 1, 2, 3);
        check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_EINVAL);
    }
    {
        printf("Checking nonexisting pivots, should fail:\n");
        double a_elements[] = {7, 8, 9, 2./7., -2./7., 3./7., 1./7., 1./2., -1./2.};
        int b_elements[] = {1, 1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 3, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 3, 5, 6, 7);
        check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_EINVAL);
    }
    {
        printf("Checking too few pivots, should fail:\n");
        double a_elements[] = {7, 8, 9, 2./7., -2./7., 3./7., 1./7., 1./2., -1./2.};
        int b_elements[] = {1, 1, 1};
        matrix_init_real_row_major(&a, 3, 3, a_elements);
        matrix_init_int_row_major(&b, 3, 1, b_elements);
        igraph_vector_int_init_int(&ipiv, 0);
        check_and_destroy(&a, &b, &ipiv, 0, IGRAPH_EINVAL);
    }

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lapack_dgetrs.out0000644000175100001710000000174500000000000026670 0ustar00runnerdocker00000000000000Checking empty matrices:
LU matrix:
Pivot vector:

B matrix:
Returned matrix:

Checking 3x3 matrix:
LU matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Pivot vector:
1 2 3
B matrix:
1
1
1
Returned matrix:
6
-4
-1

Checking transpose and pivot:
LU matrix:
9 3 1
0.888889 -0.666667 0.111111
0.777778 0.5 0.166667
Pivot vector:
3 2 3
B matrix:
1
1
1
Returned matrix:
6
-4
-1

Checking 2x3 matrix, expected to fail:
LU matrix:
4 5 6
0.25 0.75 1.5
Pivot vector:
2 2
B matrix:
1
1

Checking singular matrix, this gives random output, so we just check for memory problems.

Checking wrong size of B matrix, should fail:
LU matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Pivot vector:
1 2 3
B matrix:
1
1

Checking nonexisting pivots, should fail:
LU matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Pivot vector:
5 6 7
B matrix:
1
1
1

Checking too few pivots, should fail:
LU matrix:
7 8 9
0.285714 -0.285714 0.428571
0.142857 0.5 -0.5
Pivot vector:

B matrix:
1
1
1

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lastcit_game.c0000644000175100001710000000743300000000000026134 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_vector_t preference;

    igraph_rng_seed(igraph_rng_default(), 42);

    /*No nodes*/
    igraph_vector_init_int_end(&preference, -1, 1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 0, /*edges_per_node*/ 5, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 0);
    igraph_destroy(&g);
    igraph_vector_destroy(&preference);

    /*No edges*/
    igraph_vector_init_int_end(&preference, -1, 1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 0, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 9);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    igraph_destroy(&g);
    igraph_vector_destroy(&preference);

    /*Only cite un-cited to make a line*/
    igraph_vector_init_int_end(&preference, -1, 0, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&preference);

    /*Hugely prefer cited to make a star*/
    igraph_vector_init_real(&preference, 2, 1e30, 1e-30);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);
    igraph_vector_destroy(&preference);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /*Negative number of nodes*/
    igraph_vector_init_int_end(&preference, -1, 1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ -9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&preference);

    /*Too few agebins*/
    igraph_vector_init_int_end(&preference, -1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 0, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&preference);

    /*Wrong vector size*/
    igraph_vector_init_int_end(&preference, -1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&preference);

    /*No uncited preference*/
    igraph_vector_init_int_end(&preference, -1, 1, 0, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&preference);

    /*Negative preference*/
    igraph_vector_init_int_end(&preference, -1, -1, 1, -1);
    IGRAPH_ASSERT(igraph_lastcit_game(&g, /*nodes*/ 9, /*edges_per_node*/ 1, /*agebins*/ 1, /*preference*/ &preference, /*directed*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&preference);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lastcit_game.out0000644000175100001710000000021100000000000026504 0ustar00runnerdocker00000000000000directed: false
vcount: 9
edges: {
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
}
directed: true
vcount: 9
edges: {
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_lattice.c0000644000175100001710000001516000000000000025121 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

typedef struct {
    int dim;
    int m;
    int nei;
    igraph_bool_t directed, mutual, circular;
    igraph_real_t *dimedges;
} lat_test_t;

#define LAT_TEST(id, d, m, ne, di, mu, ci, ...) \
    igraph_real_t lat_ ## id ## _edges[] = { __VA_ARGS__ } ; \
    lat_test_t lat_ ## id = { d, m, ne, di, mu, ci, lat_ ## id ## _edges }

/*----------------d--m--ne-di-mu-ci-dimedges------------------------*/
LAT_TEST(u_0,     0, 0, 1, 0, 0, 0,  -1 );
LAT_TEST(u_01,    1, 0, 1, 0, 0, 0,  0 );
LAT_TEST(u_02,    2, 0, 1, 0, 0, 0,  0, 1 );
LAT_TEST(u_03,    2, 0, 1, 0, 0, 0,  1, 0 );

LAT_TEST(d_0,     0, 0, 1, 1, 0, 0,  -1 );
LAT_TEST(d_01,    1, 0, 1, 1, 0, 0,  0 );
LAT_TEST(d_02,    2, 0, 1, 1, 0, 0,  0, 1 );
LAT_TEST(d_03,    2, 0, 1, 1, 0, 0,  1, 0 );

LAT_TEST(u_1,     1, 0, 1, 0, 0, 0,  1 );
LAT_TEST(u_1x1,   2, 0, 1, 0, 0, 0,  1, 1 );
LAT_TEST(u_2,     1, 1, 1, 0, 0, 0,  2, 0, 1 );
LAT_TEST(u_2x1,   2, 1, 1, 0, 0, 0,  2, 1, 0, 1 );
LAT_TEST(u_2x2,   2, 4, 1, 0, 0, 0,  2, 2, 0, 1, 0, 2, 1, 3, 2, 3 );

LAT_TEST(uc_1,    1, 0, 1, 0, 0, 1,  1 );
LAT_TEST(uc_1x1,  2, 0, 1, 0, 0, 1,  1, 1 );
LAT_TEST(uc_2,    1, 1, 1, 0, 0, 1,  2, 0, 1 );
LAT_TEST(uc_2x1,  2, 1, 1, 0, 0, 1,  2, 1, 0, 1 );
LAT_TEST(uc_2x2,  2, 4, 1, 0, 0, 1,  2, 2, 0, 1, 0, 2, 1, 3, 2, 3 );

LAT_TEST(dc_1,    1, 0, 1, 1, 0, 1,  1 );
LAT_TEST(dc_1x1,  2, 0, 1, 1, 0, 1,  1, 1 );
LAT_TEST(dc_2,    1, 2, 1, 1, 0, 1,  2, 0, 1, 1, 0 );
LAT_TEST(dc_2x1,  2, 2, 1, 1, 0, 1,  2, 1, 0, 1, 1, 0 );
LAT_TEST(dc_2x2,  2, 8, 1, 1, 0, 1,  2, 2, 0, 1, 0, 2, 1, 3, 2, 3,
         1, 0, 2, 0, 3, 1, 3, 2, );

LAT_TEST(d_1,     1, 0, 1, 1, 0, 0,  1 );
LAT_TEST(d_1x1,   2, 0, 1, 1, 0, 0,  1, 1 );
LAT_TEST(d_2,     1, 1, 1, 1, 0, 0,  2, 0, 1 );
LAT_TEST(d_2x1,   2, 1, 1, 1, 0, 0,  2, 1, 0, 1 );
LAT_TEST(d_2x2,   2, 4, 1, 1, 0, 0,  2, 2, 0, 1, 0, 2, 1, 3, 2, 3 );

LAT_TEST(dmc_1,   1, 0, 1, 1, 0, 1,  1 );
LAT_TEST(dmc_1x1, 2, 0, 1, 1, 0, 1,  1, 1 );
LAT_TEST(dmc_2,   1, 2, 1, 1, 0, 1,  2, 0, 1, 1, 0 );
LAT_TEST(dmc_2x1, 2, 2, 1, 1, 0, 1,  2, 1, 0, 1, 1, 0 );
LAT_TEST(dmc_2x2, 2, 4, 1, 1, 0, 1,  2, 2, 0, 1, 0, 2, 1, 3, 2, 3,
         1, 0, 3, 2, );
/*----------------d--m--ne-di-mu-ci-dimedges------------------------*/

/* TODO: add more */

lat_test_t *all_checks[] = { /*  1 */ &lat_u_0,   /*  2 */ &lat_u_01,
                                      /*  3 */ &lat_u_02,  /*  4 */ &lat_u_03,
                                      /*  5 */ &lat_d_0,   /*  6 */ &lat_d_01,
                                      /*  7 */ &lat_d_02,  /*  8 */ &lat_d_03,
                                      /*  9 */ &lat_u_1,   /* 10 */ &lat_u_1x1,
                                      /* 11 */ &lat_u_2,   /* 12 */ &lat_u_2x1,
                                      /* 13 */ &lat_u_2x2, /* 14 */ &lat_u_1,
                                      /* 15 */ &lat_u_1x1, /* 16 */ &lat_u_2,
                                      /* 17 */ &lat_u_2x1, /* 18 */ &lat_uc_2x2,
                                      /* 19 */ &lat_dc_1,  /* 20 */ &lat_dc_1x1,
                                      /* 21 */ &lat_dc_2,  /* 22 */ &lat_dc_2x1,
                                      /* 23 */ &lat_dc_2x2,/* 24 */ &lat_d_1,
                                      /* 25 */ &lat_d_1x1, /* 26 */ &lat_d_2,
                                      /* 27 */ &lat_d_2x1, /* 28 */ &lat_d_2x2,
                                      /* 29 */ &lat_dc_2x2,/* 30 */ &lat_d_1,
                                      /* 31 */ &lat_d_1x1, /* 32 */ &lat_d_2,
                                      /* 33 */ &lat_d_2x1, /* 34 */ &lat_d_2x2,
                                      0
                           };

int check_lattice_properties(const igraph_t *lattice,
                             const igraph_vector_t *dim,
                             igraph_bool_t directed,
                             igraph_bool_t mutual,
                             igraph_bool_t circular) {
    igraph_bool_t res;

    /* Connected */
    igraph_is_connected(lattice, &res, IGRAPH_WEAK);
    if (!res && igraph_vcount(lattice) > 0) {
        printf("Not connected\n");
        return 1;
    }

    /* Simple */
    igraph_is_simple(lattice, &res);
    if (!res) {
        printf("Not simple\n");
        return 2;
    }

    return 0;
}

int check_lattice(const lat_test_t *test) {
    igraph_t graph, othergraph;
    igraph_vector_t otheredges;
    igraph_vector_t dimvector;
    igraph_bool_t iso;
    int ret;

    /* Create lattice */
    igraph_vector_view(&dimvector, test->dimedges, test->dim);
    igraph_lattice(&graph, &dimvector, test->nei, test->directed,
                   test->mutual, test->circular);

    /* Check its properties */
    if ((ret = check_lattice_properties(&graph, &dimvector, test->directed,
                                        test->mutual, test->circular))) {
        igraph_destroy(&graph);
        printf("Lattice properties are not satisfied\n");
        return ret;
    }

    /* Check that it is isomorphic to the stored graph */
    igraph_vector_view(&otheredges, test->dimedges + test->dim, test->m * 2);
    igraph_create(&othergraph, &otheredges, igraph_vector_prod(&dimvector),
                  test->directed);
    igraph_isomorphic(&graph, &othergraph, &iso);
    if (!iso) {
        printf("--\n");
        igraph_write_graph_edgelist(&graph, stdout);
        printf("--\n");
        igraph_write_graph_edgelist(&othergraph, stdout);
        igraph_destroy(&graph);
        igraph_destroy(&othergraph);
        return 50;
    }

    igraph_destroy(&graph);
    igraph_destroy(&othergraph);
    return 0;
}

int main() {
    int i, ret;

    i = 0;
    while (all_checks[i]) {
        if ((ret = check_lattice(all_checks[i]))) {
            printf("Check no #%d failed.\n", (int) (i + 1));
            return ret;
        }
        i++;
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_bipartite.c0000644000175100001710000001106600000000000027055 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_matrix_t result;
    igraph_vector_bool_t types;

    printf("No vertices:\n");
    igraph_small(&g, 0, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init(&types, 0);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/ 100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("1 vertex:\n");
    igraph_small(&g, 1, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 1, 0);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/ 100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("4 vertices, disconnected, not actually bipartite, with loops and multiple edges:\n");
    igraph_small(&g, 4, 0, 0,0, 0,0, 0,0, 1,2, 1,2, 1,3, 1,3, 2,3, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 4, 0, 1, 0, 1);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/ 100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("10 vertices bipartite graph:\n");
    igraph_small(&g, 10, 0, 0,5, 0,7, 1,6, 1,7, 1,8, 2,5, 3,8, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 10, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("10 vertices bipartite graph, no iterations:\n");
    igraph_small(&g, 10, 0, 0,5, 0,7, 1,6, 1,7, 1,8, 2,5, 3,8, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 10, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/0) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("4 vertices with -10 true values for types:\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, 3,0, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 4, 0, -10, 0, -10);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ 1.0, /*maxiter*/ 100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("4 vertices, negative vgaps:\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, 3,0, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 4, 0, 1, 0, 1);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ 1.0, /*vgap*/ -1.0, /*maxiter*/ 100) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("4 vertices, negative hgaps, emits error.\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, 3,0, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_bool_init_int(&types, 4, 0, 1, 0, 1);
    IGRAPH_ASSERT(igraph_layout_bipartite(&g, &types, &result, /*hgap*/ -1.0, /*vgap*/ 1.0, /*maxiter*/ 100) == IGRAPH_EINVAL);
    igraph_vector_bool_destroy(&types);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_bipartite.out0000644000175100001710000000170100000000000027435 0ustar00runnerdocker00000000000000No vertices:
1 vertex:
[        0        1 ]
4 vertices, disconnected, not actually bipartite, with loops and multiple edges:
[        0        1
         1        0
         1        1
         2        0 ]
10 vertices bipartite graph:
[        1        1
         2        1
         0        1
         3        1
         4        1
         0        0
         2        0
         1        0
         3        0
         5        0 ]
10 vertices bipartite graph, no iterations:
[     -0.5        1
         1        1
         2        1
         3        1
         4        1
         0        0
         1        0
         2        0
         3        0
         5        0 ]
4 vertices with -10 true values for types:
[        0        1
         0        0
         1        1
         1        0 ]
4 vertices, negative vgaps:
[        0       -1
         0        0
         1       -1
         1        0 ]
4 vertices, negative hgaps, emits error.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_davidson_harel.c0000644000175100001710000000700700000000000030054 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set ts=4 sw=4 sts=4 et: */
/*
   IGraph R package.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "layout/layout_internal.h"

#include "test_utilities.inc"

int intersect() {

    float negative[][8] = {
        { 1, 2, 2, 2, 1, 1, 2, 1 }, /* 1 */
        { 1, 2, 1, 1, 2, 2, 2, 1 }, /* 2 */
        { 1, 0, 0, 1, 2, 0, 3, 1 }, /* 3 */
        { 1, 0, 1, 1, 0, 2, 2, 2 }, /* 4 */
        { 1, 0, 1, 2, 3, 1, 3, 3 }, /* 5 */
        { 0, 0, 0, 2, 1, 1, 1, 2 }, /* 6 */
        { 0, 1, 1, 1, 2, 0, 2, 3 }, /* 7 */
        { 0, 0, 5, 0, 2, 1, 4, 3 }, /* 8 */
        { 0, 0, 5, 5, 3, 2, 3, 2 }  /* 9 */
    };

    float positive[][8] = {
        { 0, 1, 2, 1, 1, 0, 1, 2 }, /* 10 */
        { 0, 2, 5, 2, 1, 1, 4, 3 }, /* 11 */
        { 0, 0, 0, 3, 0, 1, 5, 1 }, /* 12 */
        { 0, 4, 2, 6, 0, 4, 2, 2 }  /* 13 */
    };
    /* { 1,1,1,1, 1,1,0,0 }, /\* 14 *\/ */
    /* { 0,0,1,1, 1,1,1,1 }, /\* 15 *\/ */
    /* { 0,0,2,2, 1,1,1,1 }}; /\* 16 *\/ */

    int no_neg = sizeof(negative) / sizeof(float) / 8;
    int no_pos = sizeof(positive) / sizeof(float) / 8;
    int i;

    for (i = 0; i < no_neg; i++) {
        float *co = negative[i];
        if (igraph_i_layout_segments_intersect(co[0], co[1], co[2], co[3],
                                        co[4], co[5], co[6], co[7])) {
            return i + 1;
        }
    }

    for (i = 0; i < no_pos; i++) {
        float *co = positive[i];
        if (!igraph_i_layout_segments_intersect(co[0], co[1], co[2], co[3],
                                         co[4], co[5], co[6], co[7])) {
            return no_neg + i + 1;
        }
    }

    return 0;
}

int distance() {

    float configs[][7] = {
        { 1, 1, 2, 0, 2, 3, 1.0 }, /* 1 */
        { 1, 1, 1, 0, 1, 3, 0.0 }, /* 2 */
        { 1, 1, 0, 1, 1, 0, 0.5 }, /* 3 */
        { 1, 2, 0, 0, 0, 1, 2.0 }, /* 4 */
        { 1, 0, 0, 1, 0, 2, 2.0 }, /* 5 */
        { 0, 0, 1, 1, 1, 2, 2.0 }, /* 6 */
        { 0, 3, 1, 1, 1, 2, 2.0 }  /* 7 */
    };

    int no = sizeof(configs) / sizeof(float) / 8;
    int i;

    for (i = 0; i < no; i++) {
        float *co = configs[i];
        float res = igraph_i_layout_point_segment_dist2(co[0], co[1],
                    co[2], co[3], co[4], co[5]);
        if (fabsf(res - co[6]) > 1e-12) {
            printf("%g\n", (double) res);
            return i + 1;
        }
    }

    return 0;
}

int main() {
    int res1, res2;

    res1 = intersect();
    if (res1 != 0) {
        printf("Unexpected result from intersect(), config %d.\n", res1);
        return res1;
    }
    res2 = distance() ;
    if (res2 != 0) {
        printf("Unexpected result from distance(), config %d.\n", res2);
        return res2;
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_drl.c0000644000175100001710000000656600000000000025664 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void set_options_fast(igraph_layout_drl_options_t *options) {
        options->edge_cut = 4.0/5.0;

        options->init_iterations   = 10;
        options->init_temperature  = 2000;
        options->init_attraction   = 10;
        options->init_damping_mult = 1.0;

        options->liquid_iterations   = 10;
        options->liquid_temperature  = 2000;
        options->liquid_attraction   = 10;
        options->liquid_damping_mult = 1.0;

        options->expansion_iterations   = 10;
        options->expansion_temperature  = 2000;
        options->expansion_attraction   = 2;
        options->expansion_damping_mult = 1.0;

        options->cooldown_iterations   = 10;
        options->cooldown_temperature  = 2000;
        options->cooldown_attraction   = 1;
        options->cooldown_damping_mult = .1;

        options->crunch_iterations   = 10;
        options->crunch_temperature  = 250;
        options->crunch_attraction   = 1;
        options->crunch_damping_mult = 0.25;

        options->simmer_iterations   = 10;
        options->simmer_temperature  = 250;
        options->simmer_attraction   = .5;
        options->simmer_damping_mult = 1;
}

void check_and_destroy(igraph_matrix_t *result, igraph_real_t half_size) {
    igraph_real_t min, max;
    igraph_matrix_minmax(result, &min, &max);
    IGRAPH_ASSERT(min >= -half_size);
    IGRAPH_ASSERT(max <= half_size);
    igraph_matrix_destroy(result);
}

int main() {
    igraph_t g;
    igraph_matrix_t result;
    igraph_layout_drl_options_t options;
    int i;
    igraph_real_t *damping_muls[6] = {&options.init_damping_mult, &options.liquid_damping_mult, &options.expansion_damping_mult, &options.cooldown_damping_mult, &options.crunch_damping_mult, &options.simmer_damping_mult};

    igraph_rng_seed(igraph_rng_default(), 42);

    set_options_fast(&options);

    printf("The Zachary karate club.\n");
    igraph_famous(&g, "zachary");
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_drl(&g, &result, /*use_seed*/ 0, &options,
                  /*weights*/ NULL, /*fixed*/ 0) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 50);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative damping.\n");
    igraph_matrix_init(&result, 0, 0);
    for (i = 0; i < 6; i++) {
        *damping_muls[i] *= -1.0;
        IGRAPH_ASSERT(igraph_layout_drl(&g, &result, /*use_seed*/ 0, &options,
                    /*weights*/ NULL, /*fixed*/ 0) == IGRAPH_EINVAL);
        *damping_muls[i] *= -1.0;
    }
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_fruchterman_reingold.c0000644000175100001710000001242400000000000031272 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void make_box(int vertices, float half_size, igraph_vector_t *bounds) {
    for (int i = 0; i < 4; i++) {
        igraph_vector_init(&bounds[i], vertices);
    }
    igraph_vector_fill(&bounds[0], -half_size);
    igraph_vector_fill(&bounds[1], half_size);
    igraph_vector_fill(&bounds[2], -half_size);
    igraph_vector_fill(&bounds[3], half_size);
}

void destroy_bounds(igraph_vector_t *bounds) {
    for (int i = 0; i < 4; i++) {
        igraph_vector_destroy(&bounds[i]);
    }
}

void check_and_destroy(igraph_matrix_t *result, igraph_real_t half_size) {
    igraph_real_t min, max;
    igraph_matrix_minmax(result, &min, &max);
    IGRAPH_ASSERT(min >= -half_size);
    IGRAPH_ASSERT(max <= half_size);
    igraph_matrix_destroy(result);
}

int main() {
    igraph_t g;
    igraph_matrix_t result;
    igraph_vector_t bounds[4];
    igraph_vector_t weights;
    igraph_real_t seed[20] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0};

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("Empty graph.\n");
    igraph_small(&g, 0, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 0,
                  /*niter*/ 100, /*start_temp*/ 1.0, IGRAPH_LAYOUT_NOGRID,
                  /*weight*/ NULL, /*minx*/ NULL, /*maxx*/ NULL, /*miny*/ NULL,
                  /*maxy*/ NULL) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("Singleton graph in a box.\n");
    igraph_small(&g, 1, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    make_box(1, 1.0, bounds);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 0,
                  /*niter*/ 100, /*start_temp*/ 1.0, IGRAPH_LAYOUT_NOGRID,
                  /*weights*/ NULL, &bounds[0], &bounds[1], &bounds[2], &bounds[3]) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);
    igraph_destroy(&g);
    destroy_bounds(bounds);

    printf("A few tests with a disconnected graph of 10 vertices with loops in a box from -1 to 1.\n");
    igraph_small(&g, 10, 0, 0,1, 1,2, 2,0, 5,6, 6,7, 7,6, 7,7, 8,8, -1);
    igraph_vector_init(&weights, 8);
    igraph_vector_fill(&weights, 100);
    make_box(10, 1.0, bounds);
    printf("Without weights, grid or bounds.\n");
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 0,
                  /*niter*/ 100, /*start_temp*/ 10.0, IGRAPH_LAYOUT_NOGRID,
                  /*weight*/ NULL, /*minx*/ NULL, /*maxx*/ NULL, /*miny*/ NULL,
                  /*maxy*/ NULL) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 50.0);

    printf("With weights and no grid.\n");
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 0,
                  /*niter*/ 100, /*start_temp*/ 1.0, IGRAPH_LAYOUT_NOGRID,
                  /*weight*/ NULL, /*minx*/ NULL, /*maxx*/ NULL, /*miny*/ NULL,
                  /*maxy*/ NULL) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 50.0);

    printf("With weights and grid and high temperature.\n");
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 0,
                  /*niter*/ 10, /*start_temp*/ 1e10, IGRAPH_LAYOUT_GRID,
                  &weights, &bounds[0], &bounds[1], &bounds[2], &bounds[3]) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);

    printf("With weights and grid and high temperature and seed.\n");
    matrix_init_real_row_major(&result, 10, 2, seed);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 1,
                  /*niter*/ 10, /*start_temp*/ 1e10, IGRAPH_LAYOUT_GRID,
                  &weights, &bounds[0], &bounds[1], &bounds[2], &bounds[3]) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);
    igraph_destroy(&g);

    printf("Full graph of 5 vertices, seed and no iterations:\n");
    igraph_full(&g, 5, 0, 0);
    matrix_init_real_row_major(&result, 5, 2, seed);
    IGRAPH_ASSERT(igraph_layout_fruchterman_reingold(&g, &result, /*use_seed*/ 1,
                  /*niter*/ 0, /*start_temp*/ 100, IGRAPH_LAYOUT_GRID,
                  /*weight*/ NULL, /*minx*/ NULL, /*maxx*/ NULL, /*miny*/ NULL,
                  /*maxy*/ NULL) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);
    destroy_bounds(bounds);
    igraph_vector_destroy(&weights);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_fruchterman_reingold.out0000644000175100001710000000066200000000000031660 0ustar00runnerdocker00000000000000Empty graph.
Singleton graph in a box.
A few tests with a disconnected graph of 10 vertices with loops in a box from -1 to 1.
Without weights, grid or bounds.
With weights and no grid.
With weights and grid and high temperature.
With weights and grid and high temperature and seed.
Full graph of 5 vertices, seed and no iterations:
[      0.1      0.2
       0.3      0.4
       0.5      0.6
       0.7      0.8
       0.9        1 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_graphopt.c0000644000175100001710000001115600000000000026716 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void check_and_destroy(igraph_matrix_t *result, igraph_real_t half_size) {
    igraph_real_t min, max;
    igraph_matrix_minmax(result, &min, &max);
    IGRAPH_ASSERT(min >= -half_size);
    IGRAPH_ASSERT(max <= half_size);
    igraph_matrix_destroy(result);
}

int main() {
    igraph_t g;
    igraph_matrix_t result;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    igraph_small(&g, 0, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.001, /*node_mass*/ 30, /*spring_length*/ 0, /*spring constant*/ 1, /*max_sa_movement*/ 5, /*use seed*/ 0) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("One vertex.\n");
    igraph_small(&g, 1, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.001, /*node_mass*/ 30, /*spring_length*/ 0, /*spring constant*/ 1, /*max_sa_movement*/ 5, /*use seed*/ 0) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);
    igraph_destroy(&g);

    printf("Full graph of 4 vertices, no loops.\n");
    igraph_full(&g, 4, 0, 0);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.001, /*node_mass*/ 30, /*spring_length*/ 0, /*spring constant*/ 1, /*max_sa_movement*/ 5, /*use seed*/ 0) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 20.0);
    igraph_destroy(&g);

    printf("4 vertices, disconnected, with loops and multi-edges.\n");
    igraph_small(&g, 4, 0, 0,0, 0,0, 0,0, 1,2, 1,2, 1,2, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.001, /*node_mass*/ 30, /*spring_length*/ 0, /*spring constant*/ 1, /*max_sa_movement*/ 5, /*use seed*/ 0) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 100.0);
    igraph_destroy(&g);

    printf("Full graph of 4 vertices, no loops with no repulsion.\n");
    igraph_full(&g, 4, 0, 0);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.0, /*node_mass*/ 30, /*spring_length*/ 0, /*spring constant*/ 1, /*max_sa_movement*/ 5, /*use seed*/ 0) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);
    igraph_destroy(&g);

    printf("4 vertices in a line, with no repulsion, spring length 1 and a seed:\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, -1);
    igraph_real_t seed[] = {0.15, -0.15, 0.05, -0.05, -0.05, 0.05, -0.15, 0.15};
    matrix_init_real_row_major(&result, 4, 2, seed);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.0, /*node_mass*/ 30, /*spring_length*/ 1, /*spring constant*/ 10, /*max_sa_movement*/ 5, /*use seed*/ 1) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("4 vertices in a line, with no repulsion, spring length 1 and a seed, no sa_movement:\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, -1);
    matrix_init_real_row_major(&result, 4, 2, seed);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.0, /*node_mass*/ 30, /*spring_length*/ 1, /*spring constant*/ 10, /*max_sa_movement*/ 0, /*use seed*/ 1) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);

    printf("Wrong size seed.\n");
    igraph_small(&g, 4, 0, 0,1, 1,2, 2,3, -1);
    matrix_init_real_row_major(&result, 3, 2, seed);
    IGRAPH_ASSERT(igraph_layout_graphopt(&g, &result, /*niter*/ 500, /*node_charge*/ 0.0, /*node_mass*/ 30, /*spring_length*/ 1, /*spring constant*/ 10, /*max_sa_movement*/ 0, /*use seed*/ 1) == IGRAPH_SUCCESS);
    check_and_destroy(&result, 1.0);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_graphopt.out0000644000175100001710000000077200000000000027305 0ustar00runnerdocker00000000000000No vertices:
One vertex.
Full graph of 4 vertices, no loops.
4 vertices, disconnected, with loops and multi-edges.
Full graph of 4 vertices, no loops with no repulsion.
4 vertices in a line, with no repulsion, spring length 1 and a seed:
[  1.06066 -1.06066
  0.353553 -0.353553
  -0.353553 0.353553
  -1.06066  1.06066 ]
4 vertices in a line, with no repulsion, spring length 1 and a seed, no sa_movement:
[     0.15    -0.15
      0.05    -0.05
     -0.05     0.05
     -0.15     0.15 ]
Wrong size seed.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_grid.c0000644000175100001710000000371400000000000026020 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_matrix_t coords;

    igraph_empty(&g, 15, 0);
    igraph_matrix_init(&coords, 0, 0);

    /* Predefined width, 2D */
    igraph_layout_grid(&g, &coords, 5);
    igraph_matrix_print(&coords);
    printf("===\n");

    /* Automatic width, 2D */
    igraph_layout_grid(&g, &coords, -1);
    igraph_matrix_print(&coords);
    printf("===\n");

    /* Predefined width and height, 3D */
    igraph_layout_grid_3d(&g, &coords, 4, 2);
    igraph_matrix_print(&coords);
    printf("=====\n");

    /* Predefined width, 3D */
    igraph_layout_grid_3d(&g, &coords, 4, -1);
    igraph_matrix_print(&coords);
    printf("=====\n");

    /* Predefined height, 3D */
    igraph_layout_grid_3d(&g, &coords, -1, 3);
    igraph_matrix_print(&coords);
    printf("=====\n");

    /* Automatic width and height, 3D */
    igraph_layout_grid_3d(&g, &coords, -1, -1);
    igraph_matrix_print(&coords);

    igraph_matrix_destroy(&coords);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_grid.out0000644000175100001710000000077200000000000026406 0ustar00runnerdocker000000000000000 0
1 0
2 0
3 0
4 0
0 1
1 1
2 1
3 1
4 1
0 2
1 2
2 2
3 2
4 2
===
0 0
1 0
2 0
3 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
0 3
1 3
2 3
===
0 0 0
1 0 0
2 0 0
3 0 0
0 1 0
1 1 0
2 1 0
3 1 0
0 0 1
1 0 1
2 0 1
3 0 1
0 1 1
1 1 1
2 1 1
=====
0 0 0
1 0 0
2 0 0
3 0 0
0 1 0
1 1 0
2 1 0
3 1 0
0 0 1
1 0 1
2 0 1
3 0 1
0 1 1
1 1 1
2 1 1
=====
0 0 0
1 0 0
2 0 0
0 1 0
1 1 0
2 1 0
0 2 0
1 2 0
2 2 0
0 0 1
1 0 1
2 0 1
0 1 1
1 1 1
2 1 1
=====
0 0 0
1 0 0
2 0 0
0 1 0
1 1 0
2 1 0
0 2 0
1 2 0
2 2 0
0 0 1
1 0 1
2 0 1
0 1 1
1 1 1
2 1 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_lgl.c0000644000175100001710000000331300000000000025644 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_matrix_t coords;
    igraph_real_t vc;

    igraph_rng_seed(igraph_rng_default(), 33);

    igraph_tree(&g, 100, 3, IGRAPH_TREE_UNDIRECTED);
    /*   igraph_barabasi_game(&g, 1000, 1, 0, 0, IGRAPH_UNDIRECTED); */
    igraph_matrix_init(&coords, 0, 0);
    vc = igraph_vcount(&g);
    igraph_layout_lgl(&g, &coords,
                      /* maxiter */    150,
                      /* maxdelta */   vc,
                      /* area */       vc * vc,
                      /* coolexp */    1.5,
                      /* repulserad */ vc * vc * vc,
                      /* cellsize */   sqrt(sqrt(vc)),
                      /* root */       0);

    igraph_matrix_destroy(&coords);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_mds.c0000644000175100001710000000562200000000000025656 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "test_utilities.inc"

#define sqr(x) ((x)*(x))

int main() {
    igraph_t g;
    igraph_matrix_t coords, dist_mat;
    int i, j;

    srand(42); /* make tests deterministic */

    igraph_tree(&g, 10, 2, IGRAPH_TREE_UNDIRECTED);
    igraph_matrix_init(&coords, 0, 0);
    igraph_layout_mds(&g, &coords, 0, 2);
    if (MATRIX(coords, 0, 0) > 0) {
        for (i = 0; i < igraph_matrix_nrow(&coords); i++) {
            MATRIX(coords, i, 0) *= -1;
        }
    }
    if (MATRIX(coords, 0, 1) < 0) {
        for (i = 0; i < igraph_matrix_nrow(&coords); i++) {
            MATRIX(coords, i, 1) *= -1;
        }
    }
    igraph_matrix_print(&coords);
    igraph_matrix_destroy(&coords);
    igraph_destroy(&g);

    igraph_full(&g, 8, IGRAPH_UNDIRECTED, 0);
    igraph_matrix_init(&coords, 8, 2);
    igraph_matrix_init(&dist_mat, 8, 8);
    for (i = 0; i < 8; i++)
        for (j = 0; j < 2; j++) {
            MATRIX(coords, i, j) = rand() % 1000;
        }
    for (i = 0; i < 8; i++)
        for (j = i + 1; j < 8; j++) {
            double dist_sq = 0.0;
            dist_sq += sqr(MATRIX(coords, i, 0) - MATRIX(coords, j, 0));
            dist_sq += sqr(MATRIX(coords, i, 1) - MATRIX(coords, j, 1));
            MATRIX(dist_mat, i, j) = sqrt(dist_sq);
            MATRIX(dist_mat, j, i) = sqrt(dist_sq);
        }
    igraph_layout_mds(&g, &coords, &dist_mat, 2);
    for (i = 0; i < 8; i++)
        for (j = i + 1; j < 8; j++) {
            double dist_sq = 0.0;
            dist_sq += sqr(MATRIX(coords, i, 0) - MATRIX(coords, j, 0));
            dist_sq += sqr(MATRIX(coords, i, 1) - MATRIX(coords, j, 1));
            if (fabs(sqrt(dist_sq) - MATRIX(dist_mat, i, j)) > 1e-2) {
                printf("dist(%d,%d) should be %.4f, but it is %.4f\n",
                       i, j, MATRIX(dist_mat, i, j), sqrt(dist_sq));
                return 1;
            }
        }
    igraph_matrix_destroy(&dist_mat);
    igraph_matrix_destroy(&coords);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_mds.out0000644000175100001710000000025700000000000026242 0ustar00runnerdocker00000000000000-0.692039 0.0247583
0.399957 0.178289
-1.78403 -0.128772
1.25186 -0.697105
0.891182 1.32979
-2.6988 -0.242629
-2.6988 -0.242629
1.97413 -1.3515
1.97413 -1.3515
1.38241 2.4813
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_merge.c0000644000175100001710000000470500000000000026173 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "layout/layout_internal.h"

#include "test_utilities.inc"

int main() {

    /*******************/
    /* Testing the DLA */
    /*******************/
    long int nodes = 10;
    igraph_i_layout_mergegrid_t grid;
    igraph_vector_t x, y, r;
    long int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&x, nodes);
    igraph_vector_init(&y, nodes);
    igraph_vector_init(&r, nodes);
    igraph_i_layout_mergegrid_init(&grid, -5, 5, 100, -5, 5, 100);

    /* radius */
    for (i = 0; i < nodes; i++) {
        VECTOR(r)[i] = rand() / (double)RAND_MAX;
    }
    igraph_vector_sort(&r);

    /* place */
    VECTOR(x)[0] = 0;
    VECTOR(y)[0] = 0;
    igraph_i_layout_merge_place_sphere(&grid, 0, 0, VECTOR(r)[nodes - 1], 0);

    for (i = 1; i < nodes; i++) {
        /*     fprintf(stderr, "%li ", i); */
        igraph_i_layout_merge_dla(&grid, i,
                                  igraph_vector_e_ptr(&x, i),
                                  igraph_vector_e_ptr(&y, i),
                                  VECTOR(r)[nodes - i - 1], 0, 0, 4, 7);
        igraph_i_layout_merge_place_sphere(&grid, VECTOR(x)[i], VECTOR(y)[i],
                                           VECTOR(r)[nodes - i - 1], i);
    }

    /*   for (i=0; i
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t small, big;
    igraph_matrix_t small_coords, big_coords, merged_coords;
    igraph_vector_ptr_t graph_ptr, coords_ptr;
    igraph_arpack_options_t arpack_opts;
    long int i, j, nrow, ncol;

    /* To make things reproducible */
    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&big, 10, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0,
                 -1);

    igraph_small(&small, 3, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 2, 0,
                 -1);

    igraph_arpack_options_init(&arpack_opts);

    igraph_matrix_init(&big_coords, 0, 0);
    igraph_layout_circle(&big, &big_coords, igraph_vss_all());

    igraph_matrix_init(&small_coords, 0, 0);
    igraph_layout_circle(&small, &small_coords, igraph_vss_all());

    igraph_vector_ptr_init(&graph_ptr, 2);
    igraph_vector_ptr_init(&coords_ptr, 2);
    igraph_matrix_init(&merged_coords, 0, 0);
    VECTOR(graph_ptr)[0] = &big;
    VECTOR(graph_ptr)[1] = &small;
    VECTOR(coords_ptr)[0] = &big_coords;
    VECTOR(coords_ptr)[1] = &small_coords;

    igraph_layout_merge_dla(&graph_ptr, &coords_ptr, &merged_coords);

    nrow = igraph_matrix_nrow(&merged_coords);
    ncol = igraph_matrix_ncol(&merged_coords);
    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            if (fabs((double)MATRIX(merged_coords, i, j)) < 1e-8) {
                MATRIX(merged_coords, i, j) = 0;
            }
        }
    }

    igraph_matrix_printf(&merged_coords, "%.4f");

    igraph_matrix_destroy(&merged_coords);
    igraph_matrix_destroy(&small_coords);
    igraph_matrix_destroy(&big_coords);
    igraph_vector_ptr_destroy(&graph_ptr);
    igraph_vector_ptr_destroy(&coords_ptr);
    igraph_destroy(&small);
    igraph_destroy(&big);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_merge2.out0000644000175100001710000000030200000000000026627 0ustar00runnerdocker000000000000004.0748 0.0000
3.2966 2.3951
1.2592 3.8754
-1.2592 3.8754
-3.2966 2.3951
-4.0748 0.0000
-3.2966 -2.3951
-1.2592 -3.8754
1.2592 -3.8754
3.2966 -2.3951
-1.7741 7.3663
-4.7586 9.0894
-4.7586 5.6432
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_merge3.c0000644000175100001710000000261100000000000026250 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_matrix_t coords;
    int i;

    igraph_matrix_init(&coords, 0, 0);

    for (i = 0; i < 10; i++) {
        igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNP, /*n=*/ 100,
                                /*p=*/ 2.0 / 100, IGRAPH_UNDIRECTED, /*loops=*/ 0);
        igraph_layout_mds(&graph, &coords, /*dist=*/ 0, /*dim=*/ 2);
        igraph_destroy(&graph);
    }

    igraph_matrix_destroy(&coords);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_random_3d.c0000644000175100001710000000335100000000000026736 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_matrix_t result;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    igraph_small(&g, 0, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_random_3d(&g, &result) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_destroy(&g);
    igraph_matrix_destroy(&result);

    printf("One vertex:\n");
    igraph_small(&g, 1, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_random_3d(&g, &result) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_destroy(&g);
    igraph_matrix_destroy(&result);

    printf("10 vertices:\n");
    igraph_small(&g, 10, 0, 0,1, 0,1, 0,1, 2,2, 2,2, 2,2, 3,4, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_random_3d(&g, &result) == IGRAPH_SUCCESS);
    print_matrix(&result);
    igraph_destroy(&g);
    igraph_matrix_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_random_3d.out0000644000175100001710000000056700000000000027331 0ustar00runnerdocker00000000000000No vertices:
One vertex:
[ -0.25092 0.593086 0.901429 ]
10 vertices:
[ -0.63313 0.463988 0.559382
  0.197317   0.1937 -0.687963
  -0.108334 -0.688011 -0.80005
  -0.883833 -0.0815022 0.732352
  -0.332583  0.20223 -0.714266
  0.416145 0.301777 -0.958831
  -0.887177  0.93982 0.443998
  0.664885 0.877105 -0.575322
  -0.998442 -0.63635 0.984423
  -0.633191 0.234963 -0.391516 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_circular.c0000644000175100001710000001120100000000000032273 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void chop_print_destroy(igraph_matrix_t *result) {
    matrix_chop(result, 1e-10);
    print_matrix(result);
    igraph_matrix_destroy(result);
}

int main() {
    igraph_t g;
    igraph_matrix_t result;
    igraph_vector_t roots, rootlevel;

    printf("Empty graph check:\n");
    igraph_small(&g, 0, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_ALL, /*roots*/ NULL, /*rootlevel*/ NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);

    printf("Singleton graph check:\n");
    igraph_small(&g, 1, 0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_ALL, /*roots*/ NULL, /*rootlevel*/ NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);

    printf("Star graph check with given root:\n");
    igraph_small(&g, 5, 1, 0,1, 0,2, 0,3, 0,4, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init_int(&roots, 1, 1);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_OUT, &roots, /*rootlevel*/ NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);
    igraph_vector_destroy(&roots);

    printf("Star graph check with root found by topological sort:\n");
    igraph_small(&g, 5, 1, 1,0, 2,0, 3,0, 4,0, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_IN, NULL, /*rootlevel*/ NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);

    printf("Two minitrees without rootlevel:\n");
    igraph_small(&g, 6, 1, 0,1, 0,2, 3,4, 3,5, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init_int(&roots, 2, 0, 3);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_OUT, &roots, NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);
    igraph_vector_destroy(&roots);

    printf("Two minitrees with rootlevel 10 and 20:\n");
    igraph_small(&g, 6, 1, 0,1, 0,2, 3,4, 3,5, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init_int(&roots, 2, 0, 3);
    igraph_vector_init_int(&rootlevel, 2, 10, 20);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_OUT, &roots, &rootlevel) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);
    igraph_vector_destroy(&roots);
    igraph_vector_destroy(&rootlevel);

    printf("Graph with just loops, triple edges and disconnected vertices:\n");
    igraph_small(&g, 5, 1, 0,0, 0,0, 0,0, 1,2, 1,2, 1,2, -1);
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_ALL, NULL, /*rootlevel*/ NULL) == IGRAPH_SUCCESS);
    chop_print_destroy(&result);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking proper error handling:\n");
    printf("Giving negative root.\n");
    igraph_small(&g, 5, 1, 0,1, 0,2, 0,3, 0,4, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init_int(&roots, 1, -1);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_OUT, &roots, /*rootlevel*/ NULL) == IGRAPH_EINVVID);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);
    igraph_vector_destroy(&roots);

    printf("Giving negative rootlevel.\n");
    igraph_small(&g, 6, 1, 0,1, 0,2, 3,4, 3,5, -1);
    igraph_matrix_init(&result, 0, 0);
    igraph_vector_init_int(&roots, 2, 0, 3);
    igraph_vector_init_int(&rootlevel, 2, -10, -20);
    IGRAPH_ASSERT(igraph_layout_reingold_tilford_circular(&g, &result, IGRAPH_OUT, &roots, &rootlevel) == IGRAPH_EINVAL);
    igraph_matrix_destroy(&result);
    igraph_destroy(&g);
    igraph_vector_destroy(&roots);
    igraph_vector_destroy(&rootlevel);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_circular.out0000644000175100001710000000164600000000000032674 0ustar00runnerdocker00000000000000Empty graph check:
Singleton graph check:
[        0        0 ]
Star graph check with given root:
[        1        0
         0        0
  -0.104528 0.994522
  -0.978148 -0.207912
  0.309017 -0.951057 ]
Star graph check with root found by topological sort:
[        0        0
         1        0
  -0.104528 0.994522
  -0.978148 -0.207912
  0.309017 -0.951057 ]
Two minitrees without rootlevel:
[ 0.642788 0.766044
         2        0
  -0.347296  1.96962
  -0.34202 -0.939693
  -1.87939 -0.68404
         1 -1.73205 ]
Two minitrees with rootlevel 10 and 20:
[      5.5  9.52628
        12        0
        -6  10.3923
     -10.5 -18.1865
       -22        0
        11 -19.0526 ]
Graph with just loops, triple edges and disconnected vertices:
[        1        0
  -0.104528 0.994522
  -0.209057  1.98904
  -0.978148 -0.207912
  0.309017 -0.951057 ]
Checking proper error handling:
Giving negative root.
Giving negative rootlevel.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_reingold_tilford_extended.c0000644000175100001710000000275200000000000032302 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    FILE *f;
    igraph_matrix_t coords;
    /* long int i, n; */

    f = fopen("igraph_layout_reingold_tilford_extended.in", "r");
    igraph_read_graph_edgelist(&g, f, 0, 1);
    igraph_matrix_init(&coords, 0, 0);

    igraph_layout_reingold_tilford(&g, &coords, IGRAPH_IN, 0, 0);

    /*
    n=igraph_vcount(&g);
    for (i=0; i

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_t *g, igraph_integer_t center, igraph_vector_t *order, igraph_error_type_t error) {
    igraph_matrix_t result;
    igraph_matrix_init(&result, 0, 0);
    IGRAPH_ASSERT(igraph_layout_star(g, &result, center, order) == error);
    if (error == IGRAPH_SUCCESS) {
        matrix_chop(&result, 1e-13);
        print_matrix(&result);
    }

    igraph_matrix_destroy(&result);
    igraph_destroy(g);
    if(order) {
        igraph_vector_destroy(order);
    }

}

int main() {
    igraph_t g;
    igraph_vector_t order;

    printf("Star of 8 points and a center:\n");
    igraph_small(&g, 9, 0, -1);
    print_and_destroy(&g, 0, NULL, IGRAPH_SUCCESS);

    printf("Star of 8 points and a center in reverse:\n");
    igraph_small(&g, 9, 0, -1);
    igraph_vector_init_int(&order, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
    print_and_destroy(&g, 0, &order, IGRAPH_SUCCESS);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking if negative center fails nicely.\n");
    igraph_small(&g, 9, 0, -1);
    print_and_destroy(&g, -10, NULL, IGRAPH_EINVAL);

    printf("Checking if order out of range fails nicely.\n");
    igraph_small(&g, 9, 0, -1);
    igraph_vector_init_int(&order, 9, -1, -1, -1, 10, 10, 10, 2, 1, 0);
    print_and_destroy(&g, 0, &order, IGRAPH_EINVAL);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_star.out0000644000175100001710000000102400000000000026421 0ustar00runnerdocker00000000000000Star of 8 points and a center:
[        0        0
         1        0
  0.707107 0.707107
         0        1
  -0.707107 0.707107
        -1        0
  -0.707107 -0.707107
         0       -1
  0.707107 -0.707107 ]
Star of 8 points and a center in reverse:
[        0        0
  0.707107 -0.707107
         0       -1
  -0.707107 -0.707107
        -1        0
  -0.707107 0.707107
         0        1
  0.707107 0.707107
         1        0 ]
Checking if negative center fails nicely.
Checking if order out of range fails nicely.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_sugiyama.c0000644000175100001710000000673100000000000026714 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_t g, extd_g;
    igraph_matrix_t coords;
    igraph_vector_t edgelist, extd_edgelist, extd_to_orig_eids;
    igraph_vector_t layers;

    igraph_matrix_init(&coords, 0, 0);
    igraph_vector_init(&extd_to_orig_eids, 0);

    /* Layout on simple graph with predefined layers */
    igraph_vector_init_int_end(&layers, -1, 0, 1, 1, 2, 3, 3, 4, 4, 5, -1);
    igraph_vector_init_int_end(&edgelist, -1,
                               0, 1, 0, 2, 0, 3, 1, 2, 2, 2, 1, 4, 2, 5, 4, 6, 5, 7, 6, 8, 7, 8,
                               3, 8, 8, 1, 8, 2, -1);
    igraph_create(&g, &edgelist, 0, 1);

    igraph_layout_sugiyama(&g, &coords, 0, 0, &layers,
                           /* hgap = */ 1,
                           /* vgap = */ 1,
                           /* maxiter = */ 100,
                           /* weights = */ 0);
    igraph_matrix_print(&coords);
    printf("===\n");

    /* Same, but this time also return the extended graph */
    igraph_layout_sugiyama(&g, &coords, &extd_g, &extd_to_orig_eids, &layers,
                           /* hgap = */ 1,
                           /* vgap = */ 1,
                           /* maxiter = */ 100,
                           /* weights = */ 0);
    igraph_matrix_print(&coords);
    printf("===\n");
    igraph_vector_init(&extd_edgelist, 0);
    igraph_get_edgelist(&extd_g, &extd_edgelist, 0);
    igraph_vector_print(&extd_edgelist);
    igraph_vector_destroy(&extd_edgelist);
    igraph_destroy(&extd_g);
    printf("===\n");
    igraph_vector_print(&extd_to_orig_eids);
    printf("===\n");

    igraph_vector_destroy(&layers);

    /* Same, but with automatic layering */
    igraph_layout_sugiyama(&g, &coords, 0, 0, 0,
                           /* hgap = */ 1,
                           /* vgap = */ 1,
                           /* maxiter = */ 100,
                           /* weights = */ 0);
    igraph_matrix_print(&coords);
    printf("===\n");

    /* Layering with gaps in it */
    igraph_vector_init_int_end(&layers, -1, 0, 2, 2, 4, 6, 6, 12, 12, 15, -1);
    igraph_layout_sugiyama(&g, &coords, 0, 0, &layers,
                           /* hgap = */ 1,
                           /* vgap = */ 1,
                           /* maxiter = */ 100,
                           /* weights = */ 0);
    igraph_matrix_print(&coords);
    igraph_vector_destroy(&layers);
    printf("===\n");

    igraph_vector_destroy(&edgelist);
    igraph_matrix_destroy(&coords);
    igraph_vector_destroy(&extd_to_orig_eids);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_layout_sugiyama.out0000644000175100001710000000105000000000000027266 0ustar00runnerdocker000000000000002.5 0
0.5 1
2.5 1
4 2
0 3
2 3
0 4
2 4
2 5
4 1
0 2
2 2
4 3
4 4
1 2
1 3
1 4
3 2
3 3
3 4
===
2.5 0
0.5 1
2.5 1
4 2
0 3
2 3
0 4
2 4
2 5
4 1
0 2
2 2
4 3
4 4
1 2
1 3
1 4
3 2
3 3
3 4
===
0 1 0 2 0 9 9 3 1 2 1 10 10 4 2 2 2 11 11 5 3 12 12 13 13 8 4 6 5 7 6 8 7 8 8 16 16 15 15 14 14 1 8 19 19 18 18 17 17 2
===
0 1 2 2 3 5 5 4 6 6 11 11 11 7 8 9 10 12 12 12 12 13 13 13 13
===
2.5 0
1 1
2.5 2
4 1
0 2
2 3
0 3
2 4
2 5
2.5 1
4 2
4 3
4 4
0 4
1 2
1 3
1 4
3 3
3 4
===
2.5 0
0.5 2
2.5 2
4 4
0 6
2 6
0 12
2 12
2 15
4 2
0 4
2 4
4 6
4 12
1 4
1 6
1 12
3 4
3 6
3 12
===
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_le_community_to_membership.c0000644000175100001710000001006700000000000031116 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_vector_t *membership, igraph_vector_t *csize, igraph_matrix_t *mat) {
    printf("Membership: ");
    igraph_vector_print(membership);
    printf("Csize: ");
    igraph_vector_print(csize);
    printf("\n");
    igraph_vector_destroy(membership);
    igraph_matrix_destroy(mat);
}

int main() {
    igraph_matrix_t merges;
    igraph_vector_t membership;
    igraph_vector_t csize;

    igraph_vector_init_int(&csize, 0);

    printf("One member:\n");
    igraph_vector_init_int(&membership, 1, 0);
    igraph_matrix_init(&merges, 0, 2);
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 0, &membership, &csize) == IGRAPH_SUCCESS);
    print_and_destroy(&membership, &csize, &merges);

    printf("Five singleton clusters, one merge:\n");
    igraph_vector_init_int(&membership, 5, 0, 1, 2, 3, 4);
    {
        int elem[] = {1, 3};
        matrix_init_int_row_major(&merges, 1, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 1, &membership, &csize) == IGRAPH_SUCCESS);
    print_and_destroy(&membership, &csize, &merges);

    printf("Six clusters, two merges:\n");
    igraph_vector_init_int(&membership, 12, 0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5);
    {
        int elem[] = {0,3, 2,5};
        matrix_init_int_row_major(&merges, 2, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 2, &membership, &csize) == IGRAPH_SUCCESS);
    print_and_destroy(&membership, &csize, &merges);


    VERIFY_FINALLY_STACK();
    printf("These should fail nicely:\n");
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Five singleton clusters, two merges, but second merge refers to singleton which is already merged.\n");
    igraph_vector_init_int(&membership, 5, 0, 1, 2, 3, 4);
    {
        int elem[] = {1,3, 1,4,};
        matrix_init_int_row_major(&merges, 2, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 2, &membership, &csize) == IGRAPH_EINVAL);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);

    printf("Negative cluster index.\n");
    igraph_vector_init_int(&membership, 5, -1, 0, 1, 2, 3);
    {
        int elem[] = {1,2, 3,4,};
        matrix_init_int_row_major(&merges, 2, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 2, &membership, &csize) == IGRAPH_EINVAL);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);

    printf("Skip a cluster index.\n");
    igraph_vector_init_int(&membership, 5, 0, 0, 2, 3, 4);
    {
        int elem[] = {1,2, 3,4,};
        matrix_init_int_row_major(&merges, 2, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 2, &membership, &csize) == IGRAPH_EINVAL);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);

    printf("Too many steps.\n");
    igraph_vector_init_int(&membership, 5, 0, 1, 2, 3, 4);
    {
        int elem[] = {1,2, 3,4,};
        matrix_init_int_row_major(&merges, 2, 2, elem);
    }
    IGRAPH_ASSERT(igraph_le_community_to_membership(&merges, /*steps*/ 20, &membership, &csize) == IGRAPH_EINVAL);
    igraph_vector_destroy(&membership);
    igraph_matrix_destroy(&merges);

    igraph_vector_destroy(&csize);
    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_le_community_to_membership.out0000644000175100001710000000056700000000000031507 0ustar00runnerdocker00000000000000One member:
Membership: 0
Csize: 1

Five singleton clusters, one merge:
Membership: 1 0 2 0 3
Csize: 2 1 1 1

Six clusters, two merges:
Membership: 1 1 2 0 0 1 1 3 3 0 0 0
Csize: 5 4 1 2

These should fail nicely:
Five singleton clusters, two merges, but second merge refers to singleton which is already merged.
Negative cluster index.
Skip a cluster index.
Too many steps.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_linegraph.c0000644000175100001710000000467400000000000025455 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g_start, g_line, g_test;
    igraph_bool_t same;

    /*    Undirected    */
    igraph_small(&g_start, 7, IGRAPH_UNDIRECTED,
                 0, 1, 1, 2, 1, 3, 1, 3, 2, 2, 2, 4, 3, 4, 4, 5, -1);
    IGRAPH_ASSERT(igraph_linegraph(&g_start, &g_line) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 8, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 1, 4, 1, 4, 1, 5, 2, 3, 2, 3,
                 2, 6, 3, 6, 4, 5, 4, 5, 5, 6, 5, 7, 6, 7, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g_line, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g_start);
    igraph_destroy(&g_line);
    igraph_destroy(&g_test);

     /*    Directed    */
    igraph_small(&g_start, 7, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 1, 3, 3, 1, 2, 2, 2, 4, 3, 4, 4, 5, -1);
    IGRAPH_ASSERT(igraph_linegraph(&g_start, &g_line) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 8, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 4, 1, 5, 2, 3, 2, 6, 3, 1, 3, 2, 4, 4, 4, 5,
                 5, 7, 6, 7, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g_line, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g_start);
    igraph_destroy(&g_line);
    igraph_destroy(&g_test);

    /*    No edges    */
    igraph_small(&g_start, 7, IGRAPH_DIRECTED, -1);
    IGRAPH_ASSERT(igraph_linegraph(&g_start, &g_line) == IGRAPH_SUCCESS);
    igraph_small(&g_test, 0, IGRAPH_DIRECTED, -1);
    IGRAPH_ASSERT(igraph_is_same_graph(&g_line, &g_test, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);
    igraph_destroy(&g_start);
    igraph_destroy(&g_line);
    igraph_destroy(&g_test);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_list_triangles.c0000644000175100001710000000344300000000000026520 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph) {
    igraph_vector_int_t result;
    igraph_vector_int_init(&result, 0);
    IGRAPH_ASSERT(igraph_list_triangles(graph, &result) == IGRAPH_SUCCESS);
    print_vector_int(&result);
    IGRAPH_ASSERT(igraph_vector_int_size(&result) % 3 == 0);
    igraph_vector_int_destroy(&result);
    printf("\n");
}


int main() {
    igraph_t g_0, g_1, g_5_full, g_lm;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_full(&g_5_full, 5, 0, IGRAPH_NO_LOOPS);
    igraph_small(&g_lm, 6, 1, 0,1, 0,1, 0,2, 0,2, 1,1, 1,2, 1,2, 1,3, 2,0, 2,3, 3,4, 3,4, -1);


    printf("No vertices:\n");
    call_and_print(&g_0);

    printf("One vertex:\n");
    call_and_print(&g_1);

    printf("Full graph of 5 vertices:\n");
    call_and_print(&g_5_full);

    printf("Graph with loops and multiple edges:\n");
    call_and_print(&g_lm);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_5_full);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_list_triangles.out0000644000175100001710000000026400000000000027103 0ustar00runnerdocker00000000000000No vertices:
( )

One vertex:
( )

Full graph of 5 vertices:
( 0 1 4 0 1 2 0 1 3 0 2 4 0 2 3 0 3 4 1 2 4 1 2 3 1 3 4 2 3 4 )

Graph with loops and multiple edges:
( 1 2 0 1 2 3 )

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_local_scan_k_ecount.c0000644000175100001710000000647400000000000027471 0ustar00runnerdocker00000000000000/* IGraph library.  Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, int k, igraph_vector_t *weights, igraph_neimode_t mode) {
    igraph_vector_t result;
    igraph_vector_init(&result, 0);
    IGRAPH_ASSERT(igraph_local_scan_k_ecount(graph, k, &result, weights, mode) == IGRAPH_SUCCESS);
    print_vector(&result);
    igraph_vector_destroy(&result);
    printf("\n");
}


int main() {
    igraph_t g_0, g_1, g_lmu, g_lm, g_lm_nl;
    igraph_vector_t weights, result;

    igraph_vector_init_real(&weights, 8, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
    igraph_vector_init(&result, 0);
    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1); //undirected
    igraph_small(&g_lm_nl, 6, 1, 0,1, 0,2, 1,3, 2,0, 2,3, 3,4, 3,4, -1); // no loop

    printf("No vertices:\n");
    call_and_print(&g_0, 2, NULL, IGRAPH_ALL);

    printf("One vertex:\n");
    call_and_print(&g_1, 2, NULL, IGRAPH_ALL);

    printf("Directed disconnected graph with loops and multiple edges, no weights, k = 0, IGRAPH_IN:\n");
    call_and_print(&g_lm, 0, NULL, IGRAPH_IN);

    printf("Same graph, k=1:\n");
    call_and_print(&g_lm, 1, NULL, IGRAPH_IN);

    printf("Same graph, without loops, k=1:\n");
    call_and_print(&g_lm_nl, 1, NULL, IGRAPH_IN);

    printf("Same graph with loop, k=1, undirected:\n");
    call_and_print(&g_lmu, 1, NULL, IGRAPH_IN);

    printf("Checking if calling igraph_local_scan_1_ecount properly redirects:\n");
    igraph_vector_clear(&result);
    IGRAPH_ASSERT(igraph_local_scan_1_ecount(&g_lmu, &result, NULL, IGRAPH_IN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("Same graph, directed, k=2:\n");
    call_and_print(&g_lm, 2, NULL, IGRAPH_IN);

    printf("Same graph, undirected, k=2:\n");
    call_and_print(&g_lmu, 2, NULL, IGRAPH_IN);

    printf("Same graph, weighted:\n");
    call_and_print(&g_lmu, 2, &weights, IGRAPH_IN);

    VERIFY_FINALLY_STACK();

    printf("Wrong size weights.\n");
    igraph_vector_clear(&weights);
    CHECK_ERROR(igraph_local_scan_k_ecount(&g_lmu, 3, &result, &weights, IGRAPH_ALL), IGRAPH_EINVAL);

    printf("Negative k.\n");
    CHECK_ERROR(igraph_local_scan_k_ecount(&g_lmu, -3, &result, NULL, IGRAPH_ALL), IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_lmu);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lm_nl);
    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_local_scan_k_ecount.out0000644000175100001710000000102300000000000030037 0ustar00runnerdocker00000000000000No vertices:
( )

One vertex:
( 0 )

Directed disconnected graph with loops and multiple edges, no weights, k = 0, IGRAPH_IN:
( 1 2 1 2 2 0 )

Same graph, k=1:
( 2 2 2 3 2 0 )

Same graph, without loops, k=1:
( 2 1 2 2 2 0 )

Same graph with loop, k=1, undirected:
( 4 3 3 5 2 0 )

Checking if calling igraph_local_scan_1_ecount properly redirects:
( 4 3 3 5 2 0 )

Same graph, directed, k=2:
( 2 4 2 6 5 0 )

Same graph, undirected, k=2:
( 6 8 8 8 5 0 )

Same graph, weighted:
( 0.9 2 2 2 1.8 0 )

Wrong size weights.
Negative k.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_local_transitivity.c0000644000175100001710000002203300000000000027414 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

/* Compare the elements of two vectors for equality, handling NaN values. */
igraph_bool_t vector_equal(const igraph_vector_t *v1, const igraph_vector_t *v2) {
    long int n1 = igraph_vector_size(v1), n2 = igraph_vector_size(v2);
    long int i;

    if (n1 != n2) {
        return 0;
    }

    for (i=0; i < n1; ++i) {
        /* Since NaN == NaN compares false, we must handle NaN values early. */
        if (igraph_is_nan(VECTOR(*v1)[i]) && igraph_is_nan(VECTOR(*v2)[i])) {
            continue;
        }
        if (VECTOR(*v1)[i]  != VECTOR(*v2)[i]) {
            return 0;
        }
    }

    return 1;
}

/* Compute the average of a vector, ignoring NaN values. */
igraph_real_t vector_avg(const igraph_vector_t *v) {
    long int n = igraph_vector_size(v);
    long int i;
    igraph_real_t sum = 0.0, count;

    count = 0;
    for (i=0; i < n; ++i) {
        if (igraph_is_nan(VECTOR(*v)[i])) {
            continue;
        }
        sum += VECTOR(*v)[i];
        count += 1;
    }
    return sum / count;
}

int main() {

    igraph_t g;
    igraph_vector_t result1, result2, result3;
    igraph_vs_t vertices;
    igraph_real_t avg_local;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&result1, 0);
    igraph_vector_init(&result2, 0);

    /* igraph_transitivity_local_undirected() uses different code paths for:
     *  - all vertices
     *  - some vertices of graphs with >= 100 vertices
     *  - some vertices of graphs with < 100 vertices
     *
     * We test that these are consistent.
     */

    /* 100 vertices */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 100, 0.1,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    igraph_vs_seq(&vertices, 0, igraph_vcount(&g) - 1);

    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(),
                                         IGRAPH_TRANSITIVITY_NAN);
    igraph_transitivity_local_undirected(&g, &result2, vertices,
                                         IGRAPH_TRANSITIVITY_NAN);

    IGRAPH_ASSERT(vector_equal(&result1, &result2));

    igraph_vs_destroy(&vertices);
    igraph_destroy(&g);

    /* 50 vertices */

    igraph_erdos_renyi_game(&g, IGRAPH_ERDOS_RENYI_GNP, 50, 0.3,
                            IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    igraph_vs_seq(&vertices, 0, igraph_vcount(&g) - 1);

    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(),
                                         IGRAPH_TRANSITIVITY_NAN);
    igraph_transitivity_local_undirected(&g, &result2, vertices,
                                         IGRAPH_TRANSITIVITY_NAN);

    IGRAPH_ASSERT(vector_equal(&result1, &result2));

    igraph_vs_destroy(&vertices);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    /* Zachary karate club */

    printf("Zachary karate club network:\n");
    igraph_famous(&g, "Zachary");

    printf("IGRAPH_TRANSITIVITY_ZERO:\n");
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_ZERO);
    print_vector(&result1);

    printf("IGRAPH_TRANSITIVITY_NAN:\n");
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);

    igraph_destroy(&g);

    /* Small graphs */

    printf("\nNull graph:\n");
    igraph_empty(&g, 0, IGRAPH_UNDIRECTED);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_NAN);
    IGRAPH_ASSERT(igraph_is_nan(avg_local));
    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_ZERO);
    IGRAPH_ASSERT(avg_local == 0);
    igraph_destroy(&g);

    printf("\nSingleton graph:\n");
    igraph_empty(&g, 1, IGRAPH_UNDIRECTED);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_NAN);
    IGRAPH_ASSERT(igraph_is_nan(avg_local));
    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_ZERO);
    IGRAPH_ASSERT(avg_local == 0);
    igraph_destroy(&g);

    printf("\nTwo connected vertices:\n");
    igraph_small(&g, 2, IGRAPH_UNDIRECTED, 0,1, -1);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    igraph_destroy(&g);

    printf("\nTriangle:\n");
    igraph_full(&g, 3, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    igraph_destroy(&g);

    printf("\nTwo-star:\n");
    igraph_small(&g, 3, IGRAPH_UNDIRECTED, 0,2, 0,1, -1);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    igraph_destroy(&g);

    /* Multigraph */

    printf("\nDirected and multigraphs:\n");

    igraph_small(&g, 20, IGRAPH_DIRECTED,
                 15, 12, 12, 10, 15, 0, 11, 10, 2, 8, 8, 6, 13, 17, 10, 10, 17, 2, 14,
                 0, 16, 13, 14, 14, 0, 5, 6, 4, 0, 9, 0, 6, 10, 9, 16, 4, 14, 5, 17,
                 15, 14, 9, 17, 17, 1, 4, 10, 16, 7, 0, 11, 12, 6, 13, 2, 17, 4, 0, 0,
                 14, 4, 0, 6, 16, 16, 14, 13, 13, 12, 11, 3, 11, 11, 3, 6, 7, 4, 14,
                 10, 8, 13, 7, 14, 2, 5, 2, 0, 14, 3, 15, 5, 5, 7, 2, 14, 15, 5, 10,
                 10, 16, 7, 9, 14, 0, 15, 7, 13, 1, 15, 1, 4, 5, 4, 6, 16, 13, 6, 17,
                 8, 6, 9, 3, 8, 6, 6, 14, 11, 14, 6, 10, 10, 5, 1, 0, 16, 17, 9, 1, 5,
                 0, 5, 15, 8, 0, 0, 8, 5, 3, 9, 4, 13, 12, 11, 0, 11, 0, 10, 6, 4, 13,
                 8, 9, 11, 11, 3, 16, 1, 2, 16, 0, 9, 8, 3, 8, 8, 7, 12, 10, 9, 3, 13,
                 5, 3, 9, 6, 2, 11, 10, 1, 16, 0, 2, 10, 17, 16, 8, 11, 5, 13, 0, 19, 19,
                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                 -1);

    igraph_vs_seq(&vertices, 0, igraph_vcount(&g) - 1);

    printf("\nDirected multi:\n");
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);

    igraph_vector_copy(&result3, &result1);

    igraph_transitivity_local_undirected(&g, &result2, vertices, IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result2);
    IGRAPH_ASSERT(vector_equal(&result2, &result3));

    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_NAN);
    printf("Average: %.10g == %.10g == %.10g\n", avg_local, vector_avg(&result1), vector_avg(&result2));
    IGRAPH_ASSERT(fabs(avg_local - vector_avg(&result1)) < 1e-14);

    printf("\nUndirected multi:\n");
    igraph_to_undirected(&g, IGRAPH_TO_UNDIRECTED_COLLAPSE, NULL);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    IGRAPH_ASSERT(vector_equal(&result1, &result3));
    igraph_transitivity_local_undirected(&g, &result2, vertices, IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result2);
    IGRAPH_ASSERT(vector_equal(&result2, &result3));

    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_NAN);
    printf("Average: %.10g == %.10g == %.10g\n", avg_local, vector_avg(&result1), vector_avg(&result2));
    IGRAPH_ASSERT(fabs(avg_local - vector_avg(&result1)) < 1e-14);

    printf("\nUndirected simple:\n");
    igraph_simplify(&g, 1, 1, NULL);
    igraph_transitivity_local_undirected(&g, &result1, igraph_vss_all(), IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result1);
    IGRAPH_ASSERT(vector_equal(&result1, &result3));
    igraph_transitivity_local_undirected(&g, &result2, vertices, IGRAPH_TRANSITIVITY_NAN);
    print_vector(&result2);
    IGRAPH_ASSERT(vector_equal(&result2, &result3));

    igraph_transitivity_avglocal_undirected(&g, &avg_local, IGRAPH_TRANSITIVITY_NAN);
    printf("Average: %.10g == %.10g == %.10g\n", avg_local, vector_avg(&result1), vector_avg(&result2));
    IGRAPH_ASSERT(fabs(avg_local - vector_avg(&result1)) < 1e-14);

    igraph_vector_destroy(&result3);
    igraph_vector_destroy(&result2);
    igraph_vector_destroy(&result1);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_local_transitivity.out0000644000175100001710000000336700000000000030012 0ustar00runnerdocker00000000000000Zachary karate club network:
IGRAPH_TRANSITIVITY_ZERO:
( 0.15 0.333333 0.244444 0.666667 0.666667 0.5 0.5 1 0.5 0 0.666667 0 1 0.6 1 1 1 1 1 0.333333 1 1 1 0.4 0.333333 0.333333 1 0.166667 0.333333 0.666667 0.5 0.2 0.19697 0.110294 )
IGRAPH_TRANSITIVITY_NAN:
( 0.15 0.333333 0.244444 0.666667 0.666667 0.5 0.5 1 0.5 0 0.666667 NaN 1 0.6 1 1 1 1 1 0.333333 1 1 1 0.4 0.333333 0.333333 1 0.166667 0.333333 0.666667 0.5 0.2 0.19697 0.110294 )

Null graph:
( )

Singleton graph:
( NaN )

Two connected vertices:
( NaN NaN )

Triangle:
( 1 1 1 )

Two-star:
( 0 NaN NaN )

Directed and multigraphs:

Directed multi:
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
Average: 0.4126407543 == 0.4126407543 == 0.4126407543

Undirected multi:
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
Average: 0.4126407543 == 0.4126407543 == 0.4126407543

Undirected simple:
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
( 0.474359 0.47619 0.428571 0.266667 0.642857 0.388889 0.533333 0.52381 0.535714 0.357143 0.285714 0.4 0.166667 0.416667 0.472222 0.214286 0.444444 0.4 NaN NaN )
Average: 0.4126407543 == 0.4126407543 == 0.4126407543
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques2.c0000644000175100001710000000551000000000000026731 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void sort_cliques(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_sort(v);
    }
    igraph_vector_ptr_sort(cliques, igraph_vector_lex_cmp);
}

int print_and_destroy(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    sort_cliques(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
    }
    igraph_vector_ptr_destroy_all(cliques);
    return 0;
}

int main() {
    igraph_t graph;
    igraph_vector_ptr_t cliques;
    igraph_integer_t no;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_ring(&graph, /*n=*/ 10, /*directed=*/ 0,
                /*mutual=*/ 0, /*circular=*/ 1);
    igraph_vector_ptr_init(&cliques, 0);

    igraph_maximal_cliques(&graph, &cliques, /*min_size=*/ 0,
                           /*max_size=*/ 0);
    igraph_maximal_cliques_count(&graph, &no, /*min_size=*/ 0,
                                 /*max_size=*/ 0 /*no limit*/);
    IGRAPH_ASSERT(no == igraph_vector_ptr_size(&cliques));

    print_and_destroy(&cliques);
    igraph_destroy(&graph);

    printf("---\n");
    /* ----------------------------------------------------------- */

    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNP,
                            /*n=*/ 50, /*p=*/ 0.5, /*directed=*/ 0,
                            /*loops=*/ 0);

    igraph_vector_ptr_init(&cliques, 0);

    igraph_maximal_cliques(&graph, &cliques, /*min_size=*/ 8,
                           /*max_size=*/ 0);
    igraph_maximal_cliques_count(&graph, &no, /*min_size=*/ 8,
                                 /*max_size=*/ 0 /*no limit*/);
    IGRAPH_ASSERT(no == igraph_vector_ptr_size(&cliques));

    print_and_destroy(&cliques);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques2.out0000644000175100001710000000010200000000000027306 0ustar00runnerdocker000000000000000 1
0 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
---
0 7 10 11 13 24 34 42
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques3.c0000644000175100001710000000404700000000000026736 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void sort_cliques(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_sort(v);
    }
    igraph_vector_ptr_sort(cliques, igraph_vector_lex_cmp);
}

int print_and_destroy(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    sort_cliques(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
    }
    igraph_vector_ptr_destroy_all(cliques);
    return 0;
}

int main() {
    igraph_t graph;
    igraph_vector_ptr_t cliques;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNP,
                            /*n=*/ 100, /*p=*/ 0.7, /*directed=*/ 0,
                            /*loops=*/ 0);

    igraph_vector_ptr_init(&cliques, 0);

    igraph_maximal_cliques(&graph, &cliques, /*min_size=*/ 15,
                           /*max_size=*/ 0);

    print_and_destroy(&cliques);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques3.out0000644000175100001710000000225700000000000027324 0ustar00runnerdocker000000000000000 6 17 19 25 30 33 35 40 73 74 79 90 92 97
0 6 17 19 25 30 33 35 47 73 74 79 90 92 97
0 11 12 17 19 30 33 35 47 53 62 79 91 92 97
0 17 19 25 30 33 35 47 73 74 79 90 91 92 97
1 3 6 17 25 28 37 40 49 50 69 74 85 86 97
1 3 6 17 25 28 37 40 49 50 73 74 85 86 97
1 3 6 17 25 28 37 40 50 54 69 74 85 86 97
1 3 6 17 25 28 37 40 50 54 73 74 85 86 97
1 3 6 17 25 37 40 49 50 69 74 85 86 90 97
1 3 6 17 25 37 40 49 50 73 74 85 86 90 97
1 3 6 17 25 37 40 50 69 74 85 86 90 95 97
1 3 6 17 25 37 40 50 73 74 85 86 90 95 97
1 3 17 25 28 37 40 49 50 69 74 85 86 97 98
1 3 17 25 28 37 40 49 50 73 74 85 86 97 98
1 3 17 25 28 37 40 50 54 69 74 85 86 97 98
1 3 17 25 28 37 40 50 54 73 74 85 86 97 98
1 6 17 25 28 37 40 49 50 61 69 74 85 86 97
1 6 17 25 28 37 40 49 50 61 73 74 85 86 97
1 6 17 25 28 37 40 50 54 61 69 74 85 86 97
1 6 17 25 28 37 40 50 54 61 73 74 85 86 97
1 6 17 25 37 40 49 50 61 69 74 85 86 90 97
1 6 17 25 37 40 49 50 61 73 74 85 86 90 97
1 6 17 25 37 40 50 61 69 74 85 86 90 95 97
1 6 17 25 37 40 50 61 73 74 85 86 90 95 97
1 9 16 25 28 54 57 58 67 78 85 86 87 97 99
1 9 16 25 28 54 57 58 67 85 86 87 97 98 99
1 9 25 28 54 57 58 67 69 85 86 87 97 98 99
8 15 28 39 43 48 55 56 59 61 62 63 76 78 84
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques4.c0000644000175100001710000000575700000000000026750 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2013  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void sort_cliques(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_sort(v);
    }
    igraph_vector_ptr_sort(cliques, igraph_vector_lex_cmp);
}

int print_and_destroy(igraph_vector_ptr_t *cliques) {
    int i, n = igraph_vector_ptr_size(cliques);
    sort_cliques(cliques);
    for (i = 0; i < n; i++) {
        igraph_vector_t *v = VECTOR(*cliques)[i];
        igraph_vector_print(v);
        igraph_vector_destroy(v);
    }
    igraph_vector_ptr_destroy_all(cliques);
    return 0;
}

int main() {
    igraph_t graph;
    igraph_vector_ptr_t cliques, cl1, cl2;
    igraph_vector_int_t v1, v2;
    igraph_integer_t n, n1, n2;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNP,
                            /*n=*/ 100, /*p=*/ 0.5, /*directed=*/ 0,
                            /*loops=*/ 0);

    igraph_vector_ptr_init(&cliques, 0);

    igraph_maximal_cliques_subset(&graph, /*subset=*/ 0,
                                  &cliques, &n, /*outfile=*/ 0,
                                  /*min_size=*/ 9, /*max_size=*/ 0);

    igraph_vector_int_init_seq(&v1,  0, 12);
    igraph_vector_int_init_seq(&v2, 13, 99);
    igraph_vector_ptr_init(&cl1, 0);
    igraph_vector_ptr_init(&cl2, 0);
    igraph_maximal_cliques_subset(&graph, &v1, &cl1, &n1, /*outfile=*/ 0,
                                  /*min_size=*/ 9, /*max_size=*/ 0);
    igraph_maximal_cliques_subset(&graph, &v2, &cl2, &n2, /*outfile=*/ 0,
                                  /*min_size=*/ 9, /*max_size=*/ 0);

    igraph_vector_int_destroy(&v1);
    igraph_vector_int_destroy(&v2);

    if (n1 + n2 != n) {
        return 1;
    }
    if (n1 != igraph_vector_ptr_size(&cl1)) {
        return 2;
    }
    if (n2 != igraph_vector_ptr_size(&cl2)) {
        return 3;
    }

    print_and_destroy(&cliques);
    printf("---\n");
    print_and_destroy(&cl1);
    printf("+\n");
    print_and_destroy(&cl2);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques4.out0000644000175100001710000000135000000000000027316 0ustar00runnerdocker000000000000000 10 11 13 24 34 42 79 97
0 11 13 24 34 42 58 64 97
2 5 7 34 42 64 67 78 92
4 24 30 31 47 52 60 87 95
4 24 30 47 52 60 84 87 95
6 11 13 26 35 38 54 62 79
6 11 13 60 66 73 81 82 84
11 13 16 34 45 58 64 67 82
13 29 33 49 50 62 63 66 96
13 29 33 50 62 63 66 86 96
24 30 31 47 52 60 69 87 95
24 30 31 52 60 69 79 87 95
24 30 31 52 60 69 79 88 95
24 31 32 52 60 69 79 88 95
---
0 10 11 13 24 34 42 79 97
0 11 13 24 34 42 58 64 97
2 5 7 34 42 64 67 78 92
4 24 30 31 47 52 60 87 95
4 24 30 47 52 60 84 87 95
6 11 13 26 35 38 54 62 79
6 11 13 60 66 73 81 82 84
11 13 16 34 45 58 64 67 82
13 29 33 49 50 62 63 66 96
13 29 33 50 62 63 66 86 96
+
24 30 31 47 52 60 69 87 95
24 30 31 52 60 69 79 87 95
24 30 31 52 60 69 79 88 95
24 31 32 52 60 69 79 88 95
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques_file.c0000644000175100001710000000327000000000000027647 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g_empty, g_lm;

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,2, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_maximal_cliques_file(&g_empty, stdout, /*min*/ 0, /*max*/ 0) == IGRAPH_SUCCESS);

    printf("\nGraph with loops and multiple edges:\n");
    IGRAPH_ASSERT(igraph_maximal_cliques_file(&g_lm, stdout, /*min*/ 0, /*max*/ 0) == IGRAPH_SUCCESS);

    printf("\nGraph with loops and multiple edges, minimum clique size 10:\n");
    IGRAPH_ASSERT(igraph_maximal_cliques_file(&g_lm, stdout, /*min*/ 10, /*max*/ 0) == IGRAPH_SUCCESS);

    printf("\nGraph with loops and multiple edges, maximum clique size 2:\n");
    IGRAPH_ASSERT(igraph_maximal_cliques_file(&g_lm, stdout, /*min*/ 0, /*max*/ 2) == IGRAPH_SUCCESS);

    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_maximal_cliques_file.out0000644000175100001710000000030600000000000030231 0ustar00runnerdocker00000000000000No vertices:

Graph with loops and multiple edges:
5
3 4
3 1 2
0 1 2

Graph with loops and multiple edges, minimum clique size 10:

Graph with loops and multiple edges, maximum clique size 2:
5
3 4
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_modularity.c0000644000175100001710000001124300000000000025663 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_t weights;
    igraph_vector_t membership;
    igraph_real_t modularity, resolution;
    igraph_attribute_combination_t comb;

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_attribute_combination(&comb,
                                 "weight", IGRAPH_ATTRIBUTE_COMBINE_SUM,
                                 IGRAPH_NO_MORE_ATTRIBUTES);

    /* Set default seed to get reproducible results */
    igraph_rng_seed(igraph_rng_default(), 0);

    /* Null graph */
    igraph_vector_init(&membership, 0);
    igraph_small(&graph, 0, IGRAPH_UNDIRECTED, -1);
    igraph_modularity(&graph, &membership, 0, /* resolution */ 1, /* directed */ 0, &modularity);
    if (!igraph_is_nan(modularity)) {
        return 1;
    }
    igraph_destroy(&graph);
    igraph_small(&graph, 0, IGRAPH_DIRECTED, -1);
    igraph_modularity(&graph, &membership, 0, /* resolution */ 1, /* directed */ 0, &modularity);
    if (!igraph_is_nan(modularity)) {
        return 1;
    }
    /* Should not crash if we omit 'modularity' */
    igraph_modularity(&graph, &membership, 0, /* resolution */ 1, /* directed */ 0, /* modularity = */ 0);
    igraph_destroy(&graph);
    igraph_vector_destroy(&membership);

    /* Simple unweighted graph */
    igraph_small(&graph, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9,
                 0, 5, -1);

    /* Set weights */
    igraph_vector_init(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1.0);
    SETEANV(&graph, "weight", &weights);

    /* Set membership */
    igraph_vector_init(&membership, igraph_vcount(&graph));
    VECTOR(membership)[0] = 0;
    VECTOR(membership)[1] = 0;
    VECTOR(membership)[2] = 0;
    VECTOR(membership)[3] = 0;
    VECTOR(membership)[4] = 0;
    VECTOR(membership)[5] = 1;
    VECTOR(membership)[6] = 1;
    VECTOR(membership)[7] = 1;
    VECTOR(membership)[8] = 1;
    VECTOR(membership)[9] = 1;

    /* Calculate modularity */
    for (resolution = 0.5; resolution <= 1.5; resolution += 0.5)
    {
        igraph_modularity(&graph, &membership, &weights,
                        /* resolution */ resolution,
                        /* directed */ 1, &modularity);
        printf("Modularity (resolution %.2f) is %f.\n", resolution, modularity);
    }

    igraph_to_directed(&graph, IGRAPH_TO_DIRECTED_MUTUAL);
    igraph_vector_resize(&weights, igraph_ecount(&graph));
    igraph_vector_fill(&weights, 1.0);
    for (resolution = 0.5; resolution <= 1.5; resolution += 0.5)
    {
        igraph_modularity(&graph, &membership, &weights,
                        /* resolution */ resolution,
                        /* directed */ 1, &modularity);
        printf("Modularity (resolution %.2f) is %f on directed graph.\n", resolution, modularity);
    }

    /* Recalculate modularity on contracted graph */
    igraph_contract_vertices(&graph, &membership, NULL);
    igraph_vector_destroy(&membership);

    igraph_simplify(&graph, /* multiple */ 1, /* loops */ 0, &comb);

    igraph_vector_init_seq(&membership, 0, igraph_vcount(&graph) - 1);
    EANV(&graph, "weight", &weights);
    for (resolution = 0.5; resolution <= 1.5; resolution += 0.5)
    {
        igraph_modularity(&graph, &membership, &weights,
                        /* resolution */ resolution,
                        /* directed */ 1, &modularity);
        printf("Modularity (resolution %.2f) is %f after aggregation.\n", resolution, modularity);
    }

    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&weights);
    igraph_destroy(&graph);
    igraph_attribute_combination_destroy(&comb);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_modularity.out0000644000175100001710000000074600000000000026256 0ustar00runnerdocker00000000000000Modularity (resolution 0.50) is 0.702381.
Modularity (resolution 1.00) is 0.452381.
Modularity (resolution 1.50) is 0.202381.
Modularity (resolution 0.50) is 0.702381 on directed graph.
Modularity (resolution 1.00) is 0.452381 on directed graph.
Modularity (resolution 1.50) is 0.202381 on directed graph.
Modularity (resolution 0.50) is 0.702381 after aggregation.
Modularity (resolution 1.00) is 0.452381 after aggregation.
Modularity (resolution 1.50) is 0.202381 after aggregation.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_modularity_matrix.c0000644000175100001710000001154600000000000027255 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void test_print_destroy(igraph_t *g, igraph_vector_t *weights, float resolution, igraph_matrix_t *modmat, igraph_bool_t directed) {
    int i, j;
    IGRAPH_ASSERT(igraph_modularity_matrix(g, weights, resolution, modmat, directed) == IGRAPH_SUCCESS);
    for (i = 0; i < igraph_matrix_nrow(modmat); i++) {
        for (j = 0; j < igraph_matrix_ncol(modmat); j++) {
            if (fabs(MATRIX(*modmat, i, j)) < 1e-10) {
                MATRIX(*modmat, i, j) = 0;
            }
        }
    }
    print_matrix(modmat);
    igraph_destroy(g);
    igraph_matrix_destroy(modmat);
    if (weights) {
        igraph_vector_destroy(weights);
    }
}

int main() {
    igraph_t g;
    igraph_vector_t weights, membership;
    igraph_matrix_t modmat;
    igraph_real_t modularity, test_modularity;
    int i, j;

    printf("No vertices:\n");
    igraph_small(&g, 0, /*directed*/0, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 1.0, &modmat, 0);

    printf("No edges:\n");
    igraph_small(&g, 3, /*directed*/0, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 1.0, &modmat, 0);

    printf("Triangle with no resolution should give the adjacency matrix:\n");
    igraph_small(&g, 3, /*directed*/0, 0,1, 0,2, 1,2, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 0.0, &modmat, 0);

    printf("Triangle and point with self-loop, undirected :\n");
    igraph_small(&g, 4, /*directed*/0, 0,1, 0,2, 1,2, 3,3, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 1.0, &modmat, 0);

    printf("Triangle and point with self-loop, directed, but direction ignored:\n");
    igraph_small(&g, 4, /*directed*/1, 0,1, 0,2, 1,2, 3,3, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 1.0, &modmat, 0);

    printf("Triangle and point with self-loop, directed:\n");
    igraph_small(&g, 4, /*directed*/1, 0,1, 0,2, 1,2, 3,3, -1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, NULL, 1.0, &modmat, 1);

    printf("Triangle with weights 0, 1, 2:\n");
    igraph_small(&g, 3, /*directed*/0, 0,1, 0,2, 1,2, -1);
    igraph_vector_init_int(&weights, 3, 0, 1, 2);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, &weights, 1.0, &modmat, 0);

    printf("Triangle with weights 0, -1, -2:\n");
    igraph_small(&g, 3, /*directed*/0, 0,1, 0,2, 1,2, -1);
    igraph_vector_init_int(&weights, 3, 0, -1, -2);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, &weights, 1.0, &modmat, 0);

    printf("Directed triangle with weights 0, 1, 2:\n");
    igraph_small(&g, 3, /*directed*/1, 0,1, 0,2, 1,2, -1);
    igraph_vector_init_int(&weights, 3, 0, 1, 2);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, &weights, 1.0, &modmat, 1);

    printf("Triangle with weights -1, 0, 1 will cause divisions by zero:\n");
    igraph_small(&g, 3, /*directed*/0, 0,1, 0,2, 1,2, -1);
    igraph_vector_init_int(&weights, 3, -1, 0, 1);
    igraph_matrix_init(&modmat, 0, 0);
    test_print_destroy(&g, &weights, 1.0, &modmat, 0);

    printf("Comparison with modularity:\n");
    igraph_small(&g, 5, /*directed*/1, 0,1, 0,2, 1,2, 3,4, 4,0, -1);
    igraph_vector_init_int(&weights, 5, 1, 2, 3, 4, 5);
    igraph_vector_init_int(&membership, 5, 0, 0, 0, 1, 1);
    igraph_matrix_init(&modmat, 0, 0);
    IGRAPH_ASSERT(igraph_modularity_matrix(&g, &weights, 0.7, &modmat, 1) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_modularity(&g, &membership, &weights, 0.7, 1, &modularity) == IGRAPH_SUCCESS);
    print_matrix(&modmat);
    test_modularity = 0;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            test_modularity += MATRIX(modmat, i, j);
        }
    }
    for (i = 3; i < 5; i++) {
        for (j = 3; j < 5; j++) {
            test_modularity += MATRIX(modmat, i, j);
        }
    }
    printf("Modularity: %g, modularity via matrix: %g\n", modularity, test_modularity / igraph_vector_sum(&weights));
    igraph_destroy(&g);
    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&weights);
    igraph_matrix_destroy(&modmat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_modularity_matrix.out0000644000175100001710000000330700000000000027636 0ustar00runnerdocker00000000000000No vertices:
No edges:
[      NaN      NaN      NaN
       NaN      NaN      NaN
       NaN      NaN      NaN ]
Triangle with no resolution should give the adjacency matrix:
[        0        1        1
         1        0        1
         1        1        0 ]
Triangle and point with self-loop, undirected :
[     -0.5      0.5      0.5     -0.5
       0.5     -0.5      0.5     -0.5
       0.5      0.5     -0.5     -0.5
      -0.5     -0.5     -0.5      1.5 ]
Triangle and point with self-loop, directed, but direction ignored:
[     -0.5      0.5      0.5     -0.5
       0.5     -0.5      0.5     -0.5
       0.5      0.5     -0.5     -0.5
      -0.5     -0.5     -0.5      1.5 ]
Triangle and point with self-loop, directed:
[        0      0.5        0     -0.5
         0    -0.25      0.5    -0.25
         0        0        0        0
         0    -0.25     -0.5     0.75 ]
Triangle with weights 0, 1, 2:
[ -0.166667 -0.333333      0.5
  -0.333333 -0.666667        1
       0.5        1     -1.5 ]
Triangle with weights 0, -1, -2:
[ 0.166667 0.333333     -0.5
  0.333333 0.666667       -1
      -0.5       -1      1.5 ]
Directed triangle with weights 0, 1, 2:
[        0        0        0
         0        0        0
         0        0        0 ]
Triangle with weights -1, 0, 1 will cause divisions by zero:
[     -Inf      NaN      Inf
       NaN      NaN      NaN
       Inf      NaN     -Inf ]
Comparison with modularity:
[     -0.7     0.86      1.3        0    -0.56
      -0.7    -0.14      2.3        0    -0.56
         0        0        0        0        0
  -0.933333 -0.186667 -0.933333        0  3.25333
   3.83333 -0.233333 -1.16667        0 -0.933333 ]
Modularity: 0.349333, modularity via matrix: 0.349333
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_moran_process.c0000644000175100001710000002074300000000000026351 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
  Test suite for the Moran process in a network setting.
  Copyright (C) 2011 Minh Van Nguyen 

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA
*/

#include 
#include 

#include "test_utilities.inc"

/* test parameters structure */
typedef struct {
    igraph_t *graph;
    igraph_vector_t *weights;
    igraph_vector_t *quantities;
    igraph_vector_t *strategies;
    igraph_neimode_t mode;
    int retval;
} strategy_test_t;

/* Error tests, i.e. we expect errors to be raised for each test.
 */
int error_tests() {
    igraph_t g, gzero, h;
    igraph_vector_t quant, quantnvert, quantzero;
    igraph_vector_t strat, stratnvert, stratzero;
    igraph_vector_t wgt, wgtnedge, wgtzero;
    int i, n, nvert, ret;
    strategy_test_t *test;

    igraph_empty(&h, 0, 0);  /* empty graph */
    /* nonempty graph */
    igraph_small(&g, /* n= */ 0, IGRAPH_UNDIRECTED, 0, 1, 1, 2, 2, 0, -1);
    nvert = igraph_vcount(&g);
    /* weights vectors */
    igraph_vector_init(&wgt, 0);
    igraph_vector_init(&wgtnedge, igraph_ecount(&g));
    /* quantities vectors */
    igraph_vector_init(&quant, 1);
    igraph_vector_init_real(&quantnvert, nvert, 0.1, 0.2, 0.3);
    /* strategies vectors */
    igraph_vector_init(&strat, 2);
    igraph_vector_init_real(&stratnvert, nvert, 0.0, 1.0, 2.0);

    igraph_small(&gzero, /* n= */ 0, IGRAPH_UNDIRECTED,
                 0, 3, 0, 4, 1, 2, 1, 4, 1, 5, 2, 3, 2, 4, 3, 4, -1);
    nvert = igraph_vcount(&gzero);
    igraph_vector_init(&quantzero, nvert);                /* vector of zeros */
    igraph_vector_init(&stratzero, nvert);                /* vector of zeros */
    igraph_vector_init(&wgtzero, igraph_ecount(&gzero));  /* vector of zeros */
    /* igraph_vector_init_real(&stratzero, nvert, 1.0, 0.0, 1.0, 2.0, 0.0, 3.0); */

    /* test parameters */
    /*------graph--weights--quantities--strategies--mode--retval------*/
    /* null pointer for graph */
    strategy_test_t null_graph = {NULL, NULL, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for weights vector */
    strategy_test_t null_wgt = {&g, NULL, &quantnvert, &stratnvert, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for quantities vector */
    strategy_test_t null_quant = {&g, &wgt, NULL, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* null pointer for strategies vector */
    strategy_test_t null_strat = {&g, &wgt, &quant, NULL, IGRAPH_ALL, IGRAPH_EINVAL};
    /* empty graph */
    strategy_test_t empty_graph = {&h, &wgt, &quant, &strat, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of quantities vector different from number of vertices */
    strategy_test_t qdiff_length = {&g, &wgtnedge, &quant, &strat, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of strategies vector different from number of vertices */
    strategy_test_t sdiff_length = {&g, &wgtnedge, &quantnvert, &strat, IGRAPH_ALL, IGRAPH_EINVAL};
    /* length of weights vector different from number of edges */
    strategy_test_t wdiff_length = {&g, &wgt, &quantnvert, &stratnvert, IGRAPH_ALL, IGRAPH_EINVAL};
    /* weights vector contains all zeros */
    strategy_test_t zero_wgt = {&g, &wgtnedge, &quantnvert, &stratnvert, IGRAPH_ALL, IGRAPH_EINVAL};
    /* quantities vector contains all zeros */
    strategy_test_t zero_quant = {&gzero, &wgtzero, &quantzero, &stratzero, IGRAPH_ALL, IGRAPH_EINVAL};
    strategy_test_t *all_checks[] = {/* 1 */  &null_graph,
                                              /* 2 */  &null_quant,
                                              /* 3 */  &null_strat,
                                              /* 4 */  &null_wgt,
                                              /* 5 */  &empty_graph,
                                              /* 6 */  &qdiff_length,
                                              /* 7 */  &sdiff_length,
                                              /* 8 */  &wdiff_length,
                                              /* 9 */  &zero_quant,
                                              /* 10 */ &zero_wgt
                                    };

    /* Run the error tests. We expect error to be raised for each test. */
    igraph_set_error_handler(igraph_error_handler_ignore);
    n = 10;
    i = 0;
    while (i < n) {
        test = all_checks[i];
        ret = igraph_moran_process(test->graph, test->weights, test->quantities,
                                   test->strategies, test->mode);
        if (ret != test->retval) {
            printf("Error test no. %d failed.\n", (int)(i + 1));
            return IGRAPH_FAILURE;
        }
        i++;
    }
    /* clean up */
    igraph_destroy(&g);
    igraph_destroy(&gzero);
    igraph_destroy(&h);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&quantnvert);
    igraph_vector_destroy(&quantzero);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&stratnvert);
    igraph_vector_destroy(&stratzero);
    igraph_vector_destroy(&wgt);
    igraph_vector_destroy(&wgtnedge);
    igraph_vector_destroy(&wgtzero);

    return IGRAPH_SUCCESS;
}

/* One iteration of the Moran process on a simple digraph.
 */
int moran_one_test() {
    igraph_t g;
    igraph_integer_t u = -1;  /* vertex chosen for reproduction */
    igraph_integer_t v = -1;  /* clone of u */
    igraph_integer_t nedge, nvert;
    igraph_real_t q = 0.0;
    igraph_vector_t quant, quantcp;
    igraph_vector_t strat, stratcp;
    igraph_vector_t wgt;
    long int i;

    /* graph representing the game network; quantities and strategies vectors */
    igraph_small(&g, /*nvert*/ 0, IGRAPH_DIRECTED,
                 0, 1, 0, 4, 1, 2, 1, 4, 2, 1, 3, 2, 4, 0, 4, 3, -1);
    nvert = igraph_vcount(&g);
    nedge = igraph_ecount(&g);
    igraph_vector_init_real(&quant, nvert, 0.77, 0.83, 0.64, 0.81, 0.05);
    igraph_vector_init_real(&strat, nvert, 2.0, 0.0, 0.0, 1.0, 2.0);
    /* Set the edge weights. Here we assume the following correspondence */
    /* between edge IDs and directed edges: */
    /* edge 0: 0 -> 1 */
    /* edge 1: 0 -> 4 */
    /* edge 2: 1 -> 2 */
    /* edge 3: 1 -> 4 */
    /* edge 4: 2 -> 1 */
    /* edge 5: 3 -> 2 */
    /* edge 6: 4 -> 0 */
    /* edge 7: 4 -> 3 */
    igraph_vector_init_real(&wgt, nedge, 1.9, 0.8, 6.2, 2.4, 1.1, 5.2, 7.3, 8.8);

    /* play game */
    igraph_vector_copy(&quantcp, &quant);
    igraph_vector_copy(&stratcp, &strat);
    igraph_moran_process(&g, &wgt, &quantcp, &stratcp, IGRAPH_OUT);

    /* Determine which vertex was chosen for death. The original quantities */
    /* vector contain unique values, i.e. no duplicates. Thus we compare the */
    /* updated quantities with the original one. */
    for (i = 0; i < igraph_vector_size(&quant); i++) {
        if (VECTOR(quant)[i] != VECTOR(quantcp)[i]) {
            /* found the new clone vertex */
            v = (igraph_integer_t)i;
            q = (igraph_real_t)VECTOR(quantcp)[i];
            break;
        }
    }
    IGRAPH_ASSERT(v >= 0);
    IGRAPH_ASSERT(q != 0.0);

    /* Now we know that v is a clone of some vertex. Determine the vertex that */
    /* v is a clone of. */
    for (i = 0; i < igraph_vector_size(&quant); i++) {
        if (VECTOR(quant)[i] == q) {
            /* found the vertex chosen for reproduction */
            u = (igraph_integer_t)i;
            break;
        }
    }
    IGRAPH_ASSERT(u >= 0);

    /* check that v is indeed a clone of u */
    if (VECTOR(quant)[u] != VECTOR(quantcp)[v]) {
        return IGRAPH_FAILURE;
    }
    if (VECTOR(strat)[u] != VECTOR(stratcp)[v]) {
        return IGRAPH_FAILURE;
    }

    igraph_destroy(&g);
    igraph_vector_destroy(&quant);
    igraph_vector_destroy(&quantcp);
    igraph_vector_destroy(&strat);
    igraph_vector_destroy(&stratcp);
    igraph_vector_destroy(&wgt);

    return IGRAPH_SUCCESS;
}

int main() {

    igraph_rng_seed(igraph_rng_default(), 1298);

    IGRAPH_ASSERT(error_tests() == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(moran_one_test() == IGRAPH_SUCCESS);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu.c0000644000175100001710000000450200000000000026514 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

igraph_bool_t print_motif(const igraph_t *graph, igraph_vector_t *vids,
                          int isoclass, void* extra) {
    printf("Class %d: ", isoclass);
    print_vector(vids);
    return 0;
}

int main() {

    igraph_t g;
    igraph_vector_t hist;
    igraph_real_t zeros[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
    igraph_vector_t cut_prob;
    igraph_integer_t size;

    igraph_ring(&g, 1000, IGRAPH_DIRECTED, 1, 1);
    igraph_vector_init(&hist, 0);
    igraph_motifs_randesu(&g, &hist, 3, igraph_vector_view(&cut_prob, zeros, 3));
    print_vector(&hist);
    igraph_destroy(&g);
    igraph_vector_destroy(&hist);

    igraph_famous(&g, "Octahedral");
    size = 3;
    printf("Motif size: %" IGRAPH_PRId "\n", size);
    igraph_motifs_randesu_callback(&g, size, igraph_vector_view(&cut_prob, zeros, size), &print_motif, NULL);
    size = 4;
    printf("Motif size: %" IGRAPH_PRId "\n", size);
    igraph_motifs_randesu_callback(&g, size, igraph_vector_view(&cut_prob, zeros, size), &print_motif, NULL);
    size = 5;
    printf("Motif size: %" IGRAPH_PRId "\n", size);
    igraph_motifs_randesu_callback(&g, size, igraph_vector_view(&cut_prob, zeros, size), &print_motif, NULL);
    size = 6;
    printf("Motif size: %" IGRAPH_PRId "\n", size);
    igraph_motifs_randesu_callback(&g, size, igraph_vector_view(&cut_prob, zeros, size), &print_motif, NULL);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu.out0000644000175100001710000000170700000000000027105 0ustar00runnerdocker00000000000000( NaN NaN 0 NaN 0 0 0 0 0 0 1000 0 0 0 0 0 )
Motif size: 3
Class 2: ( 0 5 1 )
Class 3: ( 0 5 2 )
Class 3: ( 0 5 3 )
Class 2: ( 0 5 4 )
Class 3: ( 0 3 1 )
Class 2: ( 0 3 2 )
Class 2: ( 0 3 4 )
Class 3: ( 0 2 1 )
Class 2: ( 0 2 4 )
Class 2: ( 0 1 4 )
Class 3: ( 1 4 2 )
Class 3: ( 1 4 3 )
Class 2: ( 1 4 5 )
Class 2: ( 1 3 2 )
Class 2: ( 1 3 5 )
Class 2: ( 1 2 5 )
Class 3: ( 2 5 4 )
Class 2: ( 2 5 3 )
Class 2: ( 2 4 3 )
Class 3: ( 3 5 4 )
Motif size: 4
Class 8: ( 0 5 4 1 )
Class 9: ( 0 5 4 2 )
Class 9: ( 0 5 4 3 )
Class 9: ( 0 5 3 1 )
Class 9: ( 0 5 3 2 )
Class 9: ( 0 5 2 1 )
Class 9: ( 0 3 4 1 )
Class 8: ( 0 3 4 2 )
Class 9: ( 0 3 2 1 )
Class 9: ( 0 2 4 1 )
Class 9: ( 1 4 5 2 )
Class 9: ( 1 4 5 3 )
Class 9: ( 1 4 3 2 )
Class 8: ( 1 3 5 2 )
Class 9: ( 2 5 3 4 )
Motif size: 5
Class 31: ( 0 5 4 3 1 )
Class 31: ( 0 5 4 3 2 )
Class 31: ( 0 5 4 2 1 )
Class 31: ( 0 5 3 2 1 )
Class 31: ( 0 3 4 2 1 )
Class 31: ( 1 4 5 3 2 )
Motif size: 6
Class 152: ( 0 5 4 3 2 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu_estimate.c0000644000175100001710000001010600000000000030404 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, int size, igraph_vector_t *cut_prob,
                    igraph_integer_t sample_size, igraph_vector_t *parsample) {
    igraph_integer_t estimate;
    IGRAPH_ASSERT(igraph_motifs_randesu_estimate(graph, &estimate, size, cut_prob, sample_size, parsample) == IGRAPH_SUCCESS);
    printf("Estimate: %" IGRAPH_PRId "\n\n", estimate);
}


int main() {
    igraph_t g_0, g_1, g_50_full, g_4_3_1;
    igraph_vector_t cut_prob_0_3;
    igraph_vector_t cut_prob_0_4;
    igraph_vector_t cut_prob_01;
    igraph_vector_t parsample;
    igraph_integer_t estimate;

    igraph_vector_init_real(&cut_prob_0_3, 3, 0.0, 0.0, 0.0);
    igraph_vector_init_real(&cut_prob_0_4, 4, 0.0, 0.0, 0.0, 0.0);
    igraph_vector_init_real(&cut_prob_01, 3, 0.1, 0.1, 0.1);
    igraph_vector_init_seq(&parsample, 0, 40);

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_full(&g_50_full, 50, 0, IGRAPH_NO_LOOPS);
    igraph_small(&g_4_3_1, 4, 0, 0,1, 1,2, 2,0, -1);

    printf("No vertices:\n");
    call_and_print(&g_0, /*size*/ 3, &cut_prob_0_3, /*sample_size*/ 1, /*parsample*/ NULL);

    printf("One vertex:\n");
    call_and_print(&g_1, /*size*/ 3, &cut_prob_0_3, /*sample_size*/ 1, /*parsample*/ NULL);

    printf("Full graph of 50 vertices, motif size 3, sample all, (50 choose 3 = 19600):\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_0_3, /*sample_size*/ 50, /*parsample*/ NULL);

    printf("Full graph of 50 vertices, motif size 3, sample all, cut_prob 0.1 at each level:\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_01, /*sample_size*/ 50, /*parsample*/ NULL);

    printf("Full graph of 50 vertices, motif size 3, sample 20:\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_0_3, /*sample_size*/ 20, /*parsample*/ NULL);

    printf("Full graph of 50 vertices, motif size 3, sample first 40:\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_0_3, /*sample_size*/ 0, &parsample);

    printf("Full graph of 50 vertices, motif size 4, sample 20 (50 choose 4 = 230300:\n");
    call_and_print(&g_50_full, /*size*/ 4, &cut_prob_0_4, /*sample_size*/ 20, /*parsample*/ NULL);

    printf("Triangle and a vertex, motif size 4, sample all:\n");
    call_and_print(&g_4_3_1, /*size*/ 4, &cut_prob_0_4, /*sample_size*/ 4, /*parsample*/ NULL);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Cut prob too short.\n");
    IGRAPH_ASSERT(igraph_motifs_randesu_estimate(&g_4_3_1, &estimate, /*size*/ 14, &cut_prob_0_3, /*sample_size*/ 4, /*parsample*/ NULL) == IGRAPH_EINVAL);

    printf("Too many samples.\n");
    IGRAPH_ASSERT(igraph_motifs_randesu_estimate(&g_4_3_1, &estimate, /*size*/ 4, &cut_prob_0_4, /*sample_size*/ 40, /*parsample*/ NULL) == IGRAPH_EINVAL);

    printf("Too many parsamples.\n");
    IGRAPH_ASSERT(igraph_motifs_randesu_estimate(&g_4_3_1, &estimate, /*size*/ 4, &cut_prob_0_4, /*sample_size*/ 4, /*parsample*/ &parsample) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_50_full);
    igraph_destroy(&g_4_3_1);
    igraph_vector_destroy(&cut_prob_0_3);
    igraph_vector_destroy(&cut_prob_0_4);
    igraph_vector_destroy(&cut_prob_01);
    igraph_vector_destroy(&parsample);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu_estimate.out0000644000175100001710000000112700000000000030774 0ustar00runnerdocker00000000000000No vertices:
Estimate: 0

One vertex:
Estimate: 0

Full graph of 50 vertices, motif size 3, sample all, (50 choose 3 = 19600):
Estimate: 19600

Full graph of 50 vertices, motif size 3, sample all, cut_prob 0.1 at each level:
Estimate: 14030

Full graph of 50 vertices, motif size 3, sample 20:
Estimate: 18192

Full graph of 50 vertices, motif size 3, sample first 40:
Estimate: 23800

Full graph of 50 vertices, motif size 4, sample 20 (50 choose 4 = 230300:
Estimate: 318737

Triangle and a vertex, motif size 4, sample all:
Estimate: 0

Cut prob too short.
Too many samples.
Too many parsamples.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu_no.c0000644000175100001710000000546700000000000027223 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, int size, igraph_vector_t *cut_prob) {
    igraph_integer_t result;
    IGRAPH_ASSERT(igraph_motifs_randesu_no(graph, &result, size, cut_prob) == IGRAPH_SUCCESS);
    printf("Result: %" IGRAPH_PRId "\n\n", result);
}

int main() {
    igraph_t g_0, g_1, g_50_full, g_4_3_1;
    igraph_vector_t cut_prob_0_3;
    igraph_vector_t cut_prob_0_4;
    igraph_vector_t cut_prob_01;
    igraph_integer_t result;

    igraph_vector_init_real(&cut_prob_0_3, 3, 0.0, 0.0, 0.0);
    igraph_vector_init_real(&cut_prob_0_4, 4, 0.0, 0.0, 0.0, 0.0);
    igraph_vector_init_real(&cut_prob_01, 3, 0.1, 0.1, 0.1);

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_full(&g_50_full, 50, 0, IGRAPH_NO_LOOPS);
    igraph_small(&g_4_3_1, 4, 0, 0,1, 1,2, 2,0, -1);

    printf("No vertices:\n");
    call_and_print(&g_0, /*size*/ 3, &cut_prob_0_3);

    printf("One vertex:\n");
    call_and_print(&g_1, /*size*/ 3, &cut_prob_0_3);

    printf("Full graph of 50 vertices, motif size 3 (50 choose 3 = 19600):\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_0_3);

    printf("Full graph of 50 vertices, motif size 3, cut_prob 0.1 at each level:\n");
    call_and_print(&g_50_full, /*size*/ 3, &cut_prob_01);

    printf("Full graph of 50 vertices, motif size 4 (50 choose 4 = 230300:\n");
    call_and_print(&g_50_full, /*size*/ 4, &cut_prob_0_4);

    printf("Triangle and a vertex, motif size 4:\n");
    call_and_print(&g_4_3_1, /*size*/ 4, &cut_prob_0_4);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Cut prob too short.\n");
    IGRAPH_ASSERT(igraph_motifs_randesu_no(&g_4_3_1, &result, /*size*/ 14, &cut_prob_0_3) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_50_full);
    igraph_destroy(&g_4_3_1);
    igraph_vector_destroy(&cut_prob_0_3);
    igraph_vector_destroy(&cut_prob_0_4);
    igraph_vector_destroy(&cut_prob_01);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_motifs_randesu_no.out0000644000175100001710000000054400000000000027577 0ustar00runnerdocker00000000000000No vertices:
Result: 0

One vertex:
Result: 0

Full graph of 50 vertices, motif size 3 (50 choose 3 = 19600):
Result: 19600

Full graph of 50 vertices, motif size 3, cut_prob 0.1 at each level:
Result: 14030

Full graph of 50 vertices, motif size 4 (50 choose 4 = 230300:
Result: 230300

Triangle and a vertex, motif size 4:
Result: 0

Cut prob too short.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood.c0000644000175100001710000000725200000000000026146 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_vector_ptr_t *result) {
    int i;
    igraph_vector_t *v;
    for (i = 0; i < igraph_vector_ptr_size(result); i++) {
        v = VECTOR(*result)[i];
        print_vector(v);
        igraph_vector_destroy(v);
        igraph_free(v);
    }
}

int main() {
    igraph_t g_empty, g_lm;
    igraph_vector_ptr_t result;
    igraph_vs_t vids;

    igraph_vector_ptr_init(&result, 0);
    igraph_vs_all(&vids);

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_empty, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 0:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 0,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 1, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_IN, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 10, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 10,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 2,
                  /*mode*/ IGRAPH_OUT, /*mindist*/ 2) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative order.\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ -4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_EINVAL);

    printf("Negative mindist.\n");
    IGRAPH_ASSERT(igraph_neighborhood(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ -4) == IGRAPH_EINVAL);

    igraph_vector_ptr_destroy(&result);
    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood.out0000644000175100001710000000134700000000000026532 0ustar00runnerdocker00000000000000No vertices:
Directed graph with loops and multi-edges, order 0:
( 0 )
( 1 )
( 2 )
( 3 )
( 4 )
( 5 )
Directed graph with loops and multi-edges, order 1, ignoring direction:
( 0 1 2 )
( 1 0 3 )
( 2 0 3 )
( 3 1 2 4 )
( 4 3 )
( 5 )
Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:
( 0 2 )
( 1 0 )
( 2 0 )
( 3 1 2 )
( 4 3 )
( 5 )
Directed graph with loops and multi-edges, order 10, ignoring direction:
( 0 1 2 3 4 )
( 1 0 3 2 4 )
( 2 0 3 1 4 )
( 3 1 2 4 0 )
( 4 3 1 2 0 )
( 5 )
Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:
( 3 )
( 4 )
( 1 4 )
( )
( )
( )
Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:
( )
( )
( )
( )
( )
( )
Negative order.
Negative mindist.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood_graphs.c0000644000175100001710000000771500000000000027516 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_and_destroy(igraph_vector_ptr_t *result) {
    int i;
    igraph_t *g;
    for (i = 0; i < igraph_vector_ptr_size(result); i++) {
        g = VECTOR(*result)[i];
        if (igraph_vcount(g) == 0) {
            printf("null graph\n");
        } else if (igraph_ecount(g) == 0 && igraph_vcount(g) == 1) {
            printf("One vertex, no edges\n");
        } else {
            print_graph_canon(g);
        }
        igraph_destroy(g);
        igraph_free(g);
    }
    printf("\n");
}

int main() {
    igraph_t g_empty, g_lm;
    igraph_vector_ptr_t result;
    igraph_vs_t vids;

    igraph_vector_ptr_init(&result, 0);
    igraph_vs_all(&vids);

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_empty, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 0:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 0,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 1, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_IN, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 10, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 10,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 2,
                  /*mode*/ IGRAPH_OUT, /*mindist*/ 2) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    printf("Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_SUCCESS);
    print_and_destroy(&result);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative order.\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ -4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_EINVAL);

    printf("Negative mindist.\n");
    IGRAPH_ASSERT(igraph_neighborhood_graphs(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ -4) == IGRAPH_EINVAL);

    igraph_vector_ptr_destroy(&result);
    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood_graphs.out0000644000175100001710000000321700000000000030074 0ustar00runnerdocker00000000000000No vertices:

Directed graph with loops and multi-edges, order 0:
One vertex, no edges
directed: true
vcount: 1
edges: {
0 0
}
One vertex, no edges
One vertex, no edges
One vertex, no edges
One vertex, no edges

Directed graph with loops and multi-edges, order 1, ignoring direction:
directed: true
vcount: 3
edges: {
0 1
0 2
1 1
2 0
}
directed: true
vcount: 3
edges: {
0 1
1 1
1 2
}
directed: true
vcount: 3
edges: {
0 1
1 0
1 2
}
directed: true
vcount: 4
edges: {
0 0
0 2
1 2
2 3
2 3
}
directed: true
vcount: 2
edges: {
0 1
0 1
}
One vertex, no edges

Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:
directed: true
vcount: 2
edges: {
0 1
1 0
}
directed: true
vcount: 2
edges: {
0 1
1 1
}
directed: true
vcount: 2
edges: {
0 1
1 0
}
directed: true
vcount: 3
edges: {
0 0
0 2
1 2
}
directed: true
vcount: 2
edges: {
0 1
0 1
}
One vertex, no edges

Directed graph with loops and multi-edges, order 10, ignoring direction:
directed: true
vcount: 5
edges: {
0 1
0 2
1 1
1 3
2 0
2 3
3 4
3 4
}
directed: true
vcount: 5
edges: {
0 1
0 2
1 1
1 3
2 0
2 3
3 4
3 4
}
directed: true
vcount: 5
edges: {
0 1
0 2
1 1
1 3
2 0
2 3
3 4
3 4
}
directed: true
vcount: 5
edges: {
0 1
0 2
1 1
1 3
2 0
2 3
3 4
3 4
}
directed: true
vcount: 5
edges: {
0 1
0 2
1 1
1 3
2 0
2 3
3 4
3 4
}
One vertex, no edges

Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:
One vertex, no edges
One vertex, no edges
directed: true
vcount: 2
edges: {
0 0
}
null graph
null graph
null graph

Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:
null graph
null graph
null graph
null graph
null graph
null graph

Negative order.
Negative mindist.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood_size.c0000644000175100001710000000671000000000000027176 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g_empty, g_lm;
    igraph_vector_t result;
    igraph_vs_t vids;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&result, 0);
    igraph_vs_all(&vids);

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_empty, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 0:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 0,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 1, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 1,
                  /*mode*/ IGRAPH_IN, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 10, ignoring direction:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 10,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 0) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 2,
                  /*mode*/ IGRAPH_OUT, /*mindist*/ 2) == IGRAPH_SUCCESS);
    print_vector(&result);

    printf("Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_SUCCESS);
    print_vector(&result);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative order.\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ -4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ 4) == IGRAPH_EINVAL);

    printf("Negative mindist.\n");
    IGRAPH_ASSERT(igraph_neighborhood_size(&g_lm, &result, vids, /*order*/ 4,
                  /*mode*/ IGRAPH_ALL, /*mindist*/ -4) == IGRAPH_EINVAL);

    igraph_vector_destroy(&result);
    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_neighborhood_size.out0000644000175100001710000000107300000000000027560 0ustar00runnerdocker00000000000000No vertices:
( )
Directed graph with loops and multi-edges, order 0:
( 1 1 1 1 1 1 )
Directed graph with loops and multi-edges, order 1, ignoring direction:
( 3 3 3 4 2 1 )
Directed graph with loops and multi-edges, order 1, only checking IGRAPH_IN:
( 2 2 2 3 2 1 )
Directed graph with loops and multi-edges, order 10, ignoring direction:
( 5 5 5 5 5 1 )
Directed graph with loops and multi-edges, order 2, mindist 2, IGRAPH_OUT:
( 1 1 2 0 0 0 )
Directed graph with loops and multi-edges, order 4, mindist 4, IGRAPH_ALL:
( 0 0 0 0 0 0 )
Negative order.
Negative mindist.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_pagerank.c0000644000175100001710000003455000000000000025270 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include 
#include 

#include "test_utilities.inc"

int is_almost_one(igraph_real_t x) {
    /* 2^5 = 32 is 5 binary digits  of tolerance */
    if (fabs(x - 1) > 32*DBL_EPSILON) {
        printf("Expected value to be 1, but actually got %15g.", x);
        return 0;
    }
    return 1;
}

int main() {

    igraph_t g;
    igraph_vector_t res, reset, weights;
    igraph_arpack_options_t arpack_options;
    igraph_real_t value;
    int err;

    /* The ARPACK method uses a random perturbation to the in-degrees
       to set the starting vector for ARPACK. */
    igraph_rng_seed(igraph_rng_default(), 137);

    igraph_arpack_options_init(&arpack_options);

    /* Test graphs taken from http://www.iprcom.com/papers/pagerank/ */

    printf("\nTest graph 1\n");
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0,1, 1,2, 2,0, 3,2, 0,2,
                 -1);

    igraph_vector_init(&res, 0);
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&res);

    igraph_destroy(&g);

    printf("\nTest graph 2\n");
    igraph_small(&g, 0, IGRAPH_DIRECTED,
                 0,1, 0,2, 0,3, 1,0, 2,0, 3,0,
                 3,4, 3,5, 3,6, 3,7, 4,0, 5,0,
                 6,0, 7,0,
                 -1);

    igraph_vector_init(&res, 0);
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&res);
    igraph_destroy(&g);

    /* Undirected star graph */

    printf("\nUndirected star\n");

    igraph_star(&g, 11, IGRAPH_STAR_UNDIRECTED, 0);
    igraph_vector_init(&res, 0);
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    /* Check twice more for consistency */
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 0, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    /* Check personalized PageRank */

    printf("\nPersonalized PageRank\n");

    igraph_personalized_pagerank_vs(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                                    igraph_vss_all(), 0, 0.5,
                                    igraph_vss_1(1), 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_personalized_pagerank_vs(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                                    igraph_vss_all(), 0, 0.5,
                                    igraph_vss_1(1), 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));


    /* Errors */

    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_init(&reset, 2);
    err = igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0,
                                       igraph_vss_all(), 0, 0.85, &reset, 0,
                                       &arpack_options);
    IGRAPH_ASSERT(err == IGRAPH_EINVAL);

    err = igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0,
                                       igraph_vss_all(), 0, 0.85, &reset, 0, 0);
    IGRAPH_ASSERT(err == IGRAPH_EINVAL);

    igraph_vector_resize(&reset, 10);
    igraph_vector_fill(&reset, 0);
    err = igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK,
                                       &res, 0, igraph_vss_all(), 0, 0.85,
                                       &reset, 0, &arpack_options);
    IGRAPH_ASSERT(err == IGRAPH_EINVAL);

    err = igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK,
                                       &res, 0, igraph_vss_all(), 0, 0.85,
                                       &reset, 0, 0);
    IGRAPH_ASSERT(err == IGRAPH_EINVAL);

    igraph_vector_destroy(&reset);
    igraph_destroy(&g);
    igraph_set_error_handler(igraph_error_handler_abort);


    /* Special cases: check for empty graph */
    /* The ARPACK method has a special code path for this case */

    printf("\nEdgeless graph\n");

    igraph_empty(&g, 10, IGRAPH_UNDIRECTED);
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_destroy(&g);

    /* Special cases: check for empty graph, personalized */
    /* The ARPACK method has a special code path for this case */

    printf("\nEdgeless graph, personalized PageRank\n");

    igraph_empty(&g, 4, IGRAPH_UNDIRECTED);
    igraph_vector_init_seq(&reset, 1, 4);

    igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &reset, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &reset, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    /* We also test the personalized case on a non-empty disconnected case,
     * which does not use the special code path for the ARPACK version.
     * The result must be the same for ARPACK and PRPACK. */

    printf("\nOne edge, two isolated vertices, personalized\n");
    igraph_add_edge(&g, 0, 1);

    igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &reset, 0, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &reset, 0, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&reset);
    igraph_destroy(&g);

    /* Special cases: check for full graph, zero weights */
    /* The ARPACK method has a special code path for this case */

    printf("\nComplete graph, zero weights\n");

    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);
    igraph_vector_init(&weights, 45);
    igraph_vector_fill(&weights, 0);
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* Another test case for PageRank (bug #792352) */

    printf("\nTest graph 3\n");

    igraph_small(&g, 9, IGRAPH_DIRECTED, 0, 5, 1, 5, 2, 0, 3, 1, 5, 4, 5, 7, 6, 0, 8, 0, 8, 1, -1);
    igraph_vector_init(&weights, 9);
    VECTOR(weights)[0] = 4;
    VECTOR(weights)[1] = 5;
    VECTOR(weights)[2] = 5;
    VECTOR(weights)[3] = 4;
    VECTOR(weights)[4] = 4;
    VECTOR(weights)[5] = 4;
    VECTOR(weights)[6] = 3;
    VECTOR(weights)[7] = 4;
    VECTOR(weights)[8] = 4;
    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    /* Multigraph */

    printf("\nSmall undirected multigraph (unweighted)\n");

    igraph_small(&g, 0, IGRAPH_UNDIRECTED,
                 0,1, 1,2, 1,2,
                 -1);

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, NULL, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, NULL, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    printf("\nSmall undirected multigraph (unit weights)\n");

    igraph_vector_init(&weights, 3);
    igraph_vector_fill(&weights, 1.0);

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, &arpack_options);
    printf("ARPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value,
                    igraph_vss_all(), 1, 0.85, &weights, 0);
    printf("PRPACK: "); print_vector(&res);
    IGRAPH_ASSERT(is_almost_one(value));

    igraph_vector_destroy(&weights);
    igraph_destroy(&g);

    igraph_vector_destroy(&res);

    /* Graph with more than 127 vertices. PRPACK uses a different method above this size. */

    {
        igraph_vector_t edges_to_delete;
        igraph_vector_t res_arpack, res_prpack;
        igraph_vector_t weights;
        long int i, n;

        printf("\nLarge test graph, unweighted\n");

        /* 243 vertices, 729 edges */
        igraph_de_bruijn(&g, 3, 5);

        /* We delete some edges to break the symmetry of the graph.
         * Otherwise all vertices would have the same PageRank. */
        igraph_vector_init_seq(&edges_to_delete, 0, 37);
        igraph_delete_edges(&g, igraph_ess_vector(&edges_to_delete));
        igraph_vector_destroy(&edges_to_delete);

        /* Note: This test graph is not connected and has self-loops. */

        igraph_vector_init(&res_arpack, 0);
        igraph_vector_init(&res_prpack, 0);

        igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res_arpack, &value,
                        igraph_vss_all(), 1, 0.85, NULL, &arpack_options);
        IGRAPH_ASSERT(is_almost_one(value));

        igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res_prpack, &value,
                        igraph_vss_all(), 1, 0.85, NULL, NULL);
        IGRAPH_ASSERT(is_almost_one(value));

        n = igraph_vector_size(&res_arpack);
        for (i=0; i < n; ++i) {
            igraph_real_t ar = VECTOR(res_arpack)[i];
            igraph_real_t pr = VECTOR(res_prpack)[i];
            if (fabs(ar - pr) > 1e-12) {
                printf("Unexpected difference between ARPACK and PRPACK results for vertex %ld:\n"
                       "ARPACK: %g\n"
                       "PRPACK: %g\n"
                       "Difference: %g\n",
                       i, ar, pr, fabs(ar - pr));
            }
        }

        printf("\nLarge test graph, weighted\n");

        igraph_vector_init_seq(&weights, igraph_ecount(&g) + 1, 2*igraph_ecount(&g));

        igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res_arpack, &value,
                        igraph_vss_all(), 1, 0.85, &weights, &arpack_options);
        IGRAPH_ASSERT(is_almost_one(value));

        igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res_prpack, &value,
                        igraph_vss_all(), 1, 0.85, &weights, NULL);
        IGRAPH_ASSERT(is_almost_one(value));

        n = igraph_vector_size(&res_arpack);
        for (i=0; i < n; ++i) {
            igraph_real_t ar = VECTOR(res_arpack)[i];
            igraph_real_t pr = VECTOR(res_prpack)[i];
            if (fabs(ar - pr) > 1e-12) {
                printf("Unexpected difference between ARPACK and PRPACK results for vertex %ld:\n"
                       "ARPACK: %g\n"
                       "PRPACK: %g\n"
                       "Difference: %g\n",
                       i, ar, pr, fabs(ar - pr));
            }
        }

        igraph_vector_destroy(&weights);

        igraph_vector_destroy(&res_arpack);
        igraph_vector_destroy(&res_prpack);

        igraph_destroy(&g);
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_pagerank.out0000644000175100001710000000427000000000000025651 0ustar00runnerdocker00000000000000
Test graph 1
ARPACK: ( 0.288717 0.201989 0.389109 0.120186 )
PRPACK: ( 0.288717 0.201989 0.389109 0.120186 )

Test graph 2
ARPACK: ( 0.336204 0.0759047 0.0759047 0.205964 0.0765056 0.0765056 0.0765056 0.0765056 )
PRPACK: ( 0.336204 0.0759047 0.0759047 0.205964 0.0765056 0.0765056 0.0765056 0.0765056 )

Undirected star
ARPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )
PRPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )
ARPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )
PRPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )
ARPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )
PRPACK: ( 0.46683 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 0.053317 )

Personalized PageRank
ARPACK: ( 0.333333 0.516667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 )
PRPACK: ( 0.333333 0.516667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 0.0166667 )

Edgeless graph
ARPACK: ( 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 )
PRPACK: ( 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 )

Edgeless graph, personalized PageRank
ARPACK: ( 0.1 0.2 0.3 0.4 )
PRPACK: ( 0.1 0.2 0.3 0.4 )

One edge, two isolated vertices, personalized
ARPACK: ( 0.36036 0.38038 0.111111 0.148148 )
PRPACK: ( 0.36036 0.38038 0.111111 0.148148 )

Complete graph, zero weights
ARPACK: ( 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 )
PRPACK: ( 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 )

Test graph 3
ARPACK: ( 0.143734 0.104639 0.045995 0.045995 0.155268 0.257112 0.045995 0.155268 0.045995 )
PRPACK: ( 0.143734 0.104639 0.045995 0.045995 0.155268 0.257112 0.045995 0.155268 0.045995 )

Small undirected multigraph (unweighted)
ARPACK: ( 0.187838 0.486486 0.325676 )
PRPACK: ( 0.187838 0.486486 0.325676 )

Small undirected multigraph (unit weights)
ARPACK: ( 0.187838 0.486486 0.325676 )
PRPACK: ( 0.187838 0.486486 0.325676 )

Large test graph, unweighted

Large test graph, weighted
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_preference_game.c0000644000175100001710000001425400000000000026606 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

/* How many "true" elements in the Boolean vector? */
long vector_bool_count(const igraph_vector_bool_t *vec) {
    long i, n = igraph_vector_bool_size(vec), cnt = 0;

    for (i=0; i < n; ++i) {
        if (VECTOR(*vec)[i]) {
            cnt++;
        }
    }
    return cnt;
}

int main() {
    igraph_t g;
    igraph_vector_t type_dist;
    igraph_matrix_t pref_mat;
    igraph_vector_t types, in_types, out_types;
    igraph_bool_t connected, has_loop, has_multi;
    igraph_vector_bool_t is_loop;
    long i;

    igraph_vector_init(&types, 0);

    /* Symmetric preference game */
    igraph_vector_init_real(&type_dist, 3, 1.0, 1.0, 1.0);

    igraph_matrix_init(&pref_mat, 3, 3);
    for (i = 0; i < 3; i++) {
        MATRIX(pref_mat, i, i) = 0.2;
    }

    /* undirected, no loops */
    IGRAPH_CHECK(igraph_preference_game(&g, 1000, 3, &type_dist, /*fixed_sizes=*/ 0,
                                        &pref_mat, &types, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 1000);
    IGRAPH_ASSERT(! igraph_is_directed(&g));

    igraph_is_connected(&g, &connected, IGRAPH_STRONG);
    IGRAPH_ASSERT(! connected);

    igraph_has_loop(&g, &has_loop);
    IGRAPH_ASSERT(! has_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    IGRAPH_ASSERT(igraph_vector_size(&types) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_min(&types) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&types) == 2);

    igraph_destroy(&g);

    /* Note: preference matrix must be symmetric in the undirected case. */
    for (i = 0; i < 2; i++) {
        MATRIX(pref_mat, i, i + 1) = 0.1;
        MATRIX(pref_mat, i + 1, i) = 0.1;
    }

    /* directed, no loops */
    IGRAPH_CHECK(igraph_preference_game(&g, 1000, 3, &type_dist, /*fixed_sizes=*/0,
                                        &pref_mat, &types, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 1000);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_has_loop(&g, &has_loop);
    IGRAPH_ASSERT(! has_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    IGRAPH_ASSERT(igraph_vector_size(&types) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_min(&types) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&types) == 2);

    igraph_destroy(&g);

    /* undirected, loops */
    for (i = 0; i < 3; i++) {
        MATRIX(pref_mat, i, i) = 1.0;
    }

    IGRAPH_CHECK(igraph_preference_game(&g, 100, 3, &type_dist, /*fixed_sizes=*/ 0,
                                        &pref_mat, &types, IGRAPH_UNDIRECTED, IGRAPH_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 100);
    IGRAPH_ASSERT(igraph_ecount(&g) >= 1395);
    IGRAPH_ASSERT(!igraph_is_directed(&g));

    igraph_has_loop(&g, &has_loop);
    IGRAPH_ASSERT(has_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    IGRAPH_ASSERT(igraph_vector_size(&types) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_min(&types) == 0);
    IGRAPH_ASSERT(igraph_vector_max(&types) == 2);

    igraph_destroy(&g);

    /* directed, loops */
    IGRAPH_CHECK(igraph_preference_game(&g, 100, 3, &type_dist, /*fixed_sizes=*/ 0,
                                        &pref_mat, NULL, IGRAPH_DIRECTED, IGRAPH_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 100);
    IGRAPH_ASSERT(igraph_ecount(&g) >= 2700);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_has_loop(&g, &has_loop);
    IGRAPH_ASSERT(has_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    igraph_destroy(&g);

    igraph_vector_destroy(&types);

    /* Asymmetric preference game */

    igraph_vector_init(&in_types, 0);
    igraph_vector_init(&out_types, 0);

    /* directed, no loops */
    igraph_matrix_resize(&pref_mat, 2, 3);
    MATRIX(pref_mat, 0, 0) = 1;
    MATRIX(pref_mat, 0, 1) = 1;
    MATRIX(pref_mat, 0, 2) = 1;
    MATRIX(pref_mat, 1, 0) = 1;
    MATRIX(pref_mat, 1, 1) = 1;
    MATRIX(pref_mat, 1, 2) = 1;

    IGRAPH_CHECK(igraph_asymmetric_preference_game(&g, 100, 2, 3, NULL, &pref_mat, &in_types, &out_types, IGRAPH_NO_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 100);
    IGRAPH_ASSERT(igraph_ecount(&g) == 9900);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_has_loop(&g, &has_loop);
    IGRAPH_ASSERT(! has_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    igraph_destroy(&g);

    /* directed, loops */
    igraph_matrix_resize(&pref_mat, 2, 2);
    MATRIX(pref_mat, 0, 0) = 1;
    MATRIX(pref_mat, 0, 1) = 1;
    MATRIX(pref_mat, 1, 0) = 1;
    MATRIX(pref_mat, 1, 1) = 1;

    IGRAPH_CHECK(igraph_asymmetric_preference_game(&g, 100, 2, 2, NULL, &pref_mat, NULL, NULL, IGRAPH_LOOPS));

    IGRAPH_ASSERT(igraph_vcount(&g) == 100);
    IGRAPH_ASSERT(igraph_ecount(&g) == 10000);
    IGRAPH_ASSERT(igraph_is_directed(&g));

    igraph_vector_bool_init(&is_loop, 0);
    igraph_is_loop(&g, &is_loop, igraph_ess_all(IGRAPH_EDGEORDER_ID));
    IGRAPH_ASSERT(vector_bool_count(&is_loop) == 100);
    igraph_vector_bool_destroy(&is_loop);

    igraph_has_multiple(&g, &has_multi);
    IGRAPH_ASSERT(! has_multi);

    igraph_destroy(&g);

    igraph_vector_destroy(&type_dist);
    igraph_matrix_destroy(&pref_mat);

    igraph_vector_destroy(&in_types);
    igraph_vector_destroy(&out_types);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_progress_handler_stderr.c0000644000175100001710000000162600000000000030422 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_progress_handler_stderr("This is a message ", 10, NULL);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_psumtree.c0000644000175100001710000001361400000000000025342 0ustar00runnerdocker00000000000000
/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {
    igraph_psumtree_t tree;
    igraph_vector_t vec;
    long int i;
    igraph_real_t sum;

    /* Uniform random numbers */
    igraph_vector_init(&vec, 16);
    igraph_psumtree_init(&tree, 16);
    sum = igraph_psumtree_sum(&tree);
    if (sum != 0) {
        printf("Sum: %f instead of 0.\n", sum);
        return 1;
    }

    for (i = 0; i < 16; i++) {
        igraph_psumtree_update(&tree, i, 1);
    }
    if ((sum = igraph_psumtree_sum(&tree)) != 16) {
        printf("Sum: %f instead of 16.\n", sum);
        return 2;
    }

    for (i = 0; i < 16000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    for (i = 0; i < 16; i++) {
        if (VECTOR(vec)[i] < 800 || VECTOR(vec)[i] > 1200) {
            return 3;
        }
    }

    /* Nonuniform, even indices have twice as much chance */
    for (i = 0; i < 16; i += 2) {
        igraph_psumtree_update(&tree, i, 2);
    }
    if ((sum = igraph_psumtree_sum(&tree)) != 24) {
        printf("Sum: %f instead of 24.\n", sum);
        return 4;
    }

    igraph_vector_null(&vec);
    for (i = 0; i < 24000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    for (i = 0; i < 16; i++) {
        if (i % 2 == 0 && (VECTOR(vec)[i] < 1800 || VECTOR(vec)[i] > 2200)) {
            return 5;
        }
        if (i % 2 != 0 && (VECTOR(vec)[i] < 800 || VECTOR(vec)[i] > 1200)) {
            return 6;
        }
    }

    /* Test zero probabilities */
    igraph_psumtree_update(&tree, 0, 0);
    igraph_psumtree_update(&tree, 5, 0);
    igraph_psumtree_update(&tree, 15, 0);
    sum = igraph_psumtree_sum(&tree);

    igraph_vector_null(&vec);
    for (i = 0; i < 20000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    if (VECTOR(vec)[0] != 0 || VECTOR(vec)[5] != 0 || VECTOR(vec)[15] != 0) {
        return 7;
    }

    igraph_vector_destroy(&vec);
    igraph_psumtree_destroy(&tree);

    /****************************************************/
    /* Non power-of-two vector size                     */
    /****************************************************/

    igraph_vector_init(&vec, 9);
    igraph_psumtree_init(&tree, 9);

    for (i = 0; i < 9; i++) {
        igraph_psumtree_update(&tree, i, 1);
    }
    sum = igraph_psumtree_sum(&tree);

    for (i = 0; i < 9000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    for (i = 0; i < 9; i++) {
        if (VECTOR(vec)[i] < 800 || VECTOR(vec)[i] > 1200) {
            return 8;
        }
    }

    /* Nonuniform, even indices have twice as much chance */
    for (i = 0; i < 9; i += 2) {
        igraph_psumtree_update(&tree, i, 2);
    }
    sum = igraph_psumtree_sum(&tree);

    igraph_vector_null(&vec);
    for (i = 0; i < 14000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    for (i = 0; i < 9; i++) {
        if (i % 2 == 0 && (VECTOR(vec)[i] < 1800 || VECTOR(vec)[i] > 2200)) {
            return 9;
        }
        if (i % 2 != 0 && (VECTOR(vec)[i] < 800 || VECTOR(vec)[i] > 1200)) {
            return 10;
        }
    }

    /* Test query */
    for (i = 0; i < igraph_psumtree_size(&tree); i++) {
        if (i % 2 == 0 && igraph_psumtree_get(&tree, i) != 2) {
            return 11;
        }
        if (i % 2 != 0 && igraph_psumtree_get(&tree, i) != 1) {
            return 12;
        }
    }

    /* Test zero probabilities */
    igraph_psumtree_update(&tree, 0, 0);
    igraph_psumtree_update(&tree, 5, 0);
    igraph_psumtree_update(&tree, 8, 0);
    sum = igraph_psumtree_sum(&tree);

    igraph_vector_null(&vec);
    for (i = 0; i < 9000; i++) {
        igraph_real_t r = ((double)rand()) / RAND_MAX * sum;
        long int idx;
        igraph_psumtree_search(&tree, &idx, r);
        VECTOR(vec)[idx] += 1;
    }
    if (VECTOR(vec)[0] != 0 || VECTOR(vec)[5] != 0 || VECTOR(vec)[8] != 0) {
        return 11;
    }

    igraph_vector_destroy(&vec);
    igraph_psumtree_destroy(&tree);

    /****************************************************/
    /* Error handling                                   */
    /****************************************************/

    igraph_psumtree_init(&tree, 9);
    if (igraph_psumtree_update(&tree, 2, -2) == IGRAPH_SUCCESS) {
        return 12;
    }
    if (igraph_psumtree_update(&tree, 2, -INFINITY) == IGRAPH_SUCCESS) {
        return 13;
    }
    if (igraph_psumtree_update(&tree, 2, IGRAPH_NAN) == IGRAPH_SUCCESS) {
        return 14;
    }
    igraph_psumtree_destroy(&tree);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_qsort.c0000644000175100001710000000311000000000000024634 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA 02139, USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int comp(const void *a, const void *b) {
    igraph_real_t *aa = (igraph_real_t *) a;
    igraph_real_t *bb = (igraph_real_t *) b;

    if (*aa < *bb) {
        return -1;
    } else if (*aa > *bb) {
        return 1;
    }

    return 0;
}

int main() {
    const int len = 100;
    igraph_vector_t v;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_vector_init(&v, len);
    for (i = 0; i < len; i++) {
        VECTOR(v)[i] = i;
    }
    igraph_vector_shuffle(&v);

    igraph_qsort(VECTOR(v), igraph_vector_size(&v), sizeof(VECTOR(v)[0]), comp);

    igraph_vector_print(&v);

    igraph_vector_destroy(&v);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_qsort.out0000644000175100001710000000044200000000000025226 0ustar00runnerdocker000000000000000 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_qsort_r.c0000644000175100001710000000360300000000000025164 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA 02139, USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int comp(void *extra, const void *a, const void *b) {
    igraph_vector_t *v = (igraph_vector_t*) extra;
    int *aa = (int*) a;
    int *bb = (int*) b;
    igraph_real_t aaa = VECTOR(*v)[*aa];
    igraph_real_t bbb = VECTOR(*v)[*bb];

    if (aaa < bbb) {
        return -1;
    } else if (aaa > bbb) {
        return 1;
    }

    return 0;
}

int main() {
    const int len = 100;
    igraph_vector_t v;
    igraph_vector_int_t idx;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    igraph_vector_init(&v, len);
    igraph_vector_int_init(&idx, len);
    for (i = 0; i < len; i++) {
        VECTOR(v)[i] = i;
        VECTOR(idx)[i] = i;
    }
    igraph_vector_shuffle(&v);

    igraph_qsort_r(VECTOR(idx), len, sizeof(VECTOR(idx)[0]), (void*) &v, comp);

    for (i = 0; i < len; i++) {
        printf("%g ", VECTOR(v)[ VECTOR(idx)[i] ]);
    }
    printf("\n");

    igraph_vector_int_destroy(&idx);
    igraph_vector_destroy(&v);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_qsort_r.out0000644000175100001710000000044300000000000025550 0ustar00runnerdocker000000000000000 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_random_walk.c0000644000175100001710000000337600000000000026000 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_t walk, weights;
    igraph_integer_t ec, i;

    igraph_rng_seed(igraph_rng_default(), 137);

    igraph_vector_init(&walk, 0);
    igraph_vector_init(&weights, 0);

    /* This directed graph has loop edges.
       It also has multi-edges when considered as undirected. */
    igraph_de_bruijn(&graph, 3, 2);
    ec = igraph_ecount(&graph);

    /* unweighted, directed */
    igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
    IGRAPH_ASSERT(igraph_vector_size(&walk) == 1000);

    /* unweighted, undirected */
    igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_ALL, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
    IGRAPH_ASSERT(igraph_vector_size(&walk) == 1000);

    igraph_vector_resize(&weights, ec);
    for (i = 0; i < ec; ++i) {
        VECTOR(weights)[i] = igraph_rng_get_unif01(igraph_rng_default());
    }

    /* weighted, directed */
    igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
    IGRAPH_ASSERT(igraph_vector_size(&walk) == 1000);

    /* weighted, undirecetd */
    igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_ALL, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
    IGRAPH_ASSERT(igraph_vector_size(&walk) == 1000);

    igraph_destroy(&graph);

    /* 1-vertex graph, should get stuck */
    igraph_empty(&graph, 1, /* directed = */ 0);
    igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
    IGRAPH_ASSERT(igraph_vector_size(&walk) == 0);
    igraph_destroy(&graph);

    igraph_vector_destroy(&weights);
    igraph_vector_destroy(&walk);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_realize_degree_sequence.c0000644000175100001710000001045300000000000030332 0ustar00runnerdocker00000000000000
#include 
#include 

#include "test_utilities.inc"

void realize1(igraph_vector_t *ods, igraph_vector_t *ids, igraph_edge_type_sw_t et, igraph_realize_degseq_t method) {
    igraph_t graph;
    int err;
    err = igraph_realize_degree_sequence(&graph, ods, ids, et, method);
    if (err == IGRAPH_SUCCESS) {
        printf("\n");
        print_graph(&graph);
        igraph_destroy(&graph);
    } else if (err == IGRAPH_UNIMPLEMENTED) {
        printf(" not implemented\n");
    } else {
        printf(" not graphical\n");
    }
}

void realize2(igraph_vector_t *ods, igraph_vector_t *ids, igraph_edge_type_sw_t et) {
    printf("Largest:");
    realize1(ods, ids, et, IGRAPH_REALIZE_DEGSEQ_LARGEST);
    printf("Smallest:");
    realize1(ods, ids, et, IGRAPH_REALIZE_DEGSEQ_SMALLEST);
    printf("Index:");
    realize1(ods, ids, et, IGRAPH_REALIZE_DEGSEQ_INDEX);
}

void undirected_print_destroy(igraph_vector_t *ds) {
    print_vector_round(ds);
    printf("\nSIMPLE GRAPH:\n");
    realize2(ds, NULL, IGRAPH_SIMPLE_SW);
    printf("\nLOOPLESS MULTIGRAPH:\n");
    realize2(ds, NULL, IGRAPH_MULTI_SW);
    printf("\nLOOPY MULTIGRAPH:\n");
    realize2(ds, NULL, IGRAPH_MULTI_SW | IGRAPH_LOOPS_SW);
    printf("\n\n");
    igraph_vector_destroy(ds);
}

void directed_print_destroy(igraph_vector_t *ods, igraph_vector_t *ids) {
    print_vector_round(ods);
    print_vector_round(ids);
    printf("\nSIMPLE GRAPH:\n");
    realize2(ods, ids, IGRAPH_SIMPLE_SW);
    printf("\nLOOPLESS MULTIGRAPH:\n");
    realize2(ods, ids, IGRAPH_MULTI_SW);
    printf("\nLOOPY MULTIGRAPH:\n");
    realize2(ods, ids, IGRAPH_MULTI_SW | IGRAPH_LOOPS_SW);
    printf("\n\n");
    igraph_vector_destroy(ods);
    igraph_vector_destroy(ids);
}


int main() {
    igraph_vector_t ds, ods, ids;

    igraph_set_error_handler(&igraph_error_handler_ignore);

    /* Undirected */

    igraph_vector_init(&ds, 0);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 2, 2, 3, -1);
    undirected_print_destroy(&ds);

    /* contains negative degree */
    igraph_vector_init_int_end(&ds, -1, 1, 2, 2, -3, -1);
    undirected_print_destroy(&ds);

    /* odd sum */
    igraph_vector_init_int_end(&ds, -1, 1, 1, 2, 3, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 2, 3, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 4, 4, 4, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 3, 5, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 5, 3, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 1, 3, 3, 4, 1, 2, 1, 1, 1, 3, -1);
    undirected_print_destroy(&ds);

    igraph_vector_init_int_end(&ds, -1, 2, 0, 3, 2, 2, 2, 2, 3, -1);
    undirected_print_destroy(&ds);

    /* Directed */

    igraph_vector_init(&ods, 0);
    igraph_vector_init(&ids, 0);
    directed_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ods, -1, 3, 0, 1, 1, 1, 1, 0, 1, -1);
    igraph_vector_init_int_end(&ids, -1, 2, 1, 0, 2, 2, 1, 0, 0, -1);
    directed_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ods, -1, 3, 1, 2, 3, 1, 2, 2, -1);
    igraph_vector_init_int_end(&ids, -1, 2, 2, 1, 2, 3, 2, 2, -1);
    directed_print_destroy(&ods, &ids);

    /* single loops: graphical, but multi-eges only: non-graphical */
    igraph_vector_init_int_end(&ids, -1, 1, 0, 2, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 1, 2, -1);
    directed_print_destroy(&ods, &ids);

    /* same as before, different ordering, to test the "index" method */
    igraph_vector_init_int_end(&ids, -1, 2, 0, 1, -1);
    igraph_vector_init_int_end(&ods, -1, 2, 1, 0, -1);
    directed_print_destroy(&ods, &ids);

    /* same as before, different ordering, to test the "index" method */
    igraph_vector_init_int_end(&ids, -1, 0, 2, 1, -1);
    igraph_vector_init_int_end(&ods, -1, 1, 2, 0, -1);
    directed_print_destroy(&ods, &ids);

    igraph_vector_init_int_end(&ids, -1, 2, 0, -1);
    igraph_vector_init_int_end(&ods, -1, 0, 2, -1);
    directed_print_destroy(&ods, &ids);

    /* simple complete graph on 4 vertices */
    igraph_vector_init_int_end(&ids, -1, 3, 3, 3, 3, -1);
    igraph_vector_init_int_end(&ods, -1, 3, 3, 3, 3, -1);
    directed_print_destroy(&ods, &ids);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_realize_degree_sequence.out0000644000175100001710000001772000000000000030723 0ustar00runnerdocker00000000000000( )

SIMPLE GRAPH:
Largest:
directed: false
vcount: 0
edges: {
}
Smallest:
directed: false
vcount: 0
edges: {
}
Index:
directed: false
vcount: 0
edges: {
}

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 0
edges: {
}
Smallest:
directed: false
vcount: 0
edges: {
}
Index:
directed: false
vcount: 0
edges: {
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 0
edges: {
}
Smallest:
directed: false
vcount: 0
edges: {
}
Index:
directed: false
vcount: 0
edges: {
}


( 1 2 2 3 )

SIMPLE GRAPH:
Largest:
directed: false
vcount: 4
edges: {
3 2
3 1
3 0
2 1
}
Smallest:
directed: false
vcount: 4
edges: {
3 0
3 2
2 1
3 1
}
Index:
directed: false
vcount: 4
edges: {
3 0
3 1
2 1
3 2
}

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 4
edges: {
3 1
3 2
1 0
3 2
}
Smallest:
directed: false
vcount: 4
edges: {
3 0
3 1
2 1
3 2
}
Index:
directed: false
vcount: 4
edges: {
3 0
3 1
2 1
3 2
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 4
edges: {
3 1
3 2
1 0
3 2
}
Smallest:
directed: false
vcount: 4
edges: {
3 0
3 1
2 1
3 2
}
Index:
directed: false
vcount: 4
edges: {
3 0
3 1
2 1
3 2
}


( 1 2 2 -3 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPY MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical


( 1 1 2 3 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPY MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical


( 1 2 3 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 3
edges: {
2 1
2 0
2 1
}
Smallest:
directed: false
vcount: 3
edges: {
2 0
2 1
2 1
}
Index:
directed: false
vcount: 3
edges: {
2 0
2 1
2 1
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 3
edges: {
2 1
2 0
2 1
}
Smallest:
directed: false
vcount: 3
edges: {
2 0
2 1
2 1
}
Index:
directed: false
vcount: 3
edges: {
2 0
2 1
2 1
}


( 4 4 4 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 3
edges: {
1 0
2 1
2 0
2 1
2 0
1 0
}
Smallest:
directed: false
vcount: 3
edges: {
2 0
1 0
2 0
1 0
2 1
2 1
}
Index:
directed: false
vcount: 3
edges: {
1 0
2 0
2 0
1 0
2 1
2 1
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 3
edges: {
1 0
2 1
2 0
2 1
2 0
1 0
}
Smallest:
directed: false
vcount: 3
edges: {
2 0
1 0
2 0
1 0
2 1
2 1
}
Index:
directed: false
vcount: 3
edges: {
1 0
2 0
2 0
1 0
2 1
2 1
}


( 3 5 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
1 1
}
Smallest:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
1 1
}
Index:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
1 1
}


( 5 3 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
0 0
}
Smallest:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
0 0
}
Index:
directed: false
vcount: 2
edges: {
1 0
1 0
1 0
0 0
}


( 1 3 3 4 1 2 1 1 1 3 )

SIMPLE GRAPH:
Largest:
directed: false
vcount: 10
edges: {
9 3
3 2
3 1
5 3
9 2
9 1
2 1
8 5
7 6
4 0
}
Smallest:
directed: false
vcount: 10
edges: {
8 3
7 3
6 1
4 2
9 0
9 5
5 2
2 1
9 3
3 1
}
Index:
directed: false
vcount: 10
edges: {
3 0
3 1
2 1
9 1
3 2
9 2
5 3
5 4
9 6
8 7
}

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 10
edges: {
3 1
9 2
5 3
9 1
3 2
4 0
7 6
8 5
9 1
3 2
}
Smallest:
directed: false
vcount: 10
edges: {
8 3
7 1
6 2
9 4
3 0
5 3
5 1
2 1
9 2
9 3
}
Index:
directed: false
vcount: 10
edges: {
3 0
3 1
2 1
9 1
9 2
3 2
5 3
5 4
9 6
8 7
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 10
edges: {
3 1
9 2
5 3
9 1
3 2
4 0
7 6
8 5
9 1
3 2
}
Smallest:
directed: false
vcount: 10
edges: {
8 3
7 1
6 2
9 4
3 0
5 3
5 1
2 1
9 2
9 3
}
Index:
directed: false
vcount: 10
edges: {
3 0
3 1
2 1
9 1
9 2
3 2
5 3
5 4
9 6
8 7
}


( 2 0 3 2 2 2 2 3 )

SIMPLE GRAPH:
Largest:
directed: false
vcount: 8
edges: {
7 2
7 6
7 5
4 2
3 2
4 0
3 0
6 5
}
Smallest:
directed: false
vcount: 8
edges: {
6 2
7 6
5 2
7 5
7 0
3 2
4 0
4 3
}
Index:
directed: false
vcount: 8
edges: {
2 0
7 0
7 2
3 2
4 3
5 4
6 5
7 6
}

LOOPLESS MULTIGRAPH:
Largest:
directed: false
vcount: 8
edges: {
7 2
3 0
5 4
7 6
3 2
5 0
7 4
6 2
}
Smallest:
directed: false
vcount: 8
edges: {
6 2
7 6
7 0
3 0
4 3
5 4
5 2
7 2
}
Index:
directed: false
vcount: 8
edges: {
2 0
7 0
7 2
3 2
4 3
5 4
6 5
7 6
}

LOOPY MULTIGRAPH:
Largest:
directed: false
vcount: 8
edges: {
7 2
3 0
5 4
7 6
3 2
5 0
7 4
6 2
}
Smallest:
directed: false
vcount: 8
edges: {
6 2
7 6
7 0
3 0
4 3
5 4
5 2
7 2
}
Index:
directed: false
vcount: 8
edges: {
2 0
7 0
7 2
3 2
4 3
5 4
6 5
7 6
}


( )
( )

SIMPLE GRAPH:
Largest:
directed: true
vcount: 0
edges: {
}
Smallest:
directed: true
vcount: 0
edges: {
}
Index:
directed: true
vcount: 0
edges: {
}

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 3 0 1 1 1 1 0 1 )
( 2 1 0 2 2 1 0 0 )

SIMPLE GRAPH:
Largest:
directed: true
vcount: 8
edges: {
0 3
0 4
0 5
3 0
4 0
5 4
2 3
7 1
}
Smallest:
directed: true
vcount: 8
edges: {
7 0
2 3
5 4
3 0
0 4
0 3
0 5
4 1
}
Index:
directed: true
vcount: 8
edges: {
0 3
0 4
0 5
2 0
3 4
4 3
5 0
7 1
}

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 3 1 2 3 1 2 2 )
( 2 2 1 2 3 2 2 )

SIMPLE GRAPH:
Largest:
directed: true
vcount: 7
edges: {
4 0
3 4
3 5
3 6
1 4
0 1
0 3
0 5
6 2
6 1
2 6
2 3
5 0
5 4
}
Smallest:
directed: true
vcount: 7
edges: {
2 4
2 0
0 3
0 5
0 6
6 4
6 1
1 3
3 5
3 4
3 1
4 6
5 0
5 2
}
Index:
directed: true
vcount: 7
edges: {
0 4
0 3
0 5
1 6
2 4
2 1
3 0
3 6
3 5
4 0
5 4
5 3
6 1
6 2
}

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 0 1 2 )
( 1 0 2 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 2 1 0 )
( 2 0 1 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 1 2 0 )
( 0 2 1 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 0 2 )
( 2 0 )

SIMPLE GRAPH:
Largest: not graphical
Smallest: not graphical
Index: not graphical

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


( 3 3 3 3 )
( 3 3 3 3 )

SIMPLE GRAPH:
Largest:
directed: true
vcount: 4
edges: {
0 1
0 2
0 3
1 0
1 2
1 3
2 0
2 1
2 3
3 0
3 1
3 2
}
Smallest:
directed: true
vcount: 4
edges: {
3 0
3 1
3 2
2 3
2 0
2 1
1 3
1 2
1 0
0 3
0 2
0 1
}
Index:
directed: true
vcount: 4
edges: {
0 1
0 2
0 3
1 0
1 2
1 3
2 0
2 1
2 3
3 0
3 1
3 2
}

LOOPLESS MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented

LOOPY MULTIGRAPH:
Largest: not implemented
Smallest: not implemented
Index: not implemented


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_recent_degree_aging_game.c0000644000175100001710000001062400000000000030425 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_bool_t tree;
    igraph_vector_t outseq;
    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/0, /*edges per step(m)*/ 1, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 1, /*aging_exp*/ 1, /*aging_bins*/ 1, /*time_window*/ 1, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("No edges:\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/5, /*edges per step(m)*/ 0, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 1, /*aging_exp*/ 1, /*aging_bins*/ 6, /*time_window*/ 1, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Prefer more edges to make a star of double edges:\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/5, /*edges per step(m)*/ 2, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 20, /*aging_exp*/ 0, /*aging_bins*/ 1, /*time_window*/ 100, /*zero appeal*/ 0.001,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Prefer older edges to make a star:\n");
    igraph_vector_init_int(&outseq, 7, 1, 2, 1, 2, 1, 2, 1);
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/7, /*edges per step(m)*/ 0, &outseq,
                  /*outpref?*/ 0, /*pa_exp*/ 0, /*aging_exp*/ 20, /*aging_bins*/ 8, /*time_window*/ 100, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Checking if adding one edge per step makes a tree.\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/10, /*edges per step(m)*/ 1, /*outseq*/ NULL,
                  /*outpref?*/ 1, /*pa_exp*/ 2, /*aging_exp*/ 2, /*aging_bins*/ 5, /*time_window*/ 4, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    igraph_is_tree(&g, &tree, NULL, IGRAPH_ALL);
    IGRAPH_ASSERT(tree);
    igraph_destroy(&g);
    igraph_vector_destroy(&outseq);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking if these errors are properly handled:\n");
    printf("Negative number of vertices.\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/-20, /*edges per step(m)*/ 1, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 2, /*aging_exp*/ 2, /*aging_bins*/ 3, /*time_window*/ 4, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    printf("Negative number of edges.\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/20, /*edges per step(m)*/ -1, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 2, /*aging_exp*/ 2, /*aging_bins*/ 10, /*time_window*/ 4, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    printf("Negative aging bin.\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/20, /*edges per step(m)*/ 1, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 2, /*aging_exp*/ 2, /*aging_bins*/ -3, /*time_window*/ 4, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    printf("Negative zero appeal.\n");
    IGRAPH_ASSERT(igraph_recent_degree_aging_game(&g, /*nodes*/20, /*edges per step(m)*/ 1, /*outseq*/ NULL,
                  /*outpref?*/ 0, /*pa_exp*/ 2, /*aging_exp*/ 2, /*aging_bins*/ 10, /*time_window*/ 4, /*zero appeal*/ -1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);


    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_recent_degree_aging_game.out0000644000175100001710000000100700000000000031005 0ustar00runnerdocker00000000000000No vertices:
directed: false
vcount: 0
edges: {
}
No edges:
directed: false
vcount: 5
edges: {
}
Prefer more edges to make a star of double edges:
directed: false
vcount: 5
edges: {
0 1
0 1
0 2
0 2
0 3
0 3
0 4
0 4
}
Prefer older edges to make a star:
directed: false
vcount: 7
edges: {
0 1
0 1
0 2
0 3
0 3
0 4
0 5
0 5
0 6
}
Checking if adding one edge per step makes a tree.
Checking if these errors are properly handled:
Negative number of vertices.
Negative number of edges.
Negative aging bin.
Negative zero appeal.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_recent_degree_game.c0000644000175100001710000000620200000000000027255 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/0, /*power*/ 0.0,
                  /*window*/ 1, /*edges per step(m)*/ 1, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("No edges:\n");
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ 5, /*power*/ 0.0,
                  /*window*/ 1, /*edges per step(m)*/ 0, /*outseq*/ NULL, /*outpref?*/ 1, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("A star with double edges.\n");
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ 10, /*power*/ 30.0,
                  /*window*/ 100, /*edges per step(m)*/ 2, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ 0.001,
                  /*directed?*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /*Negative number of vertices*/
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ -1, /*power*/ 10.0,
                  /*window*/ 100, /*edges per step(m)*/ 1, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    /*Negative number of edges*/
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ 1, /*power*/ 10.0,
                  /*window*/ 100, /*edges per step(m)*/ -1, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    /*Negative window*/
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ 1, /*power*/ 10.0,
                  /*window*/ -100, /*edges per step(m)*/ 1, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ 1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    /*Negative zero appeal*/
    IGRAPH_ASSERT(igraph_recent_degree_game(&g, /*number of vertices (n)*/ 1, /*power*/ 10.0,
                  /*window*/ 100, /*edges per step(m)*/ 1, /*outseq*/ NULL, /*outpref?*/ 0, /*zero appeal*/ -1,
                  /*directed?*/ 0) == IGRAPH_EINVAL);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_recent_degree_game.out0000644000175100001710000000035000000000000027640 0ustar00runnerdocker00000000000000No vertices:
directed: false
vcount: 0
edges: {
}
No edges:
directed: false
vcount: 5
edges: {
}
A star with double edges.
directed: true
vcount: 10
edges: {
1 0
1 0
2 0
2 0
3 0
3 0
4 0
4 0
5 0
5 0
6 0
6 0
7 0
7 0
8 0
8 0
9 0
9 0
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_residual_graph.c0000644000175100001710000000406000000000000026462 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g, residual, expected_residual;
    igraph_vector_t capacity, residual_capacity, flow, expected_residual_capacity;
    igraph_bool_t iso;

    igraph_vector_init(&residual_capacity, 0);

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, -1);
    igraph_small(&expected_residual, 6, IGRAPH_DIRECTED,
         0, 1, 1, 2, 1, 3, 2, 4, 3, 5, 4, 5, -1);
    igraph_vector_init_int_end(&capacity, -1, 4, 2, 2, 3, 4, 1, 2, 5, -1);
    igraph_vector_init_int_end(&flow, -1, 3, 2, 1, 2, 3, 1, 1, 4, -1);
    igraph_vector_init_int_end(&expected_residual_capacity, -1, 1, 1, 1, 1, 1, 1, -1);

    igraph_residual_graph(&g, &capacity, &residual, &residual_capacity, &flow);

    /*    tests    */

    IGRAPH_ASSERT(!igraph_isomorphic(&residual, &expected_residual, &iso));

    IGRAPH_ASSERT(iso);

    IGRAPH_ASSERT(igraph_vector_all_e(&expected_residual_capacity, &residual_capacity));

    /*    cleanup    */

    igraph_vector_destroy(&capacity);
    igraph_vector_destroy(&residual_capacity);
    igraph_vector_destroy(&flow);
    igraph_vector_destroy(&expected_residual_capacity);

    igraph_destroy(&g);
    igraph_destroy(&residual);
    igraph_destroy(&expected_residual);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rewire.c0000644000175100001710000000636400000000000024777 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "operators/rewire_internal.h"

#include "test_utilities.inc"

static void check_rewiring(igraph_tree_mode_t tree_mode, igraph_bool_t use_adjlist, igraph_bool_t allow_loops, const char* description) {

    igraph_t g;
    igraph_vector_t indegree_before, outdegree_before, indegree_after, outdegree_after;

    igraph_tree(&g, 10, 3, tree_mode);

    igraph_vector_init(&indegree_before, 0);
    igraph_vector_init(&outdegree_before, 0);
    igraph_degree(&g, &indegree_before, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_degree(&g, &outdegree_before, igraph_vss_all(), IGRAPH_OUT, 1);

    igraph_i_rewire(&g, 1000, allow_loops ? IGRAPH_REWIRING_SIMPLE_LOOPS : IGRAPH_REWIRING_SIMPLE, use_adjlist);

    igraph_vector_init(&indegree_after, 0);
    igraph_vector_init(&outdegree_after, 0);
    igraph_degree(&g, &indegree_after, igraph_vss_all(), IGRAPH_IN, 1);
    igraph_degree(&g, &outdegree_after, igraph_vss_all(), IGRAPH_OUT, 1);

    if ((!igraph_vector_all_e(&indegree_before, &indegree_after)) ||
        (!igraph_vector_all_e(&outdegree_before, &outdegree_after))) {

        printf("%s: graph degrees changed. Rewired graph is below.\n", description);
        print_graph(&g);

        abort();
    }

    igraph_destroy(&g);
    igraph_vector_destroy(&indegree_before);
    igraph_vector_destroy(&outdegree_before);
    igraph_vector_destroy(&indegree_after);
    igraph_vector_destroy(&outdegree_after);

}

int main() {
    igraph_rng_seed(igraph_rng_default(), 3925);

    /* Short test for the top-level igraph_rewire() functions (instead of igraph_i_rewire()). */
    {
        igraph_t graph;
        igraph_ring(&graph, 12, IGRAPH_UNDIRECTED, /* mutual= */ 0, /* circular= */ 1);
        igraph_rewire(&graph, 50, IGRAPH_REWIRING_SIMPLE);
        igraph_destroy(&graph);
    }

    check_rewiring(IGRAPH_TREE_OUT, 0, 0, "Directed, no loops, standard-method");
    check_rewiring(IGRAPH_TREE_OUT, 1, 0, "Directed, no loops, adjlist-method");
    check_rewiring(IGRAPH_TREE_OUT, 0, 1, "Directed, loops, standard-method");
    check_rewiring(IGRAPH_TREE_OUT, 1, 1, "Directed, loops, adjlist-method");
    check_rewiring(IGRAPH_TREE_UNDIRECTED, 0, 0, "Undirected, no loops, standard-method");
    check_rewiring(IGRAPH_TREE_UNDIRECTED, 1, 0, "Undirected, no loops, adjlist-method");
    check_rewiring(IGRAPH_TREE_UNDIRECTED, 0, 1, "Undirected, loops, standard-method");
    check_rewiring(IGRAPH_TREE_UNDIRECTED, 1, 1, "Undirected, loops, adjlist-method");

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rewire_directed_edges.c0000644000175100001710000000716500000000000030011 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g, g_copy;
    igraph_bool_t same;
    igraph_vector_t degrees;
    igraph_vs_t vertices;
    igraph_rng_seed(igraph_rng_default(), 42);

    /*No edges, should just return the same graph*/
    igraph_small(&g, 5, IGRAPH_DIRECTED, -1);
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 0.1,
                                               /*loops*/ 0, /*mode*/ IGRAPH_ALL)
                  == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 0);
    IGRAPH_ASSERT(igraph_vcount(&g) == 5);
    igraph_destroy(&g);

    /*No rewire*/
    igraph_small(&g, 10, IGRAPH_DIRECTED, 0,1, 0,3, 5,4, 4,8, 9,2, 9,3, 9,7, 7,7, 7,8, -1);
    igraph_copy(&g_copy, &g);
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 0.0,
                                               /*loops*/ 0, /*mode*/ IGRAPH_ALL)
                  == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_copy, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(same);

    /*Rewire*/
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 0.5,
                                               /*loops*/ 1, /*mode*/ IGRAPH_ALL)
                  == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_same_graph(&g, &g_copy, &same) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(!same); /*guaranteed for this seed*/
    IGRAPH_ASSERT(igraph_ecount(&g) == 9);
    IGRAPH_ASSERT(igraph_vcount(&g) == 10);
    igraph_destroy(&g);
    igraph_destroy(&g_copy);

    /*Out-star remains out-star if outs are moved*/
    igraph_small(&g, 10, IGRAPH_DIRECTED, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9, -1);
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 1.0,
                                               /*loops*/ 0, /*mode*/ IGRAPH_OUT)
                  == IGRAPH_SUCCESS);
    igraph_vector_init(°rees, 0);
    igraph_vs_1(&vertices, 0);
    igraph_degree(&g, °rees, vertices, IGRAPH_ALL, 0);
    IGRAPH_ASSERT(VECTOR(degrees)[0] == 9);
    igraph_vector_destroy(°rees);
    igraph_vs_destroy(&vertices);
    igraph_destroy(&g);

    /*Check if multiple edges are created when using mode == IGRAPH_ALL*/
    igraph_small(&g, 5, IGRAPH_DIRECTED, 0,1, 0,2, 0,3, 0,4, 1,2, 1,3, 1,4, 2,3, 2,4, 3,4, -1);
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 1.0,
                                               /*loops*/ 0, /*mode*/ IGRAPH_ALL)
                  == IGRAPH_SUCCESS);
    print_graph_canon(&g);

    /*A few erroneous calls*/
    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ -0.1, /*loops*/ 0, /*mode*/ IGRAPH_ALL) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_rewire_directed_edges(&g, /*probability*/ 1.1, /*loops*/ 0, /*mode*/ IGRAPH_ALL) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rewire_directed_edges.out0000644000175100001710000000011400000000000030361 0ustar00runnerdocker00000000000000directed: true
vcount: 5
edges: {
0 2
0 3
0 4
1 0
1 2
1 2
2 3
2 3
3 4
4 1
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rng_get_exp.c0000644000175100001710000000211100000000000025765 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge, MA, 02138 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    int i;

    igraph_rng_seed(igraph_rng_default(), 42);
    for (i = 0; i < 1000; i++) {
        printf("%g\n", igraph_rng_get_exp(igraph_rng_default(), 2.5));
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rng_get_exp.out0000644000175100001710000002154100000000000026362 0ustar00runnerdocker000000000000000.476523
0.237234
0.0508589
0.223753
0.0789268
0.0774801
0.653777
0.304978
1.23637
0.411193
0.080892
0.611692
0.166458
0.120711
1.51326
1.30922
0.265954
0.000215919
0.736358
0.0508505
0.0893225
0.0198051
1.94721
0.343225
0.0198197
0.0894823
0.517036
0.600898
1.30636
0.34469
0.0645379
1.01166
0.228141
0.0947088
0.793474
0.489198
0.0113875
0.0128788
0.168447
0.700195
0.280937
0.261234
0.0506306
0.246718
0.493925
0.364641
1.39503
1.05688
0.621344
0.311095
0.0879973
0.286793
0.071749
0.737673
0.130018
0.204289
0.375997
0.334913
0.0373682
0.0541603
0.746052
1.10985
0.124698
0.109559
0.165773
0.0245353
0.0563552
0.781663
0.0166674
1.28794
0.0902007
0.499143
0.197856
0.311417
0.0317537
0.26299
0.0694009
0.448064
0.0778916
0.0341569
0.318858
0.605475
0.351296
0.241758
0.683372
0.908901
1.38659
0.109484
0.790408
0.34684
2.10628
1.71868
0.165486
0.169074
0.183206
0.23214
0.217016
0.084768
0.905662
0.0993878
1.07108
0.124614
0.406696
1.0424
0.83855
0.470568
0.374831
0.135073
0.397552
0.132738
0.183685
0.0730382
0.110046
0.316814
0.130926
0.489942
1.02953
0.200106
0.0490218
0.625515
0.288469
0.284307
0.307173
1.11133
0.131801
0.380228
0.0506205
0.00685655
0.156413
0.0386309
0.0835339
0.533872
0.0318729
0.204441
0.804314
0.575861
0.0790924
0.340861
0.155828
0.670426
0.173108
0.246496
0.350273
0.106723
1.10694
0.126578
0.606246
0.149537
0.396211
0.245952
0.919946
0.0305129
0.672937
2.79888
0.254412
0.441369
0.00192754
0.681416
0.00859784
0.0272715
0.545116
0.310493
0.308319
0.417443
0.601178
0.698357
0.162415
0.523397
0.459066
0.847087
0.0684486
0.280111
0.157043
0.318317
0.0102272
0.00214322
0.534918
1.36796
1.13208
0.323093
0.429373
0.0664207
0.144564
0.618181
0.0247477
0.401411
0.576935
0.209296
0.468706
0.621659
0.242512
0.465712
0.452571
0.106824
0.515378
0.0286197
0.253146
1.00963
0.238676
0.268242
0.636814
0.390507
0.00655903
0.751377
0.15665
1.23096
0.090375
0.142051
0.559117
0.00967444
0.247601
0.651188
1.04731
0.71249
0.11023
0.496035
0.0142011
0.0381289
0.140552
0.422965
0.188173
0.889744
0.0331584
0.0715166
0.603026
0.253778
0.143242
0.294586
0.580331
0.154792
0.0523207
0.419707
0.323453
0.435994
0.160286
0.180765
0.237424
0.112153
0.178009
0.970272
0.044813
0.168138
0.0645493
1.73444
0.472911
1.08119
0.183962
2.05912
0.331532
0.669104
0.365841
0.038987
0.401588
0.00501155
0.644738
0.72675
0.197193
0.463609
0.119706
0.195336
0.182329
0.370156
0.0546469
0.0340322
1.0313
0.00705126
0.465604
0.109066
0.301583
0.277998
0.718065
0.506215
0.452248
0.374321
0.00210968
0.116083
0.0615231
0.135139
0.331392
0.177962
0.284001
0.116378
1.26716
0.721272
0.0775106
0.10263
0.198175
1.75526
0.430518
0.057834
0.236504
0.913993
0.348377
0.366374
0.493415
0.765433
0.074437
0.324252
0.508765
0.19298
0.0195235
1.05371
0.823058
0.0920058
0.136915
0.0388395
0.0146637
0.349724
0.0894301
0.0378795
0.161987
0.167129
0.452445
0.042256
0.347006
0.351675
0.247489
0.548908
0.248091
0.28719
0.169548
0.953979
0.00907392
2.07174
0.00121304
0.102316
0.238636
0.776194
0.119971
0.885798
0.161574
0.512113
0.236634
1.35887
0.0937122
1.49043
1.03326
0.437592
1.1691
0.402303
0.320246
0.0794461
0.00845647
1.18709
1.20612
0.25808
0.362484
0.453564
0.0296659
0.561111
0.399901
0.0177946
0.262295
0.215995
0.311728
0.72722
0.300922
1.37056
0.776534
0.0250837
0.535425
0.0325081
0.15961
0.109944
0.597248
0.180873
0.579303
0.143149
0.393989
1.2347
0.236149
0.515372
0.31059
0.398968
0.933897
0.278636
1.63527
0.744385
0.0224227
0.468152
0.531584
1.15708
0.655116
0.343742
0.0393813
1.03257
0.171677
0.739689
0.128158
0.0776142
0.143259
0.125689
0.0434832
0.446864
0.548619
1.3198
0.598504
0.206277
0.835767
0.844531
1.03438
1.23036
0.37552
0.195095
0.715575
0.282017
0.210692
0.373275
0.708764
0.397548
0.514866
1.32419
0.0926801
0.176085
1.28893
0.294689
0.476639
1.80305
0.000831908
0.149547
0.147171
0.675908
0.0926809
0.883417
0.178116
1.54871
0.109123
0.159555
0.141735
0.498331
0.0586936
0.114631
0.565719
0.428536
0.256512
0.10705
0.256341
0.18063
0.815908
0.781049
0.315597
0.875689
0.582459
1.45277
1.20776
1.03621
0.0946031
0.146405
0.415746
0.887384
0.124578
0.38762
0.493893
0.2759
0.145291
1.58206
0.422258
0.251575
0.29437
0.328227
0.310021
0.434597
0.103154
0.0108648
0.188057
0.545973
0.242785
0.0491967
0.434886
0.245468
0.0607397
0.0354031
0.472488
0.277285
0.22113
0.0644352
0.422545
0.155783
0.0661531
0.143876
0.200697
0.191927
0.203634
0.58311
0.140086
0.365995
0.353475
0.0277217
1.11204
0.02531
0.445107
0.388161
0.18764
0.133783
0.30035
1.01868
0.346396
0.0819527
0.403122
0.0429624
0.138015
0.76312
0.233263
0.225037
0.231695
0.857064
0.293218
0.0396231
1.23145
0.0972943
0.164665
0.871422
0.150424
0.209209
0.269571
0.0945744
0.0280372
0.97006
0.33897
0.89746
0.511901
0.257488
0.0406475
0.952409
0.0106609
0.974738
0.71569
0.476092
0.102764
0.25024
0.806184
0.0971011
0.479274
0.166545
0.966181
0.382059
0.0467234
0.164067
0.34622
0.405663
0.952232
0.28315
1.84486
0.525582
0.292869
0.192779
0.864362
0.258232
0.119368
0.195369
0.196836
0.144832
0.066695
0.665483
0.477052
0.300241
0.0619939
0.499651
1.88586
0.0119665
0.393557
0.0120333
0.254833
0.904075
0.282043
0.0430834
0.156329
0.0209149
0.103519
0.636169
0.451255
0.15754
0.0674515
0.491982
0.0126004
0.0778995
0.0160433
0.508494
0.306858
0.414315
0.321069
0.697493
0.756505
0.117479
0.375229
0.628251
0.929278
0.453811
0.0720734
0.158529
1.12268
0.0288771
0.32488
0.372503
0.53519
0.251036
0.0822255
0.147785
0.310791
0.674892
0.58071
0.0211272
0.115517
0.180576
0.0649301
0.0907322
0.0229427
0.240124
0.0412703
1.28783
0.681987
1.66129
0.535267
0.4796
0.222082
0.248443
0.550438
0.635852
0.480041
0.0753046
0.199663
0.486684
0.506042
0.157783
0.270663
0.838252
0.287468
0.582845
0.31471
1.67918
0.191784
0.027477
0.153998
0.21519
0.180897
0.209907
0.48182
0.611368
0.567828
0.279567
0.0761718
0.817646
0.740753
0.205599
0.0945026
1.30931
0.450319
0.307135
0.837928
0.409293
0.0161308
0.369702
0.153021
0.024512
0.233454
0.522831
0.0719647
0.583366
0.285239
0.20411
0.227735
0.0962476
0.111489
0.163264
0.244036
0.592328
0.093811
1.76076
0.0864703
0.0719341
0.109315
0.504849
0.0438525
0.30249
0.181118
0.434468
0.037957
0.0111916
0.494534
0.511727
0.353994
0.0976694
0.0188818
0.193427
0.237177
0.625153
0.510736
0.295623
0.289974
0.0966445
0.335242
0.106721
0.0637199
0.575552
0.0298107
0.566933
0.312761
0.640606
0.51774
0.598765
0.158134
0.1127
0.730733
0.736534
0.157201
0.430327
0.535917
0.13141
0.0121888
0.134046
0.0477772
0.565849
0.69511
0.429391
0.323003
0.43345
0.720951
1.11614
0.999473
0.0389722
0.959532
0.446845
0.814786
0.0356966
0.00273382
0.405418
0.152316
0.391791
1.21223
1.02244
0.239528
0.45135
0.955034
0.00932561
0.0435235
0.480916
1.10975
0.244961
0.972685
0.198608
0.0778225
0.744985
0.058044
0.0654654
0.0946038
0.207964
0.467521
0.0250126
0.477028
1.11921
0.17068
0.149732
0.141867
0.199693
0.0256908
1.41601
0.443894
0.0260938
0.512721
0.583594
0.480914
0.737826
1.50012
0.0511721
0.392586
0.272568
0.831151
1.00268
0.401255
0.0282685
0.896438
0.425942
0.074874
0.375715
0.231337
0.119058
0.301358
0.189458
0.0694729
0.0461938
0.196352
0.0692283
0.312632
0.483295
0.3313
0.417174
0.458191
0.16845
0.0566226
0.653249
0.405816
0.0846199
0.00208897
1.08318
0.596899
0.599068
0.751532
0.994257
0.333411
0.244692
0.709313
1.34257
0.945273
1.36997
0.0196091
1.4533
0.533894
0.157569
0.0310638
0.513828
0.0607987
0.00146947
0.253658
0.0473801
0.178317
0.134915
0.256689
0.154367
0.0280294
0.0572902
0.354886
0.215594
0.810766
0.753058
0.0897429
0.79294
0.0060883
0.188998
0.586357
0.088496
0.214224
0.339068
0.990434
0.0649906
0.00488317
0.648478
0.0889009
0.0260715
0.0751065
1.37238
0.468028
0.415826
0.314527
0.837376
0.0391376
0.0559316
0.2479
0.994133
0.284684
0.598757
0.145202
2.37326
0.208182
0.962966
0.391445
0.235432
0.435448
1.06765
0.264496
0.19678
0.0344625
0.202639
0.0502485
0.484025
0.857353
0.200069
0.0595785
1.32465
0.273463
0.225212
0.601789
0.262353
0.236214
0.200402
0.799725
0.23963
0.678217
0.260106
0.680168
0.751014
0.25166
0.730233
0.0184523
0.0876683
0.108809
0.146386
0.25328
0.399013
0.48037
0.128282
0.359463
0.0318248
0.198088
0.416643
0.653045
0.50363
0.491485
0.025486
0.0348423
0.858139
0.0634993
0.0342794
0.951422
0.409764
0.102166
0.184439
0.413108
0.154974
0.600188
0.688056
0.23522
0.137361
0.0267689
0.193169
0.158911
0.0420532
0.594201
1.13825
0.80906
0.0559117
0.171251
0.209967
0.372104
1.09044
0.257006
0.0291851
0.936808
0.312606
0.512919
0.00183068
0.237836
0.0318885
0.634254
0.340821
0.217506
0.176029
1.88835
0.112918
0.0787542
0.155159
0.0524067
0.0341796
0.172943
0.280137
0.0792235
0.430372
0.261439
0.73563
0.0949679
0.0667134
0.665657
0.35709
0.0919602
0.645242
0.0385712
0.00471095
1.07686
0.0891634
0.286884
1.44992
0.180876
0.164404
1.08594
0.0521065
0.193153
0.00638322
0.121094
0.642643
0.216997
0.0610307
0.476355
0.085372
0.872874
0.298697
1.09896
0.233019
0.0340504
0.897184
0.684183
0.271118
0.750745
0.923867
0.37557
0.0150704
0.718454
0.515663
0.484148
1.20197
0.812373
0.242283
0.230232
2.01513
0.0829772
0.410858
0.942172
0.0299165
0.255038
0.431412
0.373455
0.190001
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rng_get_integer.c0000644000175100001710000000324400000000000026636 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2021  The igraph development team

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {
    int i;

    /* Seed the RNG, generate 10 random integers */
    igraph_rng_seed(igraph_rng_default(), 42);
    for (i = 0; i < 10; i++) {
        printf("%ld\n", igraph_rng_get_integer(igraph_rng_default(), 10, 100));
    }

    printf("========\n");

    /* Seed the RNG again with the same seed, verify that we get the same
     * numbers */
    igraph_rng_seed(igraph_rng_default(), 42);
    for (i = 0; i < 10; i++) {
        printf("%ld\n", igraph_rng_get_integer(igraph_rng_default(), 10, 100));
    }

    printf("========\n");

    /* Seed the RNG again with a different seed, verify that we get different
     * numbers */
    igraph_rng_seed(igraph_rng_default(), 84);
    for (i = 0; i < 10; i++) {
        printf("%ld\n", igraph_rng_get_integer(igraph_rng_default(), 10, 100));
    }

    printf("========\n");

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_rng_get_integer.out0000644000175100001710000000016600000000000027223 0ustar00runnerdocker0000000000000044
82
96
26
76
80
64
64
24
50
========
44
82
96
26
76
80
64
64
24
50
========
14
60
43
53
32
38
67
43
100
76
========
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_running_mean.c0000644000175100001710000000420400000000000026151 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_vector_t data, result;

    igraph_set_error_handler(igraph_error_handler_ignore);
    igraph_vector_init_int(&result, 0);

    printf("No values, binwidth 0 should fail.\n");
    igraph_vector_init_int(&data, 0);
    IGRAPH_ASSERT(igraph_running_mean(&data, &result, /*binwidth*/ 0) == IGRAPH_EINVAL);
    igraph_vector_destroy(&data);

    printf("No values, binwidth 1 should fail.\n");
    igraph_vector_init_int(&data, 0);
    IGRAPH_ASSERT(igraph_running_mean(&data, &result, /*binwidth*/ 1) == IGRAPH_EINVAL);
    igraph_vector_destroy(&data);

    printf("One value, binwidth 1:\n");
    igraph_vector_init_int(&data, 1, 1);
    IGRAPH_ASSERT(igraph_running_mean(&data, &result, /*binwidth*/ 1) == IGRAPH_SUCCESS);
    print_vector(&result);
    igraph_vector_destroy(&data);

    printf("1, 2, 3, 4, 5, binwidth 1:\n");
    igraph_vector_init_int(&data, 5, 1, 2, 3, 4, 5);
    IGRAPH_ASSERT(igraph_running_mean(&data, &result, /*binwidth*/ 1) == IGRAPH_SUCCESS);
    print_vector(&result);
    igraph_vector_destroy(&data);

    printf("1, 2, 3, 4, 5, binwidth 2:\n");
    igraph_vector_init_int(&data, 5, 1, 2, 3, 4, 5);
    IGRAPH_ASSERT(igraph_running_mean(&data, &result, /*binwidth*/ 2) == IGRAPH_SUCCESS);
    print_vector(&result);
    igraph_vector_destroy(&data);

    igraph_vector_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_running_mean.out0000644000175100001710000000027300000000000026540 0ustar00runnerdocker00000000000000No values, binwidth 0 should fail.
No values, binwidth 1 should fail.
One value, binwidth 1:
( 1 )
1, 2, 3, 4, 5, binwidth 1:
( 1 2 3 4 5 )
1, 2, 3, 4, 5, binwidth 2:
( 1.5 2.5 3.5 4.5 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sbm_game.c0000644000175100001710000001151600000000000025247 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_integer_t n, igraph_matrix_t *pref_matrix, igraph_vector_int_t *block_sizes, igraph_bool_t directed, igraph_bool_t loops) {
    igraph_t result;
    IGRAPH_ASSERT(igraph_sbm_game(&result, n, pref_matrix, block_sizes, directed, loops) == IGRAPH_SUCCESS);
    print_graph_canon(&result);
    printf("\n");
    igraph_destroy(&result);
}


int main() {
    igraph_t result;
    igraph_matrix_t pref_matrix_0, pref_matrix_1, pref_matrix_3, pref_matrix_3u, pref_matrix_nonsq, pref_matrix_oor, pref_matrix_nsym;
    igraph_vector_int_t block_sizes_0, block_sizes_1, block_sizes_3, block_sizes_neg;

    igraph_matrix_init(&pref_matrix_0, 0, 0);

    igraph_matrix_init(&pref_matrix_1, 1, 1);
    MATRIX(pref_matrix_1, 0, 0) = 1;

    igraph_matrix_init(&pref_matrix_3, 3, 3);
    igraph_matrix_null(&pref_matrix_3);
    MATRIX(pref_matrix_3, 0, 1) = 1;
    MATRIX(pref_matrix_3, 2, 2) = 1;

    igraph_matrix_init(&pref_matrix_3u, 3, 3);
    igraph_matrix_null(&pref_matrix_3u);
    MATRIX(pref_matrix_3u, 0, 1) = 1;
    MATRIX(pref_matrix_3u, 1, 0) = 1;
    MATRIX(pref_matrix_3u, 2, 2) = 1;

    igraph_matrix_init(&pref_matrix_nonsq, 3, 2);

    igraph_matrix_init(&pref_matrix_oor, 3, 3);
    igraph_matrix_null(&pref_matrix_oor);
    MATRIX(pref_matrix_oor, 0, 1) = 10;

    igraph_matrix_init(&pref_matrix_nsym, 3, 3);
    igraph_matrix_null(&pref_matrix_nsym);
    MATRIX(pref_matrix_nsym, 0, 1) = 1;

    igraph_vector_int_init_int(&block_sizes_0, 0);
    igraph_vector_int_init_int(&block_sizes_1, 1, 1);
    igraph_vector_int_init_int(&block_sizes_3, 3, 2, 2, 2);
    igraph_vector_int_init_int(&block_sizes_neg, 3, 2, 2, -2);

    printf("No vertices.\n");
    call_and_print(0, &pref_matrix_0, &block_sizes_0, 0, 0);

    printf("One vertex, directed, with loops.\n");
    call_and_print(1, &pref_matrix_1, &block_sizes_1, 1, 1);

    printf("Six vertices, directed, only edges from block 0 to 1 and 2 to 2.\n");
    call_and_print(6, &pref_matrix_3, &block_sizes_3, 1, 1);

    printf("Six vertices, directed, only edges from block 0 to 1 and 2 to 2, no loops.\n");
    call_and_print(6, &pref_matrix_3, &block_sizes_3, 1, 0);

    printf("Six vertices, undirected, only edges between block 0 and 1, and inside block 2.\n");
    call_and_print(6, &pref_matrix_3u, &block_sizes_3, 0, 1);

    printf("Six vertices, undirected, only edges between block 0 and 1, and inside block 2, no loops.\n");
    call_and_print(6, &pref_matrix_3u, &block_sizes_3, 0, 0);

    VERIFY_FINALLY_STACK();

    printf("Check for nonsquare matrix error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 6, &pref_matrix_nonsq, &block_sizes_3, 0, 0), IGRAPH_NONSQUARE);

    printf("Check for preference matrix probability out of range error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 6, &pref_matrix_oor, &block_sizes_3, 0, 0), IGRAPH_EINVAL);

    printf("Check for nonsymmetric preference matrix for undirected graph error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 6, &pref_matrix_nsym, &block_sizes_3, 0, 0), IGRAPH_EINVAL);

    printf("Check for incorrect block size vector error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 6, &pref_matrix_3, &block_sizes_1, 1, 0), IGRAPH_EINVAL);

    printf("Check for negative block size error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 6, &pref_matrix_3, &block_sizes_neg, 1, 0), IGRAPH_EINVAL);

    printf("Check for sum of block sizes not equal to number of vertices error handling.\n");
    CHECK_ERROR(igraph_sbm_game(&result, 3, &pref_matrix_3, &block_sizes_3, 1, 0), IGRAPH_EINVAL);

    igraph_matrix_destroy(&pref_matrix_0);
    igraph_matrix_destroy(&pref_matrix_1);
    igraph_matrix_destroy(&pref_matrix_3);
    igraph_matrix_destroy(&pref_matrix_3u);
    igraph_matrix_destroy(&pref_matrix_oor);
    igraph_matrix_destroy(&pref_matrix_nsym);
    igraph_matrix_destroy(&pref_matrix_nonsq);
    igraph_vector_int_destroy(&block_sizes_0);
    igraph_vector_int_destroy(&block_sizes_1);
    igraph_vector_int_destroy(&block_sizes_3);
    igraph_vector_int_destroy(&block_sizes_neg);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sbm_game.out0000644000175100001710000000204100000000000025625 0ustar00runnerdocker00000000000000No vertices.
directed: false
vcount: 0
edges: {
}

One vertex, directed, with loops.
directed: true
vcount: 1
edges: {
0 0
}

Six vertices, directed, only edges from block 0 to 1 and 2 to 2.
directed: true
vcount: 6
edges: {
0 2
0 3
1 2
1 3
4 4
4 5
5 4
5 5
}

Six vertices, directed, only edges from block 0 to 1 and 2 to 2, no loops.
directed: true
vcount: 6
edges: {
0 2
0 3
1 2
1 3
4 5
5 4
}

Six vertices, undirected, only edges between block 0 and 1, and inside block 2.
directed: false
vcount: 6
edges: {
0 2
0 3
1 2
1 3
4 4
4 5
5 5
}

Six vertices, undirected, only edges between block 0 and 1, and inside block 2, no loops.
directed: false
vcount: 6
edges: {
0 2
0 3
1 2
1 3
4 5
}

Check for nonsquare matrix error handling.
Check for preference matrix probability out of range error handling.
Check for nonsymmetric preference matrix for undirected graph error handling.
Check for incorrect block size vector error handling.
Check for negative block size error handling.
Check for sum of block sizes not equal to number of vertices error handling.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_set_progress_handler.c0000644000175100001710000000272200000000000027710 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int handler(const char* message, igraph_real_t percent, void*data) {
    printf("handler, %s, %f, %d\n", message, percent, *(int*)data);
    return IGRAPH_SUCCESS;
}

int main() {
    igraph_set_progress_handler(handler);
    int data = 10;

    printf("progress with set progress handler:\n");
    IGRAPH_PROGRESS("message", 100.0, &data);

    igraph_progress_handler_t *previous = igraph_set_progress_handler(NULL);

    printf("\nprogress with no handler:\n");
    IGRAPH_PROGRESS("message", 100.0, &data);

    igraph_set_progress_handler(previous);

    printf("\nprogress with previous handler:\n");
    IGRAPH_PROGRESS("message", 100.0, &data);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_set_progress_handler.out0000644000175100001710000000024200000000000030270 0ustar00runnerdocker00000000000000progress with set progress handler:
handler, message, 100.000000, 10

progress with no handler:

progress with previous handler:
handler, message, 100.000000, 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_shortest_paths_johnson.c0000644000175100001710000000626600000000000030313 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g_empty, g_empty_dir, g_lm;
    igraph_matrix_t result;
    igraph_vs_t vids;
    igraph_vector_t weights_empty, weights_lm, weights_lm_neg_loop;

    igraph_matrix_init(&result, 0, 0);
    igraph_vs_all(&vids);
    igraph_vector_init(&weights_empty, 0);
    igraph_vector_init_int(&weights_lm_neg_loop, 9, -4, -3, -2, -1, 0, 1, 2, 3, 4);
    igraph_vector_init_int(&weights_lm, 9, -1, 0, 1, -2, 2, 3, 4, 5, 6);
    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_empty_dir, 0, 1, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,2, 1,3, 2,0, 2,3, 3,4, 3,4, -1);

    igraph_set_error_handler(igraph_error_handler_printignore);

    printf("No vertices, not directed:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_empty, &result, vids, vids, &weights_empty) == IGRAPH_SUCCESS);
    print_matrix(&result);

    printf("No vertices, directed:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_empty_dir, &result, vids, vids, &weights_empty) == IGRAPH_SUCCESS);
    print_matrix(&result);

    printf("Directed graph with loops and multi-edges with negative loop:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_lm, &result, vids, vids, &weights_lm_neg_loop) == IGRAPH_ENEGLOOP);

    printf("Directed graph with loops and multi-edges:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_lm, &result, vids, vids, &weights_lm) == IGRAPH_SUCCESS);
    print_matrix(&result);

    printf("Directed graph with loops and multi-edges, select vertices 1 and 2:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_lm, &result, igraph_vss_seq(1, 2), igraph_vss_seq(1, 2), &weights_lm) == IGRAPH_SUCCESS);
    print_matrix(&result);

    printf("Directed graph with loops and multi-edges, select 0 -> 2:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_lm, &result, igraph_vss_1(0), igraph_vss_1(2), &weights_lm) == IGRAPH_SUCCESS);
    print_matrix(&result);

    printf("Directed graph with loops and multi-edges, select none:\n");
    IGRAPH_ASSERT(igraph_shortest_paths_johnson(&g_lm, &result, igraph_vss_none(), igraph_vss_none(), &weights_lm) == IGRAPH_SUCCESS);
    print_matrix(&result);

    igraph_matrix_destroy(&result);
    igraph_destroy(&g_empty);
    igraph_destroy(&g_empty_dir);
    igraph_destroy(&g_lm);
    igraph_vector_destroy(&weights_empty);
    igraph_vector_destroy(&weights_lm);
    igraph_vector_destroy(&weights_lm_neg_loop);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_shortest_paths_johnson.out0000644000175100001710000000133200000000000030665 0ustar00runnerdocker00000000000000No vertices, not directed:
No vertices, directed:
Directed graph with loops and multi-edges with negative loop:
Directed graph with loops and multi-edges:
[        0       -1       -3        1        6      Inf
         1        0       -2        2        7      Inf
         3        2        0        4        9      Inf
       Inf      Inf      Inf        0        5      Inf
       Inf      Inf      Inf      Inf        0      Inf
       Inf      Inf      Inf      Inf      Inf        0 ]
Directed graph with loops and multi-edges, select vertices 1 and 2:
[        0       -2
         2        0 ]
Directed graph with loops and multi-edges, select 0 -> 2:
[       -3 ]
Directed graph with loops and multi-edges, select none:
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_simple_interconnected_islands_game.c0000644000175100001710000000722200000000000032557 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No islands:\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/0, /*size of islands*/ 1,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("One island, no edges:\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/1, /*size of islands*/ 4,
                  /*islands_pin*/ 0, /*number of edges between two islands*/ 2) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("One island, full graph:\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/1, /*size of islands*/ 4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 2) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Two islands, full graphs, no connections between islands:\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/2, /*size of islands*/ 4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 0) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Three islands, full graphs, 20 connections between islands.\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/3, /*size of islands*/ 4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 20) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_ecount(&g) == 18 + 60);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative number of islands.\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/-2, /*size of islands*/ 4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 0) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Negative island size.\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/2, /*size of islands*/ -4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ 0) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Probability out of range.\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/2, /*size of islands*/ 4,
                  /*islands_pin*/ 2, /*number of edges between two islands*/ 0) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Negative number of edges between islands.\n");
    IGRAPH_ASSERT(igraph_simple_interconnected_islands_game(&g, /*number of islands*/2, /*size of islands*/ 4,
                  /*islands_pin*/ 1, /*number of edges between two islands*/ -3) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_simple_interconnected_islands_game.out0000644000175100001710000000100200000000000033132 0ustar00runnerdocker00000000000000No islands:
directed: false
vcount: 0
edges: {
}
One island, no edges:
directed: false
vcount: 4
edges: {
}
One island, full graph:
directed: false
vcount: 4
edges: {
0 1
0 2
0 3
1 2
1 3
2 3
}
Two islands, full graphs, no connections between islands:
directed: false
vcount: 8
edges: {
0 1
0 2
0 3
1 2
1 3
2 3
4 5
4 6
4 7
5 6
5 7
6 7
}
Three islands, full graphs, 20 connections between islands.
Negative number of islands.
Negative island size.
Probability out of range.
Negative number of edges between islands.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sir.c0000644000175100001710000000550100000000000024267 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_sir(igraph_sir_t *sir) {
    printf("times: ");
    print_vector(&sir->times);
    printf("susceptibles: ");
    print_vector_int(&sir->no_s);
    printf("infected: ");
    print_vector_int(&sir->no_i);
    printf("recovered: ");
    print_vector_int(&sir->no_r);
}


void print_result(igraph_t *g, igraph_real_t beta, igraph_real_t gamma, igraph_integer_t no_sim) {
    igraph_vector_ptr_t result;
    igraph_vector_ptr_init(&result, 0);
    IGRAPH_ASSERT(igraph_sir(g, beta, gamma, no_sim, &result) == IGRAPH_SUCCESS);
    for (int i = 0; i < igraph_vector_ptr_size(&result); i++) {
        print_sir(VECTOR(result)[i]);
        igraph_sir_destroy(VECTOR(result)[i]);
    }
    igraph_vector_ptr_destroy_all(&result);
    printf("\n");
}

int main() {
    igraph_t g_empty, g_lm, g_line, g_1, g_2, g_full;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&g_empty, 0, 0, -1);
    igraph_small(&g_lm, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_2, 2, 0, -1);
    igraph_small(&g_line, 5, 0, 0,1, 1,2, 2,3, 3,4, -1);
    igraph_full(&g_full, 5, 0, IGRAPH_NO_LOOPS);

    printf("Only one person, low recovery rate:\n");
    print_result(&g_1, 0.1, 0.0001, 2);

    printf("Two people, not connected, only one infection expected:\n");
    print_result(&g_2, 1, 1, 2);

    printf("Line:\n");
    print_result(&g_line, 1, 1, 2);

    printf("Line, low infection rate, few infections expected:\n");
    print_result(&g_line, 0.0001, 1, 2);

    printf("Full graph, more infections expected than line with same rates:\n");
    print_result(&g_full, 1, 1, 2);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    IGRAPH_ASSERT(igraph_sir(&g_lm, 1, 1, 1, NULL) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_sir(&g_empty, 1, 1, 1, NULL) == IGRAPH_EINVAL);

    igraph_destroy(&g_empty);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_line);
    igraph_destroy(&g_1);
    igraph_destroy(&g_2);
    igraph_destroy(&g_full);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sir.out0000644000175100001710000000256400000000000024662 0ustar00runnerdocker00000000000000Only one person, low recovery rate:
times: ( 0 5930.86 )
susceptibles: ( 0 0 )
infected: ( 1 0 )
recovered: ( 0 1 )
times: ( 0 4639.88 )
susceptibles: ( 0 0 )
infected: ( 1 0 )
recovered: ( 0 1 )

Two people, not connected, only one infection expected:
times: ( 0 0.1937 )
susceptibles: ( 1 1 )
infected: ( 1 0 )
recovered: ( 0 1 )
times: ( 0 1.63425 )
susceptibles: ( 1 1 )
infected: ( 1 0 )
recovered: ( 0 1 )

Line:
times: ( 0 0.462228 0.971971 1.04742 2.13843 2.13856 2.18094 2.23045 )
susceptibles: ( 4 3 2 2 1 1 1 1 )
infected: ( 1 2 3 2 3 2 1 0 )
recovered: ( 0 0 0 1 1 2 3 4 )
times: ( 0 1.31391 1.3263 1.97259 3.60554 3.76688 )
susceptibles: ( 4 3 3 2 2 2 )
infected: ( 1 2 1 2 1 0 )
recovered: ( 0 0 1 1 2 3 )

Line, low infection rate, few infections expected:
times: ( 0 0.236725 )
susceptibles: ( 4 4 )
infected: ( 1 0 )
recovered: ( 0 1 )
times: ( 0 0.0284632 )
susceptibles: ( 4 4 )
infected: ( 1 0 )
recovered: ( 0 1 )

Full graph, more infections expected than line with same rates:
times: ( 0 0.145069 0.190146 0.268184 0.316989 0.522791 1.39469 1.91247 2.09574 2.31573 )
susceptibles: ( 4 3 2 1 1 0 0 0 0 0 )
infected: ( 1 2 3 4 3 4 3 2 1 0 )
recovered: ( 0 0 0 0 1 1 2 3 4 5 )
times: ( 0 0.574604 0.597026 0.633142 0.750641 0.758668 0.782023 1.40373 1.55961 2.83335 )
susceptibles: ( 4 3 2 1 0 0 0 0 0 0 )
infected: ( 1 2 3 4 5 4 3 2 1 0 )
recovered: ( 0 0 0 0 0 1 2 3 4 5 )

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_solve_lsap.c0000644000175100001710000000422300000000000025641 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_vector_int_t result;
    igraph_matrix_t m_pdc, m_0, m_m34, m_m43;
    int pdc[] = {9, 2, 7, 8,
                 6, 4, 3, 7,
                 5, 8, 1, 8,
                 7, 6, 9, 4};
    int m34[] = {3, 3, 2, 3,
                 2, 3, 3, 3,
                 3, 2, 3, 3};
    int m43[] = {3, 3, 2,
                 2, 3, 3,
                 3, 2, 3,
                 2, 3, 3};
    igraph_vector_int_init(&result, 0);
    matrix_init_int_row_major(&m_pdc, 4, 4, pdc);
    matrix_init_int_row_major(&m_m34, 3, 4, m34);
    matrix_init_int_row_major(&m_m43, 4, 3, m43);
    igraph_matrix_init(&m_0, 0, 0);

    printf("4 tasks, 4 agents:\n");
    igraph_solve_lsap(&m_pdc, 4, &result);
    print_vector_int(&result);

    printf("\n0 tasks, 0 agents:\n");
    igraph_solve_lsap(&m_0, 0, &result);
    print_vector_int(&result);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("\n4 tasks, 3 agents, n = 4.\n");
    IGRAPH_ASSERT(igraph_solve_lsap(&m_m34, 4, &result) == IGRAPH_EINVAL);

    printf("\n3 tasks, 4 agents, n = 4.\n");
    IGRAPH_ASSERT(igraph_solve_lsap(&m_m43, 4, &result) == IGRAPH_EINVAL);

    igraph_vector_int_destroy(&result);
    igraph_matrix_destroy(&m_pdc);
    igraph_matrix_destroy(&m_0);
    igraph_matrix_destroy(&m_m34);
    igraph_matrix_destroy(&m_m43);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_solve_lsap.out0000644000175100001710000000015500000000000026226 0ustar00runnerdocker000000000000004 tasks, 4 agents:
( 1 0 2 3 )

0 tasks, 0 agents:
( )

4 tasks, 3 agents, n = 4.

3 tasks, 4 agents, n = 4.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat2.c0000644000175100001710000001751200000000000025560 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#define NCOMPLEX  /* to make it compile with MSVC on Windows */

#include 
#include 
#include "linalg/blas_internal.h"
#include "linalg/arpack_internal.h"

#include "test_utilities.inc"

int igraph_matrix_dgemv(const igraph_matrix_t *m,
                        const igraph_vector_t *v,
                        igraph_vector_t *res,
                        igraph_real_t alpha,
                        igraph_real_t beta,
                        igraph_bool_t transpose_m) {

    int nrow = igraph_matrix_nrow(m);
    int ncol = igraph_matrix_ncol(m);
    long int vlen = igraph_vector_size(v);
    int one = 1;
    char t = transpose_m ? 't' : 'n';
    long int input_len  = transpose_m ? nrow : ncol;
    long int output_len = transpose_m ? ncol : nrow;

    if (vlen != input_len) {
        IGRAPH_ERROR("Matrix and vector sizes are incompatible", IGRAPH_EINVAL);
    }

    if (beta != 0 && igraph_vector_size(res) != output_len) {
        IGRAPH_ERROR("Non-zero beta and bad `res' vector size, possible mistake",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_resize(res, output_len));

    igraphdgemv_(&t, &nrow, &ncol, &alpha, &MATRIX(*m, 0, 0),
                 &nrow, VECTOR(*v), &one, &beta, VECTOR(*res), &one);

    return 0;
}

int igraph_matrix_vector_prod(const igraph_matrix_t *m,
                              const igraph_vector_t *v,
                              igraph_vector_t *res) {
    return igraph_matrix_dgemv(m, v, res, 1.0, 0.0, /*transpose=*/ 0);
}

int my_dgemv(const igraph_matrix_t *m,
             const igraph_vector_t *v,
             igraph_vector_t *res,
             igraph_real_t alpha,
             igraph_real_t beta,
             igraph_bool_t transpose_m) {

    int nrow = igraph_matrix_nrow(m);
    int ncol = igraph_matrix_ncol(m);
    long int vlen = igraph_vector_size(v);
    int one = 1;
    char t = transpose_m ? 't' : 'n';
    long int input_len  = transpose_m ? nrow : ncol;
    long int output_len = transpose_m ? ncol : nrow;

    if (vlen != input_len) {
        IGRAPH_ERROR("Matrix and vector sizes are incompatible", IGRAPH_EINVAL);
    }

    if (beta != 0 && igraph_vector_size(res) != output_len) {
        IGRAPH_ERROR("Non-zero beta and bad `res' vector size, possible mistake",
                     IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_vector_resize(res, output_len));

    igraphdgemv_(&t, &nrow, &ncol, &alpha, &MATRIX(*m, 0, 0),
                 &nrow, VECTOR(*v), &one, &beta, VECTOR(*res), &one);

    return 0;
}

int my_gaxpy(const igraph_matrix_t *m,
             const igraph_vector_t *v,
             igraph_vector_t *res) {
    return my_dgemv(m, v, res, 1.0, 0.0, /*transpose=*/ 0);
}

int my_dgemm(const igraph_matrix_t *m1,
             const igraph_matrix_t *m2,
             igraph_matrix_t *res) {

    long int m1_r = igraph_matrix_nrow(m1);
    long int m1_c = igraph_matrix_ncol(m1);
    long int m2_r = igraph_matrix_nrow(m2);
    long int m2_c = igraph_matrix_ncol(m2);
    long int i, j, k;

    if (m1_c != m2_r) {
        IGRAPH_ERROR("Cannot multiply matrices, invalid dimensions", IGRAPH_EINVAL);
    }

    IGRAPH_CHECK(igraph_matrix_resize(res, m1_r, m2_c));
    igraph_matrix_null(res);

    for (i = 0; i < m1_r; i++) {
        for (j = 0; j < m2_c; j++) {
            for (k = 0; k < m1_c /* which is also m2_r*/; k++) {
                MATRIX(*res, i, j) += MATRIX(*m1, i, k) * MATRIX(*m2, k, j);
            }
        }
    }

    return 0;
}

igraph_bool_t check_same(const igraph_sparsemat_t *A,
                         const igraph_matrix_t *M) {

    long int nrow = igraph_sparsemat_nrow(A);
    long int ncol = igraph_sparsemat_ncol(A);
    long int j, p, nzero = 0;

    if (nrow != igraph_matrix_nrow(M) ||
        ncol != igraph_matrix_ncol(M)) {
        return 0;
    }

    for (j = 0; j < A->cs->n; j++) {
        for (p = A->cs->p[j]; p < A->cs->p[j + 1]; p++) {
            long int to = A->cs->i[p];
            igraph_real_t value = A->cs->x[p];
            if (value != MATRIX(*M, to, j)) {
                return 0;
            }
            nzero += 1;
        }
    }

    for (j = 0; j < nrow; j++) {
        for (p = 0; p < ncol; p++) {
            if (MATRIX(*M, j, p) != 0) {
                nzero -= 1;
            }
        }
    }

    return nzero == 0;
}

int main() {

    igraph_sparsemat_t A, B, C, D;
    igraph_vector_t v, w, x, y;
    igraph_matrix_t M, N, O;
    long int i;

    srand(1);

    /* Matrix-vector product */
#define NROW 10
#define NCOL 5
#define EDGES NROW*NCOL/3
    igraph_matrix_init(&M, NROW, NCOL);
    igraph_sparsemat_init(&A, NROW, NCOL, EDGES);
    for (i = 0; i < EDGES; i++) {
        long int r = RNG_INTEGER(0, NROW - 1);
        long int c = RNG_INTEGER(0, NCOL - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(M, r, c) = MATRIX(M, r, c) + value;
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_init(&v, NCOL);
    igraph_vector_init(&w, NCOL);
    for (i = 0; i < NCOL; i++) {
        VECTOR(v)[i] = VECTOR(w)[i] = RNG_INTEGER(1, 5);
    }

    igraph_vector_init(&x, NROW);
    igraph_vector_init(&y, NROW);
    my_gaxpy(&M, &v, &x);
    igraph_vector_null(&y);
    igraph_sparsemat_gaxpy(&B, &w, &y);

    if (!igraph_vector_all_e(&x, &y)) {
        return 1;
    }

    igraph_vector_destroy(&x);
    igraph_vector_destroy(&y);
    igraph_vector_destroy(&v);
    igraph_vector_destroy(&w);
    igraph_sparsemat_destroy(&B);
    igraph_matrix_destroy(&M);

#undef NROW
#undef NCOL
#undef EDGES

    /* Matrix-matrix product */
#define NROW_A 10
#define NCOL_A 7
#define EDGES_A NROW_A*NCOL_A/3
#define NROW_B 7
#define NCOL_B 9
#define EDGES_B NROW_B*NCOL_B/3
    igraph_matrix_init(&M, NROW_A, NCOL_A);
    igraph_sparsemat_init(&A, NROW_A, NCOL_A, EDGES_A);
    for (i = 0; i < EDGES_A; i++) {
        long int r = RNG_INTEGER(0, NROW_A - 1);
        long int c = RNG_INTEGER(0, NCOL_A - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(M, r, c) = MATRIX(M, r, c) + value;
        igraph_sparsemat_entry(&A, r, c, value);
    }
    igraph_sparsemat_compress(&A, &C);
    igraph_sparsemat_destroy(&A);

    igraph_matrix_init(&N, NROW_B, NCOL_B);
    igraph_sparsemat_init(&B, NROW_B, NCOL_B, EDGES_B);
    for (i = 0; i < EDGES_B; i++) {
        long int r = RNG_INTEGER(0, NROW_B - 1);
        long int c = RNG_INTEGER(0, NCOL_B - 1);
        igraph_real_t value = RNG_INTEGER(1, 5);
        MATRIX(N, r, c) = MATRIX(N, r, c) + value;
        igraph_sparsemat_entry(&B, r, c, value);
    }
    igraph_sparsemat_compress(&B, &D);
    igraph_sparsemat_destroy(&B);

    igraph_matrix_init(&O, 0, 0);
    my_dgemm(&M, &N, &O);
    igraph_sparsemat_multiply(&C, &D, &A);

    if (! check_same(&A, &O)) {
        return 2;
    }

    igraph_sparsemat_destroy(&C);
    igraph_sparsemat_destroy(&D);
    igraph_sparsemat_destroy(&A);
    igraph_matrix_destroy(&M);
    igraph_matrix_destroy(&N);
    igraph_matrix_destroy(&O);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat2.out0000644000175100001710000000000000000000000026125 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat5.c0000644000175100001710000003126300000000000025562 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2009-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define EPS 1e-13


/* Generic test for 1x1 matrices */
void test_1x1(igraph_real_t value) {
    igraph_sparsemat_t A, B;
    igraph_matrix_t values, vectors;
    igraph_vector_t values2;
    igraph_arpack_options_t options;

    igraph_arpack_options_init(&options);

    igraph_sparsemat_init(&A, 1, 1, 1);
    igraph_sparsemat_entry(&A, 0, 0, value);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_matrix_init(&values, 0, 0);
    igraph_matrix_init(&vectors, 0, 0);
    options.mode = 1;
    igraph_sparsemat_arpack_rnsolve(&B, &options, /*storage=*/ 0,
                                    &values, &vectors);
    printf("rnsolve:\n  - eigenvalues:\n");
    print_matrix(&values);
    printf("  - eigenvectors:\n");
    print_matrix(&vectors);
    igraph_matrix_destroy(&values);
    igraph_matrix_destroy(&vectors);

    igraph_vector_init(&values2, 0);
    igraph_matrix_init(&vectors, 0, 0);
    options.mode = 1;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values2, &vectors, IGRAPH_SPARSEMAT_SOLVE_LU);
    printf("rssolve:\n  - eigenvalues:\n");
    print_vector(&values2);
    printf("  - eigenvectors:\n");
    print_matrix(&vectors);
    igraph_vector_destroy(&values2);
    igraph_matrix_destroy(&vectors);

    igraph_sparsemat_destroy(&B);
}

/* Generic test for 2x2 matrices */
void test_2x2(igraph_real_t a, igraph_real_t b, igraph_real_t c, igraph_real_t d) {
    igraph_sparsemat_t A, B;
    igraph_matrix_t values, vectors;
    igraph_vector_t values2;
    igraph_arpack_options_t options;

    igraph_arpack_options_init(&options);
    options.mode = 1;
    options.nev = 2;

    igraph_sparsemat_init(&A, 2, 2, 4);
    igraph_sparsemat_entry(&A, 0, 0, a);
    igraph_sparsemat_entry(&A, 0, 1, b);
    igraph_sparsemat_entry(&A, 1, 0, c);
    igraph_sparsemat_entry(&A, 1, 1, d);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_matrix_init(&values, 0, 0);
    igraph_matrix_init(&vectors, 0, 0);
    igraph_sparsemat_arpack_rnsolve(&B, &options, /*storage=*/ 0,
                                    &values, &vectors);
    printf("rnsolve:\n  - eigenvalues:\n");
    print_matrix(&values);
    printf("  - eigenvectors:\n");
    print_matrix(&vectors);
    igraph_matrix_destroy(&values);
    igraph_matrix_destroy(&vectors);

    if (b == c) {
        igraph_vector_init(&values2, 0);
        igraph_matrix_init(&vectors, 0, 0);
        igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                        &values2, &vectors, IGRAPH_SPARSEMAT_SOLVE_QR);
        printf("rssolve:\n  - eigenvalues:\n");
        print_vector(&values2);
        printf("  - eigenvectors:\n");
        print_matrix(&vectors);
        igraph_vector_destroy(&values2);
        igraph_matrix_destroy(&vectors);
    }

    igraph_sparsemat_destroy(&B);
}

int main() {

    igraph_sparsemat_t A, B;
    igraph_matrix_t vectors, values2;
    igraph_vector_t values;
    long int i;
    igraph_arpack_options_t options;
    igraph_real_t min, max;
    igraph_t g1, g2, g3;

    /***********************************************************************/

    /* Identity matrix */
    printf("== Identity matrix ==\n");
#define DIM 10
    igraph_sparsemat_init(&A, DIM, DIM, DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, 1.0);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_init(&values, 0);
    igraph_arpack_options_init(&options);

    options.mode = 1;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ 0, /*solvemethod=*/0);
    IGRAPH_ASSERT(VECTOR(values)[0] == 1.0);

    options.mode = 3;
    options.sigma = 2;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ 0,
                                    IGRAPH_SPARSEMAT_SOLVE_LU);
    IGRAPH_ASSERT(VECTOR(values)[0] == 1.0);

    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ 0,
                                    IGRAPH_SPARSEMAT_SOLVE_QR);
    IGRAPH_ASSERT(VECTOR(values)[0] == 1.0);

    igraph_vector_destroy(&values);
    igraph_sparsemat_destroy(&B);

#undef DIM

    /***********************************************************************/

    /* Diagonal matrix */
    printf("\n== Diagonal matrix ==\n");
#define DIM 10
    igraph_sparsemat_init(&A, DIM, DIM, DIM);
    for (i = 0; i < DIM; i++) {
        igraph_sparsemat_entry(&A, i, i, i + 1.0);
    }
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_init(&values, 0);
    igraph_matrix_init(&vectors, 0, 0);

    /* Regular mode */
    options.mode = 1;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ &vectors,
                                    /*solvemethod=*/ 0);
    if ( fabs(VECTOR(values)[0] - DIM) > EPS ) {
        printf("Regular: VECTOR(values)[0] numerical precision is only %g, should be %g",
               fabs((double)VECTOR(values)[0] - DIM), EPS);
        abort();
    }

    IGRAPH_ASSERT( fabs(fabs(MATRIX(vectors, DIM - 1, 0)) - 1.0) < EPS);

    MATRIX(vectors, DIM - 1, 0) = 0.0;
    igraph_matrix_minmax(&vectors, &min, &max);
    IGRAPH_ASSERT(fabs(min) < EPS);
    IGRAPH_ASSERT(fabs(max) < EPS);

    /* Shift and invert mode */
    options.mode = 3;
    options.sigma = 11;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ &vectors,
                                    IGRAPH_SPARSEMAT_SOLVE_LU);
    if ( fabs(VECTOR(values)[0] - DIM) > EPS ) {
        printf("Shift and invert, LU: VECTOR(values)[0] numerical precision is only %g, should be %g",
               fabs((double)VECTOR(values)[0] - DIM), EPS);
        abort();
    }
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, /*vectors=*/ &vectors,
                                    IGRAPH_SPARSEMAT_SOLVE_QR);
    if ( fabs(VECTOR(values)[0] - DIM) > EPS ) {
        printf("Shift and invert, QR: VECTOR(values)[0] numerical precision is only %g, should be %g",
               fabs((double)VECTOR(values)[0] - DIM), EPS);
        abort();
    }

    IGRAPH_ASSERT( fabs(fabs(MATRIX(vectors, DIM - 1, 0)) - 1.0) < EPS);

    MATRIX(vectors, DIM - 1, 0) = 0.0;
    igraph_matrix_minmax(&vectors, &min, &max);
    IGRAPH_ASSERT(fabs(min) < EPS);
    IGRAPH_ASSERT(fabs(max) < EPS);

    igraph_vector_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_sparsemat_destroy(&B);
#undef DIM

    /***********************************************************************/

    /* A tree, plus a ring */
    printf("\n== A tree, plus a ring ==\n");
#define DIM 10
    igraph_tree(&g1, DIM, /*children=*/ 2, IGRAPH_TREE_UNDIRECTED);
    igraph_ring(&g2, DIM, IGRAPH_UNDIRECTED, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_union(&g3, &g1, &g2, /*edge_map1=*/ 0, /*edge_map1=*/ 0);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    igraph_get_sparsemat(&g3, &A);
    igraph_destroy(&g3);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_vector_init(&values, 0);
    igraph_matrix_init(&vectors, 0, 0);

    /* Regular mode */
    options.mode = 1;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, &vectors, /*solvemethod=*/ 0);

    if (MATRIX(vectors, 0, 0) < 0.0) {
        igraph_matrix_scale(&vectors, -1.0);
    }

    printf("\nRegular:\n");
    printf("Eigenvalues:\n");
    print_vector(&values);
    printf("Eigenvectors:\n");
    print_matrix(&vectors);

    /* Shift and invert mode */
    options.mode = 3;
    options.sigma = VECTOR(values)[0] * 1.1;
    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, &vectors,
                                    IGRAPH_SPARSEMAT_SOLVE_LU);

    if (MATRIX(vectors, 0, 0) < 0.0) {
        igraph_matrix_scale(&vectors, -1.0);
    }
    printf("\nShift and invert, LU:\n");
    printf("Eigenvalues:\n");
    print_vector(&values);
    printf("Eigenvectors:\n");
    print_matrix(&vectors);

    igraph_sparsemat_arpack_rssolve(&B, &options, /*storage=*/ 0,
                                    &values, &vectors,
                                    IGRAPH_SPARSEMAT_SOLVE_QR);
    if (MATRIX(vectors, 0, 0) < 0.0) {
        igraph_matrix_scale(&vectors, -1.0);
    }
    printf("\nShift and invert, QR:\n");
    printf("Eigenvalues:\n");
    print_vector(&values);
    printf("Eigenvectors:\n");
    print_matrix(&vectors);

    igraph_vector_destroy(&values);
    igraph_matrix_destroy(&vectors);
    igraph_sparsemat_destroy(&B);
#undef DIM


    /***********************************************************************/

    /* A directed tree and a directed, mutual ring */
    printf("\n== A directed tree and a directed, mutual ring ==\n");
#define DIM 10
    igraph_tree(&g1, DIM, /*children=*/ 2, IGRAPH_TREE_OUT);
    igraph_ring(&g2, DIM, IGRAPH_DIRECTED, /*mutual=*/ 1, /*circular=*/ 1);
    igraph_union(&g3, &g1, &g2, /*edge_map1=*/ 0, /*edge_map2=*/ 0);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    igraph_get_sparsemat(&g3, &A);
    igraph_destroy(&g3);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_matrix_init(&values2, 0, 0);
    igraph_matrix_init(&vectors, 0, 0);

    /* Regular mode */
    options.mode = 1;
    igraph_sparsemat_arpack_rnsolve(&B, &options, /*storage=*/ 0,
                                    &values2, &vectors);

    if (MATRIX(vectors, 0, 0) < 0.0) {
        igraph_matrix_scale(&vectors, -1.0);
    }

    printf("\nRegular:\n");
    printf("Eigenvalues:\n");
    print_matrix(&values2);
    printf("Eigenvectors:\n");
    print_matrix(&vectors);

    igraph_matrix_destroy(&values2);
    igraph_matrix_destroy(&vectors);
    igraph_sparsemat_destroy(&B);
#undef DIM

    /***********************************************************************/

    /* A small test graph */
    printf("\n== A small test graph ==\n");

    igraph_small(&g1, 11, IGRAPH_DIRECTED,
                 0, 1, 1, 3, 1, 8, 2, 10, 3, 6, 3, 10, 4, 2, 5, 4,
                 6, 1, 6, 4, 7, 9, 8, 5, 8, 7, 9, 8, 10, 0,
                 -1);

    igraph_get_sparsemat(&g1, &A);
    igraph_destroy(&g1);
    igraph_sparsemat_compress(&A, &B);
    igraph_sparsemat_destroy(&A);

    igraph_matrix_init(&values2, 0, 0);
    igraph_matrix_init(&vectors, 0, 0);

    /* Regular mode */
    options.mode = 1;
    igraph_sparsemat_arpack_rnsolve(&B, &options, /*storage=*/ 0,
                                    &values2, &vectors);

    if (MATRIX(vectors, 0, 0) < 0.0) {
        igraph_matrix_scale(&vectors, -1.0);
    }

    printf("\nRegular:\n");
    printf("Eigenvalues:\n");
    print_matrix(&values2);
    printf("Eigenvectors:\n");
    print_matrix(&vectors);

    igraph_matrix_destroy(&values2);
    igraph_matrix_destroy(&vectors);
    igraph_sparsemat_destroy(&B);

    /***********************************************************************/

    /* Testing the special case solver for 1x1 matrices */
    printf("\n== Testing the special case solver for 1x1 matrices ==\n");
    test_1x1(2);
    test_1x1(0);
    test_1x1(-3);

    /***********************************************************************/

    /* Testing the special case solver for 2x2 matrices */
    printf("\n== Testing the special case solver for 2x2 matrices ==\n");
    test_2x2(1, 2, 2, 4);      /* symmetric */
    test_2x2(1, 2, 3, 4);      /* non-symmetric, real eigenvalues */
    test_2x2(1, -5, 10, 4);    /* non-symmetric, complex eigenvalues */
    test_2x2(0, 0, 0, 0);      /* symmetric, pathological */

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat5.out0000644000175100001710000000431700000000000026147 0ustar00runnerdocker00000000000000== Identity matrix ==

== Diagonal matrix ==

== A tree, plus a ring ==

Regular:
Eigenvalues:
( 3.79369 )
Eigenvectors:
[ 0.272513
  0.387127
  0.421856
  0.429479
  0.344793
  0.266584
   0.24469
  0.239837
  0.235697
  0.224848 ]

Shift and invert, LU:
Eigenvalues:
( 3.79369 )
Eigenvectors:
[ 0.272513
  0.387127
  0.421856
  0.429479
  0.344793
  0.266584
   0.24469
  0.239837
  0.235697
  0.224848 ]

Shift and invert, QR:
Eigenvalues:
( 3.79369 )
Eigenvectors:
[ 0.272513
  0.387127
  0.421856
  0.429479
  0.344793
  0.266584
   0.24469
  0.239837
  0.235697
  0.224848 ]

== A directed tree and a directed, mutual ring ==

Regular:
Eigenvalues:
[  2.61264        0 ]
Eigenvectors:
[ 0.467245
  0.571573
  0.427081
  0.335532
  0.263456
  0.130696
  0.0780048
  0.0731022
  0.112985
  0.222086 ]

== A small test graph ==

Regular:
Eigenvalues:
[  1.35971        0 ]
Eigenvectors:
[ 0.352334
  0.479071
  0.190574
  0.525509
  0.140158
   0.10308
  0.455414
  0.0680917
  0.125888
  0.0925848
  0.259125 ]

== Testing the special case solver for 1x1 matrices ==
rnsolve:
  - eigenvalues:
[        2        0 ]
  - eigenvectors:
[        1 ]
rssolve:
  - eigenvalues:
( 2 )
  - eigenvectors:
[        1 ]
rnsolve:
  - eigenvalues:
[        0        0 ]
  - eigenvectors:
[        1 ]
rssolve:
  - eigenvalues:
( 0 )
  - eigenvectors:
[        1 ]
rnsolve:
  - eigenvalues:
[       -3        0 ]
  - eigenvectors:
[        1 ]
rssolve:
  - eigenvalues:
( -3 )
  - eigenvectors:
[        1 ]

== Testing the special case solver for 2x2 matrices ==
rnsolve:
  - eigenvalues:
[        5        0
         0        0 ]
  - eigenvectors:
[        1       -4
         2        2 ]
rssolve:
  - eigenvalues:
( 5 0 )
  - eigenvectors:
[        1       -4
         2        2 ]
rnsolve:
  - eigenvalues:
[  5.37228        0
  -0.372281        0 ]
  - eigenvectors:
[  1.37228 -4.37228
         3        3 ]
rnsolve:
  - eigenvalues:
[      2.5  6.91014
       2.5 -6.91014 ]
  - eigenvectors:
[     -1.5  6.91014
        10        0 ]
rnsolve:
  - eigenvalues:
[        0        0
         0        0 ]
  - eigenvectors:
[        1        0
         0        1 ]
rssolve:
  - eigenvalues:
( 0 0 )
  - eigenvectors:
[        1        0
         0        1 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat9.c0000644000175100001710000000515300000000000025565 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DIM1 10
#define DIM2 5
#define DIM3 6

#define INT(a) (igraph_rng_get_integer(igraph_rng_default(), 0, (a)))
#define REAL() (igraph_rng_get_normal(igraph_rng_default(), 0, 1))

int main() {
    igraph_sparsemat_t sA, sB, sC;
    igraph_matrix_t A1, A2, A3, B, C;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_sparsemat_init(&sA, DIM1, DIM2, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&sA, INT(DIM1 - 1), INT(DIM2 - 1), REAL());
    }
    igraph_sparsemat_compress(&sA, &sB);
    igraph_sparsemat_destroy(&sA);

    igraph_sparsemat_init(&sA, DIM2, DIM3, 20);
    for (i = 0; i < 10; i++) {
        igraph_sparsemat_entry(&sA, INT(DIM2 - 1), INT(DIM3 - 1), REAL());
    }
    igraph_sparsemat_compress(&sA, &sC);
    igraph_sparsemat_destroy(&sA);

    igraph_matrix_init(&B, 0, 0);
    igraph_sparsemat_as_matrix(&B, &sB);
    igraph_matrix_init(&C, 0, 0);
    igraph_sparsemat_as_matrix(&C, &sC);

    /* All possible products */
    igraph_sparsemat_multiply(&sB, &sC, &sA);
    igraph_matrix_init(&A1, 0, 0);
    igraph_sparsemat_as_matrix(&A1, &sA);
    igraph_matrix_init(&A2, 0, 0);
    igraph_sparsemat_dense_multiply(&B, &sC, &A2);
    igraph_matrix_init(&A3, 0, 0);
    igraph_sparsemat_multiply_by_dense(&sB, &C, &A3);

    if (igraph_matrix_maxdifference(&A1, &A2) > 1e-10 ||
        igraph_matrix_maxdifference(&A2, &A3) > 1e-10) {
        return 1;
    }

    igraph_sparsemat_destroy(&sA);
    igraph_sparsemat_destroy(&sB);
    igraph_sparsemat_destroy(&sC);

    igraph_matrix_destroy(&A1);
    igraph_matrix_destroy(&A2);
    igraph_matrix_destroy(&A3);
    igraph_matrix_destroy(&B);
    igraph_matrix_destroy(&C);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_droptol.c0000644000175100001710000000463600000000000027244 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_sparsemat_t spmat;
    igraph_sparsemat_t spmat_comp;

    printf("0x0 matrix.\n");
    igraph_sparsemat_init(&spmat, 0, 0, /*nzmax*/0);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_droptol(&spmat_comp, 5) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    printf("3x3 matrix.\n");
    igraph_sparsemat_init(&spmat, 3, 3, /*nzmax*/7);
    igraph_sparsemat_entry(&spmat, 0, 0, 5);
    igraph_sparsemat_entry(&spmat, 1, 1, 6);
    igraph_sparsemat_entry(&spmat, 2, 2, 7);
    igraph_sparsemat_entry(&spmat, 3, 0, 1);
    igraph_sparsemat_entry(&spmat, 0, 3, 2);
    igraph_sparsemat_entry(&spmat, 2, 1, 3);
    igraph_sparsemat_entry(&spmat, 1, 2, -14);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    printf("Remove values within distance 5 from zero:\n");
    IGRAPH_ASSERT(igraph_sparsemat_droptol(&spmat_comp, 5) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    printf("Remove values within distance 20 from zero:\n");
    IGRAPH_ASSERT(igraph_sparsemat_droptol(&spmat_comp, 20) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("uncompressed matrix.\n");
    igraph_sparsemat_init(&spmat, 0, 0, /*nzmax*/0);
    IGRAPH_ASSERT(igraph_sparsemat_droptol(&spmat, 10) == IGRAPH_EINVAL);
    igraph_sparsemat_destroy(&spmat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_droptol.out0000644000175100001710000000053500000000000027623 0ustar00runnerdocker000000000000000x0 matrix.
3x3 matrix.
Remove values within distance 5 from zero:
col 0: locations 0 to -1
col 1: locations 0 to 0
1 : 6
col 2: locations 1 to 2
2 : 7
1 : -14
col 3: locations 3 to 2
Remove values within distance 20 from zero:
col 0: locations 0 to -1
col 1: locations 0 to -1
col 2: locations 0 to -1
col 3: locations 0 to -1
uncompressed matrix.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_fkeep.c0000644000175100001710000000554600000000000026654 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

igraph_integer_t fkeep_none(igraph_integer_t row, igraph_integer_t col, igraph_real_t value, void *other) {
    IGRAPH_UNUSED(row);
    IGRAPH_UNUSED(col);
    IGRAPH_UNUSED(value);
    IGRAPH_UNUSED(other);
    return 0;
}

igraph_integer_t fkeep(igraph_integer_t row, igraph_integer_t col, igraph_real_t value, void *other) {
    if (row == 0 || col == 1 || value > *(int*)other) {
        return 0;
    }
    return 1;
}

int main() {
    igraph_sparsemat_t spmat;
    igraph_sparsemat_t spmat_comp;
    int a = 0;

    printf("0x0 matrix.\n");
    igraph_sparsemat_init(&spmat, 0, 0, /*nzmax*/0);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_fkeep(&spmat_comp, &fkeep, &a) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    printf("3x3 matrix.\n");
    igraph_sparsemat_init(&spmat, 3, 3, /*nzmax*/7);
    igraph_sparsemat_entry(&spmat, 0, 0, 5);
    igraph_sparsemat_entry(&spmat, 1, 1, 6);
    igraph_sparsemat_entry(&spmat, 2, 2, 7);
    igraph_sparsemat_entry(&spmat, 3, 0, 1);
    igraph_sparsemat_entry(&spmat, 0, 3, 2);
    igraph_sparsemat_entry(&spmat, 2, 1, 3);
    igraph_sparsemat_entry(&spmat, 1, 2, 4);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    a = 6;
    printf("Remove row 0, column 1, and values above 6:\n");
    IGRAPH_ASSERT(igraph_sparsemat_fkeep(&spmat_comp, &fkeep, &a) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    printf("Remove everything:\n");
    IGRAPH_ASSERT(igraph_sparsemat_fkeep(&spmat_comp, &fkeep_none, &a) == IGRAPH_SUCCESS);
    igraph_sparsemat_print(&spmat_comp, stdout);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("uncompressed matrix.\n");
    igraph_sparsemat_init(&spmat, 0, 0, /*nzmax*/0);
    IGRAPH_ASSERT(igraph_sparsemat_fkeep(&spmat, &fkeep, &a) == IGRAPH_EINVAL);
    igraph_sparsemat_destroy(&spmat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_fkeep.out0000644000175100001710000000047400000000000027234 0ustar00runnerdocker000000000000000x0 matrix.
3x3 matrix.
Remove row 0, column 1, and values above 6:
col 0: locations 0 to 0
3 : 1
col 1: locations 1 to 0
col 2: locations 1 to 1
1 : 4
col 3: locations 2 to 1
Remove everything:
col 0: locations 0 to -1
col 1: locations 0 to -1
col 2: locations 0 to -1
col 3: locations 0 to -1
uncompressed matrix.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_getelements_sorted.c0000644000175100001710000000567100000000000031455 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void print_res_i_j(igraph_vector_t *result, igraph_vector_int_t *i, igraph_vector_int_t *j) {
    print_vector(result);
    print_vector_int(i);
    print_vector_int(j);
}

void destroy_all(igraph_vector_t *result, igraph_vector_int_t *i, igraph_vector_int_t *j, igraph_sparsemat_t *spmat, igraph_sparsemat_t *spmat_comp) {
    igraph_vector_destroy(result);
    igraph_vector_int_destroy(i);
    igraph_vector_int_destroy(j);
    igraph_sparsemat_destroy(spmat);
    igraph_sparsemat_destroy(spmat_comp);
}

void init_all(igraph_vector_t *result, igraph_vector_int_t *i, igraph_vector_int_t *j, igraph_sparsemat_t *spmat) {
    igraph_vector_init(result, 0);
    igraph_vector_int_init(i, 0);
    igraph_vector_int_init(j, 0);
    igraph_sparsemat_init(spmat, 0, 0, 0);
}

int main() {
    igraph_sparsemat_t spmat;
    igraph_sparsemat_t spmat_comp;
    igraph_vector_t result;
    igraph_vector_int_t i, j;
    int k, l;
    int size = 3;

    printf("0x0 matrix\n");
    init_all(&result, &i, &j, &spmat);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_getelements_sorted(&spmat, &i, &j, &result) == IGRAPH_SUCCESS);
    printf("triplet:\n");
    print_res_i_j(&result, &i, &j);
    IGRAPH_ASSERT(igraph_sparsemat_getelements_sorted(&spmat_comp, &i, &j, &result) == IGRAPH_SUCCESS);
    printf("compressed:\n");
    print_res_i_j(&result, &i, &j);
    destroy_all(&result, &i, &j, &spmat, &spmat_comp);

    printf("\n3x3 matrix\n");
    init_all(&result, &i, &j, &spmat);
    for (k = 0; k < size; k += 2) {
        for (l = 0; l < size; l ++) {
            igraph_sparsemat_entry(&spmat, k, l, 100);
            igraph_sparsemat_entry(&spmat, k, l, k * size + l);
        }
    }
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_getelements_sorted(&spmat, &i, &j, &result) == IGRAPH_SUCCESS);
    printf("triplet:\n");
    print_res_i_j(&result, &i, &j);
    IGRAPH_ASSERT(igraph_sparsemat_getelements_sorted(&spmat_comp, &i, &j, &result) == IGRAPH_SUCCESS);
    printf("compressed:\n");
    print_res_i_j(&result, &i, &j);

    destroy_all(&result, &i, &j, &spmat, &spmat_comp);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_getelements_sorted.out0000644000175100001710000000041400000000000032030 0ustar00runnerdocker000000000000000x0 matrix
triplet:
( )
( )
( )
compressed:
( )
( )
( 0 )

3x3 matrix
triplet:
( 100 0 100 1 100 2 100 6 100 7 100 8 )
( 0 0 0 0 0 0 2 2 2 2 2 2 )
( 0 0 1 1 2 2 0 0 1 1 2 2 )
compressed:
( 100 0 100 6 100 1 100 7 100 2 100 8 )
( 0 0 2 2 0 0 2 2 0 0 2 2 )
( 0 4 8 12 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_is_symmetric.c0000644000175100001710000000372500000000000030266 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

#define DIM 10

#define INT(a) (igraph_rng_get_integer(igraph_rng_default(), 0, (a)))

int main() {
    int runs = 100;
    const int noelements = 20;
    igraph_sparsemat_t A;
    int i;

    igraph_rng_seed(igraph_rng_default(), 42);

    for (; runs > 0; runs--) {

        igraph_sparsemat_init(&A, DIM, DIM, noelements * 2);
        for (i = 0; i < noelements; i++) {
            int row = INT(DIM - 1);
            int col = INT(DIM - 1);
            int val = INT(100);
            igraph_sparsemat_entry(&A, row, col, val);
            igraph_sparsemat_entry(&A, col, row, val);
        }
        if (!igraph_sparsemat_is_symmetric(&A)) {
            return 1;
        }
        igraph_sparsemat_destroy(&A);

        igraph_sparsemat_init(&A, DIM, DIM, noelements);
        for (i = 0; i < noelements; i++) {
            igraph_sparsemat_entry(&A, INT(DIM - 1), INT(DIM - 1), INT(100));
        }
        if (igraph_sparsemat_is_symmetric(&A)) {
            return 2;
        }
        igraph_sparsemat_destroy(&A);

    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_iterator_idx.c0000644000175100001710000000415100000000000030246 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_sparsemat_t spmat;
    igraph_sparsemat_t spmat_comp;
    igraph_sparsemat_iterator_t it;
    igraph_sparsemat_iterator_t it_comp;

    printf("0x0 matrix.\n");
    igraph_sparsemat_init(&spmat, 0, 0, /*nzmax*/0);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    igraph_sparsemat_iterator_init(&it, &spmat);
    igraph_sparsemat_iterator_init(&it_comp, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_iterator_idx(&it) == 0);
    IGRAPH_ASSERT(igraph_sparsemat_iterator_idx(&it_comp) == 0);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    printf("3x3 matrix.\n");
    igraph_sparsemat_init(&spmat, 3, 3, /*nzmax*/0);
    igraph_sparsemat_entry(&spmat, 0, 0, 5);
    igraph_sparsemat_entry(&spmat, 3, 3, 6);
    igraph_sparsemat_entry(&spmat, 3, 3, 6);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    igraph_sparsemat_iterator_init(&it, &spmat);
    igraph_sparsemat_iterator_init(&it_comp, &spmat_comp);
    igraph_sparsemat_iterator_next(&it);
    igraph_sparsemat_iterator_next(&it);
    igraph_sparsemat_iterator_next(&it_comp);
    IGRAPH_ASSERT(igraph_sparsemat_iterator_idx(&it) == 2);
    IGRAPH_ASSERT(igraph_sparsemat_iterator_idx(&it_comp) == 1);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_minmax.c0000644000175100001710000001275500000000000027053 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

#define N  10
#define M  20
#define NZ 50

#define MIN 0
#define MAX 10

typedef int fun(igraph_sparsemat_t *A, igraph_vector_t *res);

int doit(int which) {

    int i;
    igraph_sparsemat_t A, A2;
    igraph_vector_t vec;
    fun *colfun, *rowfun;

    if (which == MIN) {
        colfun = igraph_sparsemat_colmins;
        rowfun = igraph_sparsemat_rowmins;
    } else {
        colfun = igraph_sparsemat_colmaxs;
        rowfun = igraph_sparsemat_rowmaxs;
    }

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Triplet diagonal matrix */

    igraph_vector_init(&vec, N);
    for (i = 0; i < N; i++) {
        VECTOR(vec)[i] = i;
    }
    igraph_sparsemat_diag(&A, /*nzmax=*/ N, /*values=*/ &vec,
                          /*compress=*/ 0);

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 1;
        }
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 2;
        }
    }

    igraph_vector_destroy(&vec);
    igraph_sparsemat_destroy(&A);

    /* Compressed diagonal matrix */

    igraph_vector_init(&vec, N);
    for (i = 0; i < N; i++) {
        VECTOR(vec)[i] = i;
    }
    igraph_sparsemat_diag(&A, /*nzmax=*/ N, /*values=*/ &vec,
                          /*compress=*/ 1);

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 3;
        }
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 4;
        }
    }

    igraph_vector_destroy(&vec);
    igraph_sparsemat_destroy(&A);


    /* Random triplet matrix */

    igraph_sparsemat_init(&A, /*rows=*/ N, /*cols=*/ M, /*nzmax=*/ NZ + 5);
    for (i = 0; i < NZ; i++) {
        int r = igraph_rng_get_integer(igraph_rng_default(), 0, N - 1);
        int c = igraph_rng_get_integer(igraph_rng_default(), 0, M - 1);
        igraph_real_t x = igraph_rng_get_integer(igraph_rng_default(),
                          -10, 10);
        igraph_sparsemat_entry(&A, r, c, x);
    }
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 0);
    colfun(&A, &vec);
    igraph_vector_print(&vec);

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    igraph_vector_print(&vec);

    /* Random compresssed matrix */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    colfun(&A2, &vec);
    igraph_vector_print(&vec);

    igraph_vector_null(&vec);
    rowfun(&A2, &vec);
    igraph_vector_print(&vec);

    igraph_vector_destroy(&vec);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    /* Matrix with zero rows, triplet */

    igraph_sparsemat_init(&A, /*rows=*/ 0, /*cols=*/ M, /*nzmax=*/ NZ);
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 5);
    rowfun(&A, &vec);
    if (igraph_vector_size(&vec) != 0) {
        return which + 5;
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec);
    igraph_vector_print(&vec);

    /* Matrix with zero rows, compressed */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    if (igraph_vector_size(&vec) != 0) {
        return which + 6;
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec);
    igraph_vector_print(&vec);

    igraph_vector_destroy(&vec);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    /* Matrix with zero columns, triplet */

    igraph_sparsemat_init(&A, /*rows=*/ N, /*cols=*/ 0, /*nzmax=*/ NZ);
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 5);
    colfun(&A, &vec);
    if (igraph_vector_size(&vec) != 0) {
        return which + 7;
    }

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    igraph_vector_print(&vec);

    /* Matrix with zero columns, compressed */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    colfun(&A, &vec);
    if (igraph_vector_size(&vec) != 0) {
        return which + 8;
    }

    igraph_vector_null(&vec);
    rowfun(&A, &vec);
    igraph_vector_print(&vec);

    igraph_vector_destroy(&vec);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    return 0;
}

int main() {
    int res;

    res = doit(/*which=*/ MIN);
    if (res) {
        return res;
    }

    res = doit(/*which=*/ MAX);
    if (res) {
        return res;
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_minmax.out0000644000175100001710000000154000000000000027426 0ustar00runnerdocker00000000000000-7 -9 Inf -7 Inf -6 7 -5 6 7 -9 -6 -6 -9 -4 -3 -1 9 -5 -4
5 -9 -4 -7 -9 -6 -9 -9 -5 -5
-7 -9 Inf -7 Inf -6 7 -5 6 7 -13 -12 -6 -9 -4 -3 1 9 -5 -4
7 -9 -4 -7 -7 -12 -13 -9 -5 -5
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
7 9 -Inf 7 -Inf 6 -7 5 -6 -7 9 6 6 9 4 3 1 -9 5 4
-5 9 4 7 9 6 9 9 5 5
7 9 -Inf 7 -Inf 6 -7 5 -6 -7 13 12 6 9 4 3 -1 -9 5 4
-7 9 4 7 7 12 13 9 5 5
-Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf
-Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf
-Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf
-Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf -Inf
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_nonzero_storage.c0000644000175100001710000000513200000000000030767 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"


int main() {
    igraph_sparsemat_t spmat;
    igraph_sparsemat_t spmat_comp;
    int i, j;
    int size = 3;

    printf("0x0 matrix\n");
    igraph_sparsemat_init(&spmat, 0, 0, 0);
    igraph_sparsemat_compress(&spmat, &spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat) == 0);
    IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat_comp) == 0);
    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    printf("3x3 compressed matrix with duplicate values that add up to zero.\n");
    igraph_sparsemat_init(&spmat, size, size, 7);
    for (i = 0; i < size; i++) {
        for (j = 0; j < size; j++) {
            igraph_sparsemat_entry(&spmat, i, j, 5);
            igraph_sparsemat_entry(&spmat, i, j, -5);

            /* This checks if there's two entries for every loop. */
            IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat) == (i * size + j + 1) * 2);
            igraph_sparsemat_compress(&spmat, &spmat_comp);
            IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat_comp) == (i * size + j + 1) * 2);

            igraph_sparsemat_destroy(&spmat_comp);
        }
    }
    printf("Adding one entry to work around some broken error handling.\n");
    igraph_sparsemat_entry(&spmat, 0, 0, 5);
    igraph_sparsemat_compress(&spmat, &spmat_comp);

    printf("Removing duplicates should leave us with one entry in each position.\n");
    igraph_sparsemat_dupl(&spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat_comp) == (size * size));

    printf("Removing all zeros should leave us with only one entry.\n");
    igraph_sparsemat_dropzeros(&spmat_comp);
    IGRAPH_ASSERT(igraph_sparsemat_nonzero_storage(&spmat_comp) == 1);

    igraph_sparsemat_destroy(&spmat);
    igraph_sparsemat_destroy(&spmat_comp);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_view.c0000644000175100001710000000305600000000000026526 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_sparsemat_t spmat;
    igraph_matrix_t mat;
    int p[] = {0, 1, 3};
    int i[]  = {1, 0, 2};
    double x[] = {1, 5, 2};

    printf("Empty sparsemat.\n");
    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_view(&spmat, /*nzmax*/ 0, /*m*/ 0, /*n*/ 0, /*p*/ NULL, /*i*/ NULL, /*x*/ NULL, /*nz*/ 0);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    print_matrix(&mat);
    igraph_free(spmat.cs);
    igraph_matrix_destroy(&mat);

    printf("3x2 sparsemat:\n");
    igraph_matrix_init(&mat, 0, 0);
    igraph_sparsemat_view(&spmat, /*nzmax*/ 3, /*m*/ 3, /*n*/ 2, p, i, x, /*nz*/ -1);
    igraph_sparsemat_as_matrix(&mat, &spmat);
    print_matrix(&mat);
    igraph_free(spmat.cs);
    igraph_matrix_destroy(&mat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_view.out0000644000175100001710000000013600000000000027107 0ustar00runnerdocker00000000000000Empty sparsemat.
3x2 sparsemat:
[        0        5
         1        0
         0        2 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_which_minmax.c0000644000175100001710000001537200000000000030233 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2014  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

#define N  10
#define M  20
#define NZ 50

#define MIN 0
#define MAX 10

typedef int fun(igraph_sparsemat_t *A, igraph_vector_t *res,
                igraph_vector_int_t *pos);

int doit(int which) {

    int i;
    igraph_sparsemat_t A, A2;
    igraph_vector_t vec;
    igraph_vector_int_t pos;
    fun *colfun, *rowfun;

    if (which == MIN) {
        colfun = igraph_sparsemat_which_min_cols;
        rowfun = igraph_sparsemat_which_min_rows;
    } else {
        /* colfun = */ /* TODO */
        /* rowfun = */ /* TODO */
    }

    igraph_rng_seed(igraph_rng_default(), 42);

    /* Triplet diagonal matrix */

    igraph_vector_init(&vec, N);
    igraph_vector_int_init(&pos, N);
    for (i = 0; i < N; i++) {
        VECTOR(vec)[i] = i;
    }
    igraph_sparsemat_diag(&A, /*nzmax=*/ N, /*values=*/ &vec,
                          /*compress=*/ 0);

    igraph_vector_null(&vec);
    igraph_vector_int_null(&pos);
    rowfun(&A, &vec, &pos);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 1;
        }
    }
    for (i = 0; i < N; i++) {
        if (VECTOR(pos)[i] != i) {
            return which + 2;
        }
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec, &pos);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 3;
        }
    }
    for (i = 0; i < N; i++) {
        if (VECTOR(pos)[i] != i) {
            return which + 4;
        }
    }

    igraph_vector_destroy(&vec);
    igraph_vector_int_destroy(&pos);
    igraph_sparsemat_destroy(&A);

    /* Compressed diagonal matrix */

    igraph_vector_init(&vec, N);
    igraph_vector_int_init(&pos, N);
    for (i = 0; i < N; i++) {
        VECTOR(vec)[i] = i;
    }
    igraph_sparsemat_diag(&A, /*nzmax=*/ N, /*values=*/ &vec,
                          /*compress=*/ 1);

    igraph_vector_null(&vec);
    rowfun(&A, &vec, &pos);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 5;
        }
    }
    for (i = 0; i < N; i++) {
        if (VECTOR(pos)[i] != i) {
            return which + 6;
        }
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec, &pos);
    for (i = 0; i < N; i++) {
        if (VECTOR(vec)[i] != i) {
            return which + 7;
        }
    }
    for (i = 0; i < N; i++) {
        if (VECTOR(pos)[i] != i) {
            return which + 8;
        }
    }

    igraph_vector_destroy(&vec);
    igraph_vector_int_destroy(&pos);
    igraph_sparsemat_destroy(&A);


    /* Random triplet matrix */

    igraph_sparsemat_init(&A, /*rows=*/ N, /*cols=*/ M, /*nzmax=*/ NZ + 5);
    for (i = 0; i < NZ; i++) {
        int r = igraph_rng_get_integer(igraph_rng_default(), 0, N - 1);
        int c = igraph_rng_get_integer(igraph_rng_default(), 0, M - 1);
        igraph_real_t x = igraph_rng_get_integer(igraph_rng_default(),
                          -10, 10);
        igraph_sparsemat_entry(&A, r, c, x);
    }
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 0);
    igraph_vector_int_init(&pos, 0);
    colfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    igraph_vector_null(&vec);
    rowfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    /* Random compresssed matrix */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    colfun(&A2, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    igraph_vector_null(&vec);
    rowfun(&A2, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    igraph_vector_destroy(&vec);
    igraph_vector_int_destroy(&pos);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    /* Matrix with zero rows, triplet */

    igraph_sparsemat_init(&A, /*rows=*/ 0, /*cols=*/ M, /*nzmax=*/ NZ);
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 5);
    igraph_vector_int_init(&pos, 5);
    rowfun(&A, &vec, &pos);
    if (igraph_vector_size(&vec) != 0) {
        return which + 5;
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    /* Matrix with zero rows, compressed */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    rowfun(&A, &vec, &pos);
    if (igraph_vector_size(&vec) != 0) {
        return which + 6;
    }

    igraph_vector_null(&vec);
    colfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    igraph_vector_destroy(&vec);
    igraph_vector_int_destroy(&pos);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    /* Matrix with zero columns, triplet */

    igraph_sparsemat_init(&A, /*rows=*/ N, /*cols=*/ 0, /*nzmax=*/ NZ);
    if (which == MAX) {
        igraph_sparsemat_scale(&A, -1.0);
    }

    igraph_vector_init(&vec, 5);
    igraph_vector_int_init(&pos, 5);
    colfun(&A, &vec, &pos);
    if (igraph_vector_size(&vec) != 0) {
        return which + 7;
    }

    igraph_vector_null(&vec);
    rowfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    /* Matrix with zero columns, compressed */

    igraph_sparsemat_compress(&A, &A2);

    igraph_vector_null(&vec);
    colfun(&A, &vec, &pos);
    if (igraph_vector_size(&vec) != 0) {
        return which + 8;
    }

    igraph_vector_null(&vec);
    rowfun(&A, &vec, &pos);
    igraph_vector_print(&vec);
    igraph_vector_int_print(&pos);

    igraph_vector_destroy(&vec);
    igraph_vector_int_destroy(&pos);
    igraph_sparsemat_destroy(&A);
    igraph_sparsemat_destroy(&A2);

    return 0;
}

int main() {
    int res;

    res = doit(/*which=*/ MIN);
    if (res) {
        return res;
    }

    /* res = doit(/\*which=*\/ MAX); */
    /* if (res) { return res; } */

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_sparsemat_which_minmax.out0000644000175100001710000000123500000000000030611 0ustar00runnerdocker00000000000000-7 -9 Inf -7 Inf -6 7 -5 6 7 -9 -6 -6 -9 -4 -3 -1 9 -5 -4
3 4 0 4 0 3 9 9 9 6 6 5 3 7 3 6 5 3 8 3
5 -9 -4 -7 -9 -6 -9 -9 -5 -5
19 10 13 0 1 11 10 13 18 7
-7 -9 Inf -7 Inf -6 7 -5 6 7 -13 -12 -6 -9 -4 -3 1 9 -5 -4
3 1 0 4 0 3 9 9 9 6 6 5 3 7 3 6 5 3 8 3
7 -9 -4 -7 -7 -12 -13 -9 -5 -5
0 1 13 0 3 11 10 13 18 7
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
0 0 0 0 0 0 0 0 0 0
Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
0 0 0 0 0 0 0 0 0 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_split_join_distance.c0000644000175100001710000000645500000000000027527 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_vector_t comm1, comm2;
    igraph_integer_t distance12, distance21;

    printf("No vertices:\n");
    igraph_vector_init_int(&comm1, 0);
    igraph_vector_init_int(&comm2, 0);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_SUCCESS);
    printf("%" IGRAPH_PRId ", %" IGRAPH_PRId "\n", distance12, distance21);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("Comparing 5 separate vertices and one 5-element cluster:\n");
    igraph_vector_init_int(&comm1, 5, 0, 1, 2, 3, 4);
    igraph_vector_init_int(&comm2, 5, 0, 0, 0, 0, 0);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_SUCCESS);
    printf("%" IGRAPH_PRId ", %" IGRAPH_PRId "\n", distance12, distance21);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("Comparing ((6, 1), (2,4), (3,5,0)) with ((2), (6,0,3), (4,5), (1)):\n");
    igraph_vector_init_int(&comm1, 7, 2, 0, 1, 2, 1, 2, 0);
    igraph_vector_init_int(&comm2, 7, 1, 3, 0, 1, 2, 2, 1);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_SUCCESS);
    printf("%" IGRAPH_PRId ", %" IGRAPH_PRId "\n", distance12, distance21);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("Comparing ((0,1), (), 2) with ((0), (), (1,2))\n");
    igraph_vector_init_int(&comm1, 3, 0, 0, 2);
    igraph_vector_init_int(&comm2, 3, 0, 2, 2);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_SUCCESS);
    printf("%" IGRAPH_PRId ", %" IGRAPH_PRId "\n", distance12, distance21);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("\nExpected to fail nicely:\n\n");

    printf("Differently sized clusterings\n");
    igraph_vector_init_int(&comm1, 3, 0, 1, 2);
    igraph_vector_init_int(&comm2, 5, 0, 0, 0, 0, 0);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_EINVAL);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    printf("Member index too high\n");
    igraph_vector_init_int(&comm1, 3, 0, 1, 2);
    igraph_vector_init_int(&comm2, 3, 9, 0, 0);
    IGRAPH_ASSERT(igraph_split_join_distance(&comm1, &comm2, &distance12, &distance21) == IGRAPH_EINVAL);
    igraph_vector_destroy(&comm1);
    igraph_vector_destroy(&comm2);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_split_join_distance.out0000644000175100001710000000043400000000000030103 0ustar00runnerdocker00000000000000No vertices:
0, 0
Comparing 5 separate vertices and one 5-element cluster:
0, 4
Comparing ((6, 1), (2,4), (3,5,0)) with ((2), (6,0,3), (4,5), (1)):
3, 2
Comparing ((0,1), (), 2) with ((0), (), (1,2))
1, 1

Expected to fail nicely:

Differently sized clusterings
Member index too high
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_spmatrix_add_col_values.c0000644000175100001710000000342500000000000030370 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_spmatrix_t spmat;
    int i;
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("0x0 matrix, trying to add nonexistent column\n");
    igraph_spmatrix_init(&spmat, 0, 0);
    IGRAPH_ASSERT(igraph_spmatrix_add_col_values(&spmat, /*to*/ 0, /*from*/ 0) == IGRAPH_EINVAL);
    igraph_spmatrix_destroy(&spmat);

    printf("\n1x1 matrix, adding a column to itself\n");
    igraph_spmatrix_init(&spmat, 1, 1);
    igraph_spmatrix_set(&spmat, 0, 0, 5);
    IGRAPH_ASSERT(igraph_spmatrix_add_col_values(&spmat, /*to*/ 0, /*from*/ 0) == IGRAPH_SUCCESS);
    print_spmatrix(&spmat);
    igraph_spmatrix_destroy(&spmat);

    printf("\n5x6 matrix\n");
    igraph_spmatrix_init(&spmat, 5, 6);
    for (i = 0; i < 30; i++) {
        igraph_spmatrix_set(&spmat, i/6, i%6, i);
    }
    IGRAPH_ASSERT(igraph_spmatrix_add_col_values(&spmat, /*to*/ 1, /*from*/ 2) == IGRAPH_SUCCESS);
    print_spmatrix(&spmat);
    igraph_spmatrix_destroy(&spmat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_spmatrix_add_col_values.out0000644000175100001710000000057500000000000030760 0ustar00runnerdocker000000000000000x0 matrix, trying to add nonexistent column

1x1 matrix, adding a column to itself
       10

5x6 matrix
        0        3        2        3        4        5
        6       15        8        9       10       11
       12       27       14       15       16       17
       18       39       20       21       22       23
       24       51       26       27       28       29
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_st_edge_connectivity.c0000644000175100001710000000213500000000000027702 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_integer_t value;

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, -1);

    igraph_st_edge_connectivity(&g, &value, 0, 5);

    igraph_destroy(&g);

    IGRAPH_ASSERT(value == 2);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_st_mincut.c0000644000175100001710000000402700000000000025501 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void sort_and_print(igraph_vector_t *vec) {
    igraph_vector_sort(vec);
    print_vector_round(vec);
}

int main() {

    igraph_t g;
    igraph_vector_t cut, partition, partition2, capacity;
    igraph_real_t value;
    int source = 0;
    int target = 4;

    igraph_vector_init(&partition, 0);
    igraph_vector_init(&partition2, 0);
    igraph_vector_init(&cut, 0);

    igraph_small(&g, 5, IGRAPH_DIRECTED, 0, 1, 1, 2, 1, 3, 2, 4, 3, 4, -1);
    igraph_vector_init_int_end(&capacity, -1, 8, 2, 3, 3, 2, -1);

    /*    test without capacity    */

    igraph_st_mincut(&g, &value, &cut, &partition, &partition2, source, target, /*capacity*/ NULL);

    /* cut and partition should have only one element */
    print_vector_round(&cut);
    print_vector_round(&partition);
    sort_and_print(&partition2);

    /*    test with capacity    */

    igraph_st_mincut(&g, &value, &cut, &partition, &partition2, source, target, &capacity);

    sort_and_print(&cut);
    sort_and_print(&partition);
    sort_and_print(&partition2);

    /*     cleanup     */

    igraph_vector_destroy(&cut);
    igraph_vector_destroy(&partition);
    igraph_vector_destroy(&partition2);
    igraph_vector_destroy(&capacity);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_st_mincut.out0000644000175100001710000000006200000000000026061 0ustar00runnerdocker00000000000000( 0 )
( 0 )
( 1 2 3 4 )
( 1 4 )
( 0 1 3 )
( 2 4 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_st_mincut_value.c0000644000175100001710000000235700000000000026701 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t capacity;
    igraph_real_t value;

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, -1);
    igraph_vector_init_int_end(&capacity, -1, 5, 2, 2, 3, 4, 1, 2, 5, -1);

    igraph_st_mincut_value(&g, &value, 0, 5, &capacity);

    igraph_vector_destroy(&capacity);
    igraph_destroy(&g);

    IGRAPH_ASSERT(value == 7);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_static_power_law_game.c0000644000175100001710000000655400000000000030042 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g;

    igraph_rng_seed(igraph_rng_default(), 42);

    printf("No vertices:\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/0, /*number of edges*/ 0,
                  /*exponent_out*/ 2.0, /*exponent in*/ 2.0, /*loops*/ 0, /*multiple*/ 0,
                  /*finite_size_correction*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("No edges, undirected:\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/10, /*number of edges*/ 0,
                  /*exponent_out*/ 2.0, /*exponent in*/ -2.0, /*loops*/ 0, /*multiple*/ 0,
                  /*finite_size_correction*/ 1) == IGRAPH_SUCCESS);
    print_graph_canon(&g);
    igraph_destroy(&g);

    printf("Checking some basic outputs.\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/100, /*number of edges*/ 30,
                  /*exponent_out*/ 2.0, /*exponent in*/ -2.0, /*loops*/ 1, /*multiple*/ 1,
                  /*finite_size_correction*/ 1) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&g) == 100);
    IGRAPH_ASSERT(igraph_ecount(&g) == 30);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Negative number of vertices.\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/-100, /*number of edges*/ 30,
                  /*exponent_out*/ 2.0, /*exponent in*/ -2.0, /*loops*/ 1, /*multiple*/ 1,
                  /*finite_size_correction*/ 1) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Negative number of edges.\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/100, /*number of edges*/ -30,
                  /*exponent_out*/ 2.0, /*exponent in*/ -2.0, /*loops*/ 1, /*multiple*/ 1,
                  /*finite_size_correction*/ 1) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Exponent out too low.\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/100, /*number of edges*/ 30,
                  /*exponent_out*/ 1.0, /*exponent in*/ -2.0, /*loops*/ 1, /*multiple*/ 1,
                  /*finite_size_correction*/ 1) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    printf("Exponent in too low but not negative.\n");
    IGRAPH_ASSERT(igraph_static_power_law_game(&g, /*number of vertices*/100, /*number of edges*/ 30,
                  /*exponent_out*/ 2.0, /*exponent in*/ 0.5, /*loops*/ 1, /*multiple*/ 1,
                  /*finite_size_correction*/ 1) == IGRAPH_EINVAL);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_static_power_law_game.out0000644000175100001710000000037500000000000030422 0ustar00runnerdocker00000000000000No vertices:
directed: true
vcount: 0
edges: {
}
No edges, undirected:
directed: false
vcount: 10
edges: {
}
Checking some basic outputs.
Negative number of vertices.
Negative number of edges.
Exponent out too low.
Exponent in too low but not negative.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_subcomponent.c0000644000175100001710000000506600000000000026214 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void call_and_print(igraph_t *graph, igraph_real_t vertex, igraph_neimode_t mode) {
    igraph_vector_t result;
    igraph_vector_init(&result, 0);
    IGRAPH_ASSERT(igraph_subcomponent(graph, &result, vertex, mode) == IGRAPH_SUCCESS);
    igraph_vector_sort(&result);
    igraph_vector_print(&result);
    igraph_vector_destroy(&result);
    printf("\n");
}


int main() {
    igraph_t g_0, g_1, g_lm, g_lmu;
    igraph_vector_t result;
    igraph_vector_init(&result, 0);
    int i;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_lm, 6, 1, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);
    igraph_small(&g_lmu, 6, 0, 0,1, 0,2, 1,1, 1,3, 2,0, 2,0, 2,3, 3,4, 3,4, -1);

    printf("No vertices, should give error for impossible starting vertex.\n");
    CHECK_ERROR(igraph_subcomponent(&g_0, &result, 0, IGRAPH_ALL), IGRAPH_EINVVID);

    printf("One vertex.\n");
    call_and_print(&g_1, 0, IGRAPH_ALL);

    printf("All vertices of a graph, IGRAPH_OUT:\n");
    for (i = 0; i < 6; i++) {
        call_and_print(&g_lm, i, IGRAPH_OUT);
    }

    printf("All vertices of a graph, IGRAPH_IN:\n");
    for (i = 0; i < 6; i++) {
        call_and_print(&g_lm, i, IGRAPH_IN);
    }

    printf("All vertices of a graph, IGRAPH_ALL:\n");
    for (i = 0; i < 6; i++) {
        call_and_print(&g_lm, i, IGRAPH_ALL);
    }

    printf("All vertices of a graph, undirected:\n");
    for (i = 0; i < 6; i++) {
        call_and_print(&g_lmu, i, IGRAPH_OUT);
    }

    printf("Check for invalid mode error handling.\n");
    CHECK_ERROR(igraph_subcomponent(&g_1, &result, 0, 100), IGRAPH_EINVMODE);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_lm);
    igraph_destroy(&g_lmu);
    igraph_vector_destroy(&result);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_subcomponent.out0000644000175100001710000000071400000000000026574 0ustar00runnerdocker00000000000000No vertices, should give error for impossible starting vertex.
One vertex.
0

All vertices of a graph, IGRAPH_OUT:
0 1 2 3 4

1 3 4

0 1 2 3 4

3 4

4

5

All vertices of a graph, IGRAPH_IN:
0 2

0 1 2

0 2

0 1 2 3

0 1 2 3 4

5

All vertices of a graph, IGRAPH_ALL:
0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

5

All vertices of a graph, undirected:
0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

0 1 2 3 4

5

Check for invalid mode error handling.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_subisomorphic.c0000644000175100001710000000432100000000000026357 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    /*igraph_subisomorphic now calls igraph_subisomorphic_vf2, most of
      the testing is done through calling that directly*/
    igraph_t g1, g2;
    igraph_bool_t result;

    printf("No vertices.\n");
    igraph_small(&g1, 0, 0, -1);
    igraph_small(&g2, 0, 0, -1);
    IGRAPH_ASSERT(igraph_subisomorphic(&g1, &g2, &result) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(result);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("Basic positive example, undirected.\n");
    igraph_small(&g1, 4, 0, 0,1, 1,2, 3,2, 3,1, -1);
    igraph_small(&g2, 3, 0, 0,1, 1,2, 2,0, -1);
    IGRAPH_ASSERT(igraph_subisomorphic(&g1, &g2, &result) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(result);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    printf("Basic negative example, directed.\n");
    igraph_small(&g1, 4, 1, 0,1, 1,2, 3,2, 3,1, -1);
    igraph_small(&g2, 3, 1, 0,1, 1,2, 2,0, -1);
    IGRAPH_ASSERT(igraph_subisomorphic(&g1, &g2, &result) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(!result);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Mismatching directedness.\n");
    igraph_small(&g1, 4, 1, 0,1, 1,2, 3,2, 3,1, -1);
    igraph_small(&g2, 3, 0, 0,1, 1,2, 2,0, -1);
    IGRAPH_ASSERT(igraph_subisomorphic(&g1, &g2, &result) == IGRAPH_EINVAL);
    igraph_destroy(&g1);
    igraph_destroy(&g2);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_to_directed.c0000644000175100001710000000174400000000000025764 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t ug;
    igraph_t dg;

    igraph_small(&ug, 6, /* directed= */ 0,
                 2,0, 1,4, 3,2, 2,3, 0,4, 5,0, 2,3, 5,3, 2,5, 0,1,
                 -1);

    igraph_copy(&dg, &ug);
    printf("\nARBITRARY:\n");
    igraph_to_directed(&dg, IGRAPH_TO_DIRECTED_ARBITRARY);
    print_graph(&dg);
    igraph_destroy(&dg);

    igraph_copy(&dg, &ug);
    printf("\nMUTUAL:\n");
    igraph_to_directed(&dg, IGRAPH_TO_DIRECTED_MUTUAL);
    print_graph(&dg);
    igraph_destroy(&dg);

    igraph_copy(&dg, &ug);
    printf("\nACYCLIC:\n");
    igraph_to_directed(&dg, IGRAPH_TO_DIRECTED_ACYCLIC);
    print_graph(&dg);
    igraph_destroy(&dg);

    igraph_copy(&dg, &ug);
    printf("\nRANDOM (edge count only):\n");
    igraph_to_directed(&dg, IGRAPH_TO_DIRECTED_RANDOM);
    printf("%" IGRAPH_PRId "\n", igraph_ecount(&dg));
    igraph_destroy(&dg);

    igraph_destroy(&ug);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_to_directed.out0000644000175100001710000000051100000000000026340 0ustar00runnerdocker00000000000000
ARBITRARY:
directed: true
vcount: 6
edges: {
0 2
1 4
2 3
2 3
0 4
0 5
2 3
3 5
2 5
0 1
}

MUTUAL:
directed: true
vcount: 6
edges: {
0 2
1 4
2 3
2 3
0 4
0 5
2 3
3 5
2 5
0 1
2 0
4 1
3 2
3 2
4 0
5 0
3 2
5 3
5 2
1 0
}

ACYCLIC:
directed: true
vcount: 6
edges: {
0 2
1 4
2 3
2 3
0 4
0 5
2 3
3 5
2 5
0 1
}

RANDOM (edge count only):
10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_to_prufer.c0000644000175100001710000001121400000000000025475 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int test_from_prufer_back_to_prufer() {
    igraph_t graph;
    igraph_integer_t prufer[] = {2, 3, 2, 3};

    igraph_vector_int_t expected_prufer, output_prufer;

    igraph_bool_t success = 0;

    igraph_vector_int_view(&expected_prufer, prufer, 4);
    IGRAPH_CHECK(igraph_from_prufer(&graph, &expected_prufer));

    IGRAPH_CHECK(igraph_vector_int_init(&output_prufer, 4));
    IGRAPH_CHECK(igraph_to_prufer(&graph, &output_prufer));

    success = igraph_vector_int_all_e(&expected_prufer, &output_prufer);

    igraph_destroy(&graph);
    igraph_vector_int_destroy(&output_prufer);

    return success;
}

int test_from_prufer_back_to_prufer_with_resize() {
    igraph_t graph;
    igraph_integer_t prufer[] = {0, 2, 4, 1, 1, 0};

    igraph_vector_int_t expected_prufer, output_prufer;

    igraph_bool_t success;

    igraph_vector_int_view(&expected_prufer, prufer, 6);
    IGRAPH_CHECK(igraph_from_prufer(&graph, &expected_prufer));

    IGRAPH_CHECK(igraph_vector_int_init(&output_prufer, 0));
    IGRAPH_CHECK(igraph_to_prufer(&graph, &output_prufer));

    success = igraph_vector_int_all_e(&expected_prufer, &output_prufer);

    igraph_destroy(&graph);
    igraph_vector_int_destroy(&output_prufer);

    return success;
}

int test_from_prufer_back_to_prufer_with_resize2() {
    igraph_t graph;
    igraph_integer_t prufer[] = {2, 4, 5, 1, 3};

    igraph_vector_int_t expected_prufer, output_prufer;

    igraph_bool_t success;

    igraph_vector_int_view(&expected_prufer, prufer, 5);
    IGRAPH_CHECK(igraph_from_prufer(&graph, &expected_prufer));

    IGRAPH_CHECK(igraph_vector_int_init(&output_prufer, 0));
    IGRAPH_CHECK(igraph_to_prufer(&graph, &output_prufer));


    success = igraph_vector_int_all_e(&output_prufer, &expected_prufer);

    igraph_destroy(&graph);
    igraph_vector_int_destroy(&output_prufer);

    return success;
}

int random_tree(int size, igraph_t* tree, igraph_vector_int_t* prufer) {
    int i, j;
    int prufer_length;

    if (size < 0) {
        return IGRAPH_EINVAL;
    }

    if (size < 2) {
        return igraph_empty(tree, size, IGRAPH_UNDIRECTED);
    }

    prufer_length = size - 2;
    IGRAPH_CHECK(igraph_vector_int_resize(prufer, prufer_length));

    for (i = 0; i < prufer_length; ++i) {
        j = RNG_INTEGER(0, size - 1);
        VECTOR(*prufer)[i] = j;
    }

    IGRAPH_CHECK(igraph_from_prufer(tree, prufer));

    return IGRAPH_SUCCESS;
}

int test_from_random_prufer_back_to_prufer(int tree_size) {
    igraph_t graph;
    igraph_vector_int_t expected_prufer, output_prufer;

    igraph_bool_t success = 0;
    igraph_integer_t random_seed = 4096;

    IGRAPH_CHECK(igraph_vector_int_init(&output_prufer, 0));
    IGRAPH_CHECK(igraph_vector_int_init(&expected_prufer, 0));

    igraph_rng_seed(igraph_rng_default(), random_seed);

    IGRAPH_CHECK(random_tree(tree_size, &graph, &expected_prufer));

    IGRAPH_CHECK(igraph_to_prufer(&graph, &output_prufer));

    success = igraph_vector_int_all_e(&output_prufer, &expected_prufer);

    igraph_destroy(&graph);
    igraph_vector_int_destroy(&expected_prufer);
    igraph_vector_int_destroy(&output_prufer);

    return success;
}

#undef RUN_TEST   /* from test_utilities.inc */

int test_num = 0;
#define RUN_TEST(TEST) \
    test_num++; \
    if(!(TEST)) { \
        return test_num; \
    }

int main() {
    RUN_TEST(test_from_prufer_back_to_prufer());
    RUN_TEST(test_from_prufer_back_to_prufer_with_resize());
    RUN_TEST(test_from_prufer_back_to_prufer_with_resize2());
    RUN_TEST(test_from_random_prufer_back_to_prufer(10));
    RUN_TEST(test_from_random_prufer_back_to_prufer(100));
    RUN_TEST(test_from_random_prufer_back_to_prufer(1000));
    RUN_TEST(test_from_random_prufer_back_to_prufer(10000));

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitive_closure_dag.c0000644000175100001710000000320300000000000030226 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g, g2;
    igraph_vector_t deg;

    igraph_small(&g, 9, IGRAPH_DIRECTED,
                 8, 7, 7, 6, 6, 3, 6, 0, 3, 2, 3, 1, 5, 0, 4, 1,
                 -1);
    igraph_transitive_closure_dag(&g, &g2);

    if (igraph_vcount(&g2) != igraph_vcount(&g)) {
        return 1;
    }
    if (igraph_ecount(&g2) != 19) {
        return 1;
    }

    igraph_vector_init(°, 0);
    igraph_degree(&g2, °, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS);
    igraph_vector_print(°);
    igraph_degree(&g2, °, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS);
    igraph_vector_print(°);

    igraph_vector_destroy(°);
    igraph_destroy(&g2);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitive_closure_dag.out0000644000175100001710000000004400000000000030613 0ustar00runnerdocker000000000000004 5 4 3 0 0 2 1 0
0 0 0 2 1 1 4 5 6
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitivity_avglocal_undirected.c0000644000175100001710000000550700000000000032327 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_t g_0, g_1, g_simple, g_ml;
    igraph_real_t result;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_simple, 6, 1, 0,1, 0,2, 1,2, 1,3, 2,3, 3,4, -1);
    igraph_small(&g_ml, 6, 0, 0,1, 0,2, 1,1, 1,2, 1,3, 2,1, 2,3, 3,4, 3,4, -1);

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("No vertices, transitivity zero:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_0, &result, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("No vertices, transitivity NaN:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_0, &result, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("One vertex, transitivity zero:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_1, &result, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("One vertex, transitivity NaN:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_1, &result, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("Simple graph:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_simple, &result, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("Multigraph:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_ml, &result, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    printf("Multigraph, TRANSITIVITY_NAN:\n");
    IGRAPH_ASSERT(igraph_transitivity_avglocal_undirected(&g_ml, &result, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_real(stdout, result, "%g");
    printf("\n");

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_simple);
    igraph_destroy(&g_ml);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitivity_avglocal_undirected.out0000644000175100001710000000033300000000000032704 0ustar00runnerdocker00000000000000No vertices, transitivity zero:
0
No vertices, transitivity NaN:
NaN
One vertex, transitivity zero:
0
One vertex, transitivity NaN:
NaN
Simple graph:
0.444444
Multigraph:
0.444444
Multigraph, TRANSITIVITY_NAN:
0.666667
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitivity_barrat.c0000644000175100001710000001277100000000000027605 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void warning_handler_print_stdout(const char *reason, const char *file,
                                  int line, int igraph_errno) {
    IGRAPH_UNUSED(igraph_errno);
    IGRAPH_UNUSED(file);
    IGRAPH_UNUSED(line);
    fprintf(stdout, "Warning: %s\n", reason);
}

int main() {
    igraph_t g_0, g_1, g_simple;
    igraph_vector_t result, weights_none, weights_simple;

    igraph_small(&g_0, 0, 0, -1);
    igraph_small(&g_1, 1, 0, -1);
    igraph_small(&g_simple, 6, 0, 0,1, 0,2, 1,2, 1,3, 2,3, 3,4, -1);

    igraph_vector_init(&result, 0);
    igraph_vector_init(&weights_none, 0);
    igraph_vector_init_int(&weights_simple, 6, -1, 0, 1, 2, 3, 4);

    igraph_set_warning_handler(warning_handler_print_stdout);

    printf("No vertices, transitivity zero, NULL weights:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_all(), /*weights*/ NULL, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("No vertices, transitivity zero, NULL weights, no vs:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_none(), /*weights*/ NULL, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("No vertices, transitivity zero, no weights:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_all(), &weights_none, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("No vertices, transitivity zero, no weights, no vs:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_none(), &weights_none, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("No vertices, transitivity NAN:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_all(), NULL, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("No vertices, transitivity NAN, no vs:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_0, &result, igraph_vss_none(), NULL, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("One vertex, transitivity zero:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_1, &result, igraph_vss_all(), NULL, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("One vertex, transitivity NaN:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_1, &result, igraph_vss_all(), NULL, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("One vertex, transitivity zero, vs one:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_1, &result, igraph_vss_1(0), NULL, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("One vertex, transitivity NaN, vs one:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_1, &result, igraph_vss_1(0), NULL, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("Simple graph, NULL weights, transitivity NAN:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_all(), NULL, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("Simple graph, with weights, transitivity NAN:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_all(), &weights_simple, IGRAPH_TRANSITIVITY_NAN) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("Simple graph, with weights, transitivity zero:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_all(), &weights_simple, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    printf("Simple graph, with weights, transitivity zero, vss none:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_none(), &weights_simple, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_SUCCESS);
    print_vector(&result);
    printf("\n");

    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Wrong weight length, vss all:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_all(), &weights_none, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_EINVAL);

    printf("Wrong weight length, vss none:\n");
    IGRAPH_ASSERT(igraph_transitivity_barrat(&g_simple, &result, igraph_vss_none(), &weights_none, IGRAPH_TRANSITIVITY_ZERO) == IGRAPH_EINVAL);

    igraph_destroy(&g_0);
    igraph_destroy(&g_1);
    igraph_destroy(&g_simple);

    igraph_vector_destroy(&result);
    igraph_vector_destroy(&weights_none);
    igraph_vector_destroy(&weights_simple);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_transitivity_barrat.out0000644000175100001710000000162200000000000030163 0ustar00runnerdocker00000000000000No vertices, transitivity zero, NULL weights:
( )

No vertices, transitivity zero, NULL weights, no vs:
( )

No vertices, transitivity zero, no weights:
( )

No vertices, transitivity zero, no weights, no vs:
( )

No vertices, transitivity NAN:
( )

No vertices, transitivity NAN, no vs:
( )

One vertex, transitivity zero:
( 0 )

One vertex, transitivity NaN:
( NaN )

One vertex, transitivity zero, vs one:
( 0 )

One vertex, transitivity NaN, vs one:
( NaN )

Simple graph, NULL weights, transitivity NAN:
Warning: No weights given for Barrat's transitivity, unweighted version is used.
( 1 0.666667 0.666667 0.333333 NaN NaN )

Simple graph, with weights, transitivity NAN:
( 1 0.75 0.625 0.277778 NaN NaN )

Simple graph, with weights, transitivity zero:
( 1 0.75 0.625 0.277778 0 0 )

Simple graph, with weights, transitivity zero, vss none:
( )

Wrong weight length, vss all:
Wrong weight length, vss none:
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_vector_floor.c0000644000175100001710000000240600000000000026176 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"


int main() {
    igraph_vector_t from;
    igraph_vector_long_t to;

    igraph_vector_init_real(&from, 9, -0.6, -0.5, -0.4, -0.0, 0.0, 0.4, 0.5, 0.6, 1.1);
    igraph_vector_long_init(&to, 0);

    printf("From:\n");
    igraph_vector_print(&from);
    IGRAPH_ASSERT(igraph_vector_floor(&from, &to) == IGRAPH_SUCCESS);

    printf("To:\n");
    igraph_vector_long_print(&to);

    igraph_vector_long_destroy(&to);
    igraph_vector_destroy(&from);
    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_vector_floor.out0000644000175100001710000000010300000000000026553 0ustar00runnerdocker00000000000000From:
-0.6 -0.5 -0.4 -0 0 0.4 0.5 0.6 1.1
To:
-1 -1 -1 0 0 0 0 0 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_vector_lex_cmp.c0000644000175100001710000000352400000000000026506 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_vector_t v1, v2, v3, v4, v5, v6, v7, v8;

    igraph_vector_init_real(&v1, 3, 1e30, 2e30, 9e30);
    igraph_vector_init_real(&v2, 3, 1e30, 2e30, 3e30);
    igraph_vector_init_real(&v3, 2, 1e30, 2e30);
    igraph_vector_init_real(&v4, 0);
    igraph_vector_init_real(&v5, 3, 1e30, 2e30, 9e30);
    igraph_vector_init_real(&v6, 0);
    igraph_vector_init_real(&v7, 3, 9e30, 2e30, 1e30);
    igraph_vector_init_real(&v8, 2, 3e30, 3e30);

    igraph_vector_t *vectors[] = {&v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8};
    long n = sizeof(vectors) / sizeof(igraph_vector_t *);

    printf("Lexicographical ordering:\n");
    igraph_qsort(vectors, n, sizeof(igraph_vector_t *), igraph_vector_lex_cmp);

    for (int i = 0; i < n; i++) {
        print_vector(vectors[i]);
    }

    printf("\nColexicographical ordering:\n");
    igraph_qsort(vectors, n, sizeof(igraph_vector_t *), igraph_vector_colex_cmp);

    for (int i = 0; i < n; i++) {
        print_vector(vectors[i]);
        igraph_vector_destroy(vectors[i]);
    }

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_vector_lex_cmp.out0000644000175100001710000000046700000000000027076 0ustar00runnerdocker00000000000000Lexicographical ordering:
( )
( )
( 1e+30 2e+30 )
( 1e+30 2e+30 3e+30 )
( 1e+30 2e+30 9e+30 )
( 1e+30 2e+30 9e+30 )
( 3e+30 3e+30 )
( 9e+30 2e+30 1e+30 )

Colexicographical ordering:
( )
( )
( 9e+30 2e+30 1e+30 )
( 1e+30 2e+30 )
( 1e+30 2e+30 3e+30 )
( 3e+30 3e+30 )
( 1e+30 2e+30 9e+30 )
( 1e+30 2e+30 9e+30 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_vertex_disjoint_paths.c0000644000175100001710000000214400000000000030111 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_integer_t value;

    igraph_small(&g, 7, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, 0, 5, -1);

    igraph_vertex_disjoint_paths(&g, &value, 0, 5);

    igraph_destroy(&g);

    IGRAPH_ASSERT(value == 3);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_weighted_cliques.c0000644000175100001710000001454000000000000027022 0ustar00runnerdocker00000000000000
#include 
#include 

#include "test_utilities.inc"

int compare_vectors(const void *p1, const void *p2) {
    igraph_vector_t *v1, *v2;
    long s1, s2, i;

    v1 = *((igraph_vector_t **) p1);
    v2 = *((igraph_vector_t **) p2);
    s1 = igraph_vector_size(v1);
    s2 = igraph_vector_size(v2);
    if (s1 < s2) {
        return -1;
    }
    if (s1 > s2) {
        return 1;
    }
    for (i = 0; i < s1; ++i) {
        if (VECTOR(*v1)[i] < VECTOR(*v2)[i]) {
            return -1;
        }
        if (VECTOR(*v1)[i] > VECTOR(*v2)[i]) {
            return 1;
        }
    }
    return 0;
}

/* Takes a pointer vector of vectors. Sorts each vector, then sorts the pointer vector */
void canonicalize_list(igraph_vector_ptr_t *list) {
    long i, len;
    len = igraph_vector_ptr_size(list);
    for (i = 0; i < len; ++i) {
        igraph_vector_sort((igraph_vector_t *) VECTOR(*list)[i]);
    }
    qsort(&(VECTOR(*list)[0]), len, sizeof(void *), &compare_vectors);
}

/* Prints a clique vector along with its weight */
void print_weighted_clique(const igraph_vector_t *clique, const igraph_vector_t *vertex_weights) {
    long int i, n = igraph_vector_size(clique);
    igraph_real_t clique_weight = 0.0;
    for (i = 0; i < n; i++) {
        int v = VECTOR(*clique)[i];
        clique_weight += vertex_weights ? igraph_vector_e(vertex_weights, v) : 1;
        printf(" %d", v);
    }
    printf(" w=%.1f\n", clique_weight);
}

/* Prints a clique list and clears it */
void print_and_clear_weighted_clique_list(igraph_vector_ptr_t *cliques, const igraph_vector_t *vertex_weights) {
    int i, count;

    canonicalize_list(cliques);

    count = igraph_vector_ptr_size(cliques);
    for (i = 0; i < count; i++) {
        igraph_vector_t* v = (igraph_vector_t*) igraph_vector_ptr_e(cliques, i);
        print_weighted_clique(v, vertex_weights);
        igraph_vector_destroy(v);
        igraph_free(v);
    }

    igraph_vector_ptr_clear(cliques);
}

int main() {
    igraph_t graph;

    const igraph_integer_t n = 10; /* number of vertices in test graph */

    /* edges of the test graph */
    igraph_vector_t edges;
    igraph_real_t edge_data[] = {0., 1., 0., 6., 0., 7., 0., 8., 0., 9., 1., 2., 1., 3., 1., 4., 1.,
                                 6., 1., 7., 1., 8., 1., 9., 2., 3., 2., 5., 2., 6., 2., 7., 2., 9.,
                                 3., 5., 3., 6., 3., 7., 3., 9., 4., 5., 4., 6., 4., 7., 4., 9., 5.,
                                 8., 6., 7., 6., 8., 7., 8., 8., 9.
                                };

    /* vertex weights in test graph,
       note that current implementation only supports integer weights */
    igraph_vector_t vertex_weights;
    igraph_real_t vertex_weight_data[] = {3., 2., 3., 5., 2., 3., 1., 3., 5., 5.};

    igraph_vector_ptr_t result; /* result clique list */
    igraph_integer_t count; /* number of cliques found */

    igraph_real_t weighted_clique_no;


    /* create graph */
    igraph_vector_init_copy(&edges, edge_data, (sizeof edge_data) / sizeof(igraph_real_t));
    igraph_create(&graph, &edges, n, /* directed= */ 0);

    /* set up vertex weight vector */
    igraph_vector_init_copy(&vertex_weights, vertex_weight_data, (sizeof vertex_weight_data) / sizeof(igraph_real_t));

    /* initialize result vector_ptr */
    igraph_vector_ptr_init(&result, 0);


    /* all weighted cliques above weight 6 */
    igraph_weighted_cliques(&graph, &vertex_weights, &result, 6, 0, /* maximal= */ 0);

    count = igraph_vector_ptr_size(&result);
    printf("%ld weighted cliques found above weight 6\n", (long) count);
    print_and_clear_weighted_clique_list(&result, &vertex_weights);


    /* all weighted cliques between weights 5 and 10 */
    igraph_weighted_cliques(&graph, &vertex_weights, &result, 5, 10, /* maximal= */ 0);

    count = igraph_vector_ptr_size(&result);
    printf("%ld weighted cliques found between weights 5 and 10\n", (long) count);
    print_and_clear_weighted_clique_list(&result, &vertex_weights);


    /* maximal weighted cliques above weight 7 */
    igraph_weighted_cliques(&graph, &vertex_weights, &result, 7, 0, /* maximal= */ 1);

    count = igraph_vector_ptr_size(&result);
    printf("%ld maximal weighted cliques found above weight 7\n", (long) count);
    print_and_clear_weighted_clique_list(&result, &vertex_weights);


    /* maximal weighed cliques beteen weights 5 and 10 */
    igraph_weighted_cliques(&graph, &vertex_weights, &result, 5, 10, /* maximal= */ 1);

    count = igraph_vector_ptr_size(&result);
    printf("%ld maximal weighted cliques found between weights 5 and 10\n", (long) count);
    print_and_clear_weighted_clique_list(&result, &vertex_weights);


    /* largest weight cliques */
    igraph_largest_weighted_cliques(&graph, &vertex_weights, &result);

    count = igraph_vector_ptr_size(&result);
    printf("%ld largest weight cliques found\n", (long) count);
    print_and_clear_weighted_clique_list(&result, &vertex_weights);

    igraph_weighted_clique_number(&graph, &vertex_weights, &weighted_clique_no);
    printf("weighted clique number: %.1f\n", weighted_clique_no);


    /* test fallback to unweighted variants: all cliques */
    igraph_weighted_cliques(&graph, 0, &result, 4, 5, /* maximal= */ 0);

    count = igraph_vector_ptr_size(&result);
    printf("%ld unweighted cliques found between sizes 4 and 5\n", (long) count);
    print_and_clear_weighted_clique_list(&result, 0);


    /* test fallback to unweighted variants: maximal cliques */
    igraph_weighted_cliques(&graph, 0, &result, 4, 5, /* maximal= */ 1);

    count = igraph_vector_ptr_size(&result);
    printf("%ld unweighted maximal cliques found between sizes 4 and 5\n", (long) count);
    print_and_clear_weighted_clique_list(&result, 0);


    /* test fallback to unweighted variants: largest cliques */
    igraph_largest_weighted_cliques(&graph, 0, &result);

    count = igraph_vector_ptr_size(&result);
    printf("%ld largest unweighted cliques found\n", (long) count);
    print_and_clear_weighted_clique_list(&result, 0);


    /* test fallback to unweighted variants: clique number */
    igraph_weighted_clique_number(&graph, 0, &weighted_clique_no);
    printf("unweighted clique number: %.1f\n", weighted_clique_no);


    /* free data structures */
    igraph_vector_ptr_destroy(&result);
    igraph_vector_destroy(&vertex_weights);
    igraph_destroy(&graph);
    igraph_vector_destroy(&edges);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_weighted_cliques.out0000644000175100001710000000463300000000000027411 0ustar00runnerdocker0000000000000063 weighted cliques found above weight 6
 0 7 w=6.0
 0 8 w=8.0
 0 9 w=8.0
 1 3 w=7.0
 1 8 w=7.0
 1 9 w=7.0
 2 3 w=8.0
 2 5 w=6.0
 2 7 w=6.0
 2 9 w=8.0
 3 5 w=8.0
 3 6 w=6.0
 3 7 w=8.0
 3 9 w=10.0
 4 9 w=7.0
 5 8 w=8.0
 6 8 w=6.0
 7 8 w=8.0
 8 9 w=10.0
 0 1 6 w=6.0
 0 1 7 w=8.0
 0 1 8 w=10.0
 0 1 9 w=10.0
 0 6 7 w=7.0
 0 6 8 w=9.0
 0 7 8 w=11.0
 0 8 9 w=13.0
 1 2 3 w=10.0
 1 2 6 w=6.0
 1 2 7 w=8.0
 1 2 9 w=10.0
 1 3 6 w=8.0
 1 3 7 w=10.0
 1 3 9 w=12.0
 1 4 7 w=7.0
 1 4 9 w=9.0
 1 6 7 w=6.0
 1 6 8 w=8.0
 1 7 8 w=10.0
 1 8 9 w=12.0
 2 3 5 w=11.0
 2 3 6 w=9.0
 2 3 7 w=11.0
 2 3 9 w=13.0
 2 6 7 w=7.0
 3 6 7 w=9.0
 4 6 7 w=6.0
 6 7 8 w=9.0
 0 1 6 7 w=9.0
 0 1 6 8 w=11.0
 0 1 7 8 w=13.0
 0 1 8 9 w=15.0
 0 6 7 8 w=12.0
 1 2 3 6 w=11.0
 1 2 3 7 w=13.0
 1 2 3 9 w=15.0
 1 2 6 7 w=9.0
 1 3 6 7 w=11.0
 1 4 6 7 w=8.0
 1 6 7 8 w=11.0
 2 3 6 7 w=12.0
 0 1 6 7 8 w=14.0
 1 2 3 6 7 w=14.0
53 weighted cliques found between weights 5 and 10
 3 w=5.0
 8 w=5.0
 9 w=5.0
 0 1 w=5.0
 0 7 w=6.0
 0 8 w=8.0
 0 9 w=8.0
 1 2 w=5.0
 1 3 w=7.0
 1 7 w=5.0
 1 8 w=7.0
 1 9 w=7.0
 2 3 w=8.0
 2 5 w=6.0
 2 7 w=6.0
 2 9 w=8.0
 3 5 w=8.0
 3 6 w=6.0
 3 7 w=8.0
 3 9 w=10.0
 4 5 w=5.0
 4 7 w=5.0
 4 9 w=7.0
 5 8 w=8.0
 6 8 w=6.0
 7 8 w=8.0
 8 9 w=10.0
 0 1 6 w=6.0
 0 1 7 w=8.0
 0 1 8 w=10.0
 0 1 9 w=10.0
 0 6 7 w=7.0
 0 6 8 w=9.0
 1 2 3 w=10.0
 1 2 6 w=6.0
 1 2 7 w=8.0
 1 2 9 w=10.0
 1 3 6 w=8.0
 1 3 7 w=10.0
 1 4 6 w=5.0
 1 4 7 w=7.0
 1 4 9 w=9.0
 1 6 7 w=6.0
 1 6 8 w=8.0
 1 7 8 w=10.0
 2 3 6 w=9.0
 2 6 7 w=7.0
 3 6 7 w=9.0
 4 6 7 w=6.0
 6 7 8 w=9.0
 0 1 6 7 w=9.0
 1 2 6 7 w=9.0
 1 4 6 7 w=8.0
8 maximal weighted cliques found above weight 7
 5 8 w=8.0
 1 4 9 w=9.0
 2 3 5 w=11.0
 0 1 8 9 w=15.0
 1 2 3 9 w=15.0
 1 4 6 7 w=8.0
 0 1 6 7 8 w=14.0
 1 2 3 6 7 w=14.0
4 maximal weighted cliques found between weights 5 and 10
 4 5 w=5.0
 5 8 w=8.0
 1 4 9 w=9.0
 1 4 6 7 w=8.0
2 largest weight cliques found
 0 1 8 9 w=15.0
 1 2 3 9 w=15.0
weighted clique number: 15.0
15 unweighted cliques found between sizes 4 and 5
 0 1 6 7 w=4.0
 0 1 6 8 w=4.0
 0 1 7 8 w=4.0
 0 1 8 9 w=4.0
 0 6 7 8 w=4.0
 1 2 3 6 w=4.0
 1 2 3 7 w=4.0
 1 2 3 9 w=4.0
 1 2 6 7 w=4.0
 1 3 6 7 w=4.0
 1 4 6 7 w=4.0
 1 6 7 8 w=4.0
 2 3 6 7 w=4.0
 0 1 6 7 8 w=5.0
 1 2 3 6 7 w=5.0
5 unweighted maximal cliques found between sizes 4 and 5
 0 1 8 9 w=4.0
 1 2 3 9 w=4.0
 1 4 6 7 w=4.0
 0 1 6 7 8 w=5.0
 1 2 3 6 7 w=5.0
2 largest unweighted cliques found
 0 1 6 7 8 w=5.0
 1 2 3 6 7 w=5.0
unweighted clique number: 5.0././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_write_graph_dimacs.c0000644000175100001710000000403700000000000027330 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t capacity;
    int source = 0;
    int target = 5;

    /*
    Expected output:

    ```
    c created by igraph
    p problem n_vertices n_edges
    n source s
    n target t
    a arc_node_1 arc_node2 capacity
    ```

    We always outout max as the problem.

    */

    igraph_small(&g, 6, IGRAPH_DIRECTED,
                 0, 1, 0, 2, 1, 2, 1, 3, 2, 4, 3, 4, 3, 5, 4, 5, -1);
    igraph_vector_init_int_end(&capacity, -1, 5, 2, 2, 3, 4, 1, 2, 5, -1);

    printf("DIMACS graph output:\n");
    igraph_write_graph_dimacs(&g, stdout, source, target, &capacity);

    igraph_destroy(&g);
    igraph_vector_destroy(&capacity);

    igraph_small(&g, 0, IGRAPH_DIRECTED, -1);
    igraph_vector_init(&capacity, 0);

    /* Check that the function does not crash/misbehave on a null graph.
       Note that currently igraph outputs DIMACS files for the max-flow
       problem, which only makes sense if there are at least two vertices,
       a source and the target. Here we use dummy values for them. */
    printf("\nDIMACS graph output for null graph:\n");
    igraph_write_graph_dimacs(&g, stdout, source, target, &capacity);

    igraph_vector_destroy(&capacity);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_write_graph_dimacs.out0000644000175100001710000000031600000000000027711 0ustar00runnerdocker00000000000000DIMACS graph output:
c created by igraph
p max 6 8
n 1 s
n 6 t
a 1 2 5
a 1 3 2
a 2 3 2
a 2 4 3
a 3 5 4
a 4 5 1
a 4 6 2
a 5 6 5

DIMACS graph output for null graph:
c created by igraph
p max 0 0
n 1 s
n 6 t
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_write_graph_leda.c0000644000175100001710000000677400000000000027007 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/
#include 
#include 

#include "test_utilities.inc"

int main() {
    int i;
    igraph_t g;
    igraph_vector_t values;
    igraph_strvector_t strvalues;
    const char* strings[] = {"foo", "bar", "baz", "spam", "eggs", "bacon"};

    /* Setting up attribute handler */
    igraph_set_attribute_table(&igraph_cattribute_table);

    /* Saving directed graph, no attributes */
    igraph_ring(&g, 5, /* directed = */ 1,
                /* mutual   = */ 0,
                /* circular = */ 1);
    igraph_write_graph_leda(&g, stdout, 0, 0);
    printf("===\n");
    igraph_destroy(&g);

    /* Saving undirected graph, no attributes */
    igraph_ring(&g, 5, /* directed = */ 0,
                /* mutual   = */ 0,
                /* circular = */ 1);
    igraph_write_graph_leda(&g, stdout, 0, 0);
    printf("===\n");
    igraph_destroy(&g);

    /* Saving directed graph with vertex attributes */
    igraph_ring(&g, 5, /* directed = */ 1,
                /* mutual   = */ 0,
                /* circular = */ 1);
    igraph_vector_init_seq(&values, 5, 9);
    SETVANV(&g, "name", &values);
    igraph_write_graph_leda(&g, stdout, "name", 0);
    igraph_vector_destroy(&values);
    printf("===\n");
    DELVAS(&g);
    igraph_strvector_init(&strvalues, 5);
    for (i = 0; i < 5; i++) {
        igraph_strvector_set(&strvalues, i, strings[i]);
    }
    SETVASV(&g, "name", &strvalues);
    igraph_write_graph_leda(&g, stdout, "name", 0);
    igraph_strvector_destroy(&strvalues);
    printf("===\n");
    igraph_destroy(&g);

    /* Saving undirected graph with edge attributes */
    igraph_ring(&g, 5, /* directed = */ 0,
                /* mutual   = */ 0,
                /* circular = */ 1);
    igraph_vector_init_seq(&values, 5, 9);
    SETEANV(&g, "weight", &values);
    igraph_write_graph_leda(&g, stdout, 0, "weight");
    igraph_vector_destroy(&values);
    printf("===\n");
    DELEAS(&g);
    igraph_strvector_init(&strvalues, 5);
    for (i = 0; i < 5; i++) {
        igraph_strvector_set(&strvalues, i, strings[i]);
    }
    SETEASV(&g, "weight", &strvalues);
    igraph_write_graph_leda(&g, stdout, 0, "weight");
    igraph_strvector_destroy(&strvalues);
    printf("===\n");
    igraph_destroy(&g);

    /* Saving undirected graph with edge attributes and large weights */
    igraph_ring(&g, 5, /* directed = */ 0,
                /* mutual   = */ 0,
                /* circular = */ 1);
    igraph_vector_init_seq(&values, 123456789, 123456793);
    SETEANV(&g, "weight", &values);
    igraph_write_graph_leda(&g, stdout, 0, "weight");
    igraph_vector_destroy(&values);
    printf("===\n");
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/igraph_write_graph_leda.out0000644000175100001710000000176500000000000027367 0ustar00runnerdocker00000000000000LEDA.GRAPH
void
void
-1
# Vertices
5
|{}|
|{}|
|{}|
|{}|
|{}|
# Edges
5
1 2 0 |{}|
2 3 0 |{}|
3 4 0 |{}|
4 5 0 |{}|
5 1 0 |{}|
===
LEDA.GRAPH
void
void
-2
# Vertices
5
|{}|
|{}|
|{}|
|{}|
|{}|
# Edges
5
1 2 0 |{}|
1 5 0 |{}|
2 3 0 |{}|
3 4 0 |{}|
4 5 0 |{}|
===
LEDA.GRAPH
float
void
-1
# Vertices
5
|{5}|
|{6}|
|{7}|
|{8}|
|{9}|
# Edges
5
1 2 0 |{}|
2 3 0 |{}|
3 4 0 |{}|
4 5 0 |{}|
5 1 0 |{}|
===
LEDA.GRAPH
string
void
-1
# Vertices
5
|{foo}|
|{bar}|
|{baz}|
|{spam}|
|{eggs}|
# Edges
5
1 2 0 |{}|
2 3 0 |{}|
3 4 0 |{}|
4 5 0 |{}|
5 1 0 |{}|
===
LEDA.GRAPH
void
float
-2
# Vertices
5
|{}|
|{}|
|{}|
|{}|
|{}|
# Edges
5
1 2 0 |{5}|
1 5 0 |{9}|
2 3 0 |{6}|
3 4 0 |{7}|
4 5 0 |{8}|
===
LEDA.GRAPH
void
string
-2
# Vertices
5
|{}|
|{}|
|{}|
|{}|
|{}|
# Edges
5
1 2 0 |{foo}|
1 5 0 |{eggs}|
2 3 0 |{bar}|
3 4 0 |{baz}|
4 5 0 |{spam}|
===
LEDA.GRAPH
void
float
-2
# Vertices
5
|{}|
|{}|
|{}|
|{}|
|{}|
# Edges
5
1 2 0 |{123456789}|
1 5 0 |{123456793}|
2 3 0 |{123456790}|
3 4 0 |{123456791}|
4 5 0 |{123456792}|
===
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/inclist.c0000644000175100001710000001277600000000000023621 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

#define TEST_INCLIST(label, mode, loops) { \
    igraph_inclist_init(&g, &inclist, mode, loops); \
    printf(label ": "); \
    print_inclist(&inclist); \
    printf("\n"); \
    igraph_inclist_destroy(&inclist); \
}

#define TEST_LAZY_INCLIST(label, mode, loops) { \
    igraph_lazy_inclist_init(&g, &lazy_inclist, mode, loops); \
    printf(label ": "); \
    print_lazy_inclist(&lazy_inclist); \
    printf("\n"); \
    igraph_lazy_inclist_destroy(&lazy_inclist); \
}

int test_loop_elimination_for_undirected_graph() {
    igraph_t g;
    igraph_inclist_t inclist;
    igraph_lazy_inclist_t lazy_inclist;

    igraph_small(
        &g, 5, /* directed = */ 0,
        /* edge 0 */ 0, 1,
        /* edge 1 */ 0, 3,
        /* edge 2 */ 1, 2,
        /* edge 3 */ 2, 2,
        /* edge 4 */ 2, 3,
        /* edge 5 */ 3, 0,
        /* edge 6 */ 3, 4,
        /* edge 7 */ 4, 0,
        /* edge 8 */ 4, 4,
        /* edge 9 */ 4, 5,
        /* edge 10 */ 4, 6,
        /* edge 11 */ 4, 4,
        /* edge 12 */ 6, 5,
        -1
    );

    printf("Testing loop edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_INCLIST("Loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS);
    TEST_INCLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE);
    TEST_INCLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE);

    printf("============================================================\n\n");

    printf("Testing lazy loop edge elimination in undirected graph\n\n");

    /* We are testing IGRAPH_ALL, IGRAPH_IN and IGRAPH_OUT below; it should
     * make no difference */
    TEST_LAZY_INCLIST("Loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS);
    TEST_LAZY_INCLIST("Loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE);
    TEST_LAZY_INCLIST("Loops listed twice", IGRAPH_OUT, IGRAPH_LOOPS_TWICE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int test_loop_elimination_for_directed_graph() {
    igraph_t g;
    igraph_inclist_t inclist;
    igraph_lazy_inclist_t lazy_inclist;

    igraph_small(
        &g, 5, /* directed = */ 1,
        /* edge 0 */ 0, 1,
        /* edge 1 */ 0, 3,
        /* edge 2 */ 1, 2,
        /* edge 3 */ 2, 2,
        /* edge 4 */ 2, 3,
        /* edge 5 */ 3, 0,
        /* edge 6 */ 3, 4,
        /* edge 7 */ 4, 0,
        /* edge 8 */ 4, 4,
        /* edge 9 */ 4, 5,
        /* edge 10 */ 4, 6,
        /* edge 11 */ 4, 4,
        /* edge 12 */ 6, 5,
        -1
    );

    printf("Testing loop edge elimination in directed graph\n\n");

    TEST_INCLIST("In-edges, loops eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS);
    TEST_INCLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE);
    TEST_INCLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE);

    TEST_INCLIST("Out-edges, loops eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS);
    TEST_INCLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE);
    TEST_INCLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE);

    TEST_INCLIST("In- and out-edges, loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS);
    TEST_INCLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE);
    TEST_INCLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE);

    printf("============================================================\n\n");

    printf("Testing lazy loop edge elimination in directed graph\n\n");

    TEST_LAZY_INCLIST("In-edges, loops eliminated", IGRAPH_IN, IGRAPH_NO_LOOPS);
    TEST_LAZY_INCLIST("In-edges, loops listed once", IGRAPH_IN, IGRAPH_LOOPS_ONCE);
    TEST_LAZY_INCLIST("In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_IN, IGRAPH_LOOPS_TWICE);

    TEST_LAZY_INCLIST("Out-edges, loops eliminated", IGRAPH_OUT, IGRAPH_NO_LOOPS);
    TEST_LAZY_INCLIST("Out-edges, loops listed once", IGRAPH_OUT, IGRAPH_LOOPS_ONCE);
    TEST_LAZY_INCLIST("Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given",
        IGRAPH_OUT, IGRAPH_LOOPS_TWICE);

    TEST_LAZY_INCLIST("In- and out-edges, loops eliminated", IGRAPH_ALL, IGRAPH_NO_LOOPS);
    TEST_LAZY_INCLIST("In- and out-edges, loops listed once", IGRAPH_ALL, IGRAPH_LOOPS_ONCE);
    TEST_LAZY_INCLIST("In- and out-edges, loops listed twice", IGRAPH_ALL, IGRAPH_LOOPS_TWICE);

    printf("============================================================\n\n");

    igraph_destroy(&g);

    return 0;
}

int main() {
    int retval;

    RUN_TEST(test_loop_elimination_for_undirected_graph);
    RUN_TEST(test_loop_elimination_for_directed_graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/inclist.out0000644000175100001710000000742200000000000024176 0ustar00runnerdocker00000000000000Testing loop edge elimination in undirected graph

Loops eliminated: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

Loops listed once: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

Loops listed twice: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 3 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

============================================================

Testing lazy loop edge elimination in undirected graph

Loops eliminated: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

Loops listed once: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

Loops listed twice: {
  0: ( 0 5 1 7 )
  1: ( 0 2 )
  2: ( 2 3 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

============================================================

Testing loop edge elimination in directed graph

In-edges, loops eliminated: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 )
  3: ( 1 4 )
  4: ( 6 )
  5: ( 9 12 )
  6: ( 10 )
}

In-edges, loops listed once: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 3 )
  3: ( 1 4 )
  4: ( 6 11 8 )
  5: ( 9 12 )
  6: ( 10 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 3 )
  3: ( 1 4 )
  4: ( 6 11 8 )
  5: ( 9 12 )
  6: ( 10 )
}

Out-edges, loops eliminated: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 4 )
  3: ( 5 6 )
  4: ( 7 9 10 )
  5: ( )
  6: ( 12 )
}

Out-edges, loops listed once: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 3 4 )
  3: ( 5 6 )
  4: ( 7 11 8 9 10 )
  5: ( )
  6: ( 12 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 3 4 )
  3: ( 5 6 )
  4: ( 7 11 8 9 10 )
  5: ( )
  6: ( 12 )
}

In- and out-edges, loops eliminated: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

In- and out-edges, loops listed once: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

In- and out-edges, loops listed twice: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 3 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 11 8 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

============================================================

Testing lazy loop edge elimination in directed graph

In-edges, loops eliminated: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 )
  3: ( 1 4 )
  4: ( 6 )
  5: ( 9 12 )
  6: ( 10 )
}

In-edges, loops listed once: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 3 )
  3: ( 1 4 )
  4: ( 6 11 8 )
  5: ( 9 12 )
  6: ( 10 )
}

In-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 5 7 )
  1: ( 0 )
  2: ( 2 3 )
  3: ( 1 4 )
  4: ( 6 11 8 )
  5: ( 9 12 )
  6: ( 10 )
}

Out-edges, loops eliminated: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 4 )
  3: ( 5 6 )
  4: ( 7 9 10 )
  5: ( )
  6: ( 12 )
}

Out-edges, loops listed once: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 3 4 )
  3: ( 5 6 )
  4: ( 7 11 8 9 10 )
  5: ( )
  6: ( 12 )
}

Out-edges, loops listed once even if IGRAPH_LOOPS_TWICE is given: {
  0: ( 0 1 )
  1: ( 2 )
  2: ( 3 4 )
  3: ( 5 6 )
  4: ( 7 11 8 9 10 )
  5: ( )
  6: ( 12 )
}

In- and out-edges, loops eliminated: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

In- and out-edges, loops listed once: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

In- and out-edges, loops listed twice: {
  0: ( 0 1 5 7 )
  1: ( 0 2 )
  2: ( 2 3 3 4 )
  3: ( 5 1 4 6 )
  4: ( 7 6 11 11 8 8 9 10 )
  5: ( 9 12 )
  6: ( 10 12 )
}

============================================================

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/input.dl0000644000175100001710000000141700000000000023456 0ustar00runnerdocker00000000000000DL n=66
format = edgelist1
labels embedded:
data:
R1 C1
R1 C5
R1 C7
R1 C9
R1 C11
R1 C12
R1 C13
R1 C16
R1 C17
R1 C23
R1 C24
R1 C25
R1 C28
R2 C8
R2 C11
R2 C12
R2 C17
R2 C20
R2 C24
R2 C26
R2 C27
R2 C28
R3 C2
R3 C3
R4 C17
R4 C23
R5 C6
R5 C13
R5 C19
R5 C22
R5 C24
R6 C14
R7 C17
R7 C22
R7 C26
R8 C1
R8 C17
R8 C19
R8 C22
R9 C19
R9 C22
R9 C23
R10 C6
R10 C18
R10 C28
R11 C25
R12 C25
R13 C13
R13 C19
R14 C1
R14 C4
R14 C21
R15 C15
R15 C17
R16 C17
R16 C23
R17 C4
R18 C28
R19 C6
R20 C17
R21 C28
R22 C4
R23 C6
R23 C17
R24 C11
R25 C4
R26 C16
R26 C20
R27 C1
R27 C2
R27 C5
R27 C17
R28 C13
R28 C20
R28 C21
R29 C12
R30 C1
R30 C2
R30 C22
R31 C10
R31 C13
R31 C15
R32 C6
R32 C22
R32 C28
R33 C14
R33 C23
R34 C3
R34 C28
R35 C28
R36 C13
R36 C20
R36 C27
R36 C28
R37 C28
R38 C8
R38 C10
R38 C13
R38 C14
R38 C23
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/isoclasses.c0000644000175100001710000000420300000000000024306 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t edges;
    igraph_vector_t vids;
    igraph_integer_t class;

    igraph_vector_init_int_end(&edges, -1,
                               0, 1, 1, 3, 1, 4, 1, 6, 3, 1,
                               4, 1, 4, 2, 6, 4, 6, 5, 7, 8,
                               8, 7, 7, 9, 9, 7, 8, 9, 9, 8,
                               -1);
    igraph_create(&g, &edges, 0, IGRAPH_DIRECTED);
    igraph_vector_destroy(&edges);

    igraph_vector_init_int_end(&vids, -1, 1, 4, 6, -1);
    igraph_isoclass_subgraph(&g, &vids, &class);
    printf("class: %i\n", (int)class);
    igraph_vector_destroy(&vids);

    igraph_vector_init_int_end(&vids, -1, 0, 1, 3, -1);
    igraph_isoclass_subgraph(&g, &vids, &class);
    printf("class: %i\n", (int)class);
    igraph_vector_destroy(&vids);

    igraph_vector_init_int_end(&vids, -1, 7, 8, 9, -1);
    igraph_isoclass_subgraph(&g, &vids, &class);
    printf("class: %i\n", (int)class);
    igraph_vector_destroy(&vids);

    igraph_vector_init_int_end(&vids, -1, 0, 2, 5, -1);
    igraph_isoclass_subgraph(&g, &vids, &class);
    printf("class: %i\n", (int)class);
    igraph_vector_destroy(&vids);

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/isoclasses.out0000644000175100001710000000004600000000000024674 0ustar00runnerdocker00000000000000class: 12
class: 5
class: 15
class: 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/isoclasses2.c0000644000175100001710000001135000000000000024371 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

/* Check that isoclass() and isoclass_create() are consistent with each other. */
void verify_classes() {
    igraph_integer_t class;
    igraph_integer_t size;

    igraph_integer_t classcountD[] = { 1, 1, 3, 16, 218 }; /* no. of unlabelled directed graphs */
    igraph_integer_t classcountU[] = { 1, 1, 2, 4, 11, 34, 156 }; /* no. of unlabelled undirected graphs */

    /* Directed */
    for (size=3; size <= 4; size++) {
        for (class=0; class < classcountD[size]; class++) {
            igraph_t g;
            igraph_integer_t class2;

            igraph_isoclass_create(&g, size, class, IGRAPH_DIRECTED);
            igraph_isoclass(&g, &class2);
            igraph_destroy(&g);

            IGRAPH_ASSERT(class == class2);
        }
    }

    /* Undirected */
    for (size=3; size <= 6; size++) {
        for (class=0; class < classcountU[size]; class++) {
            igraph_t g;
            igraph_integer_t class2;

            igraph_isoclass_create(&g, size, class, IGRAPH_UNDIRECTED);
            igraph_isoclass(&g, &class2);
            igraph_destroy(&g);

            IGRAPH_ASSERT(class == class2);
        }
    }
}

/* Generate small random graphs and check that their isoclasses are identified correctly. */
void random_test() {
    igraph_integer_t size, i;

    igraph_rng_seed(igraph_rng_default(), 137);

    /* Directed */
    for (size=3; size <= 4; size++) {
        for (i=0; i < 200; ++i) {
            igraph_t g1, g2;
            igraph_integer_t class;
            igraph_bool_t iso;

            igraph_erdos_renyi_game_gnp(&g1, size, 0.5, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);

            igraph_isoclass(&g1, &class);
            igraph_isoclass_create(&g2, size, class, IGRAPH_DIRECTED);

            igraph_isomorphic_bliss(&g1, &g2, NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            IGRAPH_ASSERT(iso);

            igraph_destroy(&g2);
            igraph_destroy(&g1);
        }
    }

    /* Undirected */
    for (size=3; size <= 6; size++) {
        for (i=0; i < 200; ++i) {
            igraph_t g1, g2;
            igraph_integer_t class;
            igraph_bool_t iso;

            igraph_erdos_renyi_game_gnp(&g1, size, 0.5, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

            igraph_isoclass(&g1, &class);
            igraph_isoclass_create(&g2, size, class, IGRAPH_UNDIRECTED);

            igraph_isomorphic_bliss(&g1, &g2, NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            IGRAPH_ASSERT(iso);

            igraph_destroy(&g2);
            igraph_destroy(&g1);
        }
    }
}

/* Generate a random graph, select random subgraphs, and check that their
 * isoclasses are identified correctly. */
void random_subgraph_test() {
    igraph_t graph;
    igraph_integer_t size, i;
    igraph_vector_t vids;

    igraph_rng_seed(igraph_rng_default(), 42);

    igraph_vector_init(&vids, 0);

    /* Directed */

    igraph_erdos_renyi_game_gnp(&graph, 40, 0.5, IGRAPH_DIRECTED, IGRAPH_NO_LOOPS);

    for (size=3; size <= 4; size++) {
        for (i=0; i < 100; ++i) {
            igraph_t sg1, sg2;
            igraph_integer_t class;
            igraph_bool_t iso;

            igraph_random_sample(&vids, 0, igraph_vcount(&graph) - 1, size);
            igraph_isoclass_subgraph(&graph, &vids, &class);
            igraph_isoclass_create(&sg1, size, class, igraph_is_directed(&graph));
            igraph_induced_subgraph(&graph, &sg2, igraph_vss_vector(&vids), IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);

            igraph_isomorphic_bliss(&sg1, &sg2, NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            IGRAPH_ASSERT(iso);

            igraph_destroy(&sg1);
            igraph_destroy(&sg2);
        }
    }

    igraph_destroy(&graph);

    /* Undirected */

    igraph_erdos_renyi_game_gnp(&graph, 60, 0.5, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);

    for (size=3; size <= 6; size++) {
        for (i=0; i < 100; ++i) {
            igraph_t sg1, sg2;
            igraph_integer_t class;
            igraph_bool_t iso;

            igraph_random_sample(&vids, 0, igraph_vcount(&graph) - 1, size);
            igraph_isoclass_subgraph(&graph, &vids, &class);
            igraph_isoclass_create(&sg1, size, class, igraph_is_directed(&graph));
            igraph_induced_subgraph(&graph, &sg2, igraph_vss_vector(&vids), IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);

            igraph_isomorphic_bliss(&sg1, &sg2, NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            IGRAPH_ASSERT(iso);

            igraph_destroy(&sg1);
            igraph_destroy(&sg2);
        }
    }

    igraph_destroy(&graph);

    igraph_vector_destroy(&vids);
}

int main() {

    verify_classes();
    random_test();
    random_subgraph_test();

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/isomorphism_test.c0000644000175100001710000001700400000000000025551 0ustar00runnerdocker00000000000000
#include 
#include 
#include 

#include "test_utilities.inc"

int random_permutation(igraph_vector_t *vec) {
    /* We just do size(vec) * 2 swaps */
    long int one, two, tmp, i, n = igraph_vector_size(vec);
    for (i = 0; i < 2 * n; i++) {
        one = (double)rand() / RAND_MAX * n;
        two = (double)rand() / RAND_MAX * n;
        tmp = one;
        one = two;
        two = tmp;
    }
    return 0;
}


void test3() {
    int i, j;
    igraph_vector_ptr_t graphs3;

    // Verify that no two 3-vertex graphs of distinct isoclasses are considered isomorphic by Bliss or VF2.

    igraph_vector_ptr_init(&graphs3, 0);
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&graphs3, igraph_destroy);

    for (i = 0; i < 16; i++) {
        igraph_t *g;
        g = (igraph_t *) malloc(sizeof(igraph_t));
        igraph_vector_ptr_push_back(&graphs3, g);
        igraph_isoclass_create(g, 3, i, /* directed = */ 1);
    }

    for (i = 0; i < 16; i++)
        for (j = i + 1; j < 16; j++) {
            igraph_bool_t iso;
            igraph_isomorphic_bliss(
                (igraph_t *) VECTOR(graphs3)[i], (igraph_t *) VECTOR(graphs3)[j],
                NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            if (iso) {
                printf("Bliss failure, 3 vertex directed graphs of isoclass %d and %d are not isomorphic. Bliss reports otherwise.\n", i, j);
            }
        }

    for (i = 0; i < 16; i++)
        for (j = i + 1; j < 16; j++) {
            igraph_bool_t iso;
            igraph_isomorphic_vf2(
                (igraph_t *) VECTOR(graphs3)[i], (igraph_t *) VECTOR(graphs3)[j],
                NULL, NULL, NULL, NULL, &iso, NULL, NULL, NULL, NULL, NULL);
            if (iso) {
                printf("VF2 failure, 3 vertex directed graphs of isoclass %d and %d are not isomorphic. VF2 reports otherwise.\n", i, j);
            }
        }

    igraph_vector_ptr_destroy_all(&graphs3);
}


void test4() {
    int i, j;
    igraph_vector_ptr_t graphs4;

    // Verify that no two 4-vertex graphs of distinct isoclasses are considered isomorphic by Bliss or VF2.

    igraph_vector_ptr_init(&graphs4, 0);
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&graphs4, igraph_destroy);

    for (i = 0; i < 218; i++) {
        igraph_t *g;
        g = (igraph_t *) malloc(sizeof(igraph_t));
        igraph_vector_ptr_push_back(&graphs4, g);
        igraph_isoclass_create(g, 4, i, /* directed = */ 1);
    }

    for (i = 0; i < 218; i++)
        for (j = i + 1; j < 218; j++) {
            igraph_bool_t iso;
            igraph_isomorphic_bliss(
                (igraph_t *) VECTOR(graphs4)[i], (igraph_t *) VECTOR(graphs4)[j],
                NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
            if (iso) {
                printf("Bliss failure, 4 vertex directed graphs of isoclass %d and %d are not isomorphic. Bliss reports otherwise.\n", i, j);
            }
        }

    for (i = 0; i < 218; i++)
        for (j = i + 1; j < 218; j++) {
            igraph_bool_t iso;
            igraph_isomorphic_vf2(
                (igraph_t *) VECTOR(graphs4)[i], (igraph_t *) VECTOR(graphs4)[j],
                NULL, NULL, NULL, NULL, &iso, NULL, NULL, NULL, NULL, NULL);
            if (iso) {
                printf("VF2 failure, 4 vertex directed graphs of isoclass %d and %d are not isomorphic. VF2 reports otherwise.\n", i, j);
            }
        }

    igraph_vector_ptr_destroy_all(&graphs4);
}


void test_bliss() {
    igraph_t ring1, ring2, directed_ring;
    igraph_vector_t perm;
    igraph_bool_t iso;
    igraph_bliss_info_t info;
    igraph_vector_int_t color;
    igraph_vector_ptr_t generators;

    igraph_ring(&ring1, 100, /*directed=*/ 0, /*mutual=*/ 0, /*circular=*/1);
    igraph_vector_init_seq(&perm, 0, igraph_vcount(&ring1) - 1);
    random_permutation(&perm);
    igraph_permute_vertices(&ring1, &ring2, &perm);

    igraph_ring(&directed_ring, 100, /* directed= */ 1, /* mutual = */0, /* circular = */1);

    igraph_vector_ptr_init(&generators, 0);
    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&generators, igraph_vector_destroy);

    igraph_isomorphic_bliss(&ring1, &ring2, NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
    if (! iso) {
        printf("Bliss failed on ring isomorphism.\n");
    }

    igraph_automorphisms(&ring1, NULL, IGRAPH_BLISS_F, &info);
    if (strcmp(info.group_size, "200") != 0) {
        printf("Biss automorphism count failed: ring1.\n");
    }
    igraph_free(info.group_size);

    igraph_automorphisms(&ring2, NULL, IGRAPH_BLISS_F, &info);
    if (strcmp(info.group_size, "200") != 0) {
        printf("Biss automorphism count failed: ring2.\n");
    }
    igraph_free(info.group_size);

    igraph_automorphisms(&directed_ring, NULL, IGRAPH_BLISS_F, &info);
    if (strcmp(info.group_size, "100") != 0) {
        printf("Biss automorphism count failed: directed_ring.\n");
    }
    igraph_free(info.group_size);

    // The follwing test is included so there is at least one call to igraph_automorphism_group
    // in the test suite. However, the generator set returned may depend on the splitting
    // heursitics as well as on the Bliss version. If the test fails, please verify manually
    // that the generating set is valid. For a undirected cycle graph like ring2, there should
    // be two generators: a cyclic permutation and a reversal of the vertex order.
    igraph_automorphism_group(&ring2, NULL, &generators, IGRAPH_BLISS_F, NULL);
    if (igraph_vector_ptr_size(&generators) != 2)
        printf("Bliss automorphism generators may have failed with ring2. "
               "Please verify the generators manually. "
               "Note that the generator set is not guaranteed to be minimal.\n");
    igraph_vector_ptr_free_all(&generators);

    // For a directed ring, the only generator should be a cyclic permutation.
    igraph_automorphism_group(&directed_ring, NULL, &generators, IGRAPH_BLISS_F, NULL);
    if (igraph_vector_ptr_size(&generators) != 1)
        printf("Bliss automorphism generators may have failed with directed_ring. "
               "Please verify the generators manually. "
               "Note that the generator set is not guaranteed to be minimal.\n");
    igraph_vector_ptr_free_all(&generators);

    igraph_vector_int_init_seq(&color, 0, igraph_vcount(&ring1) - 1);

    igraph_automorphisms(&ring1, &color, IGRAPH_BLISS_F, &info);
    if (strcmp(info.group_size, "1") != 0) {
        printf("Biss automorphism count with color failed: ring1.\n");
    }
    igraph_free(info.group_size);

    // There's only one automorphism for this coloured graph, so the generating set is empty.
    igraph_automorphism_group(&ring1, &color, &generators, IGRAPH_BLISS_F, NULL);
    if (igraph_vector_ptr_size(&generators) != 0) {
        printf("Bliss automorphism generators failed with colored graph.\n");
    }

    igraph_vector_ptr_destroy_all(&generators);

    igraph_vector_int_destroy(&color);

    igraph_vector_destroy(&perm);

    igraph_destroy(&ring1);
    igraph_destroy(&ring2);
    igraph_destroy(&directed_ring);
}

void test_bug_995() {
    igraph_t g1, g2;
    igraph_bool_t result;

    igraph_small(&g1, 3, 0, 0, 1, 1, 2, 2, 2, -1);
    igraph_small(&g2, 3, 0, 0, 1, 1, 2, 1, 1, -1);

    igraph_isomorphic(&g1, &g2, &result);
    if (result) {
        printf("igraph_isomorphic() failed with loop edges, see bug #995\n");
    }

    igraph_destroy(&g1);
    igraph_destroy(&g2);
}

int main() {

    srand(293847); /* rand() is used in random_permutation() */

    test3();
    test4();
    test_bliss();
    test_bug_995();

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/isomorphism_test.out0000644000175100001710000000000000000000000026122 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/levc-stress.c0000644000175100001710000000446000000000000024415 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/* vim:set sw=4 ts=4 sts=4 et: */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

/* This is a test for bug #1002140, reported by Luiz Fernando
   Bittencourt: https://bugs.launchpad.net/igraph/+bug/1002140 */

#include 

#include "test_utilities.inc"

int main() {

    int k;
    for (k = 0; k < 20; k++) {
        igraph_t g;
        igraph_matrix_t merges;
        igraph_vector_t membership;
        igraph_arpack_options_t options;
        double modularity;
        igraph_vector_t history;
        FILE *DLFile = fopen("input.dl", "r");

        igraph_read_graph_dl(&g, DLFile, /*directed=*/ 0);
        fclose(DLFile);

        igraph_matrix_init(&merges, 0, 0);
        igraph_vector_init(&membership, 0);
        igraph_vector_init(&history, 0);
        igraph_arpack_options_init(&options);

        igraph_community_leading_eigenvector(&g, /*weights=*/ 0, &merges,
                                             &membership, igraph_vcount(&g),
                                             &options, &modularity,
                                             /*start=*/ 0, /*eigenvalues=*/ 0,
                                             /*eigenvectors=*/ 0, &history,
                                             /*callback=*/ 0,
                                             /*callback_extra=*/ 0);

        igraph_vector_destroy(&history);
        igraph_vector_destroy(&membership);
        igraph_matrix_destroy(&merges);
        igraph_destroy(&g);
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/lineendings.c0000644000175100001710000000356100000000000024443 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

int main() {

    igraph_t g;
    FILE *ifile;

    /* turn on attribute handling */
    /*   igraph_set_attribute_table(&igraph_cattribute_table); */

    ifile = fopen("pajek1.net", "r");
    if (ifile == 0) {
        return 1;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    igraph_write_graph_pajek(&g, stdout);
    igraph_destroy(&g);

    ifile = fopen("pajek2.net", "r");
    if (ifile == 0) {
        return 2;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    igraph_write_graph_pajek(&g, stdout);
    igraph_destroy(&g);

    ifile = fopen("pajek3.net", "r");
    if (ifile == 0) {
        return 3;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    igraph_write_graph_pajek(&g, stdout);
    igraph_destroy(&g);

    ifile = fopen("pajek4.net", "r");
    if (ifile == 0) {
        return 4;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    igraph_write_graph_pajek(&g, stdout);
    igraph_destroy(&g);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/lineendings.out0000644000175100001710000000034400000000000025024 0ustar00runnerdocker00000000000000*Vertices 10
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
*Vertices 10
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
*Vertices 10
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
*Vertices 10
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/marked_queue.c0000644000175100001710000000340400000000000024607 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include "core/marked_queue.h"

#include "test_utilities.inc"

int main() {
    igraph_marked_queue_t Q;
    long int i;

    igraph_marked_queue_init(&Q, 100);
    for (i = 0; i < 50; i++) {
        igraph_marked_queue_push(&Q, i);
        if (!igraph_marked_queue_iselement(&Q, i)) {
            return 4;
        }
        if (! ((i + 1) % 5)) {
            igraph_marked_queue_start_batch(&Q);
        }
    }

    for (i = 1; i < 50; i++) {
        if (!igraph_marked_queue_iselement(&Q, i)) {
            printf("Problem with %li.\n", i);
            return 3;
        }
    }

    for (i = 0; i <= 50 / 5; i++) {
        if (igraph_marked_queue_empty(&Q)) {
            return 1;
        }
        igraph_marked_queue_pop_back_batch(&Q);
    }
    if (!igraph_marked_queue_empty(&Q)) {
        return 2;
    }

    igraph_marked_queue_destroy(&Q);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/matrix.c0000644000175100001710000001066000000000000023446 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_matrix_t m, m1;
    long int i, j, k;

    /* igraph_matrix_init, igraph_matrix_destroy */
    igraph_matrix_init(&m, 10, 10);
    igraph_matrix_destroy(&m);

    igraph_matrix_init(&m, 0, 0);
    igraph_matrix_destroy(&m);

    /* igraph_matrix_ncol, igraph_matrix_nrow */
    igraph_matrix_init(&m, 10, 5);
    if (igraph_matrix_nrow(&m) != 10) {
        return 1;
    }
    if (igraph_matrix_ncol(&m) != 5) {
        return 2;
    }

    /* igraph_matrix_size, igraph_matrix_resize */
    igraph_matrix_resize(&m, 6, 5);
    if (igraph_matrix_size(&m) != 30) {
        return 3;
    }
    if (igraph_matrix_nrow(&m) != 6) {
        return 4;
    }
    if (igraph_matrix_ncol(&m) != 5) {
        return 5;
    }
    igraph_matrix_resize(&m, 2, 4);
    if (igraph_matrix_nrow(&m) != 2) {
        return 6;
    }
    if (igraph_matrix_ncol(&m) != 4) {
        return 7;
    }
    igraph_matrix_destroy(&m);

    /* MATRIX, igraph_matrix_null */
    igraph_matrix_init(&m, 3, 4);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        for (j = 0; j < igraph_matrix_ncol(&m); j++) {
            MATRIX(m, i, j) = i + 1;
        }
    }
    print_matrix(&m);
    igraph_matrix_null(&m);
    print_matrix(&m);
    igraph_matrix_destroy(&m);

    /* igraph_matrix_add_cols, igraph_matrix_add_rows */
    igraph_matrix_init(&m, 4, 3);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        for (j = 0; j < igraph_matrix_ncol(&m); j++) {
            MATRIX(m, i, j) = (i + 1) * (j + 1);
        }
    }
    igraph_matrix_add_cols(&m, 2);
    igraph_matrix_add_rows(&m, 2);
    if (igraph_matrix_ncol(&m) != 5) {
        return 8;
    }
    if (igraph_matrix_nrow(&m) != 6) {
        return 9;
    }
    igraph_matrix_destroy(&m);

    /* igraph_matrix_remove_col */
    igraph_matrix_init(&m, 5, 3);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        for (j = 0; j < igraph_matrix_ncol(&m); j++) {
            MATRIX(m, i, j) = (i + 1) * (j + 1);
        }
    }
    igraph_matrix_remove_col(&m, 0);
    print_matrix(&m);
    igraph_matrix_remove_col(&m, 1);
    print_matrix(&m);
    igraph_matrix_destroy(&m);

    /* TODO: igraph_matrix_permdelete_rows */
    /* TODO: igraph_matrix_delete_rows_neg */

    /* igraph_matrix_copy */
    igraph_matrix_init(&m, 2, 3);
    for (i = 0; i < igraph_matrix_nrow(&m); i++) {
        for (j = 0; j < igraph_matrix_ncol(&m); j++) {
            MATRIX(m, i, j) = (i + 1) * (j + 1);
        }
    }
    igraph_matrix_copy(&m1, &m);
    print_matrix(&m1);
    igraph_matrix_destroy(&m);
    igraph_matrix_destroy(&m1);

    /* in-place transpose */
    igraph_matrix_init(&m, 5, 2);
    k = 0;
    for (i = 0; i < igraph_matrix_ncol(&m); i++) {
        for (j = 0; j < igraph_matrix_nrow(&m); j++) {
            MATRIX(m, j, i) = k++;
        }
    }
    print_matrix(&m);
    igraph_matrix_transpose(&m);
    print_matrix(&m);
    igraph_matrix_destroy(&m);

    igraph_matrix_init(&m, 5, 1);
    k = 0;
    for (i = 0; i < igraph_matrix_ncol(&m); i++) {
        for (j = 0; j < igraph_matrix_nrow(&m); j++) {
            MATRIX(m, j, i) = k++;
        }
    }
    print_matrix(&m);
    igraph_matrix_transpose(&m);
    print_matrix(&m);
    igraph_matrix_destroy(&m);

    igraph_matrix_init(&m, 1, 5);
    k = 0;
    for (i = 0; i < igraph_matrix_ncol(&m); i++) {
        for (j = 0; j < igraph_matrix_nrow(&m); j++) {
            MATRIX(m, j, i) = k++;
        }
    }
    print_matrix(&m);
    igraph_matrix_transpose(&m);
    print_matrix(&m);
    igraph_matrix_destroy(&m);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/matrix.out0000644000175100001710000000153500000000000024034 0ustar00runnerdocker00000000000000[        1        1        1        1
         2        2        2        2
         3        3        3        3 ]
[        0        0        0        0
         0        0        0        0
         0        0        0        0 ]
[        2        3
         4        6
         6        9
         8       12
        10       15 ]
[        2
         4
         6
         8
        10 ]
[        1        2        3
         2        4        6 ]
[        0        5
         1        6
         2        7
         3        8
         4        9 ]
[        0        1        2        3        4
         5        6        7        8        9 ]
[        0
         1
         2
         3
         4 ]
[        0        1        2        3        4 ]
[        0        1        2        3        4 ]
[        0
         1
         2
         3
         4 ]
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/matrix2.c0000644000175100001710000002157700000000000023541 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

void byrow(igraph_matrix_t *m) {
    long int r = igraph_matrix_nrow(m), c = igraph_matrix_ncol(m);
    long int n = 0, i, j;
    for (i = 0; i < r; i++) {
        for (j = 0; j < c; j++) {
            MATRIX(*m, i, j) = n++;
        }
    }
}

#define apply(m,a,b) \
    for (i=0; i
   334 Harvard st, Cambridge MA, USA 02139

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_matrix_t m;

    igraph_matrix_init(&m, 10, 10);
    if (igraph_matrix_capacity(&m) != 100) {
        return 1;
    }

    igraph_matrix_add_cols(&m, 5);
    igraph_matrix_resize(&m, 5, 5);
    igraph_matrix_resize_min(&m);
    if (igraph_matrix_capacity(&m) != igraph_matrix_size(&m)) {
        return 2;
    }

    igraph_matrix_destroy(&m);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/maximal_cliques_callback.c0000644000175100001710000000461700000000000027140 0ustar00runnerdocker00000000000000
#include 
#include 

#include "test_utilities.inc"

struct userdata {
    int i;
    igraph_vector_ptr_t *list;
};

int compare_vectors(const void *p1, const void *p2) {
    igraph_vector_t *v1, *v2;
    long s1, s2, i;

    v1 = *((igraph_vector_t **) p1);
    v2 = *((igraph_vector_t **) p2);
    s1 = igraph_vector_size(v1);
    s2 = igraph_vector_size(v2);
    if (s1 < s2) {
        return -1;
    }
    if (s1 > s2) {
        return 1;
    }
    for (i = 0; i < s1; ++i) {
        if (VECTOR(*v1)[i] < VECTOR(*v2)[i]) {
            return -1;
        }
        if (VECTOR(*v1)[i] > VECTOR(*v2)[i]) {
            return 1;
        }
    }
    return 0;
}


igraph_bool_t handler(igraph_vector_t *clique, void *arg) {
    struct userdata *ud;
    igraph_bool_t cont;

    ud = (struct userdata *) arg;
    cont = 1; /* true */

    if (compare_vectors(&clique, &(VECTOR(*(ud->list))[ud->i])) != 0) {
        printf("igraph_maximal_cliques() and igraph_maximal_cliques_callback() give different results.\n");
        cont = 0; /* false */
    }

    igraph_vector_destroy(clique);
    igraph_free(clique);

    ud->i += 1;

    return cont;
}


igraph_bool_t handler_stop(igraph_vector_t *clique, void *arg) {
    /* Stop search as soon as a 3-clique is found. */
    /* Since there are two 3-cliques in the test graph, this will stop the search before it is complete. */
    if (igraph_vector_size(clique) == 3) {
        igraph_vector_destroy(clique);
        igraph_free(clique);

        return 0;    /* false */
    }

    igraph_vector_destroy(clique);
    igraph_free(clique);

    return 1 /* true */;
}


int main() {
    igraph_t graph;
    igraph_vector_ptr_t list;
    struct userdata ud;

    igraph_small(&graph, 6, 0,
                 1, 2, 2, 3, 3, 4, 4, 5, 5, 2, 2, 4,
                 -1);

    igraph_vector_ptr_init(&list, 0);
    igraph_maximal_cliques(&graph, &list, 0, 0);

    ud.i = 0;
    ud.list = &list;

    /* Check that the callback function finds the same cliques as igraph_maximal_cliques() */
    igraph_maximal_cliques_callback(&graph, &handler, (void *) &ud, 0, 0);

    /* Check that the search can be stopped correctly */
    igraph_maximal_cliques_callback(&graph, &handler_stop, NULL, 0, 0);

    IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&list, igraph_vector_destroy);
    igraph_vector_ptr_destroy_all(&list);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/maximal_cliques_hist.c0000644000175100001710000000070200000000000026342 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_t hist;

    igraph_small(&graph, 6, 0,
                 1, 2, 2, 3, 3, 4, 4, 5, 5, 2, 2, 4,
                 -1);

    igraph_vector_init(&hist, 0);

    igraph_maximal_cliques_hist(&graph, &hist, 0, 0);
    igraph_vector_print(&hist);

    igraph_vector_destroy(&hist);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/maximal_cliques_hist.out0000644000175100001710000000000600000000000026724 0ustar00runnerdocker000000000000001 1 2
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/mt.c0000644000175100001710000000216000000000000022556 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

int main() {

    long int i;
    for (i = 0; i < 1000; i++) {
        igraph_real_t r = igraph_rng_get_unif01(igraph_rng_default());
        if (r < 0 || r > 1) {
            return 1;
        }
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek.c0000644000175100001710000000306300000000000023233 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2010-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    FILE *ifile;

    ifile = fopen("pajek5.net", "r");
    if (!ifile) {
        return 1;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    if (igraph_vcount(&g) != 10 || igraph_ecount(&g) != 9 ||
        igraph_is_directed(&g)) {
        return 2;
    }
    igraph_destroy(&g);

    ifile = fopen("pajek6.net", "r");
    if (!ifile) {
        return 3;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    if (igraph_vcount(&g) != 10 || igraph_ecount(&g) != 9 ||
        !igraph_is_directed(&g)) {
        return 4;
    }
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek1.net0000644000175100001710000000100400000000000023651 0ustar00runnerdocker00000000000000*Vertices 10
1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green
2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green
3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green
4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green
5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green
6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue
7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red
8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green
9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green
10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek2.c0000644000175100001710000000300400000000000023310 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    FILE *ifile;
    int i, n;

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    ifile = fopen("bipartite.net", "r");
    if (!ifile) {
        return 5;
    }
    igraph_read_graph_pajek(&g, ifile);
    fclose(ifile);
    if (igraph_vcount(&g) != 13 || igraph_ecount(&g) != 11 ||
        igraph_is_directed(&g)) {
        return 6;
    }

    for (i = 0, n = igraph_vcount(&g); i < n; i++) {
        printf("%i ", (int) VAN(&g, "type", i));
    }
    printf("\n");

    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek2.net0000644000175100001710000000100400000000000023652 0ustar00runnerdocker00000000000000*Vertices 10
1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green
2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green
3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green
4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green
5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green
6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue
7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red
8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green
9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green
10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek2.out0000644000175100001710000000003300000000000023674 0ustar00runnerdocker000000000000000 0 0 0 0 0 0 0 1 1 1 1 1 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek3.net0000644000175100001710000000103100000000000023653 0ustar00runnerdocker00000000000000*Vertices 10
1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green
2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green
3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green
4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green
5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green
6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue
7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red
8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green
9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green
10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green
*Edges
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek4.net0000644000175100001710000000103000000000000023653 0ustar00runnerdocker00000000000000*Vertices 10

1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green

2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green

3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green

4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green

5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green

6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue

7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red

8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green

9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green

10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green

*Edges

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek5.net0000644000175100001710000000100600000000000023657 0ustar00runnerdocker00000000000000*Vertices 10
1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green
2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green
3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green
4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green
5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green
6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue
7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red
8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green
9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green
10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green
*Edges 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek6.net0000644000175100001710000000100500000000000023657 0ustar00runnerdocker00000000000000*Vertices 10
1 "Vert 1" 0 0 box x_fact 1 y_fact 1 ic Green
2 "Vert 2" 0 0 box x_fact 1 y_fact 1 ic Green
3 "Vert 3" 0 0 box x_fact 1 y_fact 1 ic Green
4 "Vert 4" 0 0 box x_fact 1 y_fact 1 ic Green
5 "Vert 5" 0 0 box x_fact 1 y_fact 1 ic Green
6 "Vert 6" 0 0 box x_fact 1 y_fact 1 ic Blue
7 "Vert 7" 0 0 box x_fact 1 y_fact 1 ic Red
8 "Vert 8" 0 0 box x_fact 1 y_fact 1 ic Green
9 "Vert 9" 0 0 box x_fact 1 y_fact 1 ic Green
10 "Vert 10" 0 0 box x_fact 1 y_fact 1 ic Green
*Arcs 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bip.net0000644000175100001710000000034500000000000024431 0ustar00runnerdocker00000000000000*vertices 15 10
 1 "A"
 2 "B"
 3 "C"
 4 "D"
 5 "E"
 6 "F"
 7 "G"
 8 "H"
 9 "I"
10 "J"
11 "1"
12 "2"
13 "3"
14 "4"
15 "5"
*matrix
1 0 0 0 0
1 1 0 0 0
1 1 1 0 0
1 1 1 1 0
1 1 1 1 1
0 0 0 0 1
1 0 0 0 1
1 1 0 1 1
0 0 0 0 0
1 0 1 0 1
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bip2.net0000644000175100001710000000037100000000000024512 0ustar00runnerdocker00000000000000*vertices 15 10
 1 "A"
 2 "B"
 3 "C"
 4 "D"
 5 "E"
 6 "F"
 7 "G"
 8 "H"
 9 "I"
10 "J"
11 "1"
12 "2"
13 "3"
14 "4"
15 "5"
*matrix
1 0 0 0 0 1
1 1 0 0 0 2
1 1 1 0 0 3
1 1 1 1 0 4
1 1 1 1 1 5
0 0 0 0 1 1
1 0 0 0 1 2
1 1 0 1 1 4
0 0 0 0 0 0
1 0 1 0 1 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bipartite.c0000644000175100001710000000267500000000000025306 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_vector_bool_t type;
    igraph_bool_t typev[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    igraph_ring(&graph, 10, IGRAPH_UNDIRECTED, /*mutual=*/ 0, /*circular=*/ 1);
    igraph_vector_bool_view(&type, typev, sizeof(typev) / sizeof(igraph_bool_t));
    SETVABV(&graph, "type", &type);

    igraph_write_graph_pajek(&graph, stdout);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bipartite.out0000644000175100001710000000017600000000000025665 0ustar00runnerdocker00000000000000*Vertices 10 5
1 "1"
2 "3"
3 "5"
4 "7"
5 "9"
6 "2"
7 "4"
8 "6"
9 "8"
10 "10"
*Edges
1 6
6 2
2 7
7 3
3 8
8 4
4 9
9 5
5 10
1 10
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bipartite2.c0000644000175100001710000000676300000000000025372 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int print_attributes(const igraph_t *g) {

    igraph_vector_t gtypes, vtypes, etypes;
    igraph_strvector_t gnames, vnames, enames;
    long int i;

    igraph_vector_init(>ypes, 0);
    igraph_vector_init(&vtypes, 0);
    igraph_vector_init(&etypes, 0);
    igraph_strvector_init(&gnames, 0);
    igraph_strvector_init(&vnames, 0);
    igraph_strvector_init(&enames, 0);

    igraph_cattribute_list(g, &gnames, >ypes, &vnames, &vtypes,
                           &enames, &etypes);

    for (i = 0; i < igraph_vcount(g); i++) {
        long int j;
        printf("Vertex %li: ", i);
        for (j = 0; j < igraph_strvector_size(&vnames); j++) {
            printf("%s=", STR(vnames, j));
            if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(VAN(g, STR(vnames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", VAS(g, STR(vnames, j), i));
            }
        }
        printf("\n");
    }

    for (i = 0; i < igraph_ecount(g); i++) {
        long int j;
        int u = IGRAPH_FROM(g, i), v = IGRAPH_TO(g, i);
        if (u < v && !igraph_is_directed(g)) {
            u = IGRAPH_TO(g, i);
            v = IGRAPH_FROM(g, i);
        }
        printf("Edge %li (%i-%i): ", i, u, v);
        for (j = 0; j < igraph_strvector_size(&enames); j++) {
            printf("%s=", STR(enames, j));
            if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(EAN(g, STR(enames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", EAS(g, STR(enames, j), i));
            }
        }
        printf("\n");
    }

    igraph_strvector_destroy(&enames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&gnames);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(>ypes);

    return 0;
}

int main() {
    igraph_t graph;
    FILE *input;

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    /* first file, without marginals */

    input = fopen("pajek_bip.net", "r");
    if (input == 0) {
        return 1;
    }

    igraph_read_graph_pajek(&graph, input);
    fclose(input);

    print_attributes(&graph);

    igraph_destroy(&graph);

    /* second file, with marginals */

    printf("---\n");

    input = fopen("pajek_bip2.net", "r");
    if (input == 0) {
        return 1;
    }

    igraph_read_graph_pajek(&graph, input);
    fclose(input);

    print_attributes(&graph);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_bipartite2.out0000644000175100001710000000441200000000000025744 0ustar00runnerdocker00000000000000Vertex 0: type=0 id="A" name="A" 
Vertex 1: type=0 id="B" name="B" 
Vertex 2: type=0 id="C" name="C" 
Vertex 3: type=0 id="D" name="D" 
Vertex 4: type=0 id="E" name="E" 
Vertex 5: type=0 id="F" name="F" 
Vertex 6: type=0 id="G" name="G" 
Vertex 7: type=0 id="H" name="H" 
Vertex 8: type=0 id="I" name="I" 
Vertex 9: type=0 id="J" name="J" 
Vertex 10: type=1 id="1" name="1" 
Vertex 11: type=1 id="2" name="2" 
Vertex 12: type=1 id="3" name="3" 
Vertex 13: type=1 id="4" name="4" 
Vertex 14: type=1 id="5" name="5" 
Edge 0 (10-0): weight=1 
Edge 1 (10-1): weight=1 
Edge 2 (11-1): weight=1 
Edge 3 (10-2): weight=1 
Edge 4 (11-2): weight=1 
Edge 5 (12-2): weight=1 
Edge 6 (10-3): weight=1 
Edge 7 (11-3): weight=1 
Edge 8 (12-3): weight=1 
Edge 9 (13-3): weight=1 
Edge 10 (10-4): weight=1 
Edge 11 (11-4): weight=1 
Edge 12 (12-4): weight=1 
Edge 13 (13-4): weight=1 
Edge 14 (14-4): weight=1 
Edge 15 (14-5): weight=1 
Edge 16 (10-6): weight=1 
Edge 17 (14-6): weight=1 
Edge 18 (10-7): weight=1 
Edge 19 (11-7): weight=1 
Edge 20 (13-7): weight=1 
Edge 21 (14-7): weight=1 
Edge 22 (10-9): weight=1 
Edge 23 (12-9): weight=1 
Edge 24 (14-9): weight=1 
---
Vertex 0: type=0 id="A" name="A" 
Vertex 1: type=0 id="B" name="B" 
Vertex 2: type=0 id="C" name="C" 
Vertex 3: type=0 id="D" name="D" 
Vertex 4: type=0 id="E" name="E" 
Vertex 5: type=0 id="F" name="F" 
Vertex 6: type=0 id="G" name="G" 
Vertex 7: type=0 id="H" name="H" 
Vertex 8: type=0 id="I" name="I" 
Vertex 9: type=0 id="J" name="J" 
Vertex 10: type=1 id="1" name="1" 
Vertex 11: type=1 id="2" name="2" 
Vertex 12: type=1 id="3" name="3" 
Vertex 13: type=1 id="4" name="4" 
Vertex 14: type=1 id="5" name="5" 
Edge 0 (10-0): weight=1 
Edge 1 (10-1): weight=1 
Edge 2 (11-1): weight=1 
Edge 3 (10-2): weight=1 
Edge 4 (11-2): weight=1 
Edge 5 (12-2): weight=1 
Edge 6 (10-3): weight=1 
Edge 7 (11-3): weight=1 
Edge 8 (12-3): weight=1 
Edge 9 (13-3): weight=1 
Edge 10 (10-4): weight=1 
Edge 11 (11-4): weight=1 
Edge 12 (12-4): weight=1 
Edge 13 (13-4): weight=1 
Edge 14 (14-4): weight=1 
Edge 15 (14-5): weight=1 
Edge 16 (10-6): weight=1 
Edge 17 (14-6): weight=1 
Edge 18 (10-7): weight=1 
Edge 19 (11-7): weight=1 
Edge 20 (13-7): weight=1 
Edge 21 (14-7): weight=1 
Edge 22 (10-9): weight=1 
Edge 23 (12-9): weight=1 
Edge 24 (14-9): weight=1 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_signed.c0000644000175100001710000000605600000000000024571 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard street, Cambridge, MA 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int print_attributes(const igraph_t *g) {

    igraph_vector_t gtypes, vtypes, etypes;
    igraph_strvector_t gnames, vnames, enames;
    long int i;

    igraph_vector_init(>ypes, 0);
    igraph_vector_init(&vtypes, 0);
    igraph_vector_init(&etypes, 0);
    igraph_strvector_init(&gnames, 0);
    igraph_strvector_init(&vnames, 0);
    igraph_strvector_init(&enames, 0);

    igraph_cattribute_list(g, &gnames, >ypes, &vnames, &vtypes,
                           &enames, &etypes);

    for (i = 0; i < igraph_vcount(g); i++) {
        long int j;
        printf("Vertex %li: ", i);
        for (j = 0; j < igraph_strvector_size(&vnames); j++) {
            printf("%s=", STR(vnames, j));
            if (VECTOR(vtypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(VAN(g, STR(vnames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", VAS(g, STR(vnames, j), i));
            }
        }
        printf("\n");
    }

    for (i = 0; i < igraph_ecount(g); i++) {
        long int j;
        printf("Edge %li (%i-%i): ", i, (int)IGRAPH_FROM(g, i), (int)IGRAPH_TO(g, i));
        for (j = 0; j < igraph_strvector_size(&enames); j++) {
            printf("%s=", STR(enames, j));
            if (VECTOR(etypes)[j] == IGRAPH_ATTRIBUTE_NUMERIC) {
                igraph_real_printf(EAN(g, STR(enames, j), i));
                putchar(' ');
            } else {
                printf("\"%s\" ", EAS(g, STR(enames, j), i));
            }
        }
        printf("\n");
    }

    igraph_strvector_destroy(&enames);
    igraph_strvector_destroy(&vnames);
    igraph_strvector_destroy(&gnames);
    igraph_vector_destroy(&etypes);
    igraph_vector_destroy(&vtypes);
    igraph_vector_destroy(>ypes);

    return 0;
}

int main() {
    igraph_t graph;
    FILE *input;

    /* turn on attribute handling */
    igraph_set_attribute_table(&igraph_cattribute_table);

    input = fopen("pajek_signed.net", "r");
    if (input == 0) {
        return 1;
    }

    igraph_read_graph_pajek(&graph, input);
    fclose(input);

    print_attributes(&graph);

    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_signed.net0000644000175100001710000000055400000000000025132 0ustar00runnerdocker00000000000000*NETWORK First.net; 14.04.2009 / 09:46:56
*Vertices 10
1 "S65"
2 "S29"
3 "S04"
4 "S75"
5 "S24"
6 "S81"
7 "S51"
8 "S78"
9 "S86"
10 "S39"
*Matrix
 0 0 0 0 0 1 0 0 0 -1
 0 0 1 1 0 1 1 0 1 0
 -1 0 0 1 0 0 1 0 1 0
 -1 1 0 0 1 1 1 0 1 0
 0 1 0 1 0 0 0 0 -1 -1
 1 -1 0 0 0 0 0 1 0 0
 0 -1 1 1 0 -1 0 0 1 0
 0 0 1 1 0 1 -1 0 1 1
 0 0 0 0 0 0 0 0 0 -1
 1 1 1 1 1 1 1 1 1 0
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/pajek_signed.out0000644000175100001710000000263300000000000025153 0ustar00runnerdocker00000000000000Vertex 0: id="S65" name="S65" 
Vertex 1: id="S29" name="S29" 
Vertex 2: id="S04" name="S04" 
Vertex 3: id="S75" name="S75" 
Vertex 4: id="S24" name="S24" 
Vertex 5: id="S81" name="S81" 
Vertex 6: id="S51" name="S51" 
Vertex 7: id="S78" name="S78" 
Vertex 8: id="S86" name="S86" 
Vertex 9: id="S39" name="S39" 
Edge 0 (0-5): weight=1 
Edge 1 (0-9): weight=-1 
Edge 2 (1-2): weight=1 
Edge 3 (1-3): weight=1 
Edge 4 (1-5): weight=1 
Edge 5 (1-6): weight=1 
Edge 6 (1-8): weight=1 
Edge 7 (2-0): weight=-1 
Edge 8 (2-3): weight=1 
Edge 9 (2-6): weight=1 
Edge 10 (2-8): weight=1 
Edge 11 (3-0): weight=-1 
Edge 12 (3-1): weight=1 
Edge 13 (3-4): weight=1 
Edge 14 (3-5): weight=1 
Edge 15 (3-6): weight=1 
Edge 16 (3-8): weight=1 
Edge 17 (4-1): weight=1 
Edge 18 (4-3): weight=1 
Edge 19 (4-8): weight=-1 
Edge 20 (4-9): weight=-1 
Edge 21 (5-0): weight=1 
Edge 22 (5-1): weight=-1 
Edge 23 (5-7): weight=1 
Edge 24 (6-1): weight=-1 
Edge 25 (6-2): weight=1 
Edge 26 (6-3): weight=1 
Edge 27 (6-5): weight=-1 
Edge 28 (6-8): weight=1 
Edge 29 (7-2): weight=1 
Edge 30 (7-3): weight=1 
Edge 31 (7-5): weight=1 
Edge 32 (7-6): weight=-1 
Edge 33 (7-8): weight=1 
Edge 34 (7-9): weight=1 
Edge 35 (8-9): weight=-1 
Edge 36 (9-0): weight=1 
Edge 37 (9-1): weight=1 
Edge 38 (9-2): weight=1 
Edge 39 (9-3): weight=1 
Edge 40 (9-4): weight=1 
Edge 41 (9-5): weight=1 
Edge 42 (9-6): weight=1 
Edge 43 (9-7): weight=1 
Edge 44 (9-8): weight=1 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/random_spanning_tree.c0000644000175100001710000000466000000000000026341 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph, spanning_tree;
    igraph_vector_t tree_edges;
    igraph_bool_t is_tree;
    int err;

    igraph_rng_seed(igraph_rng_default(), 987);

    igraph_vector_init(&tree_edges, 0);

    /* This is guaranteed to create a connected graph. */
    igraph_barabasi_game(&graph, 100, 2, 2, NULL, 0, 1, IGRAPH_UNDIRECTED, IGRAPH_BARABASI_PSUMTREE, NULL);

    err = igraph_random_spanning_tree(&graph, &tree_edges, 0);
    IGRAPH_ASSERT(!err);

    IGRAPH_ASSERT(igraph_vector_size(&tree_edges) == igraph_vcount(&graph) - 1);

    err = igraph_subgraph_edges(&graph, &spanning_tree, igraph_ess_vector(&tree_edges), /* delete_vertices= */ 0);
    IGRAPH_ASSERT(!err);

    IGRAPH_ASSERT(igraph_vcount(&spanning_tree) == igraph_vcount(&graph));

    igraph_is_tree(&spanning_tree, &is_tree, NULL, IGRAPH_ALL);
    IGRAPH_ASSERT(is_tree);

    igraph_destroy(&spanning_tree);
    igraph_destroy(&graph);

    /* Non-connected forest graph. There is only one solution. */
    igraph_small(&graph, 4, IGRAPH_UNDIRECTED, 0,1, 2,3, -1);

    /* Find a spanning tree of the component containing vertex 0 */
    err = igraph_random_spanning_tree(&graph, &tree_edges, 0);
    IGRAPH_ASSERT(!err);

    IGRAPH_ASSERT(igraph_vector_size(&tree_edges) == 1);
    IGRAPH_ASSERT(VECTOR(tree_edges)[0] == 0);

    /* Find a spanning forest */
    err = igraph_random_spanning_tree(&graph, &tree_edges, -1);
    IGRAPH_ASSERT(!err);

    IGRAPH_ASSERT(igraph_vector_size(&tree_edges) == 2);
    IGRAPH_ASSERT(VECTOR(tree_edges)[0] == 0 && VECTOR(tree_edges)[1] == 1);

    igraph_destroy(&graph);

    igraph_vector_destroy(&tree_edges);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/ring.c0000644000175100001710000001404500000000000023102 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   Ring test suite
   Copyright (C) 2011 Minh Van Nguyen 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA
*/

#include 

#include "test_utilities.inc"

typedef struct {
    int n, m;
    igraph_bool_t directed, mutual, circular;
    igraph_real_t *edges;
} ring_test_t;

#define RING_TEST(id, n, m, di, mu, ci, ...) \
    igraph_real_t ring_ ## id ## _edges[] = { __VA_ARGS__ };      \
    ring_test_t ring_ ## id = { n, m, di, mu, ci, ring_ ## id ## _edges }

/*---------------n--m--di-mu-ci--edges-------------------------------------*/
RING_TEST(uc_6,  6, 6, 0, 0, 1,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0 );
RING_TEST(uc_0,  0, 0, 0, 0, 1,  -1 );
RING_TEST(uc_1,  1, 0, 0, 0, 1,  -1 );
RING_TEST(uc_2,  2, 1, 0, 0, 1,  0, 1 );

RING_TEST(u_6,   6, 5, 0, 0, 0,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5 );
RING_TEST(u_0,   0, 0, 0, 0, 0,  -1 );
RING_TEST(u_1,   1, 0, 0, 0, 0,  -1 );
RING_TEST(u_2,   2, 1, 0, 0, 0,  0, 1 );

RING_TEST(umc_6, 6, 6, 0, 1, 1,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0 );
RING_TEST(umc_0, 0, 0, 0, 1, 1,  -1 );
RING_TEST(umc_1, 1, 0, 0, 1, 1,  -1 );
RING_TEST(umc_2, 2, 1, 0, 1, 1,  0, 1 );

RING_TEST(um_6,  6, 5, 0, 1, 0,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5 );
RING_TEST(um_0,  0, 0, 0, 1, 0,  -1 );
RING_TEST(um_1,  1, 0, 0, 1, 0,  -1 );
RING_TEST(um_2,  2, 1, 0, 1, 0,  0, 1 );

RING_TEST(dc_6,  6, 6, 1, 0, 1,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0 );
RING_TEST(dc_0,  0, 0, 1, 0, 1,  -1 );
RING_TEST(dc_1,  1, 0, 1, 0, 1,  -1 );
RING_TEST(dc_2,  2, 2, 1, 0, 1,  0, 1, 1, 0 );

RING_TEST(d_6,   6, 5, 1, 0, 1,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5 );
RING_TEST(d_0,   0, 0, 1, 0, 1,  -1 );
RING_TEST(d_1,   1, 0, 1, 0, 1,  -1 );
RING_TEST(d_2,   2, 1, 1, 0, 1,  0, 1 );

RING_TEST(dmc_6,  6, 12, 1, 1, 1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0,
          1, 0, 2, 1, 3, 2, 4, 3, 5, 4, 0, 5 );
RING_TEST(dmc_0,  0, 0, 1, 1, 1, -1 );
RING_TEST(dmc_1,  1, 0, 1, 1, 1, -1 );
RING_TEST(dmc_2,  2, 2, 1, 1, 1, 0, 1, 1, 0 );

RING_TEST(dm_6,  6, 10, 1, 1, 0,  0, 1, 1, 2, 2, 3, 3, 4, 4, 5,
          1, 0, 2, 1, 3, 2, 4, 3, 5, 4 );
RING_TEST(dm_0,  0, 0, 1, 1, 0,  -1 );
RING_TEST(dm_1,  1, 0, 1, 1, 0,  -1 );
RING_TEST(dm_2,  2, 2, 1, 1, 0,  0, 1, 1, 0 );
/*---------------n--m--di-mu-ci--edges-------------------------------------*/

ring_test_t *all_checks[] = { /*  1 */ &ring_uc_6,   /*  2 */ &ring_uc_0,
                                       /*  3 */ &ring_uc_1,   /*  4 */ &ring_uc_2,
                                       /*  5 */ &ring_u_6,    /*  6 */ &ring_u_0,
                                       /*  7 */ &ring_u_1,    /*  8 */ &ring_u_2,
                                       /*  9 */ &ring_umc_6,  /* 10 */ &ring_umc_0,
                                       /* 11 */ &ring_umc_1,  /* 12 */ &ring_umc_2,
                                       /* 13 */ &ring_um_6,   /* 14 */ &ring_um_0,
                                       /* 15 */ &ring_um_1,   /* 16 */ &ring_um_2,
                                       /* 17 */ &ring_dc_6,   /* 18 */ &ring_dc_0,
                                       /* 19 */ &ring_dc_1,   /* 20 */ &ring_dc_2,
                                       /* 21 */ &ring_dmc_6,  /* 22 */ &ring_dmc_0,
                                       /* 23 */ &ring_dmc_1,  /* 24 */ &ring_dmc_2,
                                       /* 25 */ &ring_dm_6,   /* 26 */ &ring_dm_0,
                                       /* 27 */ &ring_dm_1,   /* 28 */ &ring_dm_2,
                                       0
                            };

int check_ring_properties(const igraph_t *ring, igraph_bool_t directed,
                          igraph_bool_t mutual, igraph_bool_t circular) {

    igraph_bool_t res;

    /* Connected */
    igraph_is_connected(ring, &res, IGRAPH_WEAK);
    if (!res && igraph_vcount(ring) > 0) {
        printf("Not connected\n");
        return 1;
    }

    /* Simple */
    igraph_is_simple(ring, &res);
    if (!res) {
        printf("Not simple\n");
        return 2;
    }

    /* Girth, for big enough circular graphs */
    if (circular && igraph_vcount(ring) > 2) {
        igraph_integer_t girth;
        igraph_girth(ring, &girth, NULL);
        if (girth != igraph_vcount(ring)) {
            printf("Wrong girth\n");
            return 3;
        }
    }

    return 0;
}

int check_ring(const ring_test_t *test) {
    igraph_t graph, othergraph;
    igraph_vector_t otheredges;
    igraph_bool_t iso;
    int ret;

    /* Create ring */
    igraph_ring(&graph, test->n, test->directed, test->mutual, test->circular);

    /* Check its properties */
    if ((ret = check_ring_properties(&graph, test->directed, test->mutual,
                                     test->circular))) {
        return ret;
    }

    /* Check that it is isomorphic to the stored graph */
    igraph_vector_view(&otheredges, test->edges, test->m * 2);
    igraph_create(&othergraph, &otheredges, test->n, test->directed);
    igraph_isomorphic(&graph, &othergraph, &iso);
    if (!iso) {
        return 50;
    }

    /* Clean up */
    igraph_destroy(&graph);
    igraph_destroy(&othergraph);

    return 0;
}

int main() {
    int i, ret;

    i = 0;
    while (all_checks[i]) {
        if ((ret = check_ring(all_checks[i]))) {
            printf("Check no #%d failed.\n", (int) (i + 1));
            return ret;
        }
        i++;
    }

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/rng_init_destroy_max_min_name_set_default.c0000644000175100001710000000360400000000000032613 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void test_and_destroy(igraph_rng_type_t *rng_type, igraph_rng_t *rng_def) {
    int i;
    igraph_rng_t rng;

    IGRAPH_ASSERT(igraph_rng_init(&rng, rng_type) == IGRAPH_SUCCESS);
    printf("rng name: %s\n", igraph_rng_name(&rng));

    igraph_rng_seed(&rng, 42);
    for (i = 0; i < 5; i++) {
        printf("%ld\n", igraph_rng_get_integer(&rng, 0, 100));
    }
    printf("\n");

    igraph_rng_set_default(&rng);
    igraph_rng_seed(igraph_rng_default(), 42);
    for (i = 0; i < 5; i++) {
        printf("%ld\n", igraph_rng_get_integer(igraph_rng_default(), 0, 100));
    }
    printf("\n");

    IGRAPH_ASSERT(igraph_rng_max(&rng) >= 32767);
    igraph_rng_set_default(rng_def);
    igraph_rng_destroy(&rng);
}

int main() {
    int i;
    igraph_rng_type_t rng_types[3] = {igraph_rngtype_glibc2, igraph_rngtype_mt19937, igraph_rngtype_rand};
    igraph_rng_t rng_def;

    IGRAPH_ASSERT(igraph_rng_init(&rng_def, &igraph_rngtype_glibc2) == IGRAPH_SUCCESS);

    for (i = 0; i < 3; i++) {
        test_and_destroy(&rng_types[i], &rng_def);
    }

    igraph_rng_destroy(&rng_def);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/rng_init_destroy_max_min_name_set_default.out0000644000175100001710000000021600000000000033174 0ustar00runnerdocker00000000000000rng name: LIBC
3
33
69
42
20

3
33
69
42
20

rng name: MT19937
37
80
96
18
73

37
80
96
18
73

rng name: RAND
58
52
47
78
42

58
52
47
78
42

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/rng_reproducibility.c0000644000175100001710000000071700000000000026223 0ustar00runnerdocker00000000000000
#include 

/*
 * This test serves to ensure that the same sequence of random numbers are generated for the
 * same seed on all platforms (different operating systems and 32- or 64-bit systems).
 */

int main() {
    int i;
    igraph_rng_seed(igraph_rng_default(), 137);

    for (i = 0; i < 32; ++i) {
        printf("%ld\n", RNG_INTEGER(0, 100));
    }

    for (i = 0; i < 32; ++i) {
        printf("%g\n", RNG_UNIF(0, 1e-6));
    }
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/rng_reproducibility.out0000644000175100001710000000073300000000000026606 0ustar00runnerdocker0000000000000095
51
8
29
70
39
70
77
50
19
50
46
90
19
8
43
85
46
35
91
100
51
77
59
76
89
70
29
77
86
0
10
8.62167e-07
7.23281e-07
5.10497e-07
1.62423e-07
1.08917e-07
4.0316e-07
6.41856e-07
8.52208e-07
8.89251e-07
8.68517e-07
8.35564e-07
8.92712e-07
8.80799e-07
4.72315e-08
5.46867e-07
2.83909e-07
4.71876e-07
4.61379e-07
8.30438e-07
8.87435e-07
5.32672e-07
8.35833e-07
2.47958e-07
1.80194e-07
6.6532e-07
6.32782e-07
5.40267e-07
4.66444e-07
3.6002e-07
5.40214e-08
6.52406e-07
2.88088e-07
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/scg2.c0000644000175100001710000001262300000000000023001 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t ev;
    igraph_t scg_graph;
    igraph_matrix_t scg_matrix;
    igraph_sparsemat_t scg_sparsemat;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_vector_t p;
    igraph_vector_t groups;
    igraph_vector_complex_t eval;
    igraph_matrix_complex_t evec;

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_vector_init(&ev, 1);
    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&scg_matrix, 0, 0);
    igraph_vector_init(&p, 0);
    igraph_vector_init(&groups, 0);
    igraph_vector_complex_init(&eval, 0);
    igraph_matrix_complex_init(&evec, 0, 0);

#define CALLSTO() do {                           \
        igraph_vector_resize(&p, 0);                     \
        igraph_vector_resize(&groups, 0);                    \
        igraph_vector_complex_resize(&eval, 0);              \
        igraph_matrix_complex_resize(&evec, 0, 0);               \
        igraph_scg_stochastic(&g, /*matrix=*/ 0, /*sparsemat=*/ 0, &ev,  \
                              /* intervals= */ 2, /* intervals_vector= */ 0, \
                              /* algorithm= */ IGRAPH_SCG_EXACT,         \
                              IGRAPH_SCG_NORM_ROW, &eval, &evec,         \
                              &groups, &p, /* use_arpack= */ 0,      \
                              /* maxiter= */ 0, &scg_graph, &scg_matrix,     \
                              &scg_sparsemat, &L, &R,            \
                              &Lsparse, &Rsparse);               \
    } while (0)

#define FIXSMALL(eps) do { \
    long int i, j, ncol, nrow; \
    ncol = igraph_vector_complex_size(&eval); \
    for (i = 0; i < ncol; i++) { \
        if (fabs((double)IGRAPH_REAL(VECTOR(eval)[i])) < eps) { \
            IGRAPH_REAL(VECTOR(eval)[i]) = 0; \
        } \
        if (fabs((double)IGRAPH_IMAG(VECTOR(eval)[i])) < eps) { \
            IGRAPH_IMAG(VECTOR(eval)[i]) = 0; \
        } \
    } \
    nrow = igraph_matrix_complex_nrow(&evec); \
    ncol = igraph_matrix_complex_ncol(&evec); \
    for (i = 0; i < nrow; i++) { \
        for (j = 0; j < ncol; j++) { \
            if (fabs((double)IGRAPH_REAL(MATRIX(evec, i, j))) < eps) { \
                IGRAPH_REAL(MATRIX(evec, i, j)) = 0; \
            } \
            if (fabs((double)IGRAPH_IMAG(MATRIX(evec, i, j))) < eps) { \
                IGRAPH_IMAG(MATRIX(evec, i, j)) = 0; \
            } \
        } \
    } \
    } while (0)

#define PRINTRES()                      \
    do {                              \
        printf("--------------------------------\n");       \
        igraph_vector_print(&groups);               \
        printf("---\n");                        \
        igraph_vector_complex_print(&eval);             \
        print_matrix_complex_first_row_positive(&evec);             \
        printf("---\n");                        \
        igraph_write_graph_edgelist(&scg_graph, stdout);        \
        printf("---\n");                        \
        igraph_sparsemat_print(&scg_sparsemat, stdout);     \
        printf("---\n");                        \
        igraph_sparsemat_print(&Lsparse, stdout);           \
        printf("---\n");                        \
        igraph_sparsemat_print(&Rsparse, stdout);           \
        printf("---\n");                        \
    } while (0)

    VECTOR(ev)[0] = 1;
    CALLSTO();
    FIXSMALL(1e-4);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    VECTOR(ev)[0] = 3;
    CALLSTO();
    FIXSMALL(1e-4);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_vector_resize(&ev, 2);
    VECTOR(ev)[0] = 1;
    VECTOR(ev)[1] = 3;
    CALLSTO();
    FIXSMALL(1e-4);
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_matrix_complex_destroy(&evec);
    igraph_vector_complex_destroy(&eval);
    igraph_vector_destroy(&groups);
    igraph_vector_destroy(&p);
    igraph_matrix_destroy(&scg_matrix);
    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_vector_destroy(&ev);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------- */

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/scg2.out0000644000175100001710000000352000000000000023362 0ustar00runnerdocker00000000000000--------------------------------
0 0 0 0 0 0 0 0 0 0
---
1+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
0.316228+0i
---
0 0
---
col 0: locations 0 to 0
0 : 1
---
0 0 : 0.166667
0 1 : 0.222222
0 2 : 0.222222
0 3 : 0.0555556
0 4 : 0.0555556
0 5 : 0.0555556
0 6 : 0.0555556
0 7 : 0.0555556
0 8 : 0.0555556
0 9 : 0.0555556
---
0 0 : 1
0 1 : 1
0 2 : 1
0 3 : 1
0 4 : 1
0 5 : 1
0 6 : 1
0 7 : 1
0 8 : 1
0 9 : 1
---
--------------------------------
0 1 2 0 3 3 3 4 4 4
---
0.866025+0i
0+0i
0.316228+0i
-0.316228+0i
0+0i
0.365148+0i
0.365148+0i
0.365148+0i
-0.365148+0i
-0.365148+0i
-0.365148+0i
---
0 0
0 1
0 2
1 0
1 3
2 0
2 4
3 1
4 2
---
col 0: locations 0 to 2
1 : 0.25
2 : 0.25
0 : 0.5
col 1: locations 3 to 4
0 : 0.25
3 : 1
col 2: locations 5 to 6
0 : 0.25
4 : 1
col 3: locations 7 to 7
1 : 0.75
col 4: locations 8 to 8
2 : 0.75
---
0 0 : 0.75
1 1 : 1
2 2 : 1
0 3 : 0.25
3 4 : 0.333333
3 5 : 0.333333
3 6 : 0.333333
4 7 : 0.333333
4 8 : 0.333333
4 9 : 0.333333
---
0 0 : 1
1 1 : 1
2 2 : 1
0 3 : 1
3 4 : 1
3 5 : 1
3 6 : 1
4 7 : 1
4 8 : 1
4 9 : 1
---
--------------------------------
0 1 2 0 3 3 3 4 4 4
---
1+0i 0.866025+0i
0.316228+0i 0+0i
0.316228+0i 0.316228+0i
0.316228+0i -0.316228+0i
0.316228+0i 0+0i
0.316228+0i 0.365148+0i
0.316228+0i 0.365148+0i
0.316228+0i 0.365148+0i
0.316228+0i -0.365148+0i
0.316228+0i -0.365148+0i
0.316228+0i -0.365148+0i
---
0 0
0 1
0 2
1 0
1 3
2 0
2 4
3 1
4 2
---
col 0: locations 0 to 2
1 : 0.25
2 : 0.25
0 : 0.5
col 1: locations 3 to 4
0 : 0.25
3 : 1
col 2: locations 5 to 6
0 : 0.25
4 : 1
col 3: locations 7 to 7
1 : 0.75
col 4: locations 8 to 8
2 : 0.75
---
0 0 : 0.75
1 1 : 1
2 2 : 1
0 3 : 0.25
3 4 : 0.333333
3 5 : 0.333333
3 6 : 0.333333
4 7 : 0.333333
4 8 : 0.333333
4 9 : 0.333333
---
0 0 : 1
1 1 : 1
2 2 : 1
0 3 : 1
3 4 : 1
3 5 : 1
3 6 : 1
4 7 : 1
4 8 : 1
4 9 : 1
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/scg3.c0000644000175100001710000001057200000000000023003 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t ev;
    igraph_t scg_graph;
    igraph_matrix_t scg_matrix;
    igraph_sparsemat_t scg_sparsemat;
    igraph_matrix_t L, R;
    igraph_sparsemat_t Lsparse, Rsparse;
    igraph_vector_t groups;
    igraph_vector_complex_t eval;
    igraph_matrix_complex_t evec;

    igraph_tree(&g, 10, /* children= */ 3, IGRAPH_TREE_UNDIRECTED);

    igraph_vector_init(&ev, 1);
    igraph_matrix_init(&L, 0, 0);
    igraph_matrix_init(&R, 0, 0);
    igraph_matrix_init(&scg_matrix, 0, 0);
    igraph_vector_init(&groups, 0);
    igraph_vector_complex_init(&eval, 0);
    igraph_matrix_complex_init(&evec, 0, 0);

#define CALLLAP() do {                           \
        igraph_vector_resize(&groups, 0);                    \
        igraph_vector_complex_resize(&eval, 0);              \
        igraph_matrix_complex_resize(&evec, 0, 0);               \
        igraph_scg_laplacian(&g, /*matrix=*/ 0, /*sparsemat=*/ 0, &ev,   \
                             /* intervals= */ 2, /* intervals_vector= */ 0, \
                             /* algorithm= */ IGRAPH_SCG_EXACT,     \
                             IGRAPH_SCG_NORM_ROW,               \
                             IGRAPH_SCG_DIRECTION_DEFAULT, &eval, &evec,    \
                             &groups, /* use_arpack= */ 0,          \
                             /* maxiter= */ 0, &scg_graph, &scg_matrix, \
                             &scg_sparsemat, &L, &R,            \
                             &Lsparse, &Rsparse);               \
    } while (0)

#define PRINTRES()                      \
    do {                              \
        printf("--------------------------------\n");       \
        igraph_vector_print(&groups);               \
        printf("---\n");                        \
        igraph_vector_complex_print(&eval);             \
        print_matrix_complex_first_row_positive(&evec);             \
        printf("---\n");                        \
        igraph_write_graph_edgelist(&scg_graph, stdout);        \
        printf("---\n");                        \
        igraph_sparsemat_print(&scg_sparsemat, stdout);     \
        printf("---\n");                        \
        igraph_sparsemat_print(&Lsparse, stdout);           \
        printf("---\n");                        \
        igraph_sparsemat_print(&Rsparse, stdout);           \
        printf("---\n");                        \
    } while (0)

    VECTOR(ev)[0] = 1;
    CALLLAP();
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    VECTOR(ev)[0] = 3;
    CALLLAP();
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_vector_resize(&ev, 2);
    VECTOR(ev)[0] = 1;
    VECTOR(ev)[1] = 3;
    CALLLAP();
    PRINTRES();
    igraph_destroy(&scg_graph);
    igraph_sparsemat_destroy(&scg_sparsemat);
    igraph_sparsemat_destroy(&Lsparse);
    igraph_sparsemat_destroy(&Rsparse);

    igraph_matrix_complex_destroy(&evec);
    igraph_vector_complex_destroy(&eval);
    igraph_vector_destroy(&groups);
    igraph_matrix_destroy(&scg_matrix);
    igraph_matrix_destroy(&L);
    igraph_matrix_destroy(&R);
    igraph_vector_destroy(&ev);
    igraph_destroy(&g);

    /* -------------------------------------------------------------------- */

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/scg3.out0000644000175100001710000000363100000000000023366 0ustar00runnerdocker00000000000000--------------------------------
0 1 1 2 3 3 3 3 3 3
---
5.52892+0i
0.493741+0i
-0.569806+0i
-0.569806+0i
-0.10902+0i
0.125815+0i
0.125815+0i
0.125815+0i
0.125815+0i
0.125815+0i
0.125815+0i
---
0 1
0 2
1 0
1 3
2 0
3 1
---
col 0: locations 0 to 2
0 : 3
1 : -1
2 : -1
col 1: locations 3 to 5
1 : 4
0 : -2
3 : -1
col 2: locations 6 to 7
2 : 1
0 : -1
col 3: locations 8 to 9
3 : 1
1 : -3
---
0 0 : 1
1 1 : 0.5
1 2 : 0.5
2 3 : 1
3 4 : 0.166667
3 5 : 0.166667
3 6 : 0.166667
3 7 : 0.166667
3 8 : 0.166667
3 9 : 0.166667
---
0 0 : 1
1 1 : 1
1 2 : 1
2 3 : 1
3 4 : 1
3 5 : 1
3 6 : 1
3 7 : 1
3 8 : 1
3 9 : 1
---
--------------------------------
0 1 1 2 3 3 3 3 3 3
---
2.83255+0i
0.749697+0i
0.267318+0i
0.267318+0i
-0.4091+0i
-0.145872+0i
-0.145872+0i
-0.145872+0i
-0.145872+0i
-0.145872+0i
-0.145872+0i
---
0 1
0 2
1 0
1 3
2 0
3 1
---
col 0: locations 0 to 2
0 : 3
1 : -1
2 : -1
col 1: locations 3 to 5
1 : 4
0 : -2
3 : -1
col 2: locations 6 to 7
2 : 1
0 : -1
col 3: locations 8 to 9
3 : 1
1 : -3
---
0 0 : 1
1 1 : 0.5
1 2 : 0.5
2 3 : 1
3 4 : 0.166667
3 5 : 0.166667
3 6 : 0.166667
3 7 : 0.166667
3 8 : 0.166667
3 9 : 0.166667
---
0 0 : 1
1 1 : 1
1 2 : 1
2 3 : 1
3 4 : 1
3 5 : 1
3 6 : 1
3 7 : 1
3 8 : 1
3 9 : 1
---
--------------------------------
0 1 1 2 3 3 3 3 3 3
---
5.52892+0i 2.83255+0i
0.493741+0i 0.749697+0i
-0.569806+0i 0.267318+0i
-0.569806+0i 0.267318+0i
-0.10902+0i -0.4091+0i
0.125815+0i -0.145872+0i
0.125815+0i -0.145872+0i
0.125815+0i -0.145872+0i
0.125815+0i -0.145872+0i
0.125815+0i -0.145872+0i
0.125815+0i -0.145872+0i
---
0 1
0 2
1 0
1 3
2 0
3 1
---
col 0: locations 0 to 2
0 : 3
1 : -1
2 : -1
col 1: locations 3 to 5
1 : 4
0 : -2
3 : -1
col 2: locations 6 to 7
2 : 1
0 : -1
col 3: locations 8 to 9
3 : 1
1 : -3
---
0 0 : 1
1 1 : 0.5
1 2 : 0.5
2 3 : 1
3 4 : 0.166667
3 5 : 0.166667
3 6 : 0.166667
3 7 : 0.166667
3 8 : 0.166667
3 9 : 0.166667
---
0 0 : 1
1 1 : 1
1 2 : 1
2 3 : 1
3 4 : 1
3 5 : 1
3 6 : 1
3 7 : 1
3 8 : 1
3 9 : 1
---
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/set.c0000644000175100001710000000416500000000000022740 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "core/set.h"

#include "test_utilities.inc"

void print_set(igraph_set_t *set, FILE *f) {
    long int state = 0;
    igraph_integer_t element;
    while (igraph_set_iterate(set, &state, &element)) {
        fprintf(f, " %li", (long int) element);
    }
    fprintf(f, "\n");
}

int main() {

    igraph_set_t set;
    int i;

    /* simple init */
    igraph_set_init(&set, 0);
    igraph_set_destroy(&set);

    /* addition, igraph_set_size */
    igraph_set_init(&set, 10);
    i = 10;
    while (igraph_set_size(&set) < 10) {
        igraph_set_add(&set, 2 * i);
        i--;
    }
    while (igraph_set_size(&set) < 21) {
        igraph_set_add(&set, 2 * i + 1);
        i++;
    }
    print_set(&set, stdout);

    /* adding existing element */
    igraph_set_add(&set, 8);
    if (igraph_set_size(&set) != 21) {
        return 4;
    }

    /* igraph_set_contains */
    if (igraph_set_contains(&set, 42) || !igraph_set_contains(&set, 7)) {
        return 3;
    }

    /* igraph_set_empty, igraph_set_clear */
    if (igraph_set_empty(&set)) {
        return 1;
    }
    igraph_set_clear(&set);
    if (!igraph_set_empty(&set)) {
        return 2;
    }
    igraph_set_destroy(&set);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/set.out0000644000175100001710000000006700000000000023322 0ustar00runnerdocker00000000000000 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/simplify_and_colorize.c0000644000175100001710000000313100000000000026521 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

#define SIMPLIFY_PRINT_DESTROY(name) \
    printf(name "\n"); \
    igraph_simplify_and_colorize(&graph, &res, &vcol, &ecol); \
    print_graph(&res); \
    print_vector_int(&vcol); \
    print_vector_int(&ecol); \
    printf("\n"); \
    igraph_destroy(&res); \
    igraph_destroy(&graph);

int main() {
    igraph_t graph, res;
    igraph_vector_int_t vcol, ecol;

    igraph_vector_int_init(&vcol, 0);
    igraph_vector_int_init(&ecol, 0);

    /* null graph */
    igraph_empty(&graph, 0, 0);
    SIMPLIFY_PRINT_DESTROY("K0");

    /* singleton graph */
    igraph_empty(&graph, 1, 0);
    SIMPLIFY_PRINT_DESTROY("K1");

    /* 4-cycle-graph */
    igraph_ring(&graph, 4, 0, 0, 1);
    SIMPLIFY_PRINT_DESTROY("C4");

    /* both multi-edges and self loops */
    igraph_small(&graph, 2, 0,
                 0, 1, 0, 1, 1, 1, -1);
    SIMPLIFY_PRINT_DESTROY("Undirected graph 1");

    /* parallel edges specified with different vertex orderings */
    igraph_small(&graph, 3, 0,
                 0, 1, 1, 2, 2, 0, 2, 2, 2, 2, 2, 1, -1);
    SIMPLIFY_PRINT_DESTROY("Undirected graph 2");

    /* directed version of the same as above */
    igraph_small(&graph, 3, 1,
                 0, 1, 1, 2, 2, 0, 2, 2, 2, 2, 2, 1, -1);
    SIMPLIFY_PRINT_DESTROY("Directed graph 1");

    /* isolated vertices */
    igraph_small(&graph, 4, 1,
                 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, -1);
    SIMPLIFY_PRINT_DESTROY("Directed graph 2");

    igraph_vector_int_destroy(&vcol);
    igraph_vector_int_destroy(&ecol);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/simplify_and_colorize.out0000644000175100001710000000100700000000000027106 0ustar00runnerdocker00000000000000K0
directed: false
vcount: 0
edges: {
}
( )
( )

K1
directed: false
vcount: 1
edges: {
}
( 0 )
( )

C4
directed: false
vcount: 4
edges: {
1 0
3 0
2 1
3 2
}
( 0 0 0 0 )
( 1 1 1 1 )

Undirected graph 1
directed: false
vcount: 2
edges: {
1 0
}
( 0 1 )
( 2 )

Undirected graph 2
directed: false
vcount: 3
edges: {
1 0
2 0
2 1
}
( 0 0 2 )
( 1 1 2 )

Directed graph 1
directed: true
vcount: 3
edges: {
0 1
1 2
2 0
2 1
}
( 0 0 2 )
( 1 1 1 1 )

Directed graph 2
directed: true
vcount: 4
edges: {
0 1
1 0
}
( 0 2 0 0 )
( 2 3 )

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/single_target_shortest_path.c0000644000175100001710000000471200000000000027741 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void igraph_warnings_ignore(const char *reason, const char *file,
                            int line, int igraph_errno) {
    /* Do nothing */
}

int main() {
    igraph_t g;
    igraph_vector_t vpath, epath;
    igraph_vector_t w;

    /* Unweighted */

    igraph_small(&g, 5, IGRAPH_DIRECTED,
                 0, 1, 1, 2, 2, 3, 3, 4, 0, 3,
                 -1);
    igraph_vector_init(&vpath, 0);
    igraph_vector_init(&epath, 0);
    igraph_get_shortest_path(&g, &vpath, &epath, 0, 4, IGRAPH_OUT);
    igraph_vector_print(&vpath);
    igraph_vector_print(&epath);

    igraph_get_shortest_path(&g, &vpath, &epath, 0, 0, IGRAPH_OUT);
    igraph_vector_print(&vpath);
    igraph_vector_print(&epath);

    igraph_set_warning_handler(igraph_warnings_ignore);
    igraph_get_shortest_path(&g, &vpath, &epath, 4, 0, IGRAPH_OUT);
    igraph_vector_print(&vpath);
    igraph_vector_print(&epath);
    igraph_set_warning_handler(igraph_warning_handler_print);

    igraph_get_shortest_path(&g, &vpath, &epath, 4, 0, IGRAPH_ALL);
    igraph_vector_print(&vpath);
    igraph_vector_print(&epath);

    /* Weighted */

    igraph_vector_init(&w, 5);
    VECTOR(w)[0] = 1;
    VECTOR(w)[1] = 1;
    VECTOR(w)[2] = 1;
    VECTOR(w)[3] = 1;
    VECTOR(w)[4] = 3.1;

    igraph_get_shortest_path_dijkstra(&g, &vpath, &epath, 0, 4, &w, IGRAPH_OUT);
    igraph_vector_print(&vpath);
    igraph_vector_print(&epath);

    igraph_vector_destroy(&w);
    igraph_vector_destroy(&epath);
    igraph_vector_destroy(&vpath);
    igraph_destroy(&g);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/single_target_shortest_path.out0000644000175100001710000000005300000000000030320 0ustar00runnerdocker000000000000000 3 4
4 3
0



4 3 0
3 4
0 1 2 3 4
0 1 2 3
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spinglass.c0000644000175100001710000001353600000000000024152 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t g;
    igraph_real_t  modularity, temperature;
    igraph_vector_t membership, csize;
    /* long int i; */
    igraph_real_t cohesion, adhesion;
    igraph_integer_t inner_links;
    igraph_integer_t outer_links;

    igraph_rng_seed(igraph_rng_default(), 137);

    /* Two 5-cliques connected by a single edge */
    igraph_small(&g, 10, IGRAPH_UNDIRECTED,
                 0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 4, 2, 3, 2, 4, 3, 4,
                 5, 6, 5, 7, 5, 8, 5, 9, 6, 7, 6, 8, 6, 9, 7, 8, 7, 9, 8, 9, 0, 5, -1);
    igraph_vector_init(&membership, 0);
    igraph_vector_init(&csize, 0);

    printf("\nOriginal implementation.\n");
    igraph_community_spinglass(&g,
                               NULL, /* no weights */
                               &modularity,
                               &temperature,
                               &membership,
                               &csize,
                               10,   /* no of spins */
                               0,    /* parallel update */
                               1.0,  /* start temperature */
                               0.01, /* stop temperature */
                               0.99, /* cooling factor */
                               IGRAPH_SPINCOMM_UPDATE_CONFIG,
                               1.0, /* gamma */
                               IGRAPH_SPINCOMM_IMP_ORIG,
                               /*gamma_minus =*/ 0);

    IGRAPH_ASSERT(igraph_vector_size(&membership) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_size(&csize) == igraph_vector_max(&membership) + 1);

    /* The following depend on the random seed, however, for this graph,
       the result is almost always the same (i.e. two clusters). */
    printf("Modularity: %g\n", modularity);
    print_vector_round(&membership);

    printf("\nOriginal implementation, parallel updating.\n");
    igraph_community_spinglass(&g,
                               NULL, /* no weights */
                               &modularity,
                               &temperature,
                               &membership,
                               &csize,
                               10,   /* no of spins */
                               1,    /* parallel update */
                               1.0,  /* start temperature */
                               0.01, /* stop temperature */
                               0.99, /* cooling factor */
                               IGRAPH_SPINCOMM_UPDATE_CONFIG,
                               1.0, /* gamma */
                               IGRAPH_SPINCOMM_IMP_ORIG,
                               /*gamma_minus =*/ 0);

    IGRAPH_ASSERT(igraph_vector_size(&membership) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_size(&csize) == igraph_vector_max(&membership) + 1);

    /* The following depend on the random seed, however, for this graph,
       the result is almost always the same (i.e. two clusters). */
    printf("Modularity: %g\n", modularity);
    print_vector_round(&membership);

    printf("\nNegative implementation.\n");
    igraph_community_spinglass(&g,
                               NULL, /* no weights */
                               &modularity,
                               &temperature,
                               &membership,
                               &csize,
                               10,   /* no of spins */
                               0,    /* parallel update */
                               1.0,  /* start temperature */
                               0.01, /* stop temperature */
                               0.99, /* cooling factor */
                               IGRAPH_SPINCOMM_UPDATE_CONFIG,
                               1.0, /* gamma */
                               IGRAPH_SPINCOMM_IMP_NEG,
                               /*gamma_minus =*/ 0);

    IGRAPH_ASSERT(igraph_vector_size(&membership) == igraph_vcount(&g));
    IGRAPH_ASSERT(igraph_vector_size(&csize) == igraph_vector_max(&membership) + 1);

    /* The following depend on the random seed, however, for this graph,
       the result is almost always the same (i.e. two clusters). */
    printf("Modularity: %g\n", modularity);
    print_vector_round(&membership);

    /* Try to call this as well, we don't check the results currently.... */

    igraph_community_spinglass_single(&g,
                                      /*weights=  */ 0,
                                      /*vertex=   */ 0,
                                      /*community=*/ &membership,
                                      /*cohesion= */ &cohesion,
                                      /*adhesion= */ &adhesion,
                                      /*inner_links= */ &inner_links,
                                      /*outer_links= */ &outer_links,
                                      /*spins=       */ 2,
                                      /*update_rule= */ IGRAPH_SPINCOMM_UPDATE_CONFIG,
                                      /*gamma=       */ 1.0);

    igraph_destroy(&g);
    igraph_vector_destroy(&membership);
    igraph_vector_destroy(&csize);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spinglass.out0000644000175100001710000000035000000000000024525 0ustar00runnerdocker00000000000000
Original implementation.
Modularity: 0.452381
( 1 1 1 1 1 0 0 0 0 0 )

Original implementation, parallel updating.
Modularity: 0.452381
( 1 1 1 1 1 0 0 0 0 0 )

Negative implementation.
Modularity: 0.452381
( 0 0 0 0 0 1 1 1 1 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spmatrix.c0000644000175100001710000001417300000000000024014 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

void print_result(igraph_spmatrix_t *m, FILE *f) {
    print_spmatrix(m);
    fprintf(f, "==================================================\n");
}

int main() {
    igraph_spmatrix_t m, m1;
    igraph_spmatrix_iter_t mit;
    igraph_real_t arr[12];
    igraph_vector_t v;
    long int i, j;
    int order[] = { 1, 5, 8, 4, 0, 9, 6, 10, 11, 2, 3, 7 };

    /* igraph_spmatrix_init, igraph_spmatrix_destroy */
    igraph_spmatrix_init(&m, 10, 10);
    igraph_spmatrix_destroy(&m);

    igraph_spmatrix_init(&m, 0, 0);
    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_ncol, igraph_spmatrix_nrow */
    igraph_spmatrix_init(&m, 10, 5);
    if (igraph_spmatrix_nrow(&m) != 10) {
        return 1;
    }
    if (igraph_spmatrix_ncol(&m) != 5) {
        return 2;
    }

    /* igraph_spmatrix_size, igraph_spmatrix_resize */
    igraph_spmatrix_resize(&m, 6, 5);
    if (igraph_spmatrix_size(&m) != 30) {
        return 3;
    }
    if (igraph_spmatrix_nrow(&m) != 6) {
        return 4;
    }
    if (igraph_spmatrix_ncol(&m) != 5) {
        return 5;
    }
    igraph_spmatrix_resize(&m, 2, 4);
    if (igraph_spmatrix_nrow(&m) != 2) {
        return 6;
    }
    if (igraph_spmatrix_ncol(&m) != 4) {
        return 7;
    }
    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_get, igraph_spmatrix_set, igraph_spmatrix_null */
    igraph_spmatrix_init(&m, 3, 4);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, (i + j) % 3);
        }
    }
    print_result(&m, stdout);
    igraph_spmatrix_null(&m);
    print_result(&m, stdout);
    /* now fill it in shuffled order */
    for (i = 0; i < 12; i++) {
        igraph_spmatrix_set(&m, order[i] / 4, order[i] % 4, (order[i] / 4 + order[i] % 4) % 3);
    }
    print_result(&m, stdout);
    /* now decrease all elements by two in shuffled order */
    for (i = 0; i < 12; i++) {
        igraph_spmatrix_add_e(&m, order[i] / 4, order[i] % 4, -2);
    }
    print_result(&m, stdout);
    /* now increase all elements by one in shuffled order */
    for (i = 0; i < 12; i++) {
        igraph_spmatrix_add_e(&m, order[i] / 4, order[i] % 4, 1);
    }
    print_result(&m, stdout);

    igraph_spmatrix_destroy(&m);

    /* igraph_matrix_add_cols, igraph_matrix_add_rows */
    igraph_spmatrix_init(&m, 4, 3);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, (i + 1) * (j + 1));
        }
    }
    igraph_spmatrix_add_cols(&m, 2);
    igraph_spmatrix_add_rows(&m, 2);
    if (igraph_spmatrix_ncol(&m) != 5) {
        return 8;
    }
    if (igraph_spmatrix_nrow(&m) != 6) {
        return 9;
    }
    print_result(&m, stdout);
    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_count_nonzero */
    igraph_spmatrix_init(&m, 5, 3);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, i * j);
        }
    }
    print_result(&m, stdout);
    if (igraph_spmatrix_count_nonzero(&m) != 8) {
        return 10;
    }
    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_copy */
    igraph_spmatrix_init(&m, 3, 4);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, i * j);
        }
    }
    igraph_spmatrix_copy(&m1, &m);
    print_result(&m1, stdout);
    igraph_spmatrix_destroy(&m);
    igraph_spmatrix_destroy(&m1);

    /* igraph_spmatrix_copy_to */
    igraph_spmatrix_init(&m, 3, 4);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, i * j);
        }
    }
    igraph_spmatrix_copy_to(&m, arr);
    for (i = 0; i < 12; i++) {
        printf(" %ld", (long)arr[i]);
    }
    printf("\n=========================\n");

    /* igraph_spmatrix_max */
    arr[0] = igraph_spmatrix_max(&m, arr + 1, arr + 2);
    for (i = 0; i < 3; i++) {
        printf(" %ld", (long)arr[i]);
    }
    printf("\n=========================\n");

    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_colsums */
    igraph_spmatrix_init(&m, 3, 5);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            igraph_spmatrix_set(&m, i, j, i + j - 4);
        }
    }
    igraph_vector_init(&v, 0);
    igraph_spmatrix_colsums(&m, &v);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);
    igraph_spmatrix_destroy(&m);

    /* igraph_spmatrix_iter_t */
    igraph_spmatrix_init(&m, 5, 5);
    for (i = 0; i < igraph_spmatrix_nrow(&m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(&m); j++) {
            if (labs(i - j) == 1) {
                igraph_spmatrix_set(&m, i, j, (i + 1) * (j + 1));
            }
        }
    }
    igraph_spmatrix_iter_create(&mit, &m);
    while (!igraph_spmatrix_iter_end(&mit)) {
        printf("%ld %ld %ld\n", mit.ri, mit.ci, (long int)mit.value);
        igraph_spmatrix_iter_next(&mit);
    }
    igraph_spmatrix_iter_destroy(&mit);
    igraph_spmatrix_destroy(&m);
    printf("=========================\n");

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spmatrix.out0000644000175100001710000000320500000000000024373 0ustar00runnerdocker00000000000000        0        1        2        0
        1        2        0        1
        2        0        1        2
==================================================
        0        0        0        0
        0        0        0        0
        0        0        0        0
==================================================
        0        1        2        0
        1        2        0        1
        2        0        1        2
==================================================
       -2       -1        0       -2
       -1        0       -2       -1
        0       -2       -1        0
==================================================
       -1        0        1       -1
        0        1       -1        0
        1       -1        0        1
==================================================
        1        2        3        0        0
        2        4        6        0        0
        3        6        9        0        0
        4        8       12        0        0
        0        0        0        0        0
        0        0        0        0        0
==================================================
        0        0        0
        0        1        2
        0        2        4
        0        3        6
        0        4        8
==================================================
        0        0        0        0
        0        1        2        3
        0        2        4        6
==================================================
 0 0 0 0 1 2 0 2 4 0 3 6
=========================
 6 2 3
=========================
( -9 -6 -3 0 3 )
1 0 2
0 1 2
2 1 6
1 2 6
3 2 12
2 3 12
4 3 20
3 4 20
=========================
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spmatrix_clear.c0000644000175100001710000000337300000000000025162 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

/*tests igraph_spmatrix_clear_row and igraph_spmatrix_clear_col */
int main() {
    igraph_spmatrix_t spmat;
    int i;
    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("0x0 matrix, trying to clear nonexistent column and row\n");
    igraph_spmatrix_init(&spmat, 0, 0);
    IGRAPH_ASSERT(igraph_spmatrix_clear_col(&spmat, 0) == IGRAPH_EINVAL);
    IGRAPH_ASSERT(igraph_spmatrix_clear_row(&spmat, 0) == IGRAPH_EINVAL);

    igraph_spmatrix_destroy(&spmat);

    printf("\n5x6 matrix\n");
    igraph_spmatrix_init(&spmat, 5, 6);
    for (i = 0; i < 30; i++) {
        igraph_spmatrix_set(&spmat, i/6, i%6, i);
    }

    printf("\nClearing col 3\n");
    IGRAPH_ASSERT(igraph_spmatrix_clear_col(&spmat, 3) == IGRAPH_SUCCESS);
    print_spmatrix(&spmat);

    printf("\nClearing row 3\n");
    IGRAPH_ASSERT(igraph_spmatrix_clear_row(&spmat, 3) == IGRAPH_SUCCESS);
    print_spmatrix(&spmat);

    igraph_spmatrix_destroy(&spmat);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/spmatrix_clear.out0000644000175100001710000000121100000000000025534 0ustar00runnerdocker000000000000000x0 matrix, trying to clear nonexistent column and row

5x6 matrix

Clearing col 3
        0        1        2        0        4        5
        6        7        8        0       10       11
       12       13       14        0       16       17
       18       19       20        0       22       23
       24       25       26        0       28       29

Clearing row 3
        0        1        2        0        4        5
        6        7        8        0       10       11
       12       13       14        0       16       17
        0        0        0        0        0        0
       24       25       26        0       28       29
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/stack.c0000644000175100001710000000445200000000000023251 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_stack_t st;
    int i;

    /* igraph_stack_init, igraph_stack_destroy */
    igraph_stack_init(&st, 0);
    igraph_stack_destroy(&st);
    igraph_stack_init(&st, 10);
    igraph_stack_destroy(&st);

    /* igraph_stack_reserve */
    igraph_stack_init(&st, 0);
    igraph_stack_reserve(&st, 10);
    igraph_stack_reserve(&st, 5);

    /* igraph_stack_empty */
    if (!igraph_stack_empty(&st)) {
        return 1;
    }
    igraph_stack_push(&st, 1);
    if (igraph_stack_empty(&st)) {
        return 2;
    }

    /* igraph_stack_size */
    if (igraph_stack_size(&st) != 1) {
        return 3;
    }
    for (i = 0; i < 10; i++) {
        igraph_stack_push(&st, i);
    }
    if (igraph_stack_size(&st) != 11) {
        return 4;
    }

    /* igraph_stack_clear */
    igraph_stack_clear(&st);
    if (!igraph_stack_empty(&st)) {
        return 5;
    }
    igraph_stack_push(&st, 100);
    if (igraph_stack_pop(&st) != 100) {
        return 6;
    }
    igraph_stack_clear(&st);
    igraph_stack_clear(&st);

    /* igraph_stack_push, igraph_stack_pop */
    for (i = 0; i < 100; i++) {
        igraph_stack_push(&st, 100 - i);
    }
    for (i = 0; i < 100; i++) {
        if (igraph_stack_pop(&st) != i + 1) {
            return 7;
        }
    }
    if (!igraph_stack_empty(&st)) {
        return 8;
    }

    igraph_stack_destroy(&st);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/strvector_set2_remove_print.c0000644000175100001710000000427400000000000027727 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    igraph_strvector_t sv;
    char *test_string = "This is a string.";
    char *test_string2 = "A completely different one.";

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("No place to put the string.\n");
    igraph_strvector_init(&sv, 0);
    IGRAPH_ASSERT(igraph_strvector_set2(&sv, 0, test_string, strlen(test_string)) == IGRAPH_EINVAL);
    igraph_strvector_destroy(&sv);

    printf("Two strings in a vector.\n");
    igraph_strvector_init(&sv, 5);
    IGRAPH_ASSERT(igraph_strvector_set2(&sv, 0, test_string, strlen(test_string)) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_strvector_set2(&sv, 4, test_string2, strlen(test_string2)) == IGRAPH_SUCCESS);
    igraph_strvector_print(&sv, stdout, " | ");

    printf("\nRemove a nonexistent one.\n");
    igraph_strvector_remove(&sv, 1);
    igraph_strvector_print(&sv, stdout, " | ");

    printf("\nRemove one.\n");
    igraph_strvector_remove(&sv, 0);
    igraph_strvector_print(&sv, stdout, " | ");
    igraph_strvector_destroy(&sv);

    printf("\nOverwriting a string.\n");
    igraph_strvector_init(&sv, 5);
    IGRAPH_ASSERT(igraph_strvector_set2(&sv, 2, test_string2, strlen(test_string2)) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_strvector_set2(&sv, 2, test_string, strlen(test_string)) == IGRAPH_SUCCESS);
    igraph_strvector_print(&sv, stdout, " | ");
    igraph_strvector_destroy(&sv);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/strvector_set2_remove_print.out0000644000175100001710000000043700000000000030311 0ustar00runnerdocker00000000000000No place to put the string.
Two strings in a vector.
This is a string. |  |  |  | A completely different one.
Remove a nonexistent one.
This is a string. |  |  | A completely different one.
Remove one.
 |  | A completely different one.
Overwriting a string.
 |  | This is a string. |  | ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/test_utilities.inc0000644000175100001710000003274200000000000025550 0ustar00runnerdocker00000000000000#ifndef TEST_UTILITIES_INC
#define TEST_UTILITIES_INC

/*
 * This file contains functions that are useful when writing tests.
 * Include it in the test program using #include "test_utilities.inc"
 */

#include 
#include 
#include 

/* Print an igraph_real_t value. Be consistent in printing NaN/Inf across platforms. */
void print_real(FILE *f, igraph_real_t x, const char *format) {
    igraph_bool_t g8 = !strcmp(format, "%8g");
    if (igraph_finite(x)) {
        if (x == 0 && signbit(x)) {
            /* print negative zeros as positive zeros for sake of consistency */
            x = +0.0;
        }
        fprintf(f, format, x);
    } else if (igraph_is_nan(x)) {
        fprintf(f, g8 ? "     NaN" : "NaN");
    } else if (igraph_is_posinf(x)) {
        fprintf(f, g8 ? "     Inf" : "Inf");
    } else if (igraph_is_neginf(x)) {
        fprintf(f, g8 ? "    -Inf" : "-Inf");
    }
}

void print_vector_format(const igraph_vector_t *v, FILE *f, const char *format) {
    long i, n = igraph_vector_size(v);
    fprintf(f, "(");
    for (i=0; i < n; i++) {
        fprintf(f, " ");
        print_real(f, VECTOR(*v)[i], format);
    }
    fprintf(f, " )\n");
}

/* Print elements of a vector. Use parentheses to make it clear when a vector has size zero. */
void print_vector(const igraph_vector_t *v) {
    print_vector_format(v, stdout, "%g");
}

/* Round elements of a vector to integers and print them. */
/* This is meant to be used when the elements of a vector are integer values. */
void print_vector_round(const igraph_vector_t *v) {
    print_vector_format(v, stdout, "%.f");
}


/* Print elements of an integer vector */
void print_vector_int(const igraph_vector_int_t *v) {
    long i, n = igraph_vector_int_size(v);
    printf("(");
    for (i=0; i < n; i++) {
        printf(" %" IGRAPH_PRId, VECTOR(*v)[i]);
    }
    printf(" )\n");
}


/* Print elements of a long vector */
void print_vector_long(const igraph_vector_long_t *v) {
    long i, n = igraph_vector_long_size(v);
    printf("(");
    for (i=0; i < n; i++) {
        printf(" %ld", VECTOR(*v)[i]);
    }
    printf(" )\n");
}


/* Print elements of a matrix. Use brackets to make it clear when a vector has size zero. */
void print_matrix_format(const igraph_matrix_t *m, FILE *f, const char *format) {
    long i, j, nrow = igraph_matrix_nrow(m), ncol = igraph_matrix_ncol(m);
    for (i = 0; i < nrow; i++) {
        fprintf(f, i == 0 ? "[" : " ");
        for (j = 0; j < ncol; j++) {
            fprintf(f, " ");
            print_real(f, MATRIX(*m, i, j), format);
        }
        fprintf(f, i == nrow-1 ? " ]\n" : "\n");
    }
}

void print_matrix(const igraph_matrix_t *m) {
    print_matrix_format(m, stdout, "%8g");
}

/* Round elements of a matrix to integers and print them. */
/* This is meant to be used when the elements of a matrix are integer values. */
void print_matrix_round(const igraph_matrix_t *m) {
    print_matrix_format(m, stdout, "%4.f");
}


/* Print an adjacency list. Use brackets around each vector and also use
 * brackets around the entire adjacency list to make it clear when the list
 * is empty.
 */
void print_adjlist(const igraph_adjlist_t *adjlist) {
    long vcount = igraph_adjlist_size(adjlist);
    long i;

    printf("{\n");
    for (i = 0; i < vcount; ++i) {
        printf("  %ld: ", i);
        print_vector_int(igraph_adjlist_get(adjlist, i));
    }
    printf("}\n");
}

/* Print a graph. Use brackets to make it obvious when the edge list is empty. */
void print_graph(const igraph_t *graph) {
    long ecount = igraph_ecount(graph);
    long vcount = igraph_vcount(graph);
    long i;

    printf("directed: %s\n", igraph_is_directed(graph) ? "true" : "false");
    printf("vcount: %ld\n", vcount);
    printf("edges: {\n");
    for (i=0; i < ecount; ++i)
        printf("%" IGRAPH_PRId " %" IGRAPH_PRId "\n", IGRAPH_FROM(graph, i), IGRAPH_TO(graph, i));
    printf("}\n");
}

/* Print an incidence list. Use brackets around each vector and also use
 * brackets around the entire incidence list to make it clear when the list
 * is empty.
 */
void print_inclist(const igraph_inclist_t *inclist) {
    long vcount = igraph_inclist_size(inclist);
    long i;

    printf("{\n");
    for (i = 0; i < vcount; ++i) {
        printf("  %ld: ", i);
        print_vector_int(igraph_inclist_get(inclist, i));
    }
    printf("}\n");
}

/* Print a lazy adjacency list. Use brackets around each vector and also use
 * brackets around the entire lazy adjacency list to make it clear when the list
 * is empty.
 */
void print_lazy_adjlist(igraph_lazy_adjlist_t *adjlist) {
    long vcount = igraph_lazy_adjlist_size(adjlist);
    long i;

    printf("{\n");
    for (i = 0; i < vcount; ++i) {
        printf("  %ld: ", i);
        print_vector_int(igraph_lazy_adjlist_get(adjlist, i));
    }
    printf("}\n");
}

/* Print a lazy incidence list. Use brackets around each vector and also use
 * brackets around the entire incidence list to make it clear when the list
 * is empty.
 */
void print_lazy_inclist(igraph_lazy_inclist_t *inclist) {
    long vcount = igraph_lazy_inclist_size(inclist);
    long i;

    printf("{\n");
    for (i = 0; i < vcount; ++i) {
        printf("  %ld: ", i);
        print_vector_int(igraph_lazy_inclist_get(inclist, i));
    }
    printf("}\n");
}

/* Edge comparisong function used for sorting in print_graph_canon(). */
int edge_compare(const void *e1, const void *e2) {
    const igraph_real_t *edge1 = (igraph_real_t *) e1, *edge2 = (igraph_real_t *) e2;
    if (edge1[0] < edge2[0]) {
        return -1;
    } else if (edge1[0] > edge2[0]) {
        return 1;
    } else if (edge1[1] < edge2[1]) {
        return -1;
    } else if (edge1[1] > edge2[1]) {
        return 1;
    } else {
        return 0;
    }
}

/* Print a graph using a sorted edge list. Other than sorting (i.e. canonicalizing) the edge list,
 * this function is identical to print_graph(). */
void print_graph_canon(const igraph_t *graph) {
    long ecount = igraph_ecount(graph);
    long vcount = igraph_vcount(graph);
    long i;
    igraph_vector_t edges;

    printf("directed: %s\n", igraph_is_directed(graph) ? "true" : "false");
    printf("vcount: %ld\n", vcount);
    printf("edges: {\n");

    igraph_vector_init(&edges, 0);
    igraph_get_edgelist(graph, &edges, 0);

    /* If the graph is undirected, we make sure that the first vertex of undirected edges
     * is always the one with the lower ID. */
    if (! igraph_is_directed(graph)) {
        for (i=0; i < ecount; ++i) {
            if (VECTOR(edges)[2*i] > VECTOR(edges)[2*i+1]) {
                igraph_real_t tmp = VECTOR(edges)[2*i];
                VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1];
                VECTOR(edges)[2*i+1] = tmp;
            }
        }
    }

    /* Sort the edge list */
    igraph_qsort(&VECTOR(edges)[0], ecount, 2*sizeof(igraph_real_t), &edge_compare);

    for (i=0; i < ecount; ++i) {
        printf("%ld %ld\n", (long) VECTOR(edges)[2*i], (long) VECTOR(edges)[2*i+1]);
    }

    igraph_vector_destroy(&edges);

    printf("}\n");
}

/* Print a vector, ensuring that the first nonzero element is positive. */
void print_vector_first_nonzero_element_positive(const igraph_vector_t *vector, const char* format) {
    igraph_vector_t copy;
    long i, n;

    igraph_vector_copy(©, vector);

    n = igraph_vector_size(©);

    for (i = 0; i < n; i++) {
        if (VECTOR(copy)[i] < 0) {
            for (; i < n; i++) {
                if (VECTOR(copy)[i] != 0) {
                    VECTOR(copy)[i] *= -1;
                }
            }
            break;
        } else if (VECTOR(copy)[i] > 0) {
            break;
        }
    }

    igraph_vector_printf(©, format);
    igraph_vector_destroy(©);
}

/* Print a complex vector, ensuring that the first element with nonzero real
 * part has a positive real part. */
void print_vector_complex_first_nonzero_real_part_positive(const igraph_vector_complex_t *vector) {
    igraph_vector_complex_t copy;
    long i, n;

    igraph_vector_complex_copy(©, vector);

    n = igraph_vector_complex_size(©);

    for (i = 0; i < n; i++) {
        if (IGRAPH_REAL(VECTOR(copy)[i]) < 0) {
            for (; i < n; i++) {
                if (IGRAPH_REAL(VECTOR(copy)[i]) != 0) {
                    IGRAPH_REAL(VECTOR(copy)[i]) *= -1;
                }
                if (IGRAPH_IMAG(VECTOR(copy)[i]) != 0) {
                    IGRAPH_IMAG(VECTOR(copy)[i]) *= -1;
                }
            }
            break;
        } else if (IGRAPH_REAL(VECTOR(copy)[i]) > 0) {
            break;
        }
    }

    igraph_vector_complex_print(©);
    igraph_vector_complex_destroy(©);
}

/* Print a matrix, ensuring that the first nonzero element in each column is
 * positive. */
void print_matrix_first_row_positive(const igraph_matrix_t *matrix, const char* format) {
    igraph_matrix_t copy;
    long i, j, nrow, ncol;

    igraph_matrix_copy(©, matrix);

    nrow = igraph_matrix_nrow(©);
    ncol = igraph_matrix_ncol(©);

    for (i = 0; i < ncol; i++) {
        for (j = 0; j < nrow; j++) {
            if (MATRIX(copy, j, i) < 0) {
                for (; j < nrow; j++) {
                    if (MATRIX(copy, j, i) != 0) {
                        MATRIX(copy, j, i) *= -1;
                    }
                }
                break;
            } else if (MATRIX(copy, j, i) > 0) {
                break;
            }
        }
    }

    igraph_matrix_printf(©, format);
    igraph_matrix_destroy(©);
}

/* Print a complex matrix, ensuring that the first element with nonzero real
 * part in each column has a positive real part. */
void print_matrix_complex_first_row_positive(const igraph_matrix_complex_t *matrix) {
    igraph_matrix_complex_t copy;
    long i, j, nrow, ncol;
    igraph_complex_t z;
    char buf[256];
    size_t len;

    igraph_matrix_complex_copy(©, matrix);

    nrow = igraph_matrix_complex_nrow(©);
    ncol = igraph_matrix_complex_ncol(©);

    for (i = 0; i < ncol; i++) {
        for (j = 0; j < nrow; j++) {
            if (IGRAPH_REAL(MATRIX(copy, j, i)) < 0) {
                for (; j < nrow; j++) {
                    if (IGRAPH_REAL(MATRIX(copy, j, i)) != 0) {
                        IGRAPH_REAL(MATRIX(copy, j, i)) *= -1;
                    }
                    if (IGRAPH_IMAG(MATRIX(copy, j, i)) != 0) {
                        IGRAPH_IMAG(MATRIX(copy, j, i)) *= -1;
                    }
                }
                break;
            } else if (IGRAPH_REAL(MATRIX(copy, j, i)) > 0) {
                break;
            }
        }
    }

    for (i = 0; i < nrow; i++) {
        for (j = 0; j < ncol; j++) {
            z = MATRIX(copy, i, j);
            if (j != 0) {
                putchar(' ');
            }

            snprintf(buf, sizeof(buf), "%g%+gi", IGRAPH_REAL(z), IGRAPH_IMAG(z));
            len = strlen(buf);

            /* ensure that we don't print -0 in the imaginary part */
            if (len > 3 && buf[len-3] == '-' && buf[len-2] == '0' && buf[len-1] == 'i') {
              buf[len-3] = '+';
            }

            /* ensure that we don't print -0 in the real part either */
            if (buf[0] == '-' && buf[1] == '0' && (buf[2] == '+' || buf[2] == '-')) {
                printf("%s", buf + 1);
            } else {
                printf("%s", buf);
            }
        }
        printf("\n");
    }

    igraph_matrix_complex_destroy(©);
}

void matrix_init_int_row_major(igraph_matrix_t *mat, int nrow, int ncol, int* elem) {
    int c, r;
    int i_elem = 0;
    igraph_matrix_init(mat, nrow, ncol);
    for (r = 0; r < nrow; r++) {
        for (c = 0; c < ncol; c++) {
            MATRIX(*mat, r, c) = elem[i_elem];
            i_elem++;
        }
    }
}

void matrix_init_real_row_major(igraph_matrix_t *mat, int nrow, int ncol, igraph_real_t* elem) {
    int c, r;
    int i_elem = 0;
    igraph_matrix_init(mat, nrow, ncol);
    for (r = 0; r < nrow; r++) {
        for (c = 0; c < ncol; c++) {
            MATRIX(*mat, r, c) = elem[i_elem];
            i_elem++;
        }
    }
}

void matrix_chop(igraph_matrix_t *mat, igraph_real_t cutoff) {
    int i;
    for (i = 0; i < igraph_matrix_nrow(mat) * igraph_matrix_ncol(mat); i++) {
        if (fabs(VECTOR(mat->data)[i]) < cutoff) {
            VECTOR(mat->data)[i] = 0;
        }
    }
}

void print_spmatrix(igraph_spmatrix_t *m) {
    long int i, j;
    for (i = 0; i < igraph_spmatrix_nrow(m); i++) {
        for (j = 0; j < igraph_spmatrix_ncol(m); j++) {
            printf(" %8g", igraph_spmatrix_e(m, i, j));
        }
        printf("\n");
    }
}

#define VERIFY_FINALLY_STACK() \
    if (!IGRAPH_FINALLY_STACK_EMPTY) { \
        printf( \
          "%s:%d : " \
          "Finally stack is not empty (stack size is %d). " \
          "Check that the number in IGRAPH_FINALLY_CLEAN matches the IGRAPH_FINALLY count.\n", \
          IGRAPH_FILE_BASENAME, __LINE__, IGRAPH_FINALLY_STACK_SIZE()); \
        abort(); \
    }

/* Run a test in a separate function; return the return value of the function
 * if it is nonzero. Also verify the FINALLY stack and bail out if it is not
 * empty. Needs an integer variable named 'retval' in the local context. */
#define RUN_TEST(func) \
    { \
        retval = func(); \
        if (retval) { \
            return retval; \
        } \
        VERIFY_FINALLY_STACK(); \
    }

#define CHECK_ERROR(funcall, expected_err) \
    do { \
        igraph_error_handler_t *handler; \
        handler = igraph_set_error_handler(igraph_error_handler_ignore); \
        IGRAPH_ASSERT(funcall == expected_err); \
        igraph_set_error_handler(handler); \
    } while (0)

#endif /* TEST_UTILITIES_INC */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tls1.c0000644000175100001710000000273400000000000023030 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

void *thread_function(void *arg) {
    IGRAPH_FINALLY(igraph_free, NULL);
    return 0;
}

int main() {
    pthread_t thread_id;
    void *exit_status;

    /* Skip if igraph is not thread-safe */
    if (!IGRAPH_THREAD_SAFE) {
        return 77;
    }

    /* Run a thread that leaves some junk in the error stack */
    pthread_create(&thread_id, NULL, thread_function, 0);
    pthread_join(thread_id, &exit_status);

    /* Check that the error stack is not common */
    if (!IGRAPH_FINALLY_STACK_EMPTY) {
        printf("Foobar\n");
        return 1;
    }

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tls2.c0000644000175100001710000001642200000000000023030 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 
#include 

#include "linalg/arpack_internal.h"

#include "test_utilities.inc"

/* Test whether ARPACK is thread-safe. We will create two threads,
   each calling a different ARPACK eigensolver. We will make sure that
   the ARPACK calls from the two threads overlap */

typedef struct thread_data_t {
    igraph_matrix_t *m;
    igraph_vector_t *result;
    pthread_cond_t *cond;
    pthread_mutex_t *mutex;
    int *steps, *othersteps;
} thread_data_t;

int arpack_mult(igraph_real_t *to, igraph_real_t *from, int n,
                igraph_matrix_t *matrix) {
    /* TODO */
    igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0, matrix,
                                           from, /*beta=*/ 0.0, to);

    return 0;
}

/* This is the function performed by each thread. It calls the
   low-level ARPACK symmetric eigensolver, step by step. After each
   step, it synchronizes with the other thread.

   The synchronization ensures that the two threads are using the
   thread-local variables at the same time. If they are really
   thread-local, then ARPACK still delivers the correct solution for
   the two matrices. Otherwise the result is undefined: maybe results
   will be incorrect, or the program will crash.

   This function is basically a simplified copy of igraph_arpack_rssolve.
*/

void *thread_function(void *arg) {
    thread_data_t *data = (thread_data_t*) arg;
    igraph_matrix_t *M = data->m;
    igraph_vector_t *result = data->result;
    pthread_cond_t *cond = data->cond;
    pthread_mutex_t *mutex = data->mutex;
    igraph_arpack_options_t options;
    igraph_real_t *v, *workl, *workd, *d, *resid, *ax;
    int *select;
    int ido = 0;
#if IGRAPH_THREAD_SAFE
    int rvec = 1;
    char *all = "All";
#endif
    int i;

    igraph_arpack_options_init(&options);
    options.n = igraph_matrix_nrow(M);
    options.ldv = options.n;
    options.nev = 1;
    options.ncv = 3;
    options.lworkl = options.ncv * (options.ncv + 8);
    options.which[0] = 'L';
    options.which[1] = 'M';

    options.iparam[0] = options.ishift;
    options.iparam[2] = options.mxiter;
    options.iparam[3] = options.nb;
    options.iparam[4] = 0;
    options.iparam[6] = options.mode;
    options.info = options.start;

    v = IGRAPH_CALLOC(options.ldv * options.ncv, igraph_real_t);
    workl = IGRAPH_CALLOC(options.lworkl, igraph_real_t);
    workd = IGRAPH_CALLOC(3 * options.n, igraph_real_t);
    d = IGRAPH_CALLOC(2 * options.ncv, igraph_real_t);
    resid = IGRAPH_CALLOC(options.n, igraph_real_t);
    ax = IGRAPH_CALLOC(options.n, igraph_real_t);
    select = IGRAPH_CALLOC(options.ncv, int);

    if (!v || !workl || !workd || !d || !resid || !ax || !select) {
        printf("Out of memory\n");
        return 0;
    }

    while (1) {
#if IGRAPH_THREAD_SAFE
        igraphdsaupd_(&ido, options.bmat, &options.n, options.which,
                      &options.nev, &options.tol, resid, &options.ncv, v,
                      &options.ldv, options.iparam, options.ipntr, workd,
                      workl, &options.lworkl, &options.info);
#endif

        if (ido == -1 || ido == 1) {

            igraph_real_t *from = workd + options.ipntr[0] - 1;
            igraph_real_t *to = workd + options.ipntr[1] - 1;
            arpack_mult(to, from, options.n, M);

        } else {
            break;
        }

        pthread_mutex_lock(mutex);
        *(data->steps) += 1;
        if ( *(data->othersteps) == *(data->steps) ) {
            pthread_cond_signal(cond);
        }

        while ( *(data->othersteps) < * (data->steps) && *(data->othersteps) != -1 ) {
            pthread_cond_wait(cond, mutex);
        }
        pthread_mutex_unlock(mutex);
    }

    pthread_mutex_lock(mutex);
    *data->steps = -1;
    pthread_cond_signal(cond);
    pthread_mutex_unlock(mutex);

    if (options.info != 0) {
        printf("ARPACK error\n");
        return 0;
    }

#if IGRAPH_THREAD_SAFE
    igraphdseupd_(&rvec, all, select, d, v, &options.ldv,
                  &options.sigma, options.bmat, &options.n,
                  options.which, &options.nev, &options.tol,
                  resid, &options.ncv, v, &options.ldv, options.iparam,
                  options.ipntr, workd, workl, &options.lworkl,
                  &options.ierr);
#endif

    if (options.ierr != 0) {
        printf("ARPACK error\n");
        return 0;
    }

    igraph_vector_resize(result, options.n);
    for (i = 0; i < options.n; i++) {
        VECTOR(*result)[i] = v[i];
    }

    free(v);
    free(workl);
    free(workd);
    free(d);
    free(resid);
    free(ax);
    free(select);

    return 0;
}

int main() {
    pthread_t thread_id1, thread_id2;
    void *exit_status1, *exit_status2;
    igraph_matrix_t m1, m2;
    igraph_vector_t result1, result2;
    pthread_cond_t steps_cond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t steps_mutex = PTHREAD_MUTEX_INITIALIZER;
    int steps1 = 0, steps2 = 0;
    thread_data_t
    data1 = { &m1, &result1, &steps_cond, &steps_mutex, &steps1, &steps2 },
    data2 = { &m2, &result2, &steps_cond, &steps_mutex, &steps2, &steps1 };
    int i, j;

    /* Skip if igraph is not thread safe */
    if (!IGRAPH_THREAD_SAFE) {
        return 77;
    }

    igraph_matrix_init(&m1, 10, 10);
    igraph_matrix_init(&m2, 10, 10);
    igraph_vector_init(&result1, igraph_matrix_nrow(&m1));
    igraph_vector_init(&result2, igraph_matrix_nrow(&m2));

    igraph_rng_seed(igraph_rng_default(), 42);

    for (i = 0; i < igraph_matrix_nrow(&m1); i++) {
        for (j = 0; j <= i; j++) {
            MATRIX(m1, i, j) = MATRIX(m1, j, i) =
                                   igraph_rng_get_integer(igraph_rng_default(), 0, 10);
        }
    }

    for (i = 0; i < igraph_matrix_nrow(&m2); i++) {
        for (j = 0; j <= i; j++) {
            MATRIX(m2, i, j) = MATRIX(m2, j, i) =
                                   igraph_rng_get_integer(igraph_rng_default(), 0, 10);
        }
    }

    pthread_create(&thread_id1, NULL, thread_function, (void *) &data1);
    pthread_create(&thread_id2, NULL, thread_function, (void *) &data2);

    pthread_join(thread_id1, &exit_status1);
    pthread_join(thread_id2, &exit_status2);

    igraph_matrix_print(&m1);
    igraph_vector_print(&result1);
    printf("---\n");
    igraph_matrix_print(&m2);
    igraph_vector_print(&result2);

    igraph_vector_destroy(&result1);
    igraph_vector_destroy(&result2);
    igraph_matrix_destroy(&m1);
    igraph_matrix_destroy(&m2);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tls2.out0000644000175100001710000000113600000000000023411 0ustar00runnerdocker000000000000004 8 2 6 1 3 0 2 4 10
8 10 8 6 1 6 10 10 0 4
2 8 8 1 0 1 7 2 3 2
6 6 1 4 5 7 9 6 5 5
1 1 0 5 9 7 10 3 6 0
3 6 1 7 7 0 2 6 4 8
0 10 7 9 10 2 0 5 1 6
2 10 2 6 3 6 5 0 0 2
4 0 3 5 6 4 1 0 3 4
10 4 2 5 0 8 6 2 4 5
0.286678 0.451579 0.240944 0.373405 0.279524 0.306442 0.358295 0.280974 0.192354 0.316299
---
10 6 0 7 0 8 7 9 8 10
6 5 9 1 10 4 2 0 3 9
0 9 6 4 10 3 4 1 4 8
7 1 4 0 10 0 7 10 5 4
0 10 10 10 6 1 1 4 2 10
8 4 3 0 1 2 6 2 6 4
7 2 4 7 1 6 5 2 6 9
9 0 1 10 4 2 2 7 2 10
8 3 4 5 2 6 6 2 0 6
10 9 8 4 10 4 9 10 6 7
0.383729 0.301458 0.289645 0.287748 0.324551 0.214976 0.2921 0.298273 0.252215 0.453578
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/topological_sorting.c0000644000175100001710000000505200000000000026222 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {

    igraph_t g;
    igraph_vector_t v, res;
    igraph_bool_t is_dag;
    int ret;

    /* Test graph taken from http://en.wikipedia.org/wiki/Topological_sorting
     * @ 05.03.2006 */
    igraph_small(&g, 8, IGRAPH_DIRECTED,
                 0, 3, 0, 4, 1, 3, 2, 4, 2, 7, 3, 5, 3, 6, 3, 7, 4, 6,
                 -1);

    igraph_vector_init(&res, 0);

    igraph_is_dag(&g, &is_dag);
    if (!is_dag) {
        return 2;
    }

    igraph_topological_sorting(&g, &res, IGRAPH_OUT);
    print_vector_round(&res);
    igraph_topological_sorting(&g, &res, IGRAPH_IN);
    print_vector_round(&res);

    /* Error handling */
    VERIFY_FINALLY_STACK();
    igraph_set_error_handler(igraph_error_handler_ignore);

    /* Add a cycle: 5 -> 0 */
    igraph_vector_init_int(&v, 2, 5, 0);
    igraph_add_edges(&g, &v, 0);
    igraph_is_dag(&g, &is_dag);
    if (is_dag) {
        return 3;
    }
    ret = igraph_topological_sorting(&g, &res, IGRAPH_OUT);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }

    igraph_vector_destroy(&v);
    igraph_destroy(&g);

    /* This graph is the same but undirected */
    igraph_small(&g, 8, IGRAPH_UNDIRECTED,
                 0, 3, 0, 4, 1, 3, 2, 4, 2, 7, 3, 5, 3, 6, 3, 7, 4, 6,
                 -1);

    igraph_is_dag(&g, &is_dag);
    if (is_dag) {
        return 4;
    }

    ret = igraph_topological_sorting(&g, &res, IGRAPH_ALL);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }

    ret = igraph_topological_sorting(&g, &res, IGRAPH_OUT);
    if (ret != IGRAPH_EINVAL) {
        return 1;
    }

    igraph_destroy(&g);

    igraph_vector_destroy(&res);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/topological_sorting.out0000644000175100001710000000005000000000000026600 0ustar00runnerdocker00000000000000( 0 1 2 3 4 5 7 6 )
( 5 6 7 4 3 2 0 1 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tree.c0000644000175100001710000000160700000000000023102 0ustar00runnerdocker00000000000000
#include 
#include "test_utilities.inc"


#define PRINT_DESTROY(name) \
    printf(name "\n"); \
    print_graph_canon(&graph); \
    igraph_destroy(&graph); \
    printf("\n");


int main() {
    igraph_t graph;

    igraph_tree(&graph, 0, 1, IGRAPH_TREE_UNDIRECTED);
    PRINT_DESTROY("Null graph");

    igraph_tree(&graph, 0, 1, IGRAPH_TREE_OUT);
    PRINT_DESTROY("Directed null graph");

    igraph_tree(&graph, 1, 1, IGRAPH_TREE_UNDIRECTED);
    PRINT_DESTROY("Singleton graph");

    igraph_tree(&graph, 3, 1, IGRAPH_TREE_OUT);
    PRINT_DESTROY("Path graph");

    igraph_tree(&graph, 3, 2, IGRAPH_TREE_OUT);
    PRINT_DESTROY("Binary out-tree, n=3");

    igraph_tree(&graph, 3, 2, IGRAPH_TREE_IN);
    PRINT_DESTROY("Binary in-tree, n=3");

    igraph_tree(&graph, 14, 3, IGRAPH_TREE_OUT);
    PRINT_DESTROY("Ternary out-tree, n=14");

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tree.out0000644000175100001710000000072000000000000023462 0ustar00runnerdocker00000000000000Null graph
directed: false
vcount: 0
edges: {
}

Directed null graph
directed: true
vcount: 0
edges: {
}

Singleton graph
directed: false
vcount: 1
edges: {
}

Path graph
directed: true
vcount: 3
edges: {
0 1
1 2
}

Binary out-tree, n=3
directed: true
vcount: 3
edges: {
0 1
0 2
}

Binary in-tree, n=3
directed: true
vcount: 3
edges: {
1 0
2 0
}

Ternary out-tree, n=14
directed: true
vcount: 14
edges: {
0 1
0 2
0 3
1 4
1 5
1 6
2 7
2 8
2 9
3 10
3 11
3 12
4 13
}

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/tree_game.c0000644000175100001710000000651300000000000024074 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_t graph;
    igraph_bool_t is_tree = 0, are_connected = 0;

    igraph_rng_seed(igraph_rng_default(), 74088);

    /* Undirected */

    IGRAPH_ASSERT(igraph_tree_game(&graph, 123, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_LERW) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_tree(&graph, &is_tree, NULL, IGRAPH_OUT) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(is_tree);
    igraph_destroy(&graph);

    IGRAPH_ASSERT(igraph_tree_game(&graph, 123, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_PRUFER) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_tree(&graph, &is_tree, NULL, IGRAPH_OUT) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(is_tree);
    igraph_destroy(&graph);

    /* Directed out-tree */

    IGRAPH_ASSERT(igraph_tree_game(&graph, 123, IGRAPH_DIRECTED, IGRAPH_RANDOM_TREE_LERW) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_is_tree(&graph, &is_tree, NULL, IGRAPH_OUT) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(is_tree);
    igraph_destroy(&graph);

    /* IGRAPH_RANDOM_TREE_PRUFER does not currently support directed graphs */

    /* Null graph */

    IGRAPH_ASSERT(igraph_tree_game(&graph, 0, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_LERW) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 0);
    igraph_destroy(&graph);

    IGRAPH_ASSERT(igraph_tree_game(&graph, 0, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_PRUFER) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 0);
    igraph_destroy(&graph);

    /* Singleton graph */

    IGRAPH_ASSERT(igraph_tree_game(&graph, 1, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_LERW) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 1);
    igraph_destroy(&graph);

    IGRAPH_ASSERT(igraph_tree_game(&graph, 1, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_PRUFER) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 1);
    igraph_destroy(&graph);

    /* P_2 */

    IGRAPH_ASSERT(igraph_tree_game(&graph, 2, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_LERW) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 2);
    IGRAPH_ASSERT(igraph_ecount(&graph) == 1);
    IGRAPH_ASSERT(igraph_are_connected(&graph, 0, 1, &are_connected) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(are_connected);
    igraph_destroy(&graph);

    IGRAPH_ASSERT(igraph_tree_game(&graph, 2, IGRAPH_UNDIRECTED, IGRAPH_RANDOM_TREE_PRUFER) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vcount(&graph) == 2);
    IGRAPH_ASSERT(igraph_ecount(&graph) == 1);
    IGRAPH_ASSERT(igraph_are_connected(&graph, 0, 1, &are_connected) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(are_connected);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/triad_census.c0000644000175100001710000000172400000000000024626 0ustar00runnerdocker00000000000000
#include 

#include "test_utilities.inc"

int main() {
    /* this is a directed graph with 10 vertices and 20 edges: */
    igraph_integer_t vc = 10, ec = 20;
    igraph_real_t edge_data[] = {
        0, 2, 1, 4, 2, 5, 2, 7, 3, 7, 3, 8, 4, 2, 5, 8, 6, 0, 6, 1, 6, 2, 7,
        0, 8, 0, 8, 2, 8, 3, 8, 5, 9, 2, 9, 3, 9, 4, 9, 5
    };

    igraph_vector_t edges;
    igraph_vector_t tri;
    igraph_t graph;

    igraph_set_warning_handler(igraph_warning_handler_ignore);

    igraph_vector_view(&edges, edge_data, 2 * ec);

    igraph_create(&graph, &edges, vc, 1 /* directed=true */);

    igraph_vector_init(&tri, 0);

    igraph_triad_census(&graph, &tri);
    print_vector_round(&tri);

    igraph_to_undirected(&graph, IGRAPH_TO_UNDIRECTED_COLLAPSE, NULL); /* convert to undirected */
    igraph_triad_census(&graph, &tri);
    print_vector_round(&tri);

    igraph_vector_destroy(&tri);
    igraph_destroy(&graph);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/triad_census.out0000644000175100001710000000011700000000000025206 0ustar00runnerdocker00000000000000( 25 45 7 7 12 11 2 4 4 1 1 0 0 1 0 0 )
( 25 0 52 0 0 0 0 0 0 0 37 0 0 0 0 6 )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/trie.c0000644000175100001710000000743700000000000023115 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "core/trie.h"

#include "test_utilities.inc"

int main() {

    igraph_trie_t trie;
    long int id;
    int i;
    char *str;

    /* init */
    igraph_trie_init(&trie, 0);

    /* add and get values */
    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    igraph_trie_get(&trie, "a", &id);
    printf("a:     %li\n", id);
    igraph_trie_get(&trie, "axon", &id);
    printf("axon:  %li\n", id);

    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    /* check for existence */
    igraph_trie_check(&trie, "head", &id);
    printf("head:  %li\n", id);
    igraph_trie_check(&trie, "alma", &id);
    printf("alma:  %li\n", id);

    /* destroy */
    igraph_trie_destroy(&trie);

    /* the same with index */
    igraph_trie_init(&trie, 1);

    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    igraph_trie_get(&trie, "a", &id);
    printf("a:     %li\n", id);
    igraph_trie_get(&trie, "axon", &id);
    printf("axon:  %li\n", id);

    igraph_trie_get(&trie, "hello", &id);
    printf("hello: %li\n", id);
    igraph_trie_get(&trie, "hepp", &id);
    printf("hepp:  %li\n", id);
    igraph_trie_get(&trie, "alma", &id);
    printf("alma:  %li\n", id);
    igraph_trie_get(&trie, "also", &id);
    printf("also:  %li\n", id);

    /* check for existence */
    igraph_trie_check(&trie, "head", &id);
    printf("head:  %li\n", id);
    igraph_trie_check(&trie, "alma", &id);
    printf("alma:  %li\n", id);

    for (i = 0; i < igraph_trie_size(&trie); i++) {
        igraph_trie_idx(&trie, i, &str);
        printf("%d: %s\n", i, str);
    }
    igraph_trie_destroy(&trie);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/trie.out0000644000175100001710000000052000000000000023464 0ustar00runnerdocker00000000000000hello: 0
hepp:  1
alma:  2
also:  3
hello: 0
hepp:  1
alma:  2
also:  3
a:     4
axon:  5
hello: 0
hepp:  1
alma:  2
also:  3
head:  -1
alma:  2
hello: 0
hepp:  1
alma:  2
also:  3
hello: 0
hepp:  1
alma:  2
also:  3
a:     4
axon:  5
hello: 0
hepp:  1
alma:  2
also:  3
head:  -1
alma:  2
0: hello
1: hepp
2: alma
3: also
4: a
5: axon
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector.c0000644000175100001710000002755100000000000023453 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_vector_t v, v2, v3;
    int i;
    igraph_real_t *ptr;
    long int pos;
    igraph_real_t min, max, min2, max2;
    long int which_min, which_max, which_min2, which_max2;

    printf("Initialise empty vector\n");
    igraph_vector_init(&v, 0);
    igraph_vector_destroy(&v);

    printf("Initialise vector of length 10\n");
    igraph_vector_init(&v, 10);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test VECTOR() and igraph_vector_size\n");
    igraph_vector_init(&v, 10);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        VECTOR(v)[i] = 10 - i;
    }
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_reserve and igraph_vector_push_back\n");
    igraph_vector_init(&v, 0);
    igraph_vector_reserve(&v, 10);
    for (i = 0; i < 10; i++) {
        igraph_vector_push_back(&v, i);
    }

    printf("Test igraph_vector_empty and igraph_vector_clear\n");
    IGRAPH_ASSERT(!igraph_vector_empty(&v));
    igraph_vector_clear(&v);
    IGRAPH_ASSERT(igraph_vector_empty(&v));
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_e and igraph_vector_e_ptr\n");
    igraph_vector_init(&v, 5);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        *igraph_vector_e_ptr(&v, i) = 100 * i;
    }
    for (i = 0; i < igraph_vector_size(&v); i++) {
        printf(" %li", (long int)igraph_vector_e(&v, i));
    }
    printf("\n");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_set\n");
    igraph_vector_init(&v, 5);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        igraph_vector_set(&v, i, 20 * i);
    }
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_null\n");
    igraph_vector_init(&v, 0);
    igraph_vector_null(&v);
    igraph_vector_destroy(&v);
    igraph_vector_init(&v, 10);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        VECTOR(v)[i] = i + 1;
    }
    igraph_vector_null(&v);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_tail, igraph_vector_pop_back\n");
    igraph_vector_init(&v, 10);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        VECTOR(v)[i] = i + 1;
    }
    while (!igraph_vector_empty(&v)) {
        printf(" %li", (long int)igraph_vector_tail(&v));
        printf(" %li", (long int)igraph_vector_pop_back(&v));
    }
    printf("\n");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_seq, igraph_vector_order\n");
    igraph_vector_init_seq(&v, 1, 10);
    igraph_vector_init(&v2, 0);
    igraph_vector_order1(&v, &v2, 10);
    print_vector_format(&v2, stdout, "%g");
    igraph_vector_destroy(&v2);
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_resize, igraph_vector_sort\n");
    igraph_vector_init(&v, 20);
    for (i = 0; i < 10; i++) {
        VECTOR(v)[i] = 10 - i;
    }
    igraph_vector_resize(&v, 10);
    igraph_vector_sort(&v);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_{which}_{min, max}\n");
    igraph_vector_init(&v, 10);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        VECTOR(v)[i] = 100 - i;
    }
    for (i = 0; i < 10; i++) {
        printf(" %li", (long int)VECTOR(v)[i]);
    }
    printf("\n");

    min = igraph_vector_min(&v);
    which_min = igraph_vector_which_min(&v);

    IGRAPH_ASSERT(min == 91);
    IGRAPH_ASSERT(which_min == 9);
    IGRAPH_ASSERT(min == VECTOR(v)[which_min]);

    max = igraph_vector_max(&v);
    which_max = igraph_vector_which_max(&v);

    IGRAPH_ASSERT(max == 100);
    IGRAPH_ASSERT(which_max == 0);
    IGRAPH_ASSERT(max == VECTOR(v)[which_max]);

    igraph_vector_minmax(&v, &min2, &max2);
    igraph_vector_which_minmax(&v, &which_min2, &which_max2);

    IGRAPH_ASSERT(min == min2);
    IGRAPH_ASSERT(max == max2);
    IGRAPH_ASSERT(which_min == which_min2);
    IGRAPH_ASSERT(which_max == which_max2);
    IGRAPH_ASSERT(min2 == VECTOR(v)[which_min2]);
    IGRAPH_ASSERT(max2 == VECTOR(v)[which_max2]);

    printf("Test NaN values\n");
    igraph_vector_push_back(&v, IGRAPH_NAN);
    igraph_vector_push_back(&v, IGRAPH_NAN);
    igraph_vector_push_back(&v, 1);

    IGRAPH_ASSERT(igraph_vector_is_any_nan(&v));

    min = igraph_vector_min(&v);
    which_min = igraph_vector_which_min(&v);

    IGRAPH_ASSERT(igraph_is_nan(min));
    /* Index should be to first NaN value */
    IGRAPH_ASSERT(which_min == 10);
    IGRAPH_ASSERT(igraph_is_nan(VECTOR(v)[which_min]));

    max = igraph_vector_max(&v);
    which_max = igraph_vector_which_max(&v);

    IGRAPH_ASSERT(igraph_is_nan(max));
    /* Index should be to first NaN value */
    IGRAPH_ASSERT(which_max == 10);
    /* In case of NaN it should hold that which_max == which_min */
    IGRAPH_ASSERT(which_max == which_min);

    igraph_vector_minmax(&v, &min2, &max2);
    igraph_vector_which_minmax(&v, &which_min2, &which_max2);

    IGRAPH_ASSERT(igraph_is_nan(min2));
    IGRAPH_ASSERT(igraph_is_nan(max2));
    IGRAPH_ASSERT(which_min == which_min2);
    IGRAPH_ASSERT(which_max == which_max2);
    /* In case of NaN it should hold that which_max == which_min */
    IGRAPH_ASSERT(which_min2 == which_max2);
    IGRAPH_ASSERT(igraph_is_nan(VECTOR(v)[which_min2]));
    IGRAPH_ASSERT(igraph_is_nan(VECTOR(v)[which_max2]));

    printf("Test igraph_vector_init_copy\n");
    igraph_vector_destroy(&v);
    ptr = (igraph_real_t*) malloc(10 * sizeof(igraph_real_t));
    igraph_vector_init_copy(&v, ptr, 10);
    free(ptr);
    for (i = 0; i < 10; i++) {
        VECTOR(v)[i] = 100 - i;
    }
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_copy_to\n");
    ptr = (igraph_real_t*) malloc(10 * sizeof(igraph_real_t));
    igraph_vector_init_seq(&v, 11, 20);
    igraph_vector_copy_to(&v, ptr);
    for (i = 0; i < 10; i++) {
        printf(" %li", (long int)ptr[i]);
    }
    printf("\n");
    free(ptr);
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_seq, igraph_vector_sum, igraph_vector_prod\n");
    igraph_vector_init_seq(&v, 1, 5);
    printf(" %li", (long int)igraph_vector_sum(&v));
    printf(" %li\n", (long int)igraph_vector_prod(&v));

    printf("Test igraph_vector_remove_section\n");
    igraph_vector_remove_section(&v, 2, 4);
    printf(" %li", (long int)igraph_vector_sum(&v));
    printf(" %li\n", (long int)igraph_vector_prod(&v));
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_remove\n");
    igraph_vector_init_seq(&v, 1, 10);
    igraph_vector_remove(&v, 9);
    igraph_vector_remove(&v, 0);
    igraph_vector_remove(&v, 4);
    printf(" %li\n", (long int)igraph_vector_sum(&v));
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_move_interval\n");
    igraph_vector_init_seq(&v, 0, 9);
    igraph_vector_move_interval(&v, 5, 10, 0);
    IGRAPH_ASSERT(igraph_vector_sum(&v) == 70);
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_isininterval\n");
    igraph_vector_init_seq(&v, 1, 10);
    IGRAPH_ASSERT(igraph_vector_isininterval(&v, 1, 10));
    IGRAPH_ASSERT(!igraph_vector_isininterval(&v, 2, 10));
    IGRAPH_ASSERT(!igraph_vector_isininterval(&v, 1, 9));

    printf("Test igraph_vector_any_smaller\n");
    IGRAPH_ASSERT(!igraph_vector_any_smaller(&v, 1));
    IGRAPH_ASSERT(igraph_vector_any_smaller(&v, 2));
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_all_e\n");

    printf("Test igraph_vector_binsearch\n");
    igraph_vector_init_seq(&v, 0, 9);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        IGRAPH_ASSERT(igraph_vector_binsearch(&v, 0, 0));
    }
    IGRAPH_ASSERT(!igraph_vector_binsearch(&v, 10, 0));
    IGRAPH_ASSERT(!igraph_vector_binsearch(&v, -1, 0));

    for (i = 0; i < igraph_vector_size(&v); i++) {
        VECTOR(v)[i] = 2 * i;
    }
    for (i = 0; i < igraph_vector_size(&v); i++) {
        long int pos;
        IGRAPH_ASSERT(igraph_vector_binsearch(&v, VECTOR(v)[i], &pos));
        IGRAPH_ASSERT(pos == i);
        IGRAPH_ASSERT(!igraph_vector_binsearch(&v, VECTOR(v)[i] + 1, &pos));
    }
    igraph_vector_destroy(&v);

    printf("Test Binsearch in empty vector\n");
    igraph_vector_init(&v, 0);
    IGRAPH_ASSERT(!igraph_vector_binsearch2(&v, 0));
    IGRAPH_ASSERT(!igraph_vector_binsearch(&v, 1, &pos));
    IGRAPH_ASSERT(pos == 0);
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_real\n");
    igraph_vector_init_real(&v, 10, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_int\n");
    igraph_vector_init_int(&v, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_real\n");
    igraph_vector_init_real_end(&v, -1, 1.0, 2.0, 3.0, 4.0, 5.0,
                                6.0, 7.0, 8.0, 9.0, 10.0, -1.0);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_init_int\n");
    igraph_vector_init_int_end(&v, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -1);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test igraph_vector_permdelete\n");
    printf("Test igraph_vector_remove_negidx\n");

    printf("Test order2\n");
    igraph_vector_init_int_end(&v, -1, 10, 9, 8, 7, 6, 7, 8, 9, 10, -1);
    igraph_vector_order2(&v);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test filter_smaller, quite special....\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 2, 3, 4, 4, 4, 4, 5, 6, 7, 8, -1);
    igraph_vector_filter_smaller(&v, 4);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);
    igraph_vector_init_int_end(&v, -1, 1, 2, 3, 4, 4, 4, 4, 5, 6, 7, 8, -1);
    igraph_vector_filter_smaller(&v, 0);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);
    igraph_vector_init_int_end(&v, -1, 0, 0, 1, 2, 3, 4, 4, 4, 4, 5, 6, 7, 8, -1);
    igraph_vector_filter_smaller(&v, 0);
    print_vector_format(&v, stdout, "%g");
    igraph_vector_destroy(&v);

    printf("Test rank\n");
    igraph_vector_init_int_end(&v, -1, 0, 1, 2, 6, 5, 2, 1, 0, -1);
    igraph_vector_init(&v2, 0);
    igraph_vector_rank(&v, &v2, 7);
    print_vector_format(&v, stdout, "%g");
    print_vector_format(&v2, stdout, "%g");
    igraph_vector_destroy(&v);
    igraph_vector_destroy(&v2);

    printf("Test order\n");
    igraph_vector_init_int_end(&v,  -1, 1, 1, 2, 2, -1);
    igraph_vector_init_int_end(&v2, -1, 2, 3, 1, 3, -1);
    igraph_vector_init(&v3, 0);
    igraph_vector_order(&v, &v2, &v3, 3);
    print_vector_format(&v3, stdout, "%g");
    igraph_vector_destroy(&v);
    igraph_vector_destroy(&v2);
    igraph_vector_destroy(&v3);

    printf("Test fill\n");

    igraph_vector_init(&v, 100);
    igraph_vector_fill(&v, 1.234567);
    for (i = 0; i < igraph_vector_size(&v); i++) {
        IGRAPH_ASSERT(VECTOR(v)[i] == 1.234567);
    }
    igraph_vector_destroy(&v);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector.out0000644000175100001710000000320600000000000024027 0ustar00runnerdocker00000000000000Initialise empty vector
Initialise vector of length 10
( 0 0 0 0 0 0 0 0 0 0 )
Test VECTOR() and igraph_vector_size
( 10 9 8 7 6 5 4 3 2 1 )
Test igraph_vector_reserve and igraph_vector_push_back
Test igraph_vector_empty and igraph_vector_clear
Test igraph_vector_e and igraph_vector_e_ptr
 0 100 200 300 400
Test igraph_vector_set
( 0 20 40 60 80 )
Test igraph_vector_null
( 0 0 0 0 0 0 0 0 0 0 )
Test igraph_vector_tail, igraph_vector_pop_back
 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1
Test igraph_vector_init_seq, igraph_vector_order
( 0 1 2 3 4 5 6 7 8 9 )
Test igraph_vector_resize, igraph_vector_sort
( 1 2 3 4 5 6 7 8 9 10 )
Test igraph_vector_{which}_{min, max}
 100 99 98 97 96 95 94 93 92 91
Test NaN values
Test igraph_vector_init_copy
( 100 99 98 97 96 95 94 93 92 91 )
Test igraph_vector_copy_to
 11 12 13 14 15 16 17 18 19 20
Test igraph_vector_init_seq, igraph_vector_sum, igraph_vector_prod
 15 120
Test igraph_vector_remove_section
 8 10
Test igraph_vector_remove
 38
Test igraph_vector_move_interval
Test igraph_vector_isininterval
Test igraph_vector_any_smaller
Test igraph_vector_all_e
Test igraph_vector_binsearch
Test Binsearch in empty vector
Test igraph_vector_init_real
( 1 2 3 4 5 6 7 8 9 10 )
Test igraph_vector_init_int
( 1 2 3 4 5 6 7 8 9 10 )
Test igraph_vector_init_real
( 1 2 3 4 5 6 7 8 9 10 )
Test igraph_vector_init_int
( 1 2 3 4 5 6 7 8 9 10 )
Test igraph_vector_permdelete
Test igraph_vector_remove_negidx
Test order2
( 0 8 1 7 6 2 3 5 4 )
Test filter_smaller, quite special....
( 4 4 5 6 7 8 )
( 1 2 3 4 4 4 4 5 6 7 8 )
( 0 1 2 3 4 4 4 4 5 6 7 8 )
Test rank
( 0 1 2 6 5 2 1 0 )
( 1 3 5 7 6 4 2 0 )
Test order
( 0 1 2 3 )
Test fill
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector2.c0000644000175100001710000000705100000000000023526 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2007-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

int main() {

    igraph_vector_t v1, v2, v3;
    igraph_real_t min, max;
    long int imin, imax;
    int i;

    igraph_vector_init_seq(&v1, 1, 10);
    igraph_vector_init_seq(&v2, 0, 9);

    igraph_vector_swap(&v1, &v2);
    print_vector_format(&v1, stdout, "%g");
    print_vector_format(&v2, stdout, "%g");

    igraph_vector_swap_elements(&v1, 0, 9);
    igraph_vector_swap_elements(&v1, 3, 6);
    print_vector_format(&v1, stdout, "%g");

    igraph_vector_reverse(&v2);
    print_vector_format(&v2, stdout, "%g");
    igraph_vector_reverse(&v2);
    print_vector_format(&v2, stdout, "%g");

    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);

    igraph_vector_init(&v1, 10);
    igraph_vector_init(&v2, 10);
    igraph_vector_fill(&v1, 4);
    igraph_vector_fill(&v2, 2);

    igraph_vector_add(&v1, &v2);
    print_vector_format(&v1, stdout, "%g");
    igraph_vector_sub(&v1, &v2);
    print_vector_format(&v1, stdout, "%g");
    igraph_vector_div(&v1, &v2);
    print_vector_format(&v1, stdout, "%g");
    igraph_vector_mul(&v1, &v2);
    print_vector_format(&v1, stdout, "%g");

    igraph_vector_minmax(&v1, &min, &max);
    igraph_vector_which_minmax(&v1, &imin, &imax);
    printf("%g %g %li %li\n", min, max, imin, imax);

    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);

    igraph_vector_init_seq(&v1, 1, 10);
    igraph_vector_init(&v2, 10);
    for (i = 0; i < 10; i++) {
        VECTOR(v2)[i] = 10 - i;
    }

    igraph_vector_minmax(&v1, &min, &max);
    igraph_vector_which_minmax(&v1, &imin, &imax);
    printf("%g %g %li %li\n", min, max, imin, imax);
    igraph_vector_minmax(&v2, &min, &max);
    igraph_vector_which_minmax(&v2, &imin, &imax);
    printf("%g %g %li %li\n", min, max, imin, imax);

    if (igraph_vector_isnull(&v1)) {
        return 1;
    }
    igraph_vector_null(&v1);
    if (!igraph_vector_isnull(&v1)) {
        return 2;
    }

    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);

    igraph_vector_init_int(&v1, 10, 3, 5, 6, 6, 6, 7, 8, 8, 9, 10);
    igraph_vector_init_int(&v2, 10, 1, 3, 3, 6, 6, 9, 12, 15, 17, 20);
    igraph_vector_init(&v3, 0);

    igraph_vector_intersect_sorted(&v1, &v2, &v3);
    print_vector_format(&v3, stdout, "%g");

    igraph_vector_difference_sorted(&v1, &v2, &v3);
    print_vector_format(&v3, stdout, "%g");
    igraph_vector_difference_sorted(&v2, &v1, &v3);
    print_vector_format(&v3, stdout, "%g");
    igraph_vector_difference_sorted(&v2, &v2, &v3);
    print_vector_format(&v3, stdout, "%g");

    igraph_vector_destroy(&v1);
    igraph_vector_destroy(&v2);
    igraph_vector_destroy(&v3);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector2.out0000644000175100001710000000044600000000000024114 0ustar00runnerdocker00000000000000( 0 1 2 3 4 5 6 7 8 9 )
( 1 2 3 4 5 6 7 8 9 10 )
( 9 1 2 6 4 5 3 7 8 0 )
( 10 9 8 7 6 5 4 3 2 1 )
( 1 2 3 4 5 6 7 8 9 10 )
( 6 6 6 6 6 6 6 6 6 6 )
( 4 4 4 4 4 4 4 4 4 4 )
( 2 2 2 2 2 2 2 2 2 2 )
( 4 4 4 4 4 4 4 4 4 4 )
4 4 0 0
1 10 0 9
1 10 9 0
( 3 6 6 9 )
( 5 7 8 8 10 )
( 1 12 15 17 20 )
( )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector3.c0000644000175100001710000000316400000000000023530 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2012  Gabor Csardi 
   334 Harvard st, Cambridge MA, USA 02139

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

#include "test_utilities.inc"

int main() {
    igraph_vector_t v;

    igraph_vector_init_seq(&v, 1, 1000);
    IGRAPH_ASSERT(igraph_vector_capacity(&v) == 1000);

    igraph_vector_push_back(&v, 1001);
    IGRAPH_ASSERT(igraph_vector_capacity(&v) == 2000);

    igraph_vector_resize_min(&v);
    IGRAPH_ASSERT(igraph_vector_capacity(&v) == igraph_vector_size(&v));

    igraph_vector_destroy(&v);

    /* regression test for #1479 -- calling resize_min() on an empty vector */
    igraph_vector_init_seq(&v, 1, 1000);
    igraph_vector_clear(&v);
    igraph_vector_resize_min(&v);
    IGRAPH_ASSERT(igraph_vector_capacity(&v) == 0);
    IGRAPH_ASSERT(igraph_vector_size(&v) == 0);
    igraph_vector_destroy(&v);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vector_ptr.c0000644000175100001710000002011000000000000024320 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2006-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

igraph_vector_ptr_t custom_destructor_stack;

void custom_destructor(void* ptr) {
    igraph_vector_ptr_push_back(&custom_destructor_stack, ptr);
}

int main() {

    igraph_vector_ptr_t v1, v2;
    igraph_vector_ptr_t v3 = IGRAPH_VECTOR_PTR_NULL;
    int i;
    void ** ptr;
    int d1 = 1, d2 = 2, d3 = 3, d4 = 4, d5 = 5;
    char *block1 = 0, *block2 = 0;

    /* igraph_vector_ptr_init, igraph_vector_ptr_destroy */
    igraph_vector_ptr_init(&v1, 10);
    igraph_vector_ptr_destroy(&v1);
    igraph_vector_ptr_init(&v1, 0);
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_free_all, igraph_vector_ptr_destroy_all */
    igraph_vector_ptr_init(&v1, 5);
    for (i = 0; i < igraph_vector_ptr_size(&v1); i++) {
        VECTOR(v1)[i] = (void*)malloc(i * 10);
    }
    igraph_vector_ptr_free_all(&v1);
    for (i = 0; i < igraph_vector_ptr_size(&v1); i++) {
        VECTOR(v1)[i] = (void*)malloc(i * 10);
    }
    igraph_vector_ptr_destroy_all(&v1);

    /* igraph_vector_ptr_reserve */
    igraph_vector_ptr_init(&v1, 0);
    igraph_vector_ptr_reserve(&v1, 5);
    igraph_vector_ptr_reserve(&v1, 15);
    igraph_vector_ptr_reserve(&v1, 1);
    igraph_vector_ptr_reserve(&v1, 0);
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_empty, igraph_vector_ptr_clear */
    igraph_vector_ptr_init(&v1, 10);
    if (igraph_vector_ptr_empty(&v1)) {
        return 1;
    }
    igraph_vector_ptr_clear(&v1);
    if (!igraph_vector_ptr_empty(&v1)) {
        return 2;
    }

    /* igraph_vector_ptr_size */
    if (igraph_vector_ptr_size(&v1) != 0) {
        return 3;
    }
    igraph_vector_ptr_resize(&v1, 10);
    if (igraph_vector_ptr_size(&v1) != 10) {
        return 4;
    }
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_push_back */
    igraph_vector_ptr_init(&v1, 0);
    for (i = 0; i < 10; i++) {
        igraph_vector_ptr_push_back(&v1, (void*)malloc(i * 10));
    }
    igraph_vector_ptr_destroy_all(&v1);

    /* igraph_vector_ptr_e */
    igraph_vector_ptr_init(&v1, 5);
    VECTOR(v1)[0] = &d1;
    VECTOR(v1)[1] = &d2;
    VECTOR(v1)[2] = &d3;
    VECTOR(v1)[3] = &d4;
    VECTOR(v1)[4] = &d5;
    if (igraph_vector_ptr_e(&v1, 0) != &d1) {
        return 5;
    }
    if (igraph_vector_ptr_e(&v1, 1) != &d2) {
        return 6;
    }
    if (igraph_vector_ptr_e(&v1, 2) != &d3) {
        return 7;
    }
    if (igraph_vector_ptr_e(&v1, 3) != &d4) {
        return 8;
    }
    if (igraph_vector_ptr_e(&v1, 4) != &d5) {
        return 9;
    }
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_set */
    igraph_vector_ptr_init(&v1, 5);
    igraph_vector_ptr_set(&v1, 0, &d1);
    igraph_vector_ptr_set(&v1, 1, &d2);
    igraph_vector_ptr_set(&v1, 2, &d3);
    igraph_vector_ptr_set(&v1, 3, &d4);
    igraph_vector_ptr_set(&v1, 4, &d5);
    if (igraph_vector_ptr_e(&v1, 0) != &d1) {
        return 5;
    }
    if (igraph_vector_ptr_e(&v1, 1) != &d2) {
        return 6;
    }
    if (igraph_vector_ptr_e(&v1, 2) != &d3) {
        return 7;
    }
    if (igraph_vector_ptr_e(&v1, 3) != &d4) {
        return 8;
    }
    if (igraph_vector_ptr_e(&v1, 4) != &d5) {
        return 9;
    }
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_null */
    igraph_vector_ptr_init(&v1, 5);
    igraph_vector_ptr_set(&v1, 0, &d1);
    igraph_vector_ptr_set(&v1, 1, &d2);
    igraph_vector_ptr_set(&v1, 2, &d3);
    igraph_vector_ptr_set(&v1, 3, &d4);
    igraph_vector_ptr_set(&v1, 4, &d5);
    igraph_vector_ptr_null(&v1);
    for (i = 0; i < igraph_vector_ptr_size(&v1); i++) {
        if (VECTOR(v1)[i] != 0) {
            return 10;
        }
    }
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_resize */
    igraph_vector_ptr_init(&v1, 10);
    igraph_vector_ptr_set(&v1, 0, &d1);
    igraph_vector_ptr_set(&v1, 1, &d2);
    igraph_vector_ptr_set(&v1, 2, &d3);
    igraph_vector_ptr_set(&v1, 3, &d4);
    igraph_vector_ptr_set(&v1, 4, &d5);
    igraph_vector_ptr_resize(&v1, 10);
    igraph_vector_ptr_resize(&v1, 15);
    igraph_vector_ptr_resize(&v1, 5);
    if (igraph_vector_ptr_size(&v1) != 5) {
        return 11;
    }
    if (igraph_vector_ptr_e(&v1, 0) != &d1) {
        return 12;
    }
    if (igraph_vector_ptr_e(&v1, 1) != &d2) {
        return 13;
    }
    if (igraph_vector_ptr_e(&v1, 2) != &d3) {
        return 14;
    }
    if (igraph_vector_ptr_e(&v1, 3) != &d4) {
        return 15;
    }
    if (igraph_vector_ptr_e(&v1, 4) != &d5) {
        return 16;
    }
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_view */
    ptr = (void**) malloc(5 * sizeof(void*));
    igraph_vector_ptr_view(&v3, ptr, 5);
    ptr[0] = &d1;
    ptr[1] = &d2;
    ptr[2] = &d3;
    ptr[3] = &d4;
    ptr[4] = &d5;
    for (i = 0; i < igraph_vector_ptr_size(&v3); i++) {
        if ( *((int*)VECTOR(v3)[i]) != i + 1) {
            return 17;
        }
    }

    /* igraph_vector_ptr_init_copy */
    igraph_vector_ptr_init_copy(&v1, ptr, 5);
    for (i = 0; i < igraph_vector_ptr_size(&v1); i++) {
        if ( *((int*)VECTOR(v1)[i]) != i + 1) {
            return 18;
        }
    }

    /* igraph_vector_ptr_copy_to */
    igraph_vector_ptr_copy_to(&v1, ptr);
    for (i = 0; i < igraph_vector_ptr_size(&v1); i++) {
        if ( *((int*)ptr[i]) != i + 1) {
            return 19;
        }
    }
    free(ptr);
    igraph_vector_ptr_destroy(&v1);

    /* igraph_vector_ptr_copy */
    igraph_vector_ptr_init(&v1, 5);
    igraph_vector_ptr_set(&v1, 0, &d1);
    igraph_vector_ptr_set(&v1, 1, &d2);
    igraph_vector_ptr_set(&v1, 2, &d3);
    igraph_vector_ptr_set(&v1, 3, &d4);
    igraph_vector_ptr_set(&v1, 4, &d5);
    igraph_vector_ptr_copy(&v2, &v1);
    igraph_vector_ptr_destroy(&v1);
    for (i = 0; i < igraph_vector_ptr_size(&v2); i++) {
        if ( *((int*)VECTOR(v2)[i]) != i + 1) {
            return 20;
        }
    }

    /* igraph_vector_ptr_remove */
    igraph_vector_ptr_remove(&v2, 0);
    igraph_vector_ptr_remove(&v2, 3);
    if ( *((int*)VECTOR(v2)[0]) != 2) {
        return 21;
    }
    if ( *((int*)VECTOR(v2)[1]) != 3) {
        return 22;
    }
    if ( *((int*)VECTOR(v2)[2]) != 4) {
        return 23;
    }

    igraph_vector_ptr_destroy(&v2);

    /* Testing destructor */
    igraph_vector_ptr_init(&custom_destructor_stack, 0);
    igraph_vector_ptr_init(&v1, 2);
    block1 = IGRAPH_CALLOC(32, char);
    block2 = IGRAPH_CALLOC(64, char);
    VECTOR(v1)[0] = block1;
    VECTOR(v1)[1] = block2;
    if (igraph_vector_ptr_get_item_destructor(&v1) != 0) {
        return 24;
    }
    if (igraph_vector_ptr_set_item_destructor(&v1, &custom_destructor) != 0) {
        return 25;
    }
    /* Okay, let's clear the vector. This should push the blocks in the
     * custom destructor stack */
    igraph_vector_ptr_clear(&v1);
    /* Put the blocks back and destroy the vector */
    igraph_vector_ptr_push_back(&v1, block1);
    igraph_vector_ptr_push_back(&v1, block2);
    igraph_vector_ptr_destroy_all(&v1);

    if (VECTOR(custom_destructor_stack)[0] != block1 ||
        VECTOR(custom_destructor_stack)[1] != block2 ||
        VECTOR(custom_destructor_stack)[2] != block1 ||
        VECTOR(custom_destructor_stack)[3] != block2
       ) {
        return 26;
    }

    igraph_vector_ptr_destroy(&custom_destructor_stack);

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vertex_selectors.c0000644000175100001710000000563700000000000025552 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

void check(igraph_t *graph, igraph_vs_t *vs) {
    igraph_vit_t vit;

    IGRAPH_ASSERT(igraph_vit_create(graph, *vs, &vit) == IGRAPH_SUCCESS);
    for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        printf("%" IGRAPH_PRId "\n", IGRAPH_VIT_GET(vit));
    }
}

int main() {
    igraph_t g, g_no_vertices, g_no_edges;
    igraph_vs_t vs;
    igraph_vector_t v;
    igraph_vit_t vit;

    igraph_small(&g, 5, IGRAPH_DIRECTED, 0,1, 0,2, 1,1, 1,3, 2,0, 2,3, 3,4, -1);
    igraph_small(&g_no_vertices, 0, IGRAPH_UNDIRECTED, -1);
    igraph_small(&g_no_edges, 5, IGRAPH_UNDIRECTED, -1);

    printf("Checking vs_none vertex selector:\n");
    IGRAPH_ASSERT(igraph_vs_none(&vs) == IGRAPH_SUCCESS);
    check(&g, &vs);
    check(&g_no_edges, &vs);
    check(&g_no_vertices, &vs);

    igraph_set_error_handler(igraph_error_handler_ignore);

    printf("Checking vector selector:\n");
    igraph_vector_init_int(&v, 3, 2, 3, 4);
    IGRAPH_ASSERT(igraph_vs_vector(&vs, &v) == IGRAPH_SUCCESS);
    printf("Some graph:\n");
    check(&g, &vs);
    printf("Edgeless graph:\n");
    check(&g_no_edges, &vs);
    printf("Graph without vertices should fail.\n");
    IGRAPH_ASSERT(igraph_vit_create(&g_no_vertices, vs, &vit) == IGRAPH_EINVVID);
    igraph_vector_destroy(&v);

    printf("Vertex selector with negative index should fail\n");
    igraph_vector_init_int(&v, 3, -2, 3, 4);
    IGRAPH_ASSERT(igraph_vs_vector(&vs, &v) == IGRAPH_SUCCESS);
    IGRAPH_ASSERT(igraph_vit_create(&g, vs, &vit) == IGRAPH_EINVVID);
    igraph_vector_destroy(&v);

    printf("Checking copy vector selector:\n");
    igraph_vector_init_int(&v, 3, 2, 3, 4);
    IGRAPH_ASSERT(igraph_vs_vector_copy(&vs, &v) == IGRAPH_SUCCESS);
    printf("Some graph:\n");
    check(&g, &vs);
    printf("Edgeless graph:\n");
    check(&g_no_edges, &vs);
    printf("Graph without vertices should fail.\n");
    IGRAPH_ASSERT(igraph_vit_create(&g_no_vertices, vs, &vit) == IGRAPH_EINVVID);
    IGRAPH_ASSERT(igraph_vs_type(&vs) == IGRAPH_VS_VECTOR);
    igraph_vector_destroy(&v);

    igraph_destroy(&g);
    igraph_destroy(&g_no_vertices);
    igraph_destroy(&g_no_edges);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/vertex_selectors.out0000644000175100001710000000044300000000000026125 0ustar00runnerdocker00000000000000Checking vs_none vertex selector:
Checking vector selector:
Some graph:
2
3
4
Edgeless graph:
2
3
4
Graph without vertices should fail.
Vertex selector with negative index should fail
Checking copy vector selector:
Some graph:
2
3
4
Edgeless graph:
2
3
4
Graph without vertices should fail.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/watts_strogatz_game.c0000644000175100001710000000763600000000000026243 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph R library.
   Copyright (C) 2011-2012  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 
#include 

#include "test_utilities.inc"

#define N 1000

igraph_bool_t has_loops(const igraph_t *graph) {
    int i, n = igraph_ecount(graph);
    for (i = 0; i < n; i++) {
        if (IGRAPH_FROM(graph, i) == IGRAPH_TO(graph, i)) {
            return 1;
        }
    }
    return 0;
}

igraph_bool_t has_multiple(const igraph_t *graph) {
    igraph_bool_t res;
    igraph_has_multiple(graph, &res);
    return res;
}

#define ERR() do {              \
        printf("Seed: %d\n", seed);           \
        igraph_write_graph_edgelist(&ws, stdout); \
    } while (0)

#define SEED() do {                         \
        seed=igraph_rng_get_integer(igraph_rng_default(), 1, 10000);        \
        igraph_rng_seed(igraph_rng_default(), seed);                \
    } while (0)

int main() {

    igraph_t ws;
    igraph_bool_t sim, seen_loops, seen_multiple;
    int i, seed = 1305473657;

    igraph_rng_seed(igraph_rng_default(), seed);

    /* No loops, no multiple edges */
    for (i = 0; i < N; i++) {
        SEED();
        igraph_watts_strogatz_game(&ws, /*dim=*/ 1, /*size=*/ 5, /*nei=*/ 1,
                                   /*p=*/ 0.5, /*loops=*/ 0, /*multiple=*/ 0);
        igraph_is_simple(&ws, &sim);
        if (!sim) {
            ERR();
            return 1;
        }
        if (has_loops(&ws)) {
            ERR();
            return 1;
        }
        if (has_multiple(&ws)) {
            ERR();
            return 2;
        }
        igraph_destroy(&ws);
    }

    /* No loops, multiple edges possible */
    seen_multiple = 0;
    for (i = 0; i < N; i++) {
        SEED();
        igraph_watts_strogatz_game(&ws, /*dim=*/ 1, /*size=*/ 5, /*nei=*/ 1,
                                   /*p=*/ 0.5, /*loops=*/ 0, /*multiple=*/ 1);
        if (has_loops(&ws)) {
            ERR();
            return 3;
        }
        seen_multiple = seen_multiple || has_multiple(&ws);
        igraph_destroy(&ws);
    }
    /* This might actually happen */
    /* if (!seen_multiple) { return 4; } */

    /* Loops possible, no multiple edges */
    seen_loops = 0;
    for (i = 0; i < N; i++) {
        SEED();
        igraph_watts_strogatz_game(&ws, /*dim=*/ 1, /*size=*/ 5, /*nei=*/ 1,
                                   /*p=*/ 0.5, /*loops=*/ 1, /*multiple=*/ 0);
        if (has_multiple(&ws)) {
            return 5;
        }
        seen_loops = seen_loops || has_loops(&ws);
        igraph_destroy(&ws);
    }
    /* This might actually happen */
    /* if (!seen_loops) { return 6; } */

    /* Both loops and multiple edges are possible */
    for (i = 0; i < N; i++) {
        SEED();
        igraph_watts_strogatz_game(&ws, /*dim=*/ 1, /*size=*/ 5, /*nei=*/ 1,
                                   /*p=*/ 0.5, /*loops=*/ 1, /*multiple=*/ 1);
        seen_loops = seen_loops || has_loops(&ws);
        seen_multiple = seen_multiple || has_multiple(&ws);
        igraph_destroy(&ws);
    }
    /* This might actually happen */
    /* if (!seen_loops) { return 7; } */
    /* if (!seen_multiple) { return 8; }   */

    VERIFY_FINALLY_STACK();

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/wikti_en_V_syn.elist0000644000175100001710000023235700000000000026040 0ustar00runnerdocker000000000000000 1
0 2
0 220
0 229
0 1010
1 2
1 12
1 3849
3 4
3 5
3 6
3 7
3 8
3 9
3 10
3 11
4 7
7 671
8 2285
9 671
10 671
10 939
10 1355
10 1844
10 2546
10 3054
11 671
12 3849
13 14
13 15
13 16
13 17
13 2270
14 1795
14 2270
14 2531
15 2270
17 1466
18 19
18 20
18 21
18 22
18 23
18 24
18 25
18 26
18 2041
21 1970
22 838
24 5101
25 2531
25 5101
27 1079
27 2041
27 2126
27 3081
28 29
28 30
28 31
28 32
28 33
28 34
28 35
28 36
28 37
28 38
29 31
29 35
29 881
29 882
29 883
29 884
29 885
38 3930
39 40
39 41
39 1251
42 6340
43 44
43 45
43 46
44 318
47 48
47 49
47 50
47 5319
48 50
48 51
48 3380
50 51
50 52
50 53
50 54
50 55
50 79
51 3380
52 58
52 59
52 60
52 61
52 62
52 63
52 64
52 65
52 66
52 67
52 68
52 69
52 70
52 71
52 72
52 73
52 74
52 75
52 76
52 77
52 78
52 1697
53 3380
56 7312
57 1376
58 61
58 64
58 67
58 73
58 2730
60 3371
61 3371
66 68
66 70
66 1949
66 3641
66 4869
66 4870
66 4871
66 4872
74 2543
74 4679
75 76
76 389
76 665
76 827
76 853
76 883
76 1017
76 1152
76 1416
76 1468
76 1469
76 1470
76 1471
76 1472
76 1473
76 1474
76 1475
76 1476
76 1477
76 1478
76 1479
76 1480
76 1481
76 1482
76 1483
76 1484
76 1485
76 1486
77 725
78 5319
80 2539
80 3798
81 2467
82 83
82 84
82 85
82 86
82 87
82 88
82 89
82 90
82 91
82 92
82 93
82 94
82 95
82 96
82 97
82 1006
82 2140
83 85
83 87
83 88
83 90
83 91
83 92
83 93
83 95
83 114
83 115
84 612
85 2140
85 4577
88 90
88 91
88 95
88 241
88 4572
88 5016
89 1003
89 1164
89 1180
89 1201
89 1909
89 2390
89 4415
89 5125
90 93
90 1201
90 1341
90 2390
91 241
91 5016
92 130
92 3619
95 4055
97 612
97 2531
97 2937
97 3516
97 4023
97 4024
97 4025
97 4026
97 4027
97 4028
97 4029
97 4030
97 4031
97 5016
98 99
98 100
99 100
99 106
99 3481
99 3616
99 5874
100 3616
100 4755
101 102
101 103
101 104
101 105
101 106
101 107
101 1095
101 4777
102 103
102 104
102 312
102 400
102 1189
102 1567
102 2699
102 2760
102 3393
102 3448
102 4243
102 5088
103 2760
103 3393
104 107
104 1498
104 1567
104 1999
104 3892
104 4777
105 106
105 107
106 107
106 3622
106 3952
106 4515
107 3997
107 4777
108 6079
109 110
109 111
109 112
109 113
109 1679
109 2263
116 117
116 118
117 355
118 251
118 2571
119 5857
120 4825
121 122
123 124
123 125
123 126
123 127
124 125
124 126
124 127
124 1398
125 126
125 127
126 127
128 129
130 138
130 2975
130 3618
131 132
132 380
132 384
132 385
132 386
132 742
132 1394
132 1704
132 2084
132 2085
132 2086
132 3018
132 3139
132 3201
132 3648
132 3653
132 3654
132 3655
132 4414
132 4987
132 5041
133 2975
134 135
134 136
135 5623
136 6204
137 138
137 139
137 140
137 141
137 142
137 143
137 144
137 145
137 146
137 147
137 148
137 149
137 150
137 151
137 152
137 153
137 154
137 155
137 156
137 157
137 158
137 159
137 160
137 161
137 162
137 163
137 164
137 165
137 166
137 167
137 168
137 169
137 170
137 171
137 172
137 173
137 174
137 175
137 176
138 139
138 140
138 141
138 142
138 143
138 185
138 186
138 187
138 188
138 189
138 190
138 191
138 192
138 193
138 194
138 195
138 196
138 197
138 198
138 199
138 200
138 201
138 202
138 203
138 204
138 205
138 206
138 207
138 208
138 209
138 210
138 211
139 208
140 142
140 205
140 208
140 1704
140 3960
141 204
141 3960
142 143
142 206
159 297
166 422
166 423
166 3804
177 3930
178 2725
178 2728
178 3816
179 2120
179 2122
180 181
181 4287
181 6173
181 6401
181 6444
181 7287
181 7292
182 445
182 2260
183 184
185 1138
185 1425
185 1797
185 2373
185 2984
185 3914
187 1210
187 1616
187 4154
188 597
189 567
189 1904
189 2390
189 4906
190 1882
190 2027
190 4158
191 1138
191 1425
191 3960
194 1498
195 1884
198 211
198 4920
199 205
202 621
202 622
202 623
203 385
203 1223
203 3270
204 567
204 587
204 1022
204 1704
204 1904
204 2960
205 1010
205 1013
205 1014
205 1494
205 1495
205 1496
206 2974
207 354
208 297
208 1748
208 3960
210 597
210 1138
210 1425
211 445
211 1653
211 3421
212 6259
213 1590
214 498
215 239
215 240
215 1153
215 2672
216 217
216 218
216 219
216 220
216 4766
217 220
217 2058
219 220
219 818
219 819
219 820
219 821
219 822
219 823
219 824
219 825
219 1722
219 4766
220 232
220 283
220 284
220 285
220 286
220 287
220 6453
221 222
221 223
221 224
221 225
221 226
221 227
221 784
221 3940
222 3940
223 1558
224 1653
224 1925
224 3098
225 226
225 564
225 1026
225 1558
225 2037
225 2363
225 3169
225 6678
226 227
226 564
226 1026
226 1558
226 1946
226 1947
226 2037
227 1558
227 2037
228 1589
228 3093
228 6782
229 230
229 231
229 232
229 233
229 234
229 235
229 236
229 237
229 238
230 236
230 1167
230 3423
230 3424
232 233
232 1010
233 234
233 235
233 1563
233 2064
233 3091
234 236
234 4496
236 4833
239 240
241 242
241 243
241 244
241 245
244 2390
245 1254
246 3094
247 248
249 250
249 251
249 252
249 604
250 251
250 400
250 965
251 354
251 393
251 394
251 395
251 396
251 397
251 398
251 399
251 400
251 401
251 402
251 985
251 1105
251 1126
251 1918
251 1980
252 297
253 254
253 255
253 256
253 257
253 258
253 259
253 260
253 261
253 262
253 263
253 264
255 454
255 1619
255 1971
257 523
262 3571
265 266
265 267
265 268
265 269
265 270
265 271
265 272
265 273
265 274
265 275
265 276
265 277
265 278
265 279
265 1821
280 281
280 282
281 5678
282 787
282 1636
282 2445
282 6200
283 6453
285 6453
286 2053
288 839
288 5033
289 290
289 291
289 292
289 293
289 294
289 295
289 296
289 297
289 298
289 299
289 300
289 301
289 302
289 303
289 304
289 305
289 306
289 307
289 308
289 706
289 1201
289 1722
289 2059
289 3615
289 3935
289 4539
289 4554
289 5254
289 6307
289 7197
289 7300
290 306
290 7300
291 306
291 4554
291 4555
291 7300
292 325
294 3279
296 4539
296 4540
296 7197
297 298
297 389
297 404
297 408
297 409
297 478
297 581
297 612
297 614
297 617
297 700
297 972
297 1180
297 1305
297 1318
297 1353
297 1371
297 1419
297 1431
297 1487
297 1721
297 1722
297 1723
297 1724
297 1725
297 1726
297 1727
297 1728
297 1729
297 1730
297 1731
297 1732
297 1733
297 1734
297 1735
297 1736
297 1737
297 1738
297 1739
297 1740
297 1741
297 1742
297 1743
297 1744
297 1745
297 1746
297 1747
297 1748
297 1749
297 1750
297 1751
297 1752
297 1753
297 1754
297 1755
297 1756
297 1757
297 2733
298 1722
298 2733
298 3935
299 498
299 1722
306 4554
306 7300
309 310
309 311
312 313
312 314
312 315
312 316
312 317
312 368
313 625
313 626
316 3390
317 1674
318 400
319 320
319 321
319 6552
322 935
322 6054
323 324
325 326
325 327
325 328
325 329
325 330
325 331
325 332
326 438
328 2041
328 2833
329 1079
330 587
330 2200
333 2495
333 2531
334 400
334 1402
334 2650
334 3156
334 3453
335 336
337 338
337 339
337 340
337 341
337 342
337 343
337 344
337 345
337 346
337 347
337 348
337 349
337 350
337 351
337 352
337 353
338 339
338 3852
339 341
339 342
339 343
339 346
339 347
339 351
339 4119
341 342
341 346
341 347
342 343
342 347
342 349
342 1597
346 347
351 3169
354 355
354 356
354 357
354 358
356 600
359 3508
359 3510
360 1180
361 362
362 2732
363 672
364 2488
365 366
366 4491
367 2213
368 369
368 370
369 370
369 1047
369 1239
369 1240
369 1241
369 1242
369 1243
371 6782
372 373
372 374
372 375
372 376
372 377
372 378
372 379
373 374
373 375
373 376
373 377
373 378
373 379
373 4791
374 375
374 378
374 379
375 1223
376 1223
381 3117
381 5859
382 3117
382 5215
382 5217
383 1400
384 385
384 386
384 387
384 388
384 5641
385 610
385 1889
385 3269
385 3270
385 3271
386 387
386 1889
386 3270
386 5640
386 7109
386 7110
387 5359
387 5641
388 1010
388 2958
389 390
389 391
389 392
389 496
389 1126
391 763
392 2079
393 1105
393 1106
394 672
396 453
396 623
396 2344
396 2571
396 2792
396 4217
397 1105
398 596
398 1413
399 400
399 1188
399 1925
399 1980
399 2213
400 470
400 581
400 617
400 666
400 671
400 672
400 689
400 706
400 722
400 767
400 857
400 905
400 914
400 956
400 968
400 1090
400 1105
400 1114
400 1118
400 1171
400 1172
400 1173
400 1174
400 1175
400 1176
400 1177
400 1178
400 1179
400 1180
400 1181
400 1182
400 1183
400 1184
400 1185
400 1186
400 1187
400 1188
400 1189
400 1190
400 1191
400 1192
400 1193
400 1194
400 1195
400 1219
400 1653
400 2263
400 3963
401 454
402 604
402 1137
402 1138
403 861
405 406
405 407
405 408
405 409
405 410
405 4500
406 407
406 1037
406 1038
406 1040
406 3643
407 1038
407 1039
407 1040
407 2515
407 3877
407 5069
407 5070
407 5071
408 1253
408 1755
408 3687
408 3978
408 3979
408 3980
408 3981
408 4590
409 454
409 1724
410 3755
411 412
411 413
411 414
411 415
411 416
411 417
411 418
411 832
411 1096
411 3062
411 3488
411 4018
412 414
412 4676
412 5769
413 800
413 2753
413 4876
414 1153
414 1349
414 1350
414 1351
414 1352
414 2924
415 1153
417 1688
417 4016
417 4018
418 2159
418 4018
419 420
421 827
422 423
422 701
422 702
422 703
422 704
422 705
422 2999
424 425
424 426
424 427
424 428
424 429
424 430
424 1932
424 2293
425 3533
426 427
426 428
426 1766
426 1767
426 1768
427 428
427 1609
427 3488
427 4014
427 5101
428 1768
428 3488
428 3533
429 3798
430 915
430 5101
430 5561
431 432
431 4226
432 3762
432 4226
433 985
433 1180
433 1212
434 597
434 3645
434 3646
435 436
435 437
435 1936
436 1070
436 1936
436 1939
436 3488
436 4059
437 1936
437 5016
439 1234
439 1679
439 2263
439 3412
440 441
440 6135
442 3553
443 535
444 4580
444 4583
445 446
445 447
445 448
445 449
445 450
445 451
445 452
445 453
446 954
446 3436
447 3371
447 3428
448 3624
448 3625
448 4036
448 4908
449 2296
452 2607
453 591
453 679
453 1106
453 1628
453 1688
453 1927
453 2344
453 2345
453 2607
453 3026
453 3224
453 3806
453 5490
453 5794
454 455
454 456
454 457
454 458
454 459
454 460
454 461
454 462
454 463
454 464
454 465
454 466
454 467
454 468
454 469
454 470
454 471
454 472
454 473
454 474
454 475
454 476
454 477
454 478
454 479
454 480
454 481
454 482
457 2054
459 3997
460 2531
462 542
465 1434
465 1649
465 1650
465 1651
465 1652
465 6577
469 4893
470 541
470 604
470 686
470 687
470 1173
470 1987
470 2440
470 2441
471 835
471 965
471 2291
471 4741
471 4949
472 1138
473 985
473 1955
475 3907
477 1138
478 1724
478 2213
479 1877
479 2483
480 4289
481 936
481 1248
483 484
483 485
483 486
483 487
483 488
483 489
483 490
483 491
483 492
483 493
483 4035
485 644
485 645
485 1424
485 2060
485 2061
485 2062
485 2063
486 487
486 488
486 489
486 2597
487 892
487 894
487 2452
487 2599
487 3622
487 4900
488 2105
488 2106
488 2107
488 2108
488 2110
488 2111
488 2112
488 2113
488 2114
488 5916
489 1036
489 2106
489 2597
490 2114
491 2112
491 2113
491 2114
492 2114
493 644
493 3546
493 3729
493 4001
493 4035
494 495
494 496
494 497
494 498
494 499
494 500
494 501
494 502
495 3798
495 4791
495 5579
496 587
496 1425
496 3211
496 7179
498 1331
498 3152
498 3205
498 3206
498 3207
498 3208
498 3209
500 1356
500 1489
503 504
503 681
503 826
503 4652
505 506
505 507
505 508
505 4015
506 915
506 1949
507 4015
507 5146
508 5690
509 3533
510 4984
511 512
511 513
511 514
511 515
511 516
511 517
511 518
511 519
512 1848
513 2516
513 5501
514 634
514 1619
515 1848
515 2030
515 2516
515 3112
516 1848
516 3112
520 521
520 522
520 4085
520 6529
524 2405
525 526
527 528
527 529
527 530
527 531
528 2555
529 1219
530 3572
531 1139
531 1299
531 1447
531 2520
531 2549
531 2555
531 2846
531 3572
531 3963
531 6647
531 7022
532 1611
533 534
533 681
533 3056
535 536
535 537
535 538
537 626
537 900
538 3075
539 2827
540 2228
540 4160
542 543
542 544
542 545
542 546
543 2041
543 2425
544 2425
545 980
547 1092
548 549
548 550
548 551
548 552
548 553
548 554
548 555
548 556
548 557
548 558
548 559
548 560
548 561
548 562
548 745
550 551
550 745
551 556
551 558
551 745
551 906
556 745
558 745
563 6075
564 695
564 696
564 697
564 5962
564 6849
565 6458
566 782
566 1096
566 3434
567 568
567 569
567 570
567 571
567 572
567 573
567 574
567 575
567 576
567 577
567 578
567 3228
568 1904
568 3228
569 575
570 681
570 985
570 1722
570 4135
570 5317
571 732
573 826
573 2816
574 1904
574 4906
575 1904
575 5507
578 1180
578 5125
579 672
580 581
580 582
580 583
580 584
580 585
580 586
580 1096
580 1376
581 1097
581 1126
581 1376
581 2178
581 3056
582 1376
582 2431
583 1376
584 1376
584 2413
584 2431
587 588
587 589
587 590
587 591
587 592
587 593
587 594
587 595
587 596
587 597
587 598
587 599
587 600
587 601
587 602
587 603
587 1425
587 3225
588 593
588 596
589 783
589 2200
589 5340
591 783
591 5340
593 595
593 596
593 597
593 1633
593 1843
593 2373
593 2374
593 2375
593 2376
595 597
595 1079
596 597
596 1310
596 1413
596 1414
597 651
597 905
597 1305
597 1371
597 1729
597 1730
597 1731
597 1986
597 2324
597 2325
597 2326
597 2327
600 735
600 813
600 1075
600 1076
600 1077
600 1078
600 1079
600 1080
600 1081
600 1082
600 1083
600 1084
600 1085
600 1086
600 1087
600 1088
600 1089
600 5016
600 6387
603 5772
604 605
604 606
604 607
604 608
604 2441
607 672
608 985
608 2213
609 4962
610 3270
610 4204
611 2362
611 5380
612 613
612 614
612 615
612 616
612 617
612 618
612 619
612 620
612 1931
612 2258
612 2531
613 1931
614 617
614 794
614 1918
614 3378
614 3379
614 3380
615 2937
617 875
617 876
617 1035
617 1126
617 1130
617 1180
617 1446
617 1769
617 1918
617 1999
617 2213
617 2214
617 2234
617 2587
617 2588
617 2589
617 2590
617 2591
617 2592
617 2593
617 2594
617 6980
618 619
618 935
618 2333
618 3460
619 928
619 2241
619 2242
620 6692
621 622
621 3454
622 2862
622 3748
622 5404
622 5405
622 5406
623 4217
624 6148
624 6149
625 626
625 627
625 628
626 897
626 900
626 1395
626 1587
626 2114
626 3608
626 4084
627 4121
628 4121
629 630
629 4876
631 3440
632 4570
633 863
633 864
633 866
633 1037
633 1325
633 4304
634 635
634 636
634 637
634 638
634 639
634 640
634 641
634 642
634 643
634 7002
639 642
639 1236
640 642
640 2228
640 2495
640 2531
640 2653
640 5561
641 5561
642 1223
642 1236
642 1339
642 1399
642 1400
642 1401
642 2329
642 2531
644 645
646 647
646 648
646 649
646 650
649 650
649 3788
649 3789
650 1385
650 1832
650 1909
652 653
652 654
652 655
652 656
652 657
652 658
652 659
652 660
654 655
656 660
657 3763
661 662
661 663
661 664
661 1268
661 1367
661 2555
662 1268
662 2553
662 3321
663 1444
663 2555
663 6674
664 3277
664 3527
665 827
665 1648
666 667
666 668
666 669
666 670
666 671
666 672
666 1180
666 3443
667 1071
668 3443
669 937
671 2606
671 3706
672 965
672 1111
672 1491
672 1492
672 1493
672 2333
673 4580
674 2267
675 676
676 4144
677 678
680 2531
681 682
681 683
681 684
681 685
681 686
681 687
681 688
681 689
681 690
681 691
681 692
681 5736
684 2041
685 1722
685 5317
689 1487
689 3056
690 4472
691 692
691 1923
691 2604
691 4472
692 2604
692 4472
693 694
695 1946
696 2037
696 2126
696 5157
698 699
698 2487
698 2488
698 5456
703 5691
703 6782
706 707
706 708
706 709
706 710
706 711
706 712
706 713
706 714
706 715
706 716
706 717
706 718
706 719
706 720
706 721
706 722
706 723
706 724
706 725
706 726
706 727
706 1234
706 1679
706 6569
707 708
707 1002
707 1008
707 1223
707 1234
707 1679
707 6569
708 1119
708 1679
711 1681
711 3516
721 806
721 1681
722 783
722 1069
722 1070
722 1180
722 1219
722 2178
722 4736
725 726
725 1425
725 1680
725 2420
725 4862
728 2531
728 3867
729 3581
730 915
731 1353
732 733
734 1546
736 737
736 738
736 739
736 740
736 741
737 740
737 741
737 2858
737 3346
737 3347
737 3348
738 740
739 740
739 6039
740 741
740 1687
740 1712
740 6405
741 2858
741 3346
741 3347
742 743
742 744
745 746
745 747
745 748
745 749
745 750
745 751
747 4091
752 753
752 754
753 754
753 1951
753 4065
754 1283
754 1951
754 2755
754 3631
754 4065
754 5154
754 6147
755 756
757 758
757 759
757 760
757 761
761 1947
761 2706
762 4195
764 765
764 766
764 2725
764 2728
764 3816
764 4597
765 2725
765 2728
765 3816
765 4597
767 1070
767 1690
767 2347
767 5529
768 769
768 770
768 771
768 772
768 773
770 6933
771 6940
772 5696
774 775
776 3553
777 778
779 780
779 781
780 781
780 799
780 800
780 2753
780 3855
781 800
781 2779
783 784
783 5340
784 986
784 988
784 1363
784 1372
784 3012
784 4109
784 5329
785 786
785 4833
787 788
787 789
787 790
788 1636
788 2445
789 2320
789 2321
791 1153
792 4197
793 794
793 795
794 1387
794 1918
796 906
797 1697
798 799
798 800
799 800
799 2753
799 2779
799 4580
800 2753
800 2777
800 2778
800 2779
800 4580
800 4876
801 802
801 803
801 804
801 805
802 6270
806 807
806 808
808 1681
809 810
809 811
809 3255
810 811
810 3247
810 3254
810 3255
810 3256
810 3257
810 4172
810 5949
810 5950
811 3244
811 3245
811 3246
811 3247
811 3248
811 3249
811 3250
811 3251
811 3252
811 3253
811 3254
811 3255
811 3256
811 3257
812 813
812 814
812 815
812 5010
813 3098
815 7233
816 3030
817 906
817 5926
817 5981
821 5548
822 1657
826 1219
826 1653
826 2816
826 4782
827 828
827 829
827 830
827 831
827 832
827 833
827 834
827 2531
832 1100
832 1213
832 1353
832 2655
832 4079
832 4080
832 4204
832 5024
833 922
834 5097
834 6692
835 965
836 837
836 2092
837 2092
839 840
839 841
839 842
839 843
839 870
839 2581
840 870
840 2581
842 870
844 4215
845 846
846 7056
847 6895
847 7117
848 849
848 850
848 851
849 4830
852 4623
854 855
854 856
857 1180
857 1353
857 2213
857 5317
858 3740
859 7122
860 6567
861 862
861 863
861 864
861 865
861 866
861 867
861 868
861 4304
863 864
863 865
863 866
863 868
863 1325
863 6279
864 865
864 866
864 868
864 1325
865 1320
866 1320
866 1321
866 1322
866 1323
866 1324
866 1325
867 5861
868 1325
869 5448
870 871
870 872
870 873
870 874
870 875
870 876
870 877
870 5033
871 2581
875 876
875 926
875 1304
875 1386
875 1542
875 1543
875 2145
875 2146
875 2147
876 6581
877 949
877 1896
877 2016
877 2367
877 3221
877 3588
877 5689
877 7251
878 1400
878 2412
879 3679
879 5121
880 3761
883 1010
883 1017
884 1353
884 2041
885 1846
885 4431
886 887
887 1877
888 889
888 890
888 891
889 890
889 2065
889 2066
889 2067
889 2068
889 2069
889 2070
889 2071
889 2072
889 2073
889 2074
889 2075
890 891
890 2371
890 2822
890 3222
890 3483
890 3484
890 3485
890 3486
890 3487
890 3581
890 4635
890 4864
890 5141
890 5563
890 6529
891 2370
891 3581
891 4431
892 893
892 894
892 895
892 896
895 2452
896 1995
896 2105
896 2108
896 2120
896 3756
896 5916
897 898
897 899
897 900
897 4134
900 1583
900 1584
900 1585
900 1586
900 1587
901 902
901 903
901 904
901 2084
902 903
902 904
903 904
903 2084
905 1980
905 3836
906 907
906 908
906 909
906 910
906 911
906 912
906 1314
906 1821
906 1822
907 908
907 2443
907 2445
907 3311
907 3313
908 3311
908 6957
911 1821
912 2872
913 4802
914 915
914 965
915 916
915 917
915 918
915 919
915 920
915 921
915 922
915 923
915 924
915 925
915 5274
919 5101
921 923
921 924
921 3051
922 923
922 2566
922 2567
922 6830
922 6831
923 1358
923 3213
926 1697
926 4700
927 2662
928 929
928 930
928 931
928 932
928 933
928 934
928 935
928 936
928 937
928 938
928 939
928 940
928 941
928 4085
929 930
930 931
930 932
930 2003
930 2662
930 2668
930 3422
930 3924
930 3925
930 5287
930 5630
931 1363
932 2662
934 2212
934 4085
935 1162
935 1941
935 2015
935 2332
935 2604
935 2605
935 3404
935 4113
936 4085
937 938
937 941
937 985
937 2410
937 2675
937 3399
937 4113
937 5092
939 1268
939 2413
942 972
942 1598
942 2602
942 4683
942 4690
943 944
943 945
943 6554
944 1653
944 1657
946 4690
947 948
947 949
947 3221
948 4430
948 5302
948 6559
948 6560
949 3221
949 3222
949 4012
949 4174
949 4924
949 6605
950 951
950 952
950 953
950 954
950 955
950 2662
951 3712
952 2662
954 1151
954 2423
954 3397
956 4590
957 6773
958 959
958 960
958 961
958 3169
959 1387
959 4465
962 963
962 964
962 3007
962 5633
963 4433
964 4433
965 966
965 967
965 968
965 969
965 970
965 971
965 972
965 2531
965 3098
966 2531
966 3098
966 4765
967 2401
972 1296
972 1297
973 2661
974 5215
974 5217
975 5380
976 977
976 978
976 979
976 980
976 981
977 1827
980 3928
980 5371
982 4443
983 984
983 985
985 1690
985 1691
985 1697
985 1698
985 1699
985 3919
985 4820
985 5203
985 5331
985 5332
985 5333
985 5334
985 5335
985 5336
985 5337
985 5338
985 5339
985 5340
985 5341
986 987
986 988
986 989
986 990
987 989
987 990
988 990
989 990
989 1729
989 3291
989 4284
989 4373
989 4736
989 6378
991 6458
992 993
992 994
992 995
995 1434
995 1435
996 997
996 998
996 999
1000 2531
1000 3098
1001 3539
1002 1003
1002 1004
1002 1005
1002 1006
1002 1007
1002 1008
1002 1009
1005 1006
1005 1008
1006 1007
1006 1009
1006 1820
1006 2526
1006 3292
1007 1009
1007 1820
1007 2488
1007 3292
1008 1820
1008 2526
1008 2527
1008 2529
1009 1472
1009 1481
1009 1820
1009 2526
1009 3223
1010 1011
1010 1012
1010 1013
1010 1014
1010 1015
1010 1016
1010 1017
1011 2958
1013 1014
1013 1495
1013 1496
1015 2956
1015 2958
1015 3156
1015 3234
1015 3567
1015 3897
1016 1022
1016 5174
1017 1021
1017 1022
1017 1120
1017 1121
1017 1122
1017 1123
1017 1124
1017 2555
1017 3321
1017 4855
1017 6654
1018 1512
1019 2041
1020 3440
1021 1022
1021 1023
1022 1023
1022 2527
1022 3187
1022 4849
1022 4850
1022 4851
1022 4852
1022 4853
1022 4854
1022 4855
1022 4856
1024 1025
1024 1026
1024 1027
1024 1028
1024 1029
1024 1030
1024 1031
1024 1032
1024 3540
1025 3540
1026 1947
1026 3540
1028 3540
1029 1423
1029 1427
1029 2141
1029 2142
1029 3750
1031 3607
1031 3702
1031 3750
1031 4182
1031 5252
1032 3540
1032 3546
1033 1126
1033 1487
1034 1035
1037 1038
1037 1039
1037 1040
1038 1039
1039 1040
1039 3771
1040 3771
1041 3143
1042 1043
1044 1054
1045 2610
1046 4561
1047 1048
1047 1049
1049 3679
1050 3546
1051 5340
1052 1053
1053 7023
1055 1353
1055 4015
1056 3706
1056 6453
1057 1058
1057 1059
1058 1769
1060 1061
1061 2449
1061 2499
1061 2591
1061 3024
1061 3695
1061 3843
1061 4273
1062 1063
1062 1064
1065 5091
1066 6286
1067 6286
1068 6887
1069 3759
1070 1806
1072 6774
1073 1791
1073 2289
1074 1434
1074 4057
1075 3930
1075 4556
1077 1079
1078 3371
1079 1473
1079 2049
1079 2375
1080 3371
1080 3712
1083 2131
1084 1679
1084 1681
1086 3156
1090 1932
1091 6288
1092 1093
1092 1094
1092 1095
1093 1095
1093 3652
1093 4545
1093 4993
1093 4994
1095 3529
1096 1097
1096 1098
1096 1099
1096 1100
1096 1101
1096 1102
1096 4016
1097 1379
1097 1520
1097 2397
1098 4016
1100 2655
1100 3062
1101 4115
1101 4741
1103 1138
1103 2553
1104 6777
1105 1106
1105 1107
1105 1108
1105 1109
1105 1110
1105 1111
1105 1112
1105 2017
1105 2263
1108 1223
1113 1716
1113 3020
1114 1180
1114 3510
1115 1116
1116 3930
1117 1234
1117 1679
1118 3030
1118 4706
1125 2212
1126 1127
1126 1128
1126 1129
1126 1130
1126 1131
1126 1132
1126 1133
1126 1134
1126 1135
1126 1136
1126 1479
1128 1133
1128 1479
1128 1565
1128 1635
1128 1666
1128 1667
1128 1668
1128 1669
1128 1670
1129 1212
1130 1133
1130 1479
1130 2589
1132 3672
1133 1444
1133 1445
1133 1448
1133 2587
1133 2589
1133 3798
1134 1487
1134 4545
1136 1831
1137 1138
1137 1139
1137 1140
1137 1141
1137 1142
1137 1143
1137 1144
1137 1145
1137 1146
1138 1310
1138 1425
1138 1758
1138 1955
1138 2010
1138 2011
1138 2012
1138 2013
1138 2014
1139 1140
1139 1299
1139 1888
1139 2520
1139 2846
1139 3853
1139 6647
1140 1498
1140 3853
1141 1964
1141 3853
1141 4446
1143 1838
1144 4459
1144 6263
1147 1697
1148 1781
1148 2284
1148 3490
1149 1180
1149 3800
1149 4082
1150 5238
1151 1153
1151 2774
1151 3895
1153 1154
1153 1155
1153 1156
1153 1157
1153 1158
1153 1159
1153 1160
1154 1223
1155 6270
1156 1415
1156 4116
1158 1223
1159 1960
1161 3089
1163 1487
1164 1165
1164 1166
1168 5309
1169 1170
1169 1223
1169 6930
1172 1653
1173 1653
1173 2441
1173 7200
1180 1199
1180 1200
1180 1201
1180 1202
1180 1203
1180 1204
1180 1205
1180 1206
1180 1207
1180 1208
1180 1209
1180 1210
1180 1211
1180 1212
1180 1213
1180 1214
1180 1215
1180 1216
1180 1217
1180 1218
1180 1219
1180 1220
1180 1221
1180 1353
1180 1846
1180 4415
1181 4590
1182 1201
1182 1660
1182 3733
1182 4590
1184 1188
1184 1919
1184 1925
1184 4227
1185 1188
1185 1280
1185 1281
1185 2402
1185 3148
1186 1188
1186 1925
1186 3148
1187 1188
1188 1595
1188 2402
1188 3148
1188 3396
1188 3397
1188 3398
1188 6861
1193 6820
1194 2210
1194 4191
1194 5329
1194 5330
1196 1197
1198 4961
1198 5834
1199 4503
1199 5168
1200 1722
1200 2095
1200 2096
1201 1202
1201 2547
1201 2747
1201 2748
1201 2749
1201 2750
1201 2751
1201 2752
1201 2753
1201 2754
1201 2755
1201 2756
1201 2757
1201 2758
1201 2759
1201 4415
1201 5125
1202 2771
1202 2773
1202 4415
1202 4416
1202 5922
1203 5125
1204 1205
1204 3155
1209 6569
1210 3507
1210 4155
1210 4156
1210 6387
1211 2937
1211 5016
1212 1353
1212 1948
1212 1949
1213 3574
1213 5024
1214 4379
1214 5785
1219 1420
1219 1423
1219 1475
1219 1911
1219 2161
1219 2162
1219 2163
1219 2164
1219 2165
1219 2166
1219 2167
1219 2168
1219 2169
1221 1845
1221 1846
1221 2415
1221 2416
1221 2417
1221 2418
1221 2419
1221 5163
1221 6057
1222 2662
1223 1224
1223 1225
1223 1226
1223 1227
1223 1228
1223 1229
1223 1230
1223 1231
1223 1232
1223 1233
1223 1234
1223 1235
1223 1236
1223 1237
1223 1238
1223 2306
1223 2307
1226 1227
1229 1997
1230 1231
1230 2306
1230 2307
1230 3897
1230 5189
1231 2306
1231 2307
1231 5189
1231 5198
1232 5189
1232 5198
1233 1904
1233 2103
1234 1391
1234 1679
1234 1680
1234 2170
1234 3318
1234 3616
1234 4005
1234 4006
1234 4007
1234 4008
1234 4009
1234 4010
1236 1401
1236 2160
1236 2531
1237 1619
1237 1932
1243 6700
1244 2126
1244 2200
1244 3732
1244 3836
1245 4144
1246 1247
1246 2495
1246 2499
1246 2650
1246 2653
1246 4113
1246 4443
1247 2495
1247 4113
1248 1249
1248 1250
1249 1250
1249 4906
1251 4042
1252 6373
1253 1254
1253 1255
1253 1256
1253 2213
1256 3433
1257 1258
1259 1791
1260 1558
1260 3056
1260 3156
1261 3156
1262 4963
1263 1932
1264 1265
1264 1266
1264 3527
1265 1724
1265 1980
1265 3527
1265 6429
1266 3527
1266 6429
1267 3156
1268 1269
1268 1270
1268 1271
1268 1272
1268 1273
1268 1274
1268 1275
1268 1276
1268 1277
1270 2457
1270 2808
1270 4527
1273 6573
1273 6574
1273 6575
1278 3440
1279 3581
1279 5154
1280 1281
1280 1282
1280 1283
1280 1284
1283 1925
1283 6861
1285 2196
1286 1287
1286 1288
1286 1289
1287 1359
1289 1359
1290 1828
1291 1292
1291 1293
1291 1294
1291 2650
1291 6706
1293 1877
1293 2483
1293 3156
1293 3317
1294 2054
1294 2845
1295 2265
1297 4040
1298 1299
1298 2798
1298 5000
1298 6647
1299 2477
1299 2521
1299 2846
1299 2848
1299 3963
1299 6647
1299 6674
1300 6127
1300 6129
1300 6130
1301 1302
1303 2356
1304 1487
1304 2108
1304 3732
1304 4766
1305 1306
1305 1307
1308 2919
1309 5194
1310 1980
1310 3689
1311 1312
1311 6748
1312 4716
1313 2041
1314 1315
1314 1316
1314 1317
1314 1821
1319 4431
1321 1322
1321 2568
1321 3419
1322 2569
1322 3419
1322 3698
1325 1701
1325 3600
1325 4304
1326 4804
1327 6289
1328 5181
1329 1330
1329 1331
1330 6129
1331 1862
1332 3498
1333 4135
1334 2127
1334 5274
1335 3054
1335 4015
1336 1413
1336 1980
1336 4777
1336 5404
1337 6366
1338 4831
1339 2531
1340 3156
1342 1464
1342 2108
1343 3156
1343 5189
1344 3344
1345 1346
1345 7117
1346 1544
1346 5329
1346 7117
1347 3379
1348 1896
1348 2016
1348 5689
1348 7251
1353 1354
1353 1355
1353 1356
1353 1660
1353 3588
1353 4015
1355 4862
1356 1489
1357 1358
1357 1359
1358 1359
1360 1361
1361 3192
1361 3193
1361 3194
1362 1997
1362 4195
1362 4197
1362 7186
1363 1364
1363 1365
1363 1366
1363 1367
1363 1368
1363 1369
1363 1370
1363 1371
1363 1372
1363 1373
1363 4109
1363 4476
1365 1367
1366 4063
1366 4476
1367 1368
1367 1720
1367 3649
1367 3650
1367 4476
1368 1720
1369 4476
1370 4476
1374 3798
1375 3490
1376 1377
1376 1378
1376 1379
1376 1447
1379 3488
1380 1381
1380 1382
1380 1383
1380 1384
1380 1385
1380 3287
1380 3600
1380 3601
1381 1383
1381 1384
1381 1842
1381 2956
1381 2957
1381 2958
1381 2959
1381 3600
1381 3963
1382 4188
1383 4144
1384 3287
1384 3600
1385 3458
1385 3540
1385 3601
1386 1387
1387 1574
1387 2753
1387 2917
1387 3669
1388 1389
1388 1390
1388 1391
1388 1392
1388 1393
1388 1394
1391 2260
1391 2263
1391 4051
1392 2054
1393 2058
1393 2818
1394 2054
1394 2058
1394 4493
1395 4464
1396 1397
1396 1398
1397 1398
1397 1569
1397 3459
1398 3459
1400 2053
1400 2258
1400 2329
1400 2331
1400 2411
1400 2412
1400 2413
1401 2531
1402 1403
1402 1404
1402 1405
1402 1406
1402 1407
1402 1408
1402 1409
1402 1410
1402 1411
1402 1412
1402 7243
1404 7243
1413 1763
1413 1764
1413 1980
1413 5595
1417 1418
1419 1758
1421 1422
1423 1424
1423 1425
1423 1426
1423 1427
1423 1428
1423 3018
1425 1426
1425 1797
1425 2013
1425 2014
1425 2235
1425 2373
1425 2420
1425 2984
1425 3225
1425 3748
1425 3914
1426 1883
1426 3471
1426 4656
1426 4755
1427 2141
1427 2142
1427 3813
1429 1430
1429 1431
1429 1432
1429 1433
1429 2655
1429 4135
1430 1431
1430 1432
1430 1433
1431 1433
1434 1435
1434 1436
1437 1438
1437 1439
1438 2362
1440 2414
1440 3490
1441 1442
1442 1443
1444 1445
1444 1446
1444 1447
1444 1448
1444 1449
1444 1450
1444 1451
1444 1452
1444 2589
1445 2589
1445 4160
1445 4274
1445 4741
1446 1447
1446 2589
1446 2591
1446 3585
1446 4703
1447 2322
1447 2555
1447 2587
1447 2589
1447 2593
1447 2751
1447 3585
1447 3586
1447 3587
1447 3588
1447 3589
1447 3590
1447 3854
1447 4160
1447 6674
1448 2589
1451 2555
1453 2126
1453 2960
1453 4766
1453 7154
1454 1455
1454 1456
1457 1994
1458 1781
1459 3930
1460 1461
1460 1462
1460 4741
1461 1462
1462 2524
1462 4741
1463 1464
1463 1465
1463 1466
1463 2258
1465 1466
1466 2051
1466 2052
1466 2053
1467 5549
1470 2367
1470 3929
1470 4431
1472 3292
1474 2460
1474 4015
1474 4032
1475 1481
1475 1507
1477 3948
1478 1660
1478 1694
1481 2714
1481 3292
1481 7156
1483 1900
1483 2064
1483 2519
1483 2527
1483 2837
1483 2859
1483 2860
1483 2861
1483 2862
1483 2863
1483 2864
1483 2865
1483 2866
1483 2867
1483 2868
1483 2869
1483 3510
1485 4178
1486 2214
1486 6980
1487 1488
1487 1489
1487 1490
1488 1956
1488 2108
1488 4113
1489 3211
1491 4145
1497 2956
1497 3234
1497 3599
1497 6165
1498 1499
1498 1500
1498 1501
1498 1502
1498 1503
1498 1504
1498 1505
1498 1506
1498 1507
1498 1997
1508 3761
1509 1510
1509 2807
1509 4642
1510 2807
1511 3112
1512 1513
1512 1514
1512 1515
1512 1516
1512 1517
1512 1518
1512 2238
1512 4487
1513 3750
1514 1897
1516 2238
1516 4487
1519 1520
1519 1521
1520 5106
1522 2653
1523 1524
1523 1525
1523 1526
1523 1527
1523 1528
1523 1529
1523 1530
1523 1531
1523 1532
1523 1533
1523 1534
1523 1535
1523 1536
1523 1537
1523 1538
1523 1539
1523 1540
1524 4446
1526 3299
1526 3300
1526 3301
1526 3302
1526 3303
1526 3304
1526 4446
1527 2431
1530 2431
1530 5106
1537 2671
1541 5016
1542 1543
1542 1544
1542 1545
1543 1544
1543 1545
1543 1872
1544 2447
1544 3569
1544 4260
1544 4284
1545 1736
1545 3002
1545 3026
1546 1547
1546 1548
1546 1549
1546 1550
1546 1551
1546 1552
1546 1553
1550 2260
1550 3074
1554 1674
1554 3856
1555 2454
1556 4015
1557 3608
1559 1704
1560 1561
1560 1562
1563 2808
1563 5954
1564 1565
1565 1795
1565 2260
1566 1932
1566 2258
1568 1569
1568 1570
1568 1571
1568 1572
1568 1573
1568 1574
1568 1575
1568 4801
1569 1570
1569 1571
1571 1575
1571 5586
1574 2089
1574 5586
1576 2974
1576 2975
1577 3585
1577 3706
1578 6440
1579 2674
1579 4085
1580 1581
1580 1582
1588 1869
1589 1590
1589 1591
1589 1592
1589 1593
1589 1594
1590 2645
1590 3770
1591 5796
1593 2513
1593 3094
1593 4244
1593 5056
1593 5273
1593 5480
1593 5865
1594 3093
1596 6500
1597 2798
1598 1599
1598 1600
1598 1601
1600 2388
1600 3930
1600 3976
1602 1603
1604 2424
1605 1606
1605 3988
1607 1608
1608 3972
1608 3973
1608 3974
1608 3975
1609 3533
1610 1917
1611 1612
1611 1613
1611 1614
1611 1615
1611 3081
1616 1617
1616 4797
1618 2260
1618 2261
1618 4797
1619 1620
1619 1621
1619 1622
1622 2054
1622 3228
1623 1624
1623 1625
1626 1627
1626 1628
1626 1629
1626 1630
1626 1631
1626 1632
1626 1633
1626 1634
1626 2041
1626 3590
1626 6340
1627 1633
1633 1634
1633 3836
1633 4447
1635 2725
1635 2728
1635 3816
1636 1637
1638 3258
1639 1640
1639 1641
1639 1642
1639 1643
1639 1644
1639 1645
1639 1646
1647 1648
1647 4556
1648 2313
1648 2921
1648 3111
1648 3214
1648 3470
1648 3707
1648 4257
1648 5351
1648 5841
1648 6635
1652 3955
1652 4057
1652 4058
1653 1654
1653 1655
1653 1656
1653 1657
1653 1658
1653 1659
1653 1660
1653 1661
1653 1662
1653 1663
1653 1664
1653 1665
1654 1781
1656 1657
1660 3588
1660 7143
1662 2531
1668 1877
1668 4018
1671 6054
1672 1673
1674 1675
1674 1676
1674 1677
1677 3856
1677 4134
1678 2388
1678 2394
1679 1680
1679 1681
1679 1682
1679 2263
1679 3071
1680 2263
1680 2958
1680 4755
1680 6458
1681 3907
1683 1684
1683 1685
1683 5805
1686 1687
1686 1970
1686 4284
1686 4373
1686 4460
1687 3088
1687 3668
1687 4260
1687 4284
1687 4360
1687 4373
1687 4374
1687 4460
1687 4964
1687 5585
1687 6405
1688 4016
1688 4018
1689 3488
1689 4741
1690 1691
1690 1692
1691 3317
1693 3127
1694 1695
1694 1696
1697 1698
1697 1699
1697 4289
1698 4015
1698 4032
1698 4289
1700 3555
1700 5032
1700 7315
1700 7325
1702 1703
1704 1705
1704 1706
1704 1707
1704 1708
1704 2390
1704 5189
1705 2390
1709 4000
1710 4828
1711 2332
1712 1713
1712 1714
1712 1715
1712 1716
1712 1717
1712 1718
1712 1719
1712 3488
1712 5371
1712 5477
1713 7233
1714 3617
1715 5106
1716 1717
1716 4142
1716 5477
1717 4949
1718 2531
1718 3992
1718 4016
1718 4949
1718 5106
1722 1727
1722 2733
1722 2821
1722 3403
1722 4220
1722 5293
1722 5294
1724 1885
1724 4802
1729 4373
1730 1731
1735 2531
1737 4015
1742 1744
1742 4421
1742 4802
1742 6429
1743 5106
1752 3259
1758 1759
1758 1760
1758 1761
1759 1761
1760 1761
1761 2199
1761 2941
1761 4396
1761 5614
1762 4706
1763 6340
1764 1980
1764 4777
1765 3690
1766 1768
1766 3390
1767 1768
1767 3390
1767 3488
1768 3901
1768 4181
1769 1770
1771 1772
1771 2563
1771 4195
1772 2563
1772 6409
1773 6567
1774 1775
1774 3798
1774 4750
1775 3798
1775 7173
1776 2285
1777 3056
1778 2460
1779 2690
1780 2260
1781 1782
1781 1783
1781 1784
1781 1785
1781 1786
1781 1787
1781 1788
1781 1789
1781 1790
1781 1791
1781 1792
1781 1793
1781 1794
1785 3503
1787 2284
1787 2292
1789 3490
1789 3621
1790 3503
1790 3997
1791 2144
1794 2017
1795 1796
1795 1797
1795 1798
1795 1799
1797 1888
1797 3630
1797 3917
1800 1801
1801 4208
1802 1803
1802 1804
1803 4583
1805 2674
1805 3837
1805 4716
1806 2038
1807 1808
1807 1809
1807 1810
1811 1812
1811 1813
1811 1814
1811 1815
1811 1816
1811 1817
1811 1818
1811 1819
1813 1817
1813 3191
1816 5696
1817 1819
1817 5533
1818 5061
1819 3426
1819 4811
1820 1972
1820 2526
1820 2557
1820 3292
1820 3293
1821 1822
1821 1823
1821 1824
1821 1825
1821 1826
1822 1823
1822 6796
1822 6797
1822 6798
1822 6799
1822 6800
1828 1829
1828 1830
1831 1832
1831 1833
1831 1834
1831 1835
1831 1836
1831 1837
1832 3081
1839 3844
1839 4690
1840 1841
1840 1842
1840 3600
1842 1904
1845 1846
1845 5163
1845 6057
1846 1996
1846 2417
1846 2419
1846 2603
1846 2612
1846 2613
1846 2614
1846 2615
1846 2616
1846 2617
1846 2618
1846 2619
1846 2620
1846 2621
1846 2622
1846 2623
1846 2624
1846 2625
1846 2626
1846 2627
1846 2628
1846 2629
1846 2630
1846 2631
1846 2632
1846 2633
1846 2634
1846 2635
1846 2636
1846 2637
1846 2638
1846 4513
1846 6057
1847 1997
1848 1849
1848 1850
1848 1851
1848 1852
1848 1853
1848 1891
1848 3911
1849 1891
1850 1891
1850 2312
1853 3112
1854 1855
1854 1856
1854 1857
1855 5044
1855 5377
1855 5522
1856 7225
1856 7331
1858 1862
1858 1863
1858 1864
1858 1865
1858 3053
1858 3818
1858 4939
1858 5052
1858 5094
1859 3673
1859 7193
1860 1861
1862 1863
1862 1864
1862 1865
1862 1866
1862 1867
1862 1868
1862 1869
1862 3353
1863 1864
1865 3052
1866 3353
1866 5285
1867 3353
1870 4500
1871 2523
1872 1873
1872 1874
1875 2531
1876 1877
1876 1878
1876 1879
1876 1880
1876 1881
1876 2483
1876 4460
1877 1878
1877 2482
1877 2483
1877 2484
1878 1932
1878 2483
1886 3056
1886 3879
1886 4862
1887 4364
1887 4707
1887 4708
1887 4710
1889 3270
1890 1891
1890 1892
1891 1892
1891 1928
1891 3617
1893 1894
1895 2103
1896 2016
1896 2367
1897 1898
1897 1899
1900 7179
1901 1902
1901 1903
1901 1904
1901 1905
1901 1906
1901 1907
1901 3964
1901 3967
1901 3969
1902 3964
1902 3967
1902 3969
1903 3964
1903 3967
1903 3969
1904 2130
1904 2882
1904 2883
1904 2884
1904 2885
1904 2886
1904 2887
1904 2888
1904 2889
1904 2890
1904 2891
1904 2892
1904 2893
1904 2894
1904 2895
1904 2896
1904 2897
1904 2898
1904 2899
1904 2900
1904 2901
1904 2902
1904 2903
1904 2904
1904 2905
1904 2906
1904 2907
1904 3964
1904 3967
1904 3969
1904 5115
1904 5575
1908 6503
1909 1989
1910 1932
1911 1912
1911 1913
1914 6422
1915 4061
1916 2126
1919 1926
1920 2696
1921 5598
1922 4741
1923 1924
1925 1926
1926 3559
1926 4809
1929 2332
1930 5000
1931 1932
1932 2257
1932 2258
1932 2259
1933 1934
1935 3795
1936 1937
1936 1938
1936 1939
1936 1940
1939 4059
1940 2937
1941 2332
1941 2333
1942 2571
1942 2574
1943 3224
1944 1945
1946 1947
1946 3476
1946 3902
1946 5447
1946 5496
1946 5592
1946 6366
1947 2377
1947 2378
1947 2379
1947 2380
1947 5380
1949 2881
1950 1951
1951 2981
1952 3219
1953 3353
1954 1955
1955 2193
1955 2600
1955 2601
1955 3176
1955 3177
1955 4569
1956 1957
1958 1959
1961 2053
1961 2329
1961 2413
1962 1963
1962 5404
1963 2558
1964 1965
1964 1966
1964 1967
1964 1968
1964 1969
1964 3259
1964 4446
1965 3259
1967 2388
1969 4446
1969 5156
1970 2450
1970 2452
1970 2599
1970 3709
1970 3888
1972 2301
1972 3292
1973 6162
1973 6814
1974 1975
1974 1976
1977 1978
1977 1979
1980 1981
1980 1982
1980 1983
1980 1984
1980 1985
1980 1986
1984 5414
1986 2361
1987 2289
1988 3510
1989 2258
1990 1991
1992 3800
1992 5357
1993 6776
1995 2108
1995 3447
1995 5916
1997 1998
1997 1999
1997 2000
1997 2001
1997 4195
1997 5629
1999 2480
1999 2520
1999 3586
1999 7186
2001 5629
2002 5786
2003 2662
2004 2041
2005 2372
2006 4002
2007 2008
2007 2009
2010 3469
2010 4200
2011 2213
2013 2526
2013 2529
2013 2988
2013 2989
2013 2990
2013 2991
2013 2992
2013 5093
2015 6054
2016 5689
2016 7251
2017 2018
2017 2019
2017 2020
2021 2022
2023 6127
2023 6129
2023 6130
2023 7077
2024 2214
2024 7179
2025 2026
2025 2027
2027 4977
2027 6444
2027 7287
2028 2029
2028 2030
2031 2032
2031 2033
2033 2089
2034 2035
2034 2036
2035 6440
2038 2039
2038 2040
2041 2042
2041 2043
2041 2044
2041 2045
2041 2046
2041 2047
2041 2048
2041 2049
2041 2050
2043 6289
2044 2144
2048 6340
2050 5163
2050 6057
2052 2531
2052 2539
2053 2258
2053 2331
2053 2412
2053 2413
2053 3114
2053 3115
2053 3116
2054 2055
2054 2056
2054 2057
2054 2058
2054 2059
2055 2916
2056 2058
2057 2058
2058 4545
2058 4643
2059 4366
2061 3960
2062 3334
2062 3960
2064 2115
2076 4113
2076 4114
2077 2078
2077 3761
2080 2081
2080 2082
2083 6512
2084 2085
2084 2086
2084 2087
2085 3015
2085 3228
2085 3540
2086 3228
2088 7179
2089 2090
2089 2091
2093 2094
2097 2098
2097 2099
2097 2100
2097 2101
2097 3510
2097 3632
2099 2101
2102 2103
2102 2104
2103 2104
2103 3335
2103 4179
2103 4180
2104 5272
2105 2106
2105 2107
2105 2108
2105 2109
2105 2115
2106 2452
2106 2922
2106 3829
2106 3836
2106 4862
2107 2108
2107 6820
2108 2111
2108 2143
2108 4158
2108 5170
2110 6820
2111 4482
2111 4921
2112 2113
2112 2114
2113 2114
2113 4164
2114 4164
2114 4259
2114 4755
2114 4921
2114 5318
2115 2116
2117 2118
2117 2119
2117 2120
2117 2121
2117 2122
2117 2123
2117 2124
2117 3682
2118 2381
2119 2120
2119 2122
2120 2123
2120 3623
2120 4494
2120 4495
2120 5916
2120 6488
2120 6820
2121 2122
2122 2269
2122 4771
2125 2412
2125 2558
2126 2127
2126 2128
2126 2129
2127 5274
2129 2189
2131 5817
2132 2133
2132 2440
2133 2440
2134 2135
2134 2136
2134 2137
2134 2138
2135 2136
2135 2137
2135 5755
2136 2137
2136 2138
2137 4514
2138 6000
2139 2140
2139 4115
2141 3813
2142 3813
2144 2289
2144 6289
2148 2149
2148 2150
2149 4621
2150 4621
2151 2152
2153 4446
2154 5353
2155 4431
2156 2157
2158 2159
2158 2531
2159 4018
2160 6379
2161 4748
2161 4749
2163 3075
2163 4015
2164 2755
2166 3546
2170 2974
2170 2975
2171 2172
2171 2173
2171 2174
2171 2175
2173 3098
2175 2604
2175 4949
2176 3400
2177 2798
2177 4801
2178 2179
2178 4736
2179 7252
2180 2531
2181 4906
2182 2183
2183 5933
2184 2185
2186 2924
2187 3287
2188 4655
2189 3440
2190 2191
2192 7288
2193 2194
2194 2213
2195 2196
2195 2197
2196 4636
2196 4637
2196 4638
2196 4639
2197 2442
2198 4984
2200 2201
2202 6572
2203 2206
2203 2753
2203 4465
2204 2960
2204 6153
2205 2604
2205 3027
2206 2207
2208 2209
2210 4976
2211 2212
2212 2531
2212 2537
2212 3846
2213 2214
2213 2215
2213 2216
2213 2217
2213 4015
2213 4474
2214 2218
2214 2219
2214 2220
2214 2221
2214 2222
2214 2223
2214 2224
2214 2225
2214 2226
2214 2227
2215 2531
2215 4518
2218 2653
2218 4015
2220 5314
2221 2223
2221 2862
2228 2229
2228 2230
2228 2231
2228 2232
2228 4160
2228 4162
2228 4831
2233 3454
2233 3457
2234 2364
2235 3761
2236 2251
2237 2238
2237 2239
2238 4288
2238 4356
2238 4958
2238 4959
2238 4960
2240 4651
2243 3829
2244 2958
2245 2246
2247 2248
2247 2249
2250 3760
2250 5156
2251 2252
2253 3997
2253 4145
2254 2255
2254 2256
2258 2412
2259 2531
2260 2261
2260 2262
2260 2263
2260 2264
2263 3318
2263 3661
2264 4672
2266 5248
2267 2268
2270 2271
2270 2272
2270 2273
2274 3283
2274 5020
2274 5198
2275 2276
2275 2277
2275 2278
2279 2280
2281 2282
2281 2283
2283 3605
2283 4306
2284 5668
2285 2286
2285 2287
2285 2288
2289 2290
2292 4291
2292 4490
2292 5011
2292 5668
2293 2294
2293 2295
2293 2296
2293 2297
2293 2298
2293 2299
2293 2300
2293 2301
2293 2302
2293 2303
2295 2301
2296 4915
2296 4922
2301 2420
2301 3442
2304 3540
2305 2602
2305 3490
2306 2307
2306 2308
2306 2309
2307 2308
2307 2309
2308 2309
2310 2311
2310 2312
2314 2315
2314 2316
2314 2317
2314 2318
2314 2319
2314 6120
2321 7092
2323 6910
2328 6075
2329 2330
2329 2331
2331 2413
2331 3625
2331 3629
2332 2333
2332 2334
2332 2335
2332 2336
2333 3702
2337 2338
2337 2339
2337 2340
2338 2339
2338 2340
2339 2340
2341 2796
2342 2343
2342 5438
2344 2345
2345 5794
2346 4704
2347 2348
2347 2349
2347 2350
2347 2351
2347 2352
2347 2353
2347 2354
2350 5831
2354 2531
2355 3776
2356 2357
2356 2358
2356 2359
2356 2360
2359 2360
2360 6822
2365 2366
2365 7018
2367 5689
2367 6038
2368 3498
2369 2370
2370 2371
2373 2984
2373 3748
2373 3914
2373 4347
2375 3829
2375 5376
2379 2704
2379 2731
2382 2383
2382 2384
2382 2385
2386 2387
2388 2389
2388 2390
2388 2391
2388 2392
2388 2393
2388 2394
2388 5317
2390 3037
2390 3038
2390 3039
2390 3040
2390 3041
2390 3042
2390 3043
2390 3044
2390 3045
2395 2396
2396 2500
2397 3488
2398 3490
2398 3493
2398 3494
2399 2975
2399 2996
2399 3618
2399 3621
2400 2401
2403 2404
2406 2407
2408 2531
2409 4344
2411 3843
2413 2432
2413 4949
2418 6057
2419 2613
2419 2776
2419 5163
2419 6057
2421 2422
2421 2423
2423 5954
2424 6333
2425 2426
2426 2945
2427 4876
2427 6453
2428 2429
2430 6133
2432 6573
2432 6574
2432 6575
2433 2434
2433 2435
2433 2436
2433 2437
2433 2438
2434 2437
2434 2644
2434 2645
2434 2646
2434 2647
2434 2648
2435 4763
2435 4764
2439 3081
2441 3693
2443 2444
2443 2445
2443 2446
2443 6957
2445 3096
2446 4815
2447 3800
2447 6895
2448 3443
2449 2450
2449 2451
2449 2452
2449 2922
2450 2452
2450 3829
2450 4583
2450 6820
2451 2452
2451 3829
2452 2597
2452 2598
2452 2599
2452 2923
2452 3839
2452 3888
2452 4275
2452 4530
2452 5912
2453 2555
2454 2455
2454 2456
2457 2458
2457 2808
2459 2460
2459 2495
2460 2495
2461 2462
2463 4431
2464 3477
2465 3352
2466 3960
2467 2468
2469 2470
2471 2472
2471 2473
2471 2474
2471 2475
2471 2476
2472 6096
2473 5943
2473 6096
2473 6124
2473 6301
2473 6960
2474 6096
2475 6096
2476 6096
2477 2478
2477 3963
2479 5752
2481 2531
2481 5101
2482 2494
2482 3210
2483 2484
2484 2704
2484 4115
2484 4802
2484 5911
2485 3027
2486 3733
2487 2488
2488 3070
2488 3324
2488 4060
2488 4253
2488 4254
2488 4255
2488 4256
2489 4261
2490 2491
2492 3317
2493 2494
2495 2496
2495 2497
2495 2498
2495 2499
2496 2499
2498 2653
2499 2592
2501 4203
2502 2503
2502 2504
2502 2505
2502 2506
2502 2507
2502 2508
2502 2509
2502 2510
2502 2511
2512 4594
2513 2514
2513 2515
2513 5480
2513 5677
2515 3249
2517 5981
2518 2862
2520 2549
2520 4152
2520 4153
2521 3854
2521 6647
2522 3094
2524 4015
2525 4458
2526 2527
2526 2528
2526 2529
2526 2530
2526 3292
2527 2862
2527 7179
2528 2529
2528 3292
2528 3294
2529 2530
2530 2588
2531 2532
2531 2533
2531 2534
2531 2535
2531 2536
2531 2537
2531 2538
2531 2539
2531 2540
2531 2541
2531 2542
2531 2543
2531 2544
2531 2545
2533 3798
2535 7174
2536 2910
2536 3174
2539 3341
2539 4344
2539 4398
2539 4399
2541 3858
2541 5398
2543 4564
2543 4678
2543 4679
2548 3540
2549 2550
2549 2551
2549 2552
2549 2555
2549 3963
2549 5422
2549 6674
2550 2555
2550 3267
2553 2554
2553 2555
2553 2556
2555 3321
2558 2559
2558 2560
2558 2561
2558 2562
2558 5827
2561 3310
2563 2564
2563 4195
2564 7288
2565 6659
2566 5093
2570 5181
2571 2572
2571 2573
2571 2574
2571 2575
2571 2576
2571 2577
2574 2948
2574 3298
2574 6340
2577 3721
2578 2579
2578 2580
2579 2580
2581 2582
2581 2583
2581 2584
2581 2585
2581 2586
2587 2589
2587 3585
2588 4970
2589 3268
2589 4942
2590 3458
2590 4306
2590 6581
2592 2750
2594 2846
2594 3853
2595 2872
2596 4801
2597 2598
2597 2599
2597 3829
2597 3836
2597 3839
2597 4583
2599 3829
2599 6820
2601 3176
2604 2605
2607 2608
2607 2609
2610 2611
2613 6576
2620 6057
2639 2640
2641 2642
2641 2643
2643 3198
2643 3199
2643 3733
2643 4988
2643 5939
2643 6016
2644 2646
2644 2647
2644 5015
2648 6907
2649 4831
2650 2651
2650 2652
2650 2653
2650 2654
2651 4443
2652 2653
2652 3585
2653 2654
2653 3027
2653 3028
2653 3585
2653 6638
2653 6639
2654 3585
2655 2656
2655 2657
2655 2658
2655 2659
2655 2660
2655 3062
2655 4876
2658 3098
2659 3103
2662 2663
2662 2664
2662 2665
2662 2666
2662 2667
2662 2668
2662 2669
2670 4673
2672 2673
2674 2675
2674 2676
2674 2677
2674 2678
2674 2679
2676 4195
2678 2683
2679 4195
2680 2681
2680 2682
2683 3673
2684 3344
2685 2686
2685 2687
2685 2688
2685 2689
2685 2802
2685 4126
2686 7175
2687 2688
2687 2801
2687 2802
2687 2803
2687 2804
2687 2805
2687 2806
2687 4126
2688 2799
2688 2800
2688 2801
2688 2802
2688 4126
2690 2691
2690 2692
2690 2693
2690 2694
2692 2693
2692 3154
2695 2696
2695 2697
2696 2697
2696 3142
2696 3143
2698 5699
2700 4689
2701 4160
2702 2703
2704 2705
2706 2707
2708 2709
2708 2710
2708 2711
2708 2712
2708 5874
2710 2958
2710 6722
2713 5880
2714 2715
2714 2716
2714 2717
2714 2718
2714 2719
2715 2716
2715 2717
2715 2719
2715 2925
2715 2926
2715 2927
2715 2928
2715 2929
2715 2930
2715 2931
2715 2932
2715 2933
2715 2934
2715 2935
2715 2936
2715 5631
2715 5877
2715 5962
2715 6817
2715 7194
2720 2721
2720 2722
2720 2723
2724 5862
2725 2726
2725 2727
2725 2728
2725 2729
2726 2728
2726 3816
2727 2728
2727 3816
2728 3816
2729 3816
2732 3605
2733 2734
2733 2735
2733 2736
2733 2737
2734 2737
2738 2739
2738 2740
2741 2742
2741 2743
2741 2744
2742 2774
2742 7310
2745 2746
2750 2752
2750 5139
2752 3027
2753 2774
2753 2779
2753 2915
2753 2916
2753 2917
2753 2918
2753 4415
2753 6667
2753 7179
2755 3077
2755 3736
2761 5629
2762 2763
2762 2764
2762 2765
2762 2766
2762 2767
2762 2768
2762 2769
2763 2764
2763 2765
2763 2766
2763 2767
2763 2768
2763 2769
2763 5120
2763 6645
2763 7036
2764 2765
2764 2766
2764 2767
2764 2768
2764 2769
2765 2766
2765 2767
2765 2768
2765 2769
2765 4645
2765 4945
2766 2767
2766 2768
2766 2769
2767 2768
2767 2769
2768 2769
2768 5421
2768 6385
2768 6571
2770 2771
2770 2772
2770 2773
2770 2774
2770 2775
2771 2775
2772 2775
2773 2775
2774 2775
2774 3575
2774 3895
2774 5400
2775 3807
2779 4580
2780 3829
2781 2782
2781 2783
2781 2784
2781 2785
2785 5803
2786 2787
2786 2788
2786 2789
2789 4866
2790 3493
2791 6437
2791 6438
2792 4730
2793 4716
2794 2795
2796 2797
2798 2846
2800 2802
2800 7106
2801 2802
2802 4126
2807 4642
2808 2809
2808 2810
2808 2811
2808 2812
2808 2813
2812 3617
2814 2815
2816 2817
2819 2820
2823 2824
2823 6055
2825 4991
2826 2827
2828 2829
2828 2830
2828 5541
2831 5878
2832 5879
2833 2919
2834 2835
2836 2837
2837 5125
2838 2839
2838 2840
2841 2842
2842 2843
2842 2844
2846 2847
2846 2848
2846 2849
2850 3855
2851 6532
2852 2853
2852 3510
2853 3510
2853 4146
2853 4147
2853 4148
2854 2855
2856 3936
2857 3863
2862 2975
2862 3339
2862 7179
2863 3292
2863 3294
2863 3510
2870 7100
2871 4683
2872 2873
2872 2874
2872 2875
2872 2876
2872 2877
2874 5500
2875 5926
2876 5691
2876 5926
2878 2958
2878 3317
2879 2880
2908 2909
2910 2911
2910 2912
2910 3702
2911 6036
2913 4716
2914 6667
2915 3624
2916 5590
2919 2920
2919 5477
2922 2923
2922 4803
2923 3829
2926 7193
2932 5080
2937 2938
2937 2939
2937 2940
2937 5416
2940 5016
2941 3540
2942 2943
2944 3702
2946 4708
2947 4364
2948 3334
2949 2950
2950 6913
2951 2952
2951 2953
2951 2954
2951 2955
2953 5285
2953 6962
2956 3234
2956 3235
2956 3236
2956 4923
2956 6428
2956 7054
2957 6428
2958 3287
2958 3316
2958 3317
2958 3318
2958 3319
2958 4306
2961 2962
2963 2964
2963 2965
2963 2966
2967 2968
2967 2969
2968 2969
2970 2971
2970 2972
2973 3994
2973 4145
2974 2975
2974 2976
2974 2977
2975 2996
2975 2998
2975 3618
2975 3620
2975 5093
2975 7018
2978 4580
2979 4716
2979 7154
2980 2981
2982 5189
2983 3612
2984 3748
2984 3913
2984 3914
2985 3502
2986 4195
2987 3390
2987 3488
2993 6340
2994 2995
2996 2997
2996 2998
2997 3618
2997 4158
2998 3618
2998 3619
2999 3000
3001 3844
3003 3004
3003 3005
3003 3006
3003 3311
3003 3312
3003 3315
3003 4130
3004 3005
3004 3006
3004 3315
3005 3006
3005 3315
3005 4130
3005 5285
3006 3315
3006 4130
3007 3008
3007 3009
3007 3010
3007 3011
3007 3012
3007 3013
3008 5633
3013 5357
3014 3498
3014 5003
3015 3016
3015 3017
3015 3018
3015 3019
3016 3017
3016 3018
3016 3204
3016 4777
3018 3653
3018 3654
3018 4777
3020 3021
3022 6020
3023 6020
3025 4421
3026 3458
3027 3028
3027 3029
3031 3311
3032 6900
3033 3034
3033 3035
3033 3036
3041 6333
3041 6456
3046 3047
3046 3048
3046 3049
3046 4415
3046 6227
3046 6452
3046 7022
3050 5615
3050 5618
3052 3053
3054 3055
3055 4015
3056 3057
3056 3156
3058 3059
3060 3061
3062 3063
3062 3064
3062 3065
3066 3067
3066 3068
3069 3661
3071 3072
3071 3073
3075 3076
3075 3077
3075 3078
3075 3079
3075 3080
3081 3082
3081 3083
3081 3084
3081 3085
3081 3086
3081 3087
3086 4197
3089 3090
3092 3600
3093 3094
3093 3095
3093 3096
3093 3548
3094 4171
3094 4244
3094 4245
3094 4246
3094 4247
3094 4248
3094 4249
3094 4250
3095 5865
3096 5480
3096 5865
3097 3134
3098 3099
3098 3100
3098 3101
3098 3102
3098 3103
3098 3104
3098 3105
3098 3106
3098 3107
3098 3108
3102 3106
3102 6840
3103 3467
3105 3106
3106 4169
3106 4170
3108 6840
3109 3110
3112 3113
3117 3118
3117 3119
3120 3121
3120 3122
3123 3472
3124 3472
3125 3126
3128 6918
3129 3130
3129 3131
3129 3132
3133 5198
3134 3135
3134 3136
3134 3137
3134 6673
3135 3136
3135 3137
3138 3602
3140 3141
3143 4760
3144 3145
3144 3146
3144 3147
3146 5503
3146 6511
3149 3150
3149 3151
3153 3904
3153 4461
3156 3157
3156 3158
3156 3159
3156 3160
3156 3161
3156 3162
3158 6467
3161 4500
3163 3164
3163 3165
3163 3166
3164 3165
3164 3166
3164 3579
3164 4692
3165 3859
3166 4323
3167 3168
3169 3170
3169 3171
3169 3172
3169 3173
3175 3448
3176 3177
3176 4569
3177 3178
3179 5909
3180 3181
3180 3182
3183 3184
3183 3185
3186 3447
3187 3188
3187 3189
3187 3190
3187 4855
3188 5479
3195 3540
3196 3197
3196 3219
3198 3199
3198 3733
3199 4993
3199 4994
3200 3201
3202 6145
3203 3416
3207 3208
3212 7233
3215 3216
3215 3605
3216 3605
3217 4804
3218 4804
3219 3220
3221 3222
3223 3292
3226 3408
3227 3733
3228 3229
3228 3230
3228 3231
3232 3233
3234 3235
3234 3236
3234 3237
3234 3238
3234 3239
3235 6165
3235 6428
3236 4565
3236 6428
3239 4015
3239 7222
3240 3241
3240 3242
3240 3243
3241 4460
3246 3255
3247 5061
3248 3252
3248 3993
3249 3252
3249 5480
3254 3255
3255 3256
3255 3426
3259 3260
3259 3261
3259 3262
3259 3263
3259 3264
3265 4970
3266 4711
3266 4878
3269 3270
3270 3271
3270 4204
3272 4489
3273 4893
3274 4804
3275 3276
3276 5633
3277 3278
3279 3280
3281 5916
3282 3960
3283 3284
3283 3285
3283 5198
3284 3285
3284 5020
3285 5020
3286 5477
3287 3288
3287 3289
3287 3290
3287 3317
3291 3317
3291 4284
3292 3293
3292 3294
3295 3296
3297 4876
3299 7047
3305 3306
3305 3307
3305 3308
3305 3309
3307 5230
3311 3312
3311 3313
3311 3314
3311 3315
3311 7235
3312 3315
3312 3857
3312 6468
3313 6393
3313 7235
3315 4130
3315 5285
3320 5317
3321 3322
3321 3323
3325 3326
3325 3327
3325 3328
3325 3329
3325 3330
3325 3331
3325 3332
3325 3333
3329 3332
3330 3332
3331 3332
3332 3333
3332 4067
3332 4068
3332 4069
3332 4070
3332 4071
3332 4072
3333 5074
3336 3337
3338 5483
3340 5444
3342 3343
3344 3345
3344 4766
3346 5884
3349 3350
3351 6995
3353 3354
3355 3356
3355 3357
3355 3358
3355 3359
3355 3360
3355 3361
3355 3362
3355 3363
3358 3363
3362 3363
3363 3364
3363 3365
3363 3366
3363 3367
3363 3368
3363 3369
3363 3370
3371 3372
3371 3373
3371 3374
3371 3375
3371 3376
3372 5165
3373 4155
3374 3428
3377 4135
3380 4149
3380 4150
3380 4151
3381 3382
3381 3383
3384 3385
3384 3386
3384 3387
3384 3388
3384 3389
3386 3389
3386 4076
3386 4077
3386 4277
3386 4278
3390 3391
3390 3392
3390 3393
3390 3394
3390 3488
3393 3503
3395 4741
3398 3569
3400 3401
3400 4262
3402 5449
3402 6846
3405 3406
3406 7039
3407 4212
3409 3410
3411 3922
3411 4599
3412 3413
3414 3415
3416 3417
3416 3418
3417 4054
3417 4551
3420 6250
3421 6567
3425 3426
3427 3701
3427 4741
3427 6845
3428 3429
3428 3430
3428 3431
3428 3432
3434 3435
3437 3438
3439 3440
3439 4690
3440 3441
3440 4562
3440 5306
3440 5591
3443 3444
3443 3445
3443 3446
3449 3450
3449 3451
3449 3452
3454 3455
3454 3456
3454 3457
3458 3482
3458 4470
3461 3462
3461 3463
3464 3465
3464 3466
3468 4655
3469 3540
3473 3930
3474 3475
3474 3577
3475 3577
3475 4592
3477 3478
3479 3560
3480 3761
3483 3581
3483 3673
3488 3489
3490 3491
3490 3492
3490 3493
3490 3494
3490 3495
3493 3578
3494 3578
3494 3591
3494 3592
3494 3621
3496 3497
3498 3499
3498 3500
3501 3502
3502 3906
3502 3944
3502 4075
3502 5265
3502 5266
3502 5267
3502 5268
3503 3504
3503 3505
3503 3997
3503 6580
3506 7112
3507 4061
3508 3509
3510 3511
3510 3512
3510 3513
3510 3514
3510 3515
3510 4401
3510 7296
3514 3576
3516 3517
3516 3518
3516 3519
3518 3519
3520 3521
3520 3522
3520 3523
3520 3524
3525 3526
3527 4344
3528 3529
3528 3530
3528 3531
3529 4497
3532 6952
3534 4065
3535 3536
3535 3537
3537 3600
3538 3929
3539 4108
3540 3541
3540 3542
3540 3543
3540 3544
3540 3545
3540 3546
3540 3547
3546 3941
3546 4294
3546 4295
3548 3549
3548 3550
3548 6918
3549 4192
3551 3552
3554 4018
3556 3557
3556 3558
3559 3560
3560 3638
3560 4975
3561 3562
3563 3564
3563 3565
3566 4704
3567 3568
3568 3850
3568 6447
3569 3893
3570 3621
3572 3573
3573 4061
3580 4840
3581 3582
3582 3673
3582 4690
3582 5154
3582 5306
3583 4740
3583 5248
3584 5494
3586 5116
3586 5812
3588 4995
3590 3848
3593 3594
3593 3595
3593 3596
3593 3597
3593 6925
3597 7178
3598 3901
3600 3601
3602 3603
3602 3604
3605 3666
3606 5249
3608 3609
3608 3610
3608 3611
3609 3611
3613 3614
3615 3935
3616 4158
3616 4862
3616 7330
3618 3619
3618 3620
3618 3621
3619 3620
3621 3847
3621 3860
3621 4003
3621 4004
3622 4158
3624 3625
3624 3626
3624 3627
3624 3628
3624 3629
3624 5404
3624 6566
3625 3629
3625 3682
3625 4036
3628 3629
3629 3682
3629 4120
3629 6667
3632 4366
3633 3634
3635 4121
3636 5197
3637 4160
3639 4716
3640 3641
3640 3642
3641 3642
3641 4824
3642 4824
3642 5403
3644 5911
3645 3646
3645 3647
3646 3647
3649 3731
3649 4476
3650 6053
3651 3673
3652 4993
3652 4994
3656 3657
3656 3658
3656 3659
3657 3658
3660 4489
3661 3662
3663 5835
3664 3665
3667 3764
3668 4373
3670 3671
3670 4426
3671 4426
3673 3674
3673 3675
3673 3676
3673 3677
3676 5154
3676 6147
3676 7154
3678 4336
3680 3681
3682 4232
3683 3684
3683 3685
3686 5040
3687 3688
3687 4590
3690 3691
3690 3692
3694 3829
3696 4460
3697 3991
3698 6795
3699 3700
3701 6845
3702 3703
3703 6765
3704 3705
3708 4755
3709 5374
3710 6916
3711 5252
3712 3713
3714 6270
3715 5284
3716 3717
3718 7002
3719 3720
3722 4476
3723 3747
3723 4232
3724 4778
3725 4207
3725 4783
3726 3727
3728 4447
3729 4035
3730 5260
3733 3734
3735 5016
3737 4065
3738 5101
3739 4580
3740 3741
3740 3742
3742 5477
3743 5252
3743 6379
3743 7114
3744 3745
3744 3746
3748 3913
3748 3914
3749 4489
3750 3751
3750 3752
3750 3753
3754 4491
3756 3757
3757 3758
3762 4226
3764 3765
3764 3766
3764 3767
3764 3768
3765 5732
3766 4455
3769 7248
3769 7249
3771 3871
3771 3872
3771 3873
3771 3874
3771 3875
3771 3876
3771 3877
3771 3878
3772 3773
3774 4553
3775 4791
3777 3778
3777 3779
3780 3781
3780 3782
3781 3782
3781 3885
3782 3885
3783 3784
3783 3785
3783 3786
3783 3787
3784 3786
3786 3787
3786 5346
3788 6212
3790 3791
3790 3792
3790 3793
3790 3794
3790 3795
3790 3796
3790 3797
3791 3795
3793 3795
3794 3795
3795 4299
3796 5649
3798 3799
3798 7173
3799 4113
3800 3801
3800 3802
3800 3803
3802 4730
3804 3805
3805 4426
3805 5018
3808 3809
3810 3811
3811 3812
3814 4217
3815 4927
3817 3818
3817 3819
3817 3820
3817 3821
3817 3822
3818 5215
3818 5216
3818 5217
3820 5215
3820 5217
3823 3824
3825 3826
3825 3827
3825 3828
3829 3830
3829 3831
3829 3832
3829 3833
3829 3834
3829 3835
3829 3836
3829 3837
3829 3838
3829 3839
3830 4167
3834 6820
3836 3839
3837 4716
3839 4528
3839 4529
3839 4530
3840 3841
3842 4785
3843 3844
3843 3845
3844 3845
3844 4081
3844 4471
3845 4081
3845 4790
3847 4163
3850 3851
3850 3852
3850 5198
3851 5855
3853 3854
3854 3927
3854 4045
3854 4175
3854 4176
3854 4177
3854 4803
3860 4716
3861 4723
3861 4724
3862 6135
3864 3865
3864 3866
3865 3866
3866 4770
3867 3868
3867 3869
3867 3870
3872 4021
3873 4021
3873 6353
3873 6655
3879 3880
3879 3881
3879 3883
3879 5210
3879 6371
3880 3882
3880 3883
3884 3905
3884 3906
3884 6130
3884 6463
3886 6353
3886 6655
3887 4903
3889 6818
3890 3891
3894 4727
3895 3896
3897 4059
3898 3899
3900 3901
3902 4580
3903 3904
3905 3906
3905 6463
3908 3909
3910 4479
3911 3912
3913 4506
3914 4504
3914 4505
3915 3916
3918 3919
3918 3920
3921 6092
3921 6342
3922 3923
3924 3925
3926 5434
3928 5371
3929 3930
3929 3931
3929 3932
3929 3933
3929 4431
3930 3931
3930 3976
3930 4117
3930 4432
3931 6662
3934 4197
3937 3938
3937 3939
3942 6757
3943 4195
3943 4197
3945 3946
3945 3947
3947 4074
3947 5253
3949 3950
3949 3951
3953 3954
3953 4228
3953 4229
3953 4230
3953 4599
3954 4228
3954 4229
3954 4230
3955 4058
3956 4330
3957 3958
3957 3959
3960 3961
3961 5219
3962 4421
3964 3965
3964 3966
3964 3967
3964 3968
3964 3969
3964 3970
3964 3971
3965 3967
3965 3969
3966 3967
3966 3969
3967 3968
3967 3969
3967 3970
3967 3971
3968 3969
3969 3970
3969 3971
3973 6932
3977 7235
3978 4015
3981 6384
3982 3983
3983 5308
3984 3985
3986 5231
3987 7288
3989 3990
3994 3995
3994 3996
3997 3998
3997 3999
4001 4035
4005 5404
4005 6413
4005 6414
4005 6647
4011 5319
4011 6034
4013 4791
4014 4059
4015 4032
4016 4017
4016 4018
4017 5249
4018 4791
4018 4792
4018 5076
4018 5077
4019 4020
4022 7142
4033 4034
4036 4656
4037 4038
4037 4039
4040 4041
4042 4043
4044 5550
4046 4047
4048 5524
4049 4050
4052 4741
4052 6554
4053 4804
4055 4056
4057 4058
4062 4518
4064 4967
4065 4066
4070 4071
4071 4072
4071 6886
4073 5085
4074 4076
4076 4077
4076 4078
4080 6884
4082 4083
4085 4086
4085 4087
4088 4089
4088 4090
4089 4090
4092 4093
4092 4094
4092 4095
4092 4096
4092 4097
4092 4098
4094 6457
4098 4230
4099 4100
4099 4101
4099 4102
4099 4103
4104 5957
4105 4106
4105 4107
4109 4110
4109 4111
4109 4112
4112 4163
4113 4114
4115 4116
4118 5249
4120 6566
4121 4122
4123 4446
4124 4217
4125 6277
4126 4127
4126 4128
4126 4129
4126 4130
4126 4131
4126 4132
4126 4133
4128 6282
4134 4135
4134 4136
4134 4137
4138 4139
4138 4140
4141 5300
4143 5565
4157 4364
4158 4159
4160 4161
4160 4162
4163 4164
4163 4165
4166 6659
4167 5100
4168 7038
4172 5776
4173 5513
4182 5252
4183 4184
4185 4186
4187 4458
4188 4189
4190 4191
4192 4193
4192 4194
4195 4196
4195 4197
4195 4198
4195 4199
4197 4199
4197 5264
4201 5442
4202 4232
4202 6704
4204 4205
4204 4206
4205 4206
4207 4783
4209 4210
4209 4211
4213 4214
4213 4215
4215 4690
4215 4830
4216 7133
4218 4219
4218 6087
4218 6088
4218 6089
4219 6087
4219 6088
4219 6089
4220 4221
4222 4223
4224 4225
4228 4229
4228 4230
4228 4231
4229 4230
4230 4231
4230 4359
4232 4233
4234 4235
4234 4236
4234 4237
4234 4238
4234 4239
4237 4238
4240 4241
4242 5156
4244 6782
4251 4252
4257 5352
4258 5319
4262 4263
4262 4741
4264 4265
4264 4266
4264 4267
4264 4268
4266 4267
4266 4943
4266 4944
4267 4943
4267 4944
4267 5852
4269 4270
4269 6289
4270 6289
4271 4767
4272 4366
4273 4274
4276 4425
4278 4973
4278 6281
4279 4280
4279 4281
4280 4281
4282 4283
4284 4373
4285 4286
4288 4487
4290 6127
4290 6129
4290 6130
4292 4293
4296 4297
4298 4791
4300 4301
4302 4303
4303 4304
4303 6130
4304 4305
4304 6130
4306 4307
4308 6508
4309 4310
4309 4311
4309 4312
4309 4313
4310 4808
4310 5731
4314 4315
4314 4316
4314 4317
4318 4319
4318 4320
4319 4320
4321 6135
4322 4545
4324 7149
4325 4326
4325 4327
4325 4328
4325 4329
4326 4327
4326 4328
4326 4329
4327 4328
4328 4329
4330 4331
4330 4332
4330 4333
4330 4334
4334 5787
4335 5194
4337 4338
4339 4340
4339 4341
4340 4341
4342 6681
4342 6751
4342 6953
4343 4590
4344 4345
4344 4346
4348 4433
4348 6200
4349 6518
4350 5478
4351 4352
4351 4353
4351 4354
4351 4355
4356 4487
4357 6342
4358 5207
4358 5929
4360 4373
4360 6405
4361 4362
4363 4708
4364 4365
4364 5380
4364 5835
4366 4367
4368 5251
4369 4370
4371 4372
4372 4519
4372 4521
4373 4374
4373 4375
4374 6014
4376 4377
4378 4893
4380 5189
4380 5198
4381 4382
4381 4383
4381 4384
4385 4386
4387 4388
4387 4389
4387 4390
4388 6601
4391 6653
4392 5885
4393 4741
4394 5056
4394 6353
4394 6655
4395 5357
4397 5098
4397 5827
4400 7011
4402 5118
4403 6419
4404 4405
4404 4406
4405 4406
4405 6015
4406 6015
4407 7133
4408 4409
4410 4411
4410 4412
4411 4412
4413 4755
4415 4416
4415 4417
4415 4418
4415 4419
4415 4420
4416 7179
4418 6178
4421 4422
4421 4423
4424 7245
4427 4428
4429 4468
4429 4469
4433 4434
4433 4435
4433 4436
4433 4437
4433 4438
4433 4439
4433 4440
4433 4441
4442 6899
4444 4445
4445 6551
4447 4448
4449 4450
4449 4451
4449 4452
4449 4453
4449 5568
4449 5569
4450 4451
4450 5568
4451 5462
4451 5568
4451 5569
4454 6129
4455 4456
4456 6124
4457 6476
4458 4459
4460 6014
4461 4462
4461 4463
4466 6114
4467 6353
4467 6655
4468 4469
4469 5624
4472 4473
4474 4475
4476 4477
4476 4478
4476 4479
4477 4479
4477 5390
4477 5391
4478 4479
4480 4481
4480 6859
4483 5173
4484 4485
4484 4486
4484 4487
4487 4958
4487 4959
4487 4960
4488 4655
4490 5011
4490 6034
4491 4492
4498 4499
4499 5248
4501 4502
4507 6092
4508 4509
4510 6123
4511 4512
4511 7154
4515 5326
4516 4517
4519 4520
4519 4521
4522 7034
4523 4524
4525 4526
4530 6484
4530 6488
4531 4532
4533 4534
4535 4536
4537 4550
4538 7154
4541 5909
4542 4543
4544 4654
4544 4655
4546 4547
4546 4548
4548 5522
4548 6296
4549 4640
4549 6090
4552 6853
4557 6634
4558 4559
4560 4626
4563 6387
4564 4678
4565 4566
4565 4567
4568 6527
4571 4572
4571 4573
4574 4575
4574 4576
4575 4576
4577 4578
4578 4655
4579 4631
4580 4581
4580 4582
4580 4583
4580 4584
4580 4585
4580 4586
4580 4587
4580 4588
4580 4589
4580 4590
4583 4893
4588 5502
4590 4591
4592 4593
4594 4595
4596 5284
4597 4598
4599 4600
4599 4601
4599 4602
4599 4603
4599 4604
4599 4605
4599 4606
4599 4607
4599 4608
4599 4609
4599 4610
4599 4611
4599 4612
4602 4603
4613 4614
4613 4615
4613 4616
4613 4617
4613 4618
4613 4619
4613 4620
4613 4693
4614 4693
4615 4673
4615 4674
4615 4693
4622 6427
4624 4625
4627 4628
4628 7329
4629 4630
4629 4631
4629 4632
4629 4633
4629 6125
4631 4632
4631 4633
4631 5415
4632 6208
4634 5502
4641 4642
4644 4791
4644 4880
4645 4646
4646 5657
4647 4893
4648 4649
4650 6211
4652 4653
4654 4655
4657 6127
4657 6129
4657 6130
4658 6232
4659 4660
4661 7321
4662 4663
4664 4665
4664 4666
4664 5578
4664 6045
4665 4667
4665 5578
4666 6786
4668 6963
4669 4670
4671 5260
4673 4674
4673 4675
4673 4676
4673 4693
4674 4676
4674 5815
4674 5817
4677 6838
4678 4679
4678 4680
4678 4681
4678 4682
4684 4685
4684 4686
4684 4687
4684 7265
4685 4686
4685 4687
4685 4719
4685 7265
4686 4687
4687 7265
4688 5118
4690 4691
4691 5414
4694 4695
4696 4697
4696 4865
4698 4699
4701 4702
4702 6792
4705 5561
4705 5827
4705 6692
4707 4708
4707 4709
4707 4710
4708 4710
4712 4713
4714 4715
4716 4717
4718 5992
4720 4721
4720 4722
4723 4724
4725 4726
4725 5716
4728 4729
4729 4961
4729 5768
4731 4732
4731 4733
4731 4734
4735 4804
4736 4737
4736 4738
4736 4739
4736 4917
4736 5875
4738 5255
4738 5256
4738 5257
4741 4742
4741 4743
4744 6906
4745 4746
4745 4747
4750 4751
4752 7017
4753 4754
4756 6075
4757 4758
4759 4828
4761 4762
4763 4933
4763 6927
4768 5443
4768 5527
4769 5954
4772 4773
4772 4774
4772 5577
4772 6505
4773 4774
4773 5577
4773 6505
4774 5577
4775 4776
4775 5961
4776 5960
4776 5961
4778 4779
4780 7256
4781 4782
4784 4785
4784 4786
4785 4787
4785 4788
4785 4789
4785 5300
4789 5589
4791 4792
4793 5396
4794 5004
4795 5238
4796 5775
4798 5305
4799 4800
4800 5741
4804 4805
4804 4806
4807 5793
4810 4811
4810 4812
4810 5061
4813 7291
4814 5805
4815 4816
4815 4817
4815 4818
4815 4819
4817 5896
4821 6289
4822 4823
4826 7116
4827 7154
4829 6499
4831 4832
4833 4834
4833 4835
4833 4836
4833 4837
4838 4839
4839 5582
4841 4842
4841 4843
4841 4844
4841 4845
4841 4846
4841 4847
4841 4848
4844 4956
4847 4848
4857 4858
4858 4877
4858 5279
4858 5316
4859 4860
4861 6801
4862 4863
4867 4868
4873 6289
4874 6751
4875 6662
4878 4879
4880 4881
4880 4882
4880 6186
4883 4884
4883 4885
4883 4886
4883 4887
4883 4888
4889 4890
4891 5445
4892 5107
4893 4894
4893 4895
4893 4896
4893 4897
4893 4898
4895 7099
4896 7099
4899 5524
4901 4902
4904 4905
4906 4907
4909 4910
4911 4912
4913 4914
4915 4916
4915 4922
4918 4919
4925 6531
4926 5397
4927 4928
4927 4929
4927 4930
4931 4932
4934 5699
4935 5914
4935 6232
4936 6151
4937 5691
4937 6782
4938 7183
4939 5300
4940 5437
4941 7095
4946 4947
4946 4948
4949 4950
4951 4952
4953 7233
4954 4955
4956 4957
4965 4966
4968 4969
4970 4971
4972 4973
4973 6280
4974 5736
4978 4979
4980 5914
4981 5012
4982 4983
4985 4986
4988 4993
4988 4994
4988 6888
4989 5887
4990 5875
4991 4992
4991 5372
4992 5087
4992 5372
4996 4997
4998 4999
5000 5001
5000 5002
5005 5006
5005 5007
5005 5008
5009 5487
5009 5488
5011 5668
5012 5013
5012 5014
5016 5017
5019 5033
5021 5022
5021 5023
5024 5025
5024 5026
5024 5027
5024 5028
5024 5029
5024 5030
5024 5031
5029 6364
5033 5034
5033 5035
5033 5036
5033 5037
5038 5923
5038 6124
5039 5040
5042 6232
5043 5804
5044 5045
5044 6296
5045 5522
5045 5648
5045 5989
5045 6276
5045 7260
5046 5891
5047 6933
5047 6934
5048 5049
5050 6974
5051 5513
5053 5755
5054 6204
5055 7299
5057 6676
5058 5623
5059 5228
5059 5300
5059 5360
5059 5943
5059 6124
5060 5930
5061 5062
5061 5063
5064 5216
5065 5066
5067 5471
5068 5752
5072 6010
5073 5930
5073 6208
5074 5075
5075 5867
5077 5864
5078 5079
5081 5082
5083 5084
5085 5086
5089 5215
5089 5217
5090 6145
5094 5095
5095 6150
5096 5280
5097 5098
5097 5099
5098 5561
5098 5827
5101 5102
5101 5103
5101 5104
5105 5550
5108 5109
5110 5111
5112 5483
5113 6554
5114 6775
5117 5445
5118 5119
5118 5120
5118 6645
5120 6645
5121 5122
5123 5124
5126 5127
5126 7272
5128 5129
5128 5130
5128 5131
5128 5132
5128 5133
5128 5134
5128 5135
5128 5136
5128 5137
5128 5138
5129 5136
5129 5137
5130 5134
5131 5136
5131 5137
5134 5136
5134 5137
5135 5136
5135 5137
5136 5137
5136 5429
5136 5430
5136 5431
5136 7283
5136 7284
5137 5429
5137 5430
5137 5431
5140 6062
5142 5943
5143 6271
5144 6791
5145 5280
5147 5529
5148 5149
5150 5151
5152 5823
5153 5235
5155 6492
5157 5158
5159 6387
5160 6606
5161 6579
5162 6669
5164 6227
5165 5455
5166 5595
5167 5691
5167 5926
5169 6379
5171 5479
5172 6973
5175 5176
5177 5178
5177 5179
5177 5180
5178 5179
5178 5180
5179 5180
5182 5183
5184 5185
5184 5186
5187 7033
5188 6340
5189 5190
5189 5191
5189 5198
5189 5855
5192 6790
5193 6557
5194 5195
5196 6112
5197 6695
5198 5199
5198 5200
5198 5201
5198 5202
5200 6602
5200 6603
5200 7248
5200 7249
5204 5205
5204 5206
5207 5208
5207 5929
5208 5929
5208 6325
5209 6371
5211 6039
5212 5213
5212 5214
5215 5216
5215 5217
5215 5218
5216 5217
5217 5218
5220 5677
5221 5222
5223 5224
5223 5225
5223 5226
5223 5227
5228 5229
5230 5231
5231 5814
5232 5233
5232 5234
5235 5236
5235 5237
5239 5240
5241 5248
5242 5243
5242 5244
5245 5246
5245 5247
5249 5250
5258 5259
5260 5261
5260 5262
5260 5263
5269 5270
5269 5271
5274 5275
5276 5277
5278 6829
5280 5281
5280 5282
5283 5579
5285 5286
5285 6962
5285 7203
5288 5289
5290 6703
5291 6208
5292 6208
5295 5845
5295 6562
5296 5775
5297 5298
5299 6000
5301 6058
5303 7201
5304 7273
5307 6621
5307 7139
5309 5310
5311 5312
5311 5313
5315 6383
5316 6896
5319 6034
5320 5321
5322 5787
5322 5796
5322 6929
5322 6952
5323 5778
5324 7098
5325 6958
5327 5328
5339 5340
5340 5873
5342 7055
5343 6769
5344 5345
5347 5348
5349 5350
5354 5355
5354 5356
5357 5358
5357 6210
5360 5361
5360 5362
5360 6248
5361 6248
5363 5471
5364 5365
5365 6021
5366 6578
5367 6448
5368 6197
5369 5370
5373 7309
5375 5376
5378 5662
5379 7098
5380 5381
5380 5382
5380 5383
5380 5384
5385 5386
5385 5387
5385 5388
5385 5389
5392 5393
5392 5394
5392 5399
5394 5736
5395 5699
5401 5402
5404 7198
5407 5408
5409 5987
5410 5411
5410 5412
5413 6208
5415 5437
5416 5417
5416 5418
5416 5419
5416 5420
5421 5802
5421 5862
5421 6385
5423 6340
5424 5425
5424 5697
5424 5698
5425 5697
5425 5698
5426 5427
5426 5428
5432 5433
5435 5988
5436 6733
5439 5835
5440 5441
5443 5897
5446 5583
5450 5451
5452 5453
5452 5454
5456 5457
5456 5458
5456 5459
5456 5460
5456 5461
5462 5568
5462 5569
5463 6670
5464 6670
5465 5466
5466 6845
5467 5533
5468 5469
5468 5470
5469 5470
5471 5472
5471 5473
5474 5475
5476 6768
5481 5482
5483 5484
5483 5485
5483 5486
5487 5488
5487 5489
5491 5563
5492 5493
5495 5751
5495 6508
5496 5497
5496 5498
5496 5499
5503 5504
5505 5506
5508 5509
5508 6812
5509 6812
5509 6813
5510 6250
5511 5512
5514 5515
5514 5516
5517 6324
5518 6124
5519 5520
5521 6296
5523 6670
5525 5526
5527 5528
5527 5897
5529 5530
5529 5531
5529 5532
5533 5534
5535 5536
5535 5537
5535 5538
5535 5539
5535 5540
5535 5541
5536 5541
5537 5541
5538 5541
5539 5541
5540 5541
5541 5542
5543 6087
5543 6088
5543 6089
5543 6447
5544 5545
5546 5868
5547 5548
5550 5551
5550 5552
5550 5553
5553 5622
5554 5555
5554 6907
5556 5823
5557 6296
5558 6301
5558 6960
5559 5560
5562 6910
5564 6279
5566 5567
5568 5569
5569 5574
5570 5571
5570 5572
5570 5573
5575 5576
5580 5581
5584 5892
5586 5587
5586 5588
5586 6012
5586 6274
5593 5752
5594 6296
5596 5597
5599 6303
5600 5601
5602 6067
5603 6535
5604 5849
5605 5606
5605 5607
5606 5607
5608 5609
5608 5610
5608 5611
5608 5612
5611 6502
5613 5626
5615 5616
5615 5617
5615 5618
5615 5619
5616 5618
5617 5618
5618 5619
5620 5621
5622 5623
5625 6223
5627 6645
5628 7248
5628 7249
5631 5632
5633 5634
5633 5635
5633 5636
5637 5638
5637 5639
5640 5641
5642 5643
5644 5645
5644 5646
5644 5647
5648 6296
5649 5650
5649 5651
5652 6204
5653 5654
5655 5656
5657 5658
5659 5660
5659 6184
5660 6184
5661 6770
5663 5664
5663 5665
5663 5666
5663 5667
5668 5669
5670 5699
5671 6199
5672 6958
5673 6127
5673 6129
5673 6130
5674 6771
5675 5676
5678 5679
5678 5680
5681 5682
5683 5684
5683 5685
5683 5686
5683 5687
5683 5688
5689 5871
5691 5692
5691 5693
5691 5926
5694 5695
5697 5698
5699 5700
5699 5701
5699 5702
5699 5703
5699 5704
5705 5706
5707 6415
5708 6652
5709 5710
5711 5712
5713 5714
5713 5715
5714 5715
5717 5718
5719 5720
5721 5722
5723 7090
5724 5725
5726 5727
5726 5728
5726 5729
5726 5730
5727 5728
5727 5729
5730 7335
5733 6877
5734 5735
5736 5737
5736 5738
5739 5740
5742 5743
5744 6561
5745 5987
5746 5787
5747 7040
5747 7041
5748 6963
5749 7000
5750 7301
5752 5753
5752 5754
5752 5755
5754 5755
5755 5913
5756 6206
5757 6651
5758 5759
5760 5936
5761 5762
5762 5763
5764 5765
5764 5766
5764 5767
5770 5771
5773 5774
5777 6248
5779 5780
5779 5781
5780 5781
5782 5783
5782 5784
5783 5784
5787 5788
5787 5789
5787 5790
5787 5791
5787 5792
5794 5795
5796 5797
5796 5798
5796 5799
5798 5904
5798 6929
5800 6009
5801 6091
5802 5862
5806 5807
5808 5809
5810 5811
5813 7097
5815 5816
5815 5817
5818 5819
5818 5820
5818 5821
5819 5820
5819 5821
5820 5821
5822 6405
5823 5824
5823 5825
5823 5826
5828 5829
5828 5933
5829 5933
5830 6232
5832 5833
5836 5837
5838 5880
5839 5840
5842 5843
5842 5844
5845 7193
5846 5858
5847 5848
5850 5851
5853 5854
5855 5856
5859 5860
5862 5863
5865 5866
5867 5868
5868 7250
5869 5870
5872 6829
5875 5876
5876 6426
5876 6519
5876 6740
5876 6741
5876 6742
5876 7096
5880 5881
5882 5883
5886 5887
5886 5888
5887 6402
5889 5890
5889 6066
5891 5892
5893 6227
5894 5895
5898 6216
5899 6944
5900 5901
5900 5902
5900 6554
5903 7186
5904 5905
5904 5906
5907 5908
5910 7148
5914 5915
5917 5918
5919 6938
5920 6199
5921 6427
5923 5924
5923 5925
5927 5928
5930 5931
5930 5932
5934 6420
5935 6711
5936 5937
5936 5938
5937 7301
5940 5941
5942 6991
5943 5944
5945 5946
5947 5948
5951 7117
5952 6493
5953 5954
5955 6553
5956 6383
5957 5958
5957 5959
5963 5964
5965 5966
5967 5968
5969 7037
5970 6910
5971 5972
5973 5974
5975 5976
5977 5978
5979 6897
5980 6068
5981 5982
5983 5984
5985 5986
5989 6296
5990 6212
5991 6296
5993 6087
5993 6088
5993 6089
5994 5995
5994 5996
5997 5998
5998 6032
5998 6033
5999 6897
6000 6001
6002 6003
6004 6839
6005 6006
6005 6007
6008 6031
6009 6010
6011 6928
6012 6013
6017 6018
6017 6019
6022 6153
6023 6751
6024 6025
6026 6027
6028 6079
6029 6030
6034 6035
6036 6037
6038 7251
6040 6041
6040 6042
6043 6044
6043 6045
6045 6786
6046 6047
6048 6049
6050 6051
6052 6087
6052 6088
6052 6089
6055 6056
6058 6059
6060 6061
6063 6064
6065 6621
6069 6070
6071 6116
6072 6073
6072 6074
6075 6076
6075 6077
6078 7154
6079 6080
6081 6082
6083 6203
6084 7151
6085 7273
6086 6802
6087 6088
6087 6089
6088 6089
6089 7193
6092 6093
6094 6095
6096 6097
6098 7093
6099 6964
6100 6101
6100 6102
6100 6103
6104 6105
6104 6106
6104 6107
6104 6108
6105 6106
6105 6107
6106 6107
6106 6108
6107 6108
6109 6207
6110 7201
6111 6375
6113 6296
6115 7150
6117 6118
6119 7105
6120 6121
6122 6341
6125 6126
6127 6128
6127 6129
6127 6130
6127 6131
6128 6436
6129 6130
6129 6131
6129 6132
6130 6131
6133 6134
6135 6136
6135 6137
6135 6138
6135 6139
6140 6141
6140 6142
6140 6143
6140 6144
6145 6146
6152 6458
6153 6154
6155 6156
6157 7085
6158 7164
6159 6669
6160 6161
6163 7185
6164 6705
6164 6914
6165 6166
6167 6168
6169 6170
6171 6172
6173 6174
6174 6444
6174 7287
6175 6176
6177 6941
6179 6180
6179 6181
6179 6182
6179 6183
6185 6224
6187 6188
6188 6189
6190 6191
6192 6977
6193 6296
6194 6396
6195 6918
6196 6227
6198 6940
6201 6202
6205 6206
6208 6209
6213 6214
6215 7149
6216 6217
6218 6219
6220 7003
6221 6959
6222 6312
6224 6225
6226 6428
6227 7022
6228 6229
6230 6231
6233 6234
6233 6235
6234 6781
6236 6237
6237 6885
6238 6948
6238 6949
6238 6950
6239 6985
6240 6947
6241 6242
6241 6243
6244 6245
6246 6247
6249 7040
6249 7041
6251 6252
6251 6253
6251 6254
6255 6256
6255 6257
6255 6258
6259 6260
6259 6261
6259 6262
6264 6383
6265 6266
6267 6995
6268 6269
6272 6273
6273 7320
6275 6822
6278 7301
6283 6284
6283 6285
6287 6289
6290 6789
6291 7163
6292 7037
6293 6960
6294 6789
6295 6942
6296 6297
6296 6298
6299 6300
6302 6346
6304 6305
6304 6306
6308 7175
6309 6310
6309 6311
6309 6933
6309 6934
6310 6311
6310 7048
6313 6962
6314 6315
6316 6902
6317 6318
6319 6320
6319 6321
6319 6322
6319 6323
6319 6395
6319 6396
6320 6321
6320 6322
6320 6323
6320 6395
6320 6396
6321 6322
6321 6323
6321 6395
6321 6396
6321 6441
6321 6442
6321 6443
6323 6396
6326 7155
6327 7068
6328 6329
6328 6330
6331 6332
6332 6903
6334 7094
6335 6959
6336 6946
6337 6735
6338 6339
6343 6344
6345 6901
6347 6348
6349 6350
6351 6352
6353 6354
6353 6355
6354 6655
6355 6655
6356 6357
6357 7065
6358 6359
6360 6361
6362 6363
6365 6901
6367 6368
6369 6370
6371 6372
6374 7038
6376 6978
6377 6944
6379 6380
6381 6789
6382 6937
6385 6386
6387 6388
6387 6389
6387 6390
6387 6391
6387 6392
6393 6394
6395 6396
6395 6397
6396 6441
6396 7134
6396 7135
6396 7136
6396 7137
6396 7138
6398 7233
6399 6400
6403 6404
6406 6407
6406 6408
6406 7018
6409 6410
6411 6412
6416 6417
6418 6852
6420 6421
6422 6423
6424 6425
6429 6430
6429 6431
6432 6433
6434 6435
6437 6438
6439 6772
6444 6602
6444 6603
6444 7248
6444 7249
6445 6446
6449 6450
6449 6451
6450 6451
6453 6454
6455 6646
6458 6459
6458 6460
6461 6462
6463 6464
6465 6466
6468 6469
6470 6471
6472 6473
6472 6474
6472 6475
6473 6474
6474 6475
6476 6477
6476 6478
6476 6479
6476 6480
6476 6481
6476 6990
6477 6478
6478 6990
6482 6483
6484 6485
6484 6486
6484 6487
6484 6488
6484 6489
6484 6490
6485 6488
6486 6488
6487 6488
6491 6896
6494 6495
6494 6496
6497 6498
6501 7267
6501 7268
6503 6504
6506 6507
6509 6510
6512 6513
6514 6519
6515 6516
6516 6754
6517 6518
6518 6723
6519 6520
6519 6521
6519 6522
6523 6524
6525 6526
6525 6527
6527 6528
6529 6530
6533 6534
6536 6537
6536 6538
6536 6539
6540 6541
6542 6543
6544 6545
6544 6546
6544 6547
6545 6547
6546 6547
6548 6787
6548 6788
6548 7036
6549 6550
6554 6555
6554 6556
6558 6942
6559 6560
6563 6564
6565 7193
6567 6568
6570 7095
6573 6574
6573 6575
6574 6575
6582 6583
6584 6585
6584 6586
6587 6588
6589 6590
6591 6592
6593 6594
6593 6595
6596 6597
6598 6599
6598 6600
6602 6603
6603 6604
6607 6608
6609 6954
6610 6611
6610 6612
6610 6613
6610 6614
6610 6615
6610 6616
6612 6613
6612 6614
6613 6614
6613 6734
6617 6618
6617 6619
6620 6812
6620 6813
6621 6622
6621 6623
6624 7255
6625 6626
6625 6627
6625 6628
6625 6629
6625 6630
6625 6631
6632 6633
6636 6637
6640 6641
6640 6642
6643 6644
6647 6648
6649 6650
6656 6657
6656 6658
6659 6660
6659 6661
6662 6663
6664 6665
6664 6666
6664 6667
6664 6668
6665 6666
6665 6667
6665 6668
6666 6667
6666 6668
6667 6668
6671 6951
6672 6951
6675 6676
6676 6677
6679 6680
6682 6683
6684 7114
6685 6686
6687 6688
6687 6689
6690 6691
6693 6930
6694 6821
6695 6696
6695 6697
6698 7244
6699 7019
6699 7020
6699 7021
6701 6702
6705 6914
6707 6708
6709 6710
6712 6713
6712 6714
6714 6752
6715 6716
6715 6717
6715 6718
6715 6719
6715 6720
6715 6721
6724 6725
6724 6726
6727 6728
6729 6730
6731 6732
6735 6736
6735 6737
6738 6739
6741 7096
6743 6744
6745 6746
6747 6748
6749 6750
6752 6753
6755 6756
6758 6759
6758 6760
6761 6762
6763 7000
6763 7001
6764 7099
6766 6767
6778 6779
6780 6781
6782 6783
6784 6785
6787 6788
6787 7036
6793 6794
6803 6804
6805 6806
6806 6807
6808 6809
6810 6811
6812 6813
6815 6816
6819 7180
6823 6824
6825 6826
6827 6828
6830 6831
6832 6834
6833 6835
6836 6837
6841 6842
6843 6844
6847 6848
6850 7028
6851 7090
6854 6855
6854 6856
6857 6858
6859 6860
6862 6863
6862 6864
6862 6865
6862 6866
6862 6867
6862 6868
6862 6869
6862 6870
6862 6871
6862 6872
6862 6873
6862 6874
6862 6875
6862 6876
6878 6879
6878 6880
6878 6881
6878 6882
6878 6883
6879 6883
6880 6882
6880 6883
6881 6882
6889 6890
6889 6891
6892 6893
6892 6894
6897 6898
6903 6904
6903 6905
6908 6909
6911 6912
6915 7033
6917 6918
6918 7199
6919 7033
6920 6921
6922 6923
6924 7192
6926 6979
6930 6931
6933 6934
6935 6936
6939 6968
6942 6943
6945 7192
6948 6949
6948 6950
6948 6976
6949 6950
6949 6976
6955 6956
6960 6961
6965 6966
6965 6967
6969 6970
6971 7201
6972 7030
6975 7078
6981 6982
6983 6984
6983 6985
6986 6987
6986 6988
6986 6989
6991 6992
6993 6994
6996 6997
6998 6999
7000 7001
7004 7005
7006 7007
7008 7009
7008 7010
7012 7013
7014 7015
7016 7081
7019 7020
7024 7025
7026 7027
7028 7029
7031 7032
7034 7035
7040 7041
7042 7043
7044 7045
7046 7111
7049 7050
7051 7052
7051 7053
7052 7053
7057 7058
7059 7060
7059 7061
7060 7061
7062 7063
7062 7064
7066 7067
7069 7070
7069 7071
7072 7073
7074 7144
7075 7093
7076 7082
7079 7080
7083 7084
7086 7087
7088 7089
7091 7092
7101 7102
7103 7104
7107 7108
7112 7113
7114 7115
7118 7119
7118 7120
7121 7257
7122 7123
7124 7125
7126 7127
7128 7129
7130 7131
7130 7132
7131 7132
7140 7141
7145 7273
7146 7147
7152 7153
7157 7158
7159 7160
7161 7162
7165 7166
7167 7168
7169 7170
7171 7172
7176 7177
7181 7318
7182 7203
7183 7184
7187 7188
7187 7189
7188 7190
7188 7191
7189 7190
7195 7196
7201 7202
7204 7205
7206 7207
7208 7209
7210 7211
7212 7213
7214 7215
7216 7217
7218 7219
7220 7221
7223 7224
7224 7269
7224 7293
7224 7319
7226 7227
7228 7229
7230 7231
7230 7232
7233 7234
7235 7236
7237 7238
7239 7240
7240 7328
7241 7242
7246 7247
7248 7249
7253 7254
7258 7259
7261 7262
7263 7264
7266 7267
7266 7268
7267 7268
7270 7271
7273 7274
7275 7276
7275 7277
7276 7277
7278 7279
7279 7280
7281 7282
7283 7284
7285 7286
7289 7290
7294 7295
7297 7298
7302 7303
7304 7305
7304 7306
7307 7308
7310 7311
7313 7314
7316 7317
7321 7322
7323 7324
7326 7327
7332 7333
7332 7334
7335 7336
7335 7337
7335 7338
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tests/unit/zero_allocs.c0000644000175100001710000000176500000000000024464 0ustar00runnerdocker00000000000000/*
   IGraph library.
   Copyright (C) 2021  The igraph development team 

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see .
*/

#include 
#include "test_utilities.inc"

int main() {
    int *a = IGRAPH_CALLOC(0, int);

    IGRAPH_ASSERT(a);

    a = IGRAPH_REALLOC(a, 0, int);

    IGRAPH_ASSERT(a);

    IGRAPH_FREE(a);

    IGRAPH_ASSERT(!a);

    VERIFY_FINALLY_STACK();
    return 0;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/tools/0000755000175100001710000000000000000000000021012 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/arpack-sed.txt0000644000175100001710000000422600000000000023571 0ustar00runnerdocker00000000000000s/dsaupd_/igraphdsaupd_/g
s/dseupd_/igraphdseupd_/g
s/dsaup2_/igraphdsaup2_/g
s/dstats_/igraphdstats_/g
s/dsesrt_/igraphdsesrt_/g
s/dsortr_/igraphdsortr_/g
s/dgetv0_/igraphdgetv0_/g
s/dsaitr_/igraphdsaitr_/g
s/dsapps_/igraphdsapps_/g
s/dsconv_/igraphdsconv_/g
s/dseigt_/igraphdseigt_/g
s/dsgets_/igraphdsgets_/g
s/dstqrb_/igraphdstqrb_/g
s/dmout_/igraphdmout_/g
s/ivout_/igraphivout_/g
s/second_/igraphsecond_/g
s/dvout_/igraphdvout_/g

s/dlarnv_/igraphdlarnv_/g
s/dlascl_/igraphdlascl_/g
s/dlartg_/igraphdlartg_/g
s/dlaset_/igraphdlaset_/g
s/dlaev2_/igraphdlaev2_/g
s/dlasr_/igraphdlasr_/g
s/dlasrt_/igraphdlasrt_/g
s/dgeqr2_/igraphdgeqr2_/g
s/dlacpy_/igraphdlacpy_/g
s/dorm2r_/igraphdorm2r_/g
s/dsteqr_/igraphdsteqr_/g
s/dlanst_/igraphdlanst_/g
s/dlapy2_/igraphdlapy2_/g
s/dlamch_/igraphdlamch_/g
s/dlaruv_/igraphdlaruv_/g
s/dlarfg_/igraphdlarfg_/g
s/dlarf_/igraphdlarf_/g
s/dlae2_/igraphdlae2_/g
s/dlassq_/igraphdlassq_/g
s/dlamc1_/igraphdlamc1_/g
s/dlamc2_/igraphdlamc2_/g
s/dlamc3_/igraphdlamc3_/g
s/dlamc4_/igraphdlamc4_/g
s/dlamc5_/igraphdlamc5_/g
s/xerbla_/igraphxerbla_/g

s/daxpy_/igraphdaxpy_/g
s/dger_/igraphdger_/g
s/dcopy_/igraphdcopy_/g
s/dscal_/igraphdscal_/g
s/dswap_/igraphdswap_/g
s/dgemv_/igraphdgemv_/g
s/ddot_/igraphddot_/g
s/dnrm2_/igraphdnrm2_/g
s/lsame_/igraphlsame_/g

s/d_sign/igraphd_sign/g
s/etime_/igraphetime_/g
s/pow_dd/igraphpow_dd/g
s/pow_di/igraphpow_di/g
s/s_cmp/igraphs_cmp/g
s/s_copy/igraphs_copy/g

s/dnaitr/igraphdnaitr/g
s/dnapps/igraphdnapps/g
s/dnaup2/igraphdnaup2/g
s/dnaupd/igraphdnaupd/g
s/dnconv/igraphdnconv/g
s/dlabad/igraphdlabad/g
s/dlanhs/igraphdlanhs/g
s/dsortc/igraphdsortc/g
s/dneigh/igraphdneigh/g
s/dngets/igraphdngets/g
s/dstatn/igraphdstatn/g
s/dtrevc/igraphdtrevc/g
s/dlaqrb/igraphdlaqrb/g
s/d_lg10/igraphd_lg10/g
s/dlanv2/igraphdlanv2/g
s/drot/igraphdrot/g
s/idamax/igraphidamax/g
s/dlaln2/igraphdlaln2/g
s/dladiv/igraphdladiv/g
s/dneupd/igraphdneupd/g
s/dtrmm/igraphdtrmm/g
s/dtrsen/igraphdtrsen/g
s/dlahqr/igraphdlahqr/g
s/dlacon/igraphdlacon/g
s/dtrsyl/igraphdtrsyl/g
s/dtrexc/igraphdtrexc/g
s/dlange/igraphdlange/g
s/dlaexc/igraphdlaexc/g
s/dlasy2/igraphdlasy2/g
s/dasum/igraphdasum/g
s/i_dnnt/igraphi_dnnt/g
s/dlarfx/igraphdlarfx/g
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/bump_version.sh0000755000175100001710000000372100000000000024064 0ustar00runnerdocker00000000000000#!/bin/sh
#
# Script that should be run whenever we bump the version number of
# igraph.
#
# This script adjusts the version numbers in the following files:
#
#   - configure.in
#   - interfaces/java/build.xml
#   - interfaces/R/configure.in
#   - examples/simple/gml.out
#   - examples/simple/cattributes2.out
#   - msvc/igraphtest/igraphtest.vcproj
#   - tools/launchpad_nightly.recipe
#   - debian/changelog

set -e
set -u

if [ $# -lt 1 ]; then
	echo "Usage: $0 version"
	exit 1
fi

VERSION="$1"

# Step to the root of the source tree
cd `dirname $0`/..

# Adjust configure.in
sed -e "s/AC_INIT(igraph, [^,]*,/AC_INIT(igraph, ${VERSION},/" \
	-e "s/AM_INIT_AUTOMAKE(igraph, [^)]*)/AM_INIT_AUTOMAKE(igraph, ${VERSION})/" \
	-i configure.in

# Adjust interfaces/java/build.xml
sed -e "s/property name=\"package\.version\" value=\"[^\"]*\"/property name=\"package.version\" value=\"${VERSION}\"/" \
	-i interfaces/java/build.xml

# Adjust interfaces/R/configure.in
sed -e "s/AC_INIT(igraph, [^,]*,/AC_INIT(igraph, ${VERSION},/" \
	-i configure.in

# Adjust examples/simple/gml.out
sed -e "s/igraph version [^ ]*/igraph version ${VERSION}/" \
	-i examples/simple/gml.out

# Adjust examples/simple/cattributes2.out
sed -e "s/igraph version [^ ]*/igraph version ${VERSION}/" \
	-i examples/simple/cattributes2.out

# Adjust msvc/igraphtest/igraphtest.vcproj
sed -e "s/igraph-[^-]*-msvc/igraph-${VERSION}-msvc/g" \
	-i msvc/igraphtest/igraphtest.vcproj

# Adjust tools/launchpad_nightly.recipe
sed -e "s/deb-version [^~]*/deb-version ${VERSION}/" \
	-e "s|lp:igraph/[^-]*-main|lp:igraph/${VERSION}-main|" \
	-i tools/launchpad_nightly.recipe

# Adjust debian/changelog
DATE="`date -R`"
cat >debian/changelog.new <  ${DATE}

EOF
cat debian/changelog >>debian/changelog.new
mv debian/changelog.new debian/changelog

# Done.
echo "Successfully bumped version number to ${VERSION}."
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/tools/isoclasses/0000755000175100001710000000000000000000000023162 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/isoclasses/isoclasses.m0000644000175100001710000000462500000000000025517 0ustar00runnerdocker00000000000000(* ::Package:: *)

(* ::Text:: *)
(*This Mathematica code is used to generate the "isoclass" lookup tables in the source file isoclasses.c. It is meant to be opened with the Mathematica front end and used as a notebook. However, it is written in plain-text "package" format in order to work well with version control, and to be readable without Mathematica.*)


(* ::Subsubsection:: *)
(*Load IGraph/M*)


Needs["IGraphM`"]


(* ::Subsubsection:: *)
(*Helper functions*)


vec2matD[n_][vec_] := Transpose@MapIndexed[Insert[#1, 0, #2]&, Partition[vec, n-1]]


vec2matUtri[n_][vec_] := PadRight[TakeList[vec, Range[n] - 1], {n, n}]


vec2matU[n_][vec_] :=
  With[{mat=vec2matUtri[n][vec]},
    mat + Transpose[mat]
  ]


(* ::Subsubsection:: *)
(*Directed idx table*)


idxD[n_] := Flatten@vec2matD[n][2^(Range[n (n - 1)] - 1)]


(* ::Subsubsection:: *)
(*Undirected idx table*)


idxU[n_] := Flatten@vec2matU[n][2^(Range[n (n - 1) / 2] - 1)]


(* ::Subsubsection:: *)
(*Directed lookup tables*)


(* ::Text:: *)
(*TODO*)


(* ::Subsubsection:: *)
(*Undirected lookup tables*)


(* ::Text:: *)
(*Vertex count:*)


n = 6;


(* ::Text:: *)
(*How many distinct elements does the adjacency matrix have?*)


k = n (n - 1) / 2


(* ::Subsubsubsection:: *)
(*classedges*)


classedges = 
  Module[{mat = vec2matUtri[n][Range[k]], pos},
    pos = Position[mat, _?Positive];
    KeySort@AssociationThread[Extract[mat,pos],pos]
  ] // Values // Flatten;

classedges = Reverse[classedges];


classedges - 1 (* 'classedges' array with 0-based indexing *)


(* ::Subsubsubsection:: *)
(*graphs*)


(* ::Text:: *)
(*Generate the "codes" of all labelled graphs on n vertices.*)


codes = Reverse /@ IntegerDigits[Range[2^k] - 1, 2, k];


graphCodes=
  DeleteDuplicatesBy[
    codes,
    IGBlissCanonicalGraph@*AdjacencyGraph@*vec2matU[n]
  ];


(* 'graphs' array: *)
graphCodesAsInts = FromDigits[#, 2]& /@ Reverse /@ graphCodes


graphs = IGBlissCanonicalGraph @* AdjacencyGraph @* vec2matU[n] /@ graphCodes;


(* 0-based indexes of non-weakly-connected graphs, needed for motif code: *)
Flatten@Position[graphs,g_/;Not@ConnectedGraphQ[g],{1},Heads->False]-1


(* ::Subsubsubsection:: *)
(*lookup table*)


asc = AssociationThread[
  Normal /@ AdjacencyMatrix /@ graphs,
  Range@Length[graphs]
];


lookup = asc @* Normal @* AdjacencyMatrix @* IGBlissCanonicalGraph @* AdjacencyGraph @* vec2matU[n] /@ codes;


(* 'isoclass2' array with 0-based indexing: *)
lookup - 1
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/tools/lapack/0000755000175100001710000000000000000000000022245 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/CompletePolish0000755000175100001710000000217700000000000025131 0ustar00runnerdocker00000000000000#!/bin/sh -
# call this Unix script "MagicScript"
# To use: MagicScript *.f
#	  that translates *.f to *.c and polish the resulting C code from f2c.
#
# Note: define trans_dir as the directory that contains this file.
#
# trans_dir=/home/barad-dur/jwd/users/mercedes-tmp/LAPACK_v2.0/LAPACK_Final_Release2.0/NEW_CLAPACK/CLAPACK/Translate

rm -f -r temp
mkdir temp
for file do
       base=`echo $file | sed -e 's/\.f//g'`
   # run_stripper
       f2c -a < ${base}.f | ${trans_dir}/lenscrub > ${base}.c
   # run_macro (better vector and array indexing; from NAG)
#   	${trans_dir}/substitute_locals.exe < ${base}.c > ${base}.u
#  	${trans_dir}/test_tool.exe ${base}.u > ${base}.c
#   	rm -f ${base}.u
   # run_comment
       sed -f ${trans_dir}/delete.sed ${base}.c > ${base}.t
       mv -f ${base}.t ${base}.c
       ${trans_dir}/comment < ${base}.c > ${base}.t
       mv -f ${base}.t ${base}.c
   # run_splitter
#       sed -n -f ${trans_dir}/split.sed ${base}.c
#       mv -f ${base}.c ${base}.t
#       cat temp/header1 temp/header3 temp/comment temp/header2 temp/prologue \
#       		temp/code > ${base}.c
#       rm -f ${base}.t
done
rm -f -r temp
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/Makefile0000644000175100001710000000045300000000000023707 0ustar00runnerdocker00000000000000LOADLIBS = -ly -lfl -lm
LIBS = -lfl -lm
CFLAGS	= -O

all: lenscrub comment

lenscrub: lenscrub.l
	lex lenscrub.l
	mv -f lex.yy.c lex_for_lenscrub.c
	cc -o lenscrub -O lex_for_lenscrub.c -ll

comment: comment.l
	lex comment.l
	mv -f lex.yy.c lex_for_comment.c
	cc -o comment -O lex_for_comment.c -ll
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/comment.l0000644000175100001710000000052000000000000024061 0ustar00runnerdocker00000000000000%{
#include 

/* extern FILE *commentFile, *localVarFile, *codeFile; */

%}

whitespace [\n\t ]*
any	   .*

%%
"*/"{whitespace}"/*"         {yytext[0]=yytext[1]=yytext[yyleng-1]=yytext[yyleng-2]=' ';printf("%s",yytext);}
"\n"                         {printf("%s", yytext);}
.                            {printf("%s", yytext);}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/delete.sed0000644000175100001710000000011700000000000024203 0ustar00runnerdocker00000000000000# delete the line of the form .. Scalar arguments ..
/\/\*  *\.\. .*\*\//{
d
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/tools/lapack/extra/0000755000175100001710000000000000000000000023370 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/extra/len_trim.f0000644000175100001710000000041600000000000025351 0ustar00runnerdocker00000000000000*
*  -- LEN_TRIM is Fortran 95, so we use a replacement here
*
      FUNCTION LEN_TRIM(S)
*
      CHARACTER*(*)  S
      INTEGER LEN_TRIM
*
      INTRINSIC LEN
*
      DO LEN_TRIM = LEN(S), 1, -1
         IF (s(LEN_TRIM:LEN_TRIM) .NE. ' ') RETURN
      END DO
      END
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/getlapack.sh0000755000175100001710000001152300000000000024541 0ustar00runnerdocker00000000000000#! /bin/sh
#
# ./getlapack.sh dgeev dsyevr dnaupd dneupd dsaupd dseupd dgemv dgeevx \
#                dgetrf dgetrs dgesv dlapy2 dpotrf dsyrk dtrsv
#

BLAS_VERSION=3.8.0
LAPACK_VERSION=3.5.0

# We can't go any further than LAPACK 3.5.0 because LAPACK 3.6.0 starts using
# recursive functions, which is a Fortran 90 construct and f2c can translate
# Fortran 77 only.

make

origdir=`pwd`
destdir=lapack-new

cd /tmp
rm -rf $destdir
mkdir $destdir

## Download and unpack BLAS

if test ! -f blas.tgz; then
    curl -o blas.tgz http://www.netlib.org/blas/blas-${BLAS_VERSION}.tgz
fi
blasdir=`tar tzf blas.tgz | head -1 | cut -f1 -d"/"`
rm -rf ${blasdir}
tar xzf blas.tgz

## Download, unpack and patch LAPACK

if test ! -f lapack.tgz; then
    curl -o lapack.tgz http://www.netlib.org/lapack/lapack-${LAPACK_VERSION}.tgz
fi
lapackdir=`tar tzf lapack.tgz | head -1 | cut -f1 -d"/"`
rm -rf ${lapackdir}
tar xzf lapack.tgz

cd /tmp/${lapackdir}
patch -p 1 <${origdir}/lapack.patch
cd /tmp

## Download and unpack ARPACK

if test ! -f arpack96.tar.gz; then
    curl -O https://www.caam.rice.edu/software/ARPACK/SRC/arpack96.tar.gz
fi
arpackdir=`tar tzf arpack96.tar.gz | head -1 | cut -f1 -d"/"`
rm -rf ${arpackdir}
tar xzf arpack96.tar.gz

alreadydone=()
lapack=()
arpack=()
blas=()

known() {
    needle=$1
    res=0
    for i in ${alreadydone[@]}; do
	    if [[ $i == ${needle} ]]; then
		return 0
	    fi
    done
    return 1
}

getdeps() {
    name=$1;
    f2c -a ${name}.f >/dev/null 2>/dev/null &&
    gcc -Wno-logical-op-parentheses -Wno-shift-op-parentheses \
		-I/Users/tamas/include \
		-c ${name}.c >/dev/null &&
    nm ${name}.o | grep " U " | awk ' { print $2 }' |
    sed 's/_$//g' | sed 's/^_//g'
}

dofunction() {
    name=$1;

    if known $name; then return 0; fi

    if test -f /tmp/${arpackdir}/SRC/${name}.f; then
	cd /tmp/${arpackdir}/SRC
	arpack[$[${#arpack[@]}+1]]=$name
    elif test -f /tmp/${lapackdir}/SRC/${name}.f; then
	cd /tmp/${lapackdir}/SRC
	lapack[$[${#lapack[@]}+1]]=$name
    elif test -f /tmp/${blasdir}/${name}.f; then
	cd /tmp/${blasdir}
	blas[$[${#blas[@]}+1]]=$name
    elif test -f /tmp/${arpackdir}/UTIL/${name}.f; then
	cd /tmp/${arpackdir}/UTIL
	arpack[$[${#arpack[@]}+1]]=$name
    elif test -f /tmp/${lapackdir}/INSTALL/${name}.f; then
	cd /tmp/${lapackdir}/INSTALL
	lapack[$[${#lapack[@]}+1]]=$name
    elif test -f ${origdir}/extra/${name}.f; then
	cd ${origdir}/extra
	lapack[$[${#lapack[@]}+1]]=$name
    else
	return
    fi

    cp ${name}.f /tmp/${destdir}

    alreadydone[$[${#alreadydone[@]}+1]]=$name

    deps=`getdeps $name`
    for i in $deps; do
	dofunction $i
    done
}

## Collect and copy the needed files

FUNCS="$@"
if [ "x$FUNCS" = x ]; then
	FUNCS="dgeev dsyevr dnaupd dneupd dsaupd dseupd dgemv dgeevx dgetrf dgetrs dgesv dlapy2 dpotrf dsyrk dtrsv"
fi

for i in $FUNCS; do
    dofunction $i
done

## Some more required files

dofunction second
dofunction dvout
dofunction ivout
dofunction dmout
dofunction dlamch
dofunction len_trim

## Polish them

cd /tmp/${destdir}

# debug.h and stat.h contained common data blocks that we want to get rid of
# because it violates encapsulation. Therefore, we replace them with empty
# files, and patch the f2c-translated files later on to initialize the variables
# in these data blocks to zero.
touch debug.h
touch stat.h
trans_dir=${origdir} ${origdir}/CompletePolish *.f

## Remove the .f files.

cd /tmp/${destdir}
rm -f *.f

## Prefix the function calls with 'igraph', this is needed
## if the user wants to link igraph including internal BLAS/LAPACK/ARPACK
## and BLAS/LAPACK/ARPACK for some reason

extrafunctions=(dlamc1 dlamc2 dlamc3 dlamc4 dlamc5)

for name in ${alreadydone[@]} ${extrafunctions[@]}; do
    echo "s/${name}_/igraph${name}_/g"
done > /tmp/lapack-sed.txt

for name in ${alreadydone[@]}; do
    sed -f /tmp/lapack-sed.txt < ${name}.c >/tmp/arpackfun.c
    mv /tmp/arpackfun.c ${name}.c
done

## Update the file that is included into the main Makefile,
## this contains the ARPACK/LAPACK/BLAS source files

blasinc=/tmp/${destdir}/blas.inc
/bin/echo -n "BLAS = " > ${blasinc}
for name in ${blas[@]}; do
    /bin/echo -n "lapack/${name}.c "
done >> ${blasinc}
/bin/echo >> ${blasinc}

lapackinc=/tmp/${destdir}/lapack.inc
/bin/echo -n "LAPACK = " > ${lapackinc}
for name in ${lapack[@]}; do
    /bin/echo -n "lapack/${name}.c "
done | sed 's/lapack\/dlamch\.c//' >> ${lapackinc}
/bin/echo >> ${lapackinc}

arpackinc=/tmp/${destdir}/arpack.inc
/bin/echo -n "ARPACK = " > ${arpackinc}
for name in ${arpack[@]}; do
    /bin/echo -n "lapack/${name}.c "
done >> ${arpackinc}
/bin/echo >> ${arpackinc}

## This is a patch to make BLAS / LAPACK / ARPACK thread-safe

cd /tmp/${destdir}
patch -p2 < ${origdir}/mt.patch

## We are done

echo "Sources are ready, to update your tree please run:

  git rm -rf ${origdir}/../../src/lapack
  mv /tmp/${destdir} ${origdir}/../../src/lapack
  git add ${origdir}/../../src/lapack

"
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/lapack.patch0000644000175100001710000001126500000000000024526 0ustar00runnerdocker00000000000000diff -ru lapack-3.2.2/SRC/xerbla.f lapack-3.2.2-new/SRC/xerbla.f
--- lapack-3.2.2/SRC/xerbla.f	2009-04-16 20:10:16.000000000 +0200
+++ lapack-3.2.2-new/SRC/xerbla.f	2010-10-08 17:53:21.000000000 +0200
@@ -33,7 +33,7 @@
 * =====================================================================
 *
 *     .. Intrinsic Functions ..
-      INTRINSIC          LEN_TRIM
+      EXTERNAL          LEN_TRIM
 *     ..
 *     .. Executable Statements ..
 *
diff -ru lapack-3.3.1/INSTALL/dlamch.f lapack-3.3.1-new/INSTALL/dlamch.f
--- lapack-3.3.1/INSTALL/dlamch.f	2011-04-26 12:41:18.000000000 -0400
+++ lapack-3.3.1-new/INSTALL/dlamch.f	2011-04-26 12:41:22.000000000 -0400
@@ -60,8 +60,8 @@
       EXTERNAL           LSAME
 *     ..
 *     .. Intrinsic Functions ..
-      INTRINSIC          DIGITS, EPSILON, HUGE, MAXEXPONENT,
-     $                   MINEXPONENT, RADIX, TINY
+      EXTERNAL           DIGITSDBL, EPSILONDBL, HUGEDBL, MAXEXPONENTDBL,
+     $                   MINEXPONENTDBL, RADIXDBL, TINYDBL
 *     ..
 *     .. Executable Statements ..
 *
@@ -71,16 +71,16 @@
       RND = ONE
 *
       IF( ONE.EQ.RND ) THEN
-         EPS = EPSILON(ZERO) * 0.5
+         EPS = EPSILONDBL(ZERO) * 0.5
       ELSE
-         EPS = EPSILON(ZERO)
+         EPS = EPSILONDBL(ZERO)
       END IF
 *
       IF( LSAME( CMACH, 'E' ) ) THEN
          RMACH = EPS
       ELSE IF( LSAME( CMACH, 'S' ) ) THEN
-         SFMIN = TINY(ZERO)
-         SMALL = ONE / HUGE(ZERO)
+         SFMIN = TINYDBL(ZERO)
+         SMALL = ONE / HUGEDBL(ZERO)
          IF( SMALL.GE.SFMIN ) THEN
 *
 *           Use SMALL plus a bit, to avoid the possibility of rounding
@@ -90,21 +90,21 @@
          END IF
          RMACH = SFMIN
       ELSE IF( LSAME( CMACH, 'B' ) ) THEN
-         RMACH = RADIX(ZERO)
+         RMACH = RADIXDBL(ZERO)
       ELSE IF( LSAME( CMACH, 'P' ) ) THEN
-         RMACH = EPS * RADIX(ZERO)
+         RMACH = EPS * RADIXDBL(ZERO)
       ELSE IF( LSAME( CMACH, 'N' ) ) THEN
-         RMACH = DIGITS(ZERO)
+         RMACH = DIGITSDBL(ZERO)
       ELSE IF( LSAME( CMACH, 'R' ) ) THEN
          RMACH = RND
       ELSE IF( LSAME( CMACH, 'M' ) ) THEN
-         RMACH = MINEXPONENT(ZERO)
+         RMACH = MINEXPONENTDBL(ZERO)
       ELSE IF( LSAME( CMACH, 'U' ) ) THEN
-         RMACH = tiny(zero)
+         RMACH = TINYDBL(zero)
       ELSE IF( LSAME( CMACH, 'L' ) ) THEN
-         RMACH = MAXEXPONENT(ZERO)
+         RMACH = MAXEXPONENTDBL(ZERO)
       ELSE IF( LSAME( CMACH, 'O' ) ) THEN
-         RMACH = HUGE(ZERO)
+         RMACH = HUGEDBL(ZERO)
       ELSE
          RMACH = ZERO
       END IF
diff -ru lapack-3.5.0/SRC/dlarft.f lapack-3.5.0-new/SRC/dlarft.f
index bc1b53b..512a997 100644
--- lapack-3.5.0/SRC/dlarft.f	2009-04-16 20:10:16.000000000 +0200
+++ lapack-3.5.0-new/SRC/dlarft.f	2010-10-08 17:53:21.000000000 +0200
@@ -217,9 +217,9 @@
                IF( LSAME( STOREV, 'C' ) ) THEN
 *                 Skip any trailing zeros.
                   DO LASTV = N, I+1, -1
-                     IF( V( LASTV, I ).NE.ZERO ) EXIT
+                     IF( V( LASTV, I ).NE.ZERO ) GOTO 11
                   END DO
-                  DO J = 1, I-1
+ 11               DO J = 1, I-1
                      T( J, I ) = -TAU( I ) * V( I , J )
                   END DO   
                   J = MIN( LASTV, PREVLASTV )
@@ -232,9 +232,9 @@
                ELSE
 *                 Skip any trailing zeros.
                   DO LASTV = N, I+1, -1
-                     IF( V( I, LASTV ).NE.ZERO ) EXIT
+                     IF( V( I, LASTV ).NE.ZERO ) GOTO 21
                   END DO
-                  DO J = 1, I-1
+ 21               DO J = 1, I-1
                      T( J, I ) = -TAU( I ) * V( J , I )
                   END DO   
                   J = MIN( LASTV, PREVLASTV )
@@ -276,9 +276,9 @@
                   IF( LSAME( STOREV, 'C' ) ) THEN
 *                    Skip any leading zeros.
                      DO LASTV = 1, I-1
-                        IF( V( LASTV, I ).NE.ZERO ) EXIT
+                        IF( V( LASTV, I ).NE.ZERO ) GOTO 31
                      END DO
-                     DO J = I+1, K
+ 31                  DO J = I+1, K
                         T( J, I ) = -TAU( I ) * V( N-K+I , J )
                      END DO   
                      J = MAX( LASTV, PREVLASTV )
@@ -291,9 +291,9 @@
                   ELSE
 *                    Skip any leading zeros.
                      DO LASTV = 1, I-1
-                        IF( V( I, LASTV ).NE.ZERO ) EXIT
+                        IF( V( I, LASTV ).NE.ZERO ) GOTO 41
                      END DO
-                     DO J = I+1, K
+ 41                  DO J = I+1, K
                         T( J, I ) = -TAU( I ) * V( J, N-K+I )
                      END DO   
                      J = MAX( LASTV, PREVLASTV )
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/lenscrub.l0000644000175100001710000000253200000000000024241 0ustar00runnerdocker00000000000000/* {definitions} */
iofun	"("[^;\{]*[;\{]
decl	"("[^)]*")"[,;]
any	[.]*
S	[ \t\n]*
cS	","{S}
len	[a-z][a-z0-9]*_len

%%
"s_stop"{decl}          |
"do_fio"{decl}          |
"s_cat"{iofun}          |
"s_copy"{iofun}         |
"s_stop"{iofun}         |
"s_cmp"{iofun}          |
"i_len"{iofun}          |
"len_trim__"{iofun}     |
"do_fio"{iofun}         |
"do_lio"{iofun}         { printf("%s", yytext); /* unchanged */ }
{any}"ilaenv_("         |
"dvout_("               |
"dmout_("               |
"ivout_("               |
"xerbla_("              |
[a-z]"tim"[a-z0-9]*"_(" |
[a-z]"prtb"[a-z0-9]"_(" {
                          register int c, paran_count = 1;
                          printf("%s", yytext); /* unchanged */
			  /* Loop until the correct closing paranthesis */
                          while (paran_count != 0) {
                              c = input();
                              if (c == '(') ++paran_count;
                              else if (c == ')') --paran_count;
                              putchar(c);
                          }
                        }
{cS}"("{S}ftnlen{S}")"{S}[1-9][0-9]* { ; /* omit -- f2c -A */ }
{cS}[1-9]([0-9])*L	{ ; /* omit */ }
{cS}ftnlen({S}{len})?	{ ; /* omit -- f2c -A */ }
^ftnlen" "{len}";\n"	{ ; /* omit -- f2c without -A or -C++ */ }
{cS}{len}		{ ; }
.			{ printf("%s", yytext); /* unchanged */ }
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/mt.patch0000644000175100001710000007224300000000000023716 0ustar00runnerdocker00000000000000diff -ru src/lapack/dgetv0.c src/lapack/dgetv0.c
--- src/lapack/dgetv0.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dgetv0.c	2020-09-07 13:55:29.000000000 +0200
@@ -144,7 +144,7 @@
 {
     /* Initialized data */
 
-    static logical inits = TRUE_;
+    IGRAPH_F77_SAVE logical inits = TRUE_;
 
     /* System generated locals */
     integer v_dim1, v_offset, i__1;
@@ -153,34 +153,34 @@
     double sqrt(doublereal);
 
     /* Local variables */
-    real t0, t1, t2, t3;
-    integer jj, nbx;
+    IGRAPH_F77_SAVE real t0, t1, t2, t3;
+    integer jj, nbx = 0;
     extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
 	    integer *);
-    static integer iter;
-    static logical orth;
-    integer nopx;
+    IGRAPH_F77_SAVE integer iter;
+    IGRAPH_F77_SAVE logical orth;
+    integer nopx = 0;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
-    static integer iseed[4];
+    IGRAPH_F77_SAVE integer iseed[4];
     extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *, integer *);
     integer idist;
     extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *);
-    static logical first;
-    real tmvbx;
+    IGRAPH_F77_SAVE logical first;
+    real tmvbx = 0;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen);
-    integer mgetv0;
-    real tgetv0;
-    static doublereal rnorm0;
+    integer mgetv0 = 0;
+    real tgetv0 = 0;
+    IGRAPH_F77_SAVE doublereal rnorm0;
     extern /* Subroutine */ int igraphsecond_(real *);
     integer logfil, ndigit;
     extern /* Subroutine */ int igraphdlarnv_(integer *, integer *, integer *, 
 	    doublereal *);
-    static integer msglvl;
-    real tmvopx;
+    IGRAPH_F77_SAVE integer msglvl;
+    real tmvopx = 0;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dlaln2.c src/lapack/dlaln2.c
--- src/lapack/dlaln2.c	2020-09-07 13:49:51.000000000 +0200
+++ src/lapack/dlaln2.c	2020-09-07 13:49:16.000000000 +0200
@@ -244,7 +244,7 @@
     /* System generated locals */
     integer a_dim1, a_offset, b_dim1, b_offset, x_dim1, x_offset;
     doublereal d__1, d__2, d__3, d__4, d__5, d__6;
-    static doublereal equiv_0[4], equiv_1[4];
+    IGRAPH_F77_SAVE doublereal equiv_0[4], equiv_1[4];
 
     /* Local variables */
     integer j;
diff -ru src/lapack/dlange.c src/lapack/dlange.c
--- src/lapack/dlange.c	2020-09-07 13:49:51.000000000 +0200
+++ src/lapack/dlange.c	2020-09-07 13:55:54.000000000 +0200
@@ -144,7 +144,7 @@
     integer i__, j;
     doublereal sum, temp, scale;
     extern logical igraphlsame_(char *, char *);
-    doublereal value;
+    doublereal value = 0.;
     extern logical igraphdisnan_(doublereal *);
     extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *);
diff -ru src/lapack/dlanhs.c src/lapack/dlanhs.c
--- src/lapack/dlanhs.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dlanhs.c	2020-09-07 13:56:02.000000000 +0200
@@ -138,7 +138,7 @@
     integer i__, j;
     doublereal sum, scale;
     extern logical igraphlsame_(char *, char *);
-    doublereal value;
+    doublereal value = 0.;
     extern logical igraphdisnan_(doublereal *);
     extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *);
diff -ru src/lapack/dnaitr.c src/lapack/dnaitr.c
--- src/lapack/dnaitr.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dnaitr.c	2020-09-07 14:01:20.000000000 +0200
@@ -236,7 +236,7 @@
 {
     /* Initialized data */
 
-    static logical first = TRUE_;
+    IGRAPH_F77_SAVE logical first = TRUE_;
 
     /* System generated locals */
     integer h_dim1, h_offset, v_dim1, v_offset, i__1, i__2;
@@ -247,24 +247,24 @@
 
     /* Local variables */
     integer i__;
-    static integer j;
-    real t0, t1, t2, t3, t4, t5;
+    IGRAPH_F77_SAVE integer j;
+    IGRAPH_F77_SAVE real t0, t1, t2, t3, t4, t5;
     integer jj;
-    static integer ipj, irj;
-    integer nbx;
-    static integer ivj;
-    static doublereal ulp;
+    IGRAPH_F77_SAVE integer ipj, irj;
+    integer nbx = 0;
+    IGRAPH_F77_SAVE integer ivj;
+    IGRAPH_F77_SAVE doublereal ulp;
     doublereal tst1;
     extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
 	    integer *);
-    static integer ierr, iter;
-    static doublereal unfl, ovfl;
-    integer nopx;
-    static integer itry;
+    IGRAPH_F77_SAVE integer ierr, iter;
+    IGRAPH_F77_SAVE doublereal unfl, ovfl;
+    integer nopx = 0;
+    IGRAPH_F77_SAVE integer itry;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
     doublereal temp1;
-    static logical orth1, orth2, step3, step4;
-    static doublereal betaj;
+    IGRAPH_F77_SAVE logical orth1, orth2, step3, step4;
+    IGRAPH_F77_SAVE doublereal betaj;
     extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
 	    integer *), igraphdgemv_(char *, integer *, integer *, doublereal *, 
 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
@@ -276,15 +276,15 @@
 	    *, integer *, integer *, doublereal *, integer *, integer *, char 
 	    *, ftnlen);
     doublereal xtemp[2];
-    real tmvbx;
+    real tmvbx = 0;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen);
-    static doublereal wnorm;
+    IGRAPH_F77_SAVE doublereal wnorm;
     extern /* Subroutine */ int igraphivout_(integer *, integer *, integer *, 
 	    integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *, 
 	    logical *, integer *, integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *), igraphdlabad_(doublereal *, doublereal *);
-    static doublereal rnorm1;
+    IGRAPH_F77_SAVE doublereal rnorm1;
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
 	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
@@ -292,14 +292,14 @@
     extern doublereal igraphdlanhs_(char *, integer *, doublereal *, integer *, 
 	    doublereal *);
     extern /* Subroutine */ int igraphsecond_(real *);
-    integer logfil, ndigit, nitref, mnaitr;
-    real titref, tnaitr;
-    static integer msglvl;
-    static doublereal smlnum;
-    integer nrorth;
-    static logical rstart;
-    integer nrstrt;
-    real tmvopx;
+    integer logfil = 0, ndigit, nitref = 0, mnaitr = 0;
+    real titref = 0, tnaitr = 0;
+    IGRAPH_F77_SAVE integer msglvl;
+    IGRAPH_F77_SAVE doublereal smlnum;
+    integer nrorth = 0;
+    IGRAPH_F77_SAVE logical rstart;
+    integer nrstrt = 0;
+    real tmvopx = 0;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dnapps.c src/lapack/dnapps.c
--- src/lapack/dnapps.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dnapps.c	2020-09-07 14:02:01.000000000 +0200
@@ -168,7 +168,7 @@
 {
     /* Initialized data */
 
-    static logical first = TRUE_;
+    IGRAPH_F77_SAVE logical first = TRUE_;
 
     /* System generated locals */
     integer h_dim1, h_offset, v_dim1, v_offset, q_dim1, q_offset, i__1, i__2, 
@@ -179,14 +179,14 @@
     doublereal c__, f, g;
     integer i__, j;
     doublereal r__, s, t, u[3];
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     doublereal h11, h12, h21, h22, h32;
     integer jj, ir, nr;
     doublereal tau;
-    static doublereal ulp;
+    IGRAPH_F77_SAVE doublereal ulp;
     doublereal tst1;
     integer iend;
-    static doublereal unfl, ovfl;
+    IGRAPH_F77_SAVE doublereal unfl, ovfl;
     extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
 	    integer *), igraphdlarf_(char *, integer *, integer *, doublereal *, 
 	    integer *, doublereal *, doublereal *, integer *, doublereal *);
@@ -215,10 +215,10 @@
 	    doublereal *);
     integer logfil, ndigit;
     doublereal sigmar;
-    integer mnapps, msglvl;
-    real tnapps;
+    integer mnapps = 0, msglvl;
+    real tnapps = 0.;
     integer istart;
-    static doublereal smlnum;
+    IGRAPH_F77_SAVE doublereal smlnum;
     integer kplusp;
 
 
diff -ru src/lapack/dnaup2.c src/lapack/dnaup2.c
--- src/lapack/dnaup2.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dnaup2.c	2020-09-07 13:49:16.000000000 +0200
@@ -213,44 +213,44 @@
     double sqrt(doublereal);
 
     /* Local variables */
-    static integer j;
-    static real t0, t1, t2, t3;
-    static integer kp[4], np0, nbx, nev0;
+    IGRAPH_F77_SAVE integer j;
+    IGRAPH_F77_SAVE real t0, t1, t2, t3;
+    IGRAPH_F77_SAVE integer kp[4], np0, nbx, nev0;
     extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
 	    integer *);
-    static doublereal eps23;
-    static integer ierr, iter;
-    static doublereal temp;
+    IGRAPH_F77_SAVE doublereal eps23;
+    IGRAPH_F77_SAVE integer ierr, iter;
+    IGRAPH_F77_SAVE doublereal temp;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
-    static logical getv0, cnorm;
+    IGRAPH_F77_SAVE logical getv0, cnorm;
     extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *);
-    static integer nconv;
+    IGRAPH_F77_SAVE integer nconv;
     extern /* Subroutine */ int igraphdmout_(integer *, integer *, integer *, 
 	    doublereal *, integer *, integer *, char *, ftnlen);
-    static logical initv;
-    static doublereal rnorm;
-    static real tmvbx;
+    IGRAPH_F77_SAVE logical initv;
+    IGRAPH_F77_SAVE doublereal rnorm;
+    IGRAPH_F77_SAVE real tmvbx;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
 	    , integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *
 	    , logical *, integer *, integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *);
     extern doublereal igraphdlapy2_(doublereal *, doublereal *);
-    static integer mnaup2;
-    static real tnaup2;
+    IGRAPH_F77_SAVE integer mnaup2;
+    IGRAPH_F77_SAVE real tnaup2;
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphdneigh_(doublereal *, integer *, doublereal *,
 	     integer *, doublereal *, doublereal *, doublereal *, doublereal *
 	    , integer *, doublereal *, integer *);
-    static integer nevbef;
+    IGRAPH_F77_SAVE integer nevbef;
     extern /* Subroutine */ int igraphsecond_(real *);
-    static integer logfil, ndigit;
+    IGRAPH_F77_SAVE integer logfil, ndigit;
     extern /* Subroutine */ int igraphdnaitr_(integer *, char *, integer *, integer 
 	    *, integer *, integer *, doublereal *, doublereal *, doublereal *,
 	     integer *, doublereal *, integer *, integer *, doublereal *, 
 	    integer *);
-    static logical update;
+    IGRAPH_F77_SAVE logical update;
     extern /* Subroutine */ int igraphdngets_(integer *, char *, integer *, integer 
 	    *, doublereal *, doublereal *, doublereal *, doublereal *, 
 	    doublereal *), igraphdnapps_(integer *, integer *, integer *, 
@@ -259,9 +259,9 @@
 	    doublereal *), igraphdnconv_(integer *, doublereal *, doublereal *, 
 	    doublereal *, doublereal *, integer *), igraphdsortc_(char *, logical *,
 	     integer *, doublereal *, doublereal *, doublereal *);
-    static logical ushift;
-    static char wprime[2];
-    static integer msglvl, nptemp, numcnv, kplusp;
+    IGRAPH_F77_SAVE logical ushift;
+    IGRAPH_F77_SAVE char wprime[2];
+    IGRAPH_F77_SAVE integer msglvl, nptemp, numcnv, kplusp;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dnaupd.c src/lapack/dnaupd.c
--- src/lapack/dnaupd.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dnaupd.c	2020-09-07 14:02:44.000000000 +0200
@@ -463,20 +463,20 @@
 
     /* Local variables */
     integer j;
-    real t0, t1;
-    static integer nb, ih, iq, np, iw, ldh, ldq;
-    integer nbx;
-    static integer nev0, mode;
+    IGRAPH_F77_SAVE real t0, t1;
+    IGRAPH_F77_SAVE integer nb, ih, iq, np, iw, ldh, ldq;
+    integer nbx = 0;
+    IGRAPH_F77_SAVE integer nev0, mode;
     integer ierr;
-    static integer iupd, next;
-    integer nopx;
-    static integer levec;
+    IGRAPH_F77_SAVE integer iupd, next;
+    integer nopx = 0;
+    IGRAPH_F77_SAVE integer levec;
     real trvec, tmvbx;
-    static integer ritzi;
+    IGRAPH_F77_SAVE integer ritzi;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
 	    , integer *, char *, ftnlen);
-    static integer ritzr;
+    IGRAPH_F77_SAVE integer ritzr;
     extern /* Subroutine */ int igraphdnaup2_(integer *, char *, integer *, char *, 
 	    integer *, integer *, doublereal *, doublereal *, integer *, 
 	    integer *, integer *, integer *, doublereal *, integer *, 
@@ -488,17 +488,17 @@
     extern /* Subroutine */ int igraphsecond_(real *);
     integer logfil, ndigit;
     real tneigh;
-    integer mnaupd;
-    static integer ishift;
+    integer mnaupd = 0;
+    IGRAPH_F77_SAVE integer ishift;
     integer nitref;
-    static integer bounds;
+    IGRAPH_F77_SAVE integer bounds;
     real tnaupd;
     extern /* Subroutine */ int igraphdstatn_(void);
     real titref, tnaitr;
-    static integer msglvl;
+    IGRAPH_F77_SAVE integer msglvl;
     real tngets, tnapps, tnconv;
-    static integer mxiter;
-    integer nrorth, nrstrt;
+    IGRAPH_F77_SAVE integer mxiter;
+    integer nrorth = 0, nrstrt = 0;
     real tmvopx;
 
     /* Fortran I/O blocks */
diff -ru src/lapack/dnconv.c src/lapack/dnconv.c
--- src/lapack/dnconv.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dnconv.c	2020-09-07 14:02:51.000000000 +0200
@@ -92,11 +92,11 @@
 
     /* Local variables */
     integer i__;
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     doublereal eps23, temp;
     extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
     extern /* Subroutine */ int igraphsecond_(real *);
-    real tnconv;
+    real tnconv = 0.;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dneigh.c src/lapack/dneigh.c
--- src/lapack/dneigh.c	2020-09-07 13:49:53.000000000 +0200
+++ src/lapack/dneigh.c	2020-09-07 14:03:18.000000000 +0200
@@ -128,7 +128,7 @@
 
     /* Local variables */
     integer i__;
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     doublereal vl[1], temp;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
     extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
@@ -144,12 +144,12 @@
     extern /* Subroutine */ int igraphdlaqrb_(logical *, integer *, integer *, 
 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
 	    doublereal *, integer *);
-    integer mneigh;
+    integer mneigh = 0;
     extern /* Subroutine */ int igraphsecond_(real *), igraphdlacpy_(char *, integer *, 
 	    integer *, doublereal *, integer *, doublereal *, integer *);
     integer logfil, ndigit;
     logical select[1];
-    real tneigh;
+    real tneigh = 0.;
     extern /* Subroutine */ int igraphdtrevc_(char *, char *, logical *, integer *, 
 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
 	    integer *, integer *, integer *, doublereal *, integer *);
diff -ru src/lapack/dneupd.c src/lapack/dneupd.c
--- src/lapack/dneupd.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dneupd.c	2020-09-07 14:03:48.000000000 +0200
@@ -393,7 +393,7 @@
     extern /* Subroutine */ int igraphdtrevc_(char *, char *, logical *, integer *, 
 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
 	    integer *, integer *, integer *, doublereal *, integer *);
-    integer mneupd, bounds;
+    integer mneupd = 0, bounds;
     extern /* Subroutine */ int igraphdtrsen_(char *, char *, logical *, integer *, 
 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
diff -ru src/lapack/dngets.c src/lapack/dngets.c
--- src/lapack/dngets.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dngets.c	2020-09-07 14:04:06.000000000 +0200
@@ -122,15 +122,15 @@
     integer s_cmp(char *, char *, ftnlen, ftnlen);
 
     /* Local variables */
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
 	    , integer *, char *, ftnlen), igraphsecond_(real *);
-    integer logfil, ndigit, mngets;
+    integer logfil, ndigit, mngets = 0;
     extern /* Subroutine */ int igraphdsortc_(char *, logical *, integer *, 
 	    doublereal *, doublereal *, doublereal *);
     integer msglvl;
-    real tngets;
+    real tngets = 0.;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dsaitr.c src/lapack/dsaitr.c
--- src/lapack/dsaitr.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsaitr.c	2020-09-07 14:05:22.000000000 +0200
@@ -231,7 +231,7 @@
 {
     /* Initialized data */
 
-    static logical first = TRUE_;
+    IGRAPH_F77_SAVE logical first = TRUE_;
 
     /* System generated locals */
     integer h_dim1, h_offset, v_dim1, v_offset, i__1;
@@ -241,20 +241,20 @@
 
     /* Local variables */
     integer i__;
-    static integer j;
-    real t0, t1, t2, t3, t4, t5;
+    IGRAPH_F77_SAVE integer j;
+    IGRAPH_F77_SAVE real t0, t1, t2, t3, t4, t5;
     integer jj;
-    static integer ipj, irj;
-    integer nbx;
-    static integer ivj;
+    IGRAPH_F77_SAVE integer ipj, irj;
+    integer nbx = 0;
+    IGRAPH_F77_SAVE integer ivj;
     extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
 	    integer *);
-    static integer ierr, iter;
-    integer nopx;
-    static integer itry;
+    IGRAPH_F77_SAVE integer ierr, iter;
+    integer nopx = 0;
+    IGRAPH_F77_SAVE integer itry;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
     doublereal temp1;
-    static logical orth1, orth2, step3, step4;
+    IGRAPH_F77_SAVE logical orth1, orth2, step3, step4;
     extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
 	    integer *), igraphdgemv_(char *, integer *, integer *, doublereal *, 
 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
@@ -263,30 +263,30 @@
     extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *);
     doublereal xtemp[2];
-    real tmvbx;
+    real tmvbx = 0;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen);
-    static doublereal wnorm;
+    IGRAPH_F77_SAVE doublereal wnorm;
     extern /* Subroutine */ int igraphivout_(integer *, integer *, integer *, 
 	    integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *, 
 	    logical *, integer *, integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *);
-    static doublereal rnorm1;
+    IGRAPH_F77_SAVE doublereal rnorm1;
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
 	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
 	    integer *, integer *), igraphsecond_(real *);
     integer logfil;
-    static doublereal safmin;
-    integer ndigit, nitref;
-    real titref;
-    integer msaitr;
-    static integer msglvl;
-    real tsaitr;
-    integer nrorth;
-    static logical rstart;
-    integer nrstrt;
-    real tmvopx;
+    IGRAPH_F77_SAVE doublereal safmin;
+    integer ndigit = 0, nitref = 0;
+    real titref = 0;
+    integer msaitr = 0;
+    IGRAPH_F77_SAVE integer msglvl;
+    real tsaitr = 0;
+    integer nrorth = 0;
+    IGRAPH_F77_SAVE logical rstart;
+    integer nrstrt = 0;
+    real tmvopx = 0;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dsapps.c src/lapack/dsapps.c
--- src/lapack/dsapps.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsapps.c	2020-09-07 14:05:45.000000000 +0200
@@ -156,7 +156,7 @@
 {
     /* Initialized data */
 
-    static logical first = TRUE_;
+    IGRAPH_F77_SAVE logical first = TRUE_;
 
     /* System generated locals */
     integer h_dim1, h_offset, q_dim1, q_offset, v_dim1, v_offset, i__1, i__2, 
@@ -167,7 +167,7 @@
     doublereal c__, f, g;
     integer i__, j;
     doublereal r__, s, a1, a2, a3, a4;
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     integer jj;
     doublereal big;
     integer iend, itop;
@@ -185,9 +185,9 @@
 	    integer *, doublereal *, integer *, doublereal *, integer *), igraphdlartg_(doublereal *, doublereal *, doublereal *, 
 	    doublereal *, doublereal *), igraphdlaset_(char *, integer *, integer *,
 	     doublereal *, doublereal *, doublereal *, integer *);
-    static doublereal epsmch;
-    integer logfil, ndigit, msapps, msglvl, istart;
-    real tsapps;
+    IGRAPH_F77_SAVE doublereal epsmch;
+    integer logfil, ndigit, msapps = 0, msglvl, istart;
+    real tsapps = 0;
     integer kplusp;
 
 
diff -ru src/lapack/dsaup2.c src/lapack/dsaup2.c
--- src/lapack/dsaup2.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsaup2.c	2020-09-07 14:06:17.000000000 +0200
@@ -219,43 +219,43 @@
 
     /* Local variables */
     integer j;
-    real t0, t1, t2, t3;
+    IGRAPH_F77_SAVE real t0, t1, t2, t3;
     integer kp[3];
-    static integer np0;
-    integer nbx;
-    static integer nev0;
+    IGRAPH_F77_SAVE integer np0;
+    integer nbx = 0;
+    IGRAPH_F77_SAVE integer nev0;
     extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
 	    integer *);
-    static doublereal eps23;
+    IGRAPH_F77_SAVE doublereal eps23;
     integer ierr;
-    static integer iter;
+    IGRAPH_F77_SAVE integer iter;
     doublereal temp;
     integer nevd2;
     extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
-    static logical getv0;
+    IGRAPH_F77_SAVE logical getv0;
     integer nevm2;
-    static logical cnorm;
+    IGRAPH_F77_SAVE logical cnorm;
     extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *), igraphdswap_(integer *, doublereal *, integer 
 	    *, doublereal *, integer *);
-    static integer nconv;
-    static logical initv;
-    static doublereal rnorm;
-    real tmvbx;
+    IGRAPH_F77_SAVE integer nconv;
+    IGRAPH_F77_SAVE logical initv;
+    IGRAPH_F77_SAVE doublereal rnorm;
+    real tmvbx = 0.0;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
 	    , integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *
 	    , logical *, integer *, integer *, doublereal *, integer *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *);
-    integer msaup2;
+    integer msaup2 = 0;
     real tsaup2;
     extern doublereal igraphdlamch_(char *);
     integer nevbef;
     extern /* Subroutine */ int igraphsecond_(real *);
-    integer logfil, ndigit;
+    integer logfil = 0, ndigit;
     extern /* Subroutine */ int igraphdseigt_(doublereal *, integer *, doublereal *,
 	     integer *, doublereal *, doublereal *, doublereal *, integer *);
-    static logical update;
+    IGRAPH_F77_SAVE logical update;
     extern /* Subroutine */ int igraphdsaitr_(integer *, char *, integer *, integer 
 	    *, integer *, integer *, doublereal *, doublereal *, doublereal *,
 	     integer *, doublereal *, integer *, integer *, doublereal *, 
@@ -265,13 +265,13 @@
 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
 	    integer *, doublereal *), igraphdsconv_(integer *, doublereal *, 
 	    doublereal *, doublereal *, integer *);
-    static logical ushift;
+    IGRAPH_F77_SAVE logical ushift;
     char wprime[2];
-    static integer msglvl;
+    IGRAPH_F77_SAVE integer msglvl;
     integer nptemp;
     extern /* Subroutine */ int igraphdsortr_(char *, logical *, integer *, 
 	    doublereal *, doublereal *);
-    static integer kplusp;
+    IGRAPH_F77_SAVE integer kplusp;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dsaupd.c src/lapack/dsaupd.c
--- src/lapack/dsaupd.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsaupd.c	2020-09-07 14:06:58.000000000 +0200
@@ -464,12 +464,12 @@
 
     /* Local variables */
     integer j;
-    real t0, t1;
-    static integer nb, ih, iq, np, iw, ldh, ldq;
-    integer nbx;
-    static integer nev0, mode, ierr, iupd, next;
-    integer nopx;
-    static integer ritz;
+    IGRAPH_F77_SAVE real t0, t1;
+    IGRAPH_F77_SAVE integer nb, ih, iq, np, iw, ldh, ldq;
+    integer nbx = 0;
+    IGRAPH_F77_SAVE integer nev0, mode, ierr, iupd, next;
+    integer nopx = 0;
+    IGRAPH_F77_SAVE integer ritz;
     real tmvbx;
     extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
 	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
@@ -483,19 +483,19 @@
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphsecond_(real *);
     integer logfil, ndigit;
-    static integer ishift;
-    integer nitref, msaupd;
-    static integer bounds;
+    IGRAPH_F77_SAVE integer ishift;
+    integer nitref, msaupd = 0;
+    IGRAPH_F77_SAVE integer bounds;
     real titref, tseigt, tsaupd;
     extern /* Subroutine */ int igraphdstats_(void);
-    static integer msglvl;
-    real tsaitr;
-    static integer mxiter;
+    IGRAPH_F77_SAVE integer msglvl;
+    real tsaitr = 0.0;
+    IGRAPH_F77_SAVE integer mxiter;
     real tsgets, tsapps;
-    integer nrorth;
-    real tsconv;
-    integer nrstrt;
-    real tmvopx;
+    integer nrorth = 0;
+    real tsconv = 0.0;
+    integer nrstrt = 0;
+    real tmvopx = 0.0;
 
     /* Fortran I/O blocks */
     static cilist io___28 = { 0, 6, 0, fmt_1000, 0 };
diff -ru src/lapack/dsconv.c src/lapack/dsconv.c
--- src/lapack/dsconv.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsconv.c	2020-09-07 14:07:16.000000000 +0200
@@ -86,11 +86,11 @@
 
     /* Local variables */
     integer i__;
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     doublereal eps23, temp;
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphsecond_(real *);
-    real tsconv;
+    real tsconv = 0;
 
 
 /*     %----------------------------------------------------%   
diff -ru src/lapack/dseigt.c src/lapack/dseigt.c
--- src/lapack/dseigt.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dseigt.c	2020-09-07 14:07:35.000000000 +0200
@@ -112,14 +112,14 @@
 
     /* Local variables */
     integer k;
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *), igraphdvout_(integer *, integer *, doublereal 
 	    *, integer *, char *, ftnlen), igraphsecond_(real *);
-    integer logfil, ndigit, mseigt;
+    integer logfil, ndigit, mseigt = 0;
     extern /* Subroutine */ int igraphdstqrb_(integer *, doublereal *, doublereal *,
 	     doublereal *, doublereal *, integer *);
-    real tseigt;
+    real tseigt = 0.0;
     integer msglvl;
 
 
diff -ru src/lapack/dseupd.c src/lapack/dseupd.c
--- src/lapack/dseupd.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dseupd.c	2020-09-07 14:08:02.000000000 +0200
@@ -280,7 +280,7 @@
     extern doublereal igraphdlamch_(char *);
     extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
 	    doublereal *, integer *, doublereal *, integer *);
-    integer logfil, ndigit, bounds, mseupd;
+    integer logfil, ndigit, bounds, mseupd = 0;
     extern /* Subroutine */ int igraphdsteqr_(char *, integer *, doublereal *, 
 	    doublereal *, doublereal *, integer *, doublereal *, integer *);
     integer msglvl, ktrord;
diff -ru src/lapack/dsgets.c src/lapack/dsgets.c
--- src/lapack/dsgets.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dsgets.c	2020-09-07 14:08:28.000000000 +0200
@@ -119,15 +119,15 @@
     integer s_cmp(char *, char *, ftnlen, ftnlen);
 
     /* Local variables */
-    real t0, t1;
+    IGRAPH_F77_SAVE real t0, t1;
     integer kevd2;
     extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
 	    doublereal *, integer *), igraphdcopy_(integer *, doublereal *, integer 
 	    *, doublereal *, integer *), igraphdvout_(integer *, integer *, 
 	    doublereal *, integer *, char *, ftnlen), igraphivout_(integer *, 
 	    integer *, integer *, integer *, char *, ftnlen), igraphsecond_(real *);
-    integer logfil, ndigit, msgets, msglvl;
-    real tsgets;
+    integer logfil, ndigit, msgets = 0, msglvl;
+    real tsgets = 0.0;
     extern /* Subroutine */ int igraphdsortr_(char *, logical *, integer *, 
 	    doublereal *, doublereal *);
 
diff -ru src/lapack/dtrsen.c src/lapack/dtrsen.c
--- src/lapack/dtrsen.c	2020-09-07 13:49:54.000000000 +0200
+++ src/lapack/dtrsen.c	2020-09-07 14:09:07.000000000 +0200
@@ -349,7 +349,7 @@
     logical swap;
     doublereal scale;
     extern logical igraphlsame_(char *, char *);
-    integer isave[3], lwmin;
+    integer isave[3], lwmin = 0;
     logical wantq, wants;
     doublereal rnorm;
     extern /* Subroutine */ int igraphdlacn2_(integer *, doublereal *, doublereal *,
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/lapack/split.sed0000644000175100001710000000117600000000000024102 0ustar00runnerdocker00000000000000# delete the header produced by f2c
/\/\*  -- trans.*/,/\*\//{
d
}

# extract the first line of including f2c.h
/#include/,/^$/{
w temp/header1
d
}

# possible local constants produced by f2c
/\/\* Table of constant values \*\//{
s/^/    /
w temp/header2
d
}
/^static.*=.*/,/^$/{
s/^/    /
w temp/header2
d
}

# matches /* Subroutine */..._(  or /* Complex */..._(
/^\/\* .*_(/,/^\{/{
w temp/header3
/^\{/!{
d
}
}
# matches any function declaration line
/^[a-zA-Z].*_(/,/^\{/{
w temp/header3
/^\{/!{
d
}
}

/^\{/,/\/\*.*LAPACK/{
/\/\*.*LAPACK/!{
/^$/d
/^\{/d
w temp/prologue
d
}
}

/\/\*.*LAPACK/,/\*\//{
w temp/comment
d
}


w temp/code
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/tools/removeexamples.py0000755000175100001710000000135500000000000024427 0ustar00runnerdocker00000000000000#!/usr/bin/env python3
"""Helper script used to remove the bundled examples from the DocBook files
that are used to generate the PDF documentation.

This file is part of the documentation build process. You do not need to call
it manually.
"""

import sys
from xml.etree.ElementTree import ElementTree


def usage():
    print(sys.argv[0], " ")


def main():
    if len(sys.argv) != 3:
        usage()
        sys.exit(2)

    # Read in
    tree = ElementTree()
    tree.parse(sys.argv[1])

    # Remove examples
    examples = tree.findall(".//example")
    for ex in examples:
        prog = ex.find("programlisting")
        ex.remove(prog)

    # Write result
    tree.write(sys.argv[2])


if __name__ == "__main__":
    main()
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6231425
igraph-0.9.9/vendor/source/igraph/vendor/0000755000175100001710000000000000000000000021147 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/CMakeLists.txt0000644000175100001710000000021600000000000023706 0ustar00runnerdocker00000000000000add_subdirectory(cs)
add_subdirectory(f2c)
add_subdirectory(glpk)
add_subdirectory(lapack)
add_subdirectory(mini-gmp)
add_subdirectory(plfit)
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6311426
igraph-0.9.9/vendor/source/igraph/vendor/cs/0000755000175100001710000000000000000000000021554 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/CMakeLists.txt0000644000175100001710000000353400000000000024321 0ustar00runnerdocker00000000000000# Declare the files needed to compile our vendored CXSparse copy
add_library(
  cxsparse_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  cs_add.c
  cs_amd.c
  cs_chol.c
  cs_cholsol.c
  cs_compress.c
  cs_counts.c
  cs_cumsum.c
  cs_dfs.c
  cs_dmperm.c
  cs_droptol.c
  cs_dropzeros.c
  cs_dupl.c
  cs_entry.c
  cs_ereach.c
  cs_etree.c
  cs_fkeep.c
  cs_gaxpy.c
  cs_happly.c
  cs_house.c
  cs_ipvec.c
  cs_leaf.c
  cs_load.c
  cs_lsolve.c
  cs_ltsolve.c
  cs_lu.c
  cs_lusol.c
  cs_malloc.c
  cs_maxtrans.c
  cs_multiply.c
  cs_norm.c
  cs_permute.c
  cs_pinv.c
  cs_post.c
  cs_pvec.c
  cs_qr.c
  cs_qrsol.c
  cs_randperm.c
  cs_reach.c
  cs_scatter.c
  cs_scc.c
  cs_schol.c
  cs_spsolve.c
  cs_sqr.c
  cs_symperm.c
  cs_tdfs.c
  cs_transpose.c
  cs_updown.c
  cs_usolve.c
  cs_util.c
  cs_utsolve.c
  # the following files are not needed - they contain no symbols
  # cs_print.c
)

target_include_directories(
  cxsparse_vendored
  PRIVATE
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
  PUBLIC
  ${CMAKE_CURRENT_SOURCE_DIR}
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET cxsparse_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Disable complex number support for CXSparse because:
#   - It is necessary to compile with MSVC
#   - igraph does not need complex number support from CXSparse on any platform
target_compile_definitions(cxsparse_vendored PUBLIC NCOMPLEX)

# Since these are included as object files, they should call the
# function as is (without a visibility specification)
target_compile_definitions(cxsparse_vendored PRIVATE IGRAPH_STATIC)

use_all_warnings(cxsparse_vendored)

if (MSVC)
  target_compile_options(
    cxsparse_vendored PRIVATE
    /wd4100
  ) # disable unreferenced parameter warning
else()
  target_compile_options(
    cxsparse_vendored PRIVATE
    $<$:-Wno-unused-variable>
  )
endif()

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/License.txt0000644000175100001710000000157500000000000023707 0ustar00runnerdocker00000000000000CXSparse: a Concise Sparse matrix package - Extended.
Copyright (c) 2006, Timothy A. Davis.
http://www.suitesparse.com

--------------------------------------------------------------------------------

CXSparse is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

CXSparse is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this Module; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/SuiteSparse_config.h0000644000175100001710000001714700000000000025533 0ustar00runnerdocker00000000000000/* ========================================================================== */
/* === SuiteSparse_config =================================================== */
/* ========================================================================== */

/* Configuration file for SuiteSparse: a Suite of Sparse matrix packages
 * (AMD, COLAMD, CCOLAMD, CAMD, CHOLMOD, UMFPACK, CXSparse, and others).
 *
 * SuiteSparse_config.h provides the definition of the long integer.  On most
 * systems, a C program can be compiled in LP64 mode, in which long's and
 * pointers are both 64-bits, and int's are 32-bits.  Windows 64, however, uses
 * the LLP64 model, in which int's and long's are 32-bits, and long long's and
 * pointers are 64-bits.
 *
 * SuiteSparse packages that include long integer versions are
 * intended for the LP64 mode.  However, as a workaround for Windows 64
 * (and perhaps other systems), the long integer can be redefined.
 *
 * If _WIN64 is defined, then the __int64 type is used instead of long.
 *
 * The long integer can also be defined at compile time.  For example, this
 * could be added to SuiteSparse_config.mk:
 *
 * CFLAGS = -O -D'SuiteSparse_long=long long' \
 *  -D'SuiteSparse_long_max=9223372036854775801' -D'SuiteSparse_long_idd="lld"'
 *
 * This file defines SuiteSparse_long as either long (on all but _WIN64) or
 * __int64 on Windows 64.  The intent is that a SuiteSparse_long is always a
 * 64-bit integer in a 64-bit code.  ptrdiff_t might be a better choice than
 * long; it is always the same size as a pointer.
 *
 * This file also defines the SUITESPARSE_VERSION and related definitions.
 *
 * Copyright (c) 2012, Timothy A. Davis.  No licensing restrictions apply
 * to this file or to the SuiteSparse_config directory.
 * Author: Timothy A. Davis.
 */

#ifndef SUITESPARSE_CONFIG_H
#define SUITESPARSE_CONFIG_H

#ifdef __cplusplus
extern "C" {
#endif

#include 
#include 

/* ========================================================================== */
/* === SuiteSparse_long ===================================================== */
/* ========================================================================== */

#ifndef SuiteSparse_long

#ifdef _WIN64

#define SuiteSparse_long __int64
#define SuiteSparse_long_max _I64_MAX
#define SuiteSparse_long_idd "I64d"

#else

#define SuiteSparse_long long
#define SuiteSparse_long_max LONG_MAX
#define SuiteSparse_long_idd "ld"

#endif
#define SuiteSparse_long_id "%" SuiteSparse_long_idd
#endif

/* Disable unneeded parts for igraph */
#if 0 /* start comment */

/* ========================================================================== */
/* === SuiteSparse_config parameters and functions ========================== */
/* ========================================================================== */

/* SuiteSparse-wide parameters are placed in this struct.  It is meant to be
   an extern, globally-accessible struct.  It is not meant to be updated
   frequently by multiple threads.  Rather, if an application needs to modify
   SuiteSparse_config, it should do it once at the beginning of the application,
   before multiple threads are launched.

   The intent of these function pointers is that they not be used in your
   application directly, except to assign them to the desired user-provided
   functions.  Rather, you should use the
 */

struct SuiteSparse_config_struct
{
    void *(*malloc_func) (size_t) ;             /* pointer to malloc */
    void *(*calloc_func) (size_t, size_t) ;     /* pointer to calloc */
    void *(*realloc_func) (void *, size_t) ;    /* pointer to realloc */
    void (*free_func) (void *) ;                /* pointer to free */
    int (*printf_func) (const char *, ...) ;    /* pointer to printf */
    double (*hypot_func) (double, double) ;     /* pointer to hypot */
    int (*divcomplex_func) (double, double, double, double, double *, double *);
} ;

extern struct SuiteSparse_config_struct SuiteSparse_config ;

void SuiteSparse_start ( void ) ;   /* called to start SuiteSparse */

void SuiteSparse_finish ( void ) ;  /* called to finish SuiteSparse */

void *SuiteSparse_malloc    /* pointer to allocated block of memory */
(
    size_t nitems,          /* number of items to malloc (>=1 is enforced) */
    size_t size_of_item     /* sizeof each item */
) ;

void *SuiteSparse_calloc    /* pointer to allocated block of memory */
(
    size_t nitems,          /* number of items to calloc (>=1 is enforced) */
    size_t size_of_item     /* sizeof each item */
) ;

void *SuiteSparse_realloc   /* pointer to reallocated block of memory, or
                               to original block if the realloc failed. */
(
    size_t nitems_new,      /* new number of items in the object */
    size_t nitems_old,      /* old number of items in the object */
    size_t size_of_item,    /* sizeof each item */
    void *p,                /* old object to reallocate */
    int *ok                 /* 1 if successful, 0 otherwise */
) ;

void *SuiteSparse_free      /* always returns NULL */
(
    void *p                 /* block to free */
) ;

void SuiteSparse_tic    /* start the timer */
(
    double tic [2]      /* output, contents undefined on input */
) ;

double SuiteSparse_toc  /* return time in seconds since last tic */
(
    double tic [2]      /* input: from last call to SuiteSparse_tic */
) ;

double SuiteSparse_time  /* returns current wall clock time in seconds */
(
    void
) ;

/* returns sqrt (x^2 + y^2), computed reliably */
double SuiteSparse_hypot (double x, double y) ;

/* complex division of c = a/b */
int SuiteSparse_divcomplex
(
    double ar, double ai,	/* real and imaginary parts of a */
    double br, double bi,	/* real and imaginary parts of b */
    double *cr, double *ci	/* real and imaginary parts of c */
) ;

/* determine which timer to use, if any */
#ifndef NTIMER
#ifdef _POSIX_C_SOURCE
#if    _POSIX_C_SOURCE >= 199309L
#define SUITESPARSE_TIMER_ENABLED
#endif
#endif
#endif

/* SuiteSparse printf macro */
#define SUITESPARSE_PRINTF(params) \
{ \
    if (SuiteSparse_config.printf_func != NULL) \
    { \
        (void) (SuiteSparse_config.printf_func) params ; \
    } \
}

/* ========================================================================== */
/* === SuiteSparse version ================================================== */
/* ========================================================================== */

/* SuiteSparse is not a package itself, but a collection of packages, some of
 * which must be used together (UMFPACK requires AMD, CHOLMOD requires AMD,
 * COLAMD, CAMD, and CCOLAMD, etc).  A version number is provided here for the
 * collection itself, which is also the version number of SuiteSparse_config.
 */

int SuiteSparse_version     /* returns SUITESPARSE_VERSION */
(
    /* output, not defined on input.  Not used if NULL.  Returns
       the three version codes in version [0..2]:
       version [0] is SUITESPARSE_MAIN_VERSION
       version [1] is SUITESPARSE_SUB_VERSION
       version [2] is SUITESPARSE_SUBSUB_VERSION
       */
    int version [3]
) ;

/* Versions prior to 4.2.0 do not have the above function.  The following
   code fragment will work with any version of SuiteSparse:

   #ifdef SUITESPARSE_HAS_VERSION_FUNCTION
   v = SuiteSparse_version (NULL) ;
   #else
   v = SUITESPARSE_VERSION ;
   #endif
*/
#define SUITESPARSE_HAS_VERSION_FUNCTION

#endif /* end comment */

#define SUITESPARSE_DATE "Mar 3, 2021"
#define SUITESPARSE_VER_CODE(main,sub) ((main) * 1000 + (sub))
#define SUITESPARSE_MAIN_VERSION 5
#define SUITESPARSE_SUB_VERSION 9
#define SUITESPARSE_SUBSUB_VERSION 0
#define SUITESPARSE_VERSION \
    SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,SUITESPARSE_SUB_VERSION)

#ifdef __cplusplus
}
#endif
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs.h0000644000175100001710000010012600000000000022332 0ustar00runnerdocker00000000000000/* ========================================================================== */
/* CXSparse/Include/cs.h file */
/* ========================================================================== */

/* This is the CXSparse/Include/cs.h file.  It has the same name (cs.h) as
   the CSparse/Include/cs.h file.  The 'make install' for SuiteSparse installs
   CXSparse, and this file, instead of CSparse.  The two packages have the same
   cs.h include filename, because CXSparse is a superset of CSparse.  Any user
   program that uses CSparse can rely on CXSparse instead, with no change to the
   user code.  The #include "cs.h" line will work for both versions, in user
   code, and the function names and user-visible typedefs from CSparse all
   appear in CXSparse.  For experimenting and changing the package itself, I
   recommend using CSparse since it's simpler and easier to modify.  For
   using the package in production codes, I recommend CXSparse since it has
   more features (support for complex matrices, and both int and long
   versions).
 */

/* ========================================================================== */

#ifndef _CXS_H
#define _CXS_H
#include 
#include 
#include 
#include 
#ifdef MATLAB_MEX_FILE
#include "mex.h"
#endif


#ifdef __cplusplus
#ifndef NCOMPLEX
#include 
typedef std::complex cs_complex_t ;
#endif
extern "C" {
#else
#ifndef NCOMPLEX
#include 
#define cs_complex_t double _Complex
#endif
#endif

#define CS_VER 3                    /* CXSparse Version */
#define CS_SUBVER 2
#define CS_SUBSUB 0
#define CS_DATE "Sept 12, 2017"       /* CSparse release date */
#define CS_COPYRIGHT "Copyright (c) Timothy A. Davis, 2006-2016"
#define CXSPARSE

#include "SuiteSparse_config.h"
#define cs_long_t       SuiteSparse_long
#define cs_long_t_id    SuiteSparse_long_id
#define cs_long_t_max   SuiteSparse_long_max

/* -------------------------------------------------------------------------- */
/* double/int version of CXSparse */
/* -------------------------------------------------------------------------- */

/* --- primary CSparse routines and data structures ------------------------- */

typedef struct cs_di_sparse  /* matrix in compressed-column or triplet form */
{
    int nzmax ;     /* maximum number of entries */
    int m ;         /* number of rows */
    int n ;         /* number of columns */
    int *p ;        /* column pointers (size n+1) or col indices (size nzmax) */
    int *i ;        /* row indices, size nzmax */
    double *x ;     /* numerical values, size nzmax */
    int nz ;        /* # of entries in triplet matrix, -1 for compressed-col */
} cs_di ;

cs_di *cs_di_add (const cs_di *A, const cs_di *B, double alpha, double beta) ;
int cs_di_cholsol (int order, const cs_di *A, double *b) ;
int cs_di_dupl (cs_di *A) ;
int cs_di_entry (cs_di *T, int i, int j, double x) ;
int cs_di_lusol (int order, const cs_di *A, double *b, double tol) ;
int cs_di_gaxpy (const cs_di *A, const double *x, double *y) ;
cs_di *cs_di_multiply (const cs_di *A, const cs_di *B) ;
int cs_di_qrsol (int order, const cs_di *A, double *b) ;
cs_di *cs_di_transpose (const cs_di *A, int values) ;
cs_di *cs_di_compress (const cs_di *T) ;
double cs_di_norm (const cs_di *A) ;
/*int cs_di_print (const cs_di *A, int brief) ;*/
cs_di *cs_di_load (FILE *f) ;

/* utilities */
void *cs_di_calloc (int n, size_t size) ;
void *cs_di_free (void *p) ;
void *cs_di_realloc (void *p, int n, size_t size, int *ok) ;
cs_di *cs_di_spalloc (int m, int n, int nzmax, int values, int t) ;
cs_di *cs_di_spfree (cs_di *A) ;
int cs_di_sprealloc (cs_di *A, int nzmax) ;
void *cs_di_malloc (int n, size_t size) ;

/* --- secondary CSparse routines and data structures ----------------------- */

typedef struct cs_di_symbolic  /* symbolic Cholesky, LU, or QR analysis */
{
    int *pinv ;     /* inverse row perm. for QR, fill red. perm for Chol */
    int *q ;        /* fill-reducing column permutation for LU and QR */
    int *parent ;   /* elimination tree for Cholesky and QR */
    int *cp ;       /* column pointers for Cholesky, row counts for QR */
    int *leftmost ; /* leftmost[i] = min(find(A(i,:))), for QR */
    int m2 ;        /* # of rows for QR, after adding fictitious rows */
    double lnz ;    /* # entries in L for LU or Cholesky; in V for QR */
    double unz ;    /* # entries in U for LU; in R for QR */
} cs_dis ;

typedef struct cs_di_numeric   /* numeric Cholesky, LU, or QR factorization */
{
    cs_di *L ;      /* L for LU and Cholesky, V for QR */
    cs_di *U ;      /* U for LU, r for QR, not used for Cholesky */
    int *pinv ;     /* partial pivoting for LU */
    double *B ;     /* beta [0..n-1] for QR */
} cs_din ;

typedef struct cs_di_dmperm_results    /* cs_di_dmperm or cs_di_scc output */
{
    int *p ;        /* size m, row permutation */
    int *q ;        /* size n, column permutation */
    int *r ;        /* size nb+1, block k is rows r[k] to r[k+1]-1 in A(p,q) */
    int *s ;        /* size nb+1, block k is cols s[k] to s[k+1]-1 in A(p,q) */
    int nb ;        /* # of blocks in fine dmperm decomposition */
    int rr [5] ;    /* coarse row decomposition */
    int cc [5] ;    /* coarse column decomposition */
} cs_did ;

int *cs_di_amd (int order, const cs_di *A) ;
cs_din *cs_di_chol (const cs_di *A, const cs_dis *S) ;
cs_did *cs_di_dmperm (const cs_di *A, int seed) ;
int cs_di_droptol (cs_di *A, double tol) ;
int cs_di_dropzeros (cs_di *A) ;
int cs_di_happly (const cs_di *V, int i, double beta, double *x) ;
int cs_di_ipvec (const int *p, const double *b, double *x, int n) ;
int cs_di_lsolve (const cs_di *L, double *x) ;
int cs_di_ltsolve (const cs_di *L, double *x) ;
cs_din *cs_di_lu (const cs_di *A, const cs_dis *S, double tol) ;
cs_di *cs_di_permute (const cs_di *A, const int *pinv, const int *q,
    int values) ;
int *cs_di_pinv (const int *p, int n) ;
int cs_di_pvec (const int *p, const double *b, double *x, int n) ;
cs_din *cs_di_qr (const cs_di *A, const cs_dis *S) ;
cs_dis *cs_di_schol (int order, const cs_di *A) ;
cs_dis *cs_di_sqr (int order, const cs_di *A, int qr) ;
cs_di *cs_di_symperm (const cs_di *A, const int *pinv, int values) ;
int cs_di_usolve (const cs_di *U, double *x) ;
int cs_di_utsolve (const cs_di *U, double *x) ;
int cs_di_updown (cs_di *L, int sigma, const cs_di *C, const int *parent) ;

/* utilities */
cs_dis *cs_di_sfree (cs_dis *S) ;
cs_din *cs_di_nfree (cs_din *N) ;
cs_did *cs_di_dfree (cs_did *D) ;

/* --- tertiary CSparse routines -------------------------------------------- */

int *cs_di_counts (const cs_di *A, const int *parent, const int *post,
    int ata) ;
double cs_di_cumsum (int *p, int *c, int n) ;
int cs_di_dfs (int j, cs_di *G, int top, int *xi, int *pstack,
    const int *pinv) ;
int *cs_di_etree (const cs_di *A, int ata) ;
int cs_di_fkeep (cs_di *A, int (*fkeep) (int, int, double, void *),
    void *other) ;
double cs_di_house (double *x, double *beta, int n) ;
int *cs_di_maxtrans (const cs_di *A, int seed) ;
int *cs_di_post (const int *parent, int n) ;
cs_did *cs_di_scc (cs_di *A) ;
int cs_di_scatter (const cs_di *A, int j, double beta, int *w, double *x,
    int mark, cs_di *C, int nz) ;
int cs_di_tdfs (int j, int k, int *head, const int *next, int *post,
    int *stack) ;
int cs_di_leaf (int i, int j, const int *first, int *maxfirst, int *prevleaf,
    int *ancestor, int *jleaf) ;
int cs_di_reach (cs_di *G, const cs_di *B, int k, int *xi, const int *pinv) ;
int cs_di_spsolve (cs_di *L, const cs_di *B, int k, int *xi, double *x,
    const int *pinv, int lo) ;
int cs_di_ereach (const cs_di *A, int k, const int *parent, int *s, int *w) ;
int *cs_di_randperm (int n, int seed) ;

/* utilities */
cs_did *cs_di_dalloc (int m, int n) ;
cs_di *cs_di_done (cs_di *C, void *w, void *x, int ok) ;
int *cs_di_idone (int *p, cs_di *C, void *w, int ok) ;
cs_din *cs_di_ndone (cs_din *N, cs_di *C, void *w, void *x, int ok) ;
cs_did *cs_di_ddone (cs_did *D, cs_di *C, void *w, int ok) ;


/* -------------------------------------------------------------------------- */
/* double/cs_long_t version of CXSparse */
/* -------------------------------------------------------------------------- */

/* --- primary CSparse routines and data structures ------------------------- */

typedef struct cs_dl_sparse  /* matrix in compressed-column or triplet form */
{
    cs_long_t nzmax ; /* maximum number of entries */
    cs_long_t m ;     /* number of rows */
    cs_long_t n ;     /* number of columns */
    cs_long_t *p ;    /* column pointers (size n+1) or col indlces (size nzmax) */
    cs_long_t *i ;    /* row indices, size nzmax */
    double *x ;     /* numerical values, size nzmax */
    cs_long_t nz ;    /* # of entries in triplet matrix, -1 for compressed-col */
} cs_dl ;

cs_dl *cs_dl_add (const cs_dl *A, const cs_dl *B, double alpha, double beta) ;
cs_long_t cs_dl_cholsol (cs_long_t order, const cs_dl *A, double *b) ;
cs_long_t cs_dl_dupl (cs_dl *A) ;
cs_long_t cs_dl_entry (cs_dl *T, cs_long_t i, cs_long_t j, double x) ;
cs_long_t cs_dl_lusol (cs_long_t order, const cs_dl *A, double *b, double tol) ;
cs_long_t cs_dl_gaxpy (const cs_dl *A, const double *x, double *y) ;
cs_dl *cs_dl_multiply (const cs_dl *A, const cs_dl *B) ;
cs_long_t cs_dl_qrsol (cs_long_t order, const cs_dl *A, double *b) ;
cs_dl *cs_dl_transpose (const cs_dl *A, cs_long_t values) ;
cs_dl *cs_dl_compress (const cs_dl *T) ;
double cs_dl_norm (const cs_dl *A) ;
/*cs_long_t cs_dl_print (const cs_dl *A, cs_long_t brief) ;*/
cs_dl *cs_dl_load (FILE *f) ;

/* utilities */
void *cs_dl_calloc (cs_long_t n, size_t size) ;
void *cs_dl_free (void *p) ;
void *cs_dl_realloc (void *p, cs_long_t n, size_t size, cs_long_t *ok) ;
cs_dl *cs_dl_spalloc (cs_long_t m, cs_long_t n, cs_long_t nzmax, cs_long_t values,
    cs_long_t t) ;
cs_dl *cs_dl_spfree (cs_dl *A) ;
cs_long_t cs_dl_sprealloc (cs_dl *A, cs_long_t nzmax) ;
void *cs_dl_malloc (cs_long_t n, size_t size) ;

/* --- secondary CSparse routines and data structures ----------------------- */

typedef struct cs_dl_symbolic  /* symbolic Cholesky, LU, or QR analysis */
{
    cs_long_t *pinv ;     /* inverse row perm. for QR, fill red. perm for Chol */
    cs_long_t *q ;        /* fill-reducing column permutation for LU and QR */
    cs_long_t *parent ;   /* elimination tree for Cholesky and QR */
    cs_long_t *cp ;       /* column pointers for Cholesky, row counts for QR */
    cs_long_t *leftmost ; /* leftmost[i] = min(find(A(i,:))), for QR */
    cs_long_t m2 ;        /* # of rows for QR, after adding fictitious rows */
    double lnz ;        /* # entries in L for LU or Cholesky; in V for QR */
    double unz ;        /* # entries in U for LU; in R for QR */
} cs_dls ;

typedef struct cs_dl_numeric   /* numeric Cholesky, LU, or QR factorization */
{
    cs_dl *L ;      /* L for LU and Cholesky, V for QR */
    cs_dl *U ;      /* U for LU, r for QR, not used for Cholesky */
    cs_long_t *pinv ; /* partial pivoting for LU */
    double *B ;     /* beta [0..n-1] for QR */
} cs_dln ;

typedef struct cs_dl_dmperm_results    /* cs_dl_dmperm or cs_dl_scc output */
{
    cs_long_t *p ;    /* size m, row permutation */
    cs_long_t *q ;    /* size n, column permutation */
    cs_long_t *r ;    /* size nb+1, block k is rows r[k] to r[k+1]-1 in A(p,q) */
    cs_long_t *s ;    /* size nb+1, block k is cols s[k] to s[k+1]-1 in A(p,q) */
    cs_long_t nb ;    /* # of blocks in fine dmperm decomposition */
    cs_long_t rr [5] ;    /* coarse row decomposition */
    cs_long_t cc [5] ;    /* coarse column decomposition */
} cs_dld ;

cs_long_t *cs_dl_amd (cs_long_t order, const cs_dl *A) ;
cs_dln *cs_dl_chol (const cs_dl *A, const cs_dls *S) ;
cs_dld *cs_dl_dmperm (const cs_dl *A, cs_long_t seed) ;
cs_long_t cs_dl_droptol (cs_dl *A, double tol) ;
cs_long_t cs_dl_dropzeros (cs_dl *A) ;
cs_long_t cs_dl_happly (const cs_dl *V, cs_long_t i, double beta, double *x) ;
cs_long_t cs_dl_ipvec (const cs_long_t *p, const double *b, double *x, cs_long_t n) ;
cs_long_t cs_dl_lsolve (const cs_dl *L, double *x) ;
cs_long_t cs_dl_ltsolve (const cs_dl *L, double *x) ;
cs_dln *cs_dl_lu (const cs_dl *A, const cs_dls *S, double tol) ;
cs_dl *cs_dl_permute (const cs_dl *A, const cs_long_t *pinv, const cs_long_t *q,
    cs_long_t values) ;
cs_long_t *cs_dl_pinv (const cs_long_t *p, cs_long_t n) ;
cs_long_t cs_dl_pvec (const cs_long_t *p, const double *b, double *x, cs_long_t n) ;
cs_dln *cs_dl_qr (const cs_dl *A, const cs_dls *S) ;
cs_dls *cs_dl_schol (cs_long_t order, const cs_dl *A) ;
cs_dls *cs_dl_sqr (cs_long_t order, const cs_dl *A, cs_long_t qr) ;
cs_dl *cs_dl_symperm (const cs_dl *A, const cs_long_t *pinv, cs_long_t values) ;
cs_long_t cs_dl_usolve (const cs_dl *U, double *x) ;
cs_long_t cs_dl_utsolve (const cs_dl *U, double *x) ;
cs_long_t cs_dl_updown (cs_dl *L, cs_long_t sigma, const cs_dl *C,
    const cs_long_t *parent) ;

/* utilities */
cs_dls *cs_dl_sfree (cs_dls *S) ;
cs_dln *cs_dl_nfree (cs_dln *N) ;
cs_dld *cs_dl_dfree (cs_dld *D) ;

/* --- tertiary CSparse routines -------------------------------------------- */

cs_long_t *cs_dl_counts (const cs_dl *A, const cs_long_t *parent,
    const cs_long_t *post, cs_long_t ata) ;
double cs_dl_cumsum (cs_long_t *p, cs_long_t *c, cs_long_t n) ;
cs_long_t cs_dl_dfs (cs_long_t j, cs_dl *G, cs_long_t top, cs_long_t *xi,
    cs_long_t *pstack, const cs_long_t *pinv) ;
cs_long_t *cs_dl_etree (const cs_dl *A, cs_long_t ata) ;
cs_long_t cs_dl_fkeep (cs_dl *A,
    cs_long_t (*fkeep) (cs_long_t, cs_long_t, double, void *), void *other) ;
double cs_dl_house (double *x, double *beta, cs_long_t n) ;
cs_long_t *cs_dl_maxtrans (const cs_dl *A, cs_long_t seed) ;
cs_long_t *cs_dl_post (const cs_long_t *parent, cs_long_t n) ;
cs_dld *cs_dl_scc (cs_dl *A) ;
cs_long_t cs_dl_scatter (const cs_dl *A, cs_long_t j, double beta, cs_long_t *w,
    double *x, cs_long_t mark,cs_dl *C, cs_long_t nz) ;
cs_long_t cs_dl_tdfs (cs_long_t j, cs_long_t k, cs_long_t *head, const cs_long_t *next,
    cs_long_t *post, cs_long_t *stack) ;
cs_long_t cs_dl_leaf (cs_long_t i, cs_long_t j, const cs_long_t *first,
    cs_long_t *maxfirst, cs_long_t *prevleaf, cs_long_t *ancestor, cs_long_t *jleaf) ;
cs_long_t cs_dl_reach (cs_dl *G, const cs_dl *B, cs_long_t k, cs_long_t *xi,
    const cs_long_t *pinv) ;
cs_long_t cs_dl_spsolve (cs_dl *L, const cs_dl *B, cs_long_t k, cs_long_t *xi,
    double *x, const cs_long_t *pinv, cs_long_t lo) ;
cs_long_t cs_dl_ereach (const cs_dl *A, cs_long_t k, const cs_long_t *parent,
    cs_long_t *s, cs_long_t *w) ;
cs_long_t *cs_dl_randperm (cs_long_t n, cs_long_t seed) ;

/* utilities */
cs_dld *cs_dl_dalloc (cs_long_t m, cs_long_t n) ;
cs_dl *cs_dl_done (cs_dl *C, void *w, void *x, cs_long_t ok) ;
cs_long_t *cs_dl_idone (cs_long_t *p, cs_dl *C, void *w, cs_long_t ok) ;
cs_dln *cs_dl_ndone (cs_dln *N, cs_dl *C, void *w, void *x, cs_long_t ok) ;
cs_dld *cs_dl_ddone (cs_dld *D, cs_dl *C, void *w, cs_long_t ok) ;


/* -------------------------------------------------------------------------- */
/* complex/int version of CXSparse */
/* -------------------------------------------------------------------------- */

#ifndef NCOMPLEX

/* --- primary CSparse routines and data structures ------------------------- */

typedef struct cs_ci_sparse  /* matrix in compressed-column or triplet form */
{
    int nzmax ;     /* maximum number of entries */
    int m ;         /* number of rows */
    int n ;         /* number of columns */
    int *p ;        /* column pointers (size n+1) or col indices (size nzmax) */
    int *i ;        /* row indices, size nzmax */
    cs_complex_t *x ;    /* numerical values, size nzmax */
    int nz ;        /* # of entries in triplet matrix, -1 for compressed-col */
} cs_ci ;

cs_ci *cs_ci_add (const cs_ci *A, const cs_ci *B, cs_complex_t alpha,
    cs_complex_t beta) ;
int cs_ci_cholsol (int order, const cs_ci *A, cs_complex_t *b) ;
int cs_ci_dupl (cs_ci *A) ;
int cs_ci_entry (cs_ci *T, int i, int j, cs_complex_t x) ;
int cs_ci_lusol (int order, const cs_ci *A, cs_complex_t *b, double tol) ;
int cs_ci_gaxpy (const cs_ci *A, const cs_complex_t *x, cs_complex_t *y) ;
cs_ci *cs_ci_multiply (const cs_ci *A, const cs_ci *B) ;
int cs_ci_qrsol (int order, const cs_ci *A, cs_complex_t *b) ;
cs_ci *cs_ci_transpose (const cs_ci *A, int values) ;
cs_ci *cs_ci_compress (const cs_ci *T) ;
double cs_ci_norm (const cs_ci *A) ;
/*int cs_ci_print (const cs_ci *A, int brief) ;*/
cs_ci *cs_ci_load (FILE *f) ;

/* utilities */
void *cs_ci_calloc (int n, size_t size) ;
void *cs_ci_free (void *p) ;
void *cs_ci_realloc (void *p, int n, size_t size, int *ok) ;
cs_ci *cs_ci_spalloc (int m, int n, int nzmax, int values, int t) ;
cs_ci *cs_ci_spfree (cs_ci *A) ;
int cs_ci_sprealloc (cs_ci *A, int nzmax) ;
void *cs_ci_malloc (int n, size_t size) ;

/* --- secondary CSparse routines and data structures ----------------------- */

typedef struct cs_ci_symbolic  /* symbolic Cholesky, LU, or QR analysis */
{
    int *pinv ;     /* inverse row perm. for QR, fill red. perm for Chol */
    int *q ;        /* fill-reducing column permutation for LU and QR */
    int *parent ;   /* elimination tree for Cholesky and QR */
    int *cp ;       /* column pointers for Cholesky, row counts for QR */
    int *leftmost ; /* leftmost[i] = min(find(A(i,:))), for QR */
    int m2 ;        /* # of rows for QR, after adding fictitious rows */
    double lnz ;    /* # entries in L for LU or Cholesky; in V for QR */
    double unz ;    /* # entries in U for LU; in R for QR */
} cs_cis ;

typedef struct cs_ci_numeric   /* numeric Cholesky, LU, or QR factorization */
{
    cs_ci *L ;      /* L for LU and Cholesky, V for QR */
    cs_ci *U ;      /* U for LU, r for QR, not used for Cholesky */
    int *pinv ;     /* partial pivoting for LU */
    double *B ;     /* beta [0..n-1] for QR */
} cs_cin ;

typedef struct cs_ci_dmperm_results    /* cs_ci_dmperm or cs_ci_scc output */
{
    int *p ;        /* size m, row permutation */
    int *q ;        /* size n, column permutation */
    int *r ;        /* size nb+1, block k is rows r[k] to r[k+1]-1 in A(p,q) */
    int *s ;        /* size nb+1, block k is cols s[k] to s[k+1]-1 in A(p,q) */
    int nb ;        /* # of blocks in fine dmperm decomposition */
    int rr [5] ;    /* coarse row decomposition */
    int cc [5] ;    /* coarse column decomposition */
} cs_cid ;

int *cs_ci_amd (int order, const cs_ci *A) ;
cs_cin *cs_ci_chol (const cs_ci *A, const cs_cis *S) ;
cs_cid *cs_ci_dmperm (const cs_ci *A, int seed) ;
int cs_ci_droptol (cs_ci *A, double tol) ;
int cs_ci_dropzeros (cs_ci *A) ;
int cs_ci_happly (const cs_ci *V, int i, double beta, cs_complex_t *x) ;
int cs_ci_ipvec (const int *p, const cs_complex_t *b, cs_complex_t *x, int n) ;
int cs_ci_lsolve (const cs_ci *L, cs_complex_t *x) ;
int cs_ci_ltsolve (const cs_ci *L, cs_complex_t *x) ;
cs_cin *cs_ci_lu (const cs_ci *A, const cs_cis *S, double tol) ;
cs_ci *cs_ci_permute (const cs_ci *A, const int *pinv, const int *q,
    int values) ;
int *cs_ci_pinv (const int *p, int n) ;
int cs_ci_pvec (const int *p, const cs_complex_t *b, cs_complex_t *x, int n) ;
cs_cin *cs_ci_qr (const cs_ci *A, const cs_cis *S) ;
cs_cis *cs_ci_schol (int order, const cs_ci *A) ;
cs_cis *cs_ci_sqr (int order, const cs_ci *A, int qr) ;
cs_ci *cs_ci_symperm (const cs_ci *A, const int *pinv, int values) ;
int cs_ci_usolve (const cs_ci *U, cs_complex_t *x) ;
int cs_ci_utsolve (const cs_ci *U, cs_complex_t *x) ;
int cs_ci_updown (cs_ci *L, int sigma, const cs_ci *C, const int *parent) ;

/* utilities */
cs_cis *cs_ci_sfree (cs_cis *S) ;
cs_cin *cs_ci_nfree (cs_cin *N) ;
cs_cid *cs_ci_dfree (cs_cid *D) ;

/* --- tertiary CSparse routines -------------------------------------------- */

int *cs_ci_counts (const cs_ci *A, const int *parent, const int *post,
    int ata) ;
double cs_ci_cumsum (int *p, int *c, int n) ;
int cs_ci_dfs (int j, cs_ci *G, int top, int *xi, int *pstack,
    const int *pinv) ;
int *cs_ci_etree (const cs_ci *A, int ata) ;
int cs_ci_fkeep (cs_ci *A, int (*fkeep) (int, int, cs_complex_t, void *),
    void *other) ;
cs_complex_t cs_ci_house (cs_complex_t *x, double *beta, int n) ;
int *cs_ci_maxtrans (const cs_ci *A, int seed) ;
int *cs_ci_post (const int *parent, int n) ;
cs_cid *cs_ci_scc (cs_ci *A) ;
int cs_ci_scatter (const cs_ci *A, int j, cs_complex_t beta, int *w, 
    cs_complex_t *x, int mark,cs_ci *C, int nz) ;
int cs_ci_tdfs (int j, int k, int *head, const int *next, int *post,
    int *stack) ;
int cs_ci_leaf (int i, int j, const int *first, int *maxfirst, int *prevleaf,
    int *ancestor, int *jleaf) ;
int cs_ci_reach (cs_ci *G, const cs_ci *B, int k, int *xi, const int *pinv) ;
int cs_ci_spsolve (cs_ci *L, const cs_ci *B, int k, int *xi, 
    cs_complex_t *x, const int *pinv, int lo) ;
int cs_ci_ereach (const cs_ci *A, int k, const int *parent, int *s, int *w) ;
int *cs_ci_randperm (int n, int seed) ;

/* utilities */
cs_cid *cs_ci_dalloc (int m, int n) ;
cs_ci *cs_ci_done (cs_ci *C, void *w, void *x, int ok) ;
int *cs_ci_idone (int *p, cs_ci *C, void *w, int ok) ;
cs_cin *cs_ci_ndone (cs_cin *N, cs_ci *C, void *w, void *x, int ok) ;
cs_cid *cs_ci_ddone (cs_cid *D, cs_ci *C, void *w, int ok) ;


/* -------------------------------------------------------------------------- */
/* complex/cs_long_t version of CXSparse */
/* -------------------------------------------------------------------------- */

/* --- primary CSparse routines and data structures ------------------------- */

typedef struct cs_cl_sparse  /* matrix in compressed-column or triplet form */
{
    cs_long_t nzmax ; /* maximum number of entries */
    cs_long_t m ;     /* number of rows */
    cs_long_t n ;     /* number of columns */
    cs_long_t *p ;    /* column pointers (size n+1) or col indlces (size nzmax) */
    cs_long_t *i ;    /* row indices, size nzmax */
    cs_complex_t *x ;    /* numerical values, size nzmax */
    cs_long_t nz ;    /* # of entries in triplet matrix, -1 for compressed-col */
} cs_cl ;

cs_cl *cs_cl_add (const cs_cl *A, const cs_cl *B, cs_complex_t alpha,
    cs_complex_t beta) ;
cs_long_t cs_cl_cholsol (cs_long_t order, const cs_cl *A, cs_complex_t *b) ;
cs_long_t cs_cl_dupl (cs_cl *A) ;
cs_long_t cs_cl_entry (cs_cl *T, cs_long_t i, cs_long_t j, cs_complex_t x) ;
cs_long_t cs_cl_lusol (cs_long_t order, const cs_cl *A, cs_complex_t *b,
    double tol) ;
cs_long_t cs_cl_gaxpy (const cs_cl *A, const cs_complex_t *x, cs_complex_t *y) ;
cs_cl *cs_cl_multiply (const cs_cl *A, const cs_cl *B) ;
cs_long_t cs_cl_qrsol (cs_long_t order, const cs_cl *A, cs_complex_t *b) ;
cs_cl *cs_cl_transpose (const cs_cl *A, cs_long_t values) ;
cs_cl *cs_cl_compress (const cs_cl *T) ;
double cs_cl_norm (const cs_cl *A) ;
/*cs_long_t cs_cl_print (const cs_cl *A, cs_long_t brief) ;*/
cs_cl *cs_cl_load (FILE *f) ;

/* utilities */
void *cs_cl_calloc (cs_long_t n, size_t size) ;
void *cs_cl_free (void *p) ;
void *cs_cl_realloc (void *p, cs_long_t n, size_t size, cs_long_t *ok) ;
cs_cl *cs_cl_spalloc (cs_long_t m, cs_long_t n, cs_long_t nzmax, cs_long_t values,
    cs_long_t t) ;
cs_cl *cs_cl_spfree (cs_cl *A) ;
cs_long_t cs_cl_sprealloc (cs_cl *A, cs_long_t nzmax) ;
void *cs_cl_malloc (cs_long_t n, size_t size) ;

/* --- secondary CSparse routines and data structures ----------------------- */

typedef struct cs_cl_symbolic  /* symbolic Cholesky, LU, or QR analysis */
{
    cs_long_t *pinv ;     /* inverse row perm. for QR, fill red. perm for Chol */
    cs_long_t *q ;        /* fill-reducing column permutation for LU and QR */
    cs_long_t *parent ;   /* elimination tree for Cholesky and QR */
    cs_long_t *cp ;       /* column pointers for Cholesky, row counts for QR */
    cs_long_t *leftmost ; /* leftmost[i] = min(find(A(i,:))), for QR */
    cs_long_t m2 ;        /* # of rows for QR, after adding fictitious rows */
    double lnz ;        /* # entries in L for LU or Cholesky; in V for QR */
    double unz ;        /* # entries in U for LU; in R for QR */
} cs_cls ;

typedef struct cs_cl_numeric   /* numeric Cholesky, LU, or QR factorization */
{
    cs_cl *L ;          /* L for LU and Cholesky, V for QR */
    cs_cl *U ;          /* U for LU, r for QR, not used for Cholesky */
    cs_long_t *pinv ;     /* partial pivoting for LU */
    double *B ;         /* beta [0..n-1] for QR */
} cs_cln ;

typedef struct cs_cl_dmperm_results    /* cs_cl_dmperm or cs_cl_scc output */
{
    cs_long_t *p ;    /* size m, row permutation */
    cs_long_t *q ;    /* size n, column permutation */
    cs_long_t *r ;    /* size nb+1, block k is rows r[k] to r[k+1]-1 in A(p,q) */
    cs_long_t *s ;    /* size nb+1, block k is cols s[k] to s[k+1]-1 in A(p,q) */
    cs_long_t nb ;    /* # of blocks in fine dmperm decomposition */
    cs_long_t rr [5] ;   /* coarse row decomposition */
    cs_long_t cc [5] ;   /* coarse column decomposition */
} cs_cld ;

cs_long_t *cs_cl_amd (cs_long_t order, const cs_cl *A) ;
cs_cln *cs_cl_chol (const cs_cl *A, const cs_cls *S) ;
cs_cld *cs_cl_dmperm (const cs_cl *A, cs_long_t seed) ;
cs_long_t cs_cl_droptol (cs_cl *A, double tol) ;
cs_long_t cs_cl_dropzeros (cs_cl *A) ;
cs_long_t cs_cl_happly (const cs_cl *V, cs_long_t i, double beta, cs_complex_t *x) ;
cs_long_t cs_cl_ipvec (const cs_long_t *p, const cs_complex_t *b,
    cs_complex_t *x, cs_long_t n) ;
cs_long_t cs_cl_lsolve (const cs_cl *L, cs_complex_t *x) ;
cs_long_t cs_cl_ltsolve (const cs_cl *L, cs_complex_t *x) ;
cs_cln *cs_cl_lu (const cs_cl *A, const cs_cls *S, double tol) ;
cs_cl *cs_cl_permute (const cs_cl *A, const cs_long_t *pinv, const cs_long_t *q,
    cs_long_t values) ;
cs_long_t *cs_cl_pinv (const cs_long_t *p, cs_long_t n) ;
cs_long_t cs_cl_pvec (const cs_long_t *p, const cs_complex_t *b,
    cs_complex_t *x, cs_long_t n) ;
cs_cln *cs_cl_qr (const cs_cl *A, const cs_cls *S) ;
cs_cls *cs_cl_schol (cs_long_t order, const cs_cl *A) ;
cs_cls *cs_cl_sqr (cs_long_t order, const cs_cl *A, cs_long_t qr) ;
cs_cl *cs_cl_symperm (const cs_cl *A, const cs_long_t *pinv, cs_long_t values) ;
cs_long_t cs_cl_usolve (const cs_cl *U, cs_complex_t *x) ;
cs_long_t cs_cl_utsolve (const cs_cl *U, cs_complex_t *x) ;
cs_long_t cs_cl_updown (cs_cl *L, cs_long_t sigma, const cs_cl *C,
    const cs_long_t *parent) ;

/* utilities */
cs_cls *cs_cl_sfree (cs_cls *S) ;
cs_cln *cs_cl_nfree (cs_cln *N) ;
cs_cld *cs_cl_dfree (cs_cld *D) ;

/* --- tertiary CSparse routines -------------------------------------------- */

cs_long_t *cs_cl_counts (const cs_cl *A, const cs_long_t *parent,
    const cs_long_t *post, cs_long_t ata) ;
double cs_cl_cumsum (cs_long_t *p, cs_long_t *c, cs_long_t n) ;
cs_long_t cs_cl_dfs (cs_long_t j, cs_cl *G, cs_long_t top, cs_long_t *xi,
    cs_long_t *pstack, const cs_long_t *pinv) ;
cs_long_t *cs_cl_etree (const cs_cl *A, cs_long_t ata) ;
cs_long_t cs_cl_fkeep (cs_cl *A,
    cs_long_t (*fkeep) (cs_long_t, cs_long_t, cs_complex_t, void *), void *other) ;
cs_complex_t cs_cl_house (cs_complex_t *x, double *beta, cs_long_t n) ;
cs_long_t *cs_cl_maxtrans (const cs_cl *A, cs_long_t seed) ;
cs_long_t *cs_cl_post (const cs_long_t *parent, cs_long_t n) ;
cs_cld *cs_cl_scc (cs_cl *A) ;
cs_long_t cs_cl_scatter (const cs_cl *A, cs_long_t j, cs_complex_t beta,
    cs_long_t *w, cs_complex_t *x, cs_long_t mark,cs_cl *C, cs_long_t nz) ;
cs_long_t cs_cl_tdfs (cs_long_t j, cs_long_t k, cs_long_t *head, const cs_long_t *next,
    cs_long_t *post, cs_long_t *stack) ;
cs_long_t cs_cl_leaf (cs_long_t i, cs_long_t j, const cs_long_t *first,
    cs_long_t *maxfirst, cs_long_t *prevleaf, cs_long_t *ancestor, cs_long_t *jleaf) ;
cs_long_t cs_cl_reach (cs_cl *G, const cs_cl *B, cs_long_t k, cs_long_t *xi,
    const cs_long_t *pinv) ;
cs_long_t cs_cl_spsolve (cs_cl *L, const cs_cl *B, cs_long_t k, cs_long_t *xi, 
    cs_complex_t *x, const cs_long_t *pinv, cs_long_t lo) ;
cs_long_t cs_cl_ereach (const cs_cl *A, cs_long_t k, const cs_long_t *parent,
    cs_long_t *s, cs_long_t *w) ;
cs_long_t *cs_cl_randperm (cs_long_t n, cs_long_t seed) ;

/* utilities */
cs_cld *cs_cl_dalloc (cs_long_t m, cs_long_t n) ;
cs_cl *cs_cl_done (cs_cl *C, void *w, void *x, cs_long_t ok) ;
cs_long_t *cs_cl_idone (cs_long_t *p, cs_cl *C, void *w, cs_long_t ok) ;
cs_cln *cs_cl_ndone (cs_cln *N, cs_cl *C, void *w, void *x, cs_long_t ok) ;
cs_cld *cs_cl_ddone (cs_cld *D, cs_cl *C, void *w, cs_long_t ok) ;

#endif

/* -------------------------------------------------------------------------- */
/* Macros for constructing each version of CSparse */
/* -------------------------------------------------------------------------- */

#ifdef CS_LONG
#define CS_INT cs_long_t
#define CS_INT_MAX cs_long_t_max
#define CS_ID cs_long_t_id
#ifdef CS_COMPLEX
#define CS_ENTRY cs_complex_t
#define CS_NAME(nm) cs_cl ## nm
#define cs cs_cl
#else
#define CS_ENTRY double
#define CS_NAME(nm) cs_dl ## nm
#define cs cs_dl
#endif
#else
#define CS_INT int
#define CS_INT_MAX INT_MAX
#define CS_ID "%d"
#ifdef CS_COMPLEX
#define CS_ENTRY cs_complex_t
#define CS_NAME(nm) cs_ci ## nm
#define cs cs_ci
#else
#define CS_ENTRY double
#define CS_NAME(nm) cs_di ## nm
#define cs cs_di
#endif
#endif

#ifdef CS_COMPLEX
#define CS_REAL(x) creal(x)
#define CS_IMAG(x) cimag(x)
#define CS_CONJ(x) conj(x)
#define CS_ABS(x) cabs(x)
#else
#define CS_REAL(x) (x)
#define CS_IMAG(x) (0.)
#define CS_CONJ(x) (x)
#define CS_ABS(x) fabs(x)
#endif

#define CS_MAX(a,b) (((a) > (b)) ? (a) : (b))
#define CS_MIN(a,b) (((a) < (b)) ? (a) : (b))
#define CS_FLIP(i) (-(i)-2)
#define CS_UNFLIP(i) (((i) < 0) ? CS_FLIP(i) : (i))
#define CS_MARKED(w,j) (w [j] < 0)
#define CS_MARK(w,j) { w [j] = CS_FLIP (w [j]) ; }
#define CS_CSC(A) (A && (A->nz == -1))
#define CS_TRIPLET(A) (A && (A->nz >= 0))

/* --- primary CSparse routines and data structures ------------------------- */

#define cs_add CS_NAME (_add)
#define cs_cholsol CS_NAME (_cholsol)
#define cs_dupl CS_NAME (_dupl)
#define cs_entry CS_NAME (_entry)
#define cs_lusol CS_NAME (_lusol)
#define cs_gaxpy CS_NAME (_gaxpy)
#define cs_multiply CS_NAME (_multiply)
#define cs_qrsol CS_NAME (_qrsol)
#define cs_transpose CS_NAME (_transpose)
#define cs_compress CS_NAME (_compress)
#define cs_norm CS_NAME (_norm)
/*#define cs_print CS_NAME (_print)*/
#define cs_load CS_NAME (_load)

/* utilities */
#define cs_calloc CS_NAME (_calloc)
#define cs_free CS_NAME (_free)
#define cs_realloc CS_NAME (_realloc)
#define cs_spalloc CS_NAME (_spalloc)
#define cs_spfree CS_NAME (_spfree)
#define cs_sprealloc CS_NAME (_sprealloc)
#define cs_malloc CS_NAME (_malloc)

/* --- secondary CSparse routines and data structures ----------------------- */
#define css CS_NAME (s)
#define csn CS_NAME (n)
#define csd CS_NAME (d)

#define cs_amd CS_NAME (_amd)
#define cs_chol CS_NAME (_chol)
#define cs_dmperm CS_NAME (_dmperm)
#define cs_droptol CS_NAME (_droptol)
#define cs_dropzeros CS_NAME (_dropzeros)
#define cs_happly CS_NAME (_happly)
#define cs_ipvec CS_NAME (_ipvec)
#define cs_lsolve CS_NAME (_lsolve)
#define cs_ltsolve CS_NAME (_ltsolve)
#define cs_lu CS_NAME (_lu)
#define cs_permute CS_NAME (_permute)
#define cs_pinv CS_NAME (_pinv)
#define cs_pvec CS_NAME (_pvec)
#define cs_qr CS_NAME (_qr)
#define cs_schol CS_NAME (_schol)
#define cs_sqr CS_NAME (_sqr)
#define cs_symperm CS_NAME (_symperm)
#define cs_usolve CS_NAME (_usolve)
#define cs_utsolve CS_NAME (_utsolve)
#define cs_updown CS_NAME (_updown)

/* utilities */
#define cs_sfree CS_NAME (_sfree)
#define cs_nfree CS_NAME (_nfree)
#define cs_dfree CS_NAME (_dfree)

/* --- tertiary CSparse routines -------------------------------------------- */
#define cs_counts CS_NAME (_counts)
#define cs_cumsum CS_NAME (_cumsum)
#define cs_dfs CS_NAME (_dfs)
#define cs_etree CS_NAME (_etree)
#define cs_fkeep CS_NAME (_fkeep)
#define cs_house CS_NAME (_house)
#define cs_invmatch CS_NAME (_invmatch)
#define cs_maxtrans CS_NAME (_maxtrans)
#define cs_post CS_NAME (_post)
#define cs_scc CS_NAME (_scc)
#define cs_scatter CS_NAME (_scatter)
#define cs_tdfs CS_NAME (_tdfs)
#define cs_reach CS_NAME (_reach)
#define cs_spsolve CS_NAME (_spsolve)
#define cs_ereach CS_NAME (_ereach)
#define cs_randperm CS_NAME (_randperm)
#define cs_leaf CS_NAME (_leaf)

/* utilities */
#define cs_dalloc CS_NAME (_dalloc)
#define cs_done CS_NAME (_done)
#define cs_idone CS_NAME (_idone)
#define cs_ndone CS_NAME (_ndone)
#define cs_ddone CS_NAME (_ddone)

/* -------------------------------------------------------------------------- */
/* Conversion routines */
/* -------------------------------------------------------------------------- */

#ifndef NCOMPLEX
cs_di *cs_i_real (cs_ci *A, int real) ;
cs_ci *cs_i_complex (cs_di *A, int real) ;
cs_dl *cs_l_real (cs_cl *A, cs_long_t real) ;
cs_cl *cs_l_complex (cs_dl *A, cs_long_t real) ;
#endif

#ifdef __cplusplus
}
#endif
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_add.c0000644000175100001710000000261300000000000023137 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = alpha*A + beta*B */
cs *cs_add (const cs *A, const cs *B, CS_ENTRY alpha, CS_ENTRY beta)
{
    CS_INT p, j, nz = 0, anz, *Cp, *Ci, *Bp, m, n, bnz, *w, values ;
    CS_ENTRY *x, *Bx, *Cx ;
    cs *C ;
    if (!CS_CSC (A) || !CS_CSC (B)) return (NULL) ;         /* check inputs */
    if (A->m != B->m || A->n != B->n) return (NULL) ;
    m = A->m ; anz = A->p [A->n] ;
    n = B->n ; Bp = B->p ; Bx = B->x ; bnz = Bp [n] ;
    w = cs_calloc (m, sizeof (CS_INT)) ;                       /* get workspace */
    values = (A->x != NULL) && (Bx != NULL) ;
    x = values ? cs_malloc (m, sizeof (CS_ENTRY)) : NULL ;    /* get workspace */
    C = cs_spalloc (m, n, anz + bnz, values, 0) ;           /* allocate result*/
    if (!C || !w || (values && !x)) return (cs_done (C, w, x, 0)) ;
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (j = 0 ; j < n ; j++)
    {
        Cp [j] = nz ;                   /* column j of C starts here */
        nz = cs_scatter (A, j, alpha, w, x, j+1, C, nz) ;   /* alpha*A(:,j)*/
        nz = cs_scatter (B, j, beta, w, x, j+1, C, nz) ;    /* beta*B(:,j) */
        if (values) for (p = Cp [j] ; p < nz ; p++) Cx [p] = x [Ci [p]] ;
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    cs_sprealloc (C, 0) ;               /* remove extra space from C */
    return (cs_done (C, w, x, 1)) ;     /* success; free workspace, return C */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_amd.c0000644000175100001710000004020200000000000023144 0ustar00runnerdocker00000000000000#include "cs.h"
/* clear w */
static CS_INT cs_wclear (CS_INT mark, CS_INT lemax, CS_INT *w, CS_INT n)
{
    CS_INT k ;
    if (mark < 2 || (mark + lemax < 0))
    {
        for (k = 0 ; k < n ; k++) if (w [k] != 0) w [k] = 1 ;
        mark = 2 ;
    }
    return (mark) ;     /* at this point, w [0..n-1] < mark holds */
}

/* keep off-diagonal entries; drop diagonal entries */
static CS_INT cs_diag (CS_INT i, CS_INT j, CS_ENTRY aij, void *other) { return (i != j) ; }

/* p = amd(A+A') if symmetric is true, or amd(A'A) otherwise */
CS_INT *cs_amd (CS_INT order, const cs *A)  /* order 0:natural, 1:Chol, 2:LU, 3:QR */
{
    cs *C, *A2, *AT ;
    CS_INT *Cp, *Ci, *last, *W, *len, *nv, *next, *P, *head, *elen, *degree, *w,
        *hhead, *ATp, *ATi, d, dk, dext, lemax = 0, e, elenk, eln, i, j, k, k1,
        k2, k3, jlast, ln, dense, nzmax, mindeg = 0, nvi, nvj, nvk, mark, wnvi,
        ok, cnz, nel = 0, p, p1, p2, p3, p4, pj, pk, pk1, pk2, pn, q, n, m, t ;
    CS_INT h ;
    /* --- Construct matrix C ----------------------------------------------- */
    if (!CS_CSC (A) || order <= 0 || order > 3) return (NULL) ; /* check */
    AT = cs_transpose (A, 0) ;              /* compute A' */
    if (!AT) return (NULL) ;
    m = A->m ; n = A->n ;
    dense = CS_MAX (16, 10 * sqrt ((double) n)) ;   /* find dense threshold */
    dense = CS_MIN (n-2, dense) ;
    if (order == 1 && n == m)
    {
        C = cs_add (A, AT, 0, 0) ;          /* C = A+A' */
    }
    else if (order == 2)
    {
        ATp = AT->p ;                       /* drop dense columns from AT */
        ATi = AT->i ;
        for (p2 = 0, j = 0 ; j < m ; j++)
        {
            p = ATp [j] ;                   /* column j of AT starts here */
            ATp [j] = p2 ;                  /* new column j starts here */
            if (ATp [j+1] - p > dense) continue ;   /* skip dense col j */
            for ( ; p < ATp [j+1] ; p++) ATi [p2++] = ATi [p] ;
        }
        ATp [m] = p2 ;                      /* finalize AT */
        A2 = cs_transpose (AT, 0) ;         /* A2 = AT' */
        C = A2 ? cs_multiply (AT, A2) : NULL ;  /* C=A'*A with no dense rows */
        cs_spfree (A2) ;
    }
    else
    {
        C = cs_multiply (AT, A) ;           /* C=A'*A */
    }
    cs_spfree (AT) ;
    if (!C) return (NULL) ;
    cs_fkeep (C, &cs_diag, NULL) ;          /* drop diagonal entries */
    Cp = C->p ;
    cnz = Cp [n] ;
    P = cs_malloc (n+1, sizeof (CS_INT)) ;     /* allocate result */
    W = cs_malloc (8*(n+1), sizeof (CS_INT)) ; /* get workspace */
    t = cnz + cnz/5 + 2*n ;                 /* add elbow room to C */
    if (!P || !W || !cs_sprealloc (C, t)) return (cs_idone (P, C, W, 0)) ;
    len  = W           ; nv     = W +   (n+1) ; next   = W + 2*(n+1) ;
    head = W + 3*(n+1) ; elen   = W + 4*(n+1) ; degree = W + 5*(n+1) ;
    w    = W + 6*(n+1) ; hhead  = W + 7*(n+1) ;
    last = P ;                              /* use P as workspace for last */
    /* --- Initialize quotient graph ---------------------------------------- */
    for (k = 0 ; k < n ; k++) len [k] = Cp [k+1] - Cp [k] ;
    len [n] = 0 ;
    nzmax = C->nzmax ;
    Ci = C->i ;
    for (i = 0 ; i <= n ; i++)
    {
        head [i] = -1 ;                     /* degree list i is empty */
        last [i] = -1 ;
        next [i] = -1 ;
        hhead [i] = -1 ;                    /* hash list i is empty */
        nv [i] = 1 ;                        /* node i is just one node */
        w [i] = 1 ;                         /* node i is alive */
        elen [i] = 0 ;                      /* Ek of node i is empty */
        degree [i] = len [i] ;              /* degree of node i */
    }
    mark = cs_wclear (0, 0, w, n) ;         /* clear w */
    elen [n] = -2 ;                         /* n is a dead element */
    Cp [n] = -1 ;                           /* n is a root of assembly tree */
    w [n] = 0 ;                             /* n is a dead element */
    /* --- Initialize degree lists ------------------------------------------ */
    for (i = 0 ; i < n ; i++)
    {
        d = degree [i] ;
        if (d == 0)                         /* node i is empty */
        {
            elen [i] = -2 ;                 /* element i is dead */
            nel++ ;
            Cp [i] = -1 ;                   /* i is a root of assembly tree */
            w [i] = 0 ;
        }
        else if (d > dense)                 /* node i is dense */
        {
            nv [i] = 0 ;                    /* absorb i into element n */
            elen [i] = -1 ;                 /* node i is dead */
            nel++ ;
            Cp [i] = CS_FLIP (n) ;
            nv [n]++ ;
        }
        else
        {
            if (head [d] != -1) last [head [d]] = i ;
            next [i] = head [d] ;           /* put node i in degree list d */
            head [d] = i ;
        }
    }
    while (nel < n)                         /* while (selecting pivots) do */
    {
        /* --- Select node of minimum approximate degree -------------------- */
        for (k = -1 ; mindeg < n && (k = head [mindeg]) == -1 ; mindeg++) ;
        if (next [k] != -1) last [next [k]] = -1 ;
        head [mindeg] = next [k] ;          /* remove k from degree list */
        elenk = elen [k] ;                  /* elenk = |Ek| */
        nvk = nv [k] ;                      /* # of nodes k represents */
        nel += nvk ;                        /* nv[k] nodes of A eliminated */
        /* --- Garbage collection ------------------------------------------- */
        if (elenk > 0 && cnz + mindeg >= nzmax)
        {
            for (j = 0 ; j < n ; j++)
            {
                if ((p = Cp [j]) >= 0)      /* j is a live node or element */
                {
                    Cp [j] = Ci [p] ;       /* save first entry of object */
                    Ci [p] = CS_FLIP (j) ;  /* first entry is now CS_FLIP(j) */
                }
            }
            for (q = 0, p = 0 ; p < cnz ; ) /* scan all of memory */
            {
                if ((j = CS_FLIP (Ci [p++])) >= 0)  /* found object j */
                {
                    Ci [q] = Cp [j] ;       /* restore first entry of object */
                    Cp [j] = q++ ;          /* new pointer to object j */
                    for (k3 = 0 ; k3 < len [j]-1 ; k3++) Ci [q++] = Ci [p++] ;
                }
            }
            cnz = q ;                       /* Ci [cnz...nzmax-1] now free */
        }
        /* --- Construct new element ---------------------------------------- */
        dk = 0 ;
        nv [k] = -nvk ;                     /* flag k as in Lk */
        p = Cp [k] ;
        pk1 = (elenk == 0) ? p : cnz ;      /* do in place if elen[k] == 0 */
        pk2 = pk1 ;
        for (k1 = 1 ; k1 <= elenk + 1 ; k1++)
        {
            if (k1 > elenk)
            {
                e = k ;                     /* search the nodes in k */
                pj = p ;                    /* list of nodes starts at Ci[pj]*/
                ln = len [k] - elenk ;      /* length of list of nodes in k */
            }
            else
            {
                e = Ci [p++] ;              /* search the nodes in e */
                pj = Cp [e] ;
                ln = len [e] ;              /* length of list of nodes in e */
            }
            for (k2 = 1 ; k2 <= ln ; k2++)
            {
                i = Ci [pj++] ;
                if ((nvi = nv [i]) <= 0) continue ; /* node i dead, or seen */
                dk += nvi ;                 /* degree[Lk] += size of node i */
                nv [i] = -nvi ;             /* negate nv[i] to denote i in Lk*/
                Ci [pk2++] = i ;            /* place i in Lk */
                if (next [i] != -1) last [next [i]] = last [i] ;
                if (last [i] != -1)         /* remove i from degree list */
                {
                    next [last [i]] = next [i] ;
                }
                else
                {
                    head [degree [i]] = next [i] ;
                }
            }
            if (e != k)
            {
                Cp [e] = CS_FLIP (k) ;      /* absorb e into k */
                w [e] = 0 ;                 /* e is now a dead element */
            }
        }
        if (elenk != 0) cnz = pk2 ;         /* Ci [cnz...nzmax] is free */
        degree [k] = dk ;                   /* external degree of k - |Lk\i| */
        Cp [k] = pk1 ;                      /* element k is in Ci[pk1..pk2-1] */
        len [k] = pk2 - pk1 ;
        elen [k] = -2 ;                     /* k is now an element */
        /* --- Find set differences ----------------------------------------- */
        mark = cs_wclear (mark, lemax, w, n) ;  /* clear w if necessary */
        for (pk = pk1 ; pk < pk2 ; pk++)    /* scan 1: find |Le\Lk| */
        {
            i = Ci [pk] ;
            if ((eln = elen [i]) <= 0) continue ;/* skip if elen[i] empty */
            nvi = -nv [i] ;                      /* nv [i] was negated */
            wnvi = mark - nvi ;
            for (p = Cp [i] ; p <= Cp [i] + eln - 1 ; p++)  /* scan Ei */
            {
                e = Ci [p] ;
                if (w [e] >= mark)
                {
                    w [e] -= nvi ;          /* decrement |Le\Lk| */
                }
                else if (w [e] != 0)        /* ensure e is a live element */
                {
                    w [e] = degree [e] + wnvi ; /* 1st time e seen in scan 1 */
                }
            }
        }
        /* --- Degree update ------------------------------------------------ */
        for (pk = pk1 ; pk < pk2 ; pk++)    /* scan2: degree update */
        {
            i = Ci [pk] ;                   /* consider node i in Lk */
            p1 = Cp [i] ;
            p2 = p1 + elen [i] - 1 ;
            pn = p1 ;
            for (h = 0, d = 0, p = p1 ; p <= p2 ; p++)    /* scan Ei */
            {
                e = Ci [p] ;
                if (w [e] != 0)             /* e is an unabsorbed element */
                {
                    dext = w [e] - mark ;   /* dext = |Le\Lk| */
                    if (dext > 0)
                    {
                        d += dext ;         /* sum up the set differences */
                        Ci [pn++] = e ;     /* keep e in Ei */
                        h += e ;            /* compute the hash of node i */
                    }
                    else
                    {
                        Cp [e] = CS_FLIP (k) ;  /* aggressive absorb. e->k */
                        w [e] = 0 ;             /* e is a dead element */
                    }
                }
            }
            elen [i] = pn - p1 + 1 ;        /* elen[i] = |Ei| */
            p3 = pn ;
            p4 = p1 + len [i] ;
            for (p = p2 + 1 ; p < p4 ; p++) /* prune edges in Ai */
            {
                j = Ci [p] ;
                if ((nvj = nv [j]) <= 0) continue ; /* node j dead or in Lk */
                d += nvj ;                  /* degree(i) += |j| */
                Ci [pn++] = j ;             /* place j in node list of i */
                h += j ;                    /* compute hash for node i */
            }
            if (d == 0)                     /* check for mass elimination */
            {
                Cp [i] = CS_FLIP (k) ;      /* absorb i into k */
                nvi = -nv [i] ;
                dk -= nvi ;                 /* |Lk| -= |i| */
                nvk += nvi ;                /* |k| += nv[i] */
                nel += nvi ;
                nv [i] = 0 ;
                elen [i] = -1 ;             /* node i is dead */
            }
            else
            {
                degree [i] = CS_MIN (degree [i], d) ;   /* update degree(i) */
                Ci [pn] = Ci [p3] ;         /* move first node to end */
                Ci [p3] = Ci [p1] ;         /* move 1st el. to end of Ei */
                Ci [p1] = k ;               /* add k as 1st element in of Ei */
                len [i] = pn - p1 + 1 ;     /* new len of adj. list of node i */
                h = ((h<0) ? (-h):h) % n ;  /* finalize hash of i */
                next [i] = hhead [h] ;      /* place i in hash bucket */
                hhead [h] = i ;
                last [i] = h ;              /* save hash of i in last[i] */
            }
        }                                   /* scan2 is done */
        degree [k] = dk ;                   /* finalize |Lk| */
        lemax = CS_MAX (lemax, dk) ;
        mark = cs_wclear (mark+lemax, lemax, w, n) ;    /* clear w */
        /* --- Supernode detection ------------------------------------------ */
        for (pk = pk1 ; pk < pk2 ; pk++)
        {
            i = Ci [pk] ;
            if (nv [i] >= 0) continue ;         /* skip if i is dead */
            h = last [i] ;                      /* scan hash bucket of node i */
            i = hhead [h] ;
            hhead [h] = -1 ;                    /* hash bucket will be empty */
            for ( ; i != -1 && next [i] != -1 ; i = next [i], mark++)
            {
                ln = len [i] ;
                eln = elen [i] ;
                for (p = Cp [i]+1 ; p <= Cp [i] + ln-1 ; p++) w [Ci [p]] = mark;
                jlast = i ;
                for (j = next [i] ; j != -1 ; ) /* compare i with all j */
                {
                    ok = (len [j] == ln) && (elen [j] == eln) ;
                    for (p = Cp [j] + 1 ; ok && p <= Cp [j] + ln - 1 ; p++)
                    {
                        if (w [Ci [p]] != mark) ok = 0 ;    /* compare i and j*/
                    }
                    if (ok)                     /* i and j are identical */
                    {
                        Cp [j] = CS_FLIP (i) ;  /* absorb j into i */
                        nv [i] += nv [j] ;
                        nv [j] = 0 ;
                        elen [j] = -1 ;         /* node j is dead */
                        j = next [j] ;          /* delete j from hash bucket */
                        next [jlast] = j ;
                    }
                    else
                    {
                        jlast = j ;             /* j and i are different */
                        j = next [j] ;
                    }
                }
            }
        }
        /* --- Finalize new element------------------------------------------ */
        for (p = pk1, pk = pk1 ; pk < pk2 ; pk++)   /* finalize Lk */
        {
            i = Ci [pk] ;
            if ((nvi = -nv [i]) <= 0) continue ;/* skip if i is dead */
            nv [i] = nvi ;                      /* restore nv[i] */
            d = degree [i] + dk - nvi ;         /* compute external degree(i) */
            d = CS_MIN (d, n - nel - nvi) ;
            if (head [d] != -1) last [head [d]] = i ;
            next [i] = head [d] ;               /* put i back in degree list */
            last [i] = -1 ;
            head [d] = i ;
            mindeg = CS_MIN (mindeg, d) ;       /* find new minimum degree */
            degree [i] = d ;
            Ci [p++] = i ;                      /* place i in Lk */
        }
        nv [k] = nvk ;                      /* # nodes absorbed into k */
        if ((len [k] = p-pk1) == 0)         /* length of adj list of element k*/
        {
            Cp [k] = -1 ;                   /* k is a root of the tree */
            w [k] = 0 ;                     /* k is now a dead element */
        }
        if (elenk != 0) cnz = p ;           /* free unused space in Lk */
    }
    /* --- Postordering ----------------------------------------------------- */
    for (i = 0 ; i < n ; i++) Cp [i] = CS_FLIP (Cp [i]) ;/* fix assembly tree */
    for (j = 0 ; j <= n ; j++) head [j] = -1 ;
    for (j = n ; j >= 0 ; j--)              /* place unordered nodes in lists */
    {
        if (nv [j] > 0) continue ;          /* skip if j is an element */
        next [j] = head [Cp [j]] ;          /* place j in list of its parent */
        head [Cp [j]] = j ;
    }
    for (e = n ; e >= 0 ; e--)              /* place elements in lists */
    {
        if (nv [e] <= 0) continue ;         /* skip unless e is an element */
        if (Cp [e] != -1)
        {
            next [e] = head [Cp [e]] ;      /* place e in list of its parent */
            head [Cp [e]] = e ;
        }
    }
    for (k = 0, i = 0 ; i <= n ; i++)       /* postorder the assembly tree */
    {
        if (Cp [i] == -1) k = cs_tdfs (i, k, head, next, P, w) ;
    }
    return (cs_idone (P, C, W, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_chol.c0000644000175100001710000000547500000000000023345 0ustar00runnerdocker00000000000000#include "cs.h"
/* L = chol (A, [pinv parent cp]), pinv is optional */
csn *cs_chol (const cs *A, const css *S)
{
    CS_ENTRY d, lki, *Lx, *x, *Cx ;
    CS_INT top, i, p, k, n, *Li, *Lp, *cp, *pinv, *s, *c, *parent, *Cp, *Ci ;
    cs *L, *C, *E ;
    csn *N ;
    if (!CS_CSC (A) || !S || !S->cp || !S->parent) return (NULL) ;
    n = A->n ;
    N = cs_calloc (1, sizeof (csn)) ;       /* allocate result */
    c = cs_malloc (2*n, sizeof (CS_INT)) ;     /* get CS_INT workspace */
    x = cs_malloc (n, sizeof (CS_ENTRY)) ;    /* get CS_ENTRY workspace */
    cp = S->cp ; pinv = S->pinv ; parent = S->parent ;
    C = pinv ? cs_symperm (A, pinv, 1) : ((cs *) A) ;
    E = pinv ? C : NULL ;           /* E is alias for A, or a copy E=A(p,p) */
    if (!N || !c || !x || !C) return (cs_ndone (N, E, c, x, 0)) ;
    s = c + n ;
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    N->L = L = cs_spalloc (n, n, cp [n], 1, 0) ;    /* allocate result */
    if (!L) return (cs_ndone (N, E, c, x, 0)) ;
    Lp = L->p ; Li = L->i ; Lx = L->x ;
    for (k = 0 ; k < n ; k++) Lp [k] = c [k] = cp [k] ;
    for (k = 0 ; k < n ; k++)       /* compute L(k,:) for L*L' = C */
    {
        /* --- Nonzero pattern of L(k,:) ------------------------------------ */
        top = cs_ereach (C, k, parent, s, c) ;      /* find pattern of L(k,:) */
        x [k] = 0 ;                                 /* x (0:k) is now zero */
        for (p = Cp [k] ; p < Cp [k+1] ; p++)       /* x = full(triu(C(:,k))) */
        {
            if (Ci [p] <= k) x [Ci [p]] = Cx [p] ;
        }
        d = x [k] ;                     /* d = C(k,k) */
        x [k] = 0 ;                     /* clear x for k+1st iteration */
        /* --- Triangular solve --------------------------------------------- */
        for ( ; top < n ; top++)    /* solve L(0:k-1,0:k-1) * x = C(:,k) */
        {
            i = s [top] ;               /* s [top..n-1] is pattern of L(k,:) */
            lki = x [i] / Lx [Lp [i]] ; /* L(k,i) = x (i) / L(i,i) */
            x [i] = 0 ;                 /* clear x for k+1st iteration */
            for (p = Lp [i] + 1 ; p < c [i] ; p++)
            {
                x [Li [p]] -= Lx [p] * lki ;
            }
            d -= lki * CS_CONJ (lki) ;            /* d = d - L(k,i)*L(k,i) */
            p = c [i]++ ;
            Li [p] = k ;                /* store L(k,i) in column i */
            Lx [p] = CS_CONJ (lki) ;
        }
        /* --- Compute L(k,k) ----------------------------------------------- */
        if (CS_REAL (d) <= 0 || CS_IMAG (d) != 0)
	    return (cs_ndone (N, E, c, x, 0)) ; /* not pos def */
        p = c [k]++ ;
        Li [p] = k ;                /* store L(k,k) = sqrt (d) in column k */
        Lx [p] = sqrt (d) ;
    }
    Lp [n] = cp [n] ;               /* finalize L */
    return (cs_ndone (N, E, c, x, 1)) ; /* success: free E,s,x; return N */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_cholsol.c0000644000175100001710000000154500000000000024055 0ustar00runnerdocker00000000000000#include "cs.h"
/* x=A\b where A is symmetric positive definite; b overwritten with solution */
CS_INT cs_cholsol (CS_INT order, const cs *A, CS_ENTRY *b)
{
    CS_ENTRY *x ;
    css *S ;
    csn *N ;
    CS_INT n, ok ;
    if (!CS_CSC (A) || !b) return (0) ;     /* check inputs */
    n = A->n ;
    S = cs_schol (order, A) ;               /* ordering and symbolic analysis */
    N = cs_chol (A, S) ;                    /* numeric Cholesky factorization */
    x = cs_malloc (n, sizeof (CS_ENTRY)) ;    /* get workspace */
    ok = (S && N && x) ;
    if (ok)
    {
        cs_ipvec (S->pinv, b, x, n) ;   /* x = P*b */
        cs_lsolve (N->L, x) ;           /* x = L\x */
        cs_ltsolve (N->L, x) ;          /* x = L'\x */
        cs_pvec (S->pinv, x, b, n) ;    /* b = P'*x */
    }
    cs_free (x) ;
    cs_sfree (S) ;
    cs_nfree (N) ;
    return (ok) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_compress.c0000644000175100001710000000175500000000000024250 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = compressed-column form of a triplet matrix T */
cs *cs_compress (const cs *T)
{
    CS_INT m, n, nz, p, k, *Cp, *Ci, *w, *Ti, *Tj ;
    CS_ENTRY *Cx, *Tx ;
    cs *C ;
    if (!CS_TRIPLET (T)) return (NULL) ;                /* check inputs */
    m = T->m ; n = T->n ; Ti = T->i ; Tj = T->p ; Tx = T->x ; nz = T->nz ;
    C = cs_spalloc (m, n, nz, Tx != NULL, 0) ;          /* allocate result */
    w = cs_calloc (n, sizeof (CS_INT)) ;                   /* get workspace */
    if (!C || !w) return (cs_done (C, w, NULL, 0)) ;    /* out of memory */
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (k = 0 ; k < nz ; k++) w [Tj [k]]++ ;           /* column counts */
    cs_cumsum (Cp, w, n) ;                              /* column pointers */
    for (k = 0 ; k < nz ; k++)
    {
        Ci [p = w [Tj [k]]++] = Ti [k] ;    /* A(i,j) is the pth entry in C */
        if (Cx) Cx [p] = Tx [k] ;
    }
    return (cs_done (C, w, NULL, 1)) ;      /* success; free w and return C */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_counts.c0000644000175100001710000000550300000000000023723 0ustar00runnerdocker00000000000000#include "cs.h"
/* column counts of LL'=A or LL'=A'A, given parent & post ordering */
#define HEAD(k,j) (ata ? head [k] : j)
#define NEXT(J)   (ata ? next [J] : -1)
static void init_ata (cs *AT, const CS_INT *post, CS_INT *w, CS_INT **head, CS_INT **next)
{
    CS_INT i, k, p, m = AT->n, n = AT->m, *ATp = AT->p, *ATi = AT->i ;
    *head = w+4*n, *next = w+5*n+1 ;
    for (k = 0 ; k < n ; k++) w [post [k]] = k ;    /* invert post */
    for (i = 0 ; i < m ; i++)
    {
        for (k = n, p = ATp[i] ; p < ATp[i+1] ; p++) k = CS_MIN (k, w [ATi[p]]);
        (*next) [i] = (*head) [k] ;     /* place row i in linked list k */
        (*head) [k] = i ;
    }
}
CS_INT *cs_counts (const cs *A, const CS_INT *parent, const CS_INT *post, CS_INT ata)
{
    CS_INT i, j, k, n, m, J, s, p, q, jleaf, *ATp, *ATi, *maxfirst, *prevleaf,
        *ancestor, *head = NULL, *next = NULL, *colcount, *w, *first, *delta ;
    cs *AT ;
    if (!CS_CSC (A) || !parent || !post) return (NULL) ;    /* check inputs */
    m = A->m ; n = A->n ;
    s = 4*n + (ata ? (n+m+1) : 0) ;
    delta = colcount = cs_malloc (n, sizeof (CS_INT)) ;    /* allocate result */
    w = cs_malloc (s, sizeof (CS_INT)) ;                   /* get workspace */
    AT = cs_transpose (A, 0) ;                          /* AT = A' */
    if (!AT || !colcount || !w) return (cs_idone (colcount, AT, w, 0)) ;
    ancestor = w ; maxfirst = w+n ; prevleaf = w+2*n ; first = w+3*n ;
    for (k = 0 ; k < s ; k++) w [k] = -1 ;      /* clear workspace w [0..s-1] */
    for (k = 0 ; k < n ; k++)                   /* find first [j] */
    {
        j = post [k] ;
        delta [j] = (first [j] == -1) ? 1 : 0 ;  /* delta[j]=1 if j is a leaf */
        for ( ; j != -1 && first [j] == -1 ; j = parent [j]) first [j] = k ;
    }
    ATp = AT->p ; ATi = AT->i ;
    if (ata) init_ata (AT, post, w, &head, &next) ;
    for (i = 0 ; i < n ; i++) ancestor [i] = i ; /* each node in its own set */
    for (k = 0 ; k < n ; k++)
    {
        j = post [k] ;          /* j is the kth node in postordered etree */
        if (parent [j] != -1) delta [parent [j]]-- ;    /* j is not a root */
        for (J = HEAD (k,j) ; J != -1 ; J = NEXT (J))   /* J=j for LL'=A case */
        {
            for (p = ATp [J] ; p < ATp [J+1] ; p++)
            {
                i = ATi [p] ;
                q = cs_leaf (i, j, first, maxfirst, prevleaf, ancestor, &jleaf);
                if (jleaf >= 1) delta [j]++ ;   /* A(i,j) is in skeleton */
                if (jleaf == 2) delta [q]-- ;   /* account for overlap in q */
            }
        }
        if (parent [j] != -1) ancestor [j] = parent [j] ;
    }
    for (j = 0 ; j < n ; j++)           /* sum up delta's of each child */
    {
        if (parent [j] != -1) colcount [parent [j]] += colcount [j] ;
    }
    return (cs_idone (colcount, AT, w, 1)) ;    /* success: free workspace */
} 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_cumsum.c0000644000175100001710000000110300000000000023711 0ustar00runnerdocker00000000000000#include "cs.h"
/* p [0..n] = cumulative sum of c [0..n-1], and then copy p [0..n-1] into c */
double cs_cumsum (CS_INT *p, CS_INT *c, CS_INT n)
{
    CS_INT i, nz = 0 ;
    double nz2 = 0 ;
    if (!p || !c) return (-1) ;     /* check inputs */
    for (i = 0 ; i < n ; i++)
    {
        p [i] = nz ;
        nz += c [i] ;
        nz2 += c [i] ;              /* also in double to avoid CS_INT overflow */
        c [i] = p [i] ;             /* also copy p[0..n-1] back into c[0..n-1]*/
    }
    p [n] = nz ;
    return (nz2) ;                  /* return sum (c [0..n-1]) */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_dfs.c0000644000175100001710000000315500000000000023165 0ustar00runnerdocker00000000000000#include "cs.h"
/* depth-first-search of the graph of a matrix, starting at node j */
CS_INT cs_dfs (CS_INT j, cs *G, CS_INT top, CS_INT *xi, CS_INT *pstack, const CS_INT *pinv)
{
    CS_INT i, p, p2, done, jnew, head = 0, *Gp, *Gi ;
    if (!CS_CSC (G) || !xi || !pstack) return (-1) ;    /* check inputs */
    Gp = G->p ; Gi = G->i ;
    xi [0] = j ;                /* initialize the recursion stack */
    while (head >= 0)
    {
        j = xi [head] ;         /* get j from the top of the recursion stack */
        jnew = pinv ? (pinv [j]) : j ;
        if (!CS_MARKED (Gp, j))
        {
            CS_MARK (Gp, j) ;       /* mark node j as visited */
            pstack [head] = (jnew < 0) ? 0 : CS_UNFLIP (Gp [jnew]) ;
        }
        done = 1 ;                  /* node j done if no unvisited neighbors */
        p2 = (jnew < 0) ? 0 : CS_UNFLIP (Gp [jnew+1]) ;
        for (p = pstack [head] ; p < p2 ; p++)  /* examine all neighbors of j */
        {
            i = Gi [p] ;            /* consider neighbor node i */
            if (CS_MARKED (Gp, i)) continue ;   /* skip visited node i */
            pstack [head] = p ;     /* pause depth-first search of node j */
            xi [++head] = i ;       /* start dfs at node i */
            done = 0 ;              /* node j is not done */
            break ;                 /* break, to start dfs (i) */
        }
        if (done)               /* depth-first search at node j is done */
        {
            head-- ;            /* remove j from the recursion stack */
            xi [--top] = j ;    /* and place in the output stack */
        }
    }
    return (top) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_dmperm.c0000644000175100001710000001442600000000000023700 0ustar00runnerdocker00000000000000#include "cs.h"
/* breadth-first search for coarse decomposition (C0,C1,R1 or R0,R3,C3) */
static CS_INT cs_bfs (const cs *A, CS_INT n, CS_INT *wi, CS_INT *wj, CS_INT *queue,
    const CS_INT *imatch, const CS_INT *jmatch, CS_INT mark)
{
    CS_INT *Ap, *Ai, head = 0, tail = 0, j, i, p, j2 ;
    cs *C ;
    for (j = 0 ; j < n ; j++)           /* place all unmatched nodes in queue */
    {
        if (imatch [j] >= 0) continue ; /* skip j if matched */
        wj [j] = 0 ;                    /* j in set C0 (R0 if transpose) */
        queue [tail++] = j ;            /* place unmatched col j in queue */
    }
    if (tail == 0) return (1) ;         /* quick return if no unmatched nodes */
    C = (mark == 1) ? ((cs *) A) : cs_transpose (A, 0) ;
    if (!C) return (0) ;                /* bfs of C=A' to find R3,C3 from R0 */
    Ap = C->p ; Ai = C->i ;
    while (head < tail)                 /* while queue is not empty */
    {
        j = queue [head++] ;            /* get the head of the queue */
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            i = Ai [p] ;
            if (wi [i] >= 0) continue ; /* skip if i is marked */
            wi [i] = mark ;             /* i in set R1 (C3 if transpose) */
            j2 = jmatch [i] ;           /* traverse alternating path to j2 */
            if (wj [j2] >= 0) continue ;/* skip j2 if it is marked */
            wj [j2] = mark ;            /* j2 in set C1 (R3 if transpose) */
            queue [tail++] = j2 ;       /* add j2 to queue */
        }
    }
    if (mark != 1) cs_spfree (C) ;      /* free A' if it was created */
    return (1) ;
}

/* collect matched rows and columns into p and q */
static void cs_matched (CS_INT n, const CS_INT *wj, const CS_INT *imatch, CS_INT *p, CS_INT *q,
    CS_INT *cc, CS_INT *rr, CS_INT set, CS_INT mark)
{
    CS_INT kc = cc [set], j ;
    CS_INT kr = rr [set-1] ;
    for (j = 0 ; j < n ; j++)
    {
        if (wj [j] != mark) continue ;      /* skip if j is not in C set */
        p [kr++] = imatch [j] ;
        q [kc++] = j ;
    }
    cc [set+1] = kc ;
    rr [set] = kr ;
}

/* collect unmatched rows into the permutation vector p */
static void cs_unmatched (CS_INT m, const CS_INT *wi, CS_INT *p, CS_INT *rr, CS_INT set)
{
    CS_INT i, kr = rr [set] ;
    for (i = 0 ; i < m ; i++) if (wi [i] == 0) p [kr++] = i ;
    rr [set+1] = kr ;
}

/* return 1 if row i is in R2 */
static CS_INT cs_rprune (CS_INT i, CS_INT j, CS_ENTRY aij, void *other)
{
    CS_INT *rr = (CS_INT *) other ;
    return (i >= rr [1] && i < rr [2]) ;
}

/* Given A, compute coarse and then fine dmperm */
csd *cs_dmperm (const cs *A, CS_INT seed)
{
    CS_INT m, n, i, j, k, cnz, nc, *jmatch, *imatch, *wi, *wj, *pinv, *Cp, *Ci,
        *ps, *rs, nb1, nb2, *p, *q, *cc, *rr, *r, *s, ok ;
    cs *C ;
    csd *D, *scc ;
    /* --- Maximum matching ------------------------------------------------- */
    if (!CS_CSC (A)) return (NULL) ;            /* check inputs */
    m = A->m ; n = A->n ;
    D = cs_dalloc (m, n) ;                      /* allocate result */
    if (!D) return (NULL) ;
    p = D->p ; q = D->q ; r = D->r ; s = D->s ; cc = D->cc ; rr = D->rr ;
    jmatch = cs_maxtrans (A, seed) ;            /* max transversal */
    imatch = jmatch + m ;                       /* imatch = inverse of jmatch */
    if (!jmatch) return (cs_ddone (D, NULL, jmatch, 0)) ;
    /* --- Coarse decomposition --------------------------------------------- */
    wi = r ; wj = s ;                           /* use r and s as workspace */
    for (j = 0 ; j < n ; j++) wj [j] = -1 ;     /* unmark all cols for bfs */
    for (i = 0 ; i < m ; i++) wi [i] = -1 ;     /* unmark all rows for bfs */
    cs_bfs (A, n, wi, wj, q, imatch, jmatch, 1) ;       /* find C1, R1 from C0*/
    ok = cs_bfs (A, m, wj, wi, p, jmatch, imatch, 3) ;  /* find R3, C3 from R0*/
    if (!ok) return (cs_ddone (D, NULL, jmatch, 0)) ;
    cs_unmatched (n, wj, q, cc, 0) ;                    /* unmatched set C0 */
    cs_matched (n, wj, imatch, p, q, cc, rr, 1, 1) ;    /* set R1 and C1 */
    cs_matched (n, wj, imatch, p, q, cc, rr, 2, -1) ;   /* set R2 and C2 */
    cs_matched (n, wj, imatch, p, q, cc, rr, 3, 3) ;    /* set R3 and C3 */
    cs_unmatched (m, wi, p, rr, 3) ;                    /* unmatched set R0 */
    cs_free (jmatch) ;
    /* --- Fine decomposition ----------------------------------------------- */
    pinv = cs_pinv (p, m) ;         /* pinv=p' */
    if (!pinv) return (cs_ddone (D, NULL, NULL, 0)) ;
    C = cs_permute (A, pinv, q, 0) ;/* C=A(p,q) (it will hold A(R2,C2)) */
    cs_free (pinv) ;
    if (!C) return (cs_ddone (D, NULL, NULL, 0)) ;
    Cp = C->p ;
    nc = cc [3] - cc [2] ;          /* delete cols C0, C1, and C3 from C */
    if (cc [2] > 0) for (j = cc [2] ; j <= cc [3] ; j++) Cp [j-cc[2]] = Cp [j] ;
    C->n = nc ;
    if (rr [2] - rr [1] < m)        /* delete rows R0, R1, and R3 from C */
    {
        cs_fkeep (C, cs_rprune, rr) ;
        cnz = Cp [nc] ;
        Ci = C->i ;
        if (rr [1] > 0) for (k = 0 ; k < cnz ; k++) Ci [k] -= rr [1] ;
    }
    C->m = nc ;
    scc = cs_scc (C) ;              /* find strongly connected components of C*/
    if (!scc) return (cs_ddone (D, C, NULL, 0)) ;
    /* --- Combine coarse and fine decompositions --------------------------- */
    ps = scc->p ;                   /* C(ps,ps) is the permuted matrix */
    rs = scc->r ;                   /* kth block is rs[k]..rs[k+1]-1 */
    nb1 = scc->nb  ;                /* # of blocks of A(R2,C2) */
    for (k = 0 ; k < nc ; k++) wj [k] = q [ps [k] + cc [2]] ;
    for (k = 0 ; k < nc ; k++) q [k + cc [2]] = wj [k] ;
    for (k = 0 ; k < nc ; k++) wi [k] = p [ps [k] + rr [1]] ;
    for (k = 0 ; k < nc ; k++) p [k + rr [1]] = wi [k] ;
    nb2 = 0 ;                       /* create the fine block partitions */
    r [0] = s [0] = 0 ;
    if (cc [2] > 0) nb2++ ;         /* leading coarse block A (R1, [C0 C1]) */
    for (k = 0 ; k < nb1 ; k++)     /* coarse block A (R2,C2) */
    {
        r [nb2] = rs [k] + rr [1] ; /* A (R2,C2) splits into nb1 fine blocks */
        s [nb2] = rs [k] + cc [2] ;
        nb2++ ;
    }
    if (rr [2] < m)
    {
        r [nb2] = rr [2] ;          /* trailing coarse block A ([R3 R0], C3) */
        s [nb2] = cc [3] ;
        nb2++ ;
    }
    r [nb2] = m ;
    s [nb2] = n ;
    D->nb = nb2 ;
    cs_dfree (scc) ;
    return (cs_ddone (D, C, NULL, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_droptol.c0000644000175100001710000000037400000000000024074 0ustar00runnerdocker00000000000000#include "cs.h"
static CS_INT cs_tol (CS_INT i, CS_INT j, CS_ENTRY aij, void *tol)
{
    return (CS_ABS (aij) > *((double *) tol)) ;
}
CS_INT cs_droptol (cs *A, double tol)
{
    return (cs_fkeep (A, &cs_tol, &tol)) ;    /* keep all large entries */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_dropzeros.c0000644000175100001710000000034500000000000024436 0ustar00runnerdocker00000000000000#include "cs.h"
static CS_INT cs_nonzero (CS_INT i, CS_INT j, CS_ENTRY aij, void *other)
{
    return (aij != 0) ;
}
CS_INT cs_dropzeros (cs *A)
{
    return (cs_fkeep (A, &cs_nonzero, NULL)) ;  /* keep all nonzero entries */
} 
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_dupl.c0000644000175100001710000000257500000000000023362 0ustar00runnerdocker00000000000000#include "cs.h"
/* remove duplicate entries from A */
CS_INT cs_dupl (cs *A)
{
    CS_INT i, j, p, q, nz = 0, n, m, *Ap, *Ai, *w ;
    CS_ENTRY *Ax ;
    if (!CS_CSC (A)) return (0) ;               /* check inputs */
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    w = cs_malloc (m, sizeof (CS_INT)) ;           /* get workspace */
    if (!w) return (0) ;                        /* out of memory */
    for (i = 0 ; i < m ; i++) w [i] = -1 ;      /* row i not yet seen */
    for (j = 0 ; j < n ; j++)
    {
        q = nz ;                                /* column j will start at q */
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            i = Ai [p] ;                        /* A(i,j) is nonzero */
            if (w [i] >= q)
            {
                Ax [w [i]] += Ax [p] ;          /* A(i,j) is a duplicate */
            }
            else
            {
                w [i] = nz ;                    /* record where row i occurs */
                Ai [nz] = i ;                   /* keep A(i,j) */
                Ax [nz++] = Ax [p] ;
            }
        }
        Ap [j] = q ;                            /* record start of column j */
    }
    Ap [n] = nz ;                               /* finalize A */
    cs_free (w) ;                               /* free workspace */
    return (cs_sprealloc (A, 0)) ;              /* remove extra space from A */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_entry.c0000644000175100001710000000071300000000000023547 0ustar00runnerdocker00000000000000#include "cs.h"
/* add an entry to a triplet matrix; return 1 if ok, 0 otherwise */
CS_INT cs_entry (cs *T, CS_INT i, CS_INT j, CS_ENTRY x)
{
    if (!CS_TRIPLET (T) || i < 0 || j < 0) return (0) ;     /* check inputs */
    if (T->nz >= T->nzmax && !cs_sprealloc (T,2*(T->nzmax))) return (0) ;
    if (T->x) T->x [T->nz] = x ;
    T->i [T->nz] = i ;
    T->p [T->nz++] = j ;
    T->m = CS_MAX (T->m, i+1) ;
    T->n = CS_MAX (T->n, j+1) ;
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_ereach.c0000644000175100001710000000213600000000000023636 0ustar00runnerdocker00000000000000#include "cs.h"
/* find nonzero pattern of Cholesky L(k,1:k-1) using etree and triu(A(:,k)) */
CS_INT cs_ereach (const cs *A, CS_INT k, const CS_INT *parent, CS_INT *s, CS_INT *w)
{
    CS_INT i, p, n, len, top, *Ap, *Ai ;
    if (!CS_CSC (A) || !parent || !s || !w) return (-1) ;   /* check inputs */
    top = n = A->n ; Ap = A->p ; Ai = A->i ;
    CS_MARK (w, k) ;                /* mark node k as visited */
    for (p = Ap [k] ; p < Ap [k+1] ; p++)
    {
        i = Ai [p] ;                /* A(i,k) is nonzero */
        if (i > k) continue ;       /* only use upper triangular part of A */
        for (len = 0 ; !CS_MARKED (w,i) ; i = parent [i]) /* traverse up etree*/
        {
            s [len++] = i ;         /* L(k,i) is nonzero */
            CS_MARK (w, i) ;        /* mark i as visited */
        }
        while (len > 0) s [--top] = s [--len] ; /* push path onto stack */
    }
    for (p = top ; p < n ; p++) CS_MARK (w, s [p]) ;    /* unmark all nodes */
    CS_MARK (w, k) ;                /* unmark node k */
    return (top) ;                  /* s [top..n-1] contains pattern of L(k,:)*/
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_etree.c0000644000175100001710000000253700000000000023520 0ustar00runnerdocker00000000000000#include "cs.h"
/* compute the etree of A (using triu(A), or A'A without forming A'A */
CS_INT *cs_etree (const cs *A, CS_INT ata)
{
    CS_INT i, k, p, m, n, inext, *Ap, *Ai, *w, *parent, *ancestor, *prev ;
    if (!CS_CSC (A)) return (NULL) ;        /* check inputs */
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ;
    parent = cs_malloc (n, sizeof (CS_INT)) ;              /* allocate result */
    w = cs_malloc (n + (ata ? m : 0), sizeof (CS_INT)) ;   /* get workspace */
    if (!w || !parent) return (cs_idone (parent, NULL, w, 0)) ;
    ancestor = w ; prev = w + n ;
    if (ata) for (i = 0 ; i < m ; i++) prev [i] = -1 ;
    for (k = 0 ; k < n ; k++)
    {
        parent [k] = -1 ;                   /* node k has no parent yet */
        ancestor [k] = -1 ;                 /* nor does k have an ancestor */
        for (p = Ap [k] ; p < Ap [k+1] ; p++)
        {
            i = ata ? (prev [Ai [p]]) : (Ai [p]) ;
            for ( ; i != -1 && i < k ; i = inext)   /* traverse from i to k */
            {
                inext = ancestor [i] ;              /* inext = ancestor of i */
                ancestor [i] = k ;                  /* path compression */
                if (inext == -1) parent [i] = k ;   /* no anc., parent is k */
            }
            if (ata) prev [Ai [p]] = k ;
        }
    }
    return (cs_idone (parent, NULL, w, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_fkeep.c0000644000175100001710000000170100000000000023476 0ustar00runnerdocker00000000000000#include "cs.h"
/* drop entries for which fkeep(A(i,j)) is false; return nz if OK, else -1 */
CS_INT cs_fkeep (cs *A, CS_INT (*fkeep) (CS_INT, CS_INT, CS_ENTRY, void *), void *other)
{
    CS_INT j, p, nz = 0, n, *Ap, *Ai ;
    CS_ENTRY *Ax ;
    if (!CS_CSC (A) || !fkeep) return (-1) ;    /* check inputs */
    n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    for (j = 0 ; j < n ; j++)
    {
        p = Ap [j] ;                        /* get current location of col j */
        Ap [j] = nz ;                       /* record new location of col j */
        for ( ; p < Ap [j+1] ; p++)
        {
            if (fkeep (Ai [p], j, Ax ? Ax [p] : 1, other))
            {
                if (Ax) Ax [nz] = Ax [p] ;  /* keep A(i,j) */
                Ai [nz++] = Ai [p] ;
            }
        }
    }
    Ap [n] = nz ;                           /* finalize A */
    cs_sprealloc (A, 0) ;                   /* remove extra space from A */
    return (nz) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_gaxpy.c0000644000175100001710000000066600000000000023545 0ustar00runnerdocker00000000000000#include "cs.h"
/* y = A*x+y */
CS_INT cs_gaxpy (const cs *A, const CS_ENTRY *x, CS_ENTRY *y)
{
    CS_INT p, j, n, *Ap, *Ai ;
    CS_ENTRY *Ax ;
    if (!CS_CSC (A) || !x || !y) return (0) ;       /* check inputs */
    n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    for (j = 0 ; j < n ; j++)
    {
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            y [Ai [p]] += Ax [p] * x [j] ;
        }
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_happly.c0000644000175100001710000000113500000000000023702 0ustar00runnerdocker00000000000000#include "cs.h"
/* apply the ith Householder vector to x */
CS_INT cs_happly (const cs *V, CS_INT i, double beta, CS_ENTRY *x)
{
    CS_INT p, *Vp, *Vi ;
    CS_ENTRY *Vx, tau = 0 ;
    if (!CS_CSC (V) || !x) return (0) ;     /* check inputs */
    Vp = V->p ; Vi = V->i ; Vx = V->x ;
    for (p = Vp [i] ; p < Vp [i+1] ; p++)   /* tau = v'*x */
    {
        tau += CS_CONJ (Vx [p]) * x [Vi [p]] ;
    }
    tau *= beta ;                           /* tau = beta*(v'*x) */
    for (p = Vp [i] ; p < Vp [i+1] ; p++)   /* x = x - v*tau */
    {
        x [Vi [p]] -= Vx [p] * tau ;
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_house.c0000644000175100001710000000154200000000000023532 0ustar00runnerdocker00000000000000#include "cs.h"
/* create a Householder reflection [v,beta,s]=house(x), overwrite x with v,
 * where (I-beta*v*v')*x = s*e1 and e1 = [1 0 ... 0]'.
 * Note that this CXSparse version is different than CSparse.  See Higham,
 * Accuracy & Stability of Num Algorithms, 2nd ed, 2002, page 357. */
CS_ENTRY cs_house (CS_ENTRY *x, double *beta, CS_INT n)
{
    CS_ENTRY s = 0 ;
    CS_INT i ;
    if (!x || !beta) return (-1) ;          /* check inputs */
    /* s = norm(x) */
    for (i = 0 ; i < n ; i++) s += x [i] * CS_CONJ (x [i]) ;
    s = sqrt (s) ;
    if (s == 0)
    {
        (*beta) = 0 ;
        x [0] = 1 ;
    }
    else
    {
        /* s = sign(x[0]) * norm (x) ; */
        if (x [0] != 0)
        {
            s *= x [0] / CS_ABS (x [0]) ;
        }
        x [0] += s ;
        (*beta) = 1. / CS_REAL (CS_CONJ (s) * x [0]) ;
    }
    return (-s) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_ipvec.c0000644000175100001710000000051400000000000023513 0ustar00runnerdocker00000000000000#include "cs.h"
/* x(p) = b, for dense vectors x and b; p=NULL denotes identity */
CS_INT cs_ipvec (const CS_INT *p, const CS_ENTRY *b, CS_ENTRY *x, CS_INT n)
{
    CS_INT k ;
    if (!x || !b) return (0) ;                              /* check inputs */
    for (k = 0 ; k < n ; k++) x [p ? p [k] : k] = b [k] ;
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_leaf.c0000644000175100001710000000201700000000000023314 0ustar00runnerdocker00000000000000#include "cs.h"
/* consider A(i,j), node j in ith row subtree and return lca(jprev,j) */
CS_INT cs_leaf (CS_INT i, CS_INT j, const CS_INT *first, CS_INT *maxfirst, CS_INT *prevleaf,
    CS_INT *ancestor, CS_INT *jleaf)
{
    CS_INT q, s, sparent, jprev ;
    if (!first || !maxfirst || !prevleaf || !ancestor || !jleaf) return (-1) ;
    *jleaf = 0 ;
    if (i <= j || first [j] <= maxfirst [i]) return (-1) ;  /* j not a leaf */
    maxfirst [i] = first [j] ;      /* update max first[j] seen so far */
    jprev = prevleaf [i] ;          /* jprev = previous leaf of ith subtree */
    prevleaf [i] = j ;
    *jleaf = (jprev == -1) ? 1: 2 ; /* j is first or subsequent leaf */
    if (*jleaf == 1) return (i) ;   /* if 1st leaf, q = root of ith subtree */
    for (q = jprev ; q != ancestor [q] ; q = ancestor [q]) ;
    for (s = jprev ; s != q ; s = sparent)
    {
        sparent = ancestor [s] ;    /* path compression */
        ancestor [s] = q ;
    }
    return (q) ;                    /* q = least common ancester (jprev,j) */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_load.c0000644000175100001710000000136300000000000023327 0ustar00runnerdocker00000000000000#include "cs.h"
/* load a triplet matrix from a file */
cs *cs_load (FILE *f)
{
    double i, j ;   /* use double for integers to avoid csi conflicts */
    double x ;
#ifdef CS_COMPLEX
    double xi ;
#endif
    cs *T ;
    if (!f) return (NULL) ;                             /* check inputs */
    T = cs_spalloc (0, 0, 1, 1, 1) ;                    /* allocate result */
#ifdef CS_COMPLEX
    while (fscanf (f, "%lg %lg %lg %lg\n", &i, &j, &x, &xi) == 4)
#else
    while (fscanf (f, "%lg %lg %lg\n", &i, &j, &x) == 3)
#endif
    {
#ifdef CS_COMPLEX
        if (!cs_entry (T, (CS_INT) i, (CS_INT) j, x + xi*I)) return (cs_spfree (T)) ;
#else
        if (!cs_entry (T, (CS_INT) i, (CS_INT) j, x)) return (cs_spfree (T)) ;
#endif
    }
    return (T) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_lsolve.c0000644000175100001710000000101200000000000023703 0ustar00runnerdocker00000000000000#include "cs.h"
/* solve Lx=b where x and b are dense.  x=b on input, solution on output. */
CS_INT cs_lsolve (const cs *L, CS_ENTRY *x)
{
    CS_INT p, j, n, *Lp, *Li ;
    CS_ENTRY *Lx ;
    if (!CS_CSC (L) || !x) return (0) ;                     /* check inputs */
    n = L->n ; Lp = L->p ; Li = L->i ; Lx = L->x ;
    for (j = 0 ; j < n ; j++)
    {
        x [j] /= Lx [Lp [j]] ;
        for (p = Lp [j]+1 ; p < Lp [j+1] ; p++)
        {
            x [Li [p]] -= Lx [p] * x [j] ;
        }
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_ltsolve.c0000644000175100001710000000104300000000000024073 0ustar00runnerdocker00000000000000#include "cs.h"
/* solve L'x=b where x and b are dense.  x=b on input, solution on output. */
CS_INT cs_ltsolve (const cs *L, CS_ENTRY *x)
{
    CS_INT p, j, n, *Lp, *Li ;
    CS_ENTRY *Lx ;
    if (!CS_CSC (L) || !x) return (0) ;                     /* check inputs */
    n = L->n ; Lp = L->p ; Li = L->i ; Lx = L->x ;
    for (j = n-1 ; j >= 0 ; j--)
    {
        for (p = Lp [j]+1 ; p < Lp [j+1] ; p++)
        {
            x [j] -= CS_CONJ (Lx [p]) * x [Li [p]] ;
        }
        x [j] /= CS_CONJ (Lx [Lp [j]]) ;
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_lu.c0000644000175100001710000001004100000000000023021 0ustar00runnerdocker00000000000000#include "cs.h"
/* [L,U,pinv]=lu(A, [q lnz unz]). lnz and unz can be guess */
csn *cs_lu (const cs *A, const css *S, double tol)
{
    cs *L, *U ;
    csn *N ;
    CS_ENTRY pivot, *Lx, *Ux, *x ;
    double a, t ;
    CS_INT *Lp, *Li, *Up, *Ui, *pinv, *xi, *q, n, ipiv, k, top, p, i, col, lnz,unz;
    if (!CS_CSC (A) || !S) return (NULL) ;          /* check inputs */
    n = A->n ;
    q = S->q ; lnz = S->lnz ; unz = S->unz ;
    x = cs_malloc (n, sizeof (CS_ENTRY)) ;            /* get CS_ENTRY workspace */
    xi = cs_malloc (2*n, sizeof (CS_INT)) ;            /* get CS_INT workspace */
    N = cs_calloc (1, sizeof (csn)) ;               /* allocate result */
    if (!x || !xi || !N) return (cs_ndone (N, NULL, xi, x, 0)) ;
    N->L = L = cs_spalloc (n, n, lnz, 1, 0) ;       /* allocate result L */
    N->U = U = cs_spalloc (n, n, unz, 1, 0) ;       /* allocate result U */
    N->pinv = pinv = cs_malloc (n, sizeof (CS_INT)) ;  /* allocate result pinv */
    if (!L || !U || !pinv) return (cs_ndone (N, NULL, xi, x, 0)) ;
    Lp = L->p ; Up = U->p ;
    for (i = 0 ; i < n ; i++) x [i] = 0 ;           /* clear workspace */
    for (i = 0 ; i < n ; i++) pinv [i] = -1 ;       /* no rows pivotal yet */
    for (k = 0 ; k <= n ; k++) Lp [k] = 0 ;         /* no cols of L yet */
    lnz = unz = 0 ;
    for (k = 0 ; k < n ; k++)       /* compute L(:,k) and U(:,k) */
    {
        /* --- Triangular solve --------------------------------------------- */
        Lp [k] = lnz ;              /* L(:,k) starts here */
        Up [k] = unz ;              /* U(:,k) starts here */
        if ((lnz + n > L->nzmax && !cs_sprealloc (L, 2*L->nzmax + n)) ||
            (unz + n > U->nzmax && !cs_sprealloc (U, 2*U->nzmax + n)))
        {
            return (cs_ndone (N, NULL, xi, x, 0)) ;
        }
        Li = L->i ; Lx = L->x ; Ui = U->i ; Ux = U->x ;
        col = q ? (q [k]) : k ;
        top = cs_spsolve (L, A, col, xi, x, pinv, 1) ;  /* x = L\A(:,col) */
        /* --- Find pivot --------------------------------------------------- */
        ipiv = -1 ;
        a = -1 ;
        for (p = top ; p < n ; p++)
        {
            i = xi [p] ;            /* x(i) is nonzero */
            if (pinv [i] < 0)       /* row i is not yet pivotal */
            {
                if ((t = CS_ABS (x [i])) > a)
                {
                    a = t ;         /* largest pivot candidate so far */
                    ipiv = i ;
                }
            }
            else                    /* x(i) is the entry U(pinv[i],k) */
            {
                Ui [unz] = pinv [i] ;
                Ux [unz++] = x [i] ;
            }
        }
        if (ipiv == -1 || a <= 0) return (cs_ndone (N, NULL, xi, x, 0)) ;
        /* tol=1 for  partial pivoting; tol<1 gives preference to diagonal */
        if (pinv [col] < 0 && CS_ABS (x [col]) >= a*tol) ipiv = col ;
        /* --- Divide by pivot ---------------------------------------------- */
        pivot = x [ipiv] ;          /* the chosen pivot */
        Ui [unz] = k ;              /* last entry in U(:,k) is U(k,k) */
        Ux [unz++] = pivot ;
        pinv [ipiv] = k ;           /* ipiv is the kth pivot row */
        Li [lnz] = ipiv ;           /* first entry in L(:,k) is L(k,k) = 1 */
        Lx [lnz++] = 1 ;
        for (p = top ; p < n ; p++) /* L(k+1:n,k) = x / pivot */
        {
            i = xi [p] ;
            if (pinv [i] < 0)       /* x(i) is an entry in L(:,k) */
            {
                Li [lnz] = i ;      /* save unpermuted row in L */
                Lx [lnz++] = x [i] / pivot ;    /* scale pivot column */
            }
            x [i] = 0 ;             /* x [0..n-1] = 0 for next k */
        }
    }
    /* --- Finalize L and U ------------------------------------------------- */
    Lp [n] = lnz ;
    Up [n] = unz ;
    Li = L->i ;                     /* fix row indices of L for final pinv */
    for (p = 0 ; p < lnz ; p++) Li [p] = pinv [Li [p]] ;
    cs_sprealloc (L, 0) ;           /* remove extra space from L and U */
    cs_sprealloc (U, 0) ;
    return (cs_ndone (N, NULL, xi, x, 1)) ;     /* success */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_lusol.c0000644000175100001710000000155100000000000023545 0ustar00runnerdocker00000000000000#include "cs.h"
/* x=A\b where A is unsymmetric; b overwritten with solution */
CS_INT cs_lusol (CS_INT order, const cs *A, CS_ENTRY *b, double tol)
{
    CS_ENTRY *x ;
    css *S ;
    csn *N ;
    CS_INT n, ok ;
    if (!CS_CSC (A) || !b) return (0) ;     /* check inputs */
    n = A->n ;
    S = cs_sqr (order, A, 0) ;              /* ordering and symbolic analysis */
    N = cs_lu (A, S, tol) ;                 /* numeric LU factorization */
    x = cs_malloc (n, sizeof (CS_ENTRY)) ;    /* get workspace */
    ok = (S && N && x) ;
    if (ok)
    {
        cs_ipvec (N->pinv, b, x, n) ;       /* x = b(p) */
        cs_lsolve (N->L, x) ;               /* x = L\x */
        cs_usolve (N->U, x) ;               /* x = U\x */
        cs_ipvec (S->q, x, b, n) ;          /* b(q) = x */
    }
    cs_free (x) ;
    cs_sfree (S) ;
    cs_nfree (N) ;
    return (ok) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_malloc.c0000644000175100001710000000160600000000000023657 0ustar00runnerdocker00000000000000#include "cs.h"
#ifdef MATLAB_MEX_FILE
#define malloc mxMalloc
#define free mxFree
#define realloc mxRealloc
#define calloc mxCalloc
#endif

/* wrapper for malloc */
void *cs_malloc (CS_INT n, size_t size)
{
    return (malloc (CS_MAX (n,1) * size)) ;
}

/* wrapper for calloc */
void *cs_calloc (CS_INT n, size_t size)
{
    return (calloc (CS_MAX (n,1), size)) ;
}

/* wrapper for free */
void *cs_free (void *p)
{
    if (p) free (p) ;       /* free p if it is not already NULL */
    return (NULL) ;         /* return NULL to simplify the use of cs_free */
}

/* wrapper for realloc */
void *cs_realloc (void *p, CS_INT n, size_t size, CS_INT *ok)
{
    void *pnew ;
    pnew = realloc (p, CS_MAX (n,1) * size) ; /* realloc the block */
    *ok = (pnew != NULL) ;                  /* realloc fails if pnew is NULL */
    return ((*ok) ? pnew : p) ;             /* return original p if failure */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_maxtrans.c0000644000175100001710000001063300000000000024245 0ustar00runnerdocker00000000000000#include "cs.h"
/* find an augmenting path starting at column k and extend the match if found */
static void cs_augment (CS_INT k, const cs *A, CS_INT *jmatch, CS_INT *cheap, CS_INT *w,
        CS_INT *js, CS_INT *is, CS_INT *ps)
{
    CS_INT found = 0, p, i = -1, *Ap = A->p, *Ai = A->i, head = 0, j ;
    js [0] = k ;                        /* start with just node k in jstack */
    while (head >= 0)
    {
        /* --- Start (or continue) depth-first-search at node j ------------- */
        j = js [head] ;                 /* get j from top of jstack */
        if (w [j] != k)                 /* 1st time j visited for kth path */
        {
            w [j] = k ;                 /* mark j as visited for kth path */
            for (p = cheap [j] ; p < Ap [j+1] && !found ; p++)
            {
                i = Ai [p] ;            /* try a cheap assignment (i,j) */
                found = (jmatch [i] == -1) ;
            }
            cheap [j] = p ;             /* start here next time j is traversed*/
            if (found)
            {
                is [head] = i ;         /* column j matched with row i */
                break ;                 /* end of augmenting path */
            }
            ps [head] = Ap [j] ;        /* no cheap match: start dfs for j */
        }
        /* --- Depth-first-search of neighbors of j ------------------------- */
        for (p = ps [head] ; p < Ap [j+1] ; p++)
        {
            i = Ai [p] ;                /* consider row i */
            if (w [jmatch [i]] == k) continue ; /* skip jmatch [i] if marked */
            ps [head] = p + 1 ;         /* pause dfs of node j */
            is [head] = i ;             /* i will be matched with j if found */
            js [++head] = jmatch [i] ;  /* start dfs at column jmatch [i] */
            break ;
        }
        if (p == Ap [j+1]) head-- ;     /* node j is done; pop from stack */
    }                                   /* augment the match if path found: */
    if (found) for (p = head ; p >= 0 ; p--) jmatch [is [p]] = js [p] ;
}

/* find a maximum transveral */
CS_INT *cs_maxtrans (const cs *A, CS_INT seed)  /*[jmatch [0..m-1]; imatch [0..n-1]]*/
{
    CS_INT i, j, k, n, m, p, n2 = 0, m2 = 0, *Ap, *jimatch, *w, *cheap, *js, *is,
        *ps, *Ai, *Cp, *jmatch, *imatch, *q ;
    cs *C ;
    if (!CS_CSC (A)) return (NULL) ;                /* check inputs */
    n = A->n ; m = A->m ; Ap = A->p ; Ai = A->i ;
    w = jimatch = cs_calloc (m+n, sizeof (CS_INT)) ;   /* allocate result */
    if (!jimatch) return (NULL) ;
    for (k = 0, j = 0 ; j < n ; j++)    /* count nonempty rows and columns */
    {
        n2 += (Ap [j] < Ap [j+1]) ;
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            w [Ai [p]] = 1 ;
            k += (j == Ai [p]) ;        /* count entries already on diagonal */
        }
    }
    if (k == CS_MIN (m,n))              /* quick return if diagonal zero-free */
    {
        jmatch = jimatch ; imatch = jimatch + m ;
        for (i = 0 ; i < k ; i++) jmatch [i] = i ;
        for (      ; i < m ; i++) jmatch [i] = -1 ;
        for (j = 0 ; j < k ; j++) imatch [j] = j ;
        for (      ; j < n ; j++) imatch [j] = -1 ;
        return (cs_idone (jimatch, NULL, NULL, 1)) ;
    }
    for (i = 0 ; i < m ; i++) m2 += w [i] ;
    C = (m2 < n2) ? cs_transpose (A,0) : ((cs *) A) ; /* transpose if needed */
    if (!C) return (cs_idone (jimatch, (m2 < n2) ? C : NULL, NULL, 0)) ;
    n = C->n ; m = C->m ; Cp = C->p ;
    jmatch = (m2 < n2) ? jimatch + n : jimatch ;
    imatch = (m2 < n2) ? jimatch : jimatch + m ;
    w = cs_malloc (5*n, sizeof (CS_INT)) ;             /* get workspace */
    if (!w) return (cs_idone (jimatch, (m2 < n2) ? C : NULL, w, 0)) ;
    cheap = w + n ; js = w + 2*n ; is = w + 3*n ; ps = w + 4*n ;
    for (j = 0 ; j < n ; j++) cheap [j] = Cp [j] ;  /* for cheap assignment */
    for (j = 0 ; j < n ; j++) w [j] = -1 ;          /* all columns unflagged */
    for (i = 0 ; i < m ; i++) jmatch [i] = -1 ;     /* nothing matched yet */
    q = cs_randperm (n, seed) ;                     /* q = random permutation */
    for (k = 0 ; k < n ; k++)   /* augment, starting at column q[k] */
    {
        cs_augment (q ? q [k]: k, C, jmatch, cheap, w, js, is, ps) ;
    }
    cs_free (q) ;
    for (j = 0 ; j < n ; j++) imatch [j] = -1 ;     /* find row match */
    for (i = 0 ; i < m ; i++) if (jmatch [i] >= 0) imatch [jmatch [i]] = i ;
    return (cs_idone (jimatch, (m2 < n2) ? C : NULL, w, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_multiply.c0000644000175100001710000000305100000000000024263 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = A*B */
cs *cs_multiply (const cs *A, const cs *B)
{
    CS_INT p, j, nz = 0, anz, *Cp, *Ci, *Bp, m, n, bnz, *w, values, *Bi ;
    CS_ENTRY *x, *Bx, *Cx ;
    cs *C ;
    if (!CS_CSC (A) || !CS_CSC (B)) return (NULL) ;      /* check inputs */
    if (A->n != B->m) return (NULL) ;
    m = A->m ; anz = A->p [A->n] ;
    n = B->n ; Bp = B->p ; Bi = B->i ; Bx = B->x ; bnz = Bp [n] ;
    w = cs_calloc (m, sizeof (CS_INT)) ;                    /* get workspace */
    values = (A->x != NULL) && (Bx != NULL) ;
    x = values ? cs_malloc (m, sizeof (CS_ENTRY)) : NULL ; /* get workspace */
    C = cs_spalloc (m, n, anz + bnz, values, 0) ;        /* allocate result */
    if (!C || !w || (values && !x)) return (cs_done (C, w, x, 0)) ;
    Cp = C->p ;
    for (j = 0 ; j < n ; j++)
    {
        if (nz + m > C->nzmax && !cs_sprealloc (C, 2*(C->nzmax)+m))
        {
            return (cs_done (C, w, x, 0)) ;             /* out of memory */
        } 
        Ci = C->i ; Cx = C->x ;         /* C->i and C->x may be reallocated */
        Cp [j] = nz ;                   /* column j of C starts here */
        for (p = Bp [j] ; p < Bp [j+1] ; p++)
        {
            nz = cs_scatter (A, Bi [p], Bx ? Bx [p] : 1, w, x, j+1, C, nz) ;
        }
        if (values) for (p = Cp [j] ; p < nz ; p++) Cx [p] = x [Ci [p]] ;
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    cs_sprealloc (C, 0) ;               /* remove extra space from C */
    return (cs_done (C, w, x, 1)) ;     /* success; free workspace, return C */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_norm.c0000644000175100001710000000073700000000000023367 0ustar00runnerdocker00000000000000#include "cs.h"
/* 1-norm of a sparse matrix = max (sum (abs (A))), largest column sum */
double cs_norm (const cs *A)
{
    CS_INT p, j, n, *Ap ;
    CS_ENTRY *Ax ;
    double norm = 0, s ;
    if (!CS_CSC (A) || !A->x) return (-1) ;             /* check inputs */
    n = A->n ; Ap = A->p ; Ax = A->x ;
    for (j = 0 ; j < n ; j++)
    {
        for (s = 0, p = Ap [j] ; p < Ap [j+1] ; p++) s += CS_ABS (Ax [p]) ;
        norm = CS_MAX (norm, s) ;
    }
    return (norm) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_permute.c0000644000175100001710000000202700000000000024067 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = A(p,q) where p and q are permutations of 0..m-1 and 0..n-1. */
cs *cs_permute (const cs *A, const CS_INT *pinv, const CS_INT *q, CS_INT values)
{
    CS_INT t, j, k, nz = 0, m, n, *Ap, *Ai, *Cp, *Ci ;
    CS_ENTRY *Cx, *Ax ;
    cs *C ;
    if (!CS_CSC (A)) return (NULL) ;    /* check inputs */
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    C = cs_spalloc (m, n, Ap [n], values && Ax != NULL, 0) ;  /* alloc result */
    if (!C) return (cs_done (C, NULL, NULL, 0)) ;   /* out of memory */
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (k = 0 ; k < n ; k++)
    {
        Cp [k] = nz ;                   /* column k of C is column q[k] of A */
        j = q ? (q [k]) : k ;
        for (t = Ap [j] ; t < Ap [j+1] ; t++)
        {
            if (Cx) Cx [nz] = Ax [t] ;  /* row i of A is row pinv[i] of C */
            Ci [nz++] = pinv ? (pinv [Ai [t]]) : Ai [t] ;
        }
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    return (cs_done (C, NULL, NULL, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_pinv.c0000644000175100001710000000074200000000000023364 0ustar00runnerdocker00000000000000#include "cs.h"
/* pinv = p', or p = pinv' */
CS_INT *cs_pinv (CS_INT const *p, CS_INT n)
{
    CS_INT k, *pinv ;
    if (!p) return (NULL) ;                     /* p = NULL denotes identity */
    pinv = cs_malloc (n, sizeof (CS_INT)) ;        /* allocate result */
    if (!pinv) return (NULL) ;                  /* out of memory */
    for (k = 0 ; k < n ; k++) pinv [p [k]] = k ;/* invert the permutation */
    return (pinv) ;                             /* return result */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_post.c0000644000175100001710000000210300000000000023366 0ustar00runnerdocker00000000000000#include "cs.h"
/* post order a forest */
CS_INT *cs_post (const CS_INT *parent, CS_INT n)
{
    CS_INT j, k = 0, *post, *w, *head, *next, *stack ;
    if (!parent) return (NULL) ;                        /* check inputs */
    post = cs_malloc (n, sizeof (CS_INT)) ;                /* allocate result */
    w = cs_malloc (3*n, sizeof (CS_INT)) ;                 /* get workspace */
    if (!w || !post) return (cs_idone (post, NULL, w, 0)) ;
    head = w ; next = w + n ; stack = w + 2*n ;
    for (j = 0 ; j < n ; j++) head [j] = -1 ;           /* empty linked lists */
    for (j = n-1 ; j >= 0 ; j--)            /* traverse nodes in reverse order*/
    {
        if (parent [j] == -1) continue ;    /* j is a root */
        next [j] = head [parent [j]] ;      /* add j to list of its parent */
        head [parent [j]] = j ;
    }
    for (j = 0 ; j < n ; j++)
    {
        if (parent [j] != -1) continue ;    /* skip j if it is not a root */
        k = cs_tdfs (j, k, head, next, post, stack) ;
    }
    return (cs_idone (post, NULL, w, 1)) ;  /* success; free w, return post */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_print.c0000644000175100001710000000347600000000000023553 0ustar00runnerdocker00000000000000#include "cs.h"
/* print a sparse matrix; use %g for integers to avoid differences with CS_INT */

/* Disabled for igraph as it prints to stdio */
#if 0
CS_INT cs_print (const cs *A, CS_INT brief)
{
    CS_INT p, j, m, n, nzmax, nz, *Ap, *Ai ;
    CS_ENTRY *Ax ;
    if (!A) { printf ("(null)\n") ; return (0) ; }
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    nzmax = A->nzmax ; nz = A->nz ;
    printf ("CXSparse Version %d.%d.%d, %s.  %s\n", CS_VER, CS_SUBVER,
        CS_SUBSUB, CS_DATE, CS_COPYRIGHT) ;
    if (nz < 0)
    {
        printf ("%g-by-%g, nzmax: %g nnz: %g, 1-norm: %g\n", (double) m,
            (double) n, (double) nzmax, (double) (Ap [n]), cs_norm (A)) ;
        for (j = 0 ; j < n ; j++)
        {
            printf ("    col %g : locations %g to %g\n", (double) j, 
                (double) (Ap [j]), (double) (Ap [j+1]-1)) ;
            for (p = Ap [j] ; p < Ap [j+1] ; p++)
            {
                printf ("      %g : ", (double) (Ai [p])) ;
#ifdef CS_COMPLEX
                printf ("(%g, %g)\n",
                    Ax ? CS_REAL (Ax [p]) : 1, Ax ? CS_IMAG (Ax [p]) : 0) ;
#else
                printf ("%g\n", Ax ? Ax [p] : 1) ;
#endif
                if (brief && p > 20) { printf ("  ...\n") ; return (1) ; }
            }
        }
    }
    else
    {
        printf ("triplet: %g-by-%g, nzmax: %g nnz: %g\n", (double) m,
            (double) n, (double) nzmax, (double) nz) ;
        for (p = 0 ; p < nz ; p++)
        {

            printf ("    %g %g : ", (double) (Ai [p]), (double) (Ap [p])) ;
#ifdef CS_COMPLEX
            printf ("(%g, %g)\n",
                Ax ? CS_REAL (Ax [p]) : 1, Ax ? CS_IMAG (Ax [p]) : 0) ;
#else
            printf ("%g\n", Ax ? Ax [p] : 1) ;
#endif
            if (brief && p > 20) { printf ("  ...\n") ; return (1) ; }
        }
    }
    return (1) ;
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_pvec.c0000644000175100001710000000051300000000000023341 0ustar00runnerdocker00000000000000#include "cs.h"
/* x = b(p), for dense vectors x and b; p=NULL denotes identity */
CS_INT cs_pvec (const CS_INT *p, const CS_ENTRY *b, CS_ENTRY *x, CS_INT n)
{
    CS_INT k ;
    if (!x || !b) return (0) ;                              /* check inputs */
    for (k = 0 ; k < n ; k++) x [k] = b [p ? p [k] : k] ;
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_qr.c0000644000175100001710000000670700000000000023041 0ustar00runnerdocker00000000000000#include "cs.h"
/* sparse QR factorization [V,beta,pinv,R] = qr (A) */
csn *cs_qr (const cs *A, const css *S)
{
    CS_ENTRY *Rx, *Vx, *Ax, *x ;
    double *Beta ;
    CS_INT i, k, p, n, vnz, p1, top, m2, len, col, rnz, *s, *leftmost, *Ap, *Ai,
        *parent, *Rp, *Ri, *Vp, *Vi, *w, *pinv, *q ;
    cs *R, *V ;
    csn *N ;
    if (!CS_CSC (A) || !S) return (NULL) ;
    n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    q = S->q ; parent = S->parent ; pinv = S->pinv ; m2 = S->m2 ;
    vnz = S->lnz ; rnz = S->unz ; leftmost = S->leftmost ;
    w = cs_malloc (m2+n, sizeof (CS_INT)) ;            /* get CS_INT workspace */
    x = cs_malloc (m2, sizeof (CS_ENTRY)) ;           /* get CS_ENTRY workspace */
    N = cs_calloc (1, sizeof (csn)) ;               /* allocate result */
    if (!w || !x || !N) return (cs_ndone (N, NULL, w, x, 0)) ;
    s = w + m2 ;                                    /* s is size n */
    for (k = 0 ; k < m2 ; k++) x [k] = 0 ;          /* clear workspace x */
    N->L = V = cs_spalloc (m2, n, vnz, 1, 0) ;      /* allocate result V */
    N->U = R = cs_spalloc (m2, n, rnz, 1, 0) ;      /* allocate result R */
    N->B = Beta = cs_malloc (n, sizeof (double)) ;  /* allocate result Beta */
    if (!R || !V || !Beta) return (cs_ndone (N, NULL, w, x, 0)) ;
    Rp = R->p ; Ri = R->i ; Rx = R->x ;
    Vp = V->p ; Vi = V->i ; Vx = V->x ;
    for (i = 0 ; i < m2 ; i++) w [i] = -1 ; /* clear w, to mark nodes */
    rnz = 0 ; vnz = 0 ;
    for (k = 0 ; k < n ; k++)               /* compute V and R */
    {
        Rp [k] = rnz ;                      /* R(:,k) starts here */
        Vp [k] = p1 = vnz ;                 /* V(:,k) starts here */
        w [k] = k ;                         /* add V(k,k) to pattern of V */
        Vi [vnz++] = k ;
        top = n ;
        col = q ? q [k] : k ;
        for (p = Ap [col] ; p < Ap [col+1] ; p++)   /* find R(:,k) pattern */
        {
            i = leftmost [Ai [p]] ;         /* i = min(find(A(i,q))) */
            for (len = 0 ; w [i] != k ; i = parent [i]) /* traverse up to k */
            {
                s [len++] = i ;
                w [i] = k ;
            }
            while (len > 0) s [--top] = s [--len] ; /* push path on stack */
            i = pinv [Ai [p]] ;             /* i = permuted row of A(:,col) */
            x [i] = Ax [p] ;                /* x (i) = A(:,col) */
            if (i > k && w [i] < k)         /* pattern of V(:,k) = x (k+1:m) */
            {
                Vi [vnz++] = i ;            /* add i to pattern of V(:,k) */
                w [i] = k ;
            }
        }
        for (p = top ; p < n ; p++) /* for each i in pattern of R(:,k) */
        {
            i = s [p] ;                     /* R(i,k) is nonzero */
            cs_happly (V, i, Beta [i], x) ; /* apply (V(i),Beta(i)) to x */
            Ri [rnz] = i ;                  /* R(i,k) = x(i) */
            Rx [rnz++] = x [i] ;
            x [i] = 0 ;
            if (parent [i] == k) vnz = cs_scatter (V, i, 0, w, NULL, k, V, vnz);
        }
        for (p = p1 ; p < vnz ; p++)        /* gather V(:,k) = x */
        {
            Vx [p] = x [Vi [p]] ;
            x [Vi [p]] = 0 ;
        }
        Ri [rnz] = k ;                     /* R(k,k) = norm (x) */
        Rx [rnz++] = cs_house (Vx+p1, Beta+k, vnz-p1) ; /* [v,beta]=house(x) */
    }
    Rp [n] = rnz ;                          /* finalize R */
    Vp [n] = vnz ;                          /* finalize V */
    return (cs_ndone (N, NULL, w, x, 1)) ;  /* success */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_qrsol.c0000644000175100001710000000353300000000000023551 0ustar00runnerdocker00000000000000#include "cs.h"
/* x=A\b where A can be rectangular; b overwritten with solution */
CS_INT cs_qrsol (CS_INT order, const cs *A, CS_ENTRY *b)
{
    CS_ENTRY *x ;
    css *S ;
    csn *N ;
    cs *AT = NULL ;
    CS_INT k, m, n, ok ;
    if (!CS_CSC (A) || !b) return (0) ; /* check inputs */
    n = A->n ;
    m = A->m ;
    if (m >= n)
    {
        S = cs_sqr (order, A, 1) ;          /* ordering and symbolic analysis */
        N = cs_qr (A, S) ;                  /* numeric QR factorization */
        x = cs_calloc (S ? S->m2 : 1, sizeof (CS_ENTRY)) ;    /* get workspace */
        ok = (S && N && x) ;
        if (ok)
        {
            cs_ipvec (S->pinv, b, x, m) ;   /* x(0:m-1) = b(p(0:m-1) */
            for (k = 0 ; k < n ; k++)       /* apply Householder refl. to x */
            {
                cs_happly (N->L, k, N->B [k], x) ;
            }
            cs_usolve (N->U, x) ;           /* x = R\x */
            cs_ipvec (S->q, x, b, n) ;      /* b(q(0:n-1)) = x(0:n-1) */
        }
    }
    else
    {
        AT = cs_transpose (A, 1) ;          /* Ax=b is underdetermined */
        S = cs_sqr (order, AT, 1) ;         /* ordering and symbolic analysis */
        N = cs_qr (AT, S) ;                 /* numeric QR factorization of A' */
        x = cs_calloc (S ? S->m2 : 1, sizeof (CS_ENTRY)) ;    /* get workspace */
        ok = (AT && S && N && x) ;
        if (ok)
        {
            cs_pvec (S->q, b, x, m) ;       /* x(q(0:m-1)) = b(0:m-1) */
            cs_utsolve (N->U, x) ;          /* x = R'\x */
            for (k = m-1 ; k >= 0 ; k--)    /* apply Householder refl. to x */
            {
                cs_happly (N->L, k, N->B [k], x) ;
            }
            cs_pvec (S->pinv, x, b, n) ;    /* b(0:n-1) = x(p(0:n-1)) */
        }
    }
    cs_free (x) ;
    cs_sfree (S) ;
    cs_nfree (N) ;
    cs_spfree (AT) ;
    return (ok) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_randperm.c0000644000175100001710000000177200000000000024224 0ustar00runnerdocker00000000000000#include "cs.h"

#include "igraph_random.h"

/* return a random permutation vector, the identity perm, or p = n-1:-1:0.
 * seed = -1 means p = n-1:-1:0.  seed = 0 means p = identity.  otherwise
 * p = random permutation.  */
CS_INT *cs_randperm (CS_INT n, CS_INT seed)
{
    CS_INT *p, k, j, t ;
    if (seed == 0) return (NULL) ;      /* return p = NULL (identity) */
    p = cs_malloc (n, sizeof (CS_INT)) ;   /* allocate result */
    if (!p) return (NULL) ;             /* out of memory */
    for (k = 0 ; k < n ; k++) p [k] = n-k-1 ;
    if (seed == -1) return (p) ;        /* return reverse permutation */
    /* srand (seed) ;                      /\* get new random number seed *\/ */
    RNG_BEGIN();
    for (k = 0 ; k < n ; k++)
    {
        /* j = k + (rand ( ) % (n-k)) ;    /\* j = rand CS_INT in range k to n-1 *\/ */
        j = RNG_INTEGER(k, n-1) ;
        t = p [j] ;                     /* swap p[k] and p[j] */
        p [j] = p [k] ;
        p [k] = t ;
    }
    RNG_END();
    return (p) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_reach.c0000644000175100001710000000127100000000000023470 0ustar00runnerdocker00000000000000#include "cs.h"
/* xi [top...n-1] = nodes reachable from graph of G*P' via nodes in B(:,k).
 * xi [n...2n-1] used as workspace */
CS_INT cs_reach (cs *G, const cs *B, CS_INT k, CS_INT *xi, const CS_INT *pinv)
{
    CS_INT p, n, top, *Bp, *Bi, *Gp ;
    if (!CS_CSC (G) || !CS_CSC (B) || !xi) return (-1) ;    /* check inputs */
    n = G->n ; Bp = B->p ; Bi = B->i ; Gp = G->p ;
    top = n ;
    for (p = Bp [k] ; p < Bp [k+1] ; p++)
    {
        if (!CS_MARKED (Gp, Bi [p]))    /* start a dfs at unmarked node i */
        {
            top = cs_dfs (Bi [p], G, top, xi, xi+n, pinv) ;
        }
    }
    for (p = top ; p < n ; p++) CS_MARK (Gp, xi [p]) ;  /* restore G */
    return (top) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_scatter.c0000644000175100001710000000160500000000000024054 0ustar00runnerdocker00000000000000#include "cs.h"
/* x = x + beta * A(:,j), where x is a dense vector and A(:,j) is sparse */
CS_INT cs_scatter (const cs *A, CS_INT j, CS_ENTRY beta, CS_INT *w, CS_ENTRY *x, CS_INT mark,
    cs *C, CS_INT nz)
{
    CS_INT i, p, *Ap, *Ai, *Ci ;
    CS_ENTRY *Ax ;
    if (!CS_CSC (A) || !w || !CS_CSC (C)) return (-1) ;     /* check inputs */
    Ap = A->p ; Ai = A->i ; Ax = A->x ; Ci = C->i ;
    for (p = Ap [j] ; p < Ap [j+1] ; p++)
    {
        i = Ai [p] ;                            /* A(i,j) is nonzero */
        if (w [i] < mark)
        {
            w [i] = mark ;                      /* i is new entry in column j */
            Ci [nz++] = i ;                     /* add i to pattern of C(:,j) */
            if (x) x [i] = beta * Ax [p] ;      /* x(i) = beta*A(i,j) */
        }
        else if (x) x [i] += beta * Ax [p] ;    /* i exists in C(:,j) already */
    }
    return (nz) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_scc.c0000644000175100001710000000354400000000000023163 0ustar00runnerdocker00000000000000#include "cs.h"
/* find the strongly connected components of a square matrix */
csd *cs_scc (cs *A)     /* matrix A temporarily modified, then restored */
{
    CS_INT n, i, k, b, nb = 0, top, *xi, *pstack, *p, *r, *Ap, *ATp, *rcopy, *Blk ;
    cs *AT ;
    csd *D ;
    if (!CS_CSC (A)) return (NULL) ;                /* check inputs */
    n = A->n ; Ap = A->p ;
    D = cs_dalloc (n, 0) ;                          /* allocate result */
    AT = cs_transpose (A, 0) ;                      /* AT = A' */
    xi = cs_malloc (2*n+1, sizeof (CS_INT)) ;          /* get workspace */
    if (!D || !AT || !xi) return (cs_ddone (D, AT, xi, 0)) ;
    Blk = xi ; rcopy = pstack = xi + n ;
    p = D->p ; r = D->r ; ATp = AT->p ;
    top = n ;
    for (i = 0 ; i < n ; i++)   /* first dfs(A) to find finish times (xi) */
    {
        if (!CS_MARKED (Ap, i)) top = cs_dfs (i, A, top, xi, pstack, NULL) ;
    }
    for (i = 0 ; i < n ; i++) CS_MARK (Ap, i) ; /* restore A; unmark all nodes*/
    top = n ;
    nb = n ;
    for (k = 0 ; k < n ; k++)   /* dfs(A') to find strongly connnected comp */
    {
        i = xi [k] ;            /* get i in reverse order of finish times */
        if (CS_MARKED (ATp, i)) continue ;  /* skip node i if already ordered */
        r [nb--] = top ;        /* node i is the start of a component in p */
        top = cs_dfs (i, AT, top, p, pstack, NULL) ;
    }
    r [nb] = 0 ;                /* first block starts at zero; shift r up */
    for (k = nb ; k <= n ; k++) r [k-nb] = r [k] ;
    D->nb = nb = n-nb ;         /* nb = # of strongly connected components */
    for (b = 0 ; b < nb ; b++)  /* sort each block in natural order */
    {
        for (k = r [b] ; k < r [b+1] ; k++) Blk [p [k]] = b ;
    }
    for (b = 0 ; b <= nb ; b++) rcopy [b] = r [b] ;
    for (i = 0 ; i < n ; i++) p [rcopy [Blk [i]]++] = i ;
    return (cs_ddone (D, AT, xi, 1)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_schol.c0000644000175100001710000000221700000000000023517 0ustar00runnerdocker00000000000000#include "cs.h"
/* ordering and symbolic analysis for a Cholesky factorization */
css *cs_schol (CS_INT order, const cs *A)
{
    CS_INT n, *c, *post, *P ;
    cs *C ;
    css *S ;
    if (!CS_CSC (A)) return (NULL) ;        /* check inputs */
    n = A->n ;
    S = cs_calloc (1, sizeof (css)) ;       /* allocate result S */
    if (!S) return (NULL) ;                 /* out of memory */
    P = cs_amd (order, A) ;                 /* P = amd(A+A'), or natural */
    S->pinv = cs_pinv (P, n) ;              /* find inverse permutation */
    cs_free (P) ;
    if (order && !S->pinv) return (cs_sfree (S)) ;
    C = cs_symperm (A, S->pinv, 0) ;        /* C = spones(triu(A(P,P))) */
    S->parent = cs_etree (C, 0) ;           /* find etree of C */
    post = cs_post (S->parent, n) ;         /* postorder the etree */
    c = cs_counts (C, S->parent, post, 0) ; /* find column counts of chol(C) */
    cs_free (post) ;
    cs_spfree (C) ;
    S->cp = cs_malloc (n+1, sizeof (CS_INT)) ; /* allocate result S->cp */
    S->unz = S->lnz = cs_cumsum (S->cp, c, n) ; /* find column pointers for L */
    cs_free (c) ;
    return ((S->lnz >= 0) ? S : cs_sfree (S)) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_spsolve.c0000644000175100001710000000255200000000000024104 0ustar00runnerdocker00000000000000#include "cs.h"
/* solve Gx=b(:,k), where G is either upper (lo=0) or lower (lo=1) triangular */
CS_INT cs_spsolve (cs *G, const cs *B, CS_INT k, CS_INT *xi, CS_ENTRY *x, const CS_INT *pinv,
    CS_INT lo)
{
    CS_INT j, J, p, q, px, top, n, *Gp, *Gi, *Bp, *Bi ;
    CS_ENTRY *Gx, *Bx ;
    if (!CS_CSC (G) || !CS_CSC (B) || !xi || !x) return (-1) ;
    Gp = G->p ; Gi = G->i ; Gx = G->x ; n = G->n ;
    Bp = B->p ; Bi = B->i ; Bx = B->x ;
    top = cs_reach (G, B, k, xi, pinv) ;        /* xi[top..n-1]=Reach(B(:,k)) */
    for (p = top ; p < n ; p++) x [xi [p]] = 0 ;    /* clear x */
    for (p = Bp [k] ; p < Bp [k+1] ; p++) x [Bi [p]] = Bx [p] ; /* scatter B */
    for (px = top ; px < n ; px++)
    {
        j = xi [px] ;                               /* x(j) is nonzero */
        J = pinv ? (pinv [j]) : j ;                 /* j maps to col J of G */
        if (J < 0) continue ;                       /* column J is empty */
        x [j] /= Gx [lo ? (Gp [J]) : (Gp [J+1]-1)] ;/* x(j) /= G(j,j) */
        p = lo ? (Gp [J]+1) : (Gp [J]) ;            /* lo: L(j,j) 1st entry */
        q = lo ? (Gp [J+1]) : (Gp [J+1]-1) ;        /* up: U(j,j) last entry */
        for ( ; p < q ; p++)
        {
            x [Gi [p]] -= Gx [p] * x [j] ;          /* x(i) -= G(i,j) * x(j) */
        }
    }
    return (top) ;                                  /* return top of stack */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_sqr.c0000644000175100001710000000737200000000000023223 0ustar00runnerdocker00000000000000#include "cs.h"
/* compute nnz(V) = S->lnz, S->pinv, S->leftmost, S->m2 from A and S->parent */
static CS_INT cs_vcount (const cs *A, css *S)
{
    CS_INT i, k, p, pa, n = A->n, m = A->m, *Ap = A->p, *Ai = A->i, *next, *head,
        *tail, *nque, *pinv, *leftmost, *w, *parent = S->parent ;
    S->pinv = pinv = cs_malloc (m+n, sizeof (CS_INT)) ;        /* allocate pinv, */
    S->leftmost = leftmost = cs_malloc (m, sizeof (CS_INT)) ;  /* and leftmost */
    w = cs_malloc (m+3*n, sizeof (CS_INT)) ;   /* get workspace */
    if (!pinv || !w || !leftmost)
    {
        cs_free (w) ;                       /* pinv and leftmost freed later */
        return (0) ;                        /* out of memory */
    }
    next = w ; head = w + m ; tail = w + m + n ; nque = w + m + 2*n ;
    for (k = 0 ; k < n ; k++) head [k] = -1 ;   /* queue k is empty */
    for (k = 0 ; k < n ; k++) tail [k] = -1 ;
    for (k = 0 ; k < n ; k++) nque [k] = 0 ;
    for (i = 0 ; i < m ; i++) leftmost [i] = -1 ;
    for (k = n-1 ; k >= 0 ; k--)
    {
        for (p = Ap [k] ; p < Ap [k+1] ; p++)
        {
            leftmost [Ai [p]] = k ;         /* leftmost[i] = min(find(A(i,:)))*/
        }
    }
    for (i = m-1 ; i >= 0 ; i--)            /* scan rows in reverse order */
    {
        pinv [i] = -1 ;                     /* row i is not yet ordered */
        k = leftmost [i] ;
        if (k == -1) continue ;             /* row i is empty */
        if (nque [k]++ == 0) tail [k] = i ; /* first row in queue k */
        next [i] = head [k] ;               /* put i at head of queue k */
        head [k] = i ;
    }
    S->lnz = 0 ;
    S->m2 = m ;
    for (k = 0 ; k < n ; k++)               /* find row permutation and nnz(V)*/
    {
        i = head [k] ;                      /* remove row i from queue k */
        S->lnz++ ;                          /* count V(k,k) as nonzero */
        if (i < 0) i = S->m2++ ;            /* add a fictitious row */
        pinv [i] = k ;                      /* associate row i with V(:,k) */
        if (--nque [k] <= 0) continue ;     /* skip if V(k+1:m,k) is empty */
        S->lnz += nque [k] ;                /* nque [k] is nnz (V(k+1:m,k)) */
        if ((pa = parent [k]) != -1)        /* move all rows to parent of k */
        {
            if (nque [pa] == 0) tail [pa] = tail [k] ;
            next [tail [k]] = head [pa] ;
            head [pa] = next [i] ;
            nque [pa] += nque [k] ;
        }
    }
    for (i = 0 ; i < m ; i++) if (pinv [i] < 0) pinv [i] = k++ ;
    cs_free (w) ;
    return (1) ;
}

/* symbolic ordering and analysis for QR or LU */
css *cs_sqr (CS_INT order, const cs *A, CS_INT qr)
{
    CS_INT n, k, ok = 1, *post ;
    css *S ;
    if (!CS_CSC (A)) return (NULL) ;        /* check inputs */
    n = A->n ;
    S = cs_calloc (1, sizeof (css)) ;       /* allocate result S */
    if (!S) return (NULL) ;                 /* out of memory */
    S->q = cs_amd (order, A) ;              /* fill-reducing ordering */
    if (order && !S->q) return (cs_sfree (S)) ;
    if (qr)                                 /* QR symbolic analysis */
    {
        cs *C = order ? cs_permute (A, NULL, S->q, 0) : ((cs *) A) ;
        S->parent = cs_etree (C, 1) ;       /* etree of C'*C, where C=A(:,q) */
        post = cs_post (S->parent, n) ;
        S->cp = cs_counts (C, S->parent, post, 1) ;  /* col counts chol(C'*C) */
        cs_free (post) ;
        ok = C && S->parent && S->cp && cs_vcount (C, S) ;
        if (ok) for (S->unz = 0, k = 0 ; k < n ; k++) S->unz += S->cp [k] ;
        if (order) cs_spfree (C) ;
    }
    else
    {
        S->unz = 4*(A->p [n]) + n ;         /* for LU factorization only, */
        S->lnz = S->unz ;                   /* guess nnz(L) and nnz(U) */
    }
    return (ok ? S : cs_sfree (S)) ;        /* return result S */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_symperm.c0000644000175100001710000000336700000000000024112 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = A(p,p) where A and C are symmetric the upper part stored; pinv not p */
cs *cs_symperm (const cs *A, const CS_INT *pinv, CS_INT values)
{
    CS_INT i, j, p, q, i2, j2, n, *Ap, *Ai, *Cp, *Ci, *w ;
    CS_ENTRY *Cx, *Ax ;
    cs *C ;
    if (!CS_CSC (A)) return (NULL) ;                    /* check inputs */
    n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    C = cs_spalloc (n, n, Ap [n], values && (Ax != NULL), 0) ; /* alloc result*/
    w = cs_calloc (n, sizeof (CS_INT)) ;                   /* get workspace */
    if (!C || !w) return (cs_done (C, w, NULL, 0)) ;    /* out of memory */
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (j = 0 ; j < n ; j++)           /* count entries in each column of C */
    {
        j2 = pinv ? pinv [j] : j ;      /* column j of A is column j2 of C */
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            i = Ai [p] ;
            if (i > j) continue ;       /* skip lower triangular part of A */
            i2 = pinv ? pinv [i] : i ;  /* row i of A is row i2 of C */
            w [CS_MAX (i2, j2)]++ ;     /* column count of C */
        }
    }
    cs_cumsum (Cp, w, n) ;              /* compute column pointers of C */
    for (j = 0 ; j < n ; j++)
    {
        j2 = pinv ? pinv [j] : j ;      /* column j of A is column j2 of C */
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            i = Ai [p] ;
            if (i > j) continue ;       /* skip lower triangular part of A*/
            i2 = pinv ? pinv [i] : i ;  /* row i of A is row i2 of C */
            Ci [q = w [CS_MAX (i2, j2)]++] = CS_MIN (i2, j2) ;
            if (Cx) Cx [q] = (i2 <= j2) ? Ax [p] : CS_CONJ (Ax [p]) ;
        }
    }
    return (cs_done (C, w, NULL, 1)) ;  /* success; free workspace, return C */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_tdfs.c0000644000175100001710000000165500000000000023354 0ustar00runnerdocker00000000000000#include "cs.h"
/* depth-first search and postorder of a tree rooted at node j */
CS_INT cs_tdfs (CS_INT j, CS_INT k, CS_INT *head, const CS_INT *next, CS_INT *post, CS_INT *stack)
{
    CS_INT i, p, top = 0 ;
    if (!head || !next || !post || !stack) return (-1) ;    /* check inputs */
    stack [0] = j ;                 /* place j on the stack */
    while (top >= 0)                /* while (stack is not empty) */
    {
        p = stack [top] ;           /* p = top of stack */
        i = head [p] ;              /* i = youngest child of p */
        if (i == -1)
        {
            top-- ;                 /* p has no unordered children left */
            post [k++] = p ;        /* node p is the kth postordered node */
        }
        else
        {
            head [p] = next [i] ;   /* remove i from children of p */
            stack [++top] = i ;     /* start dfs on child node i */
        }
    }
    return (k) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_transpose.c0000644000175100001710000000203500000000000024423 0ustar00runnerdocker00000000000000#include "cs.h"
/* C = A' */
cs *cs_transpose (const cs *A, CS_INT values)
{
    CS_INT p, q, j, *Cp, *Ci, n, m, *Ap, *Ai, *w ;
    CS_ENTRY *Cx, *Ax ;
    cs *C ;
    if (!CS_CSC (A)) return (NULL) ;    /* check inputs */
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    C = cs_spalloc (n, m, Ap [n], values && Ax, 0) ;       /* allocate result */
    w = cs_calloc (m, sizeof (CS_INT)) ;                      /* get workspace */
    if (!C || !w) return (cs_done (C, w, NULL, 0)) ;       /* out of memory */
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (p = 0 ; p < Ap [n] ; p++) w [Ai [p]]++ ;          /* row counts */
    cs_cumsum (Cp, w, m) ;                                 /* row pointers */
    for (j = 0 ; j < n ; j++)
    {
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            Ci [q = w [Ai [p]]++] = j ; /* place A(i,j) as entry C(j,i) */
            if (Cx) Cx [q] = (values > 0) ? CS_CONJ (Ax [p]) : Ax [p] ;
        }
    }
    return (cs_done (C, w, NULL, 1)) ;  /* success; free w and return C */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_updown.c0000644000175100001710000000407200000000000023724 0ustar00runnerdocker00000000000000#include "cs.h"
/* sparse Cholesky update/downdate, L*L' + sigma*w*w' (sigma = +1 or -1) */
CS_INT cs_updown (cs *L, CS_INT sigma, const cs *C, const CS_INT *parent)
{
    CS_INT n, p, f, j, *Lp, *Li, *Cp, *Ci ;
    CS_ENTRY *Lx, *Cx, alpha, gamma, w1, w2, *w ;
    double beta = 1, beta2 = 1, delta ;
#ifdef CS_COMPLEX
    cs_complex_t phase ;
#endif
    if (!CS_CSC (L) || !CS_CSC (C) || !parent) return (0) ;  /* check inputs */
    Lp = L->p ; Li = L->i ; Lx = L->x ; n = L->n ;
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    if ((p = Cp [0]) >= Cp [1]) return (1) ;        /* return if C empty */
    w = cs_malloc (n, sizeof (CS_ENTRY)) ;          /* get workspace */
    if (!w) return (0) ;                            /* out of memory */
    f = Ci [p] ;
    for ( ; p < Cp [1] ; p++) f = CS_MIN (f, Ci [p]) ;  /* f = min (find (C)) */
    for (j = f ; j != -1 ; j = parent [j]) w [j] = 0 ;  /* clear workspace w */
    for (p = Cp [0] ; p < Cp [1] ; p++) w [Ci [p]] = Cx [p] ; /* w = C */
    for (j = f ; j != -1 ; j = parent [j])          /* walk path f up to root */
    {
        p = Lp [j] ;
        alpha = w [j] / Lx [p] ;                    /* alpha = w(j) / L(j,j) */
        beta2 = beta*beta + sigma*alpha*CS_CONJ(alpha) ;
        if (beta2 <= 0) break ;                     /* not positive definite */
        beta2 = sqrt (beta2) ;
        delta = (sigma > 0) ? (beta / beta2) : (beta2 / beta) ;
        gamma = sigma * CS_CONJ(alpha) / (beta2 * beta) ;
        Lx [p] = delta * Lx [p] + ((sigma > 0) ? (gamma * w [j]) : 0) ;
        beta = beta2 ;
#ifdef CS_COMPLEX
        phase = CS_ABS (Lx [p]) / Lx [p] ;  /* phase = abs(L(j,j))/L(j,j)*/
        Lx [p] *= phase ;                   /* L(j,j) = L(j,j) * phase */
#endif
        for (p++ ; p < Lp [j+1] ; p++)
        {
            w1 = w [Li [p]] ;
            w [Li [p]] = w2 = w1 - alpha * Lx [p] ;
            Lx [p] = delta * Lx [p] + gamma * ((sigma > 0) ? w1 : w2) ;
#ifdef CS_COMPLEX
            Lx [p] *= phase ;               /* L(i,j) = L(i,j) * phase */
#endif
        }
    }
    cs_free (w) ;
    return (beta2 > 0) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_usolve.c0000644000175100001710000000102100000000000023714 0ustar00runnerdocker00000000000000#include "cs.h"
/* solve Ux=b where x and b are dense.  x=b on input, solution on output. */
CS_INT cs_usolve (const cs *U, CS_ENTRY *x)
{
    CS_INT p, j, n, *Up, *Ui ;
    CS_ENTRY *Ux ;
    if (!CS_CSC (U) || !x) return (0) ;                     /* check inputs */
    n = U->n ; Up = U->p ; Ui = U->i ; Ux = U->x ;
    for (j = n-1 ; j >= 0 ; j--)
    {
        x [j] /= Ux [Up [j+1]-1] ;
        for (p = Up [j] ; p < Up [j+1]-1 ; p++)
        {
            x [Ui [p]] -= Ux [p] * x [j] ;
        }
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_util.c0000644000175100001710000001014400000000000023362 0ustar00runnerdocker00000000000000#include "cs.h"
/* allocate a sparse matrix (triplet form or compressed-column form) */
cs *cs_spalloc (CS_INT m, CS_INT n, CS_INT nzmax, CS_INT values, CS_INT triplet)
{
    cs *A = cs_calloc (1, sizeof (cs)) ;    /* allocate the cs struct */
    if (!A) return (NULL) ;                 /* out of memory */
    A->m = m ;                              /* define dimensions and nzmax */
    A->n = n ;
    A->nzmax = nzmax = CS_MAX (nzmax, 1) ;
    A->nz = triplet ? 0 : -1 ;              /* allocate triplet or comp.col */
    A->p = cs_malloc (triplet ? nzmax : n+1, sizeof (CS_INT)) ;
    A->i = cs_malloc (nzmax, sizeof (CS_INT)) ;
    A->x = values ? cs_malloc (nzmax, sizeof (CS_ENTRY)) : NULL ;
    return ((!A->p || !A->i || (values && !A->x)) ? cs_spfree (A) : A) ;
}

/* change the max # of entries sparse matrix */
CS_INT cs_sprealloc (cs *A, CS_INT nzmax)
{
    CS_INT ok, oki, okj = 1, okx = 1 ;
    if (!A) return (0) ;
    if (nzmax <= 0) nzmax = (CS_CSC (A)) ? (A->p [A->n]) : A->nz ;
    nzmax = CS_MAX (nzmax, 1) ;
    A->i = cs_realloc (A->i, nzmax, sizeof (CS_INT), &oki) ;
    if (CS_TRIPLET (A)) A->p = cs_realloc (A->p, nzmax, sizeof (CS_INT), &okj) ;
    if (A->x) A->x = cs_realloc (A->x, nzmax, sizeof (CS_ENTRY), &okx) ;
    ok = (oki && okj && okx) ;
    if (ok) A->nzmax = nzmax ;
    return (ok) ;
}

/* free a sparse matrix */
cs *cs_spfree (cs *A)
{
    if (!A) return (NULL) ;     /* do nothing if A already NULL */
    cs_free (A->p) ;
    cs_free (A->i) ;
    cs_free (A->x) ;
    return ((cs *) cs_free (A)) ;   /* free the cs struct and return NULL */
}

/* free a numeric factorization */
csn *cs_nfree (csn *N)
{
    if (!N) return (NULL) ;     /* do nothing if N already NULL */
    cs_spfree (N->L) ;
    cs_spfree (N->U) ;
    cs_free (N->pinv) ;
    cs_free (N->B) ;
    return ((csn *) cs_free (N)) ;  /* free the csn struct and return NULL */
}

/* free a symbolic factorization */
css *cs_sfree (css *S)
{
    if (!S) return (NULL) ;     /* do nothing if S already NULL */
    cs_free (S->pinv) ;
    cs_free (S->q) ;
    cs_free (S->parent) ;
    cs_free (S->cp) ;
    cs_free (S->leftmost) ;
    return ((css *) cs_free (S)) ;  /* free the css struct and return NULL */
}

/* allocate a cs_dmperm or cs_scc result */
csd *cs_dalloc (CS_INT m, CS_INT n)
{
    csd *D ;
    D = cs_calloc (1, sizeof (csd)) ;
    if (!D) return (NULL) ;
    D->p = cs_malloc (m, sizeof (CS_INT)) ;
    D->r = cs_malloc (m+6, sizeof (CS_INT)) ;
    D->q = cs_malloc (n, sizeof (CS_INT)) ;
    D->s = cs_malloc (n+6, sizeof (CS_INT)) ;
    return ((!D->p || !D->r || !D->q || !D->s) ? cs_dfree (D) : D) ;
}

/* free a cs_dmperm or cs_scc result */
csd *cs_dfree (csd *D)
{
    if (!D) return (NULL) ;     /* do nothing if D already NULL */
    cs_free (D->p) ;
    cs_free (D->q) ;
    cs_free (D->r) ;
    cs_free (D->s) ;
    return ((csd *) cs_free (D)) ;  /* free the csd struct and return NULL */
}

/* free workspace and return a sparse matrix result */
cs *cs_done (cs *C, void *w, void *x, CS_INT ok)
{
    cs_free (w) ;                       /* free workspace */
    cs_free (x) ;
    return (ok ? C : cs_spfree (C)) ;   /* return result if OK, else free it */
}

/* free workspace and return CS_INT array result */
CS_INT *cs_idone (CS_INT *p, cs *C, void *w, CS_INT ok)
{
    cs_spfree (C) ;                     /* free temporary matrix */
    cs_free (w) ;                       /* free workspace */
    return (ok ? p : (CS_INT *) cs_free (p)) ; /* return result, or free it */
}

/* free workspace and return a numeric factorization (Cholesky, LU, or QR) */
csn *cs_ndone (csn *N, cs *C, void *w, void *x, CS_INT ok)
{
    cs_spfree (C) ;                     /* free temporary matrix */
    cs_free (w) ;                       /* free workspace */
    cs_free (x) ;
    return (ok ? N : cs_nfree (N)) ;    /* return result if OK, else free it */
}

/* free workspace and return a csd result */
csd *cs_ddone (csd *D, cs *C, void *w, CS_INT ok)
{
    cs_spfree (C) ;                     /* free temporary matrix */
    cs_free (w) ;                       /* free workspace */
    return (ok ? D : cs_dfree (D)) ;    /* return result if OK, else free it */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/cs/cs_utsolve.c0000644000175100001710000000104400000000000024105 0ustar00runnerdocker00000000000000#include "cs.h"
/* solve U'x=b where x and b are dense.  x=b on input, solution on output. */
CS_INT cs_utsolve (const cs *U, CS_ENTRY *x)
{
    CS_INT p, j, n, *Up, *Ui ;
    CS_ENTRY *Ux ;
    if (!CS_CSC (U) || !x) return (0) ;                     /* check inputs */
    n = U->n ; Up = U->p ; Ui = U->i ; Ux = U->x ;
    for (j = 0 ; j < n ; j++)
    {
        for (p = Up [j] ; p < Up [j+1]-1 ; p++)
        {
            x [j] -= CS_CONJ (Ux [p]) * x [Ui [p]] ;
        }
        x [j] /= CS_CONJ (Ux [Up [j+1]-1]) ;
    }
    return (1) ;
}
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6511428
igraph-0.9.9/vendor/source/igraph/vendor/f2c/0000755000175100001710000000000000000000000021621 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/CMakeLists.txt0000644000175100001710000001163200000000000024364 0ustar00runnerdocker00000000000000# arith.h is built during compilation using arithchk.c
add_executable(arithchk EXCLUDE_FROM_ALL arithchk.c)
target_compile_definitions(arithchk PRIVATE NO_FPINIT)  # maybe also NO_LONG_LONG?
if (NOT MSVC)
  target_link_libraries(arithchk PRIVATE m)
endif()

# Provide an option for the user to provide an external arith.h for
# cross-compilation
set(
  F2C_EXTERNAL_ARITH_HEADER "" CACHE FILEPATH
  "Path to an external arith.h to use for compiling f2c, typically for cross-compilation"
)

if(F2C_EXTERNAL_ARITH_HEADER)
  configure_file(${F2C_EXTERNAL_ARITH_HEADER} arith.h COPYONLY)
else()
  if (CMAKE_CROSSCOMPILING)
    # Warn only, as in some circumstances, such as macOS with Rosetta,
    # arithchk can be run through emulation and the build with not fail.
    message(WARNING 
      "Cross-compiling with internal ARPACK, BLAS or LAPACK, "
      "but F2C_EXTERNAL_ARITH_HEADER was not set. The build is likely to fail. "
      "See igraph's installation instructions for more information.")
  endif()
  add_custom_command(
    OUTPUT arith.h
    COMMENT "Generating arith.h for f2c..."
    COMMAND arithchk > ${CMAKE_CURRENT_BINARY_DIR}/arith.h
    DEPENDS arithchk
    VERBATIM
  )
endif()

# Hidden CMake option for Szabolcs so he can collect arith.h headers from
# multiple systems in CI
option(IGRAPH_PRINT_ARITH_HEADER "Print the contents of the generated arith.h for debugging purposes")
mark_as_advanced(IGRAPH_PRINT_ARITH_HEADER)
if(IGRAPH_PRINT_ARITH_HEADER)
  add_custom_command(
    TARGET arithchk POST_BUILD
    COMMENT "Printing contents of arith.h..."
    COMMAND arithchk
    VERBATIM USES_TERMINAL
  )
endif()

# Declare the files needed to compile our vendored f2c copy
add_library(
  f2c_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  abort_.c    dolio.c       r_sin.c
  dummy.c     dtime_.c      iio.c         r_sinh.c
  backspac.c      due.c     ilnw.c        r_sqrt.c
  c_abs.c     ef1asc_.c     inquire.c     r_tan.c
  c_cos.c     ef1cmc_.c     l_ge.c        r_tanh.c
  c_div.c     endfile.c     l_gt.c        rdfmt.c
  c_exp.c     erf_.c        l_le.c        rewind.c
  c_log.c     erfc_.c       l_lt.c        rsfe.c
  c_sin.c     err.c     lbitbits.c    rsli.c
  c_sqrt.c    etime_.c      lbitshft.c    rsne.c
  cabs.c      exit_.c       lread.c       s_cat.c
  close.c     f77_aloc.c    lwrite.c      s_cmp.c
  ctype.c     f77vers.c     s_copy.c
  d_abs.c     fmt.c     open.c        s_paus.c
  d_acos.c    fmtlib.c      pow_ci.c      s_rnge.c
  d_asin.c    ftell_.c      pow_dd.c      s_stop.c
  d_atan.c    pow_di.c      sfe.c
  d_atn2.c    getenv_.c     pow_hh.c      sig_die.c
  d_cnjg.c    h_abs.c       pow_ii.c      signal_.c
  d_cos.c     h_dim.c       pow_ri.c      signbit.c
  d_cosh.c    h_dnnt.c      pow_zi.c      sue.c
  d_dim.c     h_indx.c      pow_zz.c      system_.c
  d_exp.c     h_len.c       r_abs.c       typesize.c
  d_imag.c    h_mod.c       r_acos.c      uio.c
  d_int.c     h_nint.c      r_asin.c      uninit.c
  d_lg10.c    h_sign.c      r_atan.c      util.c
  d_log.c     hl_ge.c       r_atn2.c      wref.c
  d_mod.c     hl_gt.c       r_cnjg.c      wrtfmt.c
  d_nint.c    hl_le.c       r_cos.c       wsfe.c
  d_prod.c    hl_lt.c       r_cosh.c      wsle.c
  d_sign.c    i77vers.c     r_dim.c       wsne.c
  d_sin.c     i_abs.c       r_exp.c       xwsne.c
  d_sinh.c    i_dim.c       r_imag.c      z_abs.c
  d_sqrt.c    i_dnnt.c      r_int.c       z_cos.c
  d_tan.c     i_indx.c      r_lg10.c      z_div.c
  d_tanh.c    i_len.c       r_log.c       z_exp.c
  derf_.c     i_mod.c       r_mod.c       z_log.c
  derfc_.c    i_nint.c      r_nint.c      z_sin.c
  dfe.c   i_sign.c      r_sign.c      z_sqrt.c
  ${CMAKE_CURRENT_BINARY_DIR}/arith.h
)
target_include_directories(
  f2c_vendored
  PUBLIC
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
  ${PROJECT_SOURCE_DIR}/src
  ${PROJECT_BINARY_DIR}/src
  PRIVATE
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${CMAKE_CURRENT_BINARY_DIR}
)

if (WIN32)
  target_compile_definitions(f2c_vendored PRIVATE MSDOS)
endif()

if (MSVC)  
  target_include_directories(
    f2c_vendored
    PUBLIC
	${PROJECT_SOURCE_DIR}/msvc/include
  )
endif()

if (BUILD_SHARED_LIBS)
  set_property(TARGET f2c_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Suppress some warnings that occur in the output because we do not want to
# mess around with the source of f2c too much to fix these
if(MSVC)
  target_compile_options(f2c_vendored PRIVATE
    /wd4005  # macro redefinition: f2c redefines max and min
    /wd4311  # pointer truncation; f2c does some magic with signals in signal_.c
  )
else()
  target_compile_options(arithchk PRIVATE 
    $<$:-Wno-format-zero-length>
  )
  target_compile_options(
    f2c_vendored PRIVATE 
    $<$:-Wno-parentheses -Wno-pointer-to-int-cast -Wno-implicit-function-declaration -Wno-format-zero-length>
    $<$:-Wno-parentheses -Wno-pointer-to-int-cast -Wno-implicit-function-declaration>
  )
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/Notice0000644000175100001710000000227400000000000022772 0ustar00runnerdocker00000000000000/****************************************************************
Copyright 1990 - 1997 by AT&T, Lucent Technologies and Bellcore.

Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the names of AT&T, Bell Laboratories,
Lucent or Bellcore or any of their entities not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.

AT&T, Lucent and Bellcore disclaim all warranties with regard to
this software, including all implied warranties of
merchantability and fitness.  In no event shall AT&T, Lucent or
Bellcore be liable for any special, indirect or consequential
damages or any damages whatsoever resulting from loss of use,
data or profits, whether in an action of contract, negligence or
other tortious action, arising out of or in connection with the
use or performance of this software.
****************************************************************/

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/README0000644000175100001710000004075400000000000022513 0ustar00runnerdocker00000000000000As shipped, "makefile" is a copy of "makefile.u", a Unix makefile.
Variants for other systems have names of the form makefile.* and
have initial comments saying how to invoke them.  You may wish to
copy one of the other makefile.* files to makefile.

If you use a C++ compiler, first say

	make hadd

to create a suitable f2c.h from f2c.h0 and f2ch.add.  Otherwise,

	make f2c.h

will just copy f2c.h0 to f2c.h .

If your compiler does not recognize ANSI C headers,
compile with KR_headers defined:  either add -DKR_headers
to the definition of CFLAGS in the makefile, or insert

#define KR_headers

at the top of f2c.h .

If your system lacks onexit() and you are not using an ANSI C
compiler, then you should compile main.c with NO_ONEXIT defined.
See the comments about onexit in makefile.u.

If your system has a double drem() function such that drem(a,b)
is the IEEE remainder function (with double a, b), then you may
wish to compile r_mod.c and d_mod.c with IEEE_drem defined.

To check for transmission errors, issue the command
	make check
or
	make -f makefile.u check

This assumes you have the xsum program whose source, xsum.c,
is distributed as part of "all from f2c/src", and that it
is installed somewhere in your search path.  If you do not
have xsum, you can obtain xsum.c by sending the following E-mail
message to netlib@netlib.bell-labs.com
	send xsum.c from f2c/src

For convenience, the f2c.h0 in this directory is a copy of netlib's
"f2c.h from f2c".  It is best to install f2c.h in a standard place,
so "include f2c.h" will work in any directory without further ado.
Beware that the makefiles do not cause recompilation when f2c.h is
changed.

On machines, such as those using a DEC Alpha processor, on which
sizeof(short) == 2, sizeof(int) == sizeof(float) == 4, and
sizeof(long) == sizeof(double) == 8, it suffices to modify f2c.h by
removing the first occurrence of "long " on each line containing
"long ".  On Unix systems, you can do this by issuing the commands
	mv f2c.h f2c.h0
	sed 's/long int /int /' f2c.h0 >f2c.h
On such machines, one can enable INTEGER*8 by uncommenting the typedefs
of longint and ulongint in f2c.h and adjusting them, so they read
	typedef long longint;
	typedef unsigned long ulongint;
and by compiling libf2c with -DAllow_TYQUAD, as discussed below.


Most of the routines in libf2c are support routines for Fortran
intrinsic functions or for operations that f2c chooses not
to do "in line".  There are a few exceptions, summarized below --
functions and subroutines that appear to your program as ordinary
external Fortran routines.

If you use the REAL valued functions listed below (ERF, ERFC,
DTIME, and ETIME) with "f2c -R", then you need to compile the
corresponding source files with -DREAL=float.  To do this, it is
perhaps simplest to add "-DREAL=float" to CFLAGS in the makefile.

1.	CALL ABORT prints a message and causes a core dump.

2.	ERF(r) and DERF(d) and the REAL and DOUBLE PRECISION
	error functions (with x REAL and d DOUBLE PRECISION);
	DERF must be declared DOUBLE PRECISION in your program.
	Both ERF and DERF assume your C library provides the
	underlying erf() function (which not all systems do).

3.	ERFC(r) and DERFC(d) are the complementary error functions:
	ERFC(r) = 1 - ERF(r) and DERFC(d) = 1.d0 - DERFC(d)
	(except that their results may be more accurate than
	explicitly evaluating the above formulae would give).
	Again, ERFC and r are REAL, and DERFC and d are DOUBLE
	PRECISION (and must be declared as such in your program),
	and ERFC and DERFC rely on your system's erfc().

4.	CALL GETARG(n,s), where n is an INTEGER and s is a CHARACTER
	variable, sets s to the n-th command-line argument (or to
	all blanks if there are fewer than n command-line arguments);
	CALL GETARG(0,s) sets s to the name of the program (on systems
	that support this feature).  See IARGC below.

5.	CALL GETENV(name, value), where name and value are of type
	CHARACTER, sets value to the environment value, $name, of
	name (or to blanks if $name has not been set).

6.	NARGS = IARGC() sets NARGS to the number of command-line
	arguments (an INTEGER value).

7.	CALL SIGNAL(n,func), where n is an INTEGER and func is an
	EXTERNAL procedure, arranges for func to be invoked when n
	occurs (on systems where this makes sense).
	
If your compiler complains about the signal calls in main.c, s_paus.c,
and signal_.c, you may need to adjust signal1.h suitably.  See the
comments in signal1.h.

8.	ETIME(ARR) and DTIME(ARR) are REAL functions that return
	execution times.  ARR is declared REAL ARR(2).  The elapsed
	user and system CPU times are stored in ARR(1) and ARR(2),
	respectively.  ETIME returns the total elapsed CPU time,
	i.e., ARR(1) + ARR(2).  DTIME returns total elapsed CPU
	time since the previous call on DTIME.

9.	CALL SYSTEM(cmd), where cmd is of type CHARACTER, passes
	cmd to the system's command processor (on systems where
	this can be done).

10.	CALL FLUSH flushes all buffers.

11.	FTELL(i) is an INTEGER function that returns the current
	offset of Fortran unit i (or -1 if unit i is not open).

12.	CALL FSEEK(i, offset, whence, *errlab) attemps to move
	Fortran unit i to the specified offset: absolute offset
	if whence = 0; relative to the current offset if whence = 1;
	relative to the end of the file if whence = 2.  It branches
	to label errlab if unit i is not open or if the call
	otherwise fails.

The routines whose objects are makefile.u's $(I77) are for I/O.
The following comments apply to them.

If your system lacks /usr/include/local.h ,
then you should create an appropriate local.h in
this directory.  An appropriate local.h may simply
be empty, or it may #define VAX or #define CRAY
(or whatever else you must do to make fp.h work right).
Alternatively, edit fp.h to suite your machine.

If your system lacks /usr/include/fcntl.h , then you
should simply create an empty fcntl.h in this directory.
If your compiler then complains about creat and open not
having a prototype, compile with OPEN_DECL defined.
On many systems, open and creat are declared in fcntl.h .

If your system's sprintf does not work the way ANSI C
specifies -- specifically, if it does not return the
number of characters transmitted -- then insert the line

#define USE_STRLEN

at the end of fmt.h .  This is necessary with
at least some versions of Sun software.
In particular, if you get a warning about an improper
pointer/integer combination in compiling wref.c, then
you need to compile with -DUSE_STRLEN .

If your system's fopen does not like the ANSI binary
reading and writing modes "rb" and "wb", then you should
compile open.c with NON_ANSI_RW_MODES #defined.

If you get error messages about references to cf->_ptr
and cf->_base when compiling wrtfmt.c and wsfe.c or to
stderr->_flag when compiling err.c, then insert the line

#define NON_UNIX_STDIO

at the beginning of fio.h, and recompile everything (or
at least those modules that contain NON_UNIX_STDIO).

Unformatted sequential records consist of a length of record
contents, the record contents themselves, and the length of
record contents again (for backspace).  Prior to 17 Oct. 1991,
the length was of type int; now it is of type long, but you
can change it back to int by inserting

#define UIOLEN_int

at the beginning of fio.h.  This affects only sue.c and uio.c .

If you have a really ancient K&R C compiler that does not understand
void, add -Dvoid=int to the definition of CFLAGS in the makefile.

On VAX, Cray, or Research Tenth-Edition Unix systems, you may
need to add -DVAX, -DCRAY, or -DV10 (respectively) to CFLAGS
to make fp.h work correctly.  Alternatively, you may need to
edit fp.h to suit your machine.

If your compiler complains about the signal calls in main.c, s_paus.c,
and signal_.c, you may need to adjust signal1.h suitably.  See the
comments in signal1.h.

You may need to supply the following non-ANSI routines:

  fstat(int fileds, struct stat *buf) is similar
to stat(char *name, struct stat *buf), except that
the first argument, fileds, is the file descriptor
returned by open rather than the name of the file.
fstat is used in the system-dependent routine
canseek (in the libf2c source file err.c), which
is supposed to return 1 if it's possible to issue
seeks on the file in question, 0 if it's not; you may
need to suitably modify err.c .  On non-UNIX systems,
you can avoid references to fstat and stat by compiling
with NON_UNIX_STDIO defined; in that case, you may need
to supply access(char *Name,0), which is supposed to
return 0 if file Name exists, nonzero otherwise.

  char * mktemp(char *buf) is supposed to replace the
6 trailing X's in buf with a unique number and then
return buf.  The idea is to get a unique name for
a temporary file.

On non-UNIX systems, you may need to change a few other,
e.g.: the form of name computed by mktemp() in endfile.c and
open.c; the use of the open(), close(), and creat() system
calls in endfile.c, err.c, open.c; and the modes in calls on
fopen() and fdopen() (and perhaps the use of fdopen() itself
-- it's supposed to return a FILE* corresponding to a given
an integer file descriptor) in err.c and open.c (component ufmt
of struct unit is 1 for formatted I/O -- text mode on some systems
-- and 0 for unformatted I/O -- binary mode on some systems).
Compiling with -DNON_UNIX_STDIO omits all references to creat()
and almost all references to open() and close(), the exception
being in the function f__isdev() (in open.c).

If you wish to use translated Fortran that has funny notions
of record length for direct unformatted I/O (i.e., that assumes
RECL= values in OPEN statements are not bytes but rather counts
of some other units -- e.g., 4-character words for VMS), then you
should insert an appropriate #define for url_Adjust at the
beginning of open.c .  For VMS Fortran, for example,
#define url_Adjust(x) x *= 4
would suffice.

By default, Fortran I/O units 5, 6, and 0 are pre-connected to
stdin, stdout, and stderr, respectively.  You can change this
behavior by changing f_init() in err.c to suit your needs.
Note that f2c assumes READ(*... means READ(5... and WRITE(*...
means WRITE(6... .  Moreover, an OPEN(n,... statement that does
not specify a file name (and does not specify STATUS='SCRATCH')
assumes FILE='fort.n' .  You can change this by editing open.c
and endfile.c suitably.

Unless you adjust the "#define MXUNIT" line in fio.h, Fortran units
0, 1, ..., 99 are available, i.e., the highest allowed unit number
is MXUNIT - 1.

Lines protected from compilation by #ifdef Allow_TYQUAD
are for a possible extension to 64-bit integers in which
integer = int = 32 bits and longint = long = 64 bits.

The makefile does not attempt to compile pow_qq.c, qbitbits.c,
and qbitshft.c, which are meant for use with INTEGER*8.  To use
INTEGER*8, you must modify f2c.h to declare longint and ulongint
appropriately; then add $(QINT) to the end of the makefile's
dependency list for libf2c.a (if makefile is a copy of makefile.u;
for the PC makefiles, add pow_qq.obj qbitbits.obj qbitshft.obj
to the library's dependency list and adjust libf2c.lbc or libf2c.sy
accordingly).  Also add -DAllow_TYQUAD to the makefile's CFLAGS
assignment.  To make longint and ulongint available, it may suffice
to add -DINTEGER_STAR_8 to the CFLAGS assignment.

Following Fortran 90, s_cat.c and s_copy.c allow the target of a
(character string) assignment to be appear on its right-hand, at
the cost of some extra overhead for all run-time concatenations.
If you prefer the  extra efficiency that comes with the Fortran 77
requirement that the left-hand side of a character assignment not
be involved in the right-hand side, compile s_cat.c and s_copy.c
with -DNO_OVERWRITE .

Extensions (Feb. 1993) to NAMELIST processing:
 1. Reading a ? instead of &name (the start of a namelist) causes
the namelist being sought to be written to stdout (unit 6);
to omit this feature, compile rsne.c with -DNo_Namelist_Questions.
 2. Reading the wrong namelist name now leads to an error message
and an attempt to skip input until the right namelist name is found;
to omit this feature, compile rsne.c with -DNo_Bad_Namelist_Skip.
 3. Namelist writes now insert newlines before each variable; to omit
this feature, compile xwsne.c with -DNo_Extra_Namelist_Newlines.
 4. (Sept. 1995) When looking for the &name that starts namelist
input, lines whose first non-blank character is something other
than &, $, or ? are treated as comment lines and ignored, unless
rsne.c is compiled with -DNo_Namelist_Comments.

Nonstandard extension (Feb. 1993) to open: for sequential files,
ACCESS='APPEND' (or access='anything else starting with "A" or "a"')
causes the file to be positioned at end-of-file, so a write will
append to the file.

Some buggy Fortran programs use unformatted direct I/O to write
an incomplete record and later read more from that record than
they have written.  For records other than the last, the unwritten
portion of the record reads as binary zeros.  The last record is
a special case: attempting to read more from it than was written
gives end-of-file -- which may help one find a bug.  Some other
Fortran I/O libraries treat the last record no differently than
others and thus give no help in finding the bug of reading more
than was written.  If you wish to have this behavior, compile
uio.c with -DPad_UDread .

If you want to be able to catch write failures (e.g., due to a
disk being full) with an ERR= specifier, compile dfe.c, due.c,
sfe.c, sue.c, and wsle.c with -DALWAYS_FLUSH.  This will lead to
slower execution and more I/O, but should make ERR= work as
expected, provided fflush returns an error return when its
physical write fails.

Carriage controls are meant to be interpreted by the UNIX col
program (or a similar program).  Sometimes it's convenient to use
only ' ' as the carriage control character (normal single spacing).
If you compile lwrite.c and wsfe.c with -DOMIT_BLANK_CC, formatted
external output lines will have an initial ' ' quietly omitted,
making use of the col program unnecessary with output that only
has ' ' for carriage control.

The Fortran 77 Standard leaves it up to the implementation whether
formatted writes of floating-point numbers of absolute value < 1 have
a zero before the decimal point.  By default, libI77 omits such
superfluous zeros, but you can cause them to appear by compiling
lwrite.c, wref.c, and wrtfmt.c with -DWANT_LEAD_0 .

If your (Unix) system lacks a ranlib command, you don't need it.
Either comment out the makefile's ranlib invocation, or install
a harmless "ranlib" command somewhere in your PATH, such as the
one-line shell script

	exit 0

or (on some systems)

	exec /usr/bin/ar lts $1 >/dev/null

By default, the routines that implement complex and double complex
division, c_div.c and z_div.c, call sig_die to print an error message
and exit if they see a divisor of 0, as this is sometimes helpful for
debugging.  On systems with IEEE arithmetic, compiling c_div.c and
z_div.c with -DIEEE_COMPLEX_DIVIDE causes them instead to set both
the real and imaginary parts of the result to +INFINITY if the
numerator is nonzero, or to NaN if it vanishes.

Nowadays most Unix and Linux systems have function
	int ftruncate(int fildes, off_t len);
defined in system header file unistd.h that adjusts the length of file
descriptor fildes to length len.  Unless endfile.c is compiled with
-DNO_TRUNCATE, endfile.c #includes "unistd.h" and calls ftruncate() if
necessary to shorten files.  If your system lacks ftruncate(), compile
endfile.c with -DNO_TRUNCATE to make endfile.c use the older and more
portable scheme of shortening a file by copying to a temporary file
and back again.

The initializations for "f2c -trapuv" are done by _uninit_f2c(),
whose source is uninit.c, introduced June 2001.  On IEEE-arithmetic
systems, _uninit_f2c should initialize floating-point variables to
signaling NaNs and, at its first invocation, should enable the
invalid operation exception.  Alas, the rules for distinguishing
signaling from quiet NaNs were not specified in the IEEE P754 standard,
nor were the precise means of enabling and disabling IEEE-arithmetic
exceptions, and these details are thus system dependent.  There are
#ifdef's in uninit.c that specify them for some popular systems.  If
yours is not one of these systems, it may take some detective work to
discover the appropriate details for your system.  Sometimes it helps
to look in the standard include directories for header files with
relevant-sounding names, such as ieeefp.h, nan.h, or trap.h, and
it may be simplest to run experiments to see what distinguishes a
signaling from a quiet NaN.  (If x is initialized to a signaling
NaN and the invalid operation exception is masked off, as it should
be by default on IEEE-arithmetic systems, then computing, say,
y = x + 1 will yield a quiet NaN.)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/abort_.c0000644000175100001710000000046000000000000023233 0ustar00runnerdocker00000000000000#include "stdio.h"
#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern VOID sig_die();

int abort_()
#else
extern void sig_die(const char*,int);

int abort_(void)
#endif
{
sig_die("Fortran abort routine called", 1);
return 0;	/* not reached */
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/arithchk.c0000644000175100001710000001263600000000000023572 0ustar00runnerdocker00000000000000/****************************************************************
Copyright (C) 1997, 1998, 2000 Lucent Technologies
All Rights Reserved

Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of Lucent or any of its entities
not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
****************************************************************/

/* Try to deduce arith.h from arithmetic properties. */

#include 
#include 
#include 

#ifdef NO_FPINIT
#define fpinit_ASL()
#else
#ifndef KR_headers
extern
#ifdef __cplusplus
	"C"
#endif
	void fpinit_ASL(void);
#endif /*KR_headers*/
#endif /*NO_FPINIT*/

 static int dalign;
 typedef struct
Akind {
	char *name;
	int   kind;
	} Akind;

 static Akind
IEEE_8087	= { "IEEE_8087", 1 },
IEEE_MC68k	= { "IEEE_MC68k", 2 },
IBM		= { "IBM", 3 },
VAX		= { "VAX", 4 },
CRAY		= { "CRAY", 5};

 static double t_nan;

 static Akind *
Lcheck(void)
{
	union {
		double d;
		long L[2];
		} u;
	struct {
		double d;
		long L;
		} x[2];

	if (sizeof(x) > 2*(sizeof(double) + sizeof(long)))
		dalign = 1;
	u.L[0] = u.L[1] = 0;
	u.d = 1e13;
	if (u.L[0] == 1117925532 && u.L[1] == -448790528)
		return &IEEE_MC68k;
	if (u.L[1] == 1117925532 && u.L[0] == -448790528)
		return &IEEE_8087;
	if (u.L[0] == -2065213935 && u.L[1] == 10752)
		return &VAX;
	if (u.L[0] == 1267827943 && u.L[1] == 704643072)
		return &IBM;
	return 0;
	}

 static Akind *
icheck(void)
{
	union {
		double d;
		int L[2];
		} u;
	struct {
		double d;
		int L;
		} x[2];

	if (sizeof(x) > 2*(sizeof(double) + sizeof(int)))
		dalign = 1;
	u.L[0] = u.L[1] = 0;
	u.d = 1e13;
	if (u.L[0] == 1117925532 && u.L[1] == -448790528)
		return &IEEE_MC68k;
	if (u.L[1] == 1117925532 && u.L[0] == -448790528)
		return &IEEE_8087;
	if (u.L[0] == -2065213935 && u.L[1] == 10752)
		return &VAX;
	if (u.L[0] == 1267827943 && u.L[1] == 704643072)
		return &IBM;
	return 0;
	}

/* avoid possible warning message with printf("") */
const char *const emptyfmt = "";

#ifdef __GNUC__
#  pragma GCC diagnostic push
#  ifndef __clang__
#    pragma GCC diagnostic ignored "-Wformat-security"
#    pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#  else
#    pragma GCC diagnostic ignored "-Wformat-zero-length"
#  endif
#endif

 static Akind *
ccheck(void)
{
	union {
		double d;
		long L;
		} u;
	long Cray1;

	/* Cray1 = 4617762693716115456 -- without overflow on non-Crays */
	Cray1 = printf(emptyfmt) < 0 ? 0 : 4617762;
	if (printf(emptyfmt, Cray1) >= 0)
		Cray1 = 1000000*Cray1 + 693716;
	if (printf(emptyfmt, Cray1) >= 0)
		Cray1 = 1000000*Cray1 + 115456;
	u.d = 1e13;
	if (u.L == Cray1)
		return &CRAY;
	return 0;
	}

 static int
fzcheck(void)
{
	double a, b;
	int i;

	a = 1.;
	b = .1;
	for(i = 155;; b *= b, i >>= 1) {
		if (i & 1) {
			a *= b;
			if (i == 1)
				break;
			}
		}
	b = a * a;
	return b == 0.;
	}

 static int
need_nancheck(void)
{
	double t;

	errno = 0;
	t = log(t_nan);
	if (errno == 0)
		return 1;
	errno = 0;
	t = sqrt(t_nan);
	return errno == 0;
	}

#ifdef __GNUC__
#  ifndef __clang__
#    pragma GCC diagnostic pop
#  endif
#endif

 void
get_nanbits(unsigned int *b, int k)
{
	union { double d; unsigned int z[2]; } u, u1, u2;

	k = 2 - k;
	u1.z[k] = u2.z[k] = 0x7ff00000;
	u1.z[1-k] = u2.z[1-k] = 0;
	u.d = u1.d - u2.d;	/* Infinity - Infinity */
	b[0] = u.z[0];
	b[1] = u.z[1];
	}

 int
main(void)
{
	FILE *f;
	Akind *a = 0;
	int Ldef = 0;
	unsigned int nanbits[2];

	fpinit_ASL();
#ifdef WRITE_ARITH_H	/* for Symantec's buggy "make" */
	f = fopen("arith.h", "w");
	if (!f) {
		printf("Cannot open arith.h\n");
		return 1;
		}
#else
	f = stdout;
#endif

	if (sizeof(double) == 2*sizeof(long))
		a = Lcheck();
	else if (sizeof(double) == 2*sizeof(int)) {
		Ldef = 1;
		a = icheck();
		}
	else if (sizeof(double) == sizeof(long))
		a = ccheck();
	if (a) {
		fprintf(f, "#define %s\n#define Arith_Kind_ASL %d\n",
			a->name, a->kind);
		if (Ldef)
			fprintf(f, "#define Long int\n#define Intcast (int)(long)\n");
		if (dalign)
			fprintf(f, "#define Double_Align\n");
		if (sizeof(char*) == 8)
			fprintf(f, "#define X64_bit_pointers\n");
#ifndef NO_LONG_LONG
		if (sizeof(long long) < 8)
#endif
			fprintf(f, "#define NO_LONG_LONG\n");
		if (a->kind <= 2) {
			if (fzcheck())
				fprintf(f, "#define Sudden_Underflow\n");
			t_nan = -a->kind;
			if (need_nancheck())
				fprintf(f, "#define NANCHECK\n");
			if (sizeof(double) == 2*sizeof(unsigned int)) {
				get_nanbits(nanbits, a->kind);
				fprintf(f, "#define QNaN0 0x%x\n", nanbits[0]);
				fprintf(f, "#define QNaN1 0x%x\n", nanbits[1]);
				}
			}
		return 0;
		}
	fprintf(f, "/* Unknown arithmetic */\n");
	return 1;
	}

#ifdef __sun
#ifdef __i386
/* kludge for Intel Solaris */
void fpsetprec(int x) { }
#endif
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/backspac.c0000644000175100001710000000246000000000000023536 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef KR_headers
integer f_back(a) alist *a;
#else
integer f_back(alist *a)
#endif
{	unit *b;
	OFF_T v, w, x, y, z;
	uiolen n;
	FILE *f;

	f__curunit = b = &f__units[a->aunit];	/* curunit for error messages */
	if(a->aunit >= MXUNIT || a->aunit < 0)
		err(a->aerr,101,"backspace")
	if(b->useek==0) err(a->aerr,106,"backspace")
	if(b->ufd == NULL) {
		fk_open(1, 1, a->aunit);
		return(0);
		}
	if(b->uend==1)
	{	b->uend=0;
		return(0);
	}
	if(b->uwrt) {
		t_runc(a);
		if (f__nowreading(b))
			err(a->aerr,errno,"backspace")
		}
	f = b->ufd;	/* may have changed in t_runc() */
	if(b->url>0)
	{
		x=FTELL(f);
		y = x % b->url;
		if(y == 0) x--;
		x /= b->url;
		x *= b->url;
		(void) FSEEK(f,x,SEEK_SET);
		return(0);
	}

	if(b->ufmt==0)
	{	FSEEK(f,-(OFF_T)sizeof(uiolen),SEEK_CUR);
		fread((char *)&n,sizeof(uiolen),1,f);
		FSEEK(f,-(OFF_T)n-2*sizeof(uiolen),SEEK_CUR);
		return(0);
	}
	w = x = FTELL(f);
	z = 0;
 loop:
	while(x) {
		x -= x < 64 ? x : 64;
		FSEEK(f,x,SEEK_SET);
		for(y = x; y < w; y++) {
			if (getc(f) != '\n')
				continue;
			v = FTELL(f);
			if (v == w) {
				if (z)
					goto break2;
				goto loop;
				}
			z = v;
			}
		err(a->aerr,(EOF),"backspace")
		}
 break2:
	FSEEK(f, z, SEEK_SET);
	return 0;
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_abs.c0000644000175100001710000000043000000000000023031 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern double f__cabs();

double c_abs(z) f2c_complex *z;
#else
extern double f__cabs(double, double);

double c_abs(f2c_complex *z)
#endif
{
return( f__cabs( z->r, z->i ) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_cos.c0000644000175100001710000000055600000000000023061 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
extern double sin(), cos(), sinh(), cosh();

VOID c_cos(r, z) f2c_complex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif

void c_cos(f2c_complex *r, f2c_complex *z)
#endif
{
	double zi = z->i, zr = z->r;
	r->r =   cos(zr) * cosh(zi);
	r->i = - sin(zr) * sinh(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_div.c0000644000175100001710000000167000000000000023055 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern VOID sig_die();
VOID c_div(c, a, b)
f2c_complex *a, *b, *c;
#else
extern void sig_die(const char*,int);
void c_div(f2c_complex *c, f2c_complex *a, f2c_complex *b)
#endif
{
	double ratio, den;
	double abr, abi, cr;

	if( (abr = b->r) < 0.)
		abr = - abr;
	if( (abi = b->i) < 0.)
		abi = - abi;
	if( abr <= abi )
		{
		if(abi == 0) {
#ifdef IEEE_COMPLEX_DIVIDE
			float af, bf;
			af = bf = abr;
			if (a->i != 0 || a->r != 0)
				af = 1.;
			c->i = c->r = af / bf;
			return;
#else
			sig_die("complex division by zero", 1);
#endif
			}
		ratio = (double)b->r / b->i ;
		den = b->i * (1 + ratio*ratio);
		cr = (a->r*ratio + a->i) / den;
		c->i = (a->i*ratio - a->r) / den;
		}

	else
		{
		ratio = (double)b->i / b->r ;
		den = b->r * (1 + ratio*ratio);
		cr = (a->r + a->i*ratio) / den;
		c->i = (a->i - a->r*ratio) / den;
		}
	c->r = cr;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_exp.c0000644000175100001710000000055100000000000023064 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
extern double exp(), cos(), sin();

 VOID c_exp(r, z) f2c_complex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif

void c_exp(f2c_complex *r, f2c_complex *z)
#endif
{
	double expx, zi = z->i;

	expx = exp(z->r);
	r->r = expx * cos(zi);
	r->i = expx * sin(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_log.c0000644000175100001710000000061400000000000023051 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
extern double log(), f__cabs(), atan2();
VOID c_log(r, z) f2c_complex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double, double);

void c_log(f2c_complex *r, f2c_complex *z)
#endif
{
	double zi, zr;
	r->i = atan2(zi = z->i, zr = z->r);
	r->r = log( f__cabs(zr, zi) );
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_sin.c0000644000175100001710000000055200000000000023062 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
extern double sin(), cos(), sinh(), cosh();

VOID c_sin(r, z) f2c_complex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif

void c_sin(f2c_complex *r, f2c_complex *z)
#endif
{
	double zi = z->i, zr = z->r;
	r->r = sin(zr) * cosh(zi);
	r->i = cos(zr) * sinh(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/c_sqrt.c0000644000175100001710000000115100000000000023256 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
extern double sqrt(), f__cabs();

VOID c_sqrt(r, z) f2c_complex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double, double);

void c_sqrt(f2c_complex *r, f2c_complex *z)
#endif
{
	double mag, t;
	double zi = z->i, zr = z->r;

	if( (mag = f__cabs(zr, zi)) == 0.)
		r->r = r->i = 0.;
	else if(zr > 0)
		{
		r->r = t = sqrt(0.5 * (mag + zr) );
		t = zi / t;
		r->i = 0.5 * t;
		}
	else
		{
		t = sqrt(0.5 * (mag - zr) );
		if(zi < 0)
			t = -t;
		r->i = t;
		t = zi / t;
		r->r = 0.5 * t;
		}
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/cabs.c0000644000175100001710000000075600000000000022705 0ustar00runnerdocker00000000000000#ifdef KR_headers
extern double sqrt();
double f__cabs(real, imag) double real, imag;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double f__cabs(double real, double imag)
#endif
{
double temp;

if(real < 0)
	real = -real;
if(imag < 0)
	imag = -imag;
if(imag > real){
	temp = real;
	real = imag;
	imag = temp;
}
if((real+imag) == real)
	return(real);

temp = imag/real;
temp = real*sqrt(1.0 + temp*temp);  /*overflow!!*/
return(temp);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/changes0000644000175100001710000040750400000000000023166 0ustar00runnerdocker0000000000000031 Aug. 1989:
   1. A(min(i,j)) now is translated correctly (where A is an array).
   2. 7 and 8 character variable names are allowed (but elicit a
      complaint under -ext).
   3. LOGICAL*1 is treated as LOGICAL, with just one error message
      per LOGICAL*1 statement (rather than one per variable declared
      in that statement).  [Note that LOGICAL*1 is not in Fortran 77.]
      Like f77, f2c now allows the format in a read or write statement
      to be an integer array.

5 Sept. 1989:
   Fixed botch in argument passing of substrings of equivalenced
variables.

15 Sept. 1989:
   Warn about incorrect code generated when a character-valued
function is not declared external and is passed as a parameter
(in violation of the Fortran 77 standard) before it is invoked.
Example:

	subroutine foo(a,b)
	character*10 a,b
	call goo(a,b)
	b = a(3)
	end

18 Sept. 1989:
   Complain about overlapping initializations.

20 Sept. 1989:
   Warn about names declared EXTERNAL but never referenced;
include such names as externs in the generated C (even
though most C compilers will discard them).

24 Sept. 1989:
   New option -w8 to suppress complaint when COMMON or EQUIVALENCE
forces word alignment of a double.
   Under -A (for ANSI C), ensure that floating constants (terminated
by 'f') contain either a decimal point or an exponent field.
   Repair bugs sometimes encountered with CHAR and ICHAR intrinsic
functions.
   Restore f77's optimizations for copying and comparing character
strings of length 1.
   Always assume floating-point valued routines in libF77 return
doubles, even under -R.
   Repair occasional omission of arguments in routines having multiple
entry points.
   Repair bugs in computing offsets of character strings involved
in EQUIVALENCE.
   Don't omit structure qualification when COMMON variables are used
as FORMATs or internal files.

2 Oct. 1989:
   Warn about variables that appear only in data stmts; don't emit them.
   Fix bugs in character DATA for noncharacter variables
involved in EQUIVALENCE.
   Treat noncharacter variables initialized (at least partly) with
character data as though they were equivalenced -- put out a struct
and #define the variables.  This eliminates the hideous and nonportable
numeric values that were used to initialize such variables.
   Treat IMPLICIT NONE as IMPLICIT UNDEFINED(A-Z) .
   Quit when given invalid options.

8 Oct. 1989:
  Modified naming scheme for generated intermediate variables;
more are recycled, fewer distinct ones used.
  New option -W nn specifies nn characters/word for Hollerith
data initializing non-character variables.
  Bug fix: x(i:min(i+10,j)) used to elicit "Can't handle opcode 31 yet".
  Integer expressions of the form (i+const1) - (i+const2), where
i is a scalar integer variable, are now simplified to (const1-const2);
this leads to simpler translation of some substring expressions.
  Initialize uninitialized portions of character string arrays to 0
rather than to blanks.

9 Oct. 1989:
  New option -c to insert comments showing original Fortran source.
  New option -g to insert line numbers of original Fortran source.

10 Oct. 1989:
  ! recognized as in-line comment delimiter (a la Fortran 88).

24 Oct. 1989:
  New options to ease coping with systems that want the structs
that result from COMMON blocks to be defined just once:
  -E causes uninitialized COMMON blocks to be declared Extern;
if Extern is undefined, f2c.h #defines it to be extern.
  -ec causes a separate .c file to be emitted for each
uninitialized COMMON block: COMMON /ABC/ yields abc_com.c;
thus one can compile *_com.c into a library to ensure
precisely one definition.
  -e1c is similar to -ec, except that everything goes into
one file, along with comments that give a sed script for
splitting the file into the pieces that -ec would give.
This is for use with netlib's "execute f2c" service (for which
-ec is coerced into -e1c, and the sed script will put everything
but the COMMON definitions into f2c_out.c ).

28 Oct. 1989:
  Convert "i = i op ..." into "i op= ...;" even when i is a
dummy argument.

13 Nov. 1989:
  Name integer constants (passed as arguments) c__... rather
than c_... so
	common /c/stuff
	call foo(1)
	...
is translated correctly.

19 Nov. 1989:
  Floating-point constants are now kept as strings unless they
are involved in constant expressions that get simplified.  The
floating-point constants kept as strings can have arbitrarily
many significant figures and a very large exponent field (as
large as long int allows on the machine on which f2c runs).
Thus, for example, the body of

	subroutine zot(x)
	double precision x(6), pi
	parameter (pi=3.1415926535897932384626433832795028841972)
	x(1) = pi
	x(2) = pi+1
	x(3) = 9287349823749272.7429874923740978492734D-298374
	x(4) = .89
	x(5) = 4.0005
	x(6) = 10D7
	end

now gets translated into

    x[1] = 3.1415926535897932384626433832795028841972;
    x[2] = 4.1415926535897931;
    x[3] = 9.2873498237492727429874923740978492734e-298359;
    x[4] = (float).89;
    x[5] = (float)4.0005;
    x[6] = 1e8;

rather than the former

    x[1] = 3.1415926535897931;
    x[2] = 4.1415926535897931;
    x[3] = 0.;
    x[4] = (float)0.89000000000000003;
    x[5] = (float)4.0004999999999997;
    x[6] = 100000000.;

  Recognition of f77 machine-constant intrinsics deleted, i.e.,
epbase, epprec, epemin, epemax, eptiny, ephuge, epmrsp.

22 Nov. 1989:
  Workarounds for glitches on some Sun systems...
  libf77: libF77/makefile modified to point out possible need
to compile libF77/main.c with -Donexit=on_exit .
  libi77: libI77/wref.c (and libI77/README) modified so non-ANSI
systems can compile with USE_STRLEN defined, which will cause
	sprintf(b = buf, "%#.*f", d, x);
	n = strlen(b) + d1;
rather than
	n = sprintf(b = buf, "%#.*f", d, x) + d1;
to be compiled.

26 Nov. 1989:
  Longer names are now accepted (up to 50 characters); names may
contain underscores (in which case they will have two underscores
appended, to avoid clashes with library names).

28 Nov. 1989:
  libi77 updated:
	1. Allow 3 (or, on Crays, 4) digit exponents under format Ew.d .
	2. Try to get things right on machines where ints have 16 bits.

29 Nov. 1989:
  Supplied missing semicolon in parameterless subroutines that
have multiple entry points (all of them parameterless).

30 Nov. 1989:
  libf77 and libi77 revised to use types from f2c.h.
  f2c now types floating-point valued C library routines as "double"
rather than "doublereal" (for use with nonstandard C compilers for
which "double" is IEEE double extended).

1 Dec. 1989:
  f2c.h updated to eliminate #defines rendered unnecessary (and,
indeed, dangerous) by change of 26 Nov. to long names possibly
containing underscores.
  libi77 further revised: yesterday's change omitted two tweaks to fmt.h
(tweaks which only matter if float and real or double and doublereal are
different types).

2 Dec. 1989:
  Better error message (than "bad tag") for NAMELIST, which no longer
inhibits C output.

4 Dec. 1989:
  Allow capital letters in hex constants (f77 extension; e.g.,
x'a012BCd', X'A012BCD' and x'a012bcd' are all treated as the integer
167848909).
  libi77 further revised: lio.c lio.h lread.c wref.c wrtfmt.c tweaked
again to allow float and real or double and doublereal to be different.

6 Dec. 1989:
  Revised f2c.h -- required for the following...
  Simpler looking translations for abs, min, max, using #defines in
revised f2c.h .
  libi77: more corrections to types; additions for NAMELIST.
  Corrected casts in some I/O calls.
  Translation of NAMELIST; libi77 must still be revised.  Currently
libi77 gives you a run-time error message if you attempt NAMELIST I/O.

7 Dec. 1989:
  Fixed bug that prevented local integer variables that appear in DATA
stmts from being ASSIGNed statement labels.
  Fillers (for DATA statements initializing EQUIVALENCEd variables and
variables in COMMON) typed integer rather than doublereal (for slightly
more portability, e.g. to Crays).
  libi77: missing return values supplied in a few places; some tests
reordered for better working on the Cray.
  libf77: better accuracy for complex divide, complex square root,
real mod function (casts to double; double temporaries).

9 Dec. 1989:
  Fixed bug that caused needless (albeit harmless) empty lines to be
inserted in the C output when a comment line contained trailing blanks.
  Further tweak to type of fillers: allow doublereal fillers if the
struct has doublereal data.

11 Dec. 1989:
  Alteration of rule for producing external (C) names from names that
contain underscores.  Now the external name is always obtained by
appending a pair of underscores.

12 Dec. 1989:
  C production inhibited after most errors.

15 Dec. 1989:
  Fixed bug in headers for subroutines having two or more character
strings arguments:  the length arguments were reversed.

19 Dec. 1989:
  f2c.h libf77 libi77: adjusted so #undefs in f2c.h should not foil
compilation of libF77 and libI77.
  libf77: getenv_ adjusted to work with unsorted environments.
  libi77: the iostat= specifier should now work right with internal I/O.

20 Dec. 1989:
  f2c bugs fixed: In the absence of an err= specifier, the iostat=
specifier was generally set wrong.  Character strings containing
explicit nulls (\0) were truncated at the first null.
  Unlabeled DO loops recognized; must be terminated by ENDDO.
(Don't ask for CYCLE, EXIT, named DO loops, or DO WHILE.)

29 Dec. 1989:
  Nested unlabeled DO loops now handled properly; new warning for
extraneous text at end of FORMAT.

30 Dec. 1989:
  Fixed bug in translating dble(real(...)), dble(sngl(...)), and
dble(float(...)), where ... is either of type double complex or
is an expression requiring assignment to intermediate variables (e.g.,
dble(real(foo(x+1))), where foo is a function and x is a variable).
Regard nonblank label fields on continuation lines as an error.

3 Jan. 1990:
  New option -C++ yields output that should be understood
by C++ compilers.

6 Jan. 1989:
  -a now excludes variables that appear in a namelist from those
that it makes automatic.  (As before, it also excludes variables
that appear in a common, data, equivalence, or save statement.)
  The syntactically correct Fortran
	read(*,i) x
	end
now yields syntactically correct C (even though both the Fortran
and C are buggy -- no FORMAT has not been ASSIGNed to i).

7 Jan. 1990:
  libi77: routines supporting NAMELIST added.  Surrounding quotes
made optional when no ambiguity arises in a list or namelist READ
of a character-string value.

9 Jan. 1990:
  f2c.src made available.

16 Jan. 1990:
  New options -P to produce ANSI C or C++ prototypes for procedures
defined.  Change to -A and -C++: f2c tries to infer prototypes for
invoked procedures unless the new -!P option is given.  New warning
messages for inconsistent calling sequences among procedures within
a single file.  Most of f2c/src is affected.
  f2c.h: typedefs for procedure arguments added; netlib's f2c service
will insert appropriate typedefs for use with older versions of f2c.h.

17 Jan. 1990:
  f2c/src: defs.h exec.c format.c proc.c putpcc.c version.c xsum0.out
updated.  Castargs and protofile made extern in defs.h; exec.c
modified so superfluous else clauses are diagnosed; unused variables
omitted from declarations in format.c proc.c putpcc.c .

21 Jan. 1990:
  No C emitted for procedures declared external but not referenced.
  f2c.h: more new types added for use with -P.
  New feature: f2c accepts as arguments files ending in .p or .P;
such files are assumed to be prototype files, such as produced by
the -P option.  All prototype files are read before any Fortran files
and apply globally to all Fortran files.  Suitable prototypes help f2c
warn about calling-sequence errors and can tell f2c how to type
procedures declared external but not explicitly typed; the latter is
mainly of interest for users of the -A and -C++ options.  (Prototype
arguments are not available to netlib's "execute f2c" service.)
  New option -it tells f2c to try to infer types of untyped external
arguments from their use as parameters to prototyped or previously
defined procedures.
  f2c/src: many minor cleanups; most modules changed.  Individual
files in f2c/src are now in "bundle" format.  The former f2c.1 is
now f2c.1t; "f2c.1t from f2c" and "f2c.1t from f2c/src" are now the
same, as are "f2c.1 from f2c" and "f2c.1 from f2c/src".  People who
do not obtain a new copy of "all from f2c/src" should at least add
	fclose(sortfp);
after the call on do_init_data(outfile, sortfp) in format_data.c .

22 Jan. 1990:
  Cleaner man page wording (thanks to Doug McIlroy).
  -it now also applies to all untyped EXTERNAL procedures, not just
arguments.

23 Jan. 01:34:00 EST 1990:
  Bug fixes: under -A and -C++, incorrect C was generated for
subroutines having multiple entries but no arguments.
  Under -A -P, subroutines of no arguments were given prototype
calling sequence () rather than (void).
  Character-valued functions elicited erroneous warning messages
about inconsistent calling sequences when referenced by another
procedure in the same file.
  f2c.1t: omit first appearance of libF77.a in FILES section;
load order of libraries is -lF77 -lI77, not vice versa (bug
introduced in yesterday's edits); define .F macro for those whose
-man lacks it.  (For a while after yesterday's fixes were posted,
f2c.1t was out of date.  Sorry!)

23 Jan. 9:53:24 EST 1990:
  Character substring expressions involving function calls having
character arguments (including the intrinsic len function) yielded
incorrect C.
  Procedures defined after invocation (in the same file) with
conflicting argument types also got an erroneous message about
the wrong number of arguments.

24 Jan. 11:44:00 EST 1990:
  Bug fixes: -p omitted #undefs; COMMON block names containing
underscores had their C names incorrectly computed; a COMMON block
having the name of a previously defined procedure wreaked havoc;
if all arguments were .P files, f2c tried reading the second as a
Fortran file.
  New feature: -P emits comments showing COMMON block lengths, so one
can get warnings of incompatible COMMON block lengths by having f2c
read .P (or .p) files.  Now by running f2c twice, first with -P -!c
(or -P!c),  then with *.P among the arguments, you can be warned of
inconsistent COMMON usage, and COMMON blocks having inconsistent
lengths will be given the maximum length.  (The latter always did
happen within each input file; now -P lets you extend this behavior
across files.)

26 Jan. 16:44:00 EST 1990:
  Option -it made less aggressive: untyped external procedures that
are invoked are now typed by the rules of Fortran, rather than by
previous use of procedures to which they are passed as arguments
before being invoked.
  Option -P now includes information about references, i.e., called
procedures, in the prototype files (in the form of special comments).
This allows iterative invocations of f2c to infer more about untyped
external names, particularly when multiple Fortran files are involved.
  As usual, there are some obscure bug fixes:
1.  Repair of erroneous warning messages about inconsistent number of
arguments that arose when a character dummy parameter was discovered
to be a function or when multiple entry points involved character
variables appearing in a previous entry point.
2.  Repair of memory fault after error msg about "adjustable character
function".
3.  Under -U, allow MAIN_ as a subroutine name (in the same file as a
main program).
4.  Change for consistency: a known function invoked as a subroutine,
then as a function elicits a warning rather than an error.

26 Jan. 22:32:00 EST 1990:
  Fixed two bugs that resulted in incorrect C for substrings, within
the body of a character-valued function, of the function's name, when
those substrings were arguments to another function (even implicitly,
as in character-string assignment).

28 Jan. 18:32:00 EST 1990:
  libf77, libi77: checksum files added; "make check" looks for
transmission errors.  NAMELIST read modified to allow $ rather than &
to precede a namelist name, to allow $ rather than / to terminate
input where the name of another variable would otherwise be expected,
and to regard all nonprinting ASCII characters <= ' ' as spaces.

29 Jan. 02:11:00 EST 1990:
  "fc from f2c" added.
  -it option made the default; -!it turns it off.  Type information is
now updated in a previously missed case.
  -P option tweaked again; message about when rerunning f2c may change
prototypes or declarations made more accurate.
  New option -Ps implies -P and returns exit status 4 if rerunning
f2c -P with prototype inputs might change prototypes or declarations.
Now you can execute a crude script like

	cat *.f >zap.F
	rm -f zap.P
	while :; do
		f2c -Ps -!c zap.[FP]
		case $? in 4) ;; *) break;; esac
		done

to get a file zap.P of the best prototypes f2c can determine for *.f .

Jan. 29 07:30:21 EST 1990:
  Forgot to check for error status when setting return code 4 under -Ps;
error status (1, 2, 3, or, for caught signal, 126) now takes precedence.

Jan 29 14:17:00 EST 1990:
  Incorrect handling of
	open(n,'filename')
repaired -- now treated as
	open(n,file='filename')
(and, under -ext, given an error message).
  New optional source file memset.c for people whose systems don't
provide memset, memcmp, and memcpy; #include  in mem.c
changed to #include "string.h" so BSD people can create a local
string.h that simply says #include  .

Jan 30 10:34:00 EST 1990:
  Fix erroneous warning at end of definition of a procedure with
character arguments when the procedure had previously been called with
a numeric argument instead of a character argument.  (There were two
warnings, the second one incorrectly complaining of a wrong number of
arguments.)

Jan 30 16:29:41 EST 1990:
  Fix case where -P and -Ps erroneously reported another iteration
necessary.  (Only harm is the extra iteration.)

Feb 3 01:40:00 EST 1990:
  Supply semicolon occasionally omitted under -c .
  Try to force correct alignment when numeric variables are initialized
with character data (a non-standard and non-portable practice).  You
must use the -W option if your code has such data statements and is
meant to run on a machine with other than 4 characters/word; e.g., for
code meant to run on a Cray, you would specify -W8 .
  Allow parentheses around expressions in output lists (in write and
print statements).
  Rename source files so their names are <= 12 characters long
(so there's room to append .Z and still have <= 14 characters);
renamed files:  formatdata.c niceprintf.c niceprintf.h safstrncpy.c .
  f2c material made available by anonymous ftp from research.att.com
(look in dist/f2c ).

Feb 3 03:49:00 EST 1990:
  Repair memory fault that arose from use (in an assignment or
call) of a non-argument variable declared CHARACTER*(*).

Feb 9 01:35:43 EST 1990:
  Fix erroneous error msg about bad types in
	subroutine foo(a,adim)
	dimension a(adim)
	integer adim
  Fix improper passing of character args (and possible memory fault)
in the expression part of a computed goto.
  Fix botched calling sequences in array references involving
functions having character args.
  Fix memory fault caused by invocation of character-valued functions
of no arguments.
  Fix botched calling sequence of a character*1-valued function
assigned to a character*1 variable.
  Fix bug in error msg for inconsistent number of args in prototypes.
  Allow generation of C output despite inconsistencies in prototypes,
but give exit code 8.
  Simplify include logic (by removing some bogus logic); never
prepend "/usr/include/" to file names.
  Minor cleanups (that should produce no visible change in f2c's
behavior) in intr.c parse.h main.c defs.h formatdata.c p1output.c .

Feb 10 00:19:38 EST 1990:
  Insert (integer) casts when floating-point expressions are used
as subscripts.
  Make SAVE stmt (with no variable list) override -a .
  Minor cleanups: change field to Field in struct Addrblock (for the
benefit of buggy C compilers); omit system("/bin/cp ...") in misc.c .

Feb 13 00:39:00 EST 1990:
  Error msg fix in gram.dcl: change "cannot make %s parameter"
to "cannot make into parameter".

Feb 14 14:02:00 EST 1990:
  Various cleanups (invisible on systems with 4-byte ints), thanks
to Dave Regan: vaxx.c eliminated; %d changed to %ld various places;
external names adjusted for the benefit of stupid systems (that ignore
case and recognize only 6 significant characters in external names);
buffer shortened in xsum.c (e.g. for MS-DOS); fopen modes distinguish
text and binary files; several unused functions eliminated; missing
arg supplied to an unlikely fatalstr invocation.

Thu Feb 15 19:15:53 EST 1990:
  More cleanups (invisible on systems with 4 byte ints); casts inserted
so most complaints from cyntax(1) and lint(1) go away; a few (int)
versus (long) casts corrected.

Fri Feb 16 19:55:00 EST 1990:
  Recognize and translate unnamed Fortran 8x do while statements.
  Fix bug that occasionally caused improper breaking of character
strings.
  New error message for attempts to provide DATA in a type-declaration
statement.

Sat Feb 17 11:43:00 EST 1990:
  Fix infinite loop clf -> Fatal -> done -> clf after I/O error.
  Change "if (addrp->vclass = CLPROC)" to "if (addrp->vclass == CLPROC)"
in p1_addr (in p1output.c); this was probably harmless.
  Move a misplaced } in lex.c (which slowed initkey()).
  Thanks to Gary Word for pointing these things out.

Sun Feb 18 18:07:00 EST 1990:
  Detect overlapping initializations of arrays and scalar variables
in previously missed cases.
  Treat logical*2 as logical (after issuing a warning).
  Don't pass string literals to p1_comment().
  Correct a cast (introduced 16 Feb.) in gram.expr; this matters e.g.
on a Cray.
  Attempt to isolate UNIX-specific things in sysdep.c (a new source
file).  Unless sysdep.c is compiled with SYSTEM_SORT defined, the
intermediate files created for DATA statements are now sorted in-core
without invoking system().

Tue Feb 20 16:10:35 EST 1990:
  Move definition of binread and binwrite from init.c to sysdep.c .
  Recognize Fortran 8x tokens < <= == >= > <> as synonyms for
.LT. .LE. .EQ. .GE. .GT. .NE.
  Minor cleanup in putpcc.c:  fully remove simoffset().
  More discussion of system dependencies added to libI77/README.

Tue Feb 20 21:44:07 EST 1990:
  Minor cleanups for the benefit of EBCDIC machines -- try to remove
the assumption that 'a' through 'z' are contiguous.  (Thanks again to
Gary Word.)  Also, change log2 to log_2 (shouldn't be necessary).

Wed Feb 21 06:24:56 EST 1990:
  Fix botch in init.c introduced in previous change; only matters
to non-ASCII machines.

Thu Feb 22 17:29:12 EST 1990:
  Allow several entry points to mention the same array.  Protect
parameter adjustments with if's (for the case that an array is not
an argument to all entrypoints).
  Under -u, allow
	subroutine foo(x,n)
	real x(n)
	integer n
  Compute intermediate variables used to evaluate dimension expressions
at the right time.  Example previously mistranslated:
	subroutine foo(x,k,m,n)
	real x(min(k,m,n))
	...
	write(*,*) x
  Detect duplicate arguments.  (The error msg points to the first
executable stmt -- not wonderful, but not worth fixing.)
  Minor cleanup of min/max computation (sometimes slightly simpler).

Sun Feb 25 09:39:01 EST 1990:
  Minor tweak to multiple entry points: protect parameter adjustments
with if's only for (array) args that do not appear in all entry points.
  Minor tweaks to format.c and io.c (invisible unless your compiler
complained at the duplicate #defines of IOSUNIT and IOSFMT or at
comparisons of p1gets(...) with NULL).

Sun Feb 25 18:40:10 EST 1990:
  Fix bug introduced Feb. 22: if a subprogram contained DATA and the
first executable statement was labeled, then the label got lost.
(Just change INEXEC to INDATA in p1output.c; it occurs just once.)

Mon Feb 26 17:45:10 EST 1990:
  Fix bug in handling of " and ' in comments.

Wed Mar 28 01:43:06 EST 1990:
libI77:
 1. Repair nasty I/O bug: opening two files and closing the first
(after possibly reading or writing it), then writing the second caused
the last buffer of the second to be lost.
 2. Formatted reads of logical values treated all letters other than
t or T as f (false).
 libI77 files changed: err.c rdfmt.c Version.c
 (Request "libi77 from f2c" -- you can't get these files individually.)

f2c itself:
  Repair nasty bug in translation of
	ELSE IF (condition involving complicated abs, min, or max)
-- auxiliary statements were emitted at the wrong place.
  Supply semicolon previously omitted from the translation of a label
(of a CONTINUE) immediately preceding an ELSE IF or an ELSE.  This
bug made f2c produce invalid C.
  Correct a memory fault that occurred (on some machines) when the
error message "adjustable dimension on non-argument" should be given.
  Minor tweaks to remove some harmless warnings by overly chatty C
compilers.
  Argument arays having constant dimensions but a variable lower bound
(e.g., x(n+1:n+3)) had a * omitted from scalar arguments involved in
the array offset computation.

Wed Mar 28 18:47:59 EST 1990:
libf77: add exit(0) to end of main [return(0) encounters a Cray bug]

Sun Apr  1 16:20:58 EDT 1990:
  Avoid dereferencing null when processing equivalences after an error.

Fri Apr  6 08:29:49 EDT 1990:
  Calls involving alternate return specifiers omitted processing
needed for things like min, max, abs, and // (concatenation).
  INTEGER*2 PARAMETERs were treated as INTEGER*4.
  Convert some O(n^2) parsing to O(n).

Tue Apr 10 20:07:02 EDT 1990:
  When inconsistent calling sequences involve differing numbers of
arguments, report the first differing argument rather than the numbers
of arguments.
  Fix bug under -a: formatted I/O in which either the unit or the
format was a local character variable sometimes resulted in invalid C
(a static struct initialized with an automatic component).
  Improve error message for invalid flag after elided -.
  Complain when literal table overflows, rather than infinitely
looping.  (The complaint mentions the new and otherwise undocumented
-NL option for specifying a larger literal table.)
  New option -h for forcing strings to word (or, with -hd, double-word)
boundaries where possible.
  Repair a bug that could cause improper splitting of strings.
  Fix bug (cast of c to doublereal) in
	subroutine foo(c,r)
	double complex c
	double precision r
	c = cmplx(r,real(c))
	end
  New include file "sysdep.h" has some things from defs.h (and
elsewhere) that one may need to modify on some systems.
  Some large arrays that were previously statically allocated are now
dynamically allocated when f2c starts running.
  f2c/src files changed:
	README cds.c defs.h f2c.1 f2c.1t format.c formatdata.c init.c
	io.c lex.c main.c makefile mem.c misc.c names.c niceprintf.c
	output.c parse_args.c pread.c put.c putpcc.c sysdep.h
	version.c xsum0.out

Wed Apr 11 18:27:12 EDT 1990:
  Fix bug in argument consistency checking of character, complex, and
double complex valued functions.  If the same source file contained a
definition of such a function with arguments not explicitly typed,
then subsequent references to the function might get erroneous
warnings of inconsistent calling sequences.
  Tweaks to sysdep.h for partially ANSI systems.
  New options -kr and -krd cause f2c to use temporary variables to
enforce Fortran evaluation-order rules with pernicious, old-style C
compilers that apply the associative law to floating-point operations.

Sat Apr 14 15:50:15 EDT 1990:
  libi77: libI77 adjusted to allow list-directed and namelist I/O
of internal files; bug in namelist I/O of logical and character arrays
fixed; list input of complex numbers adjusted to permit d or D to
denote the start of the exponent field of a component.
  f2c itself: fix bug in handling complicated lower-bound
expressions for character substrings; e.g., min and max did not work
right, nor did function invocations involving character arguments.
  Switch to octal notation, rather than hexadecimal, for nonprinting
characters in character and string constants.
  Fix bug (when neither -A nor -C++ was specified) in typing of
external arguments of type complex, double complex, or character:
	subroutine foo(c)
	external c
	complex c
now results in
	/* Complex */ int (*c) ();
(as, indeed, it once did) rather than
	complex (*c) ();

Sat Apr 14 22:50:39 EDT 1990:
  libI77/makefile: updated "make check" to omit lio.c
  lib[FI]77/makefile: trivial change: define CC = cc, reference $(CC).
  (Request, e.g., "libi77 from f2c" -- you can't ask for individual
files from lib[FI]77.)

Wed Apr 18 00:56:37 EDT 1990:
  Move declaration of atof() from defs.h to sysdep.h, where it is
now not declared if stdlib.h is included.  (NeXT's stdlib.h has a
#define atof that otherwise wreaks havoc.)
  Under -u, provide a more intelligible error message (than "bad tag")
for an attempt to define a function without specifying its type.

Wed Apr 18 17:26:27 EDT 1990:
  Recognize \v (vertical tab) in Hollerith as well as quoted strings;
add recognition of \r (carriage return).
  New option -!bs turns off recognition of escapes in character strings
(\0, \\, \b, \f, \n, \r, \t, \v).
  Move to sysdep.c initialization of some arrays whose initialization
assumed ASCII; #define Table_size in sysdep.h rather than using
hard-coded 256 in allocating arrays of size 1 << (bits/byte).

Thu Apr 19 08:13:21 EDT 1990:
  Warn when escapes would make Hollerith extend beyond statement end.
  Omit max() definition from misc.c (should be invisible except on
systems that erroneously #define max in stdlib.h).

Mon Apr 23 22:24:51 EDT 1990:
  When producing default-style C (no -A or -C++), cast switch
expressions to (int).
  Move "-lF77 -lI77 -lm -lc" to link_msg, defined in sysdep.c .
  Add #define scrub(x) to sysdep.h, with invocations in format.c and
formatdata.c, so that people who have systems like VMS that would
otherwise create multiple versions of intermediate files can
#define scrub(x) unlink(x)

Tue Apr 24 18:28:36 EDT 1990:
  Pass string lengths once rather than twice to a function of character
arguments involved in comparison of character strings of length 1.

Fri Apr 27 13:11:52 EDT 1990:
  Fix bug that made f2c gag on concatenations involving char(...) on
some systems.

Sat Apr 28 23:20:16 EDT 1990:
  Fix control-stack bug in
	if(...) then
	else if (complicated condition)
	else
	endif
(where the complicated condition causes assignment to an auxiliary
variable, e.g., max(a*b,c)).

Mon Apr 30 13:30:10 EDT 1990:
  Change fillers for DATA with holes from substructures to arrays
(in an attempt to make things work right with C compilers that have
funny padding rules for substructures, e.g., Sun C compilers).
  Minor cleanup of exec.c (should not affect generated C).

Mon Apr 30 23:13:51 EDT 1990:
  Fix bug in handling return values of functions having multiple
entry points of differing return types.

Sat May  5 01:45:18 EDT 1990:
  Fix type inference bug in
	subroutine foo(x)
	call goo(x)
	end
	subroutine goo(i)
	i = 3
	end
Instead of warning of inconsistent calling sequences for goo,
f2c was simply making i a real variable; now i is correctly
typed as an integer variable, and f2c issues an error message.
  Adjust error messages issued at end of declarations so they
don't blame the first executable statement.

Sun May  6 01:29:07 EDT 1990:
  Fix bug in -P and -Ps: warn when the definition of a subprogram adds
information that would change prototypes or previous declarations.

Thu May 10 18:09:15 EDT 1990:
  Fix further obscure bug with (default) -it: inconsistent calling
sequences and I/O statements could interact to cause a memory fault.
Example:
      SUBROUTINE FOO
      CALL GOO(' Something') ! Forgot integer first arg
      END
      SUBROUTINE GOO(IUNIT,MSG)
      CHARACTER*(*)MSG
      WRITE(IUNIT,'(1X,A)') MSG
      END

Fri May 11 16:49:11 EDT 1990:
  Under -!c, do not delete any .c files (when there are errors).
  Avoid dereferencing 0 when a fatal error occurs while reading
Fortran on stdin.

Wed May 16 18:24:42 EDT 1990:
  f2c.ps made available.

Mon Jun  4 12:53:08 EDT 1990:
  Diagnose I/O units of invalid type.
  Add specific error msg about dummy arguments in common.

Wed Jun 13 12:43:17 EDT 1990:
  Under -A, supply a missing "[1]" for CHARACTER*1 variables that appear
both in a DATA statement and in either COMMON or EQUIVALENCE.

Mon Jun 18 16:58:31 EDT 1990:
  Trivial updates to f2c.ps .  ("Fortran 8x" --> "Fortran 90"; omit
"(draft)" from "(draft) ANSI C".)

Tue Jun 19 07:36:32 EDT 1990:
  Fix incorrect code generated for ELSE IF(expression involving
function call passing non-constant substring).
  Under -h, preserve the property that strings are null-terminated
where possible.
  Remove spaces between # and define in lex.c output.c parse.h .

Mon Jun 25 07:22:59 EDT 1990:
  Minor tweak to makefile to reduce unnecessary recompilations.

Tue Jun 26 11:49:53 EDT 1990:
  Fix unintended truncation of some integer constants on machines
where casting a long to (int) may change the value.  E.g., when f2c
ran on machines with 16-bit ints, "i = 99999" was being translated
to "i = -31073;".

Wed Jun 27 11:05:32 EDT 1990:
  Arrange for CHARACTER-valued PARAMETERs to honor their length
specifications.  Allow CHAR(nn) in expressions defining such PARAMETERs.

Fri Jul 20 09:17:30 EDT 1990:
  Avoid dereferencing 0 when a FORMAT statement has no label.

Thu Jul 26 11:09:39 EDT 1990:
  Remarks about VOID and binread,binwrite added to README.
  Tweaks to parse_args: should be invisible unless your compiler
complained at (short)*store.

Thu Aug  2 02:07:58 EDT 1990:
  f2c.ps: change the first line of page 5 from
	include stuff
to
	include 'stuff'

Tue Aug 14 13:21:24 EDT 1990:
  libi77: libI77 adjusted to treat tabs as spaces in list input.

Fri Aug 17 07:24:53 EDT 1990:
  libi77: libI77 adjusted so a blank='ZERO' clause (upper case Z)
in an open of a currently open file works right.

Tue Aug 28 01:56:44 EDT 1990:
  Fix bug in warnings of inconsistent calling sequences: if an
argument to a subprogram was never referenced, then a previous
invocation of the subprogram (in the same source file) that
passed something of the wrong type for that argument did not
elicit a warning message.

Thu Aug 30 09:46:12 EDT 1990:
  libi77: prevent embedded blanks in list output of complex values;
omit exponent field in list output of values of magnitude between
10 and 1e8; prevent writing stdin and reading stdout or stderr;
don't close stdin, stdout, or stderr when reopening units 5, 6, 0.

Tue Sep  4 12:30:57 EDT 1990:
  Fix bug in C emitted under -I2 or -i2 for INTEGER*4 FUNCTION.
  Warn of missing final END even if there are previous errors.

Fri Sep  7 13:55:34 EDT 1990:
  Remark about "make xsum.out" and "make f2c" added to README.

Tue Sep 18 23:50:01 EDT 1990:
  Fix null dereference (and, on some systems, writing of bogus *_com.c
files) under -ec or -e1c when a prototype file (*.p or *.P) describes
COMMON blocks that do not appear in the Fortran source.
  libi77:
    Add some #ifdef lines (#ifdef MSDOS, #ifndef MSDOS) to avoid
references to stat and fstat on non-UNIX systems.
    On UNIX systems, add component udev to unit; decide that old
and new files are the same iff both the uinode and udev components
of unit agree.
    When an open stmt specifies STATUS='OLD', use stat rather than
access (on UNIX systems) to check the existence of the file (in case
directories leading to the file have funny permissions and this is
a setuid or setgid program).

Thu Sep 27 16:04:09 EDT 1990:
  Supply missing entry for Impldoblock in blksize array of cpexpr
(in expr.c).  No examples are known where this omission caused trouble.

Tue Oct  2 22:58:09 EDT 1990:
  libf77: test signal(...) == SIG_IGN rather than & 01 in main().
  libi77: adjust rewind.c so two successive rewinds after a write
don't clobber the file.

Thu Oct 11 18:00:14 EDT 1990:
  libi77: minor cleanups: add #include "fcntl.h" to endfile.c, err.c,
open.c; adjust g_char in util.c for segmented memories; in f_inqu
(inquire.c), define x appropriately when MSDOS is defined.

Mon Oct 15 20:02:11 EDT 1990:
  Add #ifdef MSDOS pointer adjustments to mem.c; treat NAME= as a
synonym for FILE= in OPEN statements.

Wed Oct 17 16:40:37 EDT 1990:
  libf77, libi77: minor cleanups: _cleanup() and abort() invocations
replaced by invocations of sig_die in main.c; some error messages
previously lost in buffers will now appear.

Mon Oct 22 16:11:27 EDT 1990:
  libf77: separate sig_die from main (for folks who don't want to use
the main in libF77).
  libi77: minor tweak to comments in README.

Fri Nov  2 13:49:35 EST 1990:
  Use two underscores rather than one in generated temporary variable
names to avoid conflict with COMMON names.  f2c.ps updated to reflect
this change and the NAME= extension introduced 15 Oct.
  Repair a rare memory fault in io.c .

Mon Nov  5 16:43:55 EST 1990:
  libi77: changes to open.c (and err.c): complain if an open stmt
specifies new= and the file already exists (as specified by Fortrans 77
and 90); allow file= to be omitted in open stmts and allow
status='replace' (Fortran 90 extensions).

Fri Nov 30 10:10:14 EST 1990:
  Adjust malloc.c for unusual systems whose sbrk() can return values
not properly aligned for doubles.
  Arrange for slightly more helpful and less repetitive warnings for
non-character variables initialized with character data; these warnings
are (still) suppressed by -w66.

Fri Nov 30 15:57:59 EST 1990:
  Minor tweak to README (about changing VOID in f2c.h).

Mon Dec  3 07:36:20 EST 1990:
  Fix spelling of "character" in f2c.1t.

Tue Dec  4 09:48:56 EST 1990:
  Remark about link_msg and libf2c added to f2c/README.

Thu Dec  6 08:33:24 EST 1990:
  Under -U, render label nnn as L_nnn rather than Lnnn.

Fri Dec  7 18:05:00 EST 1990:
  Add more names from f2c.h (e.g. integer, real) to the c_keywords
list of names to which an underscore is appended to avoid confusion.

Mon Dec 10 19:11:15 EST 1990:
  Minor tweaks to makefile (./xsum) and README (binread/binwrite).
  libi77: a few modifications for POSIX systems; meant to be invisible
elsewhere.

Sun Dec 16 23:03:16 EST 1990:
  Fix null dereference caused by unusual erroneous input, e.g.
	call foo('abc')
	end
	subroutine foo(msg)
	data n/3/
	character*(*) msg
	end
(Subroutine foo is illegal because the character statement comes after a
data statement.)
  Use decimal rather than hex constants in xsum.c (to prevent
erroneous warning messages about constant overflow).

Mon Dec 17 12:26:40 EST 1990:
  Fix rare extra underscore in character length parameters passed
for multiple entry points.

Wed Dec 19 17:19:26 EST 1990:
  Allow generation of C despite error messages about bad alignment
forced by equivalence.
  Allow variable-length concatenations in I/O statements, such as
	open(3, file=bletch(1:n) // '.xyz')

Fri Dec 28 17:08:30 EST 1990:
  Fix bug under -p with formats and internal I/O "units" in COMMON,
as in
      COMMON /FIGLEA/F
      CHARACTER*20 F
      F = '(A)'
      WRITE (*,FMT=F) 'Hello, world!'
      END

Tue Jan 15 12:00:24 EST 1991:
  Fix bug when two equivalence groups are merged, the second with
nonzero offset, and the result is then merged into a common block.
Example:
      INTEGER W(3), X(3), Y(3), Z(3)
      COMMON /ZOT/ Z
      EQUIVALENCE (W(1),X(1)), (X(2),Y(1)), (Z(3),X(1))
***** W WAS GIVEN THE WRONG OFFSET
  Recognize Fortran 90's optional NML= in NAMELIST READs and WRITEs.
(Currently NML= and FMT= are treated as synonyms -- there's no
error message if, e.g., NML= specifies a format.)
  libi77: minor adjustment to allow internal READs from character
string constants in read-only memory.

Fri Jan 18 22:56:15 EST 1991:
  Add comment to README about needing to comment out the typedef of
size_t in sysdep.h on some systems, e.g. Sun 4.1.
  Fix misspelling of "statement" in an error message in lex.c

Wed Jan 23 00:38:48 EST 1991:
  Allow hex, octal, and binary constants to have the qualifying letter
(z, x, o, or b) either before or after the quoted string containing the
digits.  For now this change will not be reflected in f2c.ps .

Tue Jan 29 16:23:45 EST 1991:
  Arrange for character-valued statement functions to give results of
the right length (that of the statement function's name).

Wed Jan 30 07:05:32 EST 1991:
  More tweaks for character-valued statement functions: an error
check and an adjustment so a right-hand side of nonconstant length
(e.g., a substring) is handled right.

Wed Jan 30 09:49:36 EST 1991:
  Fix p1_head to avoid printing (char *)0 with %s.

Thu Jan 31 13:53:44 EST 1991:
  Add a test after the cleanup call generated for I/O statements with
ERR= or END= clauses to catch the unlikely event that the cleanup
routine encounters an error.

Mon Feb  4 08:00:58 EST 1991:
  Minor cleanup: omit unneeded jumps and labels from code generated for
some NAMELIST READs and WRITEs with IOSTAT=, ERR=, and/or END=.

Tue Feb  5 01:39:36 EST 1991:
  Change Mktemp to mktmp (for the benefit of systems so brain-damaged
that they do not distinguish case in external names -- and that for
some reason want to load mktemp).  Try to get xsum0.out right this
time (it somehow didn't get updated on 4 Feb. 1991).
  Add note to libi77/README about adjusting the interpretation of
RECL= specifiers in OPENs for direct unformatted I/O.

Thu Feb  7 17:24:42 EST 1991:
  New option -r casts values of REAL functions, including intrinsics,
to REAL.  This only matters for unportable code like
	real r
	r = asin(1.)
	if (r .eq. asin(1.)) ...
[The behavior of such code varies with the Fortran compiler used --
and sometimes is affected by compiler options.]  For now, the man page
at the end of f2c.ps is the only part of f2c.ps that reflects this new
option.

Fri Feb  8 18:12:51 EST 1991:
  Cast pointer differences passed as arguments to the appropriate type.
This matters, e.g., with MSDOS compilers that yield a long pointer
difference but have int == short.
  Disallow nonpositive dimensions.

Fri Feb 15 12:24:15 EST 1991:
  Change %d to %ld in sprintf call in putpower in putpcc.c.
  Free more memory (e.g. allowing translation of larger Fortran
files under MS-DOS).
  Recognize READ (character expression) and WRITE (character expression)
as formatted I/O with the format given by the character expression.
  Update year in Notice.

Sat Feb 16 00:42:32 EST 1991:
  Recant recognizing WRITE(character expression) as formatted output
-- Fortran 77 is not symmetric in its syntax for READ and WRITE.

Mon Mar  4 15:19:42 EST 1991:
  Fix bug in passing the real part of a complex argument to an intrinsic
function.  Omit unneeded parentheses in nested calls to intrinsics.
Example:
	subroutine foo(x, y)
	complex y
	x = exp(sin(real(y))) + exp(imag(y))
	end

Fri Mar  8 15:05:42 EST 1991:
  Fix a comment in expr.c; omit safstrncpy.c (which had bugs in
cases not used by f2c).

Wed Mar 13 02:27:23 EST 1991:
  Initialize firstmemblock->next in mem_init in mem.c .  [On most
systems it was fortuituously 0, but with System V, -lmalloc could
trip on this missed initialization.]

Wed Mar 13 11:47:42 EST 1991:
  Fix a reference to freed memory.

Wed Mar 27 00:42:19 EST 1991:
  Fix a memory fault caused by such illegal Fortran as
       function foo
       x = 3
       logical foo	! declaration among executables
       foo=.false.	! used to suffer memory fault
       end

Fri Apr  5 08:30:31 EST 1991:
  Fix loss of % in some format expressions, e.g.
	write(*,'(1h%)')
  Fix botch introduced 27 March 1991 that caused subroutines with
multiple entry points to have extraneous declarations of ret_val.

Fri Apr  5 12:44:02 EST 1991
  Try again to omit extraneous ret_val declarations -- this morning's
fix was sometimes wrong.

Mon Apr  8 13:47:06 EDT 1991:
  Arrange for s_rnge to have the right prototype under -A -C .

Wed Apr 17 13:36:03 EDT 1991:
  New fatal error message for apparent invocation of a recursive
statement function.

Thu Apr 25 15:13:37 EDT 1991:
  F2c and libi77 adjusted so NAMELIST works with -i2.  (I forgot
about -i2 when adding NAMELIST.)  This required a change to f2c.h
(that only affects NAMELIST I/O under -i2.)  Man-page description of
-i2 adjusted to reflect that -i2 stores array lengths in short ints.

Fri Apr 26 02:54:41 EDT 1991:
  Libi77: fix some bugs in NAMELIST reading of multi-dimensional arrays
(file rsne.c).

Thu May  9 02:13:51 EDT 1991:
  Omit a trailing space in expr.c (could cause a false xsum value if
a mailer drops the trailing blank).

Thu May 16 13:14:59 EDT 1991:
  Libi77: increase LEFBL in lio.h to overcome a NeXT bug.
  Tweak for compilers that recognize "nested" comments: inside comments,
turn /* into /+ (as well as */ into +/).

Sat May 25 11:44:25 EDT 1991:
  libf77: s_rnge: declare line long int rather than int.

Fri May 31 07:51:50 EDT 1991:
  libf77: system_: officially return status.

Mon Jun 17 16:52:53 EDT 1991:
  Minor tweaks: omit unnecessary declaration of strcmp (that caused
trouble on a system where strcmp was a macro) from misc.c; add
SHELL = /bin/sh to makefiles.
  Fix a dereference of null when a CHARACTER*(*) declaration appears
(illegally) after DATA.  Complain only once per subroutine about
declarations appearing after DATA.

Mon Jul  1 00:28:13 EDT 1991:
  Add test and error message for illegal use of subroutine names, e.g.
      SUBROUTINE ZAP(A)
      ZAP = A
      END

Mon Jul  8 21:49:20 EDT 1991:
  Issue a warning about things like
	integer i
	i = 'abc'
(which is treated as i = ichar('a')).  [It might be nice to treat 'abc'
as an integer initialized (in a DATA statement) with 'abc', but
other matters have higher priority.]
  Render
	i = ichar('A')
as
	i = 'A';
rather than
	i = 65;
(which assumes ASCII).

Fri Jul 12 07:41:30 EDT 1991:
  Note added to README about erroneous definitions of __STDC__ .

Sat Jul 13 13:38:54 EDT 1991:
  Fix bugs in double type convesions of complex values, e.g.
sngl(real(...)) or dble(real(...)) (where ... is complex).

Mon Jul 15 13:21:42 EDT 1991:
  Fix bug introduced 8 July 1991 that caused erroneous warnings
"ichar([first char. of] char. string) assumed for conversion to numeric"
when a subroutine had an array of character strings as an argument.

Wed Aug 28 01:12:17 EDT 1991:
  Omit an unused function in format.c, an unused variable in proc.c .
  Under -r8, promote complex to double complex (as the man page claims).

Fri Aug 30 17:19:17 EDT 1991:
  f2c.ps updated: slightly expand description of intrinsics and,or,xor,
not; add mention of intrinsics lshift, rshift; add note about f2c
accepting Fortran 90 inline comments (starting with !); update Cobalt
Blue address.

Tue Sep 17 07:17:33 EDT 1991:
  libI77: err.c and open.c modified to use modes "rb" and "wb"
when (f)opening unformatted files; README updated to point out
that it may be necessary to change these modes to "r" and "w"
on some non-ANSI systems.

Tue Oct 15 10:25:49 EDT 1991:
  Minor tweaks that make some PC compilers happier: insert some
casts, add args to signal functions.
  Change -g to emit uncommented #line lines -- and to emit more of them;
update fc, f2c.1, f2c.1t, f2c.ps to reflect this.
  Change uchar to Uchar in xsum.c .
  Bring gram.c up to date.

Thu Oct 17 09:22:05 EDT 1991:
  libi77: README, fio.h, sue.c, uio.c changed so the length field
in unformatted sequential records has type long rather than int
(unless UIOLEN_int is #defined).  This is for systems where sizeof(int)
can vary, depending on the compiler or compiler options.

Thu Oct 17 13:42:59 EDT 1991:
  libi77: inquire.c: when MSDOS is defined, don't strcmp units[i].ufnm
when it is NULL.

Fri Oct 18 15:16:00 EDT 1991:
  Correct xsum0.out in "all from f2c/src" (somehow botched on 15 Oct.).

Tue Oct 22 18:12:56 EDT 1991:
  Fix memory fault when a character*(*) argument is used (illegally)
as a dummy variable in the definition of a statement function.  (The
memory fault occurred when the statement function was invoked.)
  Complain about implicit character*(*).

Thu Nov 14 08:50:42 EST 1991:
  libi77: change uint to Uint in fmt.h, rdfmt.c, wrtfmt.c; this change
should be invisible unless you're running a brain-damaged system.

Mon Nov 25 19:04:40 EST 1991:
  libi77: correct botches introduced 17 Oct. 1991 and 14 Nov. 1991
(change uint to Uint in lwrite.c; other changes that only matter if
sizeof(int) != sizeof(long)).
  Add a more meaningful error message when bailing out due to an attempt
to invoke a COMMON variable as a function.

Sun Dec  1 19:29:24 EST 1991:
  libi77: uio.c: add test for read failure (seq. unformatted reads);
adjust an error return from EOF to off end of record.

Tue Dec 10 17:42:28 EST 1991:
  Add tests to prevent memory faults with bad uses of character*(*).

Thu Dec 12 11:24:41 EST 1991:
  libi77: fix bug with internal list input that caused the last
character of each record to be ignored; adjust error message in
internal formatted input from "end-of-file" to "off end of record"
if the format specifies more characters than the record contains.

Wed Dec 18 17:48:11 EST 1991:
  Fix bug in translating nonsensical ichar invocations involving
concatenations.
  Fix bug in passing intrinsics lle, llt, lge, lgt as arguments;
hl_le was being passed rather than l_le, etc.
  libf77: adjust length parameters from long to ftnlen, for
compiling with f2c_i2 defined.

Sat Dec 21 15:30:57 EST 1991:
  Allow DO nnn ... to end with an END DO statement labelled nnn.

Tue Dec 31 13:53:47 EST 1991:
  Fix bug in handling dimension a(n**3,2) -- pow_ii was called
incorrectly.
  Fix bug in translating
	subroutine x(abc,n)
	character abc(n)
	write(abc,'(i10)') 123
	end
(omitted declaration and initialiation of abc_dim1).
  Complain about dimension expressions of such invalid types
as complex and logical.

Fri Jan 17 11:54:20 EST 1992:
  Diagnose some illegal uses of main program name (rather than
memory faulting).
  libi77:  (1) In list and namelist input, treat "r* ," and "r*,"
alike (where r is a positive integer constant), and fix a bug in
handling null values following items with repeat counts (e.g.,
2*1,,3).  (2) For namelist reading of a numeric array, allow a new
name-value subsequence to terminate the current one (as though the
current one ended with the right number of null values).
(3) [lio.h, lwrite.c]:  omit insignificant zeros in list and namelist
output.  (Compile with -DOld_list_output to get the old behavior.)

Sat Jan 18 15:58:01 EST 1992:
  libi77:  make list output consistent with F format by printing .1
rather than 0.1 (introduced yesterday).

Wed Jan 22 08:32:43 EST 1992:
  libi77:  add comment to README pointing out preconnection of
Fortran units 5, 6, 0 to stdin, stdout, stderr (respectively).

Mon Feb  3 11:57:53 EST 1992:
  libi77:  fix namelist read bug that caused the character following
a comma to be ignored.

Fri Feb 28 01:04:26 EST 1992:
  libf77:  fix buggy z_sqrt.c (double precision square root), which
misbehaved for arguments in the southwest quadrant.

Thu Mar 19 15:05:18 EST 1992:
  Fix bug (introduced 17 Jan 1992) in handling multiple entry points
of differing types (with implicitly typed entries appearing after
the first executable statement).
  Fix memory fault in the following illegal Fortran:
        double precision foo(i)
*	illegal: above should be "double precision function foo(i)"
        foo = i * 3.2
        entry moo(i)
        end
  Note about ANSI_Libraries (relevant, e.g., to IRIX 4.0.1 and AIX)
added to README.
  Abort zero divides during constant simplification.

Sat Mar 21 01:27:09 EST 1992:
  Tweak ckalloc (misc.c) for systems where malloc(0) = 0; this matters
for subroutines with multiple entry points but no arguments.
  Add "struct memblock;" to init.c (irrelevant to most compilers).

Wed Mar 25 13:31:05 EST 1992:
  Fix bug with IMPLICIT INTEGER*4(...): under -i2 or -I2, the *4 was
ignored.

Tue May  5 09:53:55 EDT 1992:
  Tweaks to README; e.g., ANSI_LIbraries changed to ANSI_Libraries .

Wed May  6 23:49:07 EDT 1992
  Under -A and -C++, have subroutines return 0 (even if they have
no * arguments).
  Adjust libi77 (rsne.c and lread.c) for systems where ungetc is
a macro.  Tweak lib[FI]77/makefile to use unique intermediate file
names (for parallel makes).

Tue May 19 09:03:05 EDT 1992:
  Adjust libI77 to make err= work with internal list and formatted I/O.

Sat May 23 18:17:42 EDT 1992:
  Under -A and -C++, supply "return 0;" after the code generated for
a STOP statement -- the C compiler doesn't know that s_stop won't
return.
  New (mutually exclusive) options:
	-f	treats all input lines as free-format lines,
		honoring text that appears after column 72
		and not padding lines shorter than 72 characters
		with blanks (which matters if a character string
		is continued across 2 or more lines).
	-72	treats text appearing after column 72 as an error.

Sun May 24 09:45:37 EDT 1992:
  Tweak description of -f in f2c.1 and f2c.1t; update f2c.ps .

Fri May 29 01:17:15 EDT 1992:
  Complain about externals used as variables.  Example
	subroutine foo(a,b)
	external b
	a = a*b		! illegal use of b; perhaps should be b()
	end

Mon Jun 15 11:15:27 EDT 1992:
  Fix bug in handling namelists with names that have underscores.

Sat Jun 27 17:30:59 EDT 1992:
  Under -A and -C++, end Main program aliases with "return 0;".
  Under -A and -C++, use .P files and usage in previous subprograms
in the current file to give prototypes for functions declared EXTERNAL
but not invoked.
  Fix memory fault under -d1 -P .
  Under -A and -C++, cast arguments to the right types in calling
a function that has been defined in the current file or in a .P file.
  Fix bug in handling multi-dimensional arrays with array references
in their leading dimensions.
  Fix bug in the intrinsic cmplx function when the first argument
involves an expression for which f2c generates temporary variables,
e.g. cmplx(abs(real(a)),1.) .

Sat Jul 18 07:36:58 EDT 1992:
  Fix buglet with -e1c (invisible on most systems) temporary file
f2c_functions was unlinked before being closed.
  libf77: fix bugs in evaluating m**n for integer n < 0 and m an
integer different from 1 or a real or double precision 0.
Catch SIGTRAP (to print "Trace trap" before aborting).  Programs
that previously erroneously computed 1 for 0**-1 may now fault.
Relevant routines: main.c pow_di.c pow_hh.c pow_ii.c pow_ri.c .

Sat Jul 18 08:40:10 EDT 1992:
  libi77: allow namelist input to end with & (e.g. &end).

Thu Jul 23 00:14:43 EDT 1992
  Append two underscores rather than one to C keywords used as
local variables to avoid conflicts with similarly named COMMON blocks.

Thu Jul 23 11:20:55 EDT 1992:
  libf77, libi77 updated to assume ANSI prototypes unless KR_headers
is #defined.
  libi77 now recognizes a Z format item as in Fortran 90;
the implementation assumes 8-bit bytes and botches character strings
on little-endian machines (by printing their bytes from right to
left): expect this bug to persist; fixing it would require a
change to the I/O calling sequences.

Tue Jul 28 15:18:33 EDT 1992:
  libi77: insert missed "#ifdef KR_headers" lines around getnum
header in rsne.c.  Version not updated.

NOTE: "index from f2c" now ends with current timestamps of files in
"all from f2c/src", sorted by time.  To bring your source up to date,
obtain source files with a timestamp later than the time shown in your
version.c.

Fri Aug 14 08:07:09 EDT 1992:
  libi77: tweak wrt_E in wref.c to avoid signing NaNs.

Sun Aug 23 19:05:22 EDT 1992:
  fc: supply : after O in getopt invocation (for -O1 -O2 -O3).

Mon Aug 24 18:37:59 EDT 1992:
  Recant above tweak to fc: getopt is dumber than I thought;
it's necessary to say -O 1 (etc.).
  libF77/README: add comments about ABORT, ERF, DERF, ERFC, DERFC,
GETARG, GETENV, IARGC, SIGNAL, and SYSTEM.

Tue Oct 27 01:57:42 EST 1992:
  libf77, libi77:
    1.  Fix botched indirection in signal_.c.
    2.  Supply missing l_eof = 0 assignment to s_rsne() in rsne.c (so
end-of-file on other files won't confuse namelist reads of external
files).
    3.  Prepend f__ to external names that are only of internal
interest to lib[FI]77.

Thu Oct 29 12:37:18 EST 1992:
  libf77: Fix botch in signal_.c when KR_headers is #defined;
add CFLAGS to makefile.
  libi77: trivial change to makefile for consistency with
libF77/makefile.

Wed Feb  3 02:05:16 EST 1993:
  Recognize types INTEGER*1, LOGICAL*1, LOGICAL*2, INTEGER*8.
INTEGER*8 is not well tested and will only work reasonably on
systems where int = 4 bytes, long = 8 bytes; on such systems,
you'll have to modify f2c.h appropriately, changing integer
from long to int and adding typedef long longint.  You'll also
have to compile libI77 with Allow_TYQUAD #defined and adjust
libF77/makefile to compile pow_qq.c.  In the f2c source, changes
for INTEGER*8 are delimited by #ifdef TYQUAD ... #endif.  You
can omit the INTEGER*8 changes by compiling with NO_TYQUAD
#defined.  Otherwise, the new command-line option -!i8
disables recognition of INTEGER*8.
  libf77: add pow_qq.c
  libi77: add #ifdef Allow_TYQUAD stuff.  Changes for INTEGER*1,
LOGICAL*1, and LOGICAL*2 came last 23 July 1992.  Fix bug in
backspace (that only bit when the last character of the second
or subsequent buffer read was the previous newline).  Guard
against L_tmpnam being too small in endfile.c.  For MSDOS,
close and reopen files when copying to truncate.  Lengthen
LINTW (buffer size in lwrite.c).
  Add \ to the end of #define lines that get broken.
  Fix bug in handling NAMELIST of items in EQUIVALENCE.
  Under -h (or -hd), convert Hollerith to integer in general expressions
(e.g., assignments), not just when they're passed as arguments, and
blank-pad rather than 0-pad the Hollerith to a multiple of
sizeof(integer) or sizeof(doublereal).
  Add command-line option -s, which instructs f2c preserve multi-
dimensional subscripts (by emitting and using appropriate #defines).
  Fix glitch (with default type inferences) in examples like
	call foo('abc')
	end
	subroutine foo(goo)
	end
This gave two warning messages:
	Warning on line 4 of y.f: inconsistent calling sequences for foo:
	        here 1, previously 2 args and string lengths.
	Warning on line 4 of y.f: inconsistent calling sequences for foo:
	        here 2, previously 1 args and string lengths.
Now the second Warning is suppressed.
  Complain about all inconsistent arguments, not just the first.
  Switch to automatic creation of "all from f2c/src".  For folks
getting f2c source via ftp, this means f2c/src/all.Z is now an
empty file rather than a bundle.
  Separate -P and -A: -P no longer implies -A.

Thu Feb  4 00:32:20 EST 1993:
  Fix some glitches (introduced yesterday) with -h .

Fri Feb  5 01:40:38 EST 1993:
  Fix bug in types conveyed for namelists (introduced 3 Feb. 1993).

Fri Feb  5 21:26:43 EST 1993:
  libi77: tweaks to NAMELIST and open (after comments by Harold
Youngren):
 1. Reading a ? instead of &name (the start of a namelist) causes
    the namelist being sought to be written to stdout (unit 6);
    to omit this feature, compile rsne.c with -DNo_Namelist_Questions.
 2. Reading the wrong namelist name now leads to an error message
    and an attempt to skip input until the right namelist name is found;
    to omit this feature, compile rsne.c with -DNo_Bad_Namelist_Skip.
 3. Namelist writes now insert newlines before each variable; to omit
    this feature, compile xwsne.c with -DNo_Extra_Namelist_Newlines.
 4. For OPEN of sequential files, ACCESS='APPEND' (or
    access='anything else starting with "A" or "a"') causes the file to
    be positioned at end-of-file, so a write will append to the file.
    (This is nonstandard, but does not require modifying data
    structures.)

Mon Feb  8 14:40:37 EST 1993:
  Increase number of continuation lines allowed from 19 to 99,
and allow changing this limit with -NC (e.g. -NC200 for 200 lines).
  Treat control-Z (at the beginning of a line) as end-of-file: see
the new penultimate paragraph of README.
  Fix a rarely seen glitch that could make an error messages to say
"line 0".

Tue Feb  9 02:05:40 EST 1993
  libi77: change some #ifdef MSDOS lines to #ifdef NON_UNIX_STDIO,
and, in err.c under NON_UNIX_STDIO, avoid close(creat(name,0666))
when the unit has another file descriptor for name.

Tue Feb  9 17:12:49 EST 1993
  libi77: more tweaks for NON_UNIX_STDIO: use stdio routines
rather than open, close, creat, seek, fdopen (except for f__isdev).

Fri Feb 12 15:49:33 EST 1993
  Update src/gram.c (which was forgotten in the recent updates).
Most folks regenerate it anyway (wity yacc or bison).

Thu Mar  4 17:07:38 EST 1993
  Increase default max labels in computed gotos and alternate returns
to 257, and allow -Nl1234 to specify this number.
  Tweak put.c to check p->tag == TADDR in realpart() and imagpart().
  Adjust fc script to allow .r (RATFOR) files and -C (check subscripts).
  Avoid declaring strchr in niceprintf.c under -DANSI_Libraries .
  gram.c updated again.
  libi77: err.c, open.c: take declaration of fdopen from rawio.h.

Sat Mar  6 07:09:11 EST 1993
  libi77: uio.c: adjust off-end-of-record test for sequential
unformatted reads to respond to err= rather than end= .

Sat Mar  6 16:12:47 EST 1993
  Treat scalar arguments of the form (v) and v+0, where v is a variable,
as expressions: assign to a temporary variable, and pass the latter.
  gram.c updated.

Mon Mar  8 09:35:38 EST 1993
  "f2c.h from f2c" updated to add types logical1 and integer1 for
LOGICAL*1 and INTEGER*1.  ("f2c.h from f2c" is supposed to be the
same as "f2c.h from f2c/src", which was updated 3 Feb. 1993.)

Mon Mar  8 17:57:55 EST 1993
  Fix rarely seen bug that could cause strange casts in function
invocations (revealed by an example with msdos/f2c.exe).
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only).

Fri Mar 12 12:37:01 EST 1993
  Fix bug with -s in handling subscripts involving min, max, and
complicated expressions requiring temporaries.
  Fix bug in handling COMMONs that need padding by a char array.
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only).

Fri Mar 12 17:16:16 EST 1993
  libf77, libi77: updated for compiling under C++.

Mon Mar 15 16:21:37 EST 1993
  libi77: more minor tweaks (for -DKR_headers); Version.c not changed.

Thu Mar 18 12:37:30 EST 1993
  Flag -r (for discarding carriage-returns on systems that end lines
with carriage-return/newline pairs, e.g. PCs) added to xsum, and
xsum.c converted to ANSI/ISO syntax (with K&R syntax available with
-DKR_headers).  [When time permits, the f2c source will undergo a
similar conversion.]
  libi77: tweaks to #includes in endfile.c, err.c, open.c, rawio.h;
Version.c not changed.
  f2c.ps updated (to pick up revision of 2 Feb. 1993 to f2c.1).

Fri Mar 19 09:19:26 EST 1993
  libi77: add (char *) casts to malloc and realloc invocations
in err.c, open.c; Version.c not changed.

Tue Mar 30 07:17:15 EST 1993
  Fix bug introduced 6 March 1993: possible memory corruption when
loops in data statements involve constant subscripts, as in
	 DATA (GUNIT(1,I),I=0,14)/15*-1/

Tue Mar 30 16:17:42 EST 1993
  Fix bug with -s: (floating-point array item)*(complex item)
generates an _subscr() reference for the floating-point array,
but a #define for the _subscr() was omitted.

Tue Apr  6 12:11:22 EDT 1993
  libi77: adjust error returns for formatted inputs to flush the current
input line when err= is specified.  To restore the old behavior (input
left mid-line), either adjust the #definition of errfl in fio.h or omit
the invocation of f__doend in err__fl (in err.c).

Tue Apr  6 13:30:04 EDT 1993
  Fix bug revealed in
	subroutine foo(i)
	call goo(int(i))
	end
which now passes a copy of i, rather than i itself.

Sat Apr 17 11:41:02 EDT 1993
  Adjust appending of underscores to conform with f2c.ps ("A Fortran
to C Converter"): names that conflict with C keywords or f2c type
names now have just one underscore appended (rather than two); add
"integer1", "logical1", "longint" to the keyword list.
  Append underscores to names that appear in EQUIVALENCE and are
component names in a structure declared in f2c.h, thus avoiding a
problem caused by the #defines emitted for equivalences.  Example:
	complex a
	equivalence (i,j)
	a = 1	! a.i went awry because of #define i
	j = 2
	write(*,*) a, i
	end
  Adjust line-breaking logic to avoid splitting very long constants
(and names).  Example:
	! The next line starts with tab and thus is a free-format line.
	a=.012345689012345689012345689012345689012345689012345689012345689012345689
	end
  Omit extraneous "return 0;" from entry stubs emitted for multiple
entry points of type character, complex, or double complex.

Sat Apr 17 14:35:05 EDT 1993
  Fix bug (introduced 4 Feb.) in separating -P from -A that kept f2c
from re-reading a .P file written without -A or -C++ describing a
routine with an external argument.  [See the just-added note about
separating -P from -A in the changes above for 3 Feb. 1993.]
  Fix bug (type UNKNOWN for V in the example below) revealed by
	subroutine a()
	external c
	call b(c)
	end
	subroutine b(v)
	end

Sun Apr 18 19:55:26 EDT 1993
  Fix wrong calling sequence for mem() in yesterday's addition to
equiv.c .

Wed Apr 21 17:39:46 EDT 1993
  Fix bug revealed in

      ASSIGN 10 TO L1
      GO TO 20
 10   ASSIGN 30 TO L2
      STOP 10

 20   ASSIGN 10 TO L2	! Bug here because 10 had been assigned
			! to another label, then defined.
      GO TO L2
 30   END

Fri Apr 23 18:38:50 EDT 1993
  Fix bug with -h revealed in
	CHARACTER*9 FOO
	WRITE(FOO,'(I6)') 1
	WRITE(FOO,'(I6)') 2	! struct icilist io___3 botched
	END

Tue Apr 27 16:08:28 EDT 1993
  Tweak to makefile: remove "size f2c".

Tue May  4 23:48:20 EDT 1993
  libf77: tweak signal_ line of f2ch.add .

Tue Jun  1 13:47:13 EDT 1993
  Fix bug introduced 3 Feb. 1993 in handling multiple entry
points with differing return types -- the postfix array in proc.c
needed a new entry for integer*8 (which resulted in wrong
Multitype suffixes for non-integral types).
  For (default) K&R C, generate VOID rather than int functions for
functions of Fortran type character, complex, and double complex.
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only).

Tue Jun  1 23:11:15 EDT 1993
  f2c.h: add Multitype component g and commented type longint.
  proc.c: omit "return 0;" from stubs for complex and double complex
entries (when entries have multiple types); add test to avoid memory
fault with illegal combinations of entry types.

Mon Jun  7 12:00:47 EDT 1993
  Fix memory fault in
	common /c/ m
	integer m(1)
	data m(1)/1/, m(2)/2/	! one too many initializers
	end
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only).

Fri Jun 18 13:55:51 EDT 1993
  libi77: change type of signal_ in f2ch.add; change type of il in
union Uint from long to integer (for machines like the DEC Alpha,
where integer should be the same as int).  Version.c not changed.
  Tweak gram.dcl and gram.head: add semicolons after some rules that
lacked them, and remove an extraneous semicolon.  These changes are
completely transparent to our local yacc programs, but apparently
matter on some VMS systems.

Wed Jun 23 01:02:56 EDT 1993
  Update "fc" shell script, and bring f2c.1 and f2c.1t up to date:
they're meant to be linked with (i.e., the same as) src/f2c.1 and
src/f2c.1t .  [In the last update of f2c.1* (2 Feb. 1993), only
src/f2c.1 and src/f2c.1t got changed -- a mistake.]

Wed Jun 23 09:04:31 EDT 1993
  libi77: fix bug in format reversions for internal writes.
Example:
	character*60 lines(2)
	write(lines,"('n =',i3,2(' more text',i3))") 3, 4, 5, 6
	write(*,*) 'lines(1) = ', lines(1)
	write(*,*) 'lines(2) = ', lines(2)
	end
gave an error message that began "iio: off end of record", rather
than giving the correct output:

 lines(1) = n =  3 more text  4 more text  5
 lines(2) =  more text  6 more text

Thu Aug  5 11:31:14 EDT 1993
  libi77: lread.c: fix bug in handling repetition counts for logical
data (during list or namelist input).  Change struct f__syl to
struct syl (for buggy compilers).

Sat Aug  7 16:05:30 EDT 1993
  libi77: lread.c (again): fix bug in namelist reading of incomplete
logical arrays.
  Fix minor calling-sequence errors in format.c, output.c, putpcc.c:
should be invisible.

Mon Aug  9 09:12:38 EDT 1993
  Fix erroneous cast under -A in translating
	character*(*) function getc()
	getc(2:3)=' '		!wrong cast in first arg to s_copy
	end
  libi77: lread.c: fix bug in namelist reading of an incomplete array
of numeric data followed by another namelist item whose name starts
with 'd', 'D', 'e', or 'E'.

Fri Aug 20 13:22:10 EDT 1993
  Fix bug in do while revealed by
	subroutine skdig (line, i)
	character line*(*), ch*1
	integer i
	logical isdigit
	isdigit(ch) = ch.ge.'0' .and. ch.le.'9'
	do while (isdigit(line(i:i)))	! ch__1[0] was set before
					! "while(...) {...}"
		i = i + 1
		enddo
	end

Fri Aug 27 08:22:54 EDT 1993
  Add #ifdefs to avoid declaring atol when it is a macro; version.c
not updated.

Wed Sep  8 12:24:26 EDT 1993
  libi77: open.c: protect #include "sys/..." with
#ifndef NON_UNIX_STDIO; Version date not changed.

Thu Sep  9 08:51:21 EDT 1993
  Adjust "include" to interpret file names relative to the directory
of the file that contains the "include".

Fri Sep 24 00:56:12 EDT 1993
  Fix offset error resulting from repeating the same equivalence
statement twice.  Example:
	real a(2), b(2)
	equivalence (a(2), b(2))
	equivalence (a(2), b(2))
	end
  Increase MAXTOKENLEN (to roughly the largest allowed by ANSI C).

Mon Sep 27 08:55:09 EDT 1993
  libi77: endfile.c: protect #include "sys/types.h" with
#ifndef NON_UNIX_STDIO; Version.c not changed.

Fri Oct 15 15:37:26 EDT 1993
  Fix rarely seen parsing bug illustrated by
	subroutine foo(xabcdefghij)
	character*(*) xabcdefghij
               IF (xabcdefghij.NE.'##') GOTO 40
 40	end
in which the spacing in the IF line is crucial.

Thu Oct 21 13:55:11 EDT 1993
  Give more meaningful error message (then "unexpected character in
cds") when constant simplification leads to Infinity or NaN.

Wed Nov 10 15:01:05 EST 1993
  libi77: backspace.c: adjust, under -DMSDOS, to cope with MSDOS
text files, as handled by some popular PC C compilers.  Beware:
the (defective) libraries associated with these compilers assume lines
end with \r\n (conventional MS-DOS text files) -- and ftell (and
hence the current implementation of backspace) screws up if lines with
just \n.

Thu Nov 18 09:37:47 EST 1993
  Give a better error (than "control stack empty") for an extraneous
ENDDO.  Example:
	enddo
	end
  Update comments about ftp in "readme from f2c".

Sun Nov 28 17:26:50 EST 1993
  Change format of time stamp in version.c to yyyymmdd.
  Sort parameter adjustments (or complain of impossible dependencies)
so that dummy arguments are referenced only after being adjusted.
Example:
	subroutine foo(a,b)
	integer a(2)		! a must be adjusted before b
	double precision b(a(1),a(2))
	call goo(b(3,4))
	end
  Adjust structs for initialized common blocks and equivalence classes
to omit the trailing struct component added to force alignment when
padding already forces the desired alignment.  Example:
	PROGRAM TEST
	COMMON /Z/ A, CC
	CHARACTER*4 CC
	DATA cc /'a'/
	END
now gives
	struct {
	    integer fill_1[1];
	    char e_2[4];
	    } z_ = { {0}, {'a', ' ', ' ', ' '} };
rather than
struct {
    integer fill_1[1];
    char e_2[4];
    real e_3;
    } z_ = { {0}, {'a', ' ', ' ', ' '}, (float)0. };

Wed Dec  8 16:24:43 EST 1993
  Adjust lex.c to recognize # nnn "filename" lines emitted by cpp;
this affects the file names and line numbers in error messages and
the #line lines emitted under -g.
  Under -g, arrange for a file that starts with an executable
statement to have the first #line line indicate line 1, rather
than the line number of the END statement ending the main program.
  Adjust fc script to run files ending in .F through /lib/cpp.
  Fix bug ("Impossible tag 2") in
	if (t .eq. (0,2)) write(*,*) 'Bug!'
	end
  libi77: iio.c: adjust internal formatted reads to treat short records
as though padded with blanks (rather than causing an "off end of record"
error).

Wed Dec 15 15:19:15 EST 1993
  fc: adjusted for .F files to pass -D and -I options to cpp.

Fri Dec 17 20:03:38 EST 1993
  Fix botch introduced 28 Nov. 1993 in vax.c; change "version of"
to "version".

Tue Jan  4 15:39:52 EST 1994
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only).

Wed Jan 19 08:55:19 EST 1994
  Arrange to accept
	integer	Nx, Ny, Nz
	parameter	(Nx = 10, Ny = 20)
	parameter	(Nz = max(Nx, Ny))
	integer	c(Nz)
	call foo(c)
	end
rather than complaining "Declaration error for c: adjustable dimension
on non-argument".  The necessary changes cause some hitherto unfolded
constant expressions to be folded.
  Accept BYTE as a synonym for INTEGER*1.

Thu Jan 27 08:57:40 EST 1994
  Fix botch in changes of 19 Jan. 1994 that broke entry points with
multi-dimensional array arguments that did not appear in the subprogram
argument list and whose leading dimensions depend on arguments.

Mon Feb  7 09:24:30 EST 1994
  Remove artifact in "fc" script that caused -O to be ignored:
	87c87
	<		# lcc ignores -O...
	---
	>		CFLAGS="$CFLAGS $O"

Sun Feb 20 17:04:58 EST 1994
  Fix bugs reading .P files for routines with arguments of type
INTEGER*1, INTEGER*8, LOGICAL*2.
  Fix glitch in reporting inconsistent arguments for routines involving
character arguments:  "arg n" had n too large by the number of
character arguments.

Tue Feb 22 20:50:08 EST 1994
  Trivial changes to data.c format.c main.c niceprintf.c output.h and
sysdep.h (consistency improvements).
  libI77: lread.c: check for NULL return from realloc.

Fri Feb 25 23:56:08 EST 1994
  output.c, sysdep.h: arrange for -DUSE_DTOA to use dtoa.c and g_fmt.c
for correctly rounded decimal values on IEEE-arithmetic machines
(plus machines with VAX and IBM-mainframe arithmetic).  These
routines are available from netlib's fp directory.
  msdos/f2cx.exe.Z and msdos/f2c.exe.Z updated (ftp access only); the
former uses -DUSE_DTOA to keep 12 from printing as 12.000000000000001.
  vax.c: fix wrong arguments to badtag and frchain introduced
28 Nov. 1993.
  Source for f2c converted to ANSI/ISO format, with the K&R format
available by compilation with -DKR_headers .
  Arrange for (double precision expression) relop (single precision
constant) to retain the single-precision nature of the constant.
Example:
	double precision t
	if (t .eq. 0.3) ...

Mon Feb 28 11:40:24 EST 1994
  README updated to reflect a modification just made to netlib's
"dtoa.c from fp":
96a97,105
> Also add the rule
>
> 	dtoa.o: dtoa.c
> 		$(CC) -c $(CFLAGS) -DMALLOC=ckalloc -DIEEE... dtoa.c
>
> (without the initial tab) to the makefile, where IEEE... is one of
> IEEE_MC68k, IEEE_8087, VAX, or IBM, depending on your machine's
> arithmetic.  See the comments near the start of dtoa.c.
>

Sat Mar  5 09:41:52 EST 1994
  Complain about functions with the name of a previously declared
common block (which is illegal).
  New option -d specifies the directory for output .c and .P files;
f2c.1 and f2c.1t updated.  The former undocumented debug option -dnnn
is now -Dnnn.

Thu Mar 10 10:21:44 EST 1994
  libf77: add #undef min and #undef max lines to s_paus.c s_stop.c
and system_.c; Version.c not changed.
  libi77: add -DPad_UDread lines to uio.c and explanation to README:
    Some buggy Fortran programs use unformatted direct I/O to write
    an incomplete record and later read more from that record than
    they have written.  For records other than the last, the unwritten
    portion of the record reads as binary zeros.  The last record is
    a special case: attempting to read more from it than was written
    gives end-of-file -- which may help one find a bug.  Some other
    Fortran I/O libraries treat the last record no differently than
    others and thus give no help in finding the bug of reading more
    than was written.  If you wish to have this behavior, compile
    uio.c with -DPad_UDread .
Version.c not changed.

Tue Mar 29 17:27:54 EST 1994
  Adjust make_param so dimensions involving min, max, and other
complicated constant expressions do not provoke error messages
about adjustable dimensions on non-arguments.
  Fix botch introduced 19 Jan 1994: "adjustable dimension on non-
argument" messages could cause some things to be freed twice.

Tue May 10 07:55:12 EDT 1994
  Trivial changes to exec.c, p1output.c, parse_args.c, proc.c,
and putpcc.c: change arguments from
	type foo[]
to
	type *foo
for consistency with defs.h.  For most compilers, this makes no
difference.

Thu Jun  2 12:18:18 EDT 1994
  Fix bug in handling FORMAT statements that have adjacent character
(or Hollerith) strings: an extraneous \002 appeared between the
strings.
  libf77: under -DNO_ONEXIT, arrange for f_exit to be called just
once; previously, upon abnormal termination (including stop statements),
it was called twice.

Mon Jun  6 15:52:57 EDT 1994
  libf77: Avoid references to SIGABRT and SIGIOT if neither is defined;
Version.c not changed.
  libi77: Add cast to definition of errfl() in fio.h; this only matters
on systems with sizeof(int) < sizeof(long).  Under -DNON_UNIX_STDIO,
use binary mode for direct formatted files (to avoid any confusion
connected with \n characters).

Fri Jun 10 16:47:31 EDT 1994
  Fix bug under -A in handling unreferenced (and undeclared)
external arguments in subroutines with multiple entry points.  Example:
	subroutine m(fcn,futil)
	external fcn,futil
	call fcn
	entry mintio(i1) ! (D_fp)0 rather than (U_fp)0 for futil
	end

Wed Jun 15 10:38:14 EDT 1994
  Allow char(constant expression) function in parameter declarations.
(This was probably broken in the changes of 29 March 1994.)

Fri Jul  1 23:54:00 EDT 1994
  Minor adjustments to makefile (rule for f2c.1 commented out) and
sysdep.h (#undef KR_headers if __STDC__ is #defined, and base test
for ANSI_Libraries and ANSI_Prototypes on KR_headers rather than
__STDC__); version.c touched but not changed.
  libi77: adjust fp.h so local.h is only needed under -DV10;
Version.c not changed.

Tue Jul  5 03:05:46 EDT 1994
  Fix segmentation fault in
	subroutine foo(a,b,k)
	data i/1/
	double precision a(k,1)	! sequence error: must precede data
	b = a(i,1)
	end
  libi77: Fix bug (introduced 6 June 1994?) in reopening files under
NON_UNIX_STDIO.
  Fix some error messages caused by illegal Fortran.  Examples:
* 1.
	x(i) = 0  !Missing declaration for array x
	call f(x) !Said Impossible storage class 8 in routine mkaddr
	end	  !Now says invalid use of statement function x
* 2.
	f = g	!No declaration for g; by default it's a real variable
	call g	!Said invalid class code 2 for function g
	end	!Now says g cannot be called
* 3.
	intrinsic foo	!Invalid intrinsic name
	a = foo(b)	!Said intrcall: bad intrgroup 0
	end		!Now just complains about line 1

Tue Jul  5 11:14:26 EDT 1994
  Fix glitch in handling erroneous statement function declarations.
Example:
	a(j(i) - i) = a(j(i) - i) + 1	! bad statement function
	call foo(a(3))	! Said Impossible type 0 in routine mktmpn
	end		! Now warns that i and j are not used

Wed Jul  6 17:31:25 EDT 1994
  Tweak test for statement functions that (illegally) call themselves;
f2c will now proceed to check for other errors, rather than bailing
out at the first recursive statement function reference.
  Warn about but retain divisions by 0 (instead of calling them
"compiler errors" and quiting).  On IEEE machines, this permits
	double precision nan, ninf, pinf
	nan = 0.d0/0.d0
	pinf = 1.d0/0.d0
	ninf = -1.d0/0.d0
	write(*,*) 'nan, pinf, ninf = ', nan, pinf, ninf
	end
to print
	nan, pinf, ninf =   NaN  Infinity -Infinity
  libi77: wref.c: protect with #ifdef GOOD_SPRINTF_EXPONENT an
optimization that requires exponents to have 2 digits when 2 digits
suffice.  lwrite.c wsfe.c (list and formatted external output):
omit ' ' carriage-control when compiled with -DOMIT_BLANK_CC .
Off-by-one bug fixed in character count for list output of character
strings.  Omit '.' in list-directed printing of Nan, Infinity.

Mon Jul 11 13:05:33 EDT 1994
  src/gram.c updated.

Tue Jul 12 10:24:42 EDT 1994
  libi77: wrtfmt.c: under G11.4, write 0. as "  .0000    " rather
than "  .0000E+00".

Thu Jul 14 17:55:46 EDT 1994
  Fix glitch in changes of 6 July 1994 that could cause erroneous
"division by zero" warnings (or worse).  Example:
	subroutine foo(a,b)
	y = b
	a = a / y	! erroneous warning of division by zero
	end

Mon Aug  1 16:45:17 EDT 1994
  libi77: lread.c rsne.c: for benefit of systems with a buggy stdio.h,
declare ungetc when neither KR_headers nor ungetc is #defined.
Version.c not changed.

Wed Aug  3 01:53:00 EDT 1994
  libi77: lwrite.c (list output): do not insert a newline when
appending an oversize item to an empty line.

Mon Aug  8 00:51:01 EDT 1994
  Fix bug (introduced 3 Feb. 1993) that, under -i2, kept LOGICAL*2
variables from appearing in INQUIRE statements.  Under -I2, allow
LOGICAL*4 variables to appear in INQUIRE.  Fix intrinsic function
LEN so it returns a short value under -i2, a long value otherwise.
  exec.c: fix obscure memory fault possible with bizarre (and highly
erroneous) DO-loop syntax.

Fri Aug 12 10:45:57 EDT 1994
  libi77: fix glitch that kept ERR= (in list- or format-directed input)
from working after a NAMELIST READ.

Thu Aug 25 13:58:26 EDT 1994
  Suppress -s when -C is specified.
  Give full pathname (netlib@research.att.com) for netlib in readme and
src/README.

Wed Sep  7 22:13:20 EDT 1994
  libi77: typesize.c: adjust to allow types LOGICAL*1, LOGICAL*2,
INTEGER*1, and (under -DAllow_TYQUAD) INTEGER*8 in NAMELISTs.

Fri Sep 16 17:50:18 EDT 1994
  Change name adjustment for reserved words: instead of just appending
"_" (a single underscore), append "_a_" to local variable names to avoid
trouble when a common block is named a reserved word and the same
reserved word is also a local variable name.  Example:
	common /const/ a,b,c
	real const(3)
	equivalence (const(1),a)
	a = 1.234
	end
  Arrange for ichar() to treat characters as unsigned.
  libf77: s_cmp.c: treat characters as unsigned in comparisons.
These changes for unsignedness only matter for strings that contain
non-ASCII characters.  Now ichar() should always be >= 0.

Sat Sep 17 11:19:32 EDT 1994
  fc: set rc=$? before exit (to get exit code right in trap code).

Mon Sep 19 17:49:43 EDT 1994
  libf77: s_paus.c: flush stderr after PAUSE; add #ifdef MSDOS stuff.
  libi77: README: point out general need for -DMSDOS under MS-DOS.

Tue Sep 20 11:42:30 EDT 1994
  Fix bug in comparing identically named common blocks, in which
all components have the same names and types, but at least one is
dimensioned (1) and the other is not dimensioned.  Example:
	subroutine foo
	common /ab/ a
	a=1.	!!! translated correctly to ab_1.a = (float)1.;
	end
	subroutine goo
	common /ab/ a(1)
	a(1)=2.	!!! translated erroneously to ab_1.a[0] = (float)2.
	end

Tue Sep 27 23:47:34 EDT 1994
  Fix bug introduced 16 Sept. 1994: don't add _a_ to C keywords
used as external names.  In fact, return to earlier behavior of
appending __ to C keywords unless they are used as external names,
in which case they get just one underscore appended.
  Adjust constant handling so integer and logical PARAMETERs retain
type information, particularly under -I2.  Example:
	SUBROUTINE FOO
	INTEGER I
	INTEGER*1 I1
	INTEGER*2 I2
	INTEGER*4 I4
	LOGICAL L
	LOGICAL*1 L1
	LOGICAL*2 L2
	LOGICAL*4 L4
	PARAMETER (L=.FALSE., L1=.FALSE., L2=.FALSE., L4=.FALSE.)
	PARAMETER (I=0,I1=0,I2=0,I4=0)
	CALL DUMMY(I, I1, I2, I4, L, L1, L2, L4)
	END
  f2c.1t: Change f\^2c to f2c (omit half-narrow space) in line following
".SH NAME" for benefit of systems that cannot cope with troff commands
in this context.

Wed Sep 28 12:45:19 EDT 1994
  libf77: s_cmp.c fix glitch in -DKR_headers version introduced
12 days ago.

Thu Oct  6 09:46:53 EDT 1994
  libi77: util.c: omit f__mvgbt (which is never used).
  f2c.h: change "long" to "long int" to facilitate the adjustments
by means of sed described above.  Comment out unused typedef of Long.

Fri Oct 21 18:02:24 EDT 1994
  libf77: add s_catow.c and adjust README to point out that changing
"s_cat.o" to "s_catow.o" in the makefile will permit the target of a
concatenation to appear on its right-hand side (contrary to the
Fortran 77 Standard and at the cost of some run-time efficiency).

Wed Nov  2 00:03:58 EST 1994
  Adjust -g output to contain only one #line line per statement,
inserting \ before the \n ending lines broken because of their
length [this insertion was recanted 10 Dec. 1994].  This change
accommodates an idiocy in the ANSI/ISO C standard, which leaves
undefined the behavior of #line lines that occur within the arguments
to a macro call.

Wed Nov  2 14:44:27 EST 1994
  libi77: under compilation with -DALWAYS_FLUSH, flush buffers at
the end of each write statement, and test (via the return from
fflush) for write failures, which can be caught with an ERR=
specifier in the write statement.  This extra flushing slows
execution, but can abort execution or alter the flow of control
when a disk fills up.
  f2c/src/io.c: Add ERR= test to e_wsle invocation (end of
list-directed external output) to catch write failures when libI77
is compiled with -DALWAYS_FLUSH.

Thu Nov  3 10:59:13 EST 1994
  Fix bug in handling dimensions involving certain intrinsic
functions of constant expressions: the expressions, rather than
pointers to them, were passed.  Example:
      subroutine subtest(n,x)
      real x(2**n,n) ! pow_ii(2,n) was called; now it's pow_ii(&c__2,n)
      x(2,2)=3.
      end

Tue Nov  8 23:56:30 EST 1994
  malloc.c: remove assumption that only malloc calls sbrk.  This
appears to make malloc.c useful on RS6000 systems.

Sun Nov 13 13:09:38 EST 1994
  Turn off constant folding of integers used in floating-point
expressions, so the assignment in
	subroutine foo(x)
	double precision x
	x = x*1000000*500000
	end
is rendered as
	*x = *x * 1000000 * 500000;
rather than as
	*x *= 1783793664;

Sat Dec 10 16:31:40 EST 1994
  Supply a better error message (than "Impossible type 14") for
	subroutine foo
	foo = 3
	end
  Under -g, convey name of included files to #line lines.
  Recant insertion of \ introduced (under -g) 2 Nov. 1994.

Thu Dec 15 14:33:55 EST 1994
  New command-line option -Idir specifies directories in which to
look for non-absolute include files (after looking in the directory
of the current input file).  There can be several -Idir options, each
specifying one directory.  All -Idir options are considered, from
left to right, until a suitably named file is found.  The -I2 and -I4
command-line options have precedence, so directories named 2 or 4
must be spelled by some circumlocation, such as -I./2 .
  f2c.ps updated to mention the new -Idir option, correct a typo,
and bring the man page at the end up to date.
  lex.c: fix bug in reading line numbers in #line lines.
  fc updated to pass -Idir options to f2c.

Thu Dec 29 09:48:03 EST 1994
  Fix bug (e.g., addressing fault) in diagnosing inconsistency in
the type of function eta in the following example:
	function foo(c1,c2)
	double complex foo,c1,c2
	double precision eta
	foo = eta(c1,c2)
	end
	function eta(c1,c2)
	double complex eta,c1,c2
	eta = c1*c2
	end

Mon Jan  2 13:27:26 EST 1995
  Retain casts for SNGL (or FLOAT) that were erroneously optimized
away.  Example:
	subroutine foo(a,b)
	double precision a,b
	a = float(b)	! now rendered as *a = (real) (*b);
	end
  Use float (rather than double) temporaries in certain expressions
of type complex.  Example: the temporary for sngl(b) in
	complex a
	double precision b
	a = sngl(b) - (3.,4.)
is now of type float.

Fri Jan  6 00:00:27 EST 1995
  Adjust intrinsic function cmplx to act as dcmplx (returning
double complex rather than complex) if either of its args is of
type double precision.  The double temporaries used prior to 2 Jan.
1995 previously gave it this same behavior.

Thu Jan 12 12:31:35 EST 1995
  Adjust -krd to use double temporaries in some calculations of
type complex.
  libf77: pow_[dhiqrz][hiq].c: adjust x**i to work on machines
that sign-extend right shifts when i is the most negative integer.

Wed Jan 25 00:14:42 EST 1995
  Fix memory fault in handling overlapping initializations in
	block data
	common /zot/ d
	double precision d(3)
	character*6 v(4)
	real r(2)
	equivalence (d(3),r(1)), (d(1),v(1))
	data v/'abcdef', 'ghijkl', 'mnopqr', 'stuvwx'/
	data r/4.,5./
	end
  names.c: add "far", "huge", "near" to c_keywords (causing them
to have __ appended when used as local variables).
  libf77: add s_copyow.c, an alternative to s_copy.c for handling
(illegal) character assignments where the right- and left-hand
sides overlap, as in a(2:4) = a(1:3).

Thu Jan 26 14:21:19 EST 1995
  libf77: roll s_catow.c and s_copyow.c into s_cat.c and s_copy.c,
respectively, allowing the left-hand side of a character assignment
to appear on its right-hand side unless s_cat.c and s_copy.c are
compiled with -DNO_OVERWRITE (which is a bit more efficient).
Fortran 77 forbids the left-hand side from participating in the
right-hand side (of a character assignment), but Fortran 90 allows it.
  libi77: wref.c: fix glitch in printing the exponent of 0 when
GOOD_SPRINTF_EXPONENT is not #defined.

Fri Jan 27 12:25:41 EST 1995
  Under -C++ -ec (or -C++ -e1c), surround struct declarations with
	#ifdef __cplusplus
	extern "C" {
	#endif
and
	#ifdef __cplusplus
	}
	#endif
(This isn't needed with cfront, but apparently is necessary with
some other C++ compilers.)
  libf77: minor tweak to s_copy.c: copy forward whenever possible
(for better cache behavior).

Wed Feb  1 10:26:12 EST 1995
  Complain about parameter statements that assign values to dummy
arguments, as in
	subroutine foo(x)
	parameter(x = 3.4)
	end

Sat Feb  4 20:22:02 EST 1995
  fc: omit "lib=/lib/num/lib.lo".

Wed Feb  8 08:41:14 EST 1995
  Minor changes to exec.c, putpcc.c to avoid "bad tag" or "error
in frexpr" with certain invalid Fortran.

Sat Feb 11 08:57:39 EST 1995
  Complain about integer overflows, both in simplifying integer
expressions, and in converting integers from decimal to binary.
  Fix a memory fault in putcx1() associated with invalid input.

Thu Feb 23 11:20:59 EST 1995
  Omit MAXTOKENLEN; realloc token if necessary (to handle very long
strings).

Fri Feb 24 11:02:00 EST 1995
  libi77: iio.c: z_getc: insert (unsigned char *) to allow internal
reading of characters with high-bit set (on machines that sign-extend
characters).

Tue Mar 14 18:22:42 EST 1995
  Fix glitch (in io.c) in handling 0-length strings in format
statements, as in
	write(*,10)
 10	format(' ab','','cd')
  libi77: lread.c and rsfe.c: adjust s_rsle and s_rsfe to check for
end-of-file (to prevent infinite loops with empty read statements).

Wed Mar 22 10:01:46 EST 1995
  f2c.ps: adjust discussion of -P on p. 7 to reflect a change made
3 Feb. 1993: -P no longer implies -A.

Fri Apr 21 18:35:00 EDT 1995
  fc script: remove absolute paths (since PATH specifies only standard
places).  On most systems, it's still necessary to adjust the PATH
assignment at the start of fc to fit the local conventions.

Fri May 26 10:03:17 EDT 1995
  fc script: add recognition of -P and .P files.
  libi77: iio.c: z_wnew: fix bug in handling T format items in internal
writes whose last item is written to an earlier position than some
previous item.

Wed May 31 11:39:48 EDT 1995
  libf77: added subroutine exit(rc) (with integer return code rc),
which works like a stop statement but supplies rc as the program's
return code.

Fri Jun  2 11:56:50 EDT 1995
  Fix memory fault in
	parameter (x=2.)
	data x /2./
	end
This now elicits two error messages; the second ("too many
initializers"), though not desirable, seems hard to eliminate
without considerable hassle.

Mon Jul 17 23:24:20 EDT 1995
  Fix botch in simplifying constants in certain complex
expressions.  Example:
	subroutine foo(s,z)
	double complex z
	double precision s, M, P
	parameter ( M = 100.d0, P = 2.d0 )
	z = M * M  / s  * dcmplx (1.d0, P/M)
*** The imaginary part of z was miscomputed ***
	end
  Under -ext, complain about nonintegral dimensions.

Fri Jul 21 11:18:36 EDT 1995
  Fix glitch on line 159 of init.c: change
	"(shortlogical *)0)",
to
	"(shortlogical *)0",
This affects multiple entry points when some but not all have
arguments of type logical*2.
  libi77: adjust lwrite.c, wref.c, wrtfmt.c so compiling with
-DWANT_LEAD_0 causes formatted writes of floating-point numbers of
magnitude < 1 to have an explicit 0 before the decimal point (if the
field-width permits it).  Note that the Fortran 77 Standard leaves it
up to the implementation whether to supply these superfluous zeros.

Tue Aug  1 09:25:56 EDT 1995
  Permit real (or double precision) parameters in dimension expressions.

Mon Aug  7 08:04:00 EDT 1995
  Append "_eqv" rather than just "_" to names that that appear in
EQUIVALENCE statements as well as structs in f2c.h (to avoid a
conflict when these names also name common blocks).

Tue Aug  8 12:49:02 EDT 1995
  Modify yesterday's change: merge st_fields with c_keywords, to
cope with equivalences introduced to permit initializing numeric
variables with character data.  DATA statements causing these
equivalences can appear after executable statements, so the only
safe course is to rename all local variable with names in the
former st_fields list.  This has the unfortunate side effect that
the common local variable "i" will henceforth be renamed "i__".

Wed Aug 30 00:19:32 EDT 1995
  libf77: add F77_aloc, now used in s_cat and system_ (to allocate
memory and check for failure in so doing).
  libi77: improve MSDOS logic in backspace.c.

Wed Sep  6 09:06:19 EDT 1995
  libf77: Fix return type of system_ (integer) under -DKR_headers.
  libi77: Move some f_init calls around for people who do not use
libF77's main(); now open and namelist read statements that are the
first I/O statements executed should work right in that context.
Adjust namelist input to treat a subscripted name whose subscripts do
not involve colons similarly to the name without a subscript:  accept
several values, stored in successive elements starting at the
indicated subscript.  Adjust namelist output to quote character
strings (avoiding confusion with arrays of character strings).

Thu Sep  7 00:36:04 EDT 1995
  Fix glitch in integer*8 exponentiation function: it's pow_qq, not
pow_qi.
  libi77: fix some bugs with -DAllow_TYQUAD (for integer*8); when
looking for the &name that starts NAMELIST input, treat lines whose
first nonblank character is something other than &, $, or ? as
comment lines (i.e., ignore them), unless rsne.c is compiled with
-DNo_Namelist_Comments.

Thu Sep  7 09:05:40 EDT 1995
  libi77: rdfmt.c:  one more tweak for -DAllow_TYQUAD.

Tue Sep 19 00:03:02 EDT 1995
  Adjust handling of floating-point subscript bounds (a questionable
f2c extension) so subscripts in the generated C are of integral type.
  Move #define of roundup to proc.c (where its use is commented out);
version.c left at 19950918.

Wed Sep 20 17:24:19 EDT 1995
  Fix bug in handling ichar() under -h.

Thu Oct  5 07:52:56 EDT 1995
  libi77: wrtfmt.c: fix bug with t editing (f__cursor was not always
zeroed in mv_cur).

Tue Oct 10 10:47:54 EDT 1995
  Under -ext, warn about X**-Y and X**+Y.  Following the original f77,
f2c treats these as X**(-Y) and X**(+Y), respectively.  (They are not
allowed by the official Fortran 77 Standard.)  Some Fortran compilers
give a bizarre interpretation to larger contexts, making multiplication
noncommutative: they treat X**-Y*Z as X**(-Y*Z) rather than X**(-Y)*Z,
which, following the rules of Fortran 77, is the same as (X**(-Y))*Z.

Wed Oct 11 13:27:05 EDT 1995
  libi77: move defs of f__hiwater, f__svic, f__icptr from wrtfmt.c
to err.c.  This should work around a problem with buggy loaders and
sometimes leads to smaller executable programs.

Sat Oct 21 23:54:22 EDT 1995
  Under -h, fix bug in the treatment of ichar('0') in arithmetic
expressions.
  Demote to -dneg (a new command-line option not mentioned in the
man page) imitation of the original f77's treatment of unary minus
applied to a REAL operand (yielding a DOUBLE PRECISION result).
Previously this imitation (which was present for debugging) occurred
under (the default) -!R.  It is still suppressed by -R.

Tue Nov  7 23:52:57 EST 1995
  Adjust assigned GOTOs to honor SAVE declarations.
  Add comments about ranlib to lib[FI]77/README and makefile.

Tue Dec 19 22:54:06 EST 1995
  libf77: s_cat.c: fix bug when 2nd or later arg overlaps lhs.

Tue Jan  2 17:54:00 EST 1996
  libi77: rdfmt.c: move #include "ctype.h" up before "stdlib.h"; no
change to Version.c.

Sun Feb 25 22:20:20 EST 1996
  Adjust expr.c to permit raising the integer constants 1 and -1 to
negative constant integral powers.
  Avoid faulting when -T and -d are not followed by a directory name
(immediately, without intervening spaces).

Wed Feb 28 12:49:01 EST 1996
  Fix a glitch in handling complex parameters assigned a "wrong" type.
Example:
	complex d, z
	parameter(z = (0d0,0d0))
	data d/z/	! elicited "non-constant initializer"
	call foo(d)
	end

Thu Feb 29 00:53:12 EST 1996
  Fix bug in handling character parameters assigned a char() value.
Example:
	character*2 b,c
	character*1 esc
	parameter(esc = char(27))
	integer i
	data (b(i:i),i=1,2)/esc,'a'/
	data (c(i:i),i=1,2)/esc,'b'/	! memory fault
	call foo(b,c)
	end

Fri Mar  1 23:44:51 EST 1996
  Fix glitch in evaluating .EQ. and .NE. when both operands are
logical constants (.TRUE. or .FALSE.).

Fri Mar 15 17:29:54 EST 1996
  libi77: lread.c, rsfe.c: honor END= in READ stmts with empty iolist.

Tue Mar 19 23:08:32 EST 1996
  lex.c: arrange for a "statement" consisting of a single short bogus
keyword to elicit an error message showing the whole keyword.  The
error message formerly omitted the last letter of the bad keyword.
  libf77: s_cat.c: supply missing break after overlap detection.

Mon May 13 23:35:26 EDT 1996
  Recognize Fortran 90's /= as a synonym for .NE..  (<> remains a
synonym for .NE..)
  Emit an empty int function of no arguments to supply an external
name to named block data subprograms (so they can be called somewhere
to force them to be loaded from a library).
  Fix bug (memory fault) in handling the following illegal Fortran:
	parameter(i=1)
	equivalence(i,j)
	end
  Treat cdabs, cdcos, cdexp, cdlog, cdsin, and cdsqrt as synonyms for
the double complex intrinsics zabs, zcos, zexp, zlog, zsin, and zsqrt,
respectively, unless -cd is specified.
  Recognize the Fortran 90 bit-manipulation intrinsics btest, iand,
ibclr, ibits, ibset, ieor, ior, ishft, and ishftc, unless -i90 is
specified.  Note that iand, ieor, and ior are thus now synonyms for
"and", "xor", and "or", respectively.
  Add three macros (bit_test, bit_clear, bit_set) to f2c.h for use
with btest, ibclr, and ibset, respectively.  Add new functions
[lq]bit_bits, [lq]bit_shift, and [lq]_bit_cshift to libF77 for
use with ibits, ishft, and ishftc, respectively.
  Add integer function ftell(unit) (returning -1 on error) and
subroutine fseek(unit, offset, whence, *) to libI77 (with branch to
label * on error).

Tue May 14 23:21:12 EDT 1996
  Fix glitch (possible memory fault, or worse) in handling multiple
entry points with names over 28 characters long.

Mon Jun 10 01:20:16 EDT 1996
  Update netlib E-mail and ftp addresses in f2c/readme and
f2c/src/readme (which are different files) -- to reflect the upcoming
breakup of AT&T.
  libf77: trivial tweaks to F77_aloc.c and system_.c; Version.c not
changed.
  libi77: Adjust rsli.c and lread.c so internal list input with too
few items in the input string will honor end= .

Mon Jun 10 22:59:57 EDT 1996
  Add Bits_per_Byte to sysdep.h and adjust definition of Table_size
to depend on Bits_per_Byte (forcing Table_size to be a power of 2); in
lex.c, change "comstart[c & 0xfff]" to "comstart[c & (Table_size-1)]"
to avoid an out-of-range subscript on end-of-file.

Wed Jun 12 00:24:28 EDT 1996
  Fix bug in output.c (dereferencing a freed pointer) revealed in
	print *		!np in out_call in output.c clobbered by free
	end		!during out_expr.

Wed Jun 19 08:12:47 EDT 1996
  f2c.h: add types uinteger, ulongint (for libF77); add qbit_clear
and qbit_set macros (in a commented-out section) for integer*8.
  For integer*8, use qbit_clear and qbit_set for ibclr and ibset.
  libf77: add casts to unsigned in [lq]bitshft.c.

Thu Jun 20 13:30:43 EDT 1996
  Complain at character*(*) in common (rather than faulting).
  Fix bug in recognizing hex constants that start with "16#" (e.g.,
16#1234abcd, which is a synonym for z'1234abcd').
  Fix bugs in constant folding of expressions involving btest, ibclr,
and ibset.
  Fix bug in constant folding of rshift(16#80000000, -31) (on a 32-bit
machine; more generally, the bug was in constant folding of
rshift(ibset(0,NBITS-1), 1-NBITS) when f2c runs on a machine with
long ints having NBITS bits.

Mon Jun 24 07:58:53 EDT 1996
  Adjust struct Literal and newlabel() function to accommodate huge
source files (with more than 32767 newlabel() invocations).
  Omit .c file when the .f file has a missing final end statement.

Wed Jun 26 14:00:02 EDT 1996
  libi77: Add discussion of MXUNIT (highest allowed Fortran unit number)
to libI77/README.

Fri Jun 28 14:16:11 EDT 1996
  Fix glitch with -onetrip: the temporary variable used for nonconstant
initial loop variable values was recycled too soon.  Example:
	do i = j+1, k
		call foo(i+1)	! temp for j+1 was reused here
		enddo
	end

Tue Jul  2 16:11:27 EDT 1996
  formatdata.c: add a 0 to the end of the basetype array (for TYBLANK)
(an omission that was harmless on most machines).
  expr.c: fix a dereference of NULL that was only possible with buggy
input, such as
	subroutine $sub(s)	! the '$' is erroneous
	character s*(*)
	s(1:) = ' '
	end

Sat Jul  6 00:44:56 EDT 1996
  Fix glitch in the intrinsic "real" function when applied to a
complex (or double complex) variable and passed as an argument to
some intrinsic functions.  Example:
	complex a
	b = sqrt(a)
	end
  Fix glitch (only visible if you do not use f2c's malloc and the
malloc you do use is defective in the sense that malloc(0) returns 0)
in handling include files that end with another include (perhaps
followed by comments).
  Fix glitch with character*(*) arguments named "h" and "i" when
the body of the subroutine invokes the intrinsic LEN function.
  Arrange that after a previous "f2c -P foo.f" has produced foo.P,
running "f2c foo.P foo.f" will produce valid C when foo.f contains
	call sub('1234')
	end
	subroutine sub(msg)
	end
Specifically, the length argument in "call sub" is now suppressed.
With or without foo.P, it is also now suppressed when the order of
subprograms in file foo.f is reversed:
	subroutine sub(msg)
	end
	call sub('1234')
	end
  Adjust copyright notices to reflect AT&T breakup.

Wed Jul 10 09:25:49 EDT 1996
  Fix bug (possible memory fault) in handling erroneously placed
and inconsistent declarations.  Example that faulted:
	character*1 w(8)
	call foo(w)
	end
	subroutine foo(m)
	data h /0.5/
	integer m(2)	! should be before data
	end
  Fix bug (possible fault) in handling illegal "if" constructions.
Example (that faulted):
	subroutine foo(i,j)
	if (i) then		! bug: i is integer, not logical
	else if (j) then	! bug: j is integer, not logical
	endif
	end
  Fix glitch with character*(*) argument named "ret_len" to a
character*(*) function.

Wed Jul 10 23:04:16 EDT 1996
  Fix more glitches in the intrinsic "real" function when applied to a
complex (or double complex) variable and passed as an argument to
some intrinsic functions.  Example:
	complex a, b
	r = sqrt(real(conjg(a))) + sqrt(real(a*b))
	end

Thu Jul 11 17:27:16 EDT 1996
  Fix a memory fault associated with complicated, illegal input.
Example:
	subroutine goo
	character a
	call foo(a)	! inconsistent with subsequent def and call
	end
	subroutine foo(a)
	end
	call foo(a)
	end

Wed Jul 17 19:18:28 EDT 1996
  Fix yet another case of intrinsic "real" applied to a complex
argument.  Example:
	complex a(3)
	x = sqrt(real(a(2)))	! gave error message about bad tag
	end

Mon Aug 26 11:28:57 EDT 1996
  Tweak sysdep.c for non-Unix systems in which process ID's can be
over 5 digits long.

Tue Aug 27 08:31:32 EDT 1996
  Adjust the ishft intrinsic to use unsigned right shifts.  (Previously,
a negative constant second operand resulted in a possibly signed shift.)

Thu Sep 12 14:04:07 EDT 1996
  equiv.c: fix glitch with -DKR_headers.
  libi77: fmtlib.c: fix bug in printing the most negative integer.

Fri Sep 13 08:54:40 EDT 1996
  Diagnose some illegal appearances of substring notation.

Tue Sep 17 17:48:09 EDT 1996
  Fix fault in handling some complex parameters.  Example:
	subroutine foo(a)
	double complex a, b
	parameter(b = (0,1))
	a = b	! f2c faulted here
	end

Thu Sep 26 07:47:10 EDT 1996
  libi77:  fmt.h:  for formatted writes of negative integer*1 values,
make ic signed on ANSI systems.  If formatted writes of integer*1
values trouble you when using a K&R C compiler, switch to an ANSI
compiler or use a compiler flag that makes characters signed.

Tue Oct  1 14:41:36 EDT 1996
  Give a better error message when dummy arguments appear in data
statements.

Thu Oct 17 13:37:22 EDT 1996
  Fix bug in typechecking arguments to character and complex (or
double complex) functions; the bug could cause length arguments
for character arguments to be omitted on invocations appearing
textually after the first invocation.  For example, in
	subroutine foo
	character c
	complex zot
	call goo(zot(c), zot(c))
	end
the length was omitted from the second invocation of zot, and
there was an erroneous error message about inconsistent calling
sequences.

Wed Dec  4 13:59:14 EST 1996
  Fix bug revealed by
	subroutine test(cdum,rdum)
	complex cdum
	rdum=cos(real(cdum))	! "Unexpected tag 3 in opconv_fudge"
	end
  Fix glitch in parsing "DO 10 D0 = 1, 10".
  Fix glitch in parsing
	real*8 x
	real*8 x	! erroneous "incompatible type" message
	call foo(x)
	end

Mon Dec  9 23:15:02 EST 1996
  Fix glitch in parameter adjustments for arrays whose lower
bound depends on a scalar argument.  Example:
	subroutine bug(p,z,m,n)
	integer z(*),m,n
	double precision p(z(m):z(m) + n)	! p_offset botched
	call foo(p(0), p(n))
	end
  libi77: complain about non-positive rec= in direct read and write
statements.
  libf77: trivial adjustments; Version.c not changed.

Wed Feb 12 00:18:03 EST 1997
  output.c: fix (seldom problematic) glitch in out_call: put parens
around the ... in a test of the form "if (q->tag == TADDR && ...)".
  vax.c: fix bug revealed in the "psi_offset =" assignment in the
following example:
	subroutine foo(psi,m)
	integer z(100),m
	common /a/ z
	double precision psi(z(m):z(m) + 10)
	call foo(m+1, psi(0),psi(10))
	end

Mon Feb 24 23:44:54 EST 1997
  For consistency with f2c's current treatment of adjacent character
strings in FORMAT statements, recognize a Hollerith string following
a string (and merge adjacent strings in FORMAT statements).

Wed Feb 26 13:41:11 EST 1997
  New libf2c.zip, a combination of the libf77 and libi77 bundles (and
available only by ftp).
  libf77: adjust functions with a complex output argument to permit
aliasing it with input arguments.  (For now, at least, this is just
for possible benefit of g77.)
  libi77: tweak to ftell_.c for systems with strange definitions of
SEEK_SET, etc.

Tue Apr  8 20:57:08 EDT 1997
  libf77: [cz]_div.c: tweaks invisible on most systems (that may
improve things slightly with optimized compilation on systems that use
gratuitous extra precision).
  libi77: fmt.c: adjust to complain at missing numbers in formats
(but still treat missing ".nnn" as ".0").

Fri Apr 11 14:05:57 EDT 1997
  libi77: err.c: attempt to make stderr line buffered rather than
fully buffered.  (Buffering is needed for format items T and TR.)

Thu Apr 17 22:42:43 EDT 1997
 libf77: add F77_aloc.o to makefile (and makefile.u in libf2c.zip).

Fri Apr 25 19:32:09 EDT 1997
 libf77: add [de]time_.c (which may give trouble on some systems).

Tue May 27 09:18:52 EDT 1997
 libi77: ftell_.c: fix typo that caused the third argument to be
treated as 2 on some systems.

Mon Jun  9 00:04:37 EDT 1997
 libi77 (and libf2c.zip): adjust include order in err.c lread.c wref.c
rdfmt.c to include fmt.h (etc.) after system includes.  Version.c not
changed.

Mon Jul 21 16:04:54 EDT 1997
  proc.c: fix glitch in logic for "nonpositive dimension" message.
  libi77: inquire.c: always include string.h (for possible use with
-DNON_UNIX_STDIO); Version.c not changed.

Thu Jul 24 17:11:23 EDT 1997
  Tweak "Notice" to reflect the AT&T breakup -- we missed it when
updating the copyright notices in the source files last summer.
  Adjust src/makefile so malloc.o is not used by default, but can
be specified with "make MALLOC=malloc.o".
  Add comments to src/README about the "CRAY" T3E.

Tue Aug  5 14:53:25 EDT 1997
  Add definition of calloc to malloc.c; this makes f2c's malloc
work on some systems where trouble hitherto arose because references
to calloc brought in the system's malloc.  (On sensible systems,
calloc is defined separately from malloc.  To avoid confusion on
other systems, f2c/malloc.c now defines calloc.)
  libi77: lread.c: adjust to accord with a change to the Fortran 8X
draft (in 1990 or 1991) that rescinded permission to elide quote marks
in namelist input of character data; to get the old behavior, compile
with F8X_NML_ELIDE_QUOTES #defined.  wrtfmt.o: wrt_G: tweak to print
the right number of 0's for zero under G format.

Sat Aug 16 05:45:32 EDT 1997
  libi77: iio.c: fix bug in internal writes to an array of character
strings that sometimes caused one more array element than required by
the format to be blank-filled.  Example: format(1x).

Wed Sep 17 00:39:29 EDT 1997
  libi77: fmt.[ch] rdfmt.c wrtfmt.c: tweak struct syl for machines
with 64-bit pointers and 32-bit ints that did not 64-bit align
struct syl (e.g., Linux on the DEC Alpha).  This change should be
invisible on other machines.

Sun Sep 21 22:05:19 EDT 1997
  libf77: [de]time_.c (Unix systems only): change return type to double.

Thu Dec  4 22:10:09 EST 1997
  Fix bug with handling large blocks of comments (over 4k); parts of the
second and subsequent blocks were likely to be lost (not copied into
comments in the resulting C).  Allow comment lines to be longer before
breaking them.

Mon Jan 19 17:19:27 EST 1998
  makefile: change the rule for making gram.c to one for making gram1.c;
henceforth, asking netlib to "send all from f2c/src" will bring you a
working gram.c.  Nowadays there are simply too many broken versions of
yacc floating around.
  libi77: backspace.c: for b->ufmt==0, change sizeof(int) to
sizeof(uiolen).  On machines where this would make a difference, it is
best for portability to compile libI77 with -DUIOLEN_int, which will
render the change invisible.

Tue Feb 24 08:35:33 EST 1998
  makefile: remove gram.c from the "make clean" rule.

Wed Feb 25 08:29:39 EST 1998
  makefile: change CFLAGS assignment to -O; add "veryclean" rule.

Wed Mar  4 13:13:21 EST 1998
  libi77: open.c: fix glitch in comparing file names under
-DNON_UNIX_STDIO.

Mon Mar  9 23:56:56 EST 1998
  putpcc.c: omit an unnecessary temporary variable in computing
(expr)**3.
  libf77, libi77: minor tweaks to make some C++ compilers happy;
Version.c not changed.

Wed Mar 18 18:08:47 EST 1998
  libf77: minor tweaks to [ed]time_.c; Version.c not changed.
  libi77: endfile.c, open.c: acquire temporary files from tmpfile(),
unless compiled with -DNON_ANSI_STDIO, which uses mktemp().
New buffering scheme independent of NON_UNIX_STDIO for handling T
format items.  Now -DNON_UNIX_STDIO is no longer be necessary for
Linux, and libf2c no longer causes stderr to be buffered -- the former
setbuf or setvbuf call for stderr was to make T format items work.
open.c: use the Posix access() function to check existence or
nonexistence of files, except under -DNON_POSIX_STDIO, where trial
fopen calls are used.  In open.c, fix botch in changes of 19980304.
  libf2c.zip: the PC makefiles are now set for NT/W95, with comments
about changes for DOS.

Fri Apr  3 17:22:12 EST 1998
  Adjust fix of 19960913 to again permit substring notation on
character variables in data statements.

Sun Apr  5 19:26:50 EDT 1998
  libi77: wsfe.c: make $ format item work: this was lost in the changes
of 17 March 1998.

Sat May 16 19:08:51 EDT 1998
  Adjust output of ftnlen constants: rather than appending L,
prepend (ftnlen).  This should make the resulting C more portable,
e.g., to systems (such as DEC Alpha Unix systems) on which long
may be longer than ftnlen.
  Adjust -r so it also casts REAL expressions passed to intrinsic
functions to REAL.

Wed May 27 16:02:35 EDT 1998
  libf2c.zip: tweak description of compiling libf2c for INTEGER*8
to accord with makefile.u rather than libF77/makefile.

Thu May 28 22:45:59 EDT 1998
  libi77: backspace.c dfe.c due.c iio.c lread.c rsfe.c sue.c wsfe.c:
set f__curunit sooner so various error messages will correctly
identify the I/O unit involved.
  libf2c.zip: above, plus tweaks to PC makefiles: for some purposes,
it's still best to compile with -DMSDOS (even for use with NT).

Thu Jun 18 01:22:52 EDT 1998
  libi77: lread.c: modified so floating-point numbers (containing
either a decimal point or an exponent field) are treated as errors
when they appear as list input for integer data.  Compile lread.c with
-DALLOW_FLOAT_IN_INTEGER_LIST_INPUT to restore the old behavior.

Mon Aug 31 10:38:54 EDT 1998
  formatdata.c: if possible, and assuming doubles must be aligned on
double boundaries, use existing holes in DATA for common blocks to
force alignment of the block.  For example,
	block data
	common /abc/ a, b
	double precision a
	integer b(2)
	data b(2)/1/
	end
used to generate
	struct {
	    integer fill_1[3];
	    integer e_2;
	    doublereal e_3;
	    } abc_ = { {0}, 1, 0. };
and now generates
	struct {
	    doublereal fill_1[1];
	    integer fill_2[1];
	    integer e_3;
	    } abc_ = { {0}, {0}, 1 };
In the old generated C, e_3 was added to force alignment; in the new C,
fill_1 does this job.

Mon Sep  7 19:48:51 EDT 1998
  libi77: move e_wdfe from sfe.c to dfe.c, where it was originally.
Why did it ever move to sfe.c?

Tue Sep  8 10:22:50 EDT 1998
  Treat dreal as a synonym for dble unless -cd is specified on the
command line.

Sun Sep 13 22:23:41 EDT 1998
  format.c: fix bug in writing prototypes under f2c -A ... *.P:
under some circumstances involving external functions with no known
type, a null pointer was passed to printf.

Tue Oct 20 23:25:54 EDT 1998
  Comments added to libf2c/README and libF77/README, pointing out
the need to modify signal1.h on some systems.

Wed Feb 10 22:59:52 EST 1999
  defs.h lex.c: permit long names (up to at least roughly
MAX_SHARPLINE_LEN = 1000 characters long) in #line lines (which only
matters under -g).
  fc: add -U option; recognize .so files.

Sat Feb 13 10:18:27 EST 1999
 libf2c: endfile.c, lread.c, signal1.h0: minor tweaks to make some
(C++) compilers happier; f77_aloc.c: make exit_() visible to C++
compilers.  Version strings not changed.

Thu Mar 11 23:14:02 EST 1999
  Modify f2c (exec.c, expr.c) to diagnose incorrect mixing of types
when (f2c extended) intrinsic functions are involved, as in
(not(17) .and. 4).  Catching this in the first executable statement
is a bit tricky, as some checking must be postponed until all statement
function declarations have been parsed.  Thus there is a chance of
today's changes introducing bugs under (let us hope) unusual conditions.

Sun Mar 28 13:17:44 EST 1999
  lex.c: tweak to get the file name right in error messages caused
by statements just after a # nnn "filename" line emitted by the C
preprocessor.  (The trouble is that the line following the # nnn line
must be read to see if it is a continuation of the stuff that preceded
the # nnn line.)  When # nnn "filename" lines appear among the lines
for a Fortran statement, the filename reported in an error message for
the statement should now be the file that was current when the first
line of the statement was read.

Sun May  2 22:38:25 EDT 1999
  libf77, libi77, libf2c.zip: make getenv_() more portable (call
getenv() rather than knowing about char **environ); adjust some
complex intrinsics to work with overlapping arguments (caused by
inappropriate use of equivalence); open.c: get "external" versus
"internal" right in the error message if a file cannot be opened;
err.c: cast a pointer difference to (int) for %d; rdfmt.c: omit
fixed-length buffer that could be overwritten by formats Inn or Lnn
with nn > 83.

Mon May  3 13:14:07 EDT 1999
  "Invisible" changes to omit a few compiler warnings in f2c and
libf2c; two new casts in libf2c/open.c that matter with 64-bit longs,
and one more tweak (libf2c/c_log.c) for pathological equivalences.
  Minor update to "fc" script: new -L flag and comment correction.

Fri Jun 18 02:33:08 EDT 1999
  libf2c.zip: rename backspace.c backspac.c, and fix a glitch in it
-- b->ufd may change in t_runc().  (For now, it's still backspace.c
in the libi77 bundle.)

Sun Jun 27 22:05:47 EDT 1999
  libf2c.zip, libi77: rsne.c: fix bug in namelist input: a misplaced
increment could cause wrong array elements to be assigned; e.g.,
"&input k(5)=10*1 &end" assigned k(5) and k(15 .. 23).

Tue Sep  7 14:10:24 EDT 1999
  f2c.h, libf2c/f2c.h0, libf2c/README: minor tweaks so a simple
sed command converts f2c.h == libf2c/f2c.h0 to a form suitable for
machines with 8-byte longs and doubles, 4-byte int's and floats,
while working with a forthcoming (ill-advised) update to the C
standard that outlaws plain "unsigned".
  f2c.h, libf2c/f2c.h0: change "if 0" to "#ifdef INTEGER_STAR_8".
  libf77, libf2c.zip: [cz]_div.c and README: arrange for compilation
under -DIEEE_COMPLEX_DIVIDE to make these routines avoid calling sig_die
when the denominator of a complex or double complex division vanishes;
instead, they return pairs of NaNs or Infinities, depending whether the
numerator also vanishes or not.

Tue Oct  5 23:50:14 EDT 1999
  formatdata.c, io.c, output.c, sysdep.c: adjust to make format
strings legal when they contain 8-bit characters with the high bit on.
(For many C compilers, this is not necessary, but it the ANSI/ISO C
standard does not require this to work.)
  libf2c.zip: tweak README and correct xsum0.out.

Mon Oct 25 17:30:54 EDT 1999
  io.c: fix glitch introduced in the previous change (19991005) that
caused format(' %') to print "%%" rather than "%".

Mon Nov 15 12:10:35 EST 1999
  libf2c.zip: fix bug with the sequence backspace(n); endfile(n);
rewind(n); read(n).  Supply missing (long) casts in a couple of places
where they matter when size(ftnint) == sizeof(int) < sizeof(long).

Tue Jan 18 19:22:24 EST 2000
  Arrange for parameter statements involving min(...) and max(...)
functions of three or more arguments to work.
  Warn about text after "end" (rather than reporting a syntax error
with a surprising line number).
  Accept preprocessor line numbers of the form "# 1234" (possibly
with trailing blanks).
  Accept a comma after write(...) and before a list of things to write.

Fri Jan 21 17:26:27 EST 2000
  Minor updates to make compiling Win32 console binaries easier.  A
side effect is that the MSDOS restriction of only one Fortran file
per invocation is lifted (and "f2c *.f") works.

Tue Feb  1 18:38:32 EST 2000
  f2c/src/tokdefs.h added (to help people on non-Unix systems -- the
makefile has always had a rule for generating tokdefs.h).

Fri Mar 10 18:48:17 EST 2000
  libf77, libf2c.zip: z_log.c: the real part of the double complex log
of numbers near, e.g., (+-1,eps) with |eps| small is now more accurate.
For example if z = (1,1d-7), then "write(*,*) z" now writes
"(5.E-15,1.E-07" rather than the previous "(4.88498131E-15,1.E-07)".

Thu Apr 20 13:02:54 EDT 2000
  libf77, libi77, libf2c.zip: s_cat.c, rsne.c, xwsne.c: fix type
errors that only matter if sizeof(ftnint) != sizeof(ftnlen).

Tue May 30 23:36:18 EDT 2000
  expr.c: adjust subcheck() to use a temporary variable of type TYLONG
rather than TYSHORT under -C -I2.

Wed May 31 08:48:03 EDT 2000
  Simplify yesterday's adjustment; today's change should be invisible.

Tue Jul  4 22:52:21 EDT 2000
  misc.c, function "addressable": fix fault with "f2c -I2 foo.f" when
foo.f consists of the 4 lines
	subroutine foo(c)
	character*(*) c
	i = min(len(c),23)
	end
  Sundry files: tweaks for portability, e.g., for compilation by overly
fastidious C++ compilers; "false" and "true" now treated as C keywords
(so they get two underscores appended).
  libf77, libi77, libf2c.zip: "invisible" adjustments to permit
compilation by C++ compilers; version numbers not changed.

Thu Jul  6 23:46:07 EDT 2000
  Various files: tweaks to banish more compiler warnings.
  lib?77, libf2c.zip/makefile.u: add "|| true" to ranlib invocations.
  Thanks to Nelson H. F. Beebe for messages leading to these changes
(and to many of the ones two days ago).
  xsum.c: tweak include order.

Fri Jul  7 18:01:25 EDT 2000
  fc: accept -m xxx or -mxxx, pass them to the compiler as -mxxx
(suggestion of Nelson Beebe).  Note that fc simply appends to CFLAGS,
so system-specific stuff can be supplied in the environment variable
CFLAGS.  With some shells, invocations of the form
	CFLAGS='system-specific stuff' fc ...
are one way to do this.

Thu Aug 17 21:38:36 EDT 2000
  Fix obscure glitch: in "Error on line nnn of ...: Bad # line:...",
get nnn right.

Sat Sep 30 00:28:30 EDT 2000
  libf77, libf2c.zip: dtime_.c, etime_.c: use floating-point divide;
dtime_.d, erf_.c, erfc_.c, etime.c: for use with "f2c -R", compile with
-DREAL=float.

Tue Dec  5 22:55:56 EST 2000
  lread.c: under namelist input, when reading a logical array, treat
Tstuff= and Fstuff= as new assignments rather than as logical constants.

Fri Feb 23 00:43:56 EST 2001
  libf2c: endfile.c: adjust to use truncate() unless compiled with
-DNO_TRUNCATE (or with -DMSDOS).  Add libf2c/mkfile.plan9.

Sat Feb 24 21:14:24 EST 2001
  Prevent malloc(0) when a subroutine of no arguments has an entry
with no arguments, as in
	subroutine foo
	entry goo
	end
  Fix a fault that was possible when MAIN (illegally) had entry points.
  Fix a buffer overflow connected with the error message for names more
than MAXNAMELEN (i.e., 50) bytes long.
  Fix a bug in command-line argument passing that caused the invocation
"f2c -!czork foo.f" to complain about two invalid flags ('-ork' and
'-oo.f') instead of just one ('-ork').
  fc: add -s option (strip executable); portability tweaks.
  Adjustments to handing of integer*8 to permit processing 8-byte hex,
binary, octal, and decimal constants.  The adjustments are only
available when type long long (for >= 64 bit integers) is available to
f2c; they are assumed available unless f2c is compiled with either
-DNO_TYQUAD or -DNO_LONGLONG.  As has long been the case, compilation
of f2c itself with -DNO_TYQUAD eliminates recognition of integer*8
altogether.  Compilation with just -DNO_LONGLONG permits the previous
handling of integer*8, which could only handle 32-bit constants
associated with integer*8 variables.
  New command-line argument -i8const (available only when f2c itself
is compiled with neither -DNO_TYQUAD nor -DNO_LONGLONG) suppresses
the new automatic promotion of integer constants too long to express
as 32-bit values to type integer*8.  There are corresponding updates
to f2c.1 and f2c.1t.

Wed Feb 28 00:50:04 EST 2001
  Adjust misc.c for (older) systems that recognize long long but do not
have LLONG_MAX or LONGLONG_MAX in limits.h.
  main.c: filter out bad files before dofork loop to avoid trouble
in Win32 "f2c.exe" binaries.

Thu Mar  1 16:25:19 EST 2001
  Cosmetic change for consistency with some other netlib directories:
change NO_LONGLONG to NO_LONG_LONG.  (This includes adjusting the above
entry for Feb 23 2001.)  No change (other than timestamp) to version.c.
  libf2c:  endfile.c:  switch to ftruncate (absent -DNO_TRUNCATE),
thus permitting truncation of scratch files on true Unix systems,
where scratch files have no name.  Add an fflush() (surprisingly)
needed on some Linux systems.

Tue Mar 20 22:03:23 EST 2001
  expr.c:  complain ("impossible conversion") about attempts to assign
character expressions ... to integer variables, rather than implicitly
assigning ichar(...).

Sat Jun 23 23:08:22 EDT 2001
  New command-line option -trapuv adds calls on _uninit_f2c() to prologs
to dynamically initialize local variables, except those appearing in
SAVE or DATA statements, with values that may help find references to
uninitialized variables.  For example, with IEEE arithmetic, floating-
point variables are initialized to signaling NaNs.
  expr.c: new warning for out-of-bounds constant substring expressions.
Under -C, such expressions now inhibit C output.
  libf2c/mkfile.plan9: fix glitch with rule for "check" (or xsum.out).
  libf2c.zip: add uninit.c (for _uninit_f2c()) in support of -trapuv.
  fc, f2c.1, f2c.1t: adjust for -trapuv.

Thu Jul  5 22:00:51 EDT 2001
  libf2c.zip: modify uninit.c for __mc68k__ under Linux.

Wed Aug 22 08:01:37 EDT 2001
  cds.c, expr.c: in constants, preserve the sign of 0.
  expr.c: fix some glitches in folding constants to integer*8
(when NO_LONG_LONG is not #defined).
  intr.c: fold constant min(...) and max(...) expressions.

Fri Nov 16 02:00:03 EST 2001
  libf2c.zip:  tweak to permit handling files over 2GB long where
possible, with suitable -D options, provided for some systems in
new header file sysdep1.h (copied from sysdep1.h0 by default).
Add an fseek to endfile.c to fix a glitch on some systems.

Wed Nov 28 17:58:12 EST 2001
  libf2c.zip:  on IEEE systems, print -0 as -0 when the relevant
libf2c/makefile.* is suitably adjusted:  see comments about
-DSIGNED_ZEROS in libf2c/makefile.*.

Fri Jan 18 16:17:44 EST 2002
  libf2c.zip:   fix bugs (reported by Holger Helmke) in qbit_bits():
wrong return type, missing ~ on y in return value.  This affects
the intrinsic ibits function for first argument of type integer*8.

Thu Feb  7 17:14:43 EST 2002
  Fix bug handling leading array dimensions in common:  invalid C
resulted.  Example (after one provided by Dmitry G. Baksheyev):

	subroutine foo(a)
	common/c/m
	integer m, n
	equivalence(m,n)
	integer a(n,2)
	a(1,2) = 3
	end

  Fix a bug, apparently introduced sometime after 19980913, in
handling certain substring expressions that involve temporary
assignments and the first invocation of an implicitly typed function.
When the expressions appeared in "else if (...)"  and "do while(...)",
the temporary assignments appeared too soon.  Examples are hard to
find, but here is one (after an example provided by Nat Bachman):

	subroutine foo(n)
	character*8 s
	do while (moo(s(n+1:n+2)) .ge. 2)
		n = n + 1
		enddo
	end

It is hard for f2c to get this sort of example correct when the
"untyped" function is a generic intrinsic.  When incorrect code would
otherwise result, f2c now issues an error message and declines to
produce C.  For example,

	subroutine foo(n)
	character*8 s
	double precision goo
	do while (sin(goo(s(n+1:n+2))) .ge. 2)
		n = n + 1
		enddo
	end

gives the new error message, but both

	subroutine foo(n)
	character*8 s
	double precision goo
	do while (dsin(goo(s(n+1:n+2))) .ge. 2)
		n = n + 1
		enddo
	end
and
	subroutine foo(n)
	character*8 s
	double precision goo
	do while (sin(goo(min(n, (n-3)**2))) .ge. 2)
		n = n + 1
		enddo
	end

give correct C.

Fri Feb  8 08:43:40 EST 2002
  Make a cleaner fix of the bug fixed yesterday in handling certain
"do while(...)" and "else if (...)" constructs involving auxiliary
assignments.  (Yesterday's changes to expr.c are recanted; expr.c
is now restored to that of 20010820.)  Now

	subroutine foo(n)
	character*8 s
	double precision goo
	do while (sin(goo(s(n+1:n+2))) .ge. 0.2)
		n = n + 1
		enddo
	end

is correctly translated.

Thu Mar 14 12:53:08 EST 2002
  lex.c:  adjust to avoid an error message under -72 when source files
are in CRLF form ("text mode" on Microsoft systems), a source line is
exactly 72 characters long, and f2c is run on a system (such as a Unix
or Linux system) that does not distinguish text and binary modes.
Example (in CRLF form):
      write(*,*)"Hello world, with a source line that is 72 chars long."
      end
  libf2c/z_log.c:  add code to cope with buggy compilers (e.g., some
versions of gcc under -O2 or -O3) that do floating-point comparisons
against values computed into extended-precision registers on some
systems (such as Intel IA32 systems).  Compile with
-DNO_DOUBLE_EXTENDED to omit the kludge that circumvents this bug.

Thu May  2 19:09:01 EDT 2002
  src/misc.c, src/sysdep.h, src/gram.c: tweaks for KR_headers (a rare
concern today); version.c touched but left unchanged.
  libf2c: fix glitch in makefile.vc; KR_header tweaks in s_stop.c
and uninit.c (which also had a misplaced #endif).

Wed Jun  5 16:13:34 EDT 2002
  libf2c: uninit.c: for Linux on an ARM processor, add some
#ifndef _FPU... tests; f77vers.c not changed.

Tue Jun 25 15:13:32 EDT 2002
  New command-line option -K requests old-style ("K&R") C.  The
default is changed to -A (ANSI/ISO style).
  Under -K, cast string-length arguments to (ftnlen).  This should
matter only in the unusual case that "readme" instructs obtaining
f2c.h by
	sed 's/long int /long long /' f2c.h0 >f2c.h
  Increase defaults for some table sizes:  make -Nn802 -Nq300 -Nx400
the default.

Fri Sep  6 18:39:24 EDT 2002
  libf2c.zip: rsne.c: fix bug with multiple repeat counts in reading
namelists, e.g., &nl a(2) = 3*1.0, 2*2.0, 3*3.0 /
(Bug found by Jim McDonald, reported by Toon Moene.)

Fri Oct  4 10:23:51 EDT 2002
  libf2c.zip: uninit.c: on IRIX systems, omit references to shell
variables (a dreg).  This only matters with f2c -trapuv .

Thu Dec 12 22:16:00 EST 2002
  proc.c: tweak to omit "* 1" from "a_offset = 1 + a_dim1 * 1;".
  libf2c.zip: uninit.c: adjust to work with HP-UX B.11.11 as well as
HP-UX B.10.20; f77vers.c not changed.

Tue Feb 11 08:19:54 EST 2003
  Fix a fault with f2c -s on the following example of invalid Fortran
(reported by Nickolay A. Khokhlov); "function" should appear before
"cat" on the first line:
	character*(*) cat(a, b)
	character*(*) a, b
	cat = a // b
	end
  Issue warnings about inappropriate uses of arrays a, b, c and pass
a temporary for d in
	real a(2), b(2), c(2), d
	call foo((a), 1*b, +c, +d)
	end
(correcting bugs reported by Arnaud Desitter).

Thu Mar  6 22:48:08 EST 2003
  output.c: fix a bug leading to "Unexpected tag 4 in opconv_fudge"
when f2c -s processes the real part of a complex array reference.
Example (simplified from netlib/linpack/zchdc.f):

	subroutine foo(a,work,n,k)
	integer k, n
	complex*16 a(n,n), work(n)
	work(k) = dcmplx(dsqrt(dreal(a(k,k))),0.0d0)
	end

(Thanks to Nickolay A. Khokhlov for the bug report.)

Thu Mar 20 13:50:12 EST 2003
  format.c:  code around a bug (reported by Nelson H. F. Beebe) in
some versions of FreeBSD.  Compiling with __FreeBSD__ but not
NO_FSCANF_LL_BUG #defined or with FSCANF_LL_BUG #defined causes
special logic to replace  fscanf(infile, "%llx", result)  with
custom logic.  Here's an example (from Beebe) where the bug bit:
	integer*8 m, n
	m = 9223372036854775807
	end

Fri Mar 21 13:14:05 EST 2003
  libf2c.zip: err.c: before writing to a file after reading from it,
do an f_seek(file, 0, SEEK_CUR) to make writing legal in ANSI C.

Fri Jun  6 14:56:44 EDT 2003
libf2c.zip:  add comments about libf2c.so (and a rule that works under
Linux, after an adjustment to the CFLAGS = line) to libf2c/makefile.u.

Sat Oct 25 07:57:53 MDT 2003
README, main.c, sysdep.c:  adjust comments about libf2c and expand the
comments thereon in the C that f2c writes (since too few people read
the README files).  Change makefile to makefile.u (with the
expectation that people will "cp makefile.u makefile" and edit
makefile if necessary) and add makefile.vc (for Microsoft Visual C++).

Thu Oct  7 23:25:28 MDT 2004
names.c: for convenience of MSVC++ users, map "cdecl" to "cdecl__".

Fri Mar  4 18:40:48 MST 2005
sysdep.c, makefile.u, new file sysdeptest.c:  changes in response to a
message forwarded by Eric Grosse from Thierry Carrez 
(who is apparently unaware of f2c's -T option) about an unlikely
security issue:  that a local attacker could plant symbolic links in
/tmp corresponding to temporary file names that f2c generates and thus
cause overwriting of arbitrary files.  Today's change is that if
neither -T nor the unusual debugging flag -Dn is specified and the
system is not an MS-Windows system (which cannot have symbolic links,
as far as I know), then f2c's temporary files will be written in a
temporary directory that is readable and writable only by the user and
that is removed at the end of f2c's execution.  To disable today's
change, compile sysdep.c with -DNO_TEMPDIR (i.e., with NO_TEMPDIR
#defined).

Sun Mar 27 20:06:49 MST 2005
sysdep.c: in set_tmp_names(), fix botched placement of
"if (debugflag == 1) return;":  move it below declarations.

Sun May  1 21:45:46 MDT 2005
sysdep.c:  fix a possible fault under -DMSDOS and improper handling
of a tmpnam failure under the unusual combination of both -DNO_MKDTEMP
and -DNO_MKSTEMP (without -DNO_TEMPDIR).

Tue Oct  4 23:38:54 MDT 2005
libf2c.zip:  uninit.c:  on IA32 Linux systems, leave the rounding
precision alone rather than forcing it to 53 bits; compile with
-DUNINIT_F2C_PRECISION_53 to get the former behavior.  This only
affects Fortran files translated by f2c -trapuv .

Sun May  7 00:38:59 MDT 2006
  main.c, version.c:  add options -? (or --help) that print out
pointers to usage documentation and -v (or --version) that print
the current version.
  fc script:  fix botch with -O[123]; recognize --version (or -v)
and --help (or -?).
  Add f2c.pdf == PDF version of f2c.ps.

Sun Oct  8 02:45:04 MDT 2006
  putpcc.c: fix glitch in subscripting complex variables:  subscripts
of type integer*8 were converted to integer*4, which causes trouble
when 32-bit addressing does not suffice.

Tue Sep 11 23:54:05 MDT 2007
  xsum.c:  insert explicit "int" before main.

Mon Dec  3 20:53:24 MST 2007
  libf2c/main.c: insert explicit "int" before main.

Sat Apr  5 21:39:57 MDT 2008
  libf2c.zip: tweaks for political C++ and const correctness, and
to fix ctype trouble in some recent Linux versions.  No behavior
should change.

Sun Apr  6 22:38:56 MDT 2008
  libf2c.zip: adjust alternate makefiles to reflect yesterday's change.

Wed Nov 26 23:23:27 MST 2008
  libf2c.zip: add brief discussion of MacOSX to comments in makefile.u.

Fri Jan  2 23:13:25 MST 2009
  libf2c.zip: add  -DNO_ISATTY to CFLAGS assignment in makefile.vc.

Sat Apr 11 18:06:00 MDT 2009
  src/sysdep.c src/sysdeptest.c: tweak for MacOSX (include ).

NOTE:  the old libf77 and libi77 bundles are no longer being updated.
Use libf2c.zip instead.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/close.c0000644000175100001710000000256100000000000023076 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef KR_headers
integer f_clos(a) cllist *a;
#else
#undef abs
#undef min
#undef max
#include "stdlib.h"
#ifdef NON_UNIX_STDIO
#ifndef unlink
#define unlink remove
#endif
#else
#ifdef MSDOS
#include "io.h"
#else
#ifdef __cplusplus
extern "C" int unlink(const char*);
#else
extern int unlink(const char*);
#endif
#endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

integer f_clos(cllist *a)
#endif
{	unit *b;

	if(a->cunit >= MXUNIT) return(0);
	b= &f__units[a->cunit];
	if(b->ufd==NULL)
		goto done;
	if (b->uscrtch == 1)
		goto Delete;
	if (!a->csta)
		goto Keep;
	switch(*a->csta) {
		default:
	 	Keep:
		case 'k':
		case 'K':
			if(b->uwrt == 1)
				t_runc((alist *)a);
			if(b->ufnm) {
				fclose(b->ufd);
				free(b->ufnm);
				}
			break;
		case 'd':
		case 'D':
		Delete:
			fclose(b->ufd);
			if(b->ufnm) {
				unlink(b->ufnm); /*SYSDEP*/
				free(b->ufnm);
				}
		}
	b->ufd=NULL;
 done:
	b->uend=0;
	b->ufnm=NULL;
	return(0);
	}
 void
#ifdef KR_headers
f_exit()
#else
f_exit(void)
#endif
{	int i;
	static cllist xx;
	if (!xx.cerr) {
		xx.cerr=1;
		xx.csta=NULL;
		for(i=0;i
#else /*{*/
#ifndef My_ctype_DEF
extern char My_ctype[];
#else /*{*/
char My_ctype[264] = {
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 2, 2, 2, 2, 2, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	2, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0};
#endif /*}*/

#define isdigit(x) (My_ctype[(x)+8] & 1)
#define isspace(x) (My_ctype[(x)+8] & 2)
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_abs.c0000644000175100001710000000033200000000000023033 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double d_abs(x) doublereal *x;
#else
double d_abs(doublereal *x)
#endif
{
if(*x >= 0)
	return(*x);
return(- *x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_acos.c0000644000175100001710000000036500000000000023221 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double acos();
double d_acos(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_acos(doublereal *x)
#endif
{
return( acos(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_asin.c0000644000175100001710000000036500000000000023226 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double asin();
double d_asin(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_asin(doublereal *x)
#endif
{
return( asin(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_atan.c0000644000175100001710000000036500000000000023217 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double atan();
double d_atan(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_atan(doublereal *x)
#endif
{
return( atan(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_atn2.c0000644000175100001710000000041700000000000023136 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double atan2();
double d_atn2(x,y) doublereal *x, *y;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_atn2(doublereal *x, doublereal *y)
#endif
{
return( atan2(*x,*y) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_cnjg.c0000644000175100001710000000037700000000000023220 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

 VOID
#ifdef KR_headers
d_cnjg(r, z) doublecomplex *r, *z;
#else
d_cnjg(doublecomplex *r, doublecomplex *z)
#endif
{
	doublereal zi = z->i;
	r->r = z->r;
	r->i = -zi;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_cos.c0000644000175100001710000000036100000000000023054 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double cos();
double d_cos(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_cos(doublereal *x)
#endif
{
return( cos(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_cosh.c0000644000175100001710000000036500000000000023230 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double cosh();
double d_cosh(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_cosh(doublereal *x)
#endif
{
return( cosh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_dim.c0000644000175100001710000000035000000000000023037 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double d_dim(a,b) doublereal *a, *b;
#else
double d_dim(doublereal *a, doublereal *b)
#endif
{
return( *a > *b ? *a - *b : 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_exp.c0000644000175100001710000000036100000000000023064 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double exp();
double d_exp(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_exp(doublereal *x)
#endif
{
return( exp(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_imag.c0000644000175100001710000000031100000000000023200 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double d_imag(z) doublecomplex *z;
#else
double d_imag(doublecomplex *z)
#endif
{
return(z->i);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_int.c0000644000175100001710000000041500000000000023062 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
double d_int(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_int(doublereal *x)
#endif
{
return( (*x>0) ? floor(*x) : -floor(- *x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_lg10.c0000644000175100001710000000044300000000000023034 0ustar00runnerdocker00000000000000#include "f2c.h"

#define log10e 0.43429448190325182765

#ifdef KR_headers
double log();
double d_lg10(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_lg10(doublereal *x)
#endif
{
return( log10e * log(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_log.c0000644000175100001710000000036100000000000023051 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double log();
double d_log(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_log(doublereal *x)
#endif
{
return( log(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_mod.c0000644000175100001710000000126000000000000023046 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
#ifdef IEEE_drem
double drem();
#else
double floor();
#endif
double d_mod(x,y) doublereal *x, *y;
#else
#ifdef IEEE_drem
double drem(double, double);
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif
double d_mod(doublereal *x, doublereal *y)
#endif
{
#ifdef IEEE_drem
	double xa, ya, z;
	if ((ya = *y) < 0.)
		ya = -ya;
	z = drem(xa = *x, ya);
	if (xa > 0) {
		if (z < 0)
			z += ya;
		}
	else if (z > 0)
		z -= ya;
	return z;
#else
	double quotient;
	if( (quotient = *x / *y) >= 0)
		quotient = floor(quotient);
	else
		quotient = -floor(-quotient);
	return(*x - (*y) * quotient );
#endif
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_nint.c0000644000175100001710000000043100000000000023236 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
double d_nint(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_nint(doublereal *x)
#endif
{
return( (*x)>=0 ?
	floor(*x + .5) : -floor(.5 - *x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_prod.c0000644000175100001710000000031700000000000023235 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double d_prod(x,y) real *x, *y;
#else
double d_prod(real *x, real *y)
#endif
{
return( (*x) * (*y) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_sign.c0000644000175100001710000000041200000000000023225 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double d_sign(a,b) doublereal *a, *b;
#else
double d_sign(doublereal *a, doublereal *b)
#endif
{
double x;
x = (*a >= 0 ? *a : - *a);
return( *b >= 0 ? x : -x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_sin.c0000644000175100001710000000036100000000000023061 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sin();
double d_sin(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_sin(doublereal *x)
#endif
{
return( sin(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_sinh.c0000644000175100001710000000036500000000000023235 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sinh();
double d_sinh(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_sinh(doublereal *x)
#endif
{
return( sinh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_sqrt.c0000644000175100001710000000036500000000000023265 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sqrt();
double d_sqrt(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_sqrt(doublereal *x)
#endif
{
return( sqrt(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_tan.c0000644000175100001710000000036100000000000023052 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double tan();
double d_tan(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_tan(doublereal *x)
#endif
{
return( tan(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/d_tanh.c0000644000175100001710000000036500000000000023226 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double tanh();
double d_tanh(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double d_tanh(doublereal *x)
#endif
{
return( tanh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/derf_.c0000644000175100001710000000033100000000000023041 0ustar00runnerdocker00000000000000#include "f2c.h"
#include 

#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double derf_(x) doublereal *x;
#else
double derf_(doublereal *x)
#endif
{
return( erf(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/derfc_.c0000644000175100001710000000033400000000000023207 0ustar00runnerdocker00000000000000#include "f2c.h"
#include 

#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double derfc_(x) doublereal *x;
#else
double derfc_(doublereal *x)
#endif
{
return( erfc(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/dfe.c0000644000175100001710000000510000000000000022517 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif

 int
y_rsk(Void)
{
	if(f__curunit->uend || f__curunit->url <= f__recpos
		|| f__curunit->url == 1) return 0;
	do {
		getc(f__cf);
	} while(++f__recpos < f__curunit->url);
	return 0;
}

 int
y_getc(Void)
{
	int ch;
	if(f__curunit->uend) return(-1);
	if((ch=getc(f__cf))!=EOF)
	{
		f__recpos++;
		if(f__curunit->url>=f__recpos ||
			f__curunit->url==1)
			return(ch);
		else	return(' ');
	}
	if(feof(f__cf))
	{
		f__curunit->uend=1;
		errno=0;
		return(-1);
	}
	err(f__elist->cierr,errno,"readingd");
}

 static int
y_rev(Void)
{
	if (f__recpos < f__hiwater)
		f__recpos = f__hiwater;
	if (f__curunit->url > 1)
		while(f__recpos < f__curunit->url)
			(*f__putn)(' ');
	if (f__recpos)
		f__putbuf(0);
	f__recpos = 0;
	return(0);
}

 static int
y_err(Void)
{
	err(f__elist->cierr, 110, "dfe");
}

 static int
y_newrec(Void)
{
	y_rev();
	f__hiwater = f__cursor = 0;
	return(1);
}

 int
#ifdef KR_headers
c_dfe(a) cilist *a;
#else
c_dfe(cilist *a)
#endif
{
	f__sequential=0;
	f__formatted=f__external=1;
	f__elist=a;
	f__cursor=f__scale=f__recpos=0;
	f__curunit = &f__units[a->ciunit];
	if(a->ciunit>MXUNIT || a->ciunit<0)
		err(a->cierr,101,"startchk");
	if(f__curunit->ufd==NULL && fk_open(DIR,FMT,a->ciunit))
		err(a->cierr,104,"dfe");
	f__cf=f__curunit->ufd;
	if(!f__curunit->ufmt) err(a->cierr,102,"dfe")
	if(!f__curunit->useek) err(a->cierr,104,"dfe")
	f__fmtbuf=a->cifmt;
	if(a->cirec <= 0)
		err(a->cierr,130,"dfe")
	FSEEK(f__cf,(OFF_T)f__curunit->url * (a->cirec-1),SEEK_SET);
	f__curunit->uend = 0;
	return(0);
}
#ifdef KR_headers
integer s_rdfe(a) cilist *a;
#else
integer s_rdfe(cilist *a)
#endif
{
	int n;
	if(!f__init) f_init();
	f__reading=1;
	if(n=c_dfe(a))return(n);
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr,errno,"read start");
	f__getn = y_getc;
	f__doed = rd_ed;
	f__doned = rd_ned;
	f__dorevert = f__donewrec = y_err;
	f__doend = y_rsk;
	if(pars_f(f__fmtbuf)<0)
		err(a->cierr,100,"read start");
	fmt_bg();
	return(0);
}
#ifdef KR_headers
integer s_wdfe(a) cilist *a;
#else
integer s_wdfe(cilist *a)
#endif
{
	int n;
	if(!f__init) f_init();
	f__reading=0;
	if(n=c_dfe(a)) return(n);
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr,errno,"startwrt");
	f__putn = x_putc;
	f__doed = w_ed;
	f__doned= w_ned;
	f__dorevert = y_err;
	f__donewrec = y_newrec;
	f__doend = y_rev;
	if(pars_f(f__fmtbuf)<0)
		err(a->cierr,100,"startwrt");
	fmt_bg();
	return(0);
}
integer e_rdfe(Void)
{
	en_fio();
	return 0;
}
integer e_wdfe(Void)
{
	return en_fio();
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/dolio.c0000644000175100001710000000072700000000000023101 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
extern "C" {
#endif
#ifdef KR_headers
extern int (*f__lioproc)();

integer do_lio(type,number,ptr,len) ftnint *number,*type; char *ptr; ftnlen len;
#else
extern int (*f__lioproc)(ftnint*, char*, ftnlen, ftnint);

integer do_lio(ftnint *type, ftnint *number, char *ptr, ftnlen len)
#endif
{
	return((*f__lioproc)(number,ptr,len,*type));
}
#ifdef __cplusplus
	}
#endif
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/dtime_.c0000644000175100001710000000171400000000000023231 0ustar00runnerdocker00000000000000#include "time.h"

#ifdef MSDOS
#undef USE_CLOCK
#define USE_CLOCK
#endif

#ifndef REAL
#define REAL double
#endif

#ifndef USE_CLOCK
#define _INCLUDE_POSIX_SOURCE	/* for HP-UX */
#define _INCLUDE_XOPEN_SOURCE	/* for HP-UX */
#include "sys/types.h"
#include "sys/times.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif

#undef Hz
#ifdef CLK_TCK
#define Hz CLK_TCK
#else
#ifdef HZ
#define Hz HZ
#else
#define Hz 60
#endif
#endif

 REAL
#ifdef KR_headers
dtime_(tarray) float *tarray;
#else
dtime_(float *tarray)
#endif
{
#ifdef USE_CLOCK
#ifndef CLOCKS_PER_SECOND
#define CLOCKS_PER_SECOND Hz
#endif
	static double t0;
	double t = clock();
	tarray[1] = 0;
	tarray[0] = (t - t0) / CLOCKS_PER_SECOND;
	t0 = t;
	return tarray[0];
#else
	struct tms t;
	static struct tms t0;

	times(&t);
	tarray[0] = (double)(t.tms_utime - t0.tms_utime) / Hz;
	tarray[1] = (double)(t.tms_stime - t0.tms_stime) / Hz;
	t0 = t;
	return tarray[0] + tarray[1];
#endif
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/due.c0000644000175100001710000000313000000000000022537 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif

 int
#ifdef KR_headers
c_due(a) cilist *a;
#else
c_due(cilist *a)
#endif
{
	if(!f__init) f_init();
	f__sequential=f__formatted=f__recpos=0;
	f__external=1;
	f__curunit = &f__units[a->ciunit];
	if(a->ciunit>=MXUNIT || a->ciunit<0)
		err(a->cierr,101,"startio");
	f__elist=a;
	if(f__curunit->ufd==NULL && fk_open(DIR,UNF,a->ciunit) ) err(a->cierr,104,"due");
	f__cf=f__curunit->ufd;
	if(f__curunit->ufmt) err(a->cierr,102,"cdue")
	if(!f__curunit->useek) err(a->cierr,104,"cdue")
	if(f__curunit->ufd==NULL) err(a->cierr,114,"cdue")
	if(a->cirec <= 0)
		err(a->cierr,130,"due")
	FSEEK(f__cf,(OFF_T)(a->cirec-1)*f__curunit->url,SEEK_SET);
	f__curunit->uend = 0;
	return(0);
}
#ifdef KR_headers
integer s_rdue(a) cilist *a;
#else
integer s_rdue(cilist *a)
#endif
{
	int n;
	f__reading=1;
	if(n=c_due(a)) return(n);
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr,errno,"read start");
	return(0);
}
#ifdef KR_headers
integer s_wdue(a) cilist *a;
#else
integer s_wdue(cilist *a)
#endif
{
	int n;
	f__reading=0;
	if(n=c_due(a)) return(n);
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr,errno,"write start");
	return(0);
}
integer e_rdue(Void)
{
	if(f__curunit->url==1 || f__recpos==f__curunit->url)
		return(0);
	FSEEK(f__cf,(OFF_T)(f__curunit->url-f__recpos),SEEK_CUR);
	if(FTELL(f__cf)%f__curunit->url)
		err(f__elist->cierr,200,"syserr");
	return(0);
}
integer e_wdue(Void)
{
#ifdef ALWAYS_FLUSH
	if (fflush(f__cf))
		err(f__elist->cierr,errno,"write end");
#endif
	return(e_rdue());
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/dummy.c0000644000175100001710000000004000000000000023112 0ustar00runnerdocker00000000000000
int MAIN__(void) { return 0; }
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/ef1asc_.c0000644000175100001710000000101100000000000023257 0ustar00runnerdocker00000000000000/* EFL support routine to copy string b to string a */

#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif


#define M	( (long) (sizeof(long) - 1) )
#define EVEN(x)	( ( (x)+ M) & (~M) )

#ifdef KR_headers
extern VOID s_copy();
ef1asc_(a, la, b, lb) ftnint *a, *b; ftnlen *la, *lb;
#else
extern void s_copy(char*,char*,ftnlen,ftnlen);
int ef1asc_(ftnint *a, ftnlen *la, ftnint *b, ftnlen *lb)
#endif
{
s_copy( (char *)a, (char *)b, EVEN(*la), *lb );
return 0;	/* ignored return value */
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/ef1cmc_.c0000644000175100001710000000065300000000000023266 0ustar00runnerdocker00000000000000/* EFL support routine to compare two character strings */

#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
integer ef1cmc_(a, la, b, lb) ftnint *a, *b; ftnlen *la, *lb;
#else
extern integer s_cmp(char*,char*,ftnlen,ftnlen);
integer ef1cmc_(ftnint *a, ftnlen *la, ftnint *b, ftnlen *lb)
#endif
{
return( s_cmp( (char *)a, (char *)b, *la, *lb) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/endfile.c0000644000175100001710000000542600000000000023402 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"

/* Compile this with -DNO_TRUNCATE if unistd.h does not exist or */
/* if it does not define int truncate(const char *name, off_t). */

#ifdef MSDOS
#undef NO_TRUNCATE
#define NO_TRUNCATE
#endif

#ifndef NO_TRUNCATE
#include "unistd.h"
#endif

#ifdef KR_headers
extern char *strcpy();
extern FILE *tmpfile();
#else
#undef abs
#undef min
#undef max
#include "stdlib.h"
#include "string.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif

extern char *f__r_mode[], *f__w_mode[];

#ifdef KR_headers
integer f_end(a) alist *a;
#else
integer f_end(alist *a)
#endif
{
	unit *b;
	FILE *tf;

	if(a->aunit>=MXUNIT || a->aunit<0) err(a->aerr,101,"endfile");
	b = &f__units[a->aunit];
	if(b->ufd==NULL) {
		char nbuf[10];
		sprintf(nbuf,"fort.%ld",(long)a->aunit);
		if (tf = FOPEN(nbuf, f__w_mode[0]))
			fclose(tf);
		return(0);
		}
	b->uend=1;
	return(b->useek ? t_runc(a) : 0);
}

#ifdef NO_TRUNCATE
 static int
#ifdef KR_headers
copy(from, len, to) FILE *from, *to; register long len;
#else
copy(FILE *from, register long len, FILE *to)
#endif
{
	int len1;
	char buf[BUFSIZ];

	while(fread(buf, len1 = len > BUFSIZ ? BUFSIZ : (int)len, 1, from)) {
		if (!fwrite(buf, len1, 1, to))
			return 1;
		if ((len -= len1) <= 0)
			break;
		}
	return 0;
	}
#endif /* NO_TRUNCATE */

 int
#ifdef KR_headers
t_runc(a) alist *a;
#else
t_runc(alist *a)
#endif
{
	OFF_T loc, len;
	unit *b;
	int rc;
	FILE *bf;
#ifdef NO_TRUNCATE
	FILE *tf;
#endif

	b = &f__units[a->aunit];
	if(b->url)
		return(0);	/*don't truncate direct files*/
	loc=FTELL(bf = b->ufd);
	FSEEK(bf,(OFF_T)0,SEEK_END);
	len=FTELL(bf);
	if (loc >= len || b->useek == 0)
		return(0);
#ifdef NO_TRUNCATE
	if (b->ufnm == NULL)
		return 0;
	rc = 0;
	fclose(b->ufd);
	if (!loc) {
		if (!(bf = FOPEN(b->ufnm, f__w_mode[b->ufmt])))
			rc = 1;
		if (b->uwrt)
			b->uwrt = 1;
		goto done;
		}
	if (!(bf = FOPEN(b->ufnm, f__r_mode[0]))
	 || !(tf = tmpfile())) {
#ifdef NON_UNIX_STDIO
 bad:
#endif
		rc = 1;
		goto done;
		}
	if (copy(bf, (long)loc, tf)) {
 bad1:
		rc = 1;
		goto done1;
		}
	if (!(bf = FREOPEN(b->ufnm, f__w_mode[0], bf)))
		goto bad1;
	rewind(tf);
	if (copy(tf, (long)loc, bf))
		goto bad1;
	b->uwrt = 1;
	b->urw = 2;
#ifdef NON_UNIX_STDIO
	if (b->ufmt) {
		fclose(bf);
		if (!(bf = FOPEN(b->ufnm, f__w_mode[3])))
			goto bad;
		FSEEK(bf,(OFF_T)0,SEEK_END);
		b->urw = 3;
		}
#endif
done1:
	fclose(tf);
done:
	f__cf = b->ufd = bf;
#else /* NO_TRUNCATE */
	if (b->urw & 2)
		fflush(b->ufd); /* necessary on some Linux systems */
#ifndef FTRUNCATE
#define FTRUNCATE ftruncate
#endif
	rc = FTRUNCATE(fileno(b->ufd), loc);
	/* The following FSEEK is unnecessary on some systems, */
	/* but should be harmless. */
	FSEEK(b->ufd, (OFF_T)0, SEEK_END);
#endif /* NO_TRUNCATE */
	if (rc)
		err(a->aerr,111,"endfile");
	return 0;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/erf_.c0000644000175100001710000000037000000000000022700 0ustar00runnerdocker00000000000000#include "f2c.h"
#include 

#ifdef __cplusplus
extern "C" {
#endif

#ifndef REAL
#define REAL double
#endif

#ifdef KR_headers
REAL erf_(x) real *x;
#else
REAL erf_(real *x)
#endif
{
return( erf((double)*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/erfc_.c0000644000175100001710000000037300000000000023046 0ustar00runnerdocker00000000000000#include "f2c.h"
#include 

#ifdef __cplusplus
extern "C" {
#endif

#ifndef REAL
#define REAL double
#endif

#ifdef KR_headers
REAL erfc_(x) real *x;
#else
REAL erfc_(real *x)
#endif
{
return( erfc((double)*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/err.c0000644000175100001710000001445200000000000022563 0ustar00runnerdocker00000000000000#include "sysdep1.h"	/* here to get stat64 on some badly designed Linux systems */
#include "f2c.h"
#ifdef KR_headers
#define Const /*nothing*/
extern char *malloc();
#else
#define Const const
#undef abs
#undef min
#undef max
#include "stdlib.h"
#endif
#include "fio.h"
#include "fmt.h"	/* for struct syl */

/* Compile this with -DNO_ISATTY if unistd.h does not exist or */
/* if it does not define int isatty(int). */
#ifdef NO_ISATTY
#define isatty(x) 0
#else
#include 
#endif

#ifdef __cplusplus
extern "C" {
#endif

/*global definitions*/
unit f__units[MXUNIT];	/*unit table*/
flag f__init;	/*0 on entry, 1 after initializations*/
cilist *f__elist;	/*active external io list*/
icilist *f__svic;	/*active internal io list*/
flag f__reading;	/*1 if reading, 0 if writing*/
flag f__cplus,f__cblank;
Const char *f__fmtbuf;
flag f__external;	/*1 if external io, 0 if internal */
#ifdef KR_headers
int (*f__doed)(),(*f__doned)();
int (*f__doend)(),(*f__donewrec)(),(*f__dorevert)();
int (*f__getn)();	/* for formatted input */
void (*f__putn)();	/* for formatted output */
#else
int (*f__getn)(void);	/* for formatted input */
void (*f__putn)(int);	/* for formatted output */
int (*f__doed)(struct syl*, char*, ftnlen),(*f__doned)(struct syl*);
int (*f__dorevert)(void),(*f__donewrec)(void),(*f__doend)(void);
#endif
flag f__sequential;	/*1 if sequential io, 0 if direct*/
flag f__formatted;	/*1 if formatted io, 0 if unformatted*/
FILE *f__cf;	/*current file*/
unit *f__curunit;	/*current unit*/
int f__recpos;	/*place in current record*/
OFF_T f__cursor, f__hiwater;
int f__scale;
char *f__icptr;

/*error messages*/
Const char *F_err[] =
{
	"error in format",				/* 100 */
	"illegal unit number",				/* 101 */
	"formatted io not allowed",			/* 102 */
	"unformatted io not allowed",			/* 103 */
	"direct io not allowed",			/* 104 */
	"sequential io not allowed",			/* 105 */
	"can't backspace file",				/* 106 */
	"null file name",				/* 107 */
	"can't stat file",				/* 108 */
	"unit not connected",				/* 109 */
	"off end of record",				/* 110 */
	"truncation failed in endfile",			/* 111 */
	"incomprehensible list input",			/* 112 */
	"out of free space",				/* 113 */
	"unit not connected",				/* 114 */
	"read unexpected character",			/* 115 */
	"bad logical input field",			/* 116 */
	"bad variable type",				/* 117 */
	"bad namelist name",				/* 118 */
	"variable not in namelist",			/* 119 */
	"no end record",				/* 120 */
	"variable count incorrect",			/* 121 */
	"subscript for scalar variable",		/* 122 */
	"invalid array section",			/* 123 */
	"substring out of bounds",			/* 124 */
	"subscript out of bounds",			/* 125 */
	"can't read file",				/* 126 */
	"can't write file",				/* 127 */
	"'new' file exists",				/* 128 */
	"can't append to file",				/* 129 */
	"non-positive record number",			/* 130 */
	"nmLbuf overflow"				/* 131 */
};
#define MAXERR (sizeof(F_err)/sizeof(char *)+100)

 int
#ifdef KR_headers
f__canseek(f) FILE *f; /*SYSDEP*/
#else
f__canseek(FILE *f) /*SYSDEP*/
#endif
{
#ifdef NON_UNIX_STDIO
	return !isatty(fileno(f));
#else
	struct STAT_ST x;

	if (FSTAT(fileno(f),&x) < 0)
		return(0);
#ifdef S_IFMT
	switch(x.st_mode & S_IFMT) {
	case S_IFDIR:
	case S_IFREG:
		if(x.st_nlink > 0)	/* !pipe */
			return(1);
		else
			return(0);
	case S_IFCHR:
		if(isatty(fileno(f)))
			return(0);
		return(1);
#ifdef S_IFBLK
	case S_IFBLK:
		return(1);
#endif
	}
#else
#ifdef S_ISDIR
	/* POSIX version */
	if (S_ISREG(x.st_mode) || S_ISDIR(x.st_mode)) {
		if(x.st_nlink > 0)	/* !pipe */
			return(1);
		else
			return(0);
		}
	if (S_ISCHR(x.st_mode)) {
		if(isatty(fileno(f)))
			return(0);
		return(1);
		}
	if (S_ISBLK(x.st_mode))
		return(1);
#else
	Help! How does fstat work on this system?
#endif
#endif
	return(0);	/* who knows what it is? */
#endif
}

 void
#ifdef KR_headers
f__fatal(n,s) char *s;
#else
f__fatal(int n, const char *s)
#endif
{
	if(n<100 && n>=0) perror(s); /*SYSDEP*/
	else if(n >= (int)MAXERR || n < -1)
	{	fprintf(stderr,"%s: illegal error number %d\n",s,n);
	}
	else if(n == -1) fprintf(stderr,"%s: end of file\n",s);
	else
		fprintf(stderr,"%s: %s\n",s,F_err[n-100]);
	if (f__curunit) {
		fprintf(stderr,"apparent state: unit %d ",
			(int)(f__curunit-f__units));
		fprintf(stderr, f__curunit->ufnm ? "named %s\n" : "(unnamed)\n",
			f__curunit->ufnm);
		}
	else
		fprintf(stderr,"apparent state: internal I/O\n");
	if (f__fmtbuf)
		fprintf(stderr,"last format: %s\n",f__fmtbuf);
	fprintf(stderr,"lately %s %s %s %s",f__reading?"reading":"writing",
		f__sequential?"sequential":"direct",f__formatted?"formatted":"unformatted",
		f__external?"external":"internal");
	sig_die(" IO", 1);
}
/*initialization routine*/
 VOID
f_init(Void)
{	unit *p;

	f__init=1;
	p= &f__units[0];
	p->ufd=stderr;
	p->useek=f__canseek(stderr);
	p->ufmt=1;
	p->uwrt=1;
	p = &f__units[5];
	p->ufd=stdin;
	p->useek=f__canseek(stdin);
	p->ufmt=1;
	p->uwrt=0;
	p= &f__units[6];
	p->ufd=stdout;
	p->useek=f__canseek(stdout);
	p->ufmt=1;
	p->uwrt=1;
}

 int
#ifdef KR_headers
f__nowreading(x) unit *x;
#else
f__nowreading(unit *x)
#endif
{
	OFF_T loc;
	int ufmt, urw;
	extern char *f__r_mode[], *f__w_mode[];

	if (x->urw & 1)
		goto done;
	if (!x->ufnm)
		goto cantread;
	ufmt = x->url ? 0 : x->ufmt;
	loc = FTELL(x->ufd);
	urw = 3;
	if (!FREOPEN(x->ufnm, f__w_mode[ufmt|2], x->ufd)) {
		urw = 1;
		if(!FREOPEN(x->ufnm, f__r_mode[ufmt], x->ufd)) {
 cantread:
			errno = 126;
			return 1;
			}
		}
	FSEEK(x->ufd,loc,SEEK_SET);
	x->urw = urw;
 done:
	x->uwrt = 0;
	return 0;
}

 int
#ifdef KR_headers
f__nowwriting(x) unit *x;
#else
f__nowwriting(unit *x)
#endif
{
	OFF_T loc;
	int ufmt;
	extern char *f__w_mode[];

	if (x->urw & 2) {
		if (x->urw & 1)
			FSEEK(x->ufd, (OFF_T)0, SEEK_CUR);
		goto done;
		}
	if (!x->ufnm)
		goto cantwrite;
	ufmt = x->url ? 0 : x->ufmt;
	if (x->uwrt == 3) { /* just did write, rewind */
		if (!(f__cf = x->ufd =
				FREOPEN(x->ufnm,f__w_mode[ufmt],x->ufd)))
			goto cantwrite;
		x->urw = 2;
		}
	else {
		loc=FTELL(x->ufd);
		if (!(f__cf = x->ufd =
			FREOPEN(x->ufnm, f__w_mode[ufmt | 2], x->ufd)))
			{
			x->ufd = NULL;
 cantwrite:
			errno = 127;
			return(1);
			}
		x->urw = 3;
		FSEEK(x->ufd,loc,SEEK_SET);
		}
 done:
	x->uwrt = 1;
	return 0;
}

 int
#ifdef KR_headers
err__fl(f, m, s) int f, m; char *s;
#else
err__fl(int f, int m, const char *s)
#endif
{
	if (!f)
		f__fatal(m, s);
	if (f__doend)
		(*f__doend)();
	return errno = m;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/etime_.c0000644000175100001710000000150700000000000023232 0ustar00runnerdocker00000000000000#include "time.h"

#ifdef MSDOS
#undef USE_CLOCK
#define USE_CLOCK
#endif

#ifndef REAL
#define REAL double
#endif

#ifndef USE_CLOCK
#define _INCLUDE_POSIX_SOURCE	/* for HP-UX */
#define _INCLUDE_XOPEN_SOURCE	/* for HP-UX */
#include "sys/types.h"
#include "sys/times.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif

#undef Hz
#ifdef CLK_TCK
#define Hz CLK_TCK
#else
#ifdef HZ
#define Hz HZ
#else
#define Hz 60
#endif
#endif

 REAL
#ifdef KR_headers
etime_(tarray) float *tarray;
#else
etime_(float *tarray)
#endif
{
#ifdef USE_CLOCK
#ifndef CLOCKS_PER_SECOND
#define CLOCKS_PER_SECOND Hz
#endif
	double t = clock();
	tarray[1] = 0;
	return tarray[0] = t / CLOCKS_PER_SECOND;
#else
	struct tms t;

	times(&t);
	return	  (tarray[0] = (double)t.tms_utime/Hz)
		+ (tarray[1] = (double)t.tms_stime/Hz);
#endif
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/exit_.c0000644000175100001710000000103700000000000023076 0ustar00runnerdocker00000000000000/* This gives the effect of

	subroutine exit(rc)
	integer*4 rc
	stop
	end

 * with the added side effect of supplying rc as the program's exit code.
 */

#include "f2c.h"
#undef abs
#undef min
#undef max
#ifndef KR_headers
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
extern "C" {
#endif
extern void f_exit(void);
#endif

 void
#ifdef KR_headers
exit_(rc) integer *rc;
#else
exit_(integer *rc)
#endif
{
#ifdef NO_ONEXIT
	f_exit();
#endif
	exit(*rc);
	}
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/f2c.h00000644000175100001710000001237500000000000022534 0ustar00runnerdocker00000000000000/* f2c.h  --  Standard Fortran to C header file */

/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."

	- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */

#ifndef F2C_INCLUDE
#define F2C_INCLUDE

#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
typedef int integer;
typedef unsigned int uinteger;
#else
typedef long int integer;
typedef unsigned long int uinteger;
#endif
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } f2c_complex;
typedef struct { doublereal r, i; } doublecomplex;
#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
typedef int logical;
#else
typedef long int logical;
#endif
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#ifdef INTEGER_STAR_8	/* Adjust for integer*8. */
#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
typedef long longint;		/* system-dependent */
typedef unsigned long ulongint;	/* system-dependent */
#else
typedef long long longint;              /* system-dependent - oh yeah*/
typedef unsigned long long ulongint;    /* system-dependent - oh yeah*/
#endif
#define qbit_clear(a,b)	((a) & ~((ulongint)1 << (b)))
#define qbit_set(a,b)	((a) |  ((ulongint)1 << (b)))
#endif

#define TRUE_ (1)
#define FALSE_ (0)

/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif

/* I/O stuff */

#ifdef f2c_i2
/* for -i2 */
typedef short flag;
typedef short ftnlen;
typedef short ftnint;
#else
#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
#else
typedef long int flag;
typedef long int ftnlen;
typedef long int ftnint;
#endif
#endif

/*external read, write*/
typedef struct
{	flag cierr;
	ftnint ciunit;
	flag ciend;
	char *cifmt;
	ftnint cirec;
} cilist;

/*internal read, write*/
typedef struct
{	flag icierr;
	char *iciunit;
	flag iciend;
	char *icifmt;
	ftnint icirlen;
	ftnint icirnum;
} icilist;

/*open*/
typedef struct
{	flag oerr;
	ftnint ounit;
	char *ofnm;
	ftnlen ofnmlen;
	char *osta;
	char *oacc;
	char *ofm;
	ftnint orl;
	char *oblnk;
} olist;

/*close*/
typedef struct
{	flag cerr;
	ftnint cunit;
	char *csta;
} cllist;

/*rewind, backspace, endfile*/
typedef struct
{	flag aerr;
	ftnint aunit;
} alist;

/* inquire */
typedef struct
{	flag inerr;
	ftnint inunit;
	char *infile;
	ftnlen infilen;
	ftnint	*inex;	/*parameters in standard's order*/
	ftnint	*inopen;
	ftnint	*innum;
	ftnint	*innamed;
	char	*inname;
	ftnlen	innamlen;
	char	*inacc;
	ftnlen	inacclen;
	char	*inseq;
	ftnlen	inseqlen;
	char 	*indir;
	ftnlen	indirlen;
	char	*infmt;
	ftnlen	infmtlen;
	char	*inform;
	ftnint	informlen;
	char	*inunf;
	ftnlen	inunflen;
	ftnint	*inrecl;
	ftnint	*innrec;
	char	*inblank;
	ftnlen	inblanklen;
} inlist;

#define VOID void

union Multitype {	/* for multiple entry points */
	integer1 g;
	shortint h;
	integer i;
	/* longint j; */
	real r;
	doublereal d;
	complex c;
	doublecomplex z;
	};

typedef union Multitype Multitype;

/*typedef long int Long;*/	/* No longer used; formerly in Namelist */

struct Vardesc {	/* for Namelist */
	char *name;
	char *addr;
	ftnlen *dims;
	int  type;
	};
typedef struct Vardesc Vardesc;

struct Namelist {
	char *name;
	Vardesc **vars;
	int nvars;
	};
typedef struct Namelist Namelist;

#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (doublereal)abs(x)
#define min(a,b) ((a) <= (b) ? (a) : (b))
#define max(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (doublereal)min(a,b)
#define dmax(a,b) (doublereal)max(a,b)
#define bit_test(a,b)	((a) >> (b) & 1)
#define bit_clear(a,b)	((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b)	((a) |  ((uinteger)1 << (b)))

/* procedure parameter types for -A and -C++ */

#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef int /* Unknown procedure type */ (*U_fp)(...);
typedef shortint (*J_fp)(...);
typedef integer (*I_fp)(...);
typedef real (*R_fp)(...);
typedef doublereal (*D_fp)(...), (*E_fp)(...);
typedef /* Complex */ VOID (*C_fp)(...);
typedef /* Double Complex */ VOID (*Z_fp)(...);
typedef logical (*L_fp)(...);
typedef shortlogical (*K_fp)(...);
typedef /* Character */ VOID (*H_fp)(...);
typedef /* Subroutine */ int (*S_fp)(...);
#else
typedef int /* Unknown procedure type */ (*U_fp)();
typedef shortint (*J_fp)();
typedef integer (*I_fp)();
typedef real (*R_fp)();
typedef doublereal (*D_fp)(), (*E_fp)();
typedef /* Complex */ VOID (*C_fp)();
typedef /* Double Complex */ VOID (*Z_fp)();
typedef logical (*L_fp)();
typedef shortlogical (*K_fp)();
typedef /* Character */ VOID (*H_fp)();
typedef /* Subroutine */ int (*S_fp)();
#endif
/* E_fp is for real functions when -R is not specified */
typedef VOID C_f;	/* complex function */
typedef VOID H_f;	/* character function */
typedef VOID Z_f;	/* double complex function */
typedef doublereal E_f;	/* real function with -R not specified */

/* undef any lower-case symbols that your C compiler predefines, e.g.: */

#ifndef Skip_f2c_Undefs
#undef cray
#undef gcos
#undef mc68010
#undef mc68020
#undef mips
#undef pdp11
#undef sgi
#undef sparc
#undef sun
#undef sun2
#undef sun3
#undef sun4
#undef u370
#undef u3b
#undef u3b2
#undef u3b5
#undef unix
#undef vax
#endif
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/f2ch.add0000644000175100001710000001365400000000000023126 0ustar00runnerdocker00000000000000/* If you are using a C++ compiler, append the following to f2c.h
   for compiling libF77 and libI77. */

#ifdef __cplusplus
extern "C" {
extern int abort_(void);
extern double c_abs(complex *);
extern void c_cos(complex *, complex *);
extern void c_div(complex *, complex *, complex *);
extern void c_exp(complex *, complex *);
extern void c_log(complex *, complex *);
extern void c_sin(complex *, complex *);
extern void c_sqrt(complex *, complex *);
extern double d_abs(double *);
extern double d_acos(double *);
extern double d_asin(double *);
extern double d_atan(double *);
extern double d_atn2(double *, double *);
extern void d_cnjg(doublecomplex *, doublecomplex *);
extern double d_cos(double *);
extern double d_cosh(double *);
extern double d_dim(double *, double *);
extern double d_exp(double *);
extern double d_imag(doublecomplex *);
extern double d_int(double *);
extern double d_lg10(double *);
extern double d_log(double *);
extern double d_mod(double *, double *);
extern double d_nint(double *);
extern double d_prod(float *, float *);
extern double d_sign(double *, double *);
extern double d_sin(double *);
extern double d_sinh(double *);
extern double d_sqrt(double *);
extern double d_tan(double *);
extern double d_tanh(double *);
extern double derf_(double *);
extern double derfc_(double *);
extern integer do_fio(ftnint *, char *, ftnlen);
extern integer do_lio(ftnint *, ftnint *, char *, ftnlen);
extern integer do_uio(ftnint *, char *, ftnlen);
extern integer e_rdfe(void);
extern integer e_rdue(void);
extern integer e_rsfe(void);
extern integer e_rsfi(void);
extern integer e_rsle(void);
extern integer e_rsli(void);
extern integer e_rsue(void);
extern integer e_wdfe(void);
extern integer e_wdue(void);
extern integer e_wsfe(void);
extern integer e_wsfi(void);
extern integer e_wsle(void);
extern integer e_wsli(void);
extern integer e_wsue(void);
extern int ef1asc_(ftnint *, ftnlen *, ftnint *, ftnlen *);
extern integer ef1cmc_(ftnint *, ftnlen *, ftnint *, ftnlen *);
extern double erf(double);
extern double erf_(float *);
extern double erfc(double);
extern double erfc_(float *);
extern integer f_back(alist *);
extern integer f_clos(cllist *);
extern integer f_end(alist *);
extern void f_exit(void);
extern integer f_inqu(inlist *);
extern integer f_open(olist *);
extern integer f_rew(alist *);
extern int flush_(void);
extern void getarg_(integer *, char *, ftnlen);
extern void getenv_(char *, char *, ftnlen, ftnlen);
extern short h_abs(short *);
extern short h_dim(short *, short *);
extern short h_dnnt(double *);
extern short h_indx(char *, char *, ftnlen, ftnlen);
extern short h_len(char *, ftnlen);
extern short h_mod(short *, short *);
extern short h_nint(float *);
extern short h_sign(short *, short *);
extern short hl_ge(char *, char *, ftnlen, ftnlen);
extern short hl_gt(char *, char *, ftnlen, ftnlen);
extern short hl_le(char *, char *, ftnlen, ftnlen);
extern short hl_lt(char *, char *, ftnlen, ftnlen);
extern integer i_abs(integer *);
extern integer i_dim(integer *, integer *);
extern integer i_dnnt(double *);
extern integer i_indx(char *, char *, ftnlen, ftnlen);
extern integer i_len(char *, ftnlen);
extern integer i_mod(integer *, integer *);
extern integer i_nint(float *);
extern integer i_sign(integer *, integer *);
extern integer iargc_(void);
extern ftnlen l_ge(char *, char *, ftnlen, ftnlen);
extern ftnlen l_gt(char *, char *, ftnlen, ftnlen);
extern ftnlen l_le(char *, char *, ftnlen, ftnlen);
extern ftnlen l_lt(char *, char *, ftnlen, ftnlen);
extern void pow_ci(complex *, complex *, integer *);
extern double pow_dd(double *, double *);
extern double pow_di(double *, integer *);
extern short pow_hh(short *, shortint *);
extern integer pow_ii(integer *, integer *);
extern double pow_ri(float *, integer *);
extern void pow_zi(doublecomplex *, doublecomplex *, integer *);
extern void pow_zz(doublecomplex *, doublecomplex *, doublecomplex *);
extern double r_abs(float *);
extern double r_acos(float *);
extern double r_asin(float *);
extern double r_atan(float *);
extern double r_atn2(float *, float *);
extern void r_cnjg(complex *, complex *);
extern double r_cos(float *);
extern double r_cosh(float *);
extern double r_dim(float *, float *);
extern double r_exp(float *);
extern double r_imag(complex *);
extern double r_int(float *);
extern double r_lg10(float *);
extern double r_log(float *);
extern double r_mod(float *, float *);
extern double r_nint(float *);
extern double r_sign(float *, float *);
extern double r_sin(float *);
extern double r_sinh(float *);
extern double r_sqrt(float *);
extern double r_tan(float *);
extern double r_tanh(float *);
extern void s_cat(char *, char **, integer *, integer *, ftnlen);
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
extern void s_copy(char *, char *, ftnlen, ftnlen);
extern int s_paus(char *, ftnlen);
extern integer s_rdfe(cilist *);
extern integer s_rdue(cilist *);
extern integer s_rnge(char *, integer, char *, integer);
extern integer s_rsfe(cilist *);
extern integer s_rsfi(icilist *);
extern integer s_rsle(cilist *);
extern integer s_rsli(icilist *);
extern integer s_rsne(cilist *);
extern integer s_rsni(icilist *);
extern integer s_rsue(cilist *);
extern int s_stop(char *, ftnlen);
extern integer s_wdfe(cilist *);
extern integer s_wdue(cilist *);
extern integer s_wsfe(cilist *);
extern integer s_wsfi(icilist *);
extern integer s_wsle(cilist *);
extern integer s_wsli(icilist *);
extern integer s_wsne(cilist *);
extern integer s_wsni(icilist *);
extern integer s_wsue(cilist *);
extern void sig_die(char *, int);
extern integer signal_(integer *, void (*)(int));
extern integer system_(char *, ftnlen);
extern double z_abs(doublecomplex *);
extern void z_cos(doublecomplex *, doublecomplex *);
extern void z_div(doublecomplex *, doublecomplex *, doublecomplex *);
extern void z_exp(doublecomplex *, doublecomplex *);
extern void z_log(doublecomplex *, doublecomplex *);
extern void z_sin(doublecomplex *, doublecomplex *);
extern void z_sqrt(doublecomplex *, doublecomplex *);
	}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/f77_aloc.c0000644000175100001710000000125400000000000023370 0ustar00runnerdocker00000000000000#include "f2c.h"
#undef abs
#undef min
#undef max
#include "stdio.h"

static integer memfailure = 3;

#ifdef KR_headers
extern char *malloc();
extern void exit_();

 char *
F77_aloc(Len, whence) integer Len; char *whence;
#else
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
extern "C" {
#endif
extern void exit_(integer*);
#ifdef __cplusplus
	}
#endif

 char *
F77_aloc(integer Len, const char *whence)
#endif
{
	char *rv;
	unsigned int uLen = (unsigned int) Len;	/* for K&R C */

	if (!(rv = (char*)malloc(uLen))) {
		fprintf(stderr, "malloc(%u) failure in %s\n",
			uLen, whence);
		exit_(&memfailure);
		}
	return rv;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/f77vers.c0000644000175100001710000001150500000000000023272 0ustar00runnerdocker00000000000000 char 
_libf77_version_f2c[] = "\n@(#) LIBF77 VERSION (f2c) 20051004\n";

/*
2.00	11 June 1980.  File version.c added to library.
2.01	31 May 1988.  s_paus() flushes stderr; names of hl_* fixed
	[ d]erf[c ] added
	 8 Aug. 1989: #ifdefs for f2c -i2 added to s_cat.c
	29 Nov. 1989: s_cmp returns long (for f2c)
	30 Nov. 1989: arg types from f2c.h
	12 Dec. 1989: s_rnge allows long names
	19 Dec. 1989: getenv_ allows unsorted environment
	28 Mar. 1990: add exit(0) to end of main()
	 2 Oct. 1990: test signal(...) == SIG_IGN rather than & 01 in main
	17 Oct. 1990: abort() calls changed to sig_die(...,1)
	22 Oct. 1990: separate sig_die from main
	25 Apr. 1991: minor, theoretically invisible tweaks to s_cat, sig_die
	31 May  1991: make system_ return status
	18 Dec. 1991: change long to ftnlen (for -i2) many places
	28 Feb. 1992: repair z_sqrt.c (scribbled on input, gave wrong answer)
	18 July 1992: for n < 0, repair handling of 0**n in pow_[dr]i.c
			and m**n in pow_hh.c and pow_ii.c;
			catch SIGTRAP in main() for error msg before abort
	23 July 1992: switch to ANSI prototypes unless KR_headers is #defined
	23 Oct. 1992: fix botch in signal_.c (erroneous deref of 2nd arg);
			change Cabs to f__cabs.
	12 March 1993: various tweaks for C++
	 2 June 1994: adjust so abnormal terminations invoke f_exit just once
	16 Sept. 1994: s_cmp: treat characters as unsigned in comparisons.
	19 Sept. 1994: s_paus: flush after end of PAUSE; add -DMSDOS
	12 Jan. 1995:	pow_[dhiqrz][hiq]: adjust x**i to work on machines
			that sign-extend right shifts when i is the most
			negative integer.
	26 Jan. 1995: adjust s_cat.c, s_copy.c to permit the left-hand side
			of character assignments to appear on the right-hand
			side (unless compiled with -DNO_OVERWRITE).
	27 Jan. 1995: minor tweak to s_copy.c: copy forward whenever
			possible (for better cache behavior).
	30 May 1995:  added subroutine exit(rc) integer rc. Version not changed.
	29 Aug. 1995: add F77_aloc.c; use it in s_cat.c and system_.c.
	6 Sept. 1995: fix return type of system_ under -DKR_headers.
	19 Dec. 1995: s_cat.c: fix bug when 2nd or later arg overlaps lhs.
	19 Mar. 1996: s_cat.c: supply missing break after overlap detection.
	13 May 1996:  add [lq]bitbits.c and [lq]bitshft.c (f90 bit intrinsics).
	19 June 1996: add casts to unsigned in [lq]bitshft.c.
	26 Feb. 1997: adjust functions with a complex output argument
			to permit aliasing it with input arguments.
			(For now, at least, this is just for possible
			benefit of g77.)
	4 April 1997: [cz]_div.c: tweaks invisible on most systems (that may
			affect systems using gratuitous extra precision).
	19 Sept. 1997: [de]time_.c (Unix systems only): change return
			type to double.
	2 May 1999:	getenv_.c: omit environ in favor of getenv().
			c_cos.c, c_exp.c, c_sin.c, d_cnjg.c, r_cnjg.c,
			z_cos.c, z_exp.c, z_log.c, z_sin.c: cope fully with
			overlapping arguments caused by equivalence.
	3 May 1999:	"invisible" tweaks to omit compiler warnings in
			abort_.c, ef1asc_.c, s_rnge.c, s_stop.c.

	7 Sept. 1999: [cz]_div.c: arrange for compilation under
			-DIEEE_COMPLEX_DIVIDE to make these routines
			avoid calling sig_die when the denominator
			vanishes; instead, they return pairs of NaNs
			or Infinities, depending whether the numerator
			also vanishes or not.  VERSION not changed.
	15 Nov. 1999: s_rnge.c: add casts for the case of
			sizeof(ftnint) == sizeof(int) < sizeof(long).
	10 March 2000: z_log.c: improve accuracy of Real(log(z)) for, e.g.,
			z near (+-1,eps) with |eps| small.  For the old
			evaluation, compile with -DPre20000310 .
	20 April 2000: s_cat.c: tweak argument types to accord with
			calls by f2c when ftnint and ftnlen are of
			different sizes (different numbers of bits).
	4 July 2000: adjustments to permit compilation by C++ compilers;
			VERSION string remains unchanged.
	29 Sept. 2000: dtime_.c, etime_.c: use floating-point divide.
			dtime_.d, erf_.c, erfc_.c, etime.c: for use with
			"f2c -R", compile with -DREAL=float.
	23 June 2001: add uninit.c; [fi]77vers.c: make version strings
			visible as extern char _lib[fi]77_version_f2c[].
	5 July 2001: modify uninit.c for __mc68k__ under Linux.
	16 Nov. 2001: uninit.c: Linux Power PC logic supplied by Alan Bain.
	18 Jan. 2002: fix glitches in qbit_bits(): wrong return type,
			missing ~ on y in return value.
	14 March 2002: z_log.c: add code to cope with buggy compilers
			(e.g., some versions of gcc under -O2 or -O3)
			that do floating-point comparisons against values
			computed into extended-precision registers on some
			systems (such as Intel IA32 systems).  Compile with
			-DNO_DOUBLE_EXTENDED to omit the new logic.
	4 Oct. 2002: uninit.c: on IRIX systems, omit use of shell variables.
	10 Oct 2005: uninit.c: on IA32 Linux systems, leave the rounding
			precision alone rather than forcing it to 53 bits;
			compile with -DUNINIT_F2C_PRECISION_53 to get the
			former behavior.
*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/fio.h0000644000175100001710000000557300000000000022561 0ustar00runnerdocker00000000000000#ifndef SYSDEP_H_INCLUDED
#include "sysdep1.h"
#endif
#include "stdio.h"
#include "errno.h"
#ifndef NULL
/* ANSI C */
#include "stddef.h"
#endif

#ifndef SEEK_SET
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#endif

#ifndef FOPEN
#define FOPEN fopen
#endif

#ifndef FREOPEN
#define FREOPEN freopen
#endif

#ifndef FSEEK
#define FSEEK fseek
#endif

#ifndef FSTAT
#define FSTAT fstat
#endif

#ifndef FTELL
#define FTELL ftell
#endif

#ifndef OFF_T
#define OFF_T long
#endif

#ifndef STAT_ST
#define STAT_ST stat
#endif

#ifndef STAT
#define STAT stat
#endif

#ifdef MSDOS
#ifndef NON_UNIX_STDIO
#define NON_UNIX_STDIO
#endif
#endif

#ifdef UIOLEN_int
typedef int uiolen;
#else
typedef long uiolen;
#endif

/*units*/
typedef struct
{	FILE *ufd;	/*0=unconnected*/
	char *ufnm;
#ifndef MSDOS
	long uinode;
	int udev;
#endif
	int url;	/*0=sequential*/
	flag useek;	/*true=can backspace, use dir, ...*/
	flag ufmt;
	flag urw;	/* (1 for can read) | (2 for can write) */
	flag ublnk;
	flag uend;
	flag uwrt;	/*last io was write*/
	flag uscrtch;
} unit;

#undef Void
#ifdef KR_headers
#define Void /*void*/
extern int (*f__getn)();	/* for formatted input */
extern void (*f__putn)();	/* for formatted output */
extern void x_putc();
extern long f__inode();
extern VOID sig_die();
extern int (*f__donewrec)(), t_putc(), x_wSL();
extern int c_sfe(), err__fl(), xrd_SL(), f__putbuf();
#else
#define Void void
#ifdef __cplusplus
extern "C" {
#endif
extern int (*f__getn)(void);	/* for formatted input */
extern void (*f__putn)(int);	/* for formatted output */
extern void x_putc(int);
extern long f__inode(char*,int*);
extern void sig_die(const char*,int);
extern void f__fatal(int, const char*);
extern int t_runc(alist*);
extern int f__nowreading(unit*), f__nowwriting(unit*);
extern int fk_open(int,int,ftnint);
extern int en_fio(void);
extern void f_init(void);
extern int (*f__donewrec)(void), t_putc(int), x_wSL(void);
extern void b_char(const char*,char*,ftnlen), g_char(const char*,ftnlen,char*);
extern int c_sfe(cilist*), z_rnew(void);
extern int err__fl(int,int,const char*);
extern int xrd_SL(void);
extern int f__putbuf(int);
#endif
extern flag f__init;
extern cilist *f__elist;	/*active external io list*/
extern flag f__reading,f__external,f__sequential,f__formatted;
extern int (*f__doend)(Void);
extern FILE *f__cf;	/*current file*/
extern unit *f__curunit;	/*current unit*/
extern unit f__units[];
#define err(f,m,s) {if(f) errno= m; else f__fatal(m,s); return(m);}
#define errfl(f,m,s) return err__fl((int)f,m,s)

/*Table sizes*/
#define MXUNIT 100

extern int f__recpos;	/*position in current record*/
extern OFF_T f__cursor;	/* offset to move to */
extern OFF_T f__hiwater;	/* so TL doesn't confuse us */
#ifdef __cplusplus
	}
#endif

#define WRITE	1
#define READ	2
#define SEQ	3
#define DIR	4
#define FMT	5
#define UNF	6
#define EXT	7
#define INT	8

#define buf_end(x) (x->_flag & _IONBF ? x->_ptr : x->_base + BUFSIZ)
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/fmt.c0000644000175100001710000002056600000000000022564 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif
#define skip(s) while(*s==' ') s++
#ifdef interdata
#define SYLMX 300
#endif
#ifdef pdp11
#define SYLMX 300
#endif
#ifdef vax
#define SYLMX 300
#endif
#ifndef SYLMX
#define SYLMX 300
#endif
#define GLITCH '\2'
	/* special quote character for stu */
extern flag f__cblank,f__cplus;	/*blanks in I and compulsory plus*/
static struct syl f__syl[SYLMX];
int f__parenlvl,f__pc,f__revloc;
#ifdef KR_headers
#define Const /*nothing*/
#else
#define Const const
#endif

 static
#ifdef KR_headers
char *ap_end(s) char *s;
#else
const char *ap_end(const char *s)
#endif
{	char quote;
	quote= *s++;
	for(;*s;s++)
	{	if(*s!=quote) continue;
		if(*++s!=quote) return(s);
	}
	if(f__elist->cierr) {
		errno = 100;
		return(NULL);
	}
	f__fatal(100, "bad string");
	/*NOTREACHED*/ return 0;
}
 static int
#ifdef KR_headers
op_gen(a,b,c,d)
#else
op_gen(int a, int b, int c, int d)
#endif
{	struct syl *p= &f__syl[f__pc];
	if(f__pc>=SYLMX)
	{	fprintf(stderr,"format too complicated:\n");
		sig_die(f__fmtbuf, 1);
	}
	p->op=a;
	p->p1=b;
	p->p2.i[0]=c;
	p->p2.i[1]=d;
	return(f__pc++);
}
#ifdef KR_headers
static char *f_list();
static char *gt_num(s,n,n1) char *s; int *n, n1;
#else
static const char *f_list(const char*);
static const char *gt_num(const char *s, int *n, int n1)
#endif
{	int m=0,f__cnt=0;
	char c;
	for(c= *s;;c = *s)
	{	if(c==' ')
		{	s++;
			continue;
		}
		if(c>'9' || c<'0') break;
		m=10*m+c-'0';
		f__cnt++;
		s++;
	}
	if(f__cnt==0) {
		if (!n1)
			s = 0;
		*n=n1;
		}
	else *n=m;
	return(s);
}

 static
#ifdef KR_headers
char *f_s(s,curloc) char *s;
#else
const char *f_s(const char *s, int curloc)
#endif
{
	skip(s);
	if(*s++!='(')
	{
		return(NULL);
	}
	if(f__parenlvl++ ==1) f__revloc=curloc;
	if(op_gen(RET1,curloc,0,0)<0 ||
		(s=f_list(s))==NULL)
	{
		return(NULL);
	}
	skip(s);
	return(s);
}

 static int
#ifdef KR_headers
ne_d(s,p) char *s,**p;
#else
ne_d(const char *s, const char **p)
#endif
{	int n,x,sign=0;
	struct syl *sp;
	switch(*s)
	{
	default:
		return(0);
	case ':': (void) op_gen(COLON,0,0,0); break;
	case '$':
		(void) op_gen(NONL, 0, 0, 0); break;
	case 'B':
	case 'b':
		if(*++s=='z' || *s == 'Z') (void) op_gen(BZ,0,0,0);
		else (void) op_gen(BN,0,0,0);
		break;
	case 'S':
	case 's':
		if(*(s+1)=='s' || *(s+1) == 'S')
		{	x=SS;
			s++;
		}
		else if(*(s+1)=='p' || *(s+1) == 'P')
		{	x=SP;
			s++;
		}
		else x=S;
		(void) op_gen(x,0,0,0);
		break;
	case '/': (void) op_gen(SLASH,0,0,0); break;
	case '-': sign=1;
	case '+':	s++;	/*OUTRAGEOUS CODING TRICK*/
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		if (!(s=gt_num(s,&n,0))) {
 bad:			*p = 0;
			return 1;
			}
		switch(*s)
		{
		default:
			return(0);
		case 'P':
		case 'p': if(sign) n= -n; (void) op_gen(P,n,0,0); break;
		case 'X':
		case 'x': (void) op_gen(X,n,0,0); break;
		case 'H':
		case 'h':
			sp = &f__syl[op_gen(H,n,0,0)];
			sp->p2.s = (char*)s + 1;
			s+=n;
			break;
		}
		break;
	case GLITCH:
	case '"':
	case '\'':
		sp = &f__syl[op_gen(APOS,0,0,0)];
		sp->p2.s = (char*)s;
		if((*p = ap_end(s)) == NULL)
			return(0);
		return(1);
	case 'T':
	case 't':
		if(*(s+1)=='l' || *(s+1) == 'L')
		{	x=TL;
			s++;
		}
		else if(*(s+1)=='r'|| *(s+1) == 'R')
		{	x=TR;
			s++;
		}
		else x=T;
		if (!(s=gt_num(s+1,&n,0)))
			goto bad;
		s--;
		(void) op_gen(x,n,0,0);
		break;
	case 'X':
	case 'x': (void) op_gen(X,1,0,0); break;
	case 'P':
	case 'p': (void) op_gen(P,1,0,0); break;
	}
	s++;
	*p=s;
	return(1);
}

 static int
#ifdef KR_headers
e_d(s,p) char *s,**p;
#else
e_d(const char *s, const char **p)
#endif
{	int i,im,n,w,d,e,found=0,x=0;
	Const char *sv=s;
	s=gt_num(s,&n,1);
	(void) op_gen(STACK,n,0,0);
	switch(*s++)
	{
	default: break;
	case 'E':
	case 'e':	x=1;
	case 'G':
	case 'g':
		found=1;
		if (!(s=gt_num(s,&w,0))) {
 bad:
			*p = 0;
			return 1;
			}
		if(w==0) break;
		if(*s=='.') {
			if (!(s=gt_num(s+1,&d,0)))
				goto bad;
			}
		else d=0;
		if(*s!='E' && *s != 'e')
			(void) op_gen(x==1?E:G,w,d,0);	/* default is Ew.dE2 */
		else {
			if (!(s=gt_num(s+1,&e,0)))
				goto bad;
			(void) op_gen(x==1?EE:GE,w,d,e);
			}
		break;
	case 'O':
	case 'o':
		i = O;
		im = OM;
		goto finish_I;
	case 'Z':
	case 'z':
		i = Z;
		im = ZM;
		goto finish_I;
	case 'L':
	case 'l':
		found=1;
		if (!(s=gt_num(s,&w,0)))
			goto bad;
		if(w==0) break;
		(void) op_gen(L,w,0,0);
		break;
	case 'A':
	case 'a':
		found=1;
		skip(s);
		if(*s>='0' && *s<='9')
		{	s=gt_num(s,&w,1);
			if(w==0) break;
			(void) op_gen(AW,w,0,0);
			break;
		}
		(void) op_gen(A,0,0,0);
		break;
	case 'F':
	case 'f':
		if (!(s=gt_num(s,&w,0)))
			goto bad;
		found=1;
		if(w==0) break;
		if(*s=='.') {
			if (!(s=gt_num(s+1,&d,0)))
				goto bad;
			}
		else d=0;
		(void) op_gen(F,w,d,0);
		break;
	case 'D':
	case 'd':
		found=1;
		if (!(s=gt_num(s,&w,0)))
			goto bad;
		if(w==0) break;
		if(*s=='.') {
			if (!(s=gt_num(s+1,&d,0)))
				goto bad;
			}
		else d=0;
		(void) op_gen(D,w,d,0);
		break;
	case 'I':
	case 'i':
		i = I;
		im = IM;
 finish_I:
		if (!(s=gt_num(s,&w,0)))
			goto bad;
		found=1;
		if(w==0) break;
		if(*s!='.')
		{	(void) op_gen(i,w,0,0);
			break;
		}
		if (!(s=gt_num(s+1,&d,0)))
			goto bad;
		(void) op_gen(im,w,d,0);
		break;
	}
	if(found==0)
	{	f__pc--; /*unSTACK*/
		*p=sv;
		return(0);
	}
	*p=s;
	return(1);
}
 static
#ifdef KR_headers
char *i_tem(s) char *s;
#else
const char *i_tem(const char *s)
#endif
{	const char *t;
	int n,curloc;
	if(*s==')') return(s);
	if(ne_d(s,&t)) return(t);
	if(e_d(s,&t)) return(t);
	s=gt_num(s,&n,1);
	if((curloc=op_gen(STACK,n,0,0))<0) return(NULL);
	return(f_s(s,curloc));
}

 static
#ifdef KR_headers
char *f_list(s) char *s;
#else
const char *f_list(const char *s)
#endif
{
	for(;*s!=0;)
	{	skip(s);
		if((s=i_tem(s))==NULL) return(NULL);
		skip(s);
		if(*s==',') s++;
		else if(*s==')')
		{	if(--f__parenlvl==0)
			{
				(void) op_gen(REVERT,f__revloc,0,0);
				return(++s);
			}
			(void) op_gen(GOTO,0,0,0);
			return(++s);
		}
	}
	return(NULL);
}

 int
#ifdef KR_headers
pars_f(s) char *s;
#else
pars_f(const char *s)
#endif
{
	f__parenlvl=f__revloc=f__pc=0;
	if(f_s(s,0) == NULL)
	{
		return(-1);
	}
	return(0);
}
#define STKSZ 10
int f__cnt[STKSZ],f__ret[STKSZ],f__cp,f__rp;
flag f__workdone, f__nonl;

 static int
#ifdef KR_headers
type_f(n)
#else
type_f(int n)
#endif
{
	switch(n)
	{
	default:
		return(n);
	case RET1:
		return(RET1);
	case REVERT: return(REVERT);
	case GOTO: return(GOTO);
	case STACK: return(STACK);
	case X:
	case SLASH:
	case APOS: case H:
	case T: case TL: case TR:
		return(NED);
	case F:
	case I:
	case IM:
	case A: case AW:
	case O: case OM:
	case L:
	case E: case EE: case D:
	case G: case GE:
	case Z: case ZM:
		return(ED);
	}
}
#ifdef KR_headers
integer do_fio(number,ptr,len) ftnint *number; ftnlen len; char *ptr;
#else
integer do_fio(ftnint *number, char *ptr, ftnlen len)
#endif
{	struct syl *p;
	int n,i;
	for(i=0;i<*number;i++,ptr+=len)
	{
loop:	switch(type_f((p= &f__syl[f__pc])->op))
	{
	default:
		fprintf(stderr,"unknown code in do_fio: %d\n%s\n",
			p->op,f__fmtbuf);
		err(f__elist->cierr,100,"do_fio");
	case NED:
		if((*f__doned)(p))
		{	f__pc++;
			goto loop;
		}
		f__pc++;
		continue;
	case ED:
		if(f__cnt[f__cp]<=0)
		{	f__cp--;
			f__pc++;
			goto loop;
		}
		if(ptr==NULL)
			return((*f__doend)());
		f__cnt[f__cp]--;
		f__workdone=1;
		if((n=(*f__doed)(p,ptr,len))>0)
			errfl(f__elist->cierr,errno,"fmt");
		if(n<0)
			err(f__elist->ciend,(EOF),"fmt");
		continue;
	case STACK:
		f__cnt[++f__cp]=p->p1;
		f__pc++;
		goto loop;
	case RET1:
		f__ret[++f__rp]=p->p1;
		f__pc++;
		goto loop;
	case GOTO:
		if(--f__cnt[f__cp]<=0)
		{	f__cp--;
			f__rp--;
			f__pc++;
			goto loop;
		}
		f__pc=1+f__ret[f__rp--];
		goto loop;
	case REVERT:
		f__rp=f__cp=0;
		f__pc = p->p1;
		if(ptr==NULL)
			return((*f__doend)());
		if(!f__workdone) return(0);
		if((n=(*f__dorevert)()) != 0) return(n);
		goto loop;
	case COLON:
		if(ptr==NULL)
			return((*f__doend)());
		f__pc++;
		goto loop;
	case NONL:
		f__nonl = 1;
		f__pc++;
		goto loop;
	case S:
	case SS:
		f__cplus=0;
		f__pc++;
		goto loop;
	case SP:
		f__cplus = 1;
		f__pc++;
		goto loop;
	case P:	f__scale=p->p1;
		f__pc++;
		goto loop;
	case BN:
		f__cblank=0;
		f__pc++;
		goto loop;
	case BZ:
		f__cblank=1;
		f__pc++;
		goto loop;
	}
	}
	return(0);
}

 int
en_fio(Void)
{	ftnint one=1;
	return(do_fio(&one,(char *)NULL,(ftnint)0));
}

 VOID
fmt_bg(Void)
{
	f__workdone=f__cp=f__rp=f__pc=f__cursor=0;
	f__cnt[0]=f__ret[0]=0;
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/fmt.h0000644000175100001710000000372600000000000022570 0ustar00runnerdocker00000000000000struct syl
{	int op;
	int p1;
	union { int i[2]; char *s;} p2;
	};
#define RET1 1
#define REVERT 2
#define GOTO 3
#define X 4
#define SLASH 5
#define STACK 6
#define I 7
#define ED 8
#define NED 9
#define IM 10
#define APOS 11
#define H 12
#define TL 13
#define TR 14
#define T 15
#define COLON 16
#define S 17
#define SP 18
#define SS 19
#define P 20
#define BN 21
#define BZ 22
#define F 23
#define E 24
#define EE 25
#define D 26
#define G 27
#define GE 28
#define L 29
#define A 30
#define AW 31
#define O 32
#define NONL 33
#define OM 34
#define Z 35
#define ZM 36
typedef union
{	real pf;
	doublereal pd;
} ufloat;
typedef union
{	short is;
#ifndef KR_headers
	signed
#endif
		char ic;
	integer il;
#ifdef Allow_TYQUAD
	longint ili;
#endif
} Uint;
#ifdef KR_headers
extern int (*f__doed)(),(*f__doned)();
extern int (*f__dorevert)();
extern int rd_ed(),rd_ned();
extern int w_ed(),w_ned();
extern int signbit_f2c();
extern char *f__fmtbuf;
#else
#ifdef __cplusplus
extern "C" {
#define Cextern extern "C"
#else
#define Cextern extern
#endif
extern const char *f__fmtbuf;
extern int (*f__doed)(struct syl*, char*, ftnlen),(*f__doned)(struct syl*);
extern int (*f__dorevert)(void);
extern void fmt_bg(void);
extern int pars_f(const char*);
extern int rd_ed(struct syl*, char*, ftnlen),rd_ned(struct syl*);
extern int signbit_f2c(double*);
extern int w_ed(struct syl*, char*, ftnlen),w_ned(struct syl*);
extern int wrt_E(ufloat*, int, int, int, ftnlen);
extern int wrt_F(ufloat*, int, int, ftnlen);
extern int wrt_L(Uint*, int, ftnlen);
#endif
extern int f__pc,f__parenlvl,f__revloc;
extern flag f__cblank,f__cplus,f__workdone, f__nonl;
extern int f__scale;
#ifdef __cplusplus
	}
#endif
#define GET(x) if((x=(*f__getn)())<0) return(x)
#define VAL(x) (x!='\n'?x:' ')
#define PUT(x) (*f__putn)(x)

#undef TYQUAD
#ifndef Allow_TYQUAD
#undef longint
#define longint long
#else
#define TYQUAD 14
#endif

#ifdef KR_headers
extern char *f__icvt();
#else
Cextern char *f__icvt(longint, int*, int*, int);
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/fmtlib.c0000644000175100001710000000154100000000000023243 0ustar00runnerdocker00000000000000/*	@(#)fmtlib.c	1.2	*/
#define MAXINTLENGTH 23

#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef Allow_TYQUAD
#undef longint
#define longint long
#undef ulongint
#define ulongint unsigned long
#endif

#ifdef KR_headers
char *f__icvt(value,ndigit,sign, base) longint value; int *ndigit,*sign;
 register int base;
#else
char *f__icvt(longint value, int *ndigit, int *sign, int base)
#endif
{
	static char buf[MAXINTLENGTH+1];
	register int i;
	ulongint uvalue;

	if(value > 0) {
		uvalue = value;
		*sign = 0;
		}
	else if (value < 0) {
		uvalue = -value;
		*sign = 1;
		}
	else {
		*sign = 0;
		*ndigit = 1;
		buf[MAXINTLENGTH-1] = '0';
		return &buf[MAXINTLENGTH-1];
		}
	i = MAXINTLENGTH;
	do {
		buf[--i] = (uvalue%base) + '0';
		uvalue /= base;
		}
		while(uvalue > 0);
	*ndigit = MAXINTLENGTH - i;
	return &buf[i];
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/fp.h0000644000175100001710000000123100000000000022374 0ustar00runnerdocker00000000000000#define FMAX 40
#define EXPMAXDIGS 8
#define EXPMAX 99999999
/* FMAX = max number of nonzero digits passed to atof() */
/* EXPMAX = 10^EXPMAXDIGS - 1 = largest allowed exponent absolute value */

#ifdef V10 /* Research Tenth-Edition Unix */
#include "local.h"
#endif

/* MAXFRACDIGS and MAXINTDIGS are for wrt_F -- bounds (not necessarily
   tight) on the maximum number of digits to the right and left of
 * the decimal point.
 */

#ifdef VAX
#define MAXFRACDIGS 56
#define MAXINTDIGS 38
#else
#ifdef CRAY
#define MAXFRACDIGS 9880
#define MAXINTDIGS 9864
#else
/* values that suffice for IEEE double */
#define MAXFRACDIGS 344
#define MAXINTDIGS 308
#endif
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/ftell_.c0000644000175100001710000000160400000000000023233 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif

 static FILE *
#ifdef KR_headers
unit_chk(Unit, who) integer Unit; char *who;
#else
unit_chk(integer Unit, const char *who)
#endif
{
	if (Unit >= MXUNIT || Unit < 0)
		f__fatal(101, who);
	return f__units[Unit].ufd;
	}

 integer
#ifdef KR_headers
ftell_(Unit) integer *Unit;
#else
ftell_(integer *Unit)
#endif
{
	FILE *f;
	return (f = unit_chk(*Unit, "ftell")) ? ftell(f) : -1L;
	}

 int
#ifdef KR_headers
fseek_(Unit, offset, whence) integer *Unit, *offset, *whence;
#else
fseek_(integer *Unit, integer *offset, integer *whence)
#endif
{
	FILE *f;
	int w = (int)*whence;
#ifdef SEEK_SET
	static int wohin[3] = { SEEK_SET, SEEK_CUR, SEEK_END };
#endif
	if (w < 0 || w > 2)
		w = 0;
#ifdef SEEK_SET
	w = wohin[w];
#endif
	return	!(f = unit_chk(*Unit, "fseek"))
		|| fseek(f, *offset, w) ? 1 : 0;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/getarg_.c0000644000175100001710000000112000000000000023367 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

/*
 * subroutine getarg(k, c)
 * returns the kth unix command argument in fortran character
 * variable argument c
*/

#ifdef KR_headers
VOID getarg_(n, s, ls) ftnint *n; char *s; ftnlen ls;
#define Const /*nothing*/
#else
#define Const const
void getarg_(ftnint *n, char *s, ftnlen ls)
#endif
{
	extern int xargc;
	extern char **xargv;
	Const char *t;
	int i;
	
	if(*n>=0 && *n
#include 
#ifdef __cplusplus
extern "C" {
#endif
extern char *F77_aloc(ftnlen, const char*);
#endif

/*
 * getenv - f77 subroutine to return environment variables
 *
 * called by:
 *	call getenv (ENV_NAME, char_var)
 * where:
 *	ENV_NAME is the name of an environment variable
 *	char_var is a character variable which will receive
 *		the current value of ENV_NAME, or all blanks
 *		if ENV_NAME is not defined
 */

#ifdef KR_headers
 VOID
getenv_(fname, value, flen, vlen) char *value, *fname; ftnlen vlen, flen;
#else
 void
getenv_(char *fname, char *value, ftnlen flen, ftnlen vlen)
#endif
{
	char buf[256], *ep, *fp;
	integer i;

	if (flen <= 0)
		goto add_blanks;
	for(i = 0; i < sizeof(buf); i++) {
		if (i == flen || (buf[i] = fname[i]) == ' ') {
			buf[i] = 0;
			ep = getenv(buf);
			goto have_ep;
			}
		}
	while(i < flen && fname[i] != ' ')
		i++;
	strncpy(fp = F77_aloc(i+1, "getenv_"), fname, (int)i);
	fp[i] = 0;
	ep = getenv(fp);
	free(fp);
 have_ep:
	if (ep)
		while(*ep && vlen-- > 0)
			*value++ = *ep++;
 add_blanks:
	while(vlen-- > 0)
		*value++ = ' ';
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_abs.c0000644000175100001710000000033200000000000023037 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_abs(x) shortint *x;
#else
shortint h_abs(shortint *x)
#endif
{
if(*x >= 0)
	return(*x);
return(- *x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_dim.c0000644000175100001710000000034600000000000023050 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_dim(a,b) shortint *a, *b;
#else
shortint h_dim(shortint *a, shortint *b)
#endif
{
return( *a > *b ? *a - *b : 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_dnnt.c0000644000175100001710000000044600000000000023243 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
shortint h_dnnt(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
shortint h_dnnt(doublereal *x)
#endif
{
return (shortint)(*x >= 0. ? floor(*x + .5) : -floor(.5 - *x));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_indx.c0000644000175100001710000000067200000000000023243 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_indx(a, b, la, lb) char *a, *b; ftnlen la, lb;
#else
shortint h_indx(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
ftnlen i, n;
char *s, *t, *bend;

n = la - lb + 1;
bend = b + lb;

for(i = 0 ; i < n ; ++i)
	{
	s = a + i;
	t = b;
	while(t < bend)
		if(*s++ != *t++)
			goto no;
	return((shortint)i+1);
	no: ;
	}
return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_len.c0000644000175100001710000000031500000000000023051 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_len(s, n) char *s; ftnlen n;
#else
shortint h_len(char *s, ftnlen n)
#endif
{
return(n);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_mod.c0000644000175100001710000000031700000000000023054 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_mod(a,b) short *a, *b;
#else
shortint h_mod(short *a, short *b)
#endif
{
return( *a % *b);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_nint.c0000644000175100001710000000043100000000000023242 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
shortint h_nint(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
shortint h_nint(real *x)
#endif
{
return (shortint)(*x >= 0 ? floor(*x + .5) : -floor(.5 - *x));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/h_sign.c0000644000175100001710000000041200000000000023231 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint h_sign(a,b) shortint *a, *b;
#else
shortint h_sign(shortint *a, shortint *b)
#endif
{
shortint x;
x = (*a >= 0 ? *a : - *a);
return( *b >= 0 ? x : -x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/hl_ge.c0000644000175100001710000000053200000000000023043 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
shortlogical hl_ge(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
shortlogical hl_ge(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) >= 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/hl_gt.c0000644000175100001710000000053100000000000023061 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
shortlogical hl_gt(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
shortlogical hl_gt(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) > 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/hl_le.c0000644000175100001710000000053200000000000023050 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
shortlogical hl_le(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
shortlogical hl_le(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) <= 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/hl_lt.c0000644000175100001710000000053100000000000023066 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
shortlogical hl_lt(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
shortlogical hl_lt(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) < 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i77vers.c0000644000175100001710000004332000000000000023275 0ustar00runnerdocker00000000000000 char
_libi77_version_f2c[] = "\n@(#) LIBI77 VERSION (f2c) pjw,dmg-mods 20030321\n";

/*
2.01	$ format added
2.02	Coding bug in open.c repaired
2.03	fixed bugs in lread.c (read * with negative f-format) and lio.c
	and lio.h (e-format conforming to spec)
2.04	changed open.c and err.c (fopen and freopen respectively) to
	update to new c-library (append mode)
2.05	added namelist capability
2.06	allow internal list and namelist I/O
*/

/*
close.c:
	allow upper-case STATUS= values
endfile.c
	create fort.nnn if unit nnn not open;
	else if (file length == 0) use creat() rather than copy;
	use local copy() rather than forking /bin/cp;
	rewind, fseek to clear buffer (for no reading past EOF)
err.c
	use neither setbuf nor setvbuf; make stderr buffered
fio.h
	#define _bufend
inquire.c
	upper case responses;
	omit byfile test from SEQUENTIAL=
	answer "YES" to DIRECT= for unopened file (open to debate)
lio.c
	flush stderr, stdout at end of each stmt
	space before character strings in list output only at line start
lio.h
	adjust LEW, LED consistent with old libI77
lread.c
	use atof()
	allow "nnn*," when reading complex constants
open.c
	try opening for writing when open for read fails, with
	special uwrt value (2) delaying creat() to first write;
	set curunit so error messages don't drop core;
	no file name ==> fort.nnn except for STATUS='SCRATCH'
rdfmt.c
	use atof(); trust EOF == end-of-file (so don't read past
	end-of-file after endfile stmt)
sfe.c
	flush stderr, stdout at end of each stmt
wrtfmt.c:
	use upper case
	put wrt_E and wrt_F into wref.c, use sprintf()
		rather than ecvt() and fcvt() [more accurate on VAX]
*/

/* 16 Oct. 1988: uwrt = 3 after write, rewind, so close won't zap the file. */

/* 10 July 1989: change _bufend to buf_end in fio.h, wsfe.c, wrtfmt.c */

/* 28 Nov. 1989: corrections for IEEE and Cray arithmetic */
/* 29 Nov. 1989: change various int return types to long for f2c */
/* 30 Nov. 1989: various types from f2c.h */
/*  6 Dec. 1989: types corrected various places */
/* 19 Dec. 1989: make iostat= work right for internal I/O */
/*  8 Jan. 1990: add rsne, wsne -- routines for handling NAMELIST */
/* 28 Jan. 1990: have NAMELIST read treat $ as &, general white
		 space as blank */
/* 27 Mar. 1990: change an = to == in rd_L(rdfmt.c) so formatted reads
		 of logical values reject letters other than fFtT;
		 have nowwriting reset cf */
/* 14 Aug. 1990: adjust lread.c to treat tabs as spaces in list input */
/* 17 Aug. 1990: adjust open.c to recognize blank='Z...' as well as
		 blank='z...' when reopening an open file */
/* 30 Aug. 1990: prevent embedded blanks in list output of complex values;
		 omit exponent field in list output of values of
		 magnitude between 10 and 1e8; prevent writing stdin
		 and reading stdout or stderr; don't close stdin, stdout,
		 or stderr when reopening units 5, 6, 0. */
/* 18 Sep. 1990: add component udev to unit and consider old == new file
		 iff uinode and udev values agree; use stat rather than
		 access to check existence of file (when STATUS='OLD')*/
/* 2 Oct. 1990:  adjust rewind.c so two successive rewinds after a write
		 don't clobber the file. */
/* 9 Oct. 1990:  add #include "fcntl.h" to endfile.c, err.c, open.c;
		 adjust g_char in util.c for segmented memories. */
/* 17 Oct. 1990: replace abort() and _cleanup() with calls on
		 sig_die(...,1) (defined in main.c). */
/* 5 Nov. 1990:  changes to open.c: complain if new= is specified and the
		 file already exists; allow file= to be omitted in open stmts
		 and allow status='replace' (Fortran 90 extensions). */
/* 11 Dec. 1990: adjustments for POSIX. */
/* 15 Jan. 1991: tweak i_ungetc in rsli.c to allow reading from
		 strings in read-only memory. */
/* 25 Apr. 1991: adjust namelist stuff to work with f2c -i2 */
/* 26 Apr. 1991: fix some bugs with NAMELIST read of multi-dim. arrays */
/* 16 May 1991:  increase LEFBL in lio.h to bypass NeXT bug */
/* 17 Oct. 1991: change type of length field in sequential unformatted
		 records from int to long (for systems where sizeof(int)
		 can vary, depending on the compiler or compiler options). */
/* 14 Nov. 1991: change uint to Uint in fmt.h, rdfmt.c, wrtfmt.c. */
/* 25 Nov. 1991: change uint to Uint in lwrite.c; change sizeof(int) to
		 sizeof(uioint) in fseeks in sue.c (missed on 17 Oct.). */
/* 1 Dec. 1991:  uio.c: add test for read failure (seq. unformatted reads);
		 adjust an error return from EOF to off end of record */
/* 12 Dec. 1991: rsli.c: fix bug with internal list input that caused
		 the last character of each record to be ignored.
		 iio.c: adjust error message in internal formatted
		 input from "end-of-file" to "off end of record" if
		 the format specifies more characters than the
		 record contains. */
/* 17 Jan. 1992: lread.c, rsne.c: in list and namelist input,
		 treat "r* ," and "r*," alike (where r is a
		 positive integer constant), and fix a bug in
		 handling null values following items with repeat
		 counts (e.g., 2*1,,3); for namelist reading
		 of a numeric array, allow a new name-value subsequence
		 to terminate the current one (as though the current
		 one ended with the right number of null values).
		 lio.h, lwrite.c: omit insignificant zeros in
		 list and namelist output. To get the old
		 behavior, compile with -DOld_list_output . */
/* 18 Jan. 1992: make list output consistent with F format by
		 printing .1 rather than 0.1 (introduced yesterday). */
/* 3 Feb. 1992:  rsne.c: fix namelist read bug that caused the
		 character following a comma to be ignored. */
/* 19 May 1992:  adjust iio.c, ilnw.c, rdfmt.c and rsli.c to make err=
		 work with internal list and formatted I/O. */
/* 18 July 1992: adjust rsne.c to allow namelist input to stop at
		 an & (e.g. &end). */
/* 23 July 1992: switch to ANSI prototypes unless KR_headers is #defined ;
		 recognize Z format (assuming 8-bit bytes). */
/* 14 Aug. 1992: tweak wrt_E in wref.c to avoid -NaN */
/* 23 Oct. 1992: Supply missing l_eof = 0 assignment to s_rsne() in rsne.c
		 (so end-of-file on other files won't confuse namelist
		 reads of external files).  Prepend f__ to external
		 names that are only of internal interest to lib[FI]77. */
/* 1 Feb. 1993:  backspace.c: fix bug that bit when last char of 2nd
		 buffer == '\n'.
		 endfile.c: guard against tiny L_tmpnam; close and reopen
		 files in t_runc().
		 lio.h: lengthen LINTW (buffer size in lwrite.c).
		 err.c, open.c: more prepending of f__ (to [rw]_mode). */
/* 5 Feb. 1993:  tweaks to NAMELIST: rsne.c: ? prints the namelist being
		 sought; namelists of the wrong name are skipped (after
		 an error message; xwsne.c: namelist writes have a
		 newline before each new variable.
		 open.c: ACCESS='APPEND' positions sequential files
		 at EOF (nonstandard extension -- that doesn't require
		 changing data structures). */
/* 9 Feb. 1993:  Change some #ifdef MSDOS lines to #ifdef NON_UNIX_STDIO.
		 err.c: under NON_UNIX_STDIO, avoid close(creat(name,0666))
		 when the unit has another file descriptor for name. */
/* 4 March 1993: err.c, open.c: take declaration of fdopen from rawio.h;
		 open.c: always give f__w_mode[] 4 elements for use
		 in t_runc (in endfile.c -- for change of 1 Feb. 1993). */
/* 6 March 1993: uio.c: adjust off-end-of-record test for sequential
		 unformatted reads to respond to err= rather than end=. */
/* 12 March 1993: various tweaks for C++ */
/* 6 April 1993: adjust error returns for formatted inputs to flush
		 the current input line when err=label is specified.
		 To restore the old behavior (input left mid-line),
		 either adjust the #definition of errfl in fio.h or
		 omit the invocation of f__doend in err__fl (in err.c).	*/
/* 23 June 1993: iio.c: fix bug in format reversions for internal writes. */
/* 5 Aug. 1993:  lread.c: fix bug in handling repetition counts for
		 logical data (during list or namelist input).
		 Change struct f__syl to struct syl (for buggy compilers). */
/* 7 Aug. 1993:  lread.c: fix bug in namelist reading of incomplete
		 logical arrays. */
/* 9 Aug. 1993:  lread.c: fix bug in namelist reading of an incomplete
		 array of numeric data followed by another namelist
		 item whose name starts with 'd', 'D', 'e', or 'E'. */
/* 8 Sept. 1993: open.c: protect #include "sys/..." with
		 #ifndef NON_UNIX_STDIO; Version date not changed. */
/* 10 Nov. 1993: backspace.c: add nonsense for #ifdef MSDOS */
/* 8 Dec. 1993:  iio.c: adjust internal formatted reads to treat
		 short records as though padded with blanks
		 (rather than causing an "off end of record" error). */
/* 22 Feb. 1994: lread.c: check that realloc did not return NULL. */
/* 6 June 1994:  Under NON_UNIX_STDIO, use binary mode for direct
		 formatted files (avoiding any confusion regarding \n). */
/* 5 July 1994:  Fix bug (introduced 6 June 1994?) in reopening files
		 under NON_UNIX_STDIO. */
/* 6 July 1994:  wref.c: protect with #ifdef GOOD_SPRINTF_EXPONENT an
		 optimization that requires exponents to have 2 digits
		 when 2 digits suffice.
		 lwrite.c wsfe.c (list and formatted external output):
		 omit ' ' carriage-control when compiled with
		 -DOMIT_BLANK_CC .  Off-by-one bug fixed in character
		 count for list output of character strings.
		 Omit '.' in list-directed printing of Nan, Infinity. */
/* 12 July 1994: wrtfmt.c: under G11.4, write 0. as "  .0000    " rather
		 than "  .0000E+00". */
/* 3 Aug. 1994:  lwrite.c: do not insert a newline when appending an
		 oversize item to an empty line. */
/* 12 Aug. 1994: rsli.c rsne.c: fix glitch (reset nml_read) that kept
		 ERR= (in list- or format-directed input) from working
		 after a NAMELIST READ. */
/* 7 Sept. 1994: typesize.c: adjust to allow types LOGICAL*1, LOGICAL*2,
		 INTEGER*1, and (under -DAllow_TYQUAD) INTEGER*8
		 in NAMELISTs. */
/* 6 Oct. 1994:  util.c: omit f__mvgbt, as it is never used. */
/* 2 Nov. 1994:  add #ifdef ALWAYS_FLUSH logic. */
/* 26 Jan. 1995: wref.c: fix glitch in printing the exponent of 0 when
		 GOOD_SPRINTF_EXPONENT is not #defined. */
/* 24 Feb. 1995: iio.c: z_getc: insert (unsigned char *) to allow
		 internal reading of characters with high-bit set
		 (on machines that sign-extend characters). */
/* 14 March 1995:lread.c and rsfe.c: adjust s_rsle and s_rsfe to
		 check for end-of-file (to prevent infinite loops
		 with empty read statements). */
/* 26 May 1995:  iio.c: z_wnew: fix bug in handling T format items
		 in internal writes whose last item is written to
		 an earlier position than some previous item. */
/* 29 Aug. 1995: backspace.c: adjust MSDOS logic. */
/* 6 Sept. 1995: Adjust namelist input to treat a subscripted name
		 whose subscripts do not involve colons similarly
		 to the name without a subscript: accept several
		 values, stored in successive elements starting at
		 the indicated subscript.  Adjust namelist output
		 to quote character strings (avoiding confusion with
		 arrays of character strings).  Adjust f_init calls
		 for people who don't use libF77's main(); now open and
		 namelist read statements invoke f_init if needed. */
/* 7 Sept. 1995: Fix some bugs with -DAllow_TYQUAD (for integer*8).
		 Add -DNo_Namelist_Comments lines to rsne.c. */
/* 5 Oct. 1995:  wrtfmt.c: fix bug with t editing (f__cursor was not
		 always zeroed in mv_cur). */
/* 11 Oct. 1995: move defs of f__hiwater, f__svic, f__icptr from wrtfmt.c
		 to err.c */
/* 15 Mar. 1996: lread.c, rsfe.c: honor END= in READ stmt with empty iolist */

/* 13 May 1996:  add ftell_.c and fseek_.c */
/* 9 June 1996:  Adjust rsli.c and lread.c so internal list input with
		 too few items in the input string will honor end= . */
/* 12 Sept. 1995:fmtlib.c: fix glitch in printing the most negative integer. */
/* 25 Sept. 1995:fmt.h: for formatted writes of negative integer*1 values,
		 make ic signed on ANSI systems.  If formatted writes of
		 integer*1 values trouble you when using a K&R C compiler,
		 switch to an ANSI compiler or use a compiler flag that
		 makes characters signed. */
/* 9 Dec. 1996:	 d[fu]e.c, err.c: complain about non-positive rec=
		 in direct read and write statements.
		 ftell_.c: change param "unit" to "Unit" for -DKR_headers. */
/* 26 Feb. 1997: ftell_.c: on systems that define SEEK_SET, etc., use
		 SEEK_SET, SEEK_CUR, SEEK_END for *whence = 0, 1, 2. */
/* 7 Apr. 1997:	 fmt.c: adjust to complain at missing numbers in formats
		 (but still treat missing ".nnn" as ".0"). */
/* 11 Apr. 1997: err.c: attempt to make stderr line buffered rather
		 than fully buffered.  (Buffering is needed for format
		 items T and TR.) */
/* 27 May 1997:  ftell_.c: fix typo (that caused the third argument to be
		 treated as 2 on some systems). */
/* 5 Aug. 1997:  lread.c: adjust to accord with a change to the Fortran 8X
		 draft (in 1990 or 1991) that rescinded permission to elide
		 quote marks in namelist input of character data; compile
		 with -DF8X_NML_ELIDE_QUOTES to get the old behavior.
		 wrtfmt.o: wrt_G: tweak to print the right number of 0's
		 for zero under G format. */
/* 16 Aug. 1997: iio.c: fix bug in internal writes to an array of character
		 strings that sometimes caused one more array element than
		 required by the format to be blank-filled.  Example:
		 format(1x). */
/* 16 Sept. 1997:fmt.[ch] rdfmt.c wrtfmt.c: tweak struct syl for machines
		 with 64-bit pointers and 32-bit ints that did not 64-bit
		 align struct syl (e.g., Linux on the DEC Alpha). */
/* 19 Jan. 1998: backspace.c: for b->ufmt==0, change sizeof(int) to
		 sizeof(uiolen).  On machines where this would make a
		 difference, it is best for portability to compile libI77 with
		 -DUIOLEN_int (which will render the change invisible). */
/* 4 March 1998: open.c: fix glitch in comparing file names under
		-DNON_UNIX_STDIO */
/* 17 March 1998: endfile.c, open.c: acquire temporary files from tmpfile(),
		 unless compiled with -DNON_ANSI_STDIO, which uses mktemp().
		 New buffering scheme independent of NON_UNIX_STDIO for
		 handling T format items.  Now -DNON_UNIX_STDIO is no
		 longer be necessary for Linux, and libf2c no longer
		 causes stderr to be buffered -- the former setbuf or
		 setvbuf call for stderr was to make T format items work.
		 open.c: use the Posix access() function to check existence
		 or nonexistence of files, except under -DNON_POSIX_STDIO,
		 where trial fopen calls are used. */
/* 5 April 1998: wsfe.c: make $ format item work: this was lost in the
		 changes of 17 March 1998. */
/* 28 May 1998:	 backspace.c dfe.c due.c iio.c lread.c rsfe.c sue.c wsfe.c:
		 set f__curunit sooner so various error messages will
		 correctly identify the I/O unit involved. */
/* 17 June 1998: lread.c: unless compiled with
		 ALLOW_FLOAT_IN_INTEGER_LIST_INPUT #defined, treat
		 floating-point numbers (containing either a decimal point
		 or an exponent field) as errors when they appear as list
		 input for integer data. */
/* 7 Sept. 1998: move e_wdfe from sfe.c to dfe.c, where it was originally.
		 Why did it ever move to sfe.c? */
/* 2 May 1999:	 open.c: set f__external (to get "external" versus "internal"
		 right in the error message if we cannot open the file).
		 err.c: cast a pointer difference to (int) for %d.
		 rdfmt.c: omit fixed-length buffer that could be overwritten
		 by formats Inn or Lnn with nn > 83. */
/* 3 May 1999:	open.c: insert two casts for machines with 64-bit longs. */
/* 18 June 1999: backspace.c: allow for b->ufd changing in t_runc */
/* 27 June 1999: rsne.c: fix bug in namelist input: a misplaced increment */
/*		 could cause wrong array elements to be assigned; e.g.,	*/
/*		 "&input k(5)=10*1 &end" assigned k(5) and k(15..23)	*/
/* 15 Nov. 1999: endfile.c: set state to writing (b->uwrt = 1) when an */
/*		endfile statement requires copying the file. */
/*		(Otherwise an immediately following rewind statement */
/*		could make the file appear empty.)  Also, supply a */
/*		missing (long) cast in the sprintf call. */
/*		 sfe.c: add #ifdef ALWAYS_FLUSH logic, for formatted I/O: */
/*		Compiling libf2c with -DALWAYS_FLUSH should prevent losing */
/*		any data in buffers should the program fault.  It also */
/*		makes the program run more slowly. */
/* 20 April 2000: rsne.c, xwsne.c: tweaks that only matter if ftnint and */
/*		ftnlen are of different fundamental types (different numbers */
/*		of bits).  Since these files will not compile when this */
/*		change matters, the above VERSION string remains unchanged. */
/* 4 July 2000: adjustments to permit compilation by C++ compilers; */
/*		VERSION string remains unchanged. */
/* 5 Dec. 2000: lread.c: under namelist input, when reading a logical array, */
/*		treat Tstuff= and Fstuff= as new assignments rather than as */
/*		logical constants. */
/* 22 Feb. 2001: endfile.c: adjust to use truncate() unless compiled with */
/*		-DNO_TRUNCATE (or with -DMSDOS). */
/* 1 March 2001: endfile.c:  switch to ftruncate (absent -DNO_TRUNCATE), */
/*		thus permitting truncation of scratch files on true Unix */
/*		systems, where scratch files have no name.  Add an fflush() */
/*		(surprisingly) needed on some Linux systems. */
/* 11 Oct. 2001: backspac.c dfe.c due.c endfile.c err.c fio.h fmt.c fmt.h */
/*		inquire.c open.c rdfmt.c sue.c util.c: change fseek and */
/*		ftell to FSEEK and FTELL (#defined to be fseek and ftell, */
/*		respectively, in fio.h unless otherwise #defined), and use */
/*		type OFF_T (#defined to be long unless otherwise #defined) */
/*		to permit handling files over 2GB long where possible, */
/*		with suitable -D options, provided for some systems in new */
/*		header file sysdep1.h (copied from sysdep1.h0 by default). */
/* 15 Nov. 2001: endfile.c: add FSEEK after FTRUNCATE. */
/* 28 Nov. 2001: fmt.h lwrite.c wref.c and (new) signbit.c: on IEEE systems, */
/*		print -0 as -0 when compiled with -DSIGNED_ZEROS.  See */
/*		comments in makefile or (better) libf2c/makefile.* . */
/* 6 Sept. 2002: rsne.c: fix bug with multiple repeat counts in reading */
/*		namelists, e.g., &nl a(2) = 3*1.0, 2*2.0, 3*3.0 /  */
/* 21 March 2003: err.c: before writing to a file after reading from it, */
/*		f_seek(file, 0, SEEK_CUR) to make writing legal in ANSI C. */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_abs.c0000644000175100001710000000032600000000000023043 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_abs(x) integer *x;
#else
integer i_abs(integer *x)
#endif
{
if(*x >= 0)
	return(*x);
return(- *x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_dim.c0000644000175100001710000000034100000000000023044 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_dim(a,b) integer *a, *b;
#else
integer i_dim(integer *a, integer *b)
#endif
{
return( *a > *b ? *a - *b : 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_dnnt.c0000644000175100001710000000044300000000000023241 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
integer i_dnnt(x) doublereal *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
integer i_dnnt(doublereal *x)
#endif
{
return (integer)(*x >= 0. ? floor(*x + .5) : -floor(.5 - *x));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_indx.c0000644000175100001710000000065600000000000023246 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_indx(a, b, la, lb) char *a, *b; ftnlen la, lb;
#else
integer i_indx(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
ftnlen i, n;
char *s, *t, *bend;

n = la - lb + 1;
bend = b + lb;

for(i = 0 ; i < n ; ++i)
	{
	s = a + i;
	t = b;
	while(t < bend)
		if(*s++ != *t++)
			goto no;
	return(i+1);
	no: ;
	}
return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_len.c0000644000175100001710000000031300000000000023050 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_len(s, n) char *s; ftnlen n;
#else
integer i_len(char *s, ftnlen n)
#endif
{
return(n);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_mod.c0000644000175100001710000000032300000000000023052 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_mod(a,b) integer *a, *b;
#else
integer i_mod(integer *a, integer *b)
#endif
{
return( *a % *b);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_nint.c0000644000175100001710000000042600000000000023247 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
integer i_nint(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
integer i_nint(real *x)
#endif
{
return (integer)(*x >= 0 ? floor(*x + .5) : -floor(.5 - *x));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/i_sign.c0000644000175100001710000000040400000000000023233 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer i_sign(a,b) integer *a, *b;
#else
integer i_sign(integer *a, integer *b)
#endif
{
integer x;
x = (*a >= 0 ? *a : - *a);
return( *b >= 0 ? x : -x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/iargc_.c0000644000175100001710000000030400000000000023206 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
ftnint iargc_()
#else
ftnint iargc_(void)
#endif
{
extern int xargc;
return ( xargc - 1 );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/iio.c0000644000175100001710000000511700000000000022551 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif
extern char *f__icptr;
char *f__icend;
extern icilist *f__svic;
int f__icnum;

 int
z_getc(Void)
{
	if(f__recpos++ < f__svic->icirlen) {
		if(f__icptr >= f__icend) err(f__svic->iciend,(EOF),"endfile");
		return(*(unsigned char *)f__icptr++);
		}
	return '\n';
}

 void
#ifdef KR_headers
z_putc(c)
#else
z_putc(int c)
#endif
{
	if (f__icptr < f__icend && f__recpos++ < f__svic->icirlen)
		*f__icptr++ = c;
}

 int
z_rnew(Void)
{
	f__icptr = f__svic->iciunit + (++f__icnum)*f__svic->icirlen;
	f__recpos = 0;
	f__cursor = 0;
	f__hiwater = 0;
	return 1;
}

 static int
z_endp(Void)
{
	(*f__donewrec)();
	return 0;
	}

 int
#ifdef KR_headers
c_si(a) icilist *a;
#else
c_si(icilist *a)
#endif
{
	f__elist = (cilist *)a;
	f__fmtbuf=a->icifmt;
	f__curunit = 0;
	f__sequential=f__formatted=1;
	f__external=0;
	if(pars_f(f__fmtbuf)<0)
		err(a->icierr,100,"startint");
	fmt_bg();
	f__cblank=f__cplus=f__scale=0;
	f__svic=a;
	f__icnum=f__recpos=0;
	f__cursor = 0;
	f__hiwater = 0;
	f__icptr = a->iciunit;
	f__icend = f__icptr + a->icirlen*a->icirnum;
	f__cf = 0;
	return(0);
}

 int
iw_rev(Void)
{
	if(f__workdone)
		z_endp();
	f__hiwater = f__recpos = f__cursor = 0;
	return(f__workdone=0);
	}

#ifdef KR_headers
integer s_rsfi(a) icilist *a;
#else
integer s_rsfi(icilist *a)
#endif
{	int n;
	if(n=c_si(a)) return(n);
	f__reading=1;
	f__doed=rd_ed;
	f__doned=rd_ned;
	f__getn=z_getc;
	f__dorevert = z_endp;
	f__donewrec = z_rnew;
	f__doend = z_endp;
	return(0);
}

 int
z_wnew(Void)
{
	if (f__recpos < f__hiwater) {
		f__icptr += f__hiwater - f__recpos;
		f__recpos = f__hiwater;
		}
	while(f__recpos++ < f__svic->icirlen)
		*f__icptr++ = ' ';
	f__recpos = 0;
	f__cursor = 0;
	f__hiwater = 0;
	f__icnum++;
	return 1;
}
#ifdef KR_headers
integer s_wsfi(a) icilist *a;
#else
integer s_wsfi(icilist *a)
#endif
{	int n;
	if(n=c_si(a)) return(n);
	f__reading=0;
	f__doed=w_ed;
	f__doned=w_ned;
	f__putn=z_putc;
	f__dorevert = iw_rev;
	f__donewrec = z_wnew;
	f__doend = z_endp;
	return(0);
}
integer e_rsfi(Void)
{	int n = en_fio();
	f__fmtbuf = NULL;
	return(n);
}
integer e_wsfi(Void)
{
	int n;
	n = en_fio();
	f__fmtbuf = NULL;
	if(f__svic->icirnum != 1
	 && (f__icnum >  f__svic->icirnum
	 || (f__icnum == f__svic->icirnum && (f__recpos | f__hiwater))))
		err(f__svic->icierr,110,"inwrite");
	if (f__recpos < f__hiwater)
		f__recpos = f__hiwater;
	if (f__recpos >= f__svic->icirlen)
		err(f__svic->icierr,110,"recend");
	if (!f__recpos && f__icnum)
		return n;
	while(f__recpos++ < f__svic->icirlen)
		*f__icptr++ = ' ';
	return n;
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/ilnw.c0000644000175100001710000000214500000000000022740 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "lio.h"
#ifdef __cplusplus
extern "C" {
#endif
extern char *f__icptr;
extern char *f__icend;
extern icilist *f__svic;
extern int f__icnum;
#ifdef KR_headers
extern void z_putc();
#else
extern void z_putc(int);
#endif

 static int
z_wSL(Void)
{
	while(f__recpos < f__svic->icirlen)
		z_putc(' ');
	return z_rnew();
	}

 static void
#ifdef KR_headers
c_liw(a) icilist *a;
#else
c_liw(icilist *a)
#endif
{
	f__reading = 0;
	f__external = 0;
	f__formatted = 1;
	f__putn = z_putc;
	L_len = a->icirlen;
	f__donewrec = z_wSL;
	f__svic = a;
	f__icnum = f__recpos = 0;
	f__cursor = 0;
	f__cf = 0;
	f__curunit = 0;
	f__icptr = a->iciunit;
	f__icend = f__icptr + a->icirlen*a->icirnum;
	f__elist = (cilist *)a;
	}

 integer
#ifdef KR_headers
s_wsni(a) icilist *a;
#else
s_wsni(icilist *a)
#endif
{
	cilist ca;

	c_liw(a);
	ca.cifmt = a->icifmt;
	x_wsne(&ca);
	z_wSL();
	return 0;
	}

 integer
#ifdef KR_headers
s_wsli(a) icilist *a;
#else
s_wsli(icilist *a)
#endif
{
	f__lioproc = l_write;
	c_liw(a);
	return(0);
	}

integer e_wsli(Void)
{
	z_wSL();
	return(0);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/inquire.c0000644000175100001710000000525400000000000023447 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "string.h"
#ifdef NON_UNIX_STDIO
#ifndef MSDOS
#include "unistd.h" /* for access() */
#endif
#endif
#ifdef KR_headers
integer f_inqu(a) inlist *a;
#else
#ifdef __cplusplus
extern "C" integer f_inqu(inlist*);
#endif
#ifdef MSDOS
#undef abs
#undef min
#undef max
#include "io.h"
#endif
integer f_inqu(inlist *a)
#endif
{	flag byfile;
	int i;
#ifndef NON_UNIX_STDIO
	int n;
#endif
	unit *p;
	char buf[256];
	long x;
	if(a->infile!=NULL)
	{	byfile=1;
		g_char(a->infile,a->infilen,buf);
#ifdef NON_UNIX_STDIO
		x = access(buf,0) ? -1 : 0;
		for(i=0,p=NULL;iinunitinunit>=0)
		{
			p= &f__units[a->inunit];
		}
		else
		{
			p=NULL;
		}
	}
	if(a->inex!=NULL)
		if(byfile && x != -1 || !byfile && p!=NULL)
			*a->inex=1;
		else *a->inex=0;
	if(a->inopen!=NULL)
		if(byfile) *a->inopen=(p!=NULL);
		else *a->inopen=(p!=NULL && p->ufd!=NULL);
	if(a->innum!=NULL) *a->innum= p-f__units;
	if(a->innamed!=NULL)
		if(byfile || p!=NULL && p->ufnm!=NULL)
			*a->innamed=1;
		else	*a->innamed=0;
	if(a->inname!=NULL)
		if(byfile)
			b_char(buf,a->inname,a->innamlen);
		else if(p!=NULL && p->ufnm!=NULL)
			b_char(p->ufnm,a->inname,a->innamlen);
	if(a->inacc!=NULL && p!=NULL && p->ufd!=NULL)
		if(p->url)
			b_char("DIRECT",a->inacc,a->inacclen);
		else	b_char("SEQUENTIAL",a->inacc,a->inacclen);
	if(a->inseq!=NULL)
		if(p!=NULL && p->url)
			b_char("NO",a->inseq,a->inseqlen);
		else	b_char("YES",a->inseq,a->inseqlen);
	if(a->indir!=NULL)
		if(p==NULL || p->url)
			b_char("YES",a->indir,a->indirlen);
		else	b_char("NO",a->indir,a->indirlen);
	if(a->infmt!=NULL)
		if(p!=NULL && p->ufmt==0)
			b_char("UNFORMATTED",a->infmt,a->infmtlen);
		else	b_char("FORMATTED",a->infmt,a->infmtlen);
	if(a->inform!=NULL)
		if(p!=NULL && p->ufmt==0)
		b_char("NO",a->inform,a->informlen);
		else b_char("YES",a->inform,a->informlen);
	if(a->inunf)
		if(p!=NULL && p->ufmt==0)
			b_char("YES",a->inunf,a->inunflen);
		else if (p!=NULL) b_char("NO",a->inunf,a->inunflen);
		else b_char("UNKNOWN",a->inunf,a->inunflen);
	if(a->inrecl!=NULL && p!=NULL)
		*a->inrecl=p->url;
	if(a->innrec!=NULL && p!=NULL && p->url>0)
		*a->innrec=(ftnint)(FTELL(p->ufd)/p->url+1);
	if(a->inblank && p!=NULL && p->ufmt)
		if(p->ublnk)
			b_char("ZERO",a->inblank,a->inblanklen);
		else	b_char("NULL",a->inblank,a->inblanklen);
	return(0);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/l_ge.c0000644000175100001710000000051600000000000022675 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
logical l_ge(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
logical l_ge(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) >= 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/l_gt.c0000644000175100001710000000051500000000000022713 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
logical l_gt(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
logical l_gt(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) > 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/l_le.c0000644000175100001710000000051600000000000022702 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
logical l_le(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
logical l_le(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) <= 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/l_lt.c0000644000175100001710000000051500000000000022720 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern integer s_cmp();
logical l_lt(a,b,la,lb) char *a, *b; ftnlen la, lb;
#else
extern integer s_cmp(char *, char *, ftnlen, ftnlen);
logical l_lt(char *a, char *b, ftnlen la, ftnlen lb)
#endif
{
return(s_cmp(a,b,la,lb) < 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/lbitbits.c0000644000175100001710000000211100000000000023574 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifndef LONGBITS
#define LONGBITS 32
#endif

 integer
#ifdef KR_headers
lbit_bits(a, b, len) integer a, b, len;
#else
lbit_bits(integer a, integer b, integer len)
#endif
{
	/* Assume 2's complement arithmetic */

	unsigned long x, y;

	x = (unsigned long) a;
	y = (unsigned long)-1L;
	x >>= b;
	y <<= len;
	return (integer)(x & ~y);
	}

 integer
#ifdef KR_headers
lbit_cshift(a, b, len) integer a, b, len;
#else
lbit_cshift(integer a, integer b, integer len)
#endif
{
	unsigned long x, y, z;

	x = (unsigned long)a;
	if (len <= 0) {
		if (len == 0)
			return 0;
		goto full_len;
		}
	if (len >= LONGBITS) {
 full_len:
		if (b >= 0) {
			b %= LONGBITS;
			return (integer)(x << b | x >> LONGBITS -b );
			}
		b = -b;
		b %= LONGBITS;
		return (integer)(x << LONGBITS - b | x >> b);
		}
	y = z = (unsigned long)-1;
	y <<= len;
	z &= ~y;
	y &= x;
	x &= z;
	if (b >= 0) {
		b %= len;
		return (integer)(y | z & (x << b | x >> len - b));
		}
	b = -b;
	b %= len;
	return (integer)(y | z & (x >> b | x << len - b));
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/lbitshft.c0000644000175100001710000000040200000000000023600 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

 integer
#ifdef KR_headers
lbit_shift(a, b) integer a; integer b;
#else
lbit_shift(integer a, integer b)
#endif
{
	return b >= 0 ? a << b : (integer)((uinteger)a >> -b);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/libf2c.lbc0000644000175100001710000000307200000000000023446 0ustar00runnerdocker00000000000000abort_.obj
backspac.obj
c_abs.obj
c_cos.obj
c_div.obj
c_exp.obj
c_log.obj
c_sin.obj
c_sqrt.obj
cabs.obj
close.obj
d_abs.obj
d_acos.obj
d_asin.obj
d_atan.obj
d_atn2.obj
d_cnjg.obj
d_cos.obj
d_cosh.obj
d_dim.obj
d_exp.obj
d_imag.obj
d_int.obj
d_lg10.obj
d_log.obj
d_mod.obj
d_nint.obj
d_prod.obj
d_sign.obj
d_sin.obj
d_sinh.obj
d_sqrt.obj
d_tan.obj
d_tanh.obj
derf_.obj
derfc_.obj
dfe.obj
dolio.obj
dtime_.obj
due.obj
ef1asc_.obj
ef1cmc_.obj
endfile.obj
erf_.obj
erfc_.obj
err.obj
etime_.obj
exit_.obj
f77_aloc.obj
f77vers.obj
fmt.obj
fmtlib.obj
ftell_.obj
getarg_.obj
getenv_.obj
h_abs.obj
h_dim.obj
h_dnnt.obj
h_indx.obj
h_len.obj
h_mod.obj
h_nint.obj
h_sign.obj
hl_ge.obj
hl_gt.obj
hl_le.obj
hl_lt.obj
i77vers.obj
i_abs.obj
i_dim.obj
i_dnnt.obj
i_indx.obj
i_len.obj
i_mod.obj
i_nint.obj
i_sign.obj
iargc_.obj
iio.obj
ilnw.obj
inquire.obj
l_ge.obj
l_gt.obj
l_le.obj
l_lt.obj
lbitbits.obj
lbitshft.obj
lread.obj
lwrite.obj
main.obj
open.obj
pow_ci.obj
pow_dd.obj
pow_di.obj
pow_hh.obj
pow_ii.obj
pow_ri.obj
pow_zi.obj
pow_zz.obj
r_abs.obj
r_acos.obj
r_asin.obj
r_atan.obj
r_atn2.obj
r_cnjg.obj
r_cos.obj
r_cosh.obj
r_dim.obj
r_exp.obj
r_imag.obj
r_int.obj
r_lg10.obj
r_log.obj
r_mod.obj
r_nint.obj
r_sign.obj
r_sin.obj
r_sinh.obj
r_sqrt.obj
r_tan.obj
r_tanh.obj
rdfmt.obj
rewind.obj
rsfe.obj
rsli.obj
rsne.obj
s_cat.obj
s_cmp.obj
s_copy.obj
s_paus.obj
s_rnge.obj
s_stop.obj
sfe.obj
sig_die.obj
signal_.obj
sue.obj
system_.obj
typesize.obj
uio.obj
uninit.obj
util.obj
wref.obj
wrtfmt.obj
wsfe.obj
wsle.obj
wsne.obj
xwsne.obj
z_abs.obj
z_cos.obj
z_div.obj
z_exp.obj
z_log.obj
z_sin.obj
z_sqrt.obj
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/libf2c.sy0000644000175100001710000000400300000000000023334 0ustar00runnerdocker00000000000000+abort_.obj &
+backspac.obj &
+c_abs.obj &
+c_cos.obj &
+c_div.obj &
+c_exp.obj &
+c_log.obj &
+c_sin.obj &
+c_sqrt.obj &
+cabs.obj &
+close.obj &
+d_abs.obj &
+d_acos.obj &
+d_asin.obj &
+d_atan.obj &
+d_atn2.obj &
+d_cnjg.obj &
+d_cos.obj &
+d_cosh.obj &
+d_dim.obj &
+d_exp.obj &
+d_imag.obj &
+d_int.obj &
+d_lg10.obj &
+d_log.obj &
+d_mod.obj &
+d_nint.obj &
+d_prod.obj &
+d_sign.obj &
+d_sin.obj &
+d_sinh.obj &
+d_sqrt.obj &
+d_tan.obj &
+d_tanh.obj &
+derf_.obj &
+derfc_.obj &
+dfe.obj &
+dolio.obj &
+dtime_.obj &
+due.obj &
+ef1asc_.obj &
+ef1cmc_.obj &
+endfile.obj &
+erf_.obj &
+erfc_.obj &
+err.obj &
+etime_.obj &
+exit_.obj &
+f77_aloc.obj &
+f77vers.obj &
+fmt.obj &
+fmtlib.obj &
+ftell_.obj &
+getarg_.obj &
+getenv_.obj &
+h_abs.obj &
+h_dim.obj &
+h_dnnt.obj &
+h_indx.obj &
+h_len.obj &
+h_mod.obj &
+h_nint.obj &
+h_sign.obj &
+hl_ge.obj &
+hl_gt.obj &
+hl_le.obj &
+hl_lt.obj &
+i77vers.obj &
+i_abs.obj &
+i_dim.obj &
+i_dnnt.obj &
+i_indx.obj &
+i_len.obj &
+i_mod.obj &
+i_nint.obj &
+i_sign.obj &
+iargc_.obj &
+iio.obj &
+ilnw.obj &
+inquire.obj &
+l_ge.obj &
+l_gt.obj &
+l_le.obj &
+l_lt.obj &
+lbitbits.obj &
+lbitshft.obj &
+lread.obj &
+lwrite.obj &
+main.obj &
+open.obj &
+pow_ci.obj &
+pow_dd.obj &
+pow_di.obj &
+pow_hh.obj &
+pow_ii.obj &
+pow_ri.obj &
+pow_zi.obj &
+pow_zz.obj &
+r_abs.obj &
+r_acos.obj &
+r_asin.obj &
+r_atan.obj &
+r_atn2.obj &
+r_cnjg.obj &
+r_cos.obj &
+r_cosh.obj &
+r_dim.obj &
+r_exp.obj &
+r_imag.obj &
+r_int.obj &
+r_lg10.obj &
+r_log.obj &
+r_mod.obj &
+r_nint.obj &
+r_sign.obj &
+r_sin.obj &
+r_sinh.obj &
+r_sqrt.obj &
+r_tan.obj &
+r_tanh.obj &
+rdfmt.obj &
+rewind.obj &
+rsfe.obj &
+rsli.obj &
+rsne.obj &
+s_cat.obj &
+s_cmp.obj &
+s_copy.obj &
+s_paus.obj &
+s_rnge.obj &
+s_stop.obj &
+sfe.obj &
+sig_die.obj &
+signal_.obj &
+sue.obj &
+system_.obj &
+typesize.obj &
+uio.obj &
+uninit.obj &
+util.obj &
+wref.obj &
+wrtfmt.obj &
+wsfe.obj &
+wsle.obj &
+wsne.obj &
+xwsne.obj &
+z_abs.obj &
+z_cos.obj &
+z_div.obj &
+z_exp.obj &
+z_log.obj &
+z_sin.obj &
+z_sqrt.obj
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/lio.h0000644000175100001710000000303400000000000022555 0ustar00runnerdocker00000000000000/*	copy of ftypes from the compiler */
/* variable types
 * numeric assumptions:
 *	int < reals < complexes
 *	TYDREAL-TYREAL = TYDCOMPLEX-TYCOMPLEX
 */

/* 0-10 retain their old (pre LOGICAL*1, etc.) */
/* values to allow mixing old and new objects. */

#define TYUNKNOWN 0
#define TYADDR 1
#define TYSHORT 2
#define TYLONG 3
#define TYREAL 4
#define TYDREAL 5
#define TYCOMPLEX 6
#define TYDCOMPLEX 7
#define TYLOGICAL 8
#define TYCHAR 9
#define TYSUBR 10
#define TYINT1 11
#define TYLOGICAL1 12
#define TYLOGICAL2 13
#ifdef Allow_TYQUAD
#undef TYQUAD
#define TYQUAD 14
#endif

#define	LINTW	24
#define	LINE	80
#define	LLOGW	2
#ifdef Old_list_output
#define	LLOW	1.0
#define	LHIGH	1.e9
#define	LEFMT	" %# .8E"
#define	LFFMT	" %# .9g"
#else
#define	LGFMT	"%.9G"
#endif
/* LEFBL 20 should suffice; 24 overcomes a NeXT bug. */
#define	LEFBL	24

typedef union
{
	char	flchar;
	short	flshort;
	ftnint	flint;
#ifdef Allow_TYQUAD
	longint fllongint;
#endif
	real	flreal;
	doublereal	fldouble;
} flex;
#ifdef KR_headers
extern int (*f__lioproc)(), (*l_getc)(), (*l_ungetc)();
extern int l_read(), l_write();
#else
#ifdef __cplusplus
extern "C" {
#endif
extern int (*f__lioproc)(ftnint*, char*, ftnlen, ftnint);
extern int l_write(ftnint*, char*, ftnlen, ftnint);
extern void x_wsne(cilist*);
extern int c_le(cilist*), (*l_getc)(void), (*l_ungetc)(int,FILE*);
extern int l_read(ftnint*,char*,ftnlen,ftnint);
extern integer e_rsle(void), e_wsle(void), s_wsne(cilist*);
extern int z_rnew(void);
#endif
extern ftnint L_len;
extern int f__scale;
#ifdef __cplusplus
	}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/lread.c0000644000175100001710000003445300000000000023065 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include 

/* Compile with -DF8X_NML_ELIDE_QUOTES to permit eliding quotation */
/* marks in namelist input a la the Fortran 8X Draft published in  */
/* the May 1989 issue of Fortran Forum. */


#ifdef Allow_TYQUAD
static longint f__llx;
#endif

#ifdef KR_headers
extern double atof();
extern char *malloc(), *realloc();
int (*f__lioproc)(), (*l_getc)(), (*l_ungetc)();
#else
#undef abs
#undef min
#undef max
#include "stdlib.h"
#endif

#include "fmt.h"
#include "lio.h"
#include "ctype.h"
#include "fp.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern char *f__fmtbuf;
#else
extern const char *f__fmtbuf;
int (*f__lioproc)(ftnint*, char*, ftnlen, ftnint), (*l_getc)(void),
	(*l_ungetc)(int,FILE*);
#endif

int l_eof;

#define isblnk(x) (f__ltab[x+1]&B)
#define issep(x) (f__ltab[x+1]&SX)
#define isapos(x) (f__ltab[x+1]&AX)
#define isexp(x) (f__ltab[x+1]&EX)
#define issign(x) (f__ltab[x+1]&SG)
#define iswhit(x) (f__ltab[x+1]&WH)
#define SX 1
#define B 2
#define AX 4
#define EX 8
#define SG 16
#define WH 32
char f__ltab[128+1] = {	/* offset one for EOF */
	0,
	0,0,AX,0,0,0,0,0,0,WH|B,SX|WH,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	SX|B|WH,0,AX,0,0,0,0,AX,0,0,0,SG,SX,SG,0,SX,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,EX,EX,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	AX,0,0,0,EX,EX,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};

#ifdef ungetc
 static int
#ifdef KR_headers
un_getc(x,f__cf) int x; FILE *f__cf;
#else
un_getc(int x, FILE *f__cf)
#endif
{ return ungetc(x,f__cf); }
#else
#define un_getc ungetc
#endif

 int
t_getc(Void)
{	int ch;
	if(f__curunit->uend) return(EOF);
	if((ch=getc(f__cf))!=EOF) return(ch);
	if(feof(f__cf))
		f__curunit->uend = l_eof = 1;
	return(EOF);
}
integer e_rsle(Void)
{
	int ch;
	if(f__curunit->uend) return(0);
	while((ch=t_getc())!='\n')
		if (ch == EOF) {
			if(feof(f__cf))
				f__curunit->uend = l_eof = 1;
			return EOF;
			}
	return(0);
}

flag f__lquit;
int f__lcount,f__ltype,nml_read;
char *f__lchar;
double f__lx,f__ly;
#define ERR(x) if(n=(x)) return(n)
#define GETC(x) (x=(*l_getc)())
#define Ungetc(x,y) (*l_ungetc)(x,y)

 static int
#ifdef KR_headers
l_R(poststar, reqint) int poststar, reqint;
#else
l_R(int poststar, int reqint)
#endif
{
	char s[FMAX+EXPMAXDIGS+4];
	register int ch;
	register char *sp, *spe, *sp1;
	long e, exp;
	int havenum, havestar, se;

	if (!poststar) {
		if (f__lcount > 0)
			return(0);
		f__lcount = 1;
		}
#ifdef Allow_TYQUAD
	f__llx = 0;
#endif
	f__ltype = 0;
	exp = 0;
	havestar = 0;
retry:
	sp1 = sp = s;
	spe = sp + FMAX;
	havenum = 0;

	switch(GETC(ch)) {
		case '-': *sp++ = ch; sp1++; spe++;
		case '+':
			GETC(ch);
		}
	while(ch == '0') {
		++havenum;
		GETC(ch);
		}
	while(isdigit(ch)) {
		if (sp < spe) *sp++ = ch;
		else ++exp;
		GETC(ch);
		}
	if (ch == '*' && !poststar) {
		if (sp == sp1 || exp || *s == '-') {
			errfl(f__elist->cierr,112,"bad repetition count");
			}
		poststar = havestar = 1;
		*sp = 0;
		f__lcount = atoi(s);
		goto retry;
		}
	if (ch == '.') {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
		if (reqint)
			errfl(f__elist->cierr,115,"invalid integer");
#endif
		GETC(ch);
		if (sp == sp1)
			while(ch == '0') {
				++havenum;
				--exp;
				GETC(ch);
				}
		while(isdigit(ch)) {
			if (sp < spe)
				{ *sp++ = ch; --exp; }
			GETC(ch);
			}
		}
	havenum += sp - sp1;
	se = 0;
	if (issign(ch))
		goto signonly;
	if (havenum && isexp(ch)) {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
		if (reqint)
			errfl(f__elist->cierr,115,"invalid integer");
#endif
		GETC(ch);
		if (issign(ch)) {
signonly:
			if (ch == '-') se = 1;
			GETC(ch);
			}
		if (!isdigit(ch)) {
bad:
			errfl(f__elist->cierr,112,"exponent field");
			}

		e = ch - '0';
		while(isdigit(GETC(ch))) {
			e = 10*e + ch - '0';
			if (e > EXPMAX)
				goto bad;
			}
		if (se)
			exp -= e;
		else
			exp += e;
		}
	(void) Ungetc(ch, f__cf);
	if (sp > sp1) {
		++havenum;
		while(*--sp == '0')
			++exp;
		if (exp)
			sprintf(sp+1, "e%ld", exp);
		else
			sp[1] = 0;
		f__lx = atof(s);
#ifdef Allow_TYQUAD
		if (reqint&2 && (se = sp - sp1 + exp) > 14 && se < 20) {
			/* Assuming 64-bit longint and 32-bit long. */
			if (exp < 0)
				sp += exp;
			if (sp1 <= sp) {
				f__llx = *sp1 - '0';
				while(++sp1 <= sp)
					f__llx = 10*f__llx + (*sp1 - '0');
				}
			while(--exp >= 0)
				f__llx *= 10;
			if (*s == '-')
				f__llx = -f__llx;
			}
#endif
		}
	else
		f__lx = 0.;
	if (havenum)
		f__ltype = TYLONG;
	else
		switch(ch) {
			case ',':
			case '/':
				break;
			default:
				if (havestar && ( ch == ' '
						||ch == '\t'
						||ch == '\n'))
					break;
				if (nml_read > 1) {
					f__lquit = 2;
					return 0;
					}
				errfl(f__elist->cierr,112,"invalid number");
			}
	return 0;
	}

 static int
#ifdef KR_headers
rd_count(ch) register int ch;
#else
rd_count(register int ch)
#endif
{
	if (ch < '0' || ch > '9')
		return 1;
	f__lcount = ch - '0';
	while(GETC(ch) >= '0' && ch <= '9')
		f__lcount = 10*f__lcount + ch - '0';
	Ungetc(ch,f__cf);
	return f__lcount <= 0;
	}

 static int
l_C(Void)
{	int ch, nml_save;
	double lz;
	if(f__lcount>0) return(0);
	f__ltype=0;
	GETC(ch);
	if(ch!='(')
	{
		if (nml_read > 1 && (ch < '0' || ch > '9')) {
			Ungetc(ch,f__cf);
			f__lquit = 2;
			return 0;
			}
		if (rd_count(ch))
			if(!f__cf || !feof(f__cf))
				errfl(f__elist->cierr,112,"complex format");
			else
				err(f__elist->cierr,(EOF),"lread");
		if(GETC(ch)!='*')
		{
			if(!f__cf || !feof(f__cf))
				errfl(f__elist->cierr,112,"no star");
			else
				err(f__elist->cierr,(EOF),"lread");
		}
		if(GETC(ch)!='(')
		{	Ungetc(ch,f__cf);
			return(0);
		}
	}
	else
		f__lcount = 1;
	while(iswhit(GETC(ch)));
	Ungetc(ch,f__cf);
	nml_save = nml_read;
	nml_read = 0;
	if (ch = l_R(1,0))
		return ch;
	if (!f__ltype)
		errfl(f__elist->cierr,112,"no real part");
	lz = f__lx;
	while(iswhit(GETC(ch)));
	if(ch!=',')
	{	(void) Ungetc(ch,f__cf);
		errfl(f__elist->cierr,112,"no comma");
	}
	while(iswhit(GETC(ch)));
	(void) Ungetc(ch,f__cf);
	if (ch = l_R(1,0))
		return ch;
	if (!f__ltype)
		errfl(f__elist->cierr,112,"no imaginary part");
	while(iswhit(GETC(ch)));
	if(ch!=')') errfl(f__elist->cierr,112,"no )");
	f__ly = f__lx;
	f__lx = lz;
#ifdef Allow_TYQUAD
	f__llx = 0;
#endif
	nml_read = nml_save;
	return(0);
}

 static char nmLbuf[256], *nmL_next;
 static int (*nmL_getc_save)(Void);
#ifdef KR_headers
 static int (*nmL_ungetc_save)(/* int, FILE* */);
#else
 static int (*nmL_ungetc_save)(int, FILE*);
#endif

 static int
nmL_getc(Void)
{
	int rv;
	if (rv = *nmL_next++)
		return rv;
	l_getc = nmL_getc_save;
	l_ungetc = nmL_ungetc_save;
	return (*l_getc)();
	}

 static int
#ifdef KR_headers
nmL_ungetc(x, f) int x; FILE *f;
#else
nmL_ungetc(int x, FILE *f)
#endif
{
	f = f;	/* banish non-use warning */
	return *--nmL_next = x;
	}

 static int
#ifdef KR_headers
Lfinish(ch, dot, rvp) int ch, dot, *rvp;
#else
Lfinish(int ch, int dot, int *rvp)
#endif
{
	char *s, *se;
	static char what[] = "namelist input";

	s = nmLbuf + 2;
	se = nmLbuf + sizeof(nmLbuf) - 1;
	*s++ = ch;
	while(!issep(GETC(ch)) && ch!=EOF) {
		if (s >= se) {
 nmLbuf_ovfl:
			return *rvp = err__fl(f__elist->cierr,131,what);
			}
		*s++ = ch;
		if (ch != '=')
			continue;
		if (dot)
			return *rvp = err__fl(f__elist->cierr,112,what);
 got_eq:
		*s = 0;
		nmL_getc_save = l_getc;
		l_getc = nmL_getc;
		nmL_ungetc_save = l_ungetc;
		l_ungetc = nmL_ungetc;
		nmLbuf[1] = *(nmL_next = nmLbuf) = ',';
		*rvp = f__lcount = 0;
		return 1;
		}
	if (dot)
		goto done;
	for(;;) {
		if (s >= se)
			goto nmLbuf_ovfl;
		*s++ = ch;
		if (!isblnk(ch))
			break;
		if (GETC(ch) == EOF)
			goto done;
		}
	if (ch == '=')
		goto got_eq;
 done:
	Ungetc(ch, f__cf);
	return 0;
	}

 static int
l_L(Void)
{
	int ch, rv, sawdot;

	if(f__lcount>0)
		return(0);
	f__lcount = 1;
	f__ltype=0;
	GETC(ch);
	if(isdigit(ch))
	{
		rd_count(ch);
		if(GETC(ch)!='*')
			if(!f__cf || !feof(f__cf))
				errfl(f__elist->cierr,112,"no star");
			else
				err(f__elist->cierr,(EOF),"lread");
		GETC(ch);
	}
	sawdot = 0;
	if(ch == '.') {
		sawdot = 1;
		GETC(ch);
		}
	switch(ch)
	{
	case 't':
	case 'T':
		if (nml_read && Lfinish(ch, sawdot, &rv))
			return rv;
		f__lx=1;
		break;
	case 'f':
	case 'F':
		if (nml_read && Lfinish(ch, sawdot, &rv))
			return rv;
		f__lx=0;
		break;
	default:
		if(isblnk(ch) || issep(ch) || ch==EOF)
		{	(void) Ungetc(ch,f__cf);
			return(0);
		}
		if (nml_read > 1) {
			Ungetc(ch,f__cf);
			f__lquit = 2;
			return 0;
			}
		errfl(f__elist->cierr,112,"logical");
	}
	f__ltype=TYLONG;
	while(!issep(GETC(ch)) && ch!=EOF);
	Ungetc(ch, f__cf);
	return(0);
}

#define BUFSIZE	128

 static int
l_CHAR(Void)
{	int ch,size,i;
	static char rafail[] = "realloc failure";
	char quote,*p;
	if(f__lcount>0) return(0);
	f__ltype=0;
	if(f__lchar!=NULL) free(f__lchar);
	size=BUFSIZE;
	p=f__lchar = (char *)malloc((unsigned int)size);
	if(f__lchar == NULL)
		errfl(f__elist->cierr,113,"no space");

	GETC(ch);
	if(isdigit(ch)) {
		/* allow Fortran 8x-style unquoted string...	*/
		/* either find a repetition count or the string	*/
		f__lcount = ch - '0';
		*p++ = ch;
		for(i = 1;;) {
			switch(GETC(ch)) {
				case '*':
					if (f__lcount == 0) {
						f__lcount = 1;
#ifndef F8X_NML_ELIDE_QUOTES
						if (nml_read)
							goto no_quote;
#endif
						goto noquote;
						}
					p = f__lchar;
					goto have_lcount;
				case ',':
				case ' ':
				case '\t':
				case '\n':
				case '/':
					Ungetc(ch,f__cf);
					/* no break */
				case EOF:
					f__lcount = 1;
					f__ltype = TYCHAR;
					return *p = 0;
				}
			if (!isdigit(ch)) {
				f__lcount = 1;
#ifndef F8X_NML_ELIDE_QUOTES
				if (nml_read) {
 no_quote:
					errfl(f__elist->cierr,112,
						"undelimited character string");
					}
#endif
				goto noquote;
				}
			*p++ = ch;
			f__lcount = 10*f__lcount + ch - '0';
			if (++i == size) {
				f__lchar = (char *)realloc(f__lchar,
					(unsigned int)(size += BUFSIZE));
				if(f__lchar == NULL)
					errfl(f__elist->cierr,113,rafail);
				p = f__lchar + i;
				}
			}
		}
	else	(void) Ungetc(ch,f__cf);
 have_lcount:
	if(GETC(ch)=='\'' || ch=='"') quote=ch;
	else if(isblnk(ch) || (issep(ch) && ch != '\n') || ch==EOF) {
		Ungetc(ch,f__cf);
		return 0;
		}
#ifndef F8X_NML_ELIDE_QUOTES
	else if (nml_read > 1) {
		Ungetc(ch,f__cf);
		f__lquit = 2;
		return 0;
		}
#endif
	else {
		/* Fortran 8x-style unquoted string */
		*p++ = ch;
		for(i = 1;;) {
			switch(GETC(ch)) {
				case ',':
				case ' ':
				case '\t':
				case '\n':
				case '/':
					Ungetc(ch,f__cf);
					/* no break */
				case EOF:
					f__ltype = TYCHAR;
					return *p = 0;
				}
 noquote:
			*p++ = ch;
			if (++i == size) {
				f__lchar = (char *)realloc(f__lchar,
					(unsigned int)(size += BUFSIZE));
				if(f__lchar == NULL)
					errfl(f__elist->cierr,113,rafail);
				p = f__lchar + i;
				}
			}
		}
	f__ltype=TYCHAR;
	for(i=0;;)
	{	while(GETC(ch)!=quote && ch!='\n'
			&& ch!=EOF && ++icierr,113,rafail);
			p=f__lchar+i-1;
			*p++ = ch;
		}
		else if(ch==EOF) return(EOF);
		else if(ch=='\n')
		{	if(*(p-1) != '\\') continue;
			i--;
			p--;
			if(++iciunit];
	if(a->ciunit>=MXUNIT || a->ciunit<0)
		err(a->cierr,101,"stler");
	f__scale=f__recpos=0;
	f__elist=a;
	if(f__curunit->ufd==NULL && fk_open(SEQ,FMT,a->ciunit))
		err(a->cierr,102,"lio");
	f__cf=f__curunit->ufd;
	if(!f__curunit->ufmt) err(a->cierr,103,"lio")
	return(0);
}

 int
#ifdef KR_headers
l_read(number,ptr,len,type) ftnint *number,type; char *ptr; ftnlen len;
#else
l_read(ftnint *number, char *ptr, ftnlen len, ftnint type)
#endif
{
#define Ptr ((flex *)ptr)
	int i,n,ch;
	doublereal *yy;
	real *xx;
	for(i=0;i<*number;i++)
	{
		if(f__lquit) return(0);
		if(l_eof)
			err(f__elist->ciend, EOF, "list in")
		if(f__lcount == 0) {
			f__ltype = 0;
			for(;;)  {
				GETC(ch);
				switch(ch) {
				case EOF:
					err(f__elist->ciend,(EOF),"list in")
				case ' ':
				case '\t':
				case '\n':
					continue;
				case '/':
					f__lquit = 1;
					goto loopend;
				case ',':
					f__lcount = 1;
					goto loopend;
				default:
					(void) Ungetc(ch, f__cf);
					goto rddata;
				}
			}
		}
	rddata:
		switch((int)type)
		{
		case TYINT1:
		case TYSHORT:
		case TYLONG:
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
			ERR(l_R(0,1));
			break;
#endif
		case TYREAL:
		case TYDREAL:
			ERR(l_R(0,0));
			break;
#ifdef TYQUAD
		case TYQUAD:
			n = l_R(0,2);
			if (n)
				return n;
			break;
#endif
		case TYCOMPLEX:
		case TYDCOMPLEX:
			ERR(l_C());
			break;
		case TYLOGICAL1:
		case TYLOGICAL2:
		case TYLOGICAL:
			ERR(l_L());
			break;
		case TYCHAR:
			ERR(l_CHAR());
			break;
		}
	while (GETC(ch) == ' ' || ch == '\t');
	if (ch != ',' || f__lcount > 1)
		Ungetc(ch,f__cf);
	loopend:
		if(f__lquit) return(0);
		if(f__cf && ferror(f__cf)) {
			clearerr(f__cf);
			errfl(f__elist->cierr,errno,"list in");
			}
		if(f__ltype==0) goto bump;
		switch((int)type)
		{
		case TYINT1:
		case TYLOGICAL1:
			Ptr->flchar = (char)f__lx;
			break;
		case TYLOGICAL2:
		case TYSHORT:
			Ptr->flshort = (short)f__lx;
			break;
		case TYLOGICAL:
		case TYLONG:
			Ptr->flint = (ftnint)f__lx;
			break;
#ifdef Allow_TYQUAD
		case TYQUAD:
			if (!(Ptr->fllongint = f__llx))
				Ptr->fllongint = f__lx;
			break;
#endif
		case TYREAL:
			Ptr->flreal=f__lx;
			break;
		case TYDREAL:
			Ptr->fldouble=f__lx;
			break;
		case TYCOMPLEX:
			xx=(real *)ptr;
			*xx++ = f__lx;
			*xx = f__ly;
			break;
		case TYDCOMPLEX:
			yy=(doublereal *)ptr;
			*yy++ = f__lx;
			*yy = f__ly;
			break;
		case TYCHAR:
			b_char(f__lchar,ptr,len);
			break;
		}
	bump:
		if(f__lcount>0) f__lcount--;
		ptr += len;
		if (nml_read)
			nml_read++;
	}
	return(0);
#undef Ptr
}
#ifdef KR_headers
integer s_rsle(a) cilist *a;
#else
integer s_rsle(cilist *a)
#endif
{
	int n;

	f__reading=1;
	f__external=1;
	f__formatted=1;
	if(n=c_le(a)) return(n);
	f__lioproc = l_read;
	f__lquit = 0;
	f__lcount = 0;
	l_eof = 0;
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr,errno,"read start");
	if(f__curunit->uend)
		err(f__elist->ciend,(EOF),"read start");
	l_getc = t_getc;
	l_ungetc = un_getc;
	f__doend = xrd_SL;
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/lwrite.c0000644000175100001710000001101000000000000023264 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#include "lio.h"
#ifdef __cplusplus
extern "C" {
#endif

ftnint L_len;
int f__Aquote;

 static VOID
donewrec(Void)
{
	if (f__recpos)
		(*f__donewrec)();
	}

 static VOID
#ifdef KR_headers
lwrt_I(n) longint n;
#else
lwrt_I(longint n)
#endif
{
	char *p;
	int ndigit, sign;

	p = f__icvt(n, &ndigit, &sign, 10);
	if(f__recpos + ndigit >= L_len)
		donewrec();
	PUT(' ');
	if (sign)
		PUT('-');
	while(*p)
		PUT(*p++);
}
 static VOID
#ifdef KR_headers
lwrt_L(n, len) ftnint n; ftnlen len;
#else
lwrt_L(ftnint n, ftnlen len)
#endif
{
	if(f__recpos+LLOGW>=L_len)
		donewrec();
	wrt_L((Uint *)&n,LLOGW, len);
}
 static VOID
#ifdef KR_headers
lwrt_A(p,len) char *p; ftnlen len;
#else
lwrt_A(char *p, ftnlen len)
#endif
{
	int a;
	char *p1, *pe;

	a = 0;
	pe = p + len;
	if (f__Aquote) {
		a = 3;
		if (len > 1 && p[len-1] == ' ') {
			while(--len > 1 && p[len-1] == ' ');
			pe = p + len;
			}
		p1 = p;
		while(p1 < pe)
			if (*p1++ == '\'')
				a++;
		}
	if(f__recpos+len+a >= L_len)
		donewrec();
	if (a
#ifndef OMIT_BLANK_CC
		|| !f__recpos
#endif
		)
		PUT(' ');
	if (a) {
		PUT('\'');
		while(p < pe) {
			if (*p == '\'')
				PUT('\'');
			PUT(*p++);
			}
		PUT('\'');
		}
	else
		while(p < pe)
			PUT(*p++);
}

 static int
#ifdef KR_headers
l_g(buf, n) char *buf; double n;
#else
l_g(char *buf, double n)
#endif
{
#ifdef Old_list_output
	doublereal absn;
	char *fmt;

	absn = n;
	if (absn < 0)
		absn = -absn;
	fmt = LLOW <= absn && absn < LHIGH ? LFFMT : LEFMT;
#ifdef USE_STRLEN
	sprintf(buf, fmt, n);
	return strlen(buf);
#else
	return sprintf(buf, fmt, n);
#endif

#else
	register char *b, c, c1;

	b = buf;
	*b++ = ' ';
	if (n < 0) {
		*b++ = '-';
		n = -n;
		}
	else
		*b++ = ' ';
	if (n == 0) {
#ifdef SIGNED_ZEROS
		if (signbit_f2c(&n))
			*b++ = '-';
#endif
		*b++ = '0';
		*b++ = '.';
		*b = 0;
		goto f__ret;
		}
	sprintf(b, LGFMT, n);
	switch(*b) {
#ifndef WANT_LEAD_0
		case '0':
			while(b[0] = b[1])
				b++;
			break;
#endif
		case 'i':
		case 'I':
			/* Infinity */
		case 'n':
		case 'N':
			/* NaN */
			while(*++b);
			break;

		default:
	/* Fortran 77 insists on having a decimal point... */
		    for(;; b++)
			switch(*b) {
			case 0:
				*b++ = '.';
				*b = 0;
				goto f__ret;
			case '.':
				while(*++b);
				goto f__ret;
			case 'E':
				for(c1 = '.', c = 'E';  *b = c1;
					c1 = c, c = *++b);
				goto f__ret;
			}
		}
 f__ret:
	return b - buf;
#endif
	}

 static VOID
#ifdef KR_headers
l_put(s) register char *s;
#else
l_put(register char *s)
#endif
{
#ifdef KR_headers
	register void (*pn)() = f__putn;
#else
	register void (*pn)(int) = f__putn;
#endif
	register int c;

	while(c = *s++)
		(*pn)(c);
	}

 static VOID
#ifdef KR_headers
lwrt_F(n) double n;
#else
lwrt_F(double n)
#endif
{
	char buf[LEFBL];

	if(f__recpos + l_g(buf,n) >= L_len)
		donewrec();
	l_put(buf);
}
 static VOID
#ifdef KR_headers
lwrt_C(a,b) double a,b;
#else
lwrt_C(double a, double b)
#endif
{
	char *ba, *bb, bufa[LEFBL], bufb[LEFBL];
	int al, bl;

	al = l_g(bufa, a);
	for(ba = bufa; *ba == ' '; ba++)
		--al;
	bl = l_g(bufb, b) + 1;	/* intentionally high by 1 */
	for(bb = bufb; *bb == ' '; bb++)
		--bl;
	if(f__recpos + al + bl + 3 >= L_len)
		donewrec();
#ifdef OMIT_BLANK_CC
	else
#endif
	PUT(' ');
	PUT('(');
	l_put(ba);
	PUT(',');
	if (f__recpos + bl >= L_len) {
		(*f__donewrec)();
#ifndef OMIT_BLANK_CC
		PUT(' ');
#endif
		}
	l_put(bb);
	PUT(')');
}

 int
#ifdef KR_headers
l_write(number,ptr,len,type) ftnint *number,type; char *ptr; ftnlen len;
#else
l_write(ftnint *number, char *ptr, ftnlen len, ftnint type)
#endif
{
#define Ptr ((flex *)ptr)
	int i;
	longint x;
	double y,z;
	real *xx;
	doublereal *yy;
	for(i=0;i< *number; i++)
	{
		switch((int)type)
		{
		default: f__fatal(117,"unknown type in lio");
		case TYINT1:
			x = Ptr->flchar;
			goto xint;
		case TYSHORT:
			x=Ptr->flshort;
			goto xint;
#ifdef Allow_TYQUAD
		case TYQUAD:
			x = Ptr->fllongint;
			goto xint;
#endif
		case TYLONG:
			x=Ptr->flint;
		xint:	lwrt_I(x);
			break;
		case TYREAL:
			y=Ptr->flreal;
			goto xfloat;
		case TYDREAL:
			y=Ptr->fldouble;
		xfloat: lwrt_F(y);
			break;
		case TYCOMPLEX:
			xx= &Ptr->flreal;
			y = *xx++;
			z = *xx;
			goto xcomplex;
		case TYDCOMPLEX:
			yy = &Ptr->fldouble;
			y= *yy++;
			z = *yy;
		xcomplex:
			lwrt_C(y,z);
			break;
		case TYLOGICAL1:
			x = Ptr->flchar;
			goto xlog;
		case TYLOGICAL2:
			x = Ptr->flshort;
			goto xlog;
		case TYLOGICAL:
			x = Ptr->flint;
		xlog:	lwrt_L(Ptr->flint, len);
			break;
		case TYCHAR:
			lwrt_A(ptr,len);
			break;
		}
		ptr += len;
	}
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/main.c0000644000175100001710000000426600000000000022721 0ustar00runnerdocker00000000000000/* STARTUP PROCEDURE FOR UNIX FORTRAN PROGRAMS */

#include "stdio.h"
#include "signal1.h"

#ifndef SIGIOT
#ifdef SIGABRT
#define SIGIOT SIGABRT
#endif
#endif

#ifndef KR_headers
#undef VOID
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif

#ifndef VOID
#define VOID void
#endif

#ifdef __cplusplus
extern "C" {
#endif

#ifdef NO__STDC
#define ONEXIT onexit
extern VOID f_exit();
#else
#ifndef KR_headers
extern void f_exit(void);
#ifndef NO_ONEXIT
#define ONEXIT atexit
extern int atexit(void (*)(void));
#endif
#else
#ifndef NO_ONEXIT
#define ONEXIT onexit
extern VOID f_exit();
#endif
#endif
#endif

#ifdef KR_headers
extern VOID f_init(), sig_die();
extern int MAIN__();
#define Int /* int */
#else
extern void f_init(void), sig_die(const char*, int);
extern int MAIN__(void);
#define Int int
#endif

static VOID sigfdie(Sigarg)
{
Use_Sigarg;
sig_die("Floating Exception", 1);
}


static VOID sigidie(Sigarg)
{
Use_Sigarg;
sig_die("IOT Trap", 1);
}

#ifdef SIGQUIT
static VOID sigqdie(Sigarg)
{
Use_Sigarg;
sig_die("Quit signal", 1);
}
#endif


static VOID sigindie(Sigarg)
{
Use_Sigarg;
sig_die("Interrupt", 0);
}

static VOID sigtdie(Sigarg)
{
Use_Sigarg;
sig_die("Killed", 0);
}

#ifdef SIGTRAP
static VOID sigtrdie(Sigarg)
{
Use_Sigarg;
sig_die("Trace trap", 1);
}
#endif


int xargc;
char **xargv;

#ifdef __cplusplus
	}
#endif

 int
#ifdef KR_headers
main(argc, argv) int argc; char **argv;
#else
main(int argc, char **argv)
#endif
{
xargc = argc;
xargv = argv;
signal1(SIGFPE, sigfdie);	/* ignore underflow, enable overflow */
#ifdef SIGIOT
signal1(SIGIOT, sigidie);
#endif
#ifdef SIGTRAP
signal1(SIGTRAP, sigtrdie);
#endif
#ifdef SIGQUIT
if(signal1(SIGQUIT,sigqdie) == SIG_IGN)
	signal1(SIGQUIT, SIG_IGN);
#endif
if(signal1(SIGINT, sigindie) == SIG_IGN)
	signal1(SIGINT, SIG_IGN);
signal1(SIGTERM,sigtdie);

#ifdef pdp11
	ldfps(01200); /* detect overflow as an exception */
#endif

f_init();
#ifndef NO_ONEXIT
ONEXIT(f_exit);
#endif
MAIN__();
#ifdef NO_ONEXIT
f_exit();
#endif
exit(0);	/* exit(0) rather than return(0) to bypass Cray bug */
return 0;	/* For compilers that complain of missing return values; */
		/* others will complain that this is unreachable code. */
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/makefile.sy0000644000175100001710000000565600000000000023767 0ustar00runnerdocker00000000000000# For making f2c.lib (here called syf2c.lib) with Symantec C++ .
# Invoke with "make -f makefile.sy" .
# In the CFLAGS line below, "-mn" is for NT and W9x.
# For 32-bit addressing with MSDOS, change "-mn" to "-mx".
# With Symantec, it is necessary to explicitly load main.obj .

# To get signed zeros in write statements on IEEE-arithmetic systems,
# add -DSIGNED_ZEROS to the CFLAGS assignment below and add signbit.obj
# to the objects in the "w =" list below.

CC = sc
CFLAGS = -DMSDOS -D_POSIX_SOURCE -DNO_ONEXIT -s -mn -DUSE_CLOCK -DNO_My_ctype

.c.obj:
	$(CC) -c $(CFLAGS) $*.c

w = \
	abort_.obj \
	backspac.obj \
	c_abs.obj \
	c_cos.obj \
	c_div.obj \
	c_exp.obj \
	c_log.obj \
	c_sin.obj \
	c_sqrt.obj \
	cabs.obj \
	close.obj \
	d_abs.obj \
	d_acos.obj \
	d_asin.obj \
	d_atan.obj \
	d_atn2.obj \
	d_cnjg.obj \
	d_cos.obj \
	d_cosh.obj \
	d_dim.obj \
	d_exp.obj \
	d_imag.obj \
	d_int.obj \
	d_lg10.obj \
	d_log.obj \
	d_mod.obj \
	d_nint.obj \
	d_prod.obj \
	d_sign.obj \
	d_sin.obj \
	d_sinh.obj \
	d_sqrt.obj \
	d_tan.obj \
	d_tanh.obj \
	derf_.obj \
	derfc_.obj \
	dfe.obj \
	dolio.obj \
	dtime_.obj \
	due.obj \
	ef1asc_.obj \
	ef1cmc_.obj \
	endfile.obj \
	erf_.obj \
	erfc_.obj \
	err.obj \
	etime_.obj \
	exit_.obj \
	f77_aloc.obj \
	f77vers.obj \
	fmt.obj \
	fmtlib.obj \
	ftell_.obj \
	getarg_.obj \
	getenv_.obj \
	h_abs.obj \
	h_dim.obj \
	h_dnnt.obj \
	h_indx.obj \
	h_len.obj \
	h_mod.obj \
	h_nint.obj \
	h_sign.obj \
	hl_ge.obj \
	hl_gt.obj \
	hl_le.obj \
	hl_lt.obj \
	i77vers.obj \
	i_abs.obj \
	i_dim.obj \
	i_dnnt.obj \
	i_indx.obj \
	i_len.obj \
	i_mod.obj \
	i_nint.obj \
	i_sign.obj \
	iargc_.obj \
	iio.obj \
	ilnw.obj \
	inquire.obj \
	l_ge.obj \
	l_gt.obj \
	l_le.obj \
	l_lt.obj \
	lbitbits.obj \
	lbitshft.obj \
	lread.obj \
	lwrite.obj \
	main.obj \
	open.obj \
	pow_ci.obj \
	pow_dd.obj \
	pow_di.obj \
	pow_hh.obj \
	pow_ii.obj \
	pow_ri.obj \
	pow_zi.obj \
	pow_zz.obj \
	r_abs.obj \
	r_acos.obj \
	r_asin.obj \
	r_atan.obj \
	r_atn2.obj \
	r_cnjg.obj \
	r_cos.obj \
	r_cosh.obj \
	r_dim.obj \
	r_exp.obj \
	r_imag.obj \
	r_int.obj \
	r_lg10.obj \
	r_log.obj \
	r_mod.obj \
	r_nint.obj \
	r_sign.obj \
	r_sin.obj \
	r_sinh.obj \
	r_sqrt.obj \
	r_tan.obj \
	r_tanh.obj \
	rdfmt.obj \
	rewind.obj \
	rsfe.obj \
	rsli.obj \
	rsne.obj \
	s_cat.obj \
	s_cmp.obj \
	s_copy.obj \
	s_paus.obj \
	s_rnge.obj \
	s_stop.obj \
	sfe.obj \
	sig_die.obj \
	signal_.obj \
	sue.obj \
	system_.obj \
	typesize.obj \
	uio.obj \
	util.obj \
	uninit.obj \
	wref.obj \
	wrtfmt.obj \
	wsfe.obj \
	wsle.obj \
	wsne.obj \
	xwsne.obj \
	z_abs.obj \
	z_cos.obj \
	z_div.obj \
	z_exp.obj \
	z_log.obj \
	z_sin.obj \
	z_sqrt.obj

syf2c.lib: f2c.h signal1.h sysdep1.h $w
	lib /B /C syf2c.lib @libf2c.sy

f2c.h: f2c.h0
	copy f2c.h0 f2c.h

signal1.h: signal1.h0
	copy signal1.h0 signal1.h

sysdep1.h: sysdep1.h0
	copy sysdep1.h0 sysdep1.h

signbit.obj uninit.obj: arith.h

arith.h: arithchk.c
	scomptry.bat $(CC) $(CFLAGS) arithchk.c
	arithchk
	del arithchk.exe
	del arithchk.obj
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/makefile.u0000644000175100001710000001631300000000000023570 0ustar00runnerdocker00000000000000# Unix makefile: see README.
# For C++, first "make hadd".
# If your compiler does not recognize ANSI C, add
#	-DKR_headers
# to the CFLAGS = line below.
# On Sun and other BSD systems that do not provide an ANSI sprintf, add
#	-DUSE_STRLEN
# to the CFLAGS = line below.
# On Linux systems, add
#	-DNON_UNIX_STDIO
# to the CFLAGS = line below.  For libf2c.so under Linux, also add
#	-fPIC
# to the CFLAGS = line below.

.SUFFIXES: .c .o
CC = cc
SHELL = /bin/sh
CFLAGS = -O

# compile, then strip unnecessary symbols
.c.o:
	$(CC) -c -DSkip_f2c_Undefs $(CFLAGS) $*.c
	ld -r -x -o $*.xxx $*.o
	mv $*.xxx $*.o
## Under Solaris (and other systems that do not understand ld -x),
## omit -x in the ld line above.
## If your system does not have the ld command, comment out
## or remove both the ld and mv lines above.

MISC =	f77vers.o i77vers.o main.o s_rnge.o abort_.o exit_.o getarg_.o iargc_.o\
	getenv_.o signal_.o s_stop.o s_paus.o system_.o cabs.o ctype.o\
	derf_.o derfc_.o erf_.o erfc_.o sig_die.o uninit.o
POW =	pow_ci.o pow_dd.o pow_di.o pow_hh.o pow_ii.o pow_ri.o pow_zi.o pow_zz.o
CX =	c_abs.o c_cos.o c_div.o c_exp.o c_log.o c_sin.o c_sqrt.o
DCX =	z_abs.o z_cos.o z_div.o z_exp.o z_log.o z_sin.o z_sqrt.o
REAL =	r_abs.o r_acos.o r_asin.o r_atan.o r_atn2.o r_cnjg.o r_cos.o\
	r_cosh.o r_dim.o r_exp.o r_imag.o r_int.o\
	r_lg10.o r_log.o r_mod.o r_nint.o r_sign.o\
	r_sin.o r_sinh.o r_sqrt.o r_tan.o r_tanh.o
DBL =	d_abs.o d_acos.o d_asin.o d_atan.o d_atn2.o\
	d_cnjg.o d_cos.o d_cosh.o d_dim.o d_exp.o\
	d_imag.o d_int.o d_lg10.o d_log.o d_mod.o\
	d_nint.o d_prod.o d_sign.o d_sin.o d_sinh.o\
	d_sqrt.o d_tan.o d_tanh.o
INT =	i_abs.o i_dim.o i_dnnt.o i_indx.o i_len.o i_mod.o i_nint.o i_sign.o\
	lbitbits.o lbitshft.o
HALF =	h_abs.o h_dim.o h_dnnt.o h_indx.o h_len.o h_mod.o h_nint.o h_sign.o
CMP =	l_ge.o l_gt.o l_le.o l_lt.o hl_ge.o hl_gt.o hl_le.o hl_lt.o
EFL =	ef1asc_.o ef1cmc_.o
CHAR =	f77_aloc.o s_cat.o s_cmp.o s_copy.o
I77 =	backspac.o close.o dfe.o dolio.o due.o endfile.o err.o\
	fmt.o fmtlib.o ftell_.o iio.o ilnw.o inquire.o lread.o lwrite.o\
	open.o rdfmt.o rewind.o rsfe.o rsli.o rsne.o sfe.o sue.o\
	typesize.o uio.o util.o wref.o wrtfmt.o wsfe.o wsle.o wsne.o xwsne.o
QINT =	pow_qq.o qbitbits.o qbitshft.o ftell64_.o
TIME =	dtime_.o etime_.o

# If you get an error compiling dtime_.c or etime_.c, try adding
# -DUSE_CLOCK to the CFLAGS assignment above; if that does not work,
# omit $(TIME) from OFILES = assignment below.

# To get signed zeros in write statements on IEEE-arithmetic systems,
# add -DSIGNED_ZEROS to the CFLAGS assignment below and add signbit.o
# to the end of the OFILES = assignment below.

# For INTEGER*8 support (which requires system-dependent adjustments to
# f2c.h), add $(QINT) to the OFILES = assignment below...

OFILES = $(MISC) $(POW) $(CX) $(DCX) $(REAL) $(DBL) $(INT) \
	$(HALF) $(CMP) $(EFL) $(CHAR) $(I77) $(TIME)

all: f2c.h signal1.h sysdep1.h $(OFILES)

libf2c.a: $(OFILES)
	ar r libf2c.a $?
	-ranlib libf2c.a

## Shared-library variant: the following rule works on Linux
## systems.  Details are system-dependent.  Under Linux, -fPIC
## must appear in the CFLAGS assignment when making libf2c.so.
## Under Solaris, use -Kpic in CFLAGS and use "ld -G" instead
## of "$(CC) -shared".
## For MacOSX 10.4 and 10.5 (and perhaps other versions >= 10.3), use
## "MACOSX_DEPLOYMENT_TARGET=10.3 libtool -dynamic -undefined dynamic_lookup -single_module"
## instead of "$(CC) -shared", and when running programs linked against libf2c.so,
## arrange for $DYLD_LIBRARY_PATH to include the directory containing libf2c.so.

libf2c.so: $(OFILES)
	$(CC) -shared -o libf2c.so $(OFILES)

### If your system lacks ranlib, you don't need it; see README.

f77vers.o: f77vers.c
	$(CC) -c f77vers.c

i77vers.o: i77vers.c
	$(CC) -c i77vers.c

# To get an "f2c.h" for use with "f2c -C++", first "make hadd"
hadd: f2c.h0 f2ch.add
	cat f2c.h0 f2ch.add >f2c.h

# For use with "f2c" and "f2c -A":
f2c.h: f2c.h0
	cp f2c.h0 f2c.h

# You may need to adjust signal1.h and sysdep1.h suitably for your system...
signal1.h: signal1.h0
	cp signal1.h0 signal1.h

sysdep1.h: sysdep1.h0
	cp sysdep1.h0 sysdep1.h

# If your system lacks onexit() and you are not using an
# ANSI C compiler, then you should uncomment the following
# two lines (for compiling main.o):
#main.o: main.c
#	$(CC) -c -DNO_ONEXIT -DSkip_f2c_Undefs main.c
# On at least some Sun systems, it is more appropriate to
# uncomment the following two lines:
#main.o: main.c
#	$(CC) -c -Donexit=on_exit -DSkip_f2c_Undefs main.c

install: libf2c.a
	cp libf2c.a $(LIBDIR)
	-ranlib $(LIBDIR)/libf2c.a

clean:
	rm -f *.o arith.h signal1.h sysdep1.h

backspac.o:	fio.h
close.o:	fio.h
dfe.o:		fio.h
dfe.o:		fmt.h
due.o:		fio.h
endfile.o:	fio.h rawio.h
err.o:		fio.h rawio.h
fmt.o:		fio.h
fmt.o:		fmt.h
iio.o:		fio.h
iio.o:		fmt.h
ilnw.o:		fio.h
ilnw.o:		lio.h
inquire.o:	fio.h
lread.o:	fio.h
lread.o:	fmt.h
lread.o:	lio.h
lread.o:	fp.h
lwrite.o:	fio.h
lwrite.o:	fmt.h
lwrite.o:	lio.h
open.o:		fio.h rawio.h
rdfmt.o:	fio.h
rdfmt.o:	fmt.h
rdfmt.o:	fp.h
rewind.o:	fio.h
rsfe.o:		fio.h
rsfe.o:		fmt.h
rsli.o:		fio.h
rsli.o:		lio.h
rsne.o:		fio.h
rsne.o:		lio.h
sfe.o:		fio.h
signbit.o:	arith.h
sue.o:		fio.h
uio.o:		fio.h
uninit.o:	arith.h
util.o:		fio.h
wref.o:		fio.h
wref.o:		fmt.h
wref.o:		fp.h
wrtfmt.o:	fio.h
wrtfmt.o:	fmt.h
wsfe.o:		fio.h
wsfe.o:		fmt.h
wsle.o:		fio.h
wsle.o:		fmt.h
wsle.o:		lio.h
wsne.o:		fio.h
wsne.o:		lio.h
xwsne.o:	fio.h
xwsne.o:	lio.h
xwsne.o:	fmt.h

arith.h: arithchk.c
	$(CC) $(CFLAGS) -DNO_FPINIT arithchk.c -lm ||\
	 $(CC) -DNO_LONG_LONG $(CFLAGS) -DNO_FPINIT arithchk.c -lm
	./a.out >arith.h
	rm -f a.out arithchk.o

check:
	xsum Notice README abort_.c arithchk.c backspac.c c_abs.c c_cos.c \
	c_div.c c_exp.c c_log.c c_sin.c c_sqrt.c cabs.c close.c comptry.bat \
	ctype.c ctype.h \
	d_abs.c d_acos.c d_asin.c d_atan.c d_atn2.c d_cnjg.c d_cos.c d_cosh.c \
	d_dim.c d_exp.c d_imag.c d_int.c d_lg10.c d_log.c d_mod.c \
	d_nint.c d_prod.c d_sign.c d_sin.c d_sinh.c d_sqrt.c d_tan.c \
	d_tanh.c derf_.c derfc_.c dfe.c dolio.c dtime_.c due.c ef1asc_.c \
	ef1cmc_.c endfile.c erf_.c erfc_.c err.c etime_.c exit_.c f2c.h0 \
	f2ch.add f77_aloc.c f77vers.c fio.h fmt.c fmt.h fmtlib.c \
	fp.h ftell_.c ftell64_.c \
	getarg_.c getenv_.c h_abs.c h_dim.c h_dnnt.c h_indx.c h_len.c \
	h_mod.c h_nint.c h_sign.c hl_ge.c hl_gt.c hl_le.c hl_lt.c \
	i77vers.c i_abs.c i_dim.c i_dnnt.c i_indx.c i_len.c i_mod.c \
	i_nint.c i_sign.c iargc_.c iio.c ilnw.c inquire.c l_ge.c l_gt.c \
	l_le.c l_lt.c lbitbits.c lbitshft.c libf2c.lbc libf2c.sy lio.h \
	lread.c lwrite.c main.c makefile.sy makefile.u makefile.vc \
	makefile.wat math.hvc mkfile.plan9 open.c pow_ci.c pow_dd.c \
	pow_di.c pow_hh.c pow_ii.c pow_qq.c pow_ri.c pow_zi.c pow_zz.c \
	qbitbits.c qbitshft.c r_abs.c r_acos.c r_asin.c r_atan.c r_atn2.c \
	r_cnjg.c r_cos.c r_cosh.c r_dim.c r_exp.c r_imag.c r_int.c r_lg10.c \
	r_log.c r_mod.c r_nint.c r_sign.c r_sin.c r_sinh.c r_sqrt.c \
	r_tan.c r_tanh.c rawio.h rdfmt.c rewind.c rsfe.c rsli.c rsne.c \
	s_cat.c s_cmp.c s_copy.c s_paus.c s_rnge.c s_stop.c scomptry.bat sfe.c \
	sig_die.c signal1.h0 signal_.c signbit.c sue.c sysdep1.h0 system_.c \
	typesize.c \
	uio.c uninit.c util.c wref.c wrtfmt.c wsfe.c wsle.c wsne.c xwsne.c \
	z_abs.c z_cos.c z_div.c z_exp.c z_log.c z_sin.c z_sqrt.c >xsum1.out
	cmp xsum0.out xsum1.out && mv xsum1.out xsum.out || diff xsum[01].out
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/makefile.vc0000644000175100001710000000561200000000000023734 0ustar00runnerdocker00000000000000# For making f2c.lib (here called vcf2c.lib) with Microsoft Visual C++ .
# Invoke with "nmake -f makefile.vc" .

# To get signed zeros in write statements on IEEE-arithmetic systems,
# add -DSIGNED_ZEROS to the CFLAGS assignment below and add signbit.obj
# to the objects in the "w =" list below.

CC = cl
CFLAGS = -DUSE_CLOCK -DMSDOS -DNO_ONEXIT -Ot1 -DNO_My_ctype -DNO_ISATTY

.c.obj:
	$(CC) -c $(CFLAGS) $*.c

w = \
	abort_.obj \
	backspac.obj \
	c_abs.obj \
	c_cos.obj \
	c_div.obj \
	c_exp.obj \
	c_log.obj \
	c_sin.obj \
	c_sqrt.obj \
	cabs.obj \
	close.obj \
	d_abs.obj \
	d_acos.obj \
	d_asin.obj \
	d_atan.obj \
	d_atn2.obj \
	d_cnjg.obj \
	d_cos.obj \
	d_cosh.obj \
	d_dim.obj \
	d_exp.obj \
	d_imag.obj \
	d_int.obj \
	d_lg10.obj \
	d_log.obj \
	d_mod.obj \
	d_nint.obj \
	d_prod.obj \
	d_sign.obj \
	d_sin.obj \
	d_sinh.obj \
	d_sqrt.obj \
	d_tan.obj \
	d_tanh.obj \
	derf_.obj \
	derfc_.obj \
	dfe.obj \
	dolio.obj \
	dtime_.obj \
	due.obj \
	ef1asc_.obj \
	ef1cmc_.obj \
	endfile.obj \
	erf_.obj \
	erfc_.obj \
	err.obj \
	etime_.obj \
	exit_.obj \
	f77_aloc.obj \
	f77vers.obj \
	fmt.obj \
	fmtlib.obj \
	ftell_.obj \
	getarg_.obj \
	getenv_.obj \
	h_abs.obj \
	h_dim.obj \
	h_dnnt.obj \
	h_indx.obj \
	h_len.obj \
	h_mod.obj \
	h_nint.obj \
	h_sign.obj \
	hl_ge.obj \
	hl_gt.obj \
	hl_le.obj \
	hl_lt.obj \
	i77vers.obj \
	i_abs.obj \
	i_dim.obj \
	i_dnnt.obj \
	i_indx.obj \
	i_len.obj \
	i_mod.obj \
	i_nint.obj \
	i_sign.obj \
	iargc_.obj \
	iio.obj \
	ilnw.obj \
	inquire.obj \
	l_ge.obj \
	l_gt.obj \
	l_le.obj \
	l_lt.obj \
	lbitbits.obj \
	lbitshft.obj \
	lread.obj \
	lwrite.obj \
	main.obj \
	open.obj \
	pow_ci.obj \
	pow_dd.obj \
	pow_di.obj \
	pow_hh.obj \
	pow_ii.obj \
	pow_ri.obj \
	pow_zi.obj \
	pow_zz.obj \
	r_abs.obj \
	r_acos.obj \
	r_asin.obj \
	r_atan.obj \
	r_atn2.obj \
	r_cnjg.obj \
	r_cos.obj \
	r_cosh.obj \
	r_dim.obj \
	r_exp.obj \
	r_imag.obj \
	r_int.obj \
	r_lg10.obj \
	r_log.obj \
	r_mod.obj \
	r_nint.obj \
	r_sign.obj \
	r_sin.obj \
	r_sinh.obj \
	r_sqrt.obj \
	r_tan.obj \
	r_tanh.obj \
	rdfmt.obj \
	rewind.obj \
	rsfe.obj \
	rsli.obj \
	rsne.obj \
	s_cat.obj \
	s_cmp.obj \
	s_copy.obj \
	s_paus.obj \
	s_rnge.obj \
	s_stop.obj \
	sfe.obj \
	sig_die.obj \
	signal_.obj \
	sue.obj \
	system_.obj \
	typesize.obj \
	uio.obj \
	uninit.obj \
	util.obj \
	wref.obj \
	wrtfmt.obj \
	wsfe.obj \
	wsle.obj \
	wsne.obj \
	xwsne.obj \
	z_abs.obj \
	z_cos.obj \
	z_div.obj \
	z_exp.obj \
	z_log.obj \
	z_sin.obj \
	z_sqrt.obj

all: f2c.h math.h signal1.h sysdep1.h vcf2c.lib

f2c.h: f2c.h0
	copy f2c.h0 f2c.h

math.h: math.hvc
	copy math.hvc math.h

signal1.h: signal1.h0
	copy signal1.h0 signal1.h

sysdep1.h: sysdep1.h0
	copy sysdep1.h0 sysdep1.h

vcf2c.lib: $w
	lib -out:vcf2c.lib @libf2c.lbc

open.obj: open.c
	$(CC) -c $(CFLAGS) -DMSDOS open.c

signbit.obj uninit.obj: arith.h

arith.h: arithchk.c
	comptry.bat $(CC) $(CFLAGS) -DNO_FPINIT arithchk.c
	arithchk >arith.h
	del arithchk.exe
	del arithchk.obj
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/makefile.wat0000644000175100001710000000557000000000000024122 0ustar00runnerdocker00000000000000# For making f2c.lib (here called watf2c.lib) with WATCOM C/C++ .
# Invoke with "wmake -u -f makefile.wat" .
# In the CFLAGS line below, "-bt=nt" is for NT and W9x.
# With WATCOM, it is necessary to explicitly load main.obj .

# To get signed zeros in write statements on IEEE-arithmetic systems,
# add -DSIGNED_ZEROS to the CFLAGS assignment below and add signbit.obj
# to the objects in the "w =" list below.

CC = wcc386
CFLAGS = -fpd -DMSDOS -DUSE_CLOCK -DNO_ONEXIT -bt=nt -DNO_My_ctype

.c.obj:
	$(CC) $(CFLAGS) $*.c

w = \
	abort_.obj \
	backspac.obj \
	c_abs.obj \
	c_cos.obj \
	c_div.obj \
	c_exp.obj \
	c_log.obj \
	c_sin.obj \
	c_sqrt.obj \
	cabs.obj \
	close.obj \
	d_abs.obj \
	d_acos.obj \
	d_asin.obj \
	d_atan.obj \
	d_atn2.obj \
	d_cnjg.obj \
	d_cos.obj \
	d_cosh.obj \
	d_dim.obj \
	d_exp.obj \
	d_imag.obj \
	d_int.obj \
	d_lg10.obj \
	d_log.obj \
	d_mod.obj \
	d_nint.obj \
	d_prod.obj \
	d_sign.obj \
	d_sin.obj \
	d_sinh.obj \
	d_sqrt.obj \
	d_tan.obj \
	d_tanh.obj \
	derf_.obj \
	derfc_.obj \
	dfe.obj \
	dolio.obj \
	dtime_.obj \
	due.obj \
	ef1asc_.obj \
	ef1cmc_.obj \
	endfile.obj \
	erf_.obj \
	erfc_.obj \
	err.obj \
	etime_.obj \
	exit_.obj \
	f77_aloc.obj \
	f77vers.obj \
	fmt.obj \
	fmtlib.obj \
	ftell_.obj \
	getarg_.obj \
	getenv_.obj \
	h_abs.obj \
	h_dim.obj \
	h_dnnt.obj \
	h_indx.obj \
	h_len.obj \
	h_mod.obj \
	h_nint.obj \
	h_sign.obj \
	hl_ge.obj \
	hl_gt.obj \
	hl_le.obj \
	hl_lt.obj \
	i77vers.obj \
	i_abs.obj \
	i_dim.obj \
	i_dnnt.obj \
	i_indx.obj \
	i_len.obj \
	i_mod.obj \
	i_nint.obj \
	i_sign.obj \
	iargc_.obj \
	iio.obj \
	ilnw.obj \
	inquire.obj \
	l_ge.obj \
	l_gt.obj \
	l_le.obj \
	l_lt.obj \
	lbitbits.obj \
	lbitshft.obj \
	lread.obj \
	lwrite.obj \
	main.obj \
	open.obj \
	pow_ci.obj \
	pow_dd.obj \
	pow_di.obj \
	pow_hh.obj \
	pow_ii.obj \
	pow_ri.obj \
	pow_zi.obj \
	pow_zz.obj \
	r_abs.obj \
	r_acos.obj \
	r_asin.obj \
	r_atan.obj \
	r_atn2.obj \
	r_cnjg.obj \
	r_cos.obj \
	r_cosh.obj \
	r_dim.obj \
	r_exp.obj \
	r_imag.obj \
	r_int.obj \
	r_lg10.obj \
	r_log.obj \
	r_mod.obj \
	r_nint.obj \
	r_sign.obj \
	r_sin.obj \
	r_sinh.obj \
	r_sqrt.obj \
	r_tan.obj \
	r_tanh.obj \
	rdfmt.obj \
	rewind.obj \
	rsfe.obj \
	rsli.obj \
	rsne.obj \
	s_cat.obj \
	s_cmp.obj \
	s_copy.obj \
	s_paus.obj \
	s_rnge.obj \
	s_stop.obj \
	sfe.obj \
	sig_die.obj \
	signal_.obj \
	sue.obj \
	system_.obj \
	typesize.obj \
	uio.obj \
	uninit.obj \
	util.obj \
	wref.obj \
	wrtfmt.obj \
	wsfe.obj \
	wsle.obj \
	wsne.obj \
	xwsne.obj \
	z_abs.obj \
	z_cos.obj \
	z_div.obj \
	z_exp.obj \
	z_log.obj \
	z_sin.obj \
	z_sqrt.obj

watf2c.lib: f2c.h signal1.h sysdep1.h $w
	wlib -c watf2c.lib @libf2c

f2c.h: f2c.h0
	copy f2c.h0 f2c.h

signal1.h: signal1.h0
	copy signal1.h0 signal1.h

sysdep1.h: sysdep1.h0
	copy sysdep1.h0 sysdep1.h

signbit.obj uninit.obj: arith.h

arith.h: arithchk.c
	comptry.bat wcl386 -DNO_FPINIT arithchk.c
	arithchk >arith.h
	del arithchk.exe
	del arithchk.obj
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/math.hvc0000644000175100001710000000006200000000000023252 0ustar00runnerdocker00000000000000/* for VC 4.2 */
#include 
#undef complex
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/mkfile.plan90000644000175100001710000001206600000000000024042 0ustar00runnerdocker00000000000000#	Plan 9 mkfile for libf2c.a$O

f2c.h

# For use with "f2c" and "f2c -A":
f2c.h: f2c.h0
	cp f2c.h0 f2c.h

# You may need to adjust signal1.h suitably for your system...
signal1.h: signal1.h0
	cp signal1.h0 signal1.h

clean:
	rm -f libf2c.a$O *.$O arith.h

backspac.$O:	fio.h
close.$O:	fio.h
dfe.$O:		fio.h
dfe.$O:		fmt.h
due.$O:		fio.h
endfile.$O:	fio.h rawio.h
err.$O:		fio.h rawio.h
fmt.$O:		fio.h
fmt.$O:		fmt.h
iio.$O:		fio.h
iio.$O:		fmt.h
ilnw.$O:		fio.h
ilnw.$O:		lio.h
inquire.$O:	fio.h
lread.$O:	fio.h
lread.$O:	fmt.h
lread.$O:	lio.h
lread.$O:	fp.h
lwrite.$O:	fio.h
lwrite.$O:	fmt.h
lwrite.$O:	lio.h
open.$O:		fio.h rawio.h
rdfmt.$O:	fio.h
rdfmt.$O:	fmt.h
rdfmt.$O:	fp.h
rewind.$O:	fio.h
rsfe.$O:		fio.h
rsfe.$O:		fmt.h
rsli.$O:		fio.h
rsli.$O:		lio.h
rsne.$O:		fio.h
rsne.$O:		lio.h
sfe.$O:		fio.h
sue.$O:		fio.h
uio.$O:		fio.h
uninit.$O:	arith.h
util.$O:		fio.h
wref.$O:		fio.h
wref.$O:		fmt.h
wref.$O:		fp.h
wrtfmt.$O:	fio.h
wrtfmt.$O:	fmt.h
wsfe.$O:		fio.h
wsfe.$O:		fmt.h
wsle.$O:		fio.h
wsle.$O:		fmt.h
wsle.$O:		lio.h
wsne.$O:		fio.h
wsne.$O:		lio.h
xwsne.$O:	fio.h
xwsne.$O:	lio.h
xwsne.$O:	fmt.h

arith.h: arithchk.c
	pcc -DNO_FPINIT -o arithchk arithchk.c
	arithchk >$target
	rm arithchk

xsum.out:V: check

check:
	xsum Notice README abort_.c arithchk.c backspac.c c_abs.c c_cos.c \
	c_div.c c_exp.c c_log.c c_sin.c c_sqrt.c cabs.c close.c comptry.bat \
	d_abs.c d_acos.c d_asin.c d_atan.c d_atn2.c d_cnjg.c d_cos.c d_cosh.c \
	d_dim.c d_exp.c d_imag.c d_int.c d_lg10.c d_log.c d_mod.c \
	d_nint.c d_prod.c d_sign.c d_sin.c d_sinh.c d_sqrt.c d_tan.c \
	d_tanh.c derf_.c derfc_.c dfe.c dolio.c dtime_.c due.c ef1asc_.c \
	ef1cmc_.c endfile.c erf_.c erfc_.c err.c etime_.c exit_.c f2c.h0 \
	f2ch.add f77_aloc.c f77vers.c fio.h fmt.c fmt.h fmtlib.c \
	fp.h ftell_.c \
	getarg_.c getenv_.c h_abs.c h_dim.c h_dnnt.c h_indx.c h_len.c \
	h_mod.c h_nint.c h_sign.c hl_ge.c hl_gt.c hl_le.c hl_lt.c \
	i77vers.c i_abs.c i_dim.c i_dnnt.c i_indx.c i_len.c i_mod.c \
	i_nint.c i_sign.c iargc_.c iio.c ilnw.c inquire.c l_ge.c l_gt.c \
	l_le.c l_lt.c lbitbits.c lbitshft.c libf2c.lbc libf2c.sy lio.h \
	lread.c lwrite.c main.c makefile.sy makefile.u makefile.vc \
	makefile.wat math.hvc mkfile.plan9 open.c pow_ci.c pow_dd.c \
	pow_di.c pow_hh.c pow_ii.c pow_qq.c pow_ri.c pow_zi.c pow_zz.c \
	qbitbits.c qbitshft.c r_abs.c r_acos.c r_asin.c r_atan.c r_atn2.c \
	r_cnjg.c r_cos.c r_cosh.c r_dim.c r_exp.c r_imag.c r_int.c r_lg10.c \
	r_log.c r_mod.c r_nint.c r_sign.c r_sin.c r_sinh.c r_sqrt.c \
	r_tan.c r_tanh.c rawio.h rdfmt.c rewind.c rsfe.c rsli.c rsne.c \
	s_cat.c s_cmp.c s_copy.c s_paus.c s_rnge.c s_stop.c sfe.c \
	sig_die.c signal1.h0 signal_.c sue.c system_.c typesize.c uio.c \
	uninit.c util.c wref.c wrtfmt.c wsfe.c wsle.c wsne.c xwsne.c \
	z_abs.c z_cos.c z_div.c z_exp.c z_log.c z_sin.c z_sqrt.c >xsum1.out
	cmp xsum0.out xsum1.out && mv xsum1.out xsum.out || diff xsum[01].out
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/open.c0000644000175100001710000001310500000000000022726 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "string.h"
#ifndef NON_POSIX_STDIO
#ifdef MSDOS
#include "io.h"
#else
#include "unistd.h"	/* for access */
#endif
#endif

#ifdef KR_headers
extern char *malloc();
#ifdef NON_ANSI_STDIO
extern char *mktemp();
#endif
extern integer f_clos();
#define Const /*nothing*/
#else
#define Const const
#undef abs
#undef min
#undef max
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
extern int f__canseek(FILE*);
extern integer f_clos(cllist*);
#endif

#ifdef NON_ANSI_RW_MODES
Const char *f__r_mode[2] = {"r", "r"};
Const char *f__w_mode[4] = {"w", "w", "r+w", "r+w"};
#else
Const char *f__r_mode[2] = {"rb", "r"};
Const char *f__w_mode[4] = {"wb", "w", "r+b", "r+"};
#endif

 static char f__buf0[400], *f__buf = f__buf0;
 int f__buflen = (int)sizeof(f__buf0);

 static void
#ifdef KR_headers
f__bufadj(n, c) int n, c;
#else
f__bufadj(int n, int c)
#endif
{
	unsigned int len;
	char *nbuf, *s, *t, *te;

	if (f__buf == f__buf0)
		f__buflen = 1024;
	while(f__buflen <= n)
		f__buflen <<= 1;
	len = (unsigned int)f__buflen;
	if (len != f__buflen || !(nbuf = (char*)malloc(len)))
		f__fatal(113, "malloc failure");
	s = nbuf;
	t = f__buf;
	te = t + c;
	while(t < te)
		*s++ = *t++;
	if (f__buf != f__buf0)
		free(f__buf);
	f__buf = nbuf;
	}

 int
#ifdef KR_headers
f__putbuf(c) int c;
#else
f__putbuf(int c)
#endif
{
	char *s, *se;
	int n;

	if (f__hiwater > f__recpos)
		f__recpos = f__hiwater;
	n = f__recpos + 1;
	if (n >= f__buflen)
		f__bufadj(n, f__recpos);
	s = f__buf;
	se = s + f__recpos;
	if (c)
		*se++ = c;
	*se = 0;
	for(;;) {
		fputs(s, f__cf);
		s += strlen(s);
		if (s >= se)
			break;	/* normally happens the first time */
		putc(*s++, f__cf);
		}
	return 0;
	}

 void
#ifdef KR_headers
x_putc(c)
#else
x_putc(int c)
#endif
{
	if (f__recpos >= f__buflen)
		f__bufadj(f__recpos, f__buflen);
	f__buf[f__recpos++] = c;
	}

#define opnerr(f,m,s) {if(f) errno= m; else opn_err(m,s,a); return(m);}

 static void
#ifdef KR_headers
opn_err(m, s, a) int m; char *s; olist *a;
#else
opn_err(int m, const char *s, olist *a)
#endif
{
	if (a->ofnm) {
		/* supply file name to error message */
		if (a->ofnmlen >= f__buflen)
			f__bufadj((int)a->ofnmlen, 0);
		g_char(a->ofnm, a->ofnmlen, f__curunit->ufnm = f__buf);
		}
	f__fatal(m, s);
	}

#ifdef KR_headers
integer f_open(a) olist *a;
#else
integer f_open(olist *a)
#endif
{	unit *b;
	integer rv;
	char buf[256], *s;
	cllist x;
	int ufmt;
	FILE *tf;
#ifndef NON_UNIX_STDIO
	int n;
#endif
	f__external = 1;
	if(a->ounit>=MXUNIT || a->ounit<0)
		err(a->oerr,101,"open")
	if (!f__init)
		f_init();
	f__curunit = b = &f__units[a->ounit];
	if(b->ufd) {
		if(a->ofnm==0)
		{
		same:	if (a->oblnk)
				b->ublnk = *a->oblnk == 'z' || *a->oblnk == 'Z';
			return(0);
		}
#ifdef NON_UNIX_STDIO
		if (b->ufnm
		 && strlen(b->ufnm) == a->ofnmlen
		 && !strncmp(b->ufnm, a->ofnm, (unsigned)a->ofnmlen))
			goto same;
#else
		g_char(a->ofnm,a->ofnmlen,buf);
		if (f__inode(buf,&n) == b->uinode && n == b->udev)
			goto same;
#endif
		x.cunit=a->ounit;
		x.csta=0;
		x.cerr=a->oerr;
		if ((rv = f_clos(&x)) != 0)
			return rv;
		}
	b->url = (int)a->orl;
	b->ublnk = a->oblnk && (*a->oblnk == 'z' || *a->oblnk == 'Z');
	if(a->ofm==0)
	{	if(b->url>0) b->ufmt=0;
		else b->ufmt=1;
	}
	else if(*a->ofm=='f' || *a->ofm == 'F') b->ufmt=1;
	else b->ufmt=0;
	ufmt = b->ufmt;
#ifdef url_Adjust
	if (b->url && !ufmt)
		url_Adjust(b->url);
#endif
	if (a->ofnm) {
		g_char(a->ofnm,a->ofnmlen,buf);
		if (!buf[0])
			opnerr(a->oerr,107,"open")
		}
	else
		sprintf(buf, "fort.%ld", (long)a->ounit);
	b->uscrtch = 0;
	b->uend=0;
	b->uwrt = 0;
	b->ufd = 0;
	b->urw = 3;
	switch(a->osta ? *a->osta : 'u')
	{
	case 'o':
	case 'O':
#ifdef NON_POSIX_STDIO
		if (!(tf = FOPEN(buf,"r")))
			opnerr(a->oerr,errno,"open")
		fclose(tf);
#else
		if (access(buf,0))
			opnerr(a->oerr,errno,"open")
#endif
		break;
	 case 's':
	 case 'S':
		b->uscrtch=1;
#ifdef NON_ANSI_STDIO
		(void) strcpy(buf,"tmp.FXXXXXX");
		(void) mktemp(buf);
		goto replace;
#else
		if (!(b->ufd = tmpfile()))
			opnerr(a->oerr,errno,"open")
		b->ufnm = 0;
#ifndef NON_UNIX_STDIO
		b->uinode = b->udev = -1;
#endif
		b->useek = 1;
		return 0;
#endif

	case 'n':
	case 'N':
#ifdef NON_POSIX_STDIO
		if ((tf = FOPEN(buf,"r")) || (tf = FOPEN(buf,"a"))) {
			fclose(tf);
			opnerr(a->oerr,128,"open")
			}
#else
		if (!access(buf,0))
			opnerr(a->oerr,128,"open")
#endif
		/* no break */
	case 'r':	/* Fortran 90 replace option */
	case 'R':
#ifdef NON_ANSI_STDIO
 replace:
#endif
		if (tf = FOPEN(buf,f__w_mode[0]))
			fclose(tf);
	}

	b->ufnm=(char *) malloc((unsigned int)(strlen(buf)+1));
	if(b->ufnm==NULL) opnerr(a->oerr,113,"no space");
	(void) strcpy(b->ufnm,buf);
	if ((s = a->oacc) && b->url)
		ufmt = 0;
	if(!(tf = FOPEN(buf, f__w_mode[ufmt|2]))) {
		if (tf = FOPEN(buf, f__r_mode[ufmt]))
			b->urw = 1;
		else if (tf = FOPEN(buf, f__w_mode[ufmt])) {
			b->uwrt = 1;
			b->urw = 2;
			}
		else
			err(a->oerr, errno, "open");
		}
	b->useek = f__canseek(b->ufd = tf);
#ifndef NON_UNIX_STDIO
	if((b->uinode = f__inode(buf,&b->udev)) == -1)
		opnerr(a->oerr,108,"open")
#endif
	if(b->useek)
		if (a->orl)
			rewind(b->ufd);
		else if ((s = a->oacc) && (*s == 'a' || *s == 'A')
			&& FSEEK(b->ufd, 0L, SEEK_END))
				opnerr(a->oerr,129,"open");
	return(0);
}

 int
#ifdef KR_headers
fk_open(seq,fmt,n) ftnint n;
#else
fk_open(int seq, int fmt, ftnint n)
#endif
{	char nbuf[17];
	olist a;
	(void) sprintf(nbuf,"fort.%ld",(long)n);
	a.oerr=1;
	a.ounit=n;
	a.ofnm=nbuf;
	a.ofnmlen=strlen(nbuf);
	a.osta=NULL;
	a.oacc= (char*)(seq==SEQ?"s":"d");
	a.ofm = (char*)(fmt==FMT?"f":"u");
	a.orl = seq==DIR?1:0;
	a.oblnk=NULL;
	return(f_open(&a));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_ci.c0000644000175100001710000000065000000000000023246 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
VOID pow_ci(p, a, b) 	/* p = a**b  */
 f2c_complex *p, *a; integer *b;
#else
extern void pow_zi(doublecomplex*, doublecomplex*, integer*);
void pow_ci(f2c_complex *p, f2c_complex *a, integer *b) 	/* p = a**b  */
#endif
{
doublecomplex p1, a1;

a1.r = a->r;
a1.i = a->i;

pow_zi(&p1, &a1, b);

p->r = p1.r;
p->i = p1.i;
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_dd.c0000644000175100001710000000042400000000000023241 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double pow();
double pow_dd(ap, bp) doublereal *ap, *bp;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double pow_dd(doublereal *ap, doublereal *bp)
#endif
{
return(pow(*ap, *bp) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_di.c0000644000175100001710000000070000000000000023243 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double pow_di(ap, bp) doublereal *ap; integer *bp;
#else
double pow_di(doublereal *ap, integer *bp)
#endif
{
double pow, x;
integer n;
unsigned long u;

pow = 1;
x = *ap;
n = *bp;

if(n != 0)
	{
	if(n < 0)
		{
		n = -n;
		x = 1/x;
		}
	for(u = n; ; )
		{
		if(u & 01)
			pow *= x;
		if(u >>= 1)
			x *= x;
		else
			break;
		}
	}
return(pow);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_hh.c0000644000175100001710000000075100000000000023254 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
shortint pow_hh(ap, bp) shortint *ap, *bp;
#else
shortint pow_hh(shortint *ap, shortint *bp)
#endif
{
	shortint pow, x, n;
	unsigned u;

	x = *ap;
	n = *bp;

	if (n <= 0) {
		if (n == 0 || x == 1)
			return 1;
		if (x != -1)
			return x == 0 ? 1/x : 0;
		n = -n;
		}
	u = n;
	for(pow = 1; ; )
		{
		if(u & 01)
			pow *= x;
		if(u >>= 1)
			x *= x;
		else
			break;
		}
	return(pow);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_ii.c0000644000175100001710000000075000000000000023255 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer pow_ii(ap, bp) integer *ap, *bp;
#else
integer pow_ii(integer *ap, integer *bp)
#endif
{
	integer pow, x, n;
	unsigned long u;

	x = *ap;
	n = *bp;

	if (n <= 0) {
		if (n == 0 || x == 1)
			return 1;
		if (x != -1)
			return x == 0 ? 1/x : 0;
		n = -n;
		}
	u = n;
	for(pow = 1; ; )
		{
		if(u & 01)
			pow *= x;
		if(u >>= 1)
			x *= x;
		else
			break;
		}
	return(pow);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_ri.c0000644000175100001710000000066400000000000023272 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double pow_ri(ap, bp) real *ap; integer *bp;
#else
double pow_ri(real *ap, integer *bp)
#endif
{
double pow, x;
integer n;
unsigned long u;

pow = 1;
x = *ap;
n = *bp;

if(n != 0)
	{
	if(n < 0)
		{
		n = -n;
		x = 1/x;
		}
	for(u = n; ; )
		{
		if(u & 01)
			pow *= x;
		if(u >>= 1)
			x *= x;
		else
			break;
		}
	}
return(pow);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_zi.c0000644000175100001710000000152300000000000023275 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
VOID pow_zi(p, a, b) 	/* p = a**b  */
 doublecomplex *p, *a; integer *b;
#else
extern void z_div(doublecomplex*, doublecomplex*, doublecomplex*);
void pow_zi(doublecomplex *p, doublecomplex *a, integer *b) 	/* p = a**b  */
#endif
{
	integer n;
	unsigned long u;
	double t;
	doublecomplex q, x;
	static doublecomplex one = {1.0, 0.0};

	n = *b;
	q.r = 1;
	q.i = 0;

	if(n == 0)
		goto done;
	if(n < 0)
		{
		n = -n;
		z_div(&x, &one, a);
		}
	else
		{
		x.r = a->r;
		x.i = a->i;
		}

	for(u = n; ; )
		{
		if(u & 01)
			{
			t = q.r * x.r - q.i * x.i;
			q.i = q.r * x.i + q.i * x.r;
			q.r = t;
			}
		if(u >>= 1)
			{
			t = x.r * x.r - x.i * x.i;
			x.i = 2 * x.r * x.i;
			x.r = t;
			}
		else
			break;
		}
 done:
	p->i = q.i;
	p->r = q.r;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/pow_zz.c0000644000175100001710000000104500000000000023315 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double log(), exp(), cos(), sin(), atan2(), f__cabs();
VOID pow_zz(r,a,b) doublecomplex *r, *a, *b;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double,double);
void pow_zz(doublecomplex *r, doublecomplex *a, doublecomplex *b)
#endif
{
double logr, logi, x, y;

logr = log( f__cabs(a->r, a->i) );
logi = atan2(a->i, a->r);

x = exp( logr * b->r - logi * b->i );
y = logr * b->i + logi * b->r;

r->r = x * cos(y);
r->i = x * sin(y);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_abs.c0000644000175100001710000000031600000000000023053 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double r_abs(x) real *x;
#else
double r_abs(real *x)
#endif
{
if(*x >= 0)
	return(*x);
return(- *x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_acos.c0000644000175100001710000000035100000000000023232 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double acos();
double r_acos(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_acos(real *x)
#endif
{
return( acos(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_asin.c0000644000175100001710000000035100000000000023237 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double asin();
double r_asin(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_asin(real *x)
#endif
{
return( asin(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_atan.c0000644000175100001710000000035100000000000023230 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double atan();
double r_atan(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_atan(real *x)
#endif
{
return( atan(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_atn2.c0000644000175100001710000000037500000000000023157 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double atan2();
double r_atn2(x,y) real *x, *y;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_atn2(real *x, real *y)
#endif
{
return( atan2(*x,*y) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_cnjg.c0000644000175100001710000000036700000000000023235 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
VOID r_cnjg(r, z) f2c_complex *r, *z;
#else
VOID r_cnjg(f2c_complex *r, f2c_complex *z)
#endif
{
	real zi = z->i;
	r->r = z->r;
	r->i = -zi;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_cos.c0000644000175100001710000000034500000000000023074 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double cos();
double r_cos(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_cos(real *x)
#endif
{
return( cos(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_cosh.c0000644000175100001710000000035100000000000023241 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double cosh();
double r_cosh(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_cosh(real *x)
#endif
{
return( cosh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_dim.c0000644000175100001710000000032600000000000023060 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double r_dim(a,b) real *a, *b;
#else
double r_dim(real *a, real *b)
#endif
{
return( *a > *b ? *a - *b : 0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_exp.c0000644000175100001710000000034500000000000023104 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double exp();
double r_exp(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_exp(real *x)
#endif
{
return( exp(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_imag.c0000644000175100001710000000030500000000000023221 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double r_imag(z) f2c_complex *z;
#else
double r_imag(f2c_complex *z)
#endif
{
return(z->i);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_int.c0000644000175100001710000000040100000000000023073 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
double r_int(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_int(real *x)
#endif
{
return( (*x>0) ? floor(*x) : -floor(- *x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_lg10.c0000644000175100001710000000042700000000000023054 0ustar00runnerdocker00000000000000#include "f2c.h"

#define log10e 0.43429448190325182765

#ifdef KR_headers
double log();
double r_lg10(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_lg10(real *x)
#endif
{
return( log10e * log(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_log.c0000644000175100001710000000034500000000000023071 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double log();
double r_log(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_log(real *x)
#endif
{
return( log(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_mod.c0000644000175100001710000000124600000000000023070 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
#ifdef IEEE_drem
double drem();
#else
double floor();
#endif
double r_mod(x,y) real *x, *y;
#else
#ifdef IEEE_drem
double drem(double, double);
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
#endif
double r_mod(real *x, real *y)
#endif
{
#ifdef IEEE_drem
	double xa, ya, z;
	if ((ya = *y) < 0.)
		ya = -ya;
	z = drem(xa = *x, ya);
	if (xa > 0) {
		if (z < 0)
			z += ya;
		}
	else if (z > 0)
		z -= ya;
	return z;
#else
	double quotient;
	if( (quotient = (double)*x / *y) >= 0)
		quotient = floor(quotient);
	else
		quotient = -floor(-quotient);
	return(*x - (*y) * quotient );
#endif
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_nint.c0000644000175100001710000000041500000000000023256 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double floor();
double r_nint(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_nint(real *x)
#endif
{
return( (*x)>=0 ?
	floor(*x + .5) : -floor(.5 - *x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_sign.c0000644000175100001710000000037000000000000023246 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double r_sign(a,b) real *a, *b;
#else
double r_sign(real *a, real *b)
#endif
{
double x;
x = (*a >= 0 ? *a : - *a);
return( *b >= 0 ? x : -x);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_sin.c0000644000175100001710000000034500000000000023101 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sin();
double r_sin(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_sin(real *x)
#endif
{
return( sin(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_sinh.c0000644000175100001710000000035100000000000023246 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sinh();
double r_sinh(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_sinh(real *x)
#endif
{
return( sinh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_sqrt.c0000644000175100001710000000035100000000000023276 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sqrt();
double r_sqrt(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_sqrt(real *x)
#endif
{
return( sqrt(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_tan.c0000644000175100001710000000034500000000000023072 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double tan();
double r_tan(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_tan(real *x)
#endif
{
return( tan(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/r_tanh.c0000644000175100001710000000035100000000000023237 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double tanh();
double r_tanh(x) real *x;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
double r_tanh(real *x)
#endif
{
return( tanh(*x) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rawio.h0000644000175100001710000000131600000000000023114 0ustar00runnerdocker00000000000000#ifndef KR_headers
#ifdef MSDOS
#include "io.h"
#ifndef WATCOM
#define close _close
#define creat _creat
#define open _open
#define read _read
#define write _write
#endif /*WATCOM*/
#endif /*MSDOS*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MSDOS
#ifdef OPEN_DECL
extern int creat(const char*,int), open(const char*,int);
#endif
extern int close(int);
extern int read(int,void*,size_t), write(int,void*,size_t);
extern int unlink(const char*);
#ifndef _POSIX_SOURCE
#ifndef NON_UNIX_STDIO
extern FILE *fdopen(int, const char*);
#endif
#endif
#endif /*KR_HEADERS*/

extern char *mktemp(char*);

#ifdef __cplusplus
	}
#endif
#endif

#include "fcntl.h"

#ifndef O_WRONLY
#define O_RDONLY 0
#define O_WRONLY 1
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rdfmt.c0000644000175100001710000002133500000000000023105 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"

#ifdef KR_headers
extern double atof();
#define Const /*nothing*/
#else
#define Const const
#undef abs
#undef min
#undef max
#include "stdlib.h"
#endif

#include "fmt.h"
#include "fp.h"
#include "ctype.h"
#ifdef __cplusplus
extern "C" {
#endif

 static int
#ifdef KR_headers
rd_Z(n,w,len) Uint *n; ftnlen len;
#else
rd_Z(Uint *n, int w, ftnlen len)
#endif
{
	long x[9];
	char *s, *s0, *s1, *se, *t;
	Const char *sc;
	int ch, i, w1, w2;
	static char hex[256];
	static int one = 1;
	int bad = 0;

	if (!hex['0']) {
		sc = "0123456789";
		while(ch = *sc++)
			hex[ch] = ch - '0' + 1;
		sc = "ABCDEF";
		while(ch = *sc++)
			hex[ch] = hex[ch + 'a' - 'A'] = ch - 'A' + 11;
		}
	s = s0 = (char *)x;
	s1 = (char *)&x[4];
	se = (char *)&x[8];
	if (len > 4*sizeof(long))
		return errno = 117;
	while (w) {
		GET(ch);
		if (ch==',' || ch=='\n')
			break;
		w--;
		if (ch > ' ') {
			if (!hex[ch & 0xff])
				bad++;
			*s++ = ch;
			if (s == se) {
				/* discard excess characters */
				for(t = s0, s = s1; t < s1;)
					*t++ = *s++;
				s = s1;
				}
			}
		}
	if (bad)
		return errno = 115;
	w = (int)len;
	w1 = s - s0;
	w2 = w1+1 >> 1;
	t = (char *)n;
	if (*(char *)&one) {
		/* little endian */
		t += w - 1;
		i = -1;
		}
	else
		i = 1;
	for(; w > w2; t += i, --w)
		*t = 0;
	if (!w)
		return 0;
	if (w < w2)
		s0 = s - (w << 1);
	else if (w1 & 1) {
		*t = hex[*s0++ & 0xff] - 1;
		if (!--w)
			return 0;
		t += i;
		}
	do {
		*t = hex[*s0 & 0xff]-1 << 4 | hex[s0[1] & 0xff]-1;
		t += i;
		s0 += 2;
		}
		while(--w);
	return 0;
	}

 static int
#ifdef KR_headers
rd_I(n,w,len, base) Uint *n; int w; ftnlen len; register int base;
#else
rd_I(Uint *n, int w, ftnlen len, register int base)
#endif
{
	int ch, sign;
	longint x = 0;

	if (w <= 0)
		goto have_x;
	for(;;) {
		GET(ch);
		if (ch != ' ')
			break;
		if (!--w)
			goto have_x;
		}
	sign = 0;
	switch(ch) {
	  case ',':
	  case '\n':
		w = 0;
		goto have_x;
	  case '-':
		sign = 1;
	  case '+':
		break;
	  default:
		if (ch >= '0' && ch <= '9') {
			x = ch - '0';
			break;
			}
		goto have_x;
		}
	while(--w) {
		GET(ch);
		if (ch >= '0' && ch <= '9') {
			x = x*base + ch - '0';
			continue;
			}
		if (ch != ' ') {
			if (ch == '\n' || ch == ',')
				w = 0;
			break;
			}
		if (f__cblank)
			x *= base;
		}
	if (sign)
		x = -x;
 have_x:
	if(len == sizeof(integer))
		n->il=x;
	else if(len == sizeof(char))
		n->ic = (char)x;
#ifdef Allow_TYQUAD
	else if (len == sizeof(longint))
		n->ili = x;
#endif
	else
		n->is = (short)x;
	if (w) {
		while(--w)
			GET(ch);
		return errno = 115;
		}
	return 0;
}

 static int
#ifdef KR_headers
rd_L(n,w,len) ftnint *n; ftnlen len;
#else
rd_L(ftnint *n, int w, ftnlen len)
#endif
{	int ch, dot, lv;

	if (w <= 0)
		goto bad;
	for(;;) {
		GET(ch);
		--w;
		if (ch != ' ')
			break;
		if (!w)
			goto bad;
		}
	dot = 0;
 retry:
	switch(ch) {
	  case '.':
		if (dot++ || !w)
			goto bad;
		GET(ch);
		--w;
		goto retry;
	  case 't':
	  case 'T':
		lv = 1;
		break;
	  case 'f':
	  case 'F':
		lv = 0;
		break;
	  default:
 bad:
		for(; w > 0; --w)
			GET(ch);
		/* no break */
	  case ',':
	  case '\n':
		return errno = 116;
		}
	switch(len) {
		case sizeof(char):	*(char *)n = (char)lv;	 break;
		case sizeof(short):	*(short *)n = (short)lv; break;
		default:		*n = lv;
		}
	while(w-- > 0) {
		GET(ch);
		if (ch == ',' || ch == '\n')
			break;
		}
	return 0;
}

 static int
#ifdef KR_headers
rd_F(p, w, d, len) ufloat *p; ftnlen len;
#else
rd_F(ufloat *p, int w, int d, ftnlen len)
#endif
{
	char s[FMAX+EXPMAXDIGS+4];
	register int ch;
	register char *sp, *spe, *sp1;
	double x;
	int scale1, se;
	long e, exp;

	sp1 = sp = s;
	spe = sp + FMAX;
	exp = -d;
	x = 0.;

	do {
		GET(ch);
		w--;
		} while (ch == ' ' && w);
	switch(ch) {
		case '-': *sp++ = ch; sp1++; spe++;
		case '+':
			if (!w) goto zero;
			--w;
			GET(ch);
		}
	while(ch == ' ') {
blankdrop:
		if (!w--) goto zero; GET(ch); }
	while(ch == '0')
		{ if (!w--) goto zero; GET(ch); }
	if (ch == ' ' && f__cblank)
		goto blankdrop;
	scale1 = f__scale;
	while(isdigit(ch)) {
digloop1:
		if (sp < spe) *sp++ = ch;
		else ++exp;
digloop1e:
		if (!w--) goto done;
		GET(ch);
		}
	if (ch == ' ') {
		if (f__cblank)
			{ ch = '0'; goto digloop1; }
		goto digloop1e;
		}
	if (ch == '.') {
		exp += d;
		if (!w--) goto done;
		GET(ch);
		if (sp == sp1) { /* no digits yet */
			while(ch == '0') {
skip01:
				--exp;
skip0:
				if (!w--) goto done;
				GET(ch);
				}
			if (ch == ' ') {
				if (f__cblank) goto skip01;
				goto skip0;
				}
			}
		while(isdigit(ch)) {
digloop2:
			if (sp < spe)
				{ *sp++ = ch; --exp; }
digloop2e:
			if (!w--) goto done;
			GET(ch);
			}
		if (ch == ' ') {
			if (f__cblank)
				{ ch = '0'; goto digloop2; }
			goto digloop2e;
			}
		}
	switch(ch) {
	  default:
		break;
	  case '-': se = 1; goto signonly;
	  case '+': se = 0; goto signonly;
	  case 'e':
	  case 'E':
	  case 'd':
	  case 'D':
		if (!w--)
			goto bad;
		GET(ch);
		while(ch == ' ') {
			if (!w--)
				goto bad;
			GET(ch);
			}
		se = 0;
	  	switch(ch) {
		  case '-': se = 1;
		  case '+':
signonly:
			if (!w--)
				goto bad;
			GET(ch);
			}
		while(ch == ' ') {
			if (!w--)
				goto bad;
			GET(ch);
			}
		if (!isdigit(ch))
			goto bad;

		e = ch - '0';
		for(;;) {
			if (!w--)
				{ ch = '\n'; break; }
			GET(ch);
			if (!isdigit(ch)) {
				if (ch == ' ') {
					if (f__cblank)
						ch = '0';
					else continue;
					}
				else
					break;
				}
			e = 10*e + ch - '0';
			if (e > EXPMAX && sp > sp1)
				goto bad;
			}
		if (se)
			exp -= e;
		else
			exp += e;
		scale1 = 0;
		}
	switch(ch) {
	  case '\n':
	  case ',':
		break;
	  default:
bad:
		return (errno = 115);
		}
done:
	if (sp > sp1) {
		while(*--sp == '0')
			++exp;
		if (exp -= scale1)
			sprintf(sp+1, "e%ld", exp);
		else
			sp[1] = 0;
		x = atof(s);
		}
zero:
	if (len == sizeof(real))
		p->pf = x;
	else
		p->pd = x;
	return(0);
	}


 static int
#ifdef KR_headers
rd_A(p,len) char *p; ftnlen len;
#else
rd_A(char *p, ftnlen len)
#endif
{	int i,ch;
	for(i=0;i=len)
	{	for(i=0;i0;f__cursor--) if((ch=(*f__getn)())<0) return(ch);
	if(f__cursor<0)
	{	if(f__recpos+f__cursor < 0) /*err(elist->cierr,110,"fmt")*/
			f__cursor = -f__recpos;	/* is this in the standard? */
		if(f__external == 0) {
			extern char *f__icptr;
			f__icptr += f__cursor;
		}
		else if(f__curunit && f__curunit->useek)
			(void) FSEEK(f__cf, f__cursor,SEEK_CUR);
		else
			err(f__elist->cierr,106,"fmt");
		f__recpos += f__cursor;
		f__cursor=0;
	}
	switch(p->op)
	{
	default: fprintf(stderr,"rd_ed, unexpected code: %d\n", p->op);
		sig_die(f__fmtbuf, 1);
	case IM:
	case I: ch = rd_I((Uint *)ptr,p->p1,len, 10);
		break;

		/* O and OM don't work right for character, double, complex, */
		/* or doublecomplex, and they differ from Fortran 90 in */
		/* showing a minus sign for negative values. */

	case OM:
	case O: ch = rd_I((Uint *)ptr, p->p1, len, 8);
		break;
	case L: ch = rd_L((ftnint *)ptr,p->p1,len);
		break;
	case A:	ch = rd_A(ptr,len);
		break;
	case AW:
		ch = rd_AW(ptr,p->p1,len);
		break;
	case E: case EE:
	case D:
	case G:
	case GE:
	case F:	ch = rd_F((ufloat *)ptr,p->p1,p->p2.i[0],len);
		break;

		/* Z and ZM assume 8-bit bytes. */

	case ZM:
	case Z:
		ch = rd_Z((Uint *)ptr, p->p1, len);
		break;
	}
	if(ch == 0) return(ch);
	else if(ch == EOF) return(EOF);
	if (f__cf)
		clearerr(f__cf);
	return(errno);
}

 int
#ifdef KR_headers
rd_ned(p) struct syl *p;
#else
rd_ned(struct syl *p)
#endif
{
	switch(p->op)
	{
	default: fprintf(stderr,"rd_ned, unexpected code: %d\n", p->op);
		sig_die(f__fmtbuf, 1);
	case APOS:
		return(rd_POS(p->p2.s));
	case H:	return(rd_H(p->p1,p->p2.s));
	case SLASH: return((*f__donewrec)());
	case TR:
	case X:	f__cursor += p->p1;
		return(1);
	case T: f__cursor=p->p1-f__recpos - 1;
		return(1);
	case TL: f__cursor -= p->p1;
		if(f__cursor < -f__recpos)	/* TL1000, 1X */
			f__cursor = -f__recpos;
		return(1);
	}
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rewind.c0000644000175100001710000000073300000000000023260 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef KR_headers
integer f_rew(a) alist *a;
#else
integer f_rew(alist *a)
#endif
{
	unit *b;
	if(a->aunit>=MXUNIT || a->aunit<0)
		err(a->aerr,101,"rewind");
	b = &f__units[a->aunit];
	if(b->ufd == NULL || b->uwrt == 3)
		return(0);
	if(!b->useek)
		err(a->aerr,106,"rewind")
	if(b->uwrt) {
		(void) t_runc(a);
		b->uwrt = 3;
		}
	rewind(b->ufd);
	b->uend=0;
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rsfe.c0000644000175100001710000000272400000000000022731 0ustar00runnerdocker00000000000000/* read sequential formatted external */
#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif

 int
xrd_SL(Void)
{	int ch;
	if(!f__curunit->uend)
		while((ch=getc(f__cf))!='\n')
			if (ch == EOF) {
				f__curunit->uend = 1;
				break;
				}
	f__cursor=f__recpos=0;
	return(1);
}

 int
x_getc(Void)
{	int ch;
	if(f__curunit->uend) return(EOF);
	ch = getc(f__cf);
	if(ch!=EOF && ch!='\n')
	{	f__recpos++;
		return(ch);
	}
	if(ch=='\n')
	{	(void) ungetc(ch,f__cf);
		return(ch);
	}
	if(f__curunit->uend || feof(f__cf))
	{	errno=0;
		f__curunit->uend=1;
		return(-1);
	}
	return(-1);
}

 int
x_endp(Void)
{
	xrd_SL();
	return f__curunit->uend == 1 ? EOF : 0;
}

 int
x_rev(Void)
{
	(void) xrd_SL();
	return(0);
}
#ifdef KR_headers
integer s_rsfe(a) cilist *a; /* start */
#else
integer s_rsfe(cilist *a) /* start */
#endif
{	int n;
	if(!f__init) f_init();
	f__reading=1;
	f__sequential=1;
	f__formatted=1;
	f__external=1;
	if(n=c_sfe(a)) return(n);
	f__elist=a;
	f__cursor=f__recpos=0;
	f__scale=0;
	f__fmtbuf=a->cifmt;
	f__cf=f__curunit->ufd;
	if(pars_f(f__fmtbuf)<0) err(a->cierr,100,"startio");
	f__getn= x_getc;
	f__doed= rd_ed;
	f__doned= rd_ned;
	fmt_bg();
	f__doend=x_endp;
	f__donewrec=xrd_SL;
	f__dorevert=x_rev;
	f__cblank=f__curunit->ublnk;
	f__cplus=0;
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr,errno,"read start");
	if(f__curunit->uend)
		err(f__elist->ciend,(EOF),"read start");
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rsli.c0000644000175100001710000000337100000000000022742 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "lio.h"
#include "fmt.h" /* for f__doend */
#ifdef __cplusplus
extern "C" {
#endif

extern flag f__lquit;
extern int f__lcount;
extern char *f__icptr;
extern char *f__icend;
extern icilist *f__svic;
extern int f__icnum, f__recpos;

static int i_getc(Void)
{
	if(f__recpos >= f__svic->icirlen) {
		if (f__recpos++ == f__svic->icirlen)
			return '\n';
		z_rnew();
		}
	f__recpos++;
	if(f__icptr >= f__icend)
		return EOF;
	return(*f__icptr++);
	}

 static
#ifdef KR_headers
int i_ungetc(ch, f) int ch; FILE *f;
#else
int i_ungetc(int ch, FILE *f)
#endif
{
	if (--f__recpos == f__svic->icirlen)
		return '\n';
	if (f__recpos < -1)
		err(f__svic->icierr,110,"recend");
	/* *--icptr == ch, and icptr may point to read-only memory */
	return *--f__icptr /* = ch */;
	}

 static void
#ifdef KR_headers
c_lir(a) icilist *a;
#else
c_lir(icilist *a)
#endif
{
	extern int l_eof;
	f__reading = 1;
	f__external = 0;
	f__formatted = 1;
	f__svic = a;
	L_len = a->icirlen;
	f__recpos = -1;
	f__icnum = f__recpos = 0;
	f__cursor = 0;
	l_getc = i_getc;
	l_ungetc = i_ungetc;
	l_eof = 0;
	f__icptr = a->iciunit;
	f__icend = f__icptr + a->icirlen*a->icirnum;
	f__cf = 0;
	f__curunit = 0;
	f__elist = (cilist *)a;
	}


#ifdef KR_headers
integer s_rsli(a) icilist *a;
#else
integer s_rsli(icilist *a)
#endif
{
	f__lioproc = l_read;
	f__lquit = 0;
	f__lcount = 0;
	c_lir(a);
	f__doend = 0;
	return(0);
	}

integer e_rsli(Void)
{ return 0; }

#ifdef KR_headers
integer s_rsni(a) icilist *a;
#else
extern int x_rsne(cilist*);

integer s_rsni(icilist *a)
#endif
{
	extern int nml_read;
	integer rv;
	cilist ca;
	ca.ciend = a->iciend;
	ca.cierr = a->icierr;
	ca.cifmt = a->icifmt;
	c_lir(a);
	rv = x_rsne(&ca);
	nml_read = 0;
	return rv;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/rsne.c0000644000175100001710000002637000000000000022744 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "lio.h"
#include 

#define MAX_NL_CACHE 3	/* maximum number of namelist hash tables to cache */
#define MAXDIM 20	/* maximum number of subscripts */

 struct dimen {
	ftnlen extent;
	ftnlen curval;
	ftnlen delta;
	ftnlen stride;
	};
 typedef struct dimen dimen;

 struct hashentry {
	struct hashentry *next;
	char *name;
	Vardesc *vd;
	};
 typedef struct hashentry hashentry;

 struct hashtab {
	struct hashtab *next;
	Namelist *nl;
	int htsize;
	hashentry *tab[1];
	};
 typedef struct hashtab hashtab;

 static hashtab *nl_cache;
 static int n_nlcache;
 static hashentry **zot;
 static int colonseen;
 extern ftnlen f__typesize[];

 extern flag f__lquit;
 extern int f__lcount, nml_read;
 extern int t_getc(Void);

#ifdef KR_headers
 extern char *malloc(), *memset();
#define Const /*nothing*/

#ifdef ungetc
 static int
un_getc(x,f__cf) int x; FILE *f__cf;
{ return ungetc(x,f__cf); }
#else
#define un_getc ungetc
#endif

#else
#define Const const
#undef abs
#undef min
#undef max
#include "stdlib.h"
#include "string.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef ungetc
 static int
un_getc(int x, FILE *f__cf)
{ return ungetc(x,f__cf); }
#else
#define un_getc ungetc
#endif
#endif

 static Vardesc *
#ifdef KR_headers
hash(ht, s) hashtab *ht; register char *s;
#else
hash(hashtab *ht, register char *s)
#endif
{
	register int c, x;
	register hashentry *h;
	char *s0 = s;

	for(x = 0; c = *s++; x = x & 0x4000 ? ((x << 1) & 0x7fff) + 1 : x << 1)
		x += c;
	for(h = *(zot = ht->tab + x % ht->htsize); h; h = h->next)
		if (!strcmp(s0, h->name))
			return h->vd;
	return 0;
	}

 hashtab *
#ifdef KR_headers
mk_hashtab(nl) Namelist *nl;
#else
mk_hashtab(Namelist *nl)
#endif
{
	int nht, nv;
	hashtab *ht;
	Vardesc *v, **vd, **vde;
	hashentry *he;

	hashtab **x, **x0, *y;
	for(x = &nl_cache; y = *x; x0 = x, x = &y->next)
		if (nl == y->nl)
			return y;
	if (n_nlcache >= MAX_NL_CACHE) {
		/* discard least recently used namelist hash table */
		y = *x0;
		free((char *)y->next);
		y->next = 0;
		}
	else
		n_nlcache++;
	nv = nl->nvars;
	if (nv >= 0x4000)
		nht = 0x7fff;
	else {
		for(nht = 1; nht < nv; nht <<= 1);
		nht += nht - 1;
		}
	ht = (hashtab *)malloc(sizeof(hashtab) + (nht-1)*sizeof(hashentry *)
				+ nv*sizeof(hashentry));
	if (!ht)
		return 0;
	he = (hashentry *)&ht->tab[nht];
	ht->nl = nl;
	ht->htsize = nht;
	ht->next = nl_cache;
	nl_cache = ht;
	memset((char *)ht->tab, 0, nht*sizeof(hashentry *));
	vd = nl->vars;
	vde = vd + nv;
	while(vd < vde) {
		v = *vd++;
		if (!hash(ht, v->name)) {
			he->next = *zot;
			*zot = he;
			he->name = v->name;
			he->vd = v;
			he++;
			}
		}
	return ht;
	}

static char Alpha[256], Alphanum[256];

 static VOID
nl_init(Void) {
	Const char *s;
	int c;

	if(!f__init)
		f_init();
	for(s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; c = *s++; )
		Alpha[c]
		= Alphanum[c]
		= Alpha[c + 'a' - 'A']
		= Alphanum[c + 'a' - 'A']
		= c;
	for(s = "0123456789_"; c = *s++; )
		Alphanum[c] = c;
	}

#define GETC(x) (x=(*l_getc)())
#define Ungetc(x,y) (*l_ungetc)(x,y)

 static int
#ifdef KR_headers
getname(s, slen) register char *s; int slen;
#else
getname(register char *s, int slen)
#endif
{
	register char *se = s + slen - 1;
	register int ch;

	GETC(ch);
	if (!(*s++ = Alpha[ch & 0xff])) {
		if (ch != EOF)
			ch = 115;
		errfl(f__elist->cierr, ch, "namelist read");
		}
	while(*s = Alphanum[GETC(ch) & 0xff])
		if (s < se)
			s++;
	if (ch == EOF)
		err(f__elist->cierr, EOF, "namelist read");
	if (ch > ' ')
		Ungetc(ch,f__cf);
	return *s = 0;
	}

 static int
#ifdef KR_headers
getnum(chp, val) int *chp; ftnlen *val;
#else
getnum(int *chp, ftnlen *val)
#endif
{
	register int ch, sign;
	register ftnlen x;

	while(GETC(ch) <= ' ' && ch >= 0);
	if (ch == '-') {
		sign = 1;
		GETC(ch);
		}
	else {
		sign = 0;
		if (ch == '+')
			GETC(ch);
		}
	x = ch - '0';
	if (x < 0 || x > 9)
		return 115;
	while(GETC(ch) >= '0' && ch <= '9')
		x = 10*x + ch - '0';
	while(ch <= ' ' && ch >= 0)
		GETC(ch);
	if (ch == EOF)
		return EOF;
	*val = sign ? -x : x;
	*chp = ch;
	return 0;
	}

 static int
#ifdef KR_headers
getdimen(chp, d, delta, extent, x1)
 int *chp; dimen *d; ftnlen delta, extent, *x1;
#else
getdimen(int *chp, dimen *d, ftnlen delta, ftnlen extent, ftnlen *x1)
#endif
{
	register int k;
	ftnlen x2, x3;

	if (k = getnum(chp, x1))
		return k;
	x3 = 1;
	if (*chp == ':') {
		if (k = getnum(chp, &x2))
			return k;
		x2 -= *x1;
		if (*chp == ':') {
			if (k = getnum(chp, &x3))
				return k;
			if (!x3)
				return 123;
			x2 /= x3;
			colonseen = 1;
			}
		if (x2 < 0 || x2 >= extent)
			return 123;
		d->extent = x2 + 1;
		}
	else
		d->extent = 1;
	d->curval = 0;
	d->delta = delta;
	d->stride = x3;
	return 0;
	}

#ifndef No_Namelist_Questions
 static Void
#ifdef KR_headers
print_ne(a) cilist *a;
#else
print_ne(cilist *a)
#endif
{
	flag intext = f__external;
	int rpsave = f__recpos;
	FILE *cfsave = f__cf;
	unit *usave = f__curunit;
	cilist t;
	t = *a;
	t.ciunit = 6;
	s_wsne(&t);
	fflush(f__cf);
	f__external = intext;
	f__reading = 1;
	f__recpos = rpsave;
	f__cf = cfsave;
	f__curunit = usave;
	f__elist = a;
	}
#endif

 static char where0[] = "namelist read start ";

 int
#ifdef KR_headers
x_rsne(a) cilist *a;
#else
x_rsne(cilist *a)
#endif
{
	int ch, got1, k, n, nd, quote, readall;
	Namelist *nl;
	static char where[] = "namelist read";
	char buf[64];
	hashtab *ht;
	Vardesc *v;
	dimen *dn, *dn0, *dn1;
	ftnlen *dims, *dims1;
	ftnlen b, b0, b1, ex, no, nomax, size, span;
	ftnint no1, no2, type;
	char *vaddr;
	long iva, ivae;
	dimen dimens[MAXDIM], substr;

	if (!Alpha['a'])
		nl_init();
	f__reading=1;
	f__formatted=1;
	got1 = 0;
 top:
	for(;;) switch(GETC(ch)) {
		case EOF:
 eof:
			err(a->ciend,(EOF),where0);
		case '&':
		case '$':
			goto have_amp;
#ifndef No_Namelist_Questions
		case '?':
			print_ne(a);
			continue;
#endif
		default:
			if (ch <= ' ' && ch >= 0)
				continue;
#ifndef No_Namelist_Comments
			while(GETC(ch) != '\n')
				if (ch == EOF)
					goto eof;
#else
			errfl(a->cierr, 115, where0);
#endif
		}
 have_amp:
	if (ch = getname(buf,sizeof(buf)))
		return ch;
	nl = (Namelist *)a->cifmt;
	if (strcmp(buf, nl->name))
#ifdef No_Bad_Namelist_Skip
		errfl(a->cierr, 118, where0);
#else
	{
		fprintf(stderr,
			"Skipping namelist \"%s\": seeking namelist \"%s\".\n",
			buf, nl->name);
		fflush(stderr);
		for(;;) switch(GETC(ch)) {
			case EOF:
				err(a->ciend, EOF, where0);
			case '/':
			case '&':
			case '$':
				if (f__external)
					e_rsle();
				else
					z_rnew();
				goto top;
			case '"':
			case '\'':
				quote = ch;
 more_quoted:
				while(GETC(ch) != quote)
					if (ch == EOF)
						err(a->ciend, EOF, where0);
				if (GETC(ch) == quote)
					goto more_quoted;
				Ungetc(ch,f__cf);
			default:
				continue;
			}
		}
#endif
	ht = mk_hashtab(nl);
	if (!ht)
		errfl(f__elist->cierr, 113, where0);
	for(;;) {
		for(;;) switch(GETC(ch)) {
			case EOF:
				if (got1)
					return 0;
				err(a->ciend, EOF, where0);
			case '/':
			case '$':
			case '&':
				return 0;
			default:
				if (ch <= ' ' && ch >= 0 || ch == ',')
					continue;
				Ungetc(ch,f__cf);
				if (ch = getname(buf,sizeof(buf)))
					return ch;
				goto havename;
			}
 havename:
		v = hash(ht,buf);
		if (!v)
			errfl(a->cierr, 119, where);
		while(GETC(ch) <= ' ' && ch >= 0);
		vaddr = v->addr;
		type = v->type;
		if (type < 0) {
			size = -type;
			type = TYCHAR;
			}
		else
			size = f__typesize[type];
		ivae = size;
		iva = readall = 0;
		if (ch == '(' /*)*/ ) {
			dn = dimens;
			if (!(dims = v->dims)) {
				if (type != TYCHAR)
					errfl(a->cierr, 122, where);
				if (k = getdimen(&ch, dn, (ftnlen)size,
						(ftnlen)size, &b))
					errfl(a->cierr, k, where);
				if (ch != ')')
					errfl(a->cierr, 115, where);
				b1 = dn->extent;
				if (--b < 0 || b + b1 > size)
					return 124;
				iva += b;
				size = b1;
				while(GETC(ch) <= ' ' && ch >= 0);
				goto scalar;
				}
			nd = (int)dims[0];
			nomax = span = dims[1];
			ivae = iva + size*nomax;
			colonseen = 0;
			if (k = getdimen(&ch, dn, size, nomax, &b))
				errfl(a->cierr, k, where);
			no = dn->extent;
			b0 = dims[2];
			dims1 = dims += 3;
			ex = 1;
			for(n = 1; n++ < nd; dims++) {
				if (ch != ',')
					errfl(a->cierr, 115, where);
				dn1 = dn + 1;
				span /= *dims;
				if (k = getdimen(&ch, dn1, dn->delta**dims,
						span, &b1))
					errfl(a->cierr, k, where);
				ex *= *dims;
				b += b1*ex;
				no *= dn1->extent;
				dn = dn1;
				}
			if (ch != ')')
				errfl(a->cierr, 115, where);
			readall = 1 - colonseen;
			b -= b0;
			if (b < 0 || b >= nomax)
				errfl(a->cierr, 125, where);
			iva += size * b;
			dims = dims1;
			while(GETC(ch) <= ' ' && ch >= 0);
			no1 = 1;
			dn0 = dimens;
			if (type == TYCHAR && ch == '(' /*)*/) {
				if (k = getdimen(&ch, &substr, size, size, &b))
					errfl(a->cierr, k, where);
				if (ch != ')')
					errfl(a->cierr, 115, where);
				b1 = substr.extent;
				if (--b < 0 || b + b1 > size)
					return 124;
				iva += b;
				b0 = size;
				size = b1;
				while(GETC(ch) <= ' ' && ch >= 0);
				if (b1 < b0)
					goto delta_adj;
				}
			if (readall)
				goto delta_adj;
			for(; dn0 < dn; dn0++) {
				if (dn0->extent != *dims++ || dn0->stride != 1)
					break;
				no1 *= dn0->extent;
				}
			if (dn0 == dimens && dimens[0].stride == 1) {
				no1 = dimens[0].extent;
				dn0++;
				}
 delta_adj:
			ex = 0;
			for(dn1 = dn0; dn1 <= dn; dn1++)
				ex += (dn1->extent-1)
					* (dn1->delta *= dn1->stride);
			for(dn1 = dn; dn1 > dn0; dn1--) {
				ex -= (dn1->extent - 1) * dn1->delta;
				dn1->delta -= ex;
				}
			}
		else if (dims = v->dims) {
			no = no1 = dims[1];
			ivae = iva + no*size;
			}
		else
 scalar:
			no = no1 = 1;
		if (ch != '=')
			errfl(a->cierr, 115, where);
		got1 = nml_read = 1;
		f__lcount = 0;
	 readloop:
		for(;;) {
			if (iva >= ivae || iva < 0) {
				f__lquit = 1;
				goto mustend;
				}
			else if (iva + no1*size > ivae)
				no1 = (ivae - iva)/size;
			f__lquit = 0;
			if (k = l_read(&no1, vaddr + iva, size, type))
				return k;
			if (f__lquit == 1)
				return 0;
			if (readall) {
				iva += dn0->delta;
				if (f__lcount > 0) {
					no2 = (ivae - iva)/size;
					if (no2 > f__lcount)
						no2 = f__lcount;
					if (k = l_read(&no2, vaddr + iva,
							size, type))
						return k;
					iva += no2 * dn0->delta;
					}
				}
 mustend:
			GETC(ch);
			if (readall)
				if (iva >= ivae)
					readall = 0;
				else for(;;) {
					switch(ch) {
						case ' ':
						case '\t':
						case '\n':
							GETC(ch);
							continue;
						}
					break;
					}
			if (ch == '/' || ch == '$' || ch == '&') {
				f__lquit = 1;
				return 0;
				}
			else if (f__lquit) {
				while(ch <= ' ' && ch >= 0)
					GETC(ch);
				Ungetc(ch,f__cf);
				if (!Alpha[ch & 0xff] && ch >= 0)
					errfl(a->cierr, 125, where);
				break;
				}
			Ungetc(ch,f__cf);
			if (readall && !Alpha[ch & 0xff])
				goto readloop;
			if ((no -= no1) <= 0)
				break;
			for(dn1 = dn0; dn1 <= dn; dn1++) {
				if (++dn1->curval < dn1->extent) {
					iva += dn1->delta;
					goto readloop;
					}
				dn1->curval = 0;
				}
			break;
			}
		}
	}

 integer
#ifdef KR_headers
s_rsne(a) cilist *a;
#else
s_rsne(cilist *a)
#endif
{
	extern int l_eof;
	int n;

	f__external=1;
	l_eof = 0;
	if(n = c_le(a))
		return n;
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr,errno,where0);
	l_getc = t_getc;
	l_ungetc = un_getc;
	f__doend = xrd_SL;
	n = x_rsne(a);
	nml_read = 0;
	if (n)
		return n;
	return e_rsle();
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_cat.c0000644000175100001710000000266200000000000023064 0ustar00runnerdocker00000000000000/* Unless compiled with -DNO_OVERWRITE, this variant of s_cat allows the
 * target of a concatenation to appear on its right-hand side (contrary
 * to the Fortran 77 Standard, but in accordance with Fortran 90).
 */

#include "f2c.h"
#ifndef NO_OVERWRITE
#include "stdio.h"
#undef abs
#ifdef KR_headers
 extern char *F77_aloc();
 extern void free();
 extern void exit_();
#else
#undef min
#undef max
#include "stdlib.h"
extern
#ifdef __cplusplus
	"C"
#endif
	char *F77_aloc(ftnlen, const char*);
#endif
#include "string.h"
#endif /* NO_OVERWRITE */

#ifdef __cplusplus
extern "C" {
#endif

 VOID
#ifdef KR_headers
s_cat(lp, rpp, rnp, np, ll) char *lp, *rpp[]; ftnint rnp[], *np; ftnlen ll;
#else
s_cat(char *lp, char *rpp[], ftnint rnp[], ftnint *np, ftnlen ll)
#endif
{
	ftnlen i, nc;
	char *rp;
	ftnlen n = *np;
#ifndef NO_OVERWRITE
	ftnlen L, m;
	char *lp0, *lp1;

	lp0 = 0;
	lp1 = lp;
	L = ll;
	i = 0;
	while(i < n) {
		rp = rpp[i];
		m = rnp[i++];
		if (rp >= lp1 || rp + m <= lp) {
			if ((L -= m) <= 0) {
				n = i;
				break;
				}
			lp1 += m;
			continue;
			}
		lp0 = lp;
		lp = lp1 = F77_aloc(L = ll, "s_cat");
		break;
		}
	lp1 = lp;
#endif /* NO_OVERWRITE */
	for(i = 0 ; i < n ; ++i) {
		nc = ll;
		if(rnp[i] < nc)
			nc = rnp[i];
		ll -= nc;
		rp = rpp[i];
		while(--nc >= 0)
			*lp++ = *rp++;
		}
	while(--ll >= 0)
		*lp++ = ' ';
#ifndef NO_OVERWRITE
	if (lp0) {
		memcpy(lp0, lp1, L);
		free(lp1);
		}
#endif
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_cmp.c0000644000175100001710000000132200000000000023064 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

/* compare two strings */

#ifdef KR_headers
integer s_cmp(a0, b0, la, lb) char *a0, *b0; ftnlen la, lb;
#else
integer s_cmp(char *a0, char *b0, ftnlen la, ftnlen lb)
#endif
{
register unsigned char *a, *aend, *b, *bend;
a = (unsigned char *)a0;
b = (unsigned char *)b0;
aend = a + la;
bend = b + lb;

if(la <= lb)
	{
	while(a < aend)
		if(*a != *b)
			return( *a - *b );
		else
			{ ++a; ++b; }

	while(b < bend)
		if(*b != ' ')
			return( ' ' - *b );
		else	++b;
	}

else
	{
	while(b < bend)
		if(*a == *b)
			{ ++a; ++b; }
		else
			return( *a - *b );
	while(a < aend)
		if(*a != ' ')
			return(*a - ' ');
		else	++a;
	}
return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_copy.c0000644000175100001710000000200000000000000023251 0ustar00runnerdocker00000000000000/* Unless compiled with -DNO_OVERWRITE, this variant of s_copy allows the
 * target of an assignment to appear on its right-hand side (contrary
 * to the Fortran 77 Standard, but in accordance with Fortran 90),
 * as in  a(2:5) = a(4:7) .
 */

#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

/* assign strings:  a = b */

#ifdef KR_headers
VOID s_copy(a, b, la, lb) register char *a, *b; ftnlen la, lb;
#else
void s_copy(register char *a, register char *b, ftnlen la, ftnlen lb)
#endif
{
	register char *aend, *bend;

	aend = a + la;

	if(la <= lb)
#ifndef NO_OVERWRITE
		if (a <= b || a >= b + la)
#endif
			while(a < aend)
				*a++ = *b++;
#ifndef NO_OVERWRITE
		else
			for(b += la; a < aend; )
				*--aend = *--b;
#endif

	else {
		bend = b + lb;
#ifndef NO_OVERWRITE
		if (a <= b || a >= bend)
#endif
			while(b < bend)
				*a++ = *b++;
#ifndef NO_OVERWRITE
		else {
			a += lb;
			while(b < bend)
				*--a = *--bend;
			a += lb;
			}
#endif
		while(a < aend)
			*a++ = ' ';
		}
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_paus.c0000644000175100001710000000312100000000000023254 0ustar00runnerdocker00000000000000#include "stdio.h"
#include "f2c.h"
#define PAUSESIG 15

#include "signal1.h"
#ifdef KR_headers
#define Void /* void */
#define Int /* int */
#else
#define Void void
#define Int int
#undef abs
#undef min
#undef max
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
extern "C" {
#endif
extern int getpid(void), isatty(int), pause(void);
#endif

extern VOID f_exit(Void);

#ifndef MSDOS
 static VOID
waitpause(Sigarg)
{	Use_Sigarg;
	return;
	}
#endif

 static VOID
#ifdef KR_headers
s_1paus(fin) FILE *fin;
#else
s_1paus(FILE *fin)
#endif
{
	fprintf(stderr,
	"To resume execution, type go.  Other input will terminate the job.\n");
	fflush(stderr);
	if( getc(fin)!='g' || getc(fin)!='o' || getc(fin)!='\n' ) {
		fprintf(stderr, "STOP\n");
#ifdef NO_ONEXIT
		f_exit();
#endif
		exit(0);
		}
	}

 int
#ifdef KR_headers
s_paus(s, n) char *s; ftnlen n;
#else
s_paus(char *s, ftnlen n)
#endif
{
	fprintf(stderr, "PAUSE ");
	if(n > 0)
		fprintf(stderr, " %.*s", (int)n, s);
	fprintf(stderr, " statement executed\n");
	if( isatty(fileno(stdin)) )
		s_1paus(stdin);
	else {
#ifdef MSDOS
		FILE *fin;
		fin = fopen("con", "r");
		if (!fin) {
			fprintf(stderr, "s_paus: can't open con!\n");
			fflush(stderr);
			exit(1);
			}
		s_1paus(fin);
		fclose(fin);
#else
		fprintf(stderr,
		"To resume execution, execute a   kill -%d %d   command\n",
			PAUSESIG, getpid() );
		signal1(PAUSESIG, waitpause);
		fflush(stderr);
		pause();
#endif
		}
	fprintf(stderr, "Execution resumes after PAUSE.\n");
	fflush(stderr);
	return 0; /* NOT REACHED */
#ifdef __cplusplus
	}
#endif
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_rnge.c0000644000175100001710000000136700000000000023251 0ustar00runnerdocker00000000000000#include "stdio.h"
#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

/* called when a subscript is out of range */

#ifdef KR_headers
extern VOID sig_die();
integer s_rnge(varn, offset, procn, line) char *varn, *procn; ftnint offset, line;
#else
extern VOID sig_die(const char*,int);
integer s_rnge(char *varn, ftnint offset, char *procn, ftnint line)
#endif
{
register int i;

fprintf(stderr, "Subscript out of range on file line %ld, procedure ",
	(long)line);
while((i = *procn) && i != '_' && i != ' ')
	putc(*procn++, stderr);
fprintf(stderr, ".\nAttempt to access the %ld-th element of variable ",
	(long)offset+1);
while((i = *varn) && i != ' ')
	putc(*varn++, stderr);
sig_die(".", 1);
return 0;	/* not reached */
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/s_stop.c0000644000175100001710000000137200000000000023277 0ustar00runnerdocker00000000000000#include "stdio.h"
#include "f2c.h"

#ifdef KR_headers
extern void f_exit();
int s_stop(s, n) char *s; ftnlen n;
#else
#undef abs
#undef min
#undef max
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
extern "C" {
#endif
void f_exit(void);

int s_stop(char *s, ftnlen n)
#endif
{
int i;

if(n > 0)
	{
	fprintf(stderr, "STOP ");
	for(i = 0; iciunit];
	if(a->ciunit >= MXUNIT || a->ciunit<0)
		err(a->cierr,101,"startio");
	if(p->ufd==NULL && fk_open(SEQ,FMT,a->ciunit)) err(a->cierr,114,"sfe")
	if(!p->ufmt) err(a->cierr,102,"sfe")
	return(0);
}
integer e_wsfe(Void)
{
	int n = en_fio();
	f__fmtbuf = NULL;
#ifdef ALWAYS_FLUSH
	if (!n && fflush(f__cf))
		err(f__elist->cierr, errno, "write end");
#endif
	return n;
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/sig_die.c0000644000175100001710000000126100000000000023370 0ustar00runnerdocker00000000000000#include "stdio.h"
#include "signal.h"

#ifndef SIGIOT
#ifdef SIGABRT
#define SIGIOT SIGABRT
#endif
#endif

#ifdef KR_headers
void sig_die(s, kill) char *s; int kill;
#else
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
extern "C" {
#endif
 extern void f_exit(void);

void sig_die(const char *s, int kill)
#endif
{
	/* print error message, then clear buffers */
	fprintf(stderr, "%s\n", s);

	if(kill)
		{
		fflush(stderr);
		f_exit();
		fflush(stderr);
		/* now get a core */
#ifdef SIGIOT
		signal(SIGIOT, SIG_DFL);
#endif
		abort();
		}
	else {
#ifdef NO_ONEXIT
		f_exit();
#endif
		exit(1);
		}
	}
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/signal1.h0000644000175100001710000000151200000000000023327 0ustar00runnerdocker00000000000000/* You may need to adjust the definition of signal1 to supply a */
/* cast to the correct argument type.  This detail is system- and */
/* compiler-dependent.   The #define below assumes signal.h declares */
/* type SIG_PF for the signal function's second argument. */

/* For some C++ compilers, "#define Sigarg_t ..." may be appropriate. */

#include 

#ifndef Sigret_t
#define Sigret_t void
#endif
#ifndef Sigarg_t
#ifdef KR_headers
#define Sigarg_t
#else
#define Sigarg_t int
#endif
#endif /*Sigarg_t*/

#ifdef USE_SIG_PF	/* compile with -DUSE_SIG_PF under IRIX */
#define sig_pf SIG_PF
#else
typedef Sigret_t (*sig_pf)(Sigarg_t);
#endif

#define signal1(a,b) signal(a,(sig_pf)b)

#ifdef __cplusplus
#define Sigarg ...
#define Use_Sigarg
#else
#define Sigarg Int n
#define Use_Sigarg n = n	/* shut up compiler warning */
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/signal1.h00000644000175100001710000000151200000000000023407 0ustar00runnerdocker00000000000000/* You may need to adjust the definition of signal1 to supply a */
/* cast to the correct argument type.  This detail is system- and */
/* compiler-dependent.   The #define below assumes signal.h declares */
/* type SIG_PF for the signal function's second argument. */

/* For some C++ compilers, "#define Sigarg_t ..." may be appropriate. */

#include 

#ifndef Sigret_t
#define Sigret_t void
#endif
#ifndef Sigarg_t
#ifdef KR_headers
#define Sigarg_t
#else
#define Sigarg_t int
#endif
#endif /*Sigarg_t*/

#ifdef USE_SIG_PF	/* compile with -DUSE_SIG_PF under IRIX */
#define sig_pf SIG_PF
#else
typedef Sigret_t (*sig_pf)(Sigarg_t);
#endif

#define signal1(a,b) signal(a,(sig_pf)b)

#ifdef __cplusplus
#define Sigarg ...
#define Use_Sigarg
#else
#define Sigarg Int n
#define Use_Sigarg n = n	/* shut up compiler warning */
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/signal_.c0000644000175100001710000000045300000000000023403 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "signal1.h"
#ifdef __cplusplus
extern "C" {
#endif

 ftnint
#ifdef KR_headers
signal_(sigp, proc) integer *sigp; sig_pf proc;
#else
signal_(integer *sigp, sig_pf proc)
#endif
{
	int sig;
	sig = (int)*sigp;

	return (ftnint)signal(sig, proc);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/signbit.c0000644000175100001710000000051200000000000023422 0ustar00runnerdocker00000000000000#include "arith.h"

#ifndef Long
#define Long long
#endif

 int
#ifdef KR_headers
signbit_f2c(x) double *x;
#else
signbit_f2c(double *x)
#endif
{
#ifdef IEEE_MC68k
	if (*(Long*)x & 0x80000000)
		return 1;
#else
#ifdef IEEE_8087
	if (((Long*)x)[1] & 0x80000000)
		return 1;
#endif /*IEEE_8087*/
#endif /*IEEE_MC68k*/
	return 0;
	}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/sue.c0000644000175100001710000000351100000000000022561 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif
extern uiolen f__reclen;
OFF_T f__recloc;

 int
#ifdef KR_headers
c_sue(a) cilist *a;
#else
c_sue(cilist *a)
#endif
{
	f__external=f__sequential=1;
	f__formatted=0;
	f__curunit = &f__units[a->ciunit];
	if(a->ciunit >= MXUNIT || a->ciunit < 0)
		err(a->cierr,101,"startio");
	f__elist=a;
	if(f__curunit->ufd==NULL && fk_open(SEQ,UNF,a->ciunit))
		err(a->cierr,114,"sue");
	f__cf=f__curunit->ufd;
	if(f__curunit->ufmt) err(a->cierr,103,"sue")
	if(!f__curunit->useek) err(a->cierr,103,"sue")
	return(0);
}
#ifdef KR_headers
integer s_rsue(a) cilist *a;
#else
integer s_rsue(cilist *a)
#endif
{
	int n;
	if(!f__init) f_init();
	f__reading=1;
	if(n=c_sue(a)) return(n);
	f__recpos=0;
	if(f__curunit->uwrt && f__nowreading(f__curunit))
		err(a->cierr, errno, "read start");
	if(fread((char *)&f__reclen,sizeof(uiolen),1,f__cf)
		!= 1)
	{	if(feof(f__cf))
		{	f__curunit->uend = 1;
			err(a->ciend, EOF, "start");
		}
		clearerr(f__cf);
		err(a->cierr, errno, "start");
	}
	return(0);
}
#ifdef KR_headers
integer s_wsue(a) cilist *a;
#else
integer s_wsue(cilist *a)
#endif
{
	int n;
	if(!f__init) f_init();
	if(n=c_sue(a)) return(n);
	f__reading=0;
	f__reclen=0;
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr, errno, "write start");
	f__recloc=FTELL(f__cf);
	FSEEK(f__cf,(OFF_T)sizeof(uiolen),SEEK_CUR);
	return(0);
}
integer e_wsue(Void)
{	OFF_T loc;
	fwrite((char *)&f__reclen,sizeof(uiolen),1,f__cf);
#ifdef ALWAYS_FLUSH
	if (fflush(f__cf))
		err(f__elist->cierr, errno, "write end");
#endif
	loc=FTELL(f__cf);
	FSEEK(f__cf,f__recloc,SEEK_SET);
	fwrite((char *)&f__reclen,sizeof(uiolen),1,f__cf);
	FSEEK(f__cf,loc,SEEK_SET);
	return(0);
}
integer e_rsue(Void)
{
	FSEEK(f__cf,(OFF_T)(f__reclen-f__recpos+sizeof(uiolen)),SEEK_CUR);
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/sysdep1.h0000644000175100001710000000257500000000000023373 0ustar00runnerdocker00000000000000#ifndef SYSDEP_H_INCLUDED
#define SYSDEP_H_INCLUDED

#ifdef _MSC_VER
#define FTRUNCATE chsize
#endif

#undef USE_LARGEFILE
#ifndef NO_LONG_LONG

#ifdef __sun__
#define USE_LARGEFILE
#define OFF_T off64_t
#endif

#ifdef __linux__
#define USE_LARGEFILE

#ifdef __GLIBC__
#define OFF_T __off64_t
#else
#define OFF_T off64_t
#endif /* __GLIBC__ */
#endif /* __linux__ */

#ifdef _AIX43
#define _LARGE_FILES
#define _LARGE_FILE_API
#define USE_LARGEFILE
#endif /*_AIX43*/

#ifdef __hpux
#define _FILE64
#define _LARGEFILE64_SOURCE
#define USE_LARGEFILE
#endif /*__hpux*/

#ifdef __sgi
#define USE_LARGEFILE
#endif /*__sgi*/

#ifdef __FreeBSD__
#define OFF_T off_t
#define FSEEK fseeko
#define FTELL ftello
#endif

#ifdef USE_LARGEFILE
#ifndef OFF_T
#define OFF_T off64_t
#endif
#ifndef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE
#endif
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif
#include 
#include 
#define FOPEN fopen64
#define FREOPEN freopen64
#define FSEEK fseeko64
#define FSTAT fstat64
#define FTELL ftello64
#define FTRUNCATE ftruncate64
#define STAT stat64
#define STAT_ST stat64
#endif /*USE_LARGEFILE*/
#endif /*NO_LONG_LONG*/

#ifndef NON_UNIX_STDIO
#ifndef USE_LARGEFILE
#define _INCLUDE_POSIX_SOURCE	/* for HP-UX */
#define _INCLUDE_XOPEN_SOURCE	/* for HP-UX */
#include "sys/types.h"
#include "sys/stat.h"
#endif
#endif

#endif /*SYSDEP_H_INCLUDED*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/sysdep1.h00000644000175100001710000000234400000000000023445 0ustar00runnerdocker00000000000000#ifndef SYSDEP_H_INCLUDED
#define SYSDEP_H_INCLUDED

#ifdef _MSC_VER
#define FTRUNCATE chsize
#endif

#undef USE_LARGEFILE
#ifndef NO_LONG_LONG

#ifdef __sun__
#define USE_LARGEFILE
#define OFF_T off64_t
#endif

#ifdef __linux__
#define USE_LARGEFILE
#define OFF_T __off64_t
#endif

#ifdef _AIX43
#define _LARGE_FILES
#define _LARGE_FILE_API
#define USE_LARGEFILE
#endif /*_AIX43*/

#ifdef __hpux
#define _FILE64
#define _LARGEFILE64_SOURCE
#define USE_LARGEFILE
#endif /*__hpux*/

#ifdef __sgi
#define USE_LARGEFILE
#endif /*__sgi*/

#ifdef __FreeBSD__
#define OFF_T off_t
#define FSEEK fseeko
#define FTELL ftello
#endif

#ifdef USE_LARGEFILE
#ifndef OFF_T
#define OFF_T off64_t
#endif
#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE
#include 
#include 
#define FOPEN fopen64
#define FREOPEN freopen64
#define FSEEK fseeko64
#define FSTAT fstat64
#define FTELL ftello64
#define FTRUNCATE ftruncate64
#define STAT stat64
#define STAT_ST stat64
#endif /*USE_LARGEFILE*/
#endif /*NO_LONG_LONG*/

#ifndef NON_UNIX_STDIO
#ifndef USE_LARGEFILE
#define _INCLUDE_POSIX_SOURCE	/* for HP-UX */
#define _INCLUDE_XOPEN_SOURCE	/* for HP-UX */
#include "sys/types.h"
#include "sys/stat.h"
#endif
#endif

#endif /*SYSDEP_H_INCLUDED*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/system_.c0000644000175100001710000000121400000000000023446 0ustar00runnerdocker00000000000000/* f77 interface to system routine */

#include "f2c.h"

#ifdef KR_headers
extern char *F77_aloc();

 integer
system_(s, n) register char *s; ftnlen n;
#else
#undef abs
#undef min
#undef max
#include "stdlib.h"
#ifdef __cplusplus
extern "C" {
#endif
extern char *F77_aloc(ftnlen, const char*);

 integer
system_(register char *s, ftnlen n)
#endif
{
	char buff0[256], *buff;
	register char *bp, *blast;
	integer rv;

	buff = bp = n < sizeof(buff0)
			? buff0 : F77_aloc(n+1, "system_");
	blast = bp + n;

	while(bp < blast && *s)
		*bp++ = *s++;
	*bp = 0;
	rv = system(buff);
	if (buff != buff0)
		free(buff);
	return rv;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/typesize.c0000644000175100001710000000060600000000000023643 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

ftnlen f__typesize[] = { 0, 0, sizeof(shortint), sizeof(integer),
			sizeof(real), sizeof(doublereal),
			sizeof(f2c_complex), sizeof(doublecomplex),
			sizeof(logical), sizeof(char),
			0, sizeof(integer1),
			sizeof(logical1), sizeof(shortlogical),
#ifdef Allow_TYQUAD
			sizeof(longint),
#endif
			0};
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/uio.c0000644000175100001710000000312300000000000022560 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif
uiolen f__reclen;

 int
#ifdef KR_headers
do_us(number,ptr,len) ftnint *number; char *ptr; ftnlen len;
#else
do_us(ftnint *number, char *ptr, ftnlen len)
#endif
{
	if(f__reading)
	{
		f__recpos += (int)(*number * len);
		if(f__recpos>f__reclen)
			err(f__elist->cierr, 110, "do_us");
		if (fread(ptr,(int)len,(int)(*number),f__cf) != *number)
			err(f__elist->ciend, EOF, "do_us");
		return(0);
	}
	else
	{
		f__reclen += *number * len;
		(void) fwrite(ptr,(int)len,(int)(*number),f__cf);
		return(0);
	}
}
#ifdef KR_headers
integer do_ud(number,ptr,len) ftnint *number; char *ptr; ftnlen len;
#else
integer do_ud(ftnint *number, char *ptr, ftnlen len)
#endif
{
	f__recpos += (int)(*number * len);
	if(f__recpos > f__curunit->url && f__curunit->url!=1)
		err(f__elist->cierr,110,"do_ud");
	if(f__reading)
	{
#ifdef Pad_UDread
#ifdef KR_headers
	int i;
#else
	size_t i;
#endif
		if (!(i = fread(ptr,(int)len,(int)(*number),f__cf))
		 && !(f__recpos - *number*len))
			err(f__elist->cierr,EOF,"do_ud")
		if (i < *number)
			memset(ptr + i*len, 0, (*number - i)*len);
		return 0;
#else
		if(fread(ptr,(int)len,(int)(*number),f__cf) != *number)
			err(f__elist->cierr,EOF,"do_ud")
		else return(0);
#endif
	}
	(void) fwrite(ptr,(int)len,(int)(*number),f__cf);
	return(0);
}
#ifdef KR_headers
integer do_uio(number,ptr,len) ftnint *number; char *ptr; ftnlen len;
#else
integer do_uio(ftnint *number, char *ptr, ftnlen len)
#endif
{
	if(f__sequential)
		return(do_us(number,ptr,len));
	else	return(do_ud(number,ptr,len));
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/uninit.c0000644000175100001710000002571700000000000023307 0ustar00runnerdocker00000000000000
/* Defining _GNU_SOURCE enables the GNU extensions fedisableexcept() and feenableexcept()
 * when using glibc. It must be defined before any standard headers are included. */
#define _GNU_SOURCE 1
#include 
#include 
#include 
#include 
#include "arith.h"

#define TYSHORT 2
#define TYLONG 3
#define TYREAL 4
#define TYDREAL 5
#define TYCOMPLEX 6
#define TYDCOMPLEX 7
#define TYINT1 11
#define TYQUAD 14
#ifndef Long
#define Long long
#endif

#ifdef __mips
#define RNAN	0xffc00000 /* Quiet NaN */
#define DNAN0	0xfff80000 /* Signalling NaN double Big endian */
#define DNAN1	0
#endif

#ifdef _PA_RISC1_1
#define RNAN	0xffc00000 /* Quiet Nan -- big endian */
#define DNAN0	0xfff80000
#define DNAN1	0
#endif

#ifndef RNAN
#define RNAN	0xff800001
#ifdef IEEE_MC68k /* set on PPC*/
#define DNAN0	0xfff00000 /* Quiet NaN big endian */
#define DNAN1	1
#else
#define DNAN0	1   /* LSB, MSB for little endian machines */
#define DNAN1	0xfff00000
#endif
#endif /*RNAN*/

#ifdef KR_headers
#define Void /*void*/
#define FA7UL (unsigned Long) 0xfa7a7a7aL
#else
#define Void void
#define FA7UL 0xfa7a7a7aUL
#endif

#ifdef __cplusplus
extern "C" {
#endif

static void ieee0(Void);

static unsigned Long rnan = RNAN,
	dnan0 = DNAN0,
	dnan1 = DNAN1;

double _0 = 0.;

void unsupported_error()
{
  fprintf(stderr,"Runtime Error: Your Architecture is not supported by the"
                       " -trapuv option of f2c\n");
  exit(-1);
}



 void
#ifdef KR_headers
_uninit_f2c(x, type, len) void *x; int type; long len;
#else
_uninit_f2c(void *x, int type, long len)
#endif
{
	static int first = 1;

	unsigned Long *lx, *lxe;

	if (first) {
		first = 0;
		ieee0();
		}
	if (len == 1)
	 switch(type) {
	  case TYINT1:
		*(char*)x = 'Z';
		return;
	  case TYSHORT:
		*(short*)x = 0xfa7a;
		break;
	  case TYLONG:
		*(unsigned Long*)x = FA7UL;
		return;
	  case TYQUAD:
	  case TYCOMPLEX:
	  case TYDCOMPLEX:
		break;
	  case TYREAL:
		*(unsigned Long*)x = rnan;
		return;
	  case TYDREAL:
		lx = (unsigned Long*)x;
		lx[0] = dnan0;
		lx[1] = dnan1;
		return;
	  default:
		printf("Surprise type %d in _uninit_f2c\n", type);
	  }
	switch(type) {
	  case TYINT1:
		memset(x, 'Z', len);
		break;
	  case TYSHORT:
		*(short*)x = 0xfa7a;
		break;
	  case TYQUAD:
		len *= 2;
		/* no break */
	  case TYLONG:
		lx = (unsigned Long*)x;
		lxe = lx + len;
		while(lx < lxe)
			*lx++ = FA7UL;
		break;
	  case TYCOMPLEX:
		len *= 2;
		/* no break */
	  case TYREAL:
		lx = (unsigned Long*)x;
		lxe = lx + len;
		while(lx < lxe)
			*lx++ = rnan;
		break;
	  case TYDCOMPLEX:
		len *= 2;
		/* no break */
	  case TYDREAL:
		lx = (unsigned Long*)x;
		for(lxe = lx + 2*len; lx < lxe; lx += 2) {
			lx[0] = dnan0;
			lx[1] = dnan1;
			}
	  }
	}
#ifdef __cplusplus
}
#endif

#ifndef MSpc
#ifdef MSDOS
#define MSpc
#else
#ifdef _WIN32
#define MSpc
#endif
#endif
#endif

#ifdef MSpc
#define IEEE0_done
#include "float.h"
#include "signal.h"

 static void
ieee0(Void)
{
#ifndef __alpha
#ifndef EM_DENORMAL
#define EM_DENORMAL _EM_DENORMAL
#endif
#ifndef EM_UNDERFLOW
#define EM_UNDERFLOW _EM_UNDERFLOW
#endif
#ifndef EM_INEXACT
#define EM_INEXACT _EM_INEXACT
#endif
#ifndef MCW_EM
#define MCW_EM _MCW_EM
#endif
	_control87(EM_DENORMAL | EM_UNDERFLOW | EM_INEXACT, MCW_EM);
#endif
	/* With MS VC++, compiling and linking with -Zi will permit */
	/* clicking to invoke the MS C++ debugger, which will show */
	/* the point of error -- provided SIGFPE is SIG_DFL. */
	signal(SIGFPE, SIG_DFL);
	}
#endif /* MSpc */

/* What follows is for SGI IRIX only */
#if defined(__mips) && defined(__sgi)   /* must link with -lfpe */
#define IEEE0_done
/* code from Eric Grosse */
#include 
#include 
#include "/usr/include/sigfpe.h"	/* full pathname for lcc -N */
#include "/usr/include/sys/fpu.h"

 static void
#ifdef KR_headers
ieeeuserhand(exception, val) unsigned exception[5]; int val[2];
#else
ieeeuserhand(unsigned exception[5], int val[2])
#endif
{
	fflush(stdout);
	fprintf(stderr,"ieee0() aborting because of ");
	if(exception[0]==_OVERFL) fprintf(stderr,"overflow\n");
	else if(exception[0]==_UNDERFL) fprintf(stderr,"underflow\n");
	else if(exception[0]==_DIVZERO) fprintf(stderr,"divide by 0\n");
	else if(exception[0]==_INVALID) fprintf(stderr,"invalid operation\n");
	else fprintf(stderr,"\tunknown reason\n");
	fflush(stderr);
	abort();
}

 static void
#ifdef KR_headers
ieeeuserhand2(j) unsigned int **j;
#else
ieeeuserhand2(unsigned int **j)
#endif
{
	fprintf(stderr,"ieee0() aborting because of confusion\n");
	abort();
}

 static void
ieee0(Void)
{
	int i;
	for(i=1; i<=4; i++){
		sigfpe_[i].count = 1000;
		sigfpe_[i].trace = 1;
		sigfpe_[i].repls = _USER_DETERMINED;
		}
	sigfpe_[1].repls = _ZERO;	/* underflow */
	handle_sigfpes( _ON,
		_EN_UNDERFL|_EN_OVERFL|_EN_DIVZERO|_EN_INVALID,
		ieeeuserhand,_ABORT_ON_ERROR,ieeeuserhand2);
	}
#endif /* IRIX mips */

/*
 * The following is the preferred method but depends upon a GLIBC extension only
 * to be found in GLIBC 2.2 or later.  It is a GNU extension, not included in the
 * C99 extensions which allow the FP status register to be examined in a platform
 * independent way.  It should be used if at all possible  -- AFRB
 */


#ifdef __GLIBC__
#define IEEE0_done

#if ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 2)))
 static void
  ieee0(Void)
        
{
    /* Clear all exception flags */
    if (fedisableexcept(FE_ALL_EXCEPT)==-1)
         unsupported_error();
    if (feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW)==-1)
         unsupported_error();
}

/* Many linux cases will be treated through GLIBC.  Note that modern
 * linux runs on many non-i86 plaforms and as a result the following code
 * must be processor dependent rather than simply OS specific */

#else /* __GLIBC__<2.2 */
#include 


#ifdef __alpha__
#ifndef USE_setfpucw
#define __setfpucw(x) __fpu_control = (x)
#endif
#endif

/* Not all versions of libc define _FPU_SETCW;
 *  * some only provide the __setfpucw() function.
 *   */
#ifndef _FPU_SETCW
#define _FPU_SETCW(cw) __setfpucw(cw)
#endif

/* The exact set of flags we want to set in the FPU control word
 * depends on the architecture.
 * Note also that whether an exception is enabled or disabled when
 * the _FPU_MASK_nn bit is set is architecture dependent!
 * Enabled-when-set: M68k, ARM, MIPS, PowerPC
 * Disabled-when-set: x86, Alpha
 * The state we are after is:
 * exceptions on division by zero, overflow and invalid operation.
 */


#ifdef __alpha__
#ifndef USE_setfpucw
#define __setfpucw(x) __fpu_control = (x)
#endif
#endif


#ifndef _FPU_SETCW
#undef  Can_use__setfpucw
#define Can_use__setfpucw
#endif

#undef RQD_FPU_MASK
#undef RQD_FPU_CLEAR_MASK

#if (defined(__mc68000__) || defined(__mc68020__) || defined(mc68020) || defined (__mc68k__))
/* Reported 20010705 by Alan Bain  */
/* Note that IEEE 754 IOP (illegal operation) */
/* = Signaling NAN (SNAN) + operation error (OPERR). */
#define RQD_FPU_STATE (_FPU_IEEE + _FPU_DOUBLE + _FPU_MASK_OPERR + \
                 _FPU_MASK_DZ + _FPU_MASK_SNAN+_FPU_MASK_OVFL)
#define RQD_FPU_MASK (_FPU_MASK_OPERR+_FPU_MASK_DZ+_FPU_MASK_SNAN+_FPU_MASK_OVFL)

#elif (defined(__powerpc__)||defined(_ARCH_PPC)||defined(_ARCH_PWR)) /* !__mc68k__ */
    /* The following is NOT a mistake -- the author of the fpu_control.h
     * for the PPC has erroneously defined IEEE mode to turn on exceptions
     * other than Inexact! Start from default then and turn on only the ones
     * which we want*/

    /* I have changed _FPU_MASK_UM here to _FPU_MASK_ZM, because that is
     * in line with all the other architectures specified here. -- AFRB
     */
#define RQD_FPU_STATE (_FPU_DEFAULT +_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)
#define RQD_FPU_MASK (_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)

#elif (defined(__arm__))
    /* On ARM too, IEEE implies all exceptions enabled.
     * -- Peter Maydell 
     * Unfortunately some version of ARMlinux don't include any
     * flags in the fpu_control.h file
     */
#define RQD_FPU_STATE (_FPU_DEFAULT +_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)
#define RQD_FPU_MASK (_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)

#elif (defined(__mips__))
    /* And same again for MIPS; _FPU_IEEE => exceptions seems a common meme.
     *  * MIPS uses different MASK constant names, no idea why -- PMM
     *   */
#define RQD_FPU_STATE (_FPU_DEFAULT +_FPU_MASK_O+_FPU_MASK_V+_FPU_MASK_Z)
#define RQD_FPU_MASK (_FPU_MASK_O+_FPU_MASK_V+_FPU_MASK_Z)

#elif (defined(__sparc__))
#define RQD_FPU_STATE (_FPU_DEFAULT +_FPU_DOUBLE+_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)
#define RQD_FPU_MASK (_FPU_MASK_OM+_FPU_MASK_IM+_FPU_MASK_ZM)

#elif (defined(__i386__) || defined(__alpha__))
    /* This case is for Intel, and also Alpha, because the Alpha header 
     * purposely emulates x86 flags and meanings for compatibility with
     * stupid programs.
     * We used to try this case for anything defining _FPU_IEEE, but I think
     * that that's a bad idea because it isn't really likely to work.
     * Instead for unknown architectures we just won't allow -trapuv to work.
     * Trying this case was just getting us 
     *  (a) compile errors on archs which didn't know all these constants
     *  (b) silent wrong behaviour on archs (like SPARC) which do know all
     *      constants but have different semantics for them
     */
#define RQD_FPU_STATE (_FPU_IEEE - _FPU_EXTENDED + _FPU_DOUBLE - _FPU_MASK_IM - _FPU_MASK_ZM - _FPU_MASK_OM)
#define RQD_FPU_CLEAR_MASK (_FPU_MASK_IM + _FPU_MASK_ZM + _FPU_MASK_OM)
#endif

static void ieee0(Void)
{
#ifdef RQD_FPU_STATE
        
#ifndef UNINIT_F2C_PRECISION_53 /* 20051004 */
        __fpu_control = RQD_FPU_STATE;
        _FPU_SETCW(__fpu_control);
#else 
	/* unmask invalid, etc., and keep current rounding precision */
	fpu_control_t cw;
	_FPU_GETCW(cw);
#ifdef RQD_FPU_CLEAR_MASK
	cw &= ~ RQD_FPU_CLEAR_MASK;
#else
        cw |= RQD_FPU_MASK;
#endif
	_FPU_SETCW(cw);
#endif

#else /* !_FPU_IEEE */

	fprintf(stderr, "\n%s\n%s\n%s\n%s\n",
		"WARNING:  _uninit_f2c in libf2c does not know how",
		"to enable trapping on this system, so f2c's -trapuv",
		"option will not detect uninitialized variables unless",
		"you can enable trapping manually.");
	fflush(stderr);

#endif /* _FPU_IEEE */
	}
#endif /* __GLIBC__>2.2 */
#endif /* __GLIBC__ */

/* Specific to OSF/1 */
#if (defined(__alpha)&&defined(__osf__))
#ifndef IEEE0_done
#define IEEE0_done
#include 
 static void
ieee0(Void)
{
	ieee_set_fp_control(IEEE_TRAP_ENABLE_INV);
	}
#endif /*IEEE0_done*/
#endif /*__alpha OSF/1*/

#ifdef __hpux
#define IEEE0_done
#define _INCLUDE_HPUX_SOURCE
#include 

#ifndef FP_X_INV
#include 
#define fpsetmask fesettrapenable
#define FP_X_INV FE_INVALID
#endif

 static void
ieee0(Void)
{
	fpsetmask(FP_X_INV);
	}
#endif /*__hpux*/

#ifdef _AIX
#define IEEE0_done
#include 

 static void
ieee0(Void)
{
	fp_enable(TRP_INVALID);
	fp_trap(FP_TRAP_SYNC);
	}
#endif /*_AIX*/

#ifdef __sun
#define IEEE0_done
#include 

 static void
ieee0(Void)
{
	fpsetmask(FP_X_INV);
	}
#endif /*__sparc*/

#ifndef IEEE0_done
 static void
ieee0(Void) {}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/util.c0000644000175100001710000000171400000000000022745 0ustar00runnerdocker00000000000000#include "sysdep1.h"	/* here to get stat64 on some badly designed Linux systems */
#include "f2c.h"
#include "fio.h"
#ifdef __cplusplus
extern "C" {
#endif

 VOID
#ifdef KR_headers
#define Const /*nothing*/
g_char(a,alen,b) char *a,*b; ftnlen alen;
#else
#define Const const
g_char(const char *a, ftnlen alen, char *b)
#endif
{
	Const char *x = a + alen;
	char *y = b + alen;

	for(;; y--) {
		if (x <= a) {
			*b = 0;
			return;
			}
		if (*--x != ' ')
			break;
		}
	*y-- = 0;
	do *y-- = *x;
		while(x-- > a);
	}

 VOID
#ifdef KR_headers
b_char(a,b,blen) char *a,*b; ftnlen blen;
#else
b_char(const char *a, char *b, ftnlen blen)
#endif
{	int i;
	for(i=0;i= d + 2 || f__scale <= -d)
			goto nogood;
		}
	if(f__scale <= 0)
		--d;
	if (len == sizeof(real))
		dd = p->pf;
	else
		dd = p->pd;
	if (dd < 0.) {
		signspace = sign = 1;
		dd = -dd;
		}
	else {
		sign = 0;
		signspace = (int)f__cplus;
#ifndef VAX
		if (!dd) {
#ifdef SIGNED_ZEROS
			if (signbit_f2c(&dd))
				signspace = sign = 1;
#endif
			dd = 0.;	/* avoid -0 */
			}
#endif
		}
	delta = w - (2 /* for the . and the d adjustment above */
			+ 2 /* for the E+ */ + signspace + d + e);
#ifdef WANT_LEAD_0
	if (f__scale <= 0 && delta > 0) {
		delta--;
		insert0 = 1;
		}
	else
#endif
	if (delta < 0) {
nogood:
		while(--w >= 0)
			PUT('*');
		return(0);
		}
	if (f__scale < 0)
		d += f__scale;
	if (d > FMAX) {
		d1 = d - FMAX;
		d = FMAX;
		}
	else
		d1 = 0;
	sprintf(buf,"%#.*E", d, dd);
#ifndef VAX
	/* check for NaN, Infinity */
	if (!isdigit(buf[0])) {
		switch(buf[0]) {
			case 'n':
			case 'N':
				signspace = 0;	/* no sign for NaNs */
			}
		delta = w - strlen(buf) - signspace;
		if (delta < 0)
			goto nogood;
		while(--delta >= 0)
			PUT(' ');
		if (signspace)
			PUT(sign ? '-' : '+');
		for(s = buf; *s; s++)
			PUT(*s);
		return 0;
		}
#endif
	se = buf + d + 3;
#ifdef GOOD_SPRINTF_EXPONENT /* When possible, exponent has 2 digits. */
	if (f__scale != 1 && dd)
		sprintf(se, "%+.2d", atoi(se) + 1 - f__scale);
#else
	if (dd)
		sprintf(se, "%+.2d", atoi(se) + 1 - f__scale);
	else
		strcpy(se, "+00");
#endif
	s = ++se;
	if (e < 2) {
		if (*s != '0')
			goto nogood;
		}
#ifndef VAX
	/* accommodate 3 significant digits in exponent */
	if (s[2]) {
#ifdef Pedantic
		if (!e0 && !s[3])
			for(s -= 2, e1 = 2; s[0] = s[1]; s++);

	/* Pedantic gives the behavior that Fortran 77 specifies,	*/
	/* i.e., requires that E be specified for exponent fields	*/
	/* of more than 3 digits.  With Pedantic undefined, we get	*/
	/* the behavior that Cray displays -- you get a bigger		*/
	/* exponent field if it fits.	*/
#else
		if (!e0) {
			for(s -= 2, e1 = 2; s[0] = s[1]; s++)
#ifdef CRAY
				delta--;
			if ((delta += 4) < 0)
				goto nogood
#endif
				;
			}
#endif
		else if (e0 >= 0)
			goto shift;
		else
			e1 = e;
		}
	else
 shift:
#endif
		for(s += 2, e1 = 2; *s; ++e1, ++s)
			if (e1 >= e)
				goto nogood;
	while(--delta >= 0)
		PUT(' ');
	if (signspace)
		PUT(sign ? '-' : '+');
	s = buf;
	i = f__scale;
	if (f__scale <= 0) {
#ifdef WANT_LEAD_0
		if (insert0)
			PUT('0');
#endif
		PUT('.');
		for(; i < 0; ++i)
			PUT('0');
		PUT(*s);
		s += 2;
		}
	else if (f__scale > 1) {
		PUT(*s);
		s += 2;
		while(--i > 0)
			PUT(*s++);
		PUT('.');
		}
	if (d1) {
		se -= 2;
		while(s < se) PUT(*s++);
		se += 2;
		do PUT('0'); while(--d1 > 0);
		}
	while(s < se)
		PUT(*s++);
	if (e < 2)
		PUT(s[1]);
	else {
		while(++e1 <= e)
			PUT('0');
		while(*s)
			PUT(*s++);
		}
	return 0;
	}

 int
#ifdef KR_headers
wrt_F(p,w,d,len) ufloat *p; ftnlen len;
#else
wrt_F(ufloat *p, int w, int d, ftnlen len)
#endif
{
	int d1, sign, n;
	double x;
	char *b, buf[MAXINTDIGS+MAXFRACDIGS+4], *s;

	x= (len==sizeof(real)?p->pf:p->pd);
	if (d < MAXFRACDIGS)
		d1 = 0;
	else {
		d1 = d - MAXFRACDIGS;
		d = MAXFRACDIGS;
		}
	if (x < 0.)
		{ x = -x; sign = 1; }
	else {
		sign = 0;
#ifndef VAX
		if (!x) {
#ifdef SIGNED_ZEROS
			if (signbit_f2c(&x))
				sign = 2;
#endif
			x = 0.;
			}
#endif
		}

	if (n = f__scale)
		if (n > 0)
			do x *= 10.; while(--n > 0);
		else
			do x *= 0.1; while(++n < 0);

#ifdef USE_STRLEN
	sprintf(b = buf, "%#.*f", d, x);
	n = strlen(b) + d1;
#else
	n = sprintf(b = buf, "%#.*f", d, x) + d1;
#endif

#ifndef WANT_LEAD_0
	if (buf[0] == '0' && d)
		{ ++b; --n; }
#endif
	if (sign == 1) {
		/* check for all zeros */
		for(s = b;;) {
			while(*s == '0') s++;
			switch(*s) {
				case '.':
					s++; continue;
				case 0:
					sign = 0;
				}
			break;
			}
		}
	if (sign || f__cplus)
		++n;
	if (n > w) {
#ifdef WANT_LEAD_0
		if (buf[0] == '0' && --n == w)
			++b;
		else
#endif
		{
			while(--w >= 0)
				PUT('*');
			return 0;
			}
		}
	for(w -= n; --w >= 0; )
		PUT(' ');
	if (sign)
		PUT('-');
	else if (f__cplus)
		PUT('+');
	while(n = *b++)
		PUT(n);
	while(--d1 >= 0)
		PUT('0');
	return 0;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/wrtfmt.c0000644000175100001710000001652200000000000023316 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif

extern icilist *f__svic;
extern char *f__icptr;

 static int
mv_cur(Void)	/* shouldn't use fseek because it insists on calling fflush */
		/* instead we know too much about stdio */
{
	int cursor = f__cursor;
	f__cursor = 0;
	if(f__external == 0) {
		if(cursor < 0) {
			if(f__hiwater < f__recpos)
				f__hiwater = f__recpos;
			f__recpos += cursor;
			f__icptr += cursor;
			if(f__recpos < 0)
				err(f__elist->cierr, 110, "left off");
		}
		else if(cursor > 0) {
			if(f__recpos + cursor >= f__svic->icirlen)
				err(f__elist->cierr, 110, "recend");
			if(f__hiwater <= f__recpos)
				for(; cursor > 0; cursor--)
					(*f__putn)(' ');
			else if(f__hiwater <= f__recpos + cursor) {
				cursor -= f__hiwater - f__recpos;
				f__icptr += f__hiwater - f__recpos;
				f__recpos = f__hiwater;
				for(; cursor > 0; cursor--)
					(*f__putn)(' ');
			}
			else {
				f__icptr += cursor;
				f__recpos += cursor;
			}
		}
		return(0);
	}
	if (cursor > 0) {
		if(f__hiwater <= f__recpos)
			for(;cursor>0;cursor--) (*f__putn)(' ');
		else if(f__hiwater <= f__recpos + cursor) {
			cursor -= f__hiwater - f__recpos;
			f__recpos = f__hiwater;
			for(; cursor > 0; cursor--)
				(*f__putn)(' ');
		}
		else {
			f__recpos += cursor;
		}
	}
	else if (cursor < 0)
	{
		if(cursor + f__recpos < 0)
			err(f__elist->cierr,110,"left off");
		if(f__hiwater < f__recpos)
			f__hiwater = f__recpos;
		f__recpos += cursor;
	}
	return(0);
}

 static int
#ifdef KR_headers
wrt_Z(n,w,minlen,len) Uint *n; int w, minlen; ftnlen len;
#else
wrt_Z(Uint *n, int w, int minlen, ftnlen len)
#endif
{
	register char *s, *se;
	register int i, w1;
	static int one = 1;
	static char hex[] = "0123456789ABCDEF";
	s = (char *)n;
	--len;
	if (*(char *)&one) {
		/* little endian */
		se = s;
		s += len;
		i = -1;
		}
	else {
		se = s + len;
		i = 1;
		}
	for(;; s += i)
		if (s == se || *s)
			break;
	w1 = (i*(se-s) << 1) + 1;
	if (*s & 0xf0)
		w1++;
	if (w1 > w)
		for(i = 0; i < w; i++)
			(*f__putn)('*');
	else {
		if ((minlen -= w1) > 0)
			w1 += minlen;
		while(--w >= w1)
			(*f__putn)(' ');
		while(--minlen >= 0)
			(*f__putn)('0');
		if (!(*s & 0xf0)) {
			(*f__putn)(hex[*s & 0xf]);
			if (s == se)
				return 0;
			s += i;
			}
		for(;; s += i) {
			(*f__putn)(hex[*s >> 4 & 0xf]);
			(*f__putn)(hex[*s & 0xf]);
			if (s == se)
				break;
			}
		}
	return 0;
	}

 static int
#ifdef KR_headers
wrt_I(n,w,len, base) Uint *n; ftnlen len; register int base;
#else
wrt_I(Uint *n, int w, ftnlen len, register int base)
#endif
{	int ndigit,sign,spare,i;
	longint x;
	char *ans;
	if(len==sizeof(integer)) x=n->il;
	else if(len == sizeof(char)) x = n->ic;
#ifdef Allow_TYQUAD
	else if (len == sizeof(longint)) x = n->ili;
#endif
	else x=n->is;
	ans=f__icvt(x,&ndigit,&sign, base);
	spare=w-ndigit;
	if(sign || f__cplus) spare--;
	if(spare<0)
		for(i=0;iil;
	else if(len == sizeof(char)) x = n->ic;
#ifdef Allow_TYQUAD
	else if (len == sizeof(longint)) x = n->ili;
#endif
	else x=n->is;
	ans=f__icvt(x,&ndigit,&sign, base);
	if(sign || f__cplus) xsign=1;
	else xsign=0;
	if(ndigit+xsign>w || m+xsign>w)
	{	for(i=0;i=m)
		spare=w-ndigit-xsign;
	else
		spare=w-m-xsign;
	for(i=0;iil;
	else if(sz == sizeof(char)) x = n->ic;
	else x=n->is;
	for(i=0;i 0) (*f__putn)(*p++);
	return(0);
}
 static int
#ifdef KR_headers
wrt_AW(p,w,len) char * p; ftnlen len;
#else
wrt_AW(char * p, int w, ftnlen len)
#endif
{
	while(w>len)
	{	w--;
		(*f__putn)(' ');
	}
	while(w-- > 0)
		(*f__putn)(*p++);
	return(0);
}

 static int
#ifdef KR_headers
wrt_G(p,w,d,e,len) ufloat *p; ftnlen len;
#else
wrt_G(ufloat *p, int w, int d, int e, ftnlen len)
#endif
{	double up = 1,x;
	int i=0,oldscale,n,j;
	x = len==sizeof(real)?p->pf:p->pd;
	if(x < 0 ) x = -x;
	if(x<.1) {
		if (x != 0.)
			return(wrt_E(p,w,d,e,len));
		i = 1;
		goto have_i;
		}
	for(;i<=d;i++,up*=10)
	{	if(x>=up) continue;
 have_i:
		oldscale = f__scale;
		f__scale = 0;
		if(e==0) n=4;
		else	n=e+2;
		i=wrt_F(p,w-n,d-i,len);
		for(j=0;jop)
	{
	default:
		fprintf(stderr,"w_ed, unexpected code: %d\n", p->op);
		sig_die(f__fmtbuf, 1);
	case I:	return(wrt_I((Uint *)ptr,p->p1,len, 10));
	case IM:
		return(wrt_IM((Uint *)ptr,p->p1,p->p2.i[0],len,10));

		/* O and OM don't work right for character, double, complex, */
		/* or doublecomplex, and they differ from Fortran 90 in */
		/* showing a minus sign for negative values. */

	case O:	return(wrt_I((Uint *)ptr, p->p1, len, 8));
	case OM:
		return(wrt_IM((Uint *)ptr,p->p1,p->p2.i[0],len,8));
	case L:	return(wrt_L((Uint *)ptr,p->p1, len));
	case A: return(wrt_A(ptr,len));
	case AW:
		return(wrt_AW(ptr,p->p1,len));
	case D:
	case E:
	case EE:
		return(wrt_E((ufloat *)ptr,p->p1,p->p2.i[0],p->p2.i[1],len));
	case G:
	case GE:
		return(wrt_G((ufloat *)ptr,p->p1,p->p2.i[0],p->p2.i[1],len));
	case F:	return(wrt_F((ufloat *)ptr,p->p1,p->p2.i[0],len));

		/* Z and ZM assume 8-bit bytes. */

	case Z: return(wrt_Z((Uint *)ptr,p->p1,0,len));
	case ZM:
		return(wrt_Z((Uint *)ptr,p->p1,p->p2.i[0],len));
	}
}

 int
#ifdef KR_headers
w_ned(p) struct syl *p;
#else
w_ned(struct syl *p)
#endif
{
	switch(p->op)
	{
	default: fprintf(stderr,"w_ned, unexpected code: %d\n", p->op);
		sig_die(f__fmtbuf, 1);
	case SLASH:
		return((*f__donewrec)());
	case T: f__cursor = p->p1-f__recpos - 1;
		return(1);
	case TL: f__cursor -= p->p1;
		if(f__cursor < -f__recpos)	/* TL1000, 1X */
			f__cursor = -f__recpos;
		return(1);
	case TR:
	case X:
		f__cursor += p->p1;
		return(1);
	case APOS:
		return(wrt_AP(p->p2.s));
	case H:
		return(wrt_H(p->p1,p->p2.s));
	}
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/wsfe.c0000644000175100001710000000240000000000000022725 0ustar00runnerdocker00000000000000/*write sequential formatted external*/
#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#ifdef __cplusplus
extern "C" {
#endif

 int
x_wSL(Void)
{
	int n = f__putbuf('\n');
	f__hiwater = f__recpos = f__cursor = 0;
	return(n == 0);
}

 static int
xw_end(Void)
{
	int n;

	if(f__nonl) {
		f__putbuf(n = 0);
		fflush(f__cf);
		}
	else
		n = f__putbuf('\n');
	f__hiwater = f__recpos = f__cursor = 0;
	return n;
}

 static int
xw_rev(Void)
{
	int n = 0;
	if(f__workdone) {
		n = f__putbuf('\n');
		f__workdone = 0;
		}
	f__hiwater = f__recpos = f__cursor = 0;
	return n;
}

#ifdef KR_headers
integer s_wsfe(a) cilist *a;	/*start*/
#else
integer s_wsfe(cilist *a)	/*start*/
#endif
{	int n;
	if(!f__init) f_init();
	f__reading=0;
	f__sequential=1;
	f__formatted=1;
	f__external=1;
	if(n=c_sfe(a)) return(n);
	f__elist=a;
	f__hiwater = f__cursor=f__recpos=0;
	f__nonl = 0;
	f__scale=0;
	f__fmtbuf=a->cifmt;
	f__cf=f__curunit->ufd;
	if(pars_f(f__fmtbuf)<0) err(a->cierr,100,"startio");
	f__putn= x_putc;
	f__doed= w_ed;
	f__doned= w_ned;
	f__doend=xw_end;
	f__dorevert=xw_rev;
	f__donewrec=x_wSL;
	fmt_bg();
	f__cplus=0;
	f__cblank=f__curunit->ublnk;
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr,errno,"write start");
	return(0);
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/wsle.c0000644000175100001710000000127100000000000022740 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "fmt.h"
#include "lio.h"
#include "string.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
integer s_wsle(a) cilist *a;
#else
integer s_wsle(cilist *a)
#endif
{
	int n;
	if(n=c_le(a)) return(n);
	f__reading=0;
	f__external=1;
	f__formatted=1;
	f__putn = x_putc;
	f__lioproc = l_write;
	L_len = LINE;
	f__donewrec = x_wSL;
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr, errno, "list output start");
	return(0);
	}

integer e_wsle(Void)
{
	int n = f__putbuf('\n');
	f__recpos=0;
#ifdef ALWAYS_FLUSH
	if (!n && fflush(f__cf))
		err(f__elist->cierr, errno, "write end");
#endif
	return(n);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/wsne.c0000644000175100001710000000073700000000000022750 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "lio.h"
#ifdef __cplusplus
extern "C" {
#endif

 integer
#ifdef KR_headers
s_wsne(a) cilist *a;
#else
s_wsne(cilist *a)
#endif
{
	int n;

	if(n=c_le(a))
		return(n);
	f__reading=0;
	f__external=1;
	f__formatted=1;
	f__putn = x_putc;
	L_len = LINE;
	f__donewrec = x_wSL;
	if(f__curunit->uwrt != 1 && f__nowwriting(f__curunit))
		err(a->cierr, errno, "namelist output start");
	x_wsne(a);
	return e_wsle();
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/xsum0.out0000644000175100001710000000755100000000000023436 0ustar00runnerdocker00000000000000Notice	76f23b4	1212
README	16a3882f	16876
abort_.c	f51c808	304
arithchk.c	fae7c666	5171
backspac.c	10ebf554	1328
c_abs.c	fec22c59	272
c_cos.c	18fc0ea3	354
c_div.c	1797c106	936
c_exp.c	1b85b1fc	349
c_log.c	28cdfed	384
c_sin.c	1ccaedc8	350
c_sqrt.c	f1ee88d5	605
cabs.c	f3d3b5f2	494
close.c	173f01de	1393
comptry.bat	f8a8a0d5	125
ctype.c	f553a125	40
ctype.h	1e54977d	1139
d_abs.c	e58094ef	218
d_acos.c	e5ecf93d	245
d_asin.c	e12ceeff	245
d_atan.c	53034db	245
d_atn2.c	ff8a1a78	271
d_cnjg.c	1c27c728	255
d_cos.c	c0eb625	241
d_cosh.c	11dc4adb	245
d_dim.c	e1ccb774	232
d_exp.c	1879c41c	241
d_imag.c	fe9c703e	201
d_int.c	f5de3566	269
d_lg10.c	1a1d7b77	291
d_log.c	1b368adf	241
d_mod.c	f540cf24	688
d_nint.c	ff913b40	281
d_prod.c	ad4856b	207
d_sign.c	9562fc5	266
d_sin.c	6e3f542	241
d_sinh.c	18b22950	245
d_sqrt.c	17e1db09	245
d_tan.c	ec93ebdb	241
d_tanh.c	1c55d15b	245
derf_.c	f85e74a3	239
derfc_.c	e96b7667	253
dfe.c	1d658105	2624
dolio.c	19c9fbd9	471
dtime_.c	c982be4	972
due.c	ee219f6d	1624
ef1asc_.c	e0576e63	521
ef1cmc_.c	ea5ad9e8	427
endfile.c	6f7201d	2838
erf_.c	e82f7790	270
erfc_.c	ba65441	275
err.c	e59d1707	6442
etime_.c	19d1fdad	839
exit_.c	ff4baa3a	543
f2c.h0	e770b7d8	4688
f2ch.add	ef66bf17	6060
f77_aloc.c	f8daf96e	684
f77vers.c	ed1c96fa	4933
fio.h	e41d245e	2939
fmt.c	f9a1bb94	8566
fmt.h	ec84ce17	2006
fmtlib.c	eefc6a27	865
fp.h	100fb355	665
ftell_.c	78218d	900
ftell64_.c	e2c4b21e	917
getarg_.c	fd514f59	592
getenv_.c	f4b06e2	1223
h_abs.c	e4443109	218
h_dim.c	c6e48bc	230
h_dnnt.c	f6bb90e	294
h_indx.c	ef8461eb	442
h_len.c	e8c3633	205
h_mod.c	7355bd0	207
h_nint.c	f0da3396	281
h_sign.c	f1370ffd	266
hl_ge.c	ed792501	346
hl_gt.c	feeacbd9	345
hl_le.c	f6fb5d6e	346
hl_lt.c	18501419	345
i77vers.c	f57b8ef2	18128
i_abs.c	12ab51ab	214
i_dim.c	f2a56785	225
i_dnnt.c	11748482	291
i_indx.c	fb59026f	430
i_len.c	17d17252	203
i_mod.c	bef73ae	211
i_nint.c	e494b804	278
i_sign.c	fa015b08	260
iargc_.c	49abda3	196
iio.c	f958b627	2639
ilnw.c	fe0ab14b	1125
inquire.c	1883d542	2732
l_ge.c	f4710e74	334
l_gt.c	e8db94a7	333
l_le.c	c9c0a99	334
l_lt.c	767e79f	333
lbitbits.c	33fe981	1097
lbitshft.c	e81981d2	258
libf2c.lbc	10af591e	1594
libf2c.sy	fd5f568f	2051
lio.h	805735d	1564
lread.c	f1e54a1f	14739
lwrite.c	f80da63f	4616
main.c	371f60f	2230
makefile.sy	174ccb83	2990
makefile.u	fce2cb5f	7302
makefile.vc	179d7b1c	2942
makefile.wat	18b044ac	2936
math.hvc	19bb2d07	50
mkfile.plan9	e67e471e	5174
open.c	e7bcc295	5701
pow_ci.c	fa934cec	412
pow_dd.c	f004559b	276
pow_di.c	a4db539	448
pow_hh.c	d1a45a9	489
pow_ii.c	1fcf2742	488
pow_qq.c	e6a32de6	516
pow_ri.c	e7d9fc2a	436
pow_zi.c	1b894af7	851
pow_zz.c	f81a06b5	549
qbitbits.c	fdb9910e	1151
qbitshft.c	873054d	258
r_abs.c	f471383c	206
r_acos.c	1a6aca63	233
r_asin.c	e8555587	233
r_atan.c	eac25444	233
r_atn2.c	f611bea	253
r_cnjg.c	a8d7805	235
r_cos.c	fdef1ece	229
r_cosh.c	f05d1ae	233
r_dim.c	ee23e1a8	214
r_exp.c	1da16cd7	229
r_imag.c	166ad0f3	189
r_int.c	fc80b9a8	257
r_lg10.c	e876cfab	279
r_log.c	2062254	229
r_mod.c	187363fc	678
r_nint.c	6edcbb2	269
r_sign.c	1ae32441	248
r_sin.c	c3d968	229
r_sinh.c	1090c850	233
r_sqrt.c	ffbb0625	233
r_tan.c	fe85179d	229
r_tanh.c	10ffcc5b	233
rawio.h	1ab49f7c	718
rdfmt.c	7222fee	8925
rewind.c	e4c6236f	475
rsfe.c	eb9e882c	1492
rsli.c	11f59b61	1785
rsne.c	fea7e5be	11585
s_cat.c	164a6ff1	1458
s_cmp.c	e69e8b60	722
s_copy.c	1e258852	1024
s_paus.c	e37cfe6	1617
s_rnge.c	e8cf83a3	759
s_stop.c	ffa80b24	762
scomptry.bat	ed740ad8	181
sfe.c	1e10bda3	828
sig_die.c	12eb0eac	689
signal1.h0	1d43ee57	842
signal_.c	f3ef9cfc	299
signbit.c	e37eac06	330
sue.c	9705ecf	1865
sysdep1.h0	1812022d	1202
system_.c	ff72e46c	652
typesize.c	eee307ae	386
uio.c	e354a770	1619
uninit.c	fe760fb0	7584
util.c	172fa76e	972
wref.c	17bbfb7b	4747
wrtfmt.c	113fc4f9	7506
wsfe.c	f2d1fe4d	1280
wsle.c	fe50b4c9	697
wsne.c	428bfda	479
xwsne.c	185c4bdc	1174
z_abs.c	1fa0640d	268
z_cos.c	facccd9b	363
z_div.c	e6f03676	913
z_exp.c	1a8506e8	357
z_log.c	6bf3b22	2729
z_sin.c	1aa35b59	359
z_sqrt.c	1864d867	581
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/xwsne.c0000644000175100001710000000222600000000000023133 0ustar00runnerdocker00000000000000#include "f2c.h"
#include "fio.h"
#include "lio.h"
#include "fmt.h"

extern int f__Aquote;

 static VOID
nl_donewrec(Void)
{
	(*f__donewrec)();
	PUT(' ');
	}

#ifdef KR_headers
x_wsne(a) cilist *a;
#else
#include "string.h"
#ifdef __cplusplus
extern "C" {
#endif

 VOID
x_wsne(cilist *a)
#endif
{
	Namelist *nl;
	char *s;
	Vardesc *v, **vd, **vde;
	ftnint number, type;
	ftnlen *dims;
	ftnlen size;
	extern ftnlen f__typesize[];

	nl = (Namelist *)a->cifmt;
	PUT('&');
	for(s = nl->name; *s; s++)
		PUT(*s);
	PUT(' ');
	f__Aquote = 1;
	vd = nl->vars;
	vde = vd + nl->nvars;
	while(vd < vde) {
		v = *vd++;
		s = v->name;
#ifdef No_Extra_Namelist_Newlines
		if (f__recpos+strlen(s)+2 >= L_len)
#endif
			nl_donewrec();
		while(*s)
			PUT(*s++);
		PUT(' ');
		PUT('=');
		number = (dims = v->dims) ? dims[1] : 1;
		type = v->type;
		if (type < 0) {
			size = -type;
			type = TYCHAR;
			}
		else
			size = f__typesize[type];
		l_write(&number, v->addr, size, type);
		if (vd < vde) {
			if (f__recpos+2 >= L_len)
				nl_donewrec();
			PUT(',');
			PUT(' ');
			}
		else if (f__recpos+1 >= L_len)
			nl_donewrec();
		}
	f__Aquote = 0;
	PUT('/');
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_abs.c0000644000175100001710000000041400000000000023062 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
double f__cabs();
double z_abs(z) doublecomplex *z;
#else
double f__cabs(double, double);
double z_abs(doublecomplex *z)
#endif
{
return( f__cabs( z->r, z->i ) );
}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_cos.c0000644000175100001710000000055300000000000023105 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sin(), cos(), sinh(), cosh();
VOID z_cos(r, z) doublecomplex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
void z_cos(doublecomplex *r, doublecomplex *z)
#endif
{
	double zi = z->i, zr = z->r;
	r->r =   cos(zr) * cosh(zi);
	r->i = - sin(zr) * sinh(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_div.c0000644000175100001710000000162100000000000023100 0ustar00runnerdocker00000000000000#include "f2c.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifdef KR_headers
extern VOID sig_die();
VOID z_div(c, a, b) doublecomplex *a, *b, *c;
#else
extern void sig_die(const char*, int);
void z_div(doublecomplex *c, doublecomplex *a, doublecomplex *b)
#endif
{
	double ratio, den;
	double abr, abi, cr;

	if( (abr = b->r) < 0.)
		abr = - abr;
	if( (abi = b->i) < 0.)
		abi = - abi;
	if( abr <= abi )
		{
		if(abi == 0) {
#ifdef IEEE_COMPLEX_DIVIDE
			if (a->i != 0 || a->r != 0)
				abi = 1.;
			c->i = c->r = abi / abr;
			return;
#else
			sig_die("complex division by zero", 1);
#endif
			}
		ratio = b->r / b->i ;
		den = b->i * (1 + ratio*ratio);
		cr = (a->r*ratio + a->i) / den;
		c->i = (a->i*ratio - a->r) / den;
		}

	else
		{
		ratio = b->i / b->r ;
		den = b->r * (1 + ratio*ratio);
		cr = (a->r + a->i*ratio) / den;
		c->i = (a->i - a->r*ratio) / den;
		}
	c->r = cr;
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_exp.c0000644000175100001710000000054500000000000023116 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double exp(), cos(), sin();
VOID z_exp(r, z) doublecomplex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
void z_exp(doublecomplex *r, doublecomplex *z)
#endif
{
	double expx, zi = z->i;

	expx = exp(z->r);
	r->r = expx * cos(zi);
	r->i = expx * sin(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_log.c0000644000175100001710000000525100000000000023102 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double log(), f__cabs(), atan2();
#define ANSI(x) ()
#else
#define ANSI(x) x
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double, double);
#endif

#ifndef NO_DOUBLE_EXTENDED
#ifndef GCC_COMPARE_BUG_FIXED
#ifndef Pre20000310
#ifdef Comment
Some versions of gcc, such as 2.95.3 and 3.0.4, are buggy under -O2 or -O3:
on IA32 (Intel 80x87) systems, they may do comparisons on values computed
in extended-precision registers.  This can lead to the test "s > s0" that
was used below being carried out incorrectly.  The fix below cannot be
spoiled by overzealous optimization, since the compiler cannot know
whether gcc_bug_bypass_diff_F2C will be nonzero.  (We expect it always
to be zero.  The weird name is unlikely to collide with anything.)

An example (provided by Ulrich Jakobus) where the bug fix matters is

	double complex a, b
	a = (.1099557428756427618354862829619, .9857360542953131909982289471372)
	b = log(a)

An alternative to the fix below would be to use 53-bit rounding precision,
but the means of specifying this 80x87 feature are highly unportable.
#endif /*Comment*/
#define BYPASS_GCC_COMPARE_BUG
double (*gcc_bug_bypass_diff_F2C) ANSI((double*,double*));
 static double
#ifdef KR_headers
diff1(a,b) double *a, *b;
#else
diff1(double *a, double *b)
#endif
{ return *a - *b; }
#endif /*Pre20000310*/
#endif /*GCC_COMPARE_BUG_FIXED*/
#endif /*NO_DOUBLE_EXTENDED*/

#ifdef KR_headers
VOID z_log(r, z) doublecomplex *r, *z;
#else
void z_log(doublecomplex *r, doublecomplex *z)
#endif
{
	double s, s0, t, t2, u, v;
	double zi = z->i, zr = z->r;
#ifdef BYPASS_GCC_COMPARE_BUG
	double (*diff) ANSI((double*,double*));
#endif

	r->i = atan2(zi, zr);
#ifdef Pre20000310
	r->r = log( f__cabs( zr, zi ) );
#else
	if (zi < 0)
		zi = -zi;
	if (zr < 0)
		zr = -zr;
	if (zr < zi) {
		t = zi;
		zi = zr;
		zr = t;
		}
	t = zi/zr;
	s = zr * sqrt(1 + t*t);
	/* now s = f__cabs(zi,zr), and zr = |zr| >= |zi| = zi */
	if ((t = s - 1) < 0)
		t = -t;
	if (t > .01)
		r->r = log(s);
	else {

#ifdef Comment

	log(1+x) = x - x^2/2 + x^3/3 - x^4/4 + - ...

		 = x(1 - x/2 + x^2/3 -+...)

	[sqrt(y^2 + z^2) - 1] * [sqrt(y^2 + z^2) + 1] = y^2 + z^2 - 1, so

	sqrt(y^2 + z^2) - 1 = (y^2 + z^2 - 1) / [sqrt(y^2 + z^2) + 1]

#endif /*Comment*/

#ifdef BYPASS_GCC_COMPARE_BUG
		if (!(diff = gcc_bug_bypass_diff_F2C))
			diff = diff1;
#endif
		t = ((zr*zr - 1.) + zi*zi) / (s + 1);
		t2 = t*t;
		s = 1. - 0.5*t;
		u = v = 1;
		do {
			s0 = s;
			u *= t2;
			v += 2;
			s += u/v - t*u/(v+1);
			}
#ifdef BYPASS_GCC_COMPARE_BUG
			while(s - s0 > 1e-18 || (*diff)(&s,&s0) > 0.);
#else
			while(s > s0);
#endif
		r->r = s*t;
		}
#endif
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_sin.c0000644000175100001710000000054700000000000023115 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sin(), cos(), sinh(), cosh();
VOID z_sin(r, z) doublecomplex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
void z_sin(doublecomplex *r, doublecomplex *z)
#endif
{
	double zi = z->i, zr = z->r;
	r->r = sin(zr) * cosh(zi);
	r->i = cos(zr) * sinh(zi);
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/f2c/z_sqrt.c0000644000175100001710000000110500000000000023304 0ustar00runnerdocker00000000000000#include "f2c.h"

#ifdef KR_headers
double sqrt(), f__cabs();
VOID z_sqrt(r, z) doublecomplex *r, *z;
#else
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double, double);
void z_sqrt(doublecomplex *r, doublecomplex *z)
#endif
{
	double mag, zi = z->i, zr = z->r;

	if( (mag = f__cabs(zr, zi)) == 0.)
		r->r = r->i = 0.;
	else if(zr > 0)
		{
		r->r = sqrt(0.5 * (mag + zr) );
		r->i = zi / r->r / 2;
		}
	else
		{
		r->i = sqrt(0.5 * (mag - zr) );
		if(zi < 0)
			r->i = - r->i;
		r->r = zi / r->i / 2;
		}
	}
#ifdef __cplusplus
}
#endif
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6511428
igraph-0.9.9/vendor/source/igraph/vendor/glpk/0000755000175100001710000000000000000000000022104 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/CMakeLists.txt0000644000175100001710000001007500000000000024647 0ustar00runnerdocker00000000000000
add_library(
  glpk_vendored
  OBJECT
  EXCLUDE_FROM_ALL

  amd/amd_1.c amd/amd_2.c amd/amd_aat.c amd/amd_control.c amd/amd_defaults.c
  amd/amd_info.c amd/amd_order.c amd/amd_post_tree.c
  amd/amd_postorder.c amd/amd_preprocess.c amd/amd_valid.c

  api/advbas.c api/asnhall.c api/asnlp.c api/asnokalg.c api/ckasn.c api/ckcnf.c
  api/cplex.c api/cpp.c api/cpxbas.c api/graph.c api/gridgen.c api/intfeas1.c
  api/maxffalg.c api/maxflp.c api/mcflp.c api/mcfokalg.c api/mcfrelax.c
  api/minisat1.c api/mpl.c api/mps.c api/netgen.c api/npp.c api/pript.c
  api/prmip.c api/prob1.c api/prob2.c api/prob3.c api/prob4.c api/prob5.c
  api/prrngs.c api/prsol.c api/rdasn.c api/rdcc.c api/rdcnf.c api/rdipt.c
  api/rdmaxf.c api/rdmcf.c api/rdmip.c api/rdprob.c api/rdsol.c api/rmfgen.c
  api/strong.c api/topsort.c api/wcliqex.c api/weak.c api/wrasn.c api/wrcc.c
  api/wrcnf.c api/wript.c api/wrmaxf.c api/wrmcf.c api/wrmip.c api/wrprob.c
  api/wrsol.c

  bflib/btf.c bflib/btfint.c bflib/fhv.c bflib/fhvint.c bflib/ifu.c bflib/luf.c
  bflib/lufint.c bflib/scf.c bflib/scfint.c bflib/sgf.c bflib/sva.c

  colamd/colamd.c

  draft/bfd.c draft/bfx.c draft/glpapi06.c draft/glpapi07.c draft/glpapi08.c
  draft/glpapi09.c draft/glpapi10.c draft/glpapi12.c draft/glpapi13.c
  draft/glpios01.c draft/glpios02.c draft/glpios03.c draft/glpios07.c
  draft/glpios09.c draft/glpios11.c draft/glpios12.c draft/glpipm.c
  draft/glpmat.c draft/glpscl.c draft/glpssx01.c draft/glpssx02.c draft/lux.c

  env/alloc.c env/dlsup.c env/env.c env/error.c env/stdc.c env/stdout.c
  env/stream.c env/time.c env/tls.c

  intopt/cfg.c intopt/cfg1.c intopt/cfg2.c intopt/clqcut.c intopt/covgen.c
  intopt/fpump.c intopt/gmicut.c intopt/gmigen.c intopt/mirgen.c intopt/spv.c

  minisat/minisat.c

  misc/avl.c misc/bignum.c misc/dimacs.c misc/dmp.c misc/ffalg.c misc/fp2rat.c
  misc/fvs.c misc/gcd.c misc/hbm.c misc/jd.c misc/keller.c misc/ks.c
  misc/mc13d.c misc/mc21a.c misc/mt1.c misc/mygmp.c misc/okalg.c misc/qmd.c
  misc/relax4.c misc/rgr.c misc/rng.c misc/rng1.c misc/round2n.c misc/spm.c
  misc/str2int.c misc/str2num.c misc/strspx.c misc/strtrim.c misc/triang.c
  misc/wclique.c misc/wclique1.c

  mpl/mpl1.c mpl/mpl2.c mpl/mpl3.c mpl/mpl4.c mpl/mpl5.c mpl/mpl6.c
  mpl/mplsql.c

  npp/npp1.c npp/npp2.c npp/npp3.c npp/npp4.c npp/npp5.c npp/npp6.c

  proxy/proxy.c proxy/proxy1.c

  simplex/spxat.c simplex/spxchuzc.c simplex/spxchuzr.c simplex/spxlp.c
  simplex/spxnt.c simplex/spxprim.c simplex/spxprob.c simplex/spychuzc.c
  simplex/spychuzr.c simplex/spydual.c

  # amd/amd_dump.c has no symbols
)

target_include_directories(
  glpk_vendored
  PUBLIC
  ${CMAKE_CURRENT_SOURCE_DIR}
  PRIVATE
  ${CMAKE_CURRENT_SOURCE_DIR}/amd
  ${CMAKE_CURRENT_SOURCE_DIR}/api
  ${CMAKE_CURRENT_SOURCE_DIR}/bflib
  ${CMAKE_CURRENT_SOURCE_DIR}/colamd
  ${CMAKE_CURRENT_SOURCE_DIR}/draft
  ${CMAKE_CURRENT_SOURCE_DIR}/env
  ${CMAKE_CURRENT_SOURCE_DIR}/intopt
  ${CMAKE_CURRENT_SOURCE_DIR}/minisat
  ${CMAKE_CURRENT_SOURCE_DIR}/misc
  ${CMAKE_CURRENT_SOURCE_DIR}/mpl
  ${CMAKE_CURRENT_SOURCE_DIR}/npp
  ${CMAKE_CURRENT_SOURCE_DIR}/simplex
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
  ${PROJECT_BINARY_DIR}/src # config.h for TLS
)

# We are using IGRAPH_FILE_BASENAME in glpk/env/env.h
define_file_basename_for_sources(glpk_vendored)

if (BUILD_SHARED_LIBS)
  set_property(TARGET glpk_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Since these are included as object files, they should call the
# function as is (without visibility specification)
target_compile_definitions(glpk_vendored PRIVATE IGRAPH_STATIC)

# GLPK requires __WOE__ to be defined when building for Windows,
# either with MSVC or with MinGW.
# See w64/config_VC in the original GLPK distribution
if (WIN32)
  target_compile_definitions(glpk_vendored PRIVATE __WOE__=1)
endif()

if (MSVC)
  target_compile_options(glpk_vendored PRIVATE
    /wd4068
  )
else()
  target_compile_options(glpk_vendored PRIVATE
    $<$:-wd161 -Wno-return-type>
    $<$:-Wno-return-type -Wno-unused-value -Wno-dangling-else -Wno-logical-op-parentheses>
  )
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/COPYING0000644000175100001710000010451300000000000023143 0ustar00runnerdocker00000000000000                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. 
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    
    Copyright (C)   

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see .

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

      Copyright (C)   
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/README0000644000175100001710000000232200000000000022763 0ustar00runnerdocker00000000000000GLPK (GNU Linear Programming Kit) Version 5.0
Copyright (C) 2000-2020 Free Software Foundation, Inc.

GLPK is part of the GNU Project released under the aegis of GNU.

GLPK is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.

See the file COPYING for the GNU General Public License.

See the file INSTALL for compilation and installation instructions.

The GLPK package is a set of routines written in ANSI C and organized
in the form of a callable library. This package is intended for solving
large-scale linear programming (LP), mixed integer linear programming
(MIP), and other related problems.

The GLPK package includes the following main components:

* primal simplex method;
* dual simplex method;
* exact simplex method based on rational arithmetic;
* primal-dual interior-point method;
* branch-and-cut method;
* application program interface (API);
* GNU MathProg modeling language (a subset of AMPL);
* GLPSOL (stand-alone LP/MIP solver).

See GLPK webpage .

Please report bugs to .
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6551428
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/0000755000175100001710000000000000000000000022645 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/COPYING0000644000175100001710000006362500000000000023714 0ustar00runnerdocker00000000000000                  GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999

 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

                  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.

  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

                            NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

                     END OF TERMS AND CONDITIONS

           How to Apply These Terms to Your New Libraries

  If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

  To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

    
    Copyright (C)   

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

  , 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/README0000644000175100001710000000461700000000000023535 0ustar00runnerdocker00000000000000NOTE: Files in this subdirectory are NOT part of the GLPK package, but
      are used with GLPK.

      The original code was modified according to GLPK requirements by
      Andrew Makhorin .
************************************************************************
AMD Version 2.2, Copyright (C) 2007 by Timothy A. Davis,
Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.

Description:

   AMD is a set of routines for pre-ordering sparse matrices prior to
   Cholesky or LU factorization, using the approximate minimum degree
   ordering algorithm.  Written in ANSI/ISO C with a MATLAB interface,
   and in Fortran 77.

Authors:

   Timothy A. Davis (davis at cise.ufl.edu), University of Florida.
   Patrick R. Amestoy, ENSEEIHT, Toulouse, France.
   Iain S. Duff, Rutherford Appleton Laboratory, UK.

AMD License:

   Your use or distribution of AMD or any modified version of AMD
   implies that you agree to this License.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1 of
   the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
   USA.

   Permission is hereby granted to use or copy this program under the
   terms of the GNU LGPL, provided that the Copyright, this License,
   and the Availability of the original version is retained on all
   copies.  User documentation of any code that uses this code or any
   modified version of this code must cite the Copyright, this License,
   the Availability note, and "Used by permission."  Permission to
   modify the code and to distribute modified code is granted, provided
   the Copyright, this License, and the Availability note are retained,
   and a notice that the code was modified is included.

   AMD is available under alternate licences; contact T. Davis for
   details.

Availability:

    http://www.cise.ufl.edu/research/sparse/amd
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd.h0000644000175100001710000000327600000000000023567 0ustar00runnerdocker00000000000000/* amd.h */

/* Written by Andrew Makhorin . */

#ifndef GLPAMD_H
#define GLPAMD_H

#define AMD_DATE "May 31, 2007"
#define AMD_VERSION_CODE(main, sub) ((main) * 1000 + (sub))
#define AMD_MAIN_VERSION 2
#define AMD_SUB_VERSION 2
#define AMD_SUBSUB_VERSION 0
#define AMD_VERSION AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)

#define AMD_CONTROL 5
#define AMD_INFO 20

#define AMD_DENSE 0
#define AMD_AGGRESSIVE 1

#define AMD_DEFAULT_DENSE 10.0
#define AMD_DEFAULT_AGGRESSIVE 1

#define AMD_STATUS         0
#define AMD_N              1
#define AMD_NZ             2
#define AMD_SYMMETRY       3
#define AMD_NZDIAG         4
#define AMD_NZ_A_PLUS_AT   5
#define AMD_NDENSE         6
#define AMD_MEMORY         7
#define AMD_NCMPA          8
#define AMD_LNZ            9
#define AMD_NDIV           10
#define AMD_NMULTSUBS_LDL  11
#define AMD_NMULTSUBS_LU   12
#define AMD_DMAX           13

#define AMD_OK             0
#define AMD_OUT_OF_MEMORY  (-1)
#define AMD_INVALID        (-2)
#define AMD_OK_BUT_JUMBLED 1

#define amd_order _glp_amd_order
int amd_order(int n, const int Ap[], const int Ai[], int P[],
      double Control[], double Info[]);

#define amd_2 _glp_amd_2
void amd_2(int n, int Pe[], int Iw[], int Len[], int iwlen, int pfree,
      int Nv[], int Next[], int Last[], int Head[], int Elen[],
      int Degree[], int W[], double Control[], double Info[]);

#define amd_valid _glp_amd_valid
int amd_valid(int n_row, int n_col, const int Ap[], const int Ai[]);

#define amd_defaults _glp_amd_defaults
void amd_defaults(double Control[]);

#define amd_control _glp_amd_control
void amd_control(double Control[]);

#define amd_info _glp_amd_info
void amd_info(double Info[]);

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_1.c0000644000175100001710000001504300000000000023775 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_1 =============================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* AMD_1: Construct A+A' for a sparse matrix A and perform the AMD ordering.
 *
 * The n-by-n sparse matrix A can be unsymmetric.  It is stored in MATLAB-style
 * compressed-column form, with sorted row indices in each column, and no
 * duplicate entries.  Diagonal entries may be present, but they are ignored.
 * Row indices of column j of A are stored in Ai [Ap [j] ... Ap [j+1]-1].
 * Ap [0] must be zero, and nz = Ap [n] is the number of entries in A.  The
 * size of the matrix, n, must be greater than or equal to zero.
 *
 * This routine must be preceded by a call to AMD_aat, which computes the
 * number of entries in each row/column in A+A', excluding the diagonal.
 * Len [j], on input, is the number of entries in row/column j of A+A'.  This
 * routine constructs the matrix A+A' and then calls AMD_2.  No error checking
 * is performed (this was done in AMD_valid).
 */

#include "amd_internal.h"

GLOBAL void AMD_1
(
    Int n,              /* n > 0 */
    const Int Ap [ ],   /* input of size n+1, not modified */
    const Int Ai [ ],   /* input of size nz = Ap [n], not modified */
    Int P [ ],          /* size n output permutation */
    Int Pinv [ ],       /* size n output inverse permutation */
    Int Len [ ],        /* size n input, undefined on output */
    Int slen,           /* slen >= sum (Len [0..n-1]) + 7n,
                         * ideally slen = 1.2 * sum (Len) + 8n */
    Int S [ ],          /* size slen workspace */
    double Control [ ], /* input array of size AMD_CONTROL */
    double Info [ ]     /* output array of size AMD_INFO */
)
{
    Int i, j, k, p, pfree, iwlen, pj, p1, p2, pj2, *Iw, *Pe, *Nv, *Head,
        *Elen, *Degree, *s, *W, *Sp, *Tp ;

    /* --------------------------------------------------------------------- */
    /* construct the matrix for AMD_2 */
    /* --------------------------------------------------------------------- */

    ASSERT (n > 0) ;

    iwlen = slen - 6*n ;
    s = S ;
    Pe = s ;        s += n ;
    Nv = s ;        s += n ;
    Head = s ;      s += n ;
    Elen = s ;      s += n ;
    Degree = s ;    s += n ;
    W = s ;         s += n ;
    Iw = s ;        s += iwlen ;

    ASSERT (AMD_valid (n, n, Ap, Ai) == AMD_OK) ;

    /* construct the pointers for A+A' */
    Sp = Nv ;                   /* use Nv and W as workspace for Sp and Tp [ */
    Tp = W ;
    pfree = 0 ;
    for (j = 0 ; j < n ; j++)
    {
        Pe [j] = pfree ;
        Sp [j] = pfree ;
        pfree += Len [j] ;
    }

    /* Note that this restriction on iwlen is slightly more restrictive than
     * what is strictly required in AMD_2.  AMD_2 can operate with no elbow
     * room at all, but it will be very slow.  For better performance, at
     * least size-n elbow room is enforced. */
    ASSERT (iwlen >= pfree + n) ;

#ifndef NDEBUG
    for (p = 0 ; p < iwlen ; p++) Iw [p] = EMPTY ;
#endif

    for (k = 0 ; k < n ; k++)
    {
        AMD_DEBUG1 (("Construct row/column k= "ID" of A+A'\n", k))  ;
        p1 = Ap [k] ;
        p2 = Ap [k+1] ;

        /* construct A+A' */
        for (p = p1 ; p < p2 ; )
        {
            /* scan the upper triangular part of A */
            j = Ai [p] ;
            ASSERT (j >= 0 && j < n) ;
            if (j < k)
            {
                /* entry A (j,k) in the strictly upper triangular part */
                ASSERT (Sp [j] < (j == n-1 ? pfree : Pe [j+1])) ;
                ASSERT (Sp [k] < (k == n-1 ? pfree : Pe [k+1])) ;
                Iw [Sp [j]++] = k ;
                Iw [Sp [k]++] = j ;
                p++ ;
            }
            else if (j == k)
            {
                /* skip the diagonal */
                p++ ;
                break ;
            }
            else /* j > k */
            {
                /* first entry below the diagonal */
                break ;
            }
            /* scan lower triangular part of A, in column j until reaching
             * row k.  Start where last scan left off. */
            ASSERT (Ap [j] <= Tp [j] && Tp [j] <= Ap [j+1]) ;
            pj2 = Ap [j+1] ;
            for (pj = Tp [j] ; pj < pj2 ; )
            {
                i = Ai [pj] ;
                ASSERT (i >= 0 && i < n) ;
                if (i < k)
                {
                    /* A (i,j) is only in the lower part, not in upper */
                    ASSERT (Sp [i] < (i == n-1 ? pfree : Pe [i+1])) ;
                    ASSERT (Sp [j] < (j == n-1 ? pfree : Pe [j+1])) ;
                    Iw [Sp [i]++] = j ;
                    Iw [Sp [j]++] = i ;
                    pj++ ;
                }
                else if (i == k)
                {
                    /* entry A (k,j) in lower part and A (j,k) in upper */
                    pj++ ;
                    break ;
                }
                else /* i > k */
                {
                    /* consider this entry later, when k advances to i */
                    break ;
                }
            }
            Tp [j] = pj ;
        }
        Tp [k] = p ;
    }

    /* clean up, for remaining mismatched entries */
    for (j = 0 ; j < n ; j++)
    {
        for (pj = Tp [j] ; pj < Ap [j+1] ; pj++)
        {
            i = Ai [pj] ;
            ASSERT (i >= 0 && i < n) ;
            /* A (i,j) is only in the lower part, not in upper */
            ASSERT (Sp [i] < (i == n-1 ? pfree : Pe [i+1])) ;
            ASSERT (Sp [j] < (j == n-1 ? pfree : Pe [j+1])) ;
            Iw [Sp [i]++] = j ;
            Iw [Sp [j]++] = i ;
        }
    }

#ifndef NDEBUG
    for (j = 0 ; j < n-1 ; j++) ASSERT (Sp [j] == Pe [j+1]) ;
    ASSERT (Sp [n-1] == pfree) ;
#endif

    /* Tp and Sp no longer needed ] */

    /* --------------------------------------------------------------------- */
    /* order the matrix */
    /* --------------------------------------------------------------------- */

    AMD_2 (n, Pe, Iw, Len, iwlen, pfree,
        Nv, Pinv, P, Head, Elen, Degree, W, Control, Info) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_2.c0000644000175100001710000023046700000000000024007 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_2 =============================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* AMD_2:  performs the AMD ordering on a symmetric sparse matrix A, followed
 * by a postordering (via depth-first search) of the assembly tree using the
 * AMD_postorder routine.
 */

#include "amd_internal.h"

/* ========================================================================= */
/* === clear_flag ========================================================== */
/* ========================================================================= */

static Int clear_flag (Int wflg, Int wbig, Int W [ ], Int n)
{
    Int x ;
    if (wflg < 2 || wflg >= wbig)
    {
        for (x = 0 ; x < n ; x++)
        {
            if (W [x] != 0) W [x] = 1 ;
        }
        wflg = 2 ;
    }
    /*  at this point, W [0..n-1] < wflg holds */
    return (wflg) ;
}


/* ========================================================================= */
/* === AMD_2 =============================================================== */
/* ========================================================================= */

GLOBAL void AMD_2
(
    Int n,              /* A is n-by-n, where n > 0 */
    Int Pe [ ],         /* Pe [0..n-1]: index in Iw of row i on input */
    Int Iw [ ],         /* workspace of size iwlen. Iw [0..pfree-1]
                         * holds the matrix on input */
    Int Len [ ],        /* Len [0..n-1]: length for row/column i on input */
    Int iwlen,          /* length of Iw. iwlen >= pfree + n */
    Int pfree,          /* Iw [pfree ... iwlen-1] is empty on input */

    /* 7 size-n workspaces, not defined on input: */
    Int Nv [ ],         /* the size of each supernode on output */
    Int Next [ ],       /* the output inverse permutation */
    Int Last [ ],       /* the output permutation */
    Int Head [ ],
    Int Elen [ ],       /* the size columns of L for each supernode */
    Int Degree [ ],
    Int W [ ],

    /* control parameters and output statistics */
    double Control [ ], /* array of size AMD_CONTROL */
    double Info [ ]     /* array of size AMD_INFO */
)
{

/*
 * Given a representation of the nonzero pattern of a symmetric matrix, A,
 * (excluding the diagonal) perform an approximate minimum (UMFPACK/MA38-style)
 * degree ordering to compute a pivot order such that the introduction of
 * nonzeros (fill-in) in the Cholesky factors A = LL' is kept low.  At each
 * step, the pivot selected is the one with the minimum UMFAPACK/MA38-style
 * upper-bound on the external degree.  This routine can optionally perform
 * aggresive absorption (as done by MC47B in the Harwell Subroutine
 * Library).
 *
 * The approximate degree algorithm implemented here is the symmetric analog of
 * the degree update algorithm in MA38 and UMFPACK (the Unsymmetric-pattern
 * MultiFrontal PACKage, both by Davis and Duff).  The routine is based on the
 * MA27 minimum degree ordering algorithm by Iain Duff and John Reid.
 *
 * This routine is a translation of the original AMDBAR and MC47B routines,
 * in Fortran, with the following modifications:
 *
 * (1) dense rows/columns are removed prior to ordering the matrix, and placed
 *      last in the output order.  The presence of a dense row/column can
 *      increase the ordering time by up to O(n^2), unless they are removed
 *      prior to ordering.
 *
 * (2) the minimum degree ordering is followed by a postordering (depth-first
 *      search) of the assembly tree.  Note that mass elimination (discussed
 *      below) combined with the approximate degree update can lead to the mass
 *      elimination of nodes with lower exact degree than the current pivot
 *      element.  No additional fill-in is caused in the representation of the
 *      Schur complement.  The mass-eliminated nodes merge with the current
 *      pivot element.  They are ordered prior to the current pivot element.
 *      Because they can have lower exact degree than the current element, the
 *      merger of two or more of these nodes in the current pivot element can
 *      lead to a single element that is not a "fundamental supernode".  The
 *      diagonal block can have zeros in it.  Thus, the assembly tree used here
 *      is not guaranteed to be the precise supernodal elemination tree (with
 *      "funadmental" supernodes), and the postordering performed by this
 *      routine is not guaranteed to be a precise postordering of the
 *      elimination tree.
 *
 * (3) input parameters are added, to control aggressive absorption and the
 *      detection of "dense" rows/columns of A.
 *
 * (4) additional statistical information is returned, such as the number of
 *      nonzeros in L, and the flop counts for subsequent LDL' and LU
 *      factorizations.  These are slight upper bounds, because of the mass
 *      elimination issue discussed above.
 *
 * (5) additional routines are added to interface this routine to MATLAB
 *      to provide a simple C-callable user-interface, to check inputs for
 *      errors, compute the symmetry of the pattern of A and the number of
 *      nonzeros in each row/column of A+A', to compute the pattern of A+A',
 *      to perform the assembly tree postordering, and to provide debugging
 *      ouput.  Many of these functions are also provided by the Fortran
 *      Harwell Subroutine Library routine MC47A.
 *
 * (6) both int and UF_long versions are provided.  In the descriptions below
 *      and integer is and int or UF_long depending on which version is
 *      being used.

 **********************************************************************
 ***** CAUTION:  ARGUMENTS ARE NOT CHECKED FOR ERRORS ON INPUT.  ******
 **********************************************************************
 ** If you want error checking, a more versatile input format, and a **
 ** simpler user interface, use amd_order or amd_l_order instead.    **
 ** This routine is not meant to be user-callable.                   **
 **********************************************************************

 * ----------------------------------------------------------------------------
 * References:
 * ----------------------------------------------------------------------------
 *
 *  [1] Timothy A. Davis and Iain Duff, "An unsymmetric-pattern multifrontal
 *      method for sparse LU factorization", SIAM J. Matrix Analysis and
 *      Applications, vol. 18, no. 1, pp. 140-158.  Discusses UMFPACK / MA38,
 *      which first introduced the approximate minimum degree used by this
 *      routine.
 *
 *  [2] Patrick Amestoy, Timothy A. Davis, and Iain S. Duff, "An approximate
 *      minimum degree ordering algorithm," SIAM J. Matrix Analysis and
 *      Applications, vol. 17, no. 4, pp. 886-905, 1996.  Discusses AMDBAR and
 *      MC47B, which are the Fortran versions of this routine.
 *
 *  [3] Alan George and Joseph Liu, "The evolution of the minimum degree
 *      ordering algorithm," SIAM Review, vol. 31, no. 1, pp. 1-19, 1989.
 *      We list below the features mentioned in that paper that this code
 *      includes:
 *
 *      mass elimination:
 *          Yes.  MA27 relied on supervariable detection for mass elimination.
 *
 *      indistinguishable nodes:
 *          Yes (we call these "supervariables").  This was also in the MA27
 *          code - although we modified the method of detecting them (the
 *          previous hash was the true degree, which we no longer keep track
 *          of).  A supervariable is a set of rows with identical nonzero
 *          pattern.  All variables in a supervariable are eliminated together.
 *          Each supervariable has as its numerical name that of one of its
 *          variables (its principal variable).
 *
 *      quotient graph representation:
 *          Yes.  We use the term "element" for the cliques formed during
 *          elimination.  This was also in the MA27 code.  The algorithm can
 *          operate in place, but it will work more efficiently if given some
 *          "elbow room."
 *
 *      element absorption:
 *          Yes.  This was also in the MA27 code.
 *
 *      external degree:
 *          Yes.  The MA27 code was based on the true degree.
 *
 *      incomplete degree update and multiple elimination:
 *          No.  This was not in MA27, either.  Our method of degree update
 *          within MC47B is element-based, not variable-based.  It is thus
 *          not well-suited for use with incomplete degree update or multiple
 *          elimination.
 *
 * Authors, and Copyright (C) 2004 by:
 * Timothy A. Davis, Patrick Amestoy, Iain S. Duff, John K. Reid.
 *
 * Acknowledgements: This work (and the UMFPACK package) was supported by the
 * National Science Foundation (ASC-9111263, DMS-9223088, and CCR-0203270).
 * The UMFPACK/MA38 approximate degree update algorithm, the unsymmetric analog
 * which forms the basis of AMD, was developed while Tim Davis was supported by
 * CERFACS (Toulouse, France) in a post-doctoral position.  This C version, and
 * the etree postorder, were written while Tim Davis was on sabbatical at
 * Stanford University and Lawrence Berkeley National Laboratory.

 * ----------------------------------------------------------------------------
 * INPUT ARGUMENTS (unaltered):
 * ----------------------------------------------------------------------------

 * n:  The matrix order.  Restriction:  n >= 1.
 *
 * iwlen:  The size of the Iw array.  On input, the matrix is stored in
 *      Iw [0..pfree-1].  However, Iw [0..iwlen-1] should be slightly larger
 *      than what is required to hold the matrix, at least iwlen >= pfree + n.
 *      Otherwise, excessive compressions will take place.  The recommended
 *      value of iwlen is 1.2 * pfree + n, which is the value used in the
 *      user-callable interface to this routine (amd_order.c).  The algorithm
 *      will not run at all if iwlen < pfree.  Restriction: iwlen >= pfree + n.
 *      Note that this is slightly more restrictive than the actual minimum
 *      (iwlen >= pfree), but AMD_2 will be very slow with no elbow room.
 *      Thus, this routine enforces a bare minimum elbow room of size n.
 *
 * pfree: On input the tail end of the array, Iw [pfree..iwlen-1], is empty,
 *      and the matrix is stored in Iw [0..pfree-1].  During execution,
 *      additional data is placed in Iw, and pfree is modified so that
 *      Iw [pfree..iwlen-1] is always the unused part of Iw.
 *
 * Control:  A double array of size AMD_CONTROL containing input parameters
 *      that affect how the ordering is computed.  If NULL, then default
 *      settings are used.
 *
 *      Control [AMD_DENSE] is used to determine whether or not a given input
 *      row is "dense".  A row is "dense" if the number of entries in the row
 *      exceeds Control [AMD_DENSE] times sqrt (n), except that rows with 16 or
 *      fewer entries are never considered "dense".  To turn off the detection
 *      of dense rows, set Control [AMD_DENSE] to a negative number, or to a
 *      number larger than sqrt (n).  The default value of Control [AMD_DENSE]
 *      is AMD_DEFAULT_DENSE, which is defined in amd.h as 10.
 *
 *      Control [AMD_AGGRESSIVE] is used to determine whether or not aggressive
 *      absorption is to be performed.  If nonzero, then aggressive absorption
 *      is performed (this is the default).

 * ----------------------------------------------------------------------------
 * INPUT/OUPUT ARGUMENTS:
 * ----------------------------------------------------------------------------
 *
 * Pe:  An integer array of size n.  On input, Pe [i] is the index in Iw of
 *      the start of row i.  Pe [i] is ignored if row i has no off-diagonal
 *      entries.  Thus Pe [i] must be in the range 0 to pfree-1 for non-empty
 *      rows.
 *
 *      During execution, it is used for both supervariables and elements:
 *
 *      Principal supervariable i:  index into Iw of the description of
 *          supervariable i.  A supervariable represents one or more rows of
 *          the matrix with identical nonzero pattern.  In this case,
 *          Pe [i] >= 0.
 *
 *      Non-principal supervariable i:  if i has been absorbed into another
 *          supervariable j, then Pe [i] = FLIP (j), where FLIP (j) is defined
 *          as (-(j)-2).  Row j has the same pattern as row i.  Note that j
 *          might later be absorbed into another supervariable j2, in which
 *          case Pe [i] is still FLIP (j), and Pe [j] = FLIP (j2) which is
 *          < EMPTY, where EMPTY is defined as (-1) in amd_internal.h.
 *
 *      Unabsorbed element e:  the index into Iw of the description of element
 *          e, if e has not yet been absorbed by a subsequent element.  Element
 *          e is created when the supervariable of the same name is selected as
 *          the pivot.  In this case, Pe [i] >= 0.
 *
 *      Absorbed element e:  if element e is absorbed into element e2, then
 *          Pe [e] = FLIP (e2).  This occurs when the pattern of e (which we
 *          refer to as Le) is found to be a subset of the pattern of e2 (that
 *          is, Le2).  In this case, Pe [i] < EMPTY.  If element e is "null"
 *          (it has no nonzeros outside its pivot block), then Pe [e] = EMPTY,
 *          and e is the root of an assembly subtree (or the whole tree if
 *          there is just one such root).
 *
 *      Dense variable i:  if i is "dense", then Pe [i] = EMPTY.
 *
 *      On output, Pe holds the assembly tree/forest, which implicitly
 *      represents a pivot order with identical fill-in as the actual order
 *      (via a depth-first search of the tree), as follows.  If Nv [i] > 0,
 *      then i represents a node in the assembly tree, and the parent of i is
 *      Pe [i], or EMPTY if i is a root.  If Nv [i] = 0, then (i, Pe [i])
 *      represents an edge in a subtree, the root of which is a node in the
 *      assembly tree.  Note that i refers to a row/column in the original
 *      matrix, not the permuted matrix.
 *
 * Info:  A double array of size AMD_INFO.  If present, (that is, not NULL),
 *      then statistics about the ordering are returned in the Info array.
 *      See amd.h for a description.

 * ----------------------------------------------------------------------------
 * INPUT/MODIFIED (undefined on output):
 * ----------------------------------------------------------------------------
 *
 * Len:  An integer array of size n.  On input, Len [i] holds the number of
 *      entries in row i of the matrix, excluding the diagonal.  The contents
 *      of Len are undefined on output.
 *
 * Iw:  An integer array of size iwlen.  On input, Iw [0..pfree-1] holds the
 *      description of each row i in the matrix.  The matrix must be symmetric,
 *      and both upper and lower triangular parts must be present.  The
 *      diagonal must not be present.  Row i is held as follows:
 *
 *          Len [i]:  the length of the row i data structure in the Iw array.
 *          Iw [Pe [i] ... Pe [i] + Len [i] - 1]:
 *              the list of column indices for nonzeros in row i (simple
 *              supervariables), excluding the diagonal.  All supervariables
 *              start with one row/column each (supervariable i is just row i).
 *              If Len [i] is zero on input, then Pe [i] is ignored on input.
 *
 *          Note that the rows need not be in any particular order, and there
 *          may be empty space between the rows.
 *
 *      During execution, the supervariable i experiences fill-in.  This is
 *      represented by placing in i a list of the elements that cause fill-in
 *      in supervariable i:
 *
 *          Len [i]:  the length of supervariable i in the Iw array.
 *          Iw [Pe [i] ... Pe [i] + Elen [i] - 1]:
 *              the list of elements that contain i.  This list is kept short
 *              by removing absorbed elements.
 *          Iw [Pe [i] + Elen [i] ... Pe [i] + Len [i] - 1]:
 *              the list of supervariables in i.  This list is kept short by
 *              removing nonprincipal variables, and any entry j that is also
 *              contained in at least one of the elements (j in Le) in the list
 *              for i (e in row i).
 *
 *      When supervariable i is selected as pivot, we create an element e of
 *      the same name (e=i):
 *
 *          Len [e]:  the length of element e in the Iw array.
 *          Iw [Pe [e] ... Pe [e] + Len [e] - 1]:
 *              the list of supervariables in element e.
 *
 *      An element represents the fill-in that occurs when supervariable i is
 *      selected as pivot (which represents the selection of row i and all
 *      non-principal variables whose principal variable is i).  We use the
 *      term Le to denote the set of all supervariables in element e.  Absorbed
 *      supervariables and elements are pruned from these lists when
 *      computationally convenient.
 *
 *  CAUTION:  THE INPUT MATRIX IS OVERWRITTEN DURING COMPUTATION.
 *  The contents of Iw are undefined on output.

 * ----------------------------------------------------------------------------
 * OUTPUT (need not be set on input):
 * ----------------------------------------------------------------------------
 *
 * Nv:  An integer array of size n.  During execution, ABS (Nv [i]) is equal to
 *      the number of rows that are represented by the principal supervariable
 *      i.  If i is a nonprincipal or dense variable, then Nv [i] = 0.
 *      Initially, Nv [i] = 1 for all i.  Nv [i] < 0 signifies that i is a
 *      principal variable in the pattern Lme of the current pivot element me.
 *      After element me is constructed, Nv [i] is set back to a positive
 *      value.
 *
 *      On output, Nv [i] holds the number of pivots represented by super
 *      row/column i of the original matrix, or Nv [i] = 0 for non-principal
 *      rows/columns.  Note that i refers to a row/column in the original
 *      matrix, not the permuted matrix.
 *
 * Elen:  An integer array of size n.  See the description of Iw above.  At the
 *      start of execution, Elen [i] is set to zero for all rows i.  During
 *      execution, Elen [i] is the number of elements in the list for
 *      supervariable i.  When e becomes an element, Elen [e] = FLIP (esize) is
 *      set, where esize is the size of the element (the number of pivots, plus
 *      the number of nonpivotal entries).  Thus Elen [e] < EMPTY.
 *      Elen (i) = EMPTY set when variable i becomes nonprincipal.
 *
 *      For variables, Elen (i) >= EMPTY holds until just before the
 *      postordering and permutation vectors are computed.  For elements,
 *      Elen [e] < EMPTY holds.
 *
 *      On output, Elen [i] is the degree of the row/column in the Cholesky
 *      factorization of the permuted matrix, corresponding to the original row
 *      i, if i is a super row/column.  It is equal to EMPTY if i is
 *      non-principal.  Note that i refers to a row/column in the original
 *      matrix, not the permuted matrix.
 *
 *      Note that the contents of Elen on output differ from the Fortran
 *      version (Elen holds the inverse permutation in the Fortran version,
 *      which is instead returned in the Next array in this C version,
 *      described below).
 *
 * Last: In a degree list, Last [i] is the supervariable preceding i, or EMPTY
 *      if i is the head of the list.  In a hash bucket, Last [i] is the hash
 *      key for i.
 *
 *      Last [Head [hash]] is also used as the head of a hash bucket if
 *      Head [hash] contains a degree list (see the description of Head,
 *      below).
 *
 *      On output, Last [0..n-1] holds the permutation.  That is, if
 *      i = Last [k], then row i is the kth pivot row (where k ranges from 0 to
 *      n-1).  Row Last [k] of A is the kth row in the permuted matrix, PAP'.
 *
 * Next: Next [i] is the supervariable following i in a link list, or EMPTY if
 *      i is the last in the list.  Used for two kinds of lists:  degree lists
 *      and hash buckets (a supervariable can be in only one kind of list at a
 *      time).
 *
 *      On output Next [0..n-1] holds the inverse permutation.  That is, if
 *      k = Next [i], then row i is the kth pivot row. Row i of A appears as
 *      the (Next[i])-th row in the permuted matrix, PAP'.
 *
 *      Note that the contents of Next on output differ from the Fortran
 *      version (Next is undefined on output in the Fortran version).

 * ----------------------------------------------------------------------------
 * LOCAL WORKSPACE (not input or output - used only during execution):
 * ----------------------------------------------------------------------------
 *
 * Degree:  An integer array of size n.  If i is a supervariable, then
 *      Degree [i] holds the current approximation of the external degree of
 *      row i (an upper bound).  The external degree is the number of nonzeros
 *      in row i, minus ABS (Nv [i]), the diagonal part.  The bound is equal to
 *      the exact external degree if Elen [i] is less than or equal to two.
 *
 *      We also use the term "external degree" for elements e to refer to
 *      |Le \ Lme|.  If e is an element, then Degree [e] is |Le|, which is the
 *      degree of the off-diagonal part of the element e (not including the
 *      diagonal part).
 *
 * Head:   An integer array of size n.  Head is used for degree lists.
 *      Head [deg] is the first supervariable in a degree list.  All
 *      supervariables i in a degree list Head [deg] have the same approximate
 *      degree, namely, deg = Degree [i].  If the list Head [deg] is empty then
 *      Head [deg] = EMPTY.
 *
 *      During supervariable detection Head [hash] also serves as a pointer to
 *      a hash bucket.  If Head [hash] >= 0, there is a degree list of degree
 *      hash.  The hash bucket head pointer is Last [Head [hash]].  If
 *      Head [hash] = EMPTY, then the degree list and hash bucket are both
 *      empty.  If Head [hash] < EMPTY, then the degree list is empty, and
 *      FLIP (Head [hash]) is the head of the hash bucket.  After supervariable
 *      detection is complete, all hash buckets are empty, and the
 *      (Last [Head [hash]] = EMPTY) condition is restored for the non-empty
 *      degree lists.
 *
 * W:  An integer array of size n.  The flag array W determines the status of
 *      elements and variables, and the external degree of elements.
 *
 *      for elements:
 *          if W [e] = 0, then the element e is absorbed.
 *          if W [e] >= wflg, then W [e] - wflg is the size of the set
 *              |Le \ Lme|, in terms of nonzeros (the sum of ABS (Nv [i]) for
 *              each principal variable i that is both in the pattern of
 *              element e and NOT in the pattern of the current pivot element,
 *              me).
 *          if wflg > W [e] > 0, then e is not absorbed and has not yet been
 *              seen in the scan of the element lists in the computation of
 *              |Le\Lme| in Scan 1 below.
 *
 *      for variables:
 *          during supervariable detection, if W [j] != wflg then j is
 *          not in the pattern of variable i.
 *
 *      The W array is initialized by setting W [i] = 1 for all i, and by
 *      setting wflg = 2.  It is reinitialized if wflg becomes too large (to
 *      ensure that wflg+n does not cause integer overflow).

 * ----------------------------------------------------------------------------
 * LOCAL INTEGERS:
 * ----------------------------------------------------------------------------
 */

    Int deg, degme, dext, lemax, e, elenme, eln, i, ilast, inext, j,
        jlast, jnext, k, knt1, knt2, knt3, lenj, ln, me, mindeg, nel, nleft,
        nvi, nvj, nvpiv, slenme, wbig, we, wflg, wnvi, ok, ndense, ncmpa,
        dense, aggressive ;

    unsigned Int hash ;     /* unsigned, so that hash % n is well defined.*/

/*
 * deg:         the degree of a variable or element
 * degme:       size, |Lme|, of the current element, me (= Degree [me])
 * dext:        external degree, |Le \ Lme|, of some element e
 * lemax:       largest |Le| seen so far (called dmax in Fortran version)
 * e:           an element
 * elenme:      the length, Elen [me], of element list of pivotal variable
 * eln:         the length, Elen [...], of an element list
 * hash:        the computed value of the hash function
 * i:           a supervariable
 * ilast:       the entry in a link list preceding i
 * inext:       the entry in a link list following i
 * j:           a supervariable
 * jlast:       the entry in a link list preceding j
 * jnext:       the entry in a link list, or path, following j
 * k:           the pivot order of an element or variable
 * knt1:        loop counter used during element construction
 * knt2:        loop counter used during element construction
 * knt3:        loop counter used during compression
 * lenj:        Len [j]
 * ln:          length of a supervariable list
 * me:          current supervariable being eliminated, and the current
 *                  element created by eliminating that supervariable
 * mindeg:      current minimum degree
 * nel:         number of pivots selected so far
 * nleft:       n - nel, the number of nonpivotal rows/columns remaining
 * nvi:         the number of variables in a supervariable i (= Nv [i])
 * nvj:         the number of variables in a supervariable j (= Nv [j])
 * nvpiv:       number of pivots in current element
 * slenme:      number of variables in variable list of pivotal variable
 * wbig:        = INT_MAX - n for the int version, UF_long_max - n for the
 *                  UF_long version.  wflg is not allowed to be >= wbig.
 * we:          W [e]
 * wflg:        used for flagging the W array.  See description of Iw.
 * wnvi:        wflg - Nv [i]
 * x:           either a supervariable or an element
 *
 * ok:          true if supervariable j can be absorbed into i
 * ndense:      number of "dense" rows/columns
 * dense:       rows/columns with initial degree > dense are considered "dense"
 * aggressive:  true if aggressive absorption is being performed
 * ncmpa:       number of garbage collections

 * ----------------------------------------------------------------------------
 * LOCAL DOUBLES, used for statistical output only (except for alpha):
 * ----------------------------------------------------------------------------
 */

    double f, r, ndiv, s, nms_lu, nms_ldl, dmax, alpha, lnz, lnzme ;

/*
 * f:           nvpiv
 * r:           degme + nvpiv
 * ndiv:        number of divisions for LU or LDL' factorizations
 * s:           number of multiply-subtract pairs for LU factorization, for the
 *                  current element me
 * nms_lu       number of multiply-subtract pairs for LU factorization
 * nms_ldl      number of multiply-subtract pairs for LDL' factorization
 * dmax:        the largest number of entries in any column of L, including the
 *                  diagonal
 * alpha:       "dense" degree ratio
 * lnz:         the number of nonzeros in L (excluding the diagonal)
 * lnzme:       the number of nonzeros in L (excl. the diagonal) for the
 *                  current element me

 * ----------------------------------------------------------------------------
 * LOCAL "POINTERS" (indices into the Iw array)
 * ----------------------------------------------------------------------------
*/

    Int p, p1, p2, p3, p4, pdst, pend, pj, pme, pme1, pme2, pn, psrc ;

/*
 * Any parameter (Pe [...] or pfree) or local variable starting with "p" (for
 * Pointer) is an index into Iw, and all indices into Iw use variables starting
 * with "p."  The only exception to this rule is the iwlen input argument.
 *
 * p:           pointer into lots of things
 * p1:          Pe [i] for some variable i (start of element list)
 * p2:          Pe [i] + Elen [i] -  1 for some variable i
 * p3:          index of first supervariable in clean list
 * p4:
 * pdst:        destination pointer, for compression
 * pend:        end of memory to compress
 * pj:          pointer into an element or variable
 * pme:         pointer into the current element (pme1...pme2)
 * pme1:        the current element, me, is stored in Iw [pme1...pme2]
 * pme2:        the end of the current element
 * pn:          pointer into a "clean" variable, also used to compress
 * psrc:        source pointer, for compression
*/

/* ========================================================================= */
/*  INITIALIZATIONS */
/* ========================================================================= */

    /* Note that this restriction on iwlen is slightly more restrictive than
     * what is actually required in AMD_2.  AMD_2 can operate with no elbow
     * room at all, but it will be slow.  For better performance, at least
     * size-n elbow room is enforced. */
    ASSERT (iwlen >= pfree + n) ;
    ASSERT (n > 0) ;

    /* initialize output statistics */
    lnz = 0 ;
    ndiv = 0 ;
    nms_lu = 0 ;
    nms_ldl = 0 ;
    dmax = 1 ;
    me = EMPTY ;

    mindeg = 0 ;
    ncmpa = 0 ;
    nel = 0 ;
    lemax = 0 ;

    /* get control parameters */
    if (Control != (double *) NULL)
    {
        alpha = Control [AMD_DENSE] ;
        aggressive = (Control [AMD_AGGRESSIVE] != 0) ;
    }
    else
    {
        alpha = AMD_DEFAULT_DENSE ;
        aggressive = AMD_DEFAULT_AGGRESSIVE ;
    }
    /* Note: if alpha is NaN, this is undefined: */
    if (alpha < 0)
    {
        /* only remove completely dense rows/columns */
        dense = n-2 ;
    }
    else
    {
        dense = alpha * sqrt ((double) n) ;
    }
    dense = MAX (16, dense) ;
    dense = MIN (n,  dense) ;
    AMD_DEBUG1 (("\n\nAMD (debug), alpha %g, aggr. "ID"\n",
        alpha, aggressive)) ;

    for (i = 0 ; i < n ; i++)
    {
        Last [i] = EMPTY ;
        Head [i] = EMPTY ;
        Next [i] = EMPTY ;
        /* if separate Hhead array is used for hash buckets: *
        Hhead [i] = EMPTY ;
        */
        Nv [i] = 1 ;
        W [i] = 1 ;
        Elen [i] = 0 ;
        Degree [i] = Len [i] ;
    }

#ifndef NDEBUG
    AMD_DEBUG1 (("\n======Nel "ID" initial\n", nel)) ;
    AMD_dump (n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last,
                Head, Elen, Degree, W, -1) ;
#endif

    /* initialize wflg */
    wbig = Int_MAX - n ;
    wflg = clear_flag (0, wbig, W, n) ;

    /* --------------------------------------------------------------------- */
    /* initialize degree lists and eliminate dense and empty rows */
    /* --------------------------------------------------------------------- */

    ndense = 0 ;

    for (i = 0 ; i < n ; i++)
    {
        deg = Degree [i] ;
        ASSERT (deg >= 0 && deg < n) ;
        if (deg == 0)
        {

            /* -------------------------------------------------------------
             * we have a variable that can be eliminated at once because
             * there is no off-diagonal non-zero in its row.  Note that
             * Nv [i] = 1 for an empty variable i.  It is treated just
             * the same as an eliminated element i.
             * ------------------------------------------------------------- */

            Elen [i] = FLIP (1) ;
            nel++ ;
            Pe [i] = EMPTY ;
            W [i] = 0 ;

        }
        else if (deg > dense)
        {

            /* -------------------------------------------------------------
             * Dense variables are not treated as elements, but as unordered,
             * non-principal variables that have no parent.  They do not take
             * part in the postorder, since Nv [i] = 0.  Note that the Fortran
             * version does not have this option.
             * ------------------------------------------------------------- */

            AMD_DEBUG1 (("Dense node "ID" degree "ID"\n", i, deg)) ;
            ndense++ ;
            Nv [i] = 0 ;                /* do not postorder this node */
            Elen [i] = EMPTY ;
            nel++ ;
            Pe [i] = EMPTY ;

        }
        else
        {

            /* -------------------------------------------------------------
             * place i in the degree list corresponding to its degree
             * ------------------------------------------------------------- */

            inext = Head [deg] ;
            ASSERT (inext >= EMPTY && inext < n) ;
            if (inext != EMPTY) Last [inext] = i ;
            Next [i] = inext ;
            Head [deg] = i ;

        }
    }

/* ========================================================================= */
/* WHILE (selecting pivots) DO */
/* ========================================================================= */

    while (nel < n)
    {

#ifndef NDEBUG
        AMD_DEBUG1 (("\n======Nel "ID"\n", nel)) ;
        if (AMD_debug >= 2)
        {
            AMD_dump (n, Pe, Iw, Len, iwlen, pfree, Nv, Next,
                    Last, Head, Elen, Degree, W, nel) ;
        }
#endif

/* ========================================================================= */
/* GET PIVOT OF MINIMUM DEGREE */
/* ========================================================================= */

        /* ----------------------------------------------------------------- */
        /* find next supervariable for elimination */
        /* ----------------------------------------------------------------- */

        ASSERT (mindeg >= 0 && mindeg < n) ;
        for (deg = mindeg ; deg < n ; deg++)
        {
            me = Head [deg] ;
            if (me != EMPTY) break ;
        }
        mindeg = deg ;
        ASSERT (me >= 0 && me < n) ;
        AMD_DEBUG1 (("=================me: "ID"\n", me)) ;

        /* ----------------------------------------------------------------- */
        /* remove chosen variable from link list */
        /* ----------------------------------------------------------------- */

        inext = Next [me] ;
        ASSERT (inext >= EMPTY && inext < n) ;
        if (inext != EMPTY) Last [inext] = EMPTY ;
        Head [deg] = inext ;

        /* ----------------------------------------------------------------- */
        /* me represents the elimination of pivots nel to nel+Nv[me]-1. */
        /* place me itself as the first in this set. */
        /* ----------------------------------------------------------------- */

        elenme = Elen [me] ;
        nvpiv = Nv [me] ;
        ASSERT (nvpiv > 0) ;
        nel += nvpiv ;

/* ========================================================================= */
/* CONSTRUCT NEW ELEMENT */
/* ========================================================================= */

        /* -----------------------------------------------------------------
         * At this point, me is the pivotal supervariable.  It will be
         * converted into the current element.  Scan list of the pivotal
         * supervariable, me, setting tree pointers and constructing new list
         * of supervariables for the new element, me.  p is a pointer to the
         * current position in the old list.
         * ----------------------------------------------------------------- */

        /* flag the variable "me" as being in Lme by negating Nv [me] */
        Nv [me] = -nvpiv ;
        degme = 0 ;
        ASSERT (Pe [me] >= 0 && Pe [me] < iwlen) ;

        if (elenme == 0)
        {

            /* ------------------------------------------------------------- */
            /* construct the new element in place */
            /* ------------------------------------------------------------- */

            pme1 = Pe [me] ;
            pme2 = pme1 - 1 ;

            for (p = pme1 ; p <= pme1 + Len [me] - 1 ; p++)
            {
                i = Iw [p] ;
                ASSERT (i >= 0 && i < n && Nv [i] >= 0) ;
                nvi = Nv [i] ;
                if (nvi > 0)
                {

                    /* ----------------------------------------------------- */
                    /* i is a principal variable not yet placed in Lme. */
                    /* store i in new list */
                    /* ----------------------------------------------------- */

                    /* flag i as being in Lme by negating Nv [i] */
                    degme += nvi ;
                    Nv [i] = -nvi ;
                    Iw [++pme2] = i ;

                    /* ----------------------------------------------------- */
                    /* remove variable i from degree list. */
                    /* ----------------------------------------------------- */

                    ilast = Last [i] ;
                    inext = Next [i] ;
                    ASSERT (ilast >= EMPTY && ilast < n) ;
                    ASSERT (inext >= EMPTY && inext < n) ;
                    if (inext != EMPTY) Last [inext] = ilast ;
                    if (ilast != EMPTY)
                    {
                        Next [ilast] = inext ;
                    }
                    else
                    {
                        /* i is at the head of the degree list */
                        ASSERT (Degree [i] >= 0 && Degree [i] < n) ;
                        Head [Degree [i]] = inext ;
                    }
                }
            }
        }
        else
        {

            /* ------------------------------------------------------------- */
            /* construct the new element in empty space, Iw [pfree ...] */
            /* ------------------------------------------------------------- */

            p = Pe [me] ;
            pme1 = pfree ;
            slenme = Len [me] - elenme ;

            for (knt1 = 1 ; knt1 <= elenme + 1 ; knt1++)
            {

                if (knt1 > elenme)
                {
                    /* search the supervariables in me. */
                    e = me ;
                    pj = p ;
                    ln = slenme ;
                    AMD_DEBUG2 (("Search sv: "ID" "ID" "ID"\n", me,pj,ln)) ;
                }
                else
                {
                    /* search the elements in me. */
                    e = Iw [p++] ;
                    ASSERT (e >= 0 && e < n) ;
                    pj = Pe [e] ;
                    ln = Len [e] ;
                    AMD_DEBUG2 (("Search element e "ID" in me "ID"\n", e,me)) ;
                    ASSERT (Elen [e] < EMPTY && W [e] > 0 && pj >= 0) ;
                }
                ASSERT (ln >= 0 && (ln == 0 || (pj >= 0 && pj < iwlen))) ;

                /* ---------------------------------------------------------
                 * search for different supervariables and add them to the
                 * new list, compressing when necessary. this loop is
                 * executed once for each element in the list and once for
                 * all the supervariables in the list.
                 * --------------------------------------------------------- */

                for (knt2 = 1 ; knt2 <= ln ; knt2++)
                {
                    i = Iw [pj++] ;
                    ASSERT (i >= 0 && i < n && (i == me || Elen [i] >= EMPTY));
                    nvi = Nv [i] ;
                    AMD_DEBUG2 ((": "ID" "ID" "ID" "ID"\n",
                                i, Elen [i], Nv [i], wflg)) ;

                    if (nvi > 0)
                    {

                        /* ------------------------------------------------- */
                        /* compress Iw, if necessary */
                        /* ------------------------------------------------- */

                        if (pfree >= iwlen)
                        {

                            AMD_DEBUG1 (("GARBAGE COLLECTION\n")) ;

                            /* prepare for compressing Iw by adjusting pointers
                             * and lengths so that the lists being searched in
                             * the inner and outer loops contain only the
                             * remaining entries. */

                            Pe [me] = p ;
                            Len [me] -= knt1 ;
                            /* check if nothing left of supervariable me */
                            if (Len [me] == 0) Pe [me] = EMPTY ;
                            Pe [e] = pj ;
                            Len [e] = ln - knt2 ;
                            /* nothing left of element e */
                            if (Len [e] == 0) Pe [e] = EMPTY ;

                            ncmpa++ ;   /* one more garbage collection */

                            /* store first entry of each object in Pe */
                            /* FLIP the first entry in each object */
                            for (j = 0 ; j < n ; j++)
                            {
                                pn = Pe [j] ;
                                if (pn >= 0)
                                {
                                    ASSERT (pn >= 0 && pn < iwlen) ;
                                    Pe [j] = Iw [pn] ;
                                    Iw [pn] = FLIP (j) ;
                                }
                            }

                            /* psrc/pdst point to source/destination */
                            psrc = 0 ;
                            pdst = 0 ;
                            pend = pme1 - 1 ;

                            while (psrc <= pend)
                            {
                                /* search for next FLIP'd entry */
                                j = FLIP (Iw [psrc++]) ;
                                if (j >= 0)
                                {
                                    AMD_DEBUG2 (("Got object j: "ID"\n", j)) ;
                                    Iw [pdst] = Pe [j] ;
                                    Pe [j] = pdst++ ;
                                    lenj = Len [j] ;
                                    /* copy from source to destination */
                                    for (knt3 = 0 ; knt3 <= lenj - 2 ; knt3++)
                                    {
                                        Iw [pdst++] = Iw [psrc++] ;
                                    }
                                }
                            }

                            /* move the new partially-constructed element */
                            p1 = pdst ;
                            for (psrc = pme1 ; psrc <= pfree-1 ; psrc++)
                            {
                                Iw [pdst++] = Iw [psrc] ;
                            }
                            pme1 = p1 ;
                            pfree = pdst ;
                            pj = Pe [e] ;
                            p = Pe [me] ;

                        }

                        /* ------------------------------------------------- */
                        /* i is a principal variable not yet placed in Lme */
                        /* store i in new list */
                        /* ------------------------------------------------- */

                        /* flag i as being in Lme by negating Nv [i] */
                        degme += nvi ;
                        Nv [i] = -nvi ;
                        Iw [pfree++] = i ;
                        AMD_DEBUG2 (("     s: "ID"     nv "ID"\n", i, Nv [i]));

                        /* ------------------------------------------------- */
                        /* remove variable i from degree link list */
                        /* ------------------------------------------------- */

                        ilast = Last [i] ;
                        inext = Next [i] ;
                        ASSERT (ilast >= EMPTY && ilast < n) ;
                        ASSERT (inext >= EMPTY && inext < n) ;
                        if (inext != EMPTY) Last [inext] = ilast ;
                        if (ilast != EMPTY)
                        {
                            Next [ilast] = inext ;
                        }
                        else
                        {
                            /* i is at the head of the degree list */
                            ASSERT (Degree [i] >= 0 && Degree [i] < n) ;
                            Head [Degree [i]] = inext ;
                        }
                    }
                }

                if (e != me)
                {
                    /* set tree pointer and flag to indicate element e is
                     * absorbed into new element me (the parent of e is me) */
                    AMD_DEBUG1 ((" Element "ID" => "ID"\n", e, me)) ;
                    Pe [e] = FLIP (me) ;
                    W [e] = 0 ;
                }
            }

            pme2 = pfree - 1 ;
        }

        /* ----------------------------------------------------------------- */
        /* me has now been converted into an element in Iw [pme1..pme2] */
        /* ----------------------------------------------------------------- */

        /* degme holds the external degree of new element */
        Degree [me] = degme ;
        Pe [me] = pme1 ;
        Len [me] = pme2 - pme1 + 1 ;
        ASSERT (Pe [me] >= 0 && Pe [me] < iwlen) ;

        Elen [me] = FLIP (nvpiv + degme) ;
        /* FLIP (Elen (me)) is now the degree of pivot (including
         * diagonal part). */

#ifndef NDEBUG
        AMD_DEBUG2 (("New element structure: length= "ID"\n", pme2-pme1+1)) ;
        for (pme = pme1 ; pme <= pme2 ; pme++) AMD_DEBUG3 ((" "ID"", Iw[pme]));
        AMD_DEBUG3 (("\n")) ;
#endif

        /* ----------------------------------------------------------------- */
        /* make sure that wflg is not too large. */
        /* ----------------------------------------------------------------- */

        /* With the current value of wflg, wflg+n must not cause integer
         * overflow */

        wflg = clear_flag (wflg, wbig, W, n) ;

/* ========================================================================= */
/* COMPUTE (W [e] - wflg) = |Le\Lme| FOR ALL ELEMENTS */
/* ========================================================================= */

        /* -----------------------------------------------------------------
         * Scan 1:  compute the external degrees of previous elements with
         * respect to the current element.  That is:
         *       (W [e] - wflg) = |Le \ Lme|
         * for each element e that appears in any supervariable in Lme.  The
         * notation Le refers to the pattern (list of supervariables) of a
         * previous element e, where e is not yet absorbed, stored in
         * Iw [Pe [e] + 1 ... Pe [e] + Len [e]].  The notation Lme
         * refers to the pattern of the current element (stored in
         * Iw [pme1..pme2]).   If aggressive absorption is enabled, and
         * (W [e] - wflg) becomes zero, then the element e will be absorbed
         * in Scan 2.
         * ----------------------------------------------------------------- */

        AMD_DEBUG2 (("me: ")) ;
        for (pme = pme1 ; pme <= pme2 ; pme++)
        {
            i = Iw [pme] ;
            ASSERT (i >= 0 && i < n) ;
            eln = Elen [i] ;
            AMD_DEBUG3 ((""ID" Elen "ID": \n", i, eln)) ;
            if (eln > 0)
            {
                /* note that Nv [i] has been negated to denote i in Lme: */
                nvi = -Nv [i] ;
                ASSERT (nvi > 0 && Pe [i] >= 0 && Pe [i] < iwlen) ;
                wnvi = wflg - nvi ;
                for (p = Pe [i] ; p <= Pe [i] + eln - 1 ; p++)
                {
                    e = Iw [p] ;
                    ASSERT (e >= 0 && e < n) ;
                    we = W [e] ;
                    AMD_DEBUG4 (("    e "ID" we "ID" ", e, we)) ;
                    if (we >= wflg)
                    {
                        /* unabsorbed element e has been seen in this loop */
                        AMD_DEBUG4 (("    unabsorbed, first time seen")) ;
                        we -= nvi ;
                    }
                    else if (we != 0)
                    {
                        /* e is an unabsorbed element */
                        /* this is the first we have seen e in all of Scan 1 */
                        AMD_DEBUG4 (("    unabsorbed")) ;
                        we = Degree [e] + wnvi ;
                    }
                    AMD_DEBUG4 (("\n")) ;
                    W [e] = we ;
                }
            }
        }
        AMD_DEBUG2 (("\n")) ;

/* ========================================================================= */
/* DEGREE UPDATE AND ELEMENT ABSORPTION */
/* ========================================================================= */

        /* -----------------------------------------------------------------
         * Scan 2:  for each i in Lme, sum up the degree of Lme (which is
         * degme), plus the sum of the external degrees of each Le for the
         * elements e appearing within i, plus the supervariables in i.
         * Place i in hash list.
         * ----------------------------------------------------------------- */

        for (pme = pme1 ; pme <= pme2 ; pme++)
        {
            i = Iw [pme] ;
            ASSERT (i >= 0 && i < n && Nv [i] < 0 && Elen [i] >= 0) ;
            AMD_DEBUG2 (("Updating: i "ID" "ID" "ID"\n", i, Elen[i], Len [i]));
            p1 = Pe [i] ;
            p2 = p1 + Elen [i] - 1 ;
            pn = p1 ;
            hash = 0 ;
            deg = 0 ;
            ASSERT (p1 >= 0 && p1 < iwlen && p2 >= -1 && p2 < iwlen) ;

            /* ------------------------------------------------------------- */
            /* scan the element list associated with supervariable i */
            /* ------------------------------------------------------------- */

            /* UMFPACK/MA38-style approximate degree: */
            if (aggressive)
            {
                for (p = p1 ; p <= p2 ; p++)
                {
                    e = Iw [p] ;
                    ASSERT (e >= 0 && e < n) ;
                    we = W [e] ;
                    if (we != 0)
                    {
                        /* e is an unabsorbed element */
                        /* dext = | Le \ Lme | */
                        dext = we - wflg ;
                        if (dext > 0)
                        {
                            deg += dext ;
                            Iw [pn++] = e ;
                            hash += e ;
                            AMD_DEBUG4 ((" e: "ID" hash = "ID"\n",e,hash)) ;
                        }
                        else
                        {
                            /* external degree of e is zero, absorb e into me*/
                            AMD_DEBUG1 ((" Element "ID" =>"ID" (aggressive)\n",
                                e, me)) ;
                            ASSERT (dext == 0) ;
                            Pe [e] = FLIP (me) ;
                            W [e] = 0 ;
                        }
                    }
                }
            }
            else
            {
                for (p = p1 ; p <= p2 ; p++)
                {
                    e = Iw [p] ;
                    ASSERT (e >= 0 && e < n) ;
                    we = W [e] ;
                    if (we != 0)
                    {
                        /* e is an unabsorbed element */
                        dext = we - wflg ;
                        ASSERT (dext >= 0) ;
                        deg += dext ;
                        Iw [pn++] = e ;
                        hash += e ;
                        AMD_DEBUG4 (("  e: "ID" hash = "ID"\n",e,hash)) ;
                    }
                }
            }

            /* count the number of elements in i (including me): */
            Elen [i] = pn - p1 + 1 ;

            /* ------------------------------------------------------------- */
            /* scan the supervariables in the list associated with i */
            /* ------------------------------------------------------------- */

            /* The bulk of the AMD run time is typically spent in this loop,
             * particularly if the matrix has many dense rows that are not
             * removed prior to ordering. */
            p3 = pn ;
            p4 = p1 + Len [i] ;
            for (p = p2 + 1 ; p < p4 ; p++)
            {
                j = Iw [p] ;
                ASSERT (j >= 0 && j < n) ;
                nvj = Nv [j] ;
                if (nvj > 0)
                {
                    /* j is unabsorbed, and not in Lme. */
                    /* add to degree and add to new list */
                    deg += nvj ;
                    Iw [pn++] = j ;
                    hash += j ;
                    AMD_DEBUG4 (("  s: "ID" hash "ID" Nv[j]= "ID"\n",
                                j, hash, nvj)) ;
                }
            }

            /* ------------------------------------------------------------- */
            /* update the degree and check for mass elimination */
            /* ------------------------------------------------------------- */

            /* with aggressive absorption, deg==0 is identical to the
             * Elen [i] == 1 && p3 == pn test, below. */
            ASSERT (IMPLIES (aggressive, (deg==0) == (Elen[i]==1 && p3==pn))) ;

            if (Elen [i] == 1 && p3 == pn)
            {

                /* --------------------------------------------------------- */
                /* mass elimination */
                /* --------------------------------------------------------- */

                /* There is nothing left of this node except for an edge to
                 * the current pivot element.  Elen [i] is 1, and there are
                 * no variables adjacent to node i.  Absorb i into the
                 * current pivot element, me.  Note that if there are two or
                 * more mass eliminations, fillin due to mass elimination is
                 * possible within the nvpiv-by-nvpiv pivot block.  It is this
                 * step that causes AMD's analysis to be an upper bound.
                 *
                 * The reason is that the selected pivot has a lower
                 * approximate degree than the true degree of the two mass
                 * eliminated nodes.  There is no edge between the two mass
                 * eliminated nodes.  They are merged with the current pivot
                 * anyway.
                 *
                 * No fillin occurs in the Schur complement, in any case,
                 * and this effect does not decrease the quality of the
                 * ordering itself, just the quality of the nonzero and
                 * flop count analysis.  It also means that the post-ordering
                 * is not an exact elimination tree post-ordering. */

                AMD_DEBUG1 (("  MASS i "ID" => parent e "ID"\n", i, me)) ;
                Pe [i] = FLIP (me) ;
                nvi = -Nv [i] ;
                degme -= nvi ;
                nvpiv += nvi ;
                nel += nvi ;
                Nv [i] = 0 ;
                Elen [i] = EMPTY ;

            }
            else
            {

                /* --------------------------------------------------------- */
                /* update the upper-bound degree of i */
                /* --------------------------------------------------------- */

                /* the following degree does not yet include the size
                 * of the current element, which is added later: */

                Degree [i] = MIN (Degree [i], deg) ;

                /* --------------------------------------------------------- */
                /* add me to the list for i */
                /* --------------------------------------------------------- */

                /* move first supervariable to end of list */
                Iw [pn] = Iw [p3] ;
                /* move first element to end of element part of list */
                Iw [p3] = Iw [p1] ;
                /* add new element, me, to front of list. */
                Iw [p1] = me ;
                /* store the new length of the list in Len [i] */
                Len [i] = pn - p1 + 1 ;

                /* --------------------------------------------------------- */
                /* place in hash bucket.  Save hash key of i in Last [i]. */
                /* --------------------------------------------------------- */

                /* NOTE: this can fail if hash is negative, because the ANSI C
                 * standard does not define a % b when a and/or b are negative.
                 * That's why hash is defined as an unsigned Int, to avoid this
                 * problem. */
                hash = hash % n ;
                ASSERT (((Int) hash) >= 0 && ((Int) hash) < n) ;

                /* if the Hhead array is not used: */
                j = Head [hash] ;
                if (j <= EMPTY)
                {
                    /* degree list is empty, hash head is FLIP (j) */
                    Next [i] = FLIP (j) ;
                    Head [hash] = FLIP (i) ;
                }
                else
                {
                    /* degree list is not empty, use Last [Head [hash]] as
                     * hash head. */
                    Next [i] = Last [j] ;
                    Last [j] = i ;
                }

                /* if a separate Hhead array is used: *
                Next [i] = Hhead [hash] ;
                Hhead [hash] = i ;
                */

                Last [i] = hash ;
            }
        }

        Degree [me] = degme ;

        /* ----------------------------------------------------------------- */
        /* Clear the counter array, W [...], by incrementing wflg. */
        /* ----------------------------------------------------------------- */

        /* make sure that wflg+n does not cause integer overflow */
        lemax =  MAX (lemax, degme) ;
        wflg += lemax ;
        wflg = clear_flag (wflg, wbig, W, n) ;
        /*  at this point, W [0..n-1] < wflg holds */

/* ========================================================================= */
/* SUPERVARIABLE DETECTION */
/* ========================================================================= */

        AMD_DEBUG1 (("Detecting supervariables:\n")) ;
        for (pme = pme1 ; pme <= pme2 ; pme++)
        {
            i = Iw [pme] ;
            ASSERT (i >= 0 && i < n) ;
            AMD_DEBUG2 (("Consider i "ID" nv "ID"\n", i, Nv [i])) ;
            if (Nv [i] < 0)
            {
                /* i is a principal variable in Lme */

                /* ---------------------------------------------------------
                 * examine all hash buckets with 2 or more variables.  We do
                 * this by examing all unique hash keys for supervariables in
                 * the pattern Lme of the current element, me
                 * --------------------------------------------------------- */

                /* let i = head of hash bucket, and empty the hash bucket */
                ASSERT (Last [i] >= 0 && Last [i] < n) ;
                hash = Last [i] ;

                /* if Hhead array is not used: */
                j = Head [hash] ;
                if (j == EMPTY)
                {
                    /* hash bucket and degree list are both empty */
                    i = EMPTY ;
                }
                else if (j < EMPTY)
                {
                    /* degree list is empty */
                    i = FLIP (j) ;
                    Head [hash] = EMPTY ;
                }
                else
                {
                    /* degree list is not empty, restore Last [j] of head j */
                    i = Last [j] ;
                    Last [j] = EMPTY ;
                }

                /* if separate Hhead array is used: *
                i = Hhead [hash] ;
                Hhead [hash] = EMPTY ;
                */

                ASSERT (i >= EMPTY && i < n) ;
                AMD_DEBUG2 (("----i "ID" hash "ID"\n", i, hash)) ;

                while (i != EMPTY && Next [i] != EMPTY)
                {

                    /* -----------------------------------------------------
                     * this bucket has one or more variables following i.
                     * scan all of them to see if i can absorb any entries
                     * that follow i in hash bucket.  Scatter i into w.
                     * ----------------------------------------------------- */

                    ln = Len [i] ;
                    eln = Elen [i] ;
                    ASSERT (ln >= 0 && eln >= 0) ;
                    ASSERT (Pe [i] >= 0 && Pe [i] < iwlen) ;
                    /* do not flag the first element in the list (me) */
                    for (p = Pe [i] + 1 ; p <= Pe [i] + ln - 1 ; p++)
                    {
                        ASSERT (Iw [p] >= 0 && Iw [p] < n) ;
                        W [Iw [p]] = wflg ;
                    }

                    /* ----------------------------------------------------- */
                    /* scan every other entry j following i in bucket */
                    /* ----------------------------------------------------- */

                    jlast = i ;
                    j = Next [i] ;
                    ASSERT (j >= EMPTY && j < n) ;

                    while (j != EMPTY)
                    {
                        /* ------------------------------------------------- */
                        /* check if j and i have identical nonzero pattern */
                        /* ------------------------------------------------- */

                        AMD_DEBUG3 (("compare i "ID" and j "ID"\n", i,j)) ;

                        /* check if i and j have the same Len and Elen */
                        ASSERT (Len [j] >= 0 && Elen [j] >= 0) ;
                        ASSERT (Pe [j] >= 0 && Pe [j] < iwlen) ;
                        ok = (Len [j] == ln) && (Elen [j] == eln) ;
                        /* skip the first element in the list (me) */
                        for (p = Pe [j] + 1 ; ok && p <= Pe [j] + ln - 1 ; p++)
                        {
                            ASSERT (Iw [p] >= 0 && Iw [p] < n) ;
                            if (W [Iw [p]] != wflg) ok = 0 ;
                        }
                        if (ok)
                        {
                            /* --------------------------------------------- */
                            /* found it!  j can be absorbed into i */
                            /* --------------------------------------------- */

                            AMD_DEBUG1 (("found it! j "ID" => i "ID"\n", j,i));
                            Pe [j] = FLIP (i) ;
                            /* both Nv [i] and Nv [j] are negated since they */
                            /* are in Lme, and the absolute values of each */
                            /* are the number of variables in i and j: */
                            Nv [i] += Nv [j] ;
                            Nv [j] = 0 ;
                            Elen [j] = EMPTY ;
                            /* delete j from hash bucket */
                            ASSERT (j != Next [j]) ;
                            j = Next [j] ;
                            Next [jlast] = j ;

                        }
                        else
                        {
                            /* j cannot be absorbed into i */
                            jlast = j ;
                            ASSERT (j != Next [j]) ;
                            j = Next [j] ;
                        }
                        ASSERT (j >= EMPTY && j < n) ;
                    }

                    /* -----------------------------------------------------
                     * no more variables can be absorbed into i
                     * go to next i in bucket and clear flag array
                     * ----------------------------------------------------- */

                    wflg++ ;
                    i = Next [i] ;
                    ASSERT (i >= EMPTY && i < n) ;

                }
            }
        }
        AMD_DEBUG2 (("detect done\n")) ;

/* ========================================================================= */
/* RESTORE DEGREE LISTS AND REMOVE NONPRINCIPAL SUPERVARIABLES FROM ELEMENT */
/* ========================================================================= */

        p = pme1 ;
        nleft = n - nel ;
        for (pme = pme1 ; pme <= pme2 ; pme++)
        {
            i = Iw [pme] ;
            ASSERT (i >= 0 && i < n) ;
            nvi = -Nv [i] ;
            AMD_DEBUG3 (("Restore i "ID" "ID"\n", i, nvi)) ;
            if (nvi > 0)
            {
                /* i is a principal variable in Lme */
                /* restore Nv [i] to signify that i is principal */
                Nv [i] = nvi ;

                /* --------------------------------------------------------- */
                /* compute the external degree (add size of current element) */
                /* --------------------------------------------------------- */

                deg = Degree [i] + degme - nvi ;
                deg = MIN (deg, nleft - nvi) ;
                ASSERT (IMPLIES (aggressive, deg > 0) && deg >= 0 && deg < n) ;

                /* --------------------------------------------------------- */
                /* place the supervariable at the head of the degree list */
                /* --------------------------------------------------------- */

                inext = Head [deg] ;
                ASSERT (inext >= EMPTY && inext < n) ;
                if (inext != EMPTY) Last [inext] = i ;
                Next [i] = inext ;
                Last [i] = EMPTY ;
                Head [deg] = i ;

                /* --------------------------------------------------------- */
                /* save the new degree, and find the minimum degree */
                /* --------------------------------------------------------- */

                mindeg = MIN (mindeg, deg) ;
                Degree [i] = deg ;

                /* --------------------------------------------------------- */
                /* place the supervariable in the element pattern */
                /* --------------------------------------------------------- */

                Iw [p++] = i ;

            }
        }
        AMD_DEBUG2 (("restore done\n")) ;

/* ========================================================================= */
/* FINALIZE THE NEW ELEMENT */
/* ========================================================================= */

        AMD_DEBUG2 (("ME = "ID" DONE\n", me)) ;
        Nv [me] = nvpiv ;
        /* save the length of the list for the new element me */
        Len [me] = p - pme1 ;
        if (Len [me] == 0)
        {
            /* there is nothing left of the current pivot element */
            /* it is a root of the assembly tree */
            Pe [me] = EMPTY ;
            W [me] = 0 ;
        }
        if (elenme != 0)
        {
            /* element was not constructed in place: deallocate part of */
            /* it since newly nonprincipal variables may have been removed */
            pfree = p ;
        }

        /* The new element has nvpiv pivots and the size of the contribution
         * block for a multifrontal method is degme-by-degme, not including
         * the "dense" rows/columns.  If the "dense" rows/columns are included,
         * the frontal matrix is no larger than
         * (degme+ndense)-by-(degme+ndense).
         */

        if (Info != (double *) NULL)
        {
            f = nvpiv ;
            r = degme + ndense ;
            dmax = MAX (dmax, f + r) ;

            /* number of nonzeros in L (excluding the diagonal) */
            lnzme = f*r + (f-1)*f/2 ;
            lnz += lnzme ;

            /* number of divide operations for LDL' and for LU */
            ndiv += lnzme ;

            /* number of multiply-subtract pairs for LU */
            s = f*r*r + r*(f-1)*f + (f-1)*f*(2*f-1)/6 ;
            nms_lu += s ;

            /* number of multiply-subtract pairs for LDL' */
            nms_ldl += (s + lnzme)/2 ;
        }

#ifndef NDEBUG
        AMD_DEBUG2 (("finalize done nel "ID" n "ID"\n   ::::\n", nel, n)) ;
        for (pme = Pe [me] ; pme <= Pe [me] + Len [me] - 1 ; pme++)
        {
              AMD_DEBUG3 ((" "ID"", Iw [pme])) ;
        }
        AMD_DEBUG3 (("\n")) ;
#endif

    }

/* ========================================================================= */
/* DONE SELECTING PIVOTS */
/* ========================================================================= */

    if (Info != (double *) NULL)
    {

        /* count the work to factorize the ndense-by-ndense submatrix */
        f = ndense ;
        dmax = MAX (dmax, (double) ndense) ;

        /* number of nonzeros in L (excluding the diagonal) */
        lnzme = (f-1)*f/2 ;
        lnz += lnzme ;

        /* number of divide operations for LDL' and for LU */
        ndiv += lnzme ;

        /* number of multiply-subtract pairs for LU */
        s = (f-1)*f*(2*f-1)/6 ;
        nms_lu += s ;

        /* number of multiply-subtract pairs for LDL' */
        nms_ldl += (s + lnzme)/2 ;

        /* number of nz's in L (excl. diagonal) */
        Info [AMD_LNZ] = lnz ;

        /* number of divide ops for LU and LDL' */
        Info [AMD_NDIV] = ndiv ;

        /* number of multiply-subtract pairs for LDL' */
        Info [AMD_NMULTSUBS_LDL] = nms_ldl ;

        /* number of multiply-subtract pairs for LU */
        Info [AMD_NMULTSUBS_LU] = nms_lu ;

        /* number of "dense" rows/columns */
        Info [AMD_NDENSE] = ndense ;

        /* largest front is dmax-by-dmax */
        Info [AMD_DMAX] = dmax ;

        /* number of garbage collections in AMD */
        Info [AMD_NCMPA] = ncmpa ;

        /* successful ordering */
        Info [AMD_STATUS] = AMD_OK ;
    }

/* ========================================================================= */
/* POST-ORDERING */
/* ========================================================================= */

/* -------------------------------------------------------------------------
 * Variables at this point:
 *
 * Pe: holds the elimination tree.  The parent of j is FLIP (Pe [j]),
 *      or EMPTY if j is a root.  The tree holds both elements and
 *      non-principal (unordered) variables absorbed into them.
 *      Dense variables are non-principal and unordered.
 *
 * Elen: holds the size of each element, including the diagonal part.
 *      FLIP (Elen [e]) > 0 if e is an element.  For unordered
 *      variables i, Elen [i] is EMPTY.
 *
 * Nv: Nv [e] > 0 is the number of pivots represented by the element e.
 *      For unordered variables i, Nv [i] is zero.
 *
 * Contents no longer needed:
 *      W, Iw, Len, Degree, Head, Next, Last.
 *
 * The matrix itself has been destroyed.
 *
 * n: the size of the matrix.
 * No other scalars needed (pfree, iwlen, etc.)
 * ------------------------------------------------------------------------- */

    /* restore Pe */
    for (i = 0 ; i < n ; i++)
    {
        Pe [i] = FLIP (Pe [i]) ;
    }

    /* restore Elen, for output information, and for postordering */
    for (i = 0 ; i < n ; i++)
    {
        Elen [i] = FLIP (Elen [i]) ;
    }

/* Now the parent of j is Pe [j], or EMPTY if j is a root.  Elen [e] > 0
 * is the size of element e.  Elen [i] is EMPTY for unordered variable i. */

#ifndef NDEBUG
    AMD_DEBUG2 (("\nTree:\n")) ;
    for (i = 0 ; i < n ; i++)
    {
        AMD_DEBUG2 ((" "ID" parent: "ID"   ", i, Pe [i])) ;
        ASSERT (Pe [i] >= EMPTY && Pe [i] < n) ;
        if (Nv [i] > 0)
        {
            /* this is an element */
            e = i ;
            AMD_DEBUG2 ((" element, size is "ID"\n", Elen [i])) ;
            ASSERT (Elen [e] > 0) ;
        }
        AMD_DEBUG2 (("\n")) ;
    }
    AMD_DEBUG2 (("\nelements:\n")) ;
    for (e = 0 ; e < n ; e++)
    {
        if (Nv [e] > 0)
        {
            AMD_DEBUG3 (("Element e= "ID" size "ID" nv "ID" \n", e,
                Elen [e], Nv [e])) ;
        }
    }
    AMD_DEBUG2 (("\nvariables:\n")) ;
    for (i = 0 ; i < n ; i++)
    {
        Int cnt ;
        if (Nv [i] == 0)
        {
            AMD_DEBUG3 (("i unordered: "ID"\n", i)) ;
            j = Pe [i] ;
            cnt = 0 ;
            AMD_DEBUG3 (("  j: "ID"\n", j)) ;
            if (j == EMPTY)
            {
                AMD_DEBUG3 (("  i is a dense variable\n")) ;
            }
            else
            {
                ASSERT (j >= 0 && j < n) ;
                while (Nv [j] == 0)
                {
                    AMD_DEBUG3 (("      j : "ID"\n", j)) ;
                    j = Pe [j] ;
                    AMD_DEBUG3 (("      j:: "ID"\n", j)) ;
                    cnt++ ;
                    if (cnt > n) break ;
                }
                e = j ;
                AMD_DEBUG3 (("  got to e: "ID"\n", e)) ;
            }
        }
    }
#endif

/* ========================================================================= */
/* compress the paths of the variables */
/* ========================================================================= */

    for (i = 0 ; i < n ; i++)
    {
        if (Nv [i] == 0)
        {

            /* -------------------------------------------------------------
             * i is an un-ordered row.  Traverse the tree from i until
             * reaching an element, e.  The element, e, was the principal
             * supervariable of i and all nodes in the path from i to when e
             * was selected as pivot.
             * ------------------------------------------------------------- */

            AMD_DEBUG1 (("Path compression, i unordered: "ID"\n", i)) ;
            j = Pe [i] ;
            ASSERT (j >= EMPTY && j < n) ;
            AMD_DEBUG3 (("      j: "ID"\n", j)) ;
            if (j == EMPTY)
            {
                /* Skip a dense variable.  It has no parent. */
                AMD_DEBUG3 (("      i is a dense variable\n")) ;
                continue ;
            }

            /* while (j is a variable) */
            while (Nv [j] == 0)
            {
                AMD_DEBUG3 (("          j : "ID"\n", j)) ;
                j = Pe [j] ;
                AMD_DEBUG3 (("          j:: "ID"\n", j)) ;
                ASSERT (j >= 0 && j < n) ;
            }
            /* got to an element e */
            e = j ;
            AMD_DEBUG3 (("got to e: "ID"\n", e)) ;

            /* -------------------------------------------------------------
             * traverse the path again from i to e, and compress the path
             * (all nodes point to e).  Path compression allows this code to
             * compute in O(n) time.
             * ------------------------------------------------------------- */

            j = i ;
            /* while (j is a variable) */
            while (Nv [j] == 0)
            {
                jnext = Pe [j] ;
                AMD_DEBUG3 (("j "ID" jnext "ID"\n", j, jnext)) ;
                Pe [j] = e ;
                j = jnext ;
                ASSERT (j >= 0 && j < n) ;
            }
        }
    }

/* ========================================================================= */
/* postorder the assembly tree */
/* ========================================================================= */

    AMD_postorder (n, Pe, Nv, Elen,
        W,                      /* output order */
        Head, Next, Last) ;     /* workspace */

/* ========================================================================= */
/* compute output permutation and inverse permutation */
/* ========================================================================= */

    /* W [e] = k means that element e is the kth element in the new
     * order.  e is in the range 0 to n-1, and k is in the range 0 to
     * the number of elements.  Use Head for inverse order. */

    for (k = 0 ; k < n ; k++)
    {
        Head [k] = EMPTY ;
        Next [k] = EMPTY ;
    }
    for (e = 0 ; e < n ; e++)
    {
        k = W [e] ;
        ASSERT ((k == EMPTY) == (Nv [e] == 0)) ;
        if (k != EMPTY)
        {
            ASSERT (k >= 0 && k < n) ;
            Head [k] = e ;
        }
    }

    /* construct output inverse permutation in Next,
     * and permutation in Last */
    nel = 0 ;
    for (k = 0 ; k < n ; k++)
    {
        e = Head [k] ;
        if (e == EMPTY) break ;
        ASSERT (e >= 0 && e < n && Nv [e] > 0) ;
        Next [e] = nel ;
        nel += Nv [e] ;
    }
    ASSERT (nel == n - ndense) ;

    /* order non-principal variables (dense, & those merged into supervar's) */
    for (i = 0 ; i < n ; i++)
    {
        if (Nv [i] == 0)
        {
            e = Pe [i] ;
            ASSERT (e >= EMPTY && e < n) ;
            if (e != EMPTY)
            {
                /* This is an unordered variable that was merged
                 * into element e via supernode detection or mass
                 * elimination of i when e became the pivot element.
                 * Place i in order just before e. */
                ASSERT (Next [i] == EMPTY && Nv [e] > 0) ;
                Next [i] = Next [e] ;
                Next [e]++ ;
            }
            else
            {
                /* This is a dense unordered variable, with no parent.
                 * Place it last in the output order. */
                Next [i] = nel++ ;
            }
        }
    }
    ASSERT (nel == n) ;

    AMD_DEBUG2 (("\n\nPerm:\n")) ;
    for (i = 0 ; i < n ; i++)
    {
        k = Next [i] ;
        ASSERT (k >= 0 && k < n) ;
        Last [k] = i ;
        AMD_DEBUG2 (("   perm ["ID"] = "ID"\n", k, i)) ;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_aat.c0000644000175100001710000001340100000000000024376 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_aat ============================================================= */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* AMD_aat:  compute the symmetry of the pattern of A, and count the number of
 * nonzeros each column of A+A' (excluding the diagonal).  Assumes the input
 * matrix has no errors, with sorted columns and no duplicates
 * (AMD_valid (n, n, Ap, Ai) must be AMD_OK, but this condition is not
 * checked).
 */

#include "amd_internal.h"

GLOBAL size_t AMD_aat   /* returns nz in A+A' */
(
    Int n,
    const Int Ap [ ],
    const Int Ai [ ],
    Int Len [ ],        /* Len [j]: length of column j of A+A', excl diagonal*/
    Int Tp [ ],         /* workspace of size n */
    double Info [ ]
)
{
    Int p1, p2, p, i, j, pj, pj2, k, nzdiag, nzboth, nz ;
    double sym ;
    size_t nzaat ;

#ifndef NDEBUG
    AMD_debug_init ("AMD AAT") ;
    for (k = 0 ; k < n ; k++) Tp [k] = EMPTY ;
    ASSERT (AMD_valid (n, n, Ap, Ai) == AMD_OK) ;
#endif

    if (Info != (double *) NULL)
    {
        /* clear the Info array, if it exists */
        for (i = 0 ; i < AMD_INFO ; i++)
        {
            Info [i] = EMPTY ;
        }
        Info [AMD_STATUS] = AMD_OK ;
    }

    for (k = 0 ; k < n ; k++)
    {
        Len [k] = 0 ;
    }

    nzdiag = 0 ;
    nzboth = 0 ;
    nz = Ap [n] ;

    for (k = 0 ; k < n ; k++)
    {
        p1 = Ap [k] ;
        p2 = Ap [k+1] ;
        AMD_DEBUG2 (("\nAAT Column: "ID" p1: "ID" p2: "ID"\n", k, p1, p2)) ;

        /* construct A+A' */
        for (p = p1 ; p < p2 ; )
        {
            /* scan the upper triangular part of A */
            j = Ai [p] ;
            if (j < k)
            {
                /* entry A (j,k) is in the strictly upper triangular part,
                 * add both A (j,k) and A (k,j) to the matrix A+A' */
                Len [j]++ ;
                Len [k]++ ;
                AMD_DEBUG3 (("    upper ("ID","ID") ("ID","ID")\n", j,k, k,j));
                p++ ;
            }
            else if (j == k)
            {
                /* skip the diagonal */
                p++ ;
                nzdiag++ ;
                break ;
            }
            else /* j > k */
            {
                /* first entry below the diagonal */
                break ;
            }
            /* scan lower triangular part of A, in column j until reaching
             * row k.  Start where last scan left off. */
            ASSERT (Tp [j] != EMPTY) ;
            ASSERT (Ap [j] <= Tp [j] && Tp [j] <= Ap [j+1]) ;
            pj2 = Ap [j+1] ;
            for (pj = Tp [j] ; pj < pj2 ; )
            {
                i = Ai [pj] ;
                if (i < k)
                {
                    /* A (i,j) is only in the lower part, not in upper.
                     * add both A (i,j) and A (j,i) to the matrix A+A' */
                    Len [i]++ ;
                    Len [j]++ ;
                    AMD_DEBUG3 (("    lower ("ID","ID") ("ID","ID")\n",
                        i,j, j,i)) ;
                    pj++ ;
                }
                else if (i == k)
                {
                    /* entry A (k,j) in lower part and A (j,k) in upper */
                    pj++ ;
                    nzboth++ ;
                    break ;
                }
                else /* i > k */
                {
                    /* consider this entry later, when k advances to i */
                    break ;
                }
            }
            Tp [j] = pj ;
        }
        /* Tp [k] points to the entry just below the diagonal in column k */
        Tp [k] = p ;
    }

    /* clean up, for remaining mismatched entries */
    for (j = 0 ; j < n ; j++)
    {
        for (pj = Tp [j] ; pj < Ap [j+1] ; pj++)
        {
            i = Ai [pj] ;
            /* A (i,j) is only in the lower part, not in upper.
             * add both A (i,j) and A (j,i) to the matrix A+A' */
            Len [i]++ ;
            Len [j]++ ;
            AMD_DEBUG3 (("    lower cleanup ("ID","ID") ("ID","ID")\n",
                i,j, j,i)) ;
        }
    }

    /* --------------------------------------------------------------------- */
    /* compute the symmetry of the nonzero pattern of A */
    /* --------------------------------------------------------------------- */

    /* Given a matrix A, the symmetry of A is:
     *  B = tril (spones (A), -1) + triu (spones (A), 1) ;
     *  sym = nnz (B & B') / nnz (B) ;
     *  or 1 if nnz (B) is zero.
     */

    if (nz == nzdiag)
    {
        sym = 1 ;
    }
    else
    {
        sym = (2 * (double) nzboth) / ((double) (nz - nzdiag)) ;
    }

    nzaat = 0 ;
    for (k = 0 ; k < n ; k++)
    {
        nzaat += Len [k] ;
    }

    AMD_DEBUG1 (("AMD nz in A+A', excluding diagonal (nzaat) = %g\n",
        (double) nzaat)) ;
    AMD_DEBUG1 (("   nzboth: "ID" nz: "ID" nzdiag: "ID" symmetry: %g\n",
                nzboth, nz, nzdiag, sym)) ;

    if (Info != (double *) NULL)
    {
        Info [AMD_STATUS] = AMD_OK ;
        Info [AMD_N] = n ;
        Info [AMD_NZ] = nz ;
        Info [AMD_SYMMETRY] = sym ;         /* symmetry of pattern of A */
        Info [AMD_NZDIAG] = nzdiag ;        /* nonzeros on diagonal of A */
        Info [AMD_NZ_A_PLUS_AT] = nzaat ;   /* nonzeros in A+A' */
    }

    return (nzaat) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_control.c0000644000175100001710000000370100000000000025313 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_control ========================================================= */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* User-callable.  Prints the control parameters for AMD.  See amd.h
 * for details.  If the Control array is not present, the defaults are
 * printed instead.
 */

#include "amd_internal.h"

GLOBAL void AMD_control
(
    double Control [ ]
)
{
    double alpha ;
    Int aggressive ;

    if (Control != (double *) NULL)
    {
        alpha = Control [AMD_DENSE] ;
        aggressive = Control [AMD_AGGRESSIVE] != 0 ;
    }
    else
    {
        alpha = AMD_DEFAULT_DENSE ;
        aggressive = AMD_DEFAULT_AGGRESSIVE ;
    }

    PRINTF (("\nAMD version %d.%d.%d, %s: approximate minimum degree ordering\n"
        "    dense row parameter: %g\n", AMD_MAIN_VERSION, AMD_SUB_VERSION,
        AMD_SUBSUB_VERSION, AMD_DATE, alpha)) ;

    if (alpha < 0)
    {
        PRINTF (("    no rows treated as dense\n")) ;
    }
    else
    {
        PRINTF ((
        "    (rows with more than max (%g * sqrt (n), 16) entries are\n"
        "    considered \"dense\", and placed last in output permutation)\n",
        alpha)) ;
    }

    if (aggressive)
    {
        PRINTF (("    aggressive absorption:  yes\n")) ;
    }
    else
    {
        PRINTF (("    aggressive absorption:  no\n")) ;
    }

    PRINTF (("    size of AMD integer: %d\n\n", sizeof (Int))) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_defaults.c0000644000175100001710000000257300000000000025450 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_defaults ======================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* User-callable.  Sets default control parameters for AMD.  See amd.h
 * for details.
 */

#include "amd_internal.h"

/* ========================================================================= */
/* === AMD defaults ======================================================== */
/* ========================================================================= */

GLOBAL void AMD_defaults
(
    double Control [ ]
)
{
    Int i ;

    if (Control != (double *) NULL)
    {
        for (i = 0 ; i < AMD_CONTROL ; i++)
        {
            Control [i] = 0 ;
        }
        Control [AMD_DENSE] = AMD_DEFAULT_DENSE ;
        Control [AMD_AGGRESSIVE] = AMD_DEFAULT_AGGRESSIVE ;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_dump.c0000644000175100001710000001400100000000000024573 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_dump ============================================================ */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Debugging routines for AMD.  Not used if NDEBUG is not defined at compile-
 * time (the default).  See comments in amd_internal.h on how to enable
 * debugging.  Not user-callable.
 */

#include "amd_internal.h"

#ifndef NDEBUG

/* This global variable is present only when debugging */
GLOBAL Int AMD_debug = -999 ;           /* default is no debug printing */

/* ========================================================================= */
/* === AMD_debug_init ====================================================== */
/* ========================================================================= */

/* Sets the debug print level, by reading the file debug.amd (if it exists) */

GLOBAL void AMD_debug_init ( char *s )
{
    FILE *f ;
    f = fopen ("debug.amd", "r") ;
    if (f == (FILE *) NULL)
    {
        AMD_debug = -999 ;
    }
    else
    {
        fscanf (f, ID, &AMD_debug) ;
        fclose (f) ;
    }
    if (AMD_debug >= 0)
    {
        printf ("%s: AMD_debug_init, D= "ID"\n", s, AMD_debug) ;
    }
}

/* ========================================================================= */
/* === AMD_dump ============================================================ */
/* ========================================================================= */

/* Dump AMD's data structure, except for the hash buckets.  This routine
 * cannot be called when the hash buckets are non-empty.
 */

GLOBAL void AMD_dump (
    Int n,          /* A is n-by-n */
    Int Pe [ ],     /* pe [0..n-1]: index in iw of start of row i */
    Int Iw [ ],     /* workspace of size iwlen, iwlen [0..pfree-1]
                     * holds the matrix on input */
    Int Len [ ],    /* len [0..n-1]: length for row i */
    Int iwlen,      /* length of iw */
    Int pfree,      /* iw [pfree ... iwlen-1] is empty on input */
    Int Nv [ ],     /* nv [0..n-1] */
    Int Next [ ],   /* next [0..n-1] */
    Int Last [ ],   /* last [0..n-1] */
    Int Head [ ],   /* head [0..n-1] */
    Int Elen [ ],   /* size n */
    Int Degree [ ], /* size n */
    Int W [ ],      /* size n */
    Int nel
)
{
    Int i, pe, elen, nv, len, e, p, k, j, deg, w, cnt, ilast ;

    if (AMD_debug < 0) return ;
    ASSERT (pfree <= iwlen) ;
    AMD_DEBUG3 (("\nAMD dump, pfree: "ID"\n", pfree)) ;
    for (i = 0 ; i < n ; i++)
    {
        pe = Pe [i] ;
        elen = Elen [i] ;
        nv = Nv [i] ;
        len = Len [i] ;
        w = W [i] ;

        if (elen >= EMPTY)
        {
            if (nv == 0)
            {
                AMD_DEBUG3 (("\nI "ID": nonprincipal:    ", i)) ;
                ASSERT (elen == EMPTY) ;
                if (pe == EMPTY)
                {
                    AMD_DEBUG3 ((" dense node\n")) ;
                    ASSERT (w == 1) ;
                }
                else
                {
                    ASSERT (pe < EMPTY) ;
                    AMD_DEBUG3 ((" i "ID" -> parent "ID"\n", i, FLIP (Pe[i])));
                }
            }
            else
            {
                AMD_DEBUG3 (("\nI "ID": active principal supervariable:\n",i));
                AMD_DEBUG3 (("   nv(i): "ID"  Flag: %d\n", nv, (nv < 0))) ;
                ASSERT (elen >= 0) ;
                ASSERT (nv > 0 && pe >= 0) ;
                p = pe ;
                AMD_DEBUG3 (("   e/s: ")) ;
                if (elen == 0) AMD_DEBUG3 ((" : ")) ;
                ASSERT (pe + len <= pfree) ;
                for (k = 0 ; k < len ; k++)
                {
                    j = Iw [p] ;
                    AMD_DEBUG3 (("  "ID"", j)) ;
                    ASSERT (j >= 0 && j < n) ;
                    if (k == elen-1) AMD_DEBUG3 ((" : ")) ;
                    p++ ;
                }
                AMD_DEBUG3 (("\n")) ;
            }
        }
        else
        {
            e = i ;
            if (w == 0)
            {
                AMD_DEBUG3 (("\nE "ID": absorbed element: w "ID"\n", e, w)) ;
                ASSERT (nv > 0 && pe < 0) ;
                AMD_DEBUG3 ((" e "ID" -> parent "ID"\n", e, FLIP (Pe [e]))) ;
            }
            else
            {
                AMD_DEBUG3 (("\nE "ID": unabsorbed element: w "ID"\n", e, w)) ;
                ASSERT (nv > 0 && pe >= 0) ;
                p = pe ;
                AMD_DEBUG3 ((" : ")) ;
                ASSERT (pe + len <= pfree) ;
                for (k = 0 ; k < len ; k++)
                {
                    j = Iw [p] ;
                    AMD_DEBUG3 (("  "ID"", j)) ;
                    ASSERT (j >= 0 && j < n) ;
                    p++ ;
                }
                AMD_DEBUG3 (("\n")) ;
            }
        }
    }

    /* this routine cannot be called when the hash buckets are non-empty */
    AMD_DEBUG3 (("\nDegree lists:\n")) ;
    if (nel >= 0)
    {
        cnt = 0 ;
        for (deg = 0 ; deg < n ; deg++)
        {
            if (Head [deg] == EMPTY) continue ;
            ilast = EMPTY ;
            AMD_DEBUG3 ((ID": \n", deg)) ;
            for (i = Head [deg] ; i != EMPTY ; i = Next [i])
            {
                AMD_DEBUG3 (("   "ID" : next "ID" last "ID" deg "ID"\n",
                    i, Next [i], Last [i], Degree [i])) ;
                ASSERT (i >= 0 && i < n && ilast == Last [i] &&
                    deg == Degree [i]) ;
                cnt += Nv [i] ;
                ilast = i ;
            }
            AMD_DEBUG3 (("\n")) ;
        }
        ASSERT (cnt == n - nel) ;
    }

}

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_info.c0000644000175100001710000001065600000000000024575 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_info ============================================================ */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* User-callable.  Prints the output statistics for AMD.  See amd.h
 * for details.  If the Info array is not present, nothing is printed.
 */

#include "amd_internal.h"

#define PRI(format,x) { if (x >= 0) { PRINTF ((format, x)) ; }}

GLOBAL void AMD_info
(
    double Info [ ]
)
{
    double n, ndiv, nmultsubs_ldl, nmultsubs_lu, lnz, lnzd ;

    PRINTF (("\nAMD version %d.%d.%d, %s, results:\n",
        AMD_MAIN_VERSION, AMD_SUB_VERSION, AMD_SUBSUB_VERSION, AMD_DATE)) ;

    if (!Info)
    {
        return ;
    }

    n = Info [AMD_N] ;
    ndiv = Info [AMD_NDIV] ;
    nmultsubs_ldl = Info [AMD_NMULTSUBS_LDL] ;
    nmultsubs_lu = Info [AMD_NMULTSUBS_LU] ;
    lnz = Info [AMD_LNZ] ;
    lnzd = (n >= 0 && lnz >= 0) ? (n + lnz) : (-1) ;

    /* AMD return status */
    PRINTF (("    status: ")) ;
    if (Info [AMD_STATUS] == AMD_OK)
    {
        PRINTF (("OK\n")) ;
    }
    else if (Info [AMD_STATUS] == AMD_OUT_OF_MEMORY)
    {
        PRINTF (("out of memory\n")) ;
    }
    else if (Info [AMD_STATUS] == AMD_INVALID)
    {
        PRINTF (("invalid matrix\n")) ;
    }
    else if (Info [AMD_STATUS] == AMD_OK_BUT_JUMBLED)
    {
        PRINTF (("OK, but jumbled\n")) ;
    }
    else
    {
        PRINTF (("unknown\n")) ;
    }

    /* statistics about the input matrix */
    PRI ("    n, dimension of A:                                  %.20g\n", n);
    PRI ("    nz, number of nonzeros in A:                        %.20g\n",
        Info [AMD_NZ]) ;
    PRI ("    symmetry of A:                                      %.4f\n",
        Info [AMD_SYMMETRY]) ;
    PRI ("    number of nonzeros on diagonal:                     %.20g\n",
        Info [AMD_NZDIAG]) ;
    PRI ("    nonzeros in pattern of A+A' (excl. diagonal):       %.20g\n",
        Info [AMD_NZ_A_PLUS_AT]) ;
    PRI ("    # dense rows/columns of A+A':                       %.20g\n",
        Info [AMD_NDENSE]) ;

    /* statistics about AMD's behavior  */
    PRI ("    memory used, in bytes:                              %.20g\n",
        Info [AMD_MEMORY]) ;
    PRI ("    # of memory compactions:                            %.20g\n",
        Info [AMD_NCMPA]) ;

    /* statistics about the ordering quality */
    PRINTF (("\n"
        "    The following approximate statistics are for a subsequent\n"
        "    factorization of A(P,P) + A(P,P)'.  They are slight upper\n"
        "    bounds if there are no dense rows/columns in A+A', and become\n"
        "    looser if dense rows/columns exist.\n\n")) ;

    PRI ("    nonzeros in L (excluding diagonal):                 %.20g\n",
        lnz) ;
    PRI ("    nonzeros in L (including diagonal):                 %.20g\n",
        lnzd) ;
    PRI ("    # divide operations for LDL' or LU:                 %.20g\n",
        ndiv) ;
    PRI ("    # multiply-subtract operations for LDL':            %.20g\n",
        nmultsubs_ldl) ;
    PRI ("    # multiply-subtract operations for LU:              %.20g\n",
        nmultsubs_lu) ;
    PRI ("    max nz. in any column of L (incl. diagonal):        %.20g\n",
        Info [AMD_DMAX]) ;

    /* total flop counts for various factorizations */

    if (n >= 0 && ndiv >= 0 && nmultsubs_ldl >= 0 && nmultsubs_lu >= 0)
    {
        PRINTF (("\n"
        "    chol flop count for real A, sqrt counted as 1 flop: %.20g\n"
        "    LDL' flop count for real A:                         %.20g\n"
        "    LDL' flop count for complex A:                      %.20g\n"
        "    LU flop count for real A (with no pivoting):        %.20g\n"
        "    LU flop count for complex A (with no pivoting):     %.20g\n\n",
        n + ndiv + 2*nmultsubs_ldl,
            ndiv + 2*nmultsubs_ldl,
          9*ndiv + 8*nmultsubs_ldl,
            ndiv + 2*nmultsubs_lu,
          9*ndiv + 8*nmultsubs_lu)) ;
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_internal.h0000644000175100001710000000614700000000000025463 0ustar00runnerdocker00000000000000/* amd_internal.h */

/* Written by Andrew Makhorin . */

#ifndef AMD_INTERNAL_H
#define AMD_INTERNAL_H

/* AMD will be exceedingly slow when running in debug mode. */
#ifndef NDEBUG
#define NDEBUG
#endif

#include "amd.h"
#include "env.h"

#define Int int
#define ID "%d"
#define Int_MAX INT_MAX

#if 0 /* 15/II-2012 */
/* now this macro is defined in glpenv.h; besides, the definiton below
   depends on implementation, because size_t is an unsigned type */
#define SIZE_T_MAX ((size_t)(-1))
#endif

#define EMPTY (-1)
#define FLIP(i) (-(i)-2)
#define UNFLIP(i) ((i < EMPTY) ? FLIP (i) : (i))

#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#define MIN(a,b) (((a) < (b)) ? (a) : (b))

#define IMPLIES(p, q) (!(p) || (q))

#define GLOBAL

#define AMD_order amd_order
#define AMD_defaults amd_defaults
#define AMD_control amd_control
#define AMD_info amd_info
#define AMD_1 amd_1
#define AMD_2 amd_2
#define AMD_valid amd_valid
#define AMD_aat amd_aat
#define AMD_postorder amd_postorder
#define AMD_post_tree amd_post_tree
#define AMD_dump amd_dump
#define AMD_debug amd_debug
#define AMD_debug_init amd_debug_init
#define AMD_preprocess amd_preprocess

#define amd_malloc xmalloc
#if 0 /* 24/V-2009 */
#define amd_free xfree
#else
#define amd_free(ptr) { if ((ptr) != NULL) xfree(ptr); }
#endif
#define amd_printf xprintf

#define PRINTF(params) { amd_printf params; }

#ifndef NDEBUG
#define ASSERT(expr) xassert(expr)
#define AMD_DEBUG0(params) { PRINTF(params); }
#define AMD_DEBUG1(params) { if (AMD_debug >= 1) PRINTF(params); }
#define AMD_DEBUG2(params) { if (AMD_debug >= 2) PRINTF(params); }
#define AMD_DEBUG3(params) { if (AMD_debug >= 3) PRINTF(params); }
#define AMD_DEBUG4(params) { if (AMD_debug >= 4) PRINTF(params); }
#else
#define ASSERT(expression)
#define AMD_DEBUG0(params)
#define AMD_DEBUG1(params)
#define AMD_DEBUG2(params)
#define AMD_DEBUG3(params)
#define AMD_DEBUG4(params)
#endif

#define amd_aat _glp_amd_aat
size_t AMD_aat(Int n, const Int Ap[], const Int Ai[], Int Len[],
      Int Tp[], double Info[]);

#define amd_1 _glp_amd_1
void AMD_1(Int n, const Int Ap[], const Int Ai[], Int P[], Int Pinv[],
      Int Len[], Int slen, Int S[], double Control[], double Info[]);

#define amd_postorder _glp_amd_postorder
void AMD_postorder(Int nn, Int Parent[], Int Npiv[], Int Fsize[],
      Int Order[], Int Child[], Int Sibling[], Int Stack[]);

#define amd_post_tree _glp_amd_post_tree
#ifndef NDEBUG
Int AMD_post_tree(Int root, Int k, Int Child[], const Int Sibling[],
      Int Order[], Int Stack[], Int nn);
#else
Int AMD_post_tree(Int root, Int k, Int Child[], const Int Sibling[],
      Int Order[], Int Stack[]);
#endif

#define amd_preprocess _glp_amd_preprocess
void AMD_preprocess(Int n, const Int Ap[], const Int Ai[], Int Rp[],
      Int Ri[], Int W[], Int Flag[]);

#define amd_debug _glp_amd_debug
extern Int AMD_debug;

#define amd_debug_init _glp_amd_debug_init
void AMD_debug_init(char *s);

#define amd_dump _glp_amd_dump
void AMD_dump(Int n, Int Pe[], Int Iw[], Int Len[], Int iwlen,
      Int pfree, Int Nv[], Int Next[], Int Last[], Int Head[],
      Int Elen[], Int Degree[], Int W[], Int nel);

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_order.c0000644000175100001710000001451600000000000024754 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_order =========================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* User-callable AMD minimum degree ordering routine.  See amd.h for
 * documentation.
 */

#include "amd_internal.h"

/* ========================================================================= */
/* === AMD_order =========================================================== */
/* ========================================================================= */

GLOBAL Int AMD_order
(
    Int n,
    const Int Ap [ ],
    const Int Ai [ ],
    Int P [ ],
    double Control [ ],
    double Info [ ]
)
{
    Int *Len, *S, nz, i, *Pinv, info, status, *Rp, *Ri, *Cp, *Ci, ok ;
    size_t nzaat, slen ;
    double mem = 0 ;

#ifndef NDEBUG
    AMD_debug_init ("amd") ;
#endif

    /* clear the Info array, if it exists */
    info = Info != (double *) NULL ;
    if (info)
    {
        for (i = 0 ; i < AMD_INFO ; i++)
        {
            Info [i] = EMPTY ;
        }
        Info [AMD_N] = n ;
        Info [AMD_STATUS] = AMD_OK ;
    }

    /* make sure inputs exist and n is >= 0 */
    if (Ai == (Int *) NULL || Ap == (Int *) NULL || P == (Int *) NULL || n < 0)
    {
        if (info) Info [AMD_STATUS] = AMD_INVALID ;
        return (AMD_INVALID) ;      /* arguments are invalid */
    }

    if (n == 0)
    {
        return (AMD_OK) ;           /* n is 0 so there's nothing to do */
    }

    nz = Ap [n] ;
    if (info)
    {
        Info [AMD_NZ] = nz ;
    }
    if (nz < 0)
    {
        if (info) Info [AMD_STATUS] = AMD_INVALID ;
        return (AMD_INVALID) ;
    }

    /* check if n or nz will cause size_t overflow */
    if (((size_t) n) >= SIZE_T_MAX / sizeof (Int)
     || ((size_t) nz) >= SIZE_T_MAX / sizeof (Int))
    {
        if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
        return (AMD_OUT_OF_MEMORY) ;        /* problem too large */
    }

    /* check the input matrix:  AMD_OK, AMD_INVALID, or AMD_OK_BUT_JUMBLED */
    status = AMD_valid (n, n, Ap, Ai) ;

    if (status == AMD_INVALID)
    {
        if (info) Info [AMD_STATUS] = AMD_INVALID ;
        return (AMD_INVALID) ;      /* matrix is invalid */
    }

    /* allocate two size-n integer workspaces */
    Len = amd_malloc (n * sizeof (Int)) ;
    Pinv = amd_malloc (n * sizeof (Int)) ;
    mem += n ;
    mem += n ;
    if (!Len || !Pinv)
    {
        /* :: out of memory :: */
        amd_free (Len) ;
        amd_free (Pinv) ;
        if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
        return (AMD_OUT_OF_MEMORY) ;
    }

    if (status == AMD_OK_BUT_JUMBLED)
    {
        /* sort the input matrix and remove duplicate entries */
        AMD_DEBUG1 (("Matrix is jumbled\n")) ;
        Rp = amd_malloc ((n+1) * sizeof (Int)) ;
        Ri = amd_malloc (MAX (nz,1) * sizeof (Int)) ;
        mem += (n+1) ;
        mem += MAX (nz,1) ;
        if (!Rp || !Ri)
        {
            /* :: out of memory :: */
            amd_free (Rp) ;
            amd_free (Ri) ;
            amd_free (Len) ;
            amd_free (Pinv) ;
            if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
            return (AMD_OUT_OF_MEMORY) ;
        }
        /* use Len and Pinv as workspace to create R = A' */
        AMD_preprocess (n, Ap, Ai, Rp, Ri, Len, Pinv) ;
        Cp = Rp ;
        Ci = Ri ;
    }
    else
    {
        /* order the input matrix as-is.  No need to compute R = A' first */
        Rp = NULL ;
        Ri = NULL ;
        Cp = (Int *) Ap ;
        Ci = (Int *) Ai ;
    }

    /* --------------------------------------------------------------------- */
    /* determine the symmetry and count off-diagonal nonzeros in A+A' */
    /* --------------------------------------------------------------------- */

    nzaat = AMD_aat (n, Cp, Ci, Len, P, Info) ;
    AMD_DEBUG1 (("nzaat: %g\n", (double) nzaat)) ;
    ASSERT ((MAX (nz-n, 0) <= nzaat) && (nzaat <= 2 * (size_t) nz)) ;

    /* --------------------------------------------------------------------- */
    /* allocate workspace for matrix, elbow room, and 6 size-n vectors */
    /* --------------------------------------------------------------------- */

    S = NULL ;
    slen = nzaat ;                      /* space for matrix */
    ok = ((slen + nzaat/5) >= slen) ;   /* check for size_t overflow */
    slen += nzaat/5 ;                   /* add elbow room */
    for (i = 0 ; ok && i < 7 ; i++)
    {
        ok = ((slen + n) > slen) ;      /* check for size_t overflow */
        slen += n ;                     /* size-n elbow room, 6 size-n work */
    }
    mem += slen ;
    ok = ok && (slen < SIZE_T_MAX / sizeof (Int)) ; /* check for overflow */
    ok = ok && (slen < Int_MAX) ;       /* S[i] for Int i must be OK */
    if (ok)
    {
        S = amd_malloc (slen * sizeof (Int)) ;
    }
    AMD_DEBUG1 (("slen %g\n", (double) slen)) ;
    if (!S)
    {
        /* :: out of memory :: (or problem too large) */
        amd_free (Rp) ;
        amd_free (Ri) ;
        amd_free (Len) ;
        amd_free (Pinv) ;
        if (info) Info [AMD_STATUS] = AMD_OUT_OF_MEMORY ;
        return (AMD_OUT_OF_MEMORY) ;
    }
    if (info)
    {
        /* memory usage, in bytes. */
        Info [AMD_MEMORY] = mem * sizeof (Int) ;
    }

    /* --------------------------------------------------------------------- */
    /* order the matrix */
    /* --------------------------------------------------------------------- */

    AMD_1 (n, Cp, Ci, P, Pinv, Len, slen, S, Control, Info) ;

    /* --------------------------------------------------------------------- */
    /* free the workspace */
    /* --------------------------------------------------------------------- */

    amd_free (Rp) ;
    amd_free (Ri) ;
    amd_free (Len) ;
    amd_free (Pinv) ;
    amd_free (S) ;
    if (info) Info [AMD_STATUS] = status ;
    return (status) ;       /* successful ordering */
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_post_tree.c0000644000175100001710000001070500000000000025641 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_post_tree ======================================================= */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Post-ordering of a supernodal elimination tree.  */

#include "amd_internal.h"

GLOBAL Int AMD_post_tree
(
    Int root,                   /* root of the tree */
    Int k,                      /* start numbering at k */
    Int Child [ ],              /* input argument of size nn, undefined on
                                 * output.  Child [i] is the head of a link
                                 * list of all nodes that are children of node
                                 * i in the tree. */
    const Int Sibling [ ],      /* input argument of size nn, not modified.
                                 * If f is a node in the link list of the
                                 * children of node i, then Sibling [f] is the
                                 * next child of node i.
                                 */
    Int Order [ ],              /* output order, of size nn.  Order [i] = k
                                 * if node i is the kth node of the reordered
                                 * tree. */
    Int Stack [ ]               /* workspace of size nn */
#ifndef NDEBUG
    , Int nn                    /* nodes are in the range 0..nn-1. */
#endif
)
{
    Int f, head, h, i ;

#if 0
    /* --------------------------------------------------------------------- */
    /* recursive version (Stack [ ] is not used): */
    /* --------------------------------------------------------------------- */

    /* this is simple, but can caouse stack overflow if nn is large */
    i = root ;
    for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
    {
        k = AMD_post_tree (f, k, Child, Sibling, Order, Stack, nn) ;
    }
    Order [i] = k++ ;
    return (k) ;
#endif

    /* --------------------------------------------------------------------- */
    /* non-recursive version, using an explicit stack */
    /* --------------------------------------------------------------------- */

    /* push root on the stack */
    head = 0 ;
    Stack [0] = root ;

    while (head >= 0)
    {
        /* get head of stack */
        ASSERT (head < nn) ;
        i = Stack [head] ;
        AMD_DEBUG1 (("head of stack "ID" \n", i)) ;
        ASSERT (i >= 0 && i < nn) ;

        if (Child [i] != EMPTY)
        {
            /* the children of i are not yet ordered */
            /* push each child onto the stack in reverse order */
            /* so that small ones at the head of the list get popped first */
            /* and the biggest one at the end of the list gets popped last */
            for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
            {
                head++ ;
                ASSERT (head < nn) ;
                ASSERT (f >= 0 && f < nn) ;
            }
            h = head ;
            ASSERT (head < nn) ;
            for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
            {
                ASSERT (h > 0) ;
                Stack [h--] = f ;
                AMD_DEBUG1 (("push "ID" on stack\n", f)) ;
                ASSERT (f >= 0 && f < nn) ;
            }
            ASSERT (Stack [h] == i) ;

            /* delete child list so that i gets ordered next time we see it */
            Child [i] = EMPTY ;
        }
        else
        {
            /* the children of i (if there were any) are already ordered */
            /* remove i from the stack and order it.  Front i is kth front */
            head-- ;
            AMD_DEBUG1 (("pop "ID" order "ID"\n", i, k)) ;
            Order [i] = k++ ;
            ASSERT (k <= nn) ;
        }

#ifndef NDEBUG
        AMD_DEBUG1 (("\nStack:")) ;
        for (h = head ; h >= 0 ; h--)
        {
            Int j = Stack [h] ;
            AMD_DEBUG1 ((" "ID, j)) ;
            ASSERT (j >= 0 && j < nn) ;
        }
        AMD_DEBUG1 (("\n\n")) ;
        ASSERT (head < nn) ;
#endif

    }
    return (k) ;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_postorder.c0000644000175100001710000001543100000000000025657 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_postorder ======================================================= */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Perform a postordering (via depth-first search) of an assembly tree. */

#include "amd_internal.h"

GLOBAL void AMD_postorder
(
    /* inputs, not modified on output: */
    Int nn,             /* nodes are in the range 0..nn-1 */
    Int Parent [ ],     /* Parent [j] is the parent of j, or EMPTY if root */
    Int Nv [ ],         /* Nv [j] > 0 number of pivots represented by node j,
                         * or zero if j is not a node. */
    Int Fsize [ ],      /* Fsize [j]: size of node j */

    /* output, not defined on input: */
    Int Order [ ],      /* output post-order */

    /* workspaces of size nn: */
    Int Child [ ],
    Int Sibling [ ],
    Int Stack [ ]
)
{
    Int i, j, k, parent, frsize, f, fprev, maxfrsize, bigfprev, bigf, fnext ;

    for (j = 0 ; j < nn ; j++)
    {
        Child [j] = EMPTY ;
        Sibling [j] = EMPTY ;
    }

    /* --------------------------------------------------------------------- */
    /* place the children in link lists - bigger elements tend to be last */
    /* --------------------------------------------------------------------- */

    for (j = nn-1 ; j >= 0 ; j--)
    {
        if (Nv [j] > 0)
        {
            /* this is an element */
            parent = Parent [j] ;
            if (parent != EMPTY)
            {
                /* place the element in link list of the children its parent */
                /* bigger elements will tend to be at the end of the list */
                Sibling [j] = Child [parent] ;
                Child [parent] = j ;
            }
        }
    }

#ifndef NDEBUG
    {
        Int nels, ff, nchild ;
        AMD_DEBUG1 (("\n\n================================ AMD_postorder:\n"));
        nels = 0 ;
        for (j = 0 ; j < nn ; j++)
        {
            if (Nv [j] > 0)
            {
                AMD_DEBUG1 (( ""ID" :  nels "ID" npiv "ID" size "ID
                    " parent "ID" maxfr "ID"\n", j, nels,
                    Nv [j], Fsize [j], Parent [j], Fsize [j])) ;
                /* this is an element */
                /* dump the link list of children */
                nchild = 0 ;
                AMD_DEBUG1 (("    Children: ")) ;
                for (ff = Child [j] ; ff != EMPTY ; ff = Sibling [ff])
                {
                    AMD_DEBUG1 ((ID" ", ff)) ;
                    ASSERT (Parent [ff] == j) ;
                    nchild++ ;
                    ASSERT (nchild < nn) ;
                }
                AMD_DEBUG1 (("\n")) ;
                parent = Parent [j] ;
                if (parent != EMPTY)
                {
                    ASSERT (Nv [parent] > 0) ;
                }
                nels++ ;
            }
        }
    }
    AMD_DEBUG1 (("\n\nGo through the children of each node, and put\n"
                 "the biggest child last in each list:\n")) ;
#endif

    /* --------------------------------------------------------------------- */
    /* place the largest child last in the list of children for each node */
    /* --------------------------------------------------------------------- */

    for (i = 0 ; i < nn ; i++)
    {
        if (Nv [i] > 0 && Child [i] != EMPTY)
        {

#ifndef NDEBUG
            Int nchild ;
            AMD_DEBUG1 (("Before partial sort, element "ID"\n", i)) ;
            nchild = 0 ;
            for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
            {
                ASSERT (f >= 0 && f < nn) ;
                AMD_DEBUG1 (("      f: "ID"  size: "ID"\n", f, Fsize [f])) ;
                nchild++ ;
                ASSERT (nchild <= nn) ;
            }
#endif

            /* find the biggest element in the child list */
            fprev = EMPTY ;
            maxfrsize = EMPTY ;
            bigfprev = EMPTY ;
            bigf = EMPTY ;
            for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
            {
                ASSERT (f >= 0 && f < nn) ;
                frsize = Fsize [f] ;
                if (frsize >= maxfrsize)
                {
                    /* this is the biggest seen so far */
                    maxfrsize = frsize ;
                    bigfprev = fprev ;
                    bigf = f ;
                }
                fprev = f ;
            }
            ASSERT (bigf != EMPTY) ;

            fnext = Sibling [bigf] ;

            AMD_DEBUG1 (("bigf "ID" maxfrsize "ID" bigfprev "ID" fnext "ID
                " fprev " ID"\n", bigf, maxfrsize, bigfprev, fnext, fprev)) ;

            if (fnext != EMPTY)
            {
                /* if fnext is EMPTY then bigf is already at the end of list */

                if (bigfprev == EMPTY)
                {
                    /* delete bigf from the element of the list */
                    Child [i] = fnext ;
                }
                else
                {
                    /* delete bigf from the middle of the list */
                    Sibling [bigfprev] = fnext ;
                }

                /* put bigf at the end of the list */
                Sibling [bigf] = EMPTY ;
                ASSERT (Child [i] != EMPTY) ;
                ASSERT (fprev != bigf) ;
                ASSERT (fprev != EMPTY) ;
                Sibling [fprev] = bigf ;
            }

#ifndef NDEBUG
            AMD_DEBUG1 (("After partial sort, element "ID"\n", i)) ;
            for (f = Child [i] ; f != EMPTY ; f = Sibling [f])
            {
                ASSERT (f >= 0 && f < nn) ;
                AMD_DEBUG1 (("        "ID"  "ID"\n", f, Fsize [f])) ;
                ASSERT (Nv [f] > 0) ;
                nchild-- ;
            }
            ASSERT (nchild == 0) ;
#endif

        }
    }

    /* --------------------------------------------------------------------- */
    /* postorder the assembly tree */
    /* --------------------------------------------------------------------- */

    for (i = 0 ; i < nn ; i++)
    {
        Order [i] = EMPTY ;
    }

    k = 0 ;

    for (i = 0 ; i < nn ; i++)
    {
        if (Parent [i] == EMPTY && Nv [i] > 0)
        {
            AMD_DEBUG1 (("Root of assembly tree "ID"\n", i)) ;
            k = AMD_post_tree (i, k, Child, Sibling, Order, Stack
#ifndef NDEBUG
                , nn
#endif
                ) ;
        }
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_preprocess.c0000644000175100001710000001017700000000000026025 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_preprocess ====================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Sorts, removes duplicate entries, and transposes from the nonzero pattern of
 * a column-form matrix A, to obtain the matrix R.  The input matrix can have
 * duplicate entries and/or unsorted columns (AMD_valid (n,Ap,Ai) must not be
 * AMD_INVALID).
 *
 * This input condition is NOT checked.  This routine is not user-callable.
 */

#include "amd_internal.h"

/* ========================================================================= */
/* === AMD_preprocess ====================================================== */
/* ========================================================================= */

/* AMD_preprocess does not check its input for errors or allocate workspace.
 * On input, the condition (AMD_valid (n,n,Ap,Ai) != AMD_INVALID) must hold.
 */

GLOBAL void AMD_preprocess
(
    Int n,              /* input matrix: A is n-by-n */
    const Int Ap [ ],   /* size n+1 */
    const Int Ai [ ],   /* size nz = Ap [n] */

    /* output matrix R: */
    Int Rp [ ],         /* size n+1 */
    Int Ri [ ],         /* size nz (or less, if duplicates present) */

    Int W [ ],          /* workspace of size n */
    Int Flag [ ]        /* workspace of size n */
)
{

    /* --------------------------------------------------------------------- */
    /* local variables */
    /* --------------------------------------------------------------------- */

    Int i, j, p, p2 ;

    ASSERT (AMD_valid (n, n, Ap, Ai) != AMD_INVALID) ;

    /* --------------------------------------------------------------------- */
    /* count the entries in each row of A (excluding duplicates) */
    /* --------------------------------------------------------------------- */

    for (i = 0 ; i < n ; i++)
    {
        W [i] = 0 ;             /* # of nonzeros in row i (excl duplicates) */
        Flag [i] = EMPTY ;      /* Flag [i] = j if i appears in column j */
    }
    for (j = 0 ; j < n ; j++)
    {
        p2 = Ap [j+1] ;
        for (p = Ap [j] ; p < p2 ; p++)
        {
            i = Ai [p] ;
            if (Flag [i] != j)
            {
                /* row index i has not yet appeared in column j */
                W [i]++ ;           /* one more entry in row i */
                Flag [i] = j ;      /* flag row index i as appearing in col j*/
            }
        }
    }

    /* --------------------------------------------------------------------- */
    /* compute the row pointers for R */
    /* --------------------------------------------------------------------- */

    Rp [0] = 0 ;
    for (i = 0 ; i < n ; i++)
    {
        Rp [i+1] = Rp [i] + W [i] ;
    }
    for (i = 0 ; i < n ; i++)
    {
        W [i] = Rp [i] ;
        Flag [i] = EMPTY ;
    }

    /* --------------------------------------------------------------------- */
    /* construct the row form matrix R */
    /* --------------------------------------------------------------------- */

    /* R = row form of pattern of A */
    for (j = 0 ; j < n ; j++)
    {
        p2 = Ap [j+1] ;
        for (p = Ap [j] ; p < p2 ; p++)
        {
            i = Ai [p] ;
            if (Flag [i] != j)
            {
                /* row index i has not yet appeared in column j */
                Ri [W [i]++] = j ;  /* put col j in row i */
                Flag [i] = j ;      /* flag row index i as appearing in col j*/
            }
        }
    }

#ifndef NDEBUG
    ASSERT (AMD_valid (n, n, Rp, Ri) == AMD_OK) ;
    for (j = 0 ; j < n ; j++)
    {
        ASSERT (W [j] == Rp [j+1]) ;
    }
#endif
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/amd/amd_valid.c0000644000175100001710000000651500000000000024740 0ustar00runnerdocker00000000000000/* ========================================================================= */
/* === AMD_valid =========================================================== */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
/* AMD, Copyright (c) Timothy A. Davis,                                      */
/* Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.     */
/* email: davis at cise.ufl.edu    CISE Department, Univ. of Florida.        */
/* web: http://www.cise.ufl.edu/research/sparse/amd                          */
/* ------------------------------------------------------------------------- */

/* Check if a column-form matrix is valid or not.  The matrix A is
 * n_row-by-n_col.  The row indices of entries in column j are in
 * Ai [Ap [j] ... Ap [j+1]-1].  Required conditions are:
 *
 *      n_row >= 0
 *      n_col >= 0
 *      nz = Ap [n_col] >= 0        number of entries in the matrix
 *      Ap [0] == 0
 *      Ap [j] <= Ap [j+1] for all j in the range 0 to n_col.
 *      Ai [0 ... nz-1] must be in the range 0 to n_row-1.
 *
 * If any of the above conditions hold, AMD_INVALID is returned.  If the
 * following condition holds, AMD_OK_BUT_JUMBLED is returned (a warning,
 * not an error):
 *
 *      row indices in Ai [Ap [j] ... Ap [j+1]-1] are not sorted in ascending
 *          order, and/or duplicate entries exist.
 *
 * Otherwise, AMD_OK is returned.
 *
 * In v1.2 and earlier, this function returned TRUE if the matrix was valid
 * (now returns AMD_OK), or FALSE otherwise (now returns AMD_INVALID or
 * AMD_OK_BUT_JUMBLED).
 */

#include "amd_internal.h"

GLOBAL Int AMD_valid
(
    /* inputs, not modified on output: */
    Int n_row,          /* A is n_row-by-n_col */
    Int n_col,
    const Int Ap [ ],   /* column pointers of A, of size n_col+1 */
    const Int Ai [ ]    /* row indices of A, of size nz = Ap [n_col] */
)
{
    Int nz, j, p1, p2, ilast, i, p, result = AMD_OK ;

    if (n_row < 0 || n_col < 0 || Ap == NULL || Ai == NULL)
    {
        return (AMD_INVALID) ;
    }
    nz = Ap [n_col] ;
    if (Ap [0] != 0 || nz < 0)
    {
        /* column pointers must start at Ap [0] = 0, and Ap [n] must be >= 0 */
        AMD_DEBUG0 (("column 0 pointer bad or nz < 0\n")) ;
        return (AMD_INVALID) ;
    }
    for (j = 0 ; j < n_col ; j++)
    {
        p1 = Ap [j] ;
        p2 = Ap [j+1] ;
        AMD_DEBUG2 (("\nColumn: "ID" p1: "ID" p2: "ID"\n", j, p1, p2)) ;
        if (p1 > p2)
        {
            /* column pointers must be ascending */
            AMD_DEBUG0 (("column "ID" pointer bad\n", j)) ;
            return (AMD_INVALID) ;
        }
        ilast = EMPTY ;
        for (p = p1 ; p < p2 ; p++)
        {
            i = Ai [p] ;
            AMD_DEBUG3 (("row: "ID"\n", i)) ;
            if (i < 0 || i >= n_row)
            {
                /* row index out of range */
                AMD_DEBUG0 (("index out of range, col "ID" row "ID"\n", j, i));
                return (AMD_INVALID) ;
            }
            if (i <= ilast)
            {
                /* row index unsorted, or duplicate entry present */
                AMD_DEBUG1 (("index unsorted/dupl col "ID" row "ID"\n", j, i));
                result = AMD_OK_BUT_JUMBLED ;
            }
            ilast = i ;
        }
    }
    return (result) ;
}
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.659143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/0000755000175100001710000000000000000000000022655 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/advbas.c0000644000175100001710000001154700000000000024271 0ustar00runnerdocker00000000000000/* advbas.c (construct advanced initial LP basis) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"
#include "triang.h"

/***********************************************************************
*  NAME
*
*  glp_adv_basis - construct advanced initial LP basis
*
*  SYNOPSIS
*
*  void glp_adv_basis(glp_prob *P, int flags);
*
*  DESCRIPTION
*
*  The routine glp_adv_basis constructs an advanced initial LP basis
*  for the specified problem object.
*
*  The parameter flag is reserved for use in the future and should be
*  specified as zero.
*
*  NOTE
*
*  The routine glp_adv_basis should be called after the constraint
*  matrix has been scaled (if scaling is used). */

static int mat(void *info, int k, int ind[], double val[])
{     glp_prob *P = info;
      int m = P->m;
      int n = P->n;
      GLPROW **row = P->row;
      GLPCOL **col = P->col;
      GLPAIJ *aij;
      int i, j, len;
      if (k > 0)
      {  /* retrieve scaled row of constraint matrix */
         i = +k;
         xassert(1 <= i && i <= m);
         len = 0;
         if (row[i]->type == GLP_FX)
         {  for (aij = row[i]->ptr; aij != NULL; aij = aij->r_next)
            {  j = aij->col->j;
               if (col[j]->type != GLP_FX)
               {  len++;
                  ind[len] = j;
                  val[len] = aij->row->rii * aij->val * aij->col->sjj;
               }
            }
         }
      }
      else
      {  /* retrieve scaled column of constraint matrix */
         j = -k;
         xassert(1 <= j && j <= n);
         len = 0;
         if (col[j]->type != GLP_FX)
         {  for (aij = col[j]->ptr; aij != NULL; aij = aij->c_next)
            {  i = aij->row->i;
               if (row[i]->type == GLP_FX)
               {  len++;
                  ind[len] = i;
                  val[len] = aij->row->rii * aij->val * aij->col->sjj;
               }
            }
         }
      }
      return len;
}

void glp_adv_basis(glp_prob *P, int flags)
{     int i, j, k, m, n, min_mn, size, *rn, *cn;
      char *flag;
      if (flags != 0)
         xerror("glp_adv_basis: flags = %d; invalid flags\n", flags);
      m = P->m; /* number of rows */
      n = P->n; /* number of columns */
      if (m == 0 || n == 0)
      {  /* trivial case */
         glp_std_basis(P);
         goto done;
      }
      xprintf("Constructing initial basis...\n");
      /* allocate working arrays */
      min_mn = (m < n ? m : n);
      rn = talloc(1+min_mn, int);
      cn = talloc(1+min_mn, int);
      flag = talloc(1+m, char);
      /* make the basis empty */
      for (i = 1; i <= m; i++)
      {  flag[i] = 0;
         glp_set_row_stat(P, i, GLP_NS);
      }
      for (j = 1; j <= n; j++)
         glp_set_col_stat(P, j, GLP_NS);
      /* find maximal triangular part of the constraint matrix;
         to prevent including non-fixed rows and fixed columns in the
         triangular part, such rows and columns are temporarily made
         empty by the routine mat */
#if 1 /* FIXME: tolerance */
      size = triang(m, n, mat, P, 0.001, rn, cn);
#endif
      xassert(0 <= size && size <= min_mn);
      /* include in the basis non-fixed structural variables, whose
         columns constitute the triangular part */
      for (k = 1; k <= size; k++)
      {  i = rn[k];
         xassert(1 <= i && i <= m);
         flag[i] = 1;
         j = cn[k];
         xassert(1 <= j && j <= n);
         glp_set_col_stat(P, j, GLP_BS);
      }
      /* include in the basis appropriate auxiliary variables, whose
         unity columns preserve triangular form of the basis matrix */
      for (i = 1; i <= m; i++)
      {  if (flag[i] == 0)
         {  glp_set_row_stat(P, i, GLP_BS);
            if (P->row[i]->type != GLP_FX)
               size++;
         }
      }
      /* size of triangular part = (number of rows) - (number of basic
         fixed auxiliary variables) */
      xprintf("Size of triangular part is %d\n", size);
      /* deallocate working arrays */
      tfree(rn);
      tfree(cn);
      tfree(flag);
done: return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/asnhall.c0000644000175100001710000001302200000000000024441 0ustar00runnerdocker00000000000000/* asnhall.c (find bipartite matching of maximum cardinality) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "mc21a.h"

/***********************************************************************
*  NAME
*
*  glp_asnprob_hall - find bipartite matching of maximum cardinality
*
*  SYNOPSIS
*
*  int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
*
*  DESCRIPTION
*
*  The routine glp_asnprob_hall finds a matching of maximal cardinality
*  in the specified bipartite graph G. It uses a version of the Fortran
*  routine MC21A developed by I.S.Duff [1], which implements Hall's
*  algorithm [2].
*
*  RETURNS
*
*  The routine glp_asnprob_hall returns the cardinality of the matching
*  found. However, if the specified graph is incorrect (as detected by
*  the routine glp_check_asnprob), the routine returns negative value.
*
*  REFERENCES
*
*  1. I.S.Duff, Algorithm 575: Permutations for zero-free diagonal, ACM
*     Trans. on Math. Softw. 7 (1981), 387-390.
*
*  2. M.Hall, "An Algorithm for distinct representatives," Amer. Math.
*     Monthly 63 (1956), 716-717. */

int glp_asnprob_hall(glp_graph *G, int v_set, int a_x)
{     glp_vertex *v;
      glp_arc *a;
      int card, i, k, loc, n, n1, n2, xij;
      int *num, *icn, *ip, *lenr, *iperm, *pr, *arp, *cv, *out;
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_asnprob_hall: v_set = %d; invalid offset\n",
            v_set);
      if (a_x >= 0 && a_x > G->a_size - (int)sizeof(int))
         xerror("glp_asnprob_hall: a_x = %d; invalid offset\n", a_x);
      if (glp_check_asnprob(G, v_set))
         return -1;
      /* determine the number of vertices in sets R and S and renumber
         vertices in S which correspond to columns of the matrix; skip
         all isolated vertices */
      num = xcalloc(1+G->nv, sizeof(int));
      n1 = n2 = 0;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (v->in == NULL && v->out != NULL)
            n1++, num[i] = 0; /* vertex in R */
         else if (v->in != NULL && v->out == NULL)
            n2++, num[i] = n2; /* vertex in S */
         else
         {  xassert(v->in == NULL && v->out == NULL);
            num[i] = -1; /* isolated vertex */
         }
      }
      /* the matrix must be square, thus, if it has more columns than
         rows, extra rows will be just empty, and vice versa */
      n = (n1 >= n2 ? n1 : n2);
      /* allocate working arrays */
      icn = xcalloc(1+G->na, sizeof(int));
      ip = xcalloc(1+n, sizeof(int));
      lenr = xcalloc(1+n, sizeof(int));
      iperm = xcalloc(1+n, sizeof(int));
      pr = xcalloc(1+n, sizeof(int));
      arp = xcalloc(1+n, sizeof(int));
      cv = xcalloc(1+n, sizeof(int));
      out = xcalloc(1+n, sizeof(int));
      /* build the adjacency matrix of the bipartite graph in row-wise
         format (rows are vertices in R, columns are vertices in S) */
      k = 0, loc = 1;
      for (i = 1; i <= G->nv; i++)
      {  if (num[i] != 0) continue;
         /* vertex i in R */
         ip[++k] = loc;
         v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  xassert(num[a->head->i] != 0);
            icn[loc++] = num[a->head->i];
         }
         lenr[k] = loc - ip[k];
      }
      xassert(loc-1 == G->na);
      /* make all extra rows empty (all extra columns are empty due to
         the row-wise format used) */
      for (k++; k <= n; k++)
         ip[k] = loc, lenr[k] = 0;
      /* find a row permutation that maximizes the number of non-zeros
         on the main diagonal */
      card = mc21a(n, icn, ip, lenr, iperm, pr, arp, cv, out);
#if 1 /* 18/II-2010 */
      /* FIXED: if card = n, arp remains clobbered on exit */
      for (i = 1; i <= n; i++)
         arp[i] = 0;
      for (i = 1; i <= card; i++)
      {  k = iperm[i];
         xassert(1 <= k && k <= n);
         xassert(arp[k] == 0);
         arp[k] = i;
      }
#endif
      /* store solution, if necessary */
      if (a_x < 0) goto skip;
      k = 0;
      for (i = 1; i <= G->nv; i++)
      {  if (num[i] != 0) continue;
         /* vertex i in R */
         k++;
         v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  /* arp[k] is the number of matched column or zero */
            if (arp[k] == num[a->head->i])
            {  xassert(arp[k] != 0);
               xij = 1;
            }
            else
               xij = 0;
            memcpy((char *)a->data + a_x, &xij, sizeof(int));
         }
      }
skip: /* free working arrays */
      xfree(num);
      xfree(icn);
      xfree(ip);
      xfree(lenr);
      xfree(iperm);
      xfree(pr);
      xfree(arp);
      xfree(cv);
      xfree(out);
      return card;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/asnlp.c0000644000175100001710000000714000000000000024140 0ustar00runnerdocker00000000000000/* asnlp.c (convert assignment problem to LP) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_asnprob_lp - convert assignment problem to LP
*
*  SYNOPSIS
*
*  int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
*     int v_set, int a_cost);
*
*  DESCRIPTION
*
*  The routine glp_asnprob_lp builds an LP problem, which corresponds
*  to the assignment problem on the specified graph G.
*
*  RETURNS
*
*  If the LP problem has been successfully built, the routine returns
*  zero, otherwise, non-zero. */

int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
      int v_set, int a_cost)
{     glp_vertex *v;
      glp_arc *a;
      int i, j, ret, ind[1+2];
      double cost, val[1+2];
      if (!(form == GLP_ASN_MIN || form == GLP_ASN_MAX ||
            form == GLP_ASN_MMP))
         xerror("glp_asnprob_lp: form = %d; invalid parameter\n",
            form);
      if (!(names == GLP_ON || names == GLP_OFF))
         xerror("glp_asnprob_lp: names = %d; invalid parameter\n",
            names);
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_asnprob_lp: v_set = %d; invalid offset\n",
            v_set);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_asnprob_lp: a_cost = %d; invalid offset\n",
            a_cost);
      ret = glp_check_asnprob(G, v_set);
      if (ret != 0) goto done;
      glp_erase_prob(P);
      if (names) glp_set_prob_name(P, G->name);
      glp_set_obj_dir(P, form == GLP_ASN_MIN ? GLP_MIN : GLP_MAX);
      if (G->nv > 0) glp_add_rows(P, G->nv);
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (names) glp_set_row_name(P, i, v->name);
         glp_set_row_bnds(P, i, form == GLP_ASN_MMP ? GLP_UP : GLP_FX,
            1.0, 1.0);
      }
      if (G->na > 0) glp_add_cols(P, G->na);
      for (i = 1, j = 0; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  j++;
            if (names)
            {  char name[50+1];
               sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
               xassert(strlen(name) < sizeof(name));
               glp_set_col_name(P, j, name);
            }
            ind[1] = a->tail->i, val[1] = +1.0;
            ind[2] = a->head->i, val[2] = +1.0;
            glp_set_mat_col(P, j, 2, ind, val);
            glp_set_col_bnds(P, j, GLP_DB, 0.0, 1.0);
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 1.0;
            glp_set_obj_coef(P, j, cost);
         }
      }
      xassert(j == G->na);
done: return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/asnokalg.c0000644000175100001710000001210100000000000024613 0ustar00runnerdocker00000000000000/* asnokalg.c (solve assignment problem with out-of-kilter alg.) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "okalg.h"

int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
      double *sol, int a_x)
{     /* solve assignment problem with out-of-kilter algorithm */
      glp_vertex *v;
      glp_arc *a;
      int nv, na, i, k, *tail, *head, *low, *cap, *cost, *x, *pi, ret;
      double temp;
      if (!(form == GLP_ASN_MIN || form == GLP_ASN_MAX ||
            form == GLP_ASN_MMP))
         xerror("glp_asnprob_okalg: form = %d; invalid parameter\n",
            form);
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_asnprob_okalg: v_set = %d; invalid offset\n",
            v_set);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_asnprob_okalg: a_cost = %d; invalid offset\n",
            a_cost);
      if (a_x >= 0 && a_x > G->a_size - (int)sizeof(int))
         xerror("glp_asnprob_okalg: a_x = %d; invalid offset\n", a_x);
      if (glp_check_asnprob(G, v_set))
         return GLP_EDATA;
      /* nv is the total number of nodes in the resulting network */
      nv = G->nv + 1;
      /* na is the total number of arcs in the resulting network */
      na = G->na + G->nv;
      /* allocate working arrays */
      tail = xcalloc(1+na, sizeof(int));
      head = xcalloc(1+na, sizeof(int));
      low = xcalloc(1+na, sizeof(int));
      cap = xcalloc(1+na, sizeof(int));
      cost = xcalloc(1+na, sizeof(int));
      x = xcalloc(1+na, sizeof(int));
      pi = xcalloc(1+nv, sizeof(int));
      /* construct the resulting network */
      k = 0;
      /* (original arcs) */
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  k++;
            tail[k] = a->tail->i;
            head[k] = a->head->i;
            low[k] = 0;
            cap[k] = 1;
            if (a_cost >= 0)
               memcpy(&temp, (char *)a->data + a_cost, sizeof(double));
            else
               temp = 1.0;
            if (!(fabs(temp) <= (double)INT_MAX && temp == floor(temp)))
            {  ret = GLP_EDATA;
               goto done;
            }
            cost[k] = (int)temp;
            if (form != GLP_ASN_MIN) cost[k] = - cost[k];
         }
      }
      /* (artificial arcs) */
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         k++;
         if (v->out == NULL)
            tail[k] = i, head[k] = nv;
         else if (v->in == NULL)
            tail[k] = nv, head[k] = i;
         else
            xassert(v != v);
         low[k] = (form == GLP_ASN_MMP ? 0 : 1);
         cap[k] = 1;
         cost[k] = 0;
      }
      xassert(k == na);
      /* find minimal-cost circulation in the resulting network */
      ret = okalg(nv, na, tail, head, low, cap, cost, x, pi);
      switch (ret)
      {  case 0:
            /* optimal circulation found */
            ret = 0;
            break;
         case 1:
            /* no feasible circulation exists */
            ret = GLP_ENOPFS;
            break;
         case 2:
            /* integer overflow occured */
            ret = GLP_ERANGE;
            goto done;
         case 3:
            /* optimality test failed (logic error) */
            ret = GLP_EFAIL;
            goto done;
         default:
            xassert(ret != ret);
      }
      /* store solution components */
      /* (objective function = the total cost) */
      if (sol != NULL)
      {  temp = 0.0;
         for (k = 1; k <= na; k++)
            temp += (double)cost[k] * (double)x[k];
         if (form != GLP_ASN_MIN) temp = - temp;
         *sol = temp;
      }
      /* (arc flows) */
      if (a_x >= 0)
      {  k = 0;
         for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            for (a = v->out; a != NULL; a = a->t_next)
            {  k++;
               if (ret == 0)
                  xassert(x[k] == 0 || x[k] == 1);
               memcpy((char *)a->data + a_x, &x[k], sizeof(int));
            }
         }
      }
done: /* free working arrays */
      xfree(tail);
      xfree(head);
      xfree(low);
      xfree(cap);
      xfree(cost);
      xfree(x);
      xfree(pi);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/ckasn.c0000644000175100001710000000442400000000000024124 0ustar00runnerdocker00000000000000/* ckasn.c (check correctness of assignment problem data) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_check_asnprob - check correctness of assignment problem data
*
*  SYNOPSIS
*
*  int glp_check_asnprob(glp_graph *G, int v_set);
*
*  RETURNS
*
*  If the specified assignment problem data are correct, the routine
*  glp_check_asnprob returns zero, otherwise, non-zero. */

int glp_check_asnprob(glp_graph *G, int v_set)
{     glp_vertex *v;
      int i, k, ret = 0;
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_check_asnprob: v_set = %d; invalid offset\n",
            v_set);
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (v_set >= 0)
         {  memcpy(&k, (char *)v->data + v_set, sizeof(int));
            if (k == 0)
            {  if (v->in != NULL)
               {  ret = 1;
                  break;
               }
            }
            else if (k == 1)
            {  if (v->out != NULL)
               {  ret = 2;
                  break;
               }
            }
            else
            {  ret = 3;
               break;
            }
         }
         else
         {  if (v->in != NULL && v->out != NULL)
            {  ret = 4;
               break;
            }
         }
      }
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/ckcnf.c0000644000175100001710000000517100000000000024111 0ustar00runnerdocker00000000000000/* ckcnf.c (check for CNF-SAT problem instance) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

int glp_check_cnfsat(glp_prob *P)
{     /* check for CNF-SAT problem instance */
      int m = P->m;
      int n = P->n;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, neg;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_check_cnfsat: P = %p; invalid problem object\n",
            P);
#endif
      /* check columns */
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         /* the variable should be binary */
         if (!(col->kind == GLP_IV && col->type == GLP_DB &&
               col->lb == 0.0 && col->ub == 1.0))
            return 1;
      }
      /* objective function should be zero */
      if (P->c0 != 0.0)
         return 2;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         if (col->coef != 0.0)
            return 3;
      }
      /* check rows */
      for (i = 1; i <= m; i++)
      {  row = P->row[i];
         /* the row should be of ">=" type */
         if (row->type != GLP_LO)
            return 4;
         /* check constraint coefficients */
         neg = 0;
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  /* the constraint coefficient should be +1 or -1 */
            if (aij->val == +1.0)
               ;
            else if (aij->val == -1.0)
               neg++;
            else
               return 5;
         }
         /* the right-hand side should be (1 - neg), where neg is the
            number of negative constraint coefficients in the row */
         if (row->lb != (double)(1 - neg))
            return 6;
      }
      /* congratulations; this is CNF-SAT */
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/cplex.c0000644000175100001710000012715700000000000024151 0ustar00runnerdocker00000000000000/* cplex.c (CPLEX LP format routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"
#include "prob.h"

#define xfprintf glp_format

/***********************************************************************
*  NAME
*
*  glp_init_cpxcp - initialize CPLEX LP format control parameters
*
*  SYNOPSIS
*
*  void glp_init_cpxcp(glp_cpxcp *parm):
*
*  The routine glp_init_cpxcp initializes control parameters used by
*  the CPLEX LP input/output routines glp_read_lp and glp_write_lp with
*  default values.
*
*  Default values of the control parameters are stored in the glp_cpxcp
*  structure, which the parameter parm points to. */

void glp_init_cpxcp(glp_cpxcp *parm)
{     xassert(parm != NULL);
      return;
}

static void check_parm(const char *func, const glp_cpxcp *parm)
{     /* check control parameters */
      xassert(func != NULL);
      xassert(parm != NULL);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_read_lp - read problem data in CPLEX LP format
*
*  SYNOPSIS
*
*  int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char
*     *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_lp reads problem data in CPLEX LP format from
*  a text file.
*
*  The parameter parm is a pointer to the structure glp_cpxcp, which
*  specifies control parameters used by the routine. If parm is NULL,
*  the routine uses default settings.
*
*  The character string fname specifies a name of the text file to be
*  read.
*
*  Note that before reading data the current content of the problem
*  object is completely erased with the routine glp_erase_prob.
*
*  RETURNS
*
*  If the operation was successful, the routine glp_read_lp returns
*  zero. Otherwise, it prints an error message and returns non-zero. */

struct csa
{     /* common storage area */
      glp_prob *P;
      /* LP/MIP problem object */
      const glp_cpxcp *parm;
      /* pointer to control parameters */
      const char *fname;
      /* name of input CPLEX LP file */
      glp_file *fp;
      /* stream assigned to input CPLEX LP file */
      jmp_buf jump;
      /* label for go to in case of error */
      int count;
      /* line count */
      int c;
      /* current character or EOF */
      int token;
      /* current token: */
#define T_EOF        0x00  /* end of file */
#define T_MINIMIZE   0x01  /* keyword 'minimize' */
#define T_MAXIMIZE   0x02  /* keyword 'maximize' */
#define T_SUBJECT_TO 0x03  /* keyword 'subject to' */
#define T_BOUNDS     0x04  /* keyword 'bounds' */
#define T_GENERAL    0x05  /* keyword 'general' */
#define T_INTEGER    0x06  /* keyword 'integer' */
#define T_BINARY     0x07  /* keyword 'binary' */
#define T_END        0x08  /* keyword 'end' */
#define T_NAME       0x09  /* symbolic name */
#define T_NUMBER     0x0A  /* numeric constant */
#define T_PLUS       0x0B  /* delimiter '+' */
#define T_MINUS      0x0C  /* delimiter '-' */
#define T_COLON      0x0D  /* delimiter ':' */
#define T_LE         0x0E  /* delimiter '<=' */
#define T_GE         0x0F  /* delimiter '>=' */
#define T_EQ         0x10  /* delimiter '=' */
      char image[255+1];
      /* image of current token */
      int imlen;
      /* length of token image */
      double value;
      /* value of numeric constant */
      int n_max;
      /* length of the following five arrays (enlarged automatically,
         if necessary) */
      int *ind; /* int ind[1+n_max]; */
      double *val; /* double val[1+n_max]; */
      char *flag; /* char flag[1+n_max]; */
      /* working arrays used to construct linear forms */
      double *lb; /* double lb[1+n_max]; */
      double *ub; /* double ub[1+n_max]; */
      /* lower and upper bounds of variables (columns) */
#if 1 /* 27/VII-2013 */
      int lb_warn, ub_warn;
      /* warning 'lower/upper bound redefined' already issued */
#endif
};

#define CHAR_SET "!\"#$%&()/,.;?@_`'{}|~"
/* characters that may appear in symbolic names */

static void error(struct csa *csa, const char *fmt, ...)
{     /* print error message and terminate processing */
      va_list arg;
      xprintf("%s:%d: ", csa->fname, csa->count);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      longjmp(csa->jump, 1);
      /* no return */
}

static void warning(struct csa *csa, const char *fmt, ...)
{     /* print warning message and continue processing */
      va_list arg;
      xprintf("%s:%d: warning: ", csa->fname, csa->count);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      return;
}

static void read_char(struct csa *csa)
{     /* read next character from input file */
      int c;
      xassert(csa->c != EOF);
      if (csa->c == '\n') csa->count++;
      c = glp_getc(csa->fp);
      if (c < 0)
      {  if (glp_ioerr(csa->fp))
            error(csa, "read error - %s\n", get_err_msg());
         else if (csa->c == '\n')
         {  csa->count--;
            c = EOF;
         }
         else
         {  warning(csa, "missing final end of line\n");
            c = '\n';
         }
      }
      else if (c == '\n')
         ;
      else if (isspace(c))
         c = ' ';
      else if (iscntrl(c))
         error(csa, "invalid control character 0x%02X\n", c);
      csa->c = c;
      return;
}

static void add_char(struct csa *csa)
{     /* append current character to current token */
      if (csa->imlen == sizeof(csa->image)-1)
         error(csa, "token '%.15s...' too long\n", csa->image);
      csa->image[csa->imlen++] = (char)csa->c;
      csa->image[csa->imlen] = '\0';
      read_char(csa);
      return;
}

static int the_same(char *s1, char *s2)
{     /* compare two character strings ignoring case sensitivity */
      for (; *s1 != '\0'; s1++, s2++)
      {  if (tolower((unsigned char)*s1) != tolower((unsigned char)*s2))
            return 0;
      }
      return 1;
}

static void scan_token(struct csa *csa)
{     /* scan next token */
      int flag;
      csa->token = -1;
      csa->image[0] = '\0';
      csa->imlen = 0;
      csa->value = 0.0;
loop: flag = 0;
      /* skip non-significant characters */
      while (csa->c == ' ') read_char(csa);
      /* recognize and scan current token */
      if (csa->c == EOF)
         csa->token = T_EOF;
      else if (csa->c == '\n')
      {  read_char(csa);
         /* if the next character is letter, it may begin a keyword */
         if (isalpha(csa->c))
         {  flag = 1;
            goto name;
         }
         goto loop;
      }
      else if (csa->c == '\\')
      {  /* comment; ignore everything until end-of-line */
         while (csa->c != '\n') read_char(csa);
         goto loop;
      }
      else if (isalpha(csa->c) || csa->c != '.' && strchr(CHAR_SET,
         csa->c) != NULL)
name: {  /* symbolic name */
         csa->token = T_NAME;
         while (isalnum(csa->c) || strchr(CHAR_SET, csa->c) != NULL)
            add_char(csa);
         if (flag)
         {  /* check for keyword */
            if (the_same(csa->image, "minimize"))
               csa->token = T_MINIMIZE;
            else if (the_same(csa->image, "minimum"))
               csa->token = T_MINIMIZE;
            else if (the_same(csa->image, "min"))
               csa->token = T_MINIMIZE;
            else if (the_same(csa->image, "maximize"))
               csa->token = T_MAXIMIZE;
            else if (the_same(csa->image, "maximum"))
               csa->token = T_MAXIMIZE;
            else if (the_same(csa->image, "max"))
               csa->token = T_MAXIMIZE;
            else if (the_same(csa->image, "subject"))
            {  if (csa->c == ' ')
               {  read_char(csa);
                  if (tolower(csa->c) == 't')
                  {  csa->token = T_SUBJECT_TO;
                     csa->image[csa->imlen++] = ' ';
                     csa->image[csa->imlen] = '\0';
                     add_char(csa);
                     if (tolower(csa->c) != 'o')
                        error(csa, "keyword 'subject to' incomplete\n");
                     add_char(csa);
                     if (isalpha(csa->c))
                        error(csa, "keyword '%s%c...' not recognized\n",
                           csa->image, csa->c);
                  }
               }
            }
            else if (the_same(csa->image, "such"))
            {  if (csa->c == ' ')
               {  read_char(csa);
                  if (tolower(csa->c) == 't')
                  {  csa->token = T_SUBJECT_TO;
                     csa->image[csa->imlen++] = ' ';
                     csa->image[csa->imlen] = '\0';
                     add_char(csa);
                     if (tolower(csa->c) != 'h')
err:                    error(csa, "keyword 'such that' incomplete\n");
                     add_char(csa);
                     if (tolower(csa->c) != 'a') goto err;
                     add_char(csa);
                     if (tolower(csa->c) != 't') goto err;
                     add_char(csa);
                     if (isalpha(csa->c))
                        error(csa, "keyword '%s%c...' not recognized\n",
                           csa->image, csa->c);
                  }
               }
            }
            else if (the_same(csa->image, "st"))
               csa->token = T_SUBJECT_TO;
            else if (the_same(csa->image, "s.t."))
               csa->token = T_SUBJECT_TO;
            else if (the_same(csa->image, "st."))
               csa->token = T_SUBJECT_TO;
            else if (the_same(csa->image, "bounds"))
               csa->token = T_BOUNDS;
            else if (the_same(csa->image, "bound"))
               csa->token = T_BOUNDS;
            else if (the_same(csa->image, "general"))
               csa->token = T_GENERAL;
            else if (the_same(csa->image, "generals"))
               csa->token = T_GENERAL;
            else if (the_same(csa->image, "gen"))
               csa->token = T_GENERAL;
            else if (the_same(csa->image, "integer"))
               csa->token = T_INTEGER;
            else if (the_same(csa->image, "integers"))
               csa->token = T_INTEGER;
            else if (the_same(csa->image, "int"))
              csa->token = T_INTEGER;
            else if (the_same(csa->image, "binary"))
               csa->token = T_BINARY;
            else if (the_same(csa->image, "binaries"))
               csa->token = T_BINARY;
            else if (the_same(csa->image, "bin"))
               csa->token = T_BINARY;
            else if (the_same(csa->image, "end"))
               csa->token = T_END;
         }
      }
      else if (isdigit(csa->c) || csa->c == '.')
      {  /* numeric constant */
         csa->token = T_NUMBER;
         /* scan integer part */
         while (isdigit(csa->c)) add_char(csa);
         /* scan optional fractional part (it is mandatory, if there is
            no integer part) */
         if (csa->c == '.')
         {  add_char(csa);
            if (csa->imlen == 1 && !isdigit(csa->c))
               error(csa, "invalid use of decimal point\n");
            while (isdigit(csa->c)) add_char(csa);
         }
         /* scan optional decimal exponent */
         if (csa->c == 'e' || csa->c == 'E')
         {  add_char(csa);
            if (csa->c == '+' || csa->c == '-') add_char(csa);
            if (!isdigit(csa->c))
               error(csa, "numeric constant '%s' incomplete\n",
                  csa->image);
            while (isdigit(csa->c)) add_char(csa);
         }
         /* convert the numeric constant to floating-point */
         if (str2num(csa->image, &csa->value))
            error(csa, "numeric constant '%s' out of range\n",
               csa->image);
      }
      else if (csa->c == '+')
         csa->token = T_PLUS, add_char(csa);
      else if (csa->c == '-')
         csa->token = T_MINUS, add_char(csa);
      else if (csa->c == ':')
         csa->token = T_COLON, add_char(csa);
      else if (csa->c == '<')
      {  csa->token = T_LE, add_char(csa);
         if (csa->c == '=') add_char(csa);
      }
      else if (csa->c == '>')
      {  csa->token = T_GE, add_char(csa);
         if (csa->c == '=') add_char(csa);
      }
      else if (csa->c == '=')
      {  csa->token = T_EQ, add_char(csa);
         if (csa->c == '<')
            csa->token = T_LE, add_char(csa);
         else if (csa->c == '>')
            csa->token = T_GE, add_char(csa);
      }
      else
         error(csa, "character '%c' not recognized\n", csa->c);
      /* skip non-significant characters */
      while (csa->c == ' ') read_char(csa);
      return;
}

static int find_col(struct csa *csa, char *name)
{     /* find column by its symbolic name */
      int j;
      j = glp_find_col(csa->P, name);
      if (j == 0)
      {  /* not found; create new column */
         j = glp_add_cols(csa->P, 1);
         glp_set_col_name(csa->P, j, name);
         /* enlarge working arrays, if necessary */
         if (csa->n_max < j)
         {  int n_max = csa->n_max;
            int *ind = csa->ind;
            double *val = csa->val;
            char *flag = csa->flag;
            double *lb = csa->lb;
            double *ub = csa->ub;
            csa->n_max += csa->n_max;
            csa->ind = xcalloc(1+csa->n_max, sizeof(int));
            memcpy(&csa->ind[1], &ind[1], n_max * sizeof(int));
            xfree(ind);
            csa->val = xcalloc(1+csa->n_max, sizeof(double));
            memcpy(&csa->val[1], &val[1], n_max * sizeof(double));
            xfree(val);
            csa->flag = xcalloc(1+csa->n_max, sizeof(char));
            memset(&csa->flag[1], 0, csa->n_max * sizeof(char));
            memcpy(&csa->flag[1], &flag[1], n_max * sizeof(char));
            xfree(flag);
            csa->lb = xcalloc(1+csa->n_max, sizeof(double));
            memcpy(&csa->lb[1], &lb[1], n_max * sizeof(double));
            xfree(lb);
            csa->ub = xcalloc(1+csa->n_max, sizeof(double));
            memcpy(&csa->ub[1], &ub[1], n_max * sizeof(double));
            xfree(ub);
         }
         csa->lb[j] = +DBL_MAX, csa->ub[j] = -DBL_MAX;
      }
      return j;
}

/***********************************************************************
*  parse_linear_form - parse linear form
*
*  This routine parses the linear form using the following syntax:
*
*   ::= 
*   ::= 
*   ::=  |  
*   ::=  | +  | -  |
*      +  |  - 
*
*  The routine returns the number of terms in the linear form. */

static int parse_linear_form(struct csa *csa)
{     int j, k, len = 0, newlen;
      double s, coef;
loop: /* parse an optional sign */
      if (csa->token == T_PLUS)
         s = +1.0, scan_token(csa);
      else if (csa->token == T_MINUS)
         s = -1.0, scan_token(csa);
      else
         s = +1.0;
      /* parse an optional coefficient */
      if (csa->token == T_NUMBER)
         coef = csa->value, scan_token(csa);
      else
         coef = 1.0;
      /* parse a variable name */
      if (csa->token != T_NAME)
         error(csa, "missing variable name\n");
      /* find the corresponding column */
      j = find_col(csa, csa->image);
      /* check if the variable is already used in the linear form */
      if (csa->flag[j])
         error(csa, "multiple use of variable '%s' not allowed\n",
            csa->image);
      /* add new term to the linear form */
      len++, csa->ind[len] = j, csa->val[len] = s * coef;
      /* and mark that the variable is used in the linear form */
      csa->flag[j] = 1;
      scan_token(csa);
      /* if the next token is a sign, there is another term */
      if (csa->token == T_PLUS || csa->token == T_MINUS) goto loop;
      /* clear marks of the variables used in the linear form */
      for (k = 1; k <= len; k++) csa->flag[csa->ind[k]] = 0;
      /* remove zero coefficients */
      newlen = 0;
      for (k = 1; k <= len; k++)
      {  if (csa->val[k] != 0.0)
         {  newlen++;
            csa->ind[newlen] = csa->ind[k];
            csa->val[newlen] = csa->val[k];
         }
      }
      return newlen;
}

/***********************************************************************
*  parse_objective - parse objective function
*
*  This routine parses definition of the objective function using the
*  following syntax:
*
*   ::= minimize | minimum | min | maximize | maximum | max
*   ::=  |  :
*   ::=    */

static void parse_objective(struct csa *csa)
{     /* parse objective sense */
      int k, len;
      /* parse the keyword 'minimize' or 'maximize' */
      if (csa->token == T_MINIMIZE)
         glp_set_obj_dir(csa->P, GLP_MIN);
      else if (csa->token == T_MAXIMIZE)
         glp_set_obj_dir(csa->P, GLP_MAX);
      else
         xassert(csa != csa);
      scan_token(csa);
      /* parse objective name */
      if (csa->token == T_NAME && csa->c == ':')
      {  /* objective name is followed by a colon */
         glp_set_obj_name(csa->P, csa->image);
         scan_token(csa);
         xassert(csa->token == T_COLON);
         scan_token(csa);
      }
      else
      {  /* objective name is not specified; use default */
         glp_set_obj_name(csa->P, "obj");
      }
      /* parse linear form */
      len = parse_linear_form(csa);
      for (k = 1; k <= len; k++)
         glp_set_obj_coef(csa->P, csa->ind[k], csa->val[k]);
      return;
}

/***********************************************************************
*  parse_constraints - parse constraints section
*
*  This routine parses the constraints section using the following
*  syntax:
*
*   ::=  |  :
*   ::= < | <= | =< | > | >= | => | =
*   ::=  | +  |
*     - 
*   ::=   
*     
*   ::= subject to | such that | st | s.t. | st.
*   ::=   |
*       */

static void parse_constraints(struct csa *csa)
{     int i, len, type;
      double s;
      /* parse the keyword 'subject to' */
      xassert(csa->token == T_SUBJECT_TO);
      scan_token(csa);
loop: /* create new row (constraint) */
      i = glp_add_rows(csa->P, 1);
      /* parse row name */
      if (csa->token == T_NAME && csa->c == ':')
      {  /* row name is followed by a colon */
         if (glp_find_row(csa->P, csa->image) != 0)
            error(csa, "constraint '%s' multiply defined\n",
               csa->image);
         glp_set_row_name(csa->P, i, csa->image);
         scan_token(csa);
         xassert(csa->token == T_COLON);
         scan_token(csa);
      }
      else
      {  /* row name is not specified; use default */
         char name[50];
         sprintf(name, "r.%d", csa->count);
         glp_set_row_name(csa->P, i, name);
      }
      /* parse linear form */
      len = parse_linear_form(csa);
      glp_set_mat_row(csa->P, i, len, csa->ind, csa->val);
      /* parse constraint sense */
      if (csa->token == T_LE)
         type = GLP_UP, scan_token(csa);
      else if (csa->token == T_GE)
         type = GLP_LO, scan_token(csa);
      else if (csa->token == T_EQ)
         type = GLP_FX, scan_token(csa);
      else
         error(csa, "missing constraint sense\n");
      /* parse right-hand side */
      if (csa->token == T_PLUS)
         s = +1.0, scan_token(csa);
      else if (csa->token == T_MINUS)
         s = -1.0, scan_token(csa);
      else
         s = +1.0;
      if (csa->token != T_NUMBER)
         error(csa, "missing right-hand side\n");
      glp_set_row_bnds(csa->P, i, type, s * csa->value, s * csa->value);
      /* the rest of the current line must be empty */
      if (!(csa->c == '\n' || csa->c == EOF))
         error(csa, "invalid symbol(s) beyond right-hand side\n");
      scan_token(csa);
      /* if the next token is a sign, numeric constant, or a symbolic
         name, here is another constraint */
      if (csa->token == T_PLUS || csa->token == T_MINUS ||
          csa->token == T_NUMBER || csa->token == T_NAME) goto loop;
      return;
}

static void set_lower_bound(struct csa *csa, int j, double lb)
{     /* set lower bound of j-th variable */
      if (csa->lb[j] != +DBL_MAX && !csa->lb_warn)
      {  warning(csa, "lower bound of variable '%s' redefined\n",
            glp_get_col_name(csa->P, j));
         csa->lb_warn = 1;
      }
      csa->lb[j] = lb;
      return;
}

static void set_upper_bound(struct csa *csa, int j, double ub)
{     /* set upper bound of j-th variable */
      if (csa->ub[j] != -DBL_MAX && !csa->ub_warn)
      {  warning(csa, "upper bound of variable '%s' redefined\n",
            glp_get_col_name(csa->P, j));
         csa->ub_warn = 1;
      }
      csa->ub[j] = ub;
      return;
}

/***********************************************************************
*  parse_bounds - parse bounds section
*
*  This routine parses the bounds section using the following syntax:
*
*   ::= 
*   ::= infinity | inf
*   ::=  | +  |
*     -  | +  | - 
*   ::= < | <= | =<
*   ::= > | >= | =>
*   ::=      |
*        |    |
*        |  =  |  free
*   ::= bounds | bound
*   ::=  |
*       */

static void parse_bounds(struct csa *csa)
{     int j, lb_flag;
      double lb, s;
      /* parse the keyword 'bounds' */
      xassert(csa->token == T_BOUNDS);
      scan_token(csa);
loop: /* bound definition can start with a sign, numeric constant, or
         a symbolic name */
      if (!(csa->token == T_PLUS || csa->token == T_MINUS ||
            csa->token == T_NUMBER || csa->token == T_NAME)) goto done;
      /* parse bound definition */
      if (csa->token == T_PLUS || csa->token == T_MINUS)
      {  /* parse signed lower bound */
         lb_flag = 1;
         s = (csa->token == T_PLUS ? +1.0 : -1.0);
         scan_token(csa);
         if (csa->token == T_NUMBER)
            lb = s * csa->value, scan_token(csa);
         else if (the_same(csa->image, "infinity") ||
                  the_same(csa->image, "inf"))
         {  if (s > 0.0)
               error(csa, "invalid use of '+inf' as lower bound\n");
            lb = -DBL_MAX, scan_token(csa);
         }
         else
            error(csa, "missing lower bound\n");
      }
      else if (csa->token == T_NUMBER)
      {  /* parse unsigned lower bound */
         lb_flag = 1;
         lb = csa->value, scan_token(csa);
      }
      else
      {  /* lower bound is not specified */
         lb_flag = 0;
      }
      /* parse the token that should follow the lower bound */
      if (lb_flag)
      {  if (csa->token != T_LE)
            error(csa, "missing '<', '<=', or '=<' after lower bound\n")
               ;
         scan_token(csa);
      }
      /* parse variable name */
      if (csa->token != T_NAME)
         error(csa, "missing variable name\n");
      j = find_col(csa, csa->image);
      /* set lower bound */
      if (lb_flag) set_lower_bound(csa, j, lb);
      scan_token(csa);
      /* parse the context that follows the variable name */
      if (csa->token == T_LE)
      {  /* parse upper bound */
         scan_token(csa);
         if (csa->token == T_PLUS || csa->token == T_MINUS)
         {  /* parse signed upper bound */
            s = (csa->token == T_PLUS ? +1.0 : -1.0);
            scan_token(csa);
            if (csa->token == T_NUMBER)
            {  set_upper_bound(csa, j, s * csa->value);
               scan_token(csa);
            }
            else if (the_same(csa->image, "infinity") ||
                     the_same(csa->image, "inf"))
            {  if (s < 0.0)
                  error(csa, "invalid use of '-inf' as upper bound\n");
               set_upper_bound(csa, j, +DBL_MAX);
               scan_token(csa);
            }
            else
               error(csa, "missing upper bound\n");
         }
         else if (csa->token == T_NUMBER)
         {  /* parse unsigned upper bound */
            set_upper_bound(csa, j, csa->value);
            scan_token(csa);
         }
         else
            error(csa, "missing upper bound\n");
      }
      else if (csa->token == T_GE)
      {  /* parse lower bound */
         if (lb_flag)
         {  /* the context '... <= x >= ...' is invalid */
            error(csa, "invalid bound definition\n");
         }
         scan_token(csa);
         if (csa->token == T_PLUS || csa->token == T_MINUS)
         {  /* parse signed lower bound */
            s = (csa->token == T_PLUS ? +1.0 : -1.0);
            scan_token(csa);
            if (csa->token == T_NUMBER)
            {  set_lower_bound(csa, j, s * csa->value);
               scan_token(csa);
            }
            else if (the_same(csa->image, "infinity") ||
                     the_same(csa->image, "inf") == 0)
            {  if (s > 0.0)
                  error(csa, "invalid use of '+inf' as lower bound\n");
               set_lower_bound(csa, j, -DBL_MAX);
               scan_token(csa);
            }
            else
               error(csa, "missing lower bound\n");
         }
         else if (csa->token == T_NUMBER)
         {  /* parse unsigned lower bound */
            set_lower_bound(csa, j, csa->value);
            scan_token(csa);
         }
         else
            error(csa, "missing lower bound\n");
      }
      else if (csa->token == T_EQ)
      {  /* parse fixed value */
         if (lb_flag)
         {  /* the context '... <= x = ...' is invalid */
            error(csa, "invalid bound definition\n");
         }
         scan_token(csa);
         if (csa->token == T_PLUS || csa->token == T_MINUS)
         {  /* parse signed fixed value */
            s = (csa->token == T_PLUS ? +1.0 : -1.0);
            scan_token(csa);
            if (csa->token == T_NUMBER)
            {  set_lower_bound(csa, j, s * csa->value);
               set_upper_bound(csa, j, s * csa->value);
               scan_token(csa);
            }
            else
               error(csa, "missing fixed value\n");
         }
         else if (csa->token == T_NUMBER)
         {  /* parse unsigned fixed value */
            set_lower_bound(csa, j, csa->value);
            set_upper_bound(csa, j, csa->value);
            scan_token(csa);
         }
         else
            error(csa, "missing fixed value\n");
      }
      else if (the_same(csa->image, "free"))
      {  /* parse the keyword 'free' */
         if (lb_flag)
         {  /* the context '... <= x free ...' is invalid */
            error(csa, "invalid bound definition\n");
         }
         set_lower_bound(csa, j, -DBL_MAX);
         set_upper_bound(csa, j, +DBL_MAX);
         scan_token(csa);
      }
      else if (!lb_flag)
      {  /* neither lower nor upper bounds are specified */
         error(csa, "invalid bound definition\n");
      }
      goto loop;
done: return;
}

/***********************************************************************
*  parse_integer - parse general, integer, or binary section
*
*   ::= 
*   ::= general | generals | gen
*   ::= integer | integers | int
*   ::= binary | binaries | bin
*  
 ::=   
*   ::= 
 |
*       */

static void parse_integer(struct csa *csa)
{     int j, binary;
      /* parse the keyword 'general', 'integer', or 'binary' */
      if (csa->token == T_GENERAL)
         binary = 0, scan_token(csa);
      else if (csa->token == T_INTEGER)
         binary = 0, scan_token(csa);
      else if (csa->token == T_BINARY)
         binary = 1, scan_token(csa);
      else
         xassert(csa != csa);
      /* parse list of variables (may be empty) */
      while (csa->token == T_NAME)
      {  /* find the corresponding column */
         j = find_col(csa, csa->image);
         /* change kind of the variable */
         glp_set_col_kind(csa->P, j, GLP_IV);
         /* set bounds for the binary variable */
         if (binary)
#if 0 /* 07/VIII-2013 */
         {  set_lower_bound(csa, j, 0.0);
            set_upper_bound(csa, j, 1.0);
         }
#else
         {  set_lower_bound(csa, j,
               csa->lb[j] == +DBL_MAX ? 0.0 : csa->lb[j]);
            set_upper_bound(csa, j,
               csa->ub[j] == -DBL_MAX ? 1.0 : csa->ub[j]);
         }
#endif
         scan_token(csa);
      }
      return;
}

int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)
{     /* read problem data in CPLEX LP format */
      glp_cpxcp _parm;
      struct csa _csa, *csa = &_csa;
      int ret;
      xprintf("Reading problem data from '%s'...\n", fname);
      if (parm == NULL)
         glp_init_cpxcp(&_parm), parm = &_parm;
      /* check control parameters */
      check_parm("glp_read_lp", parm);
      /* initialize common storage area */
      csa->P = P;
      csa->parm = parm;
      csa->fname = fname;
      csa->fp = NULL;
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->count = 0;
      csa->c = '\n';
      csa->token = T_EOF;
      csa->image[0] = '\0';
      csa->imlen = 0;
      csa->value = 0.0;
      csa->n_max = 100;
      csa->ind = xcalloc(1+csa->n_max, sizeof(int));
      csa->val = xcalloc(1+csa->n_max, sizeof(double));
      csa->flag = xcalloc(1+csa->n_max, sizeof(char));
      memset(&csa->flag[1], 0, csa->n_max * sizeof(char));
      csa->lb = xcalloc(1+csa->n_max, sizeof(double));
      csa->ub = xcalloc(1+csa->n_max, sizeof(double));
#if 1 /* 27/VII-2013 */
      csa->lb_warn = csa->ub_warn = 0;
#endif
      /* erase problem object */
      glp_erase_prob(P);
      glp_create_index(P);
      /* open input CPLEX LP file */
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* scan very first token */
      scan_token(csa);
      /* parse definition of the objective function */
      if (!(csa->token == T_MINIMIZE || csa->token == T_MAXIMIZE))
         error(csa, "'minimize' or 'maximize' keyword missing\n");
      parse_objective(csa);
      /* parse constraints section */
      if (csa->token != T_SUBJECT_TO)
         error(csa, "constraints section missing\n");
      parse_constraints(csa);
      /* parse optional bounds section */
      if (csa->token == T_BOUNDS) parse_bounds(csa);
      /* parse optional general, integer, and binary sections */
      while (csa->token == T_GENERAL ||
             csa->token == T_INTEGER ||
             csa->token == T_BINARY) parse_integer(csa);
      /* check for the keyword 'end' */
      if (csa->token == T_END)
         scan_token(csa);
      else if (csa->token == T_EOF)
         warning(csa, "keyword 'end' missing\n");
      else
         error(csa, "symbol '%s' in wrong position\n", csa->image);
      /* nothing must follow the keyword 'end' (except comments) */
      if (csa->token != T_EOF)
         error(csa, "extra symbol(s) detected beyond 'end'\n");
      /* set bounds of variables */
      {  int j, type;
         double lb, ub;
         for (j = 1; j <= P->n; j++)
         {  lb = csa->lb[j];
            ub = csa->ub[j];
            if (lb == +DBL_MAX) lb = 0.0;      /* default lb */
            if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */
            if (lb == -DBL_MAX && ub == +DBL_MAX)
               type = GLP_FR;
            else if (ub == +DBL_MAX)
               type = GLP_LO;
            else if (lb == -DBL_MAX)
               type = GLP_UP;
            else if (lb != ub)
               type = GLP_DB;
            else
               type = GLP_FX;
            glp_set_col_bnds(csa->P, j, type, lb, ub);
         }
      }
      /* print some statistics */
      xprintf("%d row%s, %d column%s, %d non-zero%s\n",
         P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
         P->nnz, P->nnz == 1 ? "" : "s");
      if (glp_get_num_int(P) > 0)
      {  int ni = glp_get_num_int(P);
         int nb = glp_get_num_bin(P);
         if (ni == 1)
         {  if (nb == 0)
               xprintf("One variable is integer\n");
            else
               xprintf("One variable is binary\n");
         }
         else
         {  xprintf("%d integer variables, ", ni);
            if (nb == 0)
               xprintf("none");
            else if (nb == 1)
               xprintf("one");
            else if (nb == ni)
               xprintf("all");
            else
               xprintf("%d", nb);
            xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
         }
      }
      xprintf("%d lines were read\n", csa->count);
      /* problem data has been successfully read */
      glp_delete_index(P);
      glp_sort_matrix(P);
      ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
      xfree(csa->ind);
      xfree(csa->val);
      xfree(csa->flag);
      xfree(csa->lb);
      xfree(csa->ub);
      if (ret != 0) glp_erase_prob(P);
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_write_lp - write problem data in CPLEX LP format
*
*  SYNOPSIS
*
*  int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char
*     *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_lp writes problem data in CPLEX LP format to
*  a text file.
*
*  The parameter parm is a pointer to the structure glp_cpxcp, which
*  specifies control parameters used by the routine. If parm is NULL,
*  the routine uses default settings.
*
*  The character string fname specifies a name of the text file to be
*  written.
*
*  RETURNS
*
*  If the operation was successful, the routine glp_write_lp returns
*  zero. Otherwise, it prints an error message and returns non-zero. */

#define csa csa1

struct csa
{     /* common storage area */
      glp_prob *P;
      /* pointer to problem object */
      const glp_cpxcp *parm;
      /* pointer to control parameters */
};

static int check_name(char *name)
{     /* check if specified name is valid for CPLEX LP format */
      if (*name == '.') return 1;
      if (isdigit((unsigned char)*name)) return 1;
      for (; *name; name++)
      {  if (!isalnum((unsigned char)*name) &&
             strchr(CHAR_SET, (unsigned char)*name) == NULL) return 1;
      }
      return 0; /* name is ok */
}

static void adjust_name(char *name)
{     /* attempt to adjust specified name to make it valid for CPLEX LP
         format */
      for (; *name; name++)
      {  if (*name == ' ')
            *name = '_';
         else if (*name == '-')
            *name = '~';
         else if (*name == '[')
            *name = '(';
         else if (*name == ']')
            *name = ')';
      }
      return;
}

static char *row_name(struct csa *csa, int i, char rname[255+1])
{     /* construct symbolic name of i-th row (constraint) */
      const char *name;
      if (i == 0)
         name = glp_get_obj_name(csa->P);
      else
         name = glp_get_row_name(csa->P, i);
      if (name == NULL) goto fake;
      strcpy(rname, name);
      adjust_name(rname);
      if (check_name(rname)) goto fake;
      return rname;
fake: if (i == 0)
         strcpy(rname, "obj");
      else
         sprintf(rname, "r_%d", i);
      return rname;
}

static char *col_name(struct csa *csa, int j, char cname[255+1])
{     /* construct symbolic name of j-th column (variable) */
      const char *name;
      name = glp_get_col_name(csa->P, j);
      if (name == NULL) goto fake;
      strcpy(cname, name);
      adjust_name(cname);
      if (check_name(cname)) goto fake;
      return cname;
#if 0 /* 18/I-2018 */
fake: sprintf(cname, "x_%d", j);
#else
fake: /* construct fake name depending on column's attributes */
      {  GLPCOL *col = csa->P->col[j];
         if (col->type == GLP_FX)
         {  /* fixed column */
            sprintf(cname, "s_%d", j);
         }
         else if (col->kind == GLP_CV)
         {  /* continuous variable */
            sprintf(cname, "x_%d", j);
         }
         else if (!(col->lb == 0 && col->ub == 1))
         {  /* general (non-binary) integer variable */
            sprintf(cname, "y_%d", j);
         }
         else
         {  /* binary variable */
            sprintf(cname, "z_%d", j);
         }
      }
#endif
      return cname;
}

int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)
{     /* write problem data in CPLEX LP format */
      glp_cpxcp _parm;
      struct csa _csa, *csa = &_csa;
      glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, len, flag, count, ret;
      char line[1000+1], term[500+1], name[255+1];
      xprintf("Writing problem data to '%s'...\n", fname);
      if (parm == NULL)
         glp_init_cpxcp(&_parm), parm = &_parm;
      /* check control parameters */
      check_parm("glp_write_lp", parm);
      /* initialize common storage area */
      csa->P = P;
      csa->parm = parm;
      /* create output CPLEX LP file */
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* write problem name */
      xfprintf(fp, "\\* Problem: %s *\\\n",
         P->name == NULL ? "Unknown" : P->name), count++;
      xfprintf(fp, "\n"), count++;
      /* the problem should contain at least one row and one column */
      if (!(P->m > 0 && P->n > 0))
      {  xprintf("Warning: problem has no rows/columns\n");
         xfprintf(fp, "\\* WARNING: PROBLEM HAS NO ROWS/COLUMNS *\\\n"),
            count++;
         xfprintf(fp, "\n"), count++;
         goto skip;
      }
      /* write the objective function definition */
      if (P->dir == GLP_MIN)
         xfprintf(fp, "Minimize\n"), count++;
      else if (P->dir == GLP_MAX)
         xfprintf(fp, "Maximize\n"), count++;
      else
         xassert(P != P);
      row_name(csa, 0, name);
      sprintf(line, " %s:", name);
      len = 0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->coef != 0.0 || col->ptr == NULL)
         {  len++;
            col_name(csa, j, name);
            if (col->coef == 0.0)
               sprintf(term, " + 0 %s", name); /* empty column */
            else if (col->coef == +1.0)
               sprintf(term, " + %s", name);
            else if (col->coef == -1.0)
               sprintf(term, " - %s", name);
            else if (col->coef > 0.0)
               sprintf(term, " + %.*g %s", DBL_DIG, +col->coef, name);
            else
               sprintf(term, " - %.*g %s", DBL_DIG, -col->coef, name);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
      }
      if (len == 0)
      {  /* empty objective */
         sprintf(term, " 0 %s", col_name(csa, 1, name));
         strcat(line, term);
      }
      xfprintf(fp, "%s\n", line), count++;
      if (P->c0 != 0.0)
         xfprintf(fp, "\\* constant term = %.*g *\\\n", DBL_DIG, P->c0),
            count++;
      xfprintf(fp, "\n"), count++;
      /* write the constraints section */
      xfprintf(fp, "Subject To\n"), count++;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type == GLP_FR) continue; /* skip free row */
         row_name(csa, i, name);
         sprintf(line, " %s:", name);
         /* linear form */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  col_name(csa, aij->col->j, name);
            if (aij->val == +1.0)
               sprintf(term, " + %s", name);
            else if (aij->val == -1.0)
               sprintf(term, " - %s", name);
            else if (aij->val > 0.0)
               sprintf(term, " + %.*g %s", DBL_DIG, +aij->val, name);
            else
               sprintf(term, " - %.*g %s", DBL_DIG, -aij->val, name);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
         if (row->type == GLP_DB)
         {  /* double-bounded (ranged) constraint */
            sprintf(term, " - ~r_%d", i);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
         else if (row->ptr == NULL)
         {  /* empty constraint */
            sprintf(term, " 0 %s", col_name(csa, 1, name));
            strcat(line, term);
         }
         /* right hand-side */
         if (row->type == GLP_LO)
            sprintf(term, " >= %.*g", DBL_DIG, row->lb);
         else if (row->type == GLP_UP)
            sprintf(term, " <= %.*g", DBL_DIG, row->ub);
         else if (row->type == GLP_DB || row->type == GLP_FX)
            sprintf(term, " = %.*g", DBL_DIG, row->lb);
         else
            xassert(row != row);
         if (strlen(line) + strlen(term) > 72)
            xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
         strcat(line, term);
         xfprintf(fp, "%s\n", line), count++;
      }
      xfprintf(fp, "\n"), count++;
      /* write the bounds section */
      flag = 0;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type != GLP_DB) continue;
         if (!flag)
            xfprintf(fp, "Bounds\n"), flag = 1, count++;
         xfprintf(fp, " 0 <= ~r_%d <= %.*g\n",
            i, DBL_DIG, row->ub - row->lb), count++;
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->type == GLP_LO && col->lb == 0.0) continue;
         if (!flag)
            xfprintf(fp, "Bounds\n"), flag = 1, count++;
         col_name(csa, j, name);
         if (col->type == GLP_FR)
            xfprintf(fp, " %s free\n", name), count++;
         else if (col->type == GLP_LO)
            xfprintf(fp, " %s >= %.*g\n",
               name, DBL_DIG, col->lb), count++;
         else if (col->type == GLP_UP)
            xfprintf(fp, " -Inf <= %s <= %.*g\n",
               name, DBL_DIG, col->ub), count++;
         else if (col->type == GLP_DB)
            xfprintf(fp, " %.*g <= %s <= %.*g\n",
               DBL_DIG, col->lb, name, DBL_DIG, col->ub), count++;
         else if (col->type == GLP_FX)
            xfprintf(fp, " %s = %.*g\n",
               name, DBL_DIG, col->lb), count++;
         else
            xassert(col != col);
      }
      if (flag) xfprintf(fp, "\n"), count++;
      /* write the integer section */
      flag = 0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->kind == GLP_CV) continue;
         xassert(col->kind == GLP_IV);
         if (!flag)
            xfprintf(fp, "Generals\n"), flag = 1, count++;
         xfprintf(fp, " %s\n", col_name(csa, j, name)), count++;
      }
      if (flag) xfprintf(fp, "\n"), count++;
skip: /* write the end keyword */
      xfprintf(fp, "End\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* problem data has been successfully written */
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/cpp.c0000644000175100001710000001413100000000000023603 0ustar00runnerdocker00000000000000/* cpp.c (solve critical path problem) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_cpp - solve critical path problem
*
*  SYNOPSIS
*
*  double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
*
*  DESCRIPTION
*
*  The routine glp_cpp solves the critical path problem represented in
*  the form of the project network.
*
*  The parameter G is a pointer to the graph object, which specifies
*  the project network. This graph must be acyclic. Multiple arcs are
*  allowed being considered as single arcs.
*
*  The parameter v_t specifies an offset of the field of type double
*  in the vertex data block, which contains time t[i] >= 0 needed to
*  perform corresponding job j. If v_t < 0, it is assumed that t[i] = 1
*  for all jobs.
*
*  The parameter v_es specifies an offset of the field of type double
*  in the vertex data block, to which the routine stores earliest start
*  time for corresponding job. If v_es < 0, this time is not stored.
*
*  The parameter v_ls specifies an offset of the field of type double
*  in the vertex data block, to which the routine stores latest start
*  time for corresponding job. If v_ls < 0, this time is not stored.
*
*  RETURNS
*
*  The routine glp_cpp returns the minimal project duration, that is,
*  minimal time needed to perform all jobs in the project. */

static void sorting(glp_graph *G, int list[]);

double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls)
{     glp_vertex *v;
      glp_arc *a;
      int i, j, k, nv, *list;
      double temp, total, *t, *es, *ls;
      if (v_t >= 0 && v_t > G->v_size - (int)sizeof(double))
         xerror("glp_cpp: v_t = %d; invalid offset\n", v_t);
      if (v_es >= 0 && v_es > G->v_size - (int)sizeof(double))
         xerror("glp_cpp: v_es = %d; invalid offset\n", v_es);
      if (v_ls >= 0 && v_ls > G->v_size - (int)sizeof(double))
         xerror("glp_cpp: v_ls = %d; invalid offset\n", v_ls);
      nv = G->nv;
      if (nv == 0)
      {  total = 0.0;
         goto done;
      }
      /* allocate working arrays */
      t = xcalloc(1+nv, sizeof(double));
      es = xcalloc(1+nv, sizeof(double));
      ls = xcalloc(1+nv, sizeof(double));
      list = xcalloc(1+nv, sizeof(int));
      /* retrieve job times */
      for (i = 1; i <= nv; i++)
      {  v = G->v[i];
         if (v_t >= 0)
         {  memcpy(&t[i], (char *)v->data + v_t, sizeof(double));
            if (t[i] < 0.0)
               xerror("glp_cpp: t[%d] = %g; invalid time\n", i, t[i]);
         }
         else
            t[i] = 1.0;
      }
      /* perform topological sorting to determine the list of nodes
         (jobs) such that if list[k] = i and list[kk] = j and there
         exists arc (i->j), then k < kk */
      sorting(G, list);
      /* FORWARD PASS */
      /* determine earliest start times */
      for (k = 1; k <= nv; k++)
      {  j = list[k];
         es[j] = 0.0;
         for (a = G->v[j]->in; a != NULL; a = a->h_next)
         {  i = a->tail->i;
            /* there exists arc (i->j) in the project network */
            temp = es[i] + t[i];
            if (es[j] < temp) es[j] = temp;
         }
      }
      /* determine the minimal project duration */
      total = 0.0;
      for (i = 1; i <= nv; i++)
      {  temp = es[i] + t[i];
         if (total < temp) total = temp;
      }
      /* BACKWARD PASS */
      /* determine latest start times */
      for (k = nv; k >= 1; k--)
      {  i = list[k];
         ls[i] = total - t[i];
         for (a = G->v[i]->out; a != NULL; a = a->t_next)
         {  j = a->head->i;
            /* there exists arc (i->j) in the project network */
            temp = ls[j] - t[i];
            if (ls[i] > temp) ls[i] = temp;
         }
         /* avoid possible round-off errors */
         if (ls[i] < es[i]) ls[i] = es[i];
      }
      /* store results, if necessary */
      if (v_es >= 0)
      {  for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_es, &es[i], sizeof(double));
         }
      }
      if (v_ls >= 0)
      {  for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_ls, &ls[i], sizeof(double));
         }
      }
      /* free working arrays */
      xfree(t);
      xfree(es);
      xfree(ls);
      xfree(list);
done: return total;
}

static void sorting(glp_graph *G, int list[])
{     /* perform topological sorting to determine the list of nodes
         (jobs) such that if list[k] = i and list[kk] = j and there
         exists arc (i->j), then k < kk */
      int i, k, nv, v_size, *num;
      void **save;
      nv = G->nv;
      v_size = G->v_size;
      save = xcalloc(1+nv, sizeof(void *));
      num = xcalloc(1+nv, sizeof(int));
      G->v_size = sizeof(int);
      for (i = 1; i <= nv; i++)
      {  save[i] = G->v[i]->data;
         G->v[i]->data = &num[i];
         list[i] = 0;
      }
      if (glp_top_sort(G, 0) != 0)
         xerror("glp_cpp: project network is not acyclic\n");
      G->v_size = v_size;
      for (i = 1; i <= nv; i++)
      {  G->v[i]->data = save[i];
         k = num[i];
         xassert(1 <= k && k <= nv);
         xassert(list[k] == 0);
         list[k] = i;
      }
      xfree(save);
      xfree(num);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/cpxbas.c0000644000175100001710000002132700000000000024306 0ustar00runnerdocker00000000000000/* cpxbas.c (construct Bixby's initial LP basis) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

struct var
{     /* structural variable */
      int j;
      /* ordinal number */
      double q;
      /* penalty value */
};

static int CDECL fcmp(const void *ptr1, const void *ptr2)
{     /* this routine is passed to the qsort() function */
      struct var *col1 = (void *)ptr1, *col2 = (void *)ptr2;
      if (col1->q < col2->q) return -1;
      if (col1->q > col2->q) return +1;
      return 0;
}

static int get_column(glp_prob *lp, int j, int ind[], double val[])
{     /* Bixby's algorithm assumes that the constraint matrix is scaled
         such that the maximum absolute value in every non-zero row and
         column is 1 */
      int k, len;
      double big;
      len = glp_get_mat_col(lp, j, ind, val);
      big = 0.0;
      for (k = 1; k <= len; k++)
         if (big < fabs(val[k])) big = fabs(val[k]);
      if (big == 0.0) big = 1.0;
      for (k = 1; k <= len; k++) val[k] /= big;
      return len;
}

static void cpx_basis(glp_prob *lp)
{     /* main routine */
      struct var *C, *C2, *C3, *C4;
      int m, n, i, j, jk, k, l, ll, t, n2, n3, n4, type, len, *I, *r,
         *ind;
      double alpha, gamma, cmax, temp, *v, *val;
      xprintf("Constructing initial basis...\n");
      /* determine the number of rows and columns */
      m = glp_get_num_rows(lp);
      n = glp_get_num_cols(lp);
      /* allocate working arrays */
      C = xcalloc(1+n, sizeof(struct var));
      I = xcalloc(1+m, sizeof(int));
      r = xcalloc(1+m, sizeof(int));
      v = xcalloc(1+m, sizeof(double));
      ind = xcalloc(1+m, sizeof(int));
      val = xcalloc(1+m, sizeof(double));
      /* make all auxiliary variables non-basic */
      for (i = 1; i <= m; i++)
      {  if (glp_get_row_type(lp, i) != GLP_DB)
            glp_set_row_stat(lp, i, GLP_NS);
         else if (fabs(glp_get_row_lb(lp, i)) <=
                  fabs(glp_get_row_ub(lp, i)))
            glp_set_row_stat(lp, i, GLP_NL);
         else
            glp_set_row_stat(lp, i, GLP_NU);
      }
      /* make all structural variables non-basic */
      for (j = 1; j <= n; j++)
      {  if (glp_get_col_type(lp, j) != GLP_DB)
            glp_set_col_stat(lp, j, GLP_NS);
         else if (fabs(glp_get_col_lb(lp, j)) <=
                  fabs(glp_get_col_ub(lp, j)))
            glp_set_col_stat(lp, j, GLP_NL);
         else
            glp_set_col_stat(lp, j, GLP_NU);
      }
      /* C2 is a set of free structural variables */
      n2 = 0, C2 = C + 0;
      for (j = 1; j <= n; j++)
      {  type = glp_get_col_type(lp, j);
         if (type == GLP_FR)
         {  n2++;
            C2[n2].j = j;
            C2[n2].q = 0.0;
         }
      }
      /* C3 is a set of structural variables having excatly one (lower
         or upper) bound */
      n3 = 0, C3 = C2 + n2;
      for (j = 1; j <= n; j++)
      {  type = glp_get_col_type(lp, j);
         if (type == GLP_LO)
         {  n3++;
            C3[n3].j = j;
            C3[n3].q = + glp_get_col_lb(lp, j);
         }
         else if (type == GLP_UP)
         {  n3++;
            C3[n3].j = j;
            C3[n3].q = - glp_get_col_ub(lp, j);
         }
      }
      /* C4 is a set of structural variables having both (lower and
         upper) bounds */
      n4 = 0, C4 = C3 + n3;
      for (j = 1; j <= n; j++)
      {  type = glp_get_col_type(lp, j);
         if (type == GLP_DB)
         {  n4++;
            C4[n4].j = j;
            C4[n4].q = glp_get_col_lb(lp, j) - glp_get_col_ub(lp, j);
         }
      }
      /* compute gamma = max{|c[j]|: 1 <= j <= n} */
      gamma = 0.0;
      for (j = 1; j <= n; j++)
      {  temp = fabs(glp_get_obj_coef(lp, j));
         if (gamma < temp) gamma = temp;
      }
      /* compute cmax */
      cmax = (gamma == 0.0 ? 1.0 : 1000.0 * gamma);
      /* compute final penalty for all structural variables within sets
         C2, C3, and C4 */
      switch (glp_get_obj_dir(lp))
      {  case GLP_MIN: temp = +1.0; break;
         case GLP_MAX: temp = -1.0; break;
         default: xassert(lp != lp);
      }
      for (k = 1; k <= n2+n3+n4; k++)
      {  j = C[k].j;
         C[k].q += (temp * glp_get_obj_coef(lp, j)) / cmax;
      }
      /* sort structural variables within C2, C3, and C4 in ascending
         order of penalty value */
      qsort(C2+1, n2, sizeof(struct var), fcmp);
      for (k = 1; k < n2; k++) xassert(C2[k].q <= C2[k+1].q);
      qsort(C3+1, n3, sizeof(struct var), fcmp);
      for (k = 1; k < n3; k++) xassert(C3[k].q <= C3[k+1].q);
      qsort(C4+1, n4, sizeof(struct var), fcmp);
      for (k = 1; k < n4; k++) xassert(C4[k].q <= C4[k+1].q);
      /*** STEP 1 ***/
      for (i = 1; i <= m; i++)
      {  type = glp_get_row_type(lp, i);
         if (type != GLP_FX)
         {  /* row i is either free or inequality constraint */
            glp_set_row_stat(lp, i, GLP_BS);
            I[i] = 1;
            r[i] = 1;
         }
         else
         {  /* row i is equality constraint */
            I[i] = 0;
            r[i] = 0;
         }
         v[i] = +DBL_MAX;
      }
      /*** STEP 2 ***/
      for (k = 1; k <= n2+n3+n4; k++)
      {  jk = C[k].j;
         len = get_column(lp, jk, ind, val);
         /* let alpha = max{|A[l,jk]|: r[l] = 0} and let l' be such
            that alpha = |A[l',jk]| */
         alpha = 0.0, ll = 0;
         for (t = 1; t <= len; t++)
         {  l = ind[t];
            if (r[l] == 0 && alpha < fabs(val[t]))
               alpha = fabs(val[t]), ll = l;
         }
         if (alpha >= 0.99)
         {  /* B := B union {jk} */
            glp_set_col_stat(lp, jk, GLP_BS);
            I[ll] = 1;
            v[ll] = alpha;
            /* r[l] := r[l] + 1 for all l such that |A[l,jk]| != 0 */
            for (t = 1; t <= len; t++)
            {  l = ind[t];
               if (val[t] != 0.0) r[l]++;
            }
            /* continue to the next k */
            continue;
         }
         /* if |A[l,jk]| > 0.01 * v[l] for some l, continue to the
            next k */
         for (t = 1; t <= len; t++)
         {  l = ind[t];
            if (fabs(val[t]) > 0.01 * v[l]) break;
         }
         if (t <= len) continue;
         /* otherwise, let alpha = max{|A[l,jk]|: I[l] = 0} and let l'
            be such that alpha = |A[l',jk]| */
         alpha = 0.0, ll = 0;
         for (t = 1; t <= len; t++)
         {  l = ind[t];
            if (I[l] == 0 && alpha < fabs(val[t]))
               alpha = fabs(val[t]), ll = l;
         }
         /* if alpha = 0, continue to the next k */
         if (alpha == 0.0) continue;
         /* B := B union {jk} */
         glp_set_col_stat(lp, jk, GLP_BS);
         I[ll] = 1;
         v[ll] = alpha;
         /* r[l] := r[l] + 1 for all l such that |A[l,jk]| != 0 */
         for (t = 1; t <= len; t++)
         {  l = ind[t];
            if (val[t] != 0.0) r[l]++;
         }
      }
      /*** STEP 3 ***/
      /* add an artificial variable (auxiliary variable for equality
         constraint) to cover each remaining uncovered row */
      for (i = 1; i <= m; i++)
         if (I[i] == 0) glp_set_row_stat(lp, i, GLP_BS);
      /* free working arrays */
      xfree(C);
      xfree(I);
      xfree(r);
      xfree(v);
      xfree(ind);
      xfree(val);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_cpx_basis - construct Bixby's initial LP basis
*
*  SYNOPSIS
*
*  void glp_cpx_basis(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_cpx_basis constructs an advanced initial basis for
*  the specified problem object.
*
*  The routine is based on Bixby's algorithm described in the paper:
*
*  Robert E. Bixby. Implementing the Simplex Method: The Initial Basis.
*  ORSA Journal on Computing, Vol. 4, No. 3, 1992, pp. 267-84. */

void glp_cpx_basis(glp_prob *lp)
{     if (lp->m == 0 || lp->n == 0)
         glp_std_basis(lp);
      else
         cpx_basis(lp);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/graph.c0000644000175100001710000003630700000000000024133 0ustar00runnerdocker00000000000000/* graph.c (basic graph routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "avl.h"
#include "dmp.h"
#include "env.h"
#include "glpk.h"

/* CAUTION: DO NOT CHANGE THE LIMITS BELOW */

#define NV_MAX 100000000 /* = 100*10^6 */
/* maximal number of vertices in the graph */

#define NA_MAX 500000000 /* = 500*10^6 */
/* maximal number of arcs in the graph */

/***********************************************************************
*  NAME
*
*  glp_create_graph - create graph
*
*  SYNOPSIS
*
*  glp_graph *glp_create_graph(int v_size, int a_size);
*
*  DESCRIPTION
*
*  The routine creates a new graph, which initially is empty, i.e. has
*  no vertices and arcs.
*
*  The parameter v_size specifies the size of data associated with each
*  vertex of the graph (0 to 256 bytes).
*
*  The parameter a_size specifies the size of data associated with each
*  arc of the graph (0 to 256 bytes).
*
*  RETURNS
*
*  The routine returns a pointer to the graph created. */

static void create_graph(glp_graph *G, int v_size, int a_size)
{     G->pool = dmp_create_pool();
      G->name = NULL;
      G->nv_max = 50;
      G->nv = G->na = 0;
      G->v = xcalloc(1+G->nv_max, sizeof(glp_vertex *));
      G->index = NULL;
      G->v_size = v_size;
      G->a_size = a_size;
      return;
}

glp_graph *glp_create_graph(int v_size, int a_size)
{     glp_graph *G;
      if (!(0 <= v_size && v_size <= 256))
         xerror("glp_create_graph: v_size = %d; invalid size of vertex "
            "data\n", v_size);
      if (!(0 <= a_size && a_size <= 256))
         xerror("glp_create_graph: a_size = %d; invalid size of arc dat"
            "a\n", a_size);
      G = xmalloc(sizeof(glp_graph));
      create_graph(G, v_size, a_size);
      return G;
}

/***********************************************************************
*  NAME
*
*  glp_set_graph_name - assign (change) graph name
*
*  SYNOPSIS
*
*  void glp_set_graph_name(glp_graph *G, const char *name);
*
*  DESCRIPTION
*
*  The routine glp_set_graph_name assigns a symbolic name specified by
*  the character string name (1 to 255 chars) to the graph.
*
*  If the parameter name is NULL or an empty string, the routine erases
*  the existing symbolic name of the graph. */

void glp_set_graph_name(glp_graph *G, const char *name)
{     if (G->name != NULL)
      {  dmp_free_atom(G->pool, G->name, strlen(G->name)+1);
         G->name = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int j;
         for (j = 0; name[j] != '\0'; j++)
         {  if (j == 256)
               xerror("glp_set_graph_name: graph name too long\n");
            if (iscntrl((unsigned char)name[j]))
               xerror("glp_set_graph_name: graph name contains invalid "
                  "character(s)\n");
         }
         G->name = dmp_get_atom(G->pool, strlen(name)+1);
         strcpy(G->name, name);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_add_vertices - add new vertices to graph
*
*  SYNOPSIS
*
*  int glp_add_vertices(glp_graph *G, int nadd);
*
*  DESCRIPTION
*
*  The routine glp_add_vertices adds nadd vertices to the specified
*  graph. New vertices are always added to the end of the vertex list,
*  so ordinal numbers of existing vertices remain unchanged.
*
*  Being added each new vertex is isolated (has no incident arcs).
*
*  RETURNS
*
*  The routine glp_add_vertices returns an ordinal number of the first
*  new vertex added to the graph. */

int glp_add_vertices(glp_graph *G, int nadd)
{     int i, nv_new;
      if (nadd < 1)
         xerror("glp_add_vertices: nadd = %d; invalid number of vertice"
            "s\n", nadd);
      if (nadd > NV_MAX - G->nv)
         xerror("glp_add_vertices: nadd = %d; too many vertices\n",
            nadd);
      /* determine new number of vertices */
      nv_new = G->nv + nadd;
      /* increase the room, if necessary */
      if (G->nv_max < nv_new)
      {  glp_vertex **save = G->v;
         while (G->nv_max < nv_new)
         {  G->nv_max += G->nv_max;
            xassert(G->nv_max > 0);
         }
         G->v = xcalloc(1+G->nv_max, sizeof(glp_vertex *));
         memcpy(&G->v[1], &save[1], G->nv * sizeof(glp_vertex *));
         xfree(save);
      }
      /* add new vertices to the end of the vertex list */
      for (i = G->nv+1; i <= nv_new; i++)
      {  glp_vertex *v;
         G->v[i] = v = dmp_get_atom(G->pool, sizeof(glp_vertex));
         v->i = i;
         v->name = NULL;
         v->entry = NULL;
         if (G->v_size == 0)
            v->data = NULL;
         else
         {  v->data = dmp_get_atom(G->pool, G->v_size);
            memset(v->data, 0, G->v_size);
         }
         v->temp = NULL;
         v->in = v->out = NULL;
      }
      /* set new number of vertices */
      G->nv = nv_new;
      /* return the ordinal number of the first vertex added */
      return nv_new - nadd + 1;
}

/**********************************************************************/

void glp_set_vertex_name(glp_graph *G, int i, const char *name)
{     /* assign (change) vertex name */
      glp_vertex *v;
      if (!(1 <= i && i <= G->nv))
         xerror("glp_set_vertex_name: i = %d; vertex number out of rang"
            "e\n", i);
      v = G->v[i];
      if (v->name != NULL)
      {  if (v->entry != NULL)
         {  xassert(G->index != NULL);
            avl_delete_node(G->index, v->entry);
            v->entry = NULL;
         }
         dmp_free_atom(G->pool, v->name, strlen(v->name)+1);
         v->name = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int k;
         for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_set_vertex_name: i = %d; vertex name too lon"
                  "g\n", i);
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_set_vertex_name: i = %d; vertex name contain"
                  "s invalid character(s)\n", i);
         }
         v->name = dmp_get_atom(G->pool, strlen(name)+1);
         strcpy(v->name, name);
         if (G->index != NULL)
         {  xassert(v->entry == NULL);
            v->entry = avl_insert_node(G->index, v->name);
            avl_set_node_link(v->entry, v);
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_add_arc - add new arc to graph
*
*  SYNOPSIS
*
*  glp_arc *glp_add_arc(glp_graph *G, int i, int j);
*
*  DESCRIPTION
*
*  The routine glp_add_arc adds a new arc to the specified graph.
*
*  The parameters i and j specify the ordinal numbers of, resp., tail
*  and head vertices of the arc. Note that self-loops and multiple arcs
*  are allowed.
*
*  RETURNS
*
*  The routine glp_add_arc returns a pointer to the arc added. */

glp_arc *glp_add_arc(glp_graph *G, int i, int j)
{     glp_arc *a;
      if (!(1 <= i && i <= G->nv))
         xerror("glp_add_arc: i = %d; tail vertex number out of range\n"
            , i);
      if (!(1 <= j && j <= G->nv))
         xerror("glp_add_arc: j = %d; head vertex number out of range\n"
            , j);
      if (G->na == NA_MAX)
         xerror("glp_add_arc: too many arcs\n");
      a = dmp_get_atom(G->pool, sizeof(glp_arc));
      a->tail = G->v[i];
      a->head = G->v[j];
      if (G->a_size == 0)
         a->data = NULL;
      else
      {  a->data = dmp_get_atom(G->pool, G->a_size);
         memset(a->data, 0, G->a_size);
      }
      a->temp = NULL;
      a->t_prev = NULL;
      a->t_next = G->v[i]->out;
      if (a->t_next != NULL) a->t_next->t_prev = a;
      a->h_prev = NULL;
      a->h_next = G->v[j]->in;
      if (a->h_next != NULL) a->h_next->h_prev = a;
      G->v[i]->out = G->v[j]->in = a;
      G->na++;
      return a;
}

/***********************************************************************
*  NAME
*
*  glp_del_vertices - delete vertices from graph
*
*  SYNOPSIS
*
*  void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
*
*  DESCRIPTION
*
*  The routine glp_del_vertices deletes vertices along with all
*  incident arcs from the specified graph. Ordinal numbers of vertices
*  to be deleted should be placed in locations num[1], ..., num[ndel],
*  ndel > 0.
*
*  Note that deleting vertices involves changing ordinal numbers of
*  other vertices remaining in the graph. New ordinal numbers of the
*  remaining vertices are assigned under the assumption that the
*  original order of vertices is not changed. */

void glp_del_vertices(glp_graph *G, int ndel, const int num[])
{     glp_vertex *v;
      int i, k, nv_new;
      /* scan the list of vertices to be deleted */
      if (!(1 <= ndel && ndel <= G->nv))
         xerror("glp_del_vertices: ndel = %d; invalid number of vertice"
            "s\n", ndel);
      for (k = 1; k <= ndel; k++)
      {  /* take the number of vertex to be deleted */
         i = num[k];
         /* obtain pointer to i-th vertex */
         if (!(1 <= i && i <= G->nv))
            xerror("glp_del_vertices: num[%d] = %d; vertex number out o"
               "f range\n", k, i);
         v = G->v[i];
         /* check that the vertex is not marked yet */
         if (v->i == 0)
            xerror("glp_del_vertices: num[%d] = %d; duplicate vertex nu"
               "mbers not allowed\n", k, i);
         /* erase symbolic name assigned to the vertex */
         glp_set_vertex_name(G, i, NULL);
         xassert(v->name == NULL);
         xassert(v->entry == NULL);
         /* free vertex data, if allocated */
         if (v->data != NULL)
            dmp_free_atom(G->pool, v->data, G->v_size);
         /* delete all incoming arcs */
         while (v->in != NULL)
            glp_del_arc(G, v->in);
         /* delete all outgoing arcs */
         while (v->out != NULL)
            glp_del_arc(G, v->out);
         /* mark the vertex to be deleted */
         v->i = 0;
      }
      /* delete all marked vertices from the vertex list */
      nv_new = 0;
      for (i = 1; i <= G->nv; i++)
      {  /* obtain pointer to i-th vertex */
         v = G->v[i];
         /* check if the vertex is marked */
         if (v->i == 0)
         {  /* it is marked, delete it */
            dmp_free_atom(G->pool, v, sizeof(glp_vertex));
         }
         else
         {  /* it is not marked, keep it */
            v->i = ++nv_new;
            G->v[v->i] = v;
         }
      }
      /* set new number of vertices in the graph */
      G->nv = nv_new;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_del_arc - delete arc from graph
*
*  SYNOPSIS
*
*  void glp_del_arc(glp_graph *G, glp_arc *a);
*
*  DESCRIPTION
*
*  The routine glp_del_arc deletes an arc from the specified graph.
*  The arc to be deleted must exist. */

void glp_del_arc(glp_graph *G, glp_arc *a)
{     /* some sanity checks */
      xassert(G->na > 0);
      xassert(1 <= a->tail->i && a->tail->i <= G->nv);
      xassert(a->tail == G->v[a->tail->i]);
      xassert(1 <= a->head->i && a->head->i <= G->nv);
      xassert(a->head == G->v[a->head->i]);
      /* remove the arc from the list of incoming arcs */
      if (a->h_prev == NULL)
         a->head->in = a->h_next;
      else
         a->h_prev->h_next = a->h_next;
      if (a->h_next == NULL)
         ;
      else
         a->h_next->h_prev = a->h_prev;
      /* remove the arc from the list of outgoing arcs */
      if (a->t_prev == NULL)
         a->tail->out = a->t_next;
      else
         a->t_prev->t_next = a->t_next;
      if (a->t_next == NULL)
         ;
      else
         a->t_next->t_prev = a->t_prev;
      /* free arc data, if allocated */
      if (a->data != NULL)
         dmp_free_atom(G->pool, a->data, G->a_size);
      /* delete the arc from the graph */
      dmp_free_atom(G->pool, a, sizeof(glp_arc));
      G->na--;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_erase_graph - erase graph content
*
*  SYNOPSIS
*
*  void glp_erase_graph(glp_graph *G, int v_size, int a_size);
*
*  DESCRIPTION
*
*  The routine glp_erase_graph erases the content of the specified
*  graph. The effect of this operation is the same as if the graph
*  would be deleted with the routine glp_delete_graph and then created
*  anew with the routine glp_create_graph, with exception that the
*  handle (pointer) to the graph remains valid. */

static void delete_graph(glp_graph *G)
{     dmp_delete_pool(G->pool);
      xfree(G->v);
      if (G->index != NULL) avl_delete_tree(G->index);
      return;
}

void glp_erase_graph(glp_graph *G, int v_size, int a_size)
{     if (!(0 <= v_size && v_size <= 256))
         xerror("glp_erase_graph: v_size = %d; invalid size of vertex d"
            "ata\n", v_size);
      if (!(0 <= a_size && a_size <= 256))
         xerror("glp_erase_graph: a_size = %d; invalid size of arc data"
            "\n", a_size);
      delete_graph(G);
      create_graph(G, v_size, a_size);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_delete_graph - delete graph
*
*  SYNOPSIS
*
*  void glp_delete_graph(glp_graph *G);
*
*  DESCRIPTION
*
*  The routine glp_delete_graph deletes the specified graph and frees
*  all the memory allocated to this program object. */

void glp_delete_graph(glp_graph *G)
{     delete_graph(G);
      xfree(G);
      return;
}

/**********************************************************************/

void glp_create_v_index(glp_graph *G)
{     /* create vertex name index */
      glp_vertex *v;
      int i;
      if (G->index == NULL)
      {  G->index = avl_create_tree(avl_strcmp, NULL);
         for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            xassert(v->entry == NULL);
            if (v->name != NULL)
            {  v->entry = avl_insert_node(G->index, v->name);
               avl_set_node_link(v->entry, v);
            }
         }
      }
      return;
}

int glp_find_vertex(glp_graph *G, const char *name)
{     /* find vertex by its name */
      AVLNODE *node;
      int i = 0;
      if (G->index == NULL)
         xerror("glp_find_vertex: vertex name index does not exist\n");
      if (!(name == NULL || name[0] == '\0' || strlen(name) > 255))
      {  node = avl_find_node(G->index, name);
         if (node != NULL)
            i = ((glp_vertex *)avl_get_node_link(node))->i;
      }
      return i;
}

void glp_delete_v_index(glp_graph *G)
{     /* delete vertex name index */
      int i;
      if (G->index != NULL)
      {  avl_delete_tree(G->index), G->index = NULL;
         for (i = 1; i <= G->nv; i++) G->v[i]->entry = NULL;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/gridgen.c0000644000175100001710000000100200000000000024431 0ustar00runnerdocker00000000000000/* gridgen.c */

#include "env.h"
#include "glpk.h"

int glp_gridgen(glp_graph *G_, int v_rhs_, int a_cap_, int a_cost_,
      const int parm[1+14])
{     static const char func[] = "glp_gridgen";
      xassert(G_ == G_);
      xassert(v_rhs_ == v_rhs_);
      xassert(a_cap_ == a_cap_);
      xassert(a_cost_ == a_cost_);
      xassert(parm == parm);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
      return -1;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/intfeas1.c0000644000175100001710000002323600000000000024541 0ustar00runnerdocker00000000000000/* intfeas1.c (solve integer feasibility problem) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2011-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

int glp_intfeas1(glp_prob *P, int use_bound, int obj_bound)
{     /* solve integer feasibility problem */
      NPP *npp = NULL;
      glp_prob *mip = NULL;
      int *obj_ind = NULL;
      double *obj_val = NULL;
      int obj_row = 0;
      int i, j, k, obj_len, temp, ret;
#if 0 /* 04/IV-2016 */
      /* check the problem object */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_intfeas1: P = %p; invalid problem object\n",
            P);
#endif
      if (P->tree != NULL)
         xerror("glp_intfeas1: operation not allowed\n");
      /* integer solution is currently undefined */
      P->mip_stat = GLP_UNDEF;
      P->mip_obj = 0.0;
      /* check columns (variables) */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
#if 0 /* binarization is not yet implemented */
         if (!(col->kind == GLP_IV || col->type == GLP_FX))
         {  xprintf("glp_intfeas1: column %d: non-integer non-fixed var"
               "iable not allowed\n", j);
#else
         if (!((col->kind == GLP_IV && col->lb == 0.0 && col->ub == 1.0)
            || col->type == GLP_FX))
         {  xprintf("glp_intfeas1: column %d: non-binary non-fixed vari"
               "able not allowed\n", j);
#endif
            ret = GLP_EDATA;
            goto done;
         }
         temp = (int)col->lb;
         if ((double)temp != col->lb)
         {  if (col->type == GLP_FX)
               xprintf("glp_intfeas1: column %d: fixed value %g is non-"
                  "integer or out of range\n", j, col->lb);
            else
               xprintf("glp_intfeas1: column %d: lower bound %g is non-"
                  "integer or out of range\n", j, col->lb);
            ret = GLP_EDATA;
            goto done;
         }
         temp = (int)col->ub;
         if ((double)temp != col->ub)
         {  xprintf("glp_intfeas1: column %d: upper bound %g is non-int"
               "eger or out of range\n", j, col->ub);
            ret = GLP_EDATA;
            goto done;
         }
         if (col->type == GLP_DB && col->lb > col->ub)
         {  xprintf("glp_intfeas1: column %d: lower bound %g is greater"
               " than upper bound %g\n", j, col->lb, col->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      /* check rows (constraints) */
      for (i = 1; i <= P->m; i++)
      {  GLPROW *row = P->row[i];
         GLPAIJ *aij;
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  temp = (int)aij->val;
            if ((double)temp != aij->val)
            {  xprintf("glp_intfeas1: row = %d, column %d: constraint c"
                  "oefficient %g is non-integer or out of range\n",
                  i, aij->col->j, aij->val);
               ret = GLP_EDATA;
               goto done;
            }
         }
         temp = (int)row->lb;
         if ((double)temp != row->lb)
         {  if (row->type == GLP_FX)
               xprintf("glp_intfeas1: row = %d: fixed value %g is non-i"
                  "nteger or out of range\n", i, row->lb);
            else
               xprintf("glp_intfeas1: row = %d: lower bound %g is non-i"
                  "nteger or out of range\n", i, row->lb);
            ret = GLP_EDATA;
            goto done;
         }
         temp = (int)row->ub;
         if ((double)temp != row->ub)
         {  xprintf("glp_intfeas1: row = %d: upper bound %g is non-inte"
               "ger or out of range\n", i, row->ub);
            ret = GLP_EDATA;
            goto done;
         }
         if (row->type == GLP_DB && row->lb > row->ub)
         {  xprintf("glp_intfeas1: row %d: lower bound %g is greater th"
               "an upper bound %g\n", i, row->lb, row->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      /* check the objective function */
#if 1 /* 08/I-2017 by cmatraki & mao */
      if (!use_bound)
      {  /* skip check if no obj. bound is specified */
         goto skip;
      }
#endif
      temp = (int)P->c0;
      if ((double)temp != P->c0)
      {  xprintf("glp_intfeas1: objective constant term %g is non-integ"
            "er or out of range\n", P->c0);
         ret = GLP_EDATA;
         goto done;
      }
      for (j = 1; j <= P->n; j++)
      {  temp = (int)P->col[j]->coef;
         if ((double)temp != P->col[j]->coef)
         {  xprintf("glp_intfeas1: column %d: objective coefficient is "
               "non-integer or out of range\n", j, P->col[j]->coef);
            ret = GLP_EDATA;
            goto done;
         }
      }
#if 1 /* 08/I-2017 by cmatraki & mao */
skip: ;
#endif
      /* save the objective function and set it to zero */
      obj_ind = xcalloc(1+P->n, sizeof(int));
      obj_val = xcalloc(1+P->n, sizeof(double));
      obj_len = 0;
      obj_ind[0] = 0;
      obj_val[0] = P->c0;
      P->c0 = 0.0;
      for (j = 1; j <= P->n; j++)
      {  if (P->col[j]->coef != 0.0)
         {  obj_len++;
            obj_ind[obj_len] = j;
            obj_val[obj_len] = P->col[j]->coef;
            P->col[j]->coef = 0.0;
         }
      }
      /* add inequality to bound the objective function, if required */
      if (!use_bound)
         xprintf("Will search for ANY feasible solution\n");
      else
      {  xprintf("Will search only for solution not worse than %d\n",
            obj_bound);
         obj_row = glp_add_rows(P, 1);
         glp_set_mat_row(P, obj_row, obj_len, obj_ind, obj_val);
         if (P->dir == GLP_MIN)
            glp_set_row_bnds(P, obj_row,
               GLP_UP, 0.0, (double)obj_bound - obj_val[0]);
         else if (P->dir == GLP_MAX)
            glp_set_row_bnds(P, obj_row,
               GLP_LO, (double)obj_bound - obj_val[0], 0.0);
         else
            xassert(P != P);
      }
      /* create preprocessor workspace */
      xprintf("Translating to CNF-SAT...\n");
      xprintf("Original problem has %d row%s, %d column%s, and %d non-z"
         "ero%s\n", P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" :
         "s", P->nnz, P->nnz == 1 ? "" : "s");
      npp = npp_create_wksp();
      /* load the original problem into the preprocessor workspace */
      npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
      /* perform translation to SAT-CNF problem instance */
      ret = npp_sat_encode_prob(npp);
      if (ret == 0)
         ;
      else if (ret == GLP_ENOPFS)
         xprintf("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION\n");
      else if (ret == GLP_ERANGE)
         xprintf("glp_intfeas1: translation to SAT-CNF failed because o"
            "f integer overflow\n");
      else
         xassert(ret != ret);
      if (ret != 0)
         goto done;
      /* build SAT-CNF problem instance and try to solve it */
      mip = glp_create_prob();
      npp_build_prob(npp, mip);
      ret = glp_minisat1(mip);
      /* only integer feasible solution can be postprocessed */
      if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
      {  P->mip_stat = mip->mip_stat;
         goto done;
      }
      /* postprocess the solution found */
      npp_postprocess(npp, mip);
      /* the transformed problem is no longer needed */
      glp_delete_prob(mip), mip = NULL;
      /* store solution to the original problem object */
      npp_unload_sol(npp, P);
      /* change the solution status to 'integer feasible' */
      P->mip_stat = GLP_FEAS;
      /* check integer feasibility */
      for (i = 1; i <= P->m; i++)
      {  GLPROW *row;
         GLPAIJ *aij;
         double sum;
         row = P->row[i];
         sum = 0.0;
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            sum += aij->val * aij->col->mipx;
         xassert(sum == row->mipx);
         if (row->type == GLP_LO || row->type == GLP_DB ||
             row->type == GLP_FX)
            xassert(sum >= row->lb);
         if (row->type == GLP_UP || row->type == GLP_DB ||
             row->type == GLP_FX)
            xassert(sum <= row->ub);
      }
      /* compute value of the original objective function */
      P->mip_obj = obj_val[0];
      for (k = 1; k <= obj_len; k++)
         P->mip_obj += obj_val[k] * P->col[obj_ind[k]]->mipx;
      xprintf("Objective value = %17.9e\n", P->mip_obj);
done: /* delete the transformed problem, if it exists */
      if (mip != NULL)
         glp_delete_prob(mip);
      /* delete the preprocessor workspace, if it exists */
      if (npp != NULL)
         npp_delete_wksp(npp);
      /* remove inequality used to bound the objective function */
      if (obj_row > 0)
      {  int ind[1+1];
         ind[1] = obj_row;
         glp_del_rows(P, 1, ind);
      }
      /* restore the original objective function */
      if (obj_ind != NULL)
      {  P->c0 = obj_val[0];
         for (k = 1; k <= obj_len; k++)
            P->col[obj_ind[k]]->coef = obj_val[k];
         xfree(obj_ind);
         xfree(obj_val);
      }
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/maxffalg.c0000644000175100001710000001031200000000000024603 0ustar00runnerdocker00000000000000/* maxffalg.c (find maximal flow with Ford-Fulkerson algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ffalg.h"
#include "glpk.h"

int glp_maxflow_ffalg(glp_graph *G, int s, int t, int a_cap,
      double *sol, int a_x, int v_cut)
{     /* find maximal flow with Ford-Fulkerson algorithm */
      glp_vertex *v;
      glp_arc *a;
      int nv, na, i, k, flag, *tail, *head, *cap, *x, ret;
      char *cut;
      double temp;
      if (!(1 <= s && s <= G->nv))
         xerror("glp_maxflow_ffalg: s = %d; source node number out of r"
            "ange\n", s);
      if (!(1 <= t && t <= G->nv))
         xerror("glp_maxflow_ffalg: t = %d: sink node number out of ran"
            "ge\n", t);
      if (s == t)
         xerror("glp_maxflow_ffalg: s = t = %d; source and sink nodes m"
            "ust be distinct\n", s);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_maxflow_ffalg: a_cap = %d; invalid offset\n",
            a_cap);
      if (v_cut >= 0 && v_cut > G->v_size - (int)sizeof(int))
         xerror("glp_maxflow_ffalg: v_cut = %d; invalid offset\n",
            v_cut);
      /* allocate working arrays */
      nv = G->nv;
      na = G->na;
      tail = xcalloc(1+na, sizeof(int));
      head = xcalloc(1+na, sizeof(int));
      cap = xcalloc(1+na, sizeof(int));
      x = xcalloc(1+na, sizeof(int));
      if (v_cut < 0)
         cut = NULL;
      else
         cut = xcalloc(1+nv, sizeof(char));
      /* copy the flow network */
      k = 0;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  k++;
            tail[k] = a->tail->i;
            head[k] = a->head->i;
            if (tail[k] == head[k])
            {  ret = GLP_EDATA;
               goto done;
            }
            if (a_cap >= 0)
               memcpy(&temp, (char *)a->data + a_cap, sizeof(double));
            else
               temp = 1.0;
            if (!(0.0 <= temp && temp <= (double)INT_MAX &&
                  temp == floor(temp)))
            {  ret = GLP_EDATA;
               goto done;
            }
            cap[k] = (int)temp;
         }
      }
      xassert(k == na);
      /* find maximal flow in the flow network */
      ffalg(nv, na, tail, head, s, t, cap, x, cut);
      ret = 0;
      /* store solution components */
      /* (objective function = total flow through the network) */
      if (sol != NULL)
      {  temp = 0.0;
         for (k = 1; k <= na; k++)
         {  if (tail[k] == s)
               temp += (double)x[k];
            else if (head[k] == s)
               temp -= (double)x[k];
         }
         *sol = temp;
      }
      /* (arc flows) */
      if (a_x >= 0)
      {  k = 0;
         for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            for (a = v->out; a != NULL; a = a->t_next)
            {  temp = (double)x[++k];
               memcpy((char *)a->data + a_x, &temp, sizeof(double));
            }
         }
      }
      /* (node flags) */
      if (v_cut >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            flag = cut[i];
            memcpy((char *)v->data + v_cut, &flag, sizeof(int));
         }
      }
done: /* free working arrays */
      xfree(tail);
      xfree(head);
      xfree(cap);
      xfree(x);
      if (cut != NULL) xfree(cut);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/maxflp.c0000644000175100001710000000755100000000000024320 0ustar00runnerdocker00000000000000/* maxflp.c (convert maximum flow problem to LP) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_maxflow_lp - convert maximum flow problem to LP
*
*  SYNOPSIS
*
*  void glp_maxflow_lp(glp_prob *lp, glp_graph *G, int names, int s,
*     int t, int a_cap);
*
*  DESCRIPTION
*
*  The routine glp_maxflow_lp builds an LP problem, which corresponds
*  to the maximum flow problem on the specified network G. */

void glp_maxflow_lp(glp_prob *lp, glp_graph *G, int names, int s,
      int t, int a_cap)
{     glp_vertex *v;
      glp_arc *a;
      int i, j, type, ind[1+2];
      double cap, val[1+2];
      if (!(names == GLP_ON || names == GLP_OFF))
         xerror("glp_maxflow_lp: names = %d; invalid parameter\n",
            names);
      if (!(1 <= s && s <= G->nv))
         xerror("glp_maxflow_lp: s = %d; source node number out of rang"
            "e\n", s);
      if (!(1 <= t && t <= G->nv))
         xerror("glp_maxflow_lp: t = %d: sink node number out of range "
            "\n", t);
      if (s == t)
         xerror("glp_maxflow_lp: s = t = %d; source and sink nodes must"
            " be distinct\n", s);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_maxflow_lp: a_cap = %d; invalid offset\n", a_cap);
      glp_erase_prob(lp);
      if (names) glp_set_prob_name(lp, G->name);
      glp_set_obj_dir(lp, GLP_MAX);
      glp_add_rows(lp, G->nv);
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (names) glp_set_row_name(lp, i, v->name);
         if (i == s)
            type = GLP_LO;
         else if (i == t)
            type = GLP_UP;
         else
            type = GLP_FX;
         glp_set_row_bnds(lp, i, type, 0.0, 0.0);
      }
      if (G->na > 0) glp_add_cols(lp, G->na);
      for (i = 1, j = 0; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  j++;
            if (names)
            {  char name[50+1];
               sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
               xassert(strlen(name) < sizeof(name));
               glp_set_col_name(lp, j, name);
            }
            if (a->tail->i != a->head->i)
            {  ind[1] = a->tail->i, val[1] = +1.0;
               ind[2] = a->head->i, val[2] = -1.0;
               glp_set_mat_col(lp, j, 2, ind, val);
            }
            if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = 1.0;
            if (cap == DBL_MAX)
               type = GLP_LO;
            else if (cap != 0.0)
               type = GLP_DB;
            else
               type = GLP_FX;
            glp_set_col_bnds(lp, j, type, 0.0, cap);
            if (a->tail->i == s)
               glp_set_obj_coef(lp, j, +1.0);
            else if (a->head->i == s)
               glp_set_obj_coef(lp, j, -1.0);
         }
      }
      xassert(j == G->na);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/mcflp.c0000644000175100001710000001013700000000000024124 0ustar00runnerdocker00000000000000/* mcflp.c (convert minimum cost flow problem to LP) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_mincost_lp - convert minimum cost flow problem to LP
*
*  SYNOPSIS
*
*  void glp_mincost_lp(glp_prob *lp, glp_graph *G, int names,
*     int v_rhs, int a_low, int a_cap, int a_cost);
*
*  DESCRIPTION
*
*  The routine glp_mincost_lp builds an LP problem, which corresponds
*  to the minimum cost flow problem on the specified network G. */

void glp_mincost_lp(glp_prob *lp, glp_graph *G, int names, int v_rhs,
      int a_low, int a_cap, int a_cost)
{     glp_vertex *v;
      glp_arc *a;
      int i, j, type, ind[1+2];
      double rhs, low, cap, cost, val[1+2];
      if (!(names == GLP_ON || names == GLP_OFF))
         xerror("glp_mincost_lp: names = %d; invalid parameter\n",
            names);
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_mincost_lp: v_rhs = %d; invalid offset\n", v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_lp: a_low = %d; invalid offset\n", a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_lp: a_cap = %d; invalid offset\n", a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_lp: a_cost = %d; invalid offset\n", a_cost)
            ;
      glp_erase_prob(lp);
      if (names) glp_set_prob_name(lp, G->name);
      if (G->nv > 0) glp_add_rows(lp, G->nv);
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (names) glp_set_row_name(lp, i, v->name);
         if (v_rhs >= 0)
            memcpy(&rhs, (char *)v->data + v_rhs, sizeof(double));
         else
            rhs = 0.0;
         glp_set_row_bnds(lp, i, GLP_FX, rhs, rhs);
      }
      if (G->na > 0) glp_add_cols(lp, G->na);
      for (i = 1, j = 0; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  j++;
            if (names)
            {  char name[50+1];
               sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
               xassert(strlen(name) < sizeof(name));
               glp_set_col_name(lp, j, name);
            }
            if (a->tail->i != a->head->i)
            {  ind[1] = a->tail->i, val[1] = +1.0;
               ind[2] = a->head->i, val[2] = -1.0;
               glp_set_mat_col(lp, j, 2, ind, val);
            }
            if (a_low >= 0)
               memcpy(&low, (char *)a->data + a_low, sizeof(double));
            else
               low = 0.0;
            if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = 1.0;
            if (cap == DBL_MAX)
               type = GLP_LO;
            else if (low != cap)
               type = GLP_DB;
            else
               type = GLP_FX;
            glp_set_col_bnds(lp, j, type, low, cap);
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 0.0;
            glp_set_obj_coef(lp, j, cost);
         }
      }
      xassert(j == G->na);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/mcfokalg.c0000644000175100001710000001634000000000000024610 0ustar00runnerdocker00000000000000/* mcfokalg.c (find minimum-cost flow with out-of-kilter algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "okalg.h"

int glp_mincost_okalg(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, double *sol, int a_x, int v_pi)
{     /* find minimum-cost flow with out-of-kilter algorithm */
      glp_vertex *v;
      glp_arc *a;
      int nv, na, i, k, s, t, *tail, *head, *low, *cap, *cost, *x, *pi,
         ret;
      double sum, temp;
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: v_rhs = %d; invalid offset\n",
            v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: a_low = %d; invalid offset\n",
            a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: a_cap = %d; invalid offset\n",
            a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: a_cost = %d; invalid offset\n",
            a_cost);
      if (a_x >= 0 && a_x > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: a_x = %d; invalid offset\n", a_x);
      if (v_pi >= 0 && v_pi > G->v_size - (int)sizeof(double))
         xerror("glp_mincost_okalg: v_pi = %d; invalid offset\n", v_pi);
      /* s is artificial source node */
      s = G->nv + 1;
      /* t is artificial sink node */
      t = s + 1;
      /* nv is the total number of nodes in the resulting network */
      nv = t;
      /* na is the total number of arcs in the resulting network */
      na = G->na + 1;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (v_rhs >= 0)
            memcpy(&temp, (char *)v->data + v_rhs, sizeof(double));
         else
            temp = 0.0;
         if (temp != 0.0) na++;
      }
      /* allocate working arrays */
      tail = xcalloc(1+na, sizeof(int));
      head = xcalloc(1+na, sizeof(int));
      low = xcalloc(1+na, sizeof(int));
      cap = xcalloc(1+na, sizeof(int));
      cost = xcalloc(1+na, sizeof(int));
      x = xcalloc(1+na, sizeof(int));
      pi = xcalloc(1+nv, sizeof(int));
      /* construct the resulting network */
      k = 0;
      /* (original arcs) */
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  k++;
            tail[k] = a->tail->i;
            head[k] = a->head->i;
            if (tail[k] == head[k])
            {  ret = GLP_EDATA;
               goto done;
            }
            if (a_low >= 0)
               memcpy(&temp, (char *)a->data + a_low, sizeof(double));
            else
               temp = 0.0;
            if (!(0.0 <= temp && temp <= (double)INT_MAX &&
                  temp == floor(temp)))
            {  ret = GLP_EDATA;
               goto done;
            }
            low[k] = (int)temp;
            if (a_cap >= 0)
               memcpy(&temp, (char *)a->data + a_cap, sizeof(double));
            else
               temp = 1.0;
            if (!((double)low[k] <= temp && temp <= (double)INT_MAX &&
                  temp == floor(temp)))
            {  ret = GLP_EDATA;
               goto done;
            }
            cap[k] = (int)temp;
            if (a_cost >= 0)
               memcpy(&temp, (char *)a->data + a_cost, sizeof(double));
            else
               temp = 0.0;
            if (!(fabs(temp) <= (double)INT_MAX && temp == floor(temp)))
            {  ret = GLP_EDATA;
               goto done;
            }
            cost[k] = (int)temp;
         }
      }
      /* (artificial arcs) */
      sum = 0.0;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (v_rhs >= 0)
            memcpy(&temp, (char *)v->data + v_rhs, sizeof(double));
         else
            temp = 0.0;
         if (!(fabs(temp) <= (double)INT_MAX && temp == floor(temp)))
         {  ret = GLP_EDATA;
            goto done;
         }
         if (temp > 0.0)
         {  /* artificial arc from s to original source i */
            k++;
            tail[k] = s;
            head[k] = i;
            low[k] = cap[k] = (int)(+temp); /* supply */
            cost[k] = 0;
            sum += (double)temp;
         }
         else if (temp < 0.0)
         {  /* artificial arc from original sink i to t */
            k++;
            tail[k] = i;
            head[k] = t;
            low[k] = cap[k] = (int)(-temp); /* demand */
            cost[k] = 0;
         }
      }
      /* (feedback arc from t to s) */
      k++;
      xassert(k == na);
      tail[k] = t;
      head[k] = s;
      if (sum > (double)INT_MAX)
      {  ret = GLP_EDATA;
         goto done;
      }
      low[k] = cap[k] = (int)sum; /* total supply/demand */
      cost[k] = 0;
      /* find minimal-cost circulation in the resulting network */
      ret = okalg(nv, na, tail, head, low, cap, cost, x, pi);
      switch (ret)
      {  case 0:
            /* optimal circulation found */
            ret = 0;
            break;
         case 1:
            /* no feasible circulation exists */
            ret = GLP_ENOPFS;
            break;
         case 2:
            /* integer overflow occured */
            ret = GLP_ERANGE;
            goto done;
         case 3:
            /* optimality test failed (logic error) */
            ret = GLP_EFAIL;
            goto done;
         default:
            xassert(ret != ret);
      }
      /* store solution components */
      /* (objective function = the total cost) */
      if (sol != NULL)
      {  temp = 0.0;
         for (k = 1; k <= na; k++)
            temp += (double)cost[k] * (double)x[k];
         *sol = temp;
      }
      /* (arc flows) */
      if (a_x >= 0)
      {  k = 0;
         for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            for (a = v->out; a != NULL; a = a->t_next)
            {  temp = (double)x[++k];
               memcpy((char *)a->data + a_x, &temp, sizeof(double));
            }
         }
      }
      /* (node potentials = Lagrange multipliers) */
      if (v_pi >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            temp = - (double)pi[i];
            memcpy((char *)v->data + v_pi, &temp, sizeof(double));
         }
      }
done: /* free working arrays */
      xfree(tail);
      xfree(head);
      xfree(low);
      xfree(cap);
      xfree(cost);
      xfree(x);
      xfree(pi);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/mcfrelax.c0000644000175100001710000002076000000000000024627 0ustar00runnerdocker00000000000000/* mcfrelax.c (find minimum-cost flow with RELAX-IV) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "relax4.h"

static int overflow(int u, int v)
{     /* check for integer overflow on computing u + v */
      if (u > 0 && v > 0 && u + v < 0) return 1;
      if (u < 0 && v < 0 && u + v > 0) return 1;
      return 0;
}

int glp_mincost_relax4(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, int crash, double *sol, int a_x, int a_rc)
{     /* find minimum-cost flow with Bertsekas-Tseng relaxation method
         (RELAX-IV) */
      glp_vertex *v;
      glp_arc *a;
      struct relax4_csa csa;
      int i, k, large, n, na, ret;
      double cap, cost, low, rc, rhs, sum, x;
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: v_rhs = %d; invalid offset\n",
            v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: a_low = %d; invalid offset\n",
            a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: a_cap = %d; invalid offset\n",
            a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: a_cost = %d; invalid offset\n",
            a_cost);
      if (a_x >= 0 && a_x > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: a_x = %d; invalid offset\n",
            a_x);
      if (a_rc >= 0 && a_rc > G->a_size - (int)sizeof(double))
         xerror("glp_mincost_relax4: a_rc = %d; invalid offset\n",
            a_rc);
      csa.n = n = G->nv; /* number of nodes */
      csa.na = na = G->na; /* number of arcs */
      csa.large = large = INT_MAX / 4;
      csa.repeat = 0;
      csa.crash = crash;
      /* allocate working arrays */
      csa.startn = xcalloc(1+na, sizeof(int));
      csa.endn = xcalloc(1+na, sizeof(int));
      csa.fou = xcalloc(1+n, sizeof(int));
      csa.nxtou = xcalloc(1+na, sizeof(int));
      csa.fin = xcalloc(1+n, sizeof(int));
      csa.nxtin = xcalloc(1+na, sizeof(int));
      csa.rc = xcalloc(1+na, sizeof(int));
      csa.u = xcalloc(1+na, sizeof(int));
      csa.dfct = xcalloc(1+n, sizeof(int));
      csa.x = xcalloc(1+na, sizeof(int));
      csa.label = xcalloc(1+n, sizeof(int));
      csa.prdcsr = xcalloc(1+n, sizeof(int));
      csa.save = xcalloc(1+na, sizeof(int));
      csa.tfstou = xcalloc(1+n, sizeof(int));
      csa.tnxtou = xcalloc(1+na, sizeof(int));
      csa.tfstin = xcalloc(1+n, sizeof(int));
      csa.tnxtin = xcalloc(1+na, sizeof(int));
      csa.nxtqueue = xcalloc(1+n, sizeof(int));
      csa.scan = xcalloc(1+n, sizeof(char));
      csa.mark = xcalloc(1+n, sizeof(char));
      if (crash)
      {  csa.extend_arc = xcalloc(1+n, sizeof(int));
         csa.sb_level = xcalloc(1+n, sizeof(int));
         csa.sb_arc = xcalloc(1+n, sizeof(int));
      }
      else
      {  csa.extend_arc = NULL;
         csa.sb_level = NULL;
         csa.sb_arc = NULL;
      }
      /* scan nodes */
      for (i = 1; i <= n; i++)
      {  v = G->v[i];
         /* get supply at i-th node */
         if (v_rhs >= 0)
            memcpy(&rhs, (char *)v->data + v_rhs, sizeof(double));
         else
            rhs = 0.0;
         if (!(fabs(rhs) <= (double)large && rhs == floor(rhs)))
         {  ret = GLP_EDATA;
            goto done;
         }
         /* set demand at i-th node */
         csa.dfct[i] = -(int)rhs;
      }
      /* scan arcs */
      k = 0;
      for (i = 1; i <= n; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  k++;
            /* set endpoints of k-th arc */
            if (a->tail->i == a->head->i)
            {  /* self-loops not allowed */
               ret = GLP_EDATA;
               goto done;
            }
            csa.startn[k] = a->tail->i;
            csa.endn[k] = a->head->i;
            /* set per-unit cost for k-th arc flow */
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 0.0;
            if (!(fabs(cost) <= (double)large && cost == floor(cost)))
            {  ret = GLP_EDATA;
               goto done;
            }
            csa.rc[k] = (int)cost;
            /* get lower bound for k-th arc flow */
            if (a_low >= 0)
               memcpy(&low, (char *)a->data + a_low, sizeof(double));
            else
               low = 0.0;
            if (!(0.0 <= low && low <= (double)large &&
                  low == floor(low)))
            {  ret = GLP_EDATA;
               goto done;
            }
            /* get upper bound for k-th arc flow */
            if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = 1.0;
            if (!(low <= cap && cap <= (double)large &&
                  cap == floor(cap)))
            {  ret = GLP_EDATA;
               goto done;
            }
            /* substitute x = x' + low, where 0 <= x' <= cap - low */
            csa.u[k] = (int)(cap - low);
            /* correct demands at endpoints of k-th arc */
            if (overflow(csa.dfct[a->tail->i], +low))
            {  ret = GLP_ERANGE;
               goto done;
            }
#if 0 /* 29/IX-2017 */
            csa.dfct[a->tail->i] += low;
#else
            csa.dfct[a->tail->i] += (int)low;
#endif
            if (overflow(csa.dfct[a->head->i], -low))
            {  ret = GLP_ERANGE;
               goto done;
            }
#if 0 /* 29/IX-2017 */
            csa.dfct[a->head->i] -= low;
#else
            csa.dfct[a->head->i] -= (int)low;
#endif
         }
      }
      /* construct linked list for network topology */
      relax4_inidat(&csa);
      /* find minimum-cost flow */
      ret = relax4(&csa);
      if (ret != 0)
      {  /* problem is found to be infeasible */
         xassert(1 <= ret && ret <= 8);
         ret = GLP_ENOPFS;
         goto done;
      }
      /* store solution */
      sum = 0.0;
      k = 0;
      for (i = 1; i <= n; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  k++;
            /* get lower bound for k-th arc flow */
            if (a_low >= 0)
               memcpy(&low, (char *)a->data + a_low, sizeof(double));
            else
               low = 0.0;
            /* store original flow x = x' + low thru k-th arc */
            x = (double)csa.x[k] + low;
            if (a_x >= 0)
               memcpy((char *)a->data + a_x, &x, sizeof(double));
            /* store reduced cost for k-th arc flow */
            rc = (double)csa.rc[k];
            if (a_rc >= 0)
               memcpy((char *)a->data + a_rc, &rc, sizeof(double));
            /* get per-unit cost for k-th arc flow */
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 0.0;
            /* compute the total cost */
            sum += cost * x;
         }
      }
      /* store the total cost */
      if (sol != NULL)
         *sol = sum;
done: /* free working arrays */
      xfree(csa.startn);
      xfree(csa.endn);
      xfree(csa.fou);
      xfree(csa.nxtou);
      xfree(csa.fin);
      xfree(csa.nxtin);
      xfree(csa.rc);
      xfree(csa.u);
      xfree(csa.dfct);
      xfree(csa.x);
      xfree(csa.label);
      xfree(csa.prdcsr);
      xfree(csa.save);
      xfree(csa.tfstou);
      xfree(csa.tnxtou);
      xfree(csa.tfstin);
      xfree(csa.tnxtin);
      xfree(csa.nxtqueue);
      xfree(csa.scan);
      xfree(csa.mark);
      if (crash)
      {  xfree(csa.extend_arc);
         xfree(csa.sb_level);
         xfree(csa.sb_arc);
      }
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/minisat1.c0000644000175100001710000001214200000000000024546 0ustar00runnerdocker00000000000000/* minisat1.c (driver to MiniSat solver) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2011-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "minisat.h"
#include "prob.h"

int glp_minisat1(glp_prob *P)
{     /* solve CNF-SAT problem with MiniSat solver */
      solver *s;
      GLPAIJ *aij;
      int i, j, len, ret, *ind;
      double sum;
#if 0 /* 04/IV-2016 */
      /* check problem object */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_minisat1: P = %p; invalid problem object\n",
            P);
#endif
      if (P->tree != NULL)
         xerror("glp_minisat1: operation not allowed\n");
      /* integer solution is currently undefined */
      P->mip_stat = GLP_UNDEF;
      P->mip_obj = 0.0;
      /* check that problem object encodes CNF-SAT instance */
      if (glp_check_cnfsat(P) != 0)
      {  xprintf("glp_minisat1: problem object does not encode CNF-SAT "
            "instance\n");
         ret = GLP_EDATA;
         goto done;
      }
#if 0 /* 08/I-2017 by cmatraki */
#if 1 /* 07/XI-2015 */
      if (sizeof(void *) != sizeof(int))
      {  xprintf("glp_minisat1: sorry, MiniSat solver is not supported "
            "on 64-bit platforms\n");
         ret = GLP_EFAIL;
         goto done;
      }
#endif
#else
      if (sizeof(void *) != sizeof(size_t))
      {  xprintf("glp_minisat1: sorry, MiniSat solver is not supported "
            "on this platform\n");
         ret = GLP_EFAIL;
         goto done;
      }
#endif
      /* solve CNF-SAT problem */
      xprintf("Solving CNF-SAT problem...\n");
      xprintf("Instance has %d variable%s, %d clause%s, and %d literal%"
         "s\n", P->n, P->n == 1 ? "" : "s", P->m, P->m == 1 ? "" : "s",
         P->nnz, P->nnz == 1 ? "" : "s");
      /* if CNF-SAT has no clauses, it is satisfiable */
      if (P->m == 0)
      {  P->mip_stat = GLP_OPT;
         for (j = 1; j <= P->n; j++)
            P->col[j]->mipx = 0.0;
         goto fini;
      }
      /* if CNF-SAT has an empty clause, it is unsatisfiable */
      for (i = 1; i <= P->m; i++)
      {  if (P->row[i]->ptr == NULL)
         {  P->mip_stat = GLP_NOFEAS;
            goto fini;
         }
      }
      /* prepare input data for the solver */
      s = solver_new();
      solver_setnvars(s, P->n);
      ind = xcalloc(1+P->n, sizeof(int));
      for (i = 1; i <= P->m; i++)
      {  len = 0;
         for (aij = P->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  ind[++len] = toLit(aij->col->j-1);
            if (aij->val < 0.0)
               ind[len] = lit_neg(ind[len]);
         }
         xassert(len > 0);
#if 0 /* 08/I-2017 by cmatraki */
         xassert(solver_addclause(s, &ind[1], &ind[1+len]));
#else
         if (!solver_addclause(s, &ind[1], &ind[1+len]))
         {  /* found trivial conflict */
            xfree(ind);
            solver_delete(s);
            P->mip_stat = GLP_NOFEAS;
            goto fini;
         }
#endif
      }
      xfree(ind);
      /* call the solver */
      s->verbosity = 1;
      if (solver_solve(s, 0, 0))
      {  /* instance is reported as satisfiable */
         P->mip_stat = GLP_OPT;
         /* copy solution to the problem object */
         xassert(s->model.size == P->n);
         for (j = 1; j <= P->n; j++)
         {  P->col[j]->mipx =
               s->model.ptr[j-1] == l_True ? 1.0 : 0.0;
         }
         /* compute row values */
         for (i = 1; i <= P->m; i++)
         {  sum = 0;
            for (aij = P->row[i]->ptr; aij != NULL; aij = aij->r_next)
               sum += aij->val * aij->col->mipx;
            P->row[i]->mipx = sum;
         }
         /* check integer feasibility */
         for (i = 1; i <= P->m; i++)
         {  if (P->row[i]->mipx < P->row[i]->lb)
            {  /* solution is wrong */
               P->mip_stat = GLP_UNDEF;
               break;
            }
         }
      }
      else
      {  /* instance is reported as unsatisfiable */
         P->mip_stat = GLP_NOFEAS;
      }
      solver_delete(s);
fini: /* report the instance status */
      if (P->mip_stat == GLP_OPT)
      {  xprintf("SATISFIABLE\n");
         ret = 0;
      }
      else if (P->mip_stat == GLP_NOFEAS)
      {  xprintf("UNSATISFIABLE\n");
         ret = 0;
      }
      else
      {  xprintf("glp_minisat1: solver failed\n");
         ret = GLP_EFAIL;
      }
done: return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/mpl.c0000644000175100001710000002163000000000000023613 0ustar00runnerdocker00000000000000/* mpl.c (processing model in GNU MathProg language) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"
#include "prob.h"

glp_tran *glp_mpl_alloc_wksp(void)
{     /* allocate the MathProg translator workspace */
      glp_tran *tran;
      tran = mpl_initialize();
      return tran;
}

void glp_mpl_init_rand(glp_tran *tran, int seed)
{     /* initialize pseudo-random number generator */
      if (tran->phase != 0)
         xerror("glp_mpl_init_rand: invalid call sequence\n");
      rng_init_rand(tran->rand, seed);
      return;
}

int glp_mpl_read_model(glp_tran *tran, const char *fname, int skip)
{     /* read and translate model section */
      int ret;
      if (tran->phase != 0)
         xerror("glp_mpl_read_model: invalid call sequence\n");
      ret = mpl_read_model(tran, (char *)fname, skip);
      if (ret == 1 || ret == 2)
         ret = 0;
      else if (ret == 4)
         ret = 1;
      else
         xassert(ret != ret);
      return ret;
}

int glp_mpl_read_data(glp_tran *tran, const char *fname)
{     /* read and translate data section */
      int ret;
      if (!(tran->phase == 1 || tran->phase == 2))
         xerror("glp_mpl_read_data: invalid call sequence\n");
      ret = mpl_read_data(tran, (char *)fname);
      if (ret == 2)
         ret = 0;
      else if (ret == 4)
         ret = 1;
      else
         xassert(ret != ret);
      return ret;
}

int glp_mpl_generate(glp_tran *tran, const char *fname)
{     /* generate the model */
      int ret;
      if (!(tran->phase == 1 || tran->phase == 2))
         xerror("glp_mpl_generate: invalid call sequence\n");
      ret = mpl_generate(tran, (char *)fname);
      if (ret == 3)
         ret = 0;
      else if (ret == 4)
         ret = 1;
      return ret;
}

void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob)
{     /* build LP/MIP problem instance from the model */
      int m, n, i, j, t, kind, type, len, *ind;
      double lb, ub, *val;
      if (tran->phase != 3)
         xerror("glp_mpl_build_prob: invalid call sequence\n");
      /* erase the problem object */
      glp_erase_prob(prob);
      /* set problem name */
      glp_set_prob_name(prob, mpl_get_prob_name(tran));
      /* build rows (constraints) */
      m = mpl_get_num_rows(tran);
      if (m > 0)
         glp_add_rows(prob, m);
      for (i = 1; i <= m; i++)
      {  /* set row name */
         glp_set_row_name(prob, i, mpl_get_row_name(tran, i));
         /* set row bounds */
         type = mpl_get_row_bnds(tran, i, &lb, &ub);
         switch (type)
         {  case MPL_FR: type = GLP_FR; break;
            case MPL_LO: type = GLP_LO; break;
            case MPL_UP: type = GLP_UP; break;
            case MPL_DB: type = GLP_DB; break;
            case MPL_FX: type = GLP_FX; break;
            default: xassert(type != type);
         }
         if (type == GLP_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
         {  type = GLP_FX;
            if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
         }
         glp_set_row_bnds(prob, i, type, lb, ub);
         /* warn about non-zero constant term */
         if (mpl_get_row_c0(tran, i) != 0.0)
            xprintf("glp_mpl_build_prob: row %s; constant term %.12g ig"
               "nored\n",
               mpl_get_row_name(tran, i), mpl_get_row_c0(tran, i));
      }
      /* build columns (variables) */
      n = mpl_get_num_cols(tran);
      if (n > 0)
         glp_add_cols(prob, n);
      for (j = 1; j <= n; j++)
      {  /* set column name */
         glp_set_col_name(prob, j, mpl_get_col_name(tran, j));
         /* set column kind */
         kind = mpl_get_col_kind(tran, j);
         switch (kind)
         {  case MPL_NUM:
               break;
            case MPL_INT:
            case MPL_BIN:
               glp_set_col_kind(prob, j, GLP_IV);
               break;
            default:
               xassert(kind != kind);
         }
         /* set column bounds */
         type = mpl_get_col_bnds(tran, j, &lb, &ub);
         switch (type)
         {  case MPL_FR: type = GLP_FR; break;
            case MPL_LO: type = GLP_LO; break;
            case MPL_UP: type = GLP_UP; break;
            case MPL_DB: type = GLP_DB; break;
            case MPL_FX: type = GLP_FX; break;
            default: xassert(type != type);
         }
         if (kind == MPL_BIN)
         {  if (type == GLP_FR || type == GLP_UP || lb < 0.0) lb = 0.0;
            if (type == GLP_FR || type == GLP_LO || ub > 1.0) ub = 1.0;
            type = GLP_DB;
         }
         if (type == GLP_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
         {  type = GLP_FX;
            if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
         }
         glp_set_col_bnds(prob, j, type, lb, ub);
      }
      /* load the constraint matrix */
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      for (i = 1; i <= m; i++)
      {  len = mpl_get_mat_row(tran, i, ind, val);
         glp_set_mat_row(prob, i, len, ind, val);
      }
      /* build objective function (the first objective is used) */
      for (i = 1; i <= m; i++)
      {  kind = mpl_get_row_kind(tran, i);
         if (kind == MPL_MIN || kind == MPL_MAX)
         {  /* set objective name */
            glp_set_obj_name(prob, mpl_get_row_name(tran, i));
            /* set optimization direction */
            glp_set_obj_dir(prob, kind == MPL_MIN ? GLP_MIN : GLP_MAX);
            /* set constant term */
            glp_set_obj_coef(prob, 0, mpl_get_row_c0(tran, i));
            /* set objective coefficients */
            len = mpl_get_mat_row(tran, i, ind, val);
            for (t = 1; t <= len; t++)
               glp_set_obj_coef(prob, ind[t], val[t]);
            break;
         }
      }
      /* free working arrays */
      xfree(ind);
      xfree(val);
      return;
}

int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol)
{     /* postsolve the model */
      int i, j, m, n, stat, ret;
      double prim, dual;
      if (!(tran->phase == 3 && !tran->flag_p))
         xerror("glp_mpl_postsolve: invalid call sequence\n");
      if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
         xerror("glp_mpl_postsolve: sol = %d; invalid parameter\n",
            sol);
      m = mpl_get_num_rows(tran);
      n = mpl_get_num_cols(tran);
      if (!(m == glp_get_num_rows(prob) &&
            n == glp_get_num_cols(prob)))
         xerror("glp_mpl_postsolve: wrong problem object\n");
      if (!mpl_has_solve_stmt(tran))
      {  ret = 0;
         goto done;
      }
      for (i = 1; i <= m; i++)
      {  if (sol == GLP_SOL)
         {  stat = glp_get_row_stat(prob, i);
            prim = glp_get_row_prim(prob, i);
            dual = glp_get_row_dual(prob, i);
         }
         else if (sol == GLP_IPT)
         {  stat = 0;
            prim = glp_ipt_row_prim(prob, i);
            dual = glp_ipt_row_dual(prob, i);
         }
         else if (sol == GLP_MIP)
         {  stat = 0;
            prim = glp_mip_row_val(prob, i);
            dual = 0.0;
         }
         else
            xassert(sol != sol);
         if (fabs(prim) < 1e-9) prim = 0.0;
         if (fabs(dual) < 1e-9) dual = 0.0;
         mpl_put_row_soln(tran, i, stat, prim, dual);
      }
      for (j = 1; j <= n; j++)
      {  if (sol == GLP_SOL)
         {  stat = glp_get_col_stat(prob, j);
            prim = glp_get_col_prim(prob, j);
            dual = glp_get_col_dual(prob, j);
         }
         else if (sol == GLP_IPT)
         {  stat = 0;
            prim = glp_ipt_col_prim(prob, j);
            dual = glp_ipt_col_dual(prob, j);
         }
         else if (sol == GLP_MIP)
         {  stat = 0;
            prim = glp_mip_col_val(prob, j);
            dual = 0.0;
         }
         else
            xassert(sol != sol);
         if (fabs(prim) < 1e-9) prim = 0.0;
         if (fabs(dual) < 1e-9) dual = 0.0;
         mpl_put_col_soln(tran, j, stat, prim, dual);
      }
      ret = mpl_postsolve(tran);
      if (ret == 3)
         ret = 0;
      else if (ret == 4)
         ret = 1;
done: return ret;
}

void glp_mpl_free_wksp(glp_tran *tran)
{     /* free the MathProg translator workspace */
      mpl_terminate(tran);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/mps.c0000644000175100001710000013607500000000000023634 0ustar00runnerdocker00000000000000/* mps.c (MPS format routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"
#include "prob.h"

#define xfprintf glp_format

/***********************************************************************
*  NAME
*
*  glp_init_mpscp - initialize MPS format control parameters
*
*  SYNOPSIS
*
*  void glp_init_mpscp(glp_mpscp *parm);
*
*  DESCRIPTION
*
*  The routine glp_init_mpscp initializes control parameters, which are
*  used by the MPS input/output routines glp_read_mps and glp_write_mps,
*  with default values.
*
*  Default values of the control parameters are stored in the glp_mpscp
*  structure, which the parameter parm points to. */

void glp_init_mpscp(glp_mpscp *parm)
{     parm->blank = '\0';
      parm->obj_name = NULL;
      parm->tol_mps = 1e-12;
      return;
}

static void check_parm(const char *func, const glp_mpscp *parm)
{     /* check control parameters */
      if (!(0x00 <= parm->blank && parm->blank <= 0xFF) ||
          !(parm->blank == '\0' || isprint(parm->blank)))
         xerror("%s: blank = 0x%02X; invalid parameter\n",
            func, parm->blank);
      if (!(parm->obj_name == NULL || strlen(parm->obj_name) <= 255))
         xerror("%s: obj_name = \"%.12s...\"; parameter too long\n",
            func, parm->obj_name);
      if (!(0.0 <= parm->tol_mps && parm->tol_mps < 1.0))
         xerror("%s: tol_mps = %g; invalid parameter\n",
            func, parm->tol_mps);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_read_mps - read problem data in MPS format
*
*  SYNOPSIS
*
*  int glp_read_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_mps reads problem data in MPS format from a
*  text file.
*
*  The parameter fmt specifies the version of MPS format:
*
*  GLP_MPS_DECK - fixed (ancient) MPS format;
*  GLP_MPS_FILE - free (modern) MPS format.
*
*  The parameter parm is a pointer to the structure glp_mpscp, which
*  specifies control parameters used by the routine. If parm is NULL,
*  the routine uses default settings.
*
*  The character string fname specifies a name of the text file to be
*  read.
*
*  Note that before reading data the current content of the problem
*  object is completely erased with the routine glp_erase_prob.
*
*  RETURNS
*
*  If the operation was successful, the routine glp_read_mps returns
*  zero. Otherwise, it prints an error message and returns non-zero. */

struct csa
{     /* common storage area */
      glp_prob *P;
      /* pointer to problem object */
      int deck;
      /* MPS format (0 - free, 1 - fixed) */
      const glp_mpscp *parm;
      /* pointer to control parameters */
      const char *fname;
      /* name of input MPS file */
      glp_file *fp;
      /* stream assigned to input MPS file */
      jmp_buf jump;
      /* label for go to in case of error */
      int recno;
      /* current record (card) number */
      int recpos;
      /* current record (card) position */
      int c;
      /* current character */
      int fldno;
      /* current field number */
      char field[255+1];
      /* current field content */
      int w80;
      /* warning 'record must not be longer than 80 chars' issued */
      int wef;
      /* warning 'extra fields detected beyond field 6' issued */
      int obj_row;
      /* objective row number */
      void *work1, *work2, *work3;
      /* working arrays */
};

static void error(struct csa *csa, const char *fmt, ...)
{     /* print error message and terminate processing */
      va_list arg;
      xprintf("%s:%d: ", csa->fname, csa->recno);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      longjmp(csa->jump, 1);
      /* no return */
}

static void warning(struct csa *csa, const char *fmt, ...)
{     /* print warning message and continue processing */
      va_list arg;
      xprintf("%s:%d: warning: ", csa->fname, csa->recno);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      return;
}

static void read_char(struct csa *csa)
{     /* read next character */
      int c;
      if (csa->c == '\n')
         csa->recno++, csa->recpos = 0;
      csa->recpos++;
read: c = glp_getc(csa->fp);
      if (c < 0)
      {  if (glp_ioerr(csa->fp))
            error(csa, "read error - %s\n", get_err_msg());
         else if (csa->c == '\n')
            error(csa, "unexpected end of file\n");
         else
         {  warning(csa, "missing final end of line\n");
            c = '\n';
         }
      }
      else if (c == '\n')
         ;
      else if (csa->c == '\r')
      {  c = '\r';
         goto badc;
      }
      else if (csa->deck && c == '\r')
      {  csa->c = '\r';
         goto read;
      }
      else if (c == ' ')
         ;
      else if (isspace(c))
      {  if (csa->deck)
badc:       error(csa, "in fixed MPS format white-space character 0x%02"
               "X is not allowed\n", c);
         c = ' ';
      }
      else if (iscntrl(c))
         error(csa, "invalid control character 0x%02X\n", c);
      if (csa->deck && csa->recpos == 81 && c != '\n' && csa->w80 < 1)
      {  warning(csa, "in fixed MPS format record must not be longer th"
            "an 80 characters\n");
         csa->w80++;
      }
      csa->c = c;
      return;
}

static int indicator(struct csa *csa, int name)
{     /* skip comment records and read possible indicator record */
      int ret;
      /* reset current field number */
      csa->fldno = 0;
loop: /* read the very first character of the next record */
      xassert(csa->c == '\n');
      read_char(csa);
      if (csa->c == ' ' || csa->c == '\n')
      {  /* data record */
         ret = 0;
      }
      else if (csa->c == '*')
      {  /* comment record */
         while (csa->c != '\n')
            read_char(csa);
         goto loop;
      }
      else
      {  /* indicator record */
         int len = 0;
         while (csa->c != ' ' && csa->c != '\n' && len < 12)
         {  csa->field[len++] = (char)csa->c;
            read_char(csa);
         }
         csa->field[len] = '\0';
         if (!(strcmp(csa->field, "NAME")    == 0 ||
               strcmp(csa->field, "ROWS")    == 0 ||
               strcmp(csa->field, "COLUMNS") == 0 ||
               strcmp(csa->field, "RHS")     == 0 ||
               strcmp(csa->field, "RANGES")  == 0 ||
               strcmp(csa->field, "BOUNDS")  == 0 ||
               strcmp(csa->field, "ENDATA")  == 0))
            error(csa, "invalid indicator record\n");
         if (!name)
         {  while (csa->c != '\n')
               read_char(csa);
         }
         ret = 1;
      }
      return ret;
}

static void read_field(struct csa *csa)
{     /* read next field of the current data record */
      csa->fldno++;
      if (csa->deck)
      {  /* fixed MPS format */
         int beg, end, pos;
         /* determine predefined field positions */
         if (csa->fldno == 1)
            beg = 2, end = 3;
         else if (csa->fldno == 2)
            beg = 5, end = 12;
         else if (csa->fldno == 3)
            beg = 15, end = 22;
         else if (csa->fldno == 4)
            beg = 25, end = 36;
         else if (csa->fldno == 5)
            beg = 40, end = 47;
         else if (csa->fldno == 6)
            beg = 50, end = 61;
         else
            xassert(csa != csa);
         /* skip blanks preceding the current field */
         if (csa->c != '\n')
         {  pos = csa->recpos;
            while (csa->recpos < beg)
            {  if (csa->c == ' ')
                  ;
               else if (csa->c == '\n')
                  break;
               else
                  error(csa, "in fixed MPS format positions %d-%d must "
                     "be blank\n", pos, beg-1);
               read_char(csa);
            }
         }
         /* skip possible comment beginning in the field 3 or 5 */
         if ((csa->fldno == 3 || csa->fldno == 5) && csa->c == '$')
         {  while (csa->c != '\n')
               read_char(csa);
         }
         /* read the current field */
         for (pos = beg; pos <= end; pos++)
         {  if (csa->c == '\n') break;
            csa->field[pos-beg] = (char)csa->c;
            read_char(csa);
         }
         csa->field[pos-beg] = '\0';
         strtrim(csa->field);
         /* skip blanks following the last field */
         if (csa->fldno == 6 && csa->c != '\n')
         {  while (csa->recpos <= 72)
            {  if (csa->c == ' ')
                  ;
               else if (csa->c == '\n')
                  break;
               else
                  error(csa, "in fixed MPS format positions 62-72 must "
                     "be blank\n");
               read_char(csa);
            }
            while (csa->c != '\n')
               read_char(csa);
         }
      }
      else
      {  /* free MPS format */
         int len;
         /* skip blanks preceding the current field */
         while (csa->c == ' ')
            read_char(csa);
         /* skip possible comment */
         if (csa->c == '$')
         {  while (csa->c != '\n')
               read_char(csa);
         }
         /* read the current field */
         len = 0;
         while (!(csa->c == ' ' || csa->c == '\n'))
         {  if (len == 255)
               error(csa, "length of field %d exceeds 255 characters\n",
                  csa->fldno++);
            csa->field[len++] = (char)csa->c;
            read_char(csa);
         }
         csa->field[len] = '\0';
         /* skip anything following the last field (any extra fields
            are considered to be comments) */
         if (csa->fldno == 6)
         {  while (csa->c == ' ')
               read_char(csa);
            if (csa->c != '$' && csa->c != '\n' && csa->wef < 1)
            {  warning(csa, "some extra field(s) detected beyond field "
                  "6; field(s) ignored\n");
               csa->wef++;
            }
            while (csa->c != '\n')
               read_char(csa);
         }
      }
      return;
}

static void patch_name(struct csa *csa, char *name)
{     /* process embedded blanks in symbolic name */
      int blank = csa->parm->blank;
      if (blank == '\0')
      {  /* remove emedded blanks */
         strspx(name);
      }
      else
      {  /* replace embedded blanks by specified character */
         for (; *name != '\0'; name++)
            if (*name == ' ') *name = (char)blank;
      }
      return;
}

static double read_number(struct csa *csa)
{     /* read next field and convert it to floating-point number */
      double x;
      char *s;
      /* read next field */
      read_field(csa);
      xassert(csa->fldno == 4 || csa->fldno == 6);
      if (csa->field[0] == '\0')
         error(csa, "missing numeric value in field %d\n", csa->fldno);
      /* skip initial spaces of the field */
      for (s = csa->field; *s == ' '; s++);
      /* perform conversion */
      if (str2num(s, &x) != 0)
         error(csa, "cannot convert '%s' to floating-point number\n",
            s);
      return x;
}

static void skip_field(struct csa *csa)
{     /* read and skip next field (assumed to be blank) */
      read_field(csa);
      if (csa->field[0] != '\0')
         error(csa, "field %d must be blank\n", csa->fldno);
      return;
}

static void read_name(struct csa *csa)
{     /* read NAME indicator record */
      if (!(indicator(csa, 1) && strcmp(csa->field, "NAME") == 0))
         error(csa, "missing NAME indicator record\n");
      /* this indicator record looks like a data record; simulate that
         fields 1 and 2 were read */
      csa->fldno = 2;
      /* field 3: model name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
         warning(csa, "missing model name in field 3\n");
      else
         glp_set_prob_name(csa->P, csa->field);
      /* skip anything following field 3 */
      while (csa->c != '\n')
         read_char(csa);
      return;
}

static void read_rows(struct csa *csa)
{     /* read ROWS section */
      int i, type;
loop: if (indicator(csa, 0)) goto done;
      /* field 1: row type */
      read_field(csa), strspx(csa->field);
      if (strcmp(csa->field, "N") == 0)
         type = GLP_FR;
      else if (strcmp(csa->field, "G") == 0)
         type = GLP_LO;
      else if (strcmp(csa->field, "L") == 0)
         type = GLP_UP;
      else if (strcmp(csa->field, "E") == 0)
         type = GLP_FX;
      else if (csa->field[0] == '\0')
         error(csa, "missing row type in field 1\n");
      else
         error(csa, "invalid row type in field 1\n");
      /* field 2: row name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
         error(csa, "missing row name in field 2\n");
      if (glp_find_row(csa->P, csa->field) != 0)
         error(csa, "row '%s' multiply specified\n", csa->field);
      i = glp_add_rows(csa->P, 1);
      glp_set_row_name(csa->P, i, csa->field);
      glp_set_row_bnds(csa->P, i, type, 0.0, 0.0);
      /* fields 3, 4, 5, and 6 must be blank */
      skip_field(csa);
      skip_field(csa);
      skip_field(csa);
      skip_field(csa);
      goto loop;
done: return;
}

static void read_columns(struct csa *csa)
{     /* read COLUMNS section */
      int i, j, f, len, kind = GLP_CV, *ind;
      double aij, *val;
      char name[255+1], *flag;
      /* allocate working arrays */
      csa->work1 = ind = xcalloc(1+csa->P->m, sizeof(int));
      csa->work2 = val = xcalloc(1+csa->P->m, sizeof(double));
      csa->work3 = flag = xcalloc(1+csa->P->m, sizeof(char));
      memset(&flag[1], 0, csa->P->m);
      /* no current column exists */
      j = 0, len = 0;
loop: if (indicator(csa, 0)) goto done;
      /* field 1 must be blank */
      if (csa->deck)
      {  read_field(csa);
         if (csa->field[0] != '\0')
            error(csa, "field 1 must be blank\n");
      }
      else
         csa->fldno++;
      /* field 2: column or kind name */
      read_field(csa), patch_name(csa, csa->field);
      strcpy(name, csa->field);
      /* field 3: row name or keyword 'MARKER' */
      read_field(csa), patch_name(csa, csa->field);
      if (strcmp(csa->field, "'MARKER'") == 0)
      {  /* process kind data record */
         /* field 4 must be blank */
         if (csa->deck)
         {  read_field(csa);
            if (csa->field[0] != '\0')
               error(csa, "field 4 must be blank\n");
         }
         else
            csa->fldno++;
         /* field 5: keyword 'INTORG' or 'INTEND' */
         read_field(csa), patch_name(csa, csa->field);
         if (strcmp(csa->field, "'INTORG'") == 0)
            kind = GLP_IV;
         else if (strcmp(csa->field, "'INTEND'") == 0)
            kind = GLP_CV;
         else if (csa->field[0] == '\0')
            error(csa, "missing keyword in field 5\n");
         else
            error(csa, "invalid keyword in field 5\n");
         /* field 6 must be blank */
         skip_field(csa);
         goto loop;
      }
      /* process column name specified in field 2 */
      if (name[0] == '\0')
      {  /* the same column as in previous data record */
         if (j == 0)
            error(csa, "missing column name in field 2\n");
      }
      else if (j != 0 && strcmp(name, csa->P->col[j]->name) == 0)
      {  /* the same column as in previous data record */
         xassert(j != 0);
      }
      else
      {  /* store the current column */
         if (j != 0)
         {  glp_set_mat_col(csa->P, j, len, ind, val);
            while (len > 0) flag[ind[len--]] = 0;
         }
         /* create new column */
         if (glp_find_col(csa->P, name) != 0)
            error(csa, "column '%s' multiply specified\n", name);
         j = glp_add_cols(csa->P, 1);
         glp_set_col_name(csa->P, j, name);
         glp_set_col_kind(csa->P, j, kind);
         if (kind == GLP_CV)
            glp_set_col_bnds(csa->P, j, GLP_LO, 0.0, 0.0);
         else if (kind == GLP_IV)
            glp_set_col_bnds(csa->P, j, GLP_DB, 0.0, 1.0);
         else
            xassert(kind != kind);
      }
      /* process fields 3-4 and 5-6 */
      for (f = 3; f <= 5; f += 2)
      {  /* field 3 or 5: row name */
         if (f == 3)
         {  if (csa->field[0] == '\0')
               error(csa, "missing row name in field 3\n");
         }
         else
         {  read_field(csa), patch_name(csa, csa->field);
            if (csa->field[0] == '\0')
            {  /* if field 5 is blank, field 6 also must be blank */
               skip_field(csa);
               continue;
            }
         }
         i = glp_find_row(csa->P, csa->field);
         if (i == 0)
            error(csa, "row '%s' not found\n", csa->field);
         if (flag[i])
            error(csa, "duplicate coefficient in row '%s'\n",
               csa->field);
         /* field 4 or 6: coefficient value */
         aij = read_number(csa);
         if (fabs(aij) < csa->parm->tol_mps) aij = 0.0;
         len++, ind[len] = i, val[len] = aij, flag[i] = 1;
      }
      goto loop;
done: /* store the last column */
      if (j != 0)
         glp_set_mat_col(csa->P, j, len, ind, val);
      /* free working arrays */
      xfree(ind);
      xfree(val);
      xfree(flag);
      csa->work1 = csa->work2 = csa->work3 = NULL;
      return;
}

static void read_rhs(struct csa *csa)
{     /* read RHS section */
      int i, f, v, type;
      double rhs;
      char name[255+1], *flag;
      /* allocate working array */
      csa->work3 = flag = xcalloc(1+csa->P->m, sizeof(char));
      memset(&flag[1], 0, csa->P->m);
      /* no current RHS vector exists */
      v = 0;
loop: if (indicator(csa, 0)) goto done;
      /* field 1 must be blank */
      if (csa->deck)
      {  read_field(csa);
         if (csa->field[0] != '\0')
            error(csa, "field 1 must be blank\n");
      }
      else
         csa->fldno++;
      /* field 2: RHS vector name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
      {  /* the same RHS vector as in previous data record */
         if (v == 0)
         {  warning(csa, "missing RHS vector name in field 2\n");
            goto blnk;
         }
      }
      else if (v != 0 && strcmp(csa->field, name) == 0)
      {  /* the same RHS vector as in previous data record */
         xassert(v != 0);
      }
      else
blnk: {  /* new RHS vector */
         if (v != 0)
            error(csa, "multiple RHS vectors not supported\n");
         v++;
         strcpy(name, csa->field);
      }
      /* process fields 3-4 and 5-6 */
      for (f = 3; f <= 5; f += 2)
      {  /* field 3 or 5: row name */
         read_field(csa), patch_name(csa, csa->field);
         if (csa->field[0] == '\0')
         {  if (f == 3)
               error(csa, "missing row name in field 3\n");
            else
            {  /* if field 5 is blank, field 6 also must be blank */
               skip_field(csa);
               continue;
            }
         }
         i = glp_find_row(csa->P, csa->field);
         if (i == 0)
            error(csa, "row '%s' not found\n", csa->field);
         if (flag[i])
            error(csa, "duplicate right-hand side for row '%s'\n",
               csa->field);
         /* field 4 or 6: right-hand side value */
         rhs = read_number(csa);
         if (fabs(rhs) < csa->parm->tol_mps) rhs = 0.0;
         type = csa->P->row[i]->type;
         if (type == GLP_FR)
         {  if (i == csa->obj_row)
               glp_set_obj_coef(csa->P, 0, rhs);
            else if (rhs != 0.0)
               warning(csa, "non-zero right-hand side for free row '%s'"
                  " ignored\n", csa->P->row[i]->name);
         }
         else
            glp_set_row_bnds(csa->P, i, type, rhs, rhs);
         flag[i] = 1;
      }
      goto loop;
done: /* free working array */
      xfree(flag);
      csa->work3 = NULL;
      return;
}

static void read_ranges(struct csa *csa)
{     /* read RANGES section */
      int i, f, v, type;
      double rhs, rng;
      char name[255+1], *flag;
      /* allocate working array */
      csa->work3 = flag = xcalloc(1+csa->P->m, sizeof(char));
      memset(&flag[1], 0, csa->P->m);
      /* no current RANGES vector exists */
      v = 0;
loop: if (indicator(csa, 0)) goto done;
      /* field 1 must be blank */
      if (csa->deck)
      {  read_field(csa);
         if (csa->field[0] != '\0')
            error(csa, "field 1 must be blank\n");
      }
      else
         csa->fldno++;
      /* field 2: RANGES vector name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
      {  /* the same RANGES vector as in previous data record */
         if (v == 0)
         {  warning(csa, "missing RANGES vector name in field 2\n");
            goto blnk;
         }
      }
      else if (v != 0 && strcmp(csa->field, name) == 0)
      {  /* the same RANGES vector as in previous data record */
         xassert(v != 0);
      }
      else
blnk: {  /* new RANGES vector */
         if (v != 0)
            error(csa, "multiple RANGES vectors not supported\n");
         v++;
         strcpy(name, csa->field);
      }
      /* process fields 3-4 and 5-6 */
      for (f = 3; f <= 5; f += 2)
      {  /* field 3 or 5: row name */
         read_field(csa), patch_name(csa, csa->field);
         if (csa->field[0] == '\0')
         {  if (f == 3)
               error(csa, "missing row name in field 3\n");
            else
            {  /* if field 5 is blank, field 6 also must be blank */
               skip_field(csa);
               continue;
            }
         }
         i = glp_find_row(csa->P, csa->field);
         if (i == 0)
            error(csa, "row '%s' not found\n", csa->field);
         if (flag[i])
            error(csa, "duplicate range for row '%s'\n", csa->field);
         /* field 4 or 6: range value */
         rng = read_number(csa);
         if (fabs(rng) < csa->parm->tol_mps) rng = 0.0;
         type = csa->P->row[i]->type;
         if (type == GLP_FR)
            warning(csa, "range for free row '%s' ignored\n",
               csa->P->row[i]->name);
         else if (type == GLP_LO)
         {  rhs = csa->P->row[i]->lb;
#if 0 /* 26/V-2017 by cmatraki */
            glp_set_row_bnds(csa->P, i, rhs == 0.0 ? GLP_FX : GLP_DB,
#else
            glp_set_row_bnds(csa->P, i, rng == 0.0 ? GLP_FX : GLP_DB,
#endif
               rhs, rhs + fabs(rng));
         }
         else if (type == GLP_UP)
         {  rhs = csa->P->row[i]->ub;
#if 0 /* 26/V-2017 by cmatraki */
            glp_set_row_bnds(csa->P, i, rhs == 0.0 ? GLP_FX : GLP_DB,
#else
            glp_set_row_bnds(csa->P, i, rng == 0.0 ? GLP_FX : GLP_DB,
#endif
               rhs - fabs(rng), rhs);
         }
         else if (type == GLP_FX)
         {  rhs = csa->P->row[i]->lb;
            if (rng > 0.0)
               glp_set_row_bnds(csa->P, i, GLP_DB, rhs, rhs + rng);
            else if (rng < 0.0)
               glp_set_row_bnds(csa->P, i, GLP_DB, rhs + rng, rhs);
         }
         else
            xassert(type != type);
         flag[i] = 1;
      }
      goto loop;
done: /* free working array */
      xfree(flag);
      csa->work3 = NULL;
      return;
}

static void read_bounds(struct csa *csa)
{     /* read BOUNDS section */
      GLPCOL *col;
      int j, v, mask, data;
      double bnd, lb, ub;
      char type[2+1], name[255+1], *flag;
      /* allocate working array */
      csa->work3 = flag = xcalloc(1+csa->P->n, sizeof(char));
      memset(&flag[1], 0, csa->P->n);
      /* no current BOUNDS vector exists */
      v = 0;
loop: if (indicator(csa, 0)) goto done;
      /* field 1: bound type */
      read_field(csa);
      if (strcmp(csa->field, "LO") == 0)
         mask = 0x01, data = 1;
      else if (strcmp(csa->field, "UP") == 0)
         mask = 0x10, data = 1;
      else if (strcmp(csa->field, "FX") == 0)
         mask = 0x11, data = 1;
      else if (strcmp(csa->field, "FR") == 0)
         mask = 0x11, data = 0;
      else if (strcmp(csa->field, "MI") == 0)
         mask = 0x01, data = 0;
      else if (strcmp(csa->field, "PL") == 0)
         mask = 0x10, data = 0;
      else if (strcmp(csa->field, "LI") == 0)
         mask = 0x01, data = 1;
      else if (strcmp(csa->field, "UI") == 0)
         mask = 0x10, data = 1;
      else if (strcmp(csa->field, "BV") == 0)
         mask = 0x11, data = 0;
      else if (csa->field[0] == '\0')
         error(csa, "missing bound type in field 1\n");
      else
         error(csa, "invalid bound type in field 1\n");
      strcpy(type, csa->field);
      /* field 2: BOUNDS vector name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
      {  /* the same BOUNDS vector as in previous data record */
         if (v == 0)
         {  warning(csa, "missing BOUNDS vector name in field 2\n");
            goto blnk;
         }
      }
      else if (v != 0 && strcmp(csa->field, name) == 0)
      {  /* the same BOUNDS vector as in previous data record */
         xassert(v != 0);
      }
      else
blnk: {  /* new BOUNDS vector */
         if (v != 0)
            error(csa, "multiple BOUNDS vectors not supported\n");
         v++;
         strcpy(name, csa->field);
      }
      /* field 3: column name */
      read_field(csa), patch_name(csa, csa->field);
      if (csa->field[0] == '\0')
         error(csa, "missing column name in field 3\n");
      j = glp_find_col(csa->P, csa->field);
      if (j == 0)
         error(csa, "column '%s' not found\n", csa->field);
      if ((flag[j] & mask) == 0x01)
         error(csa, "duplicate lower bound for column '%s'\n",
            csa->field);
      if ((flag[j] & mask) == 0x10)
         error(csa, "duplicate upper bound for column '%s'\n",
            csa->field);
      xassert((flag[j] & mask) == 0x00);
      /* field 4: bound value */
      if (data)
      {  bnd = read_number(csa);
         if (fabs(bnd) < csa->parm->tol_mps) bnd = 0.0;
      }
      else
         read_field(csa), bnd = 0.0;
      /* get current column bounds */
      col = csa->P->col[j];
      if (col->type == GLP_FR)
         lb = -DBL_MAX, ub = +DBL_MAX;
      else if (col->type == GLP_LO)
         lb = col->lb, ub = +DBL_MAX;
      else if (col->type == GLP_UP)
         lb = -DBL_MAX, ub = col->ub;
      else if (col->type == GLP_DB)
         lb = col->lb, ub = col->ub;
      else if (col->type == GLP_FX)
         lb = ub = col->lb;
      else
         xassert(col != col);
      /* change column bounds */
      if (strcmp(type, "LO") == 0)
         lb = bnd;
      else if (strcmp(type, "UP") == 0)
         ub = bnd;
      else if (strcmp(type, "FX") == 0)
         lb = ub = bnd;
      else if (strcmp(type, "FR") == 0)
         lb = -DBL_MAX, ub = +DBL_MAX;
      else if (strcmp(type, "MI") == 0)
         lb = -DBL_MAX;
      else if (strcmp(type, "PL") == 0)
         ub = +DBL_MAX;
      else if (strcmp(type, "LI") == 0)
      {  glp_set_col_kind(csa->P, j, GLP_IV);
         lb = ceil(bnd);
#if 1 /* 16/VII-2013 */
         /* if column upper bound has not been explicitly specified,
            take it as +inf */
         if (!(flag[j] & 0x10))
            ub = +DBL_MAX;
#endif
      }
      else if (strcmp(type, "UI") == 0)
      {  glp_set_col_kind(csa->P, j, GLP_IV);
         ub = floor(bnd);
      }
      else if (strcmp(type, "BV") == 0)
      {  glp_set_col_kind(csa->P, j, GLP_IV);
         lb = 0.0, ub = 1.0;
      }
      else
         xassert(type != type);
      /* set new column bounds */
      if (lb == -DBL_MAX && ub == +DBL_MAX)
         glp_set_col_bnds(csa->P, j, GLP_FR, lb, ub);
      else if (ub == +DBL_MAX)
         glp_set_col_bnds(csa->P, j, GLP_LO, lb, ub);
      else if (lb == -DBL_MAX)
         glp_set_col_bnds(csa->P, j, GLP_UP, lb, ub);
      else if (lb != ub)
         glp_set_col_bnds(csa->P, j, GLP_DB, lb, ub);
      else
         glp_set_col_bnds(csa->P, j, GLP_FX, lb, ub);
      flag[j] |= (char)mask;
      /* fields 5 and 6 must be blank */
      skip_field(csa);
      skip_field(csa);
      goto loop;
done: /* free working array */
      xfree(flag);
      csa->work3 = NULL;
      return;
}

int glp_read_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
      const char *fname)
{     /* read problem data in MPS format */
      glp_mpscp _parm;
      struct csa _csa, *csa = &_csa;
      int ret;
      xprintf("Reading problem data from '%s'...\n", fname);
      if (!(fmt == GLP_MPS_DECK || fmt == GLP_MPS_FILE))
         xerror("glp_read_mps: fmt = %d; invalid parameter\n", fmt);
      if (parm == NULL)
         glp_init_mpscp(&_parm), parm = &_parm;
      /* check control parameters */
      check_parm("glp_read_mps", parm);
      /* initialize common storage area */
      csa->P = P;
      csa->deck = (fmt == GLP_MPS_DECK);
      csa->parm = parm;
      csa->fname = fname;
      csa->fp = NULL;
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->recno = csa->recpos = 0;
      csa->c = '\n';
      csa->fldno = 0;
      csa->field[0] = '\0';
      csa->w80 = csa->wef = 0;
      csa->obj_row = 0;
      csa->work1 = csa->work2 = csa->work3 = NULL;
      /* erase problem object */
      glp_erase_prob(P);
      glp_create_index(P);
      /* open input MPS file */
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* read NAME indicator record */
      read_name(csa);
      if (P->name != NULL)
         xprintf("Problem: %s\n", P->name);
      /* read ROWS section */
      if (!(indicator(csa, 0) && strcmp(csa->field, "ROWS") == 0))
         error(csa, "missing ROWS indicator record\n");
      read_rows(csa);
      /* determine objective row */
      if (parm->obj_name == NULL || parm->obj_name[0] == '\0')
      {  /* use the first row of N type */
         int i;
         for (i = 1; i <= P->m; i++)
         {  if (P->row[i]->type == GLP_FR)
            {  csa->obj_row = i;
               break;
            }
         }
         if (csa->obj_row == 0)
            warning(csa, "unable to determine objective row\n");
      }
      else
      {  /* use a row with specified name */
         int i;
         for (i = 1; i <= P->m; i++)
         {  xassert(P->row[i]->name != NULL);
            if (strcmp(parm->obj_name, P->row[i]->name) == 0)
            {  csa->obj_row = i;
               break;
            }
         }
         if (csa->obj_row == 0)
            error(csa, "objective row '%s' not found\n",
               parm->obj_name);
      }
      if (csa->obj_row != 0)
      {  glp_set_obj_name(P, P->row[csa->obj_row]->name);
         xprintf("Objective: %s\n", P->obj);
      }
      /* read COLUMNS section */
      if (strcmp(csa->field, "COLUMNS") != 0)
         error(csa, "missing COLUMNS indicator record\n");
      read_columns(csa);
      /* set objective coefficients */
      if (csa->obj_row != 0)
      {  GLPAIJ *aij;
         for (aij = P->row[csa->obj_row]->ptr; aij != NULL; aij =
            aij->r_next) glp_set_obj_coef(P, aij->col->j, aij->val);
      }
      /* read optional RHS section */
      if (strcmp(csa->field, "RHS") == 0)
         read_rhs(csa);
      /* read optional RANGES section */
      if (strcmp(csa->field, "RANGES") == 0)
         read_ranges(csa);
      /* read optional BOUNDS section */
      if (strcmp(csa->field, "BOUNDS") == 0)
         read_bounds(csa);
      /* read ENDATA indicator record */
      if (strcmp(csa->field, "ENDATA") != 0)
         error(csa, "invalid use of %s indicator record\n",
            csa->field);
      /* print some statistics */
      xprintf("%d row%s, %d column%s, %d non-zero%s\n",
         P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
         P->nnz, P->nnz == 1 ? "" : "s");
      if (glp_get_num_int(P) > 0)
      {  int ni = glp_get_num_int(P);
         int nb = glp_get_num_bin(P);
         if (ni == 1)
         {  if (nb == 0)
               xprintf("One variable is integer\n");
            else
               xprintf("One variable is binary\n");
         }
         else
         {  xprintf("%d integer variables, ", ni);
            if (nb == 0)
               xprintf("none");
            else if (nb == 1)
               xprintf("one");
            else if (nb == ni)
               xprintf("all");
            else
               xprintf("%d", nb);
            xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
         }
      }
      xprintf("%d records were read\n", csa->recno);
#if 1 /* 31/III-2016 */
      /* free (unbounded) row(s) in MPS file are intended to specify
       * objective function(s), so all such rows can be removed */
#if 1 /* 08/VIII-2013 */
      /* remove free rows */
      {  int i, nrs, *num;
         num = talloc(1+P->m, int);
         nrs = 0;
         for (i = 1; i <= P->m; i++)
         {  if (P->row[i]->type == GLP_FR)
               num[++nrs] = i;
         }
         if (nrs > 0)
         {  glp_del_rows(P, nrs, num);
            if (nrs == 1)
               xprintf("One free row was removed\n");
            else
               xprintf("%d free rows were removed\n", nrs);
         }
         tfree(num);
      }
#endif
#else
      /* if objective function row is free, remove it */
      if (csa->obj_row != 0 && P->row[csa->obj_row]->type == GLP_FR)
      {  int num[1+1];
         num[1] = csa->obj_row;
         glp_del_rows(P, 1, num);
         xprintf("Free objective row was removed\n");
      }
#endif
      /* problem data has been successfully read */
      glp_delete_index(P);
      glp_sort_matrix(P);
      ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
      if (csa->work1 != NULL) xfree(csa->work1);
      if (csa->work2 != NULL) xfree(csa->work2);
      if (csa->work3 != NULL) xfree(csa->work3);
      if (ret != 0) glp_erase_prob(P);
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_write_mps - write problem data in MPS format
*
*  SYNOPSIS
*
*  int glp_write_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_mps writes problem data in MPS format to a
*  text file.
*
*  The parameter fmt specifies the version of MPS format:
*
*  GLP_MPS_DECK - fixed (ancient) MPS format;
*  GLP_MPS_FILE - free (modern) MPS format.
*
*  The parameter parm is a pointer to the structure glp_mpscp, which
*  specifies control parameters used by the routine. If parm is NULL,
*  the routine uses default settings.
*
*  The character string fname specifies a name of the text file to be
*  written.
*
*  RETURNS
*
*  If the operation was successful, the routine glp_read_mps returns
*  zero. Otherwise, it prints an error message and returns non-zero. */

#define csa csa1

struct csa
{     /* common storage area */
      glp_prob *P;
      /* pointer to problem object */
      int deck;
      /* MPS format (0 - free, 1 - fixed) */
      const glp_mpscp *parm;
      /* pointer to control parameters */
      char field[255+1];
      /* field buffer */
};

static char *mps_name(struct csa *csa)
{     /* make problem name */
      char *f;
      if (csa->P->name == NULL)
         csa->field[0] = '\0';
      else if (csa->deck)
      {  strncpy(csa->field, csa->P->name, 8);
         csa->field[8] = '\0';
      }
      else
         strcpy(csa->field, csa->P->name);
      for (f = csa->field; *f != '\0'; f++)
         if (*f == ' ') *f = '_';
      return csa->field;
}

static char *row_name(struct csa *csa, int i)
{     /* make i-th row name */
      char *f;
      xassert(0 <= i && i <= csa->P->m);
      if (i == 0 || csa->P->row[i]->name == NULL ||
          csa->deck && strlen(csa->P->row[i]->name) > 8)
         sprintf(csa->field, "R%07d", i);
      else
      {  strcpy(csa->field, csa->P->row[i]->name);
         for (f = csa->field; *f != '\0'; f++)
            if (*f == ' ') *f = '_';
      }
      return csa->field;
}

static char *col_name(struct csa *csa, int j)
{     /* make j-th column name */
      char *f;
      xassert(1 <= j && j <= csa->P->n);
      if (csa->P->col[j]->name == NULL ||
          csa->deck && strlen(csa->P->col[j]->name) > 8)
         sprintf(csa->field, "C%07d", j);
      else
      {  strcpy(csa->field, csa->P->col[j]->name);
         for (f = csa->field; *f != '\0'; f++)
            if (*f == ' ') *f = '_';
      }
      return csa->field;
}

static char *mps_numb(struct csa *csa, double val)
{     /* format floating-point number */
      int dig;
      char *exp;
      for (dig = 12; dig >= 6; dig--)
      {  if (val != 0.0 && fabs(val) < 0.002)
            sprintf(csa->field, "%.*E", dig-1, val);
         else
            sprintf(csa->field, "%.*G", dig, val);
         exp = strchr(csa->field, 'E');
         if (exp != NULL)
            sprintf(exp+1, "%d", atoi(exp+1));
         if (strlen(csa->field) <= 12) break;
      }
      xassert(strlen(csa->field) <= 12);
      return csa->field;
}

int glp_write_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
      const char *fname)
{     /* write problem data in MPS format */
      glp_mpscp _parm;
      struct csa _csa, *csa = &_csa;
      glp_file *fp;
      int out_obj, one_col = 0, empty = 0;
      int i, j, recno, marker, count, gap, ret;
      xprintf("Writing problem data to '%s'...\n", fname);
      if (!(fmt == GLP_MPS_DECK || fmt == GLP_MPS_FILE))
         xerror("glp_write_mps: fmt = %d; invalid parameter\n", fmt);
      if (parm == NULL)
         glp_init_mpscp(&_parm), parm = &_parm;
      /* check control parameters */
      check_parm("glp_write_mps", parm);
      /* initialize common storage area */
      csa->P = P;
      csa->deck = (fmt == GLP_MPS_DECK);
      csa->parm = parm;
      /* create output MPS file */
      fp = glp_open(fname, "w"), recno = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* write comment records */
      xfprintf(fp, "* %-*s%s\n", P->name == NULL ? 1 : 12, "Problem:",
         P->name == NULL ? "" : P->name), recno++;
      xfprintf(fp, "* %-12s%s\n", "Class:", glp_get_num_int(P) == 0 ?
         "LP" : "MIP"), recno++;
      xfprintf(fp, "* %-12s%d\n", "Rows:", P->m), recno++;
      if (glp_get_num_int(P) == 0)
         xfprintf(fp, "* %-12s%d\n", "Columns:", P->n), recno++;
      else
         xfprintf(fp, "* %-12s%d (%d integer, %d binary)\n",
            "Columns:", P->n, glp_get_num_int(P), glp_get_num_bin(P)),
            recno++;
      xfprintf(fp, "* %-12s%d\n", "Non-zeros:", P->nnz), recno++;
      xfprintf(fp, "* %-12s%s\n", "Format:", csa->deck ? "Fixed MPS" :
         "Free MPS"), recno++;
      xfprintf(fp, "*\n", recno++);
      /* write NAME indicator record */
      xfprintf(fp, "NAME%*s%s\n",
         P->name == NULL ? 0 : csa->deck ? 10 : 1, "", mps_name(csa)),
         recno++;
#if 1
      /* determine whether to write the objective row */
      out_obj = 1;
      for (i = 1; i <= P->m; i++)
      {  if (P->row[i]->type == GLP_FR)
         {  out_obj = 0;
            break;
         }
      }
#endif
      /* write ROWS section */
      xfprintf(fp, "ROWS\n"), recno++;
      for (i = (out_obj ? 0 : 1); i <= P->m; i++)
      {  int type;
         type = (i == 0 ? GLP_FR : P->row[i]->type);
         if (type == GLP_FR)
            type = 'N';
         else if (type == GLP_LO)
            type = 'G';
         else if (type == GLP_UP)
            type = 'L';
         else if (type == GLP_DB || type == GLP_FX)
            type = 'E';
         else
            xassert(type != type);
         xfprintf(fp, " %c%*s%s\n", type, csa->deck ? 2 : 1, "",
            row_name(csa, i)), recno++;
      }
      /* write COLUMNS section */
      xfprintf(fp, "COLUMNS\n"), recno++;
      marker = 0;
      for (j = 1; j <= P->n; j++)
      {  GLPAIJ cj, *aij;
         int kind;
         kind = P->col[j]->kind;
         if (kind == GLP_CV)
         {  if (marker % 2 == 1)
            {  /* close current integer block */
               marker++;
               xfprintf(fp, "%*sM%07d%*s'MARKER'%*s'INTEND'\n",
                  csa->deck ? 4 : 1, "", marker, csa->deck ? 2 : 1, "",
                  csa->deck ? 17 : 1, ""), recno++;
            }
         }
         else if (kind == GLP_IV)
         {  if (marker % 2 == 0)
            {  /* open new integer block */
               marker++;
               xfprintf(fp, "%*sM%07d%*s'MARKER'%*s'INTORG'\n",
                  csa->deck ? 4 : 1, "", marker, csa->deck ? 2 : 1, "",
                  csa->deck ? 17 : 1, ""), recno++;
            }
         }
         else
            xassert(kind != kind);
         if (out_obj && P->col[j]->coef != 0.0)
         {  /* make fake objective coefficient */
            aij = &cj;
            aij->row = NULL;
            aij->val = P->col[j]->coef;
            aij->c_next = P->col[j]->ptr;
         }
         else
            aij = P->col[j]->ptr;
#if 1 /* FIXME */
         if (aij == NULL)
         {  /* empty column */
            empty++;
            xfprintf(fp, "%*s%-*s", csa->deck ? 4 : 1, "",
               csa->deck ? 8 : 1, col_name(csa, j));
            /* we need a row */
            xassert(P->m > 0);
            xfprintf(fp, "%*s%-*s",
               csa->deck ? 2 : 1, "", csa->deck ? 8 : 1,
               row_name(csa, 1));
            xfprintf(fp, "%*s0%*s$ empty column\n",
               csa->deck ? 13 : 1, "", csa->deck ? 3 : 1, ""), recno++;
         }
#endif
         count = 0;
         for (aij = aij; aij != NULL; aij = aij->c_next)
         {  if (one_col || count % 2 == 0)
               xfprintf(fp, "%*s%-*s", csa->deck ? 4 : 1, "",
                  csa->deck ? 8 : 1, col_name(csa, j));
            gap = (one_col || count % 2 == 0 ? 2 : 3);
            xfprintf(fp, "%*s%-*s",
               csa->deck ? gap : 1, "", csa->deck ? 8 : 1,
               row_name(csa, aij->row == NULL ? 0 : aij->row->i));
            xfprintf(fp, "%*s%*s",
               csa->deck ? 2 : 1, "", csa->deck ? 12 : 1,
               mps_numb(csa, aij->val)), count++;
            if (one_col || count % 2 == 0)
               xfprintf(fp, "\n"), recno++;
         }
         if (!(one_col || count % 2 == 0))
            xfprintf(fp, "\n"), recno++;
      }
      if (marker % 2 == 1)
      {  /* close last integer block */
         marker++;
         xfprintf(fp, "%*sM%07d%*s'MARKER'%*s'INTEND'\n",
            csa->deck ? 4 : 1, "", marker, csa->deck ? 2 : 1, "",
            csa->deck ? 17 : 1, ""), recno++;
      }
#if 1
      if (empty > 0)
         xprintf("Warning: problem has %d empty column(s)\n", empty);
#endif
      /* write RHS section */
      xfprintf(fp, "RHS\n"), recno++;
      count = 0;
      for (i = (out_obj ? 0 : 1); i <= P->m; i++)
      {  int type;
         double rhs;
         if (i == 0)
            rhs = P->c0;
         else
         {  type = P->row[i]->type;
            if (type == GLP_FR)
               rhs = 0.0;
            else if (type == GLP_LO)
               rhs = P->row[i]->lb;
            else if (type == GLP_UP)
               rhs = P->row[i]->ub;
            else if (type == GLP_DB || type == GLP_FX)
               rhs = P->row[i]->lb;
            else
               xassert(type != type);
         }
         if (rhs != 0.0)
         {  if (one_col || count % 2 == 0)
               xfprintf(fp, "%*s%-*s", csa->deck ? 4 : 1, "",
                  csa->deck ? 8 : 1, "RHS1");
            gap = (one_col || count % 2 == 0 ? 2 : 3);
            xfprintf(fp, "%*s%-*s",
               csa->deck ? gap : 1, "", csa->deck ? 8 : 1,
               row_name(csa, i));
            xfprintf(fp, "%*s%*s",
               csa->deck ? 2 : 1, "", csa->deck ? 12 : 1,
               mps_numb(csa, rhs)), count++;
            if (one_col || count % 2 == 0)
               xfprintf(fp, "\n"), recno++;
         }
      }
      if (!(one_col || count % 2 == 0))
         xfprintf(fp, "\n"), recno++;
      /* write RANGES section */
      for (i = P->m; i >= 1; i--)
         if (P->row[i]->type == GLP_DB) break;
      if (i == 0) goto bnds;
      xfprintf(fp, "RANGES\n"), recno++;
      count = 0;
      for (i = 1; i <= P->m; i++)
      {  if (P->row[i]->type == GLP_DB)
         {  if (one_col || count % 2 == 0)
               xfprintf(fp, "%*s%-*s", csa->deck ? 4 : 1, "",
                  csa->deck ? 8 : 1, "RNG1");
            gap = (one_col || count % 2 == 0 ? 2 : 3);
            xfprintf(fp, "%*s%-*s",
               csa->deck ? gap : 1, "", csa->deck ? 8 : 1,
               row_name(csa, i));
            xfprintf(fp, "%*s%*s",
               csa->deck ? 2 : 1, "", csa->deck ? 12 : 1,
               mps_numb(csa, P->row[i]->ub - P->row[i]->lb)), count++;
            if (one_col || count % 2 == 0)
               xfprintf(fp, "\n"), recno++;
         }
      }
      if (!(one_col || count % 2 == 0))
         xfprintf(fp, "\n"), recno++;
bnds: /* write BOUNDS section */
      for (j = P->n; j >= 1; j--)
         if (!(P->col[j]->kind == GLP_CV &&
               P->col[j]->type == GLP_LO && P->col[j]->lb == 0.0))
            break;
      if (j == 0) goto endt;
      xfprintf(fp, "BOUNDS\n"), recno++;
      for (j = 1; j <= P->n; j++)
      {  int type, data[2];
         double bnd[2];
         char *spec[2];
         spec[0] = spec[1] = NULL;
         type = P->col[j]->type;
         if (type == GLP_FR)
            spec[0] = "FR", data[0] = 0;
         else if (type == GLP_LO)
         {  if (P->col[j]->lb != 0.0)
               spec[0] = "LO", data[0] = 1, bnd[0] = P->col[j]->lb;
            if (P->col[j]->kind == GLP_IV)
               spec[1] = "PL", data[1] = 0;
         }
         else if (type == GLP_UP)
         {  spec[0] = "MI", data[0] = 0;
            spec[1] = "UP", data[1] = 1, bnd[1] = P->col[j]->ub;
         }
         else if (type == GLP_DB)
         {  if (P->col[j]->lb != 0.0)
               spec[0] = "LO", data[0] = 1, bnd[0] = P->col[j]->lb;
            spec[1] = "UP", data[1] = 1, bnd[1] = P->col[j]->ub;
         }
         else if (type == GLP_FX)
            spec[0] = "FX", data[0] = 1, bnd[0] = P->col[j]->lb;
         else
            xassert(type != type);
         for (i = 0; i <= 1; i++)
         {  if (spec[i] != NULL)
            {  xfprintf(fp, " %s %-*s%*s%-*s", spec[i],
                  csa->deck ? 8 : 1, "BND1", csa->deck ? 2 : 1, "",
                  csa->deck ? 8 : 1, col_name(csa, j));
               if (data[i])
                  xfprintf(fp, "%*s%*s", csa->deck ? 2 : 1, "",
                     csa->deck ? 12 : 1, mps_numb(csa, bnd[i]));
               xfprintf(fp, "\n"), recno++;
            }
         }
      }
endt: /* write ENDATA indicator record */
      xfprintf(fp, "ENDATA\n"), recno++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* problem data has been successfully written */
      xprintf("%d records were written\n", recno);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/netgen.c0000644000175100001710000000077700000000000024314 0ustar00runnerdocker00000000000000/* netgen.c */

#include "env.h"
#include "glpk.h"

int glp_netgen(glp_graph *G_, int v_rhs_, int a_cap_, int a_cost_,
      const int parm[1+15])
{     static const char func[] = "glp_netgen";
      xassert(G_ == G_);
      xassert(v_rhs_ == v_rhs_);
      xassert(a_cap_ == a_cap_);
      xassert(a_cost_ == a_cost_);
      xassert(parm == parm);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
      return -1;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/npp.c0000644000175100001710000001230100000000000023613 0ustar00runnerdocker00000000000000/* npp.c (LP/MIP preprocessing) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

glp_prep *glp_npp_alloc_wksp(void)
{     /* allocate the preprocessor workspace */
      glp_prep *prep;
      prep = npp_create_wksp();
      return prep;
}

void glp_npp_load_prob(glp_prep *prep, glp_prob *P, int sol, int names)
{     /* load original problem instance */
      if (prep->sol != 0)
         xerror("glp_npp_load_prob: invalid call sequence (original ins"
            "tance already loaded)\n");
      if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
         xerror("glp_npp_load_prob: sol = %d; invalid parameter\n",
            sol);
      if (!(names == GLP_ON || names == GLP_OFF))
         xerror("glp_npp_load_prob: names = %d; invalid parameter\n",
            names);
      npp_load_prob(prep, P, names, sol, GLP_OFF);
      return;
}

int glp_npp_preprocess1(glp_prep *prep, int hard)
{     /* perform basic LP/MIP preprocessing */
      if (prep->sol == 0)
         xerror("glp_npp_preprocess1: invalid call sequence (original i"
            "nstance not loaded yet)\n");
      if (prep->pool == NULL)
         xerror("glp_npp_preprocess1: invalid call sequence (preprocess"
            "ing already finished)\n");
      if (!(hard == GLP_ON || hard == GLP_OFF))
         xerror("glp_npp_preprocess1: hard = %d; invalid parameter\n",
            hard);
      return npp_process_prob(prep, hard);
}

void glp_npp_build_prob(glp_prep *prep, glp_prob *Q)
{     /* build resultant problem instance */
      if (prep->sol == 0)
         xerror("glp_npp_build_prob: invalid call sequence (original in"
            "stance not loaded yet)\n");
      if (prep->pool == NULL)
         xerror("glp_npp_build_prob: invalid call sequence (resultant i"
            "nstance already built)\n");
      npp_build_prob(prep, Q);
      return;
}

void glp_npp_postprocess(glp_prep *prep, glp_prob *Q)
{     /* postprocess solution to resultant problem */
      if (prep->pool != NULL)
         xerror("glp_npp_postprocess: invalid call sequence (resultant "
            "instance not built yet)\n");
      if (!(prep->m == Q->m && prep->n == Q->n && prep->nnz == Q->nnz))
         xerror("glp_npp_postprocess: resultant instance mismatch\n");
      switch (prep->sol)
      {  case GLP_SOL:
            if (glp_get_status(Q) != GLP_OPT)
               xerror("glp_npp_postprocess: unable to recover non-optim"
                  "al basic solution\n");
            break;
         case GLP_IPT:
            if (glp_ipt_status(Q) != GLP_OPT)
               xerror("glp_npp_postprocess: unable to recover non-optim"
                  "al interior-point solution\n");
            break;
         case GLP_MIP:
            if (!(glp_mip_status(Q) == GLP_OPT || glp_mip_status(Q) ==
               GLP_FEAS))
               xerror("glp_npp_postprocess: unable to recover integer n"
                  "on-feasible solution\n");
            break;
         default:
            xassert(prep != prep);
      }
      npp_postprocess(prep, Q);
      return;
}

void glp_npp_obtain_sol(glp_prep *prep, glp_prob *P)
{     /* obtain solution to original problem */
      if (prep->pool != NULL)
         xerror("glp_npp_obtain_sol: invalid call sequence (resultant i"
            "nstance not built yet)\n");
      switch (prep->sol)
      {  case GLP_SOL:
            if (prep->p_stat == 0 || prep->d_stat == 0)
               xerror("glp_npp_obtain_sol: invalid call sequence (basic"
                  " solution not provided yet)\n");
            break;
         case GLP_IPT:
            if (prep->t_stat == 0)
               xerror("glp_npp_obtain_sol: invalid call sequence (inter"
                  "ior-point solution not provided yet)\n");
            break;
         case GLP_MIP:
            if (prep->i_stat == 0)
               xerror("glp_npp_obtain_sol: invalid call sequence (MIP s"
                  "olution not provided yet)\n");
            break;
         default:
            xassert(prep != prep);
      }
      if (!(prep->orig_dir == P->dir && prep->orig_m == P->m &&
            prep->orig_n == P->n && prep->orig_nnz == P->nnz))
         xerror("glp_npp_obtain_sol: original instance mismatch\n");
      npp_unload_sol(prep, P);
      return;
}

void glp_npp_free_wksp(glp_prep *prep)
{     /* free the preprocessor workspace */
      npp_delete_wksp(prep);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/pript.c0000644000175100001710000001653300000000000024167 0ustar00runnerdocker00000000000000/* pript.c (write interior-point solution in printable format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf glp_format

int glp_print_ipt(glp_prob *P, const char *fname)
{     /* write interior-point solution in printable format */
      glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, t, ae_ind, re_ind, ret;
      double ae_max, re_max;
      xprintf("Writing interior-point solution to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "%-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name);
      xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
      xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
      xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
      t = glp_ipt_status(P);
      xfprintf(fp, "%-12s%s\n", "Status:",
         t == GLP_OPT    ? "OPTIMAL" :
         t == GLP_UNDEF  ? "UNDEFINED" :
         t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
         t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" : "???");
      xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->ipt_obj,
         P->dir == GLP_MIN ? "MINimum" :
         P->dir == GLP_MAX ? "MAXimum" : "???");
      xfprintf(fp, "\n");
      xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
         " Upper bound    Marginal\n");
      xfprintf(fp, "------ ------------    ------------- ------------- "
         "------------- -------------\n");
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         xfprintf(fp, "%6d ", i);
         if (row->name == NULL || strlen(row->name) <= 12)
            xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
         else
            xfprintf(fp, "%s\n%20s", row->name, "");
         xfprintf(fp, "%3s", "");
         xfprintf(fp, "%13.6g ",
            fabs(row->pval) <= 1e-9 ? 0.0 : row->pval);
         if (row->type == GLP_LO || row->type == GLP_DB ||
             row->type == GLP_FX)
            xfprintf(fp, "%13.6g ", row->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (row->type == GLP_UP || row->type == GLP_DB)
            xfprintf(fp, "%13.6g ", row->ub);
         else
            xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
         if (fabs(row->dval) <= 1e-9)
            xfprintf(fp, "%13s", "< eps");
         else
            xfprintf(fp, "%13.6g ", row->dval);
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "   No. Column name       Activity     Lower bound  "
         " Upper bound    Marginal\n");
      xfprintf(fp, "------ ------------    ------------- ------------- "
         "------------- -------------\n");
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         xfprintf(fp, "%6d ", j);
         if (col->name == NULL || strlen(col->name) <= 12)
            xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
         else
            xfprintf(fp, "%s\n%20s", col->name, "");
         xfprintf(fp, "%3s", "");
         xfprintf(fp, "%13.6g ",
            fabs(col->pval) <= 1e-9 ? 0.0 : col->pval);
         if (col->type == GLP_LO || col->type == GLP_DB ||
             col->type == GLP_FX)
            xfprintf(fp, "%13.6g ", col->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (col->type == GLP_UP || col->type == GLP_DB)
            xfprintf(fp, "%13.6g ", col->ub);
         else
            xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
         if (fabs(col->dval) <= 1e-9)
            xfprintf(fp, "%13s", "< eps");
         else
            xfprintf(fp, "%13.6g ", col->dval);
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_IPT, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
         ae_max, ae_ind);
      xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
         re_max, re_ind);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_IPT, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
            ae_max, ae_ind <= P->m ? "row" : "column",
            ae_ind <= P->m ? ae_ind : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
            re_max, re_ind <= P->m ? "row" : "column",
            re_ind <= P->m ? re_ind : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
            "E");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_IPT, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
         ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on column %d\n",
         re_max, re_ind == 0 ? 0 : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_IPT, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
            ae_max, ae_ind <= P->m ? "row" : "column",
            ae_ind <= P->m ? ae_ind : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
            re_max, re_ind <= P->m ? "row" : "column",
            re_ind <= P->m ? re_ind : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
            ;
      xfprintf(fp, "\n");
      xfprintf(fp, "End of output\n");
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prmip.c0000644000175100001710000001366100000000000024157 0ustar00runnerdocker00000000000000/* prmip.c (write MIP solution in printable format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf glp_format

int glp_print_mip(glp_prob *P, const char *fname)
{     /* write MIP solution in printable format */
      glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, t, ae_ind, re_ind, ret;
      double ae_max, re_max;
      xprintf("Writing MIP solution to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "%-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name);
      xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
      xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
         P->n, glp_get_num_int(P), glp_get_num_bin(P));
      xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
      t = glp_mip_status(P);
      xfprintf(fp, "%-12s%s\n", "Status:",
         t == GLP_OPT    ? "INTEGER OPTIMAL" :
         t == GLP_FEAS   ? "INTEGER NON-OPTIMAL" :
         t == GLP_NOFEAS ? "INTEGER EMPTY" :
         t == GLP_UNDEF  ? "INTEGER UNDEFINED" : "???");
      xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->mip_obj,
         P->dir == GLP_MIN ? "MINimum" :
         P->dir == GLP_MAX ? "MAXimum" : "???");
      xfprintf(fp, "\n");
      xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
         " Upper bound\n");
      xfprintf(fp, "------ ------------    ------------- ------------- "
         "-------------\n");
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         xfprintf(fp, "%6d ", i);
         if (row->name == NULL || strlen(row->name) <= 12)
            xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
         else
            xfprintf(fp, "%s\n%20s", row->name, "");
         xfprintf(fp, "%3s", "");
         xfprintf(fp, "%13.6g ",
            fabs(row->mipx) <= 1e-9 ? 0.0 : row->mipx);
         if (row->type == GLP_LO || row->type == GLP_DB ||
             row->type == GLP_FX)
            xfprintf(fp, "%13.6g ", row->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (row->type == GLP_UP || row->type == GLP_DB)
            xfprintf(fp, "%13.6g ", row->ub);
         else
            xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "   No. Column name       Activity     Lower bound  "
         " Upper bound\n");
      xfprintf(fp, "------ ------------    ------------- ------------- "
         "-------------\n");
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         xfprintf(fp, "%6d ", j);
         if (col->name == NULL || strlen(col->name) <= 12)
            xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
         else
            xfprintf(fp, "%s\n%20s", col->name, "");
         xfprintf(fp, "%s  ",
            col->kind == GLP_CV ? " " :
            col->kind == GLP_IV ? "*" : "?");
         xfprintf(fp, "%13.6g ",
            fabs(col->mipx) <= 1e-9 ? 0.0 : col->mipx);
         if (col->type == GLP_LO || col->type == GLP_DB ||
             col->type == GLP_FX)
            xfprintf(fp, "%13.6g ", col->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (col->type == GLP_UP || col->type == GLP_DB)
            xfprintf(fp, "%13.6g ", col->ub);
         else
            xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "Integer feasibility conditions:\n");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
         ae_max, ae_ind);
      xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
         re_max, re_ind);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "SOLUTION IS WRONG");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
            ae_max, ae_ind <= P->m ? "row" : "column",
            ae_ind <= P->m ? ae_ind : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
            re_max, re_ind <= P->m ? "row" : "column",
            re_ind <= P->m ? re_ind : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "SOLUTION IS INFEASIBLE");
      xfprintf(fp, "\n");
      xfprintf(fp, "End of output\n");
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob.h0000644000175100001710000002562700000000000024004 0ustar00runnerdocker00000000000000/* prob.h (LP/MIP problem object) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef PROB_H
#define PROB_H

#include "avl.h"
#include "bfd.h"
#include "dmp.h"
#if 1 /* 28/III-2016 */
#define GLP_UNDOC 1
#endif
#include "glpk.h"

typedef struct GLPROW GLPROW;
typedef struct GLPCOL GLPCOL;
typedef struct GLPAIJ GLPAIJ;

#if 0 /* 04/IV-2016 */
#define GLP_PROB_MAGIC 0xD7D9D6C2
#endif

struct glp_prob
{     /* LP/MIP problem object */
#if 0 /* 04/IV-2016 */
      unsigned magic;
      /* magic value used for debugging */
#endif
      DMP *pool;
      /* memory pool to store problem object components */
      glp_tree *tree;
      /* pointer to the search tree; set by the MIP solver when this
         object is used in the tree as a core MIP object */
#if 0 /* 08/III-2014 */
      void *parms;
      /* reserved for backward compatibility */
#endif
      /*--------------------------------------------------------------*/
      /* LP/MIP data */
      char *name;
      /* problem name (1 to 255 chars); NULL means no name is assigned
         to the problem */
      char *obj;
      /* objective function name (1 to 255 chars); NULL means no name
         is assigned to the objective function */
      int dir;
      /* optimization direction flag (objective "sense"):
         GLP_MIN - minimization
         GLP_MAX - maximization */
      double c0;
      /* constant term of the objective function ("shift") */
      int m_max;
      /* length of the array of rows (enlarged automatically) */
      int n_max;
      /* length of the array of columns (enlarged automatically) */
      int m;
      /* number of rows, 0 <= m <= m_max */
      int n;
      /* number of columns, 0 <= n <= n_max */
      int nnz;
      /* number of non-zero constraint coefficients, nnz >= 0 */
      GLPROW **row; /* GLPROW *row[1+m_max]; */
      /* row[i], 1 <= i <= m, is a pointer to i-th row */
      GLPCOL **col; /* GLPCOL *col[1+n_max]; */
      /* col[j], 1 <= j <= n, is a pointer to j-th column */
      AVL *r_tree;
      /* row index to find rows by their names; NULL means this index
         does not exist */
      AVL *c_tree;
      /* column index to find columns by their names; NULL means this
         index does not exist */
      /*--------------------------------------------------------------*/
      /* basis factorization (LP) */
      int valid;
      /* the factorization is valid only if this flag is set */
      int *head; /* int head[1+m_max]; */
      /* basis header (valid only if the factorization is valid);
         head[i] = k is the ordinal number of auxiliary (1 <= k <= m)
         or structural (m+1 <= k <= m+n) variable which corresponds to
         i-th basic variable xB[i], 1 <= i <= m */
#if 0 /* 08/III-2014 */
      glp_bfcp *bfcp;
      /* basis factorization control parameters; may be NULL */
#endif
      BFD *bfd; /* BFD bfd[1:m,1:m]; */
      /* basis factorization driver; may be NULL */
      /*--------------------------------------------------------------*/
      /* basic solution (LP) */
      int pbs_stat;
      /* primal basic solution status:
         GLP_UNDEF  - primal solution is undefined
         GLP_FEAS   - primal solution is feasible
         GLP_INFEAS - primal solution is infeasible
         GLP_NOFEAS - no primal feasible solution exists */
      int dbs_stat;
      /* dual basic solution status:
         GLP_UNDEF  - dual solution is undefined
         GLP_FEAS   - dual solution is feasible
         GLP_INFEAS - dual solution is infeasible
         GLP_NOFEAS - no dual feasible solution exists */
      double obj_val;
      /* objective function value */
      int it_cnt;
      /* simplex method iteration count; increases by one on performing
         one simplex iteration */
      int some;
      /* ordinal number of some auxiliary or structural variable having
         certain property, 0 <= some <= m+n */
      /*--------------------------------------------------------------*/
      /* interior-point solution (LP) */
      int ipt_stat;
      /* interior-point solution status:
         GLP_UNDEF  - interior solution is undefined
         GLP_OPT    - interior solution is optimal
         GLP_INFEAS - interior solution is infeasible
         GLP_NOFEAS - no feasible solution exists */
      double ipt_obj;
      /* objective function value */
      /*--------------------------------------------------------------*/
      /* integer solution (MIP) */
      int mip_stat;
      /* integer solution status:
         GLP_UNDEF  - integer solution is undefined
         GLP_OPT    - integer solution is optimal
         GLP_FEAS   - integer solution is feasible
         GLP_NOFEAS - no integer solution exists */
      double mip_obj;
      /* objective function value */
};

struct GLPROW
{     /* LP/MIP row (auxiliary variable) */
      int i;
      /* ordinal number (1 to m) assigned to this row */
      char *name;
      /* row name (1 to 255 chars); NULL means no name is assigned to
         this row */
      AVLNODE *node;
      /* pointer to corresponding node in the row index; NULL means
         that either the row index does not exist or this row has no
         name assigned */
#if 1 /* 20/IX-2008 */
      int level;
      unsigned char origin;
      unsigned char klass;
#endif
      int type;
      /* type of the auxiliary variable:
         GLP_FR - free variable
         GLP_LO - variable with lower bound
         GLP_UP - variable with upper bound
         GLP_DB - double-bounded variable
         GLP_FX - fixed variable */
      double lb; /* non-scaled */
      /* lower bound; if the row has no lower bound, lb is zero */
      double ub; /* non-scaled */
      /* upper bound; if the row has no upper bound, ub is zero */
      /* if the row type is GLP_FX, ub is equal to lb */
      GLPAIJ *ptr; /* non-scaled */
      /* pointer to doubly linked list of constraint coefficients which
         are placed in this row */
      double rii;
      /* diagonal element r[i,i] of scaling matrix R for this row;
         if the scaling is not used, r[i,i] is 1 */
      int stat;
      /* status of the auxiliary variable:
         GLP_BS - basic variable
         GLP_NL - non-basic variable on lower bound
         GLP_NU - non-basic variable on upper bound
         GLP_NF - non-basic free variable
         GLP_NS - non-basic fixed variable */
      int bind;
      /* if the auxiliary variable is basic, head[bind] refers to this
         row, otherwise, bind is 0; this attribute is valid only if the
         basis factorization is valid */
      double prim; /* non-scaled */
      /* primal value of the auxiliary variable in basic solution */
      double dual; /* non-scaled */
      /* dual value of the auxiliary variable in basic solution */
      double pval; /* non-scaled */
      /* primal value of the auxiliary variable in interior solution */
      double dval; /* non-scaled */
      /* dual value of the auxiliary variable in interior solution */
      double mipx; /* non-scaled */
      /* primal value of the auxiliary variable in integer solution */
};

struct GLPCOL
{     /* LP/MIP column (structural variable) */
      int j;
      /* ordinal number (1 to n) assigned to this column */
      char *name;
      /* column name (1 to 255 chars); NULL means no name is assigned
         to this column */
      AVLNODE *node;
      /* pointer to corresponding node in the column index; NULL means
         that either the column index does not exist or the column has
         no name assigned */
      int kind;
      /* kind of the structural variable:
         GLP_CV - continuous variable
         GLP_IV - integer or binary variable */
      int type;
      /* type of the structural variable:
         GLP_FR - free variable
         GLP_LO - variable with lower bound
         GLP_UP - variable with upper bound
         GLP_DB - double-bounded variable
         GLP_FX - fixed variable */
      double lb; /* non-scaled */
      /* lower bound; if the column has no lower bound, lb is zero */
      double ub; /* non-scaled */
      /* upper bound; if the column has no upper bound, ub is zero */
      /* if the column type is GLP_FX, ub is equal to lb */
      double coef; /* non-scaled */
      /* objective coefficient at the structural variable */
      GLPAIJ *ptr; /* non-scaled */
      /* pointer to doubly linked list of constraint coefficients which
         are placed in this column */
      double sjj;
      /* diagonal element s[j,j] of scaling matrix S for this column;
         if the scaling is not used, s[j,j] is 1 */
      int stat;
      /* status of the structural variable:
         GLP_BS - basic variable
         GLP_NL - non-basic variable on lower bound
         GLP_NU - non-basic variable on upper bound
         GLP_NF - non-basic free variable
         GLP_NS - non-basic fixed variable */
      int bind;
      /* if the structural variable is basic, head[bind] refers to
         this column; otherwise, bind is 0; this attribute is valid only
         if the basis factorization is valid */
      double prim; /* non-scaled */
      /* primal value of the structural variable in basic solution */
      double dual; /* non-scaled */
      /* dual value of the structural variable in basic solution */
      double pval; /* non-scaled */
      /* primal value of the structural variable in interior solution */
      double dval; /* non-scaled */
      /* dual value of the structural variable in interior solution */
      double mipx; /* non-scaled */
      /* primal value of the structural variable in integer solution */
};

struct GLPAIJ
{     /* constraint coefficient a[i,j] */
      GLPROW *row;
      /* pointer to row, where this coefficient is placed */
      GLPCOL *col;
      /* pointer to column, where this coefficient is placed */
      double val;
      /* numeric (non-zero) value of this coefficient */
      GLPAIJ *r_prev;
      /* pointer to previous coefficient in the same row */
      GLPAIJ *r_next;
      /* pointer to next coefficient in the same row */
      GLPAIJ *c_prev;
      /* pointer to previous coefficient in the same column */
      GLPAIJ *c_next;
      /* pointer to next coefficient in the same column */
};

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob1.c0000644000175100001710000014742400000000000024060 0ustar00runnerdocker00000000000000/* prob1.c (problem creating and modifying routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/* CAUTION: DO NOT CHANGE THE LIMITS BELOW */

#define M_MAX 100000000 /* = 100*10^6 */
/* maximal number of rows in the problem object */

#define N_MAX 100000000 /* = 100*10^6 */
/* maximal number of columns in the problem object */

#define NNZ_MAX 500000000 /* = 500*10^6 */
/* maximal number of constraint coefficients in the problem object */

/***********************************************************************
*  NAME
*
*  glp_create_prob - create problem object
*
*  SYNOPSIS
*
*  glp_prob *glp_create_prob(void);
*
*  DESCRIPTION
*
*  The routine glp_create_prob creates a new problem object, which is
*  initially "empty", i.e. has no rows and columns.
*
*  RETURNS
*
*  The routine returns a pointer to the object created, which should be
*  used in any subsequent operations on this object. */

static void create_prob(glp_prob *lp)
#if 0 /* 04/IV-2016 */
{     lp->magic = GLP_PROB_MAGIC;
#else
{
#endif
      lp->pool = dmp_create_pool();
#if 0 /* 08/III-2014 */
#if 0 /* 17/XI-2009 */
      lp->cps = xmalloc(sizeof(struct LPXCPS));
      lpx_reset_parms(lp);
#else
      lp->parms = NULL;
#endif
#endif
      lp->tree = NULL;
#if 0
      lp->lwa = 0;
      lp->cwa = NULL;
#endif
      /* LP/MIP data */
      lp->name = NULL;
      lp->obj = NULL;
      lp->dir = GLP_MIN;
      lp->c0 = 0.0;
      lp->m_max = 100;
      lp->n_max = 200;
      lp->m = lp->n = 0;
      lp->nnz = 0;
      lp->row = xcalloc(1+lp->m_max, sizeof(GLPROW *));
      lp->col = xcalloc(1+lp->n_max, sizeof(GLPCOL *));
      lp->r_tree = lp->c_tree = NULL;
      /* basis factorization */
      lp->valid = 0;
      lp->head = xcalloc(1+lp->m_max, sizeof(int));
#if 0 /* 08/III-2014 */
      lp->bfcp = NULL;
#endif
      lp->bfd = NULL;
      /* basic solution (LP) */
      lp->pbs_stat = lp->dbs_stat = GLP_UNDEF;
      lp->obj_val = 0.0;
      lp->it_cnt = 0;
      lp->some = 0;
      /* interior-point solution (LP) */
      lp->ipt_stat = GLP_UNDEF;
      lp->ipt_obj = 0.0;
      /* integer solution (MIP) */
      lp->mip_stat = GLP_UNDEF;
      lp->mip_obj = 0.0;
      return;
}

glp_prob *glp_create_prob(void)
{     glp_prob *lp;
      lp = xmalloc(sizeof(glp_prob));
      create_prob(lp);
      return lp;
}

/***********************************************************************
*  NAME
*
*  glp_set_prob_name - assign (change) problem name
*
*  SYNOPSIS
*
*  void glp_set_prob_name(glp_prob *lp, const char *name);
*
*  DESCRIPTION
*
*  The routine glp_set_prob_name assigns a given symbolic name (1 up to
*  255 characters) to the specified problem object.
*
*  If the parameter name is NULL or empty string, the routine erases an
*  existing symbolic name of the problem object. */

void glp_set_prob_name(glp_prob *lp, const char *name)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_prob_name: operation not allowed\n");
      if (lp->name != NULL)
      {  dmp_free_atom(lp->pool, lp->name, strlen(lp->name)+1);
         lp->name = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int k;
         for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_set_prob_name: problem name too long\n");
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_set_prob_name: problem name contains invalid"
                  " character(s)\n");
         }
         lp->name = dmp_get_atom(lp->pool, strlen(name)+1);
         strcpy(lp->name, name);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_obj_name - assign (change) objective function name
*
*  SYNOPSIS
*
*  void glp_set_obj_name(glp_prob *lp, const char *name);
*
*  DESCRIPTION
*
*  The routine glp_set_obj_name assigns a given symbolic name (1 up to
*  255 characters) to the objective function of the specified problem
*  object.
*
*  If the parameter name is NULL or empty string, the routine erases an
*  existing name of the objective function. */

void glp_set_obj_name(glp_prob *lp, const char *name)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_obj_name: operation not allowed\n");
     if (lp->obj != NULL)
      {  dmp_free_atom(lp->pool, lp->obj, strlen(lp->obj)+1);
         lp->obj = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int k;
         for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_set_obj_name: objective name too long\n");
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_set_obj_name: objective name contains invali"
                  "d character(s)\n");
         }
         lp->obj = dmp_get_atom(lp->pool, strlen(name)+1);
         strcpy(lp->obj, name);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_obj_dir - set (change) optimization direction flag
*
*  SYNOPSIS
*
*  void glp_set_obj_dir(glp_prob *lp, int dir);
*
*  DESCRIPTION
*
*  The routine glp_set_obj_dir sets (changes) optimization direction
*  flag (i.e. "sense" of the objective function) as specified by the
*  parameter dir:
*
*  GLP_MIN - minimization;
*  GLP_MAX - maximization. */

void glp_set_obj_dir(glp_prob *lp, int dir)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_obj_dir: operation not allowed\n");
     if (!(dir == GLP_MIN || dir == GLP_MAX))
         xerror("glp_set_obj_dir: dir = %d; invalid direction flag\n",
            dir);
      lp->dir = dir;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_add_rows - add new rows to problem object
*
*  SYNOPSIS
*
*  int glp_add_rows(glp_prob *lp, int nrs);
*
*  DESCRIPTION
*
*  The routine glp_add_rows adds nrs rows (constraints) to the specified
*  problem object. New rows are always added to the end of the row list,
*  so the ordinal numbers of existing rows remain unchanged.
*
*  Being added each new row is initially free (unbounded) and has empty
*  list of the constraint coefficients.
*
*  RETURNS
*
*  The routine glp_add_rows returns the ordinal number of the first new
*  row added to the problem object. */

int glp_add_rows(glp_prob *lp, int nrs)
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      int m_new, i;
      /* determine new number of rows */
      if (nrs < 1)
         xerror("glp_add_rows: nrs = %d; invalid number of rows\n",
            nrs);
      if (nrs > M_MAX - lp->m)
         xerror("glp_add_rows: nrs = %d; too many rows\n", nrs);
      m_new = lp->m + nrs;
      /* increase the room, if necessary */
      if (lp->m_max < m_new)
      {  GLPROW **save = lp->row;
         while (lp->m_max < m_new)
         {  lp->m_max += lp->m_max;
            xassert(lp->m_max > 0);
         }
         lp->row = xcalloc(1+lp->m_max, sizeof(GLPROW *));
         memcpy(&lp->row[1], &save[1], lp->m * sizeof(GLPROW *));
         xfree(save);
         /* do not forget about the basis header */
         xfree(lp->head);
         lp->head = xcalloc(1+lp->m_max, sizeof(int));
      }
      /* add new rows to the end of the row list */
      for (i = lp->m+1; i <= m_new; i++)
      {  /* create row descriptor */
         lp->row[i] = row = dmp_get_atom(lp->pool, sizeof(GLPROW));
         row->i = i;
         row->name = NULL;
         row->node = NULL;
#if 1 /* 20/IX-2008 */
         row->level = 0;
         row->origin = 0;
         row->klass = 0;
         if (tree != NULL)
         {  switch (tree->reason)
            {  case 0:
                  break;
               case GLP_IROWGEN:
                  xassert(tree->curr != NULL);
                  row->level = tree->curr->level;
                  row->origin = GLP_RF_LAZY;
                  break;
               case GLP_ICUTGEN:
                  xassert(tree->curr != NULL);
                  row->level = tree->curr->level;
                  row->origin = GLP_RF_CUT;
                  break;
               default:
                  xassert(tree != tree);
            }
         }
#endif
         row->type = GLP_FR;
         row->lb = row->ub = 0.0;
         row->ptr = NULL;
         row->rii = 1.0;
         row->stat = GLP_BS;
#if 0
         row->bind = -1;
#else
         row->bind = 0;
#endif
         row->prim = row->dual = 0.0;
         row->pval = row->dval = 0.0;
         row->mipx = 0.0;
      }
      /* set new number of rows */
      lp->m = m_new;
      /* invalidate the basis factorization */
      lp->valid = 0;
#if 1
      if (tree != NULL && tree->reason != 0) tree->reopt = 1;
#endif
      /* return the ordinal number of the first row added */
      return m_new - nrs + 1;
}

/***********************************************************************
*  NAME
*
*  glp_add_cols - add new columns to problem object
*
*  SYNOPSIS
*
*  int glp_add_cols(glp_prob *lp, int ncs);
*
*  DESCRIPTION
*
*  The routine glp_add_cols adds ncs columns (structural variables) to
*  the specified problem object. New columns are always added to the end
*  of the column list, so the ordinal numbers of existing columns remain
*  unchanged.
*
*  Being added each new column is initially fixed at zero and has empty
*  list of the constraint coefficients.
*
*  RETURNS
*
*  The routine glp_add_cols returns the ordinal number of the first new
*  column added to the problem object. */

int glp_add_cols(glp_prob *lp, int ncs)
{     glp_tree *tree = lp->tree;
      GLPCOL *col;
      int n_new, j;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_add_cols: operation not allowed\n");
      /* determine new number of columns */
      if (ncs < 1)
         xerror("glp_add_cols: ncs = %d; invalid number of columns\n",
            ncs);
      if (ncs > N_MAX - lp->n)
         xerror("glp_add_cols: ncs = %d; too many columns\n", ncs);
      n_new = lp->n + ncs;
      /* increase the room, if necessary */
      if (lp->n_max < n_new)
      {  GLPCOL **save = lp->col;
         while (lp->n_max < n_new)
         {  lp->n_max += lp->n_max;
            xassert(lp->n_max > 0);
         }
         lp->col = xcalloc(1+lp->n_max, sizeof(GLPCOL *));
         memcpy(&lp->col[1], &save[1], lp->n * sizeof(GLPCOL *));
         xfree(save);
      }
      /* add new columns to the end of the column list */
      for (j = lp->n+1; j <= n_new; j++)
      {  /* create column descriptor */
         lp->col[j] = col = dmp_get_atom(lp->pool, sizeof(GLPCOL));
         col->j = j;
         col->name = NULL;
         col->node = NULL;
         col->kind = GLP_CV;
         col->type = GLP_FX;
         col->lb = col->ub = 0.0;
         col->coef = 0.0;
         col->ptr = NULL;
         col->sjj = 1.0;
         col->stat = GLP_NS;
#if 0
         col->bind = -1;
#else
         col->bind = 0; /* the basis may remain valid */
#endif
         col->prim = col->dual = 0.0;
         col->pval = col->dval = 0.0;
         col->mipx = 0.0;
      }
      /* set new number of columns */
      lp->n = n_new;
      /* return the ordinal number of the first column added */
      return n_new - ncs + 1;
}

/***********************************************************************
*  NAME
*
*  glp_set_row_name - assign (change) row name
*
*  SYNOPSIS
*
*  void glp_set_row_name(glp_prob *lp, int i, const char *name);
*
*  DESCRIPTION
*
*  The routine glp_set_row_name assigns a given symbolic name (1 up to
*  255 characters) to i-th row (auxiliary variable) of the specified
*  problem object.
*
*  If the parameter name is NULL or empty string, the routine erases an
*  existing name of i-th row. */

void glp_set_row_name(glp_prob *lp, int i, const char *name)
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_set_row_name: i = %d; row number out of range\n",
            i);
      row = lp->row[i];
      if (tree != NULL && tree->reason != 0)
      {  xassert(tree->curr != NULL);
         xassert(row->level == tree->curr->level);
      }
      if (row->name != NULL)
      {  if (row->node != NULL)
         {  xassert(lp->r_tree != NULL);
            avl_delete_node(lp->r_tree, row->node);
            row->node = NULL;
         }
         dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
         row->name = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int k;
         for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_set_row_name: i = %d; row name too long\n",
                  i);
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_set_row_name: i = %d: row name contains inva"
                  "lid character(s)\n", i);
         }
         row->name = dmp_get_atom(lp->pool, strlen(name)+1);
         strcpy(row->name, name);
         if (lp->r_tree != NULL)
         {  xassert(row->node == NULL);
            row->node = avl_insert_node(lp->r_tree, row->name);
            avl_set_node_link(row->node, row);
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_col_name - assign (change) column name
*
*  SYNOPSIS
*
*  void glp_set_col_name(glp_prob *lp, int j, const char *name);
*
*  DESCRIPTION
*
*  The routine glp_set_col_name assigns a given symbolic name (1 up to
*  255 characters) to j-th column (structural variable) of the specified
*  problem object.
*
*  If the parameter name is NULL or empty string, the routine erases an
*  existing name of j-th column. */

void glp_set_col_name(glp_prob *lp, int j, const char *name)
{     glp_tree *tree = lp->tree;
      GLPCOL *col;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_col_name: operation not allowed\n");
      if (!(1 <= j && j <= lp->n))
         xerror("glp_set_col_name: j = %d; column number out of range\n"
            , j);
      col = lp->col[j];
      if (col->name != NULL)
      {  if (col->node != NULL)
         {  xassert(lp->c_tree != NULL);
            avl_delete_node(lp->c_tree, col->node);
            col->node = NULL;
         }
         dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
         col->name = NULL;
      }
      if (!(name == NULL || name[0] == '\0'))
      {  int k;
         for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_set_col_name: j = %d; column name too long\n"
                  , j);
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_set_col_name: j = %d: column name contains i"
                  "nvalid character(s)\n", j);
         }
         col->name = dmp_get_atom(lp->pool, strlen(name)+1);
         strcpy(col->name, name);
         if (lp->c_tree != NULL && col->name != NULL)
         {  xassert(col->node == NULL);
            col->node = avl_insert_node(lp->c_tree, col->name);
            avl_set_node_link(col->node, col);
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_row_bnds - set (change) row bounds
*
*  SYNOPSIS
*
*  void glp_set_row_bnds(glp_prob *lp, int i, int type, double lb,
*     double ub);
*
*  DESCRIPTION
*
*  The routine glp_set_row_bnds sets (changes) the type and bounds of
*  i-th row (auxiliary variable) of the specified problem object.
*
*  Parameters type, lb, and ub specify the type, lower bound, and upper
*  bound, respectively, as follows:
*
*     Type           Bounds        Comments
*     ------------------------------------------------------
*     GLP_FR   -inf <  x <  +inf   Free variable
*     GLP_LO     lb <= x <  +inf   Variable with lower bound
*     GLP_UP   -inf <  x <=  ub    Variable with upper bound
*     GLP_DB     lb <= x <=  ub    Double-bounded variable
*     GLP_FX           x  =  lb    Fixed variable
*
*  where x is the auxiliary variable associated with i-th row.
*
*  If the row has no lower bound, the parameter lb is ignored. If the
*  row has no upper bound, the parameter ub is ignored. If the row is
*  an equality constraint (i.e. the corresponding auxiliary variable is
*  of fixed type), only the parameter lb is used while the parameter ub
*  is ignored. */

void glp_set_row_bnds(glp_prob *lp, int i, int type, double lb,
      double ub)
{     GLPROW *row;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_set_row_bnds: i = %d; row number out of range\n",
            i);
      row = lp->row[i];
      row->type = type;
      switch (type)
      {  case GLP_FR:
            row->lb = row->ub = 0.0;
            if (row->stat != GLP_BS) row->stat = GLP_NF;
            break;
         case GLP_LO:
            row->lb = lb, row->ub = 0.0;
            if (row->stat != GLP_BS) row->stat = GLP_NL;
            break;
         case GLP_UP:
            row->lb = 0.0, row->ub = ub;
            if (row->stat != GLP_BS) row->stat = GLP_NU;
            break;
         case GLP_DB:
            row->lb = lb, row->ub = ub;
            if (!(row->stat == GLP_BS ||
                  row->stat == GLP_NL || row->stat == GLP_NU))
               row->stat = (fabs(lb) <= fabs(ub) ? GLP_NL : GLP_NU);
            break;
         case GLP_FX:
            row->lb = row->ub = lb;
            if (row->stat != GLP_BS) row->stat = GLP_NS;
            break;
         default:
            xerror("glp_set_row_bnds: i = %d; type = %d; invalid row ty"
               "pe\n", i, type);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_col_bnds - set (change) column bounds
*
*  SYNOPSIS
*
*  void glp_set_col_bnds(glp_prob *lp, int j, int type, double lb,
*     double ub);
*
*  DESCRIPTION
*
*  The routine glp_set_col_bnds sets (changes) the type and bounds of
*  j-th column (structural variable) of the specified problem object.
*
*  Parameters type, lb, and ub specify the type, lower bound, and upper
*  bound, respectively, as follows:
*
*     Type           Bounds        Comments
*     ------------------------------------------------------
*     GLP_FR   -inf <  x <  +inf   Free variable
*     GLP_LO     lb <= x <  +inf   Variable with lower bound
*     GLP_UP   -inf <  x <=  ub    Variable with upper bound
*     GLP_DB     lb <= x <=  ub    Double-bounded variable
*     GLP_FX           x  =  lb    Fixed variable
*
*  where x is the structural variable associated with j-th column.
*
*  If the column has no lower bound, the parameter lb is ignored. If the
*  column has no upper bound, the parameter ub is ignored. If the column
*  is of fixed type, only the parameter lb is used while the parameter
*  ub is ignored. */

void glp_set_col_bnds(glp_prob *lp, int j, int type, double lb,
      double ub)
{     GLPCOL *col;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_set_col_bnds: j = %d; column number out of range\n"
            , j);
      col = lp->col[j];
      col->type = type;
      switch (type)
      {  case GLP_FR:
            col->lb = col->ub = 0.0;
            if (col->stat != GLP_BS) col->stat = GLP_NF;
            break;
         case GLP_LO:
            col->lb = lb, col->ub = 0.0;
            if (col->stat != GLP_BS) col->stat = GLP_NL;
            break;
         case GLP_UP:
            col->lb = 0.0, col->ub = ub;
            if (col->stat != GLP_BS) col->stat = GLP_NU;
            break;
         case GLP_DB:
            col->lb = lb, col->ub = ub;
            if (!(col->stat == GLP_BS ||
                  col->stat == GLP_NL || col->stat == GLP_NU))
               col->stat = (fabs(lb) <= fabs(ub) ? GLP_NL : GLP_NU);
            break;
         case GLP_FX:
            col->lb = col->ub = lb;
            if (col->stat != GLP_BS) col->stat = GLP_NS;
            break;
         default:
            xerror("glp_set_col_bnds: j = %d; type = %d; invalid column"
               " type\n", j, type);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_obj_coef - set (change) obj. coefficient or constant term
*
*  SYNOPSIS
*
*  void glp_set_obj_coef(glp_prob *lp, int j, double coef);
*
*  DESCRIPTION
*
*  The routine glp_set_obj_coef sets (changes) objective coefficient at
*  j-th column (structural variable) of the specified problem object.
*
*  If the parameter j is 0, the routine sets (changes) the constant term
*  ("shift") of the objective function. */

void glp_set_obj_coef(glp_prob *lp, int j, double coef)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_obj_coef: operation not allowed\n");
      if (!(0 <= j && j <= lp->n))
         xerror("glp_set_obj_coef: j = %d; column number out of range\n"
            , j);
      if (j == 0)
         lp->c0 = coef;
      else
         lp->col[j]->coef = coef;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_mat_row - set (replace) row of the constraint matrix
*
*  SYNOPSIS
*
*  void glp_set_mat_row(glp_prob *lp, int i, int len, const int ind[],
*     const double val[]);
*
*  DESCRIPTION
*
*  The routine glp_set_mat_row stores (replaces) the contents of i-th
*  row of the constraint matrix of the specified problem object.
*
*  Column indices and numeric values of new row elements must be placed
*  in locations ind[1], ..., ind[len] and val[1], ..., val[len], where
*  0 <= len <= n is the new length of i-th row, n is the current number
*  of columns in the problem object. Elements with identical column
*  indices are not allowed. Zero elements are allowed, but they are not
*  stored in the constraint matrix.
*
*  If the parameter len is zero, the parameters ind and/or val can be
*  specified as NULL. */

void glp_set_mat_row(glp_prob *lp, int i, int len, const int ind[],
      const double val[])
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij, *next;
      int j, k;
      /* obtain pointer to i-th row */
      if (!(1 <= i && i <= lp->m))
         xerror("glp_set_mat_row: i = %d; row number out of range\n",
            i);
      row = lp->row[i];
      if (tree != NULL && tree->reason != 0)
      {  xassert(tree->curr != NULL);
         xassert(row->level == tree->curr->level);
      }
      /* remove all existing elements from i-th row */
      while (row->ptr != NULL)
      {  /* take next element in the row */
         aij = row->ptr;
         /* remove the element from the row list */
         row->ptr = aij->r_next;
         /* obtain pointer to corresponding column */
         col = aij->col;
         /* remove the element from the column list */
         if (aij->c_prev == NULL)
            col->ptr = aij->c_next;
         else
            aij->c_prev->c_next = aij->c_next;
         if (aij->c_next == NULL)
            ;
         else
            aij->c_next->c_prev = aij->c_prev;
         /* return the element to the memory pool */
         dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
         /* if the corresponding column is basic, invalidate the basis
            factorization */
         if (col->stat == GLP_BS) lp->valid = 0;
      }
      /* store new contents of i-th row */
      if (!(0 <= len && len <= lp->n))
         xerror("glp_set_mat_row: i = %d; len = %d; invalid row length "
            "\n", i, len);
      if (len > NNZ_MAX - lp->nnz)
         xerror("glp_set_mat_row: i = %d; len = %d; too many constraint"
            " coefficients\n", i, len);
      for (k = 1; k <= len; k++)
      {  /* take number j of corresponding column */
         j = ind[k];
         /* obtain pointer to j-th column */
         if (!(1 <= j && j <= lp->n))
            xerror("glp_set_mat_row: i = %d; ind[%d] = %d; column index"
               " out of range\n", i, k, j);
         col = lp->col[j];
         /* if there is element with the same column index, it can only
            be found in the beginning of j-th column list */
         if (col->ptr != NULL && col->ptr->row->i == i)
            xerror("glp_set_mat_row: i = %d; ind[%d] = %d; duplicate co"
               "lumn indices not allowed\n", i, k, j);
         /* create new element */
         aij = dmp_get_atom(lp->pool, sizeof(GLPAIJ)), lp->nnz++;
         aij->row = row;
         aij->col = col;
         aij->val = val[k];
         /* add the new element to the beginning of i-th row and j-th
            column lists */
         aij->r_prev = NULL;
         aij->r_next = row->ptr;
         aij->c_prev = NULL;
         aij->c_next = col->ptr;
         if (aij->r_next != NULL) aij->r_next->r_prev = aij;
         if (aij->c_next != NULL) aij->c_next->c_prev = aij;
         row->ptr = col->ptr = aij;
         /* if the corresponding column is basic, invalidate the basis
            factorization */
         if (col->stat == GLP_BS && aij->val != 0.0) lp->valid = 0;
      }
      /* remove zero elements from i-th row */
      for (aij = row->ptr; aij != NULL; aij = next)
      {  next = aij->r_next;
         if (aij->val == 0.0)
         {  /* remove the element from the row list */
            if (aij->r_prev == NULL)
               row->ptr = next;
            else
               aij->r_prev->r_next = next;
            if (next == NULL)
               ;
            else
               next->r_prev = aij->r_prev;
            /* remove the element from the column list */
            xassert(aij->c_prev == NULL);
            aij->col->ptr = aij->c_next;
            if (aij->c_next != NULL) aij->c_next->c_prev = NULL;
            /* return the element to the memory pool */
            dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_mat_col - set (replace) column of the constraint matrix
*
*  SYNOPSIS
*
*  void glp_set_mat_col(glp_prob *lp, int j, int len, const int ind[],
*     const double val[]);
*
*  DESCRIPTION
*
*  The routine glp_set_mat_col stores (replaces) the contents of j-th
*  column of the constraint matrix of the specified problem object.
*
*  Row indices and numeric values of new column elements must be placed
*  in locations ind[1], ..., ind[len] and val[1], ..., val[len], where
*  0 <= len <= m is the new length of j-th column, m is the current
*  number of rows in the problem object. Elements with identical column
*  indices are not allowed. Zero elements are allowed, but they are not
*  stored in the constraint matrix.
*
*  If the parameter len is zero, the parameters ind and/or val can be
*  specified as NULL. */

void glp_set_mat_col(glp_prob *lp, int j, int len, const int ind[],
      const double val[])
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij, *next;
      int i, k;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_set_mat_col: operation not allowed\n");
      /* obtain pointer to j-th column */
      if (!(1 <= j && j <= lp->n))
         xerror("glp_set_mat_col: j = %d; column number out of range\n",
            j);
      col = lp->col[j];
      /* remove all existing elements from j-th column */
      while (col->ptr != NULL)
      {  /* take next element in the column */
         aij = col->ptr;
         /* remove the element from the column list */
         col->ptr = aij->c_next;
         /* obtain pointer to corresponding row */
         row = aij->row;
         /* remove the element from the row list */
         if (aij->r_prev == NULL)
            row->ptr = aij->r_next;
         else
            aij->r_prev->r_next = aij->r_next;
         if (aij->r_next == NULL)
            ;
         else
            aij->r_next->r_prev = aij->r_prev;
         /* return the element to the memory pool */
         dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
      }
      /* store new contents of j-th column */
      if (!(0 <= len && len <= lp->m))
         xerror("glp_set_mat_col: j = %d; len = %d; invalid column leng"
            "th\n", j, len);
      if (len > NNZ_MAX - lp->nnz)
         xerror("glp_set_mat_col: j = %d; len = %d; too many constraint"
            " coefficients\n", j, len);
      for (k = 1; k <= len; k++)
      {  /* take number i of corresponding row */
         i = ind[k];
         /* obtain pointer to i-th row */
         if (!(1 <= i && i <= lp->m))
            xerror("glp_set_mat_col: j = %d; ind[%d] = %d; row index ou"
               "t of range\n", j, k, i);
         row = lp->row[i];
         /* if there is element with the same row index, it can only be
            found in the beginning of i-th row list */
         if (row->ptr != NULL && row->ptr->col->j == j)
            xerror("glp_set_mat_col: j = %d; ind[%d] = %d; duplicate ro"
               "w indices not allowed\n", j, k, i);
         /* create new element */
         aij = dmp_get_atom(lp->pool, sizeof(GLPAIJ)), lp->nnz++;
         aij->row = row;
         aij->col = col;
         aij->val = val[k];
         /* add the new element to the beginning of i-th row and j-th
            column lists */
         aij->r_prev = NULL;
         aij->r_next = row->ptr;
         aij->c_prev = NULL;
         aij->c_next = col->ptr;
         if (aij->r_next != NULL) aij->r_next->r_prev = aij;
         if (aij->c_next != NULL) aij->c_next->c_prev = aij;
         row->ptr = col->ptr = aij;
      }
      /* remove zero elements from j-th column */
      for (aij = col->ptr; aij != NULL; aij = next)
      {  next = aij->c_next;
         if (aij->val == 0.0)
         {  /* remove the element from the row list */
            xassert(aij->r_prev == NULL);
            aij->row->ptr = aij->r_next;
            if (aij->r_next != NULL) aij->r_next->r_prev = NULL;
            /* remove the element from the column list */
            if (aij->c_prev == NULL)
               col->ptr = next;
            else
               aij->c_prev->c_next = next;
            if (next == NULL)
               ;
            else
               next->c_prev = aij->c_prev;
            /* return the element to the memory pool */
            dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
         }
      }
      /* if j-th column is basic, invalidate the basis factorization */
      if (col->stat == GLP_BS) lp->valid = 0;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_load_matrix - load (replace) the whole constraint matrix
*
*  SYNOPSIS
*
*  void glp_load_matrix(glp_prob *lp, int ne, const int ia[],
*     const int ja[], const double ar[]);
*
*  DESCRIPTION
*
*  The routine glp_load_matrix loads the constraint matrix passed in
*  the arrays ia, ja, and ar into the specified problem object. Before
*  loading the current contents of the constraint matrix is destroyed.
*
*  Constraint coefficients (elements of the constraint matrix) must be
*  specified as triplets (ia[k], ja[k], ar[k]) for k = 1, ..., ne,
*  where ia[k] is the row index, ja[k] is the column index, ar[k] is a
*  numeric value of corresponding constraint coefficient. The parameter
*  ne specifies the total number of (non-zero) elements in the matrix
*  to be loaded. Coefficients with identical indices are not allowed.
*  Zero coefficients are allowed, however, they are not stored in the
*  constraint matrix.
*
*  If the parameter ne is zero, the parameters ia, ja, and ar can be
*  specified as NULL. */

void glp_load_matrix(glp_prob *lp, int ne, const int ia[],
      const int ja[], const double ar[])
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij, *next;
      int i, j, k;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_load_matrix: operation not allowed\n");
      /* clear the constraint matrix */
      for (i = 1; i <= lp->m; i++)
      {  row = lp->row[i];
         while (row->ptr != NULL)
         {  aij = row->ptr;
            row->ptr = aij->r_next;
            dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
         }
      }
      xassert(lp->nnz == 0);
      for (j = 1; j <= lp->n; j++) lp->col[j]->ptr = NULL;
      /* load the new contents of the constraint matrix and build its
         row lists */
      if (ne < 0)
         xerror("glp_load_matrix: ne = %d; invalid number of constraint"
            " coefficients\n", ne);
      if (ne > NNZ_MAX)
         xerror("glp_load_matrix: ne = %d; too many constraint coeffici"
            "ents\n", ne);
      for (k = 1; k <= ne; k++)
      {  /* take indices of new element */
         i = ia[k], j = ja[k];
         /* obtain pointer to i-th row */
         if (!(1 <= i && i <= lp->m))
            xerror("glp_load_matrix: ia[%d] = %d; row index out of rang"
               "e\n", k, i);
         row = lp->row[i];
         /* obtain pointer to j-th column */
         if (!(1 <= j && j <= lp->n))
            xerror("glp_load_matrix: ja[%d] = %d; column index out of r"
               "ange\n", k, j);
         col = lp->col[j];
         /* create new element */
         aij = dmp_get_atom(lp->pool, sizeof(GLPAIJ)), lp->nnz++;
         aij->row = row;
         aij->col = col;
         aij->val = ar[k];
         /* add the new element to the beginning of i-th row list */
         aij->r_prev = NULL;
         aij->r_next = row->ptr;
         if (aij->r_next != NULL) aij->r_next->r_prev = aij;
         row->ptr = aij;
      }
      xassert(lp->nnz == ne);
      /* build column lists of the constraint matrix and check elements
         with identical indices */
      for (i = 1; i <= lp->m; i++)
      {  for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  /* obtain pointer to corresponding column */
            col = aij->col;
            /* if there is element with identical indices, it can only
               be found in the beginning of j-th column list */
            if (col->ptr != NULL && col->ptr->row->i == i)
            {  for (k = 1; k <= ne; k++)
                  if (ia[k] == i && ja[k] == col->j) break;
               xerror("glp_load_mat: ia[%d] = %d; ja[%d] = %d; duplicat"
                  "e indices not allowed\n", k, i, k, col->j);
            }
            /* add the element to the beginning of j-th column list */
            aij->c_prev = NULL;
            aij->c_next = col->ptr;
            if (aij->c_next != NULL) aij->c_next->c_prev = aij;
            col->ptr = aij;
         }
      }
      /* remove zero elements from the constraint matrix */
      for (i = 1; i <= lp->m; i++)
      {  row = lp->row[i];
         for (aij = row->ptr; aij != NULL; aij = next)
         {  next = aij->r_next;
            if (aij->val == 0.0)
            {  /* remove the element from the row list */
               if (aij->r_prev == NULL)
                  row->ptr = next;
               else
                  aij->r_prev->r_next = next;
               if (next == NULL)
                  ;
               else
                  next->r_prev = aij->r_prev;
               /* remove the element from the column list */
               if (aij->c_prev == NULL)
                  aij->col->ptr = aij->c_next;
               else
                  aij->c_prev->c_next = aij->c_next;
               if (aij->c_next == NULL)
                  ;
               else
                  aij->c_next->c_prev = aij->c_prev;
               /* return the element to the memory pool */
               dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
            }
         }
      }
      /* invalidate the basis factorization */
      lp->valid = 0;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_check_dup - check for duplicate elements in sparse matrix
*
*  SYNOPSIS
*
*  int glp_check_dup(int m, int n, int ne, const int ia[],
*     const int ja[]);
*
*  DESCRIPTION
*
*  The routine glp_check_dup checks for duplicate elements (that is,
*  elements with identical indices) in a sparse matrix specified in the
*  coordinate format.
*
*  The parameters m and n specifies, respectively, the number of rows
*  and columns in the matrix, m >= 0, n >= 0.
*
*  The parameter ne specifies the number of (structurally) non-zero
*  elements in the matrix, ne >= 0.
*
*  Elements of the matrix are specified as doublets (ia[k],ja[k]) for
*  k = 1,...,ne, where ia[k] is a row index, ja[k] is a column index.
*
*  The routine glp_check_dup can be used prior to a call to the routine
*  glp_load_matrix to check that the constraint matrix to be loaded has
*  no duplicate elements.
*
*  RETURNS
*
*  The routine glp_check_dup returns one of the following values:
*
*   0 - the matrix has no duplicate elements;
*
*  -k - indices ia[k] or/and ja[k] are out of range;
*
*  +k - element (ia[k],ja[k]) is duplicate. */

int glp_check_dup(int m, int n, int ne, const int ia[], const int ja[])
{     int i, j, k, *ptr, *next, ret;
      char *flag;
      if (m < 0)
         xerror("glp_check_dup: m = %d; invalid parameter\n");
      if (n < 0)
         xerror("glp_check_dup: n = %d; invalid parameter\n");
      if (ne < 0)
         xerror("glp_check_dup: ne = %d; invalid parameter\n");
      if (ne > 0 && ia == NULL)
         xerror("glp_check_dup: ia = %p; invalid parameter\n", ia);
      if (ne > 0 && ja == NULL)
         xerror("glp_check_dup: ja = %p; invalid parameter\n", ja);
      for (k = 1; k <= ne; k++)
      {  i = ia[k], j = ja[k];
         if (!(1 <= i && i <= m && 1 <= j && j <= n))
         {  ret = -k;
            goto done;
         }
      }
      if (m == 0 || n == 0)
      {  ret = 0;
         goto done;
      }
      /* allocate working arrays */
      ptr = xcalloc(1+m, sizeof(int));
      next = xcalloc(1+ne, sizeof(int));
      flag = xcalloc(1+n, sizeof(char));
      /* build row lists */
      for (i = 1; i <= m; i++)
         ptr[i] = 0;
      for (k = 1; k <= ne; k++)
      {  i = ia[k];
         next[k] = ptr[i];
         ptr[i] = k;
      }
      /* clear column flags */
      for (j = 1; j <= n; j++)
         flag[j] = 0;
      /* check for duplicate elements */
      for (i = 1; i <= m; i++)
      {  for (k = ptr[i]; k != 0; k = next[k])
         {  j = ja[k];
            if (flag[j])
            {  /* find first element (i,j) */
               for (k = 1; k <= ne; k++)
                  if (ia[k] == i && ja[k] == j) break;
               xassert(k <= ne);
               /* find next (duplicate) element (i,j) */
               for (k++; k <= ne; k++)
                  if (ia[k] == i && ja[k] == j) break;
               xassert(k <= ne);
               ret = +k;
               goto skip;
            }
            flag[j] = 1;
         }
         /* clear column flags */
         for (k = ptr[i]; k != 0; k = next[k])
            flag[ja[k]] = 0;
      }
      /* no duplicate element found */
      ret = 0;
skip: /* free working arrays */
      xfree(ptr);
      xfree(next);
      xfree(flag);
done: return ret;
}

/***********************************************************************
*  NAME
*
*  glp_sort_matrix - sort elements of the constraint matrix
*
*  SYNOPSIS
*
*  void glp_sort_matrix(glp_prob *P);
*
*  DESCRIPTION
*
*  The routine glp_sort_matrix sorts elements of the constraint matrix
*  rebuilding its row and column linked lists. On exit from the routine
*  the constraint matrix is not changed, however, elements in the row
*  linked lists become ordered by ascending column indices, and the
*  elements in the column linked lists become ordered by ascending row
*  indices. */

void glp_sort_matrix(glp_prob *P)
{     GLPAIJ *aij;
      int i, j;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_sort_matrix: P = %p; invalid problem object\n",
            P);
#endif
      /* rebuild row linked lists */
      for (i = P->m; i >= 1; i--)
         P->row[i]->ptr = NULL;
      for (j = P->n; j >= 1; j--)
      {  for (aij = P->col[j]->ptr; aij != NULL; aij = aij->c_next)
         {  i = aij->row->i;
            aij->r_prev = NULL;
            aij->r_next = P->row[i]->ptr;
            if (aij->r_next != NULL) aij->r_next->r_prev = aij;
            P->row[i]->ptr = aij;
         }
      }
      /* rebuild column linked lists */
      for (j = P->n; j >= 1; j--)
         P->col[j]->ptr = NULL;
      for (i = P->m; i >= 1; i--)
      {  for (aij = P->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  j = aij->col->j;
            aij->c_prev = NULL;
            aij->c_next = P->col[j]->ptr;
            if (aij->c_next != NULL) aij->c_next->c_prev = aij;
            P->col[j]->ptr = aij;
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_del_rows - delete rows from problem object
*
*  SYNOPSIS
*
*  void glp_del_rows(glp_prob *lp, int nrs, const int num[]);
*
*  DESCRIPTION
*
*  The routine glp_del_rows deletes rows from the specified problem
*  object. Ordinal numbers of rows to be deleted should be placed in
*  locations num[1], ..., num[nrs], where nrs > 0.
*
*  Note that deleting rows involves changing ordinal numbers of other
*  rows remaining in the problem object. New ordinal numbers of the
*  remaining rows are assigned under the assumption that the original
*  order of rows is not changed. */

void glp_del_rows(glp_prob *lp, int nrs, const int num[])
{     glp_tree *tree = lp->tree;
      GLPROW *row;
      int i, k, m_new;
      /* mark rows to be deleted */
      if (!(1 <= nrs && nrs <= lp->m))
         xerror("glp_del_rows: nrs = %d; invalid number of rows\n",
            nrs);
      for (k = 1; k <= nrs; k++)
      {  /* take the number of row to be deleted */
         i = num[k];
         /* obtain pointer to i-th row */
         if (!(1 <= i && i <= lp->m))
            xerror("glp_del_rows: num[%d] = %d; row number out of range"
               "\n", k, i);
         row = lp->row[i];
         if (tree != NULL && tree->reason != 0)
         {  if (!(tree->reason == GLP_IROWGEN ||
                  tree->reason == GLP_ICUTGEN))
               xerror("glp_del_rows: operation not allowed\n");
            xassert(tree->curr != NULL);
            if (row->level != tree->curr->level)
               xerror("glp_del_rows: num[%d] = %d; invalid attempt to d"
                  "elete row created not in current subproblem\n", k,i);
            if (row->stat != GLP_BS)
               xerror("glp_del_rows: num[%d] = %d; invalid attempt to d"
                  "elete active row (constraint)\n", k, i);
            tree->reinv = 1;
         }
         /* check that the row is not marked yet */
         if (row->i == 0)
            xerror("glp_del_rows: num[%d] = %d; duplicate row numbers n"
               "ot allowed\n", k, i);
         /* erase symbolic name assigned to the row */
         glp_set_row_name(lp, i, NULL);
         xassert(row->node == NULL);
         /* erase corresponding row of the constraint matrix */
         glp_set_mat_row(lp, i, 0, NULL, NULL);
         xassert(row->ptr == NULL);
         /* mark the row to be deleted */
         row->i = 0;
      }
      /* delete all marked rows from the row list */
      m_new = 0;
      for (i = 1; i <= lp->m; i++)
      {  /* obtain pointer to i-th row */
         row = lp->row[i];
         /* check if the row is marked */
         if (row->i == 0)
         {  /* it is marked, delete it */
            dmp_free_atom(lp->pool, row, sizeof(GLPROW));
         }
         else
         {  /* it is not marked; keep it */
            row->i = ++m_new;
            lp->row[row->i] = row;
         }
      }
      /* set new number of rows */
      lp->m = m_new;
      /* invalidate the basis factorization */
      lp->valid = 0;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_del_cols - delete columns from problem object
*
*  SYNOPSIS
*
*  void glp_del_cols(glp_prob *lp, int ncs, const int num[]);
*
*  DESCRIPTION
*
*  The routine glp_del_cols deletes columns from the specified problem
*  object. Ordinal numbers of columns to be deleted should be placed in
*  locations num[1], ..., num[ncs], where ncs > 0.
*
*  Note that deleting columns involves changing ordinal numbers of
*  other columns remaining in the problem object. New ordinal numbers
*  of the remaining columns are assigned under the assumption that the
*  original order of columns is not changed. */

void glp_del_cols(glp_prob *lp, int ncs, const int num[])
{     glp_tree *tree = lp->tree;
      GLPCOL *col;
      int j, k, n_new;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_del_cols: operation not allowed\n");
      /* mark columns to be deleted */
      if (!(1 <= ncs && ncs <= lp->n))
         xerror("glp_del_cols: ncs = %d; invalid number of columns\n",
            ncs);
      for (k = 1; k <= ncs; k++)
      {  /* take the number of column to be deleted */
         j = num[k];
         /* obtain pointer to j-th column */
         if (!(1 <= j && j <= lp->n))
            xerror("glp_del_cols: num[%d] = %d; column number out of ra"
               "nge", k, j);
         col = lp->col[j];
         /* check that the column is not marked yet */
         if (col->j == 0)
            xerror("glp_del_cols: num[%d] = %d; duplicate column number"
               "s not allowed\n", k, j);
         /* erase symbolic name assigned to the column */
         glp_set_col_name(lp, j, NULL);
         xassert(col->node == NULL);
         /* erase corresponding column of the constraint matrix */
         glp_set_mat_col(lp, j, 0, NULL, NULL);
         xassert(col->ptr == NULL);
         /* mark the column to be deleted */
         col->j = 0;
         /* if it is basic, invalidate the basis factorization */
         if (col->stat == GLP_BS) lp->valid = 0;
      }
      /* delete all marked columns from the column list */
      n_new = 0;
      for (j = 1; j <= lp->n; j++)
      {  /* obtain pointer to j-th column */
         col = lp->col[j];
         /* check if the column is marked */
         if (col->j == 0)
         {  /* it is marked; delete it */
            dmp_free_atom(lp->pool, col, sizeof(GLPCOL));
         }
         else
         {  /* it is not marked; keep it */
            col->j = ++n_new;
            lp->col[col->j] = col;
         }
      }
      /* set new number of columns */
      lp->n = n_new;
      /* if the basis header is still valid, adjust it */
      if (lp->valid)
      {  int m = lp->m;
         int *head = lp->head;
         for (j = 1; j <= n_new; j++)
         {  k = lp->col[j]->bind;
            if (k != 0)
            {  xassert(1 <= k && k <= m);
               head[k] = m + j;
            }
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_copy_prob - copy problem object content
*
*  SYNOPSIS
*
*  void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names);
*
*  DESCRIPTION
*
*  The routine glp_copy_prob copies the content of the problem object
*  prob to the problem object dest.
*
*  The parameter names is a flag. If it is non-zero, the routine also
*  copies all symbolic names; otherwise, if it is zero, symbolic names
*  are not copied. */

void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names)
{     glp_tree *tree = dest->tree;
      glp_bfcp bfcp;
      int i, j, len, *ind;
      double *val;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_copy_prob: operation not allowed\n");
      if (dest == prob)
         xerror("glp_copy_prob: copying problem object to itself not al"
            "lowed\n");
      if (!(names == GLP_ON || names == GLP_OFF))
         xerror("glp_copy_prob: names = %d; invalid parameter\n",
            names);
      glp_erase_prob(dest);
      if (names && prob->name != NULL)
         glp_set_prob_name(dest, prob->name);
      if (names && prob->obj != NULL)
         glp_set_obj_name(dest, prob->obj);
      dest->dir = prob->dir;
      dest->c0 = prob->c0;
      if (prob->m > 0)
         glp_add_rows(dest, prob->m);
      if (prob->n > 0)
         glp_add_cols(dest, prob->n);
      glp_get_bfcp(prob, &bfcp);
      glp_set_bfcp(dest, &bfcp);
      dest->pbs_stat = prob->pbs_stat;
      dest->dbs_stat = prob->dbs_stat;
      dest->obj_val = prob->obj_val;
      dest->some = prob->some;
      dest->ipt_stat = prob->ipt_stat;
      dest->ipt_obj = prob->ipt_obj;
      dest->mip_stat = prob->mip_stat;
      dest->mip_obj = prob->mip_obj;
      for (i = 1; i <= prob->m; i++)
      {  GLPROW *to = dest->row[i];
         GLPROW *from = prob->row[i];
         if (names && from->name != NULL)
            glp_set_row_name(dest, i, from->name);
         to->type = from->type;
         to->lb = from->lb;
         to->ub = from->ub;
         to->rii = from->rii;
         to->stat = from->stat;
         to->prim = from->prim;
         to->dual = from->dual;
         to->pval = from->pval;
         to->dval = from->dval;
         to->mipx = from->mipx;
      }
      ind = xcalloc(1+prob->m, sizeof(int));
      val = xcalloc(1+prob->m, sizeof(double));
      for (j = 1; j <= prob->n; j++)
      {  GLPCOL *to = dest->col[j];
         GLPCOL *from = prob->col[j];
         if (names && from->name != NULL)
            glp_set_col_name(dest, j, from->name);
         to->kind = from->kind;
         to->type = from->type;
         to->lb = from->lb;
         to->ub = from->ub;
         to->coef = from->coef;
         len = glp_get_mat_col(prob, j, ind, val);
         glp_set_mat_col(dest, j, len, ind, val);
         to->sjj = from->sjj;
         to->stat = from->stat;
         to->prim = from->prim;
         to->dual = from->dual;
         to->pval = from->pval;
         to->dval = from->dval;
         to->mipx = from->mipx;
      }
      xfree(ind);
      xfree(val);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_erase_prob - erase problem object content
*
*  SYNOPSIS
*
*  void glp_erase_prob(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_erase_prob erases the content of the specified
*  problem object. The effect of this operation is the same as if the
*  problem object would be deleted with the routine glp_delete_prob and
*  then created anew with the routine glp_create_prob, with exception
*  that the handle (pointer) to the problem object remains valid. */

static void delete_prob(glp_prob *lp);

void glp_erase_prob(glp_prob *lp)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_erase_prob: operation not allowed\n");
      delete_prob(lp);
      create_prob(lp);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_delete_prob - delete problem object
*
*  SYNOPSIS
*
*  void glp_delete_prob(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_delete_prob deletes the specified problem object and
*  frees all the memory allocated to it. */

static void delete_prob(glp_prob *lp)
#if 0 /* 04/IV-2016 */
{     lp->magic = 0x3F3F3F3F;
#else
{
#endif
      dmp_delete_pool(lp->pool);
#if 0 /* 08/III-2014 */
#if 0 /* 17/XI-2009 */
      xfree(lp->cps);
#else
      if (lp->parms != NULL) xfree(lp->parms);
#endif
#endif
      xassert(lp->tree == NULL);
#if 0
      if (lp->cwa != NULL) xfree(lp->cwa);
#endif
      xfree(lp->row);
      xfree(lp->col);
      if (lp->r_tree != NULL) avl_delete_tree(lp->r_tree);
      if (lp->c_tree != NULL) avl_delete_tree(lp->c_tree);
      xfree(lp->head);
#if 0 /* 08/III-2014 */
      if (lp->bfcp != NULL) xfree(lp->bfcp);
#endif
      if (lp->bfd != NULL) bfd_delete_it(lp->bfd);
      return;
}

void glp_delete_prob(glp_prob *lp)
{     glp_tree *tree = lp->tree;
      if (tree != NULL && tree->reason != 0)
         xerror("glp_delete_prob: operation not allowed\n");
      delete_prob(lp);
      xfree(lp);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob2.c0000644000175100001710000003210300000000000024044 0ustar00runnerdocker00000000000000/* prob2.c (problem retrieving routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_get_prob_name - retrieve problem name
*
*  SYNOPSIS
*
*  const char *glp_get_prob_name(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_prob_name returns a pointer to an internal
*  buffer, which contains symbolic name of the problem. However, if the
*  problem has no assigned name, the routine returns NULL. */

const char *glp_get_prob_name(glp_prob *lp)
{     char *name;
      name = lp->name;
      return name;
}

/***********************************************************************
*  NAME
*
*  glp_get_obj_name - retrieve objective function name
*
*  SYNOPSIS
*
*  const char *glp_get_obj_name(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_obj_name returns a pointer to an internal
*  buffer, which contains a symbolic name of the objective function.
*  However, if the objective function has no assigned name, the routine
*  returns NULL. */

const char *glp_get_obj_name(glp_prob *lp)
{     char *name;
      name = lp->obj;
      return name;
}

/***********************************************************************
*  NAME
*
*  glp_get_obj_dir - retrieve optimization direction flag
*
*  SYNOPSIS
*
*  int glp_get_obj_dir(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_obj_dir returns the optimization direction flag
*  (i.e. "sense" of the objective function):
*
*  GLP_MIN - minimization;
*  GLP_MAX - maximization. */

int glp_get_obj_dir(glp_prob *lp)
{     int dir = lp->dir;
      return dir;
}

/***********************************************************************
*  NAME
*
*  glp_get_num_rows - retrieve number of rows
*
*  SYNOPSIS
*
*  int glp_get_num_rows(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_num_rows returns the current number of rows in
*  the specified problem object. */

int glp_get_num_rows(glp_prob *lp)
{     int m = lp->m;
      return m;
}

/***********************************************************************
*  NAME
*
*  glp_get_num_cols - retrieve number of columns
*
*  SYNOPSIS
*
*  int glp_get_num_cols(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_num_cols returns the current number of columns
*  in the specified problem object. */

int glp_get_num_cols(glp_prob *lp)
{     int n = lp->n;
      return n;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_name - retrieve row name
*
*  SYNOPSIS
*
*  const char *glp_get_row_name(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_name returns a pointer to an internal
*  buffer, which contains symbolic name of i-th row. However, if i-th
*  row has no assigned name, the routine returns NULL. */

const char *glp_get_row_name(glp_prob *lp, int i)
{     char *name;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_name: i = %d; row number out of range\n",
            i);
      name = lp->row[i]->name;
      return name;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_name - retrieve column name
*
*  SYNOPSIS
*
*  const char *glp_get_col_name(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_name returns a pointer to an internal
*  buffer, which contains symbolic name of j-th column. However, if j-th
*  column has no assigned name, the routine returns NULL. */

const char *glp_get_col_name(glp_prob *lp, int j)
{     char *name;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_name: j = %d; column number out of range\n"
            , j);
      name = lp->col[j]->name;
      return name;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_type - retrieve row type
*
*  SYNOPSIS
*
*  int glp_get_row_type(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_type returns the type of i-th row, i.e. the
*  type of corresponding auxiliary variable, as follows:
*
*  GLP_FR - free (unbounded) variable;
*  GLP_LO - variable with lower bound;
*  GLP_UP - variable with upper bound;
*  GLP_DB - double-bounded variable;
*  GLP_FX - fixed variable. */

int glp_get_row_type(glp_prob *lp, int i)
{     if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_type: i = %d; row number out of range\n",
            i);
      return lp->row[i]->type;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_lb - retrieve row lower bound
*
*  SYNOPSIS
*
*  double glp_get_row_lb(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_lb returns the lower bound of i-th row, i.e.
*  the lower bound of corresponding auxiliary variable. However, if the
*  row has no lower bound, the routine returns -DBL_MAX. */

double glp_get_row_lb(glp_prob *lp, int i)
{     double lb;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_lb: i = %d; row number out of range\n", i);
      switch (lp->row[i]->type)
      {  case GLP_FR:
         case GLP_UP:
            lb = -DBL_MAX; break;
         case GLP_LO:
         case GLP_DB:
         case GLP_FX:
            lb = lp->row[i]->lb; break;
         default:
            xassert(lp != lp);
      }
      return lb;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_ub - retrieve row upper bound
*
*  SYNOPSIS
*
*  double glp_get_row_ub(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_ub returns the upper bound of i-th row, i.e.
*  the upper bound of corresponding auxiliary variable. However, if the
*  row has no upper bound, the routine returns +DBL_MAX. */

double glp_get_row_ub(glp_prob *lp, int i)
{     double ub;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_ub: i = %d; row number out of range\n", i);
      switch (lp->row[i]->type)
      {  case GLP_FR:
         case GLP_LO:
            ub = +DBL_MAX; break;
         case GLP_UP:
         case GLP_DB:
         case GLP_FX:
            ub = lp->row[i]->ub; break;
         default:
            xassert(lp != lp);
      }
      return ub;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_type - retrieve column type
*
*  SYNOPSIS
*
*  int glp_get_col_type(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_type returns the type of j-th column, i.e.
*  the type of corresponding structural variable, as follows:
*
*  GLP_FR - free (unbounded) variable;
*  GLP_LO - variable with lower bound;
*  GLP_UP - variable with upper bound;
*  GLP_DB - double-bounded variable;
*  GLP_FX - fixed variable. */

int glp_get_col_type(glp_prob *lp, int j)
{     if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_type: j = %d; column number out of range\n"
            , j);
      return lp->col[j]->type;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_lb - retrieve column lower bound
*
*  SYNOPSIS
*
*  double glp_get_col_lb(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_lb returns the lower bound of j-th column,
*  i.e. the lower bound of corresponding structural variable. However,
*  if the column has no lower bound, the routine returns -DBL_MAX. */

double glp_get_col_lb(glp_prob *lp, int j)
{     double lb;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_lb: j = %d; column number out of range\n",
            j);
      switch (lp->col[j]->type)
      {  case GLP_FR:
         case GLP_UP:
            lb = -DBL_MAX; break;
         case GLP_LO:
         case GLP_DB:
         case GLP_FX:
            lb = lp->col[j]->lb; break;
         default:
            xassert(lp != lp);
      }
      return lb;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_ub - retrieve column upper bound
*
*  SYNOPSIS
*
*  double glp_get_col_ub(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_ub returns the upper bound of j-th column,
*  i.e. the upper bound of corresponding structural variable. However,
*  if the column has no upper bound, the routine returns +DBL_MAX. */

double glp_get_col_ub(glp_prob *lp, int j)
{     double ub;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_ub: j = %d; column number out of range\n",
            j);
      switch (lp->col[j]->type)
      {  case GLP_FR:
         case GLP_LO:
            ub = +DBL_MAX; break;
         case GLP_UP:
         case GLP_DB:
         case GLP_FX:
            ub = lp->col[j]->ub; break;
         default:
            xassert(lp != lp);
      }
      return ub;
}

/***********************************************************************
*  NAME
*
*  glp_get_obj_coef - retrieve obj. coefficient or constant term
*
*  SYNOPSIS
*
*  double glp_get_obj_coef(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_obj_coef returns the objective coefficient at
*  j-th structural variable (column) of the specified problem object.
*
*  If the parameter j is zero, the routine returns the constant term
*  ("shift") of the objective function. */

double glp_get_obj_coef(glp_prob *lp, int j)
{     if (!(0 <= j && j <= lp->n))
         xerror("glp_get_obj_coef: j = %d; column number out of range\n"
            , j);
      return j == 0 ? lp->c0 : lp->col[j]->coef;
}

/***********************************************************************
*  NAME
*
*  glp_get_num_nz - retrieve number of constraint coefficients
*
*  SYNOPSIS
*
*  int glp_get_num_nz(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_num_nz returns the number of (non-zero) elements
*  in the constraint matrix of the specified problem object. */

int glp_get_num_nz(glp_prob *lp)
{     int nnz = lp->nnz;
      return nnz;
}

/***********************************************************************
*  NAME
*
*  glp_get_mat_row - retrieve row of the constraint matrix
*
*  SYNOPSIS
*
*  int glp_get_mat_row(glp_prob *lp, int i, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_get_mat_row scans (non-zero) elements of i-th row
*  of the constraint matrix of the specified problem object and stores
*  their column indices and numeric values to locations ind[1], ...,
*  ind[len] and val[1], ..., val[len], respectively, where 0 <= len <= n
*  is the number of elements in i-th row, n is the number of columns.
*
*  The parameter ind and/or val can be specified as NULL, in which case
*  corresponding information is not stored.
*
*  RETURNS
*
*  The routine glp_get_mat_row returns the length len, i.e. the number
*  of (non-zero) elements in i-th row. */

int glp_get_mat_row(glp_prob *lp, int i, int ind[], double val[])
{     GLPAIJ *aij;
      int len;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_mat_row: i = %d; row number out of range\n",
            i);
      len = 0;
      for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
      {  len++;
         if (ind != NULL) ind[len] = aij->col->j;
         if (val != NULL) val[len] = aij->val;
      }
      xassert(len <= lp->n);
      return len;
}

/***********************************************************************
*  NAME
*
*  glp_get_mat_col - retrieve column of the constraint matrix
*
*  SYNOPSIS
*
*  int glp_get_mat_col(glp_prob *lp, int j, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_get_mat_col scans (non-zero) elements of j-th column
*  of the constraint matrix of the specified problem object and stores
*  their row indices and numeric values to locations ind[1], ...,
*  ind[len] and val[1], ..., val[len], respectively, where 0 <= len <= m
*  is the number of elements in j-th column, m is the number of rows.
*
*  The parameter ind or/and val can be specified as NULL, in which case
*  corresponding information is not stored.
*
*  RETURNS
*
*  The routine glp_get_mat_col returns the length len, i.e. the number
*  of (non-zero) elements in j-th column. */

int glp_get_mat_col(glp_prob *lp, int j, int ind[], double val[])
{     GLPAIJ *aij;
      int len;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_mat_col: j = %d; column number out of range\n",
            j);
      len = 0;
      for (aij = lp->col[j]->ptr; aij != NULL; aij = aij->c_next)
      {  len++;
         if (ind != NULL) ind[len] = aij->row->i;
         if (val != NULL) val[len] = aij->val;
      }
      xassert(len <= lp->m);
      return len;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob3.c0000644000175100001710000001177500000000000024061 0ustar00runnerdocker00000000000000/* prob3.c (problem row/column searching routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_create_index - create the name index
*
*  SYNOPSIS
*
*  void glp_create_index(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_create_index creates the name index for the
*  specified problem object. The name index is an auxiliary data
*  structure, which is intended to quickly (i.e. for logarithmic time)
*  find rows and columns by their names.
*
*  This routine can be called at any time. If the name index already
*  exists, the routine does nothing. */

void glp_create_index(glp_prob *lp)
{     GLPROW *row;
      GLPCOL *col;
      int i, j;
      /* create row name index */
      if (lp->r_tree == NULL)
      {  lp->r_tree = avl_create_tree(avl_strcmp, NULL);
         for (i = 1; i <= lp->m; i++)
         {  row = lp->row[i];
            xassert(row->node == NULL);
            if (row->name != NULL)
            {  row->node = avl_insert_node(lp->r_tree, row->name);
               avl_set_node_link(row->node, row);
            }
         }
      }
      /* create column name index */
      if (lp->c_tree == NULL)
      {  lp->c_tree = avl_create_tree(avl_strcmp, NULL);
         for (j = 1; j <= lp->n; j++)
         {  col = lp->col[j];
            xassert(col->node == NULL);
            if (col->name != NULL)
            {  col->node = avl_insert_node(lp->c_tree, col->name);
               avl_set_node_link(col->node, col);
            }
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_find_row - find row by its name
*
*  SYNOPSIS
*
*  int glp_find_row(glp_prob *lp, const char *name);
*
*  RETURNS
*
*  The routine glp_find_row returns the ordinal number of a row,
*  which is assigned (by the routine glp_set_row_name) the specified
*  symbolic name. If no such row exists, the routine returns 0. */

int glp_find_row(glp_prob *lp, const char *name)
{     AVLNODE *node;
      int i = 0;
      if (lp->r_tree == NULL)
         xerror("glp_find_row: row name index does not exist\n");
      if (!(name == NULL || name[0] == '\0' || strlen(name) > 255))
      {  node = avl_find_node(lp->r_tree, name);
         if (node != NULL)
            i = ((GLPROW *)avl_get_node_link(node))->i;
      }
      return i;
}

/***********************************************************************
*  NAME
*
*  glp_find_col - find column by its name
*
*  SYNOPSIS
*
*  int glp_find_col(glp_prob *lp, const char *name);
*
*  RETURNS
*
*  The routine glp_find_col returns the ordinal number of a column,
*  which is assigned (by the routine glp_set_col_name) the specified
*  symbolic name. If no such column exists, the routine returns 0. */

int glp_find_col(glp_prob *lp, const char *name)
{     AVLNODE *node;
      int j = 0;
      if (lp->c_tree == NULL)
         xerror("glp_find_col: column name index does not exist\n");
      if (!(name == NULL || name[0] == '\0' || strlen(name) > 255))
      {  node = avl_find_node(lp->c_tree, name);
         if (node != NULL)
            j = ((GLPCOL *)avl_get_node_link(node))->j;
      }
      return j;
}

/***********************************************************************
*  NAME
*
*  glp_delete_index - delete the name index
*
*  SYNOPSIS
*
*  void glp_delete_index(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_delete_index deletes the name index previously
*  created by the routine glp_create_index and frees the memory
*  allocated to this auxiliary data structure.
*
*  This routine can be called at any time. If the name index does not
*  exist, the routine does nothing. */

void glp_delete_index(glp_prob *lp)
{     int i, j;
      /* delete row name index */
      if (lp->r_tree != NULL)
      {  for (i = 1; i <= lp->m; i++) lp->row[i]->node = NULL;
         avl_delete_tree(lp->r_tree), lp->r_tree = NULL;
      }
      /* delete column name index */
      if (lp->c_tree != NULL)
      {  for (j = 1; j <= lp->n; j++) lp->col[j]->node = NULL;
         avl_delete_tree(lp->c_tree), lp->c_tree = NULL;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob4.c0000644000175100001710000001063600000000000024055 0ustar00runnerdocker00000000000000/* prob4.c (problem scaling routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_set_rii - set (change) row scale factor
*
*  SYNOPSIS
*
*  void glp_set_rii(glp_prob *lp, int i, double rii);
*
*  DESCRIPTION
*
*  The routine glp_set_rii sets (changes) the scale factor r[i,i] for
*  i-th row of the specified problem object. */

void glp_set_rii(glp_prob *lp, int i, double rii)
{     if (!(1 <= i && i <= lp->m))
         xerror("glp_set_rii: i = %d; row number out of range\n", i);
      if (rii <= 0.0)
         xerror("glp_set_rii: i = %d; rii = %g; invalid scale factor\n",
            i, rii);
      if (lp->valid && lp->row[i]->rii != rii)
      {  GLPAIJ *aij;
         for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  if (aij->col->stat == GLP_BS)
            {  /* invalidate the basis factorization */
               lp->valid = 0;
               break;
            }
         }
      }
      lp->row[i]->rii = rii;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set sjj - set (change) column scale factor
*
*  SYNOPSIS
*
*  void glp_set_sjj(glp_prob *lp, int j, double sjj);
*
*  DESCRIPTION
*
*  The routine glp_set_sjj sets (changes) the scale factor s[j,j] for
*  j-th column of the specified problem object. */

void glp_set_sjj(glp_prob *lp, int j, double sjj)
{     if (!(1 <= j && j <= lp->n))
         xerror("glp_set_sjj: j = %d; column number out of range\n", j);
      if (sjj <= 0.0)
         xerror("glp_set_sjj: j = %d; sjj = %g; invalid scale factor\n",
            j, sjj);
      if (lp->valid && lp->col[j]->sjj != sjj && lp->col[j]->stat ==
         GLP_BS)
      {  /* invalidate the basis factorization */
         lp->valid = 0;
      }
      lp->col[j]->sjj = sjj;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_get_rii - retrieve row scale factor
*
*  SYNOPSIS
*
*  double glp_get_rii(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_rii returns current scale factor r[i,i] for i-th
*  row of the specified problem object. */

double glp_get_rii(glp_prob *lp, int i)
{     if (!(1 <= i && i <= lp->m))
         xerror("glp_get_rii: i = %d; row number out of range\n", i);
      return lp->row[i]->rii;
}

/***********************************************************************
*  NAME
*
*  glp_get_sjj - retrieve column scale factor
*
*  SYNOPSIS
*
*  double glp_get_sjj(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_sjj returns current scale factor s[j,j] for j-th
*  column of the specified problem object. */

double glp_get_sjj(glp_prob *lp, int j)
{     if (!(1 <= j && j <= lp->n))
         xerror("glp_get_sjj: j = %d; column number out of range\n", j);
      return lp->col[j]->sjj;
}

/***********************************************************************
*  NAME
*
*  glp_unscale_prob - unscale problem data
*
*  SYNOPSIS
*
*  void glp_unscale_prob(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_unscale_prob performs unscaling of problem data for
*  the specified problem object.
*
*  "Unscaling" means replacing the current scaling matrices R and S by
*  unity matrices that cancels the scaling effect. */

void glp_unscale_prob(glp_prob *lp)
{     int m = glp_get_num_rows(lp);
      int n = glp_get_num_cols(lp);
      int i, j;
      for (i = 1; i <= m; i++) glp_set_rii(lp, i, 1.0);
      for (j = 1; j <= n; j++) glp_set_sjj(lp, j, 1.0);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prob5.c0000644000175100001710000001275300000000000024060 0ustar00runnerdocker00000000000000/* prob5.c (LP problem basis constructing routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_set_row_stat - set (change) row status
*
*  SYNOPSIS
*
*  void glp_set_row_stat(glp_prob *lp, int i, int stat);
*
*  DESCRIPTION
*
*  The routine glp_set_row_stat sets (changes) status of the auxiliary
*  variable associated with i-th row.
*
*  The new status of the auxiliary variable should be specified by the
*  parameter stat as follows:
*
*  GLP_BS - basic variable;
*  GLP_NL - non-basic variable;
*  GLP_NU - non-basic variable on its upper bound; if the variable is
*           not double-bounded, this means the same as GLP_NL (only in
*           case of this routine);
*  GLP_NF - the same as GLP_NL (only in case of this routine);
*  GLP_NS - the same as GLP_NL (only in case of this routine). */

void glp_set_row_stat(glp_prob *lp, int i, int stat)
{     GLPROW *row;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_set_row_stat: i = %d; row number out of range\n",
            i);
      if (!(stat == GLP_BS || stat == GLP_NL || stat == GLP_NU ||
            stat == GLP_NF || stat == GLP_NS))
         xerror("glp_set_row_stat: i = %d; stat = %d; invalid status\n",
            i, stat);
      row = lp->row[i];
      if (stat != GLP_BS)
      {  switch (row->type)
         {  case GLP_FR: stat = GLP_NF; break;
            case GLP_LO: stat = GLP_NL; break;
            case GLP_UP: stat = GLP_NU; break;
            case GLP_DB: if (stat != GLP_NU) stat = GLP_NL; break;
            case GLP_FX: stat = GLP_NS; break;
            default: xassert(row != row);
         }
      }
      if (row->stat == GLP_BS && stat != GLP_BS ||
          row->stat != GLP_BS && stat == GLP_BS)
      {  /* invalidate the basis factorization */
         lp->valid = 0;
      }
      row->stat = stat;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_set_col_stat - set (change) column status
*
*  SYNOPSIS
*
*  void glp_set_col_stat(glp_prob *lp, int j, int stat);
*
*  DESCRIPTION
*
*  The routine glp_set_col_stat sets (changes) status of the structural
*  variable associated with j-th column.
*
*  The new status of the structural variable should be specified by the
*  parameter stat as follows:
*
*  GLP_BS - basic variable;
*  GLP_NL - non-basic variable;
*  GLP_NU - non-basic variable on its upper bound; if the variable is
*           not double-bounded, this means the same as GLP_NL (only in
*           case of this routine);
*  GLP_NF - the same as GLP_NL (only in case of this routine);
*  GLP_NS - the same as GLP_NL (only in case of this routine). */

void glp_set_col_stat(glp_prob *lp, int j, int stat)
{     GLPCOL *col;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_set_col_stat: j = %d; column number out of range\n"
            , j);
      if (!(stat == GLP_BS || stat == GLP_NL || stat == GLP_NU ||
            stat == GLP_NF || stat == GLP_NS))
         xerror("glp_set_col_stat: j = %d; stat = %d; invalid status\n",
            j, stat);
      col = lp->col[j];
      if (stat != GLP_BS)
      {  switch (col->type)
         {  case GLP_FR: stat = GLP_NF; break;
            case GLP_LO: stat = GLP_NL; break;
            case GLP_UP: stat = GLP_NU; break;
            case GLP_DB: if (stat != GLP_NU) stat = GLP_NL; break;
            case GLP_FX: stat = GLP_NS; break;
            default: xassert(col != col);
         }
      }
      if (col->stat == GLP_BS && stat != GLP_BS ||
          col->stat != GLP_BS && stat == GLP_BS)
      {  /* invalidate the basis factorization */
         lp->valid = 0;
      }
      col->stat = stat;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_std_basis - construct standard initial LP basis
*
*  SYNOPSIS
*
*  void glp_std_basis(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_std_basis builds the "standard" (trivial) initial
*  basis for the specified problem object.
*
*  In the "standard" basis all auxiliary variables are basic, and all
*  structural variables are non-basic. */

void glp_std_basis(glp_prob *lp)
{     int i, j;
      /* make all auxiliary variables basic */
      for (i = 1; i <= lp->m; i++)
         glp_set_row_stat(lp, i, GLP_BS);
      /* make all structural variables non-basic */
      for (j = 1; j <= lp->n; j++)
      {  GLPCOL *col = lp->col[j];
         if (col->type == GLP_DB && fabs(col->lb) > fabs(col->ub))
            glp_set_col_stat(lp, j, GLP_NU);
         else
            glp_set_col_stat(lp, j, GLP_NL);
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prrngs.c0000644000175100001710000002530700000000000024343 0ustar00runnerdocker00000000000000/* prrngs.c (print sensitivity analysis report) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf glp_format

static char *format(char buf[13+1], double x)
{     /* format floating-point number in MPS/360-like style */
      if (x == -DBL_MAX)
         strcpy(buf, "         -Inf");
      else if (x == +DBL_MAX)
         strcpy(buf, "         +Inf");
      else if (fabs(x) <= 999999.99998)
      {  sprintf(buf, "%13.5f", x);
#if 1
         if (strcmp(buf, "      0.00000") == 0 ||
             strcmp(buf, "     -0.00000") == 0)
            strcpy(buf, "       .     ");
         else if (memcmp(buf, "      0.", 8) == 0)
            memcpy(buf, "       .", 8);
         else if (memcmp(buf, "     -0.", 8) == 0)
            memcpy(buf, "      -.", 8);
#endif
      }
      else
         sprintf(buf, "%13.6g", x);
      return buf;
}

int glp_print_ranges(glp_prob *P, int len, const int list[],
      int flags, const char *fname)
{     /* print sensitivity analysis report */
      glp_file *fp = NULL;
      GLPROW *row;
      GLPCOL *col;
      int m, n, pass, k, t, numb, type, stat, var1, var2, count, page,
         ret;
      double lb, ub, slack, coef, prim, dual, value1, value2, coef1,
         coef2, obj1, obj2;
      const char *name, *limit;
      char buf[13+1];
      /* sanity checks */
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_print_ranges: P = %p; invalid problem object\n",
            P);
#endif
      m = P->m, n = P->n;
      if (len < 0)
         xerror("glp_print_ranges: len = %d; invalid list length\n",
            len);
      if (len > 0)
      {  if (list == NULL)
            xerror("glp_print_ranges: list = %p: invalid parameter\n",
               list);
         for (t = 1; t <= len; t++)
         {  k = list[t];
            if (!(1 <= k && k <= m+n))
               xerror("glp_print_ranges: list[%d] = %d; row/column numb"
                  "er out of range\n", t, k);
         }
      }
      if (flags != 0)
         xerror("glp_print_ranges: flags = %d; invalid parameter\n",
            flags);
      if (fname == NULL)
         xerror("glp_print_ranges: fname = %p; invalid parameter\n",
            fname);
      if (glp_get_status(P) != GLP_OPT)
      {  xprintf("glp_print_ranges: optimal basic solution required\n");
         ret = 1;
         goto done;
      }
      if (!glp_bf_exists(P))
      {  xprintf("glp_print_ranges: basis factorization required\n");
         ret = 2;
         goto done;
      }
      /* start reporting */
      xprintf("Write sensitivity analysis report to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 3;
         goto done;
      }
      page = count = 0;
      for (pass = 1; pass <= 2; pass++)
      for (t = 1; t <= (len == 0 ? m+n : len); t++)
      {  if (t == 1) count = 0;
         k = (len == 0 ? t : list[t]);
         if (pass == 1 && k > m || pass == 2 && k <= m)
            continue;
         if (count == 0)
         {  xfprintf(fp, "GLPK %-4s - SENSITIVITY ANALYSIS REPORT%73sPa"
               "ge%4d\n", glp_version(), "", ++page);
            xfprintf(fp, "\n");
            xfprintf(fp, "%-12s%s\n", "Problem:",
               P->name == NULL ? "" : P->name);
            xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
               P->obj == NULL ? "" : P->obj,
               P->obj == NULL ? "" : " = ", P->obj_val,
               P->dir == GLP_MIN ? "MINimum" :
               P->dir == GLP_MAX ? "MAXimum" : "???");
            xfprintf(fp, "\n");
            xfprintf(fp, "%6s %-12s %2s %13s %13s %13s  %13s %13s %13s "
               "%s\n", "No.", pass == 1 ? "Row name" : "Column name",
               "St", "Activity", pass == 1 ? "Slack" : "Obj coef",
               "Lower bound", "Activity", "Obj coef", "Obj value at",
               "Limiting");
            xfprintf(fp, "%6s %-12s %2s %13s %13s %13s  %13s %13s %13s "
               "%s\n", "", "", "", "", "Marginal", "Upper bound",
               "range", "range", "break point", "variable");
            xfprintf(fp, "------ ------------ -- ------------- --------"
               "----- -------------  ------------- ------------- ------"
               "------- ------------\n");
         }
         if (pass == 1)
         {  numb = k;
            xassert(1 <= numb && numb <= m);
            row = P->row[numb];
            name = row->name;
            type = row->type;
            lb = glp_get_row_lb(P, numb);
            ub = glp_get_row_ub(P, numb);
            coef = 0.0;
            stat = row->stat;
            prim = row->prim;
            if (type == GLP_FR)
               slack = - prim;
            else if (type == GLP_LO)
               slack = lb - prim;
            else if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
               slack = ub - prim;
            dual = row->dual;
         }
         else
         {  numb = k - m;
            xassert(1 <= numb && numb <= n);
            col = P->col[numb];
            name = col->name;
            lb = glp_get_col_lb(P, numb);
            ub = glp_get_col_ub(P, numb);
            coef = col->coef;
            stat = col->stat;
            prim = col->prim;
            slack = 0.0;
            dual = col->dual;
         }
         if (stat != GLP_BS)
         {  glp_analyze_bound(P, k, &value1, &var1, &value2, &var2);
            if (stat == GLP_NF)
               coef1 = coef2 = coef;
            else if (stat == GLP_NS)
               coef1 = -DBL_MAX, coef2 = +DBL_MAX;
            else if (stat == GLP_NL && P->dir == GLP_MIN ||
                     stat == GLP_NU && P->dir == GLP_MAX)
               coef1 = coef - dual, coef2 = +DBL_MAX;
            else
               coef1 = -DBL_MAX, coef2 = coef - dual;
            if (value1 == -DBL_MAX)
            {  if (dual < -1e-9)
                  obj1 = +DBL_MAX;
               else if (dual > +1e-9)
                  obj1 = -DBL_MAX;
               else
                  obj1 = P->obj_val;
            }
            else
               obj1 = P->obj_val + dual * (value1 - prim);
            if (value2 == +DBL_MAX)
            {  if (dual < -1e-9)
                  obj2 = -DBL_MAX;
               else if (dual > +1e-9)
                  obj2 = +DBL_MAX;
               else
                  obj2 = P->obj_val;
            }
            else
               obj2 = P->obj_val + dual * (value2 - prim);
         }
         else
         {  glp_analyze_coef(P, k, &coef1, &var1, &value1, &coef2,
               &var2, &value2);
            if (coef1 == -DBL_MAX)
            {  if (prim < -1e-9)
                  obj1 = +DBL_MAX;
               else if (prim > +1e-9)
                  obj1 = -DBL_MAX;
               else
                  obj1 = P->obj_val;
            }
            else
               obj1 = P->obj_val + (coef1 - coef) * prim;
            if (coef2 == +DBL_MAX)
            {  if (prim < -1e-9)
                  obj2 = -DBL_MAX;
               else if (prim > +1e-9)
                  obj2 = +DBL_MAX;
               else
                  obj2 = P->obj_val;
            }
            else
               obj2 = P->obj_val + (coef2 - coef) * prim;
         }
         /*** first line ***/
         /* row/column number */
         xfprintf(fp, "%6d", numb);
         /* row/column name */
         xfprintf(fp, " %-12.12s", name == NULL ? "" : name);
         if (name != NULL && strlen(name) > 12)
            xfprintf(fp, "%s\n%6s %12s", name+12, "", "");
         /* row/column status */
         xfprintf(fp, " %2s",
            stat == GLP_BS ? "BS" : stat == GLP_NL ? "NL" :
            stat == GLP_NU ? "NU" : stat == GLP_NF ? "NF" :
            stat == GLP_NS ? "NS" : "??");
         /* row/column activity */
         xfprintf(fp, " %s", format(buf, prim));
         /* row slack, column objective coefficient */
         xfprintf(fp, " %s", format(buf, k <= m ? slack : coef));
         /* row/column lower bound */
         xfprintf(fp, " %s", format(buf, lb));
         /* row/column activity range */
         xfprintf(fp, "  %s", format(buf, value1));
         /* row/column objective coefficient range */
         xfprintf(fp, " %s", format(buf, coef1));
         /* objective value at break point */
         xfprintf(fp, " %s", format(buf, obj1));
         /* limiting variable name */
         if (var1 != 0)
         {  if (var1 <= m)
               limit = glp_get_row_name(P, var1);
            else
               limit = glp_get_col_name(P, var1 - m);
            if (limit != NULL)
               xfprintf(fp, " %s", limit);
         }
         xfprintf(fp, "\n");
         /*** second line ***/
         xfprintf(fp, "%6s %-12s %2s %13s", "", "", "", "");
         /* row/column reduced cost */
         xfprintf(fp, " %s", format(buf, dual));
         /* row/column upper bound */
         xfprintf(fp, " %s", format(buf, ub));
         /* row/column activity range */
         xfprintf(fp, "  %s", format(buf, value2));
         /* row/column objective coefficient range */
         xfprintf(fp, " %s", format(buf, coef2));
         /* objective value at break point */
         xfprintf(fp, " %s", format(buf, obj2));
         /* limiting variable name */
         if (var2 != 0)
         {  if (var2 <= m)
               limit = glp_get_row_name(P, var2);
            else
               limit = glp_get_col_name(P, var2 - m);
            if (limit != NULL)
               xfprintf(fp, " %s", limit);
         }
         xfprintf(fp, "\n");
         xfprintf(fp, "\n");
         /* print 10 items per page */
         count = (count + 1) % 10;
      }
      xfprintf(fp, "End of report\n");
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 4;
         goto done;
      }
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/prsol.c0000644000175100001710000001764100000000000024171 0ustar00runnerdocker00000000000000/* prsol.c (write basic solution in printable format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf glp_format

int glp_print_sol(glp_prob *P, const char *fname)
{     /* write basic solution in printable format */
      glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, t, ae_ind, re_ind, ret;
      double ae_max, re_max;
      xprintf("Writing basic solution to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "%-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name);
      xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
      xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
      xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
      t = glp_get_status(P);
      xfprintf(fp, "%-12s%s\n", "Status:",
         t == GLP_OPT    ? "OPTIMAL" :
         t == GLP_FEAS   ? "FEASIBLE" :
         t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
         t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" :
         t == GLP_UNBND  ? "UNBOUNDED" :
         t == GLP_UNDEF  ? "UNDEFINED" : "???");
      xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->obj_val,
         P->dir == GLP_MIN ? "MINimum" :
         P->dir == GLP_MAX ? "MAXimum" : "???");
      xfprintf(fp, "\n");
      xfprintf(fp, "   No.   Row name   St   Activity     Lower bound  "
         " Upper bound    Marginal\n");
      xfprintf(fp, "------ ------------ -- ------------- ------------- "
         "------------- -------------\n");
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         xfprintf(fp, "%6d ", i);
         if (row->name == NULL || strlen(row->name) <= 12)
            xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
         else
            xfprintf(fp, "%s\n%20s", row->name, "");
         xfprintf(fp, "%s ",
            row->stat == GLP_BS ? "B " :
            row->stat == GLP_NL ? "NL" :
            row->stat == GLP_NU ? "NU" :
            row->stat == GLP_NF ? "NF" :
            row->stat == GLP_NS ? "NS" : "??");
         xfprintf(fp, "%13.6g ",
            fabs(row->prim) <= 1e-9 ? 0.0 : row->prim);
         if (row->type == GLP_LO || row->type == GLP_DB ||
             row->type == GLP_FX)
            xfprintf(fp, "%13.6g ", row->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (row->type == GLP_UP || row->type == GLP_DB)
            xfprintf(fp, "%13.6g ", row->ub);
         else
            xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
         if (row->stat != GLP_BS)
         {  if (fabs(row->dual) <= 1e-9)
               xfprintf(fp, "%13s", "< eps");
            else
               xfprintf(fp, "%13.6g ", row->dual);
         }
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "   No. Column name  St   Activity     Lower bound  "
         " Upper bound    Marginal\n");
      xfprintf(fp, "------ ------------ -- ------------- ------------- "
         "------------- -------------\n");
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         xfprintf(fp, "%6d ", j);
         if (col->name == NULL || strlen(col->name) <= 12)
            xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
         else
            xfprintf(fp, "%s\n%20s", col->name, "");
         xfprintf(fp, "%s ",
            col->stat == GLP_BS ? "B " :
            col->stat == GLP_NL ? "NL" :
            col->stat == GLP_NU ? "NU" :
            col->stat == GLP_NF ? "NF" :
            col->stat == GLP_NS ? "NS" : "??");
         xfprintf(fp, "%13.6g ",
            fabs(col->prim) <= 1e-9 ? 0.0 : col->prim);
         if (col->type == GLP_LO || col->type == GLP_DB ||
             col->type == GLP_FX)
            xfprintf(fp, "%13.6g ", col->lb);
         else
            xfprintf(fp, "%13s ", "");
         if (col->type == GLP_UP || col->type == GLP_DB)
            xfprintf(fp, "%13.6g ", col->ub);
         else
            xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
         if (col->stat != GLP_BS)
         {  if (fabs(col->dual) <= 1e-9)
               xfprintf(fp, "%13s", "< eps");
            else
               xfprintf(fp, "%13.6g ", col->dual);
         }
         xfprintf(fp, "\n");
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_SOL, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
         ae_max, ae_ind);
      xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
         re_max, re_ind);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_SOL, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
            ae_max, ae_ind <= P->m ? "row" : "column",
            ae_ind <= P->m ? ae_ind : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
            re_max, re_ind <= P->m ? "row" : "column",
            re_ind <= P->m ? re_ind : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
            "E");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_SOL, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
         ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on column %d\n",
         re_max, re_ind == 0 ? 0 : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
      xfprintf(fp, "\n");
      glp_check_kkt(P, GLP_SOL, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
         &re_ind);
      xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
            ae_max, ae_ind <= P->m ? "row" : "column",
            ae_ind <= P->m ? ae_ind : ae_ind - P->m);
      xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
            re_max, re_ind <= P->m ? "row" : "column",
            re_ind <= P->m ? re_ind : re_ind - P->m);
      xfprintf(fp, "%8s%s\n", "",
         re_max <= 1e-9 ? "High quality" :
         re_max <= 1e-6 ? "Medium quality" :
         re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
            ;
      xfprintf(fp, "\n");
      xfprintf(fp, "End of output\n");
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdasn.c0000644000175100001710000001340100000000000024127 0ustar00runnerdocker00000000000000/* rdasn.c (read assignment problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "glpk.h"
#include "misc.h"

#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

/***********************************************************************
*  NAME
*
*  glp_read_asnprob - read assignment problem data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_read_asnprob(glp_graph *G, int v_set, int a_cost,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_asnprob reads assignment problem data in DIMACS
*  format from a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_asnprob(glp_graph *G, int v_set, int a_cost, const char
      *fname)
{     DMX _csa, *csa = &_csa;
      glp_vertex *v;
      glp_arc *a;
      int nv, na, n1, i, j, k, ret = 0;
      double cost;
      char *flag = NULL;
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_read_asnprob: v_set = %d; invalid offset\n",
            v_set);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_read_asnprob: a_cost = %d; invalid offset\n",
            a_cost);
      glp_erase_graph(G, G->v_size, G->a_size);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading assignment problem data from '%s'...\n", fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "asn") != 0)
         error(csa, "wrong problem designator; 'asn' expected");
      read_field(csa);
      if (!(str2int(csa->field, &nv) == 0 && nv >= 0))
         error(csa, "number of nodes missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &na) == 0 && na >= 0))
         error(csa, "number of arcs missing or invalid");
      if (nv > 0) glp_add_vertices(G, nv);
      end_of_line(csa);
      /* read node descriptor lines */
      flag = xcalloc(1+nv, sizeof(char));
      memset(&flag[1], 0, nv * sizeof(char));
      n1 = 0;
      for (;;)
      {  read_designator(csa);
         if (strcmp(csa->field, "n") != 0) break;
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "node number %d out of range", i);
         if (flag[i])
            error(csa, "duplicate descriptor of node %d", i);
         flag[i] = 1, n1++;
         end_of_line(csa);
      }
      xprintf(
         "Assignment problem has %d + %d = %d node%s and %d arc%s\n",
         n1, nv - n1, nv, nv == 1 ? "" : "s", na, na == 1 ? "" : "s");
      if (v_set >= 0)
      {  for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            k = (flag[i] ? 0 : 1);
            memcpy((char *)v->data + v_set, &k, sizeof(int));
         }
      }
      /* read arc descriptor lines */
      for (k = 1; k <= na; k++)
      {  if (k > 1) read_designator(csa);
         if (strcmp(csa->field, "a") != 0)
            error(csa, "wrong line designator; 'a' expected");
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "starting node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "starting node number %d out of range", i);
         if (!flag[i])
            error(csa, "node %d cannot be a starting node", i);
         read_field(csa);
         if (str2int(csa->field, &j) != 0)
            error(csa, "ending node number missing or invalid");
         if (!(1 <= j && j <= nv))
            error(csa, "ending node number %d out of range", j);
         if (flag[j])
            error(csa, "node %d cannot be an ending node", j);
         read_field(csa);
         if (str2num(csa->field, &cost) != 0)
            error(csa, "arc cost missing or invalid");
         check_int(csa, cost);
         a = glp_add_arc(G, i, j);
         if (a_cost >= 0)
            memcpy((char *)a->data + a_cost, &cost, sizeof(double));
         end_of_line(csa);
      }
      xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
      if (csa->fp != NULL) glp_close(csa->fp);
      if (flag != NULL) xfree(flag);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdcc.c0000644000175100001710000001304700000000000023741 0ustar00runnerdocker00000000000000/* rdcc.c (read graph in DIMACS clique/coloring format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "glpk.h"
#include "misc.h"

#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

/***********************************************************************
*  NAME
*
*  glp_read_ccdata - read graph in DIMACS clique/coloring format
*
*  SYNOPSIS
*
*  int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_ccdata reads an (undirected) graph in DIMACS
*  clique/coloring format from a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname)
{     DMX _csa, *csa = &_csa;
      glp_vertex *v;
      int i, j, k, nv, ne, ret = 0;
      double w;
      char *flag = NULL;
      if (v_wgt >= 0 && v_wgt > G->v_size - (int)sizeof(double))
         xerror("glp_read_ccdata: v_wgt = %d; invalid offset\n",
            v_wgt);
      glp_erase_graph(G, G->v_size, G->a_size);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading graph from '%s'...\n", fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "edge") != 0)
         error(csa, "wrong problem designator; 'edge' expected");
      read_field(csa);
      if (!(str2int(csa->field, &nv) == 0 && nv >= 0))
         error(csa, "number of vertices missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &ne) == 0 && ne >= 0))
         error(csa, "number of edges missing or invalid");
      xprintf("Graph has %d vert%s and %d edge%s\n",
         nv, nv == 1 ? "ex" : "ices", ne, ne == 1 ? "" : "s");
      if (nv > 0) glp_add_vertices(G, nv);
      end_of_line(csa);
      /* read node descriptor lines */
      flag = xcalloc(1+nv, sizeof(char));
      memset(&flag[1], 0, nv * sizeof(char));
      if (v_wgt >= 0)
      {  w = 1.0;
         for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_wgt, &w, sizeof(double));
         }
      }
      for (;;)
      {  read_designator(csa);
         if (strcmp(csa->field, "n") != 0) break;
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "vertex number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "vertex number %d out of range", i);
         if (flag[i])
            error(csa, "duplicate descriptor of vertex %d", i);
         read_field(csa);
         if (str2num(csa->field, &w) != 0)
            error(csa, "vertex weight missing or invalid");
         check_int(csa, w);
         if (v_wgt >= 0)
         {  v = G->v[i];
            memcpy((char *)v->data + v_wgt, &w, sizeof(double));
         }
         flag[i] = 1;
         end_of_line(csa);
      }
      xfree(flag), flag = NULL;
      /* read edge descriptor lines */
      for (k = 1; k <= ne; k++)
      {  if (k > 1) read_designator(csa);
         if (strcmp(csa->field, "e") != 0)
            error(csa, "wrong line designator; 'e' expected");
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "first vertex number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "first vertex number %d out of range", i);
         read_field(csa);
         if (str2int(csa->field, &j) != 0)
            error(csa, "second vertex number missing or invalid");
         if (!(1 <= j && j <= nv))
            error(csa, "second vertex number %d out of range", j);
         glp_add_arc(G, i, j);
         end_of_line(csa);
      }
      xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
      if (csa->fp != NULL) glp_close(csa->fp);
      if (flag != NULL) xfree(flag);
      return ret;
}

/**********************************************************************/

int glp_read_graph(glp_graph *G, const char *fname)
{     return
         glp_read_ccdata(G, -1, fname);
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdcnf.c0000644000175100001710000001133600000000000024121 0ustar00runnerdocker00000000000000/* rdcnf.c (read CNF-SAT problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "misc.h"
#include "prob.h"

#define xfprintf        glp_format
#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

int glp_read_cnfsat(glp_prob *P, const char *fname)
{     /* read CNF-SAT problem data in DIMACS format */
      DMX _csa, *csa = &_csa;
      int m, n, i, j, len, neg, rhs, ret = 0, *ind = NULL;
      double *val = NULL;
      char *map = NULL;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_read_cnfsat: P = %p; invalid problem object\n",
            P);
#endif
      if (fname == NULL)
         xerror("glp_read_cnfsat: fname = %p; invalid parameter\n",
            fname);
      glp_erase_prob(P);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading CNF-SAT problem data from '%s'...\n", fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "cnf") != 0)
         error(csa, "wrong problem designator; 'cnf' expected\n");
      read_field(csa);
      if (!(str2int(csa->field, &n) == 0 && n >= 0))
         error(csa, "number of variables missing or invalid\n");
      read_field(csa);
      if (!(str2int(csa->field, &m) == 0 && m >= 0))
         error(csa, "number of clauses missing or invalid\n");
      xprintf("Instance has %d variable%s and %d clause%s\n",
         n, n == 1 ? "" : "s", m, m == 1 ? "" : "s");
      end_of_line(csa);
      if (m > 0)
         glp_add_rows(P, m);
      if (n > 0)
      {  glp_add_cols(P, n);
         for (j = 1; j <= n; j++)
            glp_set_col_kind(P, j, GLP_BV);
      }
      /* allocate working arrays */
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      map = xcalloc(1+n, sizeof(char));
      for (j = 1; j <= n; j++) map[j] = 0;
      /* read clauses */
      for (i = 1; i <= m; i++)
      {  /* read i-th clause */
         len = 0, rhs = 1;
         for (;;)
         {  /* skip white-space characters */
            while (csa->c == ' ' || csa->c == '\n')
               read_char(csa);
            /* read term */
            read_field(csa);
            if (str2int(csa->field, &j) != 0)
               error(csa, "variable number missing or invalid\n");
            if (j > 0)
               neg = 0;
            else if (j < 0)
               neg = 1, j = -j, rhs--;
            else
               break;
            if (!(1 <= j && j <= n))
               error(csa, "variable number out of range\n");
            if (map[j])
               error(csa, "duplicate variable number\n");
            len++, ind[len] = j, val[len] = (neg ? -1.0 : +1.0);
            map[j] = 1;
         }
         glp_set_row_bnds(P, i, GLP_LO, (double)rhs, 0.0);
         glp_set_mat_row(P, i, len, ind, val);
         while (len > 0) map[ind[len--]] = 0;
      }
      xprintf("%d lines were read\n", csa->count);
      /* problem data has been successfully read */
      glp_sort_matrix(P);
done: if (csa->fp != NULL) glp_close(csa->fp);
      if (ind != NULL) xfree(ind);
      if (val != NULL) xfree(val);
      if (map != NULL) xfree(map);
      if (ret) glp_erase_prob(P);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdipt.c0000644000175100001710000001500700000000000024146 0ustar00runnerdocker00000000000000/* rdipt.c (read interior-point solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "env.h"
#include "misc.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_read_ipt - read interior-point solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_read_ipt(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_ipt reads interior-point solution from a text
*  file in GLPK format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_ipt(glp_prob *P, const char *fname)
{     DMX dmx_, *dmx = &dmx_;
      int i, j, k, m, n, sst, ret = 1;
      char *stat = NULL;
      double obj, *prim = NULL, *dual = NULL;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_read_ipt: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_read_ipt: fname = %d; invalid parameter\n", fname);
      if (setjmp(dmx->jump))
         goto done;
      dmx->fname = fname;
      dmx->fp = NULL;
      dmx->count = 0;
      dmx->c = '\n';
      dmx->field[0] = '\0';
      dmx->empty = dmx->nonint = 0;
      xprintf("Reading interior-point solution from '%s'...\n", fname);
      dmx->fp = glp_open(fname, "r");
      if (dmx->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* read solution line */
      dmx_read_designator(dmx);
      if (strcmp(dmx->field, "s") != 0)
         dmx_error(dmx, "solution line missing or invalid");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "ipt") != 0)
         dmx_error(dmx, "wrong solution designator; 'ipt' expected");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &m) == 0 && m >= 0))
         dmx_error(dmx, "number of rows missing or invalid");
      if (m != P->m)
         dmx_error(dmx, "number of rows mismatch");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &n) == 0 && n >= 0))
         dmx_error(dmx, "number of columns missing or invalid");
      if (n != P->n)
         dmx_error(dmx, "number of columns mismatch");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "o") == 0)
         sst = GLP_OPT;
      else if (strcmp(dmx->field, "i") == 0)
         sst = GLP_INFEAS;
      else if (strcmp(dmx->field, "n") == 0)
         sst = GLP_NOFEAS;
      else if (strcmp(dmx->field, "u") == 0)
         sst = GLP_UNDEF;
      else
         dmx_error(dmx, "solution status missing or invalid");
      dmx_read_field(dmx);
      if (str2num(dmx->field, &obj) != 0)
         dmx_error(dmx, "objective value missing or invalid");
      dmx_end_of_line(dmx);
      /* allocate working arrays */
      stat = xalloc(1+m+n, sizeof(stat[0]));
      for (k = 1; k <= m+n; k++)
         stat[k] = '?';
      prim = xalloc(1+m+n, sizeof(prim[0]));
      dual = xalloc(1+m+n, sizeof(dual[0]));
      /* read solution descriptor lines */
      for (;;)
      {  dmx_read_designator(dmx);
         if (strcmp(dmx->field, "i") == 0)
         {  /* row solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &i) != 0)
               dmx_error(dmx, "row number missing or invalid");
            if (!(1 <= i && i <= m))
               dmx_error(dmx, "row number out of range");
            if (stat[i] != '?')
               dmx_error(dmx, "duplicate row solution descriptor");
            stat[i] = GLP_BS;
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[i]) != 0)
               dmx_error(dmx, "row primal value missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &dual[i]) != 0)
               dmx_error(dmx, "row dual value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "j") == 0)
         {  /* column solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &j) != 0)
               dmx_error(dmx, "column number missing or invalid");
            if (!(1 <= j && j <= n))
               dmx_error(dmx, "column number out of range");
            if (stat[m+j] != '?')
               dmx_error(dmx, "duplicate column solution descriptor");
            stat[m+j] = GLP_BS;
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[m+j]) != 0)
               dmx_error(dmx, "column primal value missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &dual[m+j]) != 0)
               dmx_error(dmx, "column dual value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "e") == 0)
            break;
         else
            dmx_error(dmx, "line designator missing or invalid");
         dmx_end_of_line(dmx);
      }
      /* store solution components into problem object */
      for (k = 1; k <= m+n; k++)
      {  if (stat[k] == '?')
            dmx_error(dmx, "incomplete interior-point solution");
      }
      P->ipt_stat = sst;
      P->ipt_obj = obj;
      for (i = 1; i <= m; i++)
      {  P->row[i]->pval = prim[i];
         P->row[i]->dval = dual[i];
      }
      for (j = 1; j <= n; j++)
      {  P->col[j]->pval = prim[m+j];
         P->col[j]->dval = dual[m+j];
      }
      /* interior-point solution has been successfully read */
      xprintf("%d lines were read\n", dmx->count);
      ret = 0;
done: if (dmx->fp != NULL)
         glp_close(dmx->fp);
      if (stat != NULL)
         xfree(stat);
      if (prim != NULL)
         xfree(prim);
      if (dual != NULL)
         xfree(dual);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdmaxf.c0000644000175100001710000001327600000000000024313 0ustar00runnerdocker00000000000000/* rdmaxf.c (read maximum flow problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "glpk.h"
#include "misc.h"

#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

/***********************************************************************
*  NAME
*
*  glp_read_maxflow - read maximum flow problem data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_read_maxflow(glp_graph *G, int *s, int *t, int a_cap,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_maxflow reads maximum flow problem data in
*  DIMACS format from a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_maxflow(glp_graph *G, int *_s, int *_t, int a_cap,
      const char *fname)
{     DMX _csa, *csa = &_csa;
      glp_arc *a;
      int i, j, k, s, t, nv, na, ret = 0;
      double cap;
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_read_maxflow: a_cap = %d; invalid offset\n",
            a_cap);
      glp_erase_graph(G, G->v_size, G->a_size);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading maximum flow problem data from '%s'...\n",
         fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "max") != 0)
         error(csa, "wrong problem designator; 'max' expected");
      read_field(csa);
      if (!(str2int(csa->field, &nv) == 0 && nv >= 2))
         error(csa, "number of nodes missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &na) == 0 && na >= 0))
         error(csa, "number of arcs missing or invalid");
      xprintf("Flow network has %d node%s and %d arc%s\n",
         nv, nv == 1 ? "" : "s", na, na == 1 ? "" : "s");
      if (nv > 0) glp_add_vertices(G, nv);
      end_of_line(csa);
      /* read node descriptor lines */
      s = t = 0;
      for (;;)
      {  read_designator(csa);
         if (strcmp(csa->field, "n") != 0) break;
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "node number %d out of range", i);
         read_field(csa);
         if (strcmp(csa->field, "s") == 0)
         {  if (s > 0)
               error(csa, "only one source node allowed");
            s = i;
         }
         else if (strcmp(csa->field, "t") == 0)
         {  if (t > 0)
               error(csa, "only one sink node allowed");
            t = i;
         }
         else
            error(csa, "wrong node designator; 's' or 't' expected");
         if (s > 0 && s == t)
            error(csa, "source and sink nodes must be distinct");
         end_of_line(csa);
      }
      if (s == 0)
         error(csa, "source node descriptor missing\n");
      if (t == 0)
         error(csa, "sink node descriptor missing\n");
      if (_s != NULL) *_s = s;
      if (_t != NULL) *_t = t;
      /* read arc descriptor lines */
      for (k = 1; k <= na; k++)
      {  if (k > 1) read_designator(csa);
         if (strcmp(csa->field, "a") != 0)
            error(csa, "wrong line designator; 'a' expected");
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "starting node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "starting node number %d out of range", i);
         read_field(csa);
         if (str2int(csa->field, &j) != 0)
            error(csa, "ending node number missing or invalid");
         if (!(1 <= j && j <= nv))
            error(csa, "ending node number %d out of range", j);
         read_field(csa);
         if (!(str2num(csa->field, &cap) == 0 && cap >= 0.0))
            error(csa, "arc capacity missing or invalid");
         check_int(csa, cap);
         a = glp_add_arc(G, i, j);
         if (a_cap >= 0)
            memcpy((char *)a->data + a_cap, &cap, sizeof(double));
         end_of_line(csa);
      }
      xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
      if (csa->fp != NULL) glp_close(csa->fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdmcf.c0000644000175100001710000001543000000000000024117 0ustar00runnerdocker00000000000000/* rdmcf.c (read min-cost flow problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "glpk.h"
#include "misc.h"

#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

/***********************************************************************
*  NAME
*
*  glp_read_mincost - read min-cost flow problem data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
*     int a_cost, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_mincost reads minimum cost flow problem data in
*  DIMACS format from a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, const char *fname)
{     DMX _csa, *csa = &_csa;
      glp_vertex *v;
      glp_arc *a;
      int i, j, k, nv, na, ret = 0;
      double rhs, low, cap, cost;
      char *flag = NULL;
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_read_mincost: v_rhs = %d; invalid offset\n",
            v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_read_mincost: a_low = %d; invalid offset\n",
            a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_read_mincost: a_cap = %d; invalid offset\n",
            a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_read_mincost: a_cost = %d; invalid offset\n",
            a_cost);
      glp_erase_graph(G, G->v_size, G->a_size);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading min-cost flow problem data from '%s'...\n",
         fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "min") != 0)
         error(csa, "wrong problem designator; 'min' expected");
      read_field(csa);
      if (!(str2int(csa->field, &nv) == 0 && nv >= 0))
         error(csa, "number of nodes missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &na) == 0 && na >= 0))
         error(csa, "number of arcs missing or invalid");
      xprintf("Flow network has %d node%s and %d arc%s\n",
         nv, nv == 1 ? "" : "s", na, na == 1 ? "" : "s");
      if (nv > 0) glp_add_vertices(G, nv);
      end_of_line(csa);
      /* read node descriptor lines */
      flag = xcalloc(1+nv, sizeof(char));
      memset(&flag[1], 0, nv * sizeof(char));
      if (v_rhs >= 0)
      {  rhs = 0.0;
         for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_rhs, &rhs, sizeof(double));
         }
      }
      for (;;)
      {  read_designator(csa);
         if (strcmp(csa->field, "n") != 0) break;
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "node number %d out of range", i);
         if (flag[i])
            error(csa, "duplicate descriptor of node %d", i);
         read_field(csa);
         if (str2num(csa->field, &rhs) != 0)
            error(csa, "node supply/demand missing or invalid");
         check_int(csa, rhs);
         if (v_rhs >= 0)
         {  v = G->v[i];
            memcpy((char *)v->data + v_rhs, &rhs, sizeof(double));
         }
         flag[i] = 1;
         end_of_line(csa);
      }
      xfree(flag), flag = NULL;
      /* read arc descriptor lines */
      for (k = 1; k <= na; k++)
      {  if (k > 1) read_designator(csa);
         if (strcmp(csa->field, "a") != 0)
            error(csa, "wrong line designator; 'a' expected");
         read_field(csa);
         if (str2int(csa->field, &i) != 0)
            error(csa, "starting node number missing or invalid");
         if (!(1 <= i && i <= nv))
            error(csa, "starting node number %d out of range", i);
         read_field(csa);
         if (str2int(csa->field, &j) != 0)
            error(csa, "ending node number missing or invalid");
         if (!(1 <= j && j <= nv))
            error(csa, "ending node number %d out of range", j);
         read_field(csa);
         if (!(str2num(csa->field, &low) == 0 && low >= 0.0))
            error(csa, "lower bound of arc flow missing or invalid");
         check_int(csa, low);
         read_field(csa);
         if (!(str2num(csa->field, &cap) == 0 && cap >= low))
            error(csa, "upper bound of arc flow missing or invalid");
         check_int(csa, cap);
         read_field(csa);
         if (str2num(csa->field, &cost) != 0)
            error(csa, "per-unit cost of arc flow missing or invalid");
         check_int(csa, cost);
         a = glp_add_arc(G, i, j);
         if (a_low >= 0)
            memcpy((char *)a->data + a_low, &low, sizeof(double));
         if (a_cap >= 0)
            memcpy((char *)a->data + a_cap, &cap, sizeof(double));
         if (a_cost >= 0)
            memcpy((char *)a->data + a_cost, &cost, sizeof(double));
         end_of_line(csa);
      }
      xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
      if (csa->fp != NULL) glp_close(csa->fp);
      if (flag != NULL) xfree(flag);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdmip.c0000644000175100001710000001367300000000000024146 0ustar00runnerdocker00000000000000/* rdmip.c (read MIP solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "env.h"
#include "misc.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_read_mip - read MIP solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_read_mip(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_mip reads MIP solution from a text file in GLPK
*  format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_mip(glp_prob *P, const char *fname)
{     DMX dmx_, *dmx = &dmx_;
      int i, j, k, m, n, sst, ret = 1;
      char *stat = NULL;
      double obj, *prim = NULL;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_read_mip: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_read_mip: fname = %d; invalid parameter\n", fname);
      if (setjmp(dmx->jump))
         goto done;
      dmx->fname = fname;
      dmx->fp = NULL;
      dmx->count = 0;
      dmx->c = '\n';
      dmx->field[0] = '\0';
      dmx->empty = dmx->nonint = 0;
      xprintf("Reading MIP solution from '%s'...\n", fname);
      dmx->fp = glp_open(fname, "r");
      if (dmx->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* read solution line */
      dmx_read_designator(dmx);
      if (strcmp(dmx->field, "s") != 0)
         dmx_error(dmx, "solution line missing or invalid");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "mip") != 0)
         dmx_error(dmx, "wrong solution designator; 'mip' expected");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &m) == 0 && m >= 0))
         dmx_error(dmx, "number of rows missing or invalid");
      if (m != P->m)
         dmx_error(dmx, "number of rows mismatch");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &n) == 0 && n >= 0))
         dmx_error(dmx, "number of columns missing or invalid");
      if (n != P->n)
         dmx_error(dmx, "number of columns mismatch");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "o") == 0)
         sst = GLP_OPT;
      else if (strcmp(dmx->field, "f") == 0)
         sst = GLP_FEAS;
      else if (strcmp(dmx->field, "n") == 0)
         sst = GLP_NOFEAS;
      else if (strcmp(dmx->field, "u") == 0)
         sst = GLP_UNDEF;
      else
         dmx_error(dmx, "solution status missing or invalid");
      dmx_read_field(dmx);
      if (str2num(dmx->field, &obj) != 0)
         dmx_error(dmx, "objective value missing or invalid");
      dmx_end_of_line(dmx);
      /* allocate working arrays */
      stat = xalloc(1+m+n, sizeof(stat[0]));
      for (k = 1; k <= m+n; k++)
         stat[k] = '?';
      prim = xalloc(1+m+n, sizeof(prim[0]));
      /* read solution descriptor lines */
      for (;;)
      {  dmx_read_designator(dmx);
         if (strcmp(dmx->field, "i") == 0)
         {  /* row solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &i) != 0)
               dmx_error(dmx, "row number missing or invalid");
            if (!(1 <= i && i <= m))
               dmx_error(dmx, "row number out of range");
            if (stat[i] != '?')
               dmx_error(dmx, "duplicate row solution descriptor");
            stat[i] = GLP_BS;
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[i]) != 0)
               dmx_error(dmx, "row value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "j") == 0)
         {  /* column solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &j) != 0)
               dmx_error(dmx, "column number missing or invalid");
            if (!(1 <= j && j <= n))
               dmx_error(dmx, "column number out of range");
            if (stat[m+j] != '?')
               dmx_error(dmx, "duplicate column solution descriptor");
            stat[m+j] = GLP_BS;
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[m+j]) != 0)
               dmx_error(dmx, "column value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "e") == 0)
            break;
         else
            dmx_error(dmx, "line designator missing or invalid");
         dmx_end_of_line(dmx);
      }
      /* store solution components into problem object */
      for (k = 1; k <= m+n; k++)
      {  if (stat[k] == '?')
            dmx_error(dmx, "incomplete MIP solution");
      }
      P->mip_stat = sst;
      P->mip_obj = obj;
      for (i = 1; i <= m; i++)
         P->row[i]->mipx = prim[i];
      for (j = 1; j <= n; j++)
         P->col[j]->mipx = prim[m+j];
      /* MIP solution has been successfully read */
      xprintf("%d lines were read\n", dmx->count);
      ret = 0;
done: if (dmx->fp != NULL)
         glp_close(dmx->fp);
      if (stat != NULL)
         xfree(stat);
      if (prim != NULL)
         xfree(prim);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdprob.c0000644000175100001710000003266000000000000024320 0ustar00runnerdocker00000000000000/* rdprob.c (read problem data in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "misc.h"
#include "prob.h"

#define xfprintf        glp_format
#define error           dmx_error
#define warning         dmx_warning
#define read_char       dmx_read_char
#define read_designator dmx_read_designator
#define read_field      dmx_read_field
#define end_of_line     dmx_end_of_line
#define check_int       dmx_check_int

/***********************************************************************
*  NAME
*
*  glp_read_prob - read problem data in GLPK format
*
*  SYNOPSIS
*
*  int glp_read_prob(glp_prob *P, int flags, const char *fname);
*
*  The routine glp_read_prob reads problem data in GLPK LP/MIP format
*  from a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_prob(glp_prob *P, int flags, const char *fname)
{     DMX _csa, *csa = &_csa;
      int mip, m, n, nnz, ne, i, j, k, type, kind, ret, *ln = NULL,
         *ia = NULL, *ja = NULL;
      double lb, ub, temp, *ar = NULL;
      char *rf = NULL, *cf = NULL;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_read_prob: P = %p; invalid problem object\n",
            P);
#endif
      if (flags != 0)
         xerror("glp_read_prob: flags = %d; invalid parameter\n",
            flags);
      if (fname == NULL)
         xerror("glp_read_prob: fname = %d; invalid parameter\n",
            fname);
      glp_erase_prob(P);
      if (setjmp(csa->jump))
      {  ret = 1;
         goto done;
      }
      csa->fname = fname;
      csa->fp = NULL;
      csa->count = 0;
      csa->c = '\n';
      csa->field[0] = '\0';
      csa->empty = csa->nonint = 0;
      xprintf("Reading problem data from '%s'...\n", fname);
      csa->fp = glp_open(fname, "r");
      if (csa->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         longjmp(csa->jump, 1);
      }
      /* read problem line */
      read_designator(csa);
      if (strcmp(csa->field, "p") != 0)
         error(csa, "problem line missing or invalid");
      read_field(csa);
      if (strcmp(csa->field, "lp") == 0)
         mip = 0;
      else if (strcmp(csa->field, "mip") == 0)
         mip = 1;
      else
         error(csa, "wrong problem designator; 'lp' or 'mip' expected");
      read_field(csa);
      if (strcmp(csa->field, "min") == 0)
         glp_set_obj_dir(P, GLP_MIN);
      else if (strcmp(csa->field, "max") == 0)
         glp_set_obj_dir(P, GLP_MAX);
      else
         error(csa, "objective sense missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &m) == 0 && m >= 0))
         error(csa, "number of rows missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &n) == 0 && n >= 0))
         error(csa, "number of columns missing or invalid");
      read_field(csa);
      if (!(str2int(csa->field, &nnz) == 0 && nnz >= 0))
         error(csa, "number of constraint coefficients missing or inval"
            "id");
      if (m > 0)
      {  glp_add_rows(P, m);
         for (i = 1; i <= m; i++)
            glp_set_row_bnds(P, i, GLP_FX, 0.0, 0.0);
      }
      if (n > 0)
      {  glp_add_cols(P, n);
         for (j = 1; j <= n; j++)
         {  if (!mip)
               glp_set_col_bnds(P, j, GLP_LO, 0.0, 0.0);
            else
               glp_set_col_kind(P, j, GLP_BV);
         }
      }
      end_of_line(csa);
      /* allocate working arrays */
      rf = xcalloc(1+m, sizeof(char));
      memset(rf, 0, 1+m);
      cf = xcalloc(1+n, sizeof(char));
      memset(cf, 0, 1+n);
      ln = xcalloc(1+nnz, sizeof(int));
      ia = xcalloc(1+nnz, sizeof(int));
      ja = xcalloc(1+nnz, sizeof(int));
      ar = xcalloc(1+nnz, sizeof(double));
      /* read descriptor lines */
      ne = 0;
      for (;;)
      {  read_designator(csa);
         if (strcmp(csa->field, "i") == 0)
         {  /* row descriptor */
            read_field(csa);
            if (str2int(csa->field, &i) != 0)
               error(csa, "row number missing or invalid");
            if (!(1 <= i && i <= m))
               error(csa, "row number out of range");
            read_field(csa);
            if (strcmp(csa->field, "f") == 0)
               type = GLP_FR;
            else if (strcmp(csa->field, "l") == 0)
               type = GLP_LO;
            else if (strcmp(csa->field, "u") == 0)
               type = GLP_UP;
            else if (strcmp(csa->field, "d") == 0)
               type = GLP_DB;
            else if (strcmp(csa->field, "s") == 0)
               type = GLP_FX;
            else
               error(csa, "row type missing or invalid");
            if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
            {  read_field(csa);
               if (str2num(csa->field, &lb) != 0)
                  error(csa, "row lower bound/fixed value missing or in"
                     "valid");
            }
            else
               lb = 0.0;
            if (type == GLP_UP || type == GLP_DB)
            {  read_field(csa);
               if (str2num(csa->field, &ub) != 0)
                  error(csa, "row upper bound missing or invalid");
            }
            else
               ub = 0.0;
            if (rf[i] & 0x01)
               error(csa, "duplicate row descriptor");
            glp_set_row_bnds(P, i, type, lb, ub), rf[i] |= 0x01;
         }
         else if (strcmp(csa->field, "j") == 0)
         {  /* column descriptor */
            read_field(csa);
            if (str2int(csa->field, &j) != 0)
               error(csa, "column number missing or invalid");
            if (!(1 <= j && j <= n))
               error(csa, "column number out of range");
            if (!mip)
               kind = GLP_CV;
            else
            {  read_field(csa);
               if (strcmp(csa->field, "c") == 0)
                  kind = GLP_CV;
               else if (strcmp(csa->field, "i") == 0)
                  kind = GLP_IV;
               else if (strcmp(csa->field, "b") == 0)
               {  kind = GLP_IV;
                  type = GLP_DB, lb = 0.0, ub = 1.0;
                  goto skip;
               }
               else
                  error(csa, "column kind missing or invalid");
            }
            read_field(csa);
            if (strcmp(csa->field, "f") == 0)
               type = GLP_FR;
            else if (strcmp(csa->field, "l") == 0)
               type = GLP_LO;
            else if (strcmp(csa->field, "u") == 0)
               type = GLP_UP;
            else if (strcmp(csa->field, "d") == 0)
               type = GLP_DB;
            else if (strcmp(csa->field, "s") == 0)
               type = GLP_FX;
            else
               error(csa, "column type missing or invalid");
            if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
            {  read_field(csa);
               if (str2num(csa->field, &lb) != 0)
                  error(csa, "column lower bound/fixed value missing or"
                     " invalid");
            }
            else
               lb = 0.0;
            if (type == GLP_UP || type == GLP_DB)
            {  read_field(csa);
               if (str2num(csa->field, &ub) != 0)
                  error(csa, "column upper bound missing or invalid");
            }
            else
               ub = 0.0;
skip:       if (cf[j] & 0x01)
               error(csa, "duplicate column descriptor");
            glp_set_col_kind(P, j, kind);
            glp_set_col_bnds(P, j, type, lb, ub), cf[j] |= 0x01;
         }
         else if (strcmp(csa->field, "a") == 0)
         {  /* coefficient descriptor */
            read_field(csa);
            if (str2int(csa->field, &i) != 0)
               error(csa, "row number missing or invalid");
            if (!(0 <= i && i <= m))
               error(csa, "row number out of range");
            read_field(csa);
            if (str2int(csa->field, &j) != 0)
               error(csa, "column number missing or invalid");
            if (!((i == 0 ? 0 : 1) <= j && j <= n))
               error(csa, "column number out of range");
            read_field(csa);
            if (i == 0)
            {  if (str2num(csa->field, &temp) != 0)
                  error(csa, "objective %s missing or invalid",
                     j == 0 ? "constant term" : "coefficient");
               if (cf[j] & 0x10)
                  error(csa, "duplicate objective %s",
                     j == 0 ? "constant term" : "coefficient");
               glp_set_obj_coef(P, j, temp), cf[j] |= 0x10;
            }
            else
            {  if (str2num(csa->field, &temp) != 0)
                  error(csa, "constraint coefficient missing or invalid"
                     );
               if (ne == nnz)
                  error(csa, "too many constraint coefficient descripto"
                     "rs");
               ln[++ne] = csa->count;
               ia[ne] = i, ja[ne] = j, ar[ne] = temp;
            }
         }
         else if (strcmp(csa->field, "n") == 0)
         {  /* symbolic name descriptor */
            read_field(csa);
            if (strcmp(csa->field, "p") == 0)
            {  /* problem name */
               read_field(csa);
               if (P->name != NULL)
                  error(csa, "duplicate problem name");
               glp_set_prob_name(P, csa->field);
            }
            else if (strcmp(csa->field, "z") == 0)
            {  /* objective name */
               read_field(csa);
               if (P->obj != NULL)
                  error(csa, "duplicate objective name");
               glp_set_obj_name(P, csa->field);
            }
            else if (strcmp(csa->field, "i") == 0)
            {  /* row name */
               read_field(csa);
               if (str2int(csa->field, &i) != 0)
                  error(csa, "row number missing or invalid");
               if (!(1 <= i && i <= m))
                  error(csa, "row number out of range");
               read_field(csa);
               if (P->row[i]->name != NULL)
                  error(csa, "duplicate row name");
               glp_set_row_name(P, i, csa->field);
            }
            else if (strcmp(csa->field, "j") == 0)
            {  /* column name */
               read_field(csa);
               if (str2int(csa->field, &j) != 0)
                  error(csa, "column number missing or invalid");
               if (!(1 <= j && j <= n))
                  error(csa, "column number out of range");
               read_field(csa);
               if (P->col[j]->name != NULL)
                  error(csa, "duplicate column name");
               glp_set_col_name(P, j, csa->field);
            }
            else
               error(csa, "object designator missing or invalid");
         }
         else if (strcmp(csa->field, "e") == 0)
            break;
         else
            error(csa, "line designator missing or invalid");
         end_of_line(csa);
      }
      if (ne < nnz)
         error(csa, "too few constraint coefficient descriptors");
      xassert(ne == nnz);
      k = glp_check_dup(m, n, ne, ia, ja);
      xassert(0 <= k && k <= nnz);
      if (k > 0)
      {  csa->count = ln[k];
         error(csa, "duplicate constraint coefficient");
      }
      glp_load_matrix(P, ne, ia, ja, ar);
      /* print some statistics */
      if (P->name != NULL)
         xprintf("Problem: %s\n", P->name);
      if (P->obj != NULL)
         xprintf("Objective: %s\n", P->obj);
      xprintf("%d row%s, %d column%s, %d non-zero%s\n",
         m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
         "" : "s");
      if (glp_get_num_int(P) > 0)
      {  int ni = glp_get_num_int(P);
         int nb = glp_get_num_bin(P);
         if (ni == 1)
         {  if (nb == 0)
               xprintf("One variable is integer\n");
            else
               xprintf("One variable is binary\n");
         }
         else
         {  xprintf("%d integer variables, ", ni);
            if (nb == 0)
               xprintf("none");
            else if (nb == 1)
               xprintf("one");
            else if (nb == ni)
               xprintf("all");
            else
               xprintf("%d", nb);
            xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
         }
      }
      xprintf("%d lines were read\n", csa->count);
      /* problem data has been successfully read */
      glp_sort_matrix(P);
      ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
      if (rf != NULL) xfree(rf);
      if (cf != NULL) xfree(cf);
      if (ln != NULL) xfree(ln);
      if (ia != NULL) xfree(ia);
      if (ja != NULL) xfree(ja);
      if (ar != NULL) xfree(ar);
      if (ret) glp_erase_prob(P);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rdsol.c0000644000175100001710000001775000000000000024156 0ustar00runnerdocker00000000000000/* rdsol.c (read basic solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"
#include "env.h"
#include "misc.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_read_sol - read basic solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_read_sol(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_read_sol reads basic solution from a text file in
*  GLPK format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_read_sol(glp_prob *P, const char *fname)
{     DMX dmx_, *dmx = &dmx_;
      int i, j, k, m, n, pst, dst, ret = 1;
      char *stat = NULL;
      double obj, *prim = NULL, *dual = NULL;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_read_sol: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_read_sol: fname = %d; invalid parameter\n", fname);
      if (setjmp(dmx->jump))
         goto done;
      dmx->fname = fname;
      dmx->fp = NULL;
      dmx->count = 0;
      dmx->c = '\n';
      dmx->field[0] = '\0';
      dmx->empty = dmx->nonint = 0;
      xprintf("Reading basic solution from '%s'...\n", fname);
      dmx->fp = glp_open(fname, "r");
      if (dmx->fp == NULL)
      {  xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* read solution line */
      dmx_read_designator(dmx);
      if (strcmp(dmx->field, "s") != 0)
         dmx_error(dmx, "solution line missing or invalid");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "bas") != 0)
         dmx_error(dmx, "wrong solution designator; 'bas' expected");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &m) == 0 && m >= 0))
         dmx_error(dmx, "number of rows missing or invalid");
      if (m != P->m)
         dmx_error(dmx, "number of rows mismatch");
      dmx_read_field(dmx);
      if (!(str2int(dmx->field, &n) == 0 && n >= 0))
         dmx_error(dmx, "number of columns missing or invalid");
      if (n != P->n)
         dmx_error(dmx, "number of columns mismatch");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "u") == 0)
         pst = GLP_UNDEF;
      else if (strcmp(dmx->field, "f") == 0)
         pst = GLP_FEAS;
      else if (strcmp(dmx->field, "i") == 0)
         pst = GLP_INFEAS;
      else if (strcmp(dmx->field, "n") == 0)
         pst = GLP_NOFEAS;
      else
         dmx_error(dmx, "primal solution status missing or invalid");
      dmx_read_field(dmx);
      if (strcmp(dmx->field, "u") == 0)
         dst = GLP_UNDEF;
      else if (strcmp(dmx->field, "f") == 0)
         dst = GLP_FEAS;
      else if (strcmp(dmx->field, "i") == 0)
         dst = GLP_INFEAS;
      else if (strcmp(dmx->field, "n") == 0)
         dst = GLP_NOFEAS;
      else
         dmx_error(dmx, "dual solution status missing or invalid");
      dmx_read_field(dmx);
      if (str2num(dmx->field, &obj) != 0)
         dmx_error(dmx, "objective value missing or invalid");
      dmx_end_of_line(dmx);
      /* allocate working arrays */
      stat = xalloc(1+m+n, sizeof(stat[0]));
      for (k = 1; k <= m+n; k++)
         stat[k] = '?';
      prim = xalloc(1+m+n, sizeof(prim[0]));
      dual = xalloc(1+m+n, sizeof(dual[0]));
      /* read solution descriptor lines */
      for (;;)
      {  dmx_read_designator(dmx);
         if (strcmp(dmx->field, "i") == 0)
         {  /* row solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &i) != 0)
               dmx_error(dmx, "row number missing or invalid");
            if (!(1 <= i && i <= m))
               dmx_error(dmx, "row number out of range");
            if (stat[i] != '?')
               dmx_error(dmx, "duplicate row solution descriptor");
            dmx_read_field(dmx);
            if (strcmp(dmx->field, "b") == 0)
               stat[i] = GLP_BS;
            else if (strcmp(dmx->field, "l") == 0)
               stat[i] = GLP_NL;
            else if (strcmp(dmx->field, "u") == 0)
               stat[i] = GLP_NU;
            else if (strcmp(dmx->field, "f") == 0)
               stat[i] = GLP_NF;
            else if (strcmp(dmx->field, "s") == 0)
               stat[i] = GLP_NS;
            else
               dmx_error(dmx, "row status missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[i]) != 0)
               dmx_error(dmx, "row primal value missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &dual[i]) != 0)
               dmx_error(dmx, "row dual value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "j") == 0)
         {  /* column solution descriptor */
            dmx_read_field(dmx);
            if (str2int(dmx->field, &j) != 0)
               dmx_error(dmx, "column number missing or invalid");
            if (!(1 <= j && j <= n))
               dmx_error(dmx, "column number out of range");
            if (stat[m+j] != '?')
               dmx_error(dmx, "duplicate column solution descriptor");
            dmx_read_field(dmx);
            if (strcmp(dmx->field, "b") == 0)
               stat[m+j] = GLP_BS;
            else if (strcmp(dmx->field, "l") == 0)
               stat[m+j] = GLP_NL;
            else if (strcmp(dmx->field, "u") == 0)
               stat[m+j] = GLP_NU;
            else if (strcmp(dmx->field, "f") == 0)
               stat[m+j] = GLP_NF;
            else if (strcmp(dmx->field, "s") == 0)
               stat[m+j] = GLP_NS;
            else
               dmx_error(dmx, "column status missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &prim[m+j]) != 0)
               dmx_error(dmx, "column primal value missing or invalid");
            dmx_read_field(dmx);
            if (str2num(dmx->field, &dual[m+j]) != 0)
               dmx_error(dmx, "column dual value missing or invalid");
            dmx_end_of_line(dmx);
         }
         else if (strcmp(dmx->field, "e") == 0)
            break;
         else
            dmx_error(dmx, "line designator missing or invalid");
         dmx_end_of_line(dmx);
      }
      /* store solution components into problem object */
      for (k = 1; k <= m+n; k++)
      {  if (stat[k] == '?')
            dmx_error(dmx, "incomplete basic solution");
      }
      P->pbs_stat = pst;
      P->dbs_stat = dst;
      P->obj_val = obj;
      P->it_cnt = 0;
      P->some = 0;
      for (i = 1; i <= m; i++)
      {  glp_set_row_stat(P, i, stat[i]);
         P->row[i]->prim = prim[i];
         P->row[i]->dual = dual[i];
      }
      for (j = 1; j <= n; j++)
      {  glp_set_col_stat(P, j, stat[m+j]);
         P->col[j]->prim = prim[m+j];
         P->col[j]->dual = dual[m+j];
      }
      /* basic solution has been successfully read */
      xprintf("%d lines were read\n", dmx->count);
      ret = 0;
done: if (dmx->fp != NULL)
         glp_close(dmx->fp);
      if (stat != NULL)
         xfree(stat);
      if (prim != NULL)
         xfree(prim);
      if (dual != NULL)
         xfree(dual);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/rmfgen.c0000644000175100001710000000074500000000000024305 0ustar00runnerdocker00000000000000/* rmfgen.c */

#include "env.h"
#include "glpk.h"

int glp_rmfgen(glp_graph *G_, int *s_, int *t_, int a_cap_,
      const int parm[1+5])
{     static const char func[] = "glp_rmfgen";
      xassert(G_ == G_);
      xassert(s_ == s_);
      xassert(t_ == t_);
      xassert(a_cap_ == a_cap_);
      xassert(parm == parm);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
      return -1;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/strong.c0000644000175100001710000000672200000000000024344 0ustar00runnerdocker00000000000000/* strong.c (find all strongly connected components of graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "mc13d.h"

/***********************************************************************
*  NAME
*
*  glp_strong_comp - find all strongly connected components of graph
*
*  SYNOPSIS
*
*  int glp_strong_comp(glp_graph *G, int v_num);
*
*  DESCRIPTION
*
*  The routine glp_strong_comp finds all strongly connected components
*  of the specified graph.
*
*  The parameter v_num specifies an offset of the field of type int
*  in the vertex data block, to which the routine stores the number of
*  a strongly connected component containing that vertex. If v_num < 0,
*  no component numbers are stored.
*
*  The components are numbered in arbitrary order from 1 to nc, where
*  nc is the total number of components found, 0 <= nc <= |V|. However,
*  the component numbering has the property that for every arc (i->j)
*  in the graph the condition num(i) >= num(j) holds.
*
*  RETURNS
*
*  The routine returns nc, the total number of components found. */

int glp_strong_comp(glp_graph *G, int v_num)
{     glp_vertex *v;
      glp_arc *a;
      int i, k, last, n, na, nc, *icn, *ip, *lenr, *ior, *ib, *lowl,
         *numb, *prev;
      if (v_num >= 0 && v_num > G->v_size - (int)sizeof(int))
         xerror("glp_strong_comp: v_num = %d; invalid offset\n",
            v_num);
      n = G->nv;
      if (n == 0)
      {  nc = 0;
         goto done;
      }
      na = G->na;
      icn = xcalloc(1+na, sizeof(int));
      ip = xcalloc(1+n, sizeof(int));
      lenr = xcalloc(1+n, sizeof(int));
      ior = xcalloc(1+n, sizeof(int));
      ib = xcalloc(1+n, sizeof(int));
      lowl = xcalloc(1+n, sizeof(int));
      numb = xcalloc(1+n, sizeof(int));
      prev = xcalloc(1+n, sizeof(int));
      k = 1;
      for (i = 1; i <= n; i++)
      {  v = G->v[i];
         ip[i] = k;
         for (a = v->out; a != NULL; a = a->t_next)
            icn[k++] = a->head->i;
         lenr[i] = k - ip[i];
      }
      xassert(na == k-1);
      nc = mc13d(n, icn, ip, lenr, ior, ib, lowl, numb, prev);
      if (v_num >= 0)
      {  xassert(ib[1] == 1);
         for (k = 1; k <= nc; k++)
         {  last = (k < nc ? ib[k+1] : n+1);
            xassert(ib[k] < last);
            for (i = ib[k]; i < last; i++)
            {  v = G->v[ior[i]];
               memcpy((char *)v->data + v_num, &k, sizeof(int));
            }
         }
      }
      xfree(icn);
      xfree(ip);
      xfree(lenr);
      xfree(ior);
      xfree(ib);
      xfree(lowl);
      xfree(numb);
      xfree(prev);
done: return nc;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/topsort.c0000644000175100001710000001024300000000000024533 0ustar00runnerdocker00000000000000/* topsort.c (topological sorting of acyclic digraph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_top_sort - topological sorting of acyclic digraph
*
*  SYNOPSIS
*
*  int glp_top_sort(glp_graph *G, int v_num);
*
*  DESCRIPTION
*
*  The routine glp_top_sort performs topological sorting of vertices of
*  the specified acyclic digraph.
*
*  The parameter v_num specifies an offset of the field of type int in
*  the vertex data block, to which the routine stores the vertex number
*  assigned. If v_num < 0, vertex numbers are not stored.
*
*  The vertices are numbered from 1 to n, where n is the total number
*  of vertices in the graph. The vertex numbering has the property that
*  for every arc (i->j) in the graph the condition num(i) < num(j)
*  holds. Special case num(i) = 0 means that vertex i is not assigned a
*  number, because the graph is *not* acyclic.
*
*  RETURNS
*
*  If the graph is acyclic and therefore all the vertices have been
*  assigned numbers, the routine glp_top_sort returns zero. Otherwise,
*  if the graph is not acyclic, the routine returns the number of
*  vertices which have not been numbered, i.e. for which num(i) = 0. */

static int top_sort(glp_graph *G, int num[])
{     glp_arc *a;
      int i, j, cnt, top, *stack, *indeg;
      /* allocate working arrays */
      indeg = xcalloc(1+G->nv, sizeof(int));
      stack = xcalloc(1+G->nv, sizeof(int));
      /* determine initial indegree of each vertex; push into the stack
         the vertices having zero indegree */
      top = 0;
      for (i = 1; i <= G->nv; i++)
      {  num[i] = indeg[i] = 0;
         for (a = G->v[i]->in; a != NULL; a = a->h_next)
            indeg[i]++;
         if (indeg[i] == 0)
            stack[++top] = i;
      }
      /* assign numbers to vertices in the sorted order */
      cnt = 0;
      while (top > 0)
      {  /* pull vertex i from the stack */
         i = stack[top--];
         /* it has zero indegree in the current graph */
         xassert(indeg[i] == 0);
         /* so assign it a next number */
         xassert(num[i] == 0);
         num[i] = ++cnt;
         /* remove vertex i from the current graph, update indegree of
            its adjacent vertices, and push into the stack new vertices
            whose indegree becomes zero */
         for (a = G->v[i]->out; a != NULL; a = a->t_next)
         {  j = a->head->i;
            /* there exists arc (i->j) in the graph */
            xassert(indeg[j] > 0);
            indeg[j]--;
            if (indeg[j] == 0)
               stack[++top] = j;
         }
      }
      /* free working arrays */
      xfree(indeg);
      xfree(stack);
      return G->nv - cnt;
}

int glp_top_sort(glp_graph *G, int v_num)
{     glp_vertex *v;
      int i, cnt, *num;
      if (v_num >= 0 && v_num > G->v_size - (int)sizeof(int))
         xerror("glp_top_sort: v_num = %d; invalid offset\n", v_num);
      if (G->nv == 0)
      {  cnt = 0;
         goto done;
      }
      num = xcalloc(1+G->nv, sizeof(int));
      cnt = top_sort(G, num);
      if (v_num >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_num, &num[i], sizeof(int));
         }
      }
      xfree(num);
done: return cnt;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wcliqex.c0000644000175100001710000001006700000000000024501 0ustar00runnerdocker00000000000000/* wcliqex.c (find maximum weight clique with exact algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"
#include "wclique.h"

static void set_edge(int nv, unsigned char a[], int i, int j)
{     int k;
      xassert(1 <= j && j < i && i <= nv);
      k = ((i - 1) * (i - 2)) / 2 + (j - 1);
      a[k / CHAR_BIT] |=
         (unsigned char)(1 << ((CHAR_BIT - 1) - k % CHAR_BIT));
      return;
}

int glp_wclique_exact(glp_graph *G, int v_wgt, double *sol, int v_set)
{     /* find maximum weight clique with exact algorithm */
      glp_arc *e;
      int i, j, k, len, x, *w, *ind, ret = 0;
      unsigned char *a;
      double s, t;
      if (v_wgt >= 0 && v_wgt > G->v_size - (int)sizeof(double))
         xerror("glp_wclique_exact: v_wgt = %d; invalid parameter\n",
            v_wgt);
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_wclique_exact: v_set = %d; invalid parameter\n",
            v_set);
      if (G->nv == 0)
      {  /* empty graph has only empty clique */
         if (sol != NULL) *sol = 0.0;
         return 0;
      }
      /* allocate working arrays */
      w = xcalloc(1+G->nv, sizeof(int));
      ind = xcalloc(1+G->nv, sizeof(int));
      len = G->nv; /* # vertices */
      len = len * (len - 1) / 2; /* # entries in lower triangle */
      len = (len + (CHAR_BIT - 1)) / CHAR_BIT; /* # bytes needed */
      a = xcalloc(len, sizeof(char));
      memset(a, 0, len * sizeof(char));
      /* determine vertex weights */
      s = 0.0;
      for (i = 1; i <= G->nv; i++)
      {  if (v_wgt >= 0)
         {  memcpy(&t, (char *)G->v[i]->data + v_wgt, sizeof(double));
            if (!(0.0 <= t && t <= (double)INT_MAX && t == floor(t)))
            {  ret = GLP_EDATA;
               goto done;
            }
            w[i] = (int)t;
         }
         else
            w[i] = 1;
         s += (double)w[i];
      }
      if (s > (double)INT_MAX)
      {  ret = GLP_EDATA;
         goto done;
      }
      /* build the adjacency matrix */
      for (i = 1; i <= G->nv; i++)
      {  for (e = G->v[i]->in; e != NULL; e = e->h_next)
         {  j = e->tail->i;
            /* there exists edge (j,i) in the graph */
            if (i > j) set_edge(G->nv, a, i, j);
         }
         for (e = G->v[i]->out; e != NULL; e = e->t_next)
         {  j = e->head->i;
            /* there exists edge (i,j) in the graph */
            if (i > j) set_edge(G->nv, a, i, j);
         }
      }
      /* find maximum weight clique in the graph */
      len = wclique(G->nv, w, a, ind);
      /* compute the clique weight */
      s = 0.0;
      for (k = 1; k <= len; k++)
      {  i = ind[k];
         xassert(1 <= i && i <= G->nv);
         s += (double)w[i];
      }
      if (sol != NULL) *sol = s;
      /* mark vertices included in the clique */
      if (v_set >= 0)
      {  x = 0;
         for (i = 1; i <= G->nv; i++)
            memcpy((char *)G->v[i]->data + v_set, &x, sizeof(int));
         x = 1;
         for (k = 1; k <= len; k++)
         {  i = ind[k];
            memcpy((char *)G->v[i]->data + v_set, &x, sizeof(int));
         }
      }
done: /* free working arrays */
      xfree(w);
      xfree(ind);
      xfree(a);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/weak.c0000644000175100001710000001231000000000000023745 0ustar00runnerdocker00000000000000/* weak.c (find all weakly connected components of graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

/***********************************************************************
*  NAME
*
*  glp_weak_comp - find all weakly connected components of graph
*
*  SYNOPSIS
*
*  int glp_weak_comp(glp_graph *G, int v_num);
*
*  DESCRIPTION
*
*  The routine glp_weak_comp finds all weakly connected components of
*  the specified graph.
*
*  The parameter v_num specifies an offset of the field of type int
*  in the vertex data block, to which the routine stores the number of
*  a (weakly) connected component containing that vertex. If v_num < 0,
*  no component numbers are stored.
*
*  The components are numbered in arbitrary order from 1 to nc, where
*  nc is the total number of components found, 0 <= nc <= |V|.
*
*  RETURNS
*
*  The routine returns nc, the total number of components found. */

int glp_weak_comp(glp_graph *G, int v_num)
{     glp_vertex *v;
      glp_arc *a;
      int f, i, j, nc, nv, pos1, pos2, *prev, *next, *list;
      if (v_num >= 0 && v_num > G->v_size - (int)sizeof(int))
         xerror("glp_weak_comp: v_num = %d; invalid offset\n", v_num);
      nv = G->nv;
      if (nv == 0)
      {  nc = 0;
         goto done;
      }
      /* allocate working arrays */
      prev = xcalloc(1+nv, sizeof(int));
      next = xcalloc(1+nv, sizeof(int));
      list = xcalloc(1+nv, sizeof(int));
      /* if vertex i is unlabelled, prev[i] is the index of previous
         unlabelled vertex, and next[i] is the index of next unlabelled
         vertex; if vertex i is labelled, then prev[i] < 0, and next[i]
         is the connected component number */
      /* initially all vertices are unlabelled */
      f = 1;
      for (i = 1; i <= nv; i++)
         prev[i] = i - 1, next[i] = i + 1;
      next[nv] = 0;
      /* main loop (until all vertices have been labelled) */
      nc = 0;
      while (f != 0)
      {  /* take an unlabelled vertex */
         i = f;
         /* and remove it from the list of unlabelled vertices */
         f = next[i];
         if (f != 0) prev[f] = 0;
         /* label the vertex; it begins a new component */
         prev[i] = -1, next[i] = ++nc;
         /* breadth first search */
         list[1] = i, pos1 = pos2 = 1;
         while (pos1 <= pos2)
         {  /* dequeue vertex i */
            i = list[pos1++];
            /* consider all arcs incoming to vertex i */
            for (a = G->v[i]->in; a != NULL; a = a->h_next)
            {  /* vertex j is adjacent to vertex i */
               j = a->tail->i;
               if (prev[j] >= 0)
               {  /* vertex j is unlabelled */
                  /* remove it from the list of unlabelled vertices */
                  if (prev[j] == 0)
                     f = next[j];
                  else
                     next[prev[j]] = next[j];
                  if (next[j] == 0)
                     ;
                  else
                     prev[next[j]] = prev[j];
                  /* label the vertex */
                  prev[j] = -1, next[j] = nc;
                  /* and enqueue it for further consideration */
                  list[++pos2] = j;
               }
            }
            /* consider all arcs outgoing from vertex i */
            for (a = G->v[i]->out; a != NULL; a = a->t_next)
            {  /* vertex j is adjacent to vertex i */
               j = a->head->i;
               if (prev[j] >= 0)
               {  /* vertex j is unlabelled */
                  /* remove it from the list of unlabelled vertices */
                  if (prev[j] == 0)
                     f = next[j];
                  else
                     next[prev[j]] = next[j];
                  if (next[j] == 0)
                     ;
                  else
                     prev[next[j]] = prev[j];
                  /* label the vertex */
                  prev[j] = -1, next[j] = nc;
                  /* and enqueue it for further consideration */
                  list[++pos2] = j;
               }
            }
         }
      }
      /* store component numbers */
      if (v_num >= 0)
      {  for (i = 1; i <= nv; i++)
         {  v = G->v[i];
            memcpy((char *)v->data + v_num, &next[i], sizeof(int));
         }
      }
      /* free working arrays */
      xfree(prev);
      xfree(next);
      xfree(list);
done: return nc;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrasn.c0000644000175100001710000000663700000000000024167 0ustar00runnerdocker00000000000000/* wrasn.c (write assignment problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

#define xfprintf        glp_format

/***********************************************************************
*  NAME
*
*  glp_write_asnprob - write assignment problem data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_write_asnprob(glp_graph *G, int v_set, int a_cost,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_asnprob writes assignment problem data in
*  DIMACS format to a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_asnprob(glp_graph *G, int v_set, int a_cost, const char
      *fname)
{     glp_file *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, k, count = 0, ret;
      double cost;
      if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
         xerror("glp_write_asnprob: v_set = %d; invalid offset\n",
            v_set);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_write_asnprob: a_cost = %d; invalid offset\n",
            a_cost);
      xprintf("Writing assignment problem data to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p asn %d %d\n", G->nv, G->na), count++;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         if (v_set >= 0)
            memcpy(&k, (char *)v->data + v_set, sizeof(int));
         else
            k = (v->out != NULL ? 0 : 1);
         if (k == 0)
            xfprintf(fp, "n %d\n", i), count++;
      }
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 1.0;
            xfprintf(fp, "a %d %d %.*g\n",
               a->tail->i, a->head->i, DBL_DIG, cost), count++;
         }
      }
      xfprintf(fp, "c eof\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrcc.c0000644000175100001710000000626500000000000023770 0ustar00runnerdocker00000000000000/* wrcc.c (write graph in DIMACS clique/coloring format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

#define xfprintf        glp_format

/***********************************************************************
*  NAME
*
*  glp_write_ccdata - write graph in DIMACS clique/coloring format
*
*  SYNOPSIS
*
*  int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_ccdata writes the specified graph in DIMACS
*  clique/coloring format to a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname)
{     glp_file *fp;
      glp_vertex *v;
      glp_arc *e;
      int i, count = 0, ret;
      double w;
      if (v_wgt >= 0 && v_wgt > G->v_size - (int)sizeof(double))
         xerror("glp_write_ccdata: v_wgt = %d; invalid offset\n",
            v_wgt);
      xprintf("Writing graph to '%s'\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p edge %d %d\n", G->nv, G->na), count++;
      if (v_wgt >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            memcpy(&w, (char *)v->data + v_wgt, sizeof(double));
            if (w != 1.0)
               xfprintf(fp, "n %d %.*g\n", i, DBL_DIG, w), count++;
         }
      }
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (e = v->out; e != NULL; e = e->t_next)
            xfprintf(fp, "e %d %d\n", e->tail->i, e->head->i), count++;
      }
      xfprintf(fp, "c eof\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/**********************************************************************/

int glp_write_graph(glp_graph *G, const char *fname)
{     return
         glp_write_ccdata(G, -1, fname);
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrcnf.c0000644000175100001710000000565400000000000024152 0ustar00runnerdocker00000000000000/* wrcnf.c (write CNF-SAT problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf        glp_format

int glp_write_cnfsat(glp_prob *P, const char *fname)
{     /* write CNF-SAT problem data in DIMACS format */
      glp_file *fp = NULL;
      GLPAIJ *aij;
      int i, j, len, count = 0, ret;
      char s[50];
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_write_cnfsat: P = %p; invalid problem object\n",
            P);
#endif
      if (glp_check_cnfsat(P) != 0)
      {  xprintf("glp_write_cnfsat: problem object does not encode CNF-"
            "SAT instance\n");
         ret = 1;
         goto done;
      }
      xprintf("Writing CNF-SAT problem data to '%s'...\n", fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         P->name == NULL ? "unknown" : P->name), count++;
      xfprintf(fp, "p cnf %d %d\n", P->n, P->m), count++;
      for (i = 1; i <= P->m; i++)
      {  len = 0;
         for (aij = P->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  j = aij->col->j;
            if (aij->val < 0.0) j = -j;
            sprintf(s, "%d", j);
            if (len > 0 && len + 1 + strlen(s) > 72)
               xfprintf(fp, "\n"), count++, len = 0;
            xfprintf(fp, "%s%s", len == 0 ? "" : " ", s);
            if (len > 0) len++;
            len += strlen(s);
         }
         if (len > 0 && len + 1 + 1 > 72)
            xfprintf(fp, "\n"), count++, len = 0;
         xfprintf(fp, "%s0\n", len == 0 ? "" : " "), count++;
      }
      xfprintf(fp, "c eof\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wript.c0000644000175100001710000001073500000000000024174 0ustar00runnerdocker00000000000000/* wript.c (write interior-point solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_write_ipt - write interior-point solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_write_ipt(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_ipt writes interior-point solution to a text
*  file in GLPK format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_ipt(glp_prob *P, const char *fname)
{     glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, count, ret = 1;
      char *s;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_write_ipt: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_write_ipt: fname = %d; invalid parameter\n", fname)
            ;
      xprintf("Writing interior-point solution to '%s'...\n", fname);
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* write comment lines */
      glp_format(fp, "c %-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name), count++;
      glp_format(fp, "c %-12s%d\n", "Rows:", P->m), count++;
      glp_format(fp, "c %-12s%d\n", "Columns:", P->n), count++;
      glp_format(fp, "c %-12s%d\n", "Non-zeros:", P->nnz), count++;
      switch (P->ipt_stat)
      {  case GLP_OPT:    s = "OPTIMAL";                   break;
         case GLP_INFEAS: s = "INFEASIBLE (INTERMEDIATE)"; break;
         case GLP_NOFEAS: s = "INFEASIBLE (FINAL)";        break;
         case GLP_UNDEF:  s = "UNDEFINED";                 break;
         default:         s = "???";                       break;
      }
      glp_format(fp, "c %-12s%s\n", "Status:", s), count++;
      switch (P->dir)
      {  case GLP_MIN: s = "MINimum"; break;
         case GLP_MAX: s = "MAXimum"; break;
         default:      s = "???";     break;
      }
      glp_format(fp, "c %-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->ipt_obj, s), count++;
      glp_format(fp, "c\n"), count++;
      /* write solution line */
      glp_format(fp, "s ipt %d %d ", P->m, P->n), count++;
      switch (P->ipt_stat)
      {  case GLP_OPT:    glp_format(fp, "o"); break;
         case GLP_INFEAS: glp_format(fp, "i"); break;
         case GLP_NOFEAS: glp_format(fp, "n"); break;
         case GLP_UNDEF:  glp_format(fp, "u"); break;
         default:         glp_format(fp, "?"); break;
      }
      glp_format(fp, " %.*g\n", DBL_DIG, P->ipt_obj);
      /* write row solution descriptor lines */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         glp_format(fp, "i %d %.*g %.*g\n", i, DBL_DIG, row->pval,
            DBL_DIG, row->dval), count++;
      }
      /* write column solution descriptor lines */
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         glp_format(fp, "j %d %.*g %.*g\n", j, DBL_DIG, col->pval,
            DBL_DIG, col->dval), count++;
      }
      /* write end line */
      glp_format(fp, "e o f\n"), count++;
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* interior-point solution has been successfully written */
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL)
         glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrmaxf.c0000644000175100001710000000654000000000000024332 0ustar00runnerdocker00000000000000/* wrmaxf.c (write maximum flow problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

#define xfprintf        glp_format

/***********************************************************************
*  NAME
*
*  glp_write_maxflow - write maximum flow problem data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
*     const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_maxflow writes maximum flow problem data in
*  DIMACS format to a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
      const char *fname)
{     glp_file *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, count = 0, ret;
      double cap;
      if (!(1 <= s && s <= G->nv))
         xerror("glp_write_maxflow: s = %d; source node number out of r"
            "ange\n", s);
      if (!(1 <= t && t <= G->nv))
         xerror("glp_write_maxflow: t = %d: sink node number out of ran"
            "ge\n", t);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cap = %d; invalid offset\n",
            a_cap);
      xprintf("Writing maximum flow problem data to '%s'...\n",
         fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p max %d %d\n", G->nv, G->na), count++;
      xfprintf(fp, "n %d s\n", s), count++;
      xfprintf(fp, "n %d t\n", t), count++;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = 1.0;
            xfprintf(fp, "a %d %d %.*g\n",
               a->tail->i, a->head->i, DBL_DIG, cap), count++;
         }
      }
      xfprintf(fp, "c eof\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrmcf.c0000644000175100001710000001015100000000000024135 0ustar00runnerdocker00000000000000/* wrmcf.c (write min-cost flow problem data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpk.h"

#define xfprintf        glp_format

/***********************************************************************
*  NAME
*
*  glp_write_mincost - write min-cost flow probl. data in DIMACS format
*
*  SYNOPSIS
*
*  int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
*     int a_cost, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_mincost writes minimum cost flow problem data
*  in DIMACS format to a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, const char *fname)
{     glp_file *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, count = 0, ret;
      double rhs, low, cap, cost;
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_write_mincost: v_rhs = %d; invalid offset\n",
            v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_low = %d; invalid offset\n",
            a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cap = %d; invalid offset\n",
            a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cost = %d; invalid offset\n",
            a_cost);
      xprintf("Writing min-cost flow problem data to '%s'...\n",
         fname);
      fp = glp_open(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p min %d %d\n", G->nv, G->na), count++;
      if (v_rhs >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            memcpy(&rhs, (char *)v->data + v_rhs, sizeof(double));
            if (rhs != 0.0)
               xfprintf(fp, "n %d %.*g\n", i, DBL_DIG, rhs), count++;
         }
      }
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  if (a_low >= 0)
               memcpy(&low, (char *)a->data + a_low, sizeof(double));
            else
               low = 0.0;
            if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = 1.0;
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 0.0;
            xfprintf(fp, "a %d %d %.*g %.*g %.*g\n",
               a->tail->i, a->head->i, DBL_DIG, low, DBL_DIG, cap,
               DBL_DIG, cost), count++;
         }
      }
      xfprintf(fp, "c eof\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrmip.c0000644000175100001710000001053400000000000024162 0ustar00runnerdocker00000000000000/* wrmip.c (write MIP solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_write_mip - write MIP solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_write_mip(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_mip writes MIP solution to a text file in GLPK
*  format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_mip(glp_prob *P, const char *fname)
{     glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, count, ret = 1;
      char *s;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_write_mip: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_write_mip: fname = %d; invalid parameter\n", fname)
            ;
      xprintf("Writing MIP solution to '%s'...\n", fname);
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* write comment lines */
      glp_format(fp, "c %-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name), count++;
      glp_format(fp, "c %-12s%d\n", "Rows:", P->m), count++;
      glp_format(fp, "c %-12s%d\n", "Columns:", P->n), count++;
      glp_format(fp, "c %-12s%d\n", "Non-zeros:", P->nnz), count++;
      switch (P->mip_stat)
      {  case GLP_OPT:    s = "INTEGER OPTIMAL";           break;
         case GLP_FEAS:   s = "INTEGER NON-OPTIMAL";       break;
         case GLP_NOFEAS: s = "INTEGER EMPTY";             break;
         case GLP_UNDEF:  s = "INTEGER UNDEFINED";         break;
         default:         s = "???";                       break;
      }
      glp_format(fp, "c %-12s%s\n", "Status:", s), count++;
      switch (P->dir)
      {  case GLP_MIN: s = "MINimum"; break;
         case GLP_MAX: s = "MAXimum"; break;
         default:      s = "???";     break;
      }
      glp_format(fp, "c %-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->mip_obj, s), count++;
      glp_format(fp, "c\n"), count++;
      /* write solution line */
      glp_format(fp, "s mip %d %d ", P->m, P->n), count++;
      switch (P->mip_stat)
      {  case GLP_OPT:    glp_format(fp, "o"); break;
         case GLP_FEAS:   glp_format(fp, "f"); break;
         case GLP_NOFEAS: glp_format(fp, "n"); break;
         case GLP_UNDEF:  glp_format(fp, "u"); break;
         default:         glp_format(fp, "?"); break;
      }
      glp_format(fp, " %.*g\n", DBL_DIG, P->mip_obj);
      /* write row solution descriptor lines */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         glp_format(fp, "i %d %.*g\n", i, DBL_DIG, row->mipx), count++;
      }
      /* write column solution descriptor lines */
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         glp_format(fp, "j %d %.*g\n", j, DBL_DIG, col->mipx), count++;
      }
      /* write end line */
      glp_format(fp, "e o f\n"), count++;
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* MIP solution has been successfully written */
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL)
         glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrprob.c0000644000175100001710000001324100000000000024335 0ustar00runnerdocker00000000000000/* wrprob.c (write problem data in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

#define xfprintf        glp_format

/***********************************************************************
*  NAME
*
*  glp_write_prob - write problem data in GLPK format
*
*  SYNOPSIS
*
*  int glp_write_prob(glp_prob *P, int flags, const char *fname);
*
*  The routine glp_write_prob writes problem data in GLPK LP/MIP format
*  to a text file.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_prob(glp_prob *P, int flags, const char *fname)
{     glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int mip, i, j, count, ret;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_write_prob: P = %p; invalid problem object\n",
            P);
#endif
      if (flags != 0)
         xerror("glp_write_prob: flags = %d; invalid parameter\n",
            flags);
      if (fname == NULL)
         xerror("glp_write_prob: fname = %d; invalid parameter\n",
            fname);
      xprintf("Writing problem data to '%s'...\n", fname);
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* write problem line */
      mip = (glp_get_num_int(P) > 0);
      xfprintf(fp, "p %s %s %d %d %d\n", !mip ? "lp" : "mip",
         P->dir == GLP_MIN ? "min" : P->dir == GLP_MAX ? "max" : "???",
         P->m, P->n, P->nnz), count++;
      if (P->name != NULL)
         xfprintf(fp, "n p %s\n", P->name), count++;
      if (P->obj != NULL)
         xfprintf(fp, "n z %s\n", P->obj), count++;
      /* write row descriptors */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type == GLP_FX && row->lb == 0.0)
            goto skip1;
         xfprintf(fp, "i %d ", i), count++;
         if (row->type == GLP_FR)
            xfprintf(fp, "f\n");
         else if (row->type == GLP_LO)
            xfprintf(fp, "l %.*g\n", DBL_DIG, row->lb);
         else if (row->type == GLP_UP)
            xfprintf(fp, "u %.*g\n", DBL_DIG, row->ub);
         else if (row->type == GLP_DB)
            xfprintf(fp, "d %.*g %.*g\n", DBL_DIG, row->lb, DBL_DIG,
                  row->ub);
         else if (row->type == GLP_FX)
            xfprintf(fp, "s %.*g\n", DBL_DIG, row->lb);
         else
            xassert(row != row);
skip1:   if (row->name != NULL)
            xfprintf(fp, "n i %d %s\n", i, row->name), count++;
      }
      /* write column descriptors */
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (!mip && col->type == GLP_LO && col->lb == 0.0)
            goto skip2;
         if (mip && col->kind == GLP_IV && col->type == GLP_DB &&
             col->lb == 0.0 && col->ub == 1.0)
            goto skip2;
         xfprintf(fp, "j %d ", j), count++;
         if (mip)
         {  if (col->kind == GLP_CV)
               xfprintf(fp, "c ");
            else if (col->kind == GLP_IV)
               xfprintf(fp, "i ");
            else
               xassert(col != col);
         }
         if (col->type == GLP_FR)
            xfprintf(fp, "f\n");
         else if (col->type == GLP_LO)
            xfprintf(fp, "l %.*g\n", DBL_DIG, col->lb);
         else if (col->type == GLP_UP)
            xfprintf(fp, "u %.*g\n", DBL_DIG, col->ub);
         else if (col->type == GLP_DB)
            xfprintf(fp, "d %.*g %.*g\n", DBL_DIG, col->lb, DBL_DIG,
                  col->ub);
         else if (col->type == GLP_FX)
            xfprintf(fp, "s %.*g\n", DBL_DIG, col->lb);
         else
            xassert(col != col);
skip2:   if (col->name != NULL)
            xfprintf(fp, "n j %d %s\n", j, col->name), count++;
      }
      /* write objective coefficient descriptors */
      if (P->c0 != 0.0)
         xfprintf(fp, "a 0 0 %.*g\n", DBL_DIG, P->c0), count++;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->coef != 0.0)
            xfprintf(fp, "a 0 %d %.*g\n", j, DBL_DIG, col->coef),
               count++;
      }
      /* write constraint coefficient descriptors */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            xfprintf(fp, "a %d %d %.*g\n", i, aij->col->j, DBL_DIG,
               aij->val), count++;
      }
      /* write end line */
      xfprintf(fp, "e o f\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/api/wrsol.c0000644000175100001710000001370000000000000024170 0ustar00runnerdocker00000000000000/* wrsol.c (write basic solution in GLPK format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2010-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_write_sol - write basic solution in GLPK format
*
*  SYNOPSIS
*
*  int glp_write_sol(glp_prob *P, const char *fname);
*
*  DESCRIPTION
*
*  The routine glp_write_sol writes basic solution to a text file in
*  GLPK format.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero. Otherwise
*  it prints an error message and returns non-zero. */

int glp_write_sol(glp_prob *P, const char *fname)
{     glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      int i, j, count, ret = 1;
      char *s;
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_write_sol: P = %p; invalid problem object\n", P);
#endif
      if (fname == NULL)
         xerror("glp_write_sol: fname = %d; invalid parameter\n", fname)
            ;
      xprintf("Writing basic solution to '%s'...\n", fname);
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* write comment lines */
      glp_format(fp, "c %-12s%s\n", "Problem:",
         P->name == NULL ? "" : P->name), count++;
      glp_format(fp, "c %-12s%d\n", "Rows:", P->m), count++;
      glp_format(fp, "c %-12s%d\n", "Columns:", P->n), count++;
      glp_format(fp, "c %-12s%d\n", "Non-zeros:", P->nnz), count++;
      switch (glp_get_status(P))
      {  case GLP_OPT:    s = "OPTIMAL";                   break;
         case GLP_FEAS:   s = "FEASIBLE";                  break;
         case GLP_INFEAS: s = "INFEASIBLE (INTERMEDIATE)"; break;
         case GLP_NOFEAS: s = "INFEASIBLE (FINAL)";        break;
         case GLP_UNBND:  s = "UNBOUNDED";                 break;
         case GLP_UNDEF:  s = "UNDEFINED";                 break;
         default:         s = "???";                       break;
      }
      glp_format(fp, "c %-12s%s\n", "Status:", s), count++;
      switch (P->dir)
      {  case GLP_MIN: s = "MINimum"; break;
         case GLP_MAX: s = "MAXimum"; break;
         default:      s = "???";     break;
      }
      glp_format(fp, "c %-12s%s%s%.10g (%s)\n", "Objective:",
         P->obj == NULL ? "" : P->obj,
         P->obj == NULL ? "" : " = ", P->obj_val, s), count++;
      glp_format(fp, "c\n"), count++;
      /* write solution line */
      glp_format(fp, "s bas %d %d ", P->m, P->n), count++;
      switch (P->pbs_stat)
      {  case GLP_UNDEF:  glp_format(fp, "u"); break;
         case GLP_FEAS:   glp_format(fp, "f"); break;
         case GLP_INFEAS: glp_format(fp, "i"); break;
         case GLP_NOFEAS: glp_format(fp, "n"); break;
         default:         glp_format(fp, "?"); break;
      }
      glp_format(fp, " ");
      switch (P->dbs_stat)
      {  case GLP_UNDEF:  glp_format(fp, "u"); break;
         case GLP_FEAS:   glp_format(fp, "f"); break;
         case GLP_INFEAS: glp_format(fp, "i"); break;
         case GLP_NOFEAS: glp_format(fp, "n"); break;
         default:         glp_format(fp, "?"); break;
      }
      glp_format(fp, " %.*g\n", DBL_DIG, P->obj_val);
      /* write row solution descriptor lines */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         glp_format(fp, "i %d ", i), count++;
         switch (row->stat)
         {  case GLP_BS:
               glp_format(fp, "b");
               break;
            case GLP_NL:
               glp_format(fp, "l");
               break;
            case GLP_NU:
               glp_format(fp, "u");
               break;
            case GLP_NF:
               glp_format(fp, "f");
               break;
            case GLP_NS:
               glp_format(fp, "s");
               break;
            default:
               xassert(row != row);
         }
         glp_format(fp, " %.*g %.*g\n", DBL_DIG, row->prim, DBL_DIG,
            row->dual);
      }
      /* write column solution descriptor lines */
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         glp_format(fp, "j %d ", j), count++;
         switch (col->stat)
         {  case GLP_BS:
               glp_format(fp, "b");
               break;
            case GLP_NL:
               glp_format(fp, "l");
               break;
            case GLP_NU:
               glp_format(fp, "u");
               break;
            case GLP_NF:
               glp_format(fp, "f");
               break;
            case GLP_NS:
               glp_format(fp, "s");
               break;
            default:
               xassert(col != col);
         }
         glp_format(fp, " %.*g %.*g\n", DBL_DIG, col->prim, DBL_DIG,
            col->dual);
      }
      /* write end line */
      glp_format(fp, "e o f\n"), count++;
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         goto done;
      }
      /* basic solution has been successfully written */
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL)
         glp_close(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.663143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/0000755000175100001710000000000000000000000023162 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/btf.c0000644000175100001710000005043200000000000024105 0ustar00runnerdocker00000000000000/* btf.c (sparse block triangular LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "btf.h"
#include "env.h"
#include "luf.h"
#include "mc13d.h"
#include "mc21a.h"

/***********************************************************************
*  btf_store_a_cols - store pattern of matrix A in column-wise format
*
*  This routine stores the pattern (that is, only indices of non-zero
*  elements) of the original matrix A in column-wise format.
*
*  On exit the routine returns the number of non-zeros in matrix A. */

int btf_store_a_cols(BTF *btf, int (*col)(void *info, int j, int ind[],
      double val[]), void *info, int ind[], double val[])
{     int n = btf->n;
      SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      int j, len, ptr, nnz;
      nnz = 0;
      for (j = 1; j <= n; j++)
      {  /* get j-th column */
         len = col(info, j, ind, val);
         xassert(0 <= len && len <= n);
         /* reserve locations for j-th column */
         if (len > 0)
         {  if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
            }
            sva_reserve_cap(sva, ac_ref+(j-1), len);
         }
         /* store pattern of j-th column */
         ptr = ac_ptr[j];
         memcpy(&sv_ind[ptr], &ind[1], len * sizeof(int));
         ac_len[j] = len;
         nnz += len;
      }
      return nnz;
}

/***********************************************************************
*  btf_make_blocks - permutations to block triangular form
*
*  This routine analyzes the pattern of the original matrix A and
*  determines permutation matrices P and Q such that A = P * A~* Q,
*  where A~ is an upper block triangular matrix.
*
*  On exit the routine returns symbolic rank of matrix A. */

int btf_make_blocks(BTF *btf)
{     int n = btf->n;
      SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      int *pp_ind = btf->pp_ind;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int *qq_inv = btf->qq_inv;
      int *beg = btf->beg;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      int i, j, rank, *iperm, *pr, *arp, *cv, *out, *ip, *lenr, *lowl,
         *numb, *prev;
      /* determine column permutation matrix M such that matrix A * M
       * has zero-free diagonal */
      iperm = qq_inv; /* matrix M */
      pr  = btf->p1_ind; /* working array */
      arp = btf->p1_inv; /* working array */
      cv  = btf->q1_ind; /* working array */
      out = btf->q1_inv; /* working array */
      rank = mc21a(n, sv_ind, ac_ptr, ac_len, iperm, pr, arp, cv, out);
      xassert(0 <= rank && rank <= n);
      if (rank < n)
      {  /* A is structurally singular (rank is its symbolic rank) */
         goto done;
      }
      /* build pattern of matrix A * M */
      ip   = pp_ind; /* working array */
      lenr = qq_ind; /* working array */
      for (j = 1; j <= n; j++)
      {  ip[j] = ac_ptr[iperm[j]];
         lenr[j] = ac_len[iperm[j]];
      }
      /* determine symmetric permutation matrix S such that matrix
       * S * (A * M) * S' = A~ is upper block triangular */
      lowl = btf->p1_ind; /* working array */
      numb = btf->p1_inv; /* working array */
      prev = btf->q1_ind; /* working array */
      btf->num =
         mc13d(n, sv_ind, ip, lenr, pp_inv, beg, lowl, numb, prev);
      xassert(beg[1] == 1);
      beg[btf->num+1] = n+1;
      /* A * M = S' * A~ * S ==> A = S' * A~ * (S * M') */
      /* determine permutation matrix P = S' */
      for (j = 1; j <= n; j++)
         pp_ind[pp_inv[j]] = j;
      /* determine permutation matrix Q = S * M' = P' * M' */
      for (i = 1; i <= n; i++)
         qq_ind[i] = iperm[pp_inv[i]];
      for (i = 1; i <= n; i++)
         qq_inv[qq_ind[i]] = i;
done: return rank;
}

/***********************************************************************
*  btf_check_blocks - check structure of matrix A~
*
*  This routine checks that structure of upper block triangular matrix
*  A~ is correct.
*
*  NOTE: For testing/debugging only. */

void btf_check_blocks(BTF *btf)
{     int n = btf->n;
      SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      int *pp_ind = btf->pp_ind;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int *qq_inv = btf->qq_inv;
      int num = btf->num;
      int *beg = btf->beg;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      int i, ii, j, jj, k, size, ptr, end, diag;
      xassert(n > 0);
      /* check permutation matrices P and Q */
      for (k = 1; k <= n; k++)
      {  xassert(1 <= pp_ind[k] && pp_ind[k] <= n);
         xassert(pp_inv[pp_ind[k]] == k);
         xassert(1 <= qq_ind[k] && qq_ind[k] <= n);
         xassert(qq_inv[qq_ind[k]] == k);
      }
      /* check that matrix A~ is upper block triangular with non-zero
       * diagonal */
      xassert(1 <= num && num <= n);
      xassert(beg[1] == 1);
      xassert(beg[num+1] == n+1);
      /* walk thru blocks of A~ */
      for (k = 1; k <= num; k++)
      {  /* determine size of k-th block */
         size = beg[k+1] - beg[k];
         xassert(size >= 1);
         /* walk thru columns of k-th block */
         for (jj = beg[k]; jj < beg[k+1]; jj++)
         {  diag = 0;
            /* jj-th column of A~ = j-th column of A */
            j = qq_ind[jj];
            /* walk thru elements of j-th column of A */
            ptr = ac_ptr[j];
            end = ptr + ac_len[j];
            for (; ptr < end; ptr++)
            {  /* determine row index of a[i,j] */
               i = sv_ind[ptr];
               /* i-th row of A = ii-th row of A~ */
               ii = pp_ind[i];
               /* a~[ii,jj] should not be below k-th block */
               xassert(ii < beg[k+1]);
               if (ii == jj)
               {  /* non-zero diagonal element of A~ encountered */
                  diag = 1;
               }
            }
            xassert(diag);
         }
      }
      return;
}

/***********************************************************************
*  btf_build_a_rows - build matrix A in row-wise format
*
*  This routine builds the row-wise representation of matrix A in the
*  right part of SVA using its column-wise representation.
*
*  The working array len should have at least 1+n elements (len[0] is
*  not used). */

void btf_build_a_rows(BTF *btf, int len[/*1+n*/])
{     int n = btf->n;
      SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int ar_ref = btf->ar_ref;
      int *ar_ptr = &sva->ptr[ar_ref-1];
      int *ar_len = &sva->len[ar_ref-1];
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      int i, j, end, nnz, ptr, ptr1;
      /* calculate the number of non-zeros in each row of matrix A and
       * the total number of non-zeros */
      nnz = 0;
      for (i = 1; i <= n; i++)
         len[i] = 0;
      for (j = 1; j <= n; j++)
      {  nnz += ac_len[j];
         for (end = (ptr = ac_ptr[j]) + ac_len[j]; ptr < end; ptr++)
            len[sv_ind[ptr]]++;
      }
      /* we need at least nnz free locations in SVA */
      if (sva->r_ptr - sva->m_ptr < nnz)
      {  sva_more_space(sva, nnz);
         sv_ind = sva->ind;
         sv_val = sva->val;
      }
      /* reserve locations for rows of matrix A */
      for (i = 1; i <= n; i++)
      {  if (len[i] > 0)
            sva_reserve_cap(sva, ar_ref-1+i, len[i]);
         ar_len[i] = len[i];
      }
      /* walk thru columns of matrix A and build its rows */
      for (j = 1; j <= n; j++)
      {  for (end = (ptr = ac_ptr[j]) + ac_len[j]; ptr < end; ptr++)
         {  i = sv_ind[ptr];
            sv_ind[ptr1 = ar_ptr[i] + (--len[i])] = j;
            sv_val[ptr1] = sv_val[ptr];
         }
      }
      return;
}

/***********************************************************************
*  btf_a_solve - solve system A * x = b
*
*  This routine solves the system A * x = b, where A is the original
*  matrix.
*
*  On entry the array b should contain elements of the right-hand size
*  vector b in locations b[1], ..., b[n], where n is the order of the
*  matrix A. On exit the array x will contain elements of the solution
*  vector in locations x[1], ..., x[n]. Note that the array b will be
*  clobbered on exit.
*
*  The routine also uses locations [1], ..., [max_size] of two working
*  arrays w1 and w2, where max_size is the maximal size of diagonal
*  blocks in BT-factorization (max_size <= n). */

void btf_a_solve(BTF *btf, double b[/*1+n*/], double x[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/])
{     SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int num = btf->num;
      int *beg = btf->beg;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      double *bb = w1;
      double *xx = w2;
      LUF luf;
      int i, j, jj, k, beg_k, flag;
      double t;
      for (k = num; k >= 1; k--)
      {  /* determine order of diagonal block A~[k,k] */
         luf.n = beg[k+1] - (beg_k = beg[k]);
         if (luf.n == 1)
         {  /* trivial case */
            /* solve system A~[k,k] * X[k] = B[k] */
            t = x[qq_ind[beg_k]] =
               b[pp_inv[beg_k]] / btf->vr_piv[beg_k];
            /* substitute X[k] into other equations */
            if (t != 0.0)
            {  int ptr = ac_ptr[qq_ind[beg_k]];
               int end = ptr + ac_len[qq_ind[beg_k]];
               for (; ptr < end; ptr++)
                  b[sv_ind[ptr]] -= sv_val[ptr] * t;
            }
         }
         else
         {  /* general case */
            /* construct B[k] */
            flag = 0;
            for (i = 1; i <= luf.n; i++)
            {  if ((bb[i] = b[pp_inv[i + (beg_k-1)]]) != 0.0)
                  flag = 1;
            }
            /* solve system A~[k,k] * X[k] = B[k] */
            if (!flag)
            {  /* B[k] = 0, so X[k] = 0 */
               for (j = 1; j <= luf.n; j++)
                  x[qq_ind[j + (beg_k-1)]] = 0.0;
               continue;
            }
            luf.sva = sva;
            luf.fr_ref = btf->fr_ref + (beg_k-1);
            luf.fc_ref = btf->fc_ref + (beg_k-1);
            luf.vr_ref = btf->vr_ref + (beg_k-1);
            luf.vr_piv = btf->vr_piv + (beg_k-1);
            luf.vc_ref = btf->vc_ref + (beg_k-1);
            luf.pp_ind = btf->p1_ind + (beg_k-1);
            luf.pp_inv = btf->p1_inv + (beg_k-1);
            luf.qq_ind = btf->q1_ind + (beg_k-1);
            luf.qq_inv = btf->q1_inv + (beg_k-1);
            luf_f_solve(&luf, bb);
            luf_v_solve(&luf, bb, xx);
            /* store X[k] and substitute it into other equations */
            for (j = 1; j <= luf.n; j++)
            {  jj = j + (beg_k-1);
               t = x[qq_ind[jj]] = xx[j];
               if (t != 0.0)
               {  int ptr = ac_ptr[qq_ind[jj]];
                  int end = ptr + ac_len[qq_ind[jj]];
                  for (; ptr < end; ptr++)
                     b[sv_ind[ptr]] -= sv_val[ptr] * t;
               }
            }
         }
      }
      return;
}

/***********************************************************************
*  btf_at_solve - solve system A'* x = b
*
*  This routine solves the system A'* x = b, where A' is a matrix
*  transposed to the original matrix A.
*
*  On entry the array b should contain elements of the right-hand size
*  vector b in locations b[1], ..., b[n], where n is the order of the
*  matrix A. On exit the array x will contain elements of the solution
*  vector in locations x[1], ..., x[n]. Note that the array b will be
*  clobbered on exit.
*
*  The routine also uses locations [1], ..., [max_size] of two working
*  arrays w1 and w2, where max_size is the maximal size of diagonal
*  blocks in BT-factorization (max_size <= n). */

void btf_at_solve(BTF *btf, double b[/*1+n*/], double x[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/])
{     SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int num = btf->num;
      int *beg = btf->beg;
      int ar_ref = btf->ar_ref;
      int *ar_ptr = &sva->ptr[ar_ref-1];
      int *ar_len = &sva->len[ar_ref-1];
      double *bb = w1;
      double *xx = w2;
      LUF luf;
      int i, j, jj, k, beg_k, flag;
      double t;
      for (k = 1; k <= num; k++)
      {  /* determine order of diagonal block A~[k,k] */
         luf.n = beg[k+1] - (beg_k = beg[k]);
         if (luf.n == 1)
         {  /* trivial case */
            /* solve system A~'[k,k] * X[k] = B[k] */
            t = x[pp_inv[beg_k]] =
               b[qq_ind[beg_k]] / btf->vr_piv[beg_k];
            /* substitute X[k] into other equations */
            if (t != 0.0)
            {  int ptr = ar_ptr[pp_inv[beg_k]];
               int end = ptr + ar_len[pp_inv[beg_k]];
               for (; ptr < end; ptr++)
                  b[sv_ind[ptr]] -= sv_val[ptr] * t;
            }
         }
         else
         {  /* general case */
            /* construct B[k] */
            flag = 0;
            for (i = 1; i <= luf.n; i++)
            {  if ((bb[i] = b[qq_ind[i + (beg_k-1)]]) != 0.0)
                  flag = 1;
            }
            /* solve system A~'[k,k] * X[k] = B[k] */
            if (!flag)
            {  /* B[k] = 0, so X[k] = 0 */
               for (j = 1; j <= luf.n; j++)
                  x[pp_inv[j + (beg_k-1)]] = 0.0;
               continue;
            }
            luf.sva = sva;
            luf.fr_ref = btf->fr_ref + (beg_k-1);
            luf.fc_ref = btf->fc_ref + (beg_k-1);
            luf.vr_ref = btf->vr_ref + (beg_k-1);
            luf.vr_piv = btf->vr_piv + (beg_k-1);
            luf.vc_ref = btf->vc_ref + (beg_k-1);
            luf.pp_ind = btf->p1_ind + (beg_k-1);
            luf.pp_inv = btf->p1_inv + (beg_k-1);
            luf.qq_ind = btf->q1_ind + (beg_k-1);
            luf.qq_inv = btf->q1_inv + (beg_k-1);
            luf_vt_solve(&luf, bb, xx);
            luf_ft_solve(&luf, xx);
            /* store X[k] and substitute it into other equations */
            for (j = 1; j <= luf.n; j++)
            {  jj = j + (beg_k-1);
               t = x[pp_inv[jj]] = xx[j];
               if (t != 0.0)
               {  int ptr = ar_ptr[pp_inv[jj]];
                  int end = ptr + ar_len[pp_inv[jj]];
                  for (; ptr < end; ptr++)
                     b[sv_ind[ptr]] -= sv_val[ptr] * t;
               }
            }
         }
      }
      return;
}

/***********************************************************************
*  btf_at_solve1 - solve system A'* y = e' to cause growth in y
*
*  This routine is a special version of btf_at_solve. It solves the
*  system A'* y = e' = e + delta e, where A' is a matrix transposed to
*  the original matrix A, e is the specified right-hand side vector,
*  and delta e is a vector of +1 and -1 chosen to cause growth in the
*  solution vector y.
*
*  On entry the array e should contain elements of the right-hand size
*  vector e in locations e[1], ..., e[n], where n is the order of the
*  matrix A. On exit the array y will contain elements of the solution
*  vector in locations y[1], ..., y[n]. Note that the array e will be
*  clobbered on exit.
*
*  The routine also uses locations [1], ..., [max_size] of two working
*  arrays w1 and w2, where max_size is the maximal size of diagonal
*  blocks in BT-factorization (max_size <= n). */

void btf_at_solve1(BTF *btf, double e[/*1+n*/], double y[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/])
{     SVA *sva = btf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int num = btf->num;
      int *beg = btf->beg;
      int ar_ref = btf->ar_ref;
      int *ar_ptr = &sva->ptr[ar_ref-1];
      int *ar_len = &sva->len[ar_ref-1];
      double *ee = w1;
      double *yy = w2;
      LUF luf;
      int i, j, jj, k, beg_k, ptr, end;
      double e_k, y_k;
      for (k = 1; k <= num; k++)
      {  /* determine order of diagonal block A~[k,k] */
         luf.n = beg[k+1] - (beg_k = beg[k]);
         if (luf.n == 1)
         {  /* trivial case */
            /* determine E'[k] = E[k] + delta E[k] */
            e_k = e[qq_ind[beg_k]];
            e_k = (e_k >= 0.0 ? e_k + 1.0 : e_k - 1.0);
            /* solve system A~'[k,k] * Y[k] = E[k] */
            y_k = y[pp_inv[beg_k]] = e_k / btf->vr_piv[beg_k];
            /* substitute Y[k] into other equations */
            ptr = ar_ptr[pp_inv[beg_k]];
            end = ptr + ar_len[pp_inv[beg_k]];
            for (; ptr < end; ptr++)
               e[sv_ind[ptr]] -= sv_val[ptr] * y_k;
         }
         else
         {  /* general case */
            /* construct E[k] */
            for (i = 1; i <= luf.n; i++)
               ee[i] = e[qq_ind[i + (beg_k-1)]];
            /* solve system A~'[k,k] * Y[k] = E[k] + delta E[k] */
            luf.sva = sva;
            luf.fr_ref = btf->fr_ref + (beg_k-1);
            luf.fc_ref = btf->fc_ref + (beg_k-1);
            luf.vr_ref = btf->vr_ref + (beg_k-1);
            luf.vr_piv = btf->vr_piv + (beg_k-1);
            luf.vc_ref = btf->vc_ref + (beg_k-1);
            luf.pp_ind = btf->p1_ind + (beg_k-1);
            luf.pp_inv = btf->p1_inv + (beg_k-1);
            luf.qq_ind = btf->q1_ind + (beg_k-1);
            luf.qq_inv = btf->q1_inv + (beg_k-1);
            luf_vt_solve1(&luf, ee, yy);
            luf_ft_solve(&luf, yy);
            /* store Y[k] and substitute it into other equations */
            for (j = 1; j <= luf.n; j++)
            {  jj = j + (beg_k-1);
               y_k = y[pp_inv[jj]] = yy[j];
               ptr = ar_ptr[pp_inv[jj]];
               end = ptr + ar_len[pp_inv[jj]];
               for (; ptr < end; ptr++)
                  e[sv_ind[ptr]] -= sv_val[ptr] * y_k;
            }
         }
      }
      return;
}

/***********************************************************************
*  btf_estimate_norm - estimate 1-norm of inv(A)
*
*  This routine estimates 1-norm of inv(A) by one step of inverse
*  iteration for the small singular vector as described in [1]. This
*  involves solving two systems of equations:
*
*     A'* y = e,
*
*     A * z = y,
*
*  where A' is a matrix transposed to A, and e is a vector of +1 and -1
*  chosen to cause growth in y. Then
*
*     estimate 1-norm of inv(A) = (1-norm of z) / (1-norm of y)
*
*  REFERENCES
*
*  1. G.E.Forsythe, M.A.Malcolm, C.B.Moler. Computer Methods for
*     Mathematical Computations. Prentice-Hall, Englewood Cliffs, N.J.,
*     pp. 30-62 (subroutines DECOMP and SOLVE). */

double btf_estimate_norm(BTF *btf, double w1[/*1+n*/], double
      w2[/*1+n*/], double w3[/*1+n*/], double w4[/*1+n*/])
{     int n = btf->n;
      double *e = w1;
      double *y = w2;
      double *z = w1;
      int i;
      double y_norm, z_norm;
      /* compute y = inv(A') * e to cause growth in y */
      for (i = 1; i <= n; i++)
         e[i] = 0.0;
      btf_at_solve1(btf, e, y, w3, w4);
      /* compute 1-norm of y = sum |y[i]| */
      y_norm = 0.0;
      for (i = 1; i <= n; i++)
         y_norm += (y[i] >= 0.0 ? +y[i] : -y[i]);
      /* compute z = inv(A) * y */
      btf_a_solve(btf, y, z, w3, w4);
      /* compute 1-norm of z = sum |z[i]| */
      z_norm = 0.0;
      for (i = 1; i <= n; i++)
         z_norm += (z[i] >= 0.0 ? +z[i] : -z[i]);
      /* estimate 1-norm of inv(A) = (1-norm of z) / (1-norm of y) */
      return z_norm / y_norm;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/btf.h0000644000175100001710000002072100000000000024110 0ustar00runnerdocker00000000000000/* btf.h (sparse block triangular LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef BTF_H
#define BTF_H

#include "sva.h"

/***********************************************************************
*  The structure BTF describes BT-factorization, which is sparse block
*  triangular LU-factorization.
*
*  The BT-factorization has the following format:
*
*     A = P * A~ * Q,                                                (1)
*
*  where A is a given (unsymmetric) square matrix, A~ is an upper block
*  triangular matrix (see below), P and Q are permutation matrices. All
*  the matrices have the same order n.
*
*  The matrix A~, which is a permuted version of the original matrix A,
*  has the following structure:
*
*     A~[1,1]  A~[1,2]  ...  A~[1,num-1]      A~[1,num]
*
*              A~[2,2]  ...  A~[2,num-1]      A~[2,num]
*
*                       . . . . . . . . .                            (2)
*
*                        A~[num-1,num-1]  A~[num-1,num]
*
*                                           A~[num,num]
*
*  where A~[i,j] is a submatrix called a "block," num is the number of
*  blocks. Each diagonal block A~[k,k] is a non-singular square matrix,
*  and each subdiagonal block A~[i,j], i > j, is a zero submatrix, thus
*  A~ is an upper block triangular matrix.
*
*  Permutation matrices P and Q are stored in ordinary arrays in both
*  row- and column-like formats.
*
*  The original matrix A is stored in both row- and column-wise sparse
*  formats in the associated sparse vector area (SVA). Should note that
*  elements of all diagonal blocks A~[k,k] in matrix A are set to zero
*  (i.e. removed), so only elements of non-diagonal blocks are stored.
*
*  Each diagonal block A~[k,k], 1 <= k <= num, is stored in the form of
*  LU-factorization (see the module LUF). */

typedef struct BTF BTF;

struct BTF
{     /* sparse block triangular LU-factorization */
      int n;
      /* order of matrices A, A~, P, Q */
      SVA *sva;
      /* associated sparse vector area used to store rows and columns
       * of matrix A as well as sparse vectors for LU-factorizations of
       * all diagonal blocks A~[k,k] */
      /*--------------------------------------------------------------*/
      /* matrix P */
      int *pp_ind; /* int pp_ind[1+n]; */
      /* pp_ind[i] = j means that P[i,j] = 1 */
      int *pp_inv; /* int pp_inv[1+n]; */
      /* pp_inv[j] = i means that P[i,j] = 1 */
      /* if i-th row of matrix A is i'-th row of matrix A~, then
       * pp_ind[i] = i' and pp_inv[i'] = i */
      /*--------------------------------------------------------------*/
      /* matrix Q */
      int *qq_ind; /* int qq_ind[1+n]; */
      /* qq_ind[i] = j means that Q[i,j] = 1 */
      int *qq_inv; /* int qq_inv[1+n]; */
      /* qq_inv[j] = i means that Q[i,j] = 1 */
      /* if j-th column of matrix A is j'-th column of matrix A~, then
       * qq_ind[j'] = j and qq_inv[j] = j' */
      /*--------------------------------------------------------------*/
      /* block triangular structure of matrix A~ */
      int num;
      /* number of diagonal blocks, 1 <= num <= n */
      int *beg; /* int beg[1+num+1]; */
      /* beg[0] is not used;
       * beg[k], 1 <= k <= num, is index of first row/column of k-th
       * block of matrix A~;
       * beg[num+1] is always n+1;
       * note that order (size) of k-th diagonal block can be computed
       * as beg[k+1] - beg[k] */
      /*--------------------------------------------------------------*/
      /* original matrix A in row-wise format */
      /* NOTE: elements of all diagonal blocks A~[k,k] are removed */
      int ar_ref;
      /* reference number of sparse vector in SVA, which is the first
       * row of matrix A */
#if 0 + 0
      int *ar_ptr = &sva->ptr[ar_ref-1];
      /* ar_ptr[0] is not used;
       * ar_ptr[i], 1 <= i <= n, is pointer to i-th row in SVA */
      int *ar_len = &sva->ptr[ar_ref-1];
      /* ar_len[0] is not used;
       * ar_len[i], 1 <= i <= n, is length of i-th row */
#endif
      /*--------------------------------------------------------------*/
      /* original matrix A in column-wise format */
      /* NOTE: elements of all diagonal blocks A~[k,k] are removed */
      int ac_ref;
      /* reference number of sparse vector in SVA, which is the first
       * column of matrix A */
#if 0 + 0
      int *ac_ptr = &sva->ptr[ac_ref-1];
      /* ac_ptr[0] is not used;
       * ac_ptr[j], 1 <= j <= n, is pointer to j-th column in SVA */
      int *ac_len = &sva->ptr[ac_ref-1];
      /* ac_len[0] is not used;
       * ac_len[j], 1 <= j <= n, is length of j-th column */
#endif
      /*--------------------------------------------------------------*/
      /* LU-factorizations of diagonal blocks A~[k,k] */
      /* to decrease overhead expenses similar arrays for all LUFs are
       * packed into a single array; for example, elements fr_ptr[1],
       * ..., fr_ptr[n1], where n1 = beg[2] - beg[1], are related to
       * LUF for first diagonal block A~[1,1], elements fr_ptr[n1+1],
       * ..., fr_ptr[n1+n2], where n2 = beg[3] - beg[2], are related to
       * LUF for second diagonal block A~[2,2], etc.; in other words,
       * elements related to LUF for k-th diagonal block A~[k,k] have
       * indices beg[k], beg[k]+1, ..., beg[k+1]-1 */
      /* for details about LUF see description of the LUF module */
      int fr_ref;
      /* reference number of sparse vector in SVA, which is the first
         row of matrix F for first diagonal block A~[1,1] */
      int fc_ref;
      /* reference number of sparse vector in SVA, which is the first
         column of matrix F for first diagonal block A~[1,1] */
      int vr_ref;
      /* reference number of sparse vector in SVA, which is the first
         row of matrix V for first diagonal block A~[1,1] */
      double *vr_piv; /* double vr_piv[1+n]; */
      /* vr_piv[0] is not used;
         vr_piv[1,...,n] are pivot elements for all diagonal blocks */
      int vc_ref;
      /* reference number of sparse vector in SVA, which is the first
         column of matrix V for first diagonal block A~[1,1] */
      int *p1_ind; /* int p1_ind[1+n]; */
      int *p1_inv; /* int p1_inv[1+n]; */
      int *q1_ind; /* int q1_ind[1+n]; */
      int *q1_inv; /* int q1_inv[1+n]; */
      /* permutation matrices P and Q for all diagonal blocks */
};

#define btf_store_a_cols _glp_btf_store_a_cols
int btf_store_a_cols(BTF *btf, int (*col)(void *info, int j, int ind[],
      double val[]), void *info, int ind[], double val[]);
/* store pattern of matrix A in column-wise format */

#define btf_make_blocks _glp_btf_make_blocks
int btf_make_blocks(BTF *btf);
/* permutations to block triangular form */

#define btf_check_blocks _glp_btf_check_blocks
void btf_check_blocks(BTF *btf);
/* check structure of matrix A~ */

#define btf_build_a_rows _glp_btf_build_a_rows
void btf_build_a_rows(BTF *btf, int len[/*1+n*/]);
/* build matrix A in row-wise format */

#define btf_a_solve _glp_btf_a_solve
void btf_a_solve(BTF *btf, double b[/*1+n*/], double x[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/]);
/* solve system A * x = b */

#define btf_at_solve _glp_btf_at_solve
void btf_at_solve(BTF *btf, double b[/*1+n*/], double x[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/]);
/* solve system A'* x = b */

#define btf_at_solve1 _glp_btf_at_solve1
void btf_at_solve1(BTF *btf, double e[/*1+n*/], double y[/*1+n*/],
      double w1[/*1+n*/], double w2[/*1+n*/]);
/* solve system A'* y = e' to cause growth in y */

#define btf_estimate_norm _glp_btf_estimate_norm
double btf_estimate_norm(BTF *btf, double w1[/*1+n*/], double
      w2[/*1+n*/], double w3[/*1+n*/], double w4[/*1+n*/]);
/* estimate 1-norm of inv(A) */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/btfint.c0000644000175100001710000003416700000000000024627 0ustar00runnerdocker00000000000000/* btfint.c (interface to BT-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "btfint.h"

BTFINT *btfint_create(void)
{     /* create interface to BT-factorization */
      BTFINT *fi;
      fi = talloc(1, BTFINT);
      fi->n_max = 0;
      fi->valid = 0;
      fi->sva = NULL;
      fi->btf = NULL;
      fi->sgf = NULL;
      fi->sva_n_max = fi->sva_size = 0;
      fi->delta_n0 = fi->delta_n = 0;
      fi->sgf_piv_tol = 0.10;
      fi->sgf_piv_lim = 4;
      fi->sgf_suhl = 1;
      fi->sgf_eps_tol = DBL_EPSILON;
      return fi;
}

static void factorize_triv(BTFINT *fi, int k, int (*col)(void *info,
      int j, int ind[], double val[]), void *info)
{     /* compute LU-factorization of diagonal block A~[k,k] and store
       * corresponding columns of matrix A except elements of A~[k,k]
       * (trivial case when the block has unity size) */
      SVA *sva = fi->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      BTF *btf = fi->btf;
      int *pp_inv = btf->pp_inv;
      int *qq_ind = btf->qq_ind;
      int *beg = btf->beg;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      SGF *sgf = fi->sgf;
      int *ind = (int *)sgf->vr_max; /* working array */
      double *val = sgf->work; /* working array */
      int i, j, t, len, ptr, beg_k;
      /* diagonal block A~[k,k] has the only element in matrix A~,
       * which is a~[beg[k],beg[k]] = a[i,j] */
      beg_k = beg[k];
      i = pp_inv[beg_k];
      j = qq_ind[beg_k];
      /* get j-th column of A */
      len = col(info, j, ind, val);
      /* find element a[i,j] = a~[beg[k],beg[k]] in j-th column */
      for (t = 1; t <= len; t++)
      {  if (ind[t] == i)
            break;
      }
      xassert(t <= len);
      /* compute LU-factorization of diagonal block A~[k,k], where
       * F = (1), V = (a[i,j]), P = Q = (1) (see the module LUF) */
#if 1 /* FIXME */
      xassert(val[t] != 0.0);
#endif
      btf->vr_piv[beg_k] = val[t];
      btf->p1_ind[beg_k] = btf->p1_inv[beg_k] = 1;
      btf->q1_ind[beg_k] = btf->q1_inv[beg_k] = 1;
      /* remove element a[i,j] = a~[beg[k],beg[k]] from j-th column */
      memmove(&ind[t], &ind[t+1], (len-t) * sizeof(int));
      memmove(&val[t], &val[t+1], (len-t) * sizeof(double));
      len--;
      /* and store resulting j-th column of A into BTF */
      if (len > 0)
      {  /* reserve locations for j-th column of A */
         if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_reserve_cap(sva, ac_ref+(j-1), len);
         /* store j-th column of A (except elements of A~[k,k]) */
         ptr = ac_ptr[j];
         memcpy(&sv_ind[ptr], &ind[1], len * sizeof(int));
         memcpy(&sv_val[ptr], &val[1], len * sizeof(double));
         ac_len[j] = len;
      }
      return;
}

static int factorize_block(BTFINT *fi, int k, int (*col)(void *info,
      int j, int ind[], double val[]), void *info)
{     /* compute LU-factorization of diagonal block A~[k,k] and store
       * corresponding columns of matrix A except elements of A~[k,k]
       * (general case) */
      SVA *sva = fi->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      BTF *btf = fi->btf;
      int *pp_ind = btf->pp_ind;
      int *qq_ind = btf->qq_ind;
      int *beg = btf->beg;
      int ac_ref = btf->ac_ref;
      int *ac_ptr = &sva->ptr[ac_ref-1];
      int *ac_len = &sva->len[ac_ref-1];
      SGF *sgf = fi->sgf;
      int *ind = (int *)sgf->vr_max; /* working array */
      double *val = sgf->work; /* working array */
      LUF luf;
      int *vc_ptr, *vc_len, *vc_cap;
      int i, ii, j, jj, t, len, cnt, ptr, beg_k;
      /* construct fake LUF for LU-factorization of A~[k,k] */
      sgf->luf = &luf;
      luf.n = beg[k+1] - (beg_k = beg[k]);
      luf.sva = sva;
      luf.fr_ref = btf->fr_ref + (beg_k-1);
      luf.fc_ref = btf->fc_ref + (beg_k-1);
      luf.vr_ref = btf->vr_ref + (beg_k-1);
      luf.vr_piv = btf->vr_piv + (beg_k-1);
      luf.vc_ref = btf->vc_ref + (beg_k-1);
      luf.pp_ind = btf->p1_ind + (beg_k-1);
      luf.pp_inv = btf->p1_inv + (beg_k-1);
      luf.qq_ind = btf->q1_ind + (beg_k-1);
      luf.qq_inv = btf->q1_inv + (beg_k-1);
      /* process columns of k-th block of matrix A~ */
      vc_ptr = &sva->ptr[luf.vc_ref-1];
      vc_len = &sva->len[luf.vc_ref-1];
      vc_cap = &sva->cap[luf.vc_ref-1];
      for (jj = 1; jj <= luf.n; jj++)
      {  /* jj-th column of A~ = j-th column of A */
         j = qq_ind[jj + (beg_k-1)];
         /* get j-th column of A */
         len = col(info, j, ind, val);
         /* move elements of diagonal block A~[k,k] to the beginning of
          * the column list */
         cnt = 0;
         for (t = 1; t <= len; t++)
         {  /* i = row index of element a[i,j] */
            i = ind[t];
            /* i-th row of A = ii-th row of A~ */
            ii = pp_ind[i];
            if (ii >= beg_k)
            {  /* a~[ii,jj] = a[i,j] is in diagonal block A~[k,k] */
               double temp;
               cnt++;
               ind[t] = ind[cnt];
               ind[cnt] = ii - (beg_k-1); /* local index */
               temp = val[t], val[t] = val[cnt], val[cnt] = temp;
            }
         }
         /* first cnt elements in the column list give jj-th column of
          * diagonal block A~[k,k], which is initial matrix V in LUF */
         /* enlarge capacity of jj-th column of V = A~[k,k] */
         if (vc_cap[jj] < cnt)
         {  if (sva->r_ptr - sva->m_ptr < cnt)
            {  sva_more_space(sva, cnt);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, luf.vc_ref+(jj-1), cnt, 0);
         }
         /* store jj-th column of V = A~[k,k] */
         ptr = vc_ptr[jj];
         memcpy(&sv_ind[ptr], &ind[1], cnt * sizeof(int));
         memcpy(&sv_val[ptr], &val[1], cnt * sizeof(double));
         vc_len[jj] = cnt;
         /* other (len-cnt) elements in the column list are stored in
          * j-th column of the original matrix A */
         len -= cnt;
         if (len > 0)
         {  /* reserve locations for j-th column of A */
            if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_reserve_cap(sva, ac_ref-1+j, len);
            /* store j-th column of A (except elements of A~[k,k]) */
            ptr = ac_ptr[j];
            memcpy(&sv_ind[ptr], &ind[cnt+1], len * sizeof(int));
            memcpy(&sv_val[ptr], &val[cnt+1], len * sizeof(double));
            ac_len[j] = len;
         }
      }
      /* compute LU-factorization of diagonal block A~[k,k]; may note
       * that A~[k,k] is irreducible (strongly connected), so singleton
       * phase will have no effect */
      k = sgf_factorize(sgf, 0 /* disable singleton phase */);
      /* now left (dynamic) part of SVA should be empty (wichtig!) */
      xassert(sva->m_ptr == 1);
      return k;
}

int btfint_factorize(BTFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info)
{     /* compute BT-factorization of specified matrix A */
      SVA *sva;
      BTF *btf;
      SGF *sgf;
      int k, rank;
      xassert(n > 0);
      fi->valid = 0;
      /* create sparse vector area (SVA), if necessary */
      sva = fi->sva;
      if (sva == NULL)
      {  int sva_n_max = fi->sva_n_max;
         int sva_size = fi->sva_size;
         if (sva_n_max == 0)
            sva_n_max = 6 * n;
         if (sva_size == 0)
            sva_size = 10 * n;
         sva = fi->sva = sva_create_area(sva_n_max, sva_size);
      }
      /* allocate/reallocate underlying objects, if necessary */
      if (fi->n_max < n)
      {  int n_max = fi->n_max;
         if (n_max == 0)
            n_max = fi->n_max = n + fi->delta_n0;
         else
            n_max = fi->n_max = n + fi->delta_n;
         xassert(n_max >= n);
         /* allocate/reallocate block triangular factorization (BTF) */
         btf = fi->btf;
         if (btf == NULL)
         {  btf = fi->btf = talloc(1, BTF);
            memset(btf, 0, sizeof(BTF));
            btf->sva = sva;
         }
         else
         {  tfree(btf->pp_ind);
            tfree(btf->pp_inv);
            tfree(btf->qq_ind);
            tfree(btf->qq_inv);
            tfree(btf->beg);
            tfree(btf->vr_piv);
            tfree(btf->p1_ind);
            tfree(btf->p1_inv);
            tfree(btf->q1_ind);
            tfree(btf->q1_inv);
         }
         btf->pp_ind = talloc(1+n_max, int);
         btf->pp_inv = talloc(1+n_max, int);
         btf->qq_ind = talloc(1+n_max, int);
         btf->qq_inv = talloc(1+n_max, int);
         btf->beg = talloc(1+n_max+1, int);
         btf->vr_piv = talloc(1+n_max, double);
         btf->p1_ind = talloc(1+n_max, int);
         btf->p1_inv = talloc(1+n_max, int);
         btf->q1_ind = talloc(1+n_max, int);
         btf->q1_inv = talloc(1+n_max, int);
         /* allocate/reallocate factorizer workspace (SGF) */
         /* (note that for SGF we could use the size of largest block
          * rather than n_max) */
         sgf = fi->sgf;
         sgf = fi->sgf;
         if (sgf == NULL)
         {  sgf = fi->sgf = talloc(1, SGF);
            memset(sgf, 0, sizeof(SGF));
         }
         else
         {  tfree(sgf->rs_head);
            tfree(sgf->rs_prev);
            tfree(sgf->rs_next);
            tfree(sgf->cs_head);
            tfree(sgf->cs_prev);
            tfree(sgf->cs_next);
            tfree(sgf->vr_max);
            tfree(sgf->flag);
            tfree(sgf->work);
         }
         sgf->rs_head = talloc(1+n_max, int);
         sgf->rs_prev = talloc(1+n_max, int);
         sgf->rs_next = talloc(1+n_max, int);
         sgf->cs_head = talloc(1+n_max, int);
         sgf->cs_prev = talloc(1+n_max, int);
         sgf->cs_next = talloc(1+n_max, int);
         sgf->vr_max = talloc(1+n_max, double);
         sgf->flag = talloc(1+n_max, char);
         sgf->work = talloc(1+n_max, double);
      }
      btf = fi->btf;
      btf->n = n;
      sgf = fi->sgf;
#if 1 /* FIXME */
      /* initialize SVA */
      sva->n = 0;
      sva->m_ptr = 1;
      sva->r_ptr = sva->size + 1;
      sva->head = sva->tail = 0;
#endif
      /* store pattern of original matrix A in column-wise format */
      btf->ac_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf_store_a_cols(btf, col, info, btf->pp_ind, btf->vr_piv);
#ifdef GLP_DEBUG
      sva_check_area(sva);
#endif
      /* analyze pattern of original matrix A and determine permutation
       * matrices P and Q such that A = P * A~* Q, where A~ is an upper
       * block triangular matrix */
      rank = btf_make_blocks(btf);
      if (rank != n)
      {  /* original matrix A is structurally singular */
         return 1;
      }
#ifdef GLP_DEBUG
      btf_check_blocks(btf);
#endif
#if 1 /* FIXME */
      /* initialize SVA */
      sva->n = 0;
      sva->m_ptr = 1;
      sva->r_ptr = sva->size + 1;
      sva->head = sva->tail = 0;
#endif
      /* allocate sparse vectors in SVA */
      btf->ar_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf->ac_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf->fr_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf->fc_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf->vr_ref = sva_alloc_vecs(btf->sva, btf->n);
      btf->vc_ref = sva_alloc_vecs(btf->sva, btf->n);
      /* setup factorizer control parameters */
      sgf->updat = 0; /* wichtig! */
      sgf->piv_tol = fi->sgf_piv_tol;
      sgf->piv_lim = fi->sgf_piv_lim;
      sgf->suhl = fi->sgf_suhl;
      sgf->eps_tol = fi->sgf_eps_tol;
      /* compute LU-factorizations of diagonal blocks A~[k,k] and also
       * store corresponding columns of matrix A except elements of all
       * blocks A~[k,k] */
      for (k = 1; k <= btf->num; k++)
      {  if (btf->beg[k+1] - btf->beg[k] == 1)
         {  /* trivial case (A~[k,k] has unity order) */
            factorize_triv(fi, k, col, info);
         }
         else
         {  /* general case */
            if (factorize_block(fi, k, col, info) != 0)
               return 2; /* factorization of A~[k,k] failed */
         }
      }
#ifdef GLP_DEBUG
      sva_check_area(sva);
#endif
      /* build row-wise representation of matrix A */
      btf_build_a_rows(fi->btf, fi->sgf->rs_head);
#ifdef GLP_DEBUG
      sva_check_area(sva);
#endif
      /* BT-factorization has been successfully computed */
      fi->valid = 1;
      return 0;
}

void btfint_delete(BTFINT *fi)
{     /* delete interface to BT-factorization */
      SVA *sva = fi->sva;
      BTF *btf = fi->btf;
      SGF *sgf = fi->sgf;
      if (sva != NULL)
         sva_delete_area(sva);
      if (btf != NULL)
      {  tfree(btf->pp_ind);
         tfree(btf->pp_inv);
         tfree(btf->qq_ind);
         tfree(btf->qq_inv);
         tfree(btf->beg);
         tfree(btf->vr_piv);
         tfree(btf->p1_ind);
         tfree(btf->p1_inv);
         tfree(btf->q1_ind);
         tfree(btf->q1_inv);
         tfree(btf);
      }
      if (sgf != NULL)
      {  tfree(sgf->rs_head);
         tfree(sgf->rs_prev);
         tfree(sgf->rs_next);
         tfree(sgf->cs_head);
         tfree(sgf->cs_prev);
         tfree(sgf->cs_next);
         tfree(sgf->vr_max);
         tfree(sgf->flag);
         tfree(sgf->work);
         tfree(sgf);
      }
      tfree(fi);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/btfint.h0000644000175100001710000000452500000000000024627 0ustar00runnerdocker00000000000000/* btfint.h (interface to BT-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef BTFINT_H
#define BTFINT_H

#include "btf.h"
#include "sgf.h"

typedef struct BTFINT BTFINT;

struct BTFINT
{     /* interface to BT-factorization */
      int n_max;
      /* maximal value of n (increased automatically) */
      int valid;
      /* factorization is valid only if this flag is set */
      SVA *sva;
      /* sparse vector area (SVA) */
      BTF *btf;
      /* sparse block triangular LU-factorization */
      SGF *sgf;
      /* sparse Gaussian factorizer workspace */
      /*--------------------------------------------------------------*/
      /* control parameters */
      int sva_n_max, sva_size;
      /* parameters passed to sva_create_area */
      int delta_n0, delta_n;
      /* if n_max = 0, set n_max = n + delta_n0
       * if n_max < n, set n_max = n + delta_n */
      double sgf_piv_tol;
      int sgf_piv_lim;
      int sgf_suhl;
      double sgf_eps_tol;
      /* factorizer control parameters */
};

#define btfint_create _glp_btfint_create
BTFINT *btfint_create(void);
/* create interface to BT-factorization */

#define btfint_factorize _glp_btfint_factorize
int btfint_factorize(BTFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info);
/* compute BT-factorization of specified matrix A */

#define btfint_delete _glp_btfint_delete
void btfint_delete(BTFINT *fi);
/* delete interface to BT-factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/fhv.c0000644000175100001710000005465200000000000024125 0ustar00runnerdocker00000000000000/* fhv.c (sparse updatable FHV-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "fhv.h"

/***********************************************************************
*  fhv_ft_update - update FHV-factorization (Forrest-Tomlin)
*
*  This routine updates FHV-factorization of the original matrix A
*  after replacing its j-th column by a new one. The routine is based
*  on the method proposed by Forrest and Tomlin [1].
*
*  The parameter q specifies the number of column of A, which has been
*  replaced, 1 <= q <= n, where n is the order of A.
*
*  Row indices and numerical values of non-zero elements of the new
*  j-th column of A should be placed in locations aq_ind[1], ...,
*  aq_ind[aq_len] and aq_val[1], ..., aq_val[aq_len], respectively,
*  where aq_len is the number of non-zeros. Neither zero nor duplicate
*  elements are allowed.
*
*  The working arrays ind, val, and work should have at least 1+n
*  elements (0-th elements are not used).
*
*  RETURNS
*
*  0  The factorization has been successfully updated.
*
*  1  New matrix U = P'* V * Q' is upper triangular with zero diagonal
*     element u[s,s]. (Elimination was not performed.)
*
*  2  New matrix U = P'* V * Q' is upper triangular, and its diagonal
*     element u[s,s] or u[t,t] is too small in magnitude. (Elimination
*     was not performed.)
*
*  3  The same as 2, but after performing elimination.
*
*  4  The factorization has not been updated, because maximal number of
*     updates has been reached.
*
*  5  Accuracy test failed for the updated factorization.
*
*  BACKGROUND
*
*  The routine is based on the updating method proposed by Forrest and
*  Tomlin [1].
*
*  Let q-th column of the original matrix A have been replaced by new
*  column A[q]. Then, to keep the equality A = F * H * V, q-th column
*  of matrix V should be replaced by column V[q] = inv(F * H) * A[q].
*  From the standpoint of matrix U = P'* V * Q' such replacement is
*  equivalent to replacement of s-th column of matrix U, where s is
*  determined from q by permutation matrix Q. Thus, matrix U loses its
*  upper triangular form and becomes the following:
*
*        1   s       t   n
*     1  x x * x x x x x x
*        . x * x x x x x x
*     s  . . * x x x x x x
*        . . * x x x x x x
*        . . * . x x x x x
*        . . * . . x x x x
*     t  . . * . . . x x x
*        . . . . . . . x x
*     n  . . . . . . . . x
*
*  where t is largest row index of a non-zero element in s-th column.
*
*  The routine makes matrix U upper triangular as follows. First, it
*  moves rows and columns s+1, ..., t by one position to the left and
*  upwards, resp., and moves s-th row and s-th column to position t.
*  Due to such symmetric permutations matrix U becomes the following
*  (note that all diagonal elements remain on the diagonal, and element
*  u[s,s] becomes u[t,t]):
*
*        1   s       t   n
*     1  x x x x x x * x x
*        . x x x x x * x x
*     s  . . x x x x * x x
*        . . . x x x * x x
*        . . . . x x * x x
*        . . . . . x * x x
*     t  . . x x x x * x x
*        . . . . . . . x x
*     n  . . . . . . . . x
*
*  Then the routine performs gaussian elimination to eliminate
*  subdiagonal elements u[t,s], ..., u[t,t-1] using diagonal elements
*  u[s,s], ..., u[t-1,t-1] as pivots. During the elimination process
*  the routine permutes neither rows nor columns, so only t-th row is
*  changed. Should note that actually all operations are performed on
*  matrix V = P * U * Q, since matrix U is not stored.
*
*  To keep the equality A = F * H * V, the routine appends new row-like
*  factor H[k] to matrix H, and every time it applies elementary
*  gaussian transformation to eliminate u[t,j'] = v[p,j] using pivot
*  u[j',j'] = v[i,j], it also adds new element f[p,j] = v[p,j] / v[i,j]
*  (gaussian multiplier) to factor H[k], which initially is a unity
*  matrix. At the end of elimination process the row-like factor H[k]
*  may look as follows:
*
*        1               n          1   s       t   n
*     1  1 . . . . . . . .       1  1 . . . . . . . .
*        . 1 . . . . . . .          . 1 . . . . . . .
*        . . 1 . . . . . .       s  . . 1 . . . . . .
*     p  . x x 1 . x . x .          . . . 1 . . . . .
*        . . . . 1 . . . .          . . . . 1 . . . .
*        . . . . . 1 . . .          . . . . . 1 . . .
*        . . . . . . 1 . .       t  . . x x x x 1 . .
*        . . . . . . . 1 .          . . . . . . . 1 .
*     n  . . . . . . . . 1       n  . . . . . . . . 1
*
*              H[k]                 inv(P) * H[k] * P
*
*  If, however, s = t, no elimination is needed, in which case no new
*  row-like factor is created.
*
*  REFERENCES
*
*  1. J.J.H.Forrest and J.A.Tomlin, "Updated triangular factors of the
*     basis to maintain sparsity in the product form simplex method,"
*     Math. Prog. 2 (1972), pp. 263-78. */

int fhv_ft_update(FHV *fhv, int q, int aq_len, const int aq_ind[],
      const double aq_val[], int ind[/*1+n*/], double val[/*1+n*/],
      double work[/*1+n*/])
{     LUF *luf = fhv->luf;
      int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int *vr_cap = &sva->cap[vr_ref-1];
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *vc_cap = &sva->cap[vc_ref-1];
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int *hh_ind = fhv->hh_ind;
      int hh_ref = fhv->hh_ref;
      int *hh_ptr = &sva->ptr[hh_ref-1];
      int *hh_len = &sva->len[hh_ref-1];
#if 1 /* FIXME */
      const double eps_tol = DBL_EPSILON;
      const double vpq_tol = 1e-5;
      const double err_tol = 1e-10;
#endif
      int end, i, i_end, i_ptr, j, j_end, j_ptr, k, len, nnz, p, p_end,
         p_ptr, ptr, q_end, q_ptr, s, t;
      double f, vpq, temp;
      /*--------------------------------------------------------------*/
      /* replace current q-th column of matrix V by new one           */
      /*--------------------------------------------------------------*/
      xassert(1 <= q && q <= n);
      /* convert new q-th column of matrix A to dense format */
      for (i = 1; i <= n; i++)
         val[i] = 0.0;
      xassert(0 <= aq_len && aq_len <= n);
      for (k = 1; k <= aq_len; k++)
      {  i = aq_ind[k];
         xassert(1 <= i && i <= n);
         xassert(val[i] == 0.0);
         xassert(aq_val[k] != 0.0);
         val[i] = aq_val[k];
      }
      /* compute new q-th column of matrix V:
       * new V[q] = inv(F * H) * (new A[q]) */
      luf->pp_ind = fhv->p0_ind;
      luf->pp_inv = fhv->p0_inv;
      luf_f_solve(luf, val);
      luf->pp_ind = pp_ind;
      luf->pp_inv = pp_inv;
      fhv_h_solve(fhv, val);
      /* q-th column of V = s-th column of U */
      s = qq_inv[q];
      /* determine row number of element v[p,q] that corresponds to
       * diagonal element u[s,s] */
      p = pp_inv[s];
      /* convert new q-th column of V to sparse format;
       * element v[p,q] = u[s,s] is not included in the element list
       * and stored separately */
      vpq = 0.0;
      len = 0;
      for (i = 1; i <= n; i++)
      {  temp = val[i];
#if 1 /* FIXME */
         if (-eps_tol < temp && temp < +eps_tol)
#endif
            /* nop */;
         else if (i == p)
            vpq = temp;
         else
         {  ind[++len] = i;
            val[len] = temp;
         }
      }
      /* clear q-th column of matrix V */
      for (q_end = (q_ptr = vc_ptr[q]) + vc_len[q];
         q_ptr < q_end; q_ptr++)
      {  /* get row index of v[i,q] */
         i = sv_ind[q_ptr];
         /* find and remove v[i,q] from i-th row */
         for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
            sv_ind[i_ptr] != q; i_ptr++)
            /* nop */;
         xassert(i_ptr < i_end);
         sv_ind[i_ptr] = sv_ind[i_end-1];
         sv_val[i_ptr] = sv_val[i_end-1];
         vr_len[i]--;
      }
      /* now q-th column of matrix V is empty */
      vc_len[q] = 0;
      /* put new q-th column of V (except element v[p,q] = u[s,s]) in
       * column-wise format */
      if (len > 0)
      {  if (vc_cap[q] < len)
         {  if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, vc_ref-1+q, len, 0);
         }
         ptr = vc_ptr[q];
         memcpy(&sv_ind[ptr], &ind[1], len * sizeof(int));
         memcpy(&sv_val[ptr], &val[1], len * sizeof(double));
         vc_len[q] = len;
      }
      /* put new q-th column of V (except element v[p,q] = u[s,s]) in
       * row-wise format, and determine largest row number t such that
       * u[s,t] != 0 */
      t = (vpq == 0.0 ? 0 : s);
      for (k = 1; k <= len; k++)
      {  /* get row index of v[i,q] */
         i = ind[k];
         /* put v[i,q] to i-th row */
         if (vr_cap[i] == vr_len[i])
         {  /* reserve extra locations in i-th row to reduce further
             * relocations of that row */
#if 1 /* FIXME */
            int need = vr_len[i] + 5;
#endif
            if (sva->r_ptr - sva->m_ptr < need)
            {  sva_more_space(sva, need);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, vr_ref-1+i, need, 0);
         }
         sv_ind[ptr = vr_ptr[i] + (vr_len[i]++)] = q;
         sv_val[ptr] = val[k];
         /* v[i,q] is non-zero; increase t */
         if (t < pp_ind[i])
            t = pp_ind[i];
      }
      /*--------------------------------------------------------------*/
      /* check if matrix U is already upper triangular                */
      /*--------------------------------------------------------------*/
      /* check if there is a spike in s-th column of matrix U, which
       * is q-th column of matrix V */
      if (s >= t)
      {  /* no spike; matrix U is already upper triangular */
         /* store its diagonal element u[s,s] = v[p,q] */
         vr_piv[p] = vpq;
         if (s > t)
         {  /* matrix U is structurally singular, because its diagonal
             * element u[s,s] = v[p,q] is exact zero */
            xassert(vpq == 0.0);
            return 1;
         }
#if 1 /* FIXME */
         else if (-vpq_tol < vpq && vpq < +vpq_tol)
#endif
         {  /* matrix U is not well conditioned, because its diagonal
             * element u[s,s] = v[p,q] is too small in magnitude */
            return 2;
         }
         else
         {  /* normal case */
            return 0;
         }
      }
      /*--------------------------------------------------------------*/
      /* perform implicit symmetric permutations of rows and columns  */
      /* of matrix U                                                  */
      /*--------------------------------------------------------------*/
      /* currently v[p,q] = u[s,s] */
      xassert(p == pp_inv[s] && q == qq_ind[s]);
      for (k = s; k < t; k++)
      {  pp_ind[pp_inv[k] = pp_inv[k+1]] = k;
         qq_inv[qq_ind[k] = qq_ind[k+1]] = k;
      }
      /* now v[p,q] = u[t,t] */
      pp_ind[pp_inv[t] = p] = qq_inv[qq_ind[t] = q] = t;
      /*--------------------------------------------------------------*/
      /* check if matrix U is already upper triangular                */
      /*--------------------------------------------------------------*/
      /* check if there is a spike in t-th row of matrix U, which is
       * p-th row of matrix V */
      for (p_end = (p_ptr = vr_ptr[p]) + vr_len[p];
         p_ptr < p_end; p_ptr++)
      {  if (qq_inv[sv_ind[p_ptr]] < t)
            break; /* spike detected */
      }
      if (p_ptr == p_end)
      {  /* no spike; matrix U is already upper triangular */
         /* store its diagonal element u[t,t] = v[p,q] */
         vr_piv[p] = vpq;
#if 1 /* FIXME */
         if (-vpq_tol < vpq && vpq < +vpq_tol)
#endif
         {  /* matrix U is not well conditioned, because its diagonal
             * element u[t,t] = v[p,q] is too small in magnitude */
            return 2;
         }
         else
         {  /* normal case */
            return 0;
         }
      }
      /*--------------------------------------------------------------*/
      /* copy p-th row of matrix V, which is t-th row of matrix U, to */
      /* working array                                                */
      /*--------------------------------------------------------------*/
      /* copy p-th row of matrix V, including element v[p,q] = u[t,t],
       * to the working array in dense format and remove these elements
       * from matrix V; since no pivoting is used, only this row will
       * change during elimination */
      for (j = 1; j <= n; j++)
         work[j] = 0.0;
      work[q] = vpq;
      for (p_end = (p_ptr = vr_ptr[p]) + vr_len[p];
         p_ptr < p_end; p_ptr++)
      {  /* get column index of v[p,j] and store this element to the
          * working array */
         work[j = sv_ind[p_ptr]] = sv_val[p_ptr];
         /* find and remove v[p,j] from j-th column */
         for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
            sv_ind[j_ptr] != p; j_ptr++)
            /* nop */;
         xassert(j_ptr < j_end);
         sv_ind[j_ptr] = sv_ind[j_end-1];
         sv_val[j_ptr] = sv_val[j_end-1];
         vc_len[j]--;
      }
      /* now p-th row of matrix V is temporarily empty */
      vr_len[p] = 0;
      /*--------------------------------------------------------------*/
      /* perform gaussian elimination                                 */
      /*--------------------------------------------------------------*/
      /* transform p-th row of matrix V stored in working array, which
       * is t-th row of matrix U, to eliminate subdiagonal elements
       * u[t,s], ..., u[t,t-1]; corresponding gaussian multipliers will
       * form non-trivial row of new row-like factor */
      nnz = 0; /* number of non-zero gaussian multipliers */
      for (k = s; k < t; k++)
      {  /* diagonal element u[k,k] = v[i,j] is used as pivot */
         i = pp_inv[k], j = qq_ind[k];
         /* take subdiagonal element u[t,k] = v[p,j] */
         temp = work[j];
#if 1 /* FIXME */
         if (-eps_tol < temp && temp < +eps_tol)
            continue;
#endif
         /* compute and save gaussian multiplier:
          * f := u[t,k] / u[k,k] = v[p,j] / v[i,j] */
         ind[++nnz] = i;
         val[nnz] = f = work[j] / vr_piv[i];
         /* gaussian transformation to eliminate u[t,k] = v[p,j]:
          * (p-th row of V) := (p-th row of V) - f * (i-th row of V) */
         for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
            i_ptr < i_end; i_ptr++)
            work[sv_ind[i_ptr]] -= f * sv_val[i_ptr];
      }
      /* now matrix U is again upper triangular */
#if 1 /* FIXME */
      if (-vpq_tol < work[q] && work[q] < +vpq_tol)
#endif
      {  /* however, its new diagonal element u[t,t] = v[p,q] is too
          * small in magnitude */
         return 3;
      }
      /*--------------------------------------------------------------*/
      /* create new row-like factor H[k] and add to eta file H        */
      /*--------------------------------------------------------------*/
      /* (nnz = 0 means that all subdiagonal elements were too small
       * in magnitude) */
      if (nnz > 0)
      {  if (fhv->nfs == fhv->nfs_max)
         {  /* maximal number of row-like factors has been reached */
            return 4;
         }
         k = ++(fhv->nfs);
         hh_ind[k] = p;
         /* store non-trivial row of H[k] in right (dynamic) part of
          * SVA (diagonal unity element is not stored) */
         if (sva->r_ptr - sva->m_ptr < nnz)
         {  sva_more_space(sva, nnz);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_reserve_cap(sva, fhv->hh_ref-1+k, nnz);
         ptr = hh_ptr[k];
         memcpy(&sv_ind[ptr], &ind[1], nnz * sizeof(int));
         memcpy(&sv_val[ptr], &val[1], nnz * sizeof(double));
         hh_len[k] = nnz;
      }
      /*--------------------------------------------------------------*/
      /* copy transformed p-th row of matrix V, which is t-th row of  */
      /* matrix U, from working array back to matrix V                */
      /*--------------------------------------------------------------*/
      /* copy elements of transformed p-th row of matrix V, which are
       * non-diagonal elements u[t,t+1], ..., u[t,n] of matrix U, from
       * working array to corresponding columns of matrix V (note that
       * diagonal element u[t,t] = v[p,q] not copied); also transform
       * p-th row of matrix V to sparse format */
      len = 0;
      for (k = t+1; k <= n; k++)
      {  /* j-th column of V = k-th column of U */
         j = qq_ind[k];
         /* take non-diagonal element v[p,j] = u[t,k] */
         temp = work[j];
#if 1 /* FIXME */
         if (-eps_tol < temp && temp < +eps_tol)
            continue;
#endif
         /* add v[p,j] to j-th column of matrix V */
         if (vc_cap[j] == vc_len[j])
         {  /* reserve extra locations in j-th column to reduce further
             * relocations of that column */
#if 1 /* FIXME */
            int need = vc_len[j] + 5;
#endif
            if (sva->r_ptr - sva->m_ptr < need)
            {  sva_more_space(sva, need);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, vc_ref-1+j, need, 0);
         }
         sv_ind[ptr = vc_ptr[j] + (vc_len[j]++)] = p;
         sv_val[ptr] = temp;
         /* store element v[p,j] = u[t,k] to working sparse vector */
         ind[++len] = j;
         val[len] = temp;
      }
      /* copy elements from working sparse vector to p-th row of matrix
       * V (this row is currently empty) */
      if (vr_cap[p] < len)
      {  if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_enlarge_cap(sva, vr_ref-1+p, len, 0);
      }
      ptr = vr_ptr[p];
      memcpy(&sv_ind[ptr], &ind[1], len * sizeof(int));
      memcpy(&sv_val[ptr], &val[1], len * sizeof(double));
      vr_len[p] = len;
      /* store new diagonal element u[t,t] = v[p,q] */
      vr_piv[p] = work[q];
      /*--------------------------------------------------------------*/
      /* perform accuracy test (only if new H[k] was added)           */
      /*--------------------------------------------------------------*/
      if (nnz > 0)
      {  /* copy p-th (non-trivial) row of row-like factor H[k] (except
          * unity diagonal element) to working array in dense format */
         for (j = 1; j <= n; j++)
            work[j] = 0.0;
         k = fhv->nfs;
         for (end = (ptr = hh_ptr[k]) + hh_len[k]; ptr < end; ptr++)
            work[sv_ind[ptr]] = sv_val[ptr];
         /* compute inner product of p-th (non-trivial) row of matrix
          * H[k] and q-th column of matrix V */
         temp = vr_piv[p]; /* 1 * v[p,q] */
         ptr = vc_ptr[q];
         end = ptr + vc_len[q];
         for (; ptr < end; ptr++)
            temp += work[sv_ind[ptr]] * sv_val[ptr];
         /* inner product should be equal to element v[p,q] *before*
          * matrix V was transformed */
         /* compute relative error */
         temp = fabs(vpq - temp) / (1.0 + fabs(vpq));
#if 1 /* FIXME */
         if (temp > err_tol)
#endif
         {  /* relative error is too large */
            return 5;
         }
      }
      /* factorization has been successfully updated */
      return 0;
}

/***********************************************************************
*  fhv_h_solve - solve system H * x = b
*
*  This routine solves the system H * x = b, where the matrix H is the
*  middle factor of the sparse updatable FHV-factorization.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix H. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void fhv_h_solve(FHV *fhv, double x[/*1+n*/])
{     SVA *sva = fhv->luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int nfs = fhv->nfs;
      int *hh_ind = fhv->hh_ind;
      int hh_ref = fhv->hh_ref;
      int *hh_ptr = &sva->ptr[hh_ref-1];
      int *hh_len = &sva->len[hh_ref-1];
      int i, k, end, ptr;
      double x_i;
      for (k = 1; k <= nfs; k++)
      {  x_i = x[i = hh_ind[k]];
         for (end = (ptr = hh_ptr[k]) + hh_len[k]; ptr < end; ptr++)
            x_i -= sv_val[ptr] * x[sv_ind[ptr]];
         x[i] = x_i;
      }
      return;
}

/***********************************************************************
*  fhv_ht_solve - solve system H' * x = b
*
*  This routine solves the system H' * x = b, where H' is a matrix
*  transposed to the matrix H, which is the middle factor of the sparse
*  updatable FHV-factorization.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix H. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void fhv_ht_solve(FHV *fhv, double x[/*1+n*/])
{     SVA *sva = fhv->luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int nfs = fhv->nfs;
      int *hh_ind = fhv->hh_ind;
      int hh_ref = fhv->hh_ref;
      int *hh_ptr = &sva->ptr[hh_ref-1];
      int *hh_len = &sva->len[hh_ref-1];
      int k, end, ptr;
      double x_j;
      for (k = nfs; k >= 1; k--)
      {  if ((x_j = x[hh_ind[k]]) == 0.0)
            continue;
         for (end = (ptr = hh_ptr[k]) + hh_len[k]; ptr < end; ptr++)
            x[sv_ind[ptr]] -= sv_val[ptr] * x_j;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/fhv.h0000644000175100001710000001026000000000000024115 0ustar00runnerdocker00000000000000/* fhv.h (sparse updatable FHV-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef FHV_H
#define FHV_H

#include "luf.h"

/***********************************************************************
*  The structure FHV describes sparse updatable FHV-factorization.
*
*  The FHV-factorization has the following format:
*
*     A = F * H * V,                                                 (1)
*
*     F = P0 * L * P0',                                              (2)
*
*     H = H[1] * H[2] * ... * H[nfs],                                (3)
*
*     V = P * U * Q,                                                 (4)
*
*  where: A is a given (unsymmetric) square matrix; F, H, V are matrix
*  factors actually computed; L is a lower triangular matrix with unity
*  diagonal; U is an upper tringular matrix; H[k], k = 1, 2, ..., nfs,
*  is a row-like factor, which differs from unity matrix only in one
*  row called a non-trivial row; P0, P, Q are permutation matrices; and
*  P0' is a matrix transposed to P0.
*
*  Matrices F, V, P, Q are stored in the underlying LUF object.
*
*  Non-trivial rows of factors H[k] are stored as sparse vectors in the
*  right (static) part of the sparse vector area (SVA). Note that unity
*  diagonal elements of non-trivial rows are not stored.
*
*  Matrix P0 is stored in the same way as matrix P.
*
*  Matrices L and U are completely defined by matrices F, V, P, and Q,
*  and therefore not stored explicitly. */

typedef struct FHV FHV;

struct FHV
{     /* FHV-factorization */
      LUF *luf;
      /* LU-factorization (contains matrices F, V, P, Q) */
      /*--------------------------------------------------------------*/
      /* matrix H in the form of eta file */
      int nfs_max;
      /* maximal number of row-like factors (this limits the number of
       * updates of the factorization) */
      int nfs;
      /* current number of row-like factors, 0 <= nfs <= nfs_max */
      int *hh_ind; /* int hh_ind[1+nfs_max]; */
      /* hh_ind[0] is not used;
       * hh_ind[k], 1 <= k <= nfs, is number of non-trivial row of
       * factor H[k] */
      int hh_ref;
      /* reference number of sparse vector in SVA, which is non-trivial
       * row of factor H[1] */
#if 0 + 0
      int *hh_ptr = &sva->ptr[hh_ref-1];
      /* hh_ptr[0] is not used;
       * hh_ptr[k], 1 <= k <= nfs, is pointer to non-trivial row of
       * factor H[k] */
      int *hh_len = &sva->len[hh_ref-1];
      /* hh_len[0] is not used;
       * hh_len[k], 1 <= k <= nfs, is number of non-zero elements in
       * non-trivial row of factor H[k] */
#endif
      /*--------------------------------------------------------------*/
      /* matrix P0 */
      int *p0_ind; /* int p0_ind[1+n]; */
      /* p0_ind[i] = j means that P0[i,j] = 1 */
      int *p0_inv; /* int p0_inv[1+n]; */
      /* p0_inv[j] = i means that P0[i,j] = 1 */
};

#define fhv_ft_update _glp_fhv_ft_update
int fhv_ft_update(FHV *fhv, int q, int aq_len, const int aq_ind[],
      const double aq_val[], int ind[/*1+n*/], double val[/*1+n*/],
      double work[/*1+n*/]);
/* update FHV-factorization (Forrest-Tomlin) */

#define fhv_h_solve _glp_fhv_h_solve
void fhv_h_solve(FHV *fhv, double x[/*1+n*/]);
/* solve system H * x = b */

#define fhv_ht_solve _glp_fhv_ht_solve
void fhv_ht_solve(FHV *fhv, double x[/*1+n*/]);
/* solve system H' * x = b */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/fhvint.c0000644000175100001710000001232300000000000024625 0ustar00runnerdocker00000000000000/* fhvint.c (interface to FHV-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "fhvint.h"

FHVINT *fhvint_create(void)
{     /* create interface to FHV-factorization */
      FHVINT *fi;
      fi = talloc(1, FHVINT);
      memset(fi, 0, sizeof(FHVINT));
      fi->lufi = lufint_create();
      return fi;
}

int fhvint_factorize(FHVINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info)
{     /* compute FHV-factorization of specified matrix A */
      int nfs_max, old_n_max, n_max, k, ret;
      xassert(n > 0);
      fi->valid = 0;
      /* get required value of nfs_max */
      nfs_max = fi->nfs_max;
      if (nfs_max == 0)
         nfs_max = 100;
      xassert(nfs_max > 0);
      /* compute factorization of specified matrix A */
      old_n_max = fi->lufi->n_max;
      fi->lufi->sva_n_max = 4 * n + nfs_max;
      fi->lufi->sgf_updat = 1;
      ret = lufint_factorize(fi->lufi, n, col, info);
      n_max = fi->lufi->n_max;
      /* allocate/reallocate arrays, if necessary */
      if (fi->fhv.nfs_max != nfs_max)
      {  if (fi->fhv.hh_ind != NULL)
            tfree(fi->fhv.hh_ind);
         fi->fhv.hh_ind = talloc(1+nfs_max, int);
      }
      if (old_n_max < n_max)
      {  if (fi->fhv.p0_ind != NULL)
            tfree(fi->fhv.p0_ind);
         if (fi->fhv.p0_inv != NULL)
            tfree(fi->fhv.p0_inv);
         fi->fhv.p0_ind = talloc(1+n_max, int);
         fi->fhv.p0_inv = talloc(1+n_max, int);
      }
      /* initialize FHV-factorization */
      fi->fhv.luf = fi->lufi->luf;
      fi->fhv.nfs_max = nfs_max;
      /* H := I */
      fi->fhv.nfs = 0;
      fi->fhv.hh_ref = sva_alloc_vecs(fi->lufi->sva, nfs_max);
      /* P0 := P */
      for (k = 1; k <= n; k++)
      {  fi->fhv.p0_ind[k] = fi->fhv.luf->pp_ind[k];
         fi->fhv.p0_inv[k] = fi->fhv.luf->pp_inv[k];
      }
      /* set validation flag */
      if (ret == 0)
         fi->valid = 1;
      return ret;
}

int fhvint_update(FHVINT *fi, int j, int len, const int ind[],
      const double val[])
{     /* update FHV-factorization after replacing j-th column of A */
      SGF *sgf = fi->lufi->sgf;
      int *ind1 = sgf->rs_next;
      double *val1 = sgf->vr_max;
      double *work = sgf->work;
      int ret;
      xassert(fi->valid);
      ret = fhv_ft_update(&fi->fhv, j, len, ind, val, ind1, val1, work);
      if (ret != 0)
         fi->valid = 0;
      return ret;
}

void fhvint_ftran(FHVINT *fi, double x[])
{     /* solve system A * x = b */
      FHV *fhv = &fi->fhv;
      LUF *luf = fhv->luf;
      int n = luf->n;
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      SGF *sgf = fi->lufi->sgf;
      double *work = sgf->work;
      xassert(fi->valid);
      /* A = F * H * V */
      /* x = inv(A) * b = inv(V) * inv(H) * inv(F) * b */
      luf->pp_ind = fhv->p0_ind;
      luf->pp_inv = fhv->p0_inv;
      luf_f_solve(luf, x);
      luf->pp_ind = pp_ind;
      luf->pp_inv = pp_inv;
      fhv_h_solve(fhv, x);
      luf_v_solve(luf, x, work);
      memcpy(&x[1], &work[1], n * sizeof(double));
      return;
}

void fhvint_btran(FHVINT *fi, double x[])
{     /* solve system A'* x = b */
      FHV *fhv = &fi->fhv;
      LUF *luf = fhv->luf;
      int n = luf->n;
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      SGF *sgf = fi->lufi->sgf;
      double *work = sgf->work;
      xassert(fi->valid);
      /* A' = (F * H * V)' = V'* H'* F' */
      /* x = inv(A') * b = inv(F') * inv(H') * inv(V') * b */
      luf_vt_solve(luf, x, work);
      fhv_ht_solve(fhv, work);
      luf->pp_ind = fhv->p0_ind;
      luf->pp_inv = fhv->p0_inv;
      luf_ft_solve(luf, work);
      luf->pp_ind = pp_ind;
      luf->pp_inv = pp_inv;
      memcpy(&x[1], &work[1], n * sizeof(double));
      return;
}

double fhvint_estimate(FHVINT *fi)
{     /* estimate 1-norm of inv(A) */
      double norm;
      xassert(fi->valid);
      xassert(fi->fhv.nfs == 0);
      norm = luf_estimate_norm(fi->fhv.luf, fi->lufi->sgf->vr_max,
         fi->lufi->sgf->work);
      return norm;
}

void fhvint_delete(FHVINT *fi)
{     /* delete interface to FHV-factorization */
      lufint_delete(fi->lufi);
      if (fi->fhv.hh_ind != NULL)
         tfree(fi->fhv.hh_ind);
      if (fi->fhv.p0_ind != NULL)
         tfree(fi->fhv.p0_ind);
      if (fi->fhv.p0_inv != NULL)
         tfree(fi->fhv.p0_inv);
      tfree(fi);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/fhvint.h0000644000175100001710000000472700000000000024643 0ustar00runnerdocker00000000000000/* fhvint.h (interface to FHV-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef FHVINT_H
#define FHVINT_H

#include "fhv.h"
#include "lufint.h"

typedef struct FHVINT FHVINT;

struct FHVINT
{     /* interface to FHV-factorization */
      int valid;
      /* factorization is valid only if this flag is set */
      FHV fhv;
      /* FHV-factorization */
      LUFINT *lufi;
      /* interface to underlying LU-factorization */
      /*--------------------------------------------------------------*/
      /* control parameters */
      int nfs_max;
      /* required maximal number of row-like factors */
};

#define fhvint_create _glp_fhvint_create
FHVINT *fhvint_create(void);
/* create interface to FHV-factorization */

#define fhvint_factorize _glp_fhvint_factorize
int fhvint_factorize(FHVINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info);
/* compute FHV-factorization of specified matrix A */

#define fhvint_update _glp_fhvint_update
int fhvint_update(FHVINT *fi, int j, int len, const int ind[],
      const double val[]);
/* update FHV-factorization after replacing j-th column of A */

#define fhvint_ftran _glp_fhvint_ftran
void fhvint_ftran(FHVINT *fi, double x[]);
/* solve system A * x = b */

#define fhvint_btran _glp_fhvint_btran
void fhvint_btran(FHVINT *fi, double x[]);
/* solve system A'* x = b */

#define fhvint_estimate _glp_fhvint_estimate
double fhvint_estimate(FHVINT *fi);
/* estimate 1-norm of inv(A) */

#define fhvint_delete _glp_fhvint_delete
void fhvint_delete(FHVINT *fi);
/* delete interface to FHV-factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/ifu.c0000644000175100001710000003035300000000000024115 0ustar00runnerdocker00000000000000/* ifu.c (dense updatable IFU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ifu.h"

/***********************************************************************
*  ifu_expand - expand IFU-factorization
*
*  This routine expands the IFU-factorization of the matrix A according
*  to the following expansion of A:
*
*             ( A  c )
*     new A = (      )
*             ( r' d )
*
*  where c[1,...,n] is a new column, r[1,...,n] is a new row, and d is
*  a new diagonal element.
*
*  From the main equality F * A = U it follows that:
*
*     ( F  0 ) ( A  c )   ( FA  Fc )   ( U  Fc )
*     (      ) (      ) = (        ) = (       ),
*     ( 0  1 ) ( r' d )   ( r'   d )   ( r'  d )
*
*  thus,
*
*             ( F  0 )           ( U  Fc )
*     new F = (      ),  new U = (       ).
*             ( 0  1 )           ( r'  d )
*
*  Note that the resulting matrix U loses its upper triangular form due
*  to row spike r', which should be eliminated. */

void ifu_expand(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d)
{     /* non-optimized version */
      int n_max = ifu->n_max;
      int n = ifu->n;
      double *f_ = ifu->f;
      double *u_ = ifu->u;
      int i, j;
      double t;
#     define f(i,j) f_[(i)*n_max+(j)]
#     define u(i,j) u_[(i)*n_max+(j)]
      xassert(0 <= n && n < n_max);
      /* adjust indexing */
      c++, r++;
      /* set new zero column of matrix F */
      for (i = 0; i < n; i++)
         f(i,n) = 0.0;
      /* set new zero row of matrix F */
      for (j = 0; j < n; j++)
         f(n,j) = 0.0;
      /* set new unity diagonal element of matrix F */
      f(n,n) = 1.0;
      /* set new column of matrix U to vector (old F) * c */
      for (i = 0; i < n; i++)
      {  /* u[i,n] := (i-th row of old F) * c */
         t = 0.0;
         for (j = 0; j < n; j++)
            t += f(i,j) * c[j];
         u(i,n) = t;
      }
      /* set new row of matrix U to vector r */
      for (j = 0; j < n; j++)
         u(n,j) = r[j];
      /* set new diagonal element of matrix U to scalar d */
      u(n,n) = d;
      /* increase factorization order */
      ifu->n++;
#     undef f
#     undef u
      return;
}

/***********************************************************************
*  ifu_bg_update - update IFU-factorization (Bartels-Golub)
*
*  This routine updates IFU-factorization of the matrix A according to
*  its expansion (see comments to the routine ifu_expand). The routine
*  is based on the method proposed by Bartels and Golub [1].
*
*  RETURNS
*
*  0  The factorization has been successfully updated.
*
*  1  On some elimination step diagional element u[k,k] to be used as
*     pivot is too small in magnitude.
*
*  2  Diagonal element u[n,n] is too small in magnitude (at the end of
*     update).
*
*  REFERENCES
*
*  1. R.H.Bartels, G.H.Golub, "The Simplex Method of Linear Programming
*     Using LU-decomposition", Comm. ACM, 12, pp. 266-68, 1969. */

int ifu_bg_update(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d)
{     /* non-optimized version */
      int n_max = ifu->n_max;
      int n = ifu->n;
      double *f_ = ifu->f;
      double *u_ = ifu->u;
#if 1 /* FIXME */
      double tol = 1e-5;
#endif
      int j, k;
      double t;
#     define f(i,j) f_[(i)*n_max+(j)]
#     define u(i,j) u_[(i)*n_max+(j)]
      /* expand factorization */
      ifu_expand(ifu, c, r, d);
      /* NOTE: n keeps its old value */
      /* eliminate spike (non-zero subdiagonal elements) in last row of
       * matrix U */
      for (k = 0; k < n; k++)
      {  /* if |u[k,k]| < |u[n,k]|, interchange k-th and n-th rows to
          * provide |u[k,k]| >= |u[n,k]| for numeric stability */
         if (fabs(u(k,k)) < fabs(u(n,k)))
         {  /* interchange k-th and n-th rows of matrix U */
            for (j = k; j <= n; j++)
               t = u(k,j), u(k,j) = u(n,j), u(n,j) = t;
            /* interchange k-th and n-th rows of matrix F to keep the
             * main equality F * A = U */
            for (j = 0; j <= n; j++)
               t = f(k,j), f(k,j) = f(n,j), f(n,j) = t;
         }
         /* now |u[k,k]| >= |u[n,k]| */
         /* check if diagonal element u[k,k] can be used as pivot */
         if (fabs(u(k,k)) < tol)
         {  /* u[k,k] is too small in magnitude */
            return 1;
         }
         /* if u[n,k] = 0, elimination is not needed */
         if (u(n,k) == 0.0)
            continue;
         /* compute gaussian multiplier t = u[n,k] / u[k,k] */
         t = u(n,k) / u(k,k);
         /* apply gaussian transformation to eliminate u[n,k] */
         /* (n-th row of U) := (n-th row of U) - t * (k-th row of U) */
         for (j = k+1; j <= n; j++)
            u(n,j) -= t * u(k,j);
         /* apply the same transformation to matrix F to keep the main
          * equality F * A = U */
         for (j = 0; j <= n; j++)
            f(n,j) -= t * f(k,j);
      }
      /* now matrix U is upper triangular */
      if (fabs(u(n,n)) < tol)
      {  /* u[n,n] is too small in magnitude */
         return 2;
      }
#     undef f
#     undef u
      return 0;
}

/***********************************************************************
*  The routine givens computes the parameters of Givens plane rotation
*  c = cos(teta) and s = sin(teta) such that:
*
*     ( c -s ) ( a )   ( r )
*     (      ) (   ) = (   ) ,
*     ( s  c ) ( b )   ( 0 )
*
*  where a and b are given scalars.
*
*  REFERENCES
*
*  G.H.Golub, C.F.Van Loan, "Matrix Computations", 2nd ed. */

static void givens(double a, double b, double *c, double *s)
{     /* non-optimized version */
      double t;
      if (b == 0.0)
         (*c) = 1.0, (*s) = 0.0;
      else if (fabs(a) <= fabs(b))
         t = - a / b, (*s) = 1.0 / sqrt(1.0 + t * t), (*c) = (*s) * t;
      else
         t = - b / a, (*c) = 1.0 / sqrt(1.0 + t * t), (*s) = (*c) * t;
      return;
}

/***********************************************************************
*  ifu_gr_update - update IFU-factorization (Givens rotations)
*
*  This routine updates IFU-factorization of the matrix A according to
*  its expansion (see comments to the routine ifu_expand). The routine
*  is based on Givens plane rotations [1].
*
*  RETURNS
*
*  0  The factorization has been successfully updated.
*
*  1  On some elimination step both elements u[k,k] and u[n,k] are too
*     small in magnitude.
*
*  2  Diagonal element u[n,n] is too small in magnitude (at the end of
*     update).
*
*  REFERENCES
*
*  1. G.H.Golub, C.F.Van Loan, "Matrix Computations", 2nd ed. */

int ifu_gr_update(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d)
{     /* non-optimized version */
      int n_max = ifu->n_max;
      int n = ifu->n;
      double *f_ = ifu->f;
      double *u_ = ifu->u;
#if 1 /* FIXME */
      double tol = 1e-5;
#endif
      int j, k;
      double cs, sn;
#     define f(i,j) f_[(i)*n_max+(j)]
#     define u(i,j) u_[(i)*n_max+(j)]
      /* expand factorization */
      ifu_expand(ifu, c, r, d);
      /* NOTE: n keeps its old value */
      /* eliminate spike (non-zero subdiagonal elements) in last row of
       * matrix U */
      for (k = 0; k < n; k++)
      {  /* check if elements u[k,k] and u[n,k] are eligible */
         if (fabs(u(k,k)) < tol && fabs(u(n,k)) < tol)
         {  /* both u[k,k] and u[n,k] are too small in magnitude */
            return 1;
         }
         /* if u[n,k] = 0, elimination is not needed */
         if (u(n,k) == 0.0)
            continue;
         /* compute parameters of Givens plane rotation */
         givens(u(k,k), u(n,k), &cs, &sn);
         /* apply Givens rotation to k-th and n-th rows of matrix U to
          * eliminate u[n,k] */
         for (j = k; j <= n; j++)
         {  double ukj = u(k,j), unj = u(n,j);
            u(k,j) = cs * ukj - sn * unj;
            u(n,j) = sn * ukj + cs * unj;
         }
         /* apply the same transformation to matrix F to keep the main
          * equality F * A = U */
         for (j = 0; j <= n; j++)
         {  double fkj = f(k,j), fnj = f(n,j);
            f(k,j) = cs * fkj - sn * fnj;
            f(n,j) = sn * fkj + cs * fnj;
         }
      }
      /* now matrix U is upper triangular */
      if (fabs(u(n,n)) < tol)
      {  /* u[n,n] is too small in magnitude */
         return 2;
      }
#     undef f
#     undef u
      return 0;
}

/***********************************************************************
*  ifu_a_solve - solve system A * x = b
*
*  This routine solves the system A * x = b, where the matrix A is
*  specified by its IFU-factorization.
*
*  Using the main equality F * A = U we have:
*
*     A * x = b  =>  F * A * x = F * b  =>  U * x = F * b  =>
*
*     x = inv(U) * F * b.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix A. On exit this array will contain elements of the solution
*  vector x in the same locations.
*
*  The working array w should have at least 1+n elements (0-th element
*  is not used). */

void ifu_a_solve(IFU *ifu, double x[/*1+n*/], double w[/*1+n*/])
{     /* non-optimized version */
      int n_max = ifu->n_max;
      int n = ifu->n;
      double *f_ = ifu->f;
      double *u_ = ifu->u;
      int i, j;
      double t;
#     define f(i,j) f_[(i)*n_max+(j)]
#     define u(i,j) u_[(i)*n_max+(j)]
      xassert(0 <= n && n <= n_max);
      /* adjust indexing */
      x++, w++;
      /* y := F * b */
      memcpy(w, x, n * sizeof(double));
      for (i = 0; i < n; i++)
      {  /* y[i] := (i-th row of F) * b */
         t = 0.0;
         for (j = 0; j < n; j++)
            t += f(i,j) * w[j];
         x[i] = t;
      }
      /* x := inv(U) * y */
      for (i = n-1; i >= 0; i--)
      {  t = x[i];
         for (j = i+1; j < n; j++)
            t -= u(i,j) * x[j];
         x[i] = t / u(i,i);
      }
#     undef f
#     undef u
      return;
}

/***********************************************************************
*  ifu_at_solve - solve system A'* x = b
*
*  This routine solves the system A'* x = b, where A' is a matrix
*  transposed to the matrix A, specified by its IFU-factorization.
*
*  Using the main equality F * A = U, from which it follows that
*  A'* F' = U', we have:
*
*     A'* x = b  =>  A'* F'* inv(F') * x = b  =>
*
*     U'* inv(F') * x = b  =>  inv(F') * x = inv(U') * b  =>
*
*     x = F' * inv(U') * b.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix A. On exit this array will contain elements of the solution
*  vector x in the same locations.
*
*  The working array w should have at least 1+n elements (0-th element
*  is not used). */

void ifu_at_solve(IFU *ifu, double x[/*1+n*/], double w[/*1+n*/])
{     /* non-optimized version */
      int n_max = ifu->n_max;
      int n = ifu->n;
      double *f_ = ifu->f;
      double *u_ = ifu->u;
      int i, j;
      double t;
#     define f(i,j) f_[(i)*n_max+(j)]
#     define u(i,j) u_[(i)*n_max+(j)]
      xassert(0 <= n && n <= n_max);
      /* adjust indexing */
      x++, w++;
      /* y := inv(U') * b */
      for (i = 0; i < n; i++)
      {  t = (x[i] /= u(i,i));
         for (j = i+1; j < n; j++)
            x[j] -= u(i,j) * t;
      }
      /* x := F'* y */
      for (j = 0; j < n; j++)
      {  /* x[j] := (j-th column of F) * y */
         t = 0.0;
         for (i = 0; i < n; i++)
            t += f(i,j) * x[i];
         w[j] = t;
      }
      memcpy(x, w, n * sizeof(double));
#     undef f
#     undef u
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/ifu.h0000644000175100001710000000704500000000000024124 0ustar00runnerdocker00000000000000/* ifu.h (dense updatable IFU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef IFU_H
#define IFU_H

/***********************************************************************
*  The structure IFU describes dense updatable IFU-factorization.
*
*  The IFU-factorization has the following format:
*
*     A = inv(F) * U,                                                (1)
*
*  where A is a given (unsymmetric) nxn square matrix, F is a square
*  matrix, U is an upper triangular matrix. Obviously, the equality (1)
*  is equivalent to the following equality:
*
*     F * A = U.                                                     (2)
*
*  It is assumed that matrix A is small and dense, so matrices F and U
*  are stored by rows in dense format as follows:
*
*        1         n       n_max      1         n       n_max
*      1 * * * * * * x x x x        1 * * * * * * x x x x
*        * * * * * * x x x x          ? * * * * * x x x x
*        * * * * * * x x x x          ? ? * * * * x x x x
*        * * * * * * x x x x          ? ? ? * * * x x x x
*        * * * * * * x x x x          ? ? ? ? * * x x x x
*      n * * * * * * x x x x        n ? ? ? ? ? * x x x x
*        x x x x x x x x x x          x x x x x x x x x x
*        x x x x x x x x x x          x x x x x x x x x x
*        x x x x x x x x x x          x x x x x x x x x x
*  n_max x x x x x x x x x x    n_max x x x x x x x x x x
*
*             matrix F                     matrix U
*
*  where '*' are matrix elements, '?' are unused locations, 'x' are
*  reserved locations. */

typedef struct IFU IFU;

struct IFU
{     /* IFU-factorization */
      int n_max;
      /* maximal order of matrices A, F, U; n_max >= 1 */
      int n;
      /* current order of matrices A, F, U; 0 <= n <= n_max */
      double *f; /* double f[n_max*n_max]; */
      /* matrix F stored by rows */
      double *u; /* double u[n_max*n_max]; */
      /* matrix U stored by rows */
};

#define ifu_expand _glp_ifu_expand
void ifu_expand(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d);
/* expand IFU-factorization */

#define ifu_bg_update _glp_ifu_bg_update
int ifu_bg_update(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d);
/* update IFU-factorization (Bartels-Golub) */

#define ifu_gr_update _glp_ifu_gr_update
int ifu_gr_update(IFU *ifu, double c[/*1+n*/], double r[/*1+n*/],
      double d);
/* update IFU-factorization (Givens rotations) */

#define ifu_a_solve _glp_ifu_a_solve
void ifu_a_solve(IFU *ifu, double x[/*1+n*/], double w[/*1+n*/]);
/* solve system A * x = b */

#define ifu_at_solve _glp_ifu_at_solve
void ifu_at_solve(IFU *ifu, double x[/*1+n*/], double w[/*1+n*/]);
/* solve system A'* x = b */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/luf.c0000644000175100001710000006070400000000000024123 0ustar00runnerdocker00000000000000/* luf.c (sparse LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "luf.h"

/***********************************************************************
*  luf_store_v_cols - store matrix V = A in column-wise format
*
*  This routine stores matrix V = A in column-wise format, where A is
*  the original matrix to be factorized.
*
*  On exit the routine returns the number of non-zeros in matrix V. */

int luf_store_v_cols(LUF *luf, int (*col)(void *info, int j, int ind[],
      double val[]), void *info, int ind[], double val[])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *vc_cap = &sva->cap[vc_ref-1];
      int j, len, ptr, nnz;
      nnz = 0;
      for (j = 1; j <= n; j++)
      {  /* get j-th column */
         len = col(info, j, ind, val);
         xassert(0 <= len && len <= n);
         /* enlarge j-th column capacity */
         if (vc_cap[j] < len)
         {  if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, vc_ref-1+j, len, 0);
         }
         /* store j-th column */
         ptr = vc_ptr[j];
         memcpy(&sv_ind[ptr], &ind[1], len * sizeof(int));
         memcpy(&sv_val[ptr], &val[1], len * sizeof(double));
         vc_len[j] = len;
         nnz += len;
      }
      return nnz;
}

/***********************************************************************
*  luf_check_all - check LU-factorization before k-th elimination step
*
*  This routine checks that before performing k-th elimination step,
*  1 <= k <= n+1, all components of the LU-factorization are correct.
*
*  In case of k = n+1, i.e. after last elimination step, it is assumed
*  that rows of F and columns of V are *not* built yet.
*
*  NOTE: For testing/debugging only. */

void luf_check_all(LUF *luf, int k)
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fr_ref = luf->fr_ref;
      int *fr_len = &sva->len[fr_ref-1];
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int i, ii, i_ptr, i_end, j, jj, j_ptr, j_end;
      xassert(n > 0);
      xassert(1 <= k && k <= n+1);
      /* check permutation matrix P */
      for (i = 1; i <= n; i++)
      {  ii = pp_ind[i];
         xassert(1 <= ii && ii <= n);
         xassert(pp_inv[ii] == i);
      }
      /* check permutation matrix Q */
      for (j = 1; j <= n; j++)
      {  jj = qq_inv[j];
         xassert(1 <= jj && jj <= n);
         xassert(qq_ind[jj] == j);
      }
      /* check row-wise representation of matrix F */
      for (i = 1; i <= n; i++)
         xassert(fr_len[i] == 0);
      /* check column-wise representation of matrix F */
      for (j = 1; j <= n; j++)
      {  /* j-th column of F = jj-th column of L */
         jj = pp_ind[j];
         if (jj < k)
         {  j_ptr = fc_ptr[j];
            j_end = j_ptr + fc_len[j];
            for (; j_ptr < j_end; j_ptr++)
            {  i = sv_ind[j_ptr];
               xassert(1 <= i && i <= n);
               ii = pp_ind[i]; /* f[i,j] = l[ii,jj] */
               xassert(ii > jj);
               xassert(sv_val[j_ptr] != 0.0);
            }
         }
         else /* jj >= k */
            xassert(fc_len[j] == 0);
      }
      /* check row-wise representation of matrix V */
      for (i = 1; i <= n; i++)
      {  /* i-th row of V = ii-th row of U */
         ii = pp_ind[i];
         i_ptr = vr_ptr[i];
         i_end = i_ptr + vr_len[i];
         for (; i_ptr < i_end; i_ptr++)
         {  j = sv_ind[i_ptr];
            xassert(1 <= j && j <= n);
            jj = qq_inv[j]; /* v[i,j] = u[ii,jj] */
            if (ii < k)
               xassert(jj > ii);
            else /* ii >= k */
            {  xassert(jj >= k);
               /* find v[i,j] in j-th column */
               j_ptr = vc_ptr[j];
               j_end = j_ptr + vc_len[j];
               for (; sv_ind[j_ptr] != i; j_ptr++)
                  /* nop */;
               xassert(j_ptr < j_end);
            }
            xassert(sv_val[i_ptr] != 0.0);
         }
      }
      /* check column-wise representation of matrix V */
      for (j = 1; j <= n; j++)
      {  /* j-th column of V = jj-th column of U */
         jj = qq_inv[j];
         if (jj < k)
            xassert(vc_len[j] == 0);
         else /* jj >= k */
         {  j_ptr = vc_ptr[j];
            j_end = j_ptr + vc_len[j];
            for (; j_ptr < j_end; j_ptr++)
            {  i = sv_ind[j_ptr];
               ii = pp_ind[i]; /* v[i,j] = u[ii,jj] */
               xassert(ii >= k);
               /* find v[i,j] in i-th row */
               i_ptr = vr_ptr[i];
               i_end = i_ptr + vr_len[i];
               for (; sv_ind[i_ptr] != j; i_ptr++)
                  /* nop */;
               xassert(i_ptr < i_end);
            }
         }
      }
      return;
}

/***********************************************************************
*  luf_build_v_rows - build matrix V in row-wise format
*
*  This routine builds the row-wise representation of matrix V in the
*  left part of SVA using its column-wise representation.
*
*  NOTE: On entry to the routine all rows of matrix V should have zero
*        capacity.
*
*  The working array len should have at least 1+n elements (len[0] is
*  not used). */

void luf_build_v_rows(LUF *luf, int len[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int i, j, end, nnz, ptr, ptr1;
      /* calculate the number of non-zeros in each row of matrix V and
       * the total number of non-zeros */
      nnz = 0;
      for (i = 1; i <= n; i++)
         len[i] = 0;
      for (j = 1; j <= n; j++)
      {  nnz += vc_len[j];
         for (end = (ptr = vc_ptr[j]) + vc_len[j]; ptr < end; ptr++)
            len[sv_ind[ptr]]++;
      }
      /* we need at least nnz free locations in SVA */
      if (sva->r_ptr - sva->m_ptr < nnz)
      {  sva_more_space(sva, nnz);
         sv_ind = sva->ind;
         sv_val = sva->val;
      }
      /* reserve locations for rows of matrix V */
      for (i = 1; i <= n; i++)
      {  if (len[i] > 0)
            sva_enlarge_cap(sva, vr_ref-1+i, len[i], 0);
         vr_len[i] = len[i];
      }
      /* walk thru column of matrix V and build its rows */
      for (j = 1; j <= n; j++)
      {  for (end = (ptr = vc_ptr[j]) + vc_len[j]; ptr < end; ptr++)
         {  i = sv_ind[ptr];
            sv_ind[ptr1 = vr_ptr[i] + (--len[i])] = j;
            sv_val[ptr1] = sv_val[ptr];
         }
      }
      return;
}

/***********************************************************************
*  luf_build_f_rows - build matrix F in row-wise format
*
*  This routine builds the row-wise representation of matrix F in the
*  right part of SVA using its column-wise representation.
*
*  NOTE: On entry to the routine all rows of matrix F should have zero
*        capacity.
*
*  The working array len should have at least 1+n elements (len[0] is
*  not used). */

void luf_build_f_rows(LUF *luf, int len[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fr_ref = luf->fr_ref;
      int *fr_ptr = &sva->ptr[fr_ref-1];
      int *fr_len = &sva->len[fr_ref-1];
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int i, j, end, nnz, ptr, ptr1;
      /* calculate the number of non-zeros in each row of matrix F and
       * the total number of non-zeros (except diagonal elements) */
      nnz = 0;
      for (i = 1; i <= n; i++)
         len[i] = 0;
      for (j = 1; j <= n; j++)
      {  nnz += fc_len[j];
         for (end = (ptr = fc_ptr[j]) + fc_len[j]; ptr < end; ptr++)
            len[sv_ind[ptr]]++;
      }
      /* we need at least nnz free locations in SVA */
      if (sva->r_ptr - sva->m_ptr < nnz)
      {  sva_more_space(sva, nnz);
         sv_ind = sva->ind;
         sv_val = sva->val;
      }
      /* reserve locations for rows of matrix F */
      for (i = 1; i <= n; i++)
      {  if (len[i] > 0)
            sva_reserve_cap(sva, fr_ref-1+i, len[i]);
         fr_len[i] = len[i];
      }
      /* walk through columns of matrix F and build its rows */
      for (j = 1; j <= n; j++)
      {  for (end = (ptr = fc_ptr[j]) + fc_len[j]; ptr < end; ptr++)
         {  i = sv_ind[ptr];
            sv_ind[ptr1 = fr_ptr[i] + (--len[i])] = j;
            sv_val[ptr1] = sv_val[ptr];
         }
      }
      return;
}

/***********************************************************************
*  luf_build_v_cols - build matrix V in column-wise format
*
*  This routine builds the column-wise representation of matrix V in
*  the left (if the flag updat is set) or right (if the flag updat is
*  clear) part of SVA using its row-wise representation.
*
*  NOTE: On entry to the routine all columns of matrix V should have
*        zero capacity.
*
*  The working array len should have at least 1+n elements (len[0] is
*  not used). */

void luf_build_v_cols(LUF *luf, int updat, int len[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int i, j, end, nnz, ptr, ptr1;
      /* calculate the number of non-zeros in each column of matrix V
       * and the total number of non-zeros (except pivot elements) */
      nnz = 0;
      for (j = 1; j <= n; j++)
         len[j] = 0;
      for (i = 1; i <= n; i++)
      {  nnz += vr_len[i];
         for (end = (ptr = vr_ptr[i]) + vr_len[i]; ptr < end; ptr++)
            len[sv_ind[ptr]]++;
      }
      /* we need at least nnz free locations in SVA */
      if (sva->r_ptr - sva->m_ptr < nnz)
      {  sva_more_space(sva, nnz);
         sv_ind = sva->ind;
         sv_val = sva->val;
      }
      /* reserve locations for columns of matrix V */
      for (j = 1; j <= n; j++)
      {  if (len[j] > 0)
         {  if (updat)
               sva_enlarge_cap(sva, vc_ref-1+j, len[j], 0);
            else
               sva_reserve_cap(sva, vc_ref-1+j, len[j]);
         }
         vc_len[j] = len[j];
      }
      /* walk through rows of matrix V and build its columns */
      for (i = 1; i <= n; i++)
      {  for (end = (ptr = vr_ptr[i]) + vr_len[i]; ptr < end; ptr++)
         {  j = sv_ind[ptr];
            sv_ind[ptr1 = vc_ptr[j] + (--len[j])] = i;
            sv_val[ptr1] = sv_val[ptr];
         }
      }
      return;
}

/***********************************************************************
*  luf_check_f_rc - check rows and columns of matrix F
*
*  This routine checks that the row- and column-wise representations
*  of matrix F are identical.
*
*  NOTE: For testing/debugging only. */

void luf_check_f_rc(LUF *luf)
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fr_ref = luf->fr_ref;
      int *fr_ptr = &sva->ptr[fr_ref-1];
      int *fr_len = &sva->len[fr_ref-1];
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int i, i_end, i_ptr, j, j_end, j_ptr;
      /* walk thru rows of matrix F */
      for (i = 1; i <= n; i++)
      {  for (i_end = (i_ptr = fr_ptr[i]) + fr_len[i];
            i_ptr < i_end; i_ptr++)
         {  j = sv_ind[i_ptr];
            /* find element f[i,j] in j-th column of matrix F */
            for (j_end = (j_ptr = fc_ptr[j]) + fc_len[j];
               sv_ind[j_ptr] != i; j_ptr++)
               /* nop */;
            xassert(j_ptr < j_end);
            xassert(sv_val[i_ptr] == sv_val[j_ptr]);
            /* mark element f[i,j] */
            sv_ind[j_ptr] = -i;
         }
      }
      /* walk thru column of matix F and check that all elements has
         been marked */
      for (j = 1; j <= n; j++)
      {  for (j_end = (j_ptr = fc_ptr[j]) + fc_len[j];
            j_ptr < j_end; j_ptr++)
         {  xassert((i = sv_ind[j_ptr]) < 0);
            /* unmark element f[i,j] */
            sv_ind[j_ptr] = -i;
         }
      }
      return;
}

/***********************************************************************
*  luf_check_v_rc - check rows and columns of matrix V
*
*  This routine checks that the row- and column-wise representations
*  of matrix V are identical.
*
*  NOTE: For testing/debugging only. */

void luf_check_v_rc(LUF *luf)
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int i, i_end, i_ptr, j, j_end, j_ptr;
      /* walk thru rows of matrix V */
      for (i = 1; i <= n; i++)
      {  for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
            i_ptr < i_end; i_ptr++)
         {  j = sv_ind[i_ptr];
            /* find element v[i,j] in j-th column of matrix V */
            for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
               sv_ind[j_ptr] != i; j_ptr++)
               /* nop */;
            xassert(j_ptr < j_end);
            xassert(sv_val[i_ptr] == sv_val[j_ptr]);
            /* mark element v[i,j] */
            sv_ind[j_ptr] = -i;
         }
      }
      /* walk thru column of matix V and check that all elements has
         been marked */
      for (j = 1; j <= n; j++)
      {  for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
            j_ptr < j_end; j_ptr++)
         {  xassert((i = sv_ind[j_ptr]) < 0);
            /* unmark element v[i,j] */
            sv_ind[j_ptr] = -i;
         }
      }
      return;
}

/***********************************************************************
*  luf_f_solve - solve system F * x = b
*
*  This routine solves the system F * x = b, where the matrix F is the
*  left factor of the sparse LU-factorization.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix F. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void luf_f_solve(LUF *luf, double x[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int *pp_inv = luf->pp_inv;
      int j, k, ptr, end;
      double x_j;
      for (k = 1; k <= n; k++)
      {  /* k-th column of L = j-th column of F */
         j = pp_inv[k];
         /* x[j] is already computed */
         /* walk thru j-th column of matrix F and substitute x[j] into
          * other equations */
         if ((x_j = x[j]) != 0.0)
         {  for (end = (ptr = fc_ptr[j]) + fc_len[j]; ptr < end; ptr++)
               x[sv_ind[ptr]] -= sv_val[ptr] * x_j;
         }
      }
      return;
}

/***********************************************************************
*  luf_ft_solve - solve system F' * x = b
*
*  This routine solves the system F' * x = b, where F' is a matrix
*  transposed to the matrix F, which is the left factor of the sparse
*  LU-factorization.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix F. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void luf_ft_solve(LUF *luf, double x[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fr_ref = luf->fr_ref;
      int *fr_ptr = &sva->ptr[fr_ref-1];
      int *fr_len = &sva->len[fr_ref-1];
      int *pp_inv = luf->pp_inv;
      int i, k, ptr, end;
      double x_i;
      for (k = n; k >= 1; k--)
      {  /* k-th column of L' = i-th row of F */
         i = pp_inv[k];
         /* x[i] is already computed */
         /* walk thru i-th row of matrix F and substitute x[i] into
          * other equations */
         if ((x_i = x[i]) != 0.0)
         {  for (end = (ptr = fr_ptr[i]) + fr_len[i]; ptr < end; ptr++)
               x[sv_ind[ptr]] -= sv_val[ptr] * x_i;
         }
      }
      return;
}

/***********************************************************************
*  luf_v_solve - solve system V * x = b
*
*  This routine solves the system V * x = b, where the matrix V is the
*  right factor of the sparse LU-factorization.
*
*  On entry the array b should contain elements of the right-hand side
*  vector b in locations b[1], ..., b[n], where n is the order of the
*  matrix V. On exit the array x will contain elements of the solution
*  vector x in locations x[1], ..., x[n]. Note that the array b will be
*  clobbered on exit. */

void luf_v_solve(LUF *luf, double b[/*1+n*/], double x[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int i, j, k, ptr, end;
      double x_j;
      for (k = n; k >= 1; k--)
      {  /* k-th row of U = i-th row of V */
         /* k-th column of U = j-th column of V */
         i = pp_inv[k];
         j = qq_ind[k];
         /* compute x[j] = b[i] / u[k,k], where u[k,k] = v[i,j];
          * walk through j-th column of matrix V and substitute x[j]
          * into other equations */
         if ((x_j = x[j] = b[i] / vr_piv[i]) != 0.0)
         {  for (end = (ptr = vc_ptr[j]) + vc_len[j]; ptr < end; ptr++)
               b[sv_ind[ptr]] -= sv_val[ptr] * x_j;
         }
      }
      return;
}

/***********************************************************************
*  luf_vt_solve - solve system V' * x = b
*
*  This routine solves the system V' * x = b, where V' is a matrix
*  transposed to the matrix V, which is the right factor of the sparse
*  LU-factorization.
*
*  On entry the array b should contain elements of the right-hand side
*  vector b in locations b[1], ..., b[n], where n is the order of the
*  matrix V. On exit the array x will contain elements of the solution
*  vector x in locations x[1], ..., x[n]. Note that the array b will be
*  clobbered on exit. */

void luf_vt_solve(LUF *luf, double b[/*1+n*/], double x[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      double *vr_piv = luf->vr_piv;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int i, j, k, ptr, end;
      double x_i;
      for (k = 1; k <= n; k++)
      {  /* k-th row of U' = j-th column of V */
         /* k-th column of U' = i-th row of V */
         i = pp_inv[k];
         j = qq_ind[k];
         /* compute x[i] = b[j] / u'[k,k], where u'[k,k] = v[i,j];
          * walk through i-th row of matrix V and substitute x[i] into
          * other equations */
         if ((x_i = x[i] = b[j] / vr_piv[i]) != 0.0)
         {  for (end = (ptr = vr_ptr[i]) + vr_len[i]; ptr < end; ptr++)
               b[sv_ind[ptr]] -= sv_val[ptr] * x_i;
         }
      }
      return;
}

/***********************************************************************
*  luf_vt_solve1 - solve system V' * y = e' to cause growth in y
*
*  This routine is a special version of luf_vt_solve. It solves the
*  system V'* y = e' = e + delta e, where V' is a matrix transposed to
*  the matrix V, e is the specified right-hand side vector, and delta e
*  is a vector of +1 and -1 chosen to cause growth in the solution
*  vector y.
*
*  On entry the array e should contain elements of the right-hand side
*  vector e in locations e[1], ..., e[n], where n is the order of the
*  matrix V. On exit the array y will contain elements of the solution
*  vector y in locations y[1], ..., y[n]. Note that the array e will be
*  clobbered on exit. */

void luf_vt_solve1(LUF *luf, double e[/*1+n*/], double y[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      double *vr_piv = luf->vr_piv;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int i, j, k, ptr, end;
      double e_j, y_i;
      for (k = 1; k <= n; k++)
      {  /* k-th row of U' = j-th column of V */
         /* k-th column of U' = i-th row of V */
         i = pp_inv[k];
         j = qq_ind[k];
         /* determine e'[j] = e[j] + delta e[j] */
         e_j = (e[j] >= 0.0 ? e[j] + 1.0 : e[j] - 1.0);
         /* compute y[i] = e'[j] / u'[k,k], where u'[k,k] = v[i,j] */
         y_i = y[i] = e_j / vr_piv[i];
         /* walk through i-th row of matrix V and substitute y[i] into
          * other equations */
         for (end = (ptr = vr_ptr[i]) + vr_len[i]; ptr < end; ptr++)
            e[sv_ind[ptr]] -= sv_val[ptr] * y_i;
      }
      return;
}

/***********************************************************************
*  luf_estimate_norm - estimate 1-norm of inv(A)
*
*  This routine estimates 1-norm of inv(A) by one step of inverse
*  iteration for the small singular vector as described in [1]. This
*  involves solving two systems of equations:
*
*     A'* y = e,
*
*     A * z = y,
*
*  where A' is a matrix transposed to A, and e is a vector of +1 and -1
*  chosen to cause growth in y. Then
*
*     estimate 1-norm of inv(A) = (1-norm of z) / (1-norm of y)
*
*  REFERENCES
*
*  1. G.E.Forsythe, M.A.Malcolm, C.B.Moler. Computer Methods for
*     Mathematical Computations. Prentice-Hall, Englewood Cliffs, N.J.,
*     pp. 30-62 (subroutines DECOMP and SOLVE). */

double luf_estimate_norm(LUF *luf, double w1[/*1+n*/], double
      w2[/*1+n*/])
{     int n = luf->n;
      double *e = w1;
      double *y = w2;
      double *z = w1;
      int i;
      double y_norm, z_norm;
      /* y = inv(A') * e = inv(F') * inv(V') * e */
      /* compute y' = inv(V') * e to cause growth in y' */
      for (i = 1; i <= n; i++)
         e[i] = 0.0;
      luf_vt_solve1(luf, e, y);
      /* compute y = inv(F') * y' */
      luf_ft_solve(luf, y);
      /* compute 1-norm of y = sum |y[i]| */
      y_norm = 0.0;
      for (i = 1; i <= n; i++)
         y_norm += (y[i] >= 0.0 ? +y[i] : -y[i]);
      /* z = inv(A) * y = inv(V) * inv(F) * y */
      /* compute z' = inv(F) * y */
      luf_f_solve(luf, y);
      /* compute z = inv(V) * z' */
      luf_v_solve(luf, y, z);
      /* compute 1-norm of z = sum |z[i]| */
      z_norm = 0.0;
      for (i = 1; i <= n; i++)
         z_norm += (z[i] >= 0.0 ? +z[i] : -z[i]);
      /* estimate 1-norm of inv(A) = (1-norm of z) / (1-norm of y) */
      return z_norm / y_norm;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/luf.h0000644000175100001710000002071200000000000024123 0ustar00runnerdocker00000000000000/* luf.h (sparse LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef LUF_H
#define LUF_H

#include "sva.h"

/***********************************************************************
*  The structure LUF describes sparse LU-factorization.
*
*  The LU-factorization has the following format:
*
*     A = F * V = P * L * U * Q,                                     (1)
*
*     F = P * L * P',                                                (2)
*
*     V = P * U * Q,                                                 (3)
*
*  where A is a given (unsymmetric) square matrix, F and V are matrix
*  factors actually computed, L is a lower triangular matrix with unity
*  diagonal, U is an upper triangular matrix, P and Q are permutation
*  matrices, P' is a matrix transposed to P. All the matrices have the
*  same order n.
*
*  Matrices F and V are stored in both row- and column-wise sparse
*  formats in the associated sparse vector area (SVA). Unity diagonal
*  elements of matrix F are not stored. Pivot elements of matrix V
*  (which correspond to diagonal elements of matrix U) are stored in
*  a separate ordinary array.
*
*  Permutation matrices P and Q are stored in ordinary arrays in both
*  row- and column-like formats.
*
*  Matrices L and U are completely defined by matrices F, V, P, and Q,
*  and therefore not stored explicitly. */

typedef struct LUF LUF;

struct LUF
{     /* sparse LU-factorization */
      int n;
      /* order of matrices A, F, V, P, Q */
      SVA *sva;
      /* associated sparse vector area (SVA) used to store rows and
       * columns of matrices F and V; note that different objects may
       * share the same SVA */
      /*--------------------------------------------------------------*/
      /* matrix F in row-wise format */
      /* during the factorization process this object is not used */
      int fr_ref;
      /* reference number of sparse vector in SVA, which is the first
       * row of matrix F */
#if 0 + 0
      int *fr_ptr = &sva->ptr[fr_ref-1];
      /* fr_ptr[0] is not used;
       * fr_ptr[i], 1 <= i <= n, is pointer to i-th row in SVA */
      int *fr_len = &sva->len[fr_ref-1];
      /* fr_len[0] is not used;
       * fr_len[i], 1 <= i <= n, is length of i-th row */
#endif
      /*--------------------------------------------------------------*/
      /* matrix F in column-wise format */
      /* during the factorization process this object is constructed
       * by columns */
      int fc_ref;
      /* reference number of sparse vector in SVA, which is the first
       * column of matrix F */
#if 0 + 0
      int *fc_ptr = &sva->ptr[fc_ref-1];
      /* fc_ptr[0] is not used;
       * fc_ptr[j], 1 <= j <= n, is pointer to j-th column in SVA */
      int *fc_len = &sva->len[fc_ref-1];
      /* fc_len[0] is not used;
       * fc_len[j], 1 <= j <= n, is length of j-th column */
#endif
      /*--------------------------------------------------------------*/
      /* matrix V in row-wise format */
      int vr_ref;
      /* reference number of sparse vector in SVA, which is the first
       * row of matrix V */
#if 0 + 0
      int *vr_ptr = &sva->ptr[vr_ref-1];
      /* vr_ptr[0] is not used;
       * vr_ptr[i], 1 <= i <= n, is pointer to i-th row in SVA */
      int *vr_len = &sva->len[vr_ref-1];
      /* vr_len[0] is not used;
       * vr_len[i], 1 <= i <= n, is length of i-th row */
      int *vr_cap = &sva->cap[vr_ref-1];
      /* vr_cap[0] is not used;
       * vr_cap[i], 1 <= i <= n, is capacity of i-th row */
#endif
      double *vr_piv; /* double vr_piv[1+n]; */
      /* vr_piv[0] is not used;
       * vr_piv[i], 1 <= i <= n, is pivot element of i-th row */
      /*--------------------------------------------------------------*/
      /* matrix V in column-wise format */
      /* during the factorization process this object contains only the
       * patterns (row indices) of columns of the active submatrix */
      int vc_ref;
      /* reference number of sparse vector in SVA, which is the first
       * column of matrix V */
#if 0 + 0
      int *vc_ptr = &sva->ptr[vc_ref-1];
      /* vc_ptr[0] is not used;
       * vc_ptr[j], 1 <= j <= n, is pointer to j-th column in SVA */
      int *vc_len = &sva->len[vc_ref-1];
      /* vc_len[0] is not used;
       * vc_len[j], 1 <= j <= n, is length of j-th column */
      int *vc_cap = &sva->cap[vc_ref-1];
      /* vc_cap[0] is not used;
       * vc_cap[j], 1 <= j <= n, is capacity of j-th column */
#endif
      /*--------------------------------------------------------------*/
      /* matrix P */
      int *pp_ind; /* int pp_ind[1+n]; */
      /* pp_ind[i] = j means that P[i,j] = 1 */
      int *pp_inv; /* int pp_inv[1+n]; */
      /* pp_inv[j] = i means that P[i,j] = 1 */
      /* if i-th row or column of matrix F is i'-th row or column of
       * matrix L, or if i-th row of matrix V is i'-th row of matrix U,
       * then pp_ind[i] = i' and pp_inv[i'] = i */
      /*--------------------------------------------------------------*/
      /* matrix Q */
      int *qq_ind; /* int qq_ind[1+n]; */
      /* qq_ind[i] = j means that Q[i,j] = 1 */
      int *qq_inv; /* int qq_inv[1+n]; */
      /* qq_inv[j] = i means that Q[i,j] = 1 */
      /* if j-th column of matrix V is j'-th column of matrix U, then
       * qq_ind[j'] = j and qq_inv[j] = j' */
};

#define luf_swap_u_rows(i1, i2) \
      do \
      {  int j1, j2; \
         j1 = pp_inv[i1], j2 = pp_inv[i2]; \
         pp_ind[j1] = i2, pp_inv[i2] = j1; \
         pp_ind[j2] = i1, pp_inv[i1] = j2; \
      } while (0)
/* swap rows i1 and i2 of matrix U = P'* V * Q' */

#define luf_swap_u_cols(j1, j2) \
      do \
      {  int i1, i2; \
         i1 = qq_ind[j1], i2 = qq_ind[j2]; \
         qq_ind[j1] = i2, qq_inv[i2] = j1; \
         qq_ind[j2] = i1, qq_inv[i1] = j2; \
      } while (0)
/* swap columns j1 and j2 of matrix U = P'* V * Q' */

#define luf_store_v_cols _glp_luf_store_v_cols
int luf_store_v_cols(LUF *luf, int (*col)(void *info, int j, int ind[],
      double val[]), void *info, int ind[], double val[]);
/* store matrix V = A in column-wise format */

#define luf_check_all _glp_luf_check_all
void luf_check_all(LUF *luf, int k);
/* check LU-factorization before k-th elimination step */

#define luf_build_v_rows _glp_luf_build_v_rows
void luf_build_v_rows(LUF *luf, int len[/*1+n*/]);
/* build matrix V in row-wise format */

#define luf_build_f_rows _glp_luf_build_f_rows
void luf_build_f_rows(LUF *luf, int len[/*1+n*/]);
/* build matrix F in row-wise format */

#define luf_build_v_cols _glp_luf_build_v_cols
void luf_build_v_cols(LUF *luf, int updat, int len[/*1+n*/]);
/* build matrix V in column-wise format */

#define luf_check_f_rc _glp_luf_check_f_rc
void luf_check_f_rc(LUF *luf);
/* check rows and columns of matrix F */

#define luf_check_v_rc _glp_luf_check_v_rc
void luf_check_v_rc(LUF *luf);
/* check rows and columns of matrix V */

#define luf_f_solve _glp_luf_f_solve
void luf_f_solve(LUF *luf, double x[/*1+n*/]);
/* solve system F * x = b */

#define luf_ft_solve _glp_luf_ft_solve
void luf_ft_solve(LUF *luf, double x[/*1+n*/]);
/* solve system F' * x = b */

#define luf_v_solve _glp_luf_v_solve
void luf_v_solve(LUF *luf, double b[/*1+n*/], double x[/*1+n*/]);
/* solve system V * x = b */

#define luf_vt_solve _glp_luf_vt_solve
void luf_vt_solve(LUF *luf, double b[/*1+n*/], double x[/*1+n*/]);
/* solve system V' * x = b */

#define luf_vt_solve1 _glp_luf_vt_solve1
void luf_vt_solve1(LUF *luf, double e[/*1+n*/], double y[/*1+n*/]);
/* solve system V' * y = e' to cause growth in y */

#define luf_estimate_norm _glp_luf_estimate_norm
double luf_estimate_norm(LUF *luf, double w1[/*1+n*/], double
      w2[/*1+n*/]);
/* estimate 1-norm of inv(A) */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/lufint.c0000644000175100001710000001316500000000000024635 0ustar00runnerdocker00000000000000/* lufint.c (interface to LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "lufint.h"

LUFINT *lufint_create(void)
{     /* create interface to LU-factorization */
      LUFINT *fi;
      fi = talloc(1, LUFINT);
      fi->n_max = 0;
      fi->valid = 0;
      fi->sva = NULL;
      fi->luf = NULL;
      fi->sgf = NULL;
      fi->sva_n_max = fi->sva_size = 0;
      fi->delta_n0 = fi->delta_n = 0;
      fi->sgf_updat = 0;
      fi->sgf_piv_tol = 0.10;
      fi->sgf_piv_lim = 4;
      fi->sgf_suhl = 1;
      fi->sgf_eps_tol = DBL_EPSILON;
      return fi;
}

int lufint_factorize(LUFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info)
{     /* compute LU-factorization of specified matrix A */
      SVA *sva;
      LUF *luf;
      SGF *sgf;
      int k;
      xassert(n > 0);
      fi->valid = 0;
      /* create sparse vector area (SVA), if necessary */
      sva = fi->sva;
      if (sva == NULL)
      {  int sva_n_max = fi->sva_n_max;
         int sva_size = fi->sva_size;
         if (sva_n_max == 0)
            sva_n_max = 4 * n;
         if (sva_size == 0)
            sva_size = 10 * n;
         sva = fi->sva = sva_create_area(sva_n_max, sva_size);
      }
      /* allocate/reallocate underlying objects, if necessary */
      if (fi->n_max < n)
      {  int n_max = fi->n_max;
         if (n_max == 0)
            n_max = fi->n_max = n + fi->delta_n0;
         else
            n_max = fi->n_max = n + fi->delta_n;
         xassert(n_max >= n);
         /* allocate/reallocate LU-factorization (LUF) */
         luf = fi->luf;
         if (luf == NULL)
         {  luf = fi->luf = talloc(1, LUF);
            memset(luf, 0, sizeof(LUF));
            luf->sva = sva;
         }
         else
         {  tfree(luf->vr_piv);
            tfree(luf->pp_ind);
            tfree(luf->pp_inv);
            tfree(luf->qq_ind);
            tfree(luf->qq_inv);
         }
         luf->vr_piv = talloc(1+n_max, double);
         luf->pp_ind = talloc(1+n_max, int);
         luf->pp_inv = talloc(1+n_max, int);
         luf->qq_ind = talloc(1+n_max, int);
         luf->qq_inv = talloc(1+n_max, int);
         /* allocate/reallocate factorizer workspace (SGF) */
         sgf = fi->sgf;
         if (sgf == NULL)
         {  sgf = fi->sgf = talloc(1, SGF);
            memset(sgf, 0, sizeof(SGF));
            sgf->luf = luf;
         }
         else
         {  tfree(sgf->rs_head);
            tfree(sgf->rs_prev);
            tfree(sgf->rs_next);
            tfree(sgf->cs_head);
            tfree(sgf->cs_prev);
            tfree(sgf->cs_next);
            tfree(sgf->vr_max);
            tfree(sgf->flag);
            tfree(sgf->work);
         }
         sgf->rs_head = talloc(1+n_max, int);
         sgf->rs_prev = talloc(1+n_max, int);
         sgf->rs_next = talloc(1+n_max, int);
         sgf->cs_head = talloc(1+n_max, int);
         sgf->cs_prev = talloc(1+n_max, int);
         sgf->cs_next = talloc(1+n_max, int);
         sgf->vr_max = talloc(1+n_max, double);
         sgf->flag = talloc(1+n_max, char);
         sgf->work = talloc(1+n_max, double);
      }
      luf = fi->luf;
      sgf = fi->sgf;
#if 1 /* FIXME */
      /* initialize SVA */
      sva->n = 0;
      sva->m_ptr = 1;
      sva->r_ptr = sva->size + 1;
      sva->head = sva->tail = 0;
#endif
      /* allocate sparse vectors in SVA */
      luf->n = n;
      luf->fr_ref = sva_alloc_vecs(sva, n);
      luf->fc_ref = sva_alloc_vecs(sva, n);
      luf->vr_ref = sva_alloc_vecs(sva, n);
      luf->vc_ref = sva_alloc_vecs(sva, n);
      /* store matrix V = A in column-wise format */
      luf_store_v_cols(luf, col, info, sgf->rs_prev, sgf->work);
      /* setup factorizer control parameters */
      sgf->updat = fi->sgf_updat;
      sgf->piv_tol = fi->sgf_piv_tol;
      sgf->piv_lim = fi->sgf_piv_lim;
      sgf->suhl = fi->sgf_suhl;
      sgf->eps_tol = fi->sgf_eps_tol;
      /* compute LU-factorization of specified matrix A */
      k = sgf_factorize(sgf, 1);
      if (k == 0)
         fi->valid = 1;
      return k;
}

void lufint_delete(LUFINT *fi)
{     /* delete interface to LU-factorization */
      SVA *sva = fi->sva;
      LUF *luf = fi->luf;
      SGF *sgf = fi->sgf;
      if (sva != NULL)
         sva_delete_area(sva);
      if (luf != NULL)
      {  tfree(luf->vr_piv);
         tfree(luf->pp_ind);
         tfree(luf->pp_inv);
         tfree(luf->qq_ind);
         tfree(luf->qq_inv);
         tfree(luf);
      }
      if (sgf != NULL)
      {  tfree(sgf->rs_head);
         tfree(sgf->rs_prev);
         tfree(sgf->rs_next);
         tfree(sgf->cs_head);
         tfree(sgf->cs_prev);
         tfree(sgf->cs_next);
         tfree(sgf->vr_max);
         tfree(sgf->flag);
         tfree(sgf->work);
         tfree(sgf);
      }
      tfree(fi);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/lufint.h0000644000175100001710000000451000000000000024634 0ustar00runnerdocker00000000000000/* lufint.h (interface to LU-factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef LUFINT_H
#define LUFINT_H

#include "sgf.h"

typedef struct LUFINT LUFINT;

struct LUFINT
{     /* interface to LU-factorization */
      int n_max;
      /* maximal value of n (increased automatically) */
      int valid;
      /* factorization is valid only if this flag is set */
      SVA *sva;
      /* sparse vector area (SVA) */
      LUF *luf;
      /* sparse LU-factorization */
      SGF *sgf;
      /* sparse Gaussian factorizer workspace */
      /*--------------------------------------------------------------*/
      /* control parameters */
      int sva_n_max, sva_size;
      /* parameters passed to sva_create_area */
      int delta_n0, delta_n;
      /* if n_max = 0, set n_max = n + delta_n0
       * if n_max < n, set n_max = n + delta_n */
      int sgf_updat;
      double sgf_piv_tol;
      int sgf_piv_lim;
      int sgf_suhl;
      double sgf_eps_tol;
      /* factorizer control parameters */
};

#define lufint_create _glp_lufint_create
LUFINT *lufint_create(void);
/* create interface to LU-factorization */

#define lufint_factorize _glp_lufint_factorize
int lufint_factorize(LUFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info);
/* compute LU-factorization of specified matrix A */

#define lufint_delete _glp_lufint_delete
void lufint_delete(LUFINT *fi);
/* delete interface to LU-factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/scf.c0000644000175100001710000004054500000000000024111 0ustar00runnerdocker00000000000000/* scf.c (sparse updatable Schur-complement-based factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "scf.h"

/***********************************************************************
*  scf_r0_solve - solve system R0 * x = b or R0'* x = b
*
*  This routine solves the system R0 * x = b (if tr is zero) or the
*  system R0'* x = b (if tr is non-zero), where R0 is the left factor
*  of the initial matrix A0 = R0 * S0.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n0], where n0 is the order of the
*  matrix R0. On exit the array x will contain elements of the solution
*  vector in the same locations. */

void scf_r0_solve(SCF *scf, int tr, double x[/*1+n0*/])
{     switch (scf->type)
      {  case 1:
            /* A0 = F0 * V0, so R0 = F0 */
            if (!tr)
               luf_f_solve(scf->a0.luf, x);
            else
               luf_ft_solve(scf->a0.luf, x);
            break;
         case 2:
            /* A0 = I * A0, so R0 = I */
            break;
         default:
            xassert(scf != scf);
      }
      return;
}

/***********************************************************************
*  scf_s0_solve - solve system S0 * x = b or S0'* x = b
*
*  This routine solves the system S0 * x = b (if tr is zero) or the
*  system S0'* x = b (if tr is non-zero), where S0 is the right factor
*  of the initial matrix A0 = R0 * S0.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n0], where n0 is the order of the
*  matrix S0. On exit the array x will contain elements of the solution
*  vector in the same locations.
*
*  The routine uses locations [1], ..., [n0] of three working arrays
*  w1, w2, and w3. (In case of type = 1 arrays w2 and w3 are not used
*  and can be specified as NULL.) */

void scf_s0_solve(SCF *scf, int tr, double x[/*1+n0*/],
      double w1[/*1+n0*/], double w2[/*1+n0*/], double w3[/*1+n0*/])
{     int n0 = scf->n0;
      switch (scf->type)
      {  case 1:
            /* A0 = F0 * V0, so S0 = V0 */
            if (!tr)
               luf_v_solve(scf->a0.luf, x, w1);
            else
               luf_vt_solve(scf->a0.luf, x, w1);
            break;
         case 2:
            /* A0 = I * A0, so S0 = A0 */
            if (!tr)
               btf_a_solve(scf->a0.btf, x, w1, w2, w3);
            else
               btf_at_solve(scf->a0.btf, x, w1, w2, w3);
            break;
         default:
            xassert(scf != scf);
      }
      memcpy(&x[1], &w1[1], n0 * sizeof(double));
      return;
}

/***********************************************************************
*  scf_r_prod - compute product y := y + alpha * R * x
*
*  This routine computes the product y := y + alpha * R * x, where
*  x is a n0-vector, alpha is a scalar, y is a nn-vector.
*
*  Since matrix R is available by rows, the product components are
*  computed as inner products:
*
*     y[i] = y[i] + alpha * (i-th row of R) * x
*
*  for i = 1, 2, ..., nn. */

void scf_r_prod(SCF *scf, double y[/*1+nn*/], double a, const double
      x[/*1+n0*/])
{     int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int rr_ref = scf->rr_ref;
      int *rr_ptr = &sva->ptr[rr_ref-1];
      int *rr_len = &sva->len[rr_ref-1];
      int i, ptr, end;
      double t;
      for (i = 1; i <= nn; i++)
      {  /* t := (i-th row of R) * x */
         t = 0.0;
         for (end = (ptr = rr_ptr[i]) + rr_len[i]; ptr < end; ptr++)
            t += sv_val[ptr] * x[sv_ind[ptr]];
         /* y[i] := y[i] + alpha * t */
         y[i] += a * t;
      }
      return;
}

/***********************************************************************
*  scf_rt_prod - compute product y := y + alpha * R'* x
*
*  This routine computes the product y := y + alpha * R'* x, where
*  R' is a matrix transposed to R, x is a nn-vector, alpha is a scalar,
*  y is a n0-vector.
*
*  Since matrix R is available by rows, the product is computed as a
*  linear combination:
*
*     y := y + alpha * (R'[1] * x[1] + ... + R'[nn] * x[nn]),
*
*  where R'[i] is i-th row of R. */

void scf_rt_prod(SCF *scf, double y[/*1+n0*/], double a, const double
      x[/*1+nn*/])
{     int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int rr_ref = scf->rr_ref;
      int *rr_ptr = &sva->ptr[rr_ref-1];
      int *rr_len = &sva->len[rr_ref-1];
      int i, ptr, end;
      double t;
      for (i = 1; i <= nn; i++)
      {  if (x[i] == 0.0)
            continue;
         /* y := y + alpha * R'[i] * x[i] */
         t = a * x[i];
         for (end = (ptr = rr_ptr[i]) + rr_len[i]; ptr < end; ptr++)
            y[sv_ind[ptr]] += sv_val[ptr] * t;
      }
      return;
}

/***********************************************************************
*  scf_s_prod - compute product y := y + alpha * S * x
*
*  This routine computes the product y := y + alpha * S * x, where
*  x is a nn-vector, alpha is a scalar, y is a n0 vector.
*
*  Since matrix S is available by columns, the product is computed as
*  a linear combination:
*
*     y := y + alpha * (S[1] * x[1] + ... + S[nn] * x[nn]),
*
*  where S[j] is j-th column of S. */

void scf_s_prod(SCF *scf, double y[/*1+n0*/], double a, const double
      x[/*1+nn*/])
{     int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int ss_ref = scf->ss_ref;
      int *ss_ptr = &sva->ptr[ss_ref-1];
      int *ss_len = &sva->len[ss_ref-1];
      int j, ptr, end;
      double t;
      for (j = 1; j <= nn; j++)
      {  if (x[j] == 0.0)
            continue;
         /* y := y + alpha * S[j] * x[j] */
         t = a * x[j];
         for (end = (ptr = ss_ptr[j]) + ss_len[j]; ptr < end; ptr++)
            y[sv_ind[ptr]] += sv_val[ptr] * t;
      }
      return;
}

/***********************************************************************
*  scf_st_prod - compute product y := y + alpha * S'* x
*
*  This routine computes the product y := y + alpha * S'* x, where
*  S' is a matrix transposed to S, x is a n0-vector, alpha is a scalar,
*  y is a nn-vector.
*
*  Since matrix S is available by columns, the product components are
*  computed as inner products:
*
*     y[j] := y[j] + alpha * (j-th column of S) * x
*
*  for j = 1, 2, ..., nn. */

void scf_st_prod(SCF *scf, double y[/*1+nn*/], double a, const double
      x[/*1+n0*/])
{     int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int ss_ref = scf->ss_ref;
      int *ss_ptr = &sva->ptr[ss_ref-1];
      int *ss_len = &sva->len[ss_ref-1];
      int j, ptr, end;
      double t;
      for (j = 1; j <= nn; j++)
      {  /* t := (j-th column of S) * x */
         t = 0.0;
         for (end = (ptr = ss_ptr[j]) + ss_len[j]; ptr < end; ptr++)
            t += sv_val[ptr] * x[sv_ind[ptr]];
         /* y[j] := y[j] + alpha * t */
         y[j] += a * t;
      }
      return;
}

/***********************************************************************
*  scf_a_solve - solve system A * x = b
*
*  This routine solves the system A * x = b, where A is the current
*  matrix.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix A. On exit the array x will contain elements of the solution
*  vector in the same locations.
*
*  For details see the program documentation. */

void scf_a_solve(SCF *scf, double x[/*1+n*/],
      double w[/*1+n0+nn*/], double work1[/*1+max(n0,nn)*/],
      double work2[/*1+n*/], double work3[/*1+n*/])
{     int n = scf->n;
      int n0 = scf->n0;
      int nn = scf->nn;
      int *pp_ind = scf->pp_ind;
      int *qq_inv = scf->qq_inv;
      int i, ii;
      /* (u1, u2) := inv(P) * (b, 0) */
      for (ii = 1; ii <= n0+nn; ii++)
      {  i = pp_ind[ii];
#if 1 /* FIXME: currently P = I */
         xassert(i == ii);
#endif
         w[ii] = (i <= n ? x[i] : 0.0);
      }
      /* v1 := inv(R0) * u1 */
      scf_r0_solve(scf, 0, &w[0]);
      /* v2 := u2 - R * v1 */
      scf_r_prod(scf, &w[n0], -1.0, &w[0]);
      /* w2 := inv(C) * v2 */
      ifu_a_solve(&scf->ifu, &w[n0], work1);
      /* w1 := inv(S0) * (v1 - S * w2) */
      scf_s_prod(scf, &w[0], -1.0, &w[n0]);
      scf_s0_solve(scf, 0, &w[0], work1, work2, work3);
      /* (x, x~) := inv(Q) * (w1, w2); x~ is not needed */
      for (i = 1; i <= n; i++)
         x[i] = w[qq_inv[i]];
      return;
}

/***********************************************************************
*  scf_at_solve - solve system A'* x = b
*
*  This routine solves the system A'* x = b, where A' is a matrix
*  transposed to the current matrix A.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix A. On exit the array x will contain elements of the solution
*  vector in the same locations.
*
*  For details see the program documentation. */

void scf_at_solve(SCF *scf, double x[/*1+n*/],
      double w[/*1+n0+nn*/], double work1[/*1+max(n0,nn)*/],
      double work2[/*1+n*/], double work3[/*1+n*/])
{     int n = scf->n;
      int n0 = scf->n0;
      int nn = scf->nn;
      int *pp_inv = scf->pp_inv;
      int *qq_ind = scf->qq_ind;
      int i, ii;
      /* (u1, u2) := Q * (b, 0) */
      for (ii = 1; ii <= n0+nn; ii++)
      {  i = qq_ind[ii];
         w[ii] = (i <= n ? x[i] : 0.0);
      }
      /* v1 := inv(S0') * u1 */
      scf_s0_solve(scf, 1, &w[0], work1, work2, work3);
      /* v2 := inv(C') * (u2 - S'* v1) */
      scf_st_prod(scf, &w[n0], -1.0, &w[0]);
      ifu_at_solve(&scf->ifu, &w[n0], work1);
      /* w2 := v2 */
      /* nop */
      /* w1 := inv(R0') * (v1 - R'* w2) */
      scf_rt_prod(scf, &w[0], -1.0, &w[n0]);
      scf_r0_solve(scf, 1, &w[0]);
      /* compute (x, x~) := P * (w1, w2); x~ is not needed */
      for (i = 1; i <= n; i++)
      {
#if 1 /* FIXME: currently P = I */
         xassert(pp_inv[i] == i);
#endif
         x[i] = w[pp_inv[i]];
      }
      return;
}

/***********************************************************************
*  scf_add_r_row - add new row to matrix R
*
*  This routine adds new (nn+1)-th row to matrix R, whose elements are
*  specified in locations w[1,...,n0]. */

void scf_add_r_row(SCF *scf, const double w[/*1+n0*/])
{     int n0 = scf->n0;
      int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int rr_ref = scf->rr_ref;
      int *rr_ptr = &sva->ptr[rr_ref-1];
      int *rr_len = &sva->len[rr_ref-1];
      int j, len, ptr;
      xassert(0 <= nn && nn < scf->nn_max);
      /* determine length of new row */
      len = 0;
      for (j = 1; j <= n0; j++)
      {  if (w[j] != 0.0)
            len++;
      }
      /* reserve locations for new row in static part of SVA */
      if (len > 0)
      {  if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_reserve_cap(sva, rr_ref + nn, len);
      }
      /* store new row in sparse format */
      ptr = rr_ptr[nn+1];
      for (j = 1; j <= n0; j++)
      {  if (w[j] != 0.0)
         {  sv_ind[ptr] = j;
            sv_val[ptr] = w[j];
            ptr++;
         }
      }
      xassert(ptr - rr_ptr[nn+1] == len);
      rr_len[nn+1] = len;
#ifdef GLP_DEBUG
      sva_check_area(sva);
#endif
      return;
}

/***********************************************************************
*  scf_add_s_col - add new column to matrix S
*
*  This routine adds new (nn+1)-th column to matrix S, whose elements
*  are specified in locations v[1,...,n0]. */

void scf_add_s_col(SCF *scf, const double v[/*1+n0*/])
{     int n0 = scf->n0;
      int nn = scf->nn;
      SVA *sva = scf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int ss_ref = scf->ss_ref;
      int *ss_ptr = &sva->ptr[ss_ref-1];
      int *ss_len = &sva->len[ss_ref-1];
      int i, len, ptr;
      xassert(0 <= nn && nn < scf->nn_max);
      /* determine length of new column */
      len = 0;
      for (i = 1; i <= n0; i++)
      {  if (v[i] != 0.0)
            len++;
      }
      /* reserve locations for new column in static part of SVA */
      if (len > 0)
      {  if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_reserve_cap(sva, ss_ref + nn, len);
      }
      /* store new column in sparse format */
      ptr = ss_ptr[nn+1];
      for (i = 1; i <= n0; i++)
      {  if (v[i] != 0.0)
         {  sv_ind[ptr] = i;
            sv_val[ptr] = v[i];
            ptr++;
         }
      }
      xassert(ptr - ss_ptr[nn+1] == len);
      ss_len[nn+1] = len;
#ifdef GLP_DEBUG
      sva_check_area(sva);
#endif
      return;
}

/***********************************************************************
*  scf_update_aug - update factorization of augmented matrix
*
*  Given factorization of the current augmented matrix:
*
*     ( A0  A1 )   ( R0    ) ( S0  S )
*     (        ) = (       ) (       ),
*     ( A2  A3 )   ( R   I ) (     C )
*
*  this routine computes factorization of the new augmented matrix:
*
*     ( A0 | A1  b )
*     ( ---+------ )   ( A0  A1^ )   ( R0    ) ( S0  S^ )
*     ( A2 | A3  f ) = (         ) = (       ) (        ),
*     (    |       )   ( A2^ A3^ )   ( R^  I ) (     C^ )
*     ( d' | g'  h )
*
*  where b and d are specified n0-vectors, f and g are specified
*  nn-vectors, and h is a specified scalar. (Note that corresponding
*  arrays are clobbered on exit.)
*
*  The parameter upd specifies how to update factorization of the Schur
*  complement C:
*
*  1  Bartels-Golub updating.
*
*  2  Givens rotations updating.
*
*  The working arrays w1, w2, and w3 are used in the same way as in the
*  routine scf_s0_solve.
*
*  RETURNS
*
*  0  Factorization has been successfully updated.
*
*  1  Updating limit has been reached.
*
*  2  Updating IFU-factorization of matrix C failed.
*
*  For details see the program documentation. */

int scf_update_aug(SCF *scf, double b[/*1+n0*/], double d[/*1+n0*/],
      double f[/*1+nn*/], double g[/*1+nn*/], double h, int upd,
      double w1[/*1+n0*/], double w2[/*1+n0*/], double w3[/*1+n0*/])
{     int n0 = scf->n0;
      int k, ret;
      double *v, *w, *x, *y, z;
      if (scf->nn == scf->nn_max)
      {  /* updating limit has been reached */
         return 1;
      }
      /* v := inv(R0) * b */
      scf_r0_solve(scf, 0, (v = b));
      /* w := inv(S0') * d */
      scf_s0_solve(scf, 1, (w = d), w1, w2, w3);
      /* x := f - R * v */
      scf_r_prod(scf, (x = f), -1.0, v);
      /* y := g - S'* w */
      scf_st_prod(scf, (y = g), -1.0, w);
      /* z := h - v'* w */
      z = h;
      for (k = 1; k <= n0; k++)
         z -= v[k] * w[k];
      /* new R := R with row w added */
      scf_add_r_row(scf, w);
      /* new S := S with column v added */
      scf_add_s_col(scf, v);
      /* update IFU-factorization of C */
      switch (upd)
      {  case 1:
            ret = ifu_bg_update(&scf->ifu, x, y, z);
            break;
         case 2:
            ret = ifu_gr_update(&scf->ifu, x, y, z);
            break;
         default:
            xassert(upd != upd);
      }
      if (ret != 0)
      {  /* updating IFU-factorization failed */
         return 2;
      }
      /* increase number of additional rows and columns */
      scf->nn++;
      /* expand P and Q */
      k = n0 + scf->nn;
      scf->pp_ind[k] = scf->pp_inv[k] = k;
      scf->qq_ind[k] = scf->qq_inv[k] = k;
      /* factorization has been successfully updated */
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/scf.h0000644000175100001710000001736100000000000024116 0ustar00runnerdocker00000000000000/* scf.h (sparse updatable Schur-complement-based factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SCF_H
#define SCF_H

#include "btf.h"
#include "ifu.h"
#include "luf.h"

/***********************************************************************
*  The structure SCF describes sparse updatable factorization based on
*  Schur complement.
*
*  The SCF-factorization has the following format:
*
*     ( A   A1~ )     ( A0  A1 )       ( R0    ) ( S0  S )
*     (         ) = P (        ) Q = P (       ) (       ) Q,        (1)
*     ( A2~ A3~ )     ( A2  A3 )       ( R   I ) (     C )
*
*  where:
*
*  A is current (unsymmetric) square matrix (not stored);
*
*  A1~, A2~, A3~ are some additional matrices (not stored);
*
*  A0 is initial (unsymmetric) square matrix (not stored);
*
*  A1, A2, A3 are some additional matrices (not stored);
*
*  R0 and S0 are matrices that define factorization of the initial
*  matrix A0 = R0 * S0 (stored in an invertable form);
*
*  R is a matrix defined from R * S0 = A2, so R = A2 * inv(S0) (stored
*  in row-wise sparse format);
*
*  S is a matrix defined from R0 * S = A1, so S = inv(R0) * A1 (stored
*  in column-wise sparse format);
*
*  C is Schur complement (to matrix A0) defined from R * S + C = A3,
*  so C = A3 - R * S = A3 - A2 * inv(A0) * A1 (stored in an invertable
*  form).
*
*  P, Q are permutation matrices (stored in both row- and column-like
*  formats). */

typedef struct SCF SCF;

struct SCF
{     /* Schur-complement-based factorization */
      int n;
      /* order of current matrix A */
      /*--------------------------------------------------------------*/
      /* initial matrix A0 = R0 * S0 of order n0 in invertable form */
      int n0;
      /* order of matrix A0 */
      int type;
      /* type of factorization used:
       * 1 - LU-factorization (R0 = F0, S0 = V0)
       * 2 - BT-factorization (R0 = I, S0 = A0) */
      union
      {  LUF *luf; /* type = 1 */
         BTF *btf; /* type = 2 */
      }  a0;
      /* factorization of matrix A0 */
      /*--------------------------------------------------------------*/
      /* augmented matrix (A0, A1; A2, A3) of order n0+nn */
      int nn_max;
      /* maximal number of additional rows and columns in the augmented
       * matrix (this limits the number of updates) */
      int nn;
      /* current number of additional rows and columns in the augmented
       * matrix, 0 <= nn <= nn_max */
      SVA *sva;
      /* associated sparse vector area (SVA) used to store rows of
       * matrix R and columns of matrix S */
      /*--------------------------------------------------------------*/
      /* nn*n0-matrix R in row-wise format */
      int rr_ref;
      /* reference number of sparse vector in SVA, which is the first
       * row of matrix R */
#if 0 + 0
      int *rr_ptr = &sva->ptr[rr_ref-1];
      /* rr_ptr[0] is not used;
       * rr_ptr[i], 1 <= i <= nn, is pointer to i-th row in SVA;
       * rr_ptr[nn+1,...,nn_max] are reserved locations */
      int *rr_len = &sva->len[rr_ref-1];
      /* rr_len[0] is not used;
       * rr_len[i], 1 <= i <= nn, is length of i-th row;
       * rr_len[nn+1,...,nn_max] are reserved locations */
#endif
      /*--------------------------------------------------------------*/
      /* n0*nn-matrix S in column-wise format */
      int ss_ref;
      /* reference number of sparse vector in SVA, which is the first
       * column of matrix S */
#if 0 + 0
      int *ss_ptr = &sva->ptr[ss_ref-1];
      /* ss_ptr[0] is not used;
       * ss_ptr[j], 1 <= j <= nn, is pointer to j-th column in SVA;
       * ss_ptr[nn+1,...,nn_max] are reserved locations */
      int *ss_len = &sva->len[ss_ref-1];
      /* ss_len[0] is not used;
       * ss_len[j], 1 <= j <= nn, is length of j-th column;
       * ss_len[nn+1,...,nn_max] are reserved locations */
#endif
      /*--------------------------------------------------------------*/
      /* Schur complement C of order nn in invertable form */
      IFU ifu;
      /* IFU-factorization of matrix C */
      /*--------------------------------------------------------------*/
      /* permutation matrix P of order n0+nn */
      int *pp_ind; /* int pp_ind[1+n0+nn_max]; */
      /* pp_ind[i] = j means that P[i,j] = 1 */
      int *pp_inv; /* int pp_inv[1+n0+nn_max]; */
      /* pp_inv[j] = i means that P[i,j] = 1 */
      /*--------------------------------------------------------------*/
      /* permutation matrix Q of order n0+nn */
      int *qq_ind; /* int qq_ind[1+n0+nn_max]; */
      /* qq_ind[i] = j means that Q[i,j] = 1 */
      int *qq_inv; /* int qq_inv[1+n0+nn_max]; */
      /* qq_inv[j] = i means that Q[i,j] = 1 */
};

#define scf_swap_q_cols(j1, j2) \
      do \
      {  int i1, i2; \
         i1 = qq_inv[j1], i2 = qq_inv[j2]; \
         qq_ind[i1] = j2, qq_inv[j2] = i1; \
         qq_ind[i2] = j1, qq_inv[j1] = i2; \
      }  while (0)
/* swap columns j1 and j2 of permutation matrix Q */

#define scf_r0_solve _glp_scf_r0_solve
void scf_r0_solve(SCF *scf, int tr, double x[/*1+n0*/]);
/* solve system R0 * x = b or R0'* x = b */

#define scf_s0_solve _glp_scf_s0_solve
void scf_s0_solve(SCF *scf, int tr, double x[/*1+n0*/],
      double w1[/*1+n0*/], double w2[/*1+n0*/], double w3[/*1+n0*/]);
/* solve system S0 * x = b or S0'* x = b */

#define scf_r_prod _glp_scf_r_prod
void scf_r_prod(SCF *scf, double y[/*1+nn*/], double a, const double
      x[/*1+n0*/]);
/* compute product y := y + alpha * R * x */

#define scf_rt_prod _glp_scf_rt_prod
void scf_rt_prod(SCF *scf, double y[/*1+n0*/], double a, const double
      x[/*1+nn*/]);
/* compute product y := y + alpha * R'* x */

#define scf_s_prod _glp_scf_s_prod
void scf_s_prod(SCF *scf, double y[/*1+n0*/], double a, const double
      x[/*1+nn*/]);
/* compute product y := y + alpha * S * x */

#define scf_st_prod _glp_scf_st_prod
void scf_st_prod(SCF *scf, double y[/*1+nn*/], double a, const double
      x[/*1+n0*/]);
/* compute product y := y + alpha * S'* x */

#define scf_a_solve _glp_scf_a_solve
void scf_a_solve(SCF *scf, double x[/*1+n*/],
      double w[/*1+n0+nn*/], double work1[/*1+max(n0,nn)*/],
      double work2[/*1+n*/], double work3[/*1+n*/]);
/* solve system A * x = b */

#define scf_at_solve _glp_scf_at_solve
void scf_at_solve(SCF *scf, double x[/*1+n*/],
      double w[/*1+n0+nn*/], double work1[/*1+max(n0,nn)*/],
      double work2[/*1+n*/], double work3[/*1+n*/]);
/* solve system A'* x = b */

#define scf_add_r_row _glp_scf_add_r_row
void scf_add_r_row(SCF *scf, const double w[/*1+n0*/]);
/* add new row to matrix R */

#define scf_add_s_col _glp_scf_add_s_col
void scf_add_s_col(SCF *scf, const double v[/*1+n0*/]);
/* add new column to matrix S */

#define scf_update_aug _glp_scf_update_aug
int scf_update_aug(SCF *scf, double b[/*1+n0*/], double d[/*1+n0*/],
      double f[/*1+nn*/], double g[/*1+nn*/], double h, int upd,
      double w1[/*1+n0*/], double w2[/*1+n0*/], double w3[/*1+n0*/]);
/* update factorization of augmented matrix */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/scfint.c0000644000175100001710000001751500000000000024625 0ustar00runnerdocker00000000000000/* scfint.c (interface to Schur-complement-based factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "scfint.h"

SCFINT *scfint_create(int type)
{     /* create interface to SC-factorization */
      SCFINT *fi;
      fi = talloc(1, SCFINT);
      memset(fi, 0, sizeof(SCFINT));
      switch ((fi->scf.type = type))
      {  case 1:
            fi->u.lufi = lufint_create();
            break;
         case 2:
            fi->u.btfi = btfint_create();
            break;
         default:
            xassert(type != type);
      }
      return fi;
}

int scfint_factorize(SCFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info)
{     /* compute SC-factorization of specified matrix A */
      int nn_max, old_n0_max, n0_max, k, ret;
      xassert(n > 0);
      fi->valid = 0;
      /* get required value of nn_max */
      nn_max = fi->nn_max;
      if (nn_max == 0)
         nn_max = 100;
      xassert(nn_max > 0);
      /* compute factorization of specified matrix A */
      switch (fi->scf.type)
      {  case 1:
            old_n0_max = fi->u.lufi->n_max;
            fi->u.lufi->sva_n_max = 4 * n + 2 * nn_max;
            ret = lufint_factorize(fi->u.lufi, n, col, info);
            n0_max = fi->u.lufi->n_max;
            fi->scf.sva = fi->u.lufi->sva;
            fi->scf.a0.luf = fi->u.lufi->luf;
            break;
         case 2:
            old_n0_max = fi->u.btfi->n_max;
            fi->u.btfi->sva_n_max = 6 * n + 2 * nn_max;
            ret = btfint_factorize(fi->u.btfi, n, col, info);
            n0_max = fi->u.btfi->n_max;
            fi->scf.sva = fi->u.btfi->sva;
            fi->scf.a0.btf = fi->u.btfi->btf;
            break;
         default:
            xassert(fi != fi);
      }
      /* allocate/reallocate arrays, if necessary */
      if (old_n0_max < n0_max)
      {  if (fi->w1 != NULL)
            tfree(fi->w1);
         if (fi->w2 != NULL)
            tfree(fi->w2);
         if (fi->w3 != NULL)
            tfree(fi->w3);
         fi->w1 = talloc(1+n0_max, double);
         fi->w2 = talloc(1+n0_max, double);
         fi->w3 = talloc(1+n0_max, double);
      }
      if (fi->scf.nn_max != nn_max)
      {  if (fi->scf.ifu.f != NULL)
            tfree(fi->scf.ifu.f);
         if (fi->scf.ifu.u != NULL)
            tfree(fi->scf.ifu.u);
         fi->scf.ifu.f = talloc(nn_max * nn_max, double);
         fi->scf.ifu.u = talloc(nn_max * nn_max, double);
      }
      if (old_n0_max < n0_max || fi->scf.nn_max != nn_max)
      {  if (fi->scf.pp_ind != NULL)
            tfree(fi->scf.pp_ind);
         if (fi->scf.pp_inv != NULL)
            tfree(fi->scf.pp_inv);
         if (fi->scf.qq_ind != NULL)
            tfree(fi->scf.qq_ind);
         if (fi->scf.qq_inv != NULL)
            tfree(fi->scf.qq_inv);
         if (fi->w4 != NULL)
            tfree(fi->w4);
         if (fi->w5 != NULL)
            tfree(fi->w5);
         fi->scf.pp_ind = talloc(1+n0_max+nn_max, int);
         fi->scf.pp_inv = talloc(1+n0_max+nn_max, int);
         fi->scf.qq_ind = talloc(1+n0_max+nn_max, int);
         fi->scf.qq_inv = talloc(1+n0_max+nn_max, int);
         fi->w4 = talloc(1+n0_max+nn_max, double);
         fi->w5 = talloc(1+n0_max+nn_max, double);
      }
      /* initialize SC-factorization */
      fi->scf.n = n;
      fi->scf.n0 = n;
      fi->scf.nn_max = nn_max;
      fi->scf.nn = 0;
      fi->scf.rr_ref = sva_alloc_vecs(fi->scf.sva, nn_max);
      fi->scf.ss_ref = sva_alloc_vecs(fi->scf.sva, nn_max);
      fi->scf.ifu.n_max = nn_max;
      fi->scf.ifu.n = 0;
      for (k = 1; k <= n; k++)
      {  fi->scf.pp_ind[k] = k;
         fi->scf.pp_inv[k] = k;
         fi->scf.qq_ind[k] = k;
         fi->scf.qq_inv[k] = k;
      }
      /* set validation flag */
      if (ret == 0)
         fi->valid = 1;
      return ret;
}

int scfint_update(SCFINT *fi, int upd, int j, int len, const int ind[],
      const double val[])
{     /* update SC-factorization after replacing j-th column of A */
      int n = fi->scf.n;
      int n0 = fi->scf.n0;
      int nn = fi->scf.nn;
      int *pp_ind = fi->scf.pp_ind;
      int *qq_ind = fi->scf.qq_ind;
      int *qq_inv = fi->scf.qq_inv;
      double *bf = fi->w4;
      double *dg = fi->w5;
      int k, t, ret;
      xassert(fi->valid);
      xassert(0 <= n && n <= n0+nn);
      /* (b, f) := inv(P) * (beta, 0) */
      for (k = 1; k <= n0+nn; k++)
         bf[k] = 0.0;
      for (t = 1; t <= len; t++)
      {  k = ind[t];
         xassert(1 <= k && k <= n);
#if 1 /* FIXME: currently P = I */
         xassert(pp_ind[k] == k);
#endif
         xassert(bf[k] == 0.0);
         xassert(val[t] != 0.0);
         bf[k] = val[t];
      }
      /* (d, g) := Q * (cj, 0) */
      for (k = 1; k <= n0+nn; k++)
         dg[k] = 0.0;
      xassert(1 <= j && j <= n);
      dg[fi->scf.qq_inv[j]] = 1;
      /* update factorization of augmented matrix */
      ret = scf_update_aug(&fi->scf, &bf[0], &dg[0], &bf[n0], &dg[n0],
         0.0, upd, fi->w1, fi->w2, fi->w3);
      if (ret == 0)
      {  /* swap j-th and last columns of new matrix Q */
         scf_swap_q_cols(j, n0+nn+1);
      }
      else
      {  /* updating failed */
         fi->valid = 0;
      }
      return ret;
}

void scfint_ftran(SCFINT *fi, double x[])
{     /* solve system A * x = b */
      xassert(fi->valid);
      scf_a_solve(&fi->scf, x, fi->w4, fi->w5, fi->w1, fi->w2);
      return;
}

void scfint_btran(SCFINT *fi, double x[])
{     /* solve system A'* x = b */
      xassert(fi->valid);
      scf_at_solve(&fi->scf, x, fi->w4, fi->w5, fi->w1, fi->w2);
      return;
}

double scfint_estimate(SCFINT *fi)
{     /* estimate 1-norm of inv(A) */
      double norm;
      xassert(fi->valid);
      xassert(fi->scf.n == fi->scf.n0);
      switch (fi->scf.type)
      {  case 1:
            norm = luf_estimate_norm(fi->scf.a0.luf, fi->w1, fi->w2);
            break;
         case 2:
            norm = btf_estimate_norm(fi->scf.a0.btf, fi->w1, fi->w2,
               fi->w3, fi->w4);
            break;
         default:
            xassert(fi != fi);
      }
      return norm;
}

void scfint_delete(SCFINT *fi)
{     /* delete interface to SC-factorization */
      switch (fi->scf.type)
      {  case 1:
            lufint_delete(fi->u.lufi);
            break;
         case 2:
            btfint_delete(fi->u.btfi);
            break;
         default:
            xassert(fi != fi);
      }
      if (fi->scf.ifu.f != NULL)
         tfree(fi->scf.ifu.f);
      if (fi->scf.ifu.u != NULL)
         tfree(fi->scf.ifu.u);
      if (fi->scf.pp_ind != NULL)
         tfree(fi->scf.pp_ind);
      if (fi->scf.pp_inv != NULL)
         tfree(fi->scf.pp_inv);
      if (fi->scf.qq_ind != NULL)
         tfree(fi->scf.qq_ind);
      if (fi->scf.qq_inv != NULL)
         tfree(fi->scf.qq_inv);
      if (fi->w1 != NULL)
         tfree(fi->w1);
      if (fi->w2 != NULL)
         tfree(fi->w2);
      if (fi->w3 != NULL)
         tfree(fi->w3);
      if (fi->w4 != NULL)
         tfree(fi->w4);
      if (fi->w5 != NULL)
         tfree(fi->w5);
      tfree(fi);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/scfint.h0000644000175100001710000000567200000000000024633 0ustar00runnerdocker00000000000000/* scfint.h (interface to Schur-complement-based factorization) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SCFINT_H
#define SCFINT_H

#include "scf.h"
#include "lufint.h"
#include "btfint.h"

typedef struct SCFINT SCFINT;

struct SCFINT
{     /* interface to SC-factorization */
      int valid;
      /* factorization is valid only if this flag is set */
      SCF scf;
      /* Schur-complement based factorization */
      union
      {  LUFINT *lufi; /* scf.type = 1 */
         BTFINT *btfi; /* scf.type = 2 */
      }  u;
      /* interface to factorize initial matrix A0 */
      /*--------------------------------------------------------------*/
      /* working arrays */
      double *w1; /* double w1[1+n0_max]; */
      double *w2; /* double w2[1+n0_max]; */
      double *w3; /* double w3[1+n0_max]; */
      double *w4; /* double w4[1+n0_max+nn_max]; */
      double *w5; /* double w5[1+n0_max+nn_max]; */
      /*--------------------------------------------------------------*/
      /* control parameters */
      int nn_max;
      /* required maximal number of updates */
};

#define scfint_create _glp_scfint_create
SCFINT *scfint_create(int type);
/* create interface to SC-factorization */

#define scfint_factorize _glp_scfint_factorize
int scfint_factorize(SCFINT *fi, int n, int (*col)(void *info, int j,
      int ind[], double val[]), void *info);
/* compute SC-factorization of specified matrix A */

#define scfint_update _glp_scfint_update
int scfint_update(SCFINT *fi, int upd, int j, int len, const int ind[],
      const double val[]);
/* update SC-factorization after replacing j-th column of A */

#define scfint_ftran _glp_scfint_ftran
void scfint_ftran(SCFINT *fi, double x[]);
/* solve system A * x = b */

#define scfint_btran _glp_scfint_btran
void scfint_btran(SCFINT *fi, double x[]);
/* solve system A'* x = b */

#define scfint_estimate _glp_scfint_estimate
double scfint_estimate(SCFINT *fi);
/* estimate 1-norm of inv(A) */

#define scfint_delete _glp_scfint_delete
void scfint_delete(SCFINT *fi);
/* delete interface to SC-factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/sgf.c0000644000175100001710000015666500000000000024130 0ustar00runnerdocker00000000000000/* sgf.c (sparse Gaussian factorizer) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "sgf.h"

/***********************************************************************
*  sgf_reduce_nuc - initial reordering to minimize nucleus size
*
*  On entry to this routine it is assumed that V = A and F = P = Q = I,
*  where A is the original matrix to be factorized. It is also assumed
*  that matrix V = A is stored in both row- and column-wise formats.
*
*  This routine performs (implicit) non-symmetric permutations of rows
*  and columns of matrix U = P'* V * Q' to reduce it to the form:
*
*        1     k1    k2    n
*     1  x x x x x x x x x x
*        . x x x x x x x x x
*        . . x x x x x x x x
*     k1 . . . * * * * x x x
*        . . . * * * * x x x
*        . . . * * * * x x x
*     k2 . . . * * * * x x x
*        . . . . . . . x x x
*        . . . . . . . . x x
*     n  . . . . . . . . . x
*
*  where non-zeros in rows and columns k1, k1+1, ..., k2 constitute so
*  called nucleus ('*'), whose size is minimized by the routine.
*
*  The numbers k1 and k2 are returned by the routine on exit. Usually,
*  if the nucleus exists, 1 <= k1 < k2 <= n. However, if the resultant
*  matrix U is upper triangular (has no nucleus), k1 = n+1 and k2 = n.
*
*  Note that the routines sgf_choose_pivot and sgf_eliminate perform
*  exactly the same transformations (by processing row and columns
*  singletons), so preliminary minimization of the nucleus may not be
*  used. However, processing row and column singletons by the routines
*  sgf_minimize_nuc and sgf_singl_phase is more efficient. */

#if 1 /* 21/II-2016 */
/* Normally this routine returns zero. If the matrix is structurally
*  singular, the routine returns non-zero. */
#endif

int sgf_reduce_nuc(LUF *luf, int *k1_, int *k2_, int cnt[/*1+n*/],
      int list[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int i, ii, j, jj, k1, k2, ns, ptr, end;
      /* initial nucleus is U = V = A */
      k1 = 1, k2 = n;
      /*--------------------------------------------------------------*/
      /* process column singletons                                    */
      /*--------------------------------------------------------------*/
      /* determine initial counts of columns of V and initialize list
       * of active column singletons */
      ns = 0; /* number of active column singletons */
      for (j = 1; j <= n; j++)
      {  if ((cnt[j] = vc_len[j]) == 1)
            list[++ns] = j;
      }
      /* process active column singletons */
      while (ns > 0)
      {  /* column singleton is in j-th column of V */
         j = list[ns--];
#if 1 /* 21/II-2016 */
         if (cnt[j] == 0)
         {  /* j-th column in the current nucleus is actually empty */
            /* this happened because on a previous step in the nucleus
             * there were two or more identical column singletons (that
             * means structural singularity), so removing one of them
             * from the nucleus made other columns empty */
            return 1;
         }
#endif
         /* find i-th row of V containing column singleton */
         ptr = vc_ptr[j];
         end = ptr + vc_len[j];
         for (; pp_ind[i = sv_ind[ptr]] < k1; ptr++)
            /* nop */;
         xassert(ptr < end);
         /* permute rows and columns of U to move column singleton to
          * position u[k1,k1] */
         ii = pp_ind[i];
         luf_swap_u_rows(k1, ii);
         jj = qq_inv[j];
         luf_swap_u_cols(k1, jj);
         /* nucleus size decreased */
         k1++;
         /* walk thru i-th row of V and decrease column counts; this
          * may cause new column singletons to appear */
         ptr = vr_ptr[i];
         end = ptr + vr_len[i];
         for (; ptr < end; ptr++)
         {  if (--(cnt[j = sv_ind[ptr]]) == 1)
               list[++ns] = j;
         }
      }
      /* nucleus begins at k1-th row/column of U */
      if (k1 > n)
      {  /* U is upper triangular; no nucleus exist */
         goto done;
      }
      /*--------------------------------------------------------------*/
      /* process row singletons                                       */
      /*--------------------------------------------------------------*/
      /* determine initial counts of rows of V and initialize list of
       * active row singletons */
      ns = 0; /* number of active row singletons */
      for (i = 1; i <= n; i++)
      {  if (pp_ind[i] < k1)
         {  /* corresponding row of U is above its k1-th row; set its
             * count to zero to prevent including it in active list */
            cnt[i] = 0;
         }
         else if ((cnt[i] = vr_len[i]) == 1)
            list[++ns] = i;
      }
      /* process active row singletons */
      while (ns > 0)
      {  /* row singleton is in i-th row of V */
         i = list[ns--];
#if 1 /* 21/II-2016 */
         if (cnt[i] == 0)
         {  /* i-th row in the current nucleus is actually empty */
            /* (see comments above for similar case of empty column) */
            return 2;
         }
#endif
         /* find j-th column of V containing row singleton */
         ptr = vr_ptr[i];
         end = ptr + vr_len[i];
         for (; qq_inv[j = sv_ind[ptr]] > k2; ptr++)
            /* nop */;
         xassert(ptr < end);
         /* permute rows and columns of U to move row singleton to
          * position u[k2,k2] */
         ii = pp_ind[i];
         luf_swap_u_rows(k2, ii);
         jj = qq_inv[j];
         luf_swap_u_cols(k2, jj);
         /* nucleus size decreased */
         k2--;
         /* walk thru j-th column of V and decrease row counts; this
          * may cause new row singletons to appear */
         ptr = vc_ptr[j];
         end = ptr + vc_len[j];
         for (; ptr < end; ptr++)
         {  if (--(cnt[i = sv_ind[ptr]]) == 1)
               list[++ns] = i;
         }
      }
      /* nucleus ends at k2-th row/column of U */
      xassert(k1 < k2);
done: *k1_ = k1, *k2_ = k2;
      return 0;
}

/***********************************************************************
*  sgf_singl_phase - compute LU-factorization (singleton phase)
*
*  It is assumed that on entry to the routine L = P'* F * P = F = I
*  and matrix U = P'* V * Q' has the following structure (provided by
*  the routine sgf_reduce_nuc):
*
*        1     k1    k2    n
*     1  a a a b b b b c c c
*        . a a b b b b c c c
*        . . a b b b b c c c
*     k1 . . . * * * * d d d
*        . . . * * * * d d d
*        . . . * * * * d d d
*     k2 . . . * * * * d d d
*        . . . . . . . e e e
*        . . . . . . . . e e
*     n  . . . . . . . . . e
*
*  First, the routine performs (implicit) symmetric permutations of
*  rows and columns of matrix U to place them in the following order:
*
*     1, 2, ..., k1-1; n, n-1, ..., k2+1; k1, k1+1, ..., k2
*
*  This changes the structure of matrix U as follows:
*
*        1     k1    k2'   n
*     1  a a a c c c b b b b
*        . a a c c c b b b b
*        . . a c c c b b b b
*     k1 . . . e . . . . . .
*        . . . e e . . . . .
*        . . . e e e . . . .
*     k2'. . . d d d * * * *
*        . . . d d d * * * *
*        . . . d d d * * * *
*     n  . . . d d d * * * *
*
*  where k2' = n - k2 + k1.
*
*  Then the routine performs elementary gaussian transformations to
*  eliminate subdiagonal elements in columns k1, ..., k2'-1 of U. The
*  effect is the same as if the routine sgf_eliminate would be called
*  for k = 1, ..., k2'-1 using diagonal elements u[k,k] as pivots.
*
*  After elimination matrices L and U becomes the following:
*
*        1     k1   k2'    n        1     k1   k2'    n
*     1  1 . . . . . . . . .     1  a a a c c c b b b b
*        . 1 . . . . . . . .        . a a c c c b b b b
*        . . 1 . . . . . . .        . . a c c c b b b b
*     k1 . . . 1 . . . . . .     k1 . . . e . . . . . .
*        . . . e'1 . . . . .        . . . . e . . . . .
*        . . . e'e'1 . . . .        . . . . . e . . . .
*     k2'. . . d'd'd'1 . . .     k2'. . . . . . * * * *
*        . . . d'd'd'. 1 . .        . . . . . . * * * *
*        . . . d'd'd'. . 1 .        . . . . . . * * * *
*     n  . . . d'd'd'. . . 1     n  . . . . . . * * * *
*
*             matrix L                   matrix U
*
*  where columns k1, ..., k2'-1 of L consist of subdiagonal elements
*  of initial matrix U divided by pivots u[k,k].
*
*  On exit the routine returns k2', the elimination step number, from
*  which computing of the factorization should be continued. Note that
*  k2' = n+1 means that matrix U is already upper triangular. */

int sgf_singl_phase(LUF *luf, int k1, int k2, int updat,
      int ind[/*1+n*/], double val[/*1+n*/])
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int i, j, k, ptr, ptr1, end, len;
      double piv;
      /* (see routine sgf_reduce_nuc) */
      xassert((1 <= k1 && k1 < k2 && k2 <= n)
         || (k1 == n+1 && k2 == n));
      /* perform symmetric permutations of rows/columns of U */
      for (k = k1; k <= k2; k++)
         pp_ind[pp_inv[k]] = qq_inv[qq_ind[k]] = k - k2 + n;
      for (k = k2+1; k <= n; k++)
         pp_ind[pp_inv[k]] = qq_inv[qq_ind[k]] = n - k + k1;
      for (k = 1; k <= n; k++)
         pp_inv[pp_ind[k]] = qq_ind[qq_inv[k]] = k;
      /* determine k2' */
      k2 = n - k2 + k1;
      /* process rows and columns of V corresponding to rows and
       * columns 1, ..., k1-1 of U */
      for (k = 1; k < k1; k++)
      {  /* k-th row of U = i-th row of V */
         i = pp_inv[k];
         /* find pivot u[k,k] = v[i,j] in i-th row of V */
         ptr = vr_ptr[i];
         end = ptr + vr_len[i];
         for (; qq_inv[sv_ind[ptr]] != k; ptr++)
            /* nop */;
         xassert(ptr < end);
         /* store pivot */
         vr_piv[i] = sv_val[ptr];
         /* and remove it from i-th row of V */
         sv_ind[ptr] = sv_ind[end-1];
         sv_val[ptr] = sv_val[end-1];
         vr_len[i]--;
         /* clear column of V corresponding to k-th column of U */
         vc_len[qq_ind[k]] = 0;
      }
      /* clear rows of V corresponding to rows k1, ..., k2'-1 of U */
      for (k = k1; k < k2; k++)
         vr_len[pp_inv[k]] = 0;
      /* process rows and columns of V corresponding to rows and
       * columns k2', ..., n of U */
      for (k = k2; k <= n; k++)
      {  /* k-th row of U = i-th row of V */
         i = pp_inv[k];
         /* remove elements from i-th row of V that correspond to
          * elements u[k,k1], ..., u[k,k2'-1] */
         ptr = ptr1 = vr_ptr[i];
         end = ptr + vr_len[i];
         for (; ptr < end; ptr++)
         {  if (qq_inv[sv_ind[ptr]] >= k2)
            {  sv_ind[ptr1] = sv_ind[ptr];
               sv_val[ptr1] = sv_val[ptr];
               ptr1++;
            }
         }
         vr_len[i] = ptr1 - vr_ptr[i];
         /* k-th column of U = j-th column of V */
         j = qq_ind[k];
         /* remove elements from j-th column of V that correspond to
          * elements u[1,k], ..., u[k1-1,k] */
         ptr = ptr1 = vc_ptr[j];
         end = ptr + vc_len[j];
         for (; ptr < end; ptr++)
         {  if (pp_ind[sv_ind[ptr]] >= k2)
               /* element value is not needed in this case */
               sv_ind[ptr1++] = sv_ind[ptr];
         }
         vc_len[j] = ptr1 - vc_ptr[j];
      }
      /* process columns of V corresponding to columns k1, ..., k2'-1
       * of U, build columns of F */
      for (k = k1; k < k2; k++)
      {  /* k-th column of U = j-th column of V */
         j = qq_ind[k];
         /* remove elements from j-th column of V that correspond to
          * pivot (diagonal) element u[k,k] and subdiagonal elements
          * u[k+1,k], ..., u[n,k]; subdiagonal elements are stored for
          * further addition to matrix F */
         len = 0;
         piv = 0.0;
         ptr = vc_ptr[j];
         end = ptr + vc_len[j];
         for (; ptr < end; ptr++)
         {  i = sv_ind[ptr]; /* v[i,j] */
            if (pp_ind[i] == k)
            {  /* store pivot v[i,j] = u[k,k] */
               piv = vr_piv[i] = sv_val[ptr];
            }
            else if (pp_ind[i] > k)
            {  /* store subdiagonal element v[i,j] = u[i',k] */
               len++;
               ind[len] = i;
               val[len] = sv_val[ptr];
            }
         }
         /* clear j-th column of V = k-th column of U */
         vc_len[j] = 0;
         /* build k-th column of L = j-th column of F */
         j = pp_inv[k];
         xassert(piv != 0.0);
         if (len > 0)
         {  if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_reserve_cap(sva, fc_ref-1+j, len);
            for (ptr = fc_ptr[j], ptr1 = 1; ptr1 <= len; ptr++, ptr1++)
            {  sv_ind[ptr] = ind[ptr1];
               sv_val[ptr] = val[ptr1] / piv;
            }
            fc_len[j] = len;
         }
      }
      /* if it is not planned to update matrix V, relocate all its
       * non-active rows corresponding to rows 1, ..., k2'-1 of U to
       * the right (static) part of SVA */
      if (!updat)
      {  for (k = 1; k < k2; k++)
         {  i = pp_inv[k];
            len = vr_len[i];
            if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_make_static(sva, vr_ref-1+i);
         }
      }
      /* elimination steps 1, ..., k2'-1 have been performed */
      return k2;
}

/***********************************************************************
*  sgf_choose_pivot - choose pivot element v[p,q]
*
*  This routine chooses pivot element v[p,q], k <= p, q <= n, in the
*  active submatrix of matrix V = P * U * Q, where k is the number of
*  current elimination step, 1 <= k <= n.
*
*  It is assumed that on entry to the routine matrix U = P'* V * Q' has
*  the following partially triangularized form:
*
*        1       k         n
*     1  x x x x x x x x x x
*        . x x x x x x x x x
*        . . x x x x x x x x
*        . . . x x x x x x x
*     k  . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*     n  . . . . * * * * * *
*
*  where rows and columns k, k+1, ..., n belong to the active submatrix
*  (its elements are marked by '*').
*
*  Since the matrix U is not stored, the routine works with the matrix
*  V = P * U * Q. It is assumed that the row-wise representation
*  corresponds to the matrix V, but the column-wise representation
*  corresponds to the active submatrix of the matrix V, i.e. elements,
*  which are not in the active submatrix, are not included in column
*  vectors. It is also assumed that each active row of the matrix V is
*  in the set R[len], where len is the number of non-zeros in the row,
*  and each active column of the matrix V is in the set C[len], where
*  len is the number of non-zeros in the column (in the latter case
*  only elements of the active submatrix are counted; such elements are
*  marked by '*' on the figure above).
*
*  For the reason of numerical stability the routine applies so called
*  threshold pivoting proposed by J.Reid. It is assumed that an element
*  v[i,j] can be selected as a pivot candidate if it is not very small
*  (in magnitude) among other elements in the same row, i.e. if it
*  satisfies to the stability condition |v[i,j]| >= tol * max|v[i,*]|,
*  where 0 < tol < 1 is a given tolerance.
*
*  In order to keep sparsity of the matrix V the routine uses Markowitz
*  strategy, trying to choose such element v[p,q], which satisfies to
*  the stability condition (see above) and has smallest Markowitz cost
*  (nr[p]-1) * (nc[q]-1), where nr[p] and nc[q] are, resp., numbers of
*  non-zeros in p-th row and q-th column of the active submatrix.
*
*  In order to reduce the search, i.e. not to walk through all elements
*  of the active submatrix, the routine uses a technique proposed by
*  I.Duff. This technique is based on using the sets R[len] and C[len]
*  of active rows and columns.
*
*  If the pivot element v[p,q] has been chosen, the routine stores its
*  indices to locations *p and *q and returns zero. Otherwise, non-zero
*  is returned. */

int sgf_choose_pivot(SGF *sgf, int *p_, int *q_)
{     LUF *luf = sgf->luf;
      int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *rs_head = sgf->rs_head;
      int *rs_next = sgf->rs_next;
      int *cs_head = sgf->cs_head;
      int *cs_prev = sgf->cs_prev;
      int *cs_next = sgf->cs_next;
      double *vr_max = sgf->vr_max;
      double piv_tol = sgf->piv_tol;
      int piv_lim = sgf->piv_lim;
      int suhl = sgf->suhl;
      int i, i_ptr, i_end, j, j_ptr, j_end, len, min_i, min_j, min_len,
         ncand, next_j, p, q;
      double best, big, cost, temp;
      /* no pivot candidate has been chosen so far */
      p = q = 0, best = DBL_MAX, ncand = 0;
      /* if the active submatrix contains a column having the only
       * non-zero element (column singleton), choose it as the pivot */
      j = cs_head[1];
      if (j != 0)
      {  xassert(vc_len[j] == 1);
         p = sv_ind[vc_ptr[j]], q = j;
         goto done;
      }
      /* if the active submatrix contains a row having the only
       * non-zero element (row singleton), choose it as the pivot */
      i = rs_head[1];
      if (i != 0)
      {  xassert(vr_len[i] == 1);
         p = i, q = sv_ind[vr_ptr[i]];
         goto done;
      }
      /* the active submatrix contains no singletons; walk thru its
       * other non-empty rows and columns */
      for (len = 2; len <= n; len++)
      {  /* consider active columns containing len non-zeros */
         for (j = cs_head[len]; j != 0; j = next_j)
         {  /* save the number of next column of the same length */
            next_j = cs_next[j];
            /* find an element in j-th column, which is placed in the
             * row with minimal number of non-zeros and satisfies to
             * the stability condition (such element may not exist) */
            min_i = min_j = 0, min_len = INT_MAX;
            for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
               j_ptr < j_end; j_ptr++)
            {  /* get row index of v[i,j] */
               i = sv_ind[j_ptr];
               /* if i-th row is not shorter, skip v[i,j] */
               if (vr_len[i] >= min_len)
                  continue;
               /* big := max|v[i,*]| */
               if ((big = vr_max[i]) < 0.0)
               {  /* largest magnitude is unknown; compute it */
                  for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
                     i_ptr < i_end; i_ptr++)
                  {  if ((temp = sv_val[i_ptr]) < 0.0)
                        temp = -temp;
                     if (big < temp)
                        big = temp;
                  }
                  xassert(big > 0.0);
                  vr_max[i] = big;
               }
               /* find v[i,j] in i-th row */
               for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
                  sv_ind[i_ptr] != j; i_ptr++)
                  /* nop */;
               xassert(i_ptr < i_end);
               /* if |v[i,j]| < piv_tol * max|v[i,*]|, skip v[i,j] */
               if ((temp = sv_val[i_ptr]) < 0.0)
                  temp = -temp;
               if (temp < piv_tol * big)
                  continue;
               /* v[i,j] is a better candidate */
               min_i = i, min_j = j, min_len = vr_len[i];
               /* if Markowitz cost of v[i,j] is not greater than
                * (len-1)**2, v[i,j] can be chosen as the pivot right
                * now; this heuristic reduces the search and works well
                * in many cases */
               if (min_len <= len)
               {  p = min_i, q = min_j;
                  goto done;
               }
            }
            /* j-th column has been scanned */
            if (min_i != 0)
            {  /* element v[min_i,min_j] is a next pivot candidate */
               ncand++;
               /* compute its Markowitz cost */
               cost = (double)(min_len - 1) * (double)(len - 1);
               /* if this element is better, choose it as the pivot */
               if (cost < best)
                  p = min_i, q = min_j, best = cost;
               /* if piv_lim candidates were considered, terminate
                * the search, because it is doubtful that a much better
                * candidate will be found */
               if (ncand == piv_lim)
                  goto done;
            }
            else if (suhl)
            {  /* j-th column has no eligible elements that satisfy to
                * the stability criterion; Uwe Suhl suggests to exclude
                * such column from further considerations until it
                * becomes a column singleton; in hard cases this may
                * significantly reduce the time needed to choose the
                * pivot element */
               sgf_deactivate_col(j);
               cs_prev[j] = cs_next[j] = j;
            }
         }
         /* consider active rows containing len non-zeros */
         for (i = rs_head[len]; i != 0; i = rs_next[i])
         {  /* big := max|v[i,*]| */
            if ((big = vr_max[i]) < 0.0)
            {  /* largest magnitude is unknown; compute it */
               for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
                  i_ptr < i_end; i_ptr++)
               {  if ((temp = sv_val[i_ptr]) < 0.0)
                     temp = -temp;
                  if (big < temp)
                     big = temp;
               }
               xassert(big > 0.0);
               vr_max[i] = big;
            }
            /* find an element in i-th row, which is placed in the
             * column with minimal number of non-zeros and satisfies to
             * the stability condition (such element always exists) */
            min_i = min_j = 0, min_len = INT_MAX;
            for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
               i_ptr < i_end; i_ptr++)
            {  /* get column index of v[i,j] */
               j = sv_ind[i_ptr];
               /* if j-th column is not shorter, skip v[i,j] */
               if (vc_len[j] >= min_len)
                  continue;
               /* if |v[i,j]| < piv_tol * max|v[i,*]|, skip v[i,j] */
               if ((temp = sv_val[i_ptr]) < 0.0)
                  temp = -temp;
               if (temp < piv_tol * big)
                  continue;
               /* v[i,j] is a better candidate */
               min_i = i, min_j = j, min_len = vc_len[j];
               /* if Markowitz cost of v[i,j] is not greater than
                * (len-1)**2, v[i,j] can be chosen as the pivot right
                * now; this heuristic reduces the search and works well
                * in many cases */
               if (min_len <= len)
               {  p = min_i, q = min_j;
                  goto done;
               }
            }
            /* i-th row has been scanned */
            if (min_i != 0)
            {  /* element v[min_i,min_j] is a next pivot candidate */
               ncand++;
               /* compute its Markowitz cost */
               cost = (double)(len - 1) * (double)(min_len - 1);
               /* if this element is better, choose it as the pivot */
               if (cost < best)
                  p = min_i, q = min_j, best = cost;
               /* if piv_lim candidates were considered, terminate
                * the search, because it is doubtful that a much better
                * candidate will be found */
               if (ncand == piv_lim)
                  goto done;
            }
            else
            {  /* this can never be */
               xassert(min_i != min_i);
            }
         }
      }
done: /* report the pivot to the factorization routine */
      *p_ = p, *q_ = q;
      return (p == 0);
}

/***********************************************************************
*  sgf_eliminate - perform gaussian elimination
*
*  This routine performs elementary gaussian transformations in order
*  to eliminate subdiagonal elements in k-th column of matrix
*  U = P'* V * Q' using pivot element u[k,k], where k is the number of
*  current elimination step, 1 <= k <= n.
*
*  The parameters p and q specify, resp., row and column indices of the
*  pivot element v[p,q] = u[k,k].
*
*  On entry the routine assumes that partially triangularized matrices
*  L = P'* F * P and U = P'* V * Q' have the following structure:
*
*        1       k         n       1        k         n
*     1  1 . . . . . . . . .     1  x x x x x x x x x x
*        x 1 . . . . . . . .        . x x x x x x x x x
*        x x 1 . . . . . . .        . . x x x x x x x x
*        x x x 1 . . . . . .        . . . x x x x x x x
*     k  x x x x 1 . . . . .     k  . . . . * * * * * *
*        x x x x _ 1 . . . .        . . . . # * * * * *
*        x x x x _ . 1 . . .        . . . . # * * * * *
*        x x x x _ . . 1 . .        . . . . # * * * * *
*        x x x x _ . . . 1 .        . . . . # * * * * *
*     n  x x x x _ . . . . 1     n  . . . . # * * * * *
*
*             matrix L                   matrix U
*
*  where rows and columns k, k+1, ..., n of matrix U constitute the
*  active submatrix. Elements to be eliminated are marked by '#', and
*  other elements of the active submatrix are marked by '*'. May note
*  that each eliminated non-zero element u[i,k] of matrix U gives
*  corresponding non-zero element l[i,k] of matrix L (marked by '_').
*
*  Actually all operations are performed on matrix V. It is assumed
*  that the row-wise representation corresponds to matrix V, but the
*  column-wise representation corresponds to the active submatrix of
*  matrix V (or, more precisely, to its pattern, because only row
*  indices for columns of the active submatrix are used on this stage).
*
*  Let u[k,k] = v[p,q] be the pivot. In order to eliminate subdiagonal
*  elements u[i',k] = v[i,q], i'= k+1, k+2, ..., n, the routine applies
*  the following elementary gaussian transformations:
*
*     (i-th row of V) := (i-th row of V) - f[i,p] * (p-th row of V),
*
*  where f[i,p] = v[i,q] / v[p,q] is a gaussian multiplier stored to
*  p-th column of matrix F to keep the main equality A = F * V
*  (corresponding elements l[i',k] of matrix L are marked by '_' on the
*  figure above).
*
*  NOTE: On entry to the routine the working arrays flag and work
*        should contain zeros. This status is retained by the routine
*        on exit. */

int sgf_eliminate(SGF *sgf, int p, int q)
{     LUF *luf = sgf->luf;
      int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int *vr_cap = &sva->cap[vr_ref-1];
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_ptr = &sva->ptr[vc_ref-1];
      int *vc_len = &sva->len[vc_ref-1];
      int *vc_cap = &sva->cap[vc_ref-1];
      int *rs_head = sgf->rs_head;
      int *rs_prev = sgf->rs_prev;
      int *rs_next = sgf->rs_next;
      int *cs_head = sgf->cs_head;
      int *cs_prev = sgf->cs_prev;
      int *cs_next = sgf->cs_next;
      double *vr_max = sgf->vr_max;
      char *flag = sgf->flag;
      double *work = sgf->work;
      double eps_tol = sgf->eps_tol;
      int nnz_diff = 0;
      int fill, i, i_ptr, i_end, j, j_ptr, j_end, ptr, len, loc, loc1;
      double vpq, fip, vij;
      xassert(1 <= p && p <= n);
      xassert(1 <= q && q <= n);
      /* remove p-th row from the active set; this row will never
       * return there */
      sgf_deactivate_row(p);
      /* process p-th (pivot) row */
      ptr = 0;
      for (i_end = (i_ptr = vr_ptr[p]) + vr_len[p];
         i_ptr < i_end; i_ptr++)
      {  /* get column index of v[p,j] */
         j = sv_ind[i_ptr];
         if (j == q)
         {  /* save pointer to pivot v[p,q] */
            ptr = i_ptr;
         }
         else
         {  /* store v[p,j], j != q, to working array */
            flag[j] = 1;
            work[j] = sv_val[i_ptr];
         }
         /* remove j-th column from the active set; q-th column will
          * never return there while other columns will return to the
          * active set with new length */
         if (cs_next[j] == j)
         {  /* j-th column was marked by the pivoting routine according
             * to Uwe Suhl's suggestion and is already inactive */
            xassert(cs_prev[j] == j);
         }
         else
            sgf_deactivate_col(j);
         nnz_diff -= vc_len[j];
         /* find and remove v[p,j] from j-th column */
         for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
            sv_ind[j_ptr] != p; j_ptr++)
            /* nop */;
         xassert(j_ptr < j_end);
         sv_ind[j_ptr] = sv_ind[j_end-1];
         vc_len[j]--;
      }
      /* save pivot v[p,q] and remove it from p-th row */
      xassert(ptr > 0);
      vpq = vr_piv[p] = sv_val[ptr];
      sv_ind[ptr] = sv_ind[i_end-1];
      sv_val[ptr] = sv_val[i_end-1];
      vr_len[p]--;
      /* if it is not planned to update matrix V, relocate p-th row to
       * the right (static) part of SVA */
      if (!sgf->updat)
      {  len = vr_len[p];
         if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_make_static(sva, vr_ref-1+p);
      }
      /* copy the pattern (row indices) of q-th column of the active
       * submatrix (from which v[p,q] has been just removed) to p-th
       * column of matrix F (without unity diagonal element) */
      len = vc_len[q];
      if (len > 0)
      {  if (sva->r_ptr - sva->m_ptr < len)
         {  sva_more_space(sva, len);
            sv_ind = sva->ind;
            sv_val = sva->val;
         }
         sva_reserve_cap(sva, fc_ref-1+p, len);
         memcpy(&sv_ind[fc_ptr[p]], &sv_ind[vc_ptr[q]],
            len * sizeof(int));
         fc_len[p] = len;
      }
      /* make q-th column of the active submatrix empty */
      vc_len[q] = 0;
      /* transform non-pivot rows of the active submatrix */
      for (loc = fc_len[p]-1; loc >= 0; loc--)
      {  /* get row index of v[i,q] = row index of f[i,p] */
         i = sv_ind[fc_ptr[p] + loc];
         xassert(i != p); /* v[p,q] was removed */
         /* remove i-th row from the active set; this row will return
          * there with new length */
         sgf_deactivate_row(i);
         /* find v[i,q] in i-th row */
         for (i_end = (i_ptr = vr_ptr[i]) + vr_len[i];
            sv_ind[i_ptr] != q; i_ptr++)
            /* nop */;
         xassert(i_ptr < i_end);
         /* compute gaussian multiplier f[i,p] = v[i,q] / v[p,q] */
         fip = sv_val[fc_ptr[p] + loc] = sv_val[i_ptr] / vpq;
         /* remove v[i,q] from i-th row */
         sv_ind[i_ptr] = sv_ind[i_end-1];
         sv_val[i_ptr] = sv_val[i_end-1];
         vr_len[i]--;
         /* perform elementary gaussian transformation:
          * (i-th row) := (i-th row) - f[i,p] * (p-th row)
          * note that p-th row of V, which is in the working array,
          * doesn't contain pivot v[p,q], and i-th row of V doesn't
          * contain v[i,q] to be eliminated */
         /* walk thru i-th row and transform existing elements */
         fill = vr_len[p];
         for (i_end = (i_ptr = ptr = vr_ptr[i]) + vr_len[i];
            i_ptr < i_end; i_ptr++)
         {  /* get column index and value of v[i,j] */
            j = sv_ind[i_ptr];
            vij = sv_val[i_ptr];
            if (flag[j])
            {  /* v[p,j] != 0 */
               flag[j] = 0, fill--;
               /* v[i,j] := v[i,j] - f[i,p] * v[p,j] */
               vij -= fip * work[j];
               if (-eps_tol < vij && vij < +eps_tol)
               {  /* new v[i,j] is close to zero; remove it from the
                   * active submatrix, i.e. replace it by exact zero */
                  /* find and remove v[i,j] from j-th column */
                  for (j_end = (j_ptr = vc_ptr[j]) + vc_len[j];
                     sv_ind[j_ptr] != i; j_ptr++)
                     /* nop */;
                  xassert(j_ptr < j_end);
                  sv_ind[j_ptr] = sv_ind[j_end-1];
                  vc_len[j]--;
                  continue;
               }
            }
            /* keep new v[i,j] in i-th row */
            sv_ind[ptr] = j;
            sv_val[ptr] = vij;
            ptr++;
         }
         /* (new length of i-th row may decrease because of numerical
          * cancellation) */
         vr_len[i] = len = ptr - vr_ptr[i];
         /* now flag[*] is the pattern of the set v[p,*] \ v[i,*], and
          * fill is the number of non-zeros in this set */
         if (fill == 0)
         {  /* no fill-in occurs */
            /* walk thru p-th row and restore the column flags */
            for (i_end = (i_ptr = vr_ptr[p]) + vr_len[p];
               i_ptr < i_end; i_ptr++)
               flag[sv_ind[i_ptr]] = 1; /* v[p,j] != 0 */
            goto skip;
         }
         /* up to fill new non-zero elements may appear in i-th row due
          * to fill-in; reserve locations for these elements (note that
          * actual length of i-th row is currently stored in len) */
         if (vr_cap[i] < len + fill)
         {  if (sva->r_ptr - sva->m_ptr < len + fill)
            {  sva_more_space(sva, len + fill);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_enlarge_cap(sva, vr_ref-1+i, len + fill, 0);
         }
         vr_len[i] += fill;
         /* walk thru p-th row and add new elements to i-th row */
         for (loc1 = vr_len[p]-1; loc1 >= 0; loc1--)
         {  /* get column index of v[p,j] */
            j = sv_ind[vr_ptr[p] + loc1];
            if (!flag[j])
            {  /* restore j-th column flag */
               flag[j] = 1;
               /* v[i,j] was computed earlier on transforming existing
                * elements of i-th row */
               continue;
            }
            /* v[i,j] := 0 - f[i,p] * v[p,j] */
            vij = - fip * work[j];
            if (-eps_tol < vij && vij < +eps_tol)
            {  /* new v[i,j] is close to zero; do not add it to the
                * active submatrix, i.e. replace it by exact zero */
               continue;
            }
            /* add new v[i,j] to i-th row */
            sv_ind[ptr = vr_ptr[i] + (len++)] = j;
            sv_val[ptr] = vij;
            /* add new v[i,j] to j-th column */
            if (vc_cap[j] == vc_len[j])
            {  /* we reserve extra locations in j-th column to reduce
                * further relocations of that column */
#if 1 /* FIXME */
               /* use control parameter to specify the number of extra
                * locations reserved */
               int need = vc_len[j] + 10;
#endif
               if (sva->r_ptr - sva->m_ptr < need)
               {  sva_more_space(sva, need);
                  sv_ind = sva->ind;
                  sv_val = sva->val;
               }
               sva_enlarge_cap(sva, vc_ref-1+j, need, 1);
            }
            sv_ind[vc_ptr[j] + (vc_len[j]++)] = i;
         }
         /* set final length of i-th row just transformed */
         xassert(len <= vr_len[i]);
         vr_len[i] = len;
skip:    /* return i-th row to the active set with new length */
         sgf_activate_row(i);
         /* since i-th row has been changed, largest magnitude of its
          * elements becomes unknown */
         vr_max[i] = -1.0;
      }
      /* walk thru p-th (pivot) row */
      for (i_end = (i_ptr = vr_ptr[p]) + vr_len[p];
         i_ptr < i_end; i_ptr++)
      {  /* get column index of v[p,j] */
         j = sv_ind[i_ptr];
         xassert(j != q); /* v[p,q] was removed */
         /* return j-th column to the active set with new length */
         if (cs_next[j] == j && vc_len[j] != 1)
         {  /* j-th column was marked by the pivoting routine and it is
             * still not a column singleton, so leave it incative */
            xassert(cs_prev[j] == j);
         }
         else
            sgf_activate_col(j);
         nnz_diff += vc_len[j];
         /* restore zero content of the working arrays */
         flag[j] = 0;
         work[j] = 0.0;
      }
      /* return the difference between the numbers of non-zeros in the
       * active submatrix on entry and on exit, resp. */
      return nnz_diff;
}

/***********************************************************************
*  sgf_dense_lu - compute dense LU-factorization with full pivoting
*
*  This routine performs Gaussian elimination with full pivoting to
*  compute dense LU-factorization of the specified matrix A of order n
*  in the form:
*
*     A = P * L * U * Q,                                             (1)
*
*  where L is lower triangular matrix with unit diagonal, U is upper
*  triangular matrix, P and Q are permutation matrices.
*
*  On entry to the routine elements of matrix A = (a[i,j]) should be
*  placed in the array elements a[0], ..., a[n^2-1] in dense row-wise
*  format. On exit from the routine matrix A is replaced by factors L
*  and U as follows:
*
*       u[1,1]   u[1,2]  ...  u[1,n-1]   u[1,n]
*       l[2,1]   u[2,2]  ...  u[2,n-1]   u[2,n]
*        . . . . . . . . . . . . . .
*     l[n-1,1] l[n-1,2]     u[n-1,n-1] u[n-1,n]
*       l[n,1]   l[n,2]  ...  l[n,n-1]   u[n,n]
*
*  The unit diagonal elements of L are not stored.
*
*  Information on permutations of rows and columns of active submatrix
*  during factorization is accumulated by the routine as follows. Every
*  time the routine permutes rows i and i' or columns j and j', it also
*  permutes elements r[i-1] and r[i'-1] or c[j-1] and c[j'-1], resp.
*  Thus, on entry to the routine elements r[0], r[1], ..., r[n-1] and
*  c[0], c[1], ..., c[n-1] should be initialized by some integers that
*  identify rows and columns of the original matrix A.
*
*  If the factorization has been successfully computed, the routine
*  returns zero. Otherwise, if on k-th elimination step, 1 <= k <= n,
*  all elements of the active submatrix are close to zero, the routine
*  returns k, in which case a partial factorization is stored in the
*  array a. */

int sgf_dense_lu(int n, double a_[], int r[], int c[], double eps)
{     /* non-optimized version */
      int i, j, k, p, q, ref;
      double akk, big, temp;
#     define a(i,j) a_[(i)*n+(j)]
      /* initially U = A, L = P = Q = I */
      /* main elimination loop */
      for (k = 0; k < n; k++)
      {  /* choose pivot u[p,q], k <= p, q <= n */
         p = q = -1, big = eps;
         for (i = k; i < n; i++)
         {  for (j = k; j < n; j++)
            {  /* temp = |u[i,j]| */
               if ((temp = a(i,j)) < 0.0)
                  temp = -temp;
               if (big < temp)
                  p = i, q = j, big = temp;
            }
         }
         if (p < 0)
         {  /* k-th elimination step failed */
            return k+1;
         }
         /* permute rows k and p */
         if (k != p)
         {  for (j = 0; j < n; j++)
               temp = a(k,j), a(k,j) = a(p,j), a(p,j) = temp;
            ref = r[k], r[k] = r[p], r[p] = ref;
         }
         /* permute columns k and q */
         if (k != q)
         {  for (i = 0; i < n; i++)
               temp = a(i,k), a(i,k) = a(i,q), a(i,q) = temp;
            ref = c[k], c[k] = c[q], c[q] = ref;
         }
         /* now pivot is in position u[k,k] */
         akk = a(k,k);
         /* eliminate subdiagonal elements u[k+1,k], ..., u[n,k] */
         for (i = k+1; i < n; i++)
         {  if (a(i,k) != 0.0)
            {  /* gaussian multiplier l[i,k] := u[i,k] / u[k,k] */
               temp = (a(i,k) /= akk);
               /* (i-th row) := (i-th row) - l[i,k] * (k-th row) */
               for (j = k+1; j < n; j++)
                  a(i,j) -= temp * a(k,j);
            }
         }
      }
#     undef a
      return 0;
}

/***********************************************************************
*  sgf_dense_phase - compute LU-factorization (dense phase)
*
*  This routine performs dense phase of computing LU-factorization.
*
*  The aim is two-fold. First, the main factorization routine switches
*  to dense phase when the active submatrix is relatively dense, so
*  using dense format allows significantly reduces overheads needed to
*  maintain sparse data structures. And second, that is more important,
*  on dense phase full pivoting is used (rather than partial pivoting)
*  that allows improving numerical stability, since round-off errors
*  tend to increase on last steps of the elimination process.
*
*  On entry the routine assumes that elimination steps 1, 2, ..., k-1
*  have been performed, so partially transformed matrices L = P'* F * P
*  and U = P'* V * Q' have the following structure:
*
*        1       k         n       1        k         n
*     1  1 . . . . . . . . .     1  x x x x x x x x x x
*        x 1 . . . . . . . .        . x x x x x x x x x
*        x x 1 . . . . . . .        . . x x x x x x x x
*        x x x 1 . . . . . .        . . . x x x x x x x
*     k  x x x x 1 . . . . .     k  . . . . * * * * * *
*        x x x x . 1 . . . .        . . . . * * * * * *
*        x x x x . . 1 . . .        . . . . * * * * * *
*        x x x x . . . 1 . .        . . . . * * * * * *
*        x x x x . . . . 1 .        . . . . * * * * * *
*     n  x x x x . . . . . 1     n  . . . . * * * * * *
*
*             matrix L                   matrix U
*
*  where rows and columns k, k+1, ..., n of matrix U constitute the
*  active submatrix A~, whose elements are marked by '*'.
*
*  The routine copies the active submatrix A~ to a working array in
*  dense format, compute dense factorization A~ = P~* L~* U~* Q~ using
*  full pivoting, and then copies non-zero elements of factors L~ and
*  U~ back to factors L and U (more precisely, to factors F and V).
*
*  If the factorization has been successfully computed, the routine
*  returns zero. Otherwise, if on k-th elimination step, 1 <= k <= n,
*  all elements of the active submatrix are close to zero, the routine
*  returns k (information on linearly dependent rows/columns in this
*  case is provided by matrices P and Q). */

int sgf_dense_phase(LUF *luf, int k, int updat)
{     int n = luf->n;
      SVA *sva = luf->sva;
      int *sv_ind = sva->ind;
      double *sv_val = sva->val;
      int fc_ref = luf->fc_ref;
      int *fc_ptr = &sva->ptr[fc_ref-1];
      int *fc_len = &sva->len[fc_ref-1];
      int *fc_cap = &sva->cap[fc_ref-1];
      int vr_ref = luf->vr_ref;
      int *vr_ptr = &sva->ptr[vr_ref-1];
      int *vr_len = &sva->len[vr_ref-1];
      int *vr_cap = &sva->cap[vr_ref-1];
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_inv = luf->pp_inv;
      int *pp_ind = luf->pp_ind;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int a_end, a_ptr, end, i, ia, ii, j, ja, jj, ka, len, na, ne,
         need, ptr;
      double *a_;
      xassert(1 <= k && k <= n);
      /* active columns of V are not longer needed; make them empty */
      for (jj = k; jj <= n; jj++)
      {  /* jj is number of active column of U = P'* V * Q' */
         vc_len[qq_ind[jj]] = 0;
      }
      /* determine order of active submatrix A~ of matrix U */
      na = n - k + 1;
      xassert(1 <= na && na <= n);
      /* determine number of elements in dense triangular factor (L~ or
       * U~), except diagonal elements */
      ne = na * (na - 1) / 2;
      /* we allocate active submatrix A~ in free (middle) part of SVA;
       * to avoid defragmentation that could destroy A~ we also should
       * reserve ne locations to build rows of V from rows of U~ and ne
       * locations to build columns of F from columns of L~ */
      need = na * na + ne + ne;
      if (sva->r_ptr - sva->m_ptr < need)
      {  sva_more_space(sva, need);
         sv_ind = sva->ind;
         sv_val = sva->val;
      }
      /* free (middle) part of SVA is structured as follows:
       * end of left (dynamic) part
       * ne free locations for new rows of V
       * na free locations for active submatrix A~
       * unused locations, if any
       * ne free locations for new columns of F
       * beginning of right (static) part */
      a_ptr = sva->m_ptr + ne;
      a_end = a_ptr + na * na;
      /* copy active submatrix A~ from matrix V to working array in
       * dense row-wise format */
      a_ = &sva->val[a_ptr];
#     define a(ia, ja) a_[((ia) - 1) * na + ((ja) - 1)]
      for (ia = 1; ia <= na; ia++)
      {  /* clear ia-th row of A~ */
         for (ja = 1; ja <= na; ja++)
            a(ia, ja) = 0.0;
         /* ia-th row of A~ = (k-1+ia)-th row of U = i-th row of V */
         i = pp_inv[k-1+ia];
         ptr = vr_ptr[i];
         end = ptr + vr_len[i];
         for (; ptr < end; ptr++)
            a(ia, qq_inv[sv_ind[ptr]]-k+1) = sv_val[ptr];
         /* i-th row of V is no longer needed; make it empty */
         vr_len[i] = 0;
      }
      /* compute dense factorization A~ = P~* L~* U~* Q~ */
#if 1 /* FIXME: epsilon tolerance */
      ka = sgf_dense_lu(na, &a(1, 1), &pp_inv[k], &qq_ind[k], 1e-20);
#endif
      /* rows of U with numbers pp_inv[k, k+1, ..., n] were permuted
       * due to row permutations of A~; update matrix P using P~ */
      for (ii = k; ii <= n; ii++)
         pp_ind[pp_inv[ii]] = ii;
      /* columns of U with numbers qq_ind[k, k+1, ..., n] were permuted
       * due to column permutations of A~; update matrix Q using Q~ */
      for (jj = k; jj <= n; jj++)
         qq_inv[qq_ind[jj]] = jj;
      /* check if dense factorization is complete */
      if (ka != 0)
      {  /* A~ is singular to working precision */
         /* information on linearly dependent rows/columns is provided
          * by matrices P and Q */
         xassert(1 <= ka && ka <= na);
         return k - 1 + ka;
      }
      /* build new rows of V from rows of U~ */
      for (ia = 1; ia <= na; ia++)
      {  /* ia-th row of U~ = (k-1+ia)-th row of U = i-th row of V */
         i = pp_inv[k-1+ia];
         xassert(vr_len[i] == 0);
         /* store diagonal element u~[ia,ia] */
         vr_piv[i] = a(ia, ia);
         /* determine number of non-zero non-diagonal elements in ia-th
          * row of U~ */
         len = 0;
         for (ja = ia+1; ja <= na; ja++)
         {  if (a(ia, ja) != 0.0)
               len++;
         }
         /* reserve len locations for i-th row of matrix V in left
          * (dynamic) part of SVA */
         if (vr_cap[i] < len)
         {  /* there should be enough room in free part of SVA */
            xassert(sva->r_ptr - sva->m_ptr >= len);
            sva_enlarge_cap(sva, vr_ref-1+i, len, 0);
            /* left part of SVA should not overlap matrix A~ */
            xassert(sva->m_ptr <= a_ptr);
         }
         /* copy non-zero non-diaginal elements of ia-th row of U~ to
          * i-th row of V */
         ptr = vr_ptr[i];
         for (ja = ia+1; ja <= na; ja++)
         {  if (a(ia, ja) != 0.0)
            {  sv_ind[ptr] = qq_ind[k-1+ja];
               sv_val[ptr] = a(ia, ja);
               ptr++;
            }
         }
         xassert(ptr - vr_ptr[i] == len);
         vr_len[i] = len;
      }
      /* build new columns of F from columns of L~ */
      for (ja = 1; ja <= na; ja++)
      {  /* ja-th column of L~ = (k-1+ja)-th column of L = j-th column
          * of F */
         j = pp_inv[k-1+ja];
         xassert(fc_len[j] == 0);
         xassert(fc_cap[j] == 0);
         /* determine number of non-zero non-diagonal elements in ja-th
          * column of L~ */
         len = 0;
         for (ia = ja+1; ia <= na; ia++)
         {  if (a(ia, ja) != 0.0)
               len++;
         }
         /* reserve len locations for j-th column of matrix F in right
          * (static) part of SVA */
         /* there should be enough room in free part of SVA */
         xassert(sva->r_ptr - sva->m_ptr >= len);
         if (len > 0)
            sva_reserve_cap(sva, fc_ref-1+j, len);
         /* right part of SVA should not overlap matrix A~ */
         xassert(a_end <= sva->r_ptr);
         /* copy non-zero non-diagonal elements of ja-th column of L~
          * to j-th column of F */
         ptr = fc_ptr[j];
         for (ia = ja+1; ia <= na; ia++)
         {  if (a(ia, ja) != 0.0)
            {  sv_ind[ptr] = pp_inv[k-1+ia];
               sv_val[ptr] = a(ia, ja);
               ptr++;
            }
         }
         xassert(ptr - fc_ptr[j] == len);
         fc_len[j] = len;
      }
      /* factors L~ and U~ are no longer needed */
#     undef a
      /* if it is not planned to update matrix V, relocate all its new
       * rows to the right (static) part of SVA */
      if (!updat)
      {  for (ia = 1; ia <= na; ia++)
         {  i = pp_inv[k-1+ia];
            len = vr_len[i];
            if (sva->r_ptr - sva->m_ptr < len)
            {  sva_more_space(sva, len);
               sv_ind = sva->ind;
               sv_val = sva->val;
            }
            sva_make_static(sva, vr_ref-1+i);
         }
      }
      return 0;
}

/***********************************************************************
*  sgf_factorize - compute LU-factorization (main routine)
*
*  This routine computes sparse LU-factorization of specified matrix A
*  using Gaussian elimination.
*
*  On entry to the routine matrix V = A should be stored in column-wise
*  format.
*
*  If the factorization has been successfully computed, the routine
*  returns zero. Otherwise, if on k-th elimination step, 1 <= k <= n,
*  all elements of the active submatrix are close to zero, the routine
*  returns k (information on linearly dependent rows/columns in this
*  case is provided by matrices P and Q). */

#if 1 /* 21/II-2016 */
/* If the matrix A is structurally singular, the routine returns -1.
*  NOTE: This case can be detected only if the singl flag is set. */
#endif

int sgf_factorize(SGF *sgf, int singl)
{     LUF *luf = sgf->luf;
      int n = luf->n;
      SVA *sva = luf->sva;
      int vr_ref = luf->vr_ref;
      int *vr_len = &sva->len[vr_ref-1];
      double *vr_piv = luf->vr_piv;
      int vc_ref = luf->vc_ref;
      int *vc_len = &sva->len[vc_ref-1];
      int *pp_ind = luf->pp_ind;
      int *pp_inv = luf->pp_inv;
      int *qq_ind = luf->qq_ind;
      int *qq_inv = luf->qq_inv;
      int *rs_head = sgf->rs_head;
      int *rs_prev = sgf->rs_prev;
      int *rs_next = sgf->rs_next;
      int *cs_head = sgf->cs_head;
      int *cs_prev = sgf->cs_prev;
      int *cs_next = sgf->cs_next;
      double *vr_max = sgf->vr_max;
      char *flag = sgf->flag;
      double *work = sgf->work;
      int i, j, k, k1, k2, p, q, nnz;
      /* build matrix V = A in row-wise format */
      luf_build_v_rows(luf, rs_prev);
      /* P := Q := I, so V = U = A, F = L = I */
      for (k = 1; k <= n; k++)
      {  vr_piv[k] = 0.0;
         pp_ind[k] = pp_inv[k] = qq_ind[k] = qq_inv[k] = k;
      }
#ifdef GLP_DEBUG
      sva_check_area(sva);
      luf_check_all(luf, 1);
#endif
      /* perform singleton phase, if required */
      if (!singl)
      {  /* assume that nucleus is entire matrix U */
         k2 = 1;
      }
      else
      {  /* minimize nucleus size */
#if 0 /* 21/II-2016 */
         sgf_reduce_nuc(luf, &k1, &k2, rs_prev, rs_next);
#else
         if (sgf_reduce_nuc(luf, &k1, &k2, rs_prev, rs_next))
            return -1;
#endif
#ifdef GLP_DEBUG
         xprintf("n = %d; k1 = %d; k2 = %d\n", n, k1, k2);
#endif
         /* perform singleton phase */
         k2 = sgf_singl_phase(luf, k1, k2, sgf->updat, rs_prev, work);
      }
#ifdef GLP_DEBUG
      sva_check_area(sva);
      luf_check_all(luf, k2);
#endif
      /* initialize working arrays */
      rs_head[0] = cs_head[0] = 0;
      for (k = 1; k <= n; k++)
      {  rs_head[k] = cs_head[k] = 0;
         vr_max[k] = -1.0;
         flag[k] = 0;
         work[k] = 0.0;
      }
      /* build lists of active rows and columns of matrix V; determine
       * number of non-zeros in initial active submatrix */
      nnz = 0;
      for (k = k2; k <= n; k++)
      {  i = pp_inv[k];
         sgf_activate_row(i);
         nnz += vr_len[i];
         j = qq_ind[k];
         sgf_activate_col(j);
      }
      /* main factorization loop */
      for (k = k2; k <= n; k++)
      {  int na;
         double den;
         /* calculate density of active submatrix */
         na = n - k + 1; /* order of active submatrix */
#if 0 /* 21/VIII-2014 */
         den = (double)nnz / (double)(na * na);
#else
         den = (double)nnz / ((double)(na) * (double)(na));
#endif
         /* if active submatrix is relatively dense, switch to dense
          * phase */
#if 1 /* FIXME */
         if (na >= 5 && den >= 0.71)
         {
#ifdef GLP_DEBUG
            xprintf("na = %d; nnz = %d; den = %g\n", na, nnz, den);
#endif
            break;
         }
#endif
         /* choose pivot v[p,q] */
         if (sgf_choose_pivot(sgf, &p, &q) != 0)
            return k; /* failure */
         /* u[i,j] = v[p,q], k <= i, j <= n */
         i = pp_ind[p];
         xassert(k <= i && i <= n);
         j = qq_inv[q];
         xassert(k <= j && j <= n);
         /* move u[i,j] to position u[k,k] by implicit permutations of
          * rows and columns of matrix U */
         luf_swap_u_rows(k, i);
         luf_swap_u_cols(k, j);
         /* perform gaussian elimination */
         nnz += sgf_eliminate(sgf, p, q);
      }
#if 1 /* FIXME */
      if (k <= n)
      {  /* continue computing factorization in dense mode */
#ifdef GLP_DEBUG
         sva_check_area(sva);
         luf_check_all(luf, k);
#endif
         k = sgf_dense_phase(luf, k, sgf->updat);
         if (k != 0)
            return k; /* failure */
      }
#endif
#ifdef GLP_DEBUG
      sva_check_area(sva);
      luf_check_all(luf, n+1);
#endif
      /* defragment SVA; currently all columns of V are empty, so they
       * will have zero capacity as required by luf_build_v_cols */
      sva_defrag_area(sva);
      /* build matrix F in row-wise format */
      luf_build_f_rows(luf, rs_head);
      /* build matrix V in column-wise format */
      luf_build_v_cols(luf, sgf->updat, rs_head);
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/sgf.h0000644000175100001710000002017400000000000024116 0ustar00runnerdocker00000000000000/* sgf.h (sparse Gaussian factorizer) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SGF_H
#define SGF_H

#include "luf.h"

typedef struct SGF SGF;

struct SGF
{     /* sparse Gaussian factorizer workspace */
      LUF *luf;
      /* LU-factorization being computed */
      /*--------------------------------------------------------------*/
      /* to efficiently choose pivot elements according to Markowitz
       * strategy, the search technique proposed by Iain Duff is used;
       * it is based on using two families of sets {R[0], ..., R[n]}
       * and {C[0], ..., C[n]}, where R[k] and C[k], 0 <= k <= n, are,
       * respectively, sets of rows and columns of the active submatrix
       * of matrix V having k non-zeros (i.e. whose length is k); each
       * set R[k] and C[k] is implemented as a doubly linked list */
      int *rs_head; /* int rs_head[1+n]; */
      /* rs_head[k], 0 <= k <= n, is the number of first row, which
       * has k non-zeros in the active submatrix */
      int *rs_prev; /* int rs_prev[1+n]; */
      /* rs_prev[0] is not used;
       * rs_prev[i], 1 <= i <= n, is the number of previous row, which
       * has the same number of non-zeros as i-th row;
       * rs_prev[i] < 0 means that i-th row is inactive */
      int *rs_next; /* int rs_next[1+n]; */
      /* rs_next[0] is not used;
       * rs_next[i], 1 <= i <= n, is the number of next row, which has
       * the same number of non-zeros as i-th row;
       * rs_next[i] < 0 means that i-th row is inactive */
      int *cs_head; /* int cs_head[1+n]; */
      /* cs_head[k], 0 <= k <= n, is the number of first column, which
       * has k non-zeros in the active submatrix */
      int *cs_prev; /* int cs_prev[1+n]; */
      /* cs_prev[0] is not used;
       * cs_prev[j], 1 <= j <= n, is the number of previous column,
       * which has the same number of non-zeros as j-th column;
       * cs_prev[j] < 0 means that j-th column is inactive */
      int *cs_next; /* int cs_next[1+n]; */
      /* cs_next[0] is not used;
       * cs_next[j], 1 <= j <= n, is the number of next column, which
       * has the same number of non-zeros as j-th column;
       * cs_next[j] < 0 means that j-th column is inactive */
      /* NOTE: cs_prev[j] = cs_next[j] = j means that j-th column was
       *       temporarily removed from corresponding set C[k] by the
       *       pivoting routine according to Uwe Suhl's heuristic */
      /*--------------------------------------------------------------*/
      /* working arrays */
      double *vr_max; /* int vr_max[1+n]; */
      /* vr_max[0] is not used;
       * vr_max[i], 1 <= i <= n, is used only if i-th row of matrix V
       * is active (i.e. belongs to the active submatrix), and is the
       * largest magnitude of elements in that row; if vr_max[i] < 0,
       * the largest magnitude is unknown yet */
      char *flag; /* char flag[1+n]; */
      /* boolean working array */
      double *work; /* double work[1+n]; */
      /* floating-point working array */
      /*--------------------------------------------------------------*/
      /* control parameters */
      int updat;
      /* if this flag is set, the matrix V is assumed to be updatable;
       * in this case factorized (non-active) part of V is stored in
       * the left part of SVA rather than in its right part */
      double piv_tol;
      /* threshold pivoting tolerance, 0 < piv_tol < 1; element v[i,j]
       * of the active submatrix fits to be pivot if it satisfies to
       * the stability criterion |v[i,j]| >= piv_tol * max |v[i,*]|,
       * i.e. if it is not very small in the magnitude among other
       * elements in the same row; decreasing this parameter gives
       * better sparsity at the expense of numerical accuracy and vice
       * versa */
      int piv_lim;
      /* maximal allowable number of pivot candidates to be considered;
       * if piv_lim pivot candidates have been considered, the pivoting
       * routine terminates the search with the best candidate found */
      int suhl;
      /* if this flag is set, the pivoting routine applies a heuristic
       * proposed by Uwe Suhl: if a column of the active submatrix has
       * no eligible pivot candidates (i.e. all its elements do not
       * satisfy to the stability criterion), the routine excludes it
       * from futher consideration until it becomes column singleton;
       * in many cases this allows reducing the time needed to choose
       * the pivot */
      double eps_tol;
      /* epsilon tolerance; each element of the active submatrix, whose
       * magnitude is less than eps_tol, is replaced by exact zero */
#if 0 /* FIXME */
      double den_lim;
      /* density limit; if the density of the active submatrix reaches
       * this limit, the factorization routine switches from sparse to
       * dense mode */
#endif
};

#define sgf_activate_row(i) \
      do \
      {  int len = vr_len[i]; \
         rs_prev[i] = 0; \
         rs_next[i] = rs_head[len]; \
         if (rs_next[i] != 0) \
            rs_prev[rs_next[i]] = i; \
         rs_head[len] = i; \
      } while (0)
/* include i-th row of matrix V in active set R[len] */

#define sgf_deactivate_row(i) \
      do \
      {  if (rs_prev[i] == 0) \
            rs_head[vr_len[i]] = rs_next[i]; \
         else \
            rs_next[rs_prev[i]] = rs_next[i]; \
         if (rs_next[i] == 0) \
            ; \
         else \
            rs_prev[rs_next[i]] = rs_prev[i]; \
         rs_prev[i] = rs_next[i] = -1; \
      } while (0)
/* remove i-th row of matrix V from active set R[len] */

#define sgf_activate_col(j) \
      do \
      {  int len = vc_len[j]; \
         cs_prev[j] = 0; \
         cs_next[j] = cs_head[len]; \
         if (cs_next[j] != 0) \
            cs_prev[cs_next[j]] = j; \
         cs_head[len] = j; \
      } while (0)
/* include j-th column of matrix V in active set C[len] */

#define sgf_deactivate_col(j) \
      do \
      {  if (cs_prev[j] == 0) \
            cs_head[vc_len[j]] = cs_next[j]; \
         else \
            cs_next[cs_prev[j]] = cs_next[j]; \
         if (cs_next[j] == 0) \
            ; \
         else \
            cs_prev[cs_next[j]] = cs_prev[j]; \
         cs_prev[j] = cs_next[j] = -1; \
      } while (0)
/* remove j-th column of matrix V from active set C[len] */

#define sgf_reduce_nuc _glp_sgf_reduce_nuc
int sgf_reduce_nuc(LUF *luf, int *k1, int *k2, int cnt[/*1+n*/],
      int list[/*1+n*/]);
/* initial reordering to minimize nucleus size */

#define sgf_singl_phase _glp_sgf_singl_phase
int sgf_singl_phase(LUF *luf, int k1, int k2, int updat,
      int ind[/*1+n*/], double val[/*1+n*/]);
/* compute LU-factorization (singleton phase) */

#define sgf_choose_pivot _glp_sgf_choose_pivot
int sgf_choose_pivot(SGF *sgf, int *p, int *q);
/* choose pivot element v[p,q] */

#define sgf_eliminate _glp_sgf_eliminate
int sgf_eliminate(SGF *sgf, int p, int q);
/* perform gaussian elimination */

#define sgf_dense_lu _glp_sgf_dense_lu
int sgf_dense_lu(int n, double a[], int r[], int c[], double eps);
/* compute dense LU-factorization with full pivoting */

#define sgf_dense_phase _glp_sgf_dense_phase
int sgf_dense_phase(LUF *luf, int k, int updat);
/* compute LU-factorization (dense phase) */

#define sgf_factorize _glp_sgf_factorize
int sgf_factorize(SGF *sgf, int singl);
/* compute LU-factorization (main routine) */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/sva.c0000644000175100001710000004556000000000000024131 0ustar00runnerdocker00000000000000/* sva.c (sparse vector area) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "sva.h"

/***********************************************************************
*  sva_create_area - create sparse vector area (SVA)
*
*  This routine creates the sparse vector area (SVA), which initially
*  is empty.
*
*  The parameter n_max specifies the initial number of vectors that can
*  be allocated in the SVA, n_max > 0.
*
*  The parameter size specifies the initial number of free locations in
*  the SVA, size > 0.
*
*  On exit the routine returns a pointer to the SVA created. */

SVA *sva_create_area(int n_max, int size)
{     SVA *sva;
      xassert(0 < n_max && n_max < INT_MAX);
      xassert(0 < size && size < INT_MAX);
      sva = talloc(1, SVA);
      sva->n_max = n_max;
      sva->n = 0;
      sva->ptr = talloc(1+n_max, int);
      sva->len = talloc(1+n_max, int);
      sva->cap = talloc(1+n_max, int);
      sva->size = size;
      sva->m_ptr = 1;
      sva->r_ptr = size+1;
      sva->head = sva->tail = 0;
      sva->prev = talloc(1+n_max, int);
      sva->next = talloc(1+n_max, int);
      sva->ind = talloc(1+size, int);
      sva->val = talloc(1+size, double);
      sva->talky = 0;
      return sva;
}

/***********************************************************************
*  sva_alloc_vecs - allocate new vectors in SVA
*
*  This routine allocates nnn new empty vectors, nnn > 0, in the sparse
*  vector area (SVA).
*
*  The new vectors are assigned reference numbers k, k+1, ..., k+nnn-1,
*  where k is a reference number assigned to the very first new vector,
*  which is returned by the routine on exit. */

int sva_alloc_vecs(SVA *sva, int nnn)
{     int n = sva->n;
      int n_max = sva->n_max;
      int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      int *prev = sva->prev;
      int *next = sva->next;
      int k, new_n;
#if 1
      if (sva->talky)
         xprintf("sva_alloc_vecs: nnn = %d\n", nnn);
#endif
      xassert(nnn > 0);
      /* determine new number of vectors in SVA */
      new_n = n + nnn;
      xassert(new_n > n);
      if (n_max < new_n)
      {  /* enlarge the SVA arrays */
         while (n_max < new_n)
         {  n_max += n_max;
            xassert(n_max > 0);
         }
         sva->n_max = n_max;
         sva->ptr = ptr = trealloc(ptr, 1+n_max, int);
         sva->len = len = trealloc(len, 1+n_max, int);
         sva->cap = cap = trealloc(cap, 1+n_max, int);
         sva->prev = prev = trealloc(prev, 1+n_max, int);
         sva->next = next = trealloc(next, 1+n_max, int);
      }
      /* initialize new vectors */
      sva->n = new_n;
      for (k = n+1; k <= new_n; k++)
      {  ptr[k] = len[k] = cap[k] = 0;
         prev[k] = next[k] = -1;
      }
#if 1
      if (sva->talky)
         xprintf("now sva->n_max = %d, sva->n = %d\n",
            sva->n_max, sva->n);
#endif
      /* return reference number of very first new vector */
      return n+1;
}

/***********************************************************************
*  sva_resize_area - change size of SVA storage
*
*  This routine increases or decrases the size of the SVA storage by
*  reallocating it.
*
*  The parameter delta specifies the number of location by which the
*  current size of the SVA storage should be increased (if delta > 0)
*  or decreased (if delta < 0). Note that if delta is negative, it
*  should not be less than the current size of the middle part.
*
*  As a result of this operation the size of the middle part of SVA is
*  increased/decreased by delta locations.
*
*  NOTE: This operation changes ptr[k] for all vectors stored in the
*        right part of SVA. */

void sva_resize_area(SVA *sva, int delta)
{     int n = sva->n;
      int *ptr = sva->ptr;
      int size = sva->size;
      int m_ptr = sva->m_ptr;
      int r_ptr = sva->r_ptr;
      int k, r_size;
#if 1
      if (sva->talky)
         xprintf("sva_resize_area: delta = %d\n", delta);
#endif
      xassert(delta != 0);
      /* determine size of the right part, in locations */
      r_size = size - r_ptr + 1;
      /* relocate the right part in case of negative delta */
      if (delta < 0)
      {  xassert(delta >= m_ptr - r_ptr);
         sva->r_ptr += delta;
         memmove(&sva->ind[sva->r_ptr], &sva->ind[r_ptr],
            r_size * sizeof(int));
         memmove(&sva->val[sva->r_ptr], &sva->val[r_ptr],
            r_size * sizeof(double));
      }
      /* reallocate the storage arrays */
      xassert(delta < INT_MAX - sva->size);
      sva->size += delta;
      sva->ind = trealloc(sva->ind, 1+sva->size, int);
      sva->val = trealloc(sva->val, 1+sva->size, double);
      /* relocate the right part in case of positive delta */
      if (delta > 0)
      {  sva->r_ptr += delta;
         memmove(&sva->ind[sva->r_ptr], &sva->ind[r_ptr],
            r_size * sizeof(int));
         memmove(&sva->val[sva->r_ptr], &sva->val[r_ptr],
            r_size * sizeof(double));
      }
      /* update pointers to vectors stored in the right part */
      for (k = 1; k <= n; k++)
      {  if (ptr[k] >= r_ptr)
            ptr[k] += delta;
      }
#if 1
      if (sva->talky)
         xprintf("now sva->size = %d\n", sva->size);
#endif
      return;
}

/***********************************************************************
*  sva_defrag_area - defragment left part of SVA
*
*  This routine performs "garbage" collection to defragment the left
*  part of SVA.
*
*  NOTE: This operation may change ptr[k] and cap[k] for all vectors
*        stored in the left part of SVA. */

void sva_defrag_area(SVA *sva)
{     int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      int *prev = sva->prev;
      int *next = sva->next;
      int *ind = sva->ind;
      double *val = sva->val;
      int k, next_k, ptr_k, len_k, m_ptr, head, tail;
#if 1
      if (sva->talky)
      {  xprintf("sva_defrag_area:\n");
         xprintf("before defragmenting = %d %d %d\n", sva->m_ptr - 1,
            sva->r_ptr - sva->m_ptr, sva->size + 1 - sva->r_ptr);
      }
#endif
      m_ptr = 1;
      head = tail = 0;
      /* walk through the linked list of vectors stored in the left
       * part of SVA */
      for (k = sva->head; k != 0; k = next_k)
      {  /* save number of next vector in the list */
         next_k = next[k];
         /* determine length of k-th vector */
         len_k = len[k];
         if (len_k == 0)
         {  /* k-th vector is empty; remove it from the left part */
            ptr[k] = cap[k] = 0;
            prev[k] = next[k] = -1;
         }
         else
         {  /* determine pointer to first location of k-th vector */
            ptr_k = ptr[k];
            xassert(m_ptr <= ptr_k);
            /* relocate k-th vector to the beginning of the left part,
             * if necessary */
            if (m_ptr < ptr_k)
            {  memmove(&ind[m_ptr], &ind[ptr_k],
                  len_k * sizeof(int));
               memmove(&val[m_ptr], &val[ptr_k],
                  len_k * sizeof(double));
               ptr[k] = m_ptr;
            }
            /* remove unused locations from k-th vector */
            cap[k] = len_k;
            /* the left part of SVA has been enlarged */
            m_ptr += len_k;
            /* add k-th vector to the end of the new linked list */
            prev[k] = tail;
            next[k] = 0;
            if (head == 0)
               head = k;
            else
               next[tail] = k;
            tail = k;
         }
      }
      /* set new pointer to the middle part of SVA */
      xassert(m_ptr <= sva->r_ptr);
      sva->m_ptr = m_ptr;
      /* set new head and tail of the linked list */
      sva->head = head;
      sva->tail = tail;
#if 1
      if (sva->talky)
         xprintf("after defragmenting = %d %d %d\n", sva->m_ptr - 1,
            sva->r_ptr - sva->m_ptr, sva->size + 1 - sva->r_ptr);
#endif
      return;
}

/***********************************************************************
*  sva_more_space - increase size of middle (free) part of SVA
*
*  This routine increases the size of the middle (free) part of the
*  sparse vector area (SVA).
*
*  The parameter m_size specifies the minimal size, in locations, of
*  the middle part to be provided. This new size should be greater than
*  the current size of the middle part.
*
*  First, the routine defragments the left part of SVA. Then, if the
*  size of the left part has not sufficiently increased, the routine
*  increases the total size of the SVA storage by reallocating it. */

void sva_more_space(SVA *sva, int m_size)
{     int size, delta;
#if 1
      if (sva->talky)
         xprintf("sva_more_space: m_size = %d\n", m_size);
#endif
      xassert(m_size > sva->r_ptr - sva->m_ptr);
      /* defragment the left part */
      sva_defrag_area(sva);
      /* set, heuristically, the minimal size of the middle part to be
       * not less than the size of the defragmented left part */
      if (m_size < sva->m_ptr - 1)
         m_size = sva->m_ptr - 1;
      /* if there is still not enough room, increase the total size of
       * the SVA storage */
      if (sva->r_ptr - sva->m_ptr < m_size)
      {  size = sva->size; /* new sva size */
         for (;;)
         {  delta = size - sva->size;
            if (sva->r_ptr - sva->m_ptr + delta >= m_size)
               break;
            size += size;
            xassert(size > 0);
         }
         sva_resize_area(sva, delta);
         xassert(sva->r_ptr - sva->m_ptr >= m_size);
      }
      return;
}

/***********************************************************************
*  sva_enlarge_cap - enlarge capacity of specified vector
*
*  This routine enlarges the current capacity of the specified vector
*  by relocating its content.
*
*  The parameter k specifies the reference number of the vector whose
*  capacity should be enlarged, 1 <= k <= n. This vector should either
*  have zero capacity or be stored in the left (dynamic) part of SVA.
*
*  The parameter new_cap specifies the new capacity of the vector,
*  in locations. This new capacity should be greater than the current
*  capacity of the vector.
*
*  The parameter skip is a flag. If this flag is set, the routine does
*  *not* copy numerical values of elements of the vector on relocating
*  its content, i.e. only element indices are copied.
*
*  NOTE: On entry to the routine the middle part of SVA should have at
*        least new_cap free locations. */

void sva_enlarge_cap(SVA *sva, int k, int new_cap, int skip)
{     int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      int *prev = sva->prev;
      int *next = sva->next;
      int *ind = sva->ind;
      double *val = sva->val;
      xassert(1 <= k && k <= sva->n);
      xassert(new_cap > cap[k]);
      /* there should be at least new_cap free locations */
      xassert(sva->r_ptr - sva->m_ptr >= new_cap);
      /* relocate the vector */
      if (cap[k] == 0)
      {  /* the vector is empty */
         xassert(ptr[k] == 0);
         xassert(len[k] == 0);
      }
      else
      {  /* the vector has non-zero capacity */
         xassert(ptr[k] + len[k] <= sva->m_ptr);
         /* copy the current vector content to the beginning of the
          * middle part */
         if (len[k] > 0)
         {  memcpy(&ind[sva->m_ptr], &ind[ptr[k]],
               len[k] * sizeof(int));
            if (!skip)
               memcpy(&val[sva->m_ptr], &val[ptr[k]],
                  len[k] * sizeof(double));
         }
         /* remove the vector from the linked list */
         if (prev[k] == 0)
            sva->head = next[k];
         else
         {  /* preceding vector exists; increase its capacity */
            cap[prev[k]] += cap[k];
            next[prev[k]] = next[k];
         }
         if (next[k] == 0)
            sva->tail = prev[k];
         else
            prev[next[k]] = prev[k];
      }
      /* set new pointer and capacity of the vector */
      ptr[k] = sva->m_ptr;
      cap[k] = new_cap;
      /* add the vector to the end of the linked list */
      prev[k] = sva->tail;
      next[k] = 0;
      if (sva->head == 0)
         sva->head = k;
      else
         next[sva->tail] = k;
      sva->tail = k;
      /* new_cap free locations have been consumed */
      sva->m_ptr += new_cap;
      xassert(sva->m_ptr <= sva->r_ptr);
      return;
}

/***********************************************************************
*  sva_reserve_cap - reserve locations for specified vector
*
*  This routine reserves locations for the specified vector in the
*  right (static) part of SVA.
*
*  The parameter k specifies the reference number of the vector (this
*  vector should have zero capacity), 1 <= k <= n.
*
*  The parameter new_cap specifies a non-zero capacity of the vector,
*  in locations.
*
*  NOTE: On entry to the routine the middle part of SVA should have at
*        least new_cap free locations. */

void sva_reserve_cap(SVA *sva, int k, int new_cap)
{     int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      xassert(1 <= k && k <= sva->n);
      xassert(new_cap > 0);
      xassert(ptr[k] == 0 && len[k] == 0 && cap[k] == 0);
      /* there should be at least new_cap free locations */
      xassert(sva->r_ptr - sva->m_ptr >= new_cap);
      /* set the pointer and capacity of the vector */
      ptr[k] = sva->r_ptr - new_cap;
      cap[k] = new_cap;
      /* new_cap free locations have been consumed */
      sva->r_ptr -= new_cap;
      return;
}

/***********************************************************************
*  sva_make_static - relocate specified vector to right part of SVA
*
*  Assuming that the specified vector is stored in the left (dynamic)
*  part of SVA, this routine makes the vector static by relocating its
*  content to the right (static) part of SVA. However, if the specified
*  vector has zero capacity, the routine does nothing.
*
*  The parameter k specifies the reference number of the vector to be
*  relocated, 1 <= k <= n.
*
*  NOTE: On entry to the routine the middle part of SVA should have at
*        least len[k] free locations, where len[k] is the length of the
*        vector to be relocated. */

void sva_make_static(SVA *sva, int k)
{     int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      int *prev = sva->prev;
      int *next = sva->next;
      int *ind = sva->ind;
      double *val = sva->val;
      int ptr_k, len_k;
      xassert(1 <= k && k <= sva->n);
      /* if the vector has zero capacity, do nothing */
      if (cap[k] == 0)
      {  xassert(ptr[k] == 0);
         xassert(len[k] == 0);
         goto done;
      }
      /* there should be at least len[k] free locations */
      len_k = len[k];
      xassert(sva->r_ptr - sva->m_ptr >= len_k);
      /* remove the vector from the linked list */
      if (prev[k] == 0)
         sva->head = next[k];
      else
      {  /* preceding vector exists; increase its capacity */
         cap[prev[k]] += cap[k];
         next[prev[k]] = next[k];
      }
      if (next[k] == 0)
         sva->tail = prev[k];
      else
         prev[next[k]] = prev[k];
      /* if the vector has zero length, make it empty */
      if (len_k == 0)
      {  ptr[k] = cap[k] = 0;
         goto done;
      }
      /* copy the vector content to the beginning of the right part */
      ptr_k = sva->r_ptr - len_k;
      memcpy(&ind[ptr_k], &ind[ptr[k]], len_k * sizeof(int));
      memcpy(&val[ptr_k], &val[ptr[k]], len_k * sizeof(double));
      /* set new pointer and capacity of the vector */
      ptr[k] = ptr_k;
      cap[k] = len_k;
      /* len[k] free locations have been consumed */
      sva->r_ptr -= len_k;
done: return;
}

/***********************************************************************
*  sva_check_area - check sparse vector area (SVA)
*
*  This routine checks the SVA data structures for correctness.
*
*  NOTE: For testing/debugging only. */

void sva_check_area(SVA *sva)
{     int n_max = sva->n_max;
      int n = sva->n;
      int *ptr = sva->ptr;
      int *len = sva->len;
      int *cap = sva->cap;
      int size = sva->size;
      int m_ptr = sva->m_ptr;
      int r_ptr = sva->r_ptr;
      int head = sva->head;
      int tail = sva->tail;
      int *prev = sva->prev;
      int *next = sva->next;
      int k;
#if 0 /* 16/II-2004; SVA may be empty */
      xassert(1 <= n && n <= n_max);
#else
      xassert(0 <= n && n <= n_max);
#endif
      xassert(1 <= m_ptr && m_ptr <= r_ptr && r_ptr <= size+1);
      /* all vectors included the linked list should have non-zero
       * capacity and be stored in the left part */
      for (k = head; k != 0; k = next[k])
      {  xassert(1 <= k && k <= n);
         xassert(cap[k] > 0);
         xassert(0 <= len[k] && len[k] <= cap[k]);
         if (prev[k] == 0)
            xassert(k == head);
         else
         {  xassert(1 <= prev[k] && prev[k] <= n);
            xassert(next[prev[k]] == k);
         }
         if (next[k] == 0)
         {  xassert(k == tail);
            xassert(ptr[k] + cap[k] <= m_ptr);
         }
         else
         {  xassert(1 <= next[k] && next[k] <= n);
            xassert(prev[next[k]] == k);
            xassert(ptr[k] + cap[k] <= ptr[next[k]]);
         }
         cap[k] = -cap[k];
      }
      /* all other vectors should either have zero capacity or be
       * stored in the right part */
      for (k = 1; k <= n; k++)
      {  if (cap[k] < 0)
         {  /* k-th vector is stored in the left part */
            cap[k] = -cap[k];
         }
         else if (cap[k] == 0)
         {  /* k-th vector has zero capacity */
            xassert(ptr[k] == 0);
            xassert(len[k] == 0);
         }
         else /* cap[k] > 0 */
         {  /* k-th vector is stored in the right part */
            xassert(0 <= len[k] && len[k] <= cap[k]);
            xassert(r_ptr <= ptr[k] && ptr[k] + cap[k] <= size+1);
         }
      }
      return;
}

/***********************************************************************
*  sva_delete_area - delete sparse vector area (SVA)
*
*  This routine deletes the sparse vector area (SVA) freeing all the
*  memory allocated to it. */

void sva_delete_area(SVA *sva)
{     tfree(sva->ptr);
      tfree(sva->len);
      tfree(sva->cap);
      tfree(sva->prev);
      tfree(sva->next);
      tfree(sva->ind);
      tfree(sva->val);
      tfree(sva);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/bflib/sva.h0000644000175100001710000001462700000000000024136 0ustar00runnerdocker00000000000000/* sva.h (sparse vector area) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SVA_H
#define SVA_H

/***********************************************************************
*  Sparse Vector Area (SVA) is a container for sparse vectors. This
*  program object is used mainly on computing factorization, where the
*  sparse vectors are rows and columns of sparse matrices.
*
*  The SVA storage is a set of locations numbered 1, 2, ..., size,
*  where size is the size of SVA, which is the total number of
*  locations currently allocated. Each location is identified by its
*  pointer p, 1 <= p <= size, and is the pair (ind[p], val[p]), where
*  ind[p] and val[p] are, respectively, the index and value fields used
*  to store the index and numeric value of a particular vector element.
*
*  Each sparse vector is identified by its reference number k,
*  1 <= k <= n, where n is the total number of vectors currently stored
*  in SVA, and defined by the triplet (ptr[k], len[k], cap[k]), where:
*  ptr[k] is a pointer to the first location of the vector; len[k] is
*  the vector length, which is the number of its non-zero elements,
*  len[k] >= 0; and cap[k] is the capacity of the vector, which is the
*  total number of adjacent locations allocated to that vector,
*  cap[k] >= len[k]. Thus, non-zero elements of k-th vector are stored
*  in locations ptr[k], ptr[k]+1, ..., ptr[k]+len[k]-1, and locations
*  ptr[k]+len[k], ptr[k]+len[k]+1, ..., ptr[k]+cap[k]-1 are reserved.
*
*  The SVA storage is divided into three parts as follows:
*
*  Locations 1, 2, ..., m_ptr-1 constitute the left (dynamic) part of
*  SVA. This part is used to store vectors, whose capacity may change.
*  Note that all vectors stored in the left part are also included in
*  a doubly linked list, where they are ordered by increasing their
*  pointers ptr[k] (this list is needed for efficient implementation
*  of the garbage collector used to defragment the left part of SVA);
*
*  Locations m_ptr, m_ptr+1, ..., r_ptr-1 are free and constitute the
*  middle (free) part of SVA.
*
*  Locations r_ptr, r_ptr+1, ..., size constitute the right (static)
*  part of SVA. This part is used to store vectors, whose capacity is
*  not changed. */

typedef struct SVA SVA;

struct SVA
{     /* sparse vector area */
      int n_max;
      /* maximal value of n (enlarged automatically) */
      int n;
      /* number of currently allocated vectors, 0 <= n <= n_max */
      int *ptr; /* int ptr[1+n_max]; */
      /* ptr[0] is not used;
       * ptr[k], 1 <= i <= n, is pointer to first location of k-th
       * vector in the arrays ind and val */
      int *len; /* int len[1+n_max]; */
      /* len[0] is not used;
       * len[k], 1 <= k <= n, is length of k-th vector, len[k] >= 0 */
      int *cap; /* int cap[1+n_max]; */
      /* cap[0] is not used;
       * cap[k], 1 <= k <= n, is capacity of k-th vector (the number
       * of adjacent locations allocated to it), cap[k] >= len[k] */
      /* NOTE: if cap[k] = 0, then ptr[k] = 0 and len[k] = 0 */
      int size;
      /* total number of locations in SVA */
      int m_ptr, r_ptr;
      /* partitioning pointers that define the left, middle, and right
       * parts of SVA (see above); 1 <= m_ptr <= r_ptr <= size+1 */
      int head;
      /* number of first (leftmost) vector in the linked list */
      int tail;
      /* number of last (rightmost) vector in the linked list */
      int *prev; /* int prev[1+n_max]; */
      /* prev[0] is not used;
       * prev[k] is number of vector which precedes k-th vector in the
       * linked list;
       * prev[k] < 0 means that k-th vector is not in the list */
      int *next; /* int next[1+n_max]; */
      /* next[0] is not used;
       * next[k] is number of vector which succedes k-th vector in the
       * linked list;
       * next[k] < 0 means that k-th vector is not in the list */
      /* NOTE: only vectors having non-zero capacity and stored in the
       *       left part of SVA are included in this linked list */
      int *ind; /* int ind[1+size]; */
      /* ind[0] is not used;
       * ind[p], 1 <= p <= size, is index field of location p */
      double *val; /* double val[1+size]; */
      /* val[0] is not used;
       * val[p], 1 <= p <= size, is value field of location p */
#if 1
      int talky;
      /* option to enable talky mode */
#endif
};

#define sva_create_area _glp_sva_create_area
SVA *sva_create_area(int n_max, int size);
/* create sparse vector area (SVA) */

#define sva_alloc_vecs _glp_sva_alloc_vecs
int sva_alloc_vecs(SVA *sva, int nnn);
/* allocate new vectors in SVA */

#define sva_resize_area _glp_sva_resize_area
void sva_resize_area(SVA *sva, int delta);
/* change size of SVA storage */

#define sva_defrag_area _glp_sva_defrag_area
void sva_defrag_area(SVA *sva);
/* defragment left part of SVA */

#define sva_more_space _glp_sva_more_space
void sva_more_space(SVA *sva, int m_size);
/* increase size of middle (free) part of SVA */

#define sva_enlarge_cap _glp_sva_enlarge_cap
void sva_enlarge_cap(SVA *sva, int k, int new_cap, int skip);
/* enlarge capacity of specified vector */

#define sva_reserve_cap _glp_sva_reserve_cap
void sva_reserve_cap(SVA *sva, int k, int new_cap);
/* reserve locations for specified vector */

#define sva_make_static _glp_sva_make_static
void sva_make_static(SVA *sva, int k);
/* relocate specified vector to right part of SVA */

#define sva_check_area _glp_sva_check_area
void sva_check_area(SVA *sva);
/* check sparse vector area (SVA) */

#define sva_delete_area _glp_sva_delete_area
void sva_delete_area(SVA *sva);
/* delete sparse vector area (SVA) */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.663143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/colamd/0000755000175100001710000000000000000000000023343 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/colamd/COPYING0000644000175100001710000006362500000000000024412 0ustar00runnerdocker00000000000000                  GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999

 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

                  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.

  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

                            NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

                     END OF TERMS AND CONDITIONS

           How to Apply These Terms to Your New Libraries

  If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

  To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

    
    Copyright (C)   

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

  , 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/colamd/README0000644000175100001710000001027400000000000024227 0ustar00runnerdocker00000000000000NOTE: Files in this subdirectory are NOT part of the GLPK package, but
      are used with GLPK.

      The original code was modified according to GLPK requirements by
      Andrew Makhorin .
************************************************************************
COLAMD/SYMAMD Version 2.7, Copyright (C) 1998-2007, Timothy A. Davis,
All Rights Reserved.

Description:

   colamd:  an approximate minimum degree column ordering algorithm,
            for LU factorization of symmetric or unsymmetric matrices,
            QR factorization, least squares, interior point methods for
            linear programming problems, and other related problems.

   symamd:  an approximate minimum degree ordering algorithm for
            Cholesky factorization of symmetric matrices.

Purpose:

   Colamd computes a permutation Q such that the Cholesky factorization
   of (AQ)'(AQ) has less fill-in and requires fewer floating point
   operations than A'A.  This also provides a good ordering for sparse
   partial pivoting methods, P(AQ) = LU, where Q is computed prior to
   numerical factorization, and P is computed during numerical
   factorization via conventional partial pivoting with row
   interchanges.  Colamd is the column ordering method used in SuperLU,
   part of the ScaLAPACK library.  It is also available as built-in
   function in MATLAB Version 6, available from MathWorks, Inc.
   (http://www.mathworks.com).  This routine can be used in place of
   colmmd in MATLAB.

   Symamd computes a permutation P of a symmetric matrix A such that
   the Cholesky factorization of PAP' has less fill-in and requires
   fewer floating point operations than A.  Symamd constructs a matrix
   M such that M'M has the same nonzero pattern of A, and then orders
   the columns of M using colmmd.  The column ordering of M is then
   returned as the row and column ordering P of A.

Authors:

   The authors of the code itself are Stefan I. Larimore and Timothy A.
   Davis (davis at cise.ufl.edu), University of Florida.  The algorithm
   was developed in collaboration with John Gilbert, Xerox PARC, and
   Esmond Ng, Oak Ridge National Laboratory.

Acknowledgements:

   This work was supported by the National Science Foundation, under
   grants DMS-9504974 and DMS-9803599.

License:

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1 of
   the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
   USA.

   Permission is hereby granted to use or copy this program under the
   terms of the GNU LGPL, provided that the Copyright, this License,
   and the Availability of the original version is retained on all
   copies.  User documentation of any code that uses this code or any
   modified version of this code must cite the Copyright, this License,
   the Availability note, and "Used by permission."  Permission to
   modify the code and to distribute modified code is granted, provided
   the Copyright, this License, and the Availability note are retained,
   and a notice that the code was modified is included.

   COLAMD is also available under alternate licenses, contact T. Davis
   for details.

Availability:

   The colamd/symamd library is available at:

   http://www.cise.ufl.edu/research/sparse/colamd/

References:

   T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, An approximate
   column minimum degree ordering algorithm, ACM Transactions on
   Mathematical Software, vol. 30, no. 3., pp. 353-376, 2004.

   T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836:
   COLAMD, an approximate column minimum degree ordering algorithm, ACM
   Transactions on Mathematical Software, vol. 30, no. 3., pp. 377-380,
   2004.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/colamd/colamd.c0000644000175100001710000036777400000000000024776 0ustar00runnerdocker00000000000000/* ========================================================================== */
/* === colamd/symamd - a sparse matrix column ordering algorithm ============ */
/* ========================================================================== */

/* COLAMD / SYMAMD

    colamd:  an approximate minimum degree column ordering algorithm,
        for LU factorization of symmetric or unsymmetric matrices,
        QR factorization, least squares, interior point methods for
        linear programming problems, and other related problems.

    symamd:  an approximate minimum degree ordering algorithm for Cholesky
        factorization of symmetric matrices.

    Purpose:

        Colamd computes a permutation Q such that the Cholesky factorization of
        (AQ)'(AQ) has less fill-in and requires fewer floating point operations
        than A'A.  This also provides a good ordering for sparse partial
        pivoting methods, P(AQ) = LU, where Q is computed prior to numerical
        factorization, and P is computed during numerical factorization via
        conventional partial pivoting with row interchanges.  Colamd is the
        column ordering method used in SuperLU, part of the ScaLAPACK library.
        It is also available as built-in function in MATLAB Version 6,
        available from MathWorks, Inc. (http://www.mathworks.com).  This
        routine can be used in place of colmmd in MATLAB.

        Symamd computes a permutation P of a symmetric matrix A such that the
        Cholesky factorization of PAP' has less fill-in and requires fewer
        floating point operations than A.  Symamd constructs a matrix M such
        that M'M has the same nonzero pattern of A, and then orders the columns
        of M using colmmd.  The column ordering of M is then returned as the
        row and column ordering P of A.

    Authors:

        The authors of the code itself are Stefan I. Larimore and Timothy A.
        Davis (davis at cise.ufl.edu), University of Florida.  The algorithm was
        developed in collaboration with John Gilbert, Xerox PARC, and Esmond
        Ng, Oak Ridge National Laboratory.

    Acknowledgements:

        This work was supported by the National Science Foundation, under
        grants DMS-9504974 and DMS-9803599.

    Copyright and License:

        Copyright (c) 1998-2007, Timothy A. Davis, All Rights Reserved.
        COLAMD is also available under alternate licenses, contact T. Davis
        for details.

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
        USA

        Permission is hereby granted to use or copy this program under the
        terms of the GNU LGPL, provided that the Copyright, this License,
        and the Availability of the original version is retained on all copies.
        User documentation of any code that uses this code or any modified
        version of this code must cite the Copyright, this License, the
        Availability note, and "Used by permission." Permission to modify
        the code and to distribute modified code is granted, provided the
        Copyright, this License, and the Availability note are retained,
        and a notice that the code was modified is included.

    Availability:

        The colamd/symamd library is available at

            http://www.cise.ufl.edu/research/sparse/colamd/

        This is the http://www.cise.ufl.edu/research/sparse/colamd/colamd.c
        file.  It requires the colamd.h file.  It is required by the colamdmex.c
        and symamdmex.c files, for the MATLAB interface to colamd and symamd.
        Appears as ACM Algorithm 836.

    See the ChangeLog file for changes since Version 1.0.

    References:

        T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, An approximate column
        minimum degree ordering algorithm, ACM Transactions on Mathematical
        Software, vol. 30, no. 3., pp. 353-376, 2004.

        T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836: COLAMD,
        an approximate column minimum degree ordering algorithm, ACM
        Transactions on Mathematical Software, vol. 30, no. 3., pp. 377-380,
        2004.

*/

/* ========================================================================== */
/* === Description of user-callable routines ================================ */
/* ========================================================================== */

/* COLAMD includes both int and UF_long versions of all its routines.  The
 * description below is for the int version.  For UF_long, all int arguments
 * become UF_long.  UF_long is normally defined as long, except for WIN64.

    ----------------------------------------------------------------------------
    colamd_recommended:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            size_t colamd_recommended (int nnz, int n_row, int n_col) ;
            size_t colamd_l_recommended (UF_long nnz, UF_long n_row,
                UF_long n_col) ;

        Purpose:

            Returns recommended value of Alen for use by colamd.  Returns 0
            if any input argument is negative.  The use of this routine
            is optional.  Not needed for symamd, which dynamically allocates
            its own memory.

            Note that in v2.4 and earlier, these routines returned int or long.
            They now return a value of type size_t.

        Arguments (all input arguments):

            int nnz ;           Number of nonzeros in the matrix A.  This must
                                be the same value as p [n_col] in the call to
                                colamd - otherwise you will get a wrong value
                                of the recommended memory to use.

            int n_row ;         Number of rows in the matrix A.

            int n_col ;         Number of columns in the matrix A.

    ----------------------------------------------------------------------------
    colamd_set_defaults:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            colamd_set_defaults (double knobs [COLAMD_KNOBS]) ;
            colamd_l_set_defaults (double knobs [COLAMD_KNOBS]) ;

        Purpose:

            Sets the default parameters.  The use of this routine is optional.

        Arguments:

            double knobs [COLAMD_KNOBS] ;       Output only.

                NOTE: the meaning of the dense row/col knobs has changed in v2.4

                knobs [0] and knobs [1] control dense row and col detection:

                Colamd: rows with more than
                max (16, knobs [COLAMD_DENSE_ROW] * sqrt (n_col))
                entries are removed prior to ordering.  Columns with more than
                max (16, knobs [COLAMD_DENSE_COL] * sqrt (MIN (n_row,n_col)))
                entries are removed prior to
                ordering, and placed last in the output column ordering.

                Symamd: uses only knobs [COLAMD_DENSE_ROW], which is knobs [0].
                Rows and columns with more than
                max (16, knobs [COLAMD_DENSE_ROW] * sqrt (n))
                entries are removed prior to ordering, and placed last in the
                output ordering.

                COLAMD_DENSE_ROW and COLAMD_DENSE_COL are defined as 0 and 1,
                respectively, in colamd.h.  Default values of these two knobs
                are both 10.  Currently, only knobs [0] and knobs [1] are
                used, but future versions may use more knobs.  If so, they will
                be properly set to their defaults by the future version of
                colamd_set_defaults, so that the code that calls colamd will
                not need to change, assuming that you either use
                colamd_set_defaults, or pass a (double *) NULL pointer as the
                knobs array to colamd or symamd.

            knobs [2]: aggressive absorption

                knobs [COLAMD_AGGRESSIVE] controls whether or not to do
                aggressive absorption during the ordering.  Default is TRUE.


    ----------------------------------------------------------------------------
    colamd:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            int colamd (int n_row, int n_col, int Alen, int *A, int *p,
                double knobs [COLAMD_KNOBS], int stats [COLAMD_STATS]) ;
            UF_long colamd_l (UF_long n_row, UF_long n_col, UF_long Alen,
                UF_long *A, UF_long *p, double knobs [COLAMD_KNOBS],
                UF_long stats [COLAMD_STATS]) ;

        Purpose:

            Computes a column ordering (Q) of A such that P(AQ)=LU or
            (AQ)'AQ=LL' have less fill-in and require fewer floating point
            operations than factorizing the unpermuted matrix A or A'A,
            respectively.

        Returns:

            TRUE (1) if successful, FALSE (0) otherwise.

        Arguments:

            int n_row ;         Input argument.

                Number of rows in the matrix A.
                Restriction:  n_row >= 0.
                Colamd returns FALSE if n_row is negative.

            int n_col ;         Input argument.

                Number of columns in the matrix A.
                Restriction:  n_col >= 0.
                Colamd returns FALSE if n_col is negative.

            int Alen ;          Input argument.

                Restriction (see note):
                Alen >= 2*nnz + 6*(n_col+1) + 4*(n_row+1) + n_col
                Colamd returns FALSE if these conditions are not met.

                Note:  this restriction makes an modest assumption regarding
                the size of the two typedef's structures in colamd.h.
                We do, however, guarantee that

                        Alen >= colamd_recommended (nnz, n_row, n_col)

                will be sufficient.  Note: the macro version does not check
                for integer overflow, and thus is not recommended.  Use
                the colamd_recommended routine instead.

            int A [Alen] ;      Input argument, undefined on output.

                A is an integer array of size Alen.  Alen must be at least as
                large as the bare minimum value given above, but this is very
                low, and can result in excessive run time.  For best
                performance, we recommend that Alen be greater than or equal to
                colamd_recommended (nnz, n_row, n_col), which adds
                nnz/5 to the bare minimum value given above.

                On input, the row indices of the entries in column c of the
                matrix are held in A [(p [c]) ... (p [c+1]-1)].  The row indices
                in a given column c need not be in ascending order, and
                duplicate row indices may be be present.  However, colamd will
                work a little faster if both of these conditions are met
                (Colamd puts the matrix into this format, if it finds that the
                the conditions are not met).

                The matrix is 0-based.  That is, rows are in the range 0 to
                n_row-1, and columns are in the range 0 to n_col-1.  Colamd
                returns FALSE if any row index is out of range.

                The contents of A are modified during ordering, and are
                undefined on output.

            int p [n_col+1] ;   Both input and output argument.

                p is an integer array of size n_col+1.  On input, it holds the
                "pointers" for the column form of the matrix A.  Column c of
                the matrix A is held in A [(p [c]) ... (p [c+1]-1)].  The first
                entry, p [0], must be zero, and p [c] <= p [c+1] must hold
                for all c in the range 0 to n_col-1.  The value p [n_col] is
                thus the total number of entries in the pattern of the matrix A.
                Colamd returns FALSE if these conditions are not met.

                On output, if colamd returns TRUE, the array p holds the column
                permutation (Q, for P(AQ)=LU or (AQ)'(AQ)=LL'), where p [0] is
                the first column index in the new ordering, and p [n_col-1] is
                the last.  That is, p [k] = j means that column j of A is the
                kth pivot column, in AQ, where k is in the range 0 to n_col-1
                (p [0] = j means that column j of A is the first column in AQ).

                If colamd returns FALSE, then no permutation is returned, and
                p is undefined on output.

            double knobs [COLAMD_KNOBS] ;       Input argument.

                See colamd_set_defaults for a description.

            int stats [COLAMD_STATS] ;          Output argument.

                Statistics on the ordering, and error status.
                See colamd.h for related definitions.
                Colamd returns FALSE if stats is not present.

                stats [0]:  number of dense or empty rows ignored.

                stats [1]:  number of dense or empty columns ignored (and
                                ordered last in the output permutation p)
                                Note that a row can become "empty" if it
                                contains only "dense" and/or "empty" columns,
                                and similarly a column can become "empty" if it
                                only contains "dense" and/or "empty" rows.

                stats [2]:  number of garbage collections performed.
                                This can be excessively high if Alen is close
                                to the minimum required value.

                stats [3]:  status code.  < 0 is an error code.
                            > 1 is a warning or notice.

                        0       OK.  Each column of the input matrix contained
                                row indices in increasing order, with no
                                duplicates.

                        1       OK, but columns of input matrix were jumbled
                                (unsorted columns or duplicate entries).  Colamd
                                had to do some extra work to sort the matrix
                                first and remove duplicate entries, but it
                                still was able to return a valid permutation
                                (return value of colamd was TRUE).

                                        stats [4]: highest numbered column that
                                                is unsorted or has duplicate
                                                entries.
                                        stats [5]: last seen duplicate or
                                                unsorted row index.
                                        stats [6]: number of duplicate or
                                                unsorted row indices.

                        -1      A is a null pointer

                        -2      p is a null pointer

                        -3      n_row is negative

                                        stats [4]: n_row

                        -4      n_col is negative

                                        stats [4]: n_col

                        -5      number of nonzeros in matrix is negative

                                        stats [4]: number of nonzeros, p [n_col]

                        -6      p [0] is nonzero

                                        stats [4]: p [0]

                        -7      A is too small

                                        stats [4]: required size
                                        stats [5]: actual size (Alen)

                        -8      a column has a negative number of entries

                                        stats [4]: column with < 0 entries
                                        stats [5]: number of entries in col

                        -9      a row index is out of bounds

                                        stats [4]: column with bad row index
                                        stats [5]: bad row index
                                        stats [6]: n_row, # of rows of matrx

                        -10     (unused; see symamd.c)

                        -999    (unused; see symamd.c)

                Future versions may return more statistics in the stats array.

        Example:

            See http://www.cise.ufl.edu/research/sparse/colamd/example.c
            for a complete example.

            To order the columns of a 5-by-4 matrix with 11 nonzero entries in
            the following nonzero pattern

                x 0 x 0
                x 0 x x
                0 x x 0
                0 0 x x
                x x 0 0

            with default knobs and no output statistics, do the following:

                #include "colamd.h"
                #define ALEN 100
                int A [ALEN] = {0, 1, 4, 2, 4, 0, 1, 2, 3, 1, 3} ;
                int p [ ] = {0, 3, 5, 9, 11} ;
                int stats [COLAMD_STATS] ;
                colamd (5, 4, ALEN, A, p, (double *) NULL, stats) ;

            The permutation is returned in the array p, and A is destroyed.

    ----------------------------------------------------------------------------
    symamd:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            int symamd (int n, int *A, int *p, int *perm,
                double knobs [COLAMD_KNOBS], int stats [COLAMD_STATS],
                void (*allocate) (size_t, size_t), void (*release) (void *)) ;
            UF_long symamd_l (UF_long n, UF_long *A, UF_long *p, UF_long *perm,
                double knobs [COLAMD_KNOBS], UF_long stats [COLAMD_STATS],
                void (*allocate) (size_t, size_t), void (*release) (void *)) ;

        Purpose:

            The symamd routine computes an ordering P of a symmetric sparse
            matrix A such that the Cholesky factorization PAP' = LL' remains
            sparse.  It is based on a column ordering of a matrix M constructed
            so that the nonzero pattern of M'M is the same as A.  The matrix A
            is assumed to be symmetric; only the strictly lower triangular part
            is accessed.  You must pass your selected memory allocator (usually
            calloc/free or mxCalloc/mxFree) to symamd, for it to allocate
            memory for the temporary matrix M.

        Returns:

            TRUE (1) if successful, FALSE (0) otherwise.

        Arguments:

            int n ;             Input argument.

                Number of rows and columns in the symmetrix matrix A.
                Restriction:  n >= 0.
                Symamd returns FALSE if n is negative.

            int A [nnz] ;       Input argument.

                A is an integer array of size nnz, where nnz = p [n].

                The row indices of the entries in column c of the matrix are
                held in A [(p [c]) ... (p [c+1]-1)].  The row indices in a
                given column c need not be in ascending order, and duplicate
                row indices may be present.  However, symamd will run faster
                if the columns are in sorted order with no duplicate entries.

                The matrix is 0-based.  That is, rows are in the range 0 to
                n-1, and columns are in the range 0 to n-1.  Symamd
                returns FALSE if any row index is out of range.

                The contents of A are not modified.

            int p [n+1] ;       Input argument.

                p is an integer array of size n+1.  On input, it holds the
                "pointers" for the column form of the matrix A.  Column c of
                the matrix A is held in A [(p [c]) ... (p [c+1]-1)].  The first
                entry, p [0], must be zero, and p [c] <= p [c+1] must hold
                for all c in the range 0 to n-1.  The value p [n] is
                thus the total number of entries in the pattern of the matrix A.
                Symamd returns FALSE if these conditions are not met.

                The contents of p are not modified.

            int perm [n+1] ;    Output argument.

                On output, if symamd returns TRUE, the array perm holds the
                permutation P, where perm [0] is the first index in the new
                ordering, and perm [n-1] is the last.  That is, perm [k] = j
                means that row and column j of A is the kth column in PAP',
                where k is in the range 0 to n-1 (perm [0] = j means
                that row and column j of A are the first row and column in
                PAP').  The array is used as a workspace during the ordering,
                which is why it must be of length n+1, not just n.

            double knobs [COLAMD_KNOBS] ;       Input argument.

                See colamd_set_defaults for a description.

            int stats [COLAMD_STATS] ;          Output argument.

                Statistics on the ordering, and error status.
                See colamd.h for related definitions.
                Symamd returns FALSE if stats is not present.

                stats [0]:  number of dense or empty row and columns ignored
                                (and ordered last in the output permutation
                                perm).  Note that a row/column can become
                                "empty" if it contains only "dense" and/or
                                "empty" columns/rows.

                stats [1]:  (same as stats [0])

                stats [2]:  number of garbage collections performed.

                stats [3]:  status code.  < 0 is an error code.
                            > 1 is a warning or notice.

                        0       OK.  Each column of the input matrix contained
                                row indices in increasing order, with no
                                duplicates.

                        1       OK, but columns of input matrix were jumbled
                                (unsorted columns or duplicate entries).  Symamd
                                had to do some extra work to sort the matrix
                                first and remove duplicate entries, but it
                                still was able to return a valid permutation
                                (return value of symamd was TRUE).

                                        stats [4]: highest numbered column that
                                                is unsorted or has duplicate
                                                entries.
                                        stats [5]: last seen duplicate or
                                                unsorted row index.
                                        stats [6]: number of duplicate or
                                                unsorted row indices.

                        -1      A is a null pointer

                        -2      p is a null pointer

                        -3      (unused, see colamd.c)

                        -4      n is negative

                                        stats [4]: n

                        -5      number of nonzeros in matrix is negative

                                        stats [4]: # of nonzeros (p [n]).

                        -6      p [0] is nonzero

                                        stats [4]: p [0]

                        -7      (unused)

                        -8      a column has a negative number of entries

                                        stats [4]: column with < 0 entries
                                        stats [5]: number of entries in col

                        -9      a row index is out of bounds

                                        stats [4]: column with bad row index
                                        stats [5]: bad row index
                                        stats [6]: n_row, # of rows of matrx

                        -10     out of memory (unable to allocate temporary
                                workspace for M or count arrays using the
                                "allocate" routine passed into symamd).

                Future versions may return more statistics in the stats array.

            void * (*allocate) (size_t, size_t)

                A pointer to a function providing memory allocation.  The
                allocated memory must be returned initialized to zero.  For a
                C application, this argument should normally be a pointer to
                calloc.  For a MATLAB mexFunction, the routine mxCalloc is
                passed instead.

            void (*release) (size_t, size_t)

                A pointer to a function that frees memory allocated by the
                memory allocation routine above.  For a C application, this
                argument should normally be a pointer to free.  For a MATLAB
                mexFunction, the routine mxFree is passed instead.


    ----------------------------------------------------------------------------
    colamd_report:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            colamd_report (int stats [COLAMD_STATS]) ;
            colamd_l_report (UF_long stats [COLAMD_STATS]) ;

        Purpose:

            Prints the error status and statistics recorded in the stats
            array on the standard error output (for a standard C routine)
            or on the MATLAB output (for a mexFunction).

        Arguments:

            int stats [COLAMD_STATS] ;  Input only.  Statistics from colamd.


    ----------------------------------------------------------------------------
    symamd_report:
    ----------------------------------------------------------------------------

        C syntax:

            #include "colamd.h"
            symamd_report (int stats [COLAMD_STATS]) ;
            symamd_l_report (UF_long stats [COLAMD_STATS]) ;

        Purpose:

            Prints the error status and statistics recorded in the stats
            array on the standard error output (for a standard C routine)
            or on the MATLAB output (for a mexFunction).

        Arguments:

            int stats [COLAMD_STATS] ;  Input only.  Statistics from symamd.


*/

/* ========================================================================== */
/* === Scaffolding code definitions  ======================================== */
/* ========================================================================== */

/* Ensure that debugging is turned off: */
#ifndef NDEBUG
#define NDEBUG
#endif

/* turn on debugging by uncommenting the following line
 #undef NDEBUG
*/

/*
   Our "scaffolding code" philosophy:  In our opinion, well-written library
   code should keep its "debugging" code, and just normally have it turned off
   by the compiler so as not to interfere with performance.  This serves
   several purposes:

   (1) assertions act as comments to the reader, telling you what the code
        expects at that point.  All assertions will always be true (unless
        there really is a bug, of course).

   (2) leaving in the scaffolding code assists anyone who would like to modify
        the code, or understand the algorithm (by reading the debugging output,
        one can get a glimpse into what the code is doing).

   (3) (gasp!) for actually finding bugs.  This code has been heavily tested
        and "should" be fully functional and bug-free ... but you never know...

    The code will become outrageously slow when debugging is
    enabled.  To control the level of debugging output, set an environment
    variable D to 0 (little), 1 (some), 2, 3, or 4 (lots).  When debugging,
    you should see the following message on the standard output:

        colamd: debug version, D = 1 (THIS WILL BE SLOW!)

    or a similar message for symamd.  If you don't, then debugging has not
    been enabled.

*/

/* ========================================================================== */
/* === Include files ======================================================== */
/* ========================================================================== */

#include "colamd.h"

#if 0 /* by mao */
#include 
#include 

#ifdef MATLAB_MEX_FILE
#include "mex.h"
#include "matrix.h"
#endif /* MATLAB_MEX_FILE */

#if !defined (NPRINT) || !defined (NDEBUG)
#include 
#endif

#ifndef NULL
#define NULL ((void *) 0)
#endif
#endif

/* ========================================================================== */
/* === int or UF_long ======================================================= */
/* ========================================================================== */

#if 0 /* by mao */
/* define UF_long */
#include "UFconfig.h"
#endif

#ifdef DLONG

#define Int UF_long
#define ID  UF_long_id
#define Int_MAX UF_long_max

#define COLAMD_recommended colamd_l_recommended
#define COLAMD_set_defaults colamd_l_set_defaults
#define COLAMD_MAIN colamd_l
#define SYMAMD_MAIN symamd_l
#define COLAMD_report colamd_l_report
#define SYMAMD_report symamd_l_report

#else

#define Int int
#define ID "%d"
#define Int_MAX INT_MAX

#define COLAMD_recommended colamd_recommended
#define COLAMD_set_defaults colamd_set_defaults
#define COLAMD_MAIN colamd
#define SYMAMD_MAIN symamd
#define COLAMD_report colamd_report
#define SYMAMD_report symamd_report

#endif

/* ========================================================================== */
/* === Row and Column structures ============================================ */
/* ========================================================================== */

/* User code that makes use of the colamd/symamd routines need not directly */
/* reference these structures.  They are used only for colamd_recommended. */

typedef struct Colamd_Col_struct
{
    Int start ;         /* index for A of first row in this column, or DEAD */
                        /* if column is dead */
    Int length ;        /* number of rows in this column */
    union
    {
        Int thickness ; /* number of original columns represented by this */
                        /* col, if the column is alive */
        Int parent ;    /* parent in parent tree super-column structure, if */
                        /* the column is dead */
    } shared1 ;
    union
    {
        Int score ;     /* the score used to maintain heap, if col is alive */
        Int order ;     /* pivot ordering of this column, if col is dead */
    } shared2 ;
    union
    {
        Int headhash ;  /* head of a hash bucket, if col is at the head of */
                        /* a degree list */
        Int hash ;      /* hash value, if col is not in a degree list */
        Int prev ;      /* previous column in degree list, if col is in a */
                        /* degree list (but not at the head of a degree list) */
    } shared3 ;
    union
    {
        Int degree_next ;       /* next column, if col is in a degree list */
        Int hash_next ;         /* next column, if col is in a hash list */
    } shared4 ;

} Colamd_Col ;

typedef struct Colamd_Row_struct
{
    Int start ;         /* index for A of first col in this row */
    Int length ;        /* number of principal columns in this row */
    union
    {
        Int degree ;    /* number of principal & non-principal columns in row */
        Int p ;         /* used as a row pointer in init_rows_cols () */
    } shared1 ;
    union
    {
        Int mark ;      /* for computing set differences and marking dead rows*/
        Int first_column ;/* first column in row (used in garbage collection) */
    } shared2 ;

} Colamd_Row ;

/* ========================================================================== */
/* === Definitions ========================================================== */
/* ========================================================================== */

/* Routines are either PUBLIC (user-callable) or PRIVATE (not user-callable) */
#define PUBLIC
#define PRIVATE static

#define DENSE_DEGREE(alpha,n) \
    ((Int) MAX (16.0, (alpha) * sqrt ((double) (n))))

#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#define MIN(a,b) (((a) < (b)) ? (a) : (b))

#define ONES_COMPLEMENT(r) (-(r)-1)

/* -------------------------------------------------------------------------- */
/* Change for version 2.1:  define TRUE and FALSE only if not yet defined */
/* -------------------------------------------------------------------------- */

#ifndef TRUE
#define TRUE (1)
#endif

#ifndef FALSE
#define FALSE (0)
#endif

/* -------------------------------------------------------------------------- */

#define EMPTY   (-1)

/* Row and column status */
#define ALIVE   (0)
#define DEAD    (-1)

/* Column status */
#define DEAD_PRINCIPAL          (-1)
#define DEAD_NON_PRINCIPAL      (-2)

/* Macros for row and column status update and checking. */
#define ROW_IS_DEAD(r)                  ROW_IS_MARKED_DEAD (Row[r].shared2.mark)
#define ROW_IS_MARKED_DEAD(row_mark)    (row_mark < ALIVE)
#define ROW_IS_ALIVE(r)                 (Row [r].shared2.mark >= ALIVE)
#define COL_IS_DEAD(c)                  (Col [c].start < ALIVE)
#define COL_IS_ALIVE(c)                 (Col [c].start >= ALIVE)
#define COL_IS_DEAD_PRINCIPAL(c)        (Col [c].start == DEAD_PRINCIPAL)
#define KILL_ROW(r)                     { Row [r].shared2.mark = DEAD ; }
#define KILL_PRINCIPAL_COL(c)           { Col [c].start = DEAD_PRINCIPAL ; }
#define KILL_NON_PRINCIPAL_COL(c)       { Col [c].start = DEAD_NON_PRINCIPAL ; }

/* ========================================================================== */
/* === Colamd reporting mechanism =========================================== */
/* ========================================================================== */

#if defined (MATLAB_MEX_FILE) || defined (MATHWORKS)
/* In MATLAB, matrices are 1-based to the user, but 0-based internally */
#define INDEX(i) ((i)+1)
#else
/* In C, matrices are 0-based and indices are reported as such in *_report */
#define INDEX(i) (i)
#endif

/* All output goes through the PRINTF macro.  */
#define PRINTF(params) { if (colamd_printf != NULL) (void) colamd_printf params ; }

/* ========================================================================== */
/* === Prototypes of PRIVATE routines ======================================= */
/* ========================================================================== */

PRIVATE Int init_rows_cols
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int p [],
    Int stats [COLAMD_STATS]
) ;

PRIVATE void init_scoring
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int head [],
    double knobs [COLAMD_KNOBS],
    Int *p_n_row2,
    Int *p_n_col2,
    Int *p_max_deg
) ;

PRIVATE Int find_ordering
(
    Int n_row,
    Int n_col,
    Int Alen,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int head [],
    Int n_col2,
    Int max_deg,
    Int pfree,
    Int aggressive
) ;

PRIVATE void order_children
(
    Int n_col,
    Colamd_Col Col [],
    Int p []
) ;

PRIVATE void detect_super_cols
(

#ifndef NDEBUG
    Int n_col,
    Colamd_Row Row [],
#endif /* NDEBUG */

    Colamd_Col Col [],
    Int A [],
    Int head [],
    Int row_start,
    Int row_length
) ;

PRIVATE Int garbage_collection
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int *pfree
) ;

PRIVATE Int clear_mark
(
    Int tag_mark,
    Int max_mark,
    Int n_row,
    Colamd_Row Row []
) ;

PRIVATE void print_report
(
    char *method,
    Int stats [COLAMD_STATS]
) ;

/* ========================================================================== */
/* === Debugging prototypes and definitions ================================= */
/* ========================================================================== */

#ifndef NDEBUG

#if 0 /* by mao */
#include 
#endif

/* colamd_debug is the *ONLY* global variable, and is only */
/* present when debugging */

PRIVATE Int colamd_debug = 0 ;  /* debug print level */

#define DEBUG0(params) { PRINTF (params) ; }
#define DEBUG1(params) { if (colamd_debug >= 1) PRINTF (params) ; }
#define DEBUG2(params) { if (colamd_debug >= 2) PRINTF (params) ; }
#define DEBUG3(params) { if (colamd_debug >= 3) PRINTF (params) ; }
#define DEBUG4(params) { if (colamd_debug >= 4) PRINTF (params) ; }

#if 0 /* by mao */
#ifdef MATLAB_MEX_FILE
#define ASSERT(expression) (mxAssert ((expression), ""))
#else
#define ASSERT(expression) (assert (expression))
#endif /* MATLAB_MEX_FILE */
#else
#define ASSERT xassert
#endif

PRIVATE void colamd_get_debug   /* gets the debug print level from getenv */
(
    char *method
) ;

PRIVATE void debug_deg_lists
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int head [],
    Int min_score,
    Int should,
    Int max_deg
) ;

PRIVATE void debug_mark
(
    Int n_row,
    Colamd_Row Row [],
    Int tag_mark,
    Int max_mark
) ;

PRIVATE void debug_matrix
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A []
) ;

PRIVATE void debug_structures
(
    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int n_col2
) ;

#else /* NDEBUG */

/* === No debugging ========================================================= */

#define DEBUG0(params) ;
#define DEBUG1(params) ;
#define DEBUG2(params) ;
#define DEBUG3(params) ;
#define DEBUG4(params) ;

#define ASSERT(expression)

#endif /* NDEBUG */

/* ========================================================================== */
/* === USER-CALLABLE ROUTINES: ============================================== */
/* ========================================================================== */

/* ========================================================================== */
/* === colamd_recommended =================================================== */
/* ========================================================================== */

/*
    The colamd_recommended routine returns the suggested size for Alen.  This
    value has been determined to provide good balance between the number of
    garbage collections and the memory requirements for colamd.  If any
    argument is negative, or if integer overflow occurs, a 0 is returned as an
    error condition.  2*nnz space is required for the row and column
    indices of the matrix. COLAMD_C (n_col) + COLAMD_R (n_row) space is
    required for the Col and Row arrays, respectively, which are internal to
    colamd (roughly 6*n_col + 4*n_row).  An additional n_col space is the
    minimal amount of "elbow room", and nnz/5 more space is recommended for
    run time efficiency.

    Alen is approximately 2.2*nnz + 7*n_col + 4*n_row + 10.

    This function is not needed when using symamd.
*/

/* add two values of type size_t, and check for integer overflow */
static size_t t_add (size_t a, size_t b, int *ok)
{
    (*ok) = (*ok) && ((a + b) >= MAX (a,b)) ;
    return ((*ok) ? (a + b) : 0) ;
}

/* compute a*k where k is a small integer, and check for integer overflow */
static size_t t_mult (size_t a, size_t k, int *ok)
{
    size_t i, s = 0 ;
    for (i = 0 ; i < k ; i++)
    {
        s = t_add (s, a, ok) ;
    }
    return (s) ;
}

/* size of the Col and Row structures */
#define COLAMD_C(n_col,ok) \
    ((t_mult (t_add (n_col, 1, ok), sizeof (Colamd_Col), ok) / sizeof (Int)))

#define COLAMD_R(n_row,ok) \
    ((t_mult (t_add (n_row, 1, ok), sizeof (Colamd_Row), ok) / sizeof (Int)))


PUBLIC size_t COLAMD_recommended        /* returns recommended value of Alen. */
(
    /* === Parameters ======================================================= */

    Int nnz,                    /* number of nonzeros in A */
    Int n_row,                  /* number of rows in A */
    Int n_col                   /* number of columns in A */
)
{
    size_t s, c, r ;
    int ok = TRUE ;
    if (nnz < 0 || n_row < 0 || n_col < 0)
    {
        return (0) ;
    }
    s = t_mult (nnz, 2, &ok) ;      /* 2*nnz */
    c = COLAMD_C (n_col, &ok) ;     /* size of column structures */
    r = COLAMD_R (n_row, &ok) ;     /* size of row structures */
    s = t_add (s, c, &ok) ;
    s = t_add (s, r, &ok) ;
    s = t_add (s, n_col, &ok) ;     /* elbow room */
    s = t_add (s, nnz/5, &ok) ;     /* elbow room */
    ok = ok && (s < Int_MAX) ;
    return (ok ? s : 0) ;
}


/* ========================================================================== */
/* === colamd_set_defaults ================================================== */
/* ========================================================================== */

/*
    The colamd_set_defaults routine sets the default values of the user-
    controllable parameters for colamd and symamd:

        Colamd: rows with more than max (16, knobs [0] * sqrt (n_col))
        entries are removed prior to ordering.  Columns with more than
        max (16, knobs [1] * sqrt (MIN (n_row,n_col))) entries are removed
        prior to ordering, and placed last in the output column ordering.

        Symamd: Rows and columns with more than max (16, knobs [0] * sqrt (n))
        entries are removed prior to ordering, and placed last in the
        output ordering.

        knobs [0]       dense row control

        knobs [1]       dense column control

        knobs [2]       if nonzero, do aggresive absorption

        knobs [3..19]   unused, but future versions might use this

*/

PUBLIC void COLAMD_set_defaults
(
    /* === Parameters ======================================================= */

    double knobs [COLAMD_KNOBS]         /* knob array */
)
{
    /* === Local variables ================================================== */

    Int i ;

    if (!knobs)
    {
        return ;                        /* no knobs to initialize */
    }
    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        knobs [i] = 0 ;
    }
    knobs [COLAMD_DENSE_ROW] = 10 ;
    knobs [COLAMD_DENSE_COL] = 10 ;
    knobs [COLAMD_AGGRESSIVE] = TRUE ;  /* default: do aggressive absorption*/
}


/* ========================================================================== */
/* === symamd =============================================================== */
/* ========================================================================== */

PUBLIC Int SYMAMD_MAIN                  /* return TRUE if OK, FALSE otherwise */
(
    /* === Parameters ======================================================= */

    Int n,                              /* number of rows and columns of A */
    Int A [],                           /* row indices of A */
    Int p [],                           /* column pointers of A */
    Int perm [],                        /* output permutation, size n+1 */
    double knobs [COLAMD_KNOBS],        /* parameters (uses defaults if NULL) */
    Int stats [COLAMD_STATS],           /* output statistics and error codes */
    void * (*allocate) (size_t, size_t),
                                        /* pointer to calloc (ANSI C) or */
                                        /* mxCalloc (for MATLAB mexFunction) */
    void (*release) (void *)
                                        /* pointer to free (ANSI C) or */
                                        /* mxFree (for MATLAB mexFunction) */
)
{
    /* === Local variables ================================================== */

    Int *count ;                /* length of each column of M, and col pointer*/
    Int *mark ;                 /* mark array for finding duplicate entries */
    Int *M ;                    /* row indices of matrix M */
    size_t Mlen ;               /* length of M */
    Int n_row ;                 /* number of rows in M */
    Int nnz ;                   /* number of entries in A */
    Int i ;                     /* row index of A */
    Int j ;                     /* column index of A */
    Int k ;                     /* row index of M */
    Int mnz ;                   /* number of nonzeros in M */
    Int pp ;                    /* index into a column of A */
    Int last_row ;              /* last row seen in the current column */
    Int length ;                /* number of nonzeros in a column */

    double cknobs [COLAMD_KNOBS] ;              /* knobs for colamd */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs for colamd */

#ifndef NDEBUG
    colamd_get_debug ("symamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("symamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("symamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("symamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n < 0)          /* n must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n ;
        DEBUG0 (("symamd: n negative %d\n", n)) ;
        return (FALSE) ;
    }

    nnz = p [n] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("symamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("symamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        COLAMD_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    /* === Allocate count and mark ========================================== */

    count = (Int *) ((*allocate) (n+1, sizeof (Int))) ;
    if (!count)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        DEBUG0 (("symamd: allocate count (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    mark = (Int *) ((*allocate) (n+1, sizeof (Int))) ;
    if (!mark)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        DEBUG0 (("symamd: allocate mark (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    /* === Compute column counts of M, check if A is valid ================== */

    stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/

    for (i = 0 ; i < n ; i++)
    {
        mark [i] = -1 ;
    }

    for (j = 0 ; j < n ; j++)
    {
        last_row = -1 ;

        length = p [j+1] - p [j] ;
        if (length < 0)
        {
            /* column pointers must be non-decreasing */
            stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
            stats [COLAMD_INFO1] = j ;
            stats [COLAMD_INFO2] = length ;
            (*release) ((void *) count) ;
            (*release) ((void *) mark) ;
            DEBUG0 (("symamd: col %d negative length %d\n", j, length)) ;
            return (FALSE) ;
        }

        for (pp = p [j] ; pp < p [j+1] ; pp++)
        {
            i = A [pp] ;
            if (i < 0 || i >= n)
            {
                /* row index i, in column j, is out of bounds */
                stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                stats [COLAMD_INFO3] = n ;
                (*release) ((void *) count) ;
                (*release) ((void *) mark) ;
                DEBUG0 (("symamd: row %d col %d out of bounds\n", i, j)) ;
                return (FALSE) ;
            }

            if (i <= last_row || mark [i] == j)
            {
                /* row index is unsorted or repeated (or both), thus col */
                /* is jumbled.  This is a notice, not an error condition. */
                stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                (stats [COLAMD_INFO3]) ++ ;
                DEBUG1 (("symamd: row %d col %d unsorted/duplicate\n", i, j)) ;
            }

            if (i > j && mark [i] != j)
            {
                /* row k of M will contain column indices i and j */
                count [i]++ ;
                count [j]++ ;
            }

            /* mark the row as having been seen in this column */
            mark [i] = j ;

            last_row = i ;
        }
    }

    /* v2.4: removed free(mark) */

    /* === Compute column pointers of M ===================================== */

    /* use output permutation, perm, for column pointers of M */
    perm [0] = 0 ;
    for (j = 1 ; j <= n ; j++)
    {
        perm [j] = perm [j-1] + count [j-1] ;
    }
    for (j = 0 ; j < n ; j++)
    {
        count [j] = perm [j] ;
    }

    /* === Construct M ====================================================== */

    mnz = perm [n] ;
    n_row = mnz / 2 ;
    Mlen = COLAMD_recommended (mnz, n_row, n) ;
    M = (Int *) ((*allocate) (Mlen, sizeof (Int))) ;
    DEBUG0 (("symamd: M is %d-by-%d with %d entries, Mlen = %g\n",
        n_row, n, mnz, (double) Mlen)) ;

    if (!M)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        (*release) ((void *) mark) ;
        DEBUG0 (("symamd: allocate M (size %g) failed\n", (double) Mlen)) ;
        return (FALSE) ;
    }

    k = 0 ;

    if (stats [COLAMD_STATUS] == COLAMD_OK)
    {
        /* Matrix is OK */
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                }
            }
        }
    }
    else
    {
        /* Matrix is jumbled.  Do not add duplicates to M.  Unsorted cols OK. */
        DEBUG0 (("symamd: Duplicates in A.\n")) ;
        for (i = 0 ; i < n ; i++)
        {
            mark [i] = -1 ;
        }
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j && mark [i] != j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                    mark [i] = j ;
                }
            }
        }
        /* v2.4: free(mark) moved below */
    }

    /* count and mark no longer needed */
    (*release) ((void *) count) ;
    (*release) ((void *) mark) ;        /* v2.4: free (mark) moved here */
    ASSERT (k == n_row) ;

    /* === Adjust the knobs for M =========================================== */

    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        cknobs [i] = knobs [i] ;
    }

    /* there are no dense rows in M */
    cknobs [COLAMD_DENSE_ROW] = -1 ;
    cknobs [COLAMD_DENSE_COL] = knobs [COLAMD_DENSE_ROW] ;

    /* === Order the columns of M =========================================== */

    /* v2.4: colamd cannot fail here, so the error check is removed */
    (void) COLAMD_MAIN (n_row, n, (Int) Mlen, M, perm, cknobs, stats) ;

    /* Note that the output permutation is now in perm */

    /* === get the statistics for symamd from colamd ======================== */

    /* a dense column in colamd means a dense row and col in symamd */
    stats [COLAMD_DENSE_ROW] = stats [COLAMD_DENSE_COL] ;

    /* === Free M =========================================================== */

    (*release) ((void *) M) ;
    DEBUG0 (("symamd: done.\n")) ;
    return (TRUE) ;

}

/* ========================================================================== */
/* === colamd =============================================================== */
/* ========================================================================== */

/*
    The colamd routine computes a column ordering Q of a sparse matrix
    A such that the LU factorization P(AQ) = LU remains sparse, where P is
    selected via partial pivoting.   The routine can also be viewed as
    providing a permutation Q such that the Cholesky factorization
    (AQ)'(AQ) = LL' remains sparse.
*/

PUBLIC Int COLAMD_MAIN          /* returns TRUE if successful, FALSE otherwise*/
(
    /* === Parameters ======================================================= */

    Int n_row,                  /* number of rows in A */
    Int n_col,                  /* number of columns in A */
    Int Alen,                   /* length of A */
    Int A [],                   /* row indices of A */
    Int p [],                   /* pointers to columns in A */
    double knobs [COLAMD_KNOBS],/* parameters (uses defaults if NULL) */
    Int stats [COLAMD_STATS]    /* output statistics and error codes */
)
{
    /* === Local variables ================================================== */

    Int i ;                     /* loop index */
    Int nnz ;                   /* nonzeros in A */
    size_t Row_size ;           /* size of Row [], in integers */
    size_t Col_size ;           /* size of Col [], in integers */
    size_t need ;               /* minimum required length of A */
    Colamd_Row *Row ;           /* pointer into A of Row [0..n_row] array */
    Colamd_Col *Col ;           /* pointer into A of Col [0..n_col] array */
    Int n_col2 ;                /* number of non-dense, non-empty columns */
    Int n_row2 ;                /* number of non-dense, non-empty rows */
    Int ngarbage ;              /* number of garbage collections performed */
    Int max_deg ;               /* maximum row degree */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs array */
    Int aggressive ;            /* do aggressive absorption */
    int ok ;

#ifndef NDEBUG
    colamd_get_debug ("colamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("colamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)             /* A is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("colamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("colamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n_row < 0)      /* n_row must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nrow_negative ;
        stats [COLAMD_INFO1] = n_row ;
        DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
        return (FALSE) ;
    }

    if (n_col < 0)      /* n_col must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n_col ;
        DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
        return (FALSE) ;
    }

    nnz = p [n_col] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        COLAMD_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    aggressive = (knobs [COLAMD_AGGRESSIVE] != FALSE) ;

    /* === Allocate the Row and Col arrays from array A ===================== */

    ok = TRUE ;
    Col_size = COLAMD_C (n_col, &ok) ;      /* size of Col array of structs */
    Row_size = COLAMD_R (n_row, &ok) ;      /* size of Row array of structs */

    /* need = 2*nnz + n_col + Col_size + Row_size ; */
    need = t_mult (nnz, 2, &ok) ;
    need = t_add (need, n_col, &ok) ;
    need = t_add (need, Col_size, &ok) ;
    need = t_add (need, Row_size, &ok) ;

    if (!ok || need > (size_t) Alen || need > Int_MAX)
    {
        /* not enough space in array A to perform the ordering */
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_too_small ;
        stats [COLAMD_INFO1] = need ;
        stats [COLAMD_INFO2] = Alen ;
        DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
        return (FALSE) ;
    }

    Alen -= Col_size + Row_size ;
    Col = (Colamd_Col *) &A [Alen] ;
    Row = (Colamd_Row *) &A [Alen + Col_size] ;

    /* === Construct the row and column data structures ===================== */

    if (!init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
    {
        /* input matrix is invalid */
        DEBUG0 (("colamd: Matrix invalid\n")) ;
        return (FALSE) ;
    }

    /* === Initialize scores, kill dense rows/columns ======================= */

    init_scoring (n_row, n_col, Row, Col, A, p, knobs,
        &n_row2, &n_col2, &max_deg) ;

    /* === Order the supercolumns =========================================== */

    ngarbage = find_ordering (n_row, n_col, Alen, Row, Col, A, p,
        n_col2, max_deg, 2*nnz, aggressive) ;

    /* === Order the non-principal columns ================================== */

    order_children (n_col, Col, p) ;

    /* === Return statistics in stats ======================================= */

    stats [COLAMD_DENSE_ROW] = n_row - n_row2 ;
    stats [COLAMD_DENSE_COL] = n_col - n_col2 ;
    stats [COLAMD_DEFRAG_COUNT] = ngarbage ;
    DEBUG0 (("colamd: done.\n")) ;
    return (TRUE) ;
}


/* ========================================================================== */
/* === colamd_report ======================================================== */
/* ========================================================================== */

PUBLIC void COLAMD_report
(
    Int stats [COLAMD_STATS]
)
{
    print_report ("colamd", stats) ;
}


/* ========================================================================== */
/* === symamd_report ======================================================== */
/* ========================================================================== */

PUBLIC void SYMAMD_report
(
    Int stats [COLAMD_STATS]
)
{
    print_report ("symamd", stats) ;
}



/* ========================================================================== */
/* === NON-USER-CALLABLE ROUTINES: ========================================== */
/* ========================================================================== */

/* There are no user-callable routines beyond this point in the file */


/* ========================================================================== */
/* === init_rows_cols ======================================================= */
/* ========================================================================== */

/*
    Takes the column form of the matrix in A and creates the row form of the
    matrix.  Also, row and column attributes are stored in the Col and Row
    structs.  If the columns are un-sorted or contain duplicate row indices,
    this routine will also sort and remove duplicate row indices from the
    column form of the matrix.  Returns FALSE if the matrix is invalid,
    TRUE otherwise.  Not user-callable.
*/

PRIVATE Int init_rows_cols      /* returns TRUE if OK, or FALSE otherwise */
(
    /* === Parameters ======================================================= */

    Int n_row,                  /* number of rows of A */
    Int n_col,                  /* number of columns of A */
    Colamd_Row Row [],          /* of size n_row+1 */
    Colamd_Col Col [],          /* of size n_col+1 */
    Int A [],                   /* row indices of A, of size Alen */
    Int p [],                   /* pointers to columns in A, of size n_col+1 */
    Int stats [COLAMD_STATS]    /* colamd statistics */
)
{
    /* === Local variables ================================================== */

    Int col ;                   /* a column index */
    Int row ;                   /* a row index */
    Int *cp ;                   /* a column pointer */
    Int *cp_end ;               /* a pointer to the end of a column */
    Int *rp ;                   /* a row pointer */
    Int *rp_end ;               /* a pointer to the end of a row */
    Int last_row ;              /* previous row */

    /* === Initialize columns, and check column pointers ==================== */

    for (col = 0 ; col < n_col ; col++)
    {
        Col [col].start = p [col] ;
        Col [col].length = p [col+1] - p [col] ;

        if (Col [col].length < 0)
        {
            /* column pointers must be non-decreasing */
            stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
            stats [COLAMD_INFO1] = col ;
            stats [COLAMD_INFO2] = Col [col].length ;
            DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
            return (FALSE) ;
        }

        Col [col].shared1.thickness = 1 ;
        Col [col].shared2.score = 0 ;
        Col [col].shared3.prev = EMPTY ;
        Col [col].shared4.degree_next = EMPTY ;
    }

    /* p [0..n_col] no longer needed, used as "head" in subsequent routines */

    /* === Scan columns, compute row degrees, and check row indices ========= */

    stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/

    for (row = 0 ; row < n_row ; row++)
    {
        Row [row].length = 0 ;
        Row [row].shared2.mark = -1 ;
    }

    for (col = 0 ; col < n_col ; col++)
    {
        last_row = -1 ;

        cp = &A [p [col]] ;
        cp_end = &A [p [col+1]] ;

        while (cp < cp_end)
        {
            row = *cp++ ;

            /* make sure row indices within range */
            if (row < 0 || row >= n_row)
            {
                stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
                stats [COLAMD_INFO1] = col ;
                stats [COLAMD_INFO2] = row ;
                stats [COLAMD_INFO3] = n_row ;
                DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
                return (FALSE) ;
            }

            if (row <= last_row || Row [row].shared2.mark == col)
            {
                /* row index are unsorted or repeated (or both), thus col */
                /* is jumbled.  This is a notice, not an error condition. */
                stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
                stats [COLAMD_INFO1] = col ;
                stats [COLAMD_INFO2] = row ;
                (stats [COLAMD_INFO3]) ++ ;
                DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
            }

            if (Row [row].shared2.mark != col)
            {
                Row [row].length++ ;
            }
            else
            {
                /* this is a repeated entry in the column, */
                /* it will be removed */
                Col [col].length-- ;
            }

            /* mark the row as having been seen in this column */
            Row [row].shared2.mark = col ;

            last_row = row ;
        }
    }

    /* === Compute row pointers ============================================= */

    /* row form of the matrix starts directly after the column */
    /* form of matrix in A */
    Row [0].start = p [n_col] ;
    Row [0].shared1.p = Row [0].start ;
    Row [0].shared2.mark = -1 ;
    for (row = 1 ; row < n_row ; row++)
    {
        Row [row].start = Row [row-1].start + Row [row-1].length ;
        Row [row].shared1.p = Row [row].start ;
        Row [row].shared2.mark = -1 ;
    }

    /* === Create row form ================================================== */

    if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
    {
        /* if cols jumbled, watch for repeated row indices */
        for (col = 0 ; col < n_col ; col++)
        {
            cp = &A [p [col]] ;
            cp_end = &A [p [col+1]] ;
            while (cp < cp_end)
            {
                row = *cp++ ;
                if (Row [row].shared2.mark != col)
                {
                    A [(Row [row].shared1.p)++] = col ;
                    Row [row].shared2.mark = col ;
                }
            }
        }
    }
    else
    {
        /* if cols not jumbled, we don't need the mark (this is faster) */
        for (col = 0 ; col < n_col ; col++)
        {
            cp = &A [p [col]] ;
            cp_end = &A [p [col+1]] ;
            while (cp < cp_end)
            {
                A [(Row [*cp++].shared1.p)++] = col ;
            }
        }
    }

    /* === Clear the row marks and set row degrees ========================== */

    for (row = 0 ; row < n_row ; row++)
    {
        Row [row].shared2.mark = 0 ;
        Row [row].shared1.degree = Row [row].length ;
    }

    /* === See if we need to re-create columns ============================== */

    if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
    {
        DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;

#ifndef NDEBUG
        /* make sure column lengths are correct */
        for (col = 0 ; col < n_col ; col++)
        {
            p [col] = Col [col].length ;
        }
        for (row = 0 ; row < n_row ; row++)
        {
            rp = &A [Row [row].start] ;
            rp_end = rp + Row [row].length ;
            while (rp < rp_end)
            {
                p [*rp++]-- ;
            }
        }
        for (col = 0 ; col < n_col ; col++)
        {
            ASSERT (p [col] == 0) ;
        }
        /* now p is all zero (different than when debugging is turned off) */
#endif /* NDEBUG */

        /* === Compute col pointers ========================================= */

        /* col form of the matrix starts at A [0]. */
        /* Note, we may have a gap between the col form and the row */
        /* form if there were duplicate entries, if so, it will be */
        /* removed upon the first garbage collection */
        Col [0].start = 0 ;
        p [0] = Col [0].start ;
        for (col = 1 ; col < n_col ; col++)
        {
            /* note that the lengths here are for pruned columns, i.e. */
            /* no duplicate row indices will exist for these columns */
            Col [col].start = Col [col-1].start + Col [col-1].length ;
            p [col] = Col [col].start ;
        }

        /* === Re-create col form =========================================== */

        for (row = 0 ; row < n_row ; row++)
        {
            rp = &A [Row [row].start] ;
            rp_end = rp + Row [row].length ;
            while (rp < rp_end)
            {
                A [(p [*rp++])++] = row ;
            }
        }
    }

    /* === Done.  Matrix is not (or no longer) jumbled ====================== */

    return (TRUE) ;
}


/* ========================================================================== */
/* === init_scoring ========================================================= */
/* ========================================================================== */

/*
    Kills dense or empty columns and rows, calculates an initial score for
    each column, and places all columns in the degree lists.  Not user-callable.
*/

PRIVATE void init_scoring
(
    /* === Parameters ======================================================= */

    Int n_row,                  /* number of rows of A */
    Int n_col,                  /* number of columns of A */
    Colamd_Row Row [],          /* of size n_row+1 */
    Colamd_Col Col [],          /* of size n_col+1 */
    Int A [],                   /* column form and row form of A */
    Int head [],                /* of size n_col+1 */
    double knobs [COLAMD_KNOBS],/* parameters */
    Int *p_n_row2,              /* number of non-dense, non-empty rows */
    Int *p_n_col2,              /* number of non-dense, non-empty columns */
    Int *p_max_deg              /* maximum row degree */
)
{
    /* === Local variables ================================================== */

    Int c ;                     /* a column index */
    Int r, row ;                /* a row index */
    Int *cp ;                   /* a column pointer */
    Int deg ;                   /* degree of a row or column */
    Int *cp_end ;               /* a pointer to the end of a column */
    Int *new_cp ;               /* new column pointer */
    Int col_length ;            /* length of pruned column */
    Int score ;                 /* current column score */
    Int n_col2 ;                /* number of non-dense, non-empty columns */
    Int n_row2 ;                /* number of non-dense, non-empty rows */
    Int dense_row_count ;       /* remove rows with more entries than this */
    Int dense_col_count ;       /* remove cols with more entries than this */
    Int min_score ;             /* smallest column score */
    Int max_deg ;               /* maximum row degree */
    Int next_col ;              /* Used to add to degree list.*/

#ifndef NDEBUG
    Int debug_count ;           /* debug only. */
#endif /* NDEBUG */

    /* === Extract knobs ==================================================== */

    /* Note: if knobs contains a NaN, this is undefined: */
    if (knobs [COLAMD_DENSE_ROW] < 0)
    {
        /* only remove completely dense rows */
        dense_row_count = n_col-1 ;
    }
    else
    {
        dense_row_count = DENSE_DEGREE (knobs [COLAMD_DENSE_ROW], n_col) ;
    }
    if (knobs [COLAMD_DENSE_COL] < 0)
    {
        /* only remove completely dense columns */
        dense_col_count = n_row-1 ;
    }
    else
    {
        dense_col_count =
            DENSE_DEGREE (knobs [COLAMD_DENSE_COL], MIN (n_row, n_col)) ;
    }

    DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
    max_deg = 0 ;
    n_col2 = n_col ;
    n_row2 = n_row ;

    /* === Kill empty columns =============================================== */

    /* Put the empty columns at the end in their natural order, so that LU */
    /* factorization can proceed as far as possible. */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        deg = Col [c].length ;
        if (deg == 0)
        {
            /* this is a empty column, kill and order it last */
            Col [c].shared2.order = --n_col2 ;
            KILL_PRINCIPAL_COL (c) ;
        }
    }
    DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;

    /* === Kill dense columns =============================================== */

    /* Put the dense columns at the end, in their natural order */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* skip any dead columns */
        if (COL_IS_DEAD (c))
        {
            continue ;
        }
        deg = Col [c].length ;
        if (deg > dense_col_count)
        {
            /* this is a dense column, kill and order it last */
            Col [c].shared2.order = --n_col2 ;
            /* decrement the row degrees */
            cp = &A [Col [c].start] ;
            cp_end = cp + Col [c].length ;
            while (cp < cp_end)
            {
                Row [*cp++].shared1.degree-- ;
            }
            KILL_PRINCIPAL_COL (c) ;
        }
    }
    DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;

    /* === Kill dense and empty rows ======================================== */

    for (r = 0 ; r < n_row ; r++)
    {
        deg = Row [r].shared1.degree ;
        ASSERT (deg >= 0 && deg <= n_col) ;
        if (deg > dense_row_count || deg == 0)
        {
            /* kill a dense or empty row */
            KILL_ROW (r) ;
            --n_row2 ;
        }
        else
        {
            /* keep track of max degree of remaining rows */
            max_deg = MAX (max_deg, deg) ;
        }
    }
    DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;

    /* === Compute initial column scores ==================================== */

    /* At this point the row degrees are accurate.  They reflect the number */
    /* of "live" (non-dense) columns in each row.  No empty rows exist. */
    /* Some "live" columns may contain only dead rows, however.  These are */
    /* pruned in the code below. */

    /* now find the initial matlab score for each column */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* skip dead column */
        if (COL_IS_DEAD (c))
        {
            continue ;
        }
        score = 0 ;
        cp = &A [Col [c].start] ;
        new_cp = cp ;
        cp_end = cp + Col [c].length ;
        while (cp < cp_end)
        {
            /* get a row */
            row = *cp++ ;
            /* skip if dead */
            if (ROW_IS_DEAD (row))
            {
                continue ;
            }
            /* compact the column */
            *new_cp++ = row ;
            /* add row's external degree */
            score += Row [row].shared1.degree - 1 ;
            /* guard against integer overflow */
            score = MIN (score, n_col) ;
        }
        /* determine pruned column length */
        col_length = (Int) (new_cp - &A [Col [c].start]) ;
        if (col_length == 0)
        {
            /* a newly-made null column (all rows in this col are "dense" */
            /* and have already been killed) */
            DEBUG2 (("Newly null killed: %d\n", c)) ;
            Col [c].shared2.order = --n_col2 ;
            KILL_PRINCIPAL_COL (c) ;
        }
        else
        {
            /* set column length and set score */
            ASSERT (score >= 0) ;
            ASSERT (score <= n_col) ;
            Col [c].length = col_length ;
            Col [c].shared2.score = score ;
        }
    }
    DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
        n_col-n_col2)) ;

    /* At this point, all empty rows and columns are dead.  All live columns */
    /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
    /* yet).  Rows may contain dead columns, but all live rows contain at */
    /* least one live column. */

#ifndef NDEBUG
    debug_structures (n_row, n_col, Row, Col, A, n_col2) ;
#endif /* NDEBUG */

    /* === Initialize degree lists ========================================== */

#ifndef NDEBUG
    debug_count = 0 ;
#endif /* NDEBUG */

    /* clear the hash buckets */
    for (c = 0 ; c <= n_col ; c++)
    {
        head [c] = EMPTY ;
    }
    min_score = n_col ;
    /* place in reverse order, so low column indices are at the front */
    /* of the lists.  This is to encourage natural tie-breaking */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* only add principal columns to degree lists */
        if (COL_IS_ALIVE (c))
        {
            DEBUG4 (("place %d score %d minscore %d ncol %d\n",
                c, Col [c].shared2.score, min_score, n_col)) ;

            /* === Add columns score to DList =============================== */

            score = Col [c].shared2.score ;

            ASSERT (min_score >= 0) ;
            ASSERT (min_score <= n_col) ;
            ASSERT (score >= 0) ;
            ASSERT (score <= n_col) ;
            ASSERT (head [score] >= EMPTY) ;

            /* now add this column to dList at proper score location */
            next_col = head [score] ;
            Col [c].shared3.prev = EMPTY ;
            Col [c].shared4.degree_next = next_col ;

            /* if there already was a column with the same score, set its */
            /* previous pointer to this new column */
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = c ;
            }
            head [score] = c ;

            /* see if this score is less than current min */
            min_score = MIN (min_score, score) ;

#ifndef NDEBUG
            debug_count++ ;
#endif /* NDEBUG */

        }
    }

#ifndef NDEBUG
    DEBUG1 (("colamd: Live cols %d out of %d, non-princ: %d\n",
        debug_count, n_col, n_col-debug_count)) ;
    ASSERT (debug_count == n_col2) ;
    debug_deg_lists (n_row, n_col, Row, Col, head, min_score, n_col2, max_deg) ;
#endif /* NDEBUG */

    /* === Return number of remaining columns, and max row degree =========== */

    *p_n_col2 = n_col2 ;
    *p_n_row2 = n_row2 ;
    *p_max_deg = max_deg ;
}


/* ========================================================================== */
/* === find_ordering ======================================================== */
/* ========================================================================== */

/*
    Order the principal columns of the supercolumn form of the matrix
    (no supercolumns on input).  Uses a minimum approximate column minimum
    degree ordering method.  Not user-callable.
*/

PRIVATE Int find_ordering       /* return the number of garbage collections */
(
    /* === Parameters ======================================================= */

    Int n_row,                  /* number of rows of A */
    Int n_col,                  /* number of columns of A */
    Int Alen,                   /* size of A, 2*nnz + n_col or larger */
    Colamd_Row Row [],          /* of size n_row+1 */
    Colamd_Col Col [],          /* of size n_col+1 */
    Int A [],                   /* column form and row form of A */
    Int head [],                /* of size n_col+1 */
    Int n_col2,                 /* Remaining columns to order */
    Int max_deg,                /* Maximum row degree */
    Int pfree,                  /* index of first free slot (2*nnz on entry) */
    Int aggressive
)
{
    /* === Local variables ================================================== */

    Int k ;                     /* current pivot ordering step */
    Int pivot_col ;             /* current pivot column */
    Int *cp ;                   /* a column pointer */
    Int *rp ;                   /* a row pointer */
    Int pivot_row ;             /* current pivot row */
    Int *new_cp ;               /* modified column pointer */
    Int *new_rp ;               /* modified row pointer */
    Int pivot_row_start ;       /* pointer to start of pivot row */
    Int pivot_row_degree ;      /* number of columns in pivot row */
    Int pivot_row_length ;      /* number of supercolumns in pivot row */
    Int pivot_col_score ;       /* score of pivot column */
    Int needed_memory ;         /* free space needed for pivot row */
    Int *cp_end ;               /* pointer to the end of a column */
    Int *rp_end ;               /* pointer to the end of a row */
    Int row ;                   /* a row index */
    Int col ;                   /* a column index */
    Int max_score ;             /* maximum possible score */
    Int cur_score ;             /* score of current column */
    unsigned Int hash ;         /* hash value for supernode detection */
    Int head_column ;           /* head of hash bucket */
    Int first_col ;             /* first column in hash bucket */
    Int tag_mark ;              /* marker value for mark array */
    Int row_mark ;              /* Row [row].shared2.mark */
    Int set_difference ;        /* set difference size of row with pivot row */
    Int min_score ;             /* smallest column score */
    Int col_thickness ;         /* "thickness" (no. of columns in a supercol) */
    Int max_mark ;              /* maximum value of tag_mark */
    Int pivot_col_thickness ;   /* number of columns represented by pivot col */
    Int prev_col ;              /* Used by Dlist operations. */
    Int next_col ;              /* Used by Dlist operations. */
    Int ngarbage ;              /* number of garbage collections performed */

#ifndef NDEBUG
    Int debug_d ;               /* debug loop counter */
    Int debug_step = 0 ;        /* debug loop counter */
#endif /* NDEBUG */

    /* === Initialization and clear mark ==================================== */

    max_mark = INT_MAX - n_col ;        /* INT_MAX defined in  */
    tag_mark = clear_mark (0, max_mark, n_row, Row) ;
    min_score = 0 ;
    ngarbage = 0 ;
    DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;

    /* === Order the columns ================================================ */

    for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
    {

#ifndef NDEBUG
        if (debug_step % 100 == 0)
        {
            DEBUG2 (("\n...       Step k: %d out of n_col2: %d\n", k, n_col2)) ;
        }
        else
        {
            DEBUG3 (("\n----------Step k: %d out of n_col2: %d\n", k, n_col2)) ;
        }
        debug_step++ ;
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k, max_deg) ;
        debug_matrix (n_row, n_col, Row, Col, A) ;
#endif /* NDEBUG */

        /* === Select pivot column, and order it ============================ */

        /* make sure degree list isn't empty */
        ASSERT (min_score >= 0) ;
        ASSERT (min_score <= n_col) ;
        ASSERT (head [min_score] >= EMPTY) ;

#ifndef NDEBUG
        for (debug_d = 0 ; debug_d < min_score ; debug_d++)
        {
            ASSERT (head [debug_d] == EMPTY) ;
        }
#endif /* NDEBUG */

        /* get pivot column from head of minimum degree list */
        while (head [min_score] == EMPTY && min_score < n_col)
        {
            min_score++ ;
        }
        pivot_col = head [min_score] ;
        ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
        next_col = Col [pivot_col].shared4.degree_next ;
        head [min_score] = next_col ;
        if (next_col != EMPTY)
        {
            Col [next_col].shared3.prev = EMPTY ;
        }

        ASSERT (COL_IS_ALIVE (pivot_col)) ;

        /* remember score for defrag check */
        pivot_col_score = Col [pivot_col].shared2.score ;

        /* the pivot column is the kth column in the pivot order */
        Col [pivot_col].shared2.order = k ;

        /* increment order count by column thickness */
        pivot_col_thickness = Col [pivot_col].shared1.thickness ;
        k += pivot_col_thickness ;
        ASSERT (pivot_col_thickness > 0) ;
        DEBUG3 (("Pivot col: %d thick %d\n", pivot_col, pivot_col_thickness)) ;

        /* === Garbage_collection, if necessary ============================= */

        needed_memory = MIN (pivot_col_score, n_col - k) ;
        if (pfree + needed_memory >= Alen)
        {
            pfree = garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
            ngarbage++ ;
            /* after garbage collection we will have enough */
            ASSERT (pfree + needed_memory < Alen) ;
            /* garbage collection has wiped out the Row[].shared2.mark array */
            tag_mark = clear_mark (0, max_mark, n_row, Row) ;

#ifndef NDEBUG
            debug_matrix (n_row, n_col, Row, Col, A) ;
#endif /* NDEBUG */
        }

        /* === Compute pivot row pattern ==================================== */

        /* get starting location for this new merged row */
        pivot_row_start = pfree ;

        /* initialize new row counts to zero */
        pivot_row_degree = 0 ;

        /* tag pivot column as having been visited so it isn't included */
        /* in merged pivot row */
        Col [pivot_col].shared1.thickness = -pivot_col_thickness ;

        /* pivot row is the union of all rows in the pivot column pattern */
        cp = &A [Col [pivot_col].start] ;
        cp_end = cp + Col [pivot_col].length ;
        while (cp < cp_end)
        {
            /* get a row */
            row = *cp++ ;
            DEBUG4 (("Pivot col pattern %d %d\n", ROW_IS_ALIVE (row), row)) ;
            /* skip if row is dead */
            if (ROW_IS_ALIVE (row))
            {
                rp = &A [Row [row].start] ;
                rp_end = rp + Row [row].length ;
                while (rp < rp_end)
                {
                    /* get a column */
                    col = *rp++ ;
                    /* add the column, if alive and untagged */
                    col_thickness = Col [col].shared1.thickness ;
                    if (col_thickness > 0 && COL_IS_ALIVE (col))
                    {
                        /* tag column in pivot row */
                        Col [col].shared1.thickness = -col_thickness ;
                        ASSERT (pfree < Alen) ;
                        /* place column in pivot row */
                        A [pfree++] = col ;
                        pivot_row_degree += col_thickness ;
                    }
                }
            }
        }

        /* clear tag on pivot column */
        Col [pivot_col].shared1.thickness = pivot_col_thickness ;
        max_deg = MAX (max_deg, pivot_row_degree) ;

#ifndef NDEBUG
        DEBUG3 (("check2\n")) ;
        debug_mark (n_row, Row, tag_mark, max_mark) ;
#endif /* NDEBUG */

        /* === Kill all rows used to construct pivot row ==================== */

        /* also kill pivot row, temporarily */
        cp = &A [Col [pivot_col].start] ;
        cp_end = cp + Col [pivot_col].length ;
        while (cp < cp_end)
        {
            /* may be killing an already dead row */
            row = *cp++ ;
            DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
            KILL_ROW (row) ;
        }

        /* === Select a row index to use as the new pivot row =============== */

        pivot_row_length = pfree - pivot_row_start ;
        if (pivot_row_length > 0)
        {
            /* pick the "pivot" row arbitrarily (first row in col) */
            pivot_row = A [Col [pivot_col].start] ;
            DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
        }
        else
        {
            /* there is no pivot row, since it is of zero length */
            pivot_row = EMPTY ;
            ASSERT (pivot_row_length == 0) ;
        }
        ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;

        /* === Approximate degree computation =============================== */

        /* Here begins the computation of the approximate degree.  The column */
        /* score is the sum of the pivot row "length", plus the size of the */
        /* set differences of each row in the column minus the pattern of the */
        /* pivot row itself.  The column ("thickness") itself is also */
        /* excluded from the column score (we thus use an approximate */
        /* external degree). */

        /* The time taken by the following code (compute set differences, and */
        /* add them up) is proportional to the size of the data structure */
        /* being scanned - that is, the sum of the sizes of each column in */
        /* the pivot row.  Thus, the amortized time to compute a column score */
        /* is proportional to the size of that column (where size, in this */
        /* context, is the column "length", or the number of row indices */
        /* in that column).  The number of row indices in a column is */
        /* monotonically non-decreasing, from the length of the original */
        /* column on input to colamd. */

        /* === Compute set differences ====================================== */

        DEBUG3 (("** Computing set differences phase. **\n")) ;

        /* pivot row is currently dead - it will be revived later. */

        DEBUG3 (("Pivot row: ")) ;
        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            col = *rp++ ;
            ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
            DEBUG3 (("Col: %d\n", col)) ;

            /* clear tags used to construct pivot row pattern */
            col_thickness = -Col [col].shared1.thickness ;
            ASSERT (col_thickness > 0) ;
            Col [col].shared1.thickness = col_thickness ;

            /* === Remove column from degree list =========================== */

            cur_score = Col [col].shared2.score ;
            prev_col = Col [col].shared3.prev ;
            next_col = Col [col].shared4.degree_next ;
            ASSERT (cur_score >= 0) ;
            ASSERT (cur_score <= n_col) ;
            ASSERT (cur_score >= EMPTY) ;
            if (prev_col == EMPTY)
            {
                head [cur_score] = next_col ;
            }
            else
            {
                Col [prev_col].shared4.degree_next = next_col ;
            }
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = prev_col ;
            }

            /* === Scan the column ========================================== */

            cp = &A [Col [col].start] ;
            cp_end = cp + Col [col].length ;
            while (cp < cp_end)
            {
                /* get a row */
                row = *cp++ ;
                row_mark = Row [row].shared2.mark ;
                /* skip if dead */
                if (ROW_IS_MARKED_DEAD (row_mark))
                {
                    continue ;
                }
                ASSERT (row != pivot_row) ;
                set_difference = row_mark - tag_mark ;
                /* check if the row has been seen yet */
                if (set_difference < 0)
                {
                    ASSERT (Row [row].shared1.degree <= max_deg) ;
                    set_difference = Row [row].shared1.degree ;
                }
                /* subtract column thickness from this row's set difference */
                set_difference -= col_thickness ;
                ASSERT (set_difference >= 0) ;
                /* absorb this row if the set difference becomes zero */
                if (set_difference == 0 && aggressive)
                {
                    DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
                    KILL_ROW (row) ;
                }
                else
                {
                    /* save the new mark */
                    Row [row].shared2.mark = set_difference + tag_mark ;
                }
            }
        }

#ifndef NDEBUG
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k-pivot_row_degree, max_deg) ;
#endif /* NDEBUG */

        /* === Add up set differences for each column ======================= */

        DEBUG3 (("** Adding set differences phase. **\n")) ;

        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            /* get a column */
            col = *rp++ ;
            ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
            hash = 0 ;
            cur_score = 0 ;
            cp = &A [Col [col].start] ;
            /* compact the column */
            new_cp = cp ;
            cp_end = cp + Col [col].length ;

            DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;

            while (cp < cp_end)
            {
                /* get a row */
                row = *cp++ ;
                ASSERT(row >= 0 && row < n_row) ;
                row_mark = Row [row].shared2.mark ;
                /* skip if dead */
                if (ROW_IS_MARKED_DEAD (row_mark))
                {
                    DEBUG4 ((" Row %d, dead\n", row)) ;
                    continue ;
                }
                DEBUG4 ((" Row %d, set diff %d\n", row, row_mark-tag_mark));
                ASSERT (row_mark >= tag_mark) ;
                /* compact the column */
                *new_cp++ = row ;
                /* compute hash function */
                hash += row ;
                /* add set difference */
                cur_score += row_mark - tag_mark ;
                /* integer overflow... */
                cur_score = MIN (cur_score, n_col) ;
            }

            /* recompute the column's length */
            Col [col].length = (Int) (new_cp - &A [Col [col].start]) ;

            /* === Further mass elimination ================================= */

            if (Col [col].length == 0)
            {
                DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
                /* nothing left but the pivot row in this column */
                KILL_PRINCIPAL_COL (col) ;
                pivot_row_degree -= Col [col].shared1.thickness ;
                ASSERT (pivot_row_degree >= 0) ;
                /* order it */
                Col [col].shared2.order = k ;
                /* increment order count by column thickness */
                k += Col [col].shared1.thickness ;
            }
            else
            {
                /* === Prepare for supercolumn detection ==================== */

                DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;

                /* save score so far */
                Col [col].shared2.score = cur_score ;

                /* add column to hash table, for supercolumn detection */
                hash %= n_col + 1 ;

                DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
                ASSERT (((Int) hash) <= n_col) ;

                head_column = head [hash] ;
                if (head_column > EMPTY)
                {
                    /* degree list "hash" is non-empty, use prev (shared3) of */
                    /* first column in degree list as head of hash bucket */
                    first_col = Col [head_column].shared3.headhash ;
                    Col [head_column].shared3.headhash = col ;
                }
                else
                {
                    /* degree list "hash" is empty, use head as hash bucket */
                    first_col = - (head_column + 2) ;
                    head [hash] = - (col + 2) ;
                }
                Col [col].shared4.hash_next = first_col ;

                /* save hash function in Col [col].shared3.hash */
                Col [col].shared3.hash = (Int) hash ;
                ASSERT (COL_IS_ALIVE (col)) ;
            }
        }

        /* The approximate external column degree is now computed.  */

        /* === Supercolumn detection ======================================== */

        DEBUG3 (("** Supercolumn detection phase. **\n")) ;

        detect_super_cols (

#ifndef NDEBUG
                n_col, Row,
#endif /* NDEBUG */

                Col, A, head, pivot_row_start, pivot_row_length) ;

        /* === Kill the pivotal column ====================================== */

        KILL_PRINCIPAL_COL (pivot_col) ;

        /* === Clear mark =================================================== */

        tag_mark = clear_mark (tag_mark+max_deg+1, max_mark, n_row, Row) ;

#ifndef NDEBUG
        DEBUG3 (("check3\n")) ;
        debug_mark (n_row, Row, tag_mark, max_mark) ;
#endif /* NDEBUG */

        /* === Finalize the new pivot row, and column scores ================ */

        DEBUG3 (("** Finalize scores phase. **\n")) ;

        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        /* compact the pivot row */
        new_rp = rp ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            col = *rp++ ;
            /* skip dead columns */
            if (COL_IS_DEAD (col))
            {
                continue ;
            }
            *new_rp++ = col ;
            /* add new pivot row to column */
            A [Col [col].start + (Col [col].length++)] = pivot_row ;

            /* retrieve score so far and add on pivot row's degree. */
            /* (we wait until here for this in case the pivot */
            /* row's degree was reduced due to mass elimination). */
            cur_score = Col [col].shared2.score + pivot_row_degree ;

            /* calculate the max possible score as the number of */
            /* external columns minus the 'k' value minus the */
            /* columns thickness */
            max_score = n_col - k - Col [col].shared1.thickness ;

            /* make the score the external degree of the union-of-rows */
            cur_score -= Col [col].shared1.thickness ;

            /* make sure score is less or equal than the max score */
            cur_score = MIN (cur_score, max_score) ;
            ASSERT (cur_score >= 0) ;

            /* store updated score */
            Col [col].shared2.score = cur_score ;

            /* === Place column back in degree list ========================= */

            ASSERT (min_score >= 0) ;
            ASSERT (min_score <= n_col) ;
            ASSERT (cur_score >= 0) ;
            ASSERT (cur_score <= n_col) ;
            ASSERT (head [cur_score] >= EMPTY) ;
            next_col = head [cur_score] ;
            Col [col].shared4.degree_next = next_col ;
            Col [col].shared3.prev = EMPTY ;
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = col ;
            }
            head [cur_score] = col ;

            /* see if this score is less than current min */
            min_score = MIN (min_score, cur_score) ;

        }

#ifndef NDEBUG
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k, max_deg) ;
#endif /* NDEBUG */

        /* === Resurrect the new pivot row ================================== */

        if (pivot_row_degree > 0)
        {
            /* update pivot row length to reflect any cols that were killed */
            /* during super-col detection and mass elimination */
            Row [pivot_row].start  = pivot_row_start ;
            Row [pivot_row].length = (Int) (new_rp - &A[pivot_row_start]) ;
            ASSERT (Row [pivot_row].length > 0) ;
            Row [pivot_row].shared1.degree = pivot_row_degree ;
            Row [pivot_row].shared2.mark = 0 ;
            /* pivot row is no longer dead */

            DEBUG1 (("Resurrect Pivot_row %d deg: %d\n",
                        pivot_row, pivot_row_degree)) ;
        }
    }

    /* === All principal columns have now been ordered ====================== */

    return (ngarbage) ;
}


/* ========================================================================== */
/* === order_children ======================================================= */
/* ========================================================================== */

/*
    The find_ordering routine has ordered all of the principal columns (the
    representatives of the supercolumns).  The non-principal columns have not
    yet been ordered.  This routine orders those columns by walking up the
    parent tree (a column is a child of the column which absorbed it).  The
    final permutation vector is then placed in p [0 ... n_col-1], with p [0]
    being the first column, and p [n_col-1] being the last.  It doesn't look
    like it at first glance, but be assured that this routine takes time linear
    in the number of columns.  Although not immediately obvious, the time
    taken by this routine is O (n_col), that is, linear in the number of
    columns.  Not user-callable.
*/

PRIVATE void order_children
(
    /* === Parameters ======================================================= */

    Int n_col,                  /* number of columns of A */
    Colamd_Col Col [],          /* of size n_col+1 */
    Int p []                    /* p [0 ... n_col-1] is the column permutation*/
)
{
    /* === Local variables ================================================== */

    Int i ;                     /* loop counter for all columns */
    Int c ;                     /* column index */
    Int parent ;                /* index of column's parent */
    Int order ;                 /* column's order */

    /* === Order each non-principal column ================================== */

    for (i = 0 ; i < n_col ; i++)
    {
        /* find an un-ordered non-principal column */
        ASSERT (COL_IS_DEAD (i)) ;
        if (!COL_IS_DEAD_PRINCIPAL (i) && Col [i].shared2.order == EMPTY)
        {
            parent = i ;
            /* once found, find its principal parent */
            do
            {
                parent = Col [parent].shared1.parent ;
            } while (!COL_IS_DEAD_PRINCIPAL (parent)) ;

            /* now, order all un-ordered non-principal columns along path */
            /* to this parent.  collapse tree at the same time */
            c = i ;
            /* get order of parent */
            order = Col [parent].shared2.order ;

            do
            {
                ASSERT (Col [c].shared2.order == EMPTY) ;

                /* order this column */
                Col [c].shared2.order = order++ ;
                /* collaps tree */
                Col [c].shared1.parent = parent ;

                /* get immediate parent of this column */
                c = Col [c].shared1.parent ;

                /* continue until we hit an ordered column.  There are */
                /* guarranteed not to be anymore unordered columns */
                /* above an ordered column */
            } while (Col [c].shared2.order == EMPTY) ;

            /* re-order the super_col parent to largest order for this group */
            Col [parent].shared2.order = order ;
        }
    }

    /* === Generate the permutation ========================================= */

    for (c = 0 ; c < n_col ; c++)
    {
        p [Col [c].shared2.order] = c ;
    }
}


/* ========================================================================== */
/* === detect_super_cols ==================================================== */
/* ========================================================================== */

/*
    Detects supercolumns by finding matches between columns in the hash buckets.
    Check amongst columns in the set A [row_start ... row_start + row_length-1].
    The columns under consideration are currently *not* in the degree lists,
    and have already been placed in the hash buckets.

    The hash bucket for columns whose hash function is equal to h is stored
    as follows:

        if head [h] is >= 0, then head [h] contains a degree list, so:

                head [h] is the first column in degree bucket h.
                Col [head [h]].headhash gives the first column in hash bucket h.

        otherwise, the degree list is empty, and:

                -(head [h] + 2) is the first column in hash bucket h.

    For a column c in a hash bucket, Col [c].shared3.prev is NOT a "previous
    column" pointer.  Col [c].shared3.hash is used instead as the hash number
    for that column.  The value of Col [c].shared4.hash_next is the next column
    in the same hash bucket.

    Assuming no, or "few" hash collisions, the time taken by this routine is
    linear in the sum of the sizes (lengths) of each column whose score has
    just been computed in the approximate degree computation.
    Not user-callable.
*/

PRIVATE void detect_super_cols
(
    /* === Parameters ======================================================= */

#ifndef NDEBUG
    /* these two parameters are only needed when debugging is enabled: */
    Int n_col,                  /* number of columns of A */
    Colamd_Row Row [],          /* of size n_row+1 */
#endif /* NDEBUG */

    Colamd_Col Col [],          /* of size n_col+1 */
    Int A [],                   /* row indices of A */
    Int head [],                /* head of degree lists and hash buckets */
    Int row_start,              /* pointer to set of columns to check */
    Int row_length              /* number of columns to check */
)
{
    /* === Local variables ================================================== */

    Int hash ;                  /* hash value for a column */
    Int *rp ;                   /* pointer to a row */
    Int c ;                     /* a column index */
    Int super_c ;               /* column index of the column to absorb into */
    Int *cp1 ;                  /* column pointer for column super_c */
    Int *cp2 ;                  /* column pointer for column c */
    Int length ;                /* length of column super_c */
    Int prev_c ;                /* column preceding c in hash bucket */
    Int i ;                     /* loop counter */
    Int *rp_end ;               /* pointer to the end of the row */
    Int col ;                   /* a column index in the row to check */
    Int head_column ;           /* first column in hash bucket or degree list */
    Int first_col ;             /* first column in hash bucket */

    /* === Consider each column in the row ================================== */

    rp = &A [row_start] ;
    rp_end = rp + row_length ;
    while (rp < rp_end)
    {
        col = *rp++ ;
        if (COL_IS_DEAD (col))
        {
            continue ;
        }

        /* get hash number for this column */
        hash = Col [col].shared3.hash ;
        ASSERT (hash <= n_col) ;

        /* === Get the first column in this hash bucket ===================== */

        head_column = head [hash] ;
        if (head_column > EMPTY)
        {
            first_col = Col [head_column].shared3.headhash ;
        }
        else
        {
            first_col = - (head_column + 2) ;
        }

        /* === Consider each column in the hash bucket ====================== */

        for (super_c = first_col ; super_c != EMPTY ;
            super_c = Col [super_c].shared4.hash_next)
        {
            ASSERT (COL_IS_ALIVE (super_c)) ;
            ASSERT (Col [super_c].shared3.hash == hash) ;
            length = Col [super_c].length ;

            /* prev_c is the column preceding column c in the hash bucket */
            prev_c = super_c ;

            /* === Compare super_c with all columns after it ================ */

            for (c = Col [super_c].shared4.hash_next ;
                 c != EMPTY ; c = Col [c].shared4.hash_next)
            {
                ASSERT (c != super_c) ;
                ASSERT (COL_IS_ALIVE (c)) ;
                ASSERT (Col [c].shared3.hash == hash) ;

                /* not identical if lengths or scores are different */
                if (Col [c].length != length ||
                    Col [c].shared2.score != Col [super_c].shared2.score)
                {
                    prev_c = c ;
                    continue ;
                }

                /* compare the two columns */
                cp1 = &A [Col [super_c].start] ;
                cp2 = &A [Col [c].start] ;

                for (i = 0 ; i < length ; i++)
                {
                    /* the columns are "clean" (no dead rows) */
                    ASSERT (ROW_IS_ALIVE (*cp1))  ;
                    ASSERT (ROW_IS_ALIVE (*cp2))  ;
                    /* row indices will same order for both supercols, */
                    /* no gather scatter nessasary */
                    if (*cp1++ != *cp2++)
                    {
                        break ;
                    }
                }

                /* the two columns are different if the for-loop "broke" */
                if (i != length)
                {
                    prev_c = c ;
                    continue ;
                }

                /* === Got it!  two columns are identical =================== */

                ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;

                Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
                Col [c].shared1.parent = super_c ;
                KILL_NON_PRINCIPAL_COL (c) ;
                /* order c later, in order_children() */
                Col [c].shared2.order = EMPTY ;
                /* remove c from hash bucket */
                Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
            }
        }

        /* === Empty this hash bucket ======================================= */

        if (head_column > EMPTY)
        {
            /* corresponding degree list "hash" is not empty */
            Col [head_column].shared3.headhash = EMPTY ;
        }
        else
        {
            /* corresponding degree list "hash" is empty */
            head [hash] = EMPTY ;
        }
    }
}


/* ========================================================================== */
/* === garbage_collection =================================================== */
/* ========================================================================== */

/*
    Defragments and compacts columns and rows in the workspace A.  Used when
    all avaliable memory has been used while performing row merging.  Returns
    the index of the first free position in A, after garbage collection.  The
    time taken by this routine is linear is the size of the array A, which is
    itself linear in the number of nonzeros in the input matrix.
    Not user-callable.
*/

PRIVATE Int garbage_collection  /* returns the new value of pfree */
(
    /* === Parameters ======================================================= */

    Int n_row,                  /* number of rows */
    Int n_col,                  /* number of columns */
    Colamd_Row Row [],          /* row info */
    Colamd_Col Col [],          /* column info */
    Int A [],                   /* A [0 ... Alen-1] holds the matrix */
    Int *pfree                  /* &A [0] ... pfree is in use */
)
{
    /* === Local variables ================================================== */

    Int *psrc ;                 /* source pointer */
    Int *pdest ;                /* destination pointer */
    Int j ;                     /* counter */
    Int r ;                     /* a row index */
    Int c ;                     /* a column index */
    Int length ;                /* length of a row or column */

#ifndef NDEBUG
    Int debug_rows ;
    DEBUG2 (("Defrag..\n")) ;
    for (psrc = &A[0] ; psrc < pfree ; psrc++) ASSERT (*psrc >= 0) ;
    debug_rows = 0 ;
#endif /* NDEBUG */

    /* === Defragment the columns =========================================== */

    pdest = &A[0] ;
    for (c = 0 ; c < n_col ; c++)
    {
        if (COL_IS_ALIVE (c))
        {
            psrc = &A [Col [c].start] ;

            /* move and compact the column */
            ASSERT (pdest <= psrc) ;
            Col [c].start = (Int) (pdest - &A [0]) ;
            length = Col [c].length ;
            for (j = 0 ; j < length ; j++)
            {
                r = *psrc++ ;
                if (ROW_IS_ALIVE (r))
                {
                    *pdest++ = r ;
                }
            }
            Col [c].length = (Int) (pdest - &A [Col [c].start]) ;
        }
    }

    /* === Prepare to defragment the rows =================================== */

    for (r = 0 ; r < n_row ; r++)
    {
        if (ROW_IS_DEAD (r) || (Row [r].length == 0))
        {
            /* This row is already dead, or is of zero length.  Cannot compact
             * a row of zero length, so kill it.  NOTE: in the current version,
             * there are no zero-length live rows.  Kill the row (for the first
             * time, or again) just to be safe. */
            KILL_ROW (r) ;
        }
        else
        {
            /* save first column index in Row [r].shared2.first_column */
            psrc = &A [Row [r].start] ;
            Row [r].shared2.first_column = *psrc ;
            ASSERT (ROW_IS_ALIVE (r)) ;
            /* flag the start of the row with the one's complement of row */
            *psrc = ONES_COMPLEMENT (r) ;
#ifndef NDEBUG
            debug_rows++ ;
#endif /* NDEBUG */
        }
    }

    /* === Defragment the rows ============================================== */

    psrc = pdest ;
    while (psrc < pfree)
    {
        /* find a negative number ... the start of a row */
        if (*psrc++ < 0)
        {
            psrc-- ;
            /* get the row index */
            r = ONES_COMPLEMENT (*psrc) ;
            ASSERT (r >= 0 && r < n_row) ;
            /* restore first column index */
            *psrc = Row [r].shared2.first_column ;
            ASSERT (ROW_IS_ALIVE (r)) ;
            ASSERT (Row [r].length > 0) ;
            /* move and compact the row */
            ASSERT (pdest <= psrc) ;
            Row [r].start = (Int) (pdest - &A [0]) ;
            length = Row [r].length ;
            for (j = 0 ; j < length ; j++)
            {
                c = *psrc++ ;
                if (COL_IS_ALIVE (c))
                {
                    *pdest++ = c ;
                }
            }
            Row [r].length = (Int) (pdest - &A [Row [r].start]) ;
            ASSERT (Row [r].length > 0) ;
#ifndef NDEBUG
            debug_rows-- ;
#endif /* NDEBUG */
        }
    }
    /* ensure we found all the rows */
    ASSERT (debug_rows == 0) ;

    /* === Return the new value of pfree ==================================== */

    return ((Int) (pdest - &A [0])) ;
}


/* ========================================================================== */
/* === clear_mark =========================================================== */
/* ========================================================================== */

/*
    Clears the Row [].shared2.mark array, and returns the new tag_mark.
    Return value is the new tag_mark.  Not user-callable.
*/

PRIVATE Int clear_mark  /* return the new value for tag_mark */
(
    /* === Parameters ======================================================= */

    Int tag_mark,       /* new value of tag_mark */
    Int max_mark,       /* max allowed value of tag_mark */

    Int n_row,          /* number of rows in A */
    Colamd_Row Row []   /* Row [0 ... n_row-1].shared2.mark is set to zero */
)
{
    /* === Local variables ================================================== */

    Int r ;

    if (tag_mark <= 0 || tag_mark >= max_mark)
    {
        for (r = 0 ; r < n_row ; r++)
        {
            if (ROW_IS_ALIVE (r))
            {
                Row [r].shared2.mark = 0 ;
            }
        }
        tag_mark = 1 ;
    }

    return (tag_mark) ;
}


/* ========================================================================== */
/* === print_report ========================================================= */
/* ========================================================================== */

PRIVATE void print_report
(
    char *method,
    Int stats [COLAMD_STATS]
)
{

    Int i1, i2, i3 ;

    PRINTF (("\n%s version %d.%d, %s: ", method,
            COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION, COLAMD_DATE)) ;

    if (!stats)
    {
        PRINTF (("No statistics available.\n")) ;
        return ;
    }

    i1 = stats [COLAMD_INFO1] ;
    i2 = stats [COLAMD_INFO2] ;
    i3 = stats [COLAMD_INFO3] ;

    if (stats [COLAMD_STATUS] >= 0)
    {
        PRINTF (("OK.  ")) ;
    }
    else
    {
        PRINTF (("ERROR.  ")) ;
    }

    switch (stats [COLAMD_STATUS])
    {

        case COLAMD_OK_BUT_JUMBLED:

            PRINTF(("Matrix has unsorted or duplicate row indices.\n")) ;

            PRINTF(("%s: number of duplicate or out-of-order row indices: %d\n",
            method, i3)) ;

            PRINTF(("%s: last seen duplicate or out-of-order row index:   %d\n",
            method, INDEX (i2))) ;

            PRINTF(("%s: last seen in column:                             %d",
            method, INDEX (i1))) ;

            /* no break - fall through to next case instead */

        case COLAMD_OK:

            PRINTF(("\n")) ;

            PRINTF(("%s: number of dense or empty rows ignored:           %d\n",
            method, stats [COLAMD_DENSE_ROW])) ;

            PRINTF(("%s: number of dense or empty columns ignored:        %d\n",
            method, stats [COLAMD_DENSE_COL])) ;

            PRINTF(("%s: number of garbage collections performed:         %d\n",
            method, stats [COLAMD_DEFRAG_COUNT])) ;
            break ;

        case COLAMD_ERROR_A_not_present:

            PRINTF(("Array A (row indices of matrix) not present.\n")) ;
            break ;

        case COLAMD_ERROR_p_not_present:

            PRINTF(("Array p (column pointers for matrix) not present.\n")) ;
            break ;

        case COLAMD_ERROR_nrow_negative:

            PRINTF(("Invalid number of rows (%d).\n", i1)) ;
            break ;

        case COLAMD_ERROR_ncol_negative:

            PRINTF(("Invalid number of columns (%d).\n", i1)) ;
            break ;

        case COLAMD_ERROR_nnz_negative:

            PRINTF(("Invalid number of nonzero entries (%d).\n", i1)) ;
            break ;

        case COLAMD_ERROR_p0_nonzero:

            PRINTF(("Invalid column pointer, p [0] = %d, must be zero.\n", i1));
            break ;

        case COLAMD_ERROR_A_too_small:

            PRINTF(("Array A too small.\n")) ;
            PRINTF(("        Need Alen >= %d, but given only Alen = %d.\n",
            i1, i2)) ;
            break ;

        case COLAMD_ERROR_col_length_negative:

            PRINTF
            (("Column %d has a negative number of nonzero entries (%d).\n",
            INDEX (i1), i2)) ;
            break ;

        case COLAMD_ERROR_row_index_out_of_bounds:

            PRINTF
            (("Row index (row %d) out of bounds (%d to %d) in column %d.\n",
            INDEX (i2), INDEX (0), INDEX (i3-1), INDEX (i1))) ;
            break ;

        case COLAMD_ERROR_out_of_memory:

            PRINTF(("Out of memory.\n")) ;
            break ;

        /* v2.4: internal-error case deleted */
    }
}




/* ========================================================================== */
/* === colamd debugging routines ============================================ */
/* ========================================================================== */

/* When debugging is disabled, the remainder of this file is ignored. */

#ifndef NDEBUG


/* ========================================================================== */
/* === debug_structures ===================================================== */
/* ========================================================================== */

/*
    At this point, all empty rows and columns are dead.  All live columns
    are "clean" (containing no dead rows) and simplicial (no supercolumns
    yet).  Rows may contain dead columns, but all live rows contain at
    least one live column.
*/

PRIVATE void debug_structures
(
    /* === Parameters ======================================================= */

    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A [],
    Int n_col2
)
{
    /* === Local variables ================================================== */

    Int i ;
    Int c ;
    Int *cp ;
    Int *cp_end ;
    Int len ;
    Int score ;
    Int r ;
    Int *rp ;
    Int *rp_end ;
    Int deg ;

    /* === Check A, Row, and Col ============================================ */

    for (c = 0 ; c < n_col ; c++)
    {
        if (COL_IS_ALIVE (c))
        {
            len = Col [c].length ;
            score = Col [c].shared2.score ;
            DEBUG4 (("initial live col %5d %5d %5d\n", c, len, score)) ;
            ASSERT (len > 0) ;
            ASSERT (score >= 0) ;
            ASSERT (Col [c].shared1.thickness == 1) ;
            cp = &A [Col [c].start] ;
            cp_end = cp + len ;
            while (cp < cp_end)
            {
                r = *cp++ ;
                ASSERT (ROW_IS_ALIVE (r)) ;
            }
        }
        else
        {
            i = Col [c].shared2.order ;
            ASSERT (i >= n_col2 && i < n_col) ;
        }
    }

    for (r = 0 ; r < n_row ; r++)
    {
        if (ROW_IS_ALIVE (r))
        {
            i = 0 ;
            len = Row [r].length ;
            deg = Row [r].shared1.degree ;
            ASSERT (len > 0) ;
            ASSERT (deg > 0) ;
            rp = &A [Row [r].start] ;
            rp_end = rp + len ;
            while (rp < rp_end)
            {
                c = *rp++ ;
                if (COL_IS_ALIVE (c))
                {
                    i++ ;
                }
            }
            ASSERT (i > 0) ;
        }
    }
}


/* ========================================================================== */
/* === debug_deg_lists ====================================================== */
/* ========================================================================== */

/*
    Prints the contents of the degree lists.  Counts the number of columns
    in the degree list and compares it to the total it should have.  Also
    checks the row degrees.
*/

PRIVATE void debug_deg_lists
(
    /* === Parameters ======================================================= */

    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int head [],
    Int min_score,
    Int should,
    Int max_deg
)
{
    /* === Local variables ================================================== */

    Int deg ;
    Int col ;
    Int have ;
    Int row ;

    /* === Check the degree lists =========================================== */

    if (n_col > 10000 && colamd_debug <= 0)
    {
        return ;
    }
    have = 0 ;
    DEBUG4 (("Degree lists: %d\n", min_score)) ;
    for (deg = 0 ; deg <= n_col ; deg++)
    {
        col = head [deg] ;
        if (col == EMPTY)
        {
            continue ;
        }
        DEBUG4 (("%d:", deg)) ;
        while (col != EMPTY)
        {
            DEBUG4 ((" %d", col)) ;
            have += Col [col].shared1.thickness ;
            ASSERT (COL_IS_ALIVE (col)) ;
            col = Col [col].shared4.degree_next ;
        }
        DEBUG4 (("\n")) ;
    }
    DEBUG4 (("should %d have %d\n", should, have)) ;
    ASSERT (should == have) ;

    /* === Check the row degrees ============================================ */

    if (n_row > 10000 && colamd_debug <= 0)
    {
        return ;
    }
    for (row = 0 ; row < n_row ; row++)
    {
        if (ROW_IS_ALIVE (row))
        {
            ASSERT (Row [row].shared1.degree <= max_deg) ;
        }
    }
}


/* ========================================================================== */
/* === debug_mark =========================================================== */
/* ========================================================================== */

/*
    Ensures that the tag_mark is less that the maximum and also ensures that
    each entry in the mark array is less than the tag mark.
*/

PRIVATE void debug_mark
(
    /* === Parameters ======================================================= */

    Int n_row,
    Colamd_Row Row [],
    Int tag_mark,
    Int max_mark
)
{
    /* === Local variables ================================================== */

    Int r ;

    /* === Check the Row marks ============================================== */

    ASSERT (tag_mark > 0 && tag_mark <= max_mark) ;
    if (n_row > 10000 && colamd_debug <= 0)
    {
        return ;
    }
    for (r = 0 ; r < n_row ; r++)
    {
        ASSERT (Row [r].shared2.mark < tag_mark) ;
    }
}


/* ========================================================================== */
/* === debug_matrix ========================================================= */
/* ========================================================================== */

/*
    Prints out the contents of the columns and the rows.
*/

PRIVATE void debug_matrix
(
    /* === Parameters ======================================================= */

    Int n_row,
    Int n_col,
    Colamd_Row Row [],
    Colamd_Col Col [],
    Int A []
)
{
    /* === Local variables ================================================== */

    Int r ;
    Int c ;
    Int *rp ;
    Int *rp_end ;
    Int *cp ;
    Int *cp_end ;

    /* === Dump the rows and columns of the matrix ========================== */

    if (colamd_debug < 3)
    {
        return ;
    }
    DEBUG3 (("DUMP MATRIX:\n")) ;
    for (r = 0 ; r < n_row ; r++)
    {
        DEBUG3 (("Row %d alive? %d\n", r, ROW_IS_ALIVE (r))) ;
        if (ROW_IS_DEAD (r))
        {
            continue ;
        }
        DEBUG3 (("start %d length %d degree %d\n",
                Row [r].start, Row [r].length, Row [r].shared1.degree)) ;
        rp = &A [Row [r].start] ;
        rp_end = rp + Row [r].length ;
        while (rp < rp_end)
        {
            c = *rp++ ;
            DEBUG4 (("  %d col %d\n", COL_IS_ALIVE (c), c)) ;
        }
    }

    for (c = 0 ; c < n_col ; c++)
    {
        DEBUG3 (("Col %d alive? %d\n", c, COL_IS_ALIVE (c))) ;
        if (COL_IS_DEAD (c))
        {
            continue ;
        }
        DEBUG3 (("start %d length %d shared1 %d shared2 %d\n",
                Col [c].start, Col [c].length,
                Col [c].shared1.thickness, Col [c].shared2.score)) ;
        cp = &A [Col [c].start] ;
        cp_end = cp + Col [c].length ;
        while (cp < cp_end)
        {
            r = *cp++ ;
            DEBUG4 (("  %d row %d\n", ROW_IS_ALIVE (r), r)) ;
        }
    }
}

PRIVATE void colamd_get_debug
(
    char *method
)
{
    FILE *f ;
    colamd_debug = 0 ;          /* no debug printing */
    f = fopen ("debug", "r") ;
    if (f == (FILE *) NULL)
    {
        colamd_debug = 0 ;
    }
    else
    {
        fscanf (f, "%d", &colamd_debug) ;
        fclose (f) ;
    }
    DEBUG0 (("%s: debug version, D = %d (THIS WILL BE SLOW!)\n",
        method, colamd_debug)) ;
}

#endif /* NDEBUG */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/colamd/colamd.h0000644000175100001710000000406300000000000024756 0ustar00runnerdocker00000000000000/* colamd.h */

/* Written by Andrew Makhorin . */

#ifndef COLAMD_H
#define COLAMD_H

#include "env.h"

#define COLAMD_DATE "Nov 1, 2007"
#define COLAMD_VERSION_CODE(main, sub) ((main) * 1000 + (sub))
#define COLAMD_MAIN_VERSION 2
#define COLAMD_SUB_VERSION 7
#define COLAMD_SUBSUB_VERSION 1
#define COLAMD_VERSION \
        COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)

#define COLAMD_KNOBS 20
#define COLAMD_STATS 20
#define COLAMD_DENSE_ROW 0
#define COLAMD_DENSE_COL 1
#define COLAMD_AGGRESSIVE 2
#define COLAMD_DEFRAG_COUNT 2
#define COLAMD_STATUS 3
#define COLAMD_INFO1 4
#define COLAMD_INFO2 5
#define COLAMD_INFO3 6

#define COLAMD_OK                            (0)
#define COLAMD_OK_BUT_JUMBLED                (1)
#define COLAMD_ERROR_A_not_present           (-1)
#define COLAMD_ERROR_p_not_present           (-2)
#define COLAMD_ERROR_nrow_negative           (-3)
#define COLAMD_ERROR_ncol_negative           (-4)
#define COLAMD_ERROR_nnz_negative            (-5)
#define COLAMD_ERROR_p0_nonzero              (-6)
#define COLAMD_ERROR_A_too_small             (-7)
#define COLAMD_ERROR_col_length_negative     (-8)
#define COLAMD_ERROR_row_index_out_of_bounds (-9)
#define COLAMD_ERROR_out_of_memory           (-10)
#define COLAMD_ERROR_internal_error          (-999)

#define colamd_recommended _glp_colamd_recommended
size_t colamd_recommended(int nnz, int n_row, int n_col);

#define colamd_set_defaults _glp_colamd_set_defaults
void colamd_set_defaults(double knobs [COLAMD_KNOBS]);

#define colamd _glp_colamd
int colamd(int n_row, int n_col, int Alen, int A[], int p[],
      double knobs[COLAMD_KNOBS], int stats[COLAMD_STATS]);

#define symamd _glp_symamd
int symamd(int n, int A[], int p[], int perm[],
      double knobs[COLAMD_KNOBS], int stats[COLAMD_STATS],
      void *(*allocate)(size_t, size_t), void(*release)(void *));

#define colamd_report _glp_colamd_report
void colamd_report(int stats[COLAMD_STATS]);

#define symamd_report _glp_symamd_report
void symamd_report(int stats[COLAMD_STATS]);

#define colamd_printf xprintf

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.667143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/0000755000175100001710000000000000000000000023204 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/bfd.c0000644000175100001710000003516200000000000024112 0ustar00runnerdocker00000000000000/* bfd.c (LP basis factorization driver) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "glpk.h"
#include "env.h"
#include "bfd.h"
#include "fhvint.h"
#include "scfint.h"
#ifdef GLP_DEBUG
#include "glpspm.h"
#endif

struct BFD
{     /* LP basis factorization driver */
      int valid;
      /* factorization is valid only if this flag is set */
      int type;
      /* type of factorization used:
         0 - interface not established yet
         1 - FHV-factorization
         2 - Schur-complement-based factorization */
      union
      {  void *none;   /* type = 0 */
         FHVINT *fhvi; /* type = 1 */
         SCFINT *scfi; /* type = 2 */
      }  u;
      /* interface to factorization of LP basis */
      glp_bfcp parm;
      /* factorization control parameters */
#ifdef GLP_DEBUG
      SPM *B;
      /* current basis (for testing/debugging only) */
#endif
      int upd_cnt;
      /* factorization update count */
#if 1 /* 21/IV-2014 */
      double b_norm;
      /* 1-norm of matrix B */
      double i_norm;
      /* estimated 1-norm of matrix inv(B) */
#endif
};

BFD *bfd_create_it(void)
{     /* create LP basis factorization */
      BFD *bfd;
#ifdef GLP_DEBUG
      xprintf("bfd_create_it: warning: debugging version used\n");
#endif
      bfd = talloc(1, BFD);
      bfd->valid = 0;
      bfd->type = 0;
      bfd->u.none = NULL;
      bfd_set_bfcp(bfd, NULL);
#ifdef GLP_DEBUG
      bfd->B = NULL;
#endif
      bfd->upd_cnt = 0;
      return bfd;
}

#if 0 /* 08/III-2014 */
void bfd_set_parm(BFD *bfd, const void *parm)
{     /* change LP basis factorization control parameters */
      memcpy(&bfd->parm, parm, sizeof(glp_bfcp));
      return;
}
#endif

void bfd_get_bfcp(BFD *bfd, void /* glp_bfcp */ *parm)
{     /* retrieve LP basis factorization control parameters */
      memcpy(parm, &bfd->parm, sizeof(glp_bfcp));
      return;
}

void bfd_set_bfcp(BFD *bfd, const void /* glp_bfcp */ *parm)
{     /* change LP basis factorization control parameters */
      if (parm == NULL)
      {  /* reset to default */
         memset(&bfd->parm, 0, sizeof(glp_bfcp));
         bfd->parm.type = GLP_BF_LUF + GLP_BF_FT;
         bfd->parm.piv_tol = 0.10;
         bfd->parm.piv_lim = 4;
         bfd->parm.suhl = 1;
         bfd->parm.eps_tol = DBL_EPSILON;
         bfd->parm.nfs_max = 100;
         bfd->parm.nrs_max = 70;
      }
      else
         memcpy(&bfd->parm, parm, sizeof(glp_bfcp));
      return;
}

#if 1 /* 21/IV-2014 */
struct bfd_info
{     BFD *bfd;
      int (*col)(void *info, int j, int ind[], double val[]);
      void *info;
};

static int bfd_col(void *info_, int j, int ind[], double val[])
{     struct bfd_info *info = info_;
      int t, len;
      double sum;
      len = info->col(info->info, j, ind, val);
      sum = 0.0;
      for (t = 1; t <= len; t++)
      {  if (val[t] >= 0.0)
            sum += val[t];
         else
            sum -= val[t];
      }
      if (info->bfd->b_norm < sum)
         info->bfd->b_norm = sum;
      return len;
}
#endif

int bfd_factorize(BFD *bfd, int m, /*const int bh[],*/ int (*col1)
      (void *info, int j, int ind[], double val[]), void *info1)
{     /* compute LP basis factorization */
#if 1 /* 21/IV-2014 */
      struct bfd_info info;
#endif
      int type, ret;
      /*xassert(bh == bh);*/
      /* invalidate current factorization */
      bfd->valid = 0;
      /* determine required factorization type */
      switch (bfd->parm.type)
      {  case GLP_BF_LUF + GLP_BF_FT:
            type = 1;
            break;
         case GLP_BF_LUF + GLP_BF_BG:
         case GLP_BF_LUF + GLP_BF_GR:
         case GLP_BF_BTF + GLP_BF_BG:
         case GLP_BF_BTF + GLP_BF_GR:
            type = 2;
            break;
         default:
            xassert(bfd != bfd);
      }
      /* delete factorization interface, if necessary */
      switch (bfd->type)
      {  case 0:
            break;
         case 1:
            if (type != 1)
            {  bfd->type = 0;
               fhvint_delete(bfd->u.fhvi);
               bfd->u.fhvi = NULL;
            }
            break;
         case 2:
            if (type != 2)
            {  bfd->type = 0;
               scfint_delete(bfd->u.scfi);
               bfd->u.scfi = NULL;
            }
            break;
         default:
            xassert(bfd != bfd);
      }
      /* establish factorization interface, if necessary */
      if (bfd->type == 0)
      {  switch (type)
         {  case 1:
               bfd->type = 1;
               xassert(bfd->u.fhvi == NULL);
               bfd->u.fhvi = fhvint_create();
               break;
            case 2:
               bfd->type = 2;
               xassert(bfd->u.scfi == NULL);
               if (!(bfd->parm.type & GLP_BF_BTF))
                  bfd->u.scfi = scfint_create(1);
               else
                  bfd->u.scfi = scfint_create(2);
               break;
            default:
               xassert(type != type);
         }
      }
      /* try to compute factorization */
#if 1 /* 21/IV-2014 */
      bfd->b_norm = bfd->i_norm = 0.0;
      info.bfd = bfd;
      info.col = col1;
      info.info = info1;
#endif
      switch (bfd->type)
      {  case 1:
            bfd->u.fhvi->lufi->sgf_piv_tol = bfd->parm.piv_tol;
            bfd->u.fhvi->lufi->sgf_piv_lim = bfd->parm.piv_lim;
            bfd->u.fhvi->lufi->sgf_suhl = bfd->parm.suhl;
            bfd->u.fhvi->lufi->sgf_eps_tol = bfd->parm.eps_tol;
            bfd->u.fhvi->nfs_max = bfd->parm.nfs_max;
            ret = fhvint_factorize(bfd->u.fhvi, m, bfd_col, &info);
#if 1 /* FIXME */
            if (ret == 0)
               bfd->i_norm = fhvint_estimate(bfd->u.fhvi);
            else
               ret = BFD_ESING;
#endif
            break;
         case 2:
            if (bfd->u.scfi->scf.type == 1)
            {  bfd->u.scfi->u.lufi->sgf_piv_tol = bfd->parm.piv_tol;
               bfd->u.scfi->u.lufi->sgf_piv_lim = bfd->parm.piv_lim;
               bfd->u.scfi->u.lufi->sgf_suhl = bfd->parm.suhl;
               bfd->u.scfi->u.lufi->sgf_eps_tol = bfd->parm.eps_tol;
            }
            else if (bfd->u.scfi->scf.type == 2)
            {  bfd->u.scfi->u.btfi->sgf_piv_tol = bfd->parm.piv_tol;
               bfd->u.scfi->u.btfi->sgf_piv_lim = bfd->parm.piv_lim;
               bfd->u.scfi->u.btfi->sgf_suhl = bfd->parm.suhl;
               bfd->u.scfi->u.btfi->sgf_eps_tol = bfd->parm.eps_tol;
            }
            else
               xassert(bfd != bfd);
            bfd->u.scfi->nn_max = bfd->parm.nrs_max;
            ret = scfint_factorize(bfd->u.scfi, m, bfd_col, &info);
#if 1 /* FIXME */
            if (ret == 0)
               bfd->i_norm = scfint_estimate(bfd->u.scfi);
            else
               ret = BFD_ESING;
#endif
            break;
         default:
            xassert(bfd != bfd);
      }
#ifdef GLP_DEBUG
      /* save specified LP basis */
      if (bfd->B != NULL)
         spm_delete_mat(bfd->B);
      bfd->B = spm_create_mat(m, m);
      {  int *ind = talloc(1+m, int);
         double *val = talloc(1+m, double);
         int j, k, len;
         for (j = 1; j <= m; j++)
         {  len = col(info, j, ind, val);
            for (k = 1; k <= len; k++)
               spm_new_elem(bfd->B, ind[k], j, val[k]);
         }
         tfree(ind);
         tfree(val);
      }
#endif
      if (ret == 0)
      {  /* factorization has been successfully computed */
         double cond;
         bfd->valid = 1;
#ifdef GLP_DEBUG
         cond = bfd_condest(bfd);
         if (cond > 1e9)
            xprintf("bfd_factorize: warning: cond(B) = %g\n", cond);
#endif
      }
#ifdef GLP_DEBUG
      xprintf("bfd_factorize: m = %d; ret = %d\n", m, ret);
#endif
      bfd->upd_cnt = 0;
      return ret;
}

#if 0 /* 21/IV-2014 */
double bfd_estimate(BFD *bfd)
{     /* estimate 1-norm of inv(B) */
      double norm;
      xassert(bfd->valid);
      xassert(bfd->upd_cnt == 0);
      switch (bfd->type)
      {  case 1:
            norm = fhvint_estimate(bfd->u.fhvi);
            break;
         case 2:
            norm = scfint_estimate(bfd->u.scfi);
            break;
         default:
            xassert(bfd != bfd);
      }
      return norm;
}
#endif

#if 1 /* 21/IV-2014 */
double bfd_condest(BFD *bfd)
{     /* estimate condition of B */
      double cond;
      xassert(bfd->valid);
      /*xassert(bfd->upd_cnt == 0);*/
      cond = bfd->b_norm * bfd->i_norm;
      if (cond < 1.0)
         cond = 1.0;
      return cond;
}
#endif

void bfd_ftran(BFD *bfd, double x[])
{     /* perform forward transformation (solve system B * x = b) */
#ifdef GLP_DEBUG
      SPM *B = bfd->B;
      int m = B->m;
      double *b = talloc(1+m, double);
      SPME *e;
      int k;
      double s, relerr, maxerr;
      for (k = 1; k <= m; k++)
         b[k] = x[k];
#endif
      xassert(bfd->valid);
      switch (bfd->type)
      {  case 1:
            fhvint_ftran(bfd->u.fhvi, x);
            break;
         case 2:
            scfint_ftran(bfd->u.scfi, x);
            break;
         default:
            xassert(bfd != bfd);
      }
#ifdef GLP_DEBUG
      maxerr = 0.0;
      for (k = 1; k <= m; k++)
      {  s = 0.0;
         for (e = B->row[k]; e != NULL; e = e->r_next)
            s += e->val * x[e->j];
         relerr = (b[k] - s) / (1.0 + fabs(b[k]));
         if (maxerr < relerr)
            maxerr = relerr;
      }
      if (maxerr > 1e-8)
         xprintf("bfd_ftran: maxerr = %g; relative error too large\n",
            maxerr);
      tfree(b);
#endif
      return;
}

#if 1 /* 30/III-2016 */
void bfd_ftran_s(BFD *bfd, FVS *x)
{     /* sparse version of bfd_ftran */
      /* (sparse mode is not implemented yet) */
      int n = x->n;
      int *ind = x->ind;
      double *vec = x->vec;
      int j, nnz = 0;
      bfd_ftran(bfd, vec);
      for (j = n; j >= 1; j--)
      {  if (vec[j] != 0.0)
            ind[++nnz] = j;
      }
      x->nnz = nnz;
      return;
}
#endif

void bfd_btran(BFD *bfd, double x[])
{     /* perform backward transformation (solve system B'* x = b) */
#ifdef GLP_DEBUG
      SPM *B = bfd->B;
      int m = B->m;
      double *b = talloc(1+m, double);
      SPME *e;
      int k;
      double s, relerr, maxerr;
      for (k = 1; k <= m; k++)
         b[k] = x[k];
#endif
      xassert(bfd->valid);
      switch (bfd->type)
      {  case 1:
            fhvint_btran(bfd->u.fhvi, x);
            break;
         case 2:
            scfint_btran(bfd->u.scfi, x);
            break;
         default:
            xassert(bfd != bfd);
      }
#ifdef GLP_DEBUG
      maxerr = 0.0;
      for (k = 1; k <= m; k++)
      {  s = 0.0;
         for (e = B->col[k]; e != NULL; e = e->c_next)
            s += e->val * x[e->i];
         relerr = (b[k] - s) / (1.0 + fabs(b[k]));
         if (maxerr < relerr)
            maxerr = relerr;
      }
      if (maxerr > 1e-8)
         xprintf("bfd_btran: maxerr = %g; relative error too large\n",
            maxerr);
      tfree(b);
#endif
      return;
}

#if 1 /* 30/III-2016 */
void bfd_btran_s(BFD *bfd, FVS *x)
{     /* sparse version of bfd_btran */
      /* (sparse mode is not implemented yet) */
      int n = x->n;
      int *ind = x->ind;
      double *vec = x->vec;
      int j, nnz = 0;
      bfd_btran(bfd, vec);
      for (j = n; j >= 1; j--)
      {  if (vec[j] != 0.0)
            ind[++nnz] = j;
      }
      x->nnz = nnz;
      return;
}
#endif

int bfd_update(BFD *bfd, int j, int len, const int ind[], const double
      val[])
{     /* update LP basis factorization */
      int ret;
      xassert(bfd->valid);
      switch (bfd->type)
      {  case 1:
            ret = fhvint_update(bfd->u.fhvi, j, len, ind, val);
#if 1 /* FIXME */
            switch (ret)
            {  case 0:
                  break;
               case 1:
                  ret = BFD_ESING;
                  break;
               case 2:
               case 3:
                  ret = BFD_ECOND;
                  break;
               case 4:
                  ret = BFD_ELIMIT;
                  break;
               case 5:
                  ret = BFD_ECHECK;
                  break;
               default:
                  xassert(ret != ret);
            }
#endif
            break;
         case 2:
            switch (bfd->parm.type & 0x0F)
            {  case GLP_BF_BG:
                  ret = scfint_update(bfd->u.scfi, 1, j, len, ind, val);
                  break;
               case GLP_BF_GR:
                  ret = scfint_update(bfd->u.scfi, 2, j, len, ind, val);
                  break;
               default:
                  xassert(bfd != bfd);
            }
#if 1 /* FIXME */
            switch (ret)
            {  case 0:
                  break;
               case 1:
                  ret = BFD_ELIMIT;
                  break;
               case 2:
                  ret = BFD_ECOND;
                  break;
               default:
                  xassert(ret != ret);
            }
#endif
            break;
         default:
            xassert(bfd != bfd);
      }
      if (ret != 0)
      {  /* updating factorization failed */
         bfd->valid = 0;
      }
#ifdef GLP_DEBUG
      /* save updated LP basis */
      {  SPME *e;
         int k;
         for (e = bfd->B->col[j]; e != NULL; e = e->c_next)
            e->val = 0.0;
         spm_drop_zeros(bfd->B, 0.0);
         for (k = 1; k <= len; k++)
            spm_new_elem(bfd->B, ind[k], j, val[k]);
      }
#endif
      if (ret == 0)
         bfd->upd_cnt++;
      return ret;
}

int bfd_get_count(BFD *bfd)
{     /* determine factorization update count */
      return bfd->upd_cnt;
}

void bfd_delete_it(BFD *bfd)
{     /* delete LP basis factorization */
      switch (bfd->type)
      {  case 0:
            break;
         case 1:
            fhvint_delete(bfd->u.fhvi);
            break;
         case 2:
            scfint_delete(bfd->u.scfi);
            break;
         default:
            xassert(bfd != bfd);
      }
#ifdef GLP_DEBUG
      if (bfd->B != NULL)
         spm_delete_mat(bfd->B);
#endif
      tfree(bfd);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/bfd.h0000644000175100001710000000625000000000000024113 0ustar00runnerdocker00000000000000/* bfd.h (LP basis factorization driver) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef BFD_H
#define BFD_H

#if 1 /* 30/III-2016 */
#include "fvs.h"
#endif

typedef struct BFD BFD;

/* return codes: */
#define BFD_ESING    1  /* singular matrix */
#define BFD_ECOND    2  /* ill-conditioned matrix */
#define BFD_ECHECK   3  /* insufficient accuracy */
#define BFD_ELIMIT   4  /* update limit reached */
#if 0 /* 05/III-2014 */
#define BFD_EROOM    5  /* SVA overflow */
#endif

#define bfd_create_it _glp_bfd_create_it
BFD *bfd_create_it(void);
/* create LP basis factorization */

#if 0 /* 08/III-2014 */
#define bfd_set_parm _glp_bfd_set_parm
void bfd_set_parm(BFD *bfd, const void *parm);
/* change LP basis factorization control parameters */
#endif

#define bfd_get_bfcp _glp_bfd_get_bfcp
void bfd_get_bfcp(BFD *bfd, void /* glp_bfcp */ *parm);
/* retrieve LP basis factorization control parameters */

#define bfd_set_bfcp _glp_bfd_set_bfcp
void bfd_set_bfcp(BFD *bfd, const void /* glp_bfcp */ *parm);
/* change LP basis factorization control parameters */

#define bfd_factorize _glp_bfd_factorize
int bfd_factorize(BFD *bfd, int m, /*const int bh[],*/ int (*col)
      (void *info, int j, int ind[], double val[]), void *info);
/* compute LP basis factorization */

#if 1 /* 21/IV-2014 */
#define bfd_condest _glp_bfd_condest
double bfd_condest(BFD *bfd);
/* estimate condition of B */
#endif

#define bfd_ftran _glp_bfd_ftran
void bfd_ftran(BFD *bfd, double x[]);
/* perform forward transformation (solve system B*x = b) */

#if 1 /* 30/III-2016 */
#define bfd_ftran_s _glp_bfd_ftran_s
void bfd_ftran_s(BFD *bfd, FVS *x);
/* sparse version of bfd_ftran */
#endif

#define bfd_btran _glp_bfd_btran
void bfd_btran(BFD *bfd, double x[]);
/* perform backward transformation (solve system B'*x = b) */

#if 1 /* 30/III-2016 */
#define bfd_btran_s _glp_bfd_btran_s
void bfd_btran_s(BFD *bfd, FVS *x);
/* sparse version of bfd_btran */
#endif

#define bfd_update _glp_bfd_update
int bfd_update(BFD *bfd, int j, int len, const int ind[], const double
      val[]);
/* update LP basis factorization */

#define bfd_get_count _glp_bfd_get_count
int bfd_get_count(BFD *bfd);
/* determine factorization update count */

#define bfd_delete_it _glp_bfd_delete_it
void bfd_delete_it(BFD *bfd);
/* delete LP basis factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/bfx.c0000644000175100001710000000472300000000000024135 0ustar00runnerdocker00000000000000/* bfx.c (LP basis factorization driver, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "bfx.h"
#include "env.h"
#include "lux.h"

struct BFX
{     int valid;
      LUX *lux;
};

BFX *bfx_create_binv(void)
{     /* create factorization of the basis matrix */
      BFX *bfx;
      bfx = xmalloc(sizeof(BFX));
      bfx->valid = 0;
      bfx->lux = NULL;
      return bfx;
}

int bfx_factorize(BFX *binv, int m, int (*col)(void *info, int j,
      int ind[], mpq_t val[]), void *info)
{     /* compute factorization of the basis matrix */
      int ret;
      xassert(m > 0);
      if (binv->lux != NULL && binv->lux->n != m)
      {  lux_delete(binv->lux);
         binv->lux = NULL;
      }
      if (binv->lux == NULL)
         binv->lux = lux_create(m);
      ret = lux_decomp(binv->lux, col, info);
      binv->valid = (ret == 0);
      return ret;
}

void bfx_ftran(BFX *binv, mpq_t x[], int save)
{     /* perform forward transformation (FTRAN) */
      xassert(binv->valid);
      lux_solve(binv->lux, 0, x);
      xassert(save == save);
      return;
}

void bfx_btran(BFX *binv, mpq_t x[])
{     /* perform backward transformation (BTRAN) */
      xassert(binv->valid);
      lux_solve(binv->lux, 1, x);
      return;
}

int bfx_update(BFX *binv, int j)
{     /* update factorization of the basis matrix */
      xassert(binv->valid);
      xassert(1 <= j && j <= binv->lux->n);
      return 1;
}

void bfx_delete_binv(BFX *binv)
{     /* delete factorization of the basis matrix */
      if (binv->lux != NULL)
         lux_delete(binv->lux);
      xfree(binv);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/bfx.h0000644000175100001710000000412200000000000024133 0ustar00runnerdocker00000000000000/* bfx.h (LP basis factorization driver, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2014 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef BFX_H
#define BFX_H

#include "mygmp.h"

typedef struct BFX BFX;

#define bfx_create_binv _glp_bfx_create_binv
BFX *bfx_create_binv(void);
/* create factorization of the basis matrix */

#define bfx_is_valid _glp_bfx_is_valid
int bfx_is_valid(BFX *binv);
/* check if factorization is valid */

#define bfx_invalidate _glp_bfx_invalidate
void bfx_invalidate(BFX *binv);
/* invalidate factorization of the basis matrix */

#define bfx_factorize _glp_bfx_factorize
int bfx_factorize(BFX *binv, int m, int (*col)(void *info, int j,
      int ind[], mpq_t val[]), void *info);
/* compute factorization of the basis matrix */

#define bfx_ftran _glp_bfx_ftran
void bfx_ftran(BFX *binv, mpq_t x[], int save);
/* perform forward transformation (FTRAN) */

#define bfx_btran _glp_bfx_btran
void bfx_btran(BFX *binv, mpq_t x[]);
/* perform backward transformation (BTRAN) */

#define bfx_update _glp_bfx_update
int bfx_update(BFX *binv, int j);
/* update factorization of the basis matrix */

#define bfx_delete_binv _glp_bfx_delete_binv
void bfx_delete_binv(BFX *binv);
/* delete factorization of the basis matrix */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/draft.h0000644000175100001710000000064400000000000024461 0ustar00runnerdocker00000000000000/* draft.h */

#ifndef DRAFT_H
#define DRAFT_H

#if 1 /* 28/III-2016 */
#define GLP_UNDOC 1
#endif
#include "glpk.h"

#if 1 /* 28/XI-2009 */
int _glp_analyze_row(glp_prob *P, int len, const int ind[],
      const double val[], int type, double rhs, double eps, int *_piv,
      double *_x, double *_dx, double *_y, double *_dy, double *_dz);
/* simulate one iteration of dual simplex method */
#endif

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi06.c0000644000175100001710000006620300000000000025001 0ustar00runnerdocker00000000000000/* glpapi06.c (simplex method routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"
#include "npp.h"
#if 0 /* 07/XI-2015 */
#include "glpspx.h"
#else
#include "simplex.h"
#define spx_dual spy_dual
#endif

/***********************************************************************
*  NAME
*
*  glp_simplex - solve LP problem with the simplex method
*
*  SYNOPSIS
*
*  int glp_simplex(glp_prob *P, const glp_smcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_simplex is a driver to the LP solver based on the
*  simplex method. This routine retrieves problem data from the
*  specified problem object, calls the solver to solve the problem
*  instance, and stores results of computations back into the problem
*  object.
*
*  The simplex solver has a set of control parameters. Values of the
*  control parameters can be passed in a structure glp_smcp, which the
*  parameter parm points to.
*
*  The parameter parm can be specified as NULL, in which case the LP
*  solver uses default settings.
*
*  RETURNS
*
*  0  The LP problem instance has been successfully solved. This code
*     does not necessarily mean that the solver has found optimal
*     solution. It only means that the solution process was successful.
*
*  GLP_EBADB
*     Unable to start the search, because the initial basis specified
*     in the problem object is invalid--the number of basic (auxiliary
*     and structural) variables is not the same as the number of rows in
*     the problem object.
*
*  GLP_ESING
*     Unable to start the search, because the basis matrix correspodning
*     to the initial basis is singular within the working precision.
*
*  GLP_ECOND
*     Unable to start the search, because the basis matrix correspodning
*     to the initial basis is ill-conditioned, i.e. its condition number
*     is too large.
*
*  GLP_EBOUND
*     Unable to start the search, because some double-bounded variables
*     have incorrect bounds.
*
*  GLP_EFAIL
*     The search was prematurely terminated due to the solver failure.
*
*  GLP_EOBJLL
*     The search was prematurely terminated, because the objective
*     function being maximized has reached its lower limit and continues
*     decreasing (dual simplex only).
*
*  GLP_EOBJUL
*     The search was prematurely terminated, because the objective
*     function being minimized has reached its upper limit and continues
*     increasing (dual simplex only).
*
*  GLP_EITLIM
*     The search was prematurely terminated, because the simplex
*     iteration limit has been exceeded.
*
*  GLP_ETMLIM
*     The search was prematurely terminated, because the time limit has
*     been exceeded.
*
*  GLP_ENOPFS
*     The LP problem instance has no primal feasible solution (only if
*     the LP presolver is used).
*
*  GLP_ENODFS
*     The LP problem instance has no dual feasible solution (only if the
*     LP presolver is used). */

static void trivial_lp(glp_prob *P, const glp_smcp *parm)
{     /* solve trivial LP which has empty constraint matrix */
      GLPROW *row;
      GLPCOL *col;
      int i, j;
      double p_infeas, d_infeas, zeta;
      P->valid = 0;
      P->pbs_stat = P->dbs_stat = GLP_FEAS;
      P->obj_val = P->c0;
      P->some = 0;
      p_infeas = d_infeas = 0.0;
      /* make all auxiliary variables basic */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         row->stat = GLP_BS;
         row->prim = row->dual = 0.0;
         /* check primal feasibility */
         if (row->type == GLP_LO || row->type == GLP_DB ||
             row->type == GLP_FX)
         {  /* row has lower bound */
            if (row->lb > + parm->tol_bnd)
            {  P->pbs_stat = GLP_NOFEAS;
               if (P->some == 0 && parm->meth != GLP_PRIMAL)
                  P->some = i;
            }
            if (p_infeas < + row->lb)
               p_infeas = + row->lb;
         }
         if (row->type == GLP_UP || row->type == GLP_DB ||
             row->type == GLP_FX)
         {  /* row has upper bound */
            if (row->ub < - parm->tol_bnd)
            {  P->pbs_stat = GLP_NOFEAS;
               if (P->some == 0 && parm->meth != GLP_PRIMAL)
                  P->some = i;
            }
            if (p_infeas < - row->ub)
               p_infeas = - row->ub;
         }
      }
      /* determine scale factor for the objective row */
      zeta = 1.0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (zeta < fabs(col->coef)) zeta = fabs(col->coef);
      }
      zeta = (P->dir == GLP_MIN ? +1.0 : -1.0) / zeta;
      /* make all structural variables non-basic */
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->type == GLP_FR)
            col->stat = GLP_NF, col->prim = 0.0;
         else if (col->type == GLP_LO)
lo:         col->stat = GLP_NL, col->prim = col->lb;
         else if (col->type == GLP_UP)
up:         col->stat = GLP_NU, col->prim = col->ub;
         else if (col->type == GLP_DB)
         {  if (zeta * col->coef > 0.0)
               goto lo;
            else if (zeta * col->coef < 0.0)
               goto up;
            else if (fabs(col->lb) <= fabs(col->ub))
               goto lo;
            else
               goto up;
         }
         else if (col->type == GLP_FX)
            col->stat = GLP_NS, col->prim = col->lb;
         col->dual = col->coef;
         P->obj_val += col->coef * col->prim;
         /* check dual feasibility */
         if (col->type == GLP_FR || col->type == GLP_LO)
         {  /* column has no upper bound */
            if (zeta * col->dual < - parm->tol_dj)
            {  P->dbs_stat = GLP_NOFEAS;
               if (P->some == 0 && parm->meth == GLP_PRIMAL)
                  P->some = P->m + j;
            }
            if (d_infeas < - zeta * col->dual)
               d_infeas = - zeta * col->dual;
         }
         if (col->type == GLP_FR || col->type == GLP_UP)
         {  /* column has no lower bound */
            if (zeta * col->dual > + parm->tol_dj)
            {  P->dbs_stat = GLP_NOFEAS;
               if (P->some == 0 && parm->meth == GLP_PRIMAL)
                  P->some = P->m + j;
            }
            if (d_infeas < + zeta * col->dual)
               d_infeas = + zeta * col->dual;
         }
      }
      /* simulate the simplex solver output */
      if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
      {  xprintf("~%6d: obj = %17.9e  infeas = %10.3e\n", P->it_cnt,
            P->obj_val, parm->meth == GLP_PRIMAL ? p_infeas : d_infeas);
      }
      if (parm->msg_lev >= GLP_MSG_ALL && parm->out_dly == 0)
      {  if (P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS)
            xprintf("OPTIMAL SOLUTION FOUND\n");
         else if (P->pbs_stat == GLP_NOFEAS)
            xprintf("PROBLEM HAS NO FEASIBLE SOLUTION\n");
         else if (parm->meth == GLP_PRIMAL)
            xprintf("PROBLEM HAS UNBOUNDED SOLUTION\n");
         else
            xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
      }
      return;
}

static int solve_lp(glp_prob *P, const glp_smcp *parm)
{     /* solve LP directly without using the preprocessor */
      int ret;
      if (!glp_bf_exists(P))
      {  ret = glp_factorize(P);
         if (ret == 0)
            ;
         else if (ret == GLP_EBADB)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_simplex: initial basis is invalid\n");
         }
         else if (ret == GLP_ESING)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_simplex: initial basis is singular\n");
         }
         else if (ret == GLP_ECOND)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf(
                  "glp_simplex: initial basis is ill-conditioned\n");
         }
         else
            xassert(ret != ret);
         if (ret != 0) goto done;
      }
      if (parm->meth == GLP_PRIMAL)
         ret = spx_primal(P, parm);
      else if (parm->meth == GLP_DUALP)
      {  ret = spx_dual(P, parm);
         if (ret == GLP_EFAIL && P->valid)
            ret = spx_primal(P, parm);
      }
      else if (parm->meth == GLP_DUAL)
         ret = spx_dual(P, parm);
      else
         xassert(parm != parm);
done: return ret;
}

static int preprocess_and_solve_lp(glp_prob *P, const glp_smcp *parm)
{     /* solve LP using the preprocessor */
      NPP *npp;
      glp_prob *lp = NULL;
      glp_bfcp bfcp;
      int ret;
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Preprocessing...\n");
      /* create preprocessor workspace */
      npp = npp_create_wksp();
      /* load original problem into the preprocessor workspace */
      npp_load_prob(npp, P, GLP_OFF, GLP_SOL, GLP_OFF);
      /* process LP prior to applying primal/dual simplex method */
      ret = npp_simplex(npp, parm);
      if (ret == 0)
         ;
      else if (ret == GLP_ENOPFS)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
      }
      else if (ret == GLP_ENODFS)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
      }
      else
         xassert(ret != ret);
      if (ret != 0) goto done;
      /* build transformed LP */
      lp = glp_create_prob();
      npp_build_prob(npp, lp);
      /* if the transformed LP is empty, it has empty solution, which
         is optimal */
      if (lp->m == 0 && lp->n == 0)
      {  lp->pbs_stat = lp->dbs_stat = GLP_FEAS;
         lp->obj_val = lp->c0;
         if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
         {  xprintf("~%6d: obj = %17.9e  infeas = %10.3e\n", P->it_cnt,
               lp->obj_val, 0.0);
         }
         if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("OPTIMAL SOLUTION FOUND BY LP PREPROCESSOR\n");
         goto post;
      }
      if (parm->msg_lev >= GLP_MSG_ALL)
      {  xprintf("%d row%s, %d column%s, %d non-zero%s\n",
            lp->m, lp->m == 1 ? "" : "s", lp->n, lp->n == 1 ? "" : "s",
            lp->nnz, lp->nnz == 1 ? "" : "s");
      }
      /* inherit basis factorization control parameters */
      glp_get_bfcp(P, &bfcp);
      glp_set_bfcp(lp, &bfcp);
      /* scale the transformed problem */
      {  ENV *env = get_env_ptr();
         int term_out = env->term_out;
         if (!term_out || parm->msg_lev < GLP_MSG_ALL)
            env->term_out = GLP_OFF;
         else
            env->term_out = GLP_ON;
         glp_scale_prob(lp, GLP_SF_AUTO);
         env->term_out = term_out;
      }
      /* build advanced initial basis */
      {  ENV *env = get_env_ptr();
         int term_out = env->term_out;
         if (!term_out || parm->msg_lev < GLP_MSG_ALL)
            env->term_out = GLP_OFF;
         else
            env->term_out = GLP_ON;
         glp_adv_basis(lp, 0);
         env->term_out = term_out;
      }
      /* solve the transformed LP */
      lp->it_cnt = P->it_cnt;
      ret = solve_lp(lp, parm);
      P->it_cnt = lp->it_cnt;
      /* only optimal solution can be postprocessed */
      if (!(ret == 0 && lp->pbs_stat == GLP_FEAS && lp->dbs_stat ==
            GLP_FEAS))
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_simplex: unable to recover undefined or non-op"
               "timal solution\n");
         if (ret == 0)
         {  if (lp->pbs_stat == GLP_NOFEAS)
               ret = GLP_ENOPFS;
            else if (lp->dbs_stat == GLP_NOFEAS)
               ret = GLP_ENODFS;
            else
               xassert(lp != lp);
         }
         goto done;
      }
post: /* postprocess solution from the transformed LP */
      npp_postprocess(npp, lp);
      /* the transformed LP is no longer needed */
      glp_delete_prob(lp), lp = NULL;
      /* store solution to the original problem */
      npp_unload_sol(npp, P);
      /* the original LP has been successfully solved */
      ret = 0;
done: /* delete the transformed LP, if it exists */
      if (lp != NULL) glp_delete_prob(lp);
      /* delete preprocessor workspace */
      npp_delete_wksp(npp);
      return ret;
}

int glp_simplex(glp_prob *P, const glp_smcp *parm)
{     /* solve LP problem with the simplex method */
      glp_smcp _parm;
      int i, j, ret;
      /* check problem object */
#if 0 /* 04/IV-2016 */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_simplex: P = %p; invalid problem object\n", P);
#endif
      if (P->tree != NULL && P->tree->reason != 0)
         xerror("glp_simplex: operation not allowed\n");
      /* check control parameters */
      if (parm == NULL)
         parm = &_parm, glp_init_smcp((glp_smcp *)parm);
      if (!(parm->msg_lev == GLP_MSG_OFF ||
            parm->msg_lev == GLP_MSG_ERR ||
            parm->msg_lev == GLP_MSG_ON  ||
            parm->msg_lev == GLP_MSG_ALL ||
            parm->msg_lev == GLP_MSG_DBG))
         xerror("glp_simplex: msg_lev = %d; invalid parameter\n",
            parm->msg_lev);
      if (!(parm->meth == GLP_PRIMAL ||
            parm->meth == GLP_DUALP  ||
            parm->meth == GLP_DUAL))
         xerror("glp_simplex: meth = %d; invalid parameter\n",
            parm->meth);
      if (!(parm->pricing == GLP_PT_STD ||
            parm->pricing == GLP_PT_PSE))
         xerror("glp_simplex: pricing = %d; invalid parameter\n",
            parm->pricing);
      if (!(parm->r_test == GLP_RT_STD ||
#if 1 /* 16/III-2016 */
            parm->r_test == GLP_RT_FLIP ||
#endif
            parm->r_test == GLP_RT_HAR))
         xerror("glp_simplex: r_test = %d; invalid parameter\n",
            parm->r_test);
      if (!(0.0 < parm->tol_bnd && parm->tol_bnd < 1.0))
         xerror("glp_simplex: tol_bnd = %g; invalid parameter\n",
            parm->tol_bnd);
      if (!(0.0 < parm->tol_dj && parm->tol_dj < 1.0))
         xerror("glp_simplex: tol_dj = %g; invalid parameter\n",
            parm->tol_dj);
      if (!(0.0 < parm->tol_piv && parm->tol_piv < 1.0))
         xerror("glp_simplex: tol_piv = %g; invalid parameter\n",
            parm->tol_piv);
      if (parm->it_lim < 0)
         xerror("glp_simplex: it_lim = %d; invalid parameter\n",
            parm->it_lim);
      if (parm->tm_lim < 0)
         xerror("glp_simplex: tm_lim = %d; invalid parameter\n",
            parm->tm_lim);
#if 0 /* 15/VII-2017 */
      if (parm->out_frq < 1)
#else
      if (parm->out_frq < 0)
#endif
         xerror("glp_simplex: out_frq = %d; invalid parameter\n",
            parm->out_frq);
      if (parm->out_dly < 0)
         xerror("glp_simplex: out_dly = %d; invalid parameter\n",
            parm->out_dly);
      if (!(parm->presolve == GLP_ON || parm->presolve == GLP_OFF))
         xerror("glp_simplex: presolve = %d; invalid parameter\n",
            parm->presolve);
#if 1 /* 11/VII-2017 */
      if (!(parm->excl == GLP_ON || parm->excl == GLP_OFF))
         xerror("glp_simplex: excl = %d; invalid parameter\n",
            parm->excl);
      if (!(parm->shift == GLP_ON || parm->shift == GLP_OFF))
         xerror("glp_simplex: shift = %d; invalid parameter\n",
            parm->shift);
      if (!(parm->aorn == GLP_USE_AT || parm->aorn == GLP_USE_NT))
         xerror("glp_simplex: aorn = %d; invalid parameter\n",
            parm->aorn);
#endif
      /* basic solution is currently undefined */
      P->pbs_stat = P->dbs_stat = GLP_UNDEF;
      P->obj_val = 0.0;
      P->some = 0;
      /* check bounds of double-bounded variables */
      for (i = 1; i <= P->m; i++)
      {  GLPROW *row = P->row[i];
         if (row->type == GLP_DB && row->lb >= row->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_simplex: row %d: lb = %g, ub = %g; incorrec"
                  "t bounds\n", i, row->lb, row->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if (col->type == GLP_DB && col->lb >= col->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_simplex: column %d: lb = %g, ub = %g; incor"
                  "rect bounds\n", j, col->lb, col->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      /* solve LP problem */
      if (parm->msg_lev >= GLP_MSG_ALL)
      {  xprintf("GLPK Simplex Optimizer %s\n", glp_version());
         xprintf("%d row%s, %d column%s, %d non-zero%s\n",
            P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
            P->nnz, P->nnz == 1 ? "" : "s");
      }
      if (P->nnz == 0)
         trivial_lp(P, parm), ret = 0;
      else if (!parm->presolve)
         ret = solve_lp(P, parm);
      else
         ret = preprocess_and_solve_lp(P, parm);
done: /* return to the application program */
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_init_smcp - initialize simplex method control parameters
*
*  SYNOPSIS
*
*  void glp_init_smcp(glp_smcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_init_smcp initializes control parameters, which are
*  used by the simplex solver, with default values.
*
*  Default values of the control parameters are stored in a glp_smcp
*  structure, which the parameter parm points to. */

void glp_init_smcp(glp_smcp *parm)
{     parm->msg_lev = GLP_MSG_ALL;
      parm->meth = GLP_PRIMAL;
      parm->pricing = GLP_PT_PSE;
      parm->r_test = GLP_RT_HAR;
      parm->tol_bnd = 1e-7;
      parm->tol_dj = 1e-7;
#if 0 /* 07/XI-2015 */
      parm->tol_piv = 1e-10;
#else
      parm->tol_piv = 1e-9;
#endif
      parm->obj_ll = -DBL_MAX;
      parm->obj_ul = +DBL_MAX;
      parm->it_lim = INT_MAX;
      parm->tm_lim = INT_MAX;
#if 0 /* 15/VII-2017 */
      parm->out_frq = 500;
#else
      parm->out_frq = 5000; /* 5 seconds */
#endif
      parm->out_dly = 0;
      parm->presolve = GLP_OFF;
#if 1 /* 11/VII-2017 */
      parm->excl = GLP_ON;
      parm->shift = GLP_ON;
      parm->aorn = GLP_USE_NT;
#endif
      return;
}

/***********************************************************************
*  NAME
*
*  glp_get_status - retrieve generic status of basic solution
*
*  SYNOPSIS
*
*  int glp_get_status(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_status reports the generic status of the basic
*  solution for the specified problem object as follows:
*
*  GLP_OPT    - solution is optimal;
*  GLP_FEAS   - solution is feasible;
*  GLP_INFEAS - solution is infeasible;
*  GLP_NOFEAS - problem has no feasible solution;
*  GLP_UNBND  - problem has unbounded solution;
*  GLP_UNDEF  - solution is undefined. */

int glp_get_status(glp_prob *lp)
{     int status;
      status = glp_get_prim_stat(lp);
      switch (status)
      {  case GLP_FEAS:
            switch (glp_get_dual_stat(lp))
            {  case GLP_FEAS:
                  status = GLP_OPT;
                  break;
               case GLP_NOFEAS:
                  status = GLP_UNBND;
                  break;
               case GLP_UNDEF:
               case GLP_INFEAS:
                  status = status;
                  break;
               default:
                  xassert(lp != lp);
            }
            break;
         case GLP_UNDEF:
         case GLP_INFEAS:
         case GLP_NOFEAS:
            status = status;
            break;
         default:
            xassert(lp != lp);
      }
      return status;
}

/***********************************************************************
*  NAME
*
*  glp_get_prim_stat - retrieve status of primal basic solution
*
*  SYNOPSIS
*
*  int glp_get_prim_stat(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_prim_stat reports the status of the primal basic
*  solution for the specified problem object as follows:
*
*  GLP_UNDEF  - primal solution is undefined;
*  GLP_FEAS   - primal solution is feasible;
*  GLP_INFEAS - primal solution is infeasible;
*  GLP_NOFEAS - no primal feasible solution exists. */

int glp_get_prim_stat(glp_prob *lp)
{     int pbs_stat = lp->pbs_stat;
      return pbs_stat;
}

/***********************************************************************
*  NAME
*
*  glp_get_dual_stat - retrieve status of dual basic solution
*
*  SYNOPSIS
*
*  int glp_get_dual_stat(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_dual_stat reports the status of the dual basic
*  solution for the specified problem object as follows:
*
*  GLP_UNDEF  - dual solution is undefined;
*  GLP_FEAS   - dual solution is feasible;
*  GLP_INFEAS - dual solution is infeasible;
*  GLP_NOFEAS - no dual feasible solution exists. */

int glp_get_dual_stat(glp_prob *lp)
{     int dbs_stat = lp->dbs_stat;
      return dbs_stat;
}

/***********************************************************************
*  NAME
*
*  glp_get_obj_val - retrieve objective value (basic solution)
*
*  SYNOPSIS
*
*  double glp_get_obj_val(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_obj_val returns value of the objective function
*  for basic solution. */

double glp_get_obj_val(glp_prob *lp)
{     /*struct LPXCPS *cps = lp->cps;*/
      double z;
      z = lp->obj_val;
      /*if (cps->round && fabs(z) < 1e-9) z = 0.0;*/
      return z;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_stat - retrieve row status
*
*  SYNOPSIS
*
*  int glp_get_row_stat(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_stat returns current status assigned to the
*  auxiliary variable associated with i-th row as follows:
*
*  GLP_BS - basic variable;
*  GLP_NL - non-basic variable on its lower bound;
*  GLP_NU - non-basic variable on its upper bound;
*  GLP_NF - non-basic free (unbounded) variable;
*  GLP_NS - non-basic fixed variable. */

int glp_get_row_stat(glp_prob *lp, int i)
{     if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_stat: i = %d; row number out of range\n",
            i);
      return lp->row[i]->stat;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_prim - retrieve row primal value (basic solution)
*
*  SYNOPSIS
*
*  double glp_get_row_prim(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_prim returns primal value of the auxiliary
*  variable associated with i-th row. */

double glp_get_row_prim(glp_prob *lp, int i)
{     /*struct LPXCPS *cps = lp->cps;*/
      double prim;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_prim: i = %d; row number out of range\n",
            i);
      prim = lp->row[i]->prim;
      /*if (cps->round && fabs(prim) < 1e-9) prim = 0.0;*/
      return prim;
}

/***********************************************************************
*  NAME
*
*  glp_get_row_dual - retrieve row dual value (basic solution)
*
*  SYNOPSIS
*
*  double glp_get_row_dual(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_dual returns dual value (i.e. reduced cost)
*  of the auxiliary variable associated with i-th row. */

double glp_get_row_dual(glp_prob *lp, int i)
{     /*struct LPXCPS *cps = lp->cps;*/
      double dual;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_dual: i = %d; row number out of range\n",
            i);
      dual = lp->row[i]->dual;
      /*if (cps->round && fabs(dual) < 1e-9) dual = 0.0;*/
      return dual;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_stat - retrieve column status
*
*  SYNOPSIS
*
*  int glp_get_col_stat(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_stat returns current status assigned to the
*  structural variable associated with j-th column as follows:
*
*  GLP_BS - basic variable;
*  GLP_NL - non-basic variable on its lower bound;
*  GLP_NU - non-basic variable on its upper bound;
*  GLP_NF - non-basic free (unbounded) variable;
*  GLP_NS - non-basic fixed variable. */

int glp_get_col_stat(glp_prob *lp, int j)
{     if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_stat: j = %d; column number out of range\n"
            , j);
      return lp->col[j]->stat;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_prim - retrieve column primal value (basic solution)
*
*  SYNOPSIS
*
*  double glp_get_col_prim(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_prim returns primal value of the structural
*  variable associated with j-th column. */

double glp_get_col_prim(glp_prob *lp, int j)
{     /*struct LPXCPS *cps = lp->cps;*/
      double prim;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_prim: j = %d; column number out of range\n"
            , j);
      prim = lp->col[j]->prim;
      /*if (cps->round && fabs(prim) < 1e-9) prim = 0.0;*/
      return prim;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_dual - retrieve column dual value (basic solution)
*
*  SYNOPSIS
*
*  double glp_get_col_dual(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_dual returns dual value (i.e. reduced cost)
*  of the structural variable associated with j-th column. */

double glp_get_col_dual(glp_prob *lp, int j)
{     /*struct LPXCPS *cps = lp->cps;*/
      double dual;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_dual: j = %d; column number out of range\n"
            , j);
      dual = lp->col[j]->dual;
      /*if (cps->round && fabs(dual) < 1e-9) dual = 0.0;*/
      return dual;
}

/***********************************************************************
*  NAME
*
*  glp_get_unbnd_ray - determine variable causing unboundedness
*
*  SYNOPSIS
*
*  int glp_get_unbnd_ray(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_get_unbnd_ray returns the number k of a variable,
*  which causes primal or dual unboundedness. If 1 <= k <= m, it is
*  k-th auxiliary variable, and if m+1 <= k <= m+n, it is (k-m)-th
*  structural variable, where m is the number of rows, n is the number
*  of columns in the problem object. If such variable is not defined,
*  the routine returns 0.
*
*  COMMENTS
*
*  If it is not exactly known which version of the simplex solver
*  detected unboundedness, i.e. whether the unboundedness is primal or
*  dual, it is sufficient to check the status of the variable reported
*  with the routine glp_get_row_stat or glp_get_col_stat. If the
*  variable is non-basic, the unboundedness is primal, otherwise, if
*  the variable is basic, the unboundedness is dual (the latter case
*  means that the problem has no primal feasible dolution). */

int glp_get_unbnd_ray(glp_prob *lp)
{     int k;
      k = lp->some;
      xassert(k >= 0);
      if (k > lp->m + lp->n) k = 0;
      return k;
}

#if 1 /* 08/VIII-2013 */
int glp_get_it_cnt(glp_prob *P)
{     /* get simplex solver iteration count */
      return P->it_cnt;
}
#endif

#if 1 /* 08/VIII-2013 */
void glp_set_it_cnt(glp_prob *P, int it_cnt)
{     /* set simplex solver iteration count */
      P->it_cnt = it_cnt;
      return;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi07.c0000644000175100001710000003611000000000000024774 0ustar00runnerdocker00000000000000/* glpapi07.c (exact simplex solver) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "draft.h"
#include "glpssx.h"
#include "misc.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_exact - solve LP problem in exact arithmetic
*
*  SYNOPSIS
*
*  int glp_exact(glp_prob *lp, const glp_smcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_exact is a tentative implementation of the primal
*  two-phase simplex method based on exact (rational) arithmetic. It is
*  similar to the routine glp_simplex, however, for all internal
*  computations it uses arithmetic of rational numbers, which is exact
*  in mathematical sense, i.e. free of round-off errors unlike floating
*  point arithmetic.
*
*  Note that the routine glp_exact uses inly two control parameters
*  passed in the structure glp_smcp, namely, it_lim and tm_lim.
*
*  RETURNS
*
*  0  The LP problem instance has been successfully solved. This code
*     does not necessarily mean that the solver has found optimal
*     solution. It only means that the solution process was successful.
*
*  GLP_EBADB
*     Unable to start the search, because the initial basis specified
*     in the problem object is invalid--the number of basic (auxiliary
*     and structural) variables is not the same as the number of rows in
*     the problem object.
*
*  GLP_ESING
*     Unable to start the search, because the basis matrix correspodning
*     to the initial basis is exactly singular.
*
*  GLP_EBOUND
*     Unable to start the search, because some double-bounded variables
*     have incorrect bounds.
*
*  GLP_EFAIL
*     The problem has no rows/columns.
*
*  GLP_EITLIM
*     The search was prematurely terminated, because the simplex
*     iteration limit has been exceeded.
*
*  GLP_ETMLIM
*     The search was prematurely terminated, because the time limit has
*     been exceeded. */

static void set_d_eps(mpq_t x, double val)
{     /* convert double val to rational x obtaining a more adequate
         fraction than provided by mpq_set_d due to allowing a small
         approximation error specified by a given relative tolerance;
         for example, mpq_set_d would give the following
         1/3 ~= 0.333333333333333314829616256247391... ->
             -> 6004799503160661/18014398509481984
         while this routine gives exactly 1/3 */
      int s, n, j;
      double f, p, q, eps = 1e-9;
      mpq_t temp;
      xassert(-DBL_MAX <= val && val <= +DBL_MAX);
#if 1 /* 30/VII-2008 */
      if (val == floor(val))
      {  /* if val is integral, do not approximate */
         mpq_set_d(x, val);
         goto done;
      }
#endif
      if (val > 0.0)
         s = +1;
      else if (val < 0.0)
         s = -1;
      else
      {  mpq_set_si(x, 0, 1);
         goto done;
      }
      f = frexp(fabs(val), &n);
      /* |val| = f * 2^n, where 0.5 <= f < 1.0 */
      fp2rat(f, 0.1 * eps, &p, &q);
      /* f ~= p / q, where p and q are integers */
      mpq_init(temp);
      mpq_set_d(x, p);
      mpq_set_d(temp, q);
      mpq_div(x, x, temp);
      mpq_set_si(temp, 1, 1);
      for (j = 1; j <= abs(n); j++)
         mpq_add(temp, temp, temp);
      if (n > 0)
         mpq_mul(x, x, temp);
      else if (n < 0)
         mpq_div(x, x, temp);
      mpq_clear(temp);
      if (s < 0) mpq_neg(x, x);
      /* check that the desired tolerance has been attained */
      xassert(fabs(val - mpq_get_d(x)) <= eps * (1.0 + fabs(val)));
done: return;
}

static void load_data(SSX *ssx, glp_prob *lp)
{     /* load LP problem data into simplex solver workspace */
      int m = ssx->m;
      int n = ssx->n;
      int nnz = ssx->A_ptr[n+1]-1;
      int j, k, type, loc, len, *ind;
      double lb, ub, coef, *val;
      xassert(lp->m == m);
      xassert(lp->n == n);
      xassert(lp->nnz == nnz);
      /* types and bounds of rows and columns */
      for (k = 1; k <= m+n; k++)
      {  if (k <= m)
         {  type = lp->row[k]->type;
            lb = lp->row[k]->lb;
            ub = lp->row[k]->ub;
         }
         else
         {  type = lp->col[k-m]->type;
            lb = lp->col[k-m]->lb;
            ub = lp->col[k-m]->ub;
         }
         switch (type)
         {  case GLP_FR: type = SSX_FR; break;
            case GLP_LO: type = SSX_LO; break;
            case GLP_UP: type = SSX_UP; break;
            case GLP_DB: type = SSX_DB; break;
            case GLP_FX: type = SSX_FX; break;
            default: xassert(type != type);
         }
         ssx->type[k] = type;
         set_d_eps(ssx->lb[k], lb);
         set_d_eps(ssx->ub[k], ub);
      }
      /* optimization direction */
      switch (lp->dir)
      {  case GLP_MIN: ssx->dir = SSX_MIN; break;
         case GLP_MAX: ssx->dir = SSX_MAX; break;
         default: xassert(lp != lp);
      }
      /* objective coefficients */
      for (k = 0; k <= m+n; k++)
      {  if (k == 0)
            coef = lp->c0;
         else if (k <= m)
            coef = 0.0;
         else
            coef = lp->col[k-m]->coef;
         set_d_eps(ssx->coef[k], coef);
      }
      /* constraint coefficients */
      ind = xcalloc(1+m, sizeof(int));
      val = xcalloc(1+m, sizeof(double));
      loc = 0;
      for (j = 1; j <= n; j++)
      {  ssx->A_ptr[j] = loc+1;
         len = glp_get_mat_col(lp, j, ind, val);
         for (k = 1; k <= len; k++)
         {  loc++;
            ssx->A_ind[loc] = ind[k];
            set_d_eps(ssx->A_val[loc], val[k]);
         }
      }
      xassert(loc == nnz);
      xfree(ind);
      xfree(val);
      return;
}

static int load_basis(SSX *ssx, glp_prob *lp)
{     /* load current LP basis into simplex solver workspace */
      int m = ssx->m;
      int n = ssx->n;
      int *type = ssx->type;
      int *stat = ssx->stat;
      int *Q_row = ssx->Q_row;
      int *Q_col = ssx->Q_col;
      int i, j, k;
      xassert(lp->m == m);
      xassert(lp->n == n);
      /* statuses of rows and columns */
      for (k = 1; k <= m+n; k++)
      {  if (k <= m)
            stat[k] = lp->row[k]->stat;
         else
            stat[k] = lp->col[k-m]->stat;
         switch (stat[k])
         {  case GLP_BS:
               stat[k] = SSX_BS;
               break;
            case GLP_NL:
               stat[k] = SSX_NL;
               xassert(type[k] == SSX_LO || type[k] == SSX_DB);
               break;
            case GLP_NU:
               stat[k] = SSX_NU;
               xassert(type[k] == SSX_UP || type[k] == SSX_DB);
               break;
            case GLP_NF:
               stat[k] = SSX_NF;
               xassert(type[k] == SSX_FR);
               break;
            case GLP_NS:
               stat[k] = SSX_NS;
               xassert(type[k] == SSX_FX);
               break;
            default:
               xassert(stat != stat);
         }
      }
      /* build permutation matix Q */
      i = j = 0;
      for (k = 1; k <= m+n; k++)
      {  if (stat[k] == SSX_BS)
         {  i++;
            if (i > m) return 1;
            Q_row[k] = i, Q_col[i] = k;
         }
         else
         {  j++;
            if (j > n) return 1;
            Q_row[k] = m+j, Q_col[m+j] = k;
         }
      }
      xassert(i == m && j == n);
      return 0;
}

int glp_exact(glp_prob *lp, const glp_smcp *parm)
{     glp_smcp _parm;
      SSX *ssx;
      int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int i, j, k, type, pst, dst, ret, stat;
      double lb, ub, prim, dual, sum;
      if (parm == NULL)
         parm = &_parm, glp_init_smcp((glp_smcp *)parm);
      /* check control parameters */
#if 1 /* 25/XI-2017 */
      switch (parm->msg_lev)
      {  case GLP_MSG_OFF:
         case GLP_MSG_ERR:
         case GLP_MSG_ON:
         case GLP_MSG_ALL:
         case GLP_MSG_DBG:
            break;
         default:
            xerror("glp_exact: msg_lev = %d; invalid parameter\n",
               parm->msg_lev);
      }
#endif
      if (parm->it_lim < 0)
         xerror("glp_exact: it_lim = %d; invalid parameter\n",
            parm->it_lim);
      if (parm->tm_lim < 0)
         xerror("glp_exact: tm_lim = %d; invalid parameter\n",
            parm->tm_lim);
      /* the problem must have at least one row and one column */
      if (!(m > 0 && n > 0))
#if 0 /* 25/XI-2017 */
      {  xprintf("glp_exact: problem has no rows/columns\n");
#else
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_exact: problem has no rows/columns\n");
#endif
         return GLP_EFAIL;
      }
#if 1
      /* basic solution is currently undefined */
      lp->pbs_stat = lp->dbs_stat = GLP_UNDEF;
      lp->obj_val = 0.0;
      lp->some = 0;
#endif
      /* check that all double-bounded variables have correct bounds */
      for (k = 1; k <= m+n; k++)
      {  if (k <= m)
         {  type = lp->row[k]->type;
            lb = lp->row[k]->lb;
            ub = lp->row[k]->ub;
         }
         else
         {  type = lp->col[k-m]->type;
            lb = lp->col[k-m]->lb;
            ub = lp->col[k-m]->ub;
         }
         if (type == GLP_DB && lb >= ub)
#if 0 /* 25/XI-2017 */
         {  xprintf("glp_exact: %s %d has invalid bounds\n",
               k <= m ? "row" : "column", k <= m ? k : k-m);
#else
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_exact: %s %d has invalid bounds\n",
                  k <= m ? "row" : "column", k <= m ? k : k-m);
#endif
            return GLP_EBOUND;
         }
      }
      /* create the simplex solver workspace */
#if 1 /* 25/XI-2017 */
      if (parm->msg_lev >= GLP_MSG_ALL)
      {
#endif
      xprintf("glp_exact: %d rows, %d columns, %d non-zeros\n",
         m, n, nnz);
#ifdef HAVE_GMP
      xprintf("GNU MP bignum library is being used\n");
#else
      xprintf("GLPK bignum module is being used\n");
      xprintf("(Consider installing GNU MP to attain a much better perf"
         "ormance.)\n");
#endif
#if 1 /* 25/XI-2017 */
      }
#endif
      ssx = ssx_create(m, n, nnz);
      /* load LP problem data into the workspace */
      load_data(ssx, lp);
      /* load current LP basis into the workspace */
      if (load_basis(ssx, lp))
#if 0 /* 25/XI-2017 */
      {  xprintf("glp_exact: initial LP basis is invalid\n");
#else
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_exact: initial LP basis is invalid\n");
#endif
         ret = GLP_EBADB;
         goto done;
      }
#if 0
      /* inherit some control parameters from the LP object */
      ssx->it_lim = lpx_get_int_parm(lp, LPX_K_ITLIM);
      ssx->it_cnt = lpx_get_int_parm(lp, LPX_K_ITCNT);
      ssx->tm_lim = lpx_get_real_parm(lp, LPX_K_TMLIM);
#else
#if 1 /* 25/XI-2017 */
      ssx->msg_lev = parm->msg_lev;
#endif
      ssx->it_lim = parm->it_lim;
      ssx->it_cnt = lp->it_cnt;
      ssx->tm_lim = (double)parm->tm_lim / 1000.0;
#endif
      ssx->out_frq = 5.0;
      ssx->tm_beg = xtime();
#if 0 /* 10/VI-2013 */
      ssx->tm_lag = xlset(0);
#else
      ssx->tm_lag = 0.0;
#endif
      /* solve LP */
      ret = ssx_driver(ssx);
#if 0
      /* copy back some statistics to the LP object */
      lpx_set_int_parm(lp, LPX_K_ITLIM, ssx->it_lim);
      lpx_set_int_parm(lp, LPX_K_ITCNT, ssx->it_cnt);
      lpx_set_real_parm(lp, LPX_K_TMLIM, ssx->tm_lim);
#else
      lp->it_cnt = ssx->it_cnt;
#endif
      /* analyze the return code */
      switch (ret)
      {  case 0:
            /* optimal solution found */
            ret = 0;
            pst = dst = GLP_FEAS;
            break;
         case 1:
            /* problem has no feasible solution */
            ret = 0;
            pst = GLP_NOFEAS, dst = GLP_INFEAS;
            break;
         case 2:
            /* problem has unbounded solution */
            ret = 0;
            pst = GLP_FEAS, dst = GLP_NOFEAS;
#if 1
            xassert(1 <= ssx->q && ssx->q <= n);
            lp->some = ssx->Q_col[m + ssx->q];
            xassert(1 <= lp->some && lp->some <= m+n);
#endif
            break;
         case 3:
            /* iteration limit exceeded (phase I) */
            ret = GLP_EITLIM;
            pst = dst = GLP_INFEAS;
            break;
         case 4:
            /* iteration limit exceeded (phase II) */
            ret = GLP_EITLIM;
            pst = GLP_FEAS, dst = GLP_INFEAS;
            break;
         case 5:
            /* time limit exceeded (phase I) */
            ret = GLP_ETMLIM;
            pst = dst = GLP_INFEAS;
            break;
         case 6:
            /* time limit exceeded (phase II) */
            ret = GLP_ETMLIM;
            pst = GLP_FEAS, dst = GLP_INFEAS;
            break;
         case 7:
            /* initial basis matrix is singular */
            ret = GLP_ESING;
            goto done;
         default:
            xassert(ret != ret);
      }
      /* store final basic solution components into LP object */
      lp->pbs_stat = pst;
      lp->dbs_stat = dst;
      sum = lp->c0;
      for (k = 1; k <= m+n; k++)
      {  if (ssx->stat[k] == SSX_BS)
         {  i = ssx->Q_row[k]; /* x[k] = xB[i] */
            xassert(1 <= i && i <= m);
            stat = GLP_BS;
            prim = mpq_get_d(ssx->bbar[i]);
            dual = 0.0;
         }
         else
         {  j = ssx->Q_row[k] - m; /* x[k] = xN[j] */
            xassert(1 <= j && j <= n);
            switch (ssx->stat[k])
            {  case SSX_NF:
                  stat = GLP_NF;
                  prim = 0.0;
                  break;
               case SSX_NL:
                  stat = GLP_NL;
                  prim = mpq_get_d(ssx->lb[k]);
                  break;
               case SSX_NU:
                  stat = GLP_NU;
                  prim = mpq_get_d(ssx->ub[k]);
                  break;
               case SSX_NS:
                  stat = GLP_NS;
                  prim = mpq_get_d(ssx->lb[k]);
                  break;
               default:
                  xassert(ssx != ssx);
            }
            dual = mpq_get_d(ssx->cbar[j]);
         }
         if (k <= m)
         {  glp_set_row_stat(lp, k, stat);
            lp->row[k]->prim = prim;
            lp->row[k]->dual = dual;
         }
         else
         {  glp_set_col_stat(lp, k-m, stat);
            lp->col[k-m]->prim = prim;
            lp->col[k-m]->dual = dual;
            sum += lp->col[k-m]->coef * prim;
         }
      }
      lp->obj_val = sum;
done: /* delete the simplex solver workspace */
      ssx_delete(ssx);
#if 1 /* 23/XI-2015 */
      xassert(gmp_pool_count() == 0);
      gmp_free_mem();
#endif
      /* return to the application program */
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi08.c0000644000175100001710000003004200000000000024773 0ustar00runnerdocker00000000000000/* glpapi08.c (interior-point method routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpipm.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  glp_interior - solve LP problem with the interior-point method
*
*  SYNOPSIS
*
*  int glp_interior(glp_prob *P, const glp_iptcp *parm);
*
*  The routine glp_interior is a driver to the LP solver based on the
*  interior-point method.
*
*  The interior-point solver has a set of control parameters. Values of
*  the control parameters can be passed in a structure glp_iptcp, which
*  the parameter parm points to.
*
*  Currently this routine implements an easy variant of the primal-dual
*  interior-point method based on Mehrotra's technique.
*
*  This routine transforms the original LP problem to an equivalent LP
*  problem in the standard formulation (all constraints are equalities,
*  all variables are non-negative), calls the routine ipm_main to solve
*  the transformed problem, and then transforms an obtained solution to
*  the solution of the original problem.
*
*  RETURNS
*
*  0  The LP problem instance has been successfully solved. This code
*     does not necessarily mean that the solver has found optimal
*     solution. It only means that the solution process was successful.
*
*  GLP_EFAIL
*     The problem has no rows/columns.
*
*  GLP_ENOCVG
*     Very slow convergence or divergence.
*
*  GLP_EITLIM
*     Iteration limit exceeded.
*
*  GLP_EINSTAB
*     Numerical instability on solving Newtonian system. */

static void transform(NPP *npp)
{     /* transform LP to the standard formulation */
      NPPROW *row, *prev_row;
      NPPCOL *col, *prev_col;
      for (row = npp->r_tail; row != NULL; row = prev_row)
      {  prev_row = row->prev;
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
            npp_free_row(npp, row);
         else if (row->lb == -DBL_MAX)
            npp_leq_row(npp, row);
         else if (row->ub == +DBL_MAX)
            npp_geq_row(npp, row);
         else if (row->lb != row->ub)
         {  if (fabs(row->lb) < fabs(row->ub))
               npp_geq_row(npp, row);
            else
               npp_leq_row(npp, row);
         }
      }
      for (col = npp->c_tail; col != NULL; col = prev_col)
      {  prev_col = col->prev;
         if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
            npp_free_col(npp, col);
         else if (col->lb == -DBL_MAX)
            npp_ubnd_col(npp, col);
         else if (col->ub == +DBL_MAX)
         {  if (col->lb != 0.0)
               npp_lbnd_col(npp, col);
         }
         else if (col->lb != col->ub)
         {  if (fabs(col->lb) < fabs(col->ub))
            {  if (col->lb != 0.0)
                  npp_lbnd_col(npp, col);
            }
            else
               npp_ubnd_col(npp, col);
            npp_dbnd_col(npp, col);
         }
         else
            npp_fixed_col(npp, col);
      }
      for (row = npp->r_head; row != NULL; row = row->next)
         xassert(row->lb == row->ub);
      for (col = npp->c_head; col != NULL; col = col->next)
         xassert(col->lb == 0.0 && col->ub == +DBL_MAX);
      return;
}

int glp_interior(glp_prob *P, const glp_iptcp *parm)
{     glp_iptcp _parm;
      GLPROW *row;
      GLPCOL *col;
      NPP *npp = NULL;
      glp_prob *prob = NULL;
      int i, j, ret;
      /* check control parameters */
      if (parm == NULL)
         glp_init_iptcp(&_parm), parm = &_parm;
      if (!(parm->msg_lev == GLP_MSG_OFF ||
            parm->msg_lev == GLP_MSG_ERR ||
            parm->msg_lev == GLP_MSG_ON  ||
            parm->msg_lev == GLP_MSG_ALL))
         xerror("glp_interior: msg_lev = %d; invalid parameter\n",
            parm->msg_lev);
      if (!(parm->ord_alg == GLP_ORD_NONE ||
            parm->ord_alg == GLP_ORD_QMD ||
            parm->ord_alg == GLP_ORD_AMD ||
            parm->ord_alg == GLP_ORD_SYMAMD))
         xerror("glp_interior: ord_alg = %d; invalid parameter\n",
            parm->ord_alg);
      /* interior-point solution is currently undefined */
      P->ipt_stat = GLP_UNDEF;
      P->ipt_obj = 0.0;
      /* check bounds of double-bounded variables */
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type == GLP_DB && row->lb >= row->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_interior: row %d: lb = %g, ub = %g; incorre"
                  "ct bounds\n", i, row->lb, row->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->type == GLP_DB && col->lb >= col->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_interior: column %d: lb = %g, ub = %g; inco"
                  "rrect bounds\n", j, col->lb, col->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      /* transform LP to the standard formulation */
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Original LP has %d row(s), %d column(s), and %d non-z"
            "ero(s)\n", P->m, P->n, P->nnz);
      npp = npp_create_wksp();
      npp_load_prob(npp, P, GLP_OFF, GLP_IPT, GLP_ON);
      transform(npp);
      prob = glp_create_prob();
      npp_build_prob(npp, prob);
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Working LP has %d row(s), %d column(s), and %d non-ze"
            "ro(s)\n", prob->m, prob->n, prob->nnz);
#if 1
      /* currently empty problem cannot be solved */
      if (!(prob->m > 0 && prob->n > 0))
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_interior: unable to solve empty problem\n");
         ret = GLP_EFAIL;
         goto done;
      }
#endif
      /* scale the resultant LP */
      {  ENV *env = get_env_ptr();
         int term_out = env->term_out;
         env->term_out = GLP_OFF;
         glp_scale_prob(prob, GLP_SF_EQ);
         env->term_out = term_out;
      }
      /* warn about dense columns */
      if (parm->msg_lev >= GLP_MSG_ON && prob->m >= 200)
      {  int len, cnt = 0;
         for (j = 1; j <= prob->n; j++)
         {  len = glp_get_mat_col(prob, j, NULL, NULL);
            if ((double)len >= 0.20 * (double)prob->m) cnt++;
         }
         if (cnt == 1)
            xprintf("WARNING: PROBLEM HAS ONE DENSE COLUMN\n");
         else if (cnt > 0)
            xprintf("WARNING: PROBLEM HAS %d DENSE COLUMNS\n", cnt);
      }
      /* solve the transformed LP */
      ret = ipm_solve(prob, parm);
      /* postprocess solution from the transformed LP */
      npp_postprocess(npp, prob);
      /* and store solution to the original LP */
      npp_unload_sol(npp, P);
done: /* free working program objects */
      if (npp != NULL) npp_delete_wksp(npp);
      if (prob != NULL) glp_delete_prob(prob);
      /* return to the application program */
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_init_iptcp - initialize interior-point solver control parameters
*
*  SYNOPSIS
*
*  void glp_init_iptcp(glp_iptcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_init_iptcp initializes control parameters, which are
*  used by the interior-point solver, with default values.
*
*  Default values of the control parameters are stored in the glp_iptcp
*  structure, which the parameter parm points to. */

void glp_init_iptcp(glp_iptcp *parm)
{     parm->msg_lev = GLP_MSG_ALL;
      parm->ord_alg = GLP_ORD_AMD;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_status - retrieve status of interior-point solution
*
*  SYNOPSIS
*
*  int glp_ipt_status(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_ipt_status reports the status of solution found by
*  the interior-point solver as follows:
*
*  GLP_UNDEF  - interior-point solution is undefined;
*  GLP_OPT    - interior-point solution is optimal;
*  GLP_INFEAS - interior-point solution is infeasible;
*  GLP_NOFEAS - no feasible solution exists. */

int glp_ipt_status(glp_prob *lp)
{     int ipt_stat = lp->ipt_stat;
      return ipt_stat;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_obj_val - retrieve objective value (interior point)
*
*  SYNOPSIS
*
*  double glp_ipt_obj_val(glp_prob *lp);
*
*  RETURNS
*
*  The routine glp_ipt_obj_val returns value of the objective function
*  for interior-point solution. */

double glp_ipt_obj_val(glp_prob *lp)
{     /*struct LPXCPS *cps = lp->cps;*/
      double z;
      z = lp->ipt_obj;
      /*if (cps->round && fabs(z) < 1e-9) z = 0.0;*/
      return z;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_row_prim - retrieve row primal value (interior point)
*
*  SYNOPSIS
*
*  double glp_ipt_row_prim(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_ipt_row_prim returns primal value of the auxiliary
*  variable associated with i-th row. */

double glp_ipt_row_prim(glp_prob *lp, int i)
{     /*struct LPXCPS *cps = lp->cps;*/
      double pval;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_ipt_row_prim: i = %d; row number out of range\n",
            i);
      pval = lp->row[i]->pval;
      /*if (cps->round && fabs(pval) < 1e-9) pval = 0.0;*/
      return pval;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_row_dual - retrieve row dual value (interior point)
*
*  SYNOPSIS
*
*  double glp_ipt_row_dual(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_ipt_row_dual returns dual value (i.e. reduced cost)
*  of the auxiliary variable associated with i-th row. */

double glp_ipt_row_dual(glp_prob *lp, int i)
{     /*struct LPXCPS *cps = lp->cps;*/
      double dval;
      if (!(1 <= i && i <= lp->m))
         xerror("glp_ipt_row_dual: i = %d; row number out of range\n",
            i);
      dval = lp->row[i]->dval;
      /*if (cps->round && fabs(dval) < 1e-9) dval = 0.0;*/
      return dval;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_col_prim - retrieve column primal value (interior point)
*
*  SYNOPSIS
*
*  double glp_ipt_col_prim(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_ipt_col_prim returns primal value of the structural
*  variable associated with j-th column. */

double glp_ipt_col_prim(glp_prob *lp, int j)
{     /*struct LPXCPS *cps = lp->cps;*/
      double pval;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_ipt_col_prim: j = %d; column number out of range\n"
            , j);
      pval = lp->col[j]->pval;
      /*if (cps->round && fabs(pval) < 1e-9) pval = 0.0;*/
      return pval;
}

/***********************************************************************
*  NAME
*
*  glp_ipt_col_dual - retrieve column dual value (interior point)
*
*  SYNOPSIS
*
*  double glp_ipt_col_dual(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_ipt_col_dual returns dual value (i.e. reduced cost)
*  of the structural variable associated with j-th column. */

double glp_ipt_col_dual(glp_prob *lp, int j)
{     /*struct LPXCPS *cps = lp->cps;*/
      double dval;
      if (!(1 <= j && j <= lp->n))
         xerror("glp_ipt_col_dual: j = %d; column number out of range\n"
            , j);
      dval = lp->col[j]->dval;
      /*if (cps->round && fabs(dval) < 1e-9) dval = 0.0;*/
      return dval;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi09.c0000644000175100001710000006224100000000000025002 0ustar00runnerdocker00000000000000/* glpapi09.c (mixed integer programming routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "draft.h"
#include "env.h"
#include "ios.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  glp_set_col_kind - set (change) column kind
*
*  SYNOPSIS
*
*  void glp_set_col_kind(glp_prob *mip, int j, int kind);
*
*  DESCRIPTION
*
*  The routine glp_set_col_kind sets (changes) the kind of j-th column
*  (structural variable) as specified by the parameter kind:
*
*  GLP_CV - continuous variable;
*  GLP_IV - integer variable;
*  GLP_BV - binary variable. */

void glp_set_col_kind(glp_prob *mip, int j, int kind)
{     GLPCOL *col;
      if (!(1 <= j && j <= mip->n))
         xerror("glp_set_col_kind: j = %d; column number out of range\n"
            , j);
      col = mip->col[j];
      switch (kind)
      {  case GLP_CV:
            col->kind = GLP_CV;
            break;
         case GLP_IV:
            col->kind = GLP_IV;
            break;
         case GLP_BV:
            col->kind = GLP_IV;
            if (!(col->type == GLP_DB && col->lb == 0.0 && col->ub ==
               1.0)) glp_set_col_bnds(mip, j, GLP_DB, 0.0, 1.0);
            break;
         default:
            xerror("glp_set_col_kind: j = %d; kind = %d; invalid column"
               " kind\n", j, kind);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_kind - retrieve column kind
*
*  SYNOPSIS
*
*  int glp_get_col_kind(glp_prob *mip, int j);
*
*  RETURNS
*
*  The routine glp_get_col_kind returns the kind of j-th column, i.e.
*  the kind of corresponding structural variable, as follows:
*
*  GLP_CV - continuous variable;
*  GLP_IV - integer variable;
*  GLP_BV - binary variable */

int glp_get_col_kind(glp_prob *mip, int j)
{     GLPCOL *col;
      int kind;
      if (!(1 <= j && j <= mip->n))
         xerror("glp_get_col_kind: j = %d; column number out of range\n"
            , j);
      col = mip->col[j];
      kind = col->kind;
      switch (kind)
      {  case GLP_CV:
            break;
         case GLP_IV:
            if (col->type == GLP_DB && col->lb == 0.0 && col->ub == 1.0)
               kind = GLP_BV;
            break;
         default:
            xassert(kind != kind);
      }
      return kind;
}

/***********************************************************************
*  NAME
*
*  glp_get_num_int - retrieve number of integer columns
*
*  SYNOPSIS
*
*  int glp_get_num_int(glp_prob *mip);
*
*  RETURNS
*
*  The routine glp_get_num_int returns the current number of columns,
*  which are marked as integer. */

int glp_get_num_int(glp_prob *mip)
{     GLPCOL *col;
      int j, count = 0;
      for (j = 1; j <= mip->n; j++)
      {  col = mip->col[j];
         if (col->kind == GLP_IV) count++;
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  glp_get_num_bin - retrieve number of binary columns
*
*  SYNOPSIS
*
*  int glp_get_num_bin(glp_prob *mip);
*
*  RETURNS
*
*  The routine glp_get_num_bin returns the current number of columns,
*  which are marked as binary. */

int glp_get_num_bin(glp_prob *mip)
{     GLPCOL *col;
      int j, count = 0;
      for (j = 1; j <= mip->n; j++)
      {  col = mip->col[j];
         if (col->kind == GLP_IV && col->type == GLP_DB && col->lb ==
            0.0 && col->ub == 1.0) count++;
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  glp_intopt - solve MIP problem with the branch-and-bound method
*
*  SYNOPSIS
*
*  int glp_intopt(glp_prob *P, const glp_iocp *parm);
*
*  DESCRIPTION
*
*  The routine glp_intopt is a driver to the MIP solver based on the
*  branch-and-bound method.
*
*  On entry the problem object should contain optimal solution to LP
*  relaxation (which can be obtained with the routine glp_simplex).
*
*  The MIP solver has a set of control parameters. Values of the control
*  parameters can be passed in a structure glp_iocp, which the parameter
*  parm points to.
*
*  The parameter parm can be specified as NULL, in which case the MIP
*  solver uses default settings.
*
*  RETURNS
*
*  0  The MIP problem instance has been successfully solved. This code
*     does not necessarily mean that the solver has found optimal
*     solution. It only means that the solution process was successful.
*
*  GLP_EBOUND
*     Unable to start the search, because some double-bounded variables
*     have incorrect bounds or some integer variables have non-integer
*     (fractional) bounds.
*
*  GLP_EROOT
*     Unable to start the search, because optimal basis for initial LP
*     relaxation is not provided.
*
*  GLP_EFAIL
*     The search was prematurely terminated due to the solver failure.
*
*  GLP_EMIPGAP
*     The search was prematurely terminated, because the relative mip
*     gap tolerance has been reached.
*
*  GLP_ETMLIM
*     The search was prematurely terminated, because the time limit has
*     been exceeded.
*
*  GLP_ENOPFS
*     The MIP problem instance has no primal feasible solution (only if
*     the MIP presolver is used).
*
*  GLP_ENODFS
*     LP relaxation of the MIP problem instance has no dual feasible
*     solution (only if the MIP presolver is used).
*
*  GLP_ESTOP
*     The search was prematurely terminated by application. */

#if 0 /* 11/VII-2013 */
static int solve_mip(glp_prob *P, const glp_iocp *parm)
#else
static int solve_mip(glp_prob *P, const glp_iocp *parm,
      glp_prob *P0 /* problem passed to glp_intopt */,
      NPP *npp /* preprocessor workspace or NULL */)
#endif
{     /* solve MIP directly without using the preprocessor */
      glp_tree *T;
      int ret;
      /* optimal basis to LP relaxation must be provided */
      if (glp_get_status(P) != GLP_OPT)
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_intopt: optimal basis to initial LP relaxation"
               " not provided\n");
         ret = GLP_EROOT;
         goto done;
      }
      /* it seems all is ok */
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Integer optimization begins...\n");
      /* create the branch-and-bound tree */
      T = ios_create_tree(P, parm);
#if 1 /* 11/VII-2013 */
      T->P = P0;
      T->npp = npp;
#endif
      /* solve the problem instance */
      ret = ios_driver(T);
      /* delete the branch-and-bound tree */
      ios_delete_tree(T);
      /* analyze exit code reported by the mip driver */
      if (ret == 0)
      {  if (P->mip_stat == GLP_FEAS)
         {  if (parm->msg_lev >= GLP_MSG_ALL)
               xprintf("INTEGER OPTIMAL SOLUTION FOUND\n");
            P->mip_stat = GLP_OPT;
         }
         else
         {  if (parm->msg_lev >= GLP_MSG_ALL)
               xprintf("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION\n");
            P->mip_stat = GLP_NOFEAS;
         }
      }
      else if (ret == GLP_EMIPGAP)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("RELATIVE MIP GAP TOLERANCE REACHED; SEARCH TERMINA"
               "TED\n");
      }
      else if (ret == GLP_ETMLIM)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("TIME LIMIT EXCEEDED; SEARCH TERMINATED\n");
      }
      else if (ret == GLP_EFAIL)
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_intopt: cannot solve current LP relaxation\n");
      }
      else if (ret == GLP_ESTOP)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("SEARCH TERMINATED BY APPLICATION\n");
      }
      else
         xassert(ret != ret);
done: return ret;
}

static int preprocess_and_solve_mip(glp_prob *P, const glp_iocp *parm)
{     /* solve MIP using the preprocessor */
      ENV *env = get_env_ptr();
      int term_out = env->term_out;
      NPP *npp;
      glp_prob *mip = NULL;
      glp_bfcp bfcp;
      glp_smcp smcp;
      int ret;
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Preprocessing...\n");
      /* create preprocessor workspace */
      npp = npp_create_wksp();
      /* load original problem into the preprocessor workspace */
      npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
      /* process MIP prior to applying the branch-and-bound method */
      if (!term_out || parm->msg_lev < GLP_MSG_ALL)
         env->term_out = GLP_OFF;
      else
         env->term_out = GLP_ON;
      ret = npp_integer(npp, parm);
      env->term_out = term_out;
      if (ret == 0)
         ;
      else if (ret == GLP_ENOPFS)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
      }
      else if (ret == GLP_ENODFS)
      {  if (parm->msg_lev >= GLP_MSG_ALL)
            xprintf("LP RELAXATION HAS NO DUAL FEASIBLE SOLUTION\n");
      }
      else
         xassert(ret != ret);
      if (ret != 0) goto done;
      /* build transformed MIP */
      mip = glp_create_prob();
      npp_build_prob(npp, mip);
      /* if the transformed MIP is empty, it has empty solution, which
         is optimal */
      if (mip->m == 0 && mip->n == 0)
      {  mip->mip_stat = GLP_OPT;
         mip->mip_obj = mip->c0;
         if (parm->msg_lev >= GLP_MSG_ALL)
         {  xprintf("Objective value = %17.9e\n", mip->mip_obj);
            xprintf("INTEGER OPTIMAL SOLUTION FOUND BY MIP PREPROCESSOR"
               "\n");
         }
         goto post;
      }
      /* display some statistics */
      if (parm->msg_lev >= GLP_MSG_ALL)
      {  int ni = glp_get_num_int(mip);
         int nb = glp_get_num_bin(mip);
         char s[50];
         xprintf("%d row%s, %d column%s, %d non-zero%s\n",
            mip->m, mip->m == 1 ? "" : "s", mip->n, mip->n == 1 ? "" :
            "s", mip->nnz, mip->nnz == 1 ? "" : "s");
         if (nb == 0)
            strcpy(s, "none of");
         else if (ni == 1 && nb == 1)
            strcpy(s, "");
         else if (nb == 1)
            strcpy(s, "one of");
         else if (nb == ni)
            strcpy(s, "all of");
         else
            sprintf(s, "%d of", nb);
         xprintf("%d integer variable%s, %s which %s binary\n",
            ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
      }
      /* inherit basis factorization control parameters */
      glp_get_bfcp(P, &bfcp);
      glp_set_bfcp(mip, &bfcp);
      /* scale the transformed problem */
      if (!term_out || parm->msg_lev < GLP_MSG_ALL)
         env->term_out = GLP_OFF;
      else
         env->term_out = GLP_ON;
      glp_scale_prob(mip,
         GLP_SF_GM | GLP_SF_EQ | GLP_SF_2N | GLP_SF_SKIP);
      env->term_out = term_out;
      /* build advanced initial basis */
      if (!term_out || parm->msg_lev < GLP_MSG_ALL)
         env->term_out = GLP_OFF;
      else
         env->term_out = GLP_ON;
      glp_adv_basis(mip, 0);
      env->term_out = term_out;
      /* solve initial LP relaxation */
      if (parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Solving LP relaxation...\n");
      glp_init_smcp(&smcp);
      smcp.msg_lev = parm->msg_lev;
      /* respect time limit */
      smcp.tm_lim = parm->tm_lim;
      mip->it_cnt = P->it_cnt;
      ret = glp_simplex(mip, &smcp);
      P->it_cnt = mip->it_cnt;
      if (ret == GLP_ETMLIM)
         goto done;
      else if (ret != 0)
      {  if (parm->msg_lev >= GLP_MSG_ERR)
            xprintf("glp_intopt: cannot solve LP relaxation\n");
         ret = GLP_EFAIL;
         goto done;
      }
      /* check status of the basic solution */
      ret = glp_get_status(mip);
      if (ret == GLP_OPT)
         ret = 0;
      else if (ret == GLP_NOFEAS)
         ret = GLP_ENOPFS;
      else if (ret == GLP_UNBND)
         ret = GLP_ENODFS;
      else
         xassert(ret != ret);
      if (ret != 0) goto done;
      /* solve the transformed MIP */
      mip->it_cnt = P->it_cnt;
#if 0 /* 11/VII-2013 */
      ret = solve_mip(mip, parm);
#else
      if (parm->use_sol)
      {  mip->mip_stat = P->mip_stat;
         mip->mip_obj = P->mip_obj;
      }
      ret = solve_mip(mip, parm, P, npp);
#endif
      P->it_cnt = mip->it_cnt;
      /* only integer feasible solution can be postprocessed */
      if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
      {  P->mip_stat = mip->mip_stat;
         goto done;
      }
      /* postprocess solution from the transformed MIP */
post: npp_postprocess(npp, mip);
      /* the transformed MIP is no longer needed */
      glp_delete_prob(mip), mip = NULL;
      /* store solution to the original problem */
      npp_unload_sol(npp, P);
done: /* delete the transformed MIP, if it exists */
      if (mip != NULL) glp_delete_prob(mip);
      /* delete preprocessor workspace */
      npp_delete_wksp(npp);
      return ret;
}

#ifndef HAVE_ALIEN_SOLVER /* 28/V-2010 */
int _glp_intopt1(glp_prob *P, const glp_iocp *parm)
{     xassert(P == P);
      xassert(parm == parm);
      xprintf("glp_intopt: no alien solver is available\n");
      return GLP_EFAIL;
}
#endif

int glp_intopt(glp_prob *P, const glp_iocp *parm)
{     /* solve MIP problem with the branch-and-bound method */
      glp_iocp _parm;
      int i, j, ret;
#if 0 /* 04/IV-2016 */
      /* check problem object */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_intopt: P = %p; invalid problem object\n", P);
#endif
      if (P->tree != NULL)
         xerror("glp_intopt: operation not allowed\n");
      /* check control parameters */
      if (parm == NULL)
         parm = &_parm, glp_init_iocp((glp_iocp *)parm);
      if (!(parm->msg_lev == GLP_MSG_OFF ||
            parm->msg_lev == GLP_MSG_ERR ||
            parm->msg_lev == GLP_MSG_ON  ||
            parm->msg_lev == GLP_MSG_ALL ||
            parm->msg_lev == GLP_MSG_DBG))
         xerror("glp_intopt: msg_lev = %d; invalid parameter\n",
            parm->msg_lev);
      if (!(parm->br_tech == GLP_BR_FFV ||
            parm->br_tech == GLP_BR_LFV ||
            parm->br_tech == GLP_BR_MFV ||
            parm->br_tech == GLP_BR_DTH ||
            parm->br_tech == GLP_BR_PCH))
         xerror("glp_intopt: br_tech = %d; invalid parameter\n",
            parm->br_tech);
      if (!(parm->bt_tech == GLP_BT_DFS ||
            parm->bt_tech == GLP_BT_BFS ||
            parm->bt_tech == GLP_BT_BLB ||
            parm->bt_tech == GLP_BT_BPH))
         xerror("glp_intopt: bt_tech = %d; invalid parameter\n",
            parm->bt_tech);
      if (!(0.0 < parm->tol_int && parm->tol_int < 1.0))
         xerror("glp_intopt: tol_int = %g; invalid parameter\n",
            parm->tol_int);
      if (!(0.0 < parm->tol_obj && parm->tol_obj < 1.0))
         xerror("glp_intopt: tol_obj = %g; invalid parameter\n",
            parm->tol_obj);
      if (parm->tm_lim < 0)
         xerror("glp_intopt: tm_lim = %d; invalid parameter\n",
            parm->tm_lim);
      if (parm->out_frq < 0)
         xerror("glp_intopt: out_frq = %d; invalid parameter\n",
            parm->out_frq);
      if (parm->out_dly < 0)
         xerror("glp_intopt: out_dly = %d; invalid parameter\n",
            parm->out_dly);
      if (!(0 <= parm->cb_size && parm->cb_size <= 256))
         xerror("glp_intopt: cb_size = %d; invalid parameter\n",
            parm->cb_size);
      if (!(parm->pp_tech == GLP_PP_NONE ||
            parm->pp_tech == GLP_PP_ROOT ||
            parm->pp_tech == GLP_PP_ALL))
         xerror("glp_intopt: pp_tech = %d; invalid parameter\n",
            parm->pp_tech);
      if (parm->mip_gap < 0.0)
         xerror("glp_intopt: mip_gap = %g; invalid parameter\n",
            parm->mip_gap);
      if (!(parm->mir_cuts == GLP_ON || parm->mir_cuts == GLP_OFF))
         xerror("glp_intopt: mir_cuts = %d; invalid parameter\n",
            parm->mir_cuts);
      if (!(parm->gmi_cuts == GLP_ON || parm->gmi_cuts == GLP_OFF))
         xerror("glp_intopt: gmi_cuts = %d; invalid parameter\n",
            parm->gmi_cuts);
      if (!(parm->cov_cuts == GLP_ON || parm->cov_cuts == GLP_OFF))
         xerror("glp_intopt: cov_cuts = %d; invalid parameter\n",
            parm->cov_cuts);
      if (!(parm->clq_cuts == GLP_ON || parm->clq_cuts == GLP_OFF))
         xerror("glp_intopt: clq_cuts = %d; invalid parameter\n",
            parm->clq_cuts);
      if (!(parm->presolve == GLP_ON || parm->presolve == GLP_OFF))
         xerror("glp_intopt: presolve = %d; invalid parameter\n",
            parm->presolve);
      if (!(parm->binarize == GLP_ON || parm->binarize == GLP_OFF))
         xerror("glp_intopt: binarize = %d; invalid parameter\n",
            parm->binarize);
      if (!(parm->fp_heur == GLP_ON || parm->fp_heur == GLP_OFF))
         xerror("glp_intopt: fp_heur = %d; invalid parameter\n",
            parm->fp_heur);
#if 1 /* 28/V-2010 */
      if (!(parm->alien == GLP_ON || parm->alien == GLP_OFF))
         xerror("glp_intopt: alien = %d; invalid parameter\n",
            parm->alien);
#endif
#if 0 /* 11/VII-2013 */
      /* integer solution is currently undefined */
      P->mip_stat = GLP_UNDEF;
      P->mip_obj = 0.0;
#else
      if (!parm->use_sol)
         P->mip_stat = GLP_UNDEF;
      if (P->mip_stat == GLP_NOFEAS)
         P->mip_stat = GLP_UNDEF;
      if (P->mip_stat == GLP_UNDEF)
         P->mip_obj = 0.0;
      else if (P->mip_stat == GLP_OPT)
         P->mip_stat = GLP_FEAS;
#endif
      /* check bounds of double-bounded variables */
      for (i = 1; i <= P->m; i++)
      {  GLPROW *row = P->row[i];
         if (row->type == GLP_DB && row->lb >= row->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_intopt: row %d: lb = %g, ub = %g; incorrect"
                  " bounds\n", i, row->lb, row->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if (col->type == GLP_DB && col->lb >= col->ub)
         {  if (parm->msg_lev >= GLP_MSG_ERR)
               xprintf("glp_intopt: column %d: lb = %g, ub = %g; incorr"
                  "ect bounds\n", j, col->lb, col->ub);
            ret = GLP_EBOUND;
            goto done;
         }
      }
      /* bounds of all integer variables must be integral */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if (col->kind != GLP_IV) continue;
         if (col->type == GLP_LO || col->type == GLP_DB)
         {  if (col->lb != floor(col->lb))
            {  if (parm->msg_lev >= GLP_MSG_ERR)
                  xprintf("glp_intopt: integer column %d has non-intege"
                     "r lower bound %g\n", j, col->lb);
               ret = GLP_EBOUND;
               goto done;
            }
         }
         if (col->type == GLP_UP || col->type == GLP_DB)
         {  if (col->ub != floor(col->ub))
            {  if (parm->msg_lev >= GLP_MSG_ERR)
                  xprintf("glp_intopt: integer column %d has non-intege"
                     "r upper bound %g\n", j, col->ub);
               ret = GLP_EBOUND;
               goto done;
            }
         }
         if (col->type == GLP_FX)
         {  if (col->lb != floor(col->lb))
            {  if (parm->msg_lev >= GLP_MSG_ERR)
                  xprintf("glp_intopt: integer column %d has non-intege"
                     "r fixed value %g\n", j, col->lb);
               ret = GLP_EBOUND;
               goto done;
            }
         }
      }
      /* solve MIP problem */
      if (parm->msg_lev >= GLP_MSG_ALL)
      {  int ni = glp_get_num_int(P);
         int nb = glp_get_num_bin(P);
         char s[50];
         xprintf("GLPK Integer Optimizer %s\n", glp_version());
         xprintf("%d row%s, %d column%s, %d non-zero%s\n",
            P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
            P->nnz, P->nnz == 1 ? "" : "s");
         if (nb == 0)
            strcpy(s, "none of");
         else if (ni == 1 && nb == 1)
            strcpy(s, "");
         else if (nb == 1)
            strcpy(s, "one of");
         else if (nb == ni)
            strcpy(s, "all of");
         else
            sprintf(s, "%d of", nb);
         xprintf("%d integer variable%s, %s which %s binary\n",
            ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
      }
#if 1 /* 28/V-2010 */
      if (parm->alien)
      {  /* use alien integer optimizer */
         ret = _glp_intopt1(P, parm);
         goto done;
      }
#endif
      if (!parm->presolve)
#if 0 /* 11/VII-2013 */
         ret = solve_mip(P, parm);
#else
         ret = solve_mip(P, parm, P, NULL);
#endif
      else
         ret = preprocess_and_solve_mip(P, parm);
#if 1 /* 12/III-2013 */
      if (ret == GLP_ENOPFS)
         P->mip_stat = GLP_NOFEAS;
#endif
done: /* return to the application program */
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_init_iocp - initialize integer optimizer control parameters
*
*  SYNOPSIS
*
*  void glp_init_iocp(glp_iocp *parm);
*
*  DESCRIPTION
*
*  The routine glp_init_iocp initializes control parameters, which are
*  used by the integer optimizer, with default values.
*
*  Default values of the control parameters are stored in a glp_iocp
*  structure, which the parameter parm points to. */

void glp_init_iocp(glp_iocp *parm)
{     parm->msg_lev = GLP_MSG_ALL;
      parm->br_tech = GLP_BR_DTH;
      parm->bt_tech = GLP_BT_BLB;
      parm->tol_int = 1e-5;
      parm->tol_obj = 1e-7;
      parm->tm_lim = INT_MAX;
      parm->out_frq = 5000;
      parm->out_dly = 10000;
      parm->cb_func = NULL;
      parm->cb_info = NULL;
      parm->cb_size = 0;
      parm->pp_tech = GLP_PP_ALL;
      parm->mip_gap = 0.0;
      parm->mir_cuts = GLP_OFF;
      parm->gmi_cuts = GLP_OFF;
      parm->cov_cuts = GLP_OFF;
      parm->clq_cuts = GLP_OFF;
      parm->presolve = GLP_OFF;
      parm->binarize = GLP_OFF;
      parm->fp_heur = GLP_OFF;
      parm->ps_heur = GLP_OFF;
      parm->ps_tm_lim = 60000; /* 1 minute */
      parm->sr_heur = GLP_ON;
#if 1 /* 24/X-2015; not documented--should not be used */
      parm->use_sol = GLP_OFF;
      parm->save_sol = NULL;
      parm->alien = GLP_OFF;
#endif
#if 0 /* 20/I-2018 */
#if 1 /* 16/III-2016; not documented--should not be used */
      parm->flip = GLP_OFF;
#endif
#else
      parm->flip = GLP_ON;
#endif
      return;
}

/***********************************************************************
*  NAME
*
*  glp_mip_status - retrieve status of MIP solution
*
*  SYNOPSIS
*
*  int glp_mip_status(glp_prob *mip);
*
*  RETURNS
*
*  The routine lpx_mip_status reports the status of MIP solution found
*  by the branch-and-bound solver as follows:
*
*  GLP_UNDEF  - MIP solution is undefined;
*  GLP_OPT    - MIP solution is integer optimal;
*  GLP_FEAS   - MIP solution is integer feasible but its optimality
*               (or non-optimality) has not been proven, perhaps due to
*               premature termination of the search;
*  GLP_NOFEAS - problem has no integer feasible solution (proven by the
*               solver). */

int glp_mip_status(glp_prob *mip)
{     int mip_stat = mip->mip_stat;
      return mip_stat;
}

/***********************************************************************
*  NAME
*
*  glp_mip_obj_val - retrieve objective value (MIP solution)
*
*  SYNOPSIS
*
*  double glp_mip_obj_val(glp_prob *mip);
*
*  RETURNS
*
*  The routine glp_mip_obj_val returns value of the objective function
*  for MIP solution. */

double glp_mip_obj_val(glp_prob *mip)
{     /*struct LPXCPS *cps = mip->cps;*/
      double z;
      z = mip->mip_obj;
      /*if (cps->round && fabs(z) < 1e-9) z = 0.0;*/
      return z;
}

/***********************************************************************
*  NAME
*
*  glp_mip_row_val - retrieve row value (MIP solution)
*
*  SYNOPSIS
*
*  double glp_mip_row_val(glp_prob *mip, int i);
*
*  RETURNS
*
*  The routine glp_mip_row_val returns value of the auxiliary variable
*  associated with i-th row. */

double glp_mip_row_val(glp_prob *mip, int i)
{     /*struct LPXCPS *cps = mip->cps;*/
      double mipx;
      if (!(1 <= i && i <= mip->m))
         xerror("glp_mip_row_val: i = %d; row number out of range\n", i)
            ;
      mipx = mip->row[i]->mipx;
      /*if (cps->round && fabs(mipx) < 1e-9) mipx = 0.0;*/
      return mipx;
}

/***********************************************************************
*  NAME
*
*  glp_mip_col_val - retrieve column value (MIP solution)
*
*  SYNOPSIS
*
*  double glp_mip_col_val(glp_prob *mip, int j);
*
*  RETURNS
*
*  The routine glp_mip_col_val returns value of the structural variable
*  associated with j-th column. */

double glp_mip_col_val(glp_prob *mip, int j)
{     /*struct LPXCPS *cps = mip->cps;*/
      double mipx;
      if (!(1 <= j && j <= mip->n))
         xerror("glp_mip_col_val: j = %d; column number out of range\n",
            j);
      mipx = mip->col[j]->mipx;
      /*if (cps->round && fabs(mipx) < 1e-9) mipx = 0.0;*/
      return mipx;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi10.c0000644000175100001710000002413300000000000024770 0ustar00runnerdocker00000000000000/* glpapi10.c (solution checking routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

void glp_check_kkt(glp_prob *P, int sol, int cond, double *_ae_max,
      int *_ae_ind, double *_re_max, int *_re_ind)
{     /* check feasibility and optimality conditions */
      int m = P->m;
      int n = P->n;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, ae_ind, re_ind;
      double e, sp, sn, t, ae_max, re_max;
      if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
         xerror("glp_check_kkt: sol = %d; invalid solution indicator\n",
            sol);
      if (!(cond == GLP_KKT_PE || cond == GLP_KKT_PB ||
            cond == GLP_KKT_DE || cond == GLP_KKT_DB ||
            cond == GLP_KKT_CS))
         xerror("glp_check_kkt: cond = %d; invalid condition indicator "
            "\n", cond);
      ae_max = re_max = 0.0;
      ae_ind = re_ind = 0;
      if (cond == GLP_KKT_PE)
      {  /* xR - A * xS = 0 */
         for (i = 1; i <= m; i++)
         {  row = P->row[i];
            sp = sn = 0.0;
            /* t := xR[i] */
            if (sol == GLP_SOL)
               t = row->prim;
            else if (sol == GLP_IPT)
               t = row->pval;
            else if (sol == GLP_MIP)
               t = row->mipx;
            else
               xassert(sol != sol);
            if (t >= 0.0) sp += t; else sn -= t;
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            {  col = aij->col;
               /* t := - a[i,j] * xS[j] */
               if (sol == GLP_SOL)
                  t = - aij->val * col->prim;
               else if (sol == GLP_IPT)
                  t = - aij->val * col->pval;
               else if (sol == GLP_MIP)
                  t = - aij->val * col->mipx;
               else
                  xassert(sol != sol);
               if (t >= 0.0) sp += t; else sn -= t;
            }
            /* absolute error */
            e = fabs(sp - sn);
            if (ae_max < e)
               ae_max = e, ae_ind = i;
            /* relative error */
            e /= (1.0 + sp + sn);
            if (re_max < e)
               re_max = e, re_ind = i;
         }
      }
      else if (cond == GLP_KKT_PB)
      {  /* lR <= xR <= uR */
         for (i = 1; i <= m; i++)
         {  row = P->row[i];
            /* t := xR[i] */
            if (sol == GLP_SOL)
               t = row->prim;
            else if (sol == GLP_IPT)
               t = row->pval;
            else if (sol == GLP_MIP)
               t = row->mipx;
            else
               xassert(sol != sol);
            /* check lower bound */
            if (row->type == GLP_LO || row->type == GLP_DB ||
                row->type == GLP_FX)
            {  if (t < row->lb)
               {  /* absolute error */
                  e = row->lb - t;
                  if (ae_max < e)
                     ae_max = e, ae_ind = i;
                  /* relative error */
                  e /= (1.0 + fabs(row->lb));
                  if (re_max < e)
                     re_max = e, re_ind = i;
               }
            }
            /* check upper bound */
            if (row->type == GLP_UP || row->type == GLP_DB ||
                row->type == GLP_FX)
            {  if (t > row->ub)
               {  /* absolute error */
                  e = t - row->ub;
                  if (ae_max < e)
                     ae_max = e, ae_ind = i;
                  /* relative error */
                  e /= (1.0 + fabs(row->ub));
                  if (re_max < e)
                     re_max = e, re_ind = i;
               }
            }
         }
         /* lS <= xS <= uS */
         for (j = 1; j <= n; j++)
         {  col = P->col[j];
            /* t := xS[j] */
            if (sol == GLP_SOL)
               t = col->prim;
            else if (sol == GLP_IPT)
               t = col->pval;
            else if (sol == GLP_MIP)
               t = col->mipx;
            else
               xassert(sol != sol);
            /* check lower bound */
            if (col->type == GLP_LO || col->type == GLP_DB ||
                col->type == GLP_FX)
            {  if (t < col->lb)
               {  /* absolute error */
                  e = col->lb - t;
                  if (ae_max < e)
                     ae_max = e, ae_ind = m+j;
                  /* relative error */
                  e /= (1.0 + fabs(col->lb));
                  if (re_max < e)
                     re_max = e, re_ind = m+j;
               }
            }
            /* check upper bound */
            if (col->type == GLP_UP || col->type == GLP_DB ||
                col->type == GLP_FX)
            {  if (t > col->ub)
               {  /* absolute error */
                  e = t - col->ub;
                  if (ae_max < e)
                     ae_max = e, ae_ind = m+j;
                  /* relative error */
                  e /= (1.0 + fabs(col->ub));
                  if (re_max < e)
                     re_max = e, re_ind = m+j;
               }
            }
         }
      }
      else if (cond == GLP_KKT_DE)
      {  /* A' * (lambdaR - cR) + (lambdaS - cS) = 0 */
         for (j = 1; j <= n; j++)
         {  col = P->col[j];
            sp = sn = 0.0;
            /* t := lambdaS[j] - cS[j] */
            if (sol == GLP_SOL)
               t = col->dual - col->coef;
            else if (sol == GLP_IPT)
               t = col->dval - col->coef;
            else
               xassert(sol != sol);
            if (t >= 0.0) sp += t; else sn -= t;
            for (aij = col->ptr; aij != NULL; aij = aij->c_next)
            {  row = aij->row;
               /* t := a[i,j] * (lambdaR[i] - cR[i]) */
               if (sol == GLP_SOL)
                  t = aij->val * row->dual;
               else if (sol == GLP_IPT)
                  t = aij->val * row->dval;
               else
                  xassert(sol != sol);
               if (t >= 0.0) sp += t; else sn -= t;
            }
            /* absolute error */
            e = fabs(sp - sn);
            if (ae_max < e)
               ae_max = e, ae_ind = m+j;
            /* relative error */
            e /= (1.0 + sp + sn);
            if (re_max < e)
               re_max = e, re_ind = m+j;
         }
      }
      else if (cond == GLP_KKT_DB)
      {  /* check lambdaR */
         for (i = 1; i <= m; i++)
         {  row = P->row[i];
            /* t := lambdaR[i] */
            if (sol == GLP_SOL)
               t = row->dual;
            else if (sol == GLP_IPT)
               t = row->dval;
            else
               xassert(sol != sol);
            /* correct sign */
            if (P->dir == GLP_MIN)
               t = + t;
            else if (P->dir == GLP_MAX)
               t = - t;
            else
               xassert(P != P);
            /* check for positivity */
#if 1 /* 08/III-2013 */
            /* the former check was correct */
            /* the bug reported by David Price is related to violation
               of complementarity slackness, not to this condition */
            if (row->type == GLP_FR || row->type == GLP_LO)
#else
            if (row->stat == GLP_NF || row->stat == GLP_NL)
#endif
            {  if (t < 0.0)
               {  e = - t;
                  if (ae_max < e)
                     ae_max = re_max = e, ae_ind = re_ind = i;
               }
            }
            /* check for negativity */
#if 1 /* 08/III-2013 */
            /* see comment above */
            if (row->type == GLP_FR || row->type == GLP_UP)
#else
            if (row->stat == GLP_NF || row->stat == GLP_NU)
#endif
            {  if (t > 0.0)
               {  e = + t;
                  if (ae_max < e)
                     ae_max = re_max = e, ae_ind = re_ind = i;
               }
            }
         }
         /* check lambdaS */
         for (j = 1; j <= n; j++)
         {  col = P->col[j];
            /* t := lambdaS[j] */
            if (sol == GLP_SOL)
               t = col->dual;
            else if (sol == GLP_IPT)
               t = col->dval;
            else
               xassert(sol != sol);
            /* correct sign */
            if (P->dir == GLP_MIN)
               t = + t;
            else if (P->dir == GLP_MAX)
               t = - t;
            else
               xassert(P != P);
            /* check for positivity */
#if 1 /* 08/III-2013 */
            /* see comment above */
            if (col->type == GLP_FR || col->type == GLP_LO)
#else
            if (col->stat == GLP_NF || col->stat == GLP_NL)
#endif
            {  if (t < 0.0)
               {  e = - t;
                  if (ae_max < e)
                     ae_max = re_max = e, ae_ind = re_ind = m+j;
               }
            }
            /* check for negativity */
#if 1 /* 08/III-2013 */
            /* see comment above */
            if (col->type == GLP_FR || col->type == GLP_UP)
#else
            if (col->stat == GLP_NF || col->stat == GLP_NU)
#endif
            {  if (t > 0.0)
               {  e = + t;
                  if (ae_max < e)
                     ae_max = re_max = e, ae_ind = re_ind = m+j;
               }
            }
         }
      }
      else
         xassert(cond != cond);
      if (_ae_max != NULL) *_ae_max = ae_max;
      if (_ae_ind != NULL) *_ae_ind = ae_ind;
      if (_re_max != NULL) *_re_max = re_max;
      if (_re_ind != NULL) *_re_ind = re_ind;
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi12.c0000644000175100001710000023260400000000000024776 0ustar00runnerdocker00000000000000/* glpapi12.c (basis factorization and simplex tableau routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "draft.h"
#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_bf_exists - check if the basis factorization exists
*
*  SYNOPSIS
*
*  int glp_bf_exists(glp_prob *lp);
*
*  RETURNS
*
*  If the basis factorization for the current basis associated with
*  the specified problem object exists and therefore is available for
*  computations, the routine glp_bf_exists returns non-zero. Otherwise
*  the routine returns zero. */

int glp_bf_exists(glp_prob *lp)
{     int ret;
      ret = (lp->m == 0 || lp->valid);
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_factorize - compute the basis factorization
*
*  SYNOPSIS
*
*  int glp_factorize(glp_prob *lp);
*
*  DESCRIPTION
*
*  The routine glp_factorize computes the basis factorization for the
*  current basis associated with the specified problem object.
*
*  RETURNS
*
*  0  The basis factorization has been successfully computed.
*
*  GLP_EBADB
*     The basis matrix is invalid, i.e. the number of basic (auxiliary
*     and structural) variables differs from the number of rows in the
*     problem object.
*
*  GLP_ESING
*     The basis matrix is singular within the working precision.
*
*  GLP_ECOND
*     The basis matrix is ill-conditioned. */

static int b_col(void *info, int j, int ind[], double val[])
{     glp_prob *lp = info;
      int m = lp->m;
      GLPAIJ *aij;
      int k, len;
      xassert(1 <= j && j <= m);
      /* determine the ordinal number of basic auxiliary or structural
         variable x[k] corresponding to basic variable xB[j] */
      k = lp->head[j];
      /* build j-th column of the basic matrix, which is k-th column of
         the scaled augmented matrix (I | -R*A*S) */
      if (k <= m)
      {  /* x[k] is auxiliary variable */
         len = 1;
         ind[1] = k;
         val[1] = 1.0;
      }
      else
      {  /* x[k] is structural variable */
         len = 0;
         for (aij = lp->col[k-m]->ptr; aij != NULL; aij = aij->c_next)
         {  len++;
            ind[len] = aij->row->i;
            val[len] = - aij->row->rii * aij->val * aij->col->sjj;
         }
      }
      return len;
}

int glp_factorize(glp_prob *lp)
{     int m = lp->m;
      int n = lp->n;
      GLPROW **row = lp->row;
      GLPCOL **col = lp->col;
      int *head = lp->head;
      int j, k, stat, ret;
      /* invalidate the basis factorization */
      lp->valid = 0;
      /* build the basis header */
      j = 0;
      for (k = 1; k <= m+n; k++)
      {  if (k <= m)
         {  stat = row[k]->stat;
            row[k]->bind = 0;
         }
         else
         {  stat = col[k-m]->stat;
            col[k-m]->bind = 0;
         }
         if (stat == GLP_BS)
         {  j++;
            if (j > m)
            {  /* too many basic variables */
               ret = GLP_EBADB;
               goto fini;
            }
            head[j] = k;
            if (k <= m)
               row[k]->bind = j;
            else
               col[k-m]->bind = j;
         }
      }
      if (j < m)
      {  /* too few basic variables */
         ret = GLP_EBADB;
         goto fini;
      }
      /* try to factorize the basis matrix */
      if (m > 0)
      {  if (lp->bfd == NULL)
         {  lp->bfd = bfd_create_it();
#if 0 /* 08/III-2014 */
            copy_bfcp(lp);
#endif
         }
         switch (bfd_factorize(lp->bfd, m, /*lp->head,*/ b_col, lp))
         {  case 0:
               /* ok */
               break;
            case BFD_ESING:
               /* singular matrix */
               ret = GLP_ESING;
               goto fini;
            case BFD_ECOND:
               /* ill-conditioned matrix */
               ret = GLP_ECOND;
               goto fini;
            default:
               xassert(lp != lp);
         }
         lp->valid = 1;
      }
      /* factorization successful */
      ret = 0;
fini: /* bring the return code to the calling program */
      return ret;
}

/***********************************************************************
*  NAME
*
*  glp_bf_updated - check if the basis factorization has been updated
*
*  SYNOPSIS
*
*  int glp_bf_updated(glp_prob *lp);
*
*  RETURNS
*
*  If the basis factorization has been just computed from scratch, the
*  routine glp_bf_updated returns zero. Otherwise, if the factorization
*  has been updated one or more times, the routine returns non-zero. */

int glp_bf_updated(glp_prob *lp)
{     int cnt;
      if (!(lp->m == 0 || lp->valid))
         xerror("glp_bf_update: basis factorization does not exist\n");
#if 0 /* 15/XI-2009 */
      cnt = (lp->m == 0 ? 0 : lp->bfd->upd_cnt);
#else
      cnt = (lp->m == 0 ? 0 : bfd_get_count(lp->bfd));
#endif
      return cnt;
}

/***********************************************************************
*  NAME
*
*  glp_get_bfcp - retrieve basis factorization control parameters
*
*  SYNOPSIS
*
*  void glp_get_bfcp(glp_prob *lp, glp_bfcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_get_bfcp retrieves control parameters, which are
*  used on computing and updating the basis factorization associated
*  with the specified problem object.
*
*  Current values of control parameters are stored by the routine in
*  a glp_bfcp structure, which the parameter parm points to. */

#if 1 /* 08/III-2014 */
void glp_get_bfcp(glp_prob *P, glp_bfcp *parm)
{     if (P->bfd == NULL)
         P->bfd = bfd_create_it();
      bfd_get_bfcp(P->bfd, parm);
      return;
}
#endif

/***********************************************************************
*  NAME
*
*  glp_set_bfcp - change basis factorization control parameters
*
*  SYNOPSIS
*
*  void glp_set_bfcp(glp_prob *lp, const glp_bfcp *parm);
*
*  DESCRIPTION
*
*  The routine glp_set_bfcp changes control parameters, which are used
*  by internal GLPK routines in computing and updating the basis
*  factorization associated with the specified problem object.
*
*  New values of the control parameters should be passed in a structure
*  glp_bfcp, which the parameter parm points to.
*
*  The parameter parm can be specified as NULL, in which case all
*  control parameters are reset to their default values. */

#if 1 /* 08/III-2014 */
void glp_set_bfcp(glp_prob *P, const glp_bfcp *parm)
{     if (P->bfd == NULL)
         P->bfd = bfd_create_it();
      if (parm != NULL)
      {  if (!(parm->type == GLP_BF_LUF + GLP_BF_FT ||
               parm->type == GLP_BF_LUF + GLP_BF_BG ||
               parm->type == GLP_BF_LUF + GLP_BF_GR ||
               parm->type == GLP_BF_BTF + GLP_BF_BG ||
               parm->type == GLP_BF_BTF + GLP_BF_GR))
            xerror("glp_set_bfcp: type = 0x%02X; invalid parameter\n",
               parm->type);
         if (!(0.0 < parm->piv_tol && parm->piv_tol < 1.0))
            xerror("glp_set_bfcp: piv_tol = %g; invalid parameter\n",
               parm->piv_tol);
         if (parm->piv_lim < 1)
            xerror("glp_set_bfcp: piv_lim = %d; invalid parameter\n",
               parm->piv_lim);
         if (!(parm->suhl == GLP_ON || parm->suhl == GLP_OFF))
            xerror("glp_set_bfcp: suhl = %d; invalid parameter\n",
               parm->suhl);
         if (!(0.0 <= parm->eps_tol && parm->eps_tol <= 1e-6))
            xerror("glp_set_bfcp: eps_tol = %g; invalid parameter\n",
               parm->eps_tol);
         if (!(1 <= parm->nfs_max && parm->nfs_max <= 32767))
            xerror("glp_set_bfcp: nfs_max = %d; invalid parameter\n",
               parm->nfs_max);
         if (!(1 <= parm->nrs_max && parm->nrs_max <= 32767))
            xerror("glp_set_bfcp: nrs_max = %d; invalid parameter\n",
               parm->nrs_max);
      }
      bfd_set_bfcp(P->bfd, parm);
      return;
}
#endif

/***********************************************************************
*  NAME
*
*  glp_get_bhead - retrieve the basis header information
*
*  SYNOPSIS
*
*  int glp_get_bhead(glp_prob *lp, int k);
*
*  DESCRIPTION
*
*  The routine glp_get_bhead returns the basis header information for
*  the current basis associated with the specified problem object.
*
*  RETURNS
*
*  If xB[k], 1 <= k <= m, is i-th auxiliary variable (1 <= i <= m), the
*  routine returns i. Otherwise, if xB[k] is j-th structural variable
*  (1 <= j <= n), the routine returns m+j. Here m is the number of rows
*  and n is the number of columns in the problem object. */

int glp_get_bhead(glp_prob *lp, int k)
{     if (!(lp->m == 0 || lp->valid))
         xerror("glp_get_bhead: basis factorization does not exist\n");
      if (!(1 <= k && k <= lp->m))
         xerror("glp_get_bhead: k = %d; index out of range\n", k);
      return lp->head[k];
}

/***********************************************************************
*  NAME
*
*  glp_get_row_bind - retrieve row index in the basis header
*
*  SYNOPSIS
*
*  int glp_get_row_bind(glp_prob *lp, int i);
*
*  RETURNS
*
*  The routine glp_get_row_bind returns the index k of basic variable
*  xB[k], 1 <= k <= m, which is i-th auxiliary variable, 1 <= i <= m,
*  in the current basis associated with the specified problem object,
*  where m is the number of rows. However, if i-th auxiliary variable
*  is non-basic, the routine returns zero. */

int glp_get_row_bind(glp_prob *lp, int i)
{     if (!(lp->m == 0 || lp->valid))
         xerror("glp_get_row_bind: basis factorization does not exist\n"
            );
      if (!(1 <= i && i <= lp->m))
         xerror("glp_get_row_bind: i = %d; row number out of range\n",
            i);
      return lp->row[i]->bind;
}

/***********************************************************************
*  NAME
*
*  glp_get_col_bind - retrieve column index in the basis header
*
*  SYNOPSIS
*
*  int glp_get_col_bind(glp_prob *lp, int j);
*
*  RETURNS
*
*  The routine glp_get_col_bind returns the index k of basic variable
*  xB[k], 1 <= k <= m, which is j-th structural variable, 1 <= j <= n,
*  in the current basis associated with the specified problem object,
*  where m is the number of rows, n is the number of columns. However,
*  if j-th structural variable is non-basic, the routine returns zero.*/

int glp_get_col_bind(glp_prob *lp, int j)
{     if (!(lp->m == 0 || lp->valid))
         xerror("glp_get_col_bind: basis factorization does not exist\n"
            );
      if (!(1 <= j && j <= lp->n))
         xerror("glp_get_col_bind: j = %d; column number out of range\n"
            , j);
      return lp->col[j]->bind;
}

/***********************************************************************
*  NAME
*
*  glp_ftran - perform forward transformation (solve system B*x = b)
*
*  SYNOPSIS
*
*  void glp_ftran(glp_prob *lp, double x[]);
*
*  DESCRIPTION
*
*  The routine glp_ftran performs forward transformation, i.e. solves
*  the system B*x = b, where B is the basis matrix corresponding to the
*  current basis for the specified problem object, x is the vector of
*  unknowns to be computed, b is the vector of right-hand sides.
*
*  On entry elements of the vector b should be stored in dense format
*  in locations x[1], ..., x[m], where m is the number of rows. On exit
*  the routine stores elements of the vector x in the same locations.
*
*  SCALING/UNSCALING
*
*  Let A~ = (I | -A) is the augmented constraint matrix of the original
*  (unscaled) problem. In the scaled LP problem instead the matrix A the
*  scaled matrix A" = R*A*S is actually used, so
*
*     A~" = (I | A") = (I | R*A*S) = (R*I*inv(R) | R*A*S) =
*                                                                    (1)
*         = R*(I | A)*S~ = R*A~*S~,
*
*  is the scaled augmented constraint matrix, where R and S are diagonal
*  scaling matrices used to scale rows and columns of the matrix A, and
*
*     S~ = diag(inv(R) | S)                                          (2)
*
*  is an augmented diagonal scaling matrix.
*
*  By definition:
*
*     A~ = (B | N),                                                  (3)
*
*  where B is the basic matrix, which consists of basic columns of the
*  augmented constraint matrix A~, and N is a matrix, which consists of
*  non-basic columns of A~. From (1) it follows that:
*
*     A~" = (B" | N") = (R*B*SB | R*N*SN),                           (4)
*
*  where SB and SN are parts of the augmented scaling matrix S~, which
*  correspond to basic and non-basic variables, respectively. Therefore
*
*     B" = R*B*SB,                                                   (5)
*
*  which is the scaled basis matrix. */

void glp_ftran(glp_prob *lp, double x[])
{     int m = lp->m;
      GLPROW **row = lp->row;
      GLPCOL **col = lp->col;
      int i, k;
      /* B*x = b ===> (R*B*SB)*(inv(SB)*x) = R*b ===>
         B"*x" = b", where b" = R*b, x = SB*x" */
      if (!(m == 0 || lp->valid))
         xerror("glp_ftran: basis factorization does not exist\n");
      /* b" := R*b */
      for (i = 1; i <= m; i++)
         x[i] *= row[i]->rii;
      /* x" := inv(B")*b" */
      if (m > 0) bfd_ftran(lp->bfd, x);
      /* x := SB*x" */
      for (i = 1; i <= m; i++)
      {  k = lp->head[i];
         if (k <= m)
            x[i] /= row[k]->rii;
         else
            x[i] *= col[k-m]->sjj;
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_btran - perform backward transformation (solve system B'*x = b)
*
*  SYNOPSIS
*
*  void glp_btran(glp_prob *lp, double x[]);
*
*  DESCRIPTION
*
*  The routine glp_btran performs backward transformation, i.e. solves
*  the system B'*x = b, where B' is a matrix transposed to the basis
*  matrix corresponding to the current basis for the specified problem
*  problem object, x is the vector of unknowns to be computed, b is the
*  vector of right-hand sides.
*
*  On entry elements of the vector b should be stored in dense format
*  in locations x[1], ..., x[m], where m is the number of rows. On exit
*  the routine stores elements of the vector x in the same locations.
*
*  SCALING/UNSCALING
*
*  See comments to the routine glp_ftran. */

void glp_btran(glp_prob *lp, double x[])
{     int m = lp->m;
      GLPROW **row = lp->row;
      GLPCOL **col = lp->col;
      int i, k;
      /* B'*x = b ===> (SB*B'*R)*(inv(R)*x) = SB*b ===>
         (B")'*x" = b", where b" = SB*b, x = R*x" */
      if (!(m == 0 || lp->valid))
         xerror("glp_btran: basis factorization does not exist\n");
      /* b" := SB*b */
      for (i = 1; i <= m; i++)
      {  k = lp->head[i];
         if (k <= m)
            x[i] /= row[k]->rii;
         else
            x[i] *= col[k-m]->sjj;
      }
      /* x" := inv[(B")']*b" */
      if (m > 0) bfd_btran(lp->bfd, x);
      /* x := R*x" */
      for (i = 1; i <= m; i++)
         x[i] *= row[i]->rii;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_warm_up - "warm up" LP basis
*
*  SYNOPSIS
*
*  int glp_warm_up(glp_prob *P);
*
*  DESCRIPTION
*
*  The routine glp_warm_up "warms up" the LP basis for the specified
*  problem object using current statuses assigned to rows and columns
*  (that is, to auxiliary and structural variables).
*
*  This operation includes computing factorization of the basis matrix
*  (if it does not exist), computing primal and dual components of basic
*  solution, and determining the solution status.
*
*  RETURNS
*
*  0  The operation has been successfully performed.
*
*  GLP_EBADB
*     The basis matrix is invalid, i.e. the number of basic (auxiliary
*     and structural) variables differs from the number of rows in the
*     problem object.
*
*  GLP_ESING
*     The basis matrix is singular within the working precision.
*
*  GLP_ECOND
*     The basis matrix is ill-conditioned. */

int glp_warm_up(glp_prob *P)
{     GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, type, stat, ret;
      double eps, temp, *work;
      /* invalidate basic solution */
      P->pbs_stat = P->dbs_stat = GLP_UNDEF;
      P->obj_val = 0.0;
      P->some = 0;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         row->prim = row->dual = 0.0;
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         col->prim = col->dual = 0.0;
      }
      /* compute the basis factorization, if necessary */
      if (!glp_bf_exists(P))
      {  ret = glp_factorize(P);
         if (ret != 0) goto done;
      }
      /* allocate working array */
      work = xcalloc(1+P->m, sizeof(double));
      /* determine and store values of non-basic variables, compute
         vector (- N * xN) */
      for (i = 1; i <= P->m; i++)
         work[i] = 0.0;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->stat == GLP_BS)
            continue;
         else if (row->stat == GLP_NL)
            row->prim = row->lb;
         else if (row->stat == GLP_NU)
            row->prim = row->ub;
         else if (row->stat == GLP_NF)
            row->prim = 0.0;
         else if (row->stat == GLP_NS)
            row->prim = row->lb;
         else
            xassert(row != row);
         /* N[j] is i-th column of matrix (I|-A) */
         work[i] -= row->prim;
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->stat == GLP_BS)
            continue;
         else if (col->stat == GLP_NL)
            col->prim = col->lb;
         else if (col->stat == GLP_NU)
            col->prim = col->ub;
         else if (col->stat == GLP_NF)
            col->prim = 0.0;
         else if (col->stat == GLP_NS)
            col->prim = col->lb;
         else
            xassert(col != col);
         /* N[j] is (m+j)-th column of matrix (I|-A) */
         if (col->prim != 0.0)
         {  for (aij = col->ptr; aij != NULL; aij = aij->c_next)
               work[aij->row->i] += aij->val * col->prim;
         }
      }
      /* compute vector of basic variables xB = - inv(B) * N * xN */
      glp_ftran(P, work);
      /* store values of basic variables, check primal feasibility */
      P->pbs_stat = GLP_FEAS;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->stat != GLP_BS)
            continue;
         row->prim = work[row->bind];
         type = row->type;
         if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
         {  eps = 1e-6 + 1e-9 * fabs(row->lb);
            if (row->prim < row->lb - eps)
               P->pbs_stat = GLP_INFEAS;
         }
         if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
         {  eps = 1e-6 + 1e-9 * fabs(row->ub);
            if (row->prim > row->ub + eps)
               P->pbs_stat = GLP_INFEAS;
         }
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->stat != GLP_BS)
            continue;
         col->prim = work[col->bind];
         type = col->type;
         if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
         {  eps = 1e-6 + 1e-9 * fabs(col->lb);
            if (col->prim < col->lb - eps)
               P->pbs_stat = GLP_INFEAS;
         }
         if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
         {  eps = 1e-6 + 1e-9 * fabs(col->ub);
            if (col->prim > col->ub + eps)
               P->pbs_stat = GLP_INFEAS;
         }
      }
      /* compute value of the objective function */
      P->obj_val = P->c0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         P->obj_val += col->coef * col->prim;
      }
      /* build vector cB of objective coefficients at basic variables */
      for (i = 1; i <= P->m; i++)
         work[i] = 0.0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->stat == GLP_BS)
            work[col->bind] = col->coef;
      }
      /* compute vector of simplex multipliers pi = inv(B') * cB */
      glp_btran(P, work);
      /* compute and store reduced costs of non-basic variables d[j] =
         c[j] - N'[j] * pi, check dual feasibility */
      P->dbs_stat = GLP_FEAS;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->stat == GLP_BS)
         {  row->dual = 0.0;
            continue;
         }
         /* N[j] is i-th column of matrix (I|-A) */
         row->dual = - work[i];
#if 0 /* 07/III-2013 */
         type = row->type;
         temp = (P->dir == GLP_MIN ? + row->dual : - row->dual);
         if ((type == GLP_FR || type == GLP_LO) && temp < -1e-5 ||
             (type == GLP_FR || type == GLP_UP) && temp > +1e-5)
            P->dbs_stat = GLP_INFEAS;
#else
         stat = row->stat;
         temp = (P->dir == GLP_MIN ? + row->dual : - row->dual);
         if ((stat == GLP_NF || stat == GLP_NL) && temp < -1e-5 ||
             (stat == GLP_NF || stat == GLP_NU) && temp > +1e-5)
            P->dbs_stat = GLP_INFEAS;
#endif
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->stat == GLP_BS)
         {  col->dual = 0.0;
            continue;
         }
         /* N[j] is (m+j)-th column of matrix (I|-A) */
         col->dual = col->coef;
         for (aij = col->ptr; aij != NULL; aij = aij->c_next)
            col->dual += aij->val * work[aij->row->i];
#if 0 /* 07/III-2013 */
         type = col->type;
         temp = (P->dir == GLP_MIN ? + col->dual : - col->dual);
         if ((type == GLP_FR || type == GLP_LO) && temp < -1e-5 ||
             (type == GLP_FR || type == GLP_UP) && temp > +1e-5)
            P->dbs_stat = GLP_INFEAS;
#else
         stat = col->stat;
         temp = (P->dir == GLP_MIN ? + col->dual : - col->dual);
         if ((stat == GLP_NF || stat == GLP_NL) && temp < -1e-5 ||
             (stat == GLP_NF || stat == GLP_NU) && temp > +1e-5)
            P->dbs_stat = GLP_INFEAS;
#endif
      }
      /* free working array */
      xfree(work);
      ret = 0;
done: return ret;
}

/***********************************************************************
*  NAME
*
*  glp_eval_tab_row - compute row of the simplex tableau
*
*  SYNOPSIS
*
*  int glp_eval_tab_row(glp_prob *lp, int k, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_eval_tab_row computes a row of the current simplex
*  tableau for the basic variable, which is specified by the number k:
*  if 1 <= k <= m, x[k] is k-th auxiliary variable; if m+1 <= k <= m+n,
*  x[k] is (k-m)-th structural variable, where m is number of rows, and
*  n is number of columns. The current basis must be available.
*
*  The routine stores column indices and numerical values of non-zero
*  elements of the computed row using sparse format to the locations
*  ind[1], ..., ind[len] and val[1], ..., val[len], respectively, where
*  0 <= len <= n is number of non-zeros returned on exit.
*
*  Element indices stored in the array ind have the same sense as the
*  index k, i.e. indices 1 to m denote auxiliary variables and indices
*  m+1 to m+n denote structural ones (all these variables are obviously
*  non-basic by definition).
*
*  The computed row shows how the specified basic variable x[k] = xB[i]
*  depends on non-basic variables:
*
*     xB[i] = alfa[i,1]*xN[1] + alfa[i,2]*xN[2] + ... + alfa[i,n]*xN[n],
*
*  where alfa[i,j] are elements of the simplex table row, xN[j] are
*  non-basic (auxiliary and structural) variables.
*
*  RETURNS
*
*  The routine returns number of non-zero elements in the simplex table
*  row stored in the arrays ind and val.
*
*  BACKGROUND
*
*  The system of equality constraints of the LP problem is:
*
*     xR = A * xS,                                                   (1)
*
*  where xR is the vector of auxliary variables, xS is the vector of
*  structural variables, A is the matrix of constraint coefficients.
*
*  The system (1) can be written in homogenous form as follows:
*
*     A~ * x = 0,                                                    (2)
*
*  where A~ = (I | -A) is the augmented constraint matrix (has m rows
*  and m+n columns), x = (xR | xS) is the vector of all (auxiliary and
*  structural) variables.
*
*  By definition for the current basis we have:
*
*     A~ = (B | N),                                                  (3)
*
*  where B is the basis matrix. Thus, the system (2) can be written as:
*
*     B * xB + N * xN = 0.                                           (4)
*
*  From (4) it follows that:
*
*     xB = A^ * xN,                                                  (5)
*
*  where the matrix
*
*     A^ = - inv(B) * N                                              (6)
*
*  is called the simplex table.
*
*  It is understood that i-th row of the simplex table is:
*
*     e * A^ = - e * inv(B) * N,                                     (7)
*
*  where e is a unity vector with e[i] = 1.
*
*  To compute i-th row of the simplex table the routine first computes
*  i-th row of the inverse:
*
*     rho = inv(B') * e,                                             (8)
*
*  where B' is a matrix transposed to B, and then computes elements of
*  i-th row of the simplex table as scalar products:
*
*     alfa[i,j] = - rho * N[j]   for all j,                          (9)
*
*  where N[j] is a column of the augmented constraint matrix A~, which
*  corresponds to some non-basic auxiliary or structural variable. */

int glp_eval_tab_row(glp_prob *lp, int k, int ind[], double val[])
{     int m = lp->m;
      int n = lp->n;
      int i, t, len, lll, *iii;
      double alfa, *rho, *vvv;
      if (!(m == 0 || lp->valid))
         xerror("glp_eval_tab_row: basis factorization does not exist\n"
            );
      if (!(1 <= k && k <= m+n))
         xerror("glp_eval_tab_row: k = %d; variable number out of range"
            , k);
      /* determine xB[i] which corresponds to x[k] */
      if (k <= m)
         i = glp_get_row_bind(lp, k);
      else
         i = glp_get_col_bind(lp, k-m);
      if (i == 0)
         xerror("glp_eval_tab_row: k = %d; variable must be basic", k);
      xassert(1 <= i && i <= m);
      /* allocate working arrays */
      rho = xcalloc(1+m, sizeof(double));
      iii = xcalloc(1+m, sizeof(int));
      vvv = xcalloc(1+m, sizeof(double));
      /* compute i-th row of the inverse; see (8) */
      for (t = 1; t <= m; t++) rho[t] = 0.0;
      rho[i] = 1.0;
      glp_btran(lp, rho);
      /* compute i-th row of the simplex table */
      len = 0;
      for (k = 1; k <= m+n; k++)
      {  if (k <= m)
         {  /* x[k] is auxiliary variable, so N[k] is a unity column */
            if (glp_get_row_stat(lp, k) == GLP_BS) continue;
            /* compute alfa[i,j]; see (9) */
            alfa = - rho[k];
         }
         else
         {  /* x[k] is structural variable, so N[k] is a column of the
               original constraint matrix A with negative sign */
            if (glp_get_col_stat(lp, k-m) == GLP_BS) continue;
            /* compute alfa[i,j]; see (9) */
            lll = glp_get_mat_col(lp, k-m, iii, vvv);
            alfa = 0.0;
            for (t = 1; t <= lll; t++) alfa += rho[iii[t]] * vvv[t];
         }
         /* store alfa[i,j] */
         if (alfa != 0.0) len++, ind[len] = k, val[len] = alfa;
      }
      xassert(len <= n);
      /* free working arrays */
      xfree(rho);
      xfree(iii);
      xfree(vvv);
      /* return to the calling program */
      return len;
}

/***********************************************************************
*  NAME
*
*  glp_eval_tab_col - compute column of the simplex tableau
*
*  SYNOPSIS
*
*  int glp_eval_tab_col(glp_prob *lp, int k, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_eval_tab_col computes a column of the current simplex
*  table for the non-basic variable, which is specified by the number k:
*  if 1 <= k <= m, x[k] is k-th auxiliary variable; if m+1 <= k <= m+n,
*  x[k] is (k-m)-th structural variable, where m is number of rows, and
*  n is number of columns. The current basis must be available.
*
*  The routine stores row indices and numerical values of non-zero
*  elements of the computed column using sparse format to the locations
*  ind[1], ..., ind[len] and val[1], ..., val[len] respectively, where
*  0 <= len <= m is number of non-zeros returned on exit.
*
*  Element indices stored in the array ind have the same sense as the
*  index k, i.e. indices 1 to m denote auxiliary variables and indices
*  m+1 to m+n denote structural ones (all these variables are obviously
*  basic by the definition).
*
*  The computed column shows how basic variables depend on the specified
*  non-basic variable x[k] = xN[j]:
*
*     xB[1] = ... + alfa[1,j]*xN[j] + ...
*     xB[2] = ... + alfa[2,j]*xN[j] + ...
*              . . . . . .
*     xB[m] = ... + alfa[m,j]*xN[j] + ...
*
*  where alfa[i,j] are elements of the simplex table column, xB[i] are
*  basic (auxiliary and structural) variables.
*
*  RETURNS
*
*  The routine returns number of non-zero elements in the simplex table
*  column stored in the arrays ind and val.
*
*  BACKGROUND
*
*  As it was explained in comments to the routine glp_eval_tab_row (see
*  above) the simplex table is the following matrix:
*
*     A^ = - inv(B) * N.                                             (1)
*
*  Therefore j-th column of the simplex table is:
*
*     A^ * e = - inv(B) * N * e = - inv(B) * N[j],                   (2)
*
*  where e is a unity vector with e[j] = 1, B is the basis matrix, N[j]
*  is a column of the augmented constraint matrix A~, which corresponds
*  to the given non-basic auxiliary or structural variable. */

int glp_eval_tab_col(glp_prob *lp, int k, int ind[], double val[])
{     int m = lp->m;
      int n = lp->n;
      int t, len, stat;
      double *col;
      if (!(m == 0 || lp->valid))
         xerror("glp_eval_tab_col: basis factorization does not exist\n"
            );
      if (!(1 <= k && k <= m+n))
         xerror("glp_eval_tab_col: k = %d; variable number out of range"
            , k);
      if (k <= m)
         stat = glp_get_row_stat(lp, k);
      else
         stat = glp_get_col_stat(lp, k-m);
      if (stat == GLP_BS)
         xerror("glp_eval_tab_col: k = %d; variable must be non-basic",
            k);
      /* obtain column N[k] with negative sign */
      col = xcalloc(1+m, sizeof(double));
      for (t = 1; t <= m; t++) col[t] = 0.0;
      if (k <= m)
      {  /* x[k] is auxiliary variable, so N[k] is a unity column */
         col[k] = -1.0;
      }
      else
      {  /* x[k] is structural variable, so N[k] is a column of the
            original constraint matrix A with negative sign */
         len = glp_get_mat_col(lp, k-m, ind, val);
         for (t = 1; t <= len; t++) col[ind[t]] = val[t];
      }
      /* compute column of the simplex table, which corresponds to the
         specified non-basic variable x[k] */
      glp_ftran(lp, col);
      len = 0;
      for (t = 1; t <= m; t++)
      {  if (col[t] != 0.0)
         {  len++;
            ind[len] = glp_get_bhead(lp, t);
            val[len] = col[t];
         }
      }
      xfree(col);
      /* return to the calling program */
      return len;
}

/***********************************************************************
*  NAME
*
*  glp_transform_row - transform explicitly specified row
*
*  SYNOPSIS
*
*  int glp_transform_row(glp_prob *P, int len, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_transform_row performs the same operation as the
*  routine glp_eval_tab_row with exception that the row to be
*  transformed is specified explicitly as a sparse vector.
*
*  The explicitly specified row may be thought as a linear form:
*
*     x = a[1]*x[m+1] + a[2]*x[m+2] + ... + a[n]*x[m+n],             (1)
*
*  where x is an auxiliary variable for this row, a[j] are coefficients
*  of the linear form, x[m+j] are structural variables.
*
*  On entry column indices and numerical values of non-zero elements of
*  the row should be stored in locations ind[1], ..., ind[len] and
*  val[1], ..., val[len], where len is the number of non-zero elements.
*
*  This routine uses the system of equality constraints and the current
*  basis in order to express the auxiliary variable x in (1) through the
*  current non-basic variables (as if the transformed row were added to
*  the problem object and its auxiliary variable were basic), i.e. the
*  resultant row has the form:
*
*     x = alfa[1]*xN[1] + alfa[2]*xN[2] + ... + alfa[n]*xN[n],       (2)
*
*  where xN[j] are non-basic (auxiliary or structural) variables, n is
*  the number of columns in the LP problem object.
*
*  On exit the routine stores indices and numerical values of non-zero
*  elements of the resultant row (2) in locations ind[1], ..., ind[len']
*  and val[1], ..., val[len'], where 0 <= len' <= n is the number of
*  non-zero elements in the resultant row returned by the routine. Note
*  that indices (numbers) of non-basic variables stored in the array ind
*  correspond to original ordinal numbers of variables: indices 1 to m
*  mean auxiliary variables and indices m+1 to m+n mean structural ones.
*
*  RETURNS
*
*  The routine returns len', which is the number of non-zero elements in
*  the resultant row stored in the arrays ind and val.
*
*  BACKGROUND
*
*  The explicitly specified row (1) is transformed in the same way as it
*  were the objective function row.
*
*  From (1) it follows that:
*
*     x = aB * xB + aN * xN,                                         (3)
*
*  where xB is the vector of basic variables, xN is the vector of
*  non-basic variables.
*
*  The simplex table, which corresponds to the current basis, is:
*
*     xB = [-inv(B) * N] * xN.                                       (4)
*
*  Therefore substituting xB from (4) to (3) we have:
*
*     x = aB * [-inv(B) * N] * xN + aN * xN =
*                                                                    (5)
*       = rho * (-N) * xN + aN * xN = alfa * xN,
*
*  where:
*
*     rho = inv(B') * aB,                                            (6)
*
*  and
*
*     alfa = aN + rho * (-N)                                         (7)
*
*  is the resultant row computed by the routine. */

int glp_transform_row(glp_prob *P, int len, int ind[], double val[])
{     int i, j, k, m, n, t, lll, *iii;
      double alfa, *a, *aB, *rho, *vvv;
      if (!glp_bf_exists(P))
         xerror("glp_transform_row: basis factorization does not exist "
            "\n");
      m = glp_get_num_rows(P);
      n = glp_get_num_cols(P);
      /* unpack the row to be transformed to the array a */
      a = xcalloc(1+n, sizeof(double));
      for (j = 1; j <= n; j++) a[j] = 0.0;
      if (!(0 <= len && len <= n))
         xerror("glp_transform_row: len = %d; invalid row length\n",
            len);
      for (t = 1; t <= len; t++)
      {  j = ind[t];
         if (!(1 <= j && j <= n))
            xerror("glp_transform_row: ind[%d] = %d; column index out o"
               "f range\n", t, j);
         if (val[t] == 0.0)
            xerror("glp_transform_row: val[%d] = 0; zero coefficient no"
               "t allowed\n", t);
         if (a[j] != 0.0)
            xerror("glp_transform_row: ind[%d] = %d; duplicate column i"
               "ndices not allowed\n", t, j);
         a[j] = val[t];
      }
      /* construct the vector aB */
      aB = xcalloc(1+m, sizeof(double));
      for (i = 1; i <= m; i++)
      {  k = glp_get_bhead(P, i);
         /* xB[i] is k-th original variable */
         xassert(1 <= k && k <= m+n);
         aB[i] = (k <= m ? 0.0 : a[k-m]);
      }
      /* solve the system B'*rho = aB to compute the vector rho */
      rho = aB, glp_btran(P, rho);
      /* compute coefficients at non-basic auxiliary variables */
      len = 0;
      for (i = 1; i <= m; i++)
      {  if (glp_get_row_stat(P, i) != GLP_BS)
         {  alfa = - rho[i];
            if (alfa != 0.0)
            {  len++;
               ind[len] = i;
               val[len] = alfa;
            }
         }
      }
      /* compute coefficients at non-basic structural variables */
      iii = xcalloc(1+m, sizeof(int));
      vvv = xcalloc(1+m, sizeof(double));
      for (j = 1; j <= n; j++)
      {  if (glp_get_col_stat(P, j) != GLP_BS)
         {  alfa = a[j];
            lll = glp_get_mat_col(P, j, iii, vvv);
            for (t = 1; t <= lll; t++) alfa += vvv[t] * rho[iii[t]];
            if (alfa != 0.0)
            {  len++;
               ind[len] = m+j;
               val[len] = alfa;
            }
         }
      }
      xassert(len <= n);
      xfree(iii);
      xfree(vvv);
      xfree(aB);
      xfree(a);
      return len;
}

/***********************************************************************
*  NAME
*
*  glp_transform_col - transform explicitly specified column
*
*  SYNOPSIS
*
*  int glp_transform_col(glp_prob *P, int len, int ind[], double val[]);
*
*  DESCRIPTION
*
*  The routine glp_transform_col performs the same operation as the
*  routine glp_eval_tab_col with exception that the column to be
*  transformed is specified explicitly as a sparse vector.
*
*  The explicitly specified column may be thought as if it were added
*  to the original system of equality constraints:
*
*     x[1] = a[1,1]*x[m+1] + ... + a[1,n]*x[m+n] + a[1]*x
*     x[2] = a[2,1]*x[m+1] + ... + a[2,n]*x[m+n] + a[2]*x            (1)
*        .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
*     x[m] = a[m,1]*x[m+1] + ... + a[m,n]*x[m+n] + a[m]*x
*
*  where x[i] are auxiliary variables, x[m+j] are structural variables,
*  x is a structural variable for the explicitly specified column, a[i]
*  are constraint coefficients for x.
*
*  On entry row indices and numerical values of non-zero elements of
*  the column should be stored in locations ind[1], ..., ind[len] and
*  val[1], ..., val[len], where len is the number of non-zero elements.
*
*  This routine uses the system of equality constraints and the current
*  basis in order to express the current basic variables through the
*  structural variable x in (1) (as if the transformed column were added
*  to the problem object and the variable x were non-basic), i.e. the
*  resultant column has the form:
*
*     xB[1] = ... + alfa[1]*x
*     xB[2] = ... + alfa[2]*x                                        (2)
*        .  .  .  .  .  .
*     xB[m] = ... + alfa[m]*x
*
*  where xB are basic (auxiliary and structural) variables, m is the
*  number of rows in the problem object.
*
*  On exit the routine stores indices and numerical values of non-zero
*  elements of the resultant column (2) in locations ind[1], ...,
*  ind[len'] and val[1], ..., val[len'], where 0 <= len' <= m is the
*  number of non-zero element in the resultant column returned by the
*  routine. Note that indices (numbers) of basic variables stored in
*  the array ind correspond to original ordinal numbers of variables:
*  indices 1 to m mean auxiliary variables and indices m+1 to m+n mean
*  structural ones.
*
*  RETURNS
*
*  The routine returns len', which is the number of non-zero elements
*  in the resultant column stored in the arrays ind and val.
*
*  BACKGROUND
*
*  The explicitly specified column (1) is transformed in the same way
*  as any other column of the constraint matrix using the formula:
*
*     alfa = inv(B) * a,                                             (3)
*
*  where alfa is the resultant column computed by the routine. */

int glp_transform_col(glp_prob *P, int len, int ind[], double val[])
{     int i, m, t;
      double *a, *alfa;
      if (!glp_bf_exists(P))
         xerror("glp_transform_col: basis factorization does not exist "
            "\n");
      m = glp_get_num_rows(P);
      /* unpack the column to be transformed to the array a */
      a = xcalloc(1+m, sizeof(double));
      for (i = 1; i <= m; i++) a[i] = 0.0;
      if (!(0 <= len && len <= m))
         xerror("glp_transform_col: len = %d; invalid column length\n",
            len);
      for (t = 1; t <= len; t++)
      {  i = ind[t];
         if (!(1 <= i && i <= m))
            xerror("glp_transform_col: ind[%d] = %d; row index out of r"
               "ange\n", t, i);
         if (val[t] == 0.0)
            xerror("glp_transform_col: val[%d] = 0; zero coefficient no"
               "t allowed\n", t);
         if (a[i] != 0.0)
            xerror("glp_transform_col: ind[%d] = %d; duplicate row indi"
               "ces not allowed\n", t, i);
         a[i] = val[t];
      }
      /* solve the system B*a = alfa to compute the vector alfa */
      alfa = a, glp_ftran(P, alfa);
      /* store resultant coefficients */
      len = 0;
      for (i = 1; i <= m; i++)
      {  if (alfa[i] != 0.0)
         {  len++;
            ind[len] = glp_get_bhead(P, i);
            val[len] = alfa[i];
         }
      }
      xfree(a);
      return len;
}

/***********************************************************************
*  NAME
*
*  glp_prim_rtest - perform primal ratio test
*
*  SYNOPSIS
*
*  int glp_prim_rtest(glp_prob *P, int len, const int ind[],
*     const double val[], int dir, double eps);
*
*  DESCRIPTION
*
*  The routine glp_prim_rtest performs the primal ratio test using an
*  explicitly specified column of the simplex table.
*
*  The current basic solution associated with the LP problem object
*  must be primal feasible.
*
*  The explicitly specified column of the simplex table shows how the
*  basic variables xB depend on some non-basic variable x (which is not
*  necessarily presented in the problem object):
*
*     xB[1] = ... + alfa[1] * x + ...
*     xB[2] = ... + alfa[2] * x + ...                                (*)
*         .  .  .  .  .  .  .  .
*     xB[m] = ... + alfa[m] * x + ...
*
*  The column (*) is specifed on entry to the routine using the sparse
*  format. Ordinal numbers of basic variables xB[i] should be placed in
*  locations ind[1], ..., ind[len], where ordinal number 1 to m denote
*  auxiliary variables, and ordinal numbers m+1 to m+n denote structural
*  variables. The corresponding non-zero coefficients alfa[i] should be
*  placed in locations val[1], ..., val[len]. The arrays ind and val are
*  not changed on exit.
*
*  The parameter dir specifies direction in which the variable x changes
*  on entering the basis: +1 means increasing, -1 means decreasing.
*
*  The parameter eps is an absolute tolerance (small positive number)
*  used by the routine to skip small alfa[j] of the row (*).
*
*  The routine determines which basic variable (among specified in
*  ind[1], ..., ind[len]) should leave the basis in order to keep primal
*  feasibility.
*
*  RETURNS
*
*  The routine glp_prim_rtest returns the index piv in the arrays ind
*  and val corresponding to the pivot element chosen, 1 <= piv <= len.
*  If the adjacent basic solution is primal unbounded and therefore the
*  choice cannot be made, the routine returns zero.
*
*  COMMENTS
*
*  If the non-basic variable x is presented in the LP problem object,
*  the column (*) can be computed with the routine glp_eval_tab_col;
*  otherwise it can be computed with the routine glp_transform_col. */

int glp_prim_rtest(glp_prob *P, int len, const int ind[],
      const double val[], int dir, double eps)
{     int k, m, n, piv, t, type, stat;
      double alfa, big, beta, lb, ub, temp, teta;
      if (glp_get_prim_stat(P) != GLP_FEAS)
         xerror("glp_prim_rtest: basic solution is not primal feasible "
            "\n");
      if (!(dir == +1 || dir == -1))
         xerror("glp_prim_rtest: dir = %d; invalid parameter\n", dir);
      if (!(0.0 < eps && eps < 1.0))
         xerror("glp_prim_rtest: eps = %g; invalid parameter\n", eps);
      m = glp_get_num_rows(P);
      n = glp_get_num_cols(P);
      /* initial settings */
      piv = 0, teta = DBL_MAX, big = 0.0;
      /* walk through the entries of the specified column */
      for (t = 1; t <= len; t++)
      {  /* get the ordinal number of basic variable */
         k = ind[t];
         if (!(1 <= k && k <= m+n))
            xerror("glp_prim_rtest: ind[%d] = %d; variable number out o"
               "f range\n", t, k);
         /* determine type, bounds, status and primal value of basic
            variable xB[i] = x[k] in the current basic solution */
         if (k <= m)
         {  type = glp_get_row_type(P, k);
            lb = glp_get_row_lb(P, k);
            ub = glp_get_row_ub(P, k);
            stat = glp_get_row_stat(P, k);
            beta = glp_get_row_prim(P, k);
         }
         else
         {  type = glp_get_col_type(P, k-m);
            lb = glp_get_col_lb(P, k-m);
            ub = glp_get_col_ub(P, k-m);
            stat = glp_get_col_stat(P, k-m);
            beta = glp_get_col_prim(P, k-m);
         }
         if (stat != GLP_BS)
            xerror("glp_prim_rtest: ind[%d] = %d; non-basic variable no"
               "t allowed\n", t, k);
         /* determine influence coefficient at basic variable xB[i]
            in the explicitly specified column and turn to the case of
            increasing the variable x in order to simplify the program
            logic */
         alfa = (dir > 0 ? + val[t] : - val[t]);
         /* analyze main cases */
         if (type == GLP_FR)
         {  /* xB[i] is free variable */
            continue;
         }
         else if (type == GLP_LO)
lo:      {  /* xB[i] has an lower bound */
            if (alfa > - eps) continue;
            temp = (lb - beta) / alfa;
         }
         else if (type == GLP_UP)
up:      {  /* xB[i] has an upper bound */
            if (alfa < + eps) continue;
            temp = (ub - beta) / alfa;
         }
         else if (type == GLP_DB)
         {  /* xB[i] has both lower and upper bounds */
            if (alfa < 0.0) goto lo; else goto up;
         }
         else if (type == GLP_FX)
         {  /* xB[i] is fixed variable */
            if (- eps < alfa && alfa < + eps) continue;
            temp = 0.0;
         }
         else
            xassert(type != type);
         /* if the value of the variable xB[i] violates its lower or
            upper bound (slightly, because the current basis is assumed
            to be primal feasible), temp is negative; we can think this
            happens due to round-off errors and the value is exactly on
            the bound; this allows replacing temp by zero */
         if (temp < 0.0) temp = 0.0;
         /* apply the minimal ratio test */
         if (teta > temp || teta == temp && big < fabs(alfa))
            piv = t, teta = temp, big = fabs(alfa);
      }
      /* return index of the pivot element chosen */
      return piv;
}

/***********************************************************************
*  NAME
*
*  glp_dual_rtest - perform dual ratio test
*
*  SYNOPSIS
*
*  int glp_dual_rtest(glp_prob *P, int len, const int ind[],
*     const double val[], int dir, double eps);
*
*  DESCRIPTION
*
*  The routine glp_dual_rtest performs the dual ratio test using an
*  explicitly specified row of the simplex table.
*
*  The current basic solution associated with the LP problem object
*  must be dual feasible.
*
*  The explicitly specified row of the simplex table is a linear form
*  that shows how some basic variable x (which is not necessarily
*  presented in the problem object) depends on non-basic variables xN:
*
*     x = alfa[1] * xN[1] + alfa[2] * xN[2] + ... + alfa[n] * xN[n]. (*)
*
*  The row (*) is specified on entry to the routine using the sparse
*  format. Ordinal numbers of non-basic variables xN[j] should be placed
*  in locations ind[1], ..., ind[len], where ordinal numbers 1 to m
*  denote auxiliary variables, and ordinal numbers m+1 to m+n denote
*  structural variables. The corresponding non-zero coefficients alfa[j]
*  should be placed in locations val[1], ..., val[len]. The arrays ind
*  and val are not changed on exit.
*
*  The parameter dir specifies direction in which the variable x changes
*  on leaving the basis: +1 means that x goes to its lower bound, and -1
*  means that x goes to its upper bound.
*
*  The parameter eps is an absolute tolerance (small positive number)
*  used by the routine to skip small alfa[j] of the row (*).
*
*  The routine determines which non-basic variable (among specified in
*  ind[1], ..., ind[len]) should enter the basis in order to keep dual
*  feasibility.
*
*  RETURNS
*
*  The routine glp_dual_rtest returns the index piv in the arrays ind
*  and val corresponding to the pivot element chosen, 1 <= piv <= len.
*  If the adjacent basic solution is dual unbounded and therefore the
*  choice cannot be made, the routine returns zero.
*
*  COMMENTS
*
*  If the basic variable x is presented in the LP problem object, the
*  row (*) can be computed with the routine glp_eval_tab_row; otherwise
*  it can be computed with the routine glp_transform_row. */

int glp_dual_rtest(glp_prob *P, int len, const int ind[],
      const double val[], int dir, double eps)
{     int k, m, n, piv, t, stat;
      double alfa, big, cost, obj, temp, teta;
      if (glp_get_dual_stat(P) != GLP_FEAS)
         xerror("glp_dual_rtest: basic solution is not dual feasible\n")
            ;
      if (!(dir == +1 || dir == -1))
         xerror("glp_dual_rtest: dir = %d; invalid parameter\n", dir);
      if (!(0.0 < eps && eps < 1.0))
         xerror("glp_dual_rtest: eps = %g; invalid parameter\n", eps);
      m = glp_get_num_rows(P);
      n = glp_get_num_cols(P);
      /* take into account optimization direction */
      obj = (glp_get_obj_dir(P) == GLP_MIN ? +1.0 : -1.0);
      /* initial settings */
      piv = 0, teta = DBL_MAX, big = 0.0;
      /* walk through the entries of the specified row */
      for (t = 1; t <= len; t++)
      {  /* get ordinal number of non-basic variable */
         k = ind[t];
         if (!(1 <= k && k <= m+n))
            xerror("glp_dual_rtest: ind[%d] = %d; variable number out o"
               "f range\n", t, k);
         /* determine status and reduced cost of non-basic variable
            x[k] = xN[j] in the current basic solution */
         if (k <= m)
         {  stat = glp_get_row_stat(P, k);
            cost = glp_get_row_dual(P, k);
         }
         else
         {  stat = glp_get_col_stat(P, k-m);
            cost = glp_get_col_dual(P, k-m);
         }
         if (stat == GLP_BS)
            xerror("glp_dual_rtest: ind[%d] = %d; basic variable not al"
               "lowed\n", t, k);
         /* determine influence coefficient at non-basic variable xN[j]
            in the explicitly specified row and turn to the case of
            increasing the variable x in order to simplify the program
            logic */
         alfa = (dir > 0 ? + val[t] : - val[t]);
         /* analyze main cases */
         if (stat == GLP_NL)
         {  /* xN[j] is on its lower bound */
            if (alfa < + eps) continue;
            temp = (obj * cost) / alfa;
         }
         else if (stat == GLP_NU)
         {  /* xN[j] is on its upper bound */
            if (alfa > - eps) continue;
            temp = (obj * cost) / alfa;
         }
         else if (stat == GLP_NF)
         {  /* xN[j] is non-basic free variable */
            if (- eps < alfa && alfa < + eps) continue;
            temp = 0.0;
         }
         else if (stat == GLP_NS)
         {  /* xN[j] is non-basic fixed variable */
            continue;
         }
         else
            xassert(stat != stat);
         /* if the reduced cost of the variable xN[j] violates its zero
            bound (slightly, because the current basis is assumed to be
            dual feasible), temp is negative; we can think this happens
            due to round-off errors and the reduced cost is exact zero;
            this allows replacing temp by zero */
         if (temp < 0.0) temp = 0.0;
         /* apply the minimal ratio test */
         if (teta > temp || teta == temp && big < fabs(alfa))
            piv = t, teta = temp, big = fabs(alfa);
      }
      /* return index of the pivot element chosen */
      return piv;
}

/***********************************************************************
*  NAME
*
*  glp_analyze_row - simulate one iteration of dual simplex method
*
*  SYNOPSIS
*
*  int glp_analyze_row(glp_prob *P, int len, const int ind[],
*     const double val[], int type, double rhs, double eps, int *piv,
*     double *x, double *dx, double *y, double *dy, double *dz);
*
*  DESCRIPTION
*
*  Let the current basis be optimal or dual feasible, and there be
*  specified a row (constraint), which is violated by the current basic
*  solution. The routine glp_analyze_row simulates one iteration of the
*  dual simplex method to determine some information on the adjacent
*  basis (see below), where the specified row becomes active constraint
*  (i.e. its auxiliary variable becomes non-basic).
*
*  The current basic solution associated with the problem object passed
*  to the routine must be dual feasible, and its primal components must
*  be defined.
*
*  The row to be analyzed must be previously transformed either with
*  the routine glp_eval_tab_row (if the row is in the problem object)
*  or with the routine glp_transform_row (if the row is external, i.e.
*  not in the problem object). This is needed to express the row only
*  through (auxiliary and structural) variables, which are non-basic in
*  the current basis:
*
*     y = alfa[1] * xN[1] + alfa[2] * xN[2] + ... + alfa[n] * xN[n],
*
*  where y is an auxiliary variable of the row, alfa[j] is an influence
*  coefficient, xN[j] is a non-basic variable.
*
*  The row is passed to the routine in sparse format. Ordinal numbers
*  of non-basic variables are stored in locations ind[1], ..., ind[len],
*  where numbers 1 to m denote auxiliary variables while numbers m+1 to
*  m+n denote structural variables. Corresponding non-zero coefficients
*  alfa[j] are stored in locations val[1], ..., val[len]. The arrays
*  ind and val are ot changed on exit.
*
*  The parameters type and rhs specify the row type and its right-hand
*  side as follows:
*
*     type = GLP_LO: y = sum alfa[j] * xN[j] >= rhs
*
*     type = GLP_UP: y = sum alfa[j] * xN[j] <= rhs
*
*  The parameter eps is an absolute tolerance (small positive number)
*  used by the routine to skip small coefficients alfa[j] on performing
*  the dual ratio test.
*
*  If the operation was successful, the routine stores the following
*  information to corresponding location (if some parameter is NULL,
*  its value is not stored):
*
*  piv   index in the array ind and val, 1 <= piv <= len, determining
*        the non-basic variable, which would enter the adjacent basis;
*
*  x     value of the non-basic variable in the current basis;
*
*  dx    difference between values of the non-basic variable in the
*        adjacent and current bases, dx = x.new - x.old;
*
*  y     value of the row (i.e. of its auxiliary variable) in the
*        current basis;
*
*  dy    difference between values of the row in the adjacent and
*        current bases, dy = y.new - y.old;
*
*  dz    difference between values of the objective function in the
*        adjacent and current bases, dz = z.new - z.old. Note that in
*        case of minimization dz >= 0, and in case of maximization
*        dz <= 0, i.e. in the adjacent basis the objective function
*        always gets worse (degrades). */

int _glp_analyze_row(glp_prob *P, int len, const int ind[],
      const double val[], int type, double rhs, double eps, int *_piv,
      double *_x, double *_dx, double *_y, double *_dy, double *_dz)
{     int t, k, dir, piv, ret = 0;
      double x, dx, y, dy, dz;
      if (P->pbs_stat == GLP_UNDEF)
         xerror("glp_analyze_row: primal basic solution components are "
            "undefined\n");
      if (P->dbs_stat != GLP_FEAS)
         xerror("glp_analyze_row: basic solution is not dual feasible\n"
            );
      /* compute the row value y = sum alfa[j] * xN[j] in the current
         basis */
      if (!(0 <= len && len <= P->n))
         xerror("glp_analyze_row: len = %d; invalid row length\n", len);
      y = 0.0;
      for (t = 1; t <= len; t++)
      {  /* determine value of x[k] = xN[j] in the current basis */
         k = ind[t];
         if (!(1 <= k && k <= P->m+P->n))
            xerror("glp_analyze_row: ind[%d] = %d; row/column index out"
               " of range\n", t, k);
         if (k <= P->m)
         {  /* x[k] is auxiliary variable */
            if (P->row[k]->stat == GLP_BS)
               xerror("glp_analyze_row: ind[%d] = %d; basic auxiliary v"
                  "ariable is not allowed\n", t, k);
            x = P->row[k]->prim;
         }
         else
         {  /* x[k] is structural variable */
            if (P->col[k-P->m]->stat == GLP_BS)
               xerror("glp_analyze_row: ind[%d] = %d; basic structural "
                  "variable is not allowed\n", t, k);
            x = P->col[k-P->m]->prim;
         }
         y += val[t] * x;
      }
      /* check if the row is primal infeasible in the current basis,
         i.e. the constraint is violated at the current point */
      if (type == GLP_LO)
      {  if (y >= rhs)
         {  /* the constraint is not violated */
            ret = 1;
            goto done;
         }
         /* in the adjacent basis y goes to its lower bound */
         dir = +1;
      }
      else if (type == GLP_UP)
      {  if (y <= rhs)
         {  /* the constraint is not violated */
            ret = 1;
            goto done;
         }
         /* in the adjacent basis y goes to its upper bound */
         dir = -1;
      }
      else
         xerror("glp_analyze_row: type = %d; invalid parameter\n",
            type);
      /* compute dy = y.new - y.old */
      dy = rhs - y;
      /* perform dual ratio test to determine which non-basic variable
         should enter the adjacent basis to keep it dual feasible */
      piv = glp_dual_rtest(P, len, ind, val, dir, eps);
      if (piv == 0)
      {  /* no dual feasible adjacent basis exists */
         ret = 2;
         goto done;
      }
      /* non-basic variable x[k] = xN[j] should enter the basis */
      k = ind[piv];
      xassert(1 <= k && k <= P->m+P->n);
      /* determine its value in the current basis */
      if (k <= P->m)
         x = P->row[k]->prim;
      else
         x = P->col[k-P->m]->prim;
      /* compute dx = x.new - x.old = dy / alfa[j] */
      xassert(val[piv] != 0.0);
      dx = dy / val[piv];
      /* compute dz = z.new - z.old = d[j] * dx, where d[j] is reduced
         cost of xN[j] in the current basis */
      if (k <= P->m)
         dz = P->row[k]->dual * dx;
      else
         dz = P->col[k-P->m]->dual * dx;
      /* store the analysis results */
      if (_piv != NULL) *_piv = piv;
      if (_x   != NULL) *_x   = x;
      if (_dx  != NULL) *_dx  = dx;
      if (_y   != NULL) *_y   = y;
      if (_dy  != NULL) *_dy  = dy;
      if (_dz  != NULL) *_dz  = dz;
done: return ret;
}

#if 0
int main(void)
{     /* example program for the routine glp_analyze_row */
      glp_prob *P;
      glp_smcp parm;
      int i, k, len, piv, ret, ind[1+100];
      double rhs, x, dx, y, dy, dz, val[1+100];
      P = glp_create_prob();
      /* read plan.mps (see glpk/examples) */
      ret = glp_read_mps(P, GLP_MPS_DECK, NULL, "plan.mps");
      glp_assert(ret == 0);
      /* and solve it to optimality */
      ret = glp_simplex(P, NULL);
      glp_assert(ret == 0);
      glp_assert(glp_get_status(P) == GLP_OPT);
      /* the optimal objective value is 296.217 */
      /* we would like to know what happens if we would add a new row
         (constraint) to plan.mps:
         .01 * bin1 + .01 * bin2 + .02 * bin4 + .02 * bin5 <= 12 */
      /* first, we specify this new row */
      glp_create_index(P);
      len = 0;
      ind[++len] = glp_find_col(P, "BIN1"), val[len] = .01;
      ind[++len] = glp_find_col(P, "BIN2"), val[len] = .01;
      ind[++len] = glp_find_col(P, "BIN4"), val[len] = .02;
      ind[++len] = glp_find_col(P, "BIN5"), val[len] = .02;
      rhs = 12;
      /* then we can compute value of the row (i.e. of its auxiliary
         variable) in the current basis to see if the constraint is
         violated */
      y = 0.0;
      for (k = 1; k <= len; k++)
         y += val[k] * glp_get_col_prim(P, ind[k]);
      glp_printf("y = %g\n", y);
      /* this prints y = 15.1372, so the constraint is violated, since
         we require that y <= rhs = 12 */
      /* now we transform the row to express it only through non-basic
         (auxiliary and artificial) variables */
      len = glp_transform_row(P, len, ind, val);
      /* finally, we simulate one step of the dual simplex method to
         obtain necessary information for the adjacent basis */
      ret = _glp_analyze_row(P, len, ind, val, GLP_UP, rhs, 1e-9, &piv,
         &x, &dx, &y, &dy, &dz);
      glp_assert(ret == 0);
      glp_printf("k = %d, x = %g; dx = %g; y = %g; dy = %g; dz = %g\n",
         ind[piv], x, dx, y, dy, dz);
      /* this prints dz = 5.64418 and means that in the adjacent basis
         the objective function would be 296.217 + 5.64418 = 301.861 */
      /* now we actually include the row into the problem object; note
         that the arrays ind and val are clobbered, so we need to build
         them once again */
      len = 0;
      ind[++len] = glp_find_col(P, "BIN1"), val[len] = .01;
      ind[++len] = glp_find_col(P, "BIN2"), val[len] = .01;
      ind[++len] = glp_find_col(P, "BIN4"), val[len] = .02;
      ind[++len] = glp_find_col(P, "BIN5"), val[len] = .02;
      rhs = 12;
      i = glp_add_rows(P, 1);
      glp_set_row_bnds(P, i, GLP_UP, 0, rhs);
      glp_set_mat_row(P, i, len, ind, val);
      /* and perform one dual simplex iteration */
      glp_init_smcp(&parm);
      parm.meth = GLP_DUAL;
      parm.it_lim = 1;
      glp_simplex(P, &parm);
      /* the current objective value is 301.861 */
      return 0;
}
#endif

/***********************************************************************
*  NAME
*
*  glp_analyze_bound - analyze active bound of non-basic variable
*
*  SYNOPSIS
*
*  void glp_analyze_bound(glp_prob *P, int k, double *limit1, int *var1,
*     double *limit2, int *var2);
*
*  DESCRIPTION
*
*  The routine glp_analyze_bound analyzes the effect of varying the
*  active bound of specified non-basic variable.
*
*  The non-basic variable is specified by the parameter k, where
*  1 <= k <= m means auxiliary variable of corresponding row while
*  m+1 <= k <= m+n means structural variable (column).
*
*  Note that the current basic solution must be optimal, and the basis
*  factorization must exist.
*
*  Results of the analysis have the following meaning.
*
*  value1 is the minimal value of the active bound, at which the basis
*  still remains primal feasible and thus optimal. -DBL_MAX means that
*  the active bound has no lower limit.
*
*  var1 is the ordinal number of an auxiliary (1 to m) or structural
*  (m+1 to n) basic variable, which reaches its bound first and thereby
*  limits further decreasing the active bound being analyzed.
*  if value1 = -DBL_MAX, var1 is set to 0.
*
*  value2 is the maximal value of the active bound, at which the basis
*  still remains primal feasible and thus optimal. +DBL_MAX means that
*  the active bound has no upper limit.
*
*  var2 is the ordinal number of an auxiliary (1 to m) or structural
*  (m+1 to n) basic variable, which reaches its bound first and thereby
*  limits further increasing the active bound being analyzed.
*  if value2 = +DBL_MAX, var2 is set to 0. */

void glp_analyze_bound(glp_prob *P, int k, double *value1, int *var1,
      double *value2, int *var2)
{     GLPROW *row;
      GLPCOL *col;
      int m, n, stat, kase, p, len, piv, *ind;
      double x, new_x, ll, uu, xx, delta, *val;
#if 0 /* 04/IV-2016 */
      /* sanity checks */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_analyze_bound: P = %p; invalid problem object\n",
            P);
#endif
      m = P->m, n = P->n;
      if (!(P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS))
         xerror("glp_analyze_bound: optimal basic solution required\n");
      if (!(m == 0 || P->valid))
         xerror("glp_analyze_bound: basis factorization required\n");
      if (!(1 <= k && k <= m+n))
         xerror("glp_analyze_bound: k = %d; variable number out of rang"
            "e\n", k);
      /* retrieve information about the specified non-basic variable
         x[k] whose active bound is to be analyzed */
      if (k <= m)
      {  row = P->row[k];
         stat = row->stat;
         x = row->prim;
      }
      else
      {  col = P->col[k-m];
         stat = col->stat;
         x = col->prim;
      }
      if (stat == GLP_BS)
         xerror("glp_analyze_bound: k = %d; basic variable not allowed "
            "\n", k);
      /* allocate working arrays */
      ind = xcalloc(1+m, sizeof(int));
      val = xcalloc(1+m, sizeof(double));
      /* compute column of the simplex table corresponding to the
         non-basic variable x[k] */
      len = glp_eval_tab_col(P, k, ind, val);
      xassert(0 <= len && len <= m);
      /* perform analysis */
      for (kase = -1; kase <= +1; kase += 2)
      {  /* kase < 0 means active bound of x[k] is decreasing;
            kase > 0 means active bound of x[k] is increasing */
         /* use the primal ratio test to determine some basic variable
            x[p] which reaches its bound first */
         piv = glp_prim_rtest(P, len, ind, val, kase, 1e-9);
         if (piv == 0)
         {  /* nothing limits changing the active bound of x[k] */
            p = 0;
            new_x = (kase < 0 ? -DBL_MAX : +DBL_MAX);
            goto store;
         }
         /* basic variable x[p] limits changing the active bound of
            x[k]; determine its value in the current basis */
         xassert(1 <= piv && piv <= len);
         p = ind[piv];
         if (p <= m)
         {  row = P->row[p];
            ll = glp_get_row_lb(P, row->i);
            uu = glp_get_row_ub(P, row->i);
            stat = row->stat;
            xx = row->prim;
         }
         else
         {  col = P->col[p-m];
            ll = glp_get_col_lb(P, col->j);
            uu = glp_get_col_ub(P, col->j);
            stat = col->stat;
            xx = col->prim;
         }
         xassert(stat == GLP_BS);
         /* determine delta x[p] = bound of x[p] - value of x[p] */
         if (kase < 0 && val[piv] > 0.0 ||
             kase > 0 && val[piv] < 0.0)
         {  /* delta x[p] < 0, so x[p] goes toward its lower bound */
            xassert(ll != -DBL_MAX);
            delta = ll - xx;
         }
         else
         {  /* delta x[p] > 0, so x[p] goes toward its upper bound */
            xassert(uu != +DBL_MAX);
            delta = uu - xx;
         }
         /* delta x[p] = alfa[p,k] * delta x[k], so new x[k] = x[k] +
            delta x[k] = x[k] + delta x[p] / alfa[p,k] is the value of
            x[k] in the adjacent basis */
         xassert(val[piv] != 0.0);
         new_x = x + delta / val[piv];
store:   /* store analysis results */
         if (kase < 0)
         {  if (value1 != NULL) *value1 = new_x;
            if (var1 != NULL) *var1 = p;
         }
         else
         {  if (value2 != NULL) *value2 = new_x;
            if (var2 != NULL) *var2 = p;
         }
      }
      /* free working arrays */
      xfree(ind);
      xfree(val);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_analyze_coef - analyze objective coefficient at basic variable
*
*  SYNOPSIS
*
*  void glp_analyze_coef(glp_prob *P, int k, double *coef1, int *var1,
*     double *value1, double *coef2, int *var2, double *value2);
*
*  DESCRIPTION
*
*  The routine glp_analyze_coef analyzes the effect of varying the
*  objective coefficient at specified basic variable.
*
*  The basic variable is specified by the parameter k, where
*  1 <= k <= m means auxiliary variable of corresponding row while
*  m+1 <= k <= m+n means structural variable (column).
*
*  Note that the current basic solution must be optimal, and the basis
*  factorization must exist.
*
*  Results of the analysis have the following meaning.
*
*  coef1 is the minimal value of the objective coefficient, at which
*  the basis still remains dual feasible and thus optimal. -DBL_MAX
*  means that the objective coefficient has no lower limit.
*
*  var1 is the ordinal number of an auxiliary (1 to m) or structural
*  (m+1 to n) non-basic variable, whose reduced cost reaches its zero
*  bound first and thereby limits further decreasing the objective
*  coefficient being analyzed. If coef1 = -DBL_MAX, var1 is set to 0.
*
*  value1 is value of the basic variable being analyzed in an adjacent
*  basis, which is defined as follows. Let the objective coefficient
*  reaches its minimal value (coef1) and continues decreasing. Then the
*  reduced cost of the limiting non-basic variable (var1) becomes dual
*  infeasible and the current basis becomes non-optimal that forces the
*  limiting non-basic variable to enter the basis replacing there some
*  basic variable that leaves the basis to keep primal feasibility.
*  Should note that on determining the adjacent basis current bounds
*  of the basic variable being analyzed are ignored as if it were free
*  (unbounded) variable, so it cannot leave the basis. It may happen
*  that no dual feasible adjacent basis exists, in which case value1 is
*  set to -DBL_MAX or +DBL_MAX.
*
*  coef2 is the maximal value of the objective coefficient, at which
*  the basis still remains dual feasible and thus optimal. +DBL_MAX
*  means that the objective coefficient has no upper limit.
*
*  var2 is the ordinal number of an auxiliary (1 to m) or structural
*  (m+1 to n) non-basic variable, whose reduced cost reaches its zero
*  bound first and thereby limits further increasing the objective
*  coefficient being analyzed. If coef2 = +DBL_MAX, var2 is set to 0.
*
*  value2 is value of the basic variable being analyzed in an adjacent
*  basis, which is defined exactly in the same way as value1 above with
*  exception that now the objective coefficient is increasing. */

void glp_analyze_coef(glp_prob *P, int k, double *coef1, int *var1,
      double *value1, double *coef2, int *var2, double *value2)
{     GLPROW *row; GLPCOL *col;
      int m, n, type, stat, kase, p, q, dir, clen, cpiv, rlen, rpiv,
         *cind, *rind;
      double lb, ub, coef, x, lim_coef, new_x, d, delta, ll, uu, xx,
         *rval, *cval;
#if 0 /* 04/IV-2016 */
      /* sanity checks */
      if (P == NULL || P->magic != GLP_PROB_MAGIC)
         xerror("glp_analyze_coef: P = %p; invalid problem object\n",
            P);
#endif
      m = P->m, n = P->n;
      if (!(P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS))
         xerror("glp_analyze_coef: optimal basic solution required\n");
      if (!(m == 0 || P->valid))
         xerror("glp_analyze_coef: basis factorization required\n");
      if (!(1 <= k && k <= m+n))
         xerror("glp_analyze_coef: k = %d; variable number out of range"
            "\n", k);
      /* retrieve information about the specified basic variable x[k]
         whose objective coefficient c[k] is to be analyzed */
      if (k <= m)
      {  row = P->row[k];
         type = row->type;
         lb = row->lb;
         ub = row->ub;
         coef = 0.0;
         stat = row->stat;
         x = row->prim;
      }
      else
      {  col = P->col[k-m];
         type = col->type;
         lb = col->lb;
         ub = col->ub;
         coef = col->coef;
         stat = col->stat;
         x = col->prim;
      }
      if (stat != GLP_BS)
         xerror("glp_analyze_coef: k = %d; non-basic variable not allow"
            "ed\n", k);
      /* allocate working arrays */
      cind = xcalloc(1+m, sizeof(int));
      cval = xcalloc(1+m, sizeof(double));
      rind = xcalloc(1+n, sizeof(int));
      rval = xcalloc(1+n, sizeof(double));
      /* compute row of the simplex table corresponding to the basic
         variable x[k] */
      rlen = glp_eval_tab_row(P, k, rind, rval);
      xassert(0 <= rlen && rlen <= n);
      /* perform analysis */
      for (kase = -1; kase <= +1; kase += 2)
      {  /* kase < 0 means objective coefficient c[k] is decreasing;
            kase > 0 means objective coefficient c[k] is increasing */
         /* note that decreasing c[k] is equivalent to increasing dual
            variable lambda[k] and vice versa; we need to correctly set
            the dir flag as required by the routine glp_dual_rtest */
         if (P->dir == GLP_MIN)
            dir = - kase;
         else if (P->dir == GLP_MAX)
            dir = + kase;
         else
            xassert(P != P);
         /* use the dual ratio test to determine non-basic variable
            x[q] whose reduced cost d[q] reaches zero bound first */
         rpiv = glp_dual_rtest(P, rlen, rind, rval, dir, 1e-9);
         if (rpiv == 0)
         {  /* nothing limits changing c[k] */
            lim_coef = (kase < 0 ? -DBL_MAX : +DBL_MAX);
            q = 0;
            /* x[k] keeps its current value */
            new_x = x;
            goto store;
         }
         /* non-basic variable x[q] limits changing coefficient c[k];
            determine its status and reduced cost d[k] in the current
            basis */
         xassert(1 <= rpiv && rpiv <= rlen);
         q = rind[rpiv];
         xassert(1 <= q && q <= m+n);
         if (q <= m)
         {  row = P->row[q];
            stat = row->stat;
            d = row->dual;
         }
         else
         {  col = P->col[q-m];
            stat = col->stat;
            d = col->dual;
         }
         /* note that delta d[q] = new d[q] - d[q] = - d[q], because
            new d[q] = 0; delta d[q] = alfa[k,q] * delta c[k], so
            delta c[k] = delta d[q] / alfa[k,q] = - d[q] / alfa[k,q] */
         xassert(rval[rpiv] != 0.0);
         delta = - d / rval[rpiv];
         /* compute new c[k] = c[k] + delta c[k], which is the limiting
            value of the objective coefficient c[k] */
         lim_coef = coef + delta;
         /* let c[k] continue decreasing/increasing that makes d[q]
            dual infeasible and forces x[q] to enter the basis;
            to perform the primal ratio test we need to know in which
            direction x[q] changes on entering the basis; we determine
            that analyzing the sign of delta d[q] (see above), since
            d[q] may be close to zero having wrong sign */
         /* let, for simplicity, the problem is minimization */
         if (kase < 0 && rval[rpiv] > 0.0 ||
             kase > 0 && rval[rpiv] < 0.0)
         {  /* delta d[q] < 0, so d[q] being non-negative will become
               negative, so x[q] will increase */
            dir = +1;
         }
         else
         {  /* delta d[q] > 0, so d[q] being non-positive will become
               positive, so x[q] will decrease */
            dir = -1;
         }
         /* if the problem is maximization, correct the direction */
         if (P->dir == GLP_MAX) dir = - dir;
         /* check that we didn't make a silly mistake */
         if (dir > 0)
            xassert(stat == GLP_NL || stat == GLP_NF);
         else
            xassert(stat == GLP_NU || stat == GLP_NF);
         /* compute column of the simplex table corresponding to the
            non-basic variable x[q] */
         clen = glp_eval_tab_col(P, q, cind, cval);
         /* make x[k] temporarily free (unbounded) */
         if (k <= m)
         {  row = P->row[k];
            row->type = GLP_FR;
            row->lb = row->ub = 0.0;
         }
         else
         {  col = P->col[k-m];
            col->type = GLP_FR;
            col->lb = col->ub = 0.0;
         }
         /* use the primal ratio test to determine some basic variable
            which leaves the basis */
         cpiv = glp_prim_rtest(P, clen, cind, cval, dir, 1e-9);
         /* restore original bounds of the basic variable x[k] */
         if (k <= m)
         {  row = P->row[k];
            row->type = type;
            row->lb = lb, row->ub = ub;
         }
         else
         {  col = P->col[k-m];
            col->type = type;
            col->lb = lb, col->ub = ub;
         }
         if (cpiv == 0)
         {  /* non-basic variable x[q] can change unlimitedly */
            if (dir < 0 && rval[rpiv] > 0.0 ||
                dir > 0 && rval[rpiv] < 0.0)
            {  /* delta x[k] = alfa[k,q] * delta x[q] < 0 */
               new_x = -DBL_MAX;
            }
            else
            {  /* delta x[k] = alfa[k,q] * delta x[q] > 0 */
               new_x = +DBL_MAX;
            }
            goto store;
         }
         /* some basic variable x[p] limits changing non-basic variable
            x[q] in the adjacent basis */
         xassert(1 <= cpiv && cpiv <= clen);
         p = cind[cpiv];
         xassert(1 <= p && p <= m+n);
         xassert(p != k);
         if (p <= m)
         {  row = P->row[p];
            xassert(row->stat == GLP_BS);
            ll = glp_get_row_lb(P, row->i);
            uu = glp_get_row_ub(P, row->i);
            xx = row->prim;
         }
         else
         {  col = P->col[p-m];
            xassert(col->stat == GLP_BS);
            ll = glp_get_col_lb(P, col->j);
            uu = glp_get_col_ub(P, col->j);
            xx = col->prim;
         }
         /* determine delta x[p] = new x[p] - x[p] */
         if (dir < 0 && cval[cpiv] > 0.0 ||
             dir > 0 && cval[cpiv] < 0.0)
         {  /* delta x[p] < 0, so x[p] goes toward its lower bound */
            xassert(ll != -DBL_MAX);
            delta = ll - xx;
         }
         else
         {  /* delta x[p] > 0, so x[p] goes toward its upper bound */
            xassert(uu != +DBL_MAX);
            delta = uu - xx;
         }
         /* compute new x[k] = x[k] + alfa[k,q] * delta x[q], where
            delta x[q] = delta x[p] / alfa[p,q] */
         xassert(cval[cpiv] != 0.0);
         new_x = x + (rval[rpiv] / cval[cpiv]) * delta;
store:   /* store analysis results */
         if (kase < 0)
         {  if (coef1 != NULL) *coef1 = lim_coef;
            if (var1 != NULL) *var1 = q;
            if (value1 != NULL) *value1 = new_x;
         }
         else
         {  if (coef2 != NULL) *coef2 = lim_coef;
            if (var2 != NULL) *var2 = q;
            if (value2 != NULL) *value2 = new_x;
         }
      }
      /* free working arrays */
      xfree(cind);
      xfree(cval);
      xfree(rind);
      xfree(rval);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpapi13.c0000644000175100001710000005447700000000000025011 0ustar00runnerdocker00000000000000/* glpapi13.c (branch-and-bound interface routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/***********************************************************************
*  NAME
*
*  glp_ios_reason - determine reason for calling the callback routine
*
*  SYNOPSIS
*
*  glp_ios_reason(glp_tree *tree);
*
*  RETURNS
*
*  The routine glp_ios_reason returns a code, which indicates why the
*  user-defined callback routine is being called. */

int glp_ios_reason(glp_tree *tree)
{     return
         tree->reason;
}

/***********************************************************************
*  NAME
*
*  glp_ios_get_prob - access the problem object
*
*  SYNOPSIS
*
*  glp_prob *glp_ios_get_prob(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine glp_ios_get_prob can be called from the user-defined
*  callback routine to access the problem object, which is used by the
*  MIP solver. It is the original problem object passed to the routine
*  glp_intopt if the MIP presolver is not used; otherwise it is an
*  internal problem object built by the presolver. If the current
*  subproblem exists, LP segment of the problem object corresponds to
*  its LP relaxation.
*
*  RETURNS
*
*  The routine glp_ios_get_prob returns a pointer to the problem object
*  used by the MIP solver. */

glp_prob *glp_ios_get_prob(glp_tree *tree)
{     return
         tree->mip;
}

/***********************************************************************
*  NAME
*
*  glp_ios_tree_size - determine size of the branch-and-bound tree
*
*  SYNOPSIS
*
*  void glp_ios_tree_size(glp_tree *tree, int *a_cnt, int *n_cnt,
*     int *t_cnt);
*
*  DESCRIPTION
*
*  The routine glp_ios_tree_size stores the following three counts which
*  characterize the current size of the branch-and-bound tree:
*
*  a_cnt is the current number of active nodes, i.e. the current size of
*        the active list;
*
*  n_cnt is the current number of all (active and inactive) nodes;
*
*  t_cnt is the total number of nodes including those which have been
*        already removed from the tree. This count is increased whenever
*        a new node appears in the tree and never decreased.
*
*  If some of the parameters a_cnt, n_cnt, t_cnt is a null pointer, the
*  corresponding count is not stored. */

void glp_ios_tree_size(glp_tree *tree, int *a_cnt, int *n_cnt,
      int *t_cnt)
{     if (a_cnt != NULL) *a_cnt = tree->a_cnt;
      if (n_cnt != NULL) *n_cnt = tree->n_cnt;
      if (t_cnt != NULL) *t_cnt = tree->t_cnt;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_ios_curr_node - determine current active subproblem
*
*  SYNOPSIS
*
*  int glp_ios_curr_node(glp_tree *tree);
*
*  RETURNS
*
*  The routine glp_ios_curr_node returns the reference number of the
*  current active subproblem. However, if the current subproblem does
*  not exist, the routine returns zero. */

int glp_ios_curr_node(glp_tree *tree)
{     IOSNPD *node;
      /* obtain pointer to the current subproblem */
      node = tree->curr;
      /* return its reference number */
      return node == NULL ? 0 : node->p;
}

/***********************************************************************
*  NAME
*
*  glp_ios_next_node - determine next active subproblem
*
*  SYNOPSIS
*
*  int glp_ios_next_node(glp_tree *tree, int p);
*
*  RETURNS
*
*  If the parameter p is zero, the routine glp_ios_next_node returns
*  the reference number of the first active subproblem. However, if the
*  tree is empty, zero is returned.
*
*  If the parameter p is not zero, it must specify the reference number
*  of some active subproblem, in which case the routine returns the
*  reference number of the next active subproblem. However, if there is
*  no next active subproblem in the list, zero is returned.
*
*  All subproblems in the active list are ordered chronologically, i.e.
*  subproblem A precedes subproblem B if A was created before B. */

int glp_ios_next_node(glp_tree *tree, int p)
{     IOSNPD *node;
      if (p == 0)
      {  /* obtain pointer to the first active subproblem */
         node = tree->head;
      }
      else
      {  /* obtain pointer to the specified subproblem */
         if (!(1 <= p && p <= tree->nslots))
err:        xerror("glp_ios_next_node: p = %d; invalid subproblem refer"
               "ence number\n", p);
         node = tree->slot[p].node;
         if (node == NULL) goto err;
         /* the specified subproblem must be active */
         if (node->count != 0)
            xerror("glp_ios_next_node: p = %d; subproblem not in the ac"
               "tive list\n", p);
         /* obtain pointer to the next active subproblem */
         node = node->next;
      }
      /* return the reference number */
      return node == NULL ? 0 : node->p;
}

/***********************************************************************
*  NAME
*
*  glp_ios_prev_node - determine previous active subproblem
*
*  SYNOPSIS
*
*  int glp_ios_prev_node(glp_tree *tree, int p);
*
*  RETURNS
*
*  If the parameter p is zero, the routine glp_ios_prev_node returns
*  the reference number of the last active subproblem. However, if the
*  tree is empty, zero is returned.
*
*  If the parameter p is not zero, it must specify the reference number
*  of some active subproblem, in which case the routine returns the
*  reference number of the previous active subproblem. However, if there
*  is no previous active subproblem in the list, zero is returned.
*
*  All subproblems in the active list are ordered chronologically, i.e.
*  subproblem A precedes subproblem B if A was created before B. */

int glp_ios_prev_node(glp_tree *tree, int p)
{     IOSNPD *node;
      if (p == 0)
      {  /* obtain pointer to the last active subproblem */
         node = tree->tail;
      }
      else
      {  /* obtain pointer to the specified subproblem */
         if (!(1 <= p && p <= tree->nslots))
err:        xerror("glp_ios_prev_node: p = %d; invalid subproblem refer"
               "ence number\n", p);
         node = tree->slot[p].node;
         if (node == NULL) goto err;
         /* the specified subproblem must be active */
         if (node->count != 0)
            xerror("glp_ios_prev_node: p = %d; subproblem not in the ac"
               "tive list\n", p);
         /* obtain pointer to the previous active subproblem */
         node = node->prev;
      }
      /* return the reference number */
      return node == NULL ? 0 : node->p;
}

/***********************************************************************
*  NAME
*
*  glp_ios_up_node - determine parent subproblem
*
*  SYNOPSIS
*
*  int glp_ios_up_node(glp_tree *tree, int p);
*
*  RETURNS
*
*  The parameter p must specify the reference number of some (active or
*  inactive) subproblem, in which case the routine iet_get_up_node
*  returns the reference number of its parent subproblem. However, if
*  the specified subproblem is the root of the tree and, therefore, has
*  no parent, the routine returns zero. */

int glp_ios_up_node(glp_tree *tree, int p)
{     IOSNPD *node;
      /* obtain pointer to the specified subproblem */
      if (!(1 <= p && p <= tree->nslots))
err:     xerror("glp_ios_up_node: p = %d; invalid subproblem reference "
            "number\n", p);
      node = tree->slot[p].node;
      if (node == NULL) goto err;
      /* obtain pointer to the parent subproblem */
      node = node->up;
      /* return the reference number */
      return node == NULL ? 0 : node->p;
}

/***********************************************************************
*  NAME
*
*  glp_ios_node_level - determine subproblem level
*
*  SYNOPSIS
*
*  int glp_ios_node_level(glp_tree *tree, int p);
*
*  RETURNS
*
*  The routine glp_ios_node_level returns the level of the subproblem,
*  whose reference number is p, in the branch-and-bound tree. (The root
*  subproblem has level 0, and the level of any other subproblem is the
*  level of its parent plus one.) */

int glp_ios_node_level(glp_tree *tree, int p)
{     IOSNPD *node;
      /* obtain pointer to the specified subproblem */
      if (!(1 <= p && p <= tree->nslots))
err:     xerror("glp_ios_node_level: p = %d; invalid subproblem referen"
            "ce number\n", p);
      node = tree->slot[p].node;
      if (node == NULL) goto err;
      /* return the node level */
      return node->level;
}

/***********************************************************************
*  NAME
*
*  glp_ios_node_bound - determine subproblem local bound
*
*  SYNOPSIS
*
*  double glp_ios_node_bound(glp_tree *tree, int p);
*
*  RETURNS
*
*  The routine glp_ios_node_bound returns the local bound for (active or
*  inactive) subproblem, whose reference number is p.
*
*  COMMENTS
*
*  The local bound for subproblem p is an lower (minimization) or upper
*  (maximization) bound for integer optimal solution to this subproblem
*  (not to the original problem). This bound is local in the sense that
*  only subproblems in the subtree rooted at node p cannot have better
*  integer feasible solutions.
*
*  On creating a subproblem (due to the branching step) its local bound
*  is inherited from its parent and then may get only stronger (never
*  weaker). For the root subproblem its local bound is initially set to
*  -DBL_MAX (minimization) or +DBL_MAX (maximization) and then improved
*  as the root LP relaxation has been solved.
*
*  Note that the local bound is not necessarily the optimal objective
*  value to corresponding LP relaxation; it may be stronger. */

double glp_ios_node_bound(glp_tree *tree, int p)
{     IOSNPD *node;
      /* obtain pointer to the specified subproblem */
      if (!(1 <= p && p <= tree->nslots))
err:     xerror("glp_ios_node_bound: p = %d; invalid subproblem referen"
            "ce number\n", p);
      node = tree->slot[p].node;
      if (node == NULL) goto err;
      /* return the node local bound */
      return node->bound;
}

/***********************************************************************
*  NAME
*
*  glp_ios_best_node - find active subproblem with best local bound
*
*  SYNOPSIS
*
*  int glp_ios_best_node(glp_tree *tree);
*
*  RETURNS
*
*  The routine glp_ios_best_node returns the reference number of the
*  active subproblem, whose local bound is best (i.e. smallest in case
*  of minimization or largest in case of maximization). However, if the
*  tree is empty, the routine returns zero.
*
*  COMMENTS
*
*  The best local bound is an lower (minimization) or upper
*  (maximization) bound for integer optimal solution to the original
*  MIP problem. */

int glp_ios_best_node(glp_tree *tree)
{     return
         ios_best_node(tree);
}

/***********************************************************************
*  NAME
*
*  glp_ios_mip_gap - compute relative MIP gap
*
*  SYNOPSIS
*
*  double glp_ios_mip_gap(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine glp_ios_mip_gap computes the relative MIP gap with the
*  following formula:
*
*     gap = |best_mip - best_bnd| / (|best_mip| + DBL_EPSILON),
*
*  where best_mip is the best integer feasible solution found so far,
*  best_bnd is the best (global) bound. If no integer feasible solution
*  has been found yet, gap is set to DBL_MAX.
*
*  RETURNS
*
*  The routine glp_ios_mip_gap returns the relative MIP gap. */

double glp_ios_mip_gap(glp_tree *tree)
{     return
         ios_relative_gap(tree);
}

/***********************************************************************
*  NAME
*
*  glp_ios_node_data - access subproblem application-specific data
*
*  SYNOPSIS
*
*  void *glp_ios_node_data(glp_tree *tree, int p);
*
*  DESCRIPTION
*
*  The routine glp_ios_node_data allows the application accessing a
*  memory block allocated for the subproblem (which may be active or
*  inactive), whose reference number is p.
*
*  The size of the block is defined by the control parameter cb_size
*  passed to the routine glp_intopt. The block is initialized by binary
*  zeros on creating corresponding subproblem, and its contents is kept
*  until the subproblem will be removed from the tree.
*
*  The application may use these memory blocks to store specific data
*  for each subproblem.
*
*  RETURNS
*
*  The routine glp_ios_node_data returns a pointer to the memory block
*  for the specified subproblem. Note that if cb_size = 0, the routine
*  returns a null pointer. */

void *glp_ios_node_data(glp_tree *tree, int p)
{     IOSNPD *node;
      /* obtain pointer to the specified subproblem */
      if (!(1 <= p && p <= tree->nslots))
err:     xerror("glp_ios_node_level: p = %d; invalid subproblem referen"
            "ce number\n", p);
      node = tree->slot[p].node;
      if (node == NULL) goto err;
      /* return pointer to the application-specific data */
      return node->data;
}

/***********************************************************************
*  NAME
*
*  glp_ios_row_attr - retrieve additional row attributes
*
*  SYNOPSIS
*
*  void glp_ios_row_attr(glp_tree *tree, int i, glp_attr *attr);
*
*  DESCRIPTION
*
*  The routine glp_ios_row_attr retrieves additional attributes of row
*  i and stores them in the structure glp_attr. */

void glp_ios_row_attr(glp_tree *tree, int i, glp_attr *attr)
{     GLPROW *row;
      if (!(1 <= i && i <= tree->mip->m))
         xerror("glp_ios_row_attr: i = %d; row number out of range\n",
            i);
      row = tree->mip->row[i];
      attr->level = row->level;
      attr->origin = row->origin;
      attr->klass = row->klass;
      return;
}

/**********************************************************************/

int glp_ios_pool_size(glp_tree *tree)
{     /* determine current size of the cut pool */
      if (tree->reason != GLP_ICUTGEN)
         xerror("glp_ios_pool_size: operation not allowed\n");
      xassert(tree->local != NULL);
#ifdef NEW_LOCAL /* 02/II-2018 */
      return tree->local->m;
#else
      return tree->local->size;
#endif
}

/**********************************************************************/

int glp_ios_add_row(glp_tree *tree,
      const char *name, int klass, int flags, int len, const int ind[],
      const double val[], int type, double rhs)
{     /* add row (constraint) to the cut pool */
      int num;
      if (tree->reason != GLP_ICUTGEN)
         xerror("glp_ios_add_row: operation not allowed\n");
      xassert(tree->local != NULL);
      num = ios_add_row(tree, tree->local, name, klass, flags, len,
         ind, val, type, rhs);
      return num;
}

/**********************************************************************/

void glp_ios_del_row(glp_tree *tree, int i)
{     /* remove row (constraint) from the cut pool */
      if (tree->reason != GLP_ICUTGEN)
         xerror("glp_ios_del_row: operation not allowed\n");
      ios_del_row(tree, tree->local, i);
      return;
}

/**********************************************************************/

void glp_ios_clear_pool(glp_tree *tree)
{     /* remove all rows (constraints) from the cut pool */
      if (tree->reason != GLP_ICUTGEN)
         xerror("glp_ios_clear_pool: operation not allowed\n");
      ios_clear_pool(tree, tree->local);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_ios_can_branch - check if can branch upon specified variable
*
*  SYNOPSIS
*
*  int glp_ios_can_branch(glp_tree *tree, int j);
*
*  RETURNS
*
*  If j-th variable (column) can be used to branch upon, the routine
*  glp_ios_can_branch returns non-zero, otherwise zero. */

int glp_ios_can_branch(glp_tree *tree, int j)
{     if (!(1 <= j && j <= tree->mip->n))
         xerror("glp_ios_can_branch: j = %d; column number out of range"
            "\n", j);
      return tree->non_int[j];
}

/***********************************************************************
*  NAME
*
*  glp_ios_branch_upon - choose variable to branch upon
*
*  SYNOPSIS
*
*  void glp_ios_branch_upon(glp_tree *tree, int j, int sel);
*
*  DESCRIPTION
*
*  The routine glp_ios_branch_upon can be called from the user-defined
*  callback routine in response to the reason GLP_IBRANCH to choose a
*  branching variable, whose ordinal number is j. Should note that only
*  variables, for which the routine glp_ios_can_branch returns non-zero,
*  can be used to branch upon.
*
*  The parameter sel is a flag that indicates which branch (subproblem)
*  should be selected next to continue the search:
*
*  GLP_DN_BRNCH - select down-branch;
*  GLP_UP_BRNCH - select up-branch;
*  GLP_NO_BRNCH - use general selection technique. */

void glp_ios_branch_upon(glp_tree *tree, int j, int sel)
{     if (!(1 <= j && j <= tree->mip->n))
         xerror("glp_ios_branch_upon: j = %d; column number out of rang"
            "e\n", j);
      if (!(sel == GLP_DN_BRNCH || sel == GLP_UP_BRNCH ||
            sel == GLP_NO_BRNCH))
         xerror("glp_ios_branch_upon: sel = %d: invalid branch selectio"
            "n flag\n", sel);
      if (!(tree->non_int[j]))
         xerror("glp_ios_branch_upon: j = %d; variable cannot be used t"
            "o branch upon\n", j);
      if (tree->br_var != 0)
         xerror("glp_ios_branch_upon: branching variable already chosen"
            "\n");
      tree->br_var = j;
      tree->br_sel = sel;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_ios_select_node - select subproblem to continue the search
*
*  SYNOPSIS
*
*  void glp_ios_select_node(glp_tree *tree, int p);
*
*  DESCRIPTION
*
*  The routine glp_ios_select_node can be called from the user-defined
*  callback routine in response to the reason GLP_ISELECT to select an
*  active subproblem, whose reference number is p. The search will be
*  continued from the subproblem selected. */

void glp_ios_select_node(glp_tree *tree, int p)
{     IOSNPD *node;
      /* obtain pointer to the specified subproblem */
      if (!(1 <= p && p <= tree->nslots))
err:     xerror("glp_ios_select_node: p = %d; invalid subproblem refere"
            "nce number\n", p);
      node = tree->slot[p].node;
      if (node == NULL) goto err;
      /* the specified subproblem must be active */
      if (node->count != 0)
         xerror("glp_ios_select_node: p = %d; subproblem not in the act"
            "ive list\n", p);
      /* no subproblem must be selected yet */
      if (tree->next_p != 0)
         xerror("glp_ios_select_node: subproblem already selected\n");
      /* select the specified subproblem to continue the search */
      tree->next_p = p;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_ios_heur_sol - provide solution found by heuristic
*
*  SYNOPSIS
*
*  int glp_ios_heur_sol(glp_tree *tree, const double x[]);
*
*  DESCRIPTION
*
*  The routine glp_ios_heur_sol can be called from the user-defined
*  callback routine in response to the reason GLP_IHEUR to provide an
*  integer feasible solution found by a primal heuristic.
*
*  Primal values of *all* variables (columns) found by the heuristic
*  should be placed in locations x[1], ..., x[n], where n is the number
*  of columns in the original problem object. Note that the routine
*  glp_ios_heur_sol *does not* check primal feasibility of the solution
*  provided.
*
*  Using the solution passed in the array x the routine computes value
*  of the objective function. If the objective value is better than the
*  best known integer feasible solution, the routine computes values of
*  auxiliary variables (rows) and stores all solution components in the
*  problem object.
*
*  RETURNS
*
*  If the provided solution is accepted, the routine glp_ios_heur_sol
*  returns zero. Otherwise, if the provided solution is rejected, the
*  routine returns non-zero. */

int glp_ios_heur_sol(glp_tree *tree, const double x[])
{     glp_prob *mip = tree->mip;
      int m = tree->orig_m;
      int n = tree->n;
      int i, j;
      double obj;
      xassert(mip->m >= m);
      xassert(mip->n == n);
      /* check values of integer variables and compute value of the
         objective function */
      obj = mip->c0;
      for (j = 1; j <= n; j++)
      {  GLPCOL *col = mip->col[j];
         if (col->kind == GLP_IV)
         {  /* provided value must be integral */
            if (x[j] != floor(x[j])) return 1;
         }
         obj += col->coef * x[j];
      }
      /* check if the provided solution is better than the best known
         integer feasible solution */
      if (mip->mip_stat == GLP_FEAS)
      {  switch (mip->dir)
         {  case GLP_MIN:
               if (obj >= tree->mip->mip_obj) return 1;
               break;
            case GLP_MAX:
               if (obj <= tree->mip->mip_obj) return 1;
               break;
            default:
               xassert(mip != mip);
         }
      }
      /* it is better; store it in the problem object */
      if (tree->parm->msg_lev >= GLP_MSG_ON)
         xprintf("Solution found by heuristic: %.12g\n", obj);
      mip->mip_stat = GLP_FEAS;
      mip->mip_obj = obj;
      for (j = 1; j <= n; j++)
         mip->col[j]->mipx = x[j];
      for (i = 1; i <= m; i++)
      {  GLPROW *row = mip->row[i];
         GLPAIJ *aij;
         row->mipx = 0.0;
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            row->mipx += aij->val * aij->col->mipx;
      }
#if 1 /* 11/VII-2013 */
      ios_process_sol(tree);
#endif
      return 0;
}

/***********************************************************************
*  NAME
*
*  glp_ios_terminate - terminate the solution process.
*
*  SYNOPSIS
*
*  void glp_ios_terminate(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine glp_ios_terminate sets a flag indicating that the MIP
*  solver should prematurely terminate the search. */

void glp_ios_terminate(glp_tree *tree)
{     if (tree->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("The search is prematurely terminated due to applicati"
            "on request\n");
      tree->stop = 1;
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios01.c0000644000175100001710000015333600000000000025021 0ustar00runnerdocker00000000000000/* glpios01.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"
#include "misc.h"

static int lpx_eval_tab_row(glp_prob *lp, int k, int ind[],
      double val[])
{     /* compute row of the simplex tableau */
      return glp_eval_tab_row(lp, k, ind, val);
}

static int lpx_dual_ratio_test(glp_prob *lp, int len, const int ind[],
      const double val[], int how, double tol)
{     /* perform dual ratio test */
      int piv;
      piv = glp_dual_rtest(lp, len, ind, val, how, tol);
      xassert(0 <= piv && piv <= len);
      return piv == 0 ? 0 : ind[piv];
}

/***********************************************************************
*  NAME
*
*  ios_create_tree - create branch-and-bound tree
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  glp_tree *ios_create_tree(glp_prob *mip, const glp_iocp *parm);
*
*  DESCRIPTION
*
*  The routine ios_create_tree creates the branch-and-bound tree.
*
*  Being created the tree consists of the only root subproblem whose
*  reference number is 1. Note that initially the root subproblem is in
*  frozen state and therefore needs to be revived.
*
*  RETURNS
*
*  The routine returns a pointer to the tree created. */

static IOSNPD *new_node(glp_tree *tree, IOSNPD *parent);

glp_tree *ios_create_tree(glp_prob *mip, const glp_iocp *parm)
{     int m = mip->m;
      int n = mip->n;
      glp_tree *tree;
      int i, j;
      xassert(mip->tree == NULL);
      mip->tree = tree = xmalloc(sizeof(glp_tree));
      tree->pool = dmp_create_pool();
      tree->n = n;
      /* save original problem components */
      tree->orig_m = m;
      tree->orig_type = xcalloc(1+m+n, sizeof(char));
      tree->orig_lb = xcalloc(1+m+n, sizeof(double));
      tree->orig_ub = xcalloc(1+m+n, sizeof(double));
      tree->orig_stat = xcalloc(1+m+n, sizeof(char));
      tree->orig_prim = xcalloc(1+m+n, sizeof(double));
      tree->orig_dual = xcalloc(1+m+n, sizeof(double));
      for (i = 1; i <= m; i++)
      {  GLPROW *row = mip->row[i];
         tree->orig_type[i] = (char)row->type;
         tree->orig_lb[i] = row->lb;
         tree->orig_ub[i] = row->ub;
         tree->orig_stat[i] = (char)row->stat;
         tree->orig_prim[i] = row->prim;
         tree->orig_dual[i] = row->dual;
      }
      for (j = 1; j <= n; j++)
      {  GLPCOL *col = mip->col[j];
         tree->orig_type[m+j] = (char)col->type;
         tree->orig_lb[m+j] = col->lb;
         tree->orig_ub[m+j] = col->ub;
         tree->orig_stat[m+j] = (char)col->stat;
         tree->orig_prim[m+j] = col->prim;
         tree->orig_dual[m+j] = col->dual;
      }
      tree->orig_obj = mip->obj_val;
      /* initialize the branch-and-bound tree */
      tree->nslots = 0;
      tree->avail = 0;
      tree->slot = NULL;
      tree->head = tree->tail = NULL;
      tree->a_cnt = tree->n_cnt = tree->t_cnt = 0;
      /* the root subproblem is not solved yet, so its final components
         are unknown so far */
      tree->root_m = 0;
      tree->root_type = NULL;
      tree->root_lb = tree->root_ub = NULL;
      tree->root_stat = NULL;
      /* the current subproblem does not exist yet */
      tree->curr = NULL;
      tree->mip = mip;
      /*tree->solved = 0;*/
      tree->non_int = xcalloc(1+n, sizeof(char));
      memset(&tree->non_int[1], 0, n);
      /* arrays to save parent subproblem components will be allocated
         later */
      tree->pred_m = tree->pred_max = 0;
      tree->pred_type = NULL;
      tree->pred_lb = tree->pred_ub = NULL;
      tree->pred_stat = NULL;
      /* cut generators */
      tree->local = ios_create_pool(tree);
      /*tree->first_attempt = 1;*/
      /*tree->max_added_cuts = 0;*/
      /*tree->min_eff = 0.0;*/
      /*tree->miss = 0;*/
      /*tree->just_selected = 0;*/
#ifdef NEW_COVER /* 13/II-2018 */
      tree->cov_gen = NULL;
#endif
      tree->mir_gen = NULL;
      tree->clq_gen = NULL;
      /*tree->round = 0;*/
#if 0
      /* create the conflict graph */
      tree->n_ref = xcalloc(1+n, sizeof(int));
      memset(&tree->n_ref[1], 0, n * sizeof(int));
      tree->c_ref = xcalloc(1+n, sizeof(int));
      memset(&tree->c_ref[1], 0, n * sizeof(int));
      tree->g = scg_create_graph(0);
      tree->j_ref = xcalloc(1+tree->g->n_max, sizeof(int));
#endif
      /* pseudocost branching */
      tree->pcost = NULL;
      tree->iwrk = xcalloc(1+n, sizeof(int));
      tree->dwrk = xcalloc(1+n, sizeof(double));
      /* initialize control parameters */
      tree->parm = parm;
      tree->tm_beg = xtime();
#if 0 /* 10/VI-2013 */
      tree->tm_lag = xlset(0);
#else
      tree->tm_lag = 0.0;
#endif
      tree->sol_cnt = 0;
#if 1 /* 11/VII-2013 */
      tree->P = NULL;
      tree->npp = NULL;
      tree->save_sol = parm->save_sol;
      tree->save_cnt = 0;
#endif
      /* initialize advanced solver interface */
      tree->reason = 0;
      tree->reopt = 0;
      tree->reinv = 0;
      tree->br_var = 0;
      tree->br_sel = 0;
      tree->child = 0;
      tree->next_p = 0;
      /*tree->btrack = NULL;*/
      tree->stop = 0;
      /* create the root subproblem, which initially is identical to
         the original MIP */
      new_node(tree, NULL);
      return tree;
}

/***********************************************************************
*  NAME
*
*  ios_revive_node - revive specified subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_revive_node(glp_tree *tree, int p);
*
*  DESCRIPTION
*
*  The routine ios_revive_node revives the specified subproblem, whose
*  reference number is p, and thereby makes it the current subproblem.
*  Note that the specified subproblem must be active. Besides, if the
*  current subproblem already exists, it must be frozen before reviving
*  another subproblem. */

void ios_revive_node(glp_tree *tree, int p)
{     glp_prob *mip = tree->mip;
      IOSNPD *node, *root;
      /* obtain pointer to the specified subproblem */
      xassert(1 <= p && p <= tree->nslots);
      node = tree->slot[p].node;
      xassert(node != NULL);
      /* the specified subproblem must be active */
      xassert(node->count == 0);
      /* the current subproblem must not exist */
      xassert(tree->curr == NULL);
      /* the specified subproblem becomes current */
      tree->curr = node;
      /*tree->solved = 0;*/
      /* obtain pointer to the root subproblem */
      root = tree->slot[1].node;
      xassert(root != NULL);
      /* at this point problem object components correspond to the root
         subproblem, so if the root subproblem should be revived, there
         is nothing more to do */
      if (node == root) goto done;
      xassert(mip->m == tree->root_m);
      /* build path from the root to the current node */
      node->temp = NULL;
      for (node = node; node != NULL; node = node->up)
      {  if (node->up == NULL)
            xassert(node == root);
         else
            node->up->temp = node;
      }
      /* go down from the root to the current node and make necessary
         changes to restore components of the current subproblem */
      for (node = root; node != NULL; node = node->temp)
      {  int m = mip->m;
         int n = mip->n;
         /* if the current node is reached, the problem object at this
            point corresponds to its parent, so save attributes of rows
            and columns for the parent subproblem */
         if (node->temp == NULL)
         {  int i, j;
            tree->pred_m = m;
            /* allocate/reallocate arrays, if necessary */
            if (tree->pred_max < m + n)
            {  int new_size = m + n + 100;
               if (tree->pred_type != NULL) xfree(tree->pred_type);
               if (tree->pred_lb != NULL) xfree(tree->pred_lb);
               if (tree->pred_ub != NULL) xfree(tree->pred_ub);
               if (tree->pred_stat != NULL) xfree(tree->pred_stat);
               tree->pred_max = new_size;
               tree->pred_type = xcalloc(1+new_size, sizeof(char));
               tree->pred_lb = xcalloc(1+new_size, sizeof(double));
               tree->pred_ub = xcalloc(1+new_size, sizeof(double));
               tree->pred_stat = xcalloc(1+new_size, sizeof(char));
            }
            /* save row attributes */
            for (i = 1; i <= m; i++)
            {  GLPROW *row = mip->row[i];
               tree->pred_type[i] = (char)row->type;
               tree->pred_lb[i] = row->lb;
               tree->pred_ub[i] = row->ub;
               tree->pred_stat[i] = (char)row->stat;
            }
            /* save column attributes */
            for (j = 1; j <= n; j++)
            {  GLPCOL *col = mip->col[j];
               tree->pred_type[mip->m+j] = (char)col->type;
               tree->pred_lb[mip->m+j] = col->lb;
               tree->pred_ub[mip->m+j] = col->ub;
               tree->pred_stat[mip->m+j] = (char)col->stat;
            }
         }
         /* change bounds of rows and columns */
         {  IOSBND *b;
            for (b = node->b_ptr; b != NULL; b = b->next)
            {  if (b->k <= m)
                  glp_set_row_bnds(mip, b->k, b->type, b->lb, b->ub);
               else
                  glp_set_col_bnds(mip, b->k-m, b->type, b->lb, b->ub);
            }
         }
         /* change statuses of rows and columns */
         {  IOSTAT *s;
            for (s = node->s_ptr; s != NULL; s = s->next)
            {  if (s->k <= m)
                  glp_set_row_stat(mip, s->k, s->stat);
               else
                  glp_set_col_stat(mip, s->k-m, s->stat);
            }
         }
         /* add new rows */
         if (node->r_ptr != NULL)
         {  IOSROW *r;
            IOSAIJ *a;
            int i, len, *ind;
            double *val;
            ind = xcalloc(1+n, sizeof(int));
            val = xcalloc(1+n, sizeof(double));
            for (r = node->r_ptr; r != NULL; r = r->next)
            {  i = glp_add_rows(mip, 1);
               glp_set_row_name(mip, i, r->name);
#if 1 /* 20/IX-2008 */
               xassert(mip->row[i]->level == 0);
               mip->row[i]->level = node->level;
               mip->row[i]->origin = r->origin;
               mip->row[i]->klass = r->klass;
#endif
               glp_set_row_bnds(mip, i, r->type, r->lb, r->ub);
               len = 0;
               for (a = r->ptr; a != NULL; a = a->next)
                  len++, ind[len] = a->j, val[len] = a->val;
               glp_set_mat_row(mip, i, len, ind, val);
               glp_set_rii(mip, i, r->rii);
               glp_set_row_stat(mip, i, r->stat);
            }
            xfree(ind);
            xfree(val);
         }
#if 0
         /* add new edges to the conflict graph */
         /* add new cliques to the conflict graph */
         /* (not implemented yet) */
         xassert(node->own_nn == 0);
         xassert(node->own_nc == 0);
         xassert(node->e_ptr == NULL);
#endif
      }
      /* the specified subproblem has been revived */
      node = tree->curr;
      /* delete its bound change list */
      while (node->b_ptr != NULL)
      {  IOSBND *b;
         b = node->b_ptr;
         node->b_ptr = b->next;
         dmp_free_atom(tree->pool, b, sizeof(IOSBND));
      }
      /* delete its status change list */
      while (node->s_ptr != NULL)
      {  IOSTAT *s;
         s = node->s_ptr;
         node->s_ptr = s->next;
         dmp_free_atom(tree->pool, s, sizeof(IOSTAT));
      }
#if 1 /* 20/XI-2009 */
      /* delete its row addition list (additional rows may appear, for
         example, due to branching on GUB constraints */
      while (node->r_ptr != NULL)
      {  IOSROW *r;
         r = node->r_ptr;
         node->r_ptr = r->next;
         xassert(r->name == NULL);
         while (r->ptr != NULL)
         {  IOSAIJ *a;
            a = r->ptr;
            r->ptr = a->next;
            dmp_free_atom(tree->pool, a, sizeof(IOSAIJ));
         }
         dmp_free_atom(tree->pool, r, sizeof(IOSROW));
      }
#endif
done: return;
}

/***********************************************************************
*  NAME
*
*  ios_freeze_node - freeze current subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_freeze_node(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_freeze_node freezes the current subproblem. */

void ios_freeze_node(glp_tree *tree)
{     glp_prob *mip = tree->mip;
      int m = mip->m;
      int n = mip->n;
      IOSNPD *node;
      /* obtain pointer to the current subproblem */
      node = tree->curr;
      xassert(node != NULL);
      if (node->up == NULL)
      {  /* freeze the root subproblem */
         int k;
         xassert(node->p == 1);
         xassert(tree->root_m == 0);
         xassert(tree->root_type == NULL);
         xassert(tree->root_lb == NULL);
         xassert(tree->root_ub == NULL);
         xassert(tree->root_stat == NULL);
         tree->root_m = m;
         tree->root_type = xcalloc(1+m+n, sizeof(char));
         tree->root_lb = xcalloc(1+m+n, sizeof(double));
         tree->root_ub = xcalloc(1+m+n, sizeof(double));
         tree->root_stat = xcalloc(1+m+n, sizeof(char));
         for (k = 1; k <= m+n; k++)
         {  if (k <= m)
            {  GLPROW *row = mip->row[k];
               tree->root_type[k] = (char)row->type;
               tree->root_lb[k] = row->lb;
               tree->root_ub[k] = row->ub;
               tree->root_stat[k] = (char)row->stat;
            }
            else
            {  GLPCOL *col = mip->col[k-m];
               tree->root_type[k] = (char)col->type;
               tree->root_lb[k] = col->lb;
               tree->root_ub[k] = col->ub;
               tree->root_stat[k] = (char)col->stat;
            }
         }
      }
      else
      {  /* freeze non-root subproblem */
         int root_m = tree->root_m;
         int pred_m = tree->pred_m;
         int i, j, k;
         xassert(pred_m <= m);
         /* build change lists for rows and columns which exist in the
            parent subproblem */
         xassert(node->b_ptr == NULL);
         xassert(node->s_ptr == NULL);
         for (k = 1; k <= pred_m + n; k++)
         {  int pred_type, pred_stat, type, stat;
            double pred_lb, pred_ub, lb, ub;
            /* determine attributes in the parent subproblem */
            pred_type = tree->pred_type[k];
            pred_lb = tree->pred_lb[k];
            pred_ub = tree->pred_ub[k];
            pred_stat = tree->pred_stat[k];
            /* determine attributes in the current subproblem */
            if (k <= pred_m)
            {  GLPROW *row = mip->row[k];
               type = row->type;
               lb = row->lb;
               ub = row->ub;
               stat = row->stat;
            }
            else
            {  GLPCOL *col = mip->col[k - pred_m];
               type = col->type;
               lb = col->lb;
               ub = col->ub;
               stat = col->stat;
            }
            /* save type and bounds of a row/column, if changed */
            if (!(pred_type == type && pred_lb == lb && pred_ub == ub))
            {  IOSBND *b;
               b = dmp_get_atom(tree->pool, sizeof(IOSBND));
               b->k = k;
               b->type = (unsigned char)type;
               b->lb = lb;
               b->ub = ub;
               b->next = node->b_ptr;
               node->b_ptr = b;
            }
            /* save status of a row/column, if changed */
            if (pred_stat != stat)
            {  IOSTAT *s;
               s = dmp_get_atom(tree->pool, sizeof(IOSTAT));
               s->k = k;
               s->stat = (unsigned char)stat;
               s->next = node->s_ptr;
               node->s_ptr = s;
            }
         }
         /* save new rows added to the current subproblem */
         xassert(node->r_ptr == NULL);
         if (pred_m < m)
         {  int i, len, *ind;
            double *val;
            ind = xcalloc(1+n, sizeof(int));
            val = xcalloc(1+n, sizeof(double));
            for (i = m; i > pred_m; i--)
            {  GLPROW *row = mip->row[i];
               IOSROW *r;
               const char *name;
               r = dmp_get_atom(tree->pool, sizeof(IOSROW));
               name = glp_get_row_name(mip, i);
               if (name == NULL)
                  r->name = NULL;
               else
               {  r->name = dmp_get_atom(tree->pool, strlen(name)+1);
                  strcpy(r->name, name);
               }
#if 1 /* 20/IX-2008 */
               r->origin = row->origin;
               r->klass = row->klass;
#endif
               r->type = (unsigned char)row->type;
               r->lb = row->lb;
               r->ub = row->ub;
               r->ptr = NULL;
               len = glp_get_mat_row(mip, i, ind, val);
               for (k = 1; k <= len; k++)
               {  IOSAIJ *a;
                  a = dmp_get_atom(tree->pool, sizeof(IOSAIJ));
                  a->j = ind[k];
                  a->val = val[k];
                  a->next = r->ptr;
                  r->ptr = a;
               }
               r->rii = row->rii;
               r->stat = (unsigned char)row->stat;
               r->next = node->r_ptr;
               node->r_ptr = r;
            }
            xfree(ind);
            xfree(val);
         }
         /* remove all rows missing in the root subproblem */
         if (m != root_m)
         {  int nrs, *num;
            nrs = m - root_m;
            xassert(nrs > 0);
            num = xcalloc(1+nrs, sizeof(int));
            for (i = 1; i <= nrs; i++) num[i] = root_m + i;
            glp_del_rows(mip, nrs, num);
            xfree(num);
         }
         m = mip->m;
         /* and restore attributes of all rows and columns for the root
            subproblem */
         xassert(m == root_m);
         for (i = 1; i <= m; i++)
         {  glp_set_row_bnds(mip, i, tree->root_type[i],
               tree->root_lb[i], tree->root_ub[i]);
            glp_set_row_stat(mip, i, tree->root_stat[i]);
         }
         for (j = 1; j <= n; j++)
         {  glp_set_col_bnds(mip, j, tree->root_type[m+j],
               tree->root_lb[m+j], tree->root_ub[m+j]);
            glp_set_col_stat(mip, j, tree->root_stat[m+j]);
         }
#if 1
         /* remove all edges and cliques missing in the conflict graph
            for the root subproblem */
         /* (not implemented yet) */
#endif
      }
      /* the current subproblem has been frozen */
      tree->curr = NULL;
      return;
}

/***********************************************************************
*  NAME
*
*  ios_clone_node - clone specified subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_clone_node(glp_tree *tree, int p, int nnn, int ref[]);
*
*  DESCRIPTION
*
*  The routine ios_clone_node clones the specified subproblem, whose
*  reference number is p, creating its nnn exact copies. Note that the
*  specified subproblem must be active and must be in the frozen state
*  (i.e. it must not be the current subproblem).
*
*  Each clone, an exact copy of the specified subproblem, becomes a new
*  active subproblem added to the end of the active list. After cloning
*  the specified subproblem becomes inactive.
*
*  The reference numbers of clone subproblems are stored to locations
*  ref[1], ..., ref[nnn]. */

static int get_slot(glp_tree *tree)
{     int p;
      /* if no free slots are available, increase the room */
      if (tree->avail == 0)
      {  int nslots = tree->nslots;
         IOSLOT *save = tree->slot;
         if (nslots == 0)
            tree->nslots = 20;
         else
         {  tree->nslots = nslots + nslots;
            xassert(tree->nslots > nslots);
         }
         tree->slot = xcalloc(1+tree->nslots, sizeof(IOSLOT));
         if (save != NULL)
         {  memcpy(&tree->slot[1], &save[1], nslots * sizeof(IOSLOT));
            xfree(save);
         }
         /* push more free slots into the stack */
         for (p = tree->nslots; p > nslots; p--)
         {  tree->slot[p].node = NULL;
            tree->slot[p].next = tree->avail;
            tree->avail = p;
         }
      }
      /* pull a free slot from the stack */
      p = tree->avail;
      tree->avail = tree->slot[p].next;
      xassert(tree->slot[p].node == NULL);
      tree->slot[p].next = 0;
      return p;
}

static IOSNPD *new_node(glp_tree *tree, IOSNPD *parent)
{     IOSNPD *node;
      int p;
      /* pull a free slot for the new node */
      p = get_slot(tree);
      /* create descriptor of the new subproblem */
      node = dmp_get_atom(tree->pool, sizeof(IOSNPD));
      tree->slot[p].node = node;
      node->p = p;
      node->up = parent;
      node->level = (parent == NULL ? 0 : parent->level + 1);
      node->count = 0;
      node->b_ptr = NULL;
      node->s_ptr = NULL;
      node->r_ptr = NULL;
      node->solved = 0;
#if 0
      node->own_nn = node->own_nc = 0;
      node->e_ptr = NULL;
#endif
#if 1 /* 04/X-2008 */
      node->lp_obj = (parent == NULL ? (tree->mip->dir == GLP_MIN ?
         -DBL_MAX : +DBL_MAX) : parent->lp_obj);
#endif
      node->bound = (parent == NULL ? (tree->mip->dir == GLP_MIN ?
         -DBL_MAX : +DBL_MAX) : parent->bound);
      node->br_var = 0;
      node->br_val = 0.0;
      node->ii_cnt = 0;
      node->ii_sum = 0.0;
#if 1 /* 30/XI-2009 */
      node->changed = 0;
#endif
      if (tree->parm->cb_size == 0)
         node->data = NULL;
      else
      {  node->data = dmp_get_atom(tree->pool, tree->parm->cb_size);
         memset(node->data, 0, tree->parm->cb_size);
      }
      node->temp = NULL;
      node->prev = tree->tail;
      node->next = NULL;
      /* add the new subproblem to the end of the active list */
      if (tree->head == NULL)
         tree->head = node;
      else
         tree->tail->next = node;
      tree->tail = node;
      tree->a_cnt++;
      tree->n_cnt++;
      tree->t_cnt++;
      /* increase the number of child subproblems */
      if (parent == NULL)
         xassert(p == 1);
      else
         parent->count++;
      return node;
}

void ios_clone_node(glp_tree *tree, int p, int nnn, int ref[])
{     IOSNPD *node;
      int k;
      /* obtain pointer to the subproblem to be cloned */
      xassert(1 <= p && p <= tree->nslots);
      node = tree->slot[p].node;
      xassert(node != NULL);
      /* the specified subproblem must be active */
      xassert(node->count == 0);
      /* and must be in the frozen state */
      xassert(tree->curr != node);
      /* remove the specified subproblem from the active list, because
         it becomes inactive */
      if (node->prev == NULL)
         tree->head = node->next;
      else
         node->prev->next = node->next;
      if (node->next == NULL)
         tree->tail = node->prev;
      else
         node->next->prev = node->prev;
      node->prev = node->next = NULL;
      tree->a_cnt--;
      /* create clone subproblems */
      xassert(nnn > 0);
      for (k = 1; k <= nnn; k++)
         ref[k] = new_node(tree, node)->p;
      return;
}

/***********************************************************************
*  NAME
*
*  ios_delete_node - delete specified subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_delete_node(glp_tree *tree, int p);
*
*  DESCRIPTION
*
*  The routine ios_delete_node deletes the specified subproblem, whose
*  reference number is p. The subproblem must be active and must be in
*  the frozen state (i.e. it must not be the current subproblem).
*
*  Note that deletion is performed recursively, i.e. if a subproblem to
*  be deleted is the only child of its parent, the parent subproblem is
*  also deleted, etc. */

void ios_delete_node(glp_tree *tree, int p)
{     IOSNPD *node, *temp;
      /* obtain pointer to the subproblem to be deleted */
      xassert(1 <= p && p <= tree->nslots);
      node = tree->slot[p].node;
      xassert(node != NULL);
      /* the specified subproblem must be active */
      xassert(node->count == 0);
      /* and must be in the frozen state */
      xassert(tree->curr != node);
      /* remove the specified subproblem from the active list, because
         it is gone from the tree */
      if (node->prev == NULL)
         tree->head = node->next;
      else
         node->prev->next = node->next;
      if (node->next == NULL)
         tree->tail = node->prev;
      else
         node->next->prev = node->prev;
      node->prev = node->next = NULL;
      tree->a_cnt--;
loop: /* recursive deletion starts here */
      /* delete the bound change list */
      {  IOSBND *b;
         while (node->b_ptr != NULL)
         {  b = node->b_ptr;
            node->b_ptr = b->next;
            dmp_free_atom(tree->pool, b, sizeof(IOSBND));
         }
      }
      /* delete the status change list */
      {  IOSTAT *s;
         while (node->s_ptr != NULL)
         {  s = node->s_ptr;
            node->s_ptr = s->next;
            dmp_free_atom(tree->pool, s, sizeof(IOSTAT));
         }
      }
      /* delete the row addition list */
      while (node->r_ptr != NULL)
      {  IOSROW *r;
         r = node->r_ptr;
         if (r->name != NULL)
            dmp_free_atom(tree->pool, r->name, strlen(r->name)+1);
         while (r->ptr != NULL)
         {  IOSAIJ *a;
            a = r->ptr;
            r->ptr = a->next;
            dmp_free_atom(tree->pool, a, sizeof(IOSAIJ));
         }
         node->r_ptr = r->next;
         dmp_free_atom(tree->pool, r, sizeof(IOSROW));
      }
#if 0
      /* delete the edge addition list */
      /* delete the clique addition list */
      /* (not implemented yet) */
      xassert(node->own_nn == 0);
      xassert(node->own_nc == 0);
      xassert(node->e_ptr == NULL);
#endif
      /* free application-specific data */
      if (tree->parm->cb_size == 0)
         xassert(node->data == NULL);
      else
         dmp_free_atom(tree->pool, node->data, tree->parm->cb_size);
      /* free the corresponding node slot */
      p = node->p;
      xassert(tree->slot[p].node == node);
      tree->slot[p].node = NULL;
      tree->slot[p].next = tree->avail;
      tree->avail = p;
      /* save pointer to the parent subproblem */
      temp = node->up;
      /* delete the subproblem descriptor */
      dmp_free_atom(tree->pool, node, sizeof(IOSNPD));
      tree->n_cnt--;
      /* take pointer to the parent subproblem */
      node = temp;
      if (node != NULL)
      {  /* the parent subproblem exists; decrease the number of its
            child subproblems */
         xassert(node->count > 0);
         node->count--;
         /* if now the parent subproblem has no childs, it also must be
            deleted */
         if (node->count == 0) goto loop;
      }
      return;
}

/***********************************************************************
*  NAME
*
*  ios_delete_tree - delete branch-and-bound tree
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_delete_tree(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_delete_tree deletes the branch-and-bound tree, which
*  the parameter tree points to, and frees all the memory allocated to
*  this program object.
*
*  On exit components of the problem object are restored to correspond
*  to the original MIP passed to the routine ios_create_tree. */

void ios_delete_tree(glp_tree *tree)
{     glp_prob *mip = tree->mip;
      int i, j;
      int m = mip->m;
      int n = mip->n;
      xassert(mip->tree == tree);
      /* remove all additional rows */
      if (m != tree->orig_m)
      {  int nrs, *num;
         nrs = m - tree->orig_m;
         xassert(nrs > 0);
         num = xcalloc(1+nrs, sizeof(int));
         for (i = 1; i <= nrs; i++) num[i] = tree->orig_m + i;
         glp_del_rows(mip, nrs, num);
         xfree(num);
      }
      m = tree->orig_m;
      /* restore original attributes of rows and columns */
      xassert(m == tree->orig_m);
      xassert(n == tree->n);
      for (i = 1; i <= m; i++)
      {  glp_set_row_bnds(mip, i, tree->orig_type[i],
            tree->orig_lb[i], tree->orig_ub[i]);
         glp_set_row_stat(mip, i, tree->orig_stat[i]);
         mip->row[i]->prim = tree->orig_prim[i];
         mip->row[i]->dual = tree->orig_dual[i];
      }
      for (j = 1; j <= n; j++)
      {  glp_set_col_bnds(mip, j, tree->orig_type[m+j],
            tree->orig_lb[m+j], tree->orig_ub[m+j]);
         glp_set_col_stat(mip, j, tree->orig_stat[m+j]);
         mip->col[j]->prim = tree->orig_prim[m+j];
         mip->col[j]->dual = tree->orig_dual[m+j];
      }
      mip->pbs_stat = mip->dbs_stat = GLP_FEAS;
      mip->obj_val = tree->orig_obj;
      /* delete the branch-and-bound tree */
      xassert(tree->local != NULL);
      ios_delete_pool(tree, tree->local);
      dmp_delete_pool(tree->pool);
      xfree(tree->orig_type);
      xfree(tree->orig_lb);
      xfree(tree->orig_ub);
      xfree(tree->orig_stat);
      xfree(tree->orig_prim);
      xfree(tree->orig_dual);
      xfree(tree->slot);
      if (tree->root_type != NULL) xfree(tree->root_type);
      if (tree->root_lb != NULL) xfree(tree->root_lb);
      if (tree->root_ub != NULL) xfree(tree->root_ub);
      if (tree->root_stat != NULL) xfree(tree->root_stat);
      xfree(tree->non_int);
#if 0
      xfree(tree->n_ref);
      xfree(tree->c_ref);
      xfree(tree->j_ref);
#endif
      if (tree->pcost != NULL) ios_pcost_free(tree);
      xfree(tree->iwrk);
      xfree(tree->dwrk);
#if 0
      scg_delete_graph(tree->g);
#endif
      if (tree->pred_type != NULL) xfree(tree->pred_type);
      if (tree->pred_lb != NULL) xfree(tree->pred_lb);
      if (tree->pred_ub != NULL) xfree(tree->pred_ub);
      if (tree->pred_stat != NULL) xfree(tree->pred_stat);
#if 0
      xassert(tree->cut_gen == NULL);
#endif
      xassert(tree->mir_gen == NULL);
      xassert(tree->clq_gen == NULL);
      xfree(tree);
      mip->tree = NULL;
      return;
}

/***********************************************************************
*  NAME
*
*  ios_eval_degrad - estimate obj. degrad. for down- and up-branches
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_eval_degrad(glp_tree *tree, int j, double *dn, double *up);
*
*  DESCRIPTION
*
*  Given optimal basis to LP relaxation of the current subproblem the
*  routine ios_eval_degrad performs the dual ratio test to compute the
*  objective values in the adjacent basis for down- and up-branches,
*  which are stored in locations *dn and *up, assuming that x[j] is a
*  variable chosen to branch upon. */

void ios_eval_degrad(glp_tree *tree, int j, double *dn, double *up)
{     glp_prob *mip = tree->mip;
      int m = mip->m, n = mip->n;
      int len, kase, k, t, stat;
      double alfa, beta, gamma, delta, dz;
      int *ind = tree->iwrk;
      double *val = tree->dwrk;
      /* current basis must be optimal */
      xassert(glp_get_status(mip) == GLP_OPT);
      /* basis factorization must exist */
      xassert(glp_bf_exists(mip));
      /* obtain (fractional) value of x[j] in optimal basic solution
         to LP relaxation of the current subproblem */
      xassert(1 <= j && j <= n);
      beta = mip->col[j]->prim;
      /* since the value of x[j] is fractional, it is basic; compute
         corresponding row of the simplex table */
      len = lpx_eval_tab_row(mip, m+j, ind, val);
      /* kase < 0 means down-branch; kase > 0 means up-branch */
      for (kase = -1; kase <= +1; kase += 2)
      {  /* for down-branch we introduce new upper bound floor(beta)
            for x[j]; similarly, for up-branch we introduce new lower
            bound ceil(beta) for x[j]; in the current basis this new
            upper/lower bound is violated, so in the adjacent basis
            x[j] will leave the basis and go to its new upper/lower
            bound; we need to know which non-basic variable x[k] should
            enter the basis to keep dual feasibility */
#if 0 /* 23/XI-2009 */
         k = lpx_dual_ratio_test(mip, len, ind, val, kase, 1e-7);
#else
         k = lpx_dual_ratio_test(mip, len, ind, val, kase, 1e-9);
#endif
         /* if no variable has been chosen, current basis being primal
            infeasible due to the new upper/lower bound of x[j] is dual
            unbounded, therefore, LP relaxation to corresponding branch
            has no primal feasible solution */
         if (k == 0)
         {  if (mip->dir == GLP_MIN)
            {  if (kase < 0)
                  *dn = +DBL_MAX;
               else
                  *up = +DBL_MAX;
            }
            else if (mip->dir == GLP_MAX)
            {  if (kase < 0)
                  *dn = -DBL_MAX;
               else
                  *up = -DBL_MAX;
            }
            else
               xassert(mip != mip);
            continue;
         }
         xassert(1 <= k && k <= m+n);
         /* row of the simplex table corresponding to specified basic
            variable x[j] is the following:
               x[j] = ... + alfa * x[k] + ... ;
            we need to know influence coefficient, alfa, at non-basic
            variable x[k] chosen with the dual ratio test */
         for (t = 1; t <= len; t++)
            if (ind[t] == k) break;
         xassert(1 <= t && t <= len);
         alfa = val[t];
         /* determine status and reduced cost of variable x[k] */
         if (k <= m)
         {  stat = mip->row[k]->stat;
            gamma = mip->row[k]->dual;
         }
         else
         {  stat = mip->col[k-m]->stat;
            gamma = mip->col[k-m]->dual;
         }
         /* x[k] cannot be basic or fixed non-basic */
         xassert(stat == GLP_NL || stat == GLP_NU || stat == GLP_NF);
         /* if the current basis is dual degenerative, some reduced
            costs, which are close to zero, may have wrong sign due to
            round-off errors, so correct the sign of gamma */
         if (mip->dir == GLP_MIN)
         {  if (stat == GLP_NL && gamma < 0.0 ||
                stat == GLP_NU && gamma > 0.0 ||
                stat == GLP_NF) gamma = 0.0;
         }
         else if (mip->dir == GLP_MAX)
         {  if (stat == GLP_NL && gamma > 0.0 ||
                stat == GLP_NU && gamma < 0.0 ||
                stat == GLP_NF) gamma = 0.0;
         }
         else
            xassert(mip != mip);
         /* determine the change of x[j] in the adjacent basis:
            delta x[j] = new x[j] - old x[j] */
         delta = (kase < 0 ? floor(beta) : ceil(beta)) - beta;
         /* compute the change of x[k] in the adjacent basis:
            delta x[k] = new x[k] - old x[k] = delta x[j] / alfa */
         delta /= alfa;
         /* compute the change of the objective in the adjacent basis:
            delta z = new z - old z = gamma * delta x[k] */
         dz = gamma * delta;
         if (mip->dir == GLP_MIN)
            xassert(dz >= 0.0);
         else if (mip->dir == GLP_MAX)
            xassert(dz <= 0.0);
         else
            xassert(mip != mip);
         /* compute the new objective value in the adjacent basis:
            new z = old z + delta z */
         if (kase < 0)
            *dn = mip->obj_val + dz;
         else
            *up = mip->obj_val + dz;
      }
      /*xprintf("obj = %g; dn = %g; up = %g\n",
         mip->obj_val, *dn, *up);*/
      return;
}

/***********************************************************************
*  NAME
*
*  ios_round_bound - improve local bound by rounding
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  double ios_round_bound(glp_tree *tree, double bound);
*
*  RETURNS
*
*  For the given local bound for any integer feasible solution to the
*  current subproblem the routine ios_round_bound returns an improved
*  local bound for the same integer feasible solution.
*
*  BACKGROUND
*
*  Let the current subproblem has the following objective function:
*
*     z =   sum  c[j] * x[j] + s >= b,                               (1)
*         j in J
*
*  where J = {j: c[j] is non-zero and integer, x[j] is integer}, s is
*  the sum of terms corresponding to fixed variables, b is an initial
*  local bound (minimization).
*
*  From (1) it follows that:
*
*     d *  sum  (c[j] / d) * x[j] + s >= b,                          (2)
*        j in J
*
*  or, equivalently,
*
*     sum  (c[j] / d) * x[j] >= (b - s) / d = h,                     (3)
*   j in J
*
*  where d = gcd(c[j]). Since the left-hand side of (3) is integer,
*  h = (b - s) / d can be rounded up to the nearest integer:
*
*     h' = ceil(h) = (b' - s) / d,                                   (4)
*
*  that gives an rounded, improved local bound:
*
*     b' = d * h' + s.                                               (5)
*
*  In case of maximization '>=' in (1) should be replaced by '<=' that
*  leads to the following formula:
*
*     h' = floor(h) = (b' - s) / d,                                  (6)
*
*  which should used in the same way as (4).
*
*  NOTE: If b is a valid local bound for a child of the current
*        subproblem, b' is also valid for that child subproblem. */

double ios_round_bound(glp_tree *tree, double bound)
{     glp_prob *mip = tree->mip;
      int n = mip->n;
      int d, j, nn, *c = tree->iwrk;
      double s, h;
      /* determine c[j] and compute s */
      nn = 0, s = mip->c0, d = 0;
      for (j = 1; j <= n; j++)
      {  GLPCOL *col = mip->col[j];
         if (col->coef == 0.0) continue;
         if (col->type == GLP_FX)
         {  /* fixed variable */
            s += col->coef * col->prim;
         }
         else
         {  /* non-fixed variable */
            if (col->kind != GLP_IV) goto skip;
            if (col->coef != floor(col->coef)) goto skip;
            if (fabs(col->coef) <= (double)INT_MAX)
               c[++nn] = (int)fabs(col->coef);
            else
               d = 1;
         }
      }
      /* compute d = gcd(c[1],...c[nn]) */
      if (d == 0)
      {  if (nn == 0) goto skip;
         d = gcdn(nn, c);
      }
      xassert(d > 0);
      /* compute new local bound */
      if (mip->dir == GLP_MIN)
      {  if (bound != +DBL_MAX)
         {  h = (bound - s) / (double)d;
            if (h >= floor(h) + 0.001)
            {  /* round up */
               h = ceil(h);
               /*xprintf("d = %d; old = %g; ", d, bound);*/
               bound = (double)d * h + s;
               /*xprintf("new = %g\n", bound);*/
            }
         }
      }
      else if (mip->dir == GLP_MAX)
      {  if (bound != -DBL_MAX)
         {  h = (bound - s) / (double)d;
            if (h <= ceil(h) - 0.001)
            {  /* round down */
               h = floor(h);
               bound = (double)d * h + s;
            }
         }
      }
      else
         xassert(mip != mip);
skip: return bound;
}

/***********************************************************************
*  NAME
*
*  ios_is_hopeful - check if subproblem is hopeful
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_is_hopeful(glp_tree *tree, double bound);
*
*  DESCRIPTION
*
*  Given the local bound of a subproblem the routine ios_is_hopeful
*  checks if the subproblem can have an integer optimal solution which
*  is better than the best one currently known.
*
*  RETURNS
*
*  If the subproblem can have a better integer optimal solution, the
*  routine returns non-zero; otherwise, if the corresponding branch can
*  be pruned, the routine returns zero. */

int ios_is_hopeful(glp_tree *tree, double bound)
{     glp_prob *mip = tree->mip;
      int ret = 1;
      double eps;
      if (mip->mip_stat == GLP_FEAS)
      {  eps = tree->parm->tol_obj * (1.0 + fabs(mip->mip_obj));
         switch (mip->dir)
         {  case GLP_MIN:
               if (bound >= mip->mip_obj - eps) ret = 0;
               break;
            case GLP_MAX:
               if (bound <= mip->mip_obj + eps) ret = 0;
               break;
            default:
               xassert(mip != mip);
         }
      }
      else
      {  switch (mip->dir)
         {  case GLP_MIN:
               if (bound == +DBL_MAX) ret = 0;
               break;
            case GLP_MAX:
               if (bound == -DBL_MAX) ret = 0;
               break;
            default:
               xassert(mip != mip);
         }
      }
      return ret;
}

/***********************************************************************
*  NAME
*
*  ios_best_node - find active node with best local bound
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_best_node(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_best_node finds an active node whose local bound is
*  best among other active nodes.
*
*  It is understood that the integer optimal solution of the original
*  mip problem cannot be better than the best bound, so the best bound
*  is an lower (minimization) or upper (maximization) global bound for
*  the original problem.
*
*  RETURNS
*
*  The routine ios_best_node returns the subproblem reference number
*  for the best node. However, if the tree is empty, it returns zero. */

int ios_best_node(glp_tree *tree)
{     IOSNPD *node, *best = NULL;
      switch (tree->mip->dir)
      {  case GLP_MIN:
            /* minimization */
            for (node = tree->head; node != NULL; node = node->next)
               if (best == NULL || best->bound > node->bound)
                  best = node;
            break;
         case GLP_MAX:
            /* maximization */
            for (node = tree->head; node != NULL; node = node->next)
               if (best == NULL || best->bound < node->bound)
                  best = node;
            break;
         default:
            xassert(tree != tree);
      }
      return best == NULL ? 0 : best->p;
}

/***********************************************************************
*  NAME
*
*  ios_relative_gap - compute relative mip gap
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  double ios_relative_gap(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_relative_gap computes the relative mip gap using the
*  formula:
*
*     gap = |best_mip - best_bnd| / (|best_mip| + DBL_EPSILON),
*
*  where best_mip is the best integer feasible solution found so far,
*  best_bnd is the best (global) bound. If no integer feasible solution
*  has been found yet, rel_gap is set to DBL_MAX.
*
*  RETURNS
*
*  The routine ios_relative_gap returns the relative mip gap. */

double ios_relative_gap(glp_tree *tree)
{     glp_prob *mip = tree->mip;
      int p;
      double best_mip, best_bnd, gap;
      if (mip->mip_stat == GLP_FEAS)
      {  best_mip = mip->mip_obj;
         p = ios_best_node(tree);
         if (p == 0)
         {  /* the tree is empty */
            gap = 0.0;
         }
         else
         {  best_bnd = tree->slot[p].node->bound;
            gap = fabs(best_mip - best_bnd) / (fabs(best_mip) +
               DBL_EPSILON);
         }
      }
      else
      {  /* no integer feasible solution has been found yet */
         gap = DBL_MAX;
      }
      return gap;
}

/***********************************************************************
*  NAME
*
*  ios_solve_node - solve LP relaxation of current subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_solve_node(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_solve_node re-optimizes LP relaxation of the current
*  subproblem using the dual simplex method.
*
*  RETURNS
*
*  The routine returns the code which is reported by glp_simplex. */

int ios_solve_node(glp_tree *tree)
{     glp_prob *mip = tree->mip;
      glp_smcp parm;
      int ret;
      /* the current subproblem must exist */
      xassert(tree->curr != NULL);
      /* set some control parameters */
      glp_init_smcp(&parm);
      switch (tree->parm->msg_lev)
      {  case GLP_MSG_OFF:
            parm.msg_lev = GLP_MSG_OFF; break;
         case GLP_MSG_ERR:
            parm.msg_lev = GLP_MSG_ERR; break;
         case GLP_MSG_ON:
         case GLP_MSG_ALL:
            parm.msg_lev = GLP_MSG_ON; break;
         case GLP_MSG_DBG:
            parm.msg_lev = GLP_MSG_ALL; break;
         default:
            xassert(tree != tree);
      }
      parm.meth = GLP_DUALP;
#if 1 /* 16/III-2016 */
      if (tree->parm->flip)
         parm.r_test = GLP_RT_FLIP;
#endif
      /* respect time limit */
      if (tree->parm->tm_lim < INT_MAX)
         parm.tm_lim = tree->parm->tm_lim - (glp_time() - tree->tm_beg);
      if (parm.tm_lim < 0)
         parm.tm_lim = 0;
      if (tree->parm->msg_lev < GLP_MSG_DBG)
         parm.out_dly = tree->parm->out_dly;
      else
         parm.out_dly = 0;
      /* if the incumbent objective value is already known, use it to
         prematurely terminate the dual simplex search */
      if (mip->mip_stat == GLP_FEAS)
      {  switch (tree->mip->dir)
         {  case GLP_MIN:
               parm.obj_ul = mip->mip_obj;
               break;
            case GLP_MAX:
               parm.obj_ll = mip->mip_obj;
               break;
            default:
               xassert(mip != mip);
         }
      }
      /* try to solve/re-optimize the LP relaxation */
      ret = glp_simplex(mip, &parm);
#if 1 /* 21/II-2016 by Chris */
      if (ret == GLP_EFAIL)
      {  /* retry with a new basis */
         glp_adv_basis(mip, 0);
         ret = glp_simplex(mip, &parm);
      }
#endif
      tree->curr->solved++;
#if 0
      xprintf("ret = %d; status = %d; pbs = %d; dbs = %d; some = %d\n",
         ret, glp_get_status(mip), mip->pbs_stat, mip->dbs_stat,
         mip->some);
      lpx_print_sol(mip, "sol");
#endif
      return ret;
}

/**********************************************************************/

#ifdef NEW_LOCAL /* 02/II-2018 */
IOSPOOL *ios_create_pool(glp_tree *tree)
{     /* create cut pool */
      IOSPOOL *pool;
      pool = glp_create_prob();
#if 1 /* 14/VII-2020 */
      if (tree->mip->n)
#endif
      glp_add_cols(pool, tree->mip->n);
      return pool;
}
#else
IOSPOOL *ios_create_pool(glp_tree *tree)
{     /* create cut pool */
      IOSPOOL *pool;
#if 0
      pool = dmp_get_atom(tree->pool, sizeof(IOSPOOL));
#else
      xassert(tree == tree);
      pool = xmalloc(sizeof(IOSPOOL));
#endif
      pool->size = 0;
      pool->head = pool->tail = NULL;
      pool->ord = 0, pool->curr = NULL;
      return pool;
}
#endif

#ifdef NEW_LOCAL /* 02/II-2018 */
int ios_add_row(glp_tree *tree, IOSPOOL *pool,
      const char *name, int klass, int flags, int len, const int ind[],
      const double val[], int type, double rhs)
{     /* add row (constraint) to the cut pool */
      int i;
      i = glp_add_rows(pool, 1);
      glp_set_row_name(pool, i, name);
      pool->row[i]->klass = klass;
      xassert(flags == 0);
      glp_set_mat_row(pool, i, len, ind, val);
      glp_set_row_bnds(pool, i, type, rhs, rhs);
      return i;
}
#else
int ios_add_row(glp_tree *tree, IOSPOOL *pool,
      const char *name, int klass, int flags, int len, const int ind[],
      const double val[], int type, double rhs)
{     /* add row (constraint) to the cut pool */
      IOSCUT *cut;
      IOSAIJ *aij;
      int k;
      xassert(pool != NULL);
      cut = dmp_get_atom(tree->pool, sizeof(IOSCUT));
      if (name == NULL || name[0] == '\0')
         cut->name = NULL;
      else
      {  for (k = 0; name[k] != '\0'; k++)
         {  if (k == 256)
               xerror("glp_ios_add_row: cut name too long\n");
            if (iscntrl((unsigned char)name[k]))
               xerror("glp_ios_add_row: cut name contains invalid chara"
                  "cter(s)\n");
         }
         cut->name = dmp_get_atom(tree->pool, strlen(name)+1);
         strcpy(cut->name, name);
      }
      if (!(0 <= klass && klass <= 255))
         xerror("glp_ios_add_row: klass = %d; invalid cut class\n",
            klass);
      cut->klass = (unsigned char)klass;
      if (flags != 0)
         xerror("glp_ios_add_row: flags = %d; invalid cut flags\n",
            flags);
      cut->ptr = NULL;
      if (!(0 <= len && len <= tree->n))
         xerror("glp_ios_add_row: len = %d; invalid cut length\n",
            len);
      for (k = 1; k <= len; k++)
      {  aij = dmp_get_atom(tree->pool, sizeof(IOSAIJ));
         if (!(1 <= ind[k] && ind[k] <= tree->n))
            xerror("glp_ios_add_row: ind[%d] = %d; column index out of "
               "range\n", k, ind[k]);
         aij->j = ind[k];
         aij->val = val[k];
         aij->next = cut->ptr;
         cut->ptr = aij;
      }
      if (!(type == GLP_LO || type == GLP_UP || type == GLP_FX))
         xerror("glp_ios_add_row: type = %d; invalid cut type\n",
            type);
      cut->type = (unsigned char)type;
      cut->rhs = rhs;
      cut->prev = pool->tail;
      cut->next = NULL;
      if (cut->prev == NULL)
         pool->head = cut;
      else
         cut->prev->next = cut;
      pool->tail = cut;
      pool->size++;
      return pool->size;
}
#endif

#ifdef NEW_LOCAL /* 02/II-2018 */
IOSCUT *ios_find_row(IOSPOOL *pool, int i)
{     /* find row (constraint) in the cut pool */
      xassert(0);
}
#else
IOSCUT *ios_find_row(IOSPOOL *pool, int i)
{     /* find row (constraint) in the cut pool */
      /* (smart linear search) */
      xassert(pool != NULL);
      xassert(1 <= i && i <= pool->size);
      if (pool->ord == 0)
      {  xassert(pool->curr == NULL);
         pool->ord = 1;
         pool->curr = pool->head;
      }
      xassert(pool->curr != NULL);
      if (i < pool->ord)
      {  if (i < pool->ord - i)
         {  pool->ord = 1;
            pool->curr = pool->head;
            while (pool->ord != i)
            {  pool->ord++;
               xassert(pool->curr != NULL);
               pool->curr = pool->curr->next;
            }
         }
         else
         {  while (pool->ord != i)
            {  pool->ord--;
               xassert(pool->curr != NULL);
               pool->curr = pool->curr->prev;
            }
         }
      }
      else if (i > pool->ord)
      {  if (i - pool->ord < pool->size - i)
         {  while (pool->ord != i)
            {  pool->ord++;
               xassert(pool->curr != NULL);
               pool->curr = pool->curr->next;
            }
         }
         else
         {  pool->ord = pool->size;
            pool->curr = pool->tail;
            while (pool->ord != i)
            {  pool->ord--;
               xassert(pool->curr != NULL);
               pool->curr = pool->curr->prev;
            }
         }
      }
      xassert(pool->ord == i);
      xassert(pool->curr != NULL);
      return pool->curr;
}
#endif

#ifdef NEW_LOCAL /* 02/II-2018 */
void ios_del_row(glp_tree *tree, IOSPOOL *pool, int i)
{     /* remove row (constraint) from the cut pool */
      xassert(0);
}
#else
void ios_del_row(glp_tree *tree, IOSPOOL *pool, int i)
{     /* remove row (constraint) from the cut pool */
      IOSCUT *cut;
      IOSAIJ *aij;
      xassert(pool != NULL);
      if (!(1 <= i && i <= pool->size))
         xerror("glp_ios_del_row: i = %d; cut number out of range\n",
            i);
      cut = ios_find_row(pool, i);
      xassert(pool->curr == cut);
      if (cut->next != NULL)
         pool->curr = cut->next;
      else if (cut->prev != NULL)
         pool->ord--, pool->curr = cut->prev;
      else
         pool->ord = 0, pool->curr = NULL;
      if (cut->name != NULL)
         dmp_free_atom(tree->pool, cut->name, strlen(cut->name)+1);
      if (cut->prev == NULL)
      {  xassert(pool->head == cut);
         pool->head = cut->next;
      }
      else
      {  xassert(cut->prev->next == cut);
         cut->prev->next = cut->next;
      }
      if (cut->next == NULL)
      {  xassert(pool->tail == cut);
         pool->tail = cut->prev;
      }
      else
      {  xassert(cut->next->prev == cut);
         cut->next->prev = cut->prev;
      }
      while (cut->ptr != NULL)
      {  aij = cut->ptr;
         cut->ptr = aij->next;
         dmp_free_atom(tree->pool, aij, sizeof(IOSAIJ));
      }
      dmp_free_atom(tree->pool, cut, sizeof(IOSCUT));
      pool->size--;
      return;
}
#endif

#ifdef NEW_LOCAL /* 02/II-2018 */
void ios_clear_pool(glp_tree *tree, IOSPOOL *pool)
{     /* remove all rows (constraints) from the cut pool */
      if (pool->m > 0)
      {  int i, *num;
         num = talloc(1+pool->m, int);
         for (i = 1; i <= pool->m; i++)
            num[i] = i;
         glp_del_rows(pool, pool->m, num);
         tfree(num);
      }
      return;
}
#else
void ios_clear_pool(glp_tree *tree, IOSPOOL *pool)
{     /* remove all rows (constraints) from the cut pool */
      xassert(pool != NULL);
      while (pool->head != NULL)
      {  IOSCUT *cut = pool->head;
         pool->head = cut->next;
         if (cut->name != NULL)
            dmp_free_atom(tree->pool, cut->name, strlen(cut->name)+1);
         while (cut->ptr != NULL)
         {  IOSAIJ *aij = cut->ptr;
            cut->ptr = aij->next;
            dmp_free_atom(tree->pool, aij, sizeof(IOSAIJ));
         }
         dmp_free_atom(tree->pool, cut, sizeof(IOSCUT));
      }
      pool->size = 0;
      pool->head = pool->tail = NULL;
      pool->ord = 0, pool->curr = NULL;
      return;
}
#endif

#ifdef NEW_LOCAL /* 02/II-2018 */
void ios_delete_pool(glp_tree *tree, IOSPOOL *pool)
{     /* delete cut pool */
      xassert(pool != NULL);
      glp_delete_prob(pool);
      return;
}
#else
void ios_delete_pool(glp_tree *tree, IOSPOOL *pool)
{     /* delete cut pool */
      xassert(pool != NULL);
      ios_clear_pool(tree, pool);
      xfree(pool);
      return;
}
#endif

#if 1 /* 11/VII-2013 */
#include "npp.h"

void ios_process_sol(glp_tree *T)
{     /* process integer feasible solution just found */
      if (T->npp != NULL)
      {  /* postprocess solution from transformed mip */
         npp_postprocess(T->npp, T->mip);
         /* store solution to problem passed to glp_intopt */
         npp_unload_sol(T->npp, T->P);
      }
      xassert(T->P != NULL);
      /* save solution to text file, if requested */
      if (T->save_sol != NULL)
      {  char *fn, *mark;
         fn = talloc(strlen(T->save_sol) + 50, char);
         mark = strrchr(T->save_sol, '*');
         if (mark == NULL)
            strcpy(fn, T->save_sol);
         else
         {  memcpy(fn, T->save_sol, mark - T->save_sol);
            fn[mark - T->save_sol] = '\0';
            sprintf(fn + strlen(fn), "%03d", ++(T->save_cnt));
            strcat(fn, &mark[1]);
         }
         /* glp_write_mip(T->P, fn); */
         tfree(fn);
      }
      return;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios02.c0000644000175100001710000006433300000000000025020 0ustar00runnerdocker00000000000000/* glpios02.c (preprocess current subproblem) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/***********************************************************************
*  prepare_row_info - prepare row info to determine implied bounds
*
*  Given a row (linear form)
*
*      n
*     sum a[j] * x[j]                                                (1)
*     j=1
*
*  and bounds of columns (variables)
*
*     l[j] <= x[j] <= u[j]                                           (2)
*
*  this routine computes f_min, j_min, f_max, j_max needed to determine
*  implied bounds.
*
*  ALGORITHM
*
*  Let J+ = {j : a[j] > 0} and J- = {j : a[j] < 0}.
*
*  Parameters f_min and j_min are computed as follows:
*
*  1) if there is no x[k] such that k in J+ and l[k] = -inf or k in J-
*     and u[k] = +inf, then
*
*     f_min :=   sum   a[j] * l[j] +   sum   a[j] * u[j]
*              j in J+               j in J-
*                                                                    (3)
*     j_min := 0
*
*  2) if there is exactly one x[k] such that k in J+ and l[k] = -inf
*     or k in J- and u[k] = +inf, then
*
*     f_min :=   sum       a[j] * l[j] +   sum       a[j] * u[j]
*              j in J+\{k}               j in J-\{k}
*                                                                    (4)
*     j_min := k
*
*  3) if there are two or more x[k] such that k in J+ and l[k] = -inf
*     or k in J- and u[k] = +inf, then
*
*     f_min := -inf
*                                                                    (5)
*     j_min := 0
*
*  Parameters f_max and j_max are computed in a similar way as follows:
*
*  1) if there is no x[k] such that k in J+ and u[k] = +inf or k in J-
*     and l[k] = -inf, then
*
*     f_max :=   sum   a[j] * u[j] +   sum   a[j] * l[j]
*              j in J+               j in J-
*                                                                    (6)
*     j_max := 0
*
*  2) if there is exactly one x[k] such that k in J+ and u[k] = +inf
*     or k in J- and l[k] = -inf, then
*
*     f_max :=   sum       a[j] * u[j] +   sum       a[j] * l[j]
*              j in J+\{k}               j in J-\{k}
*                                                                    (7)
*     j_max := k
*
*  3) if there are two or more x[k] such that k in J+ and u[k] = +inf
*     or k in J- and l[k] = -inf, then
*
*     f_max := +inf
*                                                                    (8)
*     j_max := 0                                                      */

struct f_info
{     int j_min, j_max;
      double f_min, f_max;
};

static void prepare_row_info(int n, const double a[], const double l[],
      const double u[], struct f_info *f)
{     int j, j_min, j_max;
      double f_min, f_max;
      xassert(n >= 0);
      /* determine f_min and j_min */
      f_min = 0.0, j_min = 0;
      for (j = 1; j <= n; j++)
      {  if (a[j] > 0.0)
         {  if (l[j] == -DBL_MAX)
            {  if (j_min == 0)
                  j_min = j;
               else
               {  f_min = -DBL_MAX, j_min = 0;
                  break;
               }
            }
            else
               f_min += a[j] * l[j];
         }
         else if (a[j] < 0.0)
         {  if (u[j] == +DBL_MAX)
            {  if (j_min == 0)
                  j_min = j;
               else
               {  f_min = -DBL_MAX, j_min = 0;
                  break;
               }
            }
            else
               f_min += a[j] * u[j];
         }
         else
            xassert(a != a);
      }
      f->f_min = f_min, f->j_min = j_min;
      /* determine f_max and j_max */
      f_max = 0.0, j_max = 0;
      for (j = 1; j <= n; j++)
      {  if (a[j] > 0.0)
         {  if (u[j] == +DBL_MAX)
            {  if (j_max == 0)
                  j_max = j;
               else
               {  f_max = +DBL_MAX, j_max = 0;
                  break;
               }
            }
            else
               f_max += a[j] * u[j];
         }
         else if (a[j] < 0.0)
         {  if (l[j] == -DBL_MAX)
            {  if (j_max == 0)
                  j_max = j;
               else
               {  f_max = +DBL_MAX, j_max = 0;
                  break;
               }
            }
            else
               f_max += a[j] * l[j];
         }
         else
            xassert(a != a);
      }
      f->f_max = f_max, f->j_max = j_max;
      return;
}

/***********************************************************************
*  row_implied_bounds - determine row implied bounds
*
*  Given a row (linear form)
*
*      n
*     sum a[j] * x[j]
*     j=1
*
*  and bounds of columns (variables)
*
*     l[j] <= x[j] <= u[j]
*
*  this routine determines implied bounds of the row.
*
*  ALGORITHM
*
*  Let J+ = {j : a[j] > 0} and J- = {j : a[j] < 0}.
*
*  The implied lower bound of the row is computed as follows:
*
*     L' :=   sum   a[j] * l[j] +   sum   a[j] * u[j]                (9)
*           j in J+               j in J-
*
*  and as it follows from (3), (4), and (5):
*
*     L' := if j_min = 0 then f_min else -inf                       (10)
*
*  The implied upper bound of the row is computed as follows:
*
*     U' :=   sum   a[j] * u[j] +   sum   a[j] * l[j]               (11)
*           j in J+               j in J-
*
*  and as it follows from (6), (7), and (8):
*
*     U' := if j_max = 0 then f_max else +inf                       (12)
*
*  The implied bounds are stored in locations LL and UU. */

static void row_implied_bounds(const struct f_info *f, double *LL,
      double *UU)
{     *LL = (f->j_min == 0 ? f->f_min : -DBL_MAX);
      *UU = (f->j_max == 0 ? f->f_max : +DBL_MAX);
      return;
}

/***********************************************************************
*  col_implied_bounds - determine column implied bounds
*
*  Given a row (constraint)
*
*           n
*     L <= sum a[j] * x[j] <= U                                     (13)
*          j=1
*
*  and bounds of columns (variables)
*
*     l[j] <= x[j] <= u[j]
*
*  this routine determines implied bounds of variable x[k].
*
*  It is assumed that if L != -inf, the lower bound of the row can be
*  active, and if U != +inf, the upper bound of the row can be active.
*
*  ALGORITHM
*
*  From (13) it follows that
*
*     L <= sum a[j] * x[j] + a[k] * x[k] <= U
*          j!=k
*  or
*
*     L - sum a[j] * x[j] <= a[k] * x[k] <= U - sum a[j] * x[j]
*         j!=k                                  j!=k
*
*  Thus, if the row lower bound L can be active, implied lower bound of
*  term a[k] * x[k] can be determined as follows:
*
*     ilb(a[k] * x[k]) = min(L - sum a[j] * x[j]) =
*                                j!=k
*                                                                   (14)
*                      = L - max sum a[j] * x[j]
*                            j!=k
*
*  where, as it follows from (6), (7), and (8)
*
*                           / f_max - a[k] * u[k], j_max = 0, a[k] > 0
*                           |
*                           | f_max - a[k] * l[k], j_max = 0, a[k] < 0
*     max sum a[j] * x[j] = {
*         j!=k              | f_max,               j_max = k
*                           |
*                           \ +inf,                j_max != 0
*
*  and if the upper bound U can be active, implied upper bound of term
*  a[k] * x[k] can be determined as follows:
*
*     iub(a[k] * x[k]) = max(U - sum a[j] * x[j]) =
*                                j!=k
*                                                                   (15)
*                      = U - min sum a[j] * x[j]
*                            j!=k
*
*  where, as it follows from (3), (4), and (5)
*
*                           / f_min - a[k] * l[k], j_min = 0, a[k] > 0
*                           |
*                           | f_min - a[k] * u[k], j_min = 0, a[k] < 0
*     min sum a[j] * x[j] = {
*         j!=k              | f_min,               j_min = k
*                           |
*                           \ -inf,                j_min != 0
*
*  Since
*
*     ilb(a[k] * x[k]) <= a[k] * x[k] <= iub(a[k] * x[k])
*
*  implied lower and upper bounds of x[k] are determined as follows:
*
*     l'[k] := if a[k] > 0 then ilb / a[k] else ulb / a[k]          (16)
*
*     u'[k] := if a[k] > 0 then ulb / a[k] else ilb / a[k]          (17)
*
*  The implied bounds are stored in locations ll and uu. */

static void col_implied_bounds(const struct f_info *f, int n,
      const double a[], double L, double U, const double l[],
      const double u[], int k, double *ll, double *uu)
{     double ilb, iub;
      xassert(n >= 0);
      xassert(1 <= k && k <= n);
      /* determine implied lower bound of term a[k] * x[k] (14) */
      if (L == -DBL_MAX || f->f_max == +DBL_MAX)
         ilb = -DBL_MAX;
      else if (f->j_max == 0)
      {  if (a[k] > 0.0)
         {  xassert(u[k] != +DBL_MAX);
            ilb = L - (f->f_max - a[k] * u[k]);
         }
         else if (a[k] < 0.0)
         {  xassert(l[k] != -DBL_MAX);
            ilb = L - (f->f_max - a[k] * l[k]);
         }
         else
            xassert(a != a);
      }
      else if (f->j_max == k)
         ilb = L - f->f_max;
      else
         ilb = -DBL_MAX;
      /* determine implied upper bound of term a[k] * x[k] (15) */
      if (U == +DBL_MAX || f->f_min == -DBL_MAX)
         iub = +DBL_MAX;
      else if (f->j_min == 0)
      {  if (a[k] > 0.0)
         {  xassert(l[k] != -DBL_MAX);
            iub = U - (f->f_min - a[k] * l[k]);
         }
         else if (a[k] < 0.0)
         {  xassert(u[k] != +DBL_MAX);
            iub = U - (f->f_min - a[k] * u[k]);
         }
         else
            xassert(a != a);
      }
      else if (f->j_min == k)
         iub = U - f->f_min;
      else
         iub = +DBL_MAX;
      /* determine implied bounds of x[k] (16) and (17) */
#if 1
      /* do not use a[k] if it has small magnitude to prevent wrong
         implied bounds; for example, 1e-15 * x1 >= x2 + x3, where
         x1 >= -10, x2, x3 >= 0, would lead to wrong conclusion that
         x1 >= 0 */
      if (fabs(a[k]) < 1e-6)
         *ll = -DBL_MAX, *uu = +DBL_MAX; else
#endif
      if (a[k] > 0.0)
      {  *ll = (ilb == -DBL_MAX ? -DBL_MAX : ilb / a[k]);
         *uu = (iub == +DBL_MAX ? +DBL_MAX : iub / a[k]);
      }
      else if (a[k] < 0.0)
      {  *ll = (iub == +DBL_MAX ? -DBL_MAX : iub / a[k]);
         *uu = (ilb == -DBL_MAX ? +DBL_MAX : ilb / a[k]);
      }
      else
         xassert(a != a);
      return;
}

/***********************************************************************
*  check_row_bounds - check and relax original row bounds
*
*  Given a row (constraint)
*
*           n
*     L <= sum a[j] * x[j] <= U
*          j=1
*
*  and bounds of columns (variables)
*
*     l[j] <= x[j] <= u[j]
*
*  this routine checks the original row bounds L and U for feasibility
*  and redundancy. If the original lower bound L or/and upper bound U
*  cannot be active due to bounds of variables, the routine remove them
*  replacing by -inf or/and +inf, respectively.
*
*  If no primal infeasibility is detected, the routine returns zero,
*  otherwise non-zero. */

static int check_row_bounds(const struct f_info *f, double *L_,
      double *U_)
{     int ret = 0;
      double L = *L_, U = *U_, LL, UU;
      /* determine implied bounds of the row */
      row_implied_bounds(f, &LL, &UU);
      /* check if the original lower bound is infeasible */
      if (L != -DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(L));
         if (UU < L - eps)
         {  ret = 1;
            goto done;
         }
      }
      /* check if the original upper bound is infeasible */
      if (U != +DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(U));
         if (LL > U + eps)
         {  ret = 1;
            goto done;
         }
      }
      /* check if the original lower bound is redundant */
      if (L != -DBL_MAX)
      {  double eps = 1e-12 * (1.0 + fabs(L));
         if (LL > L - eps)
         {  /* it cannot be active, so remove it */
            *L_ = -DBL_MAX;
         }
      }
      /* check if the original upper bound is redundant */
      if (U != +DBL_MAX)
      {  double eps = 1e-12 * (1.0 + fabs(U));
         if (UU < U + eps)
         {  /* it cannot be active, so remove it */
            *U_ = +DBL_MAX;
         }
      }
done: return ret;
}

/***********************************************************************
*  check_col_bounds - check and tighten original column bounds
*
*  Given a row (constraint)
*
*           n
*     L <= sum a[j] * x[j] <= U
*          j=1
*
*  and bounds of columns (variables)
*
*     l[j] <= x[j] <= u[j]
*
*  for column (variable) x[j] this routine checks the original column
*  bounds l[j] and u[j] for feasibility and redundancy. If the original
*  lower bound l[j] or/and upper bound u[j] cannot be active due to
*  bounds of the constraint and other variables, the routine tighten
*  them replacing by corresponding implied bounds, if possible.
*
*  NOTE: It is assumed that if L != -inf, the row lower bound can be
*        active, and if U != +inf, the row upper bound can be active.
*
*  The flag means that variable x[j] is required to be integer.
*
*  New actual bounds for x[j] are stored in locations lj and uj.
*
*  If no primal infeasibility is detected, the routine returns zero,
*  otherwise non-zero. */

static int check_col_bounds(const struct f_info *f, int n,
      const double a[], double L, double U, const double l[],
      const double u[], int flag, int j, double *_lj, double *_uj)
{     int ret = 0;
      double lj, uj, ll, uu;
      xassert(n >= 0);
      xassert(1 <= j && j <= n);
      lj = l[j], uj = u[j];
      /* determine implied bounds of the column */
      col_implied_bounds(f, n, a, L, U, l, u, j, &ll, &uu);
      /* if x[j] is integral, round its implied bounds */
      if (flag)
      {  if (ll != -DBL_MAX)
            ll = (ll - floor(ll) < 1e-3 ? floor(ll) : ceil(ll));
         if (uu != +DBL_MAX)
            uu = (ceil(uu) - uu < 1e-3 ? ceil(uu) : floor(uu));
      }
      /* check if the original lower bound is infeasible */
      if (lj != -DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(lj));
         if (uu < lj - eps)
         {  ret = 1;
            goto done;
         }
      }
      /* check if the original upper bound is infeasible */
      if (uj != +DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(uj));
         if (ll > uj + eps)
         {  ret = 1;
            goto done;
         }
      }
      /* check if the original lower bound is redundant */
      if (ll != -DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(ll));
         if (lj < ll - eps)
         {  /* it cannot be active, so tighten it */
            lj = ll;
         }
      }
      /* check if the original upper bound is redundant */
      if (uu != +DBL_MAX)
      {  double eps = 1e-3 * (1.0 + fabs(uu));
         if (uj > uu + eps)
         {  /* it cannot be active, so tighten it */
            uj = uu;
         }
      }
      /* due to round-off errors it may happen that lj > uj (although
         lj < uj + eps, since no primal infeasibility is detected), so
         adjuct the new actual bounds to provide lj <= uj */
      if (!(lj == -DBL_MAX || uj == +DBL_MAX))
      {  double t1 = fabs(lj), t2 = fabs(uj);
         double eps = 1e-10 * (1.0 + (t1 <= t2 ? t1 : t2));
         if (lj > uj - eps)
         {  if (lj == l[j])
               uj = lj;
            else if (uj == u[j])
               lj = uj;
            else if (t1 <= t2)
               uj = lj;
            else
               lj = uj;
         }
      }
      *_lj = lj, *_uj = uj;
done: return ret;
}

/***********************************************************************
*  check_efficiency - check if change in column bounds is efficient
*
*  Given the original bounds of a column l and u and its new actual
*  bounds l' and u' (possibly tighten by the routine check_col_bounds)
*  this routine checks if the change in the column bounds is efficient
*  enough. If so, the routine returns non-zero, otherwise zero.
*
*  The flag means that the variable is required to be integer. */

static int check_efficiency(int flag, double l, double u, double ll,
      double uu)
{     int eff = 0;
      /* check efficiency for lower bound */
      if (l < ll)
      {  if (flag || l == -DBL_MAX)
            eff++;
         else
         {  double r;
            if (u == +DBL_MAX)
               r = 1.0 + fabs(l);
            else
               r = 1.0 + (u - l);
            if (ll - l >= 0.25 * r)
               eff++;
         }
      }
      /* check efficiency for upper bound */
      if (u > uu)
      {  if (flag || u == +DBL_MAX)
            eff++;
         else
         {  double r;
            if (l == -DBL_MAX)
               r = 1.0 + fabs(u);
            else
               r = 1.0 + (u - l);
            if (u - uu >= 0.25 * r)
               eff++;
         }
      }
      return eff;
}

/***********************************************************************
*  basic_preprocessing - perform basic preprocessing
*
*  This routine performs basic preprocessing of the specified MIP that
*  includes relaxing some row bounds and tightening some column bounds.
*
*  On entry the arrays L and U contains original row bounds, and the
*  arrays l and u contains original column bounds:
*
*  L[0] is the lower bound of the objective row;
*  L[i], i = 1,...,m, is the lower bound of i-th row;
*  U[0] is the upper bound of the objective row;
*  U[i], i = 1,...,m, is the upper bound of i-th row;
*  l[0] is not used;
*  l[j], j = 1,...,n, is the lower bound of j-th column;
*  u[0] is not used;
*  u[j], j = 1,...,n, is the upper bound of j-th column.
*
*  On exit the arrays L, U, l, and u contain new actual bounds of rows
*  and column in the same locations.
*
*  The parameters nrs and num specify an initial list of rows to be
*  processed:
*
*  nrs is the number of rows in the initial list, 0 <= nrs <= m+1;
*  num[0] is not used;
*  num[1,...,nrs] are row numbers (0 means the objective row).
*
*  The parameter max_pass specifies the maximal number of times that
*  each row can be processed, max_pass > 0.
*
*  If no primal infeasibility is detected, the routine returns zero,
*  otherwise non-zero. */

static int basic_preprocessing(glp_prob *mip, double L[], double U[],
      double l[], double u[], int nrs, const int num[], int max_pass)
{     int m = mip->m;
      int n = mip->n;
      struct f_info f;
      int i, j, k, len, size, ret = 0;
      int *ind, *list, *mark, *pass;
      double *val, *lb, *ub;
      xassert(0 <= nrs && nrs <= m+1);
      xassert(max_pass > 0);
      /* allocate working arrays */
      ind = xcalloc(1+n, sizeof(int));
      list = xcalloc(1+m+1, sizeof(int));
      mark = xcalloc(1+m+1, sizeof(int));
      memset(&mark[0], 0, (m+1) * sizeof(int));
      pass = xcalloc(1+m+1, sizeof(int));
      memset(&pass[0], 0, (m+1) * sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      lb = xcalloc(1+n, sizeof(double));
      ub = xcalloc(1+n, sizeof(double));
      /* initialize the list of rows to be processed */
      size = 0;
      for (k = 1; k <= nrs; k++)
      {  i = num[k];
         xassert(0 <= i && i <= m);
         /* duplicate row numbers are not allowed */
         xassert(!mark[i]);
         list[++size] = i, mark[i] = 1;
      }
      xassert(size == nrs);
      /* process rows in the list until it becomes empty */
      while (size > 0)
      {  /* get a next row from the list */
         i = list[size--], mark[i] = 0;
         /* increase the row processing count */
         pass[i]++;
         /* if the row is free, skip it */
         if (L[i] == -DBL_MAX && U[i] == +DBL_MAX) continue;
         /* obtain coefficients of the row */
         len = 0;
         if (i == 0)
         {  for (j = 1; j <= n; j++)
            {  GLPCOL *col = mip->col[j];
               if (col->coef != 0.0)
                  len++, ind[len] = j, val[len] = col->coef;
            }
         }
         else
         {  GLPROW *row = mip->row[i];
            GLPAIJ *aij;
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
               len++, ind[len] = aij->col->j, val[len] = aij->val;
         }
         /* determine lower and upper bounds of columns corresponding
            to non-zero row coefficients */
         for (k = 1; k <= len; k++)
            j = ind[k], lb[k] = l[j], ub[k] = u[j];
         /* prepare the row info to determine implied bounds */
         prepare_row_info(len, val, lb, ub, &f);
         /* check and relax bounds of the row */
         if (check_row_bounds(&f, &L[i], &U[i]))
         {  /* the feasible region is empty */
            ret = 1;
            goto done;
         }
         /* if the row became free, drop it */
         if (L[i] == -DBL_MAX && U[i] == +DBL_MAX) continue;
         /* process columns having non-zero coefficients in the row */
         for (k = 1; k <= len; k++)
         {  GLPCOL *col;
            int flag, eff;
            double ll, uu;
            /* take a next column in the row */
            j = ind[k], col = mip->col[j];
            flag = col->kind != GLP_CV;
            /* check and tighten bounds of the column */
            if (check_col_bounds(&f, len, val, L[i], U[i], lb, ub,
                flag, k, &ll, &uu))
            {  /* the feasible region is empty */
               ret = 1;
               goto done;
            }
            /* check if change in the column bounds is efficient */
            eff = check_efficiency(flag, l[j], u[j], ll, uu);
            /* set new actual bounds of the column */
            l[j] = ll, u[j] = uu;
            /* if the change is efficient, add all rows affected by the
               corresponding column, to the list */
            if (eff > 0)
            {  GLPAIJ *aij;
               for (aij = col->ptr; aij != NULL; aij = aij->c_next)
               {  int ii = aij->row->i;
                  /* if the row was processed maximal number of times,
                     skip it */
                  if (pass[ii] >= max_pass) continue;
                  /* if the row is free, skip it */
                  if (L[ii] == -DBL_MAX && U[ii] == +DBL_MAX) continue;
                  /* put the row into the list */
                  if (mark[ii] == 0)
                  {  xassert(size <= m);
                     list[++size] = ii, mark[ii] = 1;
                  }
               }
            }
         }
      }
done: /* free working arrays */
      xfree(ind);
      xfree(list);
      xfree(mark);
      xfree(pass);
      xfree(val);
      xfree(lb);
      xfree(ub);
      return ret;
}

/***********************************************************************
*  NAME
*
*  ios_preprocess_node - preprocess current subproblem
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_preprocess_node(glp_tree *tree, int max_pass);
*
*  DESCRIPTION
*
*  The routine ios_preprocess_node performs basic preprocessing of the
*  current subproblem.
*
*  RETURNS
*
*  If no primal infeasibility is detected, the routine returns zero,
*  otherwise non-zero. */

int ios_preprocess_node(glp_tree *tree, int max_pass)
{     glp_prob *mip = tree->mip;
      int m = mip->m;
      int n = mip->n;
      int i, j, nrs, *num, ret = 0;
      double *L, *U, *l, *u;
      /* the current subproblem must exist */
      xassert(tree->curr != NULL);
      /* determine original row bounds */
      L = xcalloc(1+m, sizeof(double));
      U = xcalloc(1+m, sizeof(double));
      switch (mip->mip_stat)
      {  case GLP_UNDEF:
            L[0] = -DBL_MAX, U[0] = +DBL_MAX;
            break;
         case GLP_FEAS:
            switch (mip->dir)
            {  case GLP_MIN:
                  L[0] = -DBL_MAX, U[0] = mip->mip_obj - mip->c0;
                  break;
               case GLP_MAX:
                  L[0] = mip->mip_obj - mip->c0, U[0] = +DBL_MAX;
                  break;
               default:
                  xassert(mip != mip);
            }
            break;
         default:
            xassert(mip != mip);
      }
      for (i = 1; i <= m; i++)
      {  L[i] = glp_get_row_lb(mip, i);
         U[i] = glp_get_row_ub(mip, i);
      }
      /* determine original column bounds */
      l = xcalloc(1+n, sizeof(double));
      u = xcalloc(1+n, sizeof(double));
      for (j = 1; j <= n; j++)
      {  l[j] = glp_get_col_lb(mip, j);
         u[j] = glp_get_col_ub(mip, j);
      }
      /* build the initial list of rows to be analyzed */
      nrs = m + 1;
      num = xcalloc(1+nrs, sizeof(int));
      for (i = 1; i <= nrs; i++) num[i] = i - 1;
      /* perform basic preprocessing */
      if (basic_preprocessing(mip , L, U, l, u, nrs, num, max_pass))
      {  ret = 1;
         goto done;
      }
      /* set new actual (relaxed) row bounds */
      for (i = 1; i <= m; i++)
      {  /* consider only non-active rows to keep dual feasibility */
         if (glp_get_row_stat(mip, i) == GLP_BS)
         {  if (L[i] == -DBL_MAX && U[i] == +DBL_MAX)
               glp_set_row_bnds(mip, i, GLP_FR, 0.0, 0.0);
            else if (U[i] == +DBL_MAX)
               glp_set_row_bnds(mip, i, GLP_LO, L[i], 0.0);
            else if (L[i] == -DBL_MAX)
               glp_set_row_bnds(mip, i, GLP_UP, 0.0, U[i]);
         }
      }
      /* set new actual (tightened) column bounds */
      for (j = 1; j <= n; j++)
      {  int type;
         if (l[j] == -DBL_MAX && u[j] == +DBL_MAX)
            type = GLP_FR;
         else if (u[j] == +DBL_MAX)
            type = GLP_LO;
         else if (l[j] == -DBL_MAX)
            type = GLP_UP;
         else if (l[j] != u[j])
            type = GLP_DB;
         else
            type = GLP_FX;
         glp_set_col_bnds(mip, j, type, l[j], u[j]);
      }
done: /* free working arrays and return */
      xfree(L);
      xfree(U);
      xfree(l);
      xfree(u);
      xfree(num);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios03.c0000644000175100001710000014660200000000000025021 0ustar00runnerdocker00000000000000/* glpios03.c (branch-and-cut driver) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2005-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/***********************************************************************
*  show_progress - display current progress of the search
*
*  This routine displays some information about current progress of the
*  search.
*
*  The information includes:
*
*  the current number of iterations performed by the simplex solver;
*
*  the objective value for the best known integer feasible solution,
*  which is upper (minimization) or lower (maximization) global bound
*  for optimal solution of the original mip problem;
*
*  the best local bound for active nodes, which is lower (minimization)
*  or upper (maximization) global bound for optimal solution of the
*  original mip problem;
*
*  the relative mip gap, in percents;
*
*  the number of open (active) subproblems;
*
*  the number of completely explored subproblems, i.e. whose nodes have
*  been removed from the tree. */

static void show_progress(glp_tree *T, int bingo)
{     int p;
      double temp;
      char best_mip[50], best_bound[50], *rho, rel_gap[50];
      /* format the best known integer feasible solution */
      if (T->mip->mip_stat == GLP_FEAS)
         sprintf(best_mip, "%17.9e", T->mip->mip_obj);
      else
         sprintf(best_mip, "%17s", "not found yet");
      /* determine reference number of an active subproblem whose local
         bound is best */
      p = ios_best_node(T);
      /* format the best bound */
      if (p == 0)
         sprintf(best_bound, "%17s", "tree is empty");
      else
      {  temp = T->slot[p].node->bound;
         if (temp == -DBL_MAX)
            sprintf(best_bound, "%17s", "-inf");
         else if (temp == +DBL_MAX)
            sprintf(best_bound, "%17s", "+inf");
         else
         {  if (fabs(temp) < 1e-9)
               temp = 0;
            sprintf(best_bound, "%17.9e", temp);
         }
      }
      /* choose the relation sign between global bounds */
      if (T->mip->dir == GLP_MIN)
         rho = ">=";
      else if (T->mip->dir == GLP_MAX)
         rho = "<=";
      else
         xassert(T != T);
      /* format the relative mip gap */
      temp = ios_relative_gap(T);
      if (temp == 0.0)
         sprintf(rel_gap, "  0.0%%");
      else if (temp < 0.001)
         sprintf(rel_gap, "< 0.1%%");
      else if (temp <= 9.999)
         sprintf(rel_gap, "%5.1f%%", 100.0 * temp);
      else
         sprintf(rel_gap, "%6s", "");
      /* display progress of the search */
      xprintf("+%6d: %s %s %s %s %s (%d; %d)\n",
         T->mip->it_cnt, bingo ? ">>>>>" : "mip =", best_mip, rho,
         best_bound, rel_gap, T->a_cnt, T->t_cnt - T->n_cnt);
      T->tm_lag = xtime();
      return;
}

/***********************************************************************
*  is_branch_hopeful - check if specified branch is hopeful
*
*  This routine checks if the specified subproblem can have an integer
*  optimal solution which is better than the best known one.
*
*  The check is based on comparison of the local objective bound stored
*  in the subproblem descriptor and the incumbent objective value which
*  is the global objective bound.
*
*  If there is a chance that the specified subproblem can have a better
*  integer optimal solution, the routine returns non-zero. Otherwise, if
*  the corresponding branch can pruned, zero is returned. */

static int is_branch_hopeful(glp_tree *T, int p)
{     xassert(1 <= p && p <= T->nslots);
      xassert(T->slot[p].node != NULL);
      return ios_is_hopeful(T, T->slot[p].node->bound);
}

/***********************************************************************
*  check_integrality - check integrality of basic solution
*
*  This routine checks if the basic solution of LP relaxation of the
*  current subproblem satisfies to integrality conditions, i.e. that all
*  variables of integer kind have integral primal values. (The solution
*  is assumed to be optimal.)
*
*  For each variable of integer kind the routine computes the following
*  quantity:
*
*     ii(x[j]) = min(x[j] - floor(x[j]), ceil(x[j]) - x[j]),         (1)
*
*  which is a measure of the integer infeasibility (non-integrality) of
*  x[j] (for example, ii(2.1) = 0.1, ii(3.7) = 0.3, ii(5.0) = 0). It is
*  understood that 0 <= ii(x[j]) <= 0.5, and variable x[j] is integer
*  feasible if ii(x[j]) = 0. However, due to floating-point arithmetic
*  the routine checks less restrictive condition:
*
*     ii(x[j]) <= tol_int,                                           (2)
*
*  where tol_int is a given tolerance (small positive number) and marks
*  each variable which does not satisfy to (2) as integer infeasible by
*  setting its fractionality flag.
*
*  In order to characterize integer infeasibility of the basic solution
*  in the whole the routine computes two parameters: ii_cnt, which is
*  the number of variables with the fractionality flag set, and ii_sum,
*  which is the sum of integer infeasibilities (1). */

static void check_integrality(glp_tree *T)
{     glp_prob *mip = T->mip;
      int j, type, ii_cnt = 0;
      double lb, ub, x, temp1, temp2, ii_sum = 0.0;
      /* walk through the set of columns (structural variables) */
      for (j = 1; j <= mip->n; j++)
      {  GLPCOL *col = mip->col[j];
         T->non_int[j] = 0;
         /* if the column is not integer, skip it */
         if (col->kind != GLP_IV) continue;
         /* if the column is non-basic, it is integer feasible */
         if (col->stat != GLP_BS) continue;
         /* obtain the type and bounds of the column */
         type = col->type, lb = col->lb, ub = col->ub;
         /* obtain value of the column in optimal basic solution */
         x = col->prim;
         /* if the column's primal value is close to the lower bound,
            the column is integer feasible within given tolerance */
         if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
         {  temp1 = lb - T->parm->tol_int;
            temp2 = lb + T->parm->tol_int;
            if (temp1 <= x && x <= temp2) continue;
#if 0
            /* the lower bound must not be violated */
            xassert(x >= lb);
#else
            if (x < lb) continue;
#endif
         }
         /* if the column's primal value is close to the upper bound,
            the column is integer feasible within given tolerance */
         if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
         {  temp1 = ub - T->parm->tol_int;
            temp2 = ub + T->parm->tol_int;
            if (temp1 <= x && x <= temp2) continue;
#if 0
            /* the upper bound must not be violated */
            xassert(x <= ub);
#else
            if (x > ub) continue;
#endif
         }
         /* if the column's primal value is close to nearest integer,
            the column is integer feasible within given tolerance */
         temp1 = floor(x + 0.5) - T->parm->tol_int;
         temp2 = floor(x + 0.5) + T->parm->tol_int;
         if (temp1 <= x && x <= temp2) continue;
         /* otherwise the column is integer infeasible */
         T->non_int[j] = 1;
         /* increase the number of fractional-valued columns */
         ii_cnt++;
         /* compute the sum of integer infeasibilities */
         temp1 = x - floor(x);
         temp2 = ceil(x) - x;
         xassert(temp1 > 0.0 && temp2 > 0.0);
         ii_sum += (temp1 <= temp2 ? temp1 : temp2);
      }
      /* store ii_cnt and ii_sum to the current problem descriptor */
      xassert(T->curr != NULL);
      T->curr->ii_cnt = ii_cnt;
      T->curr->ii_sum = ii_sum;
      /* and also display these parameters */
      if (T->parm->msg_lev >= GLP_MSG_DBG)
      {  if (ii_cnt == 0)
            xprintf("There are no fractional columns\n");
         else if (ii_cnt == 1)
            xprintf("There is one fractional column, integer infeasibil"
               "ity is %.3e\n", ii_sum);
         else
            xprintf("There are %d fractional columns, integer infeasibi"
               "lity is %.3e\n", ii_cnt, ii_sum);
      }
      return;
}

/***********************************************************************
*  record_solution - record better integer feasible solution
*
*  This routine records optimal basic solution of LP relaxation of the
*  current subproblem, which being integer feasible is better than the
*  best known integer feasible solution. */

static void record_solution(glp_tree *T)
{     glp_prob *mip = T->mip;
      int i, j;
      mip->mip_stat = GLP_FEAS;
      mip->mip_obj = mip->obj_val;
      for (i = 1; i <= mip->m; i++)
      {  GLPROW *row = mip->row[i];
         row->mipx = row->prim;
      }
      for (j = 1; j <= mip->n; j++)
      {  GLPCOL *col = mip->col[j];
         if (col->kind == GLP_CV)
            col->mipx = col->prim;
         else if (col->kind == GLP_IV)
         {  /* value of the integer column must be integral */
            col->mipx = floor(col->prim + 0.5);
         }
         else
            xassert(col != col);
      }
      T->sol_cnt++;
      return;
}

/***********************************************************************
*  fix_by_red_cost - fix non-basic integer columns by reduced costs
*
*  This routine fixes some non-basic integer columns if their reduced
*  costs indicate that increasing (decreasing) the column at least by
*  one involves the objective value becoming worse than the incumbent
*  objective value. */

static void fix_by_red_cost(glp_tree *T)
{     glp_prob *mip = T->mip;
      int j, stat, fixed = 0;
      double obj, lb, ub, dj;
      /* the global bound must exist */
      xassert(T->mip->mip_stat == GLP_FEAS);
      /* basic solution of LP relaxation must be optimal */
      xassert(mip->pbs_stat == GLP_FEAS && mip->dbs_stat == GLP_FEAS);
      /* determine the objective function value */
      obj = mip->obj_val;
      /* walk through the column list */
      for (j = 1; j <= mip->n; j++)
      {  GLPCOL *col = mip->col[j];
         /* if the column is not integer, skip it */
         if (col->kind != GLP_IV) continue;
         /* obtain bounds of j-th column */
         lb = col->lb, ub = col->ub;
         /* and determine its status and reduced cost */
         stat = col->stat, dj = col->dual;
         /* analyze the reduced cost */
         switch (mip->dir)
         {  case GLP_MIN:
               /* minimization */
               if (stat == GLP_NL)
               {  /* j-th column is non-basic on its lower bound */
                  if (dj < 0.0) dj = 0.0;
                  if (obj + dj >= mip->mip_obj)
                     glp_set_col_bnds(mip, j, GLP_FX, lb, lb), fixed++;
               }
               else if (stat == GLP_NU)
               {  /* j-th column is non-basic on its upper bound */
                  if (dj > 0.0) dj = 0.0;
                  if (obj - dj >= mip->mip_obj)
                     glp_set_col_bnds(mip, j, GLP_FX, ub, ub), fixed++;
               }
               break;
            case GLP_MAX:
               /* maximization */
               if (stat == GLP_NL)
               {  /* j-th column is non-basic on its lower bound */
                  if (dj > 0.0) dj = 0.0;
                  if (obj + dj <= mip->mip_obj)
                     glp_set_col_bnds(mip, j, GLP_FX, lb, lb), fixed++;
               }
               else if (stat == GLP_NU)
               {  /* j-th column is non-basic on its upper bound */
                  if (dj < 0.0) dj = 0.0;
                  if (obj - dj <= mip->mip_obj)
                     glp_set_col_bnds(mip, j, GLP_FX, ub, ub), fixed++;
               }
               break;
            default:
               xassert(T != T);
         }
      }
      if (T->parm->msg_lev >= GLP_MSG_DBG)
      {  if (fixed == 0)
            /* nothing to say */;
         else if (fixed == 1)
            xprintf("One column has been fixed by reduced cost\n");
         else
            xprintf("%d columns have been fixed by reduced costs\n",
               fixed);
      }
      /* fixing non-basic columns on their current bounds does not
         change the basic solution */
      xassert(mip->pbs_stat == GLP_FEAS && mip->dbs_stat == GLP_FEAS);
      return;
}

/***********************************************************************
*  branch_on - perform branching on specified variable
*
*  This routine performs branching on j-th column (structural variable)
*  of the current subproblem. The specified column must be of integer
*  kind and must have a fractional value in optimal basic solution of
*  LP relaxation of the current subproblem (i.e. only columns for which
*  the flag non_int[j] is set are valid candidates to branch on).
*
*  Let x be j-th structural variable, and beta be its primal fractional
*  value in the current basic solution. Branching on j-th variable is
*  dividing the current subproblem into two new subproblems, which are
*  identical to the current subproblem with the following exception: in
*  the first subproblem that begins the down-branch x has a new upper
*  bound x <= floor(beta), and in the second subproblem that begins the
*  up-branch x has a new lower bound x >= ceil(beta).
*
*  Depending on estimation of local bounds for down- and up-branches
*  this routine returns the following:
*
*  0 - both branches have been created;
*  1 - one branch is hopeless and has been pruned, so now the current
*      subproblem is other branch;
*  2 - both branches are hopeless and have been pruned; new subproblem
*      selection is needed to continue the search. */

static int branch_on(glp_tree *T, int j, int next)
{     glp_prob *mip = T->mip;
      IOSNPD *node;
      int m = mip->m;
      int n = mip->n;
      int type, dn_type, up_type, dn_bad, up_bad, p, ret, clone[1+2];
      double lb, ub, beta, new_ub, new_lb, dn_lp, up_lp, dn_bnd, up_bnd;
      /* determine bounds and value of x[j] in optimal solution to LP
         relaxation of the current subproblem */
      xassert(1 <= j && j <= n);
      type = mip->col[j]->type;
      lb = mip->col[j]->lb;
      ub = mip->col[j]->ub;
      beta = mip->col[j]->prim;
      /* determine new bounds of x[j] for down- and up-branches */
      new_ub = floor(beta);
      new_lb = ceil(beta);
      switch (type)
      {  case GLP_FR:
            dn_type = GLP_UP;
            up_type = GLP_LO;
            break;
         case GLP_LO:
            xassert(lb <= new_ub);
            dn_type = (lb == new_ub ? GLP_FX : GLP_DB);
            xassert(lb + 1.0 <= new_lb);
            up_type = GLP_LO;
            break;
         case GLP_UP:
            xassert(new_ub <= ub - 1.0);
            dn_type = GLP_UP;
            xassert(new_lb <= ub);
            up_type = (new_lb == ub ? GLP_FX : GLP_DB);
            break;
         case GLP_DB:
            xassert(lb <= new_ub && new_ub <= ub - 1.0);
            dn_type = (lb == new_ub ? GLP_FX : GLP_DB);
            xassert(lb + 1.0 <= new_lb && new_lb <= ub);
            up_type = (new_lb == ub ? GLP_FX : GLP_DB);
            break;
         default:
            xassert(type != type);
      }
      /* compute local bounds to LP relaxation for both branches */
      ios_eval_degrad(T, j, &dn_lp, &up_lp);
      /* and improve them by rounding */
      dn_bnd = ios_round_bound(T, dn_lp);
      up_bnd = ios_round_bound(T, up_lp);
      /* check local bounds for down- and up-branches */
      dn_bad = !ios_is_hopeful(T, dn_bnd);
      up_bad = !ios_is_hopeful(T, up_bnd);
      if (dn_bad && up_bad)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Both down- and up-branches are hopeless\n");
         ret = 2;
         goto done;
      }
      else if (up_bad)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Up-branch is hopeless\n");
         glp_set_col_bnds(mip, j, dn_type, lb, new_ub);
         T->curr->lp_obj = dn_lp;
         if (mip->dir == GLP_MIN)
         {  if (T->curr->bound < dn_bnd)
                T->curr->bound = dn_bnd;
         }
         else if (mip->dir == GLP_MAX)
         {  if (T->curr->bound > dn_bnd)
                T->curr->bound = dn_bnd;
         }
         else
            xassert(mip != mip);
         ret = 1;
         goto done;
      }
      else if (dn_bad)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Down-branch is hopeless\n");
         glp_set_col_bnds(mip, j, up_type, new_lb, ub);
         T->curr->lp_obj = up_lp;
         if (mip->dir == GLP_MIN)
         {  if (T->curr->bound < up_bnd)
                T->curr->bound = up_bnd;
         }
         else if (mip->dir == GLP_MAX)
         {  if (T->curr->bound > up_bnd)
                T->curr->bound = up_bnd;
         }
         else
            xassert(mip != mip);
         ret = 1;
         goto done;
      }
      /* both down- and up-branches seem to be hopeful */
      if (T->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("Branching on column %d, primal value is %.9e\n",
            j, beta);
      /* determine the reference number of the current subproblem */
      xassert(T->curr != NULL);
      p = T->curr->p;
      T->curr->br_var = j;
      T->curr->br_val = beta;
      /* freeze the current subproblem */
      ios_freeze_node(T);
      /* create two clones of the current subproblem; the first clone
         begins the down-branch, the second one begins the up-branch */
      ios_clone_node(T, p, 2, clone);
      if (T->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("Node %d begins down branch, node %d begins up branch "
            "\n", clone[1], clone[2]);
      /* set new upper bound of j-th column in the down-branch */
      node = T->slot[clone[1]].node;
      xassert(node != NULL);
      xassert(node->up != NULL);
      xassert(node->b_ptr == NULL);
      node->b_ptr = dmp_get_atom(T->pool, sizeof(IOSBND));
      node->b_ptr->k = m + j;
      node->b_ptr->type = (unsigned char)dn_type;
      node->b_ptr->lb = lb;
      node->b_ptr->ub = new_ub;
      node->b_ptr->next = NULL;
      node->lp_obj = dn_lp;
      if (mip->dir == GLP_MIN)
      {  if (node->bound < dn_bnd)
             node->bound = dn_bnd;
      }
      else if (mip->dir == GLP_MAX)
      {  if (node->bound > dn_bnd)
             node->bound = dn_bnd;
      }
      else
         xassert(mip != mip);
      /* set new lower bound of j-th column in the up-branch */
      node = T->slot[clone[2]].node;
      xassert(node != NULL);
      xassert(node->up != NULL);
      xassert(node->b_ptr == NULL);
      node->b_ptr = dmp_get_atom(T->pool, sizeof(IOSBND));
      node->b_ptr->k = m + j;
      node->b_ptr->type = (unsigned char)up_type;
      node->b_ptr->lb = new_lb;
      node->b_ptr->ub = ub;
      node->b_ptr->next = NULL;
      node->lp_obj = up_lp;
      if (mip->dir == GLP_MIN)
      {  if (node->bound < up_bnd)
             node->bound = up_bnd;
      }
      else if (mip->dir == GLP_MAX)
      {  if (node->bound > up_bnd)
             node->bound = up_bnd;
      }
      else
         xassert(mip != mip);
      /* suggest the subproblem to be solved next */
      xassert(T->child == 0);
      if (next == GLP_NO_BRNCH)
         T->child = 0;
      else if (next == GLP_DN_BRNCH)
         T->child = clone[1];
      else if (next == GLP_UP_BRNCH)
         T->child = clone[2];
      else
         xassert(next != next);
      ret = 0;
done: return ret;
}

/***********************************************************************
*  cleanup_the_tree - prune hopeless branches from the tree
*
*  This routine walks through the active list and checks the local
*  bound for every active subproblem. If the local bound indicates that
*  the subproblem cannot have integer optimal solution better than the
*  incumbent objective value, the routine deletes such subproblem that,
*  in turn, involves pruning the corresponding branch of the tree. */

static void cleanup_the_tree(glp_tree *T)
{     IOSNPD *node, *next_node;
      int count = 0;
      /* the global bound must exist */
      xassert(T->mip->mip_stat == GLP_FEAS);
      /* walk through the list of active subproblems */
      for (node = T->head; node != NULL; node = next_node)
      {  /* deleting some active problem node may involve deleting its
            parents recursively; however, all its parents being created
            *before* it are always *precede* it in the node list, so
            the next problem node is never affected by such deletion */
         next_node = node->next;
         /* if the branch is hopeless, prune it */
         if (!is_branch_hopeful(T, node->p))
            ios_delete_node(T, node->p), count++;
      }
      if (T->parm->msg_lev >= GLP_MSG_DBG)
      {  if (count == 1)
            xprintf("One hopeless branch has been pruned\n");
         else if (count > 1)
            xprintf("%d hopeless branches have been pruned\n", count);
      }
      return;
}

/***********************************************************************
*  round_heur - simple rounding heuristic
*
*  This routine attempts to guess an integer feasible solution by
*  simple rounding values of all integer variables in basic solution to
*  nearest integers. */

static int round_heur(glp_tree *T)
{     glp_prob *P = T->mip;
      /*int m = P->m;*/
      int n = P->n;
      int i, j, ret;
      double *x;
      /* compute rounded values of variables */
      x = talloc(1+n, double);
      for (j = 1; j <= n; j++)
      {  GLPCOL *col = P->col[j];
         if (col->kind == GLP_IV)
         {  /* integer variable */
            x[j] = floor(col->prim + 0.5);
         }
         else if (col->type == GLP_FX)
         {  /* fixed variable */
            x[j] = col->prim;
         }
         else
         {  /* non-integer non-fixed variable */
            ret = 3;
            goto done;
         }
      }
      /* check that no constraints are violated */
      for (i = 1; i <= T->orig_m; i++)
      {  int type = T->orig_type[i];
         GLPAIJ *aij;
         double sum;
         if (type == GLP_FR)
            continue;
         /* compute value of linear form */
         sum = 0.0;
         for (aij = P->row[i]->ptr; aij != NULL; aij = aij->r_next)
            sum += aij->val * x[aij->col->j];
         /* check lower bound */
         if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
         {  if (sum < T->orig_lb[i] - 1e-9)
            {  /* lower bound is violated */
               ret = 2;
               goto done;
            }
         }
         /* check upper bound */
         if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
         {  if (sum > T->orig_ub[i] + 1e-9)
            {  /* upper bound is violated */
               ret = 2;
               goto done;
            }
         }
      }
      /* rounded solution is integer feasible */
      if (glp_ios_heur_sol(T, x) == 0)
      {  /* solution is accepted */
         ret = 0;
      }
      else
      {  /* solution is rejected */
         ret = 1;
      }
done: tfree(x);
      return ret;
}

/**********************************************************************/

#if 1 /* 08/III-2016 */
static void gmi_gen(glp_tree *T)
{     /* generate Gomory's mixed integer cuts */
      glp_prob *P, *pool;
      P = T->mip;
      pool = glp_create_prob();
      glp_add_cols(pool, P->n);
      glp_gmi_gen(P, pool, 50);
      if (pool->m > 0)
      {  int i, len, *ind;
         double *val;
         ind = xcalloc(1+P->n, sizeof(int));
         val = xcalloc(1+P->n, sizeof(double));
         for (i = 1; i <= pool->m; i++)
         {  len = glp_get_mat_row(pool, i, ind, val);
            glp_ios_add_row(T, NULL, GLP_RF_GMI, 0, len, ind, val,
               GLP_LO, pool->row[i]->lb);
         }
         xfree(ind);
         xfree(val);
      }
      glp_delete_prob(pool);
      return;
}
#endif

#ifdef NEW_COVER /* 13/II-2018 */
static void cov_gen(glp_tree *T)
{     /* generate cover cuts */
      glp_prob *P, *pool;
      if (T->cov_gen == NULL)
         return;
      P = T->mip;
      pool = glp_create_prob();
      glp_add_cols(pool, P->n);
      glp_cov_gen1(P, T->cov_gen, pool);
      if (pool->m > 0)
      {  int i, len, *ind;
         double *val;
         ind = xcalloc(1+P->n, sizeof(int));
         val = xcalloc(1+P->n, sizeof(double));
         for (i = 1; i <= pool->m; i++)
         {  len = glp_get_mat_row(pool, i, ind, val);
            glp_ios_add_row(T, NULL, GLP_RF_COV, 0, len, ind, val,
               GLP_UP, pool->row[i]->ub);
         }
         xfree(ind);
         xfree(val);
      }
      glp_delete_prob(pool);
      return;
}
#endif

#if 1 /* 08/III-2016 */
static void mir_gen(glp_tree *T)
{     /* generate mixed integer rounding cuts */
      glp_prob *P, *pool;
      P = T->mip;
      pool = glp_create_prob();
      glp_add_cols(pool, P->n);
      glp_mir_gen(P, T->mir_gen, pool);
      if (pool->m > 0)
      {  int i, len, *ind;
         double *val;
         ind = xcalloc(1+P->n, sizeof(int));
         val = xcalloc(1+P->n, sizeof(double));
         for (i = 1; i <= pool->m; i++)
         {  len = glp_get_mat_row(pool, i, ind, val);
            glp_ios_add_row(T, NULL, GLP_RF_MIR, 0, len, ind, val,
               GLP_UP, pool->row[i]->ub);
         }
         xfree(ind);
         xfree(val);
      }
      glp_delete_prob(pool);
      return;
}
#endif

#if 1 /* 08/III-2016 */
static void clq_gen(glp_tree *T, glp_cfg *G)
{     /* generate clique cut from conflict graph */
      glp_prob *P = T->mip;
      int n = P->n;
      int len, *ind;
      double *val;
      ind = talloc(1+n, int);
      val = talloc(1+n, double);
      len = glp_clq_cut(T->mip, G, ind, val);
      if (len > 0)
         glp_ios_add_row(T, NULL, GLP_RF_CLQ, 0, len, ind, val, GLP_UP,
            val[0]);
      tfree(ind);
      tfree(val);
      return;
}
#endif

static void generate_cuts(glp_tree *T)
{     /* generate generic cuts with built-in generators */
      if (!(T->parm->mir_cuts == GLP_ON ||
            T->parm->gmi_cuts == GLP_ON ||
            T->parm->cov_cuts == GLP_ON ||
            T->parm->clq_cuts == GLP_ON)) goto done;
#if 1 /* 20/IX-2008 */
      {  int i, max_cuts, added_cuts;
         max_cuts = T->n;
         if (max_cuts < 1000) max_cuts = 1000;
         added_cuts = 0;
         for (i = T->orig_m+1; i <= T->mip->m; i++)
         {  if (T->mip->row[i]->origin == GLP_RF_CUT)
               added_cuts++;
         }
         /* xprintf("added_cuts = %d\n", added_cuts); */
         if (added_cuts >= max_cuts) goto done;
      }
#endif
      /* generate and add to POOL all cuts violated by x* */
      if (T->parm->gmi_cuts == GLP_ON)
      {  if (T->curr->changed < 7)
#if 0 /* 08/III-2016 */
            ios_gmi_gen(T);
#else
            gmi_gen(T);
#endif
      }
      if (T->parm->mir_cuts == GLP_ON)
      {  xassert(T->mir_gen != NULL);
#if 0 /* 08/III-2016 */
         ios_mir_gen(T, T->mir_gen);
#else
         mir_gen(T);
#endif
      }
      if (T->parm->cov_cuts == GLP_ON)
      {  /* cover cuts works well along with mir cuts */
#ifdef NEW_COVER /* 13/II-2018 */
         cov_gen(T);
#else
         ios_cov_gen(T);
#endif
      }
      if (T->parm->clq_cuts == GLP_ON)
      {  if (T->clq_gen != NULL)
#if 0 /* 29/VI-2013 */
         {  if (T->curr->level == 0 && T->curr->changed < 50 ||
                T->curr->level >  0 && T->curr->changed < 5)
#else /* FIXME */
         {  if (T->curr->level == 0 && T->curr->changed < 500 ||
                T->curr->level >  0 && T->curr->changed < 50)
#endif
#if 0 /* 08/III-2016 */
               ios_clq_gen(T, T->clq_gen);
#else
               clq_gen(T, T->clq_gen);
#endif
         }
      }
done: return;
}

/**********************************************************************/

static void remove_cuts(glp_tree *T)
{     /* remove inactive cuts (some valueable globally valid cut might
         be saved in the global cut pool) */
      int i, cnt = 0, *num = NULL;
      xassert(T->curr != NULL);
      for (i = T->orig_m+1; i <= T->mip->m; i++)
      {  if (T->mip->row[i]->origin == GLP_RF_CUT &&
             T->mip->row[i]->level == T->curr->level &&
             T->mip->row[i]->stat == GLP_BS)
         {  if (num == NULL)
               num = xcalloc(1+T->mip->m, sizeof(int));
            num[++cnt] = i;
         }
      }
      if (cnt > 0)
      {  glp_del_rows(T->mip, cnt, num);
#if 0
         xprintf("%d inactive cut(s) removed\n", cnt);
#endif
         xfree(num);
         xassert(glp_factorize(T->mip) == 0);
      }
      return;
}

/**********************************************************************/

static void display_cut_info(glp_tree *T)
{     glp_prob *mip = T->mip;
      int i, gmi = 0, mir = 0, cov = 0, clq = 0, app = 0;
      for (i = mip->m; i > 0; i--)
      {  GLPROW *row;
         row = mip->row[i];
         /* if (row->level < T->curr->level) break; */
         if (row->origin == GLP_RF_CUT)
         {  if (row->klass == GLP_RF_GMI)
               gmi++;
            else if (row->klass == GLP_RF_MIR)
               mir++;
            else if (row->klass == GLP_RF_COV)
               cov++;
            else if (row->klass == GLP_RF_CLQ)
               clq++;
            else
               app++;
         }
      }
      xassert(T->curr != NULL);
      if (gmi + mir + cov + clq + app > 0)
      {  xprintf("Cuts on level %d:", T->curr->level);
         if (gmi > 0) xprintf(" gmi = %d;", gmi);
         if (mir > 0) xprintf(" mir = %d;", mir);
         if (cov > 0) xprintf(" cov = %d;", cov);
         if (clq > 0) xprintf(" clq = %d;", clq);
         if (app > 0) xprintf(" app = %d;", app);
         xprintf("\n");
      }
      return;
}

/***********************************************************************
*  NAME
*
*  ios_driver - branch-and-cut driver
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_driver(glp_tree *T);
*
*  DESCRIPTION
*
*  The routine ios_driver is a branch-and-cut driver. It controls the
*  MIP solution process.
*
*  RETURNS
*
*  0  The MIP problem instance has been successfully solved. This code
*     does not necessarily mean that the solver has found optimal
*     solution. It only means that the solution process was successful.
*
*  GLP_EFAIL
*     The search was prematurely terminated due to the solver failure.
*
*  GLP_EMIPGAP
*     The search was prematurely terminated, because the relative mip
*     gap tolerance has been reached.
*
*  GLP_ETMLIM
*     The search was prematurely terminated, because the time limit has
*     been exceeded.
*
*  GLP_ESTOP
*     The search was prematurely terminated by application. */

int ios_driver(glp_tree *T)
{     int p, curr_p, p_stat, d_stat, ret;
#if 1 /* carry out to glp_tree */
      int pred_p = 0;
      /* if the current subproblem has been just created due to
         branching, pred_p is the reference number of its parent
         subproblem, otherwise pred_p is zero */
#endif
#if 1 /* 18/VII-2013 */
      int bad_cut;
      double old_obj;
#endif
#if 0 /* 10/VI-2013 */
      glp_long ttt = T->tm_beg;
#else
      double ttt = T->tm_beg;
#endif
#if 1 /* 27/II-2016 by Chris */
      int root_done = 0;
#endif
#if 0
      ((glp_iocp *)T->parm)->msg_lev = GLP_MSG_DBG;
#endif
#if 1 /* 01/III-2018 */
      if (((glp_iocp *)T->parm)->flip)
         if (T->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Long-step dual simplex will be used\n");
#endif
      /* on entry to the B&B driver it is assumed that the active list
         contains the only active (i.e. root) subproblem, which is the
         original MIP problem to be solved */
loop: /* main loop starts here */
      /* at this point the current subproblem does not exist */
      xassert(T->curr == NULL);
      /* if the active list is empty, the search is finished */
      if (T->head == NULL)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Active list is empty!\n");
#if 0 /* 10/VI-2013 */
         xassert(dmp_in_use(T->pool).lo == 0);
#else
         xassert(dmp_in_use(T->pool) == 0);
#endif
         ret = 0;
         goto done;
      }
      /* select some active subproblem to continue the search */
      xassert(T->next_p == 0);
      /* let the application program select subproblem */
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         T->reason = GLP_ISELECT;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
      }
      if (T->next_p != 0)
      {  /* the application program has selected something */
         ;
      }
      else if (T->a_cnt == 1)
      {  /* the only active subproblem exists, so select it */
         xassert(T->head->next == NULL);
         T->next_p = T->head->p;
      }
      else if (T->child != 0)
      {  /* select one of branching childs suggested by the branching
            heuristic */
         T->next_p = T->child;
      }
      else
      {  /* select active subproblem as specified by the backtracking
            technique option */
         T->next_p = ios_choose_node(T);
      }
      /* the active subproblem just selected becomes current */
      ios_revive_node(T, T->next_p);
      T->next_p = T->child = 0;
      /* invalidate pred_p, if it is not the reference number of the
         parent of the current subproblem */
      if (T->curr->up != NULL && T->curr->up->p != pred_p) pred_p = 0;
      /* determine the reference number of the current subproblem */
      p = T->curr->p;
      if (T->parm->msg_lev >= GLP_MSG_DBG)
      {  xprintf("-----------------------------------------------------"
            "-------------------\n");
         xprintf("Processing node %d at level %d\n", p, T->curr->level);
      }
#if 0
      if (p == 1)
         glp_write_lp(T->mip, NULL, "root.lp");
#endif
#if 1 /* 24/X-2015 */
      if (p == 1)
      {  if (T->parm->sr_heur == GLP_OFF)
         {  if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("Simple rounding heuristic disabled\n");
         }
      }
#endif
      /* if it is the root subproblem, initialize cut generators */
      if (p == 1)
      {  if (T->parm->gmi_cuts == GLP_ON)
         {  if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("Gomory's cuts enabled\n");
         }
         if (T->parm->mir_cuts == GLP_ON)
         {  if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("MIR cuts enabled\n");
            xassert(T->mir_gen == NULL);
#if 0 /* 06/III-2016 */
            T->mir_gen = ios_mir_init(T);
#else
            T->mir_gen = glp_mir_init(T->mip);
#endif
         }
         if (T->parm->cov_cuts == GLP_ON)
         {  if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("Cover cuts enabled\n");
#ifdef NEW_COVER /* 13/II-2018 */
            xassert(T->cov_gen == NULL);
            T->cov_gen = glp_cov_init(T->mip);
#endif
         }
         if (T->parm->clq_cuts == GLP_ON)
         {  xassert(T->clq_gen == NULL);
            if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("Clique cuts enabled\n");
#if 0 /* 08/III-2016 */
            T->clq_gen = ios_clq_init(T);
#else
            T->clq_gen = glp_cfg_init(T->mip);
#endif
         }
      }
#if 1 /* 18/VII-2013 */
      bad_cut = 0;
#endif
more: /* minor loop starts here */
      /* at this point the current subproblem needs either to be solved
         for the first time or re-optimized due to reformulation */
      /* display current progress of the search */
      if (T->parm->msg_lev >= GLP_MSG_DBG ||
          T->parm->msg_lev >= GLP_MSG_ON &&
        (double)(T->parm->out_frq - 1) <=
            1000.0 * xdifftime(xtime(), T->tm_lag))
         show_progress(T, 0);
      if (T->parm->msg_lev >= GLP_MSG_ALL &&
            xdifftime(xtime(), ttt) >= 60.0)
#if 0 /* 16/II-2012 */
      {  glp_long total;
         glp_mem_usage(NULL, NULL, &total, NULL);
         xprintf("Time used: %.1f secs.  Memory used: %.1f Mb.\n",
            xdifftime(xtime(), T->tm_beg), xltod(total) / 1048576.0);
         ttt = xtime();
      }
#else
      {  size_t total;
         glp_mem_usage(NULL, NULL, &total, NULL);
         xprintf("Time used: %.1f secs.  Memory used: %.1f Mb.\n",
            xdifftime(xtime(), T->tm_beg), (double)total / 1048576.0);
         ttt = xtime();
      }
#endif
      /* check the mip gap */
      if (T->parm->mip_gap > 0.0 &&
          ios_relative_gap(T) <= T->parm->mip_gap)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Relative gap tolerance reached; search terminated "
               "\n");
         ret = GLP_EMIPGAP;
         goto done;
      }
      /* check if the time limit has been exhausted */
      if (T->parm->tm_lim < INT_MAX &&
         (double)(T->parm->tm_lim - 1) <=
         1000.0 * xdifftime(xtime(), T->tm_beg))
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Time limit exhausted; search terminated\n");
         ret = GLP_ETMLIM;
         goto done;
      }
      /* let the application program preprocess the subproblem */
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         T->reason = GLP_IPREPRO;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
      }
      /* perform basic preprocessing */
      if (T->parm->pp_tech == GLP_PP_NONE)
         ;
      else if (T->parm->pp_tech == GLP_PP_ROOT)
#if 0 /* 27/II-2016 by Chris */
      {  if (T->curr->level == 0)
#else
      {  if (!root_done)
#endif
         {  if (ios_preprocess_node(T, 100))
               goto fath;
         }
      }
      else if (T->parm->pp_tech == GLP_PP_ALL)
#if 0 /* 27/II-2016 by Chris */
      {  if (ios_preprocess_node(T, T->curr->level == 0 ? 100 : 10))
#else
      {  if (ios_preprocess_node(T, !root_done ? 100 : 10))
#endif
            goto fath;
      }
      else
         xassert(T != T);
      /* preprocessing may improve the global bound */
      if (!is_branch_hopeful(T, p))
      {  xprintf("*** not tested yet ***\n");
         goto fath;
      }
      /* solve LP relaxation of the current subproblem */
      if (T->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("Solving LP relaxation...\n");
      ret = ios_solve_node(T);
      if (ret == GLP_ETMLIM)
         goto done;
      else if (!(ret == 0 || ret == GLP_EOBJLL || ret == GLP_EOBJUL))
      {  if (T->parm->msg_lev >= GLP_MSG_ERR)
            xprintf("ios_driver: unable to solve current LP relaxation;"
               " glp_simplex returned %d\n", ret);
         ret = GLP_EFAIL;
         goto done;
      }
      /* analyze status of the basic solution to LP relaxation found */
      p_stat = T->mip->pbs_stat;
      d_stat = T->mip->dbs_stat;
      if (p_stat == GLP_FEAS && d_stat == GLP_FEAS)
      {  /* LP relaxation has optimal solution */
         if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Found optimal solution to LP relaxation\n");
      }
      else if (d_stat == GLP_NOFEAS)
      {  /* LP relaxation has no dual feasible solution */
         /* since the current subproblem cannot have a larger feasible
            region than its parent, there is something wrong */
         if (T->parm->msg_lev >= GLP_MSG_ERR)
            xprintf("ios_driver: current LP relaxation has no dual feas"
               "ible solution\n");
         ret = GLP_EFAIL;
         goto done;
      }
      else if (p_stat == GLP_INFEAS && d_stat == GLP_FEAS)
      {  /* LP relaxation has no primal solution which is better than
            the incumbent objective value */
         xassert(T->mip->mip_stat == GLP_FEAS);
         if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("LP relaxation has no solution better than incumben"
               "t objective value\n");
         /* prune the branch */
         goto fath;
      }
      else if (p_stat == GLP_NOFEAS)
      {  /* LP relaxation has no primal feasible solution */
         if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("LP relaxation has no feasible solution\n");
         /* prune the branch */
         goto fath;
      }
      else
      {  /* other cases cannot appear */
         xassert(T->mip != T->mip);
      }
      /* at this point basic solution to LP relaxation of the current
         subproblem is optimal */
      xassert(p_stat == GLP_FEAS && d_stat == GLP_FEAS);
      xassert(T->curr != NULL);
      T->curr->lp_obj = T->mip->obj_val;
      /* thus, it defines a local bound to integer optimal solution of
         the current subproblem */
      {  double bound = T->mip->obj_val;
         /* some local bound to the current subproblem could be already
            set before, so we should only improve it */
         bound = ios_round_bound(T, bound);
         if (T->mip->dir == GLP_MIN)
         {  if (T->curr->bound < bound)
               T->curr->bound = bound;
         }
         else if (T->mip->dir == GLP_MAX)
         {  if (T->curr->bound > bound)
               T->curr->bound = bound;
         }
         else
            xassert(T->mip != T->mip);
         if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Local bound is %.9e\n", bound);
      }
      /* if the local bound indicates that integer optimal solution of
         the current subproblem cannot be better than the global bound,
         prune the branch */
      if (!is_branch_hopeful(T, p))
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("Current branch is hopeless and can be pruned\n");
         goto fath;
      }
      /* let the application program generate additional rows ("lazy"
         constraints) */
      xassert(T->reopt == 0);
      xassert(T->reinv == 0);
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         T->reason = GLP_IROWGEN;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
         if (T->reopt)
         {  /* some rows were added; re-optimization is needed */
            T->reopt = T->reinv = 0;
            goto more;
         }
         if (T->reinv)
         {  /* no rows were added, however, some inactive rows were
               removed */
            T->reinv = 0;
            xassert(glp_factorize(T->mip) == 0);
         }
      }
      /* check if the basic solution is integer feasible */
      check_integrality(T);
      /* if the basic solution satisfies to all integrality conditions,
         it is a new, better integer feasible solution */
      if (T->curr->ii_cnt == 0)
      {  if (T->parm->msg_lev >= GLP_MSG_DBG)
            xprintf("New integer feasible solution found\n");
         if (T->parm->msg_lev >= GLP_MSG_ALL)
            display_cut_info(T);
         record_solution(T);
         if (T->parm->msg_lev >= GLP_MSG_ON)
            show_progress(T, 1);
#if 1 /* 11/VII-2013 */
         ios_process_sol(T);
#endif
         /* make the application program happy */
         if (T->parm->cb_func != NULL)
         {  xassert(T->reason == 0);
            T->reason = GLP_IBINGO;
            T->parm->cb_func(T, T->parm->cb_info);
            T->reason = 0;
            if (T->stop)
            {  ret = GLP_ESTOP;
               goto done;
            }
         }
         /* since the current subproblem has been fathomed, prune its
            branch */
         goto fath;
      }
      /* at this point basic solution to LP relaxation of the current
         subproblem is optimal, but integer infeasible */
      /* try to fix some non-basic structural variables of integer kind
         on their current bounds due to reduced costs */
      if (T->mip->mip_stat == GLP_FEAS)
         fix_by_red_cost(T);
      /* let the application program try to find some solution to the
         original MIP with a primal heuristic */
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         T->reason = GLP_IHEUR;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
         /* check if the current branch became hopeless */
         if (!is_branch_hopeful(T, p))
         {  if (T->parm->msg_lev >= GLP_MSG_DBG)
               xprintf("Current branch became hopeless and can be prune"
                  "d\n");
            goto fath;
         }
      }
      /* try to find solution with the feasibility pump heuristic */
#if 0 /* 27/II-2016 by Chris */
      if (T->parm->fp_heur)
#else
      if (T->parm->fp_heur && !root_done)
#endif
      {  xassert(T->reason == 0);
         T->reason = GLP_IHEUR;
         ios_feas_pump(T);
         T->reason = 0;
         /* check if the current branch became hopeless */
         if (!is_branch_hopeful(T, p))
         {  if (T->parm->msg_lev >= GLP_MSG_DBG)
               xprintf("Current branch became hopeless and can be prune"
                  "d\n");
            goto fath;
         }
      }
#if 1 /* 25/V-2013 */
      /* try to find solution with the proximity search heuristic */
#if 0 /* 27/II-2016 by Chris */
      if (T->parm->ps_heur)
#else
      if (T->parm->ps_heur && !root_done)
#endif
      {  xassert(T->reason == 0);
         T->reason = GLP_IHEUR;
         ios_proxy_heur(T);
         T->reason = 0;
         /* check if the current branch became hopeless */
         if (!is_branch_hopeful(T, p))
         {  if (T->parm->msg_lev >= GLP_MSG_DBG)
               xprintf("Current branch became hopeless and can be prune"
                  "d\n");
            goto fath;
         }
      }
#endif
#if 1 /* 24/X-2015 */
      /* try to find solution with a simple rounding heuristic */
      if (T->parm->sr_heur)
      {  xassert(T->reason == 0);
         T->reason = GLP_IHEUR;
         round_heur(T);
         T->reason = 0;
         /* check if the current branch became hopeless */
         if (!is_branch_hopeful(T, p))
         {  if (T->parm->msg_lev >= GLP_MSG_DBG)
               xprintf("Current branch became hopeless and can be prune"
                  "d\n");
            goto fath;
         }
      }
#endif
      /* it's time to generate cutting planes */
      xassert(T->local != NULL);
#ifdef NEW_LOCAL /* 02/II-2018 */
      xassert(T->local->m == 0);
#else
      xassert(T->local->size == 0);
#endif
      /* let the application program generate some cuts; note that it
         can add cuts either to the local cut pool or directly to the
         current subproblem */
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         T->reason = GLP_ICUTGEN;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
      }
#if 1 /* 18/VII-2013 */
      if (T->curr->changed > 0)
      {  double degrad = fabs(T->curr->lp_obj - old_obj);
         if (degrad < 1e-4 * (1.0 + fabs(old_obj)))
            bad_cut++;
         else
            bad_cut = 0;
      }
      old_obj = T->curr->lp_obj;
#if 0 /* 27/II-2016 by Chris */
      if (bad_cut == 0 || (T->curr->level == 0 && bad_cut <= 3))
#else
      if (bad_cut == 0 || (!root_done && bad_cut <= 3))
#endif
#endif
      /* try to generate generic cuts with built-in generators
         (as suggested by Prof. Fischetti et al. the built-in cuts are
         not generated at each branching node; an intense attempt of
         generating new cuts is only made at the root node, and then
         a moderate effort is spent after each backtracking step) */
#if 0 /* 27/II-2016 by Chris */
      if (T->curr->level == 0 || pred_p == 0)
#else
      if (!root_done || pred_p == 0)
#endif
      {  xassert(T->reason == 0);
         T->reason = GLP_ICUTGEN;
         generate_cuts(T);
         T->reason = 0;
      }
      /* if the local cut pool is not empty, select useful cuts and add
         them to the current subproblem */
#ifdef NEW_LOCAL /* 02/II-2018 */
      if (T->local->m > 0)
#else
      if (T->local->size > 0)
#endif
      {  xassert(T->reason == 0);
         T->reason = GLP_ICUTGEN;
         ios_process_cuts(T);
         T->reason = 0;
      }
      /* clear the local cut pool */
      ios_clear_pool(T, T->local);
      /* perform re-optimization, if necessary */
      if (T->reopt)
      {  T->reopt = 0;
         T->curr->changed++;
         goto more;
      }
      /* no cuts were generated; remove inactive cuts */
      remove_cuts(T);
#if 0 /* 27/II-2016 by Chris */
      if (T->parm->msg_lev >= GLP_MSG_ALL && T->curr->level == 0)
#else
      if (T->parm->msg_lev >= GLP_MSG_ALL && !root_done)
#endif
         display_cut_info(T);
#if 1 /* 27/II-2016 by Chris */
      /* the first node will not be treated as root any more */
      if (!root_done) root_done = 1;
#endif
      /* update history information used on pseudocost branching */
      if (T->pcost != NULL) ios_pcost_update(T);
      /* it's time to perform branching */
      xassert(T->br_var == 0);
      xassert(T->br_sel == 0);
      /* let the application program choose variable to branch on */
      if (T->parm->cb_func != NULL)
      {  xassert(T->reason == 0);
         xassert(T->br_var == 0);
         xassert(T->br_sel == 0);
         T->reason = GLP_IBRANCH;
         T->parm->cb_func(T, T->parm->cb_info);
         T->reason = 0;
         if (T->stop)
         {  ret = GLP_ESTOP;
            goto done;
         }
      }
      /* if nothing has been chosen, choose some variable as specified
         by the branching technique option */
      if (T->br_var == 0)
         T->br_var = ios_choose_var(T, &T->br_sel);
      /* perform actual branching */
      curr_p = T->curr->p;
      ret = branch_on(T, T->br_var, T->br_sel);
      T->br_var = T->br_sel = 0;
      if (ret == 0)
      {  /* both branches have been created */
         pred_p = curr_p;
         goto loop;
      }
      else if (ret == 1)
      {  /* one branch is hopeless and has been pruned, so now the
            current subproblem is other branch */
         /* the current subproblem should be considered as a new one,
            since one bound of the branching variable was changed */
         T->curr->solved = T->curr->changed = 0;
#if 1 /* 18/VII-2013 */
         /* bad_cut = 0; */
#endif
         goto more;
      }
      else if (ret == 2)
      {  /* both branches are hopeless and have been pruned; new
            subproblem selection is needed to continue the search */
         goto fath;
      }
      else
         xassert(ret != ret);
fath: /* the current subproblem has been fathomed */
      if (T->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("Node %d fathomed\n", p);
      /* freeze the current subproblem */
      ios_freeze_node(T);
      /* and prune the corresponding branch of the tree */
      ios_delete_node(T, p);
      /* if a new integer feasible solution has just been found, other
         branches may become hopeless and therefore must be pruned */
      if (T->mip->mip_stat == GLP_FEAS) cleanup_the_tree(T);
      /* new subproblem selection is needed due to backtracking */
      pred_p = 0;
      goto loop;
done: /* display progress of the search on exit from the solver */
      if (T->parm->msg_lev >= GLP_MSG_ON)
         show_progress(T, 0);
      if (T->mir_gen != NULL)
#if 0 /* 06/III-2016 */
         ios_mir_term(T->mir_gen), T->mir_gen = NULL;
#else
         glp_mir_free(T->mir_gen), T->mir_gen = NULL;
#endif
#ifdef NEW_COVER /* 13/II-2018 */
      if (T->cov_gen != NULL)
         glp_cov_free(T->cov_gen), T->cov_gen = NULL;
#endif
      if (T->clq_gen != NULL)
#if 0 /* 08/III-2016 */
         ios_clq_term(T->clq_gen), T->clq_gen = NULL;
#else
         glp_cfg_free(T->clq_gen), T->clq_gen = NULL;
#endif
      /* return to the calling program */
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios07.c0000644000175100001710000004457300000000000025031 0ustar00runnerdocker00000000000000/* glpios07.c (mixed cover cut generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2005-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/*----------------------------------------------------------------------
-- COVER INEQUALITIES
--
-- Consider the set of feasible solutions to 0-1 knapsack problem:
--
--    sum a[j]*x[j] <= b,                                            (1)
--  j in J
--
--    x[j] is binary,                                                (2)
--
-- where, wlog, we assume that a[j] > 0 (since 0-1 variables can be
-- complemented) and a[j] <= b (since a[j] > b implies x[j] = 0).
--
-- A set C within J is called a cover if
--
--    sum a[j] > b.                                                  (3)
--  j in C
--
-- For any cover C the inequality
--
--    sum x[j] <= |C| - 1                                            (4)
--  j in C
--
-- is called a cover inequality and is valid for (1)-(2).
--
-- MIXED COVER INEQUALITIES
--
-- Consider the set of feasible solutions to mixed knapsack problem:
--
--    sum a[j]*x[j] + y <= b,                                        (5)
--  j in J
--
--    x[j] is binary,                                                (6)
--
--    0 <= y <= u is continuous,                                     (7)
--
-- where again we assume that a[j] > 0.
--
-- Let C within J be some set. From (1)-(4) it follows that
--
--    sum a[j] > b - y                                               (8)
--  j in C
--
-- implies
--
--    sum x[j] <= |C| - 1.                                           (9)
--  j in C
--
-- Thus, we need to modify the inequality (9) in such a way that it be
-- a constraint only if the condition (8) is satisfied.
--
-- Consider the following inequality:
--
--    sum x[j] <= |C| - t.                                          (10)
--  j in C
--
-- If 0 < t <= 1, then (10) is equivalent to (9), because all x[j] are
-- binary variables. On the other hand, if t <= 0, (10) being satisfied
-- for any values of x[j] is not a constraint.
--
-- Let
--
--    t' = sum a[j] + y - b.                                        (11)
--       j in C
--
-- It is understood that the condition t' > 0 is equivalent to (8).
-- Besides, from (6)-(7) it follows that t' has an implied upper bound:
--
--    t'max = sum a[j] + u - b.                                     (12)
--          j in C
--
-- This allows to express the parameter t having desired properties:
--
--    t = t' / t'max.                                               (13)
--
-- In fact, t <= 1 by definition, and t > 0 being equivalent to t' > 0
-- is equivalent to (8).
--
-- Thus, the inequality (10), where t is given by formula (13) is valid
-- for (5)-(7).
--
-- Note that if u = 0, then y = 0, so t = 1, and the conditions (8) and
-- (10) is transformed to the conditions (3) and (4).
--
-- GENERATING MIXED COVER CUTS
--
-- To generate a mixed cover cut in the form (10) we need to find such
-- set C which satisfies to the inequality (8) and for which, in turn,
-- the inequality (10) is violated in the current point.
--
-- Substituting t from (13) to (10) gives:
--
--                        1
--    sum x[j] <= |C| - -----  (sum a[j] + y - b),                  (14)
--  j in C              t'max j in C
--
-- and finally we have the cut inequality in the standard form:
--
--    sum x[j] + alfa * y <= beta,                                  (15)
--  j in C
--
-- where:
--
--    alfa = 1 / t'max,                                             (16)
--
--    beta = |C| - alfa *  (sum a[j] - b).                          (17)
--                        j in C                                      */

#if 1
#define MAXTRY 1000
#else
#define MAXTRY 10000
#endif

static int cover2(int n, double a[], double b, double u, double x[],
      double y, int cov[], double *_alfa, double *_beta)
{     /* try to generate mixed cover cut using two-element cover */
      int i, j, try = 0, ret = 0;
      double eps, alfa, beta, temp, rmax = 0.001;
      eps = 0.001 * (1.0 + fabs(b));
      for (i = 0+1; i <= n; i++)
      for (j = i+1; j <= n; j++)
      {  /* C = {i, j} */
         try++;
         if (try > MAXTRY) goto done;
         /* check if condition (8) is satisfied */
         if (a[i] + a[j] + y > b + eps)
         {  /* compute parameters for inequality (15) */
            temp = a[i] + a[j] - b;
            alfa = 1.0 / (temp + u);
            beta = 2.0 - alfa * temp;
            /* compute violation of inequality (15) */
            temp = x[i] + x[j] + alfa * y - beta;
            /* choose C providing maximum violation */
            if (rmax < temp)
            {  rmax = temp;
               cov[1] = i;
               cov[2] = j;
               *_alfa = alfa;
               *_beta = beta;
               ret = 1;
            }
         }
      }
done: return ret;
}

static int cover3(int n, double a[], double b, double u, double x[],
      double y, int cov[], double *_alfa, double *_beta)
{     /* try to generate mixed cover cut using three-element cover */
      int i, j, k, try = 0, ret = 0;
      double eps, alfa, beta, temp, rmax = 0.001;
      eps = 0.001 * (1.0 + fabs(b));
      for (i = 0+1; i <= n; i++)
      for (j = i+1; j <= n; j++)
      for (k = j+1; k <= n; k++)
      {  /* C = {i, j, k} */
         try++;
         if (try > MAXTRY) goto done;
         /* check if condition (8) is satisfied */
         if (a[i] + a[j] + a[k] + y > b + eps)
         {  /* compute parameters for inequality (15) */
            temp = a[i] + a[j] + a[k] - b;
            alfa = 1.0 / (temp + u);
            beta = 3.0 - alfa * temp;
            /* compute violation of inequality (15) */
            temp = x[i] + x[j] + x[k] + alfa * y - beta;
            /* choose C providing maximum violation */
            if (rmax < temp)
            {  rmax = temp;
               cov[1] = i;
               cov[2] = j;
               cov[3] = k;
               *_alfa = alfa;
               *_beta = beta;
               ret = 1;
            }
         }
      }
done: return ret;
}

static int cover4(int n, double a[], double b, double u, double x[],
      double y, int cov[], double *_alfa, double *_beta)
{     /* try to generate mixed cover cut using four-element cover */
      int i, j, k, l, try = 0, ret = 0;
      double eps, alfa, beta, temp, rmax = 0.001;
      eps = 0.001 * (1.0 + fabs(b));
      for (i = 0+1; i <= n; i++)
      for (j = i+1; j <= n; j++)
      for (k = j+1; k <= n; k++)
      for (l = k+1; l <= n; l++)
      {  /* C = {i, j, k, l} */
         try++;
         if (try > MAXTRY) goto done;
         /* check if condition (8) is satisfied */
         if (a[i] + a[j] + a[k] + a[l] + y > b + eps)
         {  /* compute parameters for inequality (15) */
            temp = a[i] + a[j] + a[k] + a[l] - b;
            alfa = 1.0 / (temp + u);
            beta = 4.0 - alfa * temp;
            /* compute violation of inequality (15) */
            temp = x[i] + x[j] + x[k] + x[l] + alfa * y - beta;
            /* choose C providing maximum violation */
            if (rmax < temp)
            {  rmax = temp;
               cov[1] = i;
               cov[2] = j;
               cov[3] = k;
               cov[4] = l;
               *_alfa = alfa;
               *_beta = beta;
               ret = 1;
            }
         }
      }
done: return ret;
}

static int cover(int n, double a[], double b, double u, double x[],
      double y, int cov[], double *alfa, double *beta)
{     /* try to generate mixed cover cut;
         input (see (5)):
         n        is the number of binary variables;
         a[1:n]   are coefficients at binary variables;
         b        is the right-hand side;
         u        is upper bound of continuous variable;
         x[1:n]   are values of binary variables at current point;
         y        is value of continuous variable at current point;
         output (see (15), (16), (17)):
         cov[1:r] are indices of binary variables included in cover C,
                  where r is the set cardinality returned on exit;
         alfa     coefficient at continuous variable;
         beta     is the right-hand side; */
      int j;
      /* perform some sanity checks */
      xassert(n >= 2);
      for (j = 1; j <= n; j++) xassert(a[j] > 0.0);
#if 1 /* ??? */
      xassert(b > -1e-5);
#else
      xassert(b > 0.0);
#endif
      xassert(u >= 0.0);
      for (j = 1; j <= n; j++) xassert(0.0 <= x[j] && x[j] <= 1.0);
      xassert(0.0 <= y && y <= u);
      /* try to generate mixed cover cut */
      if (cover2(n, a, b, u, x, y, cov, alfa, beta)) return 2;
      if (cover3(n, a, b, u, x, y, cov, alfa, beta)) return 3;
      if (cover4(n, a, b, u, x, y, cov, alfa, beta)) return 4;
      return 0;
}

/*----------------------------------------------------------------------
-- lpx_cover_cut - generate mixed cover cut.
--
-- SYNOPSIS
--
-- int lpx_cover_cut(LPX *lp, int len, int ind[], double val[],
--    double work[]);
--
-- DESCRIPTION
--
-- The routine lpx_cover_cut generates a mixed cover cut for a given
-- row of the MIP problem.
--
-- The given row of the MIP problem should be explicitly specified in
-- the form:
--
--    sum{j in J} a[j]*x[j] <= b.                                    (1)
--
-- On entry indices (ordinal numbers) of structural variables, which
-- have non-zero constraint coefficients, should be placed in locations
-- ind[1], ..., ind[len], and corresponding constraint coefficients
-- should be placed in locations val[1], ..., val[len]. The right-hand
-- side b should be stored in location val[0].
--
-- The working array work should have at least nb locations, where nb
-- is the number of binary variables in (1).
--
-- The routine generates a mixed cover cut in the same form as (1) and
-- stores the cut coefficients and right-hand side in the same way as
-- just described above.
--
-- RETURNS
--
-- If the cutting plane has been successfully generated, the routine
-- returns 1 <= len' <= n, which is the number of non-zero coefficients
-- in the inequality constraint. Otherwise, the routine returns zero. */

static int lpx_cover_cut(glp_prob *lp, int len, int ind[],
      double val[], double work[])
{     int cov[1+4], j, k, nb, newlen, r;
      double f_min, f_max, alfa, beta, u, *x = work, y;
      /* substitute and remove fixed variables */
      newlen = 0;
      for (k = 1; k <= len; k++)
      {  j = ind[k];
         if (glp_get_col_type(lp, j) == GLP_FX)
            val[0] -= val[k] * glp_get_col_lb(lp, j);
         else
         {  newlen++;
            ind[newlen] = ind[k];
            val[newlen] = val[k];
         }
      }
      len = newlen;
      /* move binary variables to the beginning of the list so that
         elements 1, 2, ..., nb correspond to binary variables, and
         elements nb+1, nb+2, ..., len correspond to rest variables */
      nb = 0;
      for (k = 1; k <= len; k++)
      {  j = ind[k];
         if (glp_get_col_kind(lp, j) == GLP_BV)
         {  /* binary variable */
            int ind_k;
            double val_k;
            nb++;
            ind_k = ind[nb], val_k = val[nb];
            ind[nb] = ind[k], val[nb] = val[k];
            ind[k] = ind_k, val[k] = val_k;
         }
      }
      /* now the specified row has the form:
         sum a[j]*x[j] + sum a[j]*y[j] <= b,
         where x[j] are binary variables, y[j] are rest variables */
      /* at least two binary variables are needed */
      if (nb < 2) return 0;
      /* compute implied lower and upper bounds for sum a[j]*y[j] */
      f_min = f_max = 0.0;
      for (k = nb+1; k <= len; k++)
      {  j = ind[k];
         /* both bounds must be finite */
         if (glp_get_col_type(lp, j) != GLP_DB) return 0;
         if (val[k] > 0.0)
         {  f_min += val[k] * glp_get_col_lb(lp, j);
            f_max += val[k] * glp_get_col_ub(lp, j);
         }
         else
         {  f_min += val[k] * glp_get_col_ub(lp, j);
            f_max += val[k] * glp_get_col_lb(lp, j);
         }
      }
      /* sum a[j]*x[j] + sum a[j]*y[j] <= b ===>
         sum a[j]*x[j] + (sum a[j]*y[j] - f_min) <= b - f_min ===>
         sum a[j]*x[j] + y <= b - f_min,
         where y = sum a[j]*y[j] - f_min;
         note that 0 <= y <= u, u = f_max - f_min */
      /* determine upper bound of y */
      u = f_max - f_min;
      /* determine value of y at the current point */
      y = 0.0;
      for (k = nb+1; k <= len; k++)
      {  j = ind[k];
         y += val[k] * glp_get_col_prim(lp, j);
      }
      y -= f_min;
      if (y < 0.0) y = 0.0;
      if (y > u) y = u;
      /* modify the right-hand side b */
      val[0] -= f_min;
      /* now the transformed row has the form:
         sum a[j]*x[j] + y <= b, where 0 <= y <= u */
      /* determine values of x[j] at the current point */
      for (k = 1; k <= nb; k++)
      {  j = ind[k];
         x[k] = glp_get_col_prim(lp, j);
         if (x[k] < 0.0) x[k] = 0.0;
         if (x[k] > 1.0) x[k] = 1.0;
      }
      /* if a[j] < 0, replace x[j] by its complement 1 - x'[j] */
      for (k = 1; k <= nb; k++)
      {  if (val[k] < 0.0)
         {  ind[k] = - ind[k];
            val[k] = - val[k];
            val[0] += val[k];
            x[k] = 1.0 - x[k];
         }
      }
      /* try to generate a mixed cover cut for the transformed row */
      r = cover(nb, val, val[0], u, x, y, cov, &alfa, &beta);
      if (r == 0) return 0;
      xassert(2 <= r && r <= 4);
      /* now the cut is in the form:
         sum{j in C} x[j] + alfa * y <= beta */
      /* store the right-hand side beta */
      ind[0] = 0, val[0] = beta;
      /* restore the original ordinal numbers of x[j] */
      for (j = 1; j <= r; j++) cov[j] = ind[cov[j]];
      /* store cut coefficients at binary variables complementing back
         the variables having negative row coefficients */
      xassert(r <= nb);
      for (k = 1; k <= r; k++)
      {  if (cov[k] > 0)
         {  ind[k] = +cov[k];
            val[k] = +1.0;
         }
         else
         {  ind[k] = -cov[k];
            val[k] = -1.0;
            val[0] -= 1.0;
         }
      }
      /* substitute y = sum a[j]*y[j] - f_min */
      for (k = nb+1; k <= len; k++)
      {  r++;
         ind[r] = ind[k];
         val[r] = alfa * val[k];
      }
      val[0] += alfa * f_min;
      xassert(r <= len);
      len = r;
      return len;
}

/*----------------------------------------------------------------------
-- lpx_eval_row - compute explictily specified row.
--
-- SYNOPSIS
--
-- double lpx_eval_row(LPX *lp, int len, int ind[], double val[]);
--
-- DESCRIPTION
--
-- The routine lpx_eval_row computes the primal value of an explicitly
-- specified row using current values of structural variables.
--
-- The explicitly specified row may be thought as a linear form:
--
--    y = a[1]*x[m+1] + a[2]*x[m+2] + ... + a[n]*x[m+n],
--
-- where y is an auxiliary variable for this row, a[j] are coefficients
-- of the linear form, x[m+j] are structural variables.
--
-- On entry column indices and numerical values of non-zero elements of
-- the row should be stored in locations ind[1], ..., ind[len] and
-- val[1], ..., val[len], where len is the number of non-zero elements.
-- The array ind and val are not changed on exit.
--
-- RETURNS
--
-- The routine returns a computed value of y, the auxiliary variable of
-- the specified row. */

static double lpx_eval_row(glp_prob *lp, int len, int ind[],
      double val[])
{     int n = glp_get_num_cols(lp);
      int j, k;
      double sum = 0.0;
      if (len < 0)
         xerror("lpx_eval_row: len = %d; invalid row length\n", len);
      for (k = 1; k <= len; k++)
      {  j = ind[k];
         if (!(1 <= j && j <= n))
            xerror("lpx_eval_row: j = %d; column number out of range\n",
               j);
         sum += val[k] * glp_get_col_prim(lp, j);
      }
      return sum;
}

/***********************************************************************
*  NAME
*
*  ios_cov_gen - generate mixed cover cuts
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_cov_gen(glp_tree *tree);
*
*  DESCRIPTION
*
*  The routine ios_cov_gen generates mixed cover cuts for the current
*  point and adds them to the cut pool. */

void ios_cov_gen(glp_tree *tree)
{     glp_prob *prob = tree->mip;
      int m = glp_get_num_rows(prob);
      int n = glp_get_num_cols(prob);
      int i, k, type, kase, len, *ind;
      double r, *val, *work;
      xassert(glp_get_status(prob) == GLP_OPT);
      /* allocate working arrays */
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      work = xcalloc(1+n, sizeof(double));
      /* look through all rows */
      for (i = 1; i <= m; i++)
      for (kase = 1; kase <= 2; kase++)
      {  type = glp_get_row_type(prob, i);
         if (kase == 1)
         {  /* consider rows of '<=' type */
            if (!(type == GLP_UP || type == GLP_DB)) continue;
            len = glp_get_mat_row(prob, i, ind, val);
            val[0] = glp_get_row_ub(prob, i);
         }
         else
         {  /* consider rows of '>=' type */
            if (!(type == GLP_LO || type == GLP_DB)) continue;
            len = glp_get_mat_row(prob, i, ind, val);
            for (k = 1; k <= len; k++) val[k] = - val[k];
            val[0] = - glp_get_row_lb(prob, i);
         }
         /* generate mixed cover cut:
            sum{j in J} a[j] * x[j] <= b */
         len = lpx_cover_cut(prob, len, ind, val, work);
         if (len == 0) continue;
         /* at the current point the cut inequality is violated, i.e.
            sum{j in J} a[j] * x[j] - b > 0 */
         r = lpx_eval_row(prob, len, ind, val) - val[0];
         if (r < 1e-3) continue;
         /* add the cut to the cut pool */
         glp_ios_add_row(tree, NULL, GLP_RF_COV, 0, len, ind, val,
            GLP_UP, val[0]);
      }
      /* free working arrays */
      xfree(ind);
      xfree(val);
      xfree(work);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios09.c0000644000175100001710000006304200000000000025023 0ustar00runnerdocker00000000000000/* glpios09.c (branching heuristics) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2005-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/***********************************************************************
*  NAME
*
*  ios_choose_var - select variable to branch on
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_choose_var(glp_tree *T, int *next);
*
*  The routine ios_choose_var chooses a variable from the candidate
*  list to branch on. Additionally the routine provides a flag stored
*  in the location next to suggests which of the child subproblems
*  should be solved next.
*
*  RETURNS
*
*  The routine ios_choose_var returns the ordinal number of the column
*  choosen. */

static int branch_first(glp_tree *T, int *next);
static int branch_last(glp_tree *T, int *next);
static int branch_mostf(glp_tree *T, int *next);
static int branch_drtom(glp_tree *T, int *next);

int ios_choose_var(glp_tree *T, int *next)
{     int j;
      if (T->parm->br_tech == GLP_BR_FFV)
      {  /* branch on first fractional variable */
         j = branch_first(T, next);
      }
      else if (T->parm->br_tech == GLP_BR_LFV)
      {  /* branch on last fractional variable */
         j = branch_last(T, next);
      }
      else if (T->parm->br_tech == GLP_BR_MFV)
      {  /* branch on most fractional variable */
         j = branch_mostf(T, next);
      }
      else if (T->parm->br_tech == GLP_BR_DTH)
      {  /* branch using the heuristic by Dreebeck and Tomlin */
         j = branch_drtom(T, next);
      }
      else if (T->parm->br_tech == GLP_BR_PCH)
      {  /* hybrid pseudocost heuristic */
         j = ios_pcost_branch(T, next);
      }
      else
         xassert(T != T);
      return j;
}

/***********************************************************************
*  branch_first - choose first branching variable
*
*  This routine looks up the list of structural variables and chooses
*  the first one, which is of integer kind and has fractional value in
*  optimal solution to the current LP relaxation.
*
*  This routine also selects the branch to be solved next where integer
*  infeasibility of the chosen variable is less than in other one. */

static int branch_first(glp_tree *T, int *_next)
{     int j, next;
      double beta;
      /* choose the column to branch on */
      for (j = 1; j <= T->n; j++)
         if (T->non_int[j]) break;
      xassert(1 <= j && j <= T->n);
      /* select the branch to be solved next */
      beta = glp_get_col_prim(T->mip, j);
      if (beta - floor(beta) < ceil(beta) - beta)
         next = GLP_DN_BRNCH;
      else
         next = GLP_UP_BRNCH;
      *_next = next;
      return j;
}

/***********************************************************************
*  branch_last - choose last branching variable
*
*  This routine looks up the list of structural variables and chooses
*  the last one, which is of integer kind and has fractional value in
*  optimal solution to the current LP relaxation.
*
*  This routine also selects the branch to be solved next where integer
*  infeasibility of the chosen variable is less than in other one. */

static int branch_last(glp_tree *T, int *_next)
{     int j, next;
      double beta;
      /* choose the column to branch on */
      for (j = T->n; j >= 1; j--)
         if (T->non_int[j]) break;
      xassert(1 <= j && j <= T->n);
      /* select the branch to be solved next */
      beta = glp_get_col_prim(T->mip, j);
      if (beta - floor(beta) < ceil(beta) - beta)
         next = GLP_DN_BRNCH;
      else
         next = GLP_UP_BRNCH;
      *_next = next;
      return j;
}

/***********************************************************************
*  branch_mostf - choose most fractional branching variable
*
*  This routine looks up the list of structural variables and chooses
*  that one, which is of integer kind and has most fractional value in
*  optimal solution to the current LP relaxation.
*
*  This routine also selects the branch to be solved next where integer
*  infeasibility of the chosen variable is less than in other one.
*
*  (Alexander Martin notices that "...most infeasible is as good as
*  random...".) */

static int branch_mostf(glp_tree *T, int *_next)
{     int j, jj, next;
      double beta, most, temp;
      /* choose the column to branch on */
      jj = 0, most = DBL_MAX;
      for (j = 1; j <= T->n; j++)
      {  if (T->non_int[j])
         {  beta = glp_get_col_prim(T->mip, j);
            temp = floor(beta) + 0.5;
            if (most > fabs(beta - temp))
            {  jj = j, most = fabs(beta - temp);
               if (beta < temp)
                  next = GLP_DN_BRNCH;
               else
                  next = GLP_UP_BRNCH;
            }
         }
      }
      *_next = next;
      return jj;
}

/***********************************************************************
*  branch_drtom - choose branching var using Driebeck-Tomlin heuristic
*
*  This routine chooses a structural variable, which is required to be
*  integral and has fractional value in optimal solution of the current
*  LP relaxation, using a heuristic proposed by Driebeck and Tomlin.
*
*  The routine also selects the branch to be solved next, again due to
*  Driebeck and Tomlin.
*
*  This routine is based on the heuristic proposed in:
*
*  Driebeck N.J. An algorithm for the solution of mixed-integer
*  programming problems, Management Science, 12: 576-87 (1966);
*
*  and improved in:
*
*  Tomlin J.A. Branch and bound methods for integer and non-convex
*  programming, in J.Abadie (ed.), Integer and Nonlinear Programming,
*  North-Holland, Amsterdam, pp. 437-50 (1970).
*
*  Must note that this heuristic is time-expensive, because computing
*  one-step degradation (see the routine below) requires one BTRAN for
*  each fractional-valued structural variable. */

static int branch_drtom(glp_tree *T, int *_next)
{     glp_prob *mip = T->mip;
      int m = mip->m;
      int n = mip->n;
      unsigned char *non_int = T->non_int;
      int j, jj, k, t, next, kase, len, stat, *ind;
      double x, dk, alfa, delta_j, delta_k, delta_z, dz_dn, dz_up,
         dd_dn, dd_up, degrad, *val;
      /* basic solution of LP relaxation must be optimal */
      xassert(glp_get_status(mip) == GLP_OPT);
      /* allocate working arrays */
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      /* nothing has been chosen so far */
      jj = 0, degrad = -1.0;
      /* walk through the list of columns (structural variables) */
      for (j = 1; j <= n; j++)
      {  /* if j-th column is not marked as fractional, skip it */
         if (!non_int[j]) continue;
         /* obtain (fractional) value of j-th column in basic solution
            of LP relaxation */
         x = glp_get_col_prim(mip, j);
         /* since the value of j-th column is fractional, the column is
            basic; compute corresponding row of the simplex table */
         len = glp_eval_tab_row(mip, m+j, ind, val);
         /* the following fragment computes a change in the objective
            function: delta Z = new Z - old Z, where old Z is the
            objective value in the current optimal basis, and new Z is
            the objective value in the adjacent basis, for two cases:
            1) if new upper bound ub' = floor(x[j]) is introduced for
               j-th column (down branch);
            2) if new lower bound lb' = ceil(x[j]) is introduced for
               j-th column (up branch);
            since in both cases the solution remaining dual feasible
            becomes primal infeasible, one implicit simplex iteration
            is performed to determine the change delta Z;
            it is obvious that new Z, which is never better than old Z,
            is a lower (minimization) or upper (maximization) bound of
            the objective function for down- and up-branches. */
         for (kase = -1; kase <= +1; kase += 2)
         {  /* if kase < 0, the new upper bound of x[j] is introduced;
               in this case x[j] should decrease in order to leave the
               basis and go to its new upper bound */
            /* if kase > 0, the new lower bound of x[j] is introduced;
               in this case x[j] should increase in order to leave the
               basis and go to its new lower bound */
            /* apply the dual ratio test in order to determine which
               auxiliary or structural variable should enter the basis
               to keep dual feasibility */
            k = glp_dual_rtest(mip, len, ind, val, kase, 1e-9);
            if (k != 0) k = ind[k];
            /* if no non-basic variable has been chosen, LP relaxation
               of corresponding branch being primal infeasible and dual
               unbounded has no primal feasible solution; in this case
               the change delta Z is formally set to infinity */
            if (k == 0)
            {  delta_z =
                  (T->mip->dir == GLP_MIN ? +DBL_MAX : -DBL_MAX);
               goto skip;
            }
            /* row of the simplex table that corresponds to non-basic
               variable x[k] choosen by the dual ratio test is:
                  x[j] = ... + alfa * x[k] + ...
               where alfa is the influence coefficient (an element of
               the simplex table row) */
            /* determine the coefficient alfa */
            for (t = 1; t <= len; t++) if (ind[t] == k) break;
            xassert(1 <= t && t <= len);
            alfa = val[t];
            /* since in the adjacent basis the variable x[j] becomes
               non-basic, knowing its value in the current basis we can
               determine its change delta x[j] = new x[j] - old x[j] */
            delta_j = (kase < 0 ? floor(x) : ceil(x)) - x;
            /* and knowing the coefficient alfa we can determine the
               corresponding change delta x[k] = new x[k] - old x[k],
               where old x[k] is a value of x[k] in the current basis,
               and new x[k] is a value of x[k] in the adjacent basis */
            delta_k = delta_j / alfa;
            /* Tomlin noticed that if the variable x[k] is of integer
               kind, its change cannot be less (eventually) than one in
               the magnitude */
            if (k > m && glp_get_col_kind(mip, k-m) != GLP_CV)
            {  /* x[k] is structural integer variable */
               if (fabs(delta_k - floor(delta_k + 0.5)) > 1e-3)
               {  if (delta_k > 0.0)
                     delta_k = ceil(delta_k);  /* +3.14 -> +4 */
                  else
                     delta_k = floor(delta_k); /* -3.14 -> -4 */
               }
            }
            /* now determine the status and reduced cost of x[k] in the
               current basis */
            if (k <= m)
            {  stat = glp_get_row_stat(mip, k);
               dk = glp_get_row_dual(mip, k);
            }
            else
            {  stat = glp_get_col_stat(mip, k-m);
               dk = glp_get_col_dual(mip, k-m);
            }
            /* if the current basis is dual degenerate, some reduced
               costs which are close to zero may have wrong sign due to
               round-off errors, so correct the sign of d[k] */
            switch (T->mip->dir)
            {  case GLP_MIN:
                  if (stat == GLP_NL && dk < 0.0 ||
                      stat == GLP_NU && dk > 0.0 ||
                      stat == GLP_NF) dk = 0.0;
                  break;
               case GLP_MAX:
                  if (stat == GLP_NL && dk > 0.0 ||
                      stat == GLP_NU && dk < 0.0 ||
                      stat == GLP_NF) dk = 0.0;
                  break;
               default:
                  xassert(T != T);
            }
            /* now knowing the change of x[k] and its reduced cost d[k]
               we can compute the corresponding change in the objective
               function delta Z = new Z - old Z = d[k] * delta x[k];
               note that due to Tomlin's modification new Z can be even
               worse than in the adjacent basis */
            delta_z = dk * delta_k;
skip:       /* new Z is never better than old Z, therefore the change
               delta Z is always non-negative (in case of minimization)
               or non-positive (in case of maximization) */
            switch (T->mip->dir)
            {  case GLP_MIN: xassert(delta_z >= 0.0); break;
               case GLP_MAX: xassert(delta_z <= 0.0); break;
               default: xassert(T != T);
            }
            /* save the change in the objective fnction for down- and
               up-branches, respectively */
            if (kase < 0) dz_dn = delta_z; else dz_up = delta_z;
         }
         /* thus, in down-branch no integer feasible solution can be
            better than Z + dz_dn, and in up-branch no integer feasible
            solution can be better than Z + dz_up, where Z is value of
            the objective function in the current basis */
         /* following the heuristic by Driebeck and Tomlin we choose a
            column (i.e. structural variable) which provides largest
            degradation of the objective function in some of branches;
            besides, we select the branch with smaller degradation to
            be solved next and keep other branch with larger degradation
            in the active list hoping to minimize the number of further
            backtrackings */
         if (degrad < fabs(dz_dn) || degrad < fabs(dz_up))
         {  jj = j;
            if (fabs(dz_dn) < fabs(dz_up))
            {  /* select down branch to be solved next */
               next = GLP_DN_BRNCH;
               degrad = fabs(dz_up);
            }
            else
            {  /* select up branch to be solved next */
               next = GLP_UP_BRNCH;
               degrad = fabs(dz_dn);
            }
            /* save the objective changes for printing */
            dd_dn = dz_dn, dd_up = dz_up;
            /* if down- or up-branch has no feasible solution, we does
               not need to consider other candidates (in principle, the
               corresponding branch could be pruned right now) */
            if (degrad == DBL_MAX) break;
         }
      }
      /* free working arrays */
      xfree(ind);
      xfree(val);
      /* something must be chosen */
      xassert(1 <= jj && jj <= n);
#if 1 /* 02/XI-2009 */
      if (degrad < 1e-6 * (1.0 + 0.001 * fabs(mip->obj_val)))
      {  jj = branch_mostf(T, &next);
         goto done;
      }
#endif
      if (T->parm->msg_lev >= GLP_MSG_DBG)
      {  xprintf("branch_drtom: column %d chosen to branch on\n", jj);
         if (fabs(dd_dn) == DBL_MAX)
            xprintf("branch_drtom: down-branch is infeasible\n");
         else
            xprintf("branch_drtom: down-branch bound is %.9e\n",
               glp_get_obj_val(mip) + dd_dn);
         if (fabs(dd_up) == DBL_MAX)
            xprintf("branch_drtom: up-branch   is infeasible\n");
         else
            xprintf("branch_drtom: up-branch   bound is %.9e\n",
               glp_get_obj_val(mip) + dd_up);
      }
done: *_next = next;
      return jj;
}

/**********************************************************************/

struct csa
{     /* common storage area */
      int *dn_cnt; /* int dn_cnt[1+n]; */
      /* dn_cnt[j] is the number of subproblems, whose LP relaxations
         have been solved and which are down-branches for variable x[j];
         dn_cnt[j] = 0 means the down pseudocost is uninitialized */
      double *dn_sum; /* double dn_sum[1+n]; */
      /* dn_sum[j] is the sum of per unit degradations of the objective
         over all dn_cnt[j] subproblems */
      int *up_cnt; /* int up_cnt[1+n]; */
      /* up_cnt[j] is the number of subproblems, whose LP relaxations
         have been solved and which are up-branches for variable x[j];
         up_cnt[j] = 0 means the up pseudocost is uninitialized */
      double *up_sum; /* double up_sum[1+n]; */
      /* up_sum[j] is the sum of per unit degradations of the objective
         over all up_cnt[j] subproblems */
};

void *ios_pcost_init(glp_tree *tree)
{     /* initialize working data used on pseudocost branching */
      struct csa *csa;
      int n = tree->n, j;
      csa = xmalloc(sizeof(struct csa));
      csa->dn_cnt = xcalloc(1+n, sizeof(int));
      csa->dn_sum = xcalloc(1+n, sizeof(double));
      csa->up_cnt = xcalloc(1+n, sizeof(int));
      csa->up_sum = xcalloc(1+n, sizeof(double));
      for (j = 1; j <= n; j++)
      {  csa->dn_cnt[j] = csa->up_cnt[j] = 0;
         csa->dn_sum[j] = csa->up_sum[j] = 0.0;
      }
      return csa;
}

static double eval_degrad(glp_prob *P, int j, double bnd)
{     /* compute degradation of the objective on fixing x[j] at given
         value with a limited number of dual simplex iterations */
      /* this routine fixes column x[j] at specified value bnd,
         solves resulting LP, and returns a lower bound to degradation
         of the objective, degrad >= 0 */
      glp_prob *lp;
      glp_smcp parm;
      int ret;
      double degrad;
      /* the current basis must be optimal */
      xassert(glp_get_status(P) == GLP_OPT);
      /* create a copy of P */
      lp = glp_create_prob();
      glp_copy_prob(lp, P, 0);
      /* fix column x[j] at specified value */
      glp_set_col_bnds(lp, j, GLP_FX, bnd, bnd);
      /* try to solve resulting LP */
      glp_init_smcp(&parm);
      parm.msg_lev = GLP_MSG_OFF;
      parm.meth = GLP_DUAL;
      parm.it_lim = 30;
      parm.out_dly = 1000;
      parm.meth = GLP_DUAL;
      ret = glp_simplex(lp, &parm);
      if (ret == 0 || ret == GLP_EITLIM)
      {  if (glp_get_prim_stat(lp) == GLP_NOFEAS)
         {  /* resulting LP has no primal feasible solution */
            degrad = DBL_MAX;
         }
         else if (glp_get_dual_stat(lp) == GLP_FEAS)
         {  /* resulting basis is optimal or at least dual feasible,
               so we have the correct lower bound to degradation */
            if (P->dir == GLP_MIN)
               degrad = lp->obj_val - P->obj_val;
            else if (P->dir == GLP_MAX)
               degrad = P->obj_val - lp->obj_val;
            else
               xassert(P != P);
            /* degradation cannot be negative by definition */
            /* note that the lower bound to degradation may be close
               to zero even if its exact value is zero due to round-off
               errors on computing the objective value */
            if (degrad < 1e-6 * (1.0 + 0.001 * fabs(P->obj_val)))
               degrad = 0.0;
         }
         else
         {  /* the final basis reported by the simplex solver is dual
               infeasible, so we cannot determine a non-trivial lower
               bound to degradation */
            degrad = 0.0;
         }
      }
      else
      {  /* the simplex solver failed */
         degrad = 0.0;
      }
      /* delete the copy of P */
      glp_delete_prob(lp);
      return degrad;
}

void ios_pcost_update(glp_tree *tree)
{     /* update history information for pseudocost branching */
      /* this routine is called every time when LP relaxation of the
         current subproblem has been solved to optimality with all lazy
         and cutting plane constraints included */
      int j;
      double dx, dz, psi;
      struct csa *csa = tree->pcost;
      xassert(csa != NULL);
      xassert(tree->curr != NULL);
      /* if the current subproblem is the root, skip updating */
      if (tree->curr->up == NULL) goto skip;
      /* determine branching variable x[j], which was used in the
         parent subproblem to create the current subproblem */
      j = tree->curr->up->br_var;
      xassert(1 <= j && j <= tree->n);
      /* determine the change dx[j] = new x[j] - old x[j],
         where new x[j] is a value of x[j] in optimal solution to LP
         relaxation of the current subproblem, old x[j] is a value of
         x[j] in optimal solution to LP relaxation of the parent
         subproblem */
      dx = tree->mip->col[j]->prim - tree->curr->up->br_val;
      xassert(dx != 0.0);
      /* determine corresponding change dz = new dz - old dz in the
         objective function value */
      dz = tree->mip->obj_val - tree->curr->up->lp_obj;
      /* determine per unit degradation of the objective function */
      psi = fabs(dz / dx);
      /* update history information */
      if (dx < 0.0)
      {  /* the current subproblem is down-branch */
         csa->dn_cnt[j]++;
         csa->dn_sum[j] += psi;
      }
      else /* dx > 0.0 */
      {  /* the current subproblem is up-branch */
         csa->up_cnt[j]++;
         csa->up_sum[j] += psi;
      }
skip: return;
}

void ios_pcost_free(glp_tree *tree)
{     /* free working area used on pseudocost branching */
      struct csa *csa = tree->pcost;
      xassert(csa != NULL);
      xfree(csa->dn_cnt);
      xfree(csa->dn_sum);
      xfree(csa->up_cnt);
      xfree(csa->up_sum);
      xfree(csa);
      tree->pcost = NULL;
      return;
}

static double eval_psi(glp_tree *T, int j, int brnch)
{     /* compute estimation of pseudocost of variable x[j] for down-
         or up-branch */
      struct csa *csa = T->pcost;
      double beta, degrad, psi;
      xassert(csa != NULL);
      xassert(1 <= j && j <= T->n);
      if (brnch == GLP_DN_BRNCH)
      {  /* down-branch */
         if (csa->dn_cnt[j] == 0)
         {  /* initialize down pseudocost */
            beta = T->mip->col[j]->prim;
            degrad = eval_degrad(T->mip, j, floor(beta));
            if (degrad == DBL_MAX)
            {  psi = DBL_MAX;
               goto done;
            }
            csa->dn_cnt[j] = 1;
            csa->dn_sum[j] = degrad / (beta - floor(beta));
         }
         psi = csa->dn_sum[j] / (double)csa->dn_cnt[j];
      }
      else if (brnch == GLP_UP_BRNCH)
      {  /* up-branch */
         if (csa->up_cnt[j] == 0)
         {  /* initialize up pseudocost */
            beta = T->mip->col[j]->prim;
            degrad = eval_degrad(T->mip, j, ceil(beta));
            if (degrad == DBL_MAX)
            {  psi = DBL_MAX;
               goto done;
            }
            csa->up_cnt[j] = 1;
            csa->up_sum[j] = degrad / (ceil(beta) - beta);
         }
         psi = csa->up_sum[j] / (double)csa->up_cnt[j];
      }
      else
         xassert(brnch != brnch);
done: return psi;
}

static void progress(glp_tree *T)
{     /* display progress of pseudocost initialization */
      struct csa *csa = T->pcost;
      int j, nv = 0, ni = 0;
      for (j = 1; j <= T->n; j++)
      {  if (glp_ios_can_branch(T, j))
         {  nv++;
            if (csa->dn_cnt[j] > 0 && csa->up_cnt[j] > 0) ni++;
         }
      }
      xprintf("Pseudocosts initialized for %d of %d variables\n",
         ni, nv);
      return;
}

int ios_pcost_branch(glp_tree *T, int *_next)
{     /* choose branching variable with pseudocost branching */
#if 0 /* 10/VI-2013 */
      glp_long t = xtime();
#else
      double t = xtime();
#endif
      int j, jjj, sel;
      double beta, psi, d1, d2, d, dmax;
      /* initialize the working arrays */
      if (T->pcost == NULL)
         T->pcost = ios_pcost_init(T);
      /* nothing has been chosen so far */
      jjj = 0, dmax = -1.0;
      /* go through the list of branching candidates */
      for (j = 1; j <= T->n; j++)
      {  if (!glp_ios_can_branch(T, j)) continue;
         /* determine primal value of x[j] in optimal solution to LP
            relaxation of the current subproblem */
         beta = T->mip->col[j]->prim;
         /* estimate pseudocost of x[j] for down-branch */
         psi = eval_psi(T, j, GLP_DN_BRNCH);
         if (psi == DBL_MAX)
         {  /* down-branch has no primal feasible solution */
            jjj = j, sel = GLP_DN_BRNCH;
            goto done;
         }
         /* estimate degradation of the objective for down-branch */
         d1 = psi * (beta - floor(beta));
         /* estimate pseudocost of x[j] for up-branch */
         psi = eval_psi(T, j, GLP_UP_BRNCH);
         if (psi == DBL_MAX)
         {  /* up-branch has no primal feasible solution */
            jjj = j, sel = GLP_UP_BRNCH;
            goto done;
         }
         /* estimate degradation of the objective for up-branch */
         d2 = psi * (ceil(beta) - beta);
         /* determine d = max(d1, d2) */
         d = (d1 > d2 ? d1 : d2);
         /* choose x[j] which provides maximal estimated degradation of
            the objective either in down- or up-branch */
         if (dmax < d)
         {  dmax = d;
            jjj = j;
            /* continue the search from a subproblem, where degradation
               is less than in other one */
            sel = (d1 <= d2 ? GLP_DN_BRNCH : GLP_UP_BRNCH);
         }
         /* display progress of pseudocost initialization */
         if (T->parm->msg_lev >= GLP_ON)
         {  if (xdifftime(xtime(), t) >= 10.0)
            {  progress(T);
               t = xtime();
            }
         }
      }
      if (dmax == 0.0)
      {  /* no degradation is indicated; choose a variable having most
            fractional value */
         jjj = branch_mostf(T, &sel);
      }
done: *_next = sel;
      return jjj;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios11.c0000644000175100001710000004017300000000000025014 0ustar00runnerdocker00000000000000/* glpios11.c (process cuts stored in the local cut pool) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2005-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "draft.h"
#include "env.h"
#include "ios.h"

/***********************************************************************
*  NAME
*
*  ios_process_cuts - process cuts stored in the local cut pool
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_process_cuts(glp_tree *T);
*
*  DESCRIPTION
*
*  The routine ios_process_cuts analyzes each cut currently stored in
*  the local cut pool, which must be non-empty, and either adds the cut
*  to the current subproblem or just discards it. All cuts are assumed
*  to be locally valid. On exit the local cut pool remains unchanged.
*
*  REFERENCES
*
*  1. E.Balas, S.Ceria, G.Cornuejols, "Mixed 0-1 Programming by
*     Lift-and-Project in a Branch-and-Cut Framework", Management Sc.,
*     42 (1996) 1229-1246.
*
*  2. G.Andreello, A.Caprara, and M.Fischetti, "Embedding Cuts in
*     a Branch&Cut Framework: a Computational Study with {0,1/2}-Cuts",
*     Preliminary Draft, October 28, 2003, pp.6-8. */

struct info
{     /* estimated cut efficiency */
      IOSCUT *cut;
      /* pointer to cut in the cut pool */
      char flag;
      /* if this flag is set, the cut is included into the current
         subproblem */
      double eff;
      /* cut efficacy (normalized residual) */
      double deg;
      /* lower bound to objective degradation */
};

static int CDECL fcmp(const void *arg1, const void *arg2)
{     const struct info *info1 = arg1, *info2 = arg2;
      if (info1->deg == 0.0 && info2->deg == 0.0)
      {  if (info1->eff > info2->eff) return -1;
         if (info1->eff < info2->eff) return +1;
      }
      else
      {  if (info1->deg > info2->deg) return -1;
         if (info1->deg < info2->deg) return +1;
      }
      return 0;
}

static double parallel(IOSCUT *a, IOSCUT *b, double work[]);

#ifdef NEW_LOCAL /* 02/II-2018 */
void ios_process_cuts(glp_tree *T)
{     IOSPOOL *pool;
      IOSCUT *cut;
      GLPAIJ *aij;
      struct info *info;
      int k, kk, max_cuts, len, ret, *ind;
      double *val, *work, rhs;
      /* the current subproblem must exist */
      xassert(T->curr != NULL);
      /* the pool must exist and be non-empty */
      pool = T->local;
      xassert(pool != NULL);
      xassert(pool->m > 0);
      /* allocate working arrays */
      info = xcalloc(1+pool->m, sizeof(struct info));
      ind = xcalloc(1+T->n, sizeof(int));
      val = xcalloc(1+T->n, sizeof(double));
      work = xcalloc(1+T->n, sizeof(double));
      for (k = 1; k <= T->n; k++) work[k] = 0.0;
      /* build the list of cuts stored in the cut pool */
      for (k = 1; k <= pool->m; k++)
         info[k].cut = pool->row[k], info[k].flag = 0;
      /* estimate efficiency of all cuts in the cut pool */
      for (k = 1; k <= pool->m; k++)
      {  double temp, dy, dz;
         cut = info[k].cut;
         /* build the vector of cut coefficients and compute its
            Euclidean norm */
         len = 0; temp = 0.0;
         for (aij = cut->ptr; aij != NULL; aij = aij->r_next)
         {  xassert(1 <= aij->col->j && aij->col->j <= T->n);
            len++, ind[len] = aij->col->j, val[len] = aij->val;
            temp += aij->val * aij->val;
         }
         if (temp < DBL_EPSILON * DBL_EPSILON) temp = DBL_EPSILON;
         /* transform the cut to express it only through non-basic
            (auxiliary and structural) variables */
         len = glp_transform_row(T->mip, len, ind, val);
         /* determine change in the cut value and in the objective
            value for the adjacent basis by simulating one step of the
            dual simplex */
         switch (cut->type)
         {  case GLP_LO: rhs = cut->lb; break;
            case GLP_UP: rhs = cut->ub; break;
            default: xassert(cut != cut);
         }
         ret = _glp_analyze_row(T->mip, len, ind, val, cut->type,
            rhs, 1e-9, NULL, NULL, NULL, NULL, &dy, &dz);
         /* determine normalized residual and lower bound to objective
            degradation */
         if (ret == 0)
         {  info[k].eff = fabs(dy) / sqrt(temp);
            /* if some reduced costs violates (slightly) their zero
               bounds (i.e. have wrong signs) due to round-off errors,
               dz also may have wrong sign being close to zero */
            if (T->mip->dir == GLP_MIN)
            {  if (dz < 0.0) dz = 0.0;
               info[k].deg = + dz;
            }
            else /* GLP_MAX */
            {  if (dz > 0.0) dz = 0.0;
               info[k].deg = - dz;
            }
         }
         else if (ret == 1)
         {  /* the constraint is not violated at the current point */
            info[k].eff = info[k].deg = 0.0;
         }
         else if (ret == 2)
         {  /* no dual feasible adjacent basis exists */
            info[k].eff = 1.0;
            info[k].deg = DBL_MAX;
         }
         else
            xassert(ret != ret);
         /* if the degradation is too small, just ignore it */
         if (info[k].deg < 0.01) info[k].deg = 0.0;
      }
      /* sort the list of cuts by decreasing objective degradation and
         then by decreasing efficacy */
      qsort(&info[1], pool->m, sizeof(struct info), fcmp);
      /* only first (most efficient) max_cuts in the list are qualified
         as candidates to be added to the current subproblem */
      max_cuts = (T->curr->level == 0 ? 90 : 10);
      if (max_cuts > pool->m) max_cuts = pool->m;
      /* add cuts to the current subproblem */
#if 0
      xprintf("*** adding cuts ***\n");
#endif
      for (k = 1; k <= max_cuts; k++)
      {  int i, len;
         /* if this cut seems to be inefficient, skip it */
         if (info[k].deg < 0.01 && info[k].eff < 0.01) continue;
         /* if the angle between this cut and every other cut included
            in the current subproblem is small, skip this cut */
         for (kk = 1; kk < k; kk++)
         {  if (info[kk].flag)
            {  if (parallel(info[k].cut, info[kk].cut, work) > 0.90)
                  break;
            }
         }
         if (kk < k) continue;
         /* add this cut to the current subproblem */
#if 0
         xprintf("eff = %g; deg = %g\n", info[k].eff, info[k].deg);
#endif
         cut = info[k].cut, info[k].flag = 1;
         i = glp_add_rows(T->mip, 1);
         if (cut->name != NULL)
            glp_set_row_name(T->mip, i, cut->name);
         xassert(T->mip->row[i]->origin == GLP_RF_CUT);
         T->mip->row[i]->klass = cut->klass;
         len = 0;
         for (aij = cut->ptr; aij != NULL; aij = aij->r_next)
            len++, ind[len] = aij->col->j, val[len] = aij->val;
         glp_set_mat_row(T->mip, i, len, ind, val);
         switch (cut->type)
         {  case GLP_LO: rhs = cut->lb; break;
            case GLP_UP: rhs = cut->ub; break;
            default: xassert(cut != cut);
         }
         glp_set_row_bnds(T->mip, i, cut->type, rhs, rhs);
      }
      /* free working arrays */
      xfree(info);
      xfree(ind);
      xfree(val);
      xfree(work);
      return;
}
#else
void ios_process_cuts(glp_tree *T)
{     IOSPOOL *pool;
      IOSCUT *cut;
      IOSAIJ *aij;
      struct info *info;
      int k, kk, max_cuts, len, ret, *ind;
      double *val, *work;
      /* the current subproblem must exist */
      xassert(T->curr != NULL);
      /* the pool must exist and be non-empty */
      pool = T->local;
      xassert(pool != NULL);
      xassert(pool->size > 0);
      /* allocate working arrays */
      info = xcalloc(1+pool->size, sizeof(struct info));
      ind = xcalloc(1+T->n, sizeof(int));
      val = xcalloc(1+T->n, sizeof(double));
      work = xcalloc(1+T->n, sizeof(double));
      for (k = 1; k <= T->n; k++) work[k] = 0.0;
      /* build the list of cuts stored in the cut pool */
      for (k = 0, cut = pool->head; cut != NULL; cut = cut->next)
         k++, info[k].cut = cut, info[k].flag = 0;
      xassert(k == pool->size);
      /* estimate efficiency of all cuts in the cut pool */
      for (k = 1; k <= pool->size; k++)
      {  double temp, dy, dz;
         cut = info[k].cut;
         /* build the vector of cut coefficients and compute its
            Euclidean norm */
         len = 0; temp = 0.0;
         for (aij = cut->ptr; aij != NULL; aij = aij->next)
         {  xassert(1 <= aij->j && aij->j <= T->n);
            len++, ind[len] = aij->j, val[len] = aij->val;
            temp += aij->val * aij->val;
         }
         if (temp < DBL_EPSILON * DBL_EPSILON) temp = DBL_EPSILON;
         /* transform the cut to express it only through non-basic
            (auxiliary and structural) variables */
         len = glp_transform_row(T->mip, len, ind, val);
         /* determine change in the cut value and in the objective
            value for the adjacent basis by simulating one step of the
            dual simplex */
         ret = _glp_analyze_row(T->mip, len, ind, val, cut->type,
            cut->rhs, 1e-9, NULL, NULL, NULL, NULL, &dy, &dz);
         /* determine normalized residual and lower bound to objective
            degradation */
         if (ret == 0)
         {  info[k].eff = fabs(dy) / sqrt(temp);
            /* if some reduced costs violates (slightly) their zero
               bounds (i.e. have wrong signs) due to round-off errors,
               dz also may have wrong sign being close to zero */
            if (T->mip->dir == GLP_MIN)
            {  if (dz < 0.0) dz = 0.0;
               info[k].deg = + dz;
            }
            else /* GLP_MAX */
            {  if (dz > 0.0) dz = 0.0;
               info[k].deg = - dz;
            }
         }
         else if (ret == 1)
         {  /* the constraint is not violated at the current point */
            info[k].eff = info[k].deg = 0.0;
         }
         else if (ret == 2)
         {  /* no dual feasible adjacent basis exists */
            info[k].eff = 1.0;
            info[k].deg = DBL_MAX;
         }
         else
            xassert(ret != ret);
         /* if the degradation is too small, just ignore it */
         if (info[k].deg < 0.01) info[k].deg = 0.0;
      }
      /* sort the list of cuts by decreasing objective degradation and
         then by decreasing efficacy */
      qsort(&info[1], pool->size, sizeof(struct info), fcmp);
      /* only first (most efficient) max_cuts in the list are qualified
         as candidates to be added to the current subproblem */
      max_cuts = (T->curr->level == 0 ? 90 : 10);
      if (max_cuts > pool->size) max_cuts = pool->size;
      /* add cuts to the current subproblem */
#if 0
      xprintf("*** adding cuts ***\n");
#endif
      for (k = 1; k <= max_cuts; k++)
      {  int i, len;
         /* if this cut seems to be inefficient, skip it */
         if (info[k].deg < 0.01 && info[k].eff < 0.01) continue;
         /* if the angle between this cut and every other cut included
            in the current subproblem is small, skip this cut */
         for (kk = 1; kk < k; kk++)
         {  if (info[kk].flag)
            {  if (parallel(info[k].cut, info[kk].cut, work) > 0.90)
                  break;
            }
         }
         if (kk < k) continue;
         /* add this cut to the current subproblem */
#if 0
         xprintf("eff = %g; deg = %g\n", info[k].eff, info[k].deg);
#endif
         cut = info[k].cut, info[k].flag = 1;
         i = glp_add_rows(T->mip, 1);
         if (cut->name != NULL)
            glp_set_row_name(T->mip, i, cut->name);
         xassert(T->mip->row[i]->origin == GLP_RF_CUT);
         T->mip->row[i]->klass = cut->klass;
         len = 0;
         for (aij = cut->ptr; aij != NULL; aij = aij->next)
            len++, ind[len] = aij->j, val[len] = aij->val;
         glp_set_mat_row(T->mip, i, len, ind, val);
         xassert(cut->type == GLP_LO || cut->type == GLP_UP);
         glp_set_row_bnds(T->mip, i, cut->type, cut->rhs, cut->rhs);
      }
      /* free working arrays */
      xfree(info);
      xfree(ind);
      xfree(val);
      xfree(work);
      return;
}
#endif

#if 0
/***********************************************************************
*  Given a cut a * x >= b (<= b) the routine efficacy computes the cut
*  efficacy as follows:
*
*     eff = d * (a * x~ - b) / ||a||,
*
*  where d is -1 (in case of '>= b') or +1 (in case of '<= b'), x~ is
*  the vector of values of structural variables in optimal solution to
*  LP relaxation of the current subproblem, ||a|| is the Euclidean norm
*  of the vector of cut coefficients.
*
*  If the cut is violated at point x~, the efficacy eff is positive,
*  and its value is the Euclidean distance between x~ and the cut plane
*  a * x = b in the space of structural variables.
*
*  Following geometrical intuition, it is quite natural to consider
*  this distance as a first-order measure of the expected efficacy of
*  the cut: the larger the distance the better the cut [1]. */

static double efficacy(glp_tree *T, IOSCUT *cut)
{     glp_prob *mip = T->mip;
      IOSAIJ *aij;
      double s = 0.0, t = 0.0, temp;
      for (aij = cut->ptr; aij != NULL; aij = aij->next)
      {  xassert(1 <= aij->j && aij->j <= mip->n);
         s += aij->val * mip->col[aij->j]->prim;
         t += aij->val * aij->val;
      }
      temp = sqrt(t);
      if (temp < DBL_EPSILON) temp = DBL_EPSILON;
      if (cut->type == GLP_LO)
         temp = (s >= cut->rhs ? 0.0 : (cut->rhs - s) / temp);
      else if (cut->type == GLP_UP)
         temp = (s <= cut->rhs ? 0.0 : (s - cut->rhs) / temp);
      else
         xassert(cut != cut);
      return temp;
}
#endif

/***********************************************************************
*  Given two cuts a1 * x >= b1 (<= b1) and a2 * x >= b2 (<= b2) the
*  routine parallel computes the cosine of angle between the cut planes
*  a1 * x = b1 and a2 * x = b2 (which is the acute angle between two
*  normals to these planes) in the space of structural variables as
*  follows:
*
*     cos phi = (a1' * a2) / (||a1|| * ||a2||),
*
*  where (a1' * a2) is a dot product of vectors of cut coefficients,
*  ||a1|| and ||a2|| are Euclidean norms of vectors a1 and a2.
*
*  Note that requirement cos phi = 0 forces the cuts to be orthogonal,
*  i.e. with disjoint support, while requirement cos phi <= 0.999 means
*  only avoiding duplicate (parallel) cuts [1]. */

#ifdef NEW_LOCAL /* 02/II-2018 */
static double parallel(IOSCUT *a, IOSCUT *b, double work[])
{     GLPAIJ *aij;
      double s = 0.0, sa = 0.0, sb = 0.0, temp;
      for (aij = a->ptr; aij != NULL; aij = aij->r_next)
      {  work[aij->col->j] = aij->val;
         sa += aij->val * aij->val;
      }
      for (aij = b->ptr; aij != NULL; aij = aij->r_next)
      {  s += work[aij->col->j] * aij->val;
         sb += aij->val * aij->val;
      }
      for (aij = a->ptr; aij != NULL; aij = aij->r_next)
         work[aij->col->j] = 0.0;
      temp = sqrt(sa) * sqrt(sb);
      if (temp < DBL_EPSILON * DBL_EPSILON) temp = DBL_EPSILON;
      return s / temp;
}
#else
static double parallel(IOSCUT *a, IOSCUT *b, double work[])
{     IOSAIJ *aij;
      double s = 0.0, sa = 0.0, sb = 0.0, temp;
      for (aij = a->ptr; aij != NULL; aij = aij->next)
      {  work[aij->j] = aij->val;
         sa += aij->val * aij->val;
      }
      for (aij = b->ptr; aij != NULL; aij = aij->next)
      {  s += work[aij->j] * aij->val;
         sb += aij->val * aij->val;
      }
      for (aij = a->ptr; aij != NULL; aij = aij->next)
         work[aij->j] = 0.0;
      temp = sqrt(sa) * sqrt(sb);
      if (temp < DBL_EPSILON * DBL_EPSILON) temp = DBL_EPSILON;
      return s / temp;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpios12.c0000644000175100001710000001307400000000000025015 0ustar00runnerdocker00000000000000/* glpios12.c (node selection heuristics) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"

/***********************************************************************
*  NAME
*
*  ios_choose_node - select subproblem to continue the search
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  int ios_choose_node(glp_tree *T);
*
*  DESCRIPTION
*
*  The routine ios_choose_node selects a subproblem from the active
*  list to continue the search. The choice depends on the backtracking
*  technique option.
*
*  RETURNS
*
*  The routine ios_choose_node return the reference number of the
*  subproblem selected. */

static int most_feas(glp_tree *T);
static int best_proj(glp_tree *T);
static int best_node(glp_tree *T);

int ios_choose_node(glp_tree *T)
{     int p;
      if (T->parm->bt_tech == GLP_BT_DFS)
      {  /* depth first search */
         xassert(T->tail != NULL);
         p = T->tail->p;
      }
      else if (T->parm->bt_tech == GLP_BT_BFS)
      {  /* breadth first search */
         xassert(T->head != NULL);
         p = T->head->p;
      }
      else if (T->parm->bt_tech == GLP_BT_BLB)
      {  /* select node with best local bound */
         p = best_node(T);
      }
      else if (T->parm->bt_tech == GLP_BT_BPH)
      {  if (T->mip->mip_stat == GLP_UNDEF)
         {  /* "most integer feasible" subproblem */
            p = most_feas(T);
         }
         else
         {  /* best projection heuristic */
            p = best_proj(T);
         }
      }
      else
         xassert(T != T);
      return p;
}

static int most_feas(glp_tree *T)
{     /* select subproblem whose parent has minimal sum of integer
         infeasibilities */
      IOSNPD *node;
      int p;
      double best;
      p = 0, best = DBL_MAX;
      for (node = T->head; node != NULL; node = node->next)
      {  xassert(node->up != NULL);
         if (best > node->up->ii_sum)
            p = node->p, best = node->up->ii_sum;
      }
      return p;
}

static int best_proj(glp_tree *T)
{     /* select subproblem using the best projection heuristic */
      IOSNPD *root, *node;
      int p;
      double best, deg, obj;
      /* the global bound must exist */
      xassert(T->mip->mip_stat == GLP_FEAS);
      /* obtain pointer to the root node, which must exist */
      root = T->slot[1].node;
      xassert(root != NULL);
      /* deg estimates degradation of the objective function per unit
         of the sum of integer infeasibilities */
      xassert(root->ii_sum > 0.0);
      deg = (T->mip->mip_obj - root->bound) / root->ii_sum;
      /* nothing has been selected so far */
      p = 0, best = DBL_MAX;
      /* walk through the list of active subproblems */
      for (node = T->head; node != NULL; node = node->next)
      {  xassert(node->up != NULL);
         /* obj estimates optimal objective value if the sum of integer
            infeasibilities were zero */
         obj = node->up->bound + deg * node->up->ii_sum;
         if (T->mip->dir == GLP_MAX) obj = - obj;
         /* select the subproblem which has the best estimated optimal
            objective value */
         if (best > obj) p = node->p, best = obj;
      }
      return p;
}

static int best_node(glp_tree *T)
{     /* select subproblem with best local bound */
      IOSNPD *node, *best = NULL;
      double bound, eps;
      switch (T->mip->dir)
      {  case GLP_MIN:
            bound = +DBL_MAX;
            for (node = T->head; node != NULL; node = node->next)
               if (bound > node->bound) bound = node->bound;
            xassert(bound != +DBL_MAX);
            eps = 1e-10 * (1.0 + fabs(bound));
            for (node = T->head; node != NULL; node = node->next)
            {  if (node->bound <= bound + eps)
               {  xassert(node->up != NULL);
                  if (best == NULL ||
#if 1
                  best->up->ii_sum > node->up->ii_sum) best = node;
#else
                  best->lp_obj > node->lp_obj) best = node;
#endif
               }
            }
            break;
         case GLP_MAX:
            bound = -DBL_MAX;
            for (node = T->head; node != NULL; node = node->next)
               if (bound < node->bound) bound = node->bound;
            xassert(bound != -DBL_MAX);
            eps = 1e-10 * (1.0 + fabs(bound));
            for (node = T->head; node != NULL; node = node->next)
            {  if (node->bound >= bound - eps)
               {  xassert(node->up != NULL);
                  if (best == NULL ||
#if 1
                  best->up->ii_sum > node->up->ii_sum) best = node;
#else
                  best->lp_obj < node->lp_obj) best = node;
#endif
               }
            }
            break;
         default:
            xassert(T != T);
      }
      xassert(best != NULL);
      return best->p;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpipm.c0000644000175100001710000011372600000000000024652 0ustar00runnerdocker00000000000000/* glpipm.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpipm.h"
#include "glpmat.h"

#define ITER_MAX 100
/* maximal number of iterations */

struct csa
{     /* common storage area */
      /*--------------------------------------------------------------*/
      /* LP data */
      int m;
      /* number of rows (equality constraints) */
      int n;
      /* number of columns (structural variables) */
      int *A_ptr; /* int A_ptr[1+m+1]; */
      int *A_ind; /* int A_ind[A_ptr[m+1]]; */
      double *A_val; /* double A_val[A_ptr[m+1]]; */
      /* mxn-matrix A in storage-by-rows format */
      double *b; /* double b[1+m]; */
      /* m-vector b of right-hand sides */
      double *c; /* double c[1+n]; */
      /* n-vector c of objective coefficients; c[0] is constant term of
         the objective function */
      /*--------------------------------------------------------------*/
      /* LP solution */
      double *x; /* double x[1+n]; */
      double *y; /* double y[1+m]; */
      double *z; /* double z[1+n]; */
      /* current point in primal-dual space; the best point on exit */
      /*--------------------------------------------------------------*/
      /* control parameters */
      const glp_iptcp *parm;
      /*--------------------------------------------------------------*/
      /* working arrays and variables */
      double *D; /* double D[1+n]; */
      /* diagonal nxn-matrix D = X*inv(Z), where X = diag(x[j]) and
         Z = diag(z[j]) */
      int *P; /* int P[1+m+m]; */
      /* permutation mxm-matrix P used to minimize fill-in in Cholesky
         factorization */
      int *S_ptr; /* int S_ptr[1+m+1]; */
      int *S_ind; /* int S_ind[S_ptr[m+1]]; */
      double *S_val; /* double S_val[S_ptr[m+1]]; */
      double *S_diag; /* double S_diag[1+m]; */
      /* symmetric mxm-matrix S = P*A*D*A'*P' whose upper triangular
         part without diagonal elements is stored in S_ptr, S_ind, and
         S_val in storage-by-rows format, diagonal elements are stored
         in S_diag */
      int *U_ptr; /* int U_ptr[1+m+1]; */
      int *U_ind; /* int U_ind[U_ptr[m+1]]; */
      double *U_val; /* double U_val[U_ptr[m+1]]; */
      double *U_diag; /* double U_diag[1+m]; */
      /* upper triangular mxm-matrix U defining Cholesky factorization
         S = U'*U; its non-diagonal elements are stored in U_ptr, U_ind,
         U_val in storage-by-rows format, diagonal elements are stored
         in U_diag */
      int iter;
      /* iteration number (0, 1, 2, ...); iter = 0 corresponds to the
         initial point */
      double obj;
      /* current value of the objective function */
      double rpi;
      /* relative primal infeasibility rpi = ||A*x-b||/(1+||b||) */
      double rdi;
      /* relative dual infeasibility rdi = ||A'*y+z-c||/(1+||c||) */
      double gap;
      /* primal-dual gap = |c'*x-b'*y|/(1+|c'*x|) which is a relative
         difference between primal and dual objective functions */
      double phi;
      /* merit function phi = ||A*x-b||/max(1,||b||) +
                            + ||A'*y+z-c||/max(1,||c||) +
                            + |c'*x-b'*y|/max(1,||b||,||c||) */
      double mu;
      /* duality measure mu = x'*z/n (used as barrier parameter) */
      double rmu;
      /* rmu = max(||A*x-b||,||A'*y+z-c||)/mu */
      double rmu0;
      /* the initial value of rmu on iteration 0 */
      double *phi_min; /* double phi_min[1+ITER_MAX]; */
      /* phi_min[k] = min(phi[k]), where phi[k] is the value of phi on
         k-th iteration, 0 <= k <= iter */
      int best_iter;
      /* iteration number, on which the value of phi reached its best
         (minimal) value */
      double *best_x; /* double best_x[1+n]; */
      double *best_y; /* double best_y[1+m]; */
      double *best_z; /* double best_z[1+n]; */
      /* best point (in the sense of the merit function phi) which has
         been reached on iteration iter_best */
      double best_obj;
      /* objective value at the best point */
      double *dx_aff; /* double dx_aff[1+n]; */
      double *dy_aff; /* double dy_aff[1+m]; */
      double *dz_aff; /* double dz_aff[1+n]; */
      /* affine scaling direction */
      double alfa_aff_p, alfa_aff_d;
      /* maximal primal and dual stepsizes in affine scaling direction,
         on which x and z are still non-negative */
      double mu_aff;
      /* duality measure mu_aff = x_aff'*z_aff/n in the boundary point
         x_aff' = x+alfa_aff_p*dx_aff, z_aff' = z+alfa_aff_d*dz_aff */
      double sigma;
      /* Mehrotra's heuristic parameter (0 <= sigma <= 1) */
      double *dx_cc; /* double dx_cc[1+n]; */
      double *dy_cc; /* double dy_cc[1+m]; */
      double *dz_cc; /* double dz_cc[1+n]; */
      /* centering corrector direction */
      double *dx; /* double dx[1+n]; */
      double *dy; /* double dy[1+m]; */
      double *dz; /* double dz[1+n]; */
      /* final combined direction dx = dx_aff+dx_cc, dy = dy_aff+dy_cc,
         dz = dz_aff+dz_cc */
      double alfa_max_p;
      double alfa_max_d;
      /* maximal primal and dual stepsizes in combined direction, on
         which x and z are still non-negative */
};

/***********************************************************************
*  initialize - allocate and initialize common storage area
*
*  This routine allocates and initializes the common storage area (CSA)
*  used by interior-point method routines. */

static void initialize(struct csa *csa)
{     int m = csa->m;
      int n = csa->n;
      int i;
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Matrix A has %d non-zeros\n", csa->A_ptr[m+1]-1);
      csa->D = xcalloc(1+n, sizeof(double));
      /* P := I */
      csa->P = xcalloc(1+m+m, sizeof(int));
      for (i = 1; i <= m; i++) csa->P[i] = csa->P[m+i] = i;
      /* S := A*A', symbolically */
      csa->S_ptr = xcalloc(1+m+1, sizeof(int));
      csa->S_ind = adat_symbolic(m, n, csa->P, csa->A_ptr, csa->A_ind,
         csa->S_ptr);
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Matrix S = A*A' has %d non-zeros (upper triangle)\n",
            csa->S_ptr[m+1]-1 + m);
      /* determine P using specified ordering algorithm */
      if (csa->parm->ord_alg == GLP_ORD_NONE)
      {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Original ordering is being used\n");
         for (i = 1; i <= m; i++)
            csa->P[i] = csa->P[m+i] = i;
      }
      else if (csa->parm->ord_alg == GLP_ORD_QMD)
      {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Minimum degree ordering (QMD)...\n");
         min_degree(m, csa->S_ptr, csa->S_ind, csa->P);
      }
      else if (csa->parm->ord_alg == GLP_ORD_AMD)
      {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Approximate minimum degree ordering (AMD)...\n");
         amd_order1(m, csa->S_ptr, csa->S_ind, csa->P);
      }
      else if (csa->parm->ord_alg == GLP_ORD_SYMAMD)
      {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Approximate minimum degree ordering (SYMAMD)...\n")
               ;
         symamd_ord(m, csa->S_ptr, csa->S_ind, csa->P);
      }
      else
         xassert(csa != csa);
      /* S := P*A*A'*P', symbolically */
      xfree(csa->S_ind);
      csa->S_ind = adat_symbolic(m, n, csa->P, csa->A_ptr, csa->A_ind,
         csa->S_ptr);
      csa->S_val = xcalloc(csa->S_ptr[m+1], sizeof(double));
      csa->S_diag = xcalloc(1+m, sizeof(double));
      /* compute Cholesky factorization S = U'*U, symbolically */
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Computing Cholesky factorization S = L*L'...\n");
      csa->U_ptr = xcalloc(1+m+1, sizeof(int));
      csa->U_ind = chol_symbolic(m, csa->S_ptr, csa->S_ind, csa->U_ptr);
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Matrix L has %d non-zeros\n", csa->U_ptr[m+1]-1 + m);
      csa->U_val = xcalloc(csa->U_ptr[m+1], sizeof(double));
      csa->U_diag = xcalloc(1+m, sizeof(double));
      csa->iter = 0;
      csa->obj = 0.0;
      csa->rpi = 0.0;
      csa->rdi = 0.0;
      csa->gap = 0.0;
      csa->phi = 0.0;
      csa->mu = 0.0;
      csa->rmu = 0.0;
      csa->rmu0 = 0.0;
      csa->phi_min = xcalloc(1+ITER_MAX, sizeof(double));
      csa->best_iter = 0;
      csa->best_x = xcalloc(1+n, sizeof(double));
      csa->best_y = xcalloc(1+m, sizeof(double));
      csa->best_z = xcalloc(1+n, sizeof(double));
      csa->best_obj = 0.0;
      csa->dx_aff = xcalloc(1+n, sizeof(double));
      csa->dy_aff = xcalloc(1+m, sizeof(double));
      csa->dz_aff = xcalloc(1+n, sizeof(double));
      csa->alfa_aff_p = 0.0;
      csa->alfa_aff_d = 0.0;
      csa->mu_aff = 0.0;
      csa->sigma = 0.0;
      csa->dx_cc = xcalloc(1+n, sizeof(double));
      csa->dy_cc = xcalloc(1+m, sizeof(double));
      csa->dz_cc = xcalloc(1+n, sizeof(double));
      csa->dx = csa->dx_aff;
      csa->dy = csa->dy_aff;
      csa->dz = csa->dz_aff;
      csa->alfa_max_p = 0.0;
      csa->alfa_max_d = 0.0;
      return;
}

/***********************************************************************
*  A_by_vec - compute y = A*x
*
*  This routine computes matrix-vector product y = A*x, where A is the
*  constraint matrix. */

static void A_by_vec(struct csa *csa, double x[], double y[])
{     /* compute y = A*x */
      int m = csa->m;
      int *A_ptr = csa->A_ptr;
      int *A_ind = csa->A_ind;
      double *A_val = csa->A_val;
      int i, t, beg, end;
      double temp;
      for (i = 1; i <= m; i++)
      {  temp = 0.0;
         beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++) temp += A_val[t] * x[A_ind[t]];
         y[i] = temp;
      }
      return;
}

/***********************************************************************
*  AT_by_vec - compute y = A'*x
*
*  This routine computes matrix-vector product y = A'*x, where A' is a
*  matrix transposed to the constraint matrix A. */

static void AT_by_vec(struct csa *csa, double x[], double y[])
{     /* compute y = A'*x, where A' is transposed to A */
      int m = csa->m;
      int n = csa->n;
      int *A_ptr = csa->A_ptr;
      int *A_ind = csa->A_ind;
      double *A_val = csa->A_val;
      int i, j, t, beg, end;
      double temp;
      for (j = 1; j <= n; j++) y[j] = 0.0;
      for (i = 1; i <= m; i++)
      {  temp = x[i];
         if (temp == 0.0) continue;
         beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++) y[A_ind[t]] += A_val[t] * temp;
      }
      return;
}

/***********************************************************************
*  decomp_NE - numeric factorization of matrix S = P*A*D*A'*P'
*
*  This routine implements numeric phase of Cholesky factorization of
*  the matrix S = P*A*D*A'*P', which is a permuted matrix of the normal
*  equation system. Matrix D is assumed to be already computed. */

static void decomp_NE(struct csa *csa)
{     adat_numeric(csa->m, csa->n, csa->P, csa->A_ptr, csa->A_ind,
         csa->A_val, csa->D, csa->S_ptr, csa->S_ind, csa->S_val,
         csa->S_diag);
      chol_numeric(csa->m, csa->S_ptr, csa->S_ind, csa->S_val,
         csa->S_diag, csa->U_ptr, csa->U_ind, csa->U_val, csa->U_diag);
      return;
}

/***********************************************************************
*  solve_NE - solve normal equation system
*
*  This routine solves the normal equation system:
*
*     A*D*A'*y = h.
*
*  It is assumed that the matrix A*D*A' has been previously factorized
*  by the routine decomp_NE.
*
*  On entry the array y contains the vector of right-hand sides h. On
*  exit this array contains the computed vector of unknowns y.
*
*  Once the vector y has been computed the routine checks for numeric
*  stability. If the residual vector:
*
*     r = A*D*A'*y - h
*
*  is relatively small, the routine returns zero, otherwise non-zero is
*  returned. */

static int solve_NE(struct csa *csa, double y[])
{     int m = csa->m;
      int n = csa->n;
      int *P = csa->P;
      int i, j, ret = 0;
      double *h, *r, *w;
      /* save vector of right-hand sides h */
      h = xcalloc(1+m, sizeof(double));
      for (i = 1; i <= m; i++) h[i] = y[i];
      /* solve normal equation system (A*D*A')*y = h */
      /* since S = P*A*D*A'*P' = U'*U, then A*D*A' = P'*U'*U*P, so we
         have inv(A*D*A') = P'*inv(U)*inv(U')*P */
      /* w := P*h */
      w = xcalloc(1+m, sizeof(double));
      for (i = 1; i <= m; i++) w[i] = y[P[i]];
      /* w := inv(U')*w */
      ut_solve(m, csa->U_ptr, csa->U_ind, csa->U_val, csa->U_diag, w);
      /* w := inv(U)*w */
      u_solve(m, csa->U_ptr, csa->U_ind, csa->U_val, csa->U_diag, w);
      /* y := P'*w */
      for (i = 1; i <= m; i++) y[i] = w[P[m+i]];
      xfree(w);
      /* compute residual vector r = A*D*A'*y - h */
      r = xcalloc(1+m, sizeof(double));
      /* w := A'*y */
      w = xcalloc(1+n, sizeof(double));
      AT_by_vec(csa, y, w);
      /* w := D*w */
      for (j = 1; j <= n; j++) w[j] *= csa->D[j];
      /* r := A*w */
      A_by_vec(csa, w, r);
      xfree(w);
      /* r := r - h */
      for (i = 1; i <= m; i++) r[i] -= h[i];
      /* check for numeric stability */
      for (i = 1; i <= m; i++)
      {  if (fabs(r[i]) / (1.0 + fabs(h[i])) > 1e-4)
         {  ret = 1;
            break;
         }
      }
      xfree(h);
      xfree(r);
      return ret;
}

/***********************************************************************
*  solve_NS - solve Newtonian system
*
*  This routine solves the Newtonian system:
*
*     A*dx               = p
*
*           A'*dy +   dz = q
*
*     Z*dx        + X*dz = r
*
*  where X = diag(x[j]), Z = diag(z[j]), by reducing it to the normal
*  equation system:
*
*     (A*inv(Z)*X*A')*dy = A*inv(Z)*(X*q-r)+p
*
*  (it is assumed that the matrix A*inv(Z)*X*A' has been factorized by
*  the routine decomp_NE).
*
*  Once vector dy has been computed the routine computes vectors dx and
*  dz as follows:
*
*     dx = inv(Z)*(X*(A'*dy-q)+r)
*
*     dz = inv(X)*(r-Z*dx)
*
*  The routine solve_NS returns the same code which was reported by the
*  routine solve_NE (see above). */

static int solve_NS(struct csa *csa, double p[], double q[], double r[],
      double dx[], double dy[], double dz[])
{     int m = csa->m;
      int n = csa->n;
      double *x = csa->x;
      double *z = csa->z;
      int i, j, ret;
      double *w = dx;
      /* compute the vector of right-hand sides A*inv(Z)*(X*q-r)+p for
         the normal equation system */
      for (j = 1; j <= n; j++)
         w[j] = (x[j] * q[j] - r[j]) / z[j];
      A_by_vec(csa, w, dy);
      for (i = 1; i <= m; i++) dy[i] += p[i];
      /* solve the normal equation system to compute vector dy */
      ret = solve_NE(csa, dy);
      /* compute vectors dx and dz */
      AT_by_vec(csa, dy, dx);
      for (j = 1; j <= n; j++)
      {  dx[j] = (x[j] * (dx[j] - q[j]) + r[j]) / z[j];
         dz[j] = (r[j] - z[j] * dx[j]) / x[j];
      }
      return ret;
}

/***********************************************************************
*  initial_point - choose initial point using Mehrotra's heuristic
*
*  This routine chooses a starting point using a heuristic proposed in
*  the paper:
*
*  S. Mehrotra. On the implementation of a primal-dual interior point
*  method. SIAM J. on Optim., 2(4), pp. 575-601, 1992.
*
*  The starting point x in the primal space is chosen as a solution of
*  the following least squares problem:
*
*     minimize    ||x||
*
*     subject to  A*x = b
*
*  which can be computed explicitly as follows:
*
*     x = A'*inv(A*A')*b
*
*  Similarly, the starting point (y, z) in the dual space is chosen as
*  a solution of the following least squares problem:
*
*     minimize    ||z||
*
*     subject to  A'*y + z = c
*
*  which can be computed explicitly as follows:
*
*     y = inv(A*A')*A*c
*
*     z = c - A'*y
*
*  However, some components of the vectors x and z may be non-positive
*  or close to zero, so the routine uses a Mehrotra's heuristic to find
*  a more appropriate starting point. */

static void initial_point(struct csa *csa)
{     int m = csa->m;
      int n = csa->n;
      double *b = csa->b;
      double *c = csa->c;
      double *x = csa->x;
      double *y = csa->y;
      double *z = csa->z;
      double *D = csa->D;
      int i, j;
      double dp, dd, ex, ez, xz;
      /* factorize A*A' */
      for (j = 1; j <= n; j++) D[j] = 1.0;
      decomp_NE(csa);
      /* x~ = A'*inv(A*A')*b */
      for (i = 1; i <= m; i++) y[i] = b[i];
      solve_NE(csa, y);
      AT_by_vec(csa, y, x);
      /* y~ = inv(A*A')*A*c */
      A_by_vec(csa, c, y);
      solve_NE(csa, y);
      /* z~ = c - A'*y~ */
      AT_by_vec(csa, y,z);
      for (j = 1; j <= n; j++) z[j] = c[j] - z[j];
      /* use Mehrotra's heuristic in order to choose more appropriate
         starting point with positive components of vectors x and z */
      dp = dd = 0.0;
      for (j = 1; j <= n; j++)
      {  if (dp < -1.5 * x[j]) dp = -1.5 * x[j];
         if (dd < -1.5 * z[j]) dd = -1.5 * z[j];
      }
      /* note that b = 0 involves x = 0, and c = 0 involves y = 0 and
         z = 0, so we need to be careful */
      if (dp == 0.0) dp = 1.5;
      if (dd == 0.0) dd = 1.5;
      ex = ez = xz = 0.0;
      for (j = 1; j <= n; j++)
      {  ex += (x[j] + dp);
         ez += (z[j] + dd);
         xz += (x[j] + dp) * (z[j] + dd);
      }
      dp += 0.5 * (xz / ez);
      dd += 0.5 * (xz / ex);
      for (j = 1; j <= n; j++)
      {  x[j] += dp;
         z[j] += dd;
         xassert(x[j] > 0.0 && z[j] > 0.0);
      }
      return;
}

/***********************************************************************
*  basic_info - perform basic computations at the current point
*
*  This routine computes the following quantities at the current point:
*
*  1) value of the objective function:
*
*     F = c'*x + c[0]
*
*  2) relative primal infeasibility:
*
*     rpi = ||A*x-b|| / (1+||b||)
*
*  3) relative dual infeasibility:
*
*     rdi = ||A'*y+z-c|| / (1+||c||)
*
*  4) primal-dual gap (relative difference between the primal and the
*     dual objective function values):
*
*     gap = |c'*x-b'*y| / (1+|c'*x|)
*
*  5) merit function:
*
*     phi = ||A*x-b|| / max(1,||b||) + ||A'*y+z-c|| / max(1,||c||) +
*
*         + |c'*x-b'*y| / max(1,||b||,||c||)
*
*  6) duality measure:
*
*     mu = x'*z / n
*
*  7) the ratio of infeasibility to mu:
*
*     rmu = max(||A*x-b||,||A'*y+z-c||) / mu
*
*  where ||*|| denotes euclidian norm, *' denotes transposition. */

static void basic_info(struct csa *csa)
{     int m = csa->m;
      int n = csa->n;
      double *b = csa->b;
      double *c = csa->c;
      double *x = csa->x;
      double *y = csa->y;
      double *z = csa->z;
      int i, j;
      double norm1, bnorm, norm2, cnorm, cx, by, *work, temp;
      /* compute value of the objective function */
      temp = c[0];
      for (j = 1; j <= n; j++) temp += c[j] * x[j];
      csa->obj = temp;
      /* norm1 = ||A*x-b|| */
      work = xcalloc(1+m, sizeof(double));
      A_by_vec(csa, x, work);
      norm1 = 0.0;
      for (i = 1; i <= m; i++)
         norm1 += (work[i] - b[i]) * (work[i] - b[i]);
      norm1 = sqrt(norm1);
      xfree(work);
      /* bnorm = ||b|| */
      bnorm = 0.0;
      for (i = 1; i <= m; i++) bnorm += b[i] * b[i];
      bnorm = sqrt(bnorm);
      /* compute relative primal infeasibility */
      csa->rpi = norm1 / (1.0 + bnorm);
      /* norm2 = ||A'*y+z-c|| */
      work = xcalloc(1+n, sizeof(double));
      AT_by_vec(csa, y, work);
      norm2 = 0.0;
      for (j = 1; j <= n; j++)
         norm2 += (work[j] + z[j] - c[j]) * (work[j] + z[j] - c[j]);
      norm2 = sqrt(norm2);
      xfree(work);
      /* cnorm = ||c|| */
      cnorm = 0.0;
      for (j = 1; j <= n; j++) cnorm += c[j] * c[j];
      cnorm = sqrt(cnorm);
      /* compute relative dual infeasibility */
      csa->rdi = norm2 / (1.0 + cnorm);
      /* by = b'*y */
      by = 0.0;
      for (i = 1; i <= m; i++) by += b[i] * y[i];
      /* cx = c'*x */
      cx = 0.0;
      for (j = 1; j <= n; j++) cx += c[j] * x[j];
      /* compute primal-dual gap */
      csa->gap = fabs(cx - by) / (1.0 + fabs(cx));
      /* compute merit function */
      csa->phi = 0.0;
      csa->phi += norm1 / (bnorm > 1.0 ? bnorm : 1.0);
      csa->phi += norm2 / (cnorm > 1.0 ? cnorm : 1.0);
      temp = 1.0;
      if (temp < bnorm) temp = bnorm;
      if (temp < cnorm) temp = cnorm;
      csa->phi += fabs(cx - by) / temp;
      /* compute duality measure */
      temp = 0.0;
      for (j = 1; j <= n; j++) temp += x[j] * z[j];
      csa->mu = temp / (double)n;
      /* compute the ratio of infeasibility to mu */
      csa->rmu = (norm1 > norm2 ? norm1 : norm2) / csa->mu;
      return;
}

/***********************************************************************
*  make_step - compute next point using Mehrotra's technique
*
*  This routine computes the next point using the predictor-corrector
*  technique proposed in the paper:
*
*  S. Mehrotra. On the implementation of a primal-dual interior point
*  method. SIAM J. on Optim., 2(4), pp. 575-601, 1992.
*
*  At first, the routine computes so called affine scaling (predictor)
*  direction (dx_aff,dy_aff,dz_aff) which is a solution of the system:
*
*     A*dx_aff                       = b - A*x
*
*               A'*dy_aff +   dz_aff = c - A'*y - z
*
*     Z*dx_aff            + X*dz_aff = - X*Z*e
*
*  where (x,y,z) is the current point, X = diag(x[j]), Z = diag(z[j]),
*  e = (1,...,1)'.
*
*  Then, the routine computes the centering parameter sigma, using the
*  following Mehrotra's heuristic:
*
*     alfa_aff_p = inf{0 <= alfa <= 1 | x+alfa*dx_aff >= 0}
*
*     alfa_aff_d = inf{0 <= alfa <= 1 | z+alfa*dz_aff >= 0}
*
*     mu_aff = (x+alfa_aff_p*dx_aff)'*(z+alfa_aff_d*dz_aff)/n
*
*     sigma = (mu_aff/mu)^3
*
*  where alfa_aff_p is the maximal stepsize along the affine scaling
*  direction in the primal space, alfa_aff_d is the maximal stepsize
*  along the same direction in the dual space.
*
*  After determining sigma the routine computes so called centering
*  (corrector) direction (dx_cc,dy_cc,dz_cc) which is the solution of
*  the system:
*
*     A*dx_cc                     = 0
*
*              A'*dy_cc +   dz_cc = 0
*
*     Z*dx_cc           + X*dz_cc = sigma*mu*e - X*Z*e
*
*  Finally, the routine computes the combined direction
*
*     (dx,dy,dz) = (dx_aff,dy_aff,dz_aff) + (dx_cc,dy_cc,dz_cc)
*
*  and determines maximal primal and dual stepsizes along the combined
*  direction:
*
*     alfa_max_p = inf{0 <= alfa <= 1 | x+alfa*dx >= 0}
*
*     alfa_max_d = inf{0 <= alfa <= 1 | z+alfa*dz >= 0}
*
*  In order to prevent the next point to be too close to the boundary
*  of the positive ortant, the routine decreases maximal stepsizes:
*
*     alfa_p = gamma_p * alfa_max_p
*
*     alfa_d = gamma_d * alfa_max_d
*
*  where gamma_p and gamma_d are scaling factors, and computes the next
*  point:
*
*     x_new = x + alfa_p * dx
*
*     y_new = y + alfa_d * dy
*
*     z_new = z + alfa_d * dz
*
*  which becomes the current point on the next iteration. */

static int make_step(struct csa *csa)
{     int m = csa->m;
      int n = csa->n;
      double *b = csa->b;
      double *c = csa->c;
      double *x = csa->x;
      double *y = csa->y;
      double *z = csa->z;
      double *dx_aff = csa->dx_aff;
      double *dy_aff = csa->dy_aff;
      double *dz_aff = csa->dz_aff;
      double *dx_cc = csa->dx_cc;
      double *dy_cc = csa->dy_cc;
      double *dz_cc = csa->dz_cc;
      double *dx = csa->dx;
      double *dy = csa->dy;
      double *dz = csa->dz;
      int i, j, ret = 0;
      double temp, gamma_p, gamma_d, *p, *q, *r;
      /* allocate working arrays */
      p = xcalloc(1+m, sizeof(double));
      q = xcalloc(1+n, sizeof(double));
      r = xcalloc(1+n, sizeof(double));
      /* p = b - A*x */
      A_by_vec(csa, x, p);
      for (i = 1; i <= m; i++) p[i] = b[i] - p[i];
      /* q = c - A'*y - z */
      AT_by_vec(csa, y,q);
      for (j = 1; j <= n; j++) q[j] = c[j] - q[j] - z[j];
      /* r = - X * Z * e */
      for (j = 1; j <= n; j++) r[j] = - x[j] * z[j];
      /* solve the first Newtonian system */
      if (solve_NS(csa, p, q, r, dx_aff, dy_aff, dz_aff))
      {  ret = 1;
         goto done;
      }
      /* alfa_aff_p = inf{0 <= alfa <= 1 | x + alfa*dx_aff >= 0} */
      /* alfa_aff_d = inf{0 <= alfa <= 1 | z + alfa*dz_aff >= 0} */
      csa->alfa_aff_p = csa->alfa_aff_d = 1.0;
      for (j = 1; j <= n; j++)
      {  if (dx_aff[j] < 0.0)
         {  temp = - x[j] / dx_aff[j];
            if (csa->alfa_aff_p > temp) csa->alfa_aff_p = temp;
         }
         if (dz_aff[j] < 0.0)
         {  temp = - z[j] / dz_aff[j];
            if (csa->alfa_aff_d > temp) csa->alfa_aff_d = temp;
         }
      }
      /* mu_aff = (x+alfa_aff_p*dx_aff)' * (z+alfa_aff_d*dz_aff) / n */
      temp = 0.0;
      for (j = 1; j <= n; j++)
         temp += (x[j] + csa->alfa_aff_p * dx_aff[j]) *
                 (z[j] + csa->alfa_aff_d * dz_aff[j]);
      csa->mu_aff = temp / (double)n;
      /* sigma = (mu_aff/mu)^3 */
      temp = csa->mu_aff / csa->mu;
      csa->sigma = temp * temp * temp;
      /* p = 0 */
      for (i = 1; i <= m; i++) p[i] = 0.0;
      /* q = 0 */
      for (j = 1; j <= n; j++) q[j] = 0.0;
      /* r = sigma * mu * e - X * Z * e */
      for (j = 1; j <= n; j++)
         r[j] = csa->sigma * csa->mu - dx_aff[j] * dz_aff[j];
      /* solve the second Newtonian system with the same coefficients
         but with altered right-hand sides */
      if (solve_NS(csa, p, q, r, dx_cc, dy_cc, dz_cc))
      {  ret = 1;
         goto done;
      }
      /* (dx,dy,dz) = (dx_aff,dy_aff,dz_aff) + (dx_cc,dy_cc,dz_cc) */
      for (j = 1; j <= n; j++) dx[j] = dx_aff[j] + dx_cc[j];
      for (i = 1; i <= m; i++) dy[i] = dy_aff[i] + dy_cc[i];
      for (j = 1; j <= n; j++) dz[j] = dz_aff[j] + dz_cc[j];
      /* alfa_max_p = inf{0 <= alfa <= 1 | x + alfa*dx >= 0} */
      /* alfa_max_d = inf{0 <= alfa <= 1 | z + alfa*dz >= 0} */
      csa->alfa_max_p = csa->alfa_max_d = 1.0;
      for (j = 1; j <= n; j++)
      {  if (dx[j] < 0.0)
         {  temp = - x[j] / dx[j];
            if (csa->alfa_max_p > temp) csa->alfa_max_p = temp;
         }
         if (dz[j] < 0.0)
         {  temp = - z[j] / dz[j];
            if (csa->alfa_max_d > temp) csa->alfa_max_d = temp;
         }
      }
      /* determine scale factors (not implemented yet) */
      gamma_p = 0.90;
      gamma_d = 0.90;
      /* compute the next point */
      for (j = 1; j <= n; j++)
      {  x[j] += gamma_p * csa->alfa_max_p * dx[j];
         xassert(x[j] > 0.0);
      }
      for (i = 1; i <= m; i++)
         y[i] += gamma_d * csa->alfa_max_d * dy[i];
      for (j = 1; j <= n; j++)
      {  z[j] += gamma_d * csa->alfa_max_d * dz[j];
         xassert(z[j] > 0.0);
      }
done: /* free working arrays */
      xfree(p);
      xfree(q);
      xfree(r);
      return ret;
}

/***********************************************************************
*  terminate - deallocate common storage area
*
*  This routine frees all memory allocated to the common storage area
*  used by interior-point method routines. */

static void terminate(struct csa *csa)
{     xfree(csa->D);
      xfree(csa->P);
      xfree(csa->S_ptr);
      xfree(csa->S_ind);
      xfree(csa->S_val);
      xfree(csa->S_diag);
      xfree(csa->U_ptr);
      xfree(csa->U_ind);
      xfree(csa->U_val);
      xfree(csa->U_diag);
      xfree(csa->phi_min);
      xfree(csa->best_x);
      xfree(csa->best_y);
      xfree(csa->best_z);
      xfree(csa->dx_aff);
      xfree(csa->dy_aff);
      xfree(csa->dz_aff);
      xfree(csa->dx_cc);
      xfree(csa->dy_cc);
      xfree(csa->dz_cc);
      return;
}

/***********************************************************************
*  ipm_main - main interior-point method routine
*
*  This is a main routine of the primal-dual interior-point method.
*
*  The routine ipm_main returns one of the following codes:
*
*  0 - optimal solution found;
*  1 - problem has no feasible (primal or dual) solution;
*  2 - no convergence;
*  3 - iteration limit exceeded;
*  4 - numeric instability on solving Newtonian system.
*
*  In case of non-zero return code the routine returns the best point,
*  which has been reached during optimization. */

static int ipm_main(struct csa *csa)
{     int m = csa->m;
      int n = csa->n;
      int i, j, status;
      double temp;
      /* choose initial point using Mehrotra's heuristic */
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Guessing initial point...\n");
      initial_point(csa);
      /* main loop starts here */
      if (csa->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Optimization begins...\n");
      for (;;)
      {  /* perform basic computations at the current point */
         basic_info(csa);
         /* save initial value of rmu */
         if (csa->iter == 0) csa->rmu0 = csa->rmu;
         /* accumulate values of min(phi[k]) and save the best point */
         xassert(csa->iter <= ITER_MAX);
         if (csa->iter == 0 || csa->phi_min[csa->iter-1] > csa->phi)
         {  csa->phi_min[csa->iter] = csa->phi;
            csa->best_iter = csa->iter;
            for (j = 1; j <= n; j++) csa->best_x[j] = csa->x[j];
            for (i = 1; i <= m; i++) csa->best_y[i] = csa->y[i];
            for (j = 1; j <= n; j++) csa->best_z[j] = csa->z[j];
            csa->best_obj = csa->obj;
         }
         else
            csa->phi_min[csa->iter] = csa->phi_min[csa->iter-1];
         /* display information at the current point */
         if (csa->parm->msg_lev >= GLP_MSG_ON)
            xprintf("%3d: obj = %17.9e; rpi = %8.1e; rdi = %8.1e; gap ="
               " %8.1e\n", csa->iter, csa->obj, csa->rpi, csa->rdi,
               csa->gap);
         /* check if the current point is optimal */
         if (csa->rpi < 1e-8 && csa->rdi < 1e-8 && csa->gap < 1e-8)
         {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("OPTIMAL SOLUTION FOUND\n");
            status = 0;
            break;
         }
         /* check if the problem has no feasible solution */
         temp = 1e5 * csa->phi_min[csa->iter];
         if (temp < 1e-8) temp = 1e-8;
         if (csa->phi >= temp)
         {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("PROBLEM HAS NO FEASIBLE PRIMAL/DUAL SOLUTION\n")
                  ;
            status = 1;
            break;
         }
         /* check for very slow convergence or divergence */
         if (((csa->rpi >= 1e-8 || csa->rdi >= 1e-8) && csa->rmu /
               csa->rmu0 >= 1e6) ||
               (csa->iter >= 30 && csa->phi_min[csa->iter] >= 0.5 *
               csa->phi_min[csa->iter - 30]))
         {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("NO CONVERGENCE; SEARCH TERMINATED\n");
            status = 2;
            break;
         }
         /* check for maximal number of iterations */
         if (csa->iter == ITER_MAX)
         {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("ITERATION LIMIT EXCEEDED; SEARCH TERMINATED\n");
            status = 3;
            break;
         }
         /* start the next iteration */
         csa->iter++;
         /* factorize normal equation system */
         for (j = 1; j <= n; j++) csa->D[j] = csa->x[j] / csa->z[j];
         decomp_NE(csa);
         /* compute the next point using Mehrotra's predictor-corrector
            technique */
         if (make_step(csa))
         {  if (csa->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("NUMERIC INSTABILITY; SEARCH TERMINATED\n");
            status = 4;
            break;
         }
      }
      /* restore the best point */
      if (status != 0)
      {  for (j = 1; j <= n; j++) csa->x[j] = csa->best_x[j];
         for (i = 1; i <= m; i++) csa->y[i] = csa->best_y[i];
         for (j = 1; j <= n; j++) csa->z[j] = csa->best_z[j];
         if (csa->parm->msg_lev >= GLP_MSG_ALL)
            xprintf("Best point %17.9e was reached on iteration %d\n",
               csa->best_obj, csa->best_iter);
      }
      /* return to the calling program */
      return status;
}

/***********************************************************************
*  NAME
*
*  ipm_solve - core LP solver based on the interior-point method
*
*  SYNOPSIS
*
*  #include "glpipm.h"
*  int ipm_solve(glp_prob *P, const glp_iptcp *parm);
*
*  DESCRIPTION
*
*  The routine ipm_solve is a core LP solver based on the primal-dual
*  interior-point method.
*
*  The routine assumes the following standard formulation of LP problem
*  to be solved:
*
*     minimize
*
*        F = c[0] + c[1]*x[1] + c[2]*x[2] + ... + c[n]*x[n]
*
*     subject to linear constraints
*
*        a[1,1]*x[1] + a[1,2]*x[2] + ... + a[1,n]*x[n] = b[1]
*
*        a[2,1]*x[1] + a[2,2]*x[2] + ... + a[2,n]*x[n] = b[2]
*
*              . . . . . .
*
*        a[m,1]*x[1] + a[m,2]*x[2] + ... + a[m,n]*x[n] = b[m]
*
*     and non-negative variables
*
*        x[1] >= 0, x[2] >= 0, ..., x[n] >= 0
*
*  where:
*  F                    is the objective function;
*  x[1], ..., x[n]      are (structural) variables;
*  c[0]                 is a constant term of the objective function;
*  c[1], ..., c[n]      are objective coefficients;
*  a[1,1], ..., a[m,n]  are constraint coefficients;
*  b[1], ..., b[n]      are right-hand sides.
*
*  The solution is three vectors x, y, and z, which are stored by the
*  routine in the arrays x, y, and z, respectively. These vectors
*  correspond to the best primal-dual point found during optimization.
*  They are approximate solution of the following system (which is the
*  Karush-Kuhn-Tucker optimality conditions):
*
*     A*x      = b      (primal feasibility condition)
*
*     A'*y + z = c      (dual feasibility condition)
*
*     x'*z     = 0      (primal-dual complementarity condition)
*
*     x >= 0, z >= 0    (non-negativity condition)
*
*  where:
*  x[1], ..., x[n]      are primal (structural) variables;
*  y[1], ..., y[m]      are dual variables (Lagrange multipliers) for
*                       equality constraints;
*  z[1], ..., z[n]      are dual variables (Lagrange multipliers) for
*                       non-negativity constraints.
*
*  RETURNS
*
*  0  LP has been successfully solved.
*
*  GLP_ENOCVG
*     No convergence.
*
*  GLP_EITLIM
*     Iteration limit exceeded.
*
*  GLP_EINSTAB
*     Numeric instability on solving Newtonian system.
*
*  In case of non-zero return code the routine returns the best point,
*  which has been reached during optimization. */

int ipm_solve(glp_prob *P, const glp_iptcp *parm)
{     struct csa _dsa, *csa = &_dsa;
      int m = P->m;
      int n = P->n;
      int nnz = P->nnz;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, loc, ret, *A_ind, *A_ptr;
      double dir, *A_val, *b, *c, *x, *y, *z;
      xassert(m > 0);
      xassert(n > 0);
      /* allocate working arrays */
      A_ptr = xcalloc(1+m+1, sizeof(int));
      A_ind = xcalloc(1+nnz, sizeof(int));
      A_val = xcalloc(1+nnz, sizeof(double));
      b = xcalloc(1+m, sizeof(double));
      c = xcalloc(1+n, sizeof(double));
      x = xcalloc(1+n, sizeof(double));
      y = xcalloc(1+m, sizeof(double));
      z = xcalloc(1+n, sizeof(double));
      /* prepare rows and constraint coefficients */
      loc = 1;
      for (i = 1; i <= m; i++)
      {  row = P->row[i];
         xassert(row->type == GLP_FX);
         b[i] = row->lb * row->rii;
         A_ptr[i] = loc;
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  A_ind[loc] = aij->col->j;
            A_val[loc] = row->rii * aij->val * aij->col->sjj;
            loc++;
         }
      }
      A_ptr[m+1] = loc;
      xassert(loc-1 == nnz);
      /* prepare columns and objective coefficients */
      if (P->dir == GLP_MIN)
         dir = +1.0;
      else if (P->dir == GLP_MAX)
         dir = -1.0;
      else
         xassert(P != P);
      c[0] = dir * P->c0;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         xassert(col->type == GLP_LO && col->lb == 0.0);
         c[j] = dir * col->coef * col->sjj;
      }
      /* allocate and initialize the common storage area */
      csa->m = m;
      csa->n = n;
      csa->A_ptr = A_ptr;
      csa->A_ind = A_ind;
      csa->A_val = A_val;
      csa->b = b;
      csa->c = c;
      csa->x = x;
      csa->y = y;
      csa->z = z;
      csa->parm = parm;
      initialize(csa);
      /* solve LP with the interior-point method */
      ret = ipm_main(csa);
      /* deallocate the common storage area */
      terminate(csa);
      /* determine solution status */
      if (ret == 0)
      {  /* optimal solution found */
         P->ipt_stat = GLP_OPT;
         ret = 0;
      }
      else if (ret == 1)
      {  /* problem has no feasible (primal or dual) solution */
         P->ipt_stat = GLP_NOFEAS;
         ret = 0;
      }
      else if (ret == 2)
      {  /* no convergence */
         P->ipt_stat = GLP_INFEAS;
         ret = GLP_ENOCVG;
      }
      else if (ret == 3)
      {  /* iteration limit exceeded */
         P->ipt_stat = GLP_INFEAS;
         ret = GLP_EITLIM;
      }
      else if (ret == 4)
      {  /* numeric instability on solving Newtonian system */
         P->ipt_stat = GLP_INFEAS;
         ret = GLP_EINSTAB;
      }
      else
         xassert(ret != ret);
      /* store row solution components */
      for (i = 1; i <= m; i++)
      {  row = P->row[i];
         row->pval = row->lb;
         row->dval = dir * y[i] * row->rii;
      }
      /* store column solution components */
      P->ipt_obj = P->c0;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         col->pval = x[j] * col->sjj;
         col->dval = dir * z[j] / col->sjj;
         P->ipt_obj += col->coef * col->pval;
      }
      /* free working arrays */
      xfree(A_ptr);
      xfree(A_ind);
      xfree(A_val);
      xfree(b);
      xfree(c);
      xfree(x);
      xfree(y);
      xfree(z);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpipm.h0000644000175100001710000000225200000000000024646 0ustar00runnerdocker00000000000000/* glpipm.h (primal-dual interior-point method) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef GLPIPM_H
#define GLPIPM_H

#include "prob.h"

#define ipm_solve _glp_ipm_solve
int ipm_solve(glp_prob *P, const glp_iptcp *parm);
/* core LP solver based on the interior-point method */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpmat.c0000644000175100001710000010013300000000000024632 0ustar00runnerdocker00000000000000/* glpmat.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpmat.h"
#include "qmd.h"
#include "amd.h"
#include "colamd.h"

/*----------------------------------------------------------------------
-- check_fvs - check sparse vector in full-vector storage format.
--
-- SYNOPSIS
--
-- #include "glpmat.h"
-- int check_fvs(int n, int nnz, int ind[], double vec[]);
--
-- DESCRIPTION
--
-- The routine check_fvs checks if a given vector of dimension n in
-- full-vector storage format has correct representation.
--
-- RETURNS
--
-- The routine returns one of the following codes:
--
-- 0 - the vector is correct;
-- 1 - the number of elements (n) is negative;
-- 2 - the number of non-zero elements (nnz) is negative;
-- 3 - some element index is out of range;
-- 4 - some element index is duplicate;
-- 5 - some non-zero element is out of pattern. */

int check_fvs(int n, int nnz, int ind[], double vec[])
{     int i, t, ret, *flag = NULL;
      /* check the number of elements */
      if (n < 0)
      {  ret = 1;
         goto done;
      }
      /* check the number of non-zero elements */
      if (nnz < 0)
      {  ret = 2;
         goto done;
      }
      /* check vector indices */
      flag = xcalloc(1+n, sizeof(int));
      for (i = 1; i <= n; i++) flag[i] = 0;
      for (t = 1; t <= nnz; t++)
      {  i = ind[t];
         if (!(1 <= i && i <= n))
         {  ret = 3;
            goto done;
         }
         if (flag[i])
         {  ret = 4;
            goto done;
         }
         flag[i] = 1;
      }
      /* check vector elements */
      for (i = 1; i <= n; i++)
      {  if (!flag[i] && vec[i] != 0.0)
         {  ret = 5;
            goto done;
         }
      }
      /* the vector is ok */
      ret = 0;
done: if (flag != NULL) xfree(flag);
      return ret;
}

/*----------------------------------------------------------------------
-- check_pattern - check pattern of sparse matrix.
--
-- SYNOPSIS
--
-- #include "glpmat.h"
-- int check_pattern(int m, int n, int A_ptr[], int A_ind[]);
--
-- DESCRIPTION
--
-- The routine check_pattern checks the pattern of a given mxn matrix
-- in storage-by-rows format.
--
-- RETURNS
--
-- The routine returns one of the following codes:
--
-- 0 - the pattern is correct;
-- 1 - the number of rows (m) is negative;
-- 2 - the number of columns (n) is negative;
-- 3 - A_ptr[1] is not 1;
-- 4 - some column index is out of range;
-- 5 - some column indices are duplicate. */

int check_pattern(int m, int n, int A_ptr[], int A_ind[])
{     int i, j, ptr, ret, *flag = NULL;
      /* check the number of rows */
      if (m < 0)
      {  ret = 1;
         goto done;
      }
      /* check the number of columns */
      if (n < 0)
      {  ret = 2;
         goto done;
      }
      /* check location A_ptr[1] */
      if (A_ptr[1] != 1)
      {  ret = 3;
         goto done;
      }
      /* check row patterns */
      flag = xcalloc(1+n, sizeof(int));
      for (j = 1; j <= n; j++) flag[j] = 0;
      for (i = 1; i <= m; i++)
      {  /* check pattern of row i */
         for (ptr = A_ptr[i]; ptr < A_ptr[i+1]; ptr++)
         {  j = A_ind[ptr];
            /* check column index */
            if (!(1 <= j && j <= n))
            {  ret = 4;
               goto done;
            }
            /* check for duplication */
            if (flag[j])
            {  ret = 5;
               goto done;
            }
            flag[j] = 1;
         }
         /* clear flags */
         for (ptr = A_ptr[i]; ptr < A_ptr[i+1]; ptr++)
         {  j = A_ind[ptr];
            flag[j] = 0;
         }
      }
      /* the pattern is ok */
      ret = 0;
done: if (flag != NULL) xfree(flag);
      return ret;
}

/*----------------------------------------------------------------------
-- transpose - transpose sparse matrix.
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- void transpose(int m, int n, int A_ptr[], int A_ind[],
--    double A_val[], int AT_ptr[], int AT_ind[], double AT_val[]);
--
-- *Description*
--
-- For a given mxn sparse matrix A the routine transpose builds a nxm
-- sparse matrix A' which is a matrix transposed to A.
--
-- The arrays A_ptr, A_ind, and A_val specify a given mxn matrix A to
-- be transposed in storage-by-rows format. The parameter A_val can be
-- NULL, in which case numeric values are not copied. The arrays A_ptr,
-- A_ind, and A_val are not changed on exit.
--
-- On entry the arrays AT_ptr, AT_ind, and AT_val must be allocated,
-- but their content is ignored. On exit the routine stores a resultant
-- nxm matrix A' in these arrays in storage-by-rows format. Note that
-- if the parameter A_val is NULL, the array AT_val is not used.
--
-- The routine transpose has a side effect that elements in rows of the
-- resultant matrix A' follow in ascending their column indices. */

void transpose(int m, int n, int A_ptr[], int A_ind[], double A_val[],
      int AT_ptr[], int AT_ind[], double AT_val[])
{     int i, j, t, beg, end, pos, len;
      /* determine row lengths of resultant matrix */
      for (j = 1; j <= n; j++) AT_ptr[j] = 0;
      for (i = 1; i <= m; i++)
      {  beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++) AT_ptr[A_ind[t]]++;
      }
      /* set up row pointers of resultant matrix */
      pos = 1;
      for (j = 1; j <= n; j++)
         len = AT_ptr[j], pos += len, AT_ptr[j] = pos;
      AT_ptr[n+1] = pos;
      /* build resultant matrix */
      for (i = m; i >= 1; i--)
      {  beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++)
         {  pos = --AT_ptr[A_ind[t]];
            AT_ind[pos] = i;
            if (A_val != NULL) AT_val[pos] = A_val[t];
         }
      }
      return;
}

/*----------------------------------------------------------------------
-- adat_symbolic - compute S = P*A*D*A'*P' (symbolic phase).
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- int *adat_symbolic(int m, int n, int P_per[], int A_ptr[],
--    int A_ind[], int S_ptr[]);
--
-- *Description*
--
-- The routine adat_symbolic implements the symbolic phase to compute
-- symmetric matrix S = P*A*D*A'*P', where P is a permutation matrix,
-- A is a given sparse matrix, D is a diagonal matrix, A' is a matrix
-- transposed to A, P' is an inverse of P.
--
-- The parameter m is the number of rows in A and the order of P.
--
-- The parameter n is the number of columns in A and the order of D.
--
-- The array P_per specifies permutation matrix P. It is not changed on
-- exit.
--
-- The arrays A_ptr and A_ind specify the pattern of matrix A. They are
-- not changed on exit.
--
-- On exit the routine stores the pattern of upper triangular part of
-- matrix S without diagonal elements in the arrays S_ptr and S_ind in
-- storage-by-rows format. The array S_ptr should be allocated on entry,
-- however, its content is ignored. The array S_ind is allocated by the
-- routine itself which returns a pointer to it.
--
-- *Returns*
--
-- The routine returns a pointer to the array S_ind. */

int *adat_symbolic(int m, int n, int P_per[], int A_ptr[], int A_ind[],
      int S_ptr[])
{     int i, j, t, ii, jj, tt, k, size, len;
      int *S_ind, *AT_ptr, *AT_ind, *ind, *map, *temp;
      /* build the pattern of A', which is a matrix transposed to A, to
         efficiently access A in column-wise manner */
      AT_ptr = xcalloc(1+n+1, sizeof(int));
      AT_ind = xcalloc(A_ptr[m+1], sizeof(int));
      transpose(m, n, A_ptr, A_ind, NULL, AT_ptr, AT_ind, NULL);
      /* allocate the array S_ind */
      size = A_ptr[m+1] - 1;
      if (size < m) size = m;
      S_ind = xcalloc(1+size, sizeof(int));
      /* allocate and initialize working arrays */
      ind = xcalloc(1+m, sizeof(int));
      map = xcalloc(1+m, sizeof(int));
      for (jj = 1; jj <= m; jj++) map[jj] = 0;
      /* compute pattern of S; note that symbolically S = B*B', where
         B = P*A, B' is matrix transposed to B */
      S_ptr[1] = 1;
      for (ii = 1; ii <= m; ii++)
      {  /* compute pattern of ii-th row of S */
         len = 0;
         i = P_per[ii]; /* i-th row of A = ii-th row of B */
         for (t = A_ptr[i]; t < A_ptr[i+1]; t++)
         {  k = A_ind[t];
            /* walk through k-th column of A */
            for (tt = AT_ptr[k]; tt < AT_ptr[k+1]; tt++)
            {  j = AT_ind[tt];
               jj = P_per[m+j]; /* j-th row of A = jj-th row of B */
               /* a[i,k] != 0 and a[j,k] != 0 ergo s[ii,jj] != 0 */
               if (ii < jj && !map[jj]) ind[++len] = jj, map[jj] = 1;
            }
         }
         /* now (ind) is pattern of ii-th row of S */
         S_ptr[ii+1] = S_ptr[ii] + len;
         /* at least (S_ptr[ii+1] - 1) locations should be available in
            the array S_ind */
         if (S_ptr[ii+1] - 1 > size)
         {  temp = S_ind;
            size += size;
            S_ind = xcalloc(1+size, sizeof(int));
            memcpy(&S_ind[1], &temp[1], (S_ptr[ii] - 1) * sizeof(int));
            xfree(temp);
         }
         xassert(S_ptr[ii+1] - 1 <= size);
         /* (ii-th row of S) := (ind) */
         memcpy(&S_ind[S_ptr[ii]], &ind[1], len * sizeof(int));
         /* clear the row pattern map */
         for (t = 1; t <= len; t++) map[ind[t]] = 0;
      }
      /* free working arrays */
      xfree(AT_ptr);
      xfree(AT_ind);
      xfree(ind);
      xfree(map);
      /* reallocate the array S_ind to free unused locations */
      temp = S_ind;
      size = S_ptr[m+1] - 1;
      S_ind = xcalloc(1+size, sizeof(int));
      memcpy(&S_ind[1], &temp[1], size * sizeof(int));
      xfree(temp);
      return S_ind;
}

/*----------------------------------------------------------------------
-- adat_numeric - compute S = P*A*D*A'*P' (numeric phase).
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- void adat_numeric(int m, int n, int P_per[],
--    int A_ptr[], int A_ind[], double A_val[], double D_diag[],
--    int S_ptr[], int S_ind[], double S_val[], double S_diag[]);
--
-- *Description*
--
-- The routine adat_numeric implements the numeric phase to compute
-- symmetric matrix S = P*A*D*A'*P', where P is a permutation matrix,
-- A is a given sparse matrix, D is a diagonal matrix, A' is a matrix
-- transposed to A, P' is an inverse of P.
--
-- The parameter m is the number of rows in A and the order of P.
--
-- The parameter n is the number of columns in A and the order of D.
--
-- The matrix P is specified in the array P_per, which is not changed
-- on exit.
--
-- The matrix A is specified in the arrays A_ptr, A_ind, and A_val in
-- storage-by-rows format. These arrays are not changed on exit.
--
-- Diagonal elements of the matrix D are specified in the array D_diag,
-- where D_diag[0] is not used, D_diag[i] = d[i,i] for i = 1, ..., n.
-- The array D_diag is not changed on exit.
--
-- The pattern of the upper triangular part of the matrix S without
-- diagonal elements (previously computed by the routine adat_symbolic)
-- is specified in the arrays S_ptr and S_ind, which are not changed on
-- exit. Numeric values of non-diagonal elements of S are stored in
-- corresponding locations of the array S_val, and values of diagonal
-- elements of S are stored in locations S_diag[1], ..., S_diag[n]. */

void adat_numeric(int m, int n, int P_per[],
      int A_ptr[], int A_ind[], double A_val[], double D_diag[],
      int S_ptr[], int S_ind[], double S_val[], double S_diag[])
{     int i, j, t, ii, jj, tt, beg, end, beg1, end1, k;
      double sum, *work;
      work = xcalloc(1+n, sizeof(double));
      for (j = 1; j <= n; j++) work[j] = 0.0;
      /* compute S = B*D*B', where B = P*A, B' is a matrix transposed
         to B */
      for (ii = 1; ii <= m; ii++)
      {  i = P_per[ii]; /* i-th row of A = ii-th row of B */
         /* (work) := (i-th row of A) */
         beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++)
            work[A_ind[t]] = A_val[t];
         /* compute ii-th row of S */
         beg = S_ptr[ii], end = S_ptr[ii+1];
         for (t = beg; t < end; t++)
         {  jj = S_ind[t];
            j = P_per[jj]; /* j-th row of A = jj-th row of B */
            /* s[ii,jj] := sum a[i,k] * d[k,k] * a[j,k] */
            sum = 0.0;
            beg1 = A_ptr[j], end1 = A_ptr[j+1];
            for (tt = beg1; tt < end1; tt++)
            {  k = A_ind[tt];
               sum += work[k] * D_diag[k] * A_val[tt];
            }
            S_val[t] = sum;
         }
         /* s[ii,ii] := sum a[i,k] * d[k,k] * a[i,k] */
         sum = 0.0;
         beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++)
         {  k = A_ind[t];
            sum += A_val[t] * D_diag[k] * A_val[t];
            work[k] = 0.0;
         }
         S_diag[ii] = sum;
      }
      xfree(work);
      return;
}

/*----------------------------------------------------------------------
-- min_degree - minimum degree ordering.
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- void min_degree(int n, int A_ptr[], int A_ind[], int P_per[]);
--
-- *Description*
--
-- The routine min_degree uses the minimum degree ordering algorithm
-- to find a permutation matrix P for a given sparse symmetric positive
-- matrix A which minimizes the number of non-zeros in upper triangular
-- factor U for Cholesky factorization P*A*P' = U'*U.
--
-- The parameter n is the order of matrices A and P.
--
-- The pattern of the given matrix A is specified on entry in the arrays
-- A_ptr and A_ind in storage-by-rows format. Only the upper triangular
-- part without diagonal elements (which all are assumed to be non-zero)
-- should be specified as if A were upper triangular. The arrays A_ptr
-- and A_ind are not changed on exit.
--
-- The permutation matrix P is stored by the routine in the array P_per
-- on exit.
--
-- *Algorithm*
--
-- The routine min_degree is based on some subroutines from the package
-- SPARSPAK (see comments in the module glpqmd). */

void min_degree(int n, int A_ptr[], int A_ind[], int P_per[])
{     int i, j, ne, t, pos, len;
      int *xadj, *adjncy, *deg, *marker, *rchset, *nbrhd, *qsize,
         *qlink, nofsub;
      /* determine number of non-zeros in complete pattern */
      ne = A_ptr[n+1] - 1;
      ne += ne;
      /* allocate working arrays */
      xadj = xcalloc(1+n+1, sizeof(int));
      adjncy = xcalloc(1+ne, sizeof(int));
      deg = xcalloc(1+n, sizeof(int));
      marker = xcalloc(1+n, sizeof(int));
      rchset = xcalloc(1+n, sizeof(int));
      nbrhd = xcalloc(1+n, sizeof(int));
      qsize = xcalloc(1+n, sizeof(int));
      qlink = xcalloc(1+n, sizeof(int));
      /* determine row lengths in complete pattern */
      for (i = 1; i <= n; i++) xadj[i] = 0;
      for (i = 1; i <= n; i++)
      {  for (t = A_ptr[i]; t < A_ptr[i+1]; t++)
         {  j = A_ind[t];
            xassert(i < j && j <= n);
            xadj[i]++, xadj[j]++;
         }
      }
      /* set up row pointers for complete pattern */
      pos = 1;
      for (i = 1; i <= n; i++)
         len = xadj[i], pos += len, xadj[i] = pos;
      xadj[n+1] = pos;
      xassert(pos - 1 == ne);
      /* construct complete pattern */
      for (i = 1; i <= n; i++)
      {  for (t = A_ptr[i]; t < A_ptr[i+1]; t++)
         {  j = A_ind[t];
            adjncy[--xadj[i]] = j, adjncy[--xadj[j]] = i;
         }
      }
      /* call the main minimimum degree ordering routine */
      genqmd(&n, xadj, adjncy, P_per, P_per + n, deg, marker, rchset,
         nbrhd, qsize, qlink, &nofsub);
      /* make sure that permutation matrix P is correct */
      for (i = 1; i <= n; i++)
      {  j = P_per[i];
         xassert(1 <= j && j <= n);
         xassert(P_per[n+j] == i);
      }
      /* free working arrays */
      xfree(xadj);
      xfree(adjncy);
      xfree(deg);
      xfree(marker);
      xfree(rchset);
      xfree(nbrhd);
      xfree(qsize);
      xfree(qlink);
      return;
}

/**********************************************************************/

void amd_order1(int n, int A_ptr[], int A_ind[], int P_per[])
{     /* approximate minimum degree ordering (AMD) */
      int k, ret;
      double Control[AMD_CONTROL], Info[AMD_INFO];
      /* get the default parameters */
      amd_defaults(Control);
#if 0
      /* and print them */
      amd_control(Control);
#endif
      /* make all indices 0-based */
      for (k = 1; k < A_ptr[n+1]; k++) A_ind[k]--;
      for (k = 1; k <= n+1; k++) A_ptr[k]--;
      /* call the ordering routine */
      ret = amd_order(n, &A_ptr[1], &A_ind[1], &P_per[1], Control, Info)
         ;
#if 0
      amd_info(Info);
#endif
      xassert(ret == AMD_OK || ret == AMD_OK_BUT_JUMBLED);
      /* retsore 1-based indices */
      for (k = 1; k <= n+1; k++) A_ptr[k]++;
      for (k = 1; k < A_ptr[n+1]; k++) A_ind[k]++;
      /* patch up permutation matrix */
      memset(&P_per[n+1], 0, n * sizeof(int));
      for (k = 1; k <= n; k++)
      {  P_per[k]++;
         xassert(1 <= P_per[k] && P_per[k] <= n);
         xassert(P_per[n+P_per[k]] == 0);
         P_per[n+P_per[k]] = k;
      }
      return;
}

/**********************************************************************/

static void *allocate(size_t n, size_t size)
{     void *ptr;
      ptr = xcalloc(n, size);
      memset(ptr, 0, n * size);
      return ptr;
}

static void release(void *ptr)
{     xfree(ptr);
      return;
}

void symamd_ord(int n, int A_ptr[], int A_ind[], int P_per[])
{     /* approximate minimum degree ordering (SYMAMD) */
      int k, ok;
      int stats[COLAMD_STATS];
      /* make all indices 0-based */
      for (k = 1; k < A_ptr[n+1]; k++) A_ind[k]--;
      for (k = 1; k <= n+1; k++) A_ptr[k]--;
      /* call the ordering routine */
      ok = symamd(n, &A_ind[1], &A_ptr[1], &P_per[1], NULL, stats,
         allocate, release);
#if 0
      symamd_report(stats);
#endif
      xassert(ok);
      /* restore 1-based indices */
      for (k = 1; k <= n+1; k++) A_ptr[k]++;
      for (k = 1; k < A_ptr[n+1]; k++) A_ind[k]++;
      /* patch up permutation matrix */
      memset(&P_per[n+1], 0, n * sizeof(int));
      for (k = 1; k <= n; k++)
      {  P_per[k]++;
         xassert(1 <= P_per[k] && P_per[k] <= n);
         xassert(P_per[n+P_per[k]] == 0);
         P_per[n+P_per[k]] = k;
      }
      return;
}

/*----------------------------------------------------------------------
-- chol_symbolic - compute Cholesky factorization (symbolic phase).
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- int *chol_symbolic(int n, int A_ptr[], int A_ind[], int U_ptr[]);
--
-- *Description*
--
-- The routine chol_symbolic implements the symbolic phase of Cholesky
-- factorization A = U'*U, where A is a given sparse symmetric positive
-- definite matrix, U is a resultant upper triangular factor, U' is a
-- matrix transposed to U.
--
-- The parameter n is the order of matrices A and U.
--
-- The pattern of the given matrix A is specified on entry in the arrays
-- A_ptr and A_ind in storage-by-rows format. Only the upper triangular
-- part without diagonal elements (which all are assumed to be non-zero)
-- should be specified as if A were upper triangular. The arrays A_ptr
-- and A_ind are not changed on exit.
--
-- The pattern of the matrix U without diagonal elements (which all are
-- assumed to be non-zero) is stored on exit from the routine in the
-- arrays U_ptr and U_ind in storage-by-rows format. The array U_ptr
-- should be allocated on entry, however, its content is ignored. The
-- array U_ind is allocated by the routine which returns a pointer to it
-- on exit.
--
-- *Returns*
--
-- The routine returns a pointer to the array U_ind.
--
-- *Method*
--
-- The routine chol_symbolic computes the pattern of the matrix U in a
-- row-wise manner. No pivoting is used.
--
-- It is known that to compute the pattern of row k of the matrix U we
-- need to merge the pattern of row k of the matrix A and the patterns
-- of each row i of U, where u[i,k] is non-zero (these rows are already
-- computed and placed above row k).
--
-- However, to reduce the number of rows to be merged the routine uses
-- an advanced algorithm proposed in:
--
-- D.J.Rose, R.E.Tarjan, and G.S.Lueker. Algorithmic aspects of vertex
-- elimination on graphs. SIAM J. Comput. 5, 1976, 266-83.
--
-- The authors of the cited paper show that we have the same result if
-- we merge row k of the matrix A and such rows of the matrix U (among
-- rows 1, ..., k-1) whose leftmost non-diagonal non-zero element is
-- placed in k-th column. This feature signficantly reduces the number
-- of rows to be merged, especially on the final steps, where rows of
-- the matrix U become quite dense.
--
-- To determine rows, which should be merged on k-th step, for a fixed
-- time the routine uses linked lists of row numbers of the matrix U.
-- Location head[k] contains the number of a first row, whose leftmost
-- non-diagonal non-zero element is placed in column k, and location
-- next[i] contains the number of a next row with the same property as
-- row i. */

int *chol_symbolic(int n, int A_ptr[], int A_ind[], int U_ptr[])
{     int i, j, k, t, len, size, beg, end, min_j, *U_ind, *head, *next,
         *ind, *map, *temp;
      /* initially we assume that on computing the pattern of U fill-in
         will double the number of non-zeros in A */
      size = A_ptr[n+1] - 1;
      if (size < n) size = n;
      size += size;
      U_ind = xcalloc(1+size, sizeof(int));
      /* allocate and initialize working arrays */
      head = xcalloc(1+n, sizeof(int));
      for (i = 1; i <= n; i++) head[i] = 0;
      next = xcalloc(1+n, sizeof(int));
      ind = xcalloc(1+n, sizeof(int));
      map = xcalloc(1+n, sizeof(int));
      for (j = 1; j <= n; j++) map[j] = 0;
      /* compute the pattern of matrix U */
      U_ptr[1] = 1;
      for (k = 1; k <= n; k++)
      {  /* compute the pattern of k-th row of U, which is the union of
            k-th row of A and those rows of U (among 1, ..., k-1) whose
            leftmost non-diagonal non-zero is placed in k-th column */
         /* (ind) := (k-th row of A) */
         len = A_ptr[k+1] - A_ptr[k];
         memcpy(&ind[1], &A_ind[A_ptr[k]], len * sizeof(int));
         for (t = 1; t <= len; t++)
         {  j = ind[t];
            xassert(k < j && j <= n);
            map[j] = 1;
         }
         /* walk through rows of U whose leftmost non-diagonal non-zero
            is placed in k-th column */
         for (i = head[k]; i != 0; i = next[i])
         {  /* (ind) := (ind) union (i-th row of U) */
            beg = U_ptr[i], end = U_ptr[i+1];
            for (t = beg; t < end; t++)
            {  j = U_ind[t];
               if (j > k && !map[j]) ind[++len] = j, map[j] = 1;
            }
         }
         /* now (ind) is the pattern of k-th row of U */
         U_ptr[k+1] = U_ptr[k] + len;
         /* at least (U_ptr[k+1] - 1) locations should be available in
            the array U_ind */
         if (U_ptr[k+1] - 1 > size)
         {  temp = U_ind;
            size += size;
            U_ind = xcalloc(1+size, sizeof(int));
            memcpy(&U_ind[1], &temp[1], (U_ptr[k] - 1) * sizeof(int));
            xfree(temp);
         }
         xassert(U_ptr[k+1] - 1 <= size);
         /* (k-th row of U) := (ind) */
         memcpy(&U_ind[U_ptr[k]], &ind[1], len * sizeof(int));
         /* determine column index of leftmost non-diagonal non-zero in
            k-th row of U and clear the row pattern map */
         min_j = n + 1;
         for (t = 1; t <= len; t++)
         {  j = ind[t], map[j] = 0;
            if (min_j > j) min_j = j;
         }
         /* include k-th row into corresponding linked list */
         if (min_j <= n) next[k] = head[min_j], head[min_j] = k;
      }
      /* free working arrays */
      xfree(head);
      xfree(next);
      xfree(ind);
      xfree(map);
      /* reallocate the array U_ind to free unused locations */
      temp = U_ind;
      size = U_ptr[n+1] - 1;
      U_ind = xcalloc(1+size, sizeof(int));
      memcpy(&U_ind[1], &temp[1], size * sizeof(int));
      xfree(temp);
      return U_ind;
}

/*----------------------------------------------------------------------
-- chol_numeric - compute Cholesky factorization (numeric phase).
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- int chol_numeric(int n,
--    int A_ptr[], int A_ind[], double A_val[], double A_diag[],
--    int U_ptr[], int U_ind[], double U_val[], double U_diag[]);
--
-- *Description*
--
-- The routine chol_symbolic implements the numeric phase of Cholesky
-- factorization A = U'*U, where A is a given sparse symmetric positive
-- definite matrix, U is a resultant upper triangular factor, U' is a
-- matrix transposed to U.
--
-- The parameter n is the order of matrices A and U.
--
-- Upper triangular part of the matrix A without diagonal elements is
-- specified in the arrays A_ptr, A_ind, and A_val in storage-by-rows
-- format. Diagonal elements of A are specified in the array A_diag,
-- where A_diag[0] is not used, A_diag[i] = a[i,i] for i = 1, ..., n.
-- The arrays A_ptr, A_ind, A_val, and A_diag are not changed on exit.
--
-- The pattern of the matrix U without diagonal elements (previously
-- computed with the routine chol_symbolic) is specified in the arrays
-- U_ptr and U_ind, which are not changed on exit. Numeric values of
-- non-diagonal elements of U are stored in corresponding locations of
-- the array U_val, and values of diagonal elements of U are stored in
-- locations U_diag[1], ..., U_diag[n].
--
-- *Returns*
--
-- The routine returns the number of non-positive diagonal elements of
-- the matrix U which have been replaced by a huge positive number (see
-- the method description below). Zero return code means the matrix A
-- has been successfully factorized.
--
-- *Method*
--
-- The routine chol_numeric computes the matrix U in a row-wise manner
-- using standard gaussian elimination technique. No pivoting is used.
--
-- Initially the routine sets U = A, and before k-th elimination step
-- the matrix U is the following:
--
--       1       k         n
--    1  x x x x x x x x x x
--       . x x x x x x x x x
--       . . x x x x x x x x
--       . . . x x x x x x x
--    k  . . . . * * * * * *
--       . . . . * * * * * *
--       . . . . * * * * * *
--       . . . . * * * * * *
--       . . . . * * * * * *
--    n  . . . . * * * * * *
--
-- where 'x' are elements of already computed rows, '*' are elements of
-- the active submatrix. (Note that the lower triangular part of the
-- active submatrix being symmetric is not stored and diagonal elements
-- are stored separately in the array U_diag.)
--
-- The matrix A is assumed to be positive definite. However, if it is
-- close to semi-definite, on some elimination step a pivot u[k,k] may
-- happen to be non-positive due to round-off errors. In this case the
-- routine uses a technique proposed in:
--
-- S.J.Wright. The Cholesky factorization in interior-point and barrier
-- methods. Preprint MCS-P600-0596, Mathematics and Computer Science
-- Division, Argonne National Laboratory, Argonne, Ill., May 1996.
--
-- The routine just replaces non-positive u[k,k] by a huge positive
-- number. This involves non-diagonal elements in k-th row of U to be
-- close to zero that, in turn, involves k-th component of a solution
-- vector to be close to zero. Note, however, that this technique works
-- only if the system A*x = b is consistent. */

int chol_numeric(int n,
      int A_ptr[], int A_ind[], double A_val[], double A_diag[],
      int U_ptr[], int U_ind[], double U_val[], double U_diag[])
{     int i, j, k, t, t1, beg, end, beg1, end1, count = 0;
      double ukk, uki, *work;
      work = xcalloc(1+n, sizeof(double));
      for (j = 1; j <= n; j++) work[j] = 0.0;
      /* U := (upper triangle of A) */
      /* note that the upper traingle of A is a subset of U */
      for (i = 1; i <= n; i++)
      {  beg = A_ptr[i], end = A_ptr[i+1];
         for (t = beg; t < end; t++)
            j = A_ind[t], work[j] = A_val[t];
         beg = U_ptr[i], end = U_ptr[i+1];
         for (t = beg; t < end; t++)
            j = U_ind[t], U_val[t] = work[j], work[j] = 0.0;
         U_diag[i] = A_diag[i];
      }
      /* main elimination loop */
      for (k = 1; k <= n; k++)
      {  /* transform k-th row of U */
         ukk = U_diag[k];
         if (ukk > 0.0)
            U_diag[k] = ukk = sqrt(ukk);
         else
            U_diag[k] = ukk = DBL_MAX, count++;
         /* (work) := (transformed k-th row) */
         beg = U_ptr[k], end = U_ptr[k+1];
         for (t = beg; t < end; t++)
            work[U_ind[t]] = (U_val[t] /= ukk);
         /* transform other rows of U */
         for (t = beg; t < end; t++)
         {  i = U_ind[t];
            xassert(i > k);
            /* (i-th row) := (i-th row) - u[k,i] * (k-th row) */
            uki = work[i];
            beg1 = U_ptr[i], end1 = U_ptr[i+1];
            for (t1 = beg1; t1 < end1; t1++)
               U_val[t1] -= uki * work[U_ind[t1]];
            U_diag[i] -= uki * uki;
         }
         /* (work) := 0 */
         for (t = beg; t < end; t++)
            work[U_ind[t]] = 0.0;
      }
      xfree(work);
      return count;
}

/*----------------------------------------------------------------------
-- u_solve - solve upper triangular system U*x = b.
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- void u_solve(int n, int U_ptr[], int U_ind[], double U_val[],
--    double U_diag[], double x[]);
--
-- *Description*
--
-- The routine u_solve solves an linear system U*x = b, where U is an
-- upper triangular matrix.
--
-- The parameter n is the order of matrix U.
--
-- The matrix U without diagonal elements is specified in the arrays
-- U_ptr, U_ind, and U_val in storage-by-rows format. Diagonal elements
-- of U are specified in the array U_diag, where U_diag[0] is not used,
-- U_diag[i] = u[i,i] for i = 1, ..., n. All these four arrays are not
-- changed on exit.
--
-- The right-hand side vector b is specified on entry in the array x,
-- where x[0] is not used, and x[i] = b[i] for i = 1, ..., n. On exit
-- the routine stores computed components of the vector of unknowns x
-- in the array x in the same manner. */

void u_solve(int n, int U_ptr[], int U_ind[], double U_val[],
      double U_diag[], double x[])
{     int i, t, beg, end;
      double temp;
      for (i = n; i >= 1; i--)
      {  temp = x[i];
         beg = U_ptr[i], end = U_ptr[i+1];
         for (t = beg; t < end; t++)
            temp -= U_val[t] * x[U_ind[t]];
         xassert(U_diag[i] != 0.0);
         x[i] = temp / U_diag[i];
      }
      return;
}

/*----------------------------------------------------------------------
-- ut_solve - solve lower triangular system U'*x = b.
--
-- *Synopsis*
--
-- #include "glpmat.h"
-- void ut_solve(int n, int U_ptr[], int U_ind[], double U_val[],
--    double U_diag[], double x[]);
--
-- *Description*
--
-- The routine ut_solve solves an linear system U'*x = b, where U is a
-- matrix transposed to an upper triangular matrix.
--
-- The parameter n is the order of matrix U.
--
-- The matrix U without diagonal elements is specified in the arrays
-- U_ptr, U_ind, and U_val in storage-by-rows format. Diagonal elements
-- of U are specified in the array U_diag, where U_diag[0] is not used,
-- U_diag[i] = u[i,i] for i = 1, ..., n. All these four arrays are not
-- changed on exit.
--
-- The right-hand side vector b is specified on entry in the array x,
-- where x[0] is not used, and x[i] = b[i] for i = 1, ..., n. On exit
-- the routine stores computed components of the vector of unknowns x
-- in the array x in the same manner. */

void ut_solve(int n, int U_ptr[], int U_ind[], double U_val[],
      double U_diag[], double x[])
{     int i, t, beg, end;
      double temp;
      for (i = 1; i <= n; i++)
      {  xassert(U_diag[i] != 0.0);
         temp = (x[i] /= U_diag[i]);
         if (temp == 0.0) continue;
         beg = U_ptr[i], end = U_ptr[i+1];
         for (t = beg; t < end; t++)
            x[U_ind[t]] -= U_val[t] * temp;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpmat.h0000644000175100001710000001621600000000000024647 0ustar00runnerdocker00000000000000/* glpmat.h (linear algebra routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef GLPMAT_H
#define GLPMAT_H

/***********************************************************************
*  FULL-VECTOR STORAGE
*
*  For a sparse vector x having n elements, ne of which are non-zero,
*  the full-vector storage format uses two arrays x_ind and x_vec, which
*  are set up as follows:
*
*  x_ind is an integer array of length [1+ne]. Location x_ind[0] is
*  not used, and locations x_ind[1], ..., x_ind[ne] contain indices of
*  non-zero elements in vector x.
*
*  x_vec is a floating-point array of length [1+n]. Location x_vec[0]
*  is not used, and locations x_vec[1], ..., x_vec[n] contain numeric
*  values of ALL elements in vector x, including its zero elements.
*
*  Let, for example, the following sparse vector x be given:
*
*     (0, 1, 0, 0, 2, 3, 0, 4)
*
*  Then the arrays are:
*
*     x_ind = { X; 2, 5, 6, 8 }
*
*     x_vec = { X; 0, 1, 0, 0, 2, 3, 0, 4 }
*
*  COMPRESSED-VECTOR STORAGE
*
*  For a sparse vector x having n elements, ne of which are non-zero,
*  the compressed-vector storage format uses two arrays x_ind and x_vec,
*  which are set up as follows:
*
*  x_ind is an integer array of length [1+ne]. Location x_ind[0] is
*  not used, and locations x_ind[1], ..., x_ind[ne] contain indices of
*  non-zero elements in vector x.
*
*  x_vec is a floating-point array of length [1+ne]. Location x_vec[0]
*  is not used, and locations x_vec[1], ..., x_vec[ne] contain numeric
*  values of corresponding non-zero elements in vector x.
*
*  Let, for example, the following sparse vector x be given:
*
*     (0, 1, 0, 0, 2, 3, 0, 4)
*
*  Then the arrays are:
*
*     x_ind = { X; 2, 5, 6, 8 }
*
*     x_vec = { X; 1, 2, 3, 4 }
*
*  STORAGE-BY-ROWS
*
*  For a sparse matrix A, which has m rows, n columns, and ne non-zero
*  elements the storage-by-rows format uses three arrays A_ptr, A_ind,
*  and A_val, which are set up as follows:
*
*  A_ptr is an integer array of length [1+m+1] also called "row pointer
*  array". It contains the relative starting positions of each row of A
*  in the arrays A_ind and A_val, i.e. element A_ptr[i], 1 <= i <= m,
*  indicates where row i begins in the arrays A_ind and A_val. If all
*  elements in row i are zero, then A_ptr[i] = A_ptr[i+1]. Location
*  A_ptr[0] is not used, location A_ptr[1] must contain 1, and location
*  A_ptr[m+1] must contain ne+1 that indicates the position after the
*  last element in the arrays A_ind and A_val.
*
*  A_ind is an integer array of length [1+ne]. Location A_ind[0] is not
*  used, and locations A_ind[1], ..., A_ind[ne] contain column indices
*  of (non-zero) elements in matrix A.
*
*  A_val is a floating-point array of length [1+ne]. Location A_val[0]
*  is not used, and locations A_val[1], ..., A_val[ne] contain numeric
*  values of non-zero elements in matrix A.
*
*  Non-zero elements of matrix A are stored contiguously, and the rows
*  of matrix A are stored consecutively from 1 to m in the arrays A_ind
*  and A_val. The elements in each row of A may be stored in any order
*  in A_ind and A_val. Note that elements with duplicate column indices
*  are not allowed.
*
*  Let, for example, the following sparse matrix A be given:
*
*     | 11  . 13  .  .  . |
*     | 21 22  . 24  .  . |
*     |  . 32 33  .  .  . |
*     |  .  . 43 44  . 46 |
*     |  .  .  .  .  .  . |
*     | 61 62  .  .  . 66 |
*
*  Then the arrays are:
*
*     A_ptr = { X; 1, 3, 6, 8, 11, 11; 14 }
*
*     A_ind = { X;  1,  3;  4,  2,  1;  2,  3;  4,  3,  6;  1,  2,  6 }
*
*     A_val = { X; 11, 13; 24, 22, 21; 32, 33; 44, 43, 46; 61, 62, 66 }
*
*  PERMUTATION MATRICES
*
*  Let P be a permutation matrix of the order n. It is represented as
*  an integer array P_per of length [1+n+n] as follows: if p[i,j] = 1,
*  then P_per[i] = j and P_per[n+j] = i. Location P_per[0] is not used.
*
*  Let A' = P*A. If i-th row of A corresponds to i'-th row of A', then
*  P_per[i'] = i and P_per[n+i] = i'.
*
*  References:
*
*  1. Gustavson F.G. Some basic techniques for solving sparse systems of
*     linear equations. In Rose and Willoughby (1972), pp. 41-52.
*
*  2. Basic Linear Algebra Subprograms Technical (BLAST) Forum Standard.
*     University of Tennessee (2001). */

#define check_fvs _glp_mat_check_fvs
int check_fvs(int n, int nnz, int ind[], double vec[]);
/* check sparse vector in full-vector storage format */

#define check_pattern _glp_mat_check_pattern
int check_pattern(int m, int n, int A_ptr[], int A_ind[]);
/* check pattern of sparse matrix */

#define transpose _glp_mat_transpose
void transpose(int m, int n, int A_ptr[], int A_ind[], double A_val[],
      int AT_ptr[], int AT_ind[], double AT_val[]);
/* transpose sparse matrix */

#define adat_symbolic _glp_mat_adat_symbolic
int *adat_symbolic(int m, int n, int P_per[], int A_ptr[], int A_ind[],
      int S_ptr[]);
/* compute S = P*A*D*A'*P' (symbolic phase) */

#define adat_numeric _glp_mat_adat_numeric
void adat_numeric(int m, int n, int P_per[],
      int A_ptr[], int A_ind[], double A_val[], double D_diag[],
      int S_ptr[], int S_ind[], double S_val[], double S_diag[]);
/* compute S = P*A*D*A'*P' (numeric phase) */

#define min_degree _glp_mat_min_degree
void min_degree(int n, int A_ptr[], int A_ind[], int P_per[]);
/* minimum degree ordering */

#define amd_order1 _glp_mat_amd_order1
void amd_order1(int n, int A_ptr[], int A_ind[], int P_per[]);
/* approximate minimum degree ordering (AMD) */

#define symamd_ord _glp_mat_symamd_ord
void symamd_ord(int n, int A_ptr[], int A_ind[], int P_per[]);
/* approximate minimum degree ordering (SYMAMD) */

#define chol_symbolic _glp_mat_chol_symbolic
int *chol_symbolic(int n, int A_ptr[], int A_ind[], int U_ptr[]);
/* compute Cholesky factorization (symbolic phase) */

#define chol_numeric _glp_mat_chol_numeric
int chol_numeric(int n,
      int A_ptr[], int A_ind[], double A_val[], double A_diag[],
      int U_ptr[], int U_ind[], double U_val[], double U_diag[]);
/* compute Cholesky factorization (numeric phase) */

#define u_solve _glp_mat_u_solve
void u_solve(int n, int U_ptr[], int U_ind[], double U_val[],
      double U_diag[], double x[]);
/* solve upper triangular system U*x = b */

#define ut_solve _glp_mat_ut_solve
void ut_solve(int n, int U_ptr[], int U_ind[], double U_val[],
      double U_diag[], double x[]);
/* solve lower triangular system U'*x = b */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpscl.c0000644000175100001710000003712400000000000024643 0ustar00runnerdocker00000000000000/* glpscl.c (problem scaling routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"
#include "prob.h"

/***********************************************************************
*  min_row_aij - determine minimal |a[i,j]| in i-th row
*
*  This routine returns minimal magnitude of (non-zero) constraint
*  coefficients in i-th row of the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If i-th row of the matrix is empty, the routine returns 1. */

static double min_row_aij(glp_prob *lp, int i, int scaled)
{     GLPAIJ *aij;
      double min_aij, temp;
      xassert(1 <= i && i <= lp->m);
      min_aij = 1.0;
      for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
      {  temp = fabs(aij->val);
         if (scaled) temp *= (aij->row->rii * aij->col->sjj);
         if (aij->r_prev == NULL || min_aij > temp)
            min_aij = temp;
      }
      return min_aij;
}

/***********************************************************************
*  max_row_aij - determine maximal |a[i,j]| in i-th row
*
*  This routine returns maximal magnitude of (non-zero) constraint
*  coefficients in i-th row of the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If i-th row of the matrix is empty, the routine returns 1. */

static double max_row_aij(glp_prob *lp, int i, int scaled)
{     GLPAIJ *aij;
      double max_aij, temp;
      xassert(1 <= i && i <= lp->m);
      max_aij = 1.0;
      for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
      {  temp = fabs(aij->val);
         if (scaled) temp *= (aij->row->rii * aij->col->sjj);
         if (aij->r_prev == NULL || max_aij < temp)
            max_aij = temp;
      }
      return max_aij;
}

/***********************************************************************
*  min_col_aij - determine minimal |a[i,j]| in j-th column
*
*  This routine returns minimal magnitude of (non-zero) constraint
*  coefficients in j-th column of the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If j-th column of the matrix is empty, the routine returns 1. */

static double min_col_aij(glp_prob *lp, int j, int scaled)
{     GLPAIJ *aij;
      double min_aij, temp;
      xassert(1 <= j && j <= lp->n);
      min_aij = 1.0;
      for (aij = lp->col[j]->ptr; aij != NULL; aij = aij->c_next)
      {  temp = fabs(aij->val);
         if (scaled) temp *= (aij->row->rii * aij->col->sjj);
         if (aij->c_prev == NULL || min_aij > temp)
            min_aij = temp;
      }
      return min_aij;
}

/***********************************************************************
*  max_col_aij - determine maximal |a[i,j]| in j-th column
*
*  This routine returns maximal magnitude of (non-zero) constraint
*  coefficients in j-th column of the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If j-th column of the matrix is empty, the routine returns 1. */

static double max_col_aij(glp_prob *lp, int j, int scaled)
{     GLPAIJ *aij;
      double max_aij, temp;
      xassert(1 <= j && j <= lp->n);
      max_aij = 1.0;
      for (aij = lp->col[j]->ptr; aij != NULL; aij = aij->c_next)
      {  temp = fabs(aij->val);
         if (scaled) temp *= (aij->row->rii * aij->col->sjj);
         if (aij->c_prev == NULL || max_aij < temp)
            max_aij = temp;
      }
      return max_aij;
}

/***********************************************************************
*  min_mat_aij - determine minimal |a[i,j]| in constraint matrix
*
*  This routine returns minimal magnitude of (non-zero) constraint
*  coefficients in the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If the matrix is empty, the routine returns 1. */

static double min_mat_aij(glp_prob *lp, int scaled)
{     int i;
      double min_aij, temp;
      min_aij = 1.0;
      for (i = 1; i <= lp->m; i++)
      {  temp = min_row_aij(lp, i, scaled);
         if (i == 1 || min_aij > temp)
            min_aij = temp;
      }
      return min_aij;
}

/***********************************************************************
*  max_mat_aij - determine maximal |a[i,j]| in constraint matrix
*
*  This routine returns maximal magnitude of (non-zero) constraint
*  coefficients in the constraint matrix.
*
*  If the parameter scaled is zero, the original constraint matrix A is
*  assumed. Otherwise, the scaled constraint matrix R*A*S is assumed.
*
*  If the matrix is empty, the routine returns 1. */

static double max_mat_aij(glp_prob *lp, int scaled)
{     int i;
      double max_aij, temp;
      max_aij = 1.0;
      for (i = 1; i <= lp->m; i++)
      {  temp = max_row_aij(lp, i, scaled);
         if (i == 1 || max_aij < temp)
            max_aij = temp;
      }
      return max_aij;
}

/***********************************************************************
*  eq_scaling - perform equilibration scaling
*
*  This routine performs equilibration scaling of rows and columns of
*  the constraint matrix.
*
*  If the parameter flag is zero, the routine scales rows at first and
*  then columns. Otherwise, the routine scales columns and then rows.
*
*  Rows are scaled as follows:
*
*                         n
*     a'[i,j] = a[i,j] / max |a[i,j]|,  i = 1,...,m.
*                        j=1
*
*  This makes the infinity (maximum) norm of each row of the matrix
*  equal to 1.
*
*  Columns are scaled as follows:
*
*                         m
*     a'[i,j] = a[i,j] / max |a[i,j]|,  j = 1,...,n.
*                        i=1
*
*  This makes the infinity (maximum) norm of each column of the matrix
*  equal to 1. */

static void eq_scaling(glp_prob *lp, int flag)
{     int i, j, pass;
      double temp;
      xassert(flag == 0 || flag == 1);
      for (pass = 0; pass <= 1; pass++)
      {  if (pass == flag)
         {  /* scale rows */
            for (i = 1; i <= lp->m; i++)
            {  temp = max_row_aij(lp, i, 1);
               glp_set_rii(lp, i, glp_get_rii(lp, i) / temp);
            }
         }
         else
         {  /* scale columns */
            for (j = 1; j <= lp->n; j++)
            {  temp = max_col_aij(lp, j, 1);
               glp_set_sjj(lp, j, glp_get_sjj(lp, j) / temp);
            }
         }
      }
      return;
}

/***********************************************************************
*  gm_scaling - perform geometric mean scaling
*
*  This routine performs geometric mean scaling of rows and columns of
*  the constraint matrix.
*
*  If the parameter flag is zero, the routine scales rows at first and
*  then columns. Otherwise, the routine scales columns and then rows.
*
*  Rows are scaled as follows:
*
*     a'[i,j] = a[i,j] / sqrt(alfa[i] * beta[i]),  i = 1,...,m,
*
*  where:
*                n                        n
*     alfa[i] = min |a[i,j]|,  beta[i] = max |a[i,j]|.
*               j=1                      j=1
*
*  This allows decreasing the ratio beta[i] / alfa[i] for each row of
*  the matrix.
*
*  Columns are scaled as follows:
*
*     a'[i,j] = a[i,j] / sqrt(alfa[j] * beta[j]),  j = 1,...,n,
*
*  where:
*                m                        m
*     alfa[j] = min |a[i,j]|,  beta[j] = max |a[i,j]|.
*               i=1                      i=1
*
*  This allows decreasing the ratio beta[j] / alfa[j] for each column
*  of the matrix. */

static void gm_scaling(glp_prob *lp, int flag)
{     int i, j, pass;
      double temp;
      xassert(flag == 0 || flag == 1);
      for (pass = 0; pass <= 1; pass++)
      {  if (pass == flag)
         {  /* scale rows */
            for (i = 1; i <= lp->m; i++)
            {  temp = min_row_aij(lp, i, 1) * max_row_aij(lp, i, 1);
               glp_set_rii(lp, i, glp_get_rii(lp, i) / sqrt(temp));
            }
         }
         else
         {  /* scale columns */
            for (j = 1; j <= lp->n; j++)
            {  temp = min_col_aij(lp, j, 1) * max_col_aij(lp, j, 1);
               glp_set_sjj(lp, j, glp_get_sjj(lp, j) / sqrt(temp));
            }
         }
      }
      return;
}

/***********************************************************************
*  max_row_ratio - determine worst scaling "quality" for rows
*
*  This routine returns the worst scaling "quality" for rows of the
*  currently scaled constraint matrix:
*
*              m
*     ratio = max ratio[i],
*             i=1
*  where:
*                 n              n
*     ratio[i] = max |a[i,j]| / min |a[i,j]|,  1 <= i <= m,
*                j=1            j=1
*
*  is the scaling "quality" of i-th row. */

static double max_row_ratio(glp_prob *lp)
{     int i;
      double ratio, temp;
      ratio = 1.0;
      for (i = 1; i <= lp->m; i++)
      {  temp = max_row_aij(lp, i, 1) / min_row_aij(lp, i, 1);
         if (i == 1 || ratio < temp) ratio = temp;
      }
      return ratio;
}

/***********************************************************************
*  max_col_ratio - determine worst scaling "quality" for columns
*
*  This routine returns the worst scaling "quality" for columns of the
*  currently scaled constraint matrix:
*
*              n
*     ratio = max ratio[j],
*             j=1
*  where:
*                 m              m
*     ratio[j] = max |a[i,j]| / min |a[i,j]|,  1 <= j <= n,
*                i=1            i=1
*
*  is the scaling "quality" of j-th column. */

static double max_col_ratio(glp_prob *lp)
{     int j;
      double ratio, temp;
      ratio = 1.0;
      for (j = 1; j <= lp->n; j++)
      {  temp = max_col_aij(lp, j, 1) / min_col_aij(lp, j, 1);
         if (j == 1 || ratio < temp) ratio = temp;
      }
      return ratio;
}

/***********************************************************************
*  gm_iterate - perform iterative geometric mean scaling
*
*  This routine performs iterative geometric mean scaling of rows and
*  columns of the constraint matrix.
*
*  The parameter it_max specifies the maximal number of iterations.
*  Recommended value of it_max is 15.
*
*  The parameter tau specifies a minimal improvement of the scaling
*  "quality" on each iteration, 0 < tau < 1. It means than the scaling
*  process continues while the following condition is satisfied:
*
*     ratio[k] <= tau * ratio[k-1],
*
*  where ratio = max |a[i,j]| / min |a[i,j]| is the scaling "quality"
*  to be minimized, k is the iteration number. Recommended value of tau
*  is 0.90. */

static void gm_iterate(glp_prob *lp, int it_max, double tau)
{     int k, flag;
      double ratio = 0.0, r_old;
      /* if the scaling "quality" for rows is better than for columns,
         the rows are scaled first; otherwise, the columns are scaled
         first */
      flag = (max_row_ratio(lp) > max_col_ratio(lp));
      for (k = 1; k <= it_max; k++)
      {  /* save the scaling "quality" from previous iteration */
         r_old = ratio;
         /* determine the current scaling "quality" */
         ratio = max_mat_aij(lp, 1) / min_mat_aij(lp, 1);
#if 0
         xprintf("k = %d; ratio = %g\n", k, ratio);
#endif
         /* if improvement is not enough, terminate scaling */
         if (k > 1 && ratio > tau * r_old) break;
         /* otherwise, perform another iteration */
         gm_scaling(lp, flag);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  scale_prob - scale problem data
*
*  SYNOPSIS
*
*  #include "glpscl.h"
*  void scale_prob(glp_prob *lp, int flags);
*
*  DESCRIPTION
*
*  The routine scale_prob performs automatic scaling of problem data
*  for the specified problem object. */

static void scale_prob(glp_prob *lp, int flags)
{     static const char *fmt =
         "%s: min|aij| = %10.3e  max|aij| = %10.3e  ratio = %10.3e\n";
      double min_aij, max_aij, ratio;
      xprintf("Scaling...\n");
      /* cancel the current scaling effect */
      glp_unscale_prob(lp);
      /* report original scaling "quality" */
      min_aij = min_mat_aij(lp, 1);
      max_aij = max_mat_aij(lp, 1);
      ratio = max_aij / min_aij;
      xprintf(fmt, " A", min_aij, max_aij, ratio);
      /* check if the problem is well scaled */
      if (min_aij >= 0.10 && max_aij <= 10.0)
      {  xprintf("Problem data seem to be well scaled\n");
         /* skip scaling, if required */
         if (flags & GLP_SF_SKIP) goto done;
      }
      /* perform iterative geometric mean scaling, if required */
      if (flags & GLP_SF_GM)
      {  gm_iterate(lp, 15, 0.90);
         min_aij = min_mat_aij(lp, 1);
         max_aij = max_mat_aij(lp, 1);
         ratio = max_aij / min_aij;
         xprintf(fmt, "GM", min_aij, max_aij, ratio);
      }
      /* perform equilibration scaling, if required */
      if (flags & GLP_SF_EQ)
      {  eq_scaling(lp, max_row_ratio(lp) > max_col_ratio(lp));
         min_aij = min_mat_aij(lp, 1);
         max_aij = max_mat_aij(lp, 1);
         ratio = max_aij / min_aij;
         xprintf(fmt, "EQ", min_aij, max_aij, ratio);
      }
      /* round scale factors to nearest power of two, if required */
      if (flags & GLP_SF_2N)
      {  int i, j;
         for (i = 1; i <= lp->m; i++)
            glp_set_rii(lp, i, round2n(glp_get_rii(lp, i)));
         for (j = 1; j <= lp->n; j++)
            glp_set_sjj(lp, j, round2n(glp_get_sjj(lp, j)));
         min_aij = min_mat_aij(lp, 1);
         max_aij = max_mat_aij(lp, 1);
         ratio = max_aij / min_aij;
         xprintf(fmt, "2N", min_aij, max_aij, ratio);
      }
done: return;
}

/***********************************************************************
*  NAME
*
*  glp_scale_prob - scale problem data
*
*  SYNOPSIS
*
*  void glp_scale_prob(glp_prob *lp, int flags);
*
*  DESCRIPTION
*
*  The routine glp_scale_prob performs automatic scaling of problem
*  data for the specified problem object.
*
*  The parameter flags specifies scaling options used by the routine.
*  Options can be combined with the bitwise OR operator and may be the
*  following:
*
*  GLP_SF_GM      perform geometric mean scaling;
*  GLP_SF_EQ      perform equilibration scaling;
*  GLP_SF_2N      round scale factors to nearest power of two;
*  GLP_SF_SKIP    skip scaling, if the problem is well scaled.
*
*  The parameter flags may be specified as GLP_SF_AUTO, in which case
*  the routine chooses scaling options automatically. */

void glp_scale_prob(glp_prob *lp, int flags)
{     if (flags & ~(GLP_SF_GM | GLP_SF_EQ | GLP_SF_2N | GLP_SF_SKIP |
                    GLP_SF_AUTO))
         xerror("glp_scale_prob: flags = 0x%02X; invalid scaling option"
            "s\n", flags);
      if (flags & GLP_SF_AUTO)
         flags = (GLP_SF_GM | GLP_SF_EQ | GLP_SF_SKIP);
      scale_prob(lp, flags);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpssx.h0000644000175100001710000004053300000000000024702 0ustar00runnerdocker00000000000000/* glpssx.h (simplex method, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef GLPSSX_H
#define GLPSSX_H

#include "bfx.h"
#include "env.h"
#if 1 /* 25/XI-2017 */
#include "glpk.h"
#endif

typedef struct SSX SSX;

struct SSX
{     /* simplex solver workspace */
/*----------------------------------------------------------------------
// LP PROBLEM DATA
//
// It is assumed that LP problem has the following statement:
//
//    minimize (or maximize)
//
//       z = c[1]*x[1] + ... + c[m+n]*x[m+n] + c[0]                  (1)
//
//    subject to equality constraints
//
//       x[1] - a[1,1]*x[m+1] - ... - a[1,n]*x[m+n] = 0
//
//          .  .  .  .  .  .  .                                      (2)
//
//       x[m] - a[m,1]*x[m+1] + ... - a[m,n]*x[m+n] = 0
//
//    and bounds of variables
//
//         l[1] <= x[1]   <= u[1]
//
//          .  .  .  .  .  .  .                                      (3)
//
//       l[m+n] <= x[m+n] <= u[m+n]
//
// where:
// x[1], ..., x[m]      - auxiliary variables;
// x[m+1], ..., x[m+n]  - structural variables;
// z                    - objective function;
// c[1], ..., c[m+n]    - coefficients of the objective function;
// c[0]                 - constant term of the objective function;
// a[1,1], ..., a[m,n]  - constraint coefficients;
// l[1], ..., l[m+n]    - lower bounds of variables;
// u[1], ..., u[m+n]    - upper bounds of variables.
//
// Bounds of variables can be finite as well as inifinite. Besides,
// lower and upper bounds can be equal to each other. So the following
// five types of variables are possible:
//
//    Bounds of variable      Type of variable
//    -------------------------------------------------
//    -inf <  x[k] <  +inf    Free (unbounded) variable
//    l[k] <= x[k] <  +inf    Variable with lower bound
//    -inf <  x[k] <= u[k]    Variable with upper bound
//    l[k] <= x[k] <= u[k]    Double-bounded variable
//    l[k] =  x[k] =  u[k]    Fixed variable
//
// Using vector-matrix notations the LP problem (1)-(3) can be written
// as follows:
//
//    minimize (or maximize)
//
//       z = c * x + c[0]                                            (4)
//
//    subject to equality constraints
//
//       xR - A * xS = 0                                             (5)
//
//    and bounds of variables
//
//       l <= x <= u                                                 (6)
//
// where:
// xR                   - vector of auxiliary variables;
// xS                   - vector of structural variables;
// x = (xR, xS)         - vector of all variables;
// z                    - objective function;
// c                    - vector of objective coefficients;
// c[0]                 - constant term of the objective function;
// A                    - matrix of constraint coefficients (has m rows
//                        and n columns);
// l                    - vector of lower bounds of variables;
// u                    - vector of upper bounds of variables.
//
// The simplex method makes no difference between auxiliary and
// structural variables, so it is convenient to think the system of
// equality constraints (5) written in a homogeneous form:
//
//    (I | -A) * x = 0,                                              (7)
//
// where (I | -A) is an augmented (m+n)xm constraint matrix, I is mxm
// unity matrix whose columns correspond to auxiliary variables, and A
// is the original mxn constraint matrix whose columns correspond to
// structural variables. Note that only the matrix A is stored.
----------------------------------------------------------------------*/
      int m;
      /* number of rows (auxiliary variables), m > 0 */
      int n;
      /* number of columns (structural variables), n > 0 */
      int *type; /* int type[1+m+n]; */
      /* type[0] is not used;
         type[k], 1 <= k <= m+n, is the type of variable x[k]: */
#define SSX_FR          0     /* free (unbounded) variable */
#define SSX_LO          1     /* variable with lower bound */
#define SSX_UP          2     /* variable with upper bound */
#define SSX_DB          3     /* double-bounded variable */
#define SSX_FX          4     /* fixed variable */
      mpq_t *lb; /* mpq_t lb[1+m+n]; alias: l */
      /* lb[0] is not used;
         lb[k], 1 <= k <= m+n, is an lower bound of variable x[k];
         if x[k] has no lower bound, lb[k] is zero */
      mpq_t *ub; /* mpq_t ub[1+m+n]; alias: u */
      /* ub[0] is not used;
         ub[k], 1 <= k <= m+n, is an upper bound of variable x[k];
         if x[k] has no upper bound, ub[k] is zero;
         if x[k] is of fixed type, ub[k] is equal to lb[k] */
      int dir;
      /* optimization direction (sense of the objective function): */
#define SSX_MIN         0     /* minimization */
#define SSX_MAX         1     /* maximization */
      mpq_t *coef; /* mpq_t coef[1+m+n]; alias: c */
      /* coef[0] is a constant term of the objective function;
         coef[k], 1 <= k <= m+n, is a coefficient of the objective
         function at variable x[k];
         note that auxiliary variables also may have non-zero objective
         coefficients */
      int *A_ptr; /* int A_ptr[1+n+1]; */
      int *A_ind; /* int A_ind[A_ptr[n+1]]; */
      mpq_t *A_val; /* mpq_t A_val[A_ptr[n+1]]; */
      /* constraint matrix A (see (5)) in storage-by-columns format */
/*----------------------------------------------------------------------
// LP BASIS AND CURRENT BASIC SOLUTION
//
// The LP basis is defined by the following partition of the augmented
// constraint matrix (7):
//
//    (B | N) = (I | -A) * Q,                                        (8)
//
// where B is a mxm non-singular basis matrix whose columns correspond
// to basic variables xB, N is a mxn matrix whose columns correspond to
// non-basic variables xN, and Q is a permutation (m+n)x(m+n) matrix.
//
// From (7) and (8) it follows that
//
//    (I | -A) * x = (I | -A) * Q * Q' * x = (B | N) * (xB, xN),
//
// therefore
//
//    (xB, xN) = Q' * x,                                             (9)
//
// where x is the vector of all variables in the original order, xB is
// a vector of basic variables, xN is a vector of non-basic variables,
// Q' = inv(Q) is a matrix transposed to Q.
//
// Current values of non-basic variables xN[j], j = 1, ..., n, are not
// stored; they are defined implicitly by their statuses as follows:
//
//    0,             if xN[j] is free variable
//    lN[j],         if xN[j] is on its lower bound                 (10)
//    uN[j],         if xN[j] is on its upper bound
//    lN[j] = uN[j], if xN[j] is fixed variable
//
// where lN[j] and uN[j] are lower and upper bounds of xN[j].
//
// Current values of basic variables xB[i], i = 1, ..., m, are computed
// as follows:
//
//    beta = - inv(B) * N * xN,                                     (11)
//
// where current values of xN are defined by (10).
//
// Current values of simplex multipliers pi[i], i = 1, ..., m (which
// are values of Lagrange multipliers for equality constraints (7) also
// called shadow prices) are computed as follows:
//
//    pi = inv(B') * cB,                                            (12)
//
// where B' is a matrix transposed to B, cB is a vector of objective
// coefficients at basic variables xB.
//
// Current values of reduced costs d[j], j = 1, ..., n, (which are
// values of Langrange multipliers for active inequality constraints
// corresponding to non-basic variables) are computed as follows:
//
//    d = cN - N' * pi,                                             (13)
//
// where N' is a matrix transposed to N, cN is a vector of objective
// coefficients at non-basic variables xN.
----------------------------------------------------------------------*/
      int *stat; /* int stat[1+m+n]; */
      /* stat[0] is not used;
         stat[k], 1 <= k <= m+n, is the status of variable x[k]: */
#define SSX_BS          0     /* basic variable */
#define SSX_NL          1     /* non-basic variable on lower bound */
#define SSX_NU          2     /* non-basic variable on upper bound */
#define SSX_NF          3     /* non-basic free variable */
#define SSX_NS          4     /* non-basic fixed variable */
      int *Q_row; /* int Q_row[1+m+n]; */
      /* matrix Q in row-like format;
         Q_row[0] is not used;
         Q_row[i] = j means that q[i,j] = 1 */
      int *Q_col; /* int Q_col[1+m+n]; */
      /* matrix Q in column-like format;
         Q_col[0] is not used;
         Q_col[j] = i means that q[i,j] = 1 */
      /* if k-th column of the matrix (I | A) is k'-th column of the
         matrix (B | N), then Q_row[k] = k' and Q_col[k'] = k;
         if x[k] is xB[i], then Q_row[k] = i and Q_col[i] = k;
         if x[k] is xN[j], then Q_row[k] = m+j and Q_col[m+j] = k */
      BFX *binv;
      /* invertable form of the basis matrix B */
      mpq_t *bbar; /* mpq_t bbar[1+m]; alias: beta */
      /* bbar[0] is a value of the objective function;
         bbar[i], 1 <= i <= m, is a value of basic variable xB[i] */
      mpq_t *pi; /* mpq_t pi[1+m]; */
      /* pi[0] is not used;
         pi[i], 1 <= i <= m, is a simplex multiplier corresponding to
         i-th row (equality constraint) */
      mpq_t *cbar; /* mpq_t cbar[1+n]; alias: d */
      /* cbar[0] is not used;
         cbar[j], 1 <= j <= n, is a reduced cost of non-basic variable
         xN[j] */
/*----------------------------------------------------------------------
// SIMPLEX TABLE
//
// Due to (8) and (9) the system of equality constraints (7) for the
// current basis can be written as follows:
//
//    xB = A~ * xN,                                                 (14)
//
// where
//
//    A~ = - inv(B) * N                                             (15)
//
// is a mxn matrix called the simplex table.
//
// The revised simplex method uses only two components of A~, namely,
// pivot column corresponding to non-basic variable xN[q] chosen to
// enter the basis, and pivot row corresponding to basic variable xB[p]
// chosen to leave the basis.
//
// Pivot column alfa_q is q-th column of A~, so
//
//    alfa_q = A~ * e[q] = - inv(B) * N * e[q] = - inv(B) * N[q],   (16)
//
// where N[q] is q-th column of the matrix N.
//
// Pivot row alfa_p is p-th row of A~ or, equivalently, p-th column of
// A~', a matrix transposed to A~, so
//
//    alfa_p = A~' * e[p] = - N' * inv(B') * e[p] = - N' * rho_p,   (17)
//
// where (*)' means transposition, and
//
//    rho_p = inv(B') * e[p],                                       (18)
//
// is p-th column of inv(B') or, that is the same, p-th row of inv(B).
----------------------------------------------------------------------*/
      int p;
      /* number of basic variable xB[p], 1 <= p <= m, chosen to leave
         the basis */
      mpq_t *rho; /* mpq_t rho[1+m]; */
      /* p-th row of the inverse inv(B); see (18) */
      mpq_t *ap; /* mpq_t ap[1+n]; */
      /* p-th row of the simplex table; see (17) */
      int q;
      /* number of non-basic variable xN[q], 1 <= q <= n, chosen to
         enter the basis */
      mpq_t *aq; /* mpq_t aq[1+m]; */
      /* q-th column of the simplex table; see (16) */
/*--------------------------------------------------------------------*/
      int q_dir;
      /* direction in which non-basic variable xN[q] should change on
         moving to the adjacent vertex of the polyhedron:
         +1 means that xN[q] increases
         -1 means that xN[q] decreases */
      int p_stat;
      /* non-basic status which should be assigned to basic variable
         xB[p] when it has left the basis and become xN[q] */
      mpq_t delta;
      /* actual change of xN[q] in the adjacent basis (it has the same
         sign as q_dir) */
/*--------------------------------------------------------------------*/
#if 1 /* 25/XI-2017 */
      int msg_lev;
      /* verbosity level:
         GLP_MSG_OFF no output
         GLP_MSG_ERR report errors and warnings
         GLP_MSG_ON  normal output
         GLP_MSG_ALL highest verbosity */
#endif
      int it_lim;
      /* simplex iterations limit; if this value is positive, it is
         decreased by one each time when one simplex iteration has been
         performed, and reaching zero value signals the solver to stop
         the search; negative value means no iterations limit */
      int it_cnt;
      /* simplex iterations count; this count is increased by one each
         time when one simplex iteration has been performed */
      double tm_lim;
      /* searching time limit, in seconds; if this value is positive,
         it is decreased each time when one simplex iteration has been
         performed by the amount of time spent for the iteration, and
         reaching zero value signals the solver to stop the search;
         negative value means no time limit */
      double out_frq;
      /* output frequency, in seconds; this parameter specifies how
         frequently the solver sends information about the progress of
         the search to the standard output */
#if 0 /* 10/VI-2013 */
      glp_long tm_beg;
#else
      double tm_beg;
#endif
      /* starting time of the search, in seconds; the total time of the
         search is the difference between xtime() and tm_beg */
#if 0 /* 10/VI-2013 */
      glp_long tm_lag;
#else
      double tm_lag;
#endif
      /* the most recent time, in seconds, at which the progress of the
         the search was displayed */
};

#define ssx_create            _glp_ssx_create
#define ssx_factorize         _glp_ssx_factorize
#define ssx_get_xNj           _glp_ssx_get_xNj
#define ssx_eval_bbar         _glp_ssx_eval_bbar
#define ssx_eval_pi           _glp_ssx_eval_pi
#define ssx_eval_dj           _glp_ssx_eval_dj
#define ssx_eval_cbar         _glp_ssx_eval_cbar
#define ssx_eval_rho          _glp_ssx_eval_rho
#define ssx_eval_row          _glp_ssx_eval_row
#define ssx_eval_col          _glp_ssx_eval_col
#define ssx_chuzc             _glp_ssx_chuzc
#define ssx_chuzr             _glp_ssx_chuzr
#define ssx_update_bbar       _glp_ssx_update_bbar
#define ssx_update_pi         _glp_ssx_update_pi
#define ssx_update_cbar       _glp_ssx_update_cbar
#define ssx_change_basis      _glp_ssx_change_basis
#define ssx_delete            _glp_ssx_delete

#define ssx_phase_I           _glp_ssx_phase_I
#define ssx_phase_II          _glp_ssx_phase_II
#define ssx_driver            _glp_ssx_driver

SSX *ssx_create(int m, int n, int nnz);
/* create simplex solver workspace */

int ssx_factorize(SSX *ssx);
/* factorize the current basis matrix */

void ssx_get_xNj(SSX *ssx, int j, mpq_t x);
/* determine value of non-basic variable */

void ssx_eval_bbar(SSX *ssx);
/* compute values of basic variables */

void ssx_eval_pi(SSX *ssx);
/* compute values of simplex multipliers */

void ssx_eval_dj(SSX *ssx, int j, mpq_t dj);
/* compute reduced cost of non-basic variable */

void ssx_eval_cbar(SSX *ssx);
/* compute reduced costs of all non-basic variables */

void ssx_eval_rho(SSX *ssx);
/* compute p-th row of the inverse */

void ssx_eval_row(SSX *ssx);
/* compute pivot row of the simplex table */

void ssx_eval_col(SSX *ssx);
/* compute pivot column of the simplex table */

void ssx_chuzc(SSX *ssx);
/* choose pivot column */

void ssx_chuzr(SSX *ssx);
/* choose pivot row */

void ssx_update_bbar(SSX *ssx);
/* update values of basic variables */

void ssx_update_pi(SSX *ssx);
/* update simplex multipliers */

void ssx_update_cbar(SSX *ssx);
/* update reduced costs of non-basic variables */

void ssx_change_basis(SSX *ssx);
/* change current basis to adjacent one */

void ssx_delete(SSX *ssx);
/* delete simplex solver workspace */

int ssx_phase_I(SSX *ssx);
/* find primal feasible solution */

int ssx_phase_II(SSX *ssx);
/* find optimal solution */

int ssx_driver(SSX *ssx);
/* base driver to exact simplex method */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpssx01.c0000644000175100001710000006601500000000000025041 0ustar00runnerdocker00000000000000/* glpssx01.c (simplex method, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpssx.h"
#define xfault xerror

/*----------------------------------------------------------------------
// ssx_create - create simplex solver workspace.
//
// This routine creates the workspace used by simplex solver routines,
// and returns a pointer to it.
//
// Parameters m, n, and nnz specify, respectively, the number of rows,
// columns, and non-zero constraint coefficients.
//
// This routine only allocates the memory for the workspace components,
// so the workspace needs to be saturated by data. */

SSX *ssx_create(int m, int n, int nnz)
{     SSX *ssx;
      int i, j, k;
      if (m < 1)
         xfault("ssx_create: m = %d; invalid number of rows\n", m);
      if (n < 1)
         xfault("ssx_create: n = %d; invalid number of columns\n", n);
      if (nnz < 0)
         xfault("ssx_create: nnz = %d; invalid number of non-zero const"
            "raint coefficients\n", nnz);
      ssx = xmalloc(sizeof(SSX));
      ssx->m = m;
      ssx->n = n;
      ssx->type = xcalloc(1+m+n, sizeof(int));
      ssx->lb = xcalloc(1+m+n, sizeof(mpq_t));
      for (k = 1; k <= m+n; k++) mpq_init(ssx->lb[k]);
      ssx->ub = xcalloc(1+m+n, sizeof(mpq_t));
      for (k = 1; k <= m+n; k++) mpq_init(ssx->ub[k]);
      ssx->coef = xcalloc(1+m+n, sizeof(mpq_t));
      for (k = 0; k <= m+n; k++) mpq_init(ssx->coef[k]);
      ssx->A_ptr = xcalloc(1+n+1, sizeof(int));
      ssx->A_ptr[n+1] = nnz+1;
      ssx->A_ind = xcalloc(1+nnz, sizeof(int));
      ssx->A_val = xcalloc(1+nnz, sizeof(mpq_t));
      for (k = 1; k <= nnz; k++) mpq_init(ssx->A_val[k]);
      ssx->stat = xcalloc(1+m+n, sizeof(int));
      ssx->Q_row = xcalloc(1+m+n, sizeof(int));
      ssx->Q_col = xcalloc(1+m+n, sizeof(int));
      ssx->binv = bfx_create_binv();
      ssx->bbar = xcalloc(1+m, sizeof(mpq_t));
      for (i = 0; i <= m; i++) mpq_init(ssx->bbar[i]);
      ssx->pi = xcalloc(1+m, sizeof(mpq_t));
      for (i = 1; i <= m; i++) mpq_init(ssx->pi[i]);
      ssx->cbar = xcalloc(1+n, sizeof(mpq_t));
      for (j = 1; j <= n; j++) mpq_init(ssx->cbar[j]);
      ssx->rho = xcalloc(1+m, sizeof(mpq_t));
      for (i = 1; i <= m; i++) mpq_init(ssx->rho[i]);
      ssx->ap = xcalloc(1+n, sizeof(mpq_t));
      for (j = 1; j <= n; j++) mpq_init(ssx->ap[j]);
      ssx->aq = xcalloc(1+m, sizeof(mpq_t));
      for (i = 1; i <= m; i++) mpq_init(ssx->aq[i]);
      mpq_init(ssx->delta);
      return ssx;
}

/*----------------------------------------------------------------------
// ssx_factorize - factorize the current basis matrix.
//
// This routine computes factorization of the current basis matrix B
// and returns the singularity flag. If the matrix B is non-singular,
// the flag is zero, otherwise non-zero. */

static int basis_col(void *info, int j, int ind[], mpq_t val[])
{     /* this auxiliary routine provides row indices and numeric values
         of non-zero elements in j-th column of the matrix B */
      SSX *ssx = info;
      int m = ssx->m;
      int n = ssx->n;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      int k, len, ptr;
      xassert(1 <= j && j <= m);
      k = Q_col[j]; /* x[k] = xB[j] */
      xassert(1 <= k && k <= m+n);
      /* j-th column of the matrix B is k-th column of the augmented
         constraint matrix (I | -A) */
      if (k <= m)
      {  /* it is a column of the unity matrix I */
         len = 1, ind[1] = k, mpq_set_si(val[1], 1, 1);
      }
      else
      {  /* it is a column of the original constraint matrix -A */
         len = 0;
         for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
         {  len++;
            ind[len] = A_ind[ptr];
            mpq_neg(val[len], A_val[ptr]);
         }
      }
      return len;
}

int ssx_factorize(SSX *ssx)
{     int ret;
      ret = bfx_factorize(ssx->binv, ssx->m, basis_col, ssx);
      return ret;
}

/*----------------------------------------------------------------------
// ssx_get_xNj - determine value of non-basic variable.
//
// This routine determines the value of non-basic variable xN[j] in the
// current basic solution defined as follows:
//
//    0,             if xN[j] is free variable
//    lN[j],         if xN[j] is on its lower bound
//    uN[j],         if xN[j] is on its upper bound
//    lN[j] = uN[j], if xN[j] is fixed variable
//
// where lN[j] and uN[j] are lower and upper bounds of xN[j]. */

void ssx_get_xNj(SSX *ssx, int j, mpq_t x)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *lb = ssx->lb;
      mpq_t *ub = ssx->ub;
      int *stat = ssx->stat;
      int *Q_col = ssx->Q_col;
      int k;
      xassert(1 <= j && j <= n);
      k = Q_col[m+j]; /* x[k] = xN[j] */
      xassert(1 <= k && k <= m+n);
      switch (stat[k])
      {  case SSX_NL:
            /* xN[j] is on its lower bound */
            mpq_set(x, lb[k]); break;
         case SSX_NU:
            /* xN[j] is on its upper bound */
            mpq_set(x, ub[k]); break;
         case SSX_NF:
            /* xN[j] is free variable */
            mpq_set_si(x, 0, 1); break;
         case SSX_NS:
            /* xN[j] is fixed variable */
            mpq_set(x, lb[k]); break;
         default:
            xassert(stat != stat);
      }
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_bbar - compute values of basic variables.
//
// This routine computes values of basic variables xB in the current
// basic solution as follows:
//
//    beta = - inv(B) * N * xN,
//
// where B is the basis matrix, N is the matrix of non-basic columns,
// xN is a vector of current values of non-basic variables. */

void ssx_eval_bbar(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *coef = ssx->coef;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      mpq_t *bbar = ssx->bbar;
      int i, j, k, ptr;
      mpq_t x, temp;
      mpq_init(x);
      mpq_init(temp);
      /* bbar := 0 */
      for (i = 1; i <= m; i++)
         mpq_set_si(bbar[i], 0, 1);
      /* bbar := - N * xN = - N[1] * xN[1] - ... - N[n] * xN[n] */
      for (j = 1; j <= n; j++)
      {  ssx_get_xNj(ssx, j, x);
         if (mpq_sgn(x) == 0) continue;
         k = Q_col[m+j]; /* x[k] = xN[j] */
         if (k <= m)
         {  /* N[j] is a column of the unity matrix I */
            mpq_sub(bbar[k], bbar[k], x);
         }
         else
         {  /* N[j] is a column of the original constraint matrix -A */
            for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
            {  mpq_mul(temp, A_val[ptr], x);
               mpq_add(bbar[A_ind[ptr]], bbar[A_ind[ptr]], temp);
            }
         }
      }
      /* bbar := inv(B) * bbar */
      bfx_ftran(ssx->binv, bbar, 0);
#if 1
      /* compute value of the objective function */
      /* bbar[0] := c[0] */
      mpq_set(bbar[0], coef[0]);
      /* bbar[0] := bbar[0] + sum{i in B} cB[i] * xB[i] */
      for (i = 1; i <= m; i++)
      {  k = Q_col[i]; /* x[k] = xB[i] */
         if (mpq_sgn(coef[k]) == 0) continue;
         mpq_mul(temp, coef[k], bbar[i]);
         mpq_add(bbar[0], bbar[0], temp);
      }
      /* bbar[0] := bbar[0] + sum{j in N} cN[j] * xN[j] */
      for (j = 1; j <= n; j++)
      {  k = Q_col[m+j]; /* x[k] = xN[j] */
         if (mpq_sgn(coef[k]) == 0) continue;
         ssx_get_xNj(ssx, j, x);
         mpq_mul(temp, coef[k], x);
         mpq_add(bbar[0], bbar[0], temp);
      }
#endif
      mpq_clear(x);
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_pi - compute values of simplex multipliers.
//
// This routine computes values of simplex multipliers (shadow prices)
// pi in the current basic solution as follows:
//
//    pi = inv(B') * cB,
//
// where B' is a matrix transposed to the basis matrix B, cB is a vector
// of objective coefficients at basic variables xB. */

void ssx_eval_pi(SSX *ssx)
{     int m = ssx->m;
      mpq_t *coef = ssx->coef;
      int *Q_col = ssx->Q_col;
      mpq_t *pi = ssx->pi;
      int i;
      /* pi := cB */
      for (i = 1; i <= m; i++) mpq_set(pi[i], coef[Q_col[i]]);
      /* pi := inv(B') * cB */
      bfx_btran(ssx->binv, pi);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_dj - compute reduced cost of non-basic variable.
//
// This routine computes reduced cost d[j] of non-basic variable xN[j]
// in the current basic solution as follows:
//
//    d[j] = cN[j] - N[j] * pi,
//
// where cN[j] is an objective coefficient at xN[j], N[j] is a column
// of the augmented constraint matrix (I | -A) corresponding to xN[j],
// pi is the vector of simplex multipliers (shadow prices). */

void ssx_eval_dj(SSX *ssx, int j, mpq_t dj)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *coef = ssx->coef;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      mpq_t *pi = ssx->pi;
      int k, ptr, end;
      mpq_t temp;
      mpq_init(temp);
      xassert(1 <= j && j <= n);
      k = Q_col[m+j]; /* x[k] = xN[j] */
      xassert(1 <= k && k <= m+n);
      /* j-th column of the matrix N is k-th column of the augmented
         constraint matrix (I | -A) */
      if (k <= m)
      {  /* it is a column of the unity matrix I */
         mpq_sub(dj, coef[k], pi[k]);
      }
      else
      {  /* it is a column of the original constraint matrix -A */
         mpq_set(dj, coef[k]);
         for (ptr = A_ptr[k-m], end = A_ptr[k-m+1]; ptr < end; ptr++)
         {  mpq_mul(temp, A_val[ptr], pi[A_ind[ptr]]);
            mpq_add(dj, dj, temp);
         }
      }
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_cbar - compute reduced costs of all non-basic variables.
//
// This routine computes the vector of reduced costs pi in the current
// basic solution for all non-basic variables, including fixed ones. */

void ssx_eval_cbar(SSX *ssx)
{     int n = ssx->n;
      mpq_t *cbar = ssx->cbar;
      int j;
      for (j = 1; j <= n; j++)
         ssx_eval_dj(ssx, j, cbar[j]);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_rho - compute p-th row of the inverse.
//
// This routine computes p-th row of the matrix inv(B), where B is the
// current basis matrix.
//
// p-th row of the inverse is computed using the following formula:
//
//    rho = inv(B') * e[p],
//
// where B' is a matrix transposed to B, e[p] is a unity vector, which
// contains one in p-th position. */

void ssx_eval_rho(SSX *ssx)
{     int m = ssx->m;
      int p = ssx->p;
      mpq_t *rho = ssx->rho;
      int i;
      xassert(1 <= p && p <= m);
      /* rho := 0 */
      for (i = 1; i <= m; i++) mpq_set_si(rho[i], 0, 1);
      /* rho := e[p] */
      mpq_set_si(rho[p], 1, 1);
      /* rho := inv(B') * rho */
      bfx_btran(ssx->binv, rho);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_row - compute pivot row of the simplex table.
//
// This routine computes p-th (pivot) row of the current simplex table
// A~ = - inv(B) * N using the following formula:
//
//    A~[p] = - N' * inv(B') * e[p] = - N' * rho[p],
//
// where N' is a matrix transposed to the matrix N, rho[p] is p-th row
// of the inverse inv(B). */

void ssx_eval_row(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      mpq_t *rho = ssx->rho;
      mpq_t *ap = ssx->ap;
      int j, k, ptr;
      mpq_t temp;
      mpq_init(temp);
      for (j = 1; j <= n; j++)
      {  /* ap[j] := - N'[j] * rho (inner product) */
         k = Q_col[m+j]; /* x[k] = xN[j] */
         if (k <= m)
            mpq_neg(ap[j], rho[k]);
         else
         {  mpq_set_si(ap[j], 0, 1);
            for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
            {  mpq_mul(temp, A_val[ptr], rho[A_ind[ptr]]);
               mpq_add(ap[j], ap[j], temp);
            }
         }
      }
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_eval_col - compute pivot column of the simplex table.
//
// This routine computes q-th (pivot) column of the current simplex
// table A~ = - inv(B) * N using the following formula:
//
//    A~[q] = - inv(B) * N[q],
//
// where N[q] is q-th column of the matrix N corresponding to chosen
// non-basic variable xN[q]. */

void ssx_eval_col(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      int q = ssx->q;
      mpq_t *aq = ssx->aq;
      int i, k, ptr;
      xassert(1 <= q && q <= n);
      /* aq := 0 */
      for (i = 1; i <= m; i++) mpq_set_si(aq[i], 0, 1);
      /* aq := N[q] */
      k = Q_col[m+q]; /* x[k] = xN[q] */
      if (k <= m)
      {  /* N[q] is a column of the unity matrix I */
         mpq_set_si(aq[k], 1, 1);
      }
      else
      {  /* N[q] is a column of the original constraint matrix -A */
         for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
            mpq_neg(aq[A_ind[ptr]], A_val[ptr]);
      }
      /* aq := inv(B) * aq */
      bfx_ftran(ssx->binv, aq, 1);
      /* aq := - aq */
      for (i = 1; i <= m; i++) mpq_neg(aq[i], aq[i]);
      return;
}

/*----------------------------------------------------------------------
// ssx_chuzc - choose pivot column.
//
// This routine chooses non-basic variable xN[q] whose reduced cost
// indicates possible improving of the objective function to enter it
// in the basis.
//
// Currently the standard (textbook) pricing is used, i.e. that
// non-basic variable is preferred which has greatest reduced cost (in
// magnitude).
//
// If xN[q] has been chosen, the routine stores its number q and also
// sets the flag q_dir that indicates direction in which xN[q] has to
// change (+1 means increasing, -1 means decreasing).
//
// If the choice cannot be made, because the current basic solution is
// dual feasible, the routine sets the number q to 0. */

void ssx_chuzc(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int dir = (ssx->dir == SSX_MIN ? +1 : -1);
      int *Q_col = ssx->Q_col;
      int *stat = ssx->stat;
      mpq_t *cbar = ssx->cbar;
      int j, k, s, q, q_dir;
      double best, temp;
      /* nothing is chosen so far */
      q = 0, q_dir = 0, best = 0.0;
      /* look through the list of non-basic variables */
      for (j = 1; j <= n; j++)
      {  k = Q_col[m+j]; /* x[k] = xN[j] */
         s = dir * mpq_sgn(cbar[j]);
         if ((stat[k] == SSX_NF || stat[k] == SSX_NL) && s < 0 ||
             (stat[k] == SSX_NF || stat[k] == SSX_NU) && s > 0)
         {  /* reduced cost of xN[j] indicates possible improving of
               the objective function */
            temp = fabs(mpq_get_d(cbar[j]));
            xassert(temp != 0.0);
            if (q == 0 || best < temp)
               q = j, q_dir = - s, best = temp;
         }
      }
      ssx->q = q, ssx->q_dir = q_dir;
      return;
}

/*----------------------------------------------------------------------
// ssx_chuzr - choose pivot row.
//
// This routine looks through elements of q-th column of the simplex
// table and chooses basic variable xB[p] which should leave the basis.
//
// The choice is based on the standard (textbook) ratio test.
//
// If xB[p] has been chosen, the routine stores its number p and also
// sets its non-basic status p_stat which should be assigned to xB[p]
// when it has left the basis and become xN[q].
//
// Special case p < 0 means that xN[q] is double-bounded variable and
// it reaches its opposite bound before any basic variable does that,
// so the current basis remains unchanged.
//
// If the choice cannot be made, because xN[q] can infinitely change in
// the feasible direction, the routine sets the number p to 0. */

void ssx_chuzr(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int *type = ssx->type;
      mpq_t *lb = ssx->lb;
      mpq_t *ub = ssx->ub;
      int *Q_col = ssx->Q_col;
      mpq_t *bbar = ssx->bbar;
      int q = ssx->q;
      mpq_t *aq = ssx->aq;
      int q_dir = ssx->q_dir;
      int i, k, s, t, p, p_stat;
      mpq_t teta, temp;
      mpq_init(teta);
      mpq_init(temp);
      xassert(1 <= q && q <= n);
      xassert(q_dir == +1 || q_dir == -1);
      /* nothing is chosen so far */
      p = 0, p_stat = 0;
      /* look through the list of basic variables */
      for (i = 1; i <= m; i++)
      {  s = q_dir * mpq_sgn(aq[i]);
         if (s < 0)
         {  /* xB[i] decreases */
            k = Q_col[i]; /* x[k] = xB[i] */
            t = type[k];
            if (t == SSX_LO || t == SSX_DB || t == SSX_FX)
            {  /* xB[i] has finite lower bound */
               mpq_sub(temp, bbar[i], lb[k]);
               mpq_div(temp, temp, aq[i]);
               mpq_abs(temp, temp);
               if (p == 0 || mpq_cmp(teta, temp) > 0)
               {  p = i;
                  p_stat = (t == SSX_FX ? SSX_NS : SSX_NL);
                  mpq_set(teta, temp);
               }
            }
         }
         else if (s > 0)
         {  /* xB[i] increases */
            k = Q_col[i]; /* x[k] = xB[i] */
            t = type[k];
            if (t == SSX_UP || t == SSX_DB || t == SSX_FX)
            {  /* xB[i] has finite upper bound */
               mpq_sub(temp, bbar[i], ub[k]);
               mpq_div(temp, temp, aq[i]);
               mpq_abs(temp, temp);
               if (p == 0 || mpq_cmp(teta, temp) > 0)
               {  p = i;
                  p_stat = (t == SSX_FX ? SSX_NS : SSX_NU);
                  mpq_set(teta, temp);
               }
            }
         }
         /* if something has been chosen and the ratio test indicates
            exact degeneracy, the search can be finished */
         if (p != 0 && mpq_sgn(teta) == 0) break;
      }
      /* if xN[q] is double-bounded, check if it can reach its opposite
         bound before any basic variable */
      k = Q_col[m+q]; /* x[k] = xN[q] */
      if (type[k] == SSX_DB)
      {  mpq_sub(temp, ub[k], lb[k]);
         if (p == 0 || mpq_cmp(teta, temp) > 0)
         {  p = -1;
            p_stat = -1;
            mpq_set(teta, temp);
         }
      }
      ssx->p = p;
      ssx->p_stat = p_stat;
      /* if xB[p] has been chosen, determine its actual change in the
         adjacent basis (it has the same sign as q_dir) */
      if (p != 0)
      {  xassert(mpq_sgn(teta) >= 0);
         if (q_dir > 0)
            mpq_set(ssx->delta, teta);
         else
            mpq_neg(ssx->delta, teta);
      }
      mpq_clear(teta);
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_update_bbar - update values of basic variables.
//
// This routine recomputes the current values of basic variables for
// the adjacent basis.
//
// The simplex table for the current basis is the following:
//
//    xB[i] = sum{j in 1..n} alfa[i,j] * xN[q],  i = 1,...,m
//
// therefore
//
//    delta xB[i] = alfa[i,q] * delta xN[q],  i = 1,...,m
//
// where delta xN[q] = xN.new[q] - xN[q] is the change of xN[q] in the
// adjacent basis, and delta xB[i] = xB.new[i] - xB[i] is the change of
// xB[i]. This gives formulae for recomputing values of xB[i]:
//
//    xB.new[p] = xN[q] + delta xN[q]
//
// (because xN[q] becomes xB[p] in the adjacent basis), and
//
//    xB.new[i] = xB[i] + alfa[i,q] * delta xN[q],  i != p
//
// for other basic variables. */

void ssx_update_bbar(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *bbar = ssx->bbar;
      mpq_t *cbar = ssx->cbar;
      int p = ssx->p;
      int q = ssx->q;
      mpq_t *aq = ssx->aq;
      int i;
      mpq_t temp;
      mpq_init(temp);
      xassert(1 <= q && q <= n);
      if (p < 0)
      {  /* xN[q] is double-bounded and goes to its opposite bound */
         /* nop */;
      }
      else
      {  /* xN[q] becomes xB[p] in the adjacent basis */
         /* xB.new[p] = xN[q] + delta xN[q] */
         xassert(1 <= p && p <= m);
         ssx_get_xNj(ssx, q, temp);
         mpq_add(bbar[p], temp, ssx->delta);
      }
      /* update values of other basic variables depending on xN[q] */
      for (i = 1; i <= m; i++)
      {  if (i == p) continue;
         /* xB.new[i] = xB[i] + alfa[i,q] * delta xN[q] */
         if (mpq_sgn(aq[i]) == 0) continue;
         mpq_mul(temp, aq[i], ssx->delta);
         mpq_add(bbar[i], bbar[i], temp);
      }
#if 1
      /* update value of the objective function */
      /* z.new = z + d[q] * delta xN[q] */
      mpq_mul(temp, cbar[q], ssx->delta);
      mpq_add(bbar[0], bbar[0], temp);
#endif
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
-- ssx_update_pi - update simplex multipliers.
--
-- This routine recomputes the vector of simplex multipliers for the
-- adjacent basis. */

void ssx_update_pi(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *pi = ssx->pi;
      mpq_t *cbar = ssx->cbar;
      int p = ssx->p;
      int q = ssx->q;
      mpq_t *aq = ssx->aq;
      mpq_t *rho = ssx->rho;
      int i;
      mpq_t new_dq, temp;
      mpq_init(new_dq);
      mpq_init(temp);
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n);
      /* compute d[q] in the adjacent basis */
      mpq_div(new_dq, cbar[q], aq[p]);
      /* update the vector of simplex multipliers */
      for (i = 1; i <= m; i++)
      {  if (mpq_sgn(rho[i]) == 0) continue;
         mpq_mul(temp, new_dq, rho[i]);
         mpq_sub(pi[i], pi[i], temp);
      }
      mpq_clear(new_dq);
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_update_cbar - update reduced costs of non-basic variables.
//
// This routine recomputes the vector of reduced costs of non-basic
// variables for the adjacent basis. */

void ssx_update_cbar(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      mpq_t *cbar = ssx->cbar;
      int p = ssx->p;
      int q = ssx->q;
      mpq_t *ap = ssx->ap;
      int j;
      mpq_t temp;
      mpq_init(temp);
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n);
      /* compute d[q] in the adjacent basis */
      /* d.new[q] = d[q] / alfa[p,q] */
      mpq_div(cbar[q], cbar[q], ap[q]);
      /* update reduced costs of other non-basic variables */
      for (j = 1; j <= n; j++)
      {  if (j == q) continue;
         /* d.new[j] = d[j] - (alfa[p,j] / alfa[p,q]) * d[q] */
         if (mpq_sgn(ap[j]) == 0) continue;
         mpq_mul(temp, ap[j], cbar[q]);
         mpq_sub(cbar[j], cbar[j], temp);
      }
      mpq_clear(temp);
      return;
}

/*----------------------------------------------------------------------
// ssx_change_basis - change current basis to adjacent one.
//
// This routine changes the current basis to the adjacent one swapping
// basic variable xB[p] and non-basic variable xN[q]. */

void ssx_change_basis(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int *type = ssx->type;
      int *stat = ssx->stat;
      int *Q_row = ssx->Q_row;
      int *Q_col = ssx->Q_col;
      int p = ssx->p;
      int q = ssx->q;
      int p_stat = ssx->p_stat;
      int k, kp, kq;
      if (p < 0)
      {  /* special case: xN[q] goes to its opposite bound */
         xassert(1 <= q && q <= n);
         k = Q_col[m+q]; /* x[k] = xN[q] */
         xassert(type[k] == SSX_DB);
         switch (stat[k])
         {  case SSX_NL:
               stat[k] = SSX_NU;
               break;
            case SSX_NU:
               stat[k] = SSX_NL;
               break;
            default:
               xassert(stat != stat);
         }
      }
      else
      {  /* xB[p] leaves the basis, xN[q] enters the basis */
         xassert(1 <= p && p <= m);
         xassert(1 <= q && q <= n);
         kp = Q_col[p];   /* x[kp] = xB[p] */
         kq = Q_col[m+q]; /* x[kq] = xN[q] */
         /* check non-basic status of xB[p] which becomes xN[q] */
         switch (type[kp])
         {  case SSX_FR:
               xassert(p_stat == SSX_NF);
               break;
            case SSX_LO:
               xassert(p_stat == SSX_NL);
               break;
            case SSX_UP:
               xassert(p_stat == SSX_NU);
               break;
            case SSX_DB:
               xassert(p_stat == SSX_NL || p_stat == SSX_NU);
               break;
            case SSX_FX:
               xassert(p_stat == SSX_NS);
               break;
            default:
               xassert(type != type);
         }
         /* swap xB[p] and xN[q] */
         stat[kp] = (char)p_stat, stat[kq] = SSX_BS;
         Q_row[kp] = m+q, Q_row[kq] = p;
         Q_col[p] = kq, Q_col[m+q] = kp;
         /* update factorization of the basis matrix */
         if (bfx_update(ssx->binv, p))
         {  if (ssx_factorize(ssx))
               xassert(("Internal error: basis matrix is singular", 0));
         }
      }
      return;
}

/*----------------------------------------------------------------------
// ssx_delete - delete simplex solver workspace.
//
// This routine deletes the simplex solver workspace freeing all the
// memory allocated to this object. */

void ssx_delete(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int nnz = ssx->A_ptr[n+1]-1;
      int i, j, k;
      xfree(ssx->type);
      for (k = 1; k <= m+n; k++) mpq_clear(ssx->lb[k]);
      xfree(ssx->lb);
      for (k = 1; k <= m+n; k++) mpq_clear(ssx->ub[k]);
      xfree(ssx->ub);
      for (k = 0; k <= m+n; k++) mpq_clear(ssx->coef[k]);
      xfree(ssx->coef);
      xfree(ssx->A_ptr);
      xfree(ssx->A_ind);
      for (k = 1; k <= nnz; k++) mpq_clear(ssx->A_val[k]);
      xfree(ssx->A_val);
      xfree(ssx->stat);
      xfree(ssx->Q_row);
      xfree(ssx->Q_col);
      bfx_delete_binv(ssx->binv);
      for (i = 0; i <= m; i++) mpq_clear(ssx->bbar[i]);
      xfree(ssx->bbar);
      for (i = 1; i <= m; i++) mpq_clear(ssx->pi[i]);
      xfree(ssx->pi);
      for (j = 1; j <= n; j++) mpq_clear(ssx->cbar[j]);
      xfree(ssx->cbar);
      for (i = 1; i <= m; i++) mpq_clear(ssx->rho[i]);
      xfree(ssx->rho);
      for (j = 1; j <= n; j++) mpq_clear(ssx->ap[j]);
      xfree(ssx->ap);
      for (i = 1; i <= m; i++) mpq_clear(ssx->aq[i]);
      xfree(ssx->aq);
      mpq_clear(ssx->delta);
      xfree(ssx);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/glpssx02.c0000644000175100001710000004263000000000000025037 0ustar00runnerdocker00000000000000/* glpssx02.c (simplex method, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "glpssx.h"

static void show_progress(SSX *ssx, int phase)
{     /* this auxiliary routine displays information about progress of
         the search */
      int i, def = 0;
      for (i = 1; i <= ssx->m; i++)
         if (ssx->type[ssx->Q_col[i]] == SSX_FX) def++;
      xprintf("%s%6d:   %s = %22.15g   (%d)\n", phase == 1 ? " " : "*",
         ssx->it_cnt, phase == 1 ? "infsum" : "objval",
         mpq_get_d(ssx->bbar[0]), def);
#if 0
      ssx->tm_lag = utime();
#else
      ssx->tm_lag = xtime();
#endif
      return;
}

/*----------------------------------------------------------------------
// ssx_phase_I - find primal feasible solution.
//
// This routine implements phase I of the primal simplex method.
//
// On exit the routine returns one of the following codes:
//
// 0 - feasible solution found;
// 1 - problem has no feasible solution;
// 2 - iterations limit exceeded;
// 3 - time limit exceeded.
----------------------------------------------------------------------*/

int ssx_phase_I(SSX *ssx)
{     int m = ssx->m;
      int n = ssx->n;
      int *type = ssx->type;
      mpq_t *lb = ssx->lb;
      mpq_t *ub = ssx->ub;
      mpq_t *coef = ssx->coef;
      int *A_ptr = ssx->A_ptr;
      int *A_ind = ssx->A_ind;
      mpq_t *A_val = ssx->A_val;
      int *Q_col = ssx->Q_col;
      mpq_t *bbar = ssx->bbar;
      mpq_t *pi = ssx->pi;
      mpq_t *cbar = ssx->cbar;
      int *orig_type, orig_dir;
      mpq_t *orig_lb, *orig_ub, *orig_coef;
      int i, k, ret;
      /* save components of the original LP problem, which are changed
         by the routine */
      orig_type = xcalloc(1+m+n, sizeof(int));
      orig_lb = xcalloc(1+m+n, sizeof(mpq_t));
      orig_ub = xcalloc(1+m+n, sizeof(mpq_t));
      orig_coef = xcalloc(1+m+n, sizeof(mpq_t));
      for (k = 1; k <= m+n; k++)
      {  orig_type[k] = type[k];
         mpq_init(orig_lb[k]);
         mpq_set(orig_lb[k], lb[k]);
         mpq_init(orig_ub[k]);
         mpq_set(orig_ub[k], ub[k]);
      }
      orig_dir = ssx->dir;
      for (k = 0; k <= m+n; k++)
      {  mpq_init(orig_coef[k]);
         mpq_set(orig_coef[k], coef[k]);
      }
      /* build an artificial basic solution, which is primal feasible,
         and also build an auxiliary objective function to minimize the
         sum of infeasibilities for the original problem */
      ssx->dir = SSX_MIN;
      for (k = 0; k <= m+n; k++) mpq_set_si(coef[k], 0, 1);
      mpq_set_si(bbar[0], 0, 1);
      for (i = 1; i <= m; i++)
      {  int t;
         k = Q_col[i]; /* x[k] = xB[i] */
         t = type[k];
         if (t == SSX_LO || t == SSX_DB || t == SSX_FX)
         {  /* in the original problem x[k] has lower bound */
            if (mpq_cmp(bbar[i], lb[k]) < 0)
            {  /* which is violated */
               type[k] = SSX_UP;
               mpq_set(ub[k], lb[k]);
               mpq_set_si(lb[k], 0, 1);
               mpq_set_si(coef[k], -1, 1);
               mpq_add(bbar[0], bbar[0], ub[k]);
               mpq_sub(bbar[0], bbar[0], bbar[i]);
            }
         }
         if (t == SSX_UP || t == SSX_DB || t == SSX_FX)
         {  /* in the original problem x[k] has upper bound */
            if (mpq_cmp(bbar[i], ub[k]) > 0)
            {  /* which is violated */
               type[k] = SSX_LO;
               mpq_set(lb[k], ub[k]);
               mpq_set_si(ub[k], 0, 1);
               mpq_set_si(coef[k], +1, 1);
               mpq_add(bbar[0], bbar[0], bbar[i]);
               mpq_sub(bbar[0], bbar[0], lb[k]);
            }
         }
      }
      /* now the initial basic solution should be primal feasible due
         to changes of bounds of some basic variables, which turned to
         implicit artifical variables */
      /* compute simplex multipliers and reduced costs */
      ssx_eval_pi(ssx);
      ssx_eval_cbar(ssx);
      /* display initial progress of the search */
#if 1 /* 25/XI-2017 */
      if (ssx->msg_lev >= GLP_MSG_ON)
#endif
      show_progress(ssx, 1);
      /* main loop starts here */
      for (;;)
      {  /* display current progress of the search */
#if 1 /* 25/XI-2017 */
         if (ssx->msg_lev >= GLP_MSG_ON)
#endif
#if 0
         if (utime() - ssx->tm_lag >= ssx->out_frq - 0.001)
#else
         if (xdifftime(xtime(), ssx->tm_lag) >= ssx->out_frq - 0.001)
#endif
            show_progress(ssx, 1);
         /* we do not need to wait until all artificial variables have
            left the basis */
         if (mpq_sgn(bbar[0]) == 0)
         {  /* the sum of infeasibilities is zero, therefore the current
               solution is primal feasible for the original problem */
            ret = 0;
            break;
         }
         /* check if the iterations limit has been exhausted */
         if (ssx->it_lim == 0)
         {  ret = 2;
            break;
         }
         /* check if the time limit has been exhausted */
#if 0
         if (ssx->tm_lim >= 0.0 && ssx->tm_lim <= utime() - ssx->tm_beg)
#else
         if (ssx->tm_lim >= 0.0 &&
             ssx->tm_lim <= xdifftime(xtime(), ssx->tm_beg))
#endif
         {  ret = 3;
            break;
         }
         /* choose non-basic variable xN[q] */
         ssx_chuzc(ssx);
         /* if xN[q] cannot be chosen, the sum of infeasibilities is
            minimal but non-zero; therefore the original problem has no
            primal feasible solution */
         if (ssx->q == 0)
         {  ret = 1;
            break;
         }
         /* compute q-th column of the simplex table */
         ssx_eval_col(ssx);
         /* choose basic variable xB[p] */
         ssx_chuzr(ssx);
         /* the sum of infeasibilities cannot be negative, therefore
            the auxiliary lp problem cannot have unbounded solution */
         xassert(ssx->p != 0);
         /* update values of basic variables */
         ssx_update_bbar(ssx);
         if (ssx->p > 0)
         {  /* compute p-th row of the inverse inv(B) */
            ssx_eval_rho(ssx);
            /* compute p-th row of the simplex table */
            ssx_eval_row(ssx);
            xassert(mpq_cmp(ssx->aq[ssx->p], ssx->ap[ssx->q]) == 0);
            /* update simplex multipliers */
            ssx_update_pi(ssx);
            /* update reduced costs of non-basic variables */
            ssx_update_cbar(ssx);
         }
         /* xB[p] is leaving the basis; if it is implicit artificial
            variable, the corresponding residual vanishes; therefore
            bounds of this variable should be restored to the original
            values */
         if (ssx->p > 0)
         {  k = Q_col[ssx->p]; /* x[k] = xB[p] */
            if (type[k] != orig_type[k])
            {  /* x[k] is implicit artificial variable */
               type[k] = orig_type[k];
               mpq_set(lb[k], orig_lb[k]);
               mpq_set(ub[k], orig_ub[k]);
               xassert(ssx->p_stat == SSX_NL || ssx->p_stat == SSX_NU);
               ssx->p_stat = (ssx->p_stat == SSX_NL ? SSX_NU : SSX_NL);
               if (type[k] == SSX_FX) ssx->p_stat = SSX_NS;
               /* nullify the objective coefficient at x[k] */
               mpq_set_si(coef[k], 0, 1);
               /* since coef[k] has been changed, we need to compute
                  new reduced cost of x[k], which it will have in the
                  adjacent basis */
               /* the formula d[j] = cN[j] - pi' * N[j] is used (note
                  that the vector pi is not changed, because it depends
                  on objective coefficients at basic variables, but in
                  the adjacent basis, for which the vector pi has been
                  just recomputed, x[k] is non-basic) */
               if (k <= m)
               {  /* x[k] is auxiliary variable */
                  mpq_neg(cbar[ssx->q], pi[k]);
               }
               else
               {  /* x[k] is structural variable */
                  int ptr;
                  mpq_t temp;
                  mpq_init(temp);
                  mpq_set_si(cbar[ssx->q], 0, 1);
                  for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
                  {  mpq_mul(temp, pi[A_ind[ptr]], A_val[ptr]);
                     mpq_add(cbar[ssx->q], cbar[ssx->q], temp);
                  }
                  mpq_clear(temp);
               }
            }
         }
         /* jump to the adjacent vertex of the polyhedron */
         ssx_change_basis(ssx);
         /* one simplex iteration has been performed */
         if (ssx->it_lim > 0) ssx->it_lim--;
         ssx->it_cnt++;
      }
      /* display final progress of the search */
#if 1 /* 25/XI-2017 */
      if (ssx->msg_lev >= GLP_MSG_ON)
#endif
      show_progress(ssx, 1);
      /* restore components of the original problem, which were changed
         by the routine */
      for (k = 1; k <= m+n; k++)
      {  type[k] = orig_type[k];
         mpq_set(lb[k], orig_lb[k]);
         mpq_clear(orig_lb[k]);
         mpq_set(ub[k], orig_ub[k]);
         mpq_clear(orig_ub[k]);
      }
      ssx->dir = orig_dir;
      for (k = 0; k <= m+n; k++)
      {  mpq_set(coef[k], orig_coef[k]);
         mpq_clear(orig_coef[k]);
      }
      xfree(orig_type);
      xfree(orig_lb);
      xfree(orig_ub);
      xfree(orig_coef);
      /* return to the calling program */
      return ret;
}

/*----------------------------------------------------------------------
// ssx_phase_II - find optimal solution.
//
// This routine implements phase II of the primal simplex method.
//
// On exit the routine returns one of the following codes:
//
// 0 - optimal solution found;
// 1 - problem has unbounded solution;
// 2 - iterations limit exceeded;
// 3 - time limit exceeded.
----------------------------------------------------------------------*/

int ssx_phase_II(SSX *ssx)
{     int ret;
      /* display initial progress of the search */
#if 1 /* 25/XI-2017 */
      if (ssx->msg_lev >= GLP_MSG_ON)
#endif
      show_progress(ssx, 2);
      /* main loop starts here */
      for (;;)
      {  /* display current progress of the search */
#if 1 /* 25/XI-2017 */
         if (ssx->msg_lev >= GLP_MSG_ON)
#endif
#if 0
         if (utime() - ssx->tm_lag >= ssx->out_frq - 0.001)
#else
         if (xdifftime(xtime(), ssx->tm_lag) >= ssx->out_frq - 0.001)
#endif
            show_progress(ssx, 2);
         /* check if the iterations limit has been exhausted */
         if (ssx->it_lim == 0)
         {  ret = 2;
            break;
         }
         /* check if the time limit has been exhausted */
#if 0
         if (ssx->tm_lim >= 0.0 && ssx->tm_lim <= utime() - ssx->tm_beg)
#else
         if (ssx->tm_lim >= 0.0 &&
             ssx->tm_lim <= xdifftime(xtime(), ssx->tm_beg))
#endif
         {  ret = 3;
            break;
         }
         /* choose non-basic variable xN[q] */
         ssx_chuzc(ssx);
         /* if xN[q] cannot be chosen, the current basic solution is
            dual feasible and therefore optimal */
         if (ssx->q == 0)
         {  ret = 0;
            break;
         }
         /* compute q-th column of the simplex table */
         ssx_eval_col(ssx);
         /* choose basic variable xB[p] */
         ssx_chuzr(ssx);
         /* if xB[p] cannot be chosen, the problem has no dual feasible
            solution (i.e. unbounded) */
         if (ssx->p == 0)
         {  ret = 1;
            break;
         }
         /* update values of basic variables */
         ssx_update_bbar(ssx);
         if (ssx->p > 0)
         {  /* compute p-th row of the inverse inv(B) */
            ssx_eval_rho(ssx);
            /* compute p-th row of the simplex table */
            ssx_eval_row(ssx);
            xassert(mpq_cmp(ssx->aq[ssx->p], ssx->ap[ssx->q]) == 0);
#if 0
            /* update simplex multipliers */
            ssx_update_pi(ssx);
#endif
            /* update reduced costs of non-basic variables */
            ssx_update_cbar(ssx);
         }
         /* jump to the adjacent vertex of the polyhedron */
         ssx_change_basis(ssx);
         /* one simplex iteration has been performed */
         if (ssx->it_lim > 0) ssx->it_lim--;
         ssx->it_cnt++;
      }
      /* display final progress of the search */
#if 1 /* 25/XI-2017 */
      if (ssx->msg_lev >= GLP_MSG_ON)
#endif
      show_progress(ssx, 2);
      /* return to the calling program */
      return ret;
}

/*----------------------------------------------------------------------
// ssx_driver - base driver to exact simplex method.
//
// This routine is a base driver to a version of the primal simplex
// method using exact (bignum) arithmetic.
//
// On exit the routine returns one of the following codes:
//
// 0 - optimal solution found;
// 1 - problem has no feasible solution;
// 2 - problem has unbounded solution;
// 3 - iterations limit exceeded (phase I);
// 4 - iterations limit exceeded (phase II);
// 5 - time limit exceeded (phase I);
// 6 - time limit exceeded (phase II);
// 7 - initial basis matrix is exactly singular.
----------------------------------------------------------------------*/

int ssx_driver(SSX *ssx)
{     int m = ssx->m;
      int *type = ssx->type;
      mpq_t *lb = ssx->lb;
      mpq_t *ub = ssx->ub;
      int *Q_col = ssx->Q_col;
      mpq_t *bbar = ssx->bbar;
      int i, k, ret;
      ssx->tm_beg = xtime();
      /* factorize the initial basis matrix */
      if (ssx_factorize(ssx))
#if 0 /* 25/XI-2017 */
      {  xprintf("Initial basis matrix is singular\n");
#else
      {  if (ssx->msg_lev >= GLP_MSG_ERR)
            xprintf("Initial basis matrix is singular\n");
#endif
         ret = 7;
         goto done;
      }
      /* compute values of basic variables */
      ssx_eval_bbar(ssx);
      /* check if the initial basic solution is primal feasible */
      for (i = 1; i <= m; i++)
      {  int t;
         k = Q_col[i]; /* x[k] = xB[i] */
         t = type[k];
         if (t == SSX_LO || t == SSX_DB || t == SSX_FX)
         {  /* x[k] has lower bound */
            if (mpq_cmp(bbar[i], lb[k]) < 0)
            {  /* which is violated */
               break;
            }
         }
         if (t == SSX_UP || t == SSX_DB || t == SSX_FX)
         {  /* x[k] has upper bound */
            if (mpq_cmp(bbar[i], ub[k]) > 0)
            {  /* which is violated */
               break;
            }
         }
      }
      if (i > m)
      {  /* no basic variable violates its bounds */
         ret = 0;
         goto skip;
      }
      /* phase I: find primal feasible solution */
      ret = ssx_phase_I(ssx);
      switch (ret)
      {  case 0:
            ret = 0;
            break;
         case 1:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("PROBLEM HAS NO FEASIBLE SOLUTION\n");
            ret = 1;
            break;
         case 2:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("ITERATIONS LIMIT EXCEEDED; SEARCH TERMINATED\n");
            ret = 3;
            break;
         case 3:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("TIME LIMIT EXCEEDED; SEARCH TERMINATED\n");
            ret = 5;
            break;
         default:
            xassert(ret != ret);
      }
      /* compute values of basic variables (actually only the objective
         value needs to be computed) */
      ssx_eval_bbar(ssx);
skip: /* compute simplex multipliers */
      ssx_eval_pi(ssx);
      /* compute reduced costs of non-basic variables */
      ssx_eval_cbar(ssx);
      /* if phase I failed, do not start phase II */
      if (ret != 0) goto done;
      /* phase II: find optimal solution */
      ret = ssx_phase_II(ssx);
      switch (ret)
      {  case 0:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("OPTIMAL SOLUTION FOUND\n");
            ret = 0;
            break;
         case 1:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("PROBLEM HAS UNBOUNDED SOLUTION\n");
            ret = 2;
            break;
         case 2:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("ITERATIONS LIMIT EXCEEDED; SEARCH TERMINATED\n");
            ret = 4;
            break;
         case 3:
#if 1 /* 25/XI-2017 */
            if (ssx->msg_lev >= GLP_MSG_ALL)
#endif
            xprintf("TIME LIMIT EXCEEDED; SEARCH TERMINATED\n");
            ret = 6;
            break;
         default:
            xassert(ret != ret);
      }
done: /* decrease the time limit by the spent amount of time */
      if (ssx->tm_lim >= 0.0)
#if 0
      {  ssx->tm_lim -= utime() - ssx->tm_beg;
#else
      {  ssx->tm_lim -= xdifftime(xtime(), ssx->tm_beg);
#endif
         if (ssx->tm_lim < 0.0) ssx->tm_lim = 0.0;
      }
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/ios.h0000644000175100001710000005015700000000000024157 0ustar00runnerdocker00000000000000/* ios.h (integer optimization suite) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef IOS_H
#define IOS_H

#include "prob.h"

#if 1 /* 02/II-2018 */
#define NEW_LOCAL 1
#endif

#if 1 /* 15/II-2018 */
#define NEW_COVER 1
#endif

typedef struct IOSLOT IOSLOT;
typedef struct IOSNPD IOSNPD;
typedef struct IOSBND IOSBND;
typedef struct IOSTAT IOSTAT;
typedef struct IOSROW IOSROW;
typedef struct IOSAIJ IOSAIJ;
#ifdef NEW_LOCAL /* 02/II-2018 */
typedef glp_prob IOSPOOL;
typedef GLPROW IOSCUT;
#else
typedef struct IOSPOOL IOSPOOL;
typedef struct IOSCUT IOSCUT;
#endif

struct glp_tree
{     /* branch-and-bound tree */
      int magic;
      /* magic value used for debugging */
      DMP *pool;
      /* memory pool to store all IOS components */
      int n;
      /* number of columns (variables) */
      /*--------------------------------------------------------------*/
      /* problem components corresponding to the original MIP and its
         LP relaxation (used to restore the original problem object on
         exit from the solver) */
      int orig_m;
      /* number of rows */
      unsigned char *orig_type; /* uchar orig_type[1+orig_m+n]; */
      /* types of all variables */
      double *orig_lb; /* double orig_lb[1+orig_m+n]; */
      /* lower bounds of all variables */
      double *orig_ub; /* double orig_ub[1+orig_m+n]; */
      /* upper bounds of all variables */
      unsigned char *orig_stat; /* uchar orig_stat[1+orig_m+n]; */
      /* statuses of all variables */
      double *orig_prim; /* double orig_prim[1+orig_m+n]; */
      /* primal values of all variables */
      double *orig_dual; /* double orig_dual[1+orig_m+n]; */
      /* dual values of all variables */
      double orig_obj;
      /* optimal objective value for LP relaxation */
      /*--------------------------------------------------------------*/
      /* branch-and-bound tree */
      int nslots;
      /* length of the array of slots (enlarged automatically) */
      int avail;
      /* index of the first free slot; 0 means all slots are in use */
      IOSLOT *slot; /* IOSLOT slot[1+nslots]; */
      /* array of slots:
         slot[0] is not used;
         slot[p], 1 <= p <= nslots, either contains a pointer to some
         node of the branch-and-bound tree, in which case p is used on
         API level as the reference number of corresponding subproblem,
         or is free; all free slots are linked into single linked list;
         slot[1] always contains a pointer to the root node (it is free
         only if the tree is empty) */
      IOSNPD *head;
      /* pointer to the head of the active list */
      IOSNPD *tail;
      /* pointer to the tail of the active list */
      /* the active list is a doubly linked list of active subproblems
         which correspond to leaves of the tree; all subproblems in the
         active list are ordered chronologically (each a new subproblem
         is always added to the tail of the list) */
      int a_cnt;
      /* current number of active nodes (including the current one) */
      int n_cnt;
      /* current number of all (active and inactive) nodes */
      int t_cnt;
      /* total number of nodes including those which have been already
         removed from the tree; this count is increased by one whenever
         a new node is created and never decreased */
      /*--------------------------------------------------------------*/
      /* problem components corresponding to the root subproblem */
      int root_m;
      /* number of rows */
      unsigned char *root_type; /* uchar root_type[1+root_m+n]; */
      /* types of all variables */
      double *root_lb; /* double root_lb[1+root_m+n]; */
      /* lower bounds of all variables */
      double *root_ub; /* double root_ub[1+root_m+n]; */
      /* upper bounds of all variables */
      unsigned char *root_stat; /* uchar root_stat[1+root_m+n]; */
      /* statuses of all variables */
      /*--------------------------------------------------------------*/
      /* current subproblem and its LP relaxation */
      IOSNPD *curr;
      /* pointer to the current subproblem (which can be only active);
         NULL means the current subproblem does not exist */
      glp_prob *mip;
      /* original problem object passed to the solver; if the current
         subproblem exists, its LP segment corresponds to LP relaxation
         of the current subproblem; if the current subproblem does not
         exist, its LP segment corresponds to LP relaxation of the root
         subproblem (note that the root subproblem may differ from the
         original MIP, because it may be preprocessed and/or may have
         additional rows) */
      unsigned char *non_int; /* uchar non_int[1+n]; */
      /* these column flags are set each time when LP relaxation of the
         current subproblem has been solved;
         non_int[0] is not used;
         non_int[j], 1 <= j <= n, is j-th column flag; if this flag is
         set, corresponding variable is required to be integer, but its
         value in basic solution is fractional */
      /*--------------------------------------------------------------*/
      /* problem components corresponding to the parent (predecessor)
         subproblem for the current subproblem; used to inspect changes
         on freezing the current subproblem */
      int pred_m;
      /* number of rows */
      int pred_max;
      /* length of the following four arrays (enlarged automatically),
         pred_max >= pred_m + n */
      unsigned char *pred_type; /* uchar pred_type[1+pred_m+n]; */
      /* types of all variables */
      double *pred_lb; /* double pred_lb[1+pred_m+n]; */
      /* lower bounds of all variables */
      double *pred_ub; /* double pred_ub[1+pred_m+n]; */
      /* upper bounds of all variables */
      unsigned char *pred_stat; /* uchar pred_stat[1+pred_m+n]; */
      /* statuses of all variables */
      /****************************************************************/
      /* built-in cut generators segment */
      IOSPOOL *local;
      /* local cut pool */
#if 1 /* 13/II-2018 */
      glp_cov *cov_gen;
      /* pointer to working area used by the cover cut generator */
#endif
      glp_mir *mir_gen;
      /* pointer to working area used by the MIR cut generator */
      glp_cfg *clq_gen;
      /* pointer to conflict graph used by the clique cut generator */
      /*--------------------------------------------------------------*/
      void *pcost;
      /* pointer to working area used on pseudocost branching */
      int *iwrk; /* int iwrk[1+n]; */
      /* working array */
      double *dwrk; /* double dwrk[1+n]; */
      /* working array */
      /*--------------------------------------------------------------*/
      /* control parameters and statistics */
      const glp_iocp *parm;
      /* copy of control parameters passed to the solver */
      double tm_beg;
      /* starting time of the search, in seconds; the total time of the
         search is the difference between xtime() and tm_beg */
      double tm_lag;
      /* the most recent time, in seconds, at which the progress of the
         the search was displayed */
      int sol_cnt;
      /* number of integer feasible solutions found */
#if 1 /* 11/VII-2013 */
      void *P; /* glp_prob *P; */
      /* problem passed to glp_intopt */
      void *npp; /* NPP *npp; */
      /* preprocessor workspace or NULL */
      const char *save_sol;
      /* filename (template) to save every new solution */
      int save_cnt;
      /* count to generate filename */
#endif
      /*--------------------------------------------------------------*/
      /* advanced solver interface */
      int reason;
      /* flag indicating the reason why the callback routine is being
         called (see glpk.h) */
      int stop;
      /* flag indicating that the callback routine requires premature
         termination of the search */
      int next_p;
      /* reference number of active subproblem selected to continue
         the search; 0 means no subproblem has been selected */
      int reopt;
      /* flag indicating that the current LP relaxation needs to be
         re-optimized */
      int reinv;
      /* flag indicating that some (non-active) rows were removed from
         the current LP relaxation, so if there no new rows appear, the
         basis must be re-factorized */
      int br_var;
      /* the number of variable chosen to branch on */
      int br_sel;
      /* flag indicating which branch (subproblem) is suggested to be
         selected to continue the search:
         GLP_DN_BRNCH - select down-branch
         GLP_UP_BRNCH - select up-branch
         GLP_NO_BRNCH - use general selection technique */
      int child;
      /* subproblem reference number corresponding to br_sel */
};

struct IOSLOT
{     /* node subproblem slot */
      IOSNPD *node;
      /* pointer to subproblem descriptor; NULL means free slot */
      int next;
      /* index of another free slot (only if this slot is free) */
};

struct IOSNPD
{     /* node subproblem descriptor */
      int p;
      /* subproblem reference number (it is the index to corresponding
         slot, i.e. slot[p] points to this descriptor) */
      IOSNPD *up;
      /* pointer to the parent subproblem; NULL means this node is the
         root of the tree, in which case p = 1 */
      int level;
      /* node level (the root node has level 0) */
      int count;
      /* if count = 0, this subproblem is active; if count > 0, this
         subproblem is inactive, in which case count is the number of
         its child subproblems */
      /* the following three linked lists are destroyed on reviving and
         built anew on freezing the subproblem: */
      IOSBND *b_ptr;
      /* linked list of rows and columns of the parent subproblem whose
         types and bounds were changed */
      IOSTAT *s_ptr;
      /* linked list of rows and columns of the parent subproblem whose
         statuses were changed */
      IOSROW *r_ptr;
      /* linked list of rows (cuts) added to the parent subproblem */
      int solved;
      /* how many times LP relaxation of this subproblem was solved;
         for inactive subproblem this count is always non-zero;
         for active subproblem, which is not current, this count may be
         non-zero, if the subproblem was temporarily suspended */
      double lp_obj;
      /* optimal objective value to LP relaxation of this subproblem;
         on creating a subproblem this value is inherited from its
         parent; for the root subproblem, which has no parent, this
         value is initially set to -DBL_MAX (minimization) or +DBL_MAX
         (maximization); each time the subproblem is re-optimized, this
         value is appropriately changed */
      double bound;
      /* local lower (minimization) or upper (maximization) bound for
         integer optimal solution to *this* subproblem; this bound is
         local in the sense that only subproblems in the subtree rooted
         at this node cannot have better integer feasible solutions;
         on creating a subproblem its local bound is inherited from its
         parent and then can be made stronger (never weaker); for the
         root subproblem its local bound is initially set to -DBL_MAX
         (minimization) or +DBL_MAX (maximization) and then improved as
         the root LP relaxation has been solved */
      /* the following two quantities are defined only if LP relaxation
         of this subproblem was solved at least once (solved > 0): */
      int ii_cnt;
      /* number of integer variables whose value in optimal solution to
         LP relaxation of this subproblem is fractional */
      double ii_sum;
      /* sum of integer infeasibilities */
#if 1 /* 30/XI-2009 */
      int changed;
      /* how many times this subproblem was re-formulated (by adding
         cutting plane constraints) */
#endif
      int br_var;
      /* ordinal number of branching variable, 1 <= br_var <= n, used
         to split this subproblem; 0 means that either this subproblem
         is active or branching was made on a constraint */
      double br_val;
      /* (fractional) value of branching variable in optimal solution
         to final LP relaxation of this subproblem */
      void *data; /* char data[tree->cb_size]; */
      /* pointer to the application-specific data */
      IOSNPD *temp;
      /* working pointer used by some routines */
      IOSNPD *prev;
      /* pointer to previous subproblem in the active list */
      IOSNPD *next;
      /* pointer to next subproblem in the active list */
};

struct IOSBND
{     /* bounds change entry */
      int k;
      /* ordinal number of corresponding row (1 <= k <= m) or column
         (m+1 <= k <= m+n), where m and n are the number of rows and
         columns, resp., in the parent subproblem */
      unsigned char type;
      /* new type */
      double lb;
      /* new lower bound */
      double ub;
      /* new upper bound */
      IOSBND *next;
      /* pointer to next entry for the same subproblem */
};

struct IOSTAT
{     /* status change entry */
      int k;
      /* ordinal number of corresponding row (1 <= k <= m) or column
         (m+1 <= k <= m+n), where m and n are the number of rows and
         columns, resp., in the parent subproblem */
      unsigned char stat;
      /* new status */
      IOSTAT *next;
      /* pointer to next entry for the same subproblem */
};

struct IOSROW
{     /* row (constraint) addition entry */
      char *name;
      /* row name or NULL */
      unsigned char origin;
      /* row origin flag (see glp_attr.origin) */
      unsigned char klass;
      /* row class descriptor (see glp_attr.klass) */
      unsigned char type;
      /* row type (GLP_LO, GLP_UP, etc.) */
      double lb;
      /* row lower bound */
      double ub;
      /* row upper bound */
      IOSAIJ *ptr;
      /* pointer to the row coefficient list */
      double rii;
      /* row scale factor */
      unsigned char stat;
      /* row status (GLP_BS, GLP_NL, etc.) */
      IOSROW *next;
      /* pointer to next entry for the same subproblem */
};

struct IOSAIJ
{     /* constraint coefficient */
      int j;
      /* variable (column) number, 1 <= j <= n */
      double val;
      /* non-zero coefficient value */
      IOSAIJ *next;
      /* pointer to next coefficient for the same row */
};

#ifndef NEW_LOCAL /* 02/II-2018 */
struct IOSPOOL
{     /* cut pool */
      int size;
      /* pool size = number of cuts in the pool */
      IOSCUT *head;
      /* pointer to the first cut */
      IOSCUT *tail;
      /* pointer to the last cut */
      int ord;
      /* ordinal number of the current cut, 1 <= ord <= size */
      IOSCUT *curr;
      /* pointer to the current cut */
};
#endif

#ifndef NEW_LOCAL /* 02/II-2018 */
struct IOSCUT
{     /* cut (cutting plane constraint) */
      char *name;
      /* cut name or NULL */
      unsigned char klass;
      /* cut class descriptor (see glp_attr.klass) */
      IOSAIJ *ptr;
      /* pointer to the cut coefficient list */
      unsigned char type;
      /* cut type:
         GLP_LO: sum a[j] * x[j] >= b
         GLP_UP: sum a[j] * x[j] <= b
         GLP_FX: sum a[j] * x[j]  = b */
      double rhs;
      /* cut right-hand side */
      IOSCUT *prev;
      /* pointer to previous cut */
      IOSCUT *next;
      /* pointer to next cut */
};
#endif

#define ios_create_tree _glp_ios_create_tree
glp_tree *ios_create_tree(glp_prob *mip, const glp_iocp *parm);
/* create branch-and-bound tree */

#define ios_revive_node _glp_ios_revive_node
void ios_revive_node(glp_tree *tree, int p);
/* revive specified subproblem */

#define ios_freeze_node _glp_ios_freeze_node
void ios_freeze_node(glp_tree *tree);
/* freeze current subproblem */

#define ios_clone_node _glp_ios_clone_node
void ios_clone_node(glp_tree *tree, int p, int nnn, int ref[]);
/* clone specified subproblem */

#define ios_delete_node _glp_ios_delete_node
void ios_delete_node(glp_tree *tree, int p);
/* delete specified subproblem */

#define ios_delete_tree _glp_ios_delete_tree
void ios_delete_tree(glp_tree *tree);
/* delete branch-and-bound tree */

#define ios_eval_degrad _glp_ios_eval_degrad
void ios_eval_degrad(glp_tree *tree, int j, double *dn, double *up);
/* estimate obj. degrad. for down- and up-branches */

#define ios_round_bound _glp_ios_round_bound
double ios_round_bound(glp_tree *tree, double bound);
/* improve local bound by rounding */

#define ios_is_hopeful _glp_ios_is_hopeful
int ios_is_hopeful(glp_tree *tree, double bound);
/* check if subproblem is hopeful */

#define ios_best_node _glp_ios_best_node
int ios_best_node(glp_tree *tree);
/* find active node with best local bound */

#define ios_relative_gap _glp_ios_relative_gap
double ios_relative_gap(glp_tree *tree);
/* compute relative mip gap */

#define ios_solve_node _glp_ios_solve_node
int ios_solve_node(glp_tree *tree);
/* solve LP relaxation of current subproblem */

#define ios_create_pool _glp_ios_create_pool
IOSPOOL *ios_create_pool(glp_tree *tree);
/* create cut pool */

#define ios_add_row _glp_ios_add_row
int ios_add_row(glp_tree *tree, IOSPOOL *pool,
      const char *name, int klass, int flags, int len, const int ind[],
      const double val[], int type, double rhs);
/* add row (constraint) to the cut pool */

#define ios_find_row _glp_ios_find_row
IOSCUT *ios_find_row(IOSPOOL *pool, int i);
/* find row (constraint) in the cut pool */

#define ios_del_row _glp_ios_del_row
void ios_del_row(glp_tree *tree, IOSPOOL *pool, int i);
/* remove row (constraint) from the cut pool */

#define ios_clear_pool _glp_ios_clear_pool
void ios_clear_pool(glp_tree *tree, IOSPOOL *pool);
/* remove all rows (constraints) from the cut pool */

#define ios_delete_pool _glp_ios_delete_pool
void ios_delete_pool(glp_tree *tree, IOSPOOL *pool);
/* delete cut pool */

#if 1 /* 11/VII-2013 */
#define ios_process_sol _glp_ios_process_sol
void ios_process_sol(glp_tree *T);
/* process integer feasible solution just found */
#endif

#define ios_preprocess_node _glp_ios_preprocess_node
int ios_preprocess_node(glp_tree *tree, int max_pass);
/* preprocess current subproblem */

#define ios_driver _glp_ios_driver
int ios_driver(glp_tree *tree);
/* branch-and-bound driver */

#define ios_cov_gen _glp_ios_cov_gen
void ios_cov_gen(glp_tree *tree);
/* generate mixed cover cuts */

#define ios_pcost_init _glp_ios_pcost_init
void *ios_pcost_init(glp_tree *tree);
/* initialize working data used on pseudocost branching */

#define ios_pcost_branch _glp_ios_pcost_branch
int ios_pcost_branch(glp_tree *T, int *next);
/* choose branching variable with pseudocost branching */

#define ios_pcost_update _glp_ios_pcost_update
void ios_pcost_update(glp_tree *tree);
/* update history information for pseudocost branching */

#define ios_pcost_free _glp_ios_pcost_free
void ios_pcost_free(glp_tree *tree);
/* free working area used on pseudocost branching */

#define ios_feas_pump _glp_ios_feas_pump
void ios_feas_pump(glp_tree *T);
/* feasibility pump heuristic */

#if 1 /* 25/V-2013 */
#define ios_proxy_heur _glp_ios_proxy_heur
void ios_proxy_heur(glp_tree *T);
/* proximity search heuristic */
#endif

#define ios_process_cuts _glp_ios_process_cuts
void ios_process_cuts(glp_tree *T);
/* process cuts stored in the local cut pool */

#define ios_choose_node _glp_ios_choose_node
int ios_choose_node(glp_tree *T);
/* select subproblem to continue the search */

#define ios_choose_var _glp_ios_choose_var
int ios_choose_var(glp_tree *T, int *next);
/* select variable to branch on */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/lux.c0000644000175100001710000011353000000000000024163 0ustar00runnerdocker00000000000000/* lux.c (LU-factorization, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "lux.h"

#define xfault xerror
#define dmp_create_poolx(size) dmp_create_pool()

/***********************************************************************
*  lux_create - create LU-factorization
*
*  SYNOPSIS
*
*  #include "lux.h"
*  LUX *lux_create(int n);
*
*  DESCRIPTION
*
*  The routine lux_create creates LU-factorization data structure for
*  a matrix of the order n. Initially the factorization corresponds to
*  the unity matrix (F = V = P = Q = I, so A = I).
*
*  RETURNS
*
*  The routine returns a pointer to the created LU-factorization data
*  structure, which represents the unity matrix of the order n. */

LUX *lux_create(int n)
{     LUX *lux;
      int k;
      if (n < 1)
         xfault("lux_create: n = %d; invalid parameter\n", n);
      lux = xmalloc(sizeof(LUX));
      lux->n = n;
      lux->pool = dmp_create_poolx(sizeof(LUXELM));
      lux->F_row = xcalloc(1+n, sizeof(LUXELM *));
      lux->F_col = xcalloc(1+n, sizeof(LUXELM *));
      lux->V_piv = xcalloc(1+n, sizeof(mpq_t));
      lux->V_row = xcalloc(1+n, sizeof(LUXELM *));
      lux->V_col = xcalloc(1+n, sizeof(LUXELM *));
      lux->P_row = xcalloc(1+n, sizeof(int));
      lux->P_col = xcalloc(1+n, sizeof(int));
      lux->Q_row = xcalloc(1+n, sizeof(int));
      lux->Q_col = xcalloc(1+n, sizeof(int));
      for (k = 1; k <= n; k++)
      {  lux->F_row[k] = lux->F_col[k] = NULL;
         mpq_init(lux->V_piv[k]);
         mpq_set_si(lux->V_piv[k], 1, 1);
         lux->V_row[k] = lux->V_col[k] = NULL;
         lux->P_row[k] = lux->P_col[k] = k;
         lux->Q_row[k] = lux->Q_col[k] = k;
      }
      lux->rank = n;
      return lux;
}

/***********************************************************************
*  initialize - initialize LU-factorization data structures
*
*  This routine initializes data structures for subsequent computing
*  the LU-factorization of a given matrix A, which is specified by the
*  formal routine col. On exit V = A and F = P = Q = I, where I is the
*  unity matrix. */

static void initialize(LUX *lux, int (*col)(void *info, int j,
      int ind[], mpq_t val[]), void *info, LUXWKA *wka)
{     int n = lux->n;
      DMP *pool = lux->pool;
      LUXELM **F_row = lux->F_row;
      LUXELM **F_col = lux->F_col;
      mpq_t *V_piv = lux->V_piv;
      LUXELM **V_row = lux->V_row;
      LUXELM **V_col = lux->V_col;
      int *P_row = lux->P_row;
      int *P_col = lux->P_col;
      int *Q_row = lux->Q_row;
      int *Q_col = lux->Q_col;
      int *R_len = wka->R_len;
      int *R_head = wka->R_head;
      int *R_prev = wka->R_prev;
      int *R_next = wka->R_next;
      int *C_len = wka->C_len;
      int *C_head = wka->C_head;
      int *C_prev = wka->C_prev;
      int *C_next = wka->C_next;
      LUXELM *fij, *vij;
      int i, j, k, len, *ind;
      mpq_t *val;
      /* F := I */
      for (i = 1; i <= n; i++)
      {  while (F_row[i] != NULL)
         {  fij = F_row[i], F_row[i] = fij->r_next;
            mpq_clear(fij->val);
            dmp_free_atom(pool, fij, sizeof(LUXELM));
         }
      }
      for (j = 1; j <= n; j++) F_col[j] = NULL;
      /* V := 0 */
      for (k = 1; k <= n; k++) mpq_set_si(V_piv[k], 0, 1);
      for (i = 1; i <= n; i++)
      {  while (V_row[i] != NULL)
         {  vij = V_row[i], V_row[i] = vij->r_next;
            mpq_clear(vij->val);
            dmp_free_atom(pool, vij, sizeof(LUXELM));
         }
      }
      for (j = 1; j <= n; j++) V_col[j] = NULL;
      /* V := A */
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(mpq_t));
      for (k = 1; k <= n; k++) mpq_init(val[k]);
      for (j = 1; j <= n; j++)
      {  /* obtain j-th column of matrix A */
         len = col(info, j, ind, val);
         if (!(0 <= len && len <= n))
            xfault("lux_decomp: j = %d: len = %d; invalid column length"
               "\n", j, len);
         /* copy elements of j-th column to matrix V */
         for (k = 1; k <= len; k++)
         {  /* get row index of a[i,j] */
            i = ind[k];
            if (!(1 <= i && i <= n))
               xfault("lux_decomp: j = %d: i = %d; row index out of ran"
                  "ge\n", j, i);
            /* check for duplicate indices */
            if (V_row[i] != NULL && V_row[i]->j == j)
               xfault("lux_decomp: j = %d: i = %d; duplicate row indice"
                  "s not allowed\n", j, i);
            /* check for zero value */
            if (mpq_sgn(val[k]) == 0)
               xfault("lux_decomp: j = %d: i = %d; zero elements not al"
                  "lowed\n", j, i);
            /* add new element v[i,j] = a[i,j] to V */
            vij = dmp_get_atom(pool, sizeof(LUXELM));
            vij->i = i, vij->j = j;
            mpq_init(vij->val);
            mpq_set(vij->val, val[k]);
            vij->r_prev = NULL;
            vij->r_next = V_row[i];
            vij->c_prev = NULL;
            vij->c_next = V_col[j];
            if (vij->r_next != NULL) vij->r_next->r_prev = vij;
            if (vij->c_next != NULL) vij->c_next->c_prev = vij;
            V_row[i] = V_col[j] = vij;
         }
      }
      xfree(ind);
      for (k = 1; k <= n; k++) mpq_clear(val[k]);
      xfree(val);
      /* P := Q := I */
      for (k = 1; k <= n; k++)
         P_row[k] = P_col[k] = Q_row[k] = Q_col[k] = k;
      /* the rank of A and V is not determined yet */
      lux->rank = -1;
      /* initially the entire matrix V is active */
      /* determine its row lengths */
      for (i = 1; i <= n; i++)
      {  len = 0;
         for (vij = V_row[i]; vij != NULL; vij = vij->r_next) len++;
         R_len[i] = len;
      }
      /* build linked lists of active rows */
      for (len = 0; len <= n; len++) R_head[len] = 0;
      for (i = 1; i <= n; i++)
      {  len = R_len[i];
         R_prev[i] = 0;
         R_next[i] = R_head[len];
         if (R_next[i] != 0) R_prev[R_next[i]] = i;
         R_head[len] = i;
      }
      /* determine its column lengths */
      for (j = 1; j <= n; j++)
      {  len = 0;
         for (vij = V_col[j]; vij != NULL; vij = vij->c_next) len++;
         C_len[j] = len;
      }
      /* build linked lists of active columns */
      for (len = 0; len <= n; len++) C_head[len] = 0;
      for (j = 1; j <= n; j++)
      {  len = C_len[j];
         C_prev[j] = 0;
         C_next[j] = C_head[len];
         if (C_next[j] != 0) C_prev[C_next[j]] = j;
         C_head[len] = j;
      }
      return;
}

/***********************************************************************
*  find_pivot - choose a pivot element
*
*  This routine chooses a pivot element v[p,q] in the active submatrix
*  of matrix U = P*V*Q.
*
*  It is assumed that on entry the matrix U has the following partially
*  triangularized form:
*
*        1       k         n
*     1  x x x x x x x x x x
*        . x x x x x x x x x
*        . . x x x x x x x x
*        . . . x x x x x x x
*     k  . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*        . . . . * * * * * *
*     n  . . . . * * * * * *
*
*  where rows and columns k, k+1, ..., n belong to the active submatrix
*  (elements of the active submatrix are marked by '*').
*
*  Since the matrix U = P*V*Q is not stored, the routine works with the
*  matrix V. It is assumed that the row-wise representation corresponds
*  to the matrix V, but the column-wise representation corresponds to
*  the active submatrix of the matrix V, i.e. elements of the matrix V,
*  which does not belong to the active submatrix, are missing from the
*  column linked lists. It is also assumed that each active row of the
*  matrix V is in the set R[len], where len is number of non-zeros in
*  the row, and each active column of the matrix V is in the set C[len],
*  where len is number of non-zeros in the column (in the latter case
*  only elements of the active submatrix are counted; such elements are
*  marked by '*' on the figure above).
*
*  Due to exact arithmetic any non-zero element of the active submatrix
*  can be chosen as a pivot. However, to keep sparsity of the matrix V
*  the routine uses Markowitz strategy, trying to choose such element
*  v[p,q], which has smallest Markowitz cost (nr[p]-1) * (nc[q]-1),
*  where nr[p] and nc[q] are the number of non-zero elements, resp., in
*  p-th row and in q-th column of the active submatrix.
*
*  In order to reduce the search, i.e. not to walk through all elements
*  of the active submatrix, the routine exploits a technique proposed by
*  I.Duff. This technique is based on using the sets R[len] and C[len]
*  of active rows and columns.
*
*  On exit the routine returns a pointer to a pivot v[p,q] chosen, or
*  NULL, if the active submatrix is empty. */

static LUXELM *find_pivot(LUX *lux, LUXWKA *wka)
{     int n = lux->n;
      LUXELM **V_row = lux->V_row;
      LUXELM **V_col = lux->V_col;
      int *R_len = wka->R_len;
      int *R_head = wka->R_head;
      int *R_next = wka->R_next;
      int *C_len = wka->C_len;
      int *C_head = wka->C_head;
      int *C_next = wka->C_next;
      LUXELM *piv, *some, *vij;
      int i, j, len, min_len, ncand, piv_lim = 5;
      double best, cost;
      /* nothing is chosen so far */
      piv = NULL, best = DBL_MAX, ncand = 0;
      /* if in the active submatrix there is a column that has the only
         non-zero (column singleton), choose it as a pivot */
      j = C_head[1];
      if (j != 0)
      {  xassert(C_len[j] == 1);
         piv = V_col[j];
         xassert(piv != NULL && piv->c_next == NULL);
         goto done;
      }
      /* if in the active submatrix there is a row that has the only
         non-zero (row singleton), choose it as a pivot */
      i = R_head[1];
      if (i != 0)
      {  xassert(R_len[i] == 1);
         piv = V_row[i];
         xassert(piv != NULL && piv->r_next == NULL);
         goto done;
      }
      /* there are no singletons in the active submatrix; walk through
         other non-empty rows and columns */
      for (len = 2; len <= n; len++)
      {  /* consider active columns having len non-zeros */
         for (j = C_head[len]; j != 0; j = C_next[j])
         {  /* j-th column has len non-zeros */
            /* find an element in the row of minimal length */
            some = NULL, min_len = INT_MAX;
            for (vij = V_col[j]; vij != NULL; vij = vij->c_next)
            {  if (min_len > R_len[vij->i])
                  some = vij, min_len = R_len[vij->i];
               /* if Markowitz cost of this element is not greater than
                  (len-1)**2, it can be chosen right now; this heuristic
                  reduces the search and works well in many cases */
               if (min_len <= len)
               {  piv = some;
                  goto done;
               }
            }
            /* j-th column has been scanned */
            /* the minimal element found is a next pivot candidate */
            xassert(some != NULL);
            ncand++;
            /* compute its Markowitz cost */
            cost = (double)(min_len - 1) * (double)(len - 1);
            /* choose between the current candidate and this element */
            if (cost < best) piv = some, best = cost;
            /* if piv_lim candidates have been considered, there is a
               doubt that a much better candidate exists; therefore it
               is the time to terminate the search */
            if (ncand == piv_lim) goto done;
         }
         /* now consider active rows having len non-zeros */
         for (i = R_head[len]; i != 0; i = R_next[i])
         {  /* i-th row has len non-zeros */
            /* find an element in the column of minimal length */
            some = NULL, min_len = INT_MAX;
            for (vij = V_row[i]; vij != NULL; vij = vij->r_next)
            {  if (min_len > C_len[vij->j])
                  some = vij, min_len = C_len[vij->j];
               /* if Markowitz cost of this element is not greater than
                  (len-1)**2, it can be chosen right now; this heuristic
                  reduces the search and works well in many cases */
               if (min_len <= len)
               {  piv = some;
                  goto done;
               }
            }
            /* i-th row has been scanned */
            /* the minimal element found is a next pivot candidate */
            xassert(some != NULL);
            ncand++;
            /* compute its Markowitz cost */
            cost = (double)(len - 1) * (double)(min_len - 1);
            /* choose between the current candidate and this element */
            if (cost < best) piv = some, best = cost;
            /* if piv_lim candidates have been considered, there is a
               doubt that a much better candidate exists; therefore it
               is the time to terminate the search */
            if (ncand == piv_lim) goto done;
         }
      }
done: /* bring the pivot v[p,q] to the factorizing routine */
      return piv;
}

/***********************************************************************
*  eliminate - perform gaussian elimination
*
*  This routine performs elementary gaussian transformations in order
*  to eliminate subdiagonal elements in the k-th column of the matrix
*  U = P*V*Q using the pivot element u[k,k], where k is the number of
*  the current elimination step.
*
*  The parameter piv specifies the pivot element v[p,q] = u[k,k].
*
*  Each time when the routine applies the elementary transformation to
*  a non-pivot row of the matrix V, it stores the corresponding element
*  to the matrix F in order to keep the main equality A = F*V.
*
*  The routine assumes that on entry the matrices L = P*F*inv(P) and
*  U = P*V*Q are the following:
*
*        1       k                  1       k         n
*     1  1 . . . . . . . . .     1  x x x x x x x x x x
*        x 1 . . . . . . . .        . x x x x x x x x x
*        x x 1 . . . . . . .        . . x x x x x x x x
*        x x x 1 . . . . . .        . . . x x x x x x x
*     k  x x x x 1 . . . . .     k  . . . . * * * * * *
*        x x x x _ 1 . . . .        . . . . # * * * * *
*        x x x x _ . 1 . . .        . . . . # * * * * *
*        x x x x _ . . 1 . .        . . . . # * * * * *
*        x x x x _ . . . 1 .        . . . . # * * * * *
*     n  x x x x _ . . . . 1     n  . . . . # * * * * *
*
*             matrix L                   matrix U
*
*  where rows and columns of the matrix U with numbers k, k+1, ..., n
*  form the active submatrix (eliminated elements are marked by '#' and
*  other elements of the active submatrix are marked by '*'). Note that
*  each eliminated non-zero element u[i,k] of the matrix U gives the
*  corresponding element l[i,k] of the matrix L (marked by '_').
*
*  Actually all operations are performed on the matrix V. Should note
*  that the row-wise representation corresponds to the matrix V, but the
*  column-wise representation corresponds to the active submatrix of the
*  matrix V, i.e. elements of the matrix V, which doesn't belong to the
*  active submatrix, are missing from the column linked lists.
*
*  Let u[k,k] = v[p,q] be the pivot. In order to eliminate subdiagonal
*  elements u[i',k] = v[i,q], i' = k+1, k+2, ..., n, the routine applies
*  the following elementary gaussian transformations:
*
*     (i-th row of V) := (i-th row of V) - f[i,p] * (p-th row of V),
*
*  where f[i,p] = v[i,q] / v[p,q] is a gaussian multiplier.
*
*  Additionally, in order to keep the main equality A = F*V, each time
*  when the routine applies the transformation to i-th row of the matrix
*  V, it also adds f[i,p] as a new element to the matrix F.
*
*  IMPORTANT: On entry the working arrays flag and work should contain
*  zeros. This status is provided by the routine on exit. */

static void eliminate(LUX *lux, LUXWKA *wka, LUXELM *piv, int flag[],
      mpq_t work[])
{     DMP *pool = lux->pool;
      LUXELM **F_row = lux->F_row;
      LUXELM **F_col = lux->F_col;
      mpq_t *V_piv = lux->V_piv;
      LUXELM **V_row = lux->V_row;
      LUXELM **V_col = lux->V_col;
      int *R_len = wka->R_len;
      int *R_head = wka->R_head;
      int *R_prev = wka->R_prev;
      int *R_next = wka->R_next;
      int *C_len = wka->C_len;
      int *C_head = wka->C_head;
      int *C_prev = wka->C_prev;
      int *C_next = wka->C_next;
      LUXELM *fip, *vij, *vpj, *viq, *next;
      mpq_t temp;
      int i, j, p, q;
      mpq_init(temp);
      /* determine row and column indices of the pivot v[p,q] */
      xassert(piv != NULL);
      p = piv->i, q = piv->j;
      /* remove p-th (pivot) row from the active set; it will never
         return there */
      if (R_prev[p] == 0)
         R_head[R_len[p]] = R_next[p];
      else
         R_next[R_prev[p]] = R_next[p];
      if (R_next[p] == 0)
         ;
      else
         R_prev[R_next[p]] = R_prev[p];
      /* remove q-th (pivot) column from the active set; it will never
         return there */
      if (C_prev[q] == 0)
         C_head[C_len[q]] = C_next[q];
      else
         C_next[C_prev[q]] = C_next[q];
      if (C_next[q] == 0)
         ;
      else
         C_prev[C_next[q]] = C_prev[q];
      /* store the pivot value in a separate array */
      mpq_set(V_piv[p], piv->val);
      /* remove the pivot from p-th row */
      if (piv->r_prev == NULL)
         V_row[p] = piv->r_next;
      else
         piv->r_prev->r_next = piv->r_next;
      if (piv->r_next == NULL)
         ;
      else
         piv->r_next->r_prev = piv->r_prev;
      R_len[p]--;
      /* remove the pivot from q-th column */
      if (piv->c_prev == NULL)
         V_col[q] = piv->c_next;
      else
         piv->c_prev->c_next = piv->c_next;
      if (piv->c_next == NULL)
         ;
      else
         piv->c_next->c_prev = piv->c_prev;
      C_len[q]--;
      /* free the space occupied by the pivot */
      mpq_clear(piv->val);
      dmp_free_atom(pool, piv, sizeof(LUXELM));
      /* walk through p-th (pivot) row, which already does not contain
         the pivot v[p,q], and do the following... */
      for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
      {  /* get column index of v[p,j] */
         j = vpj->j;
         /* store v[p,j] in the working array */
         flag[j] = 1;
         mpq_set(work[j], vpj->val);
         /* remove j-th column from the active set; it will return there
            later with a new length */
         if (C_prev[j] == 0)
            C_head[C_len[j]] = C_next[j];
         else
            C_next[C_prev[j]] = C_next[j];
         if (C_next[j] == 0)
            ;
         else
            C_prev[C_next[j]] = C_prev[j];
         /* v[p,j] leaves the active submatrix, so remove it from j-th
            column; however, v[p,j] is kept in p-th row */
         if (vpj->c_prev == NULL)
            V_col[j] = vpj->c_next;
         else
            vpj->c_prev->c_next = vpj->c_next;
         if (vpj->c_next == NULL)
            ;
         else
            vpj->c_next->c_prev = vpj->c_prev;
         C_len[j]--;
      }
      /* now walk through q-th (pivot) column, which already does not
         contain the pivot v[p,q], and perform gaussian elimination */
      while (V_col[q] != NULL)
      {  /* element v[i,q] has to be eliminated */
         viq = V_col[q];
         /* get row index of v[i,q] */
         i = viq->i;
         /* remove i-th row from the active set; later it will return
            there with a new length */
         if (R_prev[i] == 0)
            R_head[R_len[i]] = R_next[i];
         else
            R_next[R_prev[i]] = R_next[i];
         if (R_next[i] == 0)
            ;
         else
            R_prev[R_next[i]] = R_prev[i];
         /* compute gaussian multiplier f[i,p] = v[i,q] / v[p,q] and
            store it in the matrix F */
         fip = dmp_get_atom(pool, sizeof(LUXELM));
         fip->i = i, fip->j = p;
         mpq_init(fip->val);
         mpq_div(fip->val, viq->val, V_piv[p]);
         fip->r_prev = NULL;
         fip->r_next = F_row[i];
         fip->c_prev = NULL;
         fip->c_next = F_col[p];
         if (fip->r_next != NULL) fip->r_next->r_prev = fip;
         if (fip->c_next != NULL) fip->c_next->c_prev = fip;
         F_row[i] = F_col[p] = fip;
         /* v[i,q] has to be eliminated, so remove it from i-th row */
         if (viq->r_prev == NULL)
            V_row[i] = viq->r_next;
         else
            viq->r_prev->r_next = viq->r_next;
         if (viq->r_next == NULL)
            ;
         else
            viq->r_next->r_prev = viq->r_prev;
         R_len[i]--;
         /* and also from q-th column */
         V_col[q] = viq->c_next;
         C_len[q]--;
         /* free the space occupied by v[i,q] */
         mpq_clear(viq->val);
         dmp_free_atom(pool, viq, sizeof(LUXELM));
         /* perform gaussian transformation:
            (i-th row) := (i-th row) - f[i,p] * (p-th row)
            note that now p-th row, which is in the working array,
            does not contain the pivot v[p,q], and i-th row does not
            contain the element v[i,q] to be eliminated */
         /* walk through i-th row and transform existing non-zero
            elements */
         for (vij = V_row[i]; vij != NULL; vij = next)
         {  next = vij->r_next;
            /* get column index of v[i,j] */
            j = vij->j;
            /* v[i,j] := v[i,j] - f[i,p] * v[p,j] */
            if (flag[j])
            {  /* v[p,j] != 0 */
               flag[j] = 0;
               mpq_mul(temp, fip->val, work[j]);
               mpq_sub(vij->val, vij->val, temp);
               if (mpq_sgn(vij->val) == 0)
               {  /* new v[i,j] is zero, so remove it from the active
                     submatrix */
                  /* remove v[i,j] from i-th row */
                  if (vij->r_prev == NULL)
                     V_row[i] = vij->r_next;
                  else
                     vij->r_prev->r_next = vij->r_next;
                  if (vij->r_next == NULL)
                     ;
                  else
                     vij->r_next->r_prev = vij->r_prev;
                  R_len[i]--;
                  /* remove v[i,j] from j-th column */
                  if (vij->c_prev == NULL)
                     V_col[j] = vij->c_next;
                  else
                     vij->c_prev->c_next = vij->c_next;
                  if (vij->c_next == NULL)
                     ;
                  else
                     vij->c_next->c_prev = vij->c_prev;
                  C_len[j]--;
                  /* free the space occupied by v[i,j] */
                  mpq_clear(vij->val);
                  dmp_free_atom(pool, vij, sizeof(LUXELM));
               }
            }
         }
         /* now flag is the pattern of the set v[p,*] \ v[i,*] */
         /* walk through p-th (pivot) row and create new elements in
            i-th row, which appear due to fill-in */
         for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
         {  j = vpj->j;
            if (flag[j])
            {  /* create new non-zero v[i,j] = 0 - f[i,p] * v[p,j] and
                  add it to i-th row and j-th column */
               vij = dmp_get_atom(pool, sizeof(LUXELM));
               vij->i = i, vij->j = j;
               mpq_init(vij->val);
               mpq_mul(vij->val, fip->val, work[j]);
               mpq_neg(vij->val, vij->val);
               vij->r_prev = NULL;
               vij->r_next = V_row[i];
               vij->c_prev = NULL;
               vij->c_next = V_col[j];
               if (vij->r_next != NULL) vij->r_next->r_prev = vij;
               if (vij->c_next != NULL) vij->c_next->c_prev = vij;
               V_row[i] = V_col[j] = vij;
               R_len[i]++, C_len[j]++;
            }
            else
            {  /* there is no fill-in, because v[i,j] already exists in
                  i-th row; restore the flag, which was reset before */
               flag[j] = 1;
            }
         }
         /* now i-th row has been completely transformed and can return
            to the active set with a new length */
         R_prev[i] = 0;
         R_next[i] = R_head[R_len[i]];
         if (R_next[i] != 0) R_prev[R_next[i]] = i;
         R_head[R_len[i]] = i;
      }
      /* at this point q-th (pivot) column must be empty */
      xassert(C_len[q] == 0);
      /* walk through p-th (pivot) row again and do the following... */
      for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
      {  /* get column index of v[p,j] */
         j = vpj->j;
         /* erase v[p,j] from the working array */
         flag[j] = 0;
         mpq_set_si(work[j], 0, 1);
         /* now j-th column has been completely transformed, so it can
            return to the active list with a new length */
         C_prev[j] = 0;
         C_next[j] = C_head[C_len[j]];
         if (C_next[j] != 0) C_prev[C_next[j]] = j;
         C_head[C_len[j]] = j;
      }
      mpq_clear(temp);
      /* return to the factorizing routine */
      return;
}

/***********************************************************************
*  lux_decomp - compute LU-factorization
*
*  SYNOPSIS
*
*  #include "lux.h"
*  int lux_decomp(LUX *lux, int (*col)(void *info, int j, int ind[],
*     mpq_t val[]), void *info);
*
*  DESCRIPTION
*
*  The routine lux_decomp computes LU-factorization of a given square
*  matrix A.
*
*  The parameter lux specifies LU-factorization data structure built by
*  means of the routine lux_create.
*
*  The formal routine col specifies the original matrix A. In order to
*  obtain j-th column of the matrix A the routine lux_decomp calls the
*  routine col with the parameter j (1 <= j <= n, where n is the order
*  of A). In response the routine col should store row indices and
*  numerical values of non-zero elements of j-th column of A to the
*  locations ind[1], ..., ind[len] and val[1], ..., val[len], resp.,
*  where len is the number of non-zeros in j-th column, which should be
*  returned on exit. Neiter zero nor duplicate elements are allowed.
*
*  The parameter info is a transit pointer passed to the formal routine
*  col; it can be used for various purposes.
*
*  RETURNS
*
*  The routine lux_decomp returns the singularity flag. Zero flag means
*  that the original matrix A is non-singular while non-zero flag means
*  that A is (exactly!) singular.
*
*  Note that LU-factorization is valid in both cases, however, in case
*  of singularity some rows of the matrix V (including pivot elements)
*  will be empty.
*
*  REPAIRING SINGULAR MATRIX
*
*  If the routine lux_decomp returns non-zero flag, it provides all
*  necessary information that can be used for "repairing" the matrix A,
*  where "repairing" means replacing linearly dependent columns of the
*  matrix A by appropriate columns of the unity matrix. This feature is
*  needed when the routine lux_decomp is used for reinverting the basis
*  matrix within the simplex method procedure.
*
*  On exit linearly dependent columns of the matrix U have the numbers
*  rank+1, rank+2, ..., n, where rank is the exact rank of the matrix A
*  stored by the routine to the member lux->rank. The correspondence
*  between columns of A and U is the same as between columns of V and U.
*  Thus, linearly dependent columns of the matrix A have the numbers
*  Q_col[rank+1], Q_col[rank+2], ..., Q_col[n], where Q_col is an array
*  representing the permutation matrix Q in column-like format. It is
*  understood that each j-th linearly dependent column of the matrix U
*  should be replaced by the unity vector, where all elements are zero
*  except the unity diagonal element u[j,j]. On the other hand j-th row
*  of the matrix U corresponds to the row of the matrix V (and therefore
*  of the matrix A) with the number P_row[j], where P_row is an array
*  representing the permutation matrix P in row-like format. Thus, each
*  j-th linearly dependent column of the matrix U should be replaced by
*  a column of the unity matrix with the number P_row[j].
*
*  The code that repairs the matrix A may look like follows:
*
*     for (j = rank+1; j <= n; j++)
*     {  replace column Q_col[j] of the matrix A by column P_row[j] of
*        the unity matrix;
*     }
*
*  where rank, P_row, and Q_col are members of the structure LUX. */

int lux_decomp(LUX *lux, int (*col)(void *info, int j, int ind[],
      mpq_t val[]), void *info)
{     int n = lux->n;
      LUXELM **V_row = lux->V_row;
      LUXELM **V_col = lux->V_col;
      int *P_row = lux->P_row;
      int *P_col = lux->P_col;
      int *Q_row = lux->Q_row;
      int *Q_col = lux->Q_col;
      LUXELM *piv, *vij;
      LUXWKA *wka;
      int i, j, k, p, q, t, *flag;
      mpq_t *work;
      /* allocate working area */
      wka = xmalloc(sizeof(LUXWKA));
      wka->R_len = xcalloc(1+n, sizeof(int));
      wka->R_head = xcalloc(1+n, sizeof(int));
      wka->R_prev = xcalloc(1+n, sizeof(int));
      wka->R_next = xcalloc(1+n, sizeof(int));
      wka->C_len = xcalloc(1+n, sizeof(int));
      wka->C_head = xcalloc(1+n, sizeof(int));
      wka->C_prev = xcalloc(1+n, sizeof(int));
      wka->C_next = xcalloc(1+n, sizeof(int));
      /* initialize LU-factorization data structures */
      initialize(lux, col, info, wka);
      /* allocate working arrays */
      flag = xcalloc(1+n, sizeof(int));
      work = xcalloc(1+n, sizeof(mpq_t));
      for (k = 1; k <= n; k++)
      {  flag[k] = 0;
         mpq_init(work[k]);
      }
      /* main elimination loop */
      for (k = 1; k <= n; k++)
      {  /* choose a pivot element v[p,q] */
         piv = find_pivot(lux, wka);
         if (piv == NULL)
         {  /* no pivot can be chosen, because the active submatrix is
               empty */
            break;
         }
         /* determine row and column indices of the pivot element */
         p = piv->i, q = piv->j;
         /* let v[p,q] correspond to u[i',j']; permute k-th and i'-th
            rows and k-th and j'-th columns of the matrix U = P*V*Q to
            move the element u[i',j'] to the position u[k,k] */
         i = P_col[p], j = Q_row[q];
         xassert(k <= i && i <= n && k <= j && j <= n);
         /* permute k-th and i-th rows of the matrix U */
         t = P_row[k];
         P_row[i] = t, P_col[t] = i;
         P_row[k] = p, P_col[p] = k;
         /* permute k-th and j-th columns of the matrix U */
         t = Q_col[k];
         Q_col[j] = t, Q_row[t] = j;
         Q_col[k] = q, Q_row[q] = k;
         /* eliminate subdiagonal elements of k-th column of the matrix
            U = P*V*Q using the pivot element u[k,k] = v[p,q] */
         eliminate(lux, wka, piv, flag, work);
      }
      /* determine the rank of A (and V) */
      lux->rank = k - 1;
      /* free working arrays */
      xfree(flag);
      for (k = 1; k <= n; k++) mpq_clear(work[k]);
      xfree(work);
      /* build column lists of the matrix V using its row lists */
      for (j = 1; j <= n; j++)
         xassert(V_col[j] == NULL);
      for (i = 1; i <= n; i++)
      {  for (vij = V_row[i]; vij != NULL; vij = vij->r_next)
         {  j = vij->j;
            vij->c_prev = NULL;
            vij->c_next = V_col[j];
            if (vij->c_next != NULL) vij->c_next->c_prev = vij;
            V_col[j] = vij;
         }
      }
      /* free working area */
      xfree(wka->R_len);
      xfree(wka->R_head);
      xfree(wka->R_prev);
      xfree(wka->R_next);
      xfree(wka->C_len);
      xfree(wka->C_head);
      xfree(wka->C_prev);
      xfree(wka->C_next);
      xfree(wka);
      /* return to the calling program */
      return (lux->rank < n);
}

/***********************************************************************
*  lux_f_solve - solve system F*x = b or F'*x = b
*
*  SYNOPSIS
*
*  #include "lux.h"
*  void lux_f_solve(LUX *lux, int tr, mpq_t x[]);
*
*  DESCRIPTION
*
*  The routine lux_f_solve solves either the system F*x = b (if the
*  flag tr is zero) or the system F'*x = b (if the flag tr is non-zero),
*  where the matrix F is a component of LU-factorization specified by
*  the parameter lux, F' is a matrix transposed to F.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix F. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void lux_f_solve(LUX *lux, int tr, mpq_t x[])
{     int n = lux->n;
      LUXELM **F_row = lux->F_row;
      LUXELM **F_col = lux->F_col;
      int *P_row = lux->P_row;
      LUXELM *fik, *fkj;
      int i, j, k;
      mpq_t temp;
      mpq_init(temp);
      if (!tr)
      {  /* solve the system F*x = b */
         for (j = 1; j <= n; j++)
         {  k = P_row[j];
            if (mpq_sgn(x[k]) != 0)
            {  for (fik = F_col[k]; fik != NULL; fik = fik->c_next)
               {  mpq_mul(temp, fik->val, x[k]);
                  mpq_sub(x[fik->i], x[fik->i], temp);
               }
            }
         }
      }
      else
      {  /* solve the system F'*x = b */
         for (i = n; i >= 1; i--)
         {  k = P_row[i];
            if (mpq_sgn(x[k]) != 0)
            {  for (fkj = F_row[k]; fkj != NULL; fkj = fkj->r_next)
               {  mpq_mul(temp, fkj->val, x[k]);
                  mpq_sub(x[fkj->j], x[fkj->j], temp);
               }
            }
         }
      }
      mpq_clear(temp);
      return;
}

/***********************************************************************
*  lux_v_solve - solve system V*x = b or V'*x = b
*
*  SYNOPSIS
*
*  #include "lux.h"
*  void lux_v_solve(LUX *lux, int tr, double x[]);
*
*  DESCRIPTION
*
*  The routine lux_v_solve solves either the system V*x = b (if the
*  flag tr is zero) or the system V'*x = b (if the flag tr is non-zero),
*  where the matrix V is a component of LU-factorization specified by
*  the parameter lux, V' is a matrix transposed to V.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix V. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void lux_v_solve(LUX *lux, int tr, mpq_t x[])
{     int n = lux->n;
      mpq_t *V_piv = lux->V_piv;
      LUXELM **V_row = lux->V_row;
      LUXELM **V_col = lux->V_col;
      int *P_row = lux->P_row;
      int *Q_col = lux->Q_col;
      LUXELM *vij;
      int i, j, k;
      mpq_t *b, temp;
      b = xcalloc(1+n, sizeof(mpq_t));
      for (k = 1; k <= n; k++)
         mpq_init(b[k]), mpq_set(b[k], x[k]), mpq_set_si(x[k], 0, 1);
      mpq_init(temp);
      if (!tr)
      {  /* solve the system V*x = b */
         for (k = n; k >= 1; k--)
         {  i = P_row[k], j = Q_col[k];
            if (mpq_sgn(b[i]) != 0)
            {  mpq_set(x[j], b[i]);
               mpq_div(x[j], x[j], V_piv[i]);
               for (vij = V_col[j]; vij != NULL; vij = vij->c_next)
               {  mpq_mul(temp, vij->val, x[j]);
                  mpq_sub(b[vij->i], b[vij->i], temp);
               }
            }
         }
      }
      else
      {  /* solve the system V'*x = b */
         for (k = 1; k <= n; k++)
         {  i = P_row[k], j = Q_col[k];
            if (mpq_sgn(b[j]) != 0)
            {  mpq_set(x[i], b[j]);
               mpq_div(x[i], x[i], V_piv[i]);
               for (vij = V_row[i]; vij != NULL; vij = vij->r_next)
               {  mpq_mul(temp, vij->val, x[i]);
                  mpq_sub(b[vij->j], b[vij->j], temp);
               }
            }
         }
      }
      for (k = 1; k <= n; k++) mpq_clear(b[k]);
      mpq_clear(temp);
      xfree(b);
      return;
}

/***********************************************************************
*  lux_solve - solve system A*x = b or A'*x = b
*
*  SYNOPSIS
*
*  #include "lux.h"
*  void lux_solve(LUX *lux, int tr, mpq_t x[]);
*
*  DESCRIPTION
*
*  The routine lux_solve solves either the system A*x = b (if the flag
*  tr is zero) or the system A'*x = b (if the flag tr is non-zero),
*  where the parameter lux specifies LU-factorization of the matrix A,
*  A' is a matrix transposed to A.
*
*  On entry the array x should contain elements of the right-hand side
*  vector b in locations x[1], ..., x[n], where n is the order of the
*  matrix A. On exit this array will contain elements of the solution
*  vector x in the same locations. */

void lux_solve(LUX *lux, int tr, mpq_t x[])
{     if (lux->rank < lux->n)
         xfault("lux_solve: LU-factorization has incomplete rank\n");
      if (!tr)
      {  /* A = F*V, therefore inv(A) = inv(V)*inv(F) */
         lux_f_solve(lux, 0, x);
         lux_v_solve(lux, 0, x);
      }
      else
      {  /* A' = V'*F', therefore inv(A') = inv(F')*inv(V') */
         lux_v_solve(lux, 1, x);
         lux_f_solve(lux, 1, x);
      }
      return;
}

/***********************************************************************
*  lux_delete - delete LU-factorization
*
*  SYNOPSIS
*
*  #include "lux.h"
*  void lux_delete(LUX *lux);
*
*  DESCRIPTION
*
*  The routine lux_delete deletes LU-factorization data structure,
*  which the parameter lux points to, freeing all the memory allocated
*  to this object. */

void lux_delete(LUX *lux)
{     int n = lux->n;
      LUXELM *fij, *vij;
      int i;
      for (i = 1; i <= n; i++)
      {  for (fij = lux->F_row[i]; fij != NULL; fij = fij->r_next)
            mpq_clear(fij->val);
         mpq_clear(lux->V_piv[i]);
         for (vij = lux->V_row[i]; vij != NULL; vij = vij->r_next)
            mpq_clear(vij->val);
      }
      dmp_delete_pool(lux->pool);
      xfree(lux->F_row);
      xfree(lux->F_col);
      xfree(lux->V_piv);
      xfree(lux->V_row);
      xfree(lux->V_col);
      xfree(lux->P_row);
      xfree(lux->P_col);
      xfree(lux->Q_row);
      xfree(lux->Q_col);
      xfree(lux);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/draft/lux.h0000644000175100001710000002066200000000000024173 0ustar00runnerdocker00000000000000/* lux.h (LU-factorization, rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef LUX_H
#define LUX_H

#include "dmp.h"
#include "mygmp.h"

/***********************************************************************
*  The structure LUX defines LU-factorization of a square matrix A,
*  which is the following quartet:
*
*     [A] = (F, V, P, Q),                                            (1)
*
*  where F and V are such matrices that
*
*     A = F * V,                                                     (2)
*
*  and P and Q are such permutation matrices that the matrix
*
*     L = P * F * inv(P)                                             (3)
*
*  is lower triangular with unity diagonal, and the matrix
*
*     U = P * V * Q                                                  (4)
*
*  is upper triangular. All the matrices have the order n.
*
*  The matrices F and V are stored in row/column-wise sparse format as
*  row and column linked lists of non-zero elements. Unity elements on
*  the main diagonal of the matrix F are not stored. Pivot elements of
*  the matrix V (that correspond to diagonal elements of the matrix U)
*  are also missing from the row and column lists and stored separately
*  in an ordinary array.
*
*  The permutation matrices P and Q are stored as ordinary arrays using
*  both row- and column-like formats.
*
*  The matrices L and U being completely defined by the matrices F, V,
*  P, and Q are not stored explicitly.
*
*  It is easy to show that the factorization (1)-(3) is some version of
*  LU-factorization. Indeed, from (3) and (4) it follows that:
*
*     F = inv(P) * L * P,
*
*     V = inv(P) * U * inv(Q),
*
*  and substitution into (2) gives:
*
*     A = F * V = inv(P) * L * U * inv(Q).
*
*  For more details see the program documentation. */

typedef struct LUX LUX;
typedef struct LUXELM LUXELM;
typedef struct LUXWKA LUXWKA;

struct LUX
{     /* LU-factorization of a square matrix */
      int n;
      /* the order of matrices A, F, V, P, Q */
      DMP *pool;
      /* memory pool for elements of matrices F and V */
      LUXELM **F_row; /* LUXELM *F_row[1+n]; */
      /* F_row[0] is not used;
         F_row[i], 1 <= i <= n, is a pointer to the list of elements in
         i-th row of matrix F (diagonal elements are not stored) */
      LUXELM **F_col; /* LUXELM *F_col[1+n]; */
      /* F_col[0] is not used;
         F_col[j], 1 <= j <= n, is a pointer to the list of elements in
         j-th column of matrix F (diagonal elements are not stored) */
      mpq_t *V_piv; /* mpq_t V_piv[1+n]; */
      /* V_piv[0] is not used;
         V_piv[p], 1 <= p <= n, is a pivot element v[p,q] corresponding
         to a diagonal element u[k,k] of matrix U = P*V*Q (used on k-th
         elimination step, k = 1, 2, ..., n) */
      LUXELM **V_row; /* LUXELM *V_row[1+n]; */
      /* V_row[0] is not used;
         V_row[i], 1 <= i <= n, is a pointer to the list of elements in
         i-th row of matrix V (except pivot elements) */
      LUXELM **V_col; /* LUXELM *V_col[1+n]; */
      /* V_col[0] is not used;
         V_col[j], 1 <= j <= n, is a pointer to the list of elements in
         j-th column of matrix V (except pivot elements) */
      int *P_row; /* int P_row[1+n]; */
      /* P_row[0] is not used;
         P_row[i] = j means that p[i,j] = 1, where p[i,j] is an element
         of permutation matrix P */
      int *P_col; /* int P_col[1+n]; */
      /* P_col[0] is not used;
         P_col[j] = i means that p[i,j] = 1, where p[i,j] is an element
         of permutation matrix P */
      /* if i-th row or column of matrix F is i'-th row or column of
         matrix L = P*F*inv(P), or if i-th row of matrix V is i'-th row
         of matrix U = P*V*Q, then P_row[i'] = i and P_col[i] = i' */
      int *Q_row; /* int Q_row[1+n]; */
      /* Q_row[0] is not used;
         Q_row[i] = j means that q[i,j] = 1, where q[i,j] is an element
         of permutation matrix Q */
      int *Q_col; /* int Q_col[1+n]; */
      /* Q_col[0] is not used;
         Q_col[j] = i means that q[i,j] = 1, where q[i,j] is an element
         of permutation matrix Q */
      /* if j-th column of matrix V is j'-th column of matrix U = P*V*Q,
         then Q_row[j] = j' and Q_col[j'] = j */
      int rank;
      /* the (exact) rank of matrices A and V */
};

struct LUXELM
{     /* element of matrix F or V */
      int i;
      /* row index, 1 <= i <= m */
      int j;
      /* column index, 1 <= j <= n */
      mpq_t val;
      /* numeric (non-zero) element value */
      LUXELM *r_prev;
      /* pointer to previous element in the same row */
      LUXELM *r_next;
      /* pointer to next element in the same row */
      LUXELM *c_prev;
      /* pointer to previous element in the same column */
      LUXELM *c_next;
      /* pointer to next element in the same column */
};

struct LUXWKA
{     /* working area (used only during factorization) */
      /* in order to efficiently implement Markowitz strategy and Duff
         search technique there are two families {R[0], R[1], ..., R[n]}
         and {C[0], C[1], ..., C[n]}; member R[k] is a set of active
         rows of matrix V having k non-zeros, and member C[k] is a set
         of active columns of matrix V having k non-zeros (in the active
         submatrix); each set R[k] and C[k] is implemented as a separate
         doubly linked list */
      int *R_len; /* int R_len[1+n]; */
      /* R_len[0] is not used;
         R_len[i], 1 <= i <= n, is the number of non-zero elements in
         i-th row of matrix V (that is the length of i-th row) */
      int *R_head; /* int R_head[1+n]; */
      /* R_head[k], 0 <= k <= n, is the number of a first row, which is
         active and whose length is k */
      int *R_prev; /* int R_prev[1+n]; */
      /* R_prev[0] is not used;
         R_prev[i], 1 <= i <= n, is the number of a previous row, which
         is active and has the same length as i-th row */
      int *R_next; /* int R_next[1+n]; */
      /* R_prev[0] is not used;
         R_prev[i], 1 <= i <= n, is the number of a next row, which is
         active and has the same length as i-th row */
      int *C_len; /* int C_len[1+n]; */
      /* C_len[0] is not used;
         C_len[j], 1 <= j <= n, is the number of non-zero elements in
         j-th column of the active submatrix of matrix V (that is the
         length of j-th column in the active submatrix) */
      int *C_head; /* int C_head[1+n]; */
      /* C_head[k], 0 <= k <= n, is the number of a first column, which
         is active and whose length is k */
      int *C_prev; /* int C_prev[1+n]; */
      /* C_prev[0] is not used;
         C_prev[j], 1 <= j <= n, is the number of a previous column,
         which is active and has the same length as j-th column */
      int *C_next; /* int C_next[1+n]; */
      /* C_next[0] is not used;
         C_next[j], 1 <= j <= n, is the number of a next column, which
         is active and has the same length as j-th column */
};

#define lux_create _glp_lux_create
LUX *lux_create(int n);
/* create LU-factorization */

#define lux_decomp _glp_lux_decomp
int lux_decomp(LUX *lux, int (*col)(void *info, int j, int ind[],
      mpq_t val[]), void *info);
/* compute LU-factorization */

#define lux_f_solve _glp_lux_f_solve
void lux_f_solve(LUX *lux, int tr, mpq_t x[]);
/* solve system F*x = b or F'*x = b */

#define lux_v_solve _glp_lux_v_solve
void lux_v_solve(LUX *lux, int tr, mpq_t x[]);
/* solve system V*x = b or V'*x = b */

#define lux_solve _glp_lux_solve
void lux_solve(LUX *lux, int tr, mpq_t x[]);
/* solve system A*x = b or A'*x = b */

#define lux_delete _glp_lux_delete
void lux_delete(LUX *lux);
/* delete LU-factorization */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.667143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/0000755000175100001710000000000000000000000022674 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/alloc.c0000644000175100001710000002042700000000000024137 0ustar00runnerdocker00000000000000/* alloc.c (dynamic memory allocation) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"

#define ALIGN 16
/* some processors need data to be properly aligned, so this macro
 * defines the alignment boundary, in bytes, provided by glpk memory
 * allocation routines; looks like 16-byte alignment boundary is
 * sufficient for all 32- and 64-bit platforms (8-byte boundary is not
 * sufficient for some 64-bit platforms because of jmp_buf) */

#define MBD_SIZE (((sizeof(MBD) + (ALIGN - 1)) / ALIGN) * ALIGN)
/* size of memory block descriptor, in bytes, rounded up to multiple
 * of the alignment boundary */

/***********************************************************************
*  dma - dynamic memory allocation (basic routine)
*
*  This routine performs dynamic memory allocation. It is similar to
*  the standard realloc function, however, it provides every allocated
*  memory block with a descriptor, which is used for sanity checks on
*  reallocating/freeing previously allocated memory blocks as well as
*  for book-keeping the memory usage statistics. */

static void *dma(const char *func, void *ptr, size_t size)
{     ENV *env = get_env_ptr();
      MBD *mbd;
      if (ptr == NULL)
      {  /* new memory block will be allocated */
         mbd = NULL;
      }
      else
      {  /* allocated memory block will be reallocated or freed */
         /* get pointer to the block descriptor */
         mbd = (MBD *)((char *)ptr - MBD_SIZE);
         /* make sure that the block descriptor is valid */
         if (mbd->self != mbd)
            xerror("%s: ptr = %p; invalid pointer\n", func, ptr);
         /* remove the block from the linked list */
         mbd->self = NULL;
         if (mbd->prev == NULL)
            env->mem_ptr = mbd->next;
         else
            mbd->prev->next = mbd->next;
         if (mbd->next == NULL)
            ;
         else
            mbd->next->prev = mbd->prev;
         /* decrease usage counts */
         if (!(env->mem_count >= 1 && env->mem_total >= mbd->size))
            xerror("%s: memory allocation error\n", func);
         env->mem_count--;
         env->mem_total -= mbd->size;
         if (size == 0)
         {  /* free the memory block */
            free(mbd);
            return NULL;
         }
      }
      /* allocate/reallocate memory block */
      if (size > SIZE_T_MAX - MBD_SIZE)
         xerror("%s: block too large\n", func);
      size += MBD_SIZE;
      if (size > env->mem_limit - env->mem_total)
         xerror("%s: memory allocation limit exceeded\n", func);
      if (env->mem_count == INT_MAX)
         xerror("%s: too many memory blocks allocated\n", func);
      mbd = (mbd == NULL ? malloc(size) : realloc(mbd, size));
      if (mbd == NULL)
         xerror("%s: no memory available\n", func);
      /* setup the block descriptor */
      mbd->size = size;
      mbd->self = mbd;
      mbd->prev = NULL;
      mbd->next = env->mem_ptr;
      /* add the block to the beginning of the linked list */
      if (mbd->next != NULL)
         mbd->next->prev = mbd;
      env->mem_ptr = mbd;
      /* increase usage counts */
      env->mem_count++;
      if (env->mem_cpeak < env->mem_count)
         env->mem_cpeak = env->mem_count;
      env->mem_total += size;
      if (env->mem_tpeak < env->mem_total)
         env->mem_tpeak = env->mem_total;
      return (char *)mbd + MBD_SIZE;
}

/***********************************************************************
*  NAME
*
*  glp_alloc - allocate memory block
*
*  SYNOPSIS
*
*  void *glp_alloc(int n, int size);
*
*  DESCRIPTION
*
*  The routine glp_alloc allocates a memory block of n * size bytes
*  long.
*
*  Note that being allocated the memory block contains arbitrary data
*  (not binary zeros!).
*
*  RETURNS
*
*  The routine glp_alloc returns a pointer to the block allocated.
*  To free this block the routine glp_free (not free!) must be used. */

void *glp_alloc(int n, int size)
{     if (n < 1)
         xerror("glp_alloc: n = %d; invalid parameter\n", n);
      if (size < 1)
         xerror("glp_alloc: size = %d; invalid parameter\n", size);
      if ((size_t)n > SIZE_T_MAX / (size_t)size)
         xerror("glp_alloc: n = %d, size = %d; block too large\n",
            n, size);
      return dma("glp_alloc", NULL, (size_t)n * (size_t)size);
}

/**********************************************************************/

void *glp_realloc(void *ptr, int n, int size)
{     /* reallocate memory block */
      if (ptr == NULL)
         xerror("glp_realloc: ptr = %p; invalid pointer\n", ptr);
      if (n < 1)
         xerror("glp_realloc: n = %d; invalid parameter\n", n);
      if (size < 1)
         xerror("glp_realloc: size = %d; invalid parameter\n", size);
      if ((size_t)n > SIZE_T_MAX / (size_t)size)
         xerror("glp_realloc: n = %d, size = %d; block too large\n",
            n, size);
      return dma("glp_realloc", ptr, (size_t)n * (size_t)size);
}

/***********************************************************************
*  NAME
*
*  glp_free - free (deallocate) memory block
*
*  SYNOPSIS
*
*  void glp_free(void *ptr);
*
*  DESCRIPTION
*
*  The routine glp_free frees (deallocates) a memory block pointed to
*  by ptr, which was previuosly allocated by the routine glp_alloc or
*  reallocated by the routine glp_realloc. */

void glp_free(void *ptr)
{     if (ptr == NULL)
         xerror("glp_free: ptr = %p; invalid pointer\n", ptr);
      dma("glp_free", ptr, 0);
      return;
}

/***********************************************************************
*  NAME
*
*  glp_mem_limit - set memory usage limit
*
*  SYNOPSIS
*
*  void glp_mem_limit(int limit);
*
*  DESCRIPTION
*
*  The routine glp_mem_limit limits the amount of memory available for
*  dynamic allocation (in GLPK routines) to limit megabytes. */

void glp_mem_limit(int limit)
{     ENV *env = get_env_ptr();
      if (limit < 1)
         xerror("glp_mem_limit: limit = %d; invalid parameter\n",
            limit);
      if ((size_t)limit <= (SIZE_T_MAX >> 20))
         env->mem_limit = (size_t)limit << 20;
      else
         env->mem_limit = SIZE_T_MAX;
      return;
}

/***********************************************************************
*  NAME
*
*  glp_mem_usage - get memory usage information
*
*  SYNOPSIS
*
*  void glp_mem_usage(int *count, int *cpeak, size_t *total,
*     size_t *tpeak);
*
*  DESCRIPTION
*
*  The routine glp_mem_usage reports some information about utilization
*  of the memory by GLPK routines. Information is stored to locations
*  specified by corresponding parameters (see below). Any parameter can
*  be specified as NULL, in which case its value is not stored.
*
*  *count is the number of the memory blocks currently allocated by the
*  routines glp_malloc and glp_calloc (one call to glp_malloc or
*  glp_calloc results in allocating one memory block).
*
*  *cpeak is the peak value of *count reached since the initialization
*  of the GLPK library environment.
*
*  *total is the total amount, in bytes, of the memory blocks currently
*  allocated by the routines glp_malloc and glp_calloc.
*
*  *tpeak is the peak value of *total reached since the initialization
*  of the GLPK library envirionment. */

void glp_mem_usage(int *count, int *cpeak, size_t *total,
      size_t *tpeak)
{     ENV *env = get_env_ptr();
      if (count != NULL)
         *count = env->mem_count;
      if (cpeak != NULL)
         *cpeak = env->mem_cpeak;
      if (total != NULL)
         *total = env->mem_total;
      if (tpeak != NULL)
         *tpeak = env->mem_tpeak;
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/dlsup.c0000644000175100001710000001041300000000000024166 0ustar00runnerdocker00000000000000/* dlsup.c (dynamic linking support) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "env.h"

/* GNU version ********************************************************/

#if defined(HAVE_LTDL)

#include 

void *xdlopen(const char *module)
{     /* open dynamically linked library */
      void *h = NULL;
      if (lt_dlinit() != 0)
      {  put_err_msg(lt_dlerror());
         goto done;
      }
      h = lt_dlopen(module);
      if (h == NULL)
      {  put_err_msg(lt_dlerror());
         if (lt_dlexit() != 0)
            xerror("xdlopen: %s\n", lt_dlerror());
      }
done: return h;
}

void *xdlsym(void *h, const char *symbol)
{     /* obtain address of symbol from dynamically linked library */
      void *ptr;
      xassert(h != NULL);
      ptr = lt_dlsym(h, symbol);
      if (ptr == NULL)
         xerror("xdlsym: %s: %s\n", symbol, lt_dlerror());
      return ptr;
}

void xdlclose(void *h)
{     /* close dynamically linked library */
      xassert(h != NULL);
      if (lt_dlclose(h) != 0)
         xerror("xdlclose: %s\n", lt_dlerror());
      if (lt_dlexit() != 0)
         xerror("xdlclose: %s\n", lt_dlerror());
      return;
}

/* POSIX version ******************************************************/

#elif defined(HAVE_DLFCN)

#include 

void *xdlopen(const char *module)
{     /* open dynamically linked library */
      void *h;
      h = dlopen(module, RTLD_NOW);
      if (h == NULL)
         put_err_msg(dlerror());
      return h;
}

void *xdlsym(void *h, const char *symbol)
{     /* obtain address of symbol from dynamically linked library */
      void *ptr;
      xassert(h != NULL);
      ptr = dlsym(h, symbol);
      if (ptr == NULL)
         xerror("xdlsym: %s: %s\n", symbol, dlerror());
      return ptr;
}

void xdlclose(void *h)
{     /* close dynamically linked library */
      xassert(h != NULL);
      if (dlclose(h) != 0)
         xerror("xdlclose: %s\n", dlerror());
      return;
}

/* MS Windows version *************************************************/

#elif defined(__WOE__)

#include 

void *xdlopen(const char *module)
{     /* open dynamically linked library */
      void *h;
      h = LoadLibrary(module);
      if (h == NULL)
      {  char msg[20];
         sprintf(msg, "Error %d", GetLastError());
         put_err_msg(msg);
      }
      return h;
}

void *xdlsym(void *h, const char *symbol)
{     /* obtain address of symbol from dynamically linked library */
      void *ptr;
      xassert(h != NULL);
      ptr = GetProcAddress(h, symbol);
      if (ptr == NULL)
         xerror("xdlsym: %s: Error %d\n", symbol, GetLastError());
      return ptr;
}

void xdlclose(void *h)
{     /* close dynamically linked library */
      xassert(h != NULL);
      if (!FreeLibrary(h))
         xerror("xdlclose: Error %d\n", GetLastError());
      return;
}

/* NULL version *******************************************************/

#else

void *xdlopen(const char *module)
{     /* open dynamically linked library */
      xassert(module == module);
      put_err_msg("Shared libraries not supported");
      return NULL;
}

void *xdlsym(void *h, const char *symbol)
{     /* obtain address of symbol from dynamically linked library */
      xassert(h != h);
      xassert(symbol != symbol);
      return NULL;
}

void xdlclose(void *h)
{     /* close dynamically linked library */
      xassert(h != h);
      return;
}

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/env.c0000644000175100001710000002150200000000000023630 0ustar00runnerdocker00000000000000/* env.c (GLPK environment initialization/termination) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "glpk_tls_config.h"

#include "glpk.h"
#include "env.h"

#include "igraph_error.h"

/***********************************************************************
*  NAME
*
*  glp_init_env - initialize GLPK environment
*
*  SYNOPSIS
*
*  int glp_init_env(void);
*
*  DESCRIPTION
*
*  The routine glp_init_env initializes the GLPK environment. Normally
*  the application program does not need to call this routine, because
*  it is called automatically on the first call to any API routine.
*
*  RETURNS
*
*  The routine glp_init_env returns one of the following codes:
*
*  0 - initialization successful;
*  1 - environment has been already initialized;
*  2 - initialization failed (insufficient memory);
*  3 - initialization failed (unsupported programming model). */

int glp_init_env(void)
{     ENV *env;
      int ok;
      /* check if the programming model is supported */
      ok = (CHAR_BIT == 8 && sizeof(char) == 1 &&
         sizeof(short) == 2 && sizeof(int) == 4 &&
         (sizeof(void *) == 4 || sizeof(void *) == 8));
      if (!ok)
         return 3;
      /* check if the environment is already initialized */
      if (tls_get_ptr() != NULL)
         return 1;
      /* allocate and initialize the environment block */
      env = malloc(sizeof(ENV));
      if (env == NULL)
         return 2;
      memset(env, 0, sizeof(ENV));
#if 0 /* 14/I-2017 */
      sprintf(env->version, "%d.%d",
         GLP_MAJOR_VERSION, GLP_MINOR_VERSION);
#endif
      env->self = env;
      env->term_buf = malloc(TBUF_SIZE);
      if (env->term_buf == NULL)
      {  free(env);
         return 2;
      }
      env->term_out = GLP_ON;
      env->term_hook = NULL;
      env->term_info = NULL;
      env->tee_file = NULL;
#if 1 /* 23/XI-2015 */
      env->err_st = 0;
#endif
      env->err_file = NULL;
      env->err_line = 0;
      env->err_hook = NULL;
      env->err_info = NULL;
      env->err_buf = malloc(EBUF_SIZE);
      if (env->err_buf == NULL)
      {  free(env->term_buf);
         free(env);
         return 2;
      }
      env->err_buf[0] = '\0';
      env->mem_limit = SIZE_T_MAX;
      env->mem_ptr = NULL;
      env->mem_count = env->mem_cpeak = 0;
      env->mem_total = env->mem_tpeak = 0;
#if 1 /* 23/XI-2015 */
      env->gmp_pool = NULL;
      env->gmp_size = 0;
      env->gmp_work = NULL;
#endif
      env->h_odbc = env->h_mysql = NULL;
      /* save pointer to the environment block */
      tls_set_ptr(env);
      /* initialization successful */
      return 0;
}

/***********************************************************************
*  NAME
*
*  get_env_ptr - retrieve pointer to environment block
*
*  SYNOPSIS
*
*  #include "env.h"
*  ENV *get_env_ptr(void);
*
*  DESCRIPTION
*
*  The routine get_env_ptr retrieves and returns a pointer to the GLPK
*  environment block.
*
*  If the GLPK environment has not been initialized yet, the routine
*  performs initialization. If initialization fails, the routine prints
*  an error message to stderr and terminates the program.
*
*  RETURNS
*
*  The routine returns a pointer to the environment block. */

ENV *get_env_ptr(void)
{     ENV *env = tls_get_ptr();
      /* check if the environment has been initialized */
      if (env == NULL)
      {  /* not initialized yet; perform initialization */
         if (glp_init_env() != 0)
         {  /* initialization failed; display an error message */
            IGRAPH_FATAL("GLPK initialization failed");
         }
         /* initialization successful; retrieve the pointer */
         env = tls_get_ptr();
      }
      /* check if the environment block is valid */
      if (env->self != env)
      {
         IGRAPH_FATAL("Invalid GLPK environment");
      }
      return env;
}

/***********************************************************************
*  NAME
*
*  glp_version - determine library version
*
*  SYNOPSIS
*
*  const char *glp_version(void);
*
*  RETURNS
*
*  The routine glp_version returns a pointer to a null-terminated
*  character string, which specifies the version of the GLPK library in
*  the form "X.Y", where X is the major version number, and Y is the
*  minor version number, for example, "4.16". */

#define str(s) # s
#define xstr(s) str(s)

const char *glp_version(void)
#if 0 /* 14/I-2017 */
{     ENV *env = get_env_ptr();
      return env->version;
}
#else /* suggested by Heinrich */
{     return
         xstr(GLP_MAJOR_VERSION) "." xstr(GLP_MINOR_VERSION);
}
#endif

/***********************************************************************
*  NAME
*
*  glp_config - determine library configuration
*
*  SYNOPSIS
*
*  const char *glp_config(const char *option);
*
*  DESCRIPTION
*
*  The routine glp_config determines some options which were specified
*  on configuring the GLPK library.
*
*  RETURNS
*
*  The routine glp_config returns a pointer to a null-terminating
*  string depending on the option inquired.
*
*  For option = "TLS" the routine returns the thread local storage
*  class specifier used (e.g. "_Thread_local") if the GLPK library was
*  configured to run in multi-threaded environment, or NULL otherwise.
*
*  For option = "ODBC_DLNAME" the routine returns the name of ODBC
*  shared library if this option was enabled, or NULL otherwise.
*
*  For option = "MYSQL_DLNAME" the routine returns the name of MySQL
*  shared library if this option was enabled, or NULL otherwise. */

const char *glp_config(const char *option)
{     const char *s;
      if (strcmp(option, "TLS") == 0)
#ifndef TLS
         s = NULL;
#else
         s = xstr(TLS);
#endif
      else if (strcmp(option, "ODBC_DLNAME") == 0)
#ifndef ODBC_DLNAME
         s = NULL;
#else
         s = ODBC_DLNAME;
#endif
      else if (strcmp(option, "MYSQL_DLNAME") == 0)
#ifndef MYSQL_DLNAME
         s = NULL;
#else
         s = MYSQL_DLNAME;
#endif
      else
      {  /* invalid option is always disabled */
         s = NULL;
      }
      return s;
}

/***********************************************************************
*  NAME
*
*  glp_free_env - free GLPK environment
*
*  SYNOPSIS
*
*  int glp_free_env(void);
*
*  DESCRIPTION
*
*  The routine glp_free_env frees all resources used by GLPK routines
*  (memory blocks, etc.) which are currently still in use.
*
*  Normally the application program does not need to call this routine,
*  because GLPK routines always free all unused resources. However, if
*  the application program even has deleted all problem objects, there
*  will be several memory blocks still allocated for the library needs.
*  For some reasons the application program may want GLPK to free this
*  memory, in which case it should call glp_free_env.
*
*  Note that a call to glp_free_env invalidates all problem objects as
*  if no GLPK routine were called.
*
*  RETURNS
*
*  0 - termination successful;
*  1 - environment is inactive (was not initialized). */

int glp_free_env(void)
{     ENV *env = tls_get_ptr();
      MBD *desc;
      /* check if the environment is active */
      if (env == NULL)
         return 1;
      /* check if the environment block is valid */
      if (env->self != env)
      {
         IGRAPH_FATAL("Invalid GLPK environment");
      }
      /* close handles to shared libraries */
      if (env->h_odbc != NULL)
         xdlclose(env->h_odbc);
      if (env->h_mysql != NULL)
         xdlclose(env->h_mysql);
      /* free memory blocks which are still allocated */
      while (env->mem_ptr != NULL)
      {  desc = env->mem_ptr;
         env->mem_ptr = desc->next;
         free(desc);
      }
      /* close text file used for copying terminal output */
      if (env->tee_file != NULL)
         fclose(env->tee_file);
      /* invalidate the environment block */
      env->self = NULL;
      /* free memory allocated to the environment block */
      free(env->term_buf);
      free(env->err_buf);
      free(env);
      /* reset a pointer to the environment block */
      tls_set_ptr(NULL);
      /* termination successful */
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/env.h0000644000175100001710000002052200000000000023636 0ustar00runnerdocker00000000000000/* env.h (GLPK environment) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef ENV_H
#define ENV_H

#include "stdc.h"

#include "igraph_error.h" /* IGRAPH_FILE_BASENAME */

typedef struct ENV ENV;
typedef struct MBD MBD;

#ifndef SIZE_T_MAX
#define SIZE_T_MAX (~(size_t)0)
#endif
/* largest value of size_t type */

#define TBUF_SIZE 4096
/* terminal output buffer size, in bytes */

#define EBUF_SIZE 1024
/* error message buffer size, in bytes */

/* enable/disable flag: */
#define GLP_ON  1
#define GLP_OFF 0

struct ENV
{     /* GLPK environment block */
#if 0 /* 14/I-2007 */
      char version[7+1];
      /* version string returned by the routine glp_version */
#endif
      ENV *self;
      /* pointer to this block to check its validity */
      /*--------------------------------------------------------------*/
      /* terminal output */
      char *term_buf; /* char term_buf[TBUF_SIZE]; */
      /* terminal output buffer */
      int term_out;
      /* flag to enable/disable terminal output */
      int (*term_hook)(void *info, const char *s);
      /* user-defined routine to intercept terminal output */
      void *term_info;
      /* transit pointer (cookie) passed to the routine term_hook */
      FILE *tee_file;
      /* output stream used to copy terminal output */
      /*--------------------------------------------------------------*/
      /* error handling */
#if 1 /* 07/XI-2015 */
      int err_st;
      /* error state flag; set on entry to glp_error */
#endif
      const char *err_file;
      /* value of the __FILE__ macro passed to glp_error */
      int err_line;
      /* value of the __LINE__ macro passed to glp_error */
      void (*err_hook)(void *info);
      /* user-defined routine to intercept abnormal termination */
      void *err_info;
      /* transit pointer (cookie) passed to the routine err_hook */
      char *err_buf; /* char err_buf[EBUF_SIZE]; */
      /* buffer to store error messages (used by I/O routines) */
      /*--------------------------------------------------------------*/
      /* dynamic memory allocation */
      size_t mem_limit;
      /* maximal amount of memory, in bytes, available for dynamic
       * allocation */
      MBD *mem_ptr;
      /* pointer to the linked list of allocated memory blocks */
      int mem_count;
      /* total number of currently allocated memory blocks */
      int mem_cpeak;
      /* peak value of mem_count */
      size_t mem_total;
      /* total amount of currently allocated memory, in bytes; it is
       * the sum of the size field over all memory block descriptors */
      size_t mem_tpeak;
      /* peak value of mem_total */
#if 1 /* 23/XI-2015 */
      /*--------------------------------------------------------------*/
      /* bignum module working area */
      void *gmp_pool; /* DMP *gmp_pool; */
      /* working memory pool */
      int gmp_size;
      /* size of working array */
      unsigned short *gmp_work; /* ushort gmp_work[gmp_size]; */
      /* working array */
#endif
      /*--------------------------------------------------------------*/
      /* dynamic linking support (optional) */
      void *h_odbc;
      /* handle to ODBC shared library */
      void *h_mysql;
      /* handle to MySQL shared library */
};

struct MBD
{     /* memory block descriptor */
      size_t size;
      /* size of block, in bytes, including descriptor */
      MBD *self;
      /* pointer to this descriptor to check its validity */
      MBD *prev;
      /* pointer to previous memory block descriptor */
      MBD *next;
      /* pointer to next memory block descriptor */
};

#define get_env_ptr _glp_get_env_ptr
ENV *get_env_ptr(void);
/* retrieve pointer to environment block */

#define tls_set_ptr _glp_tls_set_ptr
void tls_set_ptr(void *ptr);
/* store global pointer in TLS */

#define tls_get_ptr _glp_tls_get_ptr
void *tls_get_ptr(void);
/* retrieve global pointer from TLS */

#define xputs glp_puts
void glp_puts(const char *s);
/* write string on terminal */

#define xprintf glp_printf
void glp_printf(const char *fmt, ...);
/* write formatted output on terminal */

#define xvprintf glp_vprintf
void glp_vprintf(const char *fmt, va_list arg);
/* write formatted output on terminal */

int glp_term_out(int flag);
/* enable/disable terminal output */

void glp_term_hook(int (*func)(void *info, const char *s), void *info);
/* install hook to intercept terminal output */

int glp_open_tee(const char *fname);
/* start copying terminal output to text file */

int glp_close_tee(void);
/* stop copying terminal output to text file */

#ifndef GLP_ERRFUNC_DEFINED
#define GLP_ERRFUNC_DEFINED
typedef void (*glp_errfunc)(const char *fmt, ...);
#endif

#define xerror glp_error_(IGRAPH_FILE_BASENAME, __LINE__)
glp_errfunc glp_error_(const char *file, int line);
/* display fatal error message and terminate execution */

#define xassert(expr) \
      ((void)((expr) || (glp_assert_(#expr, IGRAPH_FILE_BASENAME, __LINE__), 1)))
void glp_assert_(const char *expr, const char *file, int line);
/* check for logical condition */

void glp_error_hook(void (*func)(void *info), void *info);
/* install hook to intercept abnormal termination */

#define put_err_msg _glp_put_err_msg
void put_err_msg(const char *msg);
/* provide error message string */

#define get_err_msg _glp_get_err_msg
const char *get_err_msg(void);
/* obtain error message string */

#define xmalloc(size) glp_alloc(1, size)
/* allocate memory block (obsolete) */

#define xcalloc(n, size) glp_alloc(n, size)
/* allocate memory block (obsolete) */

#define xalloc(n, size) glp_alloc(n, size)
#define talloc(n, type) ((type *)glp_alloc(n, sizeof(type)))
void *glp_alloc(int n, int size);
/* allocate memory block */

#define xrealloc(ptr, n, size) glp_realloc(ptr, n, size)
#define trealloc(ptr, n, type) ((type *)glp_realloc(ptr, n, \
      sizeof(type)))
void *glp_realloc(void *ptr, int n, int size);
/* reallocate memory block */

#define xfree(ptr) glp_free(ptr)
#define tfree(ptr) glp_free(ptr)
void glp_free(void *ptr);
/* free memory block */

void glp_mem_limit(int limit);
/* set memory usage limit */

void glp_mem_usage(int *count, int *cpeak, size_t *total,
      size_t *tpeak);
/* get memory usage information */

typedef struct glp_file glp_file;
/* sequential stream descriptor */

#define glp_open _glp_open
glp_file *glp_open(const char *name, const char *mode);
/* open stream */

#define glp_eof _glp_eof
int glp_eof(glp_file *f);
/* test end-of-file indicator */

#define glp_ioerr _glp_ioerr
int glp_ioerr(glp_file *f);
/* test I/O error indicator */

#define glp_read _glp_read
int glp_read(glp_file *f, void *buf, int nnn);
/* read data from stream */

#define glp_getc _glp_getc
int glp_getc(glp_file *f);
/* read character from stream */

#define glp_write _glp_write
int glp_write(glp_file *f, const void *buf, int nnn);
/* write data to stream */

#define glp_format _glp_format
int glp_format(glp_file *f, const char *fmt, ...);
/* write formatted data to stream */

#define glp_close _glp_close
int glp_close(glp_file *f);
/* close stream */

#define xtime glp_time
double glp_time(void);
/* determine current universal time */

#define xdifftime glp_difftime
double glp_difftime(double t1, double t0);
/* compute difference between two time values */

#define xdlopen _glp_dlopen
void *xdlopen(const char *module);
/* open dynamically linked library */

#define xdlsym _glp_dlsym
void *xdlsym(void *h, const char *symbol);
/* obtain address of symbol from dynamically linked library */

#define xdlclose _glp_dlclose
void xdlclose(void *h);
/* close dynamically linked library */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/error.c0000644000175100001710000001270500000000000024176 0ustar00runnerdocker00000000000000/* error.c (error handling) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"

#include "igraph_error.h"

/***********************************************************************
*  NAME
*
*  glp_error - display fatal error message and terminate execution
*
*  SYNOPSIS
*
*  void glp_error(const char *fmt, ...);
*
*  DESCRIPTION
*
*  The routine glp_error (implemented as a macro) formats its
*  parameters using the format control string fmt, writes the formatted
*  message on the terminal, and abnormally terminates the program. */

static void errfunc(const char *fmt, ...)
{     ENV *env = get_env_ptr();
      va_list arg;
#if 1 /* 07/XI-2015 */
      env->err_st = 1;
#endif
      env->term_out = GLP_ON;
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      xprintf("Error detected in file %s at line %d\n",
         env->err_file, env->err_line);
      if (env->err_hook != NULL)
         env->err_hook(env->err_info);
      IGRAPH_FATAL("Unexpected return from GLPK error hook.");
      /* no return */
}

glp_errfunc glp_error_(const char *file, int line)
{     ENV *env = get_env_ptr();
      env->err_file = file;
      env->err_line = line;
      return errfunc;
}

#if 1 /* 07/XI-2015 */
/***********************************************************************
*  NAME
*
*  glp_at_error - check for error state
*
*  SYNOPSIS
*
*  int glp_at_error(void);
*
*  DESCRIPTION
*
*  The routine glp_at_error checks if the GLPK environment is at error
*  state, i.e. if the call to the routine is (indirectly) made from the
*  glp_error routine via an user-defined hook routine.
*
*  RETURNS
*
*  If the GLPK environment is at error state, the routine glp_at_error
*  returns non-zero, otherwise zero. */

int glp_at_error(void)
{     ENV *env = get_env_ptr();
      return env->err_st;
}
#endif

/***********************************************************************
*  NAME
*
*  glp_assert - check for logical condition
*
*  SYNOPSIS
*
*  void glp_assert(int expr);
*
*  DESCRIPTION
*
*  The routine glp_assert (implemented as a macro) checks for a logical
*  condition specified by the parameter expr. If the condition is false
*  (i.e. the value of expr is zero), the routine writes a message on
*  the terminal and abnormally terminates the program. */

void glp_assert_(const char *expr, const char *file, int line)
{     glp_error_(file, line)("Assertion failed: %s\n", expr);
      /* no return */
}

/***********************************************************************
*  NAME
*
*  glp_error_hook - install hook to intercept abnormal termination
*
*  SYNOPSIS
*
*  void glp_error_hook(void (*func)(void *info), void *info);
*
*  DESCRIPTION
*
*  The routine glp_error_hook installs a user-defined hook routine to
*  intercept abnormal termination.
*
*  The parameter func specifies the user-defined hook routine. It is
*  called from the routine glp_error before the latter calls the abort
*  function to abnormally terminate the application program because of
*  fatal error. The parameter info is a transit pointer, specified in
*  the corresponding call to the routine glp_error_hook; it may be used
*  to pass some information to the hook routine.
*
*  To uninstall the hook routine the parameters func and info should be
*  both specified as NULL. */

void glp_error_hook(void (*func)(void *info), void *info)
{     ENV *env = get_env_ptr();
      if (func == NULL)
      {  env->err_hook = NULL;
         env->err_info = NULL;
      }
      else
      {  env->err_hook = func;
         env->err_info = info;
      }
      return;
}

/***********************************************************************
*  NAME
*
*  put_err_msg - provide error message string
*
*  SYNOPSIS
*
*  #include "env.h"
*  void put_err_msg(const char *msg);
*
*  DESCRIPTION
*
*  The routine put_err_msg stores an error message string pointed to by
*  msg to the environment block. */

void put_err_msg(const char *msg)
{     ENV *env = get_env_ptr();
      int len;
      len = strlen(msg);
      if (len >= EBUF_SIZE)
         len = EBUF_SIZE - 1;
      memcpy(env->err_buf, msg, len);
      if (len > 0 && env->err_buf[len-1] == '\n')
         len--;
      env->err_buf[len] = '\0';
      return;
}

/***********************************************************************
*  NAME
*
*  get_err_msg - obtain error message string
*
*  SYNOPSIS
*
*  #include "env.h"
*  const char *get_err_msg(void);
*
*  RETURNS
*
*  The routine get_err_msg returns a pointer to an error message string
*  previously stored by the routine put_err_msg. */

const char *get_err_msg(void)
{     ENV *env = get_env_ptr();
      return env->err_buf;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/stdc.c0000644000175100001710000000452400000000000024002 0ustar00runnerdocker00000000000000/* stdc.c (replacements for standard non-thread-safe functions) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "glpk_tls_config.h"

/* portable ANSI C version ********************************************/

#if !defined(TLS)

#define ENABLE_NON_SAFE
#include "stdc.h"

struct tm *xgmtime(const time_t *timer)
{     return
         gmtime(timer);
}

char *xstrerr(int errnum)
{     return
         strerror(errnum);
}

char *xstrtok(char *s1, const char *s2)
{     return
         strtok(s1, s2);
}

/* MS Windows version *************************************************/

#elif defined(__WOE__)

#include "stdc.h"

struct tm *xgmtime(const time_t *timer)
{     static TLS struct tm result;
      gmtime_s(&result, timer);
      return &result;
}

char *xstrerr(int errnum)
{     static TLS char s[1023+1];
      strerror_s(s, sizeof(s), errnum);
      return s;
}

char *xstrtok(char *s1, const char *s2)
{     static TLS char *ptr;
      return strtok_s(s1, s2, &ptr);
}

/* GNU/Linux version **************************************************/

#else

#include "stdc.h"

struct tm *xgmtime(const time_t *timer)
{     static TLS struct tm result;
      gmtime_r(timer, &result);
      return &result;
}

char *xstrerr(int errnum)
{     static TLS char s[1023+1];
      strerror_r(errnum, s, sizeof(s));
      return s;
}

char *xstrtok(char *s1, const char *s2)
{     static TLS char *ptr;
      return strtok_r(s1, s2, &ptr);
}

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/stdc.h0000644000175100001710000000353000000000000024003 0ustar00runnerdocker00000000000000/* stdc.h (standard ANSI C headers) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef STDC_H
#define STDC_H

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#ifndef ENABLE_NON_SAFE /* 29/I-2017 */
/* disable using non-thread-safe functions directly */
#undef gmtime
#define gmtime ???
#undef strerror
#define strerror ???
#undef strtok
#define strtok ???
#endif

#if 1 /* 29/I-2017 */
/* provide replacements for these functions on a per-thread basis */
#define xgmtime _glp_xgmtime
struct tm *xgmtime(const time_t *);
#define xstrerr _glp_xstrerr
char *xstrerr(int);
#define xstrtok _glp_xstrtok
char *xstrtok(char *, const char *);
#endif

#if 1 /* 06/II-2018 */
#ifdef HAVE_CONFIG_H
#include 
#endif
#ifndef __WOE__
#define CDECL
#else
#define CDECL __cdecl
#endif
#endif

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/stdout.c0000644000175100001710000001653100000000000024370 0ustar00runnerdocker00000000000000/* stdout.c (terminal output) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

/*
#undef NDEBUG
#include 
*/
#include "env.h"

#include "igraph_error.h" /* IGRAPH_ASSERT */

/***********************************************************************
*  NAME
*
*  glp_puts - write string on terminal
*
*  SYNOPSIS
*
*  void glp_puts(const char *s);
*
*  The routine glp_puts writes the string s on the terminal. */

void glp_puts(const char *s)
{     ENV *env = get_env_ptr();
      /* if terminal output is disabled, do nothing */
      if (!env->term_out)
         goto skip;
      /* pass the string to the hook routine, if defined */
      if (env->term_hook != NULL)
      {  if (env->term_hook(env->term_info, s) != 0)
            goto skip;
      }
      /* write the string on the terminal */
      fputs(s, stdout);
      fflush(stdout);
      /* write the string on the tee file, if required */
      if (env->tee_file != NULL)
      {  fputs(s, env->tee_file);
         fflush(env->tee_file);
      }
skip: return;
}

/***********************************************************************
*  NAME
*
*  glp_printf - write formatted output on terminal
*
*  SYNOPSIS
*
*  void glp_printf(const char *fmt, ...);
*
*  DESCRIPTION
*
*  The routine glp_printf uses the format control string fmt to format
*  its parameters and writes the formatted output on the terminal. */

void glp_printf(const char *fmt, ...)
{     ENV *env = get_env_ptr();
      va_list arg;
      /* if terminal output is disabled, do nothing */
      if (!env->term_out)
         goto skip;
      /* format the output */
      va_start(arg, fmt);
      vsprintf(env->term_buf, fmt, arg);
      /* (do not use xassert) */
      IGRAPH_ASSERT(strlen(env->term_buf) < TBUF_SIZE);
      va_end(arg);
      /* write the formatted output on the terminal */
      glp_puts(env->term_buf);
skip: return;
}

/***********************************************************************
*  NAME
*
*  glp_vprintf - write formatted output on terminal
*
*  SYNOPSIS
*
*  void glp_vprintf(const char *fmt, va_list arg);
*
*  DESCRIPTION
*
*  The routine glp_vprintf uses the format control string fmt to format
*  its parameters specified by the list arg and writes the formatted
*  output on the terminal. */

void glp_vprintf(const char *fmt, va_list arg)
{     ENV *env = get_env_ptr();
      /* if terminal output is disabled, do nothing */
      if (!env->term_out)
         goto skip;
      /* format the output */
      vsprintf(env->term_buf, fmt, arg);
      /* (do not use xassert) */
      IGRAPH_ASSERT(strlen(env->term_buf) < TBUF_SIZE);
      /* write the formatted output on the terminal */
      glp_puts(env->term_buf);
skip: return;
}

/***********************************************************************
*  NAME
*
*  glp_term_out - enable/disable terminal output
*
*  SYNOPSIS
*
*  int glp_term_out(int flag);
*
*  DESCRIPTION
*
*  Depending on the parameter flag the routine glp_term_out enables or
*  disables terminal output performed by glpk routines:
*
*  GLP_ON  - enable terminal output;
*  GLP_OFF - disable terminal output.
*
*  RETURNS
*
*  The routine glp_term_out returns the previous value of the terminal
*  output flag. */

int glp_term_out(int flag)
{     ENV *env = get_env_ptr();
      int old = env->term_out;
      if (!(flag == GLP_ON || flag == GLP_OFF))
         xerror("glp_term_out: flag = %d; invalid parameter\n", flag);
      env->term_out = flag;
      return old;
}

/***********************************************************************
*  NAME
*
*  glp_term_hook - install hook to intercept terminal output
*
*  SYNOPSIS
*
*  void glp_term_hook(int (*func)(void *info, const char *s),
*     void *info);
*
*  DESCRIPTION
*
*  The routine glp_term_hook installs a user-defined hook routine to
*  intercept all terminal output performed by glpk routines.
*
*  This feature can be used to redirect the terminal output to other
*  destination, for example to a file or a text window.
*
*  The parameter func specifies the user-defined hook routine. It is
*  called from an internal printing routine, which passes to it two
*  parameters: info and s. The parameter info is a transit pointer,
*  specified in the corresponding call to the routine glp_term_hook;
*  it may be used to pass some information to the hook routine. The
*  parameter s is a pointer to the null terminated character string,
*  which is intended to be written to the terminal. If the hook routine
*  returns zero, the printing routine writes the string s to the
*  terminal in a usual way; otherwise, if the hook routine returns
*  non-zero, no terminal output is performed.
*
*  To uninstall the hook routine the parameters func and info should be
*  specified as NULL. */

void glp_term_hook(int (*func)(void *info, const char *s), void *info)
{     ENV *env = get_env_ptr();
      if (func == NULL)
      {  env->term_hook = NULL;
         env->term_info = NULL;
      }
      else
      {  env->term_hook = func;
         env->term_info = info;
      }
      return;
}

/***********************************************************************
*  NAME
*
*  glp_open_tee - start copying terminal output to text file
*
*  SYNOPSIS
*
*  int glp_open_tee(const char *name);
*
*  DESCRIPTION
*
*  The routine glp_open_tee starts copying all the terminal output to
*  an output text file, whose name is specified by the character string
*  name.
*
*  RETURNS
*
*  0 - operation successful
*  1 - copying terminal output is already active
*  2 - unable to create output file */

int glp_open_tee(const char *name)
{     ENV *env = get_env_ptr();
      if (env->tee_file != NULL)
      {  /* copying terminal output is already active */
         return 1;
      }
      env->tee_file = fopen(name, "w");
      if (env->tee_file == NULL)
      {  /* unable to create output file */
         return 2;
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  glp_close_tee - stop copying terminal output to text file
*
*  SYNOPSIS
*
*  int glp_close_tee(void);
*
*  DESCRIPTION
*
*  The routine glp_close_tee stops copying the terminal output to the
*  output text file previously open by the routine glp_open_tee closing
*  that file.
*
*  RETURNS
*
*  0 - operation successful
*  1 - copying terminal output was not started */

int glp_close_tee(void)
{     ENV *env = get_env_ptr();
      if (env->tee_file == NULL)
      {  /* copying terminal output was not started */
         return 1;
      }
      fclose(env->tee_file);
      env->tee_file = NULL;
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/stream.c0000644000175100001710000002734600000000000024347 0ustar00runnerdocker00000000000000/* stream.c (stream input/output) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
/*#include "zlib.h"*/

struct glp_file
{     /* sequential stream descriptor */
      char *base;
      /* pointer to buffer */
      int size;
      /* size of buffer, in bytes */
      char *ptr;
      /* pointer to next byte in buffer */
      int cnt;
      /* count of bytes in buffer */
      int flag;
      /* stream flags: */
#define IONULL 0x01 /* null file */
#define IOSTD  0x02 /* standard stream */
#define IOGZIP 0x04 /* gzipped file */
#define IOWRT  0x08 /* output stream */
#define IOEOF  0x10 /* end of file */
#define IOERR  0x20 /* input/output error */
      void *file;
      /* pointer to underlying control object */
};

/***********************************************************************
*  NAME
*
*  glp_open - open stream
*
*  SYNOPSIS
*
*  glp_file *glp_open(const char *name, const char *mode);
*
*  DESCRIPTION
*
*  The routine glp_open opens a file whose name is a string pointed to
*  by name and associates a stream with it.
*
*  The following special filenames are recognized by the routine (this
*  feature is platform independent):
*
*  "/dev/null"    empty (null) file;
*  "/dev/stdin"   standard input stream;
*  "/dev/stdout"  standard output stream;
*  "/dev/stderr"  standard error stream.
*
*  If the specified filename is ended with ".gz", it is assumed that
*  the file is in gzipped format. In this case the file is compressed
*  or decompressed by the I/O routines "on the fly".
*
*  The parameter mode points to a string, which indicates the open mode
*  and should be one of the following:
*
*  "r"   open text file for reading;
*  "w"   truncate to zero length or create text file for writing;
*  "a"   append, open or create text file for writing at end-of-file;
*  "rb"  open binary file for reading;
*  "wb"  truncate to zero length or create binary file for writing;
*  "ab"  append, open or create binary file for writing at end-of-file.
*
*  RETURNS
*
*  The routine glp_open returns a pointer to the object controlling the
*  stream. If the operation fails, the routine returns NULL. */

glp_file *glp_open(const char *name, const char *mode)
{     glp_file *f;
      int flag;
      void *file;
      if (strcmp(mode, "r") == 0 || strcmp(mode, "rb") == 0)
         flag = 0;
      else if (strcmp(mode, "w") == 0 || strcmp(mode, "wb") == 0)
         flag = IOWRT;
#if 1 /* 08/V-2014 */
      else if (strcmp(mode, "a") == 0 || strcmp(mode, "ab") == 0)
         flag = IOWRT;
#endif
      else
         xerror("glp_open: invalid mode string\n");
      if (strcmp(name, "/dev/null") == 0)
      {  flag |= IONULL;
         file = NULL;
      }
      /*
      else if (strcmp(name, "/dev/stdin") == 0)
      {  flag |= IOSTD;
         file = stdin;
      }
      else if (strcmp(name, "/dev/stdout") == 0)
      {  flag |= IOSTD;
         file = stdout;
      }
      else if (strcmp(name, "/dev/stderr") == 0)
      {  flag |= IOSTD;
         file = stderr;
      }
      */
      else
      {  /* char *ext = strrchr(name, '.'); */
         /* if (ext == NULL || strcmp(ext, ".gz") != 0) */
         {  file = fopen(name, mode);
            if (file == NULL)
#if 0 /* 29/I-2017 */
            {  put_err_msg(strerror(errno));
#else
            {  put_err_msg(xstrerr(errno));
#endif
               return NULL;
            }
         }
      }
      f = talloc(1, glp_file);
      f->base = talloc(BUFSIZ, char);
      f->size = BUFSIZ;
      f->ptr = f->base;
      f->cnt = 0;
      f->flag = flag;
      f->file = file;
      return f;
}

/***********************************************************************
*  NAME
*
*  glp_eof - test end-of-file indicator
*
*  SYNOPSIS
*
*  int glp_eof(glp_file *f);
*
*  DESCRIPTION
*
*  The routine glp_eof tests the end-of-file indicator for the stream
*  pointed to by f.
*
*  RETURNS
*
*  The routine glp_eof returns non-zero if and only if the end-of-file
*  indicator is set for the specified stream. */

int glp_eof(glp_file *f)
{     return
         f->flag & IOEOF;
}

/***********************************************************************
*  NAME
*
*  glp_ioerr - test I/O error indicator
*
*  SYNOPSIS
*
*  int glp_ioerr(glp_file *f);
*
*  DESCRIPTION
*
*  The routine glp_ioerr tests the I/O error indicator for the stream
*  pointed to by f.
*
*  RETURNS
*
*  The routine glp_ioerr returns non-zero if and only if the I/O error
*  indicator is set for the specified stream. */

int glp_ioerr(glp_file *f)
{     return
         f->flag & IOERR;
}

/***********************************************************************
*  NAME
*
*  glp_read - read data from stream
*
*  SYNOPSIS
*
*  int glp_read(glp_file *f, void *buf, int nnn);
*
*  DESCRIPTION
*
*  The routine glp_read reads, into the buffer pointed to by buf, up to
*  nnn bytes, from the stream pointed to by f.
*
*  RETURNS
*
*  The routine glp_read returns the number of bytes successfully read
*  (which may be less than nnn). If an end-of-file is encountered, the
*  end-of-file indicator for the stream is set and glp_read returns
*  zero. If a read error occurs, the error indicator for the stream is
*  set and glp_read returns a negative value. */

int glp_read(glp_file *f, void *buf, int nnn)
{     int nrd, cnt;
      if (f->flag & IOWRT)
         xerror("glp_read: attempt to read from output stream\n");
      if (nnn < 1)
         xerror("glp_read: nnn = %d; invalid parameter\n", nnn);
      for (nrd = 0; nrd < nnn; nrd += cnt)
      {  if (f->cnt == 0)
         {  /* buffer is empty; fill it */
            if (f->flag & IONULL)
               cnt = 0;
            else
            {  cnt = fread(f->base, 1, f->size, (FILE *)(f->file));
               if (ferror((FILE *)(f->file)))
               {  f->flag |= IOERR;
#if 0 /* 29/I-2017 */
                  put_err_msg(strerror(errno));
#else
                  put_err_msg(xstrerr(errno));
#endif
                  return EOF;
               }
            }
            if (cnt == 0)
            {  if (nrd == 0)
                  f->flag |= IOEOF;
               break;
            }
            f->ptr = f->base;
            f->cnt = cnt;
         }
         cnt = nnn - nrd;
         if (cnt > f->cnt)
            cnt = f->cnt;
         memcpy((char *)buf + nrd, f->ptr, cnt);
         f->ptr += cnt;
         f->cnt -= cnt;
      }
      return nrd;
}

/***********************************************************************
*  NAME
*
*  glp_getc - read character from stream
*
*  SYNOPSIS
*
*  int glp_getc(glp_file *f);
*
*  DESCRIPTION
*
*  The routine glp_getc obtains a next character as an unsigned char
*  converted to an int from the input stream pointed to by f.
*
*  RETURNS
*
*  The routine glp_getc returns the next character obtained. However,
*  if an end-of-file is encountered or a read error occurs, the routine
*  returns EOF. (An end-of-file and a read error can be distinguished
*  by use of the routines glp_eof and glp_ioerr.) */

int glp_getc(glp_file *f)
{     unsigned char buf[1];
      if (f->flag & IOWRT)
         xerror("glp_getc: attempt to read from output stream\n");
      if (glp_read(f, buf, 1) != 1)
         return EOF;
      return buf[0];
}

/***********************************************************************
*  do_flush - flush output stream
*
*  This routine causes buffered data for the specified output stream to
*  be written to the associated file.
*
*  If the operation was successful, the routine returns zero, otherwise
*  non-zero. */

static int do_flush(glp_file *f)
{     xassert(f->flag & IOWRT);
      if (f->cnt > 0)
      {  if (f->flag & IONULL)
            ;
         else
         {  if ((int)fwrite(f->base, 1, f->cnt, (FILE *)(f->file))
               != f->cnt)
            {  f->flag |= IOERR;
#if 0 /* 29/I-2017 */
               put_err_msg(strerror(errno));
#else
               put_err_msg(xstrerr(errno));
#endif
               return EOF;
            }
         }
      }
      f->ptr = f->base;
      f->cnt = 0;
      return 0;
}

/***********************************************************************
*  NAME
*
*  glp_write - write data to stream
*
*  SYNOPSIS
*
*  int glp_write(glp_file *f, const void *buf, int nnn);
*
*  DESCRIPTION
*
*  The routine glp_write writes, from the buffer pointed to by buf, up
*  to nnn bytes, to the stream pointed to by f.
*
*  RETURNS
*
*  The routine glp_write returns the number of bytes successfully
*  written (which is equal to nnn). If a write error occurs, the error
*  indicator for the stream is set and glp_write returns a negative
*  value. */

int glp_write(glp_file *f, const void *buf, int nnn)
{     int nwr, cnt;
      if (!(f->flag & IOWRT))
         xerror("glp_write: attempt to write to input stream\n");
      if (nnn < 1)
         xerror("glp_write: nnn = %d; invalid parameter\n", nnn);
      for (nwr = 0; nwr < nnn; nwr += cnt)
      {  cnt = nnn - nwr;
         if (cnt > f->size - f->cnt)
            cnt = f->size - f->cnt;
         memcpy(f->ptr, (const char *)buf + nwr, cnt);
         f->ptr += cnt;
         f->cnt += cnt;
         if (f->cnt == f->size)
         {  /* buffer is full; flush it */
            if (do_flush(f) != 0)
               return EOF;
         }
      }
      return nwr;
}

/***********************************************************************
*  NAME
*
*  glp_format - write formatted data to stream
*
*  SYNOPSIS
*
*  int glp_format(glp_file *f, const char *fmt, ...);
*
*  DESCRIPTION
*
*  The routine glp_format writes formatted data to the stream pointed
*  to by f. The format control string pointed to by fmt specifies how
*  subsequent arguments are converted for output.
*
*  RETURNS
*
*  The routine glp_format returns the number of characters written, or
*  a negative value if an output error occurs. */

int glp_format(glp_file *f, const char *fmt, ...)
{     ENV *env = get_env_ptr();
      va_list arg;
      int nnn;
      if (!(f->flag & IOWRT))
         xerror("glp_format: attempt to write to input stream\n");
      va_start(arg, fmt);
      nnn = vsprintf(env->term_buf, fmt, arg);
      xassert(0 <= nnn && nnn < TBUF_SIZE);
      va_end(arg);
      return nnn == 0 ? 0 : glp_write(f, env->term_buf, nnn);
}

/***********************************************************************
*  NAME
*
*  glp_close - close stream
*
*  SYNOPSIS
*
*  int glp_close(glp_file *f);
*
*  DESCRIPTION
*
*  The routine glp_close closes the stream pointed to by f.
*
*  RETURNS
*
*  If the operation was successful, the routine returns zero, otherwise
*  non-zero. */

int glp_close(glp_file *f)
{     int ret = 0;
      if (f->flag & IOWRT)
      {  if (do_flush(f) != 0)
            ret = EOF;
      }
      if (f->flag & (IONULL | IOSTD))
         ;
      else
      {  if (fclose((FILE *)(f->file)) != 0)
         {  if (ret == 0)
#if 0 /* 29/I-2017 */
            {  put_err_msg(strerror(errno));
#else
            {  put_err_msg(xstrerr(errno));
#endif
               ret = EOF;
            }
         }
      }
      tfree(f->base);
      tfree(f);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/time.c0000644000175100001710000000742000000000000024001 0ustar00runnerdocker00000000000000/* time.c (standard time) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "env.h"
#include "jd.h"

/***********************************************************************
*  NAME
*
*  glp_time - determine current universal time
*
*  SYNOPSIS
*
*  double glp_time(void);
*
*  RETURNS
*
*  The routine glp_time returns the current universal time (UTC), in
*  milliseconds, elapsed since 00:00:00 GMT January 1, 1970. */

#define EPOCH 2440588 /* = jday(1, 1, 1970) */

/* POSIX version ******************************************************/

#if defined(HAVE_SYS_TIME_H) && defined(HAVE_GETTIMEOFDAY)

#if 0 /* 29/VI-2017 */
#include 
#include 

double glp_time(void)
{     struct timeval tv;
      struct tm *tm;
      int j;
      double t;
      gettimeofday(&tv, NULL);
#if 0 /* 29/I-2017 */
      tm = gmtime(&tv.tv_sec);
#else
      tm = xgmtime(&tv.tv_sec);
#endif
      j = jday(tm->tm_mday, tm->tm_mon + 1, 1900 + tm->tm_year);
      xassert(j >= 0);
      t = ((((double)(j - EPOCH) * 24.0 + (double)tm->tm_hour) * 60.0 +
         (double)tm->tm_min) * 60.0 + (double)tm->tm_sec) * 1000.0 +
         (double)(tv.tv_usec / 1000);
      return t;
}
#else
#include 

double glp_time(void)
{     struct timeval tv;
      double t;
      gettimeofday(&tv, NULL);
      t = (double)tv.tv_sec + (double)(tv.tv_usec) / 1e6;
      xassert(0.0 <= t && t < 4294967296.0);
      return 1000.0 * t;
}
#endif

/* MS Windows version *************************************************/

#elif defined(__WOE__)

#include 

double glp_time(void)
{     SYSTEMTIME st;
      int j;
      double t;
      GetSystemTime(&st);
      j = jday(st.wDay, st.wMonth, st.wYear);
      xassert(j >= 0);
      t = ((((double)(j - EPOCH) * 24.0 + (double)st.wHour) * 60.0 +
         (double)st.wMinute) * 60.0 + (double)st.wSecond) * 1000.0 +
         (double)st.wMilliseconds;
      return t;
}

/* portable ANSI C version ********************************************/

#else

#include 

double glp_time(void)
{     time_t timer;
      struct tm *tm;
      int j;
      double t;
      timer = time(NULL);
#if 0 /* 29/I-2017 */
      tm = gmtime(&timer);
#else
      tm = xgmtime(&timer);
#endif
      j = jday(tm->tm_mday, tm->tm_mon + 1, 1900 + tm->tm_year);
      xassert(j >= 0);
      t = ((((double)(j - EPOCH) * 24.0 + (double)tm->tm_hour) * 60.0 +
         (double)tm->tm_min) * 60.0 + (double)tm->tm_sec) * 1000.0;
      return t;
}

#endif

/***********************************************************************
*  NAME
*
*  glp_difftime - compute difference between two time values
*
*  SYNOPSIS
*
*  double glp_difftime(double t1, double t0);
*
*  RETURNS
*
*  The routine glp_difftime returns the difference between two time
*  values t1 and t0, expressed in seconds. */

double glp_difftime(double t1, double t0)
{     return
         (t1 - t0) / 1000.0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/env/tls.c0000644000175100001710000000711100000000000023642 0ustar00runnerdocker00000000000000/* tls.c (thread local storage) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2001-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "glpk_tls_config.h"

#include "env.h"

#ifndef TLS
static void *tls = NULL;
#else
static TLS void *tls = NULL;
/* this option allows running multiple independent instances of GLPK in
 * different threads of a multi-threaded application, in which case the
 * variable tls should be placed in the Thread Local Storage (TLS);
 * it is assumed that the macro TLS is previously defined to something
 * like '__thread', '_Thread_local', etc. */
#endif

/***********************************************************************
*  NAME
*
*  tls_set_ptr - store global pointer in TLS
*
*  SYNOPSIS
*
*  #include "env.h"
*  void tls_set_ptr(void *ptr);
*
*  DESCRIPTION
*
*  The routine tls_set_ptr stores a pointer specified by the parameter
*  ptr in the Thread Local Storage (TLS). */

void tls_set_ptr(void *ptr)
{     tls = ptr;
      return;
}

/***********************************************************************
*  NAME
*
*  tls_get_ptr - retrieve global pointer from TLS
*
*  SYNOPSIS
*
*  #include "env.h"
*  void *tls_get_ptr(void);
*
*  RETURNS
*
*  The routine tls_get_ptr returns a pointer previously stored by the
*  routine tls_set_ptr. If the latter has not been called yet, NULL is
*  returned. */

void *tls_get_ptr(void)
{     void *ptr;
      ptr = tls;
      return ptr;
}

/**********************************************************************/

#ifdef __WOE__

/*** Author: Heinrich Schuchardt  ***/

#pragma comment(lib, "user32.lib")

#include 

#define VISTA 0x06

/* This is the main entry point of the DLL. */

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID
      lpvReserved)
{     DWORD version;
      DWORD major_version;
#ifdef TLS
      switch (fdwReason)
      {  case DLL_PROCESS_ATTACH:
         /* @TODO:
          * GetVersion is deprecated but the version help functions are
          * not available in Visual Studio 2010. So lets use it until
          * we remove the outdated Build files. */
         version = GetVersion();
         major_version = version & 0xff;
         if (major_version < VISTA)
         {  MessageBoxA(NULL,
               "The GLPK library called by this application is configur"
               "ed to use thread local storage which is not fully suppo"
               "rted by your version of Microsoft Windows.\n\n"
               "Microsoft Windows Vista or a later version of Windows i"
               "s required to run this application.",
               "GLPK", MB_OK | MB_ICONERROR);
            return FALSE;
         }
         break;
      }
#endif /* TLS */
      return TRUE;
}

#endif /* __WOE__ */

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/glpk.h0000644000175100001710000011571100000000000023220 0ustar00runnerdocker00000000000000/* glpk.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2020 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef GLPK_H
#define GLPK_H

#include 
#include 

#ifdef __cplusplus
extern "C" {
#endif

/* library version numbers: */
#define GLP_MAJOR_VERSION  5
#define GLP_MINOR_VERSION  0

typedef struct glp_prob glp_prob;
/* LP/MIP problem object */

/* optimization direction flag: */
#define GLP_MIN            1  /* minimization */
#define GLP_MAX            2  /* maximization */

/* kind of structural variable: */
#define GLP_CV             1  /* continuous variable */
#define GLP_IV             2  /* integer variable */
#define GLP_BV             3  /* binary variable */

/* type of auxiliary/structural variable: */
#define GLP_FR             1  /* free (unbounded) variable */
#define GLP_LO             2  /* variable with lower bound */
#define GLP_UP             3  /* variable with upper bound */
#define GLP_DB             4  /* double-bounded variable */
#define GLP_FX             5  /* fixed variable */

/* status of auxiliary/structural variable: */
#define GLP_BS             1  /* basic variable */
#define GLP_NL             2  /* non-basic variable on lower bound */
#define GLP_NU             3  /* non-basic variable on upper bound */
#define GLP_NF             4  /* non-basic free (unbounded) variable */
#define GLP_NS             5  /* non-basic fixed variable */

/* scaling options: */
#define GLP_SF_GM       0x01  /* perform geometric mean scaling */
#define GLP_SF_EQ       0x10  /* perform equilibration scaling */
#define GLP_SF_2N       0x20  /* round scale factors to power of two */
#define GLP_SF_SKIP     0x40  /* skip if problem is well scaled */
#define GLP_SF_AUTO     0x80  /* choose scaling options automatically */

/* solution indicator: */
#define GLP_SOL            1  /* basic solution */
#define GLP_IPT            2  /* interior-point solution */
#define GLP_MIP            3  /* mixed integer solution */

/* solution status: */
#define GLP_UNDEF          1  /* solution is undefined */
#define GLP_FEAS           2  /* solution is feasible */
#define GLP_INFEAS         3  /* solution is infeasible */
#define GLP_NOFEAS         4  /* no feasible solution exists */
#define GLP_OPT            5  /* solution is optimal */
#define GLP_UNBND          6  /* solution is unbounded */

typedef struct
{     /* basis factorization control parameters */
      int msg_lev;            /* (not used) */
      int type;               /* factorization type: */
#if 1 /* 05/III-2014 */
#define GLP_BF_LUF      0x00  /* plain LU-factorization */
#define GLP_BF_BTF      0x10  /* block triangular LU-factorization */
#endif
#define GLP_BF_FT       0x01  /* Forrest-Tomlin (LUF only) */
#define GLP_BF_BG       0x02  /* Schur compl. + Bartels-Golub */
#define GLP_BF_GR       0x03  /* Schur compl. + Givens rotation */
      int lu_size;            /* (not used) */
      double piv_tol;         /* sgf_piv_tol */
      int piv_lim;            /* sgf_piv_lim */
      int suhl;               /* sgf_suhl */
      double eps_tol;         /* sgf_eps_tol */
      double max_gro;         /* (not used) */
      int nfs_max;            /* fhvint.nfs_max */
      double upd_tol;         /* (not used) */
      int nrs_max;            /* scfint.nn_max */
      int rs_size;            /* (not used) */
      double foo_bar[38];     /* (reserved) */
} glp_bfcp;

typedef struct
{     /* simplex solver control parameters */
      int msg_lev;            /* message level: */
#define GLP_MSG_OFF        0  /* no output */
#define GLP_MSG_ERR        1  /* warning and error messages only */
#define GLP_MSG_ON         2  /* normal output */
#define GLP_MSG_ALL        3  /* full output */
#define GLP_MSG_DBG        4  /* debug output */
      int meth;               /* simplex method option: */
#define GLP_PRIMAL         1  /* use primal simplex */
#define GLP_DUALP          2  /* use dual; if it fails, use primal */
#define GLP_DUAL           3  /* use dual simplex */
      int pricing;            /* pricing technique: */
#define GLP_PT_STD      0x11  /* standard (Dantzig's rule) */
#define GLP_PT_PSE      0x22  /* projected steepest edge */
      int r_test;             /* ratio test technique: */
#define GLP_RT_STD      0x11  /* standard (textbook) */
#define GLP_RT_HAR      0x22  /* Harris' two-pass ratio test */
#if 1 /* 16/III-2016 */
#define GLP_RT_FLIP     0x33  /* long-step (flip-flop) ratio test */
#endif
      double tol_bnd;         /* primal feasibility tolerance */
      double tol_dj;          /* dual feasibility tolerance */
      double tol_piv;         /* pivot tolerance */
      double obj_ll;          /* lower objective limit */
      double obj_ul;          /* upper objective limit */
      int it_lim;             /* simplex iteration limit */
      int tm_lim;             /* time limit, ms */
      int out_frq;            /* display output frequency, ms */
      int out_dly;            /* display output delay, ms */
      int presolve;           /* enable/disable using LP presolver */
#if 1 /* 11/VII-2017 (not documented yet) */
      int excl;               /* exclude fixed non-basic variables */
      int shift;              /* shift bounds of variables to zero */
      int aorn;               /* option to use A or N: */
#define GLP_USE_AT         1  /* use A matrix in row-wise format */
#define GLP_USE_NT         2  /* use N matrix in row-wise format */
      double foo_bar[33];     /* (reserved) */
#endif
} glp_smcp;

typedef struct
{     /* interior-point solver control parameters */
      int msg_lev;            /* message level (see glp_smcp) */
      int ord_alg;            /* ordering algorithm: */
#define GLP_ORD_NONE       0  /* natural (original) ordering */
#define GLP_ORD_QMD        1  /* quotient minimum degree (QMD) */
#define GLP_ORD_AMD        2  /* approx. minimum degree (AMD) */
#define GLP_ORD_SYMAMD     3  /* approx. minimum degree (SYMAMD) */
      double foo_bar[48];     /* (reserved) */
} glp_iptcp;

typedef struct glp_tree glp_tree;
/* branch-and-bound tree */

typedef struct
{     /* integer optimizer control parameters */
      int msg_lev;            /* message level (see glp_smcp) */
      int br_tech;            /* branching technique: */
#define GLP_BR_FFV         1  /* first fractional variable */
#define GLP_BR_LFV         2  /* last fractional variable */
#define GLP_BR_MFV         3  /* most fractional variable */
#define GLP_BR_DTH         4  /* heuristic by Driebeck and Tomlin */
#define GLP_BR_PCH         5  /* hybrid pseudocost heuristic */
      int bt_tech;            /* backtracking technique: */
#define GLP_BT_DFS         1  /* depth first search */
#define GLP_BT_BFS         2  /* breadth first search */
#define GLP_BT_BLB         3  /* best local bound */
#define GLP_BT_BPH         4  /* best projection heuristic */
      double tol_int;         /* mip.tol_int */
      double tol_obj;         /* mip.tol_obj */
      int tm_lim;             /* mip.tm_lim (milliseconds) */
      int out_frq;            /* mip.out_frq (milliseconds) */
      int out_dly;            /* mip.out_dly (milliseconds) */
      void (*cb_func)(glp_tree *T, void *info);
                              /* mip.cb_func */
      void *cb_info;          /* mip.cb_info */
      int cb_size;            /* mip.cb_size */
      int pp_tech;            /* preprocessing technique: */
#define GLP_PP_NONE        0  /* disable preprocessing */
#define GLP_PP_ROOT        1  /* preprocessing only on root level */
#define GLP_PP_ALL         2  /* preprocessing on all levels */
      double mip_gap;         /* relative MIP gap tolerance */
      int mir_cuts;           /* MIR cuts       (GLP_ON/GLP_OFF) */
      int gmi_cuts;           /* Gomory's cuts  (GLP_ON/GLP_OFF) */
      int cov_cuts;           /* cover cuts     (GLP_ON/GLP_OFF) */
      int clq_cuts;           /* clique cuts    (GLP_ON/GLP_OFF) */
      int presolve;           /* enable/disable using MIP presolver */
      int binarize;           /* try to binarize integer variables */
      int fp_heur;            /* feasibility pump heuristic */
      int ps_heur;            /* proximity search heuristic */
      int ps_tm_lim;          /* proxy time limit, milliseconds */
      int sr_heur;            /* simple rounding heuristic */
#if 1 /* 24/X-2015; not documented--should not be used */
      int use_sol;            /* use existing solution */
      const char *save_sol;   /* filename to save every new solution */
      int alien;              /* use alien solver */
#endif
#if 1 /* 16/III-2016; not documented--should not be used */
      int flip;               /* use long-step dual simplex */
#endif
      double foo_bar[23];     /* (reserved) */
} glp_iocp;

typedef struct
{     /* additional row attributes */
      int level;
      /* subproblem level at which the row was added */
      int origin;
      /* row origin flag: */
#define GLP_RF_REG         0  /* regular constraint */
#define GLP_RF_LAZY        1  /* "lazy" constraint */
#define GLP_RF_CUT         2  /* cutting plane constraint */
      int klass;
      /* row class descriptor: */
#define GLP_RF_GMI         1  /* Gomory's mixed integer cut */
#define GLP_RF_MIR         2  /* mixed integer rounding cut */
#define GLP_RF_COV         3  /* mixed cover cut */
#define GLP_RF_CLQ         4  /* clique cut */
      double foo_bar[7];
      /* (reserved) */
} glp_attr;

/* enable/disable flag: */
#define GLP_ON             1  /* enable something */
#define GLP_OFF            0  /* disable something */

/* reason codes: */
#define GLP_IROWGEN     0x01  /* request for row generation */
#define GLP_IBINGO      0x02  /* better integer solution found */
#define GLP_IHEUR       0x03  /* request for heuristic solution */
#define GLP_ICUTGEN     0x04  /* request for cut generation */
#define GLP_IBRANCH     0x05  /* request for branching */
#define GLP_ISELECT     0x06  /* request for subproblem selection */
#define GLP_IPREPRO     0x07  /* request for preprocessing */

/* branch selection indicator: */
#define GLP_NO_BRNCH       0  /* select no branch */
#define GLP_DN_BRNCH       1  /* select down-branch */
#define GLP_UP_BRNCH       2  /* select up-branch */

/* return codes: */
#define GLP_EBADB       0x01  /* invalid basis */
#define GLP_ESING       0x02  /* singular matrix */
#define GLP_ECOND       0x03  /* ill-conditioned matrix */
#define GLP_EBOUND      0x04  /* invalid bounds */
#define GLP_EFAIL       0x05  /* solver failed */
#define GLP_EOBJLL      0x06  /* objective lower limit reached */
#define GLP_EOBJUL      0x07  /* objective upper limit reached */
#define GLP_EITLIM      0x08  /* iteration limit exceeded */
#define GLP_ETMLIM      0x09  /* time limit exceeded */
#define GLP_ENOPFS      0x0A  /* no primal feasible solution */
#define GLP_ENODFS      0x0B  /* no dual feasible solution */
#define GLP_EROOT       0x0C  /* root LP optimum not provided */
#define GLP_ESTOP       0x0D  /* search terminated by application */
#define GLP_EMIPGAP     0x0E  /* relative mip gap tolerance reached */
#define GLP_ENOFEAS     0x0F  /* no primal/dual feasible solution */
#define GLP_ENOCVG      0x10  /* no convergence */
#define GLP_EINSTAB     0x11  /* numerical instability */
#define GLP_EDATA       0x12  /* invalid data */
#define GLP_ERANGE      0x13  /* result out of range */

/* condition indicator: */
#define GLP_KKT_PE         1  /* primal equalities */
#define GLP_KKT_PB         2  /* primal bounds */
#define GLP_KKT_DE         3  /* dual equalities */
#define GLP_KKT_DB         4  /* dual bounds */
#define GLP_KKT_CS         5  /* complementary slackness */

/* MPS file format: */
#define GLP_MPS_DECK       1  /* fixed (ancient) */
#define GLP_MPS_FILE       2  /* free (modern) */

typedef struct
{     /* MPS format control parameters */
      int blank;
      /* character code to replace blanks in symbolic names */
      char *obj_name;
      /* objective row name */
      double tol_mps;
      /* zero tolerance for MPS data */
      double foo_bar[17];
      /* (reserved for use in the future) */
} glp_mpscp;

typedef struct
{     /* CPLEX LP format control parameters */
      double foo_bar[20];
      /* (reserved for use in the future) */
} glp_cpxcp;

#if 1 /* 10/XII-2017 */
typedef struct glp_prep glp_prep;
/* LP/MIP preprocessor workspace */
#endif

typedef struct glp_tran glp_tran;
/* MathProg translator workspace */

glp_prob *glp_create_prob(void);
/* create problem object */

void glp_set_prob_name(glp_prob *P, const char *name);
/* assign (change) problem name */

void glp_set_obj_name(glp_prob *P, const char *name);
/* assign (change) objective function name */

void glp_set_obj_dir(glp_prob *P, int dir);
/* set (change) optimization direction flag */

int glp_add_rows(glp_prob *P, int nrs);
/* add new rows to problem object */

int glp_add_cols(glp_prob *P, int ncs);
/* add new columns to problem object */

void glp_set_row_name(glp_prob *P, int i, const char *name);
/* assign (change) row name */

void glp_set_col_name(glp_prob *P, int j, const char *name);
/* assign (change) column name */

void glp_set_row_bnds(glp_prob *P, int i, int type, double lb,
      double ub);
/* set (change) row bounds */

void glp_set_col_bnds(glp_prob *P, int j, int type, double lb,
      double ub);
/* set (change) column bounds */

void glp_set_obj_coef(glp_prob *P, int j, double coef);
/* set (change) obj. coefficient or constant term */

void glp_set_mat_row(glp_prob *P, int i, int len, const int ind[],
      const double val[]);
/* set (replace) row of the constraint matrix */

void glp_set_mat_col(glp_prob *P, int j, int len, const int ind[],
      const double val[]);
/* set (replace) column of the constraint matrix */

void glp_load_matrix(glp_prob *P, int ne, const int ia[],
      const int ja[], const double ar[]);
/* load (replace) the whole constraint matrix */

int glp_check_dup(int m, int n, int ne, const int ia[], const int ja[]);
/* check for duplicate elements in sparse matrix */

void glp_sort_matrix(glp_prob *P);
/* sort elements of the constraint matrix */

void glp_del_rows(glp_prob *P, int nrs, const int num[]);
/* delete specified rows from problem object */

void glp_del_cols(glp_prob *P, int ncs, const int num[]);
/* delete specified columns from problem object */

void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names);
/* copy problem object content */

void glp_erase_prob(glp_prob *P);
/* erase problem object content */

void glp_delete_prob(glp_prob *P);
/* delete problem object */

const char *glp_get_prob_name(glp_prob *P);
/* retrieve problem name */

const char *glp_get_obj_name(glp_prob *P);
/* retrieve objective function name */

int glp_get_obj_dir(glp_prob *P);
/* retrieve optimization direction flag */

int glp_get_num_rows(glp_prob *P);
/* retrieve number of rows */

int glp_get_num_cols(glp_prob *P);
/* retrieve number of columns */

const char *glp_get_row_name(glp_prob *P, int i);
/* retrieve row name */

const char *glp_get_col_name(glp_prob *P, int j);
/* retrieve column name */

int glp_get_row_type(glp_prob *P, int i);
/* retrieve row type */

double glp_get_row_lb(glp_prob *P, int i);
/* retrieve row lower bound */

double glp_get_row_ub(glp_prob *P, int i);
/* retrieve row upper bound */

int glp_get_col_type(glp_prob *P, int j);
/* retrieve column type */

double glp_get_col_lb(glp_prob *P, int j);
/* retrieve column lower bound */

double glp_get_col_ub(glp_prob *P, int j);
/* retrieve column upper bound */

double glp_get_obj_coef(glp_prob *P, int j);
/* retrieve obj. coefficient or constant term */

int glp_get_num_nz(glp_prob *P);
/* retrieve number of constraint coefficients */

int glp_get_mat_row(glp_prob *P, int i, int ind[], double val[]);
/* retrieve row of the constraint matrix */

int glp_get_mat_col(glp_prob *P, int j, int ind[], double val[]);
/* retrieve column of the constraint matrix */

void glp_create_index(glp_prob *P);
/* create the name index */

int glp_find_row(glp_prob *P, const char *name);
/* find row by its name */

int glp_find_col(glp_prob *P, const char *name);
/* find column by its name */

void glp_delete_index(glp_prob *P);
/* delete the name index */

void glp_set_rii(glp_prob *P, int i, double rii);
/* set (change) row scale factor */

void glp_set_sjj(glp_prob *P, int j, double sjj);
/* set (change) column scale factor */

double glp_get_rii(glp_prob *P, int i);
/* retrieve row scale factor */

double glp_get_sjj(glp_prob *P, int j);
/* retrieve column scale factor */

void glp_scale_prob(glp_prob *P, int flags);
/* scale problem data */

void glp_unscale_prob(glp_prob *P);
/* unscale problem data */

void glp_set_row_stat(glp_prob *P, int i, int stat);
/* set (change) row status */

void glp_set_col_stat(glp_prob *P, int j, int stat);
/* set (change) column status */

void glp_std_basis(glp_prob *P);
/* construct standard initial LP basis */

void glp_adv_basis(glp_prob *P, int flags);
/* construct advanced initial LP basis */

void glp_cpx_basis(glp_prob *P);
/* construct Bixby's initial LP basis */

int glp_simplex(glp_prob *P, const glp_smcp *parm);
/* solve LP problem with the simplex method */

int glp_exact(glp_prob *P, const glp_smcp *parm);
/* solve LP problem in exact arithmetic */

void glp_init_smcp(glp_smcp *parm);
/* initialize simplex method control parameters */

int glp_get_status(glp_prob *P);
/* retrieve generic status of basic solution */

int glp_get_prim_stat(glp_prob *P);
/* retrieve status of primal basic solution */

int glp_get_dual_stat(glp_prob *P);
/* retrieve status of dual basic solution */

double glp_get_obj_val(glp_prob *P);
/* retrieve objective value (basic solution) */

int glp_get_row_stat(glp_prob *P, int i);
/* retrieve row status */

double glp_get_row_prim(glp_prob *P, int i);
/* retrieve row primal value (basic solution) */

double glp_get_row_dual(glp_prob *P, int i);
/* retrieve row dual value (basic solution) */

int glp_get_col_stat(glp_prob *P, int j);
/* retrieve column status */

double glp_get_col_prim(glp_prob *P, int j);
/* retrieve column primal value (basic solution) */

double glp_get_col_dual(glp_prob *P, int j);
/* retrieve column dual value (basic solution) */

int glp_get_unbnd_ray(glp_prob *P);
/* determine variable causing unboundedness */

#if 1 /* 08/VIII-2013; not documented yet */
int glp_get_it_cnt(glp_prob *P);
/* get simplex solver iteration count */
#endif

#if 1 /* 08/VIII-2013; not documented yet */
void glp_set_it_cnt(glp_prob *P, int it_cnt);
/* set simplex solver iteration count */
#endif

int glp_interior(glp_prob *P, const glp_iptcp *parm);
/* solve LP problem with the interior-point method */

void glp_init_iptcp(glp_iptcp *parm);
/* initialize interior-point solver control parameters */

int glp_ipt_status(glp_prob *P);
/* retrieve status of interior-point solution */

double glp_ipt_obj_val(glp_prob *P);
/* retrieve objective value (interior point) */

double glp_ipt_row_prim(glp_prob *P, int i);
/* retrieve row primal value (interior point) */

double glp_ipt_row_dual(glp_prob *P, int i);
/* retrieve row dual value (interior point) */

double glp_ipt_col_prim(glp_prob *P, int j);
/* retrieve column primal value (interior point) */

double glp_ipt_col_dual(glp_prob *P, int j);
/* retrieve column dual value (interior point) */

void glp_set_col_kind(glp_prob *P, int j, int kind);
/* set (change) column kind */

int glp_get_col_kind(glp_prob *P, int j);
/* retrieve column kind */

int glp_get_num_int(glp_prob *P);
/* retrieve number of integer columns */

int glp_get_num_bin(glp_prob *P);
/* retrieve number of binary columns */

int glp_intopt(glp_prob *P, const glp_iocp *parm);
/* solve MIP problem with the branch-and-bound method */

void glp_init_iocp(glp_iocp *parm);
/* initialize integer optimizer control parameters */

int glp_mip_status(glp_prob *P);
/* retrieve status of MIP solution */

double glp_mip_obj_val(glp_prob *P);
/* retrieve objective value (MIP solution) */

double glp_mip_row_val(glp_prob *P, int i);
/* retrieve row value (MIP solution) */

double glp_mip_col_val(glp_prob *P, int j);
/* retrieve column value (MIP solution) */

void glp_check_kkt(glp_prob *P, int sol, int cond, double *ae_max,
      int *ae_ind, double *re_max, int *re_ind);
/* check feasibility/optimality conditions */

int glp_print_sol(glp_prob *P, const char *fname);
/* write basic solution in printable format */

int glp_read_sol(glp_prob *P, const char *fname);
/* read basic solution from text file */

int glp_write_sol(glp_prob *P, const char *fname);
/* write basic solution to text file */

int glp_print_ranges(glp_prob *P, int len, const int list[],
      int flags, const char *fname);
/* print sensitivity analysis report */

int glp_print_ipt(glp_prob *P, const char *fname);
/* write interior-point solution in printable format */

int glp_read_ipt(glp_prob *P, const char *fname);
/* read interior-point solution from text file */

int glp_write_ipt(glp_prob *P, const char *fname);
/* write interior-point solution to text file */

int glp_print_mip(glp_prob *P, const char *fname);
/* write MIP solution in printable format */

int glp_read_mip(glp_prob *P, const char *fname);
/* read MIP solution from text file */

int glp_write_mip(glp_prob *P, const char *fname);
/* write MIP solution to text file */

int glp_bf_exists(glp_prob *P);
/* check if LP basis factorization exists */

int glp_factorize(glp_prob *P);
/* compute LP basis factorization */

int glp_bf_updated(glp_prob *P);
/* check if LP basis factorization has been updated */

void glp_get_bfcp(glp_prob *P, glp_bfcp *parm);
/* retrieve LP basis factorization control parameters */

void glp_set_bfcp(glp_prob *P, const glp_bfcp *parm);
/* change LP basis factorization control parameters */

int glp_get_bhead(glp_prob *P, int k);
/* retrieve LP basis header information */

int glp_get_row_bind(glp_prob *P, int i);
/* retrieve row index in the basis header */

int glp_get_col_bind(glp_prob *P, int j);
/* retrieve column index in the basis header */

void glp_ftran(glp_prob *P, double x[]);
/* perform forward transformation (solve system B*x = b) */

void glp_btran(glp_prob *P, double x[]);
/* perform backward transformation (solve system B'*x = b) */

int glp_warm_up(glp_prob *P);
/* "warm up" LP basis */

int glp_eval_tab_row(glp_prob *P, int k, int ind[], double val[]);
/* compute row of the simplex tableau */

int glp_eval_tab_col(glp_prob *P, int k, int ind[], double val[]);
/* compute column of the simplex tableau */

int glp_transform_row(glp_prob *P, int len, int ind[], double val[]);
/* transform explicitly specified row */

int glp_transform_col(glp_prob *P, int len, int ind[], double val[]);
/* transform explicitly specified column */

int glp_prim_rtest(glp_prob *P, int len, const int ind[],
      const double val[], int dir, double eps);
/* perform primal ratio test */

int glp_dual_rtest(glp_prob *P, int len, const int ind[],
      const double val[], int dir, double eps);
/* perform dual ratio test */

void glp_analyze_bound(glp_prob *P, int k, double *value1, int *var1,
      double *value2, int *var2);
/* analyze active bound of non-basic variable */

void glp_analyze_coef(glp_prob *P, int k, double *coef1, int *var1,
      double *value1, double *coef2, int *var2, double *value2);
/* analyze objective coefficient at basic variable */

#if 1 /* 10/XII-2017 */
glp_prep *glp_npp_alloc_wksp(void);
/* allocate the preprocessor workspace */

void glp_npp_load_prob(glp_prep *prep, glp_prob *P, int sol,
      int names);
/* load original problem instance */

int glp_npp_preprocess1(glp_prep *prep, int hard);
/* perform basic LP/MIP preprocessing */

void glp_npp_build_prob(glp_prep *prep, glp_prob *Q);
/* build resultant problem instance */

void glp_npp_postprocess(glp_prep *prep, glp_prob *Q);
/* postprocess solution to resultant problem */

void glp_npp_obtain_sol(glp_prep *prep, glp_prob *P);
/* obtain solution to original problem */

void glp_npp_free_wksp(glp_prep *prep);
/* free the preprocessor workspace */
#endif

int glp_ios_reason(glp_tree *T);
/* determine reason for calling the callback routine */

glp_prob *glp_ios_get_prob(glp_tree *T);
/* access the problem object */

void glp_ios_tree_size(glp_tree *T, int *a_cnt, int *n_cnt,
      int *t_cnt);
/* determine size of the branch-and-bound tree */

int glp_ios_curr_node(glp_tree *T);
/* determine current active subproblem */

int glp_ios_next_node(glp_tree *T, int p);
/* determine next active subproblem */

int glp_ios_prev_node(glp_tree *T, int p);
/* determine previous active subproblem */

int glp_ios_up_node(glp_tree *T, int p);
/* determine parent subproblem */

int glp_ios_node_level(glp_tree *T, int p);
/* determine subproblem level */

double glp_ios_node_bound(glp_tree *T, int p);
/* determine subproblem local bound */

int glp_ios_best_node(glp_tree *T);
/* find active subproblem with best local bound */

double glp_ios_mip_gap(glp_tree *T);
/* compute relative MIP gap */

void *glp_ios_node_data(glp_tree *T, int p);
/* access subproblem application-specific data */

void glp_ios_row_attr(glp_tree *T, int i, glp_attr *attr);
/* retrieve additional row attributes */

int glp_ios_pool_size(glp_tree *T);
/* determine current size of the cut pool */

int glp_ios_add_row(glp_tree *T,
      const char *name, int klass, int flags, int len, const int ind[],
      const double val[], int type, double rhs);
/* add row (constraint) to the cut pool */

void glp_ios_del_row(glp_tree *T, int i);
/* remove row (constraint) from the cut pool */

void glp_ios_clear_pool(glp_tree *T);
/* remove all rows (constraints) from the cut pool */

int glp_ios_can_branch(glp_tree *T, int j);
/* check if can branch upon specified variable */

void glp_ios_branch_upon(glp_tree *T, int j, int sel);
/* choose variable to branch upon */

void glp_ios_select_node(glp_tree *T, int p);
/* select subproblem to continue the search */

int glp_ios_heur_sol(glp_tree *T, const double x[]);
/* provide solution found by heuristic */

void glp_ios_terminate(glp_tree *T);
/* terminate the solution process */

#ifdef GLP_UNDOC
int glp_gmi_cut(glp_prob *P, int j, int ind[], double val[], double
      phi[]);
/* generate Gomory's mixed integer cut (core routine) */

int glp_gmi_gen(glp_prob *P, glp_prob *pool, int max_cuts);
/* generate Gomory's mixed integer cuts */

typedef struct glp_cov glp_cov;
/* cover cur generator workspace */

glp_cov *glp_cov_init(glp_prob *P);
/* create and initialize cover cut generator */

void glp_cov_gen1(glp_prob *P, glp_cov *cov, glp_prob *pool);
/* generate locally valid simple cover cuts */

void glp_cov_free(glp_cov *cov);
/* delete cover cut generator workspace */

typedef struct glp_mir glp_mir;
/* MIR cut generator workspace */

glp_mir *glp_mir_init(glp_prob *P);
/* create and initialize MIR cut generator */

int glp_mir_gen(glp_prob *P, glp_mir *mir, glp_prob *pool);
/* generate mixed integer rounding (MIR) cuts */

void glp_mir_free(glp_mir *mir);
/* delete MIR cut generator workspace */

typedef struct glp_cfg glp_cfg;
/* conflict graph descriptor */

glp_cfg *glp_cfg_init(glp_prob *P);
/* create and initialize conflict graph */

void glp_cfg_free(glp_cfg *G);
/* delete conflict graph descriptor */

int glp_clq_cut(glp_prob *P, glp_cfg *G, int ind[], double val[]);
/* generate clique cut from conflict graph */
#endif /* GLP_UNDOC */

void glp_init_mpscp(glp_mpscp *parm);
/* initialize MPS format control parameters */

int glp_read_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
      const char *fname);
/* read problem data in MPS format */

int glp_write_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
      const char *fname);
/* write problem data in MPS format */

void glp_init_cpxcp(glp_cpxcp *parm);
/* initialize CPLEX LP format control parameters */

int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
/* read problem data in CPLEX LP format */

int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
/* write problem data in CPLEX LP format */

int glp_read_prob(glp_prob *P, int flags, const char *fname);
/* read problem data in GLPK format */

int glp_write_prob(glp_prob *P, int flags, const char *fname);
/* write problem data in GLPK format */

glp_tran *glp_mpl_alloc_wksp(void);
/* allocate the MathProg translator workspace */

void glp_mpl_init_rand(glp_tran *tran, int seed);
/* initialize pseudo-random number generator */

int glp_mpl_read_model(glp_tran *tran, const char *fname, int skip);
/* read and translate model section */

int glp_mpl_read_data(glp_tran *tran, const char *fname);
/* read and translate data section */

int glp_mpl_generate(glp_tran *tran, const char *fname);
/* generate the model */

void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob);
/* build LP/MIP problem instance from the model */

int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol);
/* postsolve the model */

void glp_mpl_free_wksp(glp_tran *tran);
/* free the MathProg translator workspace */

int glp_read_cnfsat(glp_prob *P, const char *fname);
/* read CNF-SAT problem data in DIMACS format */

int glp_check_cnfsat(glp_prob *P);
/* check for CNF-SAT problem instance */

int glp_write_cnfsat(glp_prob *P, const char *fname);
/* write CNF-SAT problem data in DIMACS format */

int glp_minisat1(glp_prob *P);
/* solve CNF-SAT problem with MiniSat solver */

int glp_intfeas1(glp_prob *P, int use_bound, int obj_bound);
/* solve integer feasibility problem */

int glp_init_env(void);
/* initialize GLPK environment */

const char *glp_version(void);
/* determine library version */

const char *glp_config(const char *option);
/* determine library configuration */

int glp_free_env(void);
/* free GLPK environment */

void glp_puts(const char *s);
/* write string on terminal */

void glp_printf(const char *fmt, ...);
/* write formatted output on terminal */

void glp_vprintf(const char *fmt, va_list arg);
/* write formatted output on terminal */

int glp_term_out(int flag);
/* enable/disable terminal output */

void glp_term_hook(int (*func)(void *info, const char *s), void *info);
/* install hook to intercept terminal output */

int glp_open_tee(const char *name);
/* start copying terminal output to text file */

int glp_close_tee(void);
/* stop copying terminal output to text file */

#ifndef GLP_ERRFUNC_DEFINED
#define GLP_ERRFUNC_DEFINED
typedef void (*glp_errfunc)(const char *fmt, ...);
#endif

#define glp_error glp_error_(__FILE__, __LINE__)
glp_errfunc glp_error_(const char *file, int line);
/* display fatal error message and terminate execution */

#if 1 /* 07/XI-2015 */
int glp_at_error(void);
/* check for error state */
#endif

#define glp_assert(expr) \
      ((void)((expr) || (glp_assert_(#expr, __FILE__, __LINE__), 1)))
void glp_assert_(const char *expr, const char *file, int line);
/* check for logical condition */

void glp_error_hook(void (*func)(void *info), void *info);
/* install hook to intercept abnormal termination */

#define glp_malloc(size) glp_alloc(1, size)
/* allocate memory block (obsolete) */

#define glp_calloc(n, size) glp_alloc(n, size)
/* allocate memory block (obsolete) */

void *glp_alloc(int n, int size);
/* allocate memory block */

void *glp_realloc(void *ptr, int n, int size);
/* reallocate memory block */

void glp_free(void *ptr);
/* free (deallocate) memory block */

void glp_mem_limit(int limit);
/* set memory usage limit */

void glp_mem_usage(int *count, int *cpeak, size_t *total,
      size_t *tpeak);
/* get memory usage information */

double glp_time(void);
/* determine current universal time */

double glp_difftime(double t1, double t0);
/* compute difference between two time values */

typedef struct glp_graph glp_graph;
typedef struct glp_vertex glp_vertex;
typedef struct glp_arc glp_arc;

struct glp_graph
{     /* graph descriptor */
      void *pool; /* DMP *pool; */
      /* memory pool to store graph components */
      char *name;
      /* graph name (1 to 255 chars); NULL means no name is assigned
         to the graph */
      int nv_max;
      /* length of the vertex list (enlarged automatically) */
      int nv;
      /* number of vertices in the graph, 0 <= nv <= nv_max */
      int na;
      /* number of arcs in the graph, na >= 0 */
      glp_vertex **v; /* glp_vertex *v[1+nv_max]; */
      /* v[i], 1 <= i <= nv, is a pointer to i-th vertex */
      void *index; /* AVL *index; */
      /* vertex index to find vertices by their names; NULL means the
         index does not exist */
      int v_size;
      /* size of data associated with each vertex (0 to 256 bytes) */
      int a_size;
      /* size of data associated with each arc (0 to 256 bytes) */
};

struct glp_vertex
{     /* vertex descriptor */
      int i;
      /* vertex ordinal number, 1 <= i <= nv */
      char *name;
      /* vertex name (1 to 255 chars); NULL means no name is assigned
         to the vertex */
      void *entry; /* AVLNODE *entry; */
      /* pointer to corresponding entry in the vertex index; NULL means
         that either the index does not exist or the vertex has no name
         assigned */
      void *data;
      /* pointer to data associated with the vertex */
      void *temp;
      /* working pointer */
      glp_arc *in;
      /* pointer to the (unordered) list of incoming arcs */
      glp_arc *out;
      /* pointer to the (unordered) list of outgoing arcs */
};

struct glp_arc
{     /* arc descriptor */
      glp_vertex *tail;
      /* pointer to the tail endpoint */
      glp_vertex *head;
      /* pointer to the head endpoint */
      void *data;
      /* pointer to data associated with the arc */
      void *temp;
      /* working pointer */
      glp_arc *t_prev;
      /* pointer to previous arc having the same tail endpoint */
      glp_arc *t_next;
      /* pointer to next arc having the same tail endpoint */
      glp_arc *h_prev;
      /* pointer to previous arc having the same head endpoint */
      glp_arc *h_next;
      /* pointer to next arc having the same head endpoint */
};

glp_graph *glp_create_graph(int v_size, int a_size);
/* create graph */

void glp_set_graph_name(glp_graph *G, const char *name);
/* assign (change) graph name */

int glp_add_vertices(glp_graph *G, int nadd);
/* add new vertices to graph */

void glp_set_vertex_name(glp_graph *G, int i, const char *name);
/* assign (change) vertex name */

glp_arc *glp_add_arc(glp_graph *G, int i, int j);
/* add new arc to graph */

void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
/* delete vertices from graph */

void glp_del_arc(glp_graph *G, glp_arc *a);
/* delete arc from graph */

void glp_erase_graph(glp_graph *G, int v_size, int a_size);
/* erase graph content */

void glp_delete_graph(glp_graph *G);
/* delete graph */

void glp_create_v_index(glp_graph *G);
/* create vertex name index */

int glp_find_vertex(glp_graph *G, const char *name);
/* find vertex by its name */

void glp_delete_v_index(glp_graph *G);
/* delete vertex name index */

int glp_read_graph(glp_graph *G, const char *fname);
/* read graph from plain text file */

int glp_write_graph(glp_graph *G, const char *fname);
/* write graph to plain text file */

void glp_mincost_lp(glp_prob *P, glp_graph *G, int names, int v_rhs,
      int a_low, int a_cap, int a_cost);
/* convert minimum cost flow problem to LP */

int glp_mincost_okalg(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, double *sol, int a_x, int v_pi);
/* find minimum-cost flow with out-of-kilter algorithm */

int glp_mincost_relax4(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, int crash, double *sol, int a_x, int a_rc);
/* find minimum-cost flow with Bertsekas-Tseng relaxation method */

void glp_maxflow_lp(glp_prob *P, glp_graph *G, int names, int s,
      int t, int a_cap);
/* convert maximum flow problem to LP */

int glp_maxflow_ffalg(glp_graph *G, int s, int t, int a_cap,
      double *sol, int a_x, int v_cut);
/* find maximal flow with Ford-Fulkerson algorithm */

int glp_check_asnprob(glp_graph *G, int v_set);
/* check correctness of assignment problem data */

/* assignment problem formulation: */
#define GLP_ASN_MIN        1  /* perfect matching (minimization) */
#define GLP_ASN_MAX        2  /* perfect matching (maximization) */
#define GLP_ASN_MMP        3  /* maximum matching */

int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
      int v_set, int a_cost);
/* convert assignment problem to LP */

int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
      double *sol, int a_x);
/* solve assignment problem with out-of-kilter algorithm */

int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
/* find bipartite matching of maximum cardinality */

double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
/* solve critical path problem */

int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, const char *fname);
/* read min-cost flow problem data in DIMACS format */

int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, const char *fname);
/* write min-cost flow problem data in DIMACS format */

int glp_read_maxflow(glp_graph *G, int *s, int *t, int a_cap,
      const char *fname);
/* read maximum flow problem data in DIMACS format */

int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
      const char *fname);
/* write maximum flow problem data in DIMACS format */

int glp_read_asnprob(glp_graph *G, int v_set, int a_cost, const char
      *fname);
/* read assignment problem data in DIMACS format */

int glp_write_asnprob(glp_graph *G, int v_set, int a_cost, const char
      *fname);
/* write assignment problem data in DIMACS format */

int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname);
/* read graph in DIMACS clique/coloring format */

int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname);
/* write graph in DIMACS clique/coloring format */

int glp_netgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
      const int parm[1+15]);
/* Klingman's network problem generator */

void glp_netgen_prob(int nprob, int parm[1+15]);
/* Klingman's standard network problem instance */

int glp_gridgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
      const int parm[1+14]);
/* grid-like network problem generator */

int glp_rmfgen(glp_graph *G, int *s, int *t, int a_cap,
      const int parm[1+5]);
/* Goldfarb's maximum flow problem generator */

int glp_weak_comp(glp_graph *G, int v_num);
/* find all weakly connected components of graph */

int glp_strong_comp(glp_graph *G, int v_num);
/* find all strongly connected components of graph */

int glp_top_sort(glp_graph *G, int v_num);
/* topological sorting of acyclic digraph */

int glp_wclique_exact(glp_graph *G, int v_wgt, double *sol, int v_set);
/* find maximum weight clique with exact algorithm */

#ifdef __cplusplus
}
#endif

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/glpk_tls_config.h0000644000175100001710000000034200000000000025420 0ustar00runnerdocker00000000000000
#include "igraph_threading.h" /* IGRAPH_THREAD_SAFE */

/* This includes igraph's config.h.
 * The vendored GLPK must not have a config.h. */
#include "config.h"

#if IGRAPH_THREAD_SAFE
#define TLS IGRAPH_THREAD_LOCAL
#endif
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.671143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/0000755000175100001710000000000000000000000023421 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/cfg.c0000644000175100001710000003250100000000000024325 0ustar00runnerdocker00000000000000/* cfg.c (conflict graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "cfg.h"
#include "env.h"

/***********************************************************************
*  cfg_create_graph - create conflict graph
*
*  This routine creates the conflict graph, which initially is empty,
*  and returns a pointer to the graph descriptor.
*
*  The parameter n specifies the number of *all* variables in MIP, for
*  which the conflict graph will be built.
*
*  The parameter nv_max specifies maximal number of vertices in the
*  conflict graph. It should be the double number of binary variables
*  in corresponding MIP. */

CFG *cfg_create_graph(int n, int nv_max)
{     CFG *G;
      xassert(n >= 0);
      xassert(0 <= nv_max && nv_max <= n + n);
      G = talloc(1, CFG);
      G->n = n;
      G->pos = talloc(1+n, int);
      memset(&G->pos[1], 0, n * sizeof(int));
      G->neg = talloc(1+n, int);
      memset(&G->neg[1], 0, n * sizeof(int));
      G->pool = dmp_create_pool();
      G->nv_max = nv_max;
      G->nv = 0;
      G->ref = talloc(1+nv_max, int);
      G->vptr = talloc(1+nv_max, CFGVLE *);
      G->cptr = talloc(1+nv_max, CFGCLE *);
      return G;
}

/***********************************************************************
*  cfg_add_clique - add clique to conflict graph
*
*  This routine adds a clique to the conflict graph.
*
*  The parameter size specifies the clique size, size >= 2. Note that
*  any edge can be considered as a clique of size 2.
*
*  The array ind specifies vertices constituting the clique in elements
*  ind[k], 1 <= k <= size:
*
*  ind[k] = +j means a vertex of the conflict graph that corresponds to
*  original binary variable x[j], 1 <= j <= n.
*
*  ind[k] = -j means a vertex of the conflict graph that corresponds to
*  complement of original binary variable x[j], 1 <= j <= n.
*
*  Note that if both vertices for x[j] and (1 - x[j]) have appeared in
*  the conflict graph, the routine automatically adds an edge incident
*  to these vertices. */

static void add_edge(CFG *G, int v, int w)
{     /* add clique of size 2 */
      DMP *pool = G->pool;
      int nv = G->nv;
      CFGVLE **vptr = G->vptr;
      CFGVLE *vle;
      xassert(1 <= v && v <= nv);
      xassert(1 <= w && w <= nv);
      xassert(v != w);
      vle = dmp_talloc(pool, CFGVLE);
      vle->v = w;
      vle->next = vptr[v];
      vptr[v] = vle;
      vle = dmp_talloc(pool, CFGVLE);
      vle->v = v;
      vle->next = vptr[w];
      vptr[w] = vle;
      return;
}

void cfg_add_clique(CFG *G, int size, const int ind[])
{     int n = G->n;
      int *pos = G->pos;
      int *neg = G->neg;
      DMP *pool = G->pool;
      int nv_max = G->nv_max;
      int *ref = G->ref;
      CFGVLE **vptr = G->vptr;
      CFGCLE **cptr = G->cptr;
      int j, k, v;
      xassert(2 <= size && size <= nv_max);
      /* add new vertices to the conflict graph */
      for (k = 1; k <= size; k++)
      {  j = ind[k];
         if (j > 0)
         {  /* vertex corresponds to x[j] */
            xassert(1 <= j && j <= n);
            if (pos[j] == 0)
            {  /* no such vertex exists; add it */
               v = pos[j] = ++(G->nv);
               xassert(v <= nv_max);
               ref[v] = j;
               vptr[v] = NULL;
               cptr[v] = NULL;
               if (neg[j] != 0)
               {  /* now both vertices for x[j] and (1 - x[j]) exist */
                  add_edge(G, v, neg[j]);
               }
            }
         }
         else
         {  /* vertex corresponds to (1 - x[j]) */
            j = -j;
            xassert(1 <= j && j <= n);
            if (neg[j] == 0)
            {  /* no such vertex exists; add it */
               v = neg[j] = ++(G->nv);
               xassert(v <= nv_max);
               ref[v] = j;
               vptr[v] = NULL;
               cptr[v] = NULL;
               if (pos[j] != 0)
               {  /* now both vertices for x[j] and (1 - x[j]) exist */
                  add_edge(G, v, pos[j]);
               }
            }
         }
      }
      /* add specified clique to the conflict graph */
      if (size == 2)
         add_edge(G,
            ind[1] > 0 ? pos[+ind[1]] : neg[-ind[1]],
            ind[2] > 0 ? pos[+ind[2]] : neg[-ind[2]]);
      else
      {  CFGVLE *vp, *vle;
         CFGCLE *cle;
         /* build list of clique vertices */
         vp = NULL;
         for (k = 1; k <= size; k++)
         {  vle = dmp_talloc(pool, CFGVLE);
            vle->v = ind[k] > 0 ? pos[+ind[k]] : neg[-ind[k]];
            vle->next = vp;
            vp = vle;
         }
         /* attach the clique to all its vertices */
         for (k = 1; k <= size; k++)
         {  cle = dmp_talloc(pool, CFGCLE);
            cle->vptr = vp;
            v = ind[k] > 0 ? pos[+ind[k]] : neg[-ind[k]];
            cle->next = cptr[v];
            cptr[v] = cle;
         }
      }
      return;
}

/***********************************************************************
*  cfg_get_adjacent - get vertices adjacent to specified vertex
*
*  This routine stores numbers of all vertices adjacent to specified
*  vertex v of the conflict graph in locations ind[1], ..., ind[len],
*  and returns len, 1 <= len <= nv-1, where nv is the total number of
*  vertices in the conflict graph.
*
*  Note that the conflict graph defined by this routine has neither
*  self-loops nor multiple edges. */

int cfg_get_adjacent(CFG *G, int v, int ind[])
{     int nv = G->nv;
      int *ref = G->ref;
      CFGVLE **vptr = G->vptr;
      CFGCLE **cptr = G->cptr;
      CFGVLE *vle;
      CFGCLE *cle;
      int k, w, len;
      xassert(1 <= v && v <= nv);
      len = 0;
      /* walk thru the list of adjacent vertices */
      for (vle = vptr[v]; vle != NULL; vle = vle->next)
      {  w = vle->v;
         xassert(1 <= w && w <= nv);
         xassert(w != v);
         if (ref[w] > 0)
         {  ind[++len] = w;
            ref[w] = -ref[w];
         }
      }
      /* walk thru the list of incident cliques */
      for (cle = cptr[v]; cle != NULL; cle = cle->next)
      {  /* walk thru the list of clique vertices */
         for (vle = cle->vptr; vle != NULL; vle = vle->next)
         {  w = vle->v;
            xassert(1 <= w && w <= nv);
            if (w != v && ref[w] > 0)
            {  ind[++len] = w;
               ref[w] = -ref[w];
            }
         }
      }
      xassert(1 <= len && len < nv);
      /* unmark vertices included in the resultant adjacency list */
      for (k = 1; k <= len; k++)
      {  w = ind[k];
         ref[w] = -ref[w];
      }
      return len;
}

/***********************************************************************
*  cfg_expand_clique - expand specified clique to maximal clique
*
*  Given some clique in the conflict graph this routine expands it to
*  a maximal clique by including in it new vertices.
*
*  On entry vertex indices constituting the initial clique should be
*  stored in locations c_ind[1], ..., c_ind[c_len], where c_len is the
*  initial clique size. On exit the routine stores new vertex indices
*  to locations c_ind[c_len+1], ..., c_ind[c_len'], where c_len' is the
*  size of the maximal clique found, and returns c_len'.
*
*  ALGORITHM
*
*  Let G = (V, E) be a graph, C within V be a current clique to be
*  expanded, and D within V \ C be a subset of vertices adjacent to all
*  vertices from C. On every iteration the routine chooses some vertex
*  v in D, includes it into C, and removes from D the vertex v as well
*  as all vertices not adjacent to v. Initially C is empty and D = V.
*  Iterations repeat until D becomes an empty set. Obviously, the final
*  set C is a maximal clique in G.
*
*  Now let C0 be an initial clique, and we want C0 to be a subset of
*  the final maximal clique C. To provide this condition the routine
*  starts constructing C by choosing only such vertices v in D, which
*  are in C0, until all vertices from C0 have been included in C. May
*  note that if on some iteration C0 \ C is non-empty (i.e. if not all
*  vertices from C0 have been included in C), C0 \ C is a subset of D,
*  because C0 is a clique. */

static int intersection(int d_len, int d_ind[], int d_pos[], int len,
      const int ind[])
{     /* compute intersection D := D inter W, where W is some specified
       * set of vertices */
      int k, t, v, new_len;
      /* walk thru vertices in W and mark vertices in D */
      for (t = 1; t <= len; t++)
      {  /* v in W */
         v = ind[t];
         /* determine position of v in D */
         k = d_pos[v];
         if (k != 0)
         {  /* v in D */
            xassert(d_ind[k] == v);
            /* mark v to keep it in D */
            d_ind[k] = -v;
         }
      }
      /* remove all unmarked vertices from D */
      new_len = 0;
      for (k = 1; k <= d_len; k++)
      {  /* v in D */
         v = d_ind[k];
         if (v < 0)
         {  /* v is marked; keep it */
            v = -v;
            new_len++;
            d_ind[new_len] = v;
            d_pos[v] = new_len;
         }
         else
         {  /* v is not marked; remove it */
            d_pos[v] = 0;
         }
      }
      return new_len;
}

int cfg_expand_clique(CFG *G, int c_len, int c_ind[])
{     int nv = G->nv;
      int d_len, *d_ind, *d_pos, len, *ind;
      int k, v;
      xassert(0 <= c_len && c_len <= nv);
      /* allocate working arrays */
      d_ind = talloc(1+nv, int);
      d_pos = talloc(1+nv, int);
      ind = talloc(1+nv, int);
      /* initialize C := 0, D := V */
      d_len = nv;
      for (k = 1; k <= nv; k++)
         d_ind[k] = d_pos[k] = k;
      /* expand C by vertices of specified initial clique C0 */
      for (k = 1; k <= c_len; k++)
      {  /* v in C0 */
         v = c_ind[k];
         xassert(1 <= v && v <= nv);
         /* since C0 is clique, v should be in D */
         xassert(d_pos[v] != 0);
         /* W := set of vertices adjacent to v */
         len = cfg_get_adjacent(G, v, ind);
         /* D := D inter W */
         d_len = intersection(d_len, d_ind, d_pos, len, ind);
         /* since v not in W, now v should be not in D */
         xassert(d_pos[v] == 0);
      }
      /* expand C by some other vertices until D is empty */
      while (d_len > 0)
      {  /* v in D */
         v = d_ind[1];
         xassert(1 <= v && v <= nv);
         /* note that v is adjacent to all vertices in C (by design),
          * so add v to C */
         c_ind[++c_len] = v;
         /* W := set of vertices adjacent to v */
         len = cfg_get_adjacent(G, v, ind);
         /* D := D inter W */
         d_len = intersection(d_len, d_ind, d_pos, len, ind);
         /* since v not in W, now v should be not in D */
         xassert(d_pos[v] == 0);
      }
      /* free working arrays */
      tfree(d_ind);
      tfree(d_pos);
      tfree(ind);
      /* bring maximal clique to calling routine */
      return c_len;
}

/***********************************************************************
*  cfg_check_clique - check clique in conflict graph
*
*  This routine checks that vertices of the conflict graph specified
*  in locations c_ind[1], ..., c_ind[c_len] constitute a clique.
*
*  NOTE: for testing/debugging only. */

void cfg_check_clique(CFG *G, int c_len, const int c_ind[])
{     int nv = G->nv;
      int k, kk, v, w, len, *ind;
      char *flag;
      ind = talloc(1+nv, int);
      flag = talloc(1+nv, char);
      memset(&flag[1], 0, nv);
      /* walk thru clique vertices */
      xassert(c_len >= 0);
      for (k = 1; k <= c_len; k++)
      {  /* get clique vertex v */
         v = c_ind[k];
         xassert(1 <= v && v <= nv);
         /* get vertices adjacent to vertex v */
         len = cfg_get_adjacent(G, v, ind);
         for (kk = 1; kk <= len; kk++)
         {  w = ind[kk];
            xassert(1 <= w && w <= nv);
            xassert(w != v);
            flag[w] = 1;
         }
         /* check that all clique vertices other than v are adjacent
            to v */
         for (kk = 1; kk <= c_len; kk++)
         {  w = c_ind[kk];
            xassert(1 <= w && w <= nv);
            if (w != v)
               xassert(flag[w]);
         }
         /* reset vertex flags */
         for (kk = 1; kk <= len; kk++)
            flag[ind[kk]] = 0;
      }
      tfree(ind);
      tfree(flag);
      return;
}

/***********************************************************************
*  cfg_delete_graph - delete conflict graph
*
*  This routine deletes the conflict graph by freeing all the memory
*  allocated to this program object. */

void cfg_delete_graph(CFG *G)
{     tfree(G->pos);
      tfree(G->neg);
      dmp_delete_pool(G->pool);
      tfree(G->ref);
      tfree(G->vptr);
      tfree(G->cptr);
      tfree(G);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/cfg.h0000644000175100001710000001135200000000000024333 0ustar00runnerdocker00000000000000/* cfg.h (conflict graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef CFG_H
#define CFG_H

#include "dmp.h"

/***********************************************************************
*  The structure CFG describes the conflict graph.
*
*  Conflict graph is an undirected graph G = (V, E), where V is a set
*  of vertices, E <= V x V is a set of edges. Each vertex v in V of the
*  conflict graph corresponds to a binary variable z[v], which is
*  either an original binary variable x[j] or its complement 1 - x[j].
*  Edge (v,w) in E means that z[v] and z[w] cannot take the value 1 at
*  the same time, i.e. it defines an inequality z[v] + z[w] <= 1, which
*  is assumed to be valid for original MIP.
*
*  Since the conflict graph may be dense, it is stored as an union of
*  its cliques rather than explicitly. */

#if 0 /* 08/III-2016 */
typedef struct CFG CFG;
#else
typedef struct glp_cfg CFG;
#endif
typedef struct CFGVLE CFGVLE;
typedef struct CFGCLE CFGCLE;

#if 0 /* 08/III-2016 */
struct CFG
#else
struct glp_cfg
#endif
{     /* conflict graph descriptor */
      int n;
      /* number of *all* variables (columns) in corresponding MIP */
      int *pos; /* int pos[1+n]; */
      /* pos[0] is not used;
       * pos[j] = v, 1 <= j <= n, means that vertex v corresponds to
       * original binary variable x[j], and pos[j] = 0 means that the
       * conflict graph has no such vertex */
      int *neg; /* int neg[1+n]; */
      /* neg[0] is not used;
       * neg[j] = v, 1 <= j <= n, means that vertex v corresponds to
       * complement of original binary variable x[j], and neg[j] = 0
       * means that the conflict graph has no such vertex */
      DMP *pool;
      /* memory pool to allocate elements of the conflict graph */
      int nv_max;
      /* maximal number of vertices in the conflict graph */
      int nv;
      /* current number of vertices in the conflict graph */
      int *ref; /* int ref[1+nv_max]; */
      /* ref[v] = j, 1 <= v <= nv, means that vertex v corresponds
       * either to original binary variable x[j] or to its complement,
       * i.e. either pos[j] = v or neg[j] = v */
      CFGVLE **vptr; /* CFGVLE *vptr[1+nv_max]; */
      /* vptr[v], 1 <= v <= nv, is an initial pointer to the list of
       * vertices adjacent to vertex v */
      CFGCLE **cptr; /* CFGCLE *cptr[1+nv_max]; */
      /* cptr[v], 1 <= v <= nv, is an initial pointer to the list of
       * cliques that contain vertex v */
};

struct CFGVLE
{     /* vertex list element */
      int v;
      /* vertex number, 1 <= v <= nv */
      CFGVLE *next;
      /* pointer to next vertex list element */
};

struct CFGCLE
{     /* clique list element */
      CFGVLE *vptr;
      /* initial pointer to the list of clique vertices */
      CFGCLE *next;
      /* pointer to next clique list element */
};

#define cfg_create_graph _glp_cfg_create_graph
CFG *cfg_create_graph(int n, int nv_max);
/* create conflict graph */

#define cfg_add_clique _glp_cfg_add_clique
void cfg_add_clique(CFG *G, int size, const int ind[]);
/* add clique to conflict graph */

#define cfg_get_adjacent _glp_cfg_get_adjacent
int cfg_get_adjacent(CFG *G, int v, int ind[]);
/* get vertices adjacent to specified vertex */

#define cfg_expand_clique _glp_cfg_expand_clique
int cfg_expand_clique(CFG *G, int c_len, int c_ind[]);
/* expand specified clique to maximal clique */

#define cfg_check_clique _glp_cfg_check_clique
void cfg_check_clique(CFG *G, int c_len, const int c_ind[]);
/* check clique in conflict graph */

#define cfg_delete_graph _glp_cfg_delete_graph
void cfg_delete_graph(CFG *G);
/* delete conflict graph */

#define cfg_build_graph _glp_cfg_build_graph
CFG *cfg_build_graph(void /* glp_prob */ *P);
/* build conflict graph */

#define cfg_find_clique _glp_cfg_find_clique
int cfg_find_clique(void /* glp_prob */ *P, CFG *G, int ind[],
      double *sum);
/* find maximum weight clique in conflict graph */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/cfg1.c0000644000175100001710000006026100000000000024412 0ustar00runnerdocker00000000000000/* cfg1.c (conflict graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "cfg.h"
#include "env.h"
#include "prob.h"
#include "wclique.h"
#include "wclique1.h"

/***********************************************************************
*  cfg_build_graph - build conflict graph
*
*  This routine builds the conflict graph. It analyzes the specified
*  problem object to discover original and implied packing inequalities
*  and adds corresponding cliques to the conflict graph.
*
*  Packing inequality has the form:
*
*      sum z[j] <= 1,                                                (1)
*     j in J
*
*  where z[j] = x[j] or z[j] = 1 - x[j], x[j] is an original binary
*  variable. Every packing inequality (1) is equivalent to a set of
*  edge inequalities:
*
*     z[i] + z[j] <= 1   for all i, j in J, i != j,                  (2)
*
*  and since every edge inequality (2) defines an edge in the conflict
*  graph, corresponding packing inequality (1) defines a clique.
*
*  To discover packing inequalities the routine analyzes constraints
*  of the specified MIP. To simplify the analysis each constraint is
*  analyzed separately. The analysis is performed as follows.
*
*  Let some original constraint be the following:
*
*     L <= sum a[j] x[j] <= U.                                       (3)
*
*  To analyze it the routine analyzes two constraints of "not greater
*  than" type:
*
*     sum (-a[j]) x[j] <= -L,                                        (4)
*
*     sum (+a[j]) x[j] <= +U,                                        (5)
*
*  which are relaxations of the original constraint (3). (If, however,
*  L = -oo, or U = +oo, corresponding constraint being redundant is not
*  analyzed.)
*
*  Let a constraint of "not greater than" type be the following:
*
*      sum  a[j] x[j] + sum  a[j] x[j] <= b,                         (6)
*     j in J           j in J'
*
*  where J is a subset of binary variables, J' is a subset of other
*  (continues and non-binary integer) variables. The constraint (6) is
*  is relaxed as follows, to eliminate non-binary variables:
*
*      sum  a[j] x[j] <= b -  sum  a[j] x[j] <= b',                  (7)
*     j in J                 j in J'
*
*     b' = sup(b -  sum  a[j] x[j]) =
*                  j in J'
*
*        = b - inf(sum a[j] x[j]) =
*
*        = b - sum inf(a[j] x[j]) =                                  (8)
*
*        = b -  sum  a[j] inf(x[j]) -  sum  a[j] sup(x[j]) =
*              a[j]>0                 a[j]<0
*
*        = b -  sum  a[j] l[j] -  sum  a[j] u[j],
*              a[j]>0            a[j]<0
*
*  where l[j] and u[j] are, resp., lower and upper bounds of x[j].
*
*  Then the routine transforms the relaxed constraint containing only
*  binary variables:
*
*     sum a[j] x[j] <= b                                             (9)
*
*  to an equivalent 0-1 knapsack constraint as follows:
*
*     sum  a[j] x[j] + sum  a[j] x[j] <= b   ==>
*    a[j]>0           a[j]<0
*
*     sum  a[j] x[j] + sum  a[j] (1 - x[j]) <= b   ==>
*    a[j]>0           a[j]<0                                        (10)
*
*     sum  (+a[j]) x[j] + sum  (-a[j]) x[j] <= b + sum  (-a[j])   ==>
*    a[j]>0              a[j]<0                   a[j]<0
*
*     sum a'[j] z[j] <= b',
*
*  where a'[j] = |a[j]| > 0, and
*
*            ( x[j]      if a[j] > 0
*     z[j] = <
*            ( 1 - x[j]  if a[j] < 0
*
*  is a binary variable, which is either original binary variable x[j]
*  or its complement.
*
*  Finally, the routine analyzes the resultant 0-1 knapsack inequality:
*
*       sum a[j] z[j] <= b,                                         (11)
*     j in J
*
*  where all a[j] are positive, to discover clique inequalities (1),
*  which are valid for (11) and therefore valid for (3). (It is assumed
*  that the original MIP has been preprocessed, so it is not checked,
*  for example, that b > 0 or that a[j] <= b.)
*
*  In principle, to discover any edge inequalities valid for (11) it
*  is sufficient to check whether a[i] + a[j] > b for all i, j in J,
*  i < j. However, this way requires O(|J|^2) checks, so the routine
*  analyses (11) in the following way, which is much more efficient in
*  many practical cases.
*
*  1. Let a[p] and a[q] be two minimal coefficients:
*
*     a[p] = min a[j],                                              (12)
*
*     a[q] = min a[j], j != p,                                      (13)
*
*  such that
*
*     a[p] + a[q] > b.                                              (14)
*
*  This means that a[i] + a[j] > b for any i, j in J, i != j, so
*
*     z[i] + z[j] <= 1                                              (15)
*
*  are valid for (11) for any i, j in J, i != j. This case means that
*  J define a clique in the conflict graph.
*
*  2. Otherwise, let a[p] and [q] be two maximal coefficients:
*
*     a[p] = max a[j],                                              (16)
*
*     a[q] = max a[j], j != p,                                      (17)
*
*  such that
*
*     a[p] + a[q] <= b.                                             (18)
*
*  This means that a[i] + a[j] <= b for any i, j in J, i != j, so in
*  this case no valid edge inequalities for (11) exist.
*
*  3. Otherwise, let all a[j] be ordered by descending their values:
*
*     a[1] >= a[2] >= ... >= a[p-1] >= a[p] >= a[p+1] >= ...        (19)
*
*  where p is such that
*
*     a[p-1] + a[p] >  b,                                           (20)
*
*     a[p] + a[p+1] <= b.                                           (21)
*
*  (May note that due to the former two cases in this case we always
*  have 2 <= p <= |J|-1.)
*
*  Since a[p] and a[p-1] are two minimal coefficients in the set
*  J' = {1, ..., p}, J' define a clique in the conflict graph for the
*  same reason as in the first case. Similarly, since a[p] and a[p+1]
*  are two maximal coefficients in the set J" = {p, ..., |J|}, no edge
*  inequalities exist for all i, j in J" for the same reason as in the
*  second case. Thus, to discover other edge inequalities (15) valid
*  for (11), the routine checks if a[i] + a[j] > b for all i in J',
*  j in J", i != j. */

#define is_binary(j) \
      (P->col[j]->kind == GLP_IV && P->col[j]->type == GLP_DB && \
      P->col[j]->lb == 0.0 && P->col[j]->ub == 1.0)
/* check if x[j] is binary variable */

struct term { int ind; double val; };
/* term a[j] * z[j] used to sort a[j]'s */

static int CDECL fcmp(const void *e1, const void *e2)
{     /* auxiliary routine called from qsort */
      const struct term *t1 = e1, *t2 = e2;
      if (t1->val > t2->val)
         return -1;
      else if (t1->val < t2->val)
         return +1;
      else
         return 0;
}

static void analyze_ineq(glp_prob *P, CFG *G, int len, int ind[],
      double val[], double rhs, struct term t[])
{     /* analyze inequality constraint (6) */
      /* P is the original MIP
       * G is the conflict graph to be built
       * len is the number of terms in the constraint
       * ind[1], ..., ind[len] are indices of variables x[j]
       * val[1], ..., val[len] are constraint coefficients a[j]
       * rhs is the right-hand side b
       * t[1+len] is a working array */
      int j, k, kk, p, q, type, new_len;
      /* eliminate non-binary variables; see (7) and (8) */
      new_len = 0;
      for (k = 1; k <= len; k++)
      {  /* get index of variable x[j] */
         j = ind[k];
         if (is_binary(j))
         {  /* x[j] remains in relaxed constraint */
            new_len++;
            ind[new_len] = j;
            val[new_len] = val[k];
         }
         else if (val[k] > 0.0)
         {  /* eliminate non-binary x[j] in case a[j] > 0 */
            /* b := b - a[j] * l[j]; see (8) */
            type = P->col[j]->type;
            if (type == GLP_FR || type == GLP_UP)
            {  /* x[j] has no lower bound */
               goto done;
            }
            rhs -= val[k] * P->col[j]->lb;
         }
         else /* val[j] < 0.0 */
         {  /* eliminate non-binary x[j] in case a[j] < 0 */
            /* b := b - a[j] * u[j]; see (8) */
            type = P->col[j]->type;
            if (type == GLP_FR || type == GLP_LO)
            {  /* x[j] has no upper bound */
               goto done;
            }
            rhs -= val[k] * P->col[j]->ub;
         }
      }
      len = new_len;
      /* now we have the constraint (9) */
      if (len <= 1)
      {  /* at least two terms are needed */
         goto done;
      }
      /* make all constraint coefficients positive; see (10) */
      for (k = 1; k <= len; k++)
      {  if (val[k] < 0.0)
         {  /* a[j] < 0; substitute x[j] = 1 - x'[j], where x'[j] is
             * a complement binary variable */
            ind[k] = -ind[k];
            val[k] = -val[k];
            rhs += val[k];
         }
      }
      /* now we have 0-1 knapsack inequality (11) */
      /* increase the right-hand side a bit to avoid false checks due
       * to rounding errors */
      rhs += 0.001 * (1.0 + fabs(rhs));
      /*** first case ***/
      /* find two minimal coefficients a[p] and a[q] */
      p = 0;
      for (k = 1; k <= len; k++)
      {  if (p == 0 || val[p] > val[k])
            p = k;
      }
      q = 0;
      for (k = 1; k <= len; k++)
      {  if (k != p && (q == 0 || val[q] > val[k]))
            q = k;
      }
      xassert(p != 0 && q != 0 && p != q);
      /* check condition (14) */
      if (val[p] + val[q] > rhs)
      {  /* all z[j] define a clique in the conflict graph */
         cfg_add_clique(G, len, ind);
         goto done;
      }
      /*** second case ***/
      /* find two maximal coefficients a[p] and a[q] */
      p = 0;
      for (k = 1; k <= len; k++)
      {  if (p == 0 || val[p] < val[k])
            p = k;
      }
      q = 0;
      for (k = 1; k <= len; k++)
      {  if (k != p && (q == 0 || val[q] < val[k]))
            q = k;
      }
      xassert(p != 0 && q != 0 && p != q);
      /* check condition (18) */
      if (val[p] + val[q] <= rhs)
      {  /* no valid edge inequalities exist */
         goto done;
      }
      /*** third case ***/
      xassert(len >= 3);
      /* sort terms in descending order of coefficient values */
      for (k = 1; k <= len; k++)
      {  t[k].ind = ind[k];
         t[k].val = val[k];
      }
      qsort(&t[1], len, sizeof(struct term), fcmp);
      for (k = 1; k <= len; k++)
      {  ind[k] = t[k].ind;
         val[k] = t[k].val;
      }
      /* now a[1] >= a[2] >= ... >= a[len-1] >= a[len] */
      /* note that a[1] + a[2] > b and a[len-1] + a[len] <= b due two
       * the former two cases */
      xassert(val[1] + val[2] > rhs);
      xassert(val[len-1] + val[len] <= rhs);
      /* find p according to conditions (20) and (21) */
      for (p = 2; p < len; p++)
      {  if (val[p] + val[p+1] <= rhs)
            break;
      }
      xassert(p < len);
      /* z[1], ..., z[p] define a clique in the conflict graph */
      cfg_add_clique(G, p, ind);
      /* discover other edge inequalities */
      for (k = 1; k <= p; k++)
      {  for (kk = p; kk <= len; kk++)
         {  if (k != kk && val[k] + val[kk] > rhs)
            {  int iii[1+2];
               iii[1] = ind[k];
               iii[2] = ind[kk];
               cfg_add_clique(G, 2, iii);
            }
         }
      }
done: return;
}

CFG *cfg_build_graph(void *P_)
{     glp_prob *P = P_;
      int m = P->m;
      int n = P->n;
      CFG *G;
      int i, k, type, len, *ind;
      double *val;
      struct term *t;
      /* create the conflict graph (number of its vertices cannot be
       * greater than double number of binary variables) */
      G = cfg_create_graph(n, 2 * glp_get_num_bin(P));
      /* allocate working arrays */
      ind = talloc(1+n, int);
      val = talloc(1+n, double);
      t = talloc(1+n, struct term);
      /* analyze constraints to discover edge inequalities */
      for (i = 1; i <= m; i++)
      {  type = P->row[i]->type;
         if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
         {  /* i-th row has lower bound */
            /* analyze inequality sum (-a[j]) * x[j] <= -lb */
            len = glp_get_mat_row(P, i, ind, val);
            for (k = 1; k <= len; k++)
               val[k] = -val[k];
            analyze_ineq(P, G, len, ind, val, -P->row[i]->lb, t);
         }
         if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
         {  /* i-th row has upper bound */
            /* analyze inequality sum (+a[j]) * x[j] <= +ub */
            len = glp_get_mat_row(P, i, ind, val);
            analyze_ineq(P, G, len, ind, val, +P->row[i]->ub, t);
         }
      }
      /* free working arrays */
      tfree(ind);
      tfree(val);
      tfree(t);
      return G;
}

/***********************************************************************
*  cfg_find_clique - find maximum weight clique in conflict graph
*
*  This routine finds a maximum weight clique in the conflict graph
*  G = (V, E), where the weight of vertex v in V is the value of
*  corresponding binary variable z (which is either an original binary
*  variable or its complement) in the optimal solution to LP relaxation
*  provided in the problem object. The goal is to find a clique in G,
*  whose weight is greater than 1, in which case corresponding packing
*  inequality is violated at the optimal point.
*
*  On exit the routine stores vertex indices of the conflict graph
*  included in the clique found to locations ind[1], ..., ind[len], and
*  returns len, which is the clique size. The clique weight is stored
*  in location pointed to by the parameter sum. If no clique has been
*  found, the routine returns 0.
*
*  Since the conflict graph may have a big number of vertices and be
*  quite dense, the routine uses an induced subgraph G' = (V', E'),
*  which is constructed as follows:
*
*  1. If the weight of some vertex v in V is zero (close to zero), it
*     is not included in V'. Obviously, including in a clique
*     zero-weight vertices does not change its weight, so if in G there
*     exist a clique of a non-zero weight, in G' exists a clique of the
*     same weight. This point is extremely important, because dropping
*     out zero-weight vertices can be done without retrieving lists of
*     adjacent vertices whose size may be very large.
*
*  2. Cumulative weight of vertex v in V is the sum of the weight of v
*     and weights of all vertices in V adjacent to v. Obviously, if
*     a clique includes a vertex v, the clique weight cannot be greater
*     than the cumulative weight of v. Since we are interested only in
*     cliques whose weight is greater than 1, vertices of V, whose
*     cumulative weight is not greater than 1, are not included in V'.
*
*  May note that in many practical cases the size of the induced
*  subgraph G' is much less than the size of the original conflict
*  graph G due to many binary variables, whose optimal values are zero
*  or close to zero. For example, it may happen that |V| = 100,000 and
*  |E| = 1e9 while |V'| = 50 and |E'| = 1000. */

struct csa
{     /* common storage area */
      glp_prob *P;
      /* original MIP */
      CFG *G;
      /* original conflict graph G = (V, E), |V| = nv */
      int *ind; /* int ind[1+nv]; */
      /* working array */
      /*--------------------------------------------------------------*/
      /* induced subgraph G' = (V', E') of original conflict graph */
      int nn;
      /* number of vertices in V' */
      int *vtoi; /* int vtoi[1+nv]; */
      /* vtoi[v] = i, 1 <= v <= nv, means that vertex v in V is vertex
       * i in V'; vtoi[v] = 0 means that vertex v is not included in
       * the subgraph */
      int *itov; /* int itov[1+nv]; */
      /* itov[i] = v, 1 <= i <= nn, means that vertex i in V' is vertex
       * v in V */
      double *wgt; /* double wgt[1+nv]; */
      /* wgt[i], 1 <= i <= nn, is a weight of vertex i in V', which is
       * the value of corresponding binary variable in optimal solution
       * to LP relaxation */
};

static void build_subgraph(struct csa *csa)
{     /* build induced subgraph */
      glp_prob *P = csa->P;
      int n = P->n;
      CFG *G = csa->G;
      int *ind = csa->ind;
      int *pos = G->pos;
      int *neg = G->neg;
      int nv = G->nv;
      int *ref = G->ref;
      int *vtoi = csa->vtoi;
      int *itov = csa->itov;
      double *wgt = csa->wgt;
      int j, k, v, w, nn, len;
      double z, sum;
      /* initially induced subgraph is empty */
      nn = 0;
      /* walk thru vertices of original conflict graph */
      for (v = 1; v <= nv; v++)
      {  /* determine value of binary variable z[j] that corresponds to
          * vertex v */
         j = ref[v];
         xassert(1 <= j && j <= n);
         if (pos[j] == v)
         {  /* z[j] = x[j], where x[j] is original variable */
            z = P->col[j]->prim;
         }
         else if (neg[j] == v)
         {  /* z[j] = 1 - x[j], where x[j] is original variable */
            z = 1.0 - P->col[j]->prim;
         }
         else
            xassert(v != v);
         /* if z[j] is close to zero, do not include v in the induced
          * subgraph */
         if (z < 0.001)
         {  vtoi[v] = 0;
            continue;
         }
         /* calculate cumulative weight of vertex v */
         sum = z;
         /* walk thru all vertices adjacent to v */
         len = cfg_get_adjacent(G, v, ind);
         for (k = 1; k <= len; k++)
         {  /* there is an edge (v,w) in the conflict graph */
            w = ind[k];
            xassert(w != v);
            /* add value of z[j] that corresponds to vertex w */
            j = ref[w];
            xassert(1 <= j && j <= n);
            if (pos[j] == w)
               sum += P->col[j]->prim;
            else if (neg[j] == w)
               sum += 1.0 - P->col[j]->prim;
            else
               xassert(w != w);
         }
         /* cumulative weight of vertex v is an upper bound of weight
          * of any clique containing v; so if it not greater than 1, do
          * not include v in the induced subgraph */
         if (sum < 1.010)
         {  vtoi[v] = 0;
            continue;
         }
         /* include vertex v in the induced subgraph */
         nn++;
         vtoi[v] = nn;
         itov[nn] = v;
         wgt[nn] = z;
      }
      /* induced subgraph has been built */
      csa->nn = nn;
      return;
}

static int sub_adjacent(struct csa *csa, int i, int adj[])
{     /* retrieve vertices of induced subgraph adjacent to specified
       * vertex */
      CFG *G = csa->G;
      int nv = G->nv;
      int *ind = csa->ind;
      int nn = csa->nn;
      int *vtoi = csa->vtoi;
      int *itov = csa->itov;
      int j, k, v, w, len, len1;
      /* determine original vertex v corresponding to vertex i */
      xassert(1 <= i && i <= nn);
      v = itov[i];
      /* retrieve vertices adjacent to vertex v in original graph */
      len1 = cfg_get_adjacent(G, v, ind);
      /* keep only adjacent vertices which are in induced subgraph and
       * change their numbers appropriately */
      len = 0;
      for (k = 1; k <= len1; k++)
      {  /* there exists edge (v, w) in original graph */
         w = ind[k];
         xassert(1 <= w && w <= nv && w != v);
         j = vtoi[w];
         if (j != 0)
         {  /* vertex w is vertex j in induced subgraph */
            xassert(1 <= j && j <= nn && j != i);
            adj[++len] = j;
         }
      }
      return len;
}

static int find_clique(struct csa *csa, int c_ind[])
{     /* find maximum weight clique in induced subgraph with exact
       * Ostergard's algorithm */
      int nn = csa->nn;
      double *wgt = csa->wgt;
      int i, j, k, p, q, t, ne, nb, len, *iwt, *ind;
      unsigned char *a;
      xassert(nn >= 2);
      /* allocate working array */
      ind = talloc(1+nn, int);
      /* calculate the number of elements in lower triangle (without
       * diagonal) of adjacency matrix of induced subgraph */
      ne = (nn * (nn - 1)) / 2;
      /* calculate the number of bytes needed to store lower triangle
       * of adjacency matrix */
      nb = (ne + (CHAR_BIT - 1)) / CHAR_BIT;
      /* allocate lower triangle of adjacency matrix */
      a = talloc(nb, unsigned char);
      /* fill lower triangle of adjacency matrix */
      memset(a, 0, nb);
      for (p = 1; p <= nn; p++)
      {  /* retrieve vertices adjacent to vertex p */
         len = sub_adjacent(csa, p, ind);
         for (k = 1; k <= len; k++)
         {  /* there exists edge (p, q) in induced subgraph */
            q = ind[k];
            xassert(1 <= q && q <= nn && q != p);
            /* determine row and column indices of this edge in lower
             * triangle of adjacency matrix */
            if (p > q)
               i = p, j = q;
            else /* p < q */
               i = q, j = p;
            /* set bit a[i,j] to 1, i > j */
            t = ((i - 1) * (i - 2)) / 2 + (j - 1);
            a[t / CHAR_BIT] |=
               (unsigned char)(1 << ((CHAR_BIT - 1) - t % CHAR_BIT));
         }
      }
      /* scale vertex weights by 1000 and convert them to integers as
       * required by Ostergard's algorithm */
      iwt = ind;
      for (i = 1; i <= nn; i++)
      {  /* it is assumed that 0 <= wgt[i] <= 1 */
         t = (int)(1000.0 * wgt[i] + 0.5);
         if (t < 0)
            t = 0;
         else if (t > 1000)
            t = 1000;
         iwt[i] = t;
      }
      /* find maximum weight clique */
      len = wclique(nn, iwt, a, c_ind);
      /* free working arrays */
      tfree(ind);
      tfree(a);
      /* return clique size to calling routine */
      return len;
}

static int func(void *info, int i, int ind[])
{     /* auxiliary routine used by routine find_clique1 */
      struct csa *csa = info;
      xassert(1 <= i && i <= csa->nn);
      return sub_adjacent(csa, i, ind);
}

static int find_clique1(struct csa *csa, int c_ind[])
{     /* find maximum weight clique in induced subgraph with greedy
       * heuristic */
      int nn = csa->nn;
      double *wgt = csa->wgt;
      int len;
      xassert(nn >= 2);
      len = wclique1(nn, wgt, func, csa, c_ind);
      /* return clique size to calling routine */
      return len;
}

int cfg_find_clique(void *P, CFG *G, int ind[], double *sum_)
{     int nv = G->nv;
      struct csa csa;
      int i, k, len;
      double sum;
      /* initialize common storage area */
      csa.P = P;
      csa.G = G;
      csa.ind = talloc(1+nv, int);
      csa.nn = -1;
      csa.vtoi = talloc(1+nv, int);
      csa.itov = talloc(1+nv, int);
      csa.wgt = talloc(1+nv, double);
      /* build induced subgraph */
      build_subgraph(&csa);
#ifdef GLP_DEBUG
      xprintf("nn = %d\n", csa.nn);
#endif
      /* if subgraph has less than two vertices, do nothing */
      if (csa.nn < 2)
      {  len = 0;
         sum = 0.0;
         goto skip;
      }
      /* find maximum weight clique in induced subgraph */
#if 1 /* FIXME */
      if (csa.nn <= 50)
#endif
      {  /* induced subgraph is small; use exact algorithm */
         len = find_clique(&csa, ind);
      }
      else
      {  /* induced subgraph is large; use greedy heuristic */
         len = find_clique1(&csa, ind);
      }
      /* do not report clique, if it has less than two vertices */
      if (len < 2)
      {  len = 0;
         sum = 0.0;
         goto skip;
      }
      /* convert indices of clique vertices from induced subgraph to
       * original conflict graph and compute clique weight */
      sum = 0.0;
      for (k = 1; k <= len; k++)
      {  i = ind[k];
         xassert(1 <= i && i <= csa.nn);
         sum += csa.wgt[i];
         ind[k] = csa.itov[i];
      }
skip: /* free working arrays */
      tfree(csa.ind);
      tfree(csa.vtoi);
      tfree(csa.itov);
      tfree(csa.wgt);
      /* return to calling routine */
      *sum_ = sum;
      return len;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/cfg2.c0000644000175100001710000000465600000000000024421 0ustar00runnerdocker00000000000000/* cfg2.c (conflict graph) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "cfg.h"
#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_cfg_init - create and initialize conflict graph
*
*  SYNOPSIS
*
*  glp_cfg *glp_cfg_init(glp_prob *P);
*
*  DESCRIPTION
*
*  This routine creates and initializes the conflict graph for the
*  specified problem object.
*
*  RETURNS
*
*  The routine returns a pointer to the conflict graph descriptor.
*  However, if the conflict graph is empty (no conflicts have been
*  found), the routine returns NULL. */

glp_cfg *glp_cfg_init(glp_prob *P)
{     glp_cfg *G;
      int j, n1, n2;
      xprintf("Constructing conflict graph...\n");
      G = cfg_build_graph(P);
      n1 = n2 = 0;
      for (j = 1; j <= P->n; j++)
      {  if (G->pos[j])
            n1 ++;
         if (G->neg[j])
            n2++;
      }
      if (n1 == 0 && n2 == 0)
      {  xprintf("No conflicts found\n");
         cfg_delete_graph(G);
         G = NULL;
      }
      else
         xprintf("Conflict graph has %d + %d = %d vertices\n",
            n1, n2, G->nv);
      return G;
}

/***********************************************************************
*  NAME
*
*  glp_cfg_free - delete conflict graph descriptor
*
*  SYNOPSIS
*
*  void glp_cfg_free(glp_cfg *G);
*
*  DESCRIPTION
*
*  This routine deletes the conflict graph descriptor and frees all the
*  memory allocated to it. */

void glp_cfg_free(glp_cfg *G)
{     xassert(G != NULL);
      cfg_delete_graph(G);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/clqcut.c0000644000175100001710000001020400000000000025055 0ustar00runnerdocker00000000000000/* clqcut.c (clique cut generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "cfg.h"
#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_clq_cut - generate clique cut from conflict graph
*
*  SYNOPSIS
*
*  int glp_clq_cut(glp_prob *P, glp_cfg *G, int ind[], double val[]);
*
*  DESCRIPTION
*
*  This routine attempts to generate a clique cut.
*
*  The cut generated by the routine is the following inequality:
*
*     sum a[j] * x[j] <= b,
*
*  which is expected to be violated at the current basic solution.
*
*  If the cut has been successfully generated, the routine stores its
*  non-zero coefficients a[j] and corresponding column indices j in the
*  array locations val[1], ..., val[len] and ind[1], ..., ind[len],
*  where 1 <= len <= n is the number of non-zero coefficients. The
*  right-hand side value b is stored in val[0], and ind[0] is set to 0.
*
*  RETURNS
*
*  If the cut has been successfully generated, the routine returns
*  len, the number of non-zero coefficients in the cut, 1 <= len <= n.
*  Otherwise, the routine returns a non-positive value. */

int glp_clq_cut(glp_prob *P, glp_cfg *G, int ind[], double val[])
{     int n = P->n;
      int *pos = G->pos;
      int *neg = G->neg;
      int nv = G->nv;
      int *ref = G->ref;
      int j, k, v, len;
      double rhs, sum;
      xassert(G->n == n);
      /* find maximum weight clique in conflict graph */
      len = cfg_find_clique(P, G, ind, &sum);
#ifdef GLP_DEBUG
      xprintf("len = %d; sum = %g\n", len, sum);
      cfg_check_clique(G, len, ind);
#endif
      /* check if clique inequality is violated */
      if (sum < 1.07)
         return 0;
      /* expand clique to maximal one */
      len = cfg_expand_clique(G, len, ind);
#ifdef GLP_DEBUG
      xprintf("maximal clique size = %d\n", len);
      cfg_check_clique(G, len, ind);
#endif
      /* construct clique cut (fixed binary variables are removed, so
         this cut is only locally valid) */
      rhs = 1.0;
      for (j = 1; j <= n; j++)
         val[j] = 0.0;
      for (k = 1; k <= len; k++)
      {  /* v is clique vertex */
         v = ind[k];
         xassert(1 <= v && v <= nv);
         /* j is number of corresponding binary variable */
         j = ref[v];
         xassert(1 <= j && j <= n);
         if (pos[j] == v)
         {  /* v corresponds to x[j] */
            if (P->col[j]->type == GLP_FX)
            {  /* x[j] is fixed */
               rhs -= P->col[j]->prim;
            }
            else
            {  /* x[j] is not fixed */
               val[j] += 1.0;
            }
         }
         else if (neg[j] == v)
         {  /* v corresponds to (1 - x[j]) */
            if (P->col[j]->type == GLP_FX)
            {  /* x[j] is fixed */
               rhs -= (1.0 - P->col[j]->prim);
            }
            else
            {  /* x[j] is not fixed */
               val[j] -= 1.0;
               rhs -= 1.0;
            }
         }
         else
            xassert(v != v);
      }
      /* convert cut inequality to sparse format */
      len = 0;
      for (j = 1; j <= n; j++)
      {  if (val[j] != 0.0)
         {  len++;
            ind[len] = j;
            val[len] = val[j];
         }
      }
      ind[0] = 0, val[0] = rhs;
      return len;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/covgen.c0000644000175100001710000007231600000000000025057 0ustar00runnerdocker00000000000000/* covgen.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "fvs.h"
#include "ks.h"
#include "prob.h"

struct glp_cov
{     /* cover cut generator working area */
      int n;
      /* number of columns (variables) */
      glp_prob *set;
      /* set of globally valid 0-1 knapsack inequalities chosen from
       * the root problem; each inequality is either original row or
       * its relaxation (surrogate 0-1 knapsack) which is constructed
       * by substitution of lower/upper single/variable bounds for
       * continuous and general integer (non-binary) variables */
};

struct bnd
{     /* simple or variable bound */
      /* if z = 0, it is a simple bound x >= or <= b; if b = -DBL_MAX
       * (b = +DBL_MAX), x has no lower (upper) bound; otherwise, if
       * z != 0, it is a variable bound x >= or <= a * z + b */
      int z;
      /* number of binary variable or 0 */
      double a, b;
      /* bound parameters */
};

struct csa
{     /* common storage area */
      glp_prob *P;
      /* original (root) MIP */
      struct bnd *l; /* struct bnd l[1+P->n]; */
      /* lower simple/variable bounds of variables */
      struct bnd *u; /* struct bnd u[1+P->n]; */
      /* upper simple/variable bounds of variables */
      glp_prob *set;
      /* see struct glp_cov above */
};

/***********************************************************************
*  init_bounds - initialize bounds of variables with simple bounds
*
*  This routine initializes lower and upper bounds of all variables
*  with simple bounds specified in the original mip. */

static void init_bounds(struct csa *csa)
{     glp_prob *P = csa->P;
      struct bnd *l = csa->l, *u = csa->u;
      int j;
      for (j = 1; j <= P->n; j++)
      {  l[j].z = u[j].z = 0;
         l[j].a = u[j].a = 0;
         l[j].b = glp_get_col_lb(P, j);
         u[j].b = glp_get_col_ub(P, j);
      }
      return;
}

/***********************************************************************
*  check_vb - check variable bound
*
*  This routine checks if the specified i-th row has the form
*
*     a1 * x + a2 * z >= or <= rhs,                                  (1)
*
*  where x is a non-fixed continuous or general integer variable, and
*  z is a binary variable. If it is, the routine converts the row to
*  the following variable lower/upper bound (VLB/VUB) of x:
*
*     x >= or <= a * z + b,                                          (2)
*
*  where a = - a2 / a1, b = rhs / a1. Note that the inequality type is
*  changed to opposite one when a1 < 0.
*
*  If the row is identified as a variable bound, the routine returns
*  GLP_LO for VLB or GLP_UP for VUB and provides the reference numbers
*  of variables x and z and values of a and b. Otherwise, the routine
*  returns zero. */

static int check_vb(struct csa *csa, int i, int *x, int *z, double *a,
      double *b)
{     glp_prob *P = csa->P;
      GLPROW *row;
      GLPAIJ *a1, *a2;
      int type;
      double rhs;
      xassert(1 <= i && i <= P->m);
      row = P->row[i];
      /* check row type */
      switch (row->type)
      {  case GLP_LO:
         case GLP_UP:
            break;
         default:
            return 0;
      }
      /* take first term of the row */
      a1 = row->ptr;
      if (a1 == NULL)
         return 0;
      /* take second term of the row */
      a2 = a1->r_next;
      if (a2 == NULL)
         return 0;
      /* there should be exactly two terms in the row */
      if (a2->r_next != NULL)
         return 0;
      /* if first term is a binary variable, swap the terms */
      if (glp_get_col_kind(P, a1->col->j) == GLP_BV)
      {  GLPAIJ *a;
         a = a1, a1 = a2, a2 = a;
      }
      /* now first term should be a non-fixed continuous or general
       * integer variable */
      if (a1->col->type == GLP_FX)
         return 0;
      if (glp_get_col_kind(P, a1->col->j) == GLP_BV)
         return 0;
      /* and second term should be a binary variable */
      if (glp_get_col_kind(P, a2->col->j) != GLP_BV)
         return 0;
      /* VLB/VUB row has been identified */
      switch (row->type)
      {  case GLP_LO:
            type = a1->val > 0 ? GLP_LO : GLP_UP;
            rhs = row->lb;
            break;
         case GLP_UP:
            type = a1->val > 0 ? GLP_UP : GLP_LO;
            rhs = row->ub;
            break;
         default:
            xassert(type != type);
      }
      *x = a1->col->j;
      *z = a2->col->j;
      *a = - a2->val / a1->val;
      *b = rhs / a1->val;
      return type;
}

/***********************************************************************
*  set_vb - set variable bound
*
*  This routine sets lower or upper variable bound specified as
*
*     x >= a * z + b    (type = GLP_LO)
*
*     x <= a * z + b    (type = GLP_UP) */

static void set_vb(struct csa *csa, int type, int x, int z, double a,
      double b)
{     glp_prob *P = csa->P;
      struct bnd *l = csa->l, *u = csa->u;
      xassert(glp_get_col_type(P, x) != GLP_FX);
      xassert(glp_get_col_kind(P, x) != GLP_BV);
      xassert(glp_get_col_kind(P, z) == GLP_BV);
      xassert(a != 0);
      switch (type)
      {  case GLP_LO:
            /* FIXME: check existing simple lower bound? */
            l[x].z = z, l[x].a = a, l[x].b = b;
            break;
         case GLP_UP:
            /* FIXME: check existing simple upper bound? */
            u[x].z = z, u[x].a = a, u[x].b = b;
            break;
         default:
            xassert(type != type);
      }
      return;
}

/***********************************************************************
*  obtain_vbs - obtain and set variable bounds
*
*  This routine walks thru all rows of the original mip, identifies
*  rows specifying variable lower/upper bounds, and sets these bounds
*  for corresponding (non-binary) variables. */

static void obtain_vbs(struct csa *csa)
{     glp_prob *P = csa->P;
      int i, x, z, type, save;
      double a, b;
      for (i = 1; i <= P->m; i++)
      {  switch (P->row[i]->type)
         {  case GLP_FR:
               break;
            case GLP_LO:
            case GLP_UP:
               type = check_vb(csa, i, &x, &z, &a, &b);
               if (type)
                  set_vb(csa, type, x, z, a, b);
               break;
            case GLP_DB:
            case GLP_FX:
               /* double-side inequality l <= ... <= u and equality
                * ... = l = u are considered as two single inequalities
                * ... >= l and ... <= u */
               save = P->row[i]->type;
               P->row[i]->type = GLP_LO;
               type = check_vb(csa, i, &x, &z, &a, &b);
               if (type)
                  set_vb(csa, type, x, z, a, b);
               P->row[i]->type = GLP_UP;
               type = check_vb(csa, i, &x, &z, &a, &b);
               if (type)
                  set_vb(csa, type, x, z, a, b);
               P->row[i]->type = save;
               break;
            default:
               xassert(P != P);
         }
      }
      return;
}

/***********************************************************************
*  add_term - add term to sparse vector
*
*  This routine computes the following linear combination:
*
*     v := v + a * e[j],
*
*  where v is a sparse vector in full storage format, a is a non-zero
*  scalar, e[j] is j-th column of unity matrix. */

static void add_term(FVS *v, int j, double a)
{     xassert(1 <= j && j <= v->n);
      xassert(a != 0);
      if (v->vec[j] == 0)
      {  /* create j-th component */
         v->nnz++;
         xassert(v->nnz <= v->n);
         v->ind[v->nnz] = j;
      }
      /* perform addition */
      v->vec[j] += a;
      if (fabs(v->vec[j]) < 1e-9 * (1 + fabs(a)))
      {  /* remove j-th component */
         v->vec[j] = DBL_MIN;
      }
      return;
}

/***********************************************************************
*  build_ks - build "0-1 knapsack" inequality
*
*  Given an inequality of "not greater" type:
*
*     sum{j in 1..n} a[j]*x[j] <= b,                                 (1)
*
*  this routine attempts to transform it to equivalent or relaxed "0-1
*  knapsack" inequality that contains only binary variables.
*
*  If x[j] is a binary variable, the term a[j]*x[j] is not changed.
*  Otherwise, if x[j] is a continuous or integer non-binary variable,
*  it is replaced by its lower (if a[j] > 0) or upper (if a[j] < 0)
*  single or variable bound. In the latter case, if x[j] is a non-fixed
*  variable, this results in a relaxation of original inequality known
*  as "surrogate knapsack". Thus, if the specified inequality is valid
*  for the original mip, the resulting inequality is also valid.
*
*  Note that in both source and resulting inequalities coefficients
*  a[j] can have any sign.
*
*  On entry to the routine the source inequality is specified by the
*  parameters n, ind (contains original numbers of x[j]), a, and b. The
*  parameter v is a working sparse vector whose components are assumed
*  to be zero.
*
*  On exit the routine stores the resulting "0-1 knapsack" inequality
*  in the parameters ind, a, and b, and returns n which is the number
*  of terms in the resulting inequality. Zero content of the vector v
*  is restored before exit.
*
*  If the resulting inequality cannot be constructed due to missing
*  lower/upper bounds of some variable, the routine returns a negative
*  value. */

static int build_ks(struct csa *csa, int n, int ind[], double a[],
      double *b, FVS *v)
{     glp_prob *P = csa->P;
      struct bnd *l = csa->l, *u = csa->u;
      int j, k;
      /* check that v = 0 */
#ifdef GLP_DEBUG
      fvs_check_vec(v);
#endif
      xassert(v->nnz == 0);
      /* walk thru terms of original inequality */
      for (j = 1; j <= n; j++)
      {  /* process term a[j]*x[j] */
         k = ind[j]; /* original number of x[j] in mip */
         if (glp_get_col_kind(P, k) == GLP_BV)
         {  /* x[j] is a binary variable */
            /* include its term into resulting inequality */
            add_term(v, k, a[j]);
         }
         else if (a[j] > 0)
         {  /* substitute x[j] by its lower bound */
            if (l[k].b == -DBL_MAX)
            {  /* x[j] has no lower bound */
               n = -1;
               goto skip;
            }
            else if (l[k].z == 0)
            {  /* x[j] has simple lower bound */
               *b -= a[j] * l[k].b;
            }
            else
            {  /* x[j] has variable lower bound (a * z + b) */
               add_term(v, l[k].z, a[j] * l[k].a);
               *b -= a[j] * l[k].b;
            }
         }
         else /* a[j] < 0 */
         {  /* substitute x[j] by its upper bound */
            if (u[k].b == +DBL_MAX)
            {  /* x[j] has no upper bound */
               n = -1;
               goto skip;
            }
            else if (u[k].z == 0)
            {  /* x[j] has simple upper bound */
               *b -= a[j] * u[k].b;
            }
            else
            {  /* x[j] has variable upper bound (a * z + b) */
               add_term(v, u[k].z, a[j] * u[k].a);
               *b -= a[j] * u[k].b;
            }
         }
      }
      /* replace tiny coefficients by exact zeros (see add_term) */
      fvs_adjust_vec(v, 2 * DBL_MIN);
      /* copy terms of resulting inequality */
      xassert(v->nnz <= n);
      n = v->nnz;
      for (j = 1; j <= n; j++)
      {  ind[j] = v->ind[j];
         a[j] = v->vec[ind[j]];
      }
skip: /* restore zero content of v */
      fvs_clear_vec(v);
      return n;
}

/***********************************************************************
*  can_be_active - check if inequality can be active
*
*  This routine checks if the specified "0-1 knapsack" inequality
*
*     sum{j in 1..n} a[j]*x[j] <= b
*
*  can be active. If so, the routine returns true, otherwise false. */

static int can_be_active(int n, const double a[], double b)
{     int j;
      double s;
      s = 0;
      for (j = 1; j <= n; j++)
      {  if (a[j] > 0)
            s += a[j];
      }
      return s > b + .001 * (1 + fabs(b));
}

/***********************************************************************
*  is_sos_ineq - check if inequality is packing (SOS) constraint
*
*  This routine checks if the specified "0-1 knapsack" inequality
*
*     sum{j in 1..n} a[j]*x[j] <= b                                  (1)
*
*  is equivalent to packing inequality (Padberg calls such inequalities
*  special ordered set or SOS constraints)
*
*     sum{j in J'} x[j] - sum{j in J"} x[j] <= 1 - |J"|.             (2)
*
*  If so, the routine returns true, otherwise false.
*
*  Note that if X is a set of feasible binary points satisfying to (2),
*  its convex hull conv(X) equals to the set of feasible points of LP
*  relaxation of (2), which is a n-dimensional simplex, so inequalities
*  (2) are useless for generating cover cuts (due to unimodularity).
*
*  ALGORITHM
*
*  First, we make all a[j] positive by complementing x[j] = 1 - x'[j]
*  in (1). This is performed implicitly (i.e. actually the array a is
*  not changed), but b is replaced by b - sum{j : a[j] < 0}.
*
*  Then we find two smallest coefficients a[p] = min{j in 1..n} a[j]
*  and a[q] = min{j in 1..n : j != p} a[j]. It is obvious that if
*  a[p] + a[q] > b, then a[i] + a[j] > b for all i != j, from which it
*  follows that x[i] + x[j] <= 1 for all i != j. But the latter means
*  that the original inequality (with all a[j] > 0) is equivalent to
*  packing inequality
*
*     sum{j in 1..n} x[j] <= 1.                                      (3)
*
*  Returning to original (uncomplemented) variables x'[j] = 1 - x[j]
*  we have that the original inequality is equivalent to (2), where
*  J' = {j : a[j] > 0} and J" = {j : a[j] < 0}. */

static int is_sos_ineq(int n, const double a[], double b)
{     int j, p, q;
      xassert(n >= 2);
      /* compute b := b - sum{j : a[j] < 0} */
      for (j = 1; j <= n; j++)
      {  if (a[j] < 0)
            b -= a[j];
      }
      /* find a[p] = min{j in 1..n} a[j] */
      p = 1;
      for (j = 2; j <= n; j++)
      {  if (fabs(a[p]) > fabs(a[j]))
            p = j;
      }
      /* find a[q] = min{j in 1..n : j != p} a[j] */
      q = 0;
      for (j = 1; j <= n; j++)
      {  if (j != p)
         {  if (q == 0 || fabs(a[q]) > fabs(a[j]))
               q = j;
         }
      }
      xassert(q != 0);
      /* check condition a[p] + a[q] > b */
      return fabs(a[p]) + fabs(a[q]) > b + .001 * (1 + fabs(b));
}

/***********************************************************************
*  process_ineq - basic inequality processing
*
*  This routine performs basic processing of an inequality of "not
*  greater" type
*
*     sum{j in 1..n} a[j]*x[j] <= b
*
*  specified by the parameters, n, ind, a, and b.
*
*  If the inequality can be transformed to "0-1 knapsack" ineqiality
*  suitable for generating cover cuts, the routine adds it to the set
*  of "0-1 knapsack" inequalities.
*
*  Note that the arrays ind and a are not saved on exit. */

static void process_ineq(struct csa *csa, int n, int ind[], double a[],
      double b, FVS *v)
{     int i;
      /* attempt to transform the specified inequality to equivalent or
       * relaxed "0-1 knapsack" inequality */
      n = build_ks(csa, n, ind, a, &b, v);
      if (n <= 1)
      {  /* uninteresting inequality (in principle, such inequalities
          * should be removed by the preprocessor) */
         goto done;
      }
      if (!can_be_active(n, a, b))
      {  /* inequality is redundant (i.e. cannot be active) */
         goto done;
      }
      if (is_sos_ineq(n, a, b))
      {  /* packing (SOS) inequality is useless for generating cover
          * cuts; currently such inequalities are just ignored */
         goto done;
      }
      /* add resulting "0-1 knapsack" inequality to the set */
      i = glp_add_rows(csa->set, 1);
      glp_set_mat_row(csa->set, i, n, ind, a);
      glp_set_row_bnds(csa->set, i, GLP_UP, b, b);
done: return;
}

/**********************************************************************/

glp_cov *glp_cov_init(glp_prob *P)
{     /* create and initialize cover cut generator */
      glp_cov *cov;
      struct csa csa;
      int i, k, len, *ind;
      double rhs, *val;
      FVS fvs;
      csa.P = P;
      csa.l = talloc(1+P->n, struct bnd);
      csa.u = talloc(1+P->n, struct bnd);
      csa.set = glp_create_prob();
      glp_add_cols(csa.set, P->n);
      /* initialize bounds of variables with simple bounds */
      init_bounds(&csa);
      /* obtain and set variable bounds */
      obtain_vbs(&csa);
      /* allocate working arrays */
      ind = talloc(1+P->n, int);
      val = talloc(1+P->n, double);
      fvs_alloc_vec(&fvs, P->n);
      /* process all rows of the root mip */
      for (i = 1; i <= P->m; i++)
      {  switch (P->row[i]->type)
         {  case GLP_FR:
               break;
            case GLP_LO:
               /* obtain row of ">=" type */
               len = glp_get_mat_row(P, i, ind, val);
               rhs = P->row[i]->lb;
               /* transforms it to row of "<=" type */
               for (k = 1; k <= len; k++)
                  val[k] = - val[k];
               rhs = - rhs;
               /* process the row */
               process_ineq(&csa, len, ind, val, rhs, &fvs);
               break;
            case GLP_UP:
               /* obtain row of "<=" type */
               len = glp_get_mat_row(P, i, ind, val);
               rhs = P->row[i]->ub;
               /* and process it */
               process_ineq(&csa, len, ind, val, rhs, &fvs);
               break;
            case GLP_DB:
            case GLP_FX:
               /* double-sided inequalitiy and equality constraints are
                * processed as two separate inequalities */
               /* obtain row as if it were of ">=" type */
               len = glp_get_mat_row(P, i, ind, val);
               rhs = P->row[i]->lb;
               /* transforms it to row of "<=" type */
               for (k = 1; k <= len; k++)
                  val[k] = - val[k];
               rhs = - rhs;
               /* and process it */
               process_ineq(&csa, len, ind, val, rhs, &fvs);
               /* obtain the same row as if it were of "<=" type */
               len = glp_get_mat_row(P, i, ind, val);
               rhs = P->row[i]->ub;
               /* and process it */
               process_ineq(&csa, len, ind, val, rhs, &fvs);
               break;
            default:
               xassert(P != P);
         }
      }
      /* free working arrays */
      tfree(ind);
      tfree(val);
      fvs_check_vec(&fvs);
      fvs_free_vec(&fvs);
      /* the set of "0-1 knapsack" inequalities has been built */
      if (csa.set->m == 0)
      {  /* the set is empty */
         xprintf("No 0-1 knapsack inequalities detected\n");
         cov = NULL;
         glp_delete_prob(csa.set);
      }
      else
      {  /* create the cover cut generator working area */
         xprintf("Number of 0-1 knapsack inequalities = %d\n",
            csa.set->m);
         cov = talloc(1, glp_cov);
         cov->n = P->n;
         cov->set = csa.set;
#if 0
         glp_write_lp(cov->set, 0, "set.lp");
#endif
      }
      tfree(csa.l);
      tfree(csa.u);
      return cov;
}

/***********************************************************************
*  solve_ks - solve 0-1 knapsack problem
*
*  This routine finds (sub)optimal solution to 0-1 knapsack problem:
*
*     maximize z = sum{j in 1..n} c[j]x[j]                           (1)
*
*         s.t. sum{j in 1..n} a[j]x[j] <= b                          (2)
*
*              x[j] in {0, 1} for all j in 1..n                      (3)
*
*  It is assumed that the instance is non-normalized, i.e. parameters
*  a, b, and c may have any sign.
*
*  On exit the routine stores the (sub)optimal point found in locations
*  x[1], ..., x[n] and returns the optimal objective value. However, if
*  the instance is infeasible, the routine returns INT_MIN. */

static int solve_ks(int n, const int a[], int b, const int c[],
      char x[])
{     int z;
      /* surprisingly, even for some small instances (n = 50-100)
       * MT1 routine takes too much time, so it is used only for tiny
       * instances */
      if (n <= 16)
#if 0
         z = ks_enum(n, a, b, c, x);
#else
         z = ks_mt1(n, a, b, c, x);
#endif
      else
         z = ks_greedy(n, a, b, c, x);
      return z;
}

/***********************************************************************
*  simple_cover - find simple cover cut
*
*  Given a 0-1 knapsack inequality (which may be globally as well as
*  locally valid)
*
*     sum{j in 1..n} a[j]x[j] <= b,                                  (1)
*
*  where all x[j] are binary variables and all a[j] are positive, and
*  a fractional point x~{j in 1..n}, which is feasible to LP relaxation
*  of (1), this routine attempts to find a simple cover inequality
*
*     sum{j in C} (1 - x[j]) >= 1,                                   (2)
*
*  which is valid for (1) and violated at x~.
*
*  Actually, the routine finds a cover C, i.e. a subset of {1, ..., n}
*  such that
*
*     sum{j in C} a[j] > b,                                          (3)
*
*  and which minimizes the left-hand side of (2) at x~
*
*     zeta = sum{j in C} (1 - x~[j]).                                (4)
*
*  On exit the routine stores the characteritic vector z{j in 1..n}
*  of the cover found (i.e. z[j] = 1 means j in C, and z[j] = 0 means
*  j not in C), and returns corresponding minimal value of zeta (4).
*  However, if no cover is found, the routine returns DBL_MAX.
*
*  ALGORITHM
*
*  The separation problem (3)-(4) is converted to 0-1 knapsack problem
*  as follows.
*
*  First, note that the constraint (3) is equivalent to
*
*     sum{j in 1..n} a[j]z[j] >= b + eps,                            (5)
*
*  where eps > 0 is a sufficiently small number (in case of integral
*  a and b we may take eps = 1). Multiplying both sides of (5) by (-1)
*  gives
*
*     sum{j in 1..n} (-a[j])z[j] <= - b - eps.                       (6)
*
*  To make all coefficients in (6) positive, z[j] is complemented by
*  substitution z[j] = 1 - z'[j] that finally gives
*
*     sum{j in 1..n} a[j]z'[j] <= sum{j in 1..n} a[j] - b - eps.     (7)
*
*  Minimization of zeta (4) is equivalent to maximization of
*
*     -zeta = sum{j in 1..n} (x~[j] - 1)z[j].                        (8)
*
*  Substitution z[j] = 1 - z'[j] gives
*
*     -zeta = sum{j in 1..n} (1 - x~[j])z'[j] - zeta0,               (9)
*
*  where zeta0 = sum{j in 1..n} (1 - x~[j]) is a constant term.
*
*  Thus, the 0-1 knapsack problem to be solved is the following:
*
*     maximize
*
*        -zeta = sum{j in 1..n} (1 - x~[j])z'[j] - zeta0            (10)
*
*     subject to
*
*        sum{j in 1..n} a[j]z'[j] <= sum{j in 1..n} a[j] - b - eps  (11)
*
*        z'[j] in {0,1} for all j = 1,...,n                         (12)
*
*  (The constant term zeta0 doesn't affect the solution, so it can be
*  dropped.) */

static double simple_cover(int n, const double a[], double b, const
      double x[], char z[])
{     int j, *aa, bb, *cc;
      double max_aj, min_aj, s, eps;
      xassert(n >= 3);
      /* allocate working arrays */
      aa = talloc(1+n, int);
      cc = talloc(1+n, int);
      /* compute max{j in 1..n} a[j] and min{j in 1..n} a[j] */
      max_aj = 0, min_aj = DBL_MAX;
      for (j = 1; j <= n; j++)
      {  xassert(a[j] > 0);
         if (max_aj < a[j])
            max_aj = a[j];
         if (min_aj > a[j])
            min_aj = a[j];
      }
      /* scale and round constraint parameters to make them integral;
       * note that we make the resulting inequality stronger than (11),
       * so a[j]'s are rounded up while rhs is rounded down */
      s = 0;
      for (j = 1; j <= n; j++)
      {  s += a[j];
         aa[j] = ceil(a[j] / max_aj * 1000);
      }
      bb = floor((s - b) / max_aj * 1000) - 1;
      /* scale and round obj. coefficients to make them integral;
       * again we make the objective function stronger than (10), so
       * the coefficients are rounded down */
      for (j = 1; j <= n; j++)
      {  xassert(0 <= x[j] && x[j] <= 1);
         cc[j] = floor((1 - x[j]) * 1000);
      }
      /* solve separation problem */
      if (solve_ks(n, aa, bb, cc, z) == INT_MIN)
      {  /* no cover exists */
         s = DBL_MAX;
         goto skip;
      }
      /* determine z[j] = 1 - z'[j] */
      for (j = 1; j <= n; j++)
      {  xassert(z[j] == 0 || z[j] == 1);
         z[j] ^= 1;
      }
      /* check condition (11) for original (non-scaled) parameters */
      s = 0;
      for (j = 1; j <= n; j++)
      {  if (z[j])
            s += a[j];
      }
      eps = 0.01 * (min_aj >= 1 ? min_aj : 1);
      if (!(s >= b + eps))
      {  /* no cover found within a precision req'd */
         s = DBL_MAX;
         goto skip;
      }
      /* compute corresponding zeta (4) for cover found */
      s = 0;
      for (j = 1; j <= n; j++)
      {  if (z[j])
            s += 1 - x[j];
      }
skip: /* free working arrays */
      tfree(aa);
      tfree(cc);
      return s;
}

/**********************************************************************/

void glp_cov_gen1(glp_prob *P, glp_cov *cov, glp_prob *pool)
{     /* generate locally valid simple cover cuts */
      int i, k, len, new_len, *ind;
      double *val, rhs, *x, zeta;
      char *z;
      xassert(P->n == cov->n && P->n == cov->set->n);
      xassert(glp_get_status(P) == GLP_OPT);
      /* allocate working arrays */
      ind = talloc(1+P->n, int);
      val = talloc(1+P->n, double);
      x = talloc(1+P->n, double);
      z = talloc(1+P->n, char);
      /* walk thru 0-1 knapsack inequalities */
      for (i = 1; i <= cov->set->m; i++)
      {  /* retrieve 0-1 knapsack inequality */
         len = glp_get_mat_row(cov->set, i, ind, val);
         rhs = glp_get_row_ub(cov->set, i);
         xassert(rhs != +DBL_MAX);
         /* FIXME: skip, if slack is too large? */
         /* substitute and eliminate binary variables which have been
          * fixed in the current subproblem (this makes the inequality
          * only locally valid) */
         new_len = 0;
         for (k = 1; k <= len; k++)
         {  if (glp_get_col_type(P, ind[k]) == GLP_FX)
               rhs -= val[k] * glp_get_col_prim(P, ind[k]);
            else
            {  new_len++;
               ind[new_len] = ind[k];
               val[new_len] = val[k];
            }
         }
         len = new_len;
         /* we need at least 3 binary variables in the inequality */
         if (len <= 2)
            continue;
         /* obtain values of binary variables from optimal solution to
          * LP relaxation of current subproblem */
         for (k = 1; k <= len; k++)
         {  xassert(glp_get_col_kind(P, ind[k]) == GLP_BV);
            x[k] = glp_get_col_prim(P, ind[k]);
            if (x[k] < 0.00001)
               x[k] = 0;
            else if (x[k] > 0.99999)
               x[k] = 1;
            /* if val[k] < 0, perform substitution x[k] = 1 - x'[k] to
             * make all coefficients positive */
            if (val[k] < 0)
            {  ind[k] = - ind[k]; /* x[k] is complemented */
               val[k] = - val[k];
               rhs += val[k];
               x[k] = 1 - x[k];
            }
         }
         /* find locally valid simple cover cut */
         zeta = simple_cover(len, val, rhs, x, z);
         if (zeta > 0.95)
         {  /* no violation or insufficient violation; see (2) */
            continue;
         }
         /* construct cover inequality (2) for the cover found, which
          * for original binary variables x[k] is equivalent to:
          *    sum{k in C'} x[k] + sum{k in C"} x'[k] <= |C| - 1
          * or
          *    sum{k in C'} x[k] + sum{k in C"} (1 - x[k]) <= |C| - 1
          * or
          *    sum{k in C'} x[k] - sum{k in C"} x[k] <= |C'| - 1
          * since |C| - |C"| = |C'| */
         new_len = 0;
         rhs = -1;
         for (k = 1; k <= len; k++)
         {  if (z[k])
            {  new_len++;
               if (ind[k] > 0)
               {  ind[new_len] = +ind[k];
                  val[new_len] = +1;
                  rhs++;
               }
               else /* ind[k] < 0 */
               {  ind[new_len] = -ind[k];
                  val[new_len] = -1;
               }
            }
         }
         len = new_len;
         /* add the cover inequality to the local cut pool */
         k = glp_add_rows(pool, 1);
         glp_set_mat_row(pool, k, len, ind, val);
         glp_set_row_bnds(pool, k, GLP_UP, rhs, rhs);
      }
      /* free working arrays */
      tfree(ind);
      tfree(val);
      tfree(x);
      tfree(z);
      return;
}

/**********************************************************************/

void glp_cov_free(glp_cov *cov)
{     /* delete cover cut generator workspace */
      xassert(cov != NULL);
      glp_delete_prob(cov->set);
      tfree(cov);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/fpump.c0000644000175100001710000003005300000000000024715 0ustar00runnerdocker00000000000000/* fpump.c (feasibility pump heuristic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"
#include "rng.h"

/***********************************************************************
*  NAME
*
*  ios_feas_pump - feasibility pump heuristic
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void ios_feas_pump(glp_tree *T);
*
*  DESCRIPTION
*
*  The routine ios_feas_pump is a simple implementation of the Feasi-
*  bility Pump heuristic.
*
*  REFERENCES
*
*  M.Fischetti, F.Glover, and A.Lodi. "The feasibility pump." Math.
*  Program., Ser. A 104, pp. 91-104 (2005). */

struct VAR
{     /* binary variable */
      int j;
      /* ordinal number */
      int x;
      /* value in the rounded solution (0 or 1) */
      double d;
      /* sorting key */
};

static int CDECL fcmp(const void *x, const void *y)
{     /* comparison routine */
      const struct VAR *vx = x, *vy = y;
      if (vx->d > vy->d)
         return -1;
      else if (vx->d < vy->d)
         return +1;
      else
         return 0;
}

void ios_feas_pump(glp_tree *T)
{     glp_prob *P = T->mip;
      int n = P->n;
      glp_prob *lp = NULL;
      struct VAR *var = NULL;
      RNG *rand = NULL;
      GLPCOL *col;
      glp_smcp parm;
      int j, k, new_x, nfail, npass, nv, ret, stalling;
      double dist, tol;
      xassert(glp_get_status(P) == GLP_OPT);
      /* this heuristic is applied only once on the root level */
      if (!(T->curr->level == 0 && T->curr->solved == 1)) goto done;
      /* determine number of binary variables */
      nv = 0;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         /* if x[j] is continuous, skip it */
         if (col->kind == GLP_CV) continue;
         /* if x[j] is fixed, skip it */
         if (col->type == GLP_FX) continue;
         /* x[j] is non-fixed integer */
         xassert(col->kind == GLP_IV);
         if (col->type == GLP_DB && col->lb == 0.0 && col->ub == 1.0)
         {  /* x[j] is binary */
            nv++;
         }
         else
         {  /* x[j] is general integer */
            if (T->parm->msg_lev >= GLP_MSG_ALL)
               xprintf("FPUMP heuristic cannot be applied due to genera"
                  "l integer variables\n");
            goto done;
         }
      }
      /* there must be at least one binary variable */
      if (nv == 0) goto done;
      if (T->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Applying FPUMP heuristic...\n");
      /* build the list of binary variables */
      var = xcalloc(1+nv, sizeof(struct VAR));
      k = 0;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         if (col->kind == GLP_IV && col->type == GLP_DB)
            var[++k].j = j;
      }
      xassert(k == nv);
      /* create working problem object */
      lp = glp_create_prob();
more: /* copy the original problem object to keep it intact */
      glp_copy_prob(lp, P, GLP_OFF);
      /* we are interested to find an integer feasible solution, which
         is better than the best known one */
      if (P->mip_stat == GLP_FEAS)
      {  int *ind;
         double *val, bnd;
         /* add a row and make it identical to the objective row */
         glp_add_rows(lp, 1);
         ind = xcalloc(1+n, sizeof(int));
         val = xcalloc(1+n, sizeof(double));
         for (j = 1; j <= n; j++)
         {  ind[j] = j;
            val[j] = P->col[j]->coef;
         }
         glp_set_mat_row(lp, lp->m, n, ind, val);
         xfree(ind);
         xfree(val);
         /* introduce upper (minimization) or lower (maximization)
            bound to the original objective function; note that this
            additional constraint is not violated at the optimal point
            to LP relaxation */
#if 0 /* modified by xypron  */
         if (P->dir == GLP_MIN)
         {  bnd = P->mip_obj - 0.10 * (1.0 + fabs(P->mip_obj));
            if (bnd < P->obj_val) bnd = P->obj_val;
            glp_set_row_bnds(lp, lp->m, GLP_UP, 0.0, bnd - P->c0);
         }
         else if (P->dir == GLP_MAX)
         {  bnd = P->mip_obj + 0.10 * (1.0 + fabs(P->mip_obj));
            if (bnd > P->obj_val) bnd = P->obj_val;
            glp_set_row_bnds(lp, lp->m, GLP_LO, bnd - P->c0, 0.0);
         }
         else
            xassert(P != P);
#else
         bnd = 0.1 * P->obj_val + 0.9 * P->mip_obj;
         /* xprintf("bnd = %f\n", bnd); */
         if (P->dir == GLP_MIN)
            glp_set_row_bnds(lp, lp->m, GLP_UP, 0.0, bnd - P->c0);
         else if (P->dir == GLP_MAX)
            glp_set_row_bnds(lp, lp->m, GLP_LO, bnd - P->c0, 0.0);
         else
            xassert(P != P);
#endif
      }
      /* reset pass count */
      npass = 0;
      /* invalidate the rounded point */
      for (k = 1; k <= nv; k++)
         var[k].x = -1;
pass: /* next pass starts here */
      npass++;
      if (T->parm->msg_lev >= GLP_MSG_ALL)
         xprintf("Pass %d\n", npass);
      /* initialize minimal distance between the basic point and the
         rounded one obtained during this pass */
      dist = DBL_MAX;
      /* reset failure count (the number of succeeded iterations failed
         to improve the distance) */
      nfail = 0;
      /* if it is not the first pass, perturb the last rounded point
         rather than construct it from the basic solution */
      if (npass > 1)
      {  double rho, temp;
         if (rand == NULL)
            rand = rng_create_rand();
         for (k = 1; k <= nv; k++)
         {  j = var[k].j;
            col = lp->col[j];
            rho = rng_uniform(rand, -0.3, 0.7);
            if (rho < 0.0) rho = 0.0;
            temp = fabs((double)var[k].x - col->prim);
            if (temp + rho > 0.5) var[k].x = 1 - var[k].x;
         }
         goto skip;
      }
loop: /* innermost loop begins here */
      /* round basic solution (which is assumed primal feasible) */
      stalling = 1;
      for (k = 1; k <= nv; k++)
      {  col = lp->col[var[k].j];
         if (col->prim < 0.5)
         {  /* rounded value is 0 */
            new_x = 0;
         }
         else
         {  /* rounded value is 1 */
            new_x = 1;
         }
         if (var[k].x != new_x)
         {  stalling = 0;
            var[k].x = new_x;
         }
      }
      /* if the rounded point has not changed (stalling), choose and
         flip some its entries heuristically */
      if (stalling)
      {  /* compute d[j] = |x[j] - round(x[j])| */
         for (k = 1; k <= nv; k++)
         {  col = lp->col[var[k].j];
            var[k].d = fabs(col->prim - (double)var[k].x);
         }
         /* sort the list of binary variables by descending d[j] */
         qsort(&var[1], nv, sizeof(struct VAR), fcmp);
         /* choose and flip some rounded components */
         for (k = 1; k <= nv; k++)
         {  if (k >= 5 && var[k].d < 0.35 || k >= 10) break;
            var[k].x = 1 - var[k].x;
         }
      }
skip: /* check if the time limit has been exhausted */
      if (T->parm->tm_lim < INT_MAX &&
         (double)(T->parm->tm_lim - 1) <=
         1000.0 * xdifftime(xtime(), T->tm_beg)) goto done;
      /* build the objective, which is the distance between the current
         (basic) point and the rounded one */
      lp->dir = GLP_MIN;
      lp->c0 = 0.0;
      for (j = 1; j <= n; j++)
         lp->col[j]->coef = 0.0;
      for (k = 1; k <= nv; k++)
      {  j = var[k].j;
         if (var[k].x == 0)
            lp->col[j]->coef = +1.0;
         else
         {  lp->col[j]->coef = -1.0;
            lp->c0 += 1.0;
         }
      }
      /* minimize the distance with the simplex method */
      glp_init_smcp(&parm);
      if (T->parm->msg_lev <= GLP_MSG_ERR)
         parm.msg_lev = T->parm->msg_lev;
      else if (T->parm->msg_lev <= GLP_MSG_ALL)
      {  parm.msg_lev = GLP_MSG_ON;
         parm.out_dly = 10000;
      }
      ret = glp_simplex(lp, &parm);
      if (ret != 0)
      {  if (T->parm->msg_lev >= GLP_MSG_ERR)
            xprintf("Warning: glp_simplex returned %d\n", ret);
         goto done;
      }
      ret = glp_get_status(lp);
      if (ret != GLP_OPT)
      {  if (T->parm->msg_lev >= GLP_MSG_ERR)
            xprintf("Warning: glp_get_status returned %d\n", ret);
         goto done;
      }
      if (T->parm->msg_lev >= GLP_MSG_DBG)
         xprintf("delta = %g\n", lp->obj_val);
      /* check if the basic solution is integer feasible; note that it
         may be so even if the minimial distance is positive */
      tol = 0.3 * T->parm->tol_int;
      for (k = 1; k <= nv; k++)
      {  col = lp->col[var[k].j];
         if (tol < col->prim && col->prim < 1.0 - tol) break;
      }
      if (k > nv)
      {  /* okay; the basic solution seems to be integer feasible */
         double *x = xcalloc(1+n, sizeof(double));
         for (j = 1; j <= n; j++)
         {  x[j] = lp->col[j]->prim;
            if (P->col[j]->kind == GLP_IV) x[j] = floor(x[j] + 0.5);
         }
#if 1 /* modified by xypron  */
         /* reset direction and right-hand side of objective */
         lp->c0  = P->c0;
         lp->dir = P->dir;
         /* fix integer variables */
         for (k = 1; k <= nv; k++)
#if 0 /* 18/VI-2013; fixed by mao
       * this bug causes numerical instability, because column statuses
       * are not changed appropriately */
         {  lp->col[var[k].j]->lb   = x[var[k].j];
            lp->col[var[k].j]->ub   = x[var[k].j];
            lp->col[var[k].j]->type = GLP_FX;
         }
#else
            glp_set_col_bnds(lp, var[k].j, GLP_FX, x[var[k].j], 0.);
#endif
         /* copy original objective function */
         for (j = 1; j <= n; j++)
            lp->col[j]->coef = P->col[j]->coef;
         /* solve original LP and copy result */
         ret = glp_simplex(lp, &parm);
         if (ret != 0)
         {  if (T->parm->msg_lev >= GLP_MSG_ERR)
               xprintf("Warning: glp_simplex returned %d\n", ret);
#if 1 /* 17/III-2016: fix memory leak */
            xfree(x);
#endif
            goto done;
         }
         ret = glp_get_status(lp);
         if (ret != GLP_OPT)
         {  if (T->parm->msg_lev >= GLP_MSG_ERR)
               xprintf("Warning: glp_get_status returned %d\n", ret);
#if 1 /* 17/III-2016: fix memory leak */
            xfree(x);
#endif
            goto done;
         }
         for (j = 1; j <= n; j++)
            if (P->col[j]->kind != GLP_IV) x[j] = lp->col[j]->prim;
#endif
         ret = glp_ios_heur_sol(T, x);
         xfree(x);
         if (ret == 0)
         {  /* the integer solution is accepted */
            if (ios_is_hopeful(T, T->curr->bound))
            {  /* it is reasonable to apply the heuristic once again */
               goto more;
            }
            else
            {  /* the best known integer feasible solution just found
                  is close to optimal solution to LP relaxation */
               goto done;
            }
         }
      }
      /* the basic solution is fractional */
      if (dist == DBL_MAX ||
          lp->obj_val <= dist - 1e-6 * (1.0 + dist))
      {  /* the distance is reducing */
         nfail = 0, dist = lp->obj_val;
      }
      else
      {  /* improving the distance failed */
         nfail++;
      }
      if (nfail < 3) goto loop;
      if (npass < 5) goto pass;
done: /* delete working objects */
      if (lp != NULL) glp_delete_prob(lp);
      if (var != NULL) xfree(var);
      if (rand != NULL) rng_delete_rand(rand);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/gmicut.c0000644000175100001710000002363500000000000025066 0ustar00runnerdocker00000000000000/* gmicut.c (Gomory's mixed integer cut generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2002-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_gmi_cut - generate Gomory's mixed integer cut (core routine)
*
*  SYNOPSIS
*
*  int glp_gmi_cut(glp_prob *P, int j, int ind[], double val[], double
*     phi[]);
*
*  DESCRIPTION
*
*  This routine attempts to generate a Gomory's mixed integer cut for
*  specified integer column (structural variable), whose primal value
*  in current basic solution is integer infeasible (fractional).
*
*  On entry to the routine the basic solution contained in the problem
*  object P should be optimal, and the basis factorization should be
*  valid. The parameter j should specify the ordinal number of column
*  (structural variable x[j]), for which the cut should be generated,
*  1 <= j <= n, where n is the number of columns in the problem object.
*  This column should be integer, non-fixed, and basic, and its primal
*  value should be fractional.
*
*  The cut generated by the routine is the following inequality:
*
*     sum a[j] * x[j] >= b,
*
*  which is expected to be violated at the current basic solution.
*
*  If the cut has been successfully generated, the routine stores its
*  non-zero coefficients a[j] and corresponding column indices j in the
*  array locations val[1], ..., val[len] and ind[1], ..., ind[len],
*  where 1 <= len <= n is the number of non-zero coefficients. The
*  right-hand side value b is stored in val[0], and ind[0] is set to 0.
*
*  The working array phi should have 1+m+n locations (location phi[0]
*  is not used), where m and n is the number of rows and columns in the
*  problem object, resp.
*
*  RETURNS
*
*  If the cut has been successfully generated, the routine returns
*  len, the number of non-zero coefficients in the cut, 1 <= len <= n.
*
*  Otherwise, the routine returns one of the following codes:
*
*  -1    current basis factorization is not valid;
*
*  -2    current basic solution is not optimal;
*
*  -3    column ordinal number j is out of range;
*
*  -4    variable x[j] is not of integral kind;
*
*  -5    variable x[j] is either fixed or non-basic;
*
*  -6    primal value of variable x[j] in basic solution is too close
*        to nearest integer;
*
*  -7    some coefficients in the simplex table row corresponding to
*        variable x[j] are too large in magnitude;
*
*  -8    some free (unbounded) variables have non-zero coefficients in
*        the simplex table row corresponding to variable x[j].
*
*  ALGORITHM
*
*  See glpk/doc/notes/gomory (in Russian). */

#define f(x) ((x) - floor(x))
/* compute fractional part of x */

int glp_gmi_cut(glp_prob *P, int j,
      int ind[/*1+n*/], double val[/*1+n*/], double phi[/*1+m+n*/])
{     int m = P->m;
      int n = P->n;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, k, len, kind, stat;
      double lb, ub, alfa, beta, ksi, phi1, rhs;
      /* sanity checks */
      if (!(P->m == 0 || P->valid))
      {  /* current basis factorization is not valid */
         return -1;
      }
      if (!(P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS))
      {  /* current basic solution is not optimal */
         return -2;
      }
      if (!(1 <= j && j <= n))
      {  /* column ordinal number is out of range */
         return -3;
      }
      col = P->col[j];
      if (col->kind != GLP_IV)
      {  /* x[j] is not of integral kind */
         return -4;
      }
      if (col->type == GLP_FX || col->stat != GLP_BS)
      {  /* x[j] is either fixed or non-basic */
         return -5;
      }
      if (fabs(col->prim - floor(col->prim + 0.5)) < 0.001)
      {  /* primal value of x[j] is too close to nearest integer */
         return -6;
      }
      /* compute row of the simplex tableau, which (row) corresponds
       * to specified basic variable xB[i] = x[j]; see (23) */
      len = glp_eval_tab_row(P, m+j, ind, val);
      /* determine beta[i], which a value of xB[i] in optimal solution
       * to current LP relaxation; note that this value is the same as
       * if it would be computed with formula (27); it is assumed that
       * beta[i] is fractional enough */
      beta = P->col[j]->prim;
      /* compute cut coefficients phi and right-hand side rho, which
       * correspond to formula (30); dense format is used, because rows
       * of the simplex tableau are usually dense */
      for (k = 1; k <= m+n; k++)
         phi[k] = 0.0;
      rhs = f(beta); /* initial value of rho; see (28), (32) */
      for (j = 1; j <= len; j++)
      {  /* determine original number of non-basic variable xN[j] */
         k = ind[j];
         xassert(1 <= k && k <= m+n);
         /* determine the kind, bounds and current status of xN[j] in
          * optimal solution to LP relaxation */
         if (k <= m)
         {  /* auxiliary variable */
            row = P->row[k];
            kind = GLP_CV;
            lb = row->lb;
            ub = row->ub;
            stat = row->stat;
         }
         else
         {  /* structural variable */
            col = P->col[k-m];
            kind = col->kind;
            lb = col->lb;
            ub = col->ub;
            stat = col->stat;
         }
         /* xN[j] cannot be basic */
         xassert(stat != GLP_BS);
         /* determine row coefficient ksi[i,j] at xN[j]; see (23) */
         ksi = val[j];
         /* if ksi[i,j] is too large in magnitude, report failure */
         if (fabs(ksi) > 1e+05)
            return -7;
         /* if ksi[i,j] is too small in magnitude, skip it */
         if (fabs(ksi) < 1e-10)
            goto skip;
         /* compute row coefficient alfa[i,j] at y[j]; see (26) */
         switch (stat)
         {  case GLP_NF:
               /* xN[j] is free (unbounded) having non-zero ksi[i,j];
                * report failure */
               return -8;
            case GLP_NL:
               /* xN[j] has active lower bound */
               alfa = - ksi;
               break;
            case GLP_NU:
               /* xN[j] has active upper bound */
               alfa = + ksi;
               break;
            case GLP_NS:
               /* xN[j] is fixed; skip it */
               goto skip;
            default:
               xassert(stat != stat);
         }
         /* compute cut coefficient phi'[j] at y[j]; see (21), (28) */
         switch (kind)
         {  case GLP_IV:
               /* y[j] is integer */
               if (fabs(alfa - floor(alfa + 0.5)) < 1e-10)
               {  /* alfa[i,j] is close to nearest integer; skip it */
                  goto skip;
               }
               else if (f(alfa) <= f(beta))
                  phi1 = f(alfa);
               else
                  phi1 = (f(beta) / (1.0 - f(beta))) * (1.0 - f(alfa));
               break;
            case GLP_CV:
               /* y[j] is continuous */
               if (alfa >= 0.0)
                  phi1 = + alfa;
               else
                  phi1 = (f(beta) / (1.0 - f(beta))) * (- alfa);
               break;
            default:
               xassert(kind != kind);
         }
         /* compute cut coefficient phi[j] at xN[j] and update right-
          * hand side rho; see (31), (32) */
         switch (stat)
         {  case GLP_NL:
               /* xN[j] has active lower bound */
               phi[k] = + phi1;
               rhs += phi1 * lb;
               break;
            case GLP_NU:
               /* xN[j] has active upper bound */
               phi[k] = - phi1;
               rhs -= phi1 * ub;
               break;
            default:
               xassert(stat != stat);
         }
skip:    ;
      }
      /* now the cut has the form sum_k phi[k] * x[k] >= rho, where cut
       * coefficients are stored in the array phi in dense format;
       * x[1,...,m] are auxiliary variables, x[m+1,...,m+n] are struc-
       * tural variables; see (30) */
      /* eliminate auxiliary variables in order to express the cut only
       * through structural variables; see (33) */
      for (i = 1; i <= m; i++)
      {  if (fabs(phi[i]) < 1e-10)
            continue;
         /* auxiliary variable x[i] has non-zero cut coefficient */
         row = P->row[i];
         /* x[i] cannot be fixed variable */
         xassert(row->type != GLP_FX);
         /* substitute x[i] = sum_j a[i,j] * x[m+j] */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            phi[m+aij->col->j] += phi[i] * aij->val;
      }
      /* convert the final cut to sparse format and substitute fixed
       * (structural) variables */
      len = 0;
      for (j = 1; j <= n; j++)
      {  if (fabs(phi[m+j]) < 1e-10)
            continue;
         /* structural variable x[m+j] has non-zero cut coefficient */
         col = P->col[j];
         if (col->type == GLP_FX)
         {  /* eliminate x[m+j] */
            rhs -= phi[m+j] * col->lb;
         }
         else
         {  len++;
            ind[len] = j;
            val[len] = phi[m+j];
         }
      }
      if (fabs(rhs) < 1e-12)
         rhs = 0.0;
      ind[0] = 0, val[0] = rhs;
      /* the cut has been successfully generated */
      return len;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/gmigen.c0000644000175100001710000001133700000000000025040 0ustar00runnerdocker00000000000000/* gmigen.c (Gomory's mixed integer cuts generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2002-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "prob.h"

/***********************************************************************
*  NAME
*
*  glp_gmi_gen - generate Gomory's mixed integer cuts
*
*  SYNOPSIS
*
*  int glp_gmi_gen(glp_prob *P, glp_prob *pool, int max_cuts);
*
*  DESCRIPTION
*
*  This routine attempts to generate Gomory's mixed integer cuts for
*  integer variables, whose primal values in current basic solution are
*  integer infeasible (fractional).
*
*  On entry to the routine the basic solution contained in the problem
*  object P should be optimal, and the basis factorization should be
*  valid.
*
*  The cutting plane inequalities generated by the routine are added to
*  the specified cut pool.
*
*  The parameter max_cuts specifies the maximal number of cuts to be
*  generated. Note that the number of cuts cannot exceed the number of
*  basic variables, which is the number of rows in the problem object.
*
*  RETURNS
*
*  The routine returns the number of cuts that have been generated and
*  added to the cut pool. */

#define f(x) ((x) - floor(x))
/* compute fractional part of x */

struct var { int j; double f; };

static int CDECL fcmp(const void *p1, const void *p2)
{     const struct var *v1 = p1, *v2 = p2;
      if (v1->f > v2->f) return -1;
      if (v1->f < v2->f) return +1;
      return 0;
}

int glp_gmi_gen(glp_prob *P, glp_prob *pool, int max_cuts)
{     int m = P->m;
      int n = P->n;
      GLPCOL *col;
      struct var *var;
      int i, j, k, t, len, nv, nnn, *ind;
      double frac, *val, *phi;
      /* sanity checks */
      if (!(P->m == 0 || P->valid))
         xerror("glp_gmi_gen: basis factorization does not exist\n");
      if (!(P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS))
         xerror("glp_gmi_gen: optimal basic solution required\n");
      if (pool->n != n)
         xerror("glp_gmi_gen: cut pool has wrong number of columns\n");
      /* allocate working arrays */
      var = xcalloc(1+n, sizeof(struct var));
      ind = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      phi = xcalloc(1+m+n, sizeof(double));
      /* build the list of integer structural variables, which are
       * basic and have integer infeasible (fractional) primal values
       * in optimal solution to specified LP */
      nv = 0;
      for (j = 1; j <= n; j++)
      {  col = P->col[j];
         if (col->kind != GLP_IV)
            continue;
         if (col->type == GLP_FX)
            continue;
         if (col->stat != GLP_BS)
            continue;
         frac = f(col->prim);
         if (!(0.05 <= frac && frac <= 0.95))
            continue;
         /* add variable to the list */
         nv++, var[nv].j = j, var[nv].f = frac;
      }
      /* sort the list by descending fractionality */
      qsort(&var[1], nv, sizeof(struct var), fcmp);
      /* try to generate cuts by one for each variable in the list, but
       * not more than max_cuts cuts */
      nnn = 0;
      for (t = 1; t <= nv; t++)
      {  len = glp_gmi_cut(P, var[t].j, ind, val, phi);
         if (len < 1)
            goto skip;
         /* if the cut inequality seems to be badly scaled, reject it
          * to avoid numerical difficulties */
         for (k = 1; k <= len; k++)
         {  if (fabs(val[k]) < 1e-03)
               goto skip;
            if (fabs(val[k]) > 1e+03)
               goto skip;
         }
         /* add the cut to the cut pool for further consideration */
         i = glp_add_rows(pool, 1);
         glp_set_row_bnds(pool, i, GLP_LO, val[0], 0);
         glp_set_mat_row(pool, i, len, ind, val);
         /* one cut has been generated */
         nnn++;
         if (nnn == max_cuts)
            break;
skip:    ;
      }
      /* free working arrays */
      xfree(var);
      xfree(ind);
      xfree(val);
      xfree(phi);
      return nnn;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/mirgen.c0000644000175100001710000014376700000000000025070 0ustar00runnerdocker00000000000000/* mirgen.c (mixed integer rounding cuts generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#if 1 /* 29/II-2016 by Chris */
/*----------------------------------------------------------------------
Subject: Mir cut generation performance improvement
From: Chris Matrakidis 
To: Andrew Makhorin , help-glpk 

Andrew,

I noticed that mir cut generation takes considerable time on some large
problems (like rocII-4-11 from miplib). The attached patch makes two
improvements that considerably improve performance in such instances:
1. A lot of time was spent on generating a temporary vector in function
aggregate_row. It is a lot faster to reuse an existing vector.
2. A search for an element in the same function was done in row order,
where using the elements in the order they are in the column is more
efficient. This changes the generated cuts in some cases, but seems
neutral overall (0.3% less cuts in a test set of 64 miplib instances).

Best Regards,

Chris Matrakidis
----------------------------------------------------------------------*/
#endif

#include "env.h"
#include "prob.h"
#include "spv.h"

#define MIR_DEBUG 0

#define MAXAGGR 5
/* maximal number of rows that can be aggregated */

struct glp_mir
{     /* MIR cut generator working area */
      /*--------------------------------------------------------------*/
      /* global information valid for the root subproblem */
      int m;
      /* number of rows (in the root subproblem) */
      int n;
      /* number of columns */
      char *skip; /* char skip[1+m]; */
      /* skip[i], 1 <= i <= m, is a flag that means that row i should
         not be used because (1) it is not suitable, or (2) because it
         has been used in the aggregated constraint */
      char *isint; /* char isint[1+m+n]; */
      /* isint[k], 1 <= k <= m+n, is a flag that means that variable
         x[k] is integer (otherwise, continuous) */
      double *lb; /* double lb[1+m+n]; */
      /* lb[k], 1 <= k <= m+n, is lower bound of x[k]; -DBL_MAX means
         that x[k] has no lower bound */
      int *vlb; /* int vlb[1+m+n]; */
      /* vlb[k] = k', 1 <= k <= m+n, is the number of integer variable,
         which defines variable lower bound x[k] >= lb[k] * x[k']; zero
         means that x[k] has simple lower bound */
      double *ub; /* double ub[1+m+n]; */
      /* ub[k], 1 <= k <= m+n, is upper bound of x[k]; +DBL_MAX means
         that x[k] has no upper bound */
      int *vub; /* int vub[1+m+n]; */
      /* vub[k] = k', 1 <= k <= m+n, is the number of integer variable,
         which defines variable upper bound x[k] <= ub[k] * x[k']; zero
         means that x[k] has simple upper bound */
      /*--------------------------------------------------------------*/
      /* current (fractional) point to be separated */
      double *x; /* double x[1+m+n]; */
      /* x[k] is current value of auxiliary (1 <= k <= m) or structural
         (m+1 <= k <= m+n) variable */
      /*--------------------------------------------------------------*/
      /* aggregated constraint sum a[k] * x[k] = b, which is a linear
         combination of original constraints transformed to equalities
         by introducing auxiliary variables */
      int agg_cnt;
      /* number of rows (original constraints) used to build aggregated
         constraint, 1 <= agg_cnt <= MAXAGGR */
      int *agg_row; /* int agg_row[1+MAXAGGR]; */
      /* agg_row[k], 1 <= k <= agg_cnt, is the row number used to build
         aggregated constraint */
      SPV *agg_vec; /* SPV agg_vec[1:m+n]; */
      /* sparse vector of aggregated constraint coefficients, a[k] */
      double agg_rhs;
      /* right-hand side of the aggregated constraint, b */
      /*--------------------------------------------------------------*/
      /* bound substitution flags for modified constraint */
      char *subst; /* char subst[1+m+n]; */
      /* subst[k], 1 <= k <= m+n, is a bound substitution flag used for
         variable x[k]:
         '?' - x[k] is missing in modified constraint
         'L' - x[k] = (lower bound) + x'[k]
         'U' - x[k] = (upper bound) - x'[k] */
      /*--------------------------------------------------------------*/
      /* modified constraint sum a'[k] * x'[k] = b', where x'[k] >= 0,
         derived from aggregated constraint by substituting bounds;
         note that due to substitution of variable bounds there may be
         additional terms in the modified constraint */
      SPV *mod_vec; /* SPV mod_vec[1:m+n]; */
      /* sparse vector of modified constraint coefficients, a'[k] */
      double mod_rhs;
      /* right-hand side of the modified constraint, b' */
      /*--------------------------------------------------------------*/
      /* cutting plane sum alpha[k] * x[k] <= beta */
      SPV *cut_vec; /* SPV cut_vec[1:m+n]; */
      /* sparse vector of cutting plane coefficients, alpha[k] */
      double cut_rhs;
      /* right-hand size of the cutting plane, beta */
};

/***********************************************************************
*  NAME
*
*  glp_mir_init - create and initialize MIR cut generator
*
*  SYNOPSIS
*
*  glp_mir *glp_mir_init(glp_prob *P);
*
*  DESCRIPTION
*
*  This routine creates and initializes the MIR cut generator for the
*  specified problem object.
*
*  RETURNS
*
*  The routine returns a pointer to the MIR cut generator workspace. */

static void set_row_attrib(glp_prob *mip, glp_mir *mir)
{     /* set global row attributes */
      int m = mir->m;
      int k;
      for (k = 1; k <= m; k++)
      {  GLPROW *row = mip->row[k];
         mir->skip[k] = 0;
         mir->isint[k] = 0;
         switch (row->type)
         {  case GLP_FR:
               mir->lb[k] = -DBL_MAX, mir->ub[k] = +DBL_MAX; break;
            case GLP_LO:
               mir->lb[k] = row->lb, mir->ub[k] = +DBL_MAX; break;
            case GLP_UP:
               mir->lb[k] = -DBL_MAX, mir->ub[k] = row->ub; break;
            case GLP_DB:
               mir->lb[k] = row->lb, mir->ub[k] = row->ub; break;
            case GLP_FX:
               mir->lb[k] = mir->ub[k] = row->lb; break;
            default:
               xassert(row != row);
         }
         mir->vlb[k] = mir->vub[k] = 0;
      }
      return;
}

static void set_col_attrib(glp_prob *mip, glp_mir *mir)
{     /* set global column attributes */
      int m = mir->m;
      int n = mir->n;
      int k;
      for (k = m+1; k <= m+n; k++)
      {  GLPCOL *col = mip->col[k-m];
         switch (col->kind)
         {  case GLP_CV:
               mir->isint[k] = 0; break;
            case GLP_IV:
               mir->isint[k] = 1; break;
            default:
               xassert(col != col);
         }
         switch (col->type)
         {  case GLP_FR:
               mir->lb[k] = -DBL_MAX, mir->ub[k] = +DBL_MAX; break;
            case GLP_LO:
               mir->lb[k] = col->lb, mir->ub[k] = +DBL_MAX; break;
            case GLP_UP:
               mir->lb[k] = -DBL_MAX, mir->ub[k] = col->ub; break;
            case GLP_DB:
               mir->lb[k] = col->lb, mir->ub[k] = col->ub; break;
            case GLP_FX:
               mir->lb[k] = mir->ub[k] = col->lb; break;
            default:
               xassert(col != col);
         }
         mir->vlb[k] = mir->vub[k] = 0;
      }
      return;
}

static void set_var_bounds(glp_prob *mip, glp_mir *mir)
{     /* set variable bounds */
      int m = mir->m;
      GLPAIJ *aij;
      int i, k1, k2;
      double a1, a2;
      for (i = 1; i <= m; i++)
      {  /* we need the row to be '>= 0' or '<= 0' */
         if (!(mir->lb[i] == 0.0 && mir->ub[i] == +DBL_MAX ||
               mir->lb[i] == -DBL_MAX && mir->ub[i] == 0.0)) continue;
         /* take first term */
         aij = mip->row[i]->ptr;
         if (aij == NULL) continue;
         k1 = m + aij->col->j, a1 = aij->val;
         /* take second term */
         aij = aij->r_next;
         if (aij == NULL) continue;
         k2 = m + aij->col->j, a2 = aij->val;
         /* there must be only two terms */
         if (aij->r_next != NULL) continue;
         /* interchange terms, if needed */
         if (!mir->isint[k1] && mir->isint[k2])
            ;
         else if (mir->isint[k1] && !mir->isint[k2])
         {  k2 = k1, a2 = a1;
            k1 = m + aij->col->j, a1 = aij->val;
         }
         else
         {  /* both terms are either continuous or integer */
            continue;
         }
         /* x[k2] should be double-bounded */
         if (mir->lb[k2] == -DBL_MAX || mir->ub[k2] == +DBL_MAX ||
             mir->lb[k2] == mir->ub[k2]) continue;
         /* change signs, if necessary */
         if (mir->ub[i] == 0.0) a1 = - a1, a2 = - a2;
         /* now the row has the form a1 * x1 + a2 * x2 >= 0, where x1
            is continuous, x2 is integer */
         if (a1 > 0.0)
         {  /* x1 >= - (a2 / a1) * x2 */
            if (mir->vlb[k1] == 0)
            {  /* set variable lower bound for x1 */
               mir->lb[k1] = - a2 / a1;
               mir->vlb[k1] = k2;
               /* the row should not be used */
               mir->skip[i] = 1;
            }
         }
         else /* a1 < 0.0 */
         {  /* x1 <= - (a2 / a1) * x2 */
            if (mir->vub[k1] == 0)
            {  /* set variable upper bound for x1 */
               mir->ub[k1] = - a2 / a1;
               mir->vub[k1] = k2;
               /* the row should not be used */
               mir->skip[i] = 1;
            }
         }
      }
      return;
}

static void mark_useless_rows(glp_prob *mip, glp_mir *mir)
{     /* mark rows which should not be used */
      int m = mir->m;
      GLPAIJ *aij;
      int i, k, nv;
      for (i = 1; i <= m; i++)
      {  /* free rows should not be used */
         if (mir->lb[i] == -DBL_MAX && mir->ub[i] == +DBL_MAX)
         {  mir->skip[i] = 1;
            continue;
         }
         nv = 0;
         for (aij = mip->row[i]->ptr; aij != NULL; aij = aij->r_next)
         {  k = m + aij->col->j;
            /* rows with free variables should not be used */
            if (mir->lb[k] == -DBL_MAX && mir->ub[k] == +DBL_MAX)
            {  mir->skip[i] = 1;
               break;
            }
            /* rows with integer variables having infinite (lower or
               upper) bound should not be used */
            if (mir->isint[k] && mir->lb[k] == -DBL_MAX ||
                mir->isint[k] && mir->ub[k] == +DBL_MAX)
            {  mir->skip[i] = 1;
               break;
            }
            /* count non-fixed variables */
            if (!(mir->vlb[k] == 0 && mir->vub[k] == 0 &&
                  mir->lb[k] == mir->ub[k])) nv++;
         }
         /* rows with all variables fixed should not be used */
         if (nv == 0)
         {  mir->skip[i] = 1;
            continue;
         }
      }
      return;
}

glp_mir *glp_mir_init(glp_prob *mip)
{     /* create and initialize MIR cut generator */
      int m = mip->m;
      int n = mip->n;
      glp_mir *mir;
#if MIR_DEBUG
      xprintf("ios_mir_init: warning: debug mode enabled\n");
#endif
      /* allocate working area */
      mir = xmalloc(sizeof(glp_mir));
      mir->m = m;
      mir->n = n;
      mir->skip = xcalloc(1+m, sizeof(char));
      mir->isint = xcalloc(1+m+n, sizeof(char));
      mir->lb = xcalloc(1+m+n, sizeof(double));
      mir->vlb = xcalloc(1+m+n, sizeof(int));
      mir->ub = xcalloc(1+m+n, sizeof(double));
      mir->vub = xcalloc(1+m+n, sizeof(int));
      mir->x = xcalloc(1+m+n, sizeof(double));
      mir->agg_row = xcalloc(1+MAXAGGR, sizeof(int));
      mir->agg_vec = spv_create_vec(m+n);
      mir->subst = xcalloc(1+m+n, sizeof(char));
      mir->mod_vec = spv_create_vec(m+n);
      mir->cut_vec = spv_create_vec(m+n);
      /* set global row attributes */
      set_row_attrib(mip, mir);
      /* set global column attributes */
      set_col_attrib(mip, mir);
      /* set variable bounds */
      set_var_bounds(mip, mir);
      /* mark rows which should not be used */
      mark_useless_rows(mip, mir);
      return mir;
}

/***********************************************************************
*  NAME
*
*  glp_mir_gen - generate mixed integer rounding (MIR) cuts
*
*  SYNOPSIS
*
*  int glp_mir_gen(glp_prob *P, glp_mir *mir, glp_prob *pool);
*
*  DESCRIPTION
*
*  This routine attempts to generate mixed integer rounding (MIR) cuts
*  for current basic solution to the specified problem object.
*
*  The cutting plane inequalities generated by the routine are added to
*  the specified cut pool.
*
*  RETURNS
*
*  The routine returns the number of cuts that have been generated and
*  added to the cut pool. */

static void get_current_point(glp_prob *mip, glp_mir *mir)
{     /* obtain current point */
      int m = mir->m;
      int n = mir->n;
      int k;
      for (k = 1; k <= m; k++)
         mir->x[k] = mip->row[k]->prim;
      for (k = m+1; k <= m+n; k++)
         mir->x[k] = mip->col[k-m]->prim;
      return;
}

#if MIR_DEBUG
static void check_current_point(glp_mir *mir)
{     /* check current point */
      int m = mir->m;
      int n = mir->n;
      int k, kk;
      double lb, ub, eps;
      for (k = 1; k <= m+n; k++)
      {  /* determine lower bound */
         lb = mir->lb[k];
         kk = mir->vlb[k];
         if (kk != 0)
         {  xassert(lb != -DBL_MAX);
            xassert(!mir->isint[k]);
            xassert(mir->isint[kk]);
            lb *= mir->x[kk];
         }
         /* check lower bound */
         if (lb != -DBL_MAX)
         {  eps = 1e-6 * (1.0 + fabs(lb));
            xassert(mir->x[k] >= lb - eps);
         }
         /* determine upper bound */
         ub = mir->ub[k];
         kk = mir->vub[k];
         if (kk != 0)
         {  xassert(ub != +DBL_MAX);
            xassert(!mir->isint[k]);
            xassert(mir->isint[kk]);
            ub *= mir->x[kk];
         }
         /* check upper bound */
         if (ub != +DBL_MAX)
         {  eps = 1e-6 * (1.0 + fabs(ub));
            xassert(mir->x[k] <= ub + eps);
         }
      }
      return;
}
#endif

static void initial_agg_row(glp_prob *mip, glp_mir *mir, int i)
{     /* use original i-th row as initial aggregated constraint */
      int m = mir->m;
      GLPAIJ *aij;
      xassert(1 <= i && i <= m);
      xassert(!mir->skip[i]);
      /* mark i-th row in order not to use it in the same aggregated
         constraint */
      mir->skip[i] = 2;
      mir->agg_cnt = 1;
      mir->agg_row[1] = i;
      /* use x[i] - sum a[i,j] * x[m+j] = 0, where x[i] is auxiliary
         variable of row i, x[m+j] are structural variables */
      spv_clear_vec(mir->agg_vec);
      spv_set_vj(mir->agg_vec, i, 1.0);
      for (aij = mip->row[i]->ptr; aij != NULL; aij = aij->r_next)
         spv_set_vj(mir->agg_vec, m + aij->col->j, - aij->val);
      mir->agg_rhs = 0.0;
#if MIR_DEBUG
      spv_check_vec(mir->agg_vec);
#endif
      return;
}

#if MIR_DEBUG
static void check_agg_row(glp_mir *mir)
{     /* check aggregated constraint */
      int m = mir->m;
      int n = mir->n;
      int j, k;
      double r, big;
      /* compute the residual r = sum a[k] * x[k] - b and determine
         big = max(1, |a[k]|, |b|) */
      r = 0.0, big = 1.0;
      for (j = 1; j <= mir->agg_vec->nnz; j++)
      {  k = mir->agg_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         r += mir->agg_vec->val[j] * mir->x[k];
         if (big < fabs(mir->agg_vec->val[j]))
            big = fabs(mir->agg_vec->val[j]);
      }
      r -= mir->agg_rhs;
      if (big < fabs(mir->agg_rhs))
         big = fabs(mir->agg_rhs);
      /* the residual must be close to zero */
      xassert(fabs(r) <= 1e-6 * big);
      return;
}
#endif

static void subst_fixed_vars(glp_mir *mir)
{     /* substitute fixed variables into aggregated constraint */
      int m = mir->m;
      int n = mir->n;
      int j, k;
      for (j = 1; j <= mir->agg_vec->nnz; j++)
      {  k = mir->agg_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->vlb[k] == 0 && mir->vub[k] == 0 &&
             mir->lb[k] == mir->ub[k])
         {  /* x[k] is fixed */
            mir->agg_rhs -= mir->agg_vec->val[j] * mir->lb[k];
            mir->agg_vec->val[j] = 0.0;
         }
      }
      /* remove terms corresponding to fixed variables */
      spv_clean_vec(mir->agg_vec, DBL_EPSILON);
#if MIR_DEBUG
      spv_check_vec(mir->agg_vec);
#endif
      return;
}

static void bound_subst_heur(glp_mir *mir)
{     /* bound substitution heuristic */
      int m = mir->m;
      int n = mir->n;
      int j, k, kk;
      double d1, d2;
      for (j = 1; j <= mir->agg_vec->nnz; j++)
      {  k = mir->agg_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->isint[k]) continue; /* skip integer variable */
         /* compute distance from x[k] to its lower bound */
         kk = mir->vlb[k];
         if (kk == 0)
         {  if (mir->lb[k] == -DBL_MAX)
               d1 = DBL_MAX;
            else
               d1 = mir->x[k] - mir->lb[k];
         }
         else
         {  xassert(1 <= kk && kk <= m+n);
            xassert(mir->isint[kk]);
            xassert(mir->lb[k] != -DBL_MAX);
            d1 = mir->x[k] - mir->lb[k] * mir->x[kk];
         }
         /* compute distance from x[k] to its upper bound */
         kk = mir->vub[k];
         if (kk == 0)
         {  if (mir->vub[k] == +DBL_MAX)
               d2 = DBL_MAX;
            else
               d2 = mir->ub[k] - mir->x[k];
         }
         else
         {  xassert(1 <= kk && kk <= m+n);
            xassert(mir->isint[kk]);
            xassert(mir->ub[k] != +DBL_MAX);
            d2 = mir->ub[k] * mir->x[kk] - mir->x[k];
         }
         /* x[k] cannot be free */
         xassert(d1 != DBL_MAX || d2 != DBL_MAX);
         /* choose the bound which is closer to x[k] */
         xassert(mir->subst[k] == '?');
         if (d1 <= d2)
            mir->subst[k] = 'L';
         else
            mir->subst[k] = 'U';
      }
      return;
}

static void build_mod_row(glp_mir *mir)
{     /* substitute bounds and build modified constraint */
      int m = mir->m;
      int n = mir->n;
      int j, jj, k, kk;
      /* initially modified constraint is aggregated constraint */
      spv_copy_vec(mir->mod_vec, mir->agg_vec);
      mir->mod_rhs = mir->agg_rhs;
#if MIR_DEBUG
      spv_check_vec(mir->mod_vec);
#endif
      /* substitute bounds for continuous variables; note that due to
         substitution of variable bounds additional terms may appear in
         modified constraint */
      for (j = mir->mod_vec->nnz; j >= 1; j--)
      {  k = mir->mod_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->isint[k]) continue; /* skip integer variable */
         if (mir->subst[k] == 'L')
         {  /* x[k] = (lower bound) + x'[k] */
            xassert(mir->lb[k] != -DBL_MAX);
            kk = mir->vlb[k];
            if (kk == 0)
            {  /* x[k] = lb[k] + x'[k] */
               mir->mod_rhs -= mir->mod_vec->val[j] * mir->lb[k];
            }
            else
            {  /* x[k] = lb[k] * x[kk] + x'[k] */
               xassert(mir->isint[kk]);
               jj = mir->mod_vec->pos[kk];
               if (jj == 0)
               {  spv_set_vj(mir->mod_vec, kk, 1.0);
                  jj = mir->mod_vec->pos[kk];
                  mir->mod_vec->val[jj] = 0.0;
               }
               mir->mod_vec->val[jj] +=
                  mir->mod_vec->val[j] * mir->lb[k];
            }
         }
         else if (mir->subst[k] == 'U')
         {  /* x[k] = (upper bound) - x'[k] */
            xassert(mir->ub[k] != +DBL_MAX);
            kk = mir->vub[k];
            if (kk == 0)
            {  /* x[k] = ub[k] - x'[k] */
               mir->mod_rhs -= mir->mod_vec->val[j] * mir->ub[k];
            }
            else
            {  /* x[k] = ub[k] * x[kk] - x'[k] */
               xassert(mir->isint[kk]);
               jj = mir->mod_vec->pos[kk];
               if (jj == 0)
               {  spv_set_vj(mir->mod_vec, kk, 1.0);
                  jj = mir->mod_vec->pos[kk];
                  mir->mod_vec->val[jj] = 0.0;
               }
               mir->mod_vec->val[jj] +=
                  mir->mod_vec->val[j] * mir->ub[k];
            }
            mir->mod_vec->val[j] = - mir->mod_vec->val[j];
         }
         else
            xassert(k != k);
      }
#if MIR_DEBUG
      spv_check_vec(mir->mod_vec);
#endif
      /* substitute bounds for integer variables */
      for (j = 1; j <= mir->mod_vec->nnz; j++)
      {  k = mir->mod_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (!mir->isint[k]) continue; /* skip continuous variable */
         xassert(mir->subst[k] == '?');
         xassert(mir->vlb[k] == 0 && mir->vub[k] == 0);
         xassert(mir->lb[k] != -DBL_MAX && mir->ub[k] != +DBL_MAX);
         if (fabs(mir->lb[k]) <= fabs(mir->ub[k]))
         {  /* x[k] = lb[k] + x'[k] */
            mir->subst[k] = 'L';
            mir->mod_rhs -= mir->mod_vec->val[j] * mir->lb[k];
         }
         else
         {  /* x[k] = ub[k] - x'[k] */
            mir->subst[k] = 'U';
            mir->mod_rhs -= mir->mod_vec->val[j] * mir->ub[k];
            mir->mod_vec->val[j] = - mir->mod_vec->val[j];
         }
      }
#if MIR_DEBUG
      spv_check_vec(mir->mod_vec);
#endif
      return;
}

#if MIR_DEBUG
static void check_mod_row(glp_mir *mir)
{     /* check modified constraint */
      int m = mir->m;
      int n = mir->n;
      int j, k, kk;
      double r, big, x;
      /* compute the residual r = sum a'[k] * x'[k] - b' and determine
         big = max(1, |a[k]|, |b|) */
      r = 0.0, big = 1.0;
      for (j = 1; j <= mir->mod_vec->nnz; j++)
      {  k = mir->mod_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->subst[k] == 'L')
         {  /* x'[k] = x[k] - (lower bound) */
            xassert(mir->lb[k] != -DBL_MAX);
            kk = mir->vlb[k];
            if (kk == 0)
               x = mir->x[k] - mir->lb[k];
            else
               x = mir->x[k] - mir->lb[k] * mir->x[kk];
         }
         else if (mir->subst[k] == 'U')
         {  /* x'[k] = (upper bound) - x[k] */
            xassert(mir->ub[k] != +DBL_MAX);
            kk = mir->vub[k];
            if (kk == 0)
               x = mir->ub[k] - mir->x[k];
            else
               x = mir->ub[k] * mir->x[kk] - mir->x[k];
         }
         else
            xassert(k != k);
         r += mir->mod_vec->val[j] * x;
         if (big < fabs(mir->mod_vec->val[j]))
            big = fabs(mir->mod_vec->val[j]);
      }
      r -= mir->mod_rhs;
      if (big < fabs(mir->mod_rhs))
         big = fabs(mir->mod_rhs);
      /* the residual must be close to zero */
      xassert(fabs(r) <= 1e-6 * big);
      return;
}
#endif

/***********************************************************************
*  mir_ineq - construct MIR inequality
*
*  Given the single constraint mixed integer set
*
*                    |N|
*     X = {(x,s) in Z    x R  : sum   a[j] * x[j] <= b + s},
*                    +      +  j in N
*
*  this routine constructs the mixed integer rounding (MIR) inequality
*
*     sum   alpha[j] * x[j] <= beta + gamma * s,
*    j in N
*
*  which is valid for X.
*
*  If the MIR inequality has been successfully constructed, the routine
*  returns zero. Otherwise, if b is close to nearest integer, there may
*  be numeric difficulties due to big coefficients; so in this case the
*  routine returns non-zero. */

static int mir_ineq(const int n, const double a[], const double b,
      double alpha[], double *beta, double *gamma)
{     int j;
      double f, t;
      if (fabs(b - floor(b + .5)) < 0.01)
         return 1;
      f = b - floor(b);
      for (j = 1; j <= n; j++)
      {  t = (a[j] - floor(a[j])) - f;
         if (t <= 0.0)
            alpha[j] = floor(a[j]);
         else
            alpha[j] = floor(a[j]) + t / (1.0 - f);
      }
      *beta = floor(b);
      *gamma = 1.0 / (1.0 - f);
      return 0;
}

/***********************************************************************
*  cmir_ineq - construct c-MIR inequality
*
*  Given the mixed knapsack set
*
*      MK              |N|
*     X   = {(x,s) in Z    x R  : sum   a[j] * x[j] <= b + s,
*                      +      +  j in N
*
*             x[j] <= u[j]},
*
*  a subset C of variables to be complemented, and a divisor delta > 0,
*  this routine constructs the complemented MIR (c-MIR) inequality
*
*     sum   alpha[j] * x[j] <= beta + gamma * s,
*    j in N
*                      MK
*  which is valid for X  .
*
*  If the c-MIR inequality has been successfully constructed, the
*  routine returns zero. Otherwise, if there is a risk of numerical
*  difficulties due to big coefficients (see comments to the routine
*  mir_ineq), the routine cmir_ineq returns non-zero. */

static int cmir_ineq(const int n, const double a[], const double b,
      const double u[], const char cset[], const double delta,
      double alpha[], double *beta, double *gamma)
{     int j;
      double *aa, bb;
      aa = alpha, bb = b;
      for (j = 1; j <= n; j++)
      {  aa[j] = a[j] / delta;
         if (cset[j])
            aa[j] = - aa[j], bb -= a[j] * u[j];
      }
      bb /= delta;
      if (mir_ineq(n, aa, bb, alpha, beta, gamma)) return 1;
      for (j = 1; j <= n; j++)
      {  if (cset[j])
            alpha[j] = - alpha[j], *beta += alpha[j] * u[j];
      }
      *gamma /= delta;
      return 0;
}

/***********************************************************************
*  cmir_sep - c-MIR separation heuristic
*
*  Given the mixed knapsack set
*
*      MK              |N|
*     X   = {(x,s) in Z    x R  : sum   a[j] * x[j] <= b + s,
*                      +      +  j in N
*
*             x[j] <= u[j]}
*
*                           *   *
*  and a fractional point (x , s ), this routine tries to construct
*  c-MIR inequality
*
*     sum   alpha[j] * x[j] <= beta + gamma * s,
*    j in N
*                      MK
*  which is valid for X   and has (desirably maximal) violation at the
*  fractional point given. This is attained by choosing an appropriate
*  set C of variables to be complemented and a divisor delta > 0, which
*  together define corresponding c-MIR inequality.
*
*  If a violated c-MIR inequality has been successfully constructed,
*  the routine returns its violation:
*
*                       *                      *
*     sum   alpha[j] * x [j] - beta - gamma * s ,
*    j in N
*
*  which is positive. In case of failure the routine returns zero. */

struct vset { int j; double v; };

static int CDECL cmir_cmp(const void *p1, const void *p2)
{     const struct vset *v1 = p1, *v2 = p2;
      if (v1->v < v2->v) return -1;
      if (v1->v > v2->v) return +1;
      return 0;
}

static double cmir_sep(const int n, const double a[], const double b,
      const double u[], const double x[], const double s,
      double alpha[], double *beta, double *gamma)
{     int fail, j, k, nv, v;
      double delta, eps, d_try[1+3], r, r_best;
      char *cset;
      struct vset *vset;
      /* allocate working arrays */
      cset = xcalloc(1+n, sizeof(char));
      vset = xcalloc(1+n, sizeof(struct vset));
      /* choose initial C */
      for (j = 1; j <= n; j++)
         cset[j] = (char)(x[j] >= 0.5 * u[j]);
      /* choose initial delta */
      r_best = delta = 0.0;
      for (j = 1; j <= n; j++)
      {  xassert(a[j] != 0.0);
         /* if x[j] is close to its bounds, skip it */
         eps = 1e-9 * (1.0 + fabs(u[j]));
         if (x[j] < eps || x[j] > u[j] - eps) continue;
         /* try delta = |a[j]| to construct c-MIR inequality */
         fail = cmir_ineq(n, a, b, u, cset, fabs(a[j]), alpha, beta,
            gamma);
         if (fail) continue;
         /* compute violation */
         r = - (*beta) - (*gamma) * s;
         for (k = 1; k <= n; k++) r += alpha[k] * x[k];
         if (r_best < r) r_best = r, delta = fabs(a[j]);
      }
      if (r_best < 0.001) r_best = 0.0;
      if (r_best == 0.0) goto done;
      xassert(delta > 0.0);
      /* try to increase violation by dividing delta by 2, 4, and 8,
         respectively */
      d_try[1] = delta / 2.0;
      d_try[2] = delta / 4.0;
      d_try[3] = delta / 8.0;
      for (j = 1; j <= 3; j++)
      {  /* construct c-MIR inequality */
         fail = cmir_ineq(n, a, b, u, cset, d_try[j], alpha, beta,
            gamma);
         if (fail) continue;
         /* compute violation */
         r = - (*beta) - (*gamma) * s;
         for (k = 1; k <= n; k++) r += alpha[k] * x[k];
         if (r_best < r) r_best = r, delta = d_try[j];
      }
      /* build subset of variables lying strictly between their bounds
         and order it by nondecreasing values of |x[j] - u[j]/2| */
      nv = 0;
      for (j = 1; j <= n; j++)
      {  /* if x[j] is close to its bounds, skip it */
         eps = 1e-9 * (1.0 + fabs(u[j]));
         if (x[j] < eps || x[j] > u[j] - eps) continue;
         /* add x[j] to the subset */
         nv++;
         vset[nv].j = j;
         vset[nv].v = fabs(x[j] - 0.5 * u[j]);
      }
      qsort(&vset[1], nv, sizeof(struct vset), cmir_cmp);
      /* try to increase violation by successively complementing each
         variable in the subset */
      for (v = 1; v <= nv; v++)
      {  j = vset[v].j;
         /* replace x[j] by its complement or vice versa */
         cset[j] = (char)!cset[j];
         /* construct c-MIR inequality */
         fail = cmir_ineq(n, a, b, u, cset, delta, alpha, beta, gamma);
         /* restore the variable */
         cset[j] = (char)!cset[j];
         /* do not replace the variable in case of failure */
         if (fail) continue;
         /* compute violation */
         r = - (*beta) - (*gamma) * s;
         for (k = 1; k <= n; k++) r += alpha[k] * x[k];
         if (r_best < r) r_best = r, cset[j] = (char)!cset[j];
      }
      /* construct the best c-MIR inequality chosen */
      fail = cmir_ineq(n, a, b, u, cset, delta, alpha, beta, gamma);
      xassert(!fail);
done: /* free working arrays */
      xfree(cset);
      xfree(vset);
      /* return to the calling routine */
      return r_best;
}

static double generate(glp_mir *mir)
{     /* try to generate violated c-MIR cut for modified constraint */
      int m = mir->m;
      int n = mir->n;
      int j, k, kk, nint;
      double s, *u, *x, *alpha, r_best = 0.0, b, beta, gamma;
      spv_copy_vec(mir->cut_vec, mir->mod_vec);
      mir->cut_rhs = mir->mod_rhs;
      /* remove small terms, which can appear due to substitution of
         variable bounds */
      spv_clean_vec(mir->cut_vec, DBL_EPSILON);
#if MIR_DEBUG
      spv_check_vec(mir->cut_vec);
#endif
      /* remove positive continuous terms to obtain MK relaxation */
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (!mir->isint[k] && mir->cut_vec->val[j] > 0.0)
            mir->cut_vec->val[j] = 0.0;
      }
      spv_clean_vec(mir->cut_vec, 0.0);
#if MIR_DEBUG
      spv_check_vec(mir->cut_vec);
#endif
      /* move integer terms to the beginning of the sparse vector and
         determine the number of integer variables */
      nint = 0;
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->isint[k])
         {  double temp;
            nint++;
            /* interchange elements [nint] and [j] */
            kk = mir->cut_vec->ind[nint];
            mir->cut_vec->pos[k] = nint;
            mir->cut_vec->pos[kk] = j;
            mir->cut_vec->ind[nint] = k;
            mir->cut_vec->ind[j] = kk;
            temp = mir->cut_vec->val[nint];
            mir->cut_vec->val[nint] = mir->cut_vec->val[j];
            mir->cut_vec->val[j] = temp;
         }
      }
#if MIR_DEBUG
      spv_check_vec(mir->cut_vec);
#endif
      /* if there is no integer variable, nothing to generate */
      if (nint == 0) goto done;
      /* allocate working arrays */
      u = xcalloc(1+nint, sizeof(double));
      x = xcalloc(1+nint, sizeof(double));
      alpha = xcalloc(1+nint, sizeof(double));
      /* determine u and x */
      for (j = 1; j <= nint; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(m+1 <= k && k <= m+n);
         xassert(mir->isint[k]);
         u[j] = mir->ub[k] - mir->lb[k];
         xassert(u[j] >= 1.0);
         if (mir->subst[k] == 'L')
            x[j] = mir->x[k] - mir->lb[k];
         else if (mir->subst[k] == 'U')
            x[j] = mir->ub[k] - mir->x[k];
         else
            xassert(k != k);
#if 0 /* 06/III-2016; notorious bug reported many times */
         xassert(x[j] >= -0.001);
#else
         if (x[j] < -0.001)
         {  xprintf("glp_mir_gen: warning: x[%d] = %g\n", j, x[j]);
            r_best = 0.0;
            goto skip;
         }
#endif
         if (x[j] < 0.0) x[j] = 0.0;
      }
      /* compute s = - sum of continuous terms */
      s = 0.0;
      for (j = nint+1; j <= mir->cut_vec->nnz; j++)
      {  double x;
         k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         /* must be continuous */
         xassert(!mir->isint[k]);
         if (mir->subst[k] == 'L')
         {  xassert(mir->lb[k] != -DBL_MAX);
            kk = mir->vlb[k];
            if (kk == 0)
               x = mir->x[k] - mir->lb[k];
            else
               x = mir->x[k] - mir->lb[k] * mir->x[kk];
         }
         else if (mir->subst[k] == 'U')
         {  xassert(mir->ub[k] != +DBL_MAX);
            kk = mir->vub[k];
            if (kk == 0)
               x = mir->ub[k] - mir->x[k];
            else
               x = mir->ub[k] * mir->x[kk] - mir->x[k];
         }
         else
            xassert(k != k);
#if 0 /* 06/III-2016; notorious bug reported many times */
         xassert(x >= -0.001);
#else
         if (x < -0.001)
         {  xprintf("glp_mir_gen: warning: x = %g\n", x);
            r_best = 0.0;
            goto skip;
         }
#endif
         if (x < 0.0) x = 0.0;
         s -= mir->cut_vec->val[j] * x;
      }
      xassert(s >= 0.0);
      /* apply heuristic to obtain most violated c-MIR inequality */
      b = mir->cut_rhs;
      r_best = cmir_sep(nint, mir->cut_vec->val, b, u, x, s, alpha,
         &beta, &gamma);
      if (r_best == 0.0) goto skip;
      xassert(r_best > 0.0);
      /* convert to raw cut */
      /* sum alpha[j] * x[j] <= beta + gamma * s */
      for (j = 1; j <= nint; j++)
         mir->cut_vec->val[j] = alpha[j];
      for (j = nint+1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         if (k <= m+n) mir->cut_vec->val[j] *= gamma;
      }
      mir->cut_rhs = beta;
#if MIR_DEBUG
      spv_check_vec(mir->cut_vec);
#endif
skip: /* free working arrays */
      xfree(u);
      xfree(x);
      xfree(alpha);
done: return r_best;
}

#if MIR_DEBUG
static void check_raw_cut(glp_mir *mir, double r_best)
{     /* check raw cut before back bound substitution */
      int m = mir->m;
      int n = mir->n;
      int j, k, kk;
      double r, big, x;
      /* compute the residual r = sum a[k] * x[k] - b and determine
         big = max(1, |a[k]|, |b|) */
      r = 0.0, big = 1.0;
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->subst[k] == 'L')
         {  xassert(mir->lb[k] != -DBL_MAX);
            kk = mir->vlb[k];
            if (kk == 0)
               x = mir->x[k] - mir->lb[k];
            else
               x = mir->x[k] - mir->lb[k] * mir->x[kk];
         }
         else if (mir->subst[k] == 'U')
         {  xassert(mir->ub[k] != +DBL_MAX);
            kk = mir->vub[k];
            if (kk == 0)
               x = mir->ub[k] - mir->x[k];
            else
               x = mir->ub[k] * mir->x[kk] - mir->x[k];
         }
         else
            xassert(k != k);
         r += mir->cut_vec->val[j] * x;
         if (big < fabs(mir->cut_vec->val[j]))
            big = fabs(mir->cut_vec->val[j]);
      }
      r -= mir->cut_rhs;
      if (big < fabs(mir->cut_rhs))
         big = fabs(mir->cut_rhs);
      /* the residual must be close to r_best */
      xassert(fabs(r - r_best) <= 1e-6 * big);
      return;
}
#endif

static void back_subst(glp_mir *mir)
{     /* back substitution of original bounds */
      int m = mir->m;
      int n = mir->n;
      int j, jj, k, kk;
      /* at first, restore bounds of integer variables (because on
         restoring variable bounds of continuous variables we need
         original, not shifted, bounds of integer variables) */
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (!mir->isint[k]) continue; /* skip continuous */
         if (mir->subst[k] == 'L')
         {  /* x'[k] = x[k] - lb[k] */
            xassert(mir->lb[k] != -DBL_MAX);
            xassert(mir->vlb[k] == 0);
            mir->cut_rhs += mir->cut_vec->val[j] * mir->lb[k];
         }
         else if (mir->subst[k] == 'U')
         {  /* x'[k] = ub[k] - x[k] */
            xassert(mir->ub[k] != +DBL_MAX);
            xassert(mir->vub[k] == 0);
            mir->cut_rhs -= mir->cut_vec->val[j] * mir->ub[k];
            mir->cut_vec->val[j] = - mir->cut_vec->val[j];
         }
         else
            xassert(k != k);
      }
      /* now restore bounds of continuous variables */
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (mir->isint[k]) continue; /* skip integer */
         if (mir->subst[k] == 'L')
         {  /* x'[k] = x[k] - (lower bound) */
            xassert(mir->lb[k] != -DBL_MAX);
            kk = mir->vlb[k];
            if (kk == 0)
            {  /* x'[k] = x[k] - lb[k] */
               mir->cut_rhs += mir->cut_vec->val[j] * mir->lb[k];
            }
            else
            {  /* x'[k] = x[k] - lb[k] * x[kk] */
               jj = mir->cut_vec->pos[kk];
#if 0
               xassert(jj != 0);
#else
               if (jj == 0)
               {  spv_set_vj(mir->cut_vec, kk, 1.0);
                  jj = mir->cut_vec->pos[kk];
                  xassert(jj != 0);
                  mir->cut_vec->val[jj] = 0.0;
               }
#endif
               mir->cut_vec->val[jj] -= mir->cut_vec->val[j] *
                  mir->lb[k];
            }
         }
         else if (mir->subst[k] == 'U')
         {  /* x'[k] = (upper bound) - x[k] */
            xassert(mir->ub[k] != +DBL_MAX);
            kk = mir->vub[k];
            if (kk == 0)
            {  /* x'[k] = ub[k] - x[k] */
               mir->cut_rhs -= mir->cut_vec->val[j] * mir->ub[k];
            }
            else
            {  /* x'[k] = ub[k] * x[kk] - x[k] */
               jj = mir->cut_vec->pos[kk];
               if (jj == 0)
               {  spv_set_vj(mir->cut_vec, kk, 1.0);
                  jj = mir->cut_vec->pos[kk];
                  xassert(jj != 0);
                  mir->cut_vec->val[jj] = 0.0;
               }
               mir->cut_vec->val[jj] += mir->cut_vec->val[j] *
                  mir->ub[k];
            }
            mir->cut_vec->val[j] = - mir->cut_vec->val[j];
         }
         else
            xassert(k != k);
      }
#if MIR_DEBUG
      spv_check_vec(mir->cut_vec);
#endif
      return;
}

#if MIR_DEBUG
static void check_cut_row(glp_mir *mir, double r_best)
{     /* check the cut after back bound substitution or elimination of
         auxiliary variables */
      int m = mir->m;
      int n = mir->n;
      int j, k;
      double r, big;
      /* compute the residual r = sum a[k] * x[k] - b and determine
         big = max(1, |a[k]|, |b|) */
      r = 0.0, big = 1.0;
      for (j = 1; j <= mir->cut_vec->nnz; j++)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         r += mir->cut_vec->val[j] * mir->x[k];
         if (big < fabs(mir->cut_vec->val[j]))
            big = fabs(mir->cut_vec->val[j]);
      }
      r -= mir->cut_rhs;
      if (big < fabs(mir->cut_rhs))
         big = fabs(mir->cut_rhs);
      /* the residual must be close to r_best */
      xassert(fabs(r - r_best) <= 1e-6 * big);
      return;
}
#endif

static void subst_aux_vars(glp_prob *mip, glp_mir *mir)
{     /* final substitution to eliminate auxiliary variables */
      int m = mir->m;
      int n = mir->n;
      GLPAIJ *aij;
      int j, k, kk, jj;
      for (j = mir->cut_vec->nnz; j >= 1; j--)
      {  k = mir->cut_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (k > m) continue; /* skip structurals */
         for (aij = mip->row[k]->ptr; aij != NULL; aij = aij->r_next)
         {  kk = m + aij->col->j; /* structural */
            jj = mir->cut_vec->pos[kk];
            if (jj == 0)
            {  spv_set_vj(mir->cut_vec, kk, 1.0);
               jj = mir->cut_vec->pos[kk];
               mir->cut_vec->val[jj] = 0.0;
            }
            mir->cut_vec->val[jj] += mir->cut_vec->val[j] * aij->val;
         }
         mir->cut_vec->val[j] = 0.0;
      }
      spv_clean_vec(mir->cut_vec, 0.0);
      return;
}

static void add_cut(glp_mir *mir, glp_prob *pool)
{     /* add constructed cut inequality to the cut pool */
      int m = mir->m;
      int n = mir->n;
      int j, k, len;
      int *ind = xcalloc(1+n, sizeof(int));
      double *val = xcalloc(1+n, sizeof(double));
      len = 0;
      for (j = mir->cut_vec->nnz; j >= 1; j--)
      {  k = mir->cut_vec->ind[j];
         xassert(m+1 <= k && k <= m+n);
         len++, ind[len] = k - m, val[len] = mir->cut_vec->val[j];
      }
#if 0
#if 0
      ios_add_cut_row(tree, pool, GLP_RF_MIR, len, ind, val, GLP_UP,
         mir->cut_rhs);
#else
      glp_ios_add_row(tree, NULL, GLP_RF_MIR, 0, len, ind, val, GLP_UP,
         mir->cut_rhs);
#endif
#else
      {  int i;
         i = glp_add_rows(pool, 1);
         glp_set_row_bnds(pool, i, GLP_UP, 0, mir->cut_rhs);
         glp_set_mat_row(pool, i, len, ind, val);
      }
#endif
      xfree(ind);
      xfree(val);
      return;
}

#if 0 /* 29/II-2016 by Chris */
static int aggregate_row(glp_prob *mip, glp_mir *mir)
#else
static int aggregate_row(glp_prob *mip, glp_mir *mir, SPV *v)
#endif
{     /* try to aggregate another row */
      int m = mir->m;
      int n = mir->n;
      GLPAIJ *aij;
#if 0 /* 29/II-2016 by Chris */
      SPV *v;
#endif
      int ii, j, jj, k, kk, kappa = 0, ret = 0;
      double d1, d2, d, d_max = 0.0;
      /* choose appropriate structural variable in the aggregated row
         to be substituted */
      for (j = 1; j <= mir->agg_vec->nnz; j++)
      {  k = mir->agg_vec->ind[j];
         xassert(1 <= k && k <= m+n);
         if (k <= m) continue; /* skip auxiliary var */
         if (mir->isint[k]) continue; /* skip integer var */
         if (fabs(mir->agg_vec->val[j]) < 0.001) continue;
         /* compute distance from x[k] to its lower bound */
         kk = mir->vlb[k];
         if (kk == 0)
         {  if (mir->lb[k] == -DBL_MAX)
               d1 = DBL_MAX;
            else
               d1 = mir->x[k] - mir->lb[k];
         }
         else
         {  xassert(1 <= kk && kk <= m+n);
            xassert(mir->isint[kk]);
            xassert(mir->lb[k] != -DBL_MAX);
            d1 = mir->x[k] - mir->lb[k] * mir->x[kk];
         }
         /* compute distance from x[k] to its upper bound */
         kk = mir->vub[k];
         if (kk == 0)
         {  if (mir->vub[k] == +DBL_MAX)
               d2 = DBL_MAX;
            else
               d2 = mir->ub[k] - mir->x[k];
         }
         else
         {  xassert(1 <= kk && kk <= m+n);
            xassert(mir->isint[kk]);
            xassert(mir->ub[k] != +DBL_MAX);
            d2 = mir->ub[k] * mir->x[kk] - mir->x[k];
         }
         /* x[k] cannot be free */
         xassert(d1 != DBL_MAX || d2 != DBL_MAX);
         /* d = min(d1, d2) */
         d = (d1 <= d2 ? d1 : d2);
         xassert(d != DBL_MAX);
         /* should not be close to corresponding bound */
         if (d < 0.001) continue;
         if (d_max < d) d_max = d, kappa = k;
      }
      if (kappa == 0)
      {  /* nothing chosen */
         ret = 1;
         goto done;
      }
      /* x[kappa] has been chosen */
      xassert(m+1 <= kappa && kappa <= m+n);
      xassert(!mir->isint[kappa]);
      /* find another row, which have not been used yet, to eliminate
         x[kappa] from the aggregated row */
#if 0 /* 29/II-2016 by Chris */
      for (ii = 1; ii <= m; ii++)
      {  if (mir->skip[ii]) continue;
         for (aij = mip->row[ii]->ptr; aij != NULL; aij = aij->r_next)
            if (aij->col->j == kappa - m) break;
         if (aij != NULL && fabs(aij->val) >= 0.001) break;
#else
      ii = 0;
      for (aij = mip->col[kappa - m]->ptr; aij != NULL;
         aij = aij->c_next)
      {  if (aij->row->i > m) continue;
         if (mir->skip[aij->row->i]) continue;
         if (fabs(aij->val) >= 0.001)
         {  ii = aij->row->i;
            break;
         }
#endif
      }
#if 0 /* 29/II-2016 by Chris */
      if (ii > m)
#else
      if (ii == 0)
#endif
      {  /* nothing found */
         ret = 2;
         goto done;
      }
      /* row ii has been found; include it in the aggregated list */
      mir->agg_cnt++;
      xassert(mir->agg_cnt <= MAXAGGR);
      mir->agg_row[mir->agg_cnt] = ii;
      mir->skip[ii] = 2;
      /* v := new row */
#if 0 /* 29/II-2016 by Chris */
      v = ios_create_vec(m+n);
#else
      spv_clear_vec(v);
#endif
      spv_set_vj(v, ii, 1.0);
      for (aij = mip->row[ii]->ptr; aij != NULL; aij = aij->r_next)
         spv_set_vj(v, m + aij->col->j, - aij->val);
#if MIR_DEBUG
      spv_check_vec(v);
#endif
      /* perform gaussian elimination to remove x[kappa] */
      j = mir->agg_vec->pos[kappa];
      xassert(j != 0);
      jj = v->pos[kappa];
      xassert(jj != 0);
      spv_linear_comb(mir->agg_vec,
         - mir->agg_vec->val[j] / v->val[jj], v);
#if 0 /* 29/II-2016 by Chris */
      ios_delete_vec(v);
#endif
      spv_set_vj(mir->agg_vec, kappa, 0.0);
#if MIR_DEBUG
      spv_check_vec(mir->agg_vec);
#endif
done: return ret;
}

int glp_mir_gen(glp_prob *mip, glp_mir *mir, glp_prob *pool)
{     /* main routine to generate MIR cuts */
      int m = mir->m;
      int n = mir->n;
      int i, nnn = 0;
      double r_best;
#if 1 /* 29/II-2016 by Chris */
      SPV *work;
#endif
      xassert(mip->m >= m);
      xassert(mip->n == n);
      /* obtain current point */
      get_current_point(mip, mir);
#if MIR_DEBUG
      /* check current point */
      check_current_point(mir);
#endif
      /* reset bound substitution flags */
      memset(&mir->subst[1], '?', m+n);
#if 1 /* 29/II-2016 by Chris */
      work = spv_create_vec(m+n);
#endif
      /* try to generate a set of violated MIR cuts */
      for (i = 1; i <= m; i++)
      {  if (mir->skip[i]) continue;
         /* use original i-th row as initial aggregated constraint */
         initial_agg_row(mip, mir, i);
loop:    ;
#if MIR_DEBUG
         /* check aggregated row */
         check_agg_row(mir);
#endif
         /* substitute fixed variables into aggregated constraint */
         subst_fixed_vars(mir);
#if MIR_DEBUG
         /* check aggregated row */
         check_agg_row(mir);
#endif
#if MIR_DEBUG
         /* check bound substitution flags */
         {  int k;
            for (k = 1; k <= m+n; k++)
               xassert(mir->subst[k] == '?');
         }
#endif
         /* apply bound substitution heuristic */
         bound_subst_heur(mir);
         /* substitute bounds and build modified constraint */
         build_mod_row(mir);
#if MIR_DEBUG
         /* check modified row */
         check_mod_row(mir);
#endif
         /* try to generate violated c-MIR cut for modified row */
         r_best = generate(mir);
         if (r_best > 0.0)
         {  /* success */
#if MIR_DEBUG
            /* check raw cut before back bound substitution */
            check_raw_cut(mir, r_best);
#endif
            /* back substitution of original bounds */
            back_subst(mir);
#if MIR_DEBUG
            /* check the cut after back bound substitution */
            check_cut_row(mir, r_best);
#endif
            /* final substitution to eliminate auxiliary variables */
            subst_aux_vars(mip, mir);
#if MIR_DEBUG
            /* check the cut after elimination of auxiliaries */
            check_cut_row(mir, r_best);
#endif
            /* add constructed cut inequality to the cut pool */
            add_cut(mir, pool), nnn++;
         }
         /* reset bound substitution flags */
         {  int j, k;
            for (j = 1; j <= mir->mod_vec->nnz; j++)
            {  k = mir->mod_vec->ind[j];
               xassert(1 <= k && k <= m+n);
               xassert(mir->subst[k] != '?');
               mir->subst[k] = '?';
            }
         }
         if (r_best == 0.0)
         {  /* failure */
            if (mir->agg_cnt < MAXAGGR)
            {  /* try to aggregate another row */
#if 0 /* 29/II-2016 by Chris */
               if (aggregate_row(mip, mir) == 0) goto loop;
#else
               if (aggregate_row(mip, mir, work) == 0) goto loop;
#endif
            }
         }
         /* unmark rows used in the aggregated constraint */
         {  int k, ii;
            for (k = 1; k <= mir->agg_cnt; k++)
            {  ii = mir->agg_row[k];
               xassert(1 <= ii && ii <= m);
               xassert(mir->skip[ii] == 2);
               mir->skip[ii] = 0;
            }
         }
      }
#if 1 /* 29/II-2016 by Chris */
      spv_delete_vec(work);
#endif
      return nnn;
}

/***********************************************************************
*  NAME
*
*  glp_mir_free - delete MIR cut generator workspace
*
*  SYNOPSIS
*
*  void glp_mir_free(glp_mir *mir);
*
*  DESCRIPTION
*
*  This routine deletes the MIR cut generator workspace and frees all
*  the memory allocated to it. */

void glp_mir_free(glp_mir *mir)
{     xfree(mir->skip);
      xfree(mir->isint);
      xfree(mir->lb);
      xfree(mir->vlb);
      xfree(mir->ub);
      xfree(mir->vub);
      xfree(mir->x);
      xfree(mir->agg_row);
      spv_delete_vec(mir->agg_vec);
      xfree(mir->subst);
      spv_delete_vec(mir->mod_vec);
      spv_delete_vec(mir->cut_vec);
      xfree(mir);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/spv.c0000644000175100001710000001633700000000000024407 0ustar00runnerdocker00000000000000/* spv.c (operations on sparse vectors) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spv.h"

/***********************************************************************
*  NAME
*
*  spv_create_vec - create sparse vector
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  SPV *spv_create_vec(int n);
*
*  DESCRIPTION
*
*  The routine spv_create_vec creates a sparse vector of dimension n,
*  which initially is a null vector.
*
*  RETURNS
*
*  The routine returns a pointer to the vector created. */

SPV *spv_create_vec(int n)
{     SPV *v;
      xassert(n >= 0);
      v = xmalloc(sizeof(SPV));
      v->n = n;
      v->nnz = 0;
      v->pos = xcalloc(1+n, sizeof(int));
      memset(&v->pos[1], 0, n * sizeof(int));
      v->ind = xcalloc(1+n, sizeof(int));
      v->val = xcalloc(1+n, sizeof(double));
      return v;
}

/***********************************************************************
*  NAME
*
*  spv_check_vec - check that sparse vector has correct representation
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_check_vec(SPV *v);
*
*  DESCRIPTION
*
*  The routine spv_check_vec checks that a sparse vector specified by
*  the parameter v has correct representation.
*
*  NOTE
*
*  Complexity of this operation is O(n). */

void spv_check_vec(SPV *v)
{     int j, k, nnz;
      xassert(v->n >= 0);
      nnz = 0;
      for (j = v->n; j >= 1; j--)
      {  k = v->pos[j];
         xassert(0 <= k && k <= v->nnz);
         if (k != 0)
         {  xassert(v->ind[k] == j);
            nnz++;
         }
      }
      xassert(v->nnz == nnz);
      return;
}

/***********************************************************************
*  NAME
*
*  spv_get_vj - retrieve component of sparse vector
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  double spv_get_vj(SPV *v, int j);
*
*  RETURNS
*
*  The routine spv_get_vj returns j-th component of a sparse vector
*  specified by the parameter v. */

double spv_get_vj(SPV *v, int j)
{     int k;
      xassert(1 <= j && j <= v->n);
      k = v->pos[j];
      xassert(0 <= k && k <= v->nnz);
      return (k == 0 ? 0.0 : v->val[k]);
}

/***********************************************************************
*  NAME
*
*  spv_set_vj - set/change component of sparse vector
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_set_vj(SPV *v, int j, double val);
*
*  DESCRIPTION
*
*  The routine spv_set_vj assigns val to j-th component of a sparse
*  vector specified by the parameter v. */

void spv_set_vj(SPV *v, int j, double val)
{     int k;
      xassert(1 <= j && j <= v->n);
      k = v->pos[j];
      if (val == 0.0)
      {  if (k != 0)
         {  /* remove j-th component */
            v->pos[j] = 0;
            if (k < v->nnz)
            {  v->pos[v->ind[v->nnz]] = k;
               v->ind[k] = v->ind[v->nnz];
               v->val[k] = v->val[v->nnz];
            }
            v->nnz--;
         }
      }
      else
      {  if (k == 0)
         {  /* create j-th component */
            k = ++(v->nnz);
            v->pos[j] = k;
            v->ind[k] = j;
         }
         v->val[k] = val;
      }
      return;
}

/***********************************************************************
*  NAME
*
*  spv_clear_vec - set all components of sparse vector to zero
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_clear_vec(SPV *v);
*
*  DESCRIPTION
*
*  The routine spv_clear_vec sets all components of a sparse vector
*  specified by the parameter v to zero. */

void spv_clear_vec(SPV *v)
{     int k;
      for (k = 1; k <= v->nnz; k++)
         v->pos[v->ind[k]] = 0;
      v->nnz = 0;
      return;
}

/***********************************************************************
*  NAME
*
*  spv_clean_vec - remove zero or small components from sparse vector
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_clean_vec(SPV *v, double eps);
*
*  DESCRIPTION
*
*  The routine spv_clean_vec removes zero components and components
*  whose magnitude is less than eps from a sparse vector specified by
*  the parameter v. If eps is 0.0, only zero components are removed. */

void spv_clean_vec(SPV *v, double eps)
{     int k, nnz;
      nnz = 0;
      for (k = 1; k <= v->nnz; k++)
      {  if (fabs(v->val[k]) == 0.0 || fabs(v->val[k]) < eps)
         {  /* remove component */
            v->pos[v->ind[k]] = 0;
         }
         else
         {  /* keep component */
            nnz++;
            v->pos[v->ind[k]] = nnz;
            v->ind[nnz] = v->ind[k];
            v->val[nnz] = v->val[k];
         }
      }
      v->nnz = nnz;
      return;
}

/***********************************************************************
*  NAME
*
*  spv_copy_vec - copy sparse vector (x := y)
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_copy_vec(SPV *x, SPV *y);
*
*  DESCRIPTION
*
*  The routine spv_copy_vec copies a sparse vector specified by the
*  parameter y to a sparse vector specified by the parameter x. */

void spv_copy_vec(SPV *x, SPV *y)
{     int j;
      xassert(x != y);
      xassert(x->n == y->n);
      spv_clear_vec(x);
      x->nnz = y->nnz;
      memcpy(&x->ind[1], &y->ind[1], x->nnz * sizeof(int));
      memcpy(&x->val[1], &y->val[1], x->nnz * sizeof(double));
      for (j = 1; j <= x->nnz; j++)
         x->pos[x->ind[j]] = j;
      return;
}

/***********************************************************************
*  NAME
*
*  spv_linear_comb - compute linear combination (x := x + a * y)
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_linear_comb(SPV *x, double a, SPV *y);
*
*  DESCRIPTION
*
*  The routine spv_linear_comb computes the linear combination
*
*     x := x + a * y,
*
*  where x and y are sparse vectors, a is a scalar. */

void spv_linear_comb(SPV *x, double a, SPV *y)
{     int j, k;
      double xj, yj;
      xassert(x != y);
      xassert(x->n == y->n);
      for (k = 1; k <= y->nnz; k++)
      {  j = y->ind[k];
         xj = spv_get_vj(x, j);
         yj = y->val[k];
         spv_set_vj(x, j, xj + a * yj);
      }
      return;
}

/***********************************************************************
*  NAME
*
*  spv_delete_vec - delete sparse vector
*
*  SYNOPSIS
*
*  #include "glpios.h"
*  void spv_delete_vec(SPV *v);
*
*  DESCRIPTION
*
*  The routine spv_delete_vec deletes a sparse vector specified by the
*  parameter v freeing all the memory allocated to this object. */

void spv_delete_vec(SPV *v)
{     /* delete sparse vector */
      xfree(v->pos);
      xfree(v->ind);
      xfree(v->val);
      xfree(v);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/intopt/spv.h0000644000175100001710000000521300000000000024403 0ustar00runnerdocker00000000000000/* spv.h (operations on sparse vectors) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2007-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPV_H
#define SPV_H

typedef struct SPV SPV;

struct SPV
{     /* sparse vector v = (v[j]) */
      int n;
      /* dimension, n >= 0 */
      int nnz;
      /* number of non-zero components, 0 <= nnz <= n */
      int *pos; /* int pos[1+n]; */
      /* pos[j] = k, 1 <= j <= n, is position of (non-zero) v[j] in the
       * arrays ind and val, where 1 <= k <= nnz; pos[j] = 0 means that
       * v[j] is structural zero */
      int *ind; /* int ind[1+n]; */
      /* ind[k] = j, 1 <= k <= nnz, is index of v[j] */
      double *val; /* double val[1+n]; */
      /* val[k], 1 <= k <= nnz, is a numeric value of v[j] */
};

#define spv_create_vec _glp_spv_create_vec
SPV *spv_create_vec(int n);
/* create sparse vector */

#define spv_check_vec _glp_spv_check_vec
void spv_check_vec(SPV *v);
/* check that sparse vector has correct representation */

#define spv_get_vj _glp_spv_get_vj
double spv_get_vj(SPV *v, int j);
/* retrieve component of sparse vector */

#define spv_set_vj _glp_spv_set_vj
void spv_set_vj(SPV *v, int j, double val);
/* set/change component of sparse vector */

#define spv_clear_vec _glp_spv_clear_vec
void spv_clear_vec(SPV *v);
/* set all components of sparse vector to zero */

#define spv_clean_vec _glp_spv_clean_vec
void spv_clean_vec(SPV *v, double eps);
/* remove zero or small components from sparse vector */

#define spv_copy_vec _glp_spv_copy_vec
void spv_copy_vec(SPV *x, SPV *y);
/* copy sparse vector (x := y) */

#define spv_linear_comb _glp_spv_linear_comb
void spv_linear_comb(SPV *x, double a, SPV *y);
/* compute linear combination (x := x + a * y) */

#define spv_delete_vec _glp_spv_delete_vec
void spv_delete_vec(SPV *v);
/* delete sparse vector */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1641822589.671143
igraph-0.9.9/vendor/source/igraph/vendor/glpk/minisat/0000755000175100001710000000000000000000000023550 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/minisat/LICENSE0000644000175100001710000000206000000000000024553 0ustar00runnerdocker00000000000000MiniSat -- Copyright (c) 2005, Niklas Sorensson

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/minisat/README0000644000175100001710000000160700000000000024434 0ustar00runnerdocker00000000000000NOTE: Files in this subdirectory are NOT part of the GLPK package, but
      are used with GLPK.

      The original code was modified according to GLPK requirements by
      Andrew Makhorin .
************************************************************************
MiniSat-C v1.14.1
========================================

* Fixed some serious bugs.
* Tweaked to be Visual Studio friendly (by Alan Mishchenko).
  This disabled reading of gzipped DIMACS files and signal handling,
  but none of these features are essential (and easy to re-enable, if
  wanted).

MiniSat-C v1.14
========================================

Ok, we get it. You hate C++. You hate templates. We agree; C++ is a
seriously messed up language. Although we are more pragmatic about the
quirks and maldesigns in C++, we sympathize with you. So here is a
pure C version of MiniSat, put together by Niklas Sorensson.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/minisat/minisat.c0000644000175100001710000011306700000000000025370 0ustar00runnerdocker00000000000000/* minisat.c */

/* Modified by Andrew Makhorin , August 2011 */
/* May 2017: Changes were made to provide 64-bit portability; thanks to
 * Chris Matrakidis  for patch */

/***********************************************************************
*  MiniSat -- Copyright (c) 2005, Niklas Sorensson
*  http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
*
*  Permission is hereby granted, free of charge, to any person
*  obtaining a copy of this software and associated documentation files
*  (the "Software"), to deal in the Software without restriction,
*  including without limitation the rights to use, copy, modify, merge,
*  publish, distribute, sublicense, and/or sell copies of the Software,
*  and to permit persons to whom the Software is furnished to do so,
*  subject to the following conditions:
*
*  The above copyright notice and this permission notice shall be
*  included in all copies or substantial portions of the Software.
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
*  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
*  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
*  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
*  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*  SOFTWARE.
***********************************************************************/
/* Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko */

#include "env.h"
#include "minisat.h"

#if 1 /* by mao */
static void *ymalloc(int size)
{     void *ptr;
      xassert(size > 0);
      ptr = malloc(size);
      if (ptr == NULL)
         xerror("MiniSat: no memory available\n");
      return ptr;
}

static void *yrealloc(void *ptr, int size)
{     xassert(size > 0);
      if (ptr == NULL)
         ptr = malloc(size);
      else
         ptr = realloc(ptr, size);
      if (ptr == NULL)
         xerror("MiniSat: no memory available\n");
      return ptr;
}

static void yfree(void *ptr)
{     xassert(ptr != NULL);
      free(ptr);
      return;
}

#define assert  xassert
#define printf  xprintf
#define fflush(f) /* nop */
#define malloc  ymalloc
#define realloc yrealloc
#define free    yfree
#define inline  /* empty */
#endif

/*====================================================================*/
/* Debug: */

#if 0
#define VERBOSEDEBUG 1
#endif

/* For derivation output (verbosity level 2) */
#define L_IND    "%-*d"
#define L_ind    solver_dlevel(s)*3+3,solver_dlevel(s)
#define L_LIT    "%sx%d"
#define L_lit(p) lit_sign(p)?"~":"", (lit_var(p))

#if 0 /* by mao */
/* Just like 'assert()' but expression will be evaluated in the release
   version as well. */
static inline void check(int expr) { assert(expr); }
#endif

#if 0 /* by mao */
static void printlits(lit* begin, lit* end)
{
    int i;
    for (i = 0; i < end - begin; i++)
        printf(L_LIT" ",L_lit(begin[i]));
}
#endif

/*====================================================================*/
/* Random numbers: */

/* Returns a random float 0 <= x < 1. Seed must never be 0. */
static inline double drand(double* seed) {
    int q;
    *seed *= 1389796;
    q = (int)(*seed / 2147483647);
    *seed -= (double)q * 2147483647;
    return *seed / 2147483647; }

/* Returns a random integer 0 <= x < size. Seed must never be 0. */
static inline int irand(double* seed, int size) {
    return (int)(drand(seed) * size); }

/*====================================================================*/
/* Predeclarations: */

static void sort(void** array, int size,
    int(*comp)(const void *, const void *));

/*====================================================================*/
/* Clause datatype + minor functions: */

#if 0 /* by mao; see minisat.h */
struct clause_t
{
    int size_learnt;
    lit lits[0];
};
#endif

#define clause_size(c) ((c)->size_learnt >> 1)

#define clause_begin(c) ((c)->lits)

#define clause_learnt(c) ((c)->size_learnt & 1)

#define clause_activity(c) \
    (*((float*)&(c)->lits[(c)->size_learnt>>1]))

#define clause_setactivity(c, a) \
    (void)(*((float*)&(c)->lits[(c)->size_learnt>>1]) = (a))

/*====================================================================*/
/* Encode literals in clause pointers: */

#if 0 /* 8/I-2017 by cmatraki (64-bit portability) */
#define clause_from_lit(l) \
      (clause*)((unsigned long)(l) + (unsigned long)(l) + 1)

#define clause_is_lit(c) \
      ((unsigned long)(c) & 1)

#define clause_read_lit(c) \
      (lit)((unsigned long)(c) >> 1)
#else
#define clause_from_lit(l) \
      (clause*)((size_t)(l) + (size_t)(l) + 1)

#define clause_is_lit(c) \
      ((size_t)(c) & 1)

#define clause_read_lit(c) \
      (lit)((size_t)(c) >> 1)
#endif

/*====================================================================*/
/* Simple helpers: */

#define solver_dlevel(s) \
    (int)veci_size(&(s)->trail_lim)

#define solver_read_wlist(s, l) \
    (vecp *)(&(s)->wlists[l])

static inline void    vecp_remove(vecp* v, void* e)
{
    void** ws = vecp_begin(v);
    int    j  = 0;

    for (; ws[j] != e  ; j++);
    assert(j < vecp_size(v));
    for (; j < vecp_size(v)-1; j++) ws[j] = ws[j+1];
    vecp_resize(v,vecp_size(v)-1);
}

/*====================================================================*/
/* Variable order functions: */

static inline void order_update(solver* s, int v)
{   /* updateorder */
    int*    orderpos = s->orderpos;
    double* activity = s->activity;
    int*    heap     = veci_begin(&s->order);
    int     i        = orderpos[v];
    int     x        = heap[i];
    int     parent   = (i - 1) / 2;

    assert(s->orderpos[v] != -1);

    while (i != 0 && activity[x] > activity[heap[parent]]){
        heap[i]           = heap[parent];
        orderpos[heap[i]] = i;
        i                 = parent;
        parent            = (i - 1) / 2;
    }
    heap[i]     = x;
    orderpos[x] = i;
}

#define order_assigned(s, v) /* nop */

static inline void order_unassigned(solver* s, int v)
{   /* undoorder */
    int* orderpos = s->orderpos;
    if (orderpos[v] == -1){
        orderpos[v] = veci_size(&s->order);
        veci_push(&s->order,v);
        order_update(s,v);
    }
}

static int order_select(solver* s, float random_var_freq)
{   /* selectvar */
    int*    heap;
    double* activity;
    int*    orderpos;

    lbool* values = s->assigns;

    /* Random decision: */
    if (drand(&s->random_seed) < random_var_freq){
        int next = irand(&s->random_seed,s->size);
        assert(next >= 0 && next < s->size);
        if (values[next] == l_Undef)
            return next;
    }

    /* Activity based decision: */

    heap     = veci_begin(&s->order);
    activity = s->activity;
    orderpos = s->orderpos;

    while (veci_size(&s->order) > 0){
        int    next  = heap[0];
        int    size  = veci_size(&s->order)-1;
        int    x     = heap[size];

        veci_resize(&s->order,size);

        orderpos[next] = -1;

        if (size > 0){
            double act   = activity[x];

            int    i     = 0;
            int    child = 1;

            while (child < size){
                if (child+1 < size
                    && activity[heap[child]] < activity[heap[child+1]])
                    child++;

                assert(child < size);

                if (act >= activity[heap[child]])
                    break;

                heap[i]           = heap[child];
                orderpos[heap[i]] = i;
                i                 = child;
                child             = 2 * child + 1;
            }
            heap[i]           = x;
            orderpos[heap[i]] = i;
        }

        if (values[next] == l_Undef)
            return next;
    }

    return var_Undef;
}

/*====================================================================*/
/* Activity functions: */

static inline void act_var_rescale(solver* s) {
    double* activity = s->activity;
    int i;
    for (i = 0; i < s->size; i++)
        activity[i] *= 1e-100;
    s->var_inc *= 1e-100;
}

static inline void act_var_bump(solver* s, int v) {
    double* activity = s->activity;
    if ((activity[v] += s->var_inc) > 1e100)
        act_var_rescale(s);

    /* printf("bump %d %f\n", v-1, activity[v]); */

    if (s->orderpos[v] != -1)
        order_update(s,v);

}

static inline void act_var_decay(solver* s)
    { s->var_inc *= s->var_decay; }

static inline void act_clause_rescale(solver* s) {
    clause** cs = (clause**)vecp_begin(&s->learnts);
    int i;
    for (i = 0; i < vecp_size(&s->learnts); i++){
        float a = clause_activity(cs[i]);
        clause_setactivity(cs[i], a * (float)1e-20);
    }
    s->cla_inc *= (float)1e-20;
}

static inline void act_clause_bump(solver* s, clause *c) {
    float a = clause_activity(c) + s->cla_inc;
    clause_setactivity(c,a);
    if (a > 1e20) act_clause_rescale(s);
}

static inline void act_clause_decay(solver* s)
    { s->cla_inc *= s->cla_decay; }

/*====================================================================*/
/* Clause functions: */

/* pre: size > 1 && no variable occurs twice
 */
static clause* clause_new(solver* s, lit* begin, lit* end, int learnt)
{
    int size;
    clause* c;
    int i;

    assert(end - begin > 1);
    assert(learnt >= 0 && learnt < 2);
    size           = end - begin;
    c              = (clause*)malloc(sizeof(clause)
                     + sizeof(lit) * size + learnt * sizeof(float));
    c->size_learnt = (size << 1) | learnt;
#if 1 /* by mao & cmatraki; non-portable check that is a fundamental  \
       * assumption of minisat code: bit 0 is used as a flag (zero    \
       * for pointer, one for shifted int) so allocated memory should \
       * be at least 16-bit aligned */
    assert(((size_t)c & 1) == 0);
#endif

    for (i = 0; i < size; i++)
        c->lits[i] = begin[i];

    if (learnt)
        *((float*)&c->lits[size]) = 0.0;

    assert(begin[0] >= 0);
    assert(begin[0] < s->size*2);
    assert(begin[1] >= 0);
    assert(begin[1] < s->size*2);

    assert(lit_neg(begin[0]) < s->size*2);
    assert(lit_neg(begin[1]) < s->size*2);

    /* vecp_push(solver_read_wlist(s,lit_neg(begin[0])),(void*)c); */
    /* vecp_push(solver_read_wlist(s,lit_neg(begin[1])),(void*)c); */

    vecp_push(solver_read_wlist(s,lit_neg(begin[0])),
        (void*)(size > 2 ? c : clause_from_lit(begin[1])));
    vecp_push(solver_read_wlist(s,lit_neg(begin[1])),
        (void*)(size > 2 ? c : clause_from_lit(begin[0])));

    return c;
}

static void clause_remove(solver* s, clause* c)
{
    lit* lits = clause_begin(c);
    assert(lit_neg(lits[0]) < s->size*2);
    assert(lit_neg(lits[1]) < s->size*2);

    /* vecp_remove(solver_read_wlist(s,lit_neg(lits[0])),(void*)c); */
    /* vecp_remove(solver_read_wlist(s,lit_neg(lits[1])),(void*)c); */

    assert(lits[0] < s->size*2);
    vecp_remove(solver_read_wlist(s,lit_neg(lits[0])),
        (void*)(clause_size(c) > 2 ? c : clause_from_lit(lits[1])));
    vecp_remove(solver_read_wlist(s,lit_neg(lits[1])),
        (void*)(clause_size(c) > 2 ? c : clause_from_lit(lits[0])));

    if (clause_learnt(c)){
        s->stats.learnts--;
        s->stats.learnts_literals -= clause_size(c);
    }else{
        s->stats.clauses--;
        s->stats.clauses_literals -= clause_size(c);
    }

    free(c);
}

static lbool clause_simplify(solver* s, clause* c)
{
    lit*   lits   = clause_begin(c);
    lbool* values = s->assigns;
    int i;

    assert(solver_dlevel(s) == 0);

    for (i = 0; i < clause_size(c); i++){
        lbool sig = !lit_sign(lits[i]); sig += sig - 1;
        if (values[lit_var(lits[i])] == sig)
            return l_True;
    }
    return l_False;
}

/*====================================================================*/
/* Minor (solver) functions: */

void solver_setnvars(solver* s,int n)
{
    int var;

    if (s->cap < n){

        while (s->cap < n) s->cap = s->cap*2+1;

        s->wlists    = (vecp*)   realloc(s->wlists,
                                 sizeof(vecp)*s->cap*2);
        s->activity  = (double*) realloc(s->activity,
                                 sizeof(double)*s->cap);
        s->assigns   = (lbool*)  realloc(s->assigns,
                                 sizeof(lbool)*s->cap);
        s->orderpos  = (int*)    realloc(s->orderpos,
                                 sizeof(int)*s->cap);
        s->reasons   = (clause**)realloc(s->reasons,
                                 sizeof(clause*)*s->cap);
        s->levels    = (int*)    realloc(s->levels,
                                 sizeof(int)*s->cap);
        s->tags      = (lbool*)  realloc(s->tags,
                                 sizeof(lbool)*s->cap);
        s->trail     = (lit*)    realloc(s->trail,
                                 sizeof(lit)*s->cap);
    }

    for (var = s->size; var < n; var++){
        vecp_new(&s->wlists[2*var]);
        vecp_new(&s->wlists[2*var+1]);
        s->activity [var] = 0;
        s->assigns  [var] = l_Undef;
        s->orderpos [var] = veci_size(&s->order);
        s->reasons  [var] = (clause*)0;
        s->levels   [var] = 0;
        s->tags     [var] = l_Undef;

        /* does not hold because variables enqueued at top level will
           not be reinserted in the heap
           assert(veci_size(&s->order) == var);
         */
        veci_push(&s->order,var);
        order_update(s, var);
    }

    s->size = n > s->size ? n : s->size;
}

static inline bool enqueue(solver* s, lit l, clause* from)
{
    lbool* values = s->assigns;
    int    v      = lit_var(l);
    lbool  val    = values[v];
    lbool  sig;
#ifdef VERBOSEDEBUG
    printf(L_IND"enqueue("L_LIT")\n", L_ind, L_lit(l));
#endif

    /* lbool */ sig = !lit_sign(l); sig += sig - 1;
    if (val != l_Undef){
        return val == sig;
    }else{
        /* New fact -- store it. */
        int*     levels;
        clause** reasons;
#ifdef VERBOSEDEBUG
        printf(L_IND"bind("L_LIT")\n", L_ind, L_lit(l));
#endif
        /* int*     */ levels  = s->levels;
        /* clause** */ reasons = s->reasons;

        values [v] = sig;
        levels [v] = solver_dlevel(s);
        reasons[v] = from;
        s->trail[s->qtail++] = l;

        order_assigned(s, v);
        return true;
    }
}

static inline void assume(solver* s, lit l){
    assert(s->qtail == s->qhead);
    assert(s->assigns[lit_var(l)] == l_Undef);
#ifdef VERBOSEDEBUG
    printf(L_IND"assume("L_LIT")\n", L_ind, L_lit(l));
#endif
    veci_push(&s->trail_lim,s->qtail);
    enqueue(s,l,(clause*)0);
}

static inline void solver_canceluntil(solver* s, int level) {
    lit*     trail;
    lbool*   values;
    clause** reasons;
    int      bound;
    int      c;

    if (solver_dlevel(s) <= level)
        return;

    trail   = s->trail;
    values  = s->assigns;
    reasons = s->reasons;
    bound   = (veci_begin(&s->trail_lim))[level];

    for (c = s->qtail-1; c >= bound; c--) {
        int     x  = lit_var(trail[c]);
        values [x] = l_Undef;
        reasons[x] = (clause*)0;
    }

    for (c = s->qhead-1; c >= bound; c--)
        order_unassigned(s,lit_var(trail[c]));

    s->qhead = s->qtail = bound;
    veci_resize(&s->trail_lim,level);
}

static void solver_record(solver* s, veci* cls)
{
    lit*    begin = veci_begin(cls);
    lit*    end   = begin + veci_size(cls);
    clause* c     = (veci_size(cls) > 1) ? clause_new(s,begin,end,1)
                                         : (clause*)0;
    enqueue(s,*begin,c);

    assert(veci_size(cls) > 0);

    if (c != 0) {
        vecp_push(&s->learnts,c);
        act_clause_bump(s,c);
        s->stats.learnts++;
        s->stats.learnts_literals += veci_size(cls);
    }
}

static double solver_progress(solver* s)
{
    lbool*  values = s->assigns;
    int*    levels = s->levels;
    int     i;

    double  progress = 0;
    double  F        = 1.0 / s->size;
    for (i = 0; i < s->size; i++)
        if (values[i] != l_Undef)
            progress += pow(F, levels[i]);
    return progress / s->size;
}

/*====================================================================*/
/* Major methods: */

static bool solver_lit_removable(solver* s, lit l, int minl)
{
    lbool*   tags    = s->tags;
    clause** reasons = s->reasons;
    int*     levels  = s->levels;
    int      top     = veci_size(&s->tagged);

    assert(lit_var(l) >= 0 && lit_var(l) < s->size);
    assert(reasons[lit_var(l)] != 0);
    veci_resize(&s->stack,0);
    veci_push(&s->stack,lit_var(l));

    while (veci_size(&s->stack) > 0){
        clause* c;
        int v = veci_begin(&s->stack)[veci_size(&s->stack)-1];
        assert(v >= 0 && v < s->size);
        veci_resize(&s->stack,veci_size(&s->stack)-1);
        assert(reasons[v] != 0);
        c    = reasons[v];

        if (clause_is_lit(c)){
            int v = lit_var(clause_read_lit(c));
            if (tags[v] == l_Undef && levels[v] != 0){
                if (reasons[v] != 0
                    && ((1 << (levels[v] & 31)) & minl)){
                    veci_push(&s->stack,v);
                    tags[v] = l_True;
                    veci_push(&s->tagged,v);
                }else{
                    int* tagged = veci_begin(&s->tagged);
                    int j;
                    for (j = top; j < veci_size(&s->tagged); j++)
                        tags[tagged[j]] = l_Undef;
                    veci_resize(&s->tagged,top);
                    return false;
                }
            }
        }else{
            lit*    lits = clause_begin(c);
            int     i, j;

            for (i = 1; i < clause_size(c); i++){
                int v = lit_var(lits[i]);
                if (tags[v] == l_Undef && levels[v] != 0){
                    if (reasons[v] != 0
                        && ((1 << (levels[v] & 31)) & minl)){

                        veci_push(&s->stack,lit_var(lits[i]));
                        tags[v] = l_True;
                        veci_push(&s->tagged,v);
                    }else{
                        int* tagged = veci_begin(&s->tagged);
                        for (j = top; j < veci_size(&s->tagged); j++)
                            tags[tagged[j]] = l_Undef;
                        veci_resize(&s->tagged,top);
                        return false;
                    }
                }
            }
        }
    }

    return true;
}

static void solver_analyze(solver* s, clause* c, veci* learnt)
{
    lit*     trail   = s->trail;
    lbool*   tags    = s->tags;
    clause** reasons = s->reasons;
    int*     levels  = s->levels;
    int      cnt     = 0;
    lit      p       = lit_Undef;
    int      ind     = s->qtail-1;
    lit*     lits;
    int      i, j, minl;
    int*     tagged;

    veci_push(learnt,lit_Undef);

    do{
        assert(c != 0);

        if (clause_is_lit(c)){
            lit q = clause_read_lit(c);
            assert(lit_var(q) >= 0 && lit_var(q) < s->size);
            if (tags[lit_var(q)] == l_Undef && levels[lit_var(q)] > 0){
                tags[lit_var(q)] = l_True;
                veci_push(&s->tagged,lit_var(q));
                act_var_bump(s,lit_var(q));
                if (levels[lit_var(q)] == solver_dlevel(s))
                    cnt++;
                else
                    veci_push(learnt,q);
            }
        }else{

            if (clause_learnt(c))
                act_clause_bump(s,c);

            lits = clause_begin(c);
            /* printlits(lits,lits+clause_size(c)); printf("\n"); */
            for (j = (p == lit_Undef ? 0 : 1); j < clause_size(c); j++){
                lit q = lits[j];
                assert(lit_var(q) >= 0 && lit_var(q) < s->size);
                if (tags[lit_var(q)] == l_Undef
                    && levels[lit_var(q)] > 0){
                    tags[lit_var(q)] = l_True;
                    veci_push(&s->tagged,lit_var(q));
                    act_var_bump(s,lit_var(q));
                    if (levels[lit_var(q)] == solver_dlevel(s))
                        cnt++;
                    else
                        veci_push(learnt,q);
                }
            }
        }

        while (tags[lit_var(trail[ind--])] == l_Undef);

        p = trail[ind+1];
        c = reasons[lit_var(p)];
        cnt--;

    }while (cnt > 0);

    *veci_begin(learnt) = lit_neg(p);

    lits = veci_begin(learnt);
    minl = 0;
    for (i = 1; i < veci_size(learnt); i++){
        int lev = levels[lit_var(lits[i])];
        minl    |= 1 << (lev & 31);
    }

    /* simplify (full) */
    for (i = j = 1; i < veci_size(learnt); i++){
        if (reasons[lit_var(lits[i])] == 0
            || !solver_lit_removable(s,lits[i],minl))
            lits[j++] = lits[i];
    }

    /* update size of learnt + statistics */
    s->stats.max_literals += veci_size(learnt);
    veci_resize(learnt,j);
    s->stats.tot_literals += j;

    /* clear tags */
    tagged = veci_begin(&s->tagged);
    for (i = 0; i < veci_size(&s->tagged); i++)
        tags[tagged[i]] = l_Undef;
    veci_resize(&s->tagged,0);

#ifdef DEBUG
    for (i = 0; i < s->size; i++)
        assert(tags[i] == l_Undef);
#endif

#ifdef VERBOSEDEBUG
    printf(L_IND"Learnt {", L_ind);
    for (i = 0; i < veci_size(learnt); i++)
        printf(" "L_LIT, L_lit(lits[i]));
#endif
    if (veci_size(learnt) > 1){
        int max_i = 1;
        int max   = levels[lit_var(lits[1])];
        lit tmp;

        for (i = 2; i < veci_size(learnt); i++)
            if (levels[lit_var(lits[i])] > max){
                max   = levels[lit_var(lits[i])];
                max_i = i;
            }

        tmp         = lits[1];
        lits[1]     = lits[max_i];
        lits[max_i] = tmp;
    }
#ifdef VERBOSEDEBUG
    {
        int lev = veci_size(learnt) > 1 ? levels[lit_var(lits[1])] : 0;
        printf(" } at level %d\n", lev);
    }
#endif
}

clause* solver_propagate(solver* s)
{
    lbool*  values = s->assigns;
    clause* confl  = (clause*)0;
    lit*    lits;

    /* printf("solver_propagate\n"); */
    while (confl == 0 && s->qtail - s->qhead > 0){
        lit  p  = s->trail[s->qhead++];
        vecp* ws = solver_read_wlist(s,p);
        clause **begin = (clause**)vecp_begin(ws);
        clause **end   = begin + vecp_size(ws);
        clause **i, **j;

        s->stats.propagations++;
        s->simpdb_props--;

        /* printf("checking lit %d: "L_LIT"\n", veci_size(ws),
               L_lit(p)); */
        for (i = j = begin; i < end; ){
            if (clause_is_lit(*i)){
                *j++ = *i;
                if (!enqueue(s,clause_read_lit(*i),clause_from_lit(p))){
                    confl = s->binary;
                    (clause_begin(confl))[1] = lit_neg(p);
                    (clause_begin(confl))[0] = clause_read_lit(*i++);

                    /* Copy the remaining watches: */
                    while (i < end)
                        *j++ = *i++;
                }
            }else{
                lit false_lit;
                lbool sig;

                lits = clause_begin(*i);

                /* Make sure the false literal is data[1]: */
                false_lit = lit_neg(p);
                if (lits[0] == false_lit){
                    lits[0] = lits[1];
                    lits[1] = false_lit;
                }
                assert(lits[1] == false_lit);
                /* printf("checking clause: ");
                   printlits(lits, lits+clause_size(*i));
                   printf("\n"); */

                /* If 0th watch is true, then clause is already
                   satisfied. */
                sig = !lit_sign(lits[0]); sig += sig - 1;
                if (values[lit_var(lits[0])] == sig){
                    *j++ = *i;
                }else{
                    /* Look for new watch: */
                    lit* stop = lits + clause_size(*i);
                    lit* k;
                    for (k = lits + 2; k < stop; k++){
                        lbool sig = lit_sign(*k); sig += sig - 1;
                        if (values[lit_var(*k)] != sig){
                            lits[1] = *k;
                            *k = false_lit;
                            vecp_push(solver_read_wlist(s,
                                lit_neg(lits[1])),*i);
                            goto next; }
                    }

                    *j++ = *i;
                    /* Clause is unit under assignment: */
                    if (!enqueue(s,lits[0], *i)){
                        confl = *i++;
                        /* Copy the remaining watches: */
                        while (i < end)
                            *j++ = *i++;
                    }
                }
            }
        next:
            i++;
        }

        s->stats.inspects += j - (clause**)vecp_begin(ws);
        vecp_resize(ws,j - (clause**)vecp_begin(ws));
    }

    return confl;
}

static inline int clause_cmp (const void* x, const void* y) {
    return clause_size((clause*)x) > 2
           && (clause_size((clause*)y) == 2
               || clause_activity((clause*)x)
                  < clause_activity((clause*)y)) ? -1 : 1; }

void solver_reducedb(solver* s)
{
    int      i, j;
    double   extra_lim = s->cla_inc / vecp_size(&s->learnts);
             /* Remove any clause below this activity */
    clause** learnts = (clause**)vecp_begin(&s->learnts);
    clause** reasons = s->reasons;

    sort(vecp_begin(&s->learnts), vecp_size(&s->learnts), clause_cmp);

    for (i = j = 0; i < vecp_size(&s->learnts) / 2; i++){
        if (clause_size(learnts[i]) > 2
            && reasons[lit_var(*clause_begin(learnts[i]))]
               != learnts[i])
            clause_remove(s,learnts[i]);
        else
            learnts[j++] = learnts[i];
    }
    for (; i < vecp_size(&s->learnts); i++){
        if (clause_size(learnts[i]) > 2
            && reasons[lit_var(*clause_begin(learnts[i]))]
               != learnts[i]
            && clause_activity(learnts[i]) < extra_lim)
            clause_remove(s,learnts[i]);
        else
            learnts[j++] = learnts[i];
    }

    /* printf("reducedb deleted %d\n", vecp_size(&s->learnts) - j); */

    vecp_resize(&s->learnts,j);
}

static lbool solver_search(solver* s, int nof_conflicts,
                           int nof_learnts)
{
    int*    levels          = s->levels;
    double  var_decay       = 0.95;
    double  clause_decay    = 0.999;
    double  random_var_freq = 0.02;

    int     conflictC       = 0;
    veci    learnt_clause;

    assert(s->root_level == solver_dlevel(s));

    s->stats.starts++;
    s->var_decay = (float)(1 / var_decay   );
    s->cla_decay = (float)(1 / clause_decay);
    veci_resize(&s->model,0);
    veci_new(&learnt_clause);

    for (;;){
        clause* confl = solver_propagate(s);
        if (confl != 0){
            /* CONFLICT */
            int blevel;

#ifdef VERBOSEDEBUG
            printf(L_IND"**CONFLICT**\n", L_ind);
#endif
            s->stats.conflicts++; conflictC++;
            if (solver_dlevel(s) == s->root_level){
                veci_delete(&learnt_clause);
                return l_False;
            }

            veci_resize(&learnt_clause,0);
            solver_analyze(s, confl, &learnt_clause);
            blevel = veci_size(&learnt_clause) > 1
                     ? levels[lit_var(veci_begin(&learnt_clause)[1])]
                     : s->root_level;
            blevel = s->root_level > blevel ? s->root_level : blevel;
            solver_canceluntil(s,blevel);
            solver_record(s,&learnt_clause);
            act_var_decay(s);
            act_clause_decay(s);

        }else{
            /* NO CONFLICT */
            int next;

            if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
                /* Reached bound on number of conflicts: */
                s->progress_estimate = solver_progress(s);
                solver_canceluntil(s,s->root_level);
                veci_delete(&learnt_clause);
                return l_Undef; }

            if (solver_dlevel(s) == 0)
                /* Simplify the set of problem clauses: */
                solver_simplify(s);

            if (nof_learnts >= 0
                && vecp_size(&s->learnts) - s->qtail >= nof_learnts)
                /* Reduce the set of learnt clauses: */
                solver_reducedb(s);

            /* New variable decision: */
            s->stats.decisions++;
            next = order_select(s,(float)random_var_freq);

            if (next == var_Undef){
                /* Model found: */
                lbool* values = s->assigns;
                int i;
                for (i = 0; i < s->size; i++)
                    veci_push(&s->model,(int)values[i]);
                solver_canceluntil(s,s->root_level);
                veci_delete(&learnt_clause);

                /*
                veci apa; veci_new(&apa);
                for (i = 0; i < s->size; i++)
                    veci_push(&apa,(int)(s->model.ptr[i] == l_True
                        ? toLit(i) : lit_neg(toLit(i))));
                printf("model: ");
                printlits((lit*)apa.ptr,
                    (lit*)apa.ptr + veci_size(&apa)); printf("\n");
                veci_delete(&apa);
                */

                return l_True;
            }

            assume(s,lit_neg(toLit(next)));
        }
    }

#if 0 /* by mao; unreachable code */
    return l_Undef; /* cannot happen */
#endif
}

/*====================================================================*/
/* External solver functions: */

solver* solver_new(void)
{
    solver* s = (solver*)malloc(sizeof(solver));

    /* initialize vectors */
    vecp_new(&s->clauses);
    vecp_new(&s->learnts);
    veci_new(&s->order);
    veci_new(&s->trail_lim);
    veci_new(&s->tagged);
    veci_new(&s->stack);
    veci_new(&s->model);

    /* initialize arrays */
    s->wlists    = 0;
    s->activity  = 0;
    s->assigns   = 0;
    s->orderpos  = 0;
    s->reasons   = 0;
    s->levels    = 0;
    s->tags      = 0;
    s->trail     = 0;

    /* initialize other vars */
    s->size                   = 0;
    s->cap                    = 0;
    s->qhead                  = 0;
    s->qtail                  = 0;
    s->cla_inc                = 1;
    s->cla_decay              = 1;
    s->var_inc                = 1;
    s->var_decay              = 1;
    s->root_level             = 0;
    s->simpdb_assigns         = 0;
    s->simpdb_props           = 0;
    s->random_seed            = 91648253;
    s->progress_estimate      = 0;
    s->binary                 = (clause*)malloc(sizeof(clause)
                                                + sizeof(lit)*2);
    s->binary->size_learnt    = (2 << 1);
    s->verbosity              = 0;

    s->stats.starts           = 0;
    s->stats.decisions        = 0;
    s->stats.propagations     = 0;
    s->stats.inspects         = 0;
    s->stats.conflicts        = 0;
    s->stats.clauses          = 0;
    s->stats.clauses_literals = 0;
    s->stats.learnts          = 0;
    s->stats.learnts_literals = 0;
    s->stats.max_literals     = 0;
    s->stats.tot_literals     = 0;

    return s;
}

void solver_delete(solver* s)
{
    int i;
    for (i = 0; i < vecp_size(&s->clauses); i++)
        free(vecp_begin(&s->clauses)[i]);

    for (i = 0; i < vecp_size(&s->learnts); i++)
        free(vecp_begin(&s->learnts)[i]);

    /* delete vectors */
    vecp_delete(&s->clauses);
    vecp_delete(&s->learnts);
    veci_delete(&s->order);
    veci_delete(&s->trail_lim);
    veci_delete(&s->tagged);
    veci_delete(&s->stack);
    veci_delete(&s->model);
    free(s->binary);

    /* delete arrays */
    if (s->wlists != 0){
        int i;
        for (i = 0; i < s->size*2; i++)
            vecp_delete(&s->wlists[i]);

        /* if one is different from null, all are */
        free(s->wlists);
        free(s->activity );
        free(s->assigns  );
        free(s->orderpos );
        free(s->reasons  );
        free(s->levels   );
        free(s->trail    );
        free(s->tags     );
    }

    free(s);
}

bool solver_addclause(solver* s, lit* begin, lit* end)
{
    lit *i,*j;
    int maxvar;
    lbool* values;
    lit last;

    if (begin == end) return false;

    /* printlits(begin,end); printf("\n"); */
    /* insertion sort */
    maxvar = lit_var(*begin);
    for (i = begin + 1; i < end; i++){
        lit l = *i;
        maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
        for (j = i; j > begin && *(j-1) > l; j--)
            *j = *(j-1);
        *j = l;
    }
    solver_setnvars(s,maxvar+1);

    /* printlits(begin,end); printf("\n"); */
    values = s->assigns;

    /* delete duplicates */
    last = lit_Undef;
    for (i = j = begin; i < end; i++){
        /* printf("lit: "L_LIT", value = %d\n", L_lit(*i),
        (lit_sign(*i) ? -values[lit_var(*i)] : values[lit_var(*i)])); */
        lbool sig = !lit_sign(*i); sig += sig - 1;
        if (*i == lit_neg(last) || sig == values[lit_var(*i)])
            return true;   /* tautology */
        else if (*i != last && values[lit_var(*i)] == l_Undef)
            last = *j++ = *i;
    }

    /* printf("final: "); printlits(begin,j); printf("\n"); */

    if (j == begin)          /* empty clause */
        return false;
    else if (j - begin == 1) /* unit clause */
        return enqueue(s,*begin,(clause*)0);

    /* create new clause */
    vecp_push(&s->clauses,clause_new(s,begin,j,0));

    s->stats.clauses++;
    s->stats.clauses_literals += j - begin;

    return true;
}

bool   solver_simplify(solver* s)
{
    clause** reasons;
    int type;

    assert(solver_dlevel(s) == 0);

    if (solver_propagate(s) != 0)
        return false;

    if (s->qhead == s->simpdb_assigns || s->simpdb_props > 0)
        return true;

    reasons = s->reasons;
    for (type = 0; type < 2; type++){
        vecp*    cs  = type ? &s->learnts : &s->clauses;
        clause** cls = (clause**)vecp_begin(cs);

        int i, j;
        for (j = i = 0; i < vecp_size(cs); i++){
            if (reasons[lit_var(*clause_begin(cls[i]))] != cls[i] &&
                clause_simplify(s,cls[i]) == l_True)
                clause_remove(s,cls[i]);
            else
                cls[j++] = cls[i];
        }
        vecp_resize(cs,j);
    }

    s->simpdb_assigns = s->qhead;
    /* (shouldn't depend on 'stats' really, but it will do for now) */
    s->simpdb_props   = (int)(s->stats.clauses_literals
                              + s->stats.learnts_literals);

    return true;
}

bool   solver_solve(solver* s, lit* begin, lit* end)
{
    double  nof_conflicts = 100;
    double  nof_learnts   = solver_nclauses(s) / 3;
    lbool   status        = l_Undef;
    lbool*  values        = s->assigns;
    lit*    i;

    /* printf("solve: "); printlits(begin, end); printf("\n"); */
    for (i = begin; i < end; i++){
        switch (lit_sign(*i) ? -values[lit_var(*i)]
                             : values[lit_var(*i)]){
        case 1: /* l_True: */
            break;
        case 0: /* l_Undef */
            assume(s, *i);
            if (solver_propagate(s) == NULL)
                break;
            /* falltrough */
        case -1: /* l_False */
            solver_canceluntil(s, 0);
            return false;
        }
    }

    s->root_level = solver_dlevel(s);

    if (s->verbosity >= 1){
        printf("==================================[MINISAT]============"
               "=======================\n");
        printf("| Conflicts |     ORIGINAL     |              LEARNT   "
               "           | Progress |\n");
        printf("|           | Clauses Literals |   Limit Clauses Litera"
               "ls  Lit/Cl |          |\n");
        printf("======================================================="
               "=======================\n");
    }

    while (status == l_Undef){
        double Ratio = (s->stats.learnts == 0)? 0.0 :
            s->stats.learnts_literals / (double)s->stats.learnts;

        if (s->verbosity >= 1){
            printf("| %9.0f | %7.0f %8.0f | %7.0f %7.0f %8.0f %7.1f | %"
                   "6.3f %% |\n",
                (double)s->stats.conflicts,
                (double)s->stats.clauses,
                (double)s->stats.clauses_literals,
                (double)nof_learnts,
                (double)s->stats.learnts,
                (double)s->stats.learnts_literals,
                Ratio,
                s->progress_estimate*100);
            fflush(stdout);
        }
        status = solver_search(s,(int)nof_conflicts, (int)nof_learnts);
        nof_conflicts *= 1.5;
        nof_learnts   *= 1.1;
    }
    if (s->verbosity >= 1)
        printf("======================================================="
               "=======================\n");

    solver_canceluntil(s,0);
    return status != l_False;
}

int solver_nvars(solver* s)
{
    return s->size;
}

int solver_nclauses(solver* s)
{
    return vecp_size(&s->clauses);
}

int solver_nconflicts(solver* s)
{
    return (int)s->stats.conflicts;
}

/*====================================================================*/
/* Sorting functions (sigh): */

static inline void selectionsort(void** array, int size,
                                 int(*comp)(const void *, const void *))
{
    int     i, j, best_i;
    void*   tmp;

    for (i = 0; i < size-1; i++){
        best_i = i;
        for (j = i+1; j < size; j++){
            if (comp(array[j], array[best_i]) < 0)
                best_i = j;
        }
        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
    }
}

static void sortrnd(void** array, int size,
                    int(*comp)(const void *, const void *),
                    double* seed)
{
    if (size <= 15)
        selectionsort(array, size, comp);

    else{
        void*       pivot = array[irand(seed, size)];
        void*       tmp;
        int         i = -1;
        int         j = size;

        for(;;){
            do i++; while(comp(array[i], pivot)<0);
            do j--; while(comp(pivot, array[j])<0);

            if (i >= j) break;

            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
        }

        sortrnd(array    , i     , comp, seed);
        sortrnd(&array[i], size-i, comp, seed);
    }
}

static void sort(void** array, int size,
          int(*comp)(const void *, const void *))
{
    double seed = 91648253;
    sortrnd(array,size,comp,&seed);
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/minisat/minisat.h0000644000175100001710000001617600000000000025400 0ustar00runnerdocker00000000000000/* minisat.h */

/* Modified by Andrew Makhorin , August 2011 */

/***********************************************************************
*  MiniSat -- Copyright (c) 2005, Niklas Sorensson
*  http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
*
*  Permission is hereby granted, free of charge, to any person
*  obtaining a copy of this software and associated documentation files
*  (the "Software"), to deal in the Software without restriction,
*  including without limitation the rights to use, copy, modify, merge,
*  publish, distribute, sublicense, and/or sell copies of the Software,
*  and to permit persons to whom the Software is furnished to do so,
*  subject to the following conditions:
*
*  The above copyright notice and this permission notice shall be
*  included in all copies or substantial portions of the Software.
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
*  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
*  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
*  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
*  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*  SOFTWARE.
***********************************************************************/
/* Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko */

#ifndef MINISAT_H
#define MINISAT_H

/*====================================================================*/
/* Simple types: */

typedef int bool;

#define true  1
#define false 0

typedef int  lit;
#if 0 /* by mao */
typedef char lbool;
#else
typedef int lbool;
#endif

#define var_Undef (int)(-1)
#define lit_Undef (lit)(-2)

#define l_Undef (lbool)0
#define l_True  (lbool)1
#define l_False (lbool)(-1)

#define toLit(v) (lit)((v) + (v))
#define lit_neg(l) (lit)((l) ^ 1)
#define lit_var(l) (int)((l) >> 1)
#define lit_sign(l) (int)((l) & 1)

/*====================================================================*/
/* Vectors: */

/* vector of 32-bit intergers (added for 64-bit portability) */
typedef struct /* veci_t */ {
    int    size;
    int    cap;
    int*   ptr;
} veci;

#define veci_new(v) \
{   (v)->size = 0; \
    (v)->cap  = 4; \
    (v)->ptr  = (int*)malloc(sizeof(int)*(v)->cap); \
}

#define veci_delete(v) free((v)->ptr)

#define veci_begin(v) ((v)->ptr)

#define veci_size(v) ((v)->size)

#define veci_resize(v, k) (void)((v)->size = (k))
/* only safe to shrink !! */

#define veci_push(v, e) \
{   if ((v)->size == (v)->cap) \
    {   int newsize = (v)->cap * 2+1; \
        (v)->ptr = (int*)realloc((v)->ptr,sizeof(int)*newsize); \
        (v)->cap = newsize; \
    } \
    (v)->ptr[(v)->size++] = (e); \
}

/* vector of 32- or 64-bit pointers */
typedef struct /* vecp_t */ {
    int    size;
    int    cap;
    void** ptr;
} vecp;

#define vecp_new(v) \
{   (v)->size = 0; \
    (v)->cap  = 4; \
    (v)->ptr  = (void**)malloc(sizeof(void*)*(v)->cap); \
}

#define vecp_delete(v) free((v)->ptr)

#define vecp_begin(v) ((v)->ptr)

#define vecp_size(v) ((v)->size)

#define vecp_resize(v, k) (void)((v)->size = (k))
/* only safe to shrink !! */

#define vecp_push(v, e) \
{   if ((v)->size == (v)->cap) \
    {   int newsize = (v)->cap * 2+1; \
        (v)->ptr = (void**)realloc((v)->ptr,sizeof(void*)*newsize); \
        (v)->cap = newsize; \
    } \
    (v)->ptr[(v)->size++] = (e); \
}

/*====================================================================*/
/* Solver representation: */

typedef struct /* clause_t */
{
    int size_learnt;
    lit lits[1];
} clause;

typedef struct /* stats_t */
{
    double   starts, decisions, propagations, inspects, conflicts;
    double   clauses, clauses_literals, learnts, learnts_literals,
             max_literals, tot_literals;
} stats;

typedef struct /* solver_t */
{
    int      size;          /* nof variables */
    int      cap;           /* size of varmaps */
    int      qhead;         /* Head index of queue. */
    int      qtail;         /* Tail index of queue. */

    /* clauses */
    vecp     clauses;       /* List of problem constraints.
                               (contains: clause*) */
    vecp     learnts;       /* List of learnt clauses.
                               (contains: clause*) */

    /* activities */
    double   var_inc;       /* Amount to bump next variable with. */
    double   var_decay;     /* INVERSE decay factor for variable
                               activity: stores 1/decay. */
    float    cla_inc;       /* Amount to bump next clause with. */
    float    cla_decay;     /* INVERSE decay factor for clause
                               activity: stores 1/decay. */

    vecp*    wlists;
    double*  activity;      /* A heuristic measurement of the activity
                               of a variable. */
    lbool*   assigns;       /* Current values of variables. */
    int*     orderpos;      /* Index in variable order. */
    clause** reasons;
    int*     levels;
    lit*     trail;

    clause*  binary;        /* A temporary binary clause */
    lbool*   tags;
    veci     tagged;        /* (contains: var) */
    veci     stack;         /* (contains: var) */

    veci     order;         /* Variable order. (heap) (contains: var) */
    veci     trail_lim;     /* Separator indices for different decision
                               levels in 'trail'. (contains: int) */
    veci     model;         /* If problem is solved, this vector
                               contains the model (contains: lbool). */

    int      root_level;    /* Level of first proper decision. */
    int      simpdb_assigns;/* Number of top-level assignments at last
                               'simplifyDB()'. */
    int      simpdb_props;  /* Number of propagations before next
                               'simplifyDB()'. */
    double   random_seed;
    double   progress_estimate;
    int      verbosity;     /* Verbosity level.
                               0=silent,
                               1=some progress report,
                               2=everything */

    stats    stats;
} solver;

/*====================================================================*/
/* Public interface: */

#if 1 /* by mao; to keep namespace clean */
#define solver_new        _glp_minisat_new
#define solver_delete     _glp_minisat_delete
#define solver_addclause  _glp_minisat_addclause
#define solver_simplify   _glp_minisat_simplify
#define solver_solve      _glp_minisat_solve
#define solver_nvars      _glp_minisat_nvars
#define solver_nclauses   _glp_minisat_nclauses
#define solver_nconflicts _glp_minisat_nconflicts
#define solver_setnvars   _glp_minisat_setnvars
#define solver_propagate  _glp_minisat_propagate
#define solver_reducedb   _glp_minisat_reducedb
#endif

solver* solver_new(void);
void    solver_delete(solver* s);

bool    solver_addclause(solver* s, lit* begin, lit* end);
bool    solver_simplify(solver* s);
bool    solver_solve(solver* s, lit* begin, lit* end);

int     solver_nvars(solver* s);
int     solver_nclauses(solver* s);
int     solver_nconflicts(solver* s);

void    solver_setnvars(solver* s,int n);

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6751432
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/0000755000175100001710000000000000000000000023037 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/avl.c0000644000175100001710000003135700000000000023776 0ustar00runnerdocker00000000000000/* avl.c (binary search tree) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "avl.h"
#include "dmp.h"
#include "env.h"

struct AVL
{     /* AVL tree (Adelson-Velsky & Landis binary search tree) */
      DMP *pool;
      /* memory pool for allocating nodes */
      AVLNODE *root;
      /* pointer to the root node */
      int (*fcmp)(void *info, const void *key1, const void *key2);
      /* application-defined key comparison routine */
      void *info;
      /* transit pointer passed to the routine fcmp */
      int size;
      /* the tree size (the total number of nodes) */
      int height;
      /* the tree height */
};

struct AVLNODE
{     /* node of AVL tree */
      const void *key;
      /* pointer to the node key (data structure for representing keys
         is supplied by the application) */
      int rank;
      /* node rank = relative position of the node in its own subtree =
         the number of nodes in the left subtree plus one */
      int type;
      /* reserved for the application specific information */
      void *link;
      /* reserved for the application specific information */
      AVLNODE *up;
      /* pointer to the parent node */
      short int flag;
      /* node flag:
         0 - this node is the left child of its parent (or this node is
             the root of the tree and has no parent)
         1 - this node is the right child of its parent */
      short int bal;
      /* node balance = the difference between heights of the right and
         left subtrees:
         -1 - the left subtree is higher than the right one;
          0 - the left and right subtrees have the same height;
         +1 - the left subtree is lower than the right one */
      AVLNODE *left;
      /* pointer to the root of the left subtree */
      AVLNODE *right;
      /* pointer to the root of the right subtree */
};

AVL *avl_create_tree(int (*fcmp)(void *info, const void *key1,
      const void *key2), void *info)
{     /* create AVL tree */
      AVL *tree;
      tree = xmalloc(sizeof(AVL));
      tree->pool = dmp_create_pool();
      tree->root = NULL;
      tree->fcmp = fcmp;
      tree->info = info;
      tree->size = 0;
      tree->height = 0;
      return tree;
}

int avl_strcmp(void *info, const void *key1, const void *key2)
{     /* compare character string keys */
      xassert(info == info);
      return strcmp(key1, key2);
}

static AVLNODE *rotate_subtree(AVL *tree, AVLNODE *node);

AVLNODE *avl_insert_node(AVL *tree, const void *key)
{     /* insert new node into AVL tree */
      AVLNODE *p, *q, *r;
      short int flag;
      /* find an appropriate point for insertion */
      p = NULL; q = tree->root;
      while (q != NULL)
      {  p = q;
         if (tree->fcmp(tree->info, key, p->key) <= 0)
         {  flag = 0;
            q = p->left;
            p->rank++;
         }
         else
         {  flag = 1;
            q = p->right;
         }
      }
      /* create new node and insert it into the tree */
      r = dmp_get_atom(tree->pool, sizeof(AVLNODE));
      r->key = key; r->type = 0; r->link = NULL;
      r->rank = 1; r->up = p;
      r->flag = (short int)(p == NULL ? 0 : flag);
      r->bal = 0; r->left = NULL; r->right = NULL;
      tree->size++;
      if (p == NULL)
         tree->root = r;
      else
         if (flag == 0) p->left = r; else p->right = r;
      /* go upstairs to the root and correct all subtrees affected by
         insertion */
      while (p != NULL)
      {  if (flag == 0)
         {  /* the height of the left subtree of [p] is increased */
            if (p->bal > 0)
            {  p->bal = 0;
               break;
            }
            if (p->bal < 0)
            {  rotate_subtree(tree, p);
               break;
            }
            p->bal = -1; flag = p->flag; p = p->up;
         }
         else
         {  /* the height of the right subtree of [p] is increased */
            if (p->bal < 0)
            {  p->bal = 0;
               break;
            }
            if (p->bal > 0)
            {  rotate_subtree(tree, p);
               break;
            }
            p->bal = +1; flag = p->flag; p = p->up;
         }
      }
      /* if the root has been reached, the height of the entire tree is
         increased */
      if (p == NULL) tree->height++;
      return r;
}

void avl_set_node_type(AVLNODE *node, int type)
{     /* assign the type field of specified node */
      node->type = type;
      return;
}

void avl_set_node_link(AVLNODE *node, void *link)
{     /* assign the link field of specified node */
      node->link = link;
      return;
}

AVLNODE *avl_find_node(AVL *tree, const void *key)
{     /* find node in AVL tree */
      AVLNODE *p;
      int c;
      p = tree->root;
      while (p != NULL)
      {  c = tree->fcmp(tree->info, key, p->key);
         if (c == 0) break;
         p = (c < 0 ? p->left : p->right);
      }
      return p;
}

int avl_get_node_type(AVLNODE *node)
{     /* retrieve the type field of specified node */
      return node->type;
}

void *avl_get_node_link(AVLNODE *node)
{     /* retrieve the link field of specified node */
      return node->link;
}

static AVLNODE *find_next_node(AVL *tree, AVLNODE *node)
{     /* find next node in AVL tree */
      AVLNODE *p, *q;
      if (tree->root == NULL) return NULL;
      p = node;
      q = (p == NULL ? tree->root : p->right);
      if (q == NULL)
      {  /* go upstairs from the left subtree */
         for (;;)
         {  q = p->up;
            if (q == NULL) break;
            if (p->flag == 0) break;
            p = q;
         }
      }
      else
      {  /* go downstairs into the right subtree */
         for (;;)
         {  p = q->left;
            if (p == NULL) break;
            q = p;
         }
      }
      return q;
}

void avl_delete_node(AVL *tree, AVLNODE *node)
{     /* delete specified node from AVL tree */
      AVLNODE *f, *p, *q, *r, *s, *x, *y;
      short int flag;
      p = node;
      /* if both subtrees of the specified node are non-empty, the node
         should be interchanged with the next one, at least one subtree
         of which is always empty */
      if (p->left == NULL || p->right == NULL) goto skip;
      f = p->up; q = p->left;
      r = find_next_node(tree, p); s = r->right;
      if (p->right == r)
      {  if (f == NULL)
            tree->root = r;
         else
            if (p->flag == 0) f->left = r; else f->right = r;
         r->rank = p->rank; r->up = f;
         r->flag = p->flag; r->bal = p->bal;
         r->left = q; r->right = p;
         q->up = r;
         p->rank = 1; p->up = r; p->flag = 1;
         p->bal = (short int)(s == NULL ? 0 : +1);
         p->left = NULL; p->right = s;
         if (s != NULL) s->up = p;
      }
      else
      {  x = p->right; y = r->up;
         if (f == NULL)
            tree->root = r;
         else
            if (p->flag == 0) f->left = r; else f->right = r;
         r->rank = p->rank; r->up = f;
         r->flag = p->flag; r->bal = p->bal;
         r->left = q; r->right = x;
         q->up = r; x->up = r; y->left = p;
         p->rank = 1; p->up = y; p->flag = 0;
         p->bal = (short int)(s == NULL ? 0 : +1);
         p->left = NULL; p->right = s;
         if (s != NULL) s->up = p;
      }
skip: /* now the specified node [p] has at least one empty subtree;
         go upstairs to the root and adjust the rank field of all nodes
         affected by deletion */
      q = p; f = q->up;
      while (f != NULL)
      {  if (q->flag == 0) f->rank--;
         q = f; f = q->up;
      }
      /* delete the specified node from the tree */
      f = p->up; flag = p->flag;
      q = p->left != NULL ? p->left : p->right;
      if (f == NULL)
         tree->root = q;
      else
         if (flag == 0) f->left = q; else f->right = q;
      if (q != NULL) q->up = f, q->flag = flag;
      tree->size--;
      /* go upstairs to the root and correct all subtrees affected by
         deletion */
      while (f != NULL)
      {  if (flag == 0)
         {  /* the height of the left subtree of [f] is decreased */
            if (f->bal == 0)
            {  f->bal = +1;
               break;
            }
            if (f->bal < 0)
               f->bal = 0;
            else
            {  f = rotate_subtree(tree, f);
               if (f->bal < 0) break;
            }
            flag = f->flag; f = f->up;
         }
         else
         {  /* the height of the right subtree of [f] is decreased */
            if (f->bal == 0)
            {  f->bal = -1;
               break;
            }
            if (f->bal > 0)
               f->bal = 0;
            else
            {  f = rotate_subtree(tree, f);
               if (f->bal > 0) break;
            }
            flag = f->flag; f = f->up;
         }
      }
      /* if the root has been reached, the height of the entire tree is
         decreased */
      if (f == NULL) tree->height--;
      /* returns the deleted node to the memory pool */
      dmp_free_atom(tree->pool, p, sizeof(AVLNODE));
      return;
}

static AVLNODE *rotate_subtree(AVL *tree, AVLNODE *node)
{     /* restore balance of AVL subtree */
      AVLNODE *f, *p, *q, *r, *x, *y;
      xassert(node != NULL);
      p = node;
      if (p->bal < 0)
      {  /* perform negative (left) rotation */
         f = p->up; q = p->left; r = q->right;
         if (q->bal <= 0)
         {  /* perform single negative rotation */
            if (f == NULL)
               tree->root = q;
            else
               if (p->flag == 0) f->left = q; else f->right = q;
            p->rank -= q->rank;
            q->up = f; q->flag = p->flag; q->bal++; q->right = p;
            p->up = q; p->flag = 1;
            p->bal = (short int)(-q->bal); p->left = r;
            if (r != NULL) r->up = p, r->flag = 0;
            node = q;
         }
         else
         {  /* perform double negative rotation */
            x = r->left; y = r->right;
            if (f == NULL)
               tree->root = r;
            else
               if (p->flag == 0) f->left = r; else f->right = r;
            p->rank -= (q->rank + r->rank);
            r->rank += q->rank;
            p->bal = (short int)(r->bal >= 0 ? 0 : +1);
            q->bal = (short int)(r->bal <= 0 ? 0 : -1);
            r->up = f; r->flag = p->flag; r->bal = 0;
            r->left = q; r->right = p;
            p->up = r; p->flag = 1; p->left = y;
            q->up = r; q->flag = 0; q->right = x;
            if (x != NULL) x->up = q, x->flag = 1;
            if (y != NULL) y->up = p, y->flag = 0;
            node = r;
         }
      }
      else
      {  /* perform positive (right) rotation */
         f = p->up; q = p->right; r = q->left;
         if (q->bal >= 0)
         {  /* perform single positive rotation */
            if (f == NULL)
               tree->root = q;
            else
               if (p->flag == 0) f->left = q; else f->right = q;
            q->rank += p->rank;
            q->up = f; q->flag = p->flag; q->bal--; q->left = p;
            p->up = q; p->flag = 0;
            p->bal = (short int)(-q->bal); p->right = r;
            if (r != NULL) r->up = p, r->flag = 1;
            node = q;
         }
         else
         {  /* perform double positive rotation */
            x = r->left; y = r->right;
            if (f == NULL)
               tree->root = r;
            else
               if (p->flag == 0) f->left = r; else f->right = r;
            q->rank -= r->rank;
            r->rank += p->rank;
            p->bal = (short int)(r->bal <= 0 ? 0 : -1);
            q->bal = (short int)(r->bal >= 0 ? 0 : +1);
            r->up = f; r->flag = p->flag; r->bal = 0;
            r->left = p; r->right = q;
            p->up = r; p->flag = 0; p->right = x;
            q->up = r; q->flag = 1; q->left = y;
            if (x != NULL) x->up = p, x->flag = 1;
            if (y != NULL) y->up = q, y->flag = 0;
            node = r;
         }
      }
      return node;
}

void avl_delete_tree(AVL *tree)
{     /* delete AVL tree */
      dmp_delete_pool(tree->pool);
      xfree(tree);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/avl.h0000644000175100001710000000460100000000000023773 0ustar00runnerdocker00000000000000/* avl.h (binary search tree) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef AVL_H
#define AVL_H

typedef struct AVL AVL;
typedef struct AVLNODE AVLNODE;

#define avl_create_tree _glp_avl_create_tree
AVL *avl_create_tree(int (*fcmp)(void *info, const void *key1,
      const void *key2), void *info);
/* create AVL tree */

#define avl_strcmp _glp_avl_strcmp
int avl_strcmp(void *info, const void *key1, const void *key2);
/* compare character string keys */

#define avl_insert_node _glp_avl_insert_node
AVLNODE *avl_insert_node(AVL *tree, const void *key);
/* insert new node into AVL tree */

#define avl_set_node_type _glp_avl_set_node_type
void avl_set_node_type(AVLNODE *node, int type);
/* assign the type field of specified node */

#define avl_set_node_link _glp_avl_set_node_link
void avl_set_node_link(AVLNODE *node, void *link);
/* assign the link field of specified node */

#define avl_find_node _glp_avl_find_node
AVLNODE *avl_find_node(AVL *tree, const void *key);
/* find node in AVL tree */

#define avl_get_node_type _glp_avl_get_node_type
int avl_get_node_type(AVLNODE *node);
/* retrieve the type field of specified node */

#define avl_get_node_link _glp_avl_get_node_link
void *avl_get_node_link(AVLNODE *node);
/* retrieve the link field of specified node */

#define avl_delete_node _glp_avl_delete_node
void avl_delete_node(AVL *tree, AVLNODE *node);
/* delete specified node from AVL tree */

#define avl_delete_tree _glp_avl_delete_tree
void avl_delete_tree(AVL *tree);
/* delete AVL tree */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/bignum.c0000644000175100001710000002235200000000000024470 0ustar00runnerdocker00000000000000/* bignum.c (bignum arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2006-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "bignum.h"

/***********************************************************************
*  Two routines below are intended to multiply and divide unsigned
*  integer numbers of arbitrary precision.
*
*  The routines assume that an unsigned integer number is represented in
*  the positional numeral system with the base 2^16 = 65536, i.e. each
*  "digit" of the number is in the range [0, 65535] and represented as
*  a 16-bit value of the unsigned short type. In other words, a number x
*  has the following representation:
*
*         n-1
*     x = sum d[j] * 65536^j,
*         j=0
*
*  where n is the number of places (positions), and d[j] is j-th "digit"
*  of x, 0 <= d[j] <= 65535.
***********************************************************************/

/***********************************************************************
*  NAME
*
*  bigmul - multiply unsigned integer numbers of arbitrary precision
*
*  SYNOPSIS
*
*  #include "bignum.h"
*  void bigmul(int n, int m, unsigned short x[], unsigned short y[]);
*
*  DESCRIPTION
*
*  The routine bigmul multiplies unsigned integer numbers of arbitrary
*  precision.
*
*  n is the number of digits of multiplicand, n >= 1;
*
*  m is the number of digits of multiplier, m >= 1;
*
*  x is an array containing digits of the multiplicand in elements
*  x[m], x[m+1], ..., x[n+m-1]. Contents of x[0], x[1], ..., x[m-1] are
*  ignored on entry.
*
*  y is an array containing digits of the multiplier in elements y[0],
*  y[1], ..., y[m-1].
*
*  On exit digits of the product are stored in elements x[0], x[1], ...,
*  x[n+m-1]. The array y is not changed. */

void bigmul(int n, int m, unsigned short x[], unsigned short y[])
{     int i, j;
      unsigned int t;
      xassert(n >= 1);
      xassert(m >= 1);
      for (j = 0; j < m; j++) x[j] = 0;
      for (i = 0; i < n; i++)
      {  if (x[i+m])
         {  t = 0;
            for (j = 0; j < m; j++)
            {  t += (unsigned int)x[i+m] * (unsigned int)y[j] +
                    (unsigned int)x[i+j];
               x[i+j] = (unsigned short)t;
               t >>= 16;
            }
            x[i+m] = (unsigned short)t;
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  bigdiv - divide unsigned integer numbers of arbitrary precision
*
*  SYNOPSIS
*
*  #include "bignum.h"
*  void bigdiv(int n, int m, unsigned short x[], unsigned short y[]);
*
*  DESCRIPTION
*
*  The routine bigdiv divides one unsigned integer number of arbitrary
*  precision by another with the algorithm described in [1].
*
*  n is the difference between the number of digits of dividend and the
*  number of digits of divisor, n >= 0.
*
*  m is the number of digits of divisor, m >= 1.
*
*  x is an array containing digits of the dividend in elements x[0],
*  x[1], ..., x[n+m-1].
*
*  y is an array containing digits of the divisor in elements y[0],
*  y[1], ..., y[m-1]. The highest digit y[m-1] must be non-zero.
*
*  On exit n+1 digits of the quotient are stored in elements x[m],
*  x[m+1], ..., x[n+m], and m digits of the remainder are stored in
*  elements x[0], x[1], ..., x[m-1]. The array y is changed but then
*  restored.
*
*  REFERENCES
*
*  1. D. Knuth. The Art of Computer Programming. Vol. 2: Seminumerical
*  Algorithms. Stanford University, 1969. */

void bigdiv(int n, int m, unsigned short x[], unsigned short y[])
{     int i, j;
      unsigned int t;
      unsigned short d, q, r;
      xassert(n >= 0);
      xassert(m >= 1);
      xassert(y[m-1] != 0);
      /* special case when divisor has the only digit */
      if (m == 1)
      {  d = 0;
         for (i = n; i >= 0; i--)
         {  t = ((unsigned int)d << 16) + (unsigned int)x[i];
            x[i+1] = (unsigned short)(t / y[0]);
            d = (unsigned short)(t % y[0]);
         }
         x[0] = d;
         goto done;
      }
      /* multiply dividend and divisor by a normalizing coefficient in
       * order to provide the condition y[m-1] >= base / 2 */
      d = (unsigned short)(0x10000 / ((unsigned int)y[m-1] + 1));
      if (d == 1)
         x[n+m] = 0;
      else
      {  t = 0;
         for (i = 0; i < n+m; i++)
         {  t += (unsigned int)x[i] * (unsigned int)d;
            x[i] = (unsigned short)t;
            t >>= 16;
         }
         x[n+m] = (unsigned short)t;
         t = 0;
         for (j = 0; j < m; j++)
         {  t += (unsigned int)y[j] * (unsigned int)d;
            y[j] = (unsigned short)t;
            t >>= 16;
         }
      }
      /* main loop */
      for (i = n; i >= 0; i--)
      {  /* estimate and correct the current digit of quotient */
         if (x[i+m] < y[m-1])
         {  t = ((unsigned int)x[i+m] << 16) + (unsigned int)x[i+m-1];
            q = (unsigned short)(t / (unsigned int)y[m-1]);
            r = (unsigned short)(t % (unsigned int)y[m-1]);
            if (q == 0) goto putq; else goto test;
         }
         q = 0;
         r = x[i+m-1];
decr:    q--; /* if q = 0 then q-- = 0xFFFF */
         t = (unsigned int)r + (unsigned int)y[m-1];
         r = (unsigned short)t;
         if (t > 0xFFFF) goto msub;
test:    t = (unsigned int)y[m-2] * (unsigned int)q;
         if ((unsigned short)(t >> 16) > r) goto decr;
         if ((unsigned short)(t >> 16) < r) goto msub;
         if ((unsigned short)t > x[i+m-2]) goto decr;
msub:    /* now subtract divisor multiplied by the current digit of
          * quotient from the current dividend */
         if (q == 0) goto putq;
         t = 0;
         for (j = 0; j < m; j++)
         {  t += (unsigned int)y[j] * (unsigned int)q;
            if (x[i+j] < (unsigned short)t) t += 0x10000;
            x[i+j] -= (unsigned short)t;
            t >>= 16;
         }
         if (x[i+m] >= (unsigned short)t) goto putq;
         /* perform correcting addition, because the current digit of
          * quotient is greater by one than its correct value */
         q--;
         t = 0;
         for (j = 0; j < m; j++)
         {  t += (unsigned int)x[i+j] + (unsigned int)y[j];
            x[i+j] = (unsigned short)t;
            t >>= 16;
         }
putq:    /* store the current digit of quotient */
         x[i+m] = q;
      }
      /* divide divisor and remainder by the normalizing coefficient in
       * order to restore their original values */
      if (d > 1)
      {  t = 0;
         for (i = m-1; i >= 0; i--)
         {  t = (t << 16) + (unsigned int)x[i];
            x[i] = (unsigned short)(t / (unsigned int)d);
            t %= (unsigned int)d;
         }
         t = 0;
         for (j = m-1; j >= 0; j--)
         {  t = (t << 16) + (unsigned int)y[j];
            y[j] = (unsigned short)(t / (unsigned int)d);
            t %= (unsigned int)d;
         }
      }
done: return;
}

/**********************************************************************/

#ifdef GLP_TEST
#include 
#include 
#include 
#include "rng.h"

#define N_MAX 7
/* maximal number of digits in multiplicand */

#define M_MAX 5
/* maximal number of digits in multiplier */

#define N_TEST 1000000
/* number of tests */

int main(void)
{     RNG *rand;
      int d, j, n, m, test;
      unsigned short x[N_MAX], y[M_MAX], z[N_MAX+M_MAX];
      rand = rng_create_rand();
      for (test = 1; test <= N_TEST; test++)
      {  /* x[0,...,n-1] := multiplicand */
         n = 1 + rng_unif_rand(rand, N_MAX-1);
         assert(1 <= n && n <= N_MAX);
         for (j = 0; j < n; j++)
         {  d = rng_unif_rand(rand, 65536);
            assert(0 <= d && d <= 65535);
            x[j] = (unsigned short)d;
         }
         /* y[0,...,m-1] := multiplier */
         m = 1 + rng_unif_rand(rand, M_MAX-1);
         assert(1 <= m && m <= M_MAX);
         for (j = 0; j < m; j++)
         {  d = rng_unif_rand(rand, 65536);
            assert(0 <= d && d <= 65535);
            y[j] = (unsigned short)d;
         }
         if (y[m-1] == 0) y[m-1] = 1;
         /* z[0,...,n+m-1] := x * y */
         for (j = 0; j < n; j++) z[m+j] = x[j];
         bigmul(n, m, z, y);
         /* z[0,...,m-1] := z mod y, z[m,...,n+m-1] := z div y */
         bigdiv(n, m, z, y);
         /* z mod y must be 0 */
         for (j = 0; j < m; j++) assert(z[j] == 0);
         /* z div y must be x */
         for (j = 0; j < n; j++) assert(z[m+j] == x[j]);
      }
      fprintf(stderr, "%d tests successfully passed\n", N_TEST);
      rng_delete_rand(rand);
      return 0;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/bignum.h0000644000175100001710000000246400000000000024477 0ustar00runnerdocker00000000000000/* bignum.h (bignum arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2006-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef BIGNUM_H
#define BIGNUM_H

#define bigmul _glp_bigmul
void bigmul(int n, int m, unsigned short x[], unsigned short y[]);
/* multiply unsigned integer numbers of arbitrary precision */

#define bigdiv _glp_bigdiv
void bigdiv(int n, int m, unsigned short x[], unsigned short y[]);
/* divide unsigned integer numbers of arbitrary precision */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/dimacs.c0000644000175100001710000001063300000000000024446 0ustar00runnerdocker00000000000000/* dimacs.c (reading data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "dimacs.h"

void dmx_error(DMX *csa, const char *fmt, ...)
{     /* print error message and terminate processing */
      va_list arg;
      xprintf("%s:%d: error: ", csa->fname, csa->count);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      xprintf("\n");
      longjmp(csa->jump, 1);
      /* no return */
}

void dmx_warning(DMX *csa, const char *fmt, ...)
{     /* print warning message and continue processing */
      va_list arg;
      xprintf("%s:%d: warning: ", csa->fname, csa->count);
      va_start(arg, fmt);
      xvprintf(fmt, arg);
      va_end(arg);
      xprintf("\n");
      return;
}

void dmx_read_char(DMX *csa)
{     /* read character from input text file */
      int c;
      if (csa->c == '\n') csa->count++;
      c = glp_getc(csa->fp);
      if (c < 0)
      {  if (glp_ioerr(csa->fp))
            dmx_error(csa, "read error - %s", get_err_msg());
         else if (csa->c == '\n')
            dmx_error(csa, "unexpected end of file");
         else
         {  dmx_warning(csa, "missing final end of line");
            c = '\n';
         }
      }
      else if (c == '\n')
         ;
      else if (isspace(c))
         c = ' ';
      else if (iscntrl(c))
         dmx_error(csa, "invalid control character 0x%02X", c);
      csa->c = c;
      return;
}

void dmx_read_designator(DMX *csa)
{     /* read one-character line designator */
      xassert(csa->c == '\n');
      dmx_read_char(csa);
      for (;;)
      {  /* skip preceding white-space characters */
         while (csa->c == ' ')
            dmx_read_char(csa);
         if (csa->c == '\n')
         {  /* ignore empty line */
            if (!csa->empty)
            {  dmx_warning(csa, "empty line ignored");
               csa->empty = 1;
            }
            dmx_read_char(csa);
         }
         else if (csa->c == 'c')
         {  /* skip comment line */
            while (csa->c != '\n')
               dmx_read_char(csa);
            dmx_read_char(csa);
         }
         else
         {  /* hmm... looks like a line designator */
            csa->field[0] = (char)csa->c, csa->field[1] = '\0';
            /* check that it is followed by a white-space character */
            dmx_read_char(csa);
            if (!(csa->c == ' ' || csa->c == '\n'))
               dmx_error(csa, "line designator missing or invalid");
            break;
         }
      }
      return;
}

void dmx_read_field(DMX *csa)
{     /* read data field */
      int len = 0;
      /* skip preceding white-space characters */
      while (csa->c == ' ')
         dmx_read_char(csa);
      /* scan data field */
      if (csa->c == '\n')
         dmx_error(csa, "unexpected end of line");
      while (!(csa->c == ' ' || csa->c == '\n'))
      {  if (len == sizeof(csa->field)-1)
            dmx_error(csa, "data field '%.15s...' too long",
               csa->field);
         csa->field[len++] = (char)csa->c;
         dmx_read_char(csa);
      }
      csa->field[len] = '\0';
      return;
}

void dmx_end_of_line(DMX *csa)
{     /* skip white-space characters until end of line */
      while (csa->c == ' ')
         dmx_read_char(csa);
      if (csa->c != '\n')
         dmx_error(csa, "too many data fields specified");
      return;
}

void dmx_check_int(DMX *csa, double num)
{     /* print a warning if non-integer data are detected */
      if (!csa->nonint && num != floor(num))
      {  dmx_warning(csa, "non-integer data detected");
         csa->nonint = 1;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/dimacs.h0000644000175100001710000000465300000000000024460 0ustar00runnerdocker00000000000000/* dimacs.h (reading data in DIMACS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef DIMACS_H
#define DIMACS_H

#include "env.h"

typedef struct DMX DMX;

struct DMX
{     /* DIMACS data reader */
      jmp_buf jump;
      /* label for go to in case of error */
      const char *fname;
      /* name of input text file */
      glp_file *fp;
      /* stream assigned to input text file */
      int count;
      /* line count */
      int c;
      /* current character */
      char field[255+1];
      /* data field */
      int empty;
      /* warning 'empty line ignored' was printed */
      int nonint;
      /* warning 'non-integer data detected' was printed */
};

#define dmx_error _glp_dmx_error
void dmx_error(DMX *csa, const char *fmt, ...);
/* print error message and terminate processing */

#define dmx_warning _glp_dmx_warning
void dmx_warning(DMX *csa, const char *fmt, ...);
/* print warning message and continue processing */

#define dmx_read_char _glp_dmx_read_char
void dmx_read_char(DMX *csa);
/* read character from input text file */

#define dmx_read_designator _glp_dmx_read_designator
void dmx_read_designator(DMX *csa);
/* read one-character line designator */

#define dmx_read_field _glp_dmx_read_field
void dmx_read_field(DMX *csa);
/* read data field */

#define dmx_end_of_line _glp_dmx_end_of_line
void dmx_end_of_line(DMX *csa);
/* skip white-space characters until end of line */

#define dmx_check_int _glp_dmx_check_int
void dmx_check_int(DMX *csa, double num);
/* print a warning if non-integer data are detected */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/dmp.c0000644000175100001710000001561600000000000023774 0ustar00runnerdocker00000000000000/* dmp.c (dynamic memory pool) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "dmp.h"

struct DMP
{     /* dynamic memory pool */
      void *avail[32];
      /* avail[k], 0 <= k <= 31, is a pointer to first available (free)
       * atom of (k+1)*8 bytes long; at the beginning of each free atom
       * there is a pointer to another free atom of the same size */
      void *block;
      /* pointer to most recently allocated memory block; at the
       * beginning of each allocated memory block there is a pointer to
       * previously allocated memory block */
      int used;
      /* number of bytes used in most recently allocated memory block */
      size_t count;
      /* number of atoms which are currently in use */
};

#define DMP_BLK_SIZE 8000
/* size of memory blocks, in bytes, allocated for memory pools */

struct prefix
{     /* atom prefix (for debugging only) */
      DMP *pool;
      /* dynamic memory pool */
      int size;
      /* original atom size, in bytes */
};

#define prefix_size ((sizeof(struct prefix) + 7) & ~7)
/* size of atom prefix rounded up to multiple of 8 bytes */

int dmp_debug;
/* debug mode flag */

/***********************************************************************
*  NAME
*
*  dmp_create_pool - create dynamic memory pool
*
*  SYNOPSIS
*
*  #include "dmp.h"
*  DMP *dmp_create_pool(void);
*
*  DESCRIPTION
*
*  The routine dmp_create_pool creates a dynamic memory pool.
*
*  RETURNS
*
*  The routine returns a pointer to the memory pool created. */

DMP *dmp_create_pool(void)
{     DMP *pool;
      int k;
      xassert(sizeof(void *) <= 8);
      if (dmp_debug)
         xprintf("dmp_create_pool: warning: debug mode is on\n");
      pool = talloc(1, DMP);
      for (k = 0; k <= 31; k++)
         pool->avail[k] = NULL;
      pool->block = NULL;
      pool->used = DMP_BLK_SIZE;
      pool->count = 0;
      return pool;
}

/***********************************************************************
*  NAME
*
*  dmp_get_atom - get free atom from dynamic memory pool
*
*  SYNOPSIS
*
*  #include "dmp.h"
*  void *dmp_get_atom(DMP *pool, int size);
*
*  DESCRIPTION
*
*  The routine dmp_get_atom obtains a free atom (memory space) from the
*  specified memory pool.
*
*  The parameter size is the atom size, in bytes, 1 <= size <= 256.
*
*  Note that the free atom contains arbitrary data, not binary zeros.
*
*  RETURNS
*
*  The routine returns a pointer to the free atom obtained. */

void *dmp_get_atom(DMP *pool, int size)
{     void *atom;
      int k, need;
      xassert(1 <= size && size <= 256);
      /* round up atom size to multiple of 8 bytes */
      need = (size + 7) & ~7;
      /* determine number of corresponding list of free atoms */
      k = (need >> 3) - 1;
      /* obtain free atom */
      if (pool->avail[k] == NULL)
      {  /* corresponding list of free atoms is empty */
         /* if debug mode is on, add atom prefix size */
         if (dmp_debug)
            need += prefix_size;
         if (pool->used + need > DMP_BLK_SIZE)
         {  /* allocate new memory block */
            void *block = talloc(DMP_BLK_SIZE, char);
            *(void **)block = pool->block;
            pool->block = block;
            pool->used = 8; /* sufficient to store pointer */
         }
         /* allocate new atom in current memory block */
         atom = (char *)pool->block + pool->used;
         pool->used += need;
      }
      else
      {  /* obtain atom from corresponding list of free atoms */
         atom  = pool->avail[k];
         pool->avail[k] = *(void **)atom;
      }
      /* if debug mode is on, fill atom prefix */
      if (dmp_debug)
      {  ((struct prefix *)atom)->pool = pool;
         ((struct prefix *)atom)->size = size;
         atom = (char *)atom + prefix_size;
      }
      /* increase number of allocated atoms */
      pool->count++;
      return atom;
}

/***********************************************************************
*  NAME
*
*  dmp_free_atom - return atom to dynamic memory pool
*
*  SYNOPSIS
*
*  #include "dmp.h"
*  void dmp_free_atom(DMP *pool, void *atom, int size);
*
*  DESCRIPTION
*
*  The routine dmp_free_atom returns the specified atom (memory space)
*  to the specified memory pool, making the atom free.
*
*  The parameter size is the atom size, in bytes, 1 <= size <= 256.
*
*  Note that the atom can be returned only to the pool, from which it
*  was obtained, and its size must be exactly the same as on obtaining
*  it from the pool. */

void dmp_free_atom(DMP *pool, void *atom, int size)
{     int k;
      xassert(1 <= size && size <= 256);
      /* determine number of corresponding list of free atoms */
      k = ((size + 7) >> 3) - 1;
      /* if debug mode is on, check atom prefix */
      if (dmp_debug)
      {  atom = (char *)atom - prefix_size;
         xassert(((struct prefix *)atom)->pool == pool);
         xassert(((struct prefix *)atom)->size == size);
      }
      /* return atom to corresponding list of free atoms */
      *(void **)atom = pool->avail[k];
      pool->avail[k] = atom;
      /* decrease number of allocated atoms */
      xassert(pool->count > 0);
      pool->count--;
      return;
}

/***********************************************************************
*  NAME
*
*  dmp_in_use - determine how many atoms are still in use
*
*  SYNOPSIS
*
*  #include "dmp.h"
*  size_t dmp_in_use(DMP *pool);
*
*  RETURNS
*
*  The routine returns the number of atoms of the specified memory pool
*  which are still in use. */

size_t dmp_in_use(DMP *pool)
{     return
         pool->count;
}

/***********************************************************************
*  NAME
*
*  dmp_delete_pool - delete dynamic memory pool
*
*  SYNOPSIS
*
*  #include "dmp.h"
*  void dmp_delete_pool(DMP *pool);
*
*  DESCRIPTION
*
*  The routine dmp_delete_pool deletes the specified dynamic memory
*  pool freeing all the memory allocated to this object. */

void dmp_delete_pool(DMP *pool)
{     while (pool->block != NULL)
      {  void *block = pool->block;
         pool->block = *(void **)block;
         tfree(block);
      }
      tfree(pool);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/dmp.h0000644000175100001710000000354500000000000023777 0ustar00runnerdocker00000000000000/* dmp.h (dynamic memory pool) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef DMP_H
#define DMP_H

#include "stdc.h"

typedef struct DMP DMP;

#define dmp_debug _glp_dmp_debug
extern int dmp_debug;
/* debug mode flag */

#define dmp_create_pool _glp_dmp_create_pool
DMP *dmp_create_pool(void);
/* create dynamic memory pool */

#define dmp_talloc(pool, type) \
      ((type *)dmp_get_atom(pool, sizeof(type)))

#define dmp_get_atom _glp_dmp_get_atom
void *dmp_get_atom(DMP *pool, int size);
/* get free atom from dynamic memory pool */

#define dmp_tfree(pool, atom) \
      dmp_free_atom(pool, atom, sizeof(*(atom)))

#define dmp_free_atom _glp_dmp_free_atom
void dmp_free_atom(DMP *pool, void *atom, int size);
/* return atom to dynamic memory pool */

#define dmp_in_use _glp_dmp_in_use
size_t dmp_in_use(DMP *pool);
/* determine how many atoms are still in use */

#define dmp_delete_pool _glp_dmp_delete_pool
void dmp_delete_pool(DMP *pool);
/* delete dynamic memory pool */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/ffalg.c0000644000175100001710000001632200000000000024266 0ustar00runnerdocker00000000000000/* ffalg.c (Ford-Fulkerson algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ffalg.h"

/***********************************************************************
*  NAME
*
*  ffalg - Ford-Fulkerson algorithm
*
*  SYNOPSIS
*
*  #include "ffalg.h"
*  void ffalg(int nv, int na, const int tail[], const int head[],
*     int s, int t, const int cap[], int x[], char cut[]);
*
*  DESCRIPTION
*
*  The routine ffalg implements the Ford-Fulkerson algorithm to find a
*  maximal flow in the specified flow network.
*
*  INPUT PARAMETERS
*
*  nv is the number of nodes, nv >= 2.
*
*  na is the number of arcs, na >= 0.
*
*  tail[a], a = 1,...,na, is the index of tail node of arc a.
*
*  head[a], a = 1,...,na, is the index of head node of arc a.
*
*  s is the source node index, 1 <= s <= nv.
*
*  t is the sink node index, 1 <= t <= nv, t != s.
*
*  cap[a], a = 1,...,na, is the capacity of arc a, cap[a] >= 0.
*
*  NOTE: Multiple arcs are allowed, but self-loops are not allowed.
*
*  OUTPUT PARAMETERS
*
*  x[a], a = 1,...,na, is optimal value of the flow through arc a.
*
*  cut[i], i = 1,...,nv, is 1 if node i is labelled, and 0 otherwise.
*  The set of arcs, whose one endpoint is labelled and other is not,
*  defines the minimal cut corresponding to the maximal flow found.
*  If the parameter cut is NULL, the cut information are not stored.
*
*  REFERENCES
*
*  L.R.Ford, Jr., and D.R.Fulkerson, "Flows in Networks," The RAND
*  Corp., Report R-375-PR (August 1962), Chap. I "Static Maximal Flow,"
*  pp.30-33. */

void ffalg(int nv, int na, const int tail[], const int head[],
      int s, int t, const int cap[], int x[], char cut[])
{     int a, delta, i, j, k, pos1, pos2, temp,
         *ptr, *arc, *link, *list;
      /* sanity checks */
      xassert(nv >= 2);
      xassert(na >= 0);
      xassert(1 <= s && s <= nv);
      xassert(1 <= t && t <= nv);
      xassert(s != t);
      for (a = 1; a <= na; a++)
      {  i = tail[a], j = head[a];
         xassert(1 <= i && i <= nv);
         xassert(1 <= j && j <= nv);
         xassert(i != j);
         xassert(cap[a] >= 0);
      }
      /* allocate working arrays */
      ptr = xcalloc(1+nv+1, sizeof(int));
      arc = xcalloc(1+na+na, sizeof(int));
      link = xcalloc(1+nv, sizeof(int));
      list = xcalloc(1+nv, sizeof(int));
      /* ptr[i] := (degree of node i) */
      for (i = 1; i <= nv; i++)
         ptr[i] = 0;
      for (a = 1; a <= na; a++)
      {  ptr[tail[a]]++;
         ptr[head[a]]++;
      }
      /* initialize arc pointers */
      ptr[1]++;
      for (i = 1; i < nv; i++)
         ptr[i+1] += ptr[i];
      ptr[nv+1] = ptr[nv];
      /* build arc lists */
      for (a = 1; a <= na; a++)
      {  arc[--ptr[tail[a]]] = a;
         arc[--ptr[head[a]]] = a;
      }
      xassert(ptr[1] == 1);
      xassert(ptr[nv+1] == na+na+1);
      /* now the indices of arcs incident to node i are stored in
       * locations arc[ptr[i]], arc[ptr[i]+1], ..., arc[ptr[i+1]-1] */
      /* initialize arc flows */
      for (a = 1; a <= na; a++)
         x[a] = 0;
loop: /* main loop starts here */
      /* build augmenting tree rooted at s */
      /* link[i] = 0 means that node i is not labelled yet;
       * link[i] = a means that arc a immediately precedes node i */
      /* initially node s is labelled as the root */
      for (i = 1; i <= nv; i++)
         link[i] = 0;
      link[s] = -1, list[1] = s, pos1 = pos2 = 1;
      /* breadth first search */
      while (pos1 <= pos2)
      {  /* dequeue node i */
         i = list[pos1++];
         /* consider all arcs incident to node i */
         for (k = ptr[i]; k < ptr[i+1]; k++)
         {  a = arc[k];
            if (tail[a] == i)
            {  /* a = i->j is a forward arc from s to t */
               j = head[a];
               /* if node j has been labelled, skip the arc */
               if (link[j] != 0) continue;
               /* if the arc does not allow increasing the flow through
                * it, skip the arc */
               if (x[a] == cap[a]) continue;
            }
            else if (head[a] == i)
            {  /* a = i<-j is a backward arc from s to t */
               j = tail[a];
               /* if node j has been labelled, skip the arc */
               if (link[j] != 0) continue;
               /* if the arc does not allow decreasing the flow through
                * it, skip the arc */
               if (x[a] == 0) continue;
            }
            else
               xassert(a != a);
            /* label node j and enqueue it */
            link[j] = a, list[++pos2] = j;
            /* check for breakthrough */
            if (j == t) goto brkt;
         }
      }
      /* NONBREAKTHROUGH */
      /* no augmenting path exists; current flow is maximal */
      /* store minimal cut information, if necessary */
      if (cut != NULL)
      {  for (i = 1; i <= nv; i++)
            cut[i] = (char)(link[i] != 0);
      }
      goto done;
brkt: /* BREAKTHROUGH */
      /* walk through arcs of the augmenting path (s, ..., t) found in
       * the reverse order and determine maximal change of the flow */
      delta = 0;
      for (j = t; j != s; j = i)
      {  /* arc a immediately precedes node j in the path */
         a = link[j];
         if (head[a] == j)
         {  /* a = i->j is a forward arc of the cycle */
            i = tail[a];
            /* x[a] may be increased until its upper bound */
            temp = cap[a] - x[a];
         }
         else if (tail[a] == j)
         {  /* a = i<-j is a backward arc of the cycle */
            i = head[a];
            /* x[a] may be decreased until its lower bound */
            temp = x[a];
         }
         else
            xassert(a != a);
         if (delta == 0 || delta > temp) delta = temp;
      }
      xassert(delta > 0);
      /* increase the flow along the path */
      for (j = t; j != s; j = i)
      {  /* arc a immediately precedes node j in the path */
         a = link[j];
         if (head[a] == j)
         {  /* a = i->j is a forward arc of the cycle */
            i = tail[a];
            x[a] += delta;
         }
         else if (tail[a] == j)
         {  /* a = i<-j is a backward arc of the cycle */
            i = head[a];
            x[a] -= delta;
         }
         else
            xassert(a != a);
      }
      goto loop;
done: /* free working arrays */
      xfree(ptr);
      xfree(arc);
      xfree(link);
      xfree(list);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/ffalg.h0000644000175100001710000000226100000000000024270 0ustar00runnerdocker00000000000000/* ffalg.h (Ford-Fulkerson algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef FFALG_H
#define FFALG_H

#define ffalg _glp_ffalg
void ffalg(int nv, int na, const int tail[], const int head[],
      int s, int t, const int cap[], int x[], char cut[]);
/* Ford-Fulkerson algorithm */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/fp2rat.c0000644000175100001710000001177000000000000024407 0ustar00runnerdocker00000000000000/* fp2rat.c (convert floating-point number to rational number) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"

/***********************************************************************
*  NAME
*
*  fp2rat - convert floating-point number to rational number
*
*  SYNOPSIS
*
*  #include "misc.h"
*  int fp2rat(double x, double eps, double *p, double *q);
*
*  DESCRIPTION
*
*  Given a floating-point number 0 <= x < 1 the routine fp2rat finds
*  its "best" rational approximation p / q, where p >= 0 and q > 0 are
*  integer numbers, such that |x - p / q| <= eps.
*
*  RETURNS
*
*  The routine fp2rat returns the number of iterations used to achieve
*  the specified precision eps.
*
*  EXAMPLES
*
*  For x = sqrt(2) - 1 = 0.414213562373095 and eps = 1e-6 the routine
*  gives p = 408 and q = 985, where 408 / 985 = 0.414213197969543.
*
*  BACKGROUND
*
*  It is well known that every positive real number x can be expressed
*  as the following continued fraction:
*
*     x = b[0] + a[1]
*                ------------------------
*                b[1] + a[2]
*                       -----------------
*                       b[2] + a[3]
*                              ----------
*                              b[3] + ...
*
*  where:
*
*     a[k] = 1,                  k = 0, 1, 2, ...
*
*     b[k] = floor(x[k]),        k = 0, 1, 2, ...
*
*     x[0] = x,
*
*     x[k] = 1 / frac(x[k-1]),   k = 1, 2, 3, ...
*
*  To find the "best" rational approximation of x the routine computes
*  partial fractions f[k] by dropping after k terms as follows:
*
*     f[k] = A[k] / B[k],
*
*  where:
*
*     A[-1] = 1,   A[0] = b[0],   B[-1] = 0,   B[0] = 1,
*
*     A[k] = b[k] * A[k-1] + a[k] * A[k-2],
*
*     B[k] = b[k] * B[k-1] + a[k] * B[k-2].
*
*  Once the condition
*
*     |x - f[k]| <= eps
*
*  has been satisfied, the routine reports p = A[k] and q = B[k] as the
*  final answer.
*
*  In the table below here is some statistics obtained for one million
*  random numbers uniformly distributed in the range [0, 1).
*
*      eps      max p   mean p      max q    mean q  max k   mean k
*     -------------------------------------------------------------
*     1e-1          8      1.6          9       3.2    3      1.4
*     1e-2         98      6.2         99      12.4    5      2.4
*     1e-3        997     20.7        998      41.5    8      3.4
*     1e-4       9959     66.6       9960     133.5   10      4.4
*     1e-5      97403    211.7      97404     424.2   13      5.3
*     1e-6     479669    669.9     479670    1342.9   15      6.3
*     1e-7    1579030   2127.3    3962146    4257.8   16      7.3
*     1e-8   26188823   6749.4   26188824   13503.4   19      8.2
*
*  REFERENCES
*
*  W. B. Jones and W. J. Thron, "Continued Fractions: Analytic Theory
*  and Applications," Encyclopedia on Mathematics and Its Applications,
*  Addison-Wesley, 1980. */

int fp2rat(double x, double eps, double *p, double *q)
{     int k;
      double xk, Akm1, Ak, Bkm1, Bk, ak, bk, fk, temp;
      xassert(0.0 <= x && x < 1.0);
      for (k = 0; ; k++)
      {  xassert(k <= 100);
         if (k == 0)
         {  /* x[0] = x */
            xk = x;
            /* A[-1] = 1 */
            Akm1 = 1.0;
            /* A[0] = b[0] = floor(x[0]) = 0 */
            Ak = 0.0;
            /* B[-1] = 0 */
            Bkm1 = 0.0;
            /* B[0] = 1 */
            Bk = 1.0;
         }
         else
         {  /* x[k] = 1 / frac(x[k-1]) */
            temp = xk - floor(xk);
            xassert(temp != 0.0);
            xk = 1.0 / temp;
            /* a[k] = 1 */
            ak = 1.0;
            /* b[k] = floor(x[k]) */
            bk = floor(xk);
            /* A[k] = b[k] * A[k-1] + a[k] * A[k-2] */
            temp = bk * Ak + ak * Akm1;
            Akm1 = Ak, Ak = temp;
            /* B[k] = b[k] * B[k-1] + a[k] * B[k-2] */
            temp = bk * Bk + ak * Bkm1;
            Bkm1 = Bk, Bk = temp;
         }
         /* f[k] = A[k] / B[k] */
         fk = Ak / Bk;
#if 0
         print("%.*g / %.*g = %.*g",
            DBL_DIG, Ak, DBL_DIG, Bk, DBL_DIG, fk);
#endif
         if (fabs(x - fk) <= eps)
            break;
      }
      *p = Ak;
      *q = Bk;
      return k;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/fvs.c0000644000175100001710000000670100000000000024005 0ustar00runnerdocker00000000000000/* fvs.c (sparse vector in FVS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "fvs.h"

void fvs_alloc_vec(FVS *x, int n)
{     /* allocate sparse vector */
      int j;
      xassert(n >= 0);
      x->n = n;
      x->nnz = 0;
      x->ind = talloc(1+n, int);
      x->vec = talloc(1+n, double);
      for (j = 1; j <= n; j++)
         x->vec[j] = 0.0;
      return;
}

void fvs_check_vec(const FVS *x)
{     /* check sparse vector */
      /* NOTE: for testing/debugging only */
      int n = x->n;
      int nnz = x->nnz;
      int *ind = x->ind;
      double *vec = x->vec;
      char *map;
      int j, k;
      xassert(n >= 0);
      xassert(0 <= nnz && nnz <= n);
      map = talloc(1+n, char);
      for (j = 1; j <= n; j++)
         map[j] = (vec[j] != 0.0);
      for (k = 1; k <= nnz; k++)
      {  j = ind[k];
         xassert(1 <= j && j <= n);
         xassert(map[j]);
         map[j] = 0;
      }
      for (j = 1; j <= n; j++)
         xassert(!map[j]);
      tfree(map);
      return;
}

void fvs_gather_vec(FVS *x, double eps)
{     /* gather sparse vector */
      int n = x->n;
      int *ind = x->ind;
      double *vec = x->vec;
      int j, nnz = 0;
      for (j = n; j >= 1; j--)
      {  if (-eps < vec[j] && vec[j] < +eps)
            vec[j] = 0.0;
         else
            ind[++nnz] = j;
      }
      x->nnz = nnz;
      return;
}

void fvs_clear_vec(FVS *x)
{     /* clear sparse vector */
      int *ind = x->ind;
      double *vec = x->vec;
      int k;
      for (k = x->nnz; k >= 1; k--)
         vec[ind[k]] = 0.0;
      x->nnz = 0;
      return;
}

void fvs_copy_vec(FVS *x, const FVS *y)
{     /* copy sparse vector */
      int *x_ind = x->ind;
      double *x_vec = x->vec;
      int *y_ind = y->ind;
      double *y_vec = y->vec;
      int j, k;
      xassert(x != y);
      xassert(x->n == y->n);
      fvs_clear_vec(x);
      for (k = x->nnz = y->nnz; k >= 1; k--)
      {  j = x_ind[k] = y_ind[k];
         x_vec[j] = y_vec[j];
      }
      return;
}

void fvs_adjust_vec(FVS *x, double eps)
{     /* replace tiny vector elements by exact zeros */
      int nnz = x->nnz;
      int *ind = x->ind;
      double *vec = x->vec;
      int j, k, cnt = 0;
      for (k = 1; k <= nnz; k++)
      {  j = ind[k];
         if (-eps < vec[j] && vec[j] < +eps)
            vec[j] = 0.0;
         else
            ind[++cnt] = j;
      }
      x->nnz = cnt;
      return;
}

void fvs_free_vec(FVS *x)
{     /* deallocate sparse vector */
      tfree(x->ind);
      tfree(x->vec);
      x->n = x->nnz = -1;
      x->ind = NULL;
      x->vec = NULL;
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/fvs.h0000644000175100001710000000460400000000000024012 0ustar00runnerdocker00000000000000/* fvs.h (sparse vector in FVS format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef FVS_H
#define FVS_H

typedef struct FVS FVS;

struct FVS
{     /* sparse vector in FVS (Full Vector Storage) format */
      int n;
      /* vector dimension (total number of elements) */
      int nnz;
      /* number of non-zero elements, 0 <= nnz <= n */
      int *ind; /* int ind[1+n]; */
      /* ind[0] is not used;
       * ind[k] = j, 1 <= k <= nnz, means that vec[j] != 0
       * non-zero indices in the array ind are stored in arbitrary
       * order; if vec[j] = 0, its index j SHOULD NOT be presented in
       * the array ind */
      double *vec; /* double vec[1+n]; */
      /* vec[0] is not used;
       * vec[j], 1 <= j <= n, is a numeric value of j-th element */
};

#define fvs_alloc_vec _glp_fvs_alloc_vec
void fvs_alloc_vec(FVS *x, int n);
/* allocate sparse vector */

#define fvs_check_vec _glp_fvs_check_vec
void fvs_check_vec(const FVS *x);
/* check sparse vector */

#define fvs_gather_vec _glp_fvs_gather_vec
void fvs_gather_vec(FVS *x, double eps);
/* gather sparse vector */

#define fvs_clear_vec _glp_fvs_clear_vec
void fvs_clear_vec(FVS *x);
/* clear sparse vector */

#define fvs_copy_vec _glp_fvs_copy_vec
void fvs_copy_vec(FVS *x, const FVS *y);
/* copy sparse vector */

#define fvs_adjust_vec _glp_fvs_adjust_vec
void fvs_adjust_vec(FVS *x, double eps);
/* replace tiny vector elements by exact zeros */

#define fvs_free_vec _glp_fvs_free_vec
void fvs_free_vec(FVS *x);
/* deallocate sparse vector */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/gcd.c0000644000175100001710000000515300000000000023744 0ustar00runnerdocker00000000000000/* gcd.c (greatest common divisor) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"

/***********************************************************************
*  NAME
*
*  gcd - find greatest common divisor of two integers
*
*  SYNOPSIS
*
*  #include "misc.h"
*  int gcd(int x, int y);
*
*  RETURNS
*
*  The routine gcd returns gcd(x, y), the greatest common divisor of
*  the two positive integers given.
*
*  ALGORITHM
*
*  The routine gcd is based on Euclid's algorithm.
*
*  REFERENCES
*
*  Don Knuth, The Art of Computer Programming, Vol.2: Seminumerical
*  Algorithms, 3rd Edition, Addison-Wesley, 1997. Section 4.5.2: The
*  Greatest Common Divisor, pp. 333-56. */

int gcd(int x, int y)
{     int r;
      xassert(x > 0 && y > 0);
      while (y > 0)
         r = x % y, x = y, y = r;
      return x;
}

/***********************************************************************
*  NAME
*
*  gcdn - find greatest common divisor of n integers
*
*  SYNOPSIS
*
*  #include "misc.h"
*  int gcdn(int n, int x[]);
*
*  RETURNS
*
*  The routine gcdn returns gcd(x[1], x[2], ..., x[n]), the greatest
*  common divisor of n positive integers given, n > 0.
*
*  BACKGROUND
*
*  The routine gcdn is based on the following identity:
*
*     gcd(x, y, z) = gcd(gcd(x, y), z).
*
*  REFERENCES
*
*  Don Knuth, The Art of Computer Programming, Vol.2: Seminumerical
*  Algorithms, 3rd Edition, Addison-Wesley, 1997. Section 4.5.2: The
*  Greatest Common Divisor, pp. 333-56. */

int gcdn(int n, int x[])
{     int d, j;
      xassert(n > 0);
      for (j = 1; j <= n; j++)
      {  xassert(x[j] > 0);
         if (j == 1)
            d = x[1];
         else
            d = gcd(d, x[j]);
         if (d == 1)
            break;
      }
      return d;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/hbm.c0000644000175100001710000004611000000000000023753 0ustar00runnerdocker00000000000000/* hbm.c (Harwell-Boeing sparse matrix format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "hbm.h"
#include "misc.h"

/***********************************************************************
*  NAME
*
*  hbm_read_mat - read sparse matrix in Harwell-Boeing format
*
*  SYNOPSIS
*
*  #include "glphbm.h"
*  HBM *hbm_read_mat(const char *fname);
*
*  DESCRIPTION
*
*  The routine hbm_read_mat reads a sparse matrix in the Harwell-Boeing
*  format from a text file whose name is the character string fname.
*
*  Detailed description of the Harwell-Boeing format recognised by this
*  routine is given in the following report:
*
*  I.S.Duff, R.G.Grimes, J.G.Lewis. User's Guide for the Harwell-Boeing
*  Sparse Matrix Collection (Release I), TR/PA/92/86, October 1992.
*
*  RETURNS
*
*  If no error occured, the routine hbm_read_mat returns a pointer to
*  a data structure containing the matrix. In case of error the routine
*  prints an appropriate error message and returns NULL. */

struct dsa
{     /* working area used by routine hbm_read_mat */
      const char *fname;
      /* name of input text file */
      FILE *fp;
      /* stream assigned to input text file */
      int seqn;
      /* card sequential number */
      char card[80+1];
      /* card image buffer */
      int fmt_p;
      /* scale factor */
      int fmt_k;
      /* iterator */
      int fmt_f;
      /* format code */
      int fmt_w;
      /* field width */
      int fmt_d;
      /* number of decimal places after point */
};

/***********************************************************************
*  read_card - read next data card
*
*  This routine reads the next 80-column card from the input text file
*  and stores its image into the character string card. If the card was
*  read successfully, the routine returns zero, otherwise non-zero. */

#if 1 /* 11/III-2012 */
static int read_card(struct dsa *dsa)
{     int c, len = 0;
      char buf[255+1];
      dsa->seqn++;
      for (;;)
      {  c = fgetc(dsa->fp);
         if (c == EOF)
         {  if (ferror(dsa->fp))
               xprintf("%s:%d: read error\n",
                  dsa->fname, dsa->seqn);
            else
               xprintf("%s:%d: unexpected end-of-file\n",
                  dsa->fname, dsa->seqn);
            return 1;
         }
         else if (c == '\r')
            /* nop */;
         else if (c == '\n')
            break;
         else if (iscntrl(c))
         {  xprintf("%s:%d: invalid control character\n",
               dsa->fname, dsa->seqn, c);
            return 1;
         }
         else
         {  if (len == sizeof(buf)-1)
               goto err;
            buf[len++] = (char)c;
         }
      }
      /* remove trailing spaces */
      while (len > 80 && buf[len-1] == ' ')
         len--;
      buf[len] = '\0';
      /* line should not be longer than 80 chars */
      if (len > 80)
err:  {  xerror("%s:%d: card image too long\n",
            dsa->fname, dsa->seqn);
         return 1;
      }
      /* padd by spaces to 80-column card image */
      strcpy(dsa->card, buf);
      memset(&dsa->card[len], ' ', 80 - len);
      dsa->card[80] = '\0';
      return 0;
}
#endif

/***********************************************************************
*  scan_int - scan integer value from the current card
*
*  This routine scans an integer value from the current card, where fld
*  is the name of the field, pos is the position of the field, width is
*  the width of the field, val points to a location to which the scanned
*  value should be stored. If the value was scanned successfully, the
*  routine returns zero, otherwise non-zero. */

static int scan_int(struct dsa *dsa, char *fld, int pos, int width,
      int *val)
{     char str[80+1];
      xassert(1 <= width && width <= 80);
      memcpy(str, dsa->card + pos, width), str[width] = '\0';
      if (str2int(strspx(str), val))
      {  xprintf("%s:%d: field '%s' contains invalid value '%s'\n",
            dsa->fname, dsa->seqn, fld, str);
         return 1;
      }
      return 0;
}

/***********************************************************************
*  parse_fmt - parse Fortran format specification
*
*  This routine parses the Fortran format specification represented as
*  character string which fmt points to and stores format elements into
*  appropriate static locations. Should note that not all valid Fortran
*  format specifications may be recognised. If the format specification
*  was recognised, the routine returns zero, otherwise non-zero. */

static int parse_fmt(struct dsa *dsa, char *fmt)
{     int k, s, val;
      char str[80+1];
      /* first character should be left parenthesis */
      if (fmt[0] != '(')
fail: {  xprintf("hbm_read_mat: format '%s' not recognised\n", fmt);
         return 1;
      }
      k = 1;
      /* optional scale factor */
      dsa->fmt_p = 0;
      if (isdigit((unsigned char)fmt[k]))
      {  s = 0;
         while (isdigit((unsigned char)fmt[k]))
         {  if (s == 80) goto fail;
            str[s++] = fmt[k++];
         }
         str[s] = '\0';
         if (str2int(str, &val)) goto fail;
         if (toupper((unsigned char)fmt[k]) != 'P') goto iter;
         dsa->fmt_p = val, k++;
         if (!(0 <= dsa->fmt_p && dsa->fmt_p <= 255)) goto fail;
         /* optional comma may follow scale factor */
         if (fmt[k] == ',') k++;
      }
      /* optional iterator */
      dsa->fmt_k = 1;
      if (isdigit((unsigned char)fmt[k]))
      {  s = 0;
         while (isdigit((unsigned char)fmt[k]))
         {  if (s == 80) goto fail;
            str[s++] = fmt[k++];
         }
         str[s] = '\0';
         if (str2int(str, &val)) goto fail;
iter:    dsa->fmt_k = val;
         if (!(1 <= dsa->fmt_k && dsa->fmt_k <= 255)) goto fail;
      }
      /* format code */
      dsa->fmt_f = toupper((unsigned char)fmt[k++]);
      if (!(dsa->fmt_f == 'D' || dsa->fmt_f == 'E' ||
            dsa->fmt_f == 'F' || dsa->fmt_f == 'G' ||
            dsa->fmt_f == 'I')) goto fail;
      /* field width */
      if (!isdigit((unsigned char)fmt[k])) goto fail;
      s = 0;
      while (isdigit((unsigned char)fmt[k]))
      {  if (s == 80) goto fail;
         str[s++] = fmt[k++];
      }
      str[s] = '\0';
      if (str2int(str, &dsa->fmt_w)) goto fail;
      if (!(1 <= dsa->fmt_w && dsa->fmt_w <= 255)) goto fail;
      /* optional number of decimal places after point */
      dsa->fmt_d = 0;
      if (fmt[k] == '.')
      {  k++;
         if (!isdigit((unsigned char)fmt[k])) goto fail;
         s = 0;
         while (isdigit((unsigned char)fmt[k]))
         {  if (s == 80) goto fail;
            str[s++] = fmt[k++];
         }
         str[s] = '\0';
         if (str2int(str, &dsa->fmt_d)) goto fail;
         if (!(0 <= dsa->fmt_d && dsa->fmt_d <= 255)) goto fail;
      }
      /* last character should be right parenthesis */
      if (!(fmt[k] == ')' && fmt[k+1] == '\0')) goto fail;
      return 0;
}

/***********************************************************************
*  read_int_array - read array of integer type
*
*  This routine reads an integer array from the input text file, where
*  name is array name, fmt is Fortran format specification that controls
*  reading, n is number of array elements, val is array of integer type.
*  If the array was read successful, the routine returns zero, otherwise
*  non-zero. */

static int read_int_array(struct dsa *dsa, char *name, char *fmt,
      int n, int val[])
{     int k, pos;
      char str[80+1];
      if (parse_fmt(dsa, fmt)) return 1;
      if (!(dsa->fmt_f == 'I' && dsa->fmt_w <= 80 &&
            dsa->fmt_k * dsa->fmt_w <= 80))
      {  xprintf(
            "%s:%d: can't read array '%s' - invalid format '%s'\n",
            dsa->fname, dsa->seqn, name, fmt);
         return 1;
      }
      for (k = 1, pos = INT_MAX; k <= n; k++, pos++)
      {  if (pos >= dsa->fmt_k)
         {  if (read_card(dsa)) return 1;
            pos = 0;
         }
         memcpy(str, dsa->card + dsa->fmt_w * pos, dsa->fmt_w);
         str[dsa->fmt_w] = '\0';
         strspx(str);
         if (str2int(str, &val[k]))
         {  xprintf(
               "%s:%d: can't read array '%s' - invalid value '%s'\n",
               dsa->fname, dsa->seqn, name, str);
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  read_real_array - read array of real type
*
*  This routine reads a real array from the input text file, where name
*  is array name, fmt is Fortran format specification that controls
*  reading, n is number of array elements, val is array of real type.
*  If the array was read successful, the routine returns zero, otherwise
*  non-zero. */

static int read_real_array(struct dsa *dsa, char *name, char *fmt,
      int n, double val[])
{     int k, pos;
      char str[80+1], *ptr;
      if (parse_fmt(dsa, fmt)) return 1;
      if (!(dsa->fmt_f != 'I' && dsa->fmt_w <= 80 &&
            dsa->fmt_k * dsa->fmt_w <= 80))
      {  xprintf(
            "%s:%d: can't read array '%s' - invalid format '%s'\n",
            dsa->fname, dsa->seqn, name, fmt);
         return 1;
      }
      for (k = 1, pos = INT_MAX; k <= n; k++, pos++)
      {  if (pos >= dsa->fmt_k)
         {  if (read_card(dsa)) return 1;
            pos = 0;
         }
         memcpy(str, dsa->card + dsa->fmt_w * pos, dsa->fmt_w);
         str[dsa->fmt_w] = '\0';
         strspx(str);
         if (strchr(str, '.') == NULL && strcmp(str, "0"))
         {  xprintf("%s(%d): can't read array '%s' - value '%s' has no "
               "decimal point\n", dsa->fname, dsa->seqn, name, str);
            return 1;
         }
         /* sometimes lower case letters appear */
         for (ptr = str; *ptr; ptr++)
            *ptr = (char)toupper((unsigned char)*ptr);
         ptr = strchr(str, 'D');
         if (ptr != NULL) *ptr = 'E';
         /* value may appear with decimal exponent but without letters
            E or D (for example, -123.456-012), so missing letter should
            be inserted */
         ptr = strchr(str+1, '+');
         if (ptr == NULL) ptr = strchr(str+1, '-');
         if (ptr != NULL && *(ptr-1) != 'E')
         {  xassert(strlen(str) < 80);
            memmove(ptr+1, ptr, strlen(ptr)+1);
            *ptr = 'E';
         }
         if (str2num(str, &val[k]))
         {  xprintf(
               "%s:%d: can't read array '%s' - invalid value '%s'\n",
               dsa->fname, dsa->seqn, name, str);
            return 1;
         }
      }
      return 0;
}

HBM *hbm_read_mat(const char *fname)
{     struct dsa _dsa, *dsa = &_dsa;
      HBM *hbm = NULL;
      dsa->fname = fname;
      xprintf("hbm_read_mat: reading matrix from '%s'...\n",
         dsa->fname);
      dsa->fp = fopen(dsa->fname, "r");
      if (dsa->fp == NULL)
      {  xprintf("hbm_read_mat: unable to open '%s' - %s\n",
#if 0 /* 29/I-2017 */
            dsa->fname, strerror(errno));
#else
            dsa->fname, xstrerr(errno));
#endif
         goto fail;
      }
      dsa->seqn = 0;
      hbm = xmalloc(sizeof(HBM));
      memset(hbm, 0, sizeof(HBM));
      /* read the first heading card */
      if (read_card(dsa)) goto fail;
      memcpy(hbm->title, dsa->card, 72), hbm->title[72] = '\0';
      strtrim(hbm->title);
      xprintf("%s\n", hbm->title);
      memcpy(hbm->key, dsa->card+72, 8), hbm->key[8] = '\0';
      strspx(hbm->key);
      xprintf("key = %s\n", hbm->key);
      /* read the second heading card */
      if (read_card(dsa)) goto fail;
      if (scan_int(dsa, "totcrd",  0, 14, &hbm->totcrd)) goto fail;
      if (scan_int(dsa, "ptrcrd", 14, 14, &hbm->ptrcrd)) goto fail;
      if (scan_int(dsa, "indcrd", 28, 14, &hbm->indcrd)) goto fail;
      if (scan_int(dsa, "valcrd", 42, 14, &hbm->valcrd)) goto fail;
      if (scan_int(dsa, "rhscrd", 56, 14, &hbm->rhscrd)) goto fail;
      xprintf("totcrd = %d; ptrcrd = %d; indcrd = %d; valcrd = %d; rhsc"
         "rd = %d\n", hbm->totcrd, hbm->ptrcrd, hbm->indcrd,
         hbm->valcrd, hbm->rhscrd);
      /* read the third heading card */
      if (read_card(dsa)) goto fail;
      memcpy(hbm->mxtype, dsa->card, 3), hbm->mxtype[3] = '\0';
      if (strchr("RCP",   hbm->mxtype[0]) == NULL ||
          strchr("SUHZR", hbm->mxtype[1]) == NULL ||
          strchr("AE",    hbm->mxtype[2]) == NULL)
      {  xprintf("%s:%d: matrix type '%s' not recognised\n",
            dsa->fname, dsa->seqn, hbm->mxtype);
         goto fail;
      }
      if (scan_int(dsa, "nrow", 14, 14, &hbm->nrow)) goto fail;
      if (scan_int(dsa, "ncol", 28, 14, &hbm->ncol)) goto fail;
      if (scan_int(dsa, "nnzero", 42, 14, &hbm->nnzero)) goto fail;
      if (scan_int(dsa, "neltvl", 56, 14, &hbm->neltvl)) goto fail;
      xprintf("mxtype = %s; nrow = %d; ncol = %d; nnzero = %d; neltvl ="
         " %d\n", hbm->mxtype, hbm->nrow, hbm->ncol, hbm->nnzero,
         hbm->neltvl);
      /* read the fourth heading card */
      if (read_card(dsa)) goto fail;
      memcpy(hbm->ptrfmt, dsa->card, 16), hbm->ptrfmt[16] = '\0';
      strspx(hbm->ptrfmt);
      memcpy(hbm->indfmt, dsa->card+16, 16), hbm->indfmt[16] = '\0';
      strspx(hbm->indfmt);
      memcpy(hbm->valfmt, dsa->card+32, 20), hbm->valfmt[20] = '\0';
      strspx(hbm->valfmt);
      memcpy(hbm->rhsfmt, dsa->card+52, 20), hbm->rhsfmt[20] = '\0';
      strspx(hbm->rhsfmt);
      xprintf("ptrfmt = %s; indfmt = %s; valfmt = %s; rhsfmt = %s\n",
         hbm->ptrfmt, hbm->indfmt, hbm->valfmt, hbm->rhsfmt);
      /* read the fifth heading card (optional) */
      if (hbm->rhscrd <= 0)
      {  strcpy(hbm->rhstyp, "???");
         hbm->nrhs = 0;
         hbm->nrhsix = 0;
      }
      else
      {  if (read_card(dsa)) goto fail;
         memcpy(hbm->rhstyp, dsa->card, 3), hbm->rhstyp[3] = '\0';
         if (scan_int(dsa, "nrhs", 14, 14, &hbm->nrhs)) goto fail;
         if (scan_int(dsa, "nrhsix", 28, 14, &hbm->nrhsix)) goto fail;
         xprintf("rhstyp = '%s'; nrhs = %d; nrhsix = %d\n",
            hbm->rhstyp, hbm->nrhs, hbm->nrhsix);
      }
      /* read matrix structure */
      hbm->colptr = xcalloc(1+hbm->ncol+1, sizeof(int));
      if (read_int_array(dsa, "colptr", hbm->ptrfmt, hbm->ncol+1,
         hbm->colptr)) goto fail;
      hbm->rowind = xcalloc(1+hbm->nnzero, sizeof(int));
      if (read_int_array(dsa, "rowind", hbm->indfmt, hbm->nnzero,
         hbm->rowind)) goto fail;
      /* read matrix values */
      if (hbm->valcrd <= 0) goto done;
      if (hbm->mxtype[2] == 'A')
      {  /* assembled matrix */
         hbm->values = xcalloc(1+hbm->nnzero, sizeof(double));
         if (read_real_array(dsa, "values", hbm->valfmt, hbm->nnzero,
            hbm->values)) goto fail;
      }
      else
      {  /* elemental (unassembled) matrix */
         hbm->values = xcalloc(1+hbm->neltvl, sizeof(double));
         if (read_real_array(dsa, "values", hbm->valfmt, hbm->neltvl,
            hbm->values)) goto fail;
      }
      /* read right-hand sides */
      if (hbm->nrhs <= 0) goto done;
      if (hbm->rhstyp[0] == 'F')
      {  /* dense format */
         hbm->nrhsvl = hbm->nrow * hbm->nrhs;
         hbm->rhsval = xcalloc(1+hbm->nrhsvl, sizeof(double));
         if (read_real_array(dsa, "rhsval", hbm->rhsfmt, hbm->nrhsvl,
            hbm->rhsval)) goto fail;
      }
      else if (hbm->rhstyp[0] == 'M' && hbm->mxtype[2] == 'A')
      {  /* sparse format */
         /* read pointers */
         hbm->rhsptr = xcalloc(1+hbm->nrhs+1, sizeof(int));
         if (read_int_array(dsa, "rhsptr", hbm->ptrfmt, hbm->nrhs+1,
            hbm->rhsptr)) goto fail;
         /* read sparsity pattern */
         hbm->rhsind = xcalloc(1+hbm->nrhsix, sizeof(int));
         if (read_int_array(dsa, "rhsind", hbm->indfmt, hbm->nrhsix,
            hbm->rhsind)) goto fail;
         /* read values */
         hbm->rhsval = xcalloc(1+hbm->nrhsix, sizeof(double));
         if (read_real_array(dsa, "rhsval", hbm->rhsfmt, hbm->nrhsix,
            hbm->rhsval)) goto fail;
      }
      else if (hbm->rhstyp[0] == 'M' && hbm->mxtype[2] == 'E')
      {  /* elemental format */
         hbm->rhsval = xcalloc(1+hbm->nrhsvl, sizeof(double));
         if (read_real_array(dsa, "rhsval", hbm->rhsfmt, hbm->nrhsvl,
            hbm->rhsval)) goto fail;
      }
      else
      {  xprintf("%s:%d: right-hand side type '%c' not recognised\n",
            dsa->fname, dsa->seqn, hbm->rhstyp[0]);
         goto fail;
      }
      /* read starting guesses */
      if (hbm->rhstyp[1] == 'G')
      {  hbm->nguess = hbm->nrow * hbm->nrhs;
         hbm->sguess = xcalloc(1+hbm->nguess, sizeof(double));
         if (read_real_array(dsa, "sguess", hbm->rhsfmt, hbm->nguess,
            hbm->sguess)) goto fail;
      }
      /* read solution vectors */
      if (hbm->rhstyp[2] == 'X')
      {  hbm->nexact = hbm->nrow * hbm->nrhs;
         hbm->xexact = xcalloc(1+hbm->nexact, sizeof(double));
         if (read_real_array(dsa, "xexact", hbm->rhsfmt, hbm->nexact,
            hbm->xexact)) goto fail;
      }
done: /* reading has been completed */
      xprintf("hbm_read_mat: %d cards were read\n", dsa->seqn);
      fclose(dsa->fp);
      return hbm;
fail: /* something wrong in Danish kingdom */
      if (hbm != NULL)
      {  if (hbm->colptr != NULL) xfree(hbm->colptr);
         if (hbm->rowind != NULL) xfree(hbm->rowind);
         if (hbm->rhsptr != NULL) xfree(hbm->rhsptr);
         if (hbm->rhsind != NULL) xfree(hbm->rhsind);
         if (hbm->values != NULL) xfree(hbm->values);
         if (hbm->rhsval != NULL) xfree(hbm->rhsval);
         if (hbm->sguess != NULL) xfree(hbm->sguess);
         if (hbm->xexact != NULL) xfree(hbm->xexact);
         xfree(hbm);
      }
      if (dsa->fp != NULL) fclose(dsa->fp);
      return NULL;
}

/***********************************************************************
*  NAME
*
*  hbm_free_mat - free sparse matrix in Harwell-Boeing format
*
*  SYNOPSIS
*
*  #include "glphbm.h"
*  void hbm_free_mat(HBM *hbm);
*
*  DESCRIPTION
*
*  The hbm_free_mat routine frees all the memory allocated to the data
*  structure containing a sparse matrix in the Harwell-Boeing format. */

void hbm_free_mat(HBM *hbm)
{     if (hbm->colptr != NULL) xfree(hbm->colptr);
      if (hbm->rowind != NULL) xfree(hbm->rowind);
      if (hbm->rhsptr != NULL) xfree(hbm->rhsptr);
      if (hbm->rhsind != NULL) xfree(hbm->rhsind);
      if (hbm->values != NULL) xfree(hbm->values);
      if (hbm->rhsval != NULL) xfree(hbm->rhsval);
      if (hbm->sguess != NULL) xfree(hbm->sguess);
      if (hbm->xexact != NULL) xfree(hbm->xexact);
      xfree(hbm);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/hbm.h0000644000175100001710000001060500000000000023760 0ustar00runnerdocker00000000000000/* hbm.h (Harwell-Boeing sparse matrix format) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef HBM_H
#define HBM_H

typedef struct HBM HBM;

struct HBM
{     /* sparse matrix in Harwell-Boeing format; for details see the
         report: I.S.Duff, R.G.Grimes, J.G.Lewis. User's Guide for the
         Harwell-Boeing Sparse Matrix Collection (Release I), 1992 */
      char title[72+1];
      /* matrix title (informative) */
      char key[8+1];
      /* matrix key (informative) */
      char mxtype[3+1];
      /* matrix type:
         R.. real matrix
         C.. complex matrix
         P.. pattern only (no numerical values supplied)
         .S. symmetric (lower triangle + main diagonal)
         .U. unsymmetric
         .H. hermitian (lower triangle + main diagonal)
         .Z. skew symmetric (lower triangle only)
         .R. rectangular
         ..A assembled
         ..E elemental (unassembled) */
      char rhstyp[3+1];
      /* optional types:
         F.. right-hand sides in dense format
         M.. right-hand sides in same format as matrix
         .G. starting vector(s) (guess) is supplied
         ..X exact solution vector(s) is supplied */
      char ptrfmt[16+1];
      /* format for pointers */
      char indfmt[16+1];
      /* format for row (or variable) indices */
      char valfmt[20+1];
      /* format for numerical values of coefficient matrix */
      char rhsfmt[20+1];
      /* format for numerical values of right-hand sides */
      int totcrd;
      /* total number of cards excluding header */
      int ptrcrd;
      /* number of cards for ponters */
      int indcrd;
      /* number of cards for row (or variable) indices */
      int valcrd;
      /* number of cards for numerical values */
      int rhscrd;
      /* number of lines for right-hand sides;
         including starting guesses and solution vectors if present;
         zero indicates no right-hand side data is present */
      int nrow;
      /* number of rows (or variables) */
      int ncol;
      /* number of columns (or elements) */
      int nnzero;
      /* number of row (or variable) indices;
         equal to number of entries for assembled matrix */
      int neltvl;
      /* number of elemental matrix entries;
         zero in case of assembled matrix */
      int nrhs;
      /* number of right-hand sides */
      int nrhsix;
      /* number of row indices;
         ignored in case of unassembled matrix */
      int nrhsvl;
      /* total number of entries in all right-hand sides */
      int nguess;
      /* total number of entries in all starting guesses */
      int nexact;
      /* total number of entries in all solution vectors */
      int *colptr; /* alias: eltptr */
      /* column pointers (in case of assembled matrix);
         elemental matrix pointers (in case of unassembled matrix) */
      int *rowind; /* alias: varind */
      /* row indices (in case of assembled matrix);
         variable indices (in case of unassembled matrix) */
      int *rhsptr;
      /* right-hand side pointers */
      int *rhsind;
      /* right-hand side indices */
      double *values;
      /* matrix values */
      double *rhsval;
      /* right-hand side values */
      double *sguess;
      /* starting guess values */
      double *xexact;
      /* solution vector values */
};

#define hbm_read_mat _glp_hbm_read_mat
HBM *hbm_read_mat(const char *fname);
/* read sparse matrix in Harwell-Boeing format */

#define hbm_free_mat _glp_hbm_free_mat
void hbm_free_mat(HBM *hbm);
/* free sparse matrix in Harwell-Boeing format */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/jd.c0000644000175100001710000000775100000000000023612 0ustar00runnerdocker00000000000000/* jd.c (conversions between calendar date and Julian day number) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include 
#include "jd.h"

/***********************************************************************
*  NAME
*
*  jday - convert calendar date to Julian day number
*
*  SYNOPSIS
*
*  #include "jd.h"
*  int jday(int d, int m, int y);
*
*  DESCRIPTION
*
*  The routine jday converts a calendar date, Gregorian calendar, to
*  corresponding Julian day number j.
*
*  From the given day d, month m, and year y, the Julian day number j
*  is computed without using tables.
*
*  The routine is valid for 1 <= y <= 4000.
*
*  RETURNS
*
*  The routine jday returns the Julian day number, or negative value if
*  the specified date is incorrect.
*
*  REFERENCES
*
*  R. G. Tantzen, Algorithm 199: conversions between calendar date and
*  Julian day number, Communications of the ACM, vol. 6, no. 8, p. 444,
*  Aug. 1963. */

int jday(int d, int m, int y)
{     int c, ya, j, dd;
      if (!(1 <= d && d <= 31 &&
            1 <= m && m <= 12 &&
            1 <= y && y <= 4000))
         return -1;
      if (m >= 3)
         m -= 3;
      else
         m += 9, y--;
      c = y / 100;
      ya = y - 100 * c;
      j = (146097 * c) / 4 + (1461 * ya) / 4 + (153 * m + 2) / 5 + d +
         1721119;
      jdate(j, &dd, NULL, NULL);
      if (d != dd)
         return -1;
      return j;
}

/***********************************************************************
*  NAME
*
*  jdate - convert Julian day number to calendar date
*
*  SYNOPSIS
*
*  #include "jd.h"
*  int jdate(int j, int *d, int *m, int *y);
*
*  DESCRIPTION
*
*  The routine jdate converts a Julian day number j to corresponding
*  calendar date, Gregorian calendar.
*
*  The day d, month m, and year y are computed without using tables and
*  stored in corresponding locations.
*
*  The routine is valid for 1721426 <= j <= 3182395.
*
*  RETURNS
*
*  If the conversion is successful, the routine returns zero, otherwise
*  non-zero.
*
*  REFERENCES
*
*  R. G. Tantzen, Algorithm 199: conversions between calendar date and
*  Julian day number, Communications of the ACM, vol. 6, no. 8, p. 444,
*  Aug. 1963. */

int jdate(int j, int *d_, int *m_, int *y_)
{     int d, m, y;
      if (!(1721426 <= j && j <= 3182395))
         return 1;
      j -= 1721119;
      y = (4 * j - 1) / 146097;
      j = (4 * j - 1) % 146097;
      d = j / 4;
      j = (4 * d + 3) / 1461;
      d = (4 * d + 3) % 1461;
      d = (d + 4) / 4;
      m = (5 * d - 3) / 153;
      d = (5 * d - 3) % 153;
      d = (d + 5) / 5;
      y = 100 * y + j;
      if (m <= 9)
         m += 3;
      else m -= 9,
         y++;
      if (d_ != NULL) *d_ = d;
      if (m_ != NULL) *m_ = m;
      if (y_ != NULL) *y_ = y;
      return 0;
}

#ifdef GLP_TEST
#include 
#include 
#include 

int main(void)
{     int jbeg, jend, j, d, m, y;
      jbeg = jday(1, 1, 1);
      jend = jday(31, 12, 4000);
      for (j = jbeg; j <= jend; j++)
      {  assert(jdate(j, &d, &m, &y) == 0);
         assert(jday(d, m, y) == j);
      }
      printf("Routines jday and jdate work correctly.\n");
      return 0;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/jd.h0000644000175100001710000000231100000000000023602 0ustar00runnerdocker00000000000000/* jd.h (conversions between calendar date and Julian day number) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#define jday _glp_jday
int jday(int d, int m, int y);
/* convert calendar date to Julian day number */

#define jdate _glp_jdate
int jdate(int j, int *d, int *m, int *y);
/* convert Julian day number to calendar date */

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/keller.c0000644000175100001710000002217400000000000024467 0ustar00runnerdocker00000000000000/* keller.c (cover edges by cliques, Kellerman's heuristic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "glpk.h"
#include "env.h"
#include "keller.h"

/***********************************************************************
*  NAME
*
*  kellerman - cover edges by cliques with Kellerman's heuristic
*
*  SYNOPSIS
*
*  #include "keller.h"
*  int kellerman(int n, int (*func)(void *info, int i, int ind[]),
*     void *info, glp_graph *H);
*
*  DESCRIPTION
*
*  The routine kellerman implements Kellerman's heuristic algorithm
*  to find a minimal set of cliques which cover all edges of specified
*  graph G = (V, E).
*
*  The parameter n specifies the number of vertices |V|, n >= 0.
*
*  Formal routine func specifies the set of edges E in the following
*  way. Running the routine kellerman calls the routine func and passes
*  to it parameter i, which is the number of some vertex, 1 <= i <= n.
*  In response the routine func should store numbers of all vertices
*  adjacent to vertex i to locations ind[1], ind[2], ..., ind[len] and
*  return the value of len, which is the number of adjacent vertices,
*  0 <= len <= n. Self-loops are allowed, but ignored. Multiple edges
*  are not allowed.
*
*  The parameter info is a transit pointer (magic cookie) passed to the
*  formal routine func as its first parameter.
*
*  The result provided by the routine kellerman is the bipartite graph
*  H = (V union C, F), which defines the covering found. (The program
*  object of type glp_graph specified by the parameter H should be
*  previously created with the routine glp_create_graph. On entry the
*  routine kellerman erases the content of this object with the routine
*  glp_erase_graph.) Vertices of first part V correspond to vertices of
*  the graph G and have the same ordinal numbers 1, 2, ..., n. Vertices
*  of second part C correspond to cliques and have ordinal numbers
*  n+1, n+2, ..., n+k, where k is the total number of cliques in the
*  edge covering found. Every edge f in F in the program object H is
*  represented as arc f = (i->j), where i in V and j in C, which means
*  that vertex i of the graph G is in clique C[j], 1 <= j <= k. (Thus,
*  if two vertices of the graph G are in the same clique, these vertices
*  are adjacent in G, and corresponding edge is covered by that clique.)
*
*  RETURNS
*
*  The routine Kellerman returns k, the total number of cliques in the
*  edge covering found.
*
*  REFERENCE
*
*  For more details see: glpk/doc/notes/keller.pdf (in Russian). */

struct set
{     /* set of vertices */
      int size;
      /* size (cardinality) of the set, 0 <= card <= n */
      int *list; /* int list[1+n]; */
      /* the set contains vertices list[1,...,size] */
      int *pos; /* int pos[1+n]; */
      /* pos[i] > 0 means that vertex i is in the set and
       * list[pos[i]] = i; pos[i] = 0 means that vertex i is not in
       * the set */
};

int kellerman(int n, int (*func)(void *info, int i, int ind[]),
      void *info, void /* glp_graph */ *H_)
{     glp_graph *H = H_;
      struct set W_, *W = &W_, V_, *V = &V_;
      glp_arc *a;
      int i, j, k, m, t, len, card, best;
      xassert(n >= 0);
      /* H := (V, 0; 0), where V is the set of vertices of graph G */
      glp_erase_graph(H, H->v_size, H->a_size);
      glp_add_vertices(H, n);
      /* W := 0 */
      W->size = 0;
      W->list = xcalloc(1+n, sizeof(int));
      W->pos = xcalloc(1+n, sizeof(int));
      memset(&W->pos[1], 0, sizeof(int) * n);
      /* V := 0 */
      V->size = 0;
      V->list = xcalloc(1+n, sizeof(int));
      V->pos = xcalloc(1+n, sizeof(int));
      memset(&V->pos[1], 0, sizeof(int) * n);
      /* main loop */
      for (i = 1; i <= n; i++)
      {  /* W must be empty */
         xassert(W->size == 0);
         /* W := { j : i > j and (i,j) in E } */
         len = func(info, i, W->list);
         xassert(0 <= len && len <= n);
         for (t = 1; t <= len; t++)
         {  j = W->list[t];
            xassert(1 <= j && j <= n);
            if (j >= i) continue;
            xassert(W->pos[j] == 0);
            W->list[++W->size] = j, W->pos[j] = W->size;
         }
         /* on i-th iteration we need to cover edges (i,j) for all
          * j in W */
         /* if W is empty, it is a special case */
         if (W->size == 0)
         {  /* set k := k + 1 and create new clique C[k] = { i } */
            k = glp_add_vertices(H, 1) - n;
            glp_add_arc(H, i, n + k);
            continue;
         }
         /* try to include vertex i into existing cliques */
         /* V must be empty */
         xassert(V->size == 0);
         /* k is the number of cliques found so far */
         k = H->nv - n;
         for (m = 1; m <= k; m++)
         {  /* do while V != W; since here V is within W, we can use
             * equivalent condition: do while |V| < |W| */
            if (V->size == W->size) break;
            /* check if C[m] is within W */
            for (a = H->v[n + m]->in; a != NULL; a = a->h_next)
            {  j = a->tail->i;
               if (W->pos[j] == 0) break;
            }
            if (a != NULL) continue;
            /* C[m] is within W, expand clique C[m] with vertex i */
            /* C[m] := C[m] union {i} */
            glp_add_arc(H, i, n + m);
            /* V is a set of vertices whose incident edges are already
             * covered by existing cliques */
            /* V := V union C[m] */
            for (a = H->v[n + m]->in; a != NULL; a = a->h_next)
            {  j = a->tail->i;
               if (V->pos[j] == 0)
                  V->list[++V->size] = j, V->pos[j] = V->size;
            }
         }
         /* remove from set W the vertices whose incident edges are
          * already covered by existing cliques */
         /* W := W \ V, V := 0 */
         for (t = 1; t <= V->size; t++)
         {  j = V->list[t], V->pos[j] = 0;
            if (W->pos[j] != 0)
            {  /* remove vertex j from W */
               if (W->pos[j] != W->size)
               {  int jj = W->list[W->size];
                  W->list[W->pos[j]] = jj;
                  W->pos[jj] = W->pos[j];
               }
               W->size--, W->pos[j] = 0;
            }
         }
         V->size = 0;
         /* now set W contains only vertices whose incident edges are
          * still not covered by existing cliques; create new cliques
          * to cover remaining edges until set W becomes empty */
         while (W->size > 0)
         {  /* find clique C[m], 1 <= m <= k, which shares maximal
             * number of vertices with W; to break ties choose clique
             * having smallest number m */
            m = 0, best = -1;
            k = H->nv - n;
            for (t = 1; t <= k; t++)
            {  /* compute cardinality of intersection of W and C[t] */
               card = 0;
               for (a = H->v[n + t]->in; a != NULL; a = a->h_next)
               {  j = a->tail->i;
                  if (W->pos[j] != 0) card++;
               }
               if (best < card)
                  m = t, best = card;
            }
            xassert(m > 0);
            /* set k := k + 1 and create new clique:
             * C[k] := (W intersect C[m]) union { i }, which covers all
             * edges incident to vertices from (W intersect C[m]) */
            k = glp_add_vertices(H, 1) - n;
            for (a = H->v[n + m]->in; a != NULL; a = a->h_next)
            {  j = a->tail->i;
               if (W->pos[j] != 0)
               {  /* vertex j is in both W and C[m]; include it in new
                   * clique C[k] */
                  glp_add_arc(H, j, n + k);
                  /* remove vertex j from W, since edge (i,j) will be
                   * covered by new clique C[k] */
                  if (W->pos[j] != W->size)
                  {  int jj = W->list[W->size];
                     W->list[W->pos[j]] = jj;
                     W->pos[jj] = W->pos[j];
                  }
                  W->size--, W->pos[j] = 0;
               }
            }
            /* include vertex i to new clique C[k] to cover edges (i,j)
             * incident to all vertices j just removed from W */
            glp_add_arc(H, i, n + k);
         }
      }
      /* free working arrays */
      xfree(W->list);
      xfree(W->pos);
      xfree(V->list);
      xfree(V->pos);
      /* return the number of cliques in the edge covering found */
      return H->nv - n;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/keller.h0000644000175100001710000000233400000000000024470 0ustar00runnerdocker00000000000000/* keller.h (cover edges by cliques, Kellerman's heuristic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef KELLER_H
#define KELLER_H

#define kellerman _glp_kellerman
int kellerman(int n, int (*func)(void *info, int i, int ind[]),
      void *info, void /* glp_graph */ *H);
/* cover edges by cliques with Kellerman's heuristic */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/ks.c0000644000175100001710000003525200000000000023627 0ustar00runnerdocker00000000000000/* ks.c (0-1 knapsack problem) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ks.h"
#include "mt1.h"

/***********************************************************************
*  0-1 knapsack problem has the following formulation:
*
*     maximize z = sum{j in 1..n} c[j]x[j]                           (1)
*
*         s.t. sum{j in 1..n} a[j]x[j] <= b                          (2)
*
*              x[j] in {0, 1} for all j in 1..n                      (3)
*
*  In general case it is assumed that the instance is non-normalized,
*  i.e. parameters a, b, and c may have any sign.
***********************************************************************/

/***********************************************************************
*  ks_enum - solve 0-1 knapsack problem by complete enumeration
*
*  This routine finds optimal solution to 0-1 knapsack problem (1)-(3)
*  by complete enumeration. It is intended mainly for testing purposes.
*
*  The instance to be solved is specified by parameters n, a, b, and c.
*  Note that these parameters can have any sign, i.e. normalization is
*  not needed.
*
*  On exit the routine stores the optimal point found in locations
*  x[1], ..., x[n] and returns the optimal objective value. However, if
*  the instance is infeasible, the routine returns INT_MIN.
*
*  Since the complete enumeration is inefficient, this routine can be
*  used only for small instances (n <= 20-30). */

#define N_MAX 40

int ks_enum(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/])
{     int j, s, z, z_best;
      char x_best[1+N_MAX];
      xassert(0 <= n && n <= N_MAX);
      /* initialization */
      memset(&x[1], 0, n * sizeof(char));
      z_best = INT_MIN;
loop: /* compute constraint and objective at current x */
      s = z = 0;
      for (j = 1; j <= n; j++)
      {  if (x[j])
            s += a[j], z += c[j];
      }
      /* check constraint violation */
      if (s > b)
         goto next;
      /* check objective function */
      if (z_best < z)
      {  /* better solution has been found */
         memcpy(&x_best[1], &x[1], n * sizeof(char));
         z_best = z;
      }
next: /* generate next x */
      for (j = 1; j <= n; j++)
      {  if (!x[j])
         {  x[j] = 1;
            goto loop;
         }
         x[j] = 0;
      }
      /* report best (optimal) solution */
      memcpy(&x[1], &x_best[1], n * sizeof(char));
      return z_best;
}

/***********************************************************************
*  reduce - prepare reduced instance of 0-1 knapsack
*
*  Given original instance of 0-1 knapsack (1)-(3) specified by the
*  parameters n, a, b, and c this routine transforms it to equivalent
*  reduced instance in the same format. The reduced instance is
*  normalized, i.e. the following additional conditions are met:
*
*     n >= 2                                                         (4)
*
*     1 <= a[j] <= b for all j in 1..n                               (5)
*
*     sum{j in 1..n} a[j] >= b+1                                     (6)
*
*     c[j] >= 1      for all j in 1..n                               (7)
*
*  The routine creates the structure ks and stores there parameters n,
*  a, b, and c of the reduced instance as well as template of solution
*  to original instance.
*
*  Normally the routine returns a pointer to the structure ks created.
*  However, if the original instance is infeasible, the routine returns
*  a null pointer. */

struct ks
{     int orig_n;
      /* original problem dimension */
      int n;
      /* reduced problem dimension */
      int *a; /* int a[1+orig_n]; */
      /* a{j in 1..n} are constraint coefficients (2) */
      int b;
      /* b is constraint right-hand side (2) */
      int *c; /* int c[1+orig_n]; */
      /* c{j in 1..n} are objective coefficients (1) */
      int c0;
      /* c0 is objective constant term */
      char *x; /* char x[1+orig_n]; */
      /* x{j in 1..orig_n} is solution template to original instance:
       * x[j] = 0       x[j] is fixed at 0
       * x[j] = 1       x[j] is fixed at 1
       * x[j] = 0x10    x[j] = x[j']
       * x[j] = 0x11    x[j] = 1 - x[j']
       * where x[j'] is corresponding solution to reduced instance */
};

static void free_ks(struct ks *ks);

static struct ks *reduce(const int n, const int a[/*1+n*/], int b,
      const int c[/*1+n*/])
{     struct ks *ks;
      int j, s;
      xassert(n >= 0);
      /* initially reduced instance is the same as original one */
      ks = talloc(1, struct ks);
      ks->orig_n = n;
      ks->n = 0;
      ks->a = talloc(1+n, int);
      memcpy(&ks->a[1], &a[1], n * sizeof(int));
      ks->b = b;
      ks->c = talloc(1+n, int);
      memcpy(&ks->c[1], &c[1], n * sizeof(int));
      ks->c0 = 0;
      ks->x = talloc(1+n, char);
      /* make all a[j] non-negative */
      for (j = 1; j <= n; j++)
      {  if (a[j] >= 0)
         {  /* keep original x[j] */
            ks->x[j] = 0x10;
         }
         else /* a[j] < 0 */
         {  /* substitute x[j] = 1 - x'[j] */
            ks->x[j] = 0x11;
            /* ... + a[j]x[j]        + ... <= b
             * ... + a[j](1 - x'[j]) + ... <= b
             * ... - a[j]x'[j]       + ... <= b - a[j] */
            ks->a[j] = - ks->a[j];
            ks->b += ks->a[j];
            /* z = ... + c[j]x[j]        + ... + c0 =
             *   = ... + c[j](1 - x'[j]) + ... + c0 =
             *   = ... - c[j]x'[j]       + ... + (c0 + c[j]) */
            ks->c0 += ks->c[j];
            ks->c[j] = - ks->c[j];
         }
      }
      /* now a[j] >= 0 for all j in 1..n */
      if (ks->b < 0)
      {  /* instance is infeasible */
         free_ks(ks);
         return NULL;
      }
      /* build reduced instance */
      for (j = 1; j <= n; j++)
      {  if (ks->a[j] == 0)
         {  if (ks->c[j] <= 0)
            {  /* fix x[j] at 0 */
               ks->x[j] ^= 0x10;
            }
            else
            {  /* fix x[j] at 1 */
               ks->x[j] ^= 0x11;
               ks->c0 += ks->c[j];
            }
         }
         else if (ks->a[j] > ks->b || ks->c[j] <= 0)
         {  /* fix x[j] at 0 */
            ks->x[j] ^= 0x10;
         }
         else
         {  /* include x[j] in reduced instance */
            ks->n++;
            ks->a[ks->n] = ks->a[j];
            ks->c[ks->n] = ks->c[j];
         }
      }
      /* now conditions (5) and (7) are met */
      /* check condition (6) */
      s = 0;
      for (j = 1; j <= ks->n; j++)
      {  xassert(1 <= ks->a[j] && ks->a[j] <= ks->b);
         xassert(ks->c[j] >= 1);
         s += ks->a[j];
      }
      if (s <= ks->b)
      {  /* sum{j in 1..n} a[j] <= b */
         /* fix all remaining x[j] at 1 to obtain trivial solution */
         for (j = 1; j <= n; j++)
         {  if (ks->x[j] & 0x10)
               ks->x[j] ^= 0x11;
         }
         for (j = 1; j <= ks->n; j++)
            ks->c0 += ks->c[j];
         /* reduced instance is empty */
         ks->n = 0;
      }
      /* here n = 0 or n >= 2 due to condition (6) */
      xassert(ks->n == 0 || ks->n >= 2);
      return ks;
}

/***********************************************************************
*  restore - restore solution to original 0-1 knapsack instance
*
*  Given optimal solution x{j in 1..ks->n} to the reduced 0-1 knapsack
*  instance (previously prepared by the routine reduce) this routine
*  constructs optimal solution to the original instance and stores it
*  in the array ks->x{j in 1..ks->orig_n}.
*
*  On exit the routine returns optimal objective value for the original
*  instance.
*
*  NOTE: This operation should be performed only once. */

static int restore(struct ks *ks, char x[])
{     int j, k, z;
      z = ks->c0;
      for (j = 1, k = 0; j <= ks->orig_n; j++)
      {  if (ks->x[j] & 0x10)
         {  k++;
            xassert(k <= ks->n);
            xassert(x[k] == 0 || x[k] == 1);
            if (ks->x[j] & 1)
               ks->x[j] = 1 - x[k];
            else
               ks->x[j] = x[k];
            if (x[k])
               z += ks->c[k];
         }
      }
      xassert(k == ks->n);
      return z;
}

/***********************************************************************
*  free_ks - deallocate structure ks
*
*  This routine frees memory previously allocated to the structure ks
*  and all its components. */

static void free_ks(struct ks *ks)
{     xassert(ks != NULL);
      tfree(ks->a);
      tfree(ks->c);
      tfree(ks->x);
      tfree(ks);
}

/***********************************************************************
*  ks_mt1 - solve 0-1 knapsack problem with Martello & Toth algorithm
*
*  This routine finds optimal solution to 0-1 knapsack problem (1)-(3)
*  with Martello & Toth algorithm MT1.
*
*  The instance to be solved is specified by parameters n, a, b, and c.
*  Note that these parameters can have any sign, i.e. normalization is
*  not needed.
*
*  On exit the routine stores the optimal point found in locations
*  x[1], ..., x[n] and returns the optimal objective value. However, if
*  the instance is infeasible, the routine returns INT_MIN.
*
*  REFERENCES
*
*  S.Martello, P.Toth. Knapsack Problems: Algorithms and Computer Imp-
*  lementations. John Wiley & Sons, 1990. */

struct mt
{     int j;
      float r; /* r[j] = c[j] / a[j] */
};

static int CDECL fcmp(const void *p1, const void *p2)
{     if (((struct mt *)p1)->r > ((struct mt *)p2)->r)
         return -1;
      else if (((struct mt *)p1)->r < ((struct mt *)p2)->r)
         return +1;
      else
         return 0;
}

static int mt1a(int n, const int a[], int b, const int c[], char x[])
{     /* interface routine to MT1 */
      struct mt *mt;
      int j, z, *p, *w, *x1, *xx, *min, *psign, *wsign, *zsign;
      xassert(n >= 2);
      /* allocate working arrays */
      mt = talloc(1+n, struct mt);
      p = talloc(1+n+1, int);
      w = talloc(1+n+1, int);
      x1 = talloc(1+n+1, int);
      xx = talloc(1+n+1, int);
      min = talloc(1+n+1, int);
      psign = talloc(1+n+1, int);
      wsign = talloc(1+n+1, int);
      zsign = talloc(1+n+1, int);
      /* reorder items to provide c[j] / a[j] >= a[j+1] / a[j+1] */
      for (j = 1; j <= n; j++)
      {  mt[j].j = j;
         mt[j].r = (float)c[j] / (float)a[j];
      }
      qsort(&mt[1], n, sizeof(struct mt), fcmp);
      /* load instance parameters */
      for (j = 1; j <= n; j++)
      {  p[j] = c[mt[j].j];
         w[j] = a[mt[j].j];
      }
      /* find optimal solution */
      z = mt1(n, p, w, b, x1, 1, xx, min, psign, wsign, zsign);
      xassert(z >= 0);
      /* store optimal point found */
      for (j = 1; j <= n; j++)
      {  xassert(x1[j] == 0 || x1[j] == 1);
         x[mt[j].j] = x1[j];
      }
      /* free working arrays */
      tfree(mt);
      tfree(p);
      tfree(w);
      tfree(x1);
      tfree(xx);
      tfree(min);
      tfree(psign);
      tfree(wsign);
      tfree(zsign);
      return z;
}

int ks_mt1(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/])
{     struct ks *ks;
      int j, s1, s2, z;
      xassert(n >= 0);
      /* prepare reduced instance */
      ks = reduce(n, a, b, c);
      if (ks == NULL)
      {  /* original instance is infeasible */
         return INT_MIN;
      }
      /* find optimal solution to reduced instance */
      if (ks->n > 0)
         mt1a(ks->n, ks->a, ks->b, ks->c, x);
      /* restore solution to original instance */
      z = restore(ks, x);
      memcpy(&x[1], &ks->x[1], n * sizeof(char));
      free_ks(ks);
      /* check solution found */
      s1 = s2 = 0;
      for (j = 1; j <= n; j++)
      {  xassert(x[j] == 0 || x[j] == 1);
         if (x[j])
            s1 += a[j], s2 += c[j];
      }
      xassert(s1 <= b);
      xassert(s2 == z);
      return z;
}

/***********************************************************************
*  ks_greedy - solve 0-1 knapsack problem with greedy heuristic
*
*  This routine finds (sub)optimal solution to 0-1 knapsack problem
*  (1)-(3) with greedy heuristic.
*
*  The instance to be solved is specified by parameters n, a, b, and c.
*  Note that these parameters can have any sign, i.e. normalization is
*  not needed.
*
*  On exit the routine stores the optimal point found in locations
*  x[1], ..., x[n] and returns the optimal objective value. However, if
*  the instance is infeasible, the routine returns INT_MIN. */

static int greedy(int n, const int a[], int b, const int c[], char x[])
{     /* core routine for normalized 0-1 knapsack instance */
      struct mt *mt;
      int j, s, z;
      xassert(n >= 2);
      /* reorder items to provide c[j] / a[j] >= a[j+1] / a[j+1] */
      mt = talloc(1+n, struct mt);
      for (j = 1; j <= n; j++)
      {  mt[j].j = j;
         mt[j].r = (float)c[j] / (float)a[j];
      }
      qsort(&mt[1], n, sizeof(struct mt), fcmp);
      /* take items starting from most valuable ones until the knapsack
       * is full */
      s = z = 0;
      for (j = 1; j <= n; j++)
      {  if (s + a[mt[j].j] > b)
            break;
         x[mt[j].j] = 1;
         s += a[mt[j].j];
         z += c[mt[j].j];
      }
      /* don't take remaining items */
      for (j = j; j <= n; j++)
         x[mt[j].j] = 0;
      tfree(mt);
      return z;
}

int ks_greedy(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/])
{     struct ks *ks;
      int j, s1, s2, z;
      xassert(n >= 0);
      /* prepare reduced instance */
      ks = reduce(n, a, b, c);
      if (ks == NULL)
      {  /* original instance is infeasible */
         return INT_MIN;
      }
      /* find suboptimal solution to reduced instance */
      if (ks->n > 0)
         greedy(ks->n, ks->a, ks->b, ks->c, x);
      /* restore solution to original instance */
      z = restore(ks, x);
      memcpy(&x[1], &ks->x[1], n * sizeof(char));
      free_ks(ks);
      /* check solution found */
      s1 = s2 = 0;
      for (j = 1; j <= n; j++)
      {  xassert(x[j] == 0 || x[j] == 1);
         if (x[j])
            s1 += a[j], s2 += c[j];
      }
      xassert(s1 <= b);
      xassert(s2 == z);
      return z;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/ks.h0000644000175100001710000000303000000000000023621 0ustar00runnerdocker00000000000000/* ks.h (0-1 knapsack problem) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef KS_H
#define KS_H

#define ks_enum _glp_ks_enum
int ks_enum(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/]);
/* solve 0-1 knapsack problem by complete enumeration */

#define ks_mt1 _glp_ks_mt1
int ks_mt1(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/]);
/* solve 0-1 knapsack problem with Martello & Toth algorithm */

#define ks_greedy _glp_ks_greedy
int ks_greedy(int n, const int a[/*1+n*/], int b, const int c[/*1+n*/],
      char x[/*1+n*/]);
/* solve 0-1 knapsack problem with greedy heuristic */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mc13d.c0000644000175100001710000002444000000000000024116 0ustar00runnerdocker00000000000000/* mc13d.c (permutations to block triangular form) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  This code is the result of translation of the Fortran subroutines
*  MC13D and MC13E associated with the following paper:
*
*  I.S.Duff, J.K.Reid, Algorithm 529: Permutations to block triangular
*  form, ACM Trans. on Math. Softw. 4 (1978), 189-192.
*
*  Use of ACM Algorithms is subject to the ACM Software Copyright and
*  License Agreement. See .
*
*  The translation was made by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mc13d.h"

/***********************************************************************
*  NAME
*
*  mc13d - permutations to block triangular form
*
*  SYNOPSIS
*
*  #include "mc13d.h"
*  int mc13d(int n, const int icn[], const int ip[], const int lenr[],
*     int ior[], int ib[], int lowl[], int numb[], int prev[]);
*
*  DESCRIPTION
*
*  Given the column numbers of the nonzeros in each row of the sparse
*  matrix, the routine mc13d finds a symmetric permutation that makes
*  the matrix block lower triangular.
*
*  INPUT PARAMETERS
*
*  n     order of the matrix.
*
*  icn   array containing the column indices of the non-zeros. Those
*        belonging to a single row must be contiguous but the ordering
*        of column indices within each row is unimportant and wasted
*        space between rows is permitted.
*
*  ip    ip[i], i = 1,2,...,n, is the position in array icn of the
*        first column index of a non-zero in row i.
*
*  lenr  lenr[i], i = 1,2,...,n, is the number of non-zeros in row i.
*
*  OUTPUT PARAMETERS
*
*  ior   ior[i], i = 1,2,...,n, gives the position on the original
*        ordering of the row or column which is in position i in the
*        permuted form.
*
*  ib    ib[i], i = 1,2,...,num, is the row number in the permuted
*        matrix of the beginning of block i, 1 <= num <= n.
*
*  WORKING ARRAYS
*
*  arp   working array of length [1+n], where arp[0] is not used.
*        arp[i] is one less than the number of unsearched edges leaving
*        node i. At the end of the algorithm it is set to a permutation
*        which puts the matrix in block lower triangular form.
*
*  ib    working array of length [1+n], where ib[0] is not used.
*        ib[i] is the position in the ordering of the start of the ith
*        block. ib[n+1-i] holds the node number of the ith node on the
*        stack.
*
*  lowl  working array of length [1+n], where lowl[0] is not used.
*        lowl[i] is the smallest stack position of any node to which a
*        path from node i has been found. It is set to n+1 when node i
*        is removed from the stack.
*
*  numb  working array of length [1+n], where numb[0] is not used.
*        numb[i] is the position of node i in the stack if it is on it,
*        is the permuted order of node i for those nodes whose final
*        position has been found and is otherwise zero.
*
*  prev  working array of length [1+n], where prev[0] is not used.
*        prev[i] is the node at the end of the path when node i was
*        placed on the stack.
*
*  RETURNS
*
*  The routine mc13d returns num, the number of blocks found. */

int mc13d(int n, const int icn[], const int ip[], const int lenr[],
      int ior[], int ib[], int lowl[], int numb[], int prev[])
{     int *arp = ior;
      int dummy, i, i1, i2, icnt, ii, isn, ist, ist1, iv, iw, j, lcnt,
         nnm1, num, stp;
      /* icnt is the number of nodes whose positions in final ordering
       * have been found. */
      icnt = 0;
      /* num is the number of blocks that have been found. */
      num = 0;
      nnm1 = n + n - 1;
      /* Initialization of arrays. */
      for (j = 1; j <= n; j++)
      {  numb[j] = 0;
         arp[j] = lenr[j] - 1;
      }
      for (isn = 1; isn <= n; isn++)
      {  /* Look for a starting node. */
         if (numb[isn] != 0) continue;
         iv = isn;
         /* ist is the number of nodes on the stack ... it is the stack
          * pointer. */
         ist = 1;
         /* Put node iv at beginning of stack. */
         lowl[iv] = numb[iv] = 1;
         ib[n] = iv;
         /* The body of this loop puts a new node on the stack or
          * backtracks. */
         for (dummy = 1; dummy <= nnm1; dummy++)
         {  i1 = arp[iv];
            /* Have all edges leaving node iv been searched? */
            if (i1 >= 0)
            {  i2 = ip[iv] + lenr[iv] - 1;
               i1 = i2 - i1;
               /* Look at edges leaving node iv until one enters a new
                * node or all edges are exhausted. */
               for (ii = i1; ii <= i2; ii++)
               {  iw = icn[ii];
                  /* Has node iw been on stack already? */
                  if (numb[iw] == 0) goto L70;
                  /* Update value of lowl[iv] if necessary. */
                  if (lowl[iw] < lowl[iv]) lowl[iv] = lowl[iw];
               }
               /* There are no more edges leaving node iv. */
               arp[iv] = -1;
            }
            /* Is node iv the root of a block? */
            if (lowl[iv] < numb[iv]) goto L60;
            /* Order nodes in a block. */
            num++;
            ist1 = n + 1 - ist;
            lcnt = icnt + 1;
            /* Peel block off the top of the stack starting at the top
             * and working down to the root of the block. */
            for (stp = ist1; stp <= n; stp++)
            {  iw = ib[stp];
               lowl[iw] = n + 1;
               numb[iw] = ++icnt;
               if (iw == iv) break;
            }
            ist = n - stp;
            ib[num] = lcnt;
            /* Are there any nodes left on the stack? */
            if (ist != 0) goto L60;
            /* Have all the nodes been ordered? */
            if (icnt < n) break;
            goto L100;
L60:        /* Backtrack to previous node on path. */
            iw = iv;
            iv = prev[iv];
            /* Update value of lowl[iv] if necessary. */
            if (lowl[iw] < lowl[iv]) lowl[iv] = lowl[iw];
            continue;
L70:        /* Put new node on the stack. */
            arp[iv] = i2 - ii - 1;
            prev[iw] = iv;
            iv = iw;
            lowl[iv] = numb[iv] = ++ist;
            ib[n+1-ist] = iv;
         }
      }
L100: /* Put permutation in the required form. */
      for (i = 1; i <= n; i++)
         arp[numb[i]] = i;
      return num;
}

/**********************************************************************/

#ifdef GLP_TEST
#include "env.h"

void test(int n, int ipp);

int main(void)
{     /* test program for routine mc13d */
      test( 1,   0);
      test( 2,   1);
      test( 2,   2);
      test( 3,   3);
      test( 4,   4);
      test( 5,  10);
      test(10,  10);
      test(10,  20);
      test(20,  20);
      test(20,  50);
      test(50,  50);
      test(50, 200);
      return 0;
}

void fa01bs(int max, int *nrand);

void setup(int n, char a[1+50][1+50], int ip[], int icn[], int lenr[]);

void test(int n, int ipp)
{     int ip[1+50], icn[1+1000], ior[1+50], ib[1+51], iw[1+150],
         lenr[1+50];
      char a[1+50][1+50], hold[1+100];
      int i, ii, iblock, ij, index, j, jblock, jj, k9, num;
      xprintf("\n\n\nMatrix is of order %d and has %d off-diagonal non-"
         "zeros\n", n, ipp);
      for (j = 1; j <= n; j++)
      {  for (i = 1; i <= n; i++)
            a[i][j] = 0;
         a[j][j] = 1;
      }
      for (k9 = 1; k9 <= ipp; k9++)
      {  /* these statements should be replaced by calls to your
          * favorite random number generator to place two pseudo-random
          * numbers between 1 and n in the variables i and j */
         for (;;)
         {  fa01bs(n, &i);
            fa01bs(n, &j);
            if (!a[i][j]) break;
         }
         a[i][j] = 1;
      }
      /* setup converts matrix a[i,j] to required sparsity-oriented
       * storage format */
      setup(n, a, ip, icn, lenr);
      num = mc13d(n, icn, ip, lenr, ior, ib, &iw[0], &iw[n], &iw[n+n]);
      /* output reordered matrix with blocking to improve clarity */
      xprintf("\nThe reordered matrix which has %d block%s is of the fo"
         "rm\n", num, num == 1 ? "" : "s");
      ib[num+1] = n + 1;
      index = 100;
      iblock = 1;
      for (i = 1; i <= n; i++)
      {  for (ij = 1; ij <= index; ij++)
            hold[ij] = ' ';
         if (i == ib[iblock])
         {  xprintf("\n");
            iblock++;
         }
         jblock = 1;
         index = 0;
         for (j = 1; j <= n; j++)
         {  if (j == ib[jblock])
            {  hold[++index] = ' ';
               jblock++;
            }
            ii = ior[i];
            jj = ior[j];
            hold[++index] = (char)(a[ii][jj] ? 'X' : '0');
         }
         xprintf("%.*s\n", index, &hold[1]);
      }
      xprintf("\nThe starting point for each block is given by\n");
      for (i = 1; i <= num; i++)
      {  if ((i - 1) % 12 == 0) xprintf("\n");
         xprintf(" %4d", ib[i]);
      }
      xprintf("\n");
      return;
}

void setup(int n, char a[1+50][1+50], int ip[], int icn[], int lenr[])
{     int i, j, ind;
      for (i = 1; i <= n; i++)
         lenr[i] = 0;
      ind = 1;
      for (i = 1; i <= n; i++)
      {  ip[i] = ind;
         for (j = 1; j <= n; j++)
         {  if (a[i][j])
            {  lenr[i]++;
               icn[ind++] = j;
            }
         }
      }
      return;
}

double g = 1431655765.0;

double fa01as(int i)
{     /* random number generator */
      g = fmod(g * 9228907.0, 4294967296.0);
      if (i >= 0)
         return g / 4294967296.0;
      else
         return 2.0 * g / 4294967296.0 - 1.0;
}

void fa01bs(int max, int *nrand)
{     *nrand = (int)(fa01as(1) * (double)max) + 1;
      return;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mc13d.h0000644000175100001710000000225500000000000024123 0ustar00runnerdocker00000000000000/* mc13d.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MC13D_H
#define MC13D_H

#define mc13d _glp_mc13d
int mc13d(int n, const int icn[], const int ip[], const int lenr[],
      int ior[], int ib[], int lowl[], int numb[], int prev[]);
/* permutations to block triangular form */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mc21a.c0000644000175100001710000002335200000000000024113 0ustar00runnerdocker00000000000000/* mc21a.c (permutations for zero-free diagonal) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  This code is the result of translation of the Fortran subroutines
*  MC21A and MC21B associated with the following paper:
*
*  I.S.Duff, Algorithm 575: Permutations for zero-free diagonal, ACM
*  Trans. on Math. Softw. 7 (1981), 387-390.
*
*  Use of ACM Algorithms is subject to the ACM Software Copyright and
*  License Agreement. See .
*
*  The translation was made by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mc21a.h"

/***********************************************************************
*  NAME
*
*  mc21a - permutations for zero-free diagonal
*
*  SYNOPSIS
*
*  #include "mc21a.h"
*  int mc21a(int n, const int icn[], const int ip[], const int lenr[],
*     int iperm[], int pr[], int arp[], int cv[], int out[]);
*
*  DESCRIPTION
*
*  Given the pattern of nonzeros of a sparse matrix, the routine mc21a
*  attempts to find a permutation of its rows that makes the matrix have
*  no zeros on its diagonal.
*
*  INPUT PARAMETERS
*
*  n     order of matrix.
*
*  icn   array containing the column indices of the non-zeros. Those
*        belonging to a single row must be contiguous but the ordering
*        of column indices within each row is unimportant and wasted
*        space between rows is permitted.
*
*  ip    ip[i], i = 1,2,...,n, is the position in array icn of the
*        first column index of a non-zero in row i.
*
*  lenr  lenr[i], i = 1,2,...,n, is the number of non-zeros in row i.
*
*  OUTPUT PARAMETER
*
*  iperm contains permutation to make diagonal have the smallest
*        number of zeros on it. Elements (iperm[i], i), i = 1,2,...,n,
*        are non-zero at the end of the algorithm unless the matrix is
*        structurally singular. In this case, (iperm[i], i) will be
*        zero for n - numnz entries.
*
*  WORKING ARRAYS
*
*  pr    working array of length [1+n], where pr[0] is not used.
*        pr[i] is the previous row to i in the depth first search.
*
*  arp   working array of length [1+n], where arp[0] is not used.
*        arp[i] is one less than the number of non-zeros in row i which
*        have not been scanned when looking for a cheap assignment.
*
*  cv    working array of length [1+n], where cv[0] is not used.
*        cv[i] is the most recent row extension at which column i was
*        visited.
*
*  out   working array of length [1+n], where out[0] is not used.
*        out[i] is one less than the number of non-zeros in row i
*        which have not been scanned during one pass through the main
*        loop.
*
*  RETURNS
*
*  The routine mc21a returns numnz, the number of non-zeros on diagonal
*  of permuted matrix. */

int mc21a(int n, const int icn[], const int ip[], const int lenr[],
      int iperm[], int pr[], int arp[], int cv[], int out[])
{     int i, ii, in1, in2, j, j1, jord, k, kk, numnz;
      /* Initialization of arrays. */
      for (i = 1; i <= n; i++)
      {  arp[i] = lenr[i] - 1;
         cv[i] = iperm[i] = 0;
      }
      numnz = 0;
      /* Main loop. */
      /* Each pass round this loop either results in a new assignment
       * or gives a row with no assignment. */
      for (jord = 1; jord <= n; jord++)
      {  j = jord;
         pr[j] = -1;
         for (k = 1; k <= jord; k++)
         {  /* Look for a cheap assignment. */
            in1 = arp[j];
            if (in1 >= 0)
            {  in2 = ip[j] + lenr[j] - 1;
               in1 = in2 - in1;
               for (ii = in1; ii <= in2; ii++)
               {  i = icn[ii];
                  if (iperm[i] == 0) goto L110;
               }
               /* No cheap assignment in row. */
               arp[j] = -1;
            }
            /* Begin looking for assignment chain starting with row j.*/
            out[j] = lenr[j] - 1;
            /* Inner loop. Extends chain by one or backtracks. */
            for (kk = 1; kk <= jord; kk++)
            {  in1 = out[j];
               if (in1 >= 0)
               {  in2 = ip[j] + lenr[j] - 1;
                  in1 = in2 - in1;
                  /* Forward scan. */
                  for (ii = in1; ii <= in2; ii++)
                  {  i = icn[ii];
                     if (cv[i] != jord)
                     {  /* Column i has not yet been accessed during
                         * this pass. */
                        j1 = j;
                        j = iperm[i];
                        cv[i] = jord;
                        pr[j] = j1;
                        out[j1] = in2 - ii - 1;
                        goto L100;
                     }
                  }
               }
               /* Backtracking step. */
               j = pr[j];
               if (j == -1) goto L130;
            }
L100:       ;
         }
L110:    /* New assignment is made. */
         iperm[i] = j;
         arp[j] = in2 - ii - 1;
         numnz++;
         for (k = 1; k <= jord; k++)
         {  j = pr[j];
            if (j == -1) break;
            ii = ip[j] + lenr[j] - out[j] - 2;
            i = icn[ii];
            iperm[i] = j;
         }
L130:    ;
      }
      /* If matrix is structurally singular, we now complete the
       * permutation iperm. */
      if (numnz < n)
      {  for (i = 1; i <= n; i++)
            arp[i] = 0;
         k = 0;
         for (i = 1; i <= n; i++)
         {  if (iperm[i] == 0)
               out[++k] = i;
            else
               arp[iperm[i]] = i;
         }
         k = 0;
         for (i = 1; i <= n; i++)
         {  if (arp[i] == 0)
               iperm[out[++k]] = i;
         }
      }
      return numnz;
}

/**********************************************************************/

#ifdef GLP_TEST
#include "env.h"

int sing;

void ranmat(int m, int n, int icn[], int iptr[], int nnnp1, int *knum,
      int iw[]);

void fa01bs(int max, int *nrand);

int main(void)
{     /* test program for the routine mc21a */
      /* these runs on random matrices cause all possible statements in
       * mc21a to be executed */
      int i, iold, j, j1, j2, jj, knum, l, licn, n, nov4, num, numnz;
      int ip[1+21], icn[1+1000], iperm[1+20], lenr[1+20], iw1[1+80];
      licn = 1000;
      /* run on random matrices of orders 1 through 20 */
      for (n = 1; n <= 20; n++)
      {  nov4 = n / 4;
         if (nov4 < 1) nov4 = 1;
L10:     fa01bs(nov4, &l);
         knum = l * n;
         /* knum is requested number of non-zeros in random matrix */
         if (knum > licn) goto L10;
         /* if sing is false, matrix is guaranteed structurally
          * non-singular */
         sing = ((n / 2) * 2 == n);
         /* call to subroutine to generate random matrix */
         ranmat(n, n, icn, ip, n+1, &knum, iw1);
         /* knum is now actual number of non-zeros in random matrix */
         if (knum > licn) goto L10;
         xprintf("n = %2d; nz = %4d; sing = %d\n", n, knum, sing);
         /* set up array of row lengths */
         for (i = 1; i <= n; i++)
            lenr[i] = ip[i+1] - ip[i];
         /* call to mc21a */
         numnz = mc21a(n, icn, ip, lenr, iperm, &iw1[0], &iw1[n],
            &iw1[n+n], &iw1[n+n+n]);
         /* testing to see if there are numnz non-zeros on the diagonal
          * of the permuted matrix. */
         num = 0;
         for (i = 1; i <= n; i++)
         {  iold = iperm[i];
            j1 = ip[iold];
            j2 = j1 + lenr[iold] - 1;
            if (j2 < j1) continue;
            for (jj = j1; jj <= j2; jj++)
            {  j = icn[jj];
               if (j == i)
               {  num++;
                  break;
               }
            }
         }
         if (num != numnz)
            xprintf("Failure in mc21a, numnz = %d instead of %d\n",
               numnz, num);
      }
      return 0;
}

void ranmat(int m, int n, int icn[], int iptr[], int nnnp1, int *knum,
      int iw[])
{     /* subroutine to generate random matrix */
      int i, ii, inum, j, lrow, matnum;
      inum = (*knum / n) * 2;
      if (inum > n-1) inum = n-1;
      matnum = 1;
      /* each pass through this loop generates a row of the matrix */
      for (j = 1; j <= m; j++)
      {  iptr[j] = matnum;
         if (!(sing || j > n))
            icn[matnum++] = j;
         if (n == 1) continue;
         for (i = 1; i <= n; i++) iw[i] = 0;
         if (!sing) iw[j] = 1;
         fa01bs(inum, &lrow);
         lrow--;
         if (lrow == 0) continue;
         /* lrow off-diagonal non-zeros in row j of the matrix */
         for (ii = 1; ii <= lrow; ii++)
         {  for (;;)
            {  fa01bs(n, &i);
               if (iw[i] != 1) break;
            }
            iw[i] = 1;
            icn[matnum++] = i;
         }
      }
      for (i = m+1; i <= nnnp1; i++)
         iptr[i] = matnum;
      *knum = matnum - 1;
      return;
}

double g = 1431655765.0;

double fa01as(int i)
{     /* random number generator */
      g = fmod(g * 9228907.0, 4294967296.0);
      if (i >= 0)
         return g / 4294967296.0;
      else
         return 2.0 * g / 4294967296.0 - 1.0;
}

void fa01bs(int max, int *nrand)
{     *nrand = (int)(fa01as(1) * (double)max) + 1;
      return;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mc21a.h0000644000175100001710000000231700000000000024116 0ustar00runnerdocker00000000000000/* mc21a.h (permutations for zero-free diagonal) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MC21A_H
#define MC21A_H

#define mc21a _glp_mc21a
int mc21a(int n, const int icn[], const int ip[], const int lenr[],
      int iperm[], int pr[], int arp[], int cv[], int out[]);
/* permutations for zero-free diagonal */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/misc.h0000644000175100001710000000360100000000000024143 0ustar00runnerdocker00000000000000/* misc.h (miscellaneous routines) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MISC_H
#define MISC_H

#define str2int _glp_str2int
int str2int(const char *str, int *val);
/* convert character string to value of int type */

#define str2num _glp_str2num
int str2num(const char *str, double *val);
/* convert character string to value of double type */

#define strspx _glp_strspx
char *strspx(char *str);
/* remove all spaces from character string */

#define strtrim _glp_strtrim
char *strtrim(char *str);
/* remove trailing spaces from character string */

#define gcd _glp_gcd
int gcd(int x, int y);
/* find greatest common divisor of two integers */

#define gcdn _glp_gcdn
int gcdn(int n, int x[]);
/* find greatest common divisor of n integers */

#define round2n _glp_round2n
double round2n(double x);
/* round floating-point number to nearest power of two */

#define fp2rat _glp_fp2rat
int fp2rat(double x, double eps, double *p, double *q);
/* convert floating-point number to rational number */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mt1.c0000644000175100001710000005447000000000000023716 0ustar00runnerdocker00000000000000/* mt1.c (0-1 knapsack problem; Martello & Toth algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  THIS CODE IS THE RESULT OF TRANSLATION OF THE FORTRAN SUBROUTINES
*  MT1 FROM THE BOOK:
*
*  SILVANO MARTELLO, PAOLO TOTH. KNAPSACK PROBLEMS: ALGORITHMS AND
*  COMPUTER IMPLEMENTATIONS. JOHN WILEY & SONS, 1990.
*
*  THE TRANSLATION HAS BEEN DONE WITH THE PERMISSION OF THE AUTHORS OF
*  THE ORIGINAL FORTRAN SUBROUTINES: SILVANO MARTELLO AND PAOLO TOTH.
*
*  The translation was made by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#line 1 ""
/*  -- translated by f2c (version 20100827).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#if 0 /* by mao */
#include "f2c.h"
#else
#include "env.h"
#include "mt1.h"

typedef int integer;
typedef float real;
#endif

#line 1 ""
/*<       SUBROUTINE MT1(N,P,W,C,Z,X,JDIM,JCK,XX,MIN,PSIGN,WSIGN,ZSIGN) >*/
#if 1 /* by mao */
static int chmt1_(int *, int *, int *, int *, int *, int *);

static
#endif
/* Subroutine */ int mt1_(integer *n, integer *p, integer *w, integer *c__,
	integer *z__, integer *x, integer *jdim, integer *jck, integer *xx,
	integer *min__, integer *psign, integer *wsign, integer *zsign)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    static real a, b;
    static integer j, r__, t, j1, n1, ch, ii, jj, kk, in, ll, ip, nn, iu, ii1,
	     chs, lim, lim1, diff, lold, mink;
    extern /* Subroutine */ int chmt1_(integer *, integer *, integer *,
	    integer *, integer *, integer *);
    static integer profit;


/* THIS SUBROUTINE SOLVES THE 0-1 SINGLE KNAPSACK PROBLEM */

/* MAXIMIZE  Z = P(1)*X(1) + ... + P(N)*X(N) */

/* SUBJECT TO:   W(1)*X(1) + ... + W(N)*X(N) .LE. C , */
/*               X(J) = 0 OR 1  FOR J=1,...,N. */

/* THE PROGRAM IS INCLUDED IN THE VOLUME */
/*   S. MARTELLO, P. TOTH, "KNAPSACK PROBLEMS: ALGORITHMS */
/*   AND COMPUTER IMPLEMENTATIONS", JOHN WILEY, 1990 */
/* AND IMPLEMENTS THE BRANCH-AND-BOUND ALGORITHM DESCRIBED IN */
/* SECTION  2.5.2 . */
/* THE PROGRAM DERIVES FROM AN EARLIER CODE PRESENTED IN */
/*  S. MARTELLO, P. TOTH, "ALGORITHM FOR THE SOLUTION OF THE 0-1 SINGLE */
/*  KNAPSACK PROBLEM", COMPUTING, 1978. */

/* THE INPUT PROBLEM MUST SATISFY THE CONDITIONS */

/*   1) 2 .LE. N .LE. JDIM - 1 ; */
/*   2) P(J), W(J), C  POSITIVE INTEGERS; */
/*   3) MAX (W(J)) .LE. C ; */
/*   4) W(1) + ... + W(N) .GT. C ; */
/*   5) P(J)/W(J) .GE. P(J+1)/W(J+1) FOR J=1,...,N-1. */

/* MT1 CALLS  1  PROCEDURE: CHMT1. */

/* THE PROGRAM IS COMPLETELY SELF-CONTAINED AND COMMUNICATION TO IT IS */
/* ACHIEVED SOLELY THROUGH THE PARAMETER LIST OF MT1. */
/* NO MACHINE-DEPENDENT CONSTANT IS USED. */
/* THE PROGRAM IS WRITTEN IN 1967 AMERICAN NATIONAL STANDARD FORTRAN */
/* AND IS ACCEPTED BY THE PFORT VERIFIER (PFORT IS THE PORTABLE */
/* SUBSET OF ANSI DEFINED BY THE ASSOCIATION FOR COMPUTING MACHINERY). */
/* THE PROGRAM HAS BEEN TESTED ON A DIGITAL VAX 11/780 AND AN H.P. */
/* 9000/840. */

/* MT1 NEEDS  8  ARRAYS ( P ,  W ,  X ,  XX ,  MIN ,  PSIGN ,  WSIGN */
/*                        AND  ZSIGN ) OF LENGTH AT LEAST  N + 1 . */

/* MEANING OF THE INPUT PARAMETERS: */
/* N    = NUMBER OF ITEMS; */
/* P(J) = PROFIT OF ITEM  J  (J=1,...,N); */
/* W(J) = WEIGHT OF ITEM  J  (J=1,...,N); */
/* C    = CAPACITY OF THE KNAPSACK; */
/* JDIM = DIMENSION OF THE 8 ARRAYS; */
/* JCK  = 1 IF CHECK ON THE INPUT DATA IS DESIRED, */
/*      = 0 OTHERWISE. */

/* MEANING OF THE OUTPUT PARAMETERS: */
/* Z    = VALUE OF THE OPTIMAL SOLUTION IF  Z .GT. 0 , */
/*      = ERROR IN THE INPUT DATA (WHEN JCK=1) IF Z .LT. 0 : CONDI- */
/*        TION  - Z  IS VIOLATED; */
/* X(J) = 1 IF ITEM  J  IS IN THE OPTIMAL SOLUTION, */
/*      = 0 OTHERWISE. */

/* ARRAYS XX, MIN, PSIGN, WSIGN AND ZSIGN ARE DUMMY. */

/* ALL THE PARAMETERS ARE INTEGER. ON RETURN OF MT1 ALL THE INPUT */
/* PARAMETERS ARE UNCHANGED. */

/*<       INTEGER P(JDIM),W(JDIM),X(JDIM),C,Z >*/
/*<       INTEGER XX(JDIM),MIN(JDIM),PSIGN(JDIM),WSIGN(JDIM),ZSIGN(JDIM) >*/
/*<       INTEGER CH,CHS,DIFF,PROFIT,R,T >*/
/*<       Z = 0 >*/
#line 65 ""
    /* Parameter adjustments */
#line 65 ""
    --zsign;
#line 65 ""
    --wsign;
#line 65 ""
    --psign;
#line 65 ""
    --min__;
#line 65 ""
    --xx;
#line 65 ""
    --x;
#line 65 ""
    --w;
#line 65 ""
    --p;
#line 65 ""

#line 65 ""
    /* Function Body */
#line 65 ""
    *z__ = 0;
/*<       IF ( JCK .EQ. 1 ) CALL CHMT1(N,P,W,C,Z,JDIM) >*/
#line 66 ""
    if (*jck == 1) {
#line 66 ""
	chmt1_(n, &p[1], &w[1], c__, z__, jdim);
#line 66 ""
    }
/*<       IF ( Z .LT. 0 ) RETURN >*/
#line 67 ""
    if (*z__ < 0) {
#line 67 ""
	return 0;
#line 67 ""
    }
/* INITIALIZE. */
/*<       CH = C >*/
#line 69 ""
    ch = *c__;
/*<       IP = 0 >*/
#line 70 ""
    ip = 0;
/*<       CHS = CH >*/
#line 71 ""
    chs = ch;
/*<       DO 10 LL=1,N >*/
#line 72 ""
    i__1 = *n;
#line 72 ""
    for (ll = 1; ll <= i__1; ++ll) {
/*<         IF ( W(LL) .GT. CHS ) GO TO 20 >*/
#line 73 ""
	if (w[ll] > chs) {
#line 73 ""
	    goto L20;
#line 73 ""
	}
/*<         IP = IP + P(LL) >*/
#line 74 ""
	ip += p[ll];
/*<         CHS = CHS - W(LL) >*/
#line 75 ""
	chs -= w[ll];
/*<    10 CONTINUE >*/
#line 76 ""
/* L10: */
#line 76 ""
    }
/*<    20 LL = LL - 1 >*/
#line 77 ""
L20:
#line 77 ""
    --ll;
/*<       IF ( CHS .EQ. 0 ) GO TO 50 >*/
#line 78 ""
    if (chs == 0) {
#line 78 ""
	goto L50;
#line 78 ""
    }
/*<       P(N+1) = 0 >*/
#line 79 ""
    p[*n + 1] = 0;
/*<       W(N+1) = CH + 1 >*/
#line 80 ""
    w[*n + 1] = ch + 1;
/*<       LIM = IP + CHS*P(LL+2)/W(LL+2) >*/
#line 81 ""
    lim = ip + chs * p[ll + 2] / w[ll + 2];
/*<       A = W(LL+1) - CHS >*/
#line 82 ""
    a = (real) (w[ll + 1] - chs);
/*<       B = IP + P(LL+1) >*/
#line 83 ""
    b = (real) (ip + p[ll + 1]);
/*<       LIM1 = B - A*FLOAT(P(LL))/FLOAT(W(LL)) >*/
#line 84 ""
    lim1 = b - a * (real) p[ll] / (real) w[ll];
/*<       IF ( LIM1 .GT. LIM ) LIM = LIM1 >*/
#line 85 ""
    if (lim1 > lim) {
#line 85 ""
	lim = lim1;
#line 85 ""
    }
/*<       MINK = CH + 1 >*/
#line 86 ""
    mink = ch + 1;
/*<       MIN(N) = MINK >*/
#line 87 ""
    min__[*n] = mink;
/*<       DO 30 J=2,N >*/
#line 88 ""
    i__1 = *n;
#line 88 ""
    for (j = 2; j <= i__1; ++j) {
/*<         KK = N + 2 - J >*/
#line 89 ""
	kk = *n + 2 - j;
/*<         IF ( W(KK) .LT. MINK ) MINK = W(KK) >*/
#line 90 ""
	if (w[kk] < mink) {
#line 90 ""
	    mink = w[kk];
#line 90 ""
	}
/*<         MIN(KK-1) = MINK >*/
#line 91 ""
	min__[kk - 1] = mink;
/*<    30 CONTINUE >*/
#line 92 ""
/* L30: */
#line 92 ""
    }
/*<       DO 40 J=1,N >*/
#line 93 ""
    i__1 = *n;
#line 93 ""
    for (j = 1; j <= i__1; ++j) {
/*<         XX(J) = 0 >*/
#line 94 ""
	xx[j] = 0;
/*<    40 CONTINUE >*/
#line 95 ""
/* L40: */
#line 95 ""
    }
/*<       Z = 0 >*/
#line 96 ""
    *z__ = 0;
/*<       PROFIT = 0 >*/
#line 97 ""
    profit = 0;
/*<       LOLD = N >*/
#line 98 ""
    lold = *n;
/*<       II = 1 >*/
#line 99 ""
    ii = 1;
/*<       GO TO 170 >*/
#line 100 ""
    goto L170;
/*<    50 Z = IP >*/
#line 101 ""
L50:
#line 101 ""
    *z__ = ip;
/*<       DO 60 J=1,LL >*/
#line 102 ""
    i__1 = ll;
#line 102 ""
    for (j = 1; j <= i__1; ++j) {
/*<         X(J) = 1 >*/
#line 103 ""
	x[j] = 1;
/*<    60 CONTINUE >*/
#line 104 ""
/* L60: */
#line 104 ""
    }
/*<       NN = LL + 1 >*/
#line 105 ""
    nn = ll + 1;
/*<       DO 70 J=NN,N >*/
#line 106 ""
    i__1 = *n;
#line 106 ""
    for (j = nn; j <= i__1; ++j) {
/*<         X(J) = 0 >*/
#line 107 ""
	x[j] = 0;
/*<    70 CONTINUE >*/
#line 108 ""
/* L70: */
#line 108 ""
    }
/*<       RETURN >*/
#line 109 ""
    return 0;
/* TRY TO INSERT THE II-TH ITEM INTO THE CURRENT SOLUTION. */
/*<    80 IF ( W(II) .LE. CH ) GO TO 90 >*/
#line 111 ""
L80:
#line 111 ""
    if (w[ii] <= ch) {
#line 111 ""
	goto L90;
#line 111 ""
    }
/*<       II1 = II + 1 >*/
#line 112 ""
    ii1 = ii + 1;
/*<       IF ( Z .GE. CH*P(II1)/W(II1) + PROFIT ) GO TO 280 >*/
#line 113 ""
    if (*z__ >= ch * p[ii1] / w[ii1] + profit) {
#line 113 ""
	goto L280;
#line 113 ""
    }
/*<       II = II1 >*/
#line 114 ""
    ii = ii1;
/*<       GO TO 80 >*/
#line 115 ""
    goto L80;
/* BUILD A NEW CURRENT SOLUTION. */
/*<    90 IP = PSIGN(II) >*/
#line 117 ""
L90:
#line 117 ""
    ip = psign[ii];
/*<       CHS = CH - WSIGN(II) >*/
#line 118 ""
    chs = ch - wsign[ii];
/*<       IN = ZSIGN(II) >*/
#line 119 ""
    in = zsign[ii];
/*<       DO 100 LL=IN,N >*/
#line 120 ""
    i__1 = *n;
#line 120 ""
    for (ll = in; ll <= i__1; ++ll) {
/*<         IF ( W(LL) .GT. CHS ) GO TO 160 >*/
#line 121 ""
	if (w[ll] > chs) {
#line 121 ""
	    goto L160;
#line 121 ""
	}
/*<         IP = IP + P(LL) >*/
#line 122 ""
	ip += p[ll];
/*<         CHS = CHS - W(LL) >*/
#line 123 ""
	chs -= w[ll];
/*<   100 CONTINUE >*/
#line 124 ""
/* L100: */
#line 124 ""
    }
/*<       LL = N >*/
#line 125 ""
    ll = *n;
/*<   110 IF ( Z .GE. IP + PROFIT ) GO TO 280 >*/
#line 126 ""
L110:
#line 126 ""
    if (*z__ >= ip + profit) {
#line 126 ""
	goto L280;
#line 126 ""
    }
/*<       Z = IP + PROFIT >*/
#line 127 ""
    *z__ = ip + profit;
/*<       NN = II - 1 >*/
#line 128 ""
    nn = ii - 1;
/*<       DO 120 J=1,NN >*/
#line 129 ""
    i__1 = nn;
#line 129 ""
    for (j = 1; j <= i__1; ++j) {
/*<         X(J) = XX(J) >*/
#line 130 ""
	x[j] = xx[j];
/*<   120 CONTINUE >*/
#line 131 ""
/* L120: */
#line 131 ""
    }
/*<       DO 130 J=II,LL >*/
#line 132 ""
    i__1 = ll;
#line 132 ""
    for (j = ii; j <= i__1; ++j) {
/*<         X(J) = 1 >*/
#line 133 ""
	x[j] = 1;
/*<   130 CONTINUE >*/
#line 134 ""
/* L130: */
#line 134 ""
    }
/*<       IF ( LL .EQ. N ) GO TO 150 >*/
#line 135 ""
    if (ll == *n) {
#line 135 ""
	goto L150;
#line 135 ""
    }
/*<       NN = LL + 1 >*/
#line 136 ""
    nn = ll + 1;
/*<       DO 140 J=NN,N >*/
#line 137 ""
    i__1 = *n;
#line 137 ""
    for (j = nn; j <= i__1; ++j) {
/*<         X(J) = 0 >*/
#line 138 ""
	x[j] = 0;
/*<   140 CONTINUE >*/
#line 139 ""
/* L140: */
#line 139 ""
    }
/*<   150 IF ( Z .NE. LIM ) GO TO 280 >*/
#line 140 ""
L150:
#line 140 ""
    if (*z__ != lim) {
#line 140 ""
	goto L280;
#line 140 ""
    }
/*<       RETURN >*/
#line 141 ""
    return 0;
/*<   160 IU = CHS*P(LL)/W(LL) >*/
#line 142 ""
L160:
#line 142 ""
    iu = chs * p[ll] / w[ll];
/*<       LL = LL - 1 >*/
#line 143 ""
    --ll;
/*<       IF ( IU .EQ. 0 ) GO TO 110 >*/
#line 144 ""
    if (iu == 0) {
#line 144 ""
	goto L110;
#line 144 ""
    }
/*<       IF ( Z .GE. PROFIT + IP + IU ) GO TO 280 >*/
#line 145 ""
    if (*z__ >= profit + ip + iu) {
#line 145 ""
	goto L280;
#line 145 ""
    }
/* SAVE THE CURRENT SOLUTION. */
/*<   170 WSIGN(II) = CH - CHS >*/
#line 147 ""
L170:
#line 147 ""
    wsign[ii] = ch - chs;
/*<       PSIGN(II) = IP >*/
#line 148 ""
    psign[ii] = ip;
/*<       ZSIGN(II) = LL + 1 >*/
#line 149 ""
    zsign[ii] = ll + 1;
/*<       XX(II) = 1 >*/
#line 150 ""
    xx[ii] = 1;
/*<       NN = LL - 1 >*/
#line 151 ""
    nn = ll - 1;
/*<       IF ( NN .LT. II) GO TO 190 >*/
#line 152 ""
    if (nn < ii) {
#line 152 ""
	goto L190;
#line 152 ""
    }
/*<       DO 180 J=II,NN >*/
#line 153 ""
    i__1 = nn;
#line 153 ""
    for (j = ii; j <= i__1; ++j) {
/*<         WSIGN(J+1) = WSIGN(J) - W(J) >*/
#line 154 ""
	wsign[j + 1] = wsign[j] - w[j];
/*<         PSIGN(J+1) = PSIGN(J) - P(J) >*/
#line 155 ""
	psign[j + 1] = psign[j] - p[j];
/*<         ZSIGN(J+1) = LL + 1 >*/
#line 156 ""
	zsign[j + 1] = ll + 1;
/*<         XX(J+1) = 1 >*/
#line 157 ""
	xx[j + 1] = 1;
/*<   180 CONTINUE >*/
#line 158 ""
/* L180: */
#line 158 ""
    }
/*<   190 J1 = LL + 1 >*/
#line 159 ""
L190:
#line 159 ""
    j1 = ll + 1;
/*<       DO 200 J=J1,LOLD >*/
#line 160 ""
    i__1 = lold;
#line 160 ""
    for (j = j1; j <= i__1; ++j) {
/*<         WSIGN(J) = 0 >*/
#line 161 ""
	wsign[j] = 0;
/*<         PSIGN(J) = 0 >*/
#line 162 ""
	psign[j] = 0;
/*<         ZSIGN(J) = J >*/
#line 163 ""
	zsign[j] = j;
/*<   200 CONTINUE >*/
#line 164 ""
/* L200: */
#line 164 ""
    }
/*<       LOLD = LL >*/
#line 165 ""
    lold = ll;
/*<       CH = CHS >*/
#line 166 ""
    ch = chs;
/*<       PROFIT = PROFIT + IP >*/
#line 167 ""
    profit += ip;
/*<       IF ( LL - (N - 2) ) 240, 220, 210 >*/
#line 168 ""
    if ((i__1 = ll - (*n - 2)) < 0) {
#line 168 ""
	goto L240;
#line 168 ""
    } else if (i__1 == 0) {
#line 168 ""
	goto L220;
#line 168 ""
    } else {
#line 168 ""
	goto L210;
#line 168 ""
    }
/*<   210 II = N >*/
#line 169 ""
L210:
#line 169 ""
    ii = *n;
/*<       GO TO 250 >*/
#line 170 ""
    goto L250;
/*<   220 IF ( CH .LT. W(N) ) GO TO 230 >*/
#line 171 ""
L220:
#line 171 ""
    if (ch < w[*n]) {
#line 171 ""
	goto L230;
#line 171 ""
    }
/*<       CH = CH - W(N) >*/
#line 172 ""
    ch -= w[*n];
/*<       PROFIT = PROFIT + P(N) >*/
#line 173 ""
    profit += p[*n];
/*<       XX(N) = 1 >*/
#line 174 ""
    xx[*n] = 1;
/*<   230 II = N - 1 >*/
#line 175 ""
L230:
#line 175 ""
    ii = *n - 1;
/*<       GO TO 250 >*/
#line 176 ""
    goto L250;
/*<   240 II = LL + 2 >*/
#line 177 ""
L240:
#line 177 ""
    ii = ll + 2;
/*<       IF ( CH .GE. MIN(II-1) ) GO TO 80 >*/
#line 178 ""
    if (ch >= min__[ii - 1]) {
#line 178 ""
	goto L80;
#line 178 ""
    }
/* SAVE THE CURRENT OPTIMAL SOLUTION. */
/*<   250 IF ( Z .GE. PROFIT ) GO TO 270 >*/
#line 180 ""
L250:
#line 180 ""
    if (*z__ >= profit) {
#line 180 ""
	goto L270;
#line 180 ""
    }
/*<       Z = PROFIT >*/
#line 181 ""
    *z__ = profit;
/*<       DO 260 J=1,N >*/
#line 182 ""
    i__1 = *n;
#line 182 ""
    for (j = 1; j <= i__1; ++j) {
/*<         X(J) = XX(J) >*/
#line 183 ""
	x[j] = xx[j];
/*<   260 CONTINUE >*/
#line 184 ""
/* L260: */
#line 184 ""
    }
/*<       IF ( Z .EQ. LIM ) RETURN >*/
#line 185 ""
    if (*z__ == lim) {
#line 185 ""
	return 0;
#line 185 ""
    }
/*<   270 IF ( XX(N) .EQ. 0 ) GO TO 280 >*/
#line 186 ""
L270:
#line 186 ""
    if (xx[*n] == 0) {
#line 186 ""
	goto L280;
#line 186 ""
    }
/*<       XX(N) = 0 >*/
#line 187 ""
    xx[*n] = 0;
/*<       CH = CH + W(N) >*/
#line 188 ""
    ch += w[*n];
/*<       PROFIT = PROFIT - P(N) >*/
#line 189 ""
    profit -= p[*n];
/* BACKTRACK. */
/*<   280 NN = II - 1 >*/
#line 191 ""
L280:
#line 191 ""
    nn = ii - 1;
/*<       IF ( NN .EQ. 0 ) RETURN >*/
#line 192 ""
    if (nn == 0) {
#line 192 ""
	return 0;
#line 192 ""
    }
/*<       DO 290 J=1,NN >*/
#line 193 ""
    i__1 = nn;
#line 193 ""
    for (j = 1; j <= i__1; ++j) {
/*<         KK = II - J >*/
#line 194 ""
	kk = ii - j;
/*<         IF ( XX(KK) .EQ. 1 ) GO TO 300 >*/
#line 195 ""
	if (xx[kk] == 1) {
#line 195 ""
	    goto L300;
#line 195 ""
	}
/*<   290 CONTINUE >*/
#line 196 ""
/* L290: */
#line 196 ""
    }
/*<       RETURN >*/
#line 197 ""
    return 0;
/*<   300 R = CH >*/
#line 198 ""
L300:
#line 198 ""
    r__ = ch;
/*<       CH = CH + W(KK) >*/
#line 199 ""
    ch += w[kk];
/*<       PROFIT = PROFIT - P(KK) >*/
#line 200 ""
    profit -= p[kk];
/*<       XX(KK) = 0 >*/
#line 201 ""
    xx[kk] = 0;
/*<       IF ( R .LT. MIN(KK) ) GO TO 310 >*/
#line 202 ""
    if (r__ < min__[kk]) {
#line 202 ""
	goto L310;
#line 202 ""
    }
/*<       II = KK + 1 >*/
#line 203 ""
    ii = kk + 1;
/*<       GO TO 80 >*/
#line 204 ""
    goto L80;
/*<   310 NN = KK + 1 >*/
#line 205 ""
L310:
#line 205 ""
    nn = kk + 1;
/*<       II = KK >*/
#line 206 ""
    ii = kk;
/* TRY TO SUBSTITUTE THE NN-TH ITEM FOR THE KK-TH. */
/*<   320 IF ( Z .GE. PROFIT + CH*P(NN)/W(NN) ) GO TO 280 >*/
#line 208 ""
L320:
#line 208 ""
    if (*z__ >= profit + ch * p[nn] / w[nn]) {
#line 208 ""
	goto L280;
#line 208 ""
    }
/*<       DIFF = W(NN) - W(KK) >*/
#line 209 ""
    diff = w[nn] - w[kk];
/*<       IF ( DIFF ) 370, 330, 340 >*/
#line 210 ""
    if (diff < 0) {
#line 210 ""
	goto L370;
#line 210 ""
    } else if (diff == 0) {
#line 210 ""
	goto L330;
#line 210 ""
    } else {
#line 210 ""
	goto L340;
#line 210 ""
    }
/*<   330 NN = NN + 1 >*/
#line 211 ""
L330:
#line 211 ""
    ++nn;
/*<       GO TO 320 >*/
#line 212 ""
    goto L320;
/*<   340 IF ( DIFF .GT. R ) GO TO 330 >*/
#line 213 ""
L340:
#line 213 ""
    if (diff > r__) {
#line 213 ""
	goto L330;
#line 213 ""
    }
/*<       IF ( Z .GE. PROFIT + P(NN) ) GO TO 330 >*/
#line 214 ""
    if (*z__ >= profit + p[nn]) {
#line 214 ""
	goto L330;
#line 214 ""
    }
/*<       Z = PROFIT + P(NN) >*/
#line 215 ""
    *z__ = profit + p[nn];
/*<       DO 350 J=1,KK >*/
#line 216 ""
    i__1 = kk;
#line 216 ""
    for (j = 1; j <= i__1; ++j) {
/*<         X(J) = XX(J) >*/
#line 217 ""
	x[j] = xx[j];
/*<   350 CONTINUE >*/
#line 218 ""
/* L350: */
#line 218 ""
    }
/*<       JJ = KK + 1 >*/
#line 219 ""
    jj = kk + 1;
/*<       DO 360 J=JJ,N >*/
#line 220 ""
    i__1 = *n;
#line 220 ""
    for (j = jj; j <= i__1; ++j) {
/*<         X(J) = 0 >*/
#line 221 ""
	x[j] = 0;
/*<   360 CONTINUE >*/
#line 222 ""
/* L360: */
#line 222 ""
    }
/*<       X(NN) = 1 >*/
#line 223 ""
    x[nn] = 1;
/*<       IF ( Z .EQ. LIM ) RETURN >*/
#line 224 ""
    if (*z__ == lim) {
#line 224 ""
	return 0;
#line 224 ""
    }
/*<       R = R - DIFF >*/
#line 225 ""
    r__ -= diff;
/*<       KK = NN >*/
#line 226 ""
    kk = nn;
/*<       NN = NN + 1 >*/
#line 227 ""
    ++nn;
/*<       GO TO 320 >*/
#line 228 ""
    goto L320;
/*<   370 T = R - DIFF >*/
#line 229 ""
L370:
#line 229 ""
    t = r__ - diff;
/*<       IF ( T .LT. MIN(NN) ) GO TO 330 >*/
#line 230 ""
    if (t < min__[nn]) {
#line 230 ""
	goto L330;
#line 230 ""
    }
/*<       IF ( Z .GE. PROFIT + P(NN) + T*P(NN+1)/W(NN+1)) GO TO 280 >*/
#line 231 ""
    if (*z__ >= profit + p[nn] + t * p[nn + 1] / w[nn + 1]) {
#line 231 ""
	goto L280;
#line 231 ""
    }
/*<       CH = CH - W(NN) >*/
#line 232 ""
    ch -= w[nn];
/*<       PROFIT = PROFIT + P(NN) >*/
#line 233 ""
    profit += p[nn];
/*<       XX(NN) = 1 >*/
#line 234 ""
    xx[nn] = 1;
/*<       II = NN + 1 >*/
#line 235 ""
    ii = nn + 1;
/*<       WSIGN(NN) = W(NN) >*/
#line 236 ""
    wsign[nn] = w[nn];
/*<       PSIGN(NN) = P(NN) >*/
#line 237 ""
    psign[nn] = p[nn];
/*<       ZSIGN(NN) = II >*/
#line 238 ""
    zsign[nn] = ii;
/*<       N1 = NN + 1 >*/
#line 239 ""
    n1 = nn + 1;
/*<       DO 380 J=N1,LOLD >*/
#line 240 ""
    i__1 = lold;
#line 240 ""
    for (j = n1; j <= i__1; ++j) {
/*<         WSIGN(J) = 0 >*/
#line 241 ""
	wsign[j] = 0;
/*<         PSIGN(J) = 0 >*/
#line 242 ""
	psign[j] = 0;
/*<         ZSIGN(J) = J >*/
#line 243 ""
	zsign[j] = j;
/*<   380 CONTINUE >*/
#line 244 ""
/* L380: */
#line 244 ""
    }
/*<       LOLD = NN >*/
#line 245 ""
    lold = nn;
/*<       GO TO 80 >*/
#line 246 ""
    goto L80;
/*<       END >*/
} /* mt1_ */

/*<       SUBROUTINE CHMT1(N,P,W,C,Z,JDIM) >*/
#if 1 /* by mao */
static
#endif
/* Subroutine */ int chmt1_(integer *n, integer *p, integer *w, integer *c__,
	integer *z__, integer *jdim)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    static integer j;
    static real r__, rr;
    static integer jsw;


/* CHECK THE INPUT DATA. */

/*<       INTEGER P(JDIM),W(JDIM),C,Z >*/
/*<       IF ( N .GE. 2 .AND. N .LE. JDIM - 1 ) GO TO 10 >*/
#line 253 ""
    /* Parameter adjustments */
#line 253 ""
    --w;
#line 253 ""
    --p;
#line 253 ""

#line 253 ""
    /* Function Body */
#line 253 ""
    if (*n >= 2 && *n <= *jdim - 1) {
#line 253 ""
	goto L10;
#line 253 ""
    }
/*<       Z = - 1 >*/
#line 254 ""
    *z__ = -1;
/*<       RETURN >*/
#line 255 ""
    return 0;
/*<    10 IF ( C .GT. 0 ) GO TO 30 >*/
#line 256 ""
L10:
#line 256 ""
    if (*c__ > 0) {
#line 256 ""
	goto L30;
#line 256 ""
    }
/*<    20 Z = - 2 >*/
#line 257 ""
L20:
#line 257 ""
    *z__ = -2;
/*<       RETURN >*/
#line 258 ""
    return 0;
/*<    30 JSW = 0 >*/
#line 259 ""
L30:
#line 259 ""
    jsw = 0;
/*<       RR = FLOAT(P(1))/FLOAT(W(1)) >*/
#line 260 ""
    rr = (real) p[1] / (real) w[1];
/*<       DO 50 J=1,N >*/
#line 261 ""
    i__1 = *n;
#line 261 ""
    for (j = 1; j <= i__1; ++j) {
/*<         R = RR >*/
#line 262 ""
	r__ = rr;
/*<         IF ( P(J) .LE. 0 ) GO TO 20 >*/
#line 263 ""
	if (p[j] <= 0) {
#line 263 ""
	    goto L20;
#line 263 ""
	}
/*<         IF ( W(J) .LE. 0 ) GO TO 20 >*/
#line 264 ""
	if (w[j] <= 0) {
#line 264 ""
	    goto L20;
#line 264 ""
	}
/*<         JSW = JSW + W(J) >*/
#line 265 ""
	jsw += w[j];
/*<         IF ( W(J) .LE. C ) GO TO 40 >*/
#line 266 ""
	if (w[j] <= *c__) {
#line 266 ""
	    goto L40;
#line 266 ""
	}
/*<         Z = - 3 >*/
#line 267 ""
	*z__ = -3;
/*<         RETURN >*/
#line 268 ""
	return 0;
/*<    40   RR = FLOAT(P(J))/FLOAT(W(J)) >*/
#line 269 ""
L40:
#line 269 ""
	rr = (real) p[j] / (real) w[j];
/*<         IF ( RR .LE. R ) GO TO 50 >*/
#line 270 ""
	if (rr <= r__) {
#line 270 ""
	    goto L50;
#line 270 ""
	}
/*<         Z = - 5 >*/
#line 271 ""
	*z__ = -5;
/*<         RETURN >*/
#line 272 ""
	return 0;
/*<    50 CONTINUE >*/
#line 273 ""
L50:
#line 273 ""
	;
#line 273 ""
    }
/*<       IF ( JSW .GT. C ) RETURN >*/
#line 274 ""
    if (jsw > *c__) {
#line 274 ""
	return 0;
#line 274 ""
    }
/*<       Z = - 4 >*/
#line 275 ""
    *z__ = -4;
/*<       RETURN >*/
#line 276 ""
    return 0;
/*<       END >*/
} /* chmt1_ */

#if 1 /* by mao */
int mt1(int n, int p[], int w[], int c, int x[], int jck, int xx[],
      int min[], int psign[], int wsign[], int zsign[])
{     /* solve 0-1 knapsack problem */
      int z, jdim = n+1, j, s1, s2;
      mt1_(&n, &p[1], &w[1], &c, &z, &x[1], &jdim, &jck, &xx[1],
         &min[1], &psign[1], &wsign[1], &zsign[1]);
      /* check solution found */
      s1 = s2 = 0;
      for (j = 1; j <= n; j++)
      {  xassert(x[j] == 0 || x[j] == 1);
         if (x[j])
            s1 += p[j], s2 += w[j];
      }
      xassert(s1 == z);
      xassert(s2 <= c);
      return z;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mt1.f0000644000175100001710000001617600000000000023722 0ustar00runnerdocker00000000000000      SUBROUTINE MT1(N,P,W,C,Z,X,JDIM,JCK,XX,MIN,PSIGN,WSIGN,ZSIGN)
C
C THIS SUBROUTINE SOLVES THE 0-1 SINGLE KNAPSACK PROBLEM
C
C MAXIMIZE  Z = P(1)*X(1) + ... + P(N)*X(N)
C
C SUBJECT TO:   W(1)*X(1) + ... + W(N)*X(N) .LE. C ,
C               X(J) = 0 OR 1  FOR J=1,...,N.
C
C THE PROGRAM IS INCLUDED IN THE VOLUME
C   S. MARTELLO, P. TOTH, "KNAPSACK PROBLEMS: ALGORITHMS
C   AND COMPUTER IMPLEMENTATIONS", JOHN WILEY, 1990
C AND IMPLEMENTS THE BRANCH-AND-BOUND ALGORITHM DESCRIBED IN
C SECTION  2.5.2 .
C THE PROGRAM DERIVES FROM AN EARLIER CODE PRESENTED IN
C  S. MARTELLO, P. TOTH, "ALGORITHM FOR THE SOLUTION OF THE 0-1 SINGLE
C  KNAPSACK PROBLEM", COMPUTING, 1978.
C
C THE INPUT PROBLEM MUST SATISFY THE CONDITIONS
C
C   1) 2 .LE. N .LE. JDIM - 1 ;
C   2) P(J), W(J), C  POSITIVE INTEGERS;
C   3) MAX (W(J)) .LE. C ;
C   4) W(1) + ... + W(N) .GT. C ;
C   5) P(J)/W(J) .GE. P(J+1)/W(J+1) FOR J=1,...,N-1.
C
C MT1 CALLS  1  PROCEDURE: CHMT1.
C
C THE PROGRAM IS COMPLETELY SELF-CONTAINED AND COMMUNICATION TO IT IS
C ACHIEVED SOLELY THROUGH THE PARAMETER LIST OF MT1.
C NO MACHINE-DEPENDENT CONSTANT IS USED.
C THE PROGRAM IS WRITTEN IN 1967 AMERICAN NATIONAL STANDARD FORTRAN
C AND IS ACCEPTED BY THE PFORT VERIFIER (PFORT IS THE PORTABLE
C SUBSET OF ANSI DEFINED BY THE ASSOCIATION FOR COMPUTING MACHINERY).
C THE PROGRAM HAS BEEN TESTED ON A DIGITAL VAX 11/780 AND AN H.P.
C 9000/840.
C
C MT1 NEEDS  8  ARRAYS ( P ,  W ,  X ,  XX ,  MIN ,  PSIGN ,  WSIGN
C                        AND  ZSIGN ) OF LENGTH AT LEAST  N + 1 .
C
C MEANING OF THE INPUT PARAMETERS:
C N    = NUMBER OF ITEMS;
C P(J) = PROFIT OF ITEM  J  (J=1,...,N);
C W(J) = WEIGHT OF ITEM  J  (J=1,...,N);
C C    = CAPACITY OF THE KNAPSACK;
C JDIM = DIMENSION OF THE 8 ARRAYS;
C JCK  = 1 IF CHECK ON THE INPUT DATA IS DESIRED,
C      = 0 OTHERWISE.
C
C MEANING OF THE OUTPUT PARAMETERS:
C Z    = VALUE OF THE OPTIMAL SOLUTION IF  Z .GT. 0 ,
C      = ERROR IN THE INPUT DATA (WHEN JCK=1) IF Z .LT. 0 : CONDI-
C        TION  - Z  IS VIOLATED;
C X(J) = 1 IF ITEM  J  IS IN THE OPTIMAL SOLUTION,
C      = 0 OTHERWISE.
C
C ARRAYS XX, MIN, PSIGN, WSIGN AND ZSIGN ARE DUMMY.
C
C ALL THE PARAMETERS ARE INTEGER. ON RETURN OF MT1 ALL THE INPUT
C PARAMETERS ARE UNCHANGED.
C
      INTEGER P(JDIM),W(JDIM),X(JDIM),C,Z
      INTEGER XX(JDIM),MIN(JDIM),PSIGN(JDIM),WSIGN(JDIM),ZSIGN(JDIM)
      INTEGER CH,CHS,DIFF,PROFIT,R,T
      Z = 0
      IF ( JCK .EQ. 1 ) CALL CHMT1(N,P,W,C,Z,JDIM)
      IF ( Z .LT. 0 ) RETURN
C INITIALIZE.
      CH = C
      IP = 0
      CHS = CH
      DO 10 LL=1,N
        IF ( W(LL) .GT. CHS ) GO TO 20
        IP = IP + P(LL)
        CHS = CHS - W(LL)
   10 CONTINUE
   20 LL = LL - 1
      IF ( CHS .EQ. 0 ) GO TO 50
      P(N+1) = 0
      W(N+1) = CH + 1
      LIM = IP + CHS*P(LL+2)/W(LL+2)
      A = W(LL+1) - CHS
      B = IP + P(LL+1)
      LIM1 = B - A*FLOAT(P(LL))/FLOAT(W(LL))
      IF ( LIM1 .GT. LIM ) LIM = LIM1
      MINK = CH + 1
      MIN(N) = MINK
      DO 30 J=2,N
        KK = N + 2 - J
        IF ( W(KK) .LT. MINK ) MINK = W(KK)
        MIN(KK-1) = MINK
   30 CONTINUE
      DO 40 J=1,N
        XX(J) = 0
   40 CONTINUE
      Z = 0
      PROFIT = 0
      LOLD = N
      II = 1
      GO TO 170
   50 Z = IP
      DO 60 J=1,LL
        X(J) = 1
   60 CONTINUE
      NN = LL + 1
      DO 70 J=NN,N
        X(J) = 0
   70 CONTINUE
      RETURN
C TRY TO INSERT THE II-TH ITEM INTO THE CURRENT SOLUTION.
   80 IF ( W(II) .LE. CH ) GO TO 90
      II1 = II + 1
      IF ( Z .GE. CH*P(II1)/W(II1) + PROFIT ) GO TO 280
      II = II1
      GO TO 80
C BUILD A NEW CURRENT SOLUTION.
   90 IP = PSIGN(II)
      CHS = CH - WSIGN(II)
      IN = ZSIGN(II)
      DO 100 LL=IN,N
        IF ( W(LL) .GT. CHS ) GO TO 160
        IP = IP + P(LL)
        CHS = CHS - W(LL)
  100 CONTINUE
      LL = N
  110 IF ( Z .GE. IP + PROFIT ) GO TO 280
      Z = IP + PROFIT
      NN = II - 1
      DO 120 J=1,NN
        X(J) = XX(J)
  120 CONTINUE
      DO 130 J=II,LL
        X(J) = 1
  130 CONTINUE
      IF ( LL .EQ. N ) GO TO 150
      NN = LL + 1
      DO 140 J=NN,N
        X(J) = 0
  140 CONTINUE
  150 IF ( Z .NE. LIM ) GO TO 280
      RETURN
  160 IU = CHS*P(LL)/W(LL)
      LL = LL - 1
      IF ( IU .EQ. 0 ) GO TO 110
      IF ( Z .GE. PROFIT + IP + IU ) GO TO 280
C SAVE THE CURRENT SOLUTION.
  170 WSIGN(II) = CH - CHS
      PSIGN(II) = IP
      ZSIGN(II) = LL + 1
      XX(II) = 1
      NN = LL - 1
      IF ( NN .LT. II) GO TO 190
      DO 180 J=II,NN
        WSIGN(J+1) = WSIGN(J) - W(J)
        PSIGN(J+1) = PSIGN(J) - P(J)
        ZSIGN(J+1) = LL + 1
        XX(J+1) = 1
  180 CONTINUE
  190 J1 = LL + 1
      DO 200 J=J1,LOLD
        WSIGN(J) = 0
        PSIGN(J) = 0
        ZSIGN(J) = J
  200 CONTINUE
      LOLD = LL
      CH = CHS
      PROFIT = PROFIT + IP
      IF ( LL - (N - 2) ) 240, 220, 210
  210 II = N
      GO TO 250
  220 IF ( CH .LT. W(N) ) GO TO 230
      CH = CH - W(N)
      PROFIT = PROFIT + P(N)
      XX(N) = 1
  230 II = N - 1
      GO TO 250
  240 II = LL + 2
      IF ( CH .GE. MIN(II-1) ) GO TO 80
C SAVE THE CURRENT OPTIMAL SOLUTION.
  250 IF ( Z .GE. PROFIT ) GO TO 270
      Z = PROFIT
      DO 260 J=1,N
        X(J) = XX(J)
  260 CONTINUE
      IF ( Z .EQ. LIM ) RETURN
  270 IF ( XX(N) .EQ. 0 ) GO TO 280
      XX(N) = 0
      CH = CH + W(N)
      PROFIT = PROFIT - P(N)
C BACKTRACK.
  280 NN = II - 1
      IF ( NN .EQ. 0 ) RETURN
      DO 290 J=1,NN
        KK = II - J
        IF ( XX(KK) .EQ. 1 ) GO TO 300
  290 CONTINUE
      RETURN
  300 R = CH
      CH = CH + W(KK)
      PROFIT = PROFIT - P(KK)
      XX(KK) = 0
      IF ( R .LT. MIN(KK) ) GO TO 310
      II = KK + 1
      GO TO 80
  310 NN = KK + 1
      II = KK
C TRY TO SUBSTITUTE THE NN-TH ITEM FOR THE KK-TH.
  320 IF ( Z .GE. PROFIT + CH*P(NN)/W(NN) ) GO TO 280
      DIFF = W(NN) - W(KK)
      IF ( DIFF ) 370, 330, 340
  330 NN = NN + 1
      GO TO 320
  340 IF ( DIFF .GT. R ) GO TO 330
      IF ( Z .GE. PROFIT + P(NN) ) GO TO 330
      Z = PROFIT + P(NN)
      DO 350 J=1,KK
        X(J) = XX(J)
  350 CONTINUE
      JJ = KK + 1
      DO 360 J=JJ,N
        X(J) = 0
  360 CONTINUE
      X(NN) = 1
      IF ( Z .EQ. LIM ) RETURN
      R = R - DIFF
      KK = NN
      NN = NN + 1
      GO TO 320
  370 T = R - DIFF
      IF ( T .LT. MIN(NN) ) GO TO 330
      IF ( Z .GE. PROFIT + P(NN) + T*P(NN+1)/W(NN+1)) GO TO 280
      CH = CH - W(NN)
      PROFIT = PROFIT + P(NN)
      XX(NN) = 1
      II = NN + 1
      WSIGN(NN) = W(NN)
      PSIGN(NN) = P(NN)
      ZSIGN(NN) = II
      N1 = NN + 1
      DO 380 J=N1,LOLD
        WSIGN(J) = 0
        PSIGN(J) = 0
        ZSIGN(J) = J
  380 CONTINUE
      LOLD = NN
      GO TO 80
      END
      SUBROUTINE CHMT1(N,P,W,C,Z,JDIM)
C
C CHECK THE INPUT DATA.
C
      INTEGER P(JDIM),W(JDIM),C,Z
      IF ( N .GE. 2 .AND. N .LE. JDIM - 1 ) GO TO 10
      Z = - 1
      RETURN
   10 IF ( C .GT. 0 ) GO TO 30
   20 Z = - 2
      RETURN
   30 JSW = 0
      RR = FLOAT(P(1))/FLOAT(W(1))
      DO 50 J=1,N
        R = RR
        IF ( P(J) .LE. 0 ) GO TO 20
        IF ( W(J) .LE. 0 ) GO TO 20
        JSW = JSW + W(J)
        IF ( W(J) .LE. C ) GO TO 40
        Z = - 3
        RETURN
   40   RR = FLOAT(P(J))/FLOAT(W(J))
        IF ( RR .LE. R ) GO TO 50
        Z = - 5
        RETURN
   50 CONTINUE
      IF ( JSW .GT. C ) RETURN
      Z = - 4
      RETURN
      END
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mt1.h0000644000175100001710000000231200000000000023707 0ustar00runnerdocker00000000000000/* mt1.h (0-1 knapsack problem; Martello & Toth algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2017-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MT1_H
#define MT1_H

#define mt1 _glp_mt1
int mt1(int n, int p[], int w[], int c, int x[], int jck, int xx[],
      int min[], int psign[], int wsign[], int zsign[]);
/* solve 0-1 single knapsack problem */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mygmp.c0000644000175100001710000007702500000000000024347 0ustar00runnerdocker00000000000000/* mygmp.c (integer and rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mygmp.h"

#ifdef HAVE_GMP               /* use GNU MP library */

/* nothing is needed */

#else                         /* use GLPK MP module */

#include "bignum.h"
#include "dmp.h"
#include "env.h"

#define gmp_pool env->gmp_pool
#define gmp_size env->gmp_size
#define gmp_work env->gmp_work

void *gmp_get_atom(int size)
{     ENV *env = get_env_ptr();
      if (gmp_pool == NULL)
         gmp_pool = dmp_create_pool();
      return dmp_get_atom(gmp_pool, size);
}

void gmp_free_atom(void *ptr, int size)
{     ENV *env = get_env_ptr();
      xassert(gmp_pool != NULL);
      dmp_free_atom(gmp_pool, ptr, size);
      return;
}

int gmp_pool_count(void)
{     ENV *env = get_env_ptr();
      if (gmp_pool == NULL)
         return 0;
      else
         return dmp_in_use(gmp_pool);
}

unsigned short *gmp_get_work(int size)
{     ENV *env = get_env_ptr();
      xassert(size > 0);
      if (gmp_size < size)
      {  if (gmp_size == 0)
         {  xassert(gmp_work == NULL);
            gmp_size = 100;
         }
         else
         {  xassert(gmp_work != NULL);
            xfree(gmp_work);
         }
         while (gmp_size < size)
            gmp_size += gmp_size;
         gmp_work = xcalloc(gmp_size, sizeof(unsigned short));
      }
      return gmp_work;
}

void gmp_free_mem(void)
{     ENV *env = get_env_ptr();
      if (gmp_pool != NULL)
         dmp_delete_pool(gmp_pool);
      if (gmp_work != NULL)
         xfree(gmp_work);
      gmp_pool = NULL;
      gmp_size = 0;
      gmp_work = NULL;
      return;
}

/*--------------------------------------------------------------------*/

mpz_t _mpz_init(void)
{     /* initialize x and set its value to 0 */
      mpz_t x;
      x = gmp_get_atom(sizeof(struct mpz));
      x->val = 0;
      x->ptr = NULL;
      return x;
}

void mpz_clear(mpz_t x)
{     /* free the space occupied by x */
      mpz_set_si(x, 0);
      xassert(x->ptr == NULL);
      /* free the number descriptor */
      gmp_free_atom(x, sizeof(struct mpz));
      return;
}

void mpz_set(mpz_t z, mpz_t x)
{     /* set the value of z from x */
      struct mpz_seg *e, *ee, *es;
      if (z != x)
      {  mpz_set_si(z, 0);
         z->val = x->val;
         xassert(z->ptr == NULL);
         for (e = x->ptr, es = NULL; e != NULL; e = e->next)
         {  ee = gmp_get_atom(sizeof(struct mpz_seg));
            memcpy(ee->d, e->d, 12);
            ee->next = NULL;
            if (z->ptr == NULL)
               z->ptr = ee;
            else
               es->next = ee;
            es = ee;
         }
      }
      return;
}

void mpz_set_si(mpz_t x, int val)
{     /* set the value of x to val */
      struct mpz_seg *e;
      /* free existing segments, if any */
      while (x->ptr != NULL)
      {  e = x->ptr;
         x->ptr = e->next;
         gmp_free_atom(e, sizeof(struct mpz_seg));
      }
      /* assign new value */
      if (val == 0x80000000)
      {  /* long format is needed */
         x->val = -1;
         x->ptr = e = gmp_get_atom(sizeof(struct mpz_seg));
         memset(e->d, 0, 12);
         e->d[1] = 0x8000;
         e->next = NULL;
      }
      else
      {  /* short format is enough */
         x->val = val;
      }
      return;
}

double mpz_get_d(mpz_t x)
{     /* convert x to a double, truncating if necessary */
      struct mpz_seg *e;
      int j;
      double val, deg;
      if (x->ptr == NULL)
         val = (double)x->val;
      else
      {  xassert(x->val != 0);
         val = 0.0;
         deg = 1.0;
         for (e = x->ptr; e != NULL; e = e->next)
         {  for (j = 0; j <= 5; j++)
            {  val += deg * (double)((int)e->d[j]);
               deg *= 65536.0;
            }
         }
         if (x->val < 0)
            val = - val;
      }
      return val;
}

double mpz_get_d_2exp(int *exp, mpz_t x)
{     /* convert x to a double, truncating if necessary (i.e. rounding
       * towards zero), and returning the exponent separately;
       * the return value is in the range 0.5 <= |d| < 1 and the
       * exponent is stored to *exp; d*2^exp is the (truncated) x value;
       * if x is zero, the return is 0.0 and 0 is stored to *exp;
       * this is similar to the standard C frexp function */
      struct mpz_seg *e;
      int j, n, n1;
      double val;
      if (x->ptr == NULL)
         val = (double)x->val, n = 0;
      else
      {  xassert(x->val != 0);
         val = 0.0, n = 0;
         for (e = x->ptr; e != NULL; e = e->next)
         {  for (j = 0; j <= 5; j++)
            {  val += (double)((int)e->d[j]);
               val /= 65536.0, n += 16;
            }
         }
         if (x->val < 0)
            val = - val;
      }
      val = frexp(val, &n1);
      *exp = n + n1;
      return val;
}

void mpz_swap(mpz_t x, mpz_t y)
{     /* swap the values x and y efficiently */
      int val;
      void *ptr;
      val = x->val, ptr = x->ptr;
      x->val = y->val, x->ptr = y->ptr;
      y->val = val, y->ptr = ptr;
      return;
}

static void normalize(mpz_t x)
{     /* normalize integer x that includes removing non-significant
       * (leading) zeros and converting to short format, if possible */
      struct mpz_seg *es, *e;
      /* if the integer is in short format, it remains unchanged */
      if (x->ptr == NULL)
      {  xassert(x->val != 0x80000000);
         goto done;
      }
      xassert(x->val == +1 || x->val == -1);
      /* find the last (most significant) non-zero segment */
      es = NULL;
      for (e = x->ptr; e != NULL; e = e->next)
      {  if (e->d[0] || e->d[1] || e->d[2] ||
             e->d[3] || e->d[4] || e->d[5])
            es = e;
      }
      /* if all segments contain zeros, the integer is zero */
      if (es == NULL)
      {  mpz_set_si(x, 0);
         goto done;
      }
      /* remove non-significant (leading) zero segments */
      while (es->next != NULL)
      {  e = es->next;
         es->next = e->next;
         gmp_free_atom(e, sizeof(struct mpz_seg));
      }
      /* convert the integer to short format, if possible */
      e = x->ptr;
      if (e->next == NULL && e->d[1] <= 0x7FFF &&
         !e->d[2] && !e->d[3] && !e->d[4] && !e->d[5])
      {  int val;
         val = (int)e->d[0] + ((int)e->d[1] << 16);
         if (x->val < 0)
            val = - val;
         mpz_set_si(x, val);
      }
done: return;
}

void mpz_add(mpz_t z, mpz_t x, mpz_t y)
{     /* set z to x + y */
      static struct mpz_seg zero = { { 0, 0, 0, 0, 0, 0 }, NULL };
      struct mpz_seg dumx, dumy, *ex, *ey, *ez, *es, *ee;
      int k, sx, sy, sz;
      unsigned int t;
      /* if [x] = 0 then [z] = [y] */
      if (x->val == 0)
      {  xassert(x->ptr == NULL);
         mpz_set(z, y);
         goto done;
      }
      /* if [y] = 0 then [z] = [x] */
      if (y->val == 0)
      {  xassert(y->ptr == NULL);
         mpz_set(z, x);
         goto done;
      }
      /* special case when both [x] and [y] are in short format */
      if (x->ptr == NULL && y->ptr == NULL)
      {  int xval = x->val, yval = y->val, zval = x->val + y->val;
         xassert(xval != 0x80000000 && yval != 0x80000000);
         if (!(xval > 0 && yval > 0 && zval <= 0 ||
               xval < 0 && yval < 0 && zval >= 0))
         {  mpz_set_si(z, zval);
            goto done;
         }
      }
      /* convert [x] to long format, if necessary */
      if (x->ptr == NULL)
      {  xassert(x->val != 0x80000000);
         if (x->val >= 0)
         {  sx = +1;
            t = (unsigned int)(+ x->val);
         }
         else
         {  sx = -1;
            t = (unsigned int)(- x->val);
         }
         ex = &dumx;
         ex->d[0] = (unsigned short)t;
         ex->d[1] = (unsigned short)(t >> 16);
         ex->d[2] = ex->d[3] = ex->d[4] = ex->d[5] = 0;
         ex->next = NULL;
      }
      else
      {  sx = x->val;
         xassert(sx == +1 || sx == -1);
         ex = x->ptr;
      }
      /* convert [y] to long format, if necessary */
      if (y->ptr == NULL)
      {  xassert(y->val != 0x80000000);
         if (y->val >= 0)
         {  sy = +1;
            t = (unsigned int)(+ y->val);
         }
         else
         {  sy = -1;
            t = (unsigned int)(- y->val);
         }
         ey = &dumy;
         ey->d[0] = (unsigned short)t;
         ey->d[1] = (unsigned short)(t >> 16);
         ey->d[2] = ey->d[3] = ey->d[4] = ey->d[5] = 0;
         ey->next = NULL;
      }
      else
      {  sy = y->val;
         xassert(sy == +1 || sy == -1);
         ey = y->ptr;
      }
      /* main fragment */
      sz = sx;
      ez = es = NULL;
      if (sx > 0 && sy > 0 || sx < 0 && sy < 0)
      {  /* [x] and [y] have identical signs -- addition */
         t = 0;
         for (; ex || ey; ex = ex->next, ey = ey->next)
         {  if (ex == NULL)
               ex = &zero;
            if (ey == NULL)
               ey = &zero;
            ee = gmp_get_atom(sizeof(struct mpz_seg));
            for (k = 0; k <= 5; k++)
            {  t += (unsigned int)ex->d[k];
               t += (unsigned int)ey->d[k];
               ee->d[k] = (unsigned short)t;
               t >>= 16;
            }
            ee->next = NULL;
            if (ez == NULL)
               ez = ee;
            else
               es->next = ee;
            es = ee;
         }
         if (t)
         {  /* overflow -- one extra digit is needed */
            ee = gmp_get_atom(sizeof(struct mpz_seg));
            ee->d[0] = 1;
            ee->d[1] = ee->d[2] = ee->d[3] = ee->d[4] = ee->d[5] = 0;
            ee->next = NULL;
            xassert(es != NULL);
            es->next = ee;
         }
      }
      else
      {  /* [x] and [y] have different signs -- subtraction */
         t = 1;
         for (; ex || ey; ex = ex->next, ey = ey->next)
         {  if (ex == NULL)
               ex = &zero;
            if (ey == NULL)
               ey = &zero;
            ee = gmp_get_atom(sizeof(struct mpz_seg));
            for (k = 0; k <= 5; k++)
            {  t += (unsigned int)ex->d[k];
               t += (0xFFFF - (unsigned int)ey->d[k]);
               ee->d[k] = (unsigned short)t;
               t >>= 16;
            }
            ee->next = NULL;
            if (ez == NULL)
               ez = ee;
            else
               es->next = ee;
            es = ee;
         }
         if (!t)
         {  /* |[x]| < |[y]| -- result in complement coding */
            sz = - sz;
            t = 1;
            for (ee = ez; ee != NULL; ee = ee->next)
            {  for (k = 0; k <= 5; k++)
               {  t += (0xFFFF - (unsigned int)ee->d[k]);
                  ee->d[k] = (unsigned short)t;
                  t >>= 16;
               }
            }
         }
      }
      /* contruct and normalize result */
      mpz_set_si(z, 0);
      z->val = sz;
      z->ptr = ez;
      normalize(z);
done: return;
}

void mpz_sub(mpz_t z, mpz_t x, mpz_t y)
{     /* set z to x - y */
      if (x == y)
         mpz_set_si(z, 0);
      else
      {  y->val = - y->val;
         mpz_add(z, x, y);
         if (y != z)
            y->val = - y->val;
      }
      return;
}

void mpz_mul(mpz_t z, mpz_t x, mpz_t y)
{     /* set z to x * y */
      struct mpz_seg dumx, dumy, *ex, *ey, *es, *e;
      int sx, sy, k, nx, ny, n;
      unsigned int t;
      unsigned short *work, *wx, *wy;
      /* if [x] = 0 then [z] = 0 */
      if (x->val == 0)
      {  xassert(x->ptr == NULL);
         mpz_set_si(z, 0);
         goto done;
      }
      /* if [y] = 0 then [z] = 0 */
      if (y->val == 0)
      {  xassert(y->ptr == NULL);
         mpz_set_si(z, 0);
         goto done;
      }
      /* special case when both [x] and [y] are in short format */
      if (x->ptr == NULL && y->ptr == NULL)
      {  int xval = x->val, yval = y->val, sz = +1;
         xassert(xval != 0x80000000 && yval != 0x80000000);
         if (xval < 0)
            xval = - xval, sz = - sz;
         if (yval < 0)
            yval = - yval, sz = - sz;
         if (xval <= 0x7FFFFFFF / yval)
         {  mpz_set_si(z, sz * (xval * yval));
            goto done;
         }
      }
      /* convert [x] to long format, if necessary */
      if (x->ptr == NULL)
      {  xassert(x->val != 0x80000000);
         if (x->val >= 0)
         {  sx = +1;
            t = (unsigned int)(+ x->val);
         }
         else
         {  sx = -1;
            t = (unsigned int)(- x->val);
         }
         ex = &dumx;
         ex->d[0] = (unsigned short)t;
         ex->d[1] = (unsigned short)(t >> 16);
         ex->d[2] = ex->d[3] = ex->d[4] = ex->d[5] = 0;
         ex->next = NULL;
      }
      else
      {  sx = x->val;
         xassert(sx == +1 || sx == -1);
         ex = x->ptr;
      }
      /* convert [y] to long format, if necessary */
      if (y->ptr == NULL)
      {  xassert(y->val != 0x80000000);
         if (y->val >= 0)
         {  sy = +1;
            t = (unsigned int)(+ y->val);
         }
         else
         {  sy = -1;
            t = (unsigned int)(- y->val);
         }
         ey = &dumy;
         ey->d[0] = (unsigned short)t;
         ey->d[1] = (unsigned short)(t >> 16);
         ey->d[2] = ey->d[3] = ey->d[4] = ey->d[5] = 0;
         ey->next = NULL;
      }
      else
      {  sy = y->val;
         xassert(sy == +1 || sy == -1);
         ey = y->ptr;
      }
      /* determine the number of digits of [x] */
      nx = n = 0;
      for (e = ex; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++)
         {  n++;
            if (e->d[k])
               nx = n;
         }
      }
      xassert(nx > 0);
      /* determine the number of digits of [y] */
      ny = n = 0;
      for (e = ey; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++)
         {  n++;
            if (e->d[k])
               ny = n;
         }
      }
      xassert(ny > 0);
      /* we need working array containing at least nx+ny+ny places */
      work = gmp_get_work(nx+ny+ny);
      /* load digits of [x] */
      wx = &work[0];
      for (n = 0; n < nx; n++)
         wx[ny+n] = 0;
      for (n = 0, e = ex; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++, n++)
         {  if (e->d[k])
               wx[ny+n] = e->d[k];
         }
      }
      /* load digits of [y] */
      wy = &work[nx+ny];
      for (n = 0; n < ny; n++) wy[n] = 0;
      for (n = 0, e = ey; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++, n++)
         {  if (e->d[k])
               wy[n] = e->d[k];
         }
      }
      /* compute [x] * [y] */
      bigmul(nx, ny, wx, wy);
      /* construct and normalize result */
      mpz_set_si(z, 0);
      z->val = sx * sy;
      es = NULL;
      k = 6;
      for (n = 0; n < nx+ny; n++)
      {  if (k > 5)
         {  e = gmp_get_atom(sizeof(struct mpz_seg));
            e->d[0] = e->d[1] = e->d[2] = 0;
            e->d[3] = e->d[4] = e->d[5] = 0;
            e->next = NULL;
            if (z->ptr == NULL)
               z->ptr = e;
            else
               es->next = e;
            es = e;
            k = 0;
         }
         es->d[k++] = wx[n];
      }
      normalize(z);
done: return;
}

void mpz_neg(mpz_t z, mpz_t x)
{     /* set z to 0 - x */
      mpz_set(z, x);
      z->val = - z->val;
      return;
}

void mpz_abs(mpz_t z, mpz_t x)
{     /* set z to the absolute value of x */
      mpz_set(z, x);
      if (z->val < 0)
         z->val = - z->val;
      return;
}

void mpz_div(mpz_t q, mpz_t r, mpz_t x, mpz_t y)
{     /* divide x by y, forming quotient q and/or remainder r
       * if q = NULL then quotient is not stored; if r = NULL then
       * remainder is not stored
       * the sign of quotient is determined as in algebra while the
       * sign of remainder is the same as the sign of dividend:
       * +26 : +7 = +3, remainder is +5
       * -26 : +7 = -3, remainder is -5
       * +26 : -7 = -3, remainder is +5
       * -26 : -7 = +3, remainder is -5 */
      struct mpz_seg dumx, dumy, *ex, *ey, *es, *e;
      int sx, sy, k, nx, ny, n;
      unsigned int t;
      unsigned short *work, *wx, *wy;
      /* divide by zero is not allowed */
      if (y->val == 0)
      {  xassert(y->ptr == NULL);
         xerror("mpz_div: divide by zero not allowed\n");
      }
      /* if [x] = 0 then [q] = [r] = 0 */
      if (x->val == 0)
      {  xassert(x->ptr == NULL);
         if (q != NULL)
            mpz_set_si(q, 0);
         if (r != NULL)
            mpz_set_si(r, 0);
         goto done;
      }
      /* special case when both [x] and [y] are in short format */
      if (x->ptr == NULL && y->ptr == NULL)
      {  int xval = x->val, yval = y->val;
         xassert(xval != 0x80000000 && yval != 0x80000000);
         /* FIXME: use div function */
         if (q != NULL)
            mpz_set_si(q, xval / yval);
         if (r != NULL)
            mpz_set_si(r, xval % yval);
         goto done;
      }
      /* convert [x] to long format, if necessary */
      if (x->ptr == NULL)
      {  xassert(x->val != 0x80000000);
         if (x->val >= 0)
         {  sx = +1;
            t = (unsigned int)(+ x->val);
         }
         else
         {  sx = -1;
            t = (unsigned int)(- x->val);
         }
         ex = &dumx;
         ex->d[0] = (unsigned short)t;
         ex->d[1] = (unsigned short)(t >> 16);
         ex->d[2] = ex->d[3] = ex->d[4] = ex->d[5] = 0;
         ex->next = NULL;
      }
      else
      {  sx = x->val;
         xassert(sx == +1 || sx == -1);
         ex = x->ptr;
      }
      /* convert [y] to long format, if necessary */
      if (y->ptr == NULL)
      {  xassert(y->val != 0x80000000);
         if (y->val >= 0)
         {  sy = +1;
            t = (unsigned int)(+ y->val);
         }
         else
         {  sy = -1;
            t = (unsigned int)(- y->val);
         }
         ey = &dumy;
         ey->d[0] = (unsigned short)t;
         ey->d[1] = (unsigned short)(t >> 16);
         ey->d[2] = ey->d[3] = ey->d[4] = ey->d[5] = 0;
         ey->next = NULL;
      }
      else
      {  sy = y->val;
         xassert(sy == +1 || sy == -1);
         ey = y->ptr;
      }
      /* determine the number of digits of [x] */
      nx = n = 0;
      for (e = ex; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++)
         {  n++;
            if (e->d[k])
               nx = n;
         }
      }
      xassert(nx > 0);
      /* determine the number of digits of [y] */
      ny = n = 0;
      for (e = ey; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++)
         {  n++;
            if (e->d[k])
               ny = n;
         }
      }
      xassert(ny > 0);
      /* if nx < ny then [q] = 0 and [r] = [x] */
      if (nx < ny)
      {  if (r != NULL)
            mpz_set(r, x);
         if (q != NULL)
            mpz_set_si(q, 0);
         goto done;
      }
      /* we need working array containing at least nx+ny+1 places */
      work = gmp_get_work(nx+ny+1);
      /* load digits of [x] */
      wx = &work[0];
      for (n = 0; n < nx; n++)
         wx[n] = 0;
      for (n = 0, e = ex; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++, n++)
            if (e->d[k]) wx[n] = e->d[k];
      }
      /* load digits of [y] */
      wy = &work[nx+1];
      for (n = 0; n < ny; n++)
         wy[n] = 0;
      for (n = 0, e = ey; e != NULL; e = e->next)
      {  for (k = 0; k <= 5; k++, n++)
            if (e->d[k]) wy[n] = e->d[k];
      }
      /* compute quotient and remainder */
      xassert(wy[ny-1] != 0);
      bigdiv(nx-ny, ny, wx, wy);
      /* construct and normalize quotient */
      if (q != NULL)
      {  mpz_set_si(q, 0);
         q->val = sx * sy;
         es = NULL;
         k = 6;
         for (n = ny; n <= nx; n++)
         {  if (k > 5)
            {  e = gmp_get_atom(sizeof(struct mpz_seg));
               e->d[0] = e->d[1] = e->d[2] = 0;
               e->d[3] = e->d[4] = e->d[5] = 0;
               e->next = NULL;
               if (q->ptr == NULL)
                  q->ptr = e;
               else
                  es->next = e;
               es = e;
               k = 0;
            }
            es->d[k++] = wx[n];
         }
         normalize(q);
      }
      /* construct and normalize remainder */
      if (r != NULL)
      {  mpz_set_si(r, 0);
         r->val = sx;
         es = NULL;
         k = 6;
         for (n = 0; n < ny; n++)
         {  if (k > 5)
            {  e = gmp_get_atom(sizeof(struct mpz_seg));
               e->d[0] = e->d[1] = e->d[2] = 0;
               e->d[3] = e->d[4] = e->d[5] = 0;
               e->next = NULL;
               if (r->ptr == NULL)
                  r->ptr = e;
               else
                  es->next = e;
               es = e;
               k = 0;
            }
            es->d[k++] = wx[n];
         }
         normalize(r);
      }
done: return;
}

void mpz_gcd(mpz_t z, mpz_t x, mpz_t y)
{     /* set z to the greatest common divisor of x and y */
      /* in case of arbitrary integers GCD(x, y) = GCD(|x|, |y|), and,
       * in particular, GCD(0, 0) = 0 */
      mpz_t u, v, r;
      mpz_init(u);
      mpz_init(v);
      mpz_init(r);
      mpz_abs(u, x);
      mpz_abs(v, y);
      while (mpz_sgn(v))
      {  mpz_div(NULL, r, u, v);
         mpz_set(u, v);
         mpz_set(v, r);
      }
      mpz_set(z, u);
      mpz_clear(u);
      mpz_clear(v);
      mpz_clear(r);
      return;
}

int mpz_cmp(mpz_t x, mpz_t y)
{     /* compare x and y; return a positive value if x > y, zero if
       * x = y, or a nefative value if x < y */
      static struct mpz_seg zero = { { 0, 0, 0, 0, 0, 0 }, NULL };
      struct mpz_seg dumx, dumy, *ex, *ey;
      int cc, sx, sy, k;
      unsigned int t;
      if (x == y)
      {  cc = 0;
         goto done;
      }
      /* special case when both [x] and [y] are in short format */
      if (x->ptr == NULL && y->ptr == NULL)
      {  int xval = x->val, yval = y->val;
         xassert(xval != 0x80000000 && yval != 0x80000000);
         cc = (xval > yval ? +1 : xval < yval ? -1 : 0);
         goto done;
      }
      /* special case when [x] and [y] have different signs */
      if (x->val > 0 && y->val <= 0 || x->val == 0 && y->val < 0)
      {  cc = +1;
         goto done;
      }
      if (x->val < 0 && y->val >= 0 || x->val == 0 && y->val > 0)
      {  cc = -1;
         goto done;
      }
      /* convert [x] to long format, if necessary */
      if (x->ptr == NULL)
      {  xassert(x->val != 0x80000000);
         if (x->val >= 0)
         {  sx = +1;
            t = (unsigned int)(+ x->val);
         }
         else
         {  sx = -1;
            t = (unsigned int)(- x->val);
         }
         ex = &dumx;
         ex->d[0] = (unsigned short)t;
         ex->d[1] = (unsigned short)(t >> 16);
         ex->d[2] = ex->d[3] = ex->d[4] = ex->d[5] = 0;
         ex->next = NULL;
      }
      else
      {  sx = x->val;
         xassert(sx == +1 || sx == -1);
         ex = x->ptr;
      }
      /* convert [y] to long format, if necessary */
      if (y->ptr == NULL)
      {  xassert(y->val != 0x80000000);
         if (y->val >= 0)
         {  sy = +1;
            t = (unsigned int)(+ y->val);
         }
         else
         {  sy = -1;
            t = (unsigned int)(- y->val);
         }
         ey = &dumy;
         ey->d[0] = (unsigned short)t;
         ey->d[1] = (unsigned short)(t >> 16);
         ey->d[2] = ey->d[3] = ey->d[4] = ey->d[5] = 0;
         ey->next = NULL;
      }
      else
      {  sy = y->val;
         xassert(sy == +1 || sy == -1);
         ey = y->ptr;
      }
      /* main fragment */
      xassert(sx > 0 && sy > 0 || sx < 0 && sy < 0);
      cc = 0;
      for (; ex || ey; ex = ex->next, ey = ey->next)
      {  if (ex == NULL)
            ex = &zero;
         if (ey == NULL)
            ey = &zero;
         for (k = 0; k <= 5; k++)
         {  if (ex->d[k] > ey->d[k])
               cc = +1;
            if (ex->d[k] < ey->d[k])
               cc = -1;
         }
      }
      if (sx < 0) cc = - cc;
done: return cc;
}

int mpz_sgn(mpz_t x)
{     /* return +1 if x > 0, 0 if x = 0, and -1 if x < 0 */
      int s;
      s = (x->val > 0 ? +1 : x->val < 0 ? -1 : 0);
      return s;
}

int mpz_out_str(void *_fp, int base, mpz_t x)
{     /* output x on stream fp, as a string in given base; the base
       * may vary from 2 to 36;
       * return the number of bytes written, or if an error occurred,
       * return 0 */
      FILE *fp = _fp;
      mpz_t b, y, r;
      int n, j, nwr = 0;
      unsigned char *d;
      static char *set = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      if (!(2 <= base && base <= 36))
         xerror("mpz_out_str: base = %d; invalid base\n", base);
      mpz_init(b);
      mpz_set_si(b, base);
      mpz_init(y);
      mpz_init(r);
      /* determine the number of digits */
      mpz_abs(y, x);
      for (n = 0; mpz_sgn(y) != 0; n++)
         mpz_div(y, NULL, y, b);
      if (n == 0) n = 1;
      /* compute the digits */
      d = xmalloc(n);
      mpz_abs(y, x);
      for (j = 0; j < n; j++)
      {  mpz_div(y, r, y, b);
         xassert(0 <= r->val && r->val < base && r->ptr == NULL);
         d[j] = (unsigned char)r->val;
      }
      /* output the integer to the stream */
      if (fp == NULL)
         fp = stdout;
      if (mpz_sgn(x) < 0)
         fputc('-', fp), nwr++;
      for (j = n-1; j >= 0; j--)
         fputc(set[d[j]], fp), nwr++;
      if (ferror(fp))
         nwr = 0;
      mpz_clear(b);
      mpz_clear(y);
      mpz_clear(r);
      xfree(d);
      return nwr;
}

/*--------------------------------------------------------------------*/

mpq_t _mpq_init(void)
{     /* initialize x, and set its value to 0/1 */
      mpq_t x;
      x = gmp_get_atom(sizeof(struct mpq));
      x->p.val = 0;
      x->p.ptr = NULL;
      x->q.val = 1;
      x->q.ptr = NULL;
      return x;
}

void mpq_clear(mpq_t x)
{     /* free the space occupied by x */
      mpz_set_si(&x->p, 0);
      xassert(x->p.ptr == NULL);
      mpz_set_si(&x->q, 0);
      xassert(x->q.ptr == NULL);
      /* free the number descriptor */
      gmp_free_atom(x, sizeof(struct mpq));
      return;
}

void mpq_canonicalize(mpq_t x)
{     /* remove any factors that are common to the numerator and
       * denominator of x, and make the denominator positive */
      mpz_t f;
      xassert(x->q.val != 0);
      if (x->q.val < 0)
      {  mpz_neg(&x->p, &x->p);
         mpz_neg(&x->q, &x->q);
      }
      mpz_init(f);
      mpz_gcd(f, &x->p, &x->q);
      if (!(f->val == 1 && f->ptr == NULL))
      {  mpz_div(&x->p, NULL, &x->p, f);
         mpz_div(&x->q, NULL, &x->q, f);
      }
      mpz_clear(f);
      return;
}

void mpq_set(mpq_t z, mpq_t x)
{     /* set the value of z from x */
      if (z != x)
      {  mpz_set(&z->p, &x->p);
         mpz_set(&z->q, &x->q);
      }
      return;
}

void mpq_set_si(mpq_t x, int p, unsigned int q)
{     /* set the value of x to p/q */
      if (q == 0)
         xerror("mpq_set_si: zero denominator not allowed\n");
      mpz_set_si(&x->p, p);
      xassert(q <= 0x7FFFFFFF);
      mpz_set_si(&x->q, q);
      return;
}

double mpq_get_d(mpq_t x)
{     /* convert x to a double, truncating if necessary */
      int np, nq;
      double p, q;
      p = mpz_get_d_2exp(&np, &x->p);
      q = mpz_get_d_2exp(&nq, &x->q);
      return ldexp(p / q, np - nq);
}

void mpq_set_d(mpq_t x, double val)
{     /* set x to val; there is no rounding, the conversion is exact */
      int s, n, d, j;
      double f;
      mpz_t temp;
      xassert(-DBL_MAX <= val && val <= +DBL_MAX);
      mpq_set_si(x, 0, 1);
      if (val > 0.0)
         s = +1;
      else if (val < 0.0)
         s = -1;
      else
         goto done;
      f = frexp(fabs(val), &n);
      /* |val| = f * 2^n, where 0.5 <= f < 1.0 */
      mpz_init(temp);
      while (f != 0.0)
      {  f *= 16.0, n -= 4;
         d = (int)f;
         xassert(0 <= d && d <= 15);
         f -= (double)d;
         /* x := 16 * x + d */
         mpz_set_si(temp, 16);
         mpz_mul(&x->p, &x->p, temp);
         mpz_set_si(temp, d);
         mpz_add(&x->p, &x->p, temp);
      }
      mpz_clear(temp);
      /* x := x * 2^n */
      if (n > 0)
      {  for (j = 1; j <= n; j++)
            mpz_add(&x->p, &x->p, &x->p);
      }
      else if (n < 0)
      {  for (j = 1; j <= -n; j++)
            mpz_add(&x->q, &x->q, &x->q);
         mpq_canonicalize(x);
      }
      if (s < 0)
         mpq_neg(x, x);
done: return;
}

void mpq_add(mpq_t z, mpq_t x, mpq_t y)
{     /* set z to x + y */
      mpz_t p, q;
      mpz_init(p);
      mpz_init(q);
      mpz_mul(p, &x->p, &y->q);
      mpz_mul(q, &x->q, &y->p);
      mpz_add(p, p, q);
      mpz_mul(q, &x->q, &y->q);
      mpz_set(&z->p, p);
      mpz_set(&z->q, q);
      mpz_clear(p);
      mpz_clear(q);
      mpq_canonicalize(z);
      return;
}

void mpq_sub(mpq_t z, mpq_t x, mpq_t y)
{     /* set z to x - y */
      mpz_t p, q;
      mpz_init(p);
      mpz_init(q);
      mpz_mul(p, &x->p, &y->q);
      mpz_mul(q, &x->q, &y->p);
      mpz_sub(p, p, q);
      mpz_mul(q, &x->q, &y->q);
      mpz_set(&z->p, p);
      mpz_set(&z->q, q);
      mpz_clear(p);
      mpz_clear(q);
      mpq_canonicalize(z);
      return;
}

void mpq_mul(mpq_t z, mpq_t x, mpq_t y)
{     /* set z to x * y */
      mpz_mul(&z->p, &x->p, &y->p);
      mpz_mul(&z->q, &x->q, &y->q);
      mpq_canonicalize(z);
      return;
}

void mpq_div(mpq_t z, mpq_t x, mpq_t y)
{     /* set z to x / y */
      mpz_t p, q;
      if (mpq_sgn(y) == 0)
         xerror("mpq_div: zero divisor not allowed\n");
      mpz_init(p);
      mpz_init(q);
      mpz_mul(p, &x->p, &y->q);
      mpz_mul(q, &x->q, &y->p);
      mpz_set(&z->p, p);
      mpz_set(&z->q, q);
      mpz_clear(p);
      mpz_clear(q);
      mpq_canonicalize(z);
      return;
}

void mpq_neg(mpq_t z, mpq_t x)
{     /* set z to 0 - x */
      mpq_set(z, x);
      mpz_neg(&z->p, &z->p);
      return;
}

void mpq_abs(mpq_t z, mpq_t x)
{     /* set z to the absolute value of x */
      mpq_set(z, x);
      mpz_abs(&z->p, &z->p);
      xassert(mpz_sgn(&x->q) > 0);
      return;
}

int mpq_cmp(mpq_t x, mpq_t y)
{     /* compare x and y; return a positive value if x > y, zero if
       * x = y, or a negative value if x < y */
      mpq_t temp;
      int s;
      mpq_init(temp);
      mpq_sub(temp, x, y);
      s = mpq_sgn(temp);
      mpq_clear(temp);
      return s;
}

int mpq_sgn(mpq_t x)
{     /* return +1 if x > 0, 0 if x = 0, and -1 if x < 0 */
      int s;
      s = mpz_sgn(&x->p);
      xassert(mpz_sgn(&x->q) > 0);
      return s;
}

int mpq_out_str(void *_fp, int base, mpq_t x)
{     /* output x on stream fp, as a string in given base; the base
       * may vary from 2 to 36; output is in the form 'num/den' or if
       * the denominator is 1 then just 'num';
       * if the parameter fp is a null pointer, stdout is assumed;
       * return the number of bytes written, or if an error occurred,
       * return 0 */
      FILE *fp = _fp;
      int nwr;
      if (!(2 <= base && base <= 36))
         xerror("mpq_out_str: base = %d; invalid base\n", base);
      if (fp == NULL)
         fp = stdout;
      nwr = mpz_out_str(fp, base, &x->p);
      if (x->q.val == 1 && x->q.ptr == NULL)
         ;
      else
      {  fputc('/', fp), nwr++;
         nwr += mpz_out_str(fp, base, &x->q);
      }
      if (ferror(fp))
         nwr = 0;
      return nwr;
}

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/mygmp.h0000644000175100001710000001545400000000000024352 0ustar00runnerdocker00000000000000/* mygmp.h (integer and rational arithmetic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2008-2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MYGMP_H
#define MYGMP_H

#ifdef HAVE_CONFIG_H
#include 
#endif

#ifdef HAVE_GMP               /* use GNU MP library */

#include 

#define gmp_pool_count() 0

#define gmp_free_mem() ((void)0)

#else                         /* use GLPK MP module */

/***********************************************************************
*  INTEGER NUMBERS
*  ---------------
*  Depending on its magnitude an integer number of arbitrary precision
*  is represented either in short format or in long format.
*
*  Short format corresponds to the int type and allows representing
*  integer numbers in the range [-(2^31-1), +(2^31-1)]. Note that for
*  the most negative number of int type the short format is not used.
*
*  In long format integer numbers are represented using the positional
*  system with the base (radix) 2^16 = 65536:
*
*     x = (-1)^s sum{j in 0..n-1} d[j] * 65536^j,
*
*  where x is the integer to be represented, s is its sign (+1 or -1),
*  d[j] are its digits (0 <= d[j] <= 65535).
*
*  RATIONAL NUMBERS
*  ----------------
*  A rational number is represented as an irreducible fraction:
*
*     p / q,
*
*  where p (numerator) and q (denominator) are integer numbers (q > 0)
*  having no common divisors. */

struct mpz
{     /* integer number */
      int val;
      /* if ptr is a null pointer, the number is in short format, and
         val is its value; otherwise, the number is in long format, and
         val is its sign (+1 or -1) */
      struct mpz_seg *ptr;
      /* pointer to the linked list of the number segments ordered in
         ascending of powers of the base */
};

struct mpz_seg
{     /* integer number segment */
      unsigned short d[6];
      /* six digits of the number ordered in ascending of powers of the
         base */
      struct mpz_seg *next;
      /* pointer to the next number segment */
};

struct mpq
{     /* rational number (p / q) */
      struct mpz p;
      /* numerator */
      struct mpz q;
      /* denominator */
};

typedef struct mpz *mpz_t;
typedef struct mpq *mpq_t;

#define gmp_get_atom _glp_gmp_get_atom
void *gmp_get_atom(int size);

#define gmp_free_atom _glp_gmp_free_atom
void gmp_free_atom(void *ptr, int size);

#define gmp_pool_count _glp_gmp_pool_count
int gmp_pool_count(void);

#define gmp_get_work _glp_gmp_get_work
unsigned short *gmp_get_work(int size);

#define gmp_free_mem _glp_gmp_free_mem
void gmp_free_mem(void);

#define mpz_init(x) (void)((x) = _mpz_init())

#define _mpz_init _glp_mpz_init
mpz_t _mpz_init(void);
/* initialize x and set its value to 0 */

#define mpz_clear _glp_mpz_clear
void mpz_clear(mpz_t x);
/* free the space occupied by x */

#define mpz_set _glp_mpz_set
void mpz_set(mpz_t z, mpz_t x);
/* set the value of z from x */

#define mpz_set_si _glp_mpz_set_si
void mpz_set_si(mpz_t x, int val);
/* set the value of x to val */

#define mpz_get_d _glp_mpz_get_d
double mpz_get_d(mpz_t x);
/* convert x to a double, truncating if necessary */

#define mpz_get_d_2exp _glp_mpz_get_d_2exp
double mpz_get_d_2exp(int *exp, mpz_t x);
/* convert x to a double, returning the exponent separately */

#define mpz_swap _glp_mpz_swap
void mpz_swap(mpz_t x, mpz_t y);
/* swap the values x and y efficiently */

#define mpz_add _glp_mpz_add
void mpz_add(mpz_t, mpz_t, mpz_t);
/* set z to x + y */

#define mpz_sub _glp_mpz_sub
void mpz_sub(mpz_t, mpz_t, mpz_t);
/* set z to x - y */

#define mpz_mul _glp_mpz_mul
void mpz_mul(mpz_t, mpz_t, mpz_t);
/* set z to x * y */

#define mpz_neg _glp_mpz_neg
void mpz_neg(mpz_t z, mpz_t x);
/* set z to 0 - x */

#define mpz_abs _glp_mpz_abs
void mpz_abs(mpz_t z, mpz_t x);
/* set z to the absolute value of x */

#define mpz_div _glp_mpz_div
void mpz_div(mpz_t q, mpz_t r, mpz_t x, mpz_t y);
/* divide x by y, forming quotient q and/or remainder r */

#define mpz_gcd _glp_mpz_gcd
void mpz_gcd(mpz_t z, mpz_t x, mpz_t y);
/* set z to the greatest common divisor of x and y */

#define mpz_cmp _glp_mpz_cmp
int mpz_cmp(mpz_t x, mpz_t y);
/* compare x and y */

#define mpz_sgn _glp_mpz_sgn
int mpz_sgn(mpz_t x);
/* return +1 if x > 0, 0 if x = 0, and -1 if x < 0 */

#define mpz_out_str _glp_mpz_out_str
int mpz_out_str(void *fp, int base, mpz_t x);
/* output x on stream fp, as a string in given base */

#define mpq_init(x) (void)((x) = _mpq_init())

#define _mpq_init _glp_mpq_init
mpq_t _mpq_init(void);
/* initialize x, and set its value to 0/1 */

#define mpq_clear _glp_mpq_clear
void mpq_clear(mpq_t x);
/* free the space occupied by x */

#define mpq_canonicalize _glp_mpq_canonicalize
void mpq_canonicalize(mpq_t x);
/* canonicalize x */

#define mpq_set _glp_mpq_set
void mpq_set(mpq_t z, mpq_t x);
/* set the value of z from x */

#define mpq_set_si _glp_mpq_set_si
void mpq_set_si(mpq_t x, int p, unsigned int q);
/* set the value of x to p/q */

#define mpq_get_d _glp_mpq_get_d
double mpq_get_d(mpq_t x);
/* convert x to a double, truncating if necessary */

#define mpq_set_d _glp_mpq_set_d
void mpq_set_d(mpq_t x, double val);
/* set x to val; there is no rounding, the conversion is exact */

#define mpq_add _glp_mpq_add
void mpq_add(mpq_t z, mpq_t x, mpq_t y);
/* set z to x + y */

#define mpq_sub _glp_mpq_sub
void mpq_sub(mpq_t z, mpq_t x, mpq_t y);
/* set z to x - y */

#define mpq_mul _glp_mpq_mul
void mpq_mul(mpq_t z, mpq_t x, mpq_t y);
/* set z to x * y */

#define mpq_div _glp_mpq_div
void mpq_div(mpq_t z, mpq_t x, mpq_t y);
/* set z to x / y */

#define mpq_neg _glp_mpq_neg
void mpq_neg(mpq_t z, mpq_t x);
/* set z to 0 - x */

#define mpq_abs _glp_mpq_abs
void mpq_abs(mpq_t z, mpq_t x);
/* set z to the absolute value of x */

#define mpq_cmp _glp_mpq_cmp
int mpq_cmp(mpq_t x, mpq_t y);
/* compare x and y */

#define mpq_sgn _glp_mpq_sgn
int mpq_sgn(mpq_t x);
/* return +1 if x > 0, 0 if x = 0, and -1 if x < 0 */

#define mpq_out_str _glp_mpq_out_str
int mpq_out_str(void *fp, int base, mpq_t x);
/* output x on stream fp, as a string in given base */

#endif

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/okalg.c0000644000175100001710000003040400000000000024301 0ustar00runnerdocker00000000000000/* okalg.c (out-of-kilter algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "okalg.h"

/***********************************************************************
*  NAME
*
*  okalg - out-of-kilter algorithm
*
*  SYNOPSIS
*
*  #include "okalg.h"
*  int okalg(int nv, int na, const int tail[], const int head[],
*     const int low[], const int cap[], const int cost[], int x[],
*     int pi[]);
*
*  DESCRIPTION
*
*  The routine okalg implements the out-of-kilter algorithm to find a
*  minimal-cost circulation in the specified flow network.
*
*  INPUT PARAMETERS
*
*  nv is the number of nodes, nv >= 0.
*
*  na is the number of arcs, na >= 0.
*
*  tail[a], a = 1,...,na, is the index of tail node of arc a.
*
*  head[a], a = 1,...,na, is the index of head node of arc a.
*
*  low[a], a = 1,...,na, is an lower bound to the flow through arc a.
*
*  cap[a], a = 1,...,na, is an upper bound to the flow through arc a,
*  which is the capacity of the arc.
*
*  cost[a], a = 1,...,na, is a per-unit cost of the flow through arc a.
*
*  NOTES
*
*  1. Multiple arcs are allowed, but self-loops are not allowed.
*
*  2. It is required that 0 <= low[a] <= cap[a] for all arcs.
*
*  3. Arc costs may have any sign.
*
*  OUTPUT PARAMETERS
*
*  x[a], a = 1,...,na, is optimal value of the flow through arc a.
*
*  pi[i], i = 1,...,nv, is Lagrange multiplier for flow conservation
*  equality constraint corresponding to node i (the node potential).
*
*  RETURNS
*
*  0  optimal circulation found;
*
*  1  there is no feasible circulation;
*
*  2  integer overflow occured;
*
*  3  optimality test failed (logic error).
*
*  REFERENCES
*
*  L.R.Ford, Jr., and D.R.Fulkerson, "Flows in Networks," The RAND
*  Corp., Report R-375-PR (August 1962), Chap. III "Minimal Cost Flow
*  Problems," pp.113-26. */

static int overflow(int u, int v)
{     /* check for integer overflow on computing u + v */
      if (u > 0 && v > 0 && u + v < 0) return 1;
      if (u < 0 && v < 0 && u + v > 0) return 1;
      return 0;
}

int okalg(int nv, int na, const int tail[], const int head[],
      const int low[], const int cap[], const int cost[], int x[],
      int pi[])
{     int a, aok, delta, i, j, k, lambda, pos1, pos2, s, t, temp, ret,
         *ptr, *arc, *link, *list;
      /* sanity checks */
      xassert(nv >= 0);
      xassert(na >= 0);
      for (a = 1; a <= na; a++)
      {  i = tail[a], j = head[a];
         xassert(1 <= i && i <= nv);
         xassert(1 <= j && j <= nv);
         xassert(i != j);
         xassert(0 <= low[a] && low[a] <= cap[a]);
      }
      /* allocate working arrays */
      ptr = xcalloc(1+nv+1, sizeof(int));
      arc = xcalloc(1+na+na, sizeof(int));
      link = xcalloc(1+nv, sizeof(int));
      list = xcalloc(1+nv, sizeof(int));
      /* ptr[i] := (degree of node i) */
      for (i = 1; i <= nv; i++)
         ptr[i] = 0;
      for (a = 1; a <= na; a++)
      {  ptr[tail[a]]++;
         ptr[head[a]]++;
      }
      /* initialize arc pointers */
      ptr[1]++;
      for (i = 1; i < nv; i++)
         ptr[i+1] += ptr[i];
      ptr[nv+1] = ptr[nv];
      /* build arc lists */
      for (a = 1; a <= na; a++)
      {  arc[--ptr[tail[a]]] = a;
         arc[--ptr[head[a]]] = a;
      }
      xassert(ptr[1] == 1);
      xassert(ptr[nv+1] == na+na+1);
      /* now the indices of arcs incident to node i are stored in
       * locations arc[ptr[i]], arc[ptr[i]+1], ..., arc[ptr[i+1]-1] */
      /* initialize arc flows and node potentials */
      for (a = 1; a <= na; a++)
         x[a] = 0;
      for (i = 1; i <= nv; i++)
         pi[i] = 0;
loop: /* main loop starts here */
      /* find out-of-kilter arc */
      aok = 0;
      for (a = 1; a <= na; a++)
      {  i = tail[a], j = head[a];
         if (overflow(cost[a], pi[i] - pi[j]))
         {  ret = 2;
            goto done;
         }
         lambda = cost[a] + (pi[i] - pi[j]);
         if (x[a] < low[a] || (lambda < 0 && x[a] < cap[a]))
         {  /* arc a = i->j is out of kilter, and we need to increase
             * the flow through this arc */
            aok = a, s = j, t = i;
            break;
         }
         if (x[a] > cap[a] || (lambda > 0 && x[a] > low[a]))
         {  /* arc a = i->j is out of kilter, and we need to decrease
             * the flow through this arc */
            aok = a, s = i, t = j;
            break;
         }
      }
      if (aok == 0)
      {  /* all arcs are in kilter */
         /* check for feasibility */
         for (a = 1; a <= na; a++)
         {  if (!(low[a] <= x[a] && x[a] <= cap[a]))
            {  ret = 3;
               goto done;
            }
         }
         for (i = 1; i <= nv; i++)
         {  temp = 0;
            for (k = ptr[i]; k < ptr[i+1]; k++)
            {  a = arc[k];
               if (tail[a] == i)
               {  /* a is outgoing arc */
                  temp += x[a];
               }
               else if (head[a] == i)
               {  /* a is incoming arc */
                  temp -= x[a];
               }
               else
                  xassert(a != a);
            }
            if (temp != 0)
            {  ret = 3;
               goto done;
            }
         }
         /* check for optimality */
         for (a = 1; a <= na; a++)
         {  i = tail[a], j = head[a];
            lambda = cost[a] + (pi[i] - pi[j]);
            if ((lambda > 0 && x[a] != low[a]) ||
                (lambda < 0 && x[a] != cap[a]))
            {  ret = 3;
               goto done;
            }
         }
         /* current circulation is optimal */
         ret = 0;
         goto done;
      }
      /* now we need to find a cycle (t, a, s, ..., t), which allows
       * increasing the flow along it, where a is the out-of-kilter arc
       * just found */
      /* link[i] = 0 means that node i is not labelled yet;
       * link[i] = a means that arc a immediately precedes node i */
      /* initially only node s is labelled */
      for (i = 1; i <= nv; i++)
         link[i] = 0;
      link[s] = aok, list[1] = s, pos1 = pos2 = 1;
      /* breadth first search */
      while (pos1 <= pos2)
      {  /* dequeue node i */
         i = list[pos1++];
         /* consider all arcs incident to node i */
         for (k = ptr[i]; k < ptr[i+1]; k++)
         {  a = arc[k];
            if (tail[a] == i)
            {  /* a = i->j is a forward arc from s to t */
               j = head[a];
               /* if node j has been labelled, skip the arc */
               if (link[j] != 0) continue;
               /* if the arc does not allow increasing the flow through
                * it, skip the arc */
               if (x[a] >= cap[a]) continue;
               if (overflow(cost[a], pi[i] - pi[j]))
               {  ret = 2;
                  goto done;
               }
               lambda = cost[a] + (pi[i] - pi[j]);
               if (lambda > 0 && x[a] >= low[a]) continue;
            }
            else if (head[a] == i)
            {  /* a = i<-j is a backward arc from s to t */
               j = tail[a];
               /* if node j has been labelled, skip the arc */
               if (link[j] != 0) continue;
               /* if the arc does not allow decreasing the flow through
                * it, skip the arc */
               if (x[a] <= low[a]) continue;
               if (overflow(cost[a], pi[j] - pi[i]))
               {  ret = 2;
                  goto done;
               }
               lambda = cost[a] + (pi[j] - pi[i]);
               if (lambda < 0 && x[a] <= cap[a]) continue;
            }
            else
               xassert(a != a);
            /* label node j and enqueue it */
            link[j] = a, list[++pos2] = j;
            /* check for breakthrough */
            if (j == t) goto brkt;
         }
      }
      /* NONBREAKTHROUGH */
      /* consider all arcs, whose one endpoint is labelled and other is
       * not, and determine maximal change of node potentials */
      delta = 0;
      for (a = 1; a <= na; a++)
      {  i = tail[a], j = head[a];
         if (link[i] != 0 && link[j] == 0)
         {  /* a = i->j, where node i is labelled, node j is not */
            if (overflow(cost[a], pi[i] - pi[j]))
            {  ret = 2;
               goto done;
            }
            lambda = cost[a] + (pi[i] - pi[j]);
            if (x[a] <= cap[a] && lambda > 0)
               if (delta == 0 || delta > + lambda) delta = + lambda;
         }
         else if (link[i] == 0 && link[j] != 0)
         {  /* a = j<-i, where node j is labelled, node i is not */
            if (overflow(cost[a], pi[i] - pi[j]))
            {  ret = 2;
               goto done;
            }
            lambda = cost[a] + (pi[i] - pi[j]);
            if (x[a] >= low[a] && lambda < 0)
               if (delta == 0 || delta > - lambda) delta = - lambda;
         }
      }
      if (delta == 0)
      {  /* there is no feasible circulation */
         ret = 1;
         goto done;
      }
      /* increase potentials of all unlabelled nodes */
      for (i = 1; i <= nv; i++)
      {  if (link[i] == 0)
         {  if (overflow(pi[i], delta))
            {  ret = 2;
               goto done;
            }
            pi[i] += delta;
         }
      }
      goto loop;
brkt: /* BREAKTHROUGH */
      /* walk through arcs of the cycle (t, a, s, ..., t) found in the
       * reverse order and determine maximal change of the flow */
      delta = 0;
      for (j = t;; j = i)
      {  /* arc a immediately precedes node j in the cycle */
         a = link[j];
         if (head[a] == j)
         {  /* a = i->j is a forward arc of the cycle */
            i = tail[a];
            lambda = cost[a] + (pi[i] - pi[j]);
            if (lambda > 0 && x[a] < low[a])
            {  /* x[a] may be increased until its lower bound */
               temp = low[a] - x[a];
            }
            else if (lambda <= 0 && x[a] < cap[a])
            {  /* x[a] may be increased until its upper bound */
               temp = cap[a] - x[a];
            }
            else
               xassert(a != a);
         }
         else if (tail[a] == j)
         {  /* a = i<-j is a backward arc of the cycle */
            i = head[a];
            lambda = cost[a] + (pi[j] - pi[i]);
            if (lambda < 0 && x[a] > cap[a])
            {  /* x[a] may be decreased until its upper bound */
               temp = x[a] - cap[a];
            }
            else if (lambda >= 0 && x[a] > low[a])
            {  /* x[a] may be decreased until its lower bound */
               temp = x[a] - low[a];
            }
            else
               xassert(a != a);
         }
         else
            xassert(a != a);
         if (delta == 0 || delta > temp) delta = temp;
         /* check for end of the cycle */
         if (i == t) break;
      }
      xassert(delta > 0);
      /* increase the flow along the cycle */
      for (j = t;; j = i)
      {  /* arc a immediately precedes node j in the cycle */
         a = link[j];
         if (head[a] == j)
         {  /* a = i->j is a forward arc of the cycle */
            i = tail[a];
            /* overflow cannot occur */
            x[a] += delta;
         }
         else if (tail[a] == j)
         {  /* a = i<-j is a backward arc of the cycle */
            i = head[a];
            /* overflow cannot occur */
            x[a] -= delta;
         }
         else
            xassert(a != a);
         /* check for end of the cycle */
         if (i == t) break;
      }
      goto loop;
done: /* free working arrays */
      xfree(ptr);
      xfree(arc);
      xfree(link);
      xfree(list);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/okalg.h0000644000175100001710000000230700000000000024307 0ustar00runnerdocker00000000000000/* okalg.h (out-of-kilter algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef OKALG_H
#define OKALG_H

#define okalg _glp_okalg
int okalg(int nv, int na, const int tail[], const int head[],
      const int low[], const int cap[], const int cost[], int x[],
      int pi[]);
/* out-of-kilter algorithm */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/qmd.c0000644000175100001710000000621100000000000023764 0ustar00runnerdocker00000000000000/* qmd.c */

#include "env.h"
#include "qmd.h"

void genqmd(int *neqns, int xadj[], int adjncy[], int perm[],
      int invp[], int deg[], int marker[], int rchset[], int nbrhd[],
      int qsize[], int qlink[], int *nofsub)
{     static const char func[] = "genqmd";
      xassert(neqns == neqns);
      xassert(xadj == xadj);
      xassert(adjncy == adjncy);
      xassert(perm == perm);
      xassert(invp == invp);
      xassert(deg == deg);
      xassert(marker == marker);
      xassert(rchset == rchset);
      xassert(nbrhd == nbrhd);
      xassert(qsize == qsize);
      xassert(qlink == qlink);
      xassert(nofsub == nofsub);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
}

void qmdrch(int *root, int xadj[], int adjncy[], int deg[],
      int marker[], int *rchsze, int rchset[], int *nhdsze,
      int nbrhd[])
{     static const char func[] = "qmdrch";
      xassert(root == root);
      xassert(xadj == xadj);
      xassert(adjncy == adjncy);
      xassert(deg == deg);
      xassert(marker == marker);
      xassert(rchsze == rchsze);
      xassert(rchset == rchset);
      xassert(nhdsze == nhdsze);
      xassert(nbrhd == nbrhd);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
}

void qmdqt(int *root, int xadj[], int adjncy[], int marker[],
      int *rchsze, int rchset[], int nbrhd[])
{     static const char func[] = "qmdqt";
      xassert(root == root);
      xassert(xadj == xadj);
      xassert(adjncy == adjncy);
      xassert(marker == marker);
      xassert(rchsze == rchsze);
      xassert(rchset == rchset);
      xassert(nbrhd == nbrhd);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
}

void qmdupd(int xadj[], int adjncy[], int *nlist, int list[],
      int deg[], int qsize[], int qlink[], int marker[], int rchset[],
      int nbrhd[])
{     static const char func[] = "qmdupd";
      xassert(xadj == xadj);
      xassert(adjncy == adjncy);
      xassert(nlist == nlist);
      xassert(list == list);
      xassert(deg == deg);
      xassert(qsize == qsize);
      xassert(qlink == qlink);
      xassert(marker == marker);
      xassert(rchset == rchset);
      xassert(nbrhd == nbrhd);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
}

void qmdmrg(int xadj[], int adjncy[], int deg[], int qsize[],
      int qlink[], int marker[], int *deg0, int *nhdsze, int nbrhd[],
      int rchset[], int ovrlp[])
{     static const char func[] = "qmdmrg";
      xassert(xadj == xadj);
      xassert(adjncy == adjncy);
      xassert(deg == deg);
      xassert(qsize == qsize);
      xassert(qlink == qlink);
      xassert(marker == marker);
      xassert(deg0 == deg0);
      xassert(nhdsze == nhdsze);
      xassert(nbrhd == nbrhd);
      xassert(rchset == rchset);
      xassert(ovrlp == ovrlp);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
     /*  abort(); */
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/qmd.h0000644000175100001710000000404100000000000023770 0ustar00runnerdocker00000000000000/* qmd.h (quotient minimum degree algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2001 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef QMD_H
#define QMD_H

#define genqmd _glp_genqmd
void genqmd(int *neqns, int xadj[], int adjncy[], int perm[],
      int invp[], int deg[], int marker[], int rchset[], int nbrhd[],
      int qsize[], int qlink[], int *nofsub);
/* GENeral Quotient Minimum Degree algorithm */

#define qmdrch _glp_qmdrch
void qmdrch(int *root, int xadj[], int adjncy[], int deg[],
      int marker[], int *rchsze, int rchset[], int *nhdsze,
      int nbrhd[]);
/* Quotient MD ReaCHable set */

#define qmdqt _glp_qmdqt
void qmdqt(int *root, int xadj[], int adjncy[], int marker[],
      int *rchsze, int rchset[], int nbrhd[]);
/* Quotient MD Quotient graph Transformation */

#define qmdupd _glp_qmdupd
void qmdupd(int xadj[], int adjncy[], int *nlist, int list[],
      int deg[], int qsize[], int qlink[], int marker[], int rchset[],
      int nbrhd[]);
/* Quotient MD UPDate */

#define qmdmrg _glp_qmdmrg
void qmdmrg(int xadj[], int adjncy[], int deg[], int qsize[],
      int qlink[], int marker[], int *deg0, int *nhdsze, int nbrhd[],
      int rchset[], int ovrlp[]);
/* Quotient MD MeRGe */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/relax4.c0000644000175100001710000000110000000000000024372 0ustar00runnerdocker00000000000000/* relax4.c */

#include "env.h"
#include "relax4.h"

int relax4(struct relax4_csa *csa)
{     static const char func[] = "relax4";
      xassert(csa == csa);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
      return -1;
}

void relax4_inidat(struct relax4_csa *csa)
{     static const char func[] = "relax4_inidat";
      xassert(csa == csa);
      xerror("%s: sorry, this routine is temporarily disabled due to li"
         "censing problems\n", func);
      /* abort(); */
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/relax4.h0000644000175100001710000000764100000000000024417 0ustar00runnerdocker00000000000000/* relax4.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef RELAX4_H
#define RELAX4_H

struct relax4_csa
{     /* common storage area */
      /* input parameters --------------------------------------------*/
      int n;
      /* number of nodes */
      int na;
      /* number of arcs */
      int large;
      /* very large int to represent infinity */
      int repeat;
      /* true if initialization is to be skipped (false otherwise) */
      int crash;
      /* 0 if default initialization is used
       * 1 if auction initialization is used */
      int *startn; /* int startn[1+na]; */
      /* startn[j] = starting node for arc j, j = 1,...,na */
      int *endn; /* int endn[1+na] */
      /* endn[j] = ending node for arc j, j = 1,...,na */
      int *fou; /* int fou[1+n]; */
      /* fou[i] = first arc out of node i, i = 1,...,n */
      int *nxtou; /* int nxtou[1+na]; */
      /* nxtou[j] = next arc out of the starting node of arc j,
       * j = 1,...,na */
      int *fin; /* int fin[1+n]; */
      /* fin[i] = first arc into node i, i = 1,...,n */
      int *nxtin; /* int nxtin[1+na]; */
      /* nxtin[j] = next arc into the ending node of arc j,
       * j = 1,...,na */
      /* updated parameters ------------------------------------------*/
      int *rc; /* int rc[1+na]; */
      /* rc[j] = reduced cost of arc j, j = 1,...,na */
      int *u; /* int u[1+na]; */
      /* u[j] = capacity of arc j on input
       * and (capacity of arc j) - x(j) on output, j = 1,...,na */
      int *dfct; /* int dfct[1+n]; */
      /* dfct[i] = demand at node i on input
       * and zero on output, i = 1,...,n */
      /* output parameters -------------------------------------------*/
      int *x; /* int x[1+na]; */
      /* x[j] = flow on arc j, j = 1,...,na */
      int nmultinode;
      /* number of multinode relaxation iterations in RELAX4 */
      int iter;
      /* number of relaxation iterations in RELAX4 */
      int num_augm;
      /* number of flow augmentation steps in RELAX4 */
      int num_ascnt;
      /* number of multinode ascent steps in RELAX4 */
      int nsp;
      /* number of auction/shortest path iterations */
      /* working parameters ------------------------------------------*/
      int *label; /* int label, tempin, p[1+n]; */
      int *prdcsr; /* int prdcsr, tempou, price[1+n]; */
      int *save; /* int save[1+na]; */
      int *tfstou; /* int tfstou, fpushf[1+n]; */
      int *tnxtou; /* int tnxtou, nxtpushf[1+na]; */
      int *tfstin; /* int tfstin, fpushb[1+n]; */
      int *tnxtin; /* int tnxtin, nxtpushb[1+na]; */
      int *nxtqueue; /* int nxtqueue[1+n]; */
      char *scan; /* bool scan[1+n]; */
      char *mark; /* bool mark, path_id[1+n]; */
      /* working parameters used by routine auction only -------------*/
      int *extend_arc; /* int extend_arc[1+n]; */
      int *sb_level; /* int sb_level[1+n]; */
      int *sb_arc; /* int sb_arc[1+n]; */
};

#define relax4 _glp_relax4
int relax4(struct relax4_csa *csa);

#define relax4_inidat _glp_relax4_inidat
void relax4_inidat(struct relax4_csa *csa);

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/rgr.c0000644000175100001710000001407400000000000024003 0ustar00runnerdocker00000000000000/* rgr.c (raster graphics) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "rgr.h"

/***********************************************************************
*  NAME
*
*  rgr_write_bmp16 - write 16-color raster image in BMP file format
*
*  SYNOPSIS
*
*  #include "rgr.h"
*  int rgr_write_bmp16(const char *fname, int m, int n, const char
*     map[]);
*
*  DESCRIPTION
*
*  The routine rgr_write_bmp16 writes 16-color raster image in
*  uncompressed BMP file format (Windows bitmap) to a binary file whose
*  name is specified by the character string fname.
*
*  The parameters m and n specify, respectively, the number of rows and
*  the numbers of columns (i.e. height and width) of the raster image.
*
*  The character array map has m*n elements. Elements map[0, ..., n-1]
*  correspond to the first (top) scanline, elements map[n, ..., 2*n-1]
*  correspond to the second scanline, etc.
*
*  Each element of the array map specifies a color of the corresponding
*  pixel as 8-bit binary number XXXXIRGB, where four high-order bits (X)
*  are ignored, I is high intensity bit, R is red color bit, G is green
*  color bit, and B is blue color bit. Thus, all 16 possible colors are
*  coded as following hexadecimal numbers:
*
*     0x00 = black         0x08 = dark gray
*     0x01 = blue          0x09 = bright blue
*     0x02 = green         0x0A = bright green
*     0x03 = cyan          0x0B = bright cyan
*     0x04 = red           0x0C = bright red
*     0x05 = magenta       0x0D = bright magenta
*     0x06 = brown         0x0E = yellow
*     0x07 = light gray    0x0F = white
*
*  RETURNS
*
*  If no error occured, the routine returns zero; otherwise, it prints
*  an appropriate error message and returns non-zero. */

static void put_byte(FILE *fp, int c)
{     fputc(c, fp);
      return;
}

static void put_word(FILE *fp, int w)
{     /* big endian */
      put_byte(fp, w);
      put_byte(fp, w >> 8);
      return;
}

static void put_dword(FILE *fp, int d)
{     /* big endian */
      put_word(fp, d);
      put_word(fp, d >> 16);
      return;
}

int rgr_write_bmp16(const char *fname, int m, int n, const char map[])
{     FILE *fp;
      int offset, bmsize, i, j, b, ret = 0;
      if (!(1 <= m && m <= 32767))
         xerror("rgr_write_bmp16: m = %d; invalid height\n", m);
      if (!(1 <= n && n <= 32767))
         xerror("rgr_write_bmp16: n = %d; invalid width\n", n);
      fp = fopen(fname, "wb");
      if (fp == NULL)
      {  xprintf("rgr_write_bmp16: unable to create '%s' - %s\n",
#if 0 /* 29/I-2017 */
            fname, strerror(errno));
#else
            fname, xstrerr(errno));
#endif
         ret = 1;
         goto fini;
      }
      offset = 14 + 40 + 16 * 4;
      bmsize = (4 * n + 31) / 32;
      /* struct BMPFILEHEADER (14 bytes) */
      /* UINT bfType */          put_byte(fp, 'B'), put_byte(fp, 'M');
      /* DWORD bfSize */         put_dword(fp, offset + bmsize * 4);
      /* UINT bfReserved1 */     put_word(fp, 0);
      /* UNIT bfReserved2 */     put_word(fp, 0);
      /* DWORD bfOffBits */      put_dword(fp, offset);
      /* struct BMPINFOHEADER (40 bytes) */
      /* DWORD biSize */         put_dword(fp, 40);
      /* LONG biWidth */         put_dword(fp, n);
      /* LONG biHeight */        put_dword(fp, m);
      /* WORD biPlanes */        put_word(fp, 1);
      /* WORD biBitCount */      put_word(fp, 4);
      /* DWORD biCompression */  put_dword(fp, 0 /* BI_RGB */);
      /* DWORD biSizeImage */    put_dword(fp, 0);
      /* LONG biXPelsPerMeter */ put_dword(fp, 2953 /* 75 dpi */);
      /* LONG biYPelsPerMeter */ put_dword(fp, 2953 /* 75 dpi */);
      /* DWORD biClrUsed */      put_dword(fp, 0);
      /* DWORD biClrImportant */ put_dword(fp, 0);
      /* struct RGBQUAD (16 * 4 = 64 bytes) */
      /* CGA-compatible colors: */
      /* 0x00 = black */         put_dword(fp, 0x000000);
      /* 0x01 = blue */          put_dword(fp, 0x000080);
      /* 0x02 = green */         put_dword(fp, 0x008000);
      /* 0x03 = cyan */          put_dword(fp, 0x008080);
      /* 0x04 = red */           put_dword(fp, 0x800000);
      /* 0x05 = magenta */       put_dword(fp, 0x800080);
      /* 0x06 = brown */         put_dword(fp, 0x808000);
      /* 0x07 = light gray */    put_dword(fp, 0xC0C0C0);
      /* 0x08 = dark gray */     put_dword(fp, 0x808080);
      /* 0x09 = bright blue */   put_dword(fp, 0x0000FF);
      /* 0x0A = bright green */  put_dword(fp, 0x00FF00);
      /* 0x0B = bright cyan */   put_dword(fp, 0x00FFFF);
      /* 0x0C = bright red */    put_dword(fp, 0xFF0000);
      /* 0x0D = bright magenta */ put_dword(fp, 0xFF00FF);
      /* 0x0E = yellow */        put_dword(fp, 0xFFFF00);
      /* 0x0F = white */         put_dword(fp, 0xFFFFFF);
      /* pixel data bits */
      b = 0;
      for (i = m - 1; i >= 0; i--)
      {  for (j = 0; j < ((n + 7) / 8) * 8; j++)
         {  b <<= 4;
            b |= (j < n ? map[i * n + j] & 15 : 0);
            if (j & 1) put_byte(fp, b);
         }
      }
      fflush(fp);
      if (ferror(fp))
      {  xprintf("rgr_write_bmp16: write error on '%s' - %s\n",
#if 0 /* 29/I-2017 */
            fname, strerror(errno));
#else
            fname, xstrerr(errno));
#endif
         ret = 1;
      }
fini: if (fp != NULL) fclose(fp);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/rgr.h0000644000175100001710000000223200000000000024001 0ustar00runnerdocker00000000000000/* rgr.h (raster graphics) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef RGR_H
#define RGR_H

#define rgr_write_bmp16 _glp_rgr_write_bmp16
int rgr_write_bmp16(const char *fname, int m, int n, const char map[]);
/* write 16-color raster image in BMP file format */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/rng.c0000644000175100001710000001414600000000000023777 0ustar00runnerdocker00000000000000/* rng.c (pseudo-random number generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  This code is a modified version of the module GB_FLIP, a portable
*  pseudo-random number generator. The original version of GB_FLIP is
*  a part of The Stanford GraphBase developed by Donald E. Knuth (see
*  http://www-cs-staff.stanford.edu/~knuth/sgb.html).
*
*  Note that all changes concern only external names, so this modified
*  version produces exactly the same results as the original version.
*
*  Changes were made by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "rng.h"

#if 0
int A[56] = { -1 };
#else
#define A (rand->A)
#endif
/* pseudo-random values */

#if 0
int *fptr = A;
#else
#define fptr (rand->fptr)
#endif
/* the next A value to be exported */

#define mod_diff(x, y) (((x) - (y)) & 0x7FFFFFFF)
/* difference modulo 2^31 */

static int flip_cycle(RNG *rand)
{     /* this is an auxiliary routine to do 55 more steps of the basic
       * recurrence, at high speed, and to reset fptr */
      int *ii, *jj;
      for (ii = &A[1], jj = &A[32]; jj <= &A[55]; ii++, jj++)
         *ii = mod_diff(*ii, *jj);
      for (jj = &A[1]; ii <= &A[55]; ii++, jj++)
         *ii = mod_diff(*ii, *jj);
      fptr = &A[54];
      return A[55];
}

/***********************************************************************
*  NAME
*
*  rng_create_rand - create pseudo-random number generator
*
*  SYNOPSIS
*
*  #include "rng.h"
*  RNG *rng_create_rand(void);
*
*  DESCRIPTION
*
*  The routine rng_create_rand creates and initializes a pseudo-random
*  number generator.
*
*  RETURNS
*
*  The routine returns a pointer to the generator created. */

RNG *rng_create_rand(void)
{     RNG *rand;
      int i;
      rand = talloc(1, RNG);
      A[0] = -1;
      for (i = 1; i <= 55; i++) A[i] = 0;
      fptr = A;
      rng_init_rand(rand, 1);
      return rand;
}

/***********************************************************************
*  NAME
*
*  rng_init_rand - initialize pseudo-random number generator
*
*  SYNOPSIS
*
*  #include "rng.h"
*  void rng_init_rand(RNG *rand, int seed);
*
*  DESCRIPTION
*
*  The routine rng_init_rand initializes the pseudo-random number
*  generator. The parameter seed may be any integer number. Note that
*  on creating the generator this routine is called with the parameter
*  seed equal to 1. */

void rng_init_rand(RNG *rand, int seed)
{     int i;
      int prev = seed, next = 1;
      seed = prev = mod_diff(prev, 0);
      A[55] = prev;
      for (i = 21; i; i = (i + 21) % 55)
      {  A[i] = next;
         next = mod_diff(prev, next);
         if (seed & 1)
            seed = 0x40000000 + (seed >> 1);
         else
            seed >>= 1;
         next = mod_diff(next, seed);
         prev = A[i];
      }
      flip_cycle(rand);
      flip_cycle(rand);
      flip_cycle(rand);
      flip_cycle(rand);
      flip_cycle(rand);
      return;
}

/***********************************************************************
*  NAME
*
*  rng_next_rand - obtain pseudo-random integer in the range [0, 2^31-1]
*
*  SYNOPSIS
*
*  #include "rng.h"
*  int rng_next_rand(RNG *rand);
*
*  RETURNS
*
*  The routine rng_next_rand returns a next pseudo-random integer which
*  is uniformly distributed between 0 and 2^31-1, inclusive. The period
*  length of the generated numbers is 2^85 - 2^30. The low order bits of
*  the generated numbers are just as random as the high-order bits. */

int rng_next_rand(RNG *rand)
{     return
         *fptr >= 0 ? *fptr-- : flip_cycle(rand);
}

/***********************************************************************
*  NAME
*
*  rng_unif_rand - obtain pseudo-random integer in the range [0, m-1]
*
*  SYNOPSIS
*
*  #include "rng.h"
*  int rng_unif_rand(RNG *rand, int m);
*
*  RETURNS
*
*  The routine rng_unif_rand returns a next pseudo-random integer which
*  is uniformly distributed between 0 and m-1, inclusive, where m is any
*  positive integer less than 2^31. */

#define two_to_the_31 ((unsigned int)0x80000000)

int rng_unif_rand(RNG *rand, int m)
{     unsigned int t = two_to_the_31 - (two_to_the_31 % m);
      int r;
      xassert(m > 0);
      do { r = rng_next_rand(rand); } while (t <= (unsigned int)r);
      return r % m;
}

/***********************************************************************
*  NAME
*
*  rng_delete_rand - delete pseudo-random number generator
*
*  SYNOPSIS
*
*  #include "rng.h"
*  void rng_delete_rand(RNG *rand);
*
*  DESCRIPTION
*
*  The routine rng_delete_rand frees all the memory allocated to the
*  specified pseudo-random number generator. */

void rng_delete_rand(RNG *rand)
{     tfree(rand);
      return;
}

/**********************************************************************/

#ifdef GLP_TEST
/* To be sure that this modified version produces the same results as
 * the original version, run this validation program. */

int main(void)
{     RNG *rand;
      int j;
      rand = rng_create_rand();
      rng_init_rand(rand, -314159);
      if (rng_next_rand(rand) != 119318998)
      {  fprintf(stderr, "Failure on the first try!\n");
         return -1;
      }
      for (j = 1; j <= 133; j++) rng_next_rand(rand);
      if (rng_unif_rand(rand, 0x55555555) != 748103812)
      {  fprintf(stderr, "Failure on the second try!\n");
         return -2;
      }
      fprintf(stderr, "OK, the random-number generator routines seem to"
         " work!\n");
      rng_delete_rand(rand);
      return 0;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/rng.h0000644000175100001710000000412600000000000024001 0ustar00runnerdocker00000000000000/* rng.h (pseudo-random number generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef RNG_H
#define RNG_H

typedef struct RNG RNG;

struct RNG
{     /* Knuth's portable pseudo-random number generator */
      int A[56];
      /* pseudo-random values */
      int *fptr;
      /* the next A value to be exported */
};

#define rng_create_rand _glp_rng_create_rand
RNG *rng_create_rand(void);
/* create pseudo-random number generator */

#define rng_init_rand _glp_rng_init_rand
void rng_init_rand(RNG *rand, int seed);
/* initialize pseudo-random number generator */

#define rng_next_rand _glp_rng_next_rand
int rng_next_rand(RNG *rand);
/* obtain pseudo-random integer in the range [0, 2^31-1] */

#define rng_unif_rand _glp_rng_unif_rand
int rng_unif_rand(RNG *rand, int m);
/* obtain pseudo-random integer in the range [0, m-1] */

#define rng_delete_rand _glp_rng_delete_rand
void rng_delete_rand(RNG *rand);
/* delete pseudo-random number generator */

#define rng_unif_01 _glp_rng_unif_01
double rng_unif_01(RNG *rand);
/* obtain pseudo-random number in the range [0, 1] */

#define rng_uniform _glp_rng_uniform
double rng_uniform(RNG *rand, double a, double b);
/* obtain pseudo-random number in the range [a, b] */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/rng1.c0000644000175100001710000000407000000000000024053 0ustar00runnerdocker00000000000000/* rng1.c (pseudo-random number generator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "rng.h"

/***********************************************************************
*  NAME
*
*  rng_unif_01 - obtain pseudo-random number in the range [0, 1]
*
*  SYNOPSIS
*
*  #include "rng.h"
*  double rng_unif_01(RNG *rand);
*
*  RETURNS
*
*  The routine rng_unif_01 returns a next pseudo-random number which is
*  uniformly distributed in the range [0, 1]. */

double rng_unif_01(RNG *rand)
{     double x;
      x = (double)rng_next_rand(rand) / 2147483647.0;
      xassert(0.0 <= x && x <= 1.0);
      return x;
}

/***********************************************************************
*  NAME
*
*  rng_uniform - obtain pseudo-random number in the range [a, b]
*
*  SYNOPSIS
*
*  #include "rng.h"
*  double rng_uniform(RNG *rand, double a, double b);
*
*  RETURNS
*
*  The routine rng_uniform returns a next pseudo-random number which is
*  uniformly distributed in the range [a, b]. */

double rng_uniform(RNG *rand, double a, double b)
{     double x;
      xassert(a < b);
      x = rng_unif_01(rand);
      x = a * (1.0 - x) + b * x;
      xassert(a <= x && x <= b);
      return x;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/round2n.c0000644000175100001710000000372300000000000024577 0ustar00runnerdocker00000000000000/* round2n.c (round floating-point number to nearest power of two) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "misc.h"

/***********************************************************************
*  NAME
*
*  round2n - round floating-point number to nearest power of two
*
*  SYNOPSIS
*
*  #include "misc.h"
*  double round2n(double x);
*
*  RETURNS
*
*  Given a positive floating-point value x the routine round2n returns
*  2^n such that |x - 2^n| is minimal.
*
*  EXAMPLES
*
*  round2n(10.1) = 2^3 = 8
*  round2n(15.3) = 2^4 = 16
*  round2n(0.01) = 2^(-7) = 0.0078125
*
*  BACKGROUND
*
*  Let x = f * 2^e, where 0.5 <= f < 1 is a normalized fractional part,
*  e is an integer exponent. Then, obviously, 0.5 * 2^e <= x < 2^e, so
*  if x - 0.5 * 2^e <= 2^e - x, we choose 0.5 * 2^e = 2^(e-1), and 2^e
*  otherwise. The latter condition can be written as 2 * x <= 1.5 * 2^e
*  or 2 * f * 2^e <= 1.5 * 2^e or, finally, f <= 0.75. */

double round2n(double x)
{     int e;
      double f;
      xassert(x > 0.0);
      f = frexp(x, &e);
      return ldexp(1.0, f <= 0.75 ? e-1 : e);
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/spm.c0000644000175100001710000006033300000000000024007 0ustar00runnerdocker00000000000000/* glpspm.c (general sparse matrices) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "hbm.h"
#include "rgr.h"
#include "spm.h"

/***********************************************************************
*  NAME
*
*  spm_create_mat - create general sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_create_mat(int m, int n);
*
*  DESCRIPTION
*
*  The routine spm_create_mat creates a general sparse matrix having
*  m rows and n columns. Being created the matrix is zero (empty), i.e.
*  has no elements.
*
*  RETURNS
*
*  The routine returns a pointer to the matrix created. */

SPM *spm_create_mat(int m, int n)
{     SPM *A;
      xassert(0 <= m && m < INT_MAX);
      xassert(0 <= n && n < INT_MAX);
      A = xmalloc(sizeof(SPM));
      A->m = m;
      A->n = n;
      if (m == 0 || n == 0)
      {  A->pool = NULL;
         A->row = NULL;
         A->col = NULL;
      }
      else
      {  int i, j;
         A->pool = dmp_create_pool();
         A->row = xcalloc(1+m, sizeof(SPME *));
         for (i = 1; i <= m; i++) A->row[i] = NULL;
         A->col = xcalloc(1+n, sizeof(SPME *));
         for (j = 1; j <= n; j++) A->col[j] = NULL;
      }
      return A;
}

/***********************************************************************
*  NAME
*
*  spm_new_elem - add new element to sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPME *spm_new_elem(SPM *A, int i, int j, double val);
*
*  DESCRIPTION
*
*  The routine spm_new_elem adds a new element to the specified sparse
*  matrix. Parameters i, j, and val specify the row number, the column
*  number, and a numerical value of the element, respectively.
*
*  RETURNS
*
*  The routine returns a pointer to the new element added. */

SPME *spm_new_elem(SPM *A, int i, int j, double val)
{     SPME *e;
      xassert(1 <= i && i <= A->m);
      xassert(1 <= j && j <= A->n);
      e = dmp_get_atom(A->pool, sizeof(SPME));
      e->i = i;
      e->j = j;
      e->val = val;
      e->r_prev = NULL;
      e->r_next = A->row[i];
      if (e->r_next != NULL) e->r_next->r_prev = e;
      e->c_prev = NULL;
      e->c_next = A->col[j];
      if (e->c_next != NULL) e->c_next->c_prev = e;
      A->row[i] = A->col[j] = e;
      return e;
}

/***********************************************************************
*  NAME
*
*  spm_delete_mat - delete general sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  void spm_delete_mat(SPM *A);
*
*  DESCRIPTION
*
*  The routine deletes the specified general sparse matrix freeing all
*  the memory allocated to this object. */

void spm_delete_mat(SPM *A)
{     /* delete sparse matrix */
      if (A->pool != NULL) dmp_delete_pool(A->pool);
      if (A->row != NULL) xfree(A->row);
      if (A->col != NULL) xfree(A->col);
      xfree(A);
      return;
}

/***********************************************************************
*  NAME
*
*  spm_test_mat_e - create test sparse matrix of E(n,c) class
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_test_mat_e(int n, int c);
*
*  DESCRIPTION
*
*  The routine spm_test_mat_e creates a test sparse matrix of E(n,c)
*  class as described in the book: Ole 0sterby, Zahari Zlatev. Direct
*  Methods for Sparse Matrices. Springer-Verlag, 1983.
*
*  Matrix of E(n,c) class is a symmetric positive definite matrix of
*  the order n. It has the number 4 on its main diagonal and the number
*  -1 on its four co-diagonals, two of which are neighbour to the main
*  diagonal and two others are shifted from the main diagonal on the
*  distance c.
*
*  It is necessary that n >= 3 and 2 <= c <= n-1.
*
*  RETURNS
*
*  The routine returns a pointer to the matrix created. */

SPM *spm_test_mat_e(int n, int c)
{     SPM *A;
      int i;
      xassert(n >= 3 && 2 <= c && c <= n-1);
      A = spm_create_mat(n, n);
      for (i = 1; i <= n; i++)
         spm_new_elem(A, i, i, 4.0);
      for (i = 1; i <= n-1; i++)
      {  spm_new_elem(A, i, i+1, -1.0);
         spm_new_elem(A, i+1, i, -1.0);
      }
      for (i = 1; i <= n-c; i++)
      {  spm_new_elem(A, i, i+c, -1.0);
         spm_new_elem(A, i+c, i, -1.0);
      }
      return A;
}

/***********************************************************************
*  NAME
*
*  spm_test_mat_d - create test sparse matrix of D(n,c) class
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_test_mat_d(int n, int c);
*
*  DESCRIPTION
*
*  The routine spm_test_mat_d creates a test sparse matrix of D(n,c)
*  class as described in the book: Ole 0sterby, Zahari Zlatev. Direct
*  Methods for Sparse Matrices. Springer-Verlag, 1983.
*
*  Matrix of D(n,c) class is a non-singular matrix of the order n. It
*  has unity main diagonal, three co-diagonals above the main diagonal
*  on the distance c, which are cyclically continued below the main
*  diagonal, and a triangle block of the size 10x10 in the upper right
*  corner.
*
*  It is necessary that n >= 14 and 1 <= c <= n-13.
*
*  RETURNS
*
*  The routine returns a pointer to the matrix created. */

SPM *spm_test_mat_d(int n, int c)
{     SPM *A;
      int i, j;
      xassert(n >= 14 && 1 <= c && c <= n-13);
      A = spm_create_mat(n, n);
      for (i = 1; i <= n; i++)
         spm_new_elem(A, i, i, 1.0);
      for (i = 1; i <= n-c; i++)
         spm_new_elem(A, i, i+c, (double)(i+1));
      for (i = n-c+1; i <= n; i++)
         spm_new_elem(A, i, i-n+c, (double)(i+1));
      for (i = 1; i <= n-c-1; i++)
         spm_new_elem(A, i, i+c+1, (double)(-i));
      for (i = n-c; i <= n; i++)
         spm_new_elem(A, i, i-n+c+1, (double)(-i));
      for (i = 1; i <= n-c-2; i++)
         spm_new_elem(A, i, i+c+2, 16.0);
      for (i = n-c-1; i <= n; i++)
         spm_new_elem(A, i, i-n+c+2, 16.0);
      for (j = 1; j <= 10; j++)
         for (i = 1; i <= 11-j; i++)
            spm_new_elem(A, i, n-11+i+j, 100.0 * (double)j);
      return A;
}

/***********************************************************************
*  NAME
*
*  spm_show_mat - write sparse matrix pattern in BMP file format
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  int spm_show_mat(const SPM *A, const char *fname);
*
*  DESCRIPTION
*
*  The routine spm_show_mat writes pattern of the specified sparse
*  matrix in uncompressed BMP file format (Windows bitmap) to a binary
*  file whose name is specified by the character string fname.
*
*  Each pixel corresponds to one matrix element. The pixel colors have
*  the following meaning:
*
*  Black    structurally zero element
*  White    positive element
*  Cyan     negative element
*  Green    zero element
*  Red      duplicate element
*
*  RETURNS
*
*  If no error occured, the routine returns zero. Otherwise, it prints
*  an appropriate error message and returns non-zero. */

int spm_show_mat(const SPM *A, const char *fname)
{     int m = A->m;
      int n = A->n;
      int i, j, k, ret;
      char *map;
      xprintf("spm_show_mat: writing matrix pattern to '%s'...\n",
         fname);
      xassert(1 <= m && m <= 32767);
      xassert(1 <= n && n <= 32767);
      map = xmalloc(m * n);
      memset(map, 0x08, m * n);
      for (i = 1; i <= m; i++)
      {  SPME *e;
         for (e = A->row[i]; e != NULL; e = e->r_next)
         {  j = e->j;
            xassert(1 <= j && j <= n);
            k = n * (i - 1) + (j - 1);
            if (map[k] != 0x08)
               map[k] = 0x0C;
            else if (e->val > 0.0)
               map[k] = 0x0F;
            else if (e->val < 0.0)
               map[k] = 0x0B;
            else
               map[k] = 0x0A;
         }
      }
      ret = rgr_write_bmp16(fname, m, n, map);
      xfree(map);
      return ret;
}

/***********************************************************************
*  NAME
*
*  spm_read_hbm - read sparse matrix in Harwell-Boeing format
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_read_hbm(const char *fname);
*
*  DESCRIPTION
*
*  The routine spm_read_hbm reads a sparse matrix in the Harwell-Boeing
*  format from a text file whose name is the character string fname.
*
*  Detailed description of the Harwell-Boeing format recognised by this
*  routine can be found in the following report:
*
*  I.S.Duff, R.G.Grimes, J.G.Lewis. User's Guide for the Harwell-Boeing
*  Sparse Matrix Collection (Release I), TR/PA/92/86, October 1992.
*
*  NOTE
*
*  The routine spm_read_hbm reads the matrix "as is", due to which zero
*  and/or duplicate elements can appear in the matrix.
*
*  RETURNS
*
*  If no error occured, the routine returns a pointer to the matrix
*  created. Otherwise, the routine prints an appropriate error message
*  and returns NULL. */

SPM *spm_read_hbm(const char *fname)
{     SPM *A = NULL;
      HBM *hbm;
      int nrow, ncol, nnzero, i, j, beg, end, ptr, *colptr, *rowind;
      double val, *values;
      char *mxtype;
      hbm = hbm_read_mat(fname);
      if (hbm == NULL)
      {  xprintf("spm_read_hbm: unable to read matrix\n");
         goto fini;
      }
      mxtype = hbm->mxtype;
      nrow = hbm->nrow;
      ncol = hbm->ncol;
      nnzero = hbm->nnzero;
      colptr = hbm->colptr;
      rowind = hbm->rowind;
      values = hbm->values;
      if (!(strcmp(mxtype, "RSA") == 0 || strcmp(mxtype, "PSA") == 0 ||
            strcmp(mxtype, "RUA") == 0 || strcmp(mxtype, "PUA") == 0 ||
            strcmp(mxtype, "RRA") == 0 || strcmp(mxtype, "PRA") == 0))
      {  xprintf("spm_read_hbm: matrix type '%s' not supported\n",
            mxtype);
         goto fini;
      }
      A = spm_create_mat(nrow, ncol);
      if (mxtype[1] == 'S' || mxtype[1] == 'U')
         xassert(nrow == ncol);
      for (j = 1; j <= ncol; j++)
      {  beg = colptr[j];
         end = colptr[j+1];
         xassert(1 <= beg && beg <= end && end <= nnzero + 1);
         for (ptr = beg; ptr < end; ptr++)
         {  i = rowind[ptr];
            xassert(1 <= i && i <= nrow);
            if (mxtype[0] == 'R')
               val = values[ptr];
            else
               val = 1.0;
            spm_new_elem(A, i, j, val);
            if (mxtype[1] == 'S' && i != j)
               spm_new_elem(A, j, i, val);
         }
      }
fini: if (hbm != NULL) hbm_free_mat(hbm);
      return A;
}

/***********************************************************************
*  NAME
*
*  spm_count_nnz - determine number of non-zeros in sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  int spm_count_nnz(const SPM *A);
*
*  RETURNS
*
*  The routine spm_count_nnz returns the number of structural non-zero
*  elements in the specified sparse matrix. */

int spm_count_nnz(const SPM *A)
{     SPME *e;
      int i, nnz = 0;
      for (i = 1; i <= A->m; i++)
         for (e = A->row[i]; e != NULL; e = e->r_next) nnz++;
      return nnz;
}

/***********************************************************************
*  NAME
*
*  spm_drop_zeros - remove zero elements from sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  int spm_drop_zeros(SPM *A, double eps);
*
*  DESCRIPTION
*
*  The routine spm_drop_zeros removes all elements from the specified
*  sparse matrix, whose absolute value is less than eps.
*
*  If the parameter eps is 0, only zero elements are removed from the
*  matrix.
*
*  RETURNS
*
*  The routine returns the number of elements removed. */

int spm_drop_zeros(SPM *A, double eps)
{     SPME *e, *next;
      int i, count = 0;
      for (i = 1; i <= A->m; i++)
      {  for (e = A->row[i]; e != NULL; e = next)
         {  next = e->r_next;
            if (e->val == 0.0 || fabs(e->val) < eps)
            {  /* remove element from the row list */
               if (e->r_prev == NULL)
                  A->row[e->i] = e->r_next;
               else
                  e->r_prev->r_next = e->r_next;
               if (e->r_next == NULL)
                  ;
               else
                  e->r_next->r_prev = e->r_prev;
               /* remove element from the column list */
               if (e->c_prev == NULL)
                  A->col[e->j] = e->c_next;
               else
                  e->c_prev->c_next = e->c_next;
               if (e->c_next == NULL)
                  ;
               else
                  e->c_next->c_prev = e->c_prev;
               /* return element to the memory pool */
               dmp_free_atom(A->pool, e, sizeof(SPME));
               count++;
            }
         }
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  spm_read_mat - read sparse matrix from text file
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_read_mat(const char *fname);
*
*  DESCRIPTION
*
*  The routine reads a sparse matrix from a text file whose name is
*  specified by the parameter fname.
*
*  For the file format see description of the routine spm_write_mat.
*
*  RETURNS
*
*  On success the routine returns a pointer to the matrix created,
*  otherwise NULL. */

#if 1
SPM *spm_read_mat(const char *fname)
{     xassert(fname != fname);
      return NULL;
}
#else
SPM *spm_read_mat(const char *fname)
{     SPM *A = NULL;
      PDS *pds;
      jmp_buf jump;
      int i, j, k, m, n, nnz, fail = 0;
      double val;
      xprintf("spm_read_mat: reading matrix from '%s'...\n", fname);
      pds = pds_open_file(fname);
      if (pds == NULL)
      {  xprintf("spm_read_mat: unable to open '%s' - %s\n", fname,
            strerror(errno));
         fail = 1;
         goto done;
      }
      if (setjmp(jump))
      {  fail = 1;
         goto done;
      }
      pds_set_jump(pds, jump);
      /* number of rows, number of columns, number of non-zeros */
      m = pds_scan_int(pds);
      if (m < 0)
         pds_error(pds, "invalid number of rows\n");
      n = pds_scan_int(pds);
      if (n < 0)
         pds_error(pds, "invalid number of columns\n");
      nnz = pds_scan_int(pds);
      if (nnz < 0)
         pds_error(pds, "invalid number of non-zeros\n");
      /* create matrix */
      xprintf("spm_read_mat: %d rows, %d columns, %d non-zeros\n",
         m, n, nnz);
      A = spm_create_mat(m, n);
      /* read matrix elements */
      for (k = 1; k <= nnz; k++)
      {  /* row index, column index, element value */
         i = pds_scan_int(pds);
         if (!(1 <= i && i <= m))
            pds_error(pds, "row index out of range\n");
         j = pds_scan_int(pds);
         if (!(1 <= j && j <= n))
            pds_error(pds, "column index out of range\n");
         val = pds_scan_num(pds);
         /* add new element to the matrix */
         spm_new_elem(A, i, j, val);
      }
      xprintf("spm_read_mat: %d lines were read\n", pds->count);
done: if (pds != NULL) pds_close_file(pds);
      if (fail && A != NULL) spm_delete_mat(A), A = NULL;
      return A;
}
#endif

/***********************************************************************
*  NAME
*
*  spm_write_mat - write sparse matrix to text file
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  int spm_write_mat(const SPM *A, const char *fname);
*
*  DESCRIPTION
*
*  The routine spm_write_mat writes the specified sparse matrix to a
*  text file whose name is specified by the parameter fname. This file
*  can be read back with the routine spm_read_mat.
*
*  RETURNS
*
*  On success the routine returns zero, otherwise non-zero.
*
*  FILE FORMAT
*
*  The file created by the routine spm_write_mat is a plain text file,
*  which contains the following information:
*
*     m n nnz
*     row[1] col[1] val[1]
*     row[2] col[2] val[2]
*     . . .
*     row[nnz] col[nnz] val[nnz]
*
*  where:
*  m is the number of rows;
*  n is the number of columns;
*  nnz is the number of non-zeros;
*  row[k], k = 1,...,nnz, are row indices;
*  col[k], k = 1,...,nnz, are column indices;
*  val[k], k = 1,...,nnz, are element values. */

#if 1
int spm_write_mat(const SPM *A, const char *fname)
{     xassert(A != A);
      xassert(fname != fname);
      return 0;
}
#else
int spm_write_mat(const SPM *A, const char *fname)
{     FILE *fp;
      int i, nnz, ret = 0;
      xprintf("spm_write_mat: writing matrix to '%s'...\n", fname);
      fp = fopen(fname, "w");
      if (fp == NULL)
      {  xprintf("spm_write_mat: unable to create '%s' - %s\n", fname,
            strerror(errno));
         ret = 1;
         goto done;
      }
      /* number of rows, number of columns, number of non-zeros */
      nnz = spm_count_nnz(A);
      fprintf(fp, "%d %d %d\n", A->m, A->n, nnz);
      /* walk through rows of the matrix */
      for (i = 1; i <= A->m; i++)
      {  SPME *e;
         /* walk through elements of i-th row */
         for (e = A->row[i]; e != NULL; e = e->r_next)
         {  /* row index, column index, element value */
            fprintf(fp, "%d %d %.*g\n", e->i, e->j, DBL_DIG, e->val);
         }
      }
      fflush(fp);
      if (ferror(fp))
      {  xprintf("spm_write_mat: writing error on '%s' - %s\n", fname,
            strerror(errno));
         ret = 1;
         goto done;
      }
      xprintf("spm_write_mat: %d lines were written\n", 1 + nnz);
done: if (fp != NULL) fclose(fp);
      return ret;
}
#endif

/***********************************************************************
*  NAME
*
*  spm_transpose - transpose sparse matrix
*
*  SYNOPSIS
*
*  #include "glpspm.h"
*  SPM *spm_transpose(const SPM *A);
*
*  RETURNS
*
*  The routine computes and returns sparse matrix B, which is a matrix
*  transposed to sparse matrix A. */

SPM *spm_transpose(const SPM *A)
{     SPM *B;
      int i;
      B = spm_create_mat(A->n, A->m);
      for (i = 1; i <= A->m; i++)
      {  SPME *e;
         for (e = A->row[i]; e != NULL; e = e->r_next)
            spm_new_elem(B, e->j, i, e->val);
      }
      return B;
}

SPM *spm_add_sym(const SPM *A, const SPM *B)
{     /* add two sparse matrices (symbolic phase) */
      SPM *C;
      int i, j, *flag;
      xassert(A->m == B->m);
      xassert(A->n == B->n);
      /* create resultant matrix */
      C = spm_create_mat(A->m, A->n);
      /* allocate and clear the flag array */
      flag = xcalloc(1+C->n, sizeof(int));
      for (j = 1; j <= C->n; j++)
         flag[j] = 0;
      /* compute pattern of C = A + B */
      for (i = 1; i <= C->m; i++)
      {  SPME *e;
         /* at the beginning i-th row of C is empty */
         /* (i-th row of C) := (i-th row of C) union (i-th row of A) */
         for (e = A->row[i]; e != NULL; e = e->r_next)
         {  /* (note that i-th row of A may have duplicate elements) */
            j = e->j;
            if (!flag[j])
            {  spm_new_elem(C, i, j, 0.0);
               flag[j] = 1;
            }
         }
         /* (i-th row of C) := (i-th row of C) union (i-th row of B) */
         for (e = B->row[i]; e != NULL; e = e->r_next)
         {  /* (note that i-th row of B may have duplicate elements) */
            j = e->j;
            if (!flag[j])
            {  spm_new_elem(C, i, j, 0.0);
               flag[j] = 1;
            }
         }
         /* reset the flag array */
         for (e = C->row[i]; e != NULL; e = e->r_next)
            flag[e->j] = 0;
      }
      /* check and deallocate the flag array */
      for (j = 1; j <= C->n; j++)
         xassert(!flag[j]);
      xfree(flag);
      return C;
}

void spm_add_num(SPM *C, double alfa, const SPM *A, double beta,
      const SPM *B)
{     /* add two sparse matrices (numeric phase) */
      int i, j;
      double *work;
      /* allocate and clear the working array */
      work = xcalloc(1+C->n, sizeof(double));
      for (j = 1; j <= C->n; j++)
         work[j] = 0.0;
      /* compute matrix C = alfa * A + beta * B */
      for (i = 1; i <= C->n; i++)
      {  SPME *e;
         /* work := alfa * (i-th row of A) + beta * (i-th row of B) */
         /* (note that A and/or B may have duplicate elements) */
         for (e = A->row[i]; e != NULL; e = e->r_next)
            work[e->j] += alfa * e->val;
         for (e = B->row[i]; e != NULL; e = e->r_next)
            work[e->j] += beta * e->val;
         /* (i-th row of C) := work, work := 0 */
         for (e = C->row[i]; e != NULL; e = e->r_next)
         {  j = e->j;
            e->val = work[j];
            work[j] = 0.0;
         }
      }
      /* check and deallocate the working array */
      for (j = 1; j <= C->n; j++)
         xassert(work[j] == 0.0);
      xfree(work);
      return;
}

SPM *spm_add_mat(double alfa, const SPM *A, double beta, const SPM *B)
{     /* add two sparse matrices (driver routine) */
      SPM *C;
      C = spm_add_sym(A, B);
      spm_add_num(C, alfa, A, beta, B);
      return C;
}

SPM *spm_mul_sym(const SPM *A, const SPM *B)
{     /* multiply two sparse matrices (symbolic phase) */
      int i, j, k, *flag;
      SPM *C;
      xassert(A->n == B->m);
      /* create resultant matrix */
      C = spm_create_mat(A->m, B->n);
      /* allocate and clear the flag array */
      flag = xcalloc(1+C->n, sizeof(int));
      for (j = 1; j <= C->n; j++)
         flag[j] = 0;
      /* compute pattern of C = A * B */
      for (i = 1; i <= C->m; i++)
      {  SPME *e, *ee;
         /* compute pattern of i-th row of C */
         for (e = A->row[i]; e != NULL; e = e->r_next)
         {  k = e->j;
            for (ee = B->row[k]; ee != NULL; ee = ee->r_next)
            {  j = ee->j;
               /* if a[i,k] != 0 and b[k,j] != 0 then c[i,j] != 0 */
               if (!flag[j])
               {  /* c[i,j] does not exist, so create it */
                  spm_new_elem(C, i, j, 0.0);
                  flag[j] = 1;
               }
            }
         }
         /* reset the flag array */
         for (e = C->row[i]; e != NULL; e = e->r_next)
            flag[e->j] = 0;
      }
      /* check and deallocate the flag array */
      for (j = 1; j <= C->n; j++)
         xassert(!flag[j]);
      xfree(flag);
      return C;
}

void spm_mul_num(SPM *C, const SPM *A, const SPM *B)
{     /* multiply two sparse matrices (numeric phase) */
      int i, j;
      double *work;
      /* allocate and clear the working array */
      work = xcalloc(1+A->n, sizeof(double));
      for (j = 1; j <= A->n; j++)
         work[j] = 0.0;
      /* compute matrix C = A * B */
      for (i = 1; i <= C->m; i++)
      {  SPME *e, *ee;
         double temp;
         /* work := (i-th row of A) */
         /* (note that A may have duplicate elements) */
         for (e = A->row[i]; e != NULL; e = e->r_next)
            work[e->j] += e->val;
         /* compute i-th row of C */
         for (e = C->row[i]; e != NULL; e = e->r_next)
         {  j = e->j;
            /* c[i,j] := work * (j-th column of B) */
            temp = 0.0;
            for (ee = B->col[j]; ee != NULL; ee = ee->c_next)
               temp += work[ee->i] * ee->val;
            e->val = temp;
         }
         /* reset the working array */
         for (e = A->row[i]; e != NULL; e = e->r_next)
            work[e->j] = 0.0;
      }
      /* check and deallocate the working array */
      for (j = 1; j <= A->n; j++)
         xassert(work[j] == 0.0);
      xfree(work);
      return;
}

SPM *spm_mul_mat(const SPM *A, const SPM *B)
{     /* multiply two sparse matrices (driver routine) */
      SPM *C;
      C = spm_mul_sym(A, B);
      spm_mul_num(C, A, B);
      return C;
}

PER *spm_create_per(int n)
{     /* create permutation matrix */
      PER *P;
      int k;
      xassert(n >= 0);
      P = xmalloc(sizeof(PER));
      P->n = n;
      P->row = xcalloc(1+n, sizeof(int));
      P->col = xcalloc(1+n, sizeof(int));
      /* initially it is identity matrix */
      for (k = 1; k <= n; k++)
         P->row[k] = P->col[k] = k;
      return P;
}

void spm_check_per(PER *P)
{     /* check permutation matrix for correctness */
      int i, j;
      xassert(P->n >= 0);
      for (i = 1; i <= P->n; i++)
      {  j = P->row[i];
         xassert(1 <= j && j <= P->n);
         xassert(P->col[j] == i);
      }
      return;
}

void spm_delete_per(PER *P)
{     /* delete permutation matrix */
      xfree(P->row);
      xfree(P->col);
      xfree(P);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/spm.h0000644000175100001710000001152400000000000024012 0ustar00runnerdocker00000000000000/* spm.h (general sparse matrices) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2004-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPM_H
#define SPM_H

#include "dmp.h"

typedef struct SPM SPM;
typedef struct SPME SPME;

struct SPM
{     /* general sparse matrix */
      int m;
      /* number of rows, m >= 0 */
      int n;
      /* number of columns, n >= 0 */
      DMP *pool;
      /* memory pool to store matrix elements */
      SPME **row; /* SPME *row[1+m]; */
      /* row[i], 1 <= i <= m, is a pointer to i-th row list */
      SPME **col; /* SPME *col[1+n]; */
      /* col[j], 1 <= j <= n, is a pointer to j-th column list */
};

struct SPME
{     /* sparse matrix element */
      int i;
      /* row number */
      int j;
      /* column number */
      double val;
      /* element value */
      SPME *r_prev;
      /* pointer to previous element in the same row */
      SPME *r_next;
      /* pointer to next element in the same row */
      SPME *c_prev;
      /* pointer to previous element in the same column */
      SPME *c_next;
      /* pointer to next element in the same column */
};

typedef struct PER PER;

struct PER
{     /* permutation matrix */
      int n;
      /* matrix order, n >= 0 */
      int *row; /* int row[1+n]; */
      /* row[i] = j means p[i,j] = 1 */
      int *col; /* int col[1+n]; */
      /* col[j] = i means p[i,j] = 1 */
};

#define spm_create_mat _glp_spm_create_mat
SPM *spm_create_mat(int m, int n);
/* create general sparse matrix */

#define spm_new_elem _glp_spm_new_elem
SPME *spm_new_elem(SPM *A, int i, int j, double val);
/* add new element to sparse matrix */

#define spm_delete_mat _glp_spm_delete_mat
void spm_delete_mat(SPM *A);
/* delete general sparse matrix */

#define spm_test_mat_e _glp_spm_test_mat_e
SPM *spm_test_mat_e(int n, int c);
/* create test sparse matrix of E(n,c) class */

#define spm_test_mat_d _glp_spm_test_mat_d
SPM *spm_test_mat_d(int n, int c);
/* create test sparse matrix of D(n,c) class */

#define spm_show_mat _glp_spm_show_mat
int spm_show_mat(const SPM *A, const char *fname);
/* write sparse matrix pattern in BMP file format */

#define spm_read_hbm _glp_spm_read_hbm
SPM *spm_read_hbm(const char *fname);
/* read sparse matrix in Harwell-Boeing format */

#define spm_count_nnz _glp_spm_count_nnz
int spm_count_nnz(const SPM *A);
/* determine number of non-zeros in sparse matrix */

#define spm_drop_zeros _glp_spm_drop_zeros
int spm_drop_zeros(SPM *A, double eps);
/* remove zero elements from sparse matrix */

#define spm_read_mat _glp_spm_read_mat
SPM *spm_read_mat(const char *fname);
/* read sparse matrix from text file */

#define spm_write_mat _glp_spm_write_mat
int spm_write_mat(const SPM *A, const char *fname);
/* write sparse matrix to text file */

#define spm_transpose _glp_spm_transpose
SPM *spm_transpose(const SPM *A);
/* transpose sparse matrix */

#define spm_add_sym _glp_spm_add_sym
SPM *spm_add_sym(const SPM *A, const SPM *B);
/* add two sparse matrices (symbolic phase) */

#define spm_add_num _glp_spm_add_num
void spm_add_num(SPM *C, double alfa, const SPM *A, double beta,
      const SPM *B);
/* add two sparse matrices (numeric phase) */

#define spm_add_mat _glp_spm_add_mat
SPM *spm_add_mat(double alfa, const SPM *A, double beta,
      const SPM *B);
/* add two sparse matrices (driver routine) */

#define spm_mul_sym _glp_spm_mul_sym
SPM *spm_mul_sym(const SPM *A, const SPM *B);
/* multiply two sparse matrices (symbolic phase) */

#define spm_mul_num _glp_spm_mul_num
void spm_mul_num(SPM *C, const SPM *A, const SPM *B);
/* multiply two sparse matrices (numeric phase) */

#define spm_mul_mat _glp_spm_mul_mat
SPM *spm_mul_mat(const SPM *A, const SPM *B);
/* multiply two sparse matrices (driver routine) */

#define spm_create_per _glp_spm_create_per
PER *spm_create_per(int n);
/* create permutation matrix */

#define spm_check_per _glp_spm_check_per
void spm_check_per(PER *P);
/* check permutation matrix for correctness */

#define spm_delete_per _glp_spm_delete_per
void spm_delete_per(PER *P);
/* delete permutation matrix */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/str2int.c0000644000175100001710000000513200000000000024611 0ustar00runnerdocker00000000000000/* str2int.c (convert string to int) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "misc.h"
#include "stdc.h"

/***********************************************************************
*  NAME
*
*  str2int - convert character string to value of int type
*
*  SYNOPSIS
*
*  #include "misc.h"
*  int str2int(const char *str, int *val);
*
*  DESCRIPTION
*
*  The routine str2int converts the character string str to a value of
*  integer type and stores the value into location, which the parameter
*  val points to (in the case of error content of this location is not
*  changed).
*
*  RETURNS
*
*  The routine returns one of the following error codes:
*
*  0 - no error;
*  1 - value out of range;
*  2 - character string is syntactically incorrect. */

int str2int(const char *str, int *val_)
{     int d, k, s, val = 0;
      /* scan optional sign */
      if (str[0] == '+')
         s = +1, k = 1;
      else if (str[0] == '-')
         s = -1, k = 1;
      else
         s = +1, k = 0;
      /* check for the first digit */
      if (!isdigit((unsigned char)str[k]))
         return 2;
      /* scan digits */
      while (isdigit((unsigned char)str[k]))
      {  d = str[k++] - '0';
         if (s > 0)
         {  if (val > INT_MAX / 10)
               return 1;
            val *= 10;
            if (val > INT_MAX - d)
               return 1;
            val += d;
         }
         else /* s < 0 */
         {  if (val < INT_MIN / 10)
               return 1;
            val *= 10;
            if (val < INT_MIN + d)
               return 1;
            val -= d;
         }
      }
      /* check for terminator */
      if (str[k] != '\0')
         return 2;
      /* conversion has been done */
      *val_ = val;
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/str2num.c0000644000175100001710000000637500000000000024630 0ustar00runnerdocker00000000000000/* str2num.c (convert string to double) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "misc.h"
#include "stdc.h"

/***********************************************************************
*  NAME
*
*  str2num - convert character string to value of double type
*
*  SYNOPSIS
*
*  #include "misc.h"
*  int str2num(const char *str, double *val);
*
*  DESCRIPTION
*
*  The routine str2num converts the character string str to a value of
*  double type and stores the value into location, which the parameter
*  val points to (in the case of error content of this location is not
*  changed).
*
*  RETURNS
*
*  The routine returns one of the following error codes:
*
*  0 - no error;
*  1 - value out of range;
*  2 - character string is syntactically incorrect. */

int str2num(const char *str, double *val_)
{     int k;
      double val;
      /* scan optional sign */
      k = (str[0] == '+' || str[0] == '-' ? 1 : 0);
      /* check for decimal point */
      if (str[k] == '.')
      {  k++;
         /* a digit should follow it */
         if (!isdigit((unsigned char)str[k]))
            return 2;
         k++;
         goto frac;
      }
      /* integer part should start with a digit */
      if (!isdigit((unsigned char)str[k]))
         return 2;
      /* scan integer part */
      while (isdigit((unsigned char)str[k]))
         k++;
      /* check for decimal point */
      if (str[k] == '.') k++;
frac: /* scan optional fraction part */
      while (isdigit((unsigned char)str[k]))
         k++;
      /* check for decimal exponent */
      if (str[k] == 'E' || str[k] == 'e')
      {  k++;
         /* scan optional sign */
         if (str[k] == '+' || str[k] == '-')
            k++;
         /* a digit should follow E, E+ or E- */
         if (!isdigit((unsigned char)str[k]))
            return 2;
      }
      /* scan optional exponent part */
      while (isdigit((unsigned char)str[k]))
         k++;
      /* check for terminator */
      if (str[k] != '\0')
         return 2;
      /* perform conversion */
      {  char *endptr;
         val = strtod(str, &endptr);
         if (*endptr != '\0')
            return 2;
      }
      /* check for overflow */
      if (!(-DBL_MAX <= val && val <= +DBL_MAX))
         return 1;
      /* check for underflow */
      if (-DBL_MIN < val && val < +DBL_MIN)
         val = 0.0;
      /* conversion has been done */
      *val_ = val;
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/strspx.c0000644000175100001710000000323200000000000024546 0ustar00runnerdocker00000000000000/* strspx.c (remove all spaces from string) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "misc.h"

/***********************************************************************
*  NAME
*
*  strspx - remove all spaces from character string
*
*  SYNOPSIS
*
*  #include "misc.h"
*  char *strspx(char *str);
*
*  DESCRIPTION
*
*  The routine strspx removes all spaces from the character string str.
*
*  RETURNS
*
*  The routine returns a pointer to the character string.
*
*  EXAMPLES
*
*  strspx("   Errare   humanum   est   ") => "Errarehumanumest"
*
*  strspx("      ")                       => ""                       */

char *strspx(char *str)
{     char *s, *t;
      for (s = t = str; *s; s++)
      {  if (*s != ' ')
            *t++ = *s;
      }
      *t = '\0';
      return str;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/strtrim.c0000644000175100001710000000331700000000000024713 0ustar00runnerdocker00000000000000/* strtrim.c (remove trailing spaces from string) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2000 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "misc.h"
#include "stdc.h"

/***********************************************************************
*  NAME
*
*  strtrim - remove trailing spaces from character string
*
*  SYNOPSIS
*
*  #include "misc.h"
*  char *strtrim(char *str);
*
*  DESCRIPTION
*
*  The routine strtrim removes trailing spaces from the character
*  string str.
*
*  RETURNS
*
*  The routine returns a pointer to the character string.
*
*  EXAMPLES
*
*  strtrim("Errare humanum est   ") => "Errare humanum est"
*
*  strtrim("      ")                => ""                             */

char *strtrim(char *str)
{     char *t;
      for (t = strrchr(str, '\0') - 1; t >= str; t--)
      {  if (*t != ' ')
            break;
         *t = '\0';
      }
      return str;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/triang.c0000644000175100001710000002764000000000000024500 0ustar00runnerdocker00000000000000/* triang.c (find maximal triangular part of rectangular matrix) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "triang.h"

/***********************************************************************
*  triang - find maximal triangular part of rectangular matrix
*
*  Given a mxn sparse matrix A this routine finds permutation matrices
*  P and Q such that matrix A' = P * A * Q has the following structure:
*
*        1         s         n
*     1  * . . . . . x x x x x
*        * * . . . . x x x x x
*        * * * . . . x x x x x
*        * * * * . . x x x x x
*        * * * * * . x x x x x
*     s  * * * * * * x x x x x
*        x x x x x x x x x x x
*        x x x x x x x x x x x
*     m  x x x x x x x x x x x
*
*  where '*' are elements of the triangular part, '.' are structural
*  zeros, 'x' are other elements.
*
*  The formal routine mat specifies the original matrix A in both row-
*  and column-wise format. If the routine mat is called with k = +i,
*  1 <= i <= m, it should store column indices and values of non-zero
*  elements of i-th row of A in locations ind[1], ..., ind[len] and
*  val[1], ..., val[len], resp., where len is the returned number of
*  non-zeros in the row, 0 <= len <= n. Similarly, if the routine mat
*  is called with k = -j, 1 <= j <= n, it should store row indices and
*  values of non-zero elements of j-th column of A and return len, the
*  number of non-zeros in the column, 0 <= len <= m. Should note that
*  duplicate indices are not allowed.
*
*  The parameter info is a transit pointer passed to the routine mat.
*
*  The parameter tol is a tolerance. The routine triang guarantees that
*  each diagonal element in the triangular part of matrix A' is not
*  less in magnitude than tol * max, where max is the maximal magnitude
*  of elements in corresponding column.
*
*  On exit the routine triang stores information on the triangular part
*  found in the arrays rn and cn. Elements rn[1], ..., rn[s] specify
*  row numbers and elements cn[1], ..., cn[s] specify column numbers
*  of the original matrix A, which correspond to rows/columns 1, ..., s
*  of matrix A', where s is the size of the triangular part returned by
*  the routine, 0 <= s <= min(m, n). The order of rows and columns that
*  are not included in the triangular part remains unspecified.
*
*  ALGORITHM
*
*  The routine triang uses a simple greedy heuristic.
*
*  At some step the matrix A' = P * A * Q has the following structure:
*
*        1                   n
*     1  * . . . . . . . x x x
*        * * . . . . . . x x x
*        * * * . . . . . x x x
*        * * * * . . . . x x x
*        x x x x # # # # x x x
*        x x x x # # # # x x x
*        x x x x # # # # x x x
*        x x x x # # # # x x x
*     m  x x x x # # # # x x x
*
*  where '#' are elements of active submatrix. Initially P = Q = I, so
*  the active submatrix is the original matrix A = A'.
*
*  If some row has exactly one non-zero in the active submatrix (row
*  singleton), the routine includes this row and corresponding column
*  in the triangular part, and removes the column from the active
*  submatrix. Otherwise, the routine simply removes a column having
*  maximal number of non-zeros from the active submatrix in the hope
*  that new row singleton(s) will appear.
*
*  COMPLEXITY
*
*  The time complexity of the routine triang is O(nnz), where nnz is
*  number of non-zeros in the original matrix A. */

int triang(int m, int n, int (*mat)(void *info, int k, int ind[],
      double val[]), void *info, double tol, int rn[], int cn[])
{     int head, i, j, jj, k, kk, ks, len, len2, next_j, ns, size;
      int *cind, *rind, *cnt, *ptr, *list, *prev, *next;
      double *cval, *rval, *big;
      char *flag;
      /* allocate working arrays */
      cind = talloc(1+m, int);
      cval = talloc(1+m, double);
      rind = talloc(1+n, int);
      rval = talloc(1+n, double);
      cnt = ptr = talloc(1+m, int);
      list = talloc(1+n, int);
      prev = talloc(1+n, int);
      next = talloc(1+n, int);
      big = talloc(1+n, double);
      flag = talloc(1+n, char);
      /*--------------------------------------------------------------*/
      /* build linked lists of columns having equal lengths           */
      /*--------------------------------------------------------------*/
      /* ptr[len], 0 <= len <= m, is number of first column of length
       * len;
       * next[j], 1 <= j <= n, is number of next column having the same
       * length as column j;
       * big[j], 1 <= j <= n, is maximal magnitude of elements in j-th
       * column */
      for (len = 0; len <= m; len++)
         ptr[len] = 0;
      for (j = 1; j <= n; j++)
      {  /* get j-th column */
         len = mat(info, -j, cind, cval);
         xassert(0 <= len && len <= m);
         /* add this column to beginning of list ptr[len] */
         next[j] = ptr[len];
         ptr[len] = j;
         /* determine maximal magnitude of elements in this column */
         big[j] = 0.0;
         for (k = 1; k <= len; k++)
         {  if (big[j] < fabs(cval[k]))
               big[j] = fabs(cval[k]);
         }
      }
      /*--------------------------------------------------------------*/
      /* build doubly linked list of columns ordered by decreasing    */
      /* column lengths                                               */
      /*--------------------------------------------------------------*/
      /* head is number of first column in the list;
       * prev[j], 1 <= j <= n, is number of column that precedes j-th
       * column in the list;
       * next[j], 1 <= j <= n, is number of column that follows j-th
       * column in the list */
      head = 0;
      for (len = 0; len <= m; len++)
      {  /* walk thru list of columns of length len */
         for (j = ptr[len]; j != 0; j = next_j)
         {  next_j = next[j];
            /* add j-th column to beginning of the column list */
            prev[j] = 0;
            next[j] = head;
            if (head != 0)
               prev[head] = j;
            head = j;
         }
      }
      /*--------------------------------------------------------------*/
      /* build initial singleton list                                 */
      /*--------------------------------------------------------------*/
      /* there are used two list of columns:
       * 1) doubly linked list of active columns, in which all columns
       *    are ordered by decreasing column lengths;
       * 2) singleton list; an active column is included in this list
       *    if it has at least one row singleton in active submatrix */
      /* flag[j], 1 <= j <= n, is a flag of j-th column:
       * 0  j-th column is inactive;
       * 1  j-th column is active;
       * 2  j-th column is active and has row singleton(s) */
      /* initially all columns are active */
      for (j = 1; j <= n; j++)
         flag[j] = 1;
      /* initialize row counts and build initial singleton list */
      /* cnt[i], 1 <= i <= m, is number of non-zeros, which i-th row
       * has in active submatrix;
       * ns is size of singleton list;
       * list[1], ..., list[ns] are numbers of active columns included
       * in the singleton list */
      ns = 0;
      for (i = 1; i <= m; i++)
      {  /* get i-th row */
         len = cnt[i] = mat(info, +i, rind, rval);
         xassert(0 <= len && len <= n);
         if (len == 1)
         {  /* a[i,j] is row singleton */
            j = rind[1];
            xassert(1 <= j && j <= n);
            if (flag[j] != 2)
            {  /* include j-th column in singleton list */
               flag[j] = 2;
               list[++ns] = j;
            }
         }
      }
      /*--------------------------------------------------------------*/
      /* main loop                                                    */
      /*--------------------------------------------------------------*/
      size = 0; /* size of triangular part */
      /* loop until active column list is non-empty, i.e. until the
       * active submatrix has at least one column */
      while (head != 0)
      {  if (ns == 0)
         {  /* singleton list is empty */
            /* remove from the active submatrix a column of maximal
             * length in the hope that some row singletons appear */
            j = head;
            len = mat(info, -j, cind, cval);
            xassert(0 <= len && len <= m);
            goto drop;
         }
         /* take column j from the singleton list */
         j = list[ns--];
         xassert(flag[j] == 2);
         /* j-th column has at least one row singleton in the active
          * submatrix; choose one having maximal magnitude */
         len = mat(info, -j, cind, cval);
         xassert(0 <= len && len <= m);
         kk = 0;
         for (k = 1; k <= len; k++)
         {  i = cind[k];
            xassert(1 <= i && i <= m);
            if (cnt[i] == 1)
            {  /* a[i,j] is row singleton */
               if (kk == 0 || fabs(cval[kk]) < fabs(cval[k]))
                  kk = k;
            }
         }
         xassert(kk > 0);
         /* check magnitude of the row singleton chosen */
         if (fabs(cval[kk]) < tol * big[j])
         {  /* all row singletons are too small in magnitude; drop j-th
             * column */
            goto drop;
         }
         /* row singleton a[i,j] is ok; add i-th row and j-th column to
          * the triangular part */
         size++;
         rn[size] = cind[kk];
         cn[size] = j;
drop:    /* remove j-th column from the active submatrix */
         xassert(flag[j]);
         flag[j] = 0;
         if (prev[j] == 0)
            head = next[j];
         else
            next[prev[j]] = next[j];
         if (next[j] == 0)
            ;
         else
            prev[next[j]] = prev[j];
         /* decrease row counts */
         for (k = 1; k <= len; k++)
         {  i = cind[k];
            xassert(1 <= i && i <= m);
            xassert(cnt[i] > 0);
            cnt[i]--;
            if (cnt[i] == 1)
            {  /* new singleton appeared in i-th row; determine number
                * of corresponding column (it is the only active column
                * in this row) */
               len2 = mat(info, +i, rind, rval);
               xassert(0 <= len2 && len2 <= n);
               ks = 0;
               for (kk = 1; kk <= len2; kk++)
               {  jj = rind[kk];
                  xassert(1 <= jj && jj <= n);
                  if (flag[jj])
                  {  xassert(ks == 0);
                     ks = kk;
                  }
               }
               xassert(ks > 0);
               /* a[i,jj] is new row singleton */
               jj = rind[ks];
               if (flag[jj] != 2)
               {  /* include jj-th column in the singleton list */
                  flag[jj] = 2;
                  list[++ns] = jj;
               }
            }
         }
      }
      /* now all row counts should be zero */
      for (i = 1; i <= m; i++)
         xassert(cnt[i] == 0);
      /* deallocate working arrays */
      tfree(cind);
      tfree(cval);
      tfree(rind);
      tfree(rval);
      tfree(ptr);
      tfree(list);
      tfree(prev);
      tfree(next);
      tfree(big);
      tfree(flag);
      return size;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/triang.h0000644000175100001710000000236400000000000024501 0ustar00runnerdocker00000000000000/* triang.h (find maximal triangular part of rectangular matrix) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef TRIANG_H
#define TRIANG_H

#define triang _glp_triang
int triang(int m, int n, int (*mat)(void *info, int k, int ind[],
      double val[]), void *info, double tol, int rn[], int cn[]);
/* find maximal triangular part of rectangular matrix */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/wclique.c0000644000175100001710000001653000000000000024661 0ustar00runnerdocker00000000000000/* wclique.c (maximum weight clique, Ostergard's algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*
*  Two subroutines sub() and wclique() below are intended to find a
*  maximum weight clique in a given undirected graph. These subroutines
*  are slightly modified version of the program WCLIQUE developed by
*  Patric Ostergard  and based
*  on ideas from the article "P. R. J. Ostergard, A new algorithm for
*  the maximum-weight clique problem, submitted for publication", which
*  in turn is a generalization of the algorithm for unweighted graphs
*  presented in "P. R. J. Ostergard, A fast algorithm for the maximum
*  clique problem, submitted for publication".
*
*  USED WITH PERMISSION OF THE AUTHOR OF THE ORIGINAL CODE.
*
*  Changes were made by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "wclique.h"

/***********************************************************************
*  NAME
*
*  wclique - find maximum weight clique with Ostergard's algorithm
*
*  SYNOPSIS
*
*  #include "wclique.h"
*  int wclique(int n, const int w[], const unsigned char a[],
*     int ind[]);
*
*  DESCRIPTION
*
*  The routine wclique finds a maximum weight clique in an undirected
*  graph with Ostergard's algorithm.
*
*  INPUT PARAMETERS
*
*  n is the number of vertices, n > 0.
*
*  w[i], i = 1,...,n, is a weight of vertex i.
*
*  a[*] is the strict (without main diagonal) lower triangle of the
*  graph adjacency matrix in packed format.
*
*  OUTPUT PARAMETER
*
*  ind[k], k = 1,...,size, is the number of a vertex included in the
*  clique found, 1 <= ind[k] <= n, where size is the number of vertices
*  in the clique returned on exit.
*
*  RETURNS
*
*  The routine returns the clique size, i.e. the number of vertices in
*  the clique. */

struct csa
{     /* common storage area */
      int n;
      /* number of vertices */
      const int *wt; /* int wt[0:n-1]; */
      /* weights */
      const unsigned char *a;
      /* adjacency matrix (packed lower triangle without main diag.) */
      int record;
      /* weight of best clique */
      int rec_level;
      /* number of vertices in best clique */
      int *rec; /* int rec[0:n-1]; */
      /* best clique so far */
      int *clique; /* int clique[0:n-1]; */
      /* table for pruning */
      int *set; /* int set[0:n-1]; */
      /* current clique */
};

#define n         (csa->n)
#define wt        (csa->wt)
#define a         (csa->a)
#define record    (csa->record)
#define rec_level (csa->rec_level)
#define rec       (csa->rec)
#define clique    (csa->clique)
#define set       (csa->set)

#if 0
static int is_edge(struct csa *csa, int i, int j)
{     /* if there is arc (i,j), the routine returns true; otherwise
       * false; 0 <= i, j < n */
      int k;
      xassert(0 <= i && i < n);
      xassert(0 <= j && j < n);
      if (i == j) return 0;
      if (i < j) k = i, i = j, j = k;
      k = (i * (i - 1)) / 2 + j;
      return a[k / CHAR_BIT] &
         (unsigned char)(1 << ((CHAR_BIT - 1) - k % CHAR_BIT));
}
#else
#define is_edge(csa, i, j) ((i) == (j) ? 0 : \
      (i) > (j) ? is_edge1(i, j) : is_edge1(j, i))
#define is_edge1(i, j) is_edge2(((i) * ((i) - 1)) / 2 + (j))
#define is_edge2(k) (a[(k) / CHAR_BIT] & \
      (unsigned char)(1 << ((CHAR_BIT - 1) - (k) % CHAR_BIT)))
#endif

static void sub(struct csa *csa, int ct, int table[], int level,
      int weight, int l_weight)
{     int i, j, k, curr_weight, left_weight, *p1, *p2, *newtable;
      newtable = xcalloc(n, sizeof(int));
      if (ct <= 0)
      {  /* 0 or 1 elements left; include these */
         if (ct == 0)
         {  set[level++] = table[0];
            weight += l_weight;
         }
         if (weight > record)
         {  record = weight;
            rec_level = level;
            for (i = 0; i < level; i++) rec[i] = set[i];
         }
         goto done;
      }
      for (i = ct; i >= 0; i--)
      {  if ((level == 0) && (i < ct)) goto done;
         k = table[i];
         if ((level > 0) && (clique[k] <= (record - weight)))
            goto done; /* prune */
         set[level] = k;
         curr_weight = weight + wt[k];
         l_weight -= wt[k];
         if (l_weight <= (record - curr_weight))
            goto done; /* prune */
         p1 = newtable;
         p2 = table;
         left_weight = 0;
         while (p2 < table + i)
         {  j = *p2++;
            if (is_edge(csa, j, k))
            {  *p1++ = j;
               left_weight += wt[j];
            }
         }
         if (left_weight <= (record - curr_weight)) continue;
         sub(csa, p1 - newtable - 1, newtable, level + 1, curr_weight,
            left_weight);
      }
done: xfree(newtable);
      return;
}

int wclique(int n_, const int w[], const unsigned char a_[], int ind[])
{     struct csa csa_, *csa = &csa_;
      int i, j, p, max_wt, max_nwt, wth, *used, *nwt, *pos;
      double timer;
      n = n_;
      xassert(n > 0);
      wt = &w[1];
      a = a_;
      record = 0;
      rec_level = 0;
      rec = &ind[1];
      clique = xcalloc(n, sizeof(int));
      set = xcalloc(n, sizeof(int));
      used = xcalloc(n, sizeof(int));
      nwt = xcalloc(n, sizeof(int));
      pos = xcalloc(n, sizeof(int));
      /* start timer */
      timer = xtime();
      /* order vertices */
      for (i = 0; i < n; i++)
      {  nwt[i] = 0;
         for (j = 0; j < n; j++)
            if (is_edge(csa, i, j)) nwt[i] += wt[j];
      }
      for (i = 0; i < n; i++)
         used[i] = 0;
      for (i = n-1; i >= 0; i--)
      {  max_wt = -1;
         max_nwt = -1;
         for (j = 0; j < n; j++)
         {  if ((!used[j]) && ((wt[j] > max_wt) || (wt[j] == max_wt
               && nwt[j] > max_nwt)))
            {  max_wt = wt[j];
               max_nwt = nwt[j];
               p = j;
            }
         }
         pos[i] = p;
         used[p] = 1;
         for (j = 0; j < n; j++)
            if ((!used[j]) && (j != p) && (is_edge(csa, p, j)))
               nwt[j] -= wt[p];
      }
      /* main routine */
      wth = 0;
      for (i = 0; i < n; i++)
      {  wth += wt[pos[i]];
         sub(csa, i, pos, 0, 0, wth);
         clique[pos[i]] = record;
         if (xdifftime(xtime(), timer) >= 5.0 - 0.001)
         {  /* print current record and reset timer */
            xprintf("level = %d (%d); best = %d\n", i+1, n, record);
            timer = xtime();
         }
      }
      xfree(clique);
      xfree(set);
      xfree(used);
      xfree(nwt);
      xfree(pos);
      /* return the solution found */
      for (i = 1; i <= rec_level; i++) ind[i]++;
      return rec_level;
}

#undef n
#undef wt
#undef a
#undef record
#undef rec_level
#undef rec
#undef clique
#undef set

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/wclique.h0000644000175100001710000000226400000000000024665 0ustar00runnerdocker00000000000000/* wclique.h (maximum weight clique, Ostergard's algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef WCLIQUE_H
#define WCLIQUE_H

#define wclique _glp_wclique
int wclique(int n, const int w[], const unsigned char a[], int ind[]);
/* find maximum weight clique with Ostergard's algorithm */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/wclique1.c0000644000175100001710000002564100000000000024745 0ustar00runnerdocker00000000000000/* wclique1.c (maximum weight clique, greedy heuristic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "wclique1.h"

/***********************************************************************
*  NAME
*
*  wclique1 - find maximum weight clique with greedy heuristic
*
*  SYNOPSIS
*
*  #include "wclique1.h"
*  int wclique1(int n, const double w[],
*     int (*func)(void *info, int i, int ind[]), void *info, int c[]);
*
*  DESCRIPTION
*
*  The routine wclique1 implements a sequential greedy heuristic to
*  find maximum weight clique in a given (undirected) graph G = (V, E).
*
*  The parameter n specifies the number of vertices |V| in the graph,
*  n >= 0.
*
*  The array w specifies vertex weights in locations w[i], i = 1,...,n.
*  All weights must be non-negative.
*
*  The formal routine func specifies the graph. For a given vertex i,
*  1 <= i <= n, it stores indices of all vertices adjacent to vertex i
*  in locations ind[1], ..., ind[deg], where deg is the degree of
*  vertex i, 0 <= deg < n, returned on exit. Note that self-loops and
*  multiple edges are not allowed.
*
*  The parameter info is a cookie passed to the routine func.
*
*  On exit the routine wclique1 stores vertex indices included in
*  the clique found to locations c[1], ..., c[size], where size is the
*  clique size returned by the routine, 0 <= size <= n.
*
*  RETURNS
*
*  The routine wclique1 returns the size of the clique found. */

struct vertex { int i; double cw; };

static int CDECL fcmp(const void *xx, const void *yy)
{     const struct vertex *x = xx, *y = yy;
      if (x->cw > y->cw) return -1;
      if (x->cw < y->cw) return +1;
      return 0;
}

int wclique1(int n, const double w[],
      int (*func)(void *info, int i, int ind[]), void *info, int c[])
{     struct vertex *v_list;
      int deg, c_size, d_size, i, j, k, kk, l, *ind, *c_list, *d_list,
         size = 0;
      double c_wght, d_wght, *sw, best = 0.0;
      char *d_flag, *skip;
      /* perform sanity checks */
      xassert(n >= 0);
      for (i = 1; i <= n; i++)
         xassert(w[i] >= 0.0);
      /* if the graph is empty, nothing to do */
      if (n == 0) goto done;
      /* allocate working arrays */
      ind = xcalloc(1+n, sizeof(int));
      v_list = xcalloc(1+n, sizeof(struct vertex));
      c_list = xcalloc(1+n, sizeof(int));
      d_list = xcalloc(1+n, sizeof(int));
      d_flag = xcalloc(1+n, sizeof(char));
      skip = xcalloc(1+n, sizeof(char));
      sw = xcalloc(1+n, sizeof(double));
      /* build the vertex list */
      for (i = 1; i <= n; i++)
      {  v_list[i].i = i;
         /* compute the cumulative weight of each vertex i, which is
          * cw[i] = w[i] + sum{j : (i,j) in E} w[j] */
         v_list[i].cw = w[i];
         deg = func(info, i, ind);
         xassert(0 <= deg && deg < n);
         for (k = 1; k <= deg; k++)
         {  j = ind[k];
            xassert(1 <= j && j <= n && j != i);
            v_list[i].cw += w[j];
         }
      }
      /* sort the vertex list to access vertices in descending order of
       * cumulative weights */
      qsort(&v_list[1], n, sizeof(struct vertex), fcmp);
      /* initially all vertices are unmarked */
      memset(&skip[1], 0, sizeof(char) * n);
      /* clear flags of all vertices */
      memset(&d_flag[1], 0, sizeof(char) * n);
      /* look through all vertices of the graph */
      for (l = 1; l <= n; l++)
      {  /* take vertex i */
         i = v_list[l].i;
         /* if this vertex was already included in one of previosuly
          * constructed cliques, skip it */
         if (skip[i]) continue;
         /* use vertex i as the initial clique vertex */
         c_size = 1;    /* size of current clique */
         c_list[1] = i; /* list of vertices in current clique */
         c_wght = w[i]; /* weight of current clique */
         /* determine the candidate set D = { j : (i,j) in E } */
         d_size = func(info, i, d_list);
         xassert(0 <= d_size && d_size < n);
         d_wght = 0.0;  /* weight of set D */
         for (k = 1; k <= d_size; k++)
         {  j = d_list[k];
            xassert(1 <= j && j <= n && j != i);
            xassert(!d_flag[j]);
            d_flag[j] = 1;
            d_wght += w[j];
         }
         /* check an upper bound to the final clique weight */
         if (c_wght + d_wght < best + 1e-5 * (1.0 + fabs(best)))
         {  /* skip constructing the current clique */
            goto next;
         }
         /* compute the summary weight of each vertex i in D, which is
          * sw[i] = w[i] + sum{j in D and (i,j) in E} w[j] */
         for (k = 1; k <= d_size; k++)
         {  i = d_list[k];
            sw[i] = w[i];
            /* consider vertices adjacent to vertex i */
            deg = func(info, i, ind);
            xassert(0 <= deg && deg < n);
            for (kk = 1; kk <= deg; kk++)
            {  j = ind[kk];
               xassert(1 <= j && j <= n && j != i);
               if (d_flag[j]) sw[i] += w[j];
            }
         }
         /* grow the current clique by adding vertices from D */
         while (d_size > 0)
         {  /* check an upper bound to the final clique weight */
            if (c_wght + d_wght < best + 1e-5 * (1.0 + fabs(best)))
            {  /* skip constructing the current clique */
               goto next;
            }
            /* choose vertex i in D having maximal summary weight */
            i = d_list[1];
            for (k = 2; k <= d_size; k++)
            {  j = d_list[k];
               if (sw[i] < sw[j]) i = j;
            }
            /* include vertex i in the current clique */
            c_size++;
            c_list[c_size] = i;
            c_wght += w[i];
            /* remove all vertices not adjacent to vertex i, including
             * vertex i itself, from the candidate set D */
            deg = func(info, i, ind);
            xassert(0 <= deg && deg < n);
            for (k = 1; k <= deg; k++)
            {  j = ind[k];
               xassert(1 <= j && j <= n && j != i);
               /* vertex j is adjacent to vertex i */
               if (d_flag[j])
               {  xassert(d_flag[j] == 1);
                  /* mark vertex j to keep it in D */
                  d_flag[j] = 2;
               }
            }
            kk = d_size, d_size = 0;
            for (k = 1; k <= kk; k++)
            {  j = d_list[k];
               if (d_flag[j] == 1)
               {  /* remove vertex j from D */
                  d_flag[j] = 0;
                  d_wght -= w[j];
               }
               else if (d_flag[j] == 2)
               {  /* keep vertex j in D */
                  d_list[++d_size] = j;
                  d_flag[j] = 1;
               }
               else
                  xassert(d_flag != d_flag);
            }
         }
         /* the current clique has been completely constructed */
         if (best < c_wght)
         {  best = c_wght;
            size = c_size;
            xassert(1 <= size && size <= n);
            memcpy(&c[1], &c_list[1], size * sizeof(int));
         }
next:    /* mark the current clique vertices in order not to use them
          * as initial vertices anymore */
         for (k = 1; k <= c_size; k++)
            skip[c_list[k]] = 1;
         /* set D can be non-empty, so clean up vertex flags */
         for (k = 1; k <= d_size; k++)
            d_flag[d_list[k]] = 0;
      }
      /* free working arrays */
      xfree(ind);
      xfree(v_list);
      xfree(c_list);
      xfree(d_list);
      xfree(d_flag);
      xfree(skip);
      xfree(sw);
done: /* return to the calling program */
      return size;
}

/**********************************************************************/

#ifdef GLP_TEST
#include "glpk.h"
#include "rng.h"

typedef struct { double w; } v_data;

#define weight(v) (((v_data *)((v)->data))->w)

glp_graph *G;

char *flag;

int func(void *info, int i, int ind[])
{     glp_arc *e;
      int j, k, deg = 0;
      xassert(info == NULL);
      xassert(1 <= i && i <= G->nv);
      /* look through incoming arcs */
      for (e = G->v[i]->in; e != NULL; e = e->h_next)
      {  j = e->tail->i; /* j->i */
         if (j != i && !flag[j]) ind[++deg] = j, flag[j] = 1;
      }
      /* look through outgoing arcs */
      for (e = G->v[i]->out; e != NULL; e = e->t_next)
      {  j = e->head->i; /* i->j */
         if (j != i && !flag[j]) ind[++deg] = j, flag[j] = 1;
      }
      /* clear the flag array */
      xassert(deg < G->nv);
      for (k = 1; k <= deg; k++) flag[ind[k]] = 0;
      return deg;
}

int main(int argc, char *argv[])
{     RNG *rand;
      int i, k, kk, size, *c, *ind, deg;
      double *w, sum, t;
      /* read graph in DIMACS format */
      G = glp_create_graph(sizeof(v_data), 0);
      xassert(argc == 2);
      xassert(glp_read_ccdata(G, offsetof(v_data, w), argv[1]) == 0);
      /* print the number of connected components */
      xprintf("nc = %d\n", glp_weak_comp(G, -1));
      /* assign random weights unformly distributed in [1,100] */
      w = xcalloc(1+G->nv, sizeof(double));
      rand = rng_create_rand();
      for (i = 1; i <= G->nv; i++)
#if 0
         w[i] = weight(G->v[i]) = 1.0;
#else
         w[i] = weight(G->v[i]) = rng_unif_rand(rand, 100) + 1;
#endif
      /* write graph in DIMACS format */
      xassert(glp_write_ccdata(G, offsetof(v_data, w), "graph") == 0);
      /* find maximum weight clique */
      c = xcalloc(1+G->nv, sizeof(int));
      flag = xcalloc(1+G->nv, sizeof(char));
      memset(&flag[1], 0, G->nv);
      t = xtime();
      size = wclique1(G->nv, w, func, NULL, c);
      xprintf("Time used: %.1f s\n", xdifftime(xtime(), t));
      /* check the clique found */
      ind = xcalloc(1+G->nv, sizeof(int));
      for (k = 1; k <= size; k++)
      {  i = c[k];
         deg = func(NULL, i, ind);
         for (kk = 1; kk <= size; kk++)
            flag[c[kk]] = 1;
         flag[i] = 0;
         for (kk = 1; kk <= deg; kk++)
            flag[ind[kk]] = 0;
         for (kk = 1; kk <= size; kk++)
            xassert(flag[c[kk]] == 0);
      }
      /* compute the clique weight */
      sum = 0.0;
      for (i = 1; i <= size; i++)
         sum += w[c[i]];
      xprintf("size = %d; sum = %g\n", size, sum);
      return 0;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/misc/wclique1.h0000644000175100001710000000233200000000000024742 0ustar00runnerdocker00000000000000/* wclique1.h (maximum weight clique, greedy heuristic) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2012-2013 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef WCLIQUE1_H
#define WCLIQUE1_H

#define wclique1 _glp_wclique1
int wclique1(int n, const double w[],
      int (*func)(void *info, int i, int ind[]), void *info, int c[]);
/* find maximum weight clique with greedy heuristic */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6791432
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/0000755000175100001710000000000000000000000022674 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl.h0000644000175100001710000025745600000000000023660 0ustar00runnerdocker00000000000000/* mpl.h (GNU MathProg translator) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MPL_H
#define MPL_H

#include "avl.h"
#include "dmp.h"
#include "env.h"
#include "misc.h"
#include "rng.h"

#if 0 /* 22/I-2013 */
typedef struct MPL MPL;
#else
typedef struct glp_tran MPL;
#endif
typedef char STRING;
typedef struct SYMBOL SYMBOL;
typedef struct TUPLE TUPLE;
typedef struct ARRAY ELEMSET;
typedef struct ELEMVAR ELEMVAR;
typedef struct FORMULA FORMULA;
typedef struct ELEMCON ELEMCON;
typedef union VALUE VALUE;
typedef struct ARRAY ARRAY;
typedef struct MEMBER MEMBER;
#if 1
/* many C compilers have DOMAIN declared in  :( */
#undef DOMAIN
#define DOMAIN DOMAIN1
#endif
typedef struct DOMAIN DOMAIN;
typedef struct DOMAIN_BLOCK DOMAIN_BLOCK;
typedef struct DOMAIN_SLOT DOMAIN_SLOT;
typedef struct SET SET;
typedef struct WITHIN WITHIN;
typedef struct GADGET GADGET;
typedef struct PARAMETER PARAMETER;
typedef struct CONDITION CONDITION;
typedef struct VARIABLE VARIABLE;
typedef struct CONSTRAINT CONSTRAINT;
typedef struct TABLE TABLE;
typedef struct TABARG TABARG;
typedef struct TABFLD TABFLD;
typedef struct TABIN TABIN;
typedef struct TABOUT TABOUT;
typedef struct TABDCA TABDCA;
typedef union OPERANDS OPERANDS;
typedef struct ARG_LIST ARG_LIST;
typedef struct CODE CODE;
typedef struct CHECK CHECK;
typedef struct DISPLAY DISPLAY;
typedef struct DISPLAY1 DISPLAY1;
typedef struct PRINTF PRINTF;
typedef struct PRINTF1 PRINTF1;
typedef struct FOR FOR;
typedef struct STATEMENT STATEMENT;
typedef struct TUPLE SLICE;

/**********************************************************************/
/* * *                    TRANSLATOR DATABASE                     * * */
/**********************************************************************/

#define A_BINARY        101   /* something binary */
#define A_CHECK         102   /* check statement */
#define A_CONSTRAINT    103   /* model constraint */
#define A_DISPLAY       104   /* display statement */
#define A_ELEMCON       105   /* elemental constraint/objective */
#define A_ELEMSET       106   /* elemental set */
#define A_ELEMVAR       107   /* elemental variable */
#define A_EXPRESSION    108   /* expression */
#define A_FOR           109   /* for statement */
#define A_FORMULA       110   /* formula */
#define A_INDEX         111   /* dummy index */
#define A_INPUT         112   /* input table */
#define A_INTEGER       113   /* something integer */
#define A_LOGICAL       114   /* something logical */
#define A_MAXIMIZE      115   /* objective has to be maximized */
#define A_MINIMIZE      116   /* objective has to be minimized */
#define A_NONE          117   /* nothing */
#define A_NUMERIC       118   /* something numeric */
#define A_OUTPUT        119   /* output table */
#define A_PARAMETER     120   /* model parameter */
#define A_PRINTF        121   /* printf statement */
#define A_SET           122   /* model set */
#define A_SOLVE         123   /* solve statement */
#define A_SYMBOLIC      124   /* something symbolic */
#define A_TABLE         125   /* data table */
#define A_TUPLE         126   /* n-tuple */
#define A_VARIABLE      127   /* model variable */

#define MAX_LENGTH 100
/* maximal length of any symbolic value (this includes symbolic names,
   numeric and string literals, and all symbolic values that may appear
   during the evaluation phase) */

#define CONTEXT_SIZE 60
/* size of the context queue, in characters */

#define OUTBUF_SIZE 1024
/* size of the output buffer, in characters */

#if 0 /* 22/I-2013 */
struct MPL
#else
struct glp_tran
#endif
{     /* translator database */
      /*--------------------------------------------------------------*/
      /* scanning segment */
      int line;
      /* number of the current text line */
      int c;
      /* the current character or EOF */
      int token;
      /* the current token: */
#define T_EOF           201   /* end of file */
#define T_NAME          202   /* symbolic name (model section only) */
#define T_SYMBOL        203   /* symbol (data section only) */
#define T_NUMBER        204   /* numeric literal */
#define T_STRING        205   /* string literal */
#define T_AND           206   /* and && */
#define T_BY            207   /* by */
#define T_CROSS         208   /* cross */
#define T_DIFF          209   /* diff */
#define T_DIV           210   /* div */
#define T_ELSE          211   /* else */
#define T_IF            212   /* if */
#define T_IN            213   /* in */
#define T_INFINITY      214   /* Infinity */
#define T_INTER         215   /* inter */
#define T_LESS          216   /* less */
#define T_MOD           217   /* mod */
#define T_NOT           218   /* not ! */
#define T_OR            219   /* or || */
#define T_SPTP          220   /* s.t. */
#define T_SYMDIFF       221   /* symdiff */
#define T_THEN          222   /* then */
#define T_UNION         223   /* union */
#define T_WITHIN        224   /* within */
#define T_PLUS          225   /* + */
#define T_MINUS         226   /* - */
#define T_ASTERISK      227   /* * */
#define T_SLASH         228   /* / */
#define T_POWER         229   /* ^ ** */
#define T_LT            230   /* <  */
#define T_LE            231   /* <= */
#define T_EQ            232   /* = == */
#define T_GE            233   /* >= */
#define T_GT            234   /* >  */
#define T_NE            235   /* <> != */
#define T_CONCAT        236   /* & */
#define T_BAR           237   /* | */
#define T_POINT         238   /* . */
#define T_COMMA         239   /* , */
#define T_COLON         240   /* : */
#define T_SEMICOLON     241   /* ; */
#define T_ASSIGN        242   /* := */
#define T_DOTS          243   /* .. */
#define T_LEFT          244   /* ( */
#define T_RIGHT         245   /* ) */
#define T_LBRACKET      246   /* [ */
#define T_RBRACKET      247   /* ] */
#define T_LBRACE        248   /* { */
#define T_RBRACE        249   /* } */
#define T_APPEND        250   /* >> */
#define T_TILDE         251   /* ~ */
#define T_INPUT         252   /* <- */
      int imlen;
      /* length of the current token */
      char *image; /* char image[MAX_LENGTH+1]; */
      /* image of the current token */
      double value;
      /* value of the current token (for T_NUMBER only) */
      int b_token;
      /* the previous token */
      int b_imlen;
      /* length of the previous token */
      char *b_image; /* char b_image[MAX_LENGTH+1]; */
      /* image of the previous token */
      double b_value;
      /* value of the previous token (if token is T_NUMBER) */
      int f_dots;
      /* if this flag is set, the next token should be recognized as
         T_DOTS, not as T_POINT */
      int f_scan;
      /* if this flag is set, the next token is already scanned */
      int f_token;
      /* the next token */
      int f_imlen;
      /* length of the next token */
      char *f_image; /* char f_image[MAX_LENGTH+1]; */
      /* image of the next token */
      double f_value;
      /* value of the next token (if token is T_NUMBER) */
      char *context; /* char context[CONTEXT_SIZE]; */
      /* context circular queue (not null-terminated!) */
      int c_ptr;
      /* pointer to the current position in the context queue */
      int flag_d;
      /* if this flag is set, the data section is being processed */
      /*--------------------------------------------------------------*/
      /* translating segment */
      DMP *pool;
      /* memory pool used to allocate all data instances created during
         the translation phase */
      AVL *tree;
      /* symbolic name table:
         node.type = A_INDEX     => node.link -> DOMAIN_SLOT
         node.type = A_SET       => node.link -> SET
         node.type = A_PARAMETER => node.link -> PARAMETER
         node.type = A_VARIABLE  => node.link -> VARIABLE
         node.type = A_CONSTRANT => node.link -> CONSTRAINT */
      STATEMENT *model;
      /* linked list of model statements in the original order */
      int flag_x;
      /* if this flag is set, the current token being left parenthesis
         begins a slice that allows recognizing any undeclared symbolic
         names as dummy indices; this flag is automatically reset once
         the next token has been scanned */
      int as_within;
      /* the warning "in understood as within" has been issued */
      int as_in;
      /* the warning "within understood as in" has been issued */
      int as_binary;
      /* the warning "logical understood as binary" has been issued */
      int flag_s;
      /* if this flag is set, the solve statement has been parsed */
      /*--------------------------------------------------------------*/
      /* common segment */
      DMP *strings;
      /* memory pool to allocate STRING data structures */
      DMP *symbols;
      /* memory pool to allocate SYMBOL data structures */
      DMP *tuples;
      /* memory pool to allocate TUPLE data structures */
      DMP *arrays;
      /* memory pool to allocate ARRAY data structures */
      DMP *members;
      /* memory pool to allocate MEMBER data structures */
      DMP *elemvars;
      /* memory pool to allocate ELEMVAR data structures */
      DMP *formulae;
      /* memory pool to allocate FORMULA data structures */
      DMP *elemcons;
      /* memory pool to allocate ELEMCON data structures */
      ARRAY *a_list;
      /* linked list of all arrays in the database */
      char *sym_buf; /* char sym_buf[255+1]; */
      /* working buffer used by the routine format_symbol */
      char *tup_buf; /* char tup_buf[255+1]; */
      /* working buffer used by the routine format_tuple */
      /*--------------------------------------------------------------*/
      /* generating/postsolving segment */
      RNG *rand;
      /* pseudo-random number generator */
      int flag_p;
      /* if this flag is set, the postsolving phase is in effect */
      STATEMENT *stmt;
      /* model statement being currently executed */
      TABDCA *dca;
      /* pointer to table driver communication area for table statement
         currently executed */
      int m;
      /* number of rows in the problem, m >= 0 */
      int n;
      /* number of columns in the problem, n >= 0 */
      ELEMCON **row; /* ELEMCON *row[1+m]; */
      /* row[0] is not used;
         row[i] is elemental constraint or objective, which corresponds
         to i-th row of the problem, 1 <= i <= m */
      ELEMVAR **col; /* ELEMVAR *col[1+n]; */
      /* col[0] is not used;
         col[j] is elemental variable, which corresponds to j-th column
         of the problem, 1 <= j <= n */
      /*--------------------------------------------------------------*/
      /* input/output segment */
      glp_file *in_fp;
      /* stream assigned to the input text file */
      char *in_file;
      /* name of the input text file */
      glp_file *out_fp;
      /* stream assigned to the output text file used to write all data
         produced by display and printf statements; NULL means the data
         should be sent to stdout via the routine xprintf */
      char *out_file;
      /* name of the output text file */
#if 0 /* 08/XI-2009 */
      char *out_buf; /* char out_buf[OUTBUF_SIZE] */
      /* buffer to accumulate output data */
      int out_cnt;
      /* count of data bytes stored in the output buffer */
#endif
      glp_file *prt_fp;
      /* stream assigned to the print text file; may be NULL */
      char *prt_file;
      /* name of the output print file */
      /*--------------------------------------------------------------*/
      /* solver interface segment */
      jmp_buf jump;
      /* jump address for non-local go to in case of error */
      int phase;
      /* phase of processing:
         0 - database is being or has been initialized
         1 - model section is being or has been read
         2 - data section is being or has been read
         3 - model is being or has been generated/postsolved
         4 - model processing error has occurred */
      char *mod_file;
      /* name of the input text file, which contains model section */
      char *mpl_buf; /* char mpl_buf[255+1]; */
      /* working buffer used by some interface routines */
};

/**********************************************************************/
/* * *                  PROCESSING MODEL SECTION                  * * */
/**********************************************************************/

#define alloc(type) ((type *)dmp_get_atomv(mpl->pool, sizeof(type)))
/* allocate atom of given type */

#define enter_context _glp_mpl_enter_context
void enter_context(MPL *mpl);
/* enter current token into context queue */

#define print_context _glp_mpl_print_context
void print_context(MPL *mpl);
/* print current content of context queue */

#define get_char _glp_mpl_get_char
void get_char(MPL *mpl);
/* scan next character from input text file */

#define append_char _glp_mpl_append_char
void append_char(MPL *mpl);
/* append character to current token */

#define get_token _glp_mpl_get_token
void get_token(MPL *mpl);
/* scan next token from input text file */

#define unget_token _glp_mpl_unget_token
void unget_token(MPL *mpl);
/* return current token back to input stream */

#define is_keyword _glp_mpl_is_keyword
int is_keyword(MPL *mpl, char *keyword);
/* check if current token is given non-reserved keyword */

#define is_reserved _glp_mpl_is_reserved
int is_reserved(MPL *mpl);
/* check if current token is reserved keyword */

#define make_code _glp_mpl_make_code
CODE *make_code(MPL *mpl, int op, OPERANDS *arg, int type, int dim);
/* generate pseudo-code (basic routine) */

#define make_unary _glp_mpl_make_unary
CODE *make_unary(MPL *mpl, int op, CODE *x, int type, int dim);
/* generate pseudo-code for unary operation */

#define make_binary _glp_mpl_make_binary
CODE *make_binary(MPL *mpl, int op, CODE *x, CODE *y, int type,
      int dim);
/* generate pseudo-code for binary operation */

#define make_ternary _glp_mpl_make_ternary
CODE *make_ternary(MPL *mpl, int op, CODE *x, CODE *y, CODE *z,
      int type, int dim);
/* generate pseudo-code for ternary operation */

#define numeric_literal _glp_mpl_numeric_literal
CODE *numeric_literal(MPL *mpl);
/* parse reference to numeric literal */

#define string_literal _glp_mpl_string_literal
CODE *string_literal(MPL *mpl);
/* parse reference to string literal */

#define create_arg_list _glp_mpl_create_arg_list
ARG_LIST *create_arg_list(MPL *mpl);
/* create empty operands list */

#define expand_arg_list _glp_mpl_expand_arg_list
ARG_LIST *expand_arg_list(MPL *mpl, ARG_LIST *list, CODE *x);
/* append operand to operands list */

#define arg_list_len _glp_mpl_arg_list_len
int arg_list_len(MPL *mpl, ARG_LIST *list);
/* determine length of operands list */

#define subscript_list _glp_mpl_subscript_list
ARG_LIST *subscript_list(MPL *mpl);
/* parse subscript list */

#define object_reference _glp_mpl_object_reference
CODE *object_reference(MPL *mpl);
/* parse reference to named object */

#define numeric_argument _glp_mpl_numeric_argument
CODE *numeric_argument(MPL *mpl, char *func);
/* parse argument passed to built-in function */

#define symbolic_argument _glp_mpl_symbolic_argument
CODE *symbolic_argument(MPL *mpl, char *func);

#define elemset_argument _glp_mpl_elemset_argument
CODE *elemset_argument(MPL *mpl, char *func);

#define function_reference _glp_mpl_function_reference
CODE *function_reference(MPL *mpl);
/* parse reference to built-in function */

#define create_domain _glp_mpl_create_domain
DOMAIN *create_domain(MPL *mpl);
/* create empty domain */

#define create_block _glp_mpl_create_block
DOMAIN_BLOCK *create_block(MPL *mpl);
/* create empty domain block */

#define append_block _glp_mpl_append_block
void append_block(MPL *mpl, DOMAIN *domain, DOMAIN_BLOCK *block);
/* append domain block to specified domain */

#define append_slot _glp_mpl_append_slot
DOMAIN_SLOT *append_slot(MPL *mpl, DOMAIN_BLOCK *block, char *name,
      CODE *code);
/* create and append new slot to domain block */

#define expression_list _glp_mpl_expression_list
CODE *expression_list(MPL *mpl);
/* parse expression list */

#define literal_set _glp_mpl_literal_set
CODE *literal_set(MPL *mpl, CODE *code);
/* parse literal set */

#define indexing_expression _glp_mpl_indexing_expression
DOMAIN *indexing_expression(MPL *mpl);
/* parse indexing expression */

#define close_scope _glp_mpl_close_scope
void close_scope(MPL *mpl, DOMAIN *domain);
/* close scope of indexing expression */

#define iterated_expression _glp_mpl_iterated_expression
CODE *iterated_expression(MPL *mpl);
/* parse iterated expression */

#define domain_arity _glp_mpl_domain_arity
int domain_arity(MPL *mpl, DOMAIN *domain);
/* determine arity of domain */

#define set_expression _glp_mpl_set_expression
CODE *set_expression(MPL *mpl);
/* parse set expression */

#define branched_expression _glp_mpl_branched_expression
CODE *branched_expression(MPL *mpl);
/* parse conditional expression */

#define primary_expression _glp_mpl_primary_expression
CODE *primary_expression(MPL *mpl);
/* parse primary expression */

#define error_preceding _glp_mpl_error_preceding
void error_preceding(MPL *mpl, char *opstr);
/* raise error if preceding operand has wrong type */

#define error_following _glp_mpl_error_following
void error_following(MPL *mpl, char *opstr);
/* raise error if following operand has wrong type */

#define error_dimension _glp_mpl_error_dimension
void error_dimension(MPL *mpl, char *opstr, int dim1, int dim2);
/* raise error if operands have different dimension */

#define expression_0 _glp_mpl_expression_0
CODE *expression_0(MPL *mpl);
/* parse expression of level 0 */

#define expression_1 _glp_mpl_expression_1
CODE *expression_1(MPL *mpl);
/* parse expression of level 1 */

#define expression_2 _glp_mpl_expression_2
CODE *expression_2(MPL *mpl);
/* parse expression of level 2 */

#define expression_3 _glp_mpl_expression_3
CODE *expression_3(MPL *mpl);
/* parse expression of level 3 */

#define expression_4 _glp_mpl_expression_4
CODE *expression_4(MPL *mpl);
/* parse expression of level 4 */

#define expression_5 _glp_mpl_expression_5
CODE *expression_5(MPL *mpl);
/* parse expression of level 5 */

#define expression_6 _glp_mpl_expression_6
CODE *expression_6(MPL *mpl);
/* parse expression of level 6 */

#define expression_7 _glp_mpl_expression_7
CODE *expression_7(MPL *mpl);
/* parse expression of level 7 */

#define expression_8 _glp_mpl_expression_8
CODE *expression_8(MPL *mpl);
/* parse expression of level 8 */

#define expression_9 _glp_mpl_expression_9
CODE *expression_9(MPL *mpl);
/* parse expression of level 9 */

#define expression_10 _glp_mpl_expression_10
CODE *expression_10(MPL *mpl);
/* parse expression of level 10 */

#define expression_11 _glp_mpl_expression_11
CODE *expression_11(MPL *mpl);
/* parse expression of level 11 */

#define expression_12 _glp_mpl_expression_12
CODE *expression_12(MPL *mpl);
/* parse expression of level 12 */

#define expression_13 _glp_mpl_expression_13
CODE *expression_13(MPL *mpl);
/* parse expression of level 13 */

#define set_statement _glp_mpl_set_statement
SET *set_statement(MPL *mpl);
/* parse set statement */

#define parameter_statement _glp_mpl_parameter_statement
PARAMETER *parameter_statement(MPL *mpl);
/* parse parameter statement */

#define variable_statement _glp_mpl_variable_statement
VARIABLE *variable_statement(MPL *mpl);
/* parse variable statement */

#define constraint_statement _glp_mpl_constraint_statement
CONSTRAINT *constraint_statement(MPL *mpl);
/* parse constraint statement */

#define objective_statement _glp_mpl_objective_statement
CONSTRAINT *objective_statement(MPL *mpl);
/* parse objective statement */

#define table_statement _glp_mpl_table_statement
TABLE *table_statement(MPL *mpl);
/* parse table statement */

#define solve_statement _glp_mpl_solve_statement
void *solve_statement(MPL *mpl);
/* parse solve statement */

#define check_statement _glp_mpl_check_statement
CHECK *check_statement(MPL *mpl);
/* parse check statement */

#define display_statement _glp_mpl_display_statement
DISPLAY *display_statement(MPL *mpl);
/* parse display statement */

#define printf_statement _glp_mpl_printf_statement
PRINTF *printf_statement(MPL *mpl);
/* parse printf statement */

#define for_statement _glp_mpl_for_statement
FOR *for_statement(MPL *mpl);
/* parse for statement */

#define end_statement _glp_mpl_end_statement
void end_statement(MPL *mpl);
/* parse end statement */

#define simple_statement _glp_mpl_simple_statement
STATEMENT *simple_statement(MPL *mpl, int spec);
/* parse simple statement */

#define model_section _glp_mpl_model_section
void model_section(MPL *mpl);
/* parse model section */

/**********************************************************************/
/* * *                  PROCESSING DATA SECTION                   * * */
/**********************************************************************/

#if 2 + 2 == 5
struct SLICE /* see TUPLE */
{     /* component of slice; the slice itself is associated with its
         first component; slices are similar to n-tuples with exception
         that some slice components (which are indicated by asterisks)
         don't refer to any symbols */
      SYMBOL *sym;
      /* symbol, which this component refers to; can be NULL */
      SLICE *next;
      /* the next component of slice */
};
#endif

#define create_slice _glp_mpl_create_slice
SLICE *create_slice(MPL *mpl);
/* create slice */

#define expand_slice _glp_mpl_expand_slice
SLICE *expand_slice
(     MPL *mpl,
      SLICE *slice,           /* destroyed */
      SYMBOL *sym             /* destroyed */
);
/* append new component to slice */

#define slice_dimen _glp_mpl_slice_dimen
int slice_dimen
(     MPL *mpl,
      SLICE *slice            /* not changed */
);
/* determine dimension of slice */

#define slice_arity _glp_mpl_slice_arity
int slice_arity
(     MPL *mpl,
      SLICE *slice            /* not changed */
);
/* determine arity of slice */

#define fake_slice _glp_mpl_fake_slice
SLICE *fake_slice(MPL *mpl, int dim);
/* create fake slice of all asterisks */

#define delete_slice _glp_mpl_delete_slice
void delete_slice
(     MPL *mpl,
      SLICE *slice            /* destroyed */
);
/* delete slice */

#define is_number _glp_mpl_is_number
int is_number(MPL *mpl);
/* check if current token is number */

#define is_symbol _glp_mpl_is_symbol
int is_symbol(MPL *mpl);
/* check if current token is symbol */

#define is_literal _glp_mpl_is_literal
int is_literal(MPL *mpl, char *literal);
/* check if current token is given symbolic literal */

#define read_number _glp_mpl_read_number
double read_number(MPL *mpl);
/* read number */

#define read_symbol _glp_mpl_read_symbol
SYMBOL *read_symbol(MPL *mpl);
/* read symbol */

#define read_slice _glp_mpl_read_slice
SLICE *read_slice
(     MPL *mpl,
      char *name,             /* not changed */
      int dim
);
/* read slice */

#define select_set _glp_mpl_select_set
SET *select_set
(     MPL *mpl,
      char *name              /* not changed */
);
/* select set to saturate it with elemental sets */

#define simple_format _glp_mpl_simple_format
void simple_format
(     MPL *mpl,
      SET *set,               /* not changed */
      MEMBER *memb,           /* modified */
      SLICE *slice            /* not changed */
);
/* read set data block in simple format */

#define matrix_format _glp_mpl_matrix_format
void matrix_format
(     MPL *mpl,
      SET *set,               /* not changed */
      MEMBER *memb,           /* modified */
      SLICE *slice,           /* not changed */
      int tr
);
/* read set data block in matrix format */

#define set_data _glp_mpl_set_data
void set_data(MPL *mpl);
/* read set data */

#define select_parameter _glp_mpl_select_parameter
PARAMETER *select_parameter
(     MPL *mpl,
      char *name              /* not changed */
);
/* select parameter to saturate it with data */

#define set_default _glp_mpl_set_default
void set_default
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SYMBOL *altval          /* destroyed */
);
/* set default parameter value */

#define read_value _glp_mpl_read_value
MEMBER *read_value
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* destroyed */
);
/* read value and assign it to parameter member */

#define plain_format _glp_mpl_plain_format
void plain_format
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SLICE *slice            /* not changed */
);
/* read parameter data block in plain format */

#define tabular_format _glp_mpl_tabular_format
void tabular_format
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SLICE *slice,           /* not changed */
      int tr
);
/* read parameter data block in tabular format */

#define tabbing_format _glp_mpl_tabbing_format
void tabbing_format
(     MPL *mpl,
      SYMBOL *altval          /* not changed */
);
/* read parameter data block in tabbing format */

#define parameter_data _glp_mpl_parameter_data
void parameter_data(MPL *mpl);
/* read parameter data */

#define data_section _glp_mpl_data_section
void data_section(MPL *mpl);
/* read data section */

/**********************************************************************/
/* * *                   FLOATING-POINT NUMBERS                   * * */
/**********************************************************************/

#define fp_add _glp_mpl_fp_add
double fp_add(MPL *mpl, double x, double y);
/* floating-point addition */

#define fp_sub _glp_mpl_fp_sub
double fp_sub(MPL *mpl, double x, double y);
/* floating-point subtraction */

#define fp_less _glp_mpl_fp_less
double fp_less(MPL *mpl, double x, double y);
/* floating-point non-negative subtraction */

#define fp_mul _glp_mpl_fp_mul
double fp_mul(MPL *mpl, double x, double y);
/* floating-point multiplication */

#define fp_div _glp_mpl_fp_div
double fp_div(MPL *mpl, double x, double y);
/* floating-point division */

#define fp_idiv _glp_mpl_fp_idiv
double fp_idiv(MPL *mpl, double x, double y);
/* floating-point quotient of exact division */

#define fp_mod _glp_mpl_fp_mod
double fp_mod(MPL *mpl, double x, double y);
/* floating-point remainder of exact division */

#define fp_power _glp_mpl_fp_power
double fp_power(MPL *mpl, double x, double y);
/* floating-point exponentiation (raise to power) */

#define fp_exp _glp_mpl_fp_exp
double fp_exp(MPL *mpl, double x);
/* floating-point base-e exponential */

#define fp_log _glp_mpl_fp_log
double fp_log(MPL *mpl, double x);
/* floating-point natural logarithm */

#define fp_log10 _glp_mpl_fp_log10
double fp_log10(MPL *mpl, double x);
/* floating-point common (decimal) logarithm */

#define fp_sqrt _glp_mpl_fp_sqrt
double fp_sqrt(MPL *mpl, double x);
/* floating-point square root */

#define fp_sin _glp_mpl_fp_sin
double fp_sin(MPL *mpl, double x);
/* floating-point trigonometric sine */

#define fp_cos _glp_mpl_fp_cos
double fp_cos(MPL *mpl, double x);
/* floating-point trigonometric cosine */

#define fp_tan _glp_mpl_fp_tan
double fp_tan(MPL *mpl, double x);
/* floating-point trigonometric tangent */

#define fp_atan _glp_mpl_fp_atan
double fp_atan(MPL *mpl, double x);
/* floating-point trigonometric arctangent */

#define fp_atan2 _glp_mpl_fp_atan2
double fp_atan2(MPL *mpl, double y, double x);
/* floating-point trigonometric arctangent */

#define fp_round _glp_mpl_fp_round
double fp_round(MPL *mpl, double x, double n);
/* round floating-point value to n fractional digits */

#define fp_trunc _glp_mpl_fp_trunc
double fp_trunc(MPL *mpl, double x, double n);
/* truncate floating-point value to n fractional digits */

/**********************************************************************/
/* * *              PSEUDO-RANDOM NUMBER GENERATORS               * * */
/**********************************************************************/

#define fp_irand224 _glp_mpl_fp_irand224
double fp_irand224(MPL *mpl);
/* pseudo-random integer in the range [0, 2^24) */

#define fp_uniform01 _glp_mpl_fp_uniform01
double fp_uniform01(MPL *mpl);
/* pseudo-random number in the range [0, 1) */

#define fp_uniform _glp_mpl_uniform
double fp_uniform(MPL *mpl, double a, double b);
/* pseudo-random number in the range [a, b) */

#define fp_normal01 _glp_mpl_fp_normal01
double fp_normal01(MPL *mpl);
/* Gaussian random variate with mu = 0 and sigma = 1 */

#define fp_normal _glp_mpl_fp_normal
double fp_normal(MPL *mpl, double mu, double sigma);
/* Gaussian random variate with specified mu and sigma */

/**********************************************************************/
/* * *                         DATE/TIME                          * * */
/**********************************************************************/

#define fn_gmtime _glp_mpl_fn_gmtime
double fn_gmtime(MPL *mpl);
/* obtain the current calendar time (UTC) */

#define fn_str2time _glp_mpl_fn_str2time
double fn_str2time(MPL *mpl, const char *str, const char *fmt);
/* convert character string to the calendar time */

#define fn_time2str _glp_mpl_fn_time2str
void fn_time2str(MPL *mpl, char *str, double t, const char *fmt);
/* convert the calendar time to character string */

/**********************************************************************/
/* * *                     CHARACTER STRINGS                      * * */
/**********************************************************************/

#define create_string _glp_mpl_create_string
STRING *create_string
(     MPL *mpl,
      char buf[MAX_LENGTH+1]  /* not changed */
);
/* create character string */

#define copy_string _glp_mpl_copy_string
STRING *copy_string
(     MPL *mpl,
      STRING *str             /* not changed */
);
/* make copy of character string */

#define compare_strings _glp_mpl_compare_strings
int compare_strings
(     MPL *mpl,
      STRING *str1,           /* not changed */
      STRING *str2            /* not changed */
);
/* compare one character string with another */

#define fetch_string _glp_mpl_fetch_string
char *fetch_string
(     MPL *mpl,
      STRING *str,            /* not changed */
      char buf[MAX_LENGTH+1]  /* modified */
);
/* extract content of character string */

#define delete_string _glp_mpl_delete_string
void delete_string
(     MPL *mpl,
      STRING *str             /* destroyed */
);
/* delete character string */

/**********************************************************************/
/* * *                          SYMBOLS                           * * */
/**********************************************************************/

struct SYMBOL
{     /* symbol (numeric or abstract quantity) */
      double num;
      /* numeric value of symbol (used only if str == NULL) */
      STRING *str;
      /* abstract value of symbol (used only if str != NULL) */
};

#define create_symbol_num _glp_mpl_create_symbol_num
SYMBOL *create_symbol_num(MPL *mpl, double num);
/* create symbol of numeric type */

#define create_symbol_str _glp_mpl_create_symbol_str
SYMBOL *create_symbol_str
(     MPL *mpl,
      STRING *str             /* destroyed */
);
/* create symbol of abstract type */

#define copy_symbol _glp_mpl_copy_symbol
SYMBOL *copy_symbol
(     MPL *mpl,
      SYMBOL *sym             /* not changed */
);
/* make copy of symbol */

#define compare_symbols _glp_mpl_compare_symbols
int compare_symbols
(     MPL *mpl,
      SYMBOL *sym1,           /* not changed */
      SYMBOL *sym2            /* not changed */
);
/* compare one symbol with another */

#define delete_symbol _glp_mpl_delete_symbol
void delete_symbol
(     MPL *mpl,
      SYMBOL *sym             /* destroyed */
);
/* delete symbol */

#define format_symbol _glp_mpl_format_symbol
char *format_symbol
(     MPL *mpl,
      SYMBOL *sym             /* not changed */
);
/* format symbol for displaying or printing */

#define concat_symbols _glp_mpl_concat_symbols
SYMBOL *concat_symbols
(     MPL *mpl,
      SYMBOL *sym1,           /* destroyed */
      SYMBOL *sym2            /* destroyed */
);
/* concatenate one symbol with another */

/**********************************************************************/
/* * *                          N-TUPLES                          * * */
/**********************************************************************/

struct TUPLE
{     /* component of n-tuple; the n-tuple itself is associated with
         its first component; (note that 0-tuple has no components) */
      SYMBOL *sym;
      /* symbol, which the component refers to; cannot be NULL */
      TUPLE *next;
      /* the next component of n-tuple */
};

#define create_tuple _glp_mpl_create_tuple
TUPLE *create_tuple(MPL *mpl);
/* create n-tuple */

#define expand_tuple _glp_mpl_expand_tuple
TUPLE *expand_tuple
(     MPL *mpl,
      TUPLE *tuple,           /* destroyed */
      SYMBOL *sym             /* destroyed */
);
/* append symbol to n-tuple */

#define tuple_dimen _glp_mpl_tuple_dimen
int tuple_dimen
(     MPL *mpl,
      TUPLE *tuple            /* not changed */
);
/* determine dimension of n-tuple */

#define copy_tuple _glp_mpl_copy_tuple
TUPLE *copy_tuple
(     MPL *mpl,
      TUPLE *tuple            /* not changed */
);
/* make copy of n-tuple */

#define compare_tuples _glp_mpl_compare_tuples
int compare_tuples
(     MPL *mpl,
      TUPLE *tuple1,          /* not changed */
      TUPLE *tuple2           /* not changed */
);
/* compare one n-tuple with another */

#define build_subtuple _glp_mpl_build_subtuple
TUPLE *build_subtuple
(     MPL *mpl,
      TUPLE *tuple,           /* not changed */
      int dim
);
/* build subtuple of given n-tuple */

#define delete_tuple _glp_mpl_delete_tuple
void delete_tuple
(     MPL *mpl,
      TUPLE *tuple            /* destroyed */
);
/* delete n-tuple */

#define format_tuple _glp_mpl_format_tuple
char *format_tuple
(     MPL *mpl,
      int c,
      TUPLE *tuple            /* not changed */
);
/* format n-tuple for displaying or printing */

/**********************************************************************/
/* * *                       ELEMENTAL SETS                       * * */
/**********************************************************************/

#if 2 + 2 == 5
struct ELEMSET /* see ARRAY */
{     /* elemental set of n-tuples; formally it is a "value" assigned
         to members of model sets (like numbers and symbols, which are
         values assigned to members of model parameters); note that a
         simple model set is not an elemental set, it is 0-dimensional
         array, the only member of which (if it exists) is assigned an
         elemental set */
#endif

#define create_elemset _glp_mpl_create_elemset
ELEMSET *create_elemset(MPL *mpl, int dim);
/* create elemental set */

#define find_tuple _glp_mpl_find_tuple
MEMBER *find_tuple
(     MPL *mpl,
      ELEMSET *set,           /* not changed */
      TUPLE *tuple            /* not changed */
);
/* check if elemental set contains given n-tuple */

#define add_tuple _glp_mpl_add_tuple
MEMBER *add_tuple
(     MPL *mpl,
      ELEMSET *set,           /* modified */
      TUPLE *tuple            /* destroyed */
);
/* add new n-tuple to elemental set */

#define check_then_add _glp_mpl_check_then_add
MEMBER *check_then_add
(     MPL *mpl,
      ELEMSET *set,           /* modified */
      TUPLE *tuple            /* destroyed */
);
/* check and add new n-tuple to elemental set */

#define copy_elemset _glp_mpl_copy_elemset
ELEMSET *copy_elemset
(     MPL *mpl,
      ELEMSET *set            /* not changed */
);
/* make copy of elemental set */

#define delete_elemset _glp_mpl_delete_elemset
void delete_elemset
(     MPL *mpl,
      ELEMSET *set            /* destroyed */
);
/* delete elemental set */

#define arelset_size _glp_mpl_arelset_size
int arelset_size(MPL *mpl, double t0, double tf, double dt);
/* compute size of "arithmetic" elemental set */

#define arelset_member _glp_mpl_arelset_member
double arelset_member(MPL *mpl, double t0, double tf, double dt, int j);
/* compute member of "arithmetic" elemental set */

#define create_arelset _glp_mpl_create_arelset
ELEMSET *create_arelset(MPL *mpl, double t0, double tf, double dt);
/* create "arithmetic" elemental set */

#define set_union _glp_mpl_set_union
ELEMSET *set_union
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
);
/* union of two elemental sets */

#define set_diff _glp_mpl_set_diff
ELEMSET *set_diff
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
);
/* difference between two elemental sets */

#define set_symdiff _glp_mpl_set_symdiff
ELEMSET *set_symdiff
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
);
/* symmetric difference between two elemental sets */

#define set_inter _glp_mpl_set_inter
ELEMSET *set_inter
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
);
/* intersection of two elemental sets */

#define set_cross _glp_mpl_set_cross
ELEMSET *set_cross
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
);
/* cross (Cartesian) product of two elemental sets */

/**********************************************************************/
/* * *                    ELEMENTAL VARIABLES                     * * */
/**********************************************************************/

struct ELEMVAR
{     /* elemental variable; formally it is a "value" assigned to
         members of model variables (like numbers and symbols, which
         are values assigned to members of model parameters) */
      int j;
      /* LP column number assigned to this elemental variable */
      VARIABLE *var;
      /* model variable, which contains this elemental variable */
      MEMBER *memb;
      /* array member, which is assigned this elemental variable */
      double lbnd;
      /* lower bound */
      double ubnd;
      /* upper bound */
      double temp;
      /* working quantity used in operations on linear forms; normally
         it contains floating-point zero */
#if 1 /* 15/V-2010 */
      int stat;
      double prim, dual;
      /* solution components provided by the solver */
#endif
};

/**********************************************************************/
/* * *                        LINEAR FORMS                        * * */
/**********************************************************************/

struct FORMULA
{     /* term of linear form c * x, where c is a coefficient, x is an
         elemental variable; the linear form itself is the sum of terms
         and is associated with its first term; (note that the linear
         form may be empty that means the sum is equal to zero) */
      double coef;
      /* coefficient at elemental variable or constant term */
      ELEMVAR *var;
      /* reference to elemental variable; NULL means constant term */
      FORMULA *next;
      /* the next term of linear form */
};

#define constant_term _glp_mpl_constant_term
FORMULA *constant_term(MPL *mpl, double coef);
/* create constant term */

#define single_variable _glp_mpl_single_variable
FORMULA *single_variable
(     MPL *mpl,
      ELEMVAR *var            /* referenced */
);
/* create single variable */

#define copy_formula _glp_mpl_copy_formula
FORMULA *copy_formula
(     MPL *mpl,
      FORMULA *form           /* not changed */
);
/* make copy of linear form */

#define delete_formula _glp_mpl_delete_formula
void delete_formula
(     MPL *mpl,
      FORMULA *form           /* destroyed */
);
/* delete linear form */

#define linear_comb _glp_mpl_linear_comb
FORMULA *linear_comb
(     MPL *mpl,
      double a, FORMULA *fx,  /* destroyed */
      double b, FORMULA *fy   /* destroyed */
);
/* linear combination of two linear forms */

#define remove_constant _glp_mpl_remove_constant
FORMULA *remove_constant
(     MPL *mpl,
      FORMULA *form,          /* destroyed */
      double *coef            /* modified */
);
/* remove constant term from linear form */

#define reduce_terms _glp_mpl_reduce_terms
FORMULA *reduce_terms
(     MPL *mpl,
      FORMULA *form           /* destroyed */
);
/* reduce identical terms in linear form */

/**********************************************************************/
/* * *                   ELEMENTAL CONSTRAINTS                    * * */
/**********************************************************************/

struct ELEMCON
{     /* elemental constraint; formally it is a "value" assigned to
         members of model constraints (like numbers or symbols, which
         are values assigned to members of model parameters) */
      int i;
      /* LP row number assigned to this elemental constraint */
      CONSTRAINT *con;
      /* model constraint, which contains this elemental constraint */
      MEMBER *memb;
      /* array member, which is assigned this elemental constraint */
      FORMULA *form;
      /* linear form */
      double lbnd;
      /* lower bound */
      double ubnd;
      /* upper bound */
#if 1 /* 15/V-2010 */
      int stat;
      double prim, dual;
      /* solution components provided by the solver */
#endif
};

/**********************************************************************/
/* * *                       GENERIC VALUES                       * * */
/**********************************************************************/

union VALUE
{     /* generic value, which can be assigned to object member or be a
         result of evaluation of expression */
      /* indicator that specifies the particular type of generic value
         is stored in the corresponding array or pseudo-code descriptor
         and can be one of the following:
         A_NONE     - no value
         A_NUMERIC  - floating-point number
         A_SYMBOLIC - symbol
         A_LOGICAL  - logical value
         A_TUPLE    - n-tuple
         A_ELEMSET  - elemental set
         A_ELEMVAR  - elemental variable
         A_FORMULA  - linear form
         A_ELEMCON  - elemental constraint */
      void *none;    /* null */
      double num;    /* value */
      SYMBOL *sym;   /* value */
      int bit;       /* value */
      TUPLE *tuple;  /* value */
      ELEMSET *set;  /* value */
      ELEMVAR *var;  /* reference */
      FORMULA *form; /* value */
      ELEMCON *con;  /* reference */
};

#define delete_value _glp_mpl_delete_value
void delete_value
(     MPL *mpl,
      int type,
      VALUE *value            /* content destroyed */
);
/* delete generic value */

/**********************************************************************/
/* * *                SYMBOLICALLY INDEXED ARRAYS                 * * */
/**********************************************************************/

struct ARRAY
{     /* multi-dimensional array, a set of members indexed over simple
         or compound sets of symbols; arrays are used to represent the
         contents of model objects (i.e. sets, parameters, variables,
         constraints, and objectives); arrays also are used as "values"
         that are assigned to members of set objects, in which case the
         array itself represents an elemental set */
      int type;
      /* type of generic values assigned to the array members:
         A_NONE     - none (members have no assigned values)
         A_NUMERIC  - floating-point numbers
         A_SYMBOLIC - symbols
         A_ELEMSET  - elemental sets
         A_ELEMVAR  - elemental variables
         A_ELEMCON  - elemental constraints */
      int dim;
      /* dimension of the array that determines number of components in
         n-tuples for all members of the array, dim >= 0; dim = 0 means
         the array is 0-dimensional */
      int size;
      /* size of the array, i.e. number of its members */
      MEMBER *head;
      /* the first array member; NULL means the array is empty */
      MEMBER *tail;
      /* the last array member; NULL means the array is empty */
      AVL *tree;
      /* the search tree intended to find array members for logarithmic
         time; NULL means the search tree doesn't exist */
      ARRAY *prev;
      /* the previous array in the translator database */
      ARRAY *next;
      /* the next array in the translator database */
};

struct MEMBER
{     /* array member */
      TUPLE *tuple;
      /* n-tuple, which identifies the member; number of its components
         is the same for all members within the array and determined by
         the array dimension; duplicate members are not allowed */
      MEMBER *next;
      /* the next array member */
      VALUE value;
      /* generic value assigned to the member */
};

#define create_array _glp_mpl_create_array
ARRAY *create_array(MPL *mpl, int type, int dim);
/* create array */

#define find_member _glp_mpl_find_member
MEMBER *find_member
(     MPL *mpl,
      ARRAY *array,           /* not changed */
      TUPLE *tuple            /* not changed */
);
/* find array member with given n-tuple */

#define add_member _glp_mpl_add_member
MEMBER *add_member
(     MPL *mpl,
      ARRAY *array,           /* modified */
      TUPLE *tuple            /* destroyed */
);
/* add new member to array */

#define delete_array _glp_mpl_delete_array
void delete_array
(     MPL *mpl,
      ARRAY *array            /* destroyed */
);
/* delete array */

/**********************************************************************/
/* * *                 DOMAINS AND DUMMY INDICES                  * * */
/**********************************************************************/

struct DOMAIN
{     /* domain (a simple or compound set); syntactically domain looks
         like '{ i in I, (j,k) in S, t in T :  }'; domains
         are used to define sets, over which model objects are indexed,
         and also as constituents of iterated operators */
      DOMAIN_BLOCK *list;
      /* linked list of domain blocks (in the example above such blocks
         are 'i in I', '(j,k) in S', and 't in T'); this list cannot be
         empty */
      CODE *code;
      /* pseudo-code for computing the logical predicate, which follows
         the colon; NULL means no predicate is specified */
};

struct DOMAIN_BLOCK
{     /* domain block; syntactically domain blocks look like 'i in I',
         '(j,k) in S', and 't in T' in the example above (in the sequel
         sets like I, S, and T are called basic sets) */
      DOMAIN_SLOT *list;
      /* linked list of domain slots (i.e. indexing positions); number
         of slots in this list is the same as dimension of n-tuples in
         the basic set; this list cannot be empty */
      CODE *code;
      /* pseudo-code for computing basic set; cannot be NULL */
      TUPLE *backup;
      /* if this n-tuple is not empty, current values of dummy indices
         in the domain block are the same as components of this n-tuple
         (note that this n-tuple may have larger dimension than number
         of dummy indices in this block, in which case extra components
         are ignored); this n-tuple is used to restore former values of
         dummy indices, if they were changed due to recursive calls to
         the domain block */
      DOMAIN_BLOCK *next;
      /* the next block in the same domain */
};

struct DOMAIN_SLOT
{     /* domain slot; it specifies an individual indexing position and
         defines the corresponding dummy index */
      char *name;
      /* symbolic name of the dummy index; null pointer means the dummy
         index is not explicitly specified */
      CODE *code;
      /* pseudo-code for computing symbolic value, at which the dummy
         index is bound; NULL means the dummy index is free within the
         domain scope */
      SYMBOL *value;
      /* current value assigned to the dummy index; NULL means no value
         is assigned at the moment */
      CODE *list;
      /* linked list of pseudo-codes with operation O_INDEX referring
         to this slot; this linked list is used to invalidate resultant
         values of the operation, which depend on this dummy index */
      DOMAIN_SLOT *next;
      /* the next slot in the same domain block */
};

#define assign_dummy_index _glp_mpl_assign_dummy_index
void assign_dummy_index
(     MPL *mpl,
      DOMAIN_SLOT *slot,      /* modified */
      SYMBOL *value           /* not changed */
);
/* assign new value to dummy index */

#define update_dummy_indices _glp_mpl_update_dummy_indices
void update_dummy_indices
(     MPL *mpl,
      DOMAIN_BLOCK *block     /* not changed */
);
/* update current values of dummy indices */

#define enter_domain_block _glp_mpl_enter_domain_block
int enter_domain_block
(     MPL *mpl,
      DOMAIN_BLOCK *block,    /* not changed */
      TUPLE *tuple,           /* not changed */
      void *info, void (*func)(MPL *mpl, void *info)
);
/* enter domain block */

#define eval_within_domain _glp_mpl_eval_within_domain
int eval_within_domain
(     MPL *mpl,
      DOMAIN *domain,         /* not changed */
      TUPLE *tuple,           /* not changed */
      void *info, void (*func)(MPL *mpl, void *info)
);
/* perform evaluation within domain scope */

#define loop_within_domain _glp_mpl_loop_within_domain
void loop_within_domain
(     MPL *mpl,
      DOMAIN *domain,         /* not changed */
      void *info, int (*func)(MPL *mpl, void *info)
);
/* perform iterations within domain scope */

#define out_of_domain _glp_mpl_out_of_domain
void out_of_domain
(     MPL *mpl,
      char *name,             /* not changed */
      TUPLE *tuple            /* not changed */
);
/* raise domain exception */

#define get_domain_tuple _glp_mpl_get_domain_tuple
TUPLE *get_domain_tuple
(     MPL *mpl,
      DOMAIN *domain          /* not changed */
);
/* obtain current n-tuple from domain */

#define clean_domain _glp_mpl_clean_domain
void clean_domain(MPL *mpl, DOMAIN *domain);
/* clean domain */

/**********************************************************************/
/* * *                         MODEL SETS                         * * */
/**********************************************************************/

struct SET
{     /* model set */
      char *name;
      /* symbolic name; cannot be NULL */
      char *alias;
      /* alias; NULL means alias is not specified */
      int dim; /* aka arity */
      /* dimension (number of subscripts); dim = 0 means 0-dimensional
         (unsubscripted) set, dim > 0 means set of sets */
      DOMAIN *domain;
      /* subscript domain; NULL for 0-dimensional set */
      int dimen;
      /* dimension of n-tuples, which members of this set consist of
         (note that the model set itself is an array of elemental sets,
         which are its members; so, don't confuse this dimension with
         dimension of the model set); always non-zero */
      WITHIN *within;
      /* list of supersets, which restrict each member of the set to be
         in every superset from this list; this list can be empty */
      CODE *assign;
      /* pseudo-code for computing assigned value; can be NULL */
      CODE *option;
      /* pseudo-code for computing default value; can be NULL */
      GADGET *gadget;
      /* plain set used to initialize the array of sets; can be NULL */
      int data;
      /* data status flag:
         0 - no data are provided in the data section
         1 - data are provided, but not checked yet
         2 - data are provided and have been checked */
      ARRAY *array;
      /* array of members, which are assigned elemental sets */
};

struct WITHIN
{     /* restricting superset list entry */
      CODE *code;
      /* pseudo-code for computing the superset; cannot be NULL */
      WITHIN *next;
      /* the next entry for the same set or parameter */
};

struct GADGET
{     /* plain set used to initialize the array of sets with data */
      SET *set;
      /* pointer to plain set; cannot be NULL */
      int ind[20]; /* ind[dim+dimen]; */
      /* permutation of integers 1, 2, ..., dim+dimen */
};

#define check_elem_set _glp_mpl_check_elem_set
void check_elem_set
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple,           /* not changed */
      ELEMSET *refer          /* not changed */
);
/* check elemental set assigned to set member */

#define take_member_set _glp_mpl_take_member_set
ELEMSET *take_member_set      /* returns reference, not value */
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple            /* not changed */
);
/* obtain elemental set assigned to set member */

#define eval_member_set _glp_mpl_eval_member_set
ELEMSET *eval_member_set      /* returns reference, not value */
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple            /* not changed */
);
/* evaluate elemental set assigned to set member */

#define eval_whole_set _glp_mpl_eval_whole_set
void eval_whole_set(MPL *mpl, SET *set);
/* evaluate model set over entire domain */

#define clean_set _glp_mpl_clean_set
void clean_set(MPL *mpl, SET *set);
/* clean model set */

/**********************************************************************/
/* * *                      MODEL PARAMETERS                      * * */
/**********************************************************************/

struct PARAMETER
{     /* model parameter */
      char *name;
      /* symbolic name; cannot be NULL */
      char *alias;
      /* alias; NULL means alias is not specified */
      int dim; /* aka arity */
      /* dimension (number of subscripts); dim = 0 means 0-dimensional
         (unsubscripted) parameter */
      DOMAIN *domain;
      /* subscript domain; NULL for 0-dimensional parameter */
      int type;
      /* parameter type:
         A_NUMERIC  - numeric
         A_INTEGER  - integer
         A_BINARY   - binary
         A_SYMBOLIC - symbolic */
      CONDITION *cond;
      /* list of conditions, which restrict each parameter member to
         satisfy to every condition from this list; this list is used
         only for numeric parameters and can be empty */
      WITHIN *in;
      /* list of supersets, which restrict each parameter member to be
         in every superset from this list; this list is used only for
         symbolic parameters and can be empty */
      CODE *assign;
      /* pseudo-code for computing assigned value; can be NULL */
      CODE *option;
      /* pseudo-code for computing default value; can be NULL */
      int data;
      /* data status flag:
         0 - no data are provided in the data section
         1 - data are provided, but not checked yet
         2 - data are provided and have been checked */
      SYMBOL *defval;
      /* default value provided in the data section; can be NULL */
      ARRAY *array;
      /* array of members, which are assigned numbers or symbols */
};

struct CONDITION
{     /* restricting condition list entry */
      int rho;
      /* flag that specifies the form of the condition:
         O_LT - less than
         O_LE - less than or equal to
         O_EQ - equal to
         O_GE - greater than or equal to
         O_GT - greater than
         O_NE - not equal to */
      CODE *code;
      /* pseudo-code for computing the reference value */
      CONDITION *next;
      /* the next entry for the same parameter */
};

#define check_value_num _glp_mpl_check_value_num
void check_value_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple,           /* not changed */
      double value
);
/* check numeric value assigned to parameter member */

#define take_member_num _glp_mpl_take_member_num
double take_member_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
);
/* obtain numeric value assigned to parameter member */

#define eval_member_num _glp_mpl_eval_member_num
double eval_member_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
);
/* evaluate numeric value assigned to parameter member */

#define check_value_sym _glp_mpl_check_value_sym
void check_value_sym
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple,           /* not changed */
      SYMBOL *value           /* not changed */
);
/* check symbolic value assigned to parameter member */

#define take_member_sym _glp_mpl_take_member_sym
SYMBOL *take_member_sym       /* returns value, not reference */
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
);
/* obtain symbolic value assigned to parameter member */

#define eval_member_sym _glp_mpl_eval_member_sym
SYMBOL *eval_member_sym       /* returns value, not reference */
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
);
/* evaluate symbolic value assigned to parameter member */

#define eval_whole_par _glp_mpl_eval_whole_par
void eval_whole_par(MPL *mpl, PARAMETER *par);
/* evaluate model parameter over entire domain */

#define clean_parameter _glp_mpl_clean_parameter
void clean_parameter(MPL *mpl, PARAMETER *par);
/* clean model parameter */

/**********************************************************************/
/* * *                      MODEL VARIABLES                       * * */
/**********************************************************************/

struct VARIABLE
{     /* model variable */
      char *name;
      /* symbolic name; cannot be NULL */
      char *alias;
      /* alias; NULL means alias is not specified */
      int dim; /* aka arity */
      /* dimension (number of subscripts); dim = 0 means 0-dimensional
         (unsubscripted) variable */
      DOMAIN *domain;
      /* subscript domain; NULL for 0-dimensional variable */
      int type;
      /* variable type:
         A_NUMERIC - continuous
         A_INTEGER - integer
         A_BINARY  - binary */
      CODE *lbnd;
      /* pseudo-code for computing lower bound; NULL means lower bound
         is not specified */
      CODE *ubnd;
      /* pseudo-code for computing upper bound; NULL means upper bound
         is not specified */
      /* if both the pointers lbnd and ubnd refer to the same code, the
         variable is fixed at the corresponding value */
      ARRAY *array;
      /* array of members, which are assigned elemental variables */
};

#define take_member_var _glp_mpl_take_member_var
ELEMVAR *take_member_var      /* returns reference */
(     MPL *mpl,
      VARIABLE *var,          /* not changed */
      TUPLE *tuple            /* not changed */
);
/* obtain reference to elemental variable */

#define eval_member_var _glp_mpl_eval_member_var
ELEMVAR *eval_member_var      /* returns reference */
(     MPL *mpl,
      VARIABLE *var,          /* not changed */
      TUPLE *tuple            /* not changed */
);
/* evaluate reference to elemental variable */

#define eval_whole_var _glp_mpl_eval_whole_var
void eval_whole_var(MPL *mpl, VARIABLE *var);
/* evaluate model variable over entire domain */

#define clean_variable _glp_mpl_clean_variable
void clean_variable(MPL *mpl, VARIABLE *var);
/* clean model variable */

/**********************************************************************/
/* * *              MODEL CONSTRAINTS AND OBJECTIVES              * * */
/**********************************************************************/

struct CONSTRAINT
{     /* model constraint or objective */
      char *name;
      /* symbolic name; cannot be NULL */
      char *alias;
      /* alias; NULL means alias is not specified */
      int dim; /* aka arity */
      /* dimension (number of subscripts); dim = 0 means 0-dimensional
         (unsubscripted) constraint */
      DOMAIN *domain;
      /* subscript domain; NULL for 0-dimensional constraint */
      int type;
      /* constraint type:
         A_CONSTRAINT - constraint
         A_MINIMIZE   - objective (minimization)
         A_MAXIMIZE   - objective (maximization) */
      CODE *code;
      /* pseudo-code for computing main linear form; cannot be NULL */
      CODE *lbnd;
      /* pseudo-code for computing lower bound; NULL means lower bound
         is not specified */
      CODE *ubnd;
      /* pseudo-code for computing upper bound; NULL means upper bound
         is not specified */
      /* if both the pointers lbnd and ubnd refer to the same code, the
         constraint has the form of equation */
      ARRAY *array;
      /* array of members, which are assigned elemental constraints */
};

#define take_member_con _glp_mpl_take_member_con
ELEMCON *take_member_con      /* returns reference */
(     MPL *mpl,
      CONSTRAINT *con,        /* not changed */
      TUPLE *tuple            /* not changed */
);
/* obtain reference to elemental constraint */

#define eval_member_con _glp_mpl_eval_member_con
ELEMCON *eval_member_con      /* returns reference */
(     MPL *mpl,
      CONSTRAINT *con,        /* not changed */
      TUPLE *tuple            /* not changed */
);
/* evaluate reference to elemental constraint */

#define eval_whole_con _glp_mpl_eval_whole_con
void eval_whole_con(MPL *mpl, CONSTRAINT *con);
/* evaluate model constraint over entire domain */

#define clean_constraint _glp_mpl_clean_constraint
void clean_constraint(MPL *mpl, CONSTRAINT *con);
/* clean model constraint */

/**********************************************************************/
/* * *                        DATA TABLES                         * * */
/**********************************************************************/

struct TABLE
{     /* data table */
      char *name;
      /* symbolic name; cannot be NULL */
      char *alias;
      /* alias; NULL means alias is not specified */
      int type;
      /* table type:
         A_INPUT  - input table
         A_OUTPUT - output table */
      TABARG *arg;
      /* argument list; cannot be empty */
      union
      {  struct
         {  SET *set;
            /* input set; NULL means the set is not specified */
            TABFLD *fld;
            /* field list; cannot be empty */
            TABIN *list;
            /* input list; can be empty */
         } in;
         struct
         {  DOMAIN *domain;
            /* subscript domain; cannot be NULL */
            TABOUT *list;
            /* output list; cannot be empty */
         } out;
      } u;
};

struct TABARG
{     /* table argument list entry */
      CODE *code;
      /* pseudo-code for computing the argument */
      TABARG *next;
      /* next entry for the same table */
};

struct TABFLD
{     /* table field list entry */
      char *name;
      /* field name; cannot be NULL */
      TABFLD *next;
      /* next entry for the same table */
};

struct TABIN
{     /* table input list entry */
      PARAMETER *par;
      /* parameter to be read; cannot be NULL */
      char *name;
      /* column name; cannot be NULL */
      TABIN *next;
      /* next entry for the same table */
};

struct TABOUT
{     /* table output list entry */
      CODE *code;
      /* pseudo-code for computing the value to be written */
      char *name;
      /* column name; cannot be NULL */
      TABOUT *next;
      /* next entry for the same table */
};

struct TABDCA
{     /* table driver communication area */
      int id;
      /* driver identifier (set by mpl_tab_drv_open) */
      void *link;
      /* driver link pointer (set by mpl_tab_drv_open) */
      int na;
      /* number of arguments */
      char **arg; /* char *arg[1+ns]; */
      /* arg[k], 1 <= k <= ns, is pointer to k-th argument */
      int nf;
      /* number of fields */
      char **name; /* char *name[1+nc]; */
      /* name[k], 1 <= k <= nc, is name of k-th field */
      int *type; /* int type[1+nc]; */
      /* type[k], 1 <= k <= nc, is type of k-th field:
         '?' - value not assigned
         'N' - number
         'S' - character string */
      double *num; /* double num[1+nc]; */
      /* num[k], 1 <= k <= nc, is numeric value of k-th field */
      char **str;
      /* str[k], 1 <= k <= nc, is string value of k-th field */
};

#define mpl_tab_num_args _glp_mpl_tab_num_args
int mpl_tab_num_args(TABDCA *dca);

#define mpl_tab_get_arg _glp_mpl_tab_get_arg
const char *mpl_tab_get_arg(TABDCA *dca, int k);

#define mpl_tab_num_flds _glp_mpl_tab_num_flds
int mpl_tab_num_flds(TABDCA *dca);

#define mpl_tab_get_name _glp_mpl_tab_get_name
const char *mpl_tab_get_name(TABDCA *dca, int k);

#define mpl_tab_get_type _glp_mpl_tab_get_type
int mpl_tab_get_type(TABDCA *dca, int k);

#define mpl_tab_get_num _glp_mpl_tab_get_num
double mpl_tab_get_num(TABDCA *dca, int k);

#define mpl_tab_get_str _glp_mpl_tab_get_str
const char *mpl_tab_get_str(TABDCA *dca, int k);

#define mpl_tab_set_num _glp_mpl_tab_set_num
void mpl_tab_set_num(TABDCA *dca, int k, double num);

#define mpl_tab_set_str _glp_mpl_tab_set_str
void mpl_tab_set_str(TABDCA *dca, int k, const char *str);

#define mpl_tab_drv_open _glp_mpl_tab_drv_open
void mpl_tab_drv_open(MPL *mpl, int mode);

#define mpl_tab_drv_read _glp_mpl_tab_drv_read
int mpl_tab_drv_read(MPL *mpl);

#define mpl_tab_drv_write _glp_mpl_tab_drv_write
void mpl_tab_drv_write(MPL *mpl);

#define mpl_tab_drv_close _glp_mpl_tab_drv_close
void mpl_tab_drv_close(MPL *mpl);

/**********************************************************************/
/* * *                        PSEUDO-CODE                         * * */
/**********************************************************************/

union OPERANDS
{     /* operands that participate in pseudo-code operation (choice of
         particular operands depends on the operation code) */
      /*--------------------------------------------------------------*/
      double num;             /* O_NUMBER */
      /* floaing-point number to be taken */
      /*--------------------------------------------------------------*/
      char *str;              /* O_STRING */
      /* character string to be taken */
      /*--------------------------------------------------------------*/
      struct                  /* O_INDEX */
      {  DOMAIN_SLOT *slot;
         /* domain slot, which contains dummy index to be taken */
         CODE *next;
         /* the next pseudo-code with op = O_INDEX, which refers to the
            same slot as this one; pointer to the beginning of this list
            is stored in the corresponding domain slot */
      } index;
      /*--------------------------------------------------------------*/
      struct                  /* O_MEMNUM, O_MEMSYM */
      {  PARAMETER *par;
         /* model parameter, which contains member to be taken */
         ARG_LIST *list;
         /* list of subscripts; NULL for 0-dimensional parameter */
      } par;
      /*--------------------------------------------------------------*/
      struct                  /* O_MEMSET */
      {  SET *set;
         /* model set, which contains member to be taken */
         ARG_LIST *list;
         /* list of subscripts; NULL for 0-dimensional set */
      } set;
      /*--------------------------------------------------------------*/
      struct                  /* O_MEMVAR */
      {  VARIABLE *var;
         /* model variable, which contains member to be taken */
         ARG_LIST *list;
         /* list of subscripts; NULL for 0-dimensional variable */
#if 1 /* 15/V-2010 */
         int suff;
         /* suffix specified: */
#define DOT_NONE        0x00  /* none     (means variable itself) */
#define DOT_LB          0x01  /* .lb      (lower bound) */
#define DOT_UB          0x02  /* .ub      (upper bound) */
#define DOT_STATUS      0x03  /* .status  (status) */
#define DOT_VAL         0x04  /* .val     (primal value) */
#define DOT_DUAL        0x05  /* .dual    (dual value) */
#endif
      } var;
#if 1 /* 15/V-2010 */
      /*--------------------------------------------------------------*/
      struct                  /* O_MEMCON */
      {  CONSTRAINT *con;
         /* model constraint, which contains member to be taken */
         ARG_LIST *list;
         /* list of subscripys; NULL for 0-dimensional constraint */
         int suff;
         /* suffix specified (see O_MEMVAR above) */
      } con;
#endif
      /*--------------------------------------------------------------*/
      ARG_LIST *list;         /* O_TUPLE, O_MAKE, n-ary operations */
      /* list of operands */
      /*--------------------------------------------------------------*/
      DOMAIN_BLOCK *slice;    /* O_SLICE */
      /* domain block, which specifies slice (i.e. n-tuple that contains
         free dummy indices); this operation is never evaluated */
      /*--------------------------------------------------------------*/
      struct                  /* unary, binary, ternary operations */
      {  CODE *x;
         /* pseudo-code for computing first operand */
         CODE *y;
         /* pseudo-code for computing second operand */
         CODE *z;
         /* pseudo-code for computing third operand */
      } arg;
      /*--------------------------------------------------------------*/
      struct                  /* iterated operations */
      {  DOMAIN *domain;
         /* domain, over which the operation is performed */
         CODE *x;
         /* pseudo-code for computing "integrand" */
      } loop;
      /*--------------------------------------------------------------*/
};

struct ARG_LIST
{     /* operands list entry */
      CODE *x;
      /* pseudo-code for computing operand */
      ARG_LIST *next;
      /* the next operand of the same operation */
};

struct CODE
{     /* pseudo-code (internal form of expressions) */
      int op;
      /* operation code: */
#define O_NUMBER        301   /* take floating-point number */
#define O_STRING        302   /* take character string */
#define O_INDEX         303   /* take dummy index */
#define O_MEMNUM        304   /* take member of numeric parameter */
#define O_MEMSYM        305   /* take member of symbolic parameter */
#define O_MEMSET        306   /* take member of set */
#define O_MEMVAR        307   /* take member of variable */
#define O_MEMCON        308   /* take member of constraint */
#define O_TUPLE         309   /* make n-tuple */
#define O_MAKE          310   /* make elemental set of n-tuples */
#define O_SLICE         311   /* define domain block (dummy op) */
                              /* 0-ary operations --------------------*/
#define O_IRAND224      312   /* pseudo-random in [0, 2^24-1] */
#define O_UNIFORM01     313   /* pseudo-random in [0, 1) */
#define O_NORMAL01      314   /* gaussian random, mu = 0, sigma = 1 */
#define O_GMTIME        315   /* current calendar time (UTC) */
                              /* unary operations --------------------*/
#define O_CVTNUM        316   /* conversion to numeric */
#define O_CVTSYM        317   /* conversion to symbolic */
#define O_CVTLOG        318   /* conversion to logical */
#define O_CVTTUP        319   /* conversion to 1-tuple */
#define O_CVTLFM        320   /* conversion to linear form */
#define O_PLUS          321   /* unary plus */
#define O_MINUS         322   /* unary minus */
#define O_NOT           323   /* negation (logical "not") */
#define O_ABS           324   /* absolute value */
#define O_CEIL          325   /* round upward ("ceiling of x") */
#define O_FLOOR         326   /* round downward ("floor of x") */
#define O_EXP           327   /* base-e exponential */
#define O_LOG           328   /* natural logarithm */
#define O_LOG10         329   /* common (decimal) logarithm */
#define O_SQRT          330   /* square root */
#define O_SIN           331   /* trigonometric sine */
#define O_COS           332   /* trigonometric cosine */
#define O_TAN           333   /* trigonometric tangent */
#define O_ATAN          334   /* trigonometric arctangent */
#define O_ROUND         335   /* round to nearest integer */
#define O_TRUNC         336   /* truncate to nearest integer */
#define O_CARD          337   /* cardinality of set */
#define O_LENGTH        338   /* length of symbolic value */
                              /* binary operations -------------------*/
#define O_ADD           339   /* addition */
#define O_SUB           340   /* subtraction */
#define O_LESS          341   /* non-negative subtraction */
#define O_MUL           342   /* multiplication */
#define O_DIV           343   /* division */
#define O_IDIV          344   /* quotient of exact division */
#define O_MOD           345   /* remainder of exact division */
#define O_POWER         346   /* exponentiation (raise to power) */
#define O_ATAN2         347   /* trigonometric arctangent */
#define O_ROUND2        348   /* round to n fractional digits */
#define O_TRUNC2        349   /* truncate to n fractional digits */
#define O_UNIFORM       350   /* pseudo-random in [a, b) */
#define O_NORMAL        351   /* gaussian random, given mu and sigma */
#define O_CONCAT        352   /* concatenation */
#define O_LT            353   /* comparison on 'less than' */
#define O_LE            354   /* comparison on 'not greater than' */
#define O_EQ            355   /* comparison on 'equal to' */
#define O_GE            356   /* comparison on 'not less than' */
#define O_GT            357   /* comparison on 'greater than' */
#define O_NE            358   /* comparison on 'not equal to' */
#define O_AND           359   /* conjunction (logical "and") */
#define O_OR            360   /* disjunction (logical "or") */
#define O_UNION         361   /* union */
#define O_DIFF          362   /* difference */
#define O_SYMDIFF       363   /* symmetric difference */
#define O_INTER         364   /* intersection */
#define O_CROSS         365   /* cross (Cartesian) product */
#define O_IN            366   /* test on 'x in Y' */
#define O_NOTIN         367   /* test on 'x not in Y' */
#define O_WITHIN        368   /* test on 'X within Y' */
#define O_NOTWITHIN     369   /* test on 'X not within Y' */
#define O_SUBSTR        370   /* substring */
#define O_STR2TIME      371   /* convert string to time */
#define O_TIME2STR      372   /* convert time to string */
                              /* ternary operations ------------------*/
#define O_DOTS          373   /* build "arithmetic" set */
#define O_FORK          374   /* if-then-else */
#define O_SUBSTR3       375   /* substring */
                              /* n-ary operations --------------------*/
#define O_MIN           376   /* minimal value (n-ary) */
#define O_MAX           377   /* maximal value (n-ary) */
                              /* iterated operations -----------------*/
#define O_SUM           378   /* summation */
#define O_PROD          379   /* multiplication */
#define O_MINIMUM       380   /* minimum */
#define O_MAXIMUM       381   /* maximum */
#define O_FORALL        382   /* conjunction (A-quantification) */
#define O_EXISTS        383   /* disjunction (E-quantification) */
#define O_SETOF         384   /* compute elemental set */
#define O_BUILD         385   /* build elemental set */
      OPERANDS arg;
      /* operands that participate in the operation */
      int type;
      /* type of the resultant value:
         A_NUMERIC  - numeric
         A_SYMBOLIC - symbolic
         A_LOGICAL  - logical
         A_TUPLE    - n-tuple
         A_ELEMSET  - elemental set
         A_FORMULA  - linear form */
      int dim;
      /* dimension of the resultant value; for A_TUPLE and A_ELEMSET it
         is the dimension of the corresponding n-tuple(s) and cannot be
         zero; for other resultant types it is always zero */
      CODE *up;
      /* parent pseudo-code, which refers to this pseudo-code as to its
         operand; NULL means this pseudo-code has no parent and defines
         an expression, which is not contained in another expression */
      int vflag;
      /* volatile flag; being set this flag means that this operation
         has a side effect; for primary expressions this flag is set
         directly by corresponding parsing routines (for example, if
         primary expression is a reference to a function that generates
         pseudo-random numbers); in other cases this flag is inherited
         from operands */
      int valid;
      /* if this flag is set, the resultant value, which is a temporary
         result of evaluating this operation on particular values of
         operands, is valid; if this flag is clear, the resultant value
         doesn't exist and therefore not valid; having been evaluated
         the resultant value is stored here and not destroyed until the
         dummy indices, which this value depends on, have been changed
         (and if it doesn't depend on dummy indices at all, it is never
         destroyed); thus, if the resultant value is valid, evaluating
         routine can immediately take its copy not computing the result
         from scratch; this mechanism is similar to moving invariants
         out of loops and allows improving efficiency at the expense of
         some extra memory needed to keep temporary results */
      /* however, if the volatile flag (see above) is set, even if the
         resultant value is valid, evaluating routine computes it as if
         it were not valid, i.e. caching is not used in this case */
      VALUE value;
      /* resultant value in generic format */
};

#define eval_numeric _glp_mpl_eval_numeric
double eval_numeric(MPL *mpl, CODE *code);
/* evaluate pseudo-code to determine numeric value */

#define eval_symbolic _glp_mpl_eval_symbolic
SYMBOL *eval_symbolic(MPL *mpl, CODE *code);
/* evaluate pseudo-code to determine symbolic value */

#define eval_logical _glp_mpl_eval_logical
int eval_logical(MPL *mpl, CODE *code);
/* evaluate pseudo-code to determine logical value */

#define eval_tuple _glp_mpl_eval_tuple
TUPLE *eval_tuple(MPL *mpl, CODE *code);
/* evaluate pseudo-code to construct n-tuple */

#define eval_elemset _glp_mpl_eval_elemset
ELEMSET *eval_elemset(MPL *mpl, CODE *code);
/* evaluate pseudo-code to construct elemental set */

#define is_member _glp_mpl_is_member
int is_member(MPL *mpl, CODE *code, TUPLE *tuple);
/* check if n-tuple is in set specified by pseudo-code */

#define eval_formula _glp_mpl_eval_formula
FORMULA *eval_formula(MPL *mpl, CODE *code);
/* evaluate pseudo-code to construct linear form */

#define clean_code _glp_mpl_clean_code
void clean_code(MPL *mpl, CODE *code);
/* clean pseudo-code */

/**********************************************************************/
/* * *                      MODEL STATEMENTS                      * * */
/**********************************************************************/

struct CHECK
{     /* check statement */
      DOMAIN *domain;
      /* subscript domain; NULL means domain is not used */
      CODE *code;
      /* code for computing the predicate to be checked */
};

struct DISPLAY
{     /* display statement */
      DOMAIN *domain;
      /* subscript domain; NULL means domain is not used */
      DISPLAY1 *list;
      /* display list; cannot be empty */
};

struct DISPLAY1
{     /* display list entry */
      int type;
      /* item type:
         A_INDEX      - dummy index
         A_SET        - model set
         A_PARAMETER  - model parameter
         A_VARIABLE   - model variable
         A_CONSTRAINT - model constraint/objective
         A_EXPRESSION - expression */
      union
      {  DOMAIN_SLOT *slot;
         SET *set;
         PARAMETER *par;
         VARIABLE *var;
         CONSTRAINT *con;
         CODE *code;
      } u;
      /* item to be displayed */
#if 0 /* 15/V-2010 */
      ARG_LIST *list;
      /* optional subscript list (for constraint/objective only) */
#endif
      DISPLAY1 *next;
      /* the next entry for the same statement */
};

struct PRINTF
{     /* printf statement */
      DOMAIN *domain;
      /* subscript domain; NULL means domain is not used */
      CODE *fmt;
      /* pseudo-code for computing format string */
      PRINTF1 *list;
      /* printf list; can be empty */
      CODE *fname;
      /* pseudo-code for computing filename to redirect the output;
         NULL means the output goes to stdout */
      int app;
      /* if this flag is set, the output is appended */
};

struct PRINTF1
{     /* printf list entry */
      CODE *code;
      /* pseudo-code for computing value to be printed */
      PRINTF1 *next;
      /* the next entry for the same statement */
};

struct FOR
{     /* for statement */
      DOMAIN *domain;
      /* subscript domain; cannot be NULL */
      STATEMENT *list;
      /* linked list of model statements within this for statement in
         the original order */
};

struct STATEMENT
{     /* model statement */
      int line;
      /* number of source text line, where statement begins */
      int type;
      /* statement type:
         A_SET        - set statement
         A_PARAMETER  - parameter statement
         A_VARIABLE   - variable statement
         A_CONSTRAINT - constraint/objective statement
         A_TABLE      - table statement
         A_SOLVE      - solve statement
         A_CHECK      - check statement
         A_DISPLAY    - display statement
         A_PRINTF     - printf statement
         A_FOR        - for statement */
      union
      {  SET *set;
         PARAMETER *par;
         VARIABLE *var;
         CONSTRAINT *con;
         TABLE *tab;
         void *slv; /* currently not used (set to NULL) */
         CHECK *chk;
         DISPLAY *dpy;
         PRINTF *prt;
         FOR *fur;
      } u;
      /* specific part of statement */
      STATEMENT *next;
      /* the next statement; in this list statements follow in the same
         order as they appear in the model section */
};

#define execute_table _glp_mpl_execute_table
void execute_table(MPL *mpl, TABLE *tab);
/* execute table statement */

#define free_dca _glp_mpl_free_dca
void free_dca(MPL *mpl);
/* free table driver communucation area */

#define clean_table _glp_mpl_clean_table
void clean_table(MPL *mpl, TABLE *tab);
/* clean table statement */

#define execute_check _glp_mpl_execute_check
void execute_check(MPL *mpl, CHECK *chk);
/* execute check statement */

#define clean_check _glp_mpl_clean_check
void clean_check(MPL *mpl, CHECK *chk);
/* clean check statement */

#define execute_display _glp_mpl_execute_display
void execute_display(MPL *mpl, DISPLAY *dpy);
/* execute display statement */

#define clean_display _glp_mpl_clean_display
void clean_display(MPL *mpl, DISPLAY *dpy);
/* clean display statement */

#define execute_printf _glp_mpl_execute_printf
void execute_printf(MPL *mpl, PRINTF *prt);
/* execute printf statement */

#define clean_printf _glp_mpl_clean_printf
void clean_printf(MPL *mpl, PRINTF *prt);
/* clean printf statement */

#define execute_for _glp_mpl_execute_for
void execute_for(MPL *mpl, FOR *fur);
/* execute for statement */

#define clean_for _glp_mpl_clean_for
void clean_for(MPL *mpl, FOR *fur);
/* clean for statement */

#define execute_statement _glp_mpl_execute_statement
void execute_statement(MPL *mpl, STATEMENT *stmt);
/* execute specified model statement */

#define clean_statement _glp_mpl_clean_statement
void clean_statement(MPL *mpl, STATEMENT *stmt);
/* clean specified model statement */

/**********************************************************************/
/* * *              GENERATING AND POSTSOLVING MODEL              * * */
/**********************************************************************/

#define alloc_content _glp_mpl_alloc_content
void alloc_content(MPL *mpl);
/* allocate content arrays for all model objects */

#define generate_model _glp_mpl_generate_model
void generate_model(MPL *mpl);
/* generate model */

#define build_problem _glp_mpl_build_problem
void build_problem(MPL *mpl);
/* build problem instance */

#define postsolve_model _glp_mpl_postsolve_model
void postsolve_model(MPL *mpl);
/* postsolve model */

#define clean_model _glp_mpl_clean_model
void clean_model(MPL *mpl);
/* clean model content */

/**********************************************************************/
/* * *                        INPUT/OUTPUT                        * * */
/**********************************************************************/

#define open_input _glp_mpl_open_input
void open_input(MPL *mpl, char *file);
/* open input text file */

#define read_char _glp_mpl_read_char
int read_char(MPL *mpl);
/* read next character from input text file */

#define close_input _glp_mpl_close_input
void close_input(MPL *mpl);
/* close input text file */

#define open_output _glp_mpl_open_output
void open_output(MPL *mpl, char *file);
/* open output text file */

#define write_char _glp_mpl_write_char
void write_char(MPL *mpl, int c);
/* write next character to output text file */

#define write_text _glp_mpl_write_text
void write_text(MPL *mpl, char *fmt, ...);
/* format and write text to output text file */

#define flush_output _glp_mpl_flush_output
void flush_output(MPL *mpl);
/* finalize writing data to output text file */

/**********************************************************************/
/* * *                      SOLVER INTERFACE                      * * */
/**********************************************************************/

#define MPL_FR          401   /* free (unbounded) */
#define MPL_LO          402   /* lower bound */
#define MPL_UP          403   /* upper bound */
#define MPL_DB          404   /* both lower and upper bounds */
#define MPL_FX          405   /* fixed */

#define MPL_ST          411   /* constraint */
#define MPL_MIN         412   /* objective (minimization) */
#define MPL_MAX         413   /* objective (maximization) */

#define MPL_NUM         421   /* continuous */
#define MPL_INT         422   /* integer */
#define MPL_BIN         423   /* binary */

#define error _glp_mpl_error
void error(MPL *mpl, char *fmt, ...);
/* print error message and terminate model processing */

#define warning _glp_mpl_warning
void warning(MPL *mpl, char *fmt, ...);
/* print warning message and continue model processing */

#define mpl_initialize _glp_mpl_initialize
MPL *mpl_initialize(void);
/* create and initialize translator database */

#define mpl_read_model _glp_mpl_read_model
int mpl_read_model(MPL *mpl, char *file, int skip_data);
/* read model section and optional data section */

#define mpl_read_data _glp_mpl_read_data
int mpl_read_data(MPL *mpl, char *file);
/* read data section */

#define mpl_generate _glp_mpl_generate
int mpl_generate(MPL *mpl, char *file);
/* generate model */

#define mpl_get_prob_name _glp_mpl_get_prob_name
char *mpl_get_prob_name(MPL *mpl);
/* obtain problem (model) name */

#define mpl_get_num_rows _glp_mpl_get_num_rows
int mpl_get_num_rows(MPL *mpl);
/* determine number of rows */

#define mpl_get_num_cols _glp_mpl_get_num_cols
int mpl_get_num_cols(MPL *mpl);
/* determine number of columns */

#define mpl_get_row_name _glp_mpl_get_row_name
char *mpl_get_row_name(MPL *mpl, int i);
/* obtain row name */

#define mpl_get_row_kind _glp_mpl_get_row_kind
int mpl_get_row_kind(MPL *mpl, int i);
/* determine row kind */

#define mpl_get_row_bnds _glp_mpl_get_row_bnds
int mpl_get_row_bnds(MPL *mpl, int i, double *lb, double *ub);
/* obtain row bounds */

#define mpl_get_mat_row _glp_mpl_get_mat_row
int mpl_get_mat_row(MPL *mpl, int i, int ndx[], double val[]);
/* obtain row of the constraint matrix */

#define mpl_get_row_c0 _glp_mpl_get_row_c0
double mpl_get_row_c0(MPL *mpl, int i);
/* obtain constant term of free row */

#define mpl_get_col_name _glp_mpl_get_col_name
char *mpl_get_col_name(MPL *mpl, int j);
/* obtain column name */

#define mpl_get_col_kind _glp_mpl_get_col_kind
int mpl_get_col_kind(MPL *mpl, int j);
/* determine column kind */

#define mpl_get_col_bnds _glp_mpl_get_col_bnds
int mpl_get_col_bnds(MPL *mpl, int j, double *lb, double *ub);
/* obtain column bounds */

#define mpl_has_solve_stmt _glp_mpl_has_solve_stmt
int mpl_has_solve_stmt(MPL *mpl);
/* check if model has solve statement */

#if 1 /* 15/V-2010 */
#define mpl_put_row_soln _glp_mpl_put_row_soln
void mpl_put_row_soln(MPL *mpl, int i, int stat, double prim,
      double dual);
/* store row (constraint/objective) solution components */
#endif

#if 1 /* 15/V-2010 */
#define mpl_put_col_soln _glp_mpl_put_col_soln
void mpl_put_col_soln(MPL *mpl, int j, int stat, double prim,
      double dual);
/* store column (variable) solution components */
#endif

#if 0 /* 15/V-2010 */
#define mpl_put_col_value _glp_mpl_put_col_value
void mpl_put_col_value(MPL *mpl, int j, double val);
/* store column value */
#endif

#define mpl_postsolve _glp_mpl_postsolve
int mpl_postsolve(MPL *mpl);
/* postsolve model */

#define mpl_terminate _glp_mpl_terminate
void mpl_terminate(MPL *mpl);
/* free all resources used by translator */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl1.c0000644000175100001710000052677700000000000023741 0ustar00runnerdocker00000000000000/* mpl1.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"

#define dmp_get_atomv dmp_get_atom

/**********************************************************************/
/* * *                  PROCESSING MODEL SECTION                  * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- enter_context - enter current token into context queue.
--
-- This routine enters the current token into the context queue. */

void enter_context(MPL *mpl)
{     char *image, *s;
      if (mpl->token == T_EOF)
         image = "_|_";
      else if (mpl->token == T_STRING)
         image = "'...'";
      else
         image = mpl->image;
      xassert(0 <= mpl->c_ptr && mpl->c_ptr < CONTEXT_SIZE);
      mpl->context[mpl->c_ptr++] = ' ';
      if (mpl->c_ptr == CONTEXT_SIZE) mpl->c_ptr = 0;
      for (s = image; *s != '\0'; s++)
      {  mpl->context[mpl->c_ptr++] = *s;
         if (mpl->c_ptr == CONTEXT_SIZE) mpl->c_ptr = 0;
      }
      return;
}

/*----------------------------------------------------------------------
-- print_context - print current content of context queue.
--
-- This routine prints current content of the context queue. */

void print_context(MPL *mpl)
{     int c;
      while (mpl->c_ptr > 0)
      {  mpl->c_ptr--;
         c = mpl->context[0];
         memmove(mpl->context, mpl->context+1, CONTEXT_SIZE-1);
         mpl->context[CONTEXT_SIZE-1] = (char)c;
      }
      xprintf("Context: %s%.*s\n", mpl->context[0] == ' ' ? "" : "...",
         CONTEXT_SIZE, mpl->context);
      return;
}

/*----------------------------------------------------------------------
-- get_char - scan next character from input text file.
--
-- This routine scans a next ASCII character from the input text file.
-- In case of end-of-file, the character is assigned EOF. */

void get_char(MPL *mpl)
{     int c;
      if (mpl->c == EOF) goto done;
      if (mpl->c == '\n') mpl->line++;
      c = read_char(mpl);
      if (c == EOF)
      {  if (mpl->c == '\n')
            mpl->line--;
         else
            warning(mpl, "final NL missing before end of file");
      }
      else if (c == '\n')
         ;
      else if (isspace(c))
         c = ' ';
      else if (iscntrl(c))
      {  enter_context(mpl);
         error(mpl, "control character 0x%02X not allowed", c);
      }
      mpl->c = c;
done: return;
}

/*----------------------------------------------------------------------
-- append_char - append character to current token.
--
-- This routine appends the current character to the current token and
-- then scans a next character. */

void append_char(MPL *mpl)
{     xassert(0 <= mpl->imlen && mpl->imlen <= MAX_LENGTH);
      if (mpl->imlen == MAX_LENGTH)
      {  switch (mpl->token)
         {  case T_NAME:
               enter_context(mpl);
               error(mpl, "symbolic name %s... too long", mpl->image);
            case T_SYMBOL:
               enter_context(mpl);
               error(mpl, "symbol %s... too long", mpl->image);
            case T_NUMBER:
               enter_context(mpl);
               error(mpl, "numeric literal %s... too long", mpl->image);
            case T_STRING:
               enter_context(mpl);
               error(mpl, "string literal too long");
            default:
               xassert(mpl != mpl);
         }
      }
      mpl->image[mpl->imlen++] = (char)mpl->c;
      mpl->image[mpl->imlen] = '\0';
      get_char(mpl);
      return;
}

/*----------------------------------------------------------------------
-- get_token - scan next token from input text file.
--
-- This routine scans a next token from the input text file using the
-- standard finite automation technique. */

void get_token(MPL *mpl)
{     /* save the current token */
      mpl->b_token = mpl->token;
      mpl->b_imlen = mpl->imlen;
      strcpy(mpl->b_image, mpl->image);
      mpl->b_value = mpl->value;
      /* if the next token is already scanned, make it current */
      if (mpl->f_scan)
      {  mpl->f_scan = 0;
         mpl->token = mpl->f_token;
         mpl->imlen = mpl->f_imlen;
         strcpy(mpl->image, mpl->f_image);
         mpl->value = mpl->f_value;
         goto done;
      }
loop: /* nothing has been scanned so far */
      mpl->token = 0;
      mpl->imlen = 0;
      mpl->image[0] = '\0';
      mpl->value = 0.0;
      /* skip any uninteresting characters */
      while (mpl->c == ' ' || mpl->c == '\n') get_char(mpl);
      /* recognize and construct the token */
      if (mpl->c == EOF)
      {  /* end-of-file reached */
         mpl->token = T_EOF;
      }
      else if (mpl->c == '#')
      {  /* comment; skip anything until end-of-line */
         while (mpl->c != '\n' && mpl->c != EOF) get_char(mpl);
         goto loop;
      }
      else if (!mpl->flag_d && (isalpha(mpl->c) || mpl->c == '_'))
      {  /* symbolic name or reserved keyword */
         mpl->token = T_NAME;
         while (isalnum(mpl->c) || mpl->c == '_') append_char(mpl);
         if (strcmp(mpl->image, "and") == 0)
            mpl->token = T_AND;
         else if (strcmp(mpl->image, "by") == 0)
            mpl->token = T_BY;
         else if (strcmp(mpl->image, "cross") == 0)
            mpl->token = T_CROSS;
         else if (strcmp(mpl->image, "diff") == 0)
            mpl->token = T_DIFF;
         else if (strcmp(mpl->image, "div") == 0)
            mpl->token = T_DIV;
         else if (strcmp(mpl->image, "else") == 0)
            mpl->token = T_ELSE;
         else if (strcmp(mpl->image, "if") == 0)
            mpl->token = T_IF;
         else if (strcmp(mpl->image, "in") == 0)
            mpl->token = T_IN;
#if 1 /* 21/VII-2006 */
         else if (strcmp(mpl->image, "Infinity") == 0)
            mpl->token = T_INFINITY;
#endif
         else if (strcmp(mpl->image, "inter") == 0)
            mpl->token = T_INTER;
         else if (strcmp(mpl->image, "less") == 0)
            mpl->token = T_LESS;
         else if (strcmp(mpl->image, "mod") == 0)
            mpl->token = T_MOD;
         else if (strcmp(mpl->image, "not") == 0)
            mpl->token = T_NOT;
         else if (strcmp(mpl->image, "or") == 0)
            mpl->token = T_OR;
         else if (strcmp(mpl->image, "s") == 0 && mpl->c == '.')
         {  mpl->token = T_SPTP;
            append_char(mpl);
            if (mpl->c != 't')
sptp:       {  enter_context(mpl);
               error(mpl, "keyword s.t. incomplete");
            }
            append_char(mpl);
            if (mpl->c != '.') goto sptp;
            append_char(mpl);
         }
         else if (strcmp(mpl->image, "symdiff") == 0)
            mpl->token = T_SYMDIFF;
         else if (strcmp(mpl->image, "then") == 0)
            mpl->token = T_THEN;
         else if (strcmp(mpl->image, "union") == 0)
            mpl->token = T_UNION;
         else if (strcmp(mpl->image, "within") == 0)
            mpl->token = T_WITHIN;
      }
      else if (!mpl->flag_d && isdigit(mpl->c))
      {  /* numeric literal */
         mpl->token = T_NUMBER;
         /* scan integer part */
         while (isdigit(mpl->c)) append_char(mpl);
         /* scan optional fractional part */
         if (mpl->c == '.')
         {  append_char(mpl);
            if (mpl->c == '.')
            {  /* hmm, it is not the fractional part, it is dots that
                  follow the integer part */
               mpl->imlen--;
               mpl->image[mpl->imlen] = '\0';
               mpl->f_dots = 1;
               goto conv;
            }
frac:       while (isdigit(mpl->c)) append_char(mpl);
         }
         /* scan optional decimal exponent */
         if (mpl->c == 'e' || mpl->c == 'E')
         {  append_char(mpl);
            if (mpl->c == '+' || mpl->c == '-') append_char(mpl);
            if (!isdigit(mpl->c))
            {  enter_context(mpl);
               error(mpl, "numeric literal %s incomplete", mpl->image);
            }
            while (isdigit(mpl->c)) append_char(mpl);
         }
         /* there must be no letter following the numeric literal */
         if (isalpha(mpl->c) || mpl->c == '_')
         {  enter_context(mpl);
            error(mpl, "symbol %s%c... should be enclosed in quotes",
               mpl->image, mpl->c);
         }
conv:    /* convert numeric literal to floating-point */
         if (str2num(mpl->image, &mpl->value))
err:     {  enter_context(mpl);
            error(mpl, "cannot convert numeric literal %s to floating-p"
               "oint number", mpl->image);
         }
      }
      else if (mpl->c == '\'' || mpl->c == '"')
      {  /* character string */
         int quote = mpl->c;
         mpl->token = T_STRING;
         get_char(mpl);
         for (;;)
         {  if (mpl->c == '\n' || mpl->c == EOF)
            {  enter_context(mpl);
               error(mpl, "unexpected end of line; string literal incom"
                  "plete");
            }
            if (mpl->c == quote)
            {  get_char(mpl);
               if (mpl->c != quote) break;
            }
            append_char(mpl);
         }
      }
      else if (!mpl->flag_d && mpl->c == '+')
         mpl->token = T_PLUS, append_char(mpl);
      else if (!mpl->flag_d && mpl->c == '-')
         mpl->token = T_MINUS, append_char(mpl);
      else if (mpl->c == '*')
      {  mpl->token = T_ASTERISK, append_char(mpl);
         if (mpl->c == '*')
            mpl->token = T_POWER, append_char(mpl);
      }
      else if (mpl->c == '/')
      {  mpl->token = T_SLASH, append_char(mpl);
         if (mpl->c == '*')
         {  /* comment sequence */
            get_char(mpl);
            for (;;)
            {  if (mpl->c == EOF)
               {  /* do not call enter_context at this point */
                  error(mpl, "unexpected end of file; comment sequence "
                     "incomplete");
               }
               else if (mpl->c == '*')
               {  get_char(mpl);
                  if (mpl->c == '/') break;
               }
               else
                  get_char(mpl);
            }
            get_char(mpl);
            goto loop;
         }
      }
      else if (mpl->c == '^')
         mpl->token = T_POWER, append_char(mpl);
      else if (mpl->c == '<')
      {  mpl->token = T_LT, append_char(mpl);
         if (mpl->c == '=')
            mpl->token = T_LE, append_char(mpl);
         else if (mpl->c == '>')
            mpl->token = T_NE, append_char(mpl);
#if 1 /* 11/II-2008 */
         else if (mpl->c == '-')
            mpl->token = T_INPUT, append_char(mpl);
#endif
      }
      else if (mpl->c == '=')
      {  mpl->token = T_EQ, append_char(mpl);
         if (mpl->c == '=') append_char(mpl);
      }
      else if (mpl->c == '>')
      {  mpl->token = T_GT, append_char(mpl);
         if (mpl->c == '=')
            mpl->token = T_GE, append_char(mpl);
#if 1 /* 14/VII-2006 */
         else if (mpl->c == '>')
            mpl->token = T_APPEND, append_char(mpl);
#endif
      }
      else if (mpl->c == '!')
      {  mpl->token = T_NOT, append_char(mpl);
         if (mpl->c == '=')
            mpl->token = T_NE, append_char(mpl);
      }
      else if (mpl->c == '&')
      {  mpl->token = T_CONCAT, append_char(mpl);
         if (mpl->c == '&')
            mpl->token = T_AND, append_char(mpl);
      }
      else if (mpl->c == '|')
      {  mpl->token = T_BAR, append_char(mpl);
         if (mpl->c == '|')
            mpl->token = T_OR, append_char(mpl);
      }
      else if (!mpl->flag_d && mpl->c == '.')
      {  mpl->token = T_POINT, append_char(mpl);
         if (mpl->f_dots)
         {  /* dots; the first dot was read on the previous call to the
               scanner, so the current character is the second dot */
            mpl->token = T_DOTS;
            mpl->imlen = 2;
            strcpy(mpl->image, "..");
            mpl->f_dots = 0;
         }
         else if (mpl->c == '.')
            mpl->token = T_DOTS, append_char(mpl);
         else if (isdigit(mpl->c))
         {  /* numeric literal that begins with the decimal point */
            mpl->token = T_NUMBER, append_char(mpl);
            goto frac;
         }
      }
      else if (mpl->c == ',')
         mpl->token = T_COMMA, append_char(mpl);
      else if (mpl->c == ':')
      {  mpl->token = T_COLON, append_char(mpl);
         if (mpl->c == '=')
            mpl->token = T_ASSIGN, append_char(mpl);
      }
      else if (mpl->c == ';')
         mpl->token = T_SEMICOLON, append_char(mpl);
      else if (mpl->c == '(')
         mpl->token = T_LEFT, append_char(mpl);
      else if (mpl->c == ')')
         mpl->token = T_RIGHT, append_char(mpl);
      else if (mpl->c == '[')
         mpl->token = T_LBRACKET, append_char(mpl);
      else if (mpl->c == ']')
         mpl->token = T_RBRACKET, append_char(mpl);
      else if (mpl->c == '{')
         mpl->token = T_LBRACE, append_char(mpl);
      else if (mpl->c == '}')
         mpl->token = T_RBRACE, append_char(mpl);
#if 1 /* 11/II-2008 */
      else if (mpl->c == '~')
         mpl->token = T_TILDE, append_char(mpl);
#endif
      else if (isalnum(mpl->c) || strchr("+-._", mpl->c) != NULL)
      {  /* symbol */
         xassert(mpl->flag_d);
         mpl->token = T_SYMBOL;
         while (isalnum(mpl->c) || strchr("+-._", mpl->c) != NULL)
            append_char(mpl);
         switch (str2num(mpl->image, &mpl->value))
         {  case 0:
               mpl->token = T_NUMBER;
               break;
            case 1:
               goto err;
            case 2:
               break;
            default:
               xassert(mpl != mpl);
         }
      }
      else
      {  enter_context(mpl);
         error(mpl, "character %c not allowed", mpl->c);
      }
      /* enter the current token into the context queue */
      enter_context(mpl);
      /* reset the flag, which may be set by indexing_expression() and
         is used by expression_list() */
      mpl->flag_x = 0;
done: return;
}

/*----------------------------------------------------------------------
-- unget_token - return current token back to input stream.
--
-- This routine returns the current token back to the input stream, so
-- the previously scanned token becomes the current one. */

void unget_token(MPL *mpl)
{     /* save the current token, which becomes the next one */
      xassert(!mpl->f_scan);
      mpl->f_scan = 1;
      mpl->f_token = mpl->token;
      mpl->f_imlen = mpl->imlen;
      strcpy(mpl->f_image, mpl->image);
      mpl->f_value = mpl->value;
      /* restore the previous token, which becomes the current one */
      mpl->token = mpl->b_token;
      mpl->imlen = mpl->b_imlen;
      strcpy(mpl->image, mpl->b_image);
      mpl->value = mpl->b_value;
      return;
}

/*----------------------------------------------------------------------
-- is_keyword - check if current token is given non-reserved keyword.
--
-- If the current token is given (non-reserved) keyword, this routine
-- returns non-zero. Otherwise zero is returned. */

int is_keyword(MPL *mpl, char *keyword)
{     return
         mpl->token == T_NAME && strcmp(mpl->image, keyword) == 0;
}

/*----------------------------------------------------------------------
-- is_reserved - check if current token is reserved keyword.
--
-- If the current token is a reserved keyword, this routine returns
-- non-zero. Otherwise zero is returned. */

int is_reserved(MPL *mpl)
{     return
         mpl->token == T_AND && mpl->image[0] == 'a' ||
         mpl->token == T_BY ||
         mpl->token == T_CROSS ||
         mpl->token == T_DIFF ||
         mpl->token == T_DIV ||
         mpl->token == T_ELSE ||
         mpl->token == T_IF ||
         mpl->token == T_IN ||
         mpl->token == T_INTER ||
         mpl->token == T_LESS ||
         mpl->token == T_MOD ||
         mpl->token == T_NOT && mpl->image[0] == 'n' ||
         mpl->token == T_OR && mpl->image[0] == 'o' ||
         mpl->token == T_SYMDIFF ||
         mpl->token == T_THEN ||
         mpl->token == T_UNION ||
         mpl->token == T_WITHIN;
}

/*----------------------------------------------------------------------
-- make_code - generate pseudo-code (basic routine).
--
-- This routine generates specified pseudo-code. It is assumed that all
-- other translator routines use this basic routine. */

CODE *make_code(MPL *mpl, int op, OPERANDS *arg, int type, int dim)
{     CODE *code;
      DOMAIN *domain;
      DOMAIN_BLOCK *block;
      ARG_LIST *e;
      /* generate pseudo-code */
      code = alloc(CODE);
      code->op = op;
      code->vflag = 0; /* is inherited from operand(s) */
      /* copy operands and also make them referring to the pseudo-code
         being generated, because the latter becomes the parent for all
         its operands */
      memset(&code->arg, '?', sizeof(OPERANDS));
      switch (op)
      {  case O_NUMBER:
            code->arg.num = arg->num;
            break;
         case O_STRING:
            code->arg.str = arg->str;
            break;
         case O_INDEX:
            code->arg.index.slot = arg->index.slot;
            code->arg.index.next = arg->index.next;
            break;
         case O_MEMNUM:
         case O_MEMSYM:
            for (e = arg->par.list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.par.par = arg->par.par;
            code->arg.par.list = arg->par.list;
            break;
         case O_MEMSET:
            for (e = arg->set.list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.set.set = arg->set.set;
            code->arg.set.list = arg->set.list;
            break;
         case O_MEMVAR:
            for (e = arg->var.list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.var.var = arg->var.var;
            code->arg.var.list = arg->var.list;
#if 1 /* 15/V-2010 */
            code->arg.var.suff = arg->var.suff;
#endif
            break;
#if 1 /* 15/V-2010 */
         case O_MEMCON:
            for (e = arg->con.list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.con.con = arg->con.con;
            code->arg.con.list = arg->con.list;
            code->arg.con.suff = arg->con.suff;
            break;
#endif
         case O_TUPLE:
         case O_MAKE:
            for (e = arg->list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.list = arg->list;
            break;
         case O_SLICE:
            xassert(arg->slice != NULL);
            code->arg.slice = arg->slice;
            break;
         case O_IRAND224:
         case O_UNIFORM01:
         case O_NORMAL01:
         case O_GMTIME:
            code->vflag = 1;
            break;
         case O_CVTNUM:
         case O_CVTSYM:
         case O_CVTLOG:
         case O_CVTTUP:
         case O_CVTLFM:
         case O_PLUS:
         case O_MINUS:
         case O_NOT:
         case O_ABS:
         case O_CEIL:
         case O_FLOOR:
         case O_EXP:
         case O_LOG:
         case O_LOG10:
         case O_SQRT:
         case O_SIN:
         case O_COS:
         case O_TAN:
         case O_ATAN:
         case O_ROUND:
         case O_TRUNC:
         case O_CARD:
         case O_LENGTH:
            /* unary operation */
            xassert(arg->arg.x != NULL);
            xassert(arg->arg.x->up == NULL);
            arg->arg.x->up = code;
            code->vflag |= arg->arg.x->vflag;
            code->arg.arg.x = arg->arg.x;
            break;
         case O_ADD:
         case O_SUB:
         case O_LESS:
         case O_MUL:
         case O_DIV:
         case O_IDIV:
         case O_MOD:
         case O_POWER:
         case O_ATAN2:
         case O_ROUND2:
         case O_TRUNC2:
         case O_UNIFORM:
            if (op == O_UNIFORM) code->vflag = 1;
         case O_NORMAL:
            if (op == O_NORMAL) code->vflag = 1;
         case O_CONCAT:
         case O_LT:
         case O_LE:
         case O_EQ:
         case O_GE:
         case O_GT:
         case O_NE:
         case O_AND:
         case O_OR:
         case O_UNION:
         case O_DIFF:
         case O_SYMDIFF:
         case O_INTER:
         case O_CROSS:
         case O_IN:
         case O_NOTIN:
         case O_WITHIN:
         case O_NOTWITHIN:
         case O_SUBSTR:
         case O_STR2TIME:
         case O_TIME2STR:
            /* binary operation */
            xassert(arg->arg.x != NULL);
            xassert(arg->arg.x->up == NULL);
            arg->arg.x->up = code;
            code->vflag |= arg->arg.x->vflag;
            xassert(arg->arg.y != NULL);
            xassert(arg->arg.y->up == NULL);
            arg->arg.y->up = code;
            code->vflag |= arg->arg.y->vflag;
            code->arg.arg.x = arg->arg.x;
            code->arg.arg.y = arg->arg.y;
            break;
         case O_DOTS:
         case O_FORK:
         case O_SUBSTR3:
            /* ternary operation */
            xassert(arg->arg.x != NULL);
            xassert(arg->arg.x->up == NULL);
            arg->arg.x->up = code;
            code->vflag |= arg->arg.x->vflag;
            xassert(arg->arg.y != NULL);
            xassert(arg->arg.y->up == NULL);
            arg->arg.y->up = code;
            code->vflag |= arg->arg.y->vflag;
            if (arg->arg.z != NULL)
            {  xassert(arg->arg.z->up == NULL);
               arg->arg.z->up = code;
               code->vflag |= arg->arg.z->vflag;
            }
            code->arg.arg.x = arg->arg.x;
            code->arg.arg.y = arg->arg.y;
            code->arg.arg.z = arg->arg.z;
            break;
         case O_MIN:
         case O_MAX:
            /* n-ary operation */
            for (e = arg->list; e != NULL; e = e->next)
            {  xassert(e->x != NULL);
               xassert(e->x->up == NULL);
               e->x->up = code;
               code->vflag |= e->x->vflag;
            }
            code->arg.list = arg->list;
            break;
         case O_SUM:
         case O_PROD:
         case O_MINIMUM:
         case O_MAXIMUM:
         case O_FORALL:
         case O_EXISTS:
         case O_SETOF:
         case O_BUILD:
            /* iterated operation */
            domain = arg->loop.domain;
            xassert(domain != NULL);
            if (domain->code != NULL)
            {  xassert(domain->code->up == NULL);
               domain->code->up = code;
               code->vflag |= domain->code->vflag;
            }
            for (block = domain->list; block != NULL; block =
               block->next)
            {  xassert(block->code != NULL);
               xassert(block->code->up == NULL);
               block->code->up = code;
               code->vflag |= block->code->vflag;
            }
            if (arg->loop.x != NULL)
            {  xassert(arg->loop.x->up == NULL);
               arg->loop.x->up = code;
               code->vflag |= arg->loop.x->vflag;
            }
            code->arg.loop.domain = arg->loop.domain;
            code->arg.loop.x = arg->loop.x;
            break;
         default:
            xassert(op != op);
      }
      /* set other attributes of the pseudo-code */
      code->type = type;
      code->dim = dim;
      code->up = NULL;
      code->valid = 0;
      memset(&code->value, '?', sizeof(VALUE));
      return code;
}

/*----------------------------------------------------------------------
-- make_unary - generate pseudo-code for unary operation.
--
-- This routine generates pseudo-code for unary operation. */

CODE *make_unary(MPL *mpl, int op, CODE *x, int type, int dim)
{     CODE *code;
      OPERANDS arg;
      xassert(x != NULL);
      arg.arg.x = x;
      code = make_code(mpl, op, &arg, type, dim);
      return code;
}

/*----------------------------------------------------------------------
-- make_binary - generate pseudo-code for binary operation.
--
-- This routine generates pseudo-code for binary operation. */

CODE *make_binary(MPL *mpl, int op, CODE *x, CODE *y, int type,
      int dim)
{     CODE *code;
      OPERANDS arg;
      xassert(x != NULL);
      xassert(y != NULL);
      arg.arg.x = x;
      arg.arg.y = y;
      code = make_code(mpl, op, &arg, type, dim);
      return code;
}

/*----------------------------------------------------------------------
-- make_ternary - generate pseudo-code for ternary operation.
--
-- This routine generates pseudo-code for ternary operation. */

CODE *make_ternary(MPL *mpl, int op, CODE *x, CODE *y, CODE *z,
      int type, int dim)
{     CODE *code;
      OPERANDS arg;
      xassert(x != NULL);
      xassert(y != NULL);
      /* third operand can be NULL */
      arg.arg.x = x;
      arg.arg.y = y;
      arg.arg.z = z;
      code = make_code(mpl, op, &arg, type, dim);
      return code;
}

/*----------------------------------------------------------------------
-- numeric_literal - parse reference to numeric literal.
--
-- This routine parses primary expression using the syntax:
--
--  ::=  */

CODE *numeric_literal(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      xassert(mpl->token == T_NUMBER);
      arg.num = mpl->value;
      code = make_code(mpl, O_NUMBER, &arg, A_NUMERIC, 0);
      get_token(mpl /*  */);
      return code;
}

/*----------------------------------------------------------------------
-- string_literal - parse reference to string literal.
--
-- This routine parses primary expression using the syntax:
--
--  ::=  */

CODE *string_literal(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      xassert(mpl->token == T_STRING);
      arg.str = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(arg.str, mpl->image);
      code = make_code(mpl, O_STRING, &arg, A_SYMBOLIC, 0);
      get_token(mpl /*  */);
      return code;
}

/*----------------------------------------------------------------------
-- create_arg_list - create empty operands list.
--
-- This routine creates operands list, which is initially empty. */

ARG_LIST *create_arg_list(MPL *mpl)
{     ARG_LIST *list;
      xassert(mpl == mpl);
      list = NULL;
      return list;
}

/*----------------------------------------------------------------------
-- expand_arg_list - append operand to operands list.
--
-- This routine appends new operand to specified operands list. */

ARG_LIST *expand_arg_list(MPL *mpl, ARG_LIST *list, CODE *x)
{     ARG_LIST *tail, *temp;
      xassert(x != NULL);
      /* create new operands list entry */
      tail = alloc(ARG_LIST);
      tail->x = x;
      tail->next = NULL;
      /* and append it to the operands list */
      if (list == NULL)
         list = tail;
      else
      {  for (temp = list; temp->next != NULL; temp = temp->next);
         temp->next = tail;
      }
      return list;
}

/*----------------------------------------------------------------------
-- arg_list_len - determine length of operands list.
--
-- This routine returns the number of operands in operands list. */

int arg_list_len(MPL *mpl, ARG_LIST *list)
{     ARG_LIST *temp;
      int len;
      xassert(mpl == mpl);
      len = 0;
      for (temp = list; temp != NULL; temp = temp->next) len++;
      return len;
}

/*----------------------------------------------------------------------
-- subscript_list - parse subscript list.
--
-- This routine parses subscript list using the syntax:
--
--  ::= 
--  ::=  , 
--  ::=  */

ARG_LIST *subscript_list(MPL *mpl)
{     ARG_LIST *list;
      CODE *x;
      list = create_arg_list(mpl);
      for (;;)
      {  /* parse subscript expression */
         x = expression_5(mpl);
         /* convert it to symbolic type, if necessary */
         if (x->type == A_NUMERIC)
            x = make_unary(mpl, O_CVTSYM, x, A_SYMBOLIC, 0);
         /* check that now the expression is of symbolic type */
         if (x->type != A_SYMBOLIC)
            error(mpl, "subscript expression has invalid type");
         xassert(x->dim == 0);
         /* and append it to the subscript list */
         list = expand_arg_list(mpl, list, x);
         /* check a token that follows the subscript expression */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_RBRACKET)
            break;
         else
            error(mpl, "syntax error in subscript list");
      }
      return list;
}

#if 1 /* 15/V-2010 */
/*----------------------------------------------------------------------
-- object_reference - parse reference to named object.
--
-- This routine parses primary expression using the syntax:
--
--  ::= 
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::=  
--  ::=  [  ]
--                          
--  ::=  
--  ::=  [  ]
--                          
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  | .lb | .ub | .status | .val | .dual */

CODE *object_reference(MPL *mpl)
{     AVLNODE *node;
      DOMAIN_SLOT *slot;
      SET *set;
      PARAMETER *par;
      VARIABLE *var;
      CONSTRAINT *con;
      ARG_LIST *list;
      OPERANDS arg;
      CODE *code;
      char *name;
      int dim, suff;
      /* find the object in the symbolic name table */
      xassert(mpl->token == T_NAME);
      node = avl_find_node(mpl->tree, mpl->image);
      if (node == NULL)
         error(mpl, "%s not defined", mpl->image);
      /* check the object type and obtain its dimension */
      switch (avl_get_node_type(node))
      {  case A_INDEX:
            /* dummy index */
            slot = (DOMAIN_SLOT *)avl_get_node_link(node);
            name = slot->name;
            dim = 0;
            break;
         case A_SET:
            /* model set */
            set = (SET *)avl_get_node_link(node);
            name = set->name;
            dim = set->dim;
            /* if a set object is referenced in its own declaration and
               the dimen attribute is not specified yet, use dimen 1 by
               default */
            if (set->dimen == 0) set->dimen = 1;
            break;
         case A_PARAMETER:
            /* model parameter */
            par = (PARAMETER *)avl_get_node_link(node);
            name = par->name;
            dim = par->dim;
            break;
         case A_VARIABLE:
            /* model variable */
            var = (VARIABLE *)avl_get_node_link(node);
            name = var->name;
            dim = var->dim;
            break;
         case A_CONSTRAINT:
            /* model constraint or objective */
            con = (CONSTRAINT *)avl_get_node_link(node);
            name = con->name;
            dim = con->dim;
            break;
         default:
            xassert(node != node);
      }
      get_token(mpl /*  */);
      /* parse optional subscript list */
      if (mpl->token == T_LBRACKET)
      {  /* subscript list is specified */
         if (dim == 0)
            error(mpl, "%s cannot be subscripted", name);
         get_token(mpl /* [ */);
         list = subscript_list(mpl);
         if (dim != arg_list_len(mpl, list))
            error(mpl, "%s must have %d subscript%s rather than %d",
               name, dim, dim == 1 ? "" : "s", arg_list_len(mpl, list));
         xassert(mpl->token == T_RBRACKET);
         get_token(mpl /* ] */);
      }
      else
      {  /* subscript list is not specified */
         if (dim != 0)
            error(mpl, "%s must be subscripted", name);
         list = create_arg_list(mpl);
      }
      /* parse optional suffix */
      if (!mpl->flag_s && avl_get_node_type(node) == A_VARIABLE)
         suff = DOT_NONE;
      else
         suff = DOT_VAL;
      if (mpl->token == T_POINT)
      {  get_token(mpl /* . */);
         if (mpl->token != T_NAME)
            error(mpl, "invalid use of period");
         if (!(avl_get_node_type(node) == A_VARIABLE ||
               avl_get_node_type(node) == A_CONSTRAINT))
            error(mpl, "%s cannot have a suffix", name);
         if (strcmp(mpl->image, "lb") == 0)
            suff = DOT_LB;
         else if (strcmp(mpl->image, "ub") == 0)
            suff = DOT_UB;
         else if (strcmp(mpl->image, "status") == 0)
            suff = DOT_STATUS;
         else if (strcmp(mpl->image, "val") == 0)
            suff = DOT_VAL;
         else if (strcmp(mpl->image, "dual") == 0)
            suff = DOT_DUAL;
         else
            error(mpl, "suffix .%s invalid", mpl->image);
         get_token(mpl /* suffix */);
      }
      /* generate pseudo-code to take value of the object */
      switch (avl_get_node_type(node))
      {  case A_INDEX:
            arg.index.slot = slot;
            arg.index.next = slot->list;
            code = make_code(mpl, O_INDEX, &arg, A_SYMBOLIC, 0);
            slot->list = code;
            break;
         case A_SET:
            arg.set.set = set;
            arg.set.list = list;
            code = make_code(mpl, O_MEMSET, &arg, A_ELEMSET,
               set->dimen);
            break;
         case A_PARAMETER:
            arg.par.par = par;
            arg.par.list = list;
            if (par->type == A_SYMBOLIC)
               code = make_code(mpl, O_MEMSYM, &arg, A_SYMBOLIC, 0);
            else
               code = make_code(mpl, O_MEMNUM, &arg, A_NUMERIC, 0);
            break;
         case A_VARIABLE:
            if (!mpl->flag_s && (suff == DOT_STATUS || suff == DOT_VAL
               || suff == DOT_DUAL))
               error(mpl, "invalid reference to status, primal value, o"
                  "r dual value of variable %s above solve statement",
                  var->name);
            arg.var.var = var;
            arg.var.list = list;
            arg.var.suff = suff;
            code = make_code(mpl, O_MEMVAR, &arg, suff == DOT_NONE ?
               A_FORMULA : A_NUMERIC, 0);
            break;
         case A_CONSTRAINT:
            if (!mpl->flag_s && (suff == DOT_STATUS || suff == DOT_VAL
               || suff == DOT_DUAL))
               error(mpl, "invalid reference to status, primal value, o"
                  "r dual value of %s %s above solve statement",
                  con->type == A_CONSTRAINT ? "constraint" : "objective"
                  , con->name);
            arg.con.con = con;
            arg.con.list = list;
            arg.con.suff = suff;
            code = make_code(mpl, O_MEMCON, &arg, A_NUMERIC, 0);
            break;
         default:
            xassert(node != node);
      }
      return code;
}
#endif

/*----------------------------------------------------------------------
-- numeric_argument - parse argument passed to built-in function.
--
-- This routine parses an argument passed to numeric built-in function
-- using the syntax:
--
--  ::=  */

CODE *numeric_argument(MPL *mpl, char *func)
{     CODE *x;
      x = expression_5(mpl);
      /* convert the argument to numeric type, if necessary */
      if (x->type == A_SYMBOLIC)
         x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
      /* check that now the argument is of numeric type */
      if (x->type != A_NUMERIC)
         error(mpl, "argument for %s has invalid type", func);
      xassert(x->dim == 0);
      return x;
}

#if 1 /* 15/VII-2006 */
CODE *symbolic_argument(MPL *mpl, char *func)
{     CODE *x;
      x = expression_5(mpl);
      /* convert the argument to symbolic type, if necessary */
      if (x->type == A_NUMERIC)
         x = make_unary(mpl, O_CVTSYM, x, A_SYMBOLIC, 0);
      /* check that now the argument is of symbolic type */
      if (x->type != A_SYMBOLIC)
         error(mpl, "argument for %s has invalid type", func);
      xassert(x->dim == 0);
      return x;
}
#endif

#if 1 /* 15/VII-2006 */
CODE *elemset_argument(MPL *mpl, char *func)
{     CODE *x;
      x = expression_9(mpl);
      if (x->type != A_ELEMSET)
         error(mpl, "argument for %s has invalid type", func);
      xassert(x->dim > 0);
      return x;
}
#endif

/*----------------------------------------------------------------------
-- function_reference - parse reference to built-in function.
--
-- This routine parses primary expression using the syntax:
--
--  ::= abs (  )
--  ::= ceil (  )
--  ::= floor (  )
--  ::= exp (  )
--  ::= log (  )
--  ::= log10 (  )
--  ::= max (  )
--  ::= min (  )
--  ::= sqrt (  )
--  ::= sin (  )
--  ::= cos (  )
--  ::= tan (  )
--  ::= atan (  )
--  ::= atan2 (  ,  )
--  ::= round (  )
--  ::= round (  ,  )
--  ::= trunc (  )
--  ::= trunc (  ,  )
--  ::= Irand224 ( )
--  ::= Uniform01 ( )
--  ::= Uniform (  ,  )
--  ::= Normal01 ( )
--  ::= Normal (  ,  )
--  ::= card (  )
--  ::= length (  )
--  ::= substr (  ,  )
--  ::= substr (  ,  ,  )
--  ::= str2time (  ,  )
--  ::= time2str (  ,  )
--  ::= gmtime ( )
--  ::= 
--  ::=  ,  */

CODE *function_reference(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      int op;
      char func[15+1];
      /* determine operation code */
      xassert(mpl->token == T_NAME);
      if (strcmp(mpl->image, "abs") == 0)
         op = O_ABS;
      else if (strcmp(mpl->image, "ceil") == 0)
         op = O_CEIL;
      else if (strcmp(mpl->image, "floor") == 0)
         op = O_FLOOR;
      else if (strcmp(mpl->image, "exp") == 0)
         op = O_EXP;
      else if (strcmp(mpl->image, "log") == 0)
         op = O_LOG;
      else if (strcmp(mpl->image, "log10") == 0)
         op = O_LOG10;
      else if (strcmp(mpl->image, "sqrt") == 0)
         op = O_SQRT;
      else if (strcmp(mpl->image, "sin") == 0)
         op = O_SIN;
      else if (strcmp(mpl->image, "cos") == 0)
         op = O_COS;
      else if (strcmp(mpl->image, "tan") == 0)
         op = O_TAN;
      else if (strcmp(mpl->image, "atan") == 0)
         op = O_ATAN;
      else if (strcmp(mpl->image, "min") == 0)
         op = O_MIN;
      else if (strcmp(mpl->image, "max") == 0)
         op = O_MAX;
      else if (strcmp(mpl->image, "round") == 0)
         op = O_ROUND;
      else if (strcmp(mpl->image, "trunc") == 0)
         op = O_TRUNC;
      else if (strcmp(mpl->image, "Irand224") == 0)
         op = O_IRAND224;
      else if (strcmp(mpl->image, "Uniform01") == 0)
         op = O_UNIFORM01;
      else if (strcmp(mpl->image, "Uniform") == 0)
         op = O_UNIFORM;
      else if (strcmp(mpl->image, "Normal01") == 0)
         op = O_NORMAL01;
      else if (strcmp(mpl->image, "Normal") == 0)
         op = O_NORMAL;
      else if (strcmp(mpl->image, "card") == 0)
         op = O_CARD;
      else if (strcmp(mpl->image, "length") == 0)
         op = O_LENGTH;
      else if (strcmp(mpl->image, "substr") == 0)
         op = O_SUBSTR;
      else if (strcmp(mpl->image, "str2time") == 0)
         op = O_STR2TIME;
      else if (strcmp(mpl->image, "time2str") == 0)
         op = O_TIME2STR;
      else if (strcmp(mpl->image, "gmtime") == 0)
         op = O_GMTIME;
      else
         error(mpl, "function %s unknown", mpl->image);
      /* save symbolic name of the function */
      strcpy(func, mpl->image);
      xassert(strlen(func) < sizeof(func));
      get_token(mpl /*  */);
      /* check the left parenthesis that follows the function name */
      xassert(mpl->token == T_LEFT);
      get_token(mpl /* ( */);
      /* parse argument list */
      if (op == O_MIN || op == O_MAX)
      {  /* min and max allow arbitrary number of arguments */
         arg.list = create_arg_list(mpl);
         /* parse argument list */
         for (;;)
         {  /* parse argument and append it to the operands list */
            arg.list = expand_arg_list(mpl, arg.list,
               numeric_argument(mpl, func));
            /* check a token that follows the argument */
            if (mpl->token == T_COMMA)
               get_token(mpl /* , */);
            else if (mpl->token == T_RIGHT)
               break;
            else
               error(mpl, "syntax error in argument list for %s", func);
         }
      }
      else if (op == O_IRAND224 || op == O_UNIFORM01 || op ==
         O_NORMAL01 || op == O_GMTIME)
      {  /* Irand224, Uniform01, Normal01, gmtime need no arguments */
         if (mpl->token != T_RIGHT)
            error(mpl, "%s needs no arguments", func);
      }
      else if (op == O_UNIFORM || op == O_NORMAL)
      {  /* Uniform and Normal need two arguments */
         /* parse the first argument */
         arg.arg.x = numeric_argument(mpl, func);
         /* check a token that follows the first argument */
         if (mpl->token == T_COMMA)
            ;
         else if (mpl->token == T_RIGHT)
            error(mpl, "%s needs two arguments", func);
         else
            error(mpl, "syntax error in argument for %s", func);
         get_token(mpl /* , */);
         /* parse the second argument */
         arg.arg.y = numeric_argument(mpl, func);
         /* check a token that follows the second argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs two argument", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      else if (op == O_ATAN || op == O_ROUND || op == O_TRUNC)
      {  /* atan, round, and trunc need one or two arguments */
         /* parse the first argument */
         arg.arg.x = numeric_argument(mpl, func);
         /* parse the second argument, if specified */
         if (mpl->token == T_COMMA)
         {  switch (op)
            {  case O_ATAN:  op = O_ATAN2;  break;
               case O_ROUND: op = O_ROUND2; break;
               case O_TRUNC: op = O_TRUNC2; break;
               default: xassert(op != op);
            }
            get_token(mpl /* , */);
            arg.arg.y = numeric_argument(mpl, func);
         }
         /* check a token that follows the last argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs one or two arguments", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      else if (op == O_SUBSTR)
      {  /* substr needs two or three arguments */
         /* parse the first argument */
         arg.arg.x = symbolic_argument(mpl, func);
         /* check a token that follows the first argument */
         if (mpl->token == T_COMMA)
            ;
         else if (mpl->token == T_RIGHT)
            error(mpl, "%s needs two or three arguments", func);
         else
            error(mpl, "syntax error in argument for %s", func);
         get_token(mpl /* , */);
         /* parse the second argument */
         arg.arg.y = numeric_argument(mpl, func);
         /* parse the third argument, if specified */
         if (mpl->token == T_COMMA)
         {  op = O_SUBSTR3;
            get_token(mpl /* , */);
            arg.arg.z = numeric_argument(mpl, func);
         }
         /* check a token that follows the last argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs two or three arguments", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      else if (op == O_STR2TIME)
      {  /* str2time needs two arguments, both symbolic */
         /* parse the first argument */
         arg.arg.x = symbolic_argument(mpl, func);
         /* check a token that follows the first argument */
         if (mpl->token == T_COMMA)
            ;
         else if (mpl->token == T_RIGHT)
            error(mpl, "%s needs two arguments", func);
         else
            error(mpl, "syntax error in argument for %s", func);
         get_token(mpl /* , */);
         /* parse the second argument */
         arg.arg.y = symbolic_argument(mpl, func);
         /* check a token that follows the second argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs two argument", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      else if (op == O_TIME2STR)
      {  /* time2str needs two arguments, numeric and symbolic */
         /* parse the first argument */
         arg.arg.x = numeric_argument(mpl, func);
         /* check a token that follows the first argument */
         if (mpl->token == T_COMMA)
            ;
         else if (mpl->token == T_RIGHT)
            error(mpl, "%s needs two arguments", func);
         else
            error(mpl, "syntax error in argument for %s", func);
         get_token(mpl /* , */);
         /* parse the second argument */
         arg.arg.y = symbolic_argument(mpl, func);
         /* check a token that follows the second argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs two argument", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      else
      {  /* other functions need one argument */
         if (op == O_CARD)
            arg.arg.x = elemset_argument(mpl, func);
         else if (op == O_LENGTH)
            arg.arg.x = symbolic_argument(mpl, func);
         else
            arg.arg.x = numeric_argument(mpl, func);
         /* check a token that follows the argument */
         if (mpl->token == T_COMMA)
            error(mpl, "%s needs one argument", func);
         else if (mpl->token == T_RIGHT)
            ;
         else
            error(mpl, "syntax error in argument for %s", func);
      }
      /* make pseudo-code to call the built-in function */
      if (op == O_SUBSTR || op == O_SUBSTR3 || op == O_TIME2STR)
         code = make_code(mpl, op, &arg, A_SYMBOLIC, 0);
      else
         code = make_code(mpl, op, &arg, A_NUMERIC, 0);
      /* the reference ends with the right parenthesis */
      xassert(mpl->token == T_RIGHT);
      get_token(mpl /* ) */);
      return code;
}

/*----------------------------------------------------------------------
-- create_domain - create empty domain.
--
-- This routine creates empty domain, which is initially empty, i.e.
-- has no domain blocks. */

DOMAIN *create_domain(MPL *mpl)
{     DOMAIN *domain;
      domain = alloc(DOMAIN);
      domain->list = NULL;
      domain->code = NULL;
      return domain;
}

/*----------------------------------------------------------------------
-- create_block - create empty domain block.
--
-- This routine creates empty domain block, which is initially empty,
-- i.e. has no domain slots. */

DOMAIN_BLOCK *create_block(MPL *mpl)
{     DOMAIN_BLOCK *block;
      block = alloc(DOMAIN_BLOCK);
      block->list = NULL;
      block->code = NULL;
      block->backup = NULL;
      block->next = NULL;
      return block;
}

/*----------------------------------------------------------------------
-- append_block - append domain block to specified domain.
--
-- This routine adds given domain block to the end of the block list of
-- specified domain. */

void append_block(MPL *mpl, DOMAIN *domain, DOMAIN_BLOCK *block)
{     DOMAIN_BLOCK *temp;
      xassert(mpl == mpl);
      xassert(domain != NULL);
      xassert(block != NULL);
      xassert(block->next == NULL);
      if (domain->list == NULL)
         domain->list = block;
      else
      {  for (temp = domain->list; temp->next != NULL; temp =
            temp->next);
         temp->next = block;
      }
      return;
}

/*----------------------------------------------------------------------
-- append_slot - create and append new slot to domain block.
--
-- This routine creates new domain slot and adds it to the end of slot
-- list of specified domain block.
--
-- The parameter name is symbolic name of the dummy index associated
-- with the slot (the character string must be allocated). NULL means
-- the dummy index is not explicitly specified.
--
-- The parameter code is pseudo-code for computing symbolic value, at
-- which the dummy index is bounded. NULL means the dummy index is free
-- in the domain scope. */

DOMAIN_SLOT *append_slot(MPL *mpl, DOMAIN_BLOCK *block, char *name,
      CODE *code)
{     DOMAIN_SLOT *slot, *temp;
      xassert(block != NULL);
      slot = alloc(DOMAIN_SLOT);
      slot->name = name;
      slot->code = code;
      slot->value = NULL;
      slot->list = NULL;
      slot->next = NULL;
      if (block->list == NULL)
         block->list = slot;
      else
      {  for (temp = block->list; temp->next != NULL; temp =
            temp->next);
         temp->next = slot;
      }
      return slot;
}

/*----------------------------------------------------------------------
-- expression_list - parse expression list.
--
-- This routine parses a list of one or more expressions enclosed into
-- the parentheses using the syntax:
--
--  ::= (  )
--  ::= 
--  ::=  , 
--
-- Note that this construction may have three different meanings:
--
-- 1. If  consists of only one expression,  is a parenthesized expression, which may be of any
--    valid type (not necessarily 1-tuple).
--
-- 2. If  consists of several expressions separated by
--    commae, where no expression is undeclared symbolic name,  is a n-tuple.
--
-- 3. If  consists of several expressions separated by
--    commae, where at least one expression is undeclared symbolic name
--    (that denotes a dummy index),  is a slice and
--    can be only used as constituent of indexing expression. */

#define max_dim 20
/* maximal number of components allowed within parentheses */

CODE *expression_list(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      struct { char *name; CODE *code; } list[1+max_dim];
      int flag_x, next_token, dim, j, slice = 0;
      xassert(mpl->token == T_LEFT);
      /* the flag, which allows recognizing undeclared symbolic names
         as dummy indices, will be automatically reset by get_token(),
         so save it before scanning the next token */
      flag_x = mpl->flag_x;
      get_token(mpl /* ( */);
      /* parse  */
      for (dim = 1; ; dim++)
      {  if (dim > max_dim)
            error(mpl, "too many components within parentheses");
         /* current component of  can be either dummy
            index or expression */
         if (mpl->token == T_NAME)
         {  /* symbolic name is recognized as dummy index only if:
               the flag, which allows that, is set, and
               the name is followed by comma or right parenthesis, and
               the name is undeclared */
            get_token(mpl /*  */);
            next_token = mpl->token;
            unget_token(mpl);
            if (!(flag_x &&
                  (next_token == T_COMMA || next_token == T_RIGHT) &&
                  avl_find_node(mpl->tree, mpl->image) == NULL))
            {  /* this is not dummy index */
               goto expr;
            }
            /* all dummy indices within the same slice must have unique
               symbolic names */
            for (j = 1; j < dim; j++)
            {  if (list[j].name != NULL && strcmp(list[j].name,
                  mpl->image) == 0)
                  error(mpl, "duplicate dummy index %s not allowed",
                     mpl->image);
            }
            /* current component of  is dummy index */
            list[dim].name
               = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
            strcpy(list[dim].name, mpl->image);
            list[dim].code = NULL;
            get_token(mpl /*  */);
            /*  is a slice, because at least one dummy
               index has appeared */
            slice = 1;
            /* note that the context (  ) is not allowed,
               i.e. in this case  is considered as
               a parenthesized expression */
            if (dim == 1 && mpl->token == T_RIGHT)
               error(mpl, "%s not defined", list[dim].name);
         }
         else
expr:    {  /* current component of  is expression */
            code = expression_13(mpl);
            /* if the current expression is followed by comma or it is
               not the very first expression, entire 
               is n-tuple or slice, in which case the current expression
               should be converted to symbolic type, if necessary */
            if (mpl->token == T_COMMA || dim > 1)
            {  if (code->type == A_NUMERIC)
                  code = make_unary(mpl, O_CVTSYM, code, A_SYMBOLIC, 0);
               /* now the expression must be of symbolic type */
               if (code->type != A_SYMBOLIC)
                  error(mpl, "component expression has invalid type");
               xassert(code->dim == 0);
            }
            list[dim].name = NULL;
            list[dim].code = code;
         }
         /* check a token that follows the current component */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_RIGHT)
            break;
         else
            error(mpl, "right parenthesis missing where expected");
      }
      /* generate pseudo-code for  */
      if (dim == 1 && !slice)
      {  /*  is a parenthesized expression */
         code = list[1].code;
      }
      else if (!slice)
      {  /*  is a n-tuple */
         arg.list = create_arg_list(mpl);
         for (j = 1; j <= dim; j++)
            arg.list = expand_arg_list(mpl, arg.list, list[j].code);
         code = make_code(mpl, O_TUPLE, &arg, A_TUPLE, dim);
      }
      else
      {  /*  is a slice */
         arg.slice = create_block(mpl);
         for (j = 1; j <= dim; j++)
            append_slot(mpl, arg.slice, list[j].name, list[j].code);
         /* note that actually pseudo-codes with op = O_SLICE are never
            evaluated */
         code = make_code(mpl, O_SLICE, &arg, A_TUPLE, dim);
      }
      get_token(mpl /* ) */);
      /* if  is a slice, there must be the keyword
         'in', which follows the right parenthesis */
      if (slice && mpl->token != T_IN)
         error(mpl, "keyword in missing where expected");
      /* if the slice flag is set and there is the keyword 'in', which
         follows , the latter must be a slice */
      if (flag_x && mpl->token == T_IN && !slice)
      {  if (dim == 1)
            error(mpl, "syntax error in indexing expression");
         else
            error(mpl, "0-ary slice not allowed");
      }
      return code;
}

/*----------------------------------------------------------------------
-- literal set - parse literal set.
--
-- This routine parses literal set using the syntax:
--
--  ::= {  }
--  ::= 
--  ::=  , 
--  ::= 
--
-- It is assumed that the left curly brace and the very first member
-- expression that follows it are already parsed. The right curly brace
-- remains unscanned on exit. */

CODE *literal_set(MPL *mpl, CODE *code)
{     OPERANDS arg;
      int j;
      xassert(code != NULL);
      arg.list = create_arg_list(mpl);
      /* parse  */
      for (j = 1; ; j++)
      {  /* all member expressions must be n-tuples; so, if the current
            expression is not n-tuple, convert it to 1-tuple */
         if (code->type == A_NUMERIC)
            code = make_unary(mpl, O_CVTSYM, code, A_SYMBOLIC, 0);
         if (code->type == A_SYMBOLIC)
            code = make_unary(mpl, O_CVTTUP, code, A_TUPLE, 1);
         /* now the expression must be n-tuple */
         if (code->type != A_TUPLE)
            error(mpl, "member expression has invalid type");
         /* all member expressions must have identical dimension */
         if (arg.list != NULL && arg.list->x->dim != code->dim)
            error(mpl, "member %d has %d component%s while member %d ha"
               "s %d component%s",
               j-1, arg.list->x->dim, arg.list->x->dim == 1 ? "" : "s",
               j, code->dim, code->dim == 1 ? "" : "s");
         /* append the current expression to the member list */
         arg.list = expand_arg_list(mpl, arg.list, code);
         /* check a token that follows the current expression */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_RBRACE)
            break;
         else
            error(mpl, "syntax error in literal set");
         /* parse the next expression that follows the comma */
         code = expression_5(mpl);
      }
      /* generate pseudo-code for  */
      code = make_code(mpl, O_MAKE, &arg, A_ELEMSET, arg.list->x->dim);
      return code;
}

/*----------------------------------------------------------------------
-- indexing_expression - parse indexing expression.
--
-- This routine parses indexing expression using the syntax:
--
--  ::= 
--  ::= {  }
--  ::= {  :  }
--  ::= 
--  ::=  , 
--  ::= 
--  ::=  in 
--  ::=  in 
--  ::= 
--  ::= (  )
--  ::= 
--  ::= 
--
-- This routine creates domain for , where each
-- domain block corresponds to , and each domain slot
-- corresponds to individual indexing position. */

DOMAIN *indexing_expression(MPL *mpl)
{     DOMAIN *domain;
      DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      CODE *code;
      xassert(mpl->token == T_LBRACE);
      get_token(mpl /* { */);
      if (mpl->token == T_RBRACE)
         error(mpl, "empty indexing expression not allowed");
      /* create domain to be constructed */
      domain = create_domain(mpl);
      /* parse either  or  that follows the
         left brace */
      for (;;)
      {  /* domain block for  is not created yet */
         block = NULL;
         /* pseudo-code for  is not generated yet */
         code = NULL;
         /* check a token, which  begins with */
         if (mpl->token == T_NAME)
         {  /* it is a symbolic name */
            int next_token;
            char *name;
            /* symbolic name is recognized as dummy index only if it is
               followed by the keyword 'in' and not declared */
            get_token(mpl /*  */);
            next_token = mpl->token;
            unget_token(mpl);
            if (!(next_token == T_IN &&
                  avl_find_node(mpl->tree, mpl->image) == NULL))
            {  /* this is not dummy index; the symbolic name begins an
                  expression, which is either  or the
                  very first  in  */
               goto expr;
            }
            /* create domain block with one slot, which is assigned the
               dummy index */
            block = create_block(mpl);
            name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
            strcpy(name, mpl->image);
            append_slot(mpl, block, name, NULL);
            get_token(mpl /*  */);
            /* the keyword 'in' is already checked above */
            xassert(mpl->token == T_IN);
            get_token(mpl /* in */);
            /*  that follows the keyword 'in' will be
               parsed below */
         }
         else if (mpl->token == T_LEFT)
         {  /* it is the left parenthesis; parse expression that begins
               with this parenthesis (the flag is set in order to allow
               recognizing slices; see the routine expression_list) */
            mpl->flag_x = 1;
            code = expression_9(mpl);
            if (code->op != O_SLICE)
            {  /* this is either  or the very first
                   in  */
               goto expr;
            }
            /* this is a slice; besides the corresponding domain block
               is already created by expression_list() */
            block = code->arg.slice;
            code = NULL; /*  is not parsed yet */
            /* the keyword 'in' following the slice is already checked
               by expression_list() */
            xassert(mpl->token == T_IN);
            get_token(mpl /* in */);
            /*  that follows the keyword 'in' will be
               parsed below */
         }
expr:    /* parse expression that follows either the keyword 'in' (in
            which case it can be  as well as the
            very first  in ); note that
            this expression can be already parsed above */
         if (code == NULL) code = expression_9(mpl);
         /* check the type of the expression just parsed */
         if (code->type != A_ELEMSET)
         {  /* it is not  and therefore it can only
               be the very first  in ;
               however, then there must be no dummy index neither slice
               between the left brace and this expression */
            if (block != NULL)
               error(mpl, "domain expression has invalid type");
            /* parse the rest part of  and make this set
               be , i.e. the construction {a, b, c}
               is parsed as it were written as {A}, where A = {a, b, c}
               is a temporary elemental set */
            code = literal_set(mpl, code);
         }
         /* now pseudo-code for  has been built */
         xassert(code != NULL);
         xassert(code->type == A_ELEMSET);
         xassert(code->dim > 0);
         /* if domain block for the current  is still
            not created, create it for fake slice of the same dimension
            as  */
         if (block == NULL)
         {  int j;
            block = create_block(mpl);
            for (j = 1; j <= code->dim; j++)
               append_slot(mpl, block, NULL, NULL);
         }
         /* number of indexing positions in  must be
            the same as dimension of n-tuples in basic set */
         {  int dim = 0;
            for (slot = block->list; slot != NULL; slot = slot->next)
               dim++;
            if (dim != code->dim)
               error(mpl,"%d %s specified for set of dimension %d",
                  dim, dim == 1 ? "index" : "indices", code->dim);
         }
         /* store pseudo-code for  in the domain block */
         xassert(block->code == NULL);
         block->code = code;
         /* and append the domain block to the domain */
         append_block(mpl, domain, block);
         /* the current  has been completely parsed;
            include all its dummy indices into the symbolic name table
            to make them available for referencing from expressions;
            implicit declarations of dummy indices remain valid while
            the corresponding domain scope is valid */
         for (slot = block->list; slot != NULL; slot = slot->next)
         if (slot->name != NULL)
         {  AVLNODE *node;
            xassert(avl_find_node(mpl->tree, slot->name) == NULL);
            node = avl_insert_node(mpl->tree, slot->name);
            avl_set_node_type(node, A_INDEX);
            avl_set_node_link(node, (void *)slot);
         }
         /* check a token that follows  */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_COLON || mpl->token == T_RBRACE)
            break;
         else
            error(mpl, "syntax error in indexing expression");
      }
      /* parse  that follows the colon */
      if (mpl->token == T_COLON)
      {  get_token(mpl /* : */);
         code = expression_13(mpl);
         /* convert the expression to logical type, if necessary */
         if (code->type == A_SYMBOLIC)
            code = make_unary(mpl, O_CVTNUM, code, A_NUMERIC, 0);
         if (code->type == A_NUMERIC)
            code = make_unary(mpl, O_CVTLOG, code, A_LOGICAL, 0);
         /* now the expression must be of logical type */
         if (code->type != A_LOGICAL)
            error(mpl, "expression following colon has invalid type");
         xassert(code->dim == 0);
         domain->code = code;
         /* the right brace must follow the logical expression */
         if (mpl->token != T_RBRACE)
            error(mpl, "syntax error in indexing expression");
      }
      get_token(mpl /* } */);
      return domain;
}

/*----------------------------------------------------------------------
-- close_scope - close scope of indexing expression.
--
-- The routine closes the scope of indexing expression specified by its
-- domain and thereby makes all dummy indices introduced in the indexing
-- expression no longer available for referencing. */

void close_scope(MPL *mpl, DOMAIN *domain)
{     DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      AVLNODE *node;
      xassert(domain != NULL);
      /* remove all dummy indices from the symbolic names table */
      for (block = domain->list; block != NULL; block = block->next)
      {  for (slot = block->list; slot != NULL; slot = slot->next)
         {  if (slot->name != NULL)
            {  node = avl_find_node(mpl->tree, slot->name);
               xassert(node != NULL);
               xassert(avl_get_node_type(node) == A_INDEX);
               avl_delete_node(mpl->tree, node);
            }
         }
      }
      return;
}

/*----------------------------------------------------------------------
-- iterated_expression - parse iterated expression.
--
-- This routine parses primary expression using the syntax:
--
--  ::= 
--  ::= sum  
--  ::= prod  
--  ::= min  
--  ::= max  
--  ::= exists 
--                           
--  ::= forall 
--                           
--  ::= setof  
--
-- Note that parsing "integrand" depends on the iterated operator. */

#if 1 /* 07/IX-2008 */
static void link_up(CODE *code)
{     /* if we have something like sum{(i+1,j,k-1) in E} x[i,j,k],
         where i and k are dummy indices defined out of the iterated
         expression, we should link up pseudo-code for computing i+1
         and k-1 to pseudo-code for computing the iterated expression;
         this is needed to invalidate current value of the iterated
         expression once i or k have been changed */
      DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      for (block = code->arg.loop.domain->list; block != NULL;
         block = block->next)
      {  for (slot = block->list; slot != NULL; slot = slot->next)
         {  if (slot->code != NULL)
            {  xassert(slot->code->up == NULL);
               slot->code->up = code;
            }
         }
      }
      return;
}
#endif

CODE *iterated_expression(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      int op;
      char opstr[8];
      /* determine operation code */
      xassert(mpl->token == T_NAME);
      if (strcmp(mpl->image, "sum") == 0)
         op = O_SUM;
      else if (strcmp(mpl->image, "prod") == 0)
         op = O_PROD;
      else if (strcmp(mpl->image, "min") == 0)
         op = O_MINIMUM;
      else if (strcmp(mpl->image, "max") == 0)
         op = O_MAXIMUM;
      else if (strcmp(mpl->image, "forall") == 0)
         op = O_FORALL;
      else if (strcmp(mpl->image, "exists") == 0)
         op = O_EXISTS;
      else if (strcmp(mpl->image, "setof") == 0)
         op = O_SETOF;
      else
         error(mpl, "operator %s unknown", mpl->image);
      strcpy(opstr, mpl->image);
      xassert(strlen(opstr) < sizeof(opstr));
      get_token(mpl /*  */);
      /* check the left brace that follows the operator name */
      xassert(mpl->token == T_LBRACE);
      /* parse indexing expression that controls iterating */
      arg.loop.domain = indexing_expression(mpl);
      /* parse "integrand" expression and generate pseudo-code */
      switch (op)
      {  case O_SUM:
         case O_PROD:
         case O_MINIMUM:
         case O_MAXIMUM:
            arg.loop.x = expression_3(mpl);
            /* convert the integrand to numeric type, if necessary */
            if (arg.loop.x->type == A_SYMBOLIC)
               arg.loop.x = make_unary(mpl, O_CVTNUM, arg.loop.x,
                  A_NUMERIC, 0);
            /* now the integrand must be of numeric type or linear form
               (the latter is only allowed for the sum operator) */
            if (!(arg.loop.x->type == A_NUMERIC ||
                  op == O_SUM && arg.loop.x->type == A_FORMULA))
err:           error(mpl, "integrand following %s{...} has invalid type"
                  , opstr);
            xassert(arg.loop.x->dim == 0);
            /* generate pseudo-code */
            code = make_code(mpl, op, &arg, arg.loop.x->type, 0);
            break;
         case O_FORALL:
         case O_EXISTS:
            arg.loop.x = expression_12(mpl);
            /* convert the integrand to logical type, if necessary */
            if (arg.loop.x->type == A_SYMBOLIC)
               arg.loop.x = make_unary(mpl, O_CVTNUM, arg.loop.x,
                  A_NUMERIC, 0);
            if (arg.loop.x->type == A_NUMERIC)
               arg.loop.x = make_unary(mpl, O_CVTLOG, arg.loop.x,
                  A_LOGICAL, 0);
            /* now the integrand must be of logical type */
            if (arg.loop.x->type != A_LOGICAL) goto err;
            xassert(arg.loop.x->dim == 0);
            /* generate pseudo-code */
            code = make_code(mpl, op, &arg, A_LOGICAL, 0);
            break;
         case O_SETOF:
            arg.loop.x = expression_5(mpl);
            /* convert the integrand to 1-tuple, if necessary */
            if (arg.loop.x->type == A_NUMERIC)
               arg.loop.x = make_unary(mpl, O_CVTSYM, arg.loop.x,
                  A_SYMBOLIC, 0);
            if (arg.loop.x->type == A_SYMBOLIC)
               arg.loop.x = make_unary(mpl, O_CVTTUP, arg.loop.x,
                  A_TUPLE, 1);
            /* now the integrand must be n-tuple */
            if (arg.loop.x->type != A_TUPLE) goto err;
            xassert(arg.loop.x->dim > 0);
            /* generate pseudo-code */
            code = make_code(mpl, op, &arg, A_ELEMSET, arg.loop.x->dim);
            break;
         default:
            xassert(op != op);
      }
      /* close the scope of the indexing expression */
      close_scope(mpl, arg.loop.domain);
#if 1 /* 07/IX-2008 */
      link_up(code);
#endif
      return code;
}

/*----------------------------------------------------------------------
-- domain_arity - determine arity of domain.
--
-- This routine returns arity of specified domain, which is number of
-- its free dummy indices. */

int domain_arity(MPL *mpl, DOMAIN *domain)
{     DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      int arity;
      xassert(mpl == mpl);
      arity = 0;
      for (block = domain->list; block != NULL; block = block->next)
         for (slot = block->list; slot != NULL; slot = slot->next)
            if (slot->code == NULL) arity++;
      return arity;
}

/*----------------------------------------------------------------------
-- set_expression - parse set expression.
--
-- This routine parses primary expression using the syntax:
--
--  ::= { }
--  ::=  */

CODE *set_expression(MPL *mpl)
{     CODE *code;
      OPERANDS arg;
      xassert(mpl->token == T_LBRACE);
      get_token(mpl /* { */);
      /* check a token that follows the left brace */
      if (mpl->token == T_RBRACE)
      {  /* it is the right brace, so the resultant is an empty set of
            dimension 1 */
         arg.list = NULL;
         /* generate pseudo-code to build the resultant set */
         code = make_code(mpl, O_MAKE, &arg, A_ELEMSET, 1);
         get_token(mpl /* } */);
      }
      else
      {  /* the next token begins an indexing expression */
         unget_token(mpl);
         arg.loop.domain = indexing_expression(mpl);
         arg.loop.x = NULL; /* integrand is not used */
         /* close the scope of the indexing expression */
         close_scope(mpl, arg.loop.domain);
         /* generate pseudo-code to build the resultant set */
         code = make_code(mpl, O_BUILD, &arg, A_ELEMSET,
            domain_arity(mpl, arg.loop.domain));
#if 1 /* 07/IX-2008 */
         link_up(code);
#endif
      }
      return code;
}

/*----------------------------------------------------------------------
-- branched_expression - parse conditional expression.
--
-- This routine parses primary expression using the syntax:
--
--  ::= 
--  ::= if  then 
--  ::= if  then 
--                           else 
--  ::=  */

CODE *branched_expression(MPL *mpl)
{     CODE *code, *x, *y, *z;
      xassert(mpl->token == T_IF);
      get_token(mpl /* if */);
      /* parse  that follows 'if' */
      x = expression_13(mpl);
      /* convert the expression to logical type, if necessary */
      if (x->type == A_SYMBOLIC)
         x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
      if (x->type == A_NUMERIC)
         x = make_unary(mpl, O_CVTLOG, x, A_LOGICAL, 0);
      /* now the expression must be of logical type */
      if (x->type != A_LOGICAL)
         error(mpl, "expression following if has invalid type");
      xassert(x->dim == 0);
      /* the keyword 'then' must follow the logical expression */
      if (mpl->token != T_THEN)
         error(mpl, "keyword then missing where expected");
      get_token(mpl /* then */);
      /* parse  that follows 'then' and check its type */
      y = expression_9(mpl);
      if (!(y->type == A_NUMERIC || y->type == A_SYMBOLIC ||
            y->type == A_ELEMSET || y->type == A_FORMULA))
         error(mpl, "expression following then has invalid type");
      /* if the expression that follows the keyword 'then' is elemental
         set, the keyword 'else' cannot be omitted; otherwise else-part
         is optional */
      if (mpl->token != T_ELSE)
      {  if (y->type == A_ELEMSET)
            error(mpl, "keyword else missing where expected");
         z = NULL;
         goto skip;
      }
      get_token(mpl /* else */);
      /* parse  that follow 'else' and check its type */
      z = expression_9(mpl);
      if (!(z->type == A_NUMERIC || z->type == A_SYMBOLIC ||
            z->type == A_ELEMSET || z->type == A_FORMULA))
         error(mpl, "expression following else has invalid type");
      /* convert to identical types, if necessary */
      if (y->type == A_FORMULA || z->type == A_FORMULA)
      {  if (y->type == A_SYMBOLIC)
            y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
         if (y->type == A_NUMERIC)
            y = make_unary(mpl, O_CVTLFM, y, A_FORMULA, 0);
         if (z->type == A_SYMBOLIC)
            z = make_unary(mpl, O_CVTNUM, z, A_NUMERIC, 0);
         if (z->type == A_NUMERIC)
            z = make_unary(mpl, O_CVTLFM, z, A_FORMULA, 0);
      }
      if (y->type == A_SYMBOLIC || z->type == A_SYMBOLIC)
      {  if (y->type == A_NUMERIC)
            y = make_unary(mpl, O_CVTSYM, y, A_SYMBOLIC, 0);
         if (z->type == A_NUMERIC)
            z = make_unary(mpl, O_CVTSYM, z, A_SYMBOLIC, 0);
      }
      /* now both expressions must have identical types */
      if (y->type != z->type)
         error(mpl, "expressions following then and else have incompati"
            "ble types");
      /* and identical dimensions */
      if (y->dim != z->dim)
         error(mpl, "expressions following then and else have different"
            " dimensions %d and %d, respectively", y->dim, z->dim);
skip: /* generate pseudo-code to perform branching */
      code = make_ternary(mpl, O_FORK, x, y, z, y->type, y->dim);
      return code;
}

/*----------------------------------------------------------------------
-- primary_expression - parse primary expression.
--
-- This routine parses primary expression using the syntax:
--
--  ::= 
--  ::= Infinity
--  ::= 
--  ::= 
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::=  (  )
--  ::= (  )
--  ::= 
--  ::= { }
--  ::= 
--  ::= 
--
-- For complete list of syntactic rules for  see
-- comments to the corresponding parsing routines. */

CODE *primary_expression(MPL *mpl)
{     CODE *code;
      if (mpl->token == T_NUMBER)
      {  /* parse numeric literal */
         code = numeric_literal(mpl);
      }
#if 1 /* 21/VII-2006 */
      else if (mpl->token == T_INFINITY)
      {  /* parse "infinity" */
         OPERANDS arg;
         arg.num = DBL_MAX;
         code = make_code(mpl, O_NUMBER, &arg, A_NUMERIC, 0);
         get_token(mpl /* Infinity */);
      }
#endif
      else if (mpl->token == T_STRING)
      {  /* parse string literal */
         code = string_literal(mpl);
      }
      else if (mpl->token == T_NAME)
      {  int next_token;
         get_token(mpl /*  */);
         next_token = mpl->token;
         unget_token(mpl);
         /* check a token that follows  */
         switch (next_token)
         {  case T_LBRACKET:
               /* parse reference to subscripted object */
               code = object_reference(mpl);
               break;
            case T_LEFT:
               /* parse reference to built-in function */
               code = function_reference(mpl);
               break;
            case T_LBRACE:
               /* parse iterated expression */
               code = iterated_expression(mpl);
               break;
            default:
               /* parse reference to unsubscripted object */
               code = object_reference(mpl);
               break;
         }
      }
      else if (mpl->token == T_LEFT)
      {  /* parse parenthesized expression */
         code = expression_list(mpl);
      }
      else if (mpl->token == T_LBRACE)
      {  /* parse set expression */
         code = set_expression(mpl);
      }
      else if (mpl->token == T_IF)
      {  /* parse conditional expression */
         code = branched_expression(mpl);
      }
      else if (is_reserved(mpl))
      {  /* other reserved keywords cannot be used here */
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      }
      else
         error(mpl, "syntax error in expression");
      return code;
}

/*----------------------------------------------------------------------
-- error_preceding - raise error if preceding operand has wrong type.
--
-- This routine is called to raise error if operand that precedes some
-- infix operator has invalid type. */

void error_preceding(MPL *mpl, char *opstr)
{     error(mpl, "operand preceding %s has invalid type", opstr);
      /* no return */
}

/*----------------------------------------------------------------------
-- error_following - raise error if following operand has wrong type.
--
-- This routine is called to raise error if operand that follows some
-- infix operator has invalid type. */

void error_following(MPL *mpl, char *opstr)
{     error(mpl, "operand following %s has invalid type", opstr);
      /* no return */
}

/*----------------------------------------------------------------------
-- error_dimension - raise error if operands have different dimension.
--
-- This routine is called to raise error if two operands of some infix
-- operator have different dimension. */

void error_dimension(MPL *mpl, char *opstr, int dim1, int dim2)
{     error(mpl, "operands preceding and following %s have different di"
         "mensions %d and %d, respectively", opstr, dim1, dim2);
      /* no return */
}

/*----------------------------------------------------------------------
-- expression_0 - parse expression of level 0.
--
-- This routine parses expression of level 0 using the syntax:
--
--  ::=  */

CODE *expression_0(MPL *mpl)
{     CODE *code;
      code = primary_expression(mpl);
      return code;
}

/*----------------------------------------------------------------------
-- expression_1 - parse expression of level 1.
--
-- This routine parses expression of level 1 using the syntax:
--
--  ::= 
--  ::=   
--  ::=   
--  ::= ^ | ** */

CODE *expression_1(MPL *mpl)
{     CODE *x, *y;
      char opstr[8];
      x = expression_0(mpl);
      if (mpl->token == T_POWER)
      {  strcpy(opstr, mpl->image);
         xassert(strlen(opstr) < sizeof(opstr));
         if (x->type == A_SYMBOLIC)
            x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
         if (x->type != A_NUMERIC)
            error_preceding(mpl, opstr);
         get_token(mpl /* ^ | ** */);
         if (mpl->token == T_PLUS || mpl->token == T_MINUS)
            y = expression_2(mpl);
         else
            y = expression_1(mpl);
         if (y->type == A_SYMBOLIC)
            y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
         if (y->type != A_NUMERIC)
            error_following(mpl, opstr);
         x = make_binary(mpl, O_POWER, x, y, A_NUMERIC, 0);
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_2 - parse expression of level 2.
--
-- This routine parses expression of level 2 using the syntax:
--
--  ::= 
--  ::= + 
--  ::= -  */

CODE *expression_2(MPL *mpl)
{     CODE *x;
      if (mpl->token == T_PLUS)
      {  get_token(mpl /* + */);
         x = expression_1(mpl);
         if (x->type == A_SYMBOLIC)
            x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
         if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
            error_following(mpl, "+");
         x = make_unary(mpl, O_PLUS, x, x->type, 0);
      }
      else if (mpl->token == T_MINUS)
      {  get_token(mpl /* - */);
         x = expression_1(mpl);
         if (x->type == A_SYMBOLIC)
            x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
         if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
            error_following(mpl, "-");
         x = make_unary(mpl, O_MINUS, x, x->type, 0);
      }
      else
         x = expression_1(mpl);
      return x;
}

/*----------------------------------------------------------------------
-- expression_3 - parse expression of level 3.
--
-- This routine parses expression of level 3 using the syntax:
--
--  ::= 
--  ::=  * 
--  ::=  / 
--  ::=  div 
--  ::=  mod  */

CODE *expression_3(MPL *mpl)
{     CODE *x, *y;
      x = expression_2(mpl);
      for (;;)
      {  if (mpl->token == T_ASTERISK)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
               error_preceding(mpl, "*");
            get_token(mpl /* * */);
            y = expression_2(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (!(y->type == A_NUMERIC || y->type == A_FORMULA))
               error_following(mpl, "*");
            if (x->type == A_FORMULA && y->type == A_FORMULA)
               error(mpl, "multiplication of linear forms not allowed");
            if (x->type == A_NUMERIC && y->type == A_NUMERIC)
               x = make_binary(mpl, O_MUL, x, y, A_NUMERIC, 0);
            else
               x = make_binary(mpl, O_MUL, x, y, A_FORMULA, 0);
         }
         else if (mpl->token == T_SLASH)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
               error_preceding(mpl, "/");
            get_token(mpl /* / */);
            y = expression_2(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type != A_NUMERIC)
               error_following(mpl, "/");
            if (x->type == A_NUMERIC)
               x = make_binary(mpl, O_DIV, x, y, A_NUMERIC, 0);
            else
               x = make_binary(mpl, O_DIV, x, y, A_FORMULA, 0);
         }
         else if (mpl->token == T_DIV)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type != A_NUMERIC)
               error_preceding(mpl, "div");
            get_token(mpl /* div */);
            y = expression_2(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type != A_NUMERIC)
               error_following(mpl, "div");
            x = make_binary(mpl, O_IDIV, x, y, A_NUMERIC, 0);
         }
         else if (mpl->token == T_MOD)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type != A_NUMERIC)
               error_preceding(mpl, "mod");
            get_token(mpl /* mod */);
            y = expression_2(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type != A_NUMERIC)
               error_following(mpl, "mod");
            x = make_binary(mpl, O_MOD, x, y, A_NUMERIC, 0);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_4 - parse expression of level 4.
--
-- This routine parses expression of level 4 using the syntax:
--
--  ::= 
--  ::=  + 
--  ::=  - 
--  ::=  less  */

CODE *expression_4(MPL *mpl)
{     CODE *x, *y;
      x = expression_3(mpl);
      for (;;)
      {  if (mpl->token == T_PLUS)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
               error_preceding(mpl, "+");
            get_token(mpl /* + */);
            y = expression_3(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (!(y->type == A_NUMERIC || y->type == A_FORMULA))
               error_following(mpl, "+");
            if (x->type == A_NUMERIC && y->type == A_FORMULA)
               x = make_unary(mpl, O_CVTLFM, x, A_FORMULA, 0);
            if (x->type == A_FORMULA && y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTLFM, y, A_FORMULA, 0);
            x = make_binary(mpl, O_ADD, x, y, x->type, 0);
         }
         else if (mpl->token == T_MINUS)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (!(x->type == A_NUMERIC || x->type == A_FORMULA))
               error_preceding(mpl, "-");
            get_token(mpl /* - */);
            y = expression_3(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (!(y->type == A_NUMERIC || y->type == A_FORMULA))
               error_following(mpl, "-");
            if (x->type == A_NUMERIC && y->type == A_FORMULA)
               x = make_unary(mpl, O_CVTLFM, x, A_FORMULA, 0);
            if (x->type == A_FORMULA && y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTLFM, y, A_FORMULA, 0);
            x = make_binary(mpl, O_SUB, x, y, x->type, 0);
         }
         else if (mpl->token == T_LESS)
         {  if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type != A_NUMERIC)
               error_preceding(mpl, "less");
            get_token(mpl /* less */);
            y = expression_3(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type != A_NUMERIC)
               error_following(mpl, "less");
            x = make_binary(mpl, O_LESS, x, y, A_NUMERIC, 0);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_5 - parse expression of level 5.
--
-- This routine parses expression of level 5 using the syntax:
--
--  ::= 
--  ::=  &  */

CODE *expression_5(MPL *mpl)
{     CODE *x, *y;
      x = expression_4(mpl);
      for (;;)
      {  if (mpl->token == T_CONCAT)
         {  if (x->type == A_NUMERIC)
               x = make_unary(mpl, O_CVTSYM, x, A_SYMBOLIC, 0);
            if (x->type != A_SYMBOLIC)
               error_preceding(mpl, "&");
            get_token(mpl /* & */);
            y = expression_4(mpl);
            if (y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTSYM, y, A_SYMBOLIC, 0);
            if (y->type != A_SYMBOLIC)
               error_following(mpl, "&");
            x = make_binary(mpl, O_CONCAT, x, y, A_SYMBOLIC, 0);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_6 - parse expression of level 6.
--
-- This routine parses expression of level 6 using the syntax:
--
--  ::= 
--  ::=  .. 
--  ::=  ..  by
--                     */

CODE *expression_6(MPL *mpl)
{     CODE *x, *y, *z;
      x = expression_5(mpl);
      if (mpl->token == T_DOTS)
      {  if (x->type == A_SYMBOLIC)
            x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
         if (x->type != A_NUMERIC)
            error_preceding(mpl, "..");
         get_token(mpl /* .. */);
         y = expression_5(mpl);
         if (y->type == A_SYMBOLIC)
            y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
         if (y->type != A_NUMERIC)
            error_following(mpl, "..");
         if (mpl->token == T_BY)
         {  get_token(mpl /* by */);
            z = expression_5(mpl);
            if (z->type == A_SYMBOLIC)
               z = make_unary(mpl, O_CVTNUM, z, A_NUMERIC, 0);
            if (z->type != A_NUMERIC)
               error_following(mpl, "by");
         }
         else
            z = NULL;
         x = make_ternary(mpl, O_DOTS, x, y, z, A_ELEMSET, 1);
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_7 - parse expression of level 7.
--
-- This routine parses expression of level 7 using the syntax:
--
--  ::= 
--  ::=  cross  */

CODE *expression_7(MPL *mpl)
{     CODE *x, *y;
      x = expression_6(mpl);
      for (;;)
      {  if (mpl->token == T_CROSS)
         {  if (x->type != A_ELEMSET)
               error_preceding(mpl, "cross");
            get_token(mpl /* cross */);
            y = expression_6(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, "cross");
            x = make_binary(mpl, O_CROSS, x, y, A_ELEMSET,
               x->dim + y->dim);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_8 - parse expression of level 8.
--
-- This routine parses expression of level 8 using the syntax:
--
--  ::= 
--  ::=  inter  */

CODE *expression_8(MPL *mpl)
{     CODE *x, *y;
      x = expression_7(mpl);
      for (;;)
      {  if (mpl->token == T_INTER)
         {  if (x->type != A_ELEMSET)
               error_preceding(mpl, "inter");
            get_token(mpl /* inter */);
            y = expression_7(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, "inter");
            if (x->dim != y->dim)
               error_dimension(mpl, "inter", x->dim, y->dim);
            x = make_binary(mpl, O_INTER, x, y, A_ELEMSET, x->dim);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_9 - parse expression of level 9.
--
-- This routine parses expression of level 9 using the syntax:
--
--  ::= 
--  ::=  union 
--  ::=  diff 
--  ::=  symdiff  */

CODE *expression_9(MPL *mpl)
{     CODE *x, *y;
      x = expression_8(mpl);
      for (;;)
      {  if (mpl->token == T_UNION)
         {  if (x->type != A_ELEMSET)
               error_preceding(mpl, "union");
            get_token(mpl /* union */);
            y = expression_8(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, "union");
            if (x->dim != y->dim)
               error_dimension(mpl, "union", x->dim, y->dim);
            x = make_binary(mpl, O_UNION, x, y, A_ELEMSET, x->dim);
         }
         else if (mpl->token == T_DIFF)
         {  if (x->type != A_ELEMSET)
               error_preceding(mpl, "diff");
            get_token(mpl /* diff */);
            y = expression_8(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, "diff");
            if (x->dim != y->dim)
               error_dimension(mpl, "diff", x->dim, y->dim);
            x = make_binary(mpl, O_DIFF, x, y, A_ELEMSET, x->dim);
         }
         else if (mpl->token == T_SYMDIFF)
         {  if (x->type != A_ELEMSET)
               error_preceding(mpl, "symdiff");
            get_token(mpl /* symdiff */);
            y = expression_8(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, "symdiff");
            if (x->dim != y->dim)
               error_dimension(mpl, "symdiff", x->dim, y->dim);
            x = make_binary(mpl, O_SYMDIFF, x, y, A_ELEMSET, x->dim);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_10 - parse expression of level 10.
--
-- This routine parses expression of level 10 using the syntax:
--
--  ::= 
--  ::=   
--  ::= < | <= | = | == | >= | > | <> | != | in | not in | ! in |
--           within | not within | ! within */

CODE *expression_10(MPL *mpl)
{     CODE *x, *y;
      int op = -1;
      char opstr[16];
      x = expression_9(mpl);
      strcpy(opstr, "");
      switch (mpl->token)
      {  case T_LT:
            op = O_LT; break;
         case T_LE:
            op = O_LE; break;
         case T_EQ:
            op = O_EQ; break;
         case T_GE:
            op = O_GE; break;
         case T_GT:
            op = O_GT; break;
         case T_NE:
            op = O_NE; break;
         case T_IN:
            op = O_IN; break;
         case T_WITHIN:
            op = O_WITHIN; break;
         case T_NOT:
            strcpy(opstr, mpl->image);
            get_token(mpl /* not | ! */);
            if (mpl->token == T_IN)
               op = O_NOTIN;
            else if (mpl->token == T_WITHIN)
               op = O_NOTWITHIN;
            else
               error(mpl, "invalid use of %s", opstr);
            strcat(opstr, " ");
            break;
         default:
            goto done;
      }
      strcat(opstr, mpl->image);
      xassert(strlen(opstr) < sizeof(opstr));
      switch (op)
      {  case O_EQ:
         case O_NE:
#if 1 /* 02/VIII-2008 */
         case O_LT:
         case O_LE:
         case O_GT:
         case O_GE:
#endif
            if (!(x->type == A_NUMERIC || x->type == A_SYMBOLIC))
               error_preceding(mpl, opstr);
            get_token(mpl /*  */);
            y = expression_9(mpl);
            if (!(y->type == A_NUMERIC || y->type == A_SYMBOLIC))
               error_following(mpl, opstr);
            if (x->type == A_NUMERIC && y->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTSYM, x, A_SYMBOLIC, 0);
            if (x->type == A_SYMBOLIC && y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTSYM, y, A_SYMBOLIC, 0);
            x = make_binary(mpl, op, x, y, A_LOGICAL, 0);
            break;
#if 0 /* 02/VIII-2008 */
         case O_LT:
         case O_LE:
         case O_GT:
         case O_GE:
            if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type != A_NUMERIC)
               error_preceding(mpl, opstr);
            get_token(mpl /*  */);
            y = expression_9(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type != A_NUMERIC)
               error_following(mpl, opstr);
            x = make_binary(mpl, op, x, y, A_LOGICAL, 0);
            break;
#endif
         case O_IN:
         case O_NOTIN:
            if (x->type == A_NUMERIC)
               x = make_unary(mpl, O_CVTSYM, x, A_SYMBOLIC, 0);
            if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTTUP, x, A_TUPLE, 1);
            if (x->type != A_TUPLE)
               error_preceding(mpl, opstr);
            get_token(mpl /*  */);
            y = expression_9(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, opstr);
            if (x->dim != y->dim)
               error_dimension(mpl, opstr, x->dim, y->dim);
            x = make_binary(mpl, op, x, y, A_LOGICAL, 0);
            break;
         case O_WITHIN:
         case O_NOTWITHIN:
            if (x->type != A_ELEMSET)
               error_preceding(mpl, opstr);
            get_token(mpl /*  */);
            y = expression_9(mpl);
            if (y->type != A_ELEMSET)
               error_following(mpl, opstr);
            if (x->dim != y->dim)
               error_dimension(mpl, opstr, x->dim, y->dim);
            x = make_binary(mpl, op, x, y, A_LOGICAL, 0);
            break;
         default:
            xassert(op != op);
      }
done: return x;
}

/*----------------------------------------------------------------------
-- expression_11 - parse expression of level 11.
--
-- This routine parses expression of level 11 using the syntax:
--
--  ::= 
--  ::= not 
--  ::= !  */

CODE *expression_11(MPL *mpl)
{     CODE *x;
      char opstr[8];
      if (mpl->token == T_NOT)
      {  strcpy(opstr, mpl->image);
         xassert(strlen(opstr) < sizeof(opstr));
         get_token(mpl /* not | ! */);
         x = expression_10(mpl);
         if (x->type == A_SYMBOLIC)
            x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
         if (x->type == A_NUMERIC)
            x = make_unary(mpl, O_CVTLOG, x, A_LOGICAL, 0);
         if (x->type != A_LOGICAL)
            error_following(mpl, opstr);
         x = make_unary(mpl, O_NOT, x, A_LOGICAL, 0);
      }
      else
         x = expression_10(mpl);
      return x;
}

/*----------------------------------------------------------------------
-- expression_12 - parse expression of level 12.
--
-- This routine parses expression of level 12 using the syntax:
--
--  ::= 
--  ::=  and 
--  ::=  &&  */

CODE *expression_12(MPL *mpl)
{     CODE *x, *y;
      char opstr[8];
      x = expression_11(mpl);
      for (;;)
      {  if (mpl->token == T_AND)
         {  strcpy(opstr, mpl->image);
            xassert(strlen(opstr) < sizeof(opstr));
            if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type == A_NUMERIC)
               x = make_unary(mpl, O_CVTLOG, x, A_LOGICAL, 0);
            if (x->type != A_LOGICAL)
               error_preceding(mpl, opstr);
            get_token(mpl /* and | && */);
            y = expression_11(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTLOG, y, A_LOGICAL, 0);
            if (y->type != A_LOGICAL)
               error_following(mpl, opstr);
            x = make_binary(mpl, O_AND, x, y, A_LOGICAL, 0);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- expression_13 - parse expression of level 13.
--
-- This routine parses expression of level 13 using the syntax:
--
--  ::= 
--  ::=  or 
--  ::=  ||  */

CODE *expression_13(MPL *mpl)
{     CODE *x, *y;
      char opstr[8];
      x = expression_12(mpl);
      for (;;)
      {  if (mpl->token == T_OR)
         {  strcpy(opstr, mpl->image);
            xassert(strlen(opstr) < sizeof(opstr));
            if (x->type == A_SYMBOLIC)
               x = make_unary(mpl, O_CVTNUM, x, A_NUMERIC, 0);
            if (x->type == A_NUMERIC)
               x = make_unary(mpl, O_CVTLOG, x, A_LOGICAL, 0);
            if (x->type != A_LOGICAL)
               error_preceding(mpl, opstr);
            get_token(mpl /* or | || */);
            y = expression_12(mpl);
            if (y->type == A_SYMBOLIC)
               y = make_unary(mpl, O_CVTNUM, y, A_NUMERIC, 0);
            if (y->type == A_NUMERIC)
               y = make_unary(mpl, O_CVTLOG, y, A_LOGICAL, 0);
            if (y->type != A_LOGICAL)
               error_following(mpl, opstr);
            x = make_binary(mpl, O_OR, x, y, A_LOGICAL, 0);
         }
         else
            break;
      }
      return x;
}

/*----------------------------------------------------------------------
-- set_statement - parse set statement.
--
-- This routine parses set statement using the syntax:
--
--  ::= set   
--                      ;
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  , dimen 
--  ::=  , within 
--  ::=  , := 
--  ::=  , default 
--
-- Commae in  are optional and may be omitted anywhere. */

SET *set_statement(MPL *mpl)
{     SET *set;
      int dimen_used = 0;
      xassert(is_keyword(mpl, "set"));
      get_token(mpl /* set */);
      /* symbolic name must follow the keyword 'set' */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create model set */
      set = alloc(SET);
      set->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(set->name, mpl->image);
      set->alias = NULL;
      set->dim = 0;
      set->domain = NULL;
      set->dimen = 0;
      set->within = NULL;
      set->assign = NULL;
      set->option = NULL;
      set->gadget = NULL;
      set->data = 0;
      set->array = NULL;
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  set->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(set->alias, mpl->image);
         get_token(mpl /*  */);
      }
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  set->domain = indexing_expression(mpl);
         set->dim = domain_arity(mpl, set->domain);
      }
      /* include the set name in the symbolic names table */
      {  AVLNODE *node;
         node = avl_insert_node(mpl->tree, set->name);
         avl_set_node_type(node, A_SET);
         avl_set_node_link(node, (void *)set);
      }
      /* parse the list of optional attributes */
      for (;;)
      {  if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_SEMICOLON)
            break;
         if (is_keyword(mpl, "dimen"))
         {  /* dimension of set members */
            int dimen;
            get_token(mpl /* dimen */);
            if (!(mpl->token == T_NUMBER &&
                  1.0 <= mpl->value && mpl->value <= 20.0 &&
                  floor(mpl->value) == mpl->value))
               error(mpl, "dimension must be integer between 1 and 20");
            dimen = (int)(mpl->value + 0.5);
            if (dimen_used)
               error(mpl, "at most one dimension attribute allowed");
            if (set->dimen > 0)
               error(mpl, "dimension %d conflicts with dimension %d alr"
                  "eady determined", dimen, set->dimen);
            set->dimen = dimen;
            dimen_used = 1;
            get_token(mpl /*  */);
         }
         else if (mpl->token == T_WITHIN || mpl->token == T_IN)
         {  /* restricting superset */
            WITHIN *within, *temp;
            if (mpl->token == T_IN && !mpl->as_within)
            {  warning(mpl, "keyword in understood as within");
               mpl->as_within = 1;
            }
            get_token(mpl /* within */);
            /* create new restricting superset list entry and append it
               to the within-list */
            within = alloc(WITHIN);
            within->code = NULL;
            within->next = NULL;
            if (set->within == NULL)
               set->within = within;
            else
            {  for (temp = set->within; temp->next != NULL; temp =
                  temp->next);
               temp->next = within;
            }
            /* parse an expression that follows 'within' */
            within->code = expression_9(mpl);
            if (within->code->type != A_ELEMSET)
               error(mpl, "expression following within has invalid type"
                  );
            xassert(within->code->dim > 0);
            /* check/set dimension of set members */
            if (set->dimen == 0) set->dimen = within->code->dim;
            if (set->dimen != within->code->dim)
               error(mpl, "set expression following within must have di"
                  "mension %d rather than %d",
                  set->dimen, within->code->dim);
         }
         else if (mpl->token == T_ASSIGN)
         {  /* assignment expression */
            if (!(set->assign == NULL && set->option == NULL &&
                  set->gadget == NULL))
err:           error(mpl, "at most one := or default/data allowed");
            get_token(mpl /* := */);
            /* parse an expression that follows ':=' */
            set->assign = expression_9(mpl);
            if (set->assign->type != A_ELEMSET)
               error(mpl, "expression following := has invalid type");
            xassert(set->assign->dim > 0);
            /* check/set dimension of set members */
            if (set->dimen == 0) set->dimen = set->assign->dim;
            if (set->dimen != set->assign->dim)
               error(mpl, "set expression following := must have dimens"
                  "ion %d rather than %d",
                  set->dimen, set->assign->dim);
         }
         else if (is_keyword(mpl, "default"))
         {  /* expression for default value */
            if (!(set->assign == NULL && set->option == NULL)) goto err;
            get_token(mpl /* := */);
            /* parse an expression that follows 'default' */
            set->option = expression_9(mpl);
            if (set->option->type != A_ELEMSET)
               error(mpl, "expression following default has invalid typ"
                  "e");
            xassert(set->option->dim > 0);
            /* check/set dimension of set members */
            if (set->dimen == 0) set->dimen = set->option->dim;
            if (set->dimen != set->option->dim)
               error(mpl, "set expression following default must have d"
                  "imension %d rather than %d",
                  set->dimen, set->option->dim);
         }
#if 1 /* 12/XII-2008 */
         else if (is_keyword(mpl, "data"))
         {  /* gadget to initialize the set by data from plain set */
            GADGET *gadget;
            AVLNODE *node;
            int i, k, fff[20];
            if (!(set->assign == NULL && set->gadget == NULL)) goto err;
            get_token(mpl /* data */);
            set->gadget = gadget = alloc(GADGET);
            /* set name must follow the keyword 'data' */
            if (mpl->token == T_NAME)
               ;
            else if (is_reserved(mpl))
               error(mpl, "invalid use of reserved keyword %s",
                  mpl->image);
            else
               error(mpl, "set name missing where expected");
            /* find the set in the symbolic name table */
            node = avl_find_node(mpl->tree, mpl->image);
            if (node == NULL)
               error(mpl, "%s not defined", mpl->image);
            if (avl_get_node_type(node) != A_SET)
err1:          error(mpl, "%s not a plain set", mpl->image);
            gadget->set = avl_get_node_link(node);
            if (gadget->set->dim != 0) goto err1;
            if (gadget->set == set)
               error(mpl, "set cannot be initialized by itself");
            /* check and set dimensions */
            if (set->dim >= gadget->set->dimen)
err2:          error(mpl, "dimension of %s too small", mpl->image);
            if (set->dimen == 0)
               set->dimen = gadget->set->dimen - set->dim;
            if (set->dim + set->dimen > gadget->set->dimen)
               goto err2;
            else if (set->dim + set->dimen < gadget->set->dimen)
               error(mpl, "dimension of %s too big", mpl->image);
            get_token(mpl /* set name */);
            /* left parenthesis must follow the set name */
            if (mpl->token == T_LEFT)
               get_token(mpl /* ( */);
            else
               error(mpl, "left parenthesis missing where expected");
            /* parse permutation of component numbers */
            for (k = 0; k < gadget->set->dimen; k++) fff[k] = 0;
            k = 0;
            for (;;)
            {  if (mpl->token != T_NUMBER)
                  error(mpl, "component number missing where expected");
               if (str2int(mpl->image, &i) != 0)
err3:             error(mpl, "component number must be integer between "
                     "1 and %d", gadget->set->dimen);
               if (!(1 <= i && i <= gadget->set->dimen)) goto err3;
               if (fff[i-1] != 0)
                  error(mpl, "component %d multiply specified", i);
               gadget->ind[k++] = i, fff[i-1] = 1;
               xassert(k <= gadget->set->dimen);
               get_token(mpl /* number */);
               if (mpl->token == T_COMMA)
                  get_token(mpl /* , */);
               else if (mpl->token == T_RIGHT)
                  break;
               else
                  error(mpl, "syntax error in data attribute");
            }
            if (k < gadget->set->dimen)
               error(mpl, "there are must be %d components rather than "
                  "%d", gadget->set->dimen, k);
            get_token(mpl /* ) */);
         }
#endif
         else
            error(mpl, "syntax error in set statement");
      }
      /* close the domain scope */
      if (set->domain != NULL) close_scope(mpl, set->domain);
      /* if dimension of set members is still unknown, set it to 1 */
      if (set->dimen == 0) set->dimen = 1;
      /* the set statement has been completely parsed */
      xassert(mpl->token == T_SEMICOLON);
      get_token(mpl /* ; */);
      return set;
}

/*----------------------------------------------------------------------
-- parameter_statement - parse parameter statement.
--
-- This routine parses parameter statement using the syntax:
--
--  ::= param   
--                            ;
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  , integer
--  ::=  , binary
--  ::=  , symbolic
--  ::=  ,  
--  ::=  , in 
--  ::=  , := 
--  ::=  , default 
--  ::= < | <= | = | == | >= | > | <> | !=
--
-- Commae in  are optional and may be omitted anywhere. */

PARAMETER *parameter_statement(MPL *mpl)
{     PARAMETER *par;
      int integer_used = 0, binary_used = 0, symbolic_used = 0;
      xassert(is_keyword(mpl, "param"));
      get_token(mpl /* param */);
      /* symbolic name must follow the keyword 'param' */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create model parameter */
      par = alloc(PARAMETER);
      par->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(par->name, mpl->image);
      par->alias = NULL;
      par->dim = 0;
      par->domain = NULL;
      par->type = A_NUMERIC;
      par->cond = NULL;
      par->in = NULL;
      par->assign = NULL;
      par->option = NULL;
      par->data = 0;
      par->defval = NULL;
      par->array = NULL;
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  par->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(par->alias, mpl->image);
         get_token(mpl /*  */);
      }
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  par->domain = indexing_expression(mpl);
         par->dim = domain_arity(mpl, par->domain);
      }
      /* include the parameter name in the symbolic names table */
      {  AVLNODE *node;
         node = avl_insert_node(mpl->tree, par->name);
         avl_set_node_type(node, A_PARAMETER);
         avl_set_node_link(node, (void *)par);
      }
      /* parse the list of optional attributes */
      for (;;)
      {  if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_SEMICOLON)
            break;
         if (is_keyword(mpl, "integer"))
         {  if (integer_used)
               error(mpl, "at most one integer allowed");
            if (par->type == A_SYMBOLIC)
               error(mpl, "symbolic parameter cannot be integer");
            if (par->type != A_BINARY) par->type = A_INTEGER;
            integer_used = 1;
            get_token(mpl /* integer */);
         }
         else if (is_keyword(mpl, "binary"))
bin:     {  if (binary_used)
               error(mpl, "at most one binary allowed");
            if (par->type == A_SYMBOLIC)
               error(mpl, "symbolic parameter cannot be binary");
            par->type = A_BINARY;
            binary_used = 1;
            get_token(mpl /* binary */);
         }
         else if (is_keyword(mpl, "logical"))
         {  if (!mpl->as_binary)
            {  warning(mpl, "keyword logical understood as binary");
               mpl->as_binary = 1;
            }
            goto bin;
         }
         else if (is_keyword(mpl, "symbolic"))
         {  if (symbolic_used)
               error(mpl, "at most one symbolic allowed");
            if (par->type != A_NUMERIC)
               error(mpl, "integer or binary parameter cannot be symbol"
                  "ic");
            /* the parameter may be referenced from expressions given
               in the same parameter declaration, so its type must be
               completed before parsing that expressions */
            if (!(par->cond == NULL && par->in == NULL &&
                  par->assign == NULL && par->option == NULL))
               error(mpl, "keyword symbolic must precede any other para"
                  "meter attributes");
            par->type = A_SYMBOLIC;
            symbolic_used = 1;
            get_token(mpl /* symbolic */);
         }
         else if (mpl->token == T_LT || mpl->token == T_LE ||
                  mpl->token == T_EQ || mpl->token == T_GE ||
                  mpl->token == T_GT || mpl->token == T_NE)
         {  /* restricting condition */
            CONDITION *cond, *temp;
            char opstr[8];
            /* create new restricting condition list entry and append
               it to the conditions list */
            cond = alloc(CONDITION);
            switch (mpl->token)
            {  case T_LT:
                  cond->rho = O_LT, strcpy(opstr, mpl->image); break;
               case T_LE:
                  cond->rho = O_LE, strcpy(opstr, mpl->image); break;
               case T_EQ:
                  cond->rho = O_EQ, strcpy(opstr, mpl->image); break;
               case T_GE:
                  cond->rho = O_GE, strcpy(opstr, mpl->image); break;
               case T_GT:
                  cond->rho = O_GT, strcpy(opstr, mpl->image); break;
               case T_NE:
                  cond->rho = O_NE, strcpy(opstr, mpl->image); break;
               default:
                  xassert(mpl->token != mpl->token);
            }
            xassert(strlen(opstr) < sizeof(opstr));
            cond->code = NULL;
            cond->next = NULL;
            if (par->cond == NULL)
               par->cond = cond;
            else
            {  for (temp = par->cond; temp->next != NULL; temp =
                  temp->next);
               temp->next = cond;
            }
#if 0 /* 13/VIII-2008 */
            if (par->type == A_SYMBOLIC &&
               !(cond->rho == O_EQ || cond->rho == O_NE))
               error(mpl, "inequality restriction not allowed");
#endif
            get_token(mpl /* rho */);
            /* parse an expression that follows relational operator */
            cond->code = expression_5(mpl);
            if (!(cond->code->type == A_NUMERIC ||
                  cond->code->type == A_SYMBOLIC))
               error(mpl, "expression following %s has invalid type",
                  opstr);
            xassert(cond->code->dim == 0);
            /* convert to the parameter type, if necessary */
            if (par->type != A_SYMBOLIC && cond->code->type ==
               A_SYMBOLIC)
               cond->code = make_unary(mpl, O_CVTNUM, cond->code,
                  A_NUMERIC, 0);
            if (par->type == A_SYMBOLIC && cond->code->type !=
               A_SYMBOLIC)
               cond->code = make_unary(mpl, O_CVTSYM, cond->code,
                  A_SYMBOLIC, 0);
         }
         else if (mpl->token == T_IN || mpl->token == T_WITHIN)
         {  /* restricting superset */
            WITHIN *in, *temp;
            if (mpl->token == T_WITHIN && !mpl->as_in)
            {  warning(mpl, "keyword within understood as in");
               mpl->as_in = 1;
            }
            get_token(mpl /* in */);
            /* create new restricting superset list entry and append it
               to the in-list */
            in = alloc(WITHIN);
            in->code = NULL;
            in->next = NULL;
            if (par->in == NULL)
               par->in = in;
            else
            {  for (temp = par->in; temp->next != NULL; temp =
                  temp->next);
               temp->next = in;
            }
            /* parse an expression that follows 'in' */
            in->code = expression_9(mpl);
            if (in->code->type != A_ELEMSET)
               error(mpl, "expression following in has invalid type");
            xassert(in->code->dim > 0);
            if (in->code->dim != 1)
               error(mpl, "set expression following in must have dimens"
                  "ion 1 rather than %d", in->code->dim);
         }
         else if (mpl->token == T_ASSIGN)
         {  /* assignment expression */
            if (!(par->assign == NULL && par->option == NULL))
err:           error(mpl, "at most one := or default allowed");
            get_token(mpl /* := */);
            /* parse an expression that follows ':=' */
            par->assign = expression_5(mpl);
            /* the expression must be of numeric/symbolic type */
            if (!(par->assign->type == A_NUMERIC ||
                  par->assign->type == A_SYMBOLIC))
               error(mpl, "expression following := has invalid type");
            xassert(par->assign->dim == 0);
            /* convert to the parameter type, if necessary */
            if (par->type != A_SYMBOLIC && par->assign->type ==
               A_SYMBOLIC)
               par->assign = make_unary(mpl, O_CVTNUM, par->assign,
                  A_NUMERIC, 0);
            if (par->type == A_SYMBOLIC && par->assign->type !=
               A_SYMBOLIC)
               par->assign = make_unary(mpl, O_CVTSYM, par->assign,
                  A_SYMBOLIC, 0);
         }
         else if (is_keyword(mpl, "default"))
         {  /* expression for default value */
            if (!(par->assign == NULL && par->option == NULL)) goto err;
            get_token(mpl /* default */);
            /* parse an expression that follows 'default' */
            par->option = expression_5(mpl);
            if (!(par->option->type == A_NUMERIC ||
                  par->option->type == A_SYMBOLIC))
               error(mpl, "expression following default has invalid typ"
                  "e");
            xassert(par->option->dim == 0);
            /* convert to the parameter type, if necessary */
            if (par->type != A_SYMBOLIC && par->option->type ==
               A_SYMBOLIC)
               par->option = make_unary(mpl, O_CVTNUM, par->option,
                  A_NUMERIC, 0);
            if (par->type == A_SYMBOLIC && par->option->type !=
               A_SYMBOLIC)
               par->option = make_unary(mpl, O_CVTSYM, par->option,
                  A_SYMBOLIC, 0);
         }
         else
            error(mpl, "syntax error in parameter statement");
      }
      /* close the domain scope */
      if (par->domain != NULL) close_scope(mpl, par->domain);
      /* the parameter statement has been completely parsed */
      xassert(mpl->token == T_SEMICOLON);
      get_token(mpl /* ; */);
      return par;
}

/*----------------------------------------------------------------------
-- variable_statement - parse variable statement.
--
-- This routine parses variable statement using the syntax:
--
--  ::= var   
--                           ;
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  , integer
--  ::=  , binary
--  ::=  ,  
--  ::= >= | <= | = | ==
--
-- Commae in  are optional and may be omitted anywhere. */

VARIABLE *variable_statement(MPL *mpl)
{     VARIABLE *var;
      int integer_used = 0, binary_used = 0;
      xassert(is_keyword(mpl, "var"));
      if (mpl->flag_s)
         error(mpl, "variable statement must precede solve statement");
      get_token(mpl /* var */);
      /* symbolic name must follow the keyword 'var' */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create model variable */
      var = alloc(VARIABLE);
      var->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(var->name, mpl->image);
      var->alias = NULL;
      var->dim = 0;
      var->domain = NULL;
      var->type = A_NUMERIC;
      var->lbnd = NULL;
      var->ubnd = NULL;
      var->array = NULL;
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  var->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(var->alias, mpl->image);
         get_token(mpl /*  */);
      }
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  var->domain = indexing_expression(mpl);
         var->dim = domain_arity(mpl, var->domain);
      }
      /* include the variable name in the symbolic names table */
      {  AVLNODE *node;
         node = avl_insert_node(mpl->tree, var->name);
         avl_set_node_type(node, A_VARIABLE);
         avl_set_node_link(node, (void *)var);
      }
      /* parse the list of optional attributes */
      for (;;)
      {  if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_SEMICOLON)
            break;
         if (is_keyword(mpl, "integer"))
         {  if (integer_used)
               error(mpl, "at most one integer allowed");
            if (var->type != A_BINARY) var->type = A_INTEGER;
            integer_used = 1;
            get_token(mpl /* integer */);
         }
         else if (is_keyword(mpl, "binary"))
bin:     {  if (binary_used)
               error(mpl, "at most one binary allowed");
            var->type = A_BINARY;
            binary_used = 1;
            get_token(mpl /* binary */);
         }
         else if (is_keyword(mpl, "logical"))
         {  if (!mpl->as_binary)
            {  warning(mpl, "keyword logical understood as binary");
               mpl->as_binary = 1;
            }
            goto bin;
         }
         else if (is_keyword(mpl, "symbolic"))
            error(mpl, "variable cannot be symbolic");
         else if (mpl->token == T_GE)
         {  /* lower bound */
            if (var->lbnd != NULL)
            {  if (var->lbnd == var->ubnd)
                  error(mpl, "both fixed value and lower bound not allo"
                     "wed");
               else
                  error(mpl, "at most one lower bound allowed");
            }
            get_token(mpl /* >= */);
            /* parse an expression that specifies the lower bound */
            var->lbnd = expression_5(mpl);
            if (var->lbnd->type == A_SYMBOLIC)
               var->lbnd = make_unary(mpl, O_CVTNUM, var->lbnd,
                  A_NUMERIC, 0);
            if (var->lbnd->type != A_NUMERIC)
               error(mpl, "expression following >= has invalid type");
            xassert(var->lbnd->dim == 0);
         }
         else if (mpl->token == T_LE)
         {  /* upper bound */
            if (var->ubnd != NULL)
            {  if (var->ubnd == var->lbnd)
                  error(mpl, "both fixed value and upper bound not allo"
                     "wed");
               else
                  error(mpl, "at most one upper bound allowed");
            }
            get_token(mpl /* <= */);
            /* parse an expression that specifies the upper bound */
            var->ubnd = expression_5(mpl);
            if (var->ubnd->type == A_SYMBOLIC)
               var->ubnd = make_unary(mpl, O_CVTNUM, var->ubnd,
                  A_NUMERIC, 0);
            if (var->ubnd->type != A_NUMERIC)
               error(mpl, "expression following <= has invalid type");
            xassert(var->ubnd->dim == 0);
         }
         else if (mpl->token == T_EQ)
         {  /* fixed value */
            char opstr[8];
            if (!(var->lbnd == NULL && var->ubnd == NULL))
            {  if (var->lbnd == var->ubnd)
                  error(mpl, "at most one fixed value allowed");
               else if (var->lbnd != NULL)
                  error(mpl, "both lower bound and fixed value not allo"
                     "wed");
               else
                  error(mpl, "both upper bound and fixed value not allo"
                     "wed");
            }
            strcpy(opstr, mpl->image);
            xassert(strlen(opstr) < sizeof(opstr));
            get_token(mpl /* = | == */);
            /* parse an expression that specifies the fixed value */
            var->lbnd = expression_5(mpl);
            if (var->lbnd->type == A_SYMBOLIC)
               var->lbnd = make_unary(mpl, O_CVTNUM, var->lbnd,
                  A_NUMERIC, 0);
            if (var->lbnd->type != A_NUMERIC)
               error(mpl, "expression following %s has invalid type",
                  opstr);
            xassert(var->lbnd->dim == 0);
            /* indicate that the variable is fixed, not bounded */
            var->ubnd = var->lbnd;
         }
         else if (mpl->token == T_LT || mpl->token == T_GT ||
                  mpl->token == T_NE)
            error(mpl, "strict bound not allowed");
         else
            error(mpl, "syntax error in variable statement");
      }
      /* close the domain scope */
      if (var->domain != NULL) close_scope(mpl, var->domain);
      /* the variable statement has been completely parsed */
      xassert(mpl->token == T_SEMICOLON);
      get_token(mpl /* ; */);
      return var;
}

/*----------------------------------------------------------------------
-- constraint_statement - parse constraint statement.
--
-- This routine parses constraint statement using the syntax:
--
--  ::=   
--                             :  ;
--  ::= 
--  ::= subject to
--  ::= subj to
--  ::= s.t.
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  , >= 
--  ::=  , <= 
--  ::=  , = 
--  ::=  , <=  , <= 
--  ::=  , >=  , >= 
--  ::= 
--
-- Commae in  are optional and may be omitted anywhere. */

CONSTRAINT *constraint_statement(MPL *mpl)
{     CONSTRAINT *con;
      CODE *first, *second, *third;
      int rho;
      char opstr[8];
      if (mpl->flag_s)
         error(mpl, "constraint statement must precede solve statement")
            ;
      if (is_keyword(mpl, "subject"))
      {  get_token(mpl /* subject */);
         if (!is_keyword(mpl, "to"))
            error(mpl, "keyword subject to incomplete");
         get_token(mpl /* to */);
      }
      else if (is_keyword(mpl, "subj"))
      {  get_token(mpl /* subj */);
         if (!is_keyword(mpl, "to"))
            error(mpl, "keyword subj to incomplete");
         get_token(mpl /* to */);
      }
      else if (mpl->token == T_SPTP)
         get_token(mpl /* s.t. */);
      /* the current token must be symbolic name of constraint */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create model constraint */
      con = alloc(CONSTRAINT);
      con->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(con->name, mpl->image);
      con->alias = NULL;
      con->dim = 0;
      con->domain = NULL;
      con->type = A_CONSTRAINT;
      con->code = NULL;
      con->lbnd = NULL;
      con->ubnd = NULL;
      con->array = NULL;
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  con->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(con->alias, mpl->image);
         get_token(mpl /*  */);
      }
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  con->domain = indexing_expression(mpl);
         con->dim = domain_arity(mpl, con->domain);
      }
      /* include the constraint name in the symbolic names table */
      {  AVLNODE *node;
         node = avl_insert_node(mpl->tree, con->name);
         avl_set_node_type(node, A_CONSTRAINT);
         avl_set_node_link(node, (void *)con);
      }
      /* the colon must precede the first expression */
      if (mpl->token != T_COLON)
         error(mpl, "colon missing where expected");
      get_token(mpl /* : */);
      /* parse the first expression */
      first = expression_5(mpl);
      if (first->type == A_SYMBOLIC)
         first = make_unary(mpl, O_CVTNUM, first, A_NUMERIC, 0);
      if (!(first->type == A_NUMERIC || first->type == A_FORMULA))
         error(mpl, "expression following colon has invalid type");
      xassert(first->dim == 0);
      /* relational operator must follow the first expression */
      if (mpl->token == T_COMMA) get_token(mpl /* , */);
      switch (mpl->token)
      {  case T_LE:
         case T_GE:
         case T_EQ:
            break;
         case T_LT:
         case T_GT:
         case T_NE:
            error(mpl, "strict inequality not allowed");
         case T_SEMICOLON:
            error(mpl, "constraint must be equality or inequality");
         default:
            goto err;
      }
      rho = mpl->token;
      strcpy(opstr, mpl->image);
      xassert(strlen(opstr) < sizeof(opstr));
      get_token(mpl /* rho */);
      /* parse the second expression */
      second = expression_5(mpl);
      if (second->type == A_SYMBOLIC)
         second = make_unary(mpl, O_CVTNUM, second, A_NUMERIC, 0);
      if (!(second->type == A_NUMERIC || second->type == A_FORMULA))
         error(mpl, "expression following %s has invalid type", opstr);
      xassert(second->dim == 0);
      /* check a token that follow the second expression */
      if (mpl->token == T_COMMA)
      {  get_token(mpl /* , */);
         if (mpl->token == T_SEMICOLON) goto err;
      }
      if (mpl->token == T_LT || mpl->token == T_LE ||
          mpl->token == T_EQ || mpl->token == T_GE ||
          mpl->token == T_GT || mpl->token == T_NE)
      {  /* it is another relational operator, therefore the constraint
            is double inequality */
         if (rho == T_EQ || mpl->token != rho)
            error(mpl, "double inequality must be ... <= ... <= ... or "
               "... >= ... >= ...");
         /* the first expression cannot be linear form */
         if (first->type == A_FORMULA)
            error(mpl, "leftmost expression in double inequality cannot"
               " be linear form");
         get_token(mpl /* rho */);
         /* parse the third expression */
         third = expression_5(mpl);
         if (third->type == A_SYMBOLIC)
            third = make_unary(mpl, O_CVTNUM, second, A_NUMERIC, 0);
         if (!(third->type == A_NUMERIC || third->type == A_FORMULA))
            error(mpl, "rightmost expression in double inequality const"
               "raint has invalid type");
         xassert(third->dim == 0);
         /* the third expression also cannot be linear form */
         if (third->type == A_FORMULA)
            error(mpl, "rightmost expression in double inequality canno"
               "t be linear form");
      }
      else
      {  /* the constraint is equality or single inequality */
         third = NULL;
      }
      /* close the domain scope */
      if (con->domain != NULL) close_scope(mpl, con->domain);
      /* convert all expressions to linear form, if necessary */
      if (first->type != A_FORMULA)
         first = make_unary(mpl, O_CVTLFM, first, A_FORMULA, 0);
      if (second->type != A_FORMULA)
         second = make_unary(mpl, O_CVTLFM, second, A_FORMULA, 0);
      if (third != NULL)
         third = make_unary(mpl, O_CVTLFM, third, A_FORMULA, 0);
      /* arrange expressions in the constraint */
      if (third == NULL)
      {  /* the constraint is equality or single inequality */
         switch (rho)
         {  case T_LE:
               /* first <= second */
               con->code = first;
               con->lbnd = NULL;
               con->ubnd = second;
               break;
            case T_GE:
               /* first >= second */
               con->code = first;
               con->lbnd = second;
               con->ubnd = NULL;
               break;
            case T_EQ:
               /* first = second */
               con->code = first;
               con->lbnd = second;
               con->ubnd = second;
               break;
            default:
               xassert(rho != rho);
         }
      }
      else
      {  /* the constraint is double inequality */
         switch (rho)
         {  case T_LE:
               /* first <= second <= third */
               con->code = second;
               con->lbnd = first;
               con->ubnd = third;
               break;
            case T_GE:
               /* first >= second >= third */
               con->code = second;
               con->lbnd = third;
               con->ubnd = first;
               break;
            default:
               xassert(rho != rho);
         }
      }
      /* the constraint statement has been completely parsed */
      if (mpl->token != T_SEMICOLON)
err:     error(mpl, "syntax error in constraint statement");
      get_token(mpl /* ; */);
      return con;
}

/*----------------------------------------------------------------------
-- objective_statement - parse objective statement.
--
-- This routine parses objective statement using the syntax:
--
--  ::=     :
--                            ;
--  ::= minimize
--  ::= maximize
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  */

CONSTRAINT *objective_statement(MPL *mpl)
{     CONSTRAINT *obj;
      int type;
      if (is_keyword(mpl, "minimize"))
         type = A_MINIMIZE;
      else if (is_keyword(mpl, "maximize"))
         type = A_MAXIMIZE;
      else
         xassert(mpl != mpl);
      if (mpl->flag_s)
         error(mpl, "objective statement must precede solve statement");
      get_token(mpl /* minimize | maximize */);
      /* symbolic name must follow the verb 'minimize' or 'maximize' */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create model objective */
      obj = alloc(CONSTRAINT);
      obj->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(obj->name, mpl->image);
      obj->alias = NULL;
      obj->dim = 0;
      obj->domain = NULL;
      obj->type = type;
      obj->code = NULL;
      obj->lbnd = NULL;
      obj->ubnd = NULL;
      obj->array = NULL;
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  obj->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(obj->alias, mpl->image);
         get_token(mpl /*  */);
      }
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  obj->domain = indexing_expression(mpl);
         obj->dim = domain_arity(mpl, obj->domain);
      }
      /* include the constraint name in the symbolic names table */
      {  AVLNODE *node;
         node = avl_insert_node(mpl->tree, obj->name);
         avl_set_node_type(node, A_CONSTRAINT);
         avl_set_node_link(node, (void *)obj);
      }
      /* the colon must precede the objective expression */
      if (mpl->token != T_COLON)
         error(mpl, "colon missing where expected");
      get_token(mpl /* : */);
      /* parse the objective expression */
      obj->code = expression_5(mpl);
      if (obj->code->type == A_SYMBOLIC)
         obj->code = make_unary(mpl, O_CVTNUM, obj->code, A_NUMERIC, 0);
      if (obj->code->type == A_NUMERIC)
         obj->code = make_unary(mpl, O_CVTLFM, obj->code, A_FORMULA, 0);
      if (obj->code->type != A_FORMULA)
         error(mpl, "expression following colon has invalid type");
      xassert(obj->code->dim == 0);
      /* close the domain scope */
      if (obj->domain != NULL) close_scope(mpl, obj->domain);
      /* the objective statement has been completely parsed */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in objective statement");
      get_token(mpl /* ; */);
      return obj;
}

#if 1 /* 11/II-2008 */
/***********************************************************************
*  table_statement - parse table statement
*
*  This routine parses table statement using the syntax:
*
*   ::= 
*  
 ::= 
*
*   ::=
*        table 
 IN  :
*         [  ] ,  ;
*   ::= 
*   ::= 
*   ::= 
*   ::=  
*   ::=  , 
*   ::= 
*   ::=  <-
*   ::= 
*   ::=  , 
*   ::= 
*   ::=  , 
*   ::= 
*   ::=  ~ 
*
*   ::=
*        table 
 
  OUT  :
*         ;
*   ::= 
*   ::= 
*   ::=  , 
*   ::= 
*   ::=  ~  */

TABLE *table_statement(MPL *mpl)
{     TABLE *tab;
      TABARG *last_arg, *arg;
      TABFLD *last_fld, *fld;
      TABIN *last_in, *in;
      TABOUT *last_out, *out;
      AVLNODE *node;
      int nflds;
      char name[MAX_LENGTH+1];
      xassert(is_keyword(mpl, "table"));
      get_token(mpl /* solve */);
      /* symbolic name must follow the keyword table */
      if (mpl->token == T_NAME)
         ;
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "symbolic name missing where expected");
      /* there must be no other object with the same name */
      if (avl_find_node(mpl->tree, mpl->image) != NULL)
         error(mpl, "%s multiply declared", mpl->image);
      /* create data table */
      tab = alloc(TABLE);
      tab->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
      strcpy(tab->name, mpl->image);
      get_token(mpl /*  */);
      /* parse optional alias */
      if (mpl->token == T_STRING)
      {  tab->alias = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(tab->alias, mpl->image);
         get_token(mpl /*  */);
      }
      else
         tab->alias = NULL;
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  /* this is output table */
         tab->type = A_OUTPUT;
         tab->u.out.domain = indexing_expression(mpl);
         if (!is_keyword(mpl, "OUT"))
            error(mpl, "keyword OUT missing where expected");
         get_token(mpl /* OUT */);
      }
      else
      {  /* this is input table */
         tab->type = A_INPUT;
         if (!is_keyword(mpl, "IN"))
            error(mpl, "keyword IN missing where expected");
         get_token(mpl /* IN */);
      }
      /* parse argument list */
      tab->arg = last_arg = NULL;
      for (;;)
      {  /* create argument list entry */
         arg = alloc(TABARG);
         /* parse argument expression */
         if (mpl->token == T_COMMA || mpl->token == T_COLON ||
             mpl->token == T_SEMICOLON)
            error(mpl, "argument expression missing where expected");
         arg->code = expression_5(mpl);
         /* convert the result to symbolic type, if necessary */
         if (arg->code->type == A_NUMERIC)
            arg->code =
               make_unary(mpl, O_CVTSYM, arg->code, A_SYMBOLIC, 0);
         /* check that now the result is of symbolic type */
         if (arg->code->type != A_SYMBOLIC)
            error(mpl, "argument expression has invalid type");
         /* add the entry to the end of the list */
         arg->next = NULL;
         if (last_arg == NULL)
            tab->arg = arg;
         else
            last_arg->next = arg;
         last_arg = arg;
         /* argument expression has been parsed */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_COLON || mpl->token == T_SEMICOLON)
            break;
      }
      xassert(tab->arg != NULL);
      /* argument list must end with colon */
      if (mpl->token == T_COLON)
         get_token(mpl /* : */);
      else
         error(mpl, "colon missing where expected");
      /* parse specific part of the table statement */
      switch (tab->type)
      {  case A_INPUT:  goto input_table;
         case A_OUTPUT: goto output_table;
         default:       xassert(tab != tab);
      }
input_table:
      /* parse optional set name */
      if (mpl->token == T_NAME)
      {  node = avl_find_node(mpl->tree, mpl->image);
         if (node == NULL)
            error(mpl, "%s not defined", mpl->image);
         if (avl_get_node_type(node) != A_SET)
            error(mpl, "%s not a set", mpl->image);
         tab->u.in.set = (SET *)avl_get_node_link(node);
         if (tab->u.in.set->assign != NULL)
            error(mpl, "%s needs no data", mpl->image);
         if (tab->u.in.set->dim != 0)
            error(mpl, "%s must be a simple set", mpl->image);
         get_token(mpl /*  */);
         if (mpl->token == T_INPUT)
            get_token(mpl /* <- */);
         else
            error(mpl, "delimiter <- missing where expected");
      }
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         tab->u.in.set = NULL;
      /* parse field list */
      tab->u.in.fld = last_fld = NULL;
      nflds = 0;
      if (mpl->token == T_LBRACKET)
         get_token(mpl /* [ */);
      else
         error(mpl, "field list missing where expected");
      for (;;)
      {  /* create field list entry */
         fld = alloc(TABFLD);
         /* parse field name */
         if (mpl->token == T_NAME)
            ;
         else if (is_reserved(mpl))
            error(mpl,
               "invalid use of reserved keyword %s", mpl->image);
         else
            error(mpl, "field name missing where expected");
         fld->name = dmp_get_atomv(mpl->pool, strlen(mpl->image)+1);
         strcpy(fld->name, mpl->image);
         get_token(mpl /*  */);
         /* add the entry to the end of the list */
         fld->next = NULL;
         if (last_fld == NULL)
            tab->u.in.fld = fld;
         else
            last_fld->next = fld;
         last_fld = fld;
         nflds++;
         /* field name has been parsed */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_RBRACKET)
            break;
         else
            error(mpl, "syntax error in field list");
      }
      /* check that the set dimen is equal to the number of fields */
      if (tab->u.in.set != NULL && tab->u.in.set->dimen != nflds)
         error(mpl, "there must be %d field%s rather than %d",
            tab->u.in.set->dimen, tab->u.in.set->dimen == 1 ? "" : "s",
            nflds);
      get_token(mpl /* ] */);
      /* parse optional input list */
      tab->u.in.list = last_in = NULL;
      while (mpl->token == T_COMMA)
      {  get_token(mpl /* , */);
         /* create input list entry */
         in = alloc(TABIN);
         /* parse parameter name */
         if (mpl->token == T_NAME)
            ;
         else if (is_reserved(mpl))
            error(mpl,
               "invalid use of reserved keyword %s", mpl->image);
         else
            error(mpl, "parameter name missing where expected");
         node = avl_find_node(mpl->tree, mpl->image);
         if (node == NULL)
            error(mpl, "%s not defined", mpl->image);
         if (avl_get_node_type(node) != A_PARAMETER)
            error(mpl, "%s not a parameter", mpl->image);
         in->par = (PARAMETER *)avl_get_node_link(node);
         if (in->par->dim != nflds)
            error(mpl, "%s must have %d subscript%s rather than %d",
               mpl->image, nflds, nflds == 1 ? "" : "s", in->par->dim);
         if (in->par->assign != NULL)
            error(mpl, "%s needs no data", mpl->image);
         get_token(mpl /*  */);
         /* parse optional field name */
         if (mpl->token == T_TILDE)
         {  get_token(mpl /* ~ */);
            /* parse field name */
            if (mpl->token == T_NAME)
               ;
            else if (is_reserved(mpl))
               error(mpl,
                  "invalid use of reserved keyword %s", mpl->image);
            else
               error(mpl, "field name missing where expected");
            xassert(strlen(mpl->image) < sizeof(name));
            strcpy(name, mpl->image);
            get_token(mpl /*  */);
         }
         else
         {  /* field name is the same as the parameter name */
            xassert(strlen(in->par->name) < sizeof(name));
            strcpy(name, in->par->name);
         }
         /* assign field name */
         in->name = dmp_get_atomv(mpl->pool, strlen(name)+1);
         strcpy(in->name, name);
         /* add the entry to the end of the list */
         in->next = NULL;
         if (last_in == NULL)
            tab->u.in.list = in;
         else
            last_in->next = in;
         last_in = in;
      }
      goto end_of_table;
output_table:
      /* parse output list */
      tab->u.out.list = last_out = NULL;
      for (;;)
      {  /* create output list entry */
         out = alloc(TABOUT);
         /* parse expression */
         if (mpl->token == T_COMMA || mpl->token == T_SEMICOLON)
            error(mpl, "expression missing where expected");
         if (mpl->token == T_NAME)
         {  xassert(strlen(mpl->image) < sizeof(name));
            strcpy(name, mpl->image);
         }
         else
            name[0] = '\0';
         out->code = expression_5(mpl);
         /* parse optional field name */
         if (mpl->token == T_TILDE)
         {  get_token(mpl /* ~ */);
            /* parse field name */
            if (mpl->token == T_NAME)
               ;
            else if (is_reserved(mpl))
               error(mpl,
                  "invalid use of reserved keyword %s", mpl->image);
            else
               error(mpl, "field name missing where expected");
            xassert(strlen(mpl->image) < sizeof(name));
            strcpy(name, mpl->image);
            get_token(mpl /*  */);
         }
         /* assign field name */
         if (name[0] == '\0')
            error(mpl, "field name required");
         out->name = dmp_get_atomv(mpl->pool, strlen(name)+1);
         strcpy(out->name, name);
         /* add the entry to the end of the list */
         out->next = NULL;
         if (last_out == NULL)
            tab->u.out.list = out;
         else
            last_out->next = out;
         last_out = out;
         /* output item has been parsed */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == T_SEMICOLON)
            break;
         else
            error(mpl, "syntax error in output list");
      }
      /* close the domain scope */
      close_scope(mpl,tab->u.out.domain);
end_of_table:
      /* the table statement must end with semicolon */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in table statement");
      get_token(mpl /* ; */);
      return tab;
}
#endif

/*----------------------------------------------------------------------
-- solve_statement - parse solve statement.
--
-- This routine parses solve statement using the syntax:
--
--  ::= solve ;
--
-- The solve statement can be used at most once. */

void *solve_statement(MPL *mpl)
{     xassert(is_keyword(mpl, "solve"));
      if (mpl->flag_s)
         error(mpl, "at most one solve statement allowed");
      mpl->flag_s = 1;
      get_token(mpl /* solve */);
      /* semicolon must follow solve statement */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in solve statement");
      get_token(mpl /* ; */);
      return NULL;
}

/*----------------------------------------------------------------------
-- check_statement - parse check statement.
--
-- This routine parses check statement using the syntax:
--
--  ::= check  :  ;
--  ::= 
--  ::= 
--
-- If  is omitted, colon following it may also be omitted. */

CHECK *check_statement(MPL *mpl)
{     CHECK *chk;
      xassert(is_keyword(mpl, "check"));
      /* create check descriptor */
      chk = alloc(CHECK);
      chk->domain = NULL;
      chk->code = NULL;
      get_token(mpl /* check */);
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  chk->domain = indexing_expression(mpl);
#if 0
         if (mpl->token != T_COLON)
            error(mpl, "colon missing where expected");
#endif
      }
      /* skip optional colon */
      if (mpl->token == T_COLON) get_token(mpl /* : */);
      /* parse logical expression */
      chk->code = expression_13(mpl);
      if (chk->code->type != A_LOGICAL)
         error(mpl, "expression has invalid type");
      xassert(chk->code->dim == 0);
      /* close the domain scope */
      if (chk->domain != NULL) close_scope(mpl, chk->domain);
      /* the check statement has been completely parsed */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in check statement");
      get_token(mpl /* ; */);
      return chk;
}

#if 1 /* 15/V-2010 */
/*----------------------------------------------------------------------
-- display_statement - parse display statement.
--
-- This routine parses display statement using the syntax:
--
--  ::= display  :  ;
--  ::= display   ;
--  ::= 
--  ::= 
--  ::= 
--  ::=  , 
--  ::= 
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::= 
--  ::=  [  ]
--  ::=  */

DISPLAY *display_statement(MPL *mpl)
{     DISPLAY *dpy;
      DISPLAY1 *entry, *last_entry;
      xassert(is_keyword(mpl, "display"));
      /* create display descriptor */
      dpy = alloc(DISPLAY);
      dpy->domain = NULL;
      dpy->list = last_entry = NULL;
      get_token(mpl /* display */);
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
         dpy->domain = indexing_expression(mpl);
      /* skip optional colon */
      if (mpl->token == T_COLON) get_token(mpl /* : */);
      /* parse display list */
      for (;;)
      {  /* create new display entry */
         entry = alloc(DISPLAY1);
         entry->type = 0;
         entry->next = NULL;
         /* and append it to the display list */
         if (dpy->list == NULL)
            dpy->list = entry;
         else
            last_entry->next = entry;
         last_entry = entry;
         /* parse display entry */
         if (mpl->token == T_NAME)
         {  AVLNODE *node;
            int next_token;
            get_token(mpl /*  */);
            next_token = mpl->token;
            unget_token(mpl);
            if (!(next_token == T_COMMA || next_token == T_SEMICOLON))
            {  /* symbolic name begins expression */
               goto expr;
            }
            /* display entry is dummy index or model object */
            node = avl_find_node(mpl->tree, mpl->image);
            if (node == NULL)
               error(mpl, "%s not defined", mpl->image);
            entry->type = avl_get_node_type(node);
            switch (avl_get_node_type(node))
            {  case A_INDEX:
                  entry->u.slot =
                     (DOMAIN_SLOT *)avl_get_node_link(node);
                  break;
               case A_SET:
                  entry->u.set = (SET *)avl_get_node_link(node);
                  break;
               case A_PARAMETER:
                  entry->u.par = (PARAMETER *)avl_get_node_link(node);
                  break;
               case A_VARIABLE:
                  entry->u.var = (VARIABLE *)avl_get_node_link(node);
                  if (!mpl->flag_s)
                     error(mpl, "invalid reference to variable %s above"
                        " solve statement", entry->u.var->name);
                  break;
               case A_CONSTRAINT:
                  entry->u.con = (CONSTRAINT *)avl_get_node_link(node);
                  if (!mpl->flag_s)
                     error(mpl, "invalid reference to %s %s above solve"
                        " statement",
                        entry->u.con->type == A_CONSTRAINT ?
                        "constraint" : "objective", entry->u.con->name);
                  break;
               default:
                  xassert(node != node);
            }
            get_token(mpl /*  */);
         }
         else
expr:    {  /* display entry is expression */
            entry->type = A_EXPRESSION;
            entry->u.code = expression_13(mpl);
         }
         /* check a token that follows the entry parsed */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else
            break;
      }
      /* close the domain scope */
      if (dpy->domain != NULL) close_scope(mpl, dpy->domain);
      /* the display statement has been completely parsed */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in display statement");
      get_token(mpl /* ; */);
      return dpy;
}
#endif

/*----------------------------------------------------------------------
-- printf_statement - parse printf statement.
--
-- This routine parses print statement using the syntax:
--
--  ::=  ;
--  ::=  >  ;
--  ::=  >>  ;
--  ::= printf  :  
--  ::= printf   
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::=  , 
--  ::= 
--  ::=  */

PRINTF *printf_statement(MPL *mpl)
{     PRINTF *prt;
      PRINTF1 *entry, *last_entry;
      xassert(is_keyword(mpl, "printf"));
      /* create printf descriptor */
      prt = alloc(PRINTF);
      prt->domain = NULL;
      prt->fmt = NULL;
      prt->list = last_entry = NULL;
      get_token(mpl /* printf */);
      /* parse optional indexing expression */
      if (mpl->token == T_LBRACE)
      {  prt->domain = indexing_expression(mpl);
#if 0
         if (mpl->token != T_COLON)
            error(mpl, "colon missing where expected");
#endif
      }
      /* skip optional colon */
      if (mpl->token == T_COLON) get_token(mpl /* : */);
      /* parse expression for format string */
      prt->fmt = expression_5(mpl);
      /* convert it to symbolic type, if necessary */
      if (prt->fmt->type == A_NUMERIC)
         prt->fmt = make_unary(mpl, O_CVTSYM, prt->fmt, A_SYMBOLIC, 0);
      /* check that now the expression is of symbolic type */
      if (prt->fmt->type != A_SYMBOLIC)
         error(mpl, "format expression has invalid type");
      /* parse printf list */
      while (mpl->token == T_COMMA)
      {  get_token(mpl /* , */);
         /* create new printf entry */
         entry = alloc(PRINTF1);
         entry->code = NULL;
         entry->next = NULL;
         /* and append it to the printf list */
         if (prt->list == NULL)
            prt->list = entry;
         else
            last_entry->next = entry;
         last_entry = entry;
         /* parse printf entry */
         entry->code = expression_9(mpl);
         if (!(entry->code->type == A_NUMERIC ||
               entry->code->type == A_SYMBOLIC ||
               entry->code->type == A_LOGICAL))
            error(mpl, "only numeric, symbolic, or logical expression a"
               "llowed");
      }
      /* close the domain scope */
      if (prt->domain != NULL) close_scope(mpl, prt->domain);
#if 1 /* 14/VII-2006 */
      /* parse optional redirection */
      prt->fname = NULL, prt->app = 0;
      if (mpl->token == T_GT || mpl->token == T_APPEND)
      {  prt->app = (mpl->token == T_APPEND);
         get_token(mpl /* > or >> */);
         /* parse expression for file name string */
         prt->fname = expression_5(mpl);
         /* convert it to symbolic type, if necessary */
         if (prt->fname->type == A_NUMERIC)
            prt->fname = make_unary(mpl, O_CVTSYM, prt->fname,
               A_SYMBOLIC, 0);
         /* check that now the expression is of symbolic type */
         if (prt->fname->type != A_SYMBOLIC)
            error(mpl, "file name expression has invalid type");
      }
#endif
      /* the printf statement has been completely parsed */
      if (mpl->token != T_SEMICOLON)
         error(mpl, "syntax error in printf statement");
      get_token(mpl /* ; */);
      return prt;
}

/*----------------------------------------------------------------------
-- for_statement - parse for statement.
--
-- This routine parses for statement using the syntax:
--
--  ::= for  
--  ::= for  {  }
--  ::= 
--  ::= 
--  ::=  
--  ::= 
--  ::= 
--  ::= 
--  ::=  */

FOR *for_statement(MPL *mpl)
{     FOR *fur;
      STATEMENT *stmt, *last_stmt;
      xassert(is_keyword(mpl, "for"));
      /* create for descriptor */
      fur = alloc(FOR);
      fur->domain = NULL;
      fur->list = last_stmt = NULL;
      get_token(mpl /* for */);
      /* parse indexing expression */
      if (mpl->token != T_LBRACE)
         error(mpl, "indexing expression missing where expected");
      fur->domain = indexing_expression(mpl);
      /* skip optional colon */
      if (mpl->token == T_COLON) get_token(mpl /* : */);
      /* parse for statement body */
      if (mpl->token != T_LBRACE)
      {  /* parse simple statement */
         fur->list = simple_statement(mpl, 1);
      }
      else
      {  /* parse compound statement */
         get_token(mpl /* { */);
         while (mpl->token != T_RBRACE)
         {  /* parse statement */
            stmt = simple_statement(mpl, 1);
            /* and append it to the end of the statement list */
            if (last_stmt == NULL)
               fur->list = stmt;
            else
               last_stmt->next = stmt;
            last_stmt = stmt;
         }
         get_token(mpl /* } */);
      }
      /* close the domain scope */
      xassert(fur->domain != NULL);
      close_scope(mpl, fur->domain);
      /* the for statement has been completely parsed */
      return fur;
}

/*----------------------------------------------------------------------
-- end_statement - parse end statement.
--
-- This routine parses end statement using the syntax:
--
--  ::= end ;  */

void end_statement(MPL *mpl)
{     if (!mpl->flag_d && is_keyword(mpl, "end") ||
           mpl->flag_d && is_literal(mpl, "end"))
      {  get_token(mpl /* end */);
         if (mpl->token == T_SEMICOLON)
            get_token(mpl /* ; */);
         else
            warning(mpl, "no semicolon following end statement; missing"
               " semicolon inserted");
      }
      else
         warning(mpl, "unexpected end of file; missing end statement in"
            "serted");
      if (mpl->token != T_EOF)
         warning(mpl, "some text detected beyond end statement; text ig"
            "nored");
      return;
}

/*----------------------------------------------------------------------
-- simple_statement - parse simple statement.
--
-- This routine parses simple statement using the syntax:
--
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--  ::= 
--
-- If the flag spec is set, some statements cannot be used. */

STATEMENT *simple_statement(MPL *mpl, int spec)
{     STATEMENT *stmt;
      stmt = alloc(STATEMENT);
      stmt->line = mpl->line;
      stmt->next = NULL;
      if (is_keyword(mpl, "set"))
      {  if (spec)
            error(mpl, "set statement not allowed here");
         stmt->type = A_SET;
         stmt->u.set = set_statement(mpl);
      }
      else if (is_keyword(mpl, "param"))
      {  if (spec)
            error(mpl, "parameter statement not allowed here");
         stmt->type = A_PARAMETER;
         stmt->u.par = parameter_statement(mpl);
      }
      else if (is_keyword(mpl, "var"))
      {  if (spec)
            error(mpl, "variable statement not allowed here");
         stmt->type = A_VARIABLE;
         stmt->u.var = variable_statement(mpl);
      }
      else if (is_keyword(mpl, "subject") ||
               is_keyword(mpl, "subj") ||
               mpl->token == T_SPTP)
      {  if (spec)
            error(mpl, "constraint statement not allowed here");
         stmt->type = A_CONSTRAINT;
         stmt->u.con = constraint_statement(mpl);
      }
      else if (is_keyword(mpl, "minimize") ||
               is_keyword(mpl, "maximize"))
      {  if (spec)
            error(mpl, "objective statement not allowed here");
         stmt->type = A_CONSTRAINT;
         stmt->u.con = objective_statement(mpl);
      }
#if 1 /* 11/II-2008 */
      else if (is_keyword(mpl, "table"))
      {  if (spec)
            error(mpl, "table statement not allowed here");
         stmt->type = A_TABLE;
         stmt->u.tab = table_statement(mpl);
      }
#endif
      else if (is_keyword(mpl, "solve"))
      {  if (spec)
            error(mpl, "solve statement not allowed here");
         stmt->type = A_SOLVE;
         stmt->u.slv = solve_statement(mpl);
      }
      else if (is_keyword(mpl, "check"))
      {  stmt->type = A_CHECK;
         stmt->u.chk = check_statement(mpl);
      }
      else if (is_keyword(mpl, "display"))
      {  stmt->type = A_DISPLAY;
         stmt->u.dpy = display_statement(mpl);
      }
      else if (is_keyword(mpl, "printf"))
      {  stmt->type = A_PRINTF;
         stmt->u.prt = printf_statement(mpl);
      }
      else if (is_keyword(mpl, "for"))
      {  stmt->type = A_FOR;
         stmt->u.fur = for_statement(mpl);
      }
      else if (mpl->token == T_NAME)
      {  if (spec)
            error(mpl, "constraint statement not allowed here");
         stmt->type = A_CONSTRAINT;
         stmt->u.con = constraint_statement(mpl);
      }
      else if (is_reserved(mpl))
         error(mpl, "invalid use of reserved keyword %s", mpl->image);
      else
         error(mpl, "syntax error in model section");
      return stmt;
}

/*----------------------------------------------------------------------
-- model_section - parse model section.
--
-- This routine parses model section using the syntax:
--
--  ::= 
--  ::=  
--
-- Parsing model section is terminated by either the keyword 'data', or
-- the keyword 'end', or the end of file. */

void model_section(MPL *mpl)
{     STATEMENT *stmt, *last_stmt;
      xassert(mpl->model == NULL);
      last_stmt = NULL;
      while (!(mpl->token == T_EOF || is_keyword(mpl, "data") ||
               is_keyword(mpl, "end")))
      {  /* parse statement */
         stmt = simple_statement(mpl, 0);
         /* and append it to the end of the statement list */
         if (last_stmt == NULL)
            mpl->model = stmt;
         else
            last_stmt->next = stmt;
         last_stmt = stmt;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl2.c0000644000175100001710000013043700000000000023722 0ustar00runnerdocker00000000000000/* mpl2.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"

/**********************************************************************/
/* * *                  PROCESSING DATA SECTION                   * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_slice - create slice.
--
-- This routine creates a slice, which initially has no components. */

SLICE *create_slice(MPL *mpl)
{     SLICE *slice;
      xassert(mpl == mpl);
      slice = NULL;
      return slice;
}

/*----------------------------------------------------------------------
-- expand_slice - append new component to slice.
--
-- This routine expands slice appending to it either a given symbol or
-- null component, which becomes the last component of the slice. */

SLICE *expand_slice
(     MPL *mpl,
      SLICE *slice,           /* destroyed */
      SYMBOL *sym             /* destroyed */
)
{     SLICE *tail, *temp;
      /* create a new component */
      tail = dmp_get_atom(mpl->tuples, sizeof(SLICE));
      tail->sym = sym;
      tail->next = NULL;
      /* and append it to the component list */
      if (slice == NULL)
         slice = tail;
      else
      {  for (temp = slice; temp->next != NULL; temp = temp->next);
         temp->next = tail;
      }
      return slice;
}

/*----------------------------------------------------------------------
-- slice_dimen - determine dimension of slice.
--
-- This routine returns dimension of slice, which is number of all its
-- components including null ones. */

int slice_dimen
(     MPL *mpl,
      SLICE *slice            /* not changed */
)
{     SLICE *temp;
      int dim;
      xassert(mpl == mpl);
      dim = 0;
      for (temp = slice; temp != NULL; temp = temp->next) dim++;
      return dim;
}

/*----------------------------------------------------------------------
-- slice_arity - determine arity of slice.
--
-- This routine returns arity of slice, i.e. number of null components
-- (indicated by asterisks) in the slice. */

int slice_arity
(     MPL *mpl,
      SLICE *slice            /* not changed */
)
{     SLICE *temp;
      int arity;
      xassert(mpl == mpl);
      arity = 0;
      for (temp = slice; temp != NULL; temp = temp->next)
         if (temp->sym == NULL) arity++;
      return arity;
}

/*----------------------------------------------------------------------
-- fake_slice - create fake slice of all asterisks.
--
-- This routine creates a fake slice of given dimension, which contains
-- asterisks in all components. Zero dimension is allowed. */

SLICE *fake_slice(MPL *mpl, int dim)
{     SLICE *slice;
      slice = create_slice(mpl);
      while (dim-- > 0) slice = expand_slice(mpl, slice, NULL);
      return slice;
}

/*----------------------------------------------------------------------
-- delete_slice - delete slice.
--
-- This routine deletes specified slice. */

void delete_slice
(     MPL *mpl,
      SLICE *slice            /* destroyed */
)
{     SLICE *temp;
      while (slice != NULL)
      {  temp = slice;
         slice = temp->next;
         if (temp->sym != NULL) delete_symbol(mpl, temp->sym);
xassert(sizeof(SLICE) == sizeof(TUPLE));
         dmp_free_atom(mpl->tuples, temp, sizeof(TUPLE));
      }
      return;
}

/*----------------------------------------------------------------------
-- is_number - check if current token is number.
--
-- If the current token is a number, this routine returns non-zero.
-- Otherwise zero is returned. */

int is_number(MPL *mpl)
{     return
         mpl->token == T_NUMBER;
}

/*----------------------------------------------------------------------
-- is_symbol - check if current token is symbol.
--
-- If the current token is suitable to be a symbol, the routine returns
-- non-zero. Otherwise zero is returned. */

int is_symbol(MPL *mpl)
{     return
         mpl->token == T_NUMBER ||
         mpl->token == T_SYMBOL ||
         mpl->token == T_STRING;
}

/*----------------------------------------------------------------------
-- is_literal - check if current token is given symbolic literal.
--
-- If the current token is given symbolic literal, this routine returns
-- non-zero. Otherwise zero is returned.
--
-- This routine is used on processing the data section in the same way
-- as the routine is_keyword on processing the model section. */

int is_literal(MPL *mpl, char *literal)
{     return
         is_symbol(mpl) && strcmp(mpl->image, literal) == 0;
}

/*----------------------------------------------------------------------
-- read_number - read number.
--
-- This routine reads the current token, which must be a number, and
-- returns its numeric value. */

double read_number(MPL *mpl)
{     double num;
      xassert(is_number(mpl));
      num = mpl->value;
      get_token(mpl /*  */);
      return num;
}

/*----------------------------------------------------------------------
-- read_symbol - read symbol.
--
-- This routine reads the current token, which must be a symbol, and
-- returns its symbolic value. */

SYMBOL *read_symbol(MPL *mpl)
{     SYMBOL *sym;
      xassert(is_symbol(mpl));
      if (is_number(mpl))
         sym = create_symbol_num(mpl, mpl->value);
      else
         sym = create_symbol_str(mpl, create_string(mpl, mpl->image));
      get_token(mpl /*  */);
      return sym;
}

/*----------------------------------------------------------------------
-- read_slice - read slice.
--
-- This routine reads slice using the syntax:
--
--  ::= [  ]
--  ::= (  )
--  ::= 
--  ::=  , 
--  ::= 
--  ::= *
--
-- The bracketed form of slice is used for members of multi-dimensional
-- objects while the parenthesized form is used for elemental sets. */

SLICE *read_slice
(     MPL *mpl,
      char *name,             /* not changed */
      int dim
)
{     SLICE *slice;
      int close;
      xassert(name != NULL);
      switch (mpl->token)
      {  case T_LBRACKET:
            close = T_RBRACKET;
            break;
         case T_LEFT:
            xassert(dim > 0);
            close = T_RIGHT;
            break;
         default:
            xassert(mpl != mpl);
      }
      if (dim == 0)
         error(mpl, "%s cannot be subscripted", name);
      get_token(mpl /* ( | [ */);
      /* read slice components */
      slice = create_slice(mpl);
      for (;;)
      {  /* the current token must be a symbol or asterisk */
         if (is_symbol(mpl))
            slice = expand_slice(mpl, slice, read_symbol(mpl));
         else if (mpl->token == T_ASTERISK)
         {  slice = expand_slice(mpl, slice, NULL);
            get_token(mpl /* * */);
         }
         else
            error(mpl, "number, symbol, or asterisk missing where expec"
               "ted");
         /* check a token that follows the symbol */
         if (mpl->token == T_COMMA)
            get_token(mpl /* , */);
         else if (mpl->token == close)
            break;
         else
            error(mpl, "syntax error in slice");
      }
      /* number of slice components must be the same as the appropriate
         dimension */
      if (slice_dimen(mpl, slice) != dim)
      {  switch (close)
         {  case T_RBRACKET:
               error(mpl, "%s must have %d subscript%s, not %d", name,
                  dim, dim == 1 ? "" : "s", slice_dimen(mpl, slice));
               break;
            case T_RIGHT:
               error(mpl, "%s has dimension %d, not %d", name, dim,
                  slice_dimen(mpl, slice));
               break;
            default:
               xassert(close != close);
         }
      }
      get_token(mpl /* ) | ] */);
      return slice;
}

/*----------------------------------------------------------------------
-- select_set - select set to saturate it with elemental sets.
--
-- This routine selects set to saturate it with elemental sets provided
-- in the data section. */

SET *select_set
(     MPL *mpl,
      char *name              /* not changed */
)
{     SET *set;
      AVLNODE *node;
      xassert(name != NULL);
      node = avl_find_node(mpl->tree, name);
      if (node == NULL || avl_get_node_type(node) != A_SET)
         error(mpl, "%s not a set", name);
      set = (SET *)avl_get_node_link(node);
      if (set->assign != NULL || set->gadget != NULL)
         error(mpl, "%s needs no data", name);
      set->data = 1;
      return set;
}

/*----------------------------------------------------------------------
-- simple_format - read set data block in simple format.
--
-- This routine reads set data block using the syntax:
--
--  ::=  ,  , ... , 
--
-- where  are used to construct a complete n-tuple, which is
-- included in elemental set assigned to the set member. Commae between
-- symbols are optional and may be omitted anywhere.
--
-- Number of components in the slice must be the same as dimension of
-- n-tuples in elemental sets assigned to the set members. To construct
-- complete n-tuple the routine replaces null positions in the slice by
-- corresponding .
--
-- If the slice contains at least one null position, the current token
-- must be symbol. Otherwise, the routine reads no symbols to construct
-- the n-tuple, so the current token is not checked. */

void simple_format
(     MPL *mpl,
      SET *set,               /* not changed */
      MEMBER *memb,           /* modified */
      SLICE *slice            /* not changed */
)
{     TUPLE *tuple;
      SLICE *temp;
      SYMBOL *sym, *with = NULL;
      xassert(set != NULL);
      xassert(memb != NULL);
      xassert(slice != NULL);
      xassert(set->dimen == slice_dimen(mpl, slice));
      xassert(memb->value.set->dim == set->dimen);
      if (slice_arity(mpl, slice) > 0) xassert(is_symbol(mpl));
      /* read symbols and construct complete n-tuple */
      tuple = create_tuple(mpl);
      for (temp = slice; temp != NULL; temp = temp->next)
      {  if (temp->sym == NULL)
         {  /* substitution is needed; read symbol */
            if (!is_symbol(mpl))
            {  int lack = slice_arity(mpl, temp);
               /* with cannot be null due to assertion above */
               xassert(with != NULL);
               if (lack == 1)
                  error(mpl, "one item missing in data group beginning "
                     "with %s", format_symbol(mpl, with));
               else
                  error(mpl, "%d items missing in data group beginning "
                     "with %s", lack, format_symbol(mpl, with));
            }
            sym = read_symbol(mpl);
            if (with == NULL) with = sym;
         }
         else
         {  /* copy symbol from the slice */
            sym = copy_symbol(mpl, temp->sym);
         }
         /* append the symbol to the n-tuple */
         tuple = expand_tuple(mpl, tuple, sym);
         /* skip optional comma *between*  */
         if (temp->next != NULL && mpl->token == T_COMMA)
            get_token(mpl /* , */);
      }
      /* add constructed n-tuple to elemental set */
      check_then_add(mpl, memb->value.set, tuple);
      return;
}

/*----------------------------------------------------------------------
-- matrix_format - read set data block in matrix format.
--
-- This routine reads set data block using the syntax:
--
--  ::=   ...  :=
--                  +/-      +/-    ...   +/-
--                  +/-      +/-    ...   +/-
--                 .  .  .  .  .  .  .  .  .  .  .
--                  +/-      +/-    ...   +/-
--
-- where  are symbols that denote rows of the matrix, 
-- are symbols that denote columns of the matrix, "+" and "-" indicate
-- whether corresponding n-tuple needs to be included in the elemental
-- set or not, respectively.
--
-- Number of the slice components must be the same as dimension of the
-- elemental set. The slice must have two null positions. To construct
-- complete n-tuple for particular element of the matrix the routine
-- replaces first null position of the slice by the corresponding 
-- (or , if the flag tr is on) and second null position by the
-- corresponding  (or by , if the flag tr is on). */

void matrix_format
(     MPL *mpl,
      SET *set,               /* not changed */
      MEMBER *memb,           /* modified */
      SLICE *slice,           /* not changed */
      int tr
)
{     SLICE *list, *col, *temp;
      TUPLE *tuple;
      SYMBOL *row;
      xassert(set != NULL);
      xassert(memb != NULL);
      xassert(slice != NULL);
      xassert(set->dimen == slice_dimen(mpl, slice));
      xassert(memb->value.set->dim == set->dimen);
      xassert(slice_arity(mpl, slice) == 2);
      /* read the matrix heading that contains column symbols (there
         may be no columns at all) */
      list = create_slice(mpl);
      while (mpl->token != T_ASSIGN)
      {  /* read column symbol and append it to the column list */
         if (!is_symbol(mpl))
            error(mpl, "number, symbol, or := missing where expected");
         list = expand_slice(mpl, list, read_symbol(mpl));
      }
      get_token(mpl /* := */);
      /* read zero or more rows that contain matrix data */
      while (is_symbol(mpl))
      {  /* read row symbol (if the matrix has no columns, row symbols
            are just ignored) */
         row = read_symbol(mpl);
         /* read the matrix row accordingly to the column list */
         for (col = list; col != NULL; col = col->next)
         {  int which = 0;
            /* check indicator */
            if (is_literal(mpl, "+"))
               ;
            else if (is_literal(mpl, "-"))
            {  get_token(mpl /* - */);
               continue;
            }
            else
            {  int lack = slice_dimen(mpl, col);
               if (lack == 1)
                  error(mpl, "one item missing in data group beginning "
                     "with %s", format_symbol(mpl, row));
               else
                  error(mpl, "%d items missing in data group beginning "
                     "with %s", lack, format_symbol(mpl, row));
            }
            /* construct complete n-tuple */
            tuple = create_tuple(mpl);
            for (temp = slice; temp != NULL; temp = temp->next)
            {  if (temp->sym == NULL)
               {  /* substitution is needed */
                  switch (++which)
                  {  case 1:
                        /* substitute in the first null position */
                        tuple = expand_tuple(mpl, tuple,
                           copy_symbol(mpl, tr ? col->sym : row));
                        break;
                     case 2:
                        /* substitute in the second null position */
                        tuple = expand_tuple(mpl, tuple,
                           copy_symbol(mpl, tr ? row : col->sym));
                        break;
                     default:
                        xassert(which != which);
                  }
               }
               else
               {  /* copy symbol from the slice */
                  tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
                     temp->sym));
               }
            }
            xassert(which == 2);
            /* add constructed n-tuple to elemental set */
            check_then_add(mpl, memb->value.set, tuple);
            get_token(mpl /* + */);
         }
         /* delete the row symbol */
         delete_symbol(mpl, row);
      }
      /* delete the column list */
      delete_slice(mpl, list);
      return;
}

/*----------------------------------------------------------------------
-- set_data - read set data.
--
-- This routine reads set data using the syntax:
--
--  ::= set   ;
--  ::= set  [  ]  ;
--  ::= 
--  ::= 
--  ::=  , :=
--  ::=  , (  )
--  ::=  , 
--  ::=  , : 
--  ::=  , (tr) 
--  ::=  , (tr) : 
--
-- Commae in  are optional and may be omitted anywhere. */

void set_data(MPL *mpl)
{     SET *set;
      TUPLE *tuple;
      MEMBER *memb;
      SLICE *slice;
      int tr = 0;
      xassert(is_literal(mpl, "set"));
      get_token(mpl /* set */);
      /* symbolic name of set must follows the keyword 'set' */
      if (!is_symbol(mpl))
         error(mpl, "set name missing where expected");
      /* select the set to saturate it with data */
      set = select_set(mpl, mpl->image);
      get_token(mpl /*  */);
      /* read optional subscript list, which identifies member of the
         set to be read */
      tuple = create_tuple(mpl);
      if (mpl->token == T_LBRACKET)
      {  /* subscript list is specified */
         if (set->dim == 0)
            error(mpl, "%s cannot be subscripted", set->name);
         get_token(mpl /* [ */);
         /* read symbols and construct subscript list */
         for (;;)
         {  if (!is_symbol(mpl))
               error(mpl, "number or symbol missing where expected");
            tuple = expand_tuple(mpl, tuple, read_symbol(mpl));
            if (mpl->token == T_COMMA)
               get_token(mpl /* , */);
            else if (mpl->token == T_RBRACKET)
               break;
            else
               error(mpl, "syntax error in subscript list");
         }
         if (set->dim != tuple_dimen(mpl, tuple))
            error(mpl, "%s must have %d subscript%s rather than %d",
               set->name, set->dim, set->dim == 1 ? "" : "s",
               tuple_dimen(mpl, tuple));
         get_token(mpl /* ] */);
      }
      else
      {  /* subscript list is not specified */
         if (set->dim != 0)
            error(mpl, "%s must be subscripted", set->name);
      }
      /* there must be no member with the same subscript list */
      if (find_member(mpl, set->array, tuple) != NULL)
         error(mpl, "%s%s already defined",
            set->name, format_tuple(mpl, '[', tuple));
      /* add new member to the set and assign it empty elemental set */
      memb = add_member(mpl, set->array, tuple);
      memb->value.set = create_elemset(mpl, set->dimen);
      /* create an initial fake slice of all asterisks */
      slice = fake_slice(mpl, set->dimen);
      /* read zero or more data assignments */
      for (;;)
      {  /* skip optional comma */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
         /* process assignment element */
         if (mpl->token == T_ASSIGN)
         {  /* assignment ligature is non-significant element */
            get_token(mpl /* := */);
         }
         else if (mpl->token == T_LEFT)
         {  /* left parenthesis begins either new slice or "transpose"
               indicator */
            int is_tr;
            get_token(mpl /* ( */);
            is_tr = is_literal(mpl, "tr");
            unget_token(mpl /* ( */);
            if (is_tr) goto left;
            /* delete the current slice and read new one */
            delete_slice(mpl, slice);
            slice = read_slice(mpl, set->name, set->dimen);
            /* each new slice resets the "transpose" indicator */
            tr = 0;
            /* if the new slice is 0-ary, formally there is one 0-tuple
               (in the simple format) that follows it */
            if (slice_arity(mpl, slice) == 0)
               simple_format(mpl, set, memb, slice);
         }
         else if (is_symbol(mpl))
         {  /* number or symbol begins data in the simple format */
            simple_format(mpl, set, memb, slice);
         }
         else if (mpl->token == T_COLON)
         {  /* colon begins data in the matrix format */
            if (slice_arity(mpl, slice) != 2)
err1:          error(mpl, "slice currently used must specify 2 asterisk"
                  "s, not %d", slice_arity(mpl, slice));
            get_token(mpl /* : */);
            /* read elemental set data in the matrix format */
            matrix_format(mpl, set, memb, slice, tr);
         }
         else if (mpl->token == T_LEFT)
left:    {  /* left parenthesis begins the "transpose" indicator, which
               is followed by data in the matrix format */
            get_token(mpl /* ( */);
            if (!is_literal(mpl, "tr"))
err2:          error(mpl, "transpose indicator (tr) incomplete");
            if (slice_arity(mpl, slice) != 2) goto err1;
            get_token(mpl /* tr */);
            if (mpl->token != T_RIGHT) goto err2;
            get_token(mpl /* ) */);
            /* in this case the colon is optional */
            if (mpl->token == T_COLON) get_token(mpl /* : */);
            /* set the "transpose" indicator */
            tr = 1;
            /* read elemental set data in the matrix format */
            matrix_format(mpl, set, memb, slice, tr);
         }
         else if (mpl->token == T_SEMICOLON)
         {  /* semicolon terminates the data block */
            get_token(mpl /* ; */);
            break;
         }
         else
            error(mpl, "syntax error in set data block");
      }
      /* delete the current slice */
      delete_slice(mpl, slice);
      return;
}

/*----------------------------------------------------------------------
-- select_parameter - select parameter to saturate it with data.
--
-- This routine selects parameter to saturate it with data provided in
-- the data section. */

PARAMETER *select_parameter
(     MPL *mpl,
      char *name              /* not changed */
)
{     PARAMETER *par;
      AVLNODE *node;
      xassert(name != NULL);
      node = avl_find_node(mpl->tree, name);
      if (node == NULL || avl_get_node_type(node) != A_PARAMETER)
         error(mpl, "%s not a parameter", name);
      par = (PARAMETER *)avl_get_node_link(node);
      if (par->assign != NULL)
         error(mpl, "%s needs no data", name);
      if (par->data)
         error(mpl, "%s already provided with data", name);
      par->data = 1;
      return par;
}

/*----------------------------------------------------------------------
-- set_default - set default parameter value.
--
-- This routine sets default value for specified parameter. */

void set_default
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SYMBOL *altval          /* destroyed */
)
{     xassert(par != NULL);
      xassert(altval != NULL);
      if (par->option != NULL)
         error(mpl, "default value for %s already specified in model se"
            "ction", par->name);
      xassert(par->defval == NULL);
      par->defval = altval;
      return;
}

/*----------------------------------------------------------------------
-- read_value - read value and assign it to parameter member.
--
-- This routine reads numeric or symbolic value from the input stream
-- and assigns to new parameter member specified by its n-tuple, which
-- (the member) is created and added to the parameter array. */

MEMBER *read_value
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* destroyed */
)
{     MEMBER *memb;
      xassert(par != NULL);
      xassert(is_symbol(mpl));
      /* there must be no member with the same n-tuple */
      if (find_member(mpl, par->array, tuple) != NULL)
         error(mpl, "%s%s already defined",
            par->name, format_tuple(mpl, '[', tuple));
      /* create new parameter member with given n-tuple */
      memb = add_member(mpl, par->array, tuple);
      /* read value and assigns it to the new parameter member */
      switch (par->type)
      {  case A_NUMERIC:
         case A_INTEGER:
         case A_BINARY:
            if (!is_number(mpl))
               error(mpl, "%s requires numeric data", par->name);
            memb->value.num = read_number(mpl);
            break;
         case A_SYMBOLIC:
            memb->value.sym = read_symbol(mpl);
            break;
         default:
            xassert(par != par);
      }
      return memb;
}

/*----------------------------------------------------------------------
-- plain_format - read parameter data block in plain format.
--
-- This routine reads parameter data block using the syntax:
--
--  ::=  ,  , ... ,  , 
--
-- where  are used to determine a complete subscript list for
-- parameter member,  is a numeric or symbolic value assigned to
-- the parameter member. Commae between data items are optional and may
-- be omitted anywhere.
--
-- Number of components in the slice must be the same as dimension of
-- the parameter. To construct the complete subscript list the routine
-- replaces null positions in the slice by corresponding . */

void plain_format
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SLICE *slice            /* not changed */
)
{     TUPLE *tuple;
      SLICE *temp;
      SYMBOL *sym, *with = NULL;
      xassert(par != NULL);
      xassert(par->dim == slice_dimen(mpl, slice));
      xassert(is_symbol(mpl));
      /* read symbols and construct complete subscript list */
      tuple = create_tuple(mpl);
      for (temp = slice; temp != NULL; temp = temp->next)
      {  if (temp->sym == NULL)
         {  /* substitution is needed; read symbol */
            if (!is_symbol(mpl))
            {  int lack = slice_arity(mpl, temp) + 1;
               xassert(with != NULL);
               xassert(lack > 1);
               error(mpl, "%d items missing in data group beginning wit"
                  "h %s", lack, format_symbol(mpl, with));
            }
            sym = read_symbol(mpl);
            if (with == NULL) with = sym;
         }
         else
         {  /* copy symbol from the slice */
            sym = copy_symbol(mpl, temp->sym);
         }
         /* append the symbol to the subscript list */
         tuple = expand_tuple(mpl, tuple, sym);
         /* skip optional comma */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
      }
      /* read value and assign it to new parameter member */
      if (!is_symbol(mpl))
      {  xassert(with != NULL);
         error(mpl, "one item missing in data group beginning with %s",
            format_symbol(mpl, with));
      }
      read_value(mpl, par, tuple);
      return;
}

/*----------------------------------------------------------------------
-- tabular_format - read parameter data block in tabular format.
--
-- This routine reads parameter data block using the syntax:
--
--  ::=   ...  :=
--                     ... 
--                     ... 
--                  .  .  .  .  .  .  .  .  .  .  .
--                     ... 
--
-- where  are symbols that denote rows of the table, 
-- are symbols that denote columns of the table,  are numeric
-- or symbolic values assigned to the corresponding parameter members.
-- If  is specified as single point, no value is provided.
--
-- Number of components in the slice must be the same as dimension of
-- the parameter. The slice must have two null positions. To construct
-- complete subscript list for particular  the routine replaces
-- the first null position of the slice by the corresponding  (or
-- , if the flag tr is on) and the second null position by the
-- corresponding  (or by , if the flag tr is on). */

void tabular_format
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      SLICE *slice,           /* not changed */
      int tr
)
{     SLICE *list, *col, *temp;
      TUPLE *tuple;
      SYMBOL *row;
      xassert(par != NULL);
      xassert(par->dim == slice_dimen(mpl, slice));
      xassert(slice_arity(mpl, slice) == 2);
      /* read the table heading that contains column symbols (the table
         may have no columns) */
      list = create_slice(mpl);
      while (mpl->token != T_ASSIGN)
      {  /* read column symbol and append it to the column list */
         if (!is_symbol(mpl))
            error(mpl, "number, symbol, or := missing where expected");
         list = expand_slice(mpl, list, read_symbol(mpl));
      }
      get_token(mpl /* := */);
      /* read zero or more rows that contain tabular data */
      while (is_symbol(mpl))
      {  /* read row symbol (if the table has no columns, these symbols
            are just ignored) */
         row = read_symbol(mpl);
         /* read values accordingly to the column list */
         for (col = list; col != NULL; col = col->next)
         {  int which = 0;
            /* if the token is single point, no value is provided */
            if (is_literal(mpl, "."))
            {  get_token(mpl /* . */);
               continue;
            }
            /* construct complete subscript list */
            tuple = create_tuple(mpl);
            for (temp = slice; temp != NULL; temp = temp->next)
            {  if (temp->sym == NULL)
               {  /* substitution is needed */
                  switch (++which)
                  {  case 1:
                        /* substitute in the first null position */
                        tuple = expand_tuple(mpl, tuple,
                           copy_symbol(mpl, tr ? col->sym : row));
                        break;
                     case 2:
                        /* substitute in the second null position */
                        tuple = expand_tuple(mpl, tuple,
                           copy_symbol(mpl, tr ? row : col->sym));
                        break;
                     default:
                        xassert(which != which);
                  }
               }
               else
               {  /* copy symbol from the slice */
                  tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
                     temp->sym));
               }
            }
            xassert(which == 2);
            /* read value and assign it to new parameter member */
            if (!is_symbol(mpl))
            {  int lack = slice_dimen(mpl, col);
               if (lack == 1)
                  error(mpl, "one item missing in data group beginning "
                     "with %s", format_symbol(mpl, row));
               else
                  error(mpl, "%d items missing in data group beginning "
                     "with %s", lack, format_symbol(mpl, row));
            }
            read_value(mpl, par, tuple);
         }
         /* delete the row symbol */
         delete_symbol(mpl, row);
      }
      /* delete the column list */
      delete_slice(mpl, list);
      return;
}

/*----------------------------------------------------------------------
-- tabbing_format - read parameter data block in tabbing format.
--
-- This routine reads parameter data block using the syntax:
--
--  ::=     , ... ,   , := ,
--     , ... ,  ,  , ... ,  ,
--     , ... ,  ,  , ... ,  ,
--     .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
--     , ... ,  ,  , ... , 
--  ::= 
--  ::=  :
--
-- where  are names of parameters (all the parameters must be
-- subscripted and have identical dimensions),  are symbols
-- used to define subscripts of parameter members,  are numeric
-- or symbolic values assigned to the corresponding parameter members.
-- Optional  may specify a simple set, in which case n-tuples
-- built of  for each row of the data table (i.e. subscripts
-- of parameter members) are added to the specified set. Commae between
-- data items are optional and may be omitted anywhere.
--
-- If the parameter altval is not NULL, it specifies a default value
-- provided for all the parameters specified in the data block.  */

void tabbing_format
(     MPL *mpl,
      SYMBOL *altval          /* not changed */
)
{     SET *set = NULL;
      PARAMETER *par;
      SLICE *list, *col;
      TUPLE *tuple;
      int next_token, j, dim = 0;
      char *last_name = NULL;
      /* read the optional  */
      if (is_symbol(mpl))
      {  get_token(mpl /*  */);
         next_token = mpl->token;
         unget_token(mpl /*  */);
         if (next_token == T_COLON)
         {  /* select the set to saturate it with data */
            set = select_set(mpl, mpl->image);
            /* the set must be simple (i.e. not set of sets) */
            if (set->dim != 0)
               error(mpl, "%s must be a simple set", set->name);
            /* and must not be defined yet */
            if (set->array->head != NULL)
               error(mpl, "%s already defined", set->name);
            /* add new (the only) member to the set and assign it empty
               elemental set */
            add_member(mpl, set->array, NULL)->value.set =
               create_elemset(mpl, set->dimen);
            last_name = set->name, dim = set->dimen;
            get_token(mpl /*  */);
            xassert(mpl->token == T_COLON);
            get_token(mpl /* : */);
         }
      }
      /* read the table heading that contains parameter names */
      list = create_slice(mpl);
      while (mpl->token != T_ASSIGN)
      {  /* there must be symbolic name of parameter */
         if (!is_symbol(mpl))
            error(mpl, "parameter name or := missing where expected");
         /* select the parameter to saturate it with data */
         par = select_parameter(mpl, mpl->image);
         /* the parameter must be subscripted */
         if (par->dim == 0)
            error(mpl, "%s not a subscripted parameter", mpl->image);
         /* the set (if specified) and all the parameters in the data
            block must have identical dimension */
         if (dim != 0 && par->dim != dim)
         {  xassert(last_name != NULL);
            error(mpl, "%s has dimension %d while %s has dimension %d",
               last_name, dim, par->name, par->dim);
         }
         /* set default value for the parameter (if specified) */
         if (altval != NULL)
            set_default(mpl, par, copy_symbol(mpl, altval));
         /* append the parameter to the column list */
         list = expand_slice(mpl, list, (SYMBOL *)par);
         last_name = par->name, dim = par->dim;
         get_token(mpl /*  */);
         /* skip optional comma */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
      }
      if (slice_dimen(mpl, list) == 0)
         error(mpl, "at least one parameter name required");
      get_token(mpl /* := */);
      /* skip optional comma */
      if (mpl->token == T_COMMA) get_token(mpl /* , */);
      /* read rows that contain tabbing data */
      while (is_symbol(mpl))
      {  /* read subscript list */
         tuple = create_tuple(mpl);
         for (j = 1; j <= dim; j++)
         {  /* read j-th subscript */
            if (!is_symbol(mpl))
            {  int lack = slice_dimen(mpl, list) + dim - j + 1;
               xassert(tuple != NULL);
               xassert(lack > 1);
               error(mpl, "%d items missing in data group beginning wit"
                  "h %s", lack, format_symbol(mpl, tuple->sym));
            }
            /* read and append j-th subscript to the n-tuple */
            tuple = expand_tuple(mpl, tuple, read_symbol(mpl));
            /* skip optional comma *between*  */
            if (j < dim && mpl->token == T_COMMA)
               get_token(mpl /* , */);
         }
         /* if the set is specified, add to it new n-tuple, which is a
            copy of the subscript list just read */
         if (set != NULL)
            check_then_add(mpl, set->array->head->value.set,
               copy_tuple(mpl, tuple));
         /* skip optional comma between  and  */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
         /* read values accordingly to the column list */
         for (col = list; col != NULL; col = col->next)
         {  /* if the token is single point, no value is provided */
            if (is_literal(mpl, "."))
            {  get_token(mpl /* . */);
               continue;
            }
            /* read value and assign it to new parameter member */
            if (!is_symbol(mpl))
            {  int lack = slice_dimen(mpl, col);
               xassert(tuple != NULL);
               if (lack == 1)
                  error(mpl, "one item missing in data group beginning "
                     "with %s", format_symbol(mpl, tuple->sym));
               else
                  error(mpl, "%d items missing in data group beginning "
                     "with %s", lack, format_symbol(mpl, tuple->sym));
            }
            read_value(mpl, (PARAMETER *)col->sym, copy_tuple(mpl,
               tuple));
            /* skip optional comma preceding the next value */
            if (col->next != NULL && mpl->token == T_COMMA)
               get_token(mpl /* , */);
         }
         /* delete the original subscript list */
         delete_tuple(mpl, tuple);
         /* skip optional comma (only if there is next data group) */
         if (mpl->token == T_COMMA)
         {  get_token(mpl /* , */);
            if (!is_symbol(mpl)) unget_token(mpl /* , */);
         }
      }
      /* delete the column list (it contains parameters, not symbols,
         so nullify it before) */
      for (col = list; col != NULL; col = col->next) col->sym = NULL;
      delete_slice(mpl, list);
      return;
}

/*----------------------------------------------------------------------
-- parameter_data - read parameter data.
--
-- This routine reads parameter data using the syntax:
--
--  ::= param  :  ;
--  ::= param  
--                       ;
--  ::= 
--  ::= 
--  ::= default 
--  ::= 
--  ::=  , :=
--  ::=  , [  ]
--  ::=  , 
--  ::=  , : 
--  ::=  , (tr) 
--  ::=  , (tr) : 
--
-- Commae in  are optional and may be omitted anywhere. */

void parameter_data(MPL *mpl)
{     PARAMETER *par;
      SYMBOL *altval = NULL;
      SLICE *slice;
      int tr = 0;
      xassert(is_literal(mpl, "param"));
      get_token(mpl /* param */);
      /* read optional default value */
      if (is_literal(mpl, "default"))
      {  get_token(mpl /* default */);
         if (!is_symbol(mpl))
            error(mpl, "default value missing where expected");
         altval = read_symbol(mpl);
         /* if the default value follows the keyword 'param', the next
            token must be only the colon */
         if (mpl->token != T_COLON)
            error(mpl, "colon missing where expected");
      }
      /* being used after the keyword 'param' or the optional default
         value the colon begins data in the tabbing format */
      if (mpl->token == T_COLON)
      {  get_token(mpl /* : */);
         /* skip optional comma */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
         /* read parameter data in the tabbing format */
         tabbing_format(mpl, altval);
         /* on reading data in the tabbing format the default value is
            always copied, so delete the original symbol */
         if (altval != NULL) delete_symbol(mpl, altval);
         /* the next token must be only semicolon */
         if (mpl->token != T_SEMICOLON)
            error(mpl, "symbol, number, or semicolon missing where expe"
               "cted");
         get_token(mpl /* ; */);
         goto done;
      }
      /* in other cases there must be symbolic name of parameter, which
         follows the keyword 'param' */
      if (!is_symbol(mpl))
         error(mpl, "parameter name missing where expected");
      /* select the parameter to saturate it with data */
      par = select_parameter(mpl, mpl->image);
      get_token(mpl /*  */);
      /* read optional default value */
      if (is_literal(mpl, "default"))
      {  get_token(mpl /* default */);
         if (!is_symbol(mpl))
            error(mpl, "default value missing where expected");
         altval = read_symbol(mpl);
         /* set default value for the parameter */
         set_default(mpl, par, altval);
      }
      /* create initial fake slice of all asterisks */
      slice = fake_slice(mpl, par->dim);
      /* read zero or more data assignments */
      for (;;)
      {  /* skip optional comma */
         if (mpl->token == T_COMMA) get_token(mpl /* , */);
         /* process current assignment */
         if (mpl->token == T_ASSIGN)
         {  /* assignment ligature is non-significant element */
            get_token(mpl /* := */);
         }
         else if (mpl->token == T_LBRACKET)
         {  /* left bracket begins new slice; delete the current slice
               and read new one */
            delete_slice(mpl, slice);
            slice = read_slice(mpl, par->name, par->dim);
            /* each new slice resets the "transpose" indicator */
            tr = 0;
         }
         else if (is_symbol(mpl))
         {  /* number or symbol begins data in the plain format */
            plain_format(mpl, par, slice);
         }
         else if (mpl->token == T_COLON)
         {  /* colon begins data in the tabular format */
            if (par->dim == 0)
err1:          error(mpl, "%s not a subscripted parameter",
                  par->name);
            if (slice_arity(mpl, slice) != 2)
err2:          error(mpl, "slice currently used must specify 2 asterisk"
                  "s, not %d", slice_arity(mpl, slice));
            get_token(mpl /* : */);
            /* read parameter data in the tabular format */
            tabular_format(mpl, par, slice, tr);
         }
         else if (mpl->token == T_LEFT)
         {  /* left parenthesis begins the "transpose" indicator, which
               is followed by data in the tabular format */
            get_token(mpl /* ( */);
            if (!is_literal(mpl, "tr"))
err3:          error(mpl, "transpose indicator (tr) incomplete");
            if (par->dim == 0) goto err1;
            if (slice_arity(mpl, slice) != 2) goto err2;
            get_token(mpl /* tr */);
            if (mpl->token != T_RIGHT) goto err3;
            get_token(mpl /* ) */);
            /* in this case the colon is optional */
            if (mpl->token == T_COLON) get_token(mpl /* : */);
            /* set the "transpose" indicator */
            tr = 1;
            /* read parameter data in the tabular format */
            tabular_format(mpl, par, slice, tr);
         }
         else if (mpl->token == T_SEMICOLON)
         {  /* semicolon terminates the data block */
            get_token(mpl /* ; */);
            break;
         }
         else
            error(mpl, "syntax error in parameter data block");
      }
      /* delete the current slice */
      delete_slice(mpl, slice);
done: return;
}

/*----------------------------------------------------------------------
-- data_section - read data section.
--
-- This routine reads data section using the syntax:
--
--  ::= 
--  ::=   ;
--  ::= 
--  ::= 
--
-- Reading data section is terminated by either the keyword 'end' or
-- the end of file. */

void data_section(MPL *mpl)
{     while (!(mpl->token == T_EOF || is_literal(mpl, "end")))
      {  if (is_literal(mpl, "set"))
            set_data(mpl);
         else if (is_literal(mpl, "param"))
            parameter_data(mpl);
         else
            error(mpl, "syntax error in data section");
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl3.c0000644000175100001710000064642400000000000023733 0ustar00runnerdocker00000000000000/* mpl3.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"

/**********************************************************************/
/* * *                   FLOATING-POINT NUMBERS                   * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- fp_add - floating-point addition.
--
-- This routine computes the sum x + y. */

double fp_add(MPL *mpl, double x, double y)
{     if (x > 0.0 && y > 0.0 && x > + 0.999 * DBL_MAX - y ||
          x < 0.0 && y < 0.0 && x < - 0.999 * DBL_MAX - y)
         error(mpl, "%.*g + %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      return x + y;
}

/*----------------------------------------------------------------------
-- fp_sub - floating-point subtraction.
--
-- This routine computes the difference x - y. */

double fp_sub(MPL *mpl, double x, double y)
{     if (x > 0.0 && y < 0.0 && x > + 0.999 * DBL_MAX + y ||
          x < 0.0 && y > 0.0 && x < - 0.999 * DBL_MAX + y)
         error(mpl, "%.*g - %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      return x - y;
}

/*----------------------------------------------------------------------
-- fp_less - floating-point non-negative subtraction.
--
-- This routine computes the non-negative difference max(0, x - y). */

double fp_less(MPL *mpl, double x, double y)
{     if (x < y) return 0.0;
      if (x > 0.0 && y < 0.0 && x > + 0.999 * DBL_MAX + y)
         error(mpl, "%.*g less %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      return x - y;
}

/*----------------------------------------------------------------------
-- fp_mul - floating-point multiplication.
--
-- This routine computes the product x * y. */

double fp_mul(MPL *mpl, double x, double y)
{     if (fabs(y) > 1.0 && fabs(x) > (0.999 * DBL_MAX) / fabs(y))
         error(mpl, "%.*g * %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      return x * y;
}

/*----------------------------------------------------------------------
-- fp_div - floating-point division.
--
-- This routine computes the quotient x / y. */

double fp_div(MPL *mpl, double x, double y)
{     if (fabs(y) < DBL_MIN)
         error(mpl, "%.*g / %.*g; floating-point zero divide",
            DBL_DIG, x, DBL_DIG, y);
      if (fabs(y) < 1.0 && fabs(x) > (0.999 * DBL_MAX) * fabs(y))
         error(mpl, "%.*g / %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      return x / y;
}

/*----------------------------------------------------------------------
-- fp_idiv - floating-point quotient of exact division.
--
-- This routine computes the quotient of exact division x div y. */

double fp_idiv(MPL *mpl, double x, double y)
{     if (fabs(y) < DBL_MIN)
         error(mpl, "%.*g div %.*g; floating-point zero divide",
            DBL_DIG, x, DBL_DIG, y);
      if (fabs(y) < 1.0 && fabs(x) > (0.999 * DBL_MAX) * fabs(y))
         error(mpl, "%.*g div %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      x /= y;
      return x > 0.0 ? floor(x) : x < 0.0 ? ceil(x) : 0.0;
}

/*----------------------------------------------------------------------
-- fp_mod - floating-point remainder of exact division.
--
-- This routine computes the remainder of exact division x mod y.
--
-- NOTE: By definition x mod y = x - y * floor(x / y). */

double fp_mod(MPL *mpl, double x, double y)
{     double r;
      xassert(mpl == mpl);
      if (x == 0.0)
         r = 0.0;
      else if (y == 0.0)
         r = x;
      else
      {  r = fmod(fabs(x), fabs(y));
         if (r != 0.0)
         {  if (x < 0.0) r = - r;
            if (x > 0.0 && y < 0.0 || x < 0.0 && y > 0.0) r += y;
         }
      }
      return r;
}

/*----------------------------------------------------------------------
-- fp_power - floating-point exponentiation (raise to power).
--
-- This routine computes the exponentiation x ** y. */

double fp_power(MPL *mpl, double x, double y)
{     double r;
      if (x == 0.0 && y <= 0.0 || x < 0.0 && y != floor(y))
         error(mpl, "%.*g ** %.*g; result undefined",
            DBL_DIG, x, DBL_DIG, y);
      if (x == 0.0) goto eval;
      if (fabs(x) > 1.0 && y > +1.0 &&
            +log(fabs(x)) > (0.999 * log(DBL_MAX)) / y ||
          fabs(x) < 1.0 && y < -1.0 &&
            +log(fabs(x)) < (0.999 * log(DBL_MAX)) / y)
         error(mpl, "%.*g ** %.*g; floating-point overflow",
            DBL_DIG, x, DBL_DIG, y);
      if (fabs(x) > 1.0 && y < -1.0 &&
            -log(fabs(x)) < (0.999 * log(DBL_MAX)) / y ||
          fabs(x) < 1.0 && y > +1.0 &&
            -log(fabs(x)) > (0.999 * log(DBL_MAX)) / y)
         r = 0.0;
      else
eval:    r = pow(x, y);
      return r;
}

/*----------------------------------------------------------------------
-- fp_exp - floating-point base-e exponential.
--
-- This routine computes the base-e exponential e ** x. */

double fp_exp(MPL *mpl, double x)
{     if (x > 0.999 * log(DBL_MAX))
         error(mpl, "exp(%.*g); floating-point overflow", DBL_DIG, x);
      return exp(x);
}

/*----------------------------------------------------------------------
-- fp_log - floating-point natural logarithm.
--
-- This routine computes the natural logarithm log x. */

double fp_log(MPL *mpl, double x)
{     if (x <= 0.0)
         error(mpl, "log(%.*g); non-positive argument", DBL_DIG, x);
      return log(x);
}

/*----------------------------------------------------------------------
-- fp_log10 - floating-point common (decimal) logarithm.
--
-- This routine computes the common (decimal) logarithm lg x. */

double fp_log10(MPL *mpl, double x)
{     if (x <= 0.0)
         error(mpl, "log10(%.*g); non-positive argument", DBL_DIG, x);
      return log10(x);
}

/*----------------------------------------------------------------------
-- fp_sqrt - floating-point square root.
--
-- This routine computes the square root x ** 0.5. */

double fp_sqrt(MPL *mpl, double x)
{     if (x < 0.0)
         error(mpl, "sqrt(%.*g); negative argument", DBL_DIG, x);
      return sqrt(x);
}

/*----------------------------------------------------------------------
-- fp_sin - floating-point trigonometric sine.
--
-- This routine computes the trigonometric sine sin(x). */

double fp_sin(MPL *mpl, double x)
{     if (!(-1e6 <= x && x <= +1e6))
         error(mpl, "sin(%.*g); argument too large", DBL_DIG, x);
      return sin(x);
}

/*----------------------------------------------------------------------
-- fp_cos - floating-point trigonometric cosine.
--
-- This routine computes the trigonometric cosine cos(x). */

double fp_cos(MPL *mpl, double x)
{     if (!(-1e6 <= x && x <= +1e6))
         error(mpl, "cos(%.*g); argument too large", DBL_DIG, x);
      return cos(x);
}

/*----------------------------------------------------------------------
-- fp_tan - floating-point trigonometric tangent.
--
-- This routine computes the trigonometric tangent tan(x). */

double fp_tan(MPL *mpl, double x)
{     if (!(-1e6 <= x && x <= +1e6))
         error(mpl, "tan(%.*g); argument too large", DBL_DIG, x);
      return tan(x);
}

/*----------------------------------------------------------------------
-- fp_atan - floating-point trigonometric arctangent.
--
-- This routine computes the trigonometric arctangent atan(x). */

double fp_atan(MPL *mpl, double x)
{     xassert(mpl == mpl);
      return atan(x);
}

/*----------------------------------------------------------------------
-- fp_atan2 - floating-point trigonometric arctangent.
--
-- This routine computes the trigonometric arctangent atan(y / x). */

double fp_atan2(MPL *mpl, double y, double x)
{     xassert(mpl == mpl);
      return atan2(y, x);
}

/*----------------------------------------------------------------------
-- fp_round - round floating-point value to n fractional digits.
--
-- This routine rounds given floating-point value x to n fractional
-- digits with the formula:
--
--    round(x, n) = floor(x * 10^n + 0.5) / 10^n.
--
-- The parameter n is assumed to be integer. */

double fp_round(MPL *mpl, double x, double n)
{     double ten_to_n;
      if (n != floor(n))
         error(mpl, "round(%.*g, %.*g); non-integer second argument",
            DBL_DIG, x, DBL_DIG, n);
      if (n <= DBL_DIG + 2)
      {  ten_to_n = pow(10.0, n);
         if (fabs(x) < (0.999 * DBL_MAX) / ten_to_n)
         {  x = floor(x * ten_to_n + 0.5);
            if (x != 0.0) x /= ten_to_n;
         }
      }
      return x;
}

/*----------------------------------------------------------------------
-- fp_trunc - truncate floating-point value to n fractional digits.
--
-- This routine truncates given floating-point value x to n fractional
-- digits with the formula:
--
--                  ( floor(x * 10^n) / 10^n,  if x >= 0
--    trunc(x, n) = <
--                  ( ceil(x * 10^n) / 10^n,   if x < 0
--
-- The parameter n is assumed to be integer. */

double fp_trunc(MPL *mpl, double x, double n)
{     double ten_to_n;
      if (n != floor(n))
         error(mpl, "trunc(%.*g, %.*g); non-integer second argument",
            DBL_DIG, x, DBL_DIG, n);
      if (n <= DBL_DIG + 2)
      {  ten_to_n = pow(10.0, n);
         if (fabs(x) < (0.999 * DBL_MAX) / ten_to_n)
         {  x = (x >= 0.0 ? floor(x * ten_to_n) : ceil(x * ten_to_n));
            if (x != 0.0) x /= ten_to_n;
         }
      }
      return x;
}

/**********************************************************************/
/* * *              PSEUDO-RANDOM NUMBER GENERATORS               * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- fp_irand224 - pseudo-random integer in the range [0, 2^24).
--
-- This routine returns a next pseudo-random integer (converted to
-- floating-point) which is uniformly distributed between 0 and 2^24-1,
-- inclusive. */

#define two_to_the_24 0x1000000

double fp_irand224(MPL *mpl)
{     return
         (double)rng_unif_rand(mpl->rand, two_to_the_24);
}

/*----------------------------------------------------------------------
-- fp_uniform01 - pseudo-random number in the range [0, 1).
--
-- This routine returns a next pseudo-random number which is uniformly
-- distributed in the range [0, 1). */

#define two_to_the_31 ((unsigned int)0x80000000)

double fp_uniform01(MPL *mpl)
{     return
         (double)rng_next_rand(mpl->rand) / (double)two_to_the_31;
}

/*----------------------------------------------------------------------
-- fp_uniform - pseudo-random number in the range [a, b).
--
-- This routine returns a next pseudo-random number which is uniformly
-- distributed in the range [a, b). */

double fp_uniform(MPL *mpl, double a, double b)
{     double x;
      if (a >= b)
         error(mpl, "Uniform(%.*g, %.*g); invalid range",
            DBL_DIG, a, DBL_DIG, b);
      x = fp_uniform01(mpl);
#if 0
      x = a * (1.0 - x) + b * x;
#else
      x = fp_add(mpl, a * (1.0 - x), b * x);
#endif
      return x;
}

/*----------------------------------------------------------------------
-- fp_normal01 - Gaussian random variate with mu = 0 and sigma = 1.
--
-- This routine returns a Gaussian random variate with zero mean and
-- unit standard deviation. The polar (Box-Mueller) method is used.
--
-- This code is a modified version of the routine gsl_ran_gaussian from
-- the GNU Scientific Library Version 1.0. */

double fp_normal01(MPL *mpl)
{     double x, y, r2;
      do
      {  /* choose x, y in uniform square (-1,-1) to (+1,+1) */
         x = -1.0 + 2.0 * fp_uniform01(mpl);
         y = -1.0 + 2.0 * fp_uniform01(mpl);
         /* see if it is in the unit circle */
         r2 = x * x + y * y;
      } while (r2 > 1.0 || r2 == 0.0);
      /* Box-Muller transform */
      return y * sqrt(-2.0 * log (r2) / r2);
}

/*----------------------------------------------------------------------
-- fp_normal - Gaussian random variate with specified mu and sigma.
--
-- This routine returns a Gaussian random variate with mean mu and
-- standard deviation sigma. */

double fp_normal(MPL *mpl, double mu, double sigma)
{     double x;
#if 0
      x = mu + sigma * fp_normal01(mpl);
#else
      x = fp_add(mpl, mu, fp_mul(mpl, sigma, fp_normal01(mpl)));
#endif
      return x;
}

/**********************************************************************/
/* * *                SEGMENTED CHARACTER STRINGS                 * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_string - create character string.
--
-- This routine creates a segmented character string, which is exactly
-- equivalent to specified character string. */

STRING *create_string
(     MPL *mpl,
      char buf[MAX_LENGTH+1]  /* not changed */
)
#if 0
{     STRING *head, *tail;
      int i, j;
      xassert(buf != NULL);
      xassert(strlen(buf) <= MAX_LENGTH);
      head = tail = dmp_get_atom(mpl->strings, sizeof(STRING));
      for (i = j = 0; ; i++)
      {  if ((tail->seg[j++] = buf[i]) == '\0') break;
         if (j == STRSEG_SIZE)
tail = (tail->next = dmp_get_atom(mpl->strings, sizeof(STRING))), j = 0;
      }
      tail->next = NULL;
      return head;
}
#else
{     STRING *str;
      xassert(strlen(buf) <= MAX_LENGTH);
      str = dmp_get_atom(mpl->strings, strlen(buf)+1);
      strcpy(str, buf);
      return str;
}
#endif

/*----------------------------------------------------------------------
-- copy_string - make copy of character string.
--
-- This routine returns an exact copy of segmented character string. */

STRING *copy_string
(     MPL *mpl,
      STRING *str             /* not changed */
)
#if 0
{     STRING *head, *tail;
      xassert(str != NULL);
      head = tail = dmp_get_atom(mpl->strings, sizeof(STRING));
      for (; str != NULL; str = str->next)
      {  memcpy(tail->seg, str->seg, STRSEG_SIZE);
         if (str->next != NULL)
tail = (tail->next = dmp_get_atom(mpl->strings, sizeof(STRING)));
      }
      tail->next = NULL;
      return head;
}
#else
{     xassert(mpl == mpl);
      return create_string(mpl, str);
}
#endif

/*----------------------------------------------------------------------
-- compare_strings - compare one character string with another.
--
-- This routine compares one segmented character strings with another
-- and returns the result of comparison as follows:
--
-- = 0 - both strings are identical;
-- < 0 - the first string precedes the second one;
-- > 0 - the first string follows the second one. */

int compare_strings
(     MPL *mpl,
      STRING *str1,           /* not changed */
      STRING *str2            /* not changed */
)
#if 0
{     int j, c1, c2;
      xassert(mpl == mpl);
      for (;; str1 = str1->next, str2 = str2->next)
      {  xassert(str1 != NULL);
         xassert(str2 != NULL);
         for (j = 0; j < STRSEG_SIZE; j++)
         {  c1 = (unsigned char)str1->seg[j];
            c2 = (unsigned char)str2->seg[j];
            if (c1 < c2) return -1;
            if (c1 > c2) return +1;
            if (c1 == '\0') goto done;
         }
      }
done: return 0;
}
#else
{     xassert(mpl == mpl);
      return strcmp(str1, str2);
}
#endif

/*----------------------------------------------------------------------
-- fetch_string - extract content of character string.
--
-- This routine returns a character string, which is exactly equivalent
-- to specified segmented character string. */

char *fetch_string
(     MPL *mpl,
      STRING *str,            /* not changed */
      char buf[MAX_LENGTH+1]  /* modified */
)
#if 0
{     int i, j;
      xassert(mpl == mpl);
      xassert(buf != NULL);
      for (i = 0; ; str = str->next)
      {  xassert(str != NULL);
         for (j = 0; j < STRSEG_SIZE; j++)
            if ((buf[i++] = str->seg[j]) == '\0') goto done;
      }
done: xassert(strlen(buf) <= MAX_LENGTH);
      return buf;
}
#else
{     xassert(mpl == mpl);
      return strcpy(buf, str);
}
#endif

/*----------------------------------------------------------------------
-- delete_string - delete character string.
--
-- This routine deletes specified segmented character string. */

void delete_string
(     MPL *mpl,
      STRING *str             /* destroyed */
)
#if 0
{     STRING *temp;
      xassert(str != NULL);
      while (str != NULL)
      {  temp = str;
         str = str->next;
         dmp_free_atom(mpl->strings, temp, sizeof(STRING));
      }
      return;
}
#else
{     dmp_free_atom(mpl->strings, str, strlen(str)+1);
      return;
}
#endif

/**********************************************************************/
/* * *                          SYMBOLS                           * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_symbol_num - create symbol of numeric type.
--
-- This routine creates a symbol, which has a numeric value specified
-- as floating-point number. */

SYMBOL *create_symbol_num(MPL *mpl, double num)
{     SYMBOL *sym;
      sym = dmp_get_atom(mpl->symbols, sizeof(SYMBOL));
      sym->num = num;
      sym->str = NULL;
      return sym;
}

/*----------------------------------------------------------------------
-- create_symbol_str - create symbol of abstract type.
--
-- This routine creates a symbol, which has an abstract value specified
-- as segmented character string. */

SYMBOL *create_symbol_str
(     MPL *mpl,
      STRING *str             /* destroyed */
)
{     SYMBOL *sym;
      xassert(str != NULL);
      sym = dmp_get_atom(mpl->symbols, sizeof(SYMBOL));
      sym->num = 0.0;
      sym->str = str;
      return sym;
}

/*----------------------------------------------------------------------
-- copy_symbol - make copy of symbol.
--
-- This routine returns an exact copy of symbol. */

SYMBOL *copy_symbol
(     MPL *mpl,
      SYMBOL *sym             /* not changed */
)
{     SYMBOL *copy;
      xassert(sym != NULL);
      copy = dmp_get_atom(mpl->symbols, sizeof(SYMBOL));
      if (sym->str == NULL)
      {  copy->num = sym->num;
         copy->str = NULL;
      }
      else
      {  copy->num = 0.0;
         copy->str = copy_string(mpl, sym->str);
      }
      return copy;
}

/*----------------------------------------------------------------------
-- compare_symbols - compare one symbol with another.
--
-- This routine compares one symbol with another and returns the result
-- of comparison as follows:
--
-- = 0 - both symbols are identical;
-- < 0 - the first symbol precedes the second one;
-- > 0 - the first symbol follows the second one.
--
-- Note that the linear order, in which symbols follow each other, is
-- implementation-dependent. It may be not an alphabetical order. */

int compare_symbols
(     MPL *mpl,
      SYMBOL *sym1,           /* not changed */
      SYMBOL *sym2            /* not changed */
)
{     xassert(sym1 != NULL);
      xassert(sym2 != NULL);
      /* let all numeric quantities precede all symbolic quantities */
      if (sym1->str == NULL && sym2->str == NULL)
      {  if (sym1->num < sym2->num) return -1;
         if (sym1->num > sym2->num) return +1;
         return 0;
      }
      if (sym1->str == NULL) return -1;
      if (sym2->str == NULL) return +1;
      return compare_strings(mpl, sym1->str, sym2->str);
}

/*----------------------------------------------------------------------
-- delete_symbol - delete symbol.
--
-- This routine deletes specified symbol. */

void delete_symbol
(     MPL *mpl,
      SYMBOL *sym             /* destroyed */
)
{     xassert(sym != NULL);
      if (sym->str != NULL) delete_string(mpl, sym->str);
      dmp_free_atom(mpl->symbols, sym, sizeof(SYMBOL));
      return;
}

/*----------------------------------------------------------------------
-- format_symbol - format symbol for displaying or printing.
--
-- This routine converts specified symbol to a charater string, which
-- is suitable for displaying or printing.
--
-- The resultant string is never longer than 255 characters. If it gets
-- longer, it is truncated from the right and appended by dots. */

char *format_symbol
(     MPL *mpl,
      SYMBOL *sym             /* not changed */
)
{     char *buf = mpl->sym_buf;
      xassert(sym != NULL);
      if (sym->str == NULL)
         sprintf(buf, "%.*g", DBL_DIG, sym->num);
      else
      {  char str[MAX_LENGTH+1];
         int quoted, j, len;
         fetch_string(mpl, sym->str, str);
         if (!(isalpha((unsigned char)str[0]) || str[0] == '_'))
            quoted = 1;
         else
         {  quoted = 0;
            for (j = 1; str[j] != '\0'; j++)
            {  if (!(isalnum((unsigned char)str[j]) ||
                     strchr("+-._", (unsigned char)str[j]) != NULL))
               {  quoted = 1;
                  break;
               }
            }
         }
#        define safe_append(c) \
            (void)(len < 255 ? (buf[len++] = (char)(c)) : 0)
         buf[0] = '\0', len = 0;
         if (quoted) safe_append('\'');
         for (j = 0; str[j] != '\0'; j++)
         {  if (quoted && str[j] == '\'') safe_append('\'');
            safe_append(str[j]);
         }
         if (quoted) safe_append('\'');
#        undef safe_append
         buf[len] = '\0';
         if (len == 255) strcpy(buf+252, "...");
      }
      xassert(strlen(buf) <= 255);
      return buf;
}

/*----------------------------------------------------------------------
-- concat_symbols - concatenate one symbol with another.
--
-- This routine concatenates values of two given symbols and assigns
-- the resultant character string to a new symbol, which is returned on
-- exit. Both original symbols are destroyed. */

SYMBOL *concat_symbols
(     MPL *mpl,
      SYMBOL *sym1,           /* destroyed */
      SYMBOL *sym2            /* destroyed */
)
{     char str1[MAX_LENGTH+1], str2[MAX_LENGTH+1];
      xassert(MAX_LENGTH >= DBL_DIG + DBL_DIG);
      if (sym1->str == NULL)
         sprintf(str1, "%.*g", DBL_DIG, sym1->num);
      else
         fetch_string(mpl, sym1->str, str1);
      if (sym2->str == NULL)
         sprintf(str2, "%.*g", DBL_DIG, sym2->num);
      else
         fetch_string(mpl, sym2->str, str2);
      if (strlen(str1) + strlen(str2) > MAX_LENGTH)
      {  char buf[255+1];
         strcpy(buf, format_symbol(mpl, sym1));
         xassert(strlen(buf) < sizeof(buf));
         error(mpl, "%s & %s; resultant symbol exceeds %d characters",
            buf, format_symbol(mpl, sym2), MAX_LENGTH);
      }
      delete_symbol(mpl, sym1);
      delete_symbol(mpl, sym2);
      return create_symbol_str(mpl, create_string(mpl, strcat(str1,
         str2)));
}

/**********************************************************************/
/* * *                          N-TUPLES                          * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_tuple - create n-tuple.
--
-- This routine creates a n-tuple, which initially has no components,
-- i.e. which is 0-tuple. */

TUPLE *create_tuple(MPL *mpl)
{     TUPLE *tuple;
      xassert(mpl == mpl);
      tuple = NULL;
      return tuple;
}

/*----------------------------------------------------------------------
-- expand_tuple - append symbol to n-tuple.
--
-- This routine expands n-tuple appending to it a given symbol, which
-- becomes its new last component. */

TUPLE *expand_tuple
(     MPL *mpl,
      TUPLE *tuple,           /* destroyed */
      SYMBOL *sym             /* destroyed */
)
{     TUPLE *tail, *temp;
      xassert(sym != NULL);
      /* create a new component */
      tail = dmp_get_atom(mpl->tuples, sizeof(TUPLE));
      tail->sym = sym;
      tail->next = NULL;
      /* and append it to the component list */
      if (tuple == NULL)
         tuple = tail;
      else
      {  for (temp = tuple; temp->next != NULL; temp = temp->next);
         temp->next = tail;
      }
      return tuple;
}

/*----------------------------------------------------------------------
-- tuple_dimen - determine dimension of n-tuple.
--
-- This routine returns dimension of n-tuple, i.e. number of components
-- in the n-tuple. */

int tuple_dimen
(     MPL *mpl,
      TUPLE *tuple            /* not changed */
)
{     TUPLE *temp;
      int dim = 0;
      xassert(mpl == mpl);
      for (temp = tuple; temp != NULL; temp = temp->next) dim++;
      return dim;
}

/*----------------------------------------------------------------------
-- copy_tuple - make copy of n-tuple.
--
-- This routine returns an exact copy of n-tuple. */

TUPLE *copy_tuple
(     MPL *mpl,
      TUPLE *tuple            /* not changed */
)
{     TUPLE *head, *tail;
      if (tuple == NULL)
         head = NULL;
      else
      {  head = tail = dmp_get_atom(mpl->tuples, sizeof(TUPLE));
         for (; tuple != NULL; tuple = tuple->next)
         {  xassert(tuple->sym != NULL);
            tail->sym = copy_symbol(mpl, tuple->sym);
            if (tuple->next != NULL)
tail = (tail->next = dmp_get_atom(mpl->tuples, sizeof(TUPLE)));
         }
         tail->next = NULL;
      }
      return head;
}

/*----------------------------------------------------------------------
-- compare_tuples - compare one n-tuple with another.
--
-- This routine compares two given n-tuples, which must have the same
-- dimension (not checked for the sake of efficiency), and returns one
-- of the following codes:
--
-- = 0 - both n-tuples are identical;
-- < 0 - the first n-tuple precedes the second one;
-- > 0 - the first n-tuple follows the second one.
--
-- Note that the linear order, in which n-tuples follow each other, is
-- implementation-dependent. It may be not an alphabetical order. */

int compare_tuples
(     MPL *mpl,
      TUPLE *tuple1,          /* not changed */
      TUPLE *tuple2           /* not changed */
)
{     TUPLE *item1, *item2;
      int ret;
      xassert(mpl == mpl);
      for (item1 = tuple1, item2 = tuple2; item1 != NULL;
           item1 = item1->next, item2 = item2->next)
      {  xassert(item2 != NULL);
         xassert(item1->sym != NULL);
         xassert(item2->sym != NULL);
         ret = compare_symbols(mpl, item1->sym, item2->sym);
         if (ret != 0) return ret;
      }
      xassert(item2 == NULL);
      return 0;
}

/*----------------------------------------------------------------------
-- build_subtuple - build subtuple of given n-tuple.
--
-- This routine builds subtuple, which consists of first dim components
-- of given n-tuple. */

TUPLE *build_subtuple
(     MPL *mpl,
      TUPLE *tuple,           /* not changed */
      int dim
)
{     TUPLE *head, *temp;
      int j;
      head = create_tuple(mpl);
      for (j = 1, temp = tuple; j <= dim; j++, temp = temp->next)
      {  xassert(temp != NULL);
         head = expand_tuple(mpl, head, copy_symbol(mpl, temp->sym));
      }
      return head;
}

/*----------------------------------------------------------------------
-- delete_tuple - delete n-tuple.
--
-- This routine deletes specified n-tuple. */

void delete_tuple
(     MPL *mpl,
      TUPLE *tuple            /* destroyed */
)
{     TUPLE *temp;
      while (tuple != NULL)
      {  temp = tuple;
         tuple = temp->next;
         xassert(temp->sym != NULL);
         delete_symbol(mpl, temp->sym);
         dmp_free_atom(mpl->tuples, temp, sizeof(TUPLE));
      }
      return;
}

/*----------------------------------------------------------------------
-- format_tuple - format n-tuple for displaying or printing.
--
-- This routine converts specified n-tuple to a character string, which
-- is suitable for displaying or printing.
--
-- The resultant string is never longer than 255 characters. If it gets
-- longer, it is truncated from the right and appended by dots. */

char *format_tuple
(     MPL *mpl,
      int c,
      TUPLE *tuple            /* not changed */
)
{     TUPLE *temp;
      int dim, j, len;
      char *buf = mpl->tup_buf, str[255+1], *save;
#     define safe_append(c) \
         (void)(len < 255 ? (buf[len++] = (char)(c)) : 0)
      buf[0] = '\0', len = 0;
      dim = tuple_dimen(mpl, tuple);
      if (c == '[' && dim > 0) safe_append('[');
      if (c == '(' && dim > 1) safe_append('(');
      for (temp = tuple; temp != NULL; temp = temp->next)
      {  if (temp != tuple) safe_append(',');
         xassert(temp->sym != NULL);
         save = mpl->sym_buf;
         mpl->sym_buf = str;
         format_symbol(mpl, temp->sym);
         mpl->sym_buf = save;
         xassert(strlen(str) < sizeof(str));
         for (j = 0; str[j] != '\0'; j++) safe_append(str[j]);
      }
      if (c == '[' && dim > 0) safe_append(']');
      if (c == '(' && dim > 1) safe_append(')');
#     undef safe_append
      buf[len] = '\0';
      if (len == 255) strcpy(buf+252, "...");
      xassert(strlen(buf) <= 255);
      return buf;
}

/**********************************************************************/
/* * *                       ELEMENTAL SETS                       * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_elemset - create elemental set.
--
-- This routine creates an elemental set, whose members are n-tuples of
-- specified dimension. Being created the set is initially empty. */

ELEMSET *create_elemset(MPL *mpl, int dim)
{     ELEMSET *set;
      xassert(dim > 0);
      set = create_array(mpl, A_NONE, dim);
      return set;
}

/*----------------------------------------------------------------------
-- find_tuple - check if elemental set contains given n-tuple.
--
-- This routine finds given n-tuple in specified elemental set in order
-- to check if the set contains that n-tuple. If the n-tuple is found,
-- the routine returns pointer to corresponding array member. Otherwise
-- null pointer is returned. */

MEMBER *find_tuple
(     MPL *mpl,
      ELEMSET *set,           /* not changed */
      TUPLE *tuple            /* not changed */
)
{     xassert(set != NULL);
      xassert(set->type == A_NONE);
      xassert(set->dim == tuple_dimen(mpl, tuple));
      return find_member(mpl, set, tuple);
}

/*----------------------------------------------------------------------
-- add_tuple - add new n-tuple to elemental set.
--
-- This routine adds given n-tuple to specified elemental set.
--
-- For the sake of efficiency this routine doesn't check whether the
-- set already contains the same n-tuple or not. Therefore the calling
-- program should use the routine find_tuple (if necessary) in order to
-- make sure that the given n-tuple is not contained in the set, since
-- duplicate n-tuples within the same set are not allowed. */

MEMBER *add_tuple
(     MPL *mpl,
      ELEMSET *set,           /* modified */
      TUPLE *tuple            /* destroyed */
)
{     MEMBER *memb;
      xassert(set != NULL);
      xassert(set->type == A_NONE);
      xassert(set->dim == tuple_dimen(mpl, tuple));
      memb = add_member(mpl, set, tuple);
      memb->value.none = NULL;
      return memb;
}

/*----------------------------------------------------------------------
-- check_then_add - check and add new n-tuple to elemental set.
--
-- This routine is equivalent to the routine add_tuple except that it
-- does check for duplicate n-tuples. */

MEMBER *check_then_add
(     MPL *mpl,
      ELEMSET *set,           /* modified */
      TUPLE *tuple            /* destroyed */
)
{     if (find_tuple(mpl, set, tuple) != NULL)
         error(mpl, "duplicate tuple %s detected", format_tuple(mpl,
            '(', tuple));
      return add_tuple(mpl, set, tuple);
}

/*----------------------------------------------------------------------
-- copy_elemset - make copy of elemental set.
--
-- This routine makes an exact copy of elemental set. */

ELEMSET *copy_elemset
(     MPL *mpl,
      ELEMSET *set            /* not changed */
)
{     ELEMSET *copy;
      MEMBER *memb;
      xassert(set != NULL);
      xassert(set->type == A_NONE);
      xassert(set->dim > 0);
      copy = create_elemset(mpl, set->dim);
      for (memb = set->head; memb != NULL; memb = memb->next)
         add_tuple(mpl, copy, copy_tuple(mpl, memb->tuple));
      return copy;
}

/*----------------------------------------------------------------------
-- delete_elemset - delete elemental set.
--
-- This routine deletes specified elemental set. */

void delete_elemset
(     MPL *mpl,
      ELEMSET *set            /* destroyed */
)
{     xassert(set != NULL);
      xassert(set->type == A_NONE);
      delete_array(mpl, set);
      return;
}

/*----------------------------------------------------------------------
-- arelset_size - compute size of "arithmetic" elemental set.
--
-- This routine computes the size of "arithmetic" elemental set, which
-- is specified in the form of arithmetic progression:
--
--    { t0 .. tf by dt }.
--
-- The size is computed using the formula:
--
--    n = max(0, floor((tf - t0) / dt) + 1). */

int arelset_size(MPL *mpl, double t0, double tf, double dt)
{     double temp;
      if (dt == 0.0)
         error(mpl, "%.*g .. %.*g by %.*g; zero stride not allowed",
            DBL_DIG, t0, DBL_DIG, tf, DBL_DIG, dt);
      if (tf > 0.0 && t0 < 0.0 && tf > + 0.999 * DBL_MAX + t0)
         temp = +DBL_MAX;
      else if (tf < 0.0 && t0 > 0.0 && tf < - 0.999 * DBL_MAX + t0)
         temp = -DBL_MAX;
      else
         temp = tf - t0;
      if (fabs(dt) < 1.0 && fabs(temp) > (0.999 * DBL_MAX) * fabs(dt))
      {  if (temp > 0.0 && dt > 0.0 || temp < 0.0 && dt < 0.0)
            temp = +DBL_MAX;
         else
            temp = 0.0;
      }
      else
      {  temp = floor(temp / dt) + 1.0;
         if (temp < 0.0) temp = 0.0;
      }
      xassert(temp >= 0.0);
      if (temp > (double)(INT_MAX - 1))
         error(mpl, "%.*g .. %.*g by %.*g; set too large",
            DBL_DIG, t0, DBL_DIG, tf, DBL_DIG, dt);
      return (int)(temp + 0.5);
}

/*----------------------------------------------------------------------
-- arelset_member - compute member of "arithmetic" elemental set.
--
-- This routine returns a numeric value of symbol, which is equivalent
-- to j-th member of given "arithmetic" elemental set specified in the
-- form of arithmetic progression:
--
--    { t0 .. tf by dt }.
--
-- The symbol value is computed with the formula:
--
--    j-th member = t0 + (j - 1) * dt,
--
-- The number j must satisfy to the restriction 1 <= j <= n, where n is
-- the set size computed by the routine arelset_size. */

double arelset_member(MPL *mpl, double t0, double tf, double dt, int j)
{     xassert(1 <= j && j <= arelset_size(mpl, t0, tf, dt));
      return t0 + (double)(j - 1) * dt;
}

/*----------------------------------------------------------------------
-- create_arelset - create "arithmetic" elemental set.
--
-- This routine creates "arithmetic" elemental set, which is specified
-- in the form of arithmetic progression:
--
--    { t0 .. tf by dt }.
--
-- Components of this set are 1-tuples. */

ELEMSET *create_arelset(MPL *mpl, double t0, double tf, double dt)
{     ELEMSET *set;
      int j, n;
      set = create_elemset(mpl, 1);
      n = arelset_size(mpl, t0, tf, dt);
      for (j = 1; j <= n; j++)
      {  add_tuple
         (  mpl,
            set,
            expand_tuple
            (  mpl,
               create_tuple(mpl),
               create_symbol_num
               (  mpl,
                  arelset_member(mpl, t0, tf, dt, j)
               )
            )
         );
      }
      return set;
}

/*----------------------------------------------------------------------
-- set_union - union of two elemental sets.
--
-- This routine computes the union:
--
--    X U Y = { j | (j in X) or (j in Y) },
--
-- where X and Y are given elemental sets (destroyed on exit). */

ELEMSET *set_union
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
)
{     MEMBER *memb;
      xassert(X != NULL);
      xassert(X->type == A_NONE);
      xassert(X->dim > 0);
      xassert(Y != NULL);
      xassert(Y->type == A_NONE);
      xassert(Y->dim > 0);
      xassert(X->dim == Y->dim);
      for (memb = Y->head; memb != NULL; memb = memb->next)
      {  if (find_tuple(mpl, X, memb->tuple) == NULL)
            add_tuple(mpl, X, copy_tuple(mpl, memb->tuple));
      }
      delete_elemset(mpl, Y);
      return X;
}

/*----------------------------------------------------------------------
-- set_diff - difference between two elemental sets.
--
-- This routine computes the difference:
--
--    X \ Y = { j | (j in X) and (j not in Y) },
--
-- where X and Y are given elemental sets (destroyed on exit). */

ELEMSET *set_diff
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
)
{     ELEMSET *Z;
      MEMBER *memb;
      xassert(X != NULL);
      xassert(X->type == A_NONE);
      xassert(X->dim > 0);
      xassert(Y != NULL);
      xassert(Y->type == A_NONE);
      xassert(Y->dim > 0);
      xassert(X->dim == Y->dim);
      Z = create_elemset(mpl, X->dim);
      for (memb = X->head; memb != NULL; memb = memb->next)
      {  if (find_tuple(mpl, Y, memb->tuple) == NULL)
            add_tuple(mpl, Z, copy_tuple(mpl, memb->tuple));
      }
      delete_elemset(mpl, X);
      delete_elemset(mpl, Y);
      return Z;
}

/*----------------------------------------------------------------------
-- set_symdiff - symmetric difference between two elemental sets.
--
-- This routine computes the symmetric difference:
--
--    X (+) Y = (X \ Y) U (Y \ X),
--
-- where X and Y are given elemental sets (destroyed on exit). */

ELEMSET *set_symdiff
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
)
{     ELEMSET *Z;
      MEMBER *memb;
      xassert(X != NULL);
      xassert(X->type == A_NONE);
      xassert(X->dim > 0);
      xassert(Y != NULL);
      xassert(Y->type == A_NONE);
      xassert(Y->dim > 0);
      xassert(X->dim == Y->dim);
      /* Z := X \ Y */
      Z = create_elemset(mpl, X->dim);
      for (memb = X->head; memb != NULL; memb = memb->next)
      {  if (find_tuple(mpl, Y, memb->tuple) == NULL)
            add_tuple(mpl, Z, copy_tuple(mpl, memb->tuple));
      }
      /* Z := Z U (Y \ X) */
      for (memb = Y->head; memb != NULL; memb = memb->next)
      {  if (find_tuple(mpl, X, memb->tuple) == NULL)
            add_tuple(mpl, Z, copy_tuple(mpl, memb->tuple));
      }
      delete_elemset(mpl, X);
      delete_elemset(mpl, Y);
      return Z;
}

/*----------------------------------------------------------------------
-- set_inter - intersection of two elemental sets.
--
-- This routine computes the intersection:
--
--    X ^ Y = { j | (j in X) and (j in Y) },
--
-- where X and Y are given elemental sets (destroyed on exit). */

ELEMSET *set_inter
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
)
{     ELEMSET *Z;
      MEMBER *memb;
      xassert(X != NULL);
      xassert(X->type == A_NONE);
      xassert(X->dim > 0);
      xassert(Y != NULL);
      xassert(Y->type == A_NONE);
      xassert(Y->dim > 0);
      xassert(X->dim == Y->dim);
      Z = create_elemset(mpl, X->dim);
      for (memb = X->head; memb != NULL; memb = memb->next)
      {  if (find_tuple(mpl, Y, memb->tuple) != NULL)
            add_tuple(mpl, Z, copy_tuple(mpl, memb->tuple));
      }
      delete_elemset(mpl, X);
      delete_elemset(mpl, Y);
      return Z;
}

/*----------------------------------------------------------------------
-- set_cross - cross (Cartesian) product of two elemental sets.
--
-- This routine computes the cross (Cartesian) product:
--
--    X x Y = { (i,j) | (i in X) and (j in Y) },
--
-- where X and Y are given elemental sets (destroyed on exit). */

ELEMSET *set_cross
(     MPL *mpl,
      ELEMSET *X,             /* destroyed */
      ELEMSET *Y              /* destroyed */
)
{     ELEMSET *Z;
      MEMBER *memx, *memy;
      TUPLE *tuple, *temp;
      xassert(X != NULL);
      xassert(X->type == A_NONE);
      xassert(X->dim > 0);
      xassert(Y != NULL);
      xassert(Y->type == A_NONE);
      xassert(Y->dim > 0);
      Z = create_elemset(mpl, X->dim + Y->dim);
      for (memx = X->head; memx != NULL; memx = memx->next)
      {  for (memy = Y->head; memy != NULL; memy = memy->next)
         {  tuple = copy_tuple(mpl, memx->tuple);
            for (temp = memy->tuple; temp != NULL; temp = temp->next)
               tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
                  temp->sym));
            add_tuple(mpl, Z, tuple);
         }
      }
      delete_elemset(mpl, X);
      delete_elemset(mpl, Y);
      return Z;
}

/**********************************************************************/
/* * *                    ELEMENTAL VARIABLES                     * * */
/**********************************************************************/

/* (there are no specific routines for elemental variables) */

/**********************************************************************/
/* * *                        LINEAR FORMS                        * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- constant_term - create constant term.
--
-- This routine creates the linear form, which is a constant term. */

FORMULA *constant_term(MPL *mpl, double coef)
{     FORMULA *form;
      if (coef == 0.0)
         form = NULL;
      else
      {  form = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
         form->coef = coef;
         form->var = NULL;
         form->next = NULL;
      }
      return form;
}

/*----------------------------------------------------------------------
-- single_variable - create single variable.
--
-- This routine creates the linear form, which is a single elemental
-- variable. */

FORMULA *single_variable
(     MPL *mpl,
      ELEMVAR *var            /* referenced */
)
{     FORMULA *form;
      xassert(var != NULL);
      form = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
      form->coef = 1.0;
      form->var = var;
      form->next = NULL;
      return form;
}

/*----------------------------------------------------------------------
-- copy_formula - make copy of linear form.
--
-- This routine returns an exact copy of linear form. */

FORMULA *copy_formula
(     MPL *mpl,
      FORMULA *form           /* not changed */
)
{     FORMULA *head, *tail;
      if (form == NULL)
         head = NULL;
      else
      {  head = tail = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
         for (; form != NULL; form = form->next)
         {  tail->coef = form->coef;
            tail->var = form->var;
            if (form->next != NULL)
tail = (tail->next = dmp_get_atom(mpl->formulae, sizeof(FORMULA)));
         }
         tail->next = NULL;
      }
      return head;
}

/*----------------------------------------------------------------------
-- delete_formula - delete linear form.
--
-- This routine deletes specified linear form. */

void delete_formula
(     MPL *mpl,
      FORMULA *form           /* destroyed */
)
{     FORMULA *temp;
      while (form != NULL)
      {  temp = form;
         form = form->next;
         dmp_free_atom(mpl->formulae, temp, sizeof(FORMULA));
      }
      return;
}

/*----------------------------------------------------------------------
-- linear_comb - linear combination of two linear forms.
--
-- This routine computes the linear combination:
--
--    a * fx + b * fy,
--
-- where a and b are numeric coefficients, fx and fy are linear forms
-- (destroyed on exit). */

FORMULA *linear_comb
(     MPL *mpl,
      double a, FORMULA *fx,  /* destroyed */
      double b, FORMULA *fy   /* destroyed */
)
{     FORMULA *form = NULL, *term, *temp;
      double c0 = 0.0;
      for (term = fx; term != NULL; term = term->next)
      {  if (term->var == NULL)
            c0 = fp_add(mpl, c0, fp_mul(mpl, a, term->coef));
         else
            term->var->temp =
               fp_add(mpl, term->var->temp, fp_mul(mpl, a, term->coef));
      }
      for (term = fy; term != NULL; term = term->next)
      {  if (term->var == NULL)
            c0 = fp_add(mpl, c0, fp_mul(mpl, b, term->coef));
         else
            term->var->temp =
               fp_add(mpl, term->var->temp, fp_mul(mpl, b, term->coef));
      }
      for (term = fx; term != NULL; term = term->next)
      {  if (term->var != NULL && term->var->temp != 0.0)
         {  temp = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
            temp->coef = term->var->temp, temp->var = term->var;
            temp->next = form, form = temp;
            term->var->temp = 0.0;
         }
      }
      for (term = fy; term != NULL; term = term->next)
      {  if (term->var != NULL && term->var->temp != 0.0)
         {  temp = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
            temp->coef = term->var->temp, temp->var = term->var;
            temp->next = form, form = temp;
            term->var->temp = 0.0;
         }
      }
      if (c0 != 0.0)
      {  temp = dmp_get_atom(mpl->formulae, sizeof(FORMULA));
         temp->coef = c0, temp->var = NULL;
         temp->next = form, form = temp;
      }
      delete_formula(mpl, fx);
      delete_formula(mpl, fy);
      return form;
}

/*----------------------------------------------------------------------
-- remove_constant - remove constant term from linear form.
--
-- This routine removes constant term from linear form and stores its
-- value to given location. */

FORMULA *remove_constant
(     MPL *mpl,
      FORMULA *form,          /* destroyed */
      double *coef            /* modified */
)
{     FORMULA *head = NULL, *temp;
      *coef = 0.0;
      while (form != NULL)
      {  temp = form;
         form = form->next;
         if (temp->var == NULL)
         {  /* constant term */
            *coef = fp_add(mpl, *coef, temp->coef);
            dmp_free_atom(mpl->formulae, temp, sizeof(FORMULA));
         }
         else
         {  /* linear term */
            temp->next = head;
            head = temp;
         }
      }
      return head;
}

/*----------------------------------------------------------------------
-- reduce_terms - reduce identical terms in linear form.
--
-- This routine reduces identical terms in specified linear form. */

FORMULA *reduce_terms
(     MPL *mpl,
      FORMULA *form           /* destroyed */
)
{     FORMULA *term, *next_term;
      double c0 = 0.0;
      for (term = form; term != NULL; term = term->next)
      {  if (term->var == NULL)
            c0 = fp_add(mpl, c0, term->coef);
         else
            term->var->temp = fp_add(mpl, term->var->temp, term->coef);
      }
      next_term = form, form = NULL;
      for (term = next_term; term != NULL; term = next_term)
      {  next_term = term->next;
         if (term->var == NULL && c0 != 0.0)
         {  term->coef = c0, c0 = 0.0;
            term->next = form, form = term;
         }
         else if (term->var != NULL && term->var->temp != 0.0)
         {  term->coef = term->var->temp, term->var->temp = 0.0;
            term->next = form, form = term;
         }
         else
            dmp_free_atom(mpl->formulae, term, sizeof(FORMULA));
      }
      return form;
}

/**********************************************************************/
/* * *                   ELEMENTAL CONSTRAINTS                    * * */
/**********************************************************************/

/* (there are no specific routines for elemental constraints) */

/**********************************************************************/
/* * *                       GENERIC VALUES                       * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- delete_value - delete generic value.
--
-- This routine deletes specified generic value.
--
-- NOTE: The generic value to be deleted must be valid. */

void delete_value
(     MPL *mpl,
      int type,
      VALUE *value            /* content destroyed */
)
{     xassert(value != NULL);
      switch (type)
      {  case A_NONE:
            value->none = NULL;
            break;
         case A_NUMERIC:
            value->num = 0.0;
            break;
         case A_SYMBOLIC:
            delete_symbol(mpl, value->sym), value->sym = NULL;
            break;
         case A_LOGICAL:
            value->bit = 0;
            break;
         case A_TUPLE:
            delete_tuple(mpl, value->tuple), value->tuple = NULL;
            break;
         case A_ELEMSET:
            delete_elemset(mpl, value->set), value->set = NULL;
            break;
         case A_ELEMVAR:
            value->var = NULL;
            break;
         case A_FORMULA:
            delete_formula(mpl, value->form), value->form = NULL;
            break;
         case A_ELEMCON:
            value->con = NULL;
            break;
         default:
            xassert(type != type);
      }
      return;
}

/**********************************************************************/
/* * *                SYMBOLICALLY INDEXED ARRAYS                 * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- create_array - create array.
--
-- This routine creates an array of specified type and dimension. Being
-- created the array is initially empty.
--
-- The type indicator determines generic values, which can be assigned
-- to the array members:
--
-- A_NONE     - none (members have no assigned values)
-- A_NUMERIC  - floating-point numbers
-- A_SYMBOLIC - symbols
-- A_ELEMSET  - elemental sets
-- A_ELEMVAR  - elemental variables
-- A_ELEMCON  - elemental constraints
--
-- The dimension may be 0, in which case the array consists of the only
-- member (such arrays represent 0-dimensional objects). */

ARRAY *create_array(MPL *mpl, int type, int dim)
{     ARRAY *array;
      xassert(type == A_NONE || type == A_NUMERIC ||
             type == A_SYMBOLIC || type == A_ELEMSET ||
             type == A_ELEMVAR || type == A_ELEMCON);
      xassert(dim >= 0);
      array = dmp_get_atom(mpl->arrays, sizeof(ARRAY));
      array->type = type;
      array->dim = dim;
      array->size = 0;
      array->head = NULL;
      array->tail = NULL;
      array->tree = NULL;
      array->prev = NULL;
      array->next = mpl->a_list;
      /* include the array in the global array list */
      if (array->next != NULL) array->next->prev = array;
      mpl->a_list = array;
      return array;
}

/*----------------------------------------------------------------------
-- find_member - find array member with given n-tuple.
--
-- This routine finds an array member, which has given n-tuple. If the
-- array is short, the linear search is used. Otherwise the routine
-- autimatically creates the search tree (i.e. the array index) to find
-- members for logarithmic time. */

static int compare_member_tuples(void *info, const void *key1,
      const void *key2)
{     /* this is an auxiliary routine used to compare keys, which are
         n-tuples assigned to array members */
      return compare_tuples((MPL *)info, (TUPLE *)key1, (TUPLE *)key2);
}

MEMBER *find_member
(     MPL *mpl,
      ARRAY *array,           /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      xassert(array != NULL);
      /* the n-tuple must have the same dimension as the array */
      xassert(tuple_dimen(mpl, tuple) == array->dim);
      /* if the array is large enough, create the search tree and index
         all existing members of the array */
      if (array->size > 30 && array->tree == NULL)
      {  array->tree = avl_create_tree(compare_member_tuples, mpl);
         for (memb = array->head; memb != NULL; memb = memb->next)
avl_set_node_link(avl_insert_node(array->tree, memb->tuple),
               (void *)memb);
      }
      /* find a member, which has the given tuple */
      if (array->tree == NULL)
      {  /* the search tree doesn't exist; use the linear search */
         for (memb = array->head; memb != NULL; memb = memb->next)
            if (compare_tuples(mpl, memb->tuple, tuple) == 0) break;
      }
      else
      {  /* the search tree exists; use the binary search */
         AVLNODE *node;
         node = avl_find_node(array->tree, tuple);
memb = (MEMBER *)(node == NULL ? NULL : avl_get_node_link(node));
      }
      return memb;
}

/*----------------------------------------------------------------------
-- add_member - add new member to array.
--
-- This routine creates a new member with given n-tuple and adds it to
-- specified array.
--
-- For the sake of efficiency this routine doesn't check whether the
-- array already contains a member with the given n-tuple or not. Thus,
-- if necessary, the calling program should use the routine find_member
-- in order to be sure that the array contains no member with the same
-- n-tuple, because members with duplicate n-tuples are not allowed.
--
-- This routine assigns no generic value to the new member, because the
-- calling program must do that. */

MEMBER *add_member
(     MPL *mpl,
      ARRAY *array,           /* modified */
      TUPLE *tuple            /* destroyed */
)
{     MEMBER *memb;
      xassert(array != NULL);
      /* the n-tuple must have the same dimension as the array */
      xassert(tuple_dimen(mpl, tuple) == array->dim);
      /* create new member */
      memb = dmp_get_atom(mpl->members, sizeof(MEMBER));
      memb->tuple = tuple;
      memb->next = NULL;
      memset(&memb->value, '?', sizeof(VALUE));
      /* and append it to the member list */
      array->size++;
      if (array->head == NULL)
         array->head = memb;
      else
         array->tail->next = memb;
      array->tail = memb;
      /* if the search tree exists, index the new member */
      if (array->tree != NULL)
avl_set_node_link(avl_insert_node(array->tree, memb->tuple),
            (void *)memb);
      return memb;
}

/*----------------------------------------------------------------------
-- delete_array - delete array.
--
-- This routine deletes specified array.
--
-- Generic values assigned to the array members are not deleted by this
-- routine. The calling program itself must delete all assigned generic
-- values before deleting the array. */

void delete_array
(     MPL *mpl,
      ARRAY *array            /* destroyed */
)
{     MEMBER *memb;
      xassert(array != NULL);
      /* delete all existing array members */
      while (array->head != NULL)
      {  memb = array->head;
         array->head = memb->next;
         delete_tuple(mpl, memb->tuple);
         dmp_free_atom(mpl->members, memb, sizeof(MEMBER));
      }
      /* if the search tree exists, also delete it */
      if (array->tree != NULL) avl_delete_tree(array->tree);
      /* remove the array from the global array list */
      if (array->prev == NULL)
         mpl->a_list = array->next;
      else
         array->prev->next = array->next;
      if (array->next == NULL)
         ;
      else
         array->next->prev = array->prev;
      /* delete the array descriptor */
      dmp_free_atom(mpl->arrays, array, sizeof(ARRAY));
      return;
}

/**********************************************************************/
/* * *                 DOMAINS AND DUMMY INDICES                  * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- assign_dummy_index - assign new value to dummy index.
--
-- This routine assigns new value to specified dummy index and, that is
-- important, invalidates all temporary resultant values, which depends
-- on that dummy index. */

void assign_dummy_index
(     MPL *mpl,
      DOMAIN_SLOT *slot,      /* modified */
      SYMBOL *value           /* not changed */
)
{     CODE *leaf, *code;
      xassert(slot != NULL);
      xassert(value != NULL);
      /* delete the current value assigned to the dummy index */
      if (slot->value != NULL)
      {  /* if the current value and the new one are identical, actual
            assignment is not needed */
         if (compare_symbols(mpl, slot->value, value) == 0) goto done;
         /* delete a symbol, which is the current value */
         delete_symbol(mpl, slot->value), slot->value = NULL;
      }
      /* now walk through all the pseudo-codes with op = O_INDEX, which
         refer to the dummy index to be changed (these pseudo-codes are
         leaves in the forest of *all* expressions in the database) */
      for (leaf = slot->list; leaf != NULL; leaf = leaf->arg.index.
         next)
      {  xassert(leaf->op == O_INDEX);
         /* invalidate all resultant values, which depend on the dummy
            index, walking from the current leaf toward the root of the
            corresponding expression tree */
         for (code = leaf; code != NULL; code = code->up)
         {  if (code->valid)
            {  /* invalidate and delete resultant value */
               code->valid = 0;
               delete_value(mpl, code->type, &code->value);
            }
         }
      }
      /* assign new value to the dummy index */
      slot->value = copy_symbol(mpl, value);
done: return;
}

/*----------------------------------------------------------------------
-- update_dummy_indices - update current values of dummy indices.
--
-- This routine assigns components of "backup" n-tuple to dummy indices
-- of specified domain block. If no "backup" n-tuple is defined for the
-- domain block, values of the dummy indices remain untouched. */

void update_dummy_indices
(     MPL *mpl,
      DOMAIN_BLOCK *block     /* not changed */
)
{     DOMAIN_SLOT *slot;
      TUPLE *temp;
      if (block->backup != NULL)
      {  for (slot = block->list, temp = block->backup; slot != NULL;
            slot = slot->next, temp = temp->next)
         {  xassert(temp != NULL);
            xassert(temp->sym != NULL);
            assign_dummy_index(mpl, slot, temp->sym);
         }
      }
      return;
}

/*----------------------------------------------------------------------
-- enter_domain_block - enter domain block.
--
-- Let specified domain block have the form:
--
--    { ..., (j1, j2, ..., jn) in J, ... }
--
-- where j1, j2, ..., jn are dummy indices, J is a basic set.
--
-- This routine does the following:
--
-- 1. Checks if the given n-tuple is a member of the basic set J. Note
--    that J being *out of the scope* of the domain block cannot depend
--    on the dummy indices in the same and inner domain blocks, so it
--    can be computed before the dummy indices are assigned new values.
--    If this check fails, the routine returns with non-zero code.
--
-- 2. Saves current values of the dummy indices j1, j2, ..., jn.
--
-- 3. Assigns new values, which are components of the given n-tuple, to
--    the dummy indices j1, j2, ..., jn. If dimension of the n-tuple is
--    larger than n, its extra components n+1, n+2, ... are not used.
--
-- 4. Calls the formal routine func which either enters the next domain
--    block or evaluates some code within the domain scope.
--
-- 5. Restores former values of the dummy indices j1, j2, ..., jn.
--
-- Since current values assigned to the dummy indices on entry to this
-- routine are restored on exit, the formal routine func is allowed to
-- call this routine recursively. */

int enter_domain_block
(     MPL *mpl,
      DOMAIN_BLOCK *block,    /* not changed */
      TUPLE *tuple,           /* not changed */
      void *info, void (*func)(MPL *mpl, void *info)
)
{     TUPLE *backup;
      int ret = 0;
      /* check if the given n-tuple is a member of the basic set */
      xassert(block->code != NULL);
      if (!is_member(mpl, block->code, tuple))
      {  ret = 1;
         goto done;
      }
      /* save reference to "backup" n-tuple, which was used to assign
         current values of the dummy indices (it is sufficient to save
         reference, not value, because that n-tuple is defined in some
         outer level of recursion and therefore cannot be changed on
         this and deeper recursive calls) */
      backup = block->backup;
      /* set up new "backup" n-tuple, which defines new values of the
         dummy indices */
      block->backup = tuple;
      /* assign new values to the dummy indices */
      update_dummy_indices(mpl, block);
      /* call the formal routine that does the rest part of the job */
      func(mpl, info);
      /* restore reference to the former "backup" n-tuple */
      block->backup = backup;
      /* restore former values of the dummy indices; note that if the
         domain block just escaped has no other active instances which
         may exist due to recursion (it is indicated by a null pointer
         to the former n-tuple), former values of the dummy indices are
         undefined; therefore in this case the routine keeps currently
         assigned values of the dummy indices that involves keeping all
         dependent temporary results and thereby, if this domain block
         is not used recursively, allows improving efficiency */
      update_dummy_indices(mpl, block);
done: return ret;
}

/*----------------------------------------------------------------------
-- eval_within_domain - perform evaluation within domain scope.
--
-- This routine assigns new values (symbols) to all dummy indices of
-- specified domain and calls the formal routine func, which is used to
-- evaluate some code in the domain scope. Each free dummy index in the
-- domain is assigned a value specified in the corresponding component
-- of given n-tuple. Non-free dummy indices are assigned values, which
-- are computed by this routine.
--
-- Number of components in the given n-tuple must be the same as number
-- of free indices in the domain.
--
-- If the given n-tuple is not a member of the domain set, the routine
-- func is not called, and non-zero code is returned.
--
-- For the sake of convenience it is allowed to specify domain as NULL
-- (then n-tuple also must be 0-tuple, i.e. empty), in which case this
-- routine just calls the routine func and returns zero.
--
-- This routine allows recursive calls from the routine func providing
-- correct values of dummy indices for each instance.
--
-- NOTE: The n-tuple passed to this routine must not be changed by any
--       other routines called from the formal routine func until this
--       routine has returned. */

struct eval_domain_info
{     /* working info used by the routine eval_within_domain */
      DOMAIN *domain;
      /* domain, which has to be entered */
      DOMAIN_BLOCK *block;
      /* domain block, which is currently processed */
      TUPLE *tuple;
      /* tail of original n-tuple, whose components have to be assigned
         to free dummy indices in the current domain block */
      void *info;
      /* transit pointer passed to the formal routine func */
      void (*func)(MPL *mpl, void *info);
      /* routine, which has to be executed in the domain scope */
      int failure;
      /* this flag indicates that given n-tuple is not a member of the
         domain set */
};

static void eval_domain_func(MPL *mpl, void *_my_info)
{     /* this routine recursively enters into the domain scope and then
         calls the routine func */
      struct eval_domain_info *my_info = _my_info;
      if (my_info->block != NULL)
      {  /* the current domain block to be entered exists */
         DOMAIN_BLOCK *block;
         DOMAIN_SLOT *slot;
         TUPLE *tuple = NULL, *temp = NULL;
         /* save pointer to the current domain block */
         block = my_info->block;
         /* and get ready to enter the next block (if it exists) */
         my_info->block = block->next;
         /* construct temporary n-tuple, whose components correspond to
            dummy indices (slots) of the current domain; components of
            the temporary n-tuple that correspond to free dummy indices
            are assigned references (not values!) to symbols specified
            in the corresponding components of the given n-tuple, while
            other components that correspond to non-free dummy indices
            are assigned symbolic values computed here */
         for (slot = block->list; slot != NULL; slot = slot->next)
         {  /* create component that corresponds to the current slot */
            if (tuple == NULL)
               tuple = temp = dmp_get_atom(mpl->tuples, sizeof(TUPLE));
            else
temp = (temp->next = dmp_get_atom(mpl->tuples, sizeof(TUPLE)));
            if (slot->code == NULL)
            {  /* dummy index is free; take reference to symbol, which
                  is specified in the corresponding component of given
                  n-tuple */
               xassert(my_info->tuple != NULL);
               temp->sym = my_info->tuple->sym;
               xassert(temp->sym != NULL);
               my_info->tuple = my_info->tuple->next;
            }
            else
            {  /* dummy index is non-free; compute symbolic value to be
                  temporarily assigned to the dummy index */
               temp->sym = eval_symbolic(mpl, slot->code);
            }
         }
         temp->next = NULL;
         /* enter the current domain block */
         if (enter_domain_block(mpl, block, tuple, my_info,
               eval_domain_func)) my_info->failure = 1;
         /* delete temporary n-tuple as well as symbols that correspond
            to non-free dummy indices (they were computed here) */
         for (slot = block->list; slot != NULL; slot = slot->next)
         {  xassert(tuple != NULL);
            temp = tuple;
            tuple = tuple->next;
            if (slot->code != NULL)
            {  /* dummy index is non-free; delete symbolic value */
               delete_symbol(mpl, temp->sym);
            }
            /* delete component that corresponds to the current slot */
            dmp_free_atom(mpl->tuples, temp, sizeof(TUPLE));
         }
      }
      else
      {  /* there are no more domain blocks, i.e. we have reached the
            domain scope */
         xassert(my_info->tuple == NULL);
         /* check optional predicate specified for the domain */
         if (my_info->domain->code != NULL && !eval_logical(mpl,
            my_info->domain->code))
         {  /* the predicate is false */
            my_info->failure = 2;
         }
         else
         {  /* the predicate is true; do the job */
            my_info->func(mpl, my_info->info);
         }
      }
      return;
}

int eval_within_domain
(     MPL *mpl,
      DOMAIN *domain,         /* not changed */
      TUPLE *tuple,           /* not changed */
      void *info, void (*func)(MPL *mpl, void *info)
)
{     /* this routine performs evaluation within domain scope */
      struct eval_domain_info _my_info, *my_info = &_my_info;
      if (domain == NULL)
      {  xassert(tuple == NULL);
         func(mpl, info);
         my_info->failure = 0;
      }
      else
      {  xassert(tuple != NULL);
         my_info->domain = domain;
         my_info->block = domain->list;
         my_info->tuple = tuple;
         my_info->info = info;
         my_info->func = func;
         my_info->failure = 0;
         /* enter the very first domain block */
         eval_domain_func(mpl, my_info);
      }
      return my_info->failure;
}

/*----------------------------------------------------------------------
-- loop_within_domain - perform iterations within domain scope.
--
-- This routine iteratively assigns new values (symbols) to the dummy
-- indices of specified domain by enumerating all n-tuples, which are
-- members of the domain set, and for every n-tuple it calls the formal
-- routine func to evaluate some code within the domain scope.
--
-- If the routine func returns non-zero, enumeration within the domain
-- is prematurely terminated.
--
-- For the sake of convenience it is allowed to specify domain as NULL,
-- in which case this routine just calls the routine func only once and
-- returns zero.
--
-- This routine allows recursive calls from the routine func providing
-- correct values of dummy indices for each instance. */

struct loop_domain_info
{     /* working info used by the routine loop_within_domain */
      DOMAIN *domain;
      /* domain, which has to be entered */
      DOMAIN_BLOCK *block;
      /* domain block, which is currently processed */
      int looping;
      /* clearing this flag leads to terminating enumeration */
      void *info;
      /* transit pointer passed to the formal routine func */
      int (*func)(MPL *mpl, void *info);
      /* routine, which needs to be executed in the domain scope */
};

static void loop_domain_func(MPL *mpl, void *_my_info)
{     /* this routine enumerates all n-tuples in the basic set of the
         current domain block, enters recursively into the domain scope
         for every n-tuple, and then calls the routine func */
      struct loop_domain_info *my_info = _my_info;
      if (my_info->block != NULL)
      {  /* the current domain block to be entered exists */
         DOMAIN_BLOCK *block;
         DOMAIN_SLOT *slot;
         TUPLE *bound;
         /* save pointer to the current domain block */
         block = my_info->block;
         /* and get ready to enter the next block (if it exists) */
         my_info->block = block->next;
         /* compute symbolic values, at which non-free dummy indices of
            the current domain block are bound; since that values don't
            depend on free dummy indices of the current block, they can
            be computed once out of the enumeration loop */
         bound = create_tuple(mpl);
         for (slot = block->list; slot != NULL; slot = slot->next)
         {  if (slot->code != NULL)
               bound = expand_tuple(mpl, bound, eval_symbolic(mpl,
                  slot->code));
         }
         /* start enumeration */
         xassert(block->code != NULL);
         if (block->code->op == O_DOTS)
         {  /* the basic set is "arithmetic", in which case it doesn't
               need to be computed explicitly */
            TUPLE *tuple;
            int n, j;
            double t0, tf, dt;
            /* compute "parameters" of the basic set */
            t0 = eval_numeric(mpl, block->code->arg.arg.x);
            tf = eval_numeric(mpl, block->code->arg.arg.y);
            if (block->code->arg.arg.z == NULL)
               dt = 1.0;
            else
               dt = eval_numeric(mpl, block->code->arg.arg.z);
            /* determine cardinality of the basic set */
            n = arelset_size(mpl, t0, tf, dt);
            /* create dummy 1-tuple for members of the basic set */
            tuple = expand_tuple(mpl, create_tuple(mpl),
               create_symbol_num(mpl, 0.0));
            /* in case of "arithmetic" set there is exactly one dummy
               index, which cannot be non-free */
            xassert(bound == NULL);
            /* walk through 1-tuples of the basic set */
            for (j = 1; j <= n && my_info->looping; j++)
            {  /* construct dummy 1-tuple for the current member */
               tuple->sym->num = arelset_member(mpl, t0, tf, dt, j);
               /* enter the current domain block */
               enter_domain_block(mpl, block, tuple, my_info,
                  loop_domain_func);
            }
            /* delete dummy 1-tuple */
            delete_tuple(mpl, tuple);
         }
         else
         {  /* the basic set is of general kind, in which case it needs
               to be explicitly computed */
            ELEMSET *set;
            MEMBER *memb;
            TUPLE *temp1, *temp2;
            /* compute the basic set */
            set = eval_elemset(mpl, block->code);
            /* walk through all n-tuples of the basic set */
            for (memb = set->head; memb != NULL && my_info->looping;
               memb = memb->next)
            {  /* all components of the current n-tuple that correspond
                  to non-free dummy indices must be feasible; otherwise
                  the n-tuple is not in the basic set */
               temp1 = memb->tuple;
               temp2 = bound;
               for (slot = block->list; slot != NULL; slot = slot->next)
               {  xassert(temp1 != NULL);
                  if (slot->code != NULL)
                  {  /* non-free dummy index */
                     xassert(temp2 != NULL);
                     if (compare_symbols(mpl, temp1->sym, temp2->sym)
                        != 0)
                     {  /* the n-tuple is not in the basic set */
                        goto skip;
                     }
                     temp2 = temp2->next;
                  }
                  temp1 = temp1->next;
               }
               xassert(temp1 == NULL);
               xassert(temp2 == NULL);
               /* enter the current domain block */
               enter_domain_block(mpl, block, memb->tuple, my_info,
                  loop_domain_func);
skip:          ;
            }
            /* delete the basic set */
            delete_elemset(mpl, set);
         }
         /* delete symbolic values binding non-free dummy indices */
         delete_tuple(mpl, bound);
         /* restore pointer to the current domain block */
         my_info->block = block;
      }
      else
      {  /* there are no more domain blocks, i.e. we have reached the
            domain scope */
         /* check optional predicate specified for the domain */
         if (my_info->domain->code != NULL && !eval_logical(mpl,
            my_info->domain->code))
         {  /* the predicate is false */
            /* nop */;
         }
         else
         {  /* the predicate is true; do the job */
            my_info->looping = !my_info->func(mpl, my_info->info);
         }
      }
      return;
}

void loop_within_domain
(     MPL *mpl,
      DOMAIN *domain,         /* not changed */
      void *info, int (*func)(MPL *mpl, void *info)
)
{     /* this routine performs iterations within domain scope */
      struct loop_domain_info _my_info, *my_info = &_my_info;
      if (domain == NULL)
         func(mpl, info);
      else
      {  my_info->domain = domain;
         my_info->block = domain->list;
         my_info->looping = 1;
         my_info->info = info;
         my_info->func = func;
         /* enter the very first domain block */
         loop_domain_func(mpl, my_info);
      }
      return;
}

/*----------------------------------------------------------------------
-- out_of_domain - raise domain exception.
--
-- This routine is called when a reference is made to a member of some
-- model object, but its n-tuple is out of the object domain. */

void out_of_domain
(     MPL *mpl,
      char *name,             /* not changed */
      TUPLE *tuple            /* not changed */
)
{     xassert(name != NULL);
      xassert(tuple != NULL);
      error(mpl, "%s%s out of domain", name, format_tuple(mpl, '[',
         tuple));
      /* no return */
}

/*----------------------------------------------------------------------
-- get_domain_tuple - obtain current n-tuple from domain.
--
-- This routine constructs n-tuple, whose components are current values
-- assigned to *free* dummy indices of specified domain.
--
-- For the sake of convenience it is allowed to specify domain as NULL,
-- in which case this routine returns 0-tuple.
--
-- NOTE: This routine must not be called out of domain scope. */

TUPLE *get_domain_tuple
(     MPL *mpl,
      DOMAIN *domain          /* not changed */
)
{     DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      TUPLE *tuple;
      tuple = create_tuple(mpl);
      if (domain != NULL)
      {  for (block = domain->list; block != NULL; block = block->next)
         {  for (slot = block->list; slot != NULL; slot = slot->next)
            {  if (slot->code == NULL)
               {  xassert(slot->value != NULL);
                  tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
                     slot->value));
               }
            }
         }
      }
      return tuple;
}

/*----------------------------------------------------------------------
-- clean_domain - clean domain.
--
-- This routine cleans specified domain that assumes deleting all stuff
-- dynamically allocated during the generation phase. */

void clean_domain(MPL *mpl, DOMAIN *domain)
{     DOMAIN_BLOCK *block;
      DOMAIN_SLOT *slot;
      /* if no domain is specified, do nothing */
      if (domain == NULL) goto done;
      /* clean all domain blocks */
      for (block = domain->list; block != NULL; block = block->next)
      {  /* clean all domain slots */
         for (slot = block->list; slot != NULL; slot = slot->next)
         {  /* clean pseudo-code for computing bound value */
            clean_code(mpl, slot->code);
            /* delete symbolic value assigned to dummy index */
            if (slot->value != NULL)
               delete_symbol(mpl, slot->value), slot->value = NULL;
         }
         /* clean pseudo-code for computing basic set */
         clean_code(mpl, block->code);
      }
      /* clean pseudo-code for computing domain predicate */
      clean_code(mpl, domain->code);
done: return;
}

/**********************************************************************/
/* * *                         MODEL SETS                         * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- check_elem_set - check elemental set assigned to set member.
--
-- This routine checks if given elemental set being assigned to member
-- of specified model set satisfies to all restrictions.
--
-- NOTE: This routine must not be called out of domain scope. */

void check_elem_set
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple,           /* not changed */
      ELEMSET *refer          /* not changed */
)
{     WITHIN *within;
      MEMBER *memb;
      int eqno;
      /* elemental set must be within all specified supersets */
      for (within = set->within, eqno = 1; within != NULL; within =
         within->next, eqno++)
      {  xassert(within->code != NULL);
         for (memb = refer->head; memb != NULL; memb = memb->next)
         {  if (!is_member(mpl, within->code, memb->tuple))
            {  char buf[255+1];
               strcpy(buf, format_tuple(mpl, '(', memb->tuple));
               xassert(strlen(buf) < sizeof(buf));
               error(mpl, "%s%s contains %s which not within specified "
                  "set; see (%d)", set->name, format_tuple(mpl, '[',
                     tuple), buf, eqno);
            }
         }
      }
      return;
}

/*----------------------------------------------------------------------
-- take_member_set - obtain elemental set assigned to set member.
--
-- This routine obtains a reference to elemental set assigned to given
-- member of specified model set and returns it on exit.
--
-- NOTE: This routine must not be called out of domain scope. */

ELEMSET *take_member_set      /* returns reference, not value */
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      ELEMSET *refer;
      /* find member in the set array */
      memb = find_member(mpl, set->array, tuple);
      if (memb != NULL)
      {  /* member exists, so just take the reference */
         refer = memb->value.set;
      }
      else if (set->assign != NULL)
      {  /* compute value using assignment expression */
         refer = eval_elemset(mpl, set->assign);
add:     /* check that the elemental set satisfies to all restrictions,
            assign it to new member, and add the member to the array */
         check_elem_set(mpl, set, tuple, refer);
         memb = add_member(mpl, set->array, copy_tuple(mpl, tuple));
         memb->value.set = refer;
      }
      else if (set->option != NULL)
      {  /* compute default elemental set */
         refer = eval_elemset(mpl, set->option);
         goto add;
      }
      else
      {  /* no value (elemental set) is provided */
         error(mpl, "no value for %s%s", set->name, format_tuple(mpl,
            '[', tuple));
      }
      return refer;
}

/*----------------------------------------------------------------------
-- eval_member_set - evaluate elemental set assigned to set member.
--
-- This routine evaluates a reference to elemental set assigned to given
-- member of specified model set and returns it on exit. */

struct eval_set_info
{     /* working info used by the routine eval_member_set */
      SET *set;
      /* model set */
      TUPLE *tuple;
      /* n-tuple, which defines set member */
      MEMBER *memb;
      /* normally this pointer is NULL; the routine uses this pointer
         to check data provided in the data section, in which case it
         points to a member currently checked; this check is performed
         automatically only once when a reference to any member occurs
         for the first time */
      ELEMSET *refer;
      /* evaluated reference to elemental set */
};

static void eval_set_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine to work within domain scope */
      struct eval_set_info *info = _info;
      if (info->memb != NULL)
      {  /* checking call; check elemental set being assigned */
         check_elem_set(mpl, info->set, info->memb->tuple,
            info->memb->value.set);
      }
      else
      {  /* normal call; evaluate member, which has given n-tuple */
         info->refer = take_member_set(mpl, info->set, info->tuple);
      }
      return;
}

#if 1 /* 12/XII-2008 */
static void saturate_set(MPL *mpl, SET *set)
{     GADGET *gadget = set->gadget;
      ELEMSET *data;
      MEMBER *elem, *memb;
      TUPLE *tuple, *work[20];
      int i;
      xprintf("Generating %s...\n", set->name);
      eval_whole_set(mpl, gadget->set);
      /* gadget set must have exactly one member */
      xassert(gadget->set->array != NULL);
      xassert(gadget->set->array->head != NULL);
      xassert(gadget->set->array->head == gadget->set->array->tail);
      data = gadget->set->array->head->value.set;
      xassert(data->type == A_NONE);
      xassert(data->dim == gadget->set->dimen);
      /* walk thru all elements of the plain set */
      for (elem = data->head; elem != NULL; elem = elem->next)
      {  /* create a copy of n-tuple */
         tuple = copy_tuple(mpl, elem->tuple);
         /* rearrange component of the n-tuple */
         for (i = 0; i < gadget->set->dimen; i++)
            work[i] = NULL;
         for (i = 0; tuple != NULL; tuple = tuple->next)
            work[gadget->ind[i++]-1] = tuple;
         xassert(i == gadget->set->dimen);
         for (i = 0; i < gadget->set->dimen; i++)
         {  xassert(work[i] != NULL);
            work[i]->next = work[i+1];
         }
         /* construct subscript list from first set->dim components */
         if (set->dim == 0)
            tuple = NULL;
         else
            tuple = work[0], work[set->dim-1]->next = NULL;
         /* find corresponding member of the set to be initialized */
         memb = find_member(mpl, set->array, tuple);
         if (memb == NULL)
         {  /* not found; add new member to the set and assign it empty
               elemental set */
            memb = add_member(mpl, set->array, tuple);
            memb->value.set = create_elemset(mpl, set->dimen);
         }
         else
         {  /* found; free subscript list */
            delete_tuple(mpl, tuple);
         }
         /* construct new n-tuple from rest set->dimen components */
         tuple = work[set->dim];
         xassert(set->dim + set->dimen == gadget->set->dimen);
         work[gadget->set->dimen-1]->next = NULL;
         /* and add it to the elemental set assigned to the member
            (no check for duplicates is needed) */
         add_tuple(mpl, memb->value.set, tuple);
      }
      /* the set has been saturated with data */
      set->data = 1;
      return;
}
#endif

ELEMSET *eval_member_set      /* returns reference, not value */
(     MPL *mpl,
      SET *set,               /* not changed */
      TUPLE *tuple            /* not changed */
)
{     /* this routine evaluates set member */
      struct eval_set_info _info, *info = &_info;
      xassert(set->dim == tuple_dimen(mpl, tuple));
      info->set = set;
      info->tuple = tuple;
#if 1 /* 12/XII-2008 */
      if (set->gadget != NULL && set->data == 0)
      {  /* initialize the set with data from a plain set */
         saturate_set(mpl, set);
      }
#endif
      if (set->data == 1)
      {  /* check data, which are provided in the data section, but not
            checked yet */
         /* save pointer to the last array member; note that during the
            check new members may be added beyond the last member due to
            references to the same parameter from default expression as
            well as from expressions that define restricting supersets;
            however, values assigned to the new members will be checked
            by other routine, so we don't need to check them here */
         MEMBER *tail = set->array->tail;
         /* change the data status to prevent infinite recursive loop
            due to references to the same set during the check */
         set->data = 2;
         /* check elemental sets assigned to array members in the data
            section until the marked member has been reached */
         for (info->memb = set->array->head; info->memb != NULL;
            info->memb = info->memb->next)
         {  if (eval_within_domain(mpl, set->domain, info->memb->tuple,
               info, eval_set_func))
               out_of_domain(mpl, set->name, info->memb->tuple);
            if (info->memb == tail) break;
         }
         /* the check has been finished */
      }
      /* evaluate member, which has given n-tuple */
      info->memb = NULL;
      if (eval_within_domain(mpl, info->set->domain, info->tuple, info,
         eval_set_func))
      out_of_domain(mpl, set->name, info->tuple);
      /* bring evaluated reference to the calling program */
      return info->refer;
}

/*----------------------------------------------------------------------
-- eval_whole_set - evaluate model set over entire domain.
--
-- This routine evaluates all members of specified model set over entire
-- domain. */

static int whole_set_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      SET *set = (SET *)info;
      TUPLE *tuple = get_domain_tuple(mpl, set->domain);
      eval_member_set(mpl, set, tuple);
      delete_tuple(mpl, tuple);
      return 0;
}

void eval_whole_set(MPL *mpl, SET *set)
{     loop_within_domain(mpl, set->domain, set, whole_set_func);
      return;
}

/*----------------------------------------------------------------------
-- clean set - clean model set.
--
-- This routine cleans specified model set that assumes deleting all
-- stuff dynamically allocated during the generation phase. */

void clean_set(MPL *mpl, SET *set)
{     WITHIN *within;
      MEMBER *memb;
      /* clean subscript domain */
      clean_domain(mpl, set->domain);
      /* clean pseudo-code for computing supersets */
      for (within = set->within; within != NULL; within = within->next)
         clean_code(mpl, within->code);
      /* clean pseudo-code for computing assigned value */
      clean_code(mpl, set->assign);
      /* clean pseudo-code for computing default value */
      clean_code(mpl, set->option);
      /* reset data status flag */
      set->data = 0;
      /* delete content array */
      for (memb = set->array->head; memb != NULL; memb = memb->next)
         delete_value(mpl, set->array->type, &memb->value);
      delete_array(mpl, set->array), set->array = NULL;
      return;
}

/**********************************************************************/
/* * *                      MODEL PARAMETERS                      * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- check_value_num - check numeric value assigned to parameter member.
--
-- This routine checks if numeric value being assigned to some member
-- of specified numeric model parameter satisfies to all restrictions.
--
-- NOTE: This routine must not be called out of domain scope. */

void check_value_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple,           /* not changed */
      double value
)
{     CONDITION *cond;
      WITHIN *in;
      int eqno;
      /* the value must satisfy to the parameter type */
      switch (par->type)
      {  case A_NUMERIC:
            break;
         case A_INTEGER:
            if (value != floor(value))
               error(mpl, "%s%s = %.*g not integer", par->name,
                  format_tuple(mpl, '[', tuple), DBL_DIG, value);
            break;
         case A_BINARY:
            if (!(value == 0.0 || value == 1.0))
               error(mpl, "%s%s = %.*g not binary", par->name,
                  format_tuple(mpl, '[', tuple), DBL_DIG, value);
            break;
         default:
            xassert(par != par);
      }
      /* the value must satisfy to all specified conditions */
      for (cond = par->cond, eqno = 1; cond != NULL; cond = cond->next,
         eqno++)
      {  double bound;
         char *rho;
         xassert(cond->code != NULL);
         bound = eval_numeric(mpl, cond->code);
         switch (cond->rho)
         {  case O_LT:
               if (!(value < bound))
               {  rho = "<";
err:              error(mpl, "%s%s = %.*g not %s %.*g; see (%d)",
                     par->name, format_tuple(mpl, '[', tuple), DBL_DIG,
                     value, rho, DBL_DIG, bound, eqno);
               }
               break;
            case O_LE:
               if (!(value <= bound)) { rho = "<="; goto err; }
               break;
            case O_EQ:
               if (!(value == bound)) { rho = "="; goto err; }
               break;
            case O_GE:
               if (!(value >= bound)) { rho = ">="; goto err; }
               break;
            case O_GT:
               if (!(value > bound)) { rho = ">"; goto err; }
               break;
            case O_NE:
               if (!(value != bound)) { rho = "<>"; goto err; }
               break;
            default:
               xassert(cond != cond);
         }
      }
      /* the value must be in all specified supersets */
      for (in = par->in, eqno = 1; in != NULL; in = in->next, eqno++)
      {  TUPLE *dummy;
         xassert(in->code != NULL);
         xassert(in->code->dim == 1);
         dummy = expand_tuple(mpl, create_tuple(mpl),
            create_symbol_num(mpl, value));
         if (!is_member(mpl, in->code, dummy))
            error(mpl, "%s%s = %.*g not in specified set; see (%d)",
               par->name, format_tuple(mpl, '[', tuple), DBL_DIG,
               value, eqno);
         delete_tuple(mpl, dummy);
      }
      return;
}

/*----------------------------------------------------------------------
-- take_member_num - obtain num. value assigned to parameter member.
--
-- This routine obtains a numeric value assigned to member of specified
-- numeric model parameter and returns it on exit.
--
-- NOTE: This routine must not be called out of domain scope. */

double take_member_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      double value;
      /* find member in the parameter array */
      memb = find_member(mpl, par->array, tuple);
      if (memb != NULL)
      {  /* member exists, so just take its value */
         value = memb->value.num;
      }
      else if (par->assign != NULL)
      {  /* compute value using assignment expression */
         value = eval_numeric(mpl, par->assign);
add:     /* check that the value satisfies to all restrictions, assign
            it to new member, and add the member to the array */
         check_value_num(mpl, par, tuple, value);
         memb = add_member(mpl, par->array, copy_tuple(mpl, tuple));
         memb->value.num = value;
      }
      else if (par->option != NULL)
      {  /* compute default value */
         value = eval_numeric(mpl, par->option);
         goto add;
      }
      else if (par->defval != NULL)
      {  /* take default value provided in the data section */
         if (par->defval->str != NULL)
            error(mpl, "cannot convert %s to floating-point number",
               format_symbol(mpl, par->defval));
         value = par->defval->num;
         goto add;
      }
      else
      {  /* no value is provided */
         error(mpl, "no value for %s%s", par->name, format_tuple(mpl,
            '[', tuple));
      }
      return value;
}

/*----------------------------------------------------------------------
-- eval_member_num - evaluate num. value assigned to parameter member.
--
-- This routine evaluates a numeric value assigned to given member of
-- specified numeric model parameter and returns it on exit. */

struct eval_num_info
{     /* working info used by the routine eval_member_num */
      PARAMETER *par;
      /* model parameter  */
      TUPLE *tuple;
      /* n-tuple, which defines parameter member */
      MEMBER *memb;
      /* normally this pointer is NULL; the routine uses this pointer
         to check data provided in the data section, in which case it
         points to a member currently checked; this check is performed
         automatically only once when a reference to any member occurs
         for the first time */
      double value;
      /* evaluated numeric value */
};

static void eval_num_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine to work within domain scope */
      struct eval_num_info *info = _info;
      if (info->memb != NULL)
      {  /* checking call; check numeric value being assigned */
         check_value_num(mpl, info->par, info->memb->tuple,
            info->memb->value.num);
      }
      else
      {  /* normal call; evaluate member, which has given n-tuple */
         info->value = take_member_num(mpl, info->par, info->tuple);
      }
      return;
}

double eval_member_num
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
)
{     /* this routine evaluates numeric parameter member */
      struct eval_num_info _info, *info = &_info;
      xassert(par->type == A_NUMERIC || par->type == A_INTEGER ||
             par->type == A_BINARY);
      xassert(par->dim == tuple_dimen(mpl, tuple));
      info->par = par;
      info->tuple = tuple;
      if (par->data == 1)
      {  /* check data, which are provided in the data section, but not
            checked yet */
         /* save pointer to the last array member; note that during the
            check new members may be added beyond the last member due to
            references to the same parameter from default expression as
            well as from expressions that define restricting conditions;
            however, values assigned to the new members will be checked
            by other routine, so we don't need to check them here */
         MEMBER *tail = par->array->tail;
         /* change the data status to prevent infinite recursive loop
            due to references to the same parameter during the check */
         par->data = 2;
         /* check values assigned to array members in the data section
            until the marked member has been reached */
         for (info->memb = par->array->head; info->memb != NULL;
            info->memb = info->memb->next)
         {  if (eval_within_domain(mpl, par->domain, info->memb->tuple,
               info, eval_num_func))
               out_of_domain(mpl, par->name, info->memb->tuple);
            if (info->memb == tail) break;
         }
         /* the check has been finished */
      }
      /* evaluate member, which has given n-tuple */
      info->memb = NULL;
      if (eval_within_domain(mpl, info->par->domain, info->tuple, info,
         eval_num_func))
         out_of_domain(mpl, par->name, info->tuple);
      /* bring evaluated value to the calling program */
      return info->value;
}

/*----------------------------------------------------------------------
-- check_value_sym - check symbolic value assigned to parameter member.
--
-- This routine checks if symbolic value being assigned to some member
-- of specified symbolic model parameter satisfies to all restrictions.
--
-- NOTE: This routine must not be called out of domain scope. */

void check_value_sym
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple,           /* not changed */
      SYMBOL *value           /* not changed */
)
{     CONDITION *cond;
      WITHIN *in;
      int eqno;
      /* the value must satisfy to all specified conditions */
      for (cond = par->cond, eqno = 1; cond != NULL; cond = cond->next,
         eqno++)
      {  SYMBOL *bound;
         char buf[255+1];
         xassert(cond->code != NULL);
         bound = eval_symbolic(mpl, cond->code);
         switch (cond->rho)
         {
#if 1 /* 13/VIII-2008 */
            case O_LT:
               if (!(compare_symbols(mpl, value, bound) < 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not < %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
            case O_LE:
               if (!(compare_symbols(mpl, value, bound) <= 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not <= %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
#endif
            case O_EQ:
               if (!(compare_symbols(mpl, value, bound) == 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not = %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
#if 1 /* 13/VIII-2008 */
            case O_GE:
               if (!(compare_symbols(mpl, value, bound) >= 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not >= %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
            case O_GT:
               if (!(compare_symbols(mpl, value, bound) > 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not > %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
#endif
            case O_NE:
               if (!(compare_symbols(mpl, value, bound) != 0))
               {  strcpy(buf, format_symbol(mpl, bound));
                  xassert(strlen(buf) < sizeof(buf));
                  error(mpl, "%s%s = %s not <> %s",
                     par->name, format_tuple(mpl, '[', tuple),
                     format_symbol(mpl, value), buf, eqno);
               }
               break;
            default:
               xassert(cond != cond);
         }
         delete_symbol(mpl, bound);
      }
      /* the value must be in all specified supersets */
      for (in = par->in, eqno = 1; in != NULL; in = in->next, eqno++)
      {  TUPLE *dummy;
         xassert(in->code != NULL);
         xassert(in->code->dim == 1);
         dummy = expand_tuple(mpl, create_tuple(mpl), copy_symbol(mpl,
            value));
         if (!is_member(mpl, in->code, dummy))
            error(mpl, "%s%s = %s not in specified set; see (%d)",
               par->name, format_tuple(mpl, '[', tuple),
               format_symbol(mpl, value), eqno);
         delete_tuple(mpl, dummy);
      }
      return;
}

/*----------------------------------------------------------------------
-- take_member_sym - obtain symb. value assigned to parameter member.
--
-- This routine obtains a symbolic value assigned to member of specified
-- symbolic model parameter and returns it on exit.
--
-- NOTE: This routine must not be called out of domain scope. */

SYMBOL *take_member_sym       /* returns value, not reference */
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      SYMBOL *value;
      /* find member in the parameter array */
      memb = find_member(mpl, par->array, tuple);
      if (memb != NULL)
      {  /* member exists, so just take its value */
         value = copy_symbol(mpl, memb->value.sym);
      }
      else if (par->assign != NULL)
      {  /* compute value using assignment expression */
         value = eval_symbolic(mpl, par->assign);
add:     /* check that the value satisfies to all restrictions, assign
            it to new member, and add the member to the array */
         check_value_sym(mpl, par, tuple, value);
         memb = add_member(mpl, par->array, copy_tuple(mpl, tuple));
         memb->value.sym = copy_symbol(mpl, value);
      }
      else if (par->option != NULL)
      {  /* compute default value */
         value = eval_symbolic(mpl, par->option);
         goto add;
      }
      else if (par->defval != NULL)
      {  /* take default value provided in the data section */
         value = copy_symbol(mpl, par->defval);
         goto add;
      }
      else
      {  /* no value is provided */
         error(mpl, "no value for %s%s", par->name, format_tuple(mpl,
            '[', tuple));
      }
      return value;
}

/*----------------------------------------------------------------------
-- eval_member_sym - evaluate symb. value assigned to parameter member.
--
-- This routine evaluates a symbolic value assigned to given member of
-- specified symbolic model parameter and returns it on exit. */

struct eval_sym_info
{     /* working info used by the routine eval_member_sym */
      PARAMETER *par;
      /* model parameter */
      TUPLE *tuple;
      /* n-tuple, which defines parameter member */
      MEMBER *memb;
      /* normally this pointer is NULL; the routine uses this pointer
         to check data provided in the data section, in which case it
         points to a member currently checked; this check is performed
         automatically only once when a reference to any member occurs
         for the first time */
      SYMBOL *value;
      /* evaluated symbolic value */
};

static void eval_sym_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine to work within domain scope */
      struct eval_sym_info *info = _info;
      if (info->memb != NULL)
      {  /* checking call; check symbolic value being assigned */
         check_value_sym(mpl, info->par, info->memb->tuple,
            info->memb->value.sym);
      }
      else
      {  /* normal call; evaluate member, which has given n-tuple */
         info->value = take_member_sym(mpl, info->par, info->tuple);
      }
      return;
}

SYMBOL *eval_member_sym       /* returns value, not reference */
(     MPL *mpl,
      PARAMETER *par,         /* not changed */
      TUPLE *tuple            /* not changed */
)
{     /* this routine evaluates symbolic parameter member */
      struct eval_sym_info _info, *info = &_info;
      xassert(par->type == A_SYMBOLIC);
      xassert(par->dim == tuple_dimen(mpl, tuple));
      info->par = par;
      info->tuple = tuple;
      if (par->data == 1)
      {  /* check data, which are provided in the data section, but not
            checked yet */
         /* save pointer to the last array member; note that during the
            check new members may be added beyond the last member due to
            references to the same parameter from default expression as
            well as from expressions that define restricting conditions;
            however, values assigned to the new members will be checked
            by other routine, so we don't need to check them here */
         MEMBER *tail = par->array->tail;
         /* change the data status to prevent infinite recursive loop
            due to references to the same parameter during the check */
         par->data = 2;
         /* check values assigned to array members in the data section
            until the marked member has been reached */
         for (info->memb = par->array->head; info->memb != NULL;
            info->memb = info->memb->next)
         {  if (eval_within_domain(mpl, par->domain, info->memb->tuple,
               info, eval_sym_func))
               out_of_domain(mpl, par->name, info->memb->tuple);
            if (info->memb == tail) break;
         }
         /* the check has been finished */
      }
      /* evaluate member, which has given n-tuple */
      info->memb = NULL;
      if (eval_within_domain(mpl, info->par->domain, info->tuple, info,
         eval_sym_func))
         out_of_domain(mpl, par->name, info->tuple);
      /* bring evaluated value to the calling program */
      return info->value;
}

/*----------------------------------------------------------------------
-- eval_whole_par - evaluate model parameter over entire domain.
--
-- This routine evaluates all members of specified model parameter over
-- entire domain. */

static int whole_par_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      PARAMETER *par = (PARAMETER *)info;
      TUPLE *tuple = get_domain_tuple(mpl, par->domain);
      switch (par->type)
      {  case A_NUMERIC:
         case A_INTEGER:
         case A_BINARY:
            eval_member_num(mpl, par, tuple);
            break;
         case A_SYMBOLIC:
            delete_symbol(mpl, eval_member_sym(mpl, par, tuple));
            break;
         default:
            xassert(par != par);
      }
      delete_tuple(mpl, tuple);
      return 0;
}

void eval_whole_par(MPL *mpl, PARAMETER *par)
{     loop_within_domain(mpl, par->domain, par, whole_par_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_parameter - clean model parameter.
--
-- This routine cleans specified model parameter that assumes deleting
-- all stuff dynamically allocated during the generation phase. */

void clean_parameter(MPL *mpl, PARAMETER *par)
{     CONDITION *cond;
      WITHIN *in;
      MEMBER *memb;
      /* clean subscript domain */
      clean_domain(mpl, par->domain);
      /* clean pseudo-code for computing restricting conditions */
      for (cond = par->cond; cond != NULL; cond = cond->next)
         clean_code(mpl, cond->code);
      /* clean pseudo-code for computing restricting supersets */
      for (in = par->in; in != NULL; in = in->next)
         clean_code(mpl, in->code);
      /* clean pseudo-code for computing assigned value */
      clean_code(mpl, par->assign);
      /* clean pseudo-code for computing default value */
      clean_code(mpl, par->option);
      /* reset data status flag */
      par->data = 0;
      /* delete default symbolic value */
      if (par->defval != NULL)
         delete_symbol(mpl, par->defval), par->defval = NULL;
      /* delete content array */
      for (memb = par->array->head; memb != NULL; memb = memb->next)
         delete_value(mpl, par->array->type, &memb->value);
      delete_array(mpl, par->array), par->array = NULL;
      return;
}

/**********************************************************************/
/* * *                      MODEL VARIABLES                       * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- take_member_var - obtain reference to elemental variable.
--
-- This routine obtains a reference to elemental variable assigned to
-- given member of specified model variable and returns it on exit. If
-- necessary, new elemental variable is created.
--
-- NOTE: This routine must not be called out of domain scope. */

ELEMVAR *take_member_var      /* returns reference */
(     MPL *mpl,
      VARIABLE *var,          /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      ELEMVAR *refer;
      /* find member in the variable array */
      memb = find_member(mpl, var->array, tuple);
      if (memb != NULL)
      {  /* member exists, so just take the reference */
         refer = memb->value.var;
      }
      else
      {  /* member is referenced for the first time and therefore does
            not exist; create new elemental variable, assign it to new
            member, and add the member to the variable array */
         memb = add_member(mpl, var->array, copy_tuple(mpl, tuple));
         refer = (memb->value.var =
            dmp_get_atom(mpl->elemvars, sizeof(ELEMVAR)));
         refer->j = 0;
         refer->var = var;
         refer->memb = memb;
         /* compute lower bound */
         if (var->lbnd == NULL)
            refer->lbnd = 0.0;
         else
            refer->lbnd = eval_numeric(mpl, var->lbnd);
         /* compute upper bound */
         if (var->ubnd == NULL)
            refer->ubnd = 0.0;
         else if (var->ubnd == var->lbnd)
            refer->ubnd = refer->lbnd;
         else
            refer->ubnd = eval_numeric(mpl, var->ubnd);
         /* nullify working quantity */
         refer->temp = 0.0;
#if 1 /* 15/V-2010 */
         /* solution has not been obtained by the solver yet */
         refer->stat = 0;
         refer->prim = refer->dual = 0.0;
#endif
      }
      return refer;
}

/*----------------------------------------------------------------------
-- eval_member_var - evaluate reference to elemental variable.
--
-- This routine evaluates a reference to elemental variable assigned to
-- member of specified model variable and returns it on exit. */

struct eval_var_info
{     /* working info used by the routine eval_member_var */
      VARIABLE *var;
      /* model variable */
      TUPLE *tuple;
      /* n-tuple, which defines variable member */
      ELEMVAR *refer;
      /* evaluated reference to elemental variable */
};

static void eval_var_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine to work within domain scope */
      struct eval_var_info *info = _info;
      info->refer = take_member_var(mpl, info->var, info->tuple);
      return;
}

ELEMVAR *eval_member_var      /* returns reference */
(     MPL *mpl,
      VARIABLE *var,          /* not changed */
      TUPLE *tuple            /* not changed */
)
{     /* this routine evaluates variable member */
      struct eval_var_info _info, *info = &_info;
      xassert(var->dim == tuple_dimen(mpl, tuple));
      info->var = var;
      info->tuple = tuple;
      /* evaluate member, which has given n-tuple */
      if (eval_within_domain(mpl, info->var->domain, info->tuple, info,
         eval_var_func))
         out_of_domain(mpl, var->name, info->tuple);
      /* bring evaluated reference to the calling program */
      return info->refer;
}

/*----------------------------------------------------------------------
-- eval_whole_var - evaluate model variable over entire domain.
--
-- This routine evaluates all members of specified model variable over
-- entire domain. */

static int whole_var_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      VARIABLE *var = (VARIABLE *)info;
      TUPLE *tuple = get_domain_tuple(mpl, var->domain);
      eval_member_var(mpl, var, tuple);
      delete_tuple(mpl, tuple);
      return 0;
}

void eval_whole_var(MPL *mpl, VARIABLE *var)
{     loop_within_domain(mpl, var->domain, var, whole_var_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_variable - clean model variable.
--
-- This routine cleans specified model variable that assumes deleting
-- all stuff dynamically allocated during the generation phase. */

void clean_variable(MPL *mpl, VARIABLE *var)
{     MEMBER *memb;
      /* clean subscript domain */
      clean_domain(mpl, var->domain);
      /* clean code for computing lower bound */
      clean_code(mpl, var->lbnd);
      /* clean code for computing upper bound */
      if (var->ubnd != var->lbnd) clean_code(mpl, var->ubnd);
      /* delete content array */
      for (memb = var->array->head; memb != NULL; memb = memb->next)
         dmp_free_atom(mpl->elemvars, memb->value.var, sizeof(ELEMVAR));
      delete_array(mpl, var->array), var->array = NULL;
      return;
}

/**********************************************************************/
/* * *              MODEL CONSTRAINTS AND OBJECTIVES              * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- take_member_con - obtain reference to elemental constraint.
--
-- This routine obtains a reference to elemental constraint assigned
-- to given member of specified model constraint and returns it on exit.
-- If necessary, new elemental constraint is created.
--
-- NOTE: This routine must not be called out of domain scope. */

ELEMCON *take_member_con      /* returns reference */
(     MPL *mpl,
      CONSTRAINT *con,        /* not changed */
      TUPLE *tuple            /* not changed */
)
{     MEMBER *memb;
      ELEMCON *refer;
      /* find member in the constraint array */
      memb = find_member(mpl, con->array, tuple);
      if (memb != NULL)
      {  /* member exists, so just take the reference */
         refer = memb->value.con;
      }
      else
      {  /* member is referenced for the first time and therefore does
            not exist; create new elemental constraint, assign it to new
            member, and add the member to the constraint array */
         memb = add_member(mpl, con->array, copy_tuple(mpl, tuple));
         refer = (memb->value.con =
            dmp_get_atom(mpl->elemcons, sizeof(ELEMCON)));
         refer->i = 0;
         refer->con = con;
         refer->memb = memb;
         /* compute linear form */
         xassert(con->code != NULL);
         refer->form = eval_formula(mpl, con->code);
         /* compute lower and upper bounds */
         if (con->lbnd == NULL && con->ubnd == NULL)
         {  /* objective has no bounds */
            double temp;
            xassert(con->type == A_MINIMIZE || con->type == A_MAXIMIZE);
            /* carry the constant term to the right-hand side */
            refer->form = remove_constant(mpl, refer->form, &temp);
            refer->lbnd = refer->ubnd = - temp;
         }
         else if (con->lbnd != NULL && con->ubnd == NULL)
         {  /* constraint a * x + b >= c * y + d is transformed to the
               standard form a * x - c * y >= d - b */
            double temp;
            xassert(con->type == A_CONSTRAINT);
            refer->form = linear_comb(mpl,
               +1.0, refer->form,
               -1.0, eval_formula(mpl, con->lbnd));
            refer->form = remove_constant(mpl, refer->form, &temp);
            refer->lbnd = - temp;
            refer->ubnd = 0.0;
         }
         else if (con->lbnd == NULL && con->ubnd != NULL)
         {  /* constraint a * x + b <= c * y + d is transformed to the
               standard form a * x - c * y <= d - b */
            double temp;
            xassert(con->type == A_CONSTRAINT);
            refer->form = linear_comb(mpl,
               +1.0, refer->form,
               -1.0, eval_formula(mpl, con->ubnd));
            refer->form = remove_constant(mpl, refer->form, &temp);
            refer->lbnd = 0.0;
            refer->ubnd = - temp;
         }
         else if (con->lbnd == con->ubnd)
         {  /* constraint a * x + b = c * y + d is transformed to the
               standard form a * x - c * y = d - b */
            double temp;
            xassert(con->type == A_CONSTRAINT);
            refer->form = linear_comb(mpl,
               +1.0, refer->form,
               -1.0, eval_formula(mpl, con->lbnd));
            refer->form = remove_constant(mpl, refer->form, &temp);
            refer->lbnd = refer->ubnd = - temp;
         }
         else
         {  /* ranged constraint c <= a * x + b <= d is transformed to
               the standard form c - b <= a * x <= d - b */
            double temp, temp1, temp2;
            xassert(con->type == A_CONSTRAINT);
            refer->form = remove_constant(mpl, refer->form, &temp);
            xassert(remove_constant(mpl, eval_formula(mpl, con->lbnd),
               &temp1) == NULL);
            xassert(remove_constant(mpl, eval_formula(mpl, con->ubnd),
               &temp2) == NULL);
            refer->lbnd = fp_sub(mpl, temp1, temp);
            refer->ubnd = fp_sub(mpl, temp2, temp);
         }
#if 1 /* 15/V-2010 */
         /* solution has not been obtained by the solver yet */
         refer->stat = 0;
         refer->prim = refer->dual = 0.0;
#endif
      }
      return refer;
}

/*----------------------------------------------------------------------
-- eval_member_con - evaluate reference to elemental constraint.
--
-- This routine evaluates a reference to elemental constraint assigned
-- to member of specified model constraint and returns it on exit. */

struct eval_con_info
{     /* working info used by the routine eval_member_con */
      CONSTRAINT *con;
      /* model constraint */
      TUPLE *tuple;
      /* n-tuple, which defines constraint member */
      ELEMCON *refer;
      /* evaluated reference to elemental constraint */
};

static void eval_con_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine to work within domain scope */
      struct eval_con_info *info = _info;
      info->refer = take_member_con(mpl, info->con, info->tuple);
      return;
}

ELEMCON *eval_member_con      /* returns reference */
(     MPL *mpl,
      CONSTRAINT *con,        /* not changed */
      TUPLE *tuple            /* not changed */
)
{     /* this routine evaluates constraint member */
      struct eval_con_info _info, *info = &_info;
      xassert(con->dim == tuple_dimen(mpl, tuple));
      info->con = con;
      info->tuple = tuple;
      /* evaluate member, which has given n-tuple */
      if (eval_within_domain(mpl, info->con->domain, info->tuple, info,
         eval_con_func))
         out_of_domain(mpl, con->name, info->tuple);
      /* bring evaluated reference to the calling program */
      return info->refer;
}

/*----------------------------------------------------------------------
-- eval_whole_con - evaluate model constraint over entire domain.
--
-- This routine evaluates all members of specified model constraint over
-- entire domain. */

static int whole_con_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      CONSTRAINT *con = (CONSTRAINT *)info;
      TUPLE *tuple = get_domain_tuple(mpl, con->domain);
      eval_member_con(mpl, con, tuple);
      delete_tuple(mpl, tuple);
      return 0;
}

void eval_whole_con(MPL *mpl, CONSTRAINT *con)
{     loop_within_domain(mpl, con->domain, con, whole_con_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_constraint - clean model constraint.
--
-- This routine cleans specified model constraint that assumes deleting
-- all stuff dynamically allocated during the generation phase. */

void clean_constraint(MPL *mpl, CONSTRAINT *con)
{     MEMBER *memb;
      /* clean subscript domain */
      clean_domain(mpl, con->domain);
      /* clean code for computing main linear form */
      clean_code(mpl, con->code);
      /* clean code for computing lower bound */
      clean_code(mpl, con->lbnd);
      /* clean code for computing upper bound */
      if (con->ubnd != con->lbnd) clean_code(mpl, con->ubnd);
      /* delete content array */
      for (memb = con->array->head; memb != NULL; memb = memb->next)
      {  delete_formula(mpl, memb->value.con->form);
         dmp_free_atom(mpl->elemcons, memb->value.con, sizeof(ELEMCON));
      }
      delete_array(mpl, con->array), con->array = NULL;
      return;
}

/**********************************************************************/
/* * *                        PSEUDO-CODE                         * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- eval_numeric - evaluate pseudo-code to determine numeric value.
--
-- This routine evaluates specified pseudo-code to determine resultant
-- numeric value, which is returned on exit. */

struct iter_num_info
{     /* working info used by the routine iter_num_func */
      CODE *code;
      /* pseudo-code for iterated operation to be performed */
      double value;
      /* resultant value */
};

static int iter_num_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine used to perform iterated operation
         on numeric "integrand" within domain scope */
      struct iter_num_info *info = _info;
      double temp;
      temp = eval_numeric(mpl, info->code->arg.loop.x);
      switch (info->code->op)
      {  case O_SUM:
            /* summation over domain */
            info->value = fp_add(mpl, info->value, temp);
            break;
         case O_PROD:
            /* multiplication over domain */
            info->value = fp_mul(mpl, info->value, temp);
            break;
         case O_MINIMUM:
            /* minimum over domain */
            if (info->value > temp) info->value = temp;
            break;
         case O_MAXIMUM:
            /* maximum over domain */
            if (info->value < temp) info->value = temp;
            break;
         default:
            xassert(info != info);
      }
      return 0;
}

double eval_numeric(MPL *mpl, CODE *code)
{     double value;
      xassert(code != NULL);
      xassert(code->type == A_NUMERIC);
      xassert(code->dim == 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = code->value.num;
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_NUMBER:
            /* take floating-point number */
            value = code->arg.num;
            break;
         case O_MEMNUM:
            /* take member of numeric parameter */
            {  TUPLE *tuple;
               ARG_LIST *e;
               tuple = create_tuple(mpl);
               for (e = code->arg.par.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
               value = eval_member_num(mpl, code->arg.par.par, tuple);
               delete_tuple(mpl, tuple);
            }
            break;
         case O_MEMVAR:
            /* take computed value of elemental variable */
            {  TUPLE *tuple;
               ARG_LIST *e;
#if 1 /* 15/V-2010 */
               ELEMVAR *var;
#endif
               tuple = create_tuple(mpl);
               for (e = code->arg.var.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
#if 0 /* 15/V-2010 */
               value = eval_member_var(mpl, code->arg.var.var, tuple)
                  ->value;
#else
               var = eval_member_var(mpl, code->arg.var.var, tuple);
               switch (code->arg.var.suff)
               {  case DOT_LB:
                     if (var->var->lbnd == NULL)
                        value = -DBL_MAX;
                     else
                        value = var->lbnd;
                     break;
                  case DOT_UB:
                     if (var->var->ubnd == NULL)
                        value = +DBL_MAX;
                     else
                        value = var->ubnd;
                     break;
                  case DOT_STATUS:
                     value = var->stat;
                     break;
                  case DOT_VAL:
                     value = var->prim;
                     break;
                  case DOT_DUAL:
                     value = var->dual;
                     break;
                  default:
                     xassert(code != code);
               }
#endif
               delete_tuple(mpl, tuple);
            }
            break;
#if 1 /* 15/V-2010 */
         case O_MEMCON:
            /* take computed value of elemental constraint */
            {  TUPLE *tuple;
               ARG_LIST *e;
               ELEMCON *con;
               tuple = create_tuple(mpl);
               for (e = code->arg.con.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
               con = eval_member_con(mpl, code->arg.con.con, tuple);
               switch (code->arg.con.suff)
               {  case DOT_LB:
                     if (con->con->lbnd == NULL)
                        value = -DBL_MAX;
                     else
                        value = con->lbnd;
                     break;
                  case DOT_UB:
                     if (con->con->ubnd == NULL)
                        value = +DBL_MAX;
                     else
                        value = con->ubnd;
                     break;
                  case DOT_STATUS:
                     value = con->stat;
                     break;
                  case DOT_VAL:
                     value = con->prim;
                     break;
                  case DOT_DUAL:
                     value = con->dual;
                     break;
                  default:
                     xassert(code != code);
               }
               delete_tuple(mpl, tuple);
            }
            break;
#endif
         case O_IRAND224:
            /* pseudo-random in [0, 2^24-1] */
            value = fp_irand224(mpl);
            break;
         case O_UNIFORM01:
            /* pseudo-random in [0, 1) */
            value = fp_uniform01(mpl);
            break;
         case O_NORMAL01:
            /* gaussian random, mu = 0, sigma = 1 */
            value = fp_normal01(mpl);
            break;
         case O_GMTIME:
            /* current calendar time */
            value = fn_gmtime(mpl);
            break;
         case O_CVTNUM:
            /* conversion to numeric */
            {  SYMBOL *sym;
               sym = eval_symbolic(mpl, code->arg.arg.x);
#if 0 /* 23/XI-2008 */
               if (sym->str != NULL)
                  error(mpl, "cannot convert %s to floating-point numbe"
                     "r", format_symbol(mpl, sym));
               value = sym->num;
#else
               if (sym->str == NULL)
                  value = sym->num;
               else
               {  if (str2num(sym->str, &value))
                     error(mpl, "cannot convert %s to floating-point nu"
                        "mber", format_symbol(mpl, sym));
               }
#endif
               delete_symbol(mpl, sym);
            }
            break;
         case O_PLUS:
            /* unary plus */
            value = + eval_numeric(mpl, code->arg.arg.x);
            break;
         case O_MINUS:
            /* unary minus */
            value = - eval_numeric(mpl, code->arg.arg.x);
            break;
         case O_ABS:
            /* absolute value */
            value = fabs(eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_CEIL:
            /* round upward ("ceiling of x") */
            value = ceil(eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_FLOOR:
            /* round downward ("floor of x") */
            value = floor(eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_EXP:
            /* base-e exponential */
            value = fp_exp(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_LOG:
            /* natural logarithm */
            value = fp_log(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_LOG10:
            /* common (decimal) logarithm */
            value = fp_log10(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_SQRT:
            /* square root */
            value = fp_sqrt(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_SIN:
            /* trigonometric sine */
            value = fp_sin(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_COS:
            /* trigonometric cosine */
            value = fp_cos(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_TAN:
            /* trigonometric tangent */
            value = fp_tan(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_ATAN:
            /* trigonometric arctangent (one argument) */
            value = fp_atan(mpl, eval_numeric(mpl, code->arg.arg.x));
            break;
         case O_ATAN2:
            /* trigonometric arctangent (two arguments) */
            value = fp_atan2(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_ROUND:
            /* round to nearest integer */
            value = fp_round(mpl,
               eval_numeric(mpl, code->arg.arg.x), 0.0);
            break;
         case O_ROUND2:
            /* round to n fractional digits */
            value = fp_round(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_TRUNC:
            /* truncate to nearest integer */
            value = fp_trunc(mpl,
               eval_numeric(mpl, code->arg.arg.x), 0.0);
            break;
         case O_TRUNC2:
            /* truncate to n fractional digits */
            value = fp_trunc(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_ADD:
            /* addition */
            value = fp_add(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_SUB:
            /* subtraction */
            value = fp_sub(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_LESS:
            /* non-negative subtraction */
            value = fp_less(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_MUL:
            /* multiplication */
            value = fp_mul(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_DIV:
            /* division */
            value = fp_div(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_IDIV:
            /* quotient of exact division */
            value = fp_idiv(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_MOD:
            /* remainder of exact division */
            value = fp_mod(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_POWER:
            /* exponentiation (raise to power) */
            value = fp_power(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_UNIFORM:
            /* pseudo-random in [a, b) */
            value = fp_uniform(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_NORMAL:
            /* gaussian random, given mu and sigma */
            value = fp_normal(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y));
            break;
         case O_CARD:
            {  ELEMSET *set;
               set = eval_elemset(mpl, code->arg.arg.x);
               value = set->size;
               delete_array(mpl, set);
            }
            break;
         case O_LENGTH:
            {  SYMBOL *sym;
               char str[MAX_LENGTH+1];
               sym = eval_symbolic(mpl, code->arg.arg.x);
               if (sym->str == NULL)
                  sprintf(str, "%.*g", DBL_DIG, sym->num);
               else
                  fetch_string(mpl, sym->str, str);
               delete_symbol(mpl, sym);
               value = strlen(str);
            }
            break;
         case O_STR2TIME:
            {  SYMBOL *sym;
               char str[MAX_LENGTH+1], fmt[MAX_LENGTH+1];
               sym = eval_symbolic(mpl, code->arg.arg.x);
               if (sym->str == NULL)
                  sprintf(str, "%.*g", DBL_DIG, sym->num);
               else
                  fetch_string(mpl, sym->str, str);
               delete_symbol(mpl, sym);
               sym = eval_symbolic(mpl, code->arg.arg.y);
               if (sym->str == NULL)
                  sprintf(fmt, "%.*g", DBL_DIG, sym->num);
               else
                  fetch_string(mpl, sym->str, fmt);
               delete_symbol(mpl, sym);
               value = fn_str2time(mpl, str, fmt);
            }
            break;
         case O_FORK:
            /* if-then-else */
            if (eval_logical(mpl, code->arg.arg.x))
               value = eval_numeric(mpl, code->arg.arg.y);
            else if (code->arg.arg.z == NULL)
               value = 0.0;
            else
               value = eval_numeric(mpl, code->arg.arg.z);
            break;
         case O_MIN:
            /* minimal value (n-ary) */
            {  ARG_LIST *e;
               double temp;
               value = +DBL_MAX;
               for (e = code->arg.list; e != NULL; e = e->next)
               {  temp = eval_numeric(mpl, e->x);
                  if (value > temp) value = temp;
               }
            }
            break;
         case O_MAX:
            /* maximal value (n-ary) */
            {  ARG_LIST *e;
               double temp;
               value = -DBL_MAX;
               for (e = code->arg.list; e != NULL; e = e->next)
               {  temp = eval_numeric(mpl, e->x);
                  if (value < temp) value = temp;
               }
            }
            break;
         case O_SUM:
            /* summation over domain */
            {  struct iter_num_info _info, *info = &_info;
               info->code = code;
               info->value = 0.0;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_num_func);
               value = info->value;
            }
            break;
         case O_PROD:
            /* multiplication over domain */
            {  struct iter_num_info _info, *info = &_info;
               info->code = code;
               info->value = 1.0;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_num_func);
               value = info->value;
            }
            break;
         case O_MINIMUM:
            /* minimum over domain */
            {  struct iter_num_info _info, *info = &_info;
               info->code = code;
               info->value = +DBL_MAX;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_num_func);
               if (info->value == +DBL_MAX)
                  error(mpl, "min{} over empty set; result undefined");
               value = info->value;
            }
            break;
         case O_MAXIMUM:
            /* maximum over domain */
            {  struct iter_num_info _info, *info = &_info;
               info->code = code;
               info->value = -DBL_MAX;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_num_func);
               if (info->value == -DBL_MAX)
                  error(mpl, "max{} over empty set; result undefined");
               value = info->value;
            }
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.num = value;
done: return value;
}

/*----------------------------------------------------------------------
-- eval_symbolic - evaluate pseudo-code to determine symbolic value.
--
-- This routine evaluates specified pseudo-code to determine resultant
-- symbolic value, which is returned on exit. */

SYMBOL *eval_symbolic(MPL *mpl, CODE *code)
{     SYMBOL *value;
      xassert(code != NULL);
      xassert(code->type == A_SYMBOLIC);
      xassert(code->dim == 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = copy_symbol(mpl, code->value.sym);
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_STRING:
            /* take character string */
            value = create_symbol_str(mpl, create_string(mpl,
               code->arg.str));
            break;
         case O_INDEX:
            /* take dummy index */
            xassert(code->arg.index.slot->value != NULL);
            value = copy_symbol(mpl, code->arg.index.slot->value);
            break;
         case O_MEMSYM:
            /* take member of symbolic parameter */
            {  TUPLE *tuple;
               ARG_LIST *e;
               tuple = create_tuple(mpl);
               for (e = code->arg.par.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
               value = eval_member_sym(mpl, code->arg.par.par, tuple);
               delete_tuple(mpl, tuple);
            }
            break;
         case O_CVTSYM:
            /* conversion to symbolic */
            value = create_symbol_num(mpl, eval_numeric(mpl,
               code->arg.arg.x));
            break;
         case O_CONCAT:
            /* concatenation */
            value = concat_symbols(mpl,
               eval_symbolic(mpl, code->arg.arg.x),
               eval_symbolic(mpl, code->arg.arg.y));
            break;
         case O_FORK:
            /* if-then-else */
            if (eval_logical(mpl, code->arg.arg.x))
               value = eval_symbolic(mpl, code->arg.arg.y);
            else if (code->arg.arg.z == NULL)
               value = create_symbol_num(mpl, 0.0);
            else
               value = eval_symbolic(mpl, code->arg.arg.z);
            break;
         case O_SUBSTR:
         case O_SUBSTR3:
            {  double pos, len;
               char str[MAX_LENGTH+1];
               value = eval_symbolic(mpl, code->arg.arg.x);
               if (value->str == NULL)
                  sprintf(str, "%.*g", DBL_DIG, value->num);
               else
                  fetch_string(mpl, value->str, str);
               delete_symbol(mpl, value);
               if (code->op == O_SUBSTR)
               {  pos = eval_numeric(mpl, code->arg.arg.y);
                  if (pos != floor(pos))
                     error(mpl, "substr('...', %.*g); non-integer secon"
                        "d argument", DBL_DIG, pos);
                  if (pos < 1 || pos > strlen(str) + 1)
                     error(mpl, "substr('...', %.*g); substring out of "
                        "range", DBL_DIG, pos);
               }
               else
               {  pos = eval_numeric(mpl, code->arg.arg.y);
                  len = eval_numeric(mpl, code->arg.arg.z);
                  if (pos != floor(pos) || len != floor(len))
                     error(mpl, "substr('...', %.*g, %.*g); non-integer"
                        " second and/or third argument", DBL_DIG, pos,
                        DBL_DIG, len);
                  if (pos < 1 || len < 0 || pos + len > strlen(str) + 1)
                     error(mpl, "substr('...', %.*g, %.*g); substring o"
                        "ut of range", DBL_DIG, pos, DBL_DIG, len);
                  str[(int)pos + (int)len - 1] = '\0';
               }
               value = create_symbol_str(mpl, create_string(mpl, str +
                  (int)pos - 1));
            }
            break;
         case O_TIME2STR:
            {  double num;
               SYMBOL *sym;
               char str[MAX_LENGTH+1], fmt[MAX_LENGTH+1];
               num = eval_numeric(mpl, code->arg.arg.x);
               sym = eval_symbolic(mpl, code->arg.arg.y);
               if (sym->str == NULL)
                  sprintf(fmt, "%.*g", DBL_DIG, sym->num);
               else
                  fetch_string(mpl, sym->str, fmt);
               delete_symbol(mpl, sym);
               fn_time2str(mpl, str, num, fmt);
               value = create_symbol_str(mpl, create_string(mpl, str));
            }
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.sym = copy_symbol(mpl, value);
done: return value;
}

/*----------------------------------------------------------------------
-- eval_logical - evaluate pseudo-code to determine logical value.
--
-- This routine evaluates specified pseudo-code to determine resultant
-- logical value, which is returned on exit. */

struct iter_log_info
{     /* working info used by the routine iter_log_func */
      CODE *code;
      /* pseudo-code for iterated operation to be performed */
      int value;
      /* resultant value */
};

static int iter_log_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine used to perform iterated operation
         on logical "integrand" within domain scope */
      struct iter_log_info *info = _info;
      int ret = 0;
      switch (info->code->op)
      {  case O_FORALL:
            /* conjunction over domain */
            info->value &= eval_logical(mpl, info->code->arg.loop.x);
            if (!info->value) ret = 1;
            break;
         case O_EXISTS:
            /* disjunction over domain */
            info->value |= eval_logical(mpl, info->code->arg.loop.x);
            if (info->value) ret = 1;
            break;
         default:
            xassert(info != info);
      }
      return ret;
}

int eval_logical(MPL *mpl, CODE *code)
{     int value;
      xassert(code->type == A_LOGICAL);
      xassert(code->dim == 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = code->value.bit;
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_CVTLOG:
            /* conversion to logical */
            value = (eval_numeric(mpl, code->arg.arg.x) != 0.0);
            break;
         case O_NOT:
            /* negation (logical "not") */
            value = !eval_logical(mpl, code->arg.arg.x);
            break;
         case O_LT:
            /* comparison on 'less than' */
#if 0 /* 02/VIII-2008 */
            value = (eval_numeric(mpl, code->arg.arg.x) <
                     eval_numeric(mpl, code->arg.arg.y));
#else
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) <
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) < 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
#endif
            break;
         case O_LE:
            /* comparison on 'not greater than' */
#if 0 /* 02/VIII-2008 */
            value = (eval_numeric(mpl, code->arg.arg.x) <=
                     eval_numeric(mpl, code->arg.arg.y));
#else
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) <=
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) <= 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
#endif
            break;
         case O_EQ:
            /* comparison on 'equal to' */
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) ==
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) == 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
            break;
         case O_GE:
            /* comparison on 'not less than' */
#if 0 /* 02/VIII-2008 */
            value = (eval_numeric(mpl, code->arg.arg.x) >=
                     eval_numeric(mpl, code->arg.arg.y));
#else
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) >=
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) >= 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
#endif
            break;
         case O_GT:
            /* comparison on 'greater than' */
#if 0 /* 02/VIII-2008 */
            value = (eval_numeric(mpl, code->arg.arg.x) >
                     eval_numeric(mpl, code->arg.arg.y));
#else
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) >
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) > 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
#endif
            break;
         case O_NE:
            /* comparison on 'not equal to' */
            xassert(code->arg.arg.x != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
               value = (eval_numeric(mpl, code->arg.arg.x) !=
                        eval_numeric(mpl, code->arg.arg.y));
            else
            {  SYMBOL *sym1 = eval_symbolic(mpl, code->arg.arg.x);
               SYMBOL *sym2 = eval_symbolic(mpl, code->arg.arg.y);
               value = (compare_symbols(mpl, sym1, sym2) != 0);
               delete_symbol(mpl, sym1);
               delete_symbol(mpl, sym2);
            }
            break;
         case O_AND:
            /* conjunction (logical "and") */
            value = eval_logical(mpl, code->arg.arg.x) &&
                    eval_logical(mpl, code->arg.arg.y);
            break;
         case O_OR:
            /* disjunction (logical "or") */
            value = eval_logical(mpl, code->arg.arg.x) ||
                    eval_logical(mpl, code->arg.arg.y);
            break;
         case O_IN:
            /* test on 'x in Y' */
            {  TUPLE *tuple;
               tuple = eval_tuple(mpl, code->arg.arg.x);
               value = is_member(mpl, code->arg.arg.y, tuple);
               delete_tuple(mpl, tuple);
            }
            break;
         case O_NOTIN:
            /* test on 'x not in Y' */
            {  TUPLE *tuple;
               tuple = eval_tuple(mpl, code->arg.arg.x);
               value = !is_member(mpl, code->arg.arg.y, tuple);
               delete_tuple(mpl, tuple);
            }
            break;
         case O_WITHIN:
            /* test on 'X within Y' */
            {  ELEMSET *set;
               MEMBER *memb;
               set = eval_elemset(mpl, code->arg.arg.x);
               value = 1;
               for (memb = set->head; memb != NULL; memb = memb->next)
               {  if (!is_member(mpl, code->arg.arg.y, memb->tuple))
                  {  value = 0;
                     break;
                  }
               }
               delete_elemset(mpl, set);
            }
            break;
         case O_NOTWITHIN:
            /* test on 'X not within Y' */
            {  ELEMSET *set;
               MEMBER *memb;
               set = eval_elemset(mpl, code->arg.arg.x);
               value = 1;
               for (memb = set->head; memb != NULL; memb = memb->next)
               {  if (is_member(mpl, code->arg.arg.y, memb->tuple))
                  {  value = 0;
                     break;
                  }
               }
               delete_elemset(mpl, set);
            }
            break;
         case O_FORALL:
            /* conjunction (A-quantification) */
            {  struct iter_log_info _info, *info = &_info;
               info->code = code;
               info->value = 1;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_log_func);
               value = info->value;
            }
            break;
         case O_EXISTS:
            /* disjunction (E-quantification) */
            {  struct iter_log_info _info, *info = &_info;
               info->code = code;
               info->value = 0;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_log_func);
               value = info->value;
            }
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.bit = value;
done: return value;
}

/*----------------------------------------------------------------------
-- eval_tuple - evaluate pseudo-code to construct n-tuple.
--
-- This routine evaluates specified pseudo-code to construct resultant
-- n-tuple, which is returned on exit. */

TUPLE *eval_tuple(MPL *mpl, CODE *code)
{     TUPLE *value;
      xassert(code != NULL);
      xassert(code->type == A_TUPLE);
      xassert(code->dim > 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = copy_tuple(mpl, code->value.tuple);
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_TUPLE:
            /* make n-tuple */
            {  ARG_LIST *e;
               value = create_tuple(mpl);
               for (e = code->arg.list; e != NULL; e = e->next)
                  value = expand_tuple(mpl, value, eval_symbolic(mpl,
                     e->x));
            }
            break;
         case O_CVTTUP:
            /* convert to 1-tuple */
            value = expand_tuple(mpl, create_tuple(mpl),
               eval_symbolic(mpl, code->arg.arg.x));
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.tuple = copy_tuple(mpl, value);
done: return value;
}

/*----------------------------------------------------------------------
-- eval_elemset - evaluate pseudo-code to construct elemental set.
--
-- This routine evaluates specified pseudo-code to construct resultant
-- elemental set, which is returned on exit. */

struct iter_set_info
{     /* working info used by the routine iter_set_func */
      CODE *code;
      /* pseudo-code for iterated operation to be performed */
      ELEMSET *value;
      /* resultant value */
};

static int iter_set_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine used to perform iterated operation
         on n-tuple "integrand" within domain scope */
      struct iter_set_info *info = _info;
      TUPLE *tuple;
      switch (info->code->op)
      {  case O_SETOF:
            /* compute next n-tuple and add it to the set; in this case
               duplicate n-tuples are silently ignored */
            tuple = eval_tuple(mpl, info->code->arg.loop.x);
            if (find_tuple(mpl, info->value, tuple) == NULL)
               add_tuple(mpl, info->value, tuple);
            else
               delete_tuple(mpl, tuple);
            break;
         case O_BUILD:
            /* construct next n-tuple using current values assigned to
               *free* dummy indices as its components and add it to the
               set; in this case duplicate n-tuples cannot appear */
            add_tuple(mpl, info->value, get_domain_tuple(mpl,
               info->code->arg.loop.domain));
            break;
         default:
            xassert(info != info);
      }
      return 0;
}

ELEMSET *eval_elemset(MPL *mpl, CODE *code)
{     ELEMSET *value;
      xassert(code != NULL);
      xassert(code->type == A_ELEMSET);
      xassert(code->dim > 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = copy_elemset(mpl, code->value.set);
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_MEMSET:
            /* take member of set */
            {  TUPLE *tuple;
               ARG_LIST *e;
               tuple = create_tuple(mpl);
               for (e = code->arg.set.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
               value = copy_elemset(mpl,
                  eval_member_set(mpl, code->arg.set.set, tuple));
               delete_tuple(mpl, tuple);
            }
            break;
         case O_MAKE:
            /* make elemental set of n-tuples */
            {  ARG_LIST *e;
               value = create_elemset(mpl, code->dim);
               for (e = code->arg.list; e != NULL; e = e->next)
                  check_then_add(mpl, value, eval_tuple(mpl, e->x));
            }
            break;
         case O_UNION:
            /* union of two elemental sets */
            value = set_union(mpl,
               eval_elemset(mpl, code->arg.arg.x),
               eval_elemset(mpl, code->arg.arg.y));
            break;
         case O_DIFF:
            /* difference between two elemental sets */
            value = set_diff(mpl,
               eval_elemset(mpl, code->arg.arg.x),
               eval_elemset(mpl, code->arg.arg.y));
            break;
         case O_SYMDIFF:
            /* symmetric difference between two elemental sets */
            value = set_symdiff(mpl,
               eval_elemset(mpl, code->arg.arg.x),
               eval_elemset(mpl, code->arg.arg.y));
            break;
         case O_INTER:
            /* intersection of two elemental sets */
            value = set_inter(mpl,
               eval_elemset(mpl, code->arg.arg.x),
               eval_elemset(mpl, code->arg.arg.y));
            break;
         case O_CROSS:
            /* cross (Cartesian) product of two elemental sets */
            value = set_cross(mpl,
               eval_elemset(mpl, code->arg.arg.x),
               eval_elemset(mpl, code->arg.arg.y));
            break;
         case O_DOTS:
            /* build "arithmetic" elemental set */
            value = create_arelset(mpl,
               eval_numeric(mpl, code->arg.arg.x),
               eval_numeric(mpl, code->arg.arg.y),
               code->arg.arg.z == NULL ? 1.0 : eval_numeric(mpl,
                  code->arg.arg.z));
            break;
         case O_FORK:
            /* if-then-else */
            if (eval_logical(mpl, code->arg.arg.x))
               value = eval_elemset(mpl, code->arg.arg.y);
            else
               value = eval_elemset(mpl, code->arg.arg.z);
            break;
         case O_SETOF:
            /* compute elemental set */
            {  struct iter_set_info _info, *info = &_info;
               info->code = code;
               info->value = create_elemset(mpl, code->dim);
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_set_func);
               value = info->value;
            }
            break;
         case O_BUILD:
            /* build elemental set identical to domain set */
            {  struct iter_set_info _info, *info = &_info;
               info->code = code;
               info->value = create_elemset(mpl, code->dim);
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_set_func);
               value = info->value;
            }
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.set = copy_elemset(mpl, value);
done: return value;
}

/*----------------------------------------------------------------------
-- is_member - check if n-tuple is in set specified by pseudo-code.
--
-- This routine checks if given n-tuple is a member of elemental set
-- specified in the form of pseudo-code (i.e. by expression).
--
-- The n-tuple may have more components that dimension of the elemental
-- set, in which case the extra components are ignored. */

static void null_func(MPL *mpl, void *info)
{     /* this is dummy routine used to enter the domain scope */
      xassert(mpl == mpl);
      xassert(info == NULL);
      return;
}

int is_member(MPL *mpl, CODE *code, TUPLE *tuple)
{     int value;
      xassert(code != NULL);
      xassert(code->type == A_ELEMSET);
      xassert(code->dim > 0);
      xassert(tuple != NULL);
      switch (code->op)
      {  case O_MEMSET:
            /* check if given n-tuple is member of elemental set, which
               is assigned to member of model set */
            {  ARG_LIST *e;
               TUPLE *temp;
               ELEMSET *set;
               /* evaluate reference to elemental set */
               temp = create_tuple(mpl);
               for (e = code->arg.set.list; e != NULL; e = e->next)
                  temp = expand_tuple(mpl, temp, eval_symbolic(mpl,
                     e->x));
               set = eval_member_set(mpl, code->arg.set.set, temp);
               delete_tuple(mpl, temp);
               /* check if the n-tuple is contained in the set array */
               temp = build_subtuple(mpl, tuple, set->dim);
               value = (find_tuple(mpl, set, temp) != NULL);
               delete_tuple(mpl, temp);
            }
            break;
         case O_MAKE:
            /* check if given n-tuple is member of literal set */
            {  ARG_LIST *e;
               TUPLE *temp, *that;
               value = 0;
               temp = build_subtuple(mpl, tuple, code->dim);
               for (e = code->arg.list; e != NULL; e = e->next)
               {  that = eval_tuple(mpl, e->x);
                  value = (compare_tuples(mpl, temp, that) == 0);
                  delete_tuple(mpl, that);
                  if (value) break;
               }
               delete_tuple(mpl, temp);
            }
            break;
         case O_UNION:
            value = is_member(mpl, code->arg.arg.x, tuple) ||
                    is_member(mpl, code->arg.arg.y, tuple);
            break;
         case O_DIFF:
            value = is_member(mpl, code->arg.arg.x, tuple) &&
                   !is_member(mpl, code->arg.arg.y, tuple);
            break;
         case O_SYMDIFF:
            {  int in1 = is_member(mpl, code->arg.arg.x, tuple);
               int in2 = is_member(mpl, code->arg.arg.y, tuple);
               value = (in1 && !in2) || (!in1 && in2);
            }
            break;
         case O_INTER:
            value = is_member(mpl, code->arg.arg.x, tuple) &&
                    is_member(mpl, code->arg.arg.y, tuple);
            break;
         case O_CROSS:
            {  int j;
               value = is_member(mpl, code->arg.arg.x, tuple);
               if (value)
               {  for (j = 1; j <= code->arg.arg.x->dim; j++)
                  {  xassert(tuple != NULL);
                     tuple = tuple->next;
                  }
                  value = is_member(mpl, code->arg.arg.y, tuple);
               }
            }
            break;
         case O_DOTS:
            /* check if given 1-tuple is member of "arithmetic" set */
            {  int j;
               double x, t0, tf, dt;
               xassert(code->dim == 1);
               /* compute "parameters" of the "arithmetic" set */
               t0 = eval_numeric(mpl, code->arg.arg.x);
               tf = eval_numeric(mpl, code->arg.arg.y);
               if (code->arg.arg.z == NULL)
                  dt = 1.0;
               else
                  dt = eval_numeric(mpl, code->arg.arg.z);
               /* make sure the parameters are correct */
               arelset_size(mpl, t0, tf, dt);
               /* if component of 1-tuple is symbolic, not numeric, the
                  1-tuple cannot be member of "arithmetic" set */
               xassert(tuple->sym != NULL);
               if (tuple->sym->str != NULL)
               {  value = 0;
                  break;
               }
               /* determine numeric value of the component */
               x = tuple->sym->num;
               /* if the component value is out of the set range, the
                  1-tuple is not in the set */
               if (dt > 0.0 && !(t0 <= x && x <= tf) ||
                   dt < 0.0 && !(tf <= x && x <= t0))
               {  value = 0;
                  break;
               }
               /* estimate ordinal number of the 1-tuple in the set */
               j = (int)(((x - t0) / dt) + 0.5) + 1;
               /* perform the main check */
               value = (arelset_member(mpl, t0, tf, dt, j) == x);
            }
            break;
         case O_FORK:
            /* check if given n-tuple is member of conditional set */
            if (eval_logical(mpl, code->arg.arg.x))
               value = is_member(mpl, code->arg.arg.y, tuple);
            else
               value = is_member(mpl, code->arg.arg.z, tuple);
            break;
         case O_SETOF:
            /* check if given n-tuple is member of computed set */
            /* it is not clear how to efficiently perform the check not
               computing the entire elemental set :+( */
            error(mpl, "implementation restriction; in/within setof{} n"
               "ot allowed");
            break;
         case O_BUILD:
            /* check if given n-tuple is member of domain set */
            {  TUPLE *temp;
               temp = build_subtuple(mpl, tuple, code->dim);
               /* try to enter the domain scope; if it is successful,
                  the n-tuple is in the domain set */
               value = (eval_within_domain(mpl, code->arg.loop.domain,
                  temp, NULL, null_func) == 0);
               delete_tuple(mpl, temp);
            }
            break;
         default:
            xassert(code != code);
      }
      return value;
}

/*----------------------------------------------------------------------
-- eval_formula - evaluate pseudo-code to construct linear form.
--
-- This routine evaluates specified pseudo-code to construct resultant
-- linear form, which is returned on exit. */

struct iter_form_info
{     /* working info used by the routine iter_form_func */
      CODE *code;
      /* pseudo-code for iterated operation to be performed */
      FORMULA *value;
      /* resultant value */
      FORMULA *tail;
      /* pointer to the last term */
};

static int iter_form_func(MPL *mpl, void *_info)
{     /* this is auxiliary routine used to perform iterated operation
         on linear form "integrand" within domain scope */
      struct iter_form_info *info = _info;
      switch (info->code->op)
      {  case O_SUM:
            /* summation over domain */
#if 0
            info->value =
               linear_comb(mpl,
                  +1.0, info->value,
                  +1.0, eval_formula(mpl, info->code->arg.loop.x));
#else
            /* the routine linear_comb needs to look through all terms
               of both linear forms to reduce identical terms, so using
               it here is not a good idea (for example, evaluation of
               sum{i in 1..n} x[i] required quadratic time); the better
               idea is to gather all terms of the integrand in one list
               and reduce identical terms only once after all terms of
               the resultant linear form have been evaluated */
            {  FORMULA *form, *term;
               form = eval_formula(mpl, info->code->arg.loop.x);
               if (info->value == NULL)
               {  xassert(info->tail == NULL);
                  info->value = form;
               }
               else
               {  xassert(info->tail != NULL);
                  info->tail->next = form;
               }
               for (term = form; term != NULL; term = term->next)
                  info->tail = term;
            }
#endif
            break;
         default:
            xassert(info != info);
      }
      return 0;
}

FORMULA *eval_formula(MPL *mpl, CODE *code)
{     FORMULA *value;
      xassert(code != NULL);
      xassert(code->type == A_FORMULA);
      xassert(code->dim == 0);
      /* if the operation has a side effect, invalidate and delete the
         resultant value */
      if (code->vflag && code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* if resultant value is valid, no evaluation is needed */
      if (code->valid)
      {  value = copy_formula(mpl, code->value.form);
         goto done;
      }
      /* evaluate pseudo-code recursively */
      switch (code->op)
      {  case O_MEMVAR:
            /* take member of variable */
            {  TUPLE *tuple;
               ARG_LIST *e;
               tuple = create_tuple(mpl);
               for (e = code->arg.var.list; e != NULL; e = e->next)
                  tuple = expand_tuple(mpl, tuple, eval_symbolic(mpl,
                     e->x));
#if 1 /* 15/V-2010 */
               xassert(code->arg.var.suff == DOT_NONE);
#endif
               value = single_variable(mpl,
                  eval_member_var(mpl, code->arg.var.var, tuple));
               delete_tuple(mpl, tuple);
            }
            break;
         case O_CVTLFM:
            /* convert to linear form */
            value = constant_term(mpl, eval_numeric(mpl,
               code->arg.arg.x));
            break;
         case O_PLUS:
            /* unary plus */
            value = linear_comb(mpl,
                0.0, constant_term(mpl, 0.0),
               +1.0, eval_formula(mpl, code->arg.arg.x));
            break;
         case O_MINUS:
            /* unary minus */
            value = linear_comb(mpl,
                0.0, constant_term(mpl, 0.0),
               -1.0, eval_formula(mpl, code->arg.arg.x));
            break;
         case O_ADD:
            /* addition */
            value = linear_comb(mpl,
               +1.0, eval_formula(mpl, code->arg.arg.x),
               +1.0, eval_formula(mpl, code->arg.arg.y));
            break;
         case O_SUB:
            /* subtraction */
            value = linear_comb(mpl,
               +1.0, eval_formula(mpl, code->arg.arg.x),
               -1.0, eval_formula(mpl, code->arg.arg.y));
            break;
         case O_MUL:
            /* multiplication */
            xassert(code->arg.arg.x != NULL);
            xassert(code->arg.arg.y != NULL);
            if (code->arg.arg.x->type == A_NUMERIC)
            {  xassert(code->arg.arg.y->type == A_FORMULA);
               value = linear_comb(mpl,
                  eval_numeric(mpl, code->arg.arg.x),
                  eval_formula(mpl, code->arg.arg.y),
                  0.0, constant_term(mpl, 0.0));
            }
            else
            {  xassert(code->arg.arg.x->type == A_FORMULA);
               xassert(code->arg.arg.y->type == A_NUMERIC);
               value = linear_comb(mpl,
                  eval_numeric(mpl, code->arg.arg.y),
                  eval_formula(mpl, code->arg.arg.x),
                  0.0, constant_term(mpl, 0.0));
            }
            break;
         case O_DIV:
            /* division */
            value = linear_comb(mpl,
               fp_div(mpl, 1.0, eval_numeric(mpl, code->arg.arg.y)),
               eval_formula(mpl, code->arg.arg.x),
               0.0, constant_term(mpl, 0.0));
            break;
         case O_FORK:
            /* if-then-else */
            if (eval_logical(mpl, code->arg.arg.x))
               value = eval_formula(mpl, code->arg.arg.y);
            else if (code->arg.arg.z == NULL)
               value = constant_term(mpl, 0.0);
            else
               value = eval_formula(mpl, code->arg.arg.z);
            break;
         case O_SUM:
            /* summation over domain */
            {  struct iter_form_info _info, *info = &_info;
               info->code = code;
               info->value = constant_term(mpl, 0.0);
               info->tail = NULL;
               loop_within_domain(mpl, code->arg.loop.domain, info,
                  iter_form_func);
               value = reduce_terms(mpl, info->value);
            }
            break;
         default:
            xassert(code != code);
      }
      /* save resultant value */
      xassert(!code->valid);
      code->valid = 1;
      code->value.form = copy_formula(mpl, value);
done: return value;
}

/*----------------------------------------------------------------------
-- clean_code - clean pseudo-code.
--
-- This routine recursively cleans specified pseudo-code that assumes
-- deleting all temporary resultant values. */

void clean_code(MPL *mpl, CODE *code)
{     ARG_LIST *e;
      /* if no pseudo-code is specified, do nothing */
      if (code == NULL) goto done;
      /* if resultant value is valid (exists), delete it */
      if (code->valid)
      {  code->valid = 0;
         delete_value(mpl, code->type, &code->value);
      }
      /* recursively clean pseudo-code for operands */
      switch (code->op)
      {  case O_NUMBER:
         case O_STRING:
         case O_INDEX:
            break;
         case O_MEMNUM:
         case O_MEMSYM:
            for (e = code->arg.par.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
         case O_MEMSET:
            for (e = code->arg.set.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
         case O_MEMVAR:
            for (e = code->arg.var.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
#if 1 /* 15/V-2010 */
         case O_MEMCON:
            for (e = code->arg.con.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
#endif
         case O_TUPLE:
         case O_MAKE:
            for (e = code->arg.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
         case O_SLICE:
            xassert(code != code);
         case O_IRAND224:
         case O_UNIFORM01:
         case O_NORMAL01:
         case O_GMTIME:
            break;
         case O_CVTNUM:
         case O_CVTSYM:
         case O_CVTLOG:
         case O_CVTTUP:
         case O_CVTLFM:
         case O_PLUS:
         case O_MINUS:
         case O_NOT:
         case O_ABS:
         case O_CEIL:
         case O_FLOOR:
         case O_EXP:
         case O_LOG:
         case O_LOG10:
         case O_SQRT:
         case O_SIN:
         case O_COS:
         case O_TAN:
         case O_ATAN:
         case O_ROUND:
         case O_TRUNC:
         case O_CARD:
         case O_LENGTH:
            /* unary operation */
            clean_code(mpl, code->arg.arg.x);
            break;
         case O_ADD:
         case O_SUB:
         case O_LESS:
         case O_MUL:
         case O_DIV:
         case O_IDIV:
         case O_MOD:
         case O_POWER:
         case O_ATAN2:
         case O_ROUND2:
         case O_TRUNC2:
         case O_UNIFORM:
         case O_NORMAL:
         case O_CONCAT:
         case O_LT:
         case O_LE:
         case O_EQ:
         case O_GE:
         case O_GT:
         case O_NE:
         case O_AND:
         case O_OR:
         case O_UNION:
         case O_DIFF:
         case O_SYMDIFF:
         case O_INTER:
         case O_CROSS:
         case O_IN:
         case O_NOTIN:
         case O_WITHIN:
         case O_NOTWITHIN:
         case O_SUBSTR:
         case O_STR2TIME:
         case O_TIME2STR:
            /* binary operation */
            clean_code(mpl, code->arg.arg.x);
            clean_code(mpl, code->arg.arg.y);
            break;
         case O_DOTS:
         case O_FORK:
         case O_SUBSTR3:
            /* ternary operation */
            clean_code(mpl, code->arg.arg.x);
            clean_code(mpl, code->arg.arg.y);
            clean_code(mpl, code->arg.arg.z);
            break;
         case O_MIN:
         case O_MAX:
            /* n-ary operation */
            for (e = code->arg.list; e != NULL; e = e->next)
               clean_code(mpl, e->x);
            break;
         case O_SUM:
         case O_PROD:
         case O_MINIMUM:
         case O_MAXIMUM:
         case O_FORALL:
         case O_EXISTS:
         case O_SETOF:
         case O_BUILD:
            /* iterated operation */
            clean_domain(mpl, code->arg.loop.domain);
            clean_code(mpl, code->arg.loop.x);
            break;
         default:
            xassert(code->op != code->op);
      }
done: return;
}

#if 1 /* 11/II-2008 */
/**********************************************************************/
/* * *                        DATA TABLES                         * * */
/**********************************************************************/

int mpl_tab_num_args(TABDCA *dca)
{     /* returns the number of arguments */
      return dca->na;
}

const char *mpl_tab_get_arg(TABDCA *dca, int k)
{     /* returns pointer to k-th argument */
      xassert(1 <= k && k <= dca->na);
      return dca->arg[k];
}

int mpl_tab_num_flds(TABDCA *dca)
{     /* returns the number of fields */
      return dca->nf;
}

const char *mpl_tab_get_name(TABDCA *dca, int k)
{     /* returns pointer to name of k-th field */
      xassert(1 <= k && k <= dca->nf);
      return dca->name[k];
}

int mpl_tab_get_type(TABDCA *dca, int k)
{     /* returns type of k-th field */
      xassert(1 <= k && k <= dca->nf);
      return dca->type[k];
}

double mpl_tab_get_num(TABDCA *dca, int k)
{     /* returns numeric value of k-th field */
      xassert(1 <= k && k <= dca->nf);
      xassert(dca->type[k] == 'N');
      return dca->num[k];
}

const char *mpl_tab_get_str(TABDCA *dca, int k)
{     /* returns pointer to string value of k-th field */
      xassert(1 <= k && k <= dca->nf);
      xassert(dca->type[k] == 'S');
      xassert(dca->str[k] != NULL);
      return dca->str[k];
}

void mpl_tab_set_num(TABDCA *dca, int k, double num)
{     /* assign numeric value to k-th field */
      xassert(1 <= k && k <= dca->nf);
      xassert(dca->type[k] == '?');
      dca->type[k] = 'N';
      dca->num[k] = num;
      return;
}

void mpl_tab_set_str(TABDCA *dca, int k, const char *str)
{     /* assign string value to k-th field */
      xassert(1 <= k && k <= dca->nf);
      xassert(dca->type[k] == '?');
      xassert(strlen(str) <= MAX_LENGTH);
      xassert(dca->str[k] != NULL);
      dca->type[k] = 'S';
      strcpy(dca->str[k], str);
      return;
}

static int write_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      TABLE *tab = info;
      TABDCA *dca = mpl->dca;
      TABOUT *out;
      SYMBOL *sym;
      int k;
      char buf[MAX_LENGTH+1];
      /* evaluate field values */
      k = 0;
      for (out = tab->u.out.list; out != NULL; out = out->next)
      {  k++;
         switch (out->code->type)
         {  case A_NUMERIC:
               dca->type[k] = 'N';
               dca->num[k] = eval_numeric(mpl, out->code);
               dca->str[k][0] = '\0';
               break;
            case A_SYMBOLIC:
               sym = eval_symbolic(mpl, out->code);
               if (sym->str == NULL)
               {  dca->type[k] = 'N';
                  dca->num[k] = sym->num;
                  dca->str[k][0] = '\0';
               }
               else
               {  dca->type[k] = 'S';
                  dca->num[k] = 0.0;
                  fetch_string(mpl, sym->str, buf);
                  strcpy(dca->str[k], buf);
               }
               delete_symbol(mpl, sym);
               break;
            default:
               xassert(out != out);
         }
      }
      /* write record to output table */
      mpl_tab_drv_write(mpl);
      return 0;
}

void execute_table(MPL *mpl, TABLE *tab)
{     /* execute table statement */
      TABARG *arg;
      TABFLD *fld;
      TABIN *in;
      TABOUT *out;
      TABDCA *dca;
      SET *set;
      int k;
      char buf[MAX_LENGTH+1];
      /* allocate table driver communication area */
      xassert(mpl->dca == NULL);
      mpl->dca = dca = xmalloc(sizeof(TABDCA));
      dca->id = 0;
      dca->link = NULL;
      dca->na = 0;
      dca->arg = NULL;
      dca->nf = 0;
      dca->name = NULL;
      dca->type = NULL;
      dca->num = NULL;
      dca->str = NULL;
      /* allocate arguments */
      xassert(dca->na == 0);
      for (arg = tab->arg; arg != NULL; arg = arg->next)
         dca->na++;
      dca->arg = xcalloc(1+dca->na, sizeof(char *));
#if 1 /* 28/IX-2008 */
      for (k = 1; k <= dca->na; k++) dca->arg[k] = NULL;
#endif
      /* evaluate argument values */
      k = 0;
      for (arg = tab->arg; arg != NULL; arg = arg->next)
      {  SYMBOL *sym;
         k++;
         xassert(arg->code->type == A_SYMBOLIC);
         sym = eval_symbolic(mpl, arg->code);
         if (sym->str == NULL)
            sprintf(buf, "%.*g", DBL_DIG, sym->num);
         else
            fetch_string(mpl, sym->str, buf);
         delete_symbol(mpl, sym);
         dca->arg[k] = xmalloc(strlen(buf)+1);
         strcpy(dca->arg[k], buf);
      }
      /* perform table input/output */
      switch (tab->type)
      {  case A_INPUT:  goto read_table;
         case A_OUTPUT: goto write_table;
         default:       xassert(tab != tab);
      }
read_table:
      /* read data from input table */
      /* add the only member to the control set and assign it empty
         elemental set */
      set = tab->u.in.set;
      if (set != NULL)
      {  if (set->data)
            error(mpl, "%s already provided with data", set->name);
         xassert(set->array->head == NULL);
         add_member(mpl, set->array, NULL)->value.set =
            create_elemset(mpl, set->dimen);
         set->data = 1;
      }
      /* check parameters specified in the input list */
      for (in = tab->u.in.list; in != NULL; in = in->next)
      {  if (in->par->data)
            error(mpl, "%s already provided with data", in->par->name);
         in->par->data = 1;
      }
      /* allocate and initialize fields */
      xassert(dca->nf == 0);
      for (fld = tab->u.in.fld; fld != NULL; fld = fld->next)
         dca->nf++;
      for (in = tab->u.in.list; in != NULL; in = in->next)
         dca->nf++;
      dca->name = xcalloc(1+dca->nf, sizeof(char *));
      dca->type = xcalloc(1+dca->nf, sizeof(int));
      dca->num = xcalloc(1+dca->nf, sizeof(double));
      dca->str = xcalloc(1+dca->nf, sizeof(char *));
      k = 0;
      for (fld = tab->u.in.fld; fld != NULL; fld = fld->next)
      {  k++;
         dca->name[k] = fld->name;
         dca->type[k] = '?';
         dca->num[k] = 0.0;
         dca->str[k] = xmalloc(MAX_LENGTH+1);
         dca->str[k][0] = '\0';
      }
      for (in = tab->u.in.list; in != NULL; in = in->next)
      {  k++;
         dca->name[k] = in->name;
         dca->type[k] = '?';
         dca->num[k] = 0.0;
         dca->str[k] = xmalloc(MAX_LENGTH+1);
         dca->str[k][0] = '\0';
      }
      /* open input table */
      mpl_tab_drv_open(mpl, 'R');
      /* read and process records */
      for (;;)
      {  TUPLE *tup;
         /* reset field types */
         for (k = 1; k <= dca->nf; k++)
            dca->type[k] = '?';
         /* read next record */
         if (mpl_tab_drv_read(mpl)) break;
         /* all fields must be set by the driver */
         for (k = 1; k <= dca->nf; k++)
         {  if (dca->type[k] == '?')
               error(mpl, "field %s missing in input table",
                  dca->name[k]);
         }
         /* construct n-tuple */
         tup = create_tuple(mpl);
         k = 0;
         for (fld = tab->u.in.fld; fld != NULL; fld = fld->next)
         {  k++;
            xassert(k <= dca->nf);
            switch (dca->type[k])
            {  case 'N':
                  tup = expand_tuple(mpl, tup, create_symbol_num(mpl,
                     dca->num[k]));
                  break;
               case 'S':
                  xassert(strlen(dca->str[k]) <= MAX_LENGTH);
                  tup = expand_tuple(mpl, tup, create_symbol_str(mpl,
                     create_string(mpl, dca->str[k])));
                  break;
               default:
                  xassert(dca != dca);
            }
         }
         /* add n-tuple just read to the control set */
         if (tab->u.in.set != NULL)
            check_then_add(mpl, tab->u.in.set->array->head->value.set,
               copy_tuple(mpl, tup));
         /* assign values to the parameters in the input list */
         for (in = tab->u.in.list; in != NULL; in = in->next)
         {  MEMBER *memb;
            k++;
            xassert(k <= dca->nf);
            /* there must be no member with the same n-tuple */
            if (find_member(mpl, in->par->array, tup) != NULL)
               error(mpl, "%s%s already defined", in->par->name,
               format_tuple(mpl, '[', tup));
            /* create new parameter member with given n-tuple */
            memb = add_member(mpl, in->par->array, copy_tuple(mpl, tup))
               ;
            /* assign value to the parameter member */
            switch (in->par->type)
            {  case A_NUMERIC:
               case A_INTEGER:
               case A_BINARY:
                  if (dca->type[k] != 'N')
                     error(mpl, "%s requires numeric data",
                        in->par->name);
                  memb->value.num = dca->num[k];
                  break;
               case A_SYMBOLIC:
                  switch (dca->type[k])
                  {  case 'N':
                        memb->value.sym = create_symbol_num(mpl,
                           dca->num[k]);
                        break;
                     case 'S':
                        xassert(strlen(dca->str[k]) <= MAX_LENGTH);
                        memb->value.sym = create_symbol_str(mpl,
                           create_string(mpl,dca->str[k]));
                        break;
                     default:
                        xassert(dca != dca);
                  }
                  break;
               default:
                  xassert(in != in);
            }
         }
         /* n-tuple is no more needed */
         delete_tuple(mpl, tup);
      }
      /* close input table */
      mpl_tab_drv_close(mpl);
      goto done;
write_table:
      /* write data to output table */
      /* allocate and initialize fields */
      xassert(dca->nf == 0);
      for (out = tab->u.out.list; out != NULL; out = out->next)
         dca->nf++;
      dca->name = xcalloc(1+dca->nf, sizeof(char *));
      dca->type = xcalloc(1+dca->nf, sizeof(int));
      dca->num = xcalloc(1+dca->nf, sizeof(double));
      dca->str = xcalloc(1+dca->nf, sizeof(char *));
      k = 0;
      for (out = tab->u.out.list; out != NULL; out = out->next)
      {  k++;
         dca->name[k] = out->name;
         dca->type[k] = '?';
         dca->num[k] = 0.0;
         dca->str[k] = xmalloc(MAX_LENGTH+1);
         dca->str[k][0] = '\0';
      }
      /* open output table */
      mpl_tab_drv_open(mpl, 'W');
      /* evaluate fields and write records */
      loop_within_domain(mpl, tab->u.out.domain, tab, write_func);
      /* close output table */
      mpl_tab_drv_close(mpl);
done: /* free table driver communication area */
      free_dca(mpl);
      return;
}

void free_dca(MPL *mpl)
{     /* free table driver communucation area */
      TABDCA *dca = mpl->dca;
      int k;
      if (dca != NULL)
      {  if (dca->link != NULL)
            mpl_tab_drv_close(mpl);
         if (dca->arg != NULL)
         {  for (k = 1; k <= dca->na; k++)
#if 1 /* 28/IX-2008 */
               if (dca->arg[k] != NULL)
#endif
               xfree(dca->arg[k]);
            xfree(dca->arg);
         }
         if (dca->name != NULL) xfree(dca->name);
         if (dca->type != NULL) xfree(dca->type);
         if (dca->num != NULL) xfree(dca->num);
         if (dca->str != NULL)
         {  for (k = 1; k <= dca->nf; k++)
               xfree(dca->str[k]);
            xfree(dca->str);
         }
         xfree(dca), mpl->dca = NULL;
      }
      return;
}

void clean_table(MPL *mpl, TABLE *tab)
{     /* clean table statement */
      TABARG *arg;
      TABOUT *out;
      /* clean string list */
      for (arg = tab->arg; arg != NULL; arg = arg->next)
         clean_code(mpl, arg->code);
      switch (tab->type)
      {  case A_INPUT:
            break;
         case A_OUTPUT:
            /* clean subscript domain */
            clean_domain(mpl, tab->u.out.domain);
            /* clean output list */
            for (out = tab->u.out.list; out != NULL; out = out->next)
               clean_code(mpl, out->code);
            break;
         default:
            xassert(tab != tab);
      }
      return;
}
#endif

/**********************************************************************/
/* * *                      MODEL STATEMENTS                      * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- execute_check - execute check statement.
--
-- This routine executes specified check statement. */

static int check_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      CHECK *chk = (CHECK *)info;
      if (!eval_logical(mpl, chk->code))
         error(mpl, "check%s failed", format_tuple(mpl, '[',
            get_domain_tuple(mpl, chk->domain)));
      return 0;
}

void execute_check(MPL *mpl, CHECK *chk)
{     loop_within_domain(mpl, chk->domain, chk, check_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_check - clean check statement.
--
-- This routine cleans specified check statement that assumes deleting
-- all stuff dynamically allocated on generating/postsolving phase. */

void clean_check(MPL *mpl, CHECK *chk)
{     /* clean subscript domain */
      clean_domain(mpl, chk->domain);
      /* clean pseudo-code for computing predicate */
      clean_code(mpl, chk->code);
      return;
}

/*----------------------------------------------------------------------
-- execute_display - execute display statement.
--
-- This routine executes specified display statement. */

static void display_set(MPL *mpl, SET *set, MEMBER *memb)
{     /* display member of model set */
      ELEMSET *s = memb->value.set;
      MEMBER *m;
      write_text(mpl, "%s%s%s\n", set->name,
         format_tuple(mpl, '[', memb->tuple),
         s->head == NULL ? " is empty" : ":");
      for (m = s->head; m != NULL; m = m->next)
         write_text(mpl, "   %s\n", format_tuple(mpl, '(', m->tuple));
      return;
}

static void display_par(MPL *mpl, PARAMETER *par, MEMBER *memb)
{     /* display member of model parameter */
      switch (par->type)
      {  case A_NUMERIC:
         case A_INTEGER:
         case A_BINARY:
            write_text(mpl, "%s%s = %.*g\n", par->name,
               format_tuple(mpl, '[', memb->tuple),
               DBL_DIG, memb->value.num);
            break;
         case A_SYMBOLIC:
            write_text(mpl, "%s%s = %s\n", par->name,
               format_tuple(mpl, '[', memb->tuple),
               format_symbol(mpl, memb->value.sym));
            break;
         default:
            xassert(par != par);
      }
      return;
}

#if 1 /* 15/V-2010 */
static void display_var(MPL *mpl, VARIABLE *var, MEMBER *memb,
      int suff)
{     /* display member of model variable */
      if (suff == DOT_NONE || suff == DOT_VAL)
         write_text(mpl, "%s%s.val = %.*g\n", var->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.var->prim);
      else if (suff == DOT_LB)
         write_text(mpl, "%s%s.lb = %.*g\n", var->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.var->var->lbnd == NULL ? -DBL_MAX :
            memb->value.var->lbnd);
      else if (suff == DOT_UB)
         write_text(mpl, "%s%s.ub = %.*g\n", var->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.var->var->ubnd == NULL ? +DBL_MAX :
            memb->value.var->ubnd);
      else if (suff == DOT_STATUS)
         write_text(mpl, "%s%s.status = %d\n", var->name, format_tuple
            (mpl, '[', memb->tuple), memb->value.var->stat);
      else if (suff == DOT_DUAL)
         write_text(mpl, "%s%s.dual = %.*g\n", var->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.var->dual);
      else
         xassert(suff != suff);
      return;
}
#endif

#if 1 /* 15/V-2010 */
static void display_con(MPL *mpl, CONSTRAINT *con, MEMBER *memb,
      int suff)
{     /* display member of model constraint */
      if (suff == DOT_NONE || suff == DOT_VAL)
         write_text(mpl, "%s%s.val = %.*g\n", con->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.con->prim);
      else if (suff == DOT_LB)
         write_text(mpl, "%s%s.lb = %.*g\n", con->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.con->con->lbnd == NULL ? -DBL_MAX :
            memb->value.con->lbnd);
      else if (suff == DOT_UB)
         write_text(mpl, "%s%s.ub = %.*g\n", con->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.con->con->ubnd == NULL ? +DBL_MAX :
            memb->value.con->ubnd);
      else if (suff == DOT_STATUS)
         write_text(mpl, "%s%s.status = %d\n", con->name, format_tuple
            (mpl, '[', memb->tuple), memb->value.con->stat);
      else if (suff == DOT_DUAL)
         write_text(mpl, "%s%s.dual = %.*g\n", con->name,
            format_tuple(mpl, '[', memb->tuple), DBL_DIG,
            memb->value.con->dual);
      else
         xassert(suff != suff);
      return;
}
#endif

static void display_memb(MPL *mpl, CODE *code)
{     /* display member specified by pseudo-code */
      MEMBER memb;
      ARG_LIST *e;
      xassert(code->op == O_MEMNUM || code->op == O_MEMSYM
         || code->op == O_MEMSET || code->op == O_MEMVAR
         || code->op == O_MEMCON);
      memb.tuple = create_tuple(mpl);
      for (e = code->arg.par.list; e != NULL; e = e->next)
         memb.tuple = expand_tuple(mpl, memb.tuple, eval_symbolic(mpl,
            e->x));
      switch (code->op)
      {  case O_MEMNUM:
            memb.value.num = eval_member_num(mpl, code->arg.par.par,
               memb.tuple);
            display_par(mpl, code->arg.par.par, &memb);
            break;
         case O_MEMSYM:
            memb.value.sym = eval_member_sym(mpl, code->arg.par.par,
               memb.tuple);
            display_par(mpl, code->arg.par.par, &memb);
            delete_symbol(mpl, memb.value.sym);
            break;
         case O_MEMSET:
            memb.value.set = eval_member_set(mpl, code->arg.set.set,
               memb.tuple);
            display_set(mpl, code->arg.set.set, &memb);
            break;
         case O_MEMVAR:
            memb.value.var = eval_member_var(mpl, code->arg.var.var,
               memb.tuple);
            display_var
               (mpl, code->arg.var.var, &memb, code->arg.var.suff);
            break;
         case O_MEMCON:
            memb.value.con = eval_member_con(mpl, code->arg.con.con,
               memb.tuple);
            display_con
               (mpl, code->arg.con.con, &memb, code->arg.con.suff);
            break;
         default:
            xassert(code != code);
      }
      delete_tuple(mpl, memb.tuple);
      return;
}

static void display_code(MPL *mpl, CODE *code)
{     /* display value of expression */
      switch (code->type)
      {  case A_NUMERIC:
            /* numeric value */
            {  double num;
               num = eval_numeric(mpl, code);
               write_text(mpl, "%.*g\n", DBL_DIG, num);
            }
            break;
         case A_SYMBOLIC:
            /* symbolic value */
            {  SYMBOL *sym;
               sym = eval_symbolic(mpl, code);
               write_text(mpl, "%s\n", format_symbol(mpl, sym));
               delete_symbol(mpl, sym);
            }
            break;
         case A_LOGICAL:
            /* logical value */
            {  int bit;
               bit = eval_logical(mpl, code);
               write_text(mpl, "%s\n", bit ? "true" : "false");
            }
            break;
         case A_TUPLE:
            /* n-tuple */
            {  TUPLE *tuple;
               tuple = eval_tuple(mpl, code);
               write_text(mpl, "%s\n", format_tuple(mpl, '(', tuple));
               delete_tuple(mpl, tuple);
            }
            break;
         case A_ELEMSET:
            /* elemental set */
            {  ELEMSET *set;
               MEMBER *memb;
               set = eval_elemset(mpl, code);
               if (set->head == 0)
                  write_text(mpl, "set is empty\n");
               for (memb = set->head; memb != NULL; memb = memb->next)
                  write_text(mpl, "   %s\n", format_tuple(mpl, '(',
                     memb->tuple));
               delete_elemset(mpl, set);
            }
            break;
         case A_FORMULA:
            /* linear form */
            {  FORMULA *form, *term;
               form = eval_formula(mpl, code);
               if (form == NULL)
                  write_text(mpl, "linear form is empty\n");
               for (term = form; term != NULL; term = term->next)
               {  if (term->var == NULL)
                     write_text(mpl, "   %.*g\n", term->coef);
                  else
                     write_text(mpl, "   %.*g %s%s\n", DBL_DIG,
                        term->coef, term->var->var->name,
                        format_tuple(mpl, '[', term->var->memb->tuple));
               }
               delete_formula(mpl, form);
            }
            break;
         default:
            xassert(code != code);
      }
      return;
}

static int display_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      DISPLAY *dpy = (DISPLAY *)info;
      DISPLAY1 *entry;
      for (entry = dpy->list; entry != NULL; entry = entry->next)
      {  if (entry->type == A_INDEX)
         {  /* dummy index */
            DOMAIN_SLOT *slot = entry->u.slot;
            write_text(mpl, "%s = %s\n", slot->name,
            format_symbol(mpl, slot->value));
         }
         else if (entry->type == A_SET)
         {  /* model set */
            SET *set = entry->u.set;
            MEMBER *memb;
            if (set->assign != NULL)
            {  /* the set has assignment expression; evaluate all its
                  members over entire domain */
               eval_whole_set(mpl, set);
            }
            else
            {  /* the set has no assignment expression; refer to its
                  any existing member ignoring resultant value to check
                  the data provided the data section */
#if 1 /* 12/XII-2008 */
               if (set->gadget != NULL && set->data == 0)
               {  /* initialize the set with data from a plain set */
                  saturate_set(mpl, set);
               }
#endif
               if (set->array->head != NULL)
                  eval_member_set(mpl, set, set->array->head->tuple);
            }
            /* display all members of the set array */
            if (set->array->head == NULL)
               write_text(mpl, "%s has empty content\n", set->name);
            for (memb = set->array->head; memb != NULL; memb =
               memb->next) display_set(mpl, set, memb);
         }
         else if (entry->type == A_PARAMETER)
         {  /* model parameter */
            PARAMETER *par = entry->u.par;
            MEMBER *memb;
            if (par->assign != NULL)
            {  /* the parameter has an assignment expression; evaluate
                  all its member over entire domain */
               eval_whole_par(mpl, par);
            }
            else
            {  /* the parameter has no assignment expression; refer to
                  its any existing member ignoring resultant value to
                  check the data provided in the data section */
               if (par->array->head != NULL)
               {  if (par->type != A_SYMBOLIC)
                     eval_member_num(mpl, par, par->array->head->tuple);
                  else
                     delete_symbol(mpl, eval_member_sym(mpl, par,
                        par->array->head->tuple));
               }
            }
            /* display all members of the parameter array */
            if (par->array->head == NULL)
               write_text(mpl, "%s has empty content\n", par->name);
            for (memb = par->array->head; memb != NULL; memb =
               memb->next) display_par(mpl, par, memb);
         }
         else if (entry->type == A_VARIABLE)
         {  /* model variable */
            VARIABLE *var = entry->u.var;
            MEMBER *memb;
            xassert(mpl->flag_p);
            /* display all members of the variable array */
            if (var->array->head == NULL)
               write_text(mpl, "%s has empty content\n", var->name);
            for (memb = var->array->head; memb != NULL; memb =
               memb->next) display_var(mpl, var, memb, DOT_NONE);
         }
         else if (entry->type == A_CONSTRAINT)
         {  /* model constraint */
            CONSTRAINT *con = entry->u.con;
            MEMBER *memb;
            xassert(mpl->flag_p);
            /* display all members of the constraint array */
            if (con->array->head == NULL)
               write_text(mpl, "%s has empty content\n", con->name);
            for (memb = con->array->head; memb != NULL; memb =
               memb->next) display_con(mpl, con, memb, DOT_NONE);
         }
         else if (entry->type == A_EXPRESSION)
         {  /* expression */
            CODE *code = entry->u.code;
            if (code->op == O_MEMNUM || code->op == O_MEMSYM ||
                code->op == O_MEMSET || code->op == O_MEMVAR ||
                code->op == O_MEMCON)
               display_memb(mpl, code);
            else
               display_code(mpl, code);
         }
         else
            xassert(entry != entry);
      }
      return 0;
}

void execute_display(MPL *mpl, DISPLAY *dpy)
{     loop_within_domain(mpl, dpy->domain, dpy, display_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_display - clean display statement.
--
-- This routine cleans specified display statement that assumes deleting
-- all stuff dynamically allocated on generating/postsolving phase. */

void clean_display(MPL *mpl, DISPLAY *dpy)
{     DISPLAY1 *d;
#if 0 /* 15/V-2010 */
      ARG_LIST *e;
#endif
      /* clean subscript domain */
      clean_domain(mpl, dpy->domain);
      /* clean display list */
      for (d = dpy->list; d != NULL; d = d->next)
      {  /* clean pseudo-code for computing expression */
         if (d->type == A_EXPRESSION)
            clean_code(mpl, d->u.code);
#if 0 /* 15/V-2010 */
         /* clean pseudo-code for computing subscripts */
         for (e = d->list; e != NULL; e = e->next)
            clean_code(mpl, e->x);
#endif
      }
      return;
}

/*----------------------------------------------------------------------
-- execute_printf - execute printf statement.
--
-- This routine executes specified printf statement. */

#if 1 /* 14/VII-2006 */
static void print_char(MPL *mpl, int c)
{     if (mpl->prt_fp == NULL)
         write_char(mpl, c);
      else
#if 0 /* 04/VIII-2013 */
         xfputc(c, mpl->prt_fp);
#else
      {  unsigned char buf[1];
         buf[0] = (unsigned char)c;
         glp_write(mpl->prt_fp, buf, 1);
      }
#endif
      return;
}

static void print_text(MPL *mpl, char *fmt, ...)
{     va_list arg;
      char buf[OUTBUF_SIZE], *c;
      va_start(arg, fmt);
      vsprintf(buf, fmt, arg);
      xassert(strlen(buf) < sizeof(buf));
      va_end(arg);
      for (c = buf; *c != '\0'; c++) print_char(mpl, *c);
      return;
}
#endif

static int printf_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      PRINTF *prt = (PRINTF *)info;
      PRINTF1 *entry;
      SYMBOL *sym;
      char fmt[MAX_LENGTH+1], *c, *from, save;
      /* evaluate format control string */
      sym = eval_symbolic(mpl, prt->fmt);
      if (sym->str == NULL)
         sprintf(fmt, "%.*g", DBL_DIG, sym->num);
      else
         fetch_string(mpl, sym->str, fmt);
      delete_symbol(mpl, sym);
      /* scan format control string and perform formatting output */
      entry = prt->list;
      for (c = fmt; *c != '\0'; c++)
      {  if (*c == '%')
         {  /* scan format specifier */
            from = c++;
            if (*c == '%')
            {  print_char(mpl, '%');
               continue;
            }
            if (entry == NULL) break;
            /* scan optional flags */
            while (*c == '-' || *c == '+' || *c == ' ' || *c == '#' ||
                   *c == '0') c++;
            /* scan optional minimum field width */
            while (isdigit((unsigned char)*c)) c++;
            /* scan optional precision */
            if (*c == '.')
            {  c++;
               while (isdigit((unsigned char)*c)) c++;
            }
            /* scan conversion specifier and perform formatting */
            save = *(c+1), *(c+1) = '\0';
            if (*c == 'd' || *c == 'i' || *c == 'e' || *c == 'E' ||
                *c == 'f' || *c == 'F' || *c == 'g' || *c == 'G')
            {  /* the specifier requires numeric value */
               double value;
               xassert(entry != NULL);
               switch (entry->code->type)
               {  case A_NUMERIC:
                     value = eval_numeric(mpl, entry->code);
                     break;
                  case A_SYMBOLIC:
                     sym = eval_symbolic(mpl, entry->code);
                     if (sym->str != NULL)
                        error(mpl, "cannot convert %s to floating-point"
                           " number", format_symbol(mpl, sym));
                     value = sym->num;
                     delete_symbol(mpl, sym);
                     break;
                  case A_LOGICAL:
                     if (eval_logical(mpl, entry->code))
                        value = 1.0;
                     else
                        value = 0.0;
                     break;
                  default:
                     xassert(entry != entry);
               }
               if (*c == 'd' || *c == 'i')
               {  double int_max = (double)INT_MAX;
                  if (!(-int_max <= value && value <= +int_max))
                     error(mpl, "cannot convert %.*g to integer",
                        DBL_DIG, value);
                  print_text(mpl, from, (int)floor(value + 0.5));
               }
               else
                  print_text(mpl, from, value);
            }
            else if (*c == 's')
            {  /* the specifier requires symbolic value */
               char value[MAX_LENGTH+1];
               switch (entry->code->type)
               {  case A_NUMERIC:
                     sprintf(value, "%.*g", DBL_DIG, eval_numeric(mpl,
                        entry->code));
                     break;
                  case A_LOGICAL:
                     if (eval_logical(mpl, entry->code))
                        strcpy(value, "T");
                     else
                        strcpy(value, "F");
                     break;
                  case A_SYMBOLIC:
                     sym = eval_symbolic(mpl, entry->code);
                     if (sym->str == NULL)
                        sprintf(value, "%.*g", DBL_DIG, sym->num);
                     else
                        fetch_string(mpl, sym->str, value);
                     delete_symbol(mpl, sym);
                     break;
                  default:
                     xassert(entry != entry);
               }
               print_text(mpl, from, value);
            }
            else
               error(mpl, "format specifier missing or invalid");
            *(c+1) = save;
            entry = entry->next;
         }
         else if (*c == '\\')
         {  /* write some control character */
            c++;
            if (*c == 't')
               print_char(mpl, '\t');
            else if (*c == 'n')
               print_char(mpl, '\n');
#if 1 /* 28/X-2010 */
            else if (*c == '\0')
            {  /* format string ends with backslash */
               error(mpl, "invalid use of escape character \\ in format"
                  " control string");
            }
#endif
            else
               print_char(mpl, *c);
         }
         else
         {  /* write character without formatting */
            print_char(mpl, *c);
         }
      }
      return 0;
}

#if 0 /* 14/VII-2006 */
void execute_printf(MPL *mpl, PRINTF *prt)
{     loop_within_domain(mpl, prt->domain, prt, printf_func);
      return;
}
#else
void execute_printf(MPL *mpl, PRINTF *prt)
{     if (prt->fname == NULL)
      {  /* switch to the standard output */
         if (mpl->prt_fp != NULL)
         {  glp_close(mpl->prt_fp), mpl->prt_fp = NULL;
            xfree(mpl->prt_file), mpl->prt_file = NULL;
         }
      }
      else
      {  /* evaluate file name string */
         SYMBOL *sym;
         char fname[MAX_LENGTH+1];
         sym = eval_symbolic(mpl, prt->fname);
         if (sym->str == NULL)
            sprintf(fname, "%.*g", DBL_DIG, sym->num);
         else
            fetch_string(mpl, sym->str, fname);
         delete_symbol(mpl, sym);
         /* close the current print file, if necessary */
         if (mpl->prt_fp != NULL &&
            (!prt->app || strcmp(mpl->prt_file, fname) != 0))
         {  glp_close(mpl->prt_fp), mpl->prt_fp = NULL;
            xfree(mpl->prt_file), mpl->prt_file = NULL;
         }
         /* open the specified print file, if necessary */
         if (mpl->prt_fp == NULL)
         {  mpl->prt_fp = glp_open(fname, prt->app ? "a" : "w");
            if (mpl->prt_fp == NULL)
               error(mpl, "unable to open '%s' for writing - %s",
                  fname, get_err_msg());
            mpl->prt_file = xmalloc(strlen(fname)+1);
            strcpy(mpl->prt_file, fname);
         }
      }
      loop_within_domain(mpl, prt->domain, prt, printf_func);
      if (mpl->prt_fp != NULL)
      {
#if 0 /* FIXME */
         xfflush(mpl->prt_fp);
#endif
         if (glp_ioerr(mpl->prt_fp))
            error(mpl, "writing error to '%s' - %s", mpl->prt_file,
               get_err_msg());
      }
      return;
}
#endif

/*----------------------------------------------------------------------
-- clean_printf - clean printf statement.
--
-- This routine cleans specified printf statement that assumes deleting
-- all stuff dynamically allocated on generating/postsolving phase. */

void clean_printf(MPL *mpl, PRINTF *prt)
{     PRINTF1 *p;
      /* clean subscript domain */
      clean_domain(mpl, prt->domain);
      /* clean pseudo-code for computing format string */
      clean_code(mpl, prt->fmt);
      /* clean printf list */
      for (p = prt->list; p != NULL; p = p->next)
      {  /* clean pseudo-code for computing value to be printed */
         clean_code(mpl, p->code);
      }
#if 1 /* 14/VII-2006 */
      /* clean pseudo-code for computing file name string */
      clean_code(mpl, prt->fname);
#endif
      return;
}

/*----------------------------------------------------------------------
-- execute_for - execute for statement.
--
-- This routine executes specified for statement. */

static int for_func(MPL *mpl, void *info)
{     /* this is auxiliary routine to work within domain scope */
      FOR *fur = (FOR *)info;
      STATEMENT *stmt, *save;
      save = mpl->stmt;
      for (stmt = fur->list; stmt != NULL; stmt = stmt->next)
         execute_statement(mpl, stmt);
      mpl->stmt = save;
      return 0;
}

void execute_for(MPL *mpl, FOR *fur)
{     loop_within_domain(mpl, fur->domain, fur, for_func);
      return;
}

/*----------------------------------------------------------------------
-- clean_for - clean for statement.
--
-- This routine cleans specified for statement that assumes deleting all
-- stuff dynamically allocated on generating/postsolving phase. */

void clean_for(MPL *mpl, FOR *fur)
{     STATEMENT *stmt;
      /* clean subscript domain */
      clean_domain(mpl, fur->domain);
      /* clean all sub-statements */
      for (stmt = fur->list; stmt != NULL; stmt = stmt->next)
         clean_statement(mpl, stmt);
      return;
}

/*----------------------------------------------------------------------
-- execute_statement - execute specified model statement.
--
-- This routine executes specified model statement. */

void execute_statement(MPL *mpl, STATEMENT *stmt)
{     mpl->stmt = stmt;
      switch (stmt->type)
      {  case A_SET:
         case A_PARAMETER:
         case A_VARIABLE:
            break;
         case A_CONSTRAINT:
            xprintf("Generating %s...\n", stmt->u.con->name);
            eval_whole_con(mpl, stmt->u.con);
            break;
         case A_TABLE:
            switch (stmt->u.tab->type)
            {  case A_INPUT:
                  xprintf("Reading %s...\n", stmt->u.tab->name);
                  break;
               case A_OUTPUT:
                  xprintf("Writing %s...\n", stmt->u.tab->name);
                  break;
               default:
                  xassert(stmt != stmt);
            }
            execute_table(mpl, stmt->u.tab);
            break;
         case A_SOLVE:
            break;
         case A_CHECK:
            xprintf("Checking (line %d)...\n", stmt->line);
            execute_check(mpl, stmt->u.chk);
            break;
         case A_DISPLAY:
            write_text(mpl, "Display statement at line %d\n",
               stmt->line);
            execute_display(mpl, stmt->u.dpy);
            break;
         case A_PRINTF:
            execute_printf(mpl, stmt->u.prt);
            break;
         case A_FOR:
            execute_for(mpl, stmt->u.fur);
            break;
         default:
            xassert(stmt != stmt);
      }
      return;
}

/*----------------------------------------------------------------------
-- clean_statement - clean specified model statement.
--
-- This routine cleans specified model statement that assumes deleting
-- all stuff dynamically allocated on generating/postsolving phase. */

void clean_statement(MPL *mpl, STATEMENT *stmt)
{     switch(stmt->type)
      {  case A_SET:
            clean_set(mpl, stmt->u.set); break;
         case A_PARAMETER:
            clean_parameter(mpl, stmt->u.par); break;
         case A_VARIABLE:
            clean_variable(mpl, stmt->u.var); break;
         case A_CONSTRAINT:
            clean_constraint(mpl, stmt->u.con); break;
#if 1 /* 11/II-2008 */
         case A_TABLE:
            clean_table(mpl, stmt->u.tab); break;
#endif
         case A_SOLVE:
            break;
         case A_CHECK:
            clean_check(mpl, stmt->u.chk); break;
         case A_DISPLAY:
            clean_display(mpl, stmt->u.dpy); break;
         case A_PRINTF:
            clean_printf(mpl, stmt->u.prt); break;
         case A_FOR:
            clean_for(mpl, stmt->u.fur); break;
         default:
            xassert(stmt != stmt);
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl4.c0000644000175100001710000013373400000000000023727 0ustar00runnerdocker00000000000000/* mpl4.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"

#define xfault xerror
#define xfprintf glp_format
#define dmp_create_poolx(size) dmp_create_pool()

/**********************************************************************/
/* * *              GENERATING AND POSTSOLVING MODEL              * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- alloc_content - allocate content arrays for all model objects.
--
-- This routine allocates content arrays for all existing model objects
-- and thereby finalizes creating model.
--
-- This routine must be called immediately after reading model section,
-- i.e. before reading data section or generating model. */

void alloc_content(MPL *mpl)
{     STATEMENT *stmt;
      /* walk through all model statements */
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  switch (stmt->type)
         {  case A_SET:
               /* model set */
               xassert(stmt->u.set->array == NULL);
               stmt->u.set->array = create_array(mpl, A_ELEMSET,
                  stmt->u.set->dim);
               break;
            case A_PARAMETER:
               /* model parameter */
               xassert(stmt->u.par->array == NULL);
               switch (stmt->u.par->type)
               {  case A_NUMERIC:
                  case A_INTEGER:
                  case A_BINARY:
                     stmt->u.par->array = create_array(mpl, A_NUMERIC,
                        stmt->u.par->dim);
                     break;
                  case A_SYMBOLIC:
                     stmt->u.par->array = create_array(mpl, A_SYMBOLIC,
                        stmt->u.par->dim);
                     break;
                  default:
                     xassert(stmt != stmt);
               }
               break;
            case A_VARIABLE:
               /* model variable */
               xassert(stmt->u.var->array == NULL);
               stmt->u.var->array = create_array(mpl, A_ELEMVAR,
                  stmt->u.var->dim);
               break;
            case A_CONSTRAINT:
               /* model constraint/objective */
               xassert(stmt->u.con->array == NULL);
               stmt->u.con->array = create_array(mpl, A_ELEMCON,
                  stmt->u.con->dim);
               break;
#if 1 /* 11/II-2008 */
            case A_TABLE:
#endif
            case A_SOLVE:
            case A_CHECK:
            case A_DISPLAY:
            case A_PRINTF:
            case A_FOR:
               /* functional statements have no content array */
               break;
            default:
               xassert(stmt != stmt);
         }
      }
      return;
}

/*----------------------------------------------------------------------
-- generate_model - generate model.
--
-- This routine executes the model statements which precede the solve
-- statement. */

void generate_model(MPL *mpl)
{     STATEMENT *stmt;
      xassert(!mpl->flag_p);
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  execute_statement(mpl, stmt);
         if (mpl->stmt->type == A_SOLVE) break;
      }
      mpl->stmt = stmt;
      return;
}

/*----------------------------------------------------------------------
-- build_problem - build problem instance.
--
-- This routine builds lists of rows and columns for problem instance,
-- which corresponds to the generated model. */

void build_problem(MPL *mpl)
{     STATEMENT *stmt;
      MEMBER *memb;
      VARIABLE *v;
      CONSTRAINT *c;
      FORMULA *t;
      int i, j;
      xassert(mpl->m == 0);
      xassert(mpl->n == 0);
      xassert(mpl->row == NULL);
      xassert(mpl->col == NULL);
      /* check that all elemental variables has zero column numbers */
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  if (stmt->type == A_VARIABLE)
         {  v = stmt->u.var;
            for (memb = v->array->head; memb != NULL; memb = memb->next)
               xassert(memb->value.var->j == 0);
         }
      }
      /* assign row numbers to elemental constraints and objectives */
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  if (stmt->type == A_CONSTRAINT)
         {  c = stmt->u.con;
            for (memb = c->array->head; memb != NULL; memb = memb->next)
            {  xassert(memb->value.con->i == 0);
               memb->value.con->i = ++mpl->m;
               /* walk through linear form and mark elemental variables,
                  which are referenced at least once */
               for (t = memb->value.con->form; t != NULL; t = t->next)
               {  xassert(t->var != NULL);
                  t->var->memb->value.var->j = -1;
               }
            }
         }
      }
      /* assign column numbers to marked elemental variables */
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  if (stmt->type == A_VARIABLE)
         {  v = stmt->u.var;
            for (memb = v->array->head; memb != NULL; memb = memb->next)
               if (memb->value.var->j != 0) memb->value.var->j =
                  ++mpl->n;
         }
      }
      /* build list of rows */
      mpl->row = xcalloc(1+mpl->m, sizeof(ELEMCON *));
      for (i = 1; i <= mpl->m; i++) mpl->row[i] = NULL;
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  if (stmt->type == A_CONSTRAINT)
         {  c = stmt->u.con;
            for (memb = c->array->head; memb != NULL; memb = memb->next)
            {  i = memb->value.con->i;
               xassert(1 <= i && i <= mpl->m);
               xassert(mpl->row[i] == NULL);
               mpl->row[i] = memb->value.con;
            }
         }
      }
      for (i = 1; i <= mpl->m; i++) xassert(mpl->row[i] != NULL);
      /* build list of columns */
      mpl->col = xcalloc(1+mpl->n, sizeof(ELEMVAR *));
      for (j = 1; j <= mpl->n; j++) mpl->col[j] = NULL;
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
      {  if (stmt->type == A_VARIABLE)
         {  v = stmt->u.var;
            for (memb = v->array->head; memb != NULL; memb = memb->next)
            {  j = memb->value.var->j;
               if (j == 0) continue;
               xassert(1 <= j && j <= mpl->n);
               xassert(mpl->col[j] == NULL);
               mpl->col[j] = memb->value.var;
            }
         }
      }
      for (j = 1; j <= mpl->n; j++) xassert(mpl->col[j] != NULL);
      return;
}

/*----------------------------------------------------------------------
-- postsolve_model - postsolve model.
--
-- This routine executes the model statements which follow the solve
-- statement. */

void postsolve_model(MPL *mpl)
{     STATEMENT *stmt;
      xassert(!mpl->flag_p);
      mpl->flag_p = 1;
      for (stmt = mpl->stmt; stmt != NULL; stmt = stmt->next)
         execute_statement(mpl, stmt);
      mpl->stmt = NULL;
      return;
}

/*----------------------------------------------------------------------
-- clean_model - clean model content.
--
-- This routine cleans the model content that assumes deleting all stuff
-- dynamically allocated on generating/postsolving phase.
--
-- Actually cleaning model content is not needed. This function is used
-- mainly to be sure that there were no logical errors on using dynamic
-- memory pools during the generation phase.
--
-- NOTE: This routine must not be called if any errors were detected on
--       the generation phase. */

void clean_model(MPL *mpl)
{     STATEMENT *stmt;
      for (stmt = mpl->model; stmt != NULL; stmt = stmt->next)
         clean_statement(mpl, stmt);
      /* check that all atoms have been returned to their pools */
      if (dmp_in_use(mpl->strings) != 0)
         error(mpl, "internal logic error: %d string segment(s) were lo"
            "st", dmp_in_use(mpl->strings));
      if (dmp_in_use(mpl->symbols) != 0)
         error(mpl, "internal logic error: %d symbol(s) were lost",
            dmp_in_use(mpl->symbols));
      if (dmp_in_use(mpl->tuples) != 0)
         error(mpl, "internal logic error: %d n-tuple component(s) were"
            " lost", dmp_in_use(mpl->tuples));
      if (dmp_in_use(mpl->arrays) != 0)
         error(mpl, "internal logic error: %d array(s) were lost",
            dmp_in_use(mpl->arrays));
      if (dmp_in_use(mpl->members) != 0)
         error(mpl, "internal logic error: %d array member(s) were lost"
            , dmp_in_use(mpl->members));
      if (dmp_in_use(mpl->elemvars) != 0)
         error(mpl, "internal logic error: %d elemental variable(s) wer"
            "e lost", dmp_in_use(mpl->elemvars));
      if (dmp_in_use(mpl->formulae) != 0)
         error(mpl, "internal logic error: %d linear term(s) were lost",
            dmp_in_use(mpl->formulae));
      if (dmp_in_use(mpl->elemcons) != 0)
         error(mpl, "internal logic error: %d elemental constraint(s) w"
            "ere lost", dmp_in_use(mpl->elemcons));
      return;
}

/**********************************************************************/
/* * *                        INPUT/OUTPUT                        * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- open_input - open input text file.
--
-- This routine opens the input text file for scanning. */

void open_input(MPL *mpl, char *file)
{     mpl->line = 0;
      mpl->c = '\n';
      mpl->token = 0;
      mpl->imlen = 0;
      mpl->image[0] = '\0';
      mpl->value = 0.0;
      mpl->b_token = T_EOF;
      mpl->b_imlen = 0;
      mpl->b_image[0] = '\0';
      mpl->b_value = 0.0;
      mpl->f_dots = 0;
      mpl->f_scan = 0;
      mpl->f_token = 0;
      mpl->f_imlen = 0;
      mpl->f_image[0] = '\0';
      mpl->f_value = 0.0;
      memset(mpl->context, ' ', CONTEXT_SIZE);
      mpl->c_ptr = 0;
      xassert(mpl->in_fp == NULL);
      mpl->in_fp = glp_open(file, "r");
      if (mpl->in_fp == NULL)
         error(mpl, "unable to open %s - %s", file, get_err_msg());
      mpl->in_file = file;
      /* scan the very first character */
      get_char(mpl);
      /* scan the very first token */
      get_token(mpl);
      return;
}

/*----------------------------------------------------------------------
-- read_char - read next character from input text file.
--
-- This routine returns a next ASCII character read from the input text
-- file. If the end of file has been reached, EOF is returned. */

int read_char(MPL *mpl)
{     int c;
      xassert(mpl->in_fp != NULL);
      c = glp_getc(mpl->in_fp);
      if (c < 0)
      {  if (glp_ioerr(mpl->in_fp))
            error(mpl, "read error on %s - %s", mpl->in_file,
               get_err_msg());
         c = EOF;
      }
      return c;
}

/*----------------------------------------------------------------------
-- close_input - close input text file.
--
-- This routine closes the input text file. */

void close_input(MPL *mpl)
{     xassert(mpl->in_fp != NULL);
      glp_close(mpl->in_fp);
      mpl->in_fp = NULL;
      mpl->in_file = NULL;
      return;
}

/*----------------------------------------------------------------------
-- open_output - open output text file.
--
-- This routine opens the output text file for writing data produced by
-- display and printf statements. */

void open_output(MPL *mpl, char *file)
{     xassert(mpl->out_fp == NULL);
      if (file == NULL)
      {  file = "";
         mpl->out_fp = (void *)stdout;
      }
      else
      {  mpl->out_fp = glp_open(file, "w");
         if (mpl->out_fp == NULL)
            error(mpl, "unable to create %s - %s", file, get_err_msg());
      }
      mpl->out_file = xmalloc(strlen(file)+1);
      strcpy(mpl->out_file, file);
      return;
}

/*----------------------------------------------------------------------
-- write_char - write next character to output text file.
--
-- This routine writes an ASCII character to the output text file. */

void write_char(MPL *mpl, int c)
{     xassert(mpl->out_fp != NULL);
      if (mpl->out_fp == (void *)stdout)
         xprintf("%c", c);
      else
         xfprintf(mpl->out_fp, "%c", c);
      return;
}

/*----------------------------------------------------------------------
-- write_text - format and write text to output text file.
--
-- This routine formats a text using the format control string and then
-- writes this text to the output text file. */

void write_text(MPL *mpl, char *fmt, ...)
{     va_list arg;
      char buf[OUTBUF_SIZE], *c;
      va_start(arg, fmt);
      vsprintf(buf, fmt, arg);
      xassert(strlen(buf) < sizeof(buf));
      va_end(arg);
      for (c = buf; *c != '\0'; c++) write_char(mpl, *c);
      return;
}

/*----------------------------------------------------------------------
-- flush_output - finalize writing data to output text file.
--
-- This routine finalizes writing data to the output text file. */

void flush_output(MPL *mpl)
{     xassert(mpl->out_fp != NULL);
      if (mpl->out_fp != (void *)stdout)
      {
#if 0 /* FIXME */
         xfflush(mpl->out_fp);
#endif
         if (glp_ioerr(mpl->out_fp))
            error(mpl, "write error on %s - %s", mpl->out_file,
               get_err_msg());
      }
      return;
}

/**********************************************************************/
/* * *                      SOLVER INTERFACE                      * * */
/**********************************************************************/

/*----------------------------------------------------------------------
-- error - print error message and terminate model processing.
--
-- This routine formats and prints an error message and then terminates
-- model processing. */

void error(MPL *mpl, char *fmt, ...)
{     va_list arg;
      char msg[4095+1];
      va_start(arg, fmt);
      vsprintf(msg, fmt, arg);
      xassert(strlen(msg) < sizeof(msg));
      va_end(arg);
      switch (mpl->phase)
      {  case 1:
         case 2:
            /* translation phase */
            xprintf("%s:%d: %s\n",
               mpl->in_file == NULL ? "(unknown)" : mpl->in_file,
               mpl->line, msg);
            print_context(mpl);
            break;
         case 3:
            /* generation/postsolve phase */
            xprintf("%s:%d: %s\n",
               mpl->mod_file == NULL ? "(unknown)" : mpl->mod_file,
               mpl->stmt == NULL ? 0 : mpl->stmt->line, msg);
            break;
         default:
            xassert(mpl != mpl);
      }
      mpl->phase = 4;
      longjmp(mpl->jump, 1);
      /* no return */
}

/*----------------------------------------------------------------------
-- warning - print warning message and continue model processing.
--
-- This routine formats and prints a warning message and returns to the
-- calling program. */

void warning(MPL *mpl, char *fmt, ...)
{     va_list arg;
      char msg[4095+1];
      va_start(arg, fmt);
      vsprintf(msg, fmt, arg);
      xassert(strlen(msg) < sizeof(msg));
      va_end(arg);
      switch (mpl->phase)
      {  case 1:
         case 2:
            /* translation phase */
            xprintf("%s:%d: warning: %s\n",
               mpl->in_file == NULL ? "(unknown)" : mpl->in_file,
               mpl->line, msg);
            break;
         case 3:
            /* generation/postsolve phase */
            xprintf("%s:%d: warning: %s\n",
               mpl->mod_file == NULL ? "(unknown)" : mpl->mod_file,
               mpl->stmt == NULL ? 0 : mpl->stmt->line, msg);
            break;
         default:
            xassert(mpl != mpl);
      }
      return;
}

/*----------------------------------------------------------------------
-- mpl_initialize - create and initialize translator database.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- MPL *mpl_initialize(void);
--
-- *Description*
--
-- The routine mpl_initialize creates and initializes the database used
-- by the GNU MathProg translator.
--
-- *Returns*
--
-- The routine returns a pointer to the database created. */

MPL *mpl_initialize(void)
{     MPL *mpl;
      mpl = xmalloc(sizeof(MPL));
      /* scanning segment */
      mpl->line = 0;
      mpl->c = 0;
      mpl->token = 0;
      mpl->imlen = 0;
      mpl->image = xcalloc(MAX_LENGTH+1, sizeof(char));
      mpl->image[0] = '\0';
      mpl->value = 0.0;
      mpl->b_token = 0;
      mpl->b_imlen = 0;
      mpl->b_image = xcalloc(MAX_LENGTH+1, sizeof(char));
      mpl->b_image[0] = '\0';
      mpl->b_value = 0.0;
      mpl->f_dots = 0;
      mpl->f_scan = 0;
      mpl->f_token = 0;
      mpl->f_imlen = 0;
      mpl->f_image = xcalloc(MAX_LENGTH+1, sizeof(char));
      mpl->f_image[0] = '\0';
      mpl->f_value = 0.0;
      mpl->context = xcalloc(CONTEXT_SIZE, sizeof(char));
      memset(mpl->context, ' ', CONTEXT_SIZE);
      mpl->c_ptr = 0;
      mpl->flag_d = 0;
      /* translating segment */
      mpl->pool = dmp_create_poolx(0);
      mpl->tree = avl_create_tree(avl_strcmp, NULL);
      mpl->model = NULL;
      mpl->flag_x = 0;
      mpl->as_within = 0;
      mpl->as_in = 0;
      mpl->as_binary = 0;
      mpl->flag_s = 0;
      /* common segment */
      mpl->strings = dmp_create_poolx(sizeof(STRING));
      mpl->symbols = dmp_create_poolx(sizeof(SYMBOL));
      mpl->tuples = dmp_create_poolx(sizeof(TUPLE));
      mpl->arrays = dmp_create_poolx(sizeof(ARRAY));
      mpl->members = dmp_create_poolx(sizeof(MEMBER));
      mpl->elemvars = dmp_create_poolx(sizeof(ELEMVAR));
      mpl->formulae = dmp_create_poolx(sizeof(FORMULA));
      mpl->elemcons = dmp_create_poolx(sizeof(ELEMCON));
      mpl->a_list = NULL;
      mpl->sym_buf = xcalloc(255+1, sizeof(char));
      mpl->sym_buf[0] = '\0';
      mpl->tup_buf = xcalloc(255+1, sizeof(char));
      mpl->tup_buf[0] = '\0';
      /* generating/postsolving segment */
      mpl->rand = rng_create_rand();
      mpl->flag_p = 0;
      mpl->stmt = NULL;
#if 1 /* 11/II-2008 */
      mpl->dca = NULL;
#endif
      mpl->m = 0;
      mpl->n = 0;
      mpl->row = NULL;
      mpl->col = NULL;
      /* input/output segment */
      mpl->in_fp = NULL;
      mpl->in_file = NULL;
      mpl->out_fp = NULL;
      mpl->out_file = NULL;
      mpl->prt_fp = NULL;
      mpl->prt_file = NULL;
      /* solver interface segment */
      if (setjmp(mpl->jump)) xassert(mpl != mpl);
      mpl->phase = 0;
      mpl->mod_file = NULL;
      mpl->mpl_buf = xcalloc(255+1, sizeof(char));
      mpl->mpl_buf[0] = '\0';
      return mpl;
}

/*----------------------------------------------------------------------
-- mpl_read_model - read model section and optional data section.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_read_model(MPL *mpl, char *file, int skip_data);
--
-- *Description*
--
-- The routine mpl_read_model reads model section and optionally data
-- section, which may follow the model section, from the text file,
-- whose name is the character string file, performs translating model
-- statements and data blocks, and stores all the information in the
-- translator database.
--
-- The parameter skip_data is a flag. If the input file contains the
-- data section and this flag is set, the data section is not read as
-- if there were no data section and a warning message is issued. This
-- allows reading the data section from another input file.
--
-- This routine should be called once after the routine mpl_initialize
-- and before other API routines.
--
-- *Returns*
--
-- The routine mpl_read_model returns one the following codes:
--
-- 1 - translation successful. The input text file contains only model
--     section. In this case the calling program may call the routine
--     mpl_read_data to read data section from another file.
-- 2 - translation successful. The input text file contains both model
--     and data section.
-- 4 - processing failed due to some errors. In this case the calling
--     program should call the routine mpl_terminate to terminate model
--     processing. */

int mpl_read_model(MPL *mpl, char *file, int skip_data)
{     if (mpl->phase != 0)
         xfault("mpl_read_model: invalid call sequence\n");
      if (file == NULL)
         xfault("mpl_read_model: no input filename specified\n");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* translate model section */
      mpl->phase = 1;
      xprintf("Reading model section from %s...\n", file);
      open_input(mpl, file);
      model_section(mpl);
      if (mpl->model == NULL)
         error(mpl, "empty model section not allowed");
      /* save name of the input text file containing model section for
         error diagnostics during the generation phase */
      mpl->mod_file = xcalloc(strlen(file)+1, sizeof(char));
      strcpy(mpl->mod_file, mpl->in_file);
      /* allocate content arrays for all model objects */
      alloc_content(mpl);
      /* optional data section may begin with the keyword 'data' */
      if (is_keyword(mpl, "data"))
      {  if (skip_data)
         {  warning(mpl, "data section ignored");
            goto skip;
         }
         mpl->flag_d = 1;
         get_token(mpl /* data */);
         if (mpl->token != T_SEMICOLON)
            error(mpl, "semicolon missing where expected");
         get_token(mpl /* ; */);
         /* translate data section */
         mpl->phase = 2;
         xprintf("Reading data section from %s...\n", file);
         data_section(mpl);
      }
      /* process end statement */
      end_statement(mpl);
skip: xprintf("%d line%s were read\n",
         mpl->line, mpl->line == 1 ? "" : "s");
      close_input(mpl);
done: /* return to the calling program */
      return mpl->phase;
}

/*----------------------------------------------------------------------
-- mpl_read_data - read data section.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_read_data(MPL *mpl, char *file);
--
-- *Description*
--
-- The routine mpl_read_data reads data section from the text file,
-- whose name is the character string file, performs translating data
-- blocks, and stores the data read in the translator database.
--
-- If this routine is used, it should be called once after the routine
-- mpl_read_model and if the latter returned the code 1.
--
-- *Returns*
--
-- The routine mpl_read_data returns one of the following codes:
--
-- 2 - data section has been successfully processed.
-- 4 - processing failed due to some errors. In this case the calling
--     program should call the routine mpl_terminate to terminate model
--     processing. */

int mpl_read_data(MPL *mpl, char *file)
#if 0 /* 02/X-2008 */
{     if (mpl->phase != 1)
#else
{     if (!(mpl->phase == 1 || mpl->phase == 2))
#endif
         xfault("mpl_read_data: invalid call sequence\n");
      if (file == NULL)
         xfault("mpl_read_data: no input filename specified\n");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* process data section */
      mpl->phase = 2;
      xprintf("Reading data section from %s...\n", file);
      mpl->flag_d = 1;
      open_input(mpl, file);
      /* in this case the keyword 'data' is optional */
      if (is_literal(mpl, "data"))
      {  get_token(mpl /* data */);
         if (mpl->token != T_SEMICOLON)
            error(mpl, "semicolon missing where expected");
         get_token(mpl /* ; */);
      }
      data_section(mpl);
      /* process end statement */
      end_statement(mpl);
      xprintf("%d line%s were read\n",
         mpl->line, mpl->line == 1 ? "" : "s");
      close_input(mpl);
done: /* return to the calling program */
      return mpl->phase;
}

/*----------------------------------------------------------------------
-- mpl_generate - generate model.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_generate(MPL *mpl, char *file);
--
-- *Description*
--
-- The routine mpl_generate generates the model using its description
-- stored in the translator database. This phase means generating all
-- variables, constraints, and objectives, executing check and display
-- statements, which precede the solve statement (if it is presented),
-- and building the problem instance.
--
-- The character string file specifies the name of output text file, to
-- which output produced by display statements should be written. It is
-- allowed to specify NULL, in which case the output goes to stdout via
-- the routine print.
--
-- This routine should be called once after the routine mpl_read_model
-- or mpl_read_data and if one of the latters returned the code 2.
--
-- *Returns*
--
-- The routine mpl_generate returns one of the following codes:
--
-- 3 - model has been successfully generated. In this case the calling
--     program may call other api routines to obtain components of the
--     problem instance from the translator database.
-- 4 - processing failed due to some errors. In this case the calling
--     program should call the routine mpl_terminate to terminate model
--     processing. */

int mpl_generate(MPL *mpl, char *file)
{     if (!(mpl->phase == 1 || mpl->phase == 2))
         xfault("mpl_generate: invalid call sequence\n");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* generate model */
      mpl->phase = 3;
      open_output(mpl, file);
      generate_model(mpl);
      flush_output(mpl);
      /* build problem instance */
      build_problem(mpl);
      /* generation phase has been finished */
      xprintf("Model has been successfully generated\n");
done: /* return to the calling program */
      return mpl->phase;
}

/*----------------------------------------------------------------------
-- mpl_get_prob_name - obtain problem (model) name.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- char *mpl_get_prob_name(MPL *mpl);
--
-- *Returns*
--
-- The routine mpl_get_prob_name returns a pointer to internal buffer,
-- which contains symbolic name of the problem (model).
--
-- *Note*
--
-- Currently MathProg has no feature to assign a symbolic name to the
-- model. Therefore the routine mpl_get_prob_name tries to construct
-- such name using the name of input text file containing model section,
-- although this is not a good idea (due to portability problems). */

char *mpl_get_prob_name(MPL *mpl)
{     char *name = mpl->mpl_buf;
      char *file = mpl->mod_file;
      int k;
      if (mpl->phase != 3)
         xfault("mpl_get_prob_name: invalid call sequence\n");
      for (;;)
      {  if (strchr(file, '/') != NULL)
            file = strchr(file, '/') + 1;
         else if (strchr(file, '\\') != NULL)
            file = strchr(file, '\\') + 1;
         else if (strchr(file, ':') != NULL)
            file = strchr(file, ':') + 1;
         else
            break;
      }
      for (k = 0; ; k++)
      {  if (k == 255) break;
         if (!(isalnum((unsigned char)*file) || *file == '_')) break;
         name[k] = *file++;
      }
      if (k == 0)
         strcpy(name, "Unknown");
      else
         name[k] = '\0';
      xassert(strlen(name) <= 255);
      return name;
}

/*----------------------------------------------------------------------
-- mpl_get_num_rows - determine number of rows.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_num_rows(MPL *mpl);
--
-- *Returns*
--
-- The routine mpl_get_num_rows returns total number of rows in the
-- problem, where each row is an individual constraint or objective. */

int mpl_get_num_rows(MPL *mpl)
{     if (mpl->phase != 3)
         xfault("mpl_get_num_rows: invalid call sequence\n");
      return mpl->m;
}

/*----------------------------------------------------------------------
-- mpl_get_num_cols - determine number of columns.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_num_cols(MPL *mpl);
--
-- *Returns*
--
-- The routine mpl_get_num_cols returns total number of columns in the
-- problem, where each column is an individual variable. */

int mpl_get_num_cols(MPL *mpl)
{     if (mpl->phase != 3)
         xfault("mpl_get_num_cols: invalid call sequence\n");
      return mpl->n;
}

/*----------------------------------------------------------------------
-- mpl_get_row_name - obtain row name.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- char *mpl_get_row_name(MPL *mpl, int i);
--
-- *Returns*
--
-- The routine mpl_get_row_name returns a pointer to internal buffer,
-- which contains symbolic name of i-th row of the problem. */

char *mpl_get_row_name(MPL *mpl, int i)
{     char *name = mpl->mpl_buf, *t;
      int len;
      if (mpl->phase != 3)
         xfault("mpl_get_row_name: invalid call sequence\n");
      if (!(1 <= i && i <= mpl->m))
         xfault("mpl_get_row_name: i = %d; row number out of range\n",
            i);
      strcpy(name, mpl->row[i]->con->name);
      len = strlen(name);
      xassert(len <= 255);
      t = format_tuple(mpl, '[', mpl->row[i]->memb->tuple);
      while (*t)
      {  if (len == 255) break;
         name[len++] = *t++;
      }
      name[len] = '\0';
      if (len == 255) strcpy(name+252, "...");
      xassert(strlen(name) <= 255);
      return name;
}

/*----------------------------------------------------------------------
-- mpl_get_row_kind - determine row kind.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_row_kind(MPL *mpl, int i);
--
-- *Returns*
--
-- The routine mpl_get_row_kind returns the kind of i-th row, which can
-- be one of the following:
--
-- MPL_ST  - non-free (constraint) row;
-- MPL_MIN - free (objective) row to be minimized;
-- MPL_MAX - free (objective) row to be maximized. */

int mpl_get_row_kind(MPL *mpl, int i)
{     int kind;
      if (mpl->phase != 3)
         xfault("mpl_get_row_kind: invalid call sequence\n");
      if (!(1 <= i && i <= mpl->m))
         xfault("mpl_get_row_kind: i = %d; row number out of range\n",
            i);
      switch (mpl->row[i]->con->type)
      {  case A_CONSTRAINT:
            kind = MPL_ST; break;
         case A_MINIMIZE:
            kind = MPL_MIN; break;
         case A_MAXIMIZE:
            kind = MPL_MAX; break;
         default:
            xassert(mpl != mpl);
      }
      return kind;
}

/*----------------------------------------------------------------------
-- mpl_get_row_bnds - obtain row bounds.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_row_bnds(MPL *mpl, int i, double *lb, double *ub);
--
-- *Description*
--
-- The routine mpl_get_row_bnds stores lower and upper bounds of i-th
-- row of the problem to the locations, which the parameters lb and ub
-- point to, respectively. Besides the routine returns the type of the
-- i-th row.
--
-- If some of the parameters lb and ub is NULL, the corresponding bound
-- value is not stored.
--
-- Types and bounds have the following meaning:
--
--     Type           Bounds          Note
--    -----------------------------------------------------------
--    MPL_FR   -inf <  f(x) <  +inf   Free linear form
--    MPL_LO     lb <= f(x) <  +inf   Inequality f(x) >= lb
--    MPL_UP   -inf <  f(x) <=  ub    Inequality f(x) <= ub
--    MPL_DB     lb <= f(x) <=  ub    Inequality lb <= f(x) <= ub
--    MPL_FX           f(x)  =  lb    Equality f(x) = lb
--
-- where f(x) is the corresponding linear form of the i-th row.
--
-- If the row has no lower bound, *lb is set to zero; if the row has
-- no upper bound, *ub is set to zero; and if the row is of fixed type,
-- both *lb and *ub are set to the same value.
--
-- *Returns*
--
-- The routine returns the type of the i-th row as it is stated in the
-- table above. */

int mpl_get_row_bnds(MPL *mpl, int i, double *_lb, double *_ub)
{     ELEMCON *con;
      int type;
      double lb, ub;
      if (mpl->phase != 3)
         xfault("mpl_get_row_bnds: invalid call sequence\n");
      if (!(1 <= i && i <= mpl->m))
         xfault("mpl_get_row_bnds: i = %d; row number out of range\n",
            i);
      con = mpl->row[i];
#if 0 /* 21/VII-2006 */
      if (con->con->lbnd == NULL && con->con->ubnd == NULL)
         type = MPL_FR, lb = ub = 0.0;
      else if (con->con->ubnd == NULL)
         type = MPL_LO, lb = con->lbnd, ub = 0.0;
      else if (con->con->lbnd == NULL)
         type = MPL_UP, lb = 0.0, ub = con->ubnd;
      else if (con->con->lbnd != con->con->ubnd)
         type = MPL_DB, lb = con->lbnd, ub = con->ubnd;
      else
         type = MPL_FX, lb = ub = con->lbnd;
#else
      lb = (con->con->lbnd == NULL ? -DBL_MAX : con->lbnd);
      ub = (con->con->ubnd == NULL ? +DBL_MAX : con->ubnd);
      if (lb == -DBL_MAX && ub == +DBL_MAX)
         type = MPL_FR, lb = ub = 0.0;
      else if (ub == +DBL_MAX)
         type = MPL_LO, ub = 0.0;
      else if (lb == -DBL_MAX)
         type = MPL_UP, lb = 0.0;
      else if (con->con->lbnd != con->con->ubnd)
         type = MPL_DB;
      else
         type = MPL_FX;
#endif
      if (_lb != NULL) *_lb = lb;
      if (_ub != NULL) *_ub = ub;
      return type;
}

/*----------------------------------------------------------------------
-- mpl_get_mat_row - obtain row of the constraint matrix.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_mat_row(MPL *mpl, int i, int ndx[], double val[]);
--
-- *Description*
--
-- The routine mpl_get_mat_row stores column indices and numeric values
-- of constraint coefficients for the i-th row to locations ndx[1], ...,
-- ndx[len] and val[1], ..., val[len], respectively, where 0 <= len <= n
-- is number of (structural) non-zero constraint coefficients, and n is
-- number of columns in the problem.
--
-- If the parameter ndx is NULL, column indices are not stored. If the
-- parameter val is NULL, numeric values are not stored.
--
-- Note that free rows may have constant terms, which are not part of
-- the constraint matrix and therefore not reported by this routine. The
-- constant term of a particular row can be obtained, if necessary, via
-- the routine mpl_get_row_c0.
--
-- *Returns*
--
-- The routine mpl_get_mat_row returns len, which is length of i-th row
-- of the constraint matrix (i.e. number of non-zero coefficients). */

int mpl_get_mat_row(MPL *mpl, int i, int ndx[], double val[])
{     FORMULA *term;
      int len = 0;
      if (mpl->phase != 3)
         xfault("mpl_get_mat_row: invalid call sequence\n");
      if (!(1 <= i && i <= mpl->m))
         xfault("mpl_get_mat_row: i = %d; row number out of range\n",
            i);
      for (term = mpl->row[i]->form; term != NULL; term = term->next)
      {  xassert(term->var != NULL);
         len++;
         xassert(len <= mpl->n);
         if (ndx != NULL) ndx[len] = term->var->j;
         if (val != NULL) val[len] = term->coef;
      }
      return len;
}

/*----------------------------------------------------------------------
-- mpl_get_row_c0 - obtain constant term of free row.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- double mpl_get_row_c0(MPL *mpl, int i);
--
-- *Returns*
--
-- The routine mpl_get_row_c0 returns numeric value of constant term of
-- i-th row.
--
-- Note that only free rows may have non-zero constant terms. Therefore
-- if i-th row is not free, the routine returns zero. */

double mpl_get_row_c0(MPL *mpl, int i)
{     ELEMCON *con;
      double c0;
      if (mpl->phase != 3)
         xfault("mpl_get_row_c0: invalid call sequence\n");
      if (!(1 <= i && i <= mpl->m))
         xfault("mpl_get_row_c0: i = %d; row number out of range\n",
            i);
      con = mpl->row[i];
      if (con->con->lbnd == NULL && con->con->ubnd == NULL)
         c0 = - con->lbnd;
      else
         c0 = 0.0;
      return c0;
}

/*----------------------------------------------------------------------
-- mpl_get_col_name - obtain column name.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- char *mpl_get_col_name(MPL *mpl, int j);
--
-- *Returns*
--
-- The routine mpl_get_col_name returns a pointer to internal buffer,
-- which contains symbolic name of j-th column of the problem. */

char *mpl_get_col_name(MPL *mpl, int j)
{     char *name = mpl->mpl_buf, *t;
      int len;
      if (mpl->phase != 3)
         xfault("mpl_get_col_name: invalid call sequence\n");
      if (!(1 <= j && j <= mpl->n))
         xfault("mpl_get_col_name: j = %d; column number out of range\n"
            , j);
      strcpy(name, mpl->col[j]->var->name);
      len = strlen(name);
      xassert(len <= 255);
      t = format_tuple(mpl, '[', mpl->col[j]->memb->tuple);
      while (*t)
      {  if (len == 255) break;
         name[len++] = *t++;
      }
      name[len] = '\0';
      if (len == 255) strcpy(name+252, "...");
      xassert(strlen(name) <= 255);
      return name;
}

/*----------------------------------------------------------------------
-- mpl_get_col_kind - determine column kind.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_col_kind(MPL *mpl, int j);
--
-- *Returns*
--
-- The routine mpl_get_col_kind returns the kind of j-th column, which
-- can be one of the following:
--
-- MPL_NUM - continuous variable;
-- MPL_INT - integer variable;
-- MPL_BIN - binary variable.
--
-- Note that column kinds are defined independently on type and bounds
-- (reported by the routine mpl_get_col_bnds) of corresponding columns.
-- This means, in particular, that bounds of an integer column may be
-- fractional, or a binary column may have lower and upper bounds that
-- are not 0 and 1 (or it may have no lower/upper bound at all). */

int mpl_get_col_kind(MPL *mpl, int j)
{     int kind;
      if (mpl->phase != 3)
         xfault("mpl_get_col_kind: invalid call sequence\n");
      if (!(1 <= j && j <= mpl->n))
         xfault("mpl_get_col_kind: j = %d; column number out of range\n"
            , j);
      switch (mpl->col[j]->var->type)
      {  case A_NUMERIC:
            kind = MPL_NUM; break;
         case A_INTEGER:
            kind = MPL_INT; break;
         case A_BINARY:
            kind = MPL_BIN; break;
         default:
            xassert(mpl != mpl);
      }
      return kind;
}

/*----------------------------------------------------------------------
-- mpl_get_col_bnds - obtain column bounds.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_get_col_bnds(MPL *mpl, int j, double *lb, double *ub);
--
-- *Description*
--
-- The routine mpl_get_col_bnds stores lower and upper bound of j-th
-- column of the problem to the locations, which the parameters lb and
-- ub point to, respectively. Besides the routine returns the type of
-- the j-th column.
--
-- If some of the parameters lb and ub is NULL, the corresponding bound
-- value is not stored.
--
-- Types and bounds have the following meaning:
--
--     Type         Bounds         Note
--    ------------------------------------------------------
--    MPL_FR   -inf <  x <  +inf   Free (unbounded) variable
--    MPL_LO     lb <= x <  +inf   Variable with lower bound
--    MPL_UP   -inf <  x <=  ub    Variable with upper bound
--    MPL_DB     lb <= x <=  ub    Double-bounded variable
--    MPL_FX           x  =  lb    Fixed variable
--
-- where x is individual variable corresponding to the j-th column.
--
-- If the column has no lower bound, *lb is set to zero; if the column
-- has no upper bound, *ub is set to zero; and if the column is of fixed
-- type, both *lb and *ub are set to the same value.
--
-- *Returns*
--
-- The routine returns the type of the j-th column as it is stated in
-- the table above. */

int mpl_get_col_bnds(MPL *mpl, int j, double *_lb, double *_ub)
{     ELEMVAR *var;
      int type;
      double lb, ub;
      if (mpl->phase != 3)
         xfault("mpl_get_col_bnds: invalid call sequence\n");
      if (!(1 <= j && j <= mpl->n))
         xfault("mpl_get_col_bnds: j = %d; column number out of range\n"
            , j);
      var = mpl->col[j];
#if 0 /* 21/VII-2006 */
      if (var->var->lbnd == NULL && var->var->ubnd == NULL)
         type = MPL_FR, lb = ub = 0.0;
      else if (var->var->ubnd == NULL)
         type = MPL_LO, lb = var->lbnd, ub = 0.0;
      else if (var->var->lbnd == NULL)
         type = MPL_UP, lb = 0.0, ub = var->ubnd;
      else if (var->var->lbnd != var->var->ubnd)
         type = MPL_DB, lb = var->lbnd, ub = var->ubnd;
      else
         type = MPL_FX, lb = ub = var->lbnd;
#else
      lb = (var->var->lbnd == NULL ? -DBL_MAX : var->lbnd);
      ub = (var->var->ubnd == NULL ? +DBL_MAX : var->ubnd);
      if (lb == -DBL_MAX && ub == +DBL_MAX)
         type = MPL_FR, lb = ub = 0.0;
      else if (ub == +DBL_MAX)
         type = MPL_LO, ub = 0.0;
      else if (lb == -DBL_MAX)
         type = MPL_UP, lb = 0.0;
      else if (var->var->lbnd != var->var->ubnd)
         type = MPL_DB;
      else
         type = MPL_FX;
#endif
      if (_lb != NULL) *_lb = lb;
      if (_ub != NULL) *_ub = ub;
      return type;
}

/*----------------------------------------------------------------------
-- mpl_has_solve_stmt - check if model has solve statement.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_has_solve_stmt(MPL *mpl);
--
-- *Returns*
--
-- If the model has the solve statement, the routine returns non-zero,
-- otherwise zero is returned. */

int mpl_has_solve_stmt(MPL *mpl)
{     if (mpl->phase != 3)
         xfault("mpl_has_solve_stmt: invalid call sequence\n");
      return mpl->flag_s;
}

#if 1 /* 15/V-2010 */
void mpl_put_row_soln(MPL *mpl, int i, int stat, double prim,
      double dual)
{     /* store row (constraint/objective) solution components */
      xassert(mpl->phase == 3);
      xassert(1 <= i && i <= mpl->m);
      mpl->row[i]->stat = stat;
      mpl->row[i]->prim = prim;
      mpl->row[i]->dual = dual;
      return;
}
#endif

#if 1 /* 15/V-2010 */
void mpl_put_col_soln(MPL *mpl, int j, int stat, double prim,
      double dual)
{     /* store column (variable) solution components */
      xassert(mpl->phase == 3);
      xassert(1 <= j && j <= mpl->n);
      mpl->col[j]->stat = stat;
      mpl->col[j]->prim = prim;
      mpl->col[j]->dual = dual;
      return;
}
#endif

#if 0 /* 15/V-2010 */
/*----------------------------------------------------------------------
-- mpl_put_col_value - store column value.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- void mpl_put_col_value(MPL *mpl, int j, double val);
--
-- *Description*
--
-- The routine mpl_put_col_value stores numeric value of j-th column
-- into the translator database. It is assumed that the column value is
-- provided by the solver. */

void mpl_put_col_value(MPL *mpl, int j, double val)
{     if (mpl->phase != 3)
         xfault("mpl_put_col_value: invalid call sequence\n");
      if (!(1 <= j && j <= mpl->n))
         xfault(
         "mpl_put_col_value: j = %d; column number out of range\n", j);
      mpl->col[j]->prim = val;
      return;
}
#endif

/*----------------------------------------------------------------------
-- mpl_postsolve - postsolve model.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- int mpl_postsolve(MPL *mpl);
--
-- *Description*
--
-- The routine mpl_postsolve performs postsolving of the model using
-- its description stored in the translator database. This phase means
-- executing statements, which follow the solve statement.
--
-- If this routine is used, it should be called once after the routine
-- mpl_generate and if the latter returned the code 3.
--
-- *Returns*
--
-- The routine mpl_postsolve returns one of the following codes:
--
-- 3 - model has been successfully postsolved.
-- 4 - processing failed due to some errors. In this case the calling
--     program should call the routine mpl_terminate to terminate model
--     processing. */

int mpl_postsolve(MPL *mpl)
{     if (!(mpl->phase == 3 && !mpl->flag_p))
         xfault("mpl_postsolve: invalid call sequence\n");
      /* set up error handler */
      if (setjmp(mpl->jump)) goto done;
      /* perform postsolving */
      postsolve_model(mpl);
      flush_output(mpl);
      /* postsolving phase has been finished */
      xprintf("Model has been successfully processed\n");
done: /* return to the calling program */
      return mpl->phase;
}

/*----------------------------------------------------------------------
-- mpl_terminate - free all resources used by translator.
--
-- *Synopsis*
--
-- #include "glpmpl.h"
-- void mpl_terminate(MPL *mpl);
--
-- *Description*
--
-- The routine mpl_terminate frees all the resources used by the GNU
-- MathProg translator. */

void mpl_terminate(MPL *mpl)
{     if (setjmp(mpl->jump)) xassert(mpl != mpl);
      switch (mpl->phase)
      {  case 0:
         case 1:
         case 2:
         case 3:
            /* there were no errors; clean the model content */
            clean_model(mpl);
            xassert(mpl->a_list == NULL);
#if 1 /* 11/II-2008 */
            xassert(mpl->dca == NULL);
#endif
            break;
         case 4:
            /* model processing has been finished due to error; delete
               search trees, which may be created for some arrays */
            {  ARRAY *a;
               for (a = mpl->a_list; a != NULL; a = a->next)
                  if (a->tree != NULL) avl_delete_tree(a->tree);
            }
#if 1 /* 11/II-2008 */
            free_dca(mpl);
#endif
            break;
         default:
            xassert(mpl != mpl);
      }
      /* delete the translator database */
      xfree(mpl->image);
      xfree(mpl->b_image);
      xfree(mpl->f_image);
      xfree(mpl->context);
      dmp_delete_pool(mpl->pool);
      avl_delete_tree(mpl->tree);
      dmp_delete_pool(mpl->strings);
      dmp_delete_pool(mpl->symbols);
      dmp_delete_pool(mpl->tuples);
      dmp_delete_pool(mpl->arrays);
      dmp_delete_pool(mpl->members);
      dmp_delete_pool(mpl->elemvars);
      dmp_delete_pool(mpl->formulae);
      dmp_delete_pool(mpl->elemcons);
      xfree(mpl->sym_buf);
      xfree(mpl->tup_buf);
      rng_delete_rand(mpl->rand);
      if (mpl->row != NULL) xfree(mpl->row);
      if (mpl->col != NULL) xfree(mpl->col);
      if (mpl->in_fp != NULL) glp_close(mpl->in_fp);
      if (mpl->out_fp != NULL && mpl->out_fp != (void *)stdout)
         glp_close(mpl->out_fp);
      if (mpl->out_file != NULL) xfree(mpl->out_file);
      if (mpl->prt_fp != NULL) glp_close(mpl->prt_fp);
      if (mpl->prt_file != NULL) xfree(mpl->prt_file);
      if (mpl->mod_file != NULL) xfree(mpl->mod_file);
      xfree(mpl->mpl_buf);
      xfree(mpl);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl5.c0000644000175100001710000005313700000000000023726 0ustar00runnerdocker00000000000000/* mpl5.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin  and Heinrich Schuchardt
*  
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#if 1 /* 11/VI-2013 */
#include "jd.h"
#endif
#include "mpl.h"

double fn_gmtime(MPL *mpl)
{     /* obtain the current calendar time (UTC) */
      time_t timer;
      struct tm *tm;
      int j;
      time(&timer);
      if (timer == (time_t)(-1))
err:     error(mpl, "gmtime(); unable to obtain current calendar time");
#if 0 /* 29/I-2017 */
      tm = gmtime(&timer);
#else
      tm = xgmtime(&timer);
#endif
      if (tm == NULL) goto err;
      j = jday(tm->tm_mday, tm->tm_mon + 1, 1900 + tm->tm_year);
      if (j < 0) goto err;
      return (((double)(j - jday(1, 1, 1970)) * 24.0 +
         (double)tm->tm_hour) * 60.0 + (double)tm->tm_min) * 60.0 +
         (double)tm->tm_sec;
}

static char *week[] = { "Monday", "Tuesday", "Wednesday", "Thursday",
      "Friday", "Saturday", "Sunday" };

static char *moon[] = { "January", "February", "March", "April", "May",
      "June", "July", "August", "September", "October", "November",
      "December" };

static void error1(MPL *mpl, const char *str, const char *s,
      const char *fmt, const char *f, const char *msg)
{     xprintf("Input string passed to str2time:\n");
      xprintf("%s\n", str);
      xprintf("%*s\n", (s - str) + 1, "^");
      xprintf("Format string passed to str2time:\n");
      xprintf("%s\n", fmt);
      xprintf("%*s\n", (f - fmt) + 1, "^");
      error(mpl, "%s", msg);
      /* no return */
}

double fn_str2time(MPL *mpl, const char *str, const char *fmt)
{     /* convert character string to the calendar time */
      int j, year, month, day, hh, mm, ss, zone;
      const char *s, *f;
      year = month = day = hh = mm = ss = -1, zone = INT_MAX;
      s = str;
      for (f = fmt; *f != '\0'; f++)
      {  if (*f == '%')
         {  f++;
            if (*f == 'b' || *f == 'h')
            {  /* the abbreviated month name */
               int k;
               char *name;
               if (month >= 0)
                  error1(mpl, str, s, fmt, f, "month multiply specified"
                     );
               while (*s == ' ') s++;
               for (month = 1; month <= 12; month++)
               {  name = moon[month-1];
                  for (k = 0; k <= 2; k++)
                  {  if (toupper((unsigned char)s[k]) !=
                         toupper((unsigned char)name[k])) goto next;
                  }
                  s += 3;
                  for (k = 3; name[k] != '\0'; k++)
                  {  if (toupper((unsigned char)*s) !=
                         toupper((unsigned char)name[k])) break;
                     s++;
                  }
                  break;
next:             ;
               }
               if (month > 12)
                  error1(mpl, str, s, fmt, f, "abbreviated month name m"
                     "issing or invalid");
            }
            else if (*f == 'd')
            {  /* the day of the month as a decimal number (01..31) */
               if (day >= 0)
                  error1(mpl, str, s, fmt, f, "day multiply specified");
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "day missing or invalid");
               day = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  day = 10 * day + ((*s++) - '0');
               if (!(1 <= day && day <= 31))
                  error1(mpl, str, s, fmt, f, "day out of range");
            }
            else if (*f == 'H')
            {  /* the hour as a decimal number, using a 24-hour clock
                  (00..23) */
               if (hh >= 0)
                  error1(mpl, str, s, fmt, f, "hour multiply specified")
                     ;
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "hour missing or invalid")
                     ;
               hh = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  hh = 10 * hh + ((*s++) - '0');
               if (!(0 <= hh && hh <= 23))
                  error1(mpl, str, s, fmt, f, "hour out of range");
            }
            else if (*f == 'm')
            {  /* the month as a decimal number (01..12) */
               if (month >= 0)
                  error1(mpl, str, s, fmt, f, "month multiply specified"
                     );
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "month missing or invalid"
                     );
               month = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  month = 10 * month + ((*s++) - '0');
               if (!(1 <= month && month <= 12))
                  error1(mpl, str, s, fmt, f, "month out of range");
            }
            else if (*f == 'M')
            {  /* the minute as a decimal number (00..59) */
               if (mm >= 0)
                  error1(mpl, str, s, fmt, f, "minute multiply specifie"
                     "d");
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "minute missing or invali"
                     "d");
               mm = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  mm = 10 * mm + ((*s++) - '0');
               if (!(0 <= mm && mm <= 59))
                  error1(mpl, str, s, fmt, f, "minute out of range");
            }
            else if (*f == 'S')
            {  /* the second as a decimal number (00..60) */
               if (ss >= 0)
                  error1(mpl, str, s, fmt, f, "second multiply specifie"
                     "d");
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "second missing or invali"
                     "d");
               ss = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  ss = 10 * ss + ((*s++) - '0');
               if (!(0 <= ss && ss <= 60))
                  error1(mpl, str, s, fmt, f, "second out of range");
            }
            else if (*f == 'y')
            {  /* the year without a century as a decimal number
                  (00..99); the values 00 to 68 mean the years 2000 to
                  2068 while the values 69 to 99 mean the years 1969 to
                  1999 */
               if (year >= 0)
                  error1(mpl, str, s, fmt, f, "year multiply specified")
                     ;
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "year missing or invalid")
                     ;
               year = (*s++) - '0';
               if ('0' <= *s && *s <= '9')
                  year = 10 * year + ((*s++) - '0');
               year += (year >= 69 ? 1900 : 2000);
            }
            else if (*f == 'Y')
            {  /* the year as a decimal number, using the Gregorian
                  calendar */
               if (year >= 0)
                  error1(mpl, str, s, fmt, f, "year multiply specified")
                     ;
               while (*s == ' ') s++;
               if (!('0' <= *s && *s <= '9'))
                  error1(mpl, str, s, fmt, f, "year missing or invalid")
                     ;
               year = 0;
               for (j = 1; j <= 4; j++)
               {  if (!('0' <= *s && *s <= '9')) break;
                  year = 10 * year + ((*s++) - '0');
               }
               if (!(1 <= year && year <= 4000))
                  error1(mpl, str, s, fmt, f, "year out of range");
            }
            else if (*f == 'z')
            {  /* time zone offset in the form zhhmm */
               int z, hh, mm;
               if (zone != INT_MAX)
                  error1(mpl, str, s, fmt, f, "time zone offset multipl"
                     "y specified");
               while (*s == ' ') s++;
               if (*s == 'Z')
               {  z = hh = mm = 0, s++;
                  goto skip;
               }
               if (*s == '+')
                  z = +1, s++;
               else if (*s == '-')
                  z = -1, s++;
               else
                  error1(mpl, str, s, fmt, f, "time zone offset sign mi"
                     "ssing");
               hh = 0;
               for (j = 1; j <= 2; j++)
               {  if (!('0' <= *s && *s <= '9'))
err1:                error1(mpl, str, s, fmt, f, "time zone offset valu"
                        "e incomplete or invalid");
                  hh = 10 * hh + ((*s++) - '0');
               }
               if (hh > 23)
err2:             error1(mpl, str, s, fmt, f, "time zone offset value o"
                     "ut of range");
               if (*s == ':')
               {  s++;
                  if (!('0' <= *s && *s <= '9')) goto err1;
               }
               mm = 0;
               if (!('0' <= *s && *s <= '9')) goto skip;
               for (j = 1; j <= 2; j++)
               {  if (!('0' <= *s && *s <= '9')) goto err1;
                  mm = 10 * mm + ((*s++) - '0');
               }
               if (mm > 59) goto err2;
skip:          zone = z * (60 * hh + mm);
            }
            else if (*f == '%')
            {  /* literal % character */
               goto test;
            }
            else
               error1(mpl, str, s, fmt, f, "invalid conversion specifie"
                  "r");
         }
         else if (*f == ' ')
            ;
         else
test:    {  /* check a matching character in the input string */
            if (*s != *f)
               error1(mpl, str, s, fmt, f, "character mismatch");
            s++;
         }
      }
      if (year < 0) year = 1970;
      if (month < 0) month = 1;
      if (day < 0) day = 1;
      if (hh < 0) hh = 0;
      if (mm < 0) mm = 0;
      if (ss < 0) ss = 0;
      if (zone == INT_MAX) zone = 0;
      j = jday(day, month, year);
      xassert(j >= 0);
      return (((double)(j - jday(1, 1, 1970)) * 24.0 + (double)hh) *
         60.0 + (double)mm) * 60.0 + (double)ss - 60.0 * (double)zone;
}

static void error2(MPL *mpl, const char *fmt, const char *f,
      const char *msg)
{     xprintf("Format string passed to time2str:\n");
      xprintf("%s\n", fmt);
      xprintf("%*s\n", (f - fmt) + 1, "^");
      error(mpl, "%s", msg);
      /* no return */
}

static int weekday(int j)
{     /* determine weekday number (1 = Mon, ..., 7 = Sun) */
      return (j + jday(1, 1, 1970)) % 7 + 1;
}

static int firstday(int year)
{     /* determine the first day of the first week for a specified year
         according to ISO 8601 */
      int j;
      /* if 1 January is Monday, Tuesday, Wednesday or Thursday, it is
         in week 01; if 1 January is Friday, Saturday or Sunday, it is
         in week 52 or 53 of the previous year */
      j = jday(1, 1, year) - jday(1, 1, 1970);
      switch (weekday(j))
      {  case 1: /* 1 Jan is Mon */ j += 0; break;
         case 2: /* 1 Jan is Tue */ j -= 1; break;
         case 3: /* 1 Jan is Wed */ j -= 2; break;
         case 4: /* 1 Jan is Thu */ j -= 3; break;
         case 5: /* 1 Jan is Fri */ j += 3; break;
         case 6: /* 1 Jan is Sat */ j += 2; break;
         case 7: /* 1 Jan is Sun */ j += 1; break;
         default: xassert(j != j);
      }
      /* the first day of the week must be Monday */
      xassert(weekday(j) == 1);
      return j;
}

void fn_time2str(MPL *mpl, char *str, double t, const char *fmt)
{     /* convert the calendar time to character string */
      int j, year, month, day, hh, mm, ss, len;
      double temp;
      const char *f;
      char buf[MAX_LENGTH+1];
      if (!(-62135596800.0 <= t && t <= 64092211199.0))
         error(mpl, "time2str(%.*g,...); argument out of range",
            DBL_DIG, t);
      t = floor(t + 0.5);
      temp = fabs(t) / 86400.0;
      j = (int)floor(temp);
      if (t < 0.0)
      {  if (temp == floor(temp))
            j = - j;
         else
            j = - (j + 1);
      }
      xassert(jdate(j + jday(1, 1, 1970), &day, &month, &year) == 0);
      ss = (int)(t - 86400.0 * (double)j);
      xassert(0 <= ss && ss < 86400);
      mm = ss / 60, ss %= 60;
      hh = mm / 60, mm %= 60;
      len = 0;
      for (f = fmt; *f != '\0'; f++)
      {  if (*f == '%')
         {  f++;
            if (*f == 'a')
            {  /* the abbreviated weekday name */
               memcpy(buf, week[weekday(j)-1], 3), buf[3] = '\0';
            }
            else if (*f == 'A')
            {  /* the full weekday name */
               strcpy(buf, week[weekday(j)-1]);
            }
            else if (*f == 'b' || *f == 'h')
            {  /* the abbreviated month name */
               memcpy(buf, moon[month-1], 3), buf[3] = '\0';
            }
            else if (*f == 'B')
            {  /* the full month name */
               strcpy(buf, moon[month-1]);
            }
            else if (*f == 'C')
            {  /* the century of the year */
               sprintf(buf, "%02d", year / 100);
            }
            else if (*f == 'd')
            {  /* the day of the month as a decimal number (01..31) */
               sprintf(buf, "%02d", day);
            }
            else if (*f == 'D')
            {  /* the date using the format %m/%d/%y */
               sprintf(buf, "%02d/%02d/%02d", month, day, year % 100);
            }
            else if (*f == 'e')
            {  /* the day of the month like with %d, but padded with
                  blank (1..31) */
               sprintf(buf, "%2d", day);
            }
            else if (*f == 'F')
            {  /* the date using the format %Y-%m-%d */
               sprintf(buf, "%04d-%02d-%02d", year, month, day);
            }
            else if (*f == 'g')
            {  /* the year corresponding to the ISO week number, but
                  without the century (range 00 through 99); this has
                  the same format and value as %y, except that if the
                  ISO week number (see %V) belongs to the previous or
                  next year, that year is used instead */
               int iso;
               if (j < firstday(year))
                  iso = year - 1;
               else if (j < firstday(year + 1))
                  iso = year;
               else
                  iso = year + 1;
               sprintf(buf, "%02d", iso % 100);
            }
            else if (*f == 'G')
            {  /* the year corresponding to the ISO week number; this
                  has the same format and value as %Y, excepth that if
                  the ISO week number (see %V) belongs to the previous
                  or next year, that year is used instead */
               int iso;
               if (j < firstday(year))
                  iso = year - 1;
               else if (j < firstday(year + 1))
                  iso = year;
               else
                  iso = year + 1;
               sprintf(buf, "%04d", iso);
            }
            else if (*f == 'H')
            {  /* the hour as a decimal number, using a 24-hour clock
                  (00..23) */
               sprintf(buf, "%02d", hh);
            }
            else if (*f == 'I')
            {  /* the hour as a decimal number, using a 12-hour clock
                  (01..12) */
               sprintf(buf, "%02d",
                  hh == 0 ? 12 : hh <= 12 ? hh : hh - 12);
            }
            else if (*f == 'j')
            {  /* the day of the year as a decimal number (001..366) */
               sprintf(buf, "%03d",
                  jday(day, month, year) - jday(1, 1, year) + 1);
            }
            else if (*f == 'k')
            {  /* the hour as a decimal number, using a 24-hour clock
                  like %H, but padded with blank (0..23) */
               sprintf(buf, "%2d", hh);
            }
            else if (*f == 'l')
            {  /* the hour as a decimal number, using a 12-hour clock
                  like %I, but padded with blank (1..12) */
               sprintf(buf, "%2d",
                  hh == 0 ? 12 : hh <= 12 ? hh : hh - 12);
            }
            else if (*f == 'm')
            {  /* the month as a decimal number (01..12) */
               sprintf(buf, "%02d", month);
            }
            else if (*f == 'M')
            {  /* the minute as a decimal number (00..59) */
               sprintf(buf, "%02d", mm);
            }
            else if (*f == 'p')
            {  /* either AM or PM, according to the given time value;
                  noon is treated as PM and midnight as AM */
               strcpy(buf, hh <= 11 ? "AM" : "PM");
            }
            else if (*f == 'P')
            {  /* either am or pm, according to the given time value;
                  noon is treated as pm and midnight as am */
               strcpy(buf, hh <= 11 ? "am" : "pm");
            }
            else if (*f == 'r')
            {  /* the calendar time using the format %I:%M:%S %p */
               sprintf(buf, "%02d:%02d:%02d %s",
                  hh == 0 ? 12 : hh <= 12 ? hh : hh - 12,
                  mm, ss, hh <= 11 ? "AM" : "PM");
            }
            else if (*f == 'R')
            {  /* the hour and minute using the format %H:%M */
               sprintf(buf, "%02d:%02d", hh, mm);
            }
            else if (*f == 'S')
            {  /* the second as a decimal number (00..59) */
               sprintf(buf, "%02d", ss);
            }
            else if (*f == 'T')
            {  /* the time of day using the format %H:%M:%S */
               sprintf(buf, "%02d:%02d:%02d", hh, mm, ss);
            }
            else if (*f == 'u')
            {  /* the day of the week as a decimal number (1..7),
                  Monday being 1 */
               sprintf(buf, "%d", weekday(j));
            }
            else if (*f == 'U')
            {  /* the week number of the current year as a decimal
                  number (range 00 through 53), starting with the first
                  Sunday as the first day of the first week; days
                  preceding the first Sunday in the year are considered
                  to be in week 00 */
#if 1 /* 09/I-2009 */
#undef sun
/* causes compilation error in SunOS */
#endif
               int sun;
               /* sun = the first Sunday of the year */
               sun = jday(1, 1, year) - jday(1, 1, 1970);
               sun += (7 - weekday(sun));
               sprintf(buf, "%02d", (j + 7 - sun) / 7);
            }
            else if (*f == 'V')
            {  /* the ISO week number as a decimal number (range 01
                  through 53); ISO weeks start with Monday and end with
                  Sunday; week 01 of a year is the first week which has
                  the majority of its days in that year; week 01 of
                  a year can contain days from the previous year; the
                  week before week 01 of a year is the last week (52 or
                  53) of the previous year even if it contains days
                  from the new year */
               int iso;
               if (j < firstday(year))
                  iso = j - firstday(year - 1);
               else if (j < firstday(year + 1))
                  iso = j - firstday(year);
               else
                  iso = j - firstday(year + 1);
               sprintf(buf, "%02d", iso / 7 + 1);
            }
            else if (*f == 'w')
            {  /* the day of the week as a decimal number (0..6),
                  Sunday being 0 */
               sprintf(buf, "%d", weekday(j) % 7);
            }
            else if (*f == 'W')
            {  /* the week number of the current year as a decimal
                  number (range 00 through 53), starting with the first
                  Monday as the first day of the first week; days
                  preceding the first Monday in the year are considered
                  to be in week 00 */
               int mon;
               /* mon = the first Monday of the year */
               mon = jday(1, 1, year) - jday(1, 1, 1970);
               mon += (8 - weekday(mon)) % 7;
               sprintf(buf, "%02d", (j + 7 - mon) / 7);
            }
            else if (*f == 'y')
            {  /* the year without a century as a decimal number
                  (00..99) */
               sprintf(buf, "%02d", year % 100);
            }
            else if (*f == 'Y')
            {  /* the year as a decimal number, using the Gregorian
                  calendar */
               sprintf(buf, "%04d", year);
            }
            else if (*f == '%')
            {  /* a literal % character */
               buf[0] = '%', buf[1] = '\0';
            }
            else
               error2(mpl, fmt, f, "invalid conversion specifier");
         }
         else
            buf[0] = *f, buf[1] = '\0';
         if (len + strlen(buf) > MAX_LENGTH)
            error(mpl, "time2str; output string length exceeds %d chara"
               "cters", MAX_LENGTH);
         memcpy(str+len, buf, strlen(buf));
         len += strlen(buf);
      }
      str[len] = '\0';
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mpl6.c0000644000175100001710000007624500000000000023734 0ustar00runnerdocker00000000000000/* mpl6.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "mpl.h"
#include "mplsql.h"

/**********************************************************************/

#define CSV_FIELD_MAX 50
/* maximal number of fields in record */

#define CSV_FDLEN_MAX 100
/* maximal field length */

struct csv
{     /* comma-separated values file */
      int mode;
      /* 'R' = reading; 'W' = writing */
      char *fname;
      /* name of csv file */
      FILE *fp;
      /* stream assigned to csv file */
      jmp_buf jump;
      /* address for non-local go to in case of error */
      int count;
      /* record count */
      /*--------------------------------------------------------------*/
      /* used only for input csv file */
      int c;
      /* current character or EOF */
      int what;
      /* current marker: */
#define CSV_EOF   0  /* end-of-file */
#define CSV_EOR   1  /* end-of-record */
#define CSV_NUM   2  /* floating-point number */
#define CSV_STR   3  /* character string */
      char field[CSV_FDLEN_MAX+1];
      /* current field just read */
      int nf;
      /* number of fields in the csv file */
      int ref[1+CSV_FIELD_MAX];
      /* ref[k] = k', if k-th field of the csv file corresponds to
         k'-th field in the table statement; if ref[k] = 0, k-th field
         of the csv file is ignored */
#if 1 /* 01/VI-2010 */
      int nskip;
      /* number of comment records preceding the header record */
#endif
};

#undef read_char

static void read_char(struct csv *csv)
{     /* read character from csv data file */
      int c;
      xassert(csv->c != EOF);
      if (csv->c == '\n') csv->count++;
loop: c = fgetc(csv->fp);
      if (ferror(csv->fp))
      {  xprintf("%s:%d: read error - %s\n", csv->fname, csv->count,
#if 0 /* 29/I-2017 */
            strerror(errno));
#else
            xstrerr(errno));
#endif
         longjmp(csv->jump, 0);
      }
      if (feof(csv->fp))
      {  if (csv->c == '\n')
         {  csv->count--;
            c = EOF;
         }
         else
         {  xprintf("%s:%d: warning: missing final end-of-line\n",
               csv->fname, csv->count);
            c = '\n';
         }
      }
      else if (c == '\r')
         goto loop;
      else if (c == '\n')
         ;
      else if (iscntrl(c))
      {  xprintf("%s:%d: invalid control character 0x%02X\n",
            csv->fname, csv->count, c);
         longjmp(csv->jump, 0);
      }
      csv->c = c;
      return;
}

static void read_field(struct csv *csv)
{     /* read field from csv data file */
      /* check for end of file */
      if (csv->c == EOF)
      {  csv->what = CSV_EOF;
         strcpy(csv->field, "EOF");
         goto done;
      }
      /* check for end of record */
      if (csv->c == '\n')
      {  csv->what = CSV_EOR;
         strcpy(csv->field, "EOR");
         read_char(csv);
         if (csv->c == ',')
err1:    {  xprintf("%s:%d: empty field not allowed\n", csv->fname,
               csv->count);
            longjmp(csv->jump, 0);
         }
         if (csv->c == '\n')
         {  xprintf("%s:%d: empty record not allowed\n", csv->fname,
               csv->count);
            longjmp(csv->jump, 0);
         }
#if 1 /* 01/VI-2010 */
         /* skip comment records; may appear only before the very first
            record containing field names */
         if (csv->c == '#' && csv->count == 1)
         {  while (csv->c == '#')
            {  while (csv->c != '\n')
                  read_char(csv);
               read_char(csv);
               csv->nskip++;
            }
         }
#endif
         goto done;
      }
      /* skip comma before next field */
      if (csv->c == ',')
         read_char(csv);
      /* read field */
      if (csv->c == '\'' || csv->c == '"')
      {  /* read a field enclosed in quotes */
         int quote = csv->c, len = 0;
         csv->what = CSV_STR;
         /* skip opening quote */
         read_char(csv);
         /* read field characters within quotes */
         for (;;)
         {  /* check for closing quote and read it */
            if (csv->c == quote)
            {  read_char(csv);
               if (csv->c == quote)
                  ;
               else if (csv->c == ',' || csv->c == '\n')
                  break;
               else
               {  xprintf("%s:%d: invalid field\n", csv->fname,
                     csv->count);
                  longjmp(csv->jump, 0);
               }
            }
            /* check the current field length */
            if (len == CSV_FDLEN_MAX)
err2:       {  xprintf("%s:%d: field too long\n", csv->fname,
                  csv->count);
               longjmp(csv->jump, 0);
            }
            /* add the current character to the field */
            csv->field[len++] = (char)csv->c;
            /* read the next character */
            read_char(csv);
         }
         /* the field has been read */
         if (len == 0) goto err1;
         csv->field[len] = '\0';
      }
      else
      {  /* read a field not enclosed in quotes */
         int len = 0;
         double temp;
         csv->what = CSV_NUM;
         while (!(csv->c == ',' || csv->c == '\n'))
         {  /* quotes within the field are not allowed */
            if (csv->c == '\'' || csv->c == '"')
            {  xprintf("%s:%d: invalid use of single or double quote wi"
                  "thin field\n", csv->fname, csv->count);
               longjmp(csv->jump, 0);
            }
            /* check the current field length */
            if (len == CSV_FDLEN_MAX) goto err2;
            /* add the current character to the field */
            csv->field[len++] = (char)csv->c;
            /* read the next character */
            read_char(csv);
         }
         /* the field has been read */
         if (len == 0) goto err1;
         csv->field[len] = '\0';
         /* check the field type */
         if (str2num(csv->field, &temp)) csv->what = CSV_STR;
      }
done: return;
}

static struct csv *csv_open_file(TABDCA *dca, int mode)
{     /* open csv data file */
      struct csv *csv;
      /* create control structure */
      csv = xmalloc(sizeof(struct csv));
      csv->mode = mode;
      csv->fname = NULL;
      csv->fp = NULL;
      if (setjmp(csv->jump)) goto fail;
      csv->count = 0;
      csv->c = '\n';
      csv->what = 0;
      csv->field[0] = '\0';
      csv->nf = 0;
      /* try to open the csv data file */
      if (mpl_tab_num_args(dca) < 2)
      {  xprintf("csv_driver: file name not specified\n");
         longjmp(csv->jump, 0);
      }
      csv->fname = xmalloc(strlen(mpl_tab_get_arg(dca, 2))+1);
      strcpy(csv->fname, mpl_tab_get_arg(dca, 2));
      if (mode == 'R')
      {  /* open the file for reading */
         int k;
         csv->fp = fopen(csv->fname, "r");
         if (csv->fp == NULL)
         {  xprintf("csv_driver: unable to open %s - %s\n",
#if 0 /* 29/I-2017 */
               csv->fname, strerror(errno));
#else
               csv->fname, xstrerr(errno));
#endif
            longjmp(csv->jump, 0);
         }
#if 1 /* 01/VI-2010 */
         csv->nskip = 0;
#endif
         /* skip fake new-line */
         read_field(csv);
         xassert(csv->what == CSV_EOR);
         /* read field names */
         xassert(csv->nf == 0);
         for (;;)
         {  read_field(csv);
            if (csv->what == CSV_EOR)
               break;
            if (csv->what != CSV_STR)
            {  xprintf("%s:%d: invalid field name\n", csv->fname,
                  csv->count);
               longjmp(csv->jump, 0);
            }
            if (csv->nf == CSV_FIELD_MAX)
            {  xprintf("%s:%d: too many fields\n", csv->fname,
                  csv->count);
               longjmp(csv->jump, 0);
            }
            csv->nf++;
            /* find corresponding field in the table statement */
            for (k = mpl_tab_num_flds(dca); k >= 1; k--)
            {  if (strcmp(mpl_tab_get_name(dca, k), csv->field) == 0)
                  break;
            }
            csv->ref[csv->nf] = k;
         }
         /* find dummy RECNO field in the table statement */
         for (k = mpl_tab_num_flds(dca); k >= 1; k--)
            if (strcmp(mpl_tab_get_name(dca, k), "RECNO") == 0) break;
         csv->ref[0] = k;
      }
      else if (mode == 'W')
      {  /* open the file for writing */
         int k, nf;
         csv->fp = fopen(csv->fname, "w");
         if (csv->fp == NULL)
         {  xprintf("csv_driver: unable to create %s - %s\n",
#if 0 /* 29/I-2017 */
               csv->fname, strerror(errno));
#else
               csv->fname, xstrerr(errno));
#endif
            longjmp(csv->jump, 0);
         }
         /* write field names */
         nf = mpl_tab_num_flds(dca);
         for (k = 1; k <= nf; k++)
            fprintf(csv->fp, "%s%c", mpl_tab_get_name(dca, k),
               k < nf ? ',' : '\n');
         csv->count++;
      }
      else
         xassert(mode != mode);
      /* the file has been open */
      return csv;
fail: /* the file cannot be open */
      if (csv->fname != NULL) xfree(csv->fname);
      if (csv->fp != NULL) fclose(csv->fp);
      xfree(csv);
      return NULL;
}

static int csv_read_record(TABDCA *dca, struct csv *csv)
{     /* read next record from csv data file */
      int k, ret = 0;
      xassert(csv->mode == 'R');
      if (setjmp(csv->jump))
      {  ret = 1;
         goto done;
      }
      /* read dummy RECNO field */
      if (csv->ref[0] > 0)
#if 0 /* 01/VI-2010 */
         mpl_tab_set_num(dca, csv->ref[0], csv->count-1);
#else
         mpl_tab_set_num(dca, csv->ref[0], csv->count-csv->nskip-1);
#endif
      /* read fields */
      for (k = 1; k <= csv->nf; k++)
      {  read_field(csv);
         if (csv->what == CSV_EOF)
         {  /* end-of-file reached */
            xassert(k == 1);
            ret = -1;
            goto done;
         }
         else if (csv->what == CSV_EOR)
         {  /* end-of-record reached */
            int lack = csv->nf - k + 1;
            if (lack == 1)
               xprintf("%s:%d: one field missing\n", csv->fname,
                  csv->count);
            else
               xprintf("%s:%d: %d fields missing\n", csv->fname,
                  csv->count, lack);
            longjmp(csv->jump, 0);
         }
         else if (csv->what == CSV_NUM)
         {  /* floating-point number */
            if (csv->ref[k] > 0)
            {  double num;
               xassert(str2num(csv->field, &num) == 0);
               mpl_tab_set_num(dca, csv->ref[k], num);
            }
         }
         else if (csv->what == CSV_STR)
         {  /* character string */
            if (csv->ref[k] > 0)
               mpl_tab_set_str(dca, csv->ref[k], csv->field);
         }
         else
            xassert(csv != csv);
      }
      /* now there must be NL */
      read_field(csv);
      xassert(csv->what != CSV_EOF);
      if (csv->what != CSV_EOR)
      {  xprintf("%s:%d: too many fields\n", csv->fname, csv->count);
         longjmp(csv->jump, 0);
      }
done: return ret;
}

static int csv_write_record(TABDCA *dca, struct csv *csv)
{     /* write next record to csv data file */
      int k, nf, ret = 0;
      const char *c;
      xassert(csv->mode == 'W');
      nf = mpl_tab_num_flds(dca);
      for (k = 1; k <= nf; k++)
      {  switch (mpl_tab_get_type(dca, k))
         {  case 'N':
               fprintf(csv->fp, "%.*g", DBL_DIG,
                  mpl_tab_get_num(dca, k));
               break;
            case 'S':
               fputc('"', csv->fp);
               for (c = mpl_tab_get_str(dca, k); *c != '\0'; c++)
               {  if (*c == '"')
                     fputc('"', csv->fp), fputc('"', csv->fp);
                  else
                     fputc(*c, csv->fp);
               }
               fputc('"', csv->fp);
               break;
            default:
               xassert(dca != dca);
         }
         fputc(k < nf ? ',' : '\n', csv->fp);
      }
      csv->count++;
      if (ferror(csv->fp))
      {  xprintf("%s:%d: write error - %s\n", csv->fname, csv->count,
#if 0 /* 29/I-2017 */
            strerror(errno));
#else
            xstrerr(errno));
#endif
         ret = 1;
      }
      return ret;
}

static int csv_close_file(TABDCA *dca, struct csv *csv)
{     /* close csv data file */
      int ret = 0;
      xassert(dca == dca);
      if (csv->mode == 'W')
      {  fflush(csv->fp);
         if (ferror(csv->fp))
         {  xprintf("%s:%d: write error - %s\n", csv->fname,
#if 0 /* 29/I-2017 */
               csv->count, strerror(errno));
#else
               csv->count, xstrerr(errno));
#endif
            ret = 1;
         }
      }
      xfree(csv->fname);
      fclose(csv->fp);
      xfree(csv);
      return ret;
}

/**********************************************************************/

#define DBF_FIELD_MAX 50
/* maximal number of fields in record */

#define DBF_FDLEN_MAX 100
/* maximal field length */

struct dbf
{     /* xBASE data file */
      int mode;
      /* 'R' = reading; 'W' = writing */
      char *fname;
      /* name of xBASE file */
      FILE *fp;
      /* stream assigned to xBASE file */
      jmp_buf jump;
      /* address for non-local go to in case of error */
      int offset;
      /* offset of a byte to be read next */
      int count;
      /* record count */
      int nf;
      /* number of fields */
      int ref[1+DBF_FIELD_MAX];
      /* ref[k] = k', if k-th field of the csv file corresponds to
         k'-th field in the table statement; if ref[k] = 0, k-th field
         of the csv file is ignored */
      int type[1+DBF_FIELD_MAX];
      /* type[k] is type of k-th field */
      int len[1+DBF_FIELD_MAX];
      /* len[k] is length of k-th field */
      int prec[1+DBF_FIELD_MAX];
      /* prec[k] is precision of k-th field */
};

static int read_byte(struct dbf *dbf)
{     /* read byte from xBASE data file */
      int b;
      b = fgetc(dbf->fp);
      if (ferror(dbf->fp))
      {  xprintf("%s:0x%X: read error - %s\n", dbf->fname,
#if 0 /* 29/I-2017 */
            dbf->offset, strerror(errno));
#else
            dbf->offset, xstrerr(errno));
#endif
         longjmp(dbf->jump, 0);
      }
      if (feof(dbf->fp))
      {  xprintf("%s:0x%X: unexpected end of file\n", dbf->fname,
            dbf->offset);
         longjmp(dbf->jump, 0);
      }
      xassert(0x00 <= b && b <= 0xFF);
      dbf->offset++;
      return b;
}

static void read_header(TABDCA *dca, struct dbf *dbf)
{     /* read xBASE data file header */
      int b, j, k, recl;
      char name[10+1];
      /* (ignored) */
      for (j = 1; j <= 10; j++)
         read_byte(dbf);
      /* length of each record, in bytes */
      recl = read_byte(dbf);
      recl += read_byte(dbf) << 8;
      /* (ignored) */
      for (j = 1; j <= 20; j++)
         read_byte(dbf);
      /* field descriptor array */
      xassert(dbf->nf == 0);
      for (;;)
      {  /* check for end of array */
         b = read_byte(dbf);
         if (b == 0x0D) break;
         if (dbf->nf == DBF_FIELD_MAX)
         {  xprintf("%s:0x%X: too many fields\n", dbf->fname,
               dbf->offset);
            longjmp(dbf->jump, 0);
         }
         dbf->nf++;
         /* field name */
         name[0] = (char)b;
         for (j = 1; j < 10; j++)
         {  b = read_byte(dbf);
            name[j] = (char)b;
         }
         name[10] = '\0';
         b = read_byte(dbf);
         if (b != 0x00)
         {  xprintf("%s:0x%X: invalid field name\n", dbf->fname,
               dbf->offset);
            longjmp(dbf->jump, 0);
         }
         /* find corresponding field in the table statement */
         for (k = mpl_tab_num_flds(dca); k >= 1; k--)
            if (strcmp(mpl_tab_get_name(dca, k), name) == 0) break;
         dbf->ref[dbf->nf] = k;
         /* field type */
         b = read_byte(dbf);
         if (!(b == 'C' || b == 'N'))
         {  xprintf("%s:0x%X: invalid field type\n", dbf->fname,
               dbf->offset);
            longjmp(dbf->jump, 0);
         }
         dbf->type[dbf->nf] = b;
         /* (ignored) */
         for (j = 1; j <= 4; j++)
            read_byte(dbf);
         /* field length */
         b = read_byte(dbf);
         if (b == 0)
         {  xprintf("%s:0x%X: invalid field length\n", dbf->fname,
               dbf->offset);
            longjmp(dbf->jump, 0);
         }
         if (b > DBF_FDLEN_MAX)
         {  xprintf("%s:0x%X: field too long\n", dbf->fname,
               dbf->offset);
            longjmp(dbf->jump, 0);
         }
         dbf->len[dbf->nf] = b;
         recl -= b;
         /* (ignored) */
         for (j = 1; j <= 15; j++)
            read_byte(dbf);
      }
      if (recl != 1)
      {  xprintf("%s:0x%X: invalid file header\n", dbf->fname,
            dbf->offset);
         longjmp(dbf->jump, 0);
      }
      /* find dummy RECNO field in the table statement */
      for (k = mpl_tab_num_flds(dca); k >= 1; k--)
         if (strcmp(mpl_tab_get_name(dca, k), "RECNO") == 0) break;
      dbf->ref[0] = k;
      return;
}

static void parse_third_arg(TABDCA *dca, struct dbf *dbf)
{     /* parse xBASE file format (third argument) */
      int j, k, temp;
      const char *arg;
      dbf->nf = mpl_tab_num_flds(dca);
      arg = mpl_tab_get_arg(dca, 3), j = 0;
      for (k = 1; k <= dbf->nf; k++)
      {  /* parse specification of k-th field */
         if (arg[j] == '\0')
         {  xprintf("xBASE driver: field %s: specification missing\n",
               mpl_tab_get_name(dca, k));
            longjmp(dbf->jump, 0);
         }
         /* parse field type */
         if (arg[j] == 'C' || arg[j] == 'N')
            dbf->type[k] = arg[j], j++;
         else
         {  xprintf("xBASE driver: field %s: invalid field type\n",
               mpl_tab_get_name(dca, k));
            longjmp(dbf->jump, 0);
         }
         /* check for left parenthesis */
         if (arg[j] == '(')
            j++;
         else
err:     {  xprintf("xBASE driver: field %s: invalid field format\n",
               mpl_tab_get_name(dca, k));
            longjmp(dbf->jump, 0);
         }
         /* parse field length */
         temp = 0;
         while (isdigit(arg[j]))
         {  if (temp > DBF_FDLEN_MAX) break;
            temp = 10 * temp + (arg[j] - '0'), j++;
         }
         if (!(1 <= temp && temp <= DBF_FDLEN_MAX))
         {  xprintf("xBASE driver: field %s: invalid field length\n",
               mpl_tab_get_name(dca, k));
            longjmp(dbf->jump, 0);
         }
         dbf->len[k] = temp;
         /* parse optional field precision */
         if (dbf->type[k] == 'N' && arg[j] == ',')
         {  j++;
            temp = 0;
            while (isdigit(arg[j]))
            {  if (temp > dbf->len[k]) break;
               temp = 10 * temp + (arg[j] - '0'), j++;
            }
            if (temp > dbf->len[k])
            {  xprintf("xBASE driver: field %s: invalid field precision"
                  "\n", mpl_tab_get_name(dca, k));
               longjmp(dbf->jump, 0);
            }
            dbf->prec[k] = temp;
         }
         else
            dbf->prec[k] = 0;
         /* check for right parenthesis */
         if (arg[j] == ')')
            j++;
         else
            goto err;
      }
      /* ignore other specifications */
      return;
}

static void write_byte(struct dbf *dbf, int b)
{     /* write byte to xBASE data file */
      fputc(b, dbf->fp);
      dbf->offset++;
      return;
}

static void write_header(TABDCA *dca, struct dbf *dbf)
{     /* write xBASE data file header */
      int j, k, temp;
      const char *name;
      /* version number */
      write_byte(dbf, 0x03 /* file without DBT */);
      /* date of last update (YYMMDD) */
      write_byte(dbf, 70 /* 1970 */);
      write_byte(dbf, 1 /* January */);
      write_byte(dbf, 1 /* 1st */);
      /* number of records (unknown so far) */
      for (j = 1; j <= 4; j++)
         write_byte(dbf, 0xFF);
      /* length of the header, in bytes */
      temp = 32 + dbf->nf * 32 + 1;
      write_byte(dbf, temp);
      write_byte(dbf, temp >> 8);
      /* length of each record, in bytes */
      temp = 1;
      for (k = 1; k <= dbf->nf; k++)
         temp += dbf->len[k];
      write_byte(dbf, temp);
      write_byte(dbf, temp >> 8);
      /* (reserved) */
      for (j = 1; j <= 20; j++)
         write_byte(dbf, 0x00);
      /* field descriptor array */
      for (k = 1; k <= dbf->nf; k++)
      {  /* field name (terminated by 0x00) */
         name = mpl_tab_get_name(dca, k);
         for (j = 0; j < 10 && name[j] != '\0'; j++)
            write_byte(dbf, name[j]);
         for (j = j; j < 11; j++)
            write_byte(dbf, 0x00);
         /* field type */
         write_byte(dbf, dbf->type[k]);
         /* (reserved) */
         for (j = 1; j <= 4; j++)
            write_byte(dbf, 0x00);
         /* field length */
         write_byte(dbf, dbf->len[k]);
         /* field precision */
         write_byte(dbf, dbf->prec[k]);
         /* (reserved) */
         for (j = 1; j <= 14; j++)
            write_byte(dbf, 0x00);
      }
      /* end of header */
      write_byte(dbf, 0x0D);
      return;
}

static struct dbf *dbf_open_file(TABDCA *dca, int mode)
{     /* open xBASE data file */
      struct dbf *dbf;
      /* create control structure */
      dbf = xmalloc(sizeof(struct dbf));
      dbf->mode = mode;
      dbf->fname = NULL;
      dbf->fp = NULL;
      if (setjmp(dbf->jump)) goto fail;
      dbf->offset = 0;
      dbf->count = 0;
      dbf->nf = 0;
      /* try to open the xBASE data file */
      if (mpl_tab_num_args(dca) < 2)
      {  xprintf("xBASE driver: file name not specified\n");
         longjmp(dbf->jump, 0);
      }
      dbf->fname = xmalloc(strlen(mpl_tab_get_arg(dca, 2))+1);
      strcpy(dbf->fname, mpl_tab_get_arg(dca, 2));
      if (mode == 'R')
      {  /* open the file for reading */
         dbf->fp = fopen(dbf->fname, "rb");
         if (dbf->fp == NULL)
         {  xprintf("xBASE driver: unable to open %s - %s\n",
#if 0 /* 29/I-2017 */
               dbf->fname, strerror(errno));
#else
               dbf->fname, xstrerr(errno));
#endif
            longjmp(dbf->jump, 0);
         }
         read_header(dca, dbf);
      }
      else if (mode == 'W')
      {  /* open the file for writing */
         if (mpl_tab_num_args(dca) < 3)
         {  xprintf("xBASE driver: file format not specified\n");
            longjmp(dbf->jump, 0);
         }
         parse_third_arg(dca, dbf);
         dbf->fp = fopen(dbf->fname, "wb");
         if (dbf->fp == NULL)
         {  xprintf("xBASE driver: unable to create %s - %s\n",
#if 0 /* 29/I-2017 */
               dbf->fname, strerror(errno));
#else
               dbf->fname, xstrerr(errno));
#endif
            longjmp(dbf->jump, 0);
         }
         write_header(dca, dbf);
      }
      else
         xassert(mode != mode);
      /* the file has been open */
      return dbf;
fail: /* the file cannot be open */
      if (dbf->fname != NULL) xfree(dbf->fname);
      if (dbf->fp != NULL) fclose(dbf->fp);
      xfree(dbf);
      return NULL;
}

static int dbf_read_record(TABDCA *dca, struct dbf *dbf)
{     /* read next record from xBASE data file */
      int b, j, k, ret = 0;
      char buf[DBF_FDLEN_MAX+1];
      xassert(dbf->mode == 'R');
      if (setjmp(dbf->jump))
      {  ret = 1;
         goto done;
      }
      /* check record flag */
      b = read_byte(dbf);
      if (b == 0x1A)
      {  /* end of data */
         ret = -1;
         goto done;
      }
      if (b != 0x20)
      {  xprintf("%s:0x%X: invalid record flag\n", dbf->fname,
            dbf->offset);
         longjmp(dbf->jump, 0);
      }
      /* read dummy RECNO field */
      if (dbf->ref[0] > 0)
         mpl_tab_set_num(dca, dbf->ref[0], dbf->count+1);
      /* read fields */
      for (k = 1; k <= dbf->nf; k++)
      {  /* read k-th field */
         for (j = 0; j < dbf->len[k]; j++)
            buf[j] = (char)read_byte(dbf);
         buf[dbf->len[k]] = '\0';
         /* set field value */
         if (dbf->type[k] == 'C')
         {  /* character field */
            if (dbf->ref[k] > 0)
               mpl_tab_set_str(dca, dbf->ref[k], strtrim(buf));
         }
         else if (dbf->type[k] == 'N')
         {  /* numeric field */
            if (dbf->ref[k] > 0)
            {  double num;
               strspx(buf);
               xassert(str2num(buf, &num) == 0);
               mpl_tab_set_num(dca, dbf->ref[k], num);
            }
         }
         else
            xassert(dbf != dbf);
      }
      /* increase record count */
      dbf->count++;
done: return ret;
}

static int dbf_write_record(TABDCA *dca, struct dbf *dbf)
{     /* write next record to xBASE data file */
      int j, k, ret = 0;
      char buf[255+1];
      xassert(dbf->mode == 'W');
      if (setjmp(dbf->jump))
      {  ret = 1;
         goto done;
      }
      /* record flag */
      write_byte(dbf, 0x20);
      xassert(dbf->nf == mpl_tab_num_flds(dca));
      for (k = 1; k <= dbf->nf; k++)
      {  if (dbf->type[k] == 'C')
         {  /* character field */
            const char *str;
            if (mpl_tab_get_type(dca, k) == 'N')
            {  sprintf(buf, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));
               str = buf;
            }
            else if (mpl_tab_get_type(dca, k) == 'S')
               str = mpl_tab_get_str(dca, k);
            else
               xassert(dca != dca);
            if ((int)strlen(str) > dbf->len[k])
            {  xprintf("xBASE driver: field %s: cannot convert %.15s..."
                  " to field format\n", mpl_tab_get_name(dca, k), str);
               longjmp(dbf->jump, 0);
            }
            for (j = 0; j < dbf->len[k] && str[j] != '\0'; j++)
                write_byte(dbf, str[j]);
            for (j = j; j < dbf->len[k]; j++)
                write_byte(dbf, ' ');
         }
         else if (dbf->type[k] == 'N')
         {  /* numeric field */
            double num = mpl_tab_get_num(dca, k);
            if (fabs(num) > 1e20)
err:        {  xprintf("xBASE driver: field %s: cannot convert %g to fi"
                  "eld format\n", mpl_tab_get_name(dca, k), num);
               longjmp(dbf->jump, 0);
            }
            sprintf(buf, "%*.*f", dbf->len[k], dbf->prec[k], num);
            xassert(strlen(buf) < sizeof(buf));
            if ((int)strlen(buf) != dbf->len[k]) goto err;
            for (j = 0; j < dbf->len[k]; j++)
               write_byte(dbf, buf[j]);
         }
         else
            xassert(dbf != dbf);
      }
      /* increase record count */
      dbf->count++;
done: return ret;
}

static int dbf_close_file(TABDCA *dca, struct dbf *dbf)
{     /* close xBASE data file */
      int ret = 0;
      xassert(dca == dca);
      if (dbf->mode == 'W')
      {  if (setjmp(dbf->jump))
         {  ret = 1;
            goto skip;
         }
         /* end-of-file flag */
         write_byte(dbf, 0x1A);
         /* number of records */
         dbf->offset = 4;
         if (fseek(dbf->fp, dbf->offset, SEEK_SET))
         {  xprintf("%s:0x%X: seek error - %s\n", dbf->fname,
#if 0 /* 29/I-2017 */
               dbf->offset, strerror(errno));
#else
               dbf->offset, xstrerr(errno));
#endif
            longjmp(dbf->jump, 0);
         }
         write_byte(dbf, dbf->count);
         write_byte(dbf, dbf->count >> 8);
         write_byte(dbf, dbf->count >> 16);
         write_byte(dbf, dbf->count >> 24);
         fflush(dbf->fp);
         if (ferror(dbf->fp))
         {  xprintf("%s:0x%X: write error - %s\n", dbf->fname,
#if 0 /* 29/I-2017 */
               dbf->offset, strerror(errno));
#else
               dbf->offset, xstrerr(errno));
#endif
            longjmp(dbf->jump, 0);
         }
skip:    ;
      }
      xfree(dbf->fname);
      fclose(dbf->fp);
      xfree(dbf);
      return ret;
}

/**********************************************************************/

#define TAB_CSV   1
#define TAB_XBASE 2
#define TAB_ODBC  3
#define TAB_MYSQL 4

void mpl_tab_drv_open(MPL *mpl, int mode)
{     TABDCA *dca = mpl->dca;
      xassert(dca->id == 0);
      xassert(dca->link == NULL);
      xassert(dca->na >= 1);
      if (strcmp(dca->arg[1], "CSV") == 0)
      {  dca->id = TAB_CSV;
         dca->link = csv_open_file(dca, mode);
      }
      else if (strcmp(dca->arg[1], "xBASE") == 0)
      {  dca->id = TAB_XBASE;
         dca->link = dbf_open_file(dca, mode);
      }
      else if (strcmp(dca->arg[1], "ODBC") == 0 ||
               strcmp(dca->arg[1], "iODBC") == 0)
      {  dca->id = TAB_ODBC;
         dca->link = db_iodbc_open(dca, mode);
      }
      else if (strcmp(dca->arg[1], "MySQL") == 0)
      {  dca->id = TAB_MYSQL;
         dca->link = db_mysql_open(dca, mode);
      }
      else
         xprintf("Invalid table driver '%s'\n", dca->arg[1]);
      if (dca->link == NULL)
         error(mpl, "error on opening table %s",
            mpl->stmt->u.tab->name);
      return;
}

int mpl_tab_drv_read(MPL *mpl)
{     TABDCA *dca = mpl->dca;
      int ret;
      switch (dca->id)
      {  case TAB_CSV:
            ret = csv_read_record(dca, dca->link);
            break;
         case TAB_XBASE:
            ret = dbf_read_record(dca, dca->link);
            break;
         case TAB_ODBC:
            ret = db_iodbc_read(dca, dca->link);
            break;
         case TAB_MYSQL:
            ret = db_mysql_read(dca, dca->link);
            break;
         default:
            xassert(dca != dca);
      }
      if (ret > 0)
         error(mpl, "error on reading data from table %s",
            mpl->stmt->u.tab->name);
      return ret;
}

void mpl_tab_drv_write(MPL *mpl)
{     TABDCA *dca = mpl->dca;
      int ret;
      switch (dca->id)
      {  case TAB_CSV:
            ret = csv_write_record(dca, dca->link);
            break;
         case TAB_XBASE:
            ret = dbf_write_record(dca, dca->link);
            break;
         case TAB_ODBC:
            ret = db_iodbc_write(dca, dca->link);
            break;
         case TAB_MYSQL:
            ret = db_mysql_write(dca, dca->link);
            break;
         default:
            xassert(dca != dca);
      }
      if (ret)
         error(mpl, "error on writing data to table %s",
            mpl->stmt->u.tab->name);
      return;
}

void mpl_tab_drv_close(MPL *mpl)
{     TABDCA *dca = mpl->dca;
      int ret;
      switch (dca->id)
      {  case TAB_CSV:
            ret = csv_close_file(dca, dca->link);
            break;
         case TAB_XBASE:
            ret = dbf_close_file(dca, dca->link);
            break;
         case TAB_ODBC:
            ret = db_iodbc_close(dca, dca->link);
            break;
         case TAB_MYSQL:
            ret = db_mysql_close(dca, dca->link);
            break;
         default:
            xassert(dca != dca);
      }
      dca->id = 0;
      dca->link = NULL;
      if (ret)
         error(mpl, "error on closing table %s",
            mpl->stmt->u.tab->name);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mplsql.c0000644000175100001710000013312200000000000024352 0ustar00runnerdocker00000000000000/* mplsql.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2017 Free Software Foundation, Inc.
*  Written by Heinrich Schuchardt .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include 
#endif

#include "mpl.h"
#include "mplsql.h"

#ifdef ODBC_DLNAME
#define HAVE_ODBC
#define libodbc ODBC_DLNAME
#define h_odbc (get_env_ptr()->h_odbc)
#endif

#ifdef MYSQL_DLNAME
#define HAVE_MYSQL
#define libmysql MYSQL_DLNAME
#define h_mysql (get_env_ptr()->h_mysql)
#endif

static void *db_iodbc_open_int(TABDCA *dca, int mode, const char
      **sqllines);
static void *db_mysql_open_int(TABDCA *dca, int mode, const char
      **sqllines);

/**********************************************************************/

#if defined(HAVE_ODBC) || defined(HAVE_MYSQL)

#define SQL_FIELD_MAX 100
/* maximal field count */

#define SQL_FDLEN_MAX 255
/* maximal field length */

/***********************************************************************
*  NAME
*
*  args_concat - concatenate arguments
*
*  SYNOPSIS
*
*  static char **args_concat(TABDCA *dca);
*
*  DESCRIPTION
*
*  The arguments passed in dca are SQL statements. A SQL statement may
*  be split over multiple arguments. The last argument of a SQL
*  statement will be terminated with a semilocon. Each SQL statement is
*  merged into a single zero terminated string. Boundaries between
*  arguments are replaced by space.
*
*  RETURNS
*
*  Buffer with SQL statements */

static char **args_concat(TABDCA *dca)
{
   const char  *arg;
   int          i;
   int          j;
   int          j0;
   int          j1;
   size_t       len;
   int          lentot;
   int          narg;
   int          nline = 0;
   char       **sqllines = NULL;

   narg = mpl_tab_num_args(dca);
   /* The SQL statements start with argument 3. */
   if (narg < 3)
      return NULL;
   /* Count the SQL statements */
   for (j = 3; j <= narg; j++)
   {
      arg = mpl_tab_get_arg(dca, j);
      len = strlen(arg);
      if (arg[len-1] == ';' || j == narg)
        nline ++;
   }
   /* Allocate string buffer. */
   sqllines = (char **) xmalloc((nline+1) * sizeof(char **));
   /* Join arguments */
   sqllines[0] = NULL;
   j0     = 3;
   i      = 0;
   lentot = 0;
   for (j = 3; j <= narg; j++)
   {
      arg = mpl_tab_get_arg(dca, j);
      len = strlen(arg);
      /* add length of part */
      lentot += len;
      /* add length of space separating parts or 0x00 at end of SQL
         statement */
      lentot++;
      if (arg[len-1] == ';' || j == narg)
      {  /* Join arguments for a single SQL statement */
         sqllines[i] = xmalloc(lentot);
         sqllines[i+1] = NULL;
         sqllines[i][0] = 0x00;
         for (j1 = j0; j1 <= j; j1++)
         {  if(j1>j0)
               strcat(sqllines[i], " ");
            strcat(sqllines[i], mpl_tab_get_arg(dca, j1));
         }
         len = strlen(sqllines[i]);
         if (sqllines[i][len-1] == ';')
            sqllines[i][len-1] = 0x00;
         j0 = j+1;
         i++;
         lentot = 0;
      }
   }
   return sqllines;
}

/***********************************************************************
*  NAME
*
*  free_buffer - free multiline string buffer
*
*  SYNOPSIS
*
*  static void free_buffer(char **buf);
*
*  DESCRIPTION
*
*  buf is a list of strings terminated by NULL.
*  The memory for the strings and for the list is released. */

static void free_buffer(char **buf)
{  int i;

   for(i = 0; buf[i] != NULL; i++)
      xfree(buf[i]);
   xfree(buf);
}

static int db_escaped_string_length(const char* from)
/* length of escaped string */
{
   int         count;
   const char *pointer;

    for (pointer = from, count = 0; *pointer != (char) '\0'; pointer++,
         count++)
    {
      switch (*pointer)
      {
         case '\'':
            count++;
            break;
      }
    }

    return count;
}

static void db_escape_string (char *to, const char *from)
/* escape string*/
{
   const char *source = from;
   char *target = to;
   size_t remaining;

   remaining = strlen(from);

   if (to == NULL)
     to = (char *) (from + remaining);

   while (remaining > 0)
   {
      switch (*source)
      {
         case '\'':
            *target = '\'';
            target++;
            *target = '\'';
            break;

         default:
            *target = *source;
            }
      source++;
      target++;
      remaining--;
      }

   /* Write the terminating NUL character. */
   *target = '\0';
}

static char *db_generate_select_stmt(TABDCA *dca)
/* generate select statement */
{
   char        *arg;
   char const  *field;
   char        *query;
   int          j;
   int          narg;
   int          nf;
   int          total;

   total = 50;
   nf = mpl_tab_num_flds(dca);
   narg = mpl_tab_num_args(dca);
   for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
   {
      field = mpl_tab_get_name(dca, j);
      total += strlen(field);
      total += 2;
   }
   arg = (char *) mpl_tab_get_arg(dca, narg);
   total += strlen(arg);
   query = xmalloc( total * sizeof(char));
   strcpy (query, "SELECT ");
   for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
   {
      field = mpl_tab_get_name(dca, j);
      strcat(query, field);
      if ( j < nf )
         strcat(query, ", ");
   }
   strcat(query, " FROM ");
   strcat(query, arg);
   return query;
}

static char *db_generate_insert_stmt(TABDCA *dca)
/* generate insert statement */
{
   char        *arg;
   char const  *field;
   char        *query;
   int          j;
   int          narg;
   int          nf;
   int          total;

   total = 50;
   nf = mpl_tab_num_flds(dca);
   narg = mpl_tab_num_args(dca);
   for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
   {
      field = mpl_tab_get_name(dca, j);
      total += strlen(field);
      total += 5;
   }
   arg = (char *) mpl_tab_get_arg(dca, narg);
   total += strlen(arg);
   query = xmalloc( (total+1) * sizeof(char));
   strcpy (query, "INSERT INTO ");
   strcat(query, arg);
   strcat(query, " ( ");
   for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
   {
      field = mpl_tab_get_name(dca, j);
      strcat(query, field);
      if ( j < nf )
         strcat(query, ", ");
   }
   strcat(query, " ) VALUES ( ");
   for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
   {
      strcat(query, "?");
      if ( j < nf )
         strcat(query, ", ");
   }
   strcat(query, " )");
   return query;
}

#endif

/**********************************************************************/

#ifndef HAVE_ODBC

void *db_iodbc_open(TABDCA *dca, int mode)
{     xassert(dca == dca);
      xassert(mode == mode);
      xprintf("iODBC table driver not supported\n");
      return NULL;
}

int db_iodbc_read(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

int db_iodbc_write(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

int db_iodbc_close(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

#else

#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__WOE__)
#include 
#endif

#include 
#include 

struct db_odbc
{
   int              mode;         /*'R' = Read, 'W' = Write*/
   SQLHDBC          hdbc;         /*connection handle*/
   SQLHENV          henv;         /*environment handle*/
   SQLHSTMT         hstmt;        /*statement handle*/
   SQLSMALLINT      nresultcols;  /* columns in result*/
   SQLULEN          collen[SQL_FIELD_MAX+1];
   SQLLEN           outlen[SQL_FIELD_MAX+1];
   SQLSMALLINT      coltype[SQL_FIELD_MAX+1];
   SQLCHAR          data[SQL_FIELD_MAX+1][SQL_FDLEN_MAX+1];
#if 1 /* 12/I-2014 */
   SQLDOUBLE        datanum[SQL_FIELD_MAX+1];
#endif
   SQLCHAR          colname[SQL_FIELD_MAX+1][SQL_FDLEN_MAX+1];
   int              isnumeric[SQL_FIELD_MAX+1];
   int              nf;
   /* number of fields in the csv file */
   int              ref[1+SQL_FIELD_MAX];
   /* ref[k] = k', if k-th field of the csv file corresponds to
      k'-th field in the table statement; if ref[k] = 0, k-th field
      of the csv file is ignored */
   SQLCHAR         *query;
   /* query generated by db_iodbc_open */
};

SQLRETURN SQL_API dl_SQLAllocHandle (
   SQLSMALLINT           HandleType,
   SQLHANDLE             InputHandle,
   SQLHANDLE            *OutputHandle)
{
      typedef SQLRETURN SQL_API ep_SQLAllocHandle(
         SQLSMALLINT           HandleType,
         SQLHANDLE             InputHandle,
         SQLHANDLE            *OutputHandle);

      ep_SQLAllocHandle *fn;
      fn = (ep_SQLAllocHandle *) xdlsym(h_odbc, "SQLAllocHandle");
      xassert(fn != NULL);
      return (*fn)(HandleType, InputHandle, OutputHandle);
}

SQLRETURN SQL_API dl_SQLBindCol (
   SQLHSTMT              StatementHandle,
   SQLUSMALLINT          ColumnNumber,
   SQLSMALLINT           TargetType,
   SQLPOINTER            TargetValue,
   SQLLEN                BufferLength,
   SQLLEN               *StrLen_or_Ind)
{
      typedef SQLRETURN SQL_API ep_SQLBindCol(
         SQLHSTMT              StatementHandle,
         SQLUSMALLINT          ColumnNumber,
         SQLSMALLINT           TargetType,
         SQLPOINTER            TargetValue,
         SQLLEN                BufferLength,
         SQLLEN               *StrLen_or_Ind);
      ep_SQLBindCol *fn;
      fn = (ep_SQLBindCol *) xdlsym(h_odbc, "SQLBindCol");
      xassert(fn != NULL);
      return (*fn)(StatementHandle, ColumnNumber, TargetType,
         TargetValue, BufferLength, StrLen_or_Ind);
}

SQLRETURN SQL_API dl_SQLCloseCursor (
   SQLHSTMT              StatementHandle)
{
      typedef SQLRETURN SQL_API ep_SQLCloseCursor (
         SQLHSTMT              StatementHandle);

      ep_SQLCloseCursor *fn;
      fn = (ep_SQLCloseCursor *) xdlsym(h_odbc, "SQLCloseCursor");
      xassert(fn != NULL);
      return (*fn)(StatementHandle);
}


SQLRETURN SQL_API dl_SQLDisconnect (
   SQLHDBC               ConnectionHandle)
{
      typedef SQLRETURN SQL_API ep_SQLDisconnect(
         SQLHDBC               ConnectionHandle);

      ep_SQLDisconnect *fn;
      fn = (ep_SQLDisconnect *) xdlsym(h_odbc, "SQLDisconnect");
      xassert(fn != NULL);
      return (*fn)(ConnectionHandle);
}

SQLRETURN SQL_API dl_SQLDriverConnect (
   SQLHDBC               hdbc,
   SQLHWND               hwnd,
   SQLCHAR              *szConnStrIn,
   SQLSMALLINT           cbConnStrIn,
   SQLCHAR              *szConnStrOut,
   SQLSMALLINT           cbConnStrOutMax,
   SQLSMALLINT          *pcbConnStrOut,
   SQLUSMALLINT          fDriverCompletion)
{
      typedef SQLRETURN SQL_API ep_SQLDriverConnect(
         SQLHDBC               hdbc,
         SQLHWND               hwnd,
         SQLCHAR             * szConnStrIn,
         SQLSMALLINT           cbConnStrIn,
         SQLCHAR             * szConnStrOut,
         SQLSMALLINT           cbConnStrOutMax,
         SQLSMALLINT         * pcbConnStrOut,
         SQLUSMALLINT          fDriverCompletion);

      ep_SQLDriverConnect *fn;
      fn = (ep_SQLDriverConnect *) xdlsym(h_odbc, "SQLDriverConnect");
      xassert(fn != NULL);
      return (*fn)(hdbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut,
         cbConnStrOutMax, pcbConnStrOut, fDriverCompletion);
}

SQLRETURN SQL_API dl_SQLEndTran (
   SQLSMALLINT           HandleType,
   SQLHANDLE             Handle,
   SQLSMALLINT           CompletionType)
{
      typedef SQLRETURN SQL_API ep_SQLEndTran (
         SQLSMALLINT           HandleType,
         SQLHANDLE             Handle,
         SQLSMALLINT           CompletionType);

      ep_SQLEndTran *fn;
      fn = (ep_SQLEndTran *) xdlsym(h_odbc, "SQLEndTran");
      xassert(fn != NULL);
      return (*fn)(HandleType, Handle, CompletionType);
}

SQLRETURN SQL_API dl_SQLExecDirect (
   SQLHSTMT              StatementHandle,
   SQLCHAR             * StatementText,
   SQLINTEGER            TextLength)
{
      typedef SQLRETURN SQL_API ep_SQLExecDirect (
         SQLHSTMT              StatementHandle,
         SQLCHAR             * StatementText,
         SQLINTEGER            TextLength);

      ep_SQLExecDirect *fn;
      fn = (ep_SQLExecDirect *) xdlsym(h_odbc, "SQLExecDirect");
      xassert(fn != NULL);
      return (*fn)(StatementHandle, StatementText, TextLength);
}

SQLRETURN SQL_API dl_SQLFetch (
   SQLHSTMT              StatementHandle)
{
      typedef SQLRETURN SQL_API ep_SQLFetch (
         SQLHSTMT              StatementHandle);

      ep_SQLFetch *fn;
      fn = (ep_SQLFetch*) xdlsym(h_odbc, "SQLFetch");
      xassert(fn != NULL);
      return (*fn)(StatementHandle);
}

SQLRETURN SQL_API dl_SQLFreeHandle (
   SQLSMALLINT           HandleType,
   SQLHANDLE             Handle)
{
      typedef SQLRETURN SQL_API ep_SQLFreeHandle (
         SQLSMALLINT           HandleType,
         SQLHANDLE             Handle);

      ep_SQLFreeHandle *fn;
      fn = (ep_SQLFreeHandle *) xdlsym(h_odbc, "SQLFreeHandle");
      xassert(fn != NULL);
      return (*fn)(HandleType, Handle);
}

SQLRETURN SQL_API dl_SQLDescribeCol (
   SQLHSTMT              StatementHandle,
   SQLUSMALLINT          ColumnNumber,
   SQLCHAR             * ColumnName,
   SQLSMALLINT           BufferLength,
   SQLSMALLINT         * NameLength,
   SQLSMALLINT         * DataType,
   SQLULEN             * ColumnSize,
   SQLSMALLINT         * DecimalDigits,
   SQLSMALLINT         * Nullable)
{
      typedef SQLRETURN SQL_API ep_SQLDescribeCol (
         SQLHSTMT              StatementHandle,
         SQLUSMALLINT          ColumnNumber,
         SQLCHAR              *ColumnName,
         SQLSMALLINT           BufferLength,
         SQLSMALLINT          *NameLength,
         SQLSMALLINT          *DataType,
         SQLULEN              *ColumnSize,
         SQLSMALLINT          *DecimalDigits,
         SQLSMALLINT          *Nullable);

      ep_SQLDescribeCol *fn;
      fn = (ep_SQLDescribeCol *) xdlsym(h_odbc, "SQLDescribeCol");
      xassert(fn != NULL);
      return (*fn)(StatementHandle, ColumnNumber, ColumnName,
         BufferLength, NameLength,
         DataType, ColumnSize, DecimalDigits, Nullable);
}

SQLRETURN SQL_API dl_SQLGetDiagRec (
   SQLSMALLINT           HandleType,
   SQLHANDLE             Handle,
   SQLSMALLINT           RecNumber,
   SQLCHAR              *Sqlstate,
   SQLINTEGER           *NativeError,
   SQLCHAR              *MessageText,
   SQLSMALLINT           BufferLength,
   SQLSMALLINT          *TextLength)
{
      typedef SQLRETURN SQL_API ep_SQLGetDiagRec (
         SQLSMALLINT           HandleType,
         SQLHANDLE             Handle,
         SQLSMALLINT           RecNumber,
         SQLCHAR              *Sqlstate,
         SQLINTEGER           *NativeError,
         SQLCHAR              *MessageText,
         SQLSMALLINT           BufferLength,
         SQLSMALLINT          *TextLength);

      ep_SQLGetDiagRec *fn;
      fn = (ep_SQLGetDiagRec *) xdlsym(h_odbc, "SQLGetDiagRec");
      xassert(fn != NULL);
      return (*fn)(HandleType, Handle, RecNumber, Sqlstate,
         NativeError, MessageText, BufferLength, TextLength);
}

SQLRETURN SQL_API dl_SQLGetInfo (
   SQLHDBC               ConnectionHandle,
   SQLUSMALLINT          InfoType,
   SQLPOINTER            InfoValue,
   SQLSMALLINT           BufferLength,
   SQLSMALLINT          *StringLength)
{
      typedef SQLRETURN SQL_API ep_SQLGetInfo (
         SQLHDBC               ConnectionHandle,
         SQLUSMALLINT          InfoType,
         SQLPOINTER            InfoValue,
         SQLSMALLINT           BufferLength,
         SQLSMALLINT          *StringLength);

      ep_SQLGetInfo *fn;
      fn = (ep_SQLGetInfo *) xdlsym(h_odbc, "SQLGetInfo");
      xassert(fn != NULL);
      return (*fn)(ConnectionHandle, InfoType, InfoValue, BufferLength,
         StringLength);
}

SQLRETURN SQL_API dl_SQLNumResultCols (
   SQLHSTMT              StatementHandle,
   SQLSMALLINT          *ColumnCount)
{
      typedef SQLRETURN SQL_API ep_SQLNumResultCols (
         SQLHSTMT              StatementHandle,
         SQLSMALLINT          *ColumnCount);

      ep_SQLNumResultCols *fn;
      fn = (ep_SQLNumResultCols *) xdlsym(h_odbc, "SQLNumResultCols");
      xassert(fn != NULL);
      return (*fn)(StatementHandle, ColumnCount);
}

SQLRETURN SQL_API dl_SQLSetConnectAttr (
   SQLHDBC               ConnectionHandle,
   SQLINTEGER            Attribute,
   SQLPOINTER            Value,
   SQLINTEGER            StringLength)
{
      typedef SQLRETURN SQL_API ep_SQLSetConnectAttr (
         SQLHDBC               ConnectionHandle,
         SQLINTEGER            Attribute,
         SQLPOINTER            Value,
         SQLINTEGER            StringLength);

      ep_SQLSetConnectAttr *fn;
     fn = (ep_SQLSetConnectAttr *) xdlsym(h_odbc, "SQLSetConnectAttr");
      xassert(fn != NULL);
      return (*fn)(ConnectionHandle, Attribute, Value, StringLength);
}

SQLRETURN SQL_API dl_SQLSetEnvAttr (
   SQLHENV               EnvironmentHandle,
   SQLINTEGER            Attribute,
   SQLPOINTER            Value,
   SQLINTEGER            StringLength)
{
      typedef SQLRETURN SQL_API ep_SQLSetEnvAttr (
         SQLHENV               EnvironmentHandle,
         SQLINTEGER            Attribute,
         SQLPOINTER            Value,
         SQLINTEGER            StringLength);

      ep_SQLSetEnvAttr *fn;
      fn = (ep_SQLSetEnvAttr *) xdlsym(h_odbc, "SQLSetEnvAttr");
      xassert(fn != NULL);
      return (*fn)(EnvironmentHandle, Attribute, Value, StringLength);
}

static void extract_error(
   char *fn,
   SQLHANDLE handle,
   SQLSMALLINT type);

static int is_numeric(
    SQLSMALLINT coltype);

/***********************************************************************
*  NAME
*
*  db_iodbc_open - open connection to ODBC data base
*
*  SYNOPSIS
*
*  #include "mplsql.h"
*  void *db_iodbc_open(TABDCA *dca, int mode);
*
*  DESCRIPTION
*
*  The routine db_iodbc_open opens a connection to an ODBC data base.
*  It then executes the sql statements passed.
*
*  In the case of table read the SELECT statement is executed.
*
*  In the case of table write the INSERT statement is prepared.
*  RETURNS
*
*  The routine returns a pointer to data storage area created. */
void *db_iodbc_open(TABDCA *dca, int mode)
{  void  *ret;
   char **sqllines;

   sqllines = args_concat(dca);
   if (sqllines == NULL)
   {  xprintf("Missing arguments in table statement.\n"
              "Please, supply table driver, dsn, and query.\n");
      return NULL;
   }
   ret = db_iodbc_open_int(dca, mode, (const char **) sqllines);
   free_buffer(sqllines);
   return ret;
}

static void *db_iodbc_open_int(TABDCA *dca, int mode, const char
   **sqllines)
{
   struct db_odbc    *sql;
   SQLRETURN          ret;
   SQLCHAR FAR       *dsn;
   SQLCHAR            info[256];
   SQLSMALLINT        colnamelen;
   SQLSMALLINT        nullable;
   SQLSMALLINT        scale;
   const char        *arg;
   int                narg;
   int                i, j;
   int                total;

   if (libodbc == NULL)
   {
      xprintf("No loader for shared ODBC library available\n");
      return NULL;
   }

   if (h_odbc == NULL)
   {
      h_odbc = xdlopen(libodbc);
      if (h_odbc == NULL)
      {  xprintf("unable to open library %s\n", libodbc);
         xprintf("%s\n", get_err_msg());
         return NULL;
      }
   }

   sql = (struct db_odbc *) xmalloc(sizeof(struct db_odbc));
   if (sql == NULL)
         return NULL;

   sql->mode  = mode;
   sql->hdbc  = NULL;
   sql->henv  = NULL;
   sql->hstmt = NULL;
   sql->query = NULL;
   narg = mpl_tab_num_args(dca);

   dsn = (SQLCHAR FAR *) mpl_tab_get_arg(dca, 2);
   /* allocate an environment handle */
   ret = dl_SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
      &(sql->henv));
   /* set attribute to enable application to run as ODBC 3.0
      application */
   ret = dl_SQLSetEnvAttr(sql->henv, SQL_ATTR_ODBC_VERSION,
      (void *) SQL_OV_ODBC3, 0);
   /* allocate a connection handle */
   ret = dl_SQLAllocHandle(SQL_HANDLE_DBC, sql->henv, &(sql->hdbc));
   /* connect */
   ret = dl_SQLDriverConnect(sql->hdbc, NULL, dsn, SQL_NTS, NULL, 0,
      NULL, SQL_DRIVER_COMPLETE);
   if (SQL_SUCCEEDED(ret))
   {  /* output information about data base connection */
      xprintf("Connected to ");
      dl_SQLGetInfo(sql->hdbc, SQL_DBMS_NAME, (SQLPOINTER)info,
         sizeof(info), NULL);
      xprintf("%s ", info);
      dl_SQLGetInfo(sql->hdbc, SQL_DBMS_VER, (SQLPOINTER)info,
         sizeof(info), NULL);
      xprintf("%s - ", info);
      dl_SQLGetInfo(sql->hdbc, SQL_DATABASE_NAME, (SQLPOINTER)info,
         sizeof(info), NULL);
      xprintf("%s\n", info);
   }
   else
   {  /* describe error */
      xprintf("Failed to connect\n");
      extract_error("SQLDriverConnect", sql->hdbc, SQL_HANDLE_DBC);
      dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
      dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
      xfree(sql);
      return NULL;
   }
   /* set AUTOCOMMIT on*/
   ret = dl_SQLSetConnectAttr(sql->hdbc, SQL_ATTR_AUTOCOMMIT,
      (SQLPOINTER)SQL_AUTOCOMMIT_ON, 0);
   /* allocate a statement handle */
   ret = dl_SQLAllocHandle(SQL_HANDLE_STMT, sql->hdbc, &(sql->hstmt));

   /* initialization queries */
   for(j = 0; sqllines[j+1] != NULL; j++)
   {
      sql->query = (SQLCHAR *) sqllines[j];
      xprintf("%s\n", sql->query);
      ret = dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS);
      switch (ret)
      {
         case SQL_SUCCESS:
         case SQL_SUCCESS_WITH_INFO:
         case SQL_NO_DATA_FOUND:
            break;
         default:
            xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n",
               sql->query);
            extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);
            dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
            dl_SQLDisconnect(sql->hdbc);
            dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
            dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
            xfree(sql);
            return NULL;
      }
      /* commit statement */
      dl_SQLEndTran(SQL_HANDLE_ENV, sql->henv, SQL_COMMIT);
   }

   if ( sql->mode == 'R' )
   {  sql->nf = mpl_tab_num_flds(dca);
      for(j = 0; sqllines[j] != NULL; j++)
         arg = sqllines[j];
      total = strlen(arg);
      if (total > 7 && 0 == strncmp(arg, "SELECT ", 7))
      {
         total = strlen(arg);
         sql->query = xmalloc( (total+1) * sizeof(char));
         strcpy (sql->query, arg);
      }
      else
      {
         sql->query = db_generate_select_stmt(dca);
      }
      xprintf("%s\n", sql->query);
      if (dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS) !=
         SQL_SUCCESS)
      {
         xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n", sql->query);
         extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);
         dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
         dl_SQLDisconnect(sql->hdbc);
         dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
         dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
         xfree(sql->query);
            xfree(sql);
         return NULL;
      }
      xfree(sql->query);
      /* determine number of result columns */
      ret = dl_SQLNumResultCols(sql->hstmt, &sql->nresultcols);
      total = sql->nresultcols;
      if (total > SQL_FIELD_MAX)
      {  xprintf("db_iodbc_open: Too many fields (> %d) in query.\n"
            "\"%s\"\n", SQL_FIELD_MAX, sql->query);
         dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
         dl_SQLDisconnect(sql->hdbc);
         dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
         dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
         xfree(sql->query);
         return NULL;
      }
      for (i = 1; i <= total; i++)
      {  /* return a set of attributes for a column */
         ret = dl_SQLDescribeCol(sql->hstmt, (SQLSMALLINT) i,
            sql->colname[i], SQL_FDLEN_MAX,
            &colnamelen, &(sql->coltype[i]), &(sql->collen[i]), &scale,
            &nullable);
         sql->isnumeric[i] = is_numeric(sql->coltype[i]);
         /* bind columns to program vars, converting all types to CHAR*/
         if (sql->isnumeric[i])
#if 0 /* 12/I-2014 */
         {  dl_SQLBindCol(sql->hstmt, i, SQL_DOUBLE, sql->data[i],
#else
         {  dl_SQLBindCol(sql->hstmt, i, SQL_DOUBLE, &sql->datanum[i],
#endif
               SQL_FDLEN_MAX, &(sql->outlen[i]));
         } else
         {  dl_SQLBindCol(sql->hstmt, i, SQL_CHAR, sql->data[i],
               SQL_FDLEN_MAX, &(sql->outlen[i]));
         }
         for (j = sql->nf; j >= 1; j--)
         {  if (strcmp(mpl_tab_get_name(dca, j), sql->colname[i]) == 0)
            break;
         }
         sql->ref[i] = j;
      }
   }
   else if ( sql->mode == 'W' )
   {  for(j = 0; sqllines[j] != NULL; j++)
         arg = sqllines[j];
      if (  NULL != strchr(arg, '?') )
      {
         total = strlen(arg);
         sql->query = xmalloc( (total+1) * sizeof(char));
         strcpy (sql->query, arg);
         }
      else
      {
         sql->query = db_generate_insert_stmt(dca);
      }
      xprintf("%s\n", sql->query);
   }
   return sql;
}

int db_iodbc_read(TABDCA *dca, void *link)
{
   struct db_odbc  *sql;
   SQLRETURN        ret;
   char             buf[SQL_FDLEN_MAX+1];
   int              i;
   int              len;
   double           num;

   sql = (struct db_odbc *) link;

   xassert(sql != NULL);
   xassert(sql->mode == 'R');

   ret=dl_SQLFetch(sql->hstmt);
   if (ret== SQL_ERROR)
      return -1;
   if (ret== SQL_NO_DATA_FOUND)
      return -1; /*EOF*/
   for (i=1; i <= sql->nresultcols; i++)
   {
      if (sql->ref[i] > 0)
      {
         len = sql->outlen[i];
         if (len != SQL_NULL_DATA)
         {
            if (sql->isnumeric[i])
            {  mpl_tab_set_num(dca, sql->ref[i],
#if 0 /* 12/I-2014 */
                               *((const double *) sql->data[i]));
#else
                               (const double) sql->datanum[i]);
#endif
            }
            else
            {  if (len > SQL_FDLEN_MAX)
                  len = SQL_FDLEN_MAX;
               else if (len < 0)
                  len = 0;
               strncpy(buf, (const char *) sql->data[i], len);
               buf[len] = 0x00;
               mpl_tab_set_str(dca, sql->ref[i], strtrim(buf));
            }
         }
      }
   }
   return 0;
}

int db_iodbc_write(TABDCA *dca, void *link)
{
   struct db_odbc  *sql;
   char            *part;
   char            *query;
   char            *template;
   char             num[50];
   int              k;
   int              len;
   int              nf;

   sql = (struct db_odbc *) link;
   xassert(sql != NULL);
   xassert(sql->mode == 'W');

   len      = strlen(sql->query);
   template = (char *) xmalloc( (len + 1) * sizeof(char) );
   strcpy(template, sql->query);

   nf = mpl_tab_num_flds(dca);
   for (k = 1; k <= nf; k++)
   {     switch (mpl_tab_get_type(dca, k))
      {  case 'N':
            len += 20;
            break;
         case 'S':
            len += db_escaped_string_length(mpl_tab_get_str(dca, k));
            len += 2;
            break;
              default:
                        xassert(dca != dca);
         }
   }
   query = xmalloc( (len + 1 ) * sizeof(char) );
   query[0] = 0x00;
#if 0 /* 29/I-2017 */
   for (k = 1, part = strtok (template, "?"); (part != NULL);
      part = strtok (NULL, "?"), k++)
#else
   for (k = 1, part = xstrtok (template, "?"); (part != NULL);
      part = xstrtok (NULL, "?"), k++)
#endif
   {
      if (k > nf) break;
      strcat( query, part );
      switch (mpl_tab_get_type(dca, k))
      {  case 'N':
#if 0 /* 02/XI-2010 by xypron */
            sprintf(num, "%-18g",mpl_tab_get_num(dca, k));
#else
            sprintf(num, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));
#endif
            strcat( query, num );
            break;
         case 'S':
            strcat( query, "'");
            db_escape_string( query + strlen(query),
               mpl_tab_get_str(dca, k) );
            strcat( query, "'");
            break;
              default:
                        xassert(dca != dca);
         }
   }
   if (part != NULL)
      strcat(query, part);
   if (dl_SQLExecDirect(sql->hstmt, (SQLCHAR *) query, SQL_NTS)
      != SQL_SUCCESS)
   {
      xprintf("db_iodbc_write: Query\n\"%s\"\nfailed.\n", query);
      extract_error("SQLExecDirect", sql->hdbc, SQL_HANDLE_DBC);
      xfree(query);
      xfree(template);
      return 1;
      }

   xfree(query);
   xfree(template);
   return 0;
}

int db_iodbc_close(TABDCA *dca, void *link)
{
   struct db_odbc *sql;

   sql = (struct db_odbc *) link;
   xassert(sql != NULL);
   /* Commit */
   if ( sql->mode == 'W' )
      dl_SQLEndTran(SQL_HANDLE_ENV, sql->henv, SQL_COMMIT);
   if ( sql->mode == 'R' )
      dl_SQLCloseCursor(sql->hstmt);

   dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
   dl_SQLDisconnect(sql->hdbc);
   dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
   dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
   if ( sql->mode == 'W' )
      xfree(sql->query);
   xfree(sql);
   dca->link = NULL;
   return 0;
}

static void extract_error(
   char *fn,
   SQLHANDLE handle,
   SQLSMALLINT type)
{
   SQLINTEGER   i = 0;
   SQLINTEGER   native;
   SQLCHAR   state[ 7 ];
   SQLCHAR   text[256];
   SQLSMALLINT  len;
   SQLRETURN    ret;

   xprintf("\nThe driver reported the following diagnostics whilst "
      "running %s\n", fn);

   do
   {
      ret = dl_SQLGetDiagRec(type, handle, ++i, state, &native, text,
         sizeof(text), &len );
      if (SQL_SUCCEEDED(ret))
         xprintf("%s:%ld:%ld:%s\n", state, i, native, text);
   }
   while( ret == SQL_SUCCESS );
}

static int is_numeric(SQLSMALLINT coltype)
{
   int ret = 0;
   switch (coltype)
   {
      case SQL_DECIMAL:
      case SQL_NUMERIC:
      case SQL_SMALLINT:
      case SQL_INTEGER:
      case SQL_REAL:
      case SQL_FLOAT:
      case SQL_DOUBLE:
      case SQL_TINYINT:
      case SQL_BIGINT:
         ret = 1;
         break;
   }
   return ret;
}

#endif

/**********************************************************************/

#ifndef HAVE_MYSQL

void *db_mysql_open(TABDCA *dca, int mode)
{     xassert(dca == dca);
      xassert(mode == mode);
      xprintf("MySQL table driver not supported\n");
      return NULL;
}

int db_mysql_read(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

int db_mysql_write(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

int db_mysql_close(TABDCA *dca, void *link)
{     xassert(dca != dca);
      xassert(link != link);
      return 0;
}

#else

#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__WOE__)
#include 
#endif

#ifdef __CYGWIN__
#define byte_defined 1
#endif

#if 0 /* 12/II-2014; to fix namespace bug */
#include 
#include 
#endif
#include 

struct db_mysql
{
   int              mode;  /*'R' = Read, 'W' = Write*/
   MYSQL           *con;   /*connection*/
   MYSQL_RES       *res;    /*result*/
   int              nf;
   /* number of fields in the csv file */
   int              ref[1+SQL_FIELD_MAX];
   /* ref[k] = k', if k-th field of the csv file corresponds to
      k'-th field in the table statement; if ref[k] = 0, k-th field
      of the csv file is ignored */
   char            *query;
   /* query generated by db_mysql_open */
};

void STDCALL dl_mysql_close(MYSQL *sock)
{
      typedef void STDCALL ep_mysql_close(MYSQL *sock);

      ep_mysql_close *fn;
      fn = (ep_mysql_close *) xdlsym(h_mysql, "mysql_close");
      xassert(fn != NULL);
      return (*fn)(sock);
}

const char * STDCALL dl_mysql_error(MYSQL *mysql)
{
      typedef const char * STDCALL ep_mysql_error(MYSQL *mysql);

      ep_mysql_error *fn;
      fn = (ep_mysql_error *) xdlsym(h_mysql, "mysql_error");
      xassert(fn != NULL);
      return (*fn)(mysql);
}

MYSQL_FIELD * STDCALL dl_mysql_fetch_fields(MYSQL_RES *res)
{
      typedef MYSQL_FIELD * STDCALL
         ep_mysql_fetch_fields(MYSQL_RES *res);

      ep_mysql_fetch_fields *fn;
   fn = (ep_mysql_fetch_fields *) xdlsym(h_mysql, "mysql_fetch_fields");
      xassert(fn != NULL);
      return (*fn)(res);
}

unsigned long * STDCALL dl_mysql_fetch_lengths(MYSQL_RES *result)
{
      typedef unsigned long * STDCALL
         ep_mysql_fetch_lengths(MYSQL_RES *result);

      ep_mysql_fetch_lengths *fn;
      fn = (ep_mysql_fetch_lengths *) xdlsym(h_mysql,
         "mysql_fetch_lengths");
      xassert(fn != NULL);
      return (*fn)(result);
}

MYSQL_ROW STDCALL dl_mysql_fetch_row(MYSQL_RES *result)
{
      typedef MYSQL_ROW STDCALL ep_mysql_fetch_row(MYSQL_RES *result);

      ep_mysql_fetch_row *fn;
      fn = (ep_mysql_fetch_row *) xdlsym(h_mysql, "mysql_fetch_row");
      xassert(fn != NULL);
      return (*fn)(result);
}

unsigned int STDCALL dl_mysql_field_count(MYSQL *mysql)
{
      typedef unsigned int STDCALL ep_mysql_field_count(MYSQL *mysql);

      ep_mysql_field_count *fn;
     fn = (ep_mysql_field_count *) xdlsym(h_mysql, "mysql_field_count");
      xassert(fn != NULL);
      return (*fn)(mysql);
}

MYSQL * STDCALL dl_mysql_init(MYSQL *mysql)
{
      typedef MYSQL * STDCALL ep_mysql_init(MYSQL *mysql);

      ep_mysql_init *fn;
      fn = (ep_mysql_init *) xdlsym(h_mysql, "mysql_init");
      xassert(fn != NULL);
      return (*fn)(mysql);
}

unsigned int STDCALL dl_mysql_num_fields(MYSQL_RES *res)
{
      typedef unsigned int STDCALL ep_mysql_num_fields(MYSQL_RES *res);

      ep_mysql_num_fields *fn;
      fn = (ep_mysql_num_fields *) xdlsym(h_mysql, "mysql_num_fields");
      xassert(fn != NULL);
      return (*fn)(res);
}

int STDCALL dl_mysql_query(MYSQL *mysql, const char *q)
{
      typedef int STDCALL ep_mysql_query(MYSQL *mysql, const char *q);

      ep_mysql_query *fn;
      fn = (ep_mysql_query *) xdlsym(h_mysql, "mysql_query");
      xassert(fn != NULL);
      return (*fn)(mysql, q);
}

MYSQL * STDCALL dl_mysql_real_connect(MYSQL *mysql, const char *host,
                                           const char *user,
                                           const char *passwd,
                                           const char *db,
                                           unsigned int port,
                                           const char *unix_socket,
                                           unsigned long clientflag)
{
      typedef MYSQL * STDCALL ep_mysql_real_connect(MYSQL *mysql,
            const char *host,
            const char *user,
            const char *passwd,
            const char *db,
            unsigned int port,
            const char *unix_socket,
            unsigned long clientflag);

      ep_mysql_real_connect *fn;
      fn = (ep_mysql_real_connect *) xdlsym(h_mysql,
         "mysql_real_connect");
      xassert(fn != NULL);
      return (*fn)(mysql, host, user, passwd, db, port, unix_socket,
         clientflag);
}

MYSQL_RES * STDCALL dl_mysql_use_result(MYSQL *mysql)
{
      typedef MYSQL_RES * STDCALL ep_mysql_use_result(MYSQL *mysql);
      ep_mysql_use_result *fn;
      fn = (ep_mysql_use_result *) xdlsym(h_mysql, "mysql_use_result");
      xassert(fn != NULL);
      return (*fn)(mysql);
}

/***********************************************************************
*  NAME
*
*  db_mysql_open - open connection to ODBC data base
*
*  SYNOPSIS
*
*  #include "mplsql.h"
*  void *db_mysql_open(TABDCA *dca, int mode);
*
*  DESCRIPTION
*
*  The routine db_mysql_open opens a connection to a MySQL data base.
*  It then executes the sql statements passed.
*
*  In the case of table read the SELECT statement is executed.
*
*  In the case of table write the INSERT statement is prepared.
*  RETURNS
*
*  The routine returns a pointer to data storage area created. */

void *db_mysql_open(TABDCA *dca, int mode)
{  void  *ret;
   char **sqllines;

   sqllines = args_concat(dca);
   if (sqllines == NULL)
   {  xprintf("Missing arguments in table statement.\n"
              "Please, supply table driver, dsn, and query.\n");
      return NULL;
   }
   ret = db_mysql_open_int(dca, mode, (const char **) sqllines);
   free_buffer(sqllines);
   return ret;
}

static void *db_mysql_open_int(TABDCA *dca, int mode, const char
   **sqllines)
{
   struct db_mysql *sql = NULL;
   char            *arg = NULL;
   const char      *field;
   MYSQL_FIELD     *fields;
   char            *keyword;
   char            *value;
   char            *query;
   char            *dsn;
/* "Server=[server_name];Database=[database_name];UID=[username];*/
/* PWD=[password];Port=[port]"*/
   char            *server   = NULL;        /* Server */
   char            *user     = NULL;        /* UID */
   char            *password = NULL;        /* PWD */
   char            *database = NULL;        /* Database */
   unsigned int     port = 0;               /* Port */
   int              narg;
   int              i, j, total;

   if (libmysql == NULL)
   {
      xprintf("No loader for shared MySQL library available\n");
      return NULL;
   }

   if (h_mysql == NULL)
   {
      h_mysql = xdlopen(libmysql);
      if (h_mysql == NULL)
      {  xprintf("unable to open library %s\n", libmysql);
         xprintf("%s\n", get_err_msg());
         return NULL;
      }
   }

   sql = (struct db_mysql *) xmalloc(sizeof(struct db_mysql));
   if (sql == NULL)
         return NULL;
   sql->mode = mode;
   sql->res = NULL;
   sql->query = NULL;
   sql->nf = mpl_tab_num_flds(dca);

   narg = mpl_tab_num_args(dca);
   if (narg < 3 )
      xprintf("MySQL driver: string list too short \n");

   /* get connection string*/
   dsn = (char *) mpl_tab_get_arg(dca, 2);
      /* copy connection string*/
   i = strlen(dsn);
   i++;
   arg = xmalloc(i * sizeof(char));
   strcpy(arg, dsn);
   /*tokenize connection string*/
#if 0 /* 29/I-2017 */
   for (i = 1, keyword = strtok (arg, "="); (keyword != NULL);
      keyword = strtok (NULL, "="), i++)
#else
   for (i = 1, keyword = xstrtok (arg, "="); (keyword != NULL);
      keyword = xstrtok (NULL, "="), i++)
#endif
   {
#if 0 /* 29/I-2017 */
         value = strtok (NULL, ";");
#else
         value = xstrtok (NULL, ";");
#endif
      if (value==NULL)
         {
            xprintf("db_mysql_open: Missing value for keyword %s\n",
               keyword);
            xfree(arg);
            xfree(sql);
            return NULL;
      }
      if (0 == strcmp(keyword, "Server"))
            server = value;
      else if (0 == strcmp(keyword, "Database"))
             database = value;
      else if (0 == strcmp(keyword, "UID"))
             user = value;
      else if (0 == strcmp(keyword, "PWD"))
             password = value;
      else if (0 == strcmp(keyword, "Port"))
             port = (unsigned int) atol(value);
   }
   /* Connect to database */
   sql->con = dl_mysql_init(NULL);
  if (!dl_mysql_real_connect(sql->con, server, user, password, database,
      port, NULL, 0))
   {
      xprintf("db_mysql_open: Connect failed\n");
      xprintf("%s\n", dl_mysql_error(sql->con));
      xfree(arg);
      xfree(sql);
      return NULL;
   }
   xfree(arg);

   for(j = 0; sqllines[j+1] != NULL; j++)
   {  query = (char *) sqllines[j];
      xprintf("%s\n", query);
      if (dl_mysql_query(sql->con, query))
      {
         xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);
         xprintf("%s\n",dl_mysql_error(sql->con));
         dl_mysql_close(sql->con);
         xfree(sql);
         return NULL;
      }
   }

   if ( sql->mode == 'R' )
   {  sql->nf = mpl_tab_num_flds(dca);
      for(j = 0; sqllines[j] != NULL; j++)
         arg = (char *) sqllines[j];
      total = strlen(arg);
      if (total > 7 && 0 == strncmp(arg, "SELECT ", 7))
      {
         total = strlen(arg);
         query = xmalloc( (total+1) * sizeof(char));
         strcpy (query, arg);
      }
      else
      {
         query = db_generate_select_stmt(dca);
      }
      xprintf("%s\n", query);
      if (dl_mysql_query(sql->con, query))
      {
         xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);
         xprintf("%s\n",dl_mysql_error(sql->con));
         dl_mysql_close(sql->con);
         xfree(query);
         xfree(sql);
         return NULL;
      }
      xfree(query);
      sql->res = dl_mysql_use_result(sql->con);
      if (sql->res)
      {
         /* create references between query results and table fields*/
         total = dl_mysql_num_fields(sql->res);
         if (total > SQL_FIELD_MAX)
         {  xprintf("db_mysql_open: Too many fields (> %d) in query.\n"
               "\"%s\"\n", SQL_FIELD_MAX, query);
            xprintf("%s\n",dl_mysql_error(sql->con));
            dl_mysql_close(sql->con);
            xfree(query);
                 xfree(sql);
            return NULL;
         }
         fields = dl_mysql_fetch_fields(sql->res);
         for (i = 1; i <= total; i++)
         {
               for (j = sql->nf; j >= 1; j--)
            {
               if (strcmp(mpl_tab_get_name(dca, j), fields[i-1].name)
                  == 0)
               break;
            }
            sql->ref[i] = j;
         }
      }
      else
      {
         if(dl_mysql_field_count(sql->con) == 0)
            {
            xprintf("db_mysql_open: Query was not a SELECT\n\"%s\"\n",
               query);
            xprintf("%s\n",dl_mysql_error(sql->con));
            xfree(query);
            xfree(sql);
            return NULL;
         }
         else
         {
            xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);
            xprintf("%s\n",dl_mysql_error(sql->con));
            xfree(query);
            xfree(sql);
            return NULL;
         }
      }
   }
   else if ( sql->mode == 'W' )
   {  for(j = 0; sqllines[j] != NULL; j++)
         arg = (char *) sqllines[j];
      if (  NULL != strchr(arg, '?') )
      {
         total = strlen(arg);
         query = xmalloc( (total+1) * sizeof(char));
         strcpy (query, arg);
         }
      else
         query = db_generate_insert_stmt(dca);
      sql->query = query;
      xprintf("%s\n", query);
   }
   return sql;
}

int db_mysql_read(TABDCA *dca, void *link)
{  struct db_mysql *sql;
   char            buf[255+1];
   char            **row;
   unsigned long   *lengths;
   MYSQL_FIELD     *fields;
   double          num;
   int             len;
   unsigned long   num_fields;
   int             i;

   sql = (struct db_mysql *) link;

   xassert(sql != NULL);
   xassert(sql->mode == 'R');
   if (NULL == sql->res)
   {
      xprintf("db_mysql_read: no result set available");
      return 1;
   }
   if (NULL==(row = (char **)dl_mysql_fetch_row(sql->res))) {
       return -1; /*EOF*/
   }
   lengths = dl_mysql_fetch_lengths(sql->res);
   fields = dl_mysql_fetch_fields(sql->res);
   num_fields = dl_mysql_num_fields(sql->res);
   for (i=1; i <= num_fields; i++)
   {
      if (row[i-1] != NULL)
      {  len = (size_t) lengths[i-1];
         if (len > 255)
            len = 255;
         strncpy(buf, (const char *) row[i-1], len);
         buf[len] = 0x00;
         if (0 != (fields[i-1].flags & NUM_FLAG))
         {  strspx(buf); /* remove spaces*/
            if (str2num(buf, &num) != 0)
            {  xprintf("'%s' cannot be converted to a number.\n", buf);
               return 1;
            }
            if (sql->ref[i] > 0)
               mpl_tab_set_num(dca, sql->ref[i], num);
         }
         else
         {  if (sql->ref[i] > 0)
               mpl_tab_set_str(dca, sql->ref[i], strtrim(buf));
         }
      }
   }
   return 0;
}

int db_mysql_write(TABDCA *dca, void *link)
{
   struct db_mysql *sql;
   char            *part;
   char            *query;
   char            *template;
   char             num[50];
   int              k;
   int              len;
   int              nf;

   sql = (struct db_mysql *) link;
   xassert(sql != NULL);
   xassert(sql->mode == 'W');

   len      = strlen(sql->query);
   template = (char *) xmalloc( (len + 1) * sizeof(char) );
   strcpy(template, sql->query);

   nf = mpl_tab_num_flds(dca);
   for (k = 1; k <= nf; k++)
   {     switch (mpl_tab_get_type(dca, k))
      {  case 'N':
            len += 20;
            break;
         case 'S':
            len += db_escaped_string_length(mpl_tab_get_str(dca, k));
            len += 2;
            break;
              default:
                        xassert(dca != dca);
         }
   }
   query = xmalloc( (len + 1 ) * sizeof(char) );
   query[0] = 0x00;
#if 0 /* 29/I-2017 */
   for (k = 1, part = strtok (template, "?"); (part != NULL);
      part = strtok (NULL, "?"), k++)
#else
   for (k = 1, part = xstrtok (template, "?"); (part != NULL);
      part = xstrtok (NULL, "?"), k++)
#endif
   {
      if (k > nf) break;
      strcat( query, part );
      switch (mpl_tab_get_type(dca, k))
      {  case 'N':
#if 0 /* 02/XI-2010 by xypron */
            sprintf(num, "%-18g",mpl_tab_get_num(dca, k));
#else
            sprintf(num, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));
#endif
            strcat( query, num );
            break;
         case 'S':
            strcat( query, "'");
            db_escape_string( query + strlen(query),
               mpl_tab_get_str(dca, k) );
            strcat( query, "'");
            break;
              default:
                        xassert(dca != dca);
         }
   }
   if (part != NULL)
      strcat(query, part);
   if (dl_mysql_query(sql->con, query))
   {
      xprintf("db_mysql_write: Query\n\"%s\"\nfailed.\n", query);
      xprintf("%s\n",dl_mysql_error(sql->con));
      xfree(query);
      xfree(template);
      return 1;
      }

   xfree(query);
   xfree(template);
   return 0;
   }

int db_mysql_close(TABDCA *dca, void *link)
{
   struct db_mysql *sql;

   sql = (struct db_mysql *) link;
   xassert(sql != NULL);
   dl_mysql_close(sql->con);
   if ( sql->mode == 'W' )
      xfree(sql->query);
   xfree(sql);
   dca->link = NULL;
   return 0;
}

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/mpl/mplsql.h0000644000175100001710000000365500000000000024366 0ustar00runnerdocker00000000000000/* mplsql.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2003-2016 Free Software Foundation, Inc.
*  Written by Heinrich Schuchardt .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef MPLSQL_H
#define MPLSQL_H

#define db_iodbc_open _glp_db_iodbc_open
void *db_iodbc_open(TABDCA *dca, int mode);
/* open iODBC database connection */

#define db_iodbc_read _glp_db_iodbc_read
int db_iodbc_read(TABDCA *dca, void *link);
/* read data from iODBC */

#define db_iodbc_write _glp_db_iodbc_write
int db_iodbc_write(TABDCA *dca, void *link);
/* write data to iODBC */

#define db_iodbc_close _glp_db_iodbc_close
int db_iodbc_close(TABDCA *dca, void *link);
/* close iODBC database connection */

#define db_mysql_open _glp_db_mysql_open
void *db_mysql_open(TABDCA *dca, int mode);
/* open MySQL database connection */

#define db_mysql_read _glp_db_mysql_read
int db_mysql_read(TABDCA *dca, void *link);
/* read data from MySQL */

#define db_mysql_write _glp_db_mysql_write
int db_mysql_write(TABDCA *dca, void *link);
/* write data to MySQL */

#define db_mysql_close _glp_db_mysql_close
int db_mysql_close(TABDCA *dca, void *link);
/* close MySQL database connection */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6791432
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/0000755000175100001710000000000000000000000022701 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp.h0000644000175100001710000005325300000000000023657 0ustar00runnerdocker00000000000000/* npp.h (LP/MIP preprocessor) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef NPP_H
#define NPP_H

#include "prob.h"

#if 0 /* 20/XI-2017 */
typedef struct NPP NPP;
#else
typedef struct glp_prep NPP;
#endif
typedef struct NPPROW NPPROW;
typedef struct NPPCOL NPPCOL;
typedef struct NPPAIJ NPPAIJ;
typedef struct NPPTSE NPPTSE;
typedef struct NPPLFE NPPLFE;

#if 0 /* 20/XI-2017 */
struct NPP
#else
struct glp_prep
#endif
{     /* LP/MIP preprocessor workspace */
      /*--------------------------------------------------------------*/
      /* original problem segment */
      int orig_dir;
      /* optimization direction flag:
         GLP_MIN - minimization
         GLP_MAX - maximization */
      int orig_m;
      /* number of rows */
      int orig_n;
      /* number of columns */
      int orig_nnz;
      /* number of non-zero constraint coefficients */
      /*--------------------------------------------------------------*/
      /* transformed problem segment (always minimization) */
      DMP *pool;
      /* memory pool to store problem components */
      char *name;
      /* problem name (1 to 255 chars); NULL means no name is assigned
         to the problem */
      char *obj;
      /* objective function name (1 to 255 chars); NULL means no name
         is assigned to the objective function */
      double c0;
      /* constant term of the objective function */
      int nrows;
      /* number of rows introduced into the problem; this count
         increases by one every time a new row is added and never
         decreases; thus, actual number of rows may be less than nrows
         due to row deletions */
      int ncols;
      /* number of columns introduced into the problem; this count
         increases by one every time a new column is added and never
         decreases; thus, actual number of column may be less than
         ncols due to column deletions */
      NPPROW *r_head;
      /* pointer to the beginning of the row list */
      NPPROW *r_tail;
      /* pointer to the end of the row list */
      NPPCOL *c_head;
      /* pointer to the beginning of the column list */
      NPPCOL *c_tail;
      /* pointer to the end of the column list */
      /*--------------------------------------------------------------*/
      /* transformation history */
      DMP *stack;
      /* memory pool to store transformation entries */
      NPPTSE *top;
      /* pointer to most recent transformation entry */
#if 0 /* 16/XII-2009 */
      int count[1+25];
      /* transformation statistics */
#endif
      /*--------------------------------------------------------------*/
      /* resultant (preprocessed) problem segment */
      int m;
      /* number of rows */
      int n;
      /* number of columns */
      int nnz;
      /* number of non-zero constraint coefficients */
      int *row_ref; /* int row_ref[1+m]; */
      /* row_ref[i], 1 <= i <= m, is the reference number assigned to
         a row, which is i-th row of the resultant problem */
      int *col_ref; /* int col_ref[1+n]; */
      /* col_ref[j], 1 <= j <= n, is the reference number assigned to
         a column, which is j-th column of the resultant problem */
      /*--------------------------------------------------------------*/
      /* recovered solution segment */
      int sol;
      /* solution indicator:
         GLP_SOL - basic solution
         GLP_IPT - interior-point solution
         GLP_MIP - mixed integer solution */
      int scaling;
      /* scaling option:
         GLP_OFF - scaling is disabled
         GLP_ON  - scaling is enabled */
      int p_stat;
      /* status of primal basic solution:
         GLP_UNDEF  - primal solution is undefined
         GLP_FEAS   - primal solution is feasible
         GLP_INFEAS - primal solution is infeasible
         GLP_NOFEAS - no primal feasible solution exists */
      int d_stat;
      /* status of dual basic solution:
         GLP_UNDEF  - dual solution is undefined
         GLP_FEAS   - dual solution is feasible
         GLP_INFEAS - dual solution is infeasible
         GLP_NOFEAS - no dual feasible solution exists */
      int t_stat;
      /* status of interior-point solution:
         GLP_UNDEF  - interior solution is undefined
         GLP_OPT    - interior solution is optimal */
      int i_stat;
      /* status of mixed integer solution:
         GLP_UNDEF  - integer solution is undefined
         GLP_OPT    - integer solution is optimal
         GLP_FEAS   - integer solution is feasible
         GLP_NOFEAS - no integer solution exists */
      char *r_stat; /* char r_stat[1+nrows]; */
      /* r_stat[i], 1 <= i <= nrows, is status of i-th row:
         GLP_BS - inactive constraint
         GLP_NL - active constraint on lower bound
         GLP_NU - active constraint on upper bound
         GLP_NF - active free row
         GLP_NS - active equality constraint */
      char *c_stat; /* char c_stat[1+nrows]; */
      /* c_stat[j], 1 <= j <= nrows, is status of j-th column:
         GLP_BS - basic variable
         GLP_NL - non-basic variable on lower bound
         GLP_NU - non-basic variable on upper bound
         GLP_NF - non-basic free variable
         GLP_NS - non-basic fixed variable */
      double *r_pi; /* double r_pi[1+nrows]; */
      /* r_pi[i], 1 <= i <= nrows, is Lagrange multiplier (dual value)
         for i-th row (constraint) */
      double *c_value; /* double c_value[1+ncols]; */
      /* c_value[j], 1 <= j <= ncols, is primal value of j-th column
         (structural variable) */
};

struct NPPROW
{     /* row (constraint) */
      int i;
      /* reference number assigned to the row, 1 <= i <= nrows */
      char *name;
      /* row name (1 to 255 chars); NULL means no name is assigned to
         the row */
      double lb;
      /* lower bound; -DBL_MAX means the row has no lower bound */
      double ub;
      /* upper bound; +DBL_MAX means the row has no upper bound */
      NPPAIJ *ptr;
      /* pointer to the linked list of constraint coefficients */
      int temp;
      /* working field used by preprocessor routines */
      NPPROW *prev;
      /* pointer to previous row in the row list */
      NPPROW *next;
      /* pointer to next row in the row list */
};

struct NPPCOL
{     /* column (variable) */
      int j;
      /* reference number assigned to the column, 1 <= j <= ncols */
      char *name;
      /* column name (1 to 255 chars); NULL means no name is assigned
         to the column */
      char is_int;
      /* 0 means continuous variable; 1 means integer variable */
      double lb;
      /* lower bound; -DBL_MAX means the column has no lower bound */
      double ub;
      /* upper bound; +DBL_MAX means the column has no upper bound */
      double coef;
      /* objective coefficient */
      NPPAIJ *ptr;
      /* pointer to the linked list of constraint coefficients */
      int temp;
      /* working field used by preprocessor routines */
#if 1 /* 28/XII-2009 */
      union
      {  double ll;
         /* implied column lower bound */
         int pos;
         /* vertex ordinal number corresponding to this binary column
            in the conflict graph (0, if the vertex does not exist) */
      }  ll;
      union
      {  double uu;
         /* implied column upper bound */
         int neg;
         /* vertex ordinal number corresponding to complement of this
            binary column in the conflict graph (0, if the vertex does
            not exist) */
      }  uu;
#endif
      NPPCOL *prev;
      /* pointer to previous column in the column list */
      NPPCOL *next;
      /* pointer to next column in the column list */
};

struct NPPAIJ
{     /* constraint coefficient */
      NPPROW *row;
      /* pointer to corresponding row */
      NPPCOL *col;
      /* pointer to corresponding column */
      double val;
      /* (non-zero) coefficient value */
      NPPAIJ *r_prev;
      /* pointer to previous coefficient in the same row */
      NPPAIJ *r_next;
      /* pointer to next coefficient in the same row */
      NPPAIJ *c_prev;
      /* pointer to previous coefficient in the same column */
      NPPAIJ *c_next;
      /* pointer to next coefficient in the same column */
};

struct NPPTSE
{     /* transformation stack entry */
      int (*func)(NPP *npp, void *info);
      /* pointer to routine performing back transformation */
      void *info;
      /* pointer to specific info (depends on the transformation) */
      NPPTSE *link;
      /* pointer to another entry created *before* this entry */
};

struct NPPLFE
{     /* linear form element */
      int ref;
      /* row/column reference number */
      double val;
      /* (non-zero) coefficient value */
      NPPLFE *next;
      /* pointer to another element */
};

#define npp_create_wksp _glp_npp_create_wksp
NPP *npp_create_wksp(void);
/* create LP/MIP preprocessor workspace */

#define npp_insert_row _glp_npp_insert_row
void npp_insert_row(NPP *npp, NPPROW *row, int where);
/* insert row to the row list */

#define npp_remove_row _glp_npp_remove_row
void npp_remove_row(NPP *npp, NPPROW *row);
/* remove row from the row list */

#define npp_activate_row _glp_npp_activate_row
void npp_activate_row(NPP *npp, NPPROW *row);
/* make row active */

#define npp_deactivate_row _glp_npp_deactivate_row
void npp_deactivate_row(NPP *npp, NPPROW *row);
/* make row inactive */

#define npp_insert_col _glp_npp_insert_col
void npp_insert_col(NPP *npp, NPPCOL *col, int where);
/* insert column to the column list */

#define npp_remove_col _glp_npp_remove_col
void npp_remove_col(NPP *npp, NPPCOL *col);
/* remove column from the column list */

#define npp_activate_col _glp_npp_activate_col
void npp_activate_col(NPP *npp, NPPCOL *col);
/* make column active */

#define npp_deactivate_col _glp_npp_deactivate_col
void npp_deactivate_col(NPP *npp, NPPCOL *col);
/* make column inactive */

#define npp_add_row _glp_npp_add_row
NPPROW *npp_add_row(NPP *npp);
/* add new row to the current problem */

#define npp_add_col _glp_npp_add_col
NPPCOL *npp_add_col(NPP *npp);
/* add new column to the current problem */

#define npp_add_aij _glp_npp_add_aij
NPPAIJ *npp_add_aij(NPP *npp, NPPROW *row, NPPCOL *col, double val);
/* add new element to the constraint matrix */

#define npp_row_nnz _glp_npp_row_nnz
int npp_row_nnz(NPP *npp, NPPROW *row);
/* count number of non-zero coefficients in row */

#define npp_col_nnz _glp_npp_col_nnz
int npp_col_nnz(NPP *npp, NPPCOL *col);
/* count number of non-zero coefficients in column */

#define npp_push_tse _glp_npp_push_tse
void *npp_push_tse(NPP *npp, int (*func)(NPP *npp, void *info),
      int size);
/* push new entry to the transformation stack */

#define npp_erase_row _glp_npp_erase_row
void npp_erase_row(NPP *npp, NPPROW *row);
/* erase row content to make it empty */

#define npp_del_row _glp_npp_del_row
void npp_del_row(NPP *npp, NPPROW *row);
/* remove row from the current problem */

#define npp_del_col _glp_npp_del_col
void npp_del_col(NPP *npp, NPPCOL *col);
/* remove column from the current problem */

#define npp_del_aij _glp_npp_del_aij
void npp_del_aij(NPP *npp, NPPAIJ *aij);
/* remove element from the constraint matrix */

#define npp_load_prob _glp_npp_load_prob
void npp_load_prob(NPP *npp, glp_prob *orig, int names, int sol,
      int scaling);
/* load original problem into the preprocessor workspace */

#define npp_build_prob _glp_npp_build_prob
void npp_build_prob(NPP *npp, glp_prob *prob);
/* build resultant (preprocessed) problem */

#define npp_postprocess _glp_npp_postprocess
void npp_postprocess(NPP *npp, glp_prob *prob);
/* postprocess solution from the resultant problem */

#define npp_unload_sol _glp_npp_unload_sol
void npp_unload_sol(NPP *npp, glp_prob *orig);
/* store solution to the original problem */

#define npp_delete_wksp _glp_npp_delete_wksp
void npp_delete_wksp(NPP *npp);
/* delete LP/MIP preprocessor workspace */

#define npp_error()

#define npp_free_row _glp_npp_free_row
void npp_free_row(NPP *npp, NPPROW *p);
/* process free (unbounded) row */

#define npp_geq_row _glp_npp_geq_row
void npp_geq_row(NPP *npp, NPPROW *p);
/* process row of 'not less than' type */

#define npp_leq_row _glp_npp_leq_row
void npp_leq_row(NPP *npp, NPPROW *p);
/* process row of 'not greater than' type */

#define npp_free_col _glp_npp_free_col
void npp_free_col(NPP *npp, NPPCOL *q);
/* process free (unbounded) column */

#define npp_lbnd_col _glp_npp_lbnd_col
void npp_lbnd_col(NPP *npp, NPPCOL *q);
/* process column with (non-zero) lower bound */

#define npp_ubnd_col _glp_npp_ubnd_col
void npp_ubnd_col(NPP *npp, NPPCOL *q);
/* process column with upper bound */

#define npp_dbnd_col _glp_npp_dbnd_col
void npp_dbnd_col(NPP *npp, NPPCOL *q);
/* process non-negative column with upper bound */

#define npp_fixed_col _glp_npp_fixed_col
void npp_fixed_col(NPP *npp, NPPCOL *q);
/* process fixed column */

#define npp_make_equality _glp_npp_make_equality
int npp_make_equality(NPP *npp, NPPROW *p);
/* process row with almost identical bounds */

#define npp_make_fixed _glp_npp_make_fixed
int npp_make_fixed(NPP *npp, NPPCOL *q);
/* process column with almost identical bounds */

#define npp_empty_row _glp_npp_empty_row
int npp_empty_row(NPP *npp, NPPROW *p);
/* process empty row */

#define npp_empty_col _glp_npp_empty_col
int npp_empty_col(NPP *npp, NPPCOL *q);
/* process empty column */

#define npp_implied_value _glp_npp_implied_value
int npp_implied_value(NPP *npp, NPPCOL *q, double s);
/* process implied column value */

#define npp_eq_singlet _glp_npp_eq_singlet
int npp_eq_singlet(NPP *npp, NPPROW *p);
/* process row singleton (equality constraint) */

#define npp_implied_lower _glp_npp_implied_lower
int npp_implied_lower(NPP *npp, NPPCOL *q, double l);
/* process implied column lower bound */

#define npp_implied_upper _glp_npp_implied_upper
int npp_implied_upper(NPP *npp, NPPCOL *q, double u);
/* process implied upper bound of column */

#define npp_ineq_singlet _glp_npp_ineq_singlet
int npp_ineq_singlet(NPP *npp, NPPROW *p);
/* process row singleton (inequality constraint) */

#define npp_implied_slack _glp_npp_implied_slack
void npp_implied_slack(NPP *npp, NPPCOL *q);
/* process column singleton (implied slack variable) */

#define npp_implied_free _glp_npp_implied_free
int npp_implied_free(NPP *npp, NPPCOL *q);
/* process column singleton (implied free variable) */

#define npp_eq_doublet _glp_npp_eq_doublet
NPPCOL *npp_eq_doublet(NPP *npp, NPPROW *p);
/* process row doubleton (equality constraint) */

#define npp_forcing_row _glp_npp_forcing_row
int npp_forcing_row(NPP *npp, NPPROW *p, int at);
/* process forcing row */

#define npp_analyze_row _glp_npp_analyze_row
int npp_analyze_row(NPP *npp, NPPROW *p);
/* perform general row analysis */

#define npp_inactive_bound _glp_npp_inactive_bound
void npp_inactive_bound(NPP *npp, NPPROW *p, int which);
/* remove row lower/upper inactive bound */

#define npp_implied_bounds _glp_npp_implied_bounds
void npp_implied_bounds(NPP *npp, NPPROW *p);
/* determine implied column bounds */

#define npp_binarize_prob _glp_npp_binarize_prob
int npp_binarize_prob(NPP *npp);
/* binarize MIP problem */

#define npp_is_packing _glp_npp_is_packing
int npp_is_packing(NPP *npp, NPPROW *row);
/* test if constraint is packing inequality */

#define npp_hidden_packing _glp_npp_hidden_packing
int npp_hidden_packing(NPP *npp, NPPROW *row);
/* identify hidden packing inequality */

#define npp_implied_packing _glp_npp_implied_packing
int npp_implied_packing(NPP *npp, NPPROW *row, int which,
      NPPCOL *var[], char set[]);
/* identify implied packing inequality */

#define npp_is_covering _glp_npp_is_covering
int npp_is_covering(NPP *npp, NPPROW *row);
/* test if constraint is covering inequality */

#define npp_hidden_covering _glp_npp_hidden_covering
int npp_hidden_covering(NPP *npp, NPPROW *row);
/* identify hidden covering inequality */

#define npp_is_partitioning _glp_npp_is_partitioning
int npp_is_partitioning(NPP *npp, NPPROW *row);
/* test if constraint is partitioning equality */

#define npp_reduce_ineq_coef _glp_npp_reduce_ineq_coef
int npp_reduce_ineq_coef(NPP *npp, NPPROW *row);
/* reduce inequality constraint coefficients */

#define npp_clean_prob _glp_npp_clean_prob
void npp_clean_prob(NPP *npp);
/* perform initial LP/MIP processing */

#define npp_process_row _glp_npp_process_row
int npp_process_row(NPP *npp, NPPROW *row, int hard);
/* perform basic row processing */

#define npp_improve_bounds _glp_npp_improve_bounds
int npp_improve_bounds(NPP *npp, NPPROW *row, int flag);
/* improve current column bounds */

#define npp_process_col _glp_npp_process_col
int npp_process_col(NPP *npp, NPPCOL *col);
/* perform basic column processing */

#define npp_process_prob _glp_npp_process_prob
int npp_process_prob(NPP *npp, int hard);
/* perform basic LP/MIP processing */

#define npp_simplex _glp_npp_simplex
int npp_simplex(NPP *npp, const glp_smcp *parm);
/* process LP prior to applying primal/dual simplex method */

#define npp_integer _glp_npp_integer
int npp_integer(NPP *npp, const glp_iocp *parm);
/* process MIP prior to applying branch-and-bound method */

/**********************************************************************/

#define npp_sat_free_row _glp_npp_sat_free_row
void npp_sat_free_row(NPP *npp, NPPROW *p);
/* process free (unbounded) row */

#define npp_sat_fixed_col _glp_npp_sat_fixed_col
int npp_sat_fixed_col(NPP *npp, NPPCOL *q);
/* process fixed column */

#define npp_sat_is_bin_comb _glp_npp_sat_is_bin_comb
int npp_sat_is_bin_comb(NPP *npp, NPPROW *row);
/* test if row is binary combination */

#define npp_sat_num_pos_coef _glp_npp_sat_num_pos_coef
int npp_sat_num_pos_coef(NPP *npp, NPPROW *row);
/* determine number of positive coefficients */

#define npp_sat_num_neg_coef _glp_npp_sat_num_neg_coef
int npp_sat_num_neg_coef(NPP *npp, NPPROW *row);
/* determine number of negative coefficients */

#define npp_sat_is_cover_ineq _glp_npp_sat_is_cover_ineq
int npp_sat_is_cover_ineq(NPP *npp, NPPROW *row);
/* test if row is covering inequality */

#define npp_sat_is_pack_ineq _glp_npp_sat_is_pack_ineq
int npp_sat_is_pack_ineq(NPP *npp, NPPROW *row);
/* test if row is packing inequality */

#define npp_sat_is_partn_eq _glp_npp_sat_is_partn_eq
int npp_sat_is_partn_eq(NPP *npp, NPPROW *row);
/* test if row is partitioning equality */

#define npp_sat_reverse_row _glp_npp_sat_reverse_row
int npp_sat_reverse_row(NPP *npp, NPPROW *row);
/* multiply both sides of row by -1 */

#define npp_sat_split_pack _glp_npp_sat_split_pack
NPPROW *npp_sat_split_pack(NPP *npp, NPPROW *row, int nnn);
/* split packing inequality */

#define npp_sat_encode_pack _glp_npp_sat_encode_pack
void npp_sat_encode_pack(NPP *npp, NPPROW *row);
/* encode packing inequality */

typedef struct NPPLIT NPPLIT;
typedef struct NPPLSE NPPLSE;
typedef struct NPPSED NPPSED;

struct NPPLIT
{     /* literal (binary variable or its negation) */
      NPPCOL *col;
      /* pointer to binary variable; NULL means constant false */
      int neg;
      /* negation flag:
         0 - literal is variable (or constant false)
         1 - literal is negation of variable (or constant true) */
};

struct NPPLSE
{     /* literal set element */
      NPPLIT lit;
      /* literal */
      NPPLSE *next;
      /* pointer to another element */
};

struct NPPSED
{     /* summation encoding descriptor */
      /* this struct describes the equality
            x + y + z = s + 2 * c,
         which was encoded as CNF and included into the transformed
         problem; here x and y are literals, z is either a literal or
         constant zero, s and c are binary variables modeling, resp.,
         the low and high (carry) sum bits */
      NPPLIT x, y, z;
      /* literals; if z.col = NULL, z is constant zero */
      NPPCOL *s, *c;
      /* binary variables modeling the sum bits */
};

#define npp_sat_encode_sum2 _glp_npp_sat_encode_sum2
void npp_sat_encode_sum2(NPP *npp, NPPLSE *set, NPPSED *sed);
/* encode 2-bit summation */

#define npp_sat_encode_sum3 _glp_npp_sat_encode_sum3
void npp_sat_encode_sum3(NPP *npp, NPPLSE *set, NPPSED *sed);
/* encode 3-bit summation */

#define npp_sat_encode_sum_ax _glp_npp_sat_encode_sum_ax
int npp_sat_encode_sum_ax(NPP *npp, NPPROW *row, NPPLIT y[]);
/* encode linear combination of 0-1 variables */

#define npp_sat_normalize_clause _glp_npp_sat_normalize_clause
int npp_sat_normalize_clause(NPP *npp, int size, NPPLIT lit[]);
/* normalize clause */

#define npp_sat_encode_clause _glp_npp_sat_encode_clause
NPPROW *npp_sat_encode_clause(NPP *npp, int size, NPPLIT lit[]);
/* translate clause to cover inequality */

#define npp_sat_encode_geq _glp_npp_sat_encode_geq
int npp_sat_encode_geq(NPP *npp, int n, NPPLIT y[], int rhs);
/* encode "not less than" constraint */

#define npp_sat_encode_leq _glp_npp_sat_encode_leq
int npp_sat_encode_leq(NPP *npp, int n, NPPLIT y[], int rhs);
/* encode "not greater than" constraint */

#define npp_sat_encode_row _glp_npp_sat_encode_row
int npp_sat_encode_row(NPP *npp, NPPROW *row);
/* encode constraint (row) of general type */

#define npp_sat_encode_prob _glp_npp_sat_encode_prob
int npp_sat_encode_prob(NPP *npp);
/* encode 0-1 feasibility problem */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp1.c0000644000175100001710000007107300000000000023733 0ustar00runnerdocker00000000000000/* npp1.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

NPP *npp_create_wksp(void)
{     /* create LP/MIP preprocessor workspace */
      NPP *npp;
      npp = xmalloc(sizeof(NPP));
      npp->orig_dir = 0;
      npp->orig_m = npp->orig_n = npp->orig_nnz = 0;
      npp->pool = dmp_create_pool();
      npp->name = npp->obj = NULL;
      npp->c0 = 0.0;
      npp->nrows = npp->ncols = 0;
      npp->r_head = npp->r_tail = NULL;
      npp->c_head = npp->c_tail = NULL;
      npp->stack = dmp_create_pool();
      npp->top = NULL;
#if 0 /* 16/XII-2009 */
      memset(&npp->count, 0, sizeof(npp->count));
#endif
      npp->m = npp->n = npp->nnz = 0;
      npp->row_ref = npp->col_ref = NULL;
      npp->sol = npp->scaling = 0;
      npp->p_stat = npp->d_stat = npp->t_stat = npp->i_stat = 0;
      npp->r_stat = NULL;
      /*npp->r_prim =*/ npp->r_pi = NULL;
      npp->c_stat = NULL;
      npp->c_value = /*npp->c_dual =*/ NULL;
      return npp;
}

void npp_insert_row(NPP *npp, NPPROW *row, int where)
{     /* insert row to the row list */
      if (where == 0)
      {  /* insert row to the beginning of the row list */
         row->prev = NULL;
         row->next = npp->r_head;
         if (row->next == NULL)
            npp->r_tail = row;
         else
            row->next->prev = row;
         npp->r_head = row;
      }
      else
      {  /* insert row to the end of the row list */
         row->prev = npp->r_tail;
         row->next = NULL;
         if (row->prev == NULL)
            npp->r_head = row;
         else
            row->prev->next = row;
         npp->r_tail = row;
      }
      return;
}

void npp_remove_row(NPP *npp, NPPROW *row)
{     /* remove row from the row list */
      if (row->prev == NULL)
         npp->r_head = row->next;
      else
         row->prev->next = row->next;
      if (row->next == NULL)
         npp->r_tail = row->prev;
      else
         row->next->prev = row->prev;
      return;
}

void npp_activate_row(NPP *npp, NPPROW *row)
{     /* make row active */
      if (!row->temp)
      {  row->temp = 1;
         /* move the row to the beginning of the row list */
         npp_remove_row(npp, row);
         npp_insert_row(npp, row, 0);
      }
      return;
}

void npp_deactivate_row(NPP *npp, NPPROW *row)
{     /* make row inactive */
      if (row->temp)
      {  row->temp = 0;
         /* move the row to the end of the row list */
         npp_remove_row(npp, row);
         npp_insert_row(npp, row, 1);
      }
      return;
}

void npp_insert_col(NPP *npp, NPPCOL *col, int where)
{     /* insert column to the column list */
      if (where == 0)
      {  /* insert column to the beginning of the column list */
         col->prev = NULL;
         col->next = npp->c_head;
         if (col->next == NULL)
            npp->c_tail = col;
         else
            col->next->prev = col;
         npp->c_head = col;
      }
      else
      {  /* insert column to the end of the column list */
         col->prev = npp->c_tail;
         col->next = NULL;
         if (col->prev == NULL)
            npp->c_head = col;
         else
            col->prev->next = col;
         npp->c_tail = col;
      }
      return;
}

void npp_remove_col(NPP *npp, NPPCOL *col)
{     /* remove column from the column list */
      if (col->prev == NULL)
         npp->c_head = col->next;
      else
         col->prev->next = col->next;
      if (col->next == NULL)
         npp->c_tail = col->prev;
      else
         col->next->prev = col->prev;
      return;
}

void npp_activate_col(NPP *npp, NPPCOL *col)
{     /* make column active */
      if (!col->temp)
      {  col->temp = 1;
         /* move the column to the beginning of the column list */
         npp_remove_col(npp, col);
         npp_insert_col(npp, col, 0);
      }
      return;
}

void npp_deactivate_col(NPP *npp, NPPCOL *col)
{     /* make column inactive */
      if (col->temp)
      {  col->temp = 0;
         /* move the column to the end of the column list */
         npp_remove_col(npp, col);
         npp_insert_col(npp, col, 1);
      }
      return;
}

NPPROW *npp_add_row(NPP *npp)
{     /* add new row to the current problem */
      NPPROW *row;
      row = dmp_get_atom(npp->pool, sizeof(NPPROW));
      row->i = ++(npp->nrows);
      row->name = NULL;
      row->lb = -DBL_MAX, row->ub = +DBL_MAX;
      row->ptr = NULL;
      row->temp = 0;
      npp_insert_row(npp, row, 1);
      return row;
}

NPPCOL *npp_add_col(NPP *npp)
{     /* add new column to the current problem */
      NPPCOL *col;
      col = dmp_get_atom(npp->pool, sizeof(NPPCOL));
      col->j = ++(npp->ncols);
      col->name = NULL;
#if 0
      col->kind = GLP_CV;
#else
      col->is_int = 0;
#endif
      col->lb = col->ub = col->coef = 0.0;
      col->ptr = NULL;
      col->temp = 0;
      npp_insert_col(npp, col, 1);
      return col;
}

NPPAIJ *npp_add_aij(NPP *npp, NPPROW *row, NPPCOL *col, double val)
{     /* add new element to the constraint matrix */
      NPPAIJ *aij;
      aij = dmp_get_atom(npp->pool, sizeof(NPPAIJ));
      aij->row = row;
      aij->col = col;
      aij->val = val;
      aij->r_prev = NULL;
      aij->r_next = row->ptr;
      aij->c_prev = NULL;
      aij->c_next = col->ptr;
      if (aij->r_next != NULL)
         aij->r_next->r_prev = aij;
      if (aij->c_next != NULL)
         aij->c_next->c_prev = aij;
      row->ptr = col->ptr = aij;
      return aij;
}

int npp_row_nnz(NPP *npp, NPPROW *row)
{     /* count number of non-zero coefficients in row */
      NPPAIJ *aij;
      int nnz;
      xassert(npp == npp);
      nnz = 0;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         nnz++;
      return nnz;
}

int npp_col_nnz(NPP *npp, NPPCOL *col)
{     /* count number of non-zero coefficients in column */
      NPPAIJ *aij;
      int nnz;
      xassert(npp == npp);
      nnz = 0;
      for (aij = col->ptr; aij != NULL; aij = aij->c_next)
         nnz++;
      return nnz;
}

void *npp_push_tse(NPP *npp, int (*func)(NPP *npp, void *info),
      int size)
{     /* push new entry to the transformation stack */
      NPPTSE *tse;
      tse = dmp_get_atom(npp->stack, sizeof(NPPTSE));
      tse->func = func;
      tse->info = dmp_get_atom(npp->stack, size);
      tse->link = npp->top;
      npp->top = tse;
      return tse->info;
}

#if 1 /* 23/XII-2009 */
void npp_erase_row(NPP *npp, NPPROW *row)
{     /* erase row content to make it empty */
      NPPAIJ *aij;
      while (row->ptr != NULL)
      {  aij = row->ptr;
         row->ptr = aij->r_next;
         if (aij->c_prev == NULL)
            aij->col->ptr = aij->c_next;
         else
            aij->c_prev->c_next = aij->c_next;
         if (aij->c_next == NULL)
            ;
         else
            aij->c_next->c_prev = aij->c_prev;
         dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
      }
      return;
}
#endif

void npp_del_row(NPP *npp, NPPROW *row)
{     /* remove row from the current problem */
#if 0 /* 23/XII-2009 */
      NPPAIJ *aij;
#endif
      if (row->name != NULL)
         dmp_free_atom(npp->pool, row->name, strlen(row->name)+1);
#if 0 /* 23/XII-2009 */
      while (row->ptr != NULL)
      {  aij = row->ptr;
         row->ptr = aij->r_next;
         if (aij->c_prev == NULL)
            aij->col->ptr = aij->c_next;
         else
            aij->c_prev->c_next = aij->c_next;
         if (aij->c_next == NULL)
            ;
         else
            aij->c_next->c_prev = aij->c_prev;
         dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
      }
#else
      npp_erase_row(npp, row);
#endif
      npp_remove_row(npp, row);
      dmp_free_atom(npp->pool, row, sizeof(NPPROW));
      return;
}

void npp_del_col(NPP *npp, NPPCOL *col)
{     /* remove column from the current problem */
      NPPAIJ *aij;
      if (col->name != NULL)
         dmp_free_atom(npp->pool, col->name, strlen(col->name)+1);
      while (col->ptr != NULL)
      {  aij = col->ptr;
         col->ptr = aij->c_next;
         if (aij->r_prev == NULL)
            aij->row->ptr = aij->r_next;
         else
            aij->r_prev->r_next = aij->r_next;
         if (aij->r_next == NULL)
            ;
         else
            aij->r_next->r_prev = aij->r_prev;
         dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
      }
      npp_remove_col(npp, col);
      dmp_free_atom(npp->pool, col, sizeof(NPPCOL));
      return;
}

void npp_del_aij(NPP *npp, NPPAIJ *aij)
{     /* remove element from the constraint matrix */
      if (aij->r_prev == NULL)
         aij->row->ptr = aij->r_next;
      else
         aij->r_prev->r_next = aij->r_next;
      if (aij->r_next == NULL)
         ;
      else
         aij->r_next->r_prev = aij->r_prev;
      if (aij->c_prev == NULL)
         aij->col->ptr = aij->c_next;
      else
         aij->c_prev->c_next = aij->c_next;
      if (aij->c_next == NULL)
         ;
      else
         aij->c_next->c_prev = aij->c_prev;
      dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
      return;
}

void npp_load_prob(NPP *npp, glp_prob *orig, int names, int sol,
      int scaling)
{     /* load original problem into the preprocessor workspace */
      int m = orig->m;
      int n = orig->n;
      NPPROW **link;
      int i, j;
      double dir;
      xassert(names == GLP_OFF || names == GLP_ON);
      xassert(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP);
      xassert(scaling == GLP_OFF || scaling == GLP_ON);
      if (sol == GLP_MIP) xassert(!scaling);
      npp->orig_dir = orig->dir;
      if (npp->orig_dir == GLP_MIN)
         dir = +1.0;
      else if (npp->orig_dir == GLP_MAX)
         dir = -1.0;
      else
         xassert(npp != npp);
      npp->orig_m = m;
      npp->orig_n = n;
      npp->orig_nnz = orig->nnz;
      if (names && orig->name != NULL)
      {  npp->name = dmp_get_atom(npp->pool, strlen(orig->name)+1);
         strcpy(npp->name, orig->name);
      }
      if (names && orig->obj != NULL)
      {  npp->obj = dmp_get_atom(npp->pool, strlen(orig->obj)+1);
         strcpy(npp->obj, orig->obj);
      }
      npp->c0 = dir * orig->c0;
      /* load rows */
      link = xcalloc(1+m, sizeof(NPPROW *));
      for (i = 1; i <= m; i++)
      {  GLPROW *rrr = orig->row[i];
         NPPROW *row;
         link[i] = row = npp_add_row(npp);
         xassert(row->i == i);
         if (names && rrr->name != NULL)
         {  row->name = dmp_get_atom(npp->pool, strlen(rrr->name)+1);
            strcpy(row->name, rrr->name);
         }
         if (!scaling)
         {  if (rrr->type == GLP_FR)
               row->lb = -DBL_MAX, row->ub = +DBL_MAX;
            else if (rrr->type == GLP_LO)
               row->lb = rrr->lb, row->ub = +DBL_MAX;
            else if (rrr->type == GLP_UP)
               row->lb = -DBL_MAX, row->ub = rrr->ub;
            else if (rrr->type == GLP_DB)
               row->lb = rrr->lb, row->ub = rrr->ub;
            else if (rrr->type == GLP_FX)
               row->lb = row->ub = rrr->lb;
            else
               xassert(rrr != rrr);
         }
         else
         {  double rii = rrr->rii;
            if (rrr->type == GLP_FR)
               row->lb = -DBL_MAX, row->ub = +DBL_MAX;
            else if (rrr->type == GLP_LO)
               row->lb = rrr->lb * rii, row->ub = +DBL_MAX;
            else if (rrr->type == GLP_UP)
               row->lb = -DBL_MAX, row->ub = rrr->ub * rii;
            else if (rrr->type == GLP_DB)
               row->lb = rrr->lb * rii, row->ub = rrr->ub * rii;
            else if (rrr->type == GLP_FX)
               row->lb = row->ub = rrr->lb * rii;
            else
               xassert(rrr != rrr);
         }
      }
      /* load columns and constraint coefficients */
      for (j = 1; j <= n; j++)
      {  GLPCOL *ccc = orig->col[j];
         GLPAIJ *aaa;
         NPPCOL *col;
         col = npp_add_col(npp);
         xassert(col->j == j);
         if (names && ccc->name != NULL)
         {  col->name = dmp_get_atom(npp->pool, strlen(ccc->name)+1);
            strcpy(col->name, ccc->name);
         }
         if (sol == GLP_MIP)
#if 0
            col->kind = ccc->kind;
#else
            col->is_int = (char)(ccc->kind == GLP_IV);
#endif
         if (!scaling)
         {  if (ccc->type == GLP_FR)
               col->lb = -DBL_MAX, col->ub = +DBL_MAX;
            else if (ccc->type == GLP_LO)
               col->lb = ccc->lb, col->ub = +DBL_MAX;
            else if (ccc->type == GLP_UP)
               col->lb = -DBL_MAX, col->ub = ccc->ub;
            else if (ccc->type == GLP_DB)
               col->lb = ccc->lb, col->ub = ccc->ub;
            else if (ccc->type == GLP_FX)
               col->lb = col->ub = ccc->lb;
            else
               xassert(ccc != ccc);
            col->coef = dir * ccc->coef;
            for (aaa = ccc->ptr; aaa != NULL; aaa = aaa->c_next)
               npp_add_aij(npp, link[aaa->row->i], col, aaa->val);
         }
         else
         {  double sjj = ccc->sjj;
            if (ccc->type == GLP_FR)
               col->lb = -DBL_MAX, col->ub = +DBL_MAX;
            else if (ccc->type == GLP_LO)
               col->lb = ccc->lb / sjj, col->ub = +DBL_MAX;
            else if (ccc->type == GLP_UP)
               col->lb = -DBL_MAX, col->ub = ccc->ub / sjj;
            else if (ccc->type == GLP_DB)
               col->lb = ccc->lb / sjj, col->ub = ccc->ub / sjj;
            else if (ccc->type == GLP_FX)
               col->lb = col->ub = ccc->lb / sjj;
            else
               xassert(ccc != ccc);
            col->coef = dir * ccc->coef * sjj;
            for (aaa = ccc->ptr; aaa != NULL; aaa = aaa->c_next)
               npp_add_aij(npp, link[aaa->row->i], col,
                  aaa->row->rii * aaa->val * sjj);
         }
      }
      xfree(link);
      /* keep solution indicator and scaling option */
      npp->sol = sol;
      npp->scaling = scaling;
      return;
}

void npp_build_prob(NPP *npp, glp_prob *prob)
{     /* build resultant (preprocessed) problem */
      NPPROW *row;
      NPPCOL *col;
      NPPAIJ *aij;
      int i, j, type, len, *ind;
      double dir, *val;
      glp_erase_prob(prob);
      glp_set_prob_name(prob, npp->name);
      glp_set_obj_name(prob, npp->obj);
      glp_set_obj_dir(prob, npp->orig_dir);
      if (npp->orig_dir == GLP_MIN)
         dir = +1.0;
      else if (npp->orig_dir == GLP_MAX)
         dir = -1.0;
      else
         xassert(npp != npp);
      glp_set_obj_coef(prob, 0, dir * npp->c0);
      /* build rows */
      for (row = npp->r_head; row != NULL; row = row->next)
      {  row->temp = i = glp_add_rows(prob, 1);
         glp_set_row_name(prob, i, row->name);
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
            type = GLP_FR;
         else if (row->ub == +DBL_MAX)
            type = GLP_LO;
         else if (row->lb == -DBL_MAX)
            type = GLP_UP;
         else if (row->lb != row->ub)
            type = GLP_DB;
         else
            type = GLP_FX;
         glp_set_row_bnds(prob, i, type, row->lb, row->ub);
      }
      /* build columns and the constraint matrix */
      ind = xcalloc(1+prob->m, sizeof(int));
      val = xcalloc(1+prob->m, sizeof(double));
      for (col = npp->c_head; col != NULL; col = col->next)
      {  j = glp_add_cols(prob, 1);
         glp_set_col_name(prob, j, col->name);
#if 0
         glp_set_col_kind(prob, j, col->kind);
#else
         glp_set_col_kind(prob, j, col->is_int ? GLP_IV : GLP_CV);
#endif
         if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
            type = GLP_FR;
         else if (col->ub == +DBL_MAX)
            type = GLP_LO;
         else if (col->lb == -DBL_MAX)
            type = GLP_UP;
         else if (col->lb != col->ub)
            type = GLP_DB;
         else
            type = GLP_FX;
         glp_set_col_bnds(prob, j, type, col->lb, col->ub);
         glp_set_obj_coef(prob, j, dir * col->coef);
         len = 0;
         for (aij = col->ptr; aij != NULL; aij = aij->c_next)
         {  len++;
            ind[len] = aij->row->temp;
            val[len] = aij->val;
         }
         glp_set_mat_col(prob, j, len, ind, val);
      }
      xfree(ind);
      xfree(val);
      /* resultant problem has been built */
      npp->m = prob->m;
      npp->n = prob->n;
      npp->nnz = prob->nnz;
      npp->row_ref = xcalloc(1+npp->m, sizeof(int));
      npp->col_ref = xcalloc(1+npp->n, sizeof(int));
      for (row = npp->r_head, i = 0; row != NULL; row = row->next)
         npp->row_ref[++i] = row->i;
      for (col = npp->c_head, j = 0; col != NULL; col = col->next)
         npp->col_ref[++j] = col->j;
      /* transformed problem segment is no longer needed */
      dmp_delete_pool(npp->pool), npp->pool = NULL;
      npp->name = npp->obj = NULL;
      npp->c0 = 0.0;
      npp->r_head = npp->r_tail = NULL;
      npp->c_head = npp->c_tail = NULL;
      return;
}

void npp_postprocess(NPP *npp, glp_prob *prob)
{     /* postprocess solution from the resultant problem */
      GLPROW *row;
      GLPCOL *col;
      NPPTSE *tse;
      int i, j, k;
      double dir;
      xassert(npp->orig_dir == prob->dir);
      if (npp->orig_dir == GLP_MIN)
         dir = +1.0;
      else if (npp->orig_dir == GLP_MAX)
         dir = -1.0;
      else
         xassert(npp != npp);
#if 0 /* 11/VII-2013; due to call from ios_main */
      xassert(npp->m == prob->m);
#else
      if (npp->sol != GLP_MIP)
         xassert(npp->m == prob->m);
#endif
      xassert(npp->n == prob->n);
#if 0 /* 11/VII-2013; due to call from ios_main */
      xassert(npp->nnz == prob->nnz);
#else
      if (npp->sol != GLP_MIP)
         xassert(npp->nnz == prob->nnz);
#endif
      /* copy solution status */
      if (npp->sol == GLP_SOL)
      {  npp->p_stat = prob->pbs_stat;
         npp->d_stat = prob->dbs_stat;
      }
      else if (npp->sol == GLP_IPT)
         npp->t_stat = prob->ipt_stat;
      else if (npp->sol == GLP_MIP)
         npp->i_stat = prob->mip_stat;
      else
         xassert(npp != npp);
      /* allocate solution arrays */
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat == NULL)
            npp->r_stat = xcalloc(1+npp->nrows, sizeof(char));
         for (i = 1; i <= npp->nrows; i++)
            npp->r_stat[i] = 0;
         if (npp->c_stat == NULL)
            npp->c_stat = xcalloc(1+npp->ncols, sizeof(char));
         for (j = 1; j <= npp->ncols; j++)
            npp->c_stat[j] = 0;
      }
#if 0
      if (npp->r_prim == NULL)
         npp->r_prim = xcalloc(1+npp->nrows, sizeof(double));
      for (i = 1; i <= npp->nrows; i++)
         npp->r_prim[i] = DBL_MAX;
#endif
      if (npp->c_value == NULL)
         npp->c_value = xcalloc(1+npp->ncols, sizeof(double));
      for (j = 1; j <= npp->ncols; j++)
         npp->c_value[j] = DBL_MAX;
      if (npp->sol != GLP_MIP)
      {  if (npp->r_pi == NULL)
            npp->r_pi = xcalloc(1+npp->nrows, sizeof(double));
         for (i = 1; i <= npp->nrows; i++)
            npp->r_pi[i] = DBL_MAX;
#if 0
         if (npp->c_dual == NULL)
            npp->c_dual = xcalloc(1+npp->ncols, sizeof(double));
         for (j = 1; j <= npp->ncols; j++)
            npp->c_dual[j] = DBL_MAX;
#endif
      }
      /* copy solution components from the resultant problem */
      if (npp->sol == GLP_SOL)
      {  for (i = 1; i <= npp->m; i++)
         {  row = prob->row[i];
            k = npp->row_ref[i];
            npp->r_stat[k] = (char)row->stat;
            /*npp->r_prim[k] = row->prim;*/
            npp->r_pi[k] = dir * row->dual;
         }
         for (j = 1; j <= npp->n; j++)
         {  col = prob->col[j];
            k = npp->col_ref[j];
            npp->c_stat[k] = (char)col->stat;
            npp->c_value[k] = col->prim;
            /*npp->c_dual[k] = dir * col->dual;*/
         }
      }
      else if (npp->sol == GLP_IPT)
      {  for (i = 1; i <= npp->m; i++)
         {  row = prob->row[i];
            k = npp->row_ref[i];
            /*npp->r_prim[k] = row->pval;*/
            npp->r_pi[k] = dir * row->dval;
         }
         for (j = 1; j <= npp->n; j++)
         {  col = prob->col[j];
            k = npp->col_ref[j];
            npp->c_value[k] = col->pval;
            /*npp->c_dual[k] = dir * col->dval;*/
         }
      }
      else if (npp->sol == GLP_MIP)
      {
#if 0
         for (i = 1; i <= npp->m; i++)
         {  row = prob->row[i];
            k = npp->row_ref[i];
            /*npp->r_prim[k] = row->mipx;*/
         }
#endif
         for (j = 1; j <= npp->n; j++)
         {  col = prob->col[j];
            k = npp->col_ref[j];
            npp->c_value[k] = col->mipx;
         }
      }
      else
         xassert(npp != npp);
      /* perform postprocessing to construct solution to the original
         problem */
      for (tse = npp->top; tse != NULL; tse = tse->link)
      {  xassert(tse->func != NULL);
         xassert(tse->func(npp, tse->info) == 0);
      }
      return;
}

void npp_unload_sol(NPP *npp, glp_prob *orig)
{     /* store solution to the original problem */
      GLPROW *row;
      GLPCOL *col;
      int i, j;
      double dir;
      xassert(npp->orig_dir == orig->dir);
      if (npp->orig_dir == GLP_MIN)
         dir = +1.0;
      else if (npp->orig_dir == GLP_MAX)
         dir = -1.0;
      else
         xassert(npp != npp);
      xassert(npp->orig_m == orig->m);
      xassert(npp->orig_n == orig->n);
      xassert(npp->orig_nnz == orig->nnz);
      if (npp->sol == GLP_SOL)
      {  /* store basic solution */
         orig->valid = 0;
         orig->pbs_stat = npp->p_stat;
         orig->dbs_stat = npp->d_stat;
         orig->obj_val = orig->c0;
         orig->some = 0;
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            row->stat = npp->r_stat[i];
            if (!npp->scaling)
            {  /*row->prim = npp->r_prim[i];*/
               row->dual = dir * npp->r_pi[i];
            }
            else
            {  /*row->prim = npp->r_prim[i] / row->rii;*/
               row->dual = dir * npp->r_pi[i] * row->rii;
            }
            if (row->stat == GLP_BS)
               row->dual = 0.0;
            else if (row->stat == GLP_NL)
            {  xassert(row->type == GLP_LO || row->type == GLP_DB);
               row->prim = row->lb;
            }
            else if (row->stat == GLP_NU)
            {  xassert(row->type == GLP_UP || row->type == GLP_DB);
               row->prim = row->ub;
            }
            else if (row->stat == GLP_NF)
            {  xassert(row->type == GLP_FR);
               row->prim = 0.0;
            }
            else if (row->stat == GLP_NS)
            {  xassert(row->type == GLP_FX);
               row->prim = row->lb;
            }
            else
               xassert(row != row);
         }
         for (j = 1; j <= orig->n; j++)
         {  col = orig->col[j];
            col->stat = npp->c_stat[j];
            if (!npp->scaling)
            {  col->prim = npp->c_value[j];
               /*col->dual = dir * npp->c_dual[j];*/
            }
            else
            {  col->prim = npp->c_value[j] * col->sjj;
               /*col->dual = dir * npp->c_dual[j] / col->sjj;*/
            }
            if (col->stat == GLP_BS)
               col->dual = 0.0;
#if 1
            else if (col->stat == GLP_NL)
            {  xassert(col->type == GLP_LO || col->type == GLP_DB);
               col->prim = col->lb;
            }
            else if (col->stat == GLP_NU)
            {  xassert(col->type == GLP_UP || col->type == GLP_DB);
               col->prim = col->ub;
            }
            else if (col->stat == GLP_NF)
            {  xassert(col->type == GLP_FR);
               col->prim = 0.0;
            }
            else if (col->stat == GLP_NS)
            {  xassert(col->type == GLP_FX);
               col->prim = col->lb;
            }
            else
               xassert(col != col);
#endif
            orig->obj_val += col->coef * col->prim;
         }
#if 1
         /* compute primal values of inactive rows */
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            if (row->stat == GLP_BS)
            {  GLPAIJ *aij;
               double temp;
               temp = 0.0;
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  temp += aij->val * aij->col->prim;
               row->prim = temp;
            }
         }
         /* compute reduced costs of active columns */
         for (j = 1; j <= orig->n; j++)
         {  col = orig->col[j];
            if (col->stat != GLP_BS)
            {  GLPAIJ *aij;
               double temp;
               temp = col->coef;
               for (aij = col->ptr; aij != NULL; aij = aij->c_next)
                  temp -= aij->val * aij->row->dual;
               col->dual = temp;
            }
         }
#endif
      }
      else if (npp->sol == GLP_IPT)
      {  /* store interior-point solution */
         orig->ipt_stat = npp->t_stat;
         orig->ipt_obj = orig->c0;
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            if (!npp->scaling)
            {  /*row->pval = npp->r_prim[i];*/
               row->dval = dir * npp->r_pi[i];
            }
            else
            {  /*row->pval = npp->r_prim[i] / row->rii;*/
               row->dval = dir * npp->r_pi[i] * row->rii;
            }
         }
         for (j = 1; j <= orig->n; j++)
         {  col = orig->col[j];
            if (!npp->scaling)
            {  col->pval = npp->c_value[j];
               /*col->dval = dir * npp->c_dual[j];*/
            }
            else
            {  col->pval = npp->c_value[j] * col->sjj;
               /*col->dval = dir * npp->c_dual[j] / col->sjj;*/
            }
            orig->ipt_obj += col->coef * col->pval;
         }
#if 1
         /* compute row primal values */
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            {  GLPAIJ *aij;
               double temp;
               temp = 0.0;
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  temp += aij->val * aij->col->pval;
               row->pval = temp;
            }
         }
         /* compute column dual values */
         for (j = 1; j <= orig->n; j++)
         {  col = orig->col[j];
            {  GLPAIJ *aij;
               double temp;
               temp = col->coef;
               for (aij = col->ptr; aij != NULL; aij = aij->c_next)
                  temp -= aij->val * aij->row->dval;
               col->dval = temp;
            }
         }
#endif
      }
      else if (npp->sol == GLP_MIP)
      {  /* store MIP solution */
         xassert(!npp->scaling);
         orig->mip_stat = npp->i_stat;
         orig->mip_obj = orig->c0;
#if 0
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            /*row->mipx = npp->r_prim[i];*/
         }
#endif
         for (j = 1; j <= orig->n; j++)
         {  col = orig->col[j];
            col->mipx = npp->c_value[j];
            if (col->kind == GLP_IV)
               xassert(col->mipx == floor(col->mipx));
            orig->mip_obj += col->coef * col->mipx;
         }
#if 1
         /* compute row primal values */
         for (i = 1; i <= orig->m; i++)
         {  row = orig->row[i];
            {  GLPAIJ *aij;
               double temp;
               temp = 0.0;
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  temp += aij->val * aij->col->mipx;
               row->mipx = temp;
            }
         }
#endif
      }
      else
         xassert(npp != npp);
      return;
}

void npp_delete_wksp(NPP *npp)
{     /* delete LP/MIP preprocessor workspace */
      if (npp->pool != NULL)
         dmp_delete_pool(npp->pool);
      if (npp->stack != NULL)
         dmp_delete_pool(npp->stack);
      if (npp->row_ref != NULL)
         xfree(npp->row_ref);
      if (npp->col_ref != NULL)
         xfree(npp->col_ref);
      if (npp->r_stat != NULL)
         xfree(npp->r_stat);
#if 0
      if (npp->r_prim != NULL)
         xfree(npp->r_prim);
#endif
      if (npp->r_pi != NULL)
         xfree(npp->r_pi);
      if (npp->c_stat != NULL)
         xfree(npp->c_stat);
      if (npp->c_value != NULL)
         xfree(npp->c_value);
#if 0
      if (npp->c_dual != NULL)
         xfree(npp->c_dual);
#endif
      xfree(npp);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp2.c0000644000175100001710000012604400000000000023733 0ustar00runnerdocker00000000000000/* npp2.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  npp_free_row - process free (unbounded) row
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_free_row(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_free_row processes row p, which is free (i.e. has
*  no finite bounds):
*
*     -inf < sum a[p,j] x[j] < +inf.                                 (1)
*             j
*
*  PROBLEM TRANSFORMATION
*
*  Constraint (1) cannot be active, so it is redundant and can be
*  removed from the original problem.
*
*  Removing row p leads to removing a column of multiplier pi[p] for
*  this row in the dual system. Since row p has no bounds, pi[p] = 0,
*  so removing the column does not affect the dual solution.
*
*  RECOVERING BASIC SOLUTION
*
*  In solution to the original problem row p is inactive constraint,
*  so it is assigned status GLP_BS, and multiplier pi[p] is assigned
*  zero value.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  In solution to the original problem row p is inactive constraint,
*  so its multiplier pi[p] is assigned zero value.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct free_row
{     /* free (unbounded) row */
      int p;
      /* row reference number */
};

static int rcv_free_row(NPP *npp, void *info);

void npp_free_row(NPP *npp, NPPROW *p)
{     /* process free (unbounded) row */
      struct free_row *info;
      /* the row must be free */
      xassert(p->lb == -DBL_MAX && p->ub == +DBL_MAX);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_free_row, sizeof(struct free_row));
      info->p = p->i;
      /* remove the row from the problem */
      npp_del_row(npp, p);
      return;
}

static int rcv_free_row(NPP *npp, void *_info)
{     /* recover free (unbounded) row */
      struct free_row *info = _info;
      if (npp->sol == GLP_SOL)
         npp->r_stat[info->p] = GLP_BS;
      if (npp->sol != GLP_MIP)
         npp->r_pi[info->p] = 0.0;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_geq_row - process row of 'not less than' type
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_geq_row(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_geq_row processes row p, which is 'not less than'
*  inequality constraint:
*
*     L[p] <= sum a[p,j] x[j] (<= U[p]),                             (1)
*              j
*
*  where L[p] < U[p], and upper bound may not exist (U[p] = +oo).
*
*  PROBLEM TRANSFORMATION
*
*  Constraint (1) can be replaced by equality constraint:
*
*     sum a[p,j] x[j] - s = L[p],                                    (2)
*      j
*
*  where
*
*     0 <= s (<= U[p] - L[p])                                        (3)
*
*  is a non-negative surplus variable.
*
*  Since in the primal system there appears column s having the only
*  non-zero coefficient in row p, in the dual system there appears a
*  new row:
*
*     (-1) pi[p] + lambda = 0,                                       (4)
*
*  where (-1) is coefficient of column s in row p, pi[p] is multiplier
*  of row p, lambda is multiplier of column q, 0 is coefficient of
*  column s in the objective row.
*
*  RECOVERING BASIC SOLUTION
*
*  Status of row p in solution to the original problem is determined
*  by its status and status of column q in solution to the transformed
*  problem as follows:
*
*     +--------------------------------------+------------------+
*     |         Transformed problem          | Original problem |
*     +-----------------+--------------------+------------------+
*     | Status of row p | Status of column s | Status of row p  |
*     +-----------------+--------------------+------------------+
*     |     GLP_BS      |       GLP_BS       |       N/A        |
*     |     GLP_BS      |       GLP_NL       |      GLP_BS      |
*     |     GLP_BS      |       GLP_NU       |      GLP_BS      |
*     |     GLP_NS      |       GLP_BS       |      GLP_BS      |
*     |     GLP_NS      |       GLP_NL       |      GLP_NL      |
*     |     GLP_NS      |       GLP_NU       |      GLP_NU      |
*     +-----------------+--------------------+------------------+
*
*  Value of row multiplier pi[p] in solution to the original problem
*  is the same as in solution to the transformed problem.
*
*  1. In solution to the transformed problem row p and column q cannot
*     be basic at the same time; otherwise the basis matrix would have
*     two linear dependent columns: unity column of auxiliary variable
*     of row p and unity column of variable s.
*
*  2. Though in the transformed problem row p is equality constraint,
*     it may be basic due to primal degenerate solution.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of row multiplier pi[p] in solution to the original problem
*  is the same as in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct ineq_row
{     /* inequality constraint row */
      int p;
      /* row reference number */
      int s;
      /* column reference number for slack/surplus variable */
};

static int rcv_geq_row(NPP *npp, void *info);

void npp_geq_row(NPP *npp, NPPROW *p)
{     /* process row of 'not less than' type */
      struct ineq_row *info;
      NPPCOL *s;
      /* the row must have lower bound */
      xassert(p->lb != -DBL_MAX);
      xassert(p->lb < p->ub);
      /* create column for surplus variable */
      s = npp_add_col(npp);
      s->lb = 0.0;
      s->ub = (p->ub == +DBL_MAX ? +DBL_MAX : p->ub - p->lb);
      /* and add it to the transformed problem */
      npp_add_aij(npp, p, s, -1.0);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_geq_row, sizeof(struct ineq_row));
      info->p = p->i;
      info->s = s->j;
      /* replace the row by equality constraint */
      p->ub = p->lb;
      return;
}

static int rcv_geq_row(NPP *npp, void *_info)
{     /* recover row of 'not less than' type */
      struct ineq_row *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] == GLP_BS)
         {  if (npp->c_stat[info->s] == GLP_BS)
            {  npp_error();
               return 1;
            }
            else if (npp->c_stat[info->s] == GLP_NL ||
                     npp->c_stat[info->s] == GLP_NU)
               npp->r_stat[info->p] = GLP_BS;
            else
            {  npp_error();
               return 1;
            }
         }
         else if (npp->r_stat[info->p] == GLP_NS)
         {  if (npp->c_stat[info->s] == GLP_BS)
               npp->r_stat[info->p] = GLP_BS;
            else if (npp->c_stat[info->s] == GLP_NL)
               npp->r_stat[info->p] = GLP_NL;
            else if (npp->c_stat[info->s] == GLP_NU)
               npp->r_stat[info->p] = GLP_NU;
            else
            {  npp_error();
               return 1;
            }
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_leq_row - process row of 'not greater than' type
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_leq_row(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_leq_row processes row p, which is 'not greater than'
*  inequality constraint:
*
*     (L[p] <=) sum a[p,j] x[j] <= U[p],                             (1)
*                j
*
*  where L[p] < U[p], and lower bound may not exist (L[p] = +oo).
*
*  PROBLEM TRANSFORMATION
*
*  Constraint (1) can be replaced by equality constraint:
*
*     sum a[p,j] x[j] + s = L[p],                                    (2)
*      j
*
*  where
*
*     0 <= s (<= U[p] - L[p])                                        (3)
*
*  is a non-negative slack variable.
*
*  Since in the primal system there appears column s having the only
*  non-zero coefficient in row p, in the dual system there appears a
*  new row:
*
*     (+1) pi[p] + lambda = 0,                                       (4)
*
*  where (+1) is coefficient of column s in row p, pi[p] is multiplier
*  of row p, lambda is multiplier of column q, 0 is coefficient of
*  column s in the objective row.
*
*  RECOVERING BASIC SOLUTION
*
*  Status of row p in solution to the original problem is determined
*  by its status and status of column q in solution to the transformed
*  problem as follows:
*
*     +--------------------------------------+------------------+
*     |         Transformed problem          | Original problem |
*     +-----------------+--------------------+------------------+
*     | Status of row p | Status of column s | Status of row p  |
*     +-----------------+--------------------+------------------+
*     |     GLP_BS      |       GLP_BS       |       N/A        |
*     |     GLP_BS      |       GLP_NL       |      GLP_BS      |
*     |     GLP_BS      |       GLP_NU       |      GLP_BS      |
*     |     GLP_NS      |       GLP_BS       |      GLP_BS      |
*     |     GLP_NS      |       GLP_NL       |      GLP_NU      |
*     |     GLP_NS      |       GLP_NU       |      GLP_NL      |
*     +-----------------+--------------------+------------------+
*
*  Value of row multiplier pi[p] in solution to the original problem
*  is the same as in solution to the transformed problem.
*
*  1. In solution to the transformed problem row p and column q cannot
*     be basic at the same time; otherwise the basis matrix would have
*     two linear dependent columns: unity column of auxiliary variable
*     of row p and unity column of variable s.
*
*  2. Though in the transformed problem row p is equality constraint,
*     it may be basic due to primal degeneracy.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of row multiplier pi[p] in solution to the original problem
*  is the same as in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

static int rcv_leq_row(NPP *npp, void *info);

void npp_leq_row(NPP *npp, NPPROW *p)
{     /* process row of 'not greater than' type */
      struct ineq_row *info;
      NPPCOL *s;
      /* the row must have upper bound */
      xassert(p->ub != +DBL_MAX);
      xassert(p->lb < p->ub);
      /* create column for slack variable */
      s = npp_add_col(npp);
      s->lb = 0.0;
      s->ub = (p->lb == -DBL_MAX ? +DBL_MAX : p->ub - p->lb);
      /* and add it to the transformed problem */
      npp_add_aij(npp, p, s, +1.0);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_leq_row, sizeof(struct ineq_row));
      info->p = p->i;
      info->s = s->j;
      /* replace the row by equality constraint */
      p->lb = p->ub;
      return;
}

static int rcv_leq_row(NPP *npp, void *_info)
{     /* recover row of 'not greater than' type */
      struct ineq_row *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] == GLP_BS)
         {  if (npp->c_stat[info->s] == GLP_BS)
            {  npp_error();
               return 1;
            }
            else if (npp->c_stat[info->s] == GLP_NL ||
                     npp->c_stat[info->s] == GLP_NU)
               npp->r_stat[info->p] = GLP_BS;
            else
            {  npp_error();
               return 1;
            }
         }
         else if (npp->r_stat[info->p] == GLP_NS)
         {  if (npp->c_stat[info->s] == GLP_BS)
               npp->r_stat[info->p] = GLP_BS;
            else if (npp->c_stat[info->s] == GLP_NL)
               npp->r_stat[info->p] = GLP_NU;
            else if (npp->c_stat[info->s] == GLP_NU)
               npp->r_stat[info->p] = GLP_NL;
            else
            {  npp_error();
               return 1;
            }
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_free_col - process free (unbounded) column
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_free_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_free_col processes column q, which is free (i.e. has
*  no finite bounds):
*
*     -oo < x[q] < +oo.                                              (1)
*
*  PROBLEM TRANSFORMATION
*
*  Free (unbounded) variable can be replaced by the difference of two
*  non-negative variables:
*
*     x[q] = s' - s'',   s', s'' >= 0.                               (2)
*
*  Assuming that in the transformed problem x[q] becomes s',
*  transformation (2) causes new column s'' to appear, which differs
*  from column s' only in the sign of coefficients in constraint and
*  objective rows. Thus, if in the dual system the following row
*  corresponds to column s':
*
*     sum a[i,q] pi[i] + lambda' = c[q],                             (3)
*      i
*
*  the row which corresponds to column s'' is the following:
*
*     sum (-a[i,q]) pi[i] + lambda'' = -c[q].                        (4)
*      i
*
*  Then from (3) and (4) it follows that:
*
*     lambda' + lambda'' = 0   =>   lambda' = lmabda'' = 0,          (5)
*
*  where lambda' and lambda'' are multipliers for columns s' and s'',
*  resp.
*
*  RECOVERING BASIC SOLUTION
*
*  With respect to (5) status of column q in solution to the original
*  problem is determined by statuses of columns s' and s'' in solution
*  to the transformed problem as follows:
*
*     +--------------------------------------+------------------+
*     |         Transformed problem          | Original problem |
*     +------------------+-------------------+------------------+
*     | Status of col s' | Status of col s'' | Status of col q  |
*     +------------------+-------------------+------------------+
*     |      GLP_BS      |      GLP_BS       |       N/A        |
*     |      GLP_BS      |      GLP_NL       |      GLP_BS      |
*     |      GLP_NL      |      GLP_BS       |      GLP_BS      |
*     |      GLP_NL      |      GLP_NL       |      GLP_NF      |
*     +------------------+-------------------+------------------+
*
*  Value of column q is computed with formula (2).
*
*  1. In solution to the transformed problem columns s' and s'' cannot
*     be basic at the same time, because they differ only in the sign,
*     hence, are linear dependent.
*
*  2. Though column q is free, it can be non-basic due to dual
*     degeneracy.
*
*  3. If column q is integral, columns s' and s'' are also integral.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q is computed with formula (2).
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is computed with formula (2). */

struct free_col
{     /* free (unbounded) column */
      int q;
      /* column reference number for variables x[q] and s' */
      int s;
      /* column reference number for variable s'' */
};

static int rcv_free_col(NPP *npp, void *info);

void npp_free_col(NPP *npp, NPPCOL *q)
{     /* process free (unbounded) column */
      struct free_col *info;
      NPPCOL *s;
      NPPAIJ *aij;
      /* the column must be free */
      xassert(q->lb == -DBL_MAX && q->ub == +DBL_MAX);
      /* variable x[q] becomes s' */
      q->lb = 0.0, q->ub = +DBL_MAX;
      /* create variable s'' */
      s = npp_add_col(npp);
      s->is_int = q->is_int;
      s->lb = 0.0, s->ub = +DBL_MAX;
      /* duplicate objective coefficient */
      s->coef = -q->coef;
      /* duplicate column of the constraint matrix */
      for (aij = q->ptr; aij != NULL; aij = aij->c_next)
         npp_add_aij(npp, aij->row, s, -aij->val);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_free_col, sizeof(struct free_col));
      info->q = q->j;
      info->s = s->j;
      return;
}

static int rcv_free_col(NPP *npp, void *_info)
{     /* recover free (unbounded) column */
      struct free_col *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->c_stat[info->q] == GLP_BS)
         {  if (npp->c_stat[info->s] == GLP_BS)
            {  npp_error();
               return 1;
            }
            else if (npp->c_stat[info->s] == GLP_NL)
               npp->c_stat[info->q] = GLP_BS;
            else
            {  npp_error();
               return -1;
            }
         }
         else if (npp->c_stat[info->q] == GLP_NL)
         {  if (npp->c_stat[info->s] == GLP_BS)
               npp->c_stat[info->q] = GLP_BS;
            else if (npp->c_stat[info->s] == GLP_NL)
               npp->c_stat[info->q] = GLP_NF;
            else
            {  npp_error();
               return -1;
            }
         }
         else
         {  npp_error();
            return -1;
         }
      }
      /* compute value of x[q] with formula (2) */
      npp->c_value[info->q] -= npp->c_value[info->s];
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_lbnd_col - process column with (non-zero) lower bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_lbnd_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_lbnd_col processes column q, which has (non-zero)
*  lower bound:
*
*     l[q] <= x[q] (<= u[q]),                                        (1)
*
*  where l[q] < u[q], and upper bound may not exist (u[q] = +oo).
*
*  PROBLEM TRANSFORMATION
*
*  Column q can be replaced as follows:
*
*     x[q] = l[q] + s,                                               (2)
*
*  where
*
*     0 <= s (<= u[q] - l[q])                                        (3)
*
*  is a non-negative variable.
*
*  Substituting x[q] from (2) into the objective row, we have:
*
*     z = sum c[j] x[j] + c0 =
*          j
*
*       = sum c[j] x[j] + c[q] x[q] + c0 =
*         j!=q
*
*       = sum c[j] x[j] + c[q] (l[q] + s) + c0 =
*         j!=q
*
*       = sum c[j] x[j] + c[q] s + c~0,
*
*  where
*
*     c~0 = c0 + c[q] l[q]                                           (4)
*
*  is the constant term of the objective in the transformed problem.
*  Similarly, substituting x[q] into constraint row i, we have:
*
*     L[i] <= sum a[i,j] x[j] <= U[i]  ==>
*              j
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] x[q] <= U[i]  ==>
*             j!=q
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] (l[q] + s) <= U[i]  ==>
*             j!=q
*
*     L~[i] <= sum a[i,j] x[j] + a[i,q] s <= U~[i],
*              j!=q
*
*  where
*
*     L~[i] = L[i] - a[i,q] l[q],  U~[i] = U[i] - a[i,q] l[q]        (5)
*
*  are lower and upper bounds of row i in the transformed problem,
*  resp.
*
*  Transformation (2) does not affect the dual system.
*
*  RECOVERING BASIC SOLUTION
*
*  Status of column q in solution to the original problem is the same
*  as in solution to the transformed problem (GLP_BS, GLP_NL or GLP_NU).
*  Value of column q is computed with formula (2).
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q is computed with formula (2).
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is computed with formula (2). */

struct bnd_col
{     /* bounded column */
      int q;
      /* column reference number for variables x[q] and s */
      double bnd;
      /* lower/upper bound l[q] or u[q] */
};

static int rcv_lbnd_col(NPP *npp, void *info);

void npp_lbnd_col(NPP *npp, NPPCOL *q)
{     /* process column with (non-zero) lower bound */
      struct bnd_col *info;
      NPPROW *i;
      NPPAIJ *aij;
      /* the column must have non-zero lower bound */
      xassert(q->lb != 0.0);
      xassert(q->lb != -DBL_MAX);
      xassert(q->lb < q->ub);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_lbnd_col, sizeof(struct bnd_col));
      info->q = q->j;
      info->bnd = q->lb;
      /* substitute x[q] into objective row */
      npp->c0 += q->coef * q->lb;
      /* substitute x[q] into constraint rows */
      for (aij = q->ptr; aij != NULL; aij = aij->c_next)
      {  i = aij->row;
         if (i->lb == i->ub)
            i->ub = (i->lb -= aij->val * q->lb);
         else
         {  if (i->lb != -DBL_MAX)
               i->lb -= aij->val * q->lb;
            if (i->ub != +DBL_MAX)
               i->ub -= aij->val * q->lb;
         }
      }
      /* column x[q] becomes column s */
      if (q->ub != +DBL_MAX)
         q->ub -= q->lb;
      q->lb = 0.0;
      return;
}

static int rcv_lbnd_col(NPP *npp, void *_info)
{     /* recover column with (non-zero) lower bound */
      struct bnd_col *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->c_stat[info->q] == GLP_BS ||
             npp->c_stat[info->q] == GLP_NL ||
             npp->c_stat[info->q] == GLP_NU)
            npp->c_stat[info->q] = npp->c_stat[info->q];
         else
         {  npp_error();
            return 1;
         }
      }
      /* compute value of x[q] with formula (2) */
      npp->c_value[info->q] = info->bnd + npp->c_value[info->q];
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_ubnd_col - process column with upper bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_ubnd_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_ubnd_col processes column q, which has upper bound:
*
*     (l[q] <=) x[q] <= u[q],                                        (1)
*
*  where l[q] < u[q], and lower bound may not exist (l[q] = -oo).
*
*  PROBLEM TRANSFORMATION
*
*  Column q can be replaced as follows:
*
*     x[q] = u[q] - s,                                               (2)
*
*  where
*
*     0 <= s (<= u[q] - l[q])                                        (3)
*
*  is a non-negative variable.
*
*  Substituting x[q] from (2) into the objective row, we have:
*
*     z = sum c[j] x[j] + c0 =
*          j
*
*       = sum c[j] x[j] + c[q] x[q] + c0 =
*         j!=q
*
*       = sum c[j] x[j] + c[q] (u[q] - s) + c0 =
*         j!=q
*
*       = sum c[j] x[j] - c[q] s + c~0,
*
*  where
*
*     c~0 = c0 + c[q] u[q]                                           (4)
*
*  is the constant term of the objective in the transformed problem.
*  Similarly, substituting x[q] into constraint row i, we have:
*
*     L[i] <= sum a[i,j] x[j] <= U[i]  ==>
*              j
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] x[q] <= U[i]  ==>
*             j!=q
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] (u[q] - s) <= U[i]  ==>
*             j!=q
*
*     L~[i] <= sum a[i,j] x[j] - a[i,q] s <= U~[i],
*              j!=q
*
*  where
*
*     L~[i] = L[i] - a[i,q] u[q],  U~[i] = U[i] - a[i,q] u[q]        (5)
*
*  are lower and upper bounds of row i in the transformed problem,
*  resp.
*
*  Note that in the transformed problem coefficients c[q] and a[i,q]
*  change their sign. Thus, the row of the dual system corresponding to
*  column q:
*
*     sum a[i,q] pi[i] + lambda[q] = c[q]                            (6)
*      i
*
*  in the transformed problem becomes the following:
*
*     sum (-a[i,q]) pi[i] + lambda[s] = -c[q].                       (7)
*      i
*
*  Therefore:
*
*     lambda[q] = - lambda[s],                                       (8)
*
*  where lambda[q] is multiplier for column q, lambda[s] is multiplier
*  for column s.
*
*  RECOVERING BASIC SOLUTION
*
*  With respect to (8) status of column q in solution to the original
*  problem is determined by status of column s in solution to the
*  transformed problem as follows:
*
*     +-----------------------+--------------------+
*     |  Status of column s   | Status of column q |
*     | (transformed problem) | (original problem) |
*     +-----------------------+--------------------+
*     |        GLP_BS         |       GLP_BS       |
*     |        GLP_NL         |       GLP_NU       |
*     |        GLP_NU         |       GLP_NL       |
*     +-----------------------+--------------------+
*
*  Value of column q is computed with formula (2).
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q is computed with formula (2).
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is computed with formula (2). */

static int rcv_ubnd_col(NPP *npp, void *info);

void npp_ubnd_col(NPP *npp, NPPCOL *q)
{     /* process column with upper bound */
      struct bnd_col *info;
      NPPROW *i;
      NPPAIJ *aij;
      /* the column must have upper bound */
      xassert(q->ub != +DBL_MAX);
      xassert(q->lb < q->ub);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_ubnd_col, sizeof(struct bnd_col));
      info->q = q->j;
      info->bnd = q->ub;
      /* substitute x[q] into objective row */
      npp->c0 += q->coef * q->ub;
      q->coef = -q->coef;
      /* substitute x[q] into constraint rows */
      for (aij = q->ptr; aij != NULL; aij = aij->c_next)
      {  i = aij->row;
         if (i->lb == i->ub)
            i->ub = (i->lb -= aij->val * q->ub);
         else
         {  if (i->lb != -DBL_MAX)
               i->lb -= aij->val * q->ub;
            if (i->ub != +DBL_MAX)
               i->ub -= aij->val * q->ub;
         }
         aij->val = -aij->val;
      }
      /* column x[q] becomes column s */
      if (q->lb != -DBL_MAX)
         q->ub -= q->lb;
      else
         q->ub = +DBL_MAX;
      q->lb = 0.0;
      return;
}

static int rcv_ubnd_col(NPP *npp, void *_info)
{     /* recover column with upper bound */
      struct bnd_col *info = _info;
      if (npp->sol == GLP_BS)
      {  if (npp->c_stat[info->q] == GLP_BS)
            npp->c_stat[info->q] = GLP_BS;
         else if (npp->c_stat[info->q] == GLP_NL)
            npp->c_stat[info->q] = GLP_NU;
         else if (npp->c_stat[info->q] == GLP_NU)
            npp->c_stat[info->q] = GLP_NL;
         else
         {  npp_error();
            return 1;
         }
      }
      /* compute value of x[q] with formula (2) */
      npp->c_value[info->q] = info->bnd - npp->c_value[info->q];
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_dbnd_col - process non-negative column with upper bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_dbnd_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_dbnd_col processes column q, which is non-negative
*  and has upper bound:
*
*     0 <= x[q] <= u[q],                                             (1)
*
*  where u[q] > 0.
*
*  PROBLEM TRANSFORMATION
*
*  Upper bound of column q can be replaced by the following equality
*  constraint:
*
*     x[q] + s = u[q],                                               (2)
*
*  where s >= 0 is a non-negative complement variable.
*
*  Since in the primal system along with new row (2) there appears a
*  new column s having the only non-zero coefficient in this row, in
*  the dual system there appears a new row:
*
*     (+1)pi + lambda[s] = 0,                                        (3)
*
*  where (+1) is coefficient at column s in row (2), pi is multiplier
*  for row (2), lambda[s] is multiplier for column s, 0 is coefficient
*  at column s in the objective row.
*
*  RECOVERING BASIC SOLUTION
*
*  Status of column q in solution to the original problem is determined
*  by its status and status of column s in solution to the transformed
*  problem as follows:
*
*     +-----------------------------------+------------------+
*     |         Transformed problem       | Original problem |
*     +-----------------+-----------------+------------------+
*     | Status of col q | Status of col s | Status of col q  |
*     +-----------------+-----------------+------------------+
*     |     GLP_BS      |     GLP_BS      |      GLP_BS      |
*     |     GLP_BS      |     GLP_NL      |      GLP_NU      |
*     |     GLP_NL      |     GLP_BS      |      GLP_NL      |
*     |     GLP_NL      |     GLP_NL      |      GLP_NL (*)  |
*     +-----------------+-----------------+------------------+
*
*  Value of column q in solution to the original problem is the same as
*  in solution to the transformed problem.
*
*  1. Formally, in solution to the transformed problem columns q and s
*     cannot be non-basic at the same time, since the constraint (2)
*     would be violated. However, if u[q] is close to zero, violation
*     may be less than a working precision even if both columns q and s
*     are non-basic. In this degenerate case row (2) can be only basic,
*     i.e. non-active constraint (otherwise corresponding row of the
*     basis matrix would be zero). This allows to pivot out auxiliary
*     variable and pivot in column s, in which case the row becomes
*     active while column s becomes basic.
*
*  2. If column q is integral, column s is also integral.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q in solution to the original problem is the same as
*  in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q in solution to the original problem is the same as
*  in solution to the transformed problem. */

struct dbnd_col
{     /* double-bounded column */
      int q;
      /* column reference number for variable x[q] */
      int s;
      /* column reference number for complement variable s */
};

static int rcv_dbnd_col(NPP *npp, void *info);

void npp_dbnd_col(NPP *npp, NPPCOL *q)
{     /* process non-negative column with upper bound */
      struct dbnd_col *info;
      NPPROW *p;
      NPPCOL *s;
      /* the column must be non-negative with upper bound */
      xassert(q->lb == 0.0);
      xassert(q->ub > 0.0);
      xassert(q->ub != +DBL_MAX);
      /* create variable s */
      s = npp_add_col(npp);
      s->is_int = q->is_int;
      s->lb = 0.0, s->ub = +DBL_MAX;
      /* create equality constraint (2) */
      p = npp_add_row(npp);
      p->lb = p->ub = q->ub;
      npp_add_aij(npp, p, q, +1.0);
      npp_add_aij(npp, p, s, +1.0);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_dbnd_col, sizeof(struct dbnd_col));
      info->q = q->j;
      info->s = s->j;
      /* remove upper bound of x[q] */
      q->ub = +DBL_MAX;
      return;
}

static int rcv_dbnd_col(NPP *npp, void *_info)
{     /* recover non-negative column with upper bound */
      struct dbnd_col *info = _info;
      if (npp->sol == GLP_BS)
      {  if (npp->c_stat[info->q] == GLP_BS)
         {  if (npp->c_stat[info->s] == GLP_BS)
               npp->c_stat[info->q] = GLP_BS;
            else if (npp->c_stat[info->s] == GLP_NL)
               npp->c_stat[info->q] = GLP_NU;
            else
            {  npp_error();
               return 1;
            }
         }
         else if (npp->c_stat[info->q] == GLP_NL)
         {  if (npp->c_stat[info->s] == GLP_BS ||
                npp->c_stat[info->s] == GLP_NL)
               npp->c_stat[info->q] = GLP_NL;
            else
            {  npp_error();
               return 1;
            }
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_fixed_col - process fixed column
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_fixed_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_fixed_col processes column q, which is fixed:
*
*     x[q] = s[q],                                                   (1)
*
*  where s[q] is a fixed column value.
*
*  PROBLEM TRANSFORMATION
*
*  The value of a fixed column can be substituted into the objective
*  and constraint rows that allows removing the column from the problem.
*
*  Substituting x[q] = s[q] into the objective row, we have:
*
*     z = sum c[j] x[j] + c0 =
*          j
*
*       = sum c[j] x[j] + c[q] x[q] + c0 =
*         j!=q
*
*       = sum c[j] x[j] + c[q] s[q] + c0 =
*         j!=q
*
*       = sum c[j] x[j] + c~0,
*         j!=q
*
*  where
*
*     c~0 = c0 + c[q] s[q]                                           (2)
*
*  is the constant term of the objective in the transformed problem.
*  Similarly, substituting x[q] = s[q] into constraint row i, we have:
*
*     L[i] <= sum a[i,j] x[j] <= U[i]  ==>
*              j
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] x[q] <= U[i]  ==>
*             j!=q
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] s[q] <= U[i]  ==>
*             j!=q
*
*     L~[i] <= sum a[i,j] x[j] + a[i,q] s <= U~[i],
*              j!=q
*
*  where
*
*     L~[i] = L[i] - a[i,q] s[q],  U~[i] = U[i] - a[i,q] s[q]        (3)
*
*  are lower and upper bounds of row i in the transformed problem,
*  resp.
*
*  RECOVERING BASIC SOLUTION
*
*  Column q is assigned status GLP_NS and its value is assigned s[q].
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q is assigned s[q].
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is assigned s[q]. */

struct fixed_col
{     /* fixed column */
      int q;
      /* column reference number for variable x[q] */
      double s;
      /* value, at which x[q] is fixed */
};

static int rcv_fixed_col(NPP *npp, void *info);

void npp_fixed_col(NPP *npp, NPPCOL *q)
{     /* process fixed column */
      struct fixed_col *info;
      NPPROW *i;
      NPPAIJ *aij;
      /* the column must be fixed */
      xassert(q->lb == q->ub);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_fixed_col, sizeof(struct fixed_col));
      info->q = q->j;
      info->s = q->lb;
      /* substitute x[q] = s[q] into objective row */
      npp->c0 += q->coef * q->lb;
      /* substitute x[q] = s[q] into constraint rows */
      for (aij = q->ptr; aij != NULL; aij = aij->c_next)
      {  i = aij->row;
         if (i->lb == i->ub)
            i->ub = (i->lb -= aij->val * q->lb);
         else
         {  if (i->lb != -DBL_MAX)
               i->lb -= aij->val * q->lb;
            if (i->ub != +DBL_MAX)
               i->ub -= aij->val * q->lb;
         }
      }
      /* remove the column from the problem */
      npp_del_col(npp, q);
      return;
}

static int rcv_fixed_col(NPP *npp, void *_info)
{     /* recover fixed column */
      struct fixed_col *info = _info;
      if (npp->sol == GLP_SOL)
         npp->c_stat[info->q] = GLP_NS;
      npp->c_value[info->q] = info->s;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_make_equality - process row with almost identical bounds
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_make_equality(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_make_equality processes row p:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],                               (1)
*              j
*
*  where -oo < L[p] < U[p] < +oo, i.e. which is double-sided inequality
*  constraint.
*
*  RETURNS
*
*  0 - row bounds have not been changed;
*
*  1 - row has been replaced by equality constraint.
*
*  PROBLEM TRANSFORMATION
*
*  If bounds of row (1) are very close to each other:
*
*     U[p] - L[p] <= eps,                                            (2)
*
*  where eps is an absolute tolerance for row value, the row can be
*  replaced by the following almost equivalent equiality constraint:
*
*     sum a[p,j] x[j] = b,                                           (3)
*      j
*
*  where b = (L[p] + U[p]) / 2. If the right-hand side in (3) happens
*  to be very close to its nearest integer:
*
*     |b - floor(b + 0.5)| <= eps,                                   (4)
*
*  it is reasonable to use this nearest integer as the right-hand side.
*
*  RECOVERING BASIC SOLUTION
*
*  Status of row p in solution to the original problem is determined
*  by its status and the sign of its multiplier pi[p] in solution to
*  the transformed problem as follows:
*
*     +-----------------------+---------+--------------------+
*     |    Status of row p    | Sign of |  Status of row p   |
*     | (transformed problem) |  pi[p]  | (original problem) |
*     +-----------------------+---------+--------------------+
*     |        GLP_BS         |  + / -  |       GLP_BS       |
*     |        GLP_NS         |    +    |       GLP_NL       |
*     |        GLP_NS         |    -    |       GLP_NU       |
*     +-----------------------+---------+--------------------+
*
*  Value of row multiplier pi[p] in solution to the original problem is
*  the same as in solution to the transformed problem.
*
*  RECOVERING INTERIOR POINT SOLUTION
*
*  Value of row multiplier pi[p] in solution to the original problem is
*  the same as in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct make_equality
{     /* row with almost identical bounds */
      int p;
      /* row reference number */
};

static int rcv_make_equality(NPP *npp, void *info);

int npp_make_equality(NPP *npp, NPPROW *p)
{     /* process row with almost identical bounds */
      struct make_equality *info;
      double b, eps, nint;
      /* the row must be double-sided inequality */
      xassert(p->lb != -DBL_MAX);
      xassert(p->ub != +DBL_MAX);
      xassert(p->lb < p->ub);
      /* check row bounds */
      eps = 1e-9 + 1e-12 * fabs(p->lb);
      if (p->ub - p->lb > eps) return 0;
      /* row bounds are very close to each other */
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_make_equality, sizeof(struct make_equality));
      info->p = p->i;
      /* compute right-hand side */
      b = 0.5 * (p->ub + p->lb);
      nint = floor(b + 0.5);
      if (fabs(b - nint) <= eps) b = nint;
      /* replace row p by almost equivalent equality constraint */
      p->lb = p->ub = b;
      return 1;
}

int rcv_make_equality(NPP *npp, void *_info)
{     /* recover row with almost identical bounds */
      struct make_equality *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] == GLP_BS)
            npp->r_stat[info->p] = GLP_BS;
         else if (npp->r_stat[info->p] == GLP_NS)
         {  if (npp->r_pi[info->p] >= 0.0)
               npp->r_stat[info->p] = GLP_NL;
            else
               npp->r_stat[info->p] = GLP_NU;
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_make_fixed - process column with almost identical bounds
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_make_fixed(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_make_fixed processes column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where -oo < l[q] < u[q] < +oo, i.e. which has both lower and upper
*  bounds.
*
*  RETURNS
*
*  0 - column bounds have not been changed;
*
*  1 - column has been fixed.
*
*  PROBLEM TRANSFORMATION
*
*  If bounds of column (1) are very close to each other:
*
*     u[q] - l[q] <= eps,                                            (2)
*
*  where eps is an absolute tolerance for column value, the column can
*  be fixed:
*
*     x[q] = s[q],                                                   (3)
*
*  where s[q] = (l[q] + u[q]) / 2. And if the fixed column value s[q]
*  happens to be very close to its nearest integer:
*
*     |s[q] - floor(s[q] + 0.5)| <= eps,                             (4)
*
*  it is reasonable to use this nearest integer as the fixed value.
*
*  RECOVERING BASIC SOLUTION
*
*  In the dual system of the original (as well as transformed) problem
*  column q corresponds to the following row:
*
*     sum a[i,q] pi[i] + lambda[q] = c[q].                           (5)
*      i
*
*  Since multipliers pi[i] are known for all rows from solution to the
*  transformed problem, formula (5) allows computing value of multiplier
*  (reduced cost) for column q:
*
*     lambda[q] = c[q] - sum a[i,q] pi[i].                           (6)
*                         i
*
*  Status of column q in solution to the original problem is determined
*  by its status and the sign of its multiplier lambda[q] in solution to
*  the transformed problem as follows:
*
*     +-----------------------+-----------+--------------------+
*     |  Status of column q   |  Sign of  | Status of column q |
*     | (transformed problem) | lambda[q] | (original problem) |
*     +-----------------------+-----------+--------------------+
*     |        GLP_BS         |   + / -   |       GLP_BS       |
*     |        GLP_NS         |     +     |       GLP_NL       |
*     |        GLP_NS         |     -     |       GLP_NU       |
*     +-----------------------+-----------+--------------------+
*
*  Value of column q in solution to the original problem is the same as
*  in solution to the transformed problem.
*
*  RECOVERING INTERIOR POINT SOLUTION
*
*  Value of column q in solution to the original problem is the same as
*  in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct make_fixed
{     /* column with almost identical bounds */
      int q;
      /* column reference number */
      double c;
      /* objective coefficient at x[q] */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[i,q] */
};

static int rcv_make_fixed(NPP *npp, void *info);

int npp_make_fixed(NPP *npp, NPPCOL *q)
{     /* process column with almost identical bounds */
      struct make_fixed *info;
      NPPAIJ *aij;
      NPPLFE *lfe;
      double s, eps, nint;
      /* the column must be double-bounded */
      xassert(q->lb != -DBL_MAX);
      xassert(q->ub != +DBL_MAX);
      xassert(q->lb < q->ub);
      /* check column bounds */
      eps = 1e-9 + 1e-12 * fabs(q->lb);
      if (q->ub - q->lb > eps) return 0;
      /* column bounds are very close to each other */
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_make_fixed, sizeof(struct make_fixed));
      info->q = q->j;
      info->c = q->coef;
      info->ptr = NULL;
      /* save column coefficients a[i,q] (needed for basic solution
         only) */
      if (npp->sol == GLP_SOL)
      {  for (aij = q->ptr; aij != NULL; aij = aij->c_next)
         {  lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
            lfe->ref = aij->row->i;
            lfe->val = aij->val;
            lfe->next = info->ptr;
            info->ptr = lfe;
         }
      }
      /* compute column fixed value */
      s = 0.5 * (q->ub + q->lb);
      nint = floor(s + 0.5);
      if (fabs(s - nint) <= eps) s = nint;
      /* make column q fixed */
      q->lb = q->ub = s;
      return 1;
}

static int rcv_make_fixed(NPP *npp, void *_info)
{     /* recover column with almost identical bounds */
      struct make_fixed *info = _info;
      NPPLFE *lfe;
      double lambda;
      if (npp->sol == GLP_SOL)
      {  if (npp->c_stat[info->q] == GLP_BS)
            npp->c_stat[info->q] = GLP_BS;
         else if (npp->c_stat[info->q] == GLP_NS)
         {  /* compute multiplier for column q with formula (6) */
            lambda = info->c;
            for (lfe = info->ptr; lfe != NULL; lfe = lfe->next)
               lambda -= lfe->val * npp->r_pi[lfe->ref];
            /* assign status to non-basic column */
            if (lambda >= 0.0)
               npp->c_stat[info->q] = GLP_NL;
            else
               npp->c_stat[info->q] = GLP_NU;
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp3.c0000644000175100001710000030055700000000000023737 0ustar00runnerdocker00000000000000/* npp3.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  npp_empty_row - process empty row
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_empty_row(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_empty_row processes row p, which is empty, i.e.
*  coefficients at all columns in this row are zero:
*
*     L[p] <= sum 0 x[j] <= U[p],                                    (1)
*
*  where L[p] <= U[p].
*
*  RETURNS
*
*  0 - success;
*
*  1 - problem has no primal feasible solution.
*
*  PROBLEM TRANSFORMATION
*
*  If the following conditions hold:
*
*     L[p] <= +eps,  U[p] >= -eps,                                   (2)
*
*  where eps is an absolute tolerance for row value, the row p is
*  redundant. In this case it can be replaced by equivalent redundant
*  row, which is free (unbounded), and then removed from the problem.
*  Otherwise, the row p is infeasible and, thus, the problem has no
*  primal feasible solution.
*
*  RECOVERING BASIC SOLUTION
*
*  See the routine npp_free_row.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  See the routine npp_free_row.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

int npp_empty_row(NPP *npp, NPPROW *p)
{     /* process empty row */
      double eps = 1e-3;
      /* the row must be empty */
      xassert(p->ptr == NULL);
      /* check primal feasibility */
      if (p->lb > +eps || p->ub < -eps)
         return 1;
      /* replace the row by equivalent free (unbounded) row */
      p->lb = -DBL_MAX, p->ub = +DBL_MAX;
      /* and process it */
      npp_free_row(npp, p);
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_empty_col - process empty column
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_empty_col(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_empty_col processes column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] <= u[q], which is empty, i.e. has zero coefficients in
*  all constraint rows.
*
*  RETURNS
*
*  0 - success;
*
*  1 - problem has no dual feasible solution.
*
*  PROBLEM TRANSFORMATION
*
*  The row of the dual system corresponding to the empty column is the
*  following:
*
*     sum 0 pi[i] + lambda[q] = c[q],                                (2)
*      i
*
*  from which it follows that:
*
*     lambda[q] = c[q].                                              (3)
*
*  If the following condition holds:
*
*     c[q] < - eps,                                                  (4)
*
*  where eps is an absolute tolerance for column multiplier, the lower
*  column bound l[q] must be active to provide dual feasibility (note
*  that being preprocessed the problem is always minimization). In this
*  case the column can be fixed on its lower bound and removed from the
*  problem (if the column is integral, its bounds are also assumed to
*  be integral). And if the column has no lower bound (l[q] = -oo), the
*  problem has no dual feasible solution.
*
*  If the following condition holds:
*
*     c[q] > + eps,                                                  (5)
*
*  the upper column bound u[q] must be active to provide dual
*  feasibility. In this case the column can be fixed on its upper bound
*  and removed from the problem. And if the column has no upper bound
*  (u[q] = +oo), the problem has no dual feasible solution.
*
*  Finally, if the following condition holds:
*
*     - eps <= c[q] <= +eps,                                         (6)
*
*  dual feasibility does not depend on a particular value of column q.
*  In this case the column can be fixed either on its lower bound (if
*  l[q] > -oo) or on its upper bound (if u[q] < +oo) or at zero (if the
*  column is unbounded) and then removed from the problem.
*
*  RECOVERING BASIC SOLUTION
*
*  See the routine npp_fixed_col. Having been recovered the column
*  is assigned status GLP_NS. However, if actually it is not fixed
*  (l[q] < u[q]), its status should be changed to GLP_NL, GLP_NU, or
*  GLP_NF depending on which bound it was fixed on transformation stage.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  See the routine npp_fixed_col.
*
*  RECOVERING MIP SOLUTION
*
*  See the routine npp_fixed_col. */

struct empty_col
{     /* empty column */
      int q;
      /* column reference number */
      char stat;
      /* status in basic solution */
};

static int rcv_empty_col(NPP *npp, void *info);

int npp_empty_col(NPP *npp, NPPCOL *q)
{     /* process empty column */
      struct empty_col *info;
      double eps = 1e-3;
      /* the column must be empty */
      xassert(q->ptr == NULL);
      /* check dual feasibility */
      if (q->coef > +eps && q->lb == -DBL_MAX)
         return 1;
      if (q->coef < -eps && q->ub == +DBL_MAX)
         return 1;
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_empty_col, sizeof(struct empty_col));
      info->q = q->j;
      /* fix the column */
      if (q->lb == -DBL_MAX && q->ub == +DBL_MAX)
      {  /* free column */
         info->stat = GLP_NF;
         q->lb = q->ub = 0.0;
      }
      else if (q->ub == +DBL_MAX)
lo:   {  /* column with lower bound */
         info->stat = GLP_NL;
         q->ub = q->lb;
      }
      else if (q->lb == -DBL_MAX)
up:   {  /* column with upper bound */
         info->stat = GLP_NU;
         q->lb = q->ub;
      }
      else if (q->lb != q->ub)
      {  /* double-bounded column */
         if (q->coef >= +DBL_EPSILON) goto lo;
         if (q->coef <= -DBL_EPSILON) goto up;
         if (fabs(q->lb) <= fabs(q->ub)) goto lo; else goto up;
      }
      else
      {  /* fixed column */
         info->stat = GLP_NS;
      }
      /* process fixed column */
      npp_fixed_col(npp, q);
      return 0;
}

static int rcv_empty_col(NPP *npp, void *_info)
{     /* recover empty column */
      struct empty_col *info = _info;
      if (npp->sol == GLP_SOL)
         npp->c_stat[info->q] = info->stat;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_implied_value - process implied column value
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_implied_value(NPP *npp, NPPCOL *q, double s);
*
*  DESCRIPTION
*
*  For column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] < u[q], the routine npp_implied_value processes its
*  implied value s[q]. If this implied value satisfies to the current
*  column bounds and integrality condition, the routine fixes column q
*  at the given point. Note that the column is kept in the problem in
*  any case.
*
*  RETURNS
*
*  0 - column has been fixed;
*
*  1 - implied value violates to current column bounds;
*
*  2 - implied value violates integrality condition.
*
*  ALGORITHM
*
*  Implied column value s[q] satisfies to the current column bounds if
*  the following condition holds:
*
*     l[q] - eps <= s[q] <= u[q] + eps,                              (2)
*
*  where eps is an absolute tolerance for column value. If the column
*  is integral, the following condition also must hold:
*
*     |s[q] - floor(s[q]+0.5)| <= eps,                               (3)
*
*  where floor(s[q]+0.5) is the nearest integer to s[q].
*
*  If both condition (2) and (3) are satisfied, the column can be fixed
*  at the value s[q], or, if it is integral, at floor(s[q]+0.5).
*  Otherwise, if s[q] violates (2) or (3), the problem has no feasible
*  solution.
*
*  Note: If s[q] is close to l[q] or u[q], it seems to be reasonable to
*  fix the column at its lower or upper bound, resp. rather than at the
*  implied value. */

int npp_implied_value(NPP *npp, NPPCOL *q, double s)
{     /* process implied column value */
      double eps, nint;
      xassert(npp == npp);
      /* column must not be fixed */
      xassert(q->lb < q->ub);
      /* check integrality */
      if (q->is_int)
      {  nint = floor(s + 0.5);
         if (fabs(s - nint) <= 1e-5)
            s = nint;
         else
            return 2;
      }
      /* check current column lower bound */
      if (q->lb != -DBL_MAX)
      {  eps = (q->is_int ? 1e-5 : 1e-5 + 1e-8 * fabs(q->lb));
         if (s < q->lb - eps) return 1;
         /* if s[q] is close to l[q], fix column at its lower bound
            rather than at the implied value */
         if (s < q->lb + 1e-3 * eps)
         {  q->ub = q->lb;
            return 0;
         }
      }
      /* check current column upper bound */
      if (q->ub != +DBL_MAX)
      {  eps = (q->is_int ? 1e-5 : 1e-5 + 1e-8 * fabs(q->ub));
         if (s > q->ub + eps) return 1;
         /* if s[q] is close to u[q], fix column at its upper bound
            rather than at the implied value */
         if (s > q->ub - 1e-3 * eps)
         {  q->lb = q->ub;
            return 0;
         }
      }
      /* fix column at the implied value */
      q->lb = q->ub = s;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_eq_singlet - process row singleton (equality constraint)
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_eq_singlet(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_eq_singlet processes row p, which is equiality
*  constraint having the only non-zero coefficient:
*
*     a[p,q] x[q] = b.                                               (1)
*
*  RETURNS
*
*  0 - success;
*
*  1 - problem has no primal feasible solution;
*
*  2 - problem has no integer feasible solution.
*
*  PROBLEM TRANSFORMATION
*
*  The equality constraint defines implied value of column q:
*
*     x[q] = s[q] = b / a[p,q].                                      (2)
*
*  If the implied value s[q] satisfies to the column bounds (see the
*  routine npp_implied_value), the column can be fixed at s[q] and
*  removed from the problem. In this case row p becomes redundant, so
*  it can be replaced by equivalent free row and also removed from the
*  problem.
*
*  Note that the routine removes from the problem only row p. Column q
*  becomes fixed, however, it is kept in the problem.
*
*  RECOVERING BASIC SOLUTION
*
*  In solution to the original problem row p is assigned status GLP_NS
*  (active equality constraint), and column q is assigned status GLP_BS
*  (basic column).
*
*  Multiplier for row p can be computed as follows. In the dual system
*  of the original problem column q corresponds to the following row:
*
*     sum a[i,q] pi[i] + lambda[q] = c[q]  ==>
*      i
*
*     sum a[i,q] pi[i] + a[p,q] pi[p] + lambda[q] = c[q].
*     i!=p
*
*  Therefore:
*
*               1
*     pi[p] = ------ (c[q] - lambda[q] - sum a[i,q] pi[i]),          (3)
*             a[p,q]                     i!=q
*
*  where lambda[q] = 0 (since column[q] is basic), and pi[i] for all
*  i != p are known in solution to the transformed problem.
*
*  Value of column q in solution to the original problem is assigned
*  its implied value s[q].
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Multiplier for row p is computed with formula (3). Value of column
*  q is assigned its implied value s[q].
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is assigned its implied value s[q]. */

struct eq_singlet
{     /* row singleton (equality constraint) */
      int p;
      /* row reference number */
      int q;
      /* column reference number */
      double apq;
      /* constraint coefficient a[p,q] */
      double c;
      /* objective coefficient at x[q] */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[i,q], i != p */
};

static int rcv_eq_singlet(NPP *npp, void *info);

int npp_eq_singlet(NPP *npp, NPPROW *p)
{     /* process row singleton (equality constraint) */
      struct eq_singlet *info;
      NPPCOL *q;
      NPPAIJ *aij;
      NPPLFE *lfe;
      int ret;
      double s;
      /* the row must be singleton equality constraint */
      xassert(p->lb == p->ub);
      xassert(p->ptr != NULL && p->ptr->r_next == NULL);
      /* compute and process implied column value */
      aij = p->ptr;
      q = aij->col;
      s = p->lb / aij->val;
      ret = npp_implied_value(npp, q, s);
      xassert(0 <= ret && ret <= 2);
      if (ret != 0) return ret;
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_eq_singlet, sizeof(struct eq_singlet));
      info->p = p->i;
      info->q = q->j;
      info->apq = aij->val;
      info->c = q->coef;
      info->ptr = NULL;
      /* save column coefficients a[i,q], i != p (not needed for MIP
         solution) */
      if (npp->sol != GLP_MIP)
      {  for (aij = q->ptr; aij != NULL; aij = aij->c_next)
         {  if (aij->row == p) continue; /* skip a[p,q] */
            lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
            lfe->ref = aij->row->i;
            lfe->val = aij->val;
            lfe->next = info->ptr;
            info->ptr = lfe;
         }
      }
      /* remove the row from the problem */
      npp_del_row(npp, p);
      return 0;
}

static int rcv_eq_singlet(NPP *npp, void *_info)
{     /* recover row singleton (equality constraint) */
      struct eq_singlet *info = _info;
      NPPLFE *lfe;
      double temp;
      if (npp->sol == GLP_SOL)
      {  /* column q must be already recovered as GLP_NS */
         if (npp->c_stat[info->q] != GLP_NS)
         {  npp_error();
            return 1;
         }
         npp->r_stat[info->p] = GLP_NS;
         npp->c_stat[info->q] = GLP_BS;
      }
      if (npp->sol != GLP_MIP)
      {  /* compute multiplier for row p with formula (3) */
         temp = info->c;
         for (lfe = info->ptr; lfe != NULL; lfe = lfe->next)
            temp -= lfe->val * npp->r_pi[lfe->ref];
         npp->r_pi[info->p] = temp / info->apq;
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_implied_lower - process implied column lower bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_implied_lower(NPP *npp, NPPCOL *q, double l);
*
*  DESCRIPTION
*
*  For column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] < u[q], the routine npp_implied_lower processes its
*  implied lower bound l'[q]. As the result the current column lower
*  bound may increase. Note that the column is kept in the problem in
*  any case.
*
*  RETURNS
*
*  0 - current column lower bound has not changed;
*
*  1 - current column lower bound has changed, but not significantly;
*
*  2 - current column lower bound has significantly changed;
*
*  3 - column has been fixed on its upper bound;
*
*  4 - implied lower bound violates current column upper bound.
*
*  ALGORITHM
*
*  If column q is integral, before processing its implied lower bound
*  should be rounded up:
*
*              ( floor(l'[q]+0.5), if |l'[q] - floor(l'[q]+0.5)| <= eps
*     l'[q] := <                                                     (2)
*              ( ceil(l'[q]),      otherwise
*
*  where floor(l'[q]+0.5) is the nearest integer to l'[q], ceil(l'[q])
*  is smallest integer not less than l'[q], and eps is an absolute
*  tolerance for column value.
*
*  Processing implied column lower bound l'[q] includes the following
*  cases:
*
*  1) if l'[q] < l[q] + eps, implied lower bound is redundant;
*
*  2) if l[q] + eps <= l[q] <= u[q] + eps, current column lower bound
*     l[q] can be strengthened by replacing it with l'[q]. If in this
*     case new column lower bound becomes close to current column upper
*     bound u[q], the column can be fixed on its upper bound;
*
*  3) if l'[q] > u[q] + eps, implied lower bound violates current
*     column upper bound u[q], in which case the problem has no primal
*     feasible solution. */

int npp_implied_lower(NPP *npp, NPPCOL *q, double l)
{     /* process implied column lower bound */
      int ret;
      double eps, nint;
      xassert(npp == npp);
      /* column must not be fixed */
      xassert(q->lb < q->ub);
      /* implied lower bound must be finite */
      xassert(l != -DBL_MAX);
      /* if column is integral, round up l'[q] */
      if (q->is_int)
      {  nint = floor(l + 0.5);
         if (fabs(l - nint) <= 1e-5)
            l = nint;
         else
            l = ceil(l);
      }
      /* check current column lower bound */
      if (q->lb != -DBL_MAX)
      {  eps = (q->is_int ? 1e-3 : 1e-3 + 1e-6 * fabs(q->lb));
         if (l < q->lb + eps)
         {  ret = 0; /* redundant */
            goto done;
         }
      }
      /* check current column upper bound */
      if (q->ub != +DBL_MAX)
      {  eps = (q->is_int ? 1e-5 : 1e-5 + 1e-8 * fabs(q->ub));
         if (l > q->ub + eps)
         {  ret = 4; /* infeasible */
            goto done;
         }
         /* if l'[q] is close to u[q], fix column at its upper bound */
         if (l > q->ub - 1e-3 * eps)
         {  q->lb = q->ub;
            ret = 3; /* fixed */
            goto done;
         }
      }
      /* check if column lower bound changes significantly */
      if (q->lb == -DBL_MAX)
         ret = 2; /* significantly */
      else if (q->is_int && l > q->lb + 0.5)
         ret = 2; /* significantly */
      else if (l > q->lb + 0.30 * (1.0 + fabs(q->lb)))
         ret = 2; /* significantly */
      else
         ret = 1; /* not significantly */
      /* set new column lower bound */
      q->lb = l;
done: return ret;
}

/***********************************************************************
*  NAME
*
*  npp_implied_upper - process implied column upper bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_implied_upper(NPP *npp, NPPCOL *q, double u);
*
*  DESCRIPTION
*
*  For column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] < u[q], the routine npp_implied_upper processes its
*  implied upper bound u'[q]. As the result the current column upper
*  bound may decrease. Note that the column is kept in the problem in
*  any case.
*
*  RETURNS
*
*  0 - current column upper bound has not changed;
*
*  1 - current column upper bound has changed, but not significantly;
*
*  2 - current column upper bound has significantly changed;
*
*  3 - column has been fixed on its lower bound;
*
*  4 - implied upper bound violates current column lower bound.
*
*  ALGORITHM
*
*  If column q is integral, before processing its implied upper bound
*  should be rounded down:
*
*              ( floor(u'[q]+0.5), if |u'[q] - floor(l'[q]+0.5)| <= eps
*     u'[q] := <                                                     (2)
*              ( floor(l'[q]),     otherwise
*
*  where floor(u'[q]+0.5) is the nearest integer to u'[q],
*  floor(u'[q]) is largest integer not greater than u'[q], and eps is
*  an absolute tolerance for column value.
*
*  Processing implied column upper bound u'[q] includes the following
*  cases:
*
*  1) if u'[q] > u[q] - eps, implied upper bound is redundant;
*
*  2) if l[q] - eps <= u[q] <= u[q] - eps, current column upper bound
*     u[q] can be strengthened by replacing it with u'[q]. If in this
*     case new column upper bound becomes close to current column lower
*     bound, the column can be fixed on its lower bound;
*
*  3) if u'[q] < l[q] - eps, implied upper bound violates current
*     column lower bound l[q], in which case the problem has no primal
*     feasible solution. */

int npp_implied_upper(NPP *npp, NPPCOL *q, double u)
{     int ret;
      double eps, nint;
      xassert(npp == npp);
      /* column must not be fixed */
      xassert(q->lb < q->ub);
      /* implied upper bound must be finite */
      xassert(u != +DBL_MAX);
      /* if column is integral, round down u'[q] */
      if (q->is_int)
      {  nint = floor(u + 0.5);
         if (fabs(u - nint) <= 1e-5)
            u = nint;
         else
            u = floor(u);
      }
      /* check current column upper bound */
      if (q->ub != +DBL_MAX)
      {  eps = (q->is_int ? 1e-3 : 1e-3 + 1e-6 * fabs(q->ub));
         if (u > q->ub - eps)
         {  ret = 0; /* redundant */
            goto done;
         }
      }
      /* check current column lower bound */
      if (q->lb != -DBL_MAX)
      {  eps = (q->is_int ? 1e-5 : 1e-5 + 1e-8 * fabs(q->lb));
         if (u < q->lb - eps)
         {  ret = 4; /* infeasible */
            goto done;
         }
         /* if u'[q] is close to l[q], fix column at its lower bound */
         if (u < q->lb + 1e-3 * eps)
         {  q->ub = q->lb;
            ret = 3; /* fixed */
            goto done;
         }
      }
      /* check if column upper bound changes significantly */
      if (q->ub == +DBL_MAX)
         ret = 2; /* significantly */
      else if (q->is_int && u < q->ub - 0.5)
         ret = 2; /* significantly */
      else if (u < q->ub - 0.30 * (1.0 + fabs(q->ub)))
         ret = 2; /* significantly */
      else
         ret = 1; /* not significantly */
      /* set new column upper bound */
      q->ub = u;
done: return ret;
}

/***********************************************************************
*  NAME
*
*  npp_ineq_singlet - process row singleton (inequality constraint)
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_ineq_singlet(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_ineq_singlet processes row p, which is inequality
*  constraint having the only non-zero coefficient:
*
*     L[p] <= a[p,q] * x[q] <= U[p],                                 (1)
*
*  where L[p] < U[p], L[p] > -oo and/or U[p] < +oo.
*
*  RETURNS
*
*  0 - current column bounds have not changed;
*
*  1 - current column bounds have changed, but not significantly;
*
*  2 - current column bounds have significantly changed;
*
*  3 - column has been fixed on its lower or upper bound;
*
*  4 - problem has no primal feasible solution.
*
*  PROBLEM TRANSFORMATION
*
*  Inequality constraint (1) defines implied bounds of column q:
*
*             (  L[p] / a[p,q],  if a[p,q] > 0
*     l'[q] = <                                                      (2)
*             (  U[p] / a[p,q],  if a[p,q] < 0
*
*             (  U[p] / a[p,q],  if a[p,q] > 0
*     u'[q] = <                                                      (3)
*             (  L[p] / a[p,q],  if a[p,q] < 0
*
*  If these implied bounds do not violate current bounds of column q:
*
*     l[q] <= x[q] <= u[q],                                          (4)
*
*  they can be used to strengthen the current column bounds:
*
*     l[q] := max(l[q], l'[q]),                                      (5)
*
*     u[q] := min(u[q], u'[q]).                                      (6)
*
*  (See the routines npp_implied_lower and npp_implied_upper.)
*
*  Once bounds of row p (1) have been carried over column q, the row
*  becomes redundant, so it can be replaced by equivalent free row and
*  removed from the problem.
*
*  Note that the routine removes from the problem only row p. Column q,
*  even it has been fixed, is kept in the problem.
*
*  RECOVERING BASIC SOLUTION
*
*  Note that the row in the dual system corresponding to column q is
*  the following:
*
*     sum a[i,q] pi[i] + lambda[q] = c[q]  ==>
*      i
*                                                                    (7)
*     sum a[i,q] pi[i] + a[p,q] pi[p] + lambda[q] = c[q],
*     i!=p
*
*  where pi[i] for all i != p are known in solution to the transformed
*  problem. Row p does not exist in the transformed problem, so it has
*  zero multiplier there. This allows computing multiplier for column q
*  in solution to the transformed problem:
*
*     lambda~[q] = c[q] - sum a[i,q] pi[i].                          (8)
*                         i!=p
*
*  Let in solution to the transformed problem column q be non-basic
*  with lower bound active (GLP_NL, lambda~[q] >= 0), and this lower
*  bound be implied one l'[q]. From the original problem's standpoint
*  this then means that actually the original column lower bound l[q]
*  is inactive, and active is that row bound L[p] or U[p] that defines
*  the implied bound l'[q] (2). In this case in solution to the
*  original problem column q is assigned status GLP_BS while row p is
*  assigned status GLP_NL (if a[p,q] > 0) or GLP_NU (if a[p,q] < 0).
*  Since now column q is basic, its multiplier lambda[q] is zero. This
*  allows using (7) and (8) to find multiplier for row p in solution to
*  the original problem:
*
*               1
*     pi[p] = ------ (c[q] - sum a[i,q] pi[i]) = lambda~[q] / a[p,q] (9)
*             a[p,q]         i!=p
*
*  Now let in solution to the transformed problem column q be non-basic
*  with upper bound active (GLP_NU, lambda~[q] <= 0), and this upper
*  bound be implied one u'[q]. As in the previous case this then means
*  that from the original problem's standpoint actually the original
*  column upper bound u[q] is inactive, and active is that row bound
*  L[p] or U[p] that defines the implied bound u'[q] (3). In this case
*  in solution to the original problem column q is assigned status
*  GLP_BS, row p is assigned status GLP_NU (if a[p,q] > 0) or GLP_NL
*  (if a[p,q] < 0), and its multiplier is computed with formula (9).
*
*  Strengthening bounds of column q according to (5) and (6) may make
*  it fixed. Thus, if in solution to the transformed problem column q is
*  non-basic and fixed (GLP_NS), we can suppose that if lambda~[q] > 0,
*  column q has active lower bound (GLP_NL), and if lambda~[q] < 0,
*  column q has active upper bound (GLP_NU), reducing this case to two
*  previous ones. If, however, lambda~[q] is close to zero or
*  corresponding bound of row p does not exist (this may happen if
*  lambda~[q] has wrong sign due to round-off errors, in which case it
*  is expected to be close to zero, since solution is assumed to be dual
*  feasible), column q can be assigned status GLP_BS (basic), and row p
*  can be made active on its existing bound. In the latter case row
*  multiplier pi[p] computed with formula (9) will be also close to
*  zero, and dual feasibility will be kept.
*
*  In all other cases, namely, if in solution to the transformed
*  problem column q is basic (GLP_BS), or non-basic with original lower
*  bound l[q] active (GLP_NL), or non-basic with original upper bound
*  u[q] active (GLP_NU), constraint (1) is inactive. So in solution to
*  the original problem status of column q remains unchanged, row p is
*  assigned status GLP_BS, and its multiplier pi[p] is assigned zero
*  value.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  First, value of multiplier for column q in solution to the original
*  problem is computed with formula (8). If lambda~[q] > 0 and column q
*  has implied lower bound, or if lambda~[q] < 0 and column q has
*  implied upper bound, this means that from the original problem's
*  standpoint actually row p has corresponding active bound, in which
*  case its multiplier pi[p] is computed with formula (9). In other
*  cases, when the sign of lambda~[q] corresponds to original bound of
*  column q, or when lambda~[q] =~ 0, value of row multiplier pi[p] is
*  assigned zero value.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct ineq_singlet
{     /* row singleton (inequality constraint) */
      int p;
      /* row reference number */
      int q;
      /* column reference number */
      double apq;
      /* constraint coefficient a[p,q] */
      double c;
      /* objective coefficient at x[q] */
      double lb;
      /* row lower bound */
      double ub;
      /* row upper bound */
      char lb_changed;
      /* this flag is set if column lower bound was changed */
      char ub_changed;
      /* this flag is set if column upper bound was changed */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[i,q], i != p */
};

static int rcv_ineq_singlet(NPP *npp, void *info);

int npp_ineq_singlet(NPP *npp, NPPROW *p)
{     /* process row singleton (inequality constraint) */
      struct ineq_singlet *info;
      NPPCOL *q;
      NPPAIJ *apq, *aij;
      NPPLFE *lfe;
      int lb_changed, ub_changed;
      double ll, uu;
      /* the row must be singleton inequality constraint */
      xassert(p->lb != -DBL_MAX || p->ub != +DBL_MAX);
      xassert(p->lb < p->ub);
      xassert(p->ptr != NULL && p->ptr->r_next == NULL);
      /* compute implied column bounds */
      apq = p->ptr;
      q = apq->col;
      xassert(q->lb < q->ub);
      if (apq->val > 0.0)
      {  ll = (p->lb == -DBL_MAX ? -DBL_MAX : p->lb / apq->val);
         uu = (p->ub == +DBL_MAX ? +DBL_MAX : p->ub / apq->val);
      }
      else
      {  ll = (p->ub == +DBL_MAX ? -DBL_MAX : p->ub / apq->val);
         uu = (p->lb == -DBL_MAX ? +DBL_MAX : p->lb / apq->val);
      }
      /* process implied column lower bound */
      if (ll == -DBL_MAX)
         lb_changed = 0;
      else
      {  lb_changed = npp_implied_lower(npp, q, ll);
         xassert(0 <= lb_changed && lb_changed <= 4);
         if (lb_changed == 4) return 4; /* infeasible */
      }
      /* process implied column upper bound */
      if (uu == +DBL_MAX)
         ub_changed = 0;
      else if (lb_changed == 3)
      {  /* column was fixed on its upper bound due to l'[q] = u[q] */
         /* note that L[p] < U[p], so l'[q] = u[q] < u'[q] */
         ub_changed = 0;
      }
      else
      {  ub_changed = npp_implied_upper(npp, q, uu);
         xassert(0 <= ub_changed && ub_changed <= 4);
         if (ub_changed == 4) return 4; /* infeasible */
      }
      /* if neither lower nor upper column bound was changed, the row
         is originally redundant and can be replaced by free row */
      if (!lb_changed && !ub_changed)
      {  p->lb = -DBL_MAX, p->ub = +DBL_MAX;
         npp_free_row(npp, p);
         return 0;
      }
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_ineq_singlet, sizeof(struct ineq_singlet));
      info->p = p->i;
      info->q = q->j;
      info->apq = apq->val;
      info->c = q->coef;
      info->lb = p->lb;
      info->ub = p->ub;
      info->lb_changed = (char)lb_changed;
      info->ub_changed = (char)ub_changed;
      info->ptr = NULL;
      /* save column coefficients a[i,q], i != p (not needed for MIP
         solution) */
      if (npp->sol != GLP_MIP)
      {  for (aij = q->ptr; aij != NULL; aij = aij->c_next)
         {  if (aij == apq) continue; /* skip a[p,q] */
            lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
            lfe->ref = aij->row->i;
            lfe->val = aij->val;
            lfe->next = info->ptr;
            info->ptr = lfe;
         }
      }
      /* remove the row from the problem */
      npp_del_row(npp, p);
      return lb_changed >= ub_changed ? lb_changed : ub_changed;
}

static int rcv_ineq_singlet(NPP *npp, void *_info)
{     /* recover row singleton (inequality constraint) */
      struct ineq_singlet *info = _info;
      NPPLFE *lfe;
      double lambda;
      if (npp->sol == GLP_MIP) goto done;
      /* compute lambda~[q] in solution to the transformed problem
         with formula (8) */
      lambda = info->c;
      for (lfe = info->ptr; lfe != NULL; lfe = lfe->next)
         lambda -= lfe->val * npp->r_pi[lfe->ref];
      if (npp->sol == GLP_SOL)
      {  /* recover basic solution */
         if (npp->c_stat[info->q] == GLP_BS)
         {  /* column q is basic, so row p is inactive */
            npp->r_stat[info->p] = GLP_BS;
            npp->r_pi[info->p] = 0.0;
         }
         else if (npp->c_stat[info->q] == GLP_NL)
nl:      {  /* column q is non-basic with lower bound active */
            if (info->lb_changed)
            {  /* it is implied bound, so actually row p is active
                  while column q is basic */
               npp->r_stat[info->p] =
                  (char)(info->apq > 0.0 ? GLP_NL : GLP_NU);
               npp->c_stat[info->q] = GLP_BS;
               npp->r_pi[info->p] = lambda / info->apq;
            }
            else
            {  /* it is original bound, so row p is inactive */
               npp->r_stat[info->p] = GLP_BS;
               npp->r_pi[info->p] = 0.0;
            }
         }
         else if (npp->c_stat[info->q] == GLP_NU)
nu:      {  /* column q is non-basic with upper bound active */
            if (info->ub_changed)
            {  /* it is implied bound, so actually row p is active
                  while column q is basic */
               npp->r_stat[info->p] =
                  (char)(info->apq > 0.0 ? GLP_NU : GLP_NL);
               npp->c_stat[info->q] = GLP_BS;
               npp->r_pi[info->p] = lambda / info->apq;
            }
            else
            {  /* it is original bound, so row p is inactive */
               npp->r_stat[info->p] = GLP_BS;
               npp->r_pi[info->p] = 0.0;
            }
         }
         else if (npp->c_stat[info->q] == GLP_NS)
         {  /* column q is non-basic and fixed; note, however, that in
               in the original problem it is non-fixed */
            if (lambda > +1e-7)
            {  if (info->apq > 0.0 && info->lb != -DBL_MAX ||
                   info->apq < 0.0 && info->ub != +DBL_MAX ||
                  !info->lb_changed)
               {  /* either corresponding bound of row p exists or
                     column q remains non-basic with its original lower
                     bound active */
                  npp->c_stat[info->q] = GLP_NL;
                  goto nl;
               }
            }
            if (lambda < -1e-7)
            {  if (info->apq > 0.0 && info->ub != +DBL_MAX ||
                   info->apq < 0.0 && info->lb != -DBL_MAX ||
                  !info->ub_changed)
               {  /* either corresponding bound of row p exists or
                     column q remains non-basic with its original upper
                     bound active */
                  npp->c_stat[info->q] = GLP_NU;
                  goto nu;
               }
            }
            /* either lambda~[q] is close to zero, or corresponding
               bound of row p does not exist, because lambda~[q] has
               wrong sign due to round-off errors; in the latter case
               lambda~[q] is also assumed to be close to zero; so, we
               can make row p active on its existing bound and column q
               basic; pi[p] will have wrong sign, but it also will be
               close to zero (rarus casus of dual degeneracy) */
            if (info->lb != -DBL_MAX && info->ub == +DBL_MAX)
            {  /* row lower bound exists, but upper bound doesn't */
               npp->r_stat[info->p] = GLP_NL;
            }
            else if (info->lb == -DBL_MAX && info->ub != +DBL_MAX)
            {  /* row upper bound exists, but lower bound doesn't */
               npp->r_stat[info->p] = GLP_NU;
            }
            else if (info->lb != -DBL_MAX && info->ub != +DBL_MAX)
            {  /* both row lower and upper bounds exist */
               /* to choose proper active row bound we should not use
                  lambda~[q], because its value being close to zero is
                  unreliable; so we choose that bound which provides
                  primal feasibility for original constraint (1) */
               if (info->apq * npp->c_value[info->q] <=
                   0.5 * (info->lb + info->ub))
                  npp->r_stat[info->p] = GLP_NL;
               else
                  npp->r_stat[info->p] = GLP_NU;
            }
            else
            {  npp_error();
               return 1;
            }
            npp->c_stat[info->q] = GLP_BS;
            npp->r_pi[info->p] = lambda / info->apq;
         }
         else
         {  npp_error();
            return 1;
         }
      }
      if (npp->sol == GLP_IPT)
      {  /* recover interior-point solution */
         if (lambda > +DBL_EPSILON && info->lb_changed ||
             lambda < -DBL_EPSILON && info->ub_changed)
         {  /* actually row p has corresponding active bound */
            npp->r_pi[info->p] = lambda / info->apq;
         }
         else
         {  /* either bounds of column q are both inactive or its
               original bound is active */
            npp->r_pi[info->p] = 0.0;
         }
      }
done: return 0;
}

/***********************************************************************
*  NAME
*
*  npp_implied_slack - process column singleton (implied slack variable)
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_implied_slack(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_implied_slack processes column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] < u[q], having the only non-zero coefficient in row p,
*  which is equality constraint:
*
*     sum a[p,j] x[j] + a[p,q] x[q] = b.                             (2)
*     j!=q
*
*  PROBLEM TRANSFORMATION
*
*  (If x[q] is integral, this transformation must not be used.)
*
*  The term a[p,q] x[q] in constraint (2) can be considered as a slack
*  variable that allows to carry bounds of column q over row p and then
*  remove column q from the problem.
*
*  Constraint (2) can be written as follows:
*
*     sum a[p,j] x[j] = b - a[p,q] x[q].                             (3)
*     j!=q
*
*  According to (1) constraint (3) is equivalent to the following
*  inequality constraint:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],                               (4)
*             j!=q
*
*  where
*
*            ( b - a[p,q] u[q],  if a[p,q] > 0
*     L[p] = <                                                       (5)
*            ( b - a[p,q] l[q],  if a[p,q] < 0
*
*            ( b - a[p,q] l[q],  if a[p,q] > 0
*     U[p] = <                                                       (6)
*            ( b - a[p,q] u[q],  if a[p,q] < 0
*
*  From (2) it follows that:
*
*              1
*     x[q] = ------ (b - sum a[p,j] x[j]).                           (7)
*            a[p,q]      j!=q
*
*  In order to eliminate x[q] from the objective row we substitute it
*  from (6) to that row:
*
*     z = sum c[j] x[j] + c[q] x[q] + c[0] =
*         j!=q
*                                 1
*       = sum c[j] x[j] + c[q] [------ (b - sum a[p,j] x[j])] + c0 =
*         j!=q                  a[p,q]      j!=q
*
*       = sum c~[j] x[j] + c~[0],
*         j!=q
*                         a[p,j]                     b
*     c~[j] = c[j] - c[q] ------,  c~0 = c0 - c[q] ------            (8)
*                         a[p,q]                   a[p,q]
*
*  are values of objective coefficients and constant term, resp., in
*  the transformed problem.
*
*  Note that column q is column singleton, so in the dual system of the
*  original problem it corresponds to the following row singleton:
*
*     a[p,q] pi[p] + lambda[q] = c[q].                               (9)
*
*  In the transformed problem row (9) would be the following:
*
*     a[p,q] pi~[p] + lambda[q] = c~[q] = 0.                        (10)
*
*  Subtracting (10) from (9) we have:
*
*     a[p,q] (pi[p] - pi~[p]) = c[q]
*
*  that gives the following formula to compute multiplier for row p in
*  solution to the original problem using its value in solution to the
*  transformed problem:
*
*     pi[p] = pi~[p] + c[q] / a[p,q].                               (11)
*
*  RECOVERING BASIC SOLUTION
*
*  Status of column q in solution to the original problem is defined
*  by status of row p in solution to the transformed problem and the
*  sign of coefficient a[p,q] in the original inequality constraint (2)
*  as follows:
*
*     +-----------------------+---------+--------------------+
*     |    Status of row p    | Sign of | Status of column q |
*     | (transformed problem) | a[p,q]  | (original problem) |
*     +-----------------------+---------+--------------------+
*     |        GLP_BS         |  + / -  |       GLP_BS       |
*     |        GLP_NL         |    +    |       GLP_NU       |
*     |        GLP_NL         |    -    |       GLP_NL       |
*     |        GLP_NU         |    +    |       GLP_NL       |
*     |        GLP_NU         |    -    |       GLP_NU       |
*     |        GLP_NF         |  + / -  |       GLP_NF       |
*     +-----------------------+---------+--------------------+
*
*  Value of column q is computed with formula (7). Since originally row
*  p is equality constraint, its status is assigned GLP_NS, and value of
*  its multiplier pi[p] is computed with formula (11).
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of column q is computed with formula (7). Row multiplier value
*  pi[p] is computed with formula (11).
*
*  RECOVERING MIP SOLUTION
*
*  Value of column q is computed with formula (7). */

struct implied_slack
{     /* column singleton (implied slack variable) */
      int p;
      /* row reference number */
      int q;
      /* column reference number */
      double apq;
      /* constraint coefficient a[p,q] */
      double b;
      /* right-hand side of original equality constraint */
      double c;
      /* original objective coefficient at x[q] */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[p,j], j != q */
};

static int rcv_implied_slack(NPP *npp, void *info);

void npp_implied_slack(NPP *npp, NPPCOL *q)
{     /* process column singleton (implied slack variable) */
      struct implied_slack *info;
      NPPROW *p;
      NPPAIJ *aij;
      NPPLFE *lfe;
      /* the column must be non-integral non-fixed singleton */
      xassert(!q->is_int);
      xassert(q->lb < q->ub);
      xassert(q->ptr != NULL && q->ptr->c_next == NULL);
      /* corresponding row must be equality constraint */
      aij = q->ptr;
      p = aij->row;
      xassert(p->lb == p->ub);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_implied_slack, sizeof(struct implied_slack));
      info->p = p->i;
      info->q = q->j;
      info->apq = aij->val;
      info->b = p->lb;
      info->c = q->coef;
      info->ptr = NULL;
      /* save row coefficients a[p,j], j != q, and substitute x[q]
         into the objective row */
      for (aij = p->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->col == q) continue; /* skip a[p,q] */
         lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
         lfe->ref = aij->col->j;
         lfe->val = aij->val;
         lfe->next = info->ptr;
         info->ptr = lfe;
         aij->col->coef -= info->c * (aij->val / info->apq);
      }
      npp->c0 += info->c * (info->b / info->apq);
      /* compute new row bounds */
      if (info->apq > 0.0)
      {  p->lb = (q->ub == +DBL_MAX ?
            -DBL_MAX : info->b - info->apq * q->ub);
         p->ub = (q->lb == -DBL_MAX ?
            +DBL_MAX : info->b - info->apq * q->lb);
      }
      else
      {  p->lb = (q->lb == -DBL_MAX ?
            -DBL_MAX : info->b - info->apq * q->lb);
         p->ub = (q->ub == +DBL_MAX ?
            +DBL_MAX : info->b - info->apq * q->ub);
      }
      /* remove the column from the problem */
      npp_del_col(npp, q);
      return;
}

static int rcv_implied_slack(NPP *npp, void *_info)
{     /* recover column singleton (implied slack variable) */
      struct implied_slack *info = _info;
      NPPLFE *lfe;
      double temp;
      if (npp->sol == GLP_SOL)
      {  /* assign statuses to row p and column q */
         if (npp->r_stat[info->p] == GLP_BS ||
             npp->r_stat[info->p] == GLP_NF)
            npp->c_stat[info->q] = npp->r_stat[info->p];
         else if (npp->r_stat[info->p] == GLP_NL)
            npp->c_stat[info->q] =
               (char)(info->apq > 0.0 ? GLP_NU : GLP_NL);
         else if (npp->r_stat[info->p] == GLP_NU)
            npp->c_stat[info->q] =
               (char)(info->apq > 0.0 ? GLP_NL : GLP_NU);
         else
         {  npp_error();
            return 1;
         }
         npp->r_stat[info->p] = GLP_NS;
      }
      if (npp->sol != GLP_MIP)
      {  /* compute multiplier for row p */
         npp->r_pi[info->p] += info->c / info->apq;
      }
      /* compute value of column q */
      temp = info->b;
      for (lfe = info->ptr; lfe != NULL; lfe = lfe->next)
         temp -= lfe->val * npp->c_value[lfe->ref];
      npp->c_value[info->q] = temp / info->apq;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_implied_free - process column singleton (implied free variable)
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_implied_free(NPP *npp, NPPCOL *q);
*
*  DESCRIPTION
*
*  The routine npp_implied_free processes column q:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  having non-zero coefficient in the only row p, which is inequality
*  constraint:
*
*     L[p] <= sum a[p,j] x[j] + a[p,q] x[q] <= U[p],                 (2)
*             j!=q
*
*  where l[q] < u[q], L[p] < U[p], L[p] > -oo and/or U[p] < +oo.
*
*  RETURNS
*
*  0 - success;
*
*  1 - column lower and/or upper bound(s) can be active;
*
*  2 - problem has no dual feasible solution.
*
*  PROBLEM TRANSFORMATION
*
*  Constraint (2) can be written as follows:
*
*     L[p] - sum a[p,j] x[j] <= a[p,q] x[q] <= U[p] - sum a[p,j] x[j],
*            j!=q                                     j!=q
*
*  from which it follows that:
*
*     alfa <= a[p,q] x[q] <= beta,                                   (3)
*
*  where
*
*     alfa = inf(L[p] - sum a[p,j] x[j]) =
*                       j!=q
*
*          = L[p] - sup sum a[p,j] x[j] =                            (4)
*                       j!=q
*
*          = L[p] -  sum  a[p,j] u[j] -  sum  a[p,j] l[j],
*                  j in Jp             j in Jn
*
*     beta = sup(L[p] - sum a[p,j] x[j]) =
*                       j!=q
*
*          = L[p] - inf sum a[p,j] x[j] =                            (5)
*                       j!=q
*
*          = L[p] -  sum  a[p,j] l[j] -  sum  a[p,j] u[j],
*                  j in Jp             j in Jn
*
*     Jp = {j != q: a[p,j] > 0},  Jn = {j != q: a[p,j] < 0}.         (6)
*
*  Inequality (3) defines implied bounds of variable x[q]:
*
*     l'[q] <= x[q] <= u'[q],                                        (7)
*
*  where
*
*             ( alfa / a[p,q], if a[p,q] > 0
*     l'[q] = <                                                     (8a)
*             ( beta / a[p,q], if a[p,q] < 0
*
*             ( beta / a[p,q], if a[p,q] > 0
*     u'[q] = <                                                     (8b)
*             ( alfa / a[p,q], if a[p,q] < 0
*
*  Thus, if l'[q] > l[q] - eps and u'[q] < u[q] + eps, where eps is
*  an absolute tolerance for column value, column bounds (1) cannot be
*  active, in which case column q can be replaced by equivalent free
*  (unbounded) column.
*
*  Note that column q is column singleton, so in the dual system of the
*  original problem it corresponds to the following row singleton:
*
*     a[p,q] pi[p] + lambda[q] = c[q],                               (9)
*
*  from which it follows that:
*
*     pi[p] = (c[q] - lambda[q]) / a[p,q].                          (10)
*
*  Let x[q] be implied free (unbounded) variable. Then column q can be
*  only basic, so its multiplier lambda[q] is equal to zero, and from
*  (10) we have:
*
*     pi[p] = c[q] / a[p,q].                                        (11)
*
*  There are possible three cases:
*
*  1) pi[p] < -eps, where eps is an absolute tolerance for row
*     multiplier. In this case, to provide dual feasibility of the
*     original problem, row p must be active on its lower bound, and
*     if its lower bound does not exist (L[p] = -oo), the problem has
*     no dual feasible solution;
*
*  2) pi[p] > +eps. In this case row p must be active on its upper
*     bound, and if its upper bound does not exist (U[p] = +oo), the
*     problem has no dual feasible solution;
*
*  3) -eps <= pi[p] <= +eps. In this case any (either lower or upper)
*     bound of row p can be active, because this does not affect dual
*     feasibility.
*
*  Thus, in all three cases original inequality constraint (2) can be
*  replaced by equality constraint, where the right-hand side is either
*  lower or upper bound of row p, and bounds of column q can be removed
*  that makes it free (unbounded). (May note that this transformation
*  can be followed by transformation "Column singleton (implied slack
*  variable)" performed by the routine npp_implied_slack.)
*
*  RECOVERING BASIC SOLUTION
*
*  Status of row p in solution to the original problem is determined
*  by its status in solution to the transformed problem and its bound,
*  which was choosen to be active:
*
*     +-----------------------+--------+--------------------+
*     |    Status of row p    | Active | Status of row p    |
*     | (transformed problem) | bound  | (original problem) |
*     +-----------------------+--------+--------------------+
*     |        GLP_BS         |  L[p]  |       GLP_BS       |
*     |        GLP_BS         |  U[p]  |       GLP_BS       |
*     |        GLP_NS         |  L[p]  |       GLP_NL       |
*     |        GLP_NS         |  U[p]  |       GLP_NU       |
*     +-----------------------+--------+--------------------+
*
*  Value of row multiplier pi[p] (as well as value of column q) in
*  solution to the original problem is the same as in solution to the
*  transformed problem.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of row multiplier pi[p] in solution to the original problem is
*  the same as in solution to the transformed problem.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct implied_free
{     /* column singleton (implied free variable) */
      int p;
      /* row reference number */
      char stat;
      /* row status:
         GLP_NL - active constraint on lower bound
         GLP_NU - active constraint on upper bound */
};

static int rcv_implied_free(NPP *npp, void *info);

int npp_implied_free(NPP *npp, NPPCOL *q)
{     /* process column singleton (implied free variable) */
      struct implied_free *info;
      NPPROW *p;
      NPPAIJ *apq, *aij;
      double alfa, beta, l, u, pi, eps;
      /* the column must be non-fixed singleton */
      xassert(q->lb < q->ub);
      xassert(q->ptr != NULL && q->ptr->c_next == NULL);
      /* corresponding row must be inequality constraint */
      apq = q->ptr;
      p = apq->row;
      xassert(p->lb != -DBL_MAX || p->ub != +DBL_MAX);
      xassert(p->lb < p->ub);
      /* compute alfa */
      alfa = p->lb;
      if (alfa != -DBL_MAX)
      {  for (aij = p->ptr; aij != NULL; aij = aij->r_next)
         {  if (aij == apq) continue; /* skip a[p,q] */
            if (aij->val > 0.0)
            {  if (aij->col->ub == +DBL_MAX)
               {  alfa = -DBL_MAX;
                  break;
               }
               alfa -= aij->val * aij->col->ub;
            }
            else /* < 0.0 */
            {  if (aij->col->lb == -DBL_MAX)
               {  alfa = -DBL_MAX;
                  break;
               }
               alfa -= aij->val * aij->col->lb;
            }
         }
      }
      /* compute beta */
      beta = p->ub;
      if (beta != +DBL_MAX)
      {  for (aij = p->ptr; aij != NULL; aij = aij->r_next)
         {  if (aij == apq) continue; /* skip a[p,q] */
            if (aij->val > 0.0)
            {  if (aij->col->lb == -DBL_MAX)
               {  beta = +DBL_MAX;
                  break;
               }
               beta -= aij->val * aij->col->lb;
            }
            else /* < 0.0 */
            {  if (aij->col->ub == +DBL_MAX)
               {  beta = +DBL_MAX;
                  break;
               }
               beta -= aij->val * aij->col->ub;
            }
         }
      }
      /* compute implied column lower bound l'[q] */
      if (apq->val > 0.0)
         l = (alfa == -DBL_MAX ? -DBL_MAX : alfa / apq->val);
      else /* < 0.0 */
         l = (beta == +DBL_MAX ? -DBL_MAX : beta / apq->val);
      /* compute implied column upper bound u'[q] */
      if (apq->val > 0.0)
         u = (beta == +DBL_MAX ? +DBL_MAX : beta / apq->val);
      else
         u = (alfa == -DBL_MAX ? +DBL_MAX : alfa / apq->val);
      /* check if column lower bound l[q] can be active */
      if (q->lb != -DBL_MAX)
      {  eps = 1e-9 + 1e-12 * fabs(q->lb);
         if (l < q->lb - eps) return 1; /* yes, it can */
      }
      /* check if column upper bound u[q] can be active */
      if (q->ub != +DBL_MAX)
      {  eps = 1e-9 + 1e-12 * fabs(q->ub);
         if (u > q->ub + eps) return 1; /* yes, it can */
      }
      /* okay; make column q free (unbounded) */
      q->lb = -DBL_MAX, q->ub = +DBL_MAX;
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_implied_free, sizeof(struct implied_free));
      info->p = p->i;
      info->stat = -1;
      /* compute row multiplier pi[p] */
      pi = q->coef / apq->val;
      /* check dual feasibility for row p */
      if (pi > +DBL_EPSILON)
      {  /* lower bound L[p] must be active */
         if (p->lb != -DBL_MAX)
nl:      {  info->stat = GLP_NL;
            p->ub = p->lb;
         }
         else
         {  if (pi > +1e-5) return 2; /* dual infeasibility */
            /* take a chance on U[p] */
            xassert(p->ub != +DBL_MAX);
            goto nu;
         }
      }
      else if (pi < -DBL_EPSILON)
      {  /* upper bound U[p] must be active */
         if (p->ub != +DBL_MAX)
nu:      {  info->stat = GLP_NU;
            p->lb = p->ub;
         }
         else
         {  if (pi < -1e-5) return 2; /* dual infeasibility */
            /* take a chance on L[p] */
            xassert(p->lb != -DBL_MAX);
            goto nl;
         }
      }
      else
      {  /* any bound (either L[p] or U[p]) can be made active  */
         if (p->ub == +DBL_MAX)
         {  xassert(p->lb != -DBL_MAX);
            goto nl;
         }
         if (p->lb == -DBL_MAX)
         {  xassert(p->ub != +DBL_MAX);
            goto nu;
         }
         if (fabs(p->lb) <= fabs(p->ub)) goto nl; else goto nu;
      }
      return 0;
}

static int rcv_implied_free(NPP *npp, void *_info)
{     /* recover column singleton (implied free variable) */
      struct implied_free *info = _info;
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] == GLP_BS)
            npp->r_stat[info->p] = GLP_BS;
         else if (npp->r_stat[info->p] == GLP_NS)
         {  xassert(info->stat == GLP_NL || info->stat == GLP_NU);
            npp->r_stat[info->p] = info->stat;
         }
         else
         {  npp_error();
            return 1;
         }
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_eq_doublet - process row doubleton (equality constraint)
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  NPPCOL *npp_eq_doublet(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_eq_doublet processes row p, which is equality
*  constraint having exactly two non-zero coefficients:
*
*     a[p,q] x[q] + a[p,r] x[r] = b.                                 (1)
*
*  As the result of processing one of columns q or r is eliminated from
*  all other rows and, thus, becomes column singleton of type "implied
*  slack variable". Row p is not changed and along with column q and r
*  remains in the problem.
*
*  RETURNS
*
*  The routine npp_eq_doublet returns pointer to the descriptor of that
*  column q or r which has been eliminated. If, due to some reason, the
*  elimination was not performed, the routine returns NULL.
*
*  PROBLEM TRANSFORMATION
*
*  First, we decide which column q or r will be eliminated. Let it be
*  column q. Consider i-th constraint row, where column q has non-zero
*  coefficient a[i,q] != 0:
*
*     L[i] <= sum a[i,j] x[j] <= U[i].                               (2)
*              j
*
*  In order to eliminate column q from row (2) we subtract from it row
*  (1) multiplied by gamma[i] = a[i,q] / a[p,q], i.e. we replace in the
*  transformed problem row (2) by its linear combination with row (1).
*  This transformation changes only coefficients in columns q and r,
*  and bounds of row i as follows:
*
*     a~[i,q] = a[i,q] - gamma[i] a[p,q] = 0,                        (3)
*
*     a~[i,r] = a[i,r] - gamma[i] a[p,r],                            (4)
*
*       L~[i] = L[i] - gamma[i] b,                                   (5)
*
*       U~[i] = U[i] - gamma[i] b.                                   (6)
*
*  RECOVERING BASIC SOLUTION
*
*  The transformation of the primal system of the original problem:
*
*     L <= A x <= U                                                  (7)
*
*  is equivalent to multiplying from the left a transformation matrix F
*  by components of this primal system, which in the transformed problem
*  becomes the following:
*
*     F L <= F A x <= F U  ==>  L~ <= A~x <= U~.                     (8)
*
*  The matrix F has the following structure:
*
*         ( 1           -gamma[1]            )
*         (                                  )
*         (    1        -gamma[2]            )
*         (                                  )
*         (      ...       ...               )
*         (                                  )
*     F = (          1  -gamma[p-1]          )                       (9)
*         (                                  )
*         (                 1                )
*         (                                  )
*         (             -gamma[p+1]  1       )
*         (                                  )
*         (                ...          ...  )
*
*  where its column containing elements -gamma[i] corresponds to row p
*  of the primal system.
*
*  From (8) it follows that the dual system of the original problem:
*
*     A'pi + lambda = c,                                            (10)
*
*  in the transformed problem becomes the following:
*
*     A'F'inv(F')pi + lambda = c  ==>  (A~)'pi~ + lambda = c,       (11)
*
*  where:
*
*     pi~ = inv(F')pi                                               (12)
*
*  is the vector of row multipliers in the transformed problem. Thus:
*
*     pi = F'pi~.                                                   (13)
*
*  Therefore, as it follows from (13), value of multiplier for row p in
*  solution to the original problem can be computed as follows:
*
*     pi[p] = pi~[p] - sum gamma[i] pi~[i],                         (14)
*                       i
*
*  where pi~[i] = pi[i] is multiplier for row i (i != p).
*
*  Note that the statuses of all rows and columns are not changed.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Multiplier for row p in solution to the original problem is computed
*  with formula (14).
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct eq_doublet
{     /* row doubleton (equality constraint) */
      int p;
      /* row reference number */
      double apq;
      /* constraint coefficient a[p,q] */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[i,q], i != p */
};

static int rcv_eq_doublet(NPP *npp, void *info);

NPPCOL *npp_eq_doublet(NPP *npp, NPPROW *p)
{     /* process row doubleton (equality constraint) */
      struct eq_doublet *info;
      NPPROW *i;
      NPPCOL *q, *r;
      NPPAIJ *apq, *apr, *aiq, *air, *next;
      NPPLFE *lfe;
      double gamma;
      /* the row must be doubleton equality constraint */
      xassert(p->lb == p->ub);
      xassert(p->ptr != NULL && p->ptr->r_next != NULL &&
              p->ptr->r_next->r_next == NULL);
      /* choose column to be eliminated */
      {  NPPAIJ *a1, *a2;
         a1 = p->ptr, a2 = a1->r_next;
         if (fabs(a2->val) < 0.001 * fabs(a1->val))
         {  /* only first column can be eliminated, because second one
               has too small constraint coefficient */
            apq = a1, apr = a2;
         }
         else if (fabs(a1->val) < 0.001 * fabs(a2->val))
         {  /* only second column can be eliminated, because first one
               has too small constraint coefficient */
            apq = a2, apr = a1;
         }
         else
         {  /* both columns are appropriate; choose that one which is
               shorter to minimize fill-in */
            if (npp_col_nnz(npp, a1->col) <= npp_col_nnz(npp, a2->col))
            {  /* first column is shorter */
               apq = a1, apr = a2;
            }
            else
            {  /* second column is shorter */
               apq = a2, apr = a1;
            }
         }
      }
      /* now columns q and r have been chosen */
      q = apq->col, r = apr->col;
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_eq_doublet, sizeof(struct eq_doublet));
      info->p = p->i;
      info->apq = apq->val;
      info->ptr = NULL;
      /* transform each row i (i != p), where a[i,q] != 0, to eliminate
         column q */
      for (aiq = q->ptr; aiq != NULL; aiq = next)
      {  next = aiq->c_next;
         if (aiq == apq) continue; /* skip row p */
         i = aiq->row; /* row i to be transformed */
         /* save constraint coefficient a[i,q] */
         if (npp->sol != GLP_MIP)
         {  lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
            lfe->ref = i->i;
            lfe->val = aiq->val;
            lfe->next = info->ptr;
            info->ptr = lfe;
         }
         /* find coefficient a[i,r] in row i */
         for (air = i->ptr; air != NULL; air = air->r_next)
            if (air->col == r) break;
         /* if a[i,r] does not exist, create a[i,r] = 0 */
         if (air == NULL)
            air = npp_add_aij(npp, i, r, 0.0);
         /* compute gamma[i] = a[i,q] / a[p,q] */
         gamma = aiq->val / apq->val;
         /* (row i) := (row i) - gamma[i] * (row p); see (3)-(6) */
         /* new a[i,q] is exact zero due to elimnation; remove it from
            row i */
         npp_del_aij(npp, aiq);
         /* compute new a[i,r] */
         air->val -= gamma * apr->val;
         /* if new a[i,r] is close to zero due to numeric cancelation,
            remove it from row i */
         if (fabs(air->val) <= 1e-10)
            npp_del_aij(npp, air);
         /* compute new lower and upper bounds of row i */
         if (i->lb == i->ub)
            i->lb = i->ub = (i->lb - gamma * p->lb);
         else
         {  if (i->lb != -DBL_MAX)
               i->lb -= gamma * p->lb;
            if (i->ub != +DBL_MAX)
               i->ub -= gamma * p->lb;
         }
      }
      return q;
}

static int rcv_eq_doublet(NPP *npp, void *_info)
{     /* recover row doubleton (equality constraint) */
      struct eq_doublet *info = _info;
      NPPLFE *lfe;
      double gamma, temp;
      /* we assume that processing row p is followed by processing
         column q as singleton of type "implied slack variable", in
         which case row p must always be active equality constraint */
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] != GLP_NS)
         {  npp_error();
            return 1;
         }
      }
      if (npp->sol != GLP_MIP)
      {  /* compute value of multiplier for row p; see (14) */
         temp = npp->r_pi[info->p];
         for (lfe = info->ptr; lfe != NULL; lfe = lfe->next)
         {  gamma = lfe->val / info->apq; /* a[i,q] / a[p,q] */
            temp -= gamma * npp->r_pi[lfe->ref];
         }
         npp->r_pi[info->p] = temp;
      }
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_forcing_row - process forcing row
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_forcing_row(NPP *npp, NPPROW *p, int at);
*
*  DESCRIPTION
*
*  The routine npp_forcing row processes row p of general format:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],                               (1)
*              j
*
*     l[j] <= x[j] <= u[j],                                          (2)
*
*  where L[p] <= U[p] and l[j] < u[j] for all a[p,j] != 0. It is also
*  assumed that:
*
*  1) if at = 0 then |L[p] - U'[p]| <= eps, where U'[p] is implied
*     row upper bound (see below), eps is an absolute tolerance for row
*     value;
*
*  2) if at = 1 then |U[p] - L'[p]| <= eps, where L'[p] is implied
*     row lower bound (see below).
*
*  RETURNS
*
*  0 - success;
*
*  1 - cannot fix columns due to too small constraint coefficients.
*
*  PROBLEM TRANSFORMATION
*
*  Implied lower and upper bounds of row (1) are determined by bounds
*  of corresponding columns (variables) as follows:
*
*     L'[p] = inf sum a[p,j] x[j] =
*                  j
*                                                                    (3)
*           =  sum  a[p,j] l[j] +  sum  a[p,j] u[j],
*            j in Jp             j in Jn
*
*     U'[p] = sup sum a[p,j] x[j] =
*                                                                    (4)
*           =  sum  a[p,j] u[j] +  sum  a[p,j] l[j],
*            j in Jp             j in Jn
*
*     Jp = {j: a[p,j] > 0},  Jn = {j: a[p,j] < 0}.                   (5)
*
*  If L[p] =~ U'[p] (at = 0), solution can be primal feasible only when
*  all variables take their boundary values as defined by (4):
*
*            ( u[j], if j in Jp
*     x[j] = <                                                       (6)
*            ( l[j], if j in Jn
*
*  Similarly, if U[p] =~ L'[p] (at = 1), solution can be primal feasible
*  only when all variables take their boundary values as defined by (3):
*
*            ( l[j], if j in Jp
*     x[j] = <                                                       (7)
*            ( u[j], if j in Jn
*
*  Condition (6) or (7) allows fixing all columns (variables x[j])
*  in row (1) on their bounds and then removing them from the problem
*  (see the routine npp_fixed_col). Due to this row p becomes redundant,
*  so it can be replaced by equivalent free (unbounded) row and also
*  removed from the problem (see the routine npp_free_row).
*
*  1. To apply this transformation row (1) should not have coefficients
*     whose magnitude is too small, i.e. all a[p,j] should satisfy to
*     the following condition:
*
*        |a[p,j]| >= eps * max(1, |a[p,k]|),                         (8)
*                           k
*     where eps is a relative tolerance for constraint coefficients.
*     Otherwise, fixing columns may be numerically unreliable and may
*     lead to wrong solution.
*
*  2. The routine fixes columns and remove bounds of row p, however,
*     it does not remove the row and columns from the problem.
*
*  RECOVERING BASIC SOLUTION
*
*  In the transformed problem row p being inactive constraint is
*  assigned status GLP_BS (as the result of transformation of free
*  row), and all columns in this row are assigned status GLP_NS (as the
*  result of transformation of fixed columns).
*
*  Note that in the dual system of the transformed (as well as original)
*  problem every column j in row p corresponds to the following row:
*
*     sum  a[i,j] pi[i] + a[p,j] pi[p] + lambda[j] = c[j],           (9)
*     i!=p
*
*  from which it follows that:
*
*     lambda[j] = c[j] - sum a[i,j] pi[i] - a[p,j] pi[p].           (10)
*                        i!=p
*
*  In the transformed problem values of all multipliers pi[i] are known
*  (including pi[i], whose value is zero, since row p is inactive).
*  Thus, using formula (10) it is possible to compute values of
*  multipliers lambda[j] for all columns in row p.
*
*  Note also that in the original problem all columns in row p are
*  bounded, not fixed. So status GLP_NS assigned to every such column
*  must be changed to GLP_NL or GLP_NU depending on which bound the
*  corresponding column has been fixed. This status change may lead to
*  dual feasibility violation for solution of the original problem,
*  because now column multipliers must satisfy to the following
*  condition:
*
*               ( >= 0, if status of column j is GLP_NL,
*     lambda[j] <                                                   (11)
*               ( <= 0, if status of column j is GLP_NU.
*
*  If this condition holds, solution to the original problem is the
*  same as to the transformed problem. Otherwise, we have to perform
*  one degenerate pivoting step of the primal simplex method to obtain
*  dual feasible (hence, optimal) solution to the original problem as
*  follows. If, on problem transformation, row p was made active on its
*  lower bound (case at = 0), we change its status to GLP_NL (or GLP_NS)
*  and start increasing its multiplier pi[p]. Otherwise, if row p was
*  made active on its upper bound (case at = 1), we change its status
*  to GLP_NU (or GLP_NS) and start decreasing pi[p]. From (10) it
*  follows that:
*
*     delta lambda[j] = - a[p,j] * delta pi[p] = - a[p,j] pi[p].    (12)
*
*  Simple analysis of formulae (3)-(5) shows that changing pi[p] in the
*  specified direction causes increasing lambda[j] for every column j
*  assigned status GLP_NL (delta lambda[j] > 0) and decreasing lambda[j]
*  for every column j assigned status GLP_NU (delta lambda[j] < 0). It
*  is understood that once the last lambda[q], which violates condition
*  (11), has reached zero, multipliers lambda[j] for all columns get
*  valid signs. Such column q can be determined as follows. Let d[j] be
*  initial value of lambda[j] (i.e. reduced cost of column j) in the
*  transformed problem computed with formula (10) when pi[p] = 0. Then
*  lambda[j] = d[j] + delta lambda[j], and from (12) it follows that
*  lambda[j] becomes zero if:
*
*     delta lambda[j] = - a[p,j] pi[p] = - d[j]  ==>
*                                                                   (13)
*     pi[p] = d[j] / a[p,j].
*
*  Therefore, the last column q, for which lambda[q] becomes zero, can
*  be determined from the following condition:
*
*     |d[q] / a[p,q]| = max  |pi[p]| = max  |d[j] / a[p,j]|,        (14)
*                      j in D         j in D
*
*  where D is a set of columns j whose, reduced costs d[j] have invalid
*  signs, i.e. violate condition (11). (Thus, if D is empty, solution
*  to the original problem is the same as solution to the transformed
*  problem, and no correction is needed as was noticed above.) In
*  solution to the original problem column q is assigned status GLP_BS,
*  since it replaces column of auxiliary variable of row p (becoming
*  active) in the basis, and multiplier for row p is assigned its new
*  value, which is pi[p] = d[q] / a[p,q]. Note that due to primal
*  degeneracy values of all columns having non-zero coefficients in row
*  p remain unchanged.
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  Value of multiplier pi[p] in solution to the original problem is
*  corrected in the same way as for basic solution. Values of all
*  columns having non-zero coefficients in row p remain unchanged.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct forcing_col
{     /* column fixed on its bound by forcing row */
      int j;
      /* column reference number */
      char stat;
      /* original column status:
         GLP_NL - fixed on lower bound
         GLP_NU - fixed on upper bound */
      double a;
      /* constraint coefficient a[p,j] */
      double c;
      /* objective coefficient c[j] */
      NPPLFE *ptr;
      /* list of non-zero coefficients a[i,j], i != p */
      struct forcing_col *next;
      /* pointer to another column fixed by forcing row */
};

struct forcing_row
{     /* forcing row */
      int p;
      /* row reference number */
      char stat;
      /* status assigned to the row if it becomes active:
         GLP_NS - active equality constraint
         GLP_NL - inequality constraint with lower bound active
         GLP_NU - inequality constraint with upper bound active */
      struct forcing_col *ptr;
      /* list of all columns having non-zero constraint coefficient
         a[p,j] in the forcing row */
};

static int rcv_forcing_row(NPP *npp, void *info);

int npp_forcing_row(NPP *npp, NPPROW *p, int at)
{     /* process forcing row */
      struct forcing_row *info;
      struct forcing_col *col = NULL;
      NPPCOL *j;
      NPPAIJ *apj, *aij;
      NPPLFE *lfe;
      double big;
      xassert(at == 0 || at == 1);
      /* determine maximal magnitude of the row coefficients */
      big = 1.0;
      for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         if (big < fabs(apj->val)) big = fabs(apj->val);
      /* if there are too small coefficients in the row, transformation
         should not be applied */
      for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         if (fabs(apj->val) < 1e-7 * big) return 1;
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_forcing_row, sizeof(struct forcing_row));
      info->p = p->i;
      if (p->lb == p->ub)
      {  /* equality constraint */
         info->stat = GLP_NS;
      }
      else if (at == 0)
      {  /* inequality constraint; case L[p] = U'[p] */
         info->stat = GLP_NL;
         xassert(p->lb != -DBL_MAX);
      }
      else /* at == 1 */
      {  /* inequality constraint; case U[p] = L'[p] */
         info->stat = GLP_NU;
         xassert(p->ub != +DBL_MAX);
      }
      info->ptr = NULL;
      /* scan the forcing row, fix columns at corresponding bounds, and
         save column information (the latter is not needed for MIP) */
      for (apj = p->ptr; apj != NULL; apj = apj->r_next)
      {  /* column j has non-zero coefficient in the forcing row */
         j = apj->col;
         /* it must be non-fixed */
         xassert(j->lb < j->ub);
         /* allocate stack entry to save column information */
         if (npp->sol != GLP_MIP)
         {  col = dmp_get_atom(npp->stack, sizeof(struct forcing_col));
            col->j = j->j;
            col->stat = -1; /* will be set below */
            col->a = apj->val;
            col->c = j->coef;
            col->ptr = NULL;
            col->next = info->ptr;
            info->ptr = col;
         }
         /* fix column j */
         if (at == 0 && apj->val < 0.0 || at != 0 && apj->val > 0.0)
         {  /* at its lower bound */
            if (npp->sol != GLP_MIP)
               col->stat = GLP_NL;
            xassert(j->lb != -DBL_MAX);
            j->ub = j->lb;
         }
         else
         {  /* at its upper bound */
            if (npp->sol != GLP_MIP)
               col->stat = GLP_NU;
            xassert(j->ub != +DBL_MAX);
            j->lb = j->ub;
         }
         /* save column coefficients a[i,j], i != p */
         if (npp->sol != GLP_MIP)
         {  for (aij = j->ptr; aij != NULL; aij = aij->c_next)
            {  if (aij == apj) continue; /* skip a[p,j] */
               lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
               lfe->ref = aij->row->i;
               lfe->val = aij->val;
               lfe->next = col->ptr;
               col->ptr = lfe;
            }
         }
      }
      /* make the row free (unbounded) */
      p->lb = -DBL_MAX, p->ub = +DBL_MAX;
      return 0;
}

static int rcv_forcing_row(NPP *npp, void *_info)
{     /* recover forcing row */
      struct forcing_row *info = _info;
      struct forcing_col *col, *piv;
      NPPLFE *lfe;
      double d, big, temp;
      if (npp->sol == GLP_MIP) goto done;
      /* initially solution to the original problem is the same as
         to the transformed problem, where row p is inactive constraint
         with pi[p] = 0, and all columns are non-basic */
      if (npp->sol == GLP_SOL)
      {  if (npp->r_stat[info->p] != GLP_BS)
         {  npp_error();
            return 1;
         }
         for (col = info->ptr; col != NULL; col = col->next)
         {  if (npp->c_stat[col->j] != GLP_NS)
            {  npp_error();
               return 1;
            }
            npp->c_stat[col->j] = col->stat; /* original status */
         }
      }
      /* compute reduced costs d[j] for all columns with formula (10)
         and store them in col.c instead objective coefficients */
      for (col = info->ptr; col != NULL; col = col->next)
      {  d = col->c;
         for (lfe = col->ptr; lfe != NULL; lfe = lfe->next)
            d -= lfe->val * npp->r_pi[lfe->ref];
         col->c = d;
      }
      /* consider columns j, whose multipliers lambda[j] has wrong
         sign in solution to the transformed problem (where lambda[j] =
         d[j]), and choose column q, whose multipler lambda[q] reaches
         zero last on changing row multiplier pi[p]; see (14) */
      piv = NULL, big = 0.0;
      for (col = info->ptr; col != NULL; col = col->next)
      {  d = col->c; /* d[j] */
         temp = fabs(d / col->a);
         if (col->stat == GLP_NL)
         {  /* column j has active lower bound */
            if (d < 0.0 && big < temp)
               piv = col, big = temp;
         }
         else if (col->stat == GLP_NU)
         {  /* column j has active upper bound */
            if (d > 0.0 && big < temp)
               piv = col, big = temp;
         }
         else
         {  npp_error();
            return 1;
         }
      }
      /* if column q does not exist, no correction is needed */
      if (piv != NULL)
      {  /* correct solution; row p becomes active constraint while
            column q becomes basic */
         if (npp->sol == GLP_SOL)
         {  npp->r_stat[info->p] = info->stat;
            npp->c_stat[piv->j] = GLP_BS;
         }
         /* assign new value to row multiplier pi[p] = d[p] / a[p,q] */
         npp->r_pi[info->p] = piv->c / piv->a;
      }
done: return 0;
}

/***********************************************************************
*  NAME
*
*  npp_analyze_row - perform general row analysis
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_analyze_row(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_analyze_row performs analysis of row p of general
*  format:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],                               (1)
*              j
*
*     l[j] <= x[j] <= u[j],                                          (2)
*
*  where L[p] <= U[p] and l[j] <= u[j] for all a[p,j] != 0.
*
*  RETURNS
*
*  0x?0 - row lower bound does not exist or is redundant;
*
*  0x?1 - row lower bound can be active;
*
*  0x?2 - row lower bound is a forcing bound;
*
*  0x0? - row upper bound does not exist or is redundant;
*
*  0x1? - row upper bound can be active;
*
*  0x2? - row upper bound is a forcing bound;
*
*  0x33 - row bounds are inconsistent with column bounds.
*
*  ALGORITHM
*
*  Analysis of row (1) is based on analysis of its implied lower and
*  upper bounds, which are determined by bounds of corresponding columns
*  (variables) as follows:
*
*     L'[p] = inf sum a[p,j] x[j] =
*                  j
*                                                                    (3)
*           =  sum  a[p,j] l[j] +  sum  a[p,j] u[j],
*            j in Jp             j in Jn
*
*     U'[p] = sup sum a[p,j] x[j] =
*                                                                    (4)
*           =  sum  a[p,j] u[j] +  sum  a[p,j] l[j],
*            j in Jp             j in Jn
*
*     Jp = {j: a[p,j] > 0},  Jn = {j: a[p,j] < 0}.                   (5)
*
*  (Note that bounds of all columns in row p are assumed to be correct,
*  so L'[p] <= U'[p].)
*
*  Analysis of row lower bound L[p] includes the following cases:
*
*  1) if L[p] > U'[p] + eps, where eps is an absolute tolerance for row
*     value, row lower bound L[p] and implied row upper bound U'[p] are
*     inconsistent, ergo, the problem has no primal feasible solution;
*
*  2) if U'[p] - eps <= L[p] <= U'[p] + eps, i.e. if L[p] =~ U'[p],
*     the row is a forcing row on its lower bound (see description of
*     the routine npp_forcing_row);
*
*  3) if L[p] > L'[p] + eps, row lower bound L[p] can be active (this
*     conclusion does not account other rows in the problem);
*
*  4) if L[p] <= L'[p] + eps, row lower bound L[p] cannot be active, so
*     it is redundant and can be removed (replaced by -oo).
*
*  Analysis of row upper bound U[p] is performed in a similar way and
*  includes the following cases:
*
*  1) if U[p] < L'[p] - eps, row upper bound U[p] and implied row lower
*     bound L'[p] are inconsistent, ergo the problem has no primal
*     feasible solution;
*
*  2) if L'[p] - eps <= U[p] <= L'[p] + eps, i.e. if U[p] =~ L'[p],
*     the row is a forcing row on its upper bound (see description of
*     the routine npp_forcing_row);
*
*  3) if U[p] < U'[p] - eps, row upper bound U[p] can be active (this
*     conclusion does not account other rows in the problem);
*
*  4) if U[p] >= U'[p] - eps, row upper bound U[p] cannot be active, so
*     it is redundant and can be removed (replaced by +oo). */

int npp_analyze_row(NPP *npp, NPPROW *p)
{     /* perform general row analysis */
      NPPAIJ *aij;
      int ret = 0x00;
      double l, u, eps;
      xassert(npp == npp);
      /* compute implied lower bound L'[p]; see (3) */
      l = 0.0;
      for (aij = p->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->val > 0.0)
         {  if (aij->col->lb == -DBL_MAX)
            {  l = -DBL_MAX;
               break;
            }
            l += aij->val * aij->col->lb;
         }
         else /* aij->val < 0.0 */
         {  if (aij->col->ub == +DBL_MAX)
            {  l = -DBL_MAX;
               break;
            }
            l += aij->val * aij->col->ub;
         }
      }
      /* compute implied upper bound U'[p]; see (4) */
      u = 0.0;
      for (aij = p->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->val > 0.0)
         {  if (aij->col->ub == +DBL_MAX)
            {  u = +DBL_MAX;
               break;
            }
            u += aij->val * aij->col->ub;
         }
         else /* aij->val < 0.0 */
         {  if (aij->col->lb == -DBL_MAX)
            {  u = +DBL_MAX;
               break;
            }
            u += aij->val * aij->col->lb;
         }
      }
      /* column bounds are assumed correct, so L'[p] <= U'[p] */
      /* check if row lower bound is consistent */
      if (p->lb != -DBL_MAX)
      {  eps = 1e-3 + 1e-6 * fabs(p->lb);
         if (p->lb - eps > u)
         {  ret = 0x33;
            goto done;
         }
      }
      /* check if row upper bound is consistent */
      if (p->ub != +DBL_MAX)
      {  eps = 1e-3 + 1e-6 * fabs(p->ub);
         if (p->ub + eps < l)
         {  ret = 0x33;
            goto done;
         }
      }
      /* check if row lower bound can be active/forcing */
      if (p->lb != -DBL_MAX)
      {  eps = 1e-9 + 1e-12 * fabs(p->lb);
         if (p->lb - eps > l)
         {  if (p->lb + eps <= u)
               ret |= 0x01;
            else
               ret |= 0x02;
         }
      }
      /* check if row upper bound can be active/forcing */
      if (p->ub != +DBL_MAX)
      {  eps = 1e-9 + 1e-12 * fabs(p->ub);
         if (p->ub + eps < u)
         {  /* check if the upper bound is forcing */
            if (p->ub - eps >= l)
               ret |= 0x10;
            else
               ret |= 0x20;
         }
      }
done: return ret;
}

/***********************************************************************
*  NAME
*
*  npp_inactive_bound - remove row lower/upper inactive bound
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_inactive_bound(NPP *npp, NPPROW *p, int which);
*
*  DESCRIPTION
*
*  The routine npp_inactive_bound removes lower (if which = 0) or upper
*  (if which = 1) bound of row p:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],
*
*  which (bound) is assumed to be redundant.
*
*  PROBLEM TRANSFORMATION
*
*  If which = 0, current lower bound L[p] of row p is assigned -oo.
*  If which = 1, current upper bound U[p] of row p is assigned +oo.
*
*  RECOVERING BASIC SOLUTION
*
*  If in solution to the transformed problem row p is inactive
*  constraint (GLP_BS), its status is not changed in solution to the
*  original problem. Otherwise, status of row p in solution to the
*  original problem is defined by its type before transformation and
*  its status in solution to the transformed problem as follows:
*
*     +---------------------+-------+---------------+---------------+
*     |        Row          | Flag  | Row status in | Row status in |
*     |        type         | which | transfmd soln | original soln |
*     +---------------------+-------+---------------+---------------+
*     |     sum >= L[p]     |   0   |    GLP_NF     |    GLP_NL     |
*     |     sum <= U[p]     |   1   |    GLP_NF     |    GLP_NU     |
*     | L[p] <= sum <= U[p] |   0   |    GLP_NU     |    GLP_NU     |
*     | L[p] <= sum <= U[p] |   1   |    GLP_NL     |    GLP_NL     |
*     |  sum = L[p] = U[p]  |   0   |    GLP_NU     |    GLP_NS     |
*     |  sum = L[p] = U[p]  |   1   |    GLP_NL     |    GLP_NS     |
*     +---------------------+-------+---------------+---------------+
*
*  RECOVERING INTERIOR-POINT SOLUTION
*
*  None needed.
*
*  RECOVERING MIP SOLUTION
*
*  None needed. */

struct inactive_bound
{     /* row inactive bound */
      int p;
      /* row reference number */
      char stat;
      /* row status (if active constraint) */
};

static int rcv_inactive_bound(NPP *npp, void *info);

void npp_inactive_bound(NPP *npp, NPPROW *p, int which)
{     /* remove row lower/upper inactive bound */
      struct inactive_bound *info;
      if (npp->sol == GLP_SOL)
      {  /* create transformation stack entry */
         info = npp_push_tse(npp,
            rcv_inactive_bound, sizeof(struct inactive_bound));
         info->p = p->i;
         if (p->ub == +DBL_MAX)
            info->stat = GLP_NL;
         else if (p->lb == -DBL_MAX)
            info->stat = GLP_NU;
         else if (p->lb != p->ub)
            info->stat = (char)(which == 0 ? GLP_NU : GLP_NL);
         else
            info->stat = GLP_NS;
      }
      /* remove row inactive bound */
      if (which == 0)
      {  xassert(p->lb != -DBL_MAX);
         p->lb = -DBL_MAX;
      }
      else if (which == 1)
      {  xassert(p->ub != +DBL_MAX);
         p->ub = +DBL_MAX;
      }
      else
         xassert(which != which);
      return;
}

static int rcv_inactive_bound(NPP *npp, void *_info)
{     /* recover row status */
      struct inactive_bound *info = _info;
      if (npp->sol != GLP_SOL)
      {  npp_error();
         return 1;
      }
      if (npp->r_stat[info->p] == GLP_BS)
         npp->r_stat[info->p] = GLP_BS;
      else
         npp->r_stat[info->p] = info->stat;
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_implied_bounds - determine implied column bounds
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_implied_bounds(NPP *npp, NPPROW *p);
*
*  DESCRIPTION
*
*  The routine npp_implied_bounds inspects general row (constraint) p:
*
*     L[p] <= sum a[p,j] x[j] <= U[p],                               (1)
*
*     l[j] <= x[j] <= u[j],                                          (2)
*
*  where L[p] <= U[p] and l[j] <= u[j] for all a[p,j] != 0, to compute
*  implied bounds of columns (variables x[j]) in this row.
*
*  The routine stores implied column bounds l'[j] and u'[j] in column
*  descriptors (NPPCOL); it does not change current column bounds l[j]
*  and u[j]. (Implied column bounds can be then used to strengthen the
*  current column bounds; see the routines npp_implied_lower and
*  npp_implied_upper).
*
*  ALGORITHM
*
*  Current column bounds (2) define implied lower and upper bounds of
*  row (1) as follows:
*
*     L'[p] = inf sum a[p,j] x[j] =
*                  j
*                                                                    (3)
*           =  sum  a[p,j] l[j] +  sum  a[p,j] u[j],
*            j in Jp             j in Jn
*
*     U'[p] = sup sum a[p,j] x[j] =
*                                                                    (4)
*           =  sum  a[p,j] u[j] +  sum  a[p,j] l[j],
*            j in Jp             j in Jn
*
*     Jp = {j: a[p,j] > 0},  Jn = {j: a[p,j] < 0}.                   (5)
*
*  (Note that bounds of all columns in row p are assumed to be correct,
*  so L'[p] <= U'[p].)
*
*  If L[p] > L'[p] and/or U[p] < U'[p], the lower and/or upper bound of
*  row (1) can be active, in which case such row defines implied bounds
*  of its variables.
*
*  Let x[k] be some variable having in row (1) coefficient a[p,k] != 0.
*  Consider a case when row lower bound can be active (L[p] > L'[p]):
*
*     sum a[p,j] x[j] >= L[p]  ==>
*      j
*
*     sum a[p,j] x[j] + a[p,k] x[k] >= L[p]  ==>
*     j!=k
*                                                                    (6)
*     a[p,k] x[k] >= L[p] - sum a[p,j] x[j]  ==>
*                           j!=k
*
*     a[p,k] x[k] >= L[p,k],
*
*  where
*
*     L[p,k] = inf(L[p] - sum a[p,j] x[j]) =
*                         j!=k
*
*            = L[p] - sup sum a[p,j] x[j] =                          (7)
*                         j!=k
*
*            = L[p] - sum a[p,j] u[j] - sum a[p,j] l[j].
*                    j in Jp\{k}       j in Jn\{k}
*
*  Thus:
*
*     x[k] >= l'[k] = L[p,k] / a[p,k],  if a[p,k] > 0,               (8)
*
*     x[k] <= u'[k] = L[p,k] / a[p,k],  if a[p,k] < 0.               (9)
*
*  where l'[k] and u'[k] are implied lower and upper bounds of variable
*  x[k], resp.
*
*  Now consider a similar case when row upper bound can be active
*  (U[p] < U'[p]):
*
*     sum a[p,j] x[j] <= U[p]  ==>
*      j
*
*     sum a[p,j] x[j] + a[p,k] x[k] <= U[p]  ==>
*     j!=k
*                                                                   (10)
*     a[p,k] x[k] <= U[p] - sum a[p,j] x[j]  ==>
*                           j!=k
*
*     a[p,k] x[k] <= U[p,k],
*
*  where:
*
*     U[p,k] = sup(U[p] - sum a[p,j] x[j]) =
*                         j!=k
*
*            = U[p] - inf sum a[p,j] x[j] =                         (11)
*                         j!=k
*
*            = U[p] - sum a[p,j] l[j] - sum a[p,j] u[j].
*                    j in Jp\{k}       j in Jn\{k}
*
*  Thus:
*
*     x[k] <= u'[k] = U[p,k] / a[p,k],  if a[p,k] > 0,              (12)
*
*     x[k] >= l'[k] = U[p,k] / a[p,k],  if a[p,k] < 0.              (13)
*
*  Note that in formulae (8), (9), (12), and (13) coefficient a[p,k]
*  must not be too small in magnitude relatively to other non-zero
*  coefficients in row (1), i.e. the following condition must hold:
*
*     |a[p,k]| >= eps * max(1, |a[p,j]|),                           (14)
*                        j
*
*  where eps is a relative tolerance for constraint coefficients.
*  Otherwise the implied column bounds can be numerical inreliable. For
*  example, using formula (8) for the following inequality constraint:
*
*     1e-12 x1 - x2 - x3 >= 0,
*
*  where x1 >= -1, x2, x3, >= 0, may lead to numerically unreliable
*  conclusion that x1 >= 0.
*
*  Using formulae (8), (9), (12), and (13) to compute implied bounds
*  for one variable requires |J| operations, where J = {j: a[p,j] != 0},
*  because this needs computing L[p,k] and U[p,k]. Thus, computing
*  implied bounds for all variables in row (1) would require |J|^2
*  operations, that is not a good technique. However, the total number
*  of operations can be reduced to |J| as follows.
*
*  Let a[p,k] > 0. Then from (7) and (11) we have:
*
*     L[p,k] = L[p] - (U'[p] - a[p,k] u[k]) =
*
*            = L[p] - U'[p] + a[p,k] u[k],
*
*     U[p,k] = U[p] - (L'[p] - a[p,k] l[k]) =
*
*            = U[p] - L'[p] + a[p,k] l[k],
*
*  where L'[p] and U'[p] are implied row lower and upper bounds defined
*  by formulae (3) and (4). Substituting these expressions into (8) and
*  (12) gives:
*
*     l'[k] = L[p,k] / a[p,k] = u[k] + (L[p] - U'[p]) / a[p,k],     (15)
*
*     u'[k] = U[p,k] / a[p,k] = l[k] + (U[p] - L'[p]) / a[p,k].     (16)
*
*  Similarly, if a[p,k] < 0, according to (7) and (11) we have:
*
*     L[p,k] = L[p] - (U'[p] - a[p,k] l[k]) =
*
*            = L[p] - U'[p] + a[p,k] l[k],
*
*     U[p,k] = U[p] - (L'[p] - a[p,k] u[k]) =
*
*            = U[p] - L'[p] + a[p,k] u[k],
*
*  and substituting these expressions into (8) and (12) gives:
*
*     l'[k] = U[p,k] / a[p,k] = u[k] + (U[p] - L'[p]) / a[p,k],     (17)
*
*     u'[k] = L[p,k] / a[p,k] = l[k] + (L[p] - U'[p]) / a[p,k].     (18)
*
*  Note that formulae (15)-(18) can be used only if L'[p] and U'[p]
*  exist. However, if for some variable x[j] it happens that l[j] = -oo
*  and/or u[j] = +oo, values of L'[p] (if a[p,j] > 0) and/or U'[p] (if
*  a[p,j] < 0) are undefined. Consider, therefore, the most general
*  situation, when some column bounds (2) may not exist.
*
*  Let:
*
*     J' = {j : (a[p,j] > 0 and l[j] = -oo) or
*                                                                   (19)
*               (a[p,j] < 0 and u[j] = +oo)}.
*
*  Then (assuming that row upper bound U[p] can be active) the following
*  three cases are possible:
*
*  1) |J'| = 0. In this case L'[p] exists, thus, for all variables x[j]
*     in row (1) we can use formulae (16) and (17);
*
*  2) J' = {k}. In this case L'[p] = -oo, however, U[p,k] (11) exists,
*     so for variable x[k] we can use formulae (12) and (13). Note that
*     for all other variables x[j] (j != k) l'[j] = -oo (if a[p,j] < 0)
*     or u'[j] = +oo (if a[p,j] > 0);
*
*  3) |J'| > 1. In this case for all variables x[j] in row [1] we have
*     l'[j] = -oo (if a[p,j] < 0) or u'[j] = +oo (if a[p,j] > 0).
*
*  Similarly, let:
*
*     J'' = {j : (a[p,j] > 0 and u[j] = +oo) or
*                                                                   (20)
*                (a[p,j] < 0 and l[j] = -oo)}.
*
*  Then (assuming that row lower bound L[p] can be active) the following
*  three cases are possible:
*
*  1) |J''| = 0. In this case U'[p] exists, thus, for all variables x[j]
*     in row (1) we can use formulae (15) and (18);
*
*  2) J'' = {k}. In this case U'[p] = +oo, however, L[p,k] (7) exists,
*     so for variable x[k] we can use formulae (8) and (9). Note that
*     for all other variables x[j] (j != k) l'[j] = -oo (if a[p,j] > 0)
*     or u'[j] = +oo (if a[p,j] < 0);
*
*  3) |J''| > 1. In this case for all variables x[j] in row (1) we have
*     l'[j] = -oo (if a[p,j] > 0) or u'[j] = +oo (if a[p,j] < 0). */

void npp_implied_bounds(NPP *npp, NPPROW *p)
{     NPPAIJ *apj, *apk;
      double big, eps, temp;
      xassert(npp == npp);
      /* initialize implied bounds for all variables and determine
         maximal magnitude of row coefficients a[p,j] */
      big = 1.0;
      for (apj = p->ptr; apj != NULL; apj = apj->r_next)
      {  apj->col->ll.ll = -DBL_MAX, apj->col->uu.uu = +DBL_MAX;
         if (big < fabs(apj->val)) big = fabs(apj->val);
      }
      eps = 1e-6 * big;
      /* process row lower bound (assuming that it can be active) */
      if (p->lb != -DBL_MAX)
      {  apk = NULL;
         for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         {  if (apj->val > 0.0 && apj->col->ub == +DBL_MAX ||
                apj->val < 0.0 && apj->col->lb == -DBL_MAX)
            {  if (apk == NULL)
                  apk = apj;
               else
                  goto skip1;
            }
         }
         /* if a[p,k] = NULL then |J'| = 0 else J' = { k } */
         temp = p->lb;
         for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         {  if (apj == apk)
               /* skip a[p,k] */;
            else if (apj->val > 0.0)
               temp -= apj->val * apj->col->ub;
            else /* apj->val < 0.0 */
               temp -= apj->val * apj->col->lb;
         }
         /* compute column implied bounds */
         if (apk == NULL)
         {  /* temp = L[p] - U'[p] */
            for (apj = p->ptr; apj != NULL; apj = apj->r_next)
            {  if (apj->val >= +eps)
               {  /* l'[j] := u[j] + (L[p] - U'[p]) / a[p,j] */
                  apj->col->ll.ll = apj->col->ub + temp / apj->val;
               }
               else if (apj->val <= -eps)
               {  /* u'[j] := l[j] + (L[p] - U'[p]) / a[p,j] */
                  apj->col->uu.uu = apj->col->lb + temp / apj->val;
               }
            }
         }
         else
         {  /* temp = L[p,k] */
            if (apk->val >= +eps)
            {  /* l'[k] := L[p,k] / a[p,k] */
               apk->col->ll.ll = temp / apk->val;
            }
            else if (apk->val <= -eps)
            {  /* u'[k] := L[p,k] / a[p,k] */
               apk->col->uu.uu = temp / apk->val;
            }
         }
skip1:   ;
      }
      /* process row upper bound (assuming that it can be active) */
      if (p->ub != +DBL_MAX)
      {  apk = NULL;
         for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         {  if (apj->val > 0.0 && apj->col->lb == -DBL_MAX ||
                apj->val < 0.0 && apj->col->ub == +DBL_MAX)
            {  if (apk == NULL)
                  apk = apj;
               else
                  goto skip2;
            }
         }
         /* if a[p,k] = NULL then |J''| = 0 else J'' = { k } */
         temp = p->ub;
         for (apj = p->ptr; apj != NULL; apj = apj->r_next)
         {  if (apj == apk)
               /* skip a[p,k] */;
            else if (apj->val > 0.0)
               temp -= apj->val * apj->col->lb;
            else /* apj->val < 0.0 */
               temp -= apj->val * apj->col->ub;
         }
         /* compute column implied bounds */
         if (apk == NULL)
         {  /* temp = U[p] - L'[p] */
            for (apj = p->ptr; apj != NULL; apj = apj->r_next)
            {  if (apj->val >= +eps)
               {  /* u'[j] := l[j] + (U[p] - L'[p]) / a[p,j] */
                  apj->col->uu.uu = apj->col->lb + temp / apj->val;
               }
               else if (apj->val <= -eps)
               {  /* l'[j] := u[j] + (U[p] - L'[p]) / a[p,j] */
                  apj->col->ll.ll = apj->col->ub + temp / apj->val;
               }
            }
         }
         else
         {  /* temp = U[p,k] */
            if (apk->val >= +eps)
            {  /* u'[k] := U[p,k] / a[p,k] */
               apk->col->uu.uu = temp / apk->val;
            }
            else if (apk->val <= -eps)
            {  /* l'[k] := U[p,k] / a[p,k] */
               apk->col->ll.ll = temp / apk->val;
            }
         }
skip2:   ;
      }
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp4.c0000644000175100001710000014234100000000000023733 0ustar00runnerdocker00000000000000/* npp4.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  npp_binarize_prob - binarize MIP problem
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_binarize_prob(NPP *npp);
*
*  DESCRIPTION
*
*  The routine npp_binarize_prob replaces in the original MIP problem
*  every integer variable:
*
*     l[q] <= x[q] <= u[q],                                          (1)
*
*  where l[q] < u[q], by an equivalent sum of binary variables.
*
*  RETURNS
*
*  The routine returns the number of integer variables for which the
*  transformation failed, because u[q] - l[q] > d_max.
*
*  PROBLEM TRANSFORMATION
*
*  If variable x[q] has non-zero lower bound, it is first processed
*  with the routine npp_lbnd_col. Thus, we can assume that:
*
*     0 <= x[q] <= u[q].                                             (2)
*
*  If u[q] = 1, variable x[q] is already binary, so further processing
*  is not needed. Let, therefore, that 2 <= u[q] <= d_max, and n be a
*  smallest integer such that u[q] <= 2^n - 1 (n >= 2, since u[q] >= 2).
*  Then variable x[q] can be replaced by the following sum:
*
*            n-1
*     x[q] = sum 2^k x[k],                                           (3)
*            k=0
*
*  where x[k] are binary columns (variables). If u[q] < 2^n - 1, the
*  following additional inequality constraint must be also included in
*  the transformed problem:
*
*     n-1
*     sum 2^k x[k] <= u[q].                                          (4)
*     k=0
*
*  Note: Assuming that in the transformed problem x[q] becomes binary
*  variable x[0], this transformation causes new n-1 binary variables
*  to appear.
*
*  Substituting x[q] from (3) to the objective row gives:
*
*     z = sum c[j] x[j] + c[0] =
*          j
*
*       = sum c[j] x[j] + c[q] x[q] + c[0] =
*         j!=q
*                              n-1
*       = sum c[j] x[j] + c[q] sum 2^k x[k] + c[0] =
*         j!=q                 k=0
*                         n-1
*       = sum c[j] x[j] + sum c[k] x[k] + c[0],
*         j!=q            k=0
*
*  where:
*
*     c[k] = 2^k c[q],  k = 0, ..., n-1.                             (5)
*
*  And substituting x[q] from (3) to i-th constraint row i gives:
*
*     L[i] <= sum a[i,j] x[j] <= U[i]  ==>
*              j
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] x[q] <= U[i]  ==>
*             j!=q
*                                      n-1
*     L[i] <= sum a[i,j] x[j] + a[i,q] sum 2^k x[k] <= U[i]  ==>
*             j!=q                     k=0
*                               n-1
*     L[i] <= sum a[i,j] x[j] + sum a[i,k] x[k] <= U[i],
*             j!=q              k=0
*
*  where:
*
*     a[i,k] = 2^k a[i,q],  k = 0, ..., n-1.                         (6)
*
*  RECOVERING SOLUTION
*
*  Value of variable x[q] is computed with formula (3). */

struct binarize
{     int q;
      /* column reference number for x[q] = x[0] */
      int j;
      /* column reference number for x[1]; x[2] has reference number
         j+1, x[3] - j+2, etc. */
      int n;
      /* total number of binary variables, n >= 2 */
};

static int rcv_binarize_prob(NPP *npp, void *info);

int npp_binarize_prob(NPP *npp)
{     /* binarize MIP problem */
      struct binarize *info;
      NPPROW *row;
      NPPCOL *col, *bin;
      NPPAIJ *aij;
      int u, n, k, temp, nfails, nvars, nbins, nrows;
      /* new variables will be added to the end of the column list, so
         we go from the end to beginning of the column list */
      nfails = nvars = nbins = nrows = 0;
      for (col = npp->c_tail; col != NULL; col = col->prev)
      {  /* skip continuous variable */
         if (!col->is_int) continue;
         /* skip fixed variable */
         if (col->lb == col->ub) continue;
         /* skip binary variable */
         if (col->lb == 0.0 && col->ub == 1.0) continue;
         /* check if the transformation is applicable */
         if (col->lb < -1e6 || col->ub > +1e6 ||
             col->ub - col->lb > 4095.0)
         {  /* unfortunately, not */
            nfails++;
            continue;
         }
         /* process integer non-binary variable x[q] */
         nvars++;
         /* make x[q] non-negative, if its lower bound is non-zero */
         if (col->lb != 0.0)
            npp_lbnd_col(npp, col);
         /* now 0 <= x[q] <= u[q] */
         xassert(col->lb == 0.0);
         u = (int)col->ub;
         xassert(col->ub == (double)u);
         /* if x[q] is binary, further processing is not needed */
         if (u == 1) continue;
         /* determine smallest n such that u <= 2^n - 1 (thus, n is the
            number of binary variables needed) */
         n = 2, temp = 4;
         while (u >= temp)
            n++, temp += temp;
         nbins += n;
         /* create transformation stack entry */
         info = npp_push_tse(npp,
            rcv_binarize_prob, sizeof(struct binarize));
         info->q = col->j;
         info->j = 0; /* will be set below */
         info->n = n;
         /* if u < 2^n - 1, we need one additional row for (4) */
         if (u < temp - 1)
         {  row = npp_add_row(npp), nrows++;
            row->lb = -DBL_MAX, row->ub = u;
         }
         else
            row = NULL;
         /* in the transformed problem variable x[q] becomes binary
            variable x[0], so its objective and constraint coefficients
            are not changed */
         col->ub = 1.0;
         /* include x[0] into constraint (4) */
         if (row != NULL)
            npp_add_aij(npp, row, col, 1.0);
         /* add other binary variables x[1], ..., x[n-1] */
         for (k = 1, temp = 2; k < n; k++, temp += temp)
         {  /* add new binary variable x[k] */
            bin = npp_add_col(npp);
            bin->is_int = 1;
            bin->lb = 0.0, bin->ub = 1.0;
            bin->coef = (double)temp * col->coef;
            /* store column reference number for x[1] */
            if (info->j == 0)
               info->j = bin->j;
            else
               xassert(info->j + (k-1) == bin->j);
            /* duplicate constraint coefficients for x[k]; this also
               automatically includes x[k] into constraint (4) */
            for (aij = col->ptr; aij != NULL; aij = aij->c_next)
               npp_add_aij(npp, aij->row, bin, (double)temp * aij->val);
         }
      }
      if (nvars > 0)
         xprintf("%d integer variable(s) were replaced by %d binary one"
            "s\n", nvars, nbins);
      if (nrows > 0)
         xprintf("%d row(s) were added due to binarization\n", nrows);
      if (nfails > 0)
         xprintf("Binarization failed for %d integer variable(s)\n",
            nfails);
      return nfails;
}

static int rcv_binarize_prob(NPP *npp, void *_info)
{     /* recovery binarized variable */
      struct binarize *info = _info;
      int k, temp;
      double sum;
      /* compute value of x[q]; see formula (3) */
      sum = npp->c_value[info->q];
      for (k = 1, temp = 2; k < info->n; k++, temp += temp)
         sum += (double)temp * npp->c_value[info->j + (k-1)];
      npp->c_value[info->q] = sum;
      return 0;
}

/**********************************************************************/

struct elem
{     /* linear form element a[j] x[j] */
      double aj;
      /* non-zero coefficient value */
      NPPCOL *xj;
      /* pointer to variable (column) */
      struct elem *next;
      /* pointer to another term */
};

static struct elem *copy_form(NPP *npp, NPPROW *row, double s)
{     /* copy linear form */
      NPPAIJ *aij;
      struct elem *ptr, *e;
      ptr = NULL;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  e = dmp_get_atom(npp->pool, sizeof(struct elem));
         e->aj = s * aij->val;
         e->xj = aij->col;
         e->next = ptr;
         ptr = e;
      }
      return ptr;
}

static void drop_form(NPP *npp, struct elem *ptr)
{     /* drop linear form */
      struct elem *e;
      while (ptr != NULL)
      {  e = ptr;
         ptr = e->next;
         dmp_free_atom(npp->pool, e, sizeof(struct elem));
      }
      return;
}

/***********************************************************************
*  NAME
*
*  npp_is_packing - test if constraint is packing inequality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_is_packing(NPP *npp, NPPROW *row);
*
*  RETURNS
*
*  If the specified row (constraint) is packing inequality (see below),
*  the routine npp_is_packing returns non-zero. Otherwise, it returns
*  zero.
*
*  PACKING INEQUALITIES
*
*  In canonical format the packing inequality is the following:
*
*     sum  x[j] <= 1,                                                (1)
*    j in J
*
*  where all variables x[j] are binary. This inequality expresses the
*  condition that in any integer feasible solution at most one variable
*  from set J can take non-zero (unity) value while other variables
*  must be equal to zero. W.l.o.g. it is assumed that |J| >= 2, because
*  if J is empty or |J| = 1, the inequality (1) is redundant.
*
*  In general case the packing inequality may include original variables
*  x[j] as well as their complements x~[j]:
*
*     sum   x[j] + sum   x~[j] <= 1,                                 (2)
*    j in Jp      j in Jn
*
*  where Jp and Jn are not intersected. Therefore, using substitution
*  x~[j] = 1 - x[j] gives the packing inequality in generalized format:
*
*     sum   x[j] - sum   x[j] <= 1 - |Jn|.                           (3)
*    j in Jp      j in Jn */

int npp_is_packing(NPP *npp, NPPROW *row)
{     /* test if constraint is packing inequality */
      NPPCOL *col;
      NPPAIJ *aij;
      int b;
      xassert(npp == npp);
      if (!(row->lb == -DBL_MAX && row->ub != +DBL_MAX))
         return 0;
      b = 1;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  col = aij->col;
         if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
            return 0;
         if (aij->val == +1.0)
            ;
         else if (aij->val == -1.0)
            b--;
         else
            return 0;
      }
      if (row->ub != (double)b) return 0;
      return 1;
}

/***********************************************************************
*  NAME
*
*  npp_hidden_packing - identify hidden packing inequality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_hidden_packing(NPP *npp, NPPROW *row);
*
*  DESCRIPTION
*
*  The routine npp_hidden_packing processes specified inequality
*  constraint, which includes only binary variables, and the number of
*  the variables is not less than two. If the original inequality is
*  equivalent to a packing inequality, the routine replaces it by this
*  equivalent inequality. If the original constraint is double-sided
*  inequality, it is replaced by a pair of single-sided inequalities,
*  if necessary.
*
*  RETURNS
*
*  If the original inequality constraint was replaced by equivalent
*  packing inequality, the routine npp_hidden_packing returns non-zero.
*  Otherwise, it returns zero.
*
*  PROBLEM TRANSFORMATION
*
*  Consider an inequality constraint:
*
*     sum  a[j] x[j] <= b,                                           (1)
*    j in J
*
*  where all variables x[j] are binary, and |J| >= 2. (In case of '>='
*  inequality it can be transformed to '<=' format by multiplying both
*  its sides by -1.)
*
*  Let Jp = {j: a[j] > 0}, Jn = {j: a[j] < 0}. Performing substitution
*  x[j] = 1 - x~[j] for all j in Jn, we have:
*
*     sum   a[j] x[j] <= b  ==>
*    j in J
*
*     sum   a[j] x[j] + sum   a[j] x[j] <= b  ==>
*    j in Jp           j in Jn
*
*     sum   a[j] x[j] + sum   a[j] (1 - x~[j]) <= b  ==>
*    j in Jp           j in Jn
*
*     sum   a[j] x[j] - sum   a[j] x~[j] <= b - sum   a[j].
*    j in Jp           j in Jn                 j in Jn
*
*  Thus, meaning the transformation above, we can assume that in
*  inequality (1) all coefficients a[j] are positive. Moreover, we can
*  assume that a[j] <= b. In fact, let a[j] > b; then the following
*  three cases are possible:
*
*  1) b < 0. In this case inequality (1) is infeasible, so the problem
*     has no feasible solution (see the routine npp_analyze_row);
*
*  2) b = 0. In this case inequality (1) is a forcing inequality on its
*     upper bound (see the routine npp_forcing row), from which it
*     follows that all variables x[j] should be fixed at zero;
*
*  3) b > 0. In this case inequality (1) defines an implied zero upper
*     bound for variable x[j] (see the routine npp_implied_bounds), from
*     which it follows that x[j] should be fixed at zero.
*
*  It is assumed that all three cases listed above have been recognized
*  by the routine npp_process_prob, which performs basic MIP processing
*  prior to a call the routine npp_hidden_packing. So, if one of these
*  cases occurs, we should just skip processing such constraint.
*
*  Thus, let 0 < a[j] <= b. Then it is obvious that constraint (1) is
*  equivalent to packing inquality only if:
*
*     a[j] + a[k] > b + eps                                          (2)
*
*  for all j, k in J, j != k, where eps is an absolute tolerance for
*  row (linear form) value. Checking the condition (2) for all j and k,
*  j != k, requires time O(|J|^2). However, this time can be reduced to
*  O(|J|), if use minimal a[j] and a[k], in which case it is sufficient
*  to check the condition (2) only once.
*
*  Once the original inequality (1) is replaced by equivalent packing
*  inequality, we need to perform back substitution x~[j] = 1 - x[j] for
*  all j in Jn (see above).
*
*  RECOVERING SOLUTION
*
*  None needed. */

static int hidden_packing(NPP *npp, struct elem *ptr, double *_b)
{     /* process inequality constraint: sum a[j] x[j] <= b;
         0 - specified row is NOT hidden packing inequality;
         1 - specified row is packing inequality;
         2 - specified row is hidden packing inequality. */
      struct elem *e, *ej, *ek;
      int neg;
      double b = *_b, eps;
      xassert(npp == npp);
      /* a[j] must be non-zero, x[j] must be binary, for all j in J */
      for (e = ptr; e != NULL; e = e->next)
      {  xassert(e->aj != 0.0);
         xassert(e->xj->is_int);
         xassert(e->xj->lb == 0.0 && e->xj->ub == 1.0);
      }
      /* check if the specified inequality constraint already has the
         form of packing inequality */
      neg = 0; /* neg is |Jn| */
      for (e = ptr; e != NULL; e = e->next)
      {  if (e->aj == +1.0)
            ;
         else if (e->aj == -1.0)
            neg++;
         else
            break;
      }
      if (e == NULL)
      {  /* all coefficients a[j] are +1 or -1; check rhs b */
         if (b == (double)(1 - neg))
         {  /* it is packing inequality; no processing is needed */
            return 1;
         }
      }
      /* substitute x[j] = 1 - x~[j] for all j in Jn to make all a[j]
         positive; the result is a~[j] = |a[j]| and new rhs b */
      for (e = ptr; e != NULL; e = e->next)
         if (e->aj < 0) b -= e->aj;
      /* now a[j] > 0 for all j in J (actually |a[j]| are used) */
      /* if a[j] > b, skip processing--this case must not appear */
      for (e = ptr; e != NULL; e = e->next)
         if (fabs(e->aj) > b) return 0;
      /* now 0 < a[j] <= b for all j in J */
      /* find two minimal coefficients a[j] and a[k], j != k */
      ej = NULL;
      for (e = ptr; e != NULL; e = e->next)
         if (ej == NULL || fabs(ej->aj) > fabs(e->aj)) ej = e;
      xassert(ej != NULL);
      ek = NULL;
      for (e = ptr; e != NULL; e = e->next)
         if (e != ej)
            if (ek == NULL || fabs(ek->aj) > fabs(e->aj)) ek = e;
      xassert(ek != NULL);
      /* the specified constraint is equivalent to packing inequality
         iff a[j] + a[k] > b + eps */
      eps = 1e-3 + 1e-6 * fabs(b);
      if (fabs(ej->aj) + fabs(ek->aj) <= b + eps) return 0;
      /* perform back substitution x~[j] = 1 - x[j] and construct the
         final equivalent packing inequality in generalized format */
      b = 1.0;
      for (e = ptr; e != NULL; e = e->next)
      {  if (e->aj > 0.0)
            e->aj = +1.0;
         else /* e->aj < 0.0 */
            e->aj = -1.0, b -= 1.0;
      }
      *_b = b;
      return 2;
}

int npp_hidden_packing(NPP *npp, NPPROW *row)
{     /* identify hidden packing inequality */
      NPPROW *copy;
      NPPAIJ *aij;
      struct elem *ptr, *e;
      int kase, ret, count = 0;
      double b;
      /* the row must be inequality constraint */
      xassert(row->lb < row->ub);
      for (kase = 0; kase <= 1; kase++)
      {  if (kase == 0)
         {  /* process row upper bound */
            if (row->ub == +DBL_MAX) continue;
            ptr = copy_form(npp, row, +1.0);
            b = + row->ub;
         }
         else
         {  /* process row lower bound */
            if (row->lb == -DBL_MAX) continue;
            ptr = copy_form(npp, row, -1.0);
            b = - row->lb;
         }
         /* now the inequality has the form "sum a[j] x[j] <= b" */
         ret = hidden_packing(npp, ptr, &b);
         xassert(0 <= ret && ret <= 2);
         if (kase == 1 && ret == 1 || ret == 2)
         {  /* the original inequality has been identified as hidden
               packing inequality */
            count++;
#ifdef GLP_DEBUG
            xprintf("Original constraint:\n");
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
               xprintf(" %+g x%d", aij->val, aij->col->j);
            if (row->lb != -DBL_MAX) xprintf(", >= %g", row->lb);
            if (row->ub != +DBL_MAX) xprintf(", <= %g", row->ub);
            xprintf("\n");
            xprintf("Equivalent packing inequality:\n");
            for (e = ptr; e != NULL; e = e->next)
               xprintf(" %sx%d", e->aj > 0.0 ? "+" : "-", e->xj->j);
            xprintf(", <= %g\n", b);
#endif
            if (row->lb == -DBL_MAX || row->ub == +DBL_MAX)
            {  /* the original row is single-sided inequality; no copy
                  is needed */
               copy = NULL;
            }
            else
            {  /* the original row is double-sided inequality; we need
                  to create its copy for other bound before replacing it
                  with the equivalent inequality */
               copy = npp_add_row(npp);
               if (kase == 0)
               {  /* the copy is for lower bound */
                  copy->lb = row->lb, copy->ub = +DBL_MAX;
               }
               else
               {  /* the copy is for upper bound */
                  copy->lb = -DBL_MAX, copy->ub = row->ub;
               }
               /* copy original row coefficients */
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  npp_add_aij(npp, copy, aij->col, aij->val);
            }
            /* replace the original inequality by equivalent one */
            npp_erase_row(npp, row);
            row->lb = -DBL_MAX, row->ub = b;
            for (e = ptr; e != NULL; e = e->next)
               npp_add_aij(npp, row, e->xj, e->aj);
            /* continue processing lower bound for the copy */
            if (copy != NULL) row = copy;
         }
         drop_form(npp, ptr);
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  npp_implied_packing - identify implied packing inequality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_implied_packing(NPP *npp, NPPROW *row, int which,
*     NPPCOL *var[], char set[]);
*
*  DESCRIPTION
*
*  The routine npp_implied_packing processes specified row (constraint)
*  of general format:
*
*     L <= sum a[j] x[j] <= U.                                       (1)
*           j
*
*  If which = 0, only lower bound L, which must exist, is considered,
*  while upper bound U is ignored. Similarly, if which = 1, only upper
*  bound U, which must exist, is considered, while lower bound L is
*  ignored. Thus, if the specified row is a double-sided inequality or
*  equality constraint, this routine should be called twice for both
*  lower and upper bounds.
*
*  The routine npp_implied_packing attempts to find a non-trivial (i.e.
*  having not less than two binary variables) packing inequality:
*
*     sum   x[j] - sum   x[j] <= 1 - |Jn|,                           (2)
*    j in Jp      j in Jn
*
*  which is relaxation of the constraint (1) in the sense that any
*  solution satisfying to that constraint also satisfies to the packing
*  inequality (2). If such relaxation exists, the routine stores
*  pointers to descriptors of corresponding binary variables and their
*  flags, resp., to locations var[1], var[2], ..., var[len] and set[1],
*  set[2], ..., set[len], where set[j] = 0 means that j in Jp and
*  set[j] = 1 means that j in Jn.
*
*  RETURNS
*
*  The routine npp_implied_packing returns len, which is the total
*  number of binary variables in the packing inequality found, len >= 2.
*  However, if the relaxation does not exist, the routine returns zero.
*
*  ALGORITHM
*
*  If which = 0, the constraint coefficients (1) are multiplied by -1
*  and b is assigned -L; if which = 1, the constraint coefficients (1)
*  are not changed and b is assigned +U. In both cases the specified
*  constraint gets the following format:
*
*     sum a[j] x[j] <= b.                                            (3)
*      j
*
*  (Note that (3) is a relaxation of (1), because one of bounds L or U
*  is ignored.)
*
*  Let J be set of binary variables, Kp be set of non-binary (integer
*  or continuous) variables with a[j] > 0, and Kn be set of non-binary
*  variables with a[j] < 0. Then the inequality (3) can be written as
*  follows:
*
*     sum  a[j] x[j] <= b - sum   a[j] x[j] - sum   a[j] x[j].       (4)
*    j in J                j in Kp           j in Kn
*
*  To get rid of non-binary variables we can replace the inequality (4)
*  by the following relaxed inequality:
*
*     sum  a[j] x[j] <= b~,                                          (5)
*    j in J
*
*  where:
*
*     b~ = sup(b - sum   a[j] x[j] - sum   a[j] x[j]) =
*                 j in Kp           j in Kn
*
*        = b - inf sum   a[j] x[j] - inf sum   a[j] x[j] =           (6)
*                 j in Kp               j in Kn
*
*        = b - sum   a[j] l[j] - sum   a[j] u[j].
*             j in Kp           j in Kn
*
*  Note that if lower bound l[j] (if j in Kp) or upper bound u[j]
*  (if j in Kn) of some non-binary variable x[j] does not exist, then
*  formally b = +oo, in which case further analysis is not performed.
*
*  Let Bp = {j in J: a[j] > 0}, Bn = {j in J: a[j] < 0}. To make all
*  the inequality coefficients in (5) positive, we replace all x[j] in
*  Bn by their complementaries, substituting x[j] = 1 - x~[j] for all
*  j in Bn, that gives:
*
*     sum   a[j] x[j] - sum   a[j] x~[j] <= b~ - sum   a[j].         (7)
*    j in Bp           j in Bn                  j in Bn
*
*  This inequality is a relaxation of the original constraint (1), and
*  it is a binary knapsack inequality. Writing it in the standard format
*  we have:
*
*     sum  alfa[j] z[j] <= beta,                                     (8)
*    j in J
*
*  where:
*               ( + a[j],   if j in Bp,
*     alfa[j] = <                                                    (9)
*               ( - a[j],   if j in Bn,
*
*               ( x[j],     if j in Bp,
*        z[j] = <                                                   (10)
*               ( 1 - x[j], if j in Bn,
*
*        beta = b~ - sum   a[j].                                    (11)
*                   j in Bn
*
*  In the inequality (8) all coefficients are positive, therefore, the
*  packing relaxation to be found for this inequality is the following:
*
*     sum  z[j] <= 1.                                               (12)
*    j in P
*
*  It is obvious that set P within J, which we would like to find, must
*  satisfy to the following condition:
*
*     alfa[j] + alfa[k] > beta + eps  for all j, k in P, j != k,    (13)
*
*  where eps is an absolute tolerance for value of the linear form.
*  Thus, it is natural to take P = {j: alpha[j] > (beta + eps) / 2}.
*  Moreover, if in the equality (8) there exist coefficients alfa[k],
*  for which alfa[k] <= (beta + eps) / 2, but which, nevertheless,
*  satisfies to the condition (13) for all j in P, *one* corresponding
*  variable z[k] (having, for example, maximal coefficient alfa[k]) can
*  be included in set P, that allows increasing the number of binary
*  variables in (12) by one.
*
*  Once the set P has been built, for the inequality (12) we need to
*  perform back substitution according to (10) in order to express it
*  through the original binary variables. As the result of such back
*  substitution the relaxed packing inequality get its final format (2),
*  where Jp = J intersect Bp, and Jn = J intersect Bn. */

int npp_implied_packing(NPP *npp, NPPROW *row, int which,
      NPPCOL *var[], char set[])
{     struct elem *ptr, *e, *i, *k;
      int len = 0;
      double b, eps;
      /* build inequality (3) */
      if (which == 0)
      {  ptr = copy_form(npp, row, -1.0);
         xassert(row->lb != -DBL_MAX);
         b = - row->lb;
      }
      else if (which == 1)
      {  ptr = copy_form(npp, row, +1.0);
         xassert(row->ub != +DBL_MAX);
         b = + row->ub;
      }
      /* remove non-binary variables to build relaxed inequality (5);
         compute its right-hand side b~ with formula (6) */
      for (e = ptr; e != NULL; e = e->next)
      {  if (!(e->xj->is_int && e->xj->lb == 0.0 && e->xj->ub == 1.0))
         {  /* x[j] is non-binary variable */
            if (e->aj > 0.0)
            {  if (e->xj->lb == -DBL_MAX) goto done;
               b -= e->aj * e->xj->lb;
            }
            else /* e->aj < 0.0 */
            {  if (e->xj->ub == +DBL_MAX) goto done;
               b -= e->aj * e->xj->ub;
            }
            /* a[j] = 0 means that variable x[j] is removed */
            e->aj = 0.0;
         }
      }
      /* substitute x[j] = 1 - x~[j] to build knapsack inequality (8);
         compute its right-hand side beta with formula (11) */
      for (e = ptr; e != NULL; e = e->next)
         if (e->aj < 0.0) b -= e->aj;
      /* if beta is close to zero, the knapsack inequality is either
         infeasible or forcing inequality; this must never happen, so
         we skip further analysis */
      if (b < 1e-3) goto done;
      /* build set P as well as sets Jp and Jn, and determine x[k] as
         explained above in comments to the routine */
      eps = 1e-3 + 1e-6 * b;
      i = k = NULL;
      for (e = ptr; e != NULL; e = e->next)
      {  /* note that alfa[j] = |a[j]| */
         if (fabs(e->aj) > 0.5 * (b + eps))
         {  /* alfa[j] > (b + eps) / 2; include x[j] in set P, i.e. in
               set Jp or Jn */
            var[++len] = e->xj;
            set[len] = (char)(e->aj > 0.0 ? 0 : 1);
            /* alfa[i] = min alfa[j] over all j included in set P */
            if (i == NULL || fabs(i->aj) > fabs(e->aj)) i = e;
         }
         else if (fabs(e->aj) >= 1e-3)
         {  /* alfa[k] = max alfa[j] over all j not included in set P;
               we skip coefficient a[j] if it is close to zero to avoid
               numerically unreliable results */
            if (k == NULL || fabs(k->aj) < fabs(e->aj)) k = e;
         }
      }
      /* if alfa[k] satisfies to condition (13) for all j in P, include
         x[k] in P */
      if (i != NULL && k != NULL && fabs(i->aj) + fabs(k->aj) > b + eps)
      {  var[++len] = k->xj;
         set[len] = (char)(k->aj > 0.0 ? 0 : 1);
      }
      /* trivial packing inequality being redundant must never appear,
         so we just ignore it */
      if (len < 2) len = 0;
done: drop_form(npp, ptr);
      return len;
}

/***********************************************************************
*  NAME
*
*  npp_is_covering - test if constraint is covering inequality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_is_covering(NPP *npp, NPPROW *row);
*
*  RETURNS
*
*  If the specified row (constraint) is covering inequality (see below),
*  the routine npp_is_covering returns non-zero. Otherwise, it returns
*  zero.
*
*  COVERING INEQUALITIES
*
*  In canonical format the covering inequality is the following:
*
*     sum  x[j] >= 1,                                                (1)
*    j in J
*
*  where all variables x[j] are binary. This inequality expresses the
*  condition that in any integer feasible solution variables in set J
*  cannot be all equal to zero at the same time, i.e. at least one
*  variable must take non-zero (unity) value. W.l.o.g. it is assumed
*  that |J| >= 2, because if J is empty, the inequality (1) is
*  infeasible, and if |J| = 1, the inequality (1) is a forcing row.
*
*  In general case the covering inequality may include original
*  variables x[j] as well as their complements x~[j]:
*
*     sum   x[j] + sum   x~[j] >= 1,                                 (2)
*    j in Jp      j in Jn
*
*  where Jp and Jn are not intersected. Therefore, using substitution
*  x~[j] = 1 - x[j] gives the packing inequality in generalized format:
*
*     sum   x[j] - sum   x[j] >= 1 - |Jn|.                           (3)
*    j in Jp      j in Jn
*
*  (May note that the inequality (3) cuts off infeasible solutions,
*  where x[j] = 0 for all j in Jp and x[j] = 1 for all j in Jn.)
*
*  NOTE: If |J| = 2, the inequality (3) is equivalent to packing
*        inequality (see the routine npp_is_packing). */

int npp_is_covering(NPP *npp, NPPROW *row)
{     /* test if constraint is covering inequality */
      NPPCOL *col;
      NPPAIJ *aij;
      int b;
      xassert(npp == npp);
      if (!(row->lb != -DBL_MAX && row->ub == +DBL_MAX))
         return 0;
      b = 1;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  col = aij->col;
         if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
            return 0;
         if (aij->val == +1.0)
            ;
         else if (aij->val == -1.0)
            b--;
         else
            return 0;
      }
      if (row->lb != (double)b) return 0;
      return 1;
}

/***********************************************************************
*  NAME
*
*  npp_hidden_covering - identify hidden covering inequality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_hidden_covering(NPP *npp, NPPROW *row);
*
*  DESCRIPTION
*
*  The routine npp_hidden_covering processes specified inequality
*  constraint, which includes only binary variables, and the number of
*  the variables is not less than three. If the original inequality is
*  equivalent to a covering inequality (see below), the routine
*  replaces it by the equivalent inequality. If the original constraint
*  is double-sided inequality, it is replaced by a pair of single-sided
*  inequalities, if necessary.
*
*  RETURNS
*
*  If the original inequality constraint was replaced by equivalent
*  covering inequality, the routine npp_hidden_covering returns
*  non-zero. Otherwise, it returns zero.
*
*  PROBLEM TRANSFORMATION
*
*  Consider an inequality constraint:
*
*     sum  a[j] x[j] >= b,                                           (1)
*    j in J
*
*  where all variables x[j] are binary, and |J| >= 3. (In case of '<='
*  inequality it can be transformed to '>=' format by multiplying both
*  its sides by -1.)
*
*  Let Jp = {j: a[j] > 0}, Jn = {j: a[j] < 0}. Performing substitution
*  x[j] = 1 - x~[j] for all j in Jn, we have:
*
*     sum   a[j] x[j] >= b  ==>
*    j in J
*
*     sum   a[j] x[j] + sum   a[j] x[j] >= b  ==>
*    j in Jp           j in Jn
*
*     sum   a[j] x[j] + sum   a[j] (1 - x~[j]) >= b  ==>
*    j in Jp           j in Jn
*
*     sum  m   a[j] x[j] - sum   a[j] x~[j] >= b - sum   a[j].
*    j in Jp              j in Jn                 j in Jn
*
*  Thus, meaning the transformation above, we can assume that in
*  inequality (1) all coefficients a[j] are positive. Moreover, we can
*  assume that b > 0, because otherwise the inequality (1) would be
*  redundant (see the routine npp_analyze_row). It is then obvious that
*  constraint (1) is equivalent to covering inequality only if:
*
*     a[j] >= b,                                                     (2)
*
*  for all j in J.
*
*  Once the original inequality (1) is replaced by equivalent covering
*  inequality, we need to perform back substitution x~[j] = 1 - x[j] for
*  all j in Jn (see above).
*
*  RECOVERING SOLUTION
*
*  None needed. */

static int hidden_covering(NPP *npp, struct elem *ptr, double *_b)
{     /* process inequality constraint: sum a[j] x[j] >= b;
         0 - specified row is NOT hidden covering inequality;
         1 - specified row is covering inequality;
         2 - specified row is hidden covering inequality. */
      struct elem *e;
      int neg;
      double b = *_b, eps;
      xassert(npp == npp);
      /* a[j] must be non-zero, x[j] must be binary, for all j in J */
      for (e = ptr; e != NULL; e = e->next)
      {  xassert(e->aj != 0.0);
         xassert(e->xj->is_int);
         xassert(e->xj->lb == 0.0 && e->xj->ub == 1.0);
      }
      /* check if the specified inequality constraint already has the
         form of covering inequality */
      neg = 0; /* neg is |Jn| */
      for (e = ptr; e != NULL; e = e->next)
      {  if (e->aj == +1.0)
            ;
         else if (e->aj == -1.0)
            neg++;
         else
            break;
      }
      if (e == NULL)
      {  /* all coefficients a[j] are +1 or -1; check rhs b */
         if (b == (double)(1 - neg))
         {  /* it is covering inequality; no processing is needed */
            return 1;
         }
      }
      /* substitute x[j] = 1 - x~[j] for all j in Jn to make all a[j]
         positive; the result is a~[j] = |a[j]| and new rhs b */
      for (e = ptr; e != NULL; e = e->next)
         if (e->aj < 0) b -= e->aj;
      /* now a[j] > 0 for all j in J (actually |a[j]| are used) */
      /* if b <= 0, skip processing--this case must not appear */
      if (b < 1e-3) return 0;
      /* now a[j] > 0 for all j in J, and b > 0 */
      /* the specified constraint is equivalent to covering inequality
         iff a[j] >= b for all j in J */
      eps = 1e-9 + 1e-12 * fabs(b);
      for (e = ptr; e != NULL; e = e->next)
         if (fabs(e->aj) < b - eps) return 0;
      /* perform back substitution x~[j] = 1 - x[j] and construct the
         final equivalent covering inequality in generalized format */
      b = 1.0;
      for (e = ptr; e != NULL; e = e->next)
      {  if (e->aj > 0.0)
            e->aj = +1.0;
         else /* e->aj < 0.0 */
            e->aj = -1.0, b -= 1.0;
      }
      *_b = b;
      return 2;
}

int npp_hidden_covering(NPP *npp, NPPROW *row)
{     /* identify hidden covering inequality */
      NPPROW *copy;
      NPPAIJ *aij;
      struct elem *ptr, *e;
      int kase, ret, count = 0;
      double b;
      /* the row must be inequality constraint */
      xassert(row->lb < row->ub);
      for (kase = 0; kase <= 1; kase++)
      {  if (kase == 0)
         {  /* process row lower bound */
            if (row->lb == -DBL_MAX) continue;
            ptr = copy_form(npp, row, +1.0);
            b = + row->lb;
         }
         else
         {  /* process row upper bound */
            if (row->ub == +DBL_MAX) continue;
            ptr = copy_form(npp, row, -1.0);
            b = - row->ub;
         }
         /* now the inequality has the form "sum a[j] x[j] >= b" */
         ret = hidden_covering(npp, ptr, &b);
         xassert(0 <= ret && ret <= 2);
         if (kase == 1 && ret == 1 || ret == 2)
         {  /* the original inequality has been identified as hidden
               covering inequality */
            count++;
#ifdef GLP_DEBUG
            xprintf("Original constraint:\n");
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
               xprintf(" %+g x%d", aij->val, aij->col->j);
            if (row->lb != -DBL_MAX) xprintf(", >= %g", row->lb);
            if (row->ub != +DBL_MAX) xprintf(", <= %g", row->ub);
            xprintf("\n");
            xprintf("Equivalent covering inequality:\n");
            for (e = ptr; e != NULL; e = e->next)
               xprintf(" %sx%d", e->aj > 0.0 ? "+" : "-", e->xj->j);
            xprintf(", >= %g\n", b);
#endif
            if (row->lb == -DBL_MAX || row->ub == +DBL_MAX)
            {  /* the original row is single-sided inequality; no copy
                  is needed */
               copy = NULL;
            }
            else
            {  /* the original row is double-sided inequality; we need
                  to create its copy for other bound before replacing it
                  with the equivalent inequality */
               copy = npp_add_row(npp);
               if (kase == 0)
               {  /* the copy is for upper bound */
                  copy->lb = -DBL_MAX, copy->ub = row->ub;
               }
               else
               {  /* the copy is for lower bound */
                  copy->lb = row->lb, copy->ub = +DBL_MAX;
               }
               /* copy original row coefficients */
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  npp_add_aij(npp, copy, aij->col, aij->val);
            }
            /* replace the original inequality by equivalent one */
            npp_erase_row(npp, row);
            row->lb = b, row->ub = +DBL_MAX;
            for (e = ptr; e != NULL; e = e->next)
               npp_add_aij(npp, row, e->xj, e->aj);
            /* continue processing upper bound for the copy */
            if (copy != NULL) row = copy;
         }
         drop_form(npp, ptr);
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  npp_is_partitioning - test if constraint is partitioning equality
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_is_partitioning(NPP *npp, NPPROW *row);
*
*  RETURNS
*
*  If the specified row (constraint) is partitioning equality (see
*  below), the routine npp_is_partitioning returns non-zero. Otherwise,
*  it returns zero.
*
*  PARTITIONING EQUALITIES
*
*  In canonical format the partitioning equality is the following:
*
*     sum  x[j] = 1,                                                 (1)
*    j in J
*
*  where all variables x[j] are binary. This equality expresses the
*  condition that in any integer feasible solution exactly one variable
*  in set J must take non-zero (unity) value while other variables must
*  be equal to zero. W.l.o.g. it is assumed that |J| >= 2, because if
*  J is empty, the inequality (1) is infeasible, and if |J| = 1, the
*  inequality (1) is a fixing row.
*
*  In general case the partitioning equality may include original
*  variables x[j] as well as their complements x~[j]:
*
*     sum   x[j] + sum   x~[j] = 1,                                  (2)
*    j in Jp      j in Jn
*
*  where Jp and Jn are not intersected. Therefore, using substitution
*  x~[j] = 1 - x[j] leads to the partitioning equality in generalized
*  format:
*
*     sum   x[j] - sum   x[j] = 1 - |Jn|.                            (3)
*    j in Jp      j in Jn */

int npp_is_partitioning(NPP *npp, NPPROW *row)
{     /* test if constraint is partitioning equality */
      NPPCOL *col;
      NPPAIJ *aij;
      int b;
      xassert(npp == npp);
      if (row->lb != row->ub) return 0;
      b = 1;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  col = aij->col;
         if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
            return 0;
         if (aij->val == +1.0)
            ;
         else if (aij->val == -1.0)
            b--;
         else
            return 0;
      }
      if (row->lb != (double)b) return 0;
      return 1;
}

/***********************************************************************
*  NAME
*
*  npp_reduce_ineq_coef - reduce inequality constraint coefficients
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_reduce_ineq_coef(NPP *npp, NPPROW *row);
*
*  DESCRIPTION
*
*  The routine npp_reduce_ineq_coef processes specified inequality
*  constraint attempting to replace it by an equivalent constraint,
*  where magnitude of coefficients at binary variables is smaller than
*  in the original constraint. If the inequality is double-sided, it is
*  replaced by a pair of single-sided inequalities, if necessary.
*
*  RETURNS
*
*  The routine npp_reduce_ineq_coef returns the number of coefficients
*  reduced.
*
*  BACKGROUND
*
*  Consider an inequality constraint:
*
*     sum  a[j] x[j] >= b.                                           (1)
*    j in J
*
*  (In case of '<=' inequality it can be transformed to '>=' format by
*  multiplying both its sides by -1.) Let x[k] be a binary variable;
*  other variables can be integer as well as continuous. We can write
*  constraint (1) as follows:
*
*     a[k] x[k] + t[k] >= b,                                         (2)
*
*  where:
*
*     t[k] = sum      a[j] x[j].                                     (3)
*           j in J\{k}
*
*  Since x[k] is binary, constraint (2) is equivalent to disjunction of
*  the following two constraints:
*
*     x[k] = 0,  t[k] >= b                                           (4)
*
*        OR
*
*     x[k] = 1,  t[k] >= b - a[k].                                   (5)
*
*  Let also that for the partial sum t[k] be known some its implied
*  lower bound inf t[k].
*
*  Case a[k] > 0. Let inf t[k] < b, since otherwise both constraints
*  (4) and (5) and therefore constraint (2) are redundant.
*  If inf t[k] > b - a[k], only constraint (5) is redundant, in which
*  case it can be replaced with the following redundant and therefore
*  equivalent constraint:
*
*     t[k] >= b - a'[k] = inf t[k],                                  (6)
*
*  where:
*
*     a'[k] = b - inf t[k].                                          (7)
*
*  Thus, the original constraint (2) is equivalent to the following
*  constraint with coefficient at variable x[k] changed:
*
*     a'[k] x[k] + t[k] >= b.                                        (8)
*
*  From inf t[k] < b it follows that a'[k] > 0, i.e. the coefficient
*  at x[k] keeps its sign. And from inf t[k] > b - a[k] it follows that
*  a'[k] < a[k], i.e. the coefficient reduces in magnitude.
*
*  Case a[k] < 0. Let inf t[k] < b - a[k], since otherwise both
*  constraints (4) and (5) and therefore constraint (2) are redundant.
*  If inf t[k] > b, only constraint (4) is redundant, in which case it
*  can be replaced with the following redundant and therefore equivalent
*  constraint:
*
*     t[k] >= b' = inf t[k].                                         (9)
*
*  Rewriting constraint (5) as follows:
*
*     t[k] >= b - a[k] = b' - a'[k],                                (10)
*
*  where:
*
*     a'[k] = a[k] + b' - b = a[k] + inf t[k] - b,                  (11)
*
*  we can see that disjunction of constraint (9) and (10) is equivalent
*  to disjunction of constraint (4) and (5), from which it follows that
*  the original constraint (2) is equivalent to the following constraint
*  with both coefficient at variable x[k] and right-hand side changed:
*
*     a'[k] x[k] + t[k] >= b'.                                      (12)
*
*  From inf t[k] < b - a[k] it follows that a'[k] < 0, i.e. the
*  coefficient at x[k] keeps its sign. And from inf t[k] > b it follows
*  that a'[k] > a[k], i.e. the coefficient reduces in magnitude.
*
*  PROBLEM TRANSFORMATION
*
*  In the routine npp_reduce_ineq_coef the following implied lower
*  bound of the partial sum (3) is used:
*
*     inf t[k] = sum       a[j] l[j] + sum       a[j] u[j],         (13)
*               j in Jp\{k}           k in Jn\{k}
*
*  where Jp = {j : a[j] > 0}, Jn = {j : a[j] < 0}, l[j] and u[j] are
*  lower and upper bounds, resp., of variable x[j].
*
*  In order to compute inf t[k] more efficiently, the following formula,
*  which is equivalent to (13), is actually used:
*
*                ( h - a[k] l[k] = h,        if a[k] > 0,
*     inf t[k] = <                                                  (14)
*                ( h - a[k] u[k] = h - a[k], if a[k] < 0,
*
*  where:
*
*     h = sum   a[j] l[j] + sum   a[j] u[j]                         (15)
*        j in Jp           j in Jn
*
*  is the implied lower bound of row (1).
*
*  Reduction of positive coefficient (a[k] > 0) does not change value
*  of h, since l[k] = 0. In case of reduction of negative coefficient
*  (a[k] < 0) from (11) it follows that:
*
*     delta a[k] = a'[k] - a[k] = inf t[k] - b  (> 0),              (16)
*
*  so new value of h (accounting that u[k] = 1) can be computed as
*  follows:
*
*     h := h + delta a[k] = h + (inf t[k] - b).                     (17)
*
*  RECOVERING SOLUTION
*
*  None needed. */

static int reduce_ineq_coef(NPP *npp, struct elem *ptr, double *_b)
{     /* process inequality constraint: sum a[j] x[j] >= b */
      /* returns: the number of coefficients reduced */
      struct elem *e;
      int count = 0;
      double h, inf_t, new_a, b = *_b;
      xassert(npp == npp);
      /* compute h; see (15) */
      h = 0.0;
      for (e = ptr; e != NULL; e = e->next)
      {  if (e->aj > 0.0)
         {  if (e->xj->lb == -DBL_MAX) goto done;
            h += e->aj * e->xj->lb;
         }
         else /* e->aj < 0.0 */
         {  if (e->xj->ub == +DBL_MAX) goto done;
            h += e->aj * e->xj->ub;
         }
      }
      /* perform reduction of coefficients at binary variables */
      for (e = ptr; e != NULL; e = e->next)
      {  /* skip non-binary variable */
         if (!(e->xj->is_int && e->xj->lb == 0.0 && e->xj->ub == 1.0))
            continue;
         if (e->aj > 0.0)
         {  /* compute inf t[k]; see (14) */
            inf_t = h;
            if (b - e->aj < inf_t && inf_t < b)
            {  /* compute reduced coefficient a'[k]; see (7) */
               new_a = b - inf_t;
               if (new_a >= +1e-3 &&
                   e->aj - new_a >= 0.01 * (1.0 + e->aj))
               {  /* accept a'[k] */
#ifdef GLP_DEBUG
                  xprintf("+");
#endif
                  e->aj = new_a;
                  count++;
               }
            }
         }
         else /* e->aj < 0.0 */
         {  /* compute inf t[k]; see (14) */
            inf_t = h - e->aj;
            if (b < inf_t && inf_t < b - e->aj)
            {  /* compute reduced coefficient a'[k]; see (11) */
               new_a = e->aj + (inf_t - b);
               if (new_a <= -1e-3 &&
                   new_a - e->aj >= 0.01 * (1.0 - e->aj))
               {  /* accept a'[k] */
#ifdef GLP_DEBUG
                  xprintf("-");
#endif
                  e->aj = new_a;
                  /* update h; see (17) */
                  h += (inf_t - b);
                  /* compute b'; see (9) */
                  b = inf_t;
                  count++;
               }
            }
         }
      }
      *_b = b;
done: return count;
}

int npp_reduce_ineq_coef(NPP *npp, NPPROW *row)
{     /* reduce inequality constraint coefficients */
      NPPROW *copy;
      NPPAIJ *aij;
      struct elem *ptr, *e;
      int kase, count[2];
      double b;
      /* the row must be inequality constraint */
      xassert(row->lb < row->ub);
      count[0] = count[1] = 0;
      for (kase = 0; kase <= 1; kase++)
      {  if (kase == 0)
         {  /* process row lower bound */
            if (row->lb == -DBL_MAX) continue;
#ifdef GLP_DEBUG
            xprintf("L");
#endif
            ptr = copy_form(npp, row, +1.0);
            b = + row->lb;
         }
         else
         {  /* process row upper bound */
            if (row->ub == +DBL_MAX) continue;
#ifdef GLP_DEBUG
            xprintf("U");
#endif
            ptr = copy_form(npp, row, -1.0);
            b = - row->ub;
         }
         /* now the inequality has the form "sum a[j] x[j] >= b" */
         count[kase] = reduce_ineq_coef(npp, ptr, &b);
         if (count[kase] > 0)
         {  /* the original inequality has been replaced by equivalent
               one with coefficients reduced */
            if (row->lb == -DBL_MAX || row->ub == +DBL_MAX)
            {  /* the original row is single-sided inequality; no copy
                  is needed */
               copy = NULL;
            }
            else
            {  /* the original row is double-sided inequality; we need
                  to create its copy for other bound before replacing it
                  with the equivalent inequality */
#ifdef GLP_DEBUG
               xprintf("*");
#endif
               copy = npp_add_row(npp);
               if (kase == 0)
               {  /* the copy is for upper bound */
                  copy->lb = -DBL_MAX, copy->ub = row->ub;
               }
               else
               {  /* the copy is for lower bound */
                  copy->lb = row->lb, copy->ub = +DBL_MAX;
               }
               /* copy original row coefficients */
               for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                  npp_add_aij(npp, copy, aij->col, aij->val);
            }
            /* replace the original inequality by equivalent one */
            npp_erase_row(npp, row);
            row->lb = b, row->ub = +DBL_MAX;
            for (e = ptr; e != NULL; e = e->next)
               npp_add_aij(npp, row, e->xj, e->aj);
            /* continue processing upper bound for the copy */
            if (copy != NULL) row = copy;
         }
         drop_form(npp, ptr);
      }
      return count[0] + count[1];
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp5.c0000644000175100001710000006360500000000000023741 0ustar00runnerdocker00000000000000/* npp5.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2009-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

/***********************************************************************
*  NAME
*
*  npp_clean_prob - perform initial LP/MIP processing
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  void npp_clean_prob(NPP *npp);
*
*  DESCRIPTION
*
*  The routine npp_clean_prob performs initial LP/MIP processing that
*  currently includes:
*
*  1) removing free rows;
*
*  2) replacing double-sided constraint rows with almost identical
*     bounds, by equality constraint rows;
*
*  3) removing fixed columns;
*
*  4) replacing double-bounded columns with almost identical bounds by
*     fixed columns and removing those columns;
*
*  5) initial processing constraint coefficients (not implemented);
*
*  6) initial processing objective coefficients (not implemented). */

void npp_clean_prob(NPP *npp)
{     /* perform initial LP/MIP processing */
      NPPROW *row, *next_row;
      NPPCOL *col, *next_col;
      int ret;
      xassert(npp == npp);
      /* process rows which originally are free */
      for (row = npp->r_head; row != NULL; row = next_row)
      {  next_row = row->next;
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
         {  /* process free row */
#ifdef GLP_DEBUG
            xprintf("1");
#endif
            npp_free_row(npp, row);
            /* row was deleted */
         }
      }
      /* process rows which originally are double-sided inequalities */
      for (row = npp->r_head; row != NULL; row = next_row)
      {  next_row = row->next;
         if (row->lb != -DBL_MAX && row->ub != +DBL_MAX &&
             row->lb < row->ub)
         {  ret = npp_make_equality(npp, row);
            if (ret == 0)
               ;
            else if (ret == 1)
            {  /* row was replaced by equality constraint */
#ifdef GLP_DEBUG
               xprintf("2");
#endif
            }
            else
               xassert(ret != ret);
         }
      }
      /* process columns which are originally fixed */
      for (col = npp->c_head; col != NULL; col = next_col)
      {  next_col = col->next;
         if (col->lb == col->ub)
         {  /* process fixed column */
#ifdef GLP_DEBUG
            xprintf("3");
#endif
            npp_fixed_col(npp, col);
            /* column was deleted */
         }
      }
      /* process columns which are originally double-bounded */
      for (col = npp->c_head; col != NULL; col = next_col)
      {  next_col = col->next;
         if (col->lb != -DBL_MAX && col->ub != +DBL_MAX &&
             col->lb < col->ub)
         {  ret = npp_make_fixed(npp, col);
            if (ret == 0)
               ;
            else if (ret == 1)
            {  /* column was replaced by fixed column; process it */
#ifdef GLP_DEBUG
               xprintf("4");
#endif
               npp_fixed_col(npp, col);
               /* column was deleted */
            }
         }
      }
      return;
}

/***********************************************************************
*  NAME
*
*  npp_process_row - perform basic row processing
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_process_row(NPP *npp, NPPROW *row, int hard);
*
*  DESCRIPTION
*
*  The routine npp_process_row performs basic row processing that
*  currently includes:
*
*  1) removing empty row;
*
*  2) removing equality constraint row singleton and corresponding
*     column;
*
*  3) removing inequality constraint row singleton and corresponding
*     column if it was fixed;
*
*  4) performing general row analysis;
*
*  5) removing redundant row bounds;
*
*  6) removing forcing row and corresponding columns;
*
*  7) removing row which becomes free due to redundant bounds;
*
*  8) computing implied bounds for all columns in the row and using
*     them to strengthen current column bounds (MIP only, optional,
*     performed if the flag hard is on).
*
*  Additionally the routine may activate affected rows and/or columns
*  for further processing.
*
*  RETURNS
*
*  0           success;
*
*  GLP_ENOPFS  primal/integer infeasibility detected;
*
*  GLP_ENODFS  dual infeasibility detected. */

int npp_process_row(NPP *npp, NPPROW *row, int hard)
{     /* perform basic row processing */
      NPPCOL *col;
      NPPAIJ *aij, *next_aij, *aaa;
      int ret;
      /* row must not be free */
      xassert(!(row->lb == -DBL_MAX && row->ub == +DBL_MAX));
      /* start processing row */
      if (row->ptr == NULL)
      {  /* empty row */
         ret = npp_empty_row(npp, row);
         if (ret == 0)
         {  /* row was deleted */
#ifdef GLP_DEBUG
            xprintf("A");
#endif
            return 0;
         }
         else if (ret == 1)
         {  /* primal infeasibility */
            return GLP_ENOPFS;
         }
         else
            xassert(ret != ret);
      }
      if (row->ptr->r_next == NULL)
      {  /* row singleton */
         col = row->ptr->col;
         if (row->lb == row->ub)
         {  /* equality constraint */
            ret = npp_eq_singlet(npp, row);
            if (ret == 0)
            {  /* column was fixed, row was deleted */
#ifdef GLP_DEBUG
               xprintf("B");
#endif
               /* activate rows affected by column */
               for (aij = col->ptr; aij != NULL; aij = aij->c_next)
                  npp_activate_row(npp, aij->row);
               /* process fixed column */
               npp_fixed_col(npp, col);
               /* column was deleted */
               return 0;
            }
            else if (ret == 1 || ret == 2)
            {  /* primal/integer infeasibility */
               return GLP_ENOPFS;
            }
            else
               xassert(ret != ret);
         }
         else
         {  /* inequality constraint */
            ret = npp_ineq_singlet(npp, row);
            if (0 <= ret && ret <= 3)
            {  /* row was deleted */
#ifdef GLP_DEBUG
               xprintf("C");
#endif
               /* activate column, since its length was changed due to
                  row deletion */
               npp_activate_col(npp, col);
               if (ret >= 2)
               {  /* column bounds changed significantly or column was
                     fixed */
                  /* activate rows affected by column */
                  for (aij = col->ptr; aij != NULL; aij = aij->c_next)
                     npp_activate_row(npp, aij->row);
               }
               if (ret == 3)
               {  /* column was fixed; process it */
#ifdef GLP_DEBUG
                  xprintf("D");
#endif
                  npp_fixed_col(npp, col);
                  /* column was deleted */
               }
               return 0;
            }
            else if (ret == 4)
            {  /* primal infeasibility */
               return GLP_ENOPFS;
            }
            else
               xassert(ret != ret);
         }
      }
#if 0
      /* sometimes this causes too large round-off errors; probably
         pivot coefficient should be chosen more carefully */
      if (row->ptr->r_next->r_next == NULL)
      {  /* row doubleton */
         if (row->lb == row->ub)
         {  /* equality constraint */
            if (!(row->ptr->col->is_int ||
                  row->ptr->r_next->col->is_int))
            {  /* both columns are continuous */
               NPPCOL *q;
               q = npp_eq_doublet(npp, row);
               if (q != NULL)
               {  /* column q was eliminated */
#ifdef GLP_DEBUG
                  xprintf("E");
#endif
                  /* now column q is singleton of type "implied slack
                     variable"; we process it here to make sure that on
                     recovering basic solution the row is always active
                     equality constraint (as required by the routine
                     rcv_eq_doublet) */
                  xassert(npp_process_col(npp, q) == 0);
                  /* column q was deleted; note that row p also may be
                     deleted */
                  return 0;
               }
            }
         }
      }
#endif
      /* general row analysis */
      ret = npp_analyze_row(npp, row);
      xassert(0x00 <= ret && ret <= 0xFF);
      if (ret == 0x33)
      {  /* row bounds are inconsistent with column bounds */
         return GLP_ENOPFS;
      }
      if ((ret & 0x0F) == 0x00)
      {  /* row lower bound does not exist or redundant */
         if (row->lb != -DBL_MAX)
         {  /* remove redundant row lower bound */
#ifdef GLP_DEBUG
            xprintf("F");
#endif
            npp_inactive_bound(npp, row, 0);
         }
      }
      else if ((ret & 0x0F) == 0x01)
      {  /* row lower bound can be active */
         /* see below */
      }
      else if ((ret & 0x0F) == 0x02)
      {  /* row lower bound is a forcing bound */
#ifdef GLP_DEBUG
         xprintf("G");
#endif
         /* process forcing row */
         if (npp_forcing_row(npp, row, 0) == 0)
fixup:   {  /* columns were fixed, row was made free */
            for (aij = row->ptr; aij != NULL; aij = next_aij)
            {  /* process column fixed by forcing row */
#ifdef GLP_DEBUG
               xprintf("H");
#endif
               col = aij->col;
               next_aij = aij->r_next;
               /* activate rows affected by column */
               for (aaa = col->ptr; aaa != NULL; aaa = aaa->c_next)
                  npp_activate_row(npp, aaa->row);
               /* process fixed column */
               npp_fixed_col(npp, col);
               /* column was deleted */
            }
            /* process free row (which now is empty due to deletion of
               all its columns) */
            npp_free_row(npp, row);
            /* row was deleted */
            return 0;
         }
      }
      else
         xassert(ret != ret);
      if ((ret & 0xF0) == 0x00)
      {  /* row upper bound does not exist or redundant */
         if (row->ub != +DBL_MAX)
         {  /* remove redundant row upper bound */
#ifdef GLP_DEBUG
            xprintf("I");
#endif
            npp_inactive_bound(npp, row, 1);
         }
      }
      else if ((ret & 0xF0) == 0x10)
      {  /* row upper bound can be active */
         /* see below */
      }
      else if ((ret & 0xF0) == 0x20)
      {  /* row upper bound is a forcing bound */
#ifdef GLP_DEBUG
         xprintf("J");
#endif
         /* process forcing row */
         if (npp_forcing_row(npp, row, 1) == 0) goto fixup;
      }
      else
         xassert(ret != ret);
      if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
      {  /* row became free due to redundant bounds removal */
#ifdef GLP_DEBUG
         xprintf("K");
#endif
         /* activate its columns, since their length will change due
            to row deletion */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
            npp_activate_col(npp, aij->col);
         /* process free row */
         npp_free_row(npp, row);
         /* row was deleted */
         return 0;
      }
#if 1 /* 23/XII-2009 */
      /* row lower and/or upper bounds can be active */
      if (npp->sol == GLP_MIP && hard)
      {  /* improve current column bounds (optional) */
         if (npp_improve_bounds(npp, row, 1) < 0)
            return GLP_ENOPFS;
      }
#endif
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_improve_bounds - improve current column bounds
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_improve_bounds(NPP *npp, NPPROW *row, int flag);
*
*  DESCRIPTION
*
*  The routine npp_improve_bounds analyzes specified row (inequality
*  or equality constraint) to determine implied column bounds and then
*  uses these bounds to improve (strengthen) current column bounds.
*
*  If the flag is on and current column bounds changed significantly
*  or the column was fixed, the routine activate rows affected by the
*  column for further processing. (This feature is intended to be used
*  in the main loop of the routine npp_process_row.)
*
*  NOTE: This operation can be used for MIP problem only.
*
*  RETURNS
*
*  The routine npp_improve_bounds returns the number of significantly
*  changed bounds plus the number of column having been fixed due to
*  bound improvements. However, if the routine detects primal/integer
*  infeasibility, it returns a negative value. */

int npp_improve_bounds(NPP *npp, NPPROW *row, int flag)
{     /* improve current column bounds */
      NPPCOL *col;
      NPPAIJ *aij, *next_aij, *aaa;
      int kase, ret, count = 0;
      double lb, ub;
      xassert(npp->sol == GLP_MIP);
      /* row must not be free */
      xassert(!(row->lb == -DBL_MAX && row->ub == +DBL_MAX));
      /* determine implied column bounds */
      npp_implied_bounds(npp, row);
      /* and use these bounds to strengthen current column bounds */
      for (aij = row->ptr; aij != NULL; aij = next_aij)
      {  col = aij->col;
         next_aij = aij->r_next;
         for (kase = 0; kase <= 1; kase++)
         {  /* save current column bounds */
            lb = col->lb, ub = col->ub;
            if (kase == 0)
            {  /* process implied column lower bound */
               if (col->ll.ll == -DBL_MAX) continue;
               ret = npp_implied_lower(npp, col, col->ll.ll);
            }
            else
            {  /* process implied column upper bound */
               if (col->uu.uu == +DBL_MAX) continue;
               ret = npp_implied_upper(npp, col, col->uu.uu);
            }
            if (ret == 0 || ret == 1)
            {  /* current column bounds did not change or changed, but
                  not significantly; restore current column bounds */
               col->lb = lb, col->ub = ub;
            }
            else if (ret == 2 || ret == 3)
            {  /* current column bounds changed significantly or column
                  was fixed */
#ifdef GLP_DEBUG
               xprintf("L");
#endif
               count++;
               /* activate other rows affected by column, if required */
               if (flag)
               {  for (aaa = col->ptr; aaa != NULL; aaa = aaa->c_next)
                  {  if (aaa->row != row)
                        npp_activate_row(npp, aaa->row);
                  }
               }
               if (ret == 3)
               {  /* process fixed column */
#ifdef GLP_DEBUG
                  xprintf("M");
#endif
                  npp_fixed_col(npp, col);
                  /* column was deleted */
                  break; /* for kase */
               }
            }
            else if (ret == 4)
            {  /* primal/integer infeasibility */
               return -1;
            }
            else
               xassert(ret != ret);
         }
      }
      return count;
}

/***********************************************************************
*  NAME
*
*  npp_process_col - perform basic column processing
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_process_col(NPP *npp, NPPCOL *col);
*
*  DESCRIPTION
*
*  The routine npp_process_col performs basic column processing that
*  currently includes:
*
*  1) fixing and removing empty column;
*
*  2) removing column singleton, which is implied slack variable, and
*     corresponding row if it becomes free;
*
*  3) removing bounds of column, which is implied free variable, and
*     replacing corresponding row by equality constraint.
*
*  Additionally the routine may activate affected rows and/or columns
*  for further processing.
*
*  RETURNS
*
*  0           success;
*
*  GLP_ENOPFS  primal/integer infeasibility detected;
*
*  GLP_ENODFS  dual infeasibility detected. */

int npp_process_col(NPP *npp, NPPCOL *col)
{     /* perform basic column processing */
      NPPROW *row;
      NPPAIJ *aij;
      int ret;
      /* column must not be fixed */
      xassert(col->lb < col->ub);
      /* start processing column */
      if (col->ptr == NULL)
      {  /* empty column */
         ret = npp_empty_col(npp, col);
         if (ret == 0)
         {  /* column was fixed and deleted */
#ifdef GLP_DEBUG
            xprintf("N");
#endif
            return 0;
         }
         else if (ret == 1)
         {  /* dual infeasibility */
            return GLP_ENODFS;
         }
         else
            xassert(ret != ret);
      }
      if (col->ptr->c_next == NULL)
      {  /* column singleton */
         row = col->ptr->row;
         if (row->lb == row->ub)
         {  /* equality constraint */
            if (!col->is_int)
slack:      {  /* implied slack variable */
#ifdef GLP_DEBUG
               xprintf("O");
#endif
               npp_implied_slack(npp, col);
               /* column was deleted */
               if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
               {  /* row became free due to implied slack variable */
#ifdef GLP_DEBUG
                  xprintf("P");
#endif
                  /* activate columns affected by row */
                  for (aij = row->ptr; aij != NULL; aij = aij->r_next)
                     npp_activate_col(npp, aij->col);
                  /* process free row */
                  npp_free_row(npp, row);
                  /* row was deleted */
               }
               else
               {  /* row became inequality constraint; activate it
                     since its length changed due to column deletion */
                  npp_activate_row(npp, row);
               }
               return 0;
            }
         }
         else
         {  /* inequality constraint */
            if (!col->is_int)
            {  ret = npp_implied_free(npp, col);
               if (ret == 0)
               {  /* implied free variable */
#ifdef GLP_DEBUG
                  xprintf("Q");
#endif
                  /* column bounds were removed, row was replaced by
                     equality constraint */
                  goto slack;
               }
               else if (ret == 1)
               {  /* column is not implied free variable, because its
                     lower and/or upper bounds can be active */
               }
               else if (ret == 2)
               {  /* dual infeasibility */
                  return GLP_ENODFS;
               }
            }
         }
      }
      /* column still exists */
      return 0;
}

/***********************************************************************
*  NAME
*
*  npp_process_prob - perform basic LP/MIP processing
*
*  SYNOPSIS
*
*  #include "glpnpp.h"
*  int npp_process_prob(NPP *npp, int hard);
*
*  DESCRIPTION
*
*  The routine npp_process_prob performs basic LP/MIP processing that
*  currently includes:
*
*  1) initial LP/MIP processing (see the routine npp_clean_prob),
*
*  2) basic row processing (see the routine npp_process_row), and
*
*  3) basic column processing (see the routine npp_process_col).
*
*  If the flag hard is on, the routine attempts to improve current
*  column bounds multiple times within the main processing loop, in
*  which case this feature may take a time. Otherwise, if the flag hard
*  is off, improving column bounds is performed only once at the end of
*  the main loop. (Note that this feature is used for MIP only.)
*
*  The routine uses two sets: the set of active rows and the set of
*  active columns. Rows/columns are marked by a flag (the field temp in
*  NPPROW/NPPCOL). If the flag is non-zero, the row/column is active,
*  in which case it is placed in the beginning of the row/column list;
*  otherwise, if the flag is zero, the row/column is inactive, in which
*  case it is placed in the end of the row/column list. If a row/column
*  being currently processed may affect other rows/columns, the latters
*  are activated for further processing.
*
*  RETURNS
*
*  0           success;
*
*  GLP_ENOPFS  primal/integer infeasibility detected;
*
*  GLP_ENODFS  dual infeasibility detected. */

int npp_process_prob(NPP *npp, int hard)
{     /* perform basic LP/MIP processing */
      NPPROW *row;
      NPPCOL *col;
      int processing, ret;
      /* perform initial LP/MIP processing */
      npp_clean_prob(npp);
      /* activate all remaining rows and columns */
      for (row = npp->r_head; row != NULL; row = row->next)
         row->temp = 1;
      for (col = npp->c_head; col != NULL; col = col->next)
         col->temp = 1;
      /* main processing loop */
      processing = 1;
      while (processing)
      {  processing = 0;
         /* process all active rows */
         for (;;)
         {  row = npp->r_head;
            if (row == NULL || !row->temp) break;
            npp_deactivate_row(npp, row);
            ret = npp_process_row(npp, row, hard);
            if (ret != 0) goto done;
            processing = 1;
         }
         /* process all active columns */
         for (;;)
         {  col = npp->c_head;
            if (col == NULL || !col->temp) break;
            npp_deactivate_col(npp, col);
            ret = npp_process_col(npp, col);
            if (ret != 0) goto done;
            processing = 1;
         }
      }
#if 1 /* 23/XII-2009 */
      if (npp->sol == GLP_MIP && !hard)
      {  /* improve current column bounds (optional) */
         for (row = npp->r_head; row != NULL; row = row->next)
         {  if (npp_improve_bounds(npp, row, 0) < 0)
            {  ret = GLP_ENOPFS;
               goto done;
            }
         }
      }
#endif
      /* all seems ok */
      ret = 0;
done: xassert(ret == 0 || ret == GLP_ENOPFS || ret == GLP_ENODFS);
#ifdef GLP_DEBUG
      xprintf("\n");
#endif
      return ret;
}

/**********************************************************************/

int npp_simplex(NPP *npp, const glp_smcp *parm)
{     /* process LP prior to applying primal/dual simplex method */
      int ret;
      xassert(npp->sol == GLP_SOL);
      xassert(parm == parm);
      ret = npp_process_prob(npp, 0);
      return ret;
}

/**********************************************************************/

int npp_integer(NPP *npp, const glp_iocp *parm)
{     /* process MIP prior to applying branch-and-bound method */
      NPPROW *row, *prev_row;
      NPPCOL *col;
      NPPAIJ *aij;
      int count, ret;
      xassert(npp->sol == GLP_MIP);
      xassert(parm == parm);
      /*==============================================================*/
      /* perform basic MIP processing */
      ret = npp_process_prob(npp, 1);
      if (ret != 0) goto done;
      /*==============================================================*/
      /* binarize problem, if required */
      if (parm->binarize)
         npp_binarize_prob(npp);
      /*==============================================================*/
      /* identify hidden packing inequalities */
      count = 0;
      /* new rows will be added to the end of the row list, so we go
         from the end to beginning of the row list */
      for (row = npp->r_tail; row != NULL; row = prev_row)
      {  prev_row = row->prev;
         /* skip free row */
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX) continue;
         /* skip equality constraint */
         if (row->lb == row->ub) continue;
         /* skip row having less than two variables */
         if (row->ptr == NULL || row->ptr->r_next == NULL) continue;
         /* skip row having non-binary variables */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  col = aij->col;
            if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
               break;
         }
         if (aij != NULL) continue;
         count += npp_hidden_packing(npp, row);
      }
      if (count > 0)
         xprintf("%d hidden packing inequaliti(es) were detected\n",
            count);
      /*==============================================================*/
      /* identify hidden covering inequalities */
      count = 0;
      /* new rows will be added to the end of the row list, so we go
         from the end to beginning of the row list */
      for (row = npp->r_tail; row != NULL; row = prev_row)
      {  prev_row = row->prev;
         /* skip free row */
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX) continue;
         /* skip equality constraint */
         if (row->lb == row->ub) continue;
         /* skip row having less than three variables */
         if (row->ptr == NULL || row->ptr->r_next == NULL ||
             row->ptr->r_next->r_next == NULL) continue;
         /* skip row having non-binary variables */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  col = aij->col;
            if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
               break;
         }
         if (aij != NULL) continue;
         count += npp_hidden_covering(npp, row);
      }
      if (count > 0)
         xprintf("%d hidden covering inequaliti(es) were detected\n",
            count);
      /*==============================================================*/
      /* reduce inequality constraint coefficients */
      count = 0;
      /* new rows will be added to the end of the row list, so we go
         from the end to beginning of the row list */
      for (row = npp->r_tail; row != NULL; row = prev_row)
      {  prev_row = row->prev;
         /* skip equality constraint */
         if (row->lb == row->ub) continue;
         count += npp_reduce_ineq_coef(npp, row);
      }
      if (count > 0)
         xprintf("%d constraint coefficient(s) were reduced\n", count);
      /*==============================================================*/
#ifdef GLP_DEBUG
      routine(npp);
#endif
      /*==============================================================*/
      /* all seems ok */
      ret = 0;
done: return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/npp/npp6.c0000644000175100001710000014420700000000000023740 0ustar00runnerdocker00000000000000/* npp6.c (translate feasibility problem to CNF-SAT) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2011-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "npp.h"

/***********************************************************************
*  npp_sat_free_row - process free (unbounded) row
*
*  This routine processes row p, which is free (i.e. has no finite
*  bounds):
*
*     -inf < sum a[p,j] x[j] < +inf.                                 (1)
*
*  The constraint (1) cannot be active and therefore it is redundant,
*  so the routine simply removes it from the original problem. */

void npp_sat_free_row(NPP *npp, NPPROW *p)
{     /* the row should be free */
      xassert(p->lb == -DBL_MAX && p->ub == +DBL_MAX);
      /* remove the row from the problem */
      npp_del_row(npp, p);
      return;
}

/***********************************************************************
*  npp_sat_fixed_col - process fixed column
*
*  This routine processes column q, which is fixed:
*
*     x[q] = s[q],                                                   (1)
*
*  where s[q] is a fixed column value.
*
*  The routine substitutes fixed value s[q] into constraint rows and
*  then removes column x[q] from the original problem.
*
*  Substitution of x[q] = s[q] into row i gives:
*
*     L[i] <= sum a[i,j] x[j] <= U[i]   ==>
*              j
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] x[q] <= U[i]   ==>
*            j!=q
*
*     L[i] <= sum a[i,j] x[j] + a[i,q] s[q] <= U[i]   ==>
*            j!=q
*
*     L~[i] <= sum a[i,j] x[j] <= U~[i],
*             j!=q
*
*  where
*
*     L~[i] = L[i] - a[i,q] s[q],                                    (2)
*
*     U~[i] = U[i] - a[i,q] s[q]                                     (3)
*
*  are, respectively, lower and upper bound of row i in the transformed
*  problem.
*
*  On recovering solution x[q] is assigned the value of s[q]. */

struct sat_fixed_col
{     /* fixed column */
      int q;
      /* column reference number for variable x[q] */
      int s;
      /* value, at which x[q] is fixed */
};

static int rcv_sat_fixed_col(NPP *, void *);

int npp_sat_fixed_col(NPP *npp, NPPCOL *q)
{     struct sat_fixed_col *info;
      NPPROW *i;
      NPPAIJ *aij;
      int temp;
      /* the column should be fixed */
      xassert(q->lb == q->ub);
      /* create transformation stack entry */
      info = npp_push_tse(npp,
         rcv_sat_fixed_col, sizeof(struct sat_fixed_col));
      info->q = q->j;
      info->s = (int)q->lb;
      xassert((double)info->s == q->lb);
      /* substitute x[q] = s[q] into constraint rows */
      if (info->s == 0)
         goto skip;
      for (aij = q->ptr; aij != NULL; aij = aij->c_next)
      {  i = aij->row;
         if (i->lb != -DBL_MAX)
         {  i->lb -= aij->val * (double)info->s;
            temp = (int)i->lb;
            if ((double)temp != i->lb)
               return 1; /* integer arithmetic error */
         }
         if (i->ub != +DBL_MAX)
         {  i->ub -= aij->val * (double)info->s;
            temp = (int)i->ub;
            if ((double)temp != i->ub)
               return 2; /* integer arithmetic error */
         }
      }
skip: /* remove the column from the problem */
      npp_del_col(npp, q);
      return 0;
}

static int rcv_sat_fixed_col(NPP *npp, void *info_)
{     struct sat_fixed_col *info = info_;
      npp->c_value[info->q] = (double)info->s;
      return 0;
}

/***********************************************************************
*  npp_sat_is_bin_comb - test if row is binary combination
*
*  This routine tests if the specified row is a binary combination,
*  i.e. all its constraint coefficients are +1 and -1 and all variables
*  are binary. If the test was passed, the routine returns non-zero,
*  otherwise zero. */

int npp_sat_is_bin_comb(NPP *npp, NPPROW *row)
{     NPPCOL *col;
      NPPAIJ *aij;
      xassert(npp == npp);
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  if (!(aij->val == +1.0 || aij->val == -1.0))
            return 0; /* non-unity coefficient */
         col = aij->col;
         if (!(col->is_int && col->lb == 0.0 && col->ub == 1.0))
            return 0; /* non-binary column */
      }
      return 1; /* test was passed */
}

/***********************************************************************
*  npp_sat_num_pos_coef - determine number of positive coefficients
*
*  This routine returns the number of positive coefficients in the
*  specified row. */

int npp_sat_num_pos_coef(NPP *npp, NPPROW *row)
{     NPPAIJ *aij;
      int num = 0;
      xassert(npp == npp);
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->val > 0.0)
            num++;
      }
      return num;
}

/***********************************************************************
*  npp_sat_num_neg_coef - determine number of negative coefficients
*
*  This routine returns the number of negative coefficients in the
*  specified row. */

int npp_sat_num_neg_coef(NPP *npp, NPPROW *row)
{     NPPAIJ *aij;
      int num = 0;
      xassert(npp == npp);
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->val < 0.0)
            num++;
      }
      return num;
}

/***********************************************************************
*  npp_sat_is_cover_ineq - test if row is covering inequality
*
*  The canonical form of a covering inequality is the following:
*
*     sum x[j] >= 1,                                                 (1)
*   j in J
*
*  where all x[j] are binary variables.
*
*  In general case a covering inequality may have one of the following
*  two forms:
*
*     sum  x[j] -  sum  x[j] >= 1 - |J-|,                            (2)
*   j in J+      j in J-
*
*
*     sum  x[j] -  sum  x[j] <= |J+| - 1.                            (3)
*   j in J+      j in J-
*
*  Obviously, the inequality (2) can be transformed to the form (1) by
*  substitution x[j] = 1 - x'[j] for all j in J-, where x'[j] is the
*  negation of variable x[j]. And the inequality (3) can be transformed
*  to (2) by multiplying both left- and right-hand sides by -1.
*
*  This routine returns one of the following codes:
*
*  0, if the specified row is not a covering inequality;
*
*  1, if the specified row has the form (2);
*
*  2, if the specified row has the form (3). */

int npp_sat_is_cover_ineq(NPP *npp, NPPROW *row)
{     xassert(npp == npp);
      if (row->lb != -DBL_MAX && row->ub == +DBL_MAX)
      {  /* row is inequality of '>=' type */
         if (npp_sat_is_bin_comb(npp, row))
         {  /* row is a binary combination */
            if (row->lb == 1.0 - npp_sat_num_neg_coef(npp, row))
            {  /* row has the form (2) */
               return 1;
            }
         }
      }
      else if (row->lb == -DBL_MAX && row->ub != +DBL_MAX)
      {  /* row is inequality of '<=' type */
         if (npp_sat_is_bin_comb(npp, row))
         {  /* row is a binary combination */
            if (row->ub == npp_sat_num_pos_coef(npp, row) - 1.0)
            {  /* row has the form (3) */
               return 2;
            }
         }
      }
      /* row is not a covering inequality */
      return 0;
}

/***********************************************************************
*  npp_sat_is_pack_ineq - test if row is packing inequality
*
*  The canonical form of a packing inequality is the following:
*
*     sum x[j] <= 1,                                                 (1)
*   j in J
*
*  where all x[j] are binary variables.
*
*  In general case a packing inequality may have one of the following
*  two forms:
*
*     sum  x[j] -  sum  x[j] <= 1 - |J-|,                            (2)
*   j in J+      j in J-
*
*
*     sum  x[j] -  sum  x[j] >= |J+| - 1.                            (3)
*   j in J+      j in J-
*
*  Obviously, the inequality (2) can be transformed to the form (1) by
*  substitution x[j] = 1 - x'[j] for all j in J-, where x'[j] is the
*  negation of variable x[j]. And the inequality (3) can be transformed
*  to (2) by multiplying both left- and right-hand sides by -1.
*
*  This routine returns one of the following codes:
*
*  0, if the specified row is not a packing inequality;
*
*  1, if the specified row has the form (2);
*
*  2, if the specified row has the form (3). */

int npp_sat_is_pack_ineq(NPP *npp, NPPROW *row)
{     xassert(npp == npp);
      if (row->lb == -DBL_MAX && row->ub != +DBL_MAX)
      {  /* row is inequality of '<=' type */
         if (npp_sat_is_bin_comb(npp, row))
         {  /* row is a binary combination */
            if (row->ub == 1.0 - npp_sat_num_neg_coef(npp, row))
            {  /* row has the form (2) */
               return 1;
            }
         }
      }
      else if (row->lb != -DBL_MAX && row->ub == +DBL_MAX)
      {  /* row is inequality of '>=' type */
         if (npp_sat_is_bin_comb(npp, row))
         {  /* row is a binary combination */
            if (row->lb == npp_sat_num_pos_coef(npp, row) - 1.0)
            {  /* row has the form (3) */
               return 2;
            }
         }
      }
      /* row is not a packing inequality */
      return 0;
}

/***********************************************************************
*  npp_sat_is_partn_eq - test if row is partitioning equality
*
*  The canonical form of a partitioning equality is the following:
*
*     sum x[j] = 1,                                                  (1)
*   j in J
*
*  where all x[j] are binary variables.
*
*  In general case a partitioning equality may have one of the following
*  two forms:
*
*     sum  x[j] -  sum  x[j] = 1 - |J-|,                             (2)
*   j in J+      j in J-
*
*
*     sum  x[j] -  sum  x[j] = |J+| - 1.                             (3)
*   j in J+      j in J-
*
*  Obviously, the equality (2) can be transformed to the form (1) by
*  substitution x[j] = 1 - x'[j] for all j in J-, where x'[j] is the
*  negation of variable x[j]. And the equality (3) can be transformed
*  to (2) by multiplying both left- and right-hand sides by -1.
*
*  This routine returns one of the following codes:
*
*  0, if the specified row is not a partitioning equality;
*
*  1, if the specified row has the form (2);
*
*  2, if the specified row has the form (3). */

int npp_sat_is_partn_eq(NPP *npp, NPPROW *row)
{     xassert(npp == npp);
      if (row->lb == row->ub)
      {  /* row is equality constraint */
         if (npp_sat_is_bin_comb(npp, row))
         {  /* row is a binary combination */
            if (row->lb == 1.0 - npp_sat_num_neg_coef(npp, row))
            {  /* row has the form (2) */
               return 1;
            }
            if (row->ub == npp_sat_num_pos_coef(npp, row) - 1.0)
            {  /* row has the form (3) */
               return 2;
            }
         }
      }
      /* row is not a partitioning equality */
      return 0;
}

/***********************************************************************
*  npp_sat_reverse_row - multiply both sides of row by -1
*
*  This routines multiplies by -1 both left- and right-hand sides of
*  the specified row:
*
*     L <= sum x[j] <= U,
*
*  that results in the following row:
*
*     -U <= sum (-x[j]) <= -L.
*
*  If no integer overflow occured, the routine returns zero, otherwise
*  non-zero. */

int npp_sat_reverse_row(NPP *npp, NPPROW *row)
{     NPPAIJ *aij;
      int temp, ret = 0;
      double old_lb, old_ub;
      xassert(npp == npp);
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  aij->val = -aij->val;
         temp = (int)aij->val;
         if ((double)temp != aij->val)
            ret = 1;
      }
      old_lb = row->lb, old_ub = row->ub;
      if (old_ub == +DBL_MAX)
         row->lb = -DBL_MAX;
      else
      {  row->lb = -old_ub;
         temp = (int)row->lb;
         if ((double)temp != row->lb)
            ret = 2;
      }
      if (old_lb == -DBL_MAX)
         row->ub = +DBL_MAX;
      else
      {  row->ub = -old_lb;
         temp = (int)row->ub;
         if ((double)temp != row->ub)
            ret = 3;
      }
      return ret;
}

/***********************************************************************
*  npp_sat_split_pack - split packing inequality
*
*  Let there be given a packing inequality in canonical form:
*
*     sum  t[j] <= 1,                                                (1)
*   j in J
*
*  where t[j] = x[j] or t[j] = 1 - x[j], x[j] is a binary variable.
*  And let J = J1 U J2 is a partition of the set of literals. Then the
*  inequality (1) is obviously equivalent to the following two packing
*  inequalities:
*
*     sum  t[j] <= y       <-->   sum  t[j] + (1 - y) <= 1,          (2)
*   j in J1                     j in J1
*
*     sum  t[j] <= 1 - y   <-->   sum  t[j] + y       <= 1,          (3)
*   j in J2                     j in J2
*
*  where y is a new binary variable added to the transformed problem.
*
*  Assuming that the specified row is a packing inequality (1), this
*  routine constructs the set J1 by including there first nlit literals
*  (terms) from the specified row, and the set J2 = J \ J1. Then the
*  routine creates a new row, which corresponds to inequality (2), and
*  replaces the specified row with inequality (3). */

NPPROW *npp_sat_split_pack(NPP *npp, NPPROW *row, int nlit)
{     NPPROW *rrr;
      NPPCOL *col;
      NPPAIJ *aij;
      int k;
      /* original row should be packing inequality (1) */
      xassert(npp_sat_is_pack_ineq(npp, row) == 1);
      /* and nlit should be less than the number of literals (terms)
         in the original row */
      xassert(0 < nlit && nlit < npp_row_nnz(npp, row));
      /* create new row corresponding to inequality (2) */
      rrr = npp_add_row(npp);
      rrr->lb = -DBL_MAX, rrr->ub = 1.0;
      /* move first nlit literals (terms) from the original row to the
         new row; the original row becomes inequality (3) */
      for (k = 1; k <= nlit; k++)
      {  aij = row->ptr;
         xassert(aij != NULL);
         /* add literal to the new row */
         npp_add_aij(npp, rrr, aij->col, aij->val);
         /* correct rhs */
         if (aij->val < 0.0)
            rrr->ub -= 1.0, row->ub += 1.0;
         /* remove literal from the original row */
         npp_del_aij(npp, aij);
      }
      /* create new binary variable y */
      col = npp_add_col(npp);
      col->is_int = 1, col->lb = 0.0, col->ub = 1.0;
      /* include literal (1 - y) in the new row */
      npp_add_aij(npp, rrr, col, -1.0);
      rrr->ub -= 1.0;
      /* include literal y in the original row */
      npp_add_aij(npp, row, col, +1.0);
      return rrr;
}

/***********************************************************************
*  npp_sat_encode_pack - encode packing inequality
*
*  Given a packing inequality in canonical form:
*
*     sum  t[j] <= 1,                                                (1)
*   j in J
*
*  where t[j] = x[j] or t[j] = 1 - x[j], x[j] is a binary variable,
*  this routine translates it to CNF by replacing it with the following
*  equivalent set of edge packing inequalities:
*
*     t[j] + t[k] <= 1   for all j, k in J, j != k.                  (2)
*
*  Then the routine transforms each edge packing inequality (2) to
*  corresponding covering inequality (that encodes two-literal clause)
*  by multiplying both its part by -1:
*
*     - t[j] - t[k] >= -1   <-->   (1 - t[j]) + (1 - t[k]) >= 1.     (3)
*
*  On exit the routine removes the original row from the problem. */

void npp_sat_encode_pack(NPP *npp, NPPROW *row)
{     NPPROW *rrr;
      NPPAIJ *aij, *aik;
      /* original row should be packing inequality (1) */
      xassert(npp_sat_is_pack_ineq(npp, row) == 1);
      /* create equivalent system of covering inequalities (3) */
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  /* due to symmetry only one of inequalities t[j] + t[k] <= 1
            and t[k] <= t[j] <= 1 can be considered */
         for (aik = aij->r_next; aik != NULL; aik = aik->r_next)
         {  /* create edge packing inequality (2) */
            rrr = npp_add_row(npp);
            rrr->lb = -DBL_MAX, rrr->ub = 1.0;
            npp_add_aij(npp, rrr, aij->col, aij->val);
            if (aij->val < 0.0)
               rrr->ub -= 1.0;
            npp_add_aij(npp, rrr, aik->col, aik->val);
            if (aik->val < 0.0)
               rrr->ub -= 1.0;
            /* and transform it to covering inequality (3) */
            npp_sat_reverse_row(npp, rrr);
            xassert(npp_sat_is_cover_ineq(npp, rrr) == 1);
         }
      }
      /* remove the original row from the problem */
      npp_del_row(npp, row);
      return;
}

/***********************************************************************
*  npp_sat_encode_sum2 - encode 2-bit summation
*
*  Given a set containing two literals x and y this routine encodes
*  the equality
*
*     x + y = s + 2 * c,                                             (1)
*
*  where
*
*     s = (x + y) % 2                                                (2)
*
*  is a binary variable modeling the low sum bit, and
*
*     c = (x + y) / 2                                                (3)
*
*  is a binary variable modeling the high (carry) sum bit. */

void npp_sat_encode_sum2(NPP *npp, NPPLSE *set, NPPSED *sed)
{     NPPROW *row;
      int x, y, s, c;
      /* the set should contain exactly two literals */
      xassert(set != NULL);
      xassert(set->next != NULL);
      xassert(set->next->next == NULL);
      sed->x = set->lit;
      xassert(sed->x.neg == 0 || sed->x.neg == 1);
      sed->y = set->next->lit;
      xassert(sed->y.neg == 0 || sed->y.neg == 1);
      sed->z.col = NULL, sed->z.neg = 0;
      /* perform encoding s = (x + y) % 2 */
      sed->s = npp_add_col(npp);
      sed->s->is_int = 1, sed->s->lb = 0.0, sed->s->ub = 1.0;
      for (x = 0; x <= 1; x++)
      {  for (y = 0; y <= 1; y++)
         {  for (s = 0; s <= 1; s++)
            {  if ((x + y) % 2 != s)
               {  /* generate CNF clause to disable infeasible
                     combination */
                  row = npp_add_row(npp);
                  row->lb = 1.0, row->ub = +DBL_MAX;
                  if (x == sed->x.neg)
                     npp_add_aij(npp, row, sed->x.col, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->x.col, -1.0);
                     row->lb -= 1.0;
                  }
                  if (y == sed->y.neg)
                     npp_add_aij(npp, row, sed->y.col, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->y.col, -1.0);
                     row->lb -= 1.0;
                  }
                  if (s == 0)
                     npp_add_aij(npp, row, sed->s, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->s, -1.0);
                     row->lb -= 1.0;
                  }
               }
            }
         }
      }
      /* perform encoding c = (x + y) / 2 */
      sed->c = npp_add_col(npp);
      sed->c->is_int = 1, sed->c->lb = 0.0, sed->c->ub = 1.0;
      for (x = 0; x <= 1; x++)
      {  for (y = 0; y <= 1; y++)
         {  for (c = 0; c <= 1; c++)
            {  if ((x + y) / 2 != c)
               {  /* generate CNF clause to disable infeasible
                     combination */
                  row = npp_add_row(npp);
                  row->lb = 1.0, row->ub = +DBL_MAX;
                  if (x == sed->x.neg)
                     npp_add_aij(npp, row, sed->x.col, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->x.col, -1.0);
                     row->lb -= 1.0;
                  }
                  if (y == sed->y.neg)
                     npp_add_aij(npp, row, sed->y.col, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->y.col, -1.0);
                     row->lb -= 1.0;
                  }
                  if (c == 0)
                     npp_add_aij(npp, row, sed->c, +1.0);
                  else
                  {  npp_add_aij(npp, row, sed->c, -1.0);
                     row->lb -= 1.0;
                  }
               }
            }
         }
      }
      return;
}

/***********************************************************************
*  npp_sat_encode_sum3 - encode 3-bit summation
*
*  Given a set containing at least three literals this routine chooses
*  some literals x, y, z from that set and encodes the equality
*
*     x + y + z = s + 2 * c,                                         (1)
*
*  where
*
*     s = (x + y + z) % 2                                            (2)
*
*  is a binary variable modeling the low sum bit, and
*
*     c = (x + y + z) / 2                                            (3)
*
*  is a binary variable modeling the high (carry) sum bit. */

void npp_sat_encode_sum3(NPP *npp, NPPLSE *set, NPPSED *sed)
{     NPPROW *row;
      int x, y, z, s, c;
      /* the set should contain at least three literals */
      xassert(set != NULL);
      xassert(set->next != NULL);
      xassert(set->next->next != NULL);
      sed->x = set->lit;
      xassert(sed->x.neg == 0 || sed->x.neg == 1);
      sed->y = set->next->lit;
      xassert(sed->y.neg == 0 || sed->y.neg == 1);
      sed->z = set->next->next->lit;
      xassert(sed->z.neg == 0 || sed->z.neg == 1);
      /* perform encoding s = (x + y + z) % 2 */
      sed->s = npp_add_col(npp);
      sed->s->is_int = 1, sed->s->lb = 0.0, sed->s->ub = 1.0;
      for (x = 0; x <= 1; x++)
      {  for (y = 0; y <= 1; y++)
         {  for (z = 0; z <= 1; z++)
            {  for (s = 0; s <= 1; s++)
               {  if ((x + y + z) % 2 != s)
                  {  /* generate CNF clause to disable infeasible
                        combination */
                     row = npp_add_row(npp);
                     row->lb = 1.0, row->ub = +DBL_MAX;
                     if (x == sed->x.neg)
                        npp_add_aij(npp, row, sed->x.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->x.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (y == sed->y.neg)
                        npp_add_aij(npp, row, sed->y.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->y.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (z == sed->z.neg)
                        npp_add_aij(npp, row, sed->z.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->z.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (s == 0)
                        npp_add_aij(npp, row, sed->s, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->s, -1.0);
                        row->lb -= 1.0;
                     }
                  }
               }
            }
         }
      }
      /* perform encoding c = (x + y + z) / 2 */
      sed->c = npp_add_col(npp);
      sed->c->is_int = 1, sed->c->lb = 0.0, sed->c->ub = 1.0;
      for (x = 0; x <= 1; x++)
      {  for (y = 0; y <= 1; y++)
         {  for (z = 0; z <= 1; z++)
            {  for (c = 0; c <= 1; c++)
               {  if ((x + y + z) / 2 != c)
                  {  /* generate CNF clause to disable infeasible
                        combination */
                     row = npp_add_row(npp);
                     row->lb = 1.0, row->ub = +DBL_MAX;
                     if (x == sed->x.neg)
                        npp_add_aij(npp, row, sed->x.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->x.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (y == sed->y.neg)
                        npp_add_aij(npp, row, sed->y.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->y.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (z == sed->z.neg)
                        npp_add_aij(npp, row, sed->z.col, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->z.col, -1.0);
                        row->lb -= 1.0;
                     }
                     if (c == 0)
                        npp_add_aij(npp, row, sed->c, +1.0);
                     else
                     {  npp_add_aij(npp, row, sed->c, -1.0);
                        row->lb -= 1.0;
                     }
                  }
               }
            }
         }
      }
      return;
}

/***********************************************************************
*  npp_sat_encode_sum_ax - encode linear combination of 0-1 variables
*
*  PURPOSE
*
*  Given a linear combination of binary variables:
*
*     sum a[j] x[j],                                                 (1)
*      j
*
*  which is the linear form of the specified row, this routine encodes
*  (i.e. translates to CNF) the following equality:
*
*                        n
*     sum |a[j]| t[j] = sum 2**(k-1) * y[k],                         (2)
*      j                k=1
*
*  where t[j] = x[j] (if a[j] > 0) or t[j] = 1 - x[j] (if a[j] < 0),
*  and y[k] is either t[j] or a new literal created by the routine or
*  a constant zero. Note that the sum in the right-hand side of (2) can
*  be thought as a n-bit representation of the sum in the left-hand
*  side, which is a non-negative integer number.
*
*  ALGORITHM
*
*  First, the number of bits, n, sufficient to represent any value in
*  the left-hand side of (2) is determined. Obviously, n is the number
*  of bits sufficient to represent the sum (sum |a[j]|).
*
*  Let
*
*               n
*     |a[j]| = sum 2**(k-1) b[j,k],                                  (3)
*              k=1
*
*  where b[j,k] is k-th bit in a n-bit representation of |a[j]|. Then
*
*                          m            n
*     sum |a[j]| * t[j] = sum 2**(k-1) sum b[j,k] * t[j].            (4)
*      j                  k=1          j=1
*
*  Introducing the set
*
*     J[k] = { j : b[j,k] = 1 }                                      (5)
*
*  allows rewriting (4) as follows:
*
*                          n
*     sum |a[j]| * t[j] = sum 2**(k-1)  sum    t[j].                 (6)
*      j                  k=1         j in J[k]
*
*  Thus, our goal is to provide |J[k]| <= 1 for all k, in which case
*  we will have the representation (1).
*
*  Let |J[k]| = 2, i.e. J[k] has exactly two literals u and v. In this
*  case we can apply the following transformation:
*
*     u + v = s + 2 * c,                                             (7)
*
*  where s and c are, respectively, low (sum) and high (carry) bits of
*  the sum of two bits. This allows to replace two literals u and v in
*  J[k] by one literal s, and carry out literal c to J[k+1].
*
*  If |J[k]| >= 3, i.e. J[k] has at least three literals u, v, and w,
*  we can apply the following transformation:
*
*     u + v + w = s + 2 * c.                                         (8)
*
*  Again, literal s replaces literals u, v, and w in J[k], and literal
*  c goes into J[k+1].
*
*  On exit the routine stores each literal from J[k] in element y[k],
*  1 <= k <= n. If J[k] is empty, y[k] is set to constant false.
*
*  RETURNS
*
*  The routine returns n, the number of literals in the right-hand side
*  of (2), 0 <= n <= NBIT_MAX. If the sum (sum |a[j]|) is too large, so
*  more than NBIT_MAX (= 31) literals are needed to encode the original
*  linear combination, the routine returns a negative value. */

#define NBIT_MAX 31
/* maximal number of literals in the right hand-side of (2) */

static NPPLSE *remove_lse(NPP *npp, NPPLSE *set, NPPCOL *col)
{     /* remove specified literal from specified literal set */
      NPPLSE *lse, *prev = NULL;
      for (lse = set; lse != NULL; prev = lse, lse = lse->next)
         if (lse->lit.col == col) break;
      xassert(lse != NULL);
      if (prev == NULL)
         set = lse->next;
      else
         prev->next = lse->next;
      dmp_free_atom(npp->pool, lse, sizeof(NPPLSE));
      return set;
}

int npp_sat_encode_sum_ax(NPP *npp, NPPROW *row, NPPLIT y[])
{     NPPAIJ *aij;
      NPPLSE *set[1+NBIT_MAX], *lse;
      NPPSED sed;
      int k, n, temp;
      double sum;
      /* compute the sum (sum |a[j]|) */
      sum = 0.0;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         sum += fabs(aij->val);
      /* determine n, the number of bits in the sum */
      temp = (int)sum;
      if ((double)temp != sum)
         return -1; /* integer arithmetic error */
      for (n = 0; temp > 0; n++, temp >>= 1);
      xassert(0 <= n && n <= NBIT_MAX);
      /* build initial sets J[k], 1 <= k <= n; see (5) */
      /* set[k] is a pointer to the list of literals in J[k] */
      for (k = 1; k <= n; k++)
         set[k] = NULL;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  temp = (int)fabs(aij->val);
         xassert((int)temp == fabs(aij->val));
         for (k = 1; temp > 0; k++, temp >>= 1)
         {  if (temp & 1)
            {  xassert(k <= n);
               lse = dmp_get_atom(npp->pool, sizeof(NPPLSE));
               lse->lit.col = aij->col;
               lse->lit.neg = (aij->val > 0.0 ? 0 : 1);
               lse->next = set[k];
               set[k] = lse;
            }
         }
      }
      /* main transformation loop */
      for (k = 1; k <= n; k++)
      {  /* reduce J[k] and set y[k] */
         for (;;)
         {  if (set[k] == NULL)
            {  /* J[k] is empty */
               /* set y[k] to constant false */
               y[k].col = NULL, y[k].neg = 0;
               break;
            }
            if (set[k]->next == NULL)
            {  /* J[k] contains one literal */
               /* set y[k] to that literal */
               y[k] = set[k]->lit;
               dmp_free_atom(npp->pool, set[k], sizeof(NPPLSE));
               break;
            }
            if (set[k]->next->next == NULL)
            {  /* J[k] contains two literals */
               /* apply transformation (7) */
               npp_sat_encode_sum2(npp, set[k], &sed);
            }
            else
            {  /* J[k] contains at least three literals */
               /* apply transformation (8) */
               npp_sat_encode_sum3(npp, set[k], &sed);
               /* remove third literal from set[k] */
               set[k] = remove_lse(npp, set[k], sed.z.col);
            }
            /* remove second literal from set[k] */
            set[k] = remove_lse(npp, set[k], sed.y.col);
            /* remove first literal from set[k] */
            set[k] = remove_lse(npp, set[k], sed.x.col);
            /* include new literal s to set[k] */
            lse = dmp_get_atom(npp->pool, sizeof(NPPLSE));
            lse->lit.col = sed.s, lse->lit.neg = 0;
            lse->next = set[k];
            set[k] = lse;
            /* include new literal c to set[k+1] */
            xassert(k < n); /* FIXME: can "overflow" happen? */
            lse = dmp_get_atom(npp->pool, sizeof(NPPLSE));
            lse->lit.col = sed.c, lse->lit.neg = 0;
            lse->next = set[k+1];
            set[k+1] = lse;
         }
      }
      return n;
}

/***********************************************************************
*  npp_sat_normalize_clause - normalize clause
*
*  This routine normalizes the specified clause, which is a disjunction
*  of literals, by replacing multiple literals, which refer to the same
*  binary variable, with a single literal.
*
*  On exit the routine returns the number of literals in the resulting
*  clause. However, if the specified clause includes both a literal and
*  its negation, the routine returns a negative value meaning that the
*  clause is equivalent to the value true. */

int npp_sat_normalize_clause(NPP *npp, int size, NPPLIT lit[])
{     int j, k, new_size;
      xassert(npp == npp);
      xassert(size >= 0);
      new_size = 0;
      for (k = 1; k <= size; k++)
      {  for (j = 1; j <= new_size; j++)
         {  if (lit[k].col == lit[j].col)
            {  /* lit[k] refers to the same variable as lit[j], which
                  is already included in the resulting clause */
               if (lit[k].neg == lit[j].neg)
               {  /* ignore lit[k] due to the idempotent law */
                  goto skip;
               }
               else
               {  /* lit[k] is NOT lit[j]; the clause is equivalent to
                     the value true */
                  return -1;
               }
            }
         }
         /* include lit[k] in the resulting clause */
         lit[++new_size] = lit[k];
skip:    ;
      }
      return new_size;
}

/***********************************************************************
*  npp_sat_encode_clause - translate clause to cover inequality
*
*  Given a clause
*
*     OR  t[j],                                                      (1)
*   j in J
*
*  where t[j] is a literal, i.e. t[j] = x[j] or t[j] = NOT x[j], this
*  routine translates it to the following equivalent cover inequality,
*  which is added to the transformed problem:
*
*     sum t[j] >= 1,                                                 (2)
*   j in J
*
*  where t[j] = x[j] or t[j] = 1 - x[j].
*
*  If necessary, the clause should be normalized before a call to this
*  routine. */

NPPROW *npp_sat_encode_clause(NPP *npp, int size, NPPLIT lit[])
{     NPPROW *row;
      int k;
      xassert(size >= 1);
      row = npp_add_row(npp);
      row->lb = 1.0, row->ub = +DBL_MAX;
      for (k = 1; k <= size; k++)
      {  xassert(lit[k].col != NULL);
         if (lit[k].neg == 0)
            npp_add_aij(npp, row, lit[k].col, +1.0);
         else if (lit[k].neg == 1)
         {  npp_add_aij(npp, row, lit[k].col, -1.0);
            row->lb -= 1.0;
         }
         else
            xassert(lit != lit);
      }
      return row;
}

/***********************************************************************
*  npp_sat_encode_geq - encode "not less than" constraint
*
*  PURPOSE
*
*  This routine translates to CNF the following constraint:
*
*      n
*     sum 2**(k-1) * y[k] >= b,                                      (1)
*     k=1
*
*  where y[k] is either a literal (i.e. y[k] = x[k] or y[k] = 1 - x[k])
*  or constant false (zero), b is a given lower bound.
*
*  ALGORITHM
*
*  If b < 0, the constraint is redundant, so assume that b >= 0. Let
*
*          n
*     b = sum 2**(k-1) b[k],                                         (2)
*         k=1
*
*  where b[k] is k-th binary digit of b. (Note that if b >= 2**n and
*  therefore cannot be represented in the form (2), the constraint (1)
*  is infeasible.) In this case the condition (1) is equivalent to the
*  following condition:
*
*     y[n] y[n-1] ... y[2] y[1] >= b[n] b[n-1] ... b[2] b[1],        (3)
*
*  where ">=" is understood lexicographically.
*
*  Algorithmically the condition (3) can be tested as follows:
*
*     for (k = n; k >= 1; k--)
*     {  if (y[k] < b[k])
*           y is less than b;
*        if (y[k] > b[k])
*           y is greater than b;
*     }
*     y is equal to b;
*
*  Thus, y is less than b iff there exists k, 1 <= k <= n, for which
*  the following condition is satisfied:
*
*     y[n] = b[n] AND ... AND y[k+1] = b[k+1] AND y[k] < b[k].       (4)
*
*  Negating the condition (4) we have that y is not less than b iff for
*  all k, 1 <= k <= n, the following condition is satisfied:
*
*     y[n] != b[n] OR ... OR y[k+1] != b[k+1] OR y[k] >= b[k].       (5)
*
*  Note that if b[k] = 0, the literal y[k] >= b[k] is always true, in
*  which case the entire clause (5) is true and can be omitted.
*
*  RETURNS
*
*  Normally the routine returns zero. However, if the constraint (1) is
*  infeasible, the routine returns non-zero. */

int npp_sat_encode_geq(NPP *npp, int n, NPPLIT y[], int rhs)
{     NPPLIT lit[1+NBIT_MAX];
      int j, k, size, temp, b[1+NBIT_MAX];
      xassert(0 <= n && n <= NBIT_MAX);
      /* if the constraint (1) is redundant, do nothing */
      if (rhs < 0)
         return 0;
      /* determine binary digits of b according to (2) */
      for (k = 1, temp = rhs; k <= n; k++, temp >>= 1)
         b[k] = temp & 1;
      if (temp != 0)
      {  /* b >= 2**n; the constraint (1) is infeasible */
         return 1;
      }
      /* main transformation loop */
      for (k = 1; k <= n; k++)
      {  /* build the clause (5) for current k */
         size = 0; /* clause size = number of literals */
         /* add literal y[k] >= b[k] */
         if (b[k] == 0)
         {  /* b[k] = 0 -> the literal is true */
            goto skip;
         }
         else if (y[k].col == NULL)
         {  /* y[k] = 0, b[k] = 1 -> the literal is false */
            xassert(y[k].neg == 0);
         }
         else
         {  /* add literal y[k] = 1 */
            lit[++size] = y[k];
         }
         for (j = k+1; j <= n; j++)
         {  /* add literal y[j] != b[j] */
            if (y[j].col == NULL)
            {  xassert(y[j].neg == 0);
               if (b[j] == 0)
               {  /* y[j] = 0, b[j] = 0 -> the literal is false */
                  continue;
               }
               else
               {  /* y[j] = 0, b[j] = 1 -> the literal is true */
                  goto skip;
               }
            }
            else
            {  lit[++size] = y[j];
               if (b[j] != 0)
                  lit[size].neg = 1 - lit[size].neg;
            }
         }
         /* normalize the clause */
         size = npp_sat_normalize_clause(npp, size, lit);
         if (size < 0)
         {  /* the clause is equivalent to the value true */
            goto skip;
         }
         if (size == 0)
         {  /* the clause is equivalent to the value false; this means
               that the constraint (1) is infeasible */
            return 2;
         }
         /* translate the clause to corresponding cover inequality */
         npp_sat_encode_clause(npp, size, lit);
skip:    ;
      }
      return 0;
}

/***********************************************************************
*  npp_sat_encode_leq - encode "not greater than" constraint
*
*  PURPOSE
*
*  This routine translates to CNF the following constraint:
*
*      n
*     sum 2**(k-1) * y[k] <= b,                                      (1)
*     k=1
*
*  where y[k] is either a literal (i.e. y[k] = x[k] or y[k] = 1 - x[k])
*  or constant false (zero), b is a given upper bound.
*
*  ALGORITHM
*
*  If b < 0, the constraint is infeasible, so assume that b >= 0. Let
*
*          n
*     b = sum 2**(k-1) b[k],                                         (2)
*         k=1
*
*  where b[k] is k-th binary digit of b. (Note that if b >= 2**n and
*  therefore cannot be represented in the form (2), the constraint (1)
*  is redundant.) In this case the condition (1) is equivalent to the
*  following condition:
*
*     y[n] y[n-1] ... y[2] y[1] <= b[n] b[n-1] ... b[2] b[1],        (3)
*
*  where "<=" is understood lexicographically.
*
*  Algorithmically the condition (3) can be tested as follows:
*
*     for (k = n; k >= 1; k--)
*     {  if (y[k] < b[k])
*           y is less than b;
*        if (y[k] > b[k])
*           y is greater than b;
*     }
*     y is equal to b;
*
*  Thus, y is greater than b iff there exists k, 1 <= k <= n, for which
*  the following condition is satisfied:
*
*     y[n] = b[n] AND ... AND y[k+1] = b[k+1] AND y[k] > b[k].       (4)
*
*  Negating the condition (4) we have that y is not greater than b iff
*  for all k, 1 <= k <= n, the following condition is satisfied:
*
*     y[n] != b[n] OR ... OR y[k+1] != b[k+1] OR y[k] <= b[k].       (5)
*
*  Note that if b[k] = 1, the literal y[k] <= b[k] is always true, in
*  which case the entire clause (5) is true and can be omitted.
*
*  RETURNS
*
*  Normally the routine returns zero. However, if the constraint (1) is
*  infeasible, the routine returns non-zero. */

int npp_sat_encode_leq(NPP *npp, int n, NPPLIT y[], int rhs)
{     NPPLIT lit[1+NBIT_MAX];
      int j, k, size, temp, b[1+NBIT_MAX];
      xassert(0 <= n && n <= NBIT_MAX);
      /* check if the constraint (1) is infeasible */
      if (rhs < 0)
         return 1;
      /* determine binary digits of b according to (2) */
      for (k = 1, temp = rhs; k <= n; k++, temp >>= 1)
         b[k] = temp & 1;
      if (temp != 0)
      {  /* b >= 2**n; the constraint (1) is redundant */
         return 0;
      }
      /* main transformation loop */
      for (k = 1; k <= n; k++)
      {  /* build the clause (5) for current k */
         size = 0; /* clause size = number of literals */
         /* add literal y[k] <= b[k] */
         if (b[k] == 1)
         {  /* b[k] = 1 -> the literal is true */
            goto skip;
         }
         else if (y[k].col == NULL)
         {  /* y[k] = 0, b[k] = 0 -> the literal is true */
            xassert(y[k].neg == 0);
            goto skip;
         }
         else
         {  /* add literal y[k] = 0 */
            lit[++size] = y[k];
            lit[size].neg = 1 - lit[size].neg;
         }
         for (j = k+1; j <= n; j++)
         {  /* add literal y[j] != b[j] */
            if (y[j].col == NULL)
            {  xassert(y[j].neg == 0);
               if (b[j] == 0)
               {  /* y[j] = 0, b[j] = 0 -> the literal is false */
                  continue;
               }
               else
               {  /* y[j] = 0, b[j] = 1 -> the literal is true */
                  goto skip;
               }
            }
            else
            {  lit[++size] = y[j];
               if (b[j] != 0)
                  lit[size].neg = 1 - lit[size].neg;
            }
         }
         /* normalize the clause */
         size = npp_sat_normalize_clause(npp, size, lit);
         if (size < 0)
         {  /* the clause is equivalent to the value true */
            goto skip;
         }
         if (size == 0)
         {  /* the clause is equivalent to the value false; this means
               that the constraint (1) is infeasible */
            return 2;
         }
         /* translate the clause to corresponding cover inequality */
         npp_sat_encode_clause(npp, size, lit);
skip:    ;
      }
      return 0;
}

/***********************************************************************
*  npp_sat_encode_row - encode constraint (row) of general type
*
*  PURPOSE
*
*  This routine translates to CNF the following constraint (row):
*
*     L <= sum a[j] x[j] <= U,                                       (1)
*           j
*
*  where all x[j] are binary variables.
*
*  ALGORITHM
*
*  First, the routine performs substitution x[j] = t[j] for j in J+
*  and x[j] = 1 - t[j] for j in J-, where J+ = { j : a[j] > 0 } and
*  J- = { j : a[j] < 0 }. This gives:
*
*     L <=  sum  a[j] t[j] +   sum  a[j] (1 - t[j]) <= U  ==>
*         j in J+            j in J-
*
*     L' <= sum |a[j]| t[j] <= U',                                   (2)
*            j
*
*  where
*
*     L' = L -   sum  a[j],   U' = U -   sum  a[j].                  (3)
*              j in J-                 j in J-
*
*  (Actually only new bounds L' and U' are computed.)
*
*  Then the routine translates to CNF the following equality:
*
*                        n
*     sum |a[j]| t[j] = sum 2**(k-1) * y[k],                         (4)
*      j                k=1
*
*  where y[k] is either some t[j] or a new literal or a constant zero
*  (see the routine npp_sat_encode_sum_ax).
*
*  Finally, the routine translates to CNF the following conditions:
*
*      n
*     sum 2**(k-1) * y[k] >= L'                                      (5)
*     k=1
*
*  and
*
*      n
*     sum 2**(k-1) * y[k] <= U'                                      (6)
*     k=1
*
*  (see the routines npp_sat_encode_geq and npp_sat_encode_leq).
*
*  All resulting clauses are encoded as cover inequalities and included
*  into the transformed problem.
*
*  Note that on exit the routine removes the specified constraint (row)
*  from the original problem.
*
*  RETURNS
*
*  The routine returns one of the following codes:
*
*  0 - translation was successful;
*  1 - constraint (1) was found infeasible;
*  2 - integer arithmetic error occured. */

int npp_sat_encode_row(NPP *npp, NPPROW *row)
{     NPPAIJ *aij;
      NPPLIT y[1+NBIT_MAX];
      int n, rhs;
      double lb, ub;
      /* the row should not be free */
      xassert(!(row->lb == -DBL_MAX && row->ub == +DBL_MAX));
      /* compute new bounds L' and U' (3) */
      lb = row->lb;
      ub = row->ub;
      for (aij = row->ptr; aij != NULL; aij = aij->r_next)
      {  if (aij->val < 0.0)
         {  if (lb != -DBL_MAX)
               lb -= aij->val;
            if (ub != -DBL_MAX)
               ub -= aij->val;
         }
      }
      /* encode the equality (4) */
      n = npp_sat_encode_sum_ax(npp, row, y);
      if (n < 0)
         return 2; /* integer arithmetic error */
      /* encode the condition (5) */
      if (lb != -DBL_MAX)
      {  rhs = (int)lb;
         if ((double)rhs != lb)
            return 2; /* integer arithmetic error */
         if (npp_sat_encode_geq(npp, n, y, rhs) != 0)
            return 1; /* original constraint is infeasible */
      }
      /* encode the condition (6) */
      if (ub != +DBL_MAX)
      {  rhs = (int)ub;
         if ((double)rhs != ub)
            return 2; /* integer arithmetic error */
         if (npp_sat_encode_leq(npp, n, y, rhs) != 0)
            return 1; /* original constraint is infeasible */
      }
      /* remove the specified row from the problem */
      npp_del_row(npp, row);
      return 0;
}

/***********************************************************************
*  npp_sat_encode_prob - encode 0-1 feasibility problem
*
*  This routine translates the specified 0-1 feasibility problem to an
*  equivalent SAT-CNF problem.
*
*  N.B. Currently this is a very crude implementation.
*
*  RETURNS
*
*  0           success;
*
*  GLP_ENOPFS  primal/integer infeasibility detected;
*
*  GLP_ERANGE  integer overflow occured. */

int npp_sat_encode_prob(NPP *npp)
{     NPPROW *row, *next_row, *prev_row;
      NPPCOL *col, *next_col;
      int cover = 0, pack = 0, partn = 0, ret;
      /* process and remove free rows */
      for (row = npp->r_head; row != NULL; row = next_row)
      {  next_row = row->next;
         if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
            npp_sat_free_row(npp, row);
      }
      /* process and remove fixed columns */
      for (col = npp->c_head; col != NULL; col = next_col)
      {  next_col = col->next;
         if (col->lb == col->ub)
            xassert(npp_sat_fixed_col(npp, col) == 0);
      }
      /* only binary variables should remain */
      for (col = npp->c_head; col != NULL; col = col->next)
         xassert(col->is_int && col->lb == 0.0 && col->ub == 1.0);
      /* new rows may be added to the end of the row list, so we walk
         from the end to beginning of the list */
      for (row = npp->r_tail; row != NULL; row = prev_row)
      {  prev_row = row->prev;
         /* process special cases */
         ret = npp_sat_is_cover_ineq(npp, row);
         if (ret != 0)
         {  /* row is covering inequality */
            cover++;
            /* since it already encodes a clause, just transform it to
               canonical form */
            if (ret == 2)
            {  xassert(npp_sat_reverse_row(npp, row) == 0);
               ret = npp_sat_is_cover_ineq(npp, row);
            }
            xassert(ret == 1);
            continue;
         }
         ret = npp_sat_is_partn_eq(npp, row);
         if (ret != 0)
         {  /* row is partitioning equality */
            NPPROW *cov;
            NPPAIJ *aij;
            partn++;
            /* transform it to canonical form */
            if (ret == 2)
            {  xassert(npp_sat_reverse_row(npp, row) == 0);
               ret = npp_sat_is_partn_eq(npp, row);
            }
            xassert(ret == 1);
            /* and split it into covering and packing inequalities,
               both in canonical forms */
            cov = npp_add_row(npp);
            cov->lb = row->lb, cov->ub = +DBL_MAX;
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
               npp_add_aij(npp, cov, aij->col, aij->val);
            xassert(npp_sat_is_cover_ineq(npp, cov) == 1);
            /* the cover inequality already encodes a clause and do
               not need any further processing */
            row->lb = -DBL_MAX;
            xassert(npp_sat_is_pack_ineq(npp, row) == 1);
            /* the packing inequality will be processed below */
            pack--;
         }
         ret = npp_sat_is_pack_ineq(npp, row);
         if (ret != 0)
         {  /* row is packing inequality */
            NPPROW *rrr;
            int nlit, desired_nlit = 4;
            pack++;
            /* transform it to canonical form */
            if (ret == 2)
            {  xassert(npp_sat_reverse_row(npp, row) == 0);
               ret = npp_sat_is_pack_ineq(npp, row);
            }
            xassert(ret == 1);
            /* process the packing inequality */
            for (;;)
            {  /* determine the number of literals in the remaining
                  inequality */
               nlit = npp_row_nnz(npp, row);
               if (nlit <= desired_nlit)
                  break;
               /* split the current inequality into one having not more
                  than desired_nlit literals and remaining one */
               rrr = npp_sat_split_pack(npp, row, desired_nlit-1);
               /* translate the former inequality to CNF and remove it
                  from the original problem */
               npp_sat_encode_pack(npp, rrr);
            }
            /* translate the remaining inequality to CNF and remove it
               from the original problem */
            npp_sat_encode_pack(npp, row);
            continue;
         }
         /* translate row of general type to CNF and remove it from the
            original problem */
         ret = npp_sat_encode_row(npp, row);
         if (ret == 0)
            ;
         else if (ret == 1)
            ret = GLP_ENOPFS;
         else if (ret == 2)
            ret = GLP_ERANGE;
         else
            xassert(ret != ret);
         if (ret != 0)
            goto done;
      }
      ret = 0;
      if (cover != 0)
         xprintf("%d covering inequalities\n", cover);
      if (pack != 0)
         xprintf("%d packing inequalities\n", pack);
      if (partn != 0)
         xprintf("%d partitioning equalities\n", partn);
done: return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6791432
igraph-0.9.9/vendor/source/igraph/vendor/glpk/proxy/0000755000175100001710000000000000000000000023265 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/proxy/main.c0000644000175100001710000000405700000000000024363 0ustar00runnerdocker00000000000000/* Last update: 08-May-2013 */

#include 
#include 
#include 

#include "glpk.h"
#include "proxy.h"

/**********************************************************************/
int main(int argc, char **argv)
/**********************************************************************/
{
    glp_prob *lp;
    int ncols, status;
    double *initsol, zstar, *xstar;

    /* check arguments */
    if ( (argc == 1) || (argc > 3) ) {
        printf("ERROR: Usage: ts  <(possibly) xml initsols>\n"
              );
        exit(1);
    }

    /* creating the problem */
    lp = glp_create_prob();
    glp_set_prob_name(lp, "Proxy");

    /* reading the problem */
    glp_term_out(GLP_OFF);
#if 0 /* by mao */
    status = glp_read_lp(lp, NULL, argv[1]);
#else
    status = glp_read_mps(lp, GLP_MPS_FILE, NULL, argv[1]);
#endif
    glp_term_out(GLP_ON);
    if ( status ) {
        printf("Problem %s does not exist!!!, status %d\n",
               argv[1], status);
        exit(1);
    }

    ncols = glp_get_num_cols(lp);

    initsol = (double *) calloc(ncols+1, sizeof(double));

    if (argc == 3) {
        FILE *fp=fopen(argv[2],"r");
        char  tmp[256]={0x0};
        int counter = 1;
        while(fp!=NULL && fgets(tmp, sizeof(tmp),fp)!=NULL)
        {
            char *valini = strstr(tmp, "value");
            if (valini!=NULL){
                int num;
                double dnum;
                valini +=7;
                sscanf(valini, "%d%*s",&num);
                dnum = (double)num;
                initsol[counter] = dnum;
                counter++;
            }
        }
        fclose(fp);
    }

    xstar = (double *) calloc(ncols+1, sizeof(double));

    if (argc == 3) {
        status = proxy(lp, &zstar, xstar, initsol, 0.0, 0, 1);
    }
    else {
        status = proxy(lp, &zstar, xstar, NULL, 0.0, 0, 1);
    }

    printf("Status = %d; ZSTAR = %f\n",status,zstar);
    /*
    int i;
    for (i=1; i< ncols+1; i++) {
        printf("XSTAR[%d] = %f\n",i, xstar[i]);
    }
     */

    glp_delete_prob(lp);

    return 0;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/proxy/proxy.c0000644000175100001710000010370300000000000024616 0ustar00runnerdocker00000000000000/* proxy.c (proximity search heuristic algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013, 2016 Free Software Foundation, Inc.
*  Written by Giorgio Sartor <0gioker0@gmail.com>.
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
*
************************************************************************
*
* THIS CODE IS AN IMPLEMENTATION OF THE ALGORITHM PROPOSED IN
*
* M. Fischetti, M. Monaci,
* "Proximity Search for 0-1 Mixed-Integer Convex Programming"
* Technical Report DEI, University of Padua, March 2013.
*
* AVAILABLE AT
*       http://www.dei.unipd.it/~fisch/papers/proximity_search.pdf
*
* THE CODE HAS BEEN WRITTEN BY GIORGIO SARTOR, " 0gioker0@gmail.com "
*
* BASIC IDEA:
*
* The initial feasible solution x_tilde is defined. This initial
* solution can be found by an ad-hoc heuristic and proxy can be used to
* refine it by exploiting an underlying MIP model whose solution from
* scratch turned out to be problematic. Otherwise, x_tilde can be found
* by running the GLPK mip solver until a first feasible solution is
* found, setting a conservative time limit of 10 minutes (by default).
* Time limit can be modified passing variable tlim [ms].
*
* Then the cutoff tolerance "delta" is defined. The default tolerance
* is 1% of the last feasible solution obj value--rounded to integer if
* all the variables and obj coefficients are integer.
*
* Next, the objective function c' x is replaced by the Hamming distance
* between x (the actual obj coefficients) and x_tilde (the given
* solution). Distance is only computed wrt the binary variables.
*
* The GLPK solver is then invoked to hopefully find a new incumbent
* x_star with cost c' x_star <= c' x_tilde - delta. A crucial property
* here is that the root-node solution of the LP relaxation is expected
* to be not too different from x_tilde, as this latter solution would
* be optimal without the cutoff constraint, that for a small delta can
* typically be fulfilled with just local adjustments.
*
* If no new solution x_star is found within the time limit the
* algorithm stops. Of course, if the MIP solver proved infeasibility
* for the given delta, we have that c' x_tilde - delta is a valid lower
* bound (in case of minimazation) on the optimal value of the original
* MIP.
*
* The new solution x_star, if any, is possibly improved by solving a
* simplified problem (refinement) where all binary variables have been
* fixed to their value in x_star so as to find the best solution within
* the neighborhood.
*
* Finally, the approach is reapplied on x_star (that replaces x_tilde)
* so as to recenter the distance Hamming function and by modifying the
* cutoff tolerance delta.
*
* In this way, there will be a series of hopefully not-too-difficult
* sub-MIPs to solve, each leading to an improvement of the incumbent.
* More aggressive policies on the definition of tolerance delta can
* lead to a better performance, but would require an ad-hoc tuning.
*
************************************************************************
*
* int proxy(glp_prob *lp, double *zstar, double *xstar,
*           const double[] initsol, double rel_impr, int tlim,
*           int verbose)
*
* lp       : GLPK problem pointer to a MIP with binary variables
*
* zstar    : the value of objective function of the best solution found
*
* xstar    : best solution with components xstar[1],...,xstar[ncols]
*
* initsol  : pointer to a initial feasible solution, see
*            glp_ios_heur_sol
*            If initsol = NULL, the procedure finds the first solution
*            by itself.
*
* rel_impr : minimum relative obj improvement to be achieved at each
*            internal step; if <= 0.0 a default value of 0.01 (1%) is
*            used; for some problems (e.g., set covering with small
*            integer costs) a more-conservative choice of 0.001 (0.1%)
*            can lead to a better final solution; values larger than
*            0.05 (5%) are typically too aggressive and do not work
*            well.
*
* tlim     : time limit to find a new solution, in ms.
*            If tlim = 0, it is set to its default value, 600000 ms
*
* verbose  : if 1 the output is activated. If 0 only errors are
*            displayed
*
* The procedure returns -1 if an error occurred, 0 otherwise (possibly,
* time limit)
*
***********************************************************************/

/**********************************************************************/
/* 1. INCLUDE                                                         */
/**********************************************************************/

#include "glpk.h"
#include "env.h"
#include "proxy.h"

/**********************************************************************/
/* 2. PARAMETERS AND CONSTANTS                                        */
/**********************************************************************/

#define TDAY            86400.0
#define TRUE                1
#define FALSE               0
#define EPS              1e-6
#define RINF             1e38
#define MAXVAL           1e20
#define MINVAL          -1e20
#if 0 /* by gioker */
    #define PROXY_DEBUG
#endif

/**********************************************************************/
/* 3. GLOBAL VARIABLES                                                */
/**********************************************************************/

struct csa {

int integer_obj;        /* TRUE if each feasible solution has an
                           integral cost */
int b_vars_exist;       /* TRUE if there is at least one binary
                           variable in the problem */
int i_vars_exist;       /* TRUE if there is at least one general
                           integer variable in the problem */
const double *startsol; /* Pointer to the initial solution */

int *ckind;             /* Store the kind of the structural variables
                           of the problem */
double *clb;            /* Store the lower bound on the structural
                           variables of the problem */
double *cub;            /* Store the upper bound on the structural
                           variables of the problem */
double *true_obj;       /* Store the obj coefficients of the problem */

int dir;                /* Minimization or maximization problem */
int ncols;              /* Number of structural variables of the
                           problem */

time_t GLOtstart;       /* starting time of the algorithm */

glp_prob *lp_ref;       /* glp problem for refining only*/

};

/**********************************************************************/
/* 4. FUNCTIONS PROTOTYPES                                            */
/**********************************************************************/

static void callback(glp_tree *tree, void *info);
static void get_info(struct csa *csa, glp_prob *lp);
static int is_integer(struct csa *csa);
static void check_integrality(struct csa *csa);
static int check_ref(struct csa *csa, glp_prob *lp, double *xref);
static double second(void);
static int add_cutoff(struct csa *csa, glp_prob *lp);
static void get_sol(struct csa *csa, glp_prob *lp, double *xstar);
static double elapsed_time(struct csa *csa);
static void redefine_obj(glp_prob *lp, double *xtilde, int ncols,
                         int *ckind, double *clb, double *cub);
static double update_cutoff(struct csa *csa, glp_prob *lp,
                            double zstar, int index, double rel_impr);
static double compute_delta(struct csa *csa, double z,
                            double rel_impr);
static double objval(int ncols, double *x, double *true_obj);
static void array_copy(int begin, int end, double *source,
                       double *destination);
static int do_refine(struct csa *csa, glp_prob *lp_ref, int ncols,
                     int *ckind, double *xref, int *tlim, int tref_lim,
                     int verbose);
static void deallocate(struct csa *csa, int refine);

/**********************************************************************/
/* 5. FUNCTIONS                                                       */
/**********************************************************************/

int proxy(glp_prob *lp, double *zfinal, double *xfinal,
          const double initsol[], double rel_impr, int tlim,
          int verbose)

{   struct csa csa_, *csa = &csa_;
    glp_iocp parm;
    glp_smcp parm_lp;
    size_t tpeak;
    int refine, tref_lim, err, cutoff_row, niter, status, i, tout;
    double *xref, *xstar, zstar, tela, cutoff, zz;

    memset(csa, 0, sizeof(struct csa));


    /**********                         **********/
    /********** RETRIEVING PROBLEM INFO **********/
    /**********                         **********/

    /* getting problem direction (min or max) */
    csa->dir = glp_get_obj_dir(lp);

    /* getting number of variables */
    csa->ncols = glp_get_num_cols(lp);

    /* getting kind, bounds and obj coefficient of each variable
     information is stored in ckind, cub, clb, true_obj */
    get_info(csa, lp);

    /* checking if the objective function is always integral */
    check_integrality(csa);

    /* Proximity search cannot be used if there are no binary
       variables */
    if (csa->b_vars_exist == FALSE) {
        if (verbose) {
            xprintf("The problem has not binary variables. Proximity se"
                    "arch cannot be used.\n");
        }
        tfree(csa->ckind);
        tfree(csa->clb);
        tfree(csa->cub);
        tfree(csa->true_obj);
        return -1;
    }

    /* checking if the problem needs refinement, i.e., not all
       variables are binary. If so, the routine creates a copy of the
       lp problem named lp_ref and initializes the solution xref to
       zero. */
    xref = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(xref, 0, sizeof(double)*(csa->ncols+1));
#endif
    refine = check_ref(csa, lp, xref);
#ifdef PROXY_DEBUG
    xprintf("REFINE = %d\n",refine);
#endif

    /* Initializing the solution */
    xstar = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(xstar, 0, sizeof(double)*(csa->ncols+1));
#endif

    /**********                         **********/
    /********** FINDING FIRST SOLUTION  **********/
    /**********                         **********/

    if (verbose) {
        xprintf("Applying PROXY heuristic...\n");
    }

    /* get the initial time */
    csa->GLOtstart = second();

    /* setting the optimization parameters */
    glp_init_iocp(&parm);
    glp_init_smcp(&parm_lp);
#if 0 /* by gioker */
    /* Preprocessing should be disabled because the mip passed
     to proxy is already preprocessed */
    parm.presolve = GLP_ON;
#endif
#if 1 /* by mao */
    /* best projection backtracking seems to be more efficient to find
       any integer feasible solution */
    parm.bt_tech = GLP_BT_BPH;
#endif

    /* Setting the default value of the minimum relative improvement
       to 1% */
    if ( rel_impr <= 0.0 ) {
        rel_impr = 0.01;
    }

    /* Setting the default value of time limit to 10 minutes */
    if (tlim <= 0) {
        tlim = INT_MAX;
    }
    if (verbose) {
        xprintf("Proxy's time limit set to %d seconds.\n",tlim/1000);
        xprintf("Proxy's relative improvement "
                "set to %2.2lf %c.\n",rel_impr*100,37);
    }

    parm_lp.tm_lim = tlim;

    parm.mip_gap = 9999999.9; /* to stop the optimization at the first
                                 feasible solution found */

    /* finding the first solution */
    if (verbose) {
        xprintf("Searching for a feasible solution...\n");
    }

    /* verifying the existence of an input starting solution */
    if (initsol != NULL) {
        csa->startsol = initsol;
        parm.cb_func = callback;
        parm.cb_info = csa;
        if (verbose) {
            xprintf("Input solution found.\n");
        }
    }

    tout = glp_term_out(GLP_OFF);
    err = glp_simplex(lp,&parm_lp);
    glp_term_out(tout);

    status = glp_get_status(lp);

    if (status != GLP_OPT) {
        if (verbose) {
            xprintf("Proxy heuristic terminated.\n");
        }
#ifdef  PROXY_DEBUG
        /* For debug only */
        xprintf("GLP_SIMPLEX status = %d\n",status);
        xprintf("GLP_SIMPLEX error code = %d\n",err);
#endif
        tfree(xref);
        tfree(xstar);
        deallocate(csa, refine);
        return -1;
    }

    tela = elapsed_time(csa);
    if (tlim-tela*1000 <= 0) {
        if (verbose) {
            xprintf("Time limit exceeded. Proxy could not "
                    "find optimal solution to LP relaxation.\n");
            xprintf("Proxy heuristic aborted.\n");
        }
        tfree(xref);
        tfree(xstar);
        deallocate(csa, refine);
        return -1;
    }

    parm.tm_lim = tlim - tela*1000;
    tref_lim = (tlim - tela *1000) / 20;

    tout = glp_term_out(GLP_OFF);
    err = glp_intopt(lp, &parm);
    glp_term_out(tout);

    status = glp_mip_status(lp);

    /***** If no solution was found *****/

    if (status == GLP_NOFEAS || status == GLP_UNDEF) {
        if (err == GLP_ETMLIM) {
            if (verbose) {
                xprintf("Time limit exceeded. Proxy could not "
                        "find an initial integer feasible solution.\n");
                xprintf("Proxy heuristic aborted.\n");
            }
        }
        else {
            if (verbose) {
                xprintf("Proxy could not "
                        "find an initial integer feasible solution.\n");
                xprintf("Proxy heuristic aborted.\n");
            }
        }
        tfree(xref);
        tfree(xstar);
        deallocate(csa, refine);
        return -1;
    }

    /* getting the first solution and its value */
    get_sol(csa, lp,xstar);
    zstar = glp_mip_obj_val(lp);

    if (verbose) {
        xprintf(">>>>> first solution = %e;\n", zstar);
    }

    /* If a feasible solution was found but the time limit is
       exceeded */
    if (err == GLP_ETMLIM) {
        if (verbose) {
          xprintf("Time limit exceeded. Proxy heuristic terminated.\n");
        }
        goto done;
    }

    tela = elapsed_time(csa);
    tpeak = 0;
    glp_mem_usage(NULL, NULL, NULL, &tpeak);
    if (verbose) {
        xprintf("Time used: %3.1lf secs.  Memory used: %2.1lf Mb\n",
                tela,(double)tpeak/1048576);
        xprintf("Starting proximity search...\n");
    }

    /**********                                 **********/
    /********** PREPARING THE PROBLEM FOR PROXY **********/
    /**********                                 **********/

    /* adding a dummy cutoff constraint */
    cutoff_row = add_cutoff(csa, lp);

    /* proximity search needs minimization direction
       even if the problem is a maximization one */
    if (csa->dir == GLP_MAX) {
        glp_set_obj_dir(lp, GLP_MIN);
    }

    /**********                           **********/
    /********** STARTING PROXIMITY SEARCH **********/
    /**********                           **********/


    niter = 0;

    while (TRUE) {
        niter++;

        /********** CHANGING THE OBJ FUNCTION **********/

        redefine_obj(lp,xstar, csa->ncols, csa->ckind, csa->clb,
                     csa->cub);

        /********** UPDATING THE CUTOFF CONSTRAINT **********/

        cutoff = update_cutoff(csa, lp,zstar, cutoff_row, rel_impr);

#ifdef PROXY_DEBUG
        xprintf("TRUE_OBJ[0] = %f\n",csa->true_obj[0]);
        xprintf("ZSTAR  = %f\n",zstar);
        xprintf("CUTOFF = %f\n",cutoff);
#endif

        /********** SEARCHING FOR A BETTER SOLUTION **********/

        tela = elapsed_time(csa);
        if (tlim-tela*1000 <= 0) {
            if (verbose) {
                xprintf("Time limit exceeded. Proxy heuristic "
                        "terminated.\n");
            }
            goto done;
        }
#ifdef PROXY_DEBUG
        xprintf("TELA = %3.1lf\n",tela*1000);
        xprintf("TLIM = %3.1lf\n",tlim - tela*1000);
#endif
        parm_lp.tm_lim = tlim -tela*1000;

        tout = glp_term_out(GLP_OFF);
        err = glp_simplex(lp,&parm_lp);
        glp_term_out(tout);

        status = glp_get_status(lp);

        if (status != GLP_OPT) {
            if (status == GLP_NOFEAS) {
                if (verbose) {
                    xprintf("Bound exceeded = %f. ",cutoff);
                }
            }
            if (verbose) {
                xprintf("Proxy heuristic terminated.\n");
            }
#ifdef PROXY_DEBUG
            xprintf("GLP_SIMPLEX status = %d\n",status);
            xprintf("GLP_SIMPLEX error code = %d\n",err);
#endif
            goto done;
        }

        tela = elapsed_time(csa);
        if (tlim-tela*1000 <= 0) {
            if (verbose) {
                xprintf("Time limit exceeded. Proxy heuristic "
                        "terminated.\n");
            }
            goto done;
        }
        parm.tm_lim = tlim - tela*1000;
        parm.cb_func = NULL;
#if 0 /* by gioker */
        /* Preprocessing should be disabled because the mip passed
         to proxy is already preprocessed */
        parm.presolve = GLP_ON;
#endif
        tout = glp_term_out(GLP_OFF);
        err = glp_intopt(lp, &parm);
        glp_term_out(tout);

        /********** MANAGEMENT OF THE SOLUTION **********/

        status = glp_mip_status(lp);

        /***** No feasible solutions *****/

        if (status == GLP_NOFEAS) {
            if (verbose) {
                xprintf("Bound exceeded = %f. Proxy heuristic "
                        "terminated.\n",cutoff);
            }
            goto done;
        }

        /***** Undefined solution *****/

        if (status == GLP_UNDEF) {
            if (err == GLP_ETMLIM) {
                if (verbose) {
                    xprintf("Time limit exceeded. Proxy heuristic "
                            "terminated.\n");
                }
            }
            else {
                if (verbose) {
                    xprintf("Proxy terminated unexpectedly.\n");
#ifdef PROXY_DEBUG
                    xprintf("GLP_INTOPT error code = %d\n",err);
#endif
                }
            }
            goto done;
        }

        /***** Feasible solution *****/

        if ((status == GLP_FEAS) || (status == GLP_OPT)) {

            /* getting the solution and computing its value */
            get_sol(csa, lp,xstar);
            zz = objval(csa->ncols, xstar, csa->true_obj);

            /* Comparing the incumbent solution with the current best
               one */
#ifdef PROXY_DEBUG
            xprintf("ZZ = %f\n",zz);
            xprintf("ZSTAR = %f\n",zstar);
            xprintf("REFINE = %d\n",refine);
#endif
            if (((zzdir == GLP_MIN)) ||
                ((zz>zstar) && (csa->dir == GLP_MAX))) {

                /* refining (possibly) the solution */
                if (refine) {

                    /* copying the incumbent solution in the refinement
                       one */
                    array_copy(1, csa->ncols +1, xstar, xref);
                    err = do_refine(csa, csa->lp_ref, csa->ncols,
                          csa->ckind, xref, &tlim, tref_lim, verbose);
                    if (!err) {
                        double zref = objval(csa->ncols, xref,
                                             csa->true_obj);
                        if (((zrefdir == GLP_MIN)) ||
                            ((zref>zz) && (csa->dir == GLP_MAX))) {
                            zz = zref;
                            /* copying the refinement solution in the
                               incumbent one */
                            array_copy(1, csa->ncols +1, xref, xstar);
                        }
                    }
                }
                zstar = zz;
                tela = elapsed_time(csa);
                if (verbose) {
                    xprintf(">>>>> it: %3d:   mip = %e;   elapsed time "
                            "%3.1lf sec.s\n", niter,zstar,tela);
                }
            }
        }
    }

done:
    tela = elapsed_time(csa);
    glp_mem_usage(NULL, NULL, NULL, &tpeak);
    if (verbose) {
        xprintf("Time used: %3.1lf.  Memory used: %2.1lf Mb\n",
                tela,(double)tpeak/1048576);
    }


    /* Exporting solution and obj val */
    *zfinal = zstar;

    for (i=1; i < (csa->ncols + 1); i++) {
        xfinal[i]=xstar[i];
    }

    /* Freeing allocated memory */
    tfree(xref);
    tfree(xstar);
    deallocate(csa, refine);

    return 0;
}

/**********************************************************************/
static void callback(glp_tree *tree, void *info){
/**********************************************************************/
    struct csa *csa = info;
    switch(glp_ios_reason(tree)) {
        case GLP_IHEUR:
            glp_ios_heur_sol(tree, csa->startsol);
            break;
        default: break;
    }
}

/**********************************************************************/
static void get_info(struct csa *csa, glp_prob *lp)
/**********************************************************************/
{
    int i;

    /*  Storing helpful info of the problem  */

    csa->ckind = talloc(csa->ncols+1, int);
#if 0 /* by mao */
    memset(csa->ckind, 0, sizeof(int)*(csa->ncols+1));
#endif
    csa->clb = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(csa->clb, 0, sizeof(double)*(csa->ncols+1));
#endif
    csa->cub = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(csa->cub, 0, sizeof(double)*(csa->ncols+1));
#endif
    csa->true_obj = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(csa->true_obj, 0, sizeof(double)*(csa->ncols+1));
#endif
        for( i = 1 ; i < (csa->ncols + 1); i++ ) {
            csa->ckind[i] = glp_get_col_kind(lp, i);
            csa->clb[i] = glp_get_col_lb(lp, i);
            csa->cub[i] = glp_get_col_ub(lp, i);
            csa->true_obj[i] = glp_get_obj_coef(lp, i);
        }
    csa->true_obj[0] = glp_get_obj_coef(lp, 0);
}

/**********************************************************************/
static int is_integer(struct csa *csa)
/**********************************************************************/
{
    int i;
    csa->integer_obj = TRUE;
    for ( i = 1; i < (csa->ncols + 1); i++ ) {
        if (fabs(csa->true_obj[i]) > INT_MAX ) {
            csa->integer_obj = FALSE;
        }
        if (fabs(csa->true_obj[i]) <= INT_MAX) {
            double tmp, rem;
            if (fabs(csa->true_obj[i]) - floor(fabs(csa->true_obj[i]))
                < 0.5) {
                tmp = floor(fabs(csa->true_obj[i]));
            }
            else {
                tmp = ceil(fabs(csa->true_obj[i]));
            }
            rem = fabs(csa->true_obj[i]) - tmp;
            rem = fabs(rem);
            if (rem > EPS) {
                csa->integer_obj = FALSE;
            }

        }
    }
    return csa->integer_obj;
}

/**********************************************************************/
static void check_integrality(struct csa *csa)
/**********************************************************************/
{
    /*
     Checking if the problem has binary, integer or continuos variables.
     integer_obj is TRUE if the problem has no continuous variables
     and all the obj coefficients are integer (and < INT_MAX).
     */

    int i;
    csa->integer_obj = is_integer(csa);
    csa->b_vars_exist = FALSE;
    csa->i_vars_exist = FALSE;
    for ( i = 1; i < (csa->ncols + 1); i++ ) {
        if ( csa->ckind[i] == GLP_IV ){
            csa->i_vars_exist = TRUE;
            continue;
        }
        if ( csa->ckind[i] == GLP_BV ){
            csa->b_vars_exist =TRUE;
            continue;
        }
        csa->integer_obj = FALSE;
    }
}

/**********************************************************************/
static int check_ref(struct csa *csa, glp_prob *lp, double *xref)
/**********************************************************************/
{
    /*
     checking if the problem has continuos or integer variables. If so,
     refinement is prepared.
     */
    int refine = FALSE;
    int i;
    for ( i = 1; i < (csa->ncols + 1); i++ ) {
        if ( csa->ckind[i] != GLP_BV) {
            refine = TRUE;
            break;
        }
    }

    /* possibly creating a mip clone for refinement only */
    if ( refine ) {
        csa->lp_ref = glp_create_prob();
        glp_copy_prob(csa->lp_ref, lp, GLP_ON);
    }

    return refine;
}

/**********************************************************************/
static double second(void)
/**********************************************************************/
{
#if 0 /* by mao */
    return ((double)clock()/(double)CLOCKS_PER_SEC);
#else
    return xtime() / 1000.0;
#endif
}

/**********************************************************************/
static int add_cutoff(struct csa *csa, glp_prob *lp)
/**********************************************************************/
{
    /*
     Adding a cutoff constraint to set an upper bound (in case of
     minimaztion) on the obj value of the next solution, i.e., the next
     value of the true obj function that we would like to find
     */

    /* store non-zero coefficients in the objective function */
    int *obj_index = talloc(csa->ncols+1, int);
#if 0 /* by mao */
    memset(obj_index, 0, sizeof(int)*(csa->ncols+1));
#endif
    double *obj_value = talloc(csa->ncols+1, double);
#if 0 /* by mao */
    memset(obj_value, 0, sizeof(double)*(csa->ncols+1));
#endif
    int obj_nzcnt = 0;
    int i, irow;
    const char *rowname;
    for ( i = 1; i < (csa->ncols + 1); i++ ) {
        if ( fabs(csa->true_obj[i]) > EPS ) {
            obj_nzcnt++;
            obj_index[obj_nzcnt] = i;
            obj_value[obj_nzcnt] = csa->true_obj[i];
        }
    }

    irow = glp_add_rows(lp, 1);
    rowname = "Cutoff";
    glp_set_row_name(lp, irow, rowname);
    if (csa->dir == GLP_MIN) {
        /* minimization problem */
        glp_set_row_bnds(lp, irow, GLP_UP, MAXVAL, MAXVAL);
    }
    else {
        /* maximization problem */
        glp_set_row_bnds(lp, irow, GLP_LO, MINVAL, MINVAL);
    }

    glp_set_mat_row(lp, irow, obj_nzcnt, obj_index, obj_value);

    tfree(obj_index);
    tfree(obj_value);

    return irow;
}

/**********************************************************************/
static void get_sol(struct csa *csa, glp_prob *lp, double *xstar)
/**********************************************************************/
{
    /* Retrieving and storing the coefficients of the solution */

    int i;
    for (i = 1; i < (csa->ncols +1); i++) {
        xstar[i] = glp_mip_col_val(lp, i);
    }
}

/**********************************************************************/
static double elapsed_time(struct csa *csa)
/**********************************************************************/
{
    double tela = second() - csa->GLOtstart;
    if ( tela < 0 ) tela += TDAY;
    return(tela);
}

/**********************************************************************/
static void redefine_obj(glp_prob *lp, double *xtilde, int ncols,
                         int *ckind, double *clb, double *cub)
/**********************************************************************/

/*
 Redefine the lp objective function obj as the distance-to-integrality
 (Hamming distance) from xtilde (the incumbent feasible solution), wrt
 to binary vars only
 */

{
    int j;
    double *delta = talloc(ncols+1, double);
#if 0 /* by mao */
    memset(delta, 0, sizeof(double)*(ncols+1));
#endif

    for ( j = 1; j < (ncols +1); j++ ) {
        delta[j] = 0.0;
        /* skip continuous variables */
        if ( ckind[j] == GLP_CV ) continue;

        /* skip integer variables that have been fixed */
        if ( cub[j]-clb[j] < 0.5 ) continue;

        /* binary variable */
        if ( ckind[j] == GLP_BV ) {
            if ( xtilde[j] > 0.5 ) {
                delta[j] = -1.0;
            }
            else {
                delta[j] = 1.0;
            }
        }
    }

    /* changing the obj coeff. for all variables, including continuous
       ones */
    for ( j = 1; j < (ncols +1); j++ ) {
        glp_set_obj_coef(lp, j, delta[j]);
    }
    glp_set_obj_coef(lp, 0, 0.0);

    tfree(delta);
}

/**********************************************************************/
static double update_cutoff(struct csa *csa, glp_prob *lp,
                            double zstar, int cutoff_row,
                            double rel_impr)
/**********************************************************************/
{
    /*
     Updating the cutoff constraint with the value we would like to
     find during the next optimization
     */
    double cutoff;
    zstar -= csa->true_obj[0];
    if (csa->dir == GLP_MIN) {
        cutoff = zstar - compute_delta(csa, zstar, rel_impr);
        glp_set_row_bnds(lp, cutoff_row, GLP_UP, cutoff, cutoff);
    }
    else {
        cutoff = zstar + compute_delta(csa, zstar, rel_impr);
        glp_set_row_bnds(lp, cutoff_row, GLP_LO, cutoff, cutoff);
    }

    return cutoff;
}

/**********************************************************************/
static double compute_delta(struct csa *csa, double z, double rel_impr)
/**********************************************************************/
{
    /* Computing the offset for the next best solution */

    double delta = rel_impr * fabs(z);
    if ( csa->integer_obj ) delta = ceil(delta);

    return(delta);
}

/**********************************************************************/
static double objval(int ncols, double *x, double *true_obj)
/**********************************************************************/
{
    /* Computing the true cost of x (using the original obj coeff.s) */

    int j;
    double z = 0.0;
    for ( j = 1; j < (ncols +1); j++ ) {
        z += x[j] * true_obj[j];
    }
    return z + true_obj[0];
}

/**********************************************************************/
static void array_copy(int begin, int end, double *source,
                       double *destination)
/**********************************************************************/
{
    int i;
    for (i = begin; i < end; i++) {
        destination[i] = source[i];
    }
}
/**********************************************************************/
static int do_refine(struct csa *csa, glp_prob *lp_ref, int ncols,
                     int *ckind, double *xref, int *tlim, int tref_lim,
                     int verbose)
/**********************************************************************/
{
    /*
     Refinement is applied when the variables of the problem are not
     all binary. Binary variables are fixed to their value and
     remaining ones are optimized. If there are only continuos
     variables (in addition to those binary) the problem becomes just
     an LP. Otherwise, it remains a MIP but of smaller size.
     */

    int j, tout;
    double refineStart = second();
    double val, tela, tlimit;

    if ( glp_get_num_cols(lp_ref) != ncols ) {
        if (verbose) {
            xprintf("Error in Proxy refinement: ");
            xprintf("wrong number of columns (%d vs %d).\n",
                    ncols, glp_get_num_cols(lp_ref));
        }
        return 1;
    }

    val = -1.0;

    /* fixing all binary variables to their current value in xref */
    for ( j = 1; j < (ncols + 1); j++ ) {
        if ( ckind[j] == GLP_BV ) {
            val = 0.0;
            if ( xref[j] > 0.5 ) val = 1.0;
            glp_set_col_bnds(lp_ref, j, GLP_FX, val, val);
        }
    }

    /* re-optimizing (refining) if some bound has been changed */
    if ( val > -1.0 ) {
        glp_iocp parm_ref;
        glp_smcp parm_ref_lp;
        int err, status;

        glp_init_iocp(&parm_ref);
        parm_ref.presolve = GLP_ON;
        glp_init_smcp(&parm_ref_lp);
        /*
         If there are no general integer variable the problem becomes
         an LP (after fixing the binary variables) and can be solved
         quickly. Otherwise the problem is still a MIP problem and a
         timelimit has to be set.
         */
        parm_ref.tm_lim = tref_lim;
        if (parm_ref.tm_lim > *tlim) {
            parm_ref.tm_lim = *tlim;
        }
        parm_ref_lp.tm_lim = parm_ref.tm_lim;
#ifdef PROXY_DEBUG
        xprintf("***** REFINING *****\n");
#endif
        tout = glp_term_out(GLP_OFF);
        if (csa->i_vars_exist == TRUE) {
            err = glp_intopt(lp_ref, &parm_ref);
        }
        else {
            err = glp_simplex(lp_ref, &parm_ref_lp);
        }
        glp_term_out(tout);

        if (csa->i_vars_exist == TRUE) {
            status = glp_mip_status(lp_ref);
        }
        else {
            status = glp_get_status(lp_ref);
        }

#if 1 /* 29/II-2016 by mao as reported by Chris */
      switch (status)
      {  case GLP_OPT:
         case GLP_FEAS:
            break;
         default:
            status = GLP_UNDEF;
            break;
      }
#endif

#ifdef PROXY_DEBUG
        xprintf("STATUS REFINING = %d\n",status);
#endif
        if (status == GLP_UNDEF) {
            if (err == GLP_ETMLIM) {
#ifdef PROXY_DEBUG
                    xprintf("Time limit exceeded on Proxy refining.\n");
#endif
                return 1;
            }
        }
        for( j = 1 ; j < (ncols + 1); j++ ){
            if (ckind[j] != GLP_BV) {
                if (csa->i_vars_exist == TRUE) {
                    xref[j] = glp_mip_col_val(lp_ref, j);
                }
                else{
                    xref[j] = glp_get_col_prim(lp_ref, j);
                }
            }
        }
    }
    tela = second() - refineStart;
#ifdef PROXY_DEBUG
    xprintf("REFINE TELA = %3.1lf\n",tela*1000);
#endif
    return 0;
}
/**********************************************************************/
static void deallocate(struct csa *csa, int refine)
/**********************************************************************/
{
    /* Deallocating routine */

    if (refine) {
        glp_delete_prob(csa->lp_ref);
    }

    tfree(csa->ckind);
    tfree(csa->clb);
    tfree(csa->cub);
    tfree(csa->true_obj);

}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/proxy/proxy.h0000644000175100001710000000226000000000000024617 0ustar00runnerdocker00000000000000/* proxy.h (proximity search heuristic algorithm) */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013 Free Software Foundation, Inc.
*  Written by Giorgio Sartor <0gioker0@gmail.com>.
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef PROXY_H
#define PROXY_H

#define proxy _glp_proxy
int proxy(glp_prob *lp, double *zstar, double *xstar,
          const double initsol[], double rel_impr, int tlim,
          int verbose);

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/proxy/proxy1.c0000644000175100001710000000605000000000000024674 0ustar00runnerdocker00000000000000/* proxy1.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2013, 2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "ios.h"
#include "proxy.h"

void ios_proxy_heur(glp_tree *T)
{     glp_prob *prob;
      int j, status;
      double *xstar, zstar;
      /* this heuristic is applied only once on the root level */
      if (!(T->curr->level == 0 && T->curr->solved == 1))
         goto done;
      prob = glp_create_prob();
      glp_copy_prob(prob, T->mip, 0);
      xstar = xcalloc(1+prob->n, sizeof(double));
      for (j = 1; j <= prob->n; j++)
         xstar[j] = 0.0;
      if (T->mip->mip_stat != GLP_FEAS)
         status = proxy(prob, &zstar, xstar, NULL, 0.0,
            T->parm->ps_tm_lim, 1);
      else
      {  double *xinit = xcalloc(1+prob->n, sizeof(double));
         for (j = 1; j <= prob->n; j++)
            xinit[j] = T->mip->col[j]->mipx;
         status = proxy(prob, &zstar, xstar, xinit, 0.0,
            T->parm->ps_tm_lim, 1);
         xfree(xinit);
      }
      if (status == 0)
#if 0 /* 17/III-2016 */
         glp_ios_heur_sol(T, xstar);
#else
      {  /* sometimes the proxy heuristic reports a wrong solution, so
          * make sure that the solution is really integer feasible */
         int i, feas1, feas2, ae_ind, re_ind;
         double ae_max, re_max;
         glp_copy_prob(prob, T->mip, 0);
         for (j = 1; j <= prob->n; j++)
            prob->col[j]->mipx = xstar[j];
         for (i = 1; i <= prob->m; i++)
         {  GLPROW *row;
            GLPAIJ *aij;
            row = prob->row[i];
            row->mipx = 0.0;
            for (aij = row->ptr; aij != NULL; aij = aij->r_next)
               row->mipx += aij->val * aij->col->mipx;
         }
         glp_check_kkt(prob, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind,
            &re_max, &re_ind);
         feas1 = (re_max <= 1e-6);
         glp_check_kkt(prob, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind,
            &re_max, &re_ind);
         feas2 = (re_max <= 1e-6);
         if (feas1 && feas2)
            glp_ios_heur_sol(T, xstar);
         else
            xprintf("WARNING: PROXY HEURISTIC REPORTED WRONG SOLUTION; "
               "SOLUTION REJECTED\n");
      }
#endif
      xfree(xstar);
      glp_delete_prob(prob);
done: return;
}

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.6831431
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/0000755000175100001710000000000000000000000023565 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/simplex.h0000644000175100001710000000236100000000000025421 0ustar00runnerdocker00000000000000/* simplex.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SIMPLEX_H
#define SIMPLEX_H

#include "prob.h"

#define spx_primal _glp_spx_primal
int spx_primal(glp_prob *P, const glp_smcp *parm);
/* driver to the primal simplex method */

#define spy_dual _glp_spy_dual
int spy_dual(glp_prob *P, const glp_smcp *parm);
/* driver to the dual simplex method */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxat.c0000644000175100001710000002075400000000000025100 0ustar00runnerdocker00000000000000/* spxat.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxat.h"

/***********************************************************************
*  spx_alloc_at - allocate constraint matrix in sparse row-wise format
*
*  This routine allocates the memory for arrays needed to represent the
*  constraint matrix in sparse row-wise format. */

void spx_alloc_at(SPXLP *lp, SPXAT *at)
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      at->ptr = talloc(1+m+1, int);
      at->ind = talloc(1+nnz, int);
      at->val = talloc(1+nnz, double);
      at->work = talloc(1+n, double);
      return;
}

/***********************************************************************
*  spx_build_at - build constraint matrix in sparse row-wise format
*
*  This routine builds sparse row-wise representation of the constraint
*  matrix A using its sparse column-wise representation stored in the
*  lp object, and stores the result in the at object. */

void spx_build_at(SPXLP *lp, SPXAT *at)
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int *AT_ptr = at->ptr;
      int *AT_ind = at->ind;
      double *AT_val = at->val;
      int i, k, ptr, end, pos;
      /* calculate AT_ptr[i] = number of non-zeros in i-th row */
      memset(&AT_ptr[1], 0, m * sizeof(int));
      for (k = 1; k <= n; k++)
      {  ptr = A_ptr[k];
         end = A_ptr[k+1];
         for (; ptr < end; ptr++)
            AT_ptr[A_ind[ptr]]++;
      }
      /* set AT_ptr[i] to position after last element in i-th row */
      AT_ptr[1]++;
      for (i = 2; i <= m; i++)
         AT_ptr[i] += AT_ptr[i-1];
      xassert(AT_ptr[m] == nnz+1);
      AT_ptr[m+1] = nnz+1;
      /* build row-wise representation and re-arrange AT_ptr[i] */
      for (k = n; k >= 1; k--)
      {  /* copy elements from k-th column to corresponding rows */
         ptr = A_ptr[k];
         end = A_ptr[k+1];
         for (; ptr < end; ptr++)
         {  pos = --AT_ptr[A_ind[ptr]];
            AT_ind[pos] = k;
            AT_val[pos] = A_val[ptr];
         }
      }
      xassert(AT_ptr[1] == 1);
      return;
}

/***********************************************************************
*  spx_at_prod - compute product y := y + s * A'* x
*
*  This routine computes the product:
*
*     y := y + s * A'* x,
*
*  where A' is a matrix transposed to the mxn-matrix A of constraint
*  coefficients, x is a m-vector, s is a scalar, y is a n-vector.
*
*  The routine uses the row-wise representation of the matrix A and
*  computes the product as a linear combination:
*
*     y := y + s * (A'[1] * x[1] + ... + A'[m] * x[m]),
*
*  where A'[i] is i-th row of A, 1 <= i <= m. */

void spx_at_prod(SPXLP *lp, SPXAT *at, double y[/*1+n*/], double s,
      const double x[/*1+m*/])
{     int m = lp->m;
      int *AT_ptr = at->ptr;
      int *AT_ind = at->ind;
      double *AT_val = at->val;
      int i, ptr, end;
      double t;
      for (i = 1; i <= m; i++)
      {  if (x[i] != 0.0)
         {  /* y := y + s * (i-th row of A) * x[i] */
            t = s * x[i];
            ptr = AT_ptr[i];
            end = AT_ptr[i+1];
            for (; ptr < end; ptr++)
               y[AT_ind[ptr]] += AT_val[ptr] * t;
         }
      }
      return;
}

/***********************************************************************
*  spx_nt_prod1 - compute product y := y + s * N'* x
*
*  This routine computes the product:
*
*     y := y + s * N'* x,
*
*  where N' is a matrix transposed to the mx(n-m)-matrix N composed
*  from non-basic columns of the constraint matrix A, x is a m-vector,
*  s is a scalar, y is (n-m)-vector.
*
*  If the flag ign is non-zero, the routine ignores the input content
*  of the array y assuming that y = 0. */

void spx_nt_prod1(SPXLP *lp, SPXAT *at, double y[/*1+n-m*/], int ign,
      double s, const double x[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      double *work = at->work;
      int j, k;
      for (k = 1; k <= n; k++)
         work[k] = 0.0;
      if (!ign)
      {  for (j = 1; j <= n-m; j++)
            work[head[m+j]] = y[j];
      }
      spx_at_prod(lp, at, work, s, x);
      for (j = 1; j <= n-m; j++)
         y[j] = work[head[m+j]];
      return;
}

/***********************************************************************
*  spx_eval_trow1 - compute i-th row of simplex table
*
*  This routine computes i-th row of the current simplex table
*  T = (T[i,j]) = - inv(B) * N, 1 <= i <= m, using representation of
*  the constraint matrix A in row-wise format.
*
*  The vector rho = (rho[j]), which is i-th row of the basis inverse
*  inv(B), should be previously computed with the routine spx_eval_rho.
*  It is assumed that elements of this vector are stored in the array
*  locations rho[1], ..., rho[m].
*
*  There exist two ways to compute the simplex table row.
*
*  1. T[i,j], j = 1,...,n-m, is computed as inner product:
*
*                    m
*        T[i,j] = - sum a[i,k] * rho[i],
*                   i=1
*
*  where N[j] = A[k] is a column of the constraint matrix corresponding
*  to non-basic variable xN[j]. The estimated number of operations in
*  this case is:
*
*        n1 = (n - m) * (nnz(A) / n),
*
*  (n - m) is the number of columns of N, nnz(A) / n is the average
*  number of non-zeros in one column of A and, therefore, of N.
*
*  2. The simplex table row is computed as part of a linear combination
*     of rows of A with coefficients rho[i] != 0. The estimated number
*     of operations in this case is:
*
*        n2 = nnz(rho) * (nnz(A) / m),
*
*     where nnz(rho) is the number of non-zeros in the vector rho,
*     nnz(A) / m is the average number of non-zeros in one row of A.
*
*  If n1 < n2, the routine computes the simples table row using the
*  first way (like the routine spx_eval_trow). Otherwise, the routine
*  uses the second way calling the routine spx_nt_prod1.
*
*  On exit components of the simplex table row are stored in the array
*  locations trow[1], ... trow[n-m]. */

void spx_eval_trow1(SPXLP *lp, SPXAT *at, const double rho[/*1+m*/],
      double trow[/*1+n-m*/])
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int i, j, nnz_rho;
      double cnt1, cnt2;
      /* determine nnz(rho) */
      nnz_rho = 0;
      for (i = 1; i <= m; i++)
      {  if (rho[i] != 0.0)
            nnz_rho++;
      }
      /* estimate the number of operations for both ways */
      cnt1 = (double)(n - m) * ((double)nnz / (double)n);
      cnt2 = (double)nnz_rho * ((double)nnz / (double)m);
      /* compute i-th row of simplex table */
      if (cnt1 < cnt2)
      {  /* as inner products */
         int *A_ptr = lp->A_ptr;
         int *A_ind = lp->A_ind;
         double *A_val = lp->A_val;
         int *head = lp->head;
         int k, ptr, end;
         double tij;
         for (j = 1; j <= n-m; j++)
         {  k = head[m+j]; /* x[k] = xN[j] */
            /* compute t[i,j] = - N'[j] * pi */
            tij = 0.0;
            ptr = A_ptr[k];
            end = A_ptr[k+1];
            for (; ptr < end; ptr++)
               tij -= A_val[ptr] * rho[A_ind[ptr]];
            trow[j] = tij;
         }
      }
      else
      {  /* as linear combination */
         spx_nt_prod1(lp, at, trow, 1, -1.0, rho);
      }
      return;
}

/***********************************************************************
*  spx_free_at - deallocate constraint matrix in sparse row-wise format
*
*  This routine deallocates the memory used for arrays of the program
*  object at. */

void spx_free_at(SPXLP *lp, SPXAT *at)
{     xassert(lp == lp);
      tfree(at->ptr);
      tfree(at->ind);
      tfree(at->val);
      tfree(at->work);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxat.h0000644000175100001710000000542500000000000025103 0ustar00runnerdocker00000000000000/* spxat.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXAT_H
#define SPXAT_H

#include "spxlp.h"

typedef struct SPXAT SPXAT;

struct SPXAT
{     /* mxn-matrix A of constraint coefficients in sparse row-wise
       * format */
      int *ptr; /* int ptr[1+m+1]; */
      /* ptr[0] is not used;
       * ptr[i], 1 <= i <= m, is starting position of i-th row in
       * arrays ind and val; note that ptr[1] is always 1;
       * ptr[m+1] indicates the position after the last element in
       * arrays ind and val, i.e. ptr[m+1] = nnz+1, where nnz is the
       * number of non-zero elements in matrix A;
       * the length of i-th row (the number of non-zero elements in
       * that row) can be calculated as ptr[i+1] - ptr[i] */
      int *ind; /* int ind[1+nnz]; */
      /* column indices */
      double *val; /* double val[1+nnz]; */
      /* non-zero element values */
      double *work; /* double work[1+n]; */
      /* working array */
};

#define spx_alloc_at _glp_spx_alloc_at
void spx_alloc_at(SPXLP *lp, SPXAT *at);
/* allocate constraint matrix in sparse row-wise format */

#define spx_build_at _glp_spx_build_at
void spx_build_at(SPXLP *lp, SPXAT *at);
/* build constraint matrix in sparse row-wise format */

#define spx_at_prod _glp_spx_at_prod
void spx_at_prod(SPXLP *lp, SPXAT *at, double y[/*1+n*/], double s,
      const double x[/*1+m*/]);
/* compute product y := y + s * A'* x */

#define spx_nt_prod1 _glp_spx_nt_prod1
void spx_nt_prod1(SPXLP *lp, SPXAT *at, double y[/*1+n-m*/], int ign,
      double s, const double x[/*1+m*/]);
/* compute product y := y + s * N'* x */

#define spx_eval_trow1 _glp_spx_eval_trow1
void spx_eval_trow1(SPXLP *lp, SPXAT *at, const double rho[/*1+m*/],
      double trow[/*1+n-m*/]);
/* compute i-th row of simplex table */

#define spx_free_at _glp_spx_free_at
void spx_free_at(SPXLP *lp, SPXAT *at);
/* deallocate constraint matrix in sparse row-wise format */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxchuzc.c0000644000175100001710000003045400000000000025606 0ustar00runnerdocker00000000000000/* spxchuzc.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxchuzc.h"

/***********************************************************************
*  spx_chuzc_sel - select eligible non-basic variables
*
*  This routine selects eligible non-basic variables xN[j], whose
*  reduced costs d[j] have "wrong" sign, i.e. changing such xN[j] in
*  feasible direction improves (decreases) the objective function.
*
*  Reduced costs of non-basic variables should be placed in the array
*  locations d[1], ..., d[n-m].
*
*  Non-basic variable xN[j] is considered eligible if:
*
*     d[j] <= -eps[j] and xN[j] can increase
*
*     d[j] >= +eps[j] and xN[j] can decrease
*
*  for
*
*     eps[j] = tol + tol1 * |cN[j]|,
*
*  where cN[j] is the objective coefficient at xN[j], tol and tol1 are
*  specified tolerances.
*
*  On exit the routine stores indices j of eligible non-basic variables
*  xN[j] to the array locations list[1], ..., list[num] and returns the
*  number of such variables 0 <= num <= n-m. (If the parameter list is
*  specified as NULL, no indices are stored.) */

int spx_chuzc_sel(SPXLP *lp, const double d[/*1+n-m*/], double tol,
      double tol1, int list[/*1+n-m*/])
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k, num;
      double ck, eps;
      num = 0;
      /* walk thru list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == u[k])
         {  /* xN[j] is fixed variable; skip it */
            continue;
         }
         /* determine absolute tolerance eps[j] */
         ck = c[k];
         eps = tol + tol1 * (ck >= 0.0 ? +ck : -ck);
         /* check if xN[j] is eligible */
         if (d[j] <= -eps)
         {  /* xN[j] should be able to increase */
            if (flag[j])
            {  /* but its upper bound is active */
               continue;
            }
         }
         else if (d[j] >= +eps)
         {  /* xN[j] should be able to decrease */
            if (!flag[j] && l[k] != -DBL_MAX)
            {  /* but its lower bound is active */
               continue;
            }
         }
         else /* -eps < d[j] < +eps */
         {  /* xN[j] does not affect the objective function within the
             * specified tolerance */
            continue;
         }
         /* xN[j] is eligible non-basic variable */
         num++;
         if (list != NULL)
            list[num] = j;
      }
      return num;
}

/***********************************************************************
*  spx_chuzc_std - choose non-basic variable (Dantzig's rule)
*
*  This routine chooses most eligible non-basic variable xN[q]
*  according to Dantzig's ("standard") rule:
*
*     d[q] =   max |d[j]|,
*            j in J
*
*  where J <= {1, ..., n-m} is the set of indices of eligible non-basic
*  variables, d[j] is the reduced cost of non-basic variable xN[j] in
*  the current basis.
*
*  Reduced costs of non-basic variables should be placed in the array
*  locations d[1], ..., d[n-m].
*
*  Indices of eligible non-basic variables j in J should be placed in
*  the array locations list[1], ..., list[num], where num = |J| > 0 is
*  the total number of such variables.
*
*  On exit the routine returns q, the index of the non-basic variable
*  xN[q] chosen. */

int spx_chuzc_std(SPXLP *lp, const double d[/*1+n-m*/], int num,
      const int list[])
{     int m = lp->m;
      int n = lp->n;
      int j, q, t;
      double abs_dj, abs_dq;
      xassert(0 < num && num <= n-m);
      q = 0, abs_dq = -1.0;
      for (t = 1; t <= num; t++)
      {  j = list[t];
         abs_dj = (d[j] >= 0.0 ? +d[j] : -d[j]);
         if (abs_dq < abs_dj)
            q = j, abs_dq = abs_dj;
      }
      xassert(q != 0);
      return q;
}

/***********************************************************************
*  spx_alloc_se - allocate pricing data block
*
*  This routine allocates the memory for arrays used in the pricing
*  data block. */

void spx_alloc_se(SPXLP *lp, SPXSE *se)
{     int m = lp->m;
      int n = lp->n;
      se->valid = 0;
      se->refsp = talloc(1+n, char);
      se->gamma = talloc(1+n-m, double);
      se->work = talloc(1+m, double);
      return;
}

/***********************************************************************
*  spx_reset_refsp - reset reference space
*
*  This routine resets (re-initializes) the reference space composing
*  it from variables which are non-basic in the current basis, and sets
*  all weights gamma[j] to 1. */

void spx_reset_refsp(SPXLP *lp, SPXSE *se)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *gamma = se->gamma;
      int j, k;
      se->valid = 1;
      memset(&refsp[1], 0, n * sizeof(char));
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         refsp[k] = 1;
         gamma[j] = 1.0;
      }
      return;
}

/***********************************************************************
*  spx_eval_gamma_j - compute projected steepest edge weight directly
*
*  This routine computes projected steepest edge weight gamma[j],
*  1 <= j <= n-m, for the current basis directly with the formula:
*
*                            m
*     gamma[j] = delta[j] + sum eta[i] * T[i,j]**2,
*                           i=1
*
*  where T[i,j] is element of the current simplex table, and
*
*                ( 1, if xB[i] is in the reference space
*     eta[i]   = {
*                ( 0, otherwise
*
*                ( 1, if xN[j] is in the reference space
*     delta[j] = {
*                ( 0, otherwise
*
*  NOTE: For testing/debugging only. */

double spx_eval_gamma_j(SPXLP *lp, SPXSE *se, int j)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *tcol = se->work;
      int i, k;
      double gamma_j;
      xassert(se->valid);
      xassert(1 <= j && j <= n-m);
      k = head[m+j]; /* x[k] = xN[j] */
      gamma_j = (refsp[k] ? 1.0 : 0.0);
      spx_eval_tcol(lp, j, tcol);
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         if (refsp[k])
            gamma_j += tcol[i] * tcol[i];
      }
      return gamma_j;
}

/***********************************************************************
*  spx_chuzc_pse - choose non-basic variable (projected steepest edge)
*
*  This routine chooses most eligible non-basic variable xN[q]
*  according to the projected steepest edge method:
*
*      d[q]**2           d[j]**2
*     -------- =   max  -------- ,
*     gamma[q]   j in J gamma[j]
*
*  where J <= {1, ..., n-m} is the set of indices of eligible non-basic
*  variable, d[j] is the reduced cost of non-basic variable xN[j] in
*  the current basis, gamma[j] is the projected steepest edge weight.
*
*  Reduced costs of non-basic variables should be placed in the array
*  locations d[1], ..., d[n-m].
*
*  Indices of eligible non-basic variables j in J should be placed in
*  the array locations list[1], ..., list[num], where num = |J| > 0 is
*  the total number of such variables.
*
*  On exit the routine returns q, the index of the non-basic variable
*  xN[q] chosen. */

int spx_chuzc_pse(SPXLP *lp, SPXSE *se, const double d[/*1+n-m*/],
      int num, const int list[])
{     int m = lp->m;
      int n = lp->n;
      double *gamma = se->gamma;
      int j, q, t;
      double best, temp;
      xassert(se->valid);
      xassert(0 < num && num <= n-m);
      q = 0, best = -1.0;
      for (t = 1; t <= num; t++)
      {  j = list[t];
         /* FIXME */
         if (gamma[j] < DBL_EPSILON)
            temp = 0.0;
         else
            temp = (d[j] * d[j]) / gamma[j];
         if (best < temp)
            q = j, best = temp;
      }
      xassert(q != 0);
      return q;
}

/***********************************************************************
*  spx_update_gamma - update projected steepest edge weights exactly
*
*  This routine updates the vector gamma = (gamma[j]) of projected
*  steepest edge weights exactly, for the adjacent basis.
*
*  On entry to the routine the content of the se object should be valid
*  and should correspond to the current basis.
*
*  The parameter 1 <= p <= m specifies basic variable xB[p] which
*  becomes non-basic variable xN[q] in the adjacent basis.
*
*  The parameter 1 <= q <= n-m specified non-basic variable xN[q] which
*  becomes basic variable xB[p] in the adjacent basis.
*
*  It is assumed that the array trow contains elements of p-th (pivot)
*  row T'[p] of the simplex table in locations trow[1], ..., trow[n-m].
*  It is also assumed that the array tcol contains elements of q-th
*  (pivot) column T[q] of the simple table in locations tcol[1], ...,
*  tcol[m]. (These row and column should be computed for the current
*  basis.)
*
*  For details about the formulae used see the program documentation.
*
*  The routine also computes the relative error:
*
*     e = |gamma[q] - gamma'[q]| / (1 + |gamma[q]|),
*
*  where gamma'[q] is the weight for xN[q] on entry to the routine,
*  and returns e on exit. (If e happens to be large enough, the calling
*  program may reset the reference space, since other weights also may
*  be inaccurate.) */

double spx_update_gamma(SPXLP *lp, SPXSE *se, int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *gamma = se->gamma;
      double *u = se->work;
      int i, j, k, ptr, end;
      double gamma_q, delta_q, e, r, s, t1, t2;
      xassert(se->valid);
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n-m);
      /* compute gamma[q] in current basis more accurately; also
       * compute auxiliary vector u */
      k = head[m+q]; /* x[k] = xN[q] */
      gamma_q = delta_q = (refsp[k] ? 1.0 : 0.0);
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         if (refsp[k])
         {  gamma_q += tcol[i] * tcol[i];
            u[i] = tcol[i];
         }
         else
            u[i] = 0.0;
      }
      bfd_btran(lp->bfd, u);
      /* compute relative error in gamma[q] */
      e = fabs(gamma_q - gamma[q]) / (1.0 + gamma_q);
      /* compute new gamma[q] */
      gamma[q] = gamma_q / (tcol[p] * tcol[p]);
      /* compute new gamma[j] for all j != q */
      for (j = 1; j <= n-m; j++)
      {  if (j == q)
            continue;
         if (-1e-9 < trow[j] && trow[j] < +1e-9)
         {  /* T[p,j] is close to zero; gamma[j] is not changed */
            continue;
         }
         /* compute r[j] = T[p,j] / T[p,q] */
         r = trow[j] / tcol[p];
         /* compute inner product s[j] = N'[j] * u, where N[j] = A[k]
          * is constraint matrix column corresponding to xN[j] */
         s = 0.0;
         k = head[m+j]; /* x[k] = xN[j] */
         ptr = lp->A_ptr[k];
         end = lp->A_ptr[k+1];
         for (; ptr < end; ptr++)
            s += lp->A_val[ptr] * u[lp->A_ind[ptr]];
         /* compute new gamma[j] */
         t1 = gamma[j] + r * (r * gamma_q + s + s);
         t2 = (refsp[k] ? 1.0 : 0.0) + delta_q * r * r;
         gamma[j] = (t1 >= t2 ? t1 : t2);
      }
      return e;
}

/***********************************************************************
*  spx_free_se - deallocate pricing data block
*
*  This routine deallocates the memory used for arrays in the pricing
*  data block. */

void spx_free_se(SPXLP *lp, SPXSE *se)
{     xassert(lp == lp);
      tfree(se->refsp);
      tfree(se->gamma);
      tfree(se->work);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxchuzc.h0000644000175100001710000000560200000000000025610 0ustar00runnerdocker00000000000000/* spxchuzc.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXCHUZC_H
#define SPXCHUZC_H

#include "spxlp.h"

#define spx_chuzc_sel _glp_spx_chuzc_sel
int spx_chuzc_sel(SPXLP *lp, const double d[/*1+n-m*/], double tol,
      double tol1, int list[/*1+n-m*/]);
/* select eligible non-basic variables */

#define spx_chuzc_std _glp_spx_chuzc_std
int spx_chuzc_std(SPXLP *lp, const double d[/*1+n-m*/], int num,
      const int list[]);
/* choose non-basic variable (Dantzig's rule) */

typedef struct SPXSE SPXSE;

struct SPXSE
{     /* projected steepest edge and Devex pricing data block */
      int valid;
      /* content validity flag */
      char *refsp; /* char refsp[1+n]; */
      /* refsp[0] is not used;
       * refsp[k], 1 <= k <= n, is the flag meaning that variable x[k]
       * is in the reference space */
      double *gamma; /* double gamma[1+n-m]; */
      /* gamma[0] is not used;
       * gamma[j], 1 <= j <= n-m, is the weight for reduced cost d[j]
       * of non-basic variable xN[j] in the current basis */
      double *work; /* double work[1+m]; */
      /* working array */
};

#define spx_alloc_se _glp_spx_alloc_se
void spx_alloc_se(SPXLP *lp, SPXSE *se);
/* allocate pricing data block */

#define spx_reset_refsp _glp_spx_reset_refsp
void spx_reset_refsp(SPXLP *lp, SPXSE *se);
/* reset reference space */

#define spx_eval_gamma_j _glp_spx_eval_gamma_j
double spx_eval_gamma_j(SPXLP *lp, SPXSE *se, int j);
/* compute projeted steepest edge weight directly */

#define spx_chuzc_pse _glp_spx_chuzc_pse
int spx_chuzc_pse(SPXLP *lp, SPXSE *se, const double d[/*1+n-m*/],
      int num, const int list[]);
/* choose non-basic variable (projected steepest edge) */

#define spx_update_gamma _glp_spx_update_gamma
double spx_update_gamma(SPXLP *lp, SPXSE *se, int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/]);
/* update projected steepest edge weights exactly */

#define spx_free_se _glp_spx_free_se
void spx_free_se(SPXLP *lp, SPXSE *se);
/* deallocate pricing data block */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxchuzr.c0000644000175100001710000005442300000000000025627 0ustar00runnerdocker00000000000000/* spxchuzr.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxchuzr.h"

/***********************************************************************
*  spx_chuzr_std - choose basic variable (textbook ratio test)
*
*  This routine implements an improved textbook ratio test to choose
*  basic variable xB[p].
*
*  The parameter phase specifies the search phase:
*
*  1 - searching for feasible basic solution. In this case the routine
*      uses artificial bounds of basic variables that correspond to
*      breakpoints of the penalty function:
*
*                 ( lB[i], if cB[i] = 0
*                 (
*        lB'[i] = { uB[i], if cB[i] > 0
*                 (
*                 (  -inf, if cB[i] < 0
*
*                 ( uB[i], if cB[i] = 0
*                 (
*        uB'[i] = {  +inf, if cB[i] > 0
*                 (
*                 ( lB[i], if cB[i] < 0
*
*      where lB[i] and uB[i] are original bounds of variable xB[i],
*      cB[i] is the penalty (objective) coefficient of that variable.
*
*  2 - searching for optimal basic solution. In this case the routine
*      uses original bounds of basic variables.
*
*  Current values of basic variables should be placed in the array
*  locations beta[1], ..., beta[m].
*
*  The parameter 1 <= q <= n-m specifies the index of non-basic
*  variable xN[q] chosen.
*
*  The parameter s specifies the direction in which xN[q] changes:
*  s = +1.0 means xN[q] increases, and s = -1.0 means xN[q] decreases.
*  (Thus, the corresponding ray parameter is theta = s (xN[q] - f[q]),
*  where f[q] is the active bound of xN[q] in the current basis.)
*
*  Elements of q-th simplex table column T[q] = (t[i,q]) corresponding
*  to non-basic variable xN[q] should be placed in the array locations
*  tcol[1], ..., tcol[m].
*
*  The parameter tol_piv specifies a tolerance for elements of the
*  simplex table column T[q]. If |t[i,q]| < tol_piv, basic variable
*  xB[i] is skipped, i.e. it is assumed that it does not depend on the
*  ray parameter theta.
*
*  The parameters tol and tol1 specify tolerances used to increase the
*  choice freedom by simulating an artificial degeneracy as follows.
*  If beta[i] <= lB[i] + delta[i], where delta[i] = tol + tol1 |lB[i]|,
*  it is assumed that beta[i] is exactly the same as lB[i]. Similarly,
*  if beta[i] >= uB[i] - delta[i], where delta[i] = tol + tol1 |uB[i]|,
*  it is assumed that beta[i] is exactly the same as uB[i].
*
*  The routine determines the index 1 <= p <= m of basic variable xB[p]
*  that reaches its (lower or upper) bound first on increasing the ray
*  parameter theta, stores the bound flag (0 - lower bound or fixed
*  value, 1 - upper bound) to the location pointed to by the pointer
*  p_flag, and returns the index p. If non-basic variable xN[q] is
*  double-bounded and reaches its opposite bound first, the routine
*  returns (-1). And if the ray parameter may increase unlimitedly, the
*  routine returns zero.
*
*  Should note that the bound flag stored to the location pointed to by
*  p_flag corresponds to the original (not artficial) bound of variable
*  xB[p] and defines the active bound flag lp->flag[q] to be set in the
*  adjacent basis for that basic variable. */

int spx_chuzr_std(SPXLP *lp, int phase, const double beta[/*1+m*/],
      int q, double s, const double tcol[/*1+m*/], int *p_flag,
      double tol_piv, double tol, double tol1)
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, i_flag, k, p;
      double alfa, biga, delta, lk, uk, teta, teta_min;
      xassert(phase == 1 || phase == 2);
      xassert(1 <= q && q <= n-m);
      xassert(s == +1.0 || s == -1.0);
      /* determine initial teta_min */
      k = head[m+q]; /* x[k] = xN[q] */
      if (l[k] == -DBL_MAX || u[k] == +DBL_MAX)
      {  /* xN[q] has no opposite bound */
         p = 0, *p_flag = 0, teta_min = DBL_MAX, biga = 0.0;
      }
      else
      {  /* xN[q] have both lower and upper bounds */
         p = -1, *p_flag = 0, teta_min = fabs(l[k] - u[k]), biga = 1.0;
      }
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         /* determine alfa such that delta xB[i] = alfa * teta */
         alfa = s * tcol[i];
         if (alfa <= -tol_piv)
         {  /* xB[i] decreases */
            /* determine actual lower bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* xB[i] has no actual lower bound */
               continue;
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* actual lower bound of xB[i] is its upper bound */
               lk = u[k];
               xassert(lk != +DBL_MAX);
               i_flag = 1;
            }
            else
            {  /* actual lower bound of xB[i] is its original bound */
               lk = l[k];
               if (lk == -DBL_MAX)
                  continue;
               i_flag = 0;
            }
            /* determine teta on which xB[i] reaches its lower bound */
            delta = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] <= lk + delta)
               teta = 0.0;
            else
               teta = (lk - beta[i]) / alfa;
         }
         else if (alfa >= +tol_piv)
         {  /* xB[i] increases */
            /* determine actual upper bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* actual upper bound of xB[i] is its lower bound */
               uk = l[k];
               xassert(uk != -DBL_MAX);
               i_flag = 0;
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* xB[i] has no actual upper bound */
               continue;
            }
            else
            {  /* actual upper bound of xB[i] is its original bound */
               uk = u[k];
               if (uk == +DBL_MAX)
                  continue;
               i_flag = 1;
            }
            /* determine teta on which xB[i] reaches its upper bound */
            delta = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] >= uk - delta)
               teta = 0.0;
            else
               teta = (uk - beta[i]) / alfa;
         }
         else
         {  /* xB[i] does not depend on teta */
            continue;
         }
         /* choose basic variable xB[p] for which teta is minimal */
         xassert(teta >= 0.0);
         alfa = (alfa >= 0.0 ? +alfa : -alfa);
         if (teta_min > teta || (teta_min == teta && biga < alfa))
            p = i, *p_flag = i_flag, teta_min = teta, biga = alfa;
      }
      /* if xB[p] is fixed variable, adjust its bound flag */
      if (p > 0)
      {  k = head[p];
         if (l[k] == u[k])
            *p_flag = 0;
      }
      return p;
}

/***********************************************************************
*  spx_chuzr_harris - choose basic variable (Harris' ratio test)
*
*  This routine implements Harris' ratio test to choose basic variable
*  xB[p].
*
*  All the parameters, except tol and tol1, as well as the returned
*  value have the same meaning as for the routine spx_chuzr_std (see
*  above).
*
*  The parameters tol and tol1 specify tolerances on bound violations
*  for basic variables. For the lower bound of basic variable xB[i] the
*  tolerance is delta[i] = tol + tol1 |lB[i]|, and for the upper bound
*  the tolerance is delta[i] = tol + tol1 |uB[i]|. */

int spx_chuzr_harris(SPXLP *lp, int phase, const double beta[/*1+m*/],
      int q, double s, const double tcol[/*1+m*/], int *p_flag,
      double tol_piv, double tol, double tol1)
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, i_flag, k, p;
      double alfa, biga, delta, lk, uk, teta, teta_min;
      xassert(phase == 1 || phase == 2);
      xassert(1 <= q && q <= n-m);
      xassert(s == +1.0 || s == -1.0);
      /*--------------------------------------------------------------*/
      /* first pass: determine teta_min for relaxed bounds            */
      /*--------------------------------------------------------------*/
      teta_min = DBL_MAX;
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         /* determine alfa such that delta xB[i] = alfa * teta */
         alfa = s * tcol[i];
         if (alfa <= -tol_piv)
         {  /* xB[i] decreases */
            /* determine actual lower bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* xB[i] has no actual lower bound */
               continue;
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* actual lower bound of xB[i] is its upper bound */
               lk = u[k];
               xassert(lk != +DBL_MAX);
            }
            else
            {  /* actual lower bound of xB[i] is its original bound */
               lk = l[k];
               if (lk == -DBL_MAX)
                  continue;
            }
            /* determine teta on which xB[i] reaches its relaxed lower
             * bound */
            delta = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] < lk)
               teta = - delta / alfa;
            else
               teta = ((lk - delta) - beta[i]) / alfa;
         }
         else if (alfa >= +tol_piv)
         {  /* xB[i] increases */
            /* determine actual upper bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* actual upper bound of xB[i] is its lower bound */
               uk = l[k];
               xassert(uk != -DBL_MAX);
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* xB[i] has no actual upper bound */
               continue;
            }
            else
            {  /* actual upper bound of xB[i] is its original bound */
               uk = u[k];
               if (uk == +DBL_MAX)
                  continue;
            }
            /* determine teta on which xB[i] reaches its relaxed upper
             * bound */
            delta = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] > uk)
               teta = + delta / alfa;
            else
               teta = ((uk + delta) - beta[i]) / alfa;
         }
         else
         {  /* xB[i] does not depend on teta */
            continue;
         }
         xassert(teta >= 0.0);
         if (teta_min > teta)
            teta_min = teta;
      }
      /*--------------------------------------------------------------*/
      /* second pass: choose basic variable xB[p]                     */
      /*--------------------------------------------------------------*/
      k = head[m+q]; /* x[k] = xN[q] */
      if (l[k] != -DBL_MAX && u[k] != +DBL_MAX)
      {  /* xN[q] has both lower and upper bounds */
         if (fabs(l[k] - u[k]) <= teta_min)
         {  /* and reaches its opposite bound */
            p = -1, *p_flag = 0;
            goto done;
         }
      }
      if (teta_min == DBL_MAX)
      {  /* teta may increase unlimitedly */
         p = 0, *p_flag = 0;
         goto done;
      }
      /* nothing is chosen so far */
      p = 0, *p_flag = 0, biga = 0.0;
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         /* determine alfa such that delta xB[i] = alfa * teta */
         alfa = s * tcol[i];
         if (alfa <= -tol_piv)
         {  /* xB[i] decreases */
            /* determine actual lower bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* xB[i] has no actual lower bound */
               continue;
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* actual lower bound of xB[i] is its upper bound */
               lk = u[k];
               xassert(lk != +DBL_MAX);
               i_flag = 1;
            }
            else
            {  /* actual lower bound of xB[i] is its original bound */
               lk = l[k];
               if (lk == -DBL_MAX)
                  continue;
               i_flag = 0;
            }
            /* determine teta on which xB[i] reaches its lower bound */
            teta = (lk - beta[i]) / alfa;
         }
         else if (alfa >= +tol_piv)
         {  /* xB[i] increases */
            /* determine actual upper bound of xB[i] */
            if (phase == 1 && c[k] < 0.0)
            {  /* actual upper bound of xB[i] is its lower bound */
               uk = l[k];
               xassert(uk != -DBL_MAX);
               i_flag = 0;
            }
            else if (phase == 1 && c[k] > 0.0)
            {  /* xB[i] has no actual upper bound */
               continue;
            }
            else
            {  /* actual upper bound of xB[i] is its original bound */
               uk = u[k];
               if (uk == +DBL_MAX)
                  continue;
               i_flag = 1;
            }
            /* determine teta on which xB[i] reaches its upper bound */
            teta = (uk - beta[i]) / alfa;
         }
         else
         {  /* xB[i] does not depend on teta */
            continue;
         }
         /* choose basic variable for which teta is not greater than
          * teta_min determined for relaxed bounds and which has best
          * (largest in magnitude) pivot */
         alfa = (alfa >= 0.0 ? +alfa : -alfa);
         if (teta <= teta_min && biga < alfa)
            p = i, *p_flag = i_flag, biga = alfa;
      }
      /* something must be chosen */
      xassert(1 <= p && p <= m);
      /* if xB[p] is fixed variable, adjust its bound flag */
      k = head[p];
      if (l[k] == u[k])
         *p_flag = 0;
done: return p;
}

#if 1 /* 22/VI-2017 */
/***********************************************************************
*  spx_ls_eval_bp - determine penalty function break points
*
*  This routine determines break points of the penalty function (which
*  is the sum of primal infeasibilities).
*
*  The parameters lp, beta, q, dq, tcol, and tol_piv have the same
*  meaning as for the routine spx_chuzr_std (see above).
*
*  The routine stores the break-points determined to the array elements
*  bp[1], ..., bp[nbp] in *arbitrary* order, where 0 <= nbp <= 2*m+1 is
*  the number of break-points returned by the routine on exit. */

int spx_ls_eval_bp(SPXLP *lp, const double beta[/*1+m*/],
      int q, double dq, const double tcol[/*1+m*/], double tol_piv,
      SPXBP bp[/*1+2*m+1*/])
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, k, nbp;
      double s, alfa;
      xassert(1 <= q && q <= n-m);
      xassert(dq != 0.0);
      s = (dq < 0.0 ? +1.0 : -1.0);
      nbp = 0;
      /* if chosen non-basic variable xN[q] is double-bounded, include
       * it in the list, because it can cross its opposite bound */
      k = head[m+q]; /* x[k] = xN[q] */
      if (l[k] != -DBL_MAX && u[k] != +DBL_MAX)
      {  nbp++;
         bp[nbp].i = 0;
         xassert(l[k] < u[k]); /* xN[q] cannot be fixed */
         bp[nbp].teta = u[k] - l[k];
         bp[nbp].dc = s;
      }
      /* build the list of all basic variables xB[i] that can cross
       * their bound(s) for the ray parameter 0 <= teta < teta_max */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         xassert(l[k] <= u[k]);
         /* determine alfa such that (delta xB[i]) = alfa * teta */
         alfa = s * tcol[i];
         if (alfa >= +tol_piv)
         {  /* xB[i] increases on increasing teta */
            if (l[k] == u[k])
            {  /* xB[i] is fixed at lB[i] = uB[i] */
               if (c[k] <= 0.0)
               {  /* increasing xB[i] can cross its fixed value lB[i],
                   * because currently xB[i] <= lB[i] */
                  nbp++;
                  bp[nbp].i = +i;
                  bp[nbp].teta = (l[k] - beta[i]) / alfa;
                  /* if xB[i] > lB[i] then cB[i] = +1 */
                  bp[nbp].dc = +1.0 - c[k];
               }
            }
            else
            {  if (l[k] != -DBL_MAX && c[k] < 0.0)
               {  /* increasing xB[i] can cross its lower bound lB[i],
                   * because currently xB[i] < lB[i] */
                  nbp++;
                  bp[nbp].i = +i;
                  bp[nbp].teta = (l[k] - beta[i]) / alfa;
                  bp[nbp].dc = +1.0;
               }
               if (u[k] != +DBL_MAX && c[k] <= 0.0)
               {  /* increasing xB[i] can cross its upper bound uB[i],
                   * because currently xB[i] does not violate it */
                  nbp++;
                  bp[nbp].i = -i;
                  bp[nbp].teta = (u[k] - beta[i]) / alfa;
                  bp[nbp].dc = +1.0;
               }
            }
         }
         else if (alfa <= -tol_piv)
         {  /* xB[i] decreases on increasing teta */
            if (l[k] == u[k])
            {  /* xB[i] is fixed at lB[i] = uB[i] */
               if (c[k] >= 0.0)
               {  /* decreasing xB[i] can cross its fixed value lB[i],
                   * because currently xB[i] >= lB[i] */
                  nbp++;
                  bp[nbp].i = +i;
                  bp[nbp].teta = (l[k] - beta[i]) / alfa;
                  /* if xB[i] < lB[i] then cB[i] = -1 */
                  bp[nbp].dc = -1.0 - c[k];
               }
            }
            else
            {  if (l[k] != -DBL_MAX && c[k] >= 0.0)
               {  /* decreasing xB[i] can cross its lower bound lB[i],
                   * because currently xB[i] does not violate it */
                  nbp++;
                  bp[nbp].i = +i;
                  bp[nbp].teta = (l[k] - beta[i]) / alfa;
                  bp[nbp].dc = -1.0;
               }
               if (u[k] != +DBL_MAX && c[k] > 0.0)
               {  /* decreasing xB[i] can cross its upper bound uB[i],
                   * because currently xB[i] > uB[i] */
                  nbp++;
                  bp[nbp].i = -i;
                  bp[nbp].teta = (u[k] - beta[i]) / alfa;
                  bp[nbp].dc = -1.0;
               }
            }
         }
         else
         {  /* xB[i] does not depend on teta within a tolerance */
            continue;
         }
         /* teta < 0 may happen only due to round-off errors when the
          * current value of xB[i] is *close* to its (lower or upper)
          * bound; in this case we replace teta by exact zero */
         if (bp[nbp].teta < 0.0)
            bp[nbp].teta = 0.0;
      }
      xassert(nbp <= 2*m+1);
      return nbp;
}
#endif

#if 1 /* 22/VI-2017 */
/***********************************************************************
*  spx_ls_select_bp - select and process penalty function break points
*
*  This routine selects a next portion of the penalty function break
*  points and processes them.
*
*  On entry to the routine it is assumed that break points bp[1], ...,
*  bp[num] are already processed, and slope is the penalty function
*  slope to the right of the last processed break point bp[num].
*  (Initially, when num = 0, slope should be specified as -fabs(d[q]),
*  where d[q] is the reduced cost of chosen non-basic variable xN[q].)
*
*  The routine selects break points among bp[num+1], ..., bp[nbp], for
*  which teta <= teta_lim, and moves these break points to the array
*  elements bp[num+1], ..., bp[num1], where num <= num1 <= 2*m+1 is the
*  new number of processed break points returned by the routine on
*  exit. Then the routine sorts the break points by ascending teta and
*  computes the change of the penalty function relative to its value at
*  teta = 0.
*
*  On exit the routine also replaces the parameter slope with a new
*  value that corresponds to the new last break-point bp[num1]. */

static int CDECL fcmp(const void *v1, const void *v2)
{     const SPXBP *p1 = v1, *p2 = v2;
      if (p1->teta < p2->teta)
         return -1;
      else if (p1->teta > p2->teta)
         return +1;
      else
         return 0;
}

int spx_ls_select_bp(SPXLP *lp, const double tcol[/*1+m*/],
      int nbp, SPXBP bp[/*1+m+m+1*/], int num, double *slope, double
      teta_lim)
{     int m = lp->m;
      int i, t, num1;
      double teta, dz;
      xassert(0 <= num && num <= nbp && nbp <= m+m+1);
      /* select a new portion of break points */
      num1 = num;
      for (t = num+1; t <= nbp; t++)
      {  if (bp[t].teta <= teta_lim)
         {  /* move break point to the beginning of the new portion */
            num1++;
            i = bp[num1].i, teta = bp[num1].teta, dz = bp[num1].dc;
            bp[num1].i = bp[t].i, bp[num1].teta = bp[t].teta,
            bp[num1].dc = bp[t].dc;
            bp[t].i = i, bp[t].teta = teta, bp[t].dc = dz;
         }
      }
      /* sort new break points bp[num+1], ..., bp[num1] by ascending
       * the ray parameter teta */
      if (num1 - num > 1)
         qsort(&bp[num+1], num1 - num, sizeof(SPXBP), fcmp);
      /* calculate the penalty function change at the new break points
       * selected */
      for (t = num+1; t <= num1; t++)
      {  /* calculate the penalty function change relative to its value
          * at break point bp[t-1] */
         dz = (*slope) * (bp[t].teta - (t == 1 ? 0.0 : bp[t-1].teta));
         /* calculate the penalty function change relative to its value
          * at teta = 0 */
         bp[t].dz = (t == 1 ? 0.0 : bp[t-1].dz) + dz;
         /* calculate a new slope of the penalty function to the right
          * of the current break point bp[t] */
         i = (bp[t].i >= 0 ? bp[t].i : -bp[t].i);
         xassert(0 <= i && i <= m);
         if (i == 0)
            *slope += fabs(1.0 * bp[t].dc);
         else
            *slope += fabs(tcol[i] * bp[t].dc);
      }
      return num1;
}
#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxchuzr.h0000644000175100001710000000536000000000000025630 0ustar00runnerdocker00000000000000/* spxchuzr.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXCHUZR_H
#define SPXCHUZR_H

#include "spxlp.h"

#define spx_chuzr_std _glp_spx_chuzr_std
int spx_chuzr_std(SPXLP *lp, int phase, const double beta[/*1+m*/],
      int q, double s, const double tcol[/*1+m*/], int *p_flag,
      double tol_piv, double tol, double tol1);
/* choose basic variable (textbook ratio test) */

#define spx_chuzr_harris _glp_spx_chuzr_harris
int spx_chuzr_harris(SPXLP *lp, int phase, const double beta[/*1+m*/],
      int q, double s, const double tcol[/*1+m*/], int *p_flag,
      double tol_piv, double tol, double tol1);
/* choose basic variable (Harris' ratio test) */

#if 1 /* 22/VI-2017 */
typedef struct SPXBP SPXBP;

struct SPXBP
{     /* penalty function (sum of infeasibilities) break point */
      int i;
      /* basic variable xB[i], 1 <= i <= m, that intersects its bound
       * at this break point
       * i > 0 if xB[i] intersects its lower bound (or fixed value)
       * i < 0 if xB[i] intersects its upper bound
       * i = 0 if xN[q] intersects its opposite bound */
      double teta;
      /* ray parameter value, teta >= 0, at this break point */
      double dc;
      /* increment of the penalty function coefficient cB[i] at this
       * break point */
      double dz;
      /* increment, z[t] - z[0], of the penalty function at this break
       * point */
};

#define spx_ls_eval_bp _glp_spx_ls_eval_bp
int spx_ls_eval_bp(SPXLP *lp, const double beta[/*1+m*/],
      int q, double dq, const double tcol[/*1+m*/], double tol_piv,
      SPXBP bp[/*1+2*m+1*/]);
/* determine penalty function break points */

#define spx_ls_select_bp _glp_spx_ls_select_bp
int spx_ls_select_bp(SPXLP *lp, const double tcol[/*1+m*/],
      int nbp, SPXBP bp[/*1+m+m+1*/], int num, double *slope, double
      teta_lim);
/* select and process penalty function break points */
#endif

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxlp.c0000644000175100001710000006661000000000000025110 0ustar00runnerdocker00000000000000/* spxlp.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxlp.h"

/***********************************************************************
*  spx_factorize - compute factorization of current basis matrix
*
*  This routine computes factorization of the current basis matrix B.
*
*  If the factorization has been successfully computed, the routine
*  validates it and returns zero. Otherwise, the routine invalidates
*  the factorization and returns the code provided by the factorization
*  driver (bfd_factorize). */

static int jth_col(void *info, int j, int ind[], double val[])
{     /* provide column B[j] */
      SPXLP *lp = info;
      int m = lp->m;
      int *A_ptr = lp->A_ptr;
      int *head = lp->head;
      int k, ptr, len;
      xassert(1 <= j && j <= m);
      k = head[j]; /* x[k] = xB[j] */
      ptr = A_ptr[k];
      len = A_ptr[k+1] - ptr;
      memcpy(&ind[1], &lp->A_ind[ptr], len * sizeof(int));
      memcpy(&val[1], &lp->A_val[ptr], len * sizeof(double));
      return len;
}

int spx_factorize(SPXLP *lp)
{     int ret;
      ret = bfd_factorize(lp->bfd, lp->m, jth_col, lp);
      lp->valid = (ret == 0);
      return ret;
}

/***********************************************************************
*  spx_eval_beta - compute current values of basic variables
*
*  This routine computes vector beta = (beta[i]) of current values of
*  basic variables xB = (xB[i]). (Factorization of the current basis
*  matrix should be valid.)
*
*  First the routine computes a modified vector of right-hand sides:
*
*                         n-m
*     y = b - N * f = b - sum N[j] * f[j],
*                         j=1
*
*  where b = (b[i]) is the original vector of right-hand sides, N is
*  a matrix composed from columns of the original constraint matrix A,
*  which (columns) correspond to non-basic variables, f = (f[j]) is the
*  vector of active bounds of non-basic variables xN = (xN[j]),
*  N[j] = A[k] is a column of matrix A corresponding to non-basic
*  variable xN[j] = x[k], f[j] is current active bound lN[j] = l[k] or
*  uN[j] = u[k] of non-basic variable xN[j] = x[k]. The matrix-vector
*  product N * f is computed as a linear combination of columns of N,
*  so if f[j] = 0, column N[j] can be skipped.
*
*  Then the routine performs FTRAN to compute the vector beta:
*
*     beta = inv(B) * y.
*
*  On exit the routine stores components of the vector beta to array
*  locations beta[1], ..., beta[m]. */

void spx_eval_beta(SPXLP *lp, double beta[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      double *b = lp->b;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k, ptr, end;
      double fj, *y;
      /* compute y = b - N * xN */
      /* y := b */
      y = beta;
      memcpy(&y[1], &b[1], m * sizeof(double));
      /* y := y - N * f */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* f[j] := active bound of xN[j] */
         fj = flag[j] ? u[k] : l[k];
         if (fj == 0.0 || fj == -DBL_MAX)
         {  /* either xN[j] has zero active bound or it is unbounded;
             * in the latter case its value is assumed to be zero */
            continue;
         }
         /* y := y - N[j] * f[j] */
         ptr = A_ptr[k];
         end = A_ptr[k+1];
         for (; ptr < end; ptr++)
            y[A_ind[ptr]] -= A_val[ptr] * fj;
      }
      /* compute beta = inv(B) * y */
      xassert(lp->valid);
      bfd_ftran(lp->bfd, beta);
      return;
}

/***********************************************************************
*  spx_eval_obj - compute current value of objective function
*
*  This routine computes the value of the objective function in the
*  current basic solution:
*
*     z = cB'* beta + cN'* f + c[0] =
*
*          m                    n-m
*       = sum cB[i] * beta[i] + sum cN[j] * f[j] + c[0],
*         i=1                   j=1
*
*  where cB = (cB[i]) is the vector of objective coefficients at basic
*  variables, beta = (beta[i]) is the vector of current values of basic
*  variables, cN = (cN[j]) is the vector of objective coefficients at
*  non-basic variables, f = (f[j]) is the vector of current active
*  bounds of non-basic variables, c[0] is the constant term of the
*  objective function.
*
*  It as assumed that components of the vector beta are stored in the
*  array locations beta[1], ..., beta[m]. */

double spx_eval_obj(SPXLP *lp, const double beta[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int i, j, k;
      double fj, z;
      /* compute z = cB'* beta + cN'* f + c0 */
      /* z := c0 */
      z = c[0];
      /* z := z + cB'* beta */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         z += c[k] * beta[i];
      }
      /* z := z + cN'* f */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* f[j] := active bound of xN[j] */
         fj = flag[j] ? u[k] : l[k];
         if (fj == 0.0 || fj == -DBL_MAX)
         {  /* either xN[j] has zero active bound or it is unbounded;
             * in the latter case its value is assumed to be zero */
            continue;
         }
         z += c[k] * fj;
      }
      return z;
}

/***********************************************************************
*  spx_eval_pi - compute simplex multipliers in current basis
*
*  This routine computes vector pi = (pi[i]) of simplex multipliers in
*  the current basis. (Factorization of the current basis matrix should
*  be valid.)
*
*  The vector pi is computed by performing BTRAN:
*
*     pi = inv(B') * cB,
*
*  where cB = (cB[i]) is the vector of objective coefficients at basic
*  variables xB = (xB[i]).
*
*  On exit components of vector pi are stored in the array locations
*  pi[1], ..., pi[m]. */

void spx_eval_pi(SPXLP *lp, double pi[/*1+m*/])
{     int m = lp->m;
      double *c = lp->c;
      int *head = lp->head;
      int i;
      double *cB;
      /* construct cB */
      cB = pi;
      for (i = 1; i <= m; i++)
         cB[i] = c[head[i]];
      /* compute pi = inv(B) * cB */
      bfd_btran(lp->bfd, pi);
      return;
}

/***********************************************************************
*  spx_eval_dj - compute reduced cost of j-th non-basic variable
*
*  This routine computes reduced cost d[j] of non-basic variable
*  xN[j] = x[k], 1 <= j <= n-m, in the current basic solution:
*
*     d[j] = c[k] - A'[k] * pi,
*
*  where c[k] is the objective coefficient at x[k], A[k] is k-th column
*  of the constraint matrix, pi is the vector of simplex multipliers in
*  the current basis.
*
*  It as assumed that components of the vector pi are stored in the
*  array locations pi[1], ..., pi[m]. */

double spx_eval_dj(SPXLP *lp, const double pi[/*1+m*/], int j)
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int k, ptr, end;
      double dj;
      xassert(1 <= j && j <= n-m);
      k = lp->head[m+j]; /* x[k] = xN[j] */
      /* dj := c[k] */
      dj = lp->c[k];
      /* dj := dj - A'[k] * pi */
      ptr = A_ptr[k];
      end = A_ptr[k+1];
      for (; ptr < end; ptr++)
         dj -= A_val[ptr] * pi[A_ind[ptr]];
      return dj;
}

/***********************************************************************
*  spx_eval_tcol - compute j-th column of simplex table
*
*  This routine computes j-th column of the current simplex table
*  T = (T[i,j]) = - inv(B) * N, 1 <= j <= n-m. (Factorization of the
*  current basis matrix should be valid.)
*
*  The simplex table column is computed by performing FTRAN:
*
*     tcol = - inv(B) * N[j],
*
*  where B is the current basis matrix, N[j] = A[k] is a column of the
*  constraint matrix corresponding to non-basic variable xN[j] = x[k].
*
*  On exit components of the simplex table column are stored in the
*  array locations tcol[1], ... tcol[m]. */

void spx_eval_tcol(SPXLP *lp, int j, double tcol[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int *head = lp->head;
      int i, k, ptr, end;
      xassert(1 <= j && j <= n-m);
      k = head[m+j]; /* x[k] = xN[j] */
      /* compute tcol = - inv(B) * N[j] */
      for (i = 1; i <= m; i++)
         tcol[i] = 0.0;
      ptr = A_ptr[k];
      end = A_ptr[k+1];
      for (; ptr < end; ptr++)
         tcol[A_ind[ptr]] = -A_val[ptr];
      bfd_ftran(lp->bfd, tcol);
      return;
}

/***********************************************************************
*  spx_eval_rho - compute i-th row of basis matrix inverse
*
*  This routine computes i-th row of the matrix inv(B), where B is
*  the current basis matrix, 1 <= i <= m. (Factorization of the current
*  basis matrix should be valid.)
*
*  The inverse row is computed by performing BTRAN:
*
*     rho = inv(B') * e[i],
*
*  where e[i] is i-th column of unity matrix.
*
*  On exit components of the row are stored in the array locations
*  row[1], ..., row[m]. */

void spx_eval_rho(SPXLP *lp, int i, double rho[/*1+m*/])
{     int m = lp->m;
      int j;
      xassert(1 <= i && i <= m);
      /* compute rho = inv(B') * e[i] */
      for (j = 1; j <= m; j++)
         rho[j] = 0.0;
      rho[i] = 1.0;
      bfd_btran(lp->bfd, rho);
      return;
}

#if 1 /* 31/III-2016 */
void spx_eval_rho_s(SPXLP *lp, int i, FVS *rho)
{     /* sparse version of spx_eval_rho */
      int m = lp->m;
      xassert(1 <= i && i <= m);
      /* compute rho = inv(B') * e[i] */
      xassert(rho->n == m);
      fvs_clear_vec(rho);
      rho->nnz = 1;
      rho->ind[1] = i;
      rho->vec[i] = 1.0;
      bfd_btran_s(lp->bfd, rho);
      return;
}
#endif

/***********************************************************************
*  spx_eval_tij - compute element T[i,j] of simplex table
*
*  This routine computes element T[i,j] of the current simplex table
*  T = - inv(B) * N, 1 <= i <= m, 1 <= j <= n-m, with the following
*  formula:
*
*     T[i,j] = - N'[j] * rho,                                        (1)
*
*  where N[j] = A[k] is a column of the constraint matrix corresponding
*  to non-basic variable xN[j] = x[k], rho is i-th row of the inverse
*  matrix inv(B).
*
*  It as assumed that components of the inverse row rho = (rho[j]) are
*  stored in the array locations rho[1], ..., rho[m]. */

double spx_eval_tij(SPXLP *lp, const double rho[/*1+m*/], int j)
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int k, ptr, end;
      double tij;
      xassert(1 <= j && j <= n-m);
      k = lp->head[m+j]; /* x[k] = xN[j] */
      /* compute t[i,j] = - N'[j] * pi */
      tij = 0.0;
      ptr = A_ptr[k];
      end = A_ptr[k+1];
      for (; ptr < end; ptr++)
         tij -= A_val[ptr] * rho[A_ind[ptr]];
      return tij;
}

/***********************************************************************
*  spx_eval_trow - compute i-th row of simplex table
*
*  This routine computes i-th row of the current simplex table
*  T = (T[i,j]) = - inv(B) * N, 1 <= i <= m.
*
*  Elements of the row T[i] = (T[i,j]), j = 1, ..., n-m, are computed
*  directly with the routine spx_eval_tij.
*
*  The vector rho = (rho[j]), which is i-th row of the basis inverse
*  inv(B), should be previously computed with the routine spx_eval_rho.
*  It is assumed that elements of this vector are stored in the array
*  locations rho[1], ..., rho[m].
*
*  On exit components of the simplex table row are stored in the array
*  locations trow[1], ... trow[n-m].
*
*  NOTE: For testing/debugging only. */

void spx_eval_trow(SPXLP *lp, const double rho[/*1+m*/], double
      trow[/*1+n-m*/])
{     int m = lp->m;
      int n = lp->n;
      int j;
      for (j = 1; j <= n-m; j++)
         trow[j] = spx_eval_tij(lp, rho, j);
      return;
}

/***********************************************************************
*  spx_update_beta - update values of basic variables
*
*  This routine updates the vector beta = (beta[i]) of values of basic
*  variables xB = (xB[i]) for the adjacent basis.
*
*  On entry to the routine components of the vector beta in the current
*  basis should be placed in array locations beta[1], ..., beta[m].
*
*  The parameter 1 <= p <= m specifies basic variable xB[p] which
*  becomes non-basic variable xN[q] in the adjacent basis. The special
*  case p < 0 means that non-basic variable xN[q] goes from its current
*  active bound to opposite one in the adjacent basis.
*
*  If the flag p_flag is set, the active bound of xB[p] in the adjacent
*  basis is set to its upper bound. (In this case xB[p] should have its
*  upper bound and should not be fixed.)
*
*  The parameter 1 <= q <= n-m specifies non-basic variable xN[q] which
*  becomes basic variable xB[p] in the adjacent basis (if 1 <= p <= m),
*  or goes to its opposite bound (if p < 0). (In the latter case xN[q]
*  should have both lower and upper bounds and should not be fixed.)
*
*  It is assumed that the array tcol contains elements of q-th (pivot)
*  column T[q] of the simple table in locations tcol[1], ..., tcol[m].
*  (This column should be computed for the current basis.)
*
*  First, the routine determines the increment of basic variable xB[p]
*  in the adjacent basis (but only if 1 <= p <= m):
*
*                   (       - beta[p], if -inf < xB[p] < +inf
*                   (
*     delta xB[p] = { lB[p] - beta[p], if p_flag = 0
*                   (
*                   ( uB[p] - beta[p], if p_flag = 1
*
*  where beta[p] is the value of xB[p] in the current basis, lB[p] and
*  uB[p] are its lower and upper bounds. Then, the routine determines
*  the increment of non-basic variable xN[q] in the adjacent basis:
*
*                   ( delta xB[p] / T[p,q], if 1 <= p <= m
*                   (
*     delta xN[q] = { uN[q] - lN[q],        if p < 0 and f[q] = lN[q]
*                   (
*                   ( lN[q] - uN[q],        if p < 0 and f[q] = uN[q]
*
*  where T[p,q] is the pivot element of the simplex table, f[q] is the
*  active bound of xN[q] in the current basis.
*
*  If 1 <= p <= m, in the adjacent basis xN[q] becomes xB[p], so:
*
*     new beta[p] = f[q] + delta xN[q].
*
*  Values of other basic variables xB[i] for 1 <= i <= m, i != p, are
*  updated as follows:
*
*     new beta[i] = beta[i] + T[i,q] * delta xN[q].
*
*  On exit the routine stores updated components of the vector beta to
*  the same locations, where the input vector beta was stored. */

void spx_update_beta(SPXLP *lp, double beta[/*1+m*/], int p,
      int p_flag, int q, const double tcol[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int i, k;
      double delta_p, delta_q;
      if (p < 0)
      {  /* special case: xN[q] goes to its opposite bound */
         xassert(1 <= q && q <= n-m);
         /* xN[q] should be double-bounded variable */
         k = head[m+q]; /* x[k] = xN[q] */
         xassert(l[k] != -DBL_MAX && u[k] != +DBL_MAX && l[k] != u[k]);
         /* determine delta xN[q] */
         if (flag[q])
         {  /* xN[q] goes from its upper bound to its lower bound */
            delta_q = l[k] - u[k];
         }
         else
         {  /* xN[q] goes from its lower bound to its upper bound */
            delta_q = u[k] - l[k];
         }
      }
      else
      {  /* xB[p] leaves the basis, xN[q] enters the basis */
         xassert(1 <= p && p <= m);
         xassert(1 <= q && q <= n-m);
         /* determine delta xB[p] */
         k = head[p]; /* x[k] = xB[p] */
         if (p_flag)
         {  /* xB[p] goes to its upper bound */
            xassert(l[k] != u[k] && u[k] != +DBL_MAX);
            delta_p = u[k] - beta[p];
         }
         else if (l[k] == -DBL_MAX)
         {  /* unbounded xB[p] becomes non-basic (unusual case) */
            xassert(u[k] == +DBL_MAX);
            delta_p = 0.0 - beta[p];
         }
         else
         {  /* xB[p] goes to its lower bound or becomes fixed */
            delta_p = l[k] - beta[p];
         }
         /* determine delta xN[q] */
         delta_q = delta_p / tcol[p];
         /* compute new beta[p], which is the value of xN[q] in the
          * adjacent basis */
         k = head[m+q]; /* x[k] = xN[q] */
         if (flag[q])
         {  /* xN[q] has its upper bound active */
            xassert(l[k] != u[k] && u[k] != +DBL_MAX);
            beta[p] = u[k] + delta_q;
         }
         else if (l[k] == -DBL_MAX)
         {  /* xN[q] is non-basic unbounded variable */
            xassert(u[k] == +DBL_MAX);
            beta[p] = 0.0 + delta_q;
         }
         else
         {  /* xN[q] has its lower bound active or is fixed (latter
             * case is unusual) */
            beta[p] = l[k] + delta_q;
         }
      }
      /* compute new beta[i] for all i != p */
      for (i = 1; i <= m; i++)
      {  if (i != p)
            beta[i] += tcol[i] * delta_q;
      }
      return;
}

#if 1 /* 30/III-2016 */
void spx_update_beta_s(SPXLP *lp, double beta[/*1+m*/], int p,
      int p_flag, int q, const FVS *tcol)
{     /* sparse version of spx_update_beta */
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int nnz = tcol->nnz;
      int *ind = tcol->ind;
      double *vec = tcol->vec;
      int i, k;
      double delta_p, delta_q;
      xassert(tcol->n == m);
      if (p < 0)
      {  /* special case: xN[q] goes to its opposite bound */
#if 0 /* 11/VI-2017 */
         /* FIXME: not tested yet */
         xassert(0);
#endif
         xassert(1 <= q && q <= n-m);
         /* xN[q] should be double-bounded variable */
         k = head[m+q]; /* x[k] = xN[q] */
         xassert(l[k] != -DBL_MAX && u[k] != +DBL_MAX && l[k] != u[k]);
         /* determine delta xN[q] */
         if (flag[q])
         {  /* xN[q] goes from its upper bound to its lower bound */
            delta_q = l[k] - u[k];
         }
         else
         {  /* xN[q] goes from its lower bound to its upper bound */
            delta_q = u[k] - l[k];
         }
      }
      else
      {  /* xB[p] leaves the basis, xN[q] enters the basis */
         xassert(1 <= p && p <= m);
         xassert(1 <= q && q <= n-m);
         /* determine delta xB[p] */
         k = head[p]; /* x[k] = xB[p] */
         if (p_flag)
         {  /* xB[p] goes to its upper bound */
            xassert(l[k] != u[k] && u[k] != +DBL_MAX);
            delta_p = u[k] - beta[p];
         }
         else if (l[k] == -DBL_MAX)
         {  /* unbounded xB[p] becomes non-basic (unusual case) */
            xassert(u[k] == +DBL_MAX);
            delta_p = 0.0 - beta[p];
         }
         else
         {  /* xB[p] goes to its lower bound or becomes fixed */
            delta_p = l[k] - beta[p];
         }
         /* determine delta xN[q] */
         delta_q = delta_p / vec[p];
         /* compute new beta[p], which is the value of xN[q] in the
          * adjacent basis */
         k = head[m+q]; /* x[k] = xN[q] */
         if (flag[q])
         {  /* xN[q] has its upper bound active */
            xassert(l[k] != u[k] && u[k] != +DBL_MAX);
            beta[p] = u[k] + delta_q;
         }
         else if (l[k] == -DBL_MAX)
         {  /* xN[q] is non-basic unbounded variable */
            xassert(u[k] == +DBL_MAX);
            beta[p] = 0.0 + delta_q;
         }
         else
         {  /* xN[q] has its lower bound active or is fixed (latter
             * case is unusual) */
            beta[p] = l[k] + delta_q;
         }
      }
      /* compute new beta[i] for all i != p */
      for (k = 1; k <= nnz; k++)
      {  i = ind[k];
         if (i != p)
            beta[i] += vec[i] * delta_q;
      }
      return;
}
#endif

/***********************************************************************
*  spx_update_d - update reduced costs of non-basic variables
*
*  This routine updates the vector d = (d[j]) of reduced costs of
*  non-basic variables xN = (xN[j]) for the adjacent basis.
*
*  On entry to the routine components of the vector d in the current
*  basis should be placed in locations d[1], ..., d[n-m].
*
*  The parameter 1 <= p <= m specifies basic variable xB[p] which
*  becomes non-basic variable xN[q] in the adjacent basis.
*
*  The parameter 1 <= q <= n-m specified non-basic variable xN[q] which
*  becomes basic variable xB[p] in the adjacent basis.
*
*  It is assumed that the array trow contains elements of p-th (pivot)
*  row T'[p] of the simplex table in locations trow[1], ..., trow[n-m].
*  It is also assumed that the array tcol contains elements of q-th
*  (pivot) column T[q] of the simple table in locations tcol[1], ...,
*  tcol[m]. (These row and column should be computed for the current
*  basis.)
*
*  First, the routine computes more accurate reduced cost d[q] in the
*  current basis using q-th column of the simplex table:
*
*                    n-m
*     d[q] = cN[q] + sum t[i,q] * cB[i],
*                    i=1
*
*  where cN[q] and cB[i] are objective coefficients at variables xN[q]
*  and xB[i], resp. The routine also computes the relative error:
*
*     e = |d[q] - d'[q]| / (1 + |d[q]|),
*
*  where d'[q] is the reduced cost of xN[q] on entry to the routine,
*  and returns e on exit. (If e happens to be large enough, the calling
*  program may compute the reduced costs directly, since other reduced
*  costs also may be inaccurate.)
*
*  In the adjacent basis xB[p] becomes xN[q], so:
*
*     new d[q] = d[q] / T[p,q],
*
*  where T[p,q] is the pivot element of the simplex table (it is taken
*  from column T[q] as more accurate). Reduced costs of other non-basic
*  variables xN[j] for 1 <= j <= n-m, j != q, are updated as follows:
*
*     new d[j] = d[j] + T[p,j] * new d[q].
*
*  On exit the routine stores updated components of the vector d to the
*  same locations, where the input vector d was stored. */

double spx_update_d(SPXLP *lp, double d[/*1+n-m*/], int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      int *head = lp->head;
      int i, j, k;
      double dq, e;
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n);
      /* compute d[q] in current basis more accurately */
      k = head[m+q]; /* x[k] = xN[q] */
      dq = c[k];
      for (i = 1; i <= m; i++)
         dq += tcol[i] * c[head[i]];
      /* compute relative error in d[q] */
      e = fabs(dq - d[q]) / (1.0 + fabs(dq));
      /* compute new d[q], which is the reduced cost of xB[p] in the
       * adjacent basis */
      d[q] = (dq /= tcol[p]);
      /* compute new d[j] for all j != q */
      for (j = 1; j <= n-m; j++)
      {  if (j != q)
            d[j] -= trow[j] * dq;
      }
      return e;
}

#if 1 /* 30/III-2016 */
double spx_update_d_s(SPXLP *lp, double d[/*1+n-m*/], int p, int q,
      const FVS *trow, const FVS *tcol)
{     /* sparse version of spx_update_d */
      int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      int *head = lp->head;
      int trow_nnz = trow->nnz;
      int *trow_ind = trow->ind;
      double *trow_vec = trow->vec;
      int tcol_nnz = tcol->nnz;
      int *tcol_ind = tcol->ind;
      double *tcol_vec = tcol->vec;
      int i, j, k;
      double dq, e;
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n);
      xassert(trow->n == n-m);
      xassert(tcol->n == m);
      /* compute d[q] in current basis more accurately */
      k = head[m+q]; /* x[k] = xN[q] */
      dq = c[k];
      for (k = 1; k <= tcol_nnz; k++)
      {  i = tcol_ind[k];
         dq += tcol_vec[i] * c[head[i]];
      }
      /* compute relative error in d[q] */
      e = fabs(dq - d[q]) / (1.0 + fabs(dq));
      /* compute new d[q], which is the reduced cost of xB[p] in the
       * adjacent basis */
      d[q] = (dq /= tcol_vec[p]);
      /* compute new d[j] for all j != q */
      for (k = 1; k <= trow_nnz; k++)
      {  j = trow_ind[k];
         if (j != q)
            d[j] -= trow_vec[j] * dq;
      }
      return e;
}
#endif

/***********************************************************************
*  spx_change_basis - change current basis to adjacent one
*
*  This routine changes the current basis to the adjacent one making
*  necessary changes in lp->head and lp->flag members.
*
*  The parameters p, p_flag, and q have the same meaning as for the
*  routine spx_update_beta. */

void spx_change_basis(SPXLP *lp, int p, int p_flag, int q)
{     int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int k;
      if (p < 0)
      {  /* special case: xN[q] goes to its opposite bound */
         xassert(1 <= q && q <= n-m);
         /* xN[q] should be double-bounded variable */
         k = head[m+q]; /* x[k] = xN[q] */
         xassert(l[k] != -DBL_MAX && u[k] != +DBL_MAX && l[k] != u[k]);
         /* change active bound flag */
         flag[q] = 1 - flag[q];
      }
      else
      {  /* xB[p] leaves the basis, xN[q] enters the basis */
         xassert(1 <= p && p <= m);
         xassert(p_flag == 0 || p_flag == 1);
         xassert(1 <= q && q <= n-m);
         k = head[p]; /* xB[p] = x[k] */
         if (p_flag)
         {  /* xB[p] goes to its upper bound */
            xassert(l[k] != u[k] && u[k] != +DBL_MAX);
         }
         /* swap xB[p] and xN[q] in the basis */
         head[p] = head[m+q], head[m+q] = k;
         /* and set active bound flag for new xN[q] */
         lp->flag[q] = p_flag;
      }
      return;
}

/***********************************************************************
*  spx_update_invb - update factorization of basis matrix
*
*  This routine updates factorization of the basis matrix B when i-th
*  column of B is replaced by k-th column of the constraint matrix A.
*
*  The parameter 1 <= i <= m specifies the number of column of matrix B
*  to be replaced by a new column.
*
*  The parameter 1 <= k <= n specifies the number of column of matrix A
*  to be used for replacement.
*
*  If the factorization has been successfully updated, the routine
*  validates it and returns zero. Otherwise, the routine invalidates
*  the factorization and returns the code provided by the factorization
*  driver (bfd_update). */

int spx_update_invb(SPXLP *lp, int i, int k)
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int ptr, len, ret;
      xassert(1 <= i && i <= m);
      xassert(1 <= k && k <= n);
      ptr = A_ptr[k];
      len = A_ptr[k+1] - ptr;
      ret = bfd_update(lp->bfd, i, len, &A_ind[ptr-1], &A_val[ptr-1]);
      lp->valid = (ret == 0);
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxlp.h0000644000175100001710000002111400000000000025103 0ustar00runnerdocker00000000000000/* spxlp.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXLP_H
#define SPXLP_H

#include "bfd.h"

/***********************************************************************
*  The structure SPXLP describes LP problem and its current basis.
*
*  It is assumed that LP problem has the following formulation (this is
*  so called "working format"):
*
*     z = c'* x + c0 -> min                                          (1)
*
*     A * x = b                                                      (2)
*
*     l <= x <= u                                                    (3)
*
*  where:
*
*  x = (x[k]) is a n-vector of variables;
*
*  z is an objective function;
*
*  c = (c[k]) is a n-vector of objective coefficients;
*
*  c0 is a constant term of the objective function;
*
*  A = (a[i,k]) is a mxn-matrix of constraint coefficients;
*
*  b = (b[i]) is a m-vector of right-hand sides;
*
*  l = (l[k]) is a n-vector of lower bounds of variables;
*
*  u = (u[k]) is a n-vector of upper bounds of variables.
*
*  If variable x[k] has no lower (upper) bound, it is formally assumed
*  that l[k] = -inf (u[k] = +inf). Variable having no bounds is called
*  free (unbounded) variable. If l[k] = u[k], variable x[k] is assumed
*  to be fixed.
*
*  It is also assumed that matrix A has full row rank: rank(A) = m,
*  i.e. all its rows are linearly independent, so m <= n.
*
*  The (current) basis is defined by an appropriate permutation matrix
*  P of order n such that:
*
*             ( xB )
*     P * x = (    ),                                                (4)
*             ( xN )
*
*  where xB = (xB[i]) is a m-vector of basic variables, xN = (xN[j]) is
*  a (n-m)-vector of non-basic variables. If a non-basic variable xN[j]
*  has both lower and upper bounds, there is used an additional flag to
*  indicate which bound is active.
*
*  From (2) and (4) it follows that:
*
*     A * P'* P * x = b   <=>   B * xB + N * xN = b,                 (5)
*
*  where P' is a matrix transposed to P, and
*
*     A * P' = (B | N).                                              (6)
*
*  Here B is the basis matrix, which is a square non-singular matrix
*  of order m composed from columns of matrix A that correspond to
*  basic variables xB, and N is a mx(n-m) matrix composed from columns
*  of matrix A that correspond to non-basic variables xN. */

typedef struct SPXLP SPXLP;

struct SPXLP
{     /* LP problem data and its (current) basis */
      int m;
      /* number of equality constraints, m > 0 */
      int n;
      /* number of variables, n >= m */
      int nnz;
      /* number of non-zeros in constraint matrix A */
      /*--------------------------------------------------------------*/
      /* mxn-matrix A of constraint coefficients in sparse column-wise
       * format */
      int *A_ptr; /* int A_ptr[1+n+1]; */
      /* A_ptr[0] is not used;
       * A_ptr[k], 1 <= k <= n, is starting position of k-th column in
       * arrays A_ind and A_val; note that A_ptr[1] is always 1;
       * A_ptr[n+1] indicates the position after the last element in
       * arrays A_ind and A_val, i.e. A_ptr[n+1] = nnz+1, where nnz is
       * the number of non-zero elements in matrix A;
       * the length of k-th column (the number of non-zero elements in
       * that column) can be calculated as A_ptr[k+1] - A_ptr[k] */
      int *A_ind; /* int A_ind[1+nnz]; */
      /* row indices */
      double *A_val; /* double A_val[1+nnz]; */
      /* non-zero element values (constraint coefficients) */
      /*--------------------------------------------------------------*/
      /* principal vectors of LP formulation */
      double *b; /* double b[1+m]; */
      /* b[0] is not used;
       * b[i], 1 <= i <= m, is the right-hand side of i-th equality
       * constraint */
      double *c; /* double c[1+n]; */
      /* c[0] is the constant term of the objective function;
       * c[k], 1 <= k <= n, is the objective function coefficient at
       * variable x[k] */
      double *l; /* double l[1+n]; */
      /* l[0] is not used;
       * l[k], 1 <= k <= n, is the lower bound of variable x[k];
       * if x[k] has no lower bound, l[k] = -DBL_MAX */
      double *u; /* double u[1+n]; */
      /* u[0] is not used;
       * u[k], 1 <= k <= n, is the upper bound of variable u[k];
       * if x[k] has no upper bound, u[k] = +DBL_MAX;
       * note that l[k] = u[k] means that x[k] is fixed variable */
      /*--------------------------------------------------------------*/
      /* LP basis */
      int *head; /* int head[1+n]; */
      /* basis header, which is permutation matrix P (4):
       * head[0] is not used;
       * head[i] = k means that xB[i] = x[k], 1 <= i <= m;
       * head[m+j] = k, means that xN[j] = x[k], 1 <= j <= n-m */
      char *flag; /* char flag[1+n-m]; */
      /* flags of non-basic variables:
       * flag[0] is not used;
       * flag[j], 1 <= j <= n-m, indicates that non-basic variable
       * xN[j] is non-fixed and has its upper bound active */
      /*--------------------------------------------------------------*/
      /* basis matrix B of order m stored in factorized form */
      int valid;
      /* factorization validity flag */
      BFD *bfd;
      /* driver to factorization of the basis matrix */
};

#define spx_factorize _glp_spx_factorize
int spx_factorize(SPXLP *lp);
/* compute factorization of current basis matrix */

#define spx_eval_beta _glp_spx_eval_beta
void spx_eval_beta(SPXLP *lp, double beta[/*1+m*/]);
/* compute values of basic variables */

#define spx_eval_obj _glp_spx_eval_obj
double spx_eval_obj(SPXLP *lp, const double beta[/*1+m*/]);
/* compute value of objective function */

#define spx_eval_pi _glp_spx_eval_pi
void spx_eval_pi(SPXLP *lp, double pi[/*1+m*/]);
/* compute simplex multipliers */

#define spx_eval_dj _glp_spx_eval_dj
double spx_eval_dj(SPXLP *lp, const double pi[/*1+m*/], int j);
/* compute reduced cost of j-th non-basic variable */

#define spx_eval_tcol _glp_spx_eval_tcol
void spx_eval_tcol(SPXLP *lp, int j, double tcol[/*1+m*/]);
/* compute j-th column of simplex table */

#define spx_eval_rho _glp_spx_eval_rho
void spx_eval_rho(SPXLP *lp, int i, double rho[/*1+m*/]);
/* compute i-th row of basis matrix inverse */

#if 1 /* 31/III-2016 */
#define spx_eval_rho_s _glp_spx_eval_rho_s
void spx_eval_rho_s(SPXLP *lp, int i, FVS *rho);
/* sparse version of spx_eval_rho */
#endif

#define spx_eval_tij _glp_spx_eval_tij
double spx_eval_tij(SPXLP *lp, const double rho[/*1+m*/], int j);
/* compute element T[i,j] of simplex table */

#define spx_eval_trow _glp_spx_eval_trow
void spx_eval_trow(SPXLP *lp, const double rho[/*1+m*/], double
      trow[/*1+n-m*/]);
/* compute i-th row of simplex table */

#define spx_update_beta _glp_spx_update_beta
void spx_update_beta(SPXLP *lp, double beta[/*1+m*/], int p,
      int p_flag, int q, const double tcol[/*1+m*/]);
/* update values of basic variables */

#if 1 /* 30/III-2016 */
#define spx_update_beta_s _glp_spx_update_beta_s
void spx_update_beta_s(SPXLP *lp, double beta[/*1+m*/], int p,
      int p_flag, int q, const FVS *tcol);
/* sparse version of spx_update_beta */
#endif

#define spx_update_d _glp_spx_update_d
double spx_update_d(SPXLP *lp, double d[/*1+n-m*/], int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/]);
/* update reduced costs of non-basic variables */

#if 1 /* 30/III-2016 */
#define spx_update_d_s _glp_spx_update_d_s
double spx_update_d_s(SPXLP *lp, double d[/*1+n-m*/], int p, int q,
      const FVS *trow, const FVS *tcol);
/* sparse version of spx_update_d */
#endif

#define spx_change_basis _glp_spx_change_basis
void spx_change_basis(SPXLP *lp, int p, int p_flag, int q);
/* change current basis to adjacent one */

#define spx_update_invb _glp_spx_update_invb
int spx_update_invb(SPXLP *lp, int i, int k);
/* update factorization of basis matrix */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxnt.c0000644000175100001710000002267200000000000025116 0ustar00runnerdocker00000000000000/* spxnt.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxnt.h"

/***********************************************************************
*  spx_alloc_nt - allocate matrix N in sparse row-wise format
*
*  This routine allocates the memory for arrays needed to represent the
*  matrix N composed of non-basic columns of the constraint matrix A. */

void spx_alloc_nt(SPXLP *lp, SPXNT *nt)
{     int m = lp->m;
      int nnz = lp->nnz;
      nt->ptr = talloc(1+m, int);
      nt->len = talloc(1+m, int);
      nt->ind = talloc(1+nnz, int);
      nt->val = talloc(1+nnz, double);
      return;
}

/***********************************************************************
*  spx_init_nt - initialize row pointers for matrix N
*
*  This routine initializes (sets up) row pointers for the matrix N
*  using column-wise representation of the constraint matrix A.
*
*  This routine needs to be called only once. */

void spx_init_nt(SPXLP *lp, SPXNT *nt)
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      int *NT_ptr = nt->ptr;
      int *NT_len = nt->len;
      int i, k, ptr, end;
      /* calculate NT_len[i] = maximal number of non-zeros in i-th row
       * of N = number of non-zeros in i-th row of A */
      memset(&NT_len[1], 0, m * sizeof(int));
      for (k = 1; k <= n; k++)
      {  ptr = A_ptr[k];
         end = A_ptr[k+1];
         for (; ptr < end; ptr++)
            NT_len[A_ind[ptr]]++;
      }
      /* initialize row pointers NT_ptr[i], i = 1,...,n-m */
      NT_ptr[1] = 1;
      for (i = 2; i <= m; i++)
         NT_ptr[i] = NT_ptr[i-1] + NT_len[i-1];
      xassert(NT_ptr[m] + NT_len[m] == nnz+1);
      return;
}

/***********************************************************************
*  spx_nt_add_col - add column N[j] = A[k] to matrix N
*
*  This routine adds elements of column N[j] = A[k], 1 <= j <= n-m,
*  1 <= k <= n, to the row-wise represntation of the matrix N. It is
*  assumed (with no check) that elements of the specified column are
*  missing in the row-wise represntation of N. */

void spx_nt_add_col(SPXLP *lp, SPXNT *nt, int j, int k)
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      int *NT_ptr = nt->ptr;
      int *NT_len = nt->len;
      int *NT_ind = nt->ind;
      double *NT_val = nt->val;
      int i, ptr, end, pos;
      xassert(1 <= j && j <= n-m);
      xassert(1 <= k && k <= n);
      ptr = A_ptr[k];
      end = A_ptr[k+1];
      for (; ptr < end; ptr++)
      {  i = A_ind[ptr];
         /* add element N[i,j] = A[i,k] to i-th row of matrix N */
         pos = NT_ptr[i] + (NT_len[i]++);
         if (i < m)
            xassert(pos < NT_ptr[i+1]);
         else
            xassert(pos <= nnz);
         NT_ind[pos] = j;
         NT_val[pos] = A_val[ptr];
      }
      return;
}

/***********************************************************************
*  spx_build_nt - build matrix N for current basis
*
*  This routine builds the row-wise represntation of the matrix N
*  for the current basis by adding columns of the constraint matrix A
*  corresponding to non-basic variables. */

void spx_build_nt(SPXLP *lp, SPXNT *nt)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      int *NT_len = nt->len;
      int j, k;
      /* N := 0 */
      memset(&NT_len[1], 0, m * sizeof(int));
      /* add non-basic columns N[j] = A[k] */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         spx_nt_add_col(lp, nt, j, k);
      }
      return;
}

/***********************************************************************
*  spx_nt_del_col - remove column N[j] = A[k] from matrix N
*
*  This routine removes elements of column N[j] = A[k], 1 <= j <= n-m,
*  1 <= k <= n, from the row-wise representation of the matrix N. It is
*  assumed (with no check) that elements of the specified column are
*  present in the row-wise representation of N. */

void spx_nt_del_col(SPXLP *lp, SPXNT *nt, int j, int k)
{     int m = lp->m;
      int n = lp->n;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      int *NT_ptr = nt->ptr;
      int *NT_len = nt->len;
      int *NT_ind = nt->ind;
      double *NT_val = nt->val;
      int i, ptr, end, ptr1, end1;
      xassert(1 <= j && j <= n-m);
      xassert(1 <= k && k <= n);
      ptr = A_ptr[k];
      end = A_ptr[k+1];
      for (; ptr < end; ptr++)
      {  i = A_ind[ptr];
         /* find element N[i,j] = A[i,k] in i-th row of matrix N */
         ptr1 = NT_ptr[i];
         end1 = ptr1 + NT_len[i];
         for (; NT_ind[ptr1] != j; ptr1++)
            /* nop */;
         xassert(ptr1 < end1);
         /* and remove it from i-th row element list */
         NT_len[i]--;
         NT_ind[ptr1] = NT_ind[end1-1];
         NT_val[ptr1] = NT_val[end1-1];
      }
      return;
}

/***********************************************************************
*  spx_update_nt - update matrix N for adjacent basis
*
*  This routine updates the row-wise represntation of matrix N for
*  the adjacent basis, where column N[q], 1 <= q <= n-m, is replaced by
*  column B[p], 1 <= p <= m, of the current basis matrix B. */

void spx_update_nt(SPXLP *lp, SPXNT *nt, int p, int q)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n-m);
      /* remove old column N[q] corresponding to variable xN[q] */
      spx_nt_del_col(lp, nt, q, head[m+q]);
      /* add new column N[q] corresponding to variable xB[p] */
      spx_nt_add_col(lp, nt, q, head[p]);
      return;
}

/***********************************************************************
*  spx_nt_prod - compute product y := y + s * N'* x
*
*  This routine computes the product:
*
*     y := y + s * N'* x,
*
*  where N' is a matrix transposed to the mx(n-m)-matrix N composed
*  from non-basic columns of the constraint matrix A, x is a m-vector,
*  s is a scalar, y is (n-m)-vector.
*
*  If the flag ign is non-zero, the routine ignores the input content
*  of the array y assuming that y = 0.
*
*  The routine uses the row-wise representation of the matrix N and
*  computes the product as a linear combination:
*
*     y := y + s * (N'[1] * x[1] + ... + N'[m] * x[m]),
*
*  where N'[i] is i-th row of N, 1 <= i <= m. */

void spx_nt_prod(SPXLP *lp, SPXNT *nt, double y[/*1+n-m*/], int ign,
      double s, const double x[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *NT_ptr = nt->ptr;
      int *NT_len = nt->len;
      int *NT_ind = nt->ind;
      double *NT_val = nt->val;
      int i, j, ptr, end;
      double t;
      if (ign)
      {  /* y := 0 */
         for (j = 1; j <= n-m; j++)
            y[j] = 0.0;
      }
      for (i = 1; i <= m; i++)
      {  if (x[i] != 0.0)
         {  /* y := y + s * (i-th row of N) * x[i] */
            t = s * x[i];
            ptr = NT_ptr[i];
            end = ptr + NT_len[i];
            for (; ptr < end; ptr++)
               y[NT_ind[ptr]] += NT_val[ptr] * t;
         }
      }
      return;
}

#if 1 /* 31/III-2016 */
void spx_nt_prod_s(SPXLP *lp, SPXNT *nt, FVS *y, int ign, double s,
      const FVS *x, double eps)
{     /* sparse version of spx_nt_prod */
      int *NT_ptr = nt->ptr;
      int *NT_len = nt->len;
      int *NT_ind = nt->ind;
      double *NT_val = nt->val;
      int *x_ind = x->ind;
      double *x_vec = x->vec;
      int *y_ind = y->ind;
      double *y_vec = y->vec;
      int i, j, k, nnz, ptr, end;
      double t;
      xassert(x->n == lp->m);
      xassert(y->n == lp->n-lp->m);
      if (ign)
      {  /* y := 0 */
         fvs_clear_vec(y);
      }
      nnz = y->nnz;
      for (k = x->nnz; k >= 1; k--)
      {  i = x_ind[k];
         /* y := y + s * (i-th row of N) * x[i] */
         t = s * x_vec[i];
         ptr = NT_ptr[i];
         end = ptr + NT_len[i];
         for (; ptr < end; ptr++)
         {  j = NT_ind[ptr];
            if (y_vec[j] == 0.0)
               y_ind[++nnz] = j;
            y_vec[j] += NT_val[ptr] * t;
            /* don't forget about numeric cancellation */
            if (y_vec[j] == 0.0)
               y_vec[j] = DBL_MIN;
         }
      }
      y->nnz = nnz;
      fvs_adjust_vec(y, eps);
      return;
}
#endif

/***********************************************************************
*  spx_free_nt - deallocate matrix N in sparse row-wise format
*
*  This routine deallocates the memory used for arrays of the program
*  object nt. */

void spx_free_nt(SPXLP *lp, SPXNT *nt)
{     xassert(lp == lp);
      tfree(nt->ptr);
      tfree(nt->len);
      tfree(nt->ind);
      tfree(nt->val);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxnt.h0000644000175100001710000000646300000000000025123 0ustar00runnerdocker00000000000000/* spxnt.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXNT_H
#define SPXNT_H

#include "spxlp.h"

typedef struct SPXNT SPXNT;

struct SPXNT
{     /* mx(n-m)-matrix N composed of non-basic columns of constraint
       * matrix A, in sparse row-wise format */
      int *ptr; /* int ptr[1+m]; */
      /* ptr[0] is not used;
       * ptr[i], 1 <= i <= m, is starting position of i-th row in
       * arrays ind and val; note that ptr[1] is always 1;
       * these starting positions are set up *once* as if they would
       * correspond to rows of matrix A stored without gaps, i.e.
       * ptr[i+1] - ptr[i] is the number of non-zeros in i-th (i < m)
       * row of matrix A, and (nnz+1) - ptr[m] is the number of
       * non-zero in m-th (last) row of matrix A, where nnz is the
       * total number of non-zeros in matrix A */
      int *len; /* int len[1+m]; */
      /* len[0] is not used;
       * len[i], 1 <= i <= m, is the number of non-zeros in i-th row
       * of current matrix N */
      int *ind; /* int ind[1+nnz]; */
      /* column indices */
      double *val; /* double val[1+nnz]; */
      /* non-zero element values */
};

#define spx_alloc_nt _glp_spx_alloc_nt
void spx_alloc_nt(SPXLP *lp, SPXNT *nt);
/* allocate matrix N in sparse row-wise format */

#define spx_init_nt _glp_spx_init_nt
void spx_init_nt(SPXLP *lp, SPXNT *nt);
/* initialize row pointers for matrix N */

#define spx_nt_add_col _glp_spx_nt_add_col
void spx_nt_add_col(SPXLP *lp, SPXNT *nt, int j, int k);
/* add column N[j] = A[k] */

#define spx_build_nt _glp_spx_build_nt
void spx_build_nt(SPXLP *lp, SPXNT *nt);
/* build matrix N for current basis */

#define spx_nt_del_col _glp_spx_nt_del_col
void spx_nt_del_col(SPXLP *lp, SPXNT *nt, int j, int k);
/* remove column N[j] = A[k] from matrix N */

#define spx_update_nt _glp_spx_update_nt
void spx_update_nt(SPXLP *lp, SPXNT *nt, int p, int q);
/* update matrix N for adjacent basis */

#define spx_nt_prod _glp_spx_nt_prod
void spx_nt_prod(SPXLP *lp, SPXNT *nt, double y[/*1+n-m*/], int ign,
      double s, const double x[/*1+m*/]);
/* compute product y := y + s * N'* x */

#if 1 /* 31/III-2016 */
#define spx_nt_prod_s _glp_spx_nt_prod_s
void spx_nt_prod_s(SPXLP *lp, SPXNT *nt, FVS *y, int ign, double s,
      const FVS *x, double eps);
/* sparse version of spx_nt_prod */
#endif

#define spx_free_nt _glp_spx_free_nt
void spx_free_nt(SPXLP *lp, SPXNT *nt);
/* deallocate matrix N in sparse row-wise format */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxprim.c0000644000175100001710000016577100000000000025454 0ustar00runnerdocker00000000000000/* spxprim.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#if 1 /* 18/VII-2017 */
#define SCALE_Z 1
#endif

#include "env.h"
#include "simplex.h"
#include "spxat.h"
#include "spxnt.h"
#include "spxchuzc.h"
#include "spxchuzr.h"
#include "spxprob.h"

#define CHECK_ACCURACY 0
/* (for debugging) */

struct csa
{     /* common storage area */
      SPXLP *lp;
      /* LP problem data and its (current) basis; this LP has m rows
       * and n columns */
      int dir;
      /* original optimization direction:
       * +1 - minimization
       * -1 - maximization */
#if SCALE_Z
      double fz;
      /* factor used to scale original objective */
#endif
      double *orig_c; /* double orig_c[1+n]; */
      /* copy of original objective coefficients */
      double *orig_l; /* double orig_l[1+n]; */
      /* copy of original lower bounds */
      double *orig_u; /* double orig_u[1+n]; */
      /* copy of original upper bounds */
      SPXAT *at;
      /* mxn-matrix A of constraint coefficients, in sparse row-wise
       * format (NULL if not used) */
      SPXNT *nt;
      /* mx(n-m)-matrix N composed of non-basic columns of constraint
       * matrix A, in sparse row-wise format (NULL if not used) */
      int phase;
      /* search phase:
       * 0 - not determined yet
       * 1 - searching for primal feasible solution
       * 2 - searching for optimal solution */
      double *beta; /* double beta[1+m]; */
      /* beta[i] is a primal value of basic variable xB[i] */
      int beta_st;
      /* status of the vector beta:
       * 0 - undefined
       * 1 - just computed
       * 2 - updated */
      double *d; /* double d[1+n-m]; */
      /* d[j] is a reduced cost of non-basic variable xN[j] */
      int d_st;
      /* status of the vector d:
       * 0 - undefined
       * 1 - just computed
       * 2 - updated */
      SPXSE *se;
      /* projected steepest edge and Devex pricing data block (NULL if
       * not used) */
      int num;
      /* number of eligible non-basic variables */
      int *list; /* int list[1+n-m]; */
      /* list[1], ..., list[num] are indices j of eligible non-basic
       * variables xN[j] */
      int q;
      /* xN[q] is a non-basic variable chosen to enter the basis */
#if 0 /* 11/VI-2017 */
      double *tcol; /* double tcol[1+m]; */
#else
      FVS tcol; /* FVS tcol[1:m]; */
#endif
      /* q-th (pivot) column of the simplex table */
#if 1 /* 23/VI-2017 */
      SPXBP *bp; /* SPXBP bp[1+2*m+1]; */
      /* penalty function break points */
#endif
      int p;
      /* xB[p] is a basic variable chosen to leave the basis;
       * p = 0 means that no basic variable reaches its bound;
       * p < 0 means that non-basic variable xN[q] reaches its opposite
       * bound before any basic variable */
      int p_flag;
      /* if this flag is set, the active bound of xB[p] in the adjacent
       * basis should be set to the upper bound */
#if 0 /* 11/VI-2017 */
      double *trow; /* double trow[1+n-m]; */
#else
      FVS trow; /* FVS trow[1:n-m]; */
#endif
      /* p-th (pivot) row of the simplex table */
#if 0 /* 09/VII-2017 */
      double *work; /* double work[1+m]; */
      /* working array */
#else
      FVS work; /* FVS work[1:m]; */
      /* working vector */
#endif
      int p_stat, d_stat;
      /* primal and dual solution statuses */
      /*--------------------------------------------------------------*/
      /* control parameters (see struct glp_smcp) */
      int msg_lev;
      /* message level */
#if 0 /* 23/VI-2017 */
      int harris;
      /* ratio test technique:
       * 0 - textbook ratio test
       * 1 - Harris' two pass ratio test */
#else
      int r_test;
      /* ratio test technique:
       * GLP_RT_STD  - textbook ratio test
       * GLP_RT_HAR  - Harris' two pass ratio test
       * GLP_RT_FLIP - long-step ratio test (only for phase I) */
#endif
      double tol_bnd, tol_bnd1;
      /* primal feasibility tolerances */
      double tol_dj, tol_dj1;
      /* dual feasibility tolerances */
      double tol_piv;
      /* pivot tolerance */
      int it_lim;
      /* iteration limit */
      int tm_lim;
      /* time limit, milliseconds */
      int out_frq;
#if 0 /* 15/VII-2017 */
      /* display output frequency, iterations */
#else
      /* display output frequency, milliseconds */
#endif
      int out_dly;
      /* display output delay, milliseconds */
      /*--------------------------------------------------------------*/
      /* working parameters */
      double tm_beg;
      /* time value at the beginning of the search */
      int it_beg;
      /* simplex iteration count at the beginning of the search */
      int it_cnt;
      /* simplex iteration count; it increases by one every time the
       * basis changes (including the case when a non-basic variable
       * jumps to its opposite bound) */
      int it_dpy;
      /* simplex iteration count at most recent display output */
#if 1 /* 15/VII-2017 */
      double tm_dpy;
      /* time value at most recent display output */
#endif
      int inv_cnt;
      /* basis factorization count since most recent display output */
#if 1 /* 01/VII-2017 */
      int degen;
      /* count of successive degenerate iterations; this count is used
       * to detect stalling */
#endif
#if 1 /* 23/VI-2017 */
      int ns_cnt, ls_cnt;
      /* normal and long-step iteration counts */
#endif
};

/***********************************************************************
*  set_penalty - set penalty function coefficients
*
*  This routine sets up objective coefficients of the penalty function,
*  which is the sum of primal infeasibilities, as follows:
*
*     if beta[i] < l[k] - eps1, set c[k] = -1,
*
*     if beta[i] > u[k] + eps2, set c[k] = +1,
*
*     otherwise, set c[k] = 0,
*
*  where beta[i] is current value of basic variable xB[i] = x[k], l[k]
*  and u[k] are original bounds of x[k], and
*
*     eps1 = tol + tol1 * |l[k]|,
*
*     eps2 = tol + tol1 * |u[k]|.
*
*  The routine returns the number of non-zero objective coefficients,
*  which is the number of basic variables violating their bounds. Thus,
*  if the value returned is zero, the current basis is primal feasible
*  within the specified tolerances. */

static int set_penalty(struct csa *csa, double tol, double tol1)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *beta = csa->beta;
      int i, k, count = 0;
      double t, eps;
      /* reset objective coefficients */
      for (k = 0; k <= n; k++)
         c[k] = 0.0;
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         /* check lower bound */
         if ((t = l[k]) != -DBL_MAX)
         {  eps = tol + tol1 * (t >= 0.0 ? +t : -t);
            if (beta[i] < t - eps)
            {  /* lower bound is violated */
               c[k] = -1.0, count++;
            }
         }
         /* check upper bound */
         if ((t = u[k]) != +DBL_MAX)
         {  eps = tol + tol1 * (t >= 0.0 ? +t : -t);
            if (beta[i] > t + eps)
            {  /* upper bound is violated */
               c[k] = +1.0, count++;
            }
         }
      }
      return count;
}

/***********************************************************************
*  check_feas - check primal feasibility of basic solution
*
*  This routine checks if the specified values of all basic variables
*  beta = (beta[i]) are within their bounds.
*
*  Let l[k] and u[k] be original bounds of basic variable xB[i] = x[k].
*  The actual bounds of x[k] are determined as follows:
*
*  1) if phase = 1 and c[k] < 0, x[k] violates its lower bound, so its
*     actual bounds are artificial: -inf < x[k] <= l[k];
*
*  2) if phase = 1 and c[k] > 0, x[k] violates its upper bound, so its
*     actual bounds are artificial: u[k] <= x[k] < +inf;
*
*  3) in all other cases (if phase = 1 and c[k] = 0, or if phase = 2)
*     actual bounds are original: l[k] <= x[k] <= u[k].
*
*  The parameters tol and tol1 are bound violation tolerances. The
*  actual bounds l'[k] and u'[k] are considered as non-violated within
*  the specified tolerance if
*
*     l'[k] - eps1 <= beta[i] <= u'[k] + eps2,
*
*  where eps1 = tol + tol1 * |l'[k]|, eps2 = tol + tol1 * |u'[k]|.
*
*  The routine returns one of the following codes:
*
*  0 - solution is feasible (no actual bounds are violated);
*
*  1 - solution is infeasible, however, only artificial bounds are
*      violated (this is possible only if phase = 1);
*
*  2 - solution is infeasible and at least one original bound is
*      violated. */

static int check_feas(struct csa *csa, int phase, double tol, double
      tol1)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *beta = csa->beta;
      int i, k, orig, ret = 0;
      double lk, uk, eps;
      xassert(phase == 1 || phase == 2);
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         /* determine actual bounds of x[k] */
         if (phase == 1 && c[k] < 0.0)
         {  /* -inf < x[k] <= l[k] */
            lk = -DBL_MAX, uk = l[k];
            orig = 0; /* artificial bounds */
         }
         else if (phase == 1 && c[k] > 0.0)
         {  /* u[k] <= x[k] < +inf */
            lk = u[k], uk = +DBL_MAX;
            orig = 0; /* artificial bounds */
         }
         else
         {  /* l[k] <= x[k] <= u[k] */
            lk = l[k], uk = u[k];
            orig = 1; /* original bounds */
         }
         /* check actual lower bound */
         if (lk != -DBL_MAX)
         {  eps = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] < lk - eps)
            {  /* actual lower bound is violated */
               if (orig)
               {  ret = 2;
                  break;
               }
               ret = 1;
            }
         }
         /* check actual upper bound */
         if (uk != +DBL_MAX)
         {  eps = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] > uk + eps)
            {  /* actual upper bound is violated */
               if (orig)
               {  ret = 2;
                  break;
               }
               ret = 1;
            }
         }
      }
      return ret;
}

/***********************************************************************
*  adjust_penalty - adjust penalty function coefficients
*
*  On searching for primal feasible solution it may happen that some
*  basic variable xB[i] = x[k] has non-zero objective coefficient c[k]
*  indicating that xB[i] violates its lower (if c[k] < 0) or upper (if
*  c[k] > 0) original bound, but due to primal degenarcy the violation
*  is close to zero.
*
*  This routine identifies such basic variables and sets objective
*  coefficients at these variables to zero that allows avoiding zero-
*  step simplex iterations.
*
*  The parameters tol and tol1 are bound violation tolerances. The
*  original bounds l[k] and u[k] are considered as non-violated within
*  the specified tolerance if
*
*     l[k] - eps1 <= beta[i] <= u[k] + eps2,
*
*  where beta[i] is value of basic variable xB[i] = x[k] in the current
*  basis, eps1 = tol + tol1 * |l[k]|, eps2 = tol + tol1 * |u[k]|.
*
*  The routine returns the number of objective coefficients which were
*  set to zero. */

#if 0
static int adjust_penalty(struct csa *csa, double tol, double tol1)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *beta = csa->beta;
      int i, k, count = 0;
      double t, eps;
      xassert(csa->phase == 1);
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         if (c[k] < 0.0)
         {  /* x[k] violates its original lower bound l[k] */
            xassert((t = l[k]) != -DBL_MAX);
            eps = tol + tol1 * (t >= 0.0 ? +t : -t);
            if (beta[i] >= t - eps)
            {  /* however, violation is close to zero */
               c[k] = 0.0, count++;
            }
         }
         else if (c[k] > 0.0)
         {  /* x[k] violates its original upper bound u[k] */
            xassert((t = u[k]) != +DBL_MAX);
            eps = tol + tol1 * (t >= 0.0 ? +t : -t);
            if (beta[i] <= t + eps)
            {  /* however, violation is close to zero */
               c[k] = 0.0, count++;
            }
         }
      }
      return count;
}
#else
static int adjust_penalty(struct csa *csa, int num, const int
      ind[/*1+num*/], double tol, double tol1)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *beta = csa->beta;
      int i, k, t, cnt = 0;
      double lk, uk, eps;
      xassert(csa->phase == 1);
      /* walk thru the specified list of basic variables */
      for (t = 1; t <= num; t++)
      {  i = ind[t];
         xassert(1 <= i && i <= m);
         k = head[i]; /* x[k] = xB[i] */
         if (c[k] < 0.0)
         {  /* x[k] violates its original lower bound */
            lk = l[k];
            xassert(lk != -DBL_MAX);
            eps = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] >= lk - eps)
            {  /* however, violation is close to zero */
               c[k] = 0.0, cnt++;
            }
         }
         else if (c[k] > 0.0)
         {  /* x[k] violates its original upper bound */
            uk = u[k];
            xassert(uk != +DBL_MAX);
            eps = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] <= uk + eps)
            {  /* however, violation is close to zero */
               c[k] = 0.0, cnt++;
            }
         }
      }
      return cnt;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_vec - compute maximal relative error between two vectors
*
*  This routine computes and returns maximal relative error between
*  n-vectors x and y:
*
*     err_max = max |x[i] - y[i]| / (1 + |x[i]|).
*
*  NOTE: This routine is intended only for debugginig purposes. */

static double err_in_vec(int n, const double x[], const double y[])
{     int i;
      double err, err_max;
      err_max = 0.0;
      for (i = 1; i <= n; i++)
      {  err = fabs(x[i] - y[i]) / (1.0 + fabs(x[i]));
         if (err_max < err)
            err_max = err;
      }
      return err_max;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_beta - compute maximal relative error in vector beta
*
*  This routine computes and returns maximal relative error in vector
*  of values of basic variables beta = (beta[i]).
*
*  NOTE: This routine is intended only for debugginig purposes. */

static double err_in_beta(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double err, *beta;
      beta = talloc(1+m, double);
      spx_eval_beta(lp, beta);
      err = err_in_vec(m, beta, csa->beta);
      tfree(beta);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_d - compute maximal relative error in vector d
*
*  This routine computes and returns maximal relative error in vector
*  of reduced costs of non-basic variables d = (d[j]).
*
*  NOTE: This routine is intended only for debugginig purposes. */

static double err_in_d(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      int j;
      double err, *pi, *d;
      pi = talloc(1+m, double);
      d = talloc(1+n-m, double);
      spx_eval_pi(lp, pi);
      for (j = 1; j <= n-m; j++)
         d[j] = spx_eval_dj(lp, pi, j);
      err = err_in_vec(n-m, d, csa->d);
      tfree(pi);
      tfree(d);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_gamma - compute maximal relative error in vector gamma
*
*  This routine computes and returns maximal relative error in vector
*  of projected steepest edge weights gamma = (gamma[j]).
*
*  NOTE: This routine is intended only for debugginig purposes. */

static double err_in_gamma(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      SPXSE *se = csa->se;
      int j;
      double err, *gamma;
      xassert(se != NULL);
      gamma = talloc(1+n-m, double);
      for (j = 1; j <= n-m; j++)
         gamma[j] = spx_eval_gamma_j(lp, se, j);
      err = err_in_vec(n-m, gamma, se->gamma);
      tfree(gamma);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  check_accuracy - check accuracy of basic solution components
*
*  This routine checks accuracy of current basic solution components.
*
*  NOTE: This routine is intended only for debugginig purposes. */

static void check_accuracy(struct csa *csa)
{     double e_beta, e_d, e_gamma;
      e_beta = err_in_beta(csa);
      e_d = err_in_d(csa);
      if (csa->se == NULL)
         e_gamma = 0.;
      else
         e_gamma = err_in_gamma(csa);
      xprintf("e_beta = %10.3e; e_d = %10.3e; e_gamma = %10.3e\n",
         e_beta, e_d, e_gamma);
      xassert(e_beta <= 1e-5 && e_d <= 1e-5 && e_gamma <= 1e-3);
      return;
}
#endif

/***********************************************************************
*  choose_pivot - choose xN[q] and xB[p]
*
*  Given the list of eligible non-basic variables this routine first
*  chooses non-basic variable xN[q]. This choice is always possible,
*  because the list is assumed to be non-empty. Then the routine
*  computes q-th column T[*,q] of the simplex table T[i,j] and chooses
*  basic variable xB[p]. If the pivot T[p,q] is small in magnitude,
*  the routine attempts to choose another xN[q] and xB[p] in order to
*  avoid badly conditioned adjacent bases. */

#if 1 /* 17/III-2016 */
#define MIN_RATIO 0.0001

static int choose_pivot(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *beta = csa->beta;
      double *d = csa->d;
      SPXSE *se = csa->se;
      int *list = csa->list;
#if 0 /* 09/VII-2017 */
      double *tcol = csa->work;
#else
      double *tcol = csa->work.vec;
#endif
      double tol_piv = csa->tol_piv;
      int try, nnn, /*i,*/ p, p_flag, q, t;
      double big, /*temp,*/ best_ratio;
#if 1 /* 23/VI-2017 */
      double *c = lp->c;
      int *head = lp->head;
      SPXBP *bp = csa->bp;
      int nbp, t_best, ret, k;
      double dz_best;
#endif
      xassert(csa->beta_st);
      xassert(csa->d_st);
more: /* initial number of eligible non-basic variables */
      nnn = csa->num;
      /* nothing has been chosen so far */
      csa->q = 0;
      best_ratio = 0.0;
#if 0 /* 23/VI-2017 */
      try = 0;
#else
      try = ret = 0;
#endif
try:  /* choose non-basic variable xN[q] */
      xassert(nnn > 0);
      try++;
      if (se == NULL)
      {  /* Dantzig's rule */
         q = spx_chuzc_std(lp, d, nnn, list);
      }
      else
      {  /* projected steepest edge */
         q = spx_chuzc_pse(lp, se, d, nnn, list);
      }
      xassert(1 <= q && q <= n-m);
      /* compute q-th column of the simplex table */
      spx_eval_tcol(lp, q, tcol);
#if 0
      /* big := max(1, |tcol[1]|, ..., |tcol[m]|) */
      big = 1.0;
      for (i = 1; i <= m; i++)
      {  temp = tcol[i];
         if (temp < 0.0)
            temp = - temp;
         if (big < temp)
            big = temp;
      }
#else
      /* this still puzzles me */
      big = 1.0;
#endif
      /* choose basic variable xB[p] */
#if 1 /* 23/VI-2017 */
      if (csa->phase == 1 && csa->r_test == GLP_RT_FLIP && try <= 2)
      {  /* long-step ratio test */
         int t, num, num1;
         double slope, teta_lim;
         /* determine penalty function break points */
         nbp = spx_ls_eval_bp(lp, beta, q, d[q], tcol, tol_piv, bp);
         if (nbp < 2)
            goto skip;
         /* set initial slope */
         slope = - fabs(d[q]);
         /* estimate initial teta_lim */
         teta_lim = DBL_MAX;
         for (t = 1; t <= nbp; t++)
         {  if (teta_lim > bp[t].teta)
               teta_lim = bp[t].teta;
         }
         xassert(teta_lim >= 0.0);
         if (teta_lim < 1e-3)
            teta_lim = 1e-3;
         /* nothing has been chosen so far */
         t_best = 0, dz_best = 0.0, num = 0;
         /* choose appropriate break point */
         while (num < nbp)
         {  /* select and process a new portion of break points */
            num1 = spx_ls_select_bp(lp, tcol, nbp, bp, num, &slope,
               teta_lim);
            for (t = num+1; t <= num1; t++)
            {  int i = (bp[t].i >= 0 ? bp[t].i : -bp[t].i);
               xassert(0 <= i && i <= m);
               if (i == 0 || fabs(tcol[i]) / big >= MIN_RATIO)
               {  if (dz_best > bp[t].dz)
                     t_best = t, dz_best = bp[t].dz;
               }
#if 0
               if (i == 0)
               {  /* do not consider further break points beyond this
                   * point, where xN[q] reaches its opposite bound;
                   * in principle (see spx_ls_eval_bp), this break
                   * point should be the last one, however, due to
                   * round-off errors there may be other break points
                   * with the same teta beyond this one */
                  slope = +1.0;
               }
#endif
            }
            if (slope > 0.0)
            {  /* penalty function starts increasing */
               break;
            }
            /* penalty function continues decreasing */
            num = num1;
            teta_lim += teta_lim;
         }
         if (dz_best == 0.0)
            goto skip;
         /* the choice has been made */
         xassert(1 <= t_best && t_best <= num1);
         if (t_best == 1)
         {  /* the very first break point was chosen; it is reasonable
             * to use the short-step ratio test */
            goto skip;
         }
         csa->q = q;
         memcpy(&csa->tcol.vec[1], &tcol[1], m * sizeof(double));
         fvs_gather_vec(&csa->tcol, DBL_EPSILON);
         if (bp[t_best].i == 0)
         {  /* xN[q] goes to its opposite bound */
            csa->p = -1;
            csa->p_flag = 0;
            best_ratio = 1.0;
         }
         else if (bp[t_best].i > 0)
         {  /* xB[p] leaves the basis and goes to its lower bound */
            csa->p = + bp[t_best].i;
            xassert(1 <= csa->p && csa->p <= m);
            csa->p_flag = 0;
            best_ratio = fabs(tcol[csa->p]) / big;
         }
         else
         {  /* xB[p] leaves the basis and goes to its upper bound */
            csa->p = - bp[t_best].i;
            xassert(1 <= csa->p && csa->p <= m);
            csa->p_flag = 1;
            best_ratio = fabs(tcol[csa->p]) / big;
         }
#if 0
         xprintf("num1 = %d; t_best = %d; dz = %g\n", num1, t_best,
            bp[t_best].dz);
#endif
         ret = 1;
         goto done;
skip:    ;
      }
#endif
#if 0 /* 23/VI-2017 */
      if (!csa->harris)
#else
      if (csa->r_test == GLP_RT_STD)
#endif
      {  /* textbook ratio test */
         p = spx_chuzr_std(lp, csa->phase, beta, q,
            d[q] < 0.0 ? +1. : -1., tcol, &p_flag, tol_piv,
            .30 * csa->tol_bnd, .30 * csa->tol_bnd1);
      }
      else
      {  /* Harris' two-pass ratio test */
         p = spx_chuzr_harris(lp, csa->phase, beta, q,
            d[q] < 0.0 ? +1. : -1., tcol, &p_flag , tol_piv,
            .50 * csa->tol_bnd, .50 * csa->tol_bnd1);
      }
      if (p <= 0)
      {  /* primal unboundedness or special case */
         csa->q = q;
#if 0 /* 11/VI-2017 */
         memcpy(&csa->tcol[1], &tcol[1], m * sizeof(double));
#else
         memcpy(&csa->tcol.vec[1], &tcol[1], m * sizeof(double));
         fvs_gather_vec(&csa->tcol, DBL_EPSILON);
#endif
         csa->p = p;
         csa->p_flag = p_flag;
         best_ratio = 1.0;
         goto done;
      }
      /* either keep previous choice or accept new choice depending on
       * which one is better */
      if (best_ratio < fabs(tcol[p]) / big)
      {  csa->q = q;
#if 0 /* 11/VI-2017 */
         memcpy(&csa->tcol[1], &tcol[1], m * sizeof(double));
#else
         memcpy(&csa->tcol.vec[1], &tcol[1], m * sizeof(double));
         fvs_gather_vec(&csa->tcol, DBL_EPSILON);
#endif
         csa->p = p;
         csa->p_flag = p_flag;
         best_ratio = fabs(tcol[p]) / big;
      }
      /* check if the current choice is acceptable */
      if (best_ratio >= MIN_RATIO || nnn == 1 || try == 5)
         goto done;
      /* try to choose other xN[q] and xB[p] */
      /* find xN[q] in the list */
      for (t = 1; t <= nnn; t++)
         if (list[t] == q) break;
      xassert(t <= nnn);
      /* move xN[q] to the end of the list */
      list[t] = list[nnn], list[nnn] = q;
      /* and exclude it from consideration */
      nnn--;
      /* repeat the choice */
      goto try;
done: /* the choice has been made */
#if 1 /* FIXME: currently just to avoid badly conditioned basis */
      if (best_ratio < .001 * MIN_RATIO)
      {  /* looks like this helps */
         if (bfd_get_count(lp->bfd) > 0)
            return -1;
         /* didn't help; last chance to improve the choice */
         if (tol_piv == csa->tol_piv)
         {  tol_piv *= 1000.;
            goto more;
         }
      }
#endif
#if 0 /* 23/VI-2017 */
      return 0;
#else /* FIXME */
      if (ret)
      {  /* invalidate dual basic solution components */
         csa->d_st = 0;
         /* change penalty function coefficients at basic variables for
          * all break points preceding the chosen one */
         for (t = 1; t < t_best; t++)
         {  int i = (bp[t].i >= 0 ? bp[t].i : -bp[t].i);
            xassert(0 <= i && i <= m);
            if (i == 0)
            {  /* xN[q] crosses its opposite bound */
               xassert(1 <= csa->q && csa->q <= n-m);
               k = head[m+csa->q];
            }
            else
            {  /* xB[i] crosses its (lower or upper) bound */
               k = head[i]; /* x[k] = xB[i] */
            }
            c[k] += bp[t].dc;
            xassert(c[k] == 0.0 || c[k] == +1.0 || c[k] == -1.0);
         }
      }
      return ret;
#endif
}
#endif

/***********************************************************************
*  play_bounds - play bounds of primal variables
*
*  This routine is called after the primal values of basic variables
*  beta[i] were updated and the basis was changed to the adjacent one.
*
*  It is assumed that before updating all the primal values beta[i]
*  were strongly feasible, so in the adjacent basis beta[i] remain
*  feasible within a tolerance, i.e. if some beta[i] violates its lower
*  or upper bound, the violation is insignificant.
*
*  If some beta[i] violates its lower or upper bound, this routine
*  changes (perturbs) the bound to remove such violation, i.e. to make
*  all beta[i] strongly feasible. Otherwise, if beta[i] has a feasible
*  value, this routine attempts to reduce (or remove) perturbation of
*  corresponding lower/upper bound keeping strong feasibility. */

/* FIXME: what to do if l[k] = u[k]? */

/* FIXME: reduce/remove perturbation if x[k] becomes non-basic? */

static void play_bounds(struct csa *csa, int all)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *orig_l = csa->orig_l;
      double *orig_u = csa->orig_u;
      double *beta = csa->beta;
#if 0 /* 11/VI-2017 */
      const double *tcol = csa->tcol; /* was used to update beta */
#else
      const double *tcol = csa->tcol.vec;
#endif
      int i, k;
      xassert(csa->phase == 1 || csa->phase == 2);
      /* primal values beta = (beta[i]) should be valid */
      xassert(csa->beta_st);
      /* walk thru the list of basic variables xB = (xB[i]) */
      for (i = 1; i <= m; i++)
      {  if (all || tcol[i] != 0.0)
         {  /* beta[i] has changed in the adjacent basis */
            k = head[i]; /* x[k] = xB[i] */
            if (csa->phase == 1 && c[k] < 0.0)
            {  /* -inf < xB[i] <= lB[i] (artificial bounds) */
               if (beta[i] < l[k] - 1e-9)
                  continue;
               /* restore actual bounds */
               c[k] = 0.0;
               csa->d_st = 0; /* since c[k] = cB[i] has changed */
            }
            if (csa->phase == 1 && c[k] > 0.0)
            {  /* uB[i] <= xB[i] < +inf (artificial bounds) */
               if (beta[i] > u[k] + 1e-9)
                  continue;
               /* restore actual bounds */
               c[k] = 0.0;
               csa->d_st = 0; /* since c[k] = cB[i] has changed */
            }
            /* lB[i] <= xB[i] <= uB[i] */
            if (csa->phase == 1)
               xassert(c[k] == 0.0);
            if (l[k] != -DBL_MAX)
            {  /* xB[i] has lower bound */
               if (beta[i] < l[k])
               {  /* strong feasibility means xB[i] >= lB[i] */
#if 0 /* 11/VI-2017 */
                  l[k] = beta[i];
#else
                  l[k] = beta[i] - 1e-9;
#endif
               }
               else if (l[k] < orig_l[k])
               {  /* remove/reduce perturbation of lB[i] */
                  if (beta[i] >= orig_l[k])
                     l[k] = orig_l[k];
                  else
                     l[k] = beta[i];
               }
            }
            if (u[k] != +DBL_MAX)
            {  /* xB[i] has upper bound */
               if (beta[i] > u[k])
               {  /* strong feasibility means xB[i] <= uB[i] */
#if 0 /* 11/VI-2017 */
                  u[k] = beta[i];
#else
                  u[k] = beta[i] + 1e-9;
#endif
               }
               else if (u[k] > orig_u[k])
               {  /* remove/reduce perturbation of uB[i] */
                  if (beta[i] <= orig_u[k])
                     u[k] = orig_u[k];
                  else
                     u[k] = beta[i];
               }
            }
         }
      }
      return;
}

static void remove_perturb(struct csa *csa)
{     /* remove perturbation */
      SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      double *orig_l = csa->orig_l;
      double *orig_u = csa->orig_u;
      int j, k;
      /* restore original bounds of variables */
      memcpy(l, orig_l, (1+n) * sizeof(double));
      memcpy(u, orig_u, (1+n) * sizeof(double));
      /* adjust flags of fixed non-basic variables, because in the
       * perturbed problem such variables might be changed to double-
       * bounded type */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == u[k])
            flag[j] = 0;
      }
      /* removing perturbation changes primal solution components */
      csa->phase = csa->beta_st = 0;
#if 1
      if (csa->msg_lev >= GLP_MSG_ALL)
         xprintf("Removing LP perturbation [%d]...\n",
            csa->it_cnt);
#endif
      return;
}

/***********************************************************************
*  sum_infeas - compute sum of primal infeasibilities
*
*  This routine compute the sum of primal infeasibilities, which is the
*  current penalty function value. */

static double sum_infeas(SPXLP *lp, const double beta[/*1+m*/])
{     int m = lp->m;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, k;
      double sum = 0.0;
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         if (l[k] != -DBL_MAX && beta[i] < l[k])
            sum += l[k] - beta[i];
         if (u[k] != +DBL_MAX && beta[i] > u[k])
            sum += beta[i] - u[k];
      }
      return sum;
}

/***********************************************************************
*  display - display search progress
*
*  This routine displays some information about the search progress
*  that includes:
*
*  search phase;
*
*  number of simplex iterations performed by the solver;
*
*  original objective value;
*
*  sum of (scaled) primal infeasibilities;
*
*  number of infeasibilities (phase I) or non-optimalities (phase II);
*
*  number of basic factorizations since last display output. */

static void display(struct csa *csa, int spec)
{     int nnn, k;
      double obj, sum, *save, *save1;
#if 1 /* 15/VII-2017 */
      double tm_cur;
#endif
      /* check if the display output should be skipped */
      if (csa->msg_lev < GLP_MSG_ON) goto skip;
#if 1 /* 15/VII-2017 */
      tm_cur = xtime();
#endif
      if (csa->out_dly > 0 &&
#if 0 /* 15/VII-2017 */
         1000.0 * xdifftime(xtime(), csa->tm_beg) < csa->out_dly)
#else
         1000.0 * xdifftime(tm_cur, csa->tm_beg) < csa->out_dly)
#endif
         goto skip;
      if (csa->it_cnt == csa->it_dpy) goto skip;
#if 0 /* 15/VII-2017 */
      if (!spec && csa->it_cnt % csa->out_frq != 0) goto skip;
#else
      if (!spec &&
         1000.0 * xdifftime(tm_cur, csa->tm_dpy) < csa->out_frq)
         goto skip;
#endif
      /* compute original objective value */
      save = csa->lp->c;
      csa->lp->c = csa->orig_c;
      obj = csa->dir * spx_eval_obj(csa->lp, csa->beta);
      csa->lp->c = save;
#if SCALE_Z
      obj *= csa->fz;
#endif
      /* compute sum of (scaled) primal infeasibilities */
#if 1 /* 01/VII-2017 */
      save = csa->lp->l;
      save1 = csa->lp->u;
      csa->lp->l = csa->orig_l;
      csa->lp->u = csa->orig_u;
#endif
      sum = sum_infeas(csa->lp, csa->beta);
#if 1 /* 01/VII-2017 */
      csa->lp->l = save;
      csa->lp->u = save1;
#endif
      /* compute number of infeasibilities/non-optimalities */
      switch (csa->phase)
      {  case 1:
            nnn = 0;
            for (k = 1; k <= csa->lp->n; k++)
               if (csa->lp->c[k] != 0.0) nnn++;
            break;
         case 2:
            xassert(csa->d_st);
            nnn = spx_chuzc_sel(csa->lp, csa->d, csa->tol_dj,
               csa->tol_dj1, NULL);
            break;
         default:
            xassert(csa != csa);
      }
      /* display search progress */
      xprintf("%c%6d: obj = %17.9e inf = %11.3e (%d)",
         csa->phase == 2 ? '*' : ' ', csa->it_cnt, obj, sum, nnn);
      if (csa->inv_cnt)
      {  /* number of basis factorizations performed */
         xprintf(" %d", csa->inv_cnt);
         csa->inv_cnt = 0;
      }
#if 1 /* 23/VI-2017 */
      if (csa->phase == 1 && csa->r_test == GLP_RT_FLIP)
      {  /*xprintf("   %d,%d", csa->ns_cnt, csa->ls_cnt);*/
         if (csa->ns_cnt + csa->ls_cnt)
            xprintf(" %d%%",
               (100 * csa->ls_cnt) / (csa->ns_cnt + csa->ls_cnt));
         csa->ns_cnt = csa->ls_cnt = 0;
      }
#endif
      xprintf("\n");
      csa->it_dpy = csa->it_cnt;
#if 1 /* 15/VII-2017 */
      csa->tm_dpy = tm_cur;
#endif
skip: return;
}

/***********************************************************************
*  spx_primal - driver to the primal simplex method
*
*  This routine is a driver to the two-phase primal simplex method.
*
*  On exit this routine returns one of the following codes:
*
*  0  LP instance has been successfully solved.
*
*  GLP_EITLIM
*     Iteration limit has been exhausted.
*
*  GLP_ETMLIM
*     Time limit has been exhausted.
*
*  GLP_EFAIL
*     The solver failed to solve LP instance. */

static int primal_simplex(struct csa *csa)
{     /* primal simplex method main logic routine */
      SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      int *head = lp->head;
      SPXAT *at = csa->at;
      SPXNT *nt = csa->nt;
      double *beta = csa->beta;
      double *d = csa->d;
      SPXSE *se = csa->se;
      int *list = csa->list;
#if 0 /* 11/VI-2017 */
      double *tcol = csa->tcol;
      double *trow = csa->trow;
#endif
#if 0 /* 09/VII-2017 */
      double *pi = csa->work;
      double *rho = csa->work;
#else
      double *pi = csa->work.vec;
      double *rho = csa->work.vec;
#endif
      int msg_lev = csa->msg_lev;
      double tol_bnd = csa->tol_bnd;
      double tol_bnd1 = csa->tol_bnd1;
      double tol_dj = csa->tol_dj;
      double tol_dj1 = csa->tol_dj1;
      int perturb = -1;
      /* -1 = perturbation is not used, but enabled
       *  0 = perturbation is not used and disabled
       * +1 = perturbation is being used */
      int j, refct, ret;
loop: /* main loop starts here */
      /* compute factorization of the basis matrix */
      if (!lp->valid)
      {  double cond;
         ret = spx_factorize(lp);
         csa->inv_cnt++;
         if (ret != 0)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Error: unable to factorize the basis matrix (%d"
                  ")\n", ret);
            csa->p_stat = csa->d_stat = GLP_UNDEF;
            ret = GLP_EFAIL;
            goto fini;
         }
         /* check condition of the basis matrix */
         cond = bfd_condest(lp->bfd);
         if (cond > 1.0 / DBL_EPSILON)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Error: basis matrix is singular to working prec"
                  "ision (cond = %.3g)\n", cond);
            csa->p_stat = csa->d_stat = GLP_UNDEF;
            ret = GLP_EFAIL;
            goto fini;
         }
         if (cond > 0.001 / DBL_EPSILON)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Warning: basis matrix is ill-conditioned (cond "
                  "= %.3g)\n", cond);
         }
         /* invalidate basic solution components */
         csa->beta_st = csa->d_st = 0;
      }
      /* compute values of basic variables beta = (beta[i]) */
      if (!csa->beta_st)
      {  spx_eval_beta(lp, beta);
         csa->beta_st = 1; /* just computed */
         /* determine the search phase, if not determined yet */
         if (!csa->phase)
         {  if (set_penalty(csa, 0.97 * tol_bnd, 0.97 * tol_bnd1))
            {  /* current basic solution is primal infeasible */
               /* start to minimize the sum of infeasibilities */
               csa->phase = 1;
            }
            else
            {  /* current basic solution is primal feasible */
               /* start to minimize the original objective function */
               csa->phase = 2;
               memcpy(c, csa->orig_c, (1+n) * sizeof(double));
            }
            /* working objective coefficients have been changed, so
             * invalidate reduced costs */
            csa->d_st = 0;
         }
         /* make sure that the current basic solution remains primal
          * feasible (or pseudo-feasible on phase I) */
         if (perturb <= 0)
         {  if (check_feas(csa, csa->phase, tol_bnd, tol_bnd1))
            {  /* excessive bound violations due to round-off errors */
#if 1 /* 01/VII-2017 */
               if (perturb < 0)
               {  if (msg_lev >= GLP_MSG_ALL)
                     xprintf("Perturbing LP to avoid instability [%d].."
                        ".\n", csa->it_cnt);
                  perturb = 1;
                  goto loop;
               }
#endif
               if (msg_lev >= GLP_MSG_ERR)
                  xprintf("Warning: numerical instability (primal simpl"
                     "ex, phase %s)\n", csa->phase == 1 ? "I" : "II");
               /* restart the search */
               lp->valid = 0;
               csa->phase = 0;
               goto loop;
            }
            if (csa->phase == 1)
            {  int i, cnt;
               for (i = 1; i <= m; i++)
                  csa->tcol.ind[i] = i;
               cnt = adjust_penalty(csa, m, csa->tcol.ind,
                  0.99 * tol_bnd, 0.99 * tol_bnd1);
               if (cnt)
               {  /*xprintf("*** cnt = %d\n", cnt);*/
                  csa->d_st = 0;
               }
            }
         }
         else
         {  /* FIXME */
            play_bounds(csa, 1);
         }
      }
      /* at this point the search phase is determined */
      xassert(csa->phase == 1 || csa->phase == 2);
      /* compute reduced costs of non-basic variables d = (d[j]) */
      if (!csa->d_st)
      {  spx_eval_pi(lp, pi);
         for (j = 1; j <= n-m; j++)
            d[j] = spx_eval_dj(lp, pi, j);
         csa->d_st = 1; /* just computed */
      }
      /* reset the reference space, if necessary */
      if (se != NULL && !se->valid)
         spx_reset_refsp(lp, se), refct = 1000;
      /* at this point the basis factorization and all basic solution
       * components are valid */
      xassert(lp->valid && csa->beta_st && csa->d_st);
#if CHECK_ACCURACY
      /* check accuracy of current basic solution components (only for
       * debugging) */
      check_accuracy(csa);
#endif
      /* check if the iteration limit has been exhausted */
      if (csa->it_cnt - csa->it_beg >= csa->it_lim)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         if (msg_lev >= GLP_MSG_ALL)
            xprintf("ITERATION LIMIT EXCEEDED; SEARCH TERMINATED\n");
         csa->p_stat = (csa->phase == 2 ? GLP_FEAS : GLP_INFEAS);
         csa->d_stat = GLP_UNDEF; /* will be set below */
         ret = GLP_EITLIM;
         goto fini;
      }
      /* check if the time limit has been exhausted */
      if (1000.0 * xdifftime(xtime(), csa->tm_beg) >= csa->tm_lim)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         if (msg_lev >= GLP_MSG_ALL)
            xprintf("TIME LIMIT EXCEEDED; SEARCH TERMINATED\n");
         csa->p_stat = (csa->phase == 2 ? GLP_FEAS : GLP_INFEAS);
         csa->d_stat = GLP_UNDEF; /* will be set below */
         ret = GLP_ETMLIM;
         goto fini;
      }
      /* display the search progress */
      display(csa, 0);
      /* select eligible non-basic variables */
      switch (csa->phase)
      {  case 1:
            csa->num = spx_chuzc_sel(lp, d, 1e-8, 0.0, list);
            break;
         case 2:
            csa->num = spx_chuzc_sel(lp, d, tol_dj, tol_dj1, list);
            break;
         default:
            xassert(csa != csa);
      }
      /* check for optimality */
      if (csa->num == 0)
      {  if (perturb > 0 && csa->phase == 2)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         /* current basis is optimal */
         display(csa, 1);
         switch (csa->phase)
         {  case 1:
               /* check for primal feasibility */
               if (!check_feas(csa, 2, tol_bnd, tol_bnd1))
               {  /* feasible solution found; switch to phase II */
                  memcpy(c, csa->orig_c, (1+n) * sizeof(double));
                  csa->phase = 2;
                  csa->d_st = 0;
                  goto loop;
               }
               /* no feasible solution exists */
#if 1 /* 09/VII-2017 */
               /* FIXME: remove perturbation */
#endif
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("LP HAS NO PRIMAL FEASIBLE SOLUTION\n");
               csa->p_stat = GLP_NOFEAS;
               csa->d_stat = GLP_UNDEF; /* will be set below */
               ret = 0;
               goto fini;
            case 2:
               /* optimal solution found */
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("OPTIMAL LP SOLUTION FOUND\n");
               csa->p_stat = csa->d_stat = GLP_FEAS;
               ret = 0;
               goto fini;
            default:
               xassert(csa != csa);
         }
      }
      /* choose xN[q] and xB[p] */
#if 0 /* 23/VI-2017 */
#if 0 /* 17/III-2016 */
      choose_pivot(csa);
#else
      if (choose_pivot(csa) < 0)
      {  lp->valid = 0;
         goto loop;
      }
#endif
#else
      ret = choose_pivot(csa);
      if (ret < 0)
      {  lp->valid = 0;
         goto loop;
      }
      if (ret == 0)
         csa->ns_cnt++;
      else
         csa->ls_cnt++;
#endif
      /* check for unboundedness */
      if (csa->p == 0)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         switch (csa->phase)
         {  case 1:
               /* this should never happen */
               if (msg_lev >= GLP_MSG_ERR)
                  xprintf("Error: primal simplex failed\n");
               csa->p_stat = csa->d_stat = GLP_UNDEF;
               ret = GLP_EFAIL;
               goto fini;
            case 2:
               /* primal unboundedness detected */
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("LP HAS UNBOUNDED PRIMAL SOLUTION\n");
               csa->p_stat = GLP_FEAS;
               csa->d_stat = GLP_NOFEAS;
               ret = 0;
               goto fini;
            default:
               xassert(csa != csa);
         }
      }
#if 1 /* 01/VII-2017 */
      /* check for stalling */
      if (csa->p > 0)
      {  int k;
         xassert(1 <= csa->p && csa->p <= m);
         k = head[csa->p]; /* x[k] = xB[p] */
         if (lp->l[k] != lp->u[k])
         {  if (csa->p_flag)
            {  /* xB[p] goes to its upper bound */
               xassert(lp->u[k] != +DBL_MAX);
               if (fabs(beta[csa->p] - lp->u[k]) >= 1e-6)
               {  csa->degen = 0;
                  goto skip1;
               }
            }
            else if (lp->l[k] == -DBL_MAX)
            {  /* unusual case */
               goto skip1;
            }
            else
            {  /* xB[p] goes to its lower bound */
               xassert(lp->l[k] != -DBL_MAX);
               if (fabs(beta[csa->p] - lp->l[k]) >= 1e-6)
               {  csa->degen = 0;
                  goto skip1;
               }
            }
            /* degenerate iteration has been detected */
            csa->degen++;
            if (perturb < 0 && csa->degen >= 200)
            {  if (msg_lev >= GLP_MSG_ALL)
                  xprintf("Perturbing LP to avoid stalling [%d]...\n",
                     csa->it_cnt);
               perturb = 1;
            }
skip1:      ;
         }
      }
#endif
      /* update values of basic variables for adjacent basis */
#if 0 /* 11/VI-2017 */
      spx_update_beta(lp, beta, csa->p, csa->p_flag, csa->q, tcol);
#else
      spx_update_beta_s(lp, beta, csa->p, csa->p_flag, csa->q,
         &csa->tcol);
#endif
      csa->beta_st = 2;
      /* p < 0 means that xN[q] jumps to its opposite bound */
      if (csa->p < 0)
         goto skip;
      /* xN[q] enters and xB[p] leaves the basis */
      /* compute p-th row of inv(B) */
      spx_eval_rho(lp, csa->p, rho);
      /* compute p-th (pivot) row of the simplex table */
#if 0 /* 11/VI-2017 */
      if (at != NULL)
         spx_eval_trow1(lp, at, rho, trow);
      else
         spx_nt_prod(lp, nt, trow, 1, -1.0, rho);
#else
      if (at != NULL)
         spx_eval_trow1(lp, at, rho, csa->trow.vec);
      else
         spx_nt_prod(lp, nt, csa->trow.vec, 1, -1.0, rho);
      fvs_gather_vec(&csa->trow, DBL_EPSILON);
#endif
      /* FIXME: tcol[p] and trow[q] should be close to each other */
#if 0 /* 26/V-2017 by cmatraki */
      xassert(trow[csa->q] != 0.0);
#else
      if (csa->trow.vec[csa->q] == 0.0)
      {  if (msg_lev >= GLP_MSG_ERR)
            xprintf("Error: trow[q] = 0.0\n");
         csa->p_stat = csa->d_stat = GLP_UNDEF;
         ret = GLP_EFAIL;
         goto fini;
      }
#endif
      /* update reduced costs of non-basic variables for adjacent
       * basis */
#if 1 /* 23/VI-2017 */
      /* dual solution may be invalidated due to long step */
      if (csa->d_st)
#endif
#if 0 /* 11/VI-2017 */
      if (spx_update_d(lp, d, csa->p, csa->q, trow, tcol) <= 1e-9)
#else
      if (spx_update_d_s(lp, d, csa->p, csa->q, &csa->trow, &csa->tcol)
         <= 1e-9)
#endif
      {  /* successful updating */
         csa->d_st = 2;
         if (csa->phase == 1)
         {  /* adjust reduced cost of xN[q] in adjacent basis, since
             * its penalty coefficient changes (see below) */
            d[csa->q] -= c[head[csa->p]];
         }
      }
      else
      {  /* new reduced costs are inaccurate */
         csa->d_st = 0;
      }
      if (csa->phase == 1)
      {  /* xB[p] leaves the basis replacing xN[q], so set its penalty
          * coefficient to zero */
         c[head[csa->p]] = 0.0;
      }
      /* update steepest edge weights for adjacent basis, if used */
      if (se != NULL)
      {  if (refct > 0)
#if 0 /* 11/VI-2017 */
         {  if (spx_update_gamma(lp, se, csa->p, csa->q, trow, tcol)
               <= 1e-3)
#else /* FIXME: spx_update_gamma_s */
         {  if (spx_update_gamma(lp, se, csa->p, csa->q, csa->trow.vec,
               csa->tcol.vec) <= 1e-3)
#endif
            {  /* successful updating */
               refct--;
            }
            else
            {  /* new weights are inaccurate; reset reference space */
               se->valid = 0;
            }
         }
         else
         {  /* too many updates; reset reference space */
            se->valid = 0;
         }
      }
      /* update matrix N for adjacent basis, if used */
      if (nt != NULL)
         spx_update_nt(lp, nt, csa->p, csa->q);
skip: /* change current basis header to adjacent one */
      spx_change_basis(lp, csa->p, csa->p_flag, csa->q);
      /* and update factorization of the basis matrix */
      if (csa->p > 0)
         spx_update_invb(lp, csa->p, head[csa->p]);
#if 1
      if (perturb <= 0)
      {  if (csa->phase == 1)
         {  int cnt;
            /* adjust penalty function coefficients */
            cnt = adjust_penalty(csa, csa->tcol.nnz, csa->tcol.ind,
               0.99 * tol_bnd, 0.99 * tol_bnd1);
            if (cnt)
            {  /* some coefficients were changed, so invalidate reduced
                * costs of non-basic variables */
               /*xprintf("... cnt = %d\n", cnt);*/
               csa->d_st = 0;
            }
         }
      }
      else
      {  /* FIXME */
         play_bounds(csa, 0);
      }
#endif
      /* simplex iteration complete */
      csa->it_cnt++;
      goto loop;
fini: /* restore original objective function */
      memcpy(c, csa->orig_c, (1+n) * sizeof(double));
      /* compute reduced costs of non-basic variables and determine
       * solution dual status, if necessary */
      if (csa->p_stat != GLP_UNDEF && csa->d_stat == GLP_UNDEF)
      {  xassert(ret != GLP_EFAIL);
         spx_eval_pi(lp, pi);
         for (j = 1; j <= n-m; j++)
            d[j] = spx_eval_dj(lp, pi, j);
         csa->num = spx_chuzc_sel(lp, d, tol_dj, tol_dj1, NULL);
         csa->d_stat = (csa->num == 0 ? GLP_FEAS : GLP_INFEAS);
      }
      return ret;
}

int spx_primal(glp_prob *P, const glp_smcp *parm)
{     /* driver to the primal simplex method */
      struct csa csa_, *csa = &csa_;
      SPXLP lp;
      SPXAT at;
      SPXNT nt;
      SPXSE se;
      int ret, *map, *daeh;
#if SCALE_Z
      int i, j, k;
#endif
      /* build working LP and its initial basis */
      memset(csa, 0, sizeof(struct csa));
      csa->lp = &lp;
      spx_init_lp(csa->lp, P, parm->excl);
      spx_alloc_lp(csa->lp);
      map = talloc(1+P->m+P->n, int);
      spx_build_lp(csa->lp, P, parm->excl, parm->shift, map);
      spx_build_basis(csa->lp, P, map);
      switch (P->dir)
      {  case GLP_MIN:
            csa->dir = +1;
            break;
         case GLP_MAX:
            csa->dir = -1;
            break;
         default:
            xassert(P != P);
      }
#if SCALE_Z
      csa->fz = 0.0;
      for (k = 1; k <= csa->lp->n; k++)
      {  double t = fabs(csa->lp->c[k]);
         if (csa->fz < t)
            csa->fz = t;
      }
      if (csa->fz <= 1000.0)
         csa->fz = 1.0;
      else
         csa->fz /= 1000.0;
      /*xprintf("csa->fz = %g\n", csa->fz);*/
      for (k = 0; k <= csa->lp->n; k++)
         csa->lp->c[k] /= csa->fz;
#endif
      csa->orig_c = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_c, csa->lp->c, (1+csa->lp->n) * sizeof(double));
#if 1 /*PERTURB*/
      csa->orig_l = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_l, csa->lp->l, (1+csa->lp->n) * sizeof(double));
      csa->orig_u = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_u, csa->lp->u, (1+csa->lp->n) * sizeof(double));
#else
      csa->orig_l = csa->orig_u = NULL;
#endif
      switch (parm->aorn)
      {  case GLP_USE_AT:
            /* build matrix A in row-wise format */
            csa->at = &at;
            csa->nt = NULL;
            spx_alloc_at(csa->lp, csa->at);
            spx_build_at(csa->lp, csa->at);
            break;
         case GLP_USE_NT:
            /* build matrix N in row-wise format for initial basis */
            csa->at = NULL;
            csa->nt = &nt;
            spx_alloc_nt(csa->lp, csa->nt);
            spx_init_nt(csa->lp, csa->nt);
            spx_build_nt(csa->lp, csa->nt);
            break;
         default:
            xassert(parm != parm);
      }
      /* allocate and initialize working components */
      csa->phase = 0;
      csa->beta = talloc(1+csa->lp->m, double);
      csa->beta_st = 0;
      csa->d = talloc(1+csa->lp->n-csa->lp->m, double);
      csa->d_st = 0;
      switch (parm->pricing)
      {  case GLP_PT_STD:
            csa->se = NULL;
            break;
         case GLP_PT_PSE:
            csa->se = &se;
            spx_alloc_se(csa->lp, csa->se);
            break;
         default:
            xassert(parm != parm);
      }
      csa->list = talloc(1+csa->lp->n-csa->lp->m, int);
#if 0 /* 11/VI-2017 */
      csa->tcol = talloc(1+csa->lp->m, double);
      csa->trow = talloc(1+csa->lp->n-csa->lp->m, double);
#else
      fvs_alloc_vec(&csa->tcol, csa->lp->m);
      fvs_alloc_vec(&csa->trow, csa->lp->n-csa->lp->m);
#endif
#if 1 /* 23/VI-2017 */
      csa->bp = NULL;
#endif
#if 0 /* 09/VII-2017 */
      csa->work = talloc(1+csa->lp->m, double);
#else
      fvs_alloc_vec(&csa->work, csa->lp->m);
#endif
      /* initialize control parameters */
      csa->msg_lev = parm->msg_lev;
#if 0 /* 23/VI-2017 */
      switch (parm->r_test)
      {  case GLP_RT_STD:
            csa->harris = 0;
            break;
         case GLP_RT_HAR:
#if 1 /* 16/III-2016 */
         case GLP_RT_FLIP:
            /* FIXME */
            /* currently for primal simplex GLP_RT_FLIP is equivalent
             * to GLP_RT_HAR */
#endif
            csa->harris = 1;
            break;
         default:
            xassert(parm != parm);
      }
#else
      switch (parm->r_test)
      {  case GLP_RT_STD:
         case GLP_RT_HAR:
            break;
         case GLP_RT_FLIP:
            csa->bp = talloc(1+2*csa->lp->m+1, SPXBP);
            break;
         default:
            xassert(parm != parm);
      }
      csa->r_test = parm->r_test;
#endif
      csa->tol_bnd = parm->tol_bnd;
      csa->tol_bnd1 = .001 * parm->tol_bnd;
      csa->tol_dj = parm->tol_dj;
      csa->tol_dj1 = .001 * parm->tol_dj;
      csa->tol_piv = parm->tol_piv;
      csa->it_lim = parm->it_lim;
      csa->tm_lim = parm->tm_lim;
      csa->out_frq = parm->out_frq;
      csa->out_dly = parm->out_dly;
      /* initialize working parameters */
      csa->tm_beg = xtime();
      csa->it_beg = csa->it_cnt = P->it_cnt;
      csa->it_dpy = -1;
#if 1 /* 15/VII-2017 */
      csa->tm_dpy = 0.0;
#endif
      csa->inv_cnt = 0;
#if 1 /* 01/VII-2017 */
      csa->degen = 0;
#endif
#if 1 /* 23/VI-2017 */
      csa->ns_cnt = csa->ls_cnt = 0;
#endif
      /* try to solve working LP */
      ret = primal_simplex(csa);
      /* return basis factorization back to problem object */
      P->valid = csa->lp->valid;
      P->bfd = csa->lp->bfd;
      /* set solution status */
      P->pbs_stat = csa->p_stat;
      P->dbs_stat = csa->d_stat;
      /* if the solver failed, do not store basis header and basic
       * solution components to problem object */
      if (ret == GLP_EFAIL)
         goto skip;
      /* convert working LP basis to original LP basis and store it to
       * problem object */
      daeh = talloc(1+csa->lp->n, int);
      spx_store_basis(csa->lp, P, map, daeh);
      /* compute simplex multipliers for final basic solution found by
       * the solver */
#if 0 /* 09/VII-2017 */
      spx_eval_pi(csa->lp, csa->work);
#else
      spx_eval_pi(csa->lp, csa->work.vec);
#endif
      /* convert working LP solution to original LP solution and store
       * it into the problem object */
#if SCALE_Z
      for (i = 1; i <= csa->lp->m; i++)
         csa->work.vec[i] *= csa->fz;
      for (j = 1; j <= csa->lp->n-csa->lp->m; j++)
         csa->d[j] *= csa->fz;
#endif
#if 0 /* 09/VII-2017 */
      spx_store_sol(csa->lp, P, SHIFT, map, daeh, csa->beta, csa->work,
         csa->d);
#else
      spx_store_sol(csa->lp, P, parm->shift, map, daeh, csa->beta,
         csa->work.vec, csa->d);
#endif
      tfree(daeh);
      /* save simplex iteration count */
      P->it_cnt = csa->it_cnt;
      /* report auxiliary/structural variable causing unboundedness */
      P->some = 0;
      if (csa->p_stat == GLP_FEAS && csa->d_stat == GLP_NOFEAS)
      {  int k, kk;
         /* xN[q] = x[k] causes unboundedness */
         xassert(1 <= csa->q && csa->q <= csa->lp->n - csa->lp->m);
         k = csa->lp->head[csa->lp->m + csa->q];
         xassert(1 <= k && k <= csa->lp->n);
         /* convert to number of original variable */
         for (kk = 1; kk <= P->m + P->n; kk++)
         {  if (abs(map[kk]) == k)
            {  P->some = kk;
               break;
            }
         }
         xassert(P->some != 0);
      }
skip: /* deallocate working objects and arrays */
      spx_free_lp(csa->lp);
      tfree(map);
      tfree(csa->orig_c);
#if 1 /*PERTURB*/
      tfree(csa->orig_l);
      tfree(csa->orig_u);
#endif
      if (csa->at != NULL)
         spx_free_at(csa->lp, csa->at);
      if (csa->nt != NULL)
         spx_free_nt(csa->lp, csa->nt);
      tfree(csa->beta);
      tfree(csa->d);
      if (csa->se != NULL)
         spx_free_se(csa->lp, csa->se);
      tfree(csa->list);
#if 0 /* 11/VI-2017 */
      tfree(csa->tcol);
      tfree(csa->trow);
#else
      fvs_free_vec(&csa->tcol);
      fvs_free_vec(&csa->trow);
#endif
#if 1 /* 23/VI-2017 */
      if (csa->bp != NULL)
         tfree(csa->bp);
#endif
#if 0 /* 09/VII-2017 */
      tfree(csa->work);
#else
      fvs_free_vec(&csa->work);
#endif
      /* return to calling program */
      return ret;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxprob.c0000644000175100001710000005550300000000000025436 0ustar00runnerdocker00000000000000/* spxprob.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spxprob.h"

/***********************************************************************
*  spx_init_lp - initialize working LP object
*
*  This routine determines the number of equality constraints m, the
*  number of variables n, and the number of non-zero elements nnz in
*  the constraint matrix for the working LP, which corresponds to the
*  original LP, and stores these dimensions to the working LP object.
*  (The working LP object should be allocated by the calling routine.)
*
*  If the flag excl is set, the routine assumes that non-basic fixed
*  variables will be excluded from the working LP. */

void spx_init_lp(SPXLP *lp, glp_prob *P, int excl)
{     int i, j, m, n, nnz;
      m = P->m;
      xassert(m > 0);
      n = 0;
      nnz = P->nnz;
      xassert(P->valid);
      /* scan rows of original LP */
      for (i = 1; i <= m; i++)
      {  GLPROW *row = P->row[i];
         if (excl && row->stat == GLP_NS)
         {  /* skip non-basic fixed auxiliary variable */
            /* nop */
         }
         else
         {  /* include auxiliary variable in working LP */
            n++;
            nnz++; /* unity column */
         }
      }
      /* scan columns of original LP */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if (excl && col->stat == GLP_NS)
         {  /* skip non-basic fixed structural variable */
            GLPAIJ *aij;
            for (aij = col->ptr; aij != NULL; aij = aij->c_next)
               nnz--;
         }
         else
         {  /* include structural variable in working LP */
            n++;
         }
      }
      /* initialize working LP data block */
      memset(lp, 0, sizeof(SPXLP));
      lp->m = m;
      xassert(n > 0);
      lp->n = n;
      lp->nnz = nnz;
      return;
}

/***********************************************************************
*  spx_alloc_lp - allocate working LP arrays
*
*  This routine allocates the memory for all arrays in the working LP
*  object. */

void spx_alloc_lp(SPXLP *lp)
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      lp->A_ptr = talloc(1+n+1, int);
      lp->A_ind = talloc(1+nnz, int);
      lp->A_val = talloc(1+nnz, double);
      lp->b = talloc(1+m, double);
      lp->c = talloc(1+n, double);
      lp->l = talloc(1+n, double);
      lp->u = talloc(1+n, double);
      lp->head = talloc(1+n, int);
      lp->flag = talloc(1+n-m, char);
      return;
}

/***********************************************************************
*  spx_build_lp - convert original LP to working LP
*
*  This routine converts components (except the current basis) of the
*  original LP to components of the working LP and perform scaling of
*  these components. Also, if the original LP is maximization, the
*  routine changes the signs of the objective coefficients and constant
*  term to opposite ones.
*
*  If the flag excl is set, original non-basic fixed variables are
*  *not* included in the working LP. Otherwise, all (auxiliary and
*  structural) original variables are included in the working LP. Note
*  that this flag should have the same value as it has in a call to the
*  routine spx_init_lp.
*
*  If the flag shift is set, the routine shift bounds of variables
*  included in the working LP to make at least one bound to be zero.
*  If a variable has both lower and upper bounds, the bound having
*  smaller magnitude is shifted to zero.
*
*  On exit the routine stores information about correspondence between
*  numbers of variables in the original and working LPs to the array
*  map, which should have 1+P->m+P->n locations (location [0] is not
*  used), where P->m is the numbers of rows and P->n is the number of
*  columns in the original LP:
*
*  map[i] = +k, 1 <= i <= P->m, means that i-th auxiliary variable of
*  the original LP corresponds to variable x[k] of the working LP;
*
*  map[i] = -k, 1 <= i <= P->m, means that i-th auxiliary variable of
*  the original LP corresponds to variable x[k] of the working LP, and
*  the upper bound of that variable was shifted to zero;
*
*  map[i] = 0, 1 <= i <= P->m, means that i-th auxiliary variable of
*  the original LP was excluded from the working LP;
*
*  map[P->m+j], 1 <= j <= P->n, has the same sense as above, however,
*  for j-th structural variable of the original LP. */

void spx_build_lp(SPXLP *lp, glp_prob *P, int excl, int shift,
      int map[/*1+P->m+P->n*/])
{     int m = lp->m;
      int n = lp->n;
      int nnz = lp->nnz;
      int *A_ptr = lp->A_ptr;
      int *A_ind = lp->A_ind;
      double *A_val = lp->A_val;
      double *b = lp->b;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int i, j, k, kk, ptr, end;
      double dir, delta;
      /* working LP is always minimization */
      switch (P->dir)
      {  case GLP_MIN:
            dir = +1.0;
            break;
         case GLP_MAX:
            dir = -1.0;
            break;
         default:
            xassert(P != P);
      }
      /* initialize constant term of the objective */
      c[0] = dir * P->c0;
      k = 0; /* number of variable in working LP */
      ptr = 1; /* current available position in A_ind/A_val */
      /* process rows of original LP */
      xassert(P->m == m);
      for (i = 1; i <= m; i++)
      {  GLPROW *row = P->row[i];
         if (excl && row->stat == GLP_NS)
         {  /* i-th auxiliary variable is non-basic and fixed */
            /* substitute its scaled value in working LP */
            xassert(row->type == GLP_FX);
            map[i] = 0;
            b[i] = - row->lb * row->rii;
         }
         else
         {  /* include i-th auxiliary variable in working LP */
            map[i] = ++k;
            /* setup k-th column of working constraint matrix which is
             * i-th column of unity matrix */
            A_ptr[k] = ptr;
            A_ind[ptr] = i;
            A_val[ptr] = 1.0;
            ptr++;
            /* initialize right-hand side of i-th equality constraint
             * and setup zero objective coefficient at variable x[k] */
            b[i] = c[k] = 0.0;
            /* setup scaled bounds of variable x[k] */
            switch (row->type)
            {  case GLP_FR:
                  l[k] = -DBL_MAX, u[k] = +DBL_MAX;
                  break;
               case GLP_LO:
                  l[k] = row->lb * row->rii, u[k] = +DBL_MAX;
                  break;
               case GLP_UP:
                  l[k] = -DBL_MAX, u[k] = row->ub * row->rii;
                  break;
               case GLP_DB:
                  l[k] = row->lb * row->rii, u[k] = row->ub * row->rii;
                  xassert(l[k] != u[k]);
                  break;
               case GLP_FX:
                  l[k] = u[k] = row->lb * row->rii;
                  break;
               default:
                  xassert(row != row);
            }
         }
      }
      /* process columns of original LP */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         GLPAIJ *aij;
         if (excl && col->stat == GLP_NS)
         {  /* j-th structural variable is non-basic and fixed */
            /* substitute its scaled value in working LP */
            xassert(col->type == GLP_FX);
            map[m+j] = 0;
            if (col->lb != 0.0)
            {  /* (note that sjj scale factor is cancelled) */
               for (aij = col->ptr; aij != NULL; aij = aij->c_next)
                  b[aij->row->i] +=
                     (aij->row->rii * aij->val) * col->lb;
               c[0] += (dir * col->coef) * col->lb;
            }
         }
         else
         {  /* include j-th structural variable in working LP */
            map[m+j] = ++k;
            /* setup k-th column of working constraint matrix which is
             * scaled j-th column of original constraint matrix (-A) */
            A_ptr[k] = ptr;
            for (aij = col->ptr; aij != NULL; aij = aij->c_next)
            {  A_ind[ptr] = aij->row->i;
               A_val[ptr] = - aij->row->rii * aij->val * col->sjj;
               ptr++;
            }
            /* setup scaled objective coefficient at variable x[k] */
            c[k] = dir * col->coef * col->sjj;
            /* setup scaled bounds of variable x[k] */
            switch (col->type)
            {  case GLP_FR:
                  l[k] = -DBL_MAX, u[k] = +DBL_MAX;
                  break;
               case GLP_LO:
                  l[k] = col->lb / col->sjj, u[k] = +DBL_MAX;
                  break;
               case GLP_UP:
                  l[k] = -DBL_MAX, u[k] = col->ub / col->sjj;
                  break;
               case GLP_DB:
                  l[k] = col->lb / col->sjj, u[k] = col->ub / col->sjj;
                  xassert(l[k] != u[k]);
                  break;
               case GLP_FX:
                  l[k] = u[k] = col->lb / col->sjj;
                  break;
               default:
                  xassert(col != col);
            }
         }
      }
      xassert(k == n);
      xassert(ptr == nnz+1);
      A_ptr[n+1] = ptr;
      /* shift bounds of all variables of working LP (optionally) */
      if (shift)
      {  for (kk = 1; kk <= m+P->n; kk++)
         {  k = map[kk];
            if (k == 0)
            {  /* corresponding original variable was excluded */
               continue;
            }
            /* shift bounds of variable x[k] */
            if (l[k] == -DBL_MAX && u[k] == +DBL_MAX)
            {  /* x[k] is unbounded variable */
               delta = 0.0;
            }
            else if (l[k] != -DBL_MAX && u[k] == +DBL_MAX)
            {  /* shift lower bound to zero */
               delta = l[k];
               l[k] = 0.0;
            }
            else if (l[k] == -DBL_MAX && u[k] != +DBL_MAX)
            {  /* shift upper bound to zero */
               map[kk] = -k;
               delta = u[k];
               u[k] = 0.0;
            }
            else if (l[k] != u[k])
            {  /* x[k] is double bounded variable */
               if (fabs(l[k]) <= fabs(u[k]))
               {  /* shift lower bound to zero */
                  delta = l[k];
                  l[k] = 0.0, u[k] -= delta;
               }
               else
               {  /* shift upper bound to zero */
                  map[kk] = -k;
                  delta = u[k];
                  l[k] -= delta, u[k] = 0.0;
               }
               xassert(l[k] != u[k]);
            }
            else
            {  /* shift fixed value to zero */
               delta = l[k];
               l[k] = u[k] = 0.0;
            }
            /* substitute x[k] = x'[k] + delta into all constraints
             * and the objective function of working LP */
            if (delta != 0.0)
            {  ptr = A_ptr[k];
               end = A_ptr[k+1];
               for (; ptr < end; ptr++)
                  b[A_ind[ptr]] -= A_val[ptr] * delta;
               c[0] += c[k] * delta;
            }
         }
      }
      return;
}

/***********************************************************************
*  spx_build_basis - convert original LP basis to working LP basis
*
*  This routine converts the current basis of the original LP to
*  corresponding initial basis of the working LP, and moves the basis
*  factorization driver from the original LP object to the working LP
*  object.
*
*  The array map should contain information provided by the routine
*  spx_build_lp. */

void spx_build_basis(SPXLP *lp, glp_prob *P, const int map[])
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *flag = lp->flag;
      int i, j, k, ii, jj;
      /* original basis factorization should be valid that guarantees
       * the basis is correct */
      xassert(P->m == m);
      xassert(P->valid);
      /* initialize basis header for working LP */
      memset(&head[1], 0, m * sizeof(int));
      jj = 0;
      /* scan rows of original LP */
      xassert(P->m == m);
      for (i = 1; i <= m; i++)
      {  GLPROW *row = P->row[i];
         /* determine ordinal number of x[k] in working LP */
         if ((k = map[i]) < 0)
            k = -k;
         if (k == 0)
         {  /* corresponding original variable was excluded */
            continue;
         }
         xassert(1 <= k && k <= n);
         if (row->stat == GLP_BS)
         {  /* x[k] is basic variable xB[ii] */
            ii = row->bind;
            xassert(1 <= ii && ii <= m);
            xassert(head[ii] == 0);
            head[ii] = k;
         }
         else
         {  /* x[k] is non-basic variable xN[jj] */
            jj++;
            head[m+jj] = k;
            flag[jj] = (row->stat == GLP_NU);
         }
      }
      /* scan columns of original LP */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         /* determine ordinal number of x[k] in working LP */
         if ((k = map[m+j]) < 0)
            k = -k;
         if (k == 0)
         {  /* corresponding original variable was excluded */
            continue;
         }
         xassert(1 <= k && k <= n);
         if (col->stat == GLP_BS)
         {  /* x[k] is basic variable xB[ii] */
            ii = col->bind;
            xassert(1 <= ii && ii <= m);
            xassert(head[ii] == 0);
            head[ii] = k;
         }
         else
         {  /* x[k] is non-basic variable xN[jj] */
            jj++;
            head[m+jj] = k;
            flag[jj] = (col->stat == GLP_NU);
         }
      }
      xassert(m+jj == n);
      /* acquire basis factorization */
      lp->valid = 1;
      lp->bfd = P->bfd;
      P->valid = 0;
      P->bfd = NULL;
      return;
}

/***********************************************************************
*  spx_store_basis - convert working LP basis to original LP basis
*
*  This routine converts the current working LP basis to corresponding
*  original LP basis. This operations includes determining and setting
*  statuses of all rows (auxiliary variables) and columns (structural
*  variables), and building the basis header.
*
*  The array map should contain information provided by the routine
*  spx_build_lp.
*
*  On exit the routine fills the array daeh. This array should have
*  1+lp->n locations (location [0] is not used) and contain the inverse
*  of the working basis header lp->head, i.e. head[k'] = k means that
*  daeh[k] = k'. */

void spx_store_basis(SPXLP *lp, glp_prob *P, const int map[],
      int daeh[/*1+n*/])
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *flag = lp->flag;
      int i, j, k, kk;
      /* determine inverse of working basis header */
      for (kk = 1; kk <= n; kk++)
         daeh[head[kk]] = kk;
      /* set row statuses */
      xassert(P->m == m);
      for (i = 1; i <= m; i++)
      {  GLPROW *row = P->row[i];
         if ((k = map[i]) < 0)
            k = -k;
         if (k == 0)
         {  /* non-basic fixed auxiliary variable was excluded */
            xassert(row->type == GLP_FX);
            row->stat = GLP_NS;
            row->bind = 0;
         }
         else
         {  /* auxiliary variable corresponds to variable x[k] */
            kk = daeh[k];
            if (kk <= m)
            {  /* x[k] = xB[kk] */
               P->head[kk] = i;
               row->stat = GLP_BS;
               row->bind = kk;
            }
            else
            {  /* x[k] = xN[kk-m] */
               switch (row->type)
               {  case GLP_FR:
                     row->stat = GLP_NF;
                     break;
                  case GLP_LO:
                     row->stat = GLP_NL;
                     break;
                  case GLP_UP:
                     row->stat = GLP_NU;
                     break;
                  case GLP_DB:
                     row->stat = (flag[kk-m] ? GLP_NU : GLP_NL);
                     break;
                  case GLP_FX:
                     row->stat = GLP_NS;
                     break;
                  default:
                     xassert(row != row);
               }
               row->bind = 0;
            }
         }
      }
      /* set column statuses */
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if ((k = map[m+j]) < 0)
            k = -k;
         if (k == 0)
         {  /* non-basic fixed structural variable was excluded */
            xassert(col->type == GLP_FX);
            col->stat = GLP_NS;
            col->bind = 0;
         }
         else
         {  /* structural variable corresponds to variable x[k] */
            kk = daeh[k];
            if (kk <= m)
            {  /* x[k] = xB[kk] */
               P->head[kk] = m+j;
               col->stat = GLP_BS;
               col->bind = kk;
            }
            else
            {  /* x[k] = xN[kk-m] */
               switch (col->type)
               {  case GLP_FR:
                     col->stat = GLP_NF;
                     break;
                  case GLP_LO:
                     col->stat = GLP_NL;
                     break;
                  case GLP_UP:
                     col->stat = GLP_NU;
                     break;
                  case GLP_DB:
                     col->stat = (flag[kk-m] ? GLP_NU : GLP_NL);
                     break;
                  case GLP_FX:
                     col->stat = GLP_NS;
                     break;
                  default:
                     xassert(col != col);
               }
               col->bind = 0;
            }
         }
      }
      return;
}

/***********************************************************************
*  spx_store_sol - convert working LP solution to original LP solution
*
*  This routine converts the current basic solution of the working LP
*  (values of basic variables, simplex multipliers, reduced costs of
*  non-basic variables) to corresponding basic solution of the original
*  LP (values and reduced costs of auxiliary and structural variables).
*  This conversion includes unscaling all basic solution components,
*  computing reduced costs of excluded non-basic variables, recovering
*  unshifted values of basic variables, changing the signs of reduced
*  costs (if the original LP is maximization), and computing the value
*  of the objective function.
*
*  The flag shift should have the same value as it has in a call to the
*  routine spx_build_lp.
*
*  The array map should contain information provided by the routine
*  spx_build_lp.
*
*  The array daeh should contain information provided by the routine
*  spx_store_basis.
*
*  The arrays beta, pi, and d should contain basic solution components
*  for the working LP:
*
*  array locations beta[1], ..., beta[m] should contain values of basic
*  variables beta = (beta[i]);
*
*  array locations pi[1], ..., pi[m] should contain simplex multipliers
*  pi = (pi[i]);
*
*  array locations d[1], ..., d[n-m] should contain reduced costs of
*  non-basic variables d = (d[j]). */

void spx_store_sol(SPXLP *lp, glp_prob *P, int shift,
      const int map[], const int daeh[], const double beta[],
      const double pi[], const double d[])
{     int m = lp->m;
      char *flag = lp->flag;
      int i, j, k, kk;
      double dir;
      /* working LP is always minimization */
      switch (P->dir)
      {  case GLP_MIN:
            dir = +1.0;
            break;
         case GLP_MAX:
            dir = -1.0;
            break;
         default:
            xassert(P != P);
      }
      /* compute row solution components */
      xassert(P->m == m);
      for (i = 1; i <= m; i++)
      {  GLPROW *row = P->row[i];
         if ((k = map[i]) < 0)
            k = -k;
         if (k == 0)
         {  /* non-basic fixed auxiliary variable was excluded */
            xassert(row->type == GLP_FX);
            row->prim = row->lb;
            /* compute reduced cost d[k] = c[k] - A'[k] * pi as if x[k]
             * would be non-basic in working LP */
            row->dual = - dir * pi[i] * row->rii;
         }
         else
         {  /* auxiliary variable corresponds to variable x[k] */
            kk = daeh[k];
            if (kk <= m)
            {  /* x[k] = xB[kk] */
               row->prim = beta[kk] / row->rii;
               if (shift)
                  row->prim += (map[i] < 0 ? row->ub : row->lb);
               row->dual = 0.0;
            }
            else
            {  /* x[k] = xN[kk-m] */
               row->prim = (flag[kk-m] ? row->ub : row->lb);
               row->dual = (dir * d[kk-m]) * row->rii;
            }
         }
      }
      /* compute column solution components and objective value */
      P->obj_val = P->c0;
      for (j = 1; j <= P->n; j++)
      {  GLPCOL *col = P->col[j];
         if ((k = map[m+j]) < 0)
            k = -k;
         if (k == 0)
         {  /* non-basic fixed structural variable was excluded */
            GLPAIJ *aij;
            double dk;
            xassert(col->type == GLP_FX);
            col->prim = col->lb;
            /* compute reduced cost d[k] = c[k] - A'[k] * pi as if x[k]
             * would be non-basic in working LP */
            /* (note that sjj scale factor is cancelled) */
            dk = dir * col->coef;
            for (aij = col->ptr; aij != NULL; aij = aij->c_next)
               dk += (aij->row->rii * aij->val) * pi[aij->row->i];
            col->dual = dir * dk;
         }
         else
         {  /* structural variable corresponds to variable x[k] */
            kk = daeh[k];
            if (kk <= m)
            {  /* x[k] = xB[kk] */
               col->prim = beta[kk] * col->sjj;
               if (shift)
                  col->prim += (map[m+j] < 0 ? col->ub : col->lb);
               col->dual = 0.0;
            }
            else
            {  /* x[k] = xN[kk-m] */
               col->prim = (flag[kk-m] ? col->ub : col->lb);
               col->dual = (dir * d[kk-m]) / col->sjj;
            }
         }
         P->obj_val += col->coef * col->prim;
      }
      return;
}

/***********************************************************************
*  spx_free_lp - deallocate working LP arrays
*
*  This routine deallocates the memory used for arrays of the working
*  LP object. */

void spx_free_lp(SPXLP *lp)
{     tfree(lp->A_ptr);
      tfree(lp->A_ind);
      tfree(lp->A_val);
      tfree(lp->b);
      tfree(lp->c);
      tfree(lp->l);
      tfree(lp->u);
      tfree(lp->head);
      tfree(lp->flag);
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spxprob.h0000644000175100001710000000414300000000000025435 0ustar00runnerdocker00000000000000/* spxprob.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPXPROB_H
#define SPXPROB_H

#include "prob.h"
#include "spxlp.h"

#define spx_init_lp _glp_spx_init_lp
void spx_init_lp(SPXLP *lp, glp_prob *P, int excl);
/* initialize working LP object */

#define spx_alloc_lp _glp_spx_alloc_lp
void spx_alloc_lp(SPXLP *lp);
/* allocate working LP arrays */

#define spx_build_lp _glp_spx_build_lp
void spx_build_lp(SPXLP *lp, glp_prob *P, int excl, int shift,
      int map[/*1+P->m+P->n*/]);
/* convert original LP to working LP */

#define spx_build_basis _glp_spx_build_basis
void spx_build_basis(SPXLP *lp, glp_prob *P, const int map[]);
/* convert original LP basis to working LP basis */

#define spx_store_basis _glp_spx_store_basis
void spx_store_basis(SPXLP *lp, glp_prob *P, const int map[],
      int daeh[/*1+n*/]);
/* convert working LP basis to original LP basis */

#define spx_store_sol _glp_spx_store_sol
void spx_store_sol(SPXLP *lp, glp_prob *P, int shift,
      const int map[], const int daeh[], const double beta[],
      const double pi[], const double d[]);
/* convert working LP solution to original LP solution */

#define spx_free_lp _glp_spx_free_lp
void spx_free_lp(SPXLP *lp);
/* deallocate working LP arrays */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spychuzc.c0000644000175100001710000005333400000000000025611 0ustar00runnerdocker00000000000000/* spychuzc.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2018 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spychuzc.h"

/***********************************************************************
*  spy_chuzc_std - choose non-basic variable (dual textbook ratio test)
*
*  This routine implements an improved dual textbook ratio test to
*  choose non-basic variable xN[q].
*
*  Current reduced costs of non-basic variables should be placed in the
*  array locations d[1], ..., d[n-m]. Note that d[j] is a value of dual
*  basic variable lambdaN[j] in the current basis.
*
#if 0 (* 14/III-2016 *)
*  The parameter s specifies the sign of bound violation for basic
*  variable xB[p] chosen: s = +1.0 means that xB[p] violates its lower
*  bound, so dual non-basic variable lambdaB[p] = lambda^+B[p]
*  increases, and s = -1.0 means that xB[p] violates its upper bound,
*  so dual non-basic variable lambdaB[p] = lambda^-B[p] decreases.
*  (Thus, the dual ray parameter theta = s * lambdaB[p] >= 0.)
#else
*  The parameter r specifies the bound violation for basic variable
*  xB[p] chosen:
*
*  r = lB[p] - beta[p] > 0 means that xB[p] violates its lower bound,
*  so dual non-basic variable lambdaB[p] = lambda^+B[p] increases; and
*
*  r = uB[p] - beta[p] < 0 means that xB[p] violates its upper bound,
*  so dual non-basic variable lambdaB[p] = lambda^-B[p] decreases.
*
*  (Note that r is the dual reduced cost of lambdaB[p].)
#endif
*
*  Elements of p-th simplex table row t[p] = (t[p,j]) corresponding
*  to basic variable xB[p] should be placed in the array locations
*  trow[1], ..., trow[n-m].
*
*  The parameter tol_piv specifies a tolerance for elements of the
*  simplex table row t[p]. If |t[p,j]| < tol_piv, dual basic variable
*  lambdaN[j] is skipped, i.e. it is assumed that it does not depend on
*  the dual ray parameter theta.
*
*  The parameters tol and tol1 specify tolerances used to increase the
*  choice freedom by simulating an artificial degeneracy as follows.
*  If lambdaN[j] = lambda^+N[j] >= 0 and d[j] <= +delta[j], or if
*  lambdaN[j] = lambda^-N[j] <= 0 and d[j] >= -delta[j], where
*  delta[j] = tol + tol1 * |cN[j]|, cN[j] is objective coefficient at
*  xN[j], then it is assumed that reduced cost d[j] is equal to zero.
*
*  The routine determines the index 1 <= q <= n-m of non-basic variable
*  xN[q], for which corresponding dual basic variable lambda^+N[j] or
*  lambda^-N[j] reaches its zero bound first on increasing the dual ray
*  parameter theta, and returns p on exit. And if theta may increase
*  unlimitedly, the routine returns zero. */

int spy_chuzc_std(SPXLP *lp, const double d[/*1+n-m*/],
#if 0 /* 14/III-2016 */
      double s, const double trow[/*1+n-m*/], double tol_piv,
#else
      double r, const double trow[/*1+n-m*/], double tol_piv,
#endif
      double tol, double tol1)
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k, q;
      double alfa, biga, delta, teta, teta_min;
#if 0 /* 14/III-2016 */
      xassert(s == +1.0 || s == -1.0);
#else
      double s;
      xassert(r != 0.0);
      s = (r > 0.0 ? +1.0 : -1.0);
#endif
      /* nothing is chosen so far */
      q = 0, teta_min = DBL_MAX, biga = 0.0;
      /* walk thru the list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* if xN[j] is fixed variable, skip it */
         if (l[k] == u[k])
            continue;
         alfa = s * trow[j];
         if (alfa >= +tol_piv && !flag[j])
         {  /* xN[j] is either free or has its lower bound active, so
             * lambdaN[j] = d[j] >= 0 decreases down to zero */
            delta = tol + tol1 * (c[k] >= 0.0 ? +c[k] : -c[k]);
            /* determine theta on which lambdaN[j] reaches zero */
            teta = (d[j] < +delta ? 0.0 : d[j] / alfa);
         }
         else if (alfa <= -tol_piv && (l[k] == -DBL_MAX || flag[j]))
         {  /* xN[j] is either free or has its upper bound active, so
             * lambdaN[j] = d[j] <= 0 increases up to zero */
            delta = tol + tol1 * (c[k] >= 0.0 ? +c[k] : -c[k]);
            /* determine theta on which lambdaN[j] reaches zero */
            teta = (d[j] > -delta ? 0.0 : d[j] / alfa);
         }
         else
         {  /* lambdaN[j] cannot reach zero on increasing theta */
            continue;
         }
         /* choose non-basic variable xN[q] by corresponding dual basic
          * variable lambdaN[q] for which theta is minimal */
         xassert(teta >= 0.0);
         alfa = (alfa >= 0.0 ? +alfa : -alfa);
         if (teta_min > teta || (teta_min == teta && biga < alfa))
            q = j, teta_min = teta, biga = alfa;
      }
      return q;
}

/***********************************************************************
*  spy_chuzc_harris - choose non-basic var. (dual Harris' ratio test)
*
*  This routine implements dual Harris' ratio test to choose non-basic
*  variable xN[q].
*
*  All the parameters, except tol and tol1, as well as the returned
*  value have the same meaning as for the routine spx_chuzr_std (see
*  above).
*
*  The parameters tol and tol1 specify tolerances on zero bound
*  violations for reduced costs of non-basic variables. For reduced
*  cost d[j] the tolerance is delta[j] = tol + tol1 |cN[j]|, where
*  cN[j] is objective coefficient at non-basic variable xN[j]. */

int spy_chuzc_harris(SPXLP *lp, const double d[/*1+n-m*/],
#if 0 /* 14/III-2016 */
      double s, const double trow[/*1+n-m*/], double tol_piv,
#else
      double r, const double trow[/*1+n-m*/], double tol_piv,
#endif
      double tol, double tol1)
{     int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k, q;
      double alfa, biga, delta, teta, teta_min;
#if 0 /* 14/III-2016 */
      xassert(s == +1.0 || s == -1.0);
#else
      double s;
      xassert(r != 0.0);
      s = (r > 0.0 ? +1.0 : -1.0);
#endif
      /*--------------------------------------------------------------*/
      /* first pass: determine teta_min for relaxed bounds            */
      /*--------------------------------------------------------------*/
      teta_min = DBL_MAX;
      /* walk thru the list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* if xN[j] is fixed variable, skip it */
         if (l[k] == u[k])
            continue;
         alfa = s * trow[j];
         if (alfa >= +tol_piv && !flag[j])
         {  /* xN[j] is either free or has its lower bound active, so
             * lambdaN[j] = d[j] >= 0 decreases down to zero */
            delta = tol + tol1 * (c[k] >= 0.0 ? +c[k] : -c[k]);
            /* determine theta on which lambdaN[j] reaches -delta */
            teta = ((d[j] < 0.0 ? 0.0 : d[j]) + delta) / alfa;
         }
         else if (alfa <= -tol_piv && (l[k] == -DBL_MAX || flag[j]))
         {  /* xN[j] is either free or has its upper bound active, so
             * lambdaN[j] = d[j] <= 0 increases up to zero */
            delta = tol + tol1 * (c[k] >= 0.0 ? +c[k] : -c[k]);
            /* determine theta on which lambdaN[j] reaches +delta */
            teta = ((d[j] > 0.0 ? 0.0 : d[j]) - delta) / alfa;
         }
         else
         {  /* lambdaN[j] cannot reach zero on increasing theta */
            continue;
         }
         xassert(teta >= 0.0);
         if (teta_min > teta)
            teta_min = teta;
      }
      /*--------------------------------------------------------------*/
      /* second pass: choose non-basic variable xN[q]                 */
      /*--------------------------------------------------------------*/
      if (teta_min == DBL_MAX)
      {  /* theta may increase unlimitedly */
         q = 0;
         goto done;
      }
      /* nothing is chosen so far */
      q = 0, biga = 0.0;
      /* walk thru the list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* if xN[j] is fixed variable, skip it */
         if (l[k] == u[k])
            continue;
         alfa = s * trow[j];
         if (alfa >= +tol_piv && !flag[j])
         {  /* xN[j] is either free or has its lower bound active, so
             * lambdaN[j] = d[j] >= 0 decreases down to zero */
            /* determine theta on which lambdaN[j] reaches zero */
            teta = d[j] / alfa;
         }
         else if (alfa <= -tol_piv && (l[k] == -DBL_MAX || flag[j]))
         {  /* xN[j] is either free or has its upper bound active, so
             * lambdaN[j] = d[j] <= 0 increases up to zero */
            /* determine theta on which lambdaN[j] reaches zero */
            teta = d[j] / alfa;
         }
         else
         {  /* lambdaN[j] cannot reach zero on increasing theta */
            continue;
         }
         /* choose non-basic variable for which theta is not greater
          * than theta_min determined for relaxed bounds and which has
          * best (largest in magnitude) pivot */
         alfa = (alfa >= 0.0 ? +alfa : -alfa);
         if (teta <= teta_min && biga < alfa)
            q = j, biga = alfa;
      }
      /* something must be chosen */
      xassert(1 <= q && q <= n-m);
done: return q;
}

#if 0 /* 23/III-2016 */
/***********************************************************************
*  spy_eval_bp - determine dual objective function break-points
*
*  This routine determines the dual objective function break-points.
*
*  The parameters lp, d, r, trow, and tol_piv have the same meaning as
*  for the routine spx_chuzc_std (see above).
*
*  On exit the routine stores the break-points determined to the array
*  elements bp[1], ..., bp[num], where 0 <= num <= n-m is the number of
*  break-points returned by the routine.
*
*  The break-points stored in the array bp are ordered by ascending
*  the ray parameter teta >= 0. The break-points numbered 1, ..., num-1
*  always correspond to non-basic non-fixed variables xN[j] of primal
*  LP having both lower and upper bounds while the last break-point
*  numbered num may correspond to a non-basic variable having only one
*  lower or upper bound, if such variable prevents further increasing
*  of the ray parameter teta. Besides, the routine includes in the
*  array bp only the break-points that correspond to positive increment
*  of the dual objective. */

static int CDECL fcmp(const void *v1, const void *v2)
{     const SPYBP *p1 = v1, *p2 = v2;
      if (p1->teta < p2->teta)
         return -1;
      else if (p1->teta > p2->teta)
         return +1;
      else
         return 0;
}

int spy_eval_bp(SPXLP *lp, const double d[/*1+n-m*/],
      double r, const double trow[/*1+n-m*/], double tol_piv,
      SPYBP bp[/*1+n-m*/])
{     int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, j_max, k, t, nnn, num;
      double s, alfa, teta, teta_max, dz, v;
      xassert(r != 0.0);
      s = (r > 0.0 ? +1.0 : -1.0);
      /* build the list of all dual basic variables lambdaN[j] that
       * can reach zero on increasing the ray parameter teta >= 0 */
      num = 0;
      /* walk thru the list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* if xN[j] is fixed variable, skip it */
         if (l[k] == u[k])
            continue;
         alfa = s * trow[j];
         if (alfa >= +tol_piv && !flag[j])
         {  /* xN[j] is either free or has its lower bound active, so
             * lambdaN[j] = d[j] >= 0 decreases down to zero */
            /* determine teta[j] on which lambdaN[j] reaches zero */
            teta = (d[j] < 0.0 ? 0.0 : d[j] / alfa);
         }
         else if (alfa <= -tol_piv && (l[k] == -DBL_MAX || flag[j]))
         {  /* xN[j] is either free or has its upper bound active, so
             * lambdaN[j] = d[j] <= 0 increases up to zero */
            /* determine teta[j] on which lambdaN[j] reaches zero */
            teta = (d[j] > 0.0 ? 0.0 : d[j] / alfa);
         }
         else
         {  /* lambdaN[j] cannot reach zero on increasing teta */
            continue;
         }
         /* add lambdaN[j] to the list */
         num++;
         bp[num].j = j;
         bp[num].teta = teta;
      }
      if (num == 0)
      {  /* dual unboundedness */
         goto done;
      }
      /* determine "blocking" dual basic variable lambdaN[j_max] that
       * prevents increasing teta more than teta_max */
      j_max = 0, teta_max = DBL_MAX;
      for (t = 1; t <= num; t++)
      {  j = bp[t].j;
         k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == -DBL_MAX || u[k] == +DBL_MAX)
         {  /* lambdaN[j] cannot intersect zero */
            if (j_max == 0
               || teta_max > bp[t].teta
               || (teta_max == bp[t].teta
                  && fabs(trow[j_max]) < fabs(trow[j])))
               j_max = j, teta_max = bp[t].teta;
         }
      }
      /* keep in the list only dual basic variables lambdaN[j] that
       * correspond to primal double-bounded variables xN[j] and whose
       * teta[j] is not greater than teta_max */
      nnn = 0;
      for (t = 1; t <= num; t++)
      {  j = bp[t].j;
         k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] != -DBL_MAX && u[k] != +DBL_MAX
            && bp[t].teta <= teta_max)
         {  nnn++;
            bp[nnn].j = j;
            bp[nnn].teta = bp[t].teta;
         }
      }
      num = nnn;
      /* sort break-points by ascending teta[j] */
      qsort(&bp[1], num, sizeof(SPYBP), fcmp);
      /* add lambdaN[j_max] to the end of the list */
      if (j_max != 0)
      {  xassert(num < n-m);
         num++;
         bp[num].j = j_max;
         bp[num].teta = teta_max;
      }
      /* compute increments of the dual objective at all break-points
       * (relative to its value at teta = 0) */
      dz = 0.0;      /* dual objective increment */
      v = fabs(r);   /* dual objective slope d zeta / d teta */
      for (t = 1; t <= num; t++)
      {  /* compute increment at current break-point */
         dz += v * (bp[t].teta - (t == 1 ? 0.0 : bp[t-1].teta));
         if (dz < 0.001)
         {  /* break-point with non-positive increment reached */
            num = t - 1;
            break;
         }
         bp[t].dz = dz;
         /* compute next slope on the right to current break-point */
         if (t < num)
         {  j = bp[t].j;
            k = head[m+j]; /* x[k] = xN[j] */
            xassert(-DBL_MAX < l[k] && l[k] < u[k] && u[k] < +DBL_MAX);
            v -= fabs(trow[j]) * (u[k] - l[k]);
         }
      }
done: return num;
}
#endif

/***********************************************************************
*  spy_ls_eval_bp - determine dual objective function break-points
*
*  This routine determines the dual objective function break-points.
*
*  The parameters lp, d, r, trow, and tol_piv have the same meaning as
*  for the routine spx_chuzc_std (see above).
*
*  The routine stores the break-points determined to the array elements
*  bp[1], ..., bp[nbp] in *arbitrary* order, where 0 <= nbp <= n-m is
*  the number of break-points returned by the routine on exit. */

int spy_ls_eval_bp(SPXLP *lp, const double d[/*1+n-m*/],
      double r, const double trow[/*1+n-m*/], double tol_piv,
      SPYBP bp[/*1+n-m*/])
{     int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k, t, nnn, nbp;
      double s, alfa, teta, teta_max;
      xassert(r != 0.0);
      s = (r > 0.0 ? +1.0 : -1.0);
      /* build the list of all dual basic variables lambdaN[j] that
       * can reach zero on increasing the ray parameter teta >= 0 */
      nnn = 0, teta_max = DBL_MAX;
      /* walk thru the list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         /* if xN[j] is fixed variable, skip it */
         if (l[k] == u[k])
            continue;
         alfa = s * trow[j];
         if (alfa >= +tol_piv && !flag[j])
         {  /* xN[j] is either free or has its lower bound active, so
             * lambdaN[j] = d[j] >= 0 decreases down to zero */
            /* determine teta[j] on which lambdaN[j] reaches zero */
            teta = (d[j] < 0.0 ? 0.0 : d[j] / alfa);
            /* if xN[j] has no upper bound, lambdaN[j] cannot become
             * negative and thereby blocks further increasing teta */
            if (u[k] == +DBL_MAX && teta_max > teta)
               teta_max = teta;
         }
         else if (alfa <= -tol_piv && (l[k] == -DBL_MAX || flag[j]))
         {  /* xN[j] is either free or has its upper bound active, so
             * lambdaN[j] = d[j] <= 0 increases up to zero */
            /* determine teta[j] on which lambdaN[j] reaches zero */
            teta = (d[j] > 0.0 ? 0.0 : d[j] / alfa);
            /* if xN[j] has no lower bound, lambdaN[j] cannot become
             * positive and thereby blocks further increasing teta */
            if (l[k] == -DBL_MAX && teta_max > teta)
               teta_max = teta;
         }
         else
         {  /* lambdaN[j] cannot reach zero on increasing teta */
            continue;
         }
         /* add lambdaN[j] to the list */
         nnn++;
         bp[nnn].j = j;
         bp[nnn].teta = teta;
      }
      /* remove from the list all dual basic variables lambdaN[j], for
       * which teta[j] > teta_max */
      nbp = 0;
      for (t = 1; t <= nnn; t++)
      {  if (bp[t].teta <= teta_max + 1e-6)
         {  nbp++;
            bp[nbp].j = bp[t].j;
            bp[nbp].teta = bp[t].teta;
         }
      }
      return nbp;
}

/***********************************************************************
*  spy_ls_select_bp - select and process dual objective break-points
*
*  This routine selects a next portion of the dual objective function
*  break-points and processes them.
*
*  On entry to the routine it is assumed that break-points bp[1], ...,
*  bp[num] are already processed, and slope is the dual objective slope
*  to the right of the last processed break-point bp[num]. (Initially,
*  when num = 0, slope should be specified as fabs(r), where r has the
*  same meaning as above.)
*
*  The routine selects break-points among bp[num+1], ..., bp[nbp], for
*  which teta <= teta_lim, and moves these break-points to the array
*  elements bp[num+1], ..., bp[num1], where num <= num1 <= n-m is the
*  new number of processed break-points returned by the routine on
*  exit. Then the routine sorts these break-points by ascending teta
*  and computes the change of the dual objective function relative to
*  its value at teta = 0.
*
*  On exit the routine also replaces the parameter slope with a new
*  value that corresponds to the new last break-point bp[num1]. */

static int CDECL fcmp(const void *v1, const void *v2)
{     const SPYBP *p1 = v1, *p2 = v2;
      if (p1->teta < p2->teta)
         return -1;
      else if (p1->teta > p2->teta)
         return +1;
      else
         return 0;
}

int spy_ls_select_bp(SPXLP *lp, const double trow[/*1+n-m*/],
      int nbp, SPYBP bp[/*1+n-m*/], int num, double *slope, double
      teta_lim)
{     int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int j, k, t, num1;
      double teta, dz;
      xassert(0 <= num && num <= nbp && nbp <= n-m);
      /* select a new portion of break-points */
      num1 = num;
      for (t = num+1; t <= nbp; t++)
      {  if (bp[t].teta <= teta_lim)
         {  /* move break-point to the beginning of the new portion */
            num1++;
            j = bp[num1].j, teta = bp[num1].teta;
            bp[num1].j = bp[t].j, bp[num1].teta = bp[t].teta;
            bp[t].j = j, bp[t].teta = teta;
         }
      }
      /* sort new break-points bp[num+1], ..., bp[num1] by ascending
       * the ray parameter teta */
      if (num1 - num > 1)
         qsort(&bp[num+1], num1 - num, sizeof(SPYBP), fcmp);
      /* calculate the dual objective change at the new break-points */
      for (t = num+1; t <= num1; t++)
      {  /* calculate the dual objective change relative to its value
          * at break-point bp[t-1] */
         if (*slope == -DBL_MAX)
            dz = -DBL_MAX;
         else
            dz = (*slope) *
               (bp[t].teta - (t == 1 ? 0.0 : bp[t-1].teta));
         /* calculate the dual objective change relative to its value
          * at teta = 0 */
         if (dz == -DBL_MAX)
            bp[t].dz = -DBL_MAX;
         else
            bp[t].dz = (t == 1 ? 0.0 : bp[t-1].dz) + dz;
         /* calculate a new slope of the dual objective to the right of
          * the current break-point bp[t] */
         if (*slope != -DBL_MAX)
         {  j = bp[t].j;
            k = head[m+j]; /* x[k] = xN[j] */
            if (l[k] == -DBL_MAX || u[k] == +DBL_MAX)
               *slope = -DBL_MAX; /* blocking break-point reached */
            else
            {  xassert(l[k] < u[k]);
               *slope -= fabs(trow[j]) * (u[k] - l[k]);
            }
         }
      }
      return num1;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spychuzc.h0000644000175100001710000000553600000000000025617 0ustar00runnerdocker00000000000000/* spychuzc.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2016 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPYCHUZC_H
#define SPYCHUZC_H

#include "spxlp.h"

#define spy_chuzc_std _glp_spy_chuzc_std
int spy_chuzc_std(SPXLP *lp, const double d[/*1+n-m*/],
#if 0 /* 14/III-2016 */
      double s, const double trow[/*1+n-m*/], double tol_piv,
#else
      double r, const double trow[/*1+n-m*/], double tol_piv,
#endif
      double tol, double tol1);
/* choose non-basic variable (dual textbook ratio test) */

#define spy_chuzc_harris _glp_spy_chuzc_harris
int spy_chuzc_harris(SPXLP *lp, const double d[/*1+n-m*/],
#if 0 /* 14/III-2016 */
      double s, const double trow[/*1+n-m*/], double tol_piv,
#else
      double r, const double trow[/*1+n-m*/], double tol_piv,
#endif
      double tol, double tol1);
/* choose non-basic variable (dual Harris' ratio test) */

typedef struct SPYBP SPYBP;

struct SPYBP
{     /* dual objective function break point */
      int j;
      /* dual basic variable lambdaN[j], 1 <= j <= n-m, that intersects
       * zero at this break point */
      double teta;
      /* ray parameter value, teta[j] >= 0, at this break point */
      double dz;
      /* increment, zeta[j] - zeta[0], of the dual objective function
       * at this break point */
};

#if 0 /* 23/III-2016 */
#define spy_eval_bp _glp_spy_eval_bp
int spy_eval_bp(SPXLP *lp, const double d[/*1+n-m*/],
      double r, const double trow[/*1+n-m*/], double tol_piv,
      SPYBP bp[/*1+n-m*/]);
/* determine dual objective function break-points */
#endif

#define spy_ls_eval_bp _glp_spy_ls_eval_bp
int spy_ls_eval_bp(SPXLP *lp, const double d[/*1+n-m*/],
      double r, const double trow[/*1+n-m*/], double tol_piv,
      SPYBP bp[/*1+n-m*/]);
/* determine dual objective function break-points */

#define spy_ls_select_bp _glp_spy_ls_select_bp
int spy_ls_select_bp(SPXLP *lp, const double trow[/*1+n-m*/],
      int nbp, SPYBP bp[/*1+n-m*/], int num, double *slope, double
      teta_lim);
/* select and process dual objective break-points */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spychuzr.c0000644000175100001710000003747400000000000025637 0ustar00runnerdocker00000000000000/* spychuzr.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#include "env.h"
#include "spychuzr.h"

/***********************************************************************
*  spy_chuzr_sel - select eligible basic variables
*
*  This routine selects eligible basic variables xB[i], whose value
*  beta[i] violates corresponding lower lB[i] or upper uB[i] bound.
*  Positive bound violation rp[i] = lb[i] - beta[i] > 0 is the reduced
*  cost of non-basic dual variable lambda^+B[i] >= 0, so increasing it
*  increases the dual objective. Similarly, negative bound violation
*  rn[i] = ub[i] - beta[i] < 0 is the reduced cost of non-basic dual
*  variable lambda^-B[i] <= 0, so decreasing it also increases the dual
*  objective.
*
*  Current values of basic variables should be placed in the array
*  locations beta[1], ..., beta[m].
*
*  Basic variable xB[i] is considered eligible, if:
*
*     beta[i] <= lB[i] - eps1[i], or
*
*     beta[i] >= uB[i] + eps2[i],
*
*  for
*
*     eps1[i] = tol + tol1 * |lB[i]|,
*
*     eps2[i] = tol + tol2 * |uB[i]|,
*
*  where lB[i] and uB[i] are, resp., lower and upper bounds of xB[i],
*  tol and tol1 are specified tolerances.
*
*  On exit the routine stores indices i of eligible basic variables
*  xB[i] to the array locations list[1], ..., list[num] and returns the
*  number of such variables 0 <= num <= m. (If the parameter list is
*  specified as NULL, no indices are stored.) */

int spy_chuzr_sel(SPXLP *lp, const double beta[/*1+m*/], double tol,
      double tol1, int list[/*1+m*/])
{     int m = lp->m;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, k, num;
      double lk, uk, eps;
      num = 0;
      /* walk thru list of basic variables */
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         lk = l[k], uk = u[k];
         /* check if xB[i] is eligible */
         if (beta[i] < lk)
         {  /* determine absolute tolerance eps1[i] */
            eps = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] < lk - eps)
            {  /* lower bound is violated */
               num++;
               if (list != NULL)
                  list[num] = i;
            }
         }
         else if (beta[i] > uk)
         {  /* determine absolute tolerance eps2[i] */
            eps = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] > uk + eps)
            {  /* upper bound is violated */
               num++;
               if (list != NULL)
                  list[num] = i;
            }
         }
      }
      return num;
}

/***********************************************************************
*  spy_chuzr_std - choose basic variable (dual Dantzig's rule)
*
*  This routine chooses most eligible basic variable xB[p] according
*  to dual Dantzig's ("standard") rule:
*
*     r[p] =   max  |r[i]|,
*            i in I
*
*            ( lB[i] - beta[i], if beta[i] < lB[i]
*            (
*     r[i] = { 0,               if lB[i] <= beta[i] <= uB[i]
*            (
*            ( uB[i] - beta[i], if beta[i] > uB[i]
*
*  where I <= {1, ..., m} is the set of indices of eligible basic
*  variables, beta[i] is current value of xB[i], lB[i] and uB[i] are,
*  resp., lower and upper bounds of xB[i], r[i] is bound violation.
*
*  Current values of basic variables should be placed in the array
*  locations beta[1], ..., beta[m].
*
*  Indices of eligible basic variables i in I should be placed in the
*  array locations list[1], ..., list[num], where num = |J| > 0 is the
*  total number of such variables.
*
*  On exit the routine returns p, the index of the basic variable xB[p]
*  chosen. */

int spy_chuzr_std(SPXLP *lp, const double beta[/*1+m*/], int num,
      const int list[])
{     int m = lp->m;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int i, k, p, t;
      double abs_ri, abs_rp;
      xassert(0 < num && num <= m);
      p = 0, abs_rp = -1.0;
      for (t = 1; t <= num; t++)
      {  i = list[t];
         k = head[i]; /* x[k] = xB[i] */
         if (beta[i] < l[k])
            abs_ri = l[k] - beta[i];
         else if (beta[i] > u[k])
            abs_ri = beta[i] - u[k];
         else
            xassert(t != t);
         if (abs_rp < abs_ri)
            p = i, abs_rp = abs_ri;
      }
      xassert(p != 0);
      return p;
}

/***********************************************************************
*  spy_alloc_se - allocate dual pricing data block
*
*  This routine allocates the memory for arrays used in the dual
*  pricing data block. */

void spy_alloc_se(SPXLP *lp, SPYSE *se)
{     int m = lp->m;
      int n = lp->n;
#if 1 /* 30/III-2016 */
      int i;
#endif
      se->valid = 0;
      se->refsp = talloc(1+n, char);
      se->gamma = talloc(1+m, double);
      se->work = talloc(1+m, double);
#if 1 /* 30/III-2016 */
      se->u.n = m;
      se->u.nnz = 0;
      se->u.ind = talloc(1+m, int);
      se->u.vec = talloc(1+m, double);
      for (i = 1; i <= m; i++)
         se->u.vec[i] = 0.0;
#endif
      return;
}

/***********************************************************************
*  spy_reset_refsp - reset dual reference space
*
*  This routine resets (re-initializes) the dual reference space
*  composing it from dual variables which are non-basic (corresponding
*  to basic primal variables) in the current basis, and sets all
*  weights gamma[i] to 1. */

void spy_reset_refsp(SPXLP *lp, SPYSE *se)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *gamma = se->gamma;
      int i, k;
      se->valid = 1;
      memset(&refsp[1], 0, n * sizeof(char));
      for (i = 1; i <= m; i++)
      {  k = head[i]; /* x[k] = xB[i] */
         refsp[k] = 1;
         gamma[i] = 1.0;
      }
      return;
}

/***********************************************************************
*  spy_eval_gamma_i - compute dual proj. steepest edge weight directly
*
*  This routine computes dual projected steepest edge weight gamma[i],
*  1 <= i <= m, for the current basis directly with the formula:
*
*                           n-m
*     gamma[i] = delta[i] + sum eta[j] * T[i,j]**2,
*                           j=1
*
*  where T[i,j] is element of the current simplex table, and
*
*                ( 1, if lambdaN[j] is in the reference space
*     eta[j]   = {
*                ( 0, otherwise
*
*                ( 1, if lambdaB[i] is in the reference space
*     delta[i] = {
*                ( 0, otherwise
*
*  Dual basic variable lambdaN[j] corresponds to primal non-basic
*  variable xN[j], and dual non-basic variable lambdaB[j] corresponds
*  to primal basic variable xB[i].
*
*  NOTE: For testing/debugging only. */

double spy_eval_gamma_i(SPXLP *lp, SPYSE *se, int i)
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *rho = se->work;
      int j, k;
      double gamma_i, t_ij;
      xassert(se->valid);
      xassert(1 <= i && i <= m);
      k = head[i]; /* x[k] = xB[i] */
      gamma_i = (refsp[k] ? 1.0 : 0.0);
      spx_eval_rho(lp, i, rho);
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (refsp[k])
         {  t_ij = spx_eval_tij(lp, rho, j);
            gamma_i += t_ij * t_ij;
         }
      }
      return gamma_i;
}

/***********************************************************************
*  spy_chuzr_pse - choose basic variable (dual projected steepest edge)
*
*  This routine chooses most eligible basic variable xB[p] according
*  to the dual projected steepest edge method:
*
*      r[p]**2           r[i]**2
*     -------- =   max  -------- ,
*     gamma[p]   i in I gamma[i]
*
*            ( lB[i] - beta[i], if beta[i] < lB[i]
*            (
*     r[i] = { 0,               if lB[i] <= beta[i] <= uB[i]
*            (
*            ( uB[i] - beta[i], if beta[i] > uB[i]
*
*  where I <= {1, ..., m} is the set of indices of eligible basic
*  variables, beta[i] is current value of xB[i], lB[i] and uB[i] are,
*  resp., lower and upper bounds of xB[i], r[i] is bound violation.
*
*  Current values of basic variables should be placed in the array
*  locations beta[1], ..., beta[m].
*
*  Indices of eligible basic variables i in I should be placed in the
*  array locations list[1], ..., list[num], where num = |J| > 0 is the
*  total number of such variables.
*
*  On exit the routine returns p, the index of the basic variable xB[p]
*  chosen. */

int spy_chuzr_pse(SPXLP *lp, SPYSE *se, const double beta[/*1+m*/],
      int num, const int list[])
{     int m = lp->m;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      double *gamma = se->gamma;
      int i, k, p, t;
      double best, ri, temp;
      xassert(0 < num && num <= m);
      p = 0, best = -1.0;
      for (t = 1; t <= num; t++)
      {  i = list[t];
         k = head[i]; /* x[k] = xB[i] */
         if (beta[i] < l[k])
            ri = l[k] - beta[i];
         else if (beta[i] > u[k])
            ri = u[k] - beta[i];
         else
            xassert(t != t);
         /* FIXME */
         if (gamma[i] < DBL_EPSILON)
            temp = 0.0;
         else
            temp = (ri * ri) / gamma[i];
         if (best < temp)
            p = i, best = temp;
      }
      xassert(p != 0);
      return p;
}

/***********************************************************************
*  spy_update_gamma - update dual proj. steepest edge weights exactly
*
*  This routine updates the vector gamma = (gamma[i]) of dual projected
*  steepest edge weights exactly, for the adjacent basis.
*
*  On entry to the routine the content of the se object should be valid
*  and should correspond to the current basis.
*
*  The parameter 1 <= p <= m specifies basic variable xB[p] which
*  becomes non-basic variable xN[q] in the adjacent basis.
*
*  The parameter 1 <= q <= n-m specified non-basic variable xN[q] which
*  becomes basic variable xB[p] in the adjacent basis.
*
*  It is assumed that the array trow contains elements of p-th (pivot)
*  row T'[p] of the simplex table in locations trow[1], ..., trow[n-m].
*  It is also assumed that the array tcol contains elements of q-th
*  (pivot) column T[q] of the simple table in locations tcol[1], ...,
*  tcol[m]. (These row and column should be computed for the current
*  basis.)
*
*  For details about the formulae used see the program documentation.
*
*  The routine also computes the relative error:
*
*     e = |gamma[p] - gamma'[p]| / (1 + |gamma[p]|),
*
*  where gamma'[p] is the weight for lambdaB[p] (which is dual
*  non-basic variable corresponding to xB[p]) on entry to the routine,
*  and returns e on exit. (If e happens to be large enough, the calling
*  program may reset the reference space, since other weights also may
*  be inaccurate.) */

double spy_update_gamma(SPXLP *lp, SPYSE *se, int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/])
{     int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *gamma = se->gamma;
      double *u = se->work;
      int i, j, k, ptr, end;
      double gamma_p, delta_p, e, r, t1, t2;
      xassert(se->valid);
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n-m);
      /* compute gamma[p] in current basis more accurately; also
       * compute auxiliary vector u */
      k = head[p]; /* x[k] = xB[p] */
      gamma_p = delta_p = (refsp[k] ? 1.0 : 0.0);
      for (i = 1; i <= m; i++)
         u[i] = 0.0;
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (refsp[k] && trow[j] != 0.0)
         {  gamma_p += trow[j] * trow[j];
            /* u := u + T[p,j] * N[j], where N[j] = A[k] is constraint
             * matrix column corresponding to xN[j] */
            ptr = lp->A_ptr[k];
            end = lp->A_ptr[k+1];
            for (; ptr < end; ptr++)
               u[lp->A_ind[ptr]] += trow[j] * lp->A_val[ptr];
         }
      }
      bfd_ftran(lp->bfd, u);
      /* compute relative error in gamma[p] */
      e = fabs(gamma_p - gamma[p]) / (1.0 + gamma_p);
      /* compute new gamma[p] */
      gamma[p] = gamma_p / (tcol[p] * tcol[p]);
      /* compute new gamma[i] for all i != p */
      for (i = 1; i <= m; i++)
      {  if (i == p)
            continue;
         /* compute r[i] = T[i,q] / T[p,q] */
         r = tcol[i] / tcol[p];
         /* compute new gamma[i] */
         t1 = gamma[i] + r * (r * gamma_p + u[i] + u[i]);
         k = head[i]; /* x[k] = xB[i] */
         t2 = (refsp[k] ? 1.0 : 0.0) + delta_p * r * r;
         gamma[i] = (t1 >= t2 ? t1 : t2);
      }
      return e;
}

#if 1 /* 30/III-2016 */
double spy_update_gamma_s(SPXLP *lp, SPYSE *se, int p, int q,
      const FVS *trow, const FVS *tcol)
{     /* sparse version of spy_update_gamma */
      int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *refsp = se->refsp;
      double *gamma = se->gamma;
      double *u = se->work;
      int trow_nnz = trow->nnz;
      int *trow_ind = trow->ind;
      double *trow_vec = trow->vec;
      int tcol_nnz = tcol->nnz;
      int *tcol_ind = tcol->ind;
      double *tcol_vec = tcol->vec;
      int i, j, k, t, ptr, end;
      double gamma_p, delta_p, e, r, t1, t2;
      xassert(se->valid);
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n-m);
      /* compute gamma[p] in current basis more accurately; also
       * compute auxiliary vector u */
      k = head[p]; /* x[k] = xB[p] */
      gamma_p = delta_p = (refsp[k] ? 1.0 : 0.0);
      for (i = 1; i <= m; i++)
         u[i] = 0.0;
      for (t = 1; t <= trow_nnz; t++)
      {  j = trow_ind[t];
         k = head[m+j]; /* x[k] = xN[j] */
         if (refsp[k])
         {  gamma_p += trow_vec[j] * trow_vec[j];
            /* u := u + T[p,j] * N[j], where N[j] = A[k] is constraint
             * matrix column corresponding to xN[j] */
            ptr = lp->A_ptr[k];
            end = lp->A_ptr[k+1];
            for (; ptr < end; ptr++)
               u[lp->A_ind[ptr]] += trow_vec[j] * lp->A_val[ptr];
         }
      }
      bfd_ftran(lp->bfd, u);
      /* compute relative error in gamma[p] */
      e = fabs(gamma_p - gamma[p]) / (1.0 + gamma_p);
      /* compute new gamma[p] */
      gamma[p] = gamma_p / (tcol_vec[p] * tcol_vec[p]);
      /* compute new gamma[i] for all i != p */
      for (t = 1; t <= tcol_nnz; t++)
      {  i = tcol_ind[t];
         if (i == p)
            continue;
         /* compute r[i] = T[i,q] / T[p,q] */
         r = tcol_vec[i] / tcol_vec[p];
         /* compute new gamma[i] */
         t1 = gamma[i] + r * (r * gamma_p + u[i] + u[i]);
         k = head[i]; /* x[k] = xB[i] */
         t2 = (refsp[k] ? 1.0 : 0.0) + delta_p * r * r;
         gamma[i] = (t1 >= t2 ? t1 : t2);
      }
      return e;
}
#endif

/***********************************************************************
*  spy_free_se - deallocate dual pricing data block
*
*  This routine deallocates the memory used for arrays in the dual
*  pricing data block. */

void spy_free_se(SPXLP *lp, SPYSE *se)
{     xassert(lp == lp);
      tfree(se->refsp);
      tfree(se->gamma);
      tfree(se->work);
#if 1 /* 30/III-2016 */
      tfree(se->u.ind);
      tfree(se->u.vec);
#endif
      return;
}

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spychuzr.h0000644000175100001710000000645500000000000025637 0ustar00runnerdocker00000000000000/* spychuzr.h */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#ifndef SPYCHUZR_H
#define SPYCHUZR_H

#include "spxlp.h"

#define spy_chuzr_sel _glp_spy_chuzr_sel
int spy_chuzr_sel(SPXLP *lp, const double beta[/*1+m*/], double tol,
      double tol1, int list[/*1+m*/]);
/* select eligible basic variables */

#define spy_chuzr_std _glp_spy_chuzr_std
int spy_chuzr_std(SPXLP *lp, const double beta[/*1+m*/], int num,
      const int list[]);
/* choose basic variable (dual Dantzig's rule) */

typedef struct SPYSE SPYSE;

struct SPYSE
{     /* dual projected steepest edge and Devex pricing data block */
      int valid;
      /* content validity flag */
      char *refsp; /* char refsp[1+n]; */
      /* refsp[0] is not used;
       * refsp[k], 1 <= k <= n, is the flag meaning that dual variable
       * lambda[k] is in the dual reference space */
      double *gamma; /* double gamma[1+m]; */
      /* gamma[0] is not used;
       * gamma[i], 1 <= i <= m, is the weight for reduced cost r[i]
       * of dual non-basic variable lambdaB[j] in the current basis
       * (r[i] is bound violation for basic variable xB[i]) */
      double *work; /* double work[1+m]; */
      /* working array */
#if 1 /* 30/III-2016 */
      FVS u; /* FVS u[1:m]; */
      /* working vector */
#endif
};

#define spy_alloc_se _glp_spy_alloc_se
void spy_alloc_se(SPXLP *lp, SPYSE *se);
/* allocate dual pricing data block */

#define spy_reset_refsp _glp_spy_reset_refsp
void spy_reset_refsp(SPXLP *lp, SPYSE *se);
/* reset dual reference space */

#define spy_eval_gamma_i _glp_spy_eval_gamma_i
double spy_eval_gamma_i(SPXLP *lp, SPYSE *se, int i);
/* compute dual projected steepest edge weight directly */

#define spy_chuzr_pse _glp_spy_chuzr_pse
int spy_chuzr_pse(SPXLP *lp, SPYSE *se, const double beta[/*1+m*/],
      int num, const int list[]);
/* choose basic variable (dual projected steepest edge) */

#define spy_update_gamma _glp_spy_update_gamma
double spy_update_gamma(SPXLP *lp, SPYSE *se, int p, int q,
      const double trow[/*1+n-m*/], const double tcol[/*1+m*/]);
/* update dual projected steepest edge weights exactly */

#if 1 /* 30/III-2016 */
#define spy_update_gamma_s _glp_spy_update_gamma_s
double spy_update_gamma_s(SPXLP *lp, SPYSE *se, int p, int q,
      const FVS *trow, const FVS *tcol);
/* sparse version of spy_update_gamma */
#endif

#define spy_free_se _glp_spy_free_se
void spy_free_se(SPXLP *lp, SPYSE *se);
/* deallocate dual pricing data block */

#endif

/* eof */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/glpk/simplex/spydual.c0000644000175100001710000020557300000000000025426 0ustar00runnerdocker00000000000000/* spydual.c */

/***********************************************************************
*  This code is part of GLPK (GNU Linear Programming Kit).
*  Copyright (C) 2015-2017 Free Software Foundation, Inc.
*  Written by Andrew Makhorin .
*
*  GLPK is free software: you can redistribute it and/or modify it
*  under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  GLPK is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
*  License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with GLPK. If not, see .
***********************************************************************/

#if 1 /* 18/VII-2017 */
#define SCALE_Z 1
#endif

#include "env.h"
#include "simplex.h"
#include "spxat.h"
#include "spxnt.h"
#include "spxprob.h"
#include "spychuzc.h"
#include "spychuzr.h"
#if 0 /* 11/VI-2017 */
#if 1 /* 29/III-2016 */
#include "fvs.h"
#endif
#endif

#define CHECK_ACCURACY 0
/* (for debugging) */

struct csa
{     /* common storage area */
      SPXLP *lp;
      /* LP problem data and its (current) basis; this LP has m rows
       * and n columns */
      int dir;
      /* original optimization direction:
       * +1 - minimization
       * -1 - maximization */
#if SCALE_Z
      double fz;
      /* factor used to scale original objective */
#endif
      double *orig_b; /* double orig_b[1+m]; */
      /* copy of original right-hand sides */
      double *orig_c; /* double orig_c[1+n]; */
      /* copy of original objective coefficients */
      double *orig_l; /* double orig_l[1+n]; */
      /* copy of original lower bounds */
      double *orig_u; /* double orig_u[1+n]; */
      /* copy of original upper bounds */
      SPXAT *at;
      /* mxn-matrix A of constraint coefficients, in sparse row-wise
       * format (NULL if not used) */
      SPXNT *nt;
      /* mx(n-m)-matrix N composed of non-basic columns of constraint
       * matrix A, in sparse row-wise format (NULL if not used) */
      int phase;
      /* search phase:
       * 0 - not determined yet
       * 1 - searching for dual feasible solution
       * 2 - searching for optimal solution */
      double *beta; /* double beta[1+m]; */
      /* beta[i] is primal value of basic variable xB[i] */
      int beta_st;
      /* status of the vector beta:
       * 0 - undefined
       * 1 - just computed
       * 2 - updated */
      double *d; /* double d[1+n-m]; */
      /* d[j] is reduced cost of non-basic variable xN[j] */
      int d_st;
      /* status of the vector d:
       * 0 - undefined
       * 1 - just computed
       * 2 - updated */
      SPYSE *se;
      /* dual projected steepest edge and Devex pricing data block
       * (NULL if not used) */
#if 0 /* 30/III-2016 */
      int num;
      /* number of eligible basic variables */
      int *list; /* int list[1+m]; */
      /* list[1], ..., list[num] are indices i of eligible basic
       * variables xB[i] */
#else
      FVS r; /* FVS r[1:m]; */
      /* vector of primal infeasibilities */
      /* r->nnz = num; r->ind = list */
      /* vector r has the same status as vector beta (see above) */
#endif
      int p;
      /* xB[p] is a basic variable chosen to leave the basis */
#if 0 /* 29/III-2016 */
      double *trow; /* double trow[1+n-m]; */
#else
      FVS trow; /* FVS trow[1:n-m]; */
#endif
      /* p-th (pivot) row of the simplex table */
#if 1 /* 16/III-2016 */
      SPYBP *bp; /* SPYBP bp[1+n-m]; */
      /* dual objective break-points */
#endif
      int q;
      /* xN[q] is a non-basic variable chosen to enter the basis */
#if 0 /* 29/III-2016 */
      double *tcol; /* double tcol[1+m]; */
#else
      FVS tcol; /* FVS tcol[1:m]; */
#endif
      /* q-th (pivot) column of the simplex table */
      double *work; /* double work[1+m]; */
      /* working array */
      double *work1; /* double work1[1+n-m]; */
      /* another working array */
#if 0 /* 11/VI-2017 */
#if 1 /* 31/III-2016 */
      FVS wrow; /* FVS wrow[1:n-m]; */
      FVS wcol; /* FVS wcol[1:m]; */
      /* working sparse vectors */
#endif
#endif
      int p_stat, d_stat;
      /* primal and dual solution statuses */
      /*--------------------------------------------------------------*/
      /* control parameters (see struct glp_smcp) */
      int msg_lev;
      /* message level */
      int dualp;
      /* if this flag is set, report failure in case of instability */
#if 0 /* 16/III-2016 */
      int harris;
      /* dual ratio test technique:
       * 0 - textbook ratio test
       * 1 - Harris' two pass ratio test */
#else
      int r_test;
      /* dual ratio test technique:
       * GLP_RT_STD  - textbook ratio test
       * GLP_RT_HAR  - Harris' two pass ratio test
       * GLP_RT_FLIP - long-step (flip-flop) ratio test */
#endif
      double tol_bnd, tol_bnd1;
      /* primal feasibility tolerances */
      double tol_dj, tol_dj1;
      /* dual feasibility tolerances */
      double tol_piv;
      /* pivot tolerance */
      double obj_lim;
      /* objective limit */
      int it_lim;
      /* iteration limit */
      int tm_lim;
      /* time limit, milliseconds */
      int out_frq;
#if 0 /* 15/VII-2017 */
      /* display output frequency, iterations */
#else
      /* display output frequency, milliseconds */
#endif
      int out_dly;
      /* display output delay, milliseconds */
      /*--------------------------------------------------------------*/
      /* working parameters */
      double tm_beg;
      /* time value at the beginning of the search */
      int it_beg;
      /* simplex iteration count at the beginning of the search */
      int it_cnt;
      /* simplex iteration count; it increases by one every time the
       * basis changes */
      int it_dpy;
      /* simplex iteration count at most recent display output */
#if 1 /* 15/VII-2017 */
      double tm_dpy;
      /* time value at most recent display output */
#endif
      int inv_cnt;
      /* basis factorization count since most recent display output */
#if 1 /* 11/VII-2017 */
      int degen;
      /* count of successive degenerate iterations; this count is used
       * to detect stalling */
#endif
#if 1 /* 23/III-2016 */
      int ns_cnt, ls_cnt;
      /* normal and long-step iteration count */
#endif
};

/***********************************************************************
*  check_flags - check correctness of active bound flags
*
*  This routine checks that flags specifying active bounds of all
*  non-basic variables are correct.
*
*  NOTE: It is important to note that if bounds of variables have been
*  changed, active bound flags should be corrected accordingly. */

static void check_flags(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      int j, k;
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == -DBL_MAX && u[k] == +DBL_MAX)
            xassert(!flag[j]);
         else if (l[k] != -DBL_MAX && u[k] == +DBL_MAX)
            xassert(!flag[j]);
         else if (l[k] == -DBL_MAX && u[k] != +DBL_MAX)
            xassert(flag[j]);
         else if (l[k] == u[k])
            xassert(!flag[j]);
      }
      return;
}

/***********************************************************************
*  set_art_bounds - set artificial right-hand sides and bounds
*
*  This routine sets artificial right-hand sides and artificial bounds
*  for all variables to minimize the sum of dual infeasibilities on
*  phase I. Given current reduced costs d = (d[j]) this routine also
*  sets active artificial bounds of non-basic variables to provide dual
*  feasibility (this is always possible because all variables have both
*  lower and upper artificial bounds). */

static void set_art_bounds(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *b = lp->b;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      double *d = csa->d;
      int i, j, k;
#if 1 /* 31/III-2016: FIXME */
      /* set artificial right-hand sides */
      for (i = 1; i <= m; i++)
         b[i] = 0.0;
      /* set artificial bounds depending on types of variables */
      for (k = 1; k <= n; k++)
      {  if (csa->orig_l[k] == -DBL_MAX && csa->orig_u[k] == +DBL_MAX)
         {  /* force free variables to enter the basis */
            l[k] = -1e3, u[k] = +1e3;
         }
      else if (csa->orig_l[k] != -DBL_MAX && csa->orig_u[k] == +DBL_MAX)
            l[k] = 0.0, u[k] = +1.0;
      else if (csa->orig_l[k] == -DBL_MAX && csa->orig_u[k] != +DBL_MAX)
            l[k] = -1.0, u[k] = 0.0;
         else
            l[k] = u[k] = 0.0;
      }
#endif
      /* set active artificial bounds for non-basic variables */
      xassert(csa->d_st == 1);
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         flag[j] = (l[k] != u[k] && d[j] < 0.0);
      }
      /* invalidate values of basic variables, since active bounds of
       * non-basic variables have been changed */
      csa->beta_st = 0;
      return;
}

/***********************************************************************
*  set_orig_bounds - restore original right-hand sides and bounds
*
*  This routine restores original right-hand sides and original bounds
*  for all variables. This routine also sets active original bounds for
*  non-basic variables; for double-bounded non-basic variables current
*  reduced costs d = (d[j]) are used to decide which bound (lower or
*  upper) should be made active. */

static void set_orig_bounds(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *b = lp->b;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      double *d = csa->d;
      int j, k;
      /* restore original right-hand sides */
      memcpy(b, csa->orig_b, (1+m) * sizeof(double));
      /* restore original bounds of all variables */
      memcpy(l, csa->orig_l, (1+n) * sizeof(double));
      memcpy(u, csa->orig_u, (1+n) * sizeof(double));
      /* set active original bounds for non-basic variables */
      xassert(csa->d_st == 1);
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == -DBL_MAX && u[k] == +DBL_MAX)
            flag[j] = 0;
         else if (l[k] != -DBL_MAX && u[k] == +DBL_MAX)
            flag[j] = 0;
         else if (l[k] == -DBL_MAX && u[k] != +DBL_MAX)
            flag[j] = 1;
         else if (l[k] != u[k])
            flag[j] = (d[j] < 0.0);
         else
            flag[j] = 0;
      }
      /* invalidate values of basic variables, since active bounds of
       * non-basic variables have been changed */
      csa->beta_st = 0;
      return;
}

/***********************************************************************
*  check_feas - check dual feasibility of basic solution
*
*  This routine checks that reduced costs of all non-basic variables
*  d = (d[j]) have correct signs.
*
*  Reduced cost d[j] is considered as having correct sign within the
*  specified tolerance depending on status of non-basic variable xN[j]
*  if one of the following conditions is met:
*
*     xN[j] is free                       -eps <= d[j] <= +eps
*
*     xN[j] has its lower bound active    d[j] >= -eps
*
*     xN[j] has its upper bound active    d[j] <= +eps
*
*     xN[j] is fixed                      d[j] has any value
*
*  where eps = tol + tol1 * |cN[j]|, cN[j] is the objective coefficient
*  at xN[j]. (See also the routine spx_chuzc_sel.)
*
*  The flag recov allows the routine to recover dual feasibility by
*  changing active bounds of non-basic variables. (For example, if
*  xN[j] has its lower bound active and d[j] < -eps, the feasibility
*  can be recovered by making xN[j] active on its upper bound.)
*
*  If the basic solution is dual feasible, the routine returns zero.
*  If the basic solution is dual infeasible, but its dual feasibility
*  can be recovered (or has been recovered, if the flag recov is set),
*  the routine returns a negative value. Otherwise, the routine returns
*  the number j of some non-basic variable xN[j], whose reduced cost
*  d[j] is dual infeasible and cannot be recovered. */

static int check_feas(struct csa *csa, double tol, double tol1,
      int recov)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      double *d = csa->d;
      int j, k, ret = 0;
      double eps;
      /* reduced costs should be just computed */
      xassert(csa->d_st == 1);
      /* walk thru list of non-basic variables */
      for (j = 1; j <= n-m; j++)
      {  k = head[m+j]; /* x[k] = xN[j] */
         if (l[k] == u[k])
         {  /* xN[j] is fixed variable; skip it */
            continue;
         }
         /* determine absolute tolerance eps[j] */
         eps = tol + tol1 * (c[k] >= 0.0 ? +c[k] : -c[k]);
         /* check dual feasibility of xN[j] */
         if (d[j] > +eps)
         {  /* xN[j] should have its lower bound active */
            if (l[k] == -DBL_MAX || flag[j])
            {  /* but it either has no lower bound or its lower bound
                * is inactive */
               if (l[k] == -DBL_MAX)
               {  /* cannot recover, since xN[j] has no lower bound */
                  ret = j;
                  break;
               }
               /* recovering is possible */
               if (recov)
                  flag[j] = 0;
               ret = -1;
            }
         }
         else if (d[j] < -eps)
         {  /* xN[j] should have its upper bound active */
            if (!flag[j])
            {  /* but it either has no upper bound or its upper bound
                * is inactive */
               if (u[k] == +DBL_MAX)
               {  /* cannot recover, since xN[j] has no upper bound */
                  ret = j;
                  break;
               }
               /* recovering is possible */
               if (recov)
                  flag[j] = 1;
               ret = -1;
            }
         }
      }
      if (recov && ret)
      {  /* invalidate values of basic variables, since active bounds
          * of non-basic variables have been changed */
         csa->beta_st = 0;
      }
      return ret;
}

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_vec - compute maximal relative error between two vectors
*
*  This routine computes and returns maximal relative error between
*  n-vectors x and y:
*
*     err_max = max |x[i] - y[i]| / (1 + |x[i]|).
*
*  NOTE: This routine is intended only for debugging purposes. */

static double err_in_vec(int n, const double x[], const double y[])
{     int i;
      double err, err_max;
      err_max = 0.0;
      for (i = 1; i <= n; i++)
      {  err = fabs(x[i] - y[i]) / (1.0 + fabs(x[i]));
         if (err_max < err)
            err_max = err;
      }
      return err_max;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_beta - compute maximal relative error in vector beta
*
*  This routine computes and returns maximal relative error in vector
*  of values of basic variables beta = (beta[i]).
*
*  NOTE: This routine is intended only for debugging purposes. */

static double err_in_beta(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      double err, *beta;
      beta = talloc(1+m, double);
      spx_eval_beta(lp, beta);
      err = err_in_vec(m, beta, csa->beta);
      tfree(beta);
      return err;
}
#endif

#if CHECK_ACCURACY
static double err_in_r(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int i, k;
      double err, *r;
      r = talloc(1+m, double);
      for (i = 1; i <= m; i++)
      {  k = lp->head[i];
         if (csa->beta[i] < lp->l[k])
            r[i] = lp->l[k] - csa->beta[i];
         else if (csa->beta[i] > lp->u[k])
            r[i] = lp->u[k] - csa->beta[i];
         else
            r[i] = 0.0;

if (fabs(r[i] - csa->r.vec[i]) > 1e-6)
printf("i = %d; r = %g; csa->r = %g\n", i, r[i], csa->r.vec[i]);


      }
      err = err_in_vec(m, r, csa->r.vec);
      tfree(r);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_d - compute maximal relative error in vector d
*
*  This routine computes and returns maximal relative error in vector
*  of reduced costs of non-basic variables d = (d[j]).
*
*  NOTE: This routine is intended only for debugging purposes. */

static double err_in_d(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      int j;
      double err, *pi, *d;
      pi = talloc(1+m, double);
      d = talloc(1+n-m, double);
      spx_eval_pi(lp, pi);
      for (j = 1; j <= n-m; j++)
         d[j] = spx_eval_dj(lp, pi, j);
      err = err_in_vec(n-m, d, csa->d);
      tfree(pi);
      tfree(d);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  err_in_gamma - compute maximal relative error in vector gamma
*
*  This routine computes and returns maximal relative error in vector
*  of projected steepest edge weights gamma = (gamma[j]).
*
*  NOTE: This routine is intended only for debugging purposes. */

static double err_in_gamma(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      SPYSE *se = csa->se;
      int i;
      double err, *gamma;
      xassert(se != NULL);
gamma = talloc(1+m, double);
      for (i = 1; i <= m; i++)
         gamma[i] = spy_eval_gamma_i(lp, se, i);
      err = err_in_vec(m, gamma, se->gamma);
      tfree(gamma);
      return err;
}
#endif

#if CHECK_ACCURACY
/***********************************************************************
*  check_accuracy - check accuracy of basic solution components
*
*  This routine checks accuracy of current basic solution components.
*
*  NOTE: This routine is intended only for debugging purposes. */

static void check_accuracy(struct csa *csa)
{     double e_beta, e_r, e_d, e_gamma;
      e_beta = err_in_beta(csa);
      e_r = err_in_r(csa);
      e_d = err_in_d(csa);
      if (csa->se == NULL)
         e_gamma = 0.;
      else
         e_gamma = err_in_gamma(csa);
      xprintf("e_beta = %10.3e; e_r = %10.3e; e_d = %10.3e; e_gamma = %"
         "10.3e\n", e_beta, e_r, e_d, e_gamma);
      xassert(e_beta <= 1e-5 && e_d <= 1e-5 && e_gamma <= 1e-3);
      return;
}
#endif

#if 1 /* 30/III-2016 */
static
void spy_eval_r(SPXLP *lp, const double beta[/*1+m*/], double tol,
      double tol1, FVS *r)
{     /* this routine computes the vector of primal infeasibilities:
       *
       *        ( lB[i] - beta[i] > 0, if beta[i] < lb[i]
       * r[i] = { 0,                   if lb[i] <= beta[i] <= ub[i]
       *        ( ub[i] - beta[i] < 0, if beta[i] > ub[i]
       *
       * (this routine replaces spy_chuzr_sel) */
      int m = lp->m;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int *ind = r->ind;
      double *vec = r->vec;
      int i, k, nnz = 0;
      double lk, uk, eps;
      xassert(r->n == m);
      /* walk thru the list of basic variables */
      for (i = 1; i <= m; i++)
      {  vec[i] = 0.0;
         k = head[i]; /* x[k] = xB[i] */
         lk = l[k], uk = u[k];
         /* check primal feasibility */
         if (beta[i] < lk)
         {  /* determine absolute tolerance eps1[i] */
            eps = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] < lk - eps)
            {  /* lower bound is violated */
               ind[++nnz] = i;
               vec[i] = lk - beta[i];
            }
         }
         else if (beta[i] > uk)
         {  /* determine absolute tolerance eps2[i] */
            eps = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] > uk + eps)
            {  /* upper bound is violated */
               ind[++nnz] = i;
               vec[i] = uk - beta[i];
            }
         }
      }
      r->nnz = nnz;
      return;
}
#endif

/***********************************************************************
*  choose_pivot - choose xB[p] and xN[q]
*
*  Given the list of eligible basic variables this routine first
*  chooses basic variable xB[p]. This choice is always possible,
*  because the list is assumed to be non-empty. Then the routine
*  computes p-th row T[p,*] of the simplex table T[i,j] and chooses
*  non-basic variable xN[q]. If the pivot T[p,q] is small in magnitude,
*  the routine attempts to choose another xB[p] and xN[q] in order to
*  avoid badly conditioned adjacent bases.
*
*  If the normal choice was made, the routine returns zero. Otherwise,
*  if the long-step choice was made, the routine returns non-zero. */

#ifdef TIMING /* 31/III-2016 */

#include "choose_pivot.c"

#else

#define MIN_RATIO 0.0001

static int choose_pivot(struct csa *csa)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      SPXAT *at = csa->at;
      SPXNT *nt = csa->nt;
      double *beta = csa->beta;
      double *d = csa->d;
      SPYSE *se = csa->se;
#if 0 /* 30/III-2016 */
      int *list = csa->list;
#else
      int *list = csa->r.ind;
#endif
      double *rho = csa->work;
      double *trow = csa->work1;
      SPYBP *bp = csa->bp;
      double tol_piv = csa->tol_piv;
      int try, nnn, j, k, p, q, t, t_best, nbp, ret;
      double big, temp, r, best_ratio, dz_best;
      xassert(csa->beta_st);
      xassert(csa->d_st);
more: /* initial number of eligible basic variables */
#if 0 /* 30/III-2016 */
      nnn = csa->num;
#else
      nnn = csa->r.nnz;
#endif
      /* nothing has been chosen so far */
      csa->p = 0;
      best_ratio = 0.0;
      try = ret = 0;
try:  /* choose basic variable xB[p] */
      xassert(nnn > 0);
      try++;
      if (se == NULL)
      {  /* dual Dantzig's rule */
         p = spy_chuzr_std(lp, beta, nnn, list);
      }
      else
      {  /* dual projected steepest edge */
         p = spy_chuzr_pse(lp, se, beta, nnn, list);
      }
      xassert(1 <= p && p <= m);
      /* compute p-th row of inv(B) */
      spx_eval_rho(lp, p, rho);
      /* compute p-th row of the simplex table */
      if (at != NULL)
         spx_eval_trow1(lp, at, rho, trow);
      else
         spx_nt_prod(lp, nt, trow, 1, -1.0, rho);
#if 1 /* 23/III-2016 */
      /* big := max(1, |trow[1]|, ..., |trow[n-m]|) */
      big = 1.0;
      for (j = 1; j <= n-m; j++)
      {  temp = trow[j];
         if (temp < 0.0)
            temp = - temp;
         if (big < temp)
            big = temp;
      }
#else
      /* this still puzzles me */
      big = 1.0;
#endif
      /* choose non-basic variable xN[q] */
      k = head[p]; /* x[k] = xB[p] */
      xassert(beta[p] < l[k] || beta[p] > u[k]);
      r = beta[p] < l[k] ? l[k] - beta[p] : u[k] - beta[p];
      if (csa->r_test == GLP_RT_FLIP && try <= 2)
      {  /* long-step ratio test */
#if 0 /* 23/III-2016 */
         /* determine dual objective break-points */
         nbp = spy_eval_bp(lp, d, r, trow, tol_piv, bp);
         if (nbp <= 1)
            goto skip;
         /* choose appropriate break-point */
         t_best = 0, dz_best = -DBL_MAX;
         for (t = 1; t <= nbp; t++)
         {  if (fabs(trow[bp[t].j]) / big >= MIN_RATIO)
            {  if (dz_best < bp[t].dz)
                  t_best = t, dz_best = bp[t].dz;
            }
         }
         if (t_best == 0)
            goto skip;
#else
         int t, num, num1;
         double slope, teta_lim;
         /* determine dual objective break-points */
         nbp = spy_ls_eval_bp(lp, d, r, trow, tol_piv, bp);
         if (nbp < 2)
            goto skip;
         /* set initial slope */
         slope = fabs(r);
         /* estimate initial teta_lim */
         teta_lim = DBL_MAX;
         for (t = 1; t <= nbp; t++)
         {  if (teta_lim > bp[t].teta)
               teta_lim = bp[t].teta;
         }
         xassert(teta_lim >= 0.0);
         if (teta_lim < 1e-6)
            teta_lim = 1e-6;
         /* nothing has been chosen so far */
         t_best = 0, dz_best = 0.0, num = 0;
         /* choose appropriate break-point */
         while (num < nbp)
         {  /* select and process a new portion of break-points */
            num1 = spy_ls_select_bp(lp, trow, nbp, bp, num, &slope,
               teta_lim);
            for (t = num+1; t <= num1; t++)
            {  if (fabs(trow[bp[t].j]) / big >= MIN_RATIO)
               {  if (dz_best < bp[t].dz)
                     t_best = t, dz_best = bp[t].dz;
               }
            }
            if (slope < 0.0)
            {  /* the dual objective starts decreasing */
               break;
            }
            /* the dual objective continues increasing */
            num = num1;
            teta_lim += teta_lim;
         }
         if (dz_best == 0.0)
            goto skip;
         xassert(1 <= t_best && t_best <= num1);
#endif
         /* the choice has been made */
         csa->p = p;
#if 0 /* 29/III-2016 */
         memcpy(&csa->trow[1], &trow[1], (n-m) * sizeof(double));
#else
         memcpy(&csa->trow.vec[1], &trow[1], (n-m) * sizeof(double));
         fvs_gather_vec(&csa->trow, DBL_EPSILON);
#endif
         csa->q = bp[t_best].j;
         best_ratio = fabs(trow[bp[t_best].j]) / big;
#if 0
         xprintf("num = %d; t_best = %d; dz = %g\n", num, t_best,
            bp[t_best].dz);
#endif
         ret = 1;
         goto done;
skip:    ;
      }
      if (csa->r_test == GLP_RT_STD)
      {  /* textbook dual ratio test */
         q = spy_chuzc_std(lp, d, r, trow, tol_piv,
            .30 * csa->tol_dj, .30 * csa->tol_dj1);
      }
      else
      {  /* Harris' two-pass dual ratio test */
         q = spy_chuzc_harris(lp, d, r, trow, tol_piv,
            .35 * csa->tol_dj, .35 * csa->tol_dj1);
      }
      if (q == 0)
      {  /* dual unboundedness */
         csa->p = p;
#if 0 /* 29/III-2016 */
         memcpy(&csa->trow[1], &trow[1], (n-m) * sizeof(double));
#else
         memcpy(&csa->trow.vec[1], &trow[1], (n-m) * sizeof(double));
         fvs_gather_vec(&csa->trow, DBL_EPSILON);
#endif
         csa->q = q;
         best_ratio = 1.0;
         goto done;
      }
      /* either keep previous choice or accept new choice depending on
       * which one is better */
      if (best_ratio < fabs(trow[q]) / big)
      {  csa->p = p;
#if 0 /* 29/III-2016 */
         memcpy(&csa->trow[1], &trow[1], (n-m) * sizeof(double));
#else
         memcpy(&csa->trow.vec[1], &trow[1], (n-m) * sizeof(double));
         fvs_gather_vec(&csa->trow, DBL_EPSILON);
#endif
         csa->q = q;
         best_ratio = fabs(trow[q]) / big;
      }
      /* check if the current choice is acceptable */
      if (best_ratio >= MIN_RATIO || nnn == 1 || try == 5)
         goto done;
      /* try to choose other xB[p] and xN[q] */
      /* find xB[p] in the list */
      for (t = 1; t <= nnn; t++)
         if (list[t] == p) break;
      xassert(t <= nnn);
      /* move xB[p] to the end of the list */
      list[t] = list[nnn], list[nnn] = p;
      /* and exclude it from consideration */
      nnn--;
      /* repeat the choice */
      goto try;
done: /* the choice has been made */
#if 1 /* FIXME: currently just to avoid badly conditioned basis */
      if (best_ratio < .001 * MIN_RATIO)
      {  /* looks like this helps */
         if (bfd_get_count(lp->bfd) > 0)
            return -1;
         /* didn't help; last chance to improve the choice */
         if (tol_piv == csa->tol_piv)
         {  tol_piv *= 1000.;
            goto more;
         }
      }
#endif
#if 1 /* FIXME */
      if (ret)
      {  /* invalidate basic solution components */
#if 0 /* 28/III-2016 */
         csa->beta_st = csa->d_st = 0;
#else
         /* dual solution remains valid */
         csa->beta_st = 0;
#endif
         /* set double-bounded non-basic variables to opposite bounds
          * for all break-points preceding the chosen one */
         for (t = 1; t < t_best; t++)
         {  k = head[m + bp[t].j];
            xassert(-DBL_MAX < l[k] && l[k] < u[k] && u[k] < +DBL_MAX);
            lp->flag[bp[t].j] = !(lp->flag[bp[t].j]);
         }
      }
#endif
      return ret;
}

#endif

/***********************************************************************
*  play_coef - play objective coefficients
*
*  This routine is called after the reduced costs d[j] was updated and
*  the basis was changed to the adjacent one.
*
*  It is assumed that before updating all the reduced costs d[j] were
*  strongly feasible, so in the adjacent basis d[j] remain feasible
*  within a tolerance, i.e. if some d[j] violates its zero bound, the
*  violation is insignificant.
*
*  If some d[j] violates its zero bound, the routine changes (perturbs)
*  objective coefficient cN[j] to provide d[j] = 0, i.e. to make all
*  d[j] strongly feasible. Otherwise, if d[j] has a feasible value, the
*  routine attempts to reduce (or remove) perturbation in cN[j] by
*  shifting d[j] to its zero bound keeping strong feasibility. */

static void play_coef(struct csa *csa, int all)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *c = lp->c;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      char *flag = lp->flag;
      double *orig_c = csa->orig_c;
      double *d = csa->d;
      const double *trow = csa->trow.vec;
      /* this vector was used to update d = (d[j]) */
      int j, k;
      static const double eps = 1e-9;
      /* reduced costs d = (d[j]) should be valid */
      xassert(csa->d_st);
      /* walk thru the list of non-basic variables xN = (xN[j]) */
      for (j = 1; j <= n-m; j++)
      {  if (all || trow[j] != 0.0)
         {  /* d[j] has changed in the adjacent basis */
            k = head[m+j]; /* x[k] = xN[j] */
            if (l[k] == u[k])
            {  /* xN[j] is fixed variable */
               /* d[j] may have any sign */
            }
            else if (l[k] == -DBL_MAX && u[k] == +DBL_MAX)
            {  /* xN[j] is free (unbounded) variable */
               /* strong feasibility means d[j] = 0 */
               c[k] -= d[j], d[j] = 0.0;
               /* in this case dual degeneracy is not critical, since
                * if xN[j] enters the basis, it never leaves it */
            }
            else if (!flag[j])
            {  /* xN[j] has its lower bound active */
               xassert(l[k] != -DBL_MAX);
               /* first, we remove current perturbation to provide
                * c[k] = orig_c[k] */
               d[j] -= c[k] - orig_c[k], c[k] = orig_c[k];
               /* strong feasibility means d[j] >= 0, but we provide
                * d[j] >= +eps to prevent dual degeneracy */
               if (d[j] < +eps)
                  c[k] -= d[j] - eps, d[j] = +eps;
            }
            else
            {  /* xN[j] has its upper bound active */
               xassert(u[k] != +DBL_MAX);
               /* similarly, we remove current perturbation to provide
                * c[k] = orig_c[k] */
               d[j] -= c[k] - orig_c[k], c[k] = orig_c[k];
               /* strong feasibility means d[j] <= 0, but we provide
                * d[j] <= -eps to prevent dual degeneracy */
               if (d[j] > -eps)
                  c[k] -= d[j] + eps, d[j] = -eps;
            }
         }
      }
      return;
}

#if 1 /* 11/VII-2017 */
static void remove_perturb(struct csa *csa)
{     /* remove perturbation */
      SPXLP *lp = csa->lp;
      int n = lp->n;
      double *c = lp->c;
      double *orig_c = csa->orig_c;
      memcpy(c, orig_c, (1+n) * sizeof(double));
      /* removing perturbation changes dual solution components */
      csa->phase = csa->d_st = 0;
#if 1
      if (csa->msg_lev >= GLP_MSG_ALL)
         xprintf("Removing LP perturbation [%d]...\n",
            csa->it_cnt);
#endif
      return;
}
#endif

/***********************************************************************
*  display - display search progress
*
*  This routine displays some information about the search progress
*  that includes:
*
*  search phase;
*
*  number of simplex iterations performed by the solver;
*
*  original objective value (only on phase II);
*
*  sum of (scaled) dual infeasibilities for original bounds;
*
*  number of dual infeasibilities (phase I) or primal infeasibilities
*  (phase II);
*
*  number of basic factorizations since last display output. */

static void display(struct csa *csa, int spec)
{     SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      int *head = lp->head;
      char *flag = lp->flag;
      double *l = csa->orig_l; /* original lower bounds */
      double *u = csa->orig_u; /* original upper bounds */
      double *beta = csa->beta;
      double *d = csa->d;
      int j, k, nnn;
      double sum;
#if 1 /* 15/VII-2017 */
      double tm_cur;
#endif
      /* check if the display output should be skipped */
      if (csa->msg_lev < GLP_MSG_ON) goto skip;
#if 1 /* 15/VII-2017 */
      tm_cur = xtime();
#endif
      if (csa->out_dly > 0 &&
#if 0 /* 15/VII-2017 */
         1000.0 * xdifftime(xtime(), csa->tm_beg) < csa->out_dly)
#else
         1000.0 * xdifftime(tm_cur, csa->tm_beg) < csa->out_dly)
#endif
         goto skip;
      if (csa->it_cnt == csa->it_dpy) goto skip;
#if 0 /* 15/VII-2017 */
      if (!spec && csa->it_cnt % csa->out_frq != 0) goto skip;
#else
      if (!spec &&
         1000.0 * xdifftime(tm_cur, csa->tm_dpy) < csa->out_frq)
         goto skip;
#endif
      /* display search progress depending on search phase */
      switch (csa->phase)
      {  case 1:
            /* compute sum and number of (scaled) dual infeasibilities
             * for original bounds */
            sum = 0.0, nnn = 0;
            for (j = 1; j <= n-m; j++)
            {  k = head[m+j]; /* x[k] = xN[j] */
               if (d[j] > 0.0)
               {  /* xN[j] should have lower bound */
                  if (l[k] == -DBL_MAX)
                  {  sum += d[j];
                     if (d[j] > +1e-7)
                        nnn++;
                  }
               }
               else if (d[j] < 0.0)
               {  /* xN[j] should have upper bound */
                  if (u[k] == +DBL_MAX)
                  {  sum -= d[j];
                     if (d[j] < -1e-7)
                        nnn++;
                  }
               }
            }
            /* on phase I variables have artificial bounds which are
             * meaningless for original LP, so corresponding objective
             * function value is also meaningless */
#if 0 /* 27/III-2016 */
            xprintf(" %6d: %23s inf = %11.3e (%d)",
               csa->it_cnt, "", sum, nnn);
#else
            xprintf(" %6d: sum = %17.9e inf = %11.3e (%d)",
               csa->it_cnt, lp->c[0] - spx_eval_obj(lp, beta),
               sum, nnn);
#endif
            break;
         case 2:
            /* compute sum of (scaled) dual infeasibilities */
            sum = 0.0, nnn = 0;
            for (j = 1; j <= n-m; j++)
            {  k = head[m+j]; /* x[k] = xN[j] */
               if (d[j] > 0.0)
               {  /* xN[j] should have its lower bound active */
                  if (l[k] == -DBL_MAX || flag[j])
                     sum += d[j];
               }
               else if (d[j] < 0.0)
               {  /* xN[j] should have its upper bound active */
                  if (l[k] != u[k] && !flag[j])
                     sum -= d[j];
               }
            }
            /* compute number of primal infeasibilities */
            nnn = spy_chuzr_sel(lp, beta, csa->tol_bnd, csa->tol_bnd1,
               NULL);
            xprintf("#%6d: obj = %17.9e inf = %11.3e (%d)",
#if SCALE_Z
               csa->it_cnt,
               (double)csa->dir * csa->fz * spx_eval_obj(lp, beta),
#else
               csa->it_cnt, (double)csa->dir * spx_eval_obj(lp, beta),
#endif
               sum, nnn);
            break;
         default:
            xassert(csa != csa);
      }
      if (csa->inv_cnt)
      {  /* number of basis factorizations performed */
         xprintf(" %d", csa->inv_cnt);
         csa->inv_cnt = 0;
      }
#if 1 /* 23/III-2016 */
      if (csa->r_test == GLP_RT_FLIP)
      {  /*xprintf("   %d,%d", csa->ns_cnt, csa->ls_cnt);*/
         if (csa->ns_cnt + csa->ls_cnt)
            xprintf(" %d%%",
               (100 * csa->ls_cnt) / (csa->ns_cnt + csa->ls_cnt));
         csa->ns_cnt = csa->ls_cnt = 0;
      }
#endif
      xprintf("\n");
      csa->it_dpy = csa->it_cnt;
#if 1 /* 15/VII-2017 */
      csa->tm_dpy = tm_cur;
#endif
skip: return;
}

#if 1 /* 31/III-2016 */
static
void spy_update_r(SPXLP *lp, int p, int q, const double beta[/*1+m*/],
      const FVS *tcol, double tol, double tol1, FVS *r)
{     /* update vector r of primal infeasibilities */
      /* it is assumed that xB[p] leaves the basis, xN[q] enters the
       * basis, and beta corresponds to the adjacent basis (i.e. this
       * routine should be called after spx_update_beta) */
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      int *tcol_ind = tcol->ind;
      int *ind = r->ind;
      double *vec = r->vec;
      int i, k, t, nnz;
      double lk, uk, ri, eps;
      xassert(1 <= p && p <= m);
      xassert(1 <= q && q <= n-m);
      nnz = r->nnz;
      for (t = tcol->nnz; t >= 1; t--)
      {  i = tcol_ind[t];
         /* xB[i] changes in the adjacent basis to beta[i], so only
          * r[i] should be updated */
         if (i == p)
            k = head[m+q]; /* x[k] = new xB[p] = old xN[q] */
         else
            k = head[i];   /* x[k] = new xB[i] = old xB[i] */
         lk = l[k], uk = u[k];
         /* determine new value of r[i]; see spy_eval_r */
         ri = 0.0;
         if (beta[i] < lk)
         {  /* determine absolute tolerance eps1[i] */
            eps = tol + tol1 * (lk >= 0.0 ? +lk : -lk);
            if (beta[i] < lk - eps)
            {  /* lower bound is violated */
               ri = lk - beta[i];
            }
         }
         else if (beta[i] > uk)
         {  /* determine absolute tolerance eps2[i] */
            eps = tol + tol1 * (uk >= 0.0 ? +uk : -uk);
            if (beta[i] > uk + eps)
            {  /* upper bound is violated */
               ri = uk - beta[i];
            }
         }
         if (ri == 0.0)
         {  if (vec[i] != 0.0)
               vec[i] = DBL_MIN; /* will be removed */
         }
         else
         {  if (vec[i] == 0.0)
               ind[++nnz] = i;
            vec[i] = ri;
         }

      }
      r->nnz = nnz;
      /* remove zero elements */
      fvs_adjust_vec(r, DBL_MIN + DBL_MIN);
      return;
}
#endif

/***********************************************************************
*  spy_dual - driver to the dual simplex method
*
*  This routine is a driver to the two-phase dual simplex method.
*
*  On exit this routine returns one of the following codes:
*
*  0  LP instance has been successfully solved.
*
*  GLP_EOBJLL
*     Objective lower limit has been reached (maximization).
*
*  GLP_EOBJUL
*     Objective upper limit has been reached (minimization).
*
*  GLP_EITLIM
*     Iteration limit has been exhausted.
*
*  GLP_ETMLIM
*     Time limit has been exhausted.
*
*  GLP_EFAIL
*     The solver failed to solve LP instance. */

static int dual_simplex(struct csa *csa)
{     /* dual simplex method main logic routine */
      SPXLP *lp = csa->lp;
      int m = lp->m;
      int n = lp->n;
      double *l = lp->l;
      double *u = lp->u;
      int *head = lp->head;
      SPXNT *nt = csa->nt;
      double *beta = csa->beta;
      double *d = csa->d;
      SPYSE *se = csa->se;
#if 0 /* 30/III-2016 */
      int *list = csa->list;
#endif
#if 0 /* 31/III-2016 */
      double *trow = csa->trow;
      double *tcol = csa->tcol;
#endif
      double *pi = csa->work;
      int msg_lev = csa->msg_lev;
      double tol_bnd = csa->tol_bnd;
      double tol_bnd1 = csa->tol_bnd1;
      double tol_dj = csa->tol_dj;
      double tol_dj1 = csa->tol_dj1;
      int j, k, p_flag, refct, ret;
      int perturb = -1;
      /* -1 = perturbation is not used, but enabled
       *  0 = perturbation is not used and disabled
       * +1 = perturbation is being used */
#if 1 /* 27/III-2016 */
      int instab = 0; /* instability count */
#endif
#ifdef TIMING
      double t_total  = timer(); /* total time */
      double t_fact   = 0.0;     /* computing factorization */
      double t_rtest  = 0.0;     /* performing ratio test */
      double t_pivcol = 0.0;     /* computing pivot column */
      double t_upd1   = 0.0;     /* updating primal values */
      double t_upd2   = 0.0;     /* updating dual values */
      double t_upd3   = 0.0;     /* updating se weights */
      double t_upd4   = 0.0;     /* updating matrix N */
      double t_upd5   = 0.0;     /* updating factorization */
      double t_start;
#endif
      check_flags(csa);
loop: /* main loop starts here */
      /* compute factorization of the basis matrix */
      if (!lp->valid)
      {  double cond;
#ifdef TIMING
         t_start = timer();
#endif
         ret = spx_factorize(lp);
#ifdef TIMING
         t_fact += timer() - t_start;
#endif
         csa->inv_cnt++;
         if (ret != 0)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Error: unable to factorize the basis matrix (%d"
                  ")\n", ret);
            csa->p_stat = csa->d_stat = GLP_UNDEF;
            ret = GLP_EFAIL;
            goto fini;
         }
         /* check condition of the basis matrix */
         cond = bfd_condest(lp->bfd);
         if (cond > 1.0 / DBL_EPSILON)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Error: basis matrix is singular to working prec"
                  "ision (cond = %.3g)\n", cond);
            csa->p_stat = csa->d_stat = GLP_UNDEF;
            ret = GLP_EFAIL;
            goto fini;
         }
         if (cond > 0.001 / DBL_EPSILON)
         {  if (msg_lev >= GLP_MSG_ERR)
               xprintf("Warning: basis matrix is ill-conditioned (cond "
                  "= %.3g)\n", cond);
         }
         /* invalidate basic solution components */
         csa->beta_st = csa->d_st = 0;
      }
      /* compute reduced costs of non-basic variables d = (d[j]) */
      if (!csa->d_st)
      {  spx_eval_pi(lp, pi);
         for (j = 1; j <= n-m; j++)
            d[j] = spx_eval_dj(lp, pi, j);
         csa->d_st = 1; /* just computed */
         /* determine the search phase, if not determined yet (this is
          * performed only once at the beginning of the search for the
          * original bounds) */
         if (!csa->phase)
         {  j = check_feas(csa, 0.97 * tol_dj, 0.97 * tol_dj1, 1);
            if (j > 0)
            {  /* initial basic solution is dual infeasible and cannot
                * be recovered */
               /* start to search for dual feasible solution */
               set_art_bounds(csa);
               csa->phase = 1;
            }
            else
            {  /* initial basic solution is either dual feasible or its
                * dual feasibility has been recovered */
               /* start to search for optimal solution */
               csa->phase = 2;
            }
         }
         /* make sure that current basic solution is dual feasible */
#if 1 /* 11/VII-2017 */
         if (perturb <= 0)
         {  if (check_feas(csa, tol_dj, tol_dj1, 0))
            {  /* dual feasibility is broken due to excessive round-off
                * errors */
               if (perturb < 0)
               {  if (msg_lev >= GLP_MSG_ALL)
                     xprintf("Perturbing LP to avoid instability [%d].."
                        ".\n", csa->it_cnt);
                  perturb = 1;
                  goto loop;
               }
               if (msg_lev >= GLP_MSG_ERR)
                  xprintf("Warning: numerical instability (dual simplex"
                     ", phase %s)\n", csa->phase == 1 ? "I" : "II");
               instab++;
               if (csa->dualp && instab >= 10)
               {  /* do not continue the search; report failure */
                  if (msg_lev >= GLP_MSG_ERR)
                     xprintf("Warning: dual simplex failed due to exces"
                        "sive numerical instability\n");
                  csa->p_stat = csa->d_stat = GLP_UNDEF;
                  ret = -1; /* special case of GLP_EFAIL */
                  goto fini;
               }
               /* try to recover dual feasibility */
               j = check_feas(csa, 0.97 * tol_dj, 0.97 * tol_dj1, 1);
               if (j > 0)
               {  /* dual feasibility cannot be recovered (this may
                   * happen only on phase II) */
                  xassert(csa->phase == 2);
                  /* restart to search for dual feasible solution */
                  set_art_bounds(csa);
                  csa->phase = 1;
               }
            }
         }
         else
         {  /* FIXME */
            play_coef(csa, 1);
         }
      }
#endif
      /* at this point the search phase is determined */
      xassert(csa->phase == 1 || csa->phase == 2);
      /* compute values of basic variables beta = (beta[i]) */
      if (!csa->beta_st)
      {  spx_eval_beta(lp, beta);
#if 1 /* 31/III-2016 */
         /* also compute vector r of primal infeasibilities */
         switch (csa->phase)
         {  case 1:
               spy_eval_r(lp, beta, 1e-8, 0.0, &csa->r);
               break;
            case 2:
               spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
               break;
            default:
               xassert(csa != csa);
         }
#endif
         csa->beta_st = 1; /* just computed */
      }
      /* reset the dual reference space, if necessary */
      if (se != NULL && !se->valid)
         spy_reset_refsp(lp, se), refct = 1000;
      /* at this point the basis factorization and all basic solution
       * components are valid */
      xassert(lp->valid && csa->beta_st && csa->d_st);
#ifdef GLP_DEBUG
      check_flags(csa);
#endif
#if CHECK_ACCURACY
      /* check accuracy of current basic solution components (only for
       * debugging) */
      check_accuracy(csa);
#endif
      /* check if the objective limit has been reached */
      if (csa->phase == 2 && csa->obj_lim != DBL_MAX
         && spx_eval_obj(lp, beta) >= csa->obj_lim)
      {
#if 1 /* 26/V-2017 by mao */
         if (perturb > 0)
         {  /* remove perturbation */
            /* [Should note that perturbing of objective coefficients
             * implemented in play_coef is equivalent to *relaxing* of
             * (zero) bounds of dual variables, so the perturbed
             * objective is always better (*greater*) that the original
             * one at the same basic point.] */
            remove_perturb(csa);
            perturb = 0;
         }
#endif
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         if (msg_lev >= GLP_MSG_ALL)
            xprintf("OBJECTIVE %s LIMIT REACHED; SEARCH TERMINATED\n",
               csa->dir > 0 ? "UPPER" : "LOWER");
#if 0 /* 30/III-2016 */
         csa->num = spy_chuzr_sel(lp, beta, tol_bnd, tol_bnd1, list);
         csa->p_stat = (csa->num == 0 ? GLP_FEAS : GLP_INFEAS);
#else
         spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
         csa->p_stat = (csa->r.nnz == 0 ? GLP_FEAS : GLP_INFEAS);
#endif
         csa->d_stat = GLP_FEAS;
         ret = (csa->dir > 0 ? GLP_EOBJUL : GLP_EOBJLL);
         goto fini;
      }
      /* check if the iteration limit has been exhausted */
      if (csa->it_cnt - csa->it_beg >= csa->it_lim)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         if (msg_lev >= GLP_MSG_ALL)
            xprintf("ITERATION LIMIT EXCEEDED; SEARCH TERMINATED\n");
         if (csa->phase == 1)
         {  set_orig_bounds(csa);
            check_flags(csa);
            spx_eval_beta(lp, beta);
         }
#if 0 /* 30/III-2016 */
         csa->num = spy_chuzr_sel(lp, beta, tol_bnd, tol_bnd1, list);
         csa->p_stat = (csa->num == 0 ? GLP_FEAS : GLP_INFEAS);
#else
         spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
         csa->p_stat = (csa->r.nnz == 0 ? GLP_FEAS : GLP_INFEAS);
#endif
         csa->d_stat = (csa->phase == 1 ? GLP_INFEAS : GLP_FEAS);
         ret = GLP_EITLIM;
         goto fini;
      }
      /* check if the time limit has been exhausted */
      if (1000.0 * xdifftime(xtime(), csa->tm_beg) >= csa->tm_lim)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         if (msg_lev >= GLP_MSG_ALL)
            xprintf("TIME LIMIT EXCEEDED; SEARCH TERMINATED\n");
         if (csa->phase == 1)
         {  set_orig_bounds(csa);
            check_flags(csa);
            spx_eval_beta(lp, beta);
         }
#if 0 /* 30/III-2016 */
         csa->num = spy_chuzr_sel(lp, beta, tol_bnd, tol_bnd1, list);
         csa->p_stat = (csa->num == 0 ? GLP_FEAS : GLP_INFEAS);
#else
         spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
         csa->p_stat = (csa->r.nnz == 0 ? GLP_FEAS : GLP_INFEAS);
#endif
         csa->d_stat = (csa->phase == 1 ? GLP_INFEAS : GLP_FEAS);
         ret = GLP_ETMLIM;
         goto fini;
      }
      /* display the search progress */
      display(csa, 0);
      /* select eligible basic variables */
#if 0 /* 31/III-2016; not needed because r is valid */
      switch (csa->phase)
      {  case 1:
#if 0 /* 30/III-2016 */
            csa->num = spy_chuzr_sel(lp, beta, 1e-8, 0.0, list);
#else
            spy_eval_r(lp, beta, 1e-8, 0.0, &csa->r);
#endif
            break;
         case 2:
#if 0 /* 30/III-2016 */
            csa->num = spy_chuzr_sel(lp, beta, tol_bnd, tol_bnd1, list);
#else
            spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
#endif
            break;
         default:
            xassert(csa != csa);
      }
#endif
      /* check for optimality */
#if 0 /* 30/III-2016 */
      if (csa->num == 0)
#else
      if (csa->r.nnz == 0)
#endif
      {  if (perturb > 0 && csa->phase == 2)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         /* current basis is optimal */
         display(csa, 1);
         switch (csa->phase)
         {  case 1:
               /* check for dual feasibility */
               set_orig_bounds(csa);
               check_flags(csa);
               if (check_feas(csa, tol_dj, tol_dj1, 0) == 0)
               {  /* dual feasible solution found; switch to phase II */
                  csa->phase = 2;
                  xassert(!csa->beta_st);
                  goto loop;
               }
#if 1 /* 26/V-2017 by cmatraki */
               if (perturb > 0)
               {  /* remove perturbation */
                  remove_perturb(csa);
                  perturb = 0;
                  goto loop;
               }
#endif
               /* no dual feasible solution exists */
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("LP HAS NO DUAL FEASIBLE SOLUTION\n");
               spx_eval_beta(lp, beta);
#if 0 /* 30/III-2016 */
               csa->num = spy_chuzr_sel(lp, beta, tol_bnd, tol_bnd1,
                  list);
               csa->p_stat = (csa->num == 0 ? GLP_FEAS : GLP_INFEAS);
#else
               spy_eval_r(lp, beta, tol_bnd, tol_bnd1, &csa->r);
               csa->p_stat = (csa->r.nnz == 0 ? GLP_FEAS : GLP_INFEAS);
#endif
               csa->d_stat = GLP_NOFEAS;
               ret = 0;
               goto fini;
            case 2:
               /* optimal solution found */
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("OPTIMAL LP SOLUTION FOUND\n");
               csa->p_stat = csa->d_stat = GLP_FEAS;
               ret = 0;
               goto fini;
            default:
               xassert(csa != csa);
         }
      }
      /* choose xB[p] and xN[q] */
#if 0 /* 23/III-2016 */
      choose_pivot(csa);
#else
#ifdef TIMING
      t_start = timer();
#endif
#if 1 /* 31/III-2016 */
      ret = choose_pivot(csa);
#endif
#ifdef TIMING
      t_rtest += timer() - t_start;
#endif
      if (ret < 0)
      {  lp->valid = 0;
         goto loop;
      }
      if (ret == 0)
         csa->ns_cnt++;
      else
         csa->ls_cnt++;
#endif
      /* check for dual unboundedness */
      if (csa->q == 0)
      {  if (perturb > 0)
         {  /* remove perturbation */
            remove_perturb(csa);
            perturb = 0;
         }
         if (csa->beta_st != 1)
            csa->beta_st = 0;
         if (csa->d_st != 1)
            csa->d_st = 0;
         if (!(csa->beta_st && csa->d_st))
            goto loop;
         display(csa, 1);
         switch (csa->phase)
         {  case 1:
               /* this should never happen */
               if (msg_lev >= GLP_MSG_ERR)
                  xprintf("Error: dual simplex failed\n");
               csa->p_stat = csa->d_stat = GLP_UNDEF;
               ret = GLP_EFAIL;
               goto fini;
            case 2:
               /* dual unboundedness detected */
               if (msg_lev >= GLP_MSG_ALL)
                  xprintf("LP HAS NO PRIMAL FEASIBLE SOLUTION\n");
               csa->p_stat = GLP_NOFEAS;
               csa->d_stat = GLP_FEAS;
               ret = 0;
               goto fini;
            default:
               xassert(csa != csa);
         }
      }
      /* compute q-th column of the simplex table */
#ifdef TIMING
      t_start = timer();
#endif
#if 0 /* 31/III-2016 */
      spx_eval_tcol(lp, csa->q, tcol);
#else
      spx_eval_tcol(lp, csa->q, csa->tcol.vec);
      fvs_gather_vec(&csa->tcol, DBL_EPSILON);
#endif
#ifdef TIMING
      t_pivcol += timer() - t_start;
#endif
      /* FIXME: tcol[p] and trow[q] should be close to each other */
#if 0 /* 26/V-2017 by cmatraki */
      xassert(csa->tcol.vec[csa->p] != 0.0);
#else
      if (csa->tcol.vec[csa->p] == 0.0)
      {  if (msg_lev >= GLP_MSG_ERR)
            xprintf("Error: tcol[p] = 0.0\n");
         csa->p_stat = csa->d_stat = GLP_UNDEF;
         ret = GLP_EFAIL;
         goto fini;
      }
#endif
      /* update values of basic variables for adjacent basis */
      k = head[csa->p]; /* x[k] = xB[p] */
      p_flag = (l[k] != u[k] && beta[csa->p] > u[k]);
#if 0 /* 16/III-2016 */
      spx_update_beta(lp, beta, csa->p, p_flag, csa->q, tcol);
      csa->beta_st = 2;
#else
      /* primal solution may be invalidated due to long step */
#ifdef TIMING
      t_start = timer();
#endif
      if (csa->beta_st)
#if 0 /* 30/III-2016 */
      {  spx_update_beta(lp, beta, csa->p, p_flag, csa->q, tcol);
#else
      {  spx_update_beta_s(lp, beta, csa->p, p_flag, csa->q,
            &csa->tcol);
         /* also update vector r of primal infeasibilities */
         /*fvs_check_vec(&csa->r);*/
         switch (csa->phase)
         {  case 1:
               spy_update_r(lp, csa->p, csa->q, beta, &csa->tcol,
                  1e-8, 0.0, &csa->r);
               break;
            case 2:
               spy_update_r(lp, csa->p, csa->q, beta, &csa->tcol,
                  tol_bnd, tol_bnd1, &csa->r);
               break;
            default:
               xassert(csa != csa);
         }
         /*fvs_check_vec(&csa->r);*/
#endif
         csa->beta_st = 2;
      }
#ifdef TIMING
      t_upd1 += timer() - t_start;
#endif
#endif
#if 1 /* 11/VII-2017 */
      /* check for stalling */
      {  int k;
         xassert(1 <= csa->p && csa->p <= m);
         xassert(1 <= csa->q && csa->q <= n-m);
         /* FIXME: recompute d[q]; see spx_update_d */
         k = head[m+csa->q]; /* x[k] = xN[q] */
         if (!(lp->l[k] == -DBL_MAX && lp->u[k] == +DBL_MAX))
         {  if (fabs(d[csa->q]) >= 1e-6)
            {  csa->degen = 0;
               goto skip1;
            }
            /* degenerate iteration has been detected */
            csa->degen++;
            if (perturb < 0 && csa->degen >= 200)
            {  if (msg_lev >= GLP_MSG_ALL)
                  xprintf("Perturbing LP to avoid stalling [%d]...\n",
                     csa->it_cnt);
               perturb = 1;
            }
skip1:      ;
         }
      }
#endif
      /* update reduced costs of non-basic variables for adjacent
       * basis */
#if 1 /* 28/III-2016 */
      xassert(csa->d_st);
#endif
#ifdef TIMING
      t_start = timer();
#endif
#if 0 /* 30/III-2016 */
      if (spx_update_d(lp, d, csa->p, csa->q, trow, tcol) <= 1e-9)
#else
      if (spx_update_d_s(lp, d, csa->p, csa->q, &csa->trow, &csa->tcol)
         <= 1e-9)
#endif
      {  /* successful updating */
         csa->d_st = 2;
      }
      else
      {  /* new reduced costs are inaccurate */
         csa->d_st = 0;
      }
#ifdef TIMING
      t_upd2 += timer() - t_start;
#endif
      /* update steepest edge weights for adjacent basis, if used */
#ifdef TIMING
      t_start = timer();
#endif
      if (se != NULL)
      {  if (refct > 0)
#if 0 /* 30/III-2016 */
         {  if (spy_update_gamma(lp, se, csa->p, csa->q, trow, tcol)
               <= 1e-3)
#else
         {  if (spy_update_gamma_s(lp, se, csa->p, csa->q, &csa->trow,
               &csa->tcol) <= 1e-3)
#endif
            {  /* successful updating */
               refct--;
            }
            else
            {  /* new weights are inaccurate; reset reference space */
               se->valid = 0;
            }
         }
         else
         {  /* too many updates; reset reference space */
            se->valid = 0;
         }
      }
#ifdef TIMING
      t_upd3 += timer() - t_start;
#endif
#ifdef TIMING
      t_start = timer();
#endif
      /* update matrix N for adjacent basis, if used */
      if (nt != NULL)
         spx_update_nt(lp, nt, csa->p, csa->q);
#ifdef TIMING
      t_upd4 += timer() - t_start;
#endif
      /* change current basis header to adjacent one */
      spx_change_basis(lp, csa->p, p_flag, csa->q);
      /* and update factorization of the basis matrix */
#ifdef TIMING
      t_start = timer();
#endif
#if 0 /* 16/III-2016 */
      if (csa->p > 0)
#endif
         spx_update_invb(lp, csa->p, head[csa->p]);
#ifdef TIMING
      t_upd5 += timer() - t_start;
#endif
      if (perturb > 0 && csa->d_st)
         play_coef(csa, 0);
      /* dual simplex iteration complete */
      csa->it_cnt++;
      goto loop;
fini:
#ifdef TIMING
      t_total = timer() - t_total;
      xprintf("Total time      = %10.3f\n", t_total);
      xprintf("Factorization   = %10.3f\n", t_fact);
      xprintf("Ratio test      = %10.3f\n", t_rtest);
      xprintf("Pivot column    = %10.3f\n", t_pivcol);
      xprintf("Updating beta   = %10.3f\n", t_upd1);
      xprintf("Updating d      = %10.3f\n", t_upd2);
      xprintf("Updating gamma  = %10.3f\n", t_upd3);
      xprintf("Updating N      = %10.3f\n", t_upd4);
      xprintf("Updating inv(B) = %10.3f\n", t_upd5);
#endif
      return ret;
}

int spy_dual(glp_prob *P, const glp_smcp *parm)
{     /* driver to the dual simplex method */
      struct csa csa_, *csa = &csa_;
      SPXLP lp;
      SPXAT at;
      SPXNT nt;
      SPYSE se;
      int ret, *map, *daeh;
#if SCALE_Z
      int i, j, k;
#endif
      /* build working LP and its initial basis */
      memset(csa, 0, sizeof(struct csa));
      csa->lp = &lp;
      spx_init_lp(csa->lp, P, parm->excl);
      spx_alloc_lp(csa->lp);
      map = talloc(1+P->m+P->n, int);
      spx_build_lp(csa->lp, P, parm->excl, parm->shift, map);
      spx_build_basis(csa->lp, P, map);
      switch (P->dir)
      {  case GLP_MIN:
            csa->dir = +1;
            break;
         case GLP_MAX:
            csa->dir = -1;
            break;
         default:
            xassert(P != P);
      }
#if SCALE_Z
      csa->fz = 0.0;
      for (k = 1; k <= csa->lp->n; k++)
      {  double t = fabs(csa->lp->c[k]);
         if (csa->fz < t)
            csa->fz = t;
      }
      if (csa->fz <= 1000.0)
         csa->fz = 1.0;
      else
         csa->fz /= 1000.0;
      /*xprintf("csa->fz = %g\n", csa->fz);*/
      for (k = 0; k <= csa->lp->n; k++)
         csa->lp->c[k] /= csa->fz;
#endif
      csa->orig_b = talloc(1+csa->lp->m, double);
      memcpy(csa->orig_b, csa->lp->b, (1+csa->lp->m) * sizeof(double));
      csa->orig_c = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_c, csa->lp->c, (1+csa->lp->n) * sizeof(double));
      csa->orig_l = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_l, csa->lp->l, (1+csa->lp->n) * sizeof(double));
      csa->orig_u = talloc(1+csa->lp->n, double);
      memcpy(csa->orig_u, csa->lp->u, (1+csa->lp->n) * sizeof(double));
      switch (parm->aorn)
      {  case GLP_USE_AT:
            /* build matrix A in row-wise format */
            csa->at = &at;
            csa->nt = NULL;
            spx_alloc_at(csa->lp, csa->at);
            spx_build_at(csa->lp, csa->at);
            break;
         case GLP_USE_NT:
            /* build matrix N in row-wise format for initial basis */
            csa->at = NULL;
            csa->nt = &nt;
            spx_alloc_nt(csa->lp, csa->nt);
            spx_init_nt(csa->lp, csa->nt);
            spx_build_nt(csa->lp, csa->nt);
            break;
         default:
            xassert(parm != parm);
      }
      /* allocate and initialize working components */
      csa->phase = 0;
      csa->beta = talloc(1+csa->lp->m, double);
      csa->beta_st = 0;
      csa->d = talloc(1+csa->lp->n-csa->lp->m, double);
      csa->d_st = 0;
      switch (parm->pricing)
      {  case GLP_PT_STD:
            csa->se = NULL;
            break;
         case GLP_PT_PSE:
            csa->se = &se;
            spy_alloc_se(csa->lp, csa->se);
            break;
         default:
            xassert(parm != parm);
      }
#if 0 /* 30/III-2016 */
      csa->list = talloc(1+csa->lp->m, int);
      csa->trow = talloc(1+csa->lp->n-csa->lp->m, double);
      csa->tcol = talloc(1+csa->lp->m, double);
#else
      fvs_alloc_vec(&csa->r, csa->lp->m);
      fvs_alloc_vec(&csa->trow, csa->lp->n-csa->lp->m);
      fvs_alloc_vec(&csa->tcol, csa->lp->m);
#endif
#if 1 /* 16/III-2016 */
      csa->bp = NULL;
#endif
      csa->work = talloc(1+csa->lp->m, double);
      csa->work1 = talloc(1+csa->lp->n-csa->lp->m, double);
#if 0 /* 11/VI-2017 */
#if 1 /* 31/III-2016 */
      fvs_alloc_vec(&csa->wrow, csa->lp->n-csa->lp->m);
      fvs_alloc_vec(&csa->wcol, csa->lp->m);
#endif
#endif
      /* initialize control parameters */
      csa->msg_lev = parm->msg_lev;
      csa->dualp = (parm->meth == GLP_DUALP);
#if 0 /* 16/III-2016 */
      switch (parm->r_test)
      {  case GLP_RT_STD:
            csa->harris = 0;
            break;
         case GLP_RT_HAR:
            csa->harris = 1;
            break;
         default:
            xassert(parm != parm);
      }
#else
      switch (parm->r_test)
      {  case GLP_RT_STD:
         case GLP_RT_HAR:
            break;
         case GLP_RT_FLIP:
            csa->bp = talloc(1+csa->lp->n-csa->lp->m, SPYBP);
            break;
         default:
            xassert(parm != parm);
      }
      csa->r_test = parm->r_test;
#endif
      csa->tol_bnd = parm->tol_bnd;
      csa->tol_bnd1 = .001 * parm->tol_bnd;
      csa->tol_dj = parm->tol_dj;
      csa->tol_dj1 = .001 * parm->tol_dj;
#if 0
      csa->tol_dj1 = 1e-9 * parm->tol_dj;
#endif
      csa->tol_piv = parm->tol_piv;
      switch (P->dir)
      {  case GLP_MIN:
            csa->obj_lim = + parm->obj_ul;
            break;
         case GLP_MAX:
            csa->obj_lim = - parm->obj_ll;
            break;
         default:
            xassert(parm != parm);
      }
#if SCALE_Z
      if (csa->obj_lim != DBL_MAX)
         csa->obj_lim /= csa->fz;
#endif
      csa->it_lim = parm->it_lim;
      csa->tm_lim = parm->tm_lim;
      csa->out_frq = parm->out_frq;
      csa->out_dly = parm->out_dly;
      /* initialize working parameters */
      csa->tm_beg = xtime();
      csa->it_beg = csa->it_cnt = P->it_cnt;
      csa->it_dpy = -1;
#if 1 /* 15/VII-2017 */
      csa->tm_dpy = 0.0;
#endif
      csa->inv_cnt = 0;
#if 1 /* 11/VII-2017 */
      csa->degen = 0;
#endif
#if 1 /* 23/III-2016 */
      csa->ns_cnt = csa->ls_cnt = 0;
#endif
      /* try to solve working LP */
      ret = dual_simplex(csa);
      /* return basis factorization back to problem object */
      P->valid = csa->lp->valid;
      P->bfd = csa->lp->bfd;
      /* set solution status */
      P->pbs_stat = csa->p_stat;
      P->dbs_stat = csa->d_stat;
      /* if the solver failed, do not store basis header and basic
       * solution components to problem object */
      if (ret == GLP_EFAIL)
         goto skip;
      /* convert working LP basis to original LP basis and store it to
       * problem object */
      daeh = talloc(1+csa->lp->n, int);
      spx_store_basis(csa->lp, P, map, daeh);
      /* compute simplex multipliers for final basic solution found by
       * the solver */
      spx_eval_pi(csa->lp, csa->work);
      /* convert working LP solution to original LP solution and store
       * it to problem object */
#if SCALE_Z
      for (i = 1; i <= csa->lp->m; i++)
         csa->work[i] *= csa->fz;
      for (j = 1; j <= csa->lp->n-csa->lp->m; j++)
         csa->d[j] *= csa->fz;
#endif
      spx_store_sol(csa->lp, P, parm->shift, map, daeh, csa->beta,
         csa->work, csa->d);
      tfree(daeh);
      /* save simplex iteration count */
      P->it_cnt = csa->it_cnt;
      /* report auxiliary/structural variable causing unboundedness */
      P->some = 0;
      if (csa->p_stat == GLP_NOFEAS && csa->d_stat == GLP_FEAS)
      {  int k, kk;
         /* xB[p] = x[k] causes dual unboundedness */
         xassert(1 <= csa->p && csa->p <= csa->lp->m);
         k = csa->lp->head[csa->p];
         xassert(1 <= k && k <= csa->lp->n);
         /* convert to number of original variable */
         for (kk = 1; kk <= P->m + P->n; kk++)
         {  if (abs(map[kk]) == k)
            {  P->some = kk;
               break;
            }
         }
         xassert(P->some != 0);
      }
skip: /* deallocate working objects and arrays */
      spx_free_lp(csa->lp);
      tfree(map);
      tfree(csa->orig_b);
      tfree(csa->orig_c);
      tfree(csa->orig_l);
      tfree(csa->orig_u);
      if (csa->at != NULL)
         spx_free_at(csa->lp, csa->at);
      if (csa->nt != NULL)
         spx_free_nt(csa->lp, csa->nt);
      tfree(csa->beta);
      tfree(csa->d);
      if (csa->se != NULL)
         spy_free_se(csa->lp, csa->se);
#if 0 /* 30/III-2016 */
      tfree(csa->list);
      tfree(csa->trow);
#else
      fvs_free_vec(&csa->r);
      fvs_free_vec(&csa->trow);
#endif
#if 1 /* 16/III-2016 */
      if (csa->bp != NULL)
         tfree(csa->bp);
#endif
#if 0 /* 29/III-2016 */
      tfree(csa->tcol);
#else
      fvs_free_vec(&csa->tcol);
#endif
      tfree(csa->work);
      tfree(csa->work1);
#if 0 /* 11/VI-2017 */
#if 1 /* 31/III-2016 */
      fvs_free_vec(&csa->wrow);
      fvs_free_vec(&csa->wcol);
#endif
#endif
      /* return to calling program */
      return ret >= 0 ? ret : GLP_EFAIL;
}

/* eof */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7111437
igraph-0.9.9/vendor/source/igraph/vendor/lapack/0000755000175100001710000000000000000000000022402 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/CMakeLists.txt0000644000175100001710000000565600000000000025156 0ustar00runnerdocker00000000000000# Declare the files needed to compile our vendored BLAS copy
add_library(
  blas_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  dscal.c dswap.c lsame.c dnrm2.c daxpy.c dgemv.c dger.c dgemm.c
  dcopy.c dtrmm.c dtrmv.c drot.c ddot.c dasum.c dsymv.c dsyr2k.c dsyr2.c
  dtrsm.c dsyrk.c dtrsv.c idamax.c
  $
)
target_include_directories(
  blas_vendored
  PRIVATE
  $
)
if (BUILD_SHARED_LIBS)
  set_property(TARGET blas_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Declare the files needed to compile our vendored LAPACK copy
add_library(
  lapack_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  dgeev.c dgebak.c dgebal.c disnan.c dlaisnan.c dgehrd.c dgehd2.c
  dlarf.c iladlc.c iladlr.c dlarfg.c dlapy2.c dlahr2.c dlacpy.c dlarfb.c
  ilaenv.c ieeeck.c iparmq.c dhseqr.c dlahqr.c dlabad.c dlanv2.c dlaqr0.c
  dlaqr3.c dlaqr4.c dlaqr2.c dlaset.c dormhr.c dormqr.c dlarft.c dorm2r.c
  dtrexc.c dlaexc.c dlange.c dlassq.c dlarfx.c dlartg.c dlasy2.c dlaqr5.c
  dlaqr1.c dlascl.c dorghr.c dorgqr.c dorg2r.c dtrevc.c dlaln2.c dladiv.c
  dsyevr.c dlansy.c dormtr.c dormql.c dorm2l.c dstebz.c dlaebz.c dstein.c
  dlagtf.c dlagts.c dlarnv.c dlaruv.c dstemr.c dlae2.c dlaev2.c dlanst.c
  dlarrc.c dlarre.c dlarra.c dlarrb.c dlaneg.c dlarrd.c dlarrk.c dlasq2.c
  dlasq3.c dlasq4.c dlasq5.c dlasq6.c dlasrt.c dlarrj.c dlarrr.c dlarrv.c
  dlar1v.c dlarrf.c dsterf.c dsytrd.c dlatrd.c dsytd2.c dlanhs.c dgeqr2.c
  dtrsen.c dlacn2.c dtrsyl.c dlasr.c dsteqr.c dgeevx.c dtrsna.c dlaqtr.c
  dgetrf.c dgetf2.c dlaswp.c dgetrs.c dgesv.c dpotrf.c dpotf2.c
  xerbla.c len_trim.c
  dlamch.c fortran_intrinsics.c  
  $
)
target_include_directories(
  lapack_vendored
  PRIVATE
  $
)
if (BUILD_SHARED_LIBS)
  set_property(TARGET lapack_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Declare the files needed to compile our vendored ARPACK copy
add_library(
  arpack_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  dnaupd.c dnaup2.c dgetv0.c dvout.c second.c dmout.c dnaitr.c ivout.c dnapps.c
  dnconv.c dneigh.c dlaqrb.c dngets.c dsortc.c dstatn.c dneupd.c dsaupd.c
  dsaup2.c dsaitr.c dsapps.c dsconv.c dseigt.c dstqrb.c dsgets.c dsortr.c
  dstats.c dseupd.c dsesrt.c
  $
)
target_include_directories(
  arpack_vendored
  PRIVATE
  $
)
if (BUILD_SHARED_LIBS)
  set_property(TARGET arpack_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Suppress some warnings that occur in the output because we do not want to
# mess around with the source of lapack too much to fix these
if(NOT MSVC)
  target_compile_options(blas_vendored PRIVATE 
    $<$:-Wno-logical-op-parentheses>
  )
  target_compile_options(lapack_vendored PRIVATE 
    $<$:-Wno-logical-op-parentheses -Wno-shift-op-parentheses>
  )
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dasum.c0000644000175100001710000000723600000000000023667 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DASUM   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DASUM(N,DX,INCX)   

         INTEGER INCX,N   
         DOUBLE PRECISION DX(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DASUM takes the sum of the absolute values.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 3/93 to return if incx .le. 0.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    ===================================================================== */
doublereal igraphdasum_(integer *n, doublereal *dx, integer *incx)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal ret_val, d__1, d__2, d__3, d__4, d__5, d__6;

    /* Local variables */
    integer i__, m, mp1;
    doublereal dtemp;
    integer nincx;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dx;

    /* Function Body */
    ret_val = 0.;
    dtemp = 0.;
    if (*n <= 0 || *incx <= 0) {
	return ret_val;
    }
    if (*incx == 1) {
/*        code for increment equal to 1   


          clean-up loop */

	m = *n % 6;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dtemp += (d__1 = dx[i__], abs(d__1));
	    }
	    if (*n < 6) {
		ret_val = dtemp;
		return ret_val;
	    }
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 6) {
	    dtemp = dtemp + (d__1 = dx[i__], abs(d__1)) + (d__2 = dx[i__ + 1],
		     abs(d__2)) + (d__3 = dx[i__ + 2], abs(d__3)) + (d__4 = 
		    dx[i__ + 3], abs(d__4)) + (d__5 = dx[i__ + 4], abs(d__5)) 
		    + (d__6 = dx[i__ + 5], abs(d__6));
	}
    } else {

/*        code for increment not equal to 1 */

	nincx = *n * *incx;
	i__1 = nincx;
	i__2 = *incx;
	for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
	    dtemp += (d__1 = dx[i__], abs(d__1));
	}
    }
    ret_val = dtemp;
    return ret_val;
} /* igraphdasum_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/daxpy.c0000644000175100001710000001017000000000000023672 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DAXPY   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DAXPY(N,DA,DX,INCX,DY,INCY)   

         DOUBLE PRECISION DA   
         INTEGER INCX,INCY,N   
         DOUBLE PRECISION DX(*),DY(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DAXPY constant times a vector plus a vector.   
   >    uses unrolled loops for increments equal to one.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DA   
   > \verbatim   
   >          DA is DOUBLE PRECISION   
   >           On entry, DA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   
   >   
   > \param[in,out] DY   
   > \verbatim   
   >          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >         storage spacing between elements of DY   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdaxpy_(integer *n, doublereal *da, doublereal *dx, 
	integer *incx, doublereal *dy, integer *incy)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    integer i__, m, ix, iy, mp1;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dy;
    --dx;

    /* Function Body */
    if (*n <= 0) {
	return 0;
    }
    if (*da == 0.) {
	return 0;
    }
    if (*incx == 1 && *incy == 1) {

/*        code for both increments equal to 1   


          clean-up loop */

	m = *n % 4;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dy[i__] += *da * dx[i__];
	    }
	}
	if (*n < 4) {
	    return 0;
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 4) {
	    dy[i__] += *da * dx[i__];
	    dy[i__ + 1] += *da * dx[i__ + 1];
	    dy[i__ + 2] += *da * dx[i__ + 2];
	    dy[i__ + 3] += *da * dx[i__ + 3];
	}
    } else {

/*        code for unequal increments or equal increments   
            not equal to 1 */

	ix = 1;
	iy = 1;
	if (*incx < 0) {
	    ix = (-(*n) + 1) * *incx + 1;
	}
	if (*incy < 0) {
	    iy = (-(*n) + 1) * *incy + 1;
	}
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dy[iy] += *da * dx[ix];
	    ix += *incx;
	    iy += *incy;
	}
    }
    return 0;
} /* igraphdaxpy_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dcopy.c0000644000175100001710000000765200000000000023676 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DCOPY   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DCOPY(N,DX,INCX,DY,INCY)   

         INTEGER INCX,INCY,N   
         DOUBLE PRECISION DX(*),DY(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DCOPY copies a vector, x, to a vector, y.   
   >    uses unrolled loops for increments equal to 1.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   
   >   
   > \param[out] DY   
   > \verbatim   
   >          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >         storage spacing between elements of DY   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdcopy_(integer *n, doublereal *dx, integer *incx, 
	doublereal *dy, integer *incy)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    integer i__, m, ix, iy, mp1;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dy;
    --dx;

    /* Function Body */
    if (*n <= 0) {
	return 0;
    }
    if (*incx == 1 && *incy == 1) {

/*        code for both increments equal to 1   


          clean-up loop */

	m = *n % 7;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dy[i__] = dx[i__];
	    }
	    if (*n < 7) {
		return 0;
	    }
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 7) {
	    dy[i__] = dx[i__];
	    dy[i__ + 1] = dx[i__ + 1];
	    dy[i__ + 2] = dx[i__ + 2];
	    dy[i__ + 3] = dx[i__ + 3];
	    dy[i__ + 4] = dx[i__ + 4];
	    dy[i__ + 5] = dx[i__ + 5];
	    dy[i__ + 6] = dx[i__ + 6];
	}
    } else {

/*        code for unequal increments or equal increments   
            not equal to 1 */

	ix = 1;
	iy = 1;
	if (*incx < 0) {
	    ix = (-(*n) + 1) * *incx + 1;
	}
	if (*incy < 0) {
	    iy = (-(*n) + 1) * *incy + 1;
	}
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dy[iy] = dx[ix];
	    ix += *incx;
	    iy += *incy;
	}
    }
    return 0;
} /* igraphdcopy_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/ddot.c0000644000175100001710000001002700000000000023500 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DDOT   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DDOT(N,DX,INCX,DY,INCY)   

         INTEGER INCX,INCY,N   
         DOUBLE PRECISION DX(*),DY(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DDOT forms the dot product of two vectors.   
   >    uses unrolled loops for increments equal to one.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   
   >   
   > \param[in] DY   
   > \verbatim   
   >          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >         storage spacing between elements of DY   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    ===================================================================== */
doublereal igraphddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy, 
	integer *incy)
{
    /* System generated locals */
    integer i__1;
    doublereal ret_val;

    /* Local variables */
    integer i__, m, ix, iy, mp1;
    doublereal dtemp;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dy;
    --dx;

    /* Function Body */
    ret_val = 0.;
    dtemp = 0.;
    if (*n <= 0) {
	return ret_val;
    }
    if (*incx == 1 && *incy == 1) {

/*        code for both increments equal to 1   


          clean-up loop */

	m = *n % 5;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dtemp += dx[i__] * dy[i__];
	    }
	    if (*n < 5) {
		ret_val = dtemp;
		return ret_val;
	    }
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 5) {
	    dtemp = dtemp + dx[i__] * dy[i__] + dx[i__ + 1] * dy[i__ + 1] + 
		    dx[i__ + 2] * dy[i__ + 2] + dx[i__ + 3] * dy[i__ + 3] + 
		    dx[i__ + 4] * dy[i__ + 4];
	}
    } else {

/*        code for unequal increments or equal increments   
            not equal to 1 */

	ix = 1;
	iy = 1;
	if (*incx < 0) {
	    ix = (-(*n) + 1) * *incx + 1;
	}
	if (*incy < 0) {
	    iy = (-(*n) + 1) * *incy + 1;
	}
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dtemp += dx[ix] * dy[iy];
	    ix += *incx;
	    iy += *incy;
	}
    }
    ret_val = dtemp;
    return ret_val;
} /* igraphddot_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/debug.h0000644000175100001710000000000000000000000023627 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgebak.c0000644000175100001710000001736100000000000023773 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DGEBAK   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEBAK + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEBAK( JOB, SIDE, N, ILO, IHI, SCALE, M, V, LDV,   
                            INFO )   

         CHARACTER          JOB, SIDE   
         INTEGER            IHI, ILO, INFO, LDV, M, N   
         DOUBLE PRECISION   SCALE( * ), V( LDV, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEBAK forms the right or left eigenvectors of a real general matrix   
   > by backward transformation on the computed eigenvectors of the   
   > balanced matrix output by DGEBAL.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is CHARACTER*1   
   >          Specifies the type of backward transformation required:   
   >          = 'N', do nothing, return immediately;   
   >          = 'P', do backward transformation for permutation only;   
   >          = 'S', do backward transformation for scaling only;   
   >          = 'B', do backward transformations for both permutation and   
   >                 scaling.   
   >          JOB must be the same as the argument JOB supplied to DGEBAL.   
   > \endverbatim   
   >   
   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'R':  V contains right eigenvectors;   
   >          = 'L':  V contains left eigenvectors.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of rows of the matrix V.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >          The integers ILO and IHI determined by DGEBAL.   
   >          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.   
   > \endverbatim   
   >   
   > \param[in] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION array, dimension (N)   
   >          Details of the permutation and scaling factors, as returned   
   >          by DGEBAL.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of columns of the matrix V.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension (LDV,M)   
   >          On entry, the matrix of right or left eigenvectors to be   
   >          transformed, as returned by DHSEIN or DTREVC.   
   >          On exit, V is overwritten by the transformed eigenvectors.   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is INTEGER   
   >          The leading dimension of the array V. LDV >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleGEcomputational   

    =====================================================================   
   Subroutine */ int igraphdgebak_(char *job, char *side, integer *n, integer *ilo, 
	integer *ihi, doublereal *scale, integer *m, doublereal *v, integer *
	ldv, integer *info)
{
    /* System generated locals */
    integer v_dim1, v_offset, i__1;

    /* Local variables */
    integer i__, k;
    doublereal s;
    integer ii;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    logical leftv;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical rightv;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Decode and Test the input parameters   

       Parameter adjustments */
    --scale;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;

    /* Function Body */
    rightv = igraphlsame_(side, "R");
    leftv = igraphlsame_(side, "L");

    *info = 0;
    if (! igraphlsame_(job, "N") && ! igraphlsame_(job, "P") && ! igraphlsame_(job, "S") 
	    && ! igraphlsame_(job, "B")) {
	*info = -1;
    } else if (! rightv && ! leftv) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (*ilo < 1 || *ilo > max(1,*n)) {
	*info = -4;
    } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
	*info = -5;
    } else if (*m < 0) {
	*info = -7;
    } else if (*ldv < max(1,*n)) {
	*info = -9;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEBAK", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }
    if (*m == 0) {
	return 0;
    }
    if (igraphlsame_(job, "N")) {
	return 0;
    }

    if (*ilo == *ihi) {
	goto L30;
    }

/*     Backward balance */

    if (igraphlsame_(job, "S") || igraphlsame_(job, "B")) {

	if (rightv) {
	    i__1 = *ihi;
	    for (i__ = *ilo; i__ <= i__1; ++i__) {
		s = scale[i__];
		igraphdscal_(m, &s, &v[i__ + v_dim1], ldv);
/* L10: */
	    }
	}

	if (leftv) {
	    i__1 = *ihi;
	    for (i__ = *ilo; i__ <= i__1; ++i__) {
		s = 1. / scale[i__];
		igraphdscal_(m, &s, &v[i__ + v_dim1], ldv);
/* L20: */
	    }
	}

    }

/*     Backward permutation   

       For  I = ILO-1 step -1 until 1,   
                IHI+1 step 1 until N do -- */

L30:
    if (igraphlsame_(job, "P") || igraphlsame_(job, "B")) {
	if (rightv) {
	    i__1 = *n;
	    for (ii = 1; ii <= i__1; ++ii) {
		i__ = ii;
		if (i__ >= *ilo && i__ <= *ihi) {
		    goto L40;
		}
		if (i__ < *ilo) {
		    i__ = *ilo - ii;
		}
		k = (integer) scale[i__];
		if (k == i__) {
		    goto L40;
		}
		igraphdswap_(m, &v[i__ + v_dim1], ldv, &v[k + v_dim1], ldv);
L40:
		;
	    }
	}

	if (leftv) {
	    i__1 = *n;
	    for (ii = 1; ii <= i__1; ++ii) {
		i__ = ii;
		if (i__ >= *ilo && i__ <= *ihi) {
		    goto L50;
		}
		if (i__ < *ilo) {
		    i__ = *ilo - ii;
		}
		k = (integer) scale[i__];
		if (k == i__) {
		    goto L50;
		}
		igraphdswap_(m, &v[i__ + v_dim1], ldv, &v[k + v_dim1], ldv);
L50:
		;
	    }
	}
    }

    return 0;

/*     End of DGEBAK */

} /* igraphdgebak_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgebal.c0000644000175100001710000002664200000000000023776 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DGEBAL   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEBAL + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEBAL( JOB, N, A, LDA, ILO, IHI, SCALE, INFO )   

         CHARACTER          JOB   
         INTEGER            IHI, ILO, INFO, LDA, N   
         DOUBLE PRECISION   A( LDA, * ), SCALE( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEBAL balances a general real matrix A.  This involves, first,   
   > permuting A by a similarity transformation to isolate eigenvalues   
   > in the first 1 to ILO-1 and last IHI+1 to N elements on the   
   > diagonal; and second, applying a diagonal similarity transformation   
   > to rows and columns ILO to IHI to make the rows and columns as   
   > close in norm as possible.  Both steps are optional.   
   >   
   > Balancing may reduce the 1-norm of the matrix, and improve the   
   > accuracy of the computed eigenvalues and/or eigenvectors.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is CHARACTER*1   
   >          Specifies the operations to be performed on A:   
   >          = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0   
   >                  for i = 1,...,N;   
   >          = 'P':  permute only;   
   >          = 'S':  scale only;   
   >          = 'B':  both permute and scale.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE array, dimension (LDA,N)   
   >          On entry, the input matrix A.   
   >          On exit,  A is overwritten by the balanced matrix.   
   >          If JOB = 'N', A is not referenced.   
   >          See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   > \param[out] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >          ILO and IHI are set to integers such that on exit   
   >          A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.   
   >          If JOB = 'N' or 'S', ILO = 1 and IHI = N.   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE array, dimension (N)   
   >          Details of the permutations and scaling factors applied to   
   >          A.  If P(j) is the index of the row and column interchanged   
   >          with row and column j and D(j) is the scaling factor   
   >          applied to row and column j, then   
   >          SCALE(j) = P(j)    for j = 1,...,ILO-1   
   >                   = D(j)    for j = ILO,...,IHI   
   >                   = P(j)    for j = IHI+1,...,N.   
   >          The order in which the interchanges are made is N to IHI+1,   
   >          then 1 to ILO-1.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit.   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2013   

   > \ingroup doubleGEcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The permutations consist of row and column interchanges which put   
   >  the matrix in the form   
   >   
   >             ( T1   X   Y  )   
   >     P A P = (  0   B   Z  )   
   >             (  0   0   T2 )   
   >   
   >  where T1 and T2 are upper triangular matrices whose eigenvalues lie   
   >  along the diagonal.  The column indices ILO and IHI mark the starting   
   >  and ending columns of the submatrix B. Balancing consists of applying   
   >  a diagonal similarity transformation inv(D) * B * D to make the   
   >  1-norms of each row of B and its corresponding column nearly equal.   
   >  The output matrix is   
   >   
   >     ( T1     X*D          Y    )   
   >     (  0  inv(D)*B*D  inv(D)*Z ).   
   >     (  0      0           T2   )   
   >   
   >  Information about the permutations P and the diagonal matrix D is   
   >  returned in the vector SCALE.   
   >   
   >  This subroutine is based on the EISPACK routine BALANC.   
   >   
   >  Modified by Tzu-Yi Chen, Computer Science Division, University of   
   >    California at Berkeley, USA   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgebal_(char *job, integer *n, doublereal *a, integer *
	lda, integer *ilo, integer *ihi, doublereal *scale, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Local variables */
    doublereal c__, f, g;
    integer i__, j, k, l, m;
    doublereal r__, s, ca, ra;
    integer ica, ira, iexc;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    doublereal sfmin1, sfmin2, sfmax1, sfmax2;
    extern doublereal igraphdlamch_(char *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical noconv;


/*  -- LAPACK computational routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2013   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --scale;

    /* Function Body */
    *info = 0;
    if (! igraphlsame_(job, "N") && ! igraphlsame_(job, "P") && ! igraphlsame_(job, "S") 
	    && ! igraphlsame_(job, "B")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEBAL", &i__1, (ftnlen)6);
	return 0;
    }

    k = 1;
    l = *n;

    if (*n == 0) {
	goto L210;
    }

    if (igraphlsame_(job, "N")) {
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    scale[i__] = 1.;
/* L10: */
	}
	goto L210;
    }

    if (igraphlsame_(job, "S")) {
	goto L120;
    }

/*     Permutation to isolate eigenvalues if possible */

    goto L50;

/*     Row and column exchange. */

L20:
    scale[m] = (doublereal) j;
    if (j == m) {
	goto L30;
    }

    igraphdswap_(&l, &a[j * a_dim1 + 1], &c__1, &a[m * a_dim1 + 1], &c__1);
    i__1 = *n - k + 1;
    igraphdswap_(&i__1, &a[j + k * a_dim1], lda, &a[m + k * a_dim1], lda);

L30:
    switch (iexc) {
	case 1:  goto L40;
	case 2:  goto L80;
    }

/*     Search for rows isolating an eigenvalue and push them down. */

L40:
    if (l == 1) {
	goto L210;
    }
    --l;

L50:
    for (j = l; j >= 1; --j) {

	i__1 = l;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (i__ == j) {
		goto L60;
	    }
	    if (a[j + i__ * a_dim1] != 0.) {
		goto L70;
	    }
L60:
	    ;
	}

	m = l;
	iexc = 1;
	goto L20;
L70:
	;
    }

    goto L90;

/*     Search for columns isolating an eigenvalue and push them left. */

L80:
    ++k;

L90:
    i__1 = l;
    for (j = k; j <= i__1; ++j) {

	i__2 = l;
	for (i__ = k; i__ <= i__2; ++i__) {
	    if (i__ == j) {
		goto L100;
	    }
	    if (a[i__ + j * a_dim1] != 0.) {
		goto L110;
	    }
L100:
	    ;
	}

	m = k;
	iexc = 2;
	goto L20;
L110:
	;
    }

L120:
    i__1 = l;
    for (i__ = k; i__ <= i__1; ++i__) {
	scale[i__] = 1.;
/* L130: */
    }

    if (igraphlsame_(job, "P")) {
	goto L210;
    }

/*     Balance the submatrix in rows K to L.   

       Iterative loop for norm reduction */

    sfmin1 = igraphdlamch_("S") / igraphdlamch_("P");
    sfmax1 = 1. / sfmin1;
    sfmin2 = sfmin1 * 2.;
    sfmax2 = 1. / sfmin2;

L140:
    noconv = FALSE_;

    i__1 = l;
    for (i__ = k; i__ <= i__1; ++i__) {

	i__2 = l - k + 1;
	c__ = igraphdnrm2_(&i__2, &a[k + i__ * a_dim1], &c__1);
	i__2 = l - k + 1;
	r__ = igraphdnrm2_(&i__2, &a[i__ + k * a_dim1], lda);
	ica = igraphidamax_(&l, &a[i__ * a_dim1 + 1], &c__1);
	ca = (d__1 = a[ica + i__ * a_dim1], abs(d__1));
	i__2 = *n - k + 1;
	ira = igraphidamax_(&i__2, &a[i__ + k * a_dim1], lda);
	ra = (d__1 = a[i__ + (ira + k - 1) * a_dim1], abs(d__1));

/*        Guard against zero C or R due to underflow. */

	if (c__ == 0. || r__ == 0.) {
	    goto L200;
	}
	g = r__ / 2.;
	f = 1.;
	s = c__ + r__;
L160:
/* Computing MAX */
	d__1 = max(f,c__);
/* Computing MIN */
	d__2 = min(r__,g);
	if (c__ >= g || max(d__1,ca) >= sfmax2 || min(d__2,ra) <= sfmin2) {
	    goto L170;
	}
	d__1 = c__ + f + ca + r__ + g + ra;
	if (igraphdisnan_(&d__1)) {

/*           Exit if NaN to avoid infinite loop */

	    *info = -3;
	    i__2 = -(*info);
	    igraphxerbla_("DGEBAL", &i__2, (ftnlen)6);
	    return 0;
	}
	f *= 2.;
	c__ *= 2.;
	ca *= 2.;
	r__ /= 2.;
	g /= 2.;
	ra /= 2.;
	goto L160;

L170:
	g = c__ / 2.;
L180:
/* Computing MIN */
	d__1 = min(f,c__), d__1 = min(d__1,g);
	if (g < r__ || max(r__,ra) >= sfmax2 || min(d__1,ca) <= sfmin2) {
	    goto L190;
	}
	f /= 2.;
	c__ /= 2.;
	g /= 2.;
	ca /= 2.;
	r__ *= 2.;
	ra *= 2.;
	goto L180;

/*        Now balance. */

L190:
	if (c__ + r__ >= s * .95) {
	    goto L200;
	}
	if (f < 1. && scale[i__] < 1.) {
	    if (f * scale[i__] <= sfmin1) {
		goto L200;
	    }
	}
	if (f > 1. && scale[i__] > 1.) {
	    if (scale[i__] >= sfmax1 / f) {
		goto L200;
	    }
	}
	g = 1. / f;
	scale[i__] *= f;
	noconv = TRUE_;

	i__2 = *n - k + 1;
	igraphdscal_(&i__2, &g, &a[i__ + k * a_dim1], lda);
	igraphdscal_(&l, &f, &a[i__ * a_dim1 + 1], &c__1);

L200:
	;
    }

    if (noconv) {
	goto L140;
    }

L210:
    *ilo = k;
    *ihi = l;

    return 0;

/*     End of DGEBAL */

} /* igraphdgebal_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgeev.c0000644000175100001710000005125100000000000023644 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__0 = 0;
static integer c_n1 = -1;

/* > \brief  DGEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matr
ices   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEEV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEEV( JOBVL, JOBVR, N, A, LDA, WR, WI, VL, LDVL, VR,   
                           LDVR, WORK, LWORK, INFO )   

         CHARACTER          JOBVL, JOBVR   
         INTEGER            INFO, LDA, LDVL, LDVR, LWORK, N   
         DOUBLE PRECISION   A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),   
        $                   WI( * ), WORK( * ), WR( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEEV computes for an N-by-N real nonsymmetric matrix A, the   
   > eigenvalues and, optionally, the left and/or right eigenvectors.   
   >   
   > The right eigenvector v(j) of A satisfies   
   >                  A * v(j) = lambda(j) * v(j)   
   > where lambda(j) is its eigenvalue.   
   > The left eigenvector u(j) of A satisfies   
   >               u(j)**H * A = lambda(j) * u(j)**H   
   > where u(j)**H denotes the conjugate-transpose of u(j).   
   >   
   > The computed eigenvectors are normalized to have Euclidean norm   
   > equal to 1 and largest component real.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOBVL   
   > \verbatim   
   >          JOBVL is CHARACTER*1   
   >          = 'N': left eigenvectors of A are not computed;   
   >          = 'V': left eigenvectors of A are computed.   
   > \endverbatim   
   >   
   > \param[in] JOBVR   
   > \verbatim   
   >          JOBVR is CHARACTER*1   
   >          = 'N': right eigenvectors of A are not computed;   
   >          = 'V': right eigenvectors of A are computed.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the N-by-N matrix A.   
   >          On exit, A has been overwritten.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (N)   
   >          WR and WI contain the real and imaginary parts,   
   >          respectively, of the computed eigenvalues.  Complex   
   >          conjugate pairs of eigenvalues appear consecutively   
   >          with the eigenvalue having the positive imaginary part   
   >          first.   
   > \endverbatim   
   >   
   > \param[out] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION array, dimension (LDVL,N)   
   >          If JOBVL = 'V', the left eigenvectors u(j) are stored one   
   >          after another in the columns of VL, in the same order   
   >          as their eigenvalues.   
   >          If JOBVL = 'N', VL is not referenced.   
   >          If the j-th eigenvalue is real, then u(j) = VL(:,j),   
   >          the j-th column of VL.   
   >          If the j-th and (j+1)-st eigenvalues form a complex   
   >          conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and   
   >          u(j+1) = VL(:,j) - i*VL(:,j+1).   
   > \endverbatim   
   >   
   > \param[in] LDVL   
   > \verbatim   
   >          LDVL is INTEGER   
   >          The leading dimension of the array VL.  LDVL >= 1; if   
   >          JOBVL = 'V', LDVL >= N.   
   > \endverbatim   
   >   
   > \param[out] VR   
   > \verbatim   
   >          VR is DOUBLE PRECISION array, dimension (LDVR,N)   
   >          If JOBVR = 'V', the right eigenvectors v(j) are stored one   
   >          after another in the columns of VR, in the same order   
   >          as their eigenvalues.   
   >          If JOBVR = 'N', VR is not referenced.   
   >          If the j-th eigenvalue is real, then v(j) = VR(:,j),   
   >          the j-th column of VR.   
   >          If the j-th and (j+1)-st eigenvalues form a complex   
   >          conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and   
   >          v(j+1) = VR(:,j) - i*VR(:,j+1).   
   > \endverbatim   
   >   
   > \param[in] LDVR   
   > \verbatim   
   >          LDVR is INTEGER   
   >          The leading dimension of the array VR.  LDVR >= 1; if   
   >          JOBVR = 'V', LDVR >= N.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.  LWORK >= max(1,3*N), and   
   >          if JOBVL = 'V' or JOBVR = 'V', LWORK >= 4*N.  For good   
   >          performance, LWORK must generally be larger.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   >          > 0:  if INFO = i, the QR algorithm failed to compute all the   
   >                eigenvalues, and no eigenvectors have been computed;   
   >                elements i+1:N of WR and WI contain eigenvalues which   
   >                have converged.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEeigen   

    =====================================================================   
   Subroutine */ int igraphdgeev_(char *jobvl, char *jobvr, integer *n, doublereal *
	a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl, 
	integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, 
	integer *lwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, vl_dim1, vl_offset, vr_dim1, vr_offset, i__1, 
	    i__2, i__3;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, k;
    doublereal r__, cs, sn;
    integer ihi;
    doublereal scl;
    integer ilo;
    doublereal dum[1], eps;
    integer ibal;
    char side[1];
    doublereal anrm;
    integer ierr, itau;
    extern /* Subroutine */ int igraphdrot_(integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *);
    integer iwrk, nout;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlabad_(doublereal *, doublereal *), igraphdgebak_(
	    char *, char *, integer *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *), 
	    igraphdgebal_(char *, integer *, doublereal *, integer *, integer *, 
	    integer *, doublereal *, integer *);
    logical scalea;
    extern doublereal igraphdlamch_(char *);
    doublereal cscale;
    extern doublereal igraphdlange_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *);
    extern /* Subroutine */ int igraphdgehrd_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdlascl_(char *, integer *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphdlartg_(doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *), igraphxerbla_(char *, integer *, ftnlen);
    logical select[1];
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    doublereal bignum;
    extern /* Subroutine */ int igraphdorghr_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdhseqr_(char *, char *, integer *, integer *, integer 
	    *, doublereal *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, integer *), igraphdtrevc_(char *, char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, integer *);
    integer minwrk, maxwrk;
    logical wantvl;
    doublereal smlnum;
    integer hswork;
    logical lquery, wantvr;


/*  -- LAPACK driver routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --wr;
    --wi;
    vl_dim1 = *ldvl;
    vl_offset = 1 + vl_dim1;
    vl -= vl_offset;
    vr_dim1 = *ldvr;
    vr_offset = 1 + vr_dim1;
    vr -= vr_offset;
    --work;

    /* Function Body */
    *info = 0;
    lquery = *lwork == -1;
    wantvl = igraphlsame_(jobvl, "V");
    wantvr = igraphlsame_(jobvr, "V");
    if (! wantvl && ! igraphlsame_(jobvl, "N")) {
	*info = -1;
    } else if (! wantvr && ! igraphlsame_(jobvr, "N")) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (*lda < max(1,*n)) {
	*info = -5;
    } else if (*ldvl < 1 || wantvl && *ldvl < *n) {
	*info = -9;
    } else if (*ldvr < 1 || wantvr && *ldvr < *n) {
	*info = -11;
    }

/*     Compute workspace   
        (Note: Comments in the code beginning "Workspace:" describe the   
         minimal amount of workspace needed at that point in the code,   
         as well as the preferred amount for good performance.   
         NB refers to the optimal block size for the immediately   
         following subroutine, as returned by ILAENV.   
         HSWORK refers to the workspace preferred by DHSEQR, as   
         calculated below. HSWORK is computed assuming ILO=1 and IHI=N,   
         the worst case.) */

    if (*info == 0) {
	if (*n == 0) {
	    minwrk = 1;
	    maxwrk = 1;
	} else {
	    maxwrk = (*n << 1) + *n * igraphilaenv_(&c__1, "DGEHRD", " ", n, &c__1, 
		    n, &c__0, (ftnlen)6, (ftnlen)1);
	    if (wantvl) {
		minwrk = *n << 2;
/* Computing MAX */
		i__1 = maxwrk, i__2 = (*n << 1) + (*n - 1) * igraphilaenv_(&c__1, 
			"DORGHR", " ", n, &c__1, n, &c_n1, (ftnlen)6, (ftnlen)
			1);
		maxwrk = max(i__1,i__2);
		igraphdhseqr_("S", "V", n, &c__1, n, &a[a_offset], lda, &wr[1], &wi[
			1], &vl[vl_offset], ldvl, &work[1], &c_n1, info);
		hswork = (integer) work[1];
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n + 1, i__1 = max(i__1,i__2), i__2 = *
			n + hswork;
		maxwrk = max(i__1,i__2);
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n << 2;
		maxwrk = max(i__1,i__2);
	    } else if (wantvr) {
		minwrk = *n << 2;
/* Computing MAX */
		i__1 = maxwrk, i__2 = (*n << 1) + (*n - 1) * igraphilaenv_(&c__1, 
			"DORGHR", " ", n, &c__1, n, &c_n1, (ftnlen)6, (ftnlen)
			1);
		maxwrk = max(i__1,i__2);
		igraphdhseqr_("S", "V", n, &c__1, n, &a[a_offset], lda, &wr[1], &wi[
			1], &vr[vr_offset], ldvr, &work[1], &c_n1, info);
		hswork = (integer) work[1];
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n + 1, i__1 = max(i__1,i__2), i__2 = *
			n + hswork;
		maxwrk = max(i__1,i__2);
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n << 2;
		maxwrk = max(i__1,i__2);
	    } else {
		minwrk = *n * 3;
		igraphdhseqr_("E", "N", n, &c__1, n, &a[a_offset], lda, &wr[1], &wi[
			1], &vr[vr_offset], ldvr, &work[1], &c_n1, info);
		hswork = (integer) work[1];
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n + 1, i__1 = max(i__1,i__2), i__2 = *
			n + hswork;
		maxwrk = max(i__1,i__2);
	    }
	    maxwrk = max(maxwrk,minwrk);
	}
	work[1] = (doublereal) maxwrk;

	if (*lwork < minwrk && ! lquery) {
	    *info = -13;
	}
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEEV ", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

/*     Get machine constants */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S");
    bignum = 1. / smlnum;
    igraphdlabad_(&smlnum, &bignum);
    smlnum = sqrt(smlnum) / eps;
    bignum = 1. / smlnum;

/*     Scale A if max element outside range [SMLNUM,BIGNUM] */

    anrm = igraphdlange_("M", n, n, &a[a_offset], lda, dum);
    scalea = FALSE_;
    if (anrm > 0. && anrm < smlnum) {
	scalea = TRUE_;
	cscale = smlnum;
    } else if (anrm > bignum) {
	scalea = TRUE_;
	cscale = bignum;
    }
    if (scalea) {
	igraphdlascl_("G", &c__0, &c__0, &anrm, &cscale, n, n, &a[a_offset], lda, &
		ierr);
    }

/*     Balance the matrix   
       (Workspace: need N) */

    ibal = 1;
    igraphdgebal_("B", n, &a[a_offset], lda, &ilo, &ihi, &work[ibal], &ierr);

/*     Reduce to upper Hessenberg form   
       (Workspace: need 3*N, prefer 2*N+N*NB) */

    itau = ibal + *n;
    iwrk = itau + *n;
    i__1 = *lwork - iwrk + 1;
    igraphdgehrd_(n, &ilo, &ihi, &a[a_offset], lda, &work[itau], &work[iwrk], &i__1,
	     &ierr);

    if (wantvl) {

/*        Want left eigenvectors   
          Copy Householder vectors to VL */

	*(unsigned char *)side = 'L';
	igraphdlacpy_("L", n, n, &a[a_offset], lda, &vl[vl_offset], ldvl)
		;

/*        Generate orthogonal matrix in VL   
          (Workspace: need 3*N-1, prefer 2*N+(N-1)*NB) */

	i__1 = *lwork - iwrk + 1;
	igraphdorghr_(n, &ilo, &ihi, &vl[vl_offset], ldvl, &work[itau], &work[iwrk],
		 &i__1, &ierr);

/*        Perform QR iteration, accumulating Schur vectors in VL   
          (Workspace: need N+1, prefer N+HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_("S", "V", n, &ilo, &ihi, &a[a_offset], lda, &wr[1], &wi[1], &
		vl[vl_offset], ldvl, &work[iwrk], &i__1, info);

	if (wantvr) {

/*           Want left and right eigenvectors   
             Copy Schur vectors to VR */

	    *(unsigned char *)side = 'B';
	    igraphdlacpy_("F", n, n, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr);
	}

    } else if (wantvr) {

/*        Want right eigenvectors   
          Copy Householder vectors to VR */

	*(unsigned char *)side = 'R';
	igraphdlacpy_("L", n, n, &a[a_offset], lda, &vr[vr_offset], ldvr)
		;

/*        Generate orthogonal matrix in VR   
          (Workspace: need 3*N-1, prefer 2*N+(N-1)*NB) */

	i__1 = *lwork - iwrk + 1;
	igraphdorghr_(n, &ilo, &ihi, &vr[vr_offset], ldvr, &work[itau], &work[iwrk],
		 &i__1, &ierr);

/*        Perform QR iteration, accumulating Schur vectors in VR   
          (Workspace: need N+1, prefer N+HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_("S", "V", n, &ilo, &ihi, &a[a_offset], lda, &wr[1], &wi[1], &
		vr[vr_offset], ldvr, &work[iwrk], &i__1, info);

    } else {

/*        Compute eigenvalues only   
          (Workspace: need N+1, prefer N+HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_("E", "N", n, &ilo, &ihi, &a[a_offset], lda, &wr[1], &wi[1], &
		vr[vr_offset], ldvr, &work[iwrk], &i__1, info);
    }

/*     If INFO > 0 from DHSEQR, then quit */

    if (*info > 0) {
	goto L50;
    }

    if (wantvl || wantvr) {

/*        Compute left and/or right eigenvectors   
          (Workspace: need 4*N) */

	igraphdtrevc_(side, "B", select, n, &a[a_offset], lda, &vl[vl_offset], ldvl,
		 &vr[vr_offset], ldvr, n, &nout, &work[iwrk], &ierr);
    }

    if (wantvl) {

/*        Undo balancing of left eigenvectors   
          (Workspace: need N) */

	igraphdgebak_("B", "L", n, &ilo, &ihi, &work[ibal], n, &vl[vl_offset], ldvl,
		 &ierr);

/*        Normalize left eigenvectors and make largest component real */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (wi[i__] == 0.) {
		scl = 1. / igraphdnrm2_(n, &vl[i__ * vl_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vl[i__ * vl_dim1 + 1], &c__1);
	    } else if (wi[i__] > 0.) {
		d__1 = igraphdnrm2_(n, &vl[i__ * vl_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vl[(i__ + 1) * vl_dim1 + 1], &c__1);
		scl = 1. / igraphdlapy2_(&d__1, &d__2);
		igraphdscal_(n, &scl, &vl[i__ * vl_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vl[(i__ + 1) * vl_dim1 + 1], &c__1);
		i__2 = *n;
		for (k = 1; k <= i__2; ++k) {
/* Computing 2nd power */
		    d__1 = vl[k + i__ * vl_dim1];
/* Computing 2nd power */
		    d__2 = vl[k + (i__ + 1) * vl_dim1];
		    work[iwrk + k - 1] = d__1 * d__1 + d__2 * d__2;
/* L10: */
		}
		k = igraphidamax_(n, &work[iwrk], &c__1);
		igraphdlartg_(&vl[k + i__ * vl_dim1], &vl[k + (i__ + 1) * vl_dim1], 
			&cs, &sn, &r__);
		igraphdrot_(n, &vl[i__ * vl_dim1 + 1], &c__1, &vl[(i__ + 1) * 
			vl_dim1 + 1], &c__1, &cs, &sn);
		vl[k + (i__ + 1) * vl_dim1] = 0.;
	    }
/* L20: */
	}
    }

    if (wantvr) {

/*        Undo balancing of right eigenvectors   
          (Workspace: need N) */

	igraphdgebak_("B", "R", n, &ilo, &ihi, &work[ibal], n, &vr[vr_offset], ldvr,
		 &ierr);

/*        Normalize right eigenvectors and make largest component real */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (wi[i__] == 0.) {
		scl = 1. / igraphdnrm2_(n, &vr[i__ * vr_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vr[i__ * vr_dim1 + 1], &c__1);
	    } else if (wi[i__] > 0.) {
		d__1 = igraphdnrm2_(n, &vr[i__ * vr_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vr[(i__ + 1) * vr_dim1 + 1], &c__1);
		scl = 1. / igraphdlapy2_(&d__1, &d__2);
		igraphdscal_(n, &scl, &vr[i__ * vr_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vr[(i__ + 1) * vr_dim1 + 1], &c__1);
		i__2 = *n;
		for (k = 1; k <= i__2; ++k) {
/* Computing 2nd power */
		    d__1 = vr[k + i__ * vr_dim1];
/* Computing 2nd power */
		    d__2 = vr[k + (i__ + 1) * vr_dim1];
		    work[iwrk + k - 1] = d__1 * d__1 + d__2 * d__2;
/* L30: */
		}
		k = igraphidamax_(n, &work[iwrk], &c__1);
		igraphdlartg_(&vr[k + i__ * vr_dim1], &vr[k + (i__ + 1) * vr_dim1], 
			&cs, &sn, &r__);
		igraphdrot_(n, &vr[i__ * vr_dim1 + 1], &c__1, &vr[(i__ + 1) * 
			vr_dim1 + 1], &c__1, &cs, &sn);
		vr[k + (i__ + 1) * vr_dim1] = 0.;
	    }
/* L40: */
	}
    }

/*     Undo scaling if necessary */

L50:
    if (scalea) {
	i__1 = *n - *info;
/* Computing MAX */
	i__3 = *n - *info;
	i__2 = max(i__3,1);
	igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wr[*info + 
		1], &i__2, &ierr);
	i__1 = *n - *info;
/* Computing MAX */
	i__3 = *n - *info;
	i__2 = max(i__3,1);
	igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wi[*info + 
		1], &i__2, &ierr);
	if (*info > 0) {
	    i__1 = ilo - 1;
	    igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wr[1], 
		    n, &ierr);
	    i__1 = ilo - 1;
	    igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wi[1], 
		    n, &ierr);
	}
    }

    work[1] = (doublereal) maxwrk;
    return 0;

/*     End of DGEEV */

} /* igraphdgeev_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgeevx.c0000644000175100001710000006675100000000000024047 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__0 = 0;
static integer c_n1 = -1;

/* > \brief  DGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE mat
rices   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEEVX + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, WI,   
                            VL, LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM,   
                            RCONDE, RCONDV, WORK, LWORK, IWORK, INFO )   

         CHARACTER          BALANC, JOBVL, JOBVR, SENSE   
         INTEGER            IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N   
         DOUBLE PRECISION   ABNRM   
         INTEGER            IWORK( * )   
         DOUBLE PRECISION   A( LDA, * ), RCONDE( * ), RCONDV( * ),   
        $                   SCALE( * ), VL( LDVL, * ), VR( LDVR, * ),   
        $                   WI( * ), WORK( * ), WR( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEEVX computes for an N-by-N real nonsymmetric matrix A, the   
   > eigenvalues and, optionally, the left and/or right eigenvectors.   
   >   
   > Optionally also, it computes a balancing transformation to improve   
   > the conditioning of the eigenvalues and eigenvectors (ILO, IHI,   
   > SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues   
   > (RCONDE), and reciprocal condition numbers for the right   
   > eigenvectors (RCONDV).   
   >   
   > The right eigenvector v(j) of A satisfies   
   >                  A * v(j) = lambda(j) * v(j)   
   > where lambda(j) is its eigenvalue.   
   > The left eigenvector u(j) of A satisfies   
   >               u(j)**H * A = lambda(j) * u(j)**H   
   > where u(j)**H denotes the conjugate-transpose of u(j).   
   >   
   > The computed eigenvectors are normalized to have Euclidean norm   
   > equal to 1 and largest component real.   
   >   
   > Balancing a matrix means permuting the rows and columns to make it   
   > more nearly upper triangular, and applying a diagonal similarity   
   > transformation D * A * D**(-1), where D is a diagonal matrix, to   
   > make its rows and columns closer in norm and the condition numbers   
   > of its eigenvalues and eigenvectors smaller.  The computed   
   > reciprocal condition numbers correspond to the balanced matrix.   
   > Permuting rows and columns will not change the condition numbers   
   > (in exact arithmetic) but diagonal scaling will.  For further   
   > explanation of balancing, see section 4.10.2 of the LAPACK   
   > Users' Guide.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] BALANC   
   > \verbatim   
   >          BALANC is CHARACTER*1   
   >          Indicates how the input matrix should be diagonally scaled   
   >          and/or permuted to improve the conditioning of its   
   >          eigenvalues.   
   >          = 'N': Do not diagonally scale or permute;   
   >          = 'P': Perform permutations to make the matrix more nearly   
   >                 upper triangular. Do not diagonally scale;   
   >          = 'S': Diagonally scale the matrix, i.e. replace A by   
   >                 D*A*D**(-1), where D is a diagonal matrix chosen   
   >                 to make the rows and columns of A more equal in   
   >                 norm. Do not permute;   
   >          = 'B': Both diagonally scale and permute A.   
   >   
   >          Computed reciprocal condition numbers will be for the matrix   
   >          after balancing and/or permuting. Permuting does not change   
   >          condition numbers (in exact arithmetic), but balancing does.   
   > \endverbatim   
   >   
   > \param[in] JOBVL   
   > \verbatim   
   >          JOBVL is CHARACTER*1   
   >          = 'N': left eigenvectors of A are not computed;   
   >          = 'V': left eigenvectors of A are computed.   
   >          If SENSE = 'E' or 'B', JOBVL must = 'V'.   
   > \endverbatim   
   >   
   > \param[in] JOBVR   
   > \verbatim   
   >          JOBVR is CHARACTER*1   
   >          = 'N': right eigenvectors of A are not computed;   
   >          = 'V': right eigenvectors of A are computed.   
   >          If SENSE = 'E' or 'B', JOBVR must = 'V'.   
   > \endverbatim   
   >   
   > \param[in] SENSE   
   > \verbatim   
   >          SENSE is CHARACTER*1   
   >          Determines which reciprocal condition numbers are computed.   
   >          = 'N': None are computed;   
   >          = 'E': Computed for eigenvalues only;   
   >          = 'V': Computed for right eigenvectors only;   
   >          = 'B': Computed for eigenvalues and right eigenvectors.   
   >   
   >          If SENSE = 'E' or 'B', both left and right eigenvectors   
   >          must also be computed (JOBVL = 'V' and JOBVR = 'V').   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the N-by-N matrix A.   
   >          On exit, A has been overwritten.  If JOBVL = 'V' or   
   >          JOBVR = 'V', A contains the real Schur form of the balanced   
   >          version of the input matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (N)   
   >          WR and WI contain the real and imaginary parts,   
   >          respectively, of the computed eigenvalues.  Complex   
   >          conjugate pairs of eigenvalues will appear consecutively   
   >          with the eigenvalue having the positive imaginary part   
   >          first.   
   > \endverbatim   
   >   
   > \param[out] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION array, dimension (LDVL,N)   
   >          If JOBVL = 'V', the left eigenvectors u(j) are stored one   
   >          after another in the columns of VL, in the same order   
   >          as their eigenvalues.   
   >          If JOBVL = 'N', VL is not referenced.   
   >          If the j-th eigenvalue is real, then u(j) = VL(:,j),   
   >          the j-th column of VL.   
   >          If the j-th and (j+1)-st eigenvalues form a complex   
   >          conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and   
   >          u(j+1) = VL(:,j) - i*VL(:,j+1).   
   > \endverbatim   
   >   
   > \param[in] LDVL   
   > \verbatim   
   >          LDVL is INTEGER   
   >          The leading dimension of the array VL.  LDVL >= 1; if   
   >          JOBVL = 'V', LDVL >= N.   
   > \endverbatim   
   >   
   > \param[out] VR   
   > \verbatim   
   >          VR is DOUBLE PRECISION array, dimension (LDVR,N)   
   >          If JOBVR = 'V', the right eigenvectors v(j) are stored one   
   >          after another in the columns of VR, in the same order   
   >          as their eigenvalues.   
   >          If JOBVR = 'N', VR is not referenced.   
   >          If the j-th eigenvalue is real, then v(j) = VR(:,j),   
   >          the j-th column of VR.   
   >          If the j-th and (j+1)-st eigenvalues form a complex   
   >          conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and   
   >          v(j+1) = VR(:,j) - i*VR(:,j+1).   
   > \endverbatim   
   >   
   > \param[in] LDVR   
   > \verbatim   
   >          LDVR is INTEGER   
   >          The leading dimension of the array VR.  LDVR >= 1, and if   
   >          JOBVR = 'V', LDVR >= N.   
   > \endverbatim   
   >   
   > \param[out] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[out] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >          ILO and IHI are integer values determined when A was   
   >          balanced.  The balanced A(i,j) = 0 if I > J and   
   >          J = 1,...,ILO-1 or I = IHI+1,...,N.   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION array, dimension (N)   
   >          Details of the permutations and scaling factors applied   
   >          when balancing A.  If P(j) is the index of the row and column   
   >          interchanged with row and column j, and D(j) is the scaling   
   >          factor applied to row and column j, then   
   >          SCALE(J) = P(J),    for J = 1,...,ILO-1   
   >                   = D(J),    for J = ILO,...,IHI   
   >                   = P(J)     for J = IHI+1,...,N.   
   >          The order in which the interchanges are made is N to IHI+1,   
   >          then 1 to ILO-1.   
   > \endverbatim   
   >   
   > \param[out] ABNRM   
   > \verbatim   
   >          ABNRM is DOUBLE PRECISION   
   >          The one-norm of the balanced matrix (the maximum   
   >          of the sum of absolute values of elements of any column).   
   > \endverbatim   
   >   
   > \param[out] RCONDE   
   > \verbatim   
   >          RCONDE is DOUBLE PRECISION array, dimension (N)   
   >          RCONDE(j) is the reciprocal condition number of the j-th   
   >          eigenvalue.   
   > \endverbatim   
   >   
   > \param[out] RCONDV   
   > \verbatim   
   >          RCONDV is DOUBLE PRECISION array, dimension (N)   
   >          RCONDV(j) is the reciprocal condition number of the j-th   
   >          right eigenvector.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   If SENSE = 'N' or 'E',   
   >          LWORK >= max(1,2*N), and if JOBVL = 'V' or JOBVR = 'V',   
   >          LWORK >= 3*N.  If SENSE = 'V' or 'B', LWORK >= N*(N+6).   
   >          For good performance, LWORK must generally be larger.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (2*N-2)   
   >          If SENSE = 'N' or 'E', not referenced.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   >          > 0:  if INFO = i, the QR algorithm failed to compute all the   
   >                eigenvalues, and no eigenvectors or condition numbers   
   >                have been computed; elements 1:ILO-1 and i+1:N of WR   
   >                and WI contain eigenvalues which have converged.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEeigen   

    =====================================================================   
   Subroutine */ int igraphdgeevx_(char *balanc, char *jobvl, char *jobvr, char *
	sense, integer *n, doublereal *a, integer *lda, doublereal *wr, 
	doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, 
	integer *ldvr, integer *ilo, integer *ihi, doublereal *scale, 
	doublereal *abnrm, doublereal *rconde, doublereal *rcondv, doublereal 
	*work, integer *lwork, integer *iwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, vl_dim1, vl_offset, vr_dim1, vr_offset, i__1, 
	    i__2, i__3;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, k;
    doublereal r__, cs, sn;
    char job[1];
    doublereal scl, dum[1], eps;
    char side[1];
    doublereal anrm;
    integer ierr, itau;
    extern /* Subroutine */ int igraphdrot_(integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *);
    integer iwrk, nout;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    integer icond;
    extern logical igraphlsame_(char *, char *);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlabad_(doublereal *, doublereal *), igraphdgebak_(
	    char *, char *, integer *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *), 
	    igraphdgebal_(char *, integer *, doublereal *, integer *, integer *, 
	    integer *, doublereal *, integer *);
    logical scalea;
    extern doublereal igraphdlamch_(char *);
    doublereal cscale;
    extern doublereal igraphdlange_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *);
    extern /* Subroutine */ int igraphdgehrd_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdlascl_(char *, integer *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphdlartg_(doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *), igraphxerbla_(char *, integer *, ftnlen);
    logical select[1];
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    doublereal bignum;
    extern /* Subroutine */ int igraphdorghr_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdhseqr_(char *, char *, integer *, integer *, integer 
	    *, doublereal *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, integer *), igraphdtrevc_(char *, char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, integer *), igraphdtrsna_(char *, char *, logical *, integer *, doublereal 
	    *, integer *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *, integer *);
    integer minwrk, maxwrk;
    logical wantvl, wntsnb;
    integer hswork;
    logical wntsne;
    doublereal smlnum;
    logical lquery, wantvr, wntsnn, wntsnv;


/*  -- LAPACK driver routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --wr;
    --wi;
    vl_dim1 = *ldvl;
    vl_offset = 1 + vl_dim1;
    vl -= vl_offset;
    vr_dim1 = *ldvr;
    vr_offset = 1 + vr_dim1;
    vr -= vr_offset;
    --scale;
    --rconde;
    --rcondv;
    --work;
    --iwork;

    /* Function Body */
    *info = 0;
    lquery = *lwork == -1;
    wantvl = igraphlsame_(jobvl, "V");
    wantvr = igraphlsame_(jobvr, "V");
    wntsnn = igraphlsame_(sense, "N");
    wntsne = igraphlsame_(sense, "E");
    wntsnv = igraphlsame_(sense, "V");
    wntsnb = igraphlsame_(sense, "B");
    if (! (igraphlsame_(balanc, "N") || igraphlsame_(balanc, "S") || igraphlsame_(balanc, "P") 
	    || igraphlsame_(balanc, "B"))) {
	*info = -1;
    } else if (! wantvl && ! igraphlsame_(jobvl, "N")) {
	*info = -2;
    } else if (! wantvr && ! igraphlsame_(jobvr, "N")) {
	*info = -3;
    } else if (! (wntsnn || wntsne || wntsnb || wntsnv) || (wntsne || wntsnb) 
	    && ! (wantvl && wantvr)) {
	*info = -4;
    } else if (*n < 0) {
	*info = -5;
    } else if (*lda < max(1,*n)) {
	*info = -7;
    } else if (*ldvl < 1 || wantvl && *ldvl < *n) {
	*info = -11;
    } else if (*ldvr < 1 || wantvr && *ldvr < *n) {
	*info = -13;
    }

/*     Compute workspace   
        (Note: Comments in the code beginning "Workspace:" describe the   
         minimal amount of workspace needed at that point in the code,   
         as well as the preferred amount for good performance.   
         NB refers to the optimal block size for the immediately   
         following subroutine, as returned by ILAENV.   
         HSWORK refers to the workspace preferred by DHSEQR, as   
         calculated below. HSWORK is computed assuming ILO=1 and IHI=N,   
         the worst case.) */

    if (*info == 0) {
	if (*n == 0) {
	    minwrk = 1;
	    maxwrk = 1;
	} else {
	    maxwrk = *n + *n * igraphilaenv_(&c__1, "DGEHRD", " ", n, &c__1, n, &
		    c__0, (ftnlen)6, (ftnlen)1);

	    if (wantvl) {
		igraphdhseqr_("S", "V", n, &c__1, n, &a[a_offset], lda, &wr[1], &wi[
			1], &vl[vl_offset], ldvl, &work[1], &c_n1, info);
	    } else if (wantvr) {
		igraphdhseqr_("S", "V", n, &c__1, n, &a[a_offset], lda, &wr[1], &wi[
			1], &vr[vr_offset], ldvr, &work[1], &c_n1, info);
	    } else {
		if (wntsnn) {
		    igraphdhseqr_("E", "N", n, &c__1, n, &a[a_offset], lda, &wr[1], 
			    &wi[1], &vr[vr_offset], ldvr, &work[1], &c_n1, 
			    info);
		} else {
		    igraphdhseqr_("S", "N", n, &c__1, n, &a[a_offset], lda, &wr[1], 
			    &wi[1], &vr[vr_offset], ldvr, &work[1], &c_n1, 
			    info);
		}
	    }
	    hswork = (integer) work[1];

	    if (! wantvl && ! wantvr) {
		minwrk = *n << 1;
		if (! wntsnn) {
/* Computing MAX */
		    i__1 = minwrk, i__2 = *n * *n + *n * 6;
		    minwrk = max(i__1,i__2);
		}
		maxwrk = max(maxwrk,hswork);
		if (! wntsnn) {
/* Computing MAX */
		    i__1 = maxwrk, i__2 = *n * *n + *n * 6;
		    maxwrk = max(i__1,i__2);
		}
	    } else {
		minwrk = *n * 3;
		if (! wntsnn && ! wntsne) {
/* Computing MAX */
		    i__1 = minwrk, i__2 = *n * *n + *n * 6;
		    minwrk = max(i__1,i__2);
		}
		maxwrk = max(maxwrk,hswork);
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n + (*n - 1) * igraphilaenv_(&c__1, "DORGHR",
			 " ", n, &c__1, n, &c_n1, (ftnlen)6, (ftnlen)1);
		maxwrk = max(i__1,i__2);
		if (! wntsnn && ! wntsne) {
/* Computing MAX */
		    i__1 = maxwrk, i__2 = *n * *n + *n * 6;
		    maxwrk = max(i__1,i__2);
		}
/* Computing MAX */
		i__1 = maxwrk, i__2 = *n * 3;
		maxwrk = max(i__1,i__2);
	    }
	    maxwrk = max(maxwrk,minwrk);
	}
	work[1] = (doublereal) maxwrk;

	if (*lwork < minwrk && ! lquery) {
	    *info = -21;
	}
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEEVX", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

/*     Get machine constants */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S");
    bignum = 1. / smlnum;
    igraphdlabad_(&smlnum, &bignum);
    smlnum = sqrt(smlnum) / eps;
    bignum = 1. / smlnum;

/*     Scale A if max element outside range [SMLNUM,BIGNUM] */

    icond = 0;
    anrm = igraphdlange_("M", n, n, &a[a_offset], lda, dum);
    scalea = FALSE_;
    if (anrm > 0. && anrm < smlnum) {
	scalea = TRUE_;
	cscale = smlnum;
    } else if (anrm > bignum) {
	scalea = TRUE_;
	cscale = bignum;
    }
    if (scalea) {
	igraphdlascl_("G", &c__0, &c__0, &anrm, &cscale, n, n, &a[a_offset], lda, &
		ierr);
    }

/*     Balance the matrix and compute ABNRM */

    igraphdgebal_(balanc, n, &a[a_offset], lda, ilo, ihi, &scale[1], &ierr);
    *abnrm = igraphdlange_("1", n, n, &a[a_offset], lda, dum);
    if (scalea) {
	dum[0] = *abnrm;
	igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &c__1, &c__1, dum, &c__1, &
		ierr);
	*abnrm = dum[0];
    }

/*     Reduce to upper Hessenberg form   
       (Workspace: need 2*N, prefer N+N*NB) */

    itau = 1;
    iwrk = itau + *n;
    i__1 = *lwork - iwrk + 1;
    igraphdgehrd_(n, ilo, ihi, &a[a_offset], lda, &work[itau], &work[iwrk], &i__1, &
	    ierr);

    if (wantvl) {

/*        Want left eigenvectors   
          Copy Householder vectors to VL */

	*(unsigned char *)side = 'L';
	igraphdlacpy_("L", n, n, &a[a_offset], lda, &vl[vl_offset], ldvl)
		;

/*        Generate orthogonal matrix in VL   
          (Workspace: need 2*N-1, prefer N+(N-1)*NB) */

	i__1 = *lwork - iwrk + 1;
	igraphdorghr_(n, ilo, ihi, &vl[vl_offset], ldvl, &work[itau], &work[iwrk], &
		i__1, &ierr);

/*        Perform QR iteration, accumulating Schur vectors in VL   
          (Workspace: need 1, prefer HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_("S", "V", n, ilo, ihi, &a[a_offset], lda, &wr[1], &wi[1], &vl[
		vl_offset], ldvl, &work[iwrk], &i__1, info);

	if (wantvr) {

/*           Want left and right eigenvectors   
             Copy Schur vectors to VR */

	    *(unsigned char *)side = 'B';
	    igraphdlacpy_("F", n, n, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr);
	}

    } else if (wantvr) {

/*        Want right eigenvectors   
          Copy Householder vectors to VR */

	*(unsigned char *)side = 'R';
	igraphdlacpy_("L", n, n, &a[a_offset], lda, &vr[vr_offset], ldvr)
		;

/*        Generate orthogonal matrix in VR   
          (Workspace: need 2*N-1, prefer N+(N-1)*NB) */

	i__1 = *lwork - iwrk + 1;
	igraphdorghr_(n, ilo, ihi, &vr[vr_offset], ldvr, &work[itau], &work[iwrk], &
		i__1, &ierr);

/*        Perform QR iteration, accumulating Schur vectors in VR   
          (Workspace: need 1, prefer HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_("S", "V", n, ilo, ihi, &a[a_offset], lda, &wr[1], &wi[1], &vr[
		vr_offset], ldvr, &work[iwrk], &i__1, info);

    } else {

/*        Compute eigenvalues only   
          If condition numbers desired, compute Schur form */

	if (wntsnn) {
	    *(unsigned char *)job = 'E';
	} else {
	    *(unsigned char *)job = 'S';
	}

/*        (Workspace: need 1, prefer HSWORK (see comments) ) */

	iwrk = itau;
	i__1 = *lwork - iwrk + 1;
	igraphdhseqr_(job, "N", n, ilo, ihi, &a[a_offset], lda, &wr[1], &wi[1], &vr[
		vr_offset], ldvr, &work[iwrk], &i__1, info);
    }

/*     If INFO > 0 from DHSEQR, then quit */

    if (*info > 0) {
	goto L50;
    }

    if (wantvl || wantvr) {

/*        Compute left and/or right eigenvectors   
          (Workspace: need 3*N) */

	igraphdtrevc_(side, "B", select, n, &a[a_offset], lda, &vl[vl_offset], ldvl,
		 &vr[vr_offset], ldvr, n, &nout, &work[iwrk], &ierr);
    }

/*     Compute condition numbers if desired   
       (Workspace: need N*N+6*N unless SENSE = 'E') */

    if (! wntsnn) {
	igraphdtrsna_(sense, "A", select, n, &a[a_offset], lda, &vl[vl_offset], 
		ldvl, &vr[vr_offset], ldvr, &rconde[1], &rcondv[1], n, &nout, 
		&work[iwrk], n, &iwork[1], &icond);
    }

    if (wantvl) {

/*        Undo balancing of left eigenvectors */

	igraphdgebak_(balanc, "L", n, ilo, ihi, &scale[1], n, &vl[vl_offset], ldvl, 
		&ierr);

/*        Normalize left eigenvectors and make largest component real */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (wi[i__] == 0.) {
		scl = 1. / igraphdnrm2_(n, &vl[i__ * vl_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vl[i__ * vl_dim1 + 1], &c__1);
	    } else if (wi[i__] > 0.) {
		d__1 = igraphdnrm2_(n, &vl[i__ * vl_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vl[(i__ + 1) * vl_dim1 + 1], &c__1);
		scl = 1. / igraphdlapy2_(&d__1, &d__2);
		igraphdscal_(n, &scl, &vl[i__ * vl_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vl[(i__ + 1) * vl_dim1 + 1], &c__1);
		i__2 = *n;
		for (k = 1; k <= i__2; ++k) {
/* Computing 2nd power */
		    d__1 = vl[k + i__ * vl_dim1];
/* Computing 2nd power */
		    d__2 = vl[k + (i__ + 1) * vl_dim1];
		    work[k] = d__1 * d__1 + d__2 * d__2;
/* L10: */
		}
		k = igraphidamax_(n, &work[1], &c__1);
		igraphdlartg_(&vl[k + i__ * vl_dim1], &vl[k + (i__ + 1) * vl_dim1], 
			&cs, &sn, &r__);
		igraphdrot_(n, &vl[i__ * vl_dim1 + 1], &c__1, &vl[(i__ + 1) * 
			vl_dim1 + 1], &c__1, &cs, &sn);
		vl[k + (i__ + 1) * vl_dim1] = 0.;
	    }
/* L20: */
	}
    }

    if (wantvr) {

/*        Undo balancing of right eigenvectors */

	igraphdgebak_(balanc, "R", n, ilo, ihi, &scale[1], n, &vr[vr_offset], ldvr, 
		&ierr);

/*        Normalize right eigenvectors and make largest component real */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (wi[i__] == 0.) {
		scl = 1. / igraphdnrm2_(n, &vr[i__ * vr_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vr[i__ * vr_dim1 + 1], &c__1);
	    } else if (wi[i__] > 0.) {
		d__1 = igraphdnrm2_(n, &vr[i__ * vr_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vr[(i__ + 1) * vr_dim1 + 1], &c__1);
		scl = 1. / igraphdlapy2_(&d__1, &d__2);
		igraphdscal_(n, &scl, &vr[i__ * vr_dim1 + 1], &c__1);
		igraphdscal_(n, &scl, &vr[(i__ + 1) * vr_dim1 + 1], &c__1);
		i__2 = *n;
		for (k = 1; k <= i__2; ++k) {
/* Computing 2nd power */
		    d__1 = vr[k + i__ * vr_dim1];
/* Computing 2nd power */
		    d__2 = vr[k + (i__ + 1) * vr_dim1];
		    work[k] = d__1 * d__1 + d__2 * d__2;
/* L30: */
		}
		k = igraphidamax_(n, &work[1], &c__1);
		igraphdlartg_(&vr[k + i__ * vr_dim1], &vr[k + (i__ + 1) * vr_dim1], 
			&cs, &sn, &r__);
		igraphdrot_(n, &vr[i__ * vr_dim1 + 1], &c__1, &vr[(i__ + 1) * 
			vr_dim1 + 1], &c__1, &cs, &sn);
		vr[k + (i__ + 1) * vr_dim1] = 0.;
	    }
/* L40: */
	}
    }

/*     Undo scaling if necessary */

L50:
    if (scalea) {
	i__1 = *n - *info;
/* Computing MAX */
	i__3 = *n - *info;
	i__2 = max(i__3,1);
	igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wr[*info + 
		1], &i__2, &ierr);
	i__1 = *n - *info;
/* Computing MAX */
	i__3 = *n - *info;
	i__2 = max(i__3,1);
	igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wi[*info + 
		1], &i__2, &ierr);
	if (*info == 0) {
	    if ((wntsnv || wntsnb) && icond == 0) {
		igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, n, &c__1, &rcondv[
			1], n, &ierr);
	    }
	} else {
	    i__1 = *ilo - 1;
	    igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wr[1], 
		    n, &ierr);
	    i__1 = *ilo - 1;
	    igraphdlascl_("G", &c__0, &c__0, &cscale, &anrm, &i__1, &c__1, &wi[1], 
		    n, &ierr);
	}
    }

    work[1] = (doublereal) maxwrk;
    return 0;

/*     End of DGEEVX */

} /* igraphdgeevx_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgehd2.c0000644000175100001710000001744500000000000023716 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DGEHD2 reduces a general square matrix to upper Hessenberg form using an unblocked algorithm. 
  

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEHD2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEHD2( N, ILO, IHI, A, LDA, TAU, WORK, INFO )   

         INTEGER            IHI, ILO, INFO, LDA, N   
         DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEHD2 reduces a real general matrix A to upper Hessenberg form H by   
   > an orthogonal similarity transformation:  Q**T * A * Q = H .   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >   
   >          It is assumed that A is already upper triangular in rows   
   >          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally   
   >          set by a previous call to DGEBAL; otherwise they should be   
   >          set to 1 and N respectively. See Further Details.   
   >          1 <= ILO <= IHI <= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the n by n general matrix to be reduced.   
   >          On exit, the upper triangle and the first subdiagonal of A   
   >          are overwritten with the upper Hessenberg matrix H, and the   
   >          elements below the first subdiagonal, with the array TAU,   
   >          represent the orthogonal matrix Q as a product of elementary   
   >          reflectors. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          The scalar factors of the elementary reflectors (see Further   
   >          Details).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit.   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The matrix Q is represented as a product of (ihi-ilo) elementary   
   >  reflectors   
   >   
   >     Q = H(ilo) H(ilo+1) . . . H(ihi-1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on   
   >  exit in A(i+2:ihi,i), and tau in TAU(i).   
   >   
   >  The contents of A are illustrated by the following example, with   
   >  n = 7, ilo = 2 and ihi = 6:   
   >   
   >  on entry,                        on exit,   
   >   
   >  ( a   a   a   a   a   a   a )    (  a   a   h   h   h   h   a )   
   >  (     a   a   a   a   a   a )    (      a   h   h   h   h   a )   
   >  (     a   a   a   a   a   a )    (      h   h   h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  h   h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  v3  h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  v3  v4  h   h   h )   
   >  (                         a )    (                          a )   
   >   
   >  where a denotes an element of the original matrix A, h denotes a   
   >  modified element of the upper Hessenberg matrix H, and vi denotes an   
   >  element of the vector defining H(i).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgehd2_(integer *n, integer *ilo, integer *ihi, 
	doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
	integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__;
    doublereal aii;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *), igraphdlarfg_(integer *, doublereal *, 
	    doublereal *, integer *, doublereal *), igraphxerbla_(char *, integer *,
	     ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    if (*n < 0) {
	*info = -1;
    } else if (*ilo < 1 || *ilo > max(1,*n)) {
	*info = -2;
    } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
	*info = -3;
    } else if (*lda < max(1,*n)) {
	*info = -5;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEHD2", &i__1, (ftnlen)6);
	return 0;
    }

    i__1 = *ihi - 1;
    for (i__ = *ilo; i__ <= i__1; ++i__) {

/*        Compute elementary reflector H(i) to annihilate A(i+2:ihi,i) */

	i__2 = *ihi - i__;
/* Computing MIN */
	i__3 = i__ + 2;
	igraphdlarfg_(&i__2, &a[i__ + 1 + i__ * a_dim1], &a[min(i__3,*n) + i__ * 
		a_dim1], &c__1, &tau[i__]);
	aii = a[i__ + 1 + i__ * a_dim1];
	a[i__ + 1 + i__ * a_dim1] = 1.;

/*        Apply H(i) to A(1:ihi,i+1:ihi) from the right */

	i__2 = *ihi - i__;
	igraphdlarf_("Right", ihi, &i__2, &a[i__ + 1 + i__ * a_dim1], &c__1, &tau[
		i__], &a[(i__ + 1) * a_dim1 + 1], lda, &work[1]);

/*        Apply H(i) to A(i+1:ihi,i+1:n) from the left */

	i__2 = *ihi - i__;
	i__3 = *n - i__;
	igraphdlarf_("Left", &i__2, &i__3, &a[i__ + 1 + i__ * a_dim1], &c__1, &tau[
		i__], &a[i__ + 1 + (i__ + 1) * a_dim1], lda, &work[1]);

	a[i__ + 1 + i__ * a_dim1] = aii;
/* L10: */
    }

    return 0;

/*     End of DGEHD2 */

} /* igraphdgehd2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgehrd.c0000644000175100001710000003153200000000000024007 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;
static integer c__65 = 65;
static doublereal c_b25 = -1.;
static doublereal c_b26 = 1.;

/* > \brief \b DGEHRD   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEHRD + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEHRD( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO )   

         INTEGER            IHI, ILO, INFO, LDA, LWORK, N   
         DOUBLE PRECISION  A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEHRD reduces a real general matrix A to upper Hessenberg form H by   
   > an orthogonal similarity transformation:  Q**T * A * Q = H .   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >   
   >          It is assumed that A is already upper triangular in rows   
   >          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally   
   >          set by a previous call to DGEBAL; otherwise they should be   
   >          set to 1 and N respectively. See Further Details.   
   >          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the N-by-N general matrix to be reduced.   
   >          On exit, the upper triangle and the first subdiagonal of A   
   >          are overwritten with the upper Hessenberg matrix H, and the   
   >          elements below the first subdiagonal, with the array TAU,   
   >          represent the orthogonal matrix Q as a product of elementary   
   >          reflectors. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          The scalar factors of the elementary reflectors (see Further   
   >          Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to   
   >          zero.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LWORK)   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The length of the array WORK.  LWORK >= max(1,N).   
   >          For optimum performance LWORK >= N*NB, where NB is the   
   >          optimal blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleGEcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The matrix Q is represented as a product of (ihi-ilo) elementary   
   >  reflectors   
   >   
   >     Q = H(ilo) H(ilo+1) . . . H(ihi-1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on   
   >  exit in A(i+2:ihi,i), and tau in TAU(i).   
   >   
   >  The contents of A are illustrated by the following example, with   
   >  n = 7, ilo = 2 and ihi = 6:   
   >   
   >  on entry,                        on exit,   
   >   
   >  ( a   a   a   a   a   a   a )    (  a   a   h   h   h   h   a )   
   >  (     a   a   a   a   a   a )    (      a   h   h   h   h   a )   
   >  (     a   a   a   a   a   a )    (      h   h   h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  h   h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  v3  h   h   h   h )   
   >  (     a   a   a   a   a   a )    (      v2  v3  v4  h   h   h )   
   >  (                         a )    (                          a )   
   >   
   >  where a denotes an element of the original matrix A, h denotes a   
   >  modified element of the upper Hessenberg matrix H, and vi denotes an   
   >  element of the vector defining H(i).   
   >   
   >  This file is a slight modification of LAPACK-3.0's DGEHRD   
   >  subroutine incorporating improvements proposed by Quintana-Orti and   
   >  Van de Geijn (2006). (See DLAHR2.)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgehrd_(integer *n, integer *ilo, integer *ihi, 
	doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
	integer *lwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4;

    /* Local variables */
    integer i__, j;
    doublereal t[4160]	/* was [65][64] */;
    integer ib;
    doublereal ei;
    integer nb, nh, nx, iws;
    extern /* Subroutine */ int igraphdgemm_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    integer nbmin, iinfo;
    extern /* Subroutine */ int igraphdtrmm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdaxpy_(
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *), igraphdgehd2_(integer *, integer *, integer *, doublereal *,
	     integer *, doublereal *, doublereal *, integer *), igraphdlahr2_(
	    integer *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *), 
	    igraphdlarfb_(char *, char *, char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    integer ldwork, lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
/* Computing MIN */
    i__1 = 64, i__2 = igraphilaenv_(&c__1, "DGEHRD", " ", n, ilo, ihi, &c_n1, (
	    ftnlen)6, (ftnlen)1);
    nb = min(i__1,i__2);
    lwkopt = *n * nb;
    work[1] = (doublereal) lwkopt;
    lquery = *lwork == -1;
    if (*n < 0) {
	*info = -1;
    } else if (*ilo < 1 || *ilo > max(1,*n)) {
	*info = -2;
    } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
	*info = -3;
    } else if (*lda < max(1,*n)) {
	*info = -5;
    } else if (*lwork < max(1,*n) && ! lquery) {
	*info = -8;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEHRD", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Set elements 1:ILO-1 and IHI:N-1 of TAU to zero */

    i__1 = *ilo - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	tau[i__] = 0.;
/* L10: */
    }
    i__1 = *n - 1;
    for (i__ = max(1,*ihi); i__ <= i__1; ++i__) {
	tau[i__] = 0.;
/* L20: */
    }

/*     Quick return if possible */

    nh = *ihi - *ilo + 1;
    if (nh <= 1) {
	work[1] = 1.;
	return 0;
    }

/*     Determine the block size   

   Computing MIN */
    i__1 = 64, i__2 = igraphilaenv_(&c__1, "DGEHRD", " ", n, ilo, ihi, &c_n1, (
	    ftnlen)6, (ftnlen)1);
    nb = min(i__1,i__2);
    nbmin = 2;
    iws = 1;
    if (nb > 1 && nb < nh) {

/*        Determine when to cross over from blocked to unblocked code   
          (last block is always handled by unblocked code)   

   Computing MAX */
	i__1 = nb, i__2 = igraphilaenv_(&c__3, "DGEHRD", " ", n, ilo, ihi, &c_n1, (
		ftnlen)6, (ftnlen)1);
	nx = max(i__1,i__2);
	if (nx < nh) {

/*           Determine if workspace is large enough for blocked code */

	    iws = *n * nb;
	    if (*lwork < iws) {

/*              Not enough workspace to use optimal NB:  determine the   
                minimum value of NB, and reduce NB or force use of   
                unblocked code   

   Computing MAX */
		i__1 = 2, i__2 = igraphilaenv_(&c__2, "DGEHRD", " ", n, ilo, ihi, &
			c_n1, (ftnlen)6, (ftnlen)1);
		nbmin = max(i__1,i__2);
		if (*lwork >= *n * nbmin) {
		    nb = *lwork / *n;
		} else {
		    nb = 1;
		}
	    }
	}
    }
    ldwork = *n;

    if (nb < nbmin || nb >= nh) {

/*        Use unblocked code below */

	i__ = *ilo;

    } else {

/*        Use blocked code */

	i__1 = *ihi - 1 - nx;
	i__2 = nb;
	for (i__ = *ilo; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MIN */
	    i__3 = nb, i__4 = *ihi - i__;
	    ib = min(i__3,i__4);

/*           Reduce columns i:i+ib-1 to Hessenberg form, returning the   
             matrices V and T of the block reflector H = I - V*T*V**T   
             which performs the reduction, and also the matrix Y = A*V*T */

	    igraphdlahr2_(ihi, &i__, &ib, &a[i__ * a_dim1 + 1], lda, &tau[i__], t, &
		    c__65, &work[1], &ldwork);

/*           Apply the block reflector H to A(1:ihi,i+ib:ihi) from the   
             right, computing  A := A - Y * V**T. V(i+ib,ib-1) must be set   
             to 1 */

	    ei = a[i__ + ib + (i__ + ib - 1) * a_dim1];
	    a[i__ + ib + (i__ + ib - 1) * a_dim1] = 1.;
	    i__3 = *ihi - i__ - ib + 1;
	    igraphdgemm_("No transpose", "Transpose", ihi, &i__3, &ib, &c_b25, &
		    work[1], &ldwork, &a[i__ + ib + i__ * a_dim1], lda, &
		    c_b26, &a[(i__ + ib) * a_dim1 + 1], lda);
	    a[i__ + ib + (i__ + ib - 1) * a_dim1] = ei;

/*           Apply the block reflector H to A(1:i,i+1:i+ib-1) from the   
             right */

	    i__3 = ib - 1;
	    igraphdtrmm_("Right", "Lower", "Transpose", "Unit", &i__, &i__3, &c_b26,
		     &a[i__ + 1 + i__ * a_dim1], lda, &work[1], &ldwork);
	    i__3 = ib - 2;
	    for (j = 0; j <= i__3; ++j) {
		igraphdaxpy_(&i__, &c_b25, &work[ldwork * j + 1], &c__1, &a[(i__ + 
			j + 1) * a_dim1 + 1], &c__1);
/* L30: */
	    }

/*           Apply the block reflector H to A(i+1:ihi,i+ib:n) from the   
             left */

	    i__3 = *ihi - i__;
	    i__4 = *n - i__ - ib + 1;
	    igraphdlarfb_("Left", "Transpose", "Forward", "Columnwise", &i__3, &
		    i__4, &ib, &a[i__ + 1 + i__ * a_dim1], lda, t, &c__65, &a[
		    i__ + 1 + (i__ + ib) * a_dim1], lda, &work[1], &ldwork);
/* L40: */
	}
    }

/*     Use unblocked code to reduce the rest of the matrix */

    igraphdgehd2_(n, &i__, ihi, &a[a_offset], lda, &tau[1], &work[1], &iinfo);
    work[1] = (doublereal) iws;

    return 0;

/*     End of DGEHRD */

} /* igraphdgehrd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgemm.c0000644000175100001710000002765700000000000023660 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DGEMM   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)   

         DOUBLE PRECISION ALPHA,BETA   
         INTEGER K,LDA,LDB,LDC,M,N   
         CHARACTER TRANSA,TRANSB   
         DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEMM  performs one of the matrix-matrix operations   
   >   
   >    C := alpha*op( A )*op( B ) + beta*C,   
   >   
   > where  op( X ) is one of   
   >   
   >    op( X ) = X   or   op( X ) = X**T,   
   >   
   > alpha and beta are scalars, and A, B and C are matrices, with op( A )   
   > an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] TRANSA   
   > \verbatim   
   >          TRANSA is CHARACTER*1   
   >           On entry, TRANSA specifies the form of op( A ) to be used in   
   >           the matrix multiplication as follows:   
   >   
   >              TRANSA = 'N' or 'n',  op( A ) = A.   
   >   
   >              TRANSA = 'T' or 't',  op( A ) = A**T.   
   >   
   >              TRANSA = 'C' or 'c',  op( A ) = A**T.   
   > \endverbatim   
   >   
   > \param[in] TRANSB   
   > \verbatim   
   >          TRANSB is CHARACTER*1   
   >           On entry, TRANSB specifies the form of op( B ) to be used in   
   >           the matrix multiplication as follows:   
   >   
   >              TRANSB = 'N' or 'n',  op( B ) = B.   
   >   
   >              TRANSB = 'T' or 't',  op( B ) = B**T.   
   >   
   >              TRANSB = 'C' or 'c',  op( B ) = B**T.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry,  M  specifies  the number  of rows  of the  matrix   
   >           op( A )  and of the  matrix  C.  M  must  be at least  zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry,  N  specifies the number  of columns of the matrix   
   >           op( B ) and the number of columns of the matrix C. N must be   
   >           at least zero.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >           On entry,  K  specifies  the number of columns of the matrix   
   >           op( A ) and the number of rows of the matrix op( B ). K must   
   >           be at least  zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, ka ), where ka is   
   >           k  when  TRANSA = 'N' or 'n',  and is  m  otherwise.   
   >           Before entry with  TRANSA = 'N' or 'n',  the leading  m by k   
   >           part of the array  A  must contain the matrix  A,  otherwise   
   >           the leading  k by m  part of the array  A  must contain  the   
   >           matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. When  TRANSA = 'N' or 'n' then   
   >           LDA must be at least  max( 1, m ), otherwise  LDA must be at   
   >           least  max( 1, k ).   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension ( LDB, kb ), where kb is   
   >           n  when  TRANSB = 'N' or 'n',  and is  k  otherwise.   
   >           Before entry with  TRANSB = 'N' or 'n',  the leading  k by n   
   >           part of the array  B  must contain the matrix  B,  otherwise   
   >           the leading  n by k  part of the array  B  must contain  the   
   >           matrix B.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >           On entry, LDB specifies the first dimension of B as declared   
   >           in the calling (sub) program. When  TRANSB = 'N' or 'n' then   
   >           LDB must be at least  max( 1, k ), otherwise  LDB must be at   
   >           least  max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION.   
   >           On entry,  BETA  specifies the scalar  beta.  When  BETA  is   
   >           supplied as zero then C need not be set on input.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension ( LDC, N )   
   >           Before entry, the leading  m by n  part of the array  C must   
   >           contain the matrix  C,  except when  beta  is zero, in which   
   >           case C need not be set on entry.   
   >           On exit, the array  C  is overwritten by the  m by n  matrix   
   >           ( alpha*op( A )*op( B ) + beta*C ).   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >           On entry, LDC specifies the first dimension of C as declared   
   >           in  the  calling  (sub)  program.   LDC  must  be  at  least   
   >           max( 1, m ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level3   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 3 Blas routine.   
   >   
   >  -- Written on 8-February-1989.   
   >     Jack Dongarra, Argonne National Laboratory.   
   >     Iain Duff, AERE Harwell.   
   >     Jeremy Du Croz, Numerical Algorithms Group Ltd.   
   >     Sven Hammarling, Numerical Algorithms Group Ltd.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgemm_(char *transa, char *transb, integer *m, integer *
	n, integer *k, doublereal *alpha, doublereal *a, integer *lda, 
	doublereal *b, integer *ldb, doublereal *beta, doublereal *c__, 
	integer *ldc)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2, 
	    i__3;

    /* Local variables */
    integer i__, j, l, info;
    logical nota, notb;
    doublereal temp;
    integer ncola;
    extern logical igraphlsame_(char *, char *);
    integer nrowa, nrowb;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level3 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Set  NOTA  and  NOTB  as  true if  A  and  B  respectively are not   
       transposed and set  NROWA, NCOLA and  NROWB  as the number of rows   
       and  columns of  A  and the  number of  rows  of  B  respectively.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;

    /* Function Body */
    nota = igraphlsame_(transa, "N");
    notb = igraphlsame_(transb, "N");
    if (nota) {
	nrowa = *m;
	ncola = *k;
    } else {
	nrowa = *k;
	ncola = *m;
    }
    if (notb) {
	nrowb = *k;
    } else {
	nrowb = *n;
    }

/*     Test the input parameters. */

    info = 0;
    if (! nota && ! igraphlsame_(transa, "C") && ! igraphlsame_(
	    transa, "T")) {
	info = 1;
    } else if (! notb && ! igraphlsame_(transb, "C") && ! 
	    igraphlsame_(transb, "T")) {
	info = 2;
    } else if (*m < 0) {
	info = 3;
    } else if (*n < 0) {
	info = 4;
    } else if (*k < 0) {
	info = 5;
    } else if (*lda < max(1,nrowa)) {
	info = 8;
    } else if (*ldb < max(1,nrowb)) {
	info = 10;
    } else if (*ldc < max(1,*m)) {
	info = 13;
    }
    if (info != 0) {
	igraphxerbla_("DGEMM ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0 || (*alpha == 0. || *k == 0) && *beta == 1.) {
	return 0;
    }

/*     And if  alpha.eq.zero. */

    if (*alpha == 0.) {
	if (*beta == 0.) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    c__[i__ + j * c_dim1] = 0.;
/* L10: */
		}
/* L20: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L30: */
		}
/* L40: */
	    }
	}
	return 0;
    }

/*     Start the operations. */

    if (notb) {
	if (nota) {

/*           Form  C := alpha*A*B + beta*C. */

	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L50: */
		    }
		} else if (*beta != 1.) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L60: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    temp = *alpha * b[l + j * b_dim1];
		    i__3 = *m;
		    for (i__ = 1; i__ <= i__3; ++i__) {
			c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
/* L70: */
		    }
/* L80: */
		}
/* L90: */
	    }
	} else {

/*           Form  C := alpha*A**T*B + beta*C */

	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp += a[l + i__ * a_dim1] * b[l + j * b_dim1];
/* L100: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp;
		    } else {
			c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
				i__ + j * c_dim1];
		    }
/* L110: */
		}
/* L120: */
	    }
	}
    } else {
	if (nota) {

/*           Form  C := alpha*A*B**T + beta*C */

	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L130: */
		    }
		} else if (*beta != 1.) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L140: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    temp = *alpha * b[j + l * b_dim1];
		    i__3 = *m;
		    for (i__ = 1; i__ <= i__3; ++i__) {
			c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
/* L150: */
		    }
/* L160: */
		}
/* L170: */
	    }
	} else {

/*           Form  C := alpha*A**T*B**T + beta*C */

	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp += a[l + i__ * a_dim1] * b[j + l * b_dim1];
/* L180: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp;
		    } else {
			c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
				i__ + j * c_dim1];
		    }
/* L190: */
		}
/* L200: */
	    }
	}
    }

    return 0;

/*     End of DGEMM . */

} /* igraphdgemm_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgemv.c0000644000175100001710000002206300000000000023653 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DGEMV   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DGEMV(TRANS,M,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY)   

         DOUBLE PRECISION ALPHA,BETA   
         INTEGER INCX,INCY,LDA,M,N   
         CHARACTER TRANS   
         DOUBLE PRECISION A(LDA,*),X(*),Y(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEMV  performs one of the matrix-vector operations   
   >   
   >    y := alpha*A*x + beta*y,   or   y := alpha*A**T*x + beta*y,   
   >   
   > where alpha and beta are scalars, x and y are vectors and A is an   
   > m by n matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >           On entry, TRANS specifies the operation to be performed as   
   >           follows:   
   >   
   >              TRANS = 'N' or 'n'   y := alpha*A*x + beta*y.   
   >   
   >              TRANS = 'T' or 't'   y := alpha*A**T*x + beta*y.   
   >   
   >              TRANS = 'C' or 'c'   y := alpha*A**T*x + beta*y.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry, M specifies the number of rows of the matrix A.   
   >           M must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the number of columns of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry, the leading m by n part of the array A must   
   >           contain the matrix of coefficients.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, m ).   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'   
   >           and at least   
   >           ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.   
   >           Before entry, the incremented array X must contain the   
   >           vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION.   
   >           On entry, BETA specifies the scalar beta. When BETA is   
   >           supplied as zero then Y need not be set on input.   
   > \endverbatim   
   >   
   > \param[in,out] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'   
   >           and at least   
   >           ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.   
   >           Before entry with BETA non-zero, the incremented array Y   
   >           must contain the vector y. On exit, Y is overwritten by the   
   >           updated vector y.   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >           On entry, INCY specifies the increment for the elements of   
   >           Y. INCY must not be zero.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level2   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >  The vector and matrix arguments are not referenced when N = 0, or M = 0   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgemv_(char *trans, integer *m, integer *n, doublereal *
	alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, 
	doublereal *beta, doublereal *y, integer *incy)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, iy, jx, jy, kx, ky, info;
    doublereal temp;
    integer lenx, leny;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level2 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --x;
    --y;

    /* Function Body */
    info = 0;
    if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, "T") && ! igraphlsame_(trans, "C")
	    ) {
	info = 1;
    } else if (*m < 0) {
	info = 2;
    } else if (*n < 0) {
	info = 3;
    } else if (*lda < max(1,*m)) {
	info = 6;
    } else if (*incx == 0) {
	info = 8;
    } else if (*incy == 0) {
	info = 11;
    }
    if (info != 0) {
	igraphxerbla_("DGEMV ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0 || *alpha == 0. && *beta == 1.) {
	return 0;
    }

/*     Set  LENX  and  LENY, the lengths of the vectors x and y, and set   
       up the start points in  X  and  Y. */

    if (igraphlsame_(trans, "N")) {
	lenx = *n;
	leny = *m;
    } else {
	lenx = *m;
	leny = *n;
    }
    if (*incx > 0) {
	kx = 1;
    } else {
	kx = 1 - (lenx - 1) * *incx;
    }
    if (*incy > 0) {
	ky = 1;
    } else {
	ky = 1 - (leny - 1) * *incy;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through A.   

       First form  y := beta*y. */

    if (*beta != 1.) {
	if (*incy == 1) {
	    if (*beta == 0.) {
		i__1 = leny;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[i__] = 0.;
/* L10: */
		}
	    } else {
		i__1 = leny;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[i__] = *beta * y[i__];
/* L20: */
		}
	    }
	} else {
	    iy = ky;
	    if (*beta == 0.) {
		i__1 = leny;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[iy] = 0.;
		    iy += *incy;
/* L30: */
		}
	    } else {
		i__1 = leny;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[iy] = *beta * y[iy];
		    iy += *incy;
/* L40: */
		}
	    }
	}
    }
    if (*alpha == 0.) {
	return 0;
    }
    if (igraphlsame_(trans, "N")) {

/*        Form  y := alpha*A*x + y. */

	jx = kx;
	if (*incy == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp = *alpha * x[jx];
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    y[i__] += temp * a[i__ + j * a_dim1];
/* L50: */
		}
		jx += *incx;
/* L60: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp = *alpha * x[jx];
		iy = ky;
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    y[iy] += temp * a[i__ + j * a_dim1];
		    iy += *incy;
/* L70: */
		}
		jx += *incx;
/* L80: */
	    }
	}
    } else {

/*        Form  y := alpha*A**T*x + y. */

	jy = ky;
	if (*incx == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp = 0.;
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp += a[i__ + j * a_dim1] * x[i__];
/* L90: */
		}
		y[jy] += *alpha * temp;
		jy += *incy;
/* L100: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp = 0.;
		ix = kx;
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp += a[i__ + j * a_dim1] * x[ix];
		    ix += *incx;
/* L110: */
		}
		y[jy] += *alpha * temp;
		jy += *incy;
/* L120: */
	    }
	}
    }

    return 0;

/*     End of DGEMV . */

} /* igraphdgemv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgeqr2.c0000644000175100001710000001427000000000000023736 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DGEQR2 computes the QR factorization of a general rectangular matrix using an unblocked algorit
hm.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGEQR2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGEQR2( M, N, A, LDA, TAU, WORK, INFO )   

         INTEGER            INFO, LDA, M, N   
         DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGEQR2 computes a QR factorization of a real m by n matrix A:   
   > A = Q * R.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the m by n matrix A.   
   >          On exit, the elements on and above the diagonal of the array   
   >          contain the min(m,n) by n upper trapezoidal matrix R (R is   
   >          upper triangular if m >= n); the elements below the diagonal,   
   >          with the array TAU, represent the orthogonal matrix Q as a   
   >          product of elementary reflectors (see Further Details).   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (min(M,N))   
   >          The scalar factors of the elementary reflectors (see Further   
   >          Details).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The matrix Q is represented as a product of elementary reflectors   
   >   
   >     Q = H(1) H(2) . . . H(k), where k = min(m,n).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),   
   >  and tau in TAU(i).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdgeqr2_(integer *m, integer *n, doublereal *a, integer *
	lda, doublereal *tau, doublereal *work, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, k;
    doublereal aii;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *), igraphdlarfg_(integer *, doublereal *, 
	    doublereal *, integer *, doublereal *), igraphxerbla_(char *, integer *,
	     ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    if (*m < 0) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*m)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGEQR2", &i__1, (ftnlen)6);
	return 0;
    }

    k = min(*m,*n);

    i__1 = k;
    for (i__ = 1; i__ <= i__1; ++i__) {

/*        Generate elementary reflector H(i) to annihilate A(i+1:m,i) */

	i__2 = *m - i__ + 1;
/* Computing MIN */
	i__3 = i__ + 1;
	igraphdlarfg_(&i__2, &a[i__ + i__ * a_dim1], &a[min(i__3,*m) + i__ * a_dim1]
		, &c__1, &tau[i__]);
	if (i__ < *n) {

/*           Apply H(i) to A(i:m,i+1:n) from the left */

	    aii = a[i__ + i__ * a_dim1];
	    a[i__ + i__ * a_dim1] = 1.;
	    i__2 = *m - i__ + 1;
	    i__3 = *n - i__;
	    igraphdlarf_("Left", &i__2, &i__3, &a[i__ + i__ * a_dim1], &c__1, &tau[
		    i__], &a[i__ + (i__ + 1) * a_dim1], lda, &work[1]);
	    a[i__ + i__ * a_dim1] = aii;
	}
/* L10: */
    }
    return 0;

/*     End of DGEQR2 */

} /* igraphdgeqr2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dger.c0000644000175100001710000001441200000000000023471 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DGER   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DGER(M,N,ALPHA,X,INCX,Y,INCY,A,LDA)   

         DOUBLE PRECISION ALPHA   
         INTEGER INCX,INCY,LDA,M,N   
         DOUBLE PRECISION A(LDA,*),X(*),Y(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGER   performs the rank 1 operation   
   >   
   >    A := alpha*x*y**T + A,   
   >   
   > where alpha is a scalar, x is an m element vector, y is an n element   
   > vector and A is an m by n matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry, M specifies the number of rows of the matrix A.   
   >           M must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the number of columns of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( m - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the m   
   >           element vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   
   >   
   > \param[in] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCY ) ).   
   >           Before entry, the incremented array Y must contain the n   
   >           element vector y.   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >           On entry, INCY specifies the increment for the elements of   
   >           Y. INCY must not be zero.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry, the leading m by n part of the array A must   
   >           contain the matrix of coefficients. On exit, A is   
   >           overwritten by the updated matrix.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, m ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level2   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdger_(integer *m, integer *n, doublereal *alpha, 
	doublereal *x, integer *incx, doublereal *y, integer *incy, 
	doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, jy, kx, info;
    doublereal temp;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level2 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --x;
    --y;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    info = 0;
    if (*m < 0) {
	info = 1;
    } else if (*n < 0) {
	info = 2;
    } else if (*incx == 0) {
	info = 5;
    } else if (*incy == 0) {
	info = 7;
    } else if (*lda < max(1,*m)) {
	info = 9;
    }
    if (info != 0) {
	igraphxerbla_("DGER  ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0 || *alpha == 0.) {
	return 0;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through A. */

    if (*incy > 0) {
	jy = 1;
    } else {
	jy = 1 - (*n - 1) * *incy;
    }
    if (*incx == 1) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    if (y[jy] != 0.) {
		temp = *alpha * y[jy];
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    a[i__ + j * a_dim1] += x[i__] * temp;
/* L10: */
		}
	    }
	    jy += *incy;
/* L20: */
	}
    } else {
	if (*incx > 0) {
	    kx = 1;
	} else {
	    kx = 1 - (*m - 1) * *incx;
	}
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    if (y[jy] != 0.) {
		temp = *alpha * y[jy];
		ix = kx;
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    a[i__ + j * a_dim1] += x[ix] * temp;
		    ix += *incx;
/* L30: */
		}
	    }
	    jy += *incy;
/* L40: */
	}
    }

    return 0;

/*     End of DGER  . */

} /* igraphdger_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgesv.c0000644000175100001710000001424400000000000023663 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief  DGESV computes the solution to system of linear equations A * X = B for GE matrices   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGESV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGESV( N, NRHS, A, LDA, IPIV, B, LDB, INFO )   

         INTEGER            INFO, LDA, LDB, N, NRHS   
         INTEGER            IPIV( * )   
         DOUBLE PRECISION   A( LDA, * ), B( LDB, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGESV computes the solution to a real system of linear equations   
   >    A * X = B,   
   > where A is an N-by-N matrix and X and B are N-by-NRHS matrices.   
   >   
   > The LU decomposition with partial pivoting and row interchanges is   
   > used to factor A as   
   >    A = P * L * U,   
   > where P is a permutation matrix, L is unit lower triangular, and U is   
   > upper triangular.  The factored form of A is then used to solve the   
   > system of equations A * X = B.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of linear equations, i.e., the order of the   
   >          matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] NRHS   
   > \verbatim   
   >          NRHS is INTEGER   
   >          The number of right hand sides, i.e., the number of columns   
   >          of the matrix B.  NRHS >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the N-by-N coefficient matrix A.   
   >          On exit, the factors L and U from the factorization   
   >          A = P*L*U; the unit diagonal elements of L are not stored.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] IPIV   
   > \verbatim   
   >          IPIV is INTEGER array, dimension (N)   
   >          The pivot indices that define the permutation matrix P;   
   >          row i of the matrix was interchanged with row IPIV(i).   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,NRHS)   
   >          On entry, the N-by-NRHS matrix of right hand side matrix B.   
   >          On exit, if INFO = 0, the N-by-NRHS solution matrix X.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of the array B.  LDB >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization   
   >                has been completed, but the factor U is exactly   
   >                singular, so the solution could not be computed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleGEsolve   

    =====================================================================   
   Subroutine */ int igraphdgesv_(integer *n, integer *nrhs, doublereal *a, integer 
	*lda, integer *ipiv, doublereal *b, integer *ldb, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, i__1;

    /* Local variables */
    extern /* Subroutine */ int igraphdgetrf_(integer *, integer *, doublereal *, 
	    integer *, integer *, integer *), igraphxerbla_(char *, integer *, 
	    ftnlen), igraphdgetrs_(char *, integer *, integer *, doublereal *, 
	    integer *, integer *, doublereal *, integer *, integer *);


/*  -- LAPACK driver routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --ipiv;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;

    /* Function Body */
    *info = 0;
    if (*n < 0) {
	*info = -1;
    } else if (*nrhs < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    } else if (*ldb < max(1,*n)) {
	*info = -7;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGESV ", &i__1, (ftnlen)6);
	return 0;
    }

/*     Compute the LU factorization of A. */

    igraphdgetrf_(n, n, &a[a_offset], lda, &ipiv[1], info);
    if (*info == 0) {

/*        Solve the system A*X = B, overwriting B with X. */

	igraphdgetrs_("No transpose", n, nrhs, &a[a_offset], lda, &ipiv[1], &b[
		b_offset], ldb, info);
    }
    return 0;

/*     End of DGESV */

} /* igraphdgesv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgetf2.c0000644000175100001710000001555400000000000023733 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b8 = -1.;

/* > \brief \b DGETF2 computes the LU factorization of a general m-by-n matrix using partial pivoting with row
 interchanges (unblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGETF2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGETF2( M, N, A, LDA, IPIV, INFO )   

         INTEGER            INFO, LDA, M, N   
         INTEGER            IPIV( * )   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGETF2 computes an LU factorization of a general m-by-n matrix A   
   > using partial pivoting with row interchanges.   
   >   
   > The factorization has the form   
   >    A = P * L * U   
   > where P is a permutation matrix, L is lower triangular with unit   
   > diagonal elements (lower trapezoidal if m > n), and U is upper   
   > triangular (upper trapezoidal if m < n).   
   >   
   > This is the right-looking Level 2 BLAS version of the algorithm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the m by n matrix to be factored.   
   >          On exit, the factors L and U from the factorization   
   >          A = P*L*U; the unit diagonal elements of L are not stored.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] IPIV   
   > \verbatim   
   >          IPIV is INTEGER array, dimension (min(M,N))   
   >          The pivot indices; for 1 <= i <= min(M,N), row i of the   
   >          matrix was interchanged with row IPIV(i).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -k, the k-th argument had an illegal value   
   >          > 0: if INFO = k, U(k,k) is exactly zero. The factorization   
   >               has been completed, but the factor U is exactly   
   >               singular, and division by zero will occur if it is used   
   >               to solve a system of equations.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEcomputational   

    =====================================================================   
   Subroutine */ int igraphdgetf2_(integer *m, integer *n, doublereal *a, integer *
	lda, integer *ipiv, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;
    doublereal d__1;

    /* Local variables */
    integer i__, j, jp;
    extern /* Subroutine */ int igraphdger_(integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *), igraphdscal_(integer *, doublereal *, doublereal *, integer 
	    *);
    doublereal sfmin;
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    extern doublereal igraphdlamch_(char *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --ipiv;

    /* Function Body */
    *info = 0;
    if (*m < 0) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*m)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGETF2", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0) {
	return 0;
    }

/*     Compute machine safe minimum */

    sfmin = igraphdlamch_("S");

    i__1 = min(*m,*n);
    for (j = 1; j <= i__1; ++j) {

/*        Find pivot and test for singularity. */

	i__2 = *m - j + 1;
	jp = j - 1 + igraphidamax_(&i__2, &a[j + j * a_dim1], &c__1);
	ipiv[j] = jp;
	if (a[jp + j * a_dim1] != 0.) {

/*           Apply the interchange to columns 1:N. */

	    if (jp != j) {
		igraphdswap_(n, &a[j + a_dim1], lda, &a[jp + a_dim1], lda);
	    }

/*           Compute elements J+1:M of J-th column. */

	    if (j < *m) {
		if ((d__1 = a[j + j * a_dim1], abs(d__1)) >= sfmin) {
		    i__2 = *m - j;
		    d__1 = 1. / a[j + j * a_dim1];
		    igraphdscal_(&i__2, &d__1, &a[j + 1 + j * a_dim1], &c__1);
		} else {
		    i__2 = *m - j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			a[j + i__ + j * a_dim1] /= a[j + j * a_dim1];
/* L20: */
		    }
		}
	    }

	} else if (*info == 0) {

	    *info = j;
	}

	if (j < min(*m,*n)) {

/*           Update trailing submatrix. */

	    i__2 = *m - j;
	    i__3 = *n - j;
	    igraphdger_(&i__2, &i__3, &c_b8, &a[j + 1 + j * a_dim1], &c__1, &a[j + (
		    j + 1) * a_dim1], lda, &a[j + 1 + (j + 1) * a_dim1], lda);
	}
/* L10: */
    }
    return 0;

/*     End of DGETF2 */

} /* igraphdgetf2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgetrf.c0000644000175100001710000001745600000000000024036 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static doublereal c_b16 = 1.;
static doublereal c_b19 = -1.;

/* > \brief \b DGETRF   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGETRF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGETRF( M, N, A, LDA, IPIV, INFO )   

         INTEGER            INFO, LDA, M, N   
         INTEGER            IPIV( * )   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGETRF computes an LU factorization of a general M-by-N matrix A   
   > using partial pivoting with row interchanges.   
   >   
   > The factorization has the form   
   >    A = P * L * U   
   > where P is a permutation matrix, L is lower triangular with unit   
   > diagonal elements (lower trapezoidal if m > n), and U is upper   
   > triangular (upper trapezoidal if m < n).   
   >   
   > This is the right-looking Level 3 BLAS version of the algorithm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the M-by-N matrix to be factored.   
   >          On exit, the factors L and U from the factorization   
   >          A = P*L*U; the unit diagonal elements of L are not stored.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] IPIV   
   > \verbatim   
   >          IPIV is INTEGER array, dimension (min(M,N))   
   >          The pivot indices; for 1 <= i <= min(M,N), row i of the   
   >          matrix was interchanged with row IPIV(i).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  if INFO = i, U(i,i) is exactly zero. The factorization   
   >                has been completed, but the factor U is exactly   
   >                singular, and division by zero will occur if it is used   
   >                to solve a system of equations.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleGEcomputational   

    =====================================================================   
   Subroutine */ int igraphdgetrf_(integer *m, integer *n, doublereal *a, integer *
	lda, integer *ipiv, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;

    /* Local variables */
    integer i__, j, jb, nb;
    extern /* Subroutine */ int igraphdgemm_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    integer iinfo;
    extern /* Subroutine */ int igraphdtrsm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdgetf2_(
	    integer *, integer *, doublereal *, integer *, integer *, integer 
	    *), igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphdlaswp_(integer *, doublereal *, integer *, 
	    integer *, integer *, integer *, integer *);


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --ipiv;

    /* Function Body */
    *info = 0;
    if (*m < 0) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*m)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGETRF", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0) {
	return 0;
    }

/*     Determine the block size for this environment. */

    nb = igraphilaenv_(&c__1, "DGETRF", " ", m, n, &c_n1, &c_n1, (ftnlen)6, (ftnlen)
	    1);
    if (nb <= 1 || nb >= min(*m,*n)) {

/*        Use unblocked code. */

	igraphdgetf2_(m, n, &a[a_offset], lda, &ipiv[1], info);
    } else {

/*        Use blocked code. */

	i__1 = min(*m,*n);
	i__2 = nb;
	for (j = 1; i__2 < 0 ? j >= i__1 : j <= i__1; j += i__2) {
/* Computing MIN */
	    i__3 = min(*m,*n) - j + 1;
	    jb = min(i__3,nb);

/*           Factor diagonal and subdiagonal blocks and test for exact   
             singularity. */

	    i__3 = *m - j + 1;
	    igraphdgetf2_(&i__3, &jb, &a[j + j * a_dim1], lda, &ipiv[j], &iinfo);

/*           Adjust INFO and the pivot indices. */

	    if (*info == 0 && iinfo > 0) {
		*info = iinfo + j - 1;
	    }
/* Computing MIN */
	    i__4 = *m, i__5 = j + jb - 1;
	    i__3 = min(i__4,i__5);
	    for (i__ = j; i__ <= i__3; ++i__) {
		ipiv[i__] = j - 1 + ipiv[i__];
/* L10: */
	    }

/*           Apply interchanges to columns 1:J-1. */

	    i__3 = j - 1;
	    i__4 = j + jb - 1;
	    igraphdlaswp_(&i__3, &a[a_offset], lda, &j, &i__4, &ipiv[1], &c__1);

	    if (j + jb <= *n) {

/*              Apply interchanges to columns J+JB:N. */

		i__3 = *n - j - jb + 1;
		i__4 = j + jb - 1;
		igraphdlaswp_(&i__3, &a[(j + jb) * a_dim1 + 1], lda, &j, &i__4, &
			ipiv[1], &c__1);

/*              Compute block row of U. */

		i__3 = *n - j - jb + 1;
		igraphdtrsm_("Left", "Lower", "No transpose", "Unit", &jb, &i__3, &
			c_b16, &a[j + j * a_dim1], lda, &a[j + (j + jb) * 
			a_dim1], lda);
		if (j + jb <= *m) {

/*                 Update trailing submatrix. */

		    i__3 = *m - j - jb + 1;
		    i__4 = *n - j - jb + 1;
		    igraphdgemm_("No transpose", "No transpose", &i__3, &i__4, &jb, 
			    &c_b19, &a[j + jb + j * a_dim1], lda, &a[j + (j + 
			    jb) * a_dim1], lda, &c_b16, &a[j + jb + (j + jb) *
			     a_dim1], lda);
		}
	    }
/* L20: */
	}
    }
    return 0;

/*     End of DGETRF */

} /* igraphdgetrf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgetrs.c0000644000175100001710000001567500000000000024054 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b12 = 1.;
static integer c_n1 = -1;

/* > \brief \b DGETRS   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DGETRS + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DGETRS( TRANS, N, NRHS, A, LDA, IPIV, B, LDB, INFO )   

         CHARACTER          TRANS   
         INTEGER            INFO, LDA, LDB, N, NRHS   
         INTEGER            IPIV( * )   
         DOUBLE PRECISION   A( LDA, * ), B( LDB, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGETRS solves a system of linear equations   
   >    A * X = B  or  A**T * X = B   
   > with a general N-by-N matrix A using the LU factorization computed   
   > by DGETRF.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          Specifies the form of the system of equations:   
   >          = 'N':  A * X = B  (No transpose)   
   >          = 'T':  A**T* X = B  (Transpose)   
   >          = 'C':  A**T* X = B  (Conjugate transpose = Transpose)   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] NRHS   
   > \verbatim   
   >          NRHS is INTEGER   
   >          The number of right hand sides, i.e., the number of columns   
   >          of the matrix B.  NRHS >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The factors L and U from the factorization A = P*L*U   
   >          as computed by DGETRF.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] IPIV   
   > \verbatim   
   >          IPIV is INTEGER array, dimension (N)   
   >          The pivot indices from DGETRF; for 1<=i<=N, row i of the   
   >          matrix was interchanged with row IPIV(i).   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,NRHS)   
   >          On entry, the right hand side matrix B.   
   >          On exit, the solution matrix X.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of the array B.  LDB >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleGEcomputational   

    =====================================================================   
   Subroutine */ int igraphdgetrs_(char *trans, integer *n, integer *nrhs, 
	doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *
	ldb, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, i__1;

    /* Local variables */
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdtrsm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *), igraphxerbla_(
	    char *, integer *, ftnlen), igraphdlaswp_(integer *, doublereal *, 
	    integer *, integer *, integer *, integer *, integer *);
    logical notran;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --ipiv;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;

    /* Function Body */
    *info = 0;
    notran = igraphlsame_(trans, "N");
    if (! notran && ! igraphlsame_(trans, "T") && ! igraphlsame_(
	    trans, "C")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*nrhs < 0) {
	*info = -3;
    } else if (*lda < max(1,*n)) {
	*info = -5;
    } else if (*ldb < max(1,*n)) {
	*info = -8;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DGETRS", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0 || *nrhs == 0) {
	return 0;
    }

    if (notran) {

/*        Solve A * X = B.   

          Apply row interchanges to the right hand sides. */

	igraphdlaswp_(nrhs, &b[b_offset], ldb, &c__1, n, &ipiv[1], &c__1);

/*        Solve L*X = B, overwriting B with X. */

	igraphdtrsm_("Left", "Lower", "No transpose", "Unit", n, nrhs, &c_b12, &a[
		a_offset], lda, &b[b_offset], ldb);

/*        Solve U*X = B, overwriting B with X. */

	igraphdtrsm_("Left", "Upper", "No transpose", "Non-unit", n, nrhs, &c_b12, &
		a[a_offset], lda, &b[b_offset], ldb);
    } else {

/*        Solve A**T * X = B.   

          Solve U**T *X = B, overwriting B with X. */

	igraphdtrsm_("Left", "Upper", "Transpose", "Non-unit", n, nrhs, &c_b12, &a[
		a_offset], lda, &b[b_offset], ldb);

/*        Solve L**T *X = B, overwriting B with X. */

	igraphdtrsm_("Left", "Lower", "Transpose", "Unit", n, nrhs, &c_b12, &a[
		a_offset], lda, &b[b_offset], ldb);

/*        Apply row interchanges to the solution vectors. */

	igraphdlaswp_(nrhs, &b[b_offset], ldb, &c__1, n, &ipiv[1], &c_n1);
    }

    return 0;

/*     End of DGETRS */

} /* igraphdgetrs_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dgetv0.c0000644000175100001710000003545300000000000023751 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b24 = 1.;
static doublereal c_b26 = 0.;
static doublereal c_b29 = -1.;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dgetv0   

   \Description:   
    Generate a random initial residual vector for the Arnoldi process.   
    Force the residual vector to be in the range of the operator OP.   

   \Usage:   
    call dgetv0   
       ( IDO, BMAT, ITRY, INITV, N, J, V, LDV, RESID, RNORM,   
         IPNTR, WORKD, IERR )   

   \Arguments   
    IDO     Integer.  (INPUT/OUTPUT)   
            Reverse communication flag.  IDO must be zero on the first   
            call to dgetv0.   
            -------------------------------------------------------------   
            IDO =  0: first call to the reverse communication interface   
            IDO = -1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
                      This is for the initialization phase to force the   
                      starting vector into the range of OP.   
            IDO =  2: compute  Y = B * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
            IDO = 99: done   
            -------------------------------------------------------------   

    BMAT    Character*1.  (INPUT)   
            BMAT specifies the type of the matrix B in the (generalized)   
            eigenvalue problem A*x = lambda*B*x.   
            B = 'I' -> standard eigenvalue problem A*x = lambda*x   
            B = 'G' -> generalized eigenvalue problem A*x = lambda*B*x   

    ITRY    Integer.  (INPUT)   
            ITRY counts the number of times that dgetv0 is called.   
            It should be set to 1 on the initial call to dgetv0.   

    INITV   Logical variable.  (INPUT)   
            .TRUE.  => the initial residual vector is given in RESID.   
            .FALSE. => generate a random initial residual vector.   

    N       Integer.  (INPUT)   
            Dimension of the problem.   

    J       Integer.  (INPUT)   
            Index of the residual vector to be generated, with respect to   
            the Arnoldi process.  J > 1 in case of a "restart".   

    V       Double precision N by J array.  (INPUT)   
            The first J-1 columns of V contain the current Arnoldi basis   
            if this is a "restart".   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            Initial residual vector to be generated.  If RESID is   
            provided, force RESID into the range of the operator OP.   

    RNORM   Double precision scalar.  (OUTPUT)   
            B-norm of the generated residual.   

    IPNTR   Integer array of length 3.  (OUTPUT)   

    WORKD   Double precision work array of length 2*N.  (REVERSE COMMUNICATION).   
            On exit, WORK(1:N) = B*RESID to be used in SSAITR.   

    IERR    Integer.  (OUTPUT)   
            =  0: Normal exit.   
            = -1: Cannot generate a nontrivial restarted residual vector   
                  in the range of the operator OP.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   

   \Routines called:   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine for vector output.   
       dlarnv  LAPACK routine for generating a random vector.   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: getv0.F   SID: 2.6   DATE OF SID: 8/27/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdgetv0_(integer *ido, char *bmat, integer *itry, logical 
	*initv, integer *n, integer *j, doublereal *v, integer *ldv, 
	doublereal *resid, doublereal *rnorm, integer *ipntr, doublereal *
	workd, integer *ierr)
{
    /* Initialized data */

    IGRAPH_F77_SAVE logical inits = TRUE_;

    /* System generated locals */
    integer v_dim1, v_offset, i__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    IGRAPH_F77_SAVE real t0, t1, t2, t3;
    integer jj, nbx = 0;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE integer iter;
    IGRAPH_F77_SAVE logical orth;
    integer nopx = 0;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    IGRAPH_F77_SAVE integer iseed[4];
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    integer idist;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    IGRAPH_F77_SAVE logical first;
    real tmvbx = 0;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen);
    integer mgetv0 = 0;
    real tgetv0 = 0;
    IGRAPH_F77_SAVE doublereal rnorm0;
    extern /* Subroutine */ int igraphsecond_(real *);
    integer logfil, ndigit;
    extern /* Subroutine */ int igraphdlarnv_(integer *, integer *, integer *, 
	    doublereal *);
    IGRAPH_F77_SAVE integer msglvl;
    real tmvopx = 0;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %------------------------%   
       | Local Scalars & Arrays |   
       %------------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------%   
       | Data Statements |   
       %-----------------%   

       Parameter adjustments */
    --workd;
    --resid;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --ipntr;

    /* Function Body   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   


       %-----------------------------------%   
       | Initialize the seed of the LAPACK |   
       | random number generator           |   
       %-----------------------------------% */

    if (inits) {
	iseed[0] = 1;
	iseed[1] = 3;
	iseed[2] = 5;
	iseed[3] = 7;
	inits = FALSE_;
    }

    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphsecond_(&t0);
	msglvl = mgetv0;

	*ierr = 0;
	iter = 0;
	first = FALSE_;
	orth = FALSE_;

/*        %-----------------------------------------------------%   
          | Possibly generate a random starting vector in RESID |   
          | Use a LAPACK random number generator used by the    |   
          | matrix generation routines.                         |   
          |    idist = 1: uniform (0,1)  distribution;          |   
          |    idist = 2: uniform (-1,1) distribution;          |   
          |    idist = 3: normal  (0,1)  distribution;          |   
          %-----------------------------------------------------% */

	if (! (*initv)) {
	    idist = 2;
	    igraphdlarnv_(&idist, iseed, n, &resid[1]);
	}

/*        %----------------------------------------------------------%   
          | Force the starting vector into the range of OP to handle |   
          | the generalized problem when B is possibly (singular).   |   
          %----------------------------------------------------------% */

	igraphsecond_(&t2);
	if (*(unsigned char *)bmat == 'G') {
	    ++nopx;
	    ipntr[1] = 1;
	    ipntr[2] = *n + 1;
	    igraphdcopy_(n, &resid[1], &c__1, &workd[1], &c__1);
	    *ido = -1;
	    goto L9000;
	}
    }

/*     %-----------------------------------------%   
       | Back from computing OP*(initial-vector) |   
       %-----------------------------------------% */

    if (first) {
	goto L20;
    }

/*     %-----------------------------------------------%   
       | Back from computing B*(orthogonalized-vector) |   
       %-----------------------------------------------% */

    if (orth) {
	goto L40;
    }

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvopx += t3 - t2;
    }

/*     %------------------------------------------------------%   
       | Starting vector is now in the range of OP; r = OP*r; |   
       | Compute B-norm of starting vector.                   |   
       %------------------------------------------------------% */

    igraphsecond_(&t2);
    first = TRUE_;
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &workd[*n + 1], &c__1, &resid[1], &c__1);
	ipntr[1] = *n + 1;
	ipntr[2] = 1;
	*ido = 2;
	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[1], &c__1);
    }

L20:

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    first = FALSE_;
    if (*(unsigned char *)bmat == 'G') {
	rnorm0 = igraphddot_(n, &resid[1], &c__1, &workd[1], &c__1);
	rnorm0 = sqrt((abs(rnorm0)));
    } else if (*(unsigned char *)bmat == 'I') {
	rnorm0 = igraphdnrm2_(n, &resid[1], &c__1);
    }
    *rnorm = rnorm0;

/*     %---------------------------------------------%   
       | Exit if this is the very first Arnoldi step |   
       %---------------------------------------------% */

    if (*j == 1) {
	goto L50;
    }

/*     %----------------------------------------------------------------   
       | Otherwise need to B-orthogonalize the starting vector against |   
       | the current Arnoldi basis using Gram-Schmidt with iter. ref.  |   
       | This is the case where an invariant subspace is encountered   |   
       | in the middle of the Arnoldi factorization.                   |   
       |                                                               |   
       |       s = V^{T}*B*r;   r = r - V*s;                           |   
       |                                                               |   
       | Stopping criteria used for iter. ref. is discussed in         |   
       | Parlett's book, page 107 and in Gragg & Reichel TOMS paper.   |   
       %---------------------------------------------------------------% */

    orth = TRUE_;
L30:

    i__1 = *j - 1;
    igraphdgemv_("T", n, &i__1, &c_b24, &v[v_offset], ldv, &workd[1], &c__1, &c_b26,
	     &workd[*n + 1], &c__1);
    i__1 = *j - 1;
    igraphdgemv_("N", n, &i__1, &c_b29, &v[v_offset], ldv, &workd[*n + 1], &c__1, &
	    c_b24, &resid[1], &c__1);

/*     %----------------------------------------------------------%   
       | Compute the B-norm of the orthogonalized starting vector |   
       %----------------------------------------------------------% */

    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[*n + 1], &c__1);
	ipntr[1] = *n + 1;
	ipntr[2] = 1;
	*ido = 2;
	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[1], &c__1);
    }

L40:

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    if (*(unsigned char *)bmat == 'G') {
	*rnorm = igraphddot_(n, &resid[1], &c__1, &workd[1], &c__1);
	*rnorm = sqrt((abs(*rnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	*rnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }

/*     %--------------------------------------%   
       | Check for further orthogonalization. |   
       %--------------------------------------% */

    if (msglvl > 2) {
	igraphdvout_(&logfil, &c__1, &rnorm0, &ndigit, "_getv0: re-orthonalization"
		" ; rnorm0 is", (ftnlen)38);
	igraphdvout_(&logfil, &c__1, rnorm, &ndigit, "_getv0: re-orthonalization ;"
		" rnorm is", (ftnlen)37);
    }

    if (*rnorm > rnorm0 * .717f) {
	goto L50;
    }

    ++iter;
    if (iter <= 1) {

/*        %-----------------------------------%   
          | Perform iterative refinement step |   
          %-----------------------------------% */

	rnorm0 = *rnorm;
	goto L30;
    } else {

/*        %------------------------------------%   
          | Iterative refinement step "failed" |   
          %------------------------------------% */

	i__1 = *n;
	for (jj = 1; jj <= i__1; ++jj) {
	    resid[jj] = 0.;
/* L45: */
	}
	*rnorm = 0.;
	*ierr = -1;
    }

L50:

    if (msglvl > 0) {
	igraphdvout_(&logfil, &c__1, rnorm, &ndigit, "_getv0: B-norm of initial / "
		"restarted starting vector", (ftnlen)53);
    }
    if (msglvl > 2) {
	igraphdvout_(&logfil, n, &resid[1], &ndigit, "_getv0: initial / restarted "
		"starting vector", (ftnlen)43);
    }
    *ido = 99;

    igraphsecond_(&t1);
    tgetv0 += t1 - t0;

L9000:
    return 0;

/*     %---------------%   
       | End of dgetv0 |   
       %---------------% */

} /* igraphdgetv0_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dhseqr.c0000644000175100001710000005204000000000000024035 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b11 = 0.;
static doublereal c_b12 = 1.;
static integer c__12 = 12;
static integer c__2 = 2;
static integer c__49 = 49;

/* > \brief \b DHSEQR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DHSEQR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DHSEQR( JOB, COMPZ, N, ILO, IHI, H, LDH, WR, WI, Z,   
                            LDZ, WORK, LWORK, INFO )   

         INTEGER            IHI, ILO, INFO, LDH, LDZ, LWORK, N   
         CHARACTER          COMPZ, JOB   
         DOUBLE PRECISION   H( LDH, * ), WI( * ), WORK( * ), WR( * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DHSEQR computes the eigenvalues of a Hessenberg matrix H   
   >    and, optionally, the matrices T and Z from the Schur decomposition   
   >    H = Z T Z**T, where T is an upper quasi-triangular matrix (the   
   >    Schur form), and Z is the orthogonal matrix of Schur vectors.   
   >   
   >    Optionally Z may be postmultiplied into an input orthogonal   
   >    matrix Q so that this routine can give the Schur factorization   
   >    of a matrix A which has been reduced to the Hessenberg form H   
   >    by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is CHARACTER*1   
   >           = 'E':  compute eigenvalues only;   
   >           = 'S':  compute eigenvalues and the Schur form T.   
   > \endverbatim   
   >   
   > \param[in] COMPZ   
   > \verbatim   
   >          COMPZ is CHARACTER*1   
   >           = 'N':  no Schur vectors are computed;   
   >           = 'I':  Z is initialized to the unit matrix and the matrix Z   
   >                   of Schur vectors of H is returned;   
   >           = 'V':  Z must contain an orthogonal matrix Q on entry, and   
   >                   the product Q*Z is returned.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           The order of the matrix H.  N .GE. 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >   
   >           It is assumed that H is already upper triangular in rows   
   >           and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally   
   >           set by a previous call to DGEBAL, and then passed to ZGEHRD   
   >           when the matrix output by DGEBAL is reduced to Hessenberg   
   >           form. Otherwise ILO and IHI should be set to 1 and N   
   >           respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.   
   >           If N = 0, then ILO = 1 and IHI = 0.   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >           On entry, the upper Hessenberg matrix H.   
   >           On exit, if INFO = 0 and JOB = 'S', then H contains the   
   >           upper quasi-triangular matrix T from the Schur decomposition   
   >           (the Schur form); 2-by-2 diagonal blocks (corresponding to   
   >           complex conjugate pairs of eigenvalues) are returned in   
   >           standard form, with H(i,i) = H(i+1,i+1) and   
   >           H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and JOB = 'E', the   
   >           contents of H are unspecified on exit.  (The output value of   
   >           H when INFO.GT.0 is given under the description of INFO   
   >           below.)   
   >   
   >           Unlike earlier versions of DHSEQR, this subroutine may   
   >           explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1   
   >           or j = IHI+1, IHI+2, ... N.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is INTEGER   
   >           The leading dimension of the array H. LDH .GE. max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (N)   
   >   
   >           The real and imaginary parts, respectively, of the computed   
   >           eigenvalues. If two eigenvalues are computed as a complex   
   >           conjugate pair, they are stored in consecutive elements of   
   >           WR and WI, say the i-th and (i+1)th, with WI(i) .GT. 0 and   
   >           WI(i+1) .LT. 0. If JOB = 'S', the eigenvalues are stored in   
   >           the same order as on the diagonal of the Schur form returned   
   >           in H, with WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2   
   >           diagonal block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and   
   >           WI(i+1) = -WI(i).   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,N)   
   >           If COMPZ = 'N', Z is not referenced.   
   >           If COMPZ = 'I', on entry Z need not be set and on exit,   
   >           if INFO = 0, Z contains the orthogonal matrix Z of the Schur   
   >           vectors of H.  If COMPZ = 'V', on entry Z must contain an   
   >           N-by-N matrix Q, which is assumed to be equal to the unit   
   >           matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,   
   >           if INFO = 0, Z contains Q*Z.   
   >           Normally Q is the orthogonal matrix generated by DORGHR   
   >           after the call to DGEHRD which formed the Hessenberg matrix   
   >           H. (The output value of Z when INFO.GT.0 is given under   
   >           the description of INFO below.)   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >           The leading dimension of the array Z.  if COMPZ = 'I' or   
   >           COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LWORK)   
   >           On exit, if INFO = 0, WORK(1) returns an estimate of   
   >           the optimal value for LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >           The dimension of the array WORK.  LWORK .GE. max(1,N)   
   >           is sufficient and delivers very good and sometimes   
   >           optimal performance.  However, LWORK as large as 11*N   
   >           may be required for optimal performance.  A workspace   
   >           query is recommended to determine the optimal workspace   
   >           size.   
   >   
   >           If LWORK = -1, then DHSEQR does a workspace query.   
   >           In this case, DHSEQR checks the input parameters and   
   >           estimates the optimal workspace size for the given   
   >           values of N, ILO and IHI.  The estimate is returned   
   >           in WORK(1).  No error message related to LWORK is   
   >           issued by XERBLA.  Neither H nor Z are accessed.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >             =  0:  successful exit   
   >           .LT. 0:  if INFO = -i, the i-th argument had an illegal   
   >                    value   
   >           .GT. 0:  if INFO = i, DHSEQR failed to compute all of   
   >                the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR   
   >                and WI contain those eigenvalues which have been   
   >                successfully computed.  (Failures are rare.)   
   >   
   >                If INFO .GT. 0 and JOB = 'E', then on exit, the   
   >                remaining unconverged eigenvalues are the eigen-   
   >                values of the upper Hessenberg matrix rows and   
   >                columns ILO through INFO of the final, output   
   >                value of H.   
   >   
   >                If INFO .GT. 0 and JOB   = 'S', then on exit   
   >   
   >           (*)  (initial value of H)*U  = U*(final value of H)   
   >   
   >                where U is an orthogonal matrix.  The final   
   >                value of H is upper Hessenberg and quasi-triangular   
   >                in rows and columns INFO+1 through IHI.   
   >   
   >                If INFO .GT. 0 and COMPZ = 'V', then on exit   
   >   
   >                  (final value of Z)  =  (initial value of Z)*U   
   >   
   >                where U is the orthogonal matrix in (*) (regard-   
   >                less of the value of JOB.)   
   >   
   >                If INFO .GT. 0 and COMPZ = 'I', then on exit   
   >                      (final value of Z)  = U   
   >                where U is the orthogonal matrix in (*) (regard-   
   >                less of the value of JOB.)   
   >   
   >                If INFO .GT. 0 and COMPZ = 'N', then Z is not   
   >                accessed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >             Default values supplied by   
   >             ILAENV(ISPEC,'DHSEQR',JOB(:1)//COMPZ(:1),N,ILO,IHI,LWORK).   
   >             It is suggested that these defaults be adjusted in order   
   >             to attain best performance in each particular   
   >             computational environment.   
   >   
   >            ISPEC=12: The DLAHQR vs DLAQR0 crossover point.   
   >                      Default: 75. (Must be at least 11.)   
   >   
   >            ISPEC=13: Recommended deflation window size.   
   >                      This depends on ILO, IHI and NS.  NS is the   
   >                      number of simultaneous shifts returned   
   >                      by ILAENV(ISPEC=15).  (See ISPEC=15 below.)   
   >                      The default for (IHI-ILO+1).LE.500 is NS.   
   >                      The default for (IHI-ILO+1).GT.500 is 3*NS/2.   
   >   
   >            ISPEC=14: Nibble crossover point. (See IPARMQ for   
   >                      details.)  Default: 14% of deflation window   
   >                      size.   
   >   
   >            ISPEC=15: Number of simultaneous shifts in a multishift   
   >                      QR iteration.   
   >   
   >                      If IHI-ILO+1 is ...   
   >   
   >                      greater than      ...but less    ... the   
   >                      or equal to ...      than        default is   
   >   
   >                           1               30          NS =   2(+)   
   >                          30               60          NS =   4(+)   
   >                          60              150          NS =  10(+)   
   >                         150              590          NS =  **   
   >                         590             3000          NS =  64   
   >                        3000             6000          NS = 128   
   >                        6000             infinity      NS = 256   
   >   
   >                  (+)  By default some or all matrices of this order   
   >                       are passed to the implicit double shift routine   
   >                       DLAHQR and this parameter is ignored.  See   
   >                       ISPEC=12 above and comments in IPARMQ for   
   >                       details.   
   >   
   >                 (**)  The asterisks (**) indicate an ad-hoc   
   >                       function of N increasing from 10 to 64.   
   >   
   >            ISPEC=16: Select structured matrix multiply.   
   >                      If the number of simultaneous shifts (specified   
   >                      by ISPEC=15) is less than 14, then the default   
   >                      for ISPEC=16 is 0.  Otherwise the default for   
   >                      ISPEC=16 is 2.   
   > \endverbatim   

   > \par References:   
    ================   
   >   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part I: Maintaining Well Focused Shifts, and Level 3   
   >       Performance, SIAM Journal of Matrix Analysis, volume 23, pages   
   >       929--947, 2002.   
   > \n   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part II: Aggressive Early Deflation, SIAM Journal   
   >       of Matrix Analysis, volume 23, pages 948--973, 2002.   

    =====================================================================   
   Subroutine */ int igraphdhseqr_(char *job, char *compz, integer *n, integer *ilo,
	 integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, 
	doublereal *wi, doublereal *z__, integer *ldz, doublereal *work, 
	integer *lwork, integer *info)
{
    /* System generated locals */
    address a__1[2];
    integer h_dim1, h_offset, z_dim1, z_offset, i__1, i__2[2], i__3;
    doublereal d__1;
    char ch__1[2];

    /* Builtin functions   
       Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);

    /* Local variables */
    integer i__;
    doublereal hl[2401]	/* was [49][49] */;
    integer kbot, nmin;
    extern logical igraphlsame_(char *, char *);
    logical initz;
    doublereal workl[49];
    logical wantt, wantz;
    extern /* Subroutine */ int igraphdlaqr0_(logical *, logical *, integer *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, integer *, integer *), igraphdlahqr_(logical *, logical *,
	     integer *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *), igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphdlaset_(char *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       ==== Matrices of order NTINY or smaller must be processed by   
       .    DLAHQR because of insufficient subdiagonal scratch space.   
       .    (This is a hard limit.) ====   

       ==== NL allocates some local workspace to help small matrices   
       .    through a rare DLAHQR failure.  NL .GT. NTINY = 11 is   
       .    required and NL .LE. NMIN = ILAENV(ISPEC=12,...) is recom-   
       .    mended.  (The default value of NMIN is 75.)  Using NL = 49   
       .    allows up to six simultaneous shifts and a 16-by-16   
       .    deflation window.  ====   

       ==== Decode and check the input parameters. ====   

       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --wr;
    --wi;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --work;

    /* Function Body */
    wantt = igraphlsame_(job, "S");
    initz = igraphlsame_(compz, "I");
    wantz = initz || igraphlsame_(compz, "V");
    work[1] = (doublereal) max(1,*n);
    lquery = *lwork == -1;

    *info = 0;
    if (! igraphlsame_(job, "E") && ! wantt) {
	*info = -1;
    } else if (! igraphlsame_(compz, "N") && ! wantz) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (*ilo < 1 || *ilo > max(1,*n)) {
	*info = -4;
    } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
	*info = -5;
    } else if (*ldh < max(1,*n)) {
	*info = -7;
    } else if (*ldz < 1 || wantz && *ldz < max(1,*n)) {
	*info = -11;
    } else if (*lwork < max(1,*n) && ! lquery) {
	*info = -13;
    }

    if (*info != 0) {

/*        ==== Quick return in case of invalid argument. ==== */

	i__1 = -(*info);
	igraphxerbla_("DHSEQR", &i__1, (ftnlen)6);
	return 0;

    } else if (*n == 0) {

/*        ==== Quick return in case N = 0; nothing to do. ==== */

	return 0;

    } else if (lquery) {

/*        ==== Quick return in case of a workspace query ==== */

	igraphdlaqr0_(&wantt, &wantz, n, ilo, ihi, &h__[h_offset], ldh, &wr[1], &wi[
		1], ilo, ihi, &z__[z_offset], ldz, &work[1], lwork, info);
/*        ==== Ensure reported workspace size is backward-compatible with   
          .    previous LAPACK versions. ====   
   Computing MAX */
	d__1 = (doublereal) max(1,*n);
	work[1] = max(d__1,work[1]);
	return 0;

    } else {

/*        ==== copy eigenvalues isolated by DGEBAL ==== */

	i__1 = *ilo - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    wr[i__] = h__[i__ + i__ * h_dim1];
	    wi[i__] = 0.;
/* L10: */
	}
	i__1 = *n;
	for (i__ = *ihi + 1; i__ <= i__1; ++i__) {
	    wr[i__] = h__[i__ + i__ * h_dim1];
	    wi[i__] = 0.;
/* L20: */
	}

/*        ==== Initialize Z, if requested ==== */

	if (initz) {
	    igraphdlaset_("A", n, n, &c_b11, &c_b12, &z__[z_offset], ldz)
		    ;
	}

/*        ==== Quick return if possible ==== */

	if (*ilo == *ihi) {
	    wr[*ilo] = h__[*ilo + *ilo * h_dim1];
	    wi[*ilo] = 0.;
	    return 0;
	}

/*        ==== DLAHQR/DLAQR0 crossover point ====   

   Writing concatenation */
	i__2[0] = 1, a__1[0] = job;
	i__2[1] = 1, a__1[1] = compz;
	s_cat(ch__1, a__1, i__2, &c__2, (ftnlen)2);
	nmin = igraphilaenv_(&c__12, "DHSEQR", ch__1, n, ilo, ihi, lwork, (ftnlen)6,
		 (ftnlen)2);
	nmin = max(11,nmin);

/*        ==== DLAQR0 for big matrices; DLAHQR for small ones ==== */

	if (*n > nmin) {
	    igraphdlaqr0_(&wantt, &wantz, n, ilo, ihi, &h__[h_offset], ldh, &wr[1], 
		    &wi[1], ilo, ihi, &z__[z_offset], ldz, &work[1], lwork, 
		    info);
	} else {

/*           ==== Small matrix ==== */

	    igraphdlahqr_(&wantt, &wantz, n, ilo, ihi, &h__[h_offset], ldh, &wr[1], 
		    &wi[1], ilo, ihi, &z__[z_offset], ldz, info);

	    if (*info > 0) {

/*              ==== A rare DLAHQR failure!  DLAQR0 sometimes succeeds   
                .    when DLAHQR fails. ==== */

		kbot = *info;

		if (*n >= 49) {

/*                 ==== Larger matrices have enough subdiagonal scratch   
                   .    space to call DLAQR0 directly. ==== */

		    igraphdlaqr0_(&wantt, &wantz, n, ilo, &kbot, &h__[h_offset], 
			    ldh, &wr[1], &wi[1], ilo, ihi, &z__[z_offset], 
			    ldz, &work[1], lwork, info);

		} else {

/*                 ==== Tiny matrices don't have enough subdiagonal   
                   .    scratch space to benefit from DLAQR0.  Hence,   
                   .    tiny matrices must be copied into a larger   
                   .    array before calling DLAQR0. ==== */

		    igraphdlacpy_("A", n, n, &h__[h_offset], ldh, hl, &c__49);
		    hl[*n + 1 + *n * 49 - 50] = 0.;
		    i__1 = 49 - *n;
		    igraphdlaset_("A", &c__49, &i__1, &c_b11, &c_b11, &hl[(*n + 1) *
			     49 - 49], &c__49);
		    igraphdlaqr0_(&wantt, &wantz, &c__49, ilo, &kbot, hl, &c__49, &
			    wr[1], &wi[1], ilo, ihi, &z__[z_offset], ldz, 
			    workl, &c__49, info);
		    if (wantt || *info != 0) {
			igraphdlacpy_("A", n, n, hl, &c__49, &h__[h_offset], ldh);
		    }
		}
	    }
	}

/*        ==== Clear out the trash, if necessary. ==== */

	if ((wantt || *info != 0) && *n > 2) {
	    i__1 = *n - 2;
	    i__3 = *n - 2;
	    igraphdlaset_("L", &i__1, &i__3, &c_b11, &c_b11, &h__[h_dim1 + 3], ldh);
	}

/*        ==== Ensure reported workspace size is backward-compatible with   
          .    previous LAPACK versions. ====   

   Computing MAX */
	d__1 = (doublereal) max(1,*n);
	work[1] = max(d__1,work[1]);
    }

/*     ==== End of DHSEQR ==== */

    return 0;
} /* igraphdhseqr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/disnan.c0000644000175100001710000000510200000000000024020 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DISNAN tests input for NaN.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DISNAN + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         LOGICAL FUNCTION DISNAN( DIN )   

         DOUBLE PRECISION   DIN   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DISNAN returns .TRUE. if its argument is NaN, and .FALSE.   
   > otherwise.  To be replaced by the Fortran 2003 intrinsic in the   
   > future.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] DIN   
   > \verbatim   
   >          DIN is DOUBLE PRECISION   
   >          Input to test for NaN.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
logical igraphdisnan_(doublereal *din)
{
    /* System generated locals */
    logical ret_val;

    /* Local variables */
    extern logical igraphdlaisnan_(doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ===================================================================== */

    ret_val = igraphdlaisnan_(din, din);
    return ret_val;
} /* igraphdisnan_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlabad.c0000644000175100001710000000717600000000000023770 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLABAD   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLABAD + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLABAD( SMALL, LARGE )   

         DOUBLE PRECISION   LARGE, SMALL   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLABAD takes as input the values computed by DLAMCH for underflow and   
   > overflow, and returns the square root of each of these values if the   
   > log of LARGE is sufficiently large.  This subroutine is intended to   
   > identify machines with a large exponent range, such as the Crays, and   
   > redefine the underflow and overflow limits to be the square roots of   
   > the values computed by DLAMCH.  This subroutine is needed because   
   > DLAMCH does not compensate for poor arithmetic in the upper half of   
   > the exponent range, as is found on a Cray.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in,out] SMALL   
   > \verbatim   
   >          SMALL is DOUBLE PRECISION   
   >          On entry, the underflow threshold as computed by DLAMCH.   
   >          On exit, if LOG10(LARGE) is sufficiently large, the square   
   >          root of SMALL, otherwise unchanged.   
   > \endverbatim   
   >   
   > \param[in,out] LARGE   
   > \verbatim   
   >          LARGE is DOUBLE PRECISION   
   >          On entry, the overflow threshold as computed by DLAMCH.   
   >          On exit, if LOG10(LARGE) is sufficiently large, the square   
   >          root of LARGE, otherwise unchanged.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlabad_(doublereal *small, doublereal *large)
{
    /* Builtin functions */
    double d_lg10(doublereal *), sqrt(doublereal);


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       If it looks like we're on a Cray, take the square root of   
       SMALL and LARGE to avoid overflow and underflow problems. */

    if (d_lg10(large) > 2e3) {
	*small = sqrt(*small);
	*large = sqrt(*large);
    }

    return 0;

/*     End of DLABAD */

} /* igraphdlabad_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlacn2.c0000644000175100001710000002107300000000000023714 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b11 = 1.;

/* > \brief \b DLACN2 estimates the 1-norm of a square matrix, using reverse communication for evaluating matr
ix-vector products.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLACN2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLACN2( N, V, X, ISGN, EST, KASE, ISAVE )   

         INTEGER            KASE, N   
         DOUBLE PRECISION   EST   
         INTEGER            ISGN( * ), ISAVE( 3 )   
         DOUBLE PRECISION   V( * ), X( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLACN2 estimates the 1-norm of a square, real matrix A.   
   > Reverse communication is used for evaluating matrix-vector products.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         The order of the matrix.  N >= 1.   
   > \endverbatim   
   >   
   > \param[out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension (N)   
   >         On the final return, V = A*W,  where  EST = norm(V)/norm(W)   
   >         (W is not returned).   
   > \endverbatim   
   >   
   > \param[in,out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (N)   
   >         On an intermediate return, X should be overwritten by   
   >               A * X,   if KASE=1,   
   >               A**T * X,  if KASE=2,   
   >         and DLACN2 must be re-called with all the other parameters   
   >         unchanged.   
   > \endverbatim   
   >   
   > \param[out] ISGN   
   > \verbatim   
   >          ISGN is INTEGER array, dimension (N)   
   > \endverbatim   
   >   
   > \param[in,out] EST   
   > \verbatim   
   >          EST is DOUBLE PRECISION   
   >         On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be   
   >         unchanged from the previous call to DLACN2.   
   >         On exit, EST is an estimate (a lower bound) for norm(A).   
   > \endverbatim   
   >   
   > \param[in,out] KASE   
   > \verbatim   
   >          KASE is INTEGER   
   >         On the initial call to DLACN2, KASE should be 0.   
   >         On an intermediate return, KASE will be 1 or 2, indicating   
   >         whether X should be overwritten by A * X  or A**T * X.   
   >         On the final return from DLACN2, KASE will again be 0.   
   > \endverbatim   
   >   
   > \param[in,out] ISAVE   
   > \verbatim   
   >          ISAVE is INTEGER array, dimension (3)   
   >         ISAVE is used to save variables between calls to DLACN2   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Originally named SONEST, dated March 16, 1988.   
   >   
   >  This is a thread safe version of DLACON, which uses the array ISAVE   
   >  in place of a SAVE statement, as follows:   
   >   
   >     DLACON     DLACN2   
   >      JUMP     ISAVE(1)   
   >      J        ISAVE(2)   
   >      ITER     ISAVE(3)   
   > \endverbatim   

   > \par Contributors:   
    ==================   
   >   
   >     Nick Higham, University of Manchester   

   > \par References:   
    ================   
   >   
   >  N.J. Higham, "FORTRAN codes for estimating the one-norm of   
   >  a real or complex matrix, with applications to condition estimation",   
   >  ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.   
   >   
    =====================================================================   
   Subroutine */ int igraphdlacn2_(integer *n, doublereal *v, doublereal *x, 
	integer *isgn, doublereal *est, integer *kase, integer *isave)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1;

    /* Builtin functions */
    double d_sign(doublereal *, doublereal *);
    integer i_dnnt(doublereal *);

    /* Local variables */
    integer i__;
    doublereal temp;
    extern doublereal igraphdasum_(integer *, doublereal *, integer *);
    integer jlast;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    doublereal altsgn, estold;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --isave;
    --isgn;
    --x;
    --v;

    /* Function Body */
    if (*kase == 0) {
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    x[i__] = 1. / (doublereal) (*n);
/* L10: */
	}
	*kase = 1;
	isave[1] = 1;
	return 0;
    }

    switch (isave[1]) {
	case 1:  goto L20;
	case 2:  goto L40;
	case 3:  goto L70;
	case 4:  goto L110;
	case 5:  goto L140;
    }

/*     ................ ENTRY   (ISAVE( 1 ) = 1)   
       FIRST ITERATION.  X HAS BEEN OVERWRITTEN BY A*X. */

L20:
    if (*n == 1) {
	v[1] = x[1];
	*est = abs(v[1]);
/*        ... QUIT */
	goto L150;
    }
    *est = igraphdasum_(n, &x[1], &c__1);

    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	x[i__] = d_sign(&c_b11, &x[i__]);
	isgn[i__] = i_dnnt(&x[i__]);
/* L30: */
    }
    *kase = 2;
    isave[1] = 2;
    return 0;

/*     ................ ENTRY   (ISAVE( 1 ) = 2)   
       FIRST ITERATION.  X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */

L40:
    isave[2] = igraphidamax_(n, &x[1], &c__1);
    isave[3] = 2;

/*     MAIN LOOP - ITERATIONS 2,3,...,ITMAX. */

L50:
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	x[i__] = 0.;
/* L60: */
    }
    x[isave[2]] = 1.;
    *kase = 1;
    isave[1] = 3;
    return 0;

/*     ................ ENTRY   (ISAVE( 1 ) = 3)   
       X HAS BEEN OVERWRITTEN BY A*X. */

L70:
    igraphdcopy_(n, &x[1], &c__1, &v[1], &c__1);
    estold = *est;
    *est = igraphdasum_(n, &v[1], &c__1);
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	d__1 = d_sign(&c_b11, &x[i__]);
	if (i_dnnt(&d__1) != isgn[i__]) {
	    goto L90;
	}
/* L80: */
    }
/*     REPEATED SIGN VECTOR DETECTED, HENCE ALGORITHM HAS CONVERGED. */
    goto L120;

L90:
/*     TEST FOR CYCLING. */
    if (*est <= estold) {
	goto L120;
    }

    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	x[i__] = d_sign(&c_b11, &x[i__]);
	isgn[i__] = i_dnnt(&x[i__]);
/* L100: */
    }
    *kase = 2;
    isave[1] = 4;
    return 0;

/*     ................ ENTRY   (ISAVE( 1 ) = 4)   
       X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */

L110:
    jlast = isave[2];
    isave[2] = igraphidamax_(n, &x[1], &c__1);
    if (x[jlast] != (d__1 = x[isave[2]], abs(d__1)) && isave[3] < 5) {
	++isave[3];
	goto L50;
    }

/*     ITERATION COMPLETE.  FINAL STAGE. */

L120:
    altsgn = 1.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	x[i__] = altsgn * ((doublereal) (i__ - 1) / (doublereal) (*n - 1) + 
		1.);
	altsgn = -altsgn;
/* L130: */
    }
    *kase = 1;
    isave[1] = 5;
    return 0;

/*     ................ ENTRY   (ISAVE( 1 ) = 5)   
       X HAS BEEN OVERWRITTEN BY A*X. */

L140:
    temp = igraphdasum_(n, &x[1], &c__1) / (doublereal) (*n * 3) * 2.;
    if (temp > *est) {
	igraphdcopy_(n, &x[1], &c__1, &v[1], &c__1);
	*est = temp;
    }

L150:
    *kase = 0;
    return 0;

/*     End of DLACN2 */

} /* igraphdlacn2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlacpy.c0000644000175100001710000001167100000000000024030 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLACPY copies all or part of one two-dimensional array to another.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLACPY + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLACPY( UPLO, M, N, A, LDA, B, LDB )   

         CHARACTER          UPLO   
         INTEGER            LDA, LDB, M, N   
         DOUBLE PRECISION   A( LDA, * ), B( LDB, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLACPY copies all or part of a two-dimensional matrix A to another   
   > matrix B.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies the part of the matrix A to be copied to B.   
   >          = 'U':      Upper triangular part   
   >          = 'L':      Lower triangular part   
   >          Otherwise:  All of the matrix A   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The m by n matrix A.  If UPLO = 'U', only the upper triangle   
   >          or trapezoid is accessed; if UPLO = 'L', only the lower   
   >          triangle or trapezoid is accessed.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,N)   
   >          On exit, B = A in the locations specified by UPLO.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of the array B.  LDB >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlacpy_(char *uplo, integer *m, integer *n, doublereal *
	a, integer *lda, doublereal *b, integer *ldb)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2;

    /* Local variables */
    integer i__, j;
    extern logical igraphlsame_(char *, char *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;

    /* Function Body */
    if (igraphlsame_(uplo, "U")) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = min(j,*m);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
/* L10: */
	    }
/* L20: */
	}
    } else if (igraphlsame_(uplo, "L")) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = j; i__ <= i__2; ++i__) {
		b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
/* L30: */
	    }
/* L40: */
	}
    } else {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
/* L50: */
	    }
/* L60: */
	}
    }
    return 0;

/*     End of DLACPY */

} /* igraphdlacpy_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dladiv.c0000644000175100001710000001407400000000000024017 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLADIV performs complex division in real arithmetic, avoiding unnecessary overflow.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLADIV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLADIV( A, B, C, D, P, Q )   

         DOUBLE PRECISION   A, B, C, D, P, Q   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLADIV performs complex division in  real arithmetic   
   >   
   >                       a + i*b   
   >            p + i*q = ---------   
   >                       c + i*d   
   >   
   > The algorithm is due to Michael Baudin and Robert L. Smith   
   > and can be found in the paper   
   > "A Robust Complex Division in Scilab"   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION   
   >          The scalars a, b, c, and d in the above expression.   
   > \endverbatim   
   >   
   > \param[out] P   
   > \verbatim   
   >          P is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] Q   
   > \verbatim   
   >          Q is DOUBLE PRECISION   
   >          The scalars p and q in the above expression.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date January 2013   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdladiv_(doublereal *a, doublereal *b, doublereal *c__, 
	doublereal *d__, doublereal *p, doublereal *q)
{
    /* System generated locals */
    doublereal d__1, d__2;

    /* Local variables */
    doublereal s, aa, ab, bb, cc, cd, dd, be, un, ov, eps;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int dladiv1_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       January 2013   


    ===================================================================== */



    aa = *a;
    bb = *b;
    cc = *c__;
    dd = *d__;
/* Computing MAX */
    d__1 = abs(*a), d__2 = abs(*b);
    ab = max(d__1,d__2);
/* Computing MAX */
    d__1 = abs(*c__), d__2 = abs(*d__);
    cd = max(d__1,d__2);
    s = 1.;
    ov = igraphdlamch_("Overflow threshold");
    un = igraphdlamch_("Safe minimum");
    eps = igraphdlamch_("Epsilon");
    be = 2. / (eps * eps);
    if (ab >= ov * .5) {
	aa *= .5;
	bb *= .5;
	s *= 2.;
    }
    if (cd >= ov * .5) {
	cc *= .5;
	dd *= .5;
	s *= .5;
    }
    if (ab <= un * 2. / eps) {
	aa *= be;
	bb *= be;
	s /= be;
    }
    if (cd <= un * 2. / eps) {
	cc *= be;
	dd *= be;
	s *= be;
    }
    if (abs(*d__) <= abs(*c__)) {
	dladiv1_(&aa, &bb, &cc, &dd, p, q);
    } else {
	dladiv1_(&bb, &aa, &dd, &cc, p, q);
	*q = -(*q);
    }
    *p *= s;
    *q *= s;

    return 0;

/*     End of DLADIV */

} /* igraphdladiv_   

   Subroutine */ int dladiv1_(doublereal *a, doublereal *b, doublereal *c__, 
	doublereal *d__, doublereal *p, doublereal *q)
{
    doublereal r__, t;
    extern doublereal dladiv2_(doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       January 2013   


    ===================================================================== */



    r__ = *d__ / *c__;
    t = 1. / (*c__ + *d__ * r__);
    *p = dladiv2_(a, b, c__, d__, &r__, &t);
    *a = -(*a);
    *q = dladiv2_(b, a, c__, d__, &r__, &t);

    return 0;

/*     End of DLADIV1 */

} /* dladiv1_ */

doublereal dladiv2_(doublereal *a, doublereal *b, doublereal *c__, doublereal 
	*d__, doublereal *r__, doublereal *t)
{
    /* System generated locals */
    doublereal ret_val;

    /* Local variables */
    doublereal br;


/*  -- LAPACK auxiliary routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       January 2013   


    ===================================================================== */



    if (*r__ != 0.) {
	br = *b * *r__;
	if (br != 0.) {
	    ret_val = (*a + br) * *t;
	} else {
	    ret_val = *a * *t + *b * *t * *r__;
	}
    } else {
	ret_val = (*a + *d__ * (*b / *c__)) * *t;
    }

    return ret_val;

/*     End of DLADIV12 */

} /* dladiv2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlae2.c0000644000175100001710000001231100000000000023533 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAE2 computes the eigenvalues of a 2-by-2 symmetric matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAE2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAE2( A, B, C, RT1, RT2 )   

         DOUBLE PRECISION   A, B, C, RT1, RT2   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAE2  computes the eigenvalues of a 2-by-2 symmetric matrix   
   >    [  A   B  ]   
   >    [  B   C  ].   
   > On return, RT1 is the eigenvalue of larger absolute value, and RT2   
   > is the eigenvalue of smaller absolute value.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION   
   >          The (1,1) element of the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION   
   >          The (1,2) and (2,1) elements of the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION   
   >          The (2,2) element of the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[out] RT1   
   > \verbatim   
   >          RT1 is DOUBLE PRECISION   
   >          The eigenvalue of larger absolute value.   
   > \endverbatim   
   >   
   > \param[out] RT2   
   > \verbatim   
   >          RT2 is DOUBLE PRECISION   
   >          The eigenvalue of smaller absolute value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  RT1 is accurate to a few ulps barring over/underflow.   
   >   
   >  RT2 may be inaccurate if there is massive cancellation in the   
   >  determinant A*C-B*B; higher precision or correctly rounded or   
   >  correctly truncated arithmetic would be needed to compute RT2   
   >  accurately in all cases.   
   >   
   >  Overflow is possible only if RT1 is within a factor of 5 of overflow.   
   >  Underflow is harmless if the input data is 0 or exceeds   
   >     underflow_threshold / macheps.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlae2_(doublereal *a, doublereal *b, doublereal *c__, 
	doublereal *rt1, doublereal *rt2)
{
    /* System generated locals */
    doublereal d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal ab, df, tb, sm, rt, adf, acmn, acmx;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Compute the eigenvalues */

    sm = *a + *c__;
    df = *a - *c__;
    adf = abs(df);
    tb = *b + *b;
    ab = abs(tb);
    if (abs(*a) > abs(*c__)) {
	acmx = *a;
	acmn = *c__;
    } else {
	acmx = *c__;
	acmn = *a;
    }
    if (adf > ab) {
/* Computing 2nd power */
	d__1 = ab / adf;
	rt = adf * sqrt(d__1 * d__1 + 1.);
    } else if (adf < ab) {
/* Computing 2nd power */
	d__1 = adf / ab;
	rt = ab * sqrt(d__1 * d__1 + 1.);
    } else {

/*        Includes case AB=ADF=0 */

	rt = ab * sqrt(2.);
    }
    if (sm < 0.) {
	*rt1 = (sm - rt) * .5;

/*        Order of execution important.   
          To get fully accurate smaller eigenvalue,   
          next line needs to be executed in higher precision. */

	*rt2 = acmx / *rt1 * acmn - *b / *rt1 * *b;
    } else if (sm > 0.) {
	*rt1 = (sm + rt) * .5;

/*        Order of execution important.   
          To get fully accurate smaller eigenvalue,   
          next line needs to be executed in higher precision. */

	*rt2 = acmx / *rt1 * acmn - *b / *rt1 * *b;
    } else {

/*        Includes case RT1 = RT2 = 0 */

	*rt1 = rt * .5;
	*rt2 = rt * -.5;
    }
    return 0;

/*     End of DLAE2 */

} /* igraphdlae2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaebz.c0000644000175100001710000005653200000000000024022 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAEBZ computes the number of eigenvalues of a real symmetric tridiagonal matrix which are less
 than or equal to a given value, and performs other tasks required by the routine sstebz.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAEBZ + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAEBZ( IJOB, NITMAX, N, MMAX, MINP, NBMIN, ABSTOL,   
                            RELTOL, PIVMIN, D, E, E2, NVAL, AB, C, MOUT,   
                            NAB, WORK, IWORK, INFO )   

         INTEGER            IJOB, INFO, MINP, MMAX, MOUT, N, NBMIN, NITMAX   
         DOUBLE PRECISION   ABSTOL, PIVMIN, RELTOL   
         INTEGER            IWORK( * ), NAB( MMAX, * ), NVAL( * )   
         DOUBLE PRECISION   AB( MMAX, * ), C( * ), D( * ), E( * ), E2( * ),   
        $                   WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAEBZ contains the iteration loops which compute and use the   
   > function N(w), which is the count of eigenvalues of a symmetric   
   > tridiagonal matrix T less than or equal to its argument  w.  It   
   > performs a choice of two types of loops:   
   >   
   > IJOB=1, followed by   
   > IJOB=2: It takes as input a list of intervals and returns a list of   
   >         sufficiently small intervals whose union contains the same   
   >         eigenvalues as the union of the original intervals.   
   >         The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP.   
   >         The output interval (AB(j,1),AB(j,2)] will contain   
   >         eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT.   
   >   
   > IJOB=3: It performs a binary search in each input interval   
   >         (AB(j,1),AB(j,2)] for a point  w(j)  such that   
   >         N(w(j))=NVAL(j), and uses  C(j)  as the starting point of   
   >         the search.  If such a w(j) is found, then on output   
   >         AB(j,1)=AB(j,2)=w.  If no such w(j) is found, then on output   
   >         (AB(j,1),AB(j,2)] will be a small interval containing the   
   >         point where N(w) jumps through NVAL(j), unless that point   
   >         lies outside the initial interval.   
   >   
   > Note that the intervals are in all cases half-open intervals,   
   > i.e., of the form  (a,b] , which includes  b  but not  a .   
   >   
   > To avoid underflow, the matrix should be scaled so that its largest   
   > element is no greater than  overflow**(1/2) * underflow**(1/4)   
   > in absolute value.  To assure the most accurate computation   
   > of small eigenvalues, the matrix should be scaled to be   
   > not much smaller than that, either.   
   >   
   > See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal   
   > Matrix", Report CS41, Computer Science Dept., Stanford   
   > University, July 21, 1966   
   >   
   > Note: the arguments are, in general, *not* checked for unreasonable   
   > values.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] IJOB   
   > \verbatim   
   >          IJOB is INTEGER   
   >          Specifies what is to be done:   
   >          = 1:  Compute NAB for the initial intervals.   
   >          = 2:  Perform bisection iteration to find eigenvalues of T.   
   >          = 3:  Perform bisection iteration to invert N(w), i.e.,   
   >                to find a point which has a specified number of   
   >                eigenvalues of T to its left.   
   >          Other values will cause DLAEBZ to return with INFO=-1.   
   > \endverbatim   
   >   
   > \param[in] NITMAX   
   > \verbatim   
   >          NITMAX is INTEGER   
   >          The maximum number of "levels" of bisection to be   
   >          performed, i.e., an interval of width W will not be made   
   >          smaller than 2^(-NITMAX) * W.  If not all intervals   
   >          have converged after NITMAX iterations, then INFO is set   
   >          to the number of non-converged intervals.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The dimension n of the tridiagonal matrix T.  It must be at   
   >          least 1.   
   > \endverbatim   
   >   
   > \param[in] MMAX   
   > \verbatim   
   >          MMAX is INTEGER   
   >          The maximum number of intervals.  If more than MMAX intervals   
   >          are generated, then DLAEBZ will quit with INFO=MMAX+1.   
   > \endverbatim   
   >   
   > \param[in] MINP   
   > \verbatim   
   >          MINP is INTEGER   
   >          The initial number of intervals.  It may not be greater than   
   >          MMAX.   
   > \endverbatim   
   >   
   > \param[in] NBMIN   
   > \verbatim   
   >          NBMIN is INTEGER   
   >          The smallest number of intervals that should be processed   
   >          using a vector loop.  If zero, then only the scalar loop   
   >          will be used.   
   > \endverbatim   
   >   
   > \param[in] ABSTOL   
   > \verbatim   
   >          ABSTOL is DOUBLE PRECISION   
   >          The minimum (absolute) width of an interval.  When an   
   >          interval is narrower than ABSTOL, or than RELTOL times the   
   >          larger (in magnitude) endpoint, then it is considered to be   
   >          sufficiently small, i.e., converged.  This must be at least   
   >          zero.   
   > \endverbatim   
   >   
   > \param[in] RELTOL   
   > \verbatim   
   >          RELTOL is DOUBLE PRECISION   
   >          The minimum relative width of an interval.  When an interval   
   >          is narrower than ABSTOL, or than RELTOL times the larger (in   
   >          magnitude) endpoint, then it is considered to be   
   >          sufficiently small, i.e., converged.  Note: this should   
   >          always be at least radix*machine epsilon.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum absolute value of a "pivot" in the Sturm   
   >          sequence loop.   
   >          This must be at least  max |e(j)**2|*safe_min  and at   
   >          least safe_min, where safe_min is at least   
   >          the smallest number that can divide one without overflow.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          The offdiagonal elements of the tridiagonal matrix T in   
   >          positions 1 through N-1.  E(N) is arbitrary.   
   > \endverbatim   
   >   
   > \param[in] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N)   
   >          The squares of the offdiagonal elements of the tridiagonal   
   >          matrix T.  E2(N) is ignored.   
   > \endverbatim   
   >   
   > \param[in,out] NVAL   
   > \verbatim   
   >          NVAL is INTEGER array, dimension (MINP)   
   >          If IJOB=1 or 2, not referenced.   
   >          If IJOB=3, the desired values of N(w).  The elements of NVAL   
   >          will be reordered to correspond with the intervals in AB.   
   >          Thus, NVAL(j) on output will not, in general be the same as   
   >          NVAL(j) on input, but it will correspond with the interval   
   >          (AB(j,1),AB(j,2)] on output.   
   > \endverbatim   
   >   
   > \param[in,out] AB   
   > \verbatim   
   >          AB is DOUBLE PRECISION array, dimension (MMAX,2)   
   >          The endpoints of the intervals.  AB(j,1) is  a(j), the left   
   >          endpoint of the j-th interval, and AB(j,2) is b(j), the   
   >          right endpoint of the j-th interval.  The input intervals   
   >          will, in general, be modified, split, and reordered by the   
   >          calculation.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (MMAX)   
   >          If IJOB=1, ignored.   
   >          If IJOB=2, workspace.   
   >          If IJOB=3, then on input C(j) should be initialized to the   
   >          first search point in the binary search.   
   > \endverbatim   
   >   
   > \param[out] MOUT   
   > \verbatim   
   >          MOUT is INTEGER   
   >          If IJOB=1, the number of eigenvalues in the intervals.   
   >          If IJOB=2 or 3, the number of intervals output.   
   >          If IJOB=3, MOUT will equal MINP.   
   > \endverbatim   
   >   
   > \param[in,out] NAB   
   > \verbatim   
   >          NAB is INTEGER array, dimension (MMAX,2)   
   >          If IJOB=1, then on output NAB(i,j) will be set to N(AB(i,j)).   
   >          If IJOB=2, then on input, NAB(i,j) should be set.  It must   
   >             satisfy the condition:   
   >             N(AB(i,1)) <= NAB(i,1) <= NAB(i,2) <= N(AB(i,2)),   
   >             which means that in interval i only eigenvalues   
   >             NAB(i,1)+1,...,NAB(i,2) will be considered.  Usually,   
   >             NAB(i,j)=N(AB(i,j)), from a previous call to DLAEBZ with   
   >             IJOB=1.   
   >             On output, NAB(i,j) will contain   
   >             max(na(k),min(nb(k),N(AB(i,j)))), where k is the index of   
   >             the input interval that the output interval   
   >             (AB(j,1),AB(j,2)] came from, and na(k) and nb(k) are the   
   >             the input values of NAB(k,1) and NAB(k,2).   
   >          If IJOB=3, then on output, NAB(i,j) contains N(AB(i,j)),   
   >             unless N(w) > NVAL(i) for all search points  w , in which   
   >             case NAB(i,1) will not be modified, i.e., the output   
   >             value will be the same as the input value (modulo   
   >             reorderings -- see NVAL and AB), or unless N(w) < NVAL(i)   
   >             for all search points  w , in which case NAB(i,2) will   
   >             not be modified.  Normally, NAB should be set to some   
   >             distinctive value(s) before DLAEBZ is called.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MMAX)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (MMAX)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:       All intervals converged.   
   >          = 1--MMAX: The last INFO intervals did not converge.   
   >          = MMAX+1:  More than MMAX intervals were generated.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >      This routine is intended to be called only by other LAPACK   
   >  routines, thus the interface is less user-friendly.  It is intended   
   >  for two purposes:   
   >   
   >  (a) finding eigenvalues.  In this case, DLAEBZ should have one or   
   >      more initial intervals set up in AB, and DLAEBZ should be called   
   >      with IJOB=1.  This sets up NAB, and also counts the eigenvalues.   
   >      Intervals with no eigenvalues would usually be thrown out at   
   >      this point.  Also, if not all the eigenvalues in an interval i   
   >      are desired, NAB(i,1) can be increased or NAB(i,2) decreased.   
   >      For example, set NAB(i,1)=NAB(i,2)-1 to get the largest   
   >      eigenvalue.  DLAEBZ is then called with IJOB=2 and MMAX   
   >      no smaller than the value of MOUT returned by the call with   
   >      IJOB=1.  After this (IJOB=2) call, eigenvalues NAB(i,1)+1   
   >      through NAB(i,2) are approximately AB(i,1) (or AB(i,2)) to the   
   >      tolerance specified by ABSTOL and RELTOL.   
   >   
   >  (b) finding an interval (a',b'] containing eigenvalues w(f),...,w(l).   
   >      In this case, start with a Gershgorin interval  (a,b).  Set up   
   >      AB to contain 2 search intervals, both initially (a,b).  One   
   >      NVAL element should contain  f-1  and the other should contain  l   
   >      , while C should contain a and b, resp.  NAB(i,1) should be -1   
   >      and NAB(i,2) should be N+1, to flag an error if the desired   
   >      interval does not lie in (a,b).  DLAEBZ is then called with   
   >      IJOB=3.  On exit, if w(f-1) < w(f), then one of the intervals --   
   >      j -- will have AB(j,1)=AB(j,2) and NAB(j,1)=NAB(j,2)=f-1, while   
   >      if, to the specified tolerance, w(f-k)=...=w(f+r), k > 0 and r   
   >      >= 0, then the interval will have  N(AB(j,1))=NAB(j,1)=f-k and   
   >      N(AB(j,2))=NAB(j,2)=f+r.  The cases w(l) < w(l+1) and   
   >      w(l-r)=...=w(l+k) are handled similarly.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaebz_(integer *ijob, integer *nitmax, integer *n, 
	integer *mmax, integer *minp, integer *nbmin, doublereal *abstol, 
	doublereal *reltol, doublereal *pivmin, doublereal *d__, doublereal *
	e, doublereal *e2, integer *nval, doublereal *ab, doublereal *c__, 
	integer *mout, integer *nab, doublereal *work, integer *iwork, 
	integer *info)
{
    /* System generated locals */
    integer nab_dim1, nab_offset, ab_dim1, ab_offset, i__1, i__2, i__3, i__4, 
	    i__5, i__6;
    doublereal d__1, d__2, d__3, d__4;

    /* Local variables */
    integer j, kf, ji, kl, jp, jit;
    doublereal tmp1, tmp2;
    integer itmp1, itmp2, kfnew, klnew;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Check for Errors   

       Parameter adjustments */
    nab_dim1 = *mmax;
    nab_offset = 1 + nab_dim1;
    nab -= nab_offset;
    ab_dim1 = *mmax;
    ab_offset = 1 + ab_dim1;
    ab -= ab_offset;
    --d__;
    --e;
    --e2;
    --nval;
    --c__;
    --work;
    --iwork;

    /* Function Body */
    *info = 0;
    if (*ijob < 1 || *ijob > 3) {
	*info = -1;
	return 0;
    }

/*     Initialize NAB */

    if (*ijob == 1) {

/*        Compute the number of eigenvalues in the initial intervals. */

	*mout = 0;
	i__1 = *minp;
	for (ji = 1; ji <= i__1; ++ji) {
	    for (jp = 1; jp <= 2; ++jp) {
		tmp1 = d__[1] - ab[ji + jp * ab_dim1];
		if (abs(tmp1) < *pivmin) {
		    tmp1 = -(*pivmin);
		}
		nab[ji + jp * nab_dim1] = 0;
		if (tmp1 <= 0.) {
		    nab[ji + jp * nab_dim1] = 1;
		}

		i__2 = *n;
		for (j = 2; j <= i__2; ++j) {
		    tmp1 = d__[j] - e2[j - 1] / tmp1 - ab[ji + jp * ab_dim1];
		    if (abs(tmp1) < *pivmin) {
			tmp1 = -(*pivmin);
		    }
		    if (tmp1 <= 0.) {
			++nab[ji + jp * nab_dim1];
		    }
/* L10: */
		}
/* L20: */
	    }
	    *mout = *mout + nab[ji + (nab_dim1 << 1)] - nab[ji + nab_dim1];
/* L30: */
	}
	return 0;
    }

/*     Initialize for loop   

       KF and KL have the following meaning:   
          Intervals 1,...,KF-1 have converged.   
          Intervals KF,...,KL  still need to be refined. */

    kf = 1;
    kl = *minp;

/*     If IJOB=2, initialize C.   
       If IJOB=3, use the user-supplied starting point. */

    if (*ijob == 2) {
	i__1 = *minp;
	for (ji = 1; ji <= i__1; ++ji) {
	    c__[ji] = (ab[ji + ab_dim1] + ab[ji + (ab_dim1 << 1)]) * .5;
/* L40: */
	}
    }

/*     Iteration loop */

    i__1 = *nitmax;
    for (jit = 1; jit <= i__1; ++jit) {

/*        Loop over intervals */

	if (kl - kf + 1 >= *nbmin && *nbmin > 0) {

/*           Begin of Parallel Version of the loop */

	    i__2 = kl;
	    for (ji = kf; ji <= i__2; ++ji) {

/*              Compute N(c), the number of eigenvalues less than c */

		work[ji] = d__[1] - c__[ji];
		iwork[ji] = 0;
		if (work[ji] <= *pivmin) {
		    iwork[ji] = 1;
/* Computing MIN */
		    d__1 = work[ji], d__2 = -(*pivmin);
		    work[ji] = min(d__1,d__2);
		}

		i__3 = *n;
		for (j = 2; j <= i__3; ++j) {
		    work[ji] = d__[j] - e2[j - 1] / work[ji] - c__[ji];
		    if (work[ji] <= *pivmin) {
			++iwork[ji];
/* Computing MIN */
			d__1 = work[ji], d__2 = -(*pivmin);
			work[ji] = min(d__1,d__2);
		    }
/* L50: */
		}
/* L60: */
	    }

	    if (*ijob <= 2) {

/*              IJOB=2: Choose all intervals containing eigenvalues. */

		klnew = kl;
		i__2 = kl;
		for (ji = kf; ji <= i__2; ++ji) {

/*                 Insure that N(w) is monotone   

   Computing MIN   
   Computing MAX */
		    i__5 = nab[ji + nab_dim1], i__6 = iwork[ji];
		    i__3 = nab[ji + (nab_dim1 << 1)], i__4 = max(i__5,i__6);
		    iwork[ji] = min(i__3,i__4);

/*                 Update the Queue -- add intervals if both halves   
                   contain eigenvalues. */

		    if (iwork[ji] == nab[ji + (nab_dim1 << 1)]) {

/*                    No eigenvalue in the upper interval:   
                      just use the lower interval. */

			ab[ji + (ab_dim1 << 1)] = c__[ji];

		    } else if (iwork[ji] == nab[ji + nab_dim1]) {

/*                    No eigenvalue in the lower interval:   
                      just use the upper interval. */

			ab[ji + ab_dim1] = c__[ji];
		    } else {
			++klnew;
			if (klnew <= *mmax) {

/*                       Eigenvalue in both intervals -- add upper to   
                         queue. */

			    ab[klnew + (ab_dim1 << 1)] = ab[ji + (ab_dim1 << 
				    1)];
			    nab[klnew + (nab_dim1 << 1)] = nab[ji + (nab_dim1 
				    << 1)];
			    ab[klnew + ab_dim1] = c__[ji];
			    nab[klnew + nab_dim1] = iwork[ji];
			    ab[ji + (ab_dim1 << 1)] = c__[ji];
			    nab[ji + (nab_dim1 << 1)] = iwork[ji];
			} else {
			    *info = *mmax + 1;
			}
		    }
/* L70: */
		}
		if (*info != 0) {
		    return 0;
		}
		kl = klnew;
	    } else {

/*              IJOB=3: Binary search.  Keep only the interval containing   
                        w   s.t. N(w) = NVAL */

		i__2 = kl;
		for (ji = kf; ji <= i__2; ++ji) {
		    if (iwork[ji] <= nval[ji]) {
			ab[ji + ab_dim1] = c__[ji];
			nab[ji + nab_dim1] = iwork[ji];
		    }
		    if (iwork[ji] >= nval[ji]) {
			ab[ji + (ab_dim1 << 1)] = c__[ji];
			nab[ji + (nab_dim1 << 1)] = iwork[ji];
		    }
/* L80: */
		}
	    }

	} else {

/*           End of Parallel Version of the loop   

             Begin of Serial Version of the loop */

	    klnew = kl;
	    i__2 = kl;
	    for (ji = kf; ji <= i__2; ++ji) {

/*              Compute N(w), the number of eigenvalues less than w */

		tmp1 = c__[ji];
		tmp2 = d__[1] - tmp1;
		itmp1 = 0;
		if (tmp2 <= *pivmin) {
		    itmp1 = 1;
/* Computing MIN */
		    d__1 = tmp2, d__2 = -(*pivmin);
		    tmp2 = min(d__1,d__2);
		}

		i__3 = *n;
		for (j = 2; j <= i__3; ++j) {
		    tmp2 = d__[j] - e2[j - 1] / tmp2 - tmp1;
		    if (tmp2 <= *pivmin) {
			++itmp1;
/* Computing MIN */
			d__1 = tmp2, d__2 = -(*pivmin);
			tmp2 = min(d__1,d__2);
		    }
/* L90: */
		}

		if (*ijob <= 2) {

/*                 IJOB=2: Choose all intervals containing eigenvalues.   

                   Insure that N(w) is monotone   

   Computing MIN   
   Computing MAX */
		    i__5 = nab[ji + nab_dim1];
		    i__3 = nab[ji + (nab_dim1 << 1)], i__4 = max(i__5,itmp1);
		    itmp1 = min(i__3,i__4);

/*                 Update the Queue -- add intervals if both halves   
                   contain eigenvalues. */

		    if (itmp1 == nab[ji + (nab_dim1 << 1)]) {

/*                    No eigenvalue in the upper interval:   
                      just use the lower interval. */

			ab[ji + (ab_dim1 << 1)] = tmp1;

		    } else if (itmp1 == nab[ji + nab_dim1]) {

/*                    No eigenvalue in the lower interval:   
                      just use the upper interval. */

			ab[ji + ab_dim1] = tmp1;
		    } else if (klnew < *mmax) {

/*                    Eigenvalue in both intervals -- add upper to queue. */

			++klnew;
			ab[klnew + (ab_dim1 << 1)] = ab[ji + (ab_dim1 << 1)];
			nab[klnew + (nab_dim1 << 1)] = nab[ji + (nab_dim1 << 
				1)];
			ab[klnew + ab_dim1] = tmp1;
			nab[klnew + nab_dim1] = itmp1;
			ab[ji + (ab_dim1 << 1)] = tmp1;
			nab[ji + (nab_dim1 << 1)] = itmp1;
		    } else {
			*info = *mmax + 1;
			return 0;
		    }
		} else {

/*                 IJOB=3: Binary search.  Keep only the interval   
                           containing  w  s.t. N(w) = NVAL */

		    if (itmp1 <= nval[ji]) {
			ab[ji + ab_dim1] = tmp1;
			nab[ji + nab_dim1] = itmp1;
		    }
		    if (itmp1 >= nval[ji]) {
			ab[ji + (ab_dim1 << 1)] = tmp1;
			nab[ji + (nab_dim1 << 1)] = itmp1;
		    }
		}
/* L100: */
	    }
	    kl = klnew;

	}

/*        Check for convergence */

	kfnew = kf;
	i__2 = kl;
	for (ji = kf; ji <= i__2; ++ji) {
	    tmp1 = (d__1 = ab[ji + (ab_dim1 << 1)] - ab[ji + ab_dim1], abs(
		    d__1));
/* Computing MAX */
	    d__3 = (d__1 = ab[ji + (ab_dim1 << 1)], abs(d__1)), d__4 = (d__2 =
		     ab[ji + ab_dim1], abs(d__2));
	    tmp2 = max(d__3,d__4);
/* Computing MAX */
	    d__1 = max(*abstol,*pivmin), d__2 = *reltol * tmp2;
	    if (tmp1 < max(d__1,d__2) || nab[ji + nab_dim1] >= nab[ji + (
		    nab_dim1 << 1)]) {

/*              Converged -- Swap with position KFNEW,   
                             then increment KFNEW */

		if (ji > kfnew) {
		    tmp1 = ab[ji + ab_dim1];
		    tmp2 = ab[ji + (ab_dim1 << 1)];
		    itmp1 = nab[ji + nab_dim1];
		    itmp2 = nab[ji + (nab_dim1 << 1)];
		    ab[ji + ab_dim1] = ab[kfnew + ab_dim1];
		    ab[ji + (ab_dim1 << 1)] = ab[kfnew + (ab_dim1 << 1)];
		    nab[ji + nab_dim1] = nab[kfnew + nab_dim1];
		    nab[ji + (nab_dim1 << 1)] = nab[kfnew + (nab_dim1 << 1)];
		    ab[kfnew + ab_dim1] = tmp1;
		    ab[kfnew + (ab_dim1 << 1)] = tmp2;
		    nab[kfnew + nab_dim1] = itmp1;
		    nab[kfnew + (nab_dim1 << 1)] = itmp2;
		    if (*ijob == 3) {
			itmp1 = nval[ji];
			nval[ji] = nval[kfnew];
			nval[kfnew] = itmp1;
		    }
		}
		++kfnew;
	    }
/* L110: */
	}
	kf = kfnew;

/*        Choose Midpoints */

	i__2 = kl;
	for (ji = kf; ji <= i__2; ++ji) {
	    c__[ji] = (ab[ji + ab_dim1] + ab[ji + (ab_dim1 << 1)]) * .5;
/* L120: */
	}

/*        If no more intervals to refine, quit. */

	if (kf > kl) {
	    goto L140;
	}
/* L130: */
    }

/*     Converged */

L140:
/* Computing MAX */
    i__1 = kl + 1 - kf;
    *info = max(i__1,0);
    *mout = kl;

    return 0;

/*     End of DLAEBZ */

} /* igraphdlaebz_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaev2.c0000644000175100001710000001473500000000000023735 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAEV2 computes the eigenvalues and eigenvectors of a 2-by-2 symmetric/Hermitian matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAEV2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAEV2( A, B, C, RT1, RT2, CS1, SN1 )   

         DOUBLE PRECISION   A, B, C, CS1, RT1, RT2, SN1   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAEV2 computes the eigendecomposition of a 2-by-2 symmetric matrix   
   >    [  A   B  ]   
   >    [  B   C  ].   
   > On return, RT1 is the eigenvalue of larger absolute value, RT2 is the   
   > eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right   
   > eigenvector for RT1, giving the decomposition   
   >   
   >    [ CS1  SN1 ] [  A   B  ] [ CS1 -SN1 ]  =  [ RT1  0  ]   
   >    [-SN1  CS1 ] [  B   C  ] [ SN1  CS1 ]     [  0  RT2 ].   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION   
   >          The (1,1) element of the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION   
   >          The (1,2) element and the conjugate of the (2,1) element of   
   >          the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION   
   >          The (2,2) element of the 2-by-2 matrix.   
   > \endverbatim   
   >   
   > \param[out] RT1   
   > \verbatim   
   >          RT1 is DOUBLE PRECISION   
   >          The eigenvalue of larger absolute value.   
   > \endverbatim   
   >   
   > \param[out] RT2   
   > \verbatim   
   >          RT2 is DOUBLE PRECISION   
   >          The eigenvalue of smaller absolute value.   
   > \endverbatim   
   >   
   > \param[out] CS1   
   > \verbatim   
   >          CS1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] SN1   
   > \verbatim   
   >          SN1 is DOUBLE PRECISION   
   >          The vector (CS1, SN1) is a unit right eigenvector for RT1.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  RT1 is accurate to a few ulps barring over/underflow.   
   >   
   >  RT2 may be inaccurate if there is massive cancellation in the   
   >  determinant A*C-B*B; higher precision or correctly rounded or   
   >  correctly truncated arithmetic would be needed to compute RT2   
   >  accurately in all cases.   
   >   
   >  CS1 and SN1 are accurate to a few ulps barring over/underflow.   
   >   
   >  Overflow is possible only if RT1 is within a factor of 5 of overflow.   
   >  Underflow is harmless if the input data is 0 or exceeds   
   >     underflow_threshold / macheps.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaev2_(doublereal *a, doublereal *b, doublereal *c__, 
	doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1)
{
    /* System generated locals */
    doublereal d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal ab, df, cs, ct, tb, sm, tn, rt, adf, acs;
    integer sgn1, sgn2;
    doublereal acmn, acmx;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Compute the eigenvalues */

    sm = *a + *c__;
    df = *a - *c__;
    adf = abs(df);
    tb = *b + *b;
    ab = abs(tb);
    if (abs(*a) > abs(*c__)) {
	acmx = *a;
	acmn = *c__;
    } else {
	acmx = *c__;
	acmn = *a;
    }
    if (adf > ab) {
/* Computing 2nd power */
	d__1 = ab / adf;
	rt = adf * sqrt(d__1 * d__1 + 1.);
    } else if (adf < ab) {
/* Computing 2nd power */
	d__1 = adf / ab;
	rt = ab * sqrt(d__1 * d__1 + 1.);
    } else {

/*        Includes case AB=ADF=0 */

	rt = ab * sqrt(2.);
    }
    if (sm < 0.) {
	*rt1 = (sm - rt) * .5;
	sgn1 = -1;

/*        Order of execution important.   
          To get fully accurate smaller eigenvalue,   
          next line needs to be executed in higher precision. */

	*rt2 = acmx / *rt1 * acmn - *b / *rt1 * *b;
    } else if (sm > 0.) {
	*rt1 = (sm + rt) * .5;
	sgn1 = 1;

/*        Order of execution important.   
          To get fully accurate smaller eigenvalue,   
          next line needs to be executed in higher precision. */

	*rt2 = acmx / *rt1 * acmn - *b / *rt1 * *b;
    } else {

/*        Includes case RT1 = RT2 = 0 */

	*rt1 = rt * .5;
	*rt2 = rt * -.5;
	sgn1 = 1;
    }

/*     Compute the eigenvector */

    if (df >= 0.) {
	cs = df + rt;
	sgn2 = 1;
    } else {
	cs = df - rt;
	sgn2 = -1;
    }
    acs = abs(cs);
    if (acs > ab) {
	ct = -tb / cs;
	*sn1 = 1. / sqrt(ct * ct + 1.);
	*cs1 = ct * *sn1;
    } else {
	if (ab == 0.) {
	    *cs1 = 1.;
	    *sn1 = 0.;
	} else {
	    tn = -cs / tb;
	    *cs1 = 1. / sqrt(tn * tn + 1.);
	    *sn1 = tn * *cs1;
	}
    }
    if (sgn1 == sgn2) {
	tn = *cs1;
	*cs1 = -(*sn1);
	*sn1 = tn;
    }
    return 0;

/*     End of DLAEV2 */

} /* igraphdlaev2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaexc.c0000644000175100001710000003573700000000000024025 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__4 = 4;
static logical c_false = FALSE_;
static integer c_n1 = -1;
static integer c__2 = 2;
static integer c__3 = 3;

/* > \brief \b DLAEXC swaps adjacent diagonal blocks of a real upper quasi-triangular matrix in Schur canonica
l form, by an orthogonal similarity transformation.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAEXC + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAEXC( WANTQ, N, T, LDT, Q, LDQ, J1, N1, N2, WORK,   
                            INFO )   

         LOGICAL            WANTQ   
         INTEGER            INFO, J1, LDQ, LDT, N, N1, N2   
         DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in   
   > an upper quasi-triangular matrix T by an orthogonal similarity   
   > transformation.   
   >   
   > T must be in Schur canonical form, that is, block upper triangular   
   > with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block   
   > has its diagonal elemnts equal and its off-diagonal elements of   
   > opposite sign.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTQ   
   > \verbatim   
   >          WANTQ is LOGICAL   
   >          = .TRUE. : accumulate the transformation in the matrix Q;   
   >          = .FALSE.: do not accumulate the transformation.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          On entry, the upper quasi-triangular matrix T, in Schur   
   >          canonical form.   
   >          On exit, the updated matrix T, again in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] Q   
   > \verbatim   
   >          Q is DOUBLE PRECISION array, dimension (LDQ,N)   
   >          On entry, if WANTQ is .TRUE., the orthogonal matrix Q.   
   >          On exit, if WANTQ is .TRUE., the updated matrix Q.   
   >          If WANTQ is .FALSE., Q is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDQ   
   > \verbatim   
   >          LDQ is INTEGER   
   >          The leading dimension of the array Q.   
   >          LDQ >= 1; and if WANTQ is .TRUE., LDQ >= N.   
   > \endverbatim   
   >   
   > \param[in] J1   
   > \verbatim   
   >          J1 is INTEGER   
   >          The index of the first row of the first block T11.   
   > \endverbatim   
   >   
   > \param[in] N1   
   > \verbatim   
   >          N1 is INTEGER   
   >          The order of the first block T11. N1 = 0, 1 or 2.   
   > \endverbatim   
   >   
   > \param[in] N2   
   > \verbatim   
   >          N2 is INTEGER   
   >          The order of the second block T22. N2 = 0, 1 or 2.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          = 1: the transformed matrix T would be too far from Schur   
   >               form; the blocks are not swapped and T and Q are   
   >               unchanged.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlaexc_(logical *wantq, integer *n, doublereal *t, 
	integer *ldt, doublereal *q, integer *ldq, integer *j1, integer *n1, 
	integer *n2, doublereal *work, integer *info)
{
    /* System generated locals */
    integer q_dim1, q_offset, t_dim1, t_offset, i__1;
    doublereal d__1, d__2, d__3;

    /* Local variables */
    doublereal d__[16]	/* was [4][4] */;
    integer k;
    doublereal u[3], x[4]	/* was [2][2] */;
    integer j2, j3, j4;
    doublereal u1[3], u2[3];
    integer nd;
    doublereal cs, t11, t22, t33, sn, wi1, wi2, wr1, wr2, eps, tau, tau1, 
	    tau2;
    integer ierr;
    doublereal temp;
    extern /* Subroutine */ int igraphdrot_(integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *);
    doublereal scale, dnorm, xnorm;
    extern /* Subroutine */ int igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlasy2_(
	    logical *, logical *, integer *, integer *, integer *, doublereal 
	    *, integer *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *);
    extern doublereal igraphdlamch_(char *), igraphdlange_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *);
    extern /* Subroutine */ int igraphdlarfg_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *), igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphdlartg_(doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *), igraphdlarfx_(char *, integer *, integer *, doublereal *,
	     doublereal *, doublereal *, integer *, doublereal *);
    doublereal thresh, smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;
    --work;

    /* Function Body */
    *info = 0;

/*     Quick return if possible */

    if (*n == 0 || *n1 == 0 || *n2 == 0) {
	return 0;
    }
    if (*j1 + *n1 > *n) {
	return 0;
    }

    j2 = *j1 + 1;
    j3 = *j1 + 2;
    j4 = *j1 + 3;

    if (*n1 == 1 && *n2 == 1) {

/*        Swap two 1-by-1 blocks. */

	t11 = t[*j1 + *j1 * t_dim1];
	t22 = t[j2 + j2 * t_dim1];

/*        Determine the transformation to perform the interchange. */

	d__1 = t22 - t11;
	igraphdlartg_(&t[*j1 + j2 * t_dim1], &d__1, &cs, &sn, &temp);

/*        Apply transformation to the matrix T. */

	if (j3 <= *n) {
	    i__1 = *n - *j1 - 1;
	    igraphdrot_(&i__1, &t[*j1 + j3 * t_dim1], ldt, &t[j2 + j3 * t_dim1], 
		    ldt, &cs, &sn);
	}
	i__1 = *j1 - 1;
	igraphdrot_(&i__1, &t[*j1 * t_dim1 + 1], &c__1, &t[j2 * t_dim1 + 1], &c__1, 
		&cs, &sn);

	t[*j1 + *j1 * t_dim1] = t22;
	t[j2 + j2 * t_dim1] = t11;

	if (*wantq) {

/*           Accumulate transformation in the matrix Q. */

	    igraphdrot_(n, &q[*j1 * q_dim1 + 1], &c__1, &q[j2 * q_dim1 + 1], &c__1, 
		    &cs, &sn);
	}

    } else {

/*        Swapping involves at least one 2-by-2 block.   

          Copy the diagonal block of order N1+N2 to the local array D   
          and compute its norm. */

	nd = *n1 + *n2;
	igraphdlacpy_("Full", &nd, &nd, &t[*j1 + *j1 * t_dim1], ldt, d__, &c__4);
	dnorm = igraphdlange_("Max", &nd, &nd, d__, &c__4, &work[1]);

/*        Compute machine-dependent threshold for test for accepting   
          swap. */

	eps = igraphdlamch_("P");
	smlnum = igraphdlamch_("S") / eps;
/* Computing MAX */
	d__1 = eps * 10. * dnorm;
	thresh = max(d__1,smlnum);

/*        Solve T11*X - X*T22 = scale*T12 for X. */

	igraphdlasy2_(&c_false, &c_false, &c_n1, n1, n2, d__, &c__4, &d__[*n1 + 1 + 
		(*n1 + 1 << 2) - 5], &c__4, &d__[(*n1 + 1 << 2) - 4], &c__4, &
		scale, x, &c__2, &xnorm, &ierr);

/*        Swap the adjacent diagonal blocks. */

	k = *n1 + *n1 + *n2 - 3;
	switch (k) {
	    case 1:  goto L10;
	    case 2:  goto L20;
	    case 3:  goto L30;
	}

L10:

/*        N1 = 1, N2 = 2: generate elementary reflector H so that:   

          ( scale, X11, X12 ) H = ( 0, 0, * ) */

	u[0] = scale;
	u[1] = x[0];
	u[2] = x[2];
	igraphdlarfg_(&c__3, &u[2], u, &c__1, &tau);
	u[2] = 1.;
	t11 = t[*j1 + *j1 * t_dim1];

/*        Perform swap provisionally on diagonal block in D. */

	igraphdlarfx_("L", &c__3, &c__3, u, &tau, d__, &c__4, &work[1]);
	igraphdlarfx_("R", &c__3, &c__3, u, &tau, d__, &c__4, &work[1]);

/*        Test whether to reject swap.   

   Computing MAX */
	d__2 = abs(d__[2]), d__3 = abs(d__[6]), d__2 = max(d__2,d__3), d__3 = 
		(d__1 = d__[10] - t11, abs(d__1));
	if (max(d__2,d__3) > thresh) {
	    goto L50;
	}

/*        Accept swap: apply transformation to the entire matrix T. */

	i__1 = *n - *j1 + 1;
	igraphdlarfx_("L", &c__3, &i__1, u, &tau, &t[*j1 + *j1 * t_dim1], ldt, &
		work[1]);
	igraphdlarfx_("R", &j2, &c__3, u, &tau, &t[*j1 * t_dim1 + 1], ldt, &work[1]);

	t[j3 + *j1 * t_dim1] = 0.;
	t[j3 + j2 * t_dim1] = 0.;
	t[j3 + j3 * t_dim1] = t11;

	if (*wantq) {

/*           Accumulate transformation in the matrix Q. */

	    igraphdlarfx_("R", n, &c__3, u, &tau, &q[*j1 * q_dim1 + 1], ldq, &work[
		    1]);
	}
	goto L40;

L20:

/*        N1 = 2, N2 = 1: generate elementary reflector H so that:   

          H (  -X11 ) = ( * )   
            (  -X21 ) = ( 0 )   
            ( scale ) = ( 0 ) */

	u[0] = -x[0];
	u[1] = -x[1];
	u[2] = scale;
	igraphdlarfg_(&c__3, u, &u[1], &c__1, &tau);
	u[0] = 1.;
	t33 = t[j3 + j3 * t_dim1];

/*        Perform swap provisionally on diagonal block in D. */

	igraphdlarfx_("L", &c__3, &c__3, u, &tau, d__, &c__4, &work[1]);
	igraphdlarfx_("R", &c__3, &c__3, u, &tau, d__, &c__4, &work[1]);

/*        Test whether to reject swap.   

   Computing MAX */
	d__2 = abs(d__[1]), d__3 = abs(d__[2]), d__2 = max(d__2,d__3), d__3 = 
		(d__1 = d__[0] - t33, abs(d__1));
	if (max(d__2,d__3) > thresh) {
	    goto L50;
	}

/*        Accept swap: apply transformation to the entire matrix T. */

	igraphdlarfx_("R", &j3, &c__3, u, &tau, &t[*j1 * t_dim1 + 1], ldt, &work[1]);
	i__1 = *n - *j1;
	igraphdlarfx_("L", &c__3, &i__1, u, &tau, &t[*j1 + j2 * t_dim1], ldt, &work[
		1]);

	t[*j1 + *j1 * t_dim1] = t33;
	t[j2 + *j1 * t_dim1] = 0.;
	t[j3 + *j1 * t_dim1] = 0.;

	if (*wantq) {

/*           Accumulate transformation in the matrix Q. */

	    igraphdlarfx_("R", n, &c__3, u, &tau, &q[*j1 * q_dim1 + 1], ldq, &work[
		    1]);
	}
	goto L40;

L30:

/*        N1 = 2, N2 = 2: generate elementary reflectors H(1) and H(2) so   
          that:   

          H(2) H(1) (  -X11  -X12 ) = (  *  * )   
                    (  -X21  -X22 )   (  0  * )   
                    ( scale    0  )   (  0  0 )   
                    (    0  scale )   (  0  0 ) */

	u1[0] = -x[0];
	u1[1] = -x[1];
	u1[2] = scale;
	igraphdlarfg_(&c__3, u1, &u1[1], &c__1, &tau1);
	u1[0] = 1.;

	temp = -tau1 * (x[2] + u1[1] * x[3]);
	u2[0] = -temp * u1[1] - x[3];
	u2[1] = -temp * u1[2];
	u2[2] = scale;
	igraphdlarfg_(&c__3, u2, &u2[1], &c__1, &tau2);
	u2[0] = 1.;

/*        Perform swap provisionally on diagonal block in D. */

	igraphdlarfx_("L", &c__3, &c__4, u1, &tau1, d__, &c__4, &work[1])
		;
	igraphdlarfx_("R", &c__4, &c__3, u1, &tau1, d__, &c__4, &work[1])
		;
	igraphdlarfx_("L", &c__3, &c__4, u2, &tau2, &d__[1], &c__4, &work[1]);
	igraphdlarfx_("R", &c__4, &c__3, u2, &tau2, &d__[4], &c__4, &work[1]);

/*        Test whether to reject swap.   

   Computing MAX */
	d__1 = abs(d__[2]), d__2 = abs(d__[6]), d__1 = max(d__1,d__2), d__2 = 
		abs(d__[3]), d__1 = max(d__1,d__2), d__2 = abs(d__[7]);
	if (max(d__1,d__2) > thresh) {
	    goto L50;
	}

/*        Accept swap: apply transformation to the entire matrix T. */

	i__1 = *n - *j1 + 1;
	igraphdlarfx_("L", &c__3, &i__1, u1, &tau1, &t[*j1 + *j1 * t_dim1], ldt, &
		work[1]);
	igraphdlarfx_("R", &j4, &c__3, u1, &tau1, &t[*j1 * t_dim1 + 1], ldt, &work[
		1]);
	i__1 = *n - *j1 + 1;
	igraphdlarfx_("L", &c__3, &i__1, u2, &tau2, &t[j2 + *j1 * t_dim1], ldt, &
		work[1]);
	igraphdlarfx_("R", &j4, &c__3, u2, &tau2, &t[j2 * t_dim1 + 1], ldt, &work[1]
		);

	t[j3 + *j1 * t_dim1] = 0.;
	t[j3 + j2 * t_dim1] = 0.;
	t[j4 + *j1 * t_dim1] = 0.;
	t[j4 + j2 * t_dim1] = 0.;

	if (*wantq) {

/*           Accumulate transformation in the matrix Q. */

	    igraphdlarfx_("R", n, &c__3, u1, &tau1, &q[*j1 * q_dim1 + 1], ldq, &
		    work[1]);
	    igraphdlarfx_("R", n, &c__3, u2, &tau2, &q[j2 * q_dim1 + 1], ldq, &work[
		    1]);
	}

L40:

	if (*n2 == 2) {

/*           Standardize new 2-by-2 block T11 */

	    igraphdlanv2_(&t[*j1 + *j1 * t_dim1], &t[*j1 + j2 * t_dim1], &t[j2 + *
		    j1 * t_dim1], &t[j2 + j2 * t_dim1], &wr1, &wi1, &wr2, &
		    wi2, &cs, &sn);
	    i__1 = *n - *j1 - 1;
	    igraphdrot_(&i__1, &t[*j1 + (*j1 + 2) * t_dim1], ldt, &t[j2 + (*j1 + 2) 
		    * t_dim1], ldt, &cs, &sn);
	    i__1 = *j1 - 1;
	    igraphdrot_(&i__1, &t[*j1 * t_dim1 + 1], &c__1, &t[j2 * t_dim1 + 1], &
		    c__1, &cs, &sn);
	    if (*wantq) {
		igraphdrot_(n, &q[*j1 * q_dim1 + 1], &c__1, &q[j2 * q_dim1 + 1], &
			c__1, &cs, &sn);
	    }
	}

	if (*n1 == 2) {

/*           Standardize new 2-by-2 block T22 */

	    j3 = *j1 + *n2;
	    j4 = j3 + 1;
	    igraphdlanv2_(&t[j3 + j3 * t_dim1], &t[j3 + j4 * t_dim1], &t[j4 + j3 * 
		    t_dim1], &t[j4 + j4 * t_dim1], &wr1, &wi1, &wr2, &wi2, &
		    cs, &sn);
	    if (j3 + 2 <= *n) {
		i__1 = *n - j3 - 1;
		igraphdrot_(&i__1, &t[j3 + (j3 + 2) * t_dim1], ldt, &t[j4 + (j3 + 2)
			 * t_dim1], ldt, &cs, &sn);
	    }
	    i__1 = j3 - 1;
	    igraphdrot_(&i__1, &t[j3 * t_dim1 + 1], &c__1, &t[j4 * t_dim1 + 1], &
		    c__1, &cs, &sn);
	    if (*wantq) {
		igraphdrot_(n, &q[j3 * q_dim1 + 1], &c__1, &q[j4 * q_dim1 + 1], &
			c__1, &cs, &sn);
	    }
	}

    }
    return 0;

/*     Exit with INFO = 1 if swap was rejected. */

L50:
    *info = 1;
    return 0;

/*     End of DLAEXC */

} /* igraphdlaexc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlagtf.c0000644000175100001710000002073400000000000024015 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAGTF computes an LU factorization of a matrix T-λI, where T is a general tridiagonal matrix,
 and λ a scalar, using partial pivoting with row interchanges.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAGTF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAGTF( N, A, LAMBDA, B, C, TOL, D, IN, INFO )   

         INTEGER            INFO, N   
         DOUBLE PRECISION   LAMBDA, TOL   
         INTEGER            IN( * )   
         DOUBLE PRECISION   A( * ), B( * ), C( * ), D( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAGTF factorizes the matrix (T - lambda*I), where T is an n by n   
   > tridiagonal matrix and lambda is a scalar, as   
   >   
   >    T - lambda*I = PLU,   
   >   
   > where P is a permutation matrix, L is a unit lower tridiagonal matrix   
   > with at most one non-zero sub-diagonal elements per column and U is   
   > an upper triangular matrix with at most two non-zero super-diagonal   
   > elements per column.   
   >   
   > The factorization is obtained by Gaussian elimination with partial   
   > pivoting and implicit row scaling.   
   >   
   > The parameter LAMBDA is included in the routine so that DLAGTF may   
   > be used, in conjunction with DLAGTS, to obtain eigenvectors of T by   
   > inverse iteration.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (N)   
   >          On entry, A must contain the diagonal elements of T.   
   >   
   >          On exit, A is overwritten by the n diagonal elements of the   
   >          upper triangular matrix U of the factorization of T.   
   > \endverbatim   
   >   
   > \param[in] LAMBDA   
   > \verbatim   
   >          LAMBDA is DOUBLE PRECISION   
   >          On entry, the scalar lambda.   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, B must contain the (n-1) super-diagonal elements of   
   >          T.   
   >   
   >          On exit, B is overwritten by the (n-1) super-diagonal   
   >          elements of the matrix U of the factorization of T.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, C must contain the (n-1) sub-diagonal elements of   
   >          T.   
   >   
   >          On exit, C is overwritten by the (n-1) sub-diagonal elements   
   >          of the matrix L of the factorization of T.   
   > \endverbatim   
   >   
   > \param[in] TOL   
   > \verbatim   
   >          TOL is DOUBLE PRECISION   
   >          On entry, a relative tolerance used to indicate whether or   
   >          not the matrix (T - lambda*I) is nearly singular. TOL should   
   >          normally be chose as approximately the largest relative error   
   >          in the elements of T. For example, if the elements of T are   
   >          correct to about 4 significant figures, then TOL should be   
   >          set to about 5*10**(-4). If TOL is supplied as less than eps,   
   >          where eps is the relative machine precision, then the value   
   >          eps is used in place of TOL.   
   > \endverbatim   
   >   
   > \param[out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N-2)   
   >          On exit, D is overwritten by the (n-2) second super-diagonal   
   >          elements of the matrix U of the factorization of T.   
   > \endverbatim   
   >   
   > \param[out] IN   
   > \verbatim   
   >          IN is INTEGER array, dimension (N)   
   >          On exit, IN contains details of the permutation matrix P. If   
   >          an interchange occurred at the kth step of the elimination,   
   >          then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)   
   >          returns the smallest positive integer j such that   
   >   
   >             abs( u(j,j) ).le. norm( (T - lambda*I)(j) )*TOL,   
   >   
   >          where norm( A(j) ) denotes the sum of the absolute values of   
   >          the jth row of the matrix A. If no such j exists then IN(n)   
   >          is returned as zero. If IN(n) is returned as positive, then a   
   >          diagonal element of U is small, indicating that   
   >          (T - lambda*I) is singular or nearly singular,   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0   : successful exit   
   >          .lt. 0: if INFO = -k, the kth argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdlagtf_(integer *n, doublereal *a, doublereal *lambda, 
	doublereal *b, doublereal *c__, doublereal *tol, doublereal *d__, 
	integer *in, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Local variables */
    integer k;
    doublereal tl, eps, piv1, piv2, temp, mult, scale1, scale2;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    --in;
    --d__;
    --c__;
    --b;
    --a;

    /* Function Body */
    *info = 0;
    if (*n < 0) {
	*info = -1;
	i__1 = -(*info);
	igraphxerbla_("DLAGTF", &i__1, (ftnlen)6);
	return 0;
    }

    if (*n == 0) {
	return 0;
    }

    a[1] -= *lambda;
    in[*n] = 0;
    if (*n == 1) {
	if (a[1] == 0.) {
	    in[1] = 1;
	}
	return 0;
    }

    eps = igraphdlamch_("Epsilon");

    tl = max(*tol,eps);
    scale1 = abs(a[1]) + abs(b[1]);
    i__1 = *n - 1;
    for (k = 1; k <= i__1; ++k) {
	a[k + 1] -= *lambda;
	scale2 = (d__1 = c__[k], abs(d__1)) + (d__2 = a[k + 1], abs(d__2));
	if (k < *n - 1) {
	    scale2 += (d__1 = b[k + 1], abs(d__1));
	}
	if (a[k] == 0.) {
	    piv1 = 0.;
	} else {
	    piv1 = (d__1 = a[k], abs(d__1)) / scale1;
	}
	if (c__[k] == 0.) {
	    in[k] = 0;
	    piv2 = 0.;
	    scale1 = scale2;
	    if (k < *n - 1) {
		d__[k] = 0.;
	    }
	} else {
	    piv2 = (d__1 = c__[k], abs(d__1)) / scale2;
	    if (piv2 <= piv1) {
		in[k] = 0;
		scale1 = scale2;
		c__[k] /= a[k];
		a[k + 1] -= c__[k] * b[k];
		if (k < *n - 1) {
		    d__[k] = 0.;
		}
	    } else {
		in[k] = 1;
		mult = a[k] / c__[k];
		a[k] = c__[k];
		temp = a[k + 1];
		a[k + 1] = b[k] - mult * temp;
		if (k < *n - 1) {
		    d__[k] = b[k + 1];
		    b[k + 1] = -mult * d__[k];
		}
		b[k] = temp;
		c__[k] = mult;
	    }
	}
	if (max(piv1,piv2) <= tl && in[*n] == 0) {
	    in[*n] = k;
	}
/* L10: */
    }
    if ((d__1 = a[*n], abs(d__1)) <= scale1 * tl && in[*n] == 0) {
	in[*n] = *n;
    }

    return 0;

/*     End of DLAGTF */

} /* igraphdlagtf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlagts.c0000644000175100001710000002655700000000000024043 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAGTS solves the system of equations (T-λI)x = y or (T-λI)Tx = y,where T is a general tridia
gonal matrix and λ a scalar, using the LU factorization computed by slagtf.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAGTS + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAGTS( JOB, N, A, B, C, D, IN, Y, TOL, INFO )   

         INTEGER            INFO, JOB, N   
         DOUBLE PRECISION   TOL   
         INTEGER            IN( * )   
         DOUBLE PRECISION   A( * ), B( * ), C( * ), D( * ), Y( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAGTS may be used to solve one of the systems of equations   
   >   
   >    (T - lambda*I)*x = y   or   (T - lambda*I)**T*x = y,   
   >   
   > where T is an n by n tridiagonal matrix, for x, following the   
   > factorization of (T - lambda*I) as   
   >   
   >    (T - lambda*I) = P*L*U ,   
   >   
   > by routine DLAGTF. The choice of equation to be solved is   
   > controlled by the argument JOB, and in each case there is an option   
   > to perturb zero or very small diagonal elements of U, this option   
   > being intended for use in applications such as inverse iteration.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is INTEGER   
   >          Specifies the job to be performed by DLAGTS as follows:   
   >          =  1: The equations  (T - lambda*I)x = y  are to be solved,   
   >                but diagonal elements of U are not to be perturbed.   
   >          = -1: The equations  (T - lambda*I)x = y  are to be solved   
   >                and, if overflow would otherwise occur, the diagonal   
   >                elements of U are to be perturbed. See argument TOL   
   >                below.   
   >          =  2: The equations  (T - lambda*I)**Tx = y  are to be solved,   
   >                but diagonal elements of U are not to be perturbed.   
   >          = -2: The equations  (T - lambda*I)**Tx = y  are to be solved   
   >                and, if overflow would otherwise occur, the diagonal   
   >                elements of U are to be perturbed. See argument TOL   
   >                below.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (N)   
   >          On entry, A must contain the diagonal elements of U as   
   >          returned from DLAGTF.   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, B must contain the first super-diagonal elements of   
   >          U as returned from DLAGTF.   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, C must contain the sub-diagonal elements of L as   
   >          returned from DLAGTF.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N-2)   
   >          On entry, D must contain the second super-diagonal elements   
   >          of U as returned from DLAGTF.   
   > \endverbatim   
   >   
   > \param[in] IN   
   > \verbatim   
   >          IN is INTEGER array, dimension (N)   
   >          On entry, IN must contain details of the matrix P as returned   
   >          from DLAGTF.   
   > \endverbatim   
   >   
   > \param[in,out] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the right hand side vector y.   
   >          On exit, Y is overwritten by the solution vector x.   
   > \endverbatim   
   >   
   > \param[in,out] TOL   
   > \verbatim   
   >          TOL is DOUBLE PRECISION   
   >          On entry, with  JOB .lt. 0, TOL should be the minimum   
   >          perturbation to be made to very small diagonal elements of U.   
   >          TOL should normally be chosen as about eps*norm(U), where eps   
   >          is the relative machine precision, but if TOL is supplied as   
   >          non-positive, then it is reset to eps*max( abs( u(i,j) ) ).   
   >          If  JOB .gt. 0  then TOL is not referenced.   
   >   
   >          On exit, TOL is changed as described above, only if TOL is   
   >          non-positive on entry. Otherwise TOL is unchanged.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0   : successful exit   
   >          .lt. 0: if INFO = -i, the i-th argument had an illegal value   
   >          .gt. 0: overflow would occur when computing the INFO(th)   
   >                  element of the solution vector x. This can only occur   
   >                  when JOB is supplied as positive and either means   
   >                  that a diagonal element of U is very small, or that   
   >                  the elements of the right-hand side vector y are very   
   >                  large.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlagts_(integer *job, integer *n, doublereal *a, 
	doublereal *b, doublereal *c__, doublereal *d__, integer *in, 
	doublereal *y, doublereal *tol, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2, d__3, d__4, d__5;

    /* Builtin functions */
    double d_sign(doublereal *, doublereal *);

    /* Local variables */
    integer k;
    doublereal ak, eps, temp, pert, absak, sfmin;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --y;
    --in;
    --d__;
    --c__;
    --b;
    --a;

    /* Function Body */
    *info = 0;
    if (abs(*job) > 2 || *job == 0) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DLAGTS", &i__1, (ftnlen)6);
	return 0;
    }

    if (*n == 0) {
	return 0;
    }

    eps = igraphdlamch_("Epsilon");
    sfmin = igraphdlamch_("Safe minimum");
    bignum = 1. / sfmin;

    if (*job < 0) {
	if (*tol <= 0.) {
	    *tol = abs(a[1]);
	    if (*n > 1) {
/* Computing MAX */
		d__1 = *tol, d__2 = abs(a[2]), d__1 = max(d__1,d__2), d__2 = 
			abs(b[1]);
		*tol = max(d__1,d__2);
	    }
	    i__1 = *n;
	    for (k = 3; k <= i__1; ++k) {
/* Computing MAX */
		d__4 = *tol, d__5 = (d__1 = a[k], abs(d__1)), d__4 = max(d__4,
			d__5), d__5 = (d__2 = b[k - 1], abs(d__2)), d__4 = 
			max(d__4,d__5), d__5 = (d__3 = d__[k - 2], abs(d__3));
		*tol = max(d__4,d__5);
/* L10: */
	    }
	    *tol *= eps;
	    if (*tol == 0.) {
		*tol = eps;
	    }
	}
    }

    if (abs(*job) == 1) {
	i__1 = *n;
	for (k = 2; k <= i__1; ++k) {
	    if (in[k - 1] == 0) {
		y[k] -= c__[k - 1] * y[k - 1];
	    } else {
		temp = y[k - 1];
		y[k - 1] = y[k];
		y[k] = temp - c__[k - 1] * y[k];
	    }
/* L20: */
	}
	if (*job == 1) {
	    for (k = *n; k >= 1; --k) {
		if (k <= *n - 2) {
		    temp = y[k] - b[k] * y[k + 1] - d__[k] * y[k + 2];
		} else if (k == *n - 1) {
		    temp = y[k] - b[k] * y[k + 1];
		} else {
		    temp = y[k];
		}
		ak = a[k];
		absak = abs(ak);
		if (absak < 1.) {
		    if (absak < sfmin) {
			if (absak == 0. || abs(temp) * sfmin > absak) {
			    *info = k;
			    return 0;
			} else {
			    temp *= bignum;
			    ak *= bignum;
			}
		    } else if (abs(temp) > absak * bignum) {
			*info = k;
			return 0;
		    }
		}
		y[k] = temp / ak;
/* L30: */
	    }
	} else {
	    for (k = *n; k >= 1; --k) {
		if (k <= *n - 2) {
		    temp = y[k] - b[k] * y[k + 1] - d__[k] * y[k + 2];
		} else if (k == *n - 1) {
		    temp = y[k] - b[k] * y[k + 1];
		} else {
		    temp = y[k];
		}
		ak = a[k];
		pert = d_sign(tol, &ak);
L40:
		absak = abs(ak);
		if (absak < 1.) {
		    if (absak < sfmin) {
			if (absak == 0. || abs(temp) * sfmin > absak) {
			    ak += pert;
			    pert *= 2;
			    goto L40;
			} else {
			    temp *= bignum;
			    ak *= bignum;
			}
		    } else if (abs(temp) > absak * bignum) {
			ak += pert;
			pert *= 2;
			goto L40;
		    }
		}
		y[k] = temp / ak;
/* L50: */
	    }
	}
    } else {

/*        Come to here if  JOB = 2 or -2 */

	if (*job == 2) {
	    i__1 = *n;
	    for (k = 1; k <= i__1; ++k) {
		if (k >= 3) {
		    temp = y[k] - b[k - 1] * y[k - 1] - d__[k - 2] * y[k - 2];
		} else if (k == 2) {
		    temp = y[k] - b[k - 1] * y[k - 1];
		} else {
		    temp = y[k];
		}
		ak = a[k];
		absak = abs(ak);
		if (absak < 1.) {
		    if (absak < sfmin) {
			if (absak == 0. || abs(temp) * sfmin > absak) {
			    *info = k;
			    return 0;
			} else {
			    temp *= bignum;
			    ak *= bignum;
			}
		    } else if (abs(temp) > absak * bignum) {
			*info = k;
			return 0;
		    }
		}
		y[k] = temp / ak;
/* L60: */
	    }
	} else {
	    i__1 = *n;
	    for (k = 1; k <= i__1; ++k) {
		if (k >= 3) {
		    temp = y[k] - b[k - 1] * y[k - 1] - d__[k - 2] * y[k - 2];
		} else if (k == 2) {
		    temp = y[k] - b[k - 1] * y[k - 1];
		} else {
		    temp = y[k];
		}
		ak = a[k];
		pert = d_sign(tol, &ak);
L70:
		absak = abs(ak);
		if (absak < 1.) {
		    if (absak < sfmin) {
			if (absak == 0. || abs(temp) * sfmin > absak) {
			    ak += pert;
			    pert *= 2;
			    goto L70;
			} else {
			    temp *= bignum;
			    ak *= bignum;
			}
		    } else if (abs(temp) > absak * bignum) {
			ak += pert;
			pert *= 2;
			goto L70;
		    }
		}
		y[k] = temp / ak;
/* L80: */
	    }
	}

	for (k = *n; k >= 2; --k) {
	    if (in[k - 1] == 0) {
		y[k - 1] -= c__[k - 1] * y[k];
	    } else {
		temp = y[k - 1];
		y[k - 1] = y[k];
		y[k] = temp - c__[k - 1] * y[k];
	    }
/* L90: */
	}
    }

/*     End of DLAGTS */

    return 0;
} /* igraphdlagts_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlahqr.c0000644000175100001710000005332000000000000024024 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLAHQR computes the eigenvalues and Schur factorization of an upper Hessenberg matrix, using th
e double-shift/single-shift QR algorithm.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAHQR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAHQR( WANTT, WANTZ, N, ILO, IHI, H, LDH, WR, WI,   
                            ILOZ, IHIZ, Z, LDZ, INFO )   

         INTEGER            IHI, IHIZ, ILO, ILOZ, INFO, LDH, LDZ, N   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), WI( * ), WR( * ), Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DLAHQR is an auxiliary routine called by DHSEQR to update the   
   >    eigenvalues and Schur decomposition already computed by DHSEQR, by   
   >    dealing with the Hessenberg submatrix in rows and columns ILO to   
   >    IHI.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is LOGICAL   
   >          = .TRUE. : the full Schur form T is required;   
   >          = .FALSE.: only eigenvalues are required.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is LOGICAL   
   >          = .TRUE. : the matrix of Schur vectors Z is required;   
   >          = .FALSE.: Schur vectors are not required.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix H.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >          It is assumed that H is already upper quasi-triangular in   
   >          rows and columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless   
   >          ILO = 1). DLAHQR works primarily with the Hessenberg   
   >          submatrix in rows and columns ILO to IHI, but applies   
   >          transformations to all of H if WANTT is .TRUE..   
   >          1 <= ILO <= max(1,IHI); IHI <= N.   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >          On entry, the upper Hessenberg matrix H.   
   >          On exit, if INFO is zero and if WANTT is .TRUE., H is upper   
   >          quasi-triangular in rows and columns ILO:IHI, with any   
   >          2-by-2 diagonal blocks in standard form. If INFO is zero   
   >          and WANTT is .FALSE., the contents of H are unspecified on   
   >          exit.  The output state of H if INFO is nonzero is given   
   >          below under the description of INFO.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is INTEGER   
   >          The leading dimension of the array H. LDH >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (N)   
   >          The real and imaginary parts, respectively, of the computed   
   >          eigenvalues ILO to IHI are stored in the corresponding   
   >          elements of WR and WI. If two eigenvalues are computed as a   
   >          complex conjugate pair, they are stored in consecutive   
   >          elements of WR and WI, say the i-th and (i+1)th, with   
   >          WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., the   
   >          eigenvalues are stored in the same order as on the diagonal   
   >          of the Schur form returned in H, with WR(i) = H(i,i), and, if   
   >          H(i:i+1,i:i+1) is a 2-by-2 diagonal block,   
   >          WI(i) = sqrt(H(i+1,i)*H(i,i+1)) and WI(i+1) = -WI(i).   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >          Specify the rows of Z to which transformations must be   
   >          applied if WANTZ is .TRUE..   
   >          1 <= ILOZ <= ILO; IHI <= IHIZ <= N.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,N)   
   >          If WANTZ is .TRUE., on entry Z must contain the current   
   >          matrix Z of transformations accumulated by DHSEQR, and on   
   >          exit Z has been updated; transformations are applied only to   
   >          the submatrix Z(ILOZ:IHIZ,ILO:IHI).   
   >          If WANTZ is .FALSE., Z is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z. LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >           =   0: successful exit   
   >          .GT. 0: If INFO = i, DLAHQR failed to compute all the   
   >                  eigenvalues ILO to IHI in a total of 30 iterations   
   >                  per eigenvalue; elements i+1:ihi of WR and WI   
   >                  contain those eigenvalues which have been   
   >                  successfully computed.   
   >   
   >                  If INFO .GT. 0 and WANTT is .FALSE., then on exit,   
   >                  the remaining unconverged eigenvalues are the   
   >                  eigenvalues of the upper Hessenberg matrix rows   
   >                  and columns ILO thorugh INFO of the final, output   
   >                  value of H.   
   >   
   >                  If INFO .GT. 0 and WANTT is .TRUE., then on exit   
   >          (*)       (initial value of H)*U  = U*(final value of H)   
   >                  where U is an orthognal matrix.    The final   
   >                  value of H is upper Hessenberg and triangular in   
   >                  rows and columns INFO+1 through IHI.   
   >   
   >                  If INFO .GT. 0 and WANTZ is .TRUE., then on exit   
   >                      (final value of Z)  = (initial value of Z)*U   
   >                  where U is the orthogonal matrix in (*)   
   >                  (regardless of the value of WANTT.)   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     02-96 Based on modifications by   
   >     David Day, Sandia National Laboratory, USA   
   >   
   >     12-04 Further modifications by   
   >     Ralph Byers, University of Kansas, USA   
   >     This is a modified version of DLAHQR from LAPACK version 3.0.   
   >     It is (1) more robust against overflow and underflow and   
   >     (2) adopts the more conservative Ahues & Tisseur stopping   
   >     criterion (LAWN 122, 1997).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlahqr_(logical *wantt, logical *wantz, integer *n, 
	integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
	*wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
	integer *ldz, integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, z_dim1, z_offset, i__1, i__2, i__3;
    doublereal d__1, d__2, d__3, d__4;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, k, l, m;
    doublereal s, v[3];
    integer i1, i2;
    doublereal t1, t2, t3, v2, v3, aa, ab, ba, bb, h11, h12, h21, h22, cs;
    integer nh;
    doublereal sn;
    integer nr;
    doublereal tr;
    integer nz;
    doublereal det, h21s;
    integer its;
    doublereal ulp, sum, tst, rt1i, rt2i, rt1r, rt2r;
    extern /* Subroutine */ int igraphdrot_(integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *), igraphdcopy_(
	    integer *, doublereal *, integer *, doublereal *, integer *), 
	    igraphdlanv2_(doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *), igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlarfg_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *);
    doublereal safmin, safmax, rtdisc, smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =========================================================   


       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --wr;
    --wi;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;

    /* Function Body */
    *info = 0;

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }
    if (*ilo == *ihi) {
	wr[*ilo] = h__[*ilo + *ilo * h_dim1];
	wi[*ilo] = 0.;
	return 0;
    }

/*     ==== clear out the trash ==== */
    i__1 = *ihi - 3;
    for (j = *ilo; j <= i__1; ++j) {
	h__[j + 2 + j * h_dim1] = 0.;
	h__[j + 3 + j * h_dim1] = 0.;
/* L10: */
    }
    if (*ilo <= *ihi - 2) {
	h__[*ihi + (*ihi - 2) * h_dim1] = 0.;
    }

    nh = *ihi - *ilo + 1;
    nz = *ihiz - *iloz + 1;

/*     Set machine-dependent constants for the stopping criterion. */

    safmin = igraphdlamch_("SAFE MINIMUM");
    safmax = 1. / safmin;
    igraphdlabad_(&safmin, &safmax);
    ulp = igraphdlamch_("PRECISION");
    smlnum = safmin * ((doublereal) nh / ulp);

/*     I1 and I2 are the indices of the first row and last column of H   
       to which transformations must be applied. If eigenvalues only are   
       being computed, I1 and I2 are set inside the main loop. */

    if (*wantt) {
	i1 = 1;
	i2 = *n;
    }

/*     The main loop begins here. I is the loop index and decreases from   
       IHI to ILO in steps of 1 or 2. Each iteration of the loop works   
       with the active submatrix in rows and columns L to I.   
       Eigenvalues I+1 to IHI have already converged. Either L = ILO or   
       H(L,L-1) is negligible so that the matrix splits. */

    i__ = *ihi;
L20:
    l = *ilo;
    if (i__ < *ilo) {
	goto L160;
    }

/*     Perform QR iterations on rows and columns ILO to I until a   
       submatrix of order 1 or 2 splits off at the bottom because a   
       subdiagonal element has become negligible. */

    for (its = 0; its <= 30; ++its) {

/*        Look for a single small subdiagonal element. */

	i__1 = l + 1;
	for (k = i__; k >= i__1; --k) {
	    if ((d__1 = h__[k + (k - 1) * h_dim1], abs(d__1)) <= smlnum) {
		goto L40;
	    }
	    tst = (d__1 = h__[k - 1 + (k - 1) * h_dim1], abs(d__1)) + (d__2 = 
		    h__[k + k * h_dim1], abs(d__2));
	    if (tst == 0.) {
		if (k - 2 >= *ilo) {
		    tst += (d__1 = h__[k - 1 + (k - 2) * h_dim1], abs(d__1));
		}
		if (k + 1 <= *ihi) {
		    tst += (d__1 = h__[k + 1 + k * h_dim1], abs(d__1));
		}
	    }
/*           ==== The following is a conservative small subdiagonal   
             .    deflation  criterion due to Ahues & Tisseur (LAWN 122,   
             .    1997). It has better mathematical foundation and   
             .    improves accuracy in some cases.  ==== */
	    if ((d__1 = h__[k + (k - 1) * h_dim1], abs(d__1)) <= ulp * tst) {
/* Computing MAX */
		d__3 = (d__1 = h__[k + (k - 1) * h_dim1], abs(d__1)), d__4 = (
			d__2 = h__[k - 1 + k * h_dim1], abs(d__2));
		ab = max(d__3,d__4);
/* Computing MIN */
		d__3 = (d__1 = h__[k + (k - 1) * h_dim1], abs(d__1)), d__4 = (
			d__2 = h__[k - 1 + k * h_dim1], abs(d__2));
		ba = min(d__3,d__4);
/* Computing MAX */
		d__3 = (d__1 = h__[k + k * h_dim1], abs(d__1)), d__4 = (d__2 =
			 h__[k - 1 + (k - 1) * h_dim1] - h__[k + k * h_dim1], 
			abs(d__2));
		aa = max(d__3,d__4);
/* Computing MIN */
		d__3 = (d__1 = h__[k + k * h_dim1], abs(d__1)), d__4 = (d__2 =
			 h__[k - 1 + (k - 1) * h_dim1] - h__[k + k * h_dim1], 
			abs(d__2));
		bb = min(d__3,d__4);
		s = aa + ab;
/* Computing MAX */
		d__1 = smlnum, d__2 = ulp * (bb * (aa / s));
		if (ba * (ab / s) <= max(d__1,d__2)) {
		    goto L40;
		}
	    }
/* L30: */
	}
L40:
	l = k;
	if (l > *ilo) {

/*           H(L,L-1) is negligible */

	    h__[l + (l - 1) * h_dim1] = 0.;
	}

/*        Exit from loop if a submatrix of order 1 or 2 has split off. */

	if (l >= i__ - 1) {
	    goto L150;
	}

/*        Now the active submatrix is in rows and columns L to I. If   
          eigenvalues only are being computed, only the active submatrix   
          need be transformed. */

	if (! (*wantt)) {
	    i1 = l;
	    i2 = i__;
	}

	if (its == 10) {

/*           Exceptional shift. */

	    s = (d__1 = h__[l + 1 + l * h_dim1], abs(d__1)) + (d__2 = h__[l + 
		    2 + (l + 1) * h_dim1], abs(d__2));
	    h11 = s * .75 + h__[l + l * h_dim1];
	    h12 = s * -.4375;
	    h21 = s;
	    h22 = h11;
	} else if (its == 20) {

/*           Exceptional shift. */

	    s = (d__1 = h__[i__ + (i__ - 1) * h_dim1], abs(d__1)) + (d__2 = 
		    h__[i__ - 1 + (i__ - 2) * h_dim1], abs(d__2));
	    h11 = s * .75 + h__[i__ + i__ * h_dim1];
	    h12 = s * -.4375;
	    h21 = s;
	    h22 = h11;
	} else {

/*           Prepare to use Francis' double shift   
             (i.e. 2nd degree generalized Rayleigh quotient) */

	    h11 = h__[i__ - 1 + (i__ - 1) * h_dim1];
	    h21 = h__[i__ + (i__ - 1) * h_dim1];
	    h12 = h__[i__ - 1 + i__ * h_dim1];
	    h22 = h__[i__ + i__ * h_dim1];
	}
	s = abs(h11) + abs(h12) + abs(h21) + abs(h22);
	if (s == 0.) {
	    rt1r = 0.;
	    rt1i = 0.;
	    rt2r = 0.;
	    rt2i = 0.;
	} else {
	    h11 /= s;
	    h21 /= s;
	    h12 /= s;
	    h22 /= s;
	    tr = (h11 + h22) / 2.;
	    det = (h11 - tr) * (h22 - tr) - h12 * h21;
	    rtdisc = sqrt((abs(det)));
	    if (det >= 0.) {

/*              ==== complex conjugate shifts ==== */

		rt1r = tr * s;
		rt2r = rt1r;
		rt1i = rtdisc * s;
		rt2i = -rt1i;
	    } else {

/*              ==== real shifts (use only one of them)  ==== */

		rt1r = tr + rtdisc;
		rt2r = tr - rtdisc;
		if ((d__1 = rt1r - h22, abs(d__1)) <= (d__2 = rt2r - h22, abs(
			d__2))) {
		    rt1r *= s;
		    rt2r = rt1r;
		} else {
		    rt2r *= s;
		    rt1r = rt2r;
		}
		rt1i = 0.;
		rt2i = 0.;
	    }
	}

/*        Look for two consecutive small subdiagonal elements. */

	i__1 = l;
	for (m = i__ - 2; m >= i__1; --m) {
/*           Determine the effect of starting the double-shift QR   
             iteration at row M, and see if this would make H(M,M-1)   
             negligible.  (The following uses scaling to avoid   
             overflows and most underflows.) */

	    h21s = h__[m + 1 + m * h_dim1];
	    s = (d__1 = h__[m + m * h_dim1] - rt2r, abs(d__1)) + abs(rt2i) + 
		    abs(h21s);
	    h21s = h__[m + 1 + m * h_dim1] / s;
	    v[0] = h21s * h__[m + (m + 1) * h_dim1] + (h__[m + m * h_dim1] - 
		    rt1r) * ((h__[m + m * h_dim1] - rt2r) / s) - rt1i * (rt2i 
		    / s);
	    v[1] = h21s * (h__[m + m * h_dim1] + h__[m + 1 + (m + 1) * h_dim1]
		     - rt1r - rt2r);
	    v[2] = h21s * h__[m + 2 + (m + 1) * h_dim1];
	    s = abs(v[0]) + abs(v[1]) + abs(v[2]);
	    v[0] /= s;
	    v[1] /= s;
	    v[2] /= s;
	    if (m == l) {
		goto L60;
	    }
	    if ((d__1 = h__[m + (m - 1) * h_dim1], abs(d__1)) * (abs(v[1]) + 
		    abs(v[2])) <= ulp * abs(v[0]) * ((d__2 = h__[m - 1 + (m - 
		    1) * h_dim1], abs(d__2)) + (d__3 = h__[m + m * h_dim1], 
		    abs(d__3)) + (d__4 = h__[m + 1 + (m + 1) * h_dim1], abs(
		    d__4)))) {
		goto L60;
	    }
/* L50: */
	}
L60:

/*        Double-shift QR step */

	i__1 = i__ - 1;
	for (k = m; k <= i__1; ++k) {

/*           The first iteration of this loop determines a reflection G   
             from the vector V and applies it from left and right to H,   
             thus creating a nonzero bulge below the subdiagonal.   

             Each subsequent iteration determines a reflection G to   
             restore the Hessenberg form in the (K-1)th column, and thus   
             chases the bulge one step toward the bottom of the active   
             submatrix. NR is the order of G.   

   Computing MIN */
	    i__2 = 3, i__3 = i__ - k + 1;
	    nr = min(i__2,i__3);
	    if (k > m) {
		igraphdcopy_(&nr, &h__[k + (k - 1) * h_dim1], &c__1, v, &c__1);
	    }
	    igraphdlarfg_(&nr, v, &v[1], &c__1, &t1);
	    if (k > m) {
		h__[k + (k - 1) * h_dim1] = v[0];
		h__[k + 1 + (k - 1) * h_dim1] = 0.;
		if (k < i__ - 1) {
		    h__[k + 2 + (k - 1) * h_dim1] = 0.;
		}
	    } else if (m > l) {
/*               ==== Use the following instead of   
                 .    H( K, K-1 ) = -H( K, K-1 ) to   
                 .    avoid a bug when v(2) and v(3)   
                 .    underflow. ==== */
		h__[k + (k - 1) * h_dim1] *= 1. - t1;
	    }
	    v2 = v[1];
	    t2 = t1 * v2;
	    if (nr == 3) {
		v3 = v[2];
		t3 = t1 * v3;

/*              Apply G from the left to transform the rows of the matrix   
                in columns K to I2. */

		i__2 = i2;
		for (j = k; j <= i__2; ++j) {
		    sum = h__[k + j * h_dim1] + v2 * h__[k + 1 + j * h_dim1] 
			    + v3 * h__[k + 2 + j * h_dim1];
		    h__[k + j * h_dim1] -= sum * t1;
		    h__[k + 1 + j * h_dim1] -= sum * t2;
		    h__[k + 2 + j * h_dim1] -= sum * t3;
/* L70: */
		}

/*              Apply G from the right to transform the columns of the   
                matrix in rows I1 to min(K+3,I).   

   Computing MIN */
		i__3 = k + 3;
		i__2 = min(i__3,i__);
		for (j = i1; j <= i__2; ++j) {
		    sum = h__[j + k * h_dim1] + v2 * h__[j + (k + 1) * h_dim1]
			     + v3 * h__[j + (k + 2) * h_dim1];
		    h__[j + k * h_dim1] -= sum * t1;
		    h__[j + (k + 1) * h_dim1] -= sum * t2;
		    h__[j + (k + 2) * h_dim1] -= sum * t3;
/* L80: */
		}

		if (*wantz) {

/*                 Accumulate transformations in the matrix Z */

		    i__2 = *ihiz;
		    for (j = *iloz; j <= i__2; ++j) {
			sum = z__[j + k * z_dim1] + v2 * z__[j + (k + 1) * 
				z_dim1] + v3 * z__[j + (k + 2) * z_dim1];
			z__[j + k * z_dim1] -= sum * t1;
			z__[j + (k + 1) * z_dim1] -= sum * t2;
			z__[j + (k + 2) * z_dim1] -= sum * t3;
/* L90: */
		    }
		}
	    } else if (nr == 2) {

/*              Apply G from the left to transform the rows of the matrix   
                in columns K to I2. */

		i__2 = i2;
		for (j = k; j <= i__2; ++j) {
		    sum = h__[k + j * h_dim1] + v2 * h__[k + 1 + j * h_dim1];
		    h__[k + j * h_dim1] -= sum * t1;
		    h__[k + 1 + j * h_dim1] -= sum * t2;
/* L100: */
		}

/*              Apply G from the right to transform the columns of the   
                matrix in rows I1 to min(K+3,I). */

		i__2 = i__;
		for (j = i1; j <= i__2; ++j) {
		    sum = h__[j + k * h_dim1] + v2 * h__[j + (k + 1) * h_dim1]
			    ;
		    h__[j + k * h_dim1] -= sum * t1;
		    h__[j + (k + 1) * h_dim1] -= sum * t2;
/* L110: */
		}

		if (*wantz) {

/*                 Accumulate transformations in the matrix Z */

		    i__2 = *ihiz;
		    for (j = *iloz; j <= i__2; ++j) {
			sum = z__[j + k * z_dim1] + v2 * z__[j + (k + 1) * 
				z_dim1];
			z__[j + k * z_dim1] -= sum * t1;
			z__[j + (k + 1) * z_dim1] -= sum * t2;
/* L120: */
		    }
		}
	    }
/* L130: */
	}

/* L140: */
    }

/*     Failure to converge in remaining number of iterations */

    *info = i__;
    return 0;

L150:

    if (l == i__) {

/*        H(I,I-1) is negligible: one eigenvalue has converged. */

	wr[i__] = h__[i__ + i__ * h_dim1];
	wi[i__] = 0.;
    } else if (l == i__ - 1) {

/*        H(I-1,I-2) is negligible: a pair of eigenvalues have converged.   

          Transform the 2-by-2 submatrix to standard Schur form,   
          and compute and store the eigenvalues. */

	igraphdlanv2_(&h__[i__ - 1 + (i__ - 1) * h_dim1], &h__[i__ - 1 + i__ * 
		h_dim1], &h__[i__ + (i__ - 1) * h_dim1], &h__[i__ + i__ * 
		h_dim1], &wr[i__ - 1], &wi[i__ - 1], &wr[i__], &wi[i__], &cs, 
		&sn);

	if (*wantt) {

/*           Apply the transformation to the rest of H. */

	    if (i2 > i__) {
		i__1 = i2 - i__;
		igraphdrot_(&i__1, &h__[i__ - 1 + (i__ + 1) * h_dim1], ldh, &h__[
			i__ + (i__ + 1) * h_dim1], ldh, &cs, &sn);
	    }
	    i__1 = i__ - i1 - 1;
	    igraphdrot_(&i__1, &h__[i1 + (i__ - 1) * h_dim1], &c__1, &h__[i1 + i__ *
		     h_dim1], &c__1, &cs, &sn);
	}
	if (*wantz) {

/*           Apply the transformation to Z. */

	    igraphdrot_(&nz, &z__[*iloz + (i__ - 1) * z_dim1], &c__1, &z__[*iloz + 
		    i__ * z_dim1], &c__1, &cs, &sn);
	}
    }

/*     return to start of the main loop with new value of I. */

    i__ = l - 1;
    goto L20;

L160:
    return 0;

/*     End of DLAHQR */

} /* igraphdlahqr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlahr2.c0000644000175100001710000003160200000000000023724 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b4 = -1.;
static doublereal c_b5 = 1.;
static integer c__1 = 1;
static doublereal c_b38 = 0.;

/* > \brief \b DLAHR2 reduces the specified number of first columns of a general rectangular matrix A so that 
elements below the specified subdiagonal are zero, and returns auxiliary matrices which are needed to 
apply the transformation to the unreduced part   
   of A.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAHR2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAHR2( N, K, NB, A, LDA, TAU, T, LDT, Y, LDY )   

         INTEGER            K, LDA, LDT, LDY, N, NB   
         DOUBLE PRECISION  A( LDA, * ), T( LDT, NB ), TAU( NB ),   
        $                   Y( LDY, NB )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)   
   > matrix A so that elements below the k-th subdiagonal are zero. The   
   > reduction is performed by an orthogonal similarity transformation   
   > Q**T * A * Q. The routine returns the matrices V and T which determine   
   > Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.   
   >   
   > This is an auxiliary routine called by DGEHRD.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The offset for the reduction. Elements below the k-th   
   >          subdiagonal in the first NB columns are reduced to zero.   
   >          K < N.   
   > \endverbatim   
   >   
   > \param[in] NB   
   > \verbatim   
   >          NB is INTEGER   
   >          The number of columns to be reduced.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N-K+1)   
   >          On entry, the n-by-(n-k+1) general matrix A.   
   >          On exit, the elements on and above the k-th subdiagonal in   
   >          the first NB columns are overwritten with the corresponding   
   >          elements of the reduced matrix; the elements below the k-th   
   >          subdiagonal, with the array TAU, represent the matrix Q as a   
   >          product of elementary reflectors. The other columns of A are   
   >          unchanged. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (NB)   
   >          The scalar factors of the elementary reflectors. See Further   
   >          Details.   
   > \endverbatim   
   >   
   > \param[out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,NB)   
   >          The upper triangular matrix T.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T.  LDT >= NB.   
   > \endverbatim   
   >   
   > \param[out] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension (LDY,NB)   
   >          The n-by-nb matrix Y.   
   > \endverbatim   
   >   
   > \param[in] LDY   
   > \verbatim   
   >          LDY is INTEGER   
   >          The leading dimension of the array Y. LDY >= N.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The matrix Q is represented as a product of nb elementary reflectors   
   >   
   >     Q = H(1) H(2) . . . H(nb).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in   
   >  A(i+k+1:n,i), and tau in TAU(i).   
   >   
   >  The elements of the vectors v together form the (n-k+1)-by-nb matrix   
   >  V which is needed, with T and Y, to apply the transformation to the   
   >  unreduced part of the matrix, using an update of the form:   
   >  A := (I - V*T*V**T) * (A - Y*V**T).   
   >   
   >  The contents of A on exit are illustrated by the following example   
   >  with n = 7, k = 3 and nb = 2:   
   >   
   >     ( a   a   a   a   a )   
   >     ( a   a   a   a   a )   
   >     ( a   a   a   a   a )   
   >     ( h   h   a   a   a )   
   >     ( v1  h   a   a   a )   
   >     ( v1  v2  a   a   a )   
   >     ( v1  v2  a   a   a )   
   >   
   >  where a denotes an element of the original matrix A, h denotes a   
   >  modified element of the upper Hessenberg matrix H, and vi denotes an   
   >  element of the vector defining H(i).   
   >   
   >  This subroutine is a slight modification of LAPACK-3.0's DLAHRD   
   >  incorporating improvements proposed by Quintana-Orti and Van de   
   >  Gejin. Note that the entries of A(1:K,2:NB) differ from those   
   >  returned by the original LAPACK-3.0's DLAHRD routine. (This   
   >  subroutine is not backward compatible with LAPACK-3.0's DLAHRD.)   
   > \endverbatim   

   > \par References:   
    ================   
   >   
   >  Gregorio Quintana-Orti and Robert van de Geijn, "Improving the   
   >  performance of reduction to Hessenberg form," ACM Transactions on   
   >  Mathematical Software, 32(2):180-194, June 2006.   
   >   
    =====================================================================   
   Subroutine */ int igraphdlahr2_(integer *n, integer *k, integer *nb, doublereal *
	a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, 
	doublereal *y, integer *ldy)
{
    /* System generated locals */
    integer a_dim1, a_offset, t_dim1, t_offset, y_dim1, y_offset, i__1, i__2, 
	    i__3;
    doublereal d__1;

    /* Local variables */
    integer i__;
    doublereal ei;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdgemm_(char *, char *, integer *, integer *, integer *
	    , doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *), igraphdgemv_(
	    char *, integer *, integer *, doublereal *, doublereal *, integer 
	    *, doublereal *, integer *, doublereal *, doublereal *, integer *), igraphdcopy_(integer *, doublereal *, integer *, doublereal *,
	     integer *), igraphdtrmm_(char *, char *, char *, char *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *), igraphdaxpy_(integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *), 
	    igraphdtrmv_(char *, char *, char *, integer *, doublereal *, integer *,
	     doublereal *, integer *), igraphdlarfg_(
	    integer *, doublereal *, doublereal *, integer *, doublereal *), 
	    igraphdlacpy_(char *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, integer *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Quick return if possible   

       Parameter adjustments */
    --tau;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    y_dim1 = *ldy;
    y_offset = 1 + y_dim1;
    y -= y_offset;

    /* Function Body */
    if (*n <= 1) {
	return 0;
    }

    i__1 = *nb;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if (i__ > 1) {

/*           Update A(K+1:N,I)   

             Update I-th column of A - Y * V**T */

	    i__2 = *n - *k;
	    i__3 = i__ - 1;
	    igraphdgemv_("NO TRANSPOSE", &i__2, &i__3, &c_b4, &y[*k + 1 + y_dim1], 
		    ldy, &a[*k + i__ - 1 + a_dim1], lda, &c_b5, &a[*k + 1 + 
		    i__ * a_dim1], &c__1);

/*           Apply I - V * T**T * V**T to this column (call it b) from the   
             left, using the last column of T as workspace   

             Let  V = ( V1 )   and   b = ( b1 )   (first I-1 rows)   
                      ( V2 )             ( b2 )   

             where V1 is unit lower triangular   

             w := V1**T * b1 */

	    i__2 = i__ - 1;
	    igraphdcopy_(&i__2, &a[*k + 1 + i__ * a_dim1], &c__1, &t[*nb * t_dim1 + 
		    1], &c__1);
	    i__2 = i__ - 1;
	    igraphdtrmv_("Lower", "Transpose", "UNIT", &i__2, &a[*k + 1 + a_dim1], 
		    lda, &t[*nb * t_dim1 + 1], &c__1);

/*           w := w + V2**T * b2 */

	    i__2 = *n - *k - i__ + 1;
	    i__3 = i__ - 1;
	    igraphdgemv_("Transpose", &i__2, &i__3, &c_b5, &a[*k + i__ + a_dim1], 
		    lda, &a[*k + i__ + i__ * a_dim1], &c__1, &c_b5, &t[*nb * 
		    t_dim1 + 1], &c__1);

/*           w := T**T * w */

	    i__2 = i__ - 1;
	    igraphdtrmv_("Upper", "Transpose", "NON-UNIT", &i__2, &t[t_offset], ldt,
		     &t[*nb * t_dim1 + 1], &c__1);

/*           b2 := b2 - V2*w */

	    i__2 = *n - *k - i__ + 1;
	    i__3 = i__ - 1;
	    igraphdgemv_("NO TRANSPOSE", &i__2, &i__3, &c_b4, &a[*k + i__ + a_dim1],
		     lda, &t[*nb * t_dim1 + 1], &c__1, &c_b5, &a[*k + i__ + 
		    i__ * a_dim1], &c__1);

/*           b1 := b1 - V1*w */

	    i__2 = i__ - 1;
	    igraphdtrmv_("Lower", "NO TRANSPOSE", "UNIT", &i__2, &a[*k + 1 + a_dim1]
		    , lda, &t[*nb * t_dim1 + 1], &c__1);
	    i__2 = i__ - 1;
	    igraphdaxpy_(&i__2, &c_b4, &t[*nb * t_dim1 + 1], &c__1, &a[*k + 1 + i__ 
		    * a_dim1], &c__1);

	    a[*k + i__ - 1 + (i__ - 1) * a_dim1] = ei;
	}

/*        Generate the elementary reflector H(I) to annihilate   
          A(K+I+1:N,I) */

	i__2 = *n - *k - i__ + 1;
/* Computing MIN */
	i__3 = *k + i__ + 1;
	igraphdlarfg_(&i__2, &a[*k + i__ + i__ * a_dim1], &a[min(i__3,*n) + i__ * 
		a_dim1], &c__1, &tau[i__]);
	ei = a[*k + i__ + i__ * a_dim1];
	a[*k + i__ + i__ * a_dim1] = 1.;

/*        Compute  Y(K+1:N,I) */

	i__2 = *n - *k;
	i__3 = *n - *k - i__ + 1;
	igraphdgemv_("NO TRANSPOSE", &i__2, &i__3, &c_b5, &a[*k + 1 + (i__ + 1) * 
		a_dim1], lda, &a[*k + i__ + i__ * a_dim1], &c__1, &c_b38, &y[*
		k + 1 + i__ * y_dim1], &c__1);
	i__2 = *n - *k - i__ + 1;
	i__3 = i__ - 1;
	igraphdgemv_("Transpose", &i__2, &i__3, &c_b5, &a[*k + i__ + a_dim1], lda, &
		a[*k + i__ + i__ * a_dim1], &c__1, &c_b38, &t[i__ * t_dim1 + 
		1], &c__1);
	i__2 = *n - *k;
	i__3 = i__ - 1;
	igraphdgemv_("NO TRANSPOSE", &i__2, &i__3, &c_b4, &y[*k + 1 + y_dim1], ldy, 
		&t[i__ * t_dim1 + 1], &c__1, &c_b5, &y[*k + 1 + i__ * y_dim1],
		 &c__1);
	i__2 = *n - *k;
	igraphdscal_(&i__2, &tau[i__], &y[*k + 1 + i__ * y_dim1], &c__1);

/*        Compute T(1:I,I) */

	i__2 = i__ - 1;
	d__1 = -tau[i__];
	igraphdscal_(&i__2, &d__1, &t[i__ * t_dim1 + 1], &c__1);
	i__2 = i__ - 1;
	igraphdtrmv_("Upper", "No Transpose", "NON-UNIT", &i__2, &t[t_offset], ldt, 
		&t[i__ * t_dim1 + 1], &c__1)
		;
	t[i__ + i__ * t_dim1] = tau[i__];

/* L10: */
    }
    a[*k + *nb + *nb * a_dim1] = ei;

/*     Compute Y(1:K,1:NB) */

    igraphdlacpy_("ALL", k, nb, &a[(a_dim1 << 1) + 1], lda, &y[y_offset], ldy);
    igraphdtrmm_("RIGHT", "Lower", "NO TRANSPOSE", "UNIT", k, nb, &c_b5, &a[*k + 1 
	    + a_dim1], lda, &y[y_offset], ldy);
    if (*n > *k + *nb) {
	i__1 = *n - *k - *nb;
	igraphdgemm_("NO TRANSPOSE", "NO TRANSPOSE", k, nb, &i__1, &c_b5, &a[(*nb + 
		2) * a_dim1 + 1], lda, &a[*k + 1 + *nb + a_dim1], lda, &c_b5, 
		&y[y_offset], ldy);
    }
    igraphdtrmm_("RIGHT", "Upper", "NO TRANSPOSE", "NON-UNIT", k, nb, &c_b5, &t[
	    t_offset], ldt, &y[y_offset], ldy);

    return 0;

/*     End of DLAHR2 */

} /* igraphdlahr2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaisnan.c0000644000175100001710000000633100000000000024342 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAISNAN tests input for NaN by comparing two arguments for inequality.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAISNAN + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         LOGICAL FUNCTION DLAISNAN( DIN1, DIN2 )   

         DOUBLE PRECISION   DIN1, DIN2   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > This routine is not for general use.  It exists solely to avoid   
   > over-optimization in DISNAN.   
   >   
   > DLAISNAN checks for NaNs by comparing its two arguments for   
   > inequality.  NaN is the only floating-point value where NaN != NaN   
   > returns .TRUE.  To check for NaNs, pass the same variable as both   
   > arguments.   
   >   
   > A compiler must assume that the two arguments are   
   > not the same variable, and the test will not be optimized away.   
   > Interprocedural or whole-program optimization may delete this   
   > test.  The ISNAN functions will be replaced by the correct   
   > Fortran 03 intrinsic once the intrinsic is widely available.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] DIN1   
   > \verbatim   
   >          DIN1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] DIN2   
   > \verbatim   
   >          DIN2 is DOUBLE PRECISION   
   >          Two numbers to compare for inequality.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
logical igraphdlaisnan_(doublereal *din1, doublereal *din2)
{
    /* System generated locals */
    logical ret_val;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ===================================================================== */

    ret_val = *din1 != *din2;
    return ret_val;
} /* igraphdlaisnan_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaln2.c0000644000175100001710000004544700000000000023740 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLALN2 solves a 1-by-1 or 2-by-2 linear system of equations of the specified form.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLALN2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLALN2( LTRANS, NA, NW, SMIN, CA, A, LDA, D1, D2, B,   
                            LDB, WR, WI, X, LDX, SCALE, XNORM, INFO )   

         LOGICAL            LTRANS   
         INTEGER            INFO, LDA, LDB, LDX, NA, NW   
         DOUBLE PRECISION   CA, D1, D2, SCALE, SMIN, WI, WR, XNORM   
         DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), X( LDX, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLALN2 solves a system of the form  (ca A - w D ) X = s B   
   > or (ca A**T - w D) X = s B   with possible scaling ("s") and   
   > perturbation of A.  (A**T means A-transpose.)   
   >   
   > A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA   
   > real diagonal matrix, w is a real or complex value, and X and B are   
   > NA x 1 matrices -- real if w is real, complex if w is complex.  NA   
   > may be 1 or 2.   
   >   
   > If w is complex, X and B are represented as NA x 2 matrices,   
   > the first column of each being the real part and the second   
   > being the imaginary part.   
   >   
   > "s" is a scaling factor (.LE. 1), computed by DLALN2, which is   
   > so chosen that X can be computed without overflow.  X is further   
   > scaled if necessary to assure that norm(ca A - w D)*norm(X) is less   
   > than overflow.   
   >   
   > If both singular values of (ca A - w D) are less than SMIN,   
   > SMIN*identity will be used instead of (ca A - w D).  If only one   
   > singular value is less than SMIN, one element of (ca A - w D) will be   
   > perturbed enough to make the smallest singular value roughly SMIN.   
   > If both singular values are at least SMIN, (ca A - w D) will not be   
   > perturbed.  In any case, the perturbation will be at most some small   
   > multiple of max( SMIN, ulp*norm(ca A - w D) ).  The singular values   
   > are computed by infinity-norm approximations, and thus will only be   
   > correct to a factor of 2 or so.   
   >   
   > Note: all input quantities are assumed to be smaller than overflow   
   > by a reasonable factor.  (See BIGNUM.)   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] LTRANS   
   > \verbatim   
   >          LTRANS is LOGICAL   
   >          =.TRUE.:  A-transpose will be used.   
   >          =.FALSE.: A will be used (not transposed.)   
   > \endverbatim   
   >   
   > \param[in] NA   
   > \verbatim   
   >          NA is INTEGER   
   >          The size of the matrix A.  It may (only) be 1 or 2.   
   > \endverbatim   
   >   
   > \param[in] NW   
   > \verbatim   
   >          NW is INTEGER   
   >          1 if "w" is real, 2 if "w" is complex.  It may only be 1   
   >          or 2.   
   > \endverbatim   
   >   
   > \param[in] SMIN   
   > \verbatim   
   >          SMIN is DOUBLE PRECISION   
   >          The desired lower bound on the singular values of A.  This   
   >          should be a safe distance away from underflow or overflow,   
   >          say, between (underflow/machine precision) and  (machine   
   >          precision * overflow ).  (See BIGNUM and ULP.)   
   > \endverbatim   
   >   
   > \param[in] CA   
   > \verbatim   
   >          CA is DOUBLE PRECISION   
   >          The coefficient c, which A is multiplied by.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,NA)   
   >          The NA x NA matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of A.  It must be at least NA.   
   > \endverbatim   
   >   
   > \param[in] D1   
   > \verbatim   
   >          D1 is DOUBLE PRECISION   
   >          The 1,1 element in the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] D2   
   > \verbatim   
   >          D2 is DOUBLE PRECISION   
   >          The 2,2 element in the diagonal matrix D.  Not used if NW=1.   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,NW)   
   >          The NA x NW matrix B (right-hand side).  If NW=2 ("w" is   
   >          complex), column 1 contains the real part of B and column 2   
   >          contains the imaginary part.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of B.  It must be at least NA.   
   > \endverbatim   
   >   
   > \param[in] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION   
   >          The real part of the scalar "w".   
   > \endverbatim   
   >   
   > \param[in] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION   
   >          The imaginary part of the scalar "w".  Not used if NW=1.   
   > \endverbatim   
   >   
   > \param[out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (LDX,NW)   
   >          The NA x NW matrix X (unknowns), as computed by DLALN2.   
   >          If NW=2 ("w" is complex), on exit, column 1 will contain   
   >          the real part of X and column 2 will contain the imaginary   
   >          part.   
   > \endverbatim   
   >   
   > \param[in] LDX   
   > \verbatim   
   >          LDX is INTEGER   
   >          The leading dimension of X.  It must be at least NA.   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION   
   >          The scale factor that B must be multiplied by to insure   
   >          that overflow does not occur when computing X.  Thus,   
   >          (ca A - w D) X  will be SCALE*B, not B (ignoring   
   >          perturbations of A.)  It will be at most 1.   
   > \endverbatim   
   >   
   > \param[out] XNORM   
   > \verbatim   
   >          XNORM is DOUBLE PRECISION   
   >          The infinity-norm of X, when X is regarded as an NA x NW   
   >          real matrix.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          An error flag.  It will be set to zero if no error occurs,   
   >          a negative number if an argument is in error, or a positive   
   >          number if  ca A - w D  had to be perturbed.   
   >          The possible values are:   
   >          = 0: No error occurred, and (ca A - w D) did not have to be   
   >                 perturbed.   
   >          = 1: (ca A - w D) had to be perturbed to make its smallest   
   >               (or only) singular value greater than SMIN.   
   >          NOTE: In the interests of speed, this routine does not   
   >                check the inputs for errors.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlaln2_(logical *ltrans, integer *na, integer *nw, 
	doublereal *smin, doublereal *ca, doublereal *a, integer *lda, 
	doublereal *d1, doublereal *d2, doublereal *b, integer *ldb, 
	doublereal *wr, doublereal *wi, doublereal *x, integer *ldx, 
	doublereal *scale, doublereal *xnorm, integer *info)
{
    /* Initialized data */

    static logical zswap[4] = { FALSE_,FALSE_,TRUE_,TRUE_ };
    static logical rswap[4] = { FALSE_,TRUE_,FALSE_,TRUE_ };
    static integer ipivot[16]	/* was [4][4] */ = { 1,2,3,4,2,1,4,3,3,4,1,2,
	    4,3,2,1 };

    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, x_dim1, x_offset;
    doublereal d__1, d__2, d__3, d__4, d__5, d__6;
    IGRAPH_F77_SAVE doublereal equiv_0[4], equiv_1[4];

    /* Local variables */
    integer j;
#define ci (equiv_0)
#define cr (equiv_1)
    doublereal bi1, bi2, br1, br2, xi1, xi2, xr1, xr2, ci21, ci22, cr21, cr22,
	     li21, csi, ui11, lr21, ui12, ui22;
#define civ (equiv_0)
    doublereal csr, ur11, ur12, ur22;
#define crv (equiv_1)
    doublereal bbnd, cmax, ui11r, ui12s, temp, ur11r, ur12s, u22abs;
    integer icmax;
    doublereal bnorm, cnorm, smini;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdladiv_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *);
    doublereal bignum, smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;
    x_dim1 = *ldx;
    x_offset = 1 + x_dim1;
    x -= x_offset;

    /* Function Body   

       Compute BIGNUM */

    smlnum = 2. * igraphdlamch_("Safe minimum");
    bignum = 1. / smlnum;
    smini = max(*smin,smlnum);

/*     Don't check for input errors */

    *info = 0;

/*     Standard Initializations */

    *scale = 1.;

    if (*na == 1) {

/*        1 x 1  (i.e., scalar) system   C X = B */

	if (*nw == 1) {

/*           Real 1x1 system.   

             C = ca A - w D */

	    csr = *ca * a[a_dim1 + 1] - *wr * *d1;
	    cnorm = abs(csr);

/*           If | C | < SMINI, use C = SMINI */

	    if (cnorm < smini) {
		csr = smini;
		cnorm = smini;
		*info = 1;
	    }

/*           Check scaling for  X = B / C */

	    bnorm = (d__1 = b[b_dim1 + 1], abs(d__1));
	    if (cnorm < 1. && bnorm > 1.) {
		if (bnorm > bignum * cnorm) {
		    *scale = 1. / bnorm;
		}
	    }

/*           Compute X */

	    x[x_dim1 + 1] = b[b_dim1 + 1] * *scale / csr;
	    *xnorm = (d__1 = x[x_dim1 + 1], abs(d__1));
	} else {

/*           Complex 1x1 system (w is complex)   

             C = ca A - w D */

	    csr = *ca * a[a_dim1 + 1] - *wr * *d1;
	    csi = -(*wi) * *d1;
	    cnorm = abs(csr) + abs(csi);

/*           If | C | < SMINI, use C = SMINI */

	    if (cnorm < smini) {
		csr = smini;
		csi = 0.;
		cnorm = smini;
		*info = 1;
	    }

/*           Check scaling for  X = B / C */

	    bnorm = (d__1 = b[b_dim1 + 1], abs(d__1)) + (d__2 = b[(b_dim1 << 
		    1) + 1], abs(d__2));
	    if (cnorm < 1. && bnorm > 1.) {
		if (bnorm > bignum * cnorm) {
		    *scale = 1. / bnorm;
		}
	    }

/*           Compute X */

	    d__1 = *scale * b[b_dim1 + 1];
	    d__2 = *scale * b[(b_dim1 << 1) + 1];
	    igraphdladiv_(&d__1, &d__2, &csr, &csi, &x[x_dim1 + 1], &x[(x_dim1 << 1)
		     + 1]);
	    *xnorm = (d__1 = x[x_dim1 + 1], abs(d__1)) + (d__2 = x[(x_dim1 << 
		    1) + 1], abs(d__2));
	}

    } else {

/*        2x2 System   

          Compute the real part of  C = ca A - w D  (or  ca A**T - w D ) */

	cr[0] = *ca * a[a_dim1 + 1] - *wr * *d1;
	cr[3] = *ca * a[(a_dim1 << 1) + 2] - *wr * *d2;
	if (*ltrans) {
	    cr[2] = *ca * a[a_dim1 + 2];
	    cr[1] = *ca * a[(a_dim1 << 1) + 1];
	} else {
	    cr[1] = *ca * a[a_dim1 + 2];
	    cr[2] = *ca * a[(a_dim1 << 1) + 1];
	}

	if (*nw == 1) {

/*           Real 2x2 system  (w is real)   

             Find the largest element in C */

	    cmax = 0.;
	    icmax = 0;

	    for (j = 1; j <= 4; ++j) {
		if ((d__1 = crv[j - 1], abs(d__1)) > cmax) {
		    cmax = (d__1 = crv[j - 1], abs(d__1));
		    icmax = j;
		}
/* L10: */
	    }

/*           If norm(C) < SMINI, use SMINI*identity. */

	    if (cmax < smini) {
/* Computing MAX */
		d__3 = (d__1 = b[b_dim1 + 1], abs(d__1)), d__4 = (d__2 = b[
			b_dim1 + 2], abs(d__2));
		bnorm = max(d__3,d__4);
		if (smini < 1. && bnorm > 1.) {
		    if (bnorm > bignum * smini) {
			*scale = 1. / bnorm;
		    }
		}
		temp = *scale / smini;
		x[x_dim1 + 1] = temp * b[b_dim1 + 1];
		x[x_dim1 + 2] = temp * b[b_dim1 + 2];
		*xnorm = temp * bnorm;
		*info = 1;
		return 0;
	    }

/*           Gaussian elimination with complete pivoting. */

	    ur11 = crv[icmax - 1];
	    cr21 = crv[ipivot[(icmax << 2) - 3] - 1];
	    ur12 = crv[ipivot[(icmax << 2) - 2] - 1];
	    cr22 = crv[ipivot[(icmax << 2) - 1] - 1];
	    ur11r = 1. / ur11;
	    lr21 = ur11r * cr21;
	    ur22 = cr22 - ur12 * lr21;

/*           If smaller pivot < SMINI, use SMINI */

	    if (abs(ur22) < smini) {
		ur22 = smini;
		*info = 1;
	    }
	    if (rswap[icmax - 1]) {
		br1 = b[b_dim1 + 2];
		br2 = b[b_dim1 + 1];
	    } else {
		br1 = b[b_dim1 + 1];
		br2 = b[b_dim1 + 2];
	    }
	    br2 -= lr21 * br1;
/* Computing MAX */
	    d__2 = (d__1 = br1 * (ur22 * ur11r), abs(d__1)), d__3 = abs(br2);
	    bbnd = max(d__2,d__3);
	    if (bbnd > 1. && abs(ur22) < 1.) {
		if (bbnd >= bignum * abs(ur22)) {
		    *scale = 1. / bbnd;
		}
	    }

	    xr2 = br2 * *scale / ur22;
	    xr1 = *scale * br1 * ur11r - xr2 * (ur11r * ur12);
	    if (zswap[icmax - 1]) {
		x[x_dim1 + 1] = xr2;
		x[x_dim1 + 2] = xr1;
	    } else {
		x[x_dim1 + 1] = xr1;
		x[x_dim1 + 2] = xr2;
	    }
/* Computing MAX */
	    d__1 = abs(xr1), d__2 = abs(xr2);
	    *xnorm = max(d__1,d__2);

/*           Further scaling if  norm(A) norm(X) > overflow */

	    if (*xnorm > 1. && cmax > 1.) {
		if (*xnorm > bignum / cmax) {
		    temp = cmax / bignum;
		    x[x_dim1 + 1] = temp * x[x_dim1 + 1];
		    x[x_dim1 + 2] = temp * x[x_dim1 + 2];
		    *xnorm = temp * *xnorm;
		    *scale = temp * *scale;
		}
	    }
	} else {

/*           Complex 2x2 system  (w is complex)   

             Find the largest element in C */

	    ci[0] = -(*wi) * *d1;
	    ci[1] = 0.;
	    ci[2] = 0.;
	    ci[3] = -(*wi) * *d2;
	    cmax = 0.;
	    icmax = 0;

	    for (j = 1; j <= 4; ++j) {
		if ((d__1 = crv[j - 1], abs(d__1)) + (d__2 = civ[j - 1], abs(
			d__2)) > cmax) {
		    cmax = (d__1 = crv[j - 1], abs(d__1)) + (d__2 = civ[j - 1]
			    , abs(d__2));
		    icmax = j;
		}
/* L20: */
	    }

/*           If norm(C) < SMINI, use SMINI*identity. */

	    if (cmax < smini) {
/* Computing MAX */
		d__5 = (d__1 = b[b_dim1 + 1], abs(d__1)) + (d__2 = b[(b_dim1 
			<< 1) + 1], abs(d__2)), d__6 = (d__3 = b[b_dim1 + 2], 
			abs(d__3)) + (d__4 = b[(b_dim1 << 1) + 2], abs(d__4));
		bnorm = max(d__5,d__6);
		if (smini < 1. && bnorm > 1.) {
		    if (bnorm > bignum * smini) {
			*scale = 1. / bnorm;
		    }
		}
		temp = *scale / smini;
		x[x_dim1 + 1] = temp * b[b_dim1 + 1];
		x[x_dim1 + 2] = temp * b[b_dim1 + 2];
		x[(x_dim1 << 1) + 1] = temp * b[(b_dim1 << 1) + 1];
		x[(x_dim1 << 1) + 2] = temp * b[(b_dim1 << 1) + 2];
		*xnorm = temp * bnorm;
		*info = 1;
		return 0;
	    }

/*           Gaussian elimination with complete pivoting. */

	    ur11 = crv[icmax - 1];
	    ui11 = civ[icmax - 1];
	    cr21 = crv[ipivot[(icmax << 2) - 3] - 1];
	    ci21 = civ[ipivot[(icmax << 2) - 3] - 1];
	    ur12 = crv[ipivot[(icmax << 2) - 2] - 1];
	    ui12 = civ[ipivot[(icmax << 2) - 2] - 1];
	    cr22 = crv[ipivot[(icmax << 2) - 1] - 1];
	    ci22 = civ[ipivot[(icmax << 2) - 1] - 1];
	    if (icmax == 1 || icmax == 4) {

/*              Code when off-diagonals of pivoted C are real */

		if (abs(ur11) > abs(ui11)) {
		    temp = ui11 / ur11;
/* Computing 2nd power */
		    d__1 = temp;
		    ur11r = 1. / (ur11 * (d__1 * d__1 + 1.));
		    ui11r = -temp * ur11r;
		} else {
		    temp = ur11 / ui11;
/* Computing 2nd power */
		    d__1 = temp;
		    ui11r = -1. / (ui11 * (d__1 * d__1 + 1.));
		    ur11r = -temp * ui11r;
		}
		lr21 = cr21 * ur11r;
		li21 = cr21 * ui11r;
		ur12s = ur12 * ur11r;
		ui12s = ur12 * ui11r;
		ur22 = cr22 - ur12 * lr21;
		ui22 = ci22 - ur12 * li21;
	    } else {

/*              Code when diagonals of pivoted C are real */

		ur11r = 1. / ur11;
		ui11r = 0.;
		lr21 = cr21 * ur11r;
		li21 = ci21 * ur11r;
		ur12s = ur12 * ur11r;
		ui12s = ui12 * ur11r;
		ur22 = cr22 - ur12 * lr21 + ui12 * li21;
		ui22 = -ur12 * li21 - ui12 * lr21;
	    }
	    u22abs = abs(ur22) + abs(ui22);

/*           If smaller pivot < SMINI, use SMINI */

	    if (u22abs < smini) {
		ur22 = smini;
		ui22 = 0.;
		*info = 1;
	    }
	    if (rswap[icmax - 1]) {
		br2 = b[b_dim1 + 1];
		br1 = b[b_dim1 + 2];
		bi2 = b[(b_dim1 << 1) + 1];
		bi1 = b[(b_dim1 << 1) + 2];
	    } else {
		br1 = b[b_dim1 + 1];
		br2 = b[b_dim1 + 2];
		bi1 = b[(b_dim1 << 1) + 1];
		bi2 = b[(b_dim1 << 1) + 2];
	    }
	    br2 = br2 - lr21 * br1 + li21 * bi1;
	    bi2 = bi2 - li21 * br1 - lr21 * bi1;
/* Computing MAX */
	    d__1 = (abs(br1) + abs(bi1)) * (u22abs * (abs(ur11r) + abs(ui11r))
		    ), d__2 = abs(br2) + abs(bi2);
	    bbnd = max(d__1,d__2);
	    if (bbnd > 1. && u22abs < 1.) {
		if (bbnd >= bignum * u22abs) {
		    *scale = 1. / bbnd;
		    br1 = *scale * br1;
		    bi1 = *scale * bi1;
		    br2 = *scale * br2;
		    bi2 = *scale * bi2;
		}
	    }

	    igraphdladiv_(&br2, &bi2, &ur22, &ui22, &xr2, &xi2);
	    xr1 = ur11r * br1 - ui11r * bi1 - ur12s * xr2 + ui12s * xi2;
	    xi1 = ui11r * br1 + ur11r * bi1 - ui12s * xr2 - ur12s * xi2;
	    if (zswap[icmax - 1]) {
		x[x_dim1 + 1] = xr2;
		x[x_dim1 + 2] = xr1;
		x[(x_dim1 << 1) + 1] = xi2;
		x[(x_dim1 << 1) + 2] = xi1;
	    } else {
		x[x_dim1 + 1] = xr1;
		x[x_dim1 + 2] = xr2;
		x[(x_dim1 << 1) + 1] = xi1;
		x[(x_dim1 << 1) + 2] = xi2;
	    }
/* Computing MAX */
	    d__1 = abs(xr1) + abs(xi1), d__2 = abs(xr2) + abs(xi2);
	    *xnorm = max(d__1,d__2);

/*           Further scaling if  norm(A) norm(X) > overflow */

	    if (*xnorm > 1. && cmax > 1.) {
		if (*xnorm > bignum / cmax) {
		    temp = cmax / bignum;
		    x[x_dim1 + 1] = temp * x[x_dim1 + 1];
		    x[x_dim1 + 2] = temp * x[x_dim1 + 2];
		    x[(x_dim1 << 1) + 1] = temp * x[(x_dim1 << 1) + 1];
		    x[(x_dim1 << 1) + 2] = temp * x[(x_dim1 << 1) + 2];
		    *xnorm = temp * *xnorm;
		    *scale = temp * *scale;
		}
	    }
	}
    }

    return 0;

/*     End of DLALN2 */

} /* igraphdlaln2_ */

#undef crv
#undef civ
#undef cr
#undef ci


././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlamch.c0000644000175100001710000001343200000000000024001 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b2 = 0.;

/* > \brief \b DLAMCH   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

        DOUBLE PRECISION FUNCTION DLAMCH( CMACH )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAMCH determines double precision machine parameters.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] CMACH   
   > \verbatim   
   >          Specifies the value to be returned by DLAMCH:   
   >          = 'E' or 'e',   DLAMCH := eps   
   >          = 'S' or 's ,   DLAMCH := sfmin   
   >          = 'B' or 'b',   DLAMCH := base   
   >          = 'P' or 'p',   DLAMCH := eps*base   
   >          = 'N' or 'n',   DLAMCH := t   
   >          = 'R' or 'r',   DLAMCH := rnd   
   >          = 'M' or 'm',   DLAMCH := emin   
   >          = 'U' or 'u',   DLAMCH := rmin   
   >          = 'L' or 'l',   DLAMCH := emax   
   >          = 'O' or 'o',   DLAMCH := rmax   
   >          where   
   >          eps   = relative machine precision   
   >          sfmin = safe minimum, such that 1/sfmin does not overflow   
   >          base  = base of the machine   
   >          prec  = eps*base   
   >          t     = number of (base) digits in the mantissa   
   >          rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise   
   >          emin  = minimum exponent before (gradual) underflow   
   >          rmin  = underflow threshold - base**(emin-1)   
   >          emax  = largest exponent before overflow   
   >          rmax  = overflow threshold  - (base**emax)*(1-eps)   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
doublereal igraphdlamch_(char *cmach)
{
    /* System generated locals */
    doublereal ret_val;

    /* Local variables */
    extern doublereal radixdbl_(doublereal *), digitsdbl_(doublereal *), 
	    epsilondbl_(doublereal *);
    doublereal rnd, eps, rmach;
    extern logical igraphlsame_(char *, char *);
    doublereal small, sfmin;
    extern integer minexponentdbl_(doublereal *), maxexponentdbl_(doublereal *
	    );
    extern doublereal hugedbl_(doublereal *), tinydbl_(doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   



   =====================================================================   



       Assume rounding, not chopping. Always. */

    rnd = 1.;

    if (1. == rnd) {
	eps = epsilondbl_(&c_b2) * .5f;
    } else {
	eps = epsilondbl_(&c_b2);
    }

    if (igraphlsame_(cmach, "E")) {
	rmach = eps;
    } else if (igraphlsame_(cmach, "S")) {
	sfmin = tinydbl_(&c_b2);
	small = 1. / hugedbl_(&c_b2);
	if (small >= sfmin) {

/*           Use SMALL plus a bit, to avoid the possibility of rounding   
             causing overflow when computing  1/sfmin. */

	    sfmin = small * (eps + 1.);
	}
	rmach = sfmin;
    } else if (igraphlsame_(cmach, "B")) {
	rmach = radixdbl_(&c_b2);
    } else if (igraphlsame_(cmach, "P")) {
	rmach = eps * radixdbl_(&c_b2);
    } else if (igraphlsame_(cmach, "N")) {
	rmach = digitsdbl_(&c_b2);
    } else if (igraphlsame_(cmach, "R")) {
	rmach = rnd;
    } else if (igraphlsame_(cmach, "M")) {
	rmach = (doublereal) minexponentdbl_(&c_b2);
    } else if (igraphlsame_(cmach, "U")) {
	rmach = tinydbl_(&c_b2);
    } else if (igraphlsame_(cmach, "L")) {
	rmach = (doublereal) maxexponentdbl_(&c_b2);
    } else if (igraphlsame_(cmach, "O")) {
	rmach = hugedbl_(&c_b2);
    } else {
	rmach = 0.;
    }

    ret_val = rmach;
    return ret_val;

/*     End of DLAMCH */

} /* igraphdlamch_   

   ***********************************************************************   
   > \brief \b DLAMC3   
   > \details   
   > \b Purpose:   
   > \verbatim   
   > DLAMC3  is intended to force  A  and  B  to be stored prior to doing   
   > the addition of  A  and  B ,  for use in situations where optimizers   
   > might hold one of these in a register.   
   > \endverbatim   
   > \author LAPACK is a software package provided by Univ. of Tennessee, Univ. of California Berkeley, Univ. 
of Colorado Denver and NAG Ltd..   
   > \date November 2011   
   > \ingroup auxOTHERauxiliary   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is a DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is a DOUBLE PRECISION   
   >          The values A and B.   
   > \endverbatim   
   > */
doublereal igraphdlamc3_(doublereal *a, doublereal *b)
{
    /* System generated locals */
    doublereal ret_val;


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
       Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..   
       November 2010   

   ===================================================================== */


    ret_val = *a + *b;

    return ret_val;

/*     End of DLAMC3 */

} /* igraphdlamc3_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaneg.c0000644000175100001710000001701000000000000023777 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLANEG computes the Sturm count.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANEG + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER FUNCTION DLANEG( N, D, LLD, SIGMA, PIVMIN, R )   

         INTEGER            N, R   
         DOUBLE PRECISION   PIVMIN, SIGMA   
         DOUBLE PRECISION   D( * ), LLD( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANEG computes the Sturm count, the number of negative pivots   
   > encountered while factoring tridiagonal T - sigma I = L D L^T.   
   > This implementation works directly on the factors without forming   
   > the tridiagonal matrix T.  The Sturm count is also the number of   
   > eigenvalues of T less than sigma.   
   >   
   > This routine is called from DLARRB.   
   >   
   > The current routine does not use the PIVMIN parameter but rather   
   > requires IEEE-754 propagation of Infinities and NaNs.  This   
   > routine also has no input range restrictions but does require   
   > default exception handling such that x/0 produces Inf when x is   
   > non-zero, and Inf/Inf produces NaN.  For more information, see:   
   >   
   >   Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in   
   >   Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on   
   >   Scientific Computing, v28, n5, 2006.  DOI 10.1137/050641624   
   >   (Tech report version in LAWN 172 with the same title.)   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] LLD   
   > \verbatim   
   >          LLD is DOUBLE PRECISION array, dimension (N-1)   
   >          The (N-1) elements L(i)*L(i)*D(i).   
   > \endverbatim   
   >   
   > \param[in] SIGMA   
   > \verbatim   
   >          SIGMA is DOUBLE PRECISION   
   >          Shift amount in T - sigma I = L D L^T.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot in the Sturm sequence.  May be used   
   >          when zero pivots are encountered on non-IEEE-754   
   >          architectures.   
   > \endverbatim   
   >   
   > \param[in] R   
   > \verbatim   
   >          R is INTEGER   
   >          The twist index for the twisted factorization that is used   
   >          for the negcount.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >     Osni Marques, LBNL/NERSC, USA \n   
   >     Christof Voemel, University of California, Berkeley, USA \n   
   >     Jason Riedy, University of California, Berkeley, USA \n   
   >   
    ===================================================================== */
integer igraphdlaneg_(integer *n, doublereal *d__, doublereal *lld, doublereal *
	sigma, doublereal *pivmin, integer *r__)
{
    /* System generated locals */
    integer ret_val, i__1, i__2, i__3, i__4;

    /* Local variables */
    integer j;
    doublereal p, t;
    integer bj;
    doublereal tmp;
    integer neg1, neg2;
    doublereal bsav, gamma, dplus;
    extern logical igraphdisnan_(doublereal *);
    integer negcnt;
    logical sawnan;
    doublereal dminus;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   

       Some architectures propagate Infinities and NaNs very slowly, so   
       the code computes counts in BLKLEN chunks.  Then a NaN can   
       propagate at most BLKLEN columns before being detected.  This is   
       not a general tuning parameter; it needs only to be just large   
       enough that the overhead is tiny in common cases.   
       Parameter adjustments */
    --lld;
    --d__;

    /* Function Body */
    negcnt = 0;
/*     I) upper part: L D L^T - SIGMA I = L+ D+ L+^T */
    t = -(*sigma);
    i__1 = *r__ - 1;
    for (bj = 1; bj <= i__1; bj += 128) {
	neg1 = 0;
	bsav = t;
/* Computing MIN */
	i__3 = bj + 127, i__4 = *r__ - 1;
	i__2 = min(i__3,i__4);
	for (j = bj; j <= i__2; ++j) {
	    dplus = d__[j] + t;
	    if (dplus < 0.) {
		++neg1;
	    }
	    tmp = t / dplus;
	    t = tmp * lld[j] - *sigma;
/* L21: */
	}
	sawnan = igraphdisnan_(&t);
/*     Run a slower version of the above loop if a NaN is detected.   
       A NaN should occur only with a zero pivot after an infinite   
       pivot.  In that case, substituting 1 for T/DPLUS is the   
       correct limit. */
	if (sawnan) {
	    neg1 = 0;
	    t = bsav;
/* Computing MIN */
	    i__3 = bj + 127, i__4 = *r__ - 1;
	    i__2 = min(i__3,i__4);
	    for (j = bj; j <= i__2; ++j) {
		dplus = d__[j] + t;
		if (dplus < 0.) {
		    ++neg1;
		}
		tmp = t / dplus;
		if (igraphdisnan_(&tmp)) {
		    tmp = 1.;
		}
		t = tmp * lld[j] - *sigma;
/* L22: */
	    }
	}
	negcnt += neg1;
/* L210: */
    }

/*     II) lower part: L D L^T - SIGMA I = U- D- U-^T */
    p = d__[*n] - *sigma;
    i__1 = *r__;
    for (bj = *n - 1; bj >= i__1; bj += -128) {
	neg2 = 0;
	bsav = p;
/* Computing MAX */
	i__3 = bj - 127;
	i__2 = max(i__3,*r__);
	for (j = bj; j >= i__2; --j) {
	    dminus = lld[j] + p;
	    if (dminus < 0.) {
		++neg2;
	    }
	    tmp = p / dminus;
	    p = tmp * d__[j] - *sigma;
/* L23: */
	}
	sawnan = igraphdisnan_(&p);
/*     As above, run a slower version that substitutes 1 for Inf/Inf. */

	if (sawnan) {
	    neg2 = 0;
	    p = bsav;
/* Computing MAX */
	    i__3 = bj - 127;
	    i__2 = max(i__3,*r__);
	    for (j = bj; j >= i__2; --j) {
		dminus = lld[j] + p;
		if (dminus < 0.) {
		    ++neg2;
		}
		tmp = p / dminus;
		if (igraphdisnan_(&tmp)) {
		    tmp = 1.;
		}
		p = tmp * d__[j] - *sigma;
/* L24: */
	    }
	}
	negcnt += neg2;
/* L230: */
    }

/*     III) Twist index   
         T was shifted by SIGMA initially. */
    gamma = t + *sigma + p;
    if (gamma < 0.) {
	++negcnt;
    }
    ret_val = negcnt;
    return ret_val;
} /* igraphdlaneg_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlange.c0000644000175100001710000001532600000000000024007 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute 
value of any element of a general rectangular matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANGE + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DLANGE( NORM, M, N, A, LDA, WORK )   

         CHARACTER          NORM   
         INTEGER            LDA, M, N   
         DOUBLE PRECISION   A( LDA, * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANGE  returns the value of the one norm,  or the Frobenius norm, or   
   > the  infinity norm,  or the  element of  largest absolute value  of a   
   > real matrix A.   
   > \endverbatim   
   >   
   > \return DLANGE   
   > \verbatim   
   >   
   >    DLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'   
   >             (   
   >             ( norm1(A),         NORM = '1', 'O' or 'o'   
   >             (   
   >             ( normI(A),         NORM = 'I' or 'i'   
   >             (   
   >             ( normF(A),         NORM = 'F', 'f', 'E' or 'e'   
   >   
   > where  norm1  denotes the  one norm of a matrix (maximum column sum),   
   > normI  denotes the  infinity norm  of a matrix  (maximum row sum) and   
   > normF  denotes the  Frobenius norm of a matrix (square root of sum of   
   > squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] NORM   
   > \verbatim   
   >          NORM is CHARACTER*1   
   >          Specifies the value to be returned in DLANGE as described   
   >          above.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.  When M = 0,   
   >          DLANGE is set to zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.  When N = 0,   
   >          DLANGE is set to zero.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The m by n matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(M,1).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),   
   >          where LWORK >= M when NORM = 'I'; otherwise, WORK is not   
   >          referenced.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleGEauxiliary   

    ===================================================================== */
doublereal igraphdlange_(char *norm, integer *m, integer *n, doublereal *a, integer 
	*lda, doublereal *work)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;
    doublereal ret_val, d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j;
    doublereal sum, temp, scale;
    extern logical igraphlsame_(char *, char *);
    doublereal value = 0.;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
	    doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --work;

    /* Function Body */
    if (min(*m,*n) == 0) {
	value = 0.;
    } else if (igraphlsame_(norm, "M")) {

/*        Find max(abs(A(i,j))). */

	value = 0.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		temp = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		if (value < temp || igraphdisnan_(&temp)) {
		    value = temp;
		}
/* L10: */
	    }
/* L20: */
	}
    } else if (igraphlsame_(norm, "O") || *(unsigned char *)
	    norm == '1') {

/*        Find norm1(A). */

	value = 0.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = 0.;
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		sum += (d__1 = a[i__ + j * a_dim1], abs(d__1));
/* L30: */
	    }
	    if (value < sum || igraphdisnan_(&sum)) {
		value = sum;
	    }
/* L40: */
	}
    } else if (igraphlsame_(norm, "I")) {

/*        Find normI(A). */

	i__1 = *m;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    work[i__] = 0.;
/* L50: */
	}
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		work[i__] += (d__1 = a[i__ + j * a_dim1], abs(d__1));
/* L60: */
	    }
/* L70: */
	}
	value = 0.;
	i__1 = *m;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    temp = work[i__];
	    if (value < temp || igraphdisnan_(&temp)) {
		value = temp;
	    }
/* L80: */
	}
    } else if (igraphlsame_(norm, "F") || igraphlsame_(norm, "E")) {

/*        Find normF(A). */

	scale = 0.;
	sum = 1.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    igraphdlassq_(m, &a[j * a_dim1 + 1], &c__1, &scale, &sum);
/* L90: */
	}
	value = scale * sqrt(sum);
    }

    ret_val = value;
    return ret_val;

/*     End of DLANGE */

} /* igraphdlange_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlanhs.c0000644000175100001710000001551400000000000024025 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLANHS returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute 
value of any element of an upper Hessenberg matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANHS + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DLANHS( NORM, N, A, LDA, WORK )   

         CHARACTER          NORM   
         INTEGER            LDA, N   
         DOUBLE PRECISION   A( LDA, * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANHS  returns the value of the one norm,  or the Frobenius norm, or   
   > the  infinity norm,  or the  element of  largest absolute value  of a   
   > Hessenberg matrix A.   
   > \endverbatim   
   >   
   > \return DLANHS   
   > \verbatim   
   >   
   >    DLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'   
   >             (   
   >             ( norm1(A),         NORM = '1', 'O' or 'o'   
   >             (   
   >             ( normI(A),         NORM = 'I' or 'i'   
   >             (   
   >             ( normF(A),         NORM = 'F', 'f', 'E' or 'e'   
   >   
   > where  norm1  denotes the  one norm of a matrix (maximum column sum),   
   > normI  denotes the  infinity norm  of a matrix  (maximum row sum) and   
   > normF  denotes the  Frobenius norm of a matrix (square root of sum of   
   > squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] NORM   
   > \verbatim   
   >          NORM is CHARACTER*1   
   >          Specifies the value to be returned in DLANHS as described   
   >          above.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.  When N = 0, DLANHS is   
   >          set to zero.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The n by n upper Hessenberg matrix A; the part of A below the   
   >          first sub-diagonal is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(N,1).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),   
   >          where LWORK >= N when NORM = 'I'; otherwise, WORK is not   
   >          referenced.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    ===================================================================== */
doublereal igraphdlanhs_(char *norm, integer *n, doublereal *a, integer *lda, 
	doublereal *work)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
    doublereal ret_val, d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j;
    doublereal sum, scale;
    extern logical igraphlsame_(char *, char *);
    doublereal value = 0.;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
	    doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --work;

    /* Function Body */
    if (*n == 0) {
	value = 0.;
    } else if (igraphlsame_(norm, "M")) {

/*        Find max(abs(A(i,j))). */

	value = 0.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = *n, i__4 = j + 1;
	    i__2 = min(i__3,i__4);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		sum = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		if (value < sum || igraphdisnan_(&sum)) {
		    value = sum;
		}
/* L10: */
	    }
/* L20: */
	}
    } else if (igraphlsame_(norm, "O") || *(unsigned char *)
	    norm == '1') {

/*        Find norm1(A). */

	value = 0.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = 0.;
/* Computing MIN */
	    i__3 = *n, i__4 = j + 1;
	    i__2 = min(i__3,i__4);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		sum += (d__1 = a[i__ + j * a_dim1], abs(d__1));
/* L30: */
	    }
	    if (value < sum || igraphdisnan_(&sum)) {
		value = sum;
	    }
/* L40: */
	}
    } else if (igraphlsame_(norm, "I")) {

/*        Find normI(A). */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    work[i__] = 0.;
/* L50: */
	}
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = *n, i__4 = j + 1;
	    i__2 = min(i__3,i__4);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		work[i__] += (d__1 = a[i__ + j * a_dim1], abs(d__1));
/* L60: */
	    }
/* L70: */
	}
	value = 0.;
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    sum = work[i__];
	    if (value < sum || igraphdisnan_(&sum)) {
		value = sum;
	    }
/* L80: */
	}
    } else if (igraphlsame_(norm, "F") || igraphlsame_(norm, "E")) {

/*        Find normF(A). */

	scale = 0.;
	sum = 1.;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = *n, i__4 = j + 1;
	    i__2 = min(i__3,i__4);
	    igraphdlassq_(&i__2, &a[j * a_dim1 + 1], &c__1, &scale, &sum);
/* L90: */
	}
	value = scale * sqrt(sum);
    }

    ret_val = value;
    return ret_val;

/*     End of DLANHS */

} /* igraphdlanhs_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlanst.c0000644000175100001710000001376200000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLANST returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the ele
ment of largest absolute value of a real symmetric tridiagonal matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANST + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DLANST( NORM, N, D, E )   

         CHARACTER          NORM   
         INTEGER            N   
         DOUBLE PRECISION   D( * ), E( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANST  returns the value of the one norm,  or the Frobenius norm, or   
   > the  infinity norm,  or the  element of  largest absolute value  of a   
   > real symmetric tridiagonal matrix A.   
   > \endverbatim   
   >   
   > \return DLANST   
   > \verbatim   
   >   
   >    DLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'   
   >             (   
   >             ( norm1(A),         NORM = '1', 'O' or 'o'   
   >             (   
   >             ( normI(A),         NORM = 'I' or 'i'   
   >             (   
   >             ( normF(A),         NORM = 'F', 'f', 'E' or 'e'   
   >   
   > where  norm1  denotes the  one norm of a matrix (maximum column sum),   
   > normI  denotes the  infinity norm  of a matrix  (maximum row sum) and   
   > normF  denotes the  Frobenius norm of a matrix (square root of sum of   
   > squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] NORM   
   > \verbatim   
   >          NORM is CHARACTER*1   
   >          Specifies the value to be returned in DLANST as described   
   >          above.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.  When N = 0, DLANST is   
   >          set to zero.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The diagonal elements of A.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) sub-diagonal or super-diagonal elements of A.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
doublereal igraphdlanst_(char *norm, integer *n, doublereal *d__, doublereal *e)
{
    /* System generated locals */
    integer i__1;
    doublereal ret_val, d__1, d__2, d__3;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal sum, scale;
    extern logical igraphlsame_(char *, char *);
    doublereal anorm;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
	    doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --e;
    --d__;

    /* Function Body */
    if (*n <= 0) {
	anorm = 0.;
    } else if (igraphlsame_(norm, "M")) {

/*        Find max(abs(A(i,j))). */

	anorm = (d__1 = d__[*n], abs(d__1));
	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    sum = (d__1 = d__[i__], abs(d__1));
	    if (anorm < sum || igraphdisnan_(&sum)) {
		anorm = sum;
	    }
	    sum = (d__1 = e[i__], abs(d__1));
	    if (anorm < sum || igraphdisnan_(&sum)) {
		anorm = sum;
	    }
/* L10: */
	}
    } else if (igraphlsame_(norm, "O") || *(unsigned char *)
	    norm == '1' || igraphlsame_(norm, "I")) {

/*        Find norm1(A). */

	if (*n == 1) {
	    anorm = abs(d__[1]);
	} else {
	    anorm = abs(d__[1]) + abs(e[1]);
	    sum = (d__1 = e[*n - 1], abs(d__1)) + (d__2 = d__[*n], abs(d__2));
	    if (anorm < sum || igraphdisnan_(&sum)) {
		anorm = sum;
	    }
	    i__1 = *n - 1;
	    for (i__ = 2; i__ <= i__1; ++i__) {
		sum = (d__1 = d__[i__], abs(d__1)) + (d__2 = e[i__], abs(d__2)
			) + (d__3 = e[i__ - 1], abs(d__3));
		if (anorm < sum || igraphdisnan_(&sum)) {
		    anorm = sum;
		}
/* L20: */
	    }
	}
    } else if (igraphlsame_(norm, "F") || igraphlsame_(norm, "E")) {

/*        Find normF(A). */

	scale = 0.;
	sum = 1.;
	if (*n > 1) {
	    i__1 = *n - 1;
	    igraphdlassq_(&i__1, &e[1], &c__1, &scale, &sum);
	    sum *= 2;
	}
	igraphdlassq_(n, &d__[1], &c__1, &scale, &sum);
	anorm = scale * sqrt(sum);
    }

    ret_val = anorm;
    return ret_val;

/*     End of DLANST */

} /* igraphdlanst_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlansy.c0000644000175100001710000002026400000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the ele
ment of largest absolute value of a real symmetric matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANSY + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DLANSY( NORM, UPLO, N, A, LDA, WORK )   

         CHARACTER          NORM, UPLO   
         INTEGER            LDA, N   
         DOUBLE PRECISION   A( LDA, * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANSY  returns the value of the one norm,  or the Frobenius norm, or   
   > the  infinity norm,  or the  element of  largest absolute value  of a   
   > real symmetric matrix A.   
   > \endverbatim   
   >   
   > \return DLANSY   
   > \verbatim   
   >   
   >    DLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm'   
   >             (   
   >             ( norm1(A),         NORM = '1', 'O' or 'o'   
   >             (   
   >             ( normI(A),         NORM = 'I' or 'i'   
   >             (   
   >             ( normF(A),         NORM = 'F', 'f', 'E' or 'e'   
   >   
   > where  norm1  denotes the  one norm of a matrix (maximum column sum),   
   > normI  denotes the  infinity norm  of a matrix  (maximum row sum) and   
   > normF  denotes the  Frobenius norm of a matrix (square root of sum of   
   > squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] NORM   
   > \verbatim   
   >          NORM is CHARACTER*1   
   >          Specifies the value to be returned in DLANSY as described   
   >          above.   
   > \endverbatim   
   >   
   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies whether the upper or lower triangular part of the   
   >          symmetric matrix A is to be referenced.   
   >          = 'U':  Upper triangular part of A is referenced   
   >          = 'L':  Lower triangular part of A is referenced   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.  When N = 0, DLANSY is   
   >          set to zero.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The symmetric matrix A.  If UPLO = 'U', the leading n by n   
   >          upper triangular part of A contains the upper triangular part   
   >          of the matrix A, and the strictly lower triangular part of A   
   >          is not referenced.  If UPLO = 'L', the leading n by n lower   
   >          triangular part of A contains the lower triangular part of   
   >          the matrix A, and the strictly upper triangular part of A is   
   >          not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(N,1).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),   
   >          where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,   
   >          WORK is not referenced.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleSYauxiliary   

    ===================================================================== */
doublereal igraphdlansy_(char *norm, char *uplo, integer *n, doublereal *a, integer 
	*lda, doublereal *work)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;
    doublereal ret_val, d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j;
    doublereal sum, absa, scale;
    extern logical igraphlsame_(char *, char *);
    doublereal value;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphdlassq_(integer *, doublereal *, integer *, 
	    doublereal *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --work;

    /* Function Body */
    if (*n == 0) {
	value = 0.;
    } else if (igraphlsame_(norm, "M")) {

/*        Find max(abs(A(i,j))). */

	value = 0.;
	if (igraphlsame_(uplo, "U")) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = j;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    sum = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		    if (value < sum || igraphdisnan_(&sum)) {
			value = sum;
		    }
/* L10: */
		}
/* L20: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *n;
		for (i__ = j; i__ <= i__2; ++i__) {
		    sum = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		    if (value < sum || igraphdisnan_(&sum)) {
			value = sum;
		    }
/* L30: */
		}
/* L40: */
	    }
	}
    } else if (igraphlsame_(norm, "I") || igraphlsame_(norm, "O") || *(unsigned char *)norm == '1') {

/*        Find normI(A) ( = norm1(A), since A is symmetric). */

	value = 0.;
	if (igraphlsame_(uplo, "U")) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		sum = 0.;
		i__2 = j - 1;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    absa = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		    sum += absa;
		    work[i__] += absa;
/* L50: */
		}
		work[j] = sum + (d__1 = a[j + j * a_dim1], abs(d__1));
/* L60: */
	    }
	    i__1 = *n;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		sum = work[i__];
		if (value < sum || igraphdisnan_(&sum)) {
		    value = sum;
		}
/* L70: */
	    }
	} else {
	    i__1 = *n;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		work[i__] = 0.;
/* L80: */
	    }
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		sum = work[j] + (d__1 = a[j + j * a_dim1], abs(d__1));
		i__2 = *n;
		for (i__ = j + 1; i__ <= i__2; ++i__) {
		    absa = (d__1 = a[i__ + j * a_dim1], abs(d__1));
		    sum += absa;
		    work[i__] += absa;
/* L90: */
		}
		if (value < sum || igraphdisnan_(&sum)) {
		    value = sum;
		}
/* L100: */
	    }
	}
    } else if (igraphlsame_(norm, "F") || igraphlsame_(norm, "E")) {

/*        Find normF(A). */

	scale = 0.;
	sum = 1.;
	if (igraphlsame_(uplo, "U")) {
	    i__1 = *n;
	    for (j = 2; j <= i__1; ++j) {
		i__2 = j - 1;
		igraphdlassq_(&i__2, &a[j * a_dim1 + 1], &c__1, &scale, &sum);
/* L110: */
	    }
	} else {
	    i__1 = *n - 1;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *n - j;
		igraphdlassq_(&i__2, &a[j + 1 + j * a_dim1], &c__1, &scale, &sum);
/* L120: */
	    }
	}
	sum *= 2;
	i__1 = *lda + 1;
	igraphdlassq_(n, &a[a_offset], &i__1, &scale, &sum);
	value = scale * sqrt(sum);
    }

    ret_val = value;
    return ret_val;

/*     End of DLANSY */

} /* igraphdlansy_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlanv2.c0000644000175100001710000001773500000000000023751 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b4 = 1.;

/* > \brief \b DLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form. 
  

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLANV2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLANV2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN )   

         DOUBLE PRECISION   A, B, C, CS, D, RT1I, RT1R, RT2I, RT2R, SN   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric   
   > matrix in standard form:   
   >   
   >      [ A  B ] = [ CS -SN ] [ AA  BB ] [ CS  SN ]   
   >      [ C  D ]   [ SN  CS ] [ CC  DD ] [-SN  CS ]   
   >   
   > where either   
   > 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or   
   > 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex   
   > conjugate eigenvalues.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION   
   >          On entry, the elements of the input matrix.   
   >          On exit, they are overwritten by the elements of the   
   >          standardised Schur form.   
   > \endverbatim   
   >   
   > \param[out] RT1R   
   > \verbatim   
   >          RT1R is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] RT1I   
   > \verbatim   
   >          RT1I is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] RT2R   
   > \verbatim   
   >          RT2R is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] RT2I   
   > \verbatim   
   >          RT2I is DOUBLE PRECISION   
   >          The real and imaginary parts of the eigenvalues. If the   
   >          eigenvalues are a complex conjugate pair, RT1I > 0.   
   > \endverbatim   
   >   
   > \param[out] CS   
   > \verbatim   
   >          CS is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] SN   
   > \verbatim   
   >          SN is DOUBLE PRECISION   
   >          Parameters of the rotation matrix.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Modified by V. Sima, Research Institute for Informatics, Bucharest,   
   >  Romania, to reduce the risk of cancellation errors,   
   >  when computing real eigenvalues, and to ensure, if possible, that   
   >  abs(RT1R) >= abs(RT2R).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlanv2_(doublereal *a, doublereal *b, doublereal *c__, 
	doublereal *d__, doublereal *rt1r, doublereal *rt1i, doublereal *rt2r,
	 doublereal *rt2i, doublereal *cs, doublereal *sn)
{
    /* System generated locals */
    doublereal d__1, d__2;

    /* Builtin functions */
    double d_sign(doublereal *, doublereal *), sqrt(doublereal);

    /* Local variables */
    doublereal p, z__, aa, bb, cc, dd, cs1, sn1, sab, sac, eps, tau, temp, 
	    scale, bcmax, bcmis, sigma;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ===================================================================== */


    eps = igraphdlamch_("P");
    if (*c__ == 0.) {
	*cs = 1.;
	*sn = 0.;
	goto L10;

    } else if (*b == 0.) {

/*        Swap rows and columns */

	*cs = 0.;
	*sn = 1.;
	temp = *d__;
	*d__ = *a;
	*a = temp;
	*b = -(*c__);
	*c__ = 0.;
	goto L10;
    } else if (*a - *d__ == 0. && d_sign(&c_b4, b) != d_sign(&c_b4, c__)) {
	*cs = 1.;
	*sn = 0.;
	goto L10;
    } else {

	temp = *a - *d__;
	p = temp * .5;
/* Computing MAX */
	d__1 = abs(*b), d__2 = abs(*c__);
	bcmax = max(d__1,d__2);
/* Computing MIN */
	d__1 = abs(*b), d__2 = abs(*c__);
	bcmis = min(d__1,d__2) * d_sign(&c_b4, b) * d_sign(&c_b4, c__);
/* Computing MAX */
	d__1 = abs(p);
	scale = max(d__1,bcmax);
	z__ = p / scale * p + bcmax / scale * bcmis;

/*        If Z is of the order of the machine accuracy, postpone the   
          decision on the nature of eigenvalues */

	if (z__ >= eps * 4.) {

/*           Real eigenvalues. Compute A and D. */

	    d__1 = sqrt(scale) * sqrt(z__);
	    z__ = p + d_sign(&d__1, &p);
	    *a = *d__ + z__;
	    *d__ -= bcmax / z__ * bcmis;

/*           Compute B and the rotation matrix */

	    tau = igraphdlapy2_(c__, &z__);
	    *cs = z__ / tau;
	    *sn = *c__ / tau;
	    *b -= *c__;
	    *c__ = 0.;
	} else {

/*           Complex eigenvalues, or real (almost) equal eigenvalues.   
             Make diagonal elements equal. */

	    sigma = *b + *c__;
	    tau = igraphdlapy2_(&sigma, &temp);
	    *cs = sqrt((abs(sigma) / tau + 1.) * .5);
	    *sn = -(p / (tau * *cs)) * d_sign(&c_b4, &sigma);

/*           Compute [ AA  BB ] = [ A  B ] [ CS -SN ]   
                     [ CC  DD ]   [ C  D ] [ SN  CS ] */

	    aa = *a * *cs + *b * *sn;
	    bb = -(*a) * *sn + *b * *cs;
	    cc = *c__ * *cs + *d__ * *sn;
	    dd = -(*c__) * *sn + *d__ * *cs;

/*           Compute [ A  B ] = [ CS  SN ] [ AA  BB ]   
                     [ C  D ]   [-SN  CS ] [ CC  DD ] */

	    *a = aa * *cs + cc * *sn;
	    *b = bb * *cs + dd * *sn;
	    *c__ = -aa * *sn + cc * *cs;
	    *d__ = -bb * *sn + dd * *cs;

	    temp = (*a + *d__) * .5;
	    *a = temp;
	    *d__ = temp;

	    if (*c__ != 0.) {
		if (*b != 0.) {
		    if (d_sign(&c_b4, b) == d_sign(&c_b4, c__)) {

/*                    Real eigenvalues: reduce to upper triangular form */

			sab = sqrt((abs(*b)));
			sac = sqrt((abs(*c__)));
			d__1 = sab * sac;
			p = d_sign(&d__1, c__);
			tau = 1. / sqrt((d__1 = *b + *c__, abs(d__1)));
			*a = temp + p;
			*d__ = temp - p;
			*b -= *c__;
			*c__ = 0.;
			cs1 = sab * tau;
			sn1 = sac * tau;
			temp = *cs * cs1 - *sn * sn1;
			*sn = *cs * sn1 + *sn * cs1;
			*cs = temp;
		    }
		} else {
		    *b = -(*c__);
		    *c__ = 0.;
		    temp = *cs;
		    *cs = -(*sn);
		    *sn = temp;
		}
	    }
	}

    }

L10:

/*     Store eigenvalues in (RT1R,RT1I) and (RT2R,RT2I). */

    *rt1r = *a;
    *rt2r = *d__;
    if (*c__ == 0.) {
	*rt1i = 0.;
	*rt2i = 0.;
    } else {
	*rt1i = sqrt((abs(*b))) * sqrt((abs(*c__)));
	*rt2i = -(*rt1i);
    }
    return 0;

/*     End of DLANV2 */

} /* igraphdlanv2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlapy2.c0000644000175100001710000000562000000000000023744 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAPY2 returns sqrt(x2+y2).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAPY2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DLAPY2( X, Y )   

         DOUBLE PRECISION   X, Y   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary   
   > overflow.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION   
   >          X and Y specify the values x and y.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
doublereal igraphdlapy2_(doublereal *x, doublereal *y)
{
    /* System generated locals */
    doublereal ret_val, d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal w, z__, xabs, yabs;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ===================================================================== */


    xabs = abs(*x);
    yabs = abs(*y);
    w = max(xabs,yabs);
    z__ = min(xabs,yabs);
    if (z__ == 0.) {
	ret_val = w;
    } else {
/* Computing 2nd power */
	d__1 = z__ / w;
	ret_val = w * sqrt(d__1 * d__1 + 1.);
    }
    return ret_val;

/*     End of DLAPY2 */

} /* igraphdlapy2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr0.c0000644000175100001710000007054700000000000023746 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__13 = 13;
static integer c__15 = 15;
static integer c_n1 = -1;
static integer c__12 = 12;
static integer c__14 = 14;
static integer c__16 = 16;
static logical c_false = FALSE_;
static integer c__1 = 1;
static integer c__3 = 3;

/* > \brief \b DLAQR0 computes the eigenvalues of a Hessenberg matrix, and optionally the matrices from the Sc
hur decomposition.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR0 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR0( WANTT, WANTZ, N, ILO, IHI, H, LDH, WR, WI,   
                            ILOZ, IHIZ, Z, LDZ, WORK, LWORK, INFO )   

         INTEGER            IHI, IHIZ, ILO, ILOZ, INFO, LDH, LDZ, LWORK, N   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), WI( * ), WORK( * ), WR( * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DLAQR0 computes the eigenvalues of a Hessenberg matrix H   
   >    and, optionally, the matrices T and Z from the Schur decomposition   
   >    H = Z T Z**T, where T is an upper quasi-triangular matrix (the   
   >    Schur form), and Z is the orthogonal matrix of Schur vectors.   
   >   
   >    Optionally Z may be postmultiplied into an input orthogonal   
   >    matrix Q so that this routine can give the Schur factorization   
   >    of a matrix A which has been reduced to the Hessenberg form H   
   >    by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is LOGICAL   
   >          = .TRUE. : the full Schur form T is required;   
   >          = .FALSE.: only eigenvalues are required.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is LOGICAL   
   >          = .TRUE. : the matrix of Schur vectors Z is required;   
   >          = .FALSE.: Schur vectors are not required.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           The order of the matrix H.  N .GE. 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >           It is assumed that H is already upper triangular in rows   
   >           and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,   
   >           H(ILO,ILO-1) is zero. ILO and IHI are normally set by a   
   >           previous call to DGEBAL, and then passed to DGEHRD when the   
   >           matrix output by DGEBAL is reduced to Hessenberg form.   
   >           Otherwise, ILO and IHI should be set to 1 and N,   
   >           respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.   
   >           If N = 0, then ILO = 1 and IHI = 0.   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >           On entry, the upper Hessenberg matrix H.   
   >           On exit, if INFO = 0 and WANTT is .TRUE., then H contains   
   >           the upper quasi-triangular matrix T from the Schur   
   >           decomposition (the Schur form); 2-by-2 diagonal blocks   
   >           (corresponding to complex conjugate pairs of eigenvalues)   
   >           are returned in standard form, with H(i,i) = H(i+1,i+1)   
   >           and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is   
   >           .FALSE., then the contents of H are unspecified on exit.   
   >           (The output value of H when INFO.GT.0 is given under the   
   >           description of INFO below.)   
   >   
   >           This subroutine may explicitly set H(i,j) = 0 for i.GT.j and   
   >           j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is INTEGER   
   >           The leading dimension of the array H. LDH .GE. max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (IHI)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (IHI)   
   >           The real and imaginary parts, respectively, of the computed   
   >           eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)   
   >           and WI(ILO:IHI). If two eigenvalues are computed as a   
   >           complex conjugate pair, they are stored in consecutive   
   >           elements of WR and WI, say the i-th and (i+1)th, with   
   >           WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then   
   >           the eigenvalues are stored in the same order as on the   
   >           diagonal of the Schur form returned in H, with   
   >           WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal   
   >           block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and   
   >           WI(i+1) = -WI(i).   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >           Specify the rows of Z to which transformations must be   
   >           applied if WANTZ is .TRUE..   
   >           1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,IHI)   
   >           If WANTZ is .FALSE., then Z is not referenced.   
   >           If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is   
   >           replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the   
   >           orthogonal Schur factor of H(ILO:IHI,ILO:IHI).   
   >           (The output value of Z when INFO.GT.0 is given under   
   >           the description of INFO below.)   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >           The leading dimension of the array Z.  if WANTZ is .TRUE.   
   >           then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension LWORK   
   >           On exit, if LWORK = -1, WORK(1) returns an estimate of   
   >           the optimal value for LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >           The dimension of the array WORK.  LWORK .GE. max(1,N)   
   >           is sufficient, but LWORK typically as large as 6*N may   
   >           be required for optimal performance.  A workspace query   
   >           to determine the optimal workspace size is recommended.   
   >   
   >           If LWORK = -1, then DLAQR0 does a workspace query.   
   >           In this case, DLAQR0 checks the input parameters and   
   >           estimates the optimal workspace size for the given   
   >           values of N, ILO and IHI.  The estimate is returned   
   >           in WORK(1).  No error message related to LWORK is   
   >           issued by XERBLA.  Neither H nor Z are accessed.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >             =  0:  successful exit   
   >           .GT. 0:  if INFO = i, DLAQR0 failed to compute all of   
   >                the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR   
   >                and WI contain those eigenvalues which have been   
   >                successfully computed.  (Failures are rare.)   
   >   
   >                If INFO .GT. 0 and WANT is .FALSE., then on exit,   
   >                the remaining unconverged eigenvalues are the eigen-   
   >                values of the upper Hessenberg matrix rows and   
   >                columns ILO through INFO of the final, output   
   >                value of H.   
   >   
   >                If INFO .GT. 0 and WANTT is .TRUE., then on exit   
   >   
   >           (*)  (initial value of H)*U  = U*(final value of H)   
   >   
   >                where U is an orthogonal matrix.  The final   
   >                value of H is upper Hessenberg and quasi-triangular   
   >                in rows and columns INFO+1 through IHI.   
   >   
   >                If INFO .GT. 0 and WANTZ is .TRUE., then on exit   
   >   
   >                  (final value of Z(ILO:IHI,ILOZ:IHIZ)   
   >                   =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U   
   >   
   >                where U is the orthogonal matrix in (*) (regard-   
   >                less of the value of WANTT.)   
   >   
   >                If INFO .GT. 0 and WANTZ is .FALSE., then Z is not   
   >                accessed.   
   > \endverbatim   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   

   > \par References:   
    ================   
   >   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part I: Maintaining Well Focused Shifts, and Level 3   
   >       Performance, SIAM Journal of Matrix Analysis, volume 23, pages   
   >       929--947, 2002.   
   > \n   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part II: Aggressive Early Deflation, SIAM Journal   
   >       of Matrix Analysis, volume 23, pages 948--973, 2002.   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlaqr0_(logical *wantt, logical *wantz, integer *n, 
	integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
	*wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
	integer *ldz, doublereal *work, integer *lwork, integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, z_dim1, z_offset, i__1, i__2, i__3, i__4, i__5;
    doublereal d__1, d__2, d__3, d__4;

    /* Local variables */
    integer i__, k;
    doublereal aa, bb, cc, dd;
    integer ld;
    doublereal cs;
    integer nh, it, ks, kt;
    doublereal sn;
    integer ku, kv, ls, ns;
    doublereal ss;
    integer nw, inf, kdu, nho, nve, kwh, nsr, nwr, kwv, ndec, ndfl, kbot, 
	    nmin;
    doublereal swap;
    integer ktop;
    doublereal zdum[1]	/* was [1][1] */;
    integer kacc22, itmax, nsmax, nwmax, kwtop;
    extern /* Subroutine */ int igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlaqr3_(
	    logical *, logical *, integer *, integer *, integer *, integer *, 
	    doublereal *, integer *, integer *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *), 
	    igraphdlaqr4_(logical *, logical *, integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *, 
	    integer *), igraphdlaqr5_(logical *, logical *, integer *, integer *, 
	    integer *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, doublereal *, integer *, 
	    integer *, doublereal *, integer *, integer *, doublereal *, 
	    integer *);
    integer nibble;
    extern /* Subroutine */ int igraphdlahqr_(logical *, logical *, integer *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *), igraphdlacpy_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    char jbcmpz[2];
    integer nwupbd;
    logical sorted;
    integer lwkopt;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   


       ==== Matrices of order NTINY or smaller must be processed by   
       .    DLAHQR because of insufficient subdiagonal scratch space.   
       .    (This is a hard limit.) ====   

       ==== Exceptional deflation windows:  try to cure rare   
       .    slow convergence by varying the size of the   
       .    deflation window after KEXNW iterations. ====   

       ==== Exceptional shifts: try to cure rare slow convergence   
       .    with ad-hoc exceptional shifts every KEXSH iterations.   
       .    ====   

       ==== The constants WILK1 and WILK2 are used to form the   
       .    exceptional shifts. ====   
       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --wr;
    --wi;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --work;

    /* Function Body */
    *info = 0;

/*     ==== Quick return for N = 0: nothing to do. ==== */

    if (*n == 0) {
	work[1] = 1.;
	return 0;
    }

    if (*n <= 11) {

/*        ==== Tiny matrices must use DLAHQR. ==== */

	lwkopt = 1;
	if (*lwork != -1) {
	    igraphdlahqr_(wantt, wantz, n, ilo, ihi, &h__[h_offset], ldh, &wr[1], &
		    wi[1], iloz, ihiz, &z__[z_offset], ldz, info);
	}
    } else {

/*        ==== Use small bulge multi-shift QR with aggressive early   
          .    deflation on larger-than-tiny matrices. ====   

          ==== Hope for the best. ==== */

	*info = 0;

/*        ==== Set up job flags for ILAENV. ==== */

	if (*wantt) {
	    *(unsigned char *)jbcmpz = 'S';
	} else {
	    *(unsigned char *)jbcmpz = 'E';
	}
	if (*wantz) {
	    *(unsigned char *)&jbcmpz[1] = 'V';
	} else {
	    *(unsigned char *)&jbcmpz[1] = 'N';
	}

/*        ==== NWR = recommended deflation window size.  At this   
          .    point,  N .GT. NTINY = 11, so there is enough   
          .    subdiagonal workspace for NWR.GE.2 as required.   
          .    (In fact, there is enough subdiagonal space for   
          .    NWR.GE.3.) ==== */

	nwr = igraphilaenv_(&c__13, "DLAQR0", jbcmpz, n, ilo, ihi, lwork, (ftnlen)6,
		 (ftnlen)2);
	nwr = max(2,nwr);
/* Computing MIN */
	i__1 = *ihi - *ilo + 1, i__2 = (*n - 1) / 3, i__1 = min(i__1,i__2);
	nwr = min(i__1,nwr);

/*        ==== NSR = recommended number of simultaneous shifts.   
          .    At this point N .GT. NTINY = 11, so there is at   
          .    enough subdiagonal workspace for NSR to be even   
          .    and greater than or equal to two as required. ==== */

	nsr = igraphilaenv_(&c__15, "DLAQR0", jbcmpz, n, ilo, ihi, lwork, (ftnlen)6,
		 (ftnlen)2);
/* Computing MIN */
	i__1 = nsr, i__2 = (*n + 6) / 9, i__1 = min(i__1,i__2), i__2 = *ihi - 
		*ilo;
	nsr = min(i__1,i__2);
/* Computing MAX */
	i__1 = 2, i__2 = nsr - nsr % 2;
	nsr = max(i__1,i__2);

/*        ==== Estimate optimal workspace ====   

          ==== Workspace query call to DLAQR3 ==== */

	i__1 = nwr + 1;
	igraphdlaqr3_(wantt, wantz, n, ilo, ihi, &i__1, &h__[h_offset], ldh, iloz, 
		ihiz, &z__[z_offset], ldz, &ls, &ld, &wr[1], &wi[1], &h__[
		h_offset], ldh, n, &h__[h_offset], ldh, n, &h__[h_offset], 
		ldh, &work[1], &c_n1);

/*        ==== Optimal workspace = MAX(DLAQR5, DLAQR3) ====   

   Computing MAX */
	i__1 = nsr * 3 / 2, i__2 = (integer) work[1];
	lwkopt = max(i__1,i__2);

/*        ==== Quick return in case of workspace query. ==== */

	if (*lwork == -1) {
	    work[1] = (doublereal) lwkopt;
	    return 0;
	}

/*        ==== DLAHQR/DLAQR0 crossover point ==== */

	nmin = igraphilaenv_(&c__12, "DLAQR0", jbcmpz, n, ilo, ihi, lwork, (ftnlen)
		6, (ftnlen)2);
	nmin = max(11,nmin);

/*        ==== Nibble crossover point ==== */

	nibble = igraphilaenv_(&c__14, "DLAQR0", jbcmpz, n, ilo, ihi, lwork, (
		ftnlen)6, (ftnlen)2);
	nibble = max(0,nibble);

/*        ==== Accumulate reflections during ttswp?  Use block   
          .    2-by-2 structure during matrix-matrix multiply? ==== */

	kacc22 = igraphilaenv_(&c__16, "DLAQR0", jbcmpz, n, ilo, ihi, lwork, (
		ftnlen)6, (ftnlen)2);
	kacc22 = max(0,kacc22);
	kacc22 = min(2,kacc22);

/*        ==== NWMAX = the largest possible deflation window for   
          .    which there is sufficient workspace. ====   

   Computing MIN */
	i__1 = (*n - 1) / 3, i__2 = *lwork / 2;
	nwmax = min(i__1,i__2);
	nw = nwmax;

/*        ==== NSMAX = the Largest number of simultaneous shifts   
          .    for which there is sufficient workspace. ====   

   Computing MIN */
	i__1 = (*n + 6) / 9, i__2 = (*lwork << 1) / 3;
	nsmax = min(i__1,i__2);
	nsmax -= nsmax % 2;

/*        ==== NDFL: an iteration count restarted at deflation. ==== */

	ndfl = 1;

/*        ==== ITMAX = iteration limit ====   

   Computing MAX */
	i__1 = 10, i__2 = *ihi - *ilo + 1;
	itmax = max(i__1,i__2) * 30;

/*        ==== Last row and column in the active block ==== */

	kbot = *ihi;

/*        ==== Main Loop ==== */

	i__1 = itmax;
	for (it = 1; it <= i__1; ++it) {

/*           ==== Done when KBOT falls below ILO ==== */

	    if (kbot < *ilo) {
		goto L90;
	    }

/*           ==== Locate active block ==== */

	    i__2 = *ilo + 1;
	    for (k = kbot; k >= i__2; --k) {
		if (h__[k + (k - 1) * h_dim1] == 0.) {
		    goto L20;
		}
/* L10: */
	    }
	    k = *ilo;
L20:
	    ktop = k;

/*           ==== Select deflation window size:   
             .    Typical Case:   
             .      If possible and advisable, nibble the entire   
             .      active block.  If not, use size MIN(NWR,NWMAX)   
             .      or MIN(NWR+1,NWMAX) depending upon which has   
             .      the smaller corresponding subdiagonal entry   
             .      (a heuristic).   
             .   
             .    Exceptional Case:   
             .      If there have been no deflations in KEXNW or   
             .      more iterations, then vary the deflation window   
             .      size.   At first, because, larger windows are,   
             .      in general, more powerful than smaller ones,   
             .      rapidly increase the window to the maximum possible.   
             .      Then, gradually reduce the window size. ==== */

	    nh = kbot - ktop + 1;
	    nwupbd = min(nh,nwmax);
	    if (ndfl < 5) {
		nw = min(nwupbd,nwr);
	    } else {
/* Computing MIN */
		i__2 = nwupbd, i__3 = nw << 1;
		nw = min(i__2,i__3);
	    }
	    if (nw < nwmax) {
		if (nw >= nh - 1) {
		    nw = nh;
		} else {
		    kwtop = kbot - nw + 1;
		    if ((d__1 = h__[kwtop + (kwtop - 1) * h_dim1], abs(d__1)) 
			    > (d__2 = h__[kwtop - 1 + (kwtop - 2) * h_dim1], 
			    abs(d__2))) {
			++nw;
		    }
		}
	    }
	    if (ndfl < 5) {
		ndec = -1;
	    } else if (ndec >= 0 || nw >= nwupbd) {
		++ndec;
		if (nw - ndec < 2) {
		    ndec = 0;
		}
		nw -= ndec;
	    }

/*           ==== Aggressive early deflation:   
             .    split workspace under the subdiagonal into   
             .      - an nw-by-nw work array V in the lower   
             .        left-hand-corner,   
             .      - an NW-by-at-least-NW-but-more-is-better   
             .        (NW-by-NHO) horizontal work array along   
             .        the bottom edge,   
             .      - an at-least-NW-but-more-is-better (NHV-by-NW)   
             .        vertical work array along the left-hand-edge.   
             .        ==== */

	    kv = *n - nw + 1;
	    kt = nw + 1;
	    nho = *n - nw - 1 - kt + 1;
	    kwv = nw + 2;
	    nve = *n - nw - kwv + 1;

/*           ==== Aggressive early deflation ==== */

	    igraphdlaqr3_(wantt, wantz, n, &ktop, &kbot, &nw, &h__[h_offset], ldh, 
		    iloz, ihiz, &z__[z_offset], ldz, &ls, &ld, &wr[1], &wi[1],
		     &h__[kv + h_dim1], ldh, &nho, &h__[kv + kt * h_dim1], 
		    ldh, &nve, &h__[kwv + h_dim1], ldh, &work[1], lwork);

/*           ==== Adjust KBOT accounting for new deflations. ==== */

	    kbot -= ld;

/*           ==== KS points to the shifts. ==== */

	    ks = kbot - ls + 1;

/*           ==== Skip an expensive QR sweep if there is a (partly   
             .    heuristic) reason to expect that many eigenvalues   
             .    will deflate without it.  Here, the QR sweep is   
             .    skipped if many eigenvalues have just been deflated   
             .    or if the remaining active block is small. */

	    if (ld == 0 || ld * 100 <= nw * nibble && kbot - ktop + 1 > min(
		    nmin,nwmax)) {

/*              ==== NS = nominal number of simultaneous shifts.   
                .    This may be lowered (slightly) if DLAQR3   
                .    did not provide that many shifts. ====   

   Computing MIN   
   Computing MAX */
		i__4 = 2, i__5 = kbot - ktop;
		i__2 = min(nsmax,nsr), i__3 = max(i__4,i__5);
		ns = min(i__2,i__3);
		ns -= ns % 2;

/*              ==== If there have been no deflations   
                .    in a multiple of KEXSH iterations,   
                .    then try exceptional shifts.   
                .    Otherwise use shifts provided by   
                .    DLAQR3 above or from the eigenvalues   
                .    of a trailing principal submatrix. ==== */

		if (ndfl % 6 == 0) {
		    ks = kbot - ns + 1;
/* Computing MAX */
		    i__3 = ks + 1, i__4 = ktop + 2;
		    i__2 = max(i__3,i__4);
		    for (i__ = kbot; i__ >= i__2; i__ += -2) {
			ss = (d__1 = h__[i__ + (i__ - 1) * h_dim1], abs(d__1))
				 + (d__2 = h__[i__ - 1 + (i__ - 2) * h_dim1], 
				abs(d__2));
			aa = ss * .75 + h__[i__ + i__ * h_dim1];
			bb = ss;
			cc = ss * -.4375;
			dd = aa;
			igraphdlanv2_(&aa, &bb, &cc, &dd, &wr[i__ - 1], &wi[i__ - 1]
				, &wr[i__], &wi[i__], &cs, &sn);
/* L30: */
		    }
		    if (ks == ktop) {
			wr[ks + 1] = h__[ks + 1 + (ks + 1) * h_dim1];
			wi[ks + 1] = 0.;
			wr[ks] = wr[ks + 1];
			wi[ks] = wi[ks + 1];
		    }
		} else {

/*                 ==== Got NS/2 or fewer shifts? Use DLAQR4 or   
                   .    DLAHQR on a trailing principal submatrix to   
                   .    get more. (Since NS.LE.NSMAX.LE.(N+6)/9,   
                   .    there is enough space below the subdiagonal   
                   .    to fit an NS-by-NS scratch array.) ==== */

		    if (kbot - ks + 1 <= ns / 2) {
			ks = kbot - ns + 1;
			kt = *n - ns + 1;
			igraphdlacpy_("A", &ns, &ns, &h__[ks + ks * h_dim1], ldh, &
				h__[kt + h_dim1], ldh);
			if (ns > nmin) {
			    igraphdlaqr4_(&c_false, &c_false, &ns, &c__1, &ns, &h__[
				    kt + h_dim1], ldh, &wr[ks], &wi[ks], &
				    c__1, &c__1, zdum, &c__1, &work[1], lwork,
				     &inf);
			} else {
			    igraphdlahqr_(&c_false, &c_false, &ns, &c__1, &ns, &h__[
				    kt + h_dim1], ldh, &wr[ks], &wi[ks], &
				    c__1, &c__1, zdum, &c__1, &inf);
			}
			ks += inf;

/*                    ==== In case of a rare QR failure use   
                      .    eigenvalues of the trailing 2-by-2   
                      .    principal submatrix.  ==== */

			if (ks >= kbot) {
			    aa = h__[kbot - 1 + (kbot - 1) * h_dim1];
			    cc = h__[kbot + (kbot - 1) * h_dim1];
			    bb = h__[kbot - 1 + kbot * h_dim1];
			    dd = h__[kbot + kbot * h_dim1];
			    igraphdlanv2_(&aa, &bb, &cc, &dd, &wr[kbot - 1], &wi[
				    kbot - 1], &wr[kbot], &wi[kbot], &cs, &sn)
				    ;
			    ks = kbot - 1;
			}
		    }

		    if (kbot - ks + 1 > ns) {

/*                    ==== Sort the shifts (Helps a little)   
                      .    Bubble sort keeps complex conjugate   
                      .    pairs together. ==== */

			sorted = FALSE_;
			i__2 = ks + 1;
			for (k = kbot; k >= i__2; --k) {
			    if (sorted) {
				goto L60;
			    }
			    sorted = TRUE_;
			    i__3 = k - 1;
			    for (i__ = ks; i__ <= i__3; ++i__) {
				if ((d__1 = wr[i__], abs(d__1)) + (d__2 = wi[
					i__], abs(d__2)) < (d__3 = wr[i__ + 1]
					, abs(d__3)) + (d__4 = wi[i__ + 1], 
					abs(d__4))) {
				    sorted = FALSE_;

				    swap = wr[i__];
				    wr[i__] = wr[i__ + 1];
				    wr[i__ + 1] = swap;

				    swap = wi[i__];
				    wi[i__] = wi[i__ + 1];
				    wi[i__ + 1] = swap;
				}
/* L40: */
			    }
/* L50: */
			}
L60:
			;
		    }

/*                 ==== Shuffle shifts into pairs of real shifts   
                   .    and pairs of complex conjugate shifts   
                   .    assuming complex conjugate shifts are   
                   .    already adjacent to one another. (Yes,   
                   .    they are.)  ==== */

		    i__2 = ks + 2;
		    for (i__ = kbot; i__ >= i__2; i__ += -2) {
			if (wi[i__] != -wi[i__ - 1]) {

			    swap = wr[i__];
			    wr[i__] = wr[i__ - 1];
			    wr[i__ - 1] = wr[i__ - 2];
			    wr[i__ - 2] = swap;

			    swap = wi[i__];
			    wi[i__] = wi[i__ - 1];
			    wi[i__ - 1] = wi[i__ - 2];
			    wi[i__ - 2] = swap;
			}
/* L70: */
		    }
		}

/*              ==== If there are only two shifts and both are   
                .    real, then use only one.  ==== */

		if (kbot - ks + 1 == 2) {
		    if (wi[kbot] == 0.) {
			if ((d__1 = wr[kbot] - h__[kbot + kbot * h_dim1], abs(
				d__1)) < (d__2 = wr[kbot - 1] - h__[kbot + 
				kbot * h_dim1], abs(d__2))) {
			    wr[kbot - 1] = wr[kbot];
			} else {
			    wr[kbot] = wr[kbot - 1];
			}
		    }
		}

/*              ==== Use up to NS of the the smallest magnatiude   
                .    shifts.  If there aren't NS shifts available,   
                .    then use them all, possibly dropping one to   
                .    make the number of shifts even. ====   

   Computing MIN */
		i__2 = ns, i__3 = kbot - ks + 1;
		ns = min(i__2,i__3);
		ns -= ns % 2;
		ks = kbot - ns + 1;

/*              ==== Small-bulge multi-shift QR sweep:   
                .    split workspace under the subdiagonal into   
                .    - a KDU-by-KDU work array U in the lower   
                .      left-hand-corner,   
                .    - a KDU-by-at-least-KDU-but-more-is-better   
                .      (KDU-by-NHo) horizontal work array WH along   
                .      the bottom edge,   
                .    - and an at-least-KDU-but-more-is-better-by-KDU   
                .      (NVE-by-KDU) vertical work WV arrow along   
                .      the left-hand-edge. ==== */

		kdu = ns * 3 - 3;
		ku = *n - kdu + 1;
		kwh = kdu + 1;
		nho = *n - kdu - 3 - (kdu + 1) + 1;
		kwv = kdu + 4;
		nve = *n - kdu - kwv + 1;

/*              ==== Small-bulge multi-shift QR sweep ==== */

		igraphdlaqr5_(wantt, wantz, &kacc22, n, &ktop, &kbot, &ns, &wr[ks], 
			&wi[ks], &h__[h_offset], ldh, iloz, ihiz, &z__[
			z_offset], ldz, &work[1], &c__3, &h__[ku + h_dim1], 
			ldh, &nve, &h__[kwv + h_dim1], ldh, &nho, &h__[ku + 
			kwh * h_dim1], ldh);
	    }

/*           ==== Note progress (or the lack of it). ==== */

	    if (ld > 0) {
		ndfl = 1;
	    } else {
		++ndfl;
	    }

/*           ==== End of main loop ====   
   L80: */
	}

/*        ==== Iteration limit exceeded.  Set INFO to show where   
          .    the problem occurred and exit. ==== */

	*info = kbot;
L90:
	;
    }

/*     ==== Return the optimal value of LWORK. ==== */

    work[1] = (doublereal) lwkopt;

/*     ==== End of DLAQR0 ==== */

    return 0;
} /* igraphdlaqr0_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr1.c0000644000175100001710000001341200000000000023733 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAQR1 sets a scalar multiple of the first column of the product of 2-by-2 or 3-by-3 matrix H a
nd specified shifts.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR1 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR1( N, H, LDH, SR1, SI1, SR2, SI2, V )   

         DOUBLE PRECISION   SI1, SI2, SR1, SR2   
         INTEGER            LDH, N   
         DOUBLE PRECISION   H( LDH, * ), V( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >      Given a 2-by-2 or 3-by-3 matrix H, DLAQR1 sets v to a   
   >      scalar multiple of the first column of the product   
   >   
   >      (*)  K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I)   
   >   
   >      scaling to avoid overflows and most underflows. It   
   >      is assumed that either   
   >   
   >              1) sr1 = sr2 and si1 = -si2   
   >          or   
   >              2) si1 = si2 = 0.   
   >   
   >      This is useful for starting double implicit shift bulges   
   >      in the QR algorithm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is integer   
   >              Order of the matrix H. N must be either 2 or 3.   
   > \endverbatim   
   >   
   > \param[in] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array of dimension (LDH,N)   
   >              The 2-by-2 or 3-by-3 matrix H in (*).   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is integer   
   >              The leading dimension of H as declared in   
   >              the calling procedure.  LDH.GE.N   
   > \endverbatim   
   >   
   > \param[in] SR1   
   > \verbatim   
   >          SR1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] SI1   
   > \verbatim   
   >          SI1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] SR2   
   > \verbatim   
   >          SR2 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] SI2   
   > \verbatim   
   >          SI2 is DOUBLE PRECISION   
   >              The shifts in (*).   
   > \endverbatim   
   >   
   > \param[out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array of dimension N   
   >              A scalar multiple of the first column of the   
   >              matrix K in (*).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaqr1_(integer *n, doublereal *h__, integer *ldh, 
	doublereal *sr1, doublereal *si1, doublereal *sr2, doublereal *si2, 
	doublereal *v)
{
    /* System generated locals */
    integer h_dim1, h_offset;
    doublereal d__1, d__2, d__3;

    /* Local variables */
    doublereal s, h21s, h31s;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   

       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --v;

    /* Function Body */
    if (*n == 2) {
	s = (d__1 = h__[h_dim1 + 1] - *sr2, abs(d__1)) + abs(*si2) + (d__2 = 
		h__[h_dim1 + 2], abs(d__2));
	if (s == 0.) {
	    v[1] = 0.;
	    v[2] = 0.;
	} else {
	    h21s = h__[h_dim1 + 2] / s;
	    v[1] = h21s * h__[(h_dim1 << 1) + 1] + (h__[h_dim1 + 1] - *sr1) * 
		    ((h__[h_dim1 + 1] - *sr2) / s) - *si1 * (*si2 / s);
	    v[2] = h21s * (h__[h_dim1 + 1] + h__[(h_dim1 << 1) + 2] - *sr1 - *
		    sr2);
	}
    } else {
	s = (d__1 = h__[h_dim1 + 1] - *sr2, abs(d__1)) + abs(*si2) + (d__2 = 
		h__[h_dim1 + 2], abs(d__2)) + (d__3 = h__[h_dim1 + 3], abs(
		d__3));
	if (s == 0.) {
	    v[1] = 0.;
	    v[2] = 0.;
	    v[3] = 0.;
	} else {
	    h21s = h__[h_dim1 + 2] / s;
	    h31s = h__[h_dim1 + 3] / s;
	    v[1] = (h__[h_dim1 + 1] - *sr1) * ((h__[h_dim1 + 1] - *sr2) / s) 
		    - *si1 * (*si2 / s) + h__[(h_dim1 << 1) + 1] * h21s + h__[
		    h_dim1 * 3 + 1] * h31s;
	    v[2] = h21s * (h__[h_dim1 + 1] + h__[(h_dim1 << 1) + 2] - *sr1 - *
		    sr2) + h__[h_dim1 * 3 + 2] * h31s;
	    v[3] = h31s * (h__[h_dim1 + 1] + h__[h_dim1 * 3 + 3] - *sr1 - *
		    sr2) + h21s * h__[(h_dim1 << 1) + 3];
	}
    }
    return 0;
} /* igraphdlaqr1_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr2.c0000644000175100001710000006123500000000000023742 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static doublereal c_b12 = 0.;
static doublereal c_b13 = 1.;
static logical c_true = TRUE_;

/* > \brief \b DLAQR2 performs the orthogonal similarity transformation of a Hessenberg matrix to detect and d
eflate fully converged eigenvalues from a trailing principal submatrix (aggressive early deflation). 
  

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR2( WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ,   
                            IHIZ, Z, LDZ, NS, ND, SR, SI, V, LDV, NH, T,   
                            LDT, NV, WV, LDWV, WORK, LWORK )   

         INTEGER            IHIZ, ILOZ, KBOT, KTOP, LDH, LDT, LDV, LDWV,   
        $                   LDZ, LWORK, N, ND, NH, NS, NV, NW   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), SI( * ), SR( * ), T( LDT, * ),   
        $                   V( LDV, * ), WORK( * ), WV( LDWV, * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DLAQR2 is identical to DLAQR3 except that it avoids   
   >    recursion by calling DLAHQR instead of DLAQR4.   
   >   
   >    Aggressive early deflation:   
   >   
   >    This subroutine accepts as input an upper Hessenberg matrix   
   >    H and performs an orthogonal similarity transformation   
   >    designed to detect and deflate fully converged eigenvalues from   
   >    a trailing principal submatrix.  On output H has been over-   
   >    written by a new Hessenberg matrix that is a perturbation of   
   >    an orthogonal similarity transformation of H.  It is to be   
   >    hoped that the final version of H has many zero subdiagonal   
   >    entries.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is LOGICAL   
   >          If .TRUE., then the Hessenberg matrix H is fully updated   
   >          so that the quasi-triangular Schur factor may be   
   >          computed (in cooperation with the calling subroutine).   
   >          If .FALSE., then only enough of H is updated to preserve   
   >          the eigenvalues.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is LOGICAL   
   >          If .TRUE., then the orthogonal matrix Z is updated so   
   >          so that the orthogonal Schur factor may be computed   
   >          (in cooperation with the calling subroutine).   
   >          If .FALSE., then Z is not referenced.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix H and (if WANTZ is .TRUE.) the   
   >          order of the orthogonal matrix Z.   
   > \endverbatim   
   >   
   > \param[in] KTOP   
   > \verbatim   
   >          KTOP is INTEGER   
   >          It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.   
   >          KBOT and KTOP together determine an isolated block   
   >          along the diagonal of the Hessenberg matrix.   
   > \endverbatim   
   >   
   > \param[in] KBOT   
   > \verbatim   
   >          KBOT is INTEGER   
   >          It is assumed without a check that either   
   >          KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together   
   >          determine an isolated block along the diagonal of the   
   >          Hessenberg matrix.   
   > \endverbatim   
   >   
   > \param[in] NW   
   > \verbatim   
   >          NW is INTEGER   
   >          Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1).   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >          On input the initial N-by-N section of H stores the   
   >          Hessenberg matrix undergoing aggressive early deflation.   
   >          On output H has been transformed by an orthogonal   
   >          similarity transformation, perturbed, and the returned   
   >          to Hessenberg form that (it is to be hoped) has some   
   >          zero subdiagonal entries.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is integer   
   >          Leading dimension of H just as declared in the calling   
   >          subroutine.  N .LE. LDH   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >          Specify the rows of Z to which transformations must be   
   >          applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,N)   
   >          IF WANTZ is .TRUE., then on output, the orthogonal   
   >          similarity transformation mentioned above has been   
   >          accumulated into Z(ILOZ:IHIZ,ILO:IHI) from the right.   
   >          If WANTZ is .FALSE., then Z is unreferenced.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is integer   
   >          The leading dimension of Z just as declared in the   
   >          calling subroutine.  1 .LE. LDZ.   
   > \endverbatim   
   >   
   > \param[out] NS   
   > \verbatim   
   >          NS is integer   
   >          The number of unconverged (ie approximate) eigenvalues   
   >          returned in SR and SI that may be used as shifts by the   
   >          calling subroutine.   
   > \endverbatim   
   >   
   > \param[out] ND   
   > \verbatim   
   >          ND is integer   
   >          The number of converged eigenvalues uncovered by this   
   >          subroutine.   
   > \endverbatim   
   >   
   > \param[out] SR   
   > \verbatim   
   >          SR is DOUBLE PRECISION array, dimension (KBOT)   
   > \endverbatim   
   >   
   > \param[out] SI   
   > \verbatim   
   >          SI is DOUBLE PRECISION array, dimension (KBOT)   
   >          On output, the real and imaginary parts of approximate   
   >          eigenvalues that may be used for shifts are stored in   
   >          SR(KBOT-ND-NS+1) through SR(KBOT-ND) and   
   >          SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.   
   >          The real and imaginary parts of converged eigenvalues   
   >          are stored in SR(KBOT-ND+1) through SR(KBOT) and   
   >          SI(KBOT-ND+1) through SI(KBOT), respectively.   
   > \endverbatim   
   >   
   > \param[out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension (LDV,NW)   
   >          An NW-by-NW work array.   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is integer scalar   
   >          The leading dimension of V just as declared in the   
   >          calling subroutine.  NW .LE. LDV   
   > \endverbatim   
   >   
   > \param[in] NH   
   > \verbatim   
   >          NH is integer scalar   
   >          The number of columns of T.  NH.GE.NW.   
   > \endverbatim   
   >   
   > \param[out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,NW)   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is integer   
   >          The leading dimension of T just as declared in the   
   >          calling subroutine.  NW .LE. LDT   
   > \endverbatim   
   >   
   > \param[in] NV   
   > \verbatim   
   >          NV is integer   
   >          The number of rows of work array WV available for   
   >          workspace.  NV.GE.NW.   
   > \endverbatim   
   >   
   > \param[out] WV   
   > \verbatim   
   >          WV is DOUBLE PRECISION array, dimension (LDWV,NW)   
   > \endverbatim   
   >   
   > \param[in] LDWV   
   > \verbatim   
   >          LDWV is integer   
   >          The leading dimension of W just as declared in the   
   >          calling subroutine.  NW .LE. LDV   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LWORK)   
   >          On exit, WORK(1) is set to an estimate of the optimal value   
   >          of LWORK for the given values of N, NW, KTOP and KBOT.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is integer   
   >          The dimension of the work array WORK.  LWORK = 2*NW   
   >          suffices, but greater efficiency may result from larger   
   >          values of LWORK.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; DLAQR2   
   >          only estimates the optimal workspace size for the given   
   >          values of N, NW, KTOP and KBOT.  The estimate is returned   
   >          in WORK(1).  No error message related to LWORK is issued   
   >          by XERBLA.  Neither H nor Z are accessed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaqr2_(logical *wantt, logical *wantz, integer *n, 
	integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer *
	ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, 
	integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal *
	v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer *
	nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork)
{
    /* System generated locals */
    integer h_dim1, h_offset, t_dim1, t_offset, v_dim1, v_offset, wv_dim1, 
	    wv_offset, z_dim1, z_offset, i__1, i__2, i__3, i__4;
    doublereal d__1, d__2, d__3, d__4, d__5, d__6;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, k;
    doublereal s, aa, bb, cc, dd, cs, sn;
    integer jw;
    doublereal evi, evk, foo;
    integer kln;
    doublereal tau, ulp;
    integer lwk1, lwk2;
    doublereal beta;
    integer kend, kcol, info, ifst, ilst, ltop, krow;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *), igraphdgemm_(char *, char *, integer *, integer *
	    , integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    logical bulge;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    integer infqr, kwtop;
    extern /* Subroutine */ int igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlabad_(
	    doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdgehrd_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdlarfg_(integer *, doublereal *, doublereal *, 
	    integer *, doublereal *), igraphdlahqr_(logical *, logical *, integer *,
	     integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *), igraphdlacpy_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *);
    doublereal safmin;
    extern /* Subroutine */ int igraphdlaset_(char *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *);
    doublereal safmax;
    extern /* Subroutine */ int igraphdtrexc_(char *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *, integer *, 
	    doublereal *, integer *), igraphdormhr_(char *, char *, integer 
	    *, integer *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    integer *);
    logical sorted;
    doublereal smlnum;
    integer lwkopt;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   

       ==== Estimate optimal workspace. ====   

       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --sr;
    --si;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    wv_dim1 = *ldwv;
    wv_offset = 1 + wv_dim1;
    wv -= wv_offset;
    --work;

    /* Function Body   
   Computing MIN */
    i__1 = *nw, i__2 = *kbot - *ktop + 1;
    jw = min(i__1,i__2);
    if (jw <= 2) {
	lwkopt = 1;
    } else {

/*        ==== Workspace query call to DGEHRD ==== */

	i__1 = jw - 1;
	igraphdgehrd_(&jw, &c__1, &i__1, &t[t_offset], ldt, &work[1], &work[1], &
		c_n1, &info);
	lwk1 = (integer) work[1];

/*        ==== Workspace query call to DORMHR ==== */

	i__1 = jw - 1;
	igraphdormhr_("R", "N", &jw, &jw, &c__1, &i__1, &t[t_offset], ldt, &work[1],
		 &v[v_offset], ldv, &work[1], &c_n1, &info);
	lwk2 = (integer) work[1];

/*        ==== Optimal workspace ==== */

	lwkopt = jw + max(lwk1,lwk2);
    }

/*     ==== Quick return in case of workspace query. ==== */

    if (*lwork == -1) {
	work[1] = (doublereal) lwkopt;
	return 0;
    }

/*     ==== Nothing to do ...   
       ... for an empty active block ... ==== */
    *ns = 0;
    *nd = 0;
    work[1] = 1.;
    if (*ktop > *kbot) {
	return 0;
    }
/*     ... nor for an empty deflation window. ==== */
    if (*nw < 1) {
	return 0;
    }

/*     ==== Machine constants ==== */

    safmin = igraphdlamch_("SAFE MINIMUM");
    safmax = 1. / safmin;
    igraphdlabad_(&safmin, &safmax);
    ulp = igraphdlamch_("PRECISION");
    smlnum = safmin * ((doublereal) (*n) / ulp);

/*     ==== Setup deflation window ====   

   Computing MIN */
    i__1 = *nw, i__2 = *kbot - *ktop + 1;
    jw = min(i__1,i__2);
    kwtop = *kbot - jw + 1;
    if (kwtop == *ktop) {
	s = 0.;
    } else {
	s = h__[kwtop + (kwtop - 1) * h_dim1];
    }

    if (*kbot == kwtop) {

/*        ==== 1-by-1 deflation window: not much to do ==== */

	sr[kwtop] = h__[kwtop + kwtop * h_dim1];
	si[kwtop] = 0.;
	*ns = 1;
	*nd = 0;
/* Computing MAX */
	d__2 = smlnum, d__3 = ulp * (d__1 = h__[kwtop + kwtop * h_dim1], abs(
		d__1));
	if (abs(s) <= max(d__2,d__3)) {
	    *ns = 0;
	    *nd = 1;
	    if (kwtop > *ktop) {
		h__[kwtop + (kwtop - 1) * h_dim1] = 0.;
	    }
	}
	work[1] = 1.;
	return 0;
    }

/*     ==== Convert to spike-triangular form.  (In case of a   
       .    rare QR failure, this routine continues to do   
       .    aggressive early deflation using that part of   
       .    the deflation window that converged using INFQR   
       .    here and there to keep track.) ==== */

    igraphdlacpy_("U", &jw, &jw, &h__[kwtop + kwtop * h_dim1], ldh, &t[t_offset], 
	    ldt);
    i__1 = jw - 1;
    i__2 = *ldh + 1;
    i__3 = *ldt + 1;
    igraphdcopy_(&i__1, &h__[kwtop + 1 + kwtop * h_dim1], &i__2, &t[t_dim1 + 2], &
	    i__3);

    igraphdlaset_("A", &jw, &jw, &c_b12, &c_b13, &v[v_offset], ldv);
    igraphdlahqr_(&c_true, &c_true, &jw, &c__1, &jw, &t[t_offset], ldt, &sr[kwtop], 
	    &si[kwtop], &c__1, &jw, &v[v_offset], ldv, &infqr);

/*     ==== DTREXC needs a clean margin near the diagonal ==== */

    i__1 = jw - 3;
    for (j = 1; j <= i__1; ++j) {
	t[j + 2 + j * t_dim1] = 0.;
	t[j + 3 + j * t_dim1] = 0.;
/* L10: */
    }
    if (jw > 2) {
	t[jw + (jw - 2) * t_dim1] = 0.;
    }

/*     ==== Deflation detection loop ==== */

    *ns = jw;
    ilst = infqr + 1;
L20:
    if (ilst <= *ns) {
	if (*ns == 1) {
	    bulge = FALSE_;
	} else {
	    bulge = t[*ns + (*ns - 1) * t_dim1] != 0.;
	}

/*        ==== Small spike tip test for deflation ==== */

	if (! bulge) {

/*           ==== Real eigenvalue ==== */

	    foo = (d__1 = t[*ns + *ns * t_dim1], abs(d__1));
	    if (foo == 0.) {
		foo = abs(s);
	    }
/* Computing MAX */
	    d__2 = smlnum, d__3 = ulp * foo;
	    if ((d__1 = s * v[*ns * v_dim1 + 1], abs(d__1)) <= max(d__2,d__3))
		     {

/*              ==== Deflatable ==== */

		--(*ns);
	    } else {

/*              ==== Undeflatable.   Move it up out of the way.   
                .    (DTREXC can not fail in this case.) ==== */

		ifst = *ns;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		++ilst;
	    }
	} else {

/*           ==== Complex conjugate pair ==== */

	    foo = (d__3 = t[*ns + *ns * t_dim1], abs(d__3)) + sqrt((d__1 = t[*
		    ns + (*ns - 1) * t_dim1], abs(d__1))) * sqrt((d__2 = t[*
		    ns - 1 + *ns * t_dim1], abs(d__2)));
	    if (foo == 0.) {
		foo = abs(s);
	    }
/* Computing MAX */
	    d__3 = (d__1 = s * v[*ns * v_dim1 + 1], abs(d__1)), d__4 = (d__2 =
		     s * v[(*ns - 1) * v_dim1 + 1], abs(d__2));
/* Computing MAX */
	    d__5 = smlnum, d__6 = ulp * foo;
	    if (max(d__3,d__4) <= max(d__5,d__6)) {

/*              ==== Deflatable ==== */

		*ns += -2;
	    } else {

/*              ==== Undeflatable. Move them up out of the way.   
                .    Fortunately, DTREXC does the right thing with   
                .    ILST in case of a rare exchange failure. ==== */

		ifst = *ns;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		ilst += 2;
	    }
	}

/*        ==== End deflation detection loop ==== */

	goto L20;
    }

/*        ==== Return to Hessenberg form ==== */

    if (*ns == 0) {
	s = 0.;
    }

    if (*ns < jw) {

/*        ==== sorting diagonal blocks of T improves accuracy for   
          .    graded matrices.  Bubble sort deals well with   
          .    exchange failures. ==== */

	sorted = FALSE_;
	i__ = *ns + 1;
L30:
	if (sorted) {
	    goto L50;
	}
	sorted = TRUE_;

	kend = i__ - 1;
	i__ = infqr + 1;
	if (i__ == *ns) {
	    k = i__ + 1;
	} else if (t[i__ + 1 + i__ * t_dim1] == 0.) {
	    k = i__ + 1;
	} else {
	    k = i__ + 2;
	}
L40:
	if (k <= kend) {
	    if (k == i__ + 1) {
		evi = (d__1 = t[i__ + i__ * t_dim1], abs(d__1));
	    } else {
		evi = (d__3 = t[i__ + i__ * t_dim1], abs(d__3)) + sqrt((d__1 =
			 t[i__ + 1 + i__ * t_dim1], abs(d__1))) * sqrt((d__2 =
			 t[i__ + (i__ + 1) * t_dim1], abs(d__2)));
	    }

	    if (k == kend) {
		evk = (d__1 = t[k + k * t_dim1], abs(d__1));
	    } else if (t[k + 1 + k * t_dim1] == 0.) {
		evk = (d__1 = t[k + k * t_dim1], abs(d__1));
	    } else {
		evk = (d__3 = t[k + k * t_dim1], abs(d__3)) + sqrt((d__1 = t[
			k + 1 + k * t_dim1], abs(d__1))) * sqrt((d__2 = t[k + 
			(k + 1) * t_dim1], abs(d__2)));
	    }

	    if (evi >= evk) {
		i__ = k;
	    } else {
		sorted = FALSE_;
		ifst = i__;
		ilst = k;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		if (info == 0) {
		    i__ = ilst;
		} else {
		    i__ = k;
		}
	    }
	    if (i__ == kend) {
		k = i__ + 1;
	    } else if (t[i__ + 1 + i__ * t_dim1] == 0.) {
		k = i__ + 1;
	    } else {
		k = i__ + 2;
	    }
	    goto L40;
	}
	goto L30;
L50:
	;
    }

/*     ==== Restore shift/eigenvalue array from T ==== */

    i__ = jw;
L60:
    if (i__ >= infqr + 1) {
	if (i__ == infqr + 1) {
	    sr[kwtop + i__ - 1] = t[i__ + i__ * t_dim1];
	    si[kwtop + i__ - 1] = 0.;
	    --i__;
	} else if (t[i__ + (i__ - 1) * t_dim1] == 0.) {
	    sr[kwtop + i__ - 1] = t[i__ + i__ * t_dim1];
	    si[kwtop + i__ - 1] = 0.;
	    --i__;
	} else {
	    aa = t[i__ - 1 + (i__ - 1) * t_dim1];
	    cc = t[i__ + (i__ - 1) * t_dim1];
	    bb = t[i__ - 1 + i__ * t_dim1];
	    dd = t[i__ + i__ * t_dim1];
	    igraphdlanv2_(&aa, &bb, &cc, &dd, &sr[kwtop + i__ - 2], &si[kwtop + i__ 
		    - 2], &sr[kwtop + i__ - 1], &si[kwtop + i__ - 1], &cs, &
		    sn);
	    i__ += -2;
	}
	goto L60;
    }

    if (*ns < jw || s == 0.) {
	if (*ns > 1 && s != 0.) {

/*           ==== Reflect spike back into lower triangle ==== */

	    igraphdcopy_(ns, &v[v_offset], ldv, &work[1], &c__1);
	    beta = work[1];
	    igraphdlarfg_(ns, &beta, &work[2], &c__1, &tau);
	    work[1] = 1.;

	    i__1 = jw - 2;
	    i__2 = jw - 2;
	    igraphdlaset_("L", &i__1, &i__2, &c_b12, &c_b12, &t[t_dim1 + 3], ldt);

	    igraphdlarf_("L", ns, &jw, &work[1], &c__1, &tau, &t[t_offset], ldt, &
		    work[jw + 1]);
	    igraphdlarf_("R", ns, ns, &work[1], &c__1, &tau, &t[t_offset], ldt, &
		    work[jw + 1]);
	    igraphdlarf_("R", &jw, ns, &work[1], &c__1, &tau, &v[v_offset], ldv, &
		    work[jw + 1]);

	    i__1 = *lwork - jw;
	    igraphdgehrd_(&jw, &c__1, ns, &t[t_offset], ldt, &work[1], &work[jw + 1]
		    , &i__1, &info);
	}

/*        ==== Copy updated reduced window into place ==== */

	if (kwtop > 1) {
	    h__[kwtop + (kwtop - 1) * h_dim1] = s * v[v_dim1 + 1];
	}
	igraphdlacpy_("U", &jw, &jw, &t[t_offset], ldt, &h__[kwtop + kwtop * h_dim1]
		, ldh);
	i__1 = jw - 1;
	i__2 = *ldt + 1;
	i__3 = *ldh + 1;
	igraphdcopy_(&i__1, &t[t_dim1 + 2], &i__2, &h__[kwtop + 1 + kwtop * h_dim1],
		 &i__3);

/*        ==== Accumulate orthogonal matrix in order update   
          .    H and Z, if requested.  ==== */

	if (*ns > 1 && s != 0.) {
	    i__1 = *lwork - jw;
	    igraphdormhr_("R", "N", &jw, ns, &c__1, ns, &t[t_offset], ldt, &work[1],
		     &v[v_offset], ldv, &work[jw + 1], &i__1, &info);
	}

/*        ==== Update vertical slab in H ==== */

	if (*wantt) {
	    ltop = 1;
	} else {
	    ltop = *ktop;
	}
	i__1 = kwtop - 1;
	i__2 = *nv;
	for (krow = ltop; i__2 < 0 ? krow >= i__1 : krow <= i__1; krow += 
		i__2) {
/* Computing MIN */
	    i__3 = *nv, i__4 = kwtop - krow;
	    kln = min(i__3,i__4);
	    igraphdgemm_("N", "N", &kln, &jw, &jw, &c_b13, &h__[krow + kwtop * 
		    h_dim1], ldh, &v[v_offset], ldv, &c_b12, &wv[wv_offset], 
		    ldwv);
	    igraphdlacpy_("A", &kln, &jw, &wv[wv_offset], ldwv, &h__[krow + kwtop * 
		    h_dim1], ldh);
/* L70: */
	}

/*        ==== Update horizontal slab in H ==== */

	if (*wantt) {
	    i__2 = *n;
	    i__1 = *nh;
	    for (kcol = *kbot + 1; i__1 < 0 ? kcol >= i__2 : kcol <= i__2; 
		    kcol += i__1) {
/* Computing MIN */
		i__3 = *nh, i__4 = *n - kcol + 1;
		kln = min(i__3,i__4);
		igraphdgemm_("C", "N", &jw, &kln, &jw, &c_b13, &v[v_offset], ldv, &
			h__[kwtop + kcol * h_dim1], ldh, &c_b12, &t[t_offset],
			 ldt);
		igraphdlacpy_("A", &jw, &kln, &t[t_offset], ldt, &h__[kwtop + kcol *
			 h_dim1], ldh);
/* L80: */
	    }
	}

/*        ==== Update vertical slab in Z ==== */

	if (*wantz) {
	    i__1 = *ihiz;
	    i__2 = *nv;
	    for (krow = *iloz; i__2 < 0 ? krow >= i__1 : krow <= i__1; krow +=
		     i__2) {
/* Computing MIN */
		i__3 = *nv, i__4 = *ihiz - krow + 1;
		kln = min(i__3,i__4);
		igraphdgemm_("N", "N", &kln, &jw, &jw, &c_b13, &z__[krow + kwtop * 
			z_dim1], ldz, &v[v_offset], ldv, &c_b12, &wv[
			wv_offset], ldwv);
		igraphdlacpy_("A", &kln, &jw, &wv[wv_offset], ldwv, &z__[krow + 
			kwtop * z_dim1], ldz);
/* L90: */
	    }
	}
    }

/*     ==== Return the number of deflations ... ==== */

    *nd = jw - *ns;

/*     ==== ... and the number of shifts. (Subtracting   
       .    INFQR from the spike length takes care   
       .    of the case of a rare QR failure while   
       .    calculating eigenvalues of the deflation   
       .    window.)  ==== */

    *ns -= infqr;

/*      ==== Return optimal workspace. ==== */

    work[1] = (doublereal) lwkopt;

/*     ==== End of DLAQR2 ==== */

    return 0;
} /* igraphdlaqr2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr3.c0000644000175100001710000006266000000000000023746 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static logical c_true = TRUE_;
static doublereal c_b17 = 0.;
static doublereal c_b18 = 1.;
static integer c__12 = 12;

/* > \brief \b DLAQR3 performs the orthogonal similarity transformation of a Hessenberg matrix to detect and d
eflate fully converged eigenvalues from a trailing principal submatrix (aggressive early deflation). 
  

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR3 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR3( WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ,   
                            IHIZ, Z, LDZ, NS, ND, SR, SI, V, LDV, NH, T,   
                            LDT, NV, WV, LDWV, WORK, LWORK )   

         INTEGER            IHIZ, ILOZ, KBOT, KTOP, LDH, LDT, LDV, LDWV,   
        $                   LDZ, LWORK, N, ND, NH, NS, NV, NW   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), SI( * ), SR( * ), T( LDT, * ),   
        $                   V( LDV, * ), WORK( * ), WV( LDWV, * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    Aggressive early deflation:   
   >   
   >    DLAQR3 accepts as input an upper Hessenberg matrix   
   >    H and performs an orthogonal similarity transformation   
   >    designed to detect and deflate fully converged eigenvalues from   
   >    a trailing principal submatrix.  On output H has been over-   
   >    written by a new Hessenberg matrix that is a perturbation of   
   >    an orthogonal similarity transformation of H.  It is to be   
   >    hoped that the final version of H has many zero subdiagonal   
   >    entries.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is LOGICAL   
   >          If .TRUE., then the Hessenberg matrix H is fully updated   
   >          so that the quasi-triangular Schur factor may be   
   >          computed (in cooperation with the calling subroutine).   
   >          If .FALSE., then only enough of H is updated to preserve   
   >          the eigenvalues.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is LOGICAL   
   >          If .TRUE., then the orthogonal matrix Z is updated so   
   >          so that the orthogonal Schur factor may be computed   
   >          (in cooperation with the calling subroutine).   
   >          If .FALSE., then Z is not referenced.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix H and (if WANTZ is .TRUE.) the   
   >          order of the orthogonal matrix Z.   
   > \endverbatim   
   >   
   > \param[in] KTOP   
   > \verbatim   
   >          KTOP is INTEGER   
   >          It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.   
   >          KBOT and KTOP together determine an isolated block   
   >          along the diagonal of the Hessenberg matrix.   
   > \endverbatim   
   >   
   > \param[in] KBOT   
   > \verbatim   
   >          KBOT is INTEGER   
   >          It is assumed without a check that either   
   >          KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together   
   >          determine an isolated block along the diagonal of the   
   >          Hessenberg matrix.   
   > \endverbatim   
   >   
   > \param[in] NW   
   > \verbatim   
   >          NW is INTEGER   
   >          Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1).   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >          On input the initial N-by-N section of H stores the   
   >          Hessenberg matrix undergoing aggressive early deflation.   
   >          On output H has been transformed by an orthogonal   
   >          similarity transformation, perturbed, and the returned   
   >          to Hessenberg form that (it is to be hoped) has some   
   >          zero subdiagonal entries.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is integer   
   >          Leading dimension of H just as declared in the calling   
   >          subroutine.  N .LE. LDH   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >          Specify the rows of Z to which transformations must be   
   >          applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,N)   
   >          IF WANTZ is .TRUE., then on output, the orthogonal   
   >          similarity transformation mentioned above has been   
   >          accumulated into Z(ILOZ:IHIZ,ILO:IHI) from the right.   
   >          If WANTZ is .FALSE., then Z is unreferenced.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is integer   
   >          The leading dimension of Z just as declared in the   
   >          calling subroutine.  1 .LE. LDZ.   
   > \endverbatim   
   >   
   > \param[out] NS   
   > \verbatim   
   >          NS is integer   
   >          The number of unconverged (ie approximate) eigenvalues   
   >          returned in SR and SI that may be used as shifts by the   
   >          calling subroutine.   
   > \endverbatim   
   >   
   > \param[out] ND   
   > \verbatim   
   >          ND is integer   
   >          The number of converged eigenvalues uncovered by this   
   >          subroutine.   
   > \endverbatim   
   >   
   > \param[out] SR   
   > \verbatim   
   >          SR is DOUBLE PRECISION array, dimension (KBOT)   
   > \endverbatim   
   >   
   > \param[out] SI   
   > \verbatim   
   >          SI is DOUBLE PRECISION array, dimension (KBOT)   
   >          On output, the real and imaginary parts of approximate   
   >          eigenvalues that may be used for shifts are stored in   
   >          SR(KBOT-ND-NS+1) through SR(KBOT-ND) and   
   >          SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.   
   >          The real and imaginary parts of converged eigenvalues   
   >          are stored in SR(KBOT-ND+1) through SR(KBOT) and   
   >          SI(KBOT-ND+1) through SI(KBOT), respectively.   
   > \endverbatim   
   >   
   > \param[out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension (LDV,NW)   
   >          An NW-by-NW work array.   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is integer scalar   
   >          The leading dimension of V just as declared in the   
   >          calling subroutine.  NW .LE. LDV   
   > \endverbatim   
   >   
   > \param[in] NH   
   > \verbatim   
   >          NH is integer scalar   
   >          The number of columns of T.  NH.GE.NW.   
   > \endverbatim   
   >   
   > \param[out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,NW)   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is integer   
   >          The leading dimension of T just as declared in the   
   >          calling subroutine.  NW .LE. LDT   
   > \endverbatim   
   >   
   > \param[in] NV   
   > \verbatim   
   >          NV is integer   
   >          The number of rows of work array WV available for   
   >          workspace.  NV.GE.NW.   
   > \endverbatim   
   >   
   > \param[out] WV   
   > \verbatim   
   >          WV is DOUBLE PRECISION array, dimension (LDWV,NW)   
   > \endverbatim   
   >   
   > \param[in] LDWV   
   > \verbatim   
   >          LDWV is integer   
   >          The leading dimension of W just as declared in the   
   >          calling subroutine.  NW .LE. LDV   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LWORK)   
   >          On exit, WORK(1) is set to an estimate of the optimal value   
   >          of LWORK for the given values of N, NW, KTOP and KBOT.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is integer   
   >          The dimension of the work array WORK.  LWORK = 2*NW   
   >          suffices, but greater efficiency may result from larger   
   >          values of LWORK.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; DLAQR3   
   >          only estimates the optimal workspace size for the given   
   >          values of N, NW, KTOP and KBOT.  The estimate is returned   
   >          in WORK(1).  No error message related to LWORK is issued   
   >          by XERBLA.  Neither H nor Z are accessed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaqr3_(logical *wantt, logical *wantz, integer *n, 
	integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer *
	ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, 
	integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal *
	v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer *
	nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork)
{
    /* System generated locals */
    integer h_dim1, h_offset, t_dim1, t_offset, v_dim1, v_offset, wv_dim1, 
	    wv_offset, z_dim1, z_offset, i__1, i__2, i__3, i__4;
    doublereal d__1, d__2, d__3, d__4, d__5, d__6;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, k;
    doublereal s, aa, bb, cc, dd, cs, sn;
    integer jw;
    doublereal evi, evk, foo;
    integer kln;
    doublereal tau, ulp;
    integer lwk1, lwk2, lwk3;
    doublereal beta;
    integer kend, kcol, info, nmin, ifst, ilst, ltop, krow;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *), igraphdgemm_(char *, char *, integer *, integer *
	    , integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    logical bulge;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    integer infqr, kwtop;
    extern /* Subroutine */ int igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlaqr4_(
	    logical *, logical *, integer *, integer *, integer *, doublereal 
	    *, integer *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, integer *), 
	    igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdgehrd_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *), igraphdlarfg_(integer *, doublereal *, doublereal *, 
	    integer *, doublereal *), igraphdlahqr_(logical *, logical *, integer *,
	     integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *), igraphdlacpy_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *);
    doublereal safmin;
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    doublereal safmax;
    extern /* Subroutine */ int igraphdlaset_(char *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *), 
	    igraphdtrexc_(char *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, integer *),
	     igraphdormhr_(char *, char *, integer *, integer *, integer *, integer 
	    *, doublereal *, integer *, doublereal *, doublereal *, integer *,
	     doublereal *, integer *, integer *);
    logical sorted;
    doublereal smlnum;
    integer lwkopt;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   

       ==== Estimate optimal workspace. ====   

       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --sr;
    --si;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    wv_dim1 = *ldwv;
    wv_offset = 1 + wv_dim1;
    wv -= wv_offset;
    --work;

    /* Function Body   
   Computing MIN */
    i__1 = *nw, i__2 = *kbot - *ktop + 1;
    jw = min(i__1,i__2);
    if (jw <= 2) {
	lwkopt = 1;
    } else {

/*        ==== Workspace query call to DGEHRD ==== */

	i__1 = jw - 1;
	igraphdgehrd_(&jw, &c__1, &i__1, &t[t_offset], ldt, &work[1], &work[1], &
		c_n1, &info);
	lwk1 = (integer) work[1];

/*        ==== Workspace query call to DORMHR ==== */

	i__1 = jw - 1;
	igraphdormhr_("R", "N", &jw, &jw, &c__1, &i__1, &t[t_offset], ldt, &work[1],
		 &v[v_offset], ldv, &work[1], &c_n1, &info);
	lwk2 = (integer) work[1];

/*        ==== Workspace query call to DLAQR4 ==== */

	igraphdlaqr4_(&c_true, &c_true, &jw, &c__1, &jw, &t[t_offset], ldt, &sr[1], 
		&si[1], &c__1, &jw, &v[v_offset], ldv, &work[1], &c_n1, &
		infqr);
	lwk3 = (integer) work[1];

/*        ==== Optimal workspace ====   

   Computing MAX */
	i__1 = jw + max(lwk1,lwk2);
	lwkopt = max(i__1,lwk3);
    }

/*     ==== Quick return in case of workspace query. ==== */

    if (*lwork == -1) {
	work[1] = (doublereal) lwkopt;
	return 0;
    }

/*     ==== Nothing to do ...   
       ... for an empty active block ... ==== */
    *ns = 0;
    *nd = 0;
    work[1] = 1.;
    if (*ktop > *kbot) {
	return 0;
    }
/*     ... nor for an empty deflation window. ==== */
    if (*nw < 1) {
	return 0;
    }

/*     ==== Machine constants ==== */

    safmin = igraphdlamch_("SAFE MINIMUM");
    safmax = 1. / safmin;
    igraphdlabad_(&safmin, &safmax);
    ulp = igraphdlamch_("PRECISION");
    smlnum = safmin * ((doublereal) (*n) / ulp);

/*     ==== Setup deflation window ====   

   Computing MIN */
    i__1 = *nw, i__2 = *kbot - *ktop + 1;
    jw = min(i__1,i__2);
    kwtop = *kbot - jw + 1;
    if (kwtop == *ktop) {
	s = 0.;
    } else {
	s = h__[kwtop + (kwtop - 1) * h_dim1];
    }

    if (*kbot == kwtop) {

/*        ==== 1-by-1 deflation window: not much to do ==== */

	sr[kwtop] = h__[kwtop + kwtop * h_dim1];
	si[kwtop] = 0.;
	*ns = 1;
	*nd = 0;
/* Computing MAX */
	d__2 = smlnum, d__3 = ulp * (d__1 = h__[kwtop + kwtop * h_dim1], abs(
		d__1));
	if (abs(s) <= max(d__2,d__3)) {
	    *ns = 0;
	    *nd = 1;
	    if (kwtop > *ktop) {
		h__[kwtop + (kwtop - 1) * h_dim1] = 0.;
	    }
	}
	work[1] = 1.;
	return 0;
    }

/*     ==== Convert to spike-triangular form.  (In case of a   
       .    rare QR failure, this routine continues to do   
       .    aggressive early deflation using that part of   
       .    the deflation window that converged using INFQR   
       .    here and there to keep track.) ==== */

    igraphdlacpy_("U", &jw, &jw, &h__[kwtop + kwtop * h_dim1], ldh, &t[t_offset], 
	    ldt);
    i__1 = jw - 1;
    i__2 = *ldh + 1;
    i__3 = *ldt + 1;
    igraphdcopy_(&i__1, &h__[kwtop + 1 + kwtop * h_dim1], &i__2, &t[t_dim1 + 2], &
	    i__3);

    igraphdlaset_("A", &jw, &jw, &c_b17, &c_b18, &v[v_offset], ldv);
    nmin = igraphilaenv_(&c__12, "DLAQR3", "SV", &jw, &c__1, &jw, lwork, (ftnlen)6, 
	    (ftnlen)2);
    if (jw > nmin) {
	igraphdlaqr4_(&c_true, &c_true, &jw, &c__1, &jw, &t[t_offset], ldt, &sr[
		kwtop], &si[kwtop], &c__1, &jw, &v[v_offset], ldv, &work[1], 
		lwork, &infqr);
    } else {
	igraphdlahqr_(&c_true, &c_true, &jw, &c__1, &jw, &t[t_offset], ldt, &sr[
		kwtop], &si[kwtop], &c__1, &jw, &v[v_offset], ldv, &infqr);
    }

/*     ==== DTREXC needs a clean margin near the diagonal ==== */

    i__1 = jw - 3;
    for (j = 1; j <= i__1; ++j) {
	t[j + 2 + j * t_dim1] = 0.;
	t[j + 3 + j * t_dim1] = 0.;
/* L10: */
    }
    if (jw > 2) {
	t[jw + (jw - 2) * t_dim1] = 0.;
    }

/*     ==== Deflation detection loop ==== */

    *ns = jw;
    ilst = infqr + 1;
L20:
    if (ilst <= *ns) {
	if (*ns == 1) {
	    bulge = FALSE_;
	} else {
	    bulge = t[*ns + (*ns - 1) * t_dim1] != 0.;
	}

/*        ==== Small spike tip test for deflation ==== */

	if (! bulge) {

/*           ==== Real eigenvalue ==== */

	    foo = (d__1 = t[*ns + *ns * t_dim1], abs(d__1));
	    if (foo == 0.) {
		foo = abs(s);
	    }
/* Computing MAX */
	    d__2 = smlnum, d__3 = ulp * foo;
	    if ((d__1 = s * v[*ns * v_dim1 + 1], abs(d__1)) <= max(d__2,d__3))
		     {

/*              ==== Deflatable ==== */

		--(*ns);
	    } else {

/*              ==== Undeflatable.   Move it up out of the way.   
                .    (DTREXC can not fail in this case.) ==== */

		ifst = *ns;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		++ilst;
	    }
	} else {

/*           ==== Complex conjugate pair ==== */

	    foo = (d__3 = t[*ns + *ns * t_dim1], abs(d__3)) + sqrt((d__1 = t[*
		    ns + (*ns - 1) * t_dim1], abs(d__1))) * sqrt((d__2 = t[*
		    ns - 1 + *ns * t_dim1], abs(d__2)));
	    if (foo == 0.) {
		foo = abs(s);
	    }
/* Computing MAX */
	    d__3 = (d__1 = s * v[*ns * v_dim1 + 1], abs(d__1)), d__4 = (d__2 =
		     s * v[(*ns - 1) * v_dim1 + 1], abs(d__2));
/* Computing MAX */
	    d__5 = smlnum, d__6 = ulp * foo;
	    if (max(d__3,d__4) <= max(d__5,d__6)) {

/*              ==== Deflatable ==== */

		*ns += -2;
	    } else {

/*              ==== Undeflatable. Move them up out of the way.   
                .    Fortunately, DTREXC does the right thing with   
                .    ILST in case of a rare exchange failure. ==== */

		ifst = *ns;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		ilst += 2;
	    }
	}

/*        ==== End deflation detection loop ==== */

	goto L20;
    }

/*        ==== Return to Hessenberg form ==== */

    if (*ns == 0) {
	s = 0.;
    }

    if (*ns < jw) {

/*        ==== sorting diagonal blocks of T improves accuracy for   
          .    graded matrices.  Bubble sort deals well with   
          .    exchange failures. ==== */

	sorted = FALSE_;
	i__ = *ns + 1;
L30:
	if (sorted) {
	    goto L50;
	}
	sorted = TRUE_;

	kend = i__ - 1;
	i__ = infqr + 1;
	if (i__ == *ns) {
	    k = i__ + 1;
	} else if (t[i__ + 1 + i__ * t_dim1] == 0.) {
	    k = i__ + 1;
	} else {
	    k = i__ + 2;
	}
L40:
	if (k <= kend) {
	    if (k == i__ + 1) {
		evi = (d__1 = t[i__ + i__ * t_dim1], abs(d__1));
	    } else {
		evi = (d__3 = t[i__ + i__ * t_dim1], abs(d__3)) + sqrt((d__1 =
			 t[i__ + 1 + i__ * t_dim1], abs(d__1))) * sqrt((d__2 =
			 t[i__ + (i__ + 1) * t_dim1], abs(d__2)));
	    }

	    if (k == kend) {
		evk = (d__1 = t[k + k * t_dim1], abs(d__1));
	    } else if (t[k + 1 + k * t_dim1] == 0.) {
		evk = (d__1 = t[k + k * t_dim1], abs(d__1));
	    } else {
		evk = (d__3 = t[k + k * t_dim1], abs(d__3)) + sqrt((d__1 = t[
			k + 1 + k * t_dim1], abs(d__1))) * sqrt((d__2 = t[k + 
			(k + 1) * t_dim1], abs(d__2)));
	    }

	    if (evi >= evk) {
		i__ = k;
	    } else {
		sorted = FALSE_;
		ifst = i__;
		ilst = k;
		igraphdtrexc_("V", &jw, &t[t_offset], ldt, &v[v_offset], ldv, &ifst,
			 &ilst, &work[1], &info);
		if (info == 0) {
		    i__ = ilst;
		} else {
		    i__ = k;
		}
	    }
	    if (i__ == kend) {
		k = i__ + 1;
	    } else if (t[i__ + 1 + i__ * t_dim1] == 0.) {
		k = i__ + 1;
	    } else {
		k = i__ + 2;
	    }
	    goto L40;
	}
	goto L30;
L50:
	;
    }

/*     ==== Restore shift/eigenvalue array from T ==== */

    i__ = jw;
L60:
    if (i__ >= infqr + 1) {
	if (i__ == infqr + 1) {
	    sr[kwtop + i__ - 1] = t[i__ + i__ * t_dim1];
	    si[kwtop + i__ - 1] = 0.;
	    --i__;
	} else if (t[i__ + (i__ - 1) * t_dim1] == 0.) {
	    sr[kwtop + i__ - 1] = t[i__ + i__ * t_dim1];
	    si[kwtop + i__ - 1] = 0.;
	    --i__;
	} else {
	    aa = t[i__ - 1 + (i__ - 1) * t_dim1];
	    cc = t[i__ + (i__ - 1) * t_dim1];
	    bb = t[i__ - 1 + i__ * t_dim1];
	    dd = t[i__ + i__ * t_dim1];
	    igraphdlanv2_(&aa, &bb, &cc, &dd, &sr[kwtop + i__ - 2], &si[kwtop + i__ 
		    - 2], &sr[kwtop + i__ - 1], &si[kwtop + i__ - 1], &cs, &
		    sn);
	    i__ += -2;
	}
	goto L60;
    }

    if (*ns < jw || s == 0.) {
	if (*ns > 1 && s != 0.) {

/*           ==== Reflect spike back into lower triangle ==== */

	    igraphdcopy_(ns, &v[v_offset], ldv, &work[1], &c__1);
	    beta = work[1];
	    igraphdlarfg_(ns, &beta, &work[2], &c__1, &tau);
	    work[1] = 1.;

	    i__1 = jw - 2;
	    i__2 = jw - 2;
	    igraphdlaset_("L", &i__1, &i__2, &c_b17, &c_b17, &t[t_dim1 + 3], ldt);

	    igraphdlarf_("L", ns, &jw, &work[1], &c__1, &tau, &t[t_offset], ldt, &
		    work[jw + 1]);
	    igraphdlarf_("R", ns, ns, &work[1], &c__1, &tau, &t[t_offset], ldt, &
		    work[jw + 1]);
	    igraphdlarf_("R", &jw, ns, &work[1], &c__1, &tau, &v[v_offset], ldv, &
		    work[jw + 1]);

	    i__1 = *lwork - jw;
	    igraphdgehrd_(&jw, &c__1, ns, &t[t_offset], ldt, &work[1], &work[jw + 1]
		    , &i__1, &info);
	}

/*        ==== Copy updated reduced window into place ==== */

	if (kwtop > 1) {
	    h__[kwtop + (kwtop - 1) * h_dim1] = s * v[v_dim1 + 1];
	}
	igraphdlacpy_("U", &jw, &jw, &t[t_offset], ldt, &h__[kwtop + kwtop * h_dim1]
		, ldh);
	i__1 = jw - 1;
	i__2 = *ldt + 1;
	i__3 = *ldh + 1;
	igraphdcopy_(&i__1, &t[t_dim1 + 2], &i__2, &h__[kwtop + 1 + kwtop * h_dim1],
		 &i__3);

/*        ==== Accumulate orthogonal matrix in order update   
          .    H and Z, if requested.  ==== */

	if (*ns > 1 && s != 0.) {
	    i__1 = *lwork - jw;
	    igraphdormhr_("R", "N", &jw, ns, &c__1, ns, &t[t_offset], ldt, &work[1],
		     &v[v_offset], ldv, &work[jw + 1], &i__1, &info);
	}

/*        ==== Update vertical slab in H ==== */

	if (*wantt) {
	    ltop = 1;
	} else {
	    ltop = *ktop;
	}
	i__1 = kwtop - 1;
	i__2 = *nv;
	for (krow = ltop; i__2 < 0 ? krow >= i__1 : krow <= i__1; krow += 
		i__2) {
/* Computing MIN */
	    i__3 = *nv, i__4 = kwtop - krow;
	    kln = min(i__3,i__4);
	    igraphdgemm_("N", "N", &kln, &jw, &jw, &c_b18, &h__[krow + kwtop * 
		    h_dim1], ldh, &v[v_offset], ldv, &c_b17, &wv[wv_offset], 
		    ldwv);
	    igraphdlacpy_("A", &kln, &jw, &wv[wv_offset], ldwv, &h__[krow + kwtop * 
		    h_dim1], ldh);
/* L70: */
	}

/*        ==== Update horizontal slab in H ==== */

	if (*wantt) {
	    i__2 = *n;
	    i__1 = *nh;
	    for (kcol = *kbot + 1; i__1 < 0 ? kcol >= i__2 : kcol <= i__2; 
		    kcol += i__1) {
/* Computing MIN */
		i__3 = *nh, i__4 = *n - kcol + 1;
		kln = min(i__3,i__4);
		igraphdgemm_("C", "N", &jw, &kln, &jw, &c_b18, &v[v_offset], ldv, &
			h__[kwtop + kcol * h_dim1], ldh, &c_b17, &t[t_offset],
			 ldt);
		igraphdlacpy_("A", &jw, &kln, &t[t_offset], ldt, &h__[kwtop + kcol *
			 h_dim1], ldh);
/* L80: */
	    }
	}

/*        ==== Update vertical slab in Z ==== */

	if (*wantz) {
	    i__1 = *ihiz;
	    i__2 = *nv;
	    for (krow = *iloz; i__2 < 0 ? krow >= i__1 : krow <= i__1; krow +=
		     i__2) {
/* Computing MIN */
		i__3 = *nv, i__4 = *ihiz - krow + 1;
		kln = min(i__3,i__4);
		igraphdgemm_("N", "N", &kln, &jw, &jw, &c_b18, &z__[krow + kwtop * 
			z_dim1], ldz, &v[v_offset], ldv, &c_b17, &wv[
			wv_offset], ldwv);
		igraphdlacpy_("A", &kln, &jw, &wv[wv_offset], ldwv, &z__[krow + 
			kwtop * z_dim1], ldz);
/* L90: */
	    }
	}
    }

/*     ==== Return the number of deflations ... ==== */

    *nd = jw - *ns;

/*     ==== ... and the number of shifts. (Subtracting   
       .    INFQR from the spike length takes care   
       .    of the case of a rare QR failure while   
       .    calculating eigenvalues of the deflation   
       .    window.)  ==== */

    *ns -= infqr;

/*      ==== Return optimal workspace. ==== */

    work[1] = (doublereal) lwkopt;

/*     ==== End of DLAQR3 ==== */

    return 0;
} /* igraphdlaqr3_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr4.c0000644000175100001710000007043400000000000023745 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__13 = 13;
static integer c__15 = 15;
static integer c_n1 = -1;
static integer c__12 = 12;
static integer c__14 = 14;
static integer c__16 = 16;
static logical c_false = FALSE_;
static integer c__1 = 1;
static integer c__3 = 3;

/* > \brief \b DLAQR4 computes the eigenvalues of a Hessenberg matrix, and optionally the matrices from the Sc
hur decomposition.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR4 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR4( WANTT, WANTZ, N, ILO, IHI, H, LDH, WR, WI,   
                            ILOZ, IHIZ, Z, LDZ, WORK, LWORK, INFO )   

         INTEGER            IHI, IHIZ, ILO, ILOZ, INFO, LDH, LDZ, LWORK, N   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), WI( * ), WORK( * ), WR( * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DLAQR4 implements one level of recursion for DLAQR0.   
   >    It is a complete implementation of the small bulge multi-shift   
   >    QR algorithm.  It may be called by DLAQR0 and, for large enough   
   >    deflation window size, it may be called by DLAQR3.  This   
   >    subroutine is identical to DLAQR0 except that it calls DLAQR2   
   >    instead of DLAQR3.   
   >   
   >    DLAQR4 computes the eigenvalues of a Hessenberg matrix H   
   >    and, optionally, the matrices T and Z from the Schur decomposition   
   >    H = Z T Z**T, where T is an upper quasi-triangular matrix (the   
   >    Schur form), and Z is the orthogonal matrix of Schur vectors.   
   >   
   >    Optionally Z may be postmultiplied into an input orthogonal   
   >    matrix Q so that this routine can give the Schur factorization   
   >    of a matrix A which has been reduced to the Hessenberg form H   
   >    by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is LOGICAL   
   >          = .TRUE. : the full Schur form T is required;   
   >          = .FALSE.: only eigenvalues are required.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is LOGICAL   
   >          = .TRUE. : the matrix of Schur vectors Z is required;   
   >          = .FALSE.: Schur vectors are not required.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           The order of the matrix H.  N .GE. 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >           It is assumed that H is already upper triangular in rows   
   >           and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,   
   >           H(ILO,ILO-1) is zero. ILO and IHI are normally set by a   
   >           previous call to DGEBAL, and then passed to DGEHRD when the   
   >           matrix output by DGEBAL is reduced to Hessenberg form.   
   >           Otherwise, ILO and IHI should be set to 1 and N,   
   >           respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.   
   >           If N = 0, then ILO = 1 and IHI = 0.   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array, dimension (LDH,N)   
   >           On entry, the upper Hessenberg matrix H.   
   >           On exit, if INFO = 0 and WANTT is .TRUE., then H contains   
   >           the upper quasi-triangular matrix T from the Schur   
   >           decomposition (the Schur form); 2-by-2 diagonal blocks   
   >           (corresponding to complex conjugate pairs of eigenvalues)   
   >           are returned in standard form, with H(i,i) = H(i+1,i+1)   
   >           and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is   
   >           .FALSE., then the contents of H are unspecified on exit.   
   >           (The output value of H when INFO.GT.0 is given under the   
   >           description of INFO below.)   
   >   
   >           This subroutine may explicitly set H(i,j) = 0 for i.GT.j and   
   >           j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is INTEGER   
   >           The leading dimension of the array H. LDH .GE. max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (IHI)   
   > \endverbatim   
   >   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (IHI)   
   >           The real and imaginary parts, respectively, of the computed   
   >           eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)   
   >           and WI(ILO:IHI). If two eigenvalues are computed as a   
   >           complex conjugate pair, they are stored in consecutive   
   >           elements of WR and WI, say the i-th and (i+1)th, with   
   >           WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then   
   >           the eigenvalues are stored in the same order as on the   
   >           diagonal of the Schur form returned in H, with   
   >           WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal   
   >           block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and   
   >           WI(i+1) = -WI(i).   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >           Specify the rows of Z to which transformations must be   
   >           applied if WANTZ is .TRUE..   
   >           1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ,IHI)   
   >           If WANTZ is .FALSE., then Z is not referenced.   
   >           If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is   
   >           replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the   
   >           orthogonal Schur factor of H(ILO:IHI,ILO:IHI).   
   >           (The output value of Z when INFO.GT.0 is given under   
   >           the description of INFO below.)   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >           The leading dimension of the array Z.  if WANTZ is .TRUE.   
   >           then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension LWORK   
   >           On exit, if LWORK = -1, WORK(1) returns an estimate of   
   >           the optimal value for LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >           The dimension of the array WORK.  LWORK .GE. max(1,N)   
   >           is sufficient, but LWORK typically as large as 6*N may   
   >           be required for optimal performance.  A workspace query   
   >           to determine the optimal workspace size is recommended.   
   >   
   >           If LWORK = -1, then DLAQR4 does a workspace query.   
   >           In this case, DLAQR4 checks the input parameters and   
   >           estimates the optimal workspace size for the given   
   >           values of N, ILO and IHI.  The estimate is returned   
   >           in WORK(1).  No error message related to LWORK is   
   >           issued by XERBLA.  Neither H nor Z are accessed.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >             =  0:  successful exit   
   >           .GT. 0:  if INFO = i, DLAQR4 failed to compute all of   
   >                the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR   
   >                and WI contain those eigenvalues which have been   
   >                successfully computed.  (Failures are rare.)   
   >   
   >                If INFO .GT. 0 and WANT is .FALSE., then on exit,   
   >                the remaining unconverged eigenvalues are the eigen-   
   >                values of the upper Hessenberg matrix rows and   
   >                columns ILO through INFO of the final, output   
   >                value of H.   
   >   
   >                If INFO .GT. 0 and WANTT is .TRUE., then on exit   
   >   
   >           (*)  (initial value of H)*U  = U*(final value of H)   
   >   
   >                where U is a orthogonal matrix.  The final   
   >                value of  H is upper Hessenberg and triangular in   
   >                rows and columns INFO+1 through IHI.   
   >   
   >                If INFO .GT. 0 and WANTZ is .TRUE., then on exit   
   >   
   >                  (final value of Z(ILO:IHI,ILOZ:IHIZ)   
   >                   =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U   
   >   
   >                where U is the orthogonal matrix in (*) (regard-   
   >                less of the value of WANTT.)   
   >   
   >                If INFO .GT. 0 and WANTZ is .FALSE., then Z is not   
   >                accessed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   

   > \par References:   
    ================   
   >   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part I: Maintaining Well Focused Shifts, and Level 3   
   >       Performance, SIAM Journal of Matrix Analysis, volume 23, pages   
   >       929--947, 2002.   
   > \n   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part II: Aggressive Early Deflation, SIAM Journal   
   >       of Matrix Analysis, volume 23, pages 948--973, 2002.   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaqr4_(logical *wantt, logical *wantz, integer *n, 
	integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
	*wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
	integer *ldz, doublereal *work, integer *lwork, integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, z_dim1, z_offset, i__1, i__2, i__3, i__4, i__5;
    doublereal d__1, d__2, d__3, d__4;

    /* Local variables */
    integer i__, k;
    doublereal aa, bb, cc, dd;
    integer ld;
    doublereal cs;
    integer nh, it, ks, kt;
    doublereal sn;
    integer ku, kv, ls, ns;
    doublereal ss;
    integer nw, inf, kdu, nho, nve, kwh, nsr, nwr, kwv, ndec, ndfl, kbot, 
	    nmin;
    doublereal swap;
    integer ktop;
    doublereal zdum[1]	/* was [1][1] */;
    integer kacc22, itmax, nsmax, nwmax, kwtop;
    extern /* Subroutine */ int igraphdlaqr2_(logical *, logical *, integer *, 
	    integer *, integer *, integer *, doublereal *, integer *, integer 
	    *, integer *, doublereal *, integer *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlaqr5_(
	    logical *, logical *, integer *, integer *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, doublereal *, integer *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *, doublereal *, integer *);
    integer nibble;
    extern /* Subroutine */ int igraphdlahqr_(logical *, logical *, integer *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *), igraphdlacpy_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    char jbcmpz[2];
    integer nwupbd;
    logical sorted;
    integer lwkopt;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   

       ==== Matrices of order NTINY or smaller must be processed by   
       .    DLAHQR because of insufficient subdiagonal scratch space.   
       .    (This is a hard limit.) ====   

       ==== Exceptional deflation windows:  try to cure rare   
       .    slow convergence by varying the size of the   
       .    deflation window after KEXNW iterations. ====   

       ==== Exceptional shifts: try to cure rare slow convergence   
       .    with ad-hoc exceptional shifts every KEXSH iterations.   
       .    ====   

       ==== The constants WILK1 and WILK2 are used to form the   
       .    exceptional shifts. ====   
       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --wr;
    --wi;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --work;

    /* Function Body */
    *info = 0;

/*     ==== Quick return for N = 0: nothing to do. ==== */

    if (*n == 0) {
	work[1] = 1.;
	return 0;
    }

    if (*n <= 11) {

/*        ==== Tiny matrices must use DLAHQR. ==== */

	lwkopt = 1;
	if (*lwork != -1) {
	    igraphdlahqr_(wantt, wantz, n, ilo, ihi, &h__[h_offset], ldh, &wr[1], &
		    wi[1], iloz, ihiz, &z__[z_offset], ldz, info);
	}
    } else {

/*        ==== Use small bulge multi-shift QR with aggressive early   
          .    deflation on larger-than-tiny matrices. ====   

          ==== Hope for the best. ==== */

	*info = 0;

/*        ==== Set up job flags for ILAENV. ==== */

	if (*wantt) {
	    *(unsigned char *)jbcmpz = 'S';
	} else {
	    *(unsigned char *)jbcmpz = 'E';
	}
	if (*wantz) {
	    *(unsigned char *)&jbcmpz[1] = 'V';
	} else {
	    *(unsigned char *)&jbcmpz[1] = 'N';
	}

/*        ==== NWR = recommended deflation window size.  At this   
          .    point,  N .GT. NTINY = 11, so there is enough   
          .    subdiagonal workspace for NWR.GE.2 as required.   
          .    (In fact, there is enough subdiagonal space for   
          .    NWR.GE.3.) ==== */

	nwr = igraphilaenv_(&c__13, "DLAQR4", jbcmpz, n, ilo, ihi, lwork, (ftnlen)6,
		 (ftnlen)2);
	nwr = max(2,nwr);
/* Computing MIN */
	i__1 = *ihi - *ilo + 1, i__2 = (*n - 1) / 3, i__1 = min(i__1,i__2);
	nwr = min(i__1,nwr);

/*        ==== NSR = recommended number of simultaneous shifts.   
          .    At this point N .GT. NTINY = 11, so there is at   
          .    enough subdiagonal workspace for NSR to be even   
          .    and greater than or equal to two as required. ==== */

	nsr = igraphilaenv_(&c__15, "DLAQR4", jbcmpz, n, ilo, ihi, lwork, (ftnlen)6,
		 (ftnlen)2);
/* Computing MIN */
	i__1 = nsr, i__2 = (*n + 6) / 9, i__1 = min(i__1,i__2), i__2 = *ihi - 
		*ilo;
	nsr = min(i__1,i__2);
/* Computing MAX */
	i__1 = 2, i__2 = nsr - nsr % 2;
	nsr = max(i__1,i__2);

/*        ==== Estimate optimal workspace ====   

          ==== Workspace query call to DLAQR2 ==== */

	i__1 = nwr + 1;
	igraphdlaqr2_(wantt, wantz, n, ilo, ihi, &i__1, &h__[h_offset], ldh, iloz, 
		ihiz, &z__[z_offset], ldz, &ls, &ld, &wr[1], &wi[1], &h__[
		h_offset], ldh, n, &h__[h_offset], ldh, n, &h__[h_offset], 
		ldh, &work[1], &c_n1);

/*        ==== Optimal workspace = MAX(DLAQR5, DLAQR2) ====   

   Computing MAX */
	i__1 = nsr * 3 / 2, i__2 = (integer) work[1];
	lwkopt = max(i__1,i__2);

/*        ==== Quick return in case of workspace query. ==== */

	if (*lwork == -1) {
	    work[1] = (doublereal) lwkopt;
	    return 0;
	}

/*        ==== DLAHQR/DLAQR0 crossover point ==== */

	nmin = igraphilaenv_(&c__12, "DLAQR4", jbcmpz, n, ilo, ihi, lwork, (ftnlen)
		6, (ftnlen)2);
	nmin = max(11,nmin);

/*        ==== Nibble crossover point ==== */

	nibble = igraphilaenv_(&c__14, "DLAQR4", jbcmpz, n, ilo, ihi, lwork, (
		ftnlen)6, (ftnlen)2);
	nibble = max(0,nibble);

/*        ==== Accumulate reflections during ttswp?  Use block   
          .    2-by-2 structure during matrix-matrix multiply? ==== */

	kacc22 = igraphilaenv_(&c__16, "DLAQR4", jbcmpz, n, ilo, ihi, lwork, (
		ftnlen)6, (ftnlen)2);
	kacc22 = max(0,kacc22);
	kacc22 = min(2,kacc22);

/*        ==== NWMAX = the largest possible deflation window for   
          .    which there is sufficient workspace. ====   

   Computing MIN */
	i__1 = (*n - 1) / 3, i__2 = *lwork / 2;
	nwmax = min(i__1,i__2);
	nw = nwmax;

/*        ==== NSMAX = the Largest number of simultaneous shifts   
          .    for which there is sufficient workspace. ====   

   Computing MIN */
	i__1 = (*n + 6) / 9, i__2 = (*lwork << 1) / 3;
	nsmax = min(i__1,i__2);
	nsmax -= nsmax % 2;

/*        ==== NDFL: an iteration count restarted at deflation. ==== */

	ndfl = 1;

/*        ==== ITMAX = iteration limit ====   

   Computing MAX */
	i__1 = 10, i__2 = *ihi - *ilo + 1;
	itmax = max(i__1,i__2) * 30;

/*        ==== Last row and column in the active block ==== */

	kbot = *ihi;

/*        ==== Main Loop ==== */

	i__1 = itmax;
	for (it = 1; it <= i__1; ++it) {

/*           ==== Done when KBOT falls below ILO ==== */

	    if (kbot < *ilo) {
		goto L90;
	    }

/*           ==== Locate active block ==== */

	    i__2 = *ilo + 1;
	    for (k = kbot; k >= i__2; --k) {
		if (h__[k + (k - 1) * h_dim1] == 0.) {
		    goto L20;
		}
/* L10: */
	    }
	    k = *ilo;
L20:
	    ktop = k;

/*           ==== Select deflation window size:   
             .    Typical Case:   
             .      If possible and advisable, nibble the entire   
             .      active block.  If not, use size MIN(NWR,NWMAX)   
             .      or MIN(NWR+1,NWMAX) depending upon which has   
             .      the smaller corresponding subdiagonal entry   
             .      (a heuristic).   
             .   
             .    Exceptional Case:   
             .      If there have been no deflations in KEXNW or   
             .      more iterations, then vary the deflation window   
             .      size.   At first, because, larger windows are,   
             .      in general, more powerful than smaller ones,   
             .      rapidly increase the window to the maximum possible.   
             .      Then, gradually reduce the window size. ==== */

	    nh = kbot - ktop + 1;
	    nwupbd = min(nh,nwmax);
	    if (ndfl < 5) {
		nw = min(nwupbd,nwr);
	    } else {
/* Computing MIN */
		i__2 = nwupbd, i__3 = nw << 1;
		nw = min(i__2,i__3);
	    }
	    if (nw < nwmax) {
		if (nw >= nh - 1) {
		    nw = nh;
		} else {
		    kwtop = kbot - nw + 1;
		    if ((d__1 = h__[kwtop + (kwtop - 1) * h_dim1], abs(d__1)) 
			    > (d__2 = h__[kwtop - 1 + (kwtop - 2) * h_dim1], 
			    abs(d__2))) {
			++nw;
		    }
		}
	    }
	    if (ndfl < 5) {
		ndec = -1;
	    } else if (ndec >= 0 || nw >= nwupbd) {
		++ndec;
		if (nw - ndec < 2) {
		    ndec = 0;
		}
		nw -= ndec;
	    }

/*           ==== Aggressive early deflation:   
             .    split workspace under the subdiagonal into   
             .      - an nw-by-nw work array V in the lower   
             .        left-hand-corner,   
             .      - an NW-by-at-least-NW-but-more-is-better   
             .        (NW-by-NHO) horizontal work array along   
             .        the bottom edge,   
             .      - an at-least-NW-but-more-is-better (NHV-by-NW)   
             .        vertical work array along the left-hand-edge.   
             .        ==== */

	    kv = *n - nw + 1;
	    kt = nw + 1;
	    nho = *n - nw - 1 - kt + 1;
	    kwv = nw + 2;
	    nve = *n - nw - kwv + 1;

/*           ==== Aggressive early deflation ==== */

	    igraphdlaqr2_(wantt, wantz, n, &ktop, &kbot, &nw, &h__[h_offset], ldh, 
		    iloz, ihiz, &z__[z_offset], ldz, &ls, &ld, &wr[1], &wi[1],
		     &h__[kv + h_dim1], ldh, &nho, &h__[kv + kt * h_dim1], 
		    ldh, &nve, &h__[kwv + h_dim1], ldh, &work[1], lwork);

/*           ==== Adjust KBOT accounting for new deflations. ==== */

	    kbot -= ld;

/*           ==== KS points to the shifts. ==== */

	    ks = kbot - ls + 1;

/*           ==== Skip an expensive QR sweep if there is a (partly   
             .    heuristic) reason to expect that many eigenvalues   
             .    will deflate without it.  Here, the QR sweep is   
             .    skipped if many eigenvalues have just been deflated   
             .    or if the remaining active block is small. */

	    if (ld == 0 || ld * 100 <= nw * nibble && kbot - ktop + 1 > min(
		    nmin,nwmax)) {

/*              ==== NS = nominal number of simultaneous shifts.   
                .    This may be lowered (slightly) if DLAQR2   
                .    did not provide that many shifts. ====   

   Computing MIN   
   Computing MAX */
		i__4 = 2, i__5 = kbot - ktop;
		i__2 = min(nsmax,nsr), i__3 = max(i__4,i__5);
		ns = min(i__2,i__3);
		ns -= ns % 2;

/*              ==== If there have been no deflations   
                .    in a multiple of KEXSH iterations,   
                .    then try exceptional shifts.   
                .    Otherwise use shifts provided by   
                .    DLAQR2 above or from the eigenvalues   
                .    of a trailing principal submatrix. ==== */

		if (ndfl % 6 == 0) {
		    ks = kbot - ns + 1;
/* Computing MAX */
		    i__3 = ks + 1, i__4 = ktop + 2;
		    i__2 = max(i__3,i__4);
		    for (i__ = kbot; i__ >= i__2; i__ += -2) {
			ss = (d__1 = h__[i__ + (i__ - 1) * h_dim1], abs(d__1))
				 + (d__2 = h__[i__ - 1 + (i__ - 2) * h_dim1], 
				abs(d__2));
			aa = ss * .75 + h__[i__ + i__ * h_dim1];
			bb = ss;
			cc = ss * -.4375;
			dd = aa;
			igraphdlanv2_(&aa, &bb, &cc, &dd, &wr[i__ - 1], &wi[i__ - 1]
				, &wr[i__], &wi[i__], &cs, &sn);
/* L30: */
		    }
		    if (ks == ktop) {
			wr[ks + 1] = h__[ks + 1 + (ks + 1) * h_dim1];
			wi[ks + 1] = 0.;
			wr[ks] = wr[ks + 1];
			wi[ks] = wi[ks + 1];
		    }
		} else {

/*                 ==== Got NS/2 or fewer shifts? Use DLAHQR   
                   .    on a trailing principal submatrix to   
                   .    get more. (Since NS.LE.NSMAX.LE.(N+6)/9,   
                   .    there is enough space below the subdiagonal   
                   .    to fit an NS-by-NS scratch array.) ==== */

		    if (kbot - ks + 1 <= ns / 2) {
			ks = kbot - ns + 1;
			kt = *n - ns + 1;
			igraphdlacpy_("A", &ns, &ns, &h__[ks + ks * h_dim1], ldh, &
				h__[kt + h_dim1], ldh);
			igraphdlahqr_(&c_false, &c_false, &ns, &c__1, &ns, &h__[kt 
				+ h_dim1], ldh, &wr[ks], &wi[ks], &c__1, &
				c__1, zdum, &c__1, &inf);
			ks += inf;

/*                    ==== In case of a rare QR failure use   
                      .    eigenvalues of the trailing 2-by-2   
                      .    principal submatrix.  ==== */

			if (ks >= kbot) {
			    aa = h__[kbot - 1 + (kbot - 1) * h_dim1];
			    cc = h__[kbot + (kbot - 1) * h_dim1];
			    bb = h__[kbot - 1 + kbot * h_dim1];
			    dd = h__[kbot + kbot * h_dim1];
			    igraphdlanv2_(&aa, &bb, &cc, &dd, &wr[kbot - 1], &wi[
				    kbot - 1], &wr[kbot], &wi[kbot], &cs, &sn)
				    ;
			    ks = kbot - 1;
			}
		    }

		    if (kbot - ks + 1 > ns) {

/*                    ==== Sort the shifts (Helps a little)   
                      .    Bubble sort keeps complex conjugate   
                      .    pairs together. ==== */

			sorted = FALSE_;
			i__2 = ks + 1;
			for (k = kbot; k >= i__2; --k) {
			    if (sorted) {
				goto L60;
			    }
			    sorted = TRUE_;
			    i__3 = k - 1;
			    for (i__ = ks; i__ <= i__3; ++i__) {
				if ((d__1 = wr[i__], abs(d__1)) + (d__2 = wi[
					i__], abs(d__2)) < (d__3 = wr[i__ + 1]
					, abs(d__3)) + (d__4 = wi[i__ + 1], 
					abs(d__4))) {
				    sorted = FALSE_;

				    swap = wr[i__];
				    wr[i__] = wr[i__ + 1];
				    wr[i__ + 1] = swap;

				    swap = wi[i__];
				    wi[i__] = wi[i__ + 1];
				    wi[i__ + 1] = swap;
				}
/* L40: */
			    }
/* L50: */
			}
L60:
			;
		    }

/*                 ==== Shuffle shifts into pairs of real shifts   
                   .    and pairs of complex conjugate shifts   
                   .    assuming complex conjugate shifts are   
                   .    already adjacent to one another. (Yes,   
                   .    they are.)  ==== */

		    i__2 = ks + 2;
		    for (i__ = kbot; i__ >= i__2; i__ += -2) {
			if (wi[i__] != -wi[i__ - 1]) {

			    swap = wr[i__];
			    wr[i__] = wr[i__ - 1];
			    wr[i__ - 1] = wr[i__ - 2];
			    wr[i__ - 2] = swap;

			    swap = wi[i__];
			    wi[i__] = wi[i__ - 1];
			    wi[i__ - 1] = wi[i__ - 2];
			    wi[i__ - 2] = swap;
			}
/* L70: */
		    }
		}

/*              ==== If there are only two shifts and both are   
                .    real, then use only one.  ==== */

		if (kbot - ks + 1 == 2) {
		    if (wi[kbot] == 0.) {
			if ((d__1 = wr[kbot] - h__[kbot + kbot * h_dim1], abs(
				d__1)) < (d__2 = wr[kbot - 1] - h__[kbot + 
				kbot * h_dim1], abs(d__2))) {
			    wr[kbot - 1] = wr[kbot];
			} else {
			    wr[kbot] = wr[kbot - 1];
			}
		    }
		}

/*              ==== Use up to NS of the the smallest magnatiude   
                .    shifts.  If there aren't NS shifts available,   
                .    then use them all, possibly dropping one to   
                .    make the number of shifts even. ====   

   Computing MIN */
		i__2 = ns, i__3 = kbot - ks + 1;
		ns = min(i__2,i__3);
		ns -= ns % 2;
		ks = kbot - ns + 1;

/*              ==== Small-bulge multi-shift QR sweep:   
                .    split workspace under the subdiagonal into   
                .    - a KDU-by-KDU work array U in the lower   
                .      left-hand-corner,   
                .    - a KDU-by-at-least-KDU-but-more-is-better   
                .      (KDU-by-NHo) horizontal work array WH along   
                .      the bottom edge,   
                .    - and an at-least-KDU-but-more-is-better-by-KDU   
                .      (NVE-by-KDU) vertical work WV arrow along   
                .      the left-hand-edge. ==== */

		kdu = ns * 3 - 3;
		ku = *n - kdu + 1;
		kwh = kdu + 1;
		nho = *n - kdu - 3 - (kdu + 1) + 1;
		kwv = kdu + 4;
		nve = *n - kdu - kwv + 1;

/*              ==== Small-bulge multi-shift QR sweep ==== */

		igraphdlaqr5_(wantt, wantz, &kacc22, n, &ktop, &kbot, &ns, &wr[ks], 
			&wi[ks], &h__[h_offset], ldh, iloz, ihiz, &z__[
			z_offset], ldz, &work[1], &c__3, &h__[ku + h_dim1], 
			ldh, &nve, &h__[kwv + h_dim1], ldh, &nho, &h__[ku + 
			kwh * h_dim1], ldh);
	    }

/*           ==== Note progress (or the lack of it). ==== */

	    if (ld > 0) {
		ndfl = 1;
	    } else {
		++ndfl;
	    }

/*           ==== End of main loop ====   
   L80: */
	}

/*        ==== Iteration limit exceeded.  Set INFO to show where   
          .    the problem occurred and exit. ==== */

	*info = kbot;
L90:
	;
    }

/*     ==== Return the optimal value of LWORK. ==== */

    work[1] = (doublereal) lwkopt;

/*     ==== End of DLAQR4 ==== */

    return 0;
} /* igraphdlaqr4_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqr5.c0000644000175100001710000011126600000000000023745 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b7 = 0.;
static doublereal c_b8 = 1.;
static integer c__3 = 3;
static integer c__1 = 1;
static integer c__2 = 2;

/* > \brief \b DLAQR5 performs a single small-bulge multi-shift QR sweep.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQR5 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQR5( WANTT, WANTZ, KACC22, N, KTOP, KBOT, NSHFTS,   
                            SR, SI, H, LDH, ILOZ, IHIZ, Z, LDZ, V, LDV, U,   
                            LDU, NV, WV, LDWV, NH, WH, LDWH )   

         INTEGER            IHIZ, ILOZ, KACC22, KBOT, KTOP, LDH, LDU, LDV,   
        $                   LDWH, LDWV, LDZ, N, NH, NSHFTS, NV   
         LOGICAL            WANTT, WANTZ   
         DOUBLE PRECISION   H( LDH, * ), SI( * ), SR( * ), U( LDU, * ),   
        $                   V( LDV, * ), WH( LDWH, * ), WV( LDWV, * ),   
        $                   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DLAQR5, called by DLAQR0, performs a   
   >    single small-bulge multi-shift QR sweep.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] WANTT   
   > \verbatim   
   >          WANTT is logical scalar   
   >             WANTT = .true. if the quasi-triangular Schur factor   
   >             is being computed.  WANTT is set to .false. otherwise.   
   > \endverbatim   
   >   
   > \param[in] WANTZ   
   > \verbatim   
   >          WANTZ is logical scalar   
   >             WANTZ = .true. if the orthogonal Schur factor is being   
   >             computed.  WANTZ is set to .false. otherwise.   
   > \endverbatim   
   >   
   > \param[in] KACC22   
   > \verbatim   
   >          KACC22 is integer with value 0, 1, or 2.   
   >             Specifies the computation mode of far-from-diagonal   
   >             orthogonal updates.   
   >        = 0: DLAQR5 does not accumulate reflections and does not   
   >             use matrix-matrix multiply to update far-from-diagonal   
   >             matrix entries.   
   >        = 1: DLAQR5 accumulates reflections and uses matrix-matrix   
   >             multiply to update the far-from-diagonal matrix entries.   
   >        = 2: DLAQR5 accumulates reflections, uses matrix-matrix   
   >             multiply to update the far-from-diagonal matrix entries,   
   >             and takes advantage of 2-by-2 block structure during   
   >             matrix multiplies.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is integer scalar   
   >             N is the order of the Hessenberg matrix H upon which this   
   >             subroutine operates.   
   > \endverbatim   
   >   
   > \param[in] KTOP   
   > \verbatim   
   >          KTOP is integer scalar   
   > \endverbatim   
   >   
   > \param[in] KBOT   
   > \verbatim   
   >          KBOT is integer scalar   
   >             These are the first and last rows and columns of an   
   >             isolated diagonal block upon which the QR sweep is to be   
   >             applied. It is assumed without a check that   
   >                       either KTOP = 1  or   H(KTOP,KTOP-1) = 0   
   >             and   
   >                       either KBOT = N  or   H(KBOT+1,KBOT) = 0.   
   > \endverbatim   
   >   
   > \param[in] NSHFTS   
   > \verbatim   
   >          NSHFTS is integer scalar   
   >             NSHFTS gives the number of simultaneous shifts.  NSHFTS   
   >             must be positive and even.   
   > \endverbatim   
   >   
   > \param[in,out] SR   
   > \verbatim   
   >          SR is DOUBLE PRECISION array of size (NSHFTS)   
   > \endverbatim   
   >   
   > \param[in,out] SI   
   > \verbatim   
   >          SI is DOUBLE PRECISION array of size (NSHFTS)   
   >             SR contains the real parts and SI contains the imaginary   
   >             parts of the NSHFTS shifts of origin that define the   
   >             multi-shift QR sweep.  On output SR and SI may be   
   >             reordered.   
   > \endverbatim   
   >   
   > \param[in,out] H   
   > \verbatim   
   >          H is DOUBLE PRECISION array of size (LDH,N)   
   >             On input H contains a Hessenberg matrix.  On output a   
   >             multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied   
   >             to the isolated diagonal block in rows and columns KTOP   
   >             through KBOT.   
   > \endverbatim   
   >   
   > \param[in] LDH   
   > \verbatim   
   >          LDH is integer scalar   
   >             LDH is the leading dimension of H just as declared in the   
   >             calling procedure.  LDH.GE.MAX(1,N).   
   > \endverbatim   
   >   
   > \param[in] ILOZ   
   > \verbatim   
   >          ILOZ is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHIZ   
   > \verbatim   
   >          IHIZ is INTEGER   
   >             Specify the rows of Z to which transformations must be   
   >             applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array of size (LDZ,IHI)   
   >             If WANTZ = .TRUE., then the QR Sweep orthogonal   
   >             similarity transformation is accumulated into   
   >             Z(ILOZ:IHIZ,ILO:IHI) from the right.   
   >             If WANTZ = .FALSE., then Z is unreferenced.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is integer scalar   
   >             LDA is the leading dimension of Z just as declared in   
   >             the calling procedure. LDZ.GE.N.   
   > \endverbatim   
   >   
   > \param[out] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array of size (LDV,NSHFTS/2)   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is integer scalar   
   >             LDV is the leading dimension of V as declared in the   
   >             calling procedure.  LDV.GE.3.   
   > \endverbatim   
   >   
   > \param[out] U   
   > \verbatim   
   >          U is DOUBLE PRECISION array of size   
   >             (LDU,3*NSHFTS-3)   
   > \endverbatim   
   >   
   > \param[in] LDU   
   > \verbatim   
   >          LDU is integer scalar   
   >             LDU is the leading dimension of U just as declared in the   
   >             in the calling subroutine.  LDU.GE.3*NSHFTS-3.   
   > \endverbatim   
   >   
   > \param[in] NH   
   > \verbatim   
   >          NH is integer scalar   
   >             NH is the number of columns in array WH available for   
   >             workspace. NH.GE.1.   
   > \endverbatim   
   >   
   > \param[out] WH   
   > \verbatim   
   >          WH is DOUBLE PRECISION array of size (LDWH,NH)   
   > \endverbatim   
   >   
   > \param[in] LDWH   
   > \verbatim   
   >          LDWH is integer scalar   
   >             Leading dimension of WH just as declared in the   
   >             calling procedure.  LDWH.GE.3*NSHFTS-3.   
   > \endverbatim   
   >   
   > \param[in] NV   
   > \verbatim   
   >          NV is integer scalar   
   >             NV is the number of rows in WV agailable for workspace.   
   >             NV.GE.1.   
   > \endverbatim   
   >   
   > \param[out] WV   
   > \verbatim   
   >          WV is DOUBLE PRECISION array of size   
   >             (LDWV,3*NSHFTS-3)   
   > \endverbatim   
   >   
   > \param[in] LDWV   
   > \verbatim   
   >          LDWV is integer scalar   
   >             LDWV is the leading dimension of WV as declared in the   
   >             in the calling subroutine.  LDWV.GE.NV.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   >       Karen Braman and Ralph Byers, Department of Mathematics,   
   >       University of Kansas, USA   

   > \par References:   
    ================   
   >   
   >       K. Braman, R. Byers and R. Mathias, The Multi-Shift QR   
   >       Algorithm Part I: Maintaining Well Focused Shifts, and Level 3   
   >       Performance, SIAM Journal of Matrix Analysis, volume 23, pages   
   >       929--947, 2002.   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaqr5_(logical *wantt, logical *wantz, integer *kacc22, 
	integer *n, integer *ktop, integer *kbot, integer *nshfts, doublereal 
	*sr, doublereal *si, doublereal *h__, integer *ldh, integer *iloz, 
	integer *ihiz, doublereal *z__, integer *ldz, doublereal *v, integer *
	ldv, doublereal *u, integer *ldu, integer *nv, doublereal *wv, 
	integer *ldwv, integer *nh, doublereal *wh, integer *ldwh)
{
    /* System generated locals */
    integer h_dim1, h_offset, u_dim1, u_offset, v_dim1, v_offset, wh_dim1, 
	    wh_offset, wv_dim1, wv_offset, z_dim1, z_offset, i__1, i__2, i__3,
	     i__4, i__5, i__6, i__7;
    doublereal d__1, d__2, d__3, d__4, d__5;

    /* Local variables */
    integer i__, j, k, m, i2, j2, i4, j4, k1;
    doublereal h11, h12, h21, h22;
    integer m22, ns, nu;
    doublereal vt[3], scl;
    integer kdu, kms;
    doublereal ulp;
    integer knz, kzs;
    doublereal tst1, tst2, beta;
    logical blk22, bmp22;
    integer mend, jcol, jlen, jbot, mbot;
    doublereal swap;
    integer jtop, jrow, mtop;
    doublereal alpha;
    logical accum;
    extern /* Subroutine */ int igraphdgemm_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    integer ndcol, incol, krcol, nbmps;
    extern /* Subroutine */ int igraphdtrmm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdlaqr1_(
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *), igraphdlabad_(doublereal *, 
	    doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlarfg_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *), igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *);
    doublereal safmin;
    extern /* Subroutine */ int igraphdlaset_(char *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *);
    doublereal safmax, refsum;
    integer mstart;
    doublereal smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    ================================================================   


       ==== If there are no shifts, then there is nothing to do. ====   

       Parameter adjustments */
    --sr;
    --si;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    u_dim1 = *ldu;
    u_offset = 1 + u_dim1;
    u -= u_offset;
    wv_dim1 = *ldwv;
    wv_offset = 1 + wv_dim1;
    wv -= wv_offset;
    wh_dim1 = *ldwh;
    wh_offset = 1 + wh_dim1;
    wh -= wh_offset;

    /* Function Body */
    if (*nshfts < 2) {
	return 0;
    }

/*     ==== If the active block is empty or 1-by-1, then there   
       .    is nothing to do. ==== */

    if (*ktop >= *kbot) {
	return 0;
    }

/*     ==== Shuffle shifts into pairs of real shifts and pairs   
       .    of complex conjugate shifts assuming complex   
       .    conjugate shifts are already adjacent to one   
       .    another. ==== */

    i__1 = *nshfts - 2;
    for (i__ = 1; i__ <= i__1; i__ += 2) {
	if (si[i__] != -si[i__ + 1]) {

	    swap = sr[i__];
	    sr[i__] = sr[i__ + 1];
	    sr[i__ + 1] = sr[i__ + 2];
	    sr[i__ + 2] = swap;

	    swap = si[i__];
	    si[i__] = si[i__ + 1];
	    si[i__ + 1] = si[i__ + 2];
	    si[i__ + 2] = swap;
	}
/* L10: */
    }

/*     ==== NSHFTS is supposed to be even, but if it is odd,   
       .    then simply reduce it by one.  The shuffle above   
       .    ensures that the dropped shift is real and that   
       .    the remaining shifts are paired. ==== */

    ns = *nshfts - *nshfts % 2;

/*     ==== Machine constants for deflation ==== */

    safmin = igraphdlamch_("SAFE MINIMUM");
    safmax = 1. / safmin;
    igraphdlabad_(&safmin, &safmax);
    ulp = igraphdlamch_("PRECISION");
    smlnum = safmin * ((doublereal) (*n) / ulp);

/*     ==== Use accumulated reflections to update far-from-diagonal   
       .    entries ? ==== */

    accum = *kacc22 == 1 || *kacc22 == 2;

/*     ==== If so, exploit the 2-by-2 block structure? ==== */

    blk22 = ns > 2 && *kacc22 == 2;

/*     ==== clear trash ==== */

    if (*ktop + 2 <= *kbot) {
	h__[*ktop + 2 + *ktop * h_dim1] = 0.;
    }

/*     ==== NBMPS = number of 2-shift bulges in the chain ==== */

    nbmps = ns / 2;

/*     ==== KDU = width of slab ==== */

    kdu = nbmps * 6 - 3;

/*     ==== Create and chase chains of NBMPS bulges ==== */

    i__1 = *kbot - 2;
    i__2 = nbmps * 3 - 2;
    for (incol = (1 - nbmps) * 3 + *ktop - 1; i__2 < 0 ? incol >= i__1 : 
	    incol <= i__1; incol += i__2) {
	ndcol = incol + kdu;
	if (accum) {
	    igraphdlaset_("ALL", &kdu, &kdu, &c_b7, &c_b8, &u[u_offset], ldu);
	}

/*        ==== Near-the-diagonal bulge chase.  The following loop   
          .    performs the near-the-diagonal part of a small bulge   
          .    multi-shift QR sweep.  Each 6*NBMPS-2 column diagonal   
          .    chunk extends from column INCOL to column NDCOL   
          .    (including both column INCOL and column NDCOL). The   
          .    following loop chases a 3*NBMPS column long chain of   
          .    NBMPS bulges 3*NBMPS-2 columns to the right.  (INCOL   
          .    may be less than KTOP and and NDCOL may be greater than   
          .    KBOT indicating phantom columns from which to chase   
          .    bulges before they are actually introduced or to which   
          .    to chase bulges beyond column KBOT.)  ====   

   Computing MIN */
	i__4 = incol + nbmps * 3 - 3, i__5 = *kbot - 2;
	i__3 = min(i__4,i__5);
	for (krcol = incol; krcol <= i__3; ++krcol) {

/*           ==== Bulges number MTOP to MBOT are active double implicit   
             .    shift bulges.  There may or may not also be small   
             .    2-by-2 bulge, if there is room.  The inactive bulges   
             .    (if any) must wait until the active bulges have moved   
             .    down the diagonal to make room.  The phantom matrix   
             .    paradigm described above helps keep track.  ====   

   Computing MAX */
	    i__4 = 1, i__5 = (*ktop - 1 - krcol + 2) / 3 + 1;
	    mtop = max(i__4,i__5);
/* Computing MIN */
	    i__4 = nbmps, i__5 = (*kbot - krcol) / 3;
	    mbot = min(i__4,i__5);
	    m22 = mbot + 1;
	    bmp22 = mbot < nbmps && krcol + (m22 - 1) * 3 == *kbot - 2;

/*           ==== Generate reflections to chase the chain right   
             .    one column.  (The minimum value of K is KTOP-1.) ==== */

	    i__4 = mbot;
	    for (m = mtop; m <= i__4; ++m) {
		k = krcol + (m - 1) * 3;
		if (k == *ktop - 1) {
		    igraphdlaqr1_(&c__3, &h__[*ktop + *ktop * h_dim1], ldh, &sr[(m 
			    << 1) - 1], &si[(m << 1) - 1], &sr[m * 2], &si[m *
			     2], &v[m * v_dim1 + 1]);
		    alpha = v[m * v_dim1 + 1];
		    igraphdlarfg_(&c__3, &alpha, &v[m * v_dim1 + 2], &c__1, &v[m * 
			    v_dim1 + 1]);
		} else {
		    beta = h__[k + 1 + k * h_dim1];
		    v[m * v_dim1 + 2] = h__[k + 2 + k * h_dim1];
		    v[m * v_dim1 + 3] = h__[k + 3 + k * h_dim1];
		    igraphdlarfg_(&c__3, &beta, &v[m * v_dim1 + 2], &c__1, &v[m * 
			    v_dim1 + 1]);

/*                 ==== A Bulge may collapse because of vigilant   
                   .    deflation or destructive underflow.  In the   
                   .    underflow case, try the two-small-subdiagonals   
                   .    trick to try to reinflate the bulge.  ==== */

		    if (h__[k + 3 + k * h_dim1] != 0. || h__[k + 3 + (k + 1) *
			     h_dim1] != 0. || h__[k + 3 + (k + 2) * h_dim1] ==
			     0.) {

/*                    ==== Typical case: not collapsed (yet). ==== */

			h__[k + 1 + k * h_dim1] = beta;
			h__[k + 2 + k * h_dim1] = 0.;
			h__[k + 3 + k * h_dim1] = 0.;
		    } else {

/*                    ==== Atypical case: collapsed.  Attempt to   
                      .    reintroduce ignoring H(K+1,K) and H(K+2,K).   
                      .    If the fill resulting from the new   
                      .    reflector is too large, then abandon it.   
                      .    Otherwise, use the new one. ==== */

			igraphdlaqr1_(&c__3, &h__[k + 1 + (k + 1) * h_dim1], ldh, &
				sr[(m << 1) - 1], &si[(m << 1) - 1], &sr[m * 
				2], &si[m * 2], vt);
			alpha = vt[0];
			igraphdlarfg_(&c__3, &alpha, &vt[1], &c__1, vt);
			refsum = vt[0] * (h__[k + 1 + k * h_dim1] + vt[1] * 
				h__[k + 2 + k * h_dim1]);

			if ((d__1 = h__[k + 2 + k * h_dim1] - refsum * vt[1], 
				abs(d__1)) + (d__2 = refsum * vt[2], abs(d__2)
				) > ulp * ((d__3 = h__[k + k * h_dim1], abs(
				d__3)) + (d__4 = h__[k + 1 + (k + 1) * h_dim1]
				, abs(d__4)) + (d__5 = h__[k + 2 + (k + 2) * 
				h_dim1], abs(d__5)))) {

/*                       ==== Starting a new bulge here would   
                         .    create non-negligible fill.  Use   
                         .    the old one with trepidation. ==== */

			    h__[k + 1 + k * h_dim1] = beta;
			    h__[k + 2 + k * h_dim1] = 0.;
			    h__[k + 3 + k * h_dim1] = 0.;
			} else {

/*                       ==== Stating a new bulge here would   
                         .    create only negligible fill.   
                         .    Replace the old reflector with   
                         .    the new one. ==== */

			    h__[k + 1 + k * h_dim1] -= refsum;
			    h__[k + 2 + k * h_dim1] = 0.;
			    h__[k + 3 + k * h_dim1] = 0.;
			    v[m * v_dim1 + 1] = vt[0];
			    v[m * v_dim1 + 2] = vt[1];
			    v[m * v_dim1 + 3] = vt[2];
			}
		    }
		}
/* L20: */
	    }

/*           ==== Generate a 2-by-2 reflection, if needed. ==== */

	    k = krcol + (m22 - 1) * 3;
	    if (bmp22) {
		if (k == *ktop - 1) {
		    igraphdlaqr1_(&c__2, &h__[k + 1 + (k + 1) * h_dim1], ldh, &sr[(
			    m22 << 1) - 1], &si[(m22 << 1) - 1], &sr[m22 * 2],
			     &si[m22 * 2], &v[m22 * v_dim1 + 1]);
		    beta = v[m22 * v_dim1 + 1];
		    igraphdlarfg_(&c__2, &beta, &v[m22 * v_dim1 + 2], &c__1, &v[m22 
			    * v_dim1 + 1]);
		} else {
		    beta = h__[k + 1 + k * h_dim1];
		    v[m22 * v_dim1 + 2] = h__[k + 2 + k * h_dim1];
		    igraphdlarfg_(&c__2, &beta, &v[m22 * v_dim1 + 2], &c__1, &v[m22 
			    * v_dim1 + 1]);
		    h__[k + 1 + k * h_dim1] = beta;
		    h__[k + 2 + k * h_dim1] = 0.;
		}
	    }

/*           ==== Multiply H by reflections from the left ==== */

	    if (accum) {
		jbot = min(ndcol,*kbot);
	    } else if (*wantt) {
		jbot = *n;
	    } else {
		jbot = *kbot;
	    }
	    i__4 = jbot;
	    for (j = max(*ktop,krcol); j <= i__4; ++j) {
/* Computing MIN */
		i__5 = mbot, i__6 = (j - krcol + 2) / 3;
		mend = min(i__5,i__6);
		i__5 = mend;
		for (m = mtop; m <= i__5; ++m) {
		    k = krcol + (m - 1) * 3;
		    refsum = v[m * v_dim1 + 1] * (h__[k + 1 + j * h_dim1] + v[
			    m * v_dim1 + 2] * h__[k + 2 + j * h_dim1] + v[m * 
			    v_dim1 + 3] * h__[k + 3 + j * h_dim1]);
		    h__[k + 1 + j * h_dim1] -= refsum;
		    h__[k + 2 + j * h_dim1] -= refsum * v[m * v_dim1 + 2];
		    h__[k + 3 + j * h_dim1] -= refsum * v[m * v_dim1 + 3];
/* L30: */
		}
/* L40: */
	    }
	    if (bmp22) {
		k = krcol + (m22 - 1) * 3;
/* Computing MAX */
		i__4 = k + 1;
		i__5 = jbot;
		for (j = max(i__4,*ktop); j <= i__5; ++j) {
		    refsum = v[m22 * v_dim1 + 1] * (h__[k + 1 + j * h_dim1] + 
			    v[m22 * v_dim1 + 2] * h__[k + 2 + j * h_dim1]);
		    h__[k + 1 + j * h_dim1] -= refsum;
		    h__[k + 2 + j * h_dim1] -= refsum * v[m22 * v_dim1 + 2];
/* L50: */
		}
	    }

/*           ==== Multiply H by reflections from the right.   
             .    Delay filling in the last row until the   
             .    vigilant deflation check is complete. ==== */

	    if (accum) {
		jtop = max(*ktop,incol);
	    } else if (*wantt) {
		jtop = 1;
	    } else {
		jtop = *ktop;
	    }
	    i__5 = mbot;
	    for (m = mtop; m <= i__5; ++m) {
		if (v[m * v_dim1 + 1] != 0.) {
		    k = krcol + (m - 1) * 3;
/* Computing MIN */
		    i__6 = *kbot, i__7 = k + 3;
		    i__4 = min(i__6,i__7);
		    for (j = jtop; j <= i__4; ++j) {
			refsum = v[m * v_dim1 + 1] * (h__[j + (k + 1) * 
				h_dim1] + v[m * v_dim1 + 2] * h__[j + (k + 2) 
				* h_dim1] + v[m * v_dim1 + 3] * h__[j + (k + 
				3) * h_dim1]);
			h__[j + (k + 1) * h_dim1] -= refsum;
			h__[j + (k + 2) * h_dim1] -= refsum * v[m * v_dim1 + 
				2];
			h__[j + (k + 3) * h_dim1] -= refsum * v[m * v_dim1 + 
				3];
/* L60: */
		    }

		    if (accum) {

/*                    ==== Accumulate U. (If necessary, update Z later   
                      .    with with an efficient matrix-matrix   
                      .    multiply.) ==== */

			kms = k - incol;
/* Computing MAX */
			i__4 = 1, i__6 = *ktop - incol;
			i__7 = kdu;
			for (j = max(i__4,i__6); j <= i__7; ++j) {
			    refsum = v[m * v_dim1 + 1] * (u[j + (kms + 1) * 
				    u_dim1] + v[m * v_dim1 + 2] * u[j + (kms 
				    + 2) * u_dim1] + v[m * v_dim1 + 3] * u[j 
				    + (kms + 3) * u_dim1]);
			    u[j + (kms + 1) * u_dim1] -= refsum;
			    u[j + (kms + 2) * u_dim1] -= refsum * v[m * 
				    v_dim1 + 2];
			    u[j + (kms + 3) * u_dim1] -= refsum * v[m * 
				    v_dim1 + 3];
/* L70: */
			}
		    } else if (*wantz) {

/*                    ==== U is not accumulated, so update Z   
                      .    now by multiplying by reflections   
                      .    from the right. ==== */

			i__7 = *ihiz;
			for (j = *iloz; j <= i__7; ++j) {
			    refsum = v[m * v_dim1 + 1] * (z__[j + (k + 1) * 
				    z_dim1] + v[m * v_dim1 + 2] * z__[j + (k 
				    + 2) * z_dim1] + v[m * v_dim1 + 3] * z__[
				    j + (k + 3) * z_dim1]);
			    z__[j + (k + 1) * z_dim1] -= refsum;
			    z__[j + (k + 2) * z_dim1] -= refsum * v[m * 
				    v_dim1 + 2];
			    z__[j + (k + 3) * z_dim1] -= refsum * v[m * 
				    v_dim1 + 3];
/* L80: */
			}
		    }
		}
/* L90: */
	    }

/*           ==== Special case: 2-by-2 reflection (if needed) ==== */

	    k = krcol + (m22 - 1) * 3;
	    if (bmp22) {
		if (v[m22 * v_dim1 + 1] != 0.) {
/* Computing MIN */
		    i__7 = *kbot, i__4 = k + 3;
		    i__5 = min(i__7,i__4);
		    for (j = jtop; j <= i__5; ++j) {
			refsum = v[m22 * v_dim1 + 1] * (h__[j + (k + 1) * 
				h_dim1] + v[m22 * v_dim1 + 2] * h__[j + (k + 
				2) * h_dim1]);
			h__[j + (k + 1) * h_dim1] -= refsum;
			h__[j + (k + 2) * h_dim1] -= refsum * v[m22 * v_dim1 
				+ 2];
/* L100: */
		    }

		    if (accum) {
			kms = k - incol;
/* Computing MAX */
			i__5 = 1, i__7 = *ktop - incol;
			i__4 = kdu;
			for (j = max(i__5,i__7); j <= i__4; ++j) {
			    refsum = v[m22 * v_dim1 + 1] * (u[j + (kms + 1) * 
				    u_dim1] + v[m22 * v_dim1 + 2] * u[j + (
				    kms + 2) * u_dim1]);
			    u[j + (kms + 1) * u_dim1] -= refsum;
			    u[j + (kms + 2) * u_dim1] -= refsum * v[m22 * 
				    v_dim1 + 2];
/* L110: */
			}
		    } else if (*wantz) {
			i__4 = *ihiz;
			for (j = *iloz; j <= i__4; ++j) {
			    refsum = v[m22 * v_dim1 + 1] * (z__[j + (k + 1) * 
				    z_dim1] + v[m22 * v_dim1 + 2] * z__[j + (
				    k + 2) * z_dim1]);
			    z__[j + (k + 1) * z_dim1] -= refsum;
			    z__[j + (k + 2) * z_dim1] -= refsum * v[m22 * 
				    v_dim1 + 2];
/* L120: */
			}
		    }
		}
	    }

/*           ==== Vigilant deflation check ==== */

	    mstart = mtop;
	    if (krcol + (mstart - 1) * 3 < *ktop) {
		++mstart;
	    }
	    mend = mbot;
	    if (bmp22) {
		++mend;
	    }
	    if (krcol == *kbot - 2) {
		++mend;
	    }
	    i__4 = mend;
	    for (m = mstart; m <= i__4; ++m) {
/* Computing MIN */
		i__5 = *kbot - 1, i__7 = krcol + (m - 1) * 3;
		k = min(i__5,i__7);

/*              ==== The following convergence test requires that   
                .    the tradition small-compared-to-nearby-diagonals   
                .    criterion and the Ahues & Tisseur (LAWN 122, 1997)   
                .    criteria both be satisfied.  The latter improves   
                .    accuracy in some examples. Falling back on an   
                .    alternate convergence criterion when TST1 or TST2   
                .    is zero (as done here) is traditional but probably   
                .    unnecessary. ==== */

		if (h__[k + 1 + k * h_dim1] != 0.) {
		    tst1 = (d__1 = h__[k + k * h_dim1], abs(d__1)) + (d__2 = 
			    h__[k + 1 + (k + 1) * h_dim1], abs(d__2));
		    if (tst1 == 0.) {
			if (k >= *ktop + 1) {
			    tst1 += (d__1 = h__[k + (k - 1) * h_dim1], abs(
				    d__1));
			}
			if (k >= *ktop + 2) {
			    tst1 += (d__1 = h__[k + (k - 2) * h_dim1], abs(
				    d__1));
			}
			if (k >= *ktop + 3) {
			    tst1 += (d__1 = h__[k + (k - 3) * h_dim1], abs(
				    d__1));
			}
			if (k <= *kbot - 2) {
			    tst1 += (d__1 = h__[k + 2 + (k + 1) * h_dim1], 
				    abs(d__1));
			}
			if (k <= *kbot - 3) {
			    tst1 += (d__1 = h__[k + 3 + (k + 1) * h_dim1], 
				    abs(d__1));
			}
			if (k <= *kbot - 4) {
			    tst1 += (d__1 = h__[k + 4 + (k + 1) * h_dim1], 
				    abs(d__1));
			}
		    }
/* Computing MAX */
		    d__2 = smlnum, d__3 = ulp * tst1;
		    if ((d__1 = h__[k + 1 + k * h_dim1], abs(d__1)) <= max(
			    d__2,d__3)) {
/* Computing MAX */
			d__3 = (d__1 = h__[k + 1 + k * h_dim1], abs(d__1)), 
				d__4 = (d__2 = h__[k + (k + 1) * h_dim1], abs(
				d__2));
			h12 = max(d__3,d__4);
/* Computing MIN */
			d__3 = (d__1 = h__[k + 1 + k * h_dim1], abs(d__1)), 
				d__4 = (d__2 = h__[k + (k + 1) * h_dim1], abs(
				d__2));
			h21 = min(d__3,d__4);
/* Computing MAX */
			d__3 = (d__1 = h__[k + 1 + (k + 1) * h_dim1], abs(
				d__1)), d__4 = (d__2 = h__[k + k * h_dim1] - 
				h__[k + 1 + (k + 1) * h_dim1], abs(d__2));
			h11 = max(d__3,d__4);
/* Computing MIN */
			d__3 = (d__1 = h__[k + 1 + (k + 1) * h_dim1], abs(
				d__1)), d__4 = (d__2 = h__[k + k * h_dim1] - 
				h__[k + 1 + (k + 1) * h_dim1], abs(d__2));
			h22 = min(d__3,d__4);
			scl = h11 + h12;
			tst2 = h22 * (h11 / scl);

/* Computing MAX */
			d__1 = smlnum, d__2 = ulp * tst2;
			if (tst2 == 0. || h21 * (h12 / scl) <= max(d__1,d__2))
				 {
			    h__[k + 1 + k * h_dim1] = 0.;
			}
		    }
		}
/* L130: */
	    }

/*           ==== Fill in the last row of each bulge. ====   

   Computing MIN */
	    i__4 = nbmps, i__5 = (*kbot - krcol - 1) / 3;
	    mend = min(i__4,i__5);
	    i__4 = mend;
	    for (m = mtop; m <= i__4; ++m) {
		k = krcol + (m - 1) * 3;
		refsum = v[m * v_dim1 + 1] * v[m * v_dim1 + 3] * h__[k + 4 + (
			k + 3) * h_dim1];
		h__[k + 4 + (k + 1) * h_dim1] = -refsum;
		h__[k + 4 + (k + 2) * h_dim1] = -refsum * v[m * v_dim1 + 2];
		h__[k + 4 + (k + 3) * h_dim1] -= refsum * v[m * v_dim1 + 3];
/* L140: */
	    }

/*           ==== End of near-the-diagonal bulge chase. ====   

   L150: */
	}

/*        ==== Use U (if accumulated) to update far-from-diagonal   
          .    entries in H.  If required, use U to update Z as   
          .    well. ==== */

	if (accum) {
	    if (*wantt) {
		jtop = 1;
		jbot = *n;
	    } else {
		jtop = *ktop;
		jbot = *kbot;
	    }
	    if (! blk22 || incol < *ktop || ndcol > *kbot || ns <= 2) {

/*              ==== Updates not exploiting the 2-by-2 block   
                .    structure of U.  K1 and NU keep track of   
                .    the location and size of U in the special   
                .    cases of introducing bulges and chasing   
                .    bulges off the bottom.  In these special   
                .    cases and in case the number of shifts   
                .    is NS = 2, there is no 2-by-2 block   
                .    structure to exploit.  ====   

   Computing MAX */
		i__3 = 1, i__4 = *ktop - incol;
		k1 = max(i__3,i__4);
/* Computing MAX */
		i__3 = 0, i__4 = ndcol - *kbot;
		nu = kdu - max(i__3,i__4) - k1 + 1;

/*              ==== Horizontal Multiply ==== */

		i__3 = jbot;
		i__4 = *nh;
		for (jcol = min(ndcol,*kbot) + 1; i__4 < 0 ? jcol >= i__3 : 
			jcol <= i__3; jcol += i__4) {
/* Computing MIN */
		    i__5 = *nh, i__7 = jbot - jcol + 1;
		    jlen = min(i__5,i__7);
		    igraphdgemm_("C", "N", &nu, &jlen, &nu, &c_b8, &u[k1 + k1 * 
			    u_dim1], ldu, &h__[incol + k1 + jcol * h_dim1], 
			    ldh, &c_b7, &wh[wh_offset], ldwh);
		    igraphdlacpy_("ALL", &nu, &jlen, &wh[wh_offset], ldwh, &h__[
			    incol + k1 + jcol * h_dim1], ldh);
/* L160: */
		}

/*              ==== Vertical multiply ==== */

		i__4 = max(*ktop,incol) - 1;
		i__3 = *nv;
		for (jrow = jtop; i__3 < 0 ? jrow >= i__4 : jrow <= i__4; 
			jrow += i__3) {
/* Computing MIN */
		    i__5 = *nv, i__7 = max(*ktop,incol) - jrow;
		    jlen = min(i__5,i__7);
		    igraphdgemm_("N", "N", &jlen, &nu, &nu, &c_b8, &h__[jrow + (
			    incol + k1) * h_dim1], ldh, &u[k1 + k1 * u_dim1], 
			    ldu, &c_b7, &wv[wv_offset], ldwv);
		    igraphdlacpy_("ALL", &jlen, &nu, &wv[wv_offset], ldwv, &h__[
			    jrow + (incol + k1) * h_dim1], ldh);
/* L170: */
		}

/*              ==== Z multiply (also vertical) ==== */

		if (*wantz) {
		    i__3 = *ihiz;
		    i__4 = *nv;
		    for (jrow = *iloz; i__4 < 0 ? jrow >= i__3 : jrow <= i__3;
			     jrow += i__4) {
/* Computing MIN */
			i__5 = *nv, i__7 = *ihiz - jrow + 1;
			jlen = min(i__5,i__7);
			igraphdgemm_("N", "N", &jlen, &nu, &nu, &c_b8, &z__[jrow + (
				incol + k1) * z_dim1], ldz, &u[k1 + k1 * 
				u_dim1], ldu, &c_b7, &wv[wv_offset], ldwv);
			igraphdlacpy_("ALL", &jlen, &nu, &wv[wv_offset], ldwv, &z__[
				jrow + (incol + k1) * z_dim1], ldz)
				;
/* L180: */
		    }
		}
	    } else {

/*              ==== Updates exploiting U's 2-by-2 block structure.   
                .    (I2, I4, J2, J4 are the last rows and columns   
                .    of the blocks.) ==== */

		i2 = (kdu + 1) / 2;
		i4 = kdu;
		j2 = i4 - i2;
		j4 = kdu;

/*              ==== KZS and KNZ deal with the band of zeros   
                .    along the diagonal of one of the triangular   
                .    blocks. ==== */

		kzs = j4 - j2 - (ns + 1);
		knz = ns + 1;

/*              ==== Horizontal multiply ==== */

		i__4 = jbot;
		i__3 = *nh;
		for (jcol = min(ndcol,*kbot) + 1; i__3 < 0 ? jcol >= i__4 : 
			jcol <= i__4; jcol += i__3) {
/* Computing MIN */
		    i__5 = *nh, i__7 = jbot - jcol + 1;
		    jlen = min(i__5,i__7);

/*                 ==== Copy bottom of H to top+KZS of scratch ====   
                    (The first KZS rows get multiplied by zero.) ==== */

		    igraphdlacpy_("ALL", &knz, &jlen, &h__[incol + 1 + j2 + jcol * 
			    h_dim1], ldh, &wh[kzs + 1 + wh_dim1], ldwh);

/*                 ==== Multiply by U21**T ==== */

		    igraphdlaset_("ALL", &kzs, &jlen, &c_b7, &c_b7, &wh[wh_offset], 
			    ldwh);
		    igraphdtrmm_("L", "U", "C", "N", &knz, &jlen, &c_b8, &u[j2 + 1 
			    + (kzs + 1) * u_dim1], ldu, &wh[kzs + 1 + wh_dim1]
			    , ldwh);

/*                 ==== Multiply top of H by U11**T ==== */

		    igraphdgemm_("C", "N", &i2, &jlen, &j2, &c_b8, &u[u_offset], 
			    ldu, &h__[incol + 1 + jcol * h_dim1], ldh, &c_b8, 
			    &wh[wh_offset], ldwh);

/*                 ==== Copy top of H to bottom of WH ==== */

		    igraphdlacpy_("ALL", &j2, &jlen, &h__[incol + 1 + jcol * h_dim1]
			    , ldh, &wh[i2 + 1 + wh_dim1], ldwh);

/*                 ==== Multiply by U21**T ==== */

		    igraphdtrmm_("L", "L", "C", "N", &j2, &jlen, &c_b8, &u[(i2 + 1) 
			    * u_dim1 + 1], ldu, &wh[i2 + 1 + wh_dim1], ldwh);

/*                 ==== Multiply by U22 ==== */

		    i__5 = i4 - i2;
		    i__7 = j4 - j2;
		    igraphdgemm_("C", "N", &i__5, &jlen, &i__7, &c_b8, &u[j2 + 1 + (
			    i2 + 1) * u_dim1], ldu, &h__[incol + 1 + j2 + 
			    jcol * h_dim1], ldh, &c_b8, &wh[i2 + 1 + wh_dim1],
			     ldwh);

/*                 ==== Copy it back ==== */

		    igraphdlacpy_("ALL", &kdu, &jlen, &wh[wh_offset], ldwh, &h__[
			    incol + 1 + jcol * h_dim1], ldh);
/* L190: */
		}

/*              ==== Vertical multiply ==== */

		i__3 = max(incol,*ktop) - 1;
		i__4 = *nv;
		for (jrow = jtop; i__4 < 0 ? jrow >= i__3 : jrow <= i__3; 
			jrow += i__4) {
/* Computing MIN */
		    i__5 = *nv, i__7 = max(incol,*ktop) - jrow;
		    jlen = min(i__5,i__7);

/*                 ==== Copy right of H to scratch (the first KZS   
                   .    columns get multiplied by zero) ==== */

		    igraphdlacpy_("ALL", &jlen, &knz, &h__[jrow + (incol + 1 + j2) *
			     h_dim1], ldh, &wv[(kzs + 1) * wv_dim1 + 1], ldwv);

/*                 ==== Multiply by U21 ==== */

		    igraphdlaset_("ALL", &jlen, &kzs, &c_b7, &c_b7, &wv[wv_offset], 
			    ldwv);
		    igraphdtrmm_("R", "U", "N", "N", &jlen, &knz, &c_b8, &u[j2 + 1 
			    + (kzs + 1) * u_dim1], ldu, &wv[(kzs + 1) * 
			    wv_dim1 + 1], ldwv);

/*                 ==== Multiply by U11 ==== */

		    igraphdgemm_("N", "N", &jlen, &i2, &j2, &c_b8, &h__[jrow + (
			    incol + 1) * h_dim1], ldh, &u[u_offset], ldu, &
			    c_b8, &wv[wv_offset], ldwv);

/*                 ==== Copy left of H to right of scratch ==== */

		    igraphdlacpy_("ALL", &jlen, &j2, &h__[jrow + (incol + 1) * 
			    h_dim1], ldh, &wv[(i2 + 1) * wv_dim1 + 1], ldwv);

/*                 ==== Multiply by U21 ==== */

		    i__5 = i4 - i2;
		    igraphdtrmm_("R", "L", "N", "N", &jlen, &i__5, &c_b8, &u[(i2 + 
			    1) * u_dim1 + 1], ldu, &wv[(i2 + 1) * wv_dim1 + 1]
			    , ldwv);

/*                 ==== Multiply by U22 ==== */

		    i__5 = i4 - i2;
		    i__7 = j4 - j2;
		    igraphdgemm_("N", "N", &jlen, &i__5, &i__7, &c_b8, &h__[jrow + (
			    incol + 1 + j2) * h_dim1], ldh, &u[j2 + 1 + (i2 + 
			    1) * u_dim1], ldu, &c_b8, &wv[(i2 + 1) * wv_dim1 
			    + 1], ldwv);

/*                 ==== Copy it back ==== */

		    igraphdlacpy_("ALL", &jlen, &kdu, &wv[wv_offset], ldwv, &h__[
			    jrow + (incol + 1) * h_dim1], ldh);
/* L200: */
		}

/*              ==== Multiply Z (also vertical) ==== */

		if (*wantz) {
		    i__4 = *ihiz;
		    i__3 = *nv;
		    for (jrow = *iloz; i__3 < 0 ? jrow >= i__4 : jrow <= i__4;
			     jrow += i__3) {
/* Computing MIN */
			i__5 = *nv, i__7 = *ihiz - jrow + 1;
			jlen = min(i__5,i__7);

/*                    ==== Copy right of Z to left of scratch (first   
                      .     KZS columns get multiplied by zero) ==== */

			igraphdlacpy_("ALL", &jlen, &knz, &z__[jrow + (incol + 1 + 
				j2) * z_dim1], ldz, &wv[(kzs + 1) * wv_dim1 + 
				1], ldwv);

/*                    ==== Multiply by U12 ==== */

			igraphdlaset_("ALL", &jlen, &kzs, &c_b7, &c_b7, &wv[
				wv_offset], ldwv);
			igraphdtrmm_("R", "U", "N", "N", &jlen, &knz, &c_b8, &u[j2 
				+ 1 + (kzs + 1) * u_dim1], ldu, &wv[(kzs + 1) 
				* wv_dim1 + 1], ldwv);

/*                    ==== Multiply by U11 ==== */

			igraphdgemm_("N", "N", &jlen, &i2, &j2, &c_b8, &z__[jrow + (
				incol + 1) * z_dim1], ldz, &u[u_offset], ldu, 
				&c_b8, &wv[wv_offset], ldwv);

/*                    ==== Copy left of Z to right of scratch ==== */

			igraphdlacpy_("ALL", &jlen, &j2, &z__[jrow + (incol + 1) * 
				z_dim1], ldz, &wv[(i2 + 1) * wv_dim1 + 1], 
				ldwv);

/*                    ==== Multiply by U21 ==== */

			i__5 = i4 - i2;
			igraphdtrmm_("R", "L", "N", "N", &jlen, &i__5, &c_b8, &u[(
				i2 + 1) * u_dim1 + 1], ldu, &wv[(i2 + 1) * 
				wv_dim1 + 1], ldwv);

/*                    ==== Multiply by U22 ==== */

			i__5 = i4 - i2;
			i__7 = j4 - j2;
			igraphdgemm_("N", "N", &jlen, &i__5, &i__7, &c_b8, &z__[
				jrow + (incol + 1 + j2) * z_dim1], ldz, &u[j2 
				+ 1 + (i2 + 1) * u_dim1], ldu, &c_b8, &wv[(i2 
				+ 1) * wv_dim1 + 1], ldwv);

/*                    ==== Copy the result back to Z ==== */

			igraphdlacpy_("ALL", &jlen, &kdu, &wv[wv_offset], ldwv, &
				z__[jrow + (incol + 1) * z_dim1], ldz);
/* L210: */
		    }
		}
	    }
	}
/* L220: */
    }

/*     ==== End of DLAQR5 ==== */

    return 0;
} /* igraphdlaqr5_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqrb.c0000644000175100001710000005031200000000000024014 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dlaqrb   

   \Description:   
    Compute the eigenvalues and the Schur decomposition of an upper   
    Hessenberg submatrix in rows and columns ILO to IHI.  Only the   
    last component of the Schur vectors are computed.   

    This is mostly a modification of the LAPACK routine dlahqr.   

   \Usage:   
    call dlaqrb   
       ( WANTT, N, ILO, IHI, H, LDH, WR, WI,  Z, INFO )   

   \Arguments   
    WANTT   Logical variable.  (INPUT)   
            = .TRUE. : the full Schur form T is required;   
            = .FALSE.: only eigenvalues are required.   

    N       Integer.  (INPUT)   
            The order of the matrix H.  N >= 0.   

    ILO     Integer.  (INPUT)   
    IHI     Integer.  (INPUT)   
            It is assumed that H is already upper quasi-triangular in   
            rows and columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless   
            ILO = 1). SLAQRB works primarily with the Hessenberg   
            submatrix in rows and columns ILO to IHI, but applies   
            transformations to all of H if WANTT is .TRUE..   
            1 <= ILO <= max(1,IHI); IHI <= N.   

    H       Double precision array, dimension (LDH,N).  (INPUT/OUTPUT)   
            On entry, the upper Hessenberg matrix H.   
            On exit, if WANTT is .TRUE., H is upper quasi-triangular in   
            rows and columns ILO:IHI, with any 2-by-2 diagonal blocks in   
            standard form. If WANTT is .FALSE., the contents of H are   
            unspecified on exit.   

    LDH     Integer.  (INPUT)   
            The leading dimension of the array H. LDH >= max(1,N).   

    WR      Double precision array, dimension (N).  (OUTPUT)   
    WI      Double precision array, dimension (N).  (OUTPUT)   
            The real and imaginary parts, respectively, of the computed   
            eigenvalues ILO to IHI are stored in the corresponding   
            elements of WR and WI. If two eigenvalues are computed as a   
            complex conjugate pair, they are stored in consecutive   
            elements of WR and WI, say the i-th and (i+1)th, with   
            WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., the   
            eigenvalues are stored in the same order as on the diagonal   
            of the Schur form returned in H, with WR(i) = H(i,i), and, if   
            H(i:i+1,i:i+1) is a 2-by-2 diagonal block,   
            WI(i) = sqrt(H(i+1,i)*H(i,i+1)) and WI(i+1) = -WI(i).   

    Z       Double precision array, dimension (N).  (OUTPUT)   
            On exit Z contains the last components of the Schur vectors.   

    INFO    Integer.  (OUPUT)   
            = 0: successful exit   
            > 0: SLAQRB failed to compute all the eigenvalues ILO to IHI   
                 in a total of 30*(IHI-ILO+1) iterations; if INFO = i,   
                 elements i+1:ihi of WR and WI contain those eigenvalues   
                 which have been successfully computed.   

   \Remarks   
    1. None.   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dlabad  LAPACK routine that computes machine constants.   
       dlamch  LAPACK routine that determines machine constants.   
       dlanhs  LAPACK routine that computes various norms of a matrix.   
       dlanv2  LAPACK routine that computes the Schur factorization of   
               2 by 2 nonsymmetric matrix in standard form.   
       dlarfg  LAPACK Householder reflection construction routine.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       drot    Level 1 BLAS that applies a rotation to a 2 by 2 matrix.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.4'   
                 Modified from the LAPACK routine dlahqr so that only the   
                 last component of the Schur vectors are computed.   

   \SCCS Information: @(#)   
   FILE: laqrb.F   SID: 2.2   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   
       1. None   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdlaqrb_(logical *wantt, integer *n, integer *ilo, 
	integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, 
	doublereal *wi, doublereal *z__, integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, i__1, i__2, i__3, i__4;
    doublereal d__1, d__2;

    /* Local variables */
    integer i__, j, k, l, m;
    doublereal s, v[3];
    integer i1, i2;
    doublereal t1, t2, t3, v1, v2, v3, h00, h10, h11, h12, h21, h22, h33, h44;
    integer nh;
    doublereal cs;
    integer nr;
    doublereal sn, h33s, h44s;
    integer itn, its;
    doublereal ulp, sum, tst1, h43h34, unfl, ovfl;
    extern /* Subroutine */ int igraphdrot_(integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *);
    doublereal work[1];
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdlanv2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *), igraphdlabad_(
	    doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlarfg_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *);
    extern doublereal igraphdlanhs_(char *, integer *, doublereal *, integer *, 
	    doublereal *);
    doublereal smlnum;


/*     %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %------------------------%   
       | Local Scalars & Arrays |   
       %------------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --wr;
    --wi;
    --z__;

    /* Function Body */
    *info = 0;

/*     %--------------------------%   
       | Quick return if possible |   
       %--------------------------% */

    if (*n == 0) {
	return 0;
    }
    if (*ilo == *ihi) {
	wr[*ilo] = h__[*ilo + *ilo * h_dim1];
	wi[*ilo] = 0.;
	return 0;
    }

/*     %---------------------------------------------%   
       | Initialize the vector of last components of |   
       | the Schur vectors for accumulation.         |   
       %---------------------------------------------% */

    i__1 = *n - 1;
    for (j = 1; j <= i__1; ++j) {
	z__[j] = 0.;
/* L5: */
    }
    z__[*n] = 1.;

    nh = *ihi - *ilo + 1;

/*     %-------------------------------------------------------------%   
       | Set machine-dependent constants for the stopping criterion. |   
       | If norm(H) <= sqrt(OVFL), overflow should not occur.        |   
       %-------------------------------------------------------------% */

    unfl = igraphdlamch_("safe minimum");
    ovfl = 1. / unfl;
    igraphdlabad_(&unfl, &ovfl);
    ulp = igraphdlamch_("precision");
    smlnum = unfl * (nh / ulp);

/*     %---------------------------------------------------------------%   
       | I1 and I2 are the indices of the first row and last column    |   
       | of H to which transformations must be applied. If eigenvalues |   
       | only are computed, I1 and I2 are set inside the main loop.    |   
       | Zero out H(J+2,J) = ZERO for J=1:N if WANTT = .TRUE.          |   
       | else H(J+2,J) for J=ILO:IHI-ILO-1 if WANTT = .FALSE.          |   
       %---------------------------------------------------------------% */

    if (*wantt) {
	i1 = 1;
	i2 = *n;
	i__1 = i2 - 2;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    h__[i1 + i__ + 1 + i__ * h_dim1] = 0.;
/* L8: */
	}
    } else {
	i__1 = *ihi - *ilo - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    h__[*ilo + i__ + 1 + (*ilo + i__ - 1) * h_dim1] = 0.;
/* L9: */
	}
    }

/*     %---------------------------------------------------%   
       | ITN is the total number of QR iterations allowed. |   
       %---------------------------------------------------% */

    itn = nh * 30;

/*     ------------------------------------------------------------------   
       The main loop begins here. I is the loop index and decreases from   
       IHI to ILO in steps of 1 or 2. Each iteration of the loop works   
       with the active submatrix in rows and columns L to I.   
       Eigenvalues I+1 to IHI have already converged. Either L = ILO or   
       H(L,L-1) is negligible so that the matrix splits.   
       ------------------------------------------------------------------ */

    i__ = *ihi;
L10:
    l = *ilo;
    if (i__ < *ilo) {
	goto L150;
    }
/*     %--------------------------------------------------------------%   
       | Perform QR iterations on rows and columns ILO to I until a   |   
       | submatrix of order 1 or 2 splits off at the bottom because a |   
       | subdiagonal element has become negligible.                   |   
       %--------------------------------------------------------------% */
    i__1 = itn;
    for (its = 0; its <= i__1; ++its) {

/*        %----------------------------------------------%   
          | Look for a single small subdiagonal element. |   
          %----------------------------------------------% */

	i__2 = l + 1;
	for (k = i__; k >= i__2; --k) {
	    tst1 = (d__1 = h__[k - 1 + (k - 1) * h_dim1], abs(d__1)) + (d__2 =
		     h__[k + k * h_dim1], abs(d__2));
	    if (tst1 == 0.) {
		i__3 = i__ - l + 1;
		tst1 = igraphdlanhs_("1", &i__3, &h__[l + l * h_dim1], ldh, work);
	    }
/* Computing MAX */
	    d__2 = ulp * tst1;
	    if ((d__1 = h__[k + (k - 1) * h_dim1], abs(d__1)) <= max(d__2,
		    smlnum)) {
		goto L30;
	    }
/* L20: */
	}
L30:
	l = k;
	if (l > *ilo) {

/*           %------------------------%   
             | H(L,L-1) is negligible |   
             %------------------------% */

	    h__[l + (l - 1) * h_dim1] = 0.;
	}

/*        %-------------------------------------------------------------%   
          | Exit from loop if a submatrix of order 1 or 2 has split off |   
          %-------------------------------------------------------------% */

	if (l >= i__ - 1) {
	    goto L140;
	}

/*        %---------------------------------------------------------%   
          | Now the active submatrix is in rows and columns L to I. |   
          | If eigenvalues only are being computed, only the active |   
          | submatrix need be transformed.                          |   
          %---------------------------------------------------------% */

	if (! (*wantt)) {
	    i1 = l;
	    i2 = i__;
	}

	if (its == 10 || its == 20) {

/*           %-------------------%   
             | Exceptional shift |   
             %-------------------% */

	    s = (d__1 = h__[i__ + (i__ - 1) * h_dim1], abs(d__1)) + (d__2 = 
		    h__[i__ - 1 + (i__ - 2) * h_dim1], abs(d__2));
	    h44 = s * .75;
	    h33 = h44;
	    h43h34 = s * -.4375 * s;

	} else {

/*           %-----------------------------------------%   
             | Prepare to use Wilkinson's double shift |   
             %-----------------------------------------% */

	    h44 = h__[i__ + i__ * h_dim1];
	    h33 = h__[i__ - 1 + (i__ - 1) * h_dim1];
	    h43h34 = h__[i__ + (i__ - 1) * h_dim1] * h__[i__ - 1 + i__ * 
		    h_dim1];
	}

/*        %-----------------------------------------------------%   
          | Look for two consecutive small subdiagonal elements |   
          %-----------------------------------------------------% */

	i__2 = l;
	for (m = i__ - 2; m >= i__2; --m) {

/*           %---------------------------------------------------------%   
             | Determine the effect of starting the double-shift QR    |   
             | iteration at row M, and see if this would make H(M,M-1) |   
             | negligible.                                             |   
             %---------------------------------------------------------% */

	    h11 = h__[m + m * h_dim1];
	    h22 = h__[m + 1 + (m + 1) * h_dim1];
	    h21 = h__[m + 1 + m * h_dim1];
	    h12 = h__[m + (m + 1) * h_dim1];
	    h44s = h44 - h11;
	    h33s = h33 - h11;
	    v1 = (h33s * h44s - h43h34) / h21 + h12;
	    v2 = h22 - h11 - h33s - h44s;
	    v3 = h__[m + 2 + (m + 1) * h_dim1];
	    s = abs(v1) + abs(v2) + abs(v3);
	    v1 /= s;
	    v2 /= s;
	    v3 /= s;
	    v[0] = v1;
	    v[1] = v2;
	    v[2] = v3;
	    if (m == l) {
		goto L50;
	    }
	    h00 = h__[m - 1 + (m - 1) * h_dim1];
	    h10 = h__[m + (m - 1) * h_dim1];
	    tst1 = abs(v1) * (abs(h00) + abs(h11) + abs(h22));
	    if (abs(h10) * (abs(v2) + abs(v3)) <= ulp * tst1) {
		goto L50;
	    }
/* L40: */
	}
L50:

/*        %----------------------%   
          | Double-shift QR step |   
          %----------------------% */

	i__2 = i__ - 1;
	for (k = m; k <= i__2; ++k) {

/*           ------------------------------------------------------------   
             The first iteration of this loop determines a reflection G   
             from the vector V and applies it from left and right to H,   
             thus creating a nonzero bulge below the subdiagonal.   

             Each subsequent iteration determines a reflection G to   
             restore the Hessenberg form in the (K-1)th column, and thus   
             chases the bulge one step toward the bottom of the active   
             submatrix. NR is the order of G.   
             ------------------------------------------------------------   

   Computing MIN */
	    i__3 = 3, i__4 = i__ - k + 1;
	    nr = min(i__3,i__4);
	    if (k > m) {
		igraphdcopy_(&nr, &h__[k + (k - 1) * h_dim1], &c__1, v, &c__1);
	    }
	    igraphdlarfg_(&nr, v, &v[1], &c__1, &t1);
	    if (k > m) {
		h__[k + (k - 1) * h_dim1] = v[0];
		h__[k + 1 + (k - 1) * h_dim1] = 0.;
		if (k < i__ - 1) {
		    h__[k + 2 + (k - 1) * h_dim1] = 0.;
		}
	    } else if (m > l) {
		h__[k + (k - 1) * h_dim1] = -h__[k + (k - 1) * h_dim1];
	    }
	    v2 = v[1];
	    t2 = t1 * v2;
	    if (nr == 3) {
		v3 = v[2];
		t3 = t1 * v3;

/*              %------------------------------------------------%   
                | Apply G from the left to transform the rows of |   
                | the matrix in columns K to I2.                 |   
                %------------------------------------------------% */

		i__3 = i2;
		for (j = k; j <= i__3; ++j) {
		    sum = h__[k + j * h_dim1] + v2 * h__[k + 1 + j * h_dim1] 
			    + v3 * h__[k + 2 + j * h_dim1];
		    h__[k + j * h_dim1] -= sum * t1;
		    h__[k + 1 + j * h_dim1] -= sum * t2;
		    h__[k + 2 + j * h_dim1] -= sum * t3;
/* L60: */
		}

/*              %----------------------------------------------------%   
                | Apply G from the right to transform the columns of |   
                | the matrix in rows I1 to min(K+3,I).               |   
                %----------------------------------------------------%   

   Computing MIN */
		i__4 = k + 3;
		i__3 = min(i__4,i__);
		for (j = i1; j <= i__3; ++j) {
		    sum = h__[j + k * h_dim1] + v2 * h__[j + (k + 1) * h_dim1]
			     + v3 * h__[j + (k + 2) * h_dim1];
		    h__[j + k * h_dim1] -= sum * t1;
		    h__[j + (k + 1) * h_dim1] -= sum * t2;
		    h__[j + (k + 2) * h_dim1] -= sum * t3;
/* L70: */
		}

/*              %----------------------------------%   
                | Accumulate transformations for Z |   
                %----------------------------------% */

		sum = z__[k] + v2 * z__[k + 1] + v3 * z__[k + 2];
		z__[k] -= sum * t1;
		z__[k + 1] -= sum * t2;
		z__[k + 2] -= sum * t3;
	    } else if (nr == 2) {

/*              %------------------------------------------------%   
                | Apply G from the left to transform the rows of |   
                | the matrix in columns K to I2.                 |   
                %------------------------------------------------% */

		i__3 = i2;
		for (j = k; j <= i__3; ++j) {
		    sum = h__[k + j * h_dim1] + v2 * h__[k + 1 + j * h_dim1];
		    h__[k + j * h_dim1] -= sum * t1;
		    h__[k + 1 + j * h_dim1] -= sum * t2;
/* L90: */
		}

/*              %----------------------------------------------------%   
                | Apply G from the right to transform the columns of |   
                | the matrix in rows I1 to min(K+3,I).               |   
                %----------------------------------------------------% */

		i__3 = i__;
		for (j = i1; j <= i__3; ++j) {
		    sum = h__[j + k * h_dim1] + v2 * h__[j + (k + 1) * h_dim1]
			    ;
		    h__[j + k * h_dim1] -= sum * t1;
		    h__[j + (k + 1) * h_dim1] -= sum * t2;
/* L100: */
		}

/*              %----------------------------------%   
                | Accumulate transformations for Z |   
                %----------------------------------% */

		sum = z__[k] + v2 * z__[k + 1];
		z__[k] -= sum * t1;
		z__[k + 1] -= sum * t2;
	    }
/* L120: */
	}
/* L130: */
    }

/*     %-------------------------------------------------------%   
       | Failure to converge in remaining number of iterations |   
       %-------------------------------------------------------% */

    *info = i__;
    return 0;
L140:
    if (l == i__) {

/*        %------------------------------------------------------%   
          | H(I,I-1) is negligible: one eigenvalue has converged |   
          %------------------------------------------------------% */

	wr[i__] = h__[i__ + i__ * h_dim1];
	wi[i__] = 0.;
    } else if (l == i__ - 1) {

/*        %--------------------------------------------------------%   
          | H(I-1,I-2) is negligible;                              |   
          | a pair of eigenvalues have converged.                  |   
          |                                                        |   
          | Transform the 2-by-2 submatrix to standard Schur form, |   
          | and compute and store the eigenvalues.                 |   
          %--------------------------------------------------------% */

	igraphdlanv2_(&h__[i__ - 1 + (i__ - 1) * h_dim1], &h__[i__ - 1 + i__ * 
		h_dim1], &h__[i__ + (i__ - 1) * h_dim1], &h__[i__ + i__ * 
		h_dim1], &wr[i__ - 1], &wi[i__ - 1], &wr[i__], &wi[i__], &cs, 
		&sn);
	if (*wantt) {

/*           %-----------------------------------------------------%   
             | Apply the transformation to the rest of H and to Z, |   
             | as required.                                        |   
             %-----------------------------------------------------% */

	    if (i2 > i__) {
		i__1 = i2 - i__;
		igraphdrot_(&i__1, &h__[i__ - 1 + (i__ + 1) * h_dim1], ldh, &h__[
			i__ + (i__ + 1) * h_dim1], ldh, &cs, &sn);
	    }
	    i__1 = i__ - i1 - 1;
	    igraphdrot_(&i__1, &h__[i1 + (i__ - 1) * h_dim1], &c__1, &h__[i1 + i__ *
		     h_dim1], &c__1, &cs, &sn);
	    sum = cs * z__[i__ - 1] + sn * z__[i__];
	    z__[i__] = cs * z__[i__] - sn * z__[i__ - 1];
	    z__[i__ - 1] = sum;
	}
    }

/*     %---------------------------------------------------------%   
       | Decrement number of remaining iterations, and return to |   
       | start of the main loop with new value of I.             |   
       %---------------------------------------------------------% */

    itn -= its;
    i__ = l - 1;
    goto L10;
L150:
    return 0;

/*     %---------------%   
       | End of dlaqrb |   
       %---------------% */

} /* igraphdlaqrb_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaqtr.c0000644000175100001710000005565600000000000024056 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static logical c_false = FALSE_;
static integer c__2 = 2;
static doublereal c_b21 = 1.;
static doublereal c_b25 = 0.;
static logical c_true = TRUE_;

/* > \brief \b DLAQTR solves a real quasi-triangular system of equations, or a complex quasi-triangular system
 of special form, in real arithmetic.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAQTR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAQTR( LTRAN, LREAL, N, T, LDT, B, W, SCALE, X, WORK,   
                            INFO )   

         LOGICAL            LREAL, LTRAN   
         INTEGER            INFO, LDT, N   
         DOUBLE PRECISION   SCALE, W   
         DOUBLE PRECISION   B( * ), T( LDT, * ), WORK( * ), X( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAQTR solves the real quasi-triangular system   
   >   
   >              op(T)*p = scale*c,               if LREAL = .TRUE.   
   >   
   > or the complex quasi-triangular systems   
   >   
   >            op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.   
   >   
   > in real arithmetic, where T is upper quasi-triangular.   
   > If LREAL = .FALSE., then the first diagonal block of T must be   
   > 1 by 1, B is the specially structured matrix   
   >   
   >                B = [ b(1) b(2) ... b(n) ]   
   >                    [       w            ]   
   >                    [           w        ]   
   >                    [              .     ]   
   >                    [                 w  ]   
   >   
   > op(A) = A or A**T, A**T denotes the transpose of   
   > matrix A.   
   >   
   > On input, X = [ c ].  On output, X = [ p ].   
   >               [ d ]                  [ q ]   
   >   
   > This subroutine is designed for the condition number estimation   
   > in routine DTRSNA.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] LTRAN   
   > \verbatim   
   >          LTRAN is LOGICAL   
   >          On entry, LTRAN specifies the option of conjugate transpose:   
   >             = .FALSE.,    op(T+i*B) = T+i*B,   
   >             = .TRUE.,     op(T+i*B) = (T+i*B)**T.   
   > \endverbatim   
   >   
   > \param[in] LREAL   
   > \verbatim   
   >          LREAL is LOGICAL   
   >          On entry, LREAL specifies the input matrix structure:   
   >             = .FALSE.,    the input is complex   
   >             = .TRUE.,     the input is real   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          On entry, N specifies the order of T+i*B. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          On entry, T contains a matrix in Schur canonical form.   
   >          If LREAL = .FALSE., then the first diagonal block of T mu   
   >          be 1 by 1.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the matrix T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (N)   
   >          On entry, B contains the elements to form the matrix   
   >          B as described above.   
   >          If LREAL = .TRUE., B is not referenced.   
   > \endverbatim   
   >   
   > \param[in] W   
   > \verbatim   
   >          W is DOUBLE PRECISION   
   >          On entry, W is the diagonal element of the matrix B.   
   >          If LREAL = .TRUE., W is not referenced.   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION   
   >          On exit, SCALE is the scale factor.   
   > \endverbatim   
   >   
   > \param[in,out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (2*N)   
   >          On entry, X contains the right hand side of the system.   
   >          On exit, X is overwritten by the solution.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          On exit, INFO is set to   
   >             0: successful exit.   
   >               1: the some diagonal 1 by 1 block has been perturbed by   
   >                  a small number SMIN to keep nonsingularity.   
   >               2: the some diagonal 2 by 2 block has been perturbed by   
   >                  a small number in DLALN2 to keep nonsingularity.   
   >          NOTE: In the interests of speed, this routine does not   
   >                check the inputs for errors.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlaqtr_(logical *ltran, logical *lreal, integer *n, 
	doublereal *t, integer *ldt, doublereal *b, doublereal *w, doublereal 
	*scale, doublereal *x, doublereal *work, integer *info)
{
    /* System generated locals */
    integer t_dim1, t_offset, i__1, i__2;
    doublereal d__1, d__2, d__3, d__4, d__5, d__6;

    /* Local variables */
    doublereal d__[4]	/* was [2][2] */;
    integer i__, j, k;
    doublereal v[4]	/* was [2][2] */, z__;
    integer j1, j2, n1, n2;
    doublereal si, xj, sr, rec, eps, tjj, tmp;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    integer ierr;
    doublereal smin, xmax;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern doublereal igraphdasum_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdaxpy_(integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *);
    integer jnext;
    doublereal sminw, xnorm;
    extern /* Subroutine */ int igraphdlaln2_(logical *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, doublereal *,
	     doublereal *, doublereal *, integer *, doublereal *, doublereal *
	    , doublereal *, integer *, doublereal *, doublereal *, integer *);
    extern doublereal igraphdlamch_(char *), igraphdlange_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    doublereal scaloc;
    extern /* Subroutine */ int igraphdladiv_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *);
    doublereal bignum;
    logical notran;
    doublereal smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Do not test the input parameters for errors   

       Parameter adjustments */
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    --b;
    --x;
    --work;

    /* Function Body */
    notran = ! (*ltran);
    *info = 0;

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

/*     Set constants to control overflow */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S") / eps;
    bignum = 1. / smlnum;

    xnorm = igraphdlange_("M", n, n, &t[t_offset], ldt, d__);
    if (! (*lreal)) {
/* Computing MAX */
	d__1 = xnorm, d__2 = abs(*w), d__1 = max(d__1,d__2), d__2 = igraphdlange_(
		"M", n, &c__1, &b[1], n, d__);
	xnorm = max(d__1,d__2);
    }
/* Computing MAX */
    d__1 = smlnum, d__2 = eps * xnorm;
    smin = max(d__1,d__2);

/*     Compute 1-norm of each column of strictly upper triangular   
       part of T to control overflow in triangular solver. */

    work[1] = 0.;
    i__1 = *n;
    for (j = 2; j <= i__1; ++j) {
	i__2 = j - 1;
	work[j] = igraphdasum_(&i__2, &t[j * t_dim1 + 1], &c__1);
/* L10: */
    }

    if (! (*lreal)) {
	i__1 = *n;
	for (i__ = 2; i__ <= i__1; ++i__) {
	    work[i__] += (d__1 = b[i__], abs(d__1));
/* L20: */
	}
    }

    n2 = *n << 1;
    n1 = *n;
    if (! (*lreal)) {
	n1 = n2;
    }
    k = igraphidamax_(&n1, &x[1], &c__1);
    xmax = (d__1 = x[k], abs(d__1));
    *scale = 1.;

    if (xmax > bignum) {
	*scale = bignum / xmax;
	igraphdscal_(&n1, scale, &x[1], &c__1);
	xmax = bignum;
    }

    if (*lreal) {

	if (notran) {

/*           Solve T*p = scale*c */

	    jnext = *n;
	    for (j = *n; j >= 1; --j) {
		if (j > jnext) {
		    goto L30;
		}
		j1 = j;
		j2 = j;
		jnext = j - 1;
		if (j > 1) {
		    if (t[j + (j - 1) * t_dim1] != 0.) {
			j1 = j - 1;
			jnext = j - 2;
		    }
		}

		if (j1 == j2) {

/*                 Meet 1 by 1 diagonal block   

                   Scale to avoid overflow when computing   
                       x(j) = b(j)/T(j,j) */

		    xj = (d__1 = x[j1], abs(d__1));
		    tjj = (d__1 = t[j1 + j1 * t_dim1], abs(d__1));
		    tmp = t[j1 + j1 * t_dim1];
		    if (tjj < smin) {
			tmp = smin;
			tjj = smin;
			*info = 1;
		    }

		    if (xj == 0.) {
			goto L30;
		    }

		    if (tjj < 1.) {
			if (xj > bignum * tjj) {
			    rec = 1. / xj;
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }
		    x[j1] /= tmp;
		    xj = (d__1 = x[j1], abs(d__1));

/*                 Scale x if necessary to avoid overflow when adding a   
                   multiple of column j1 of T. */

		    if (xj > 1.) {
			rec = 1. / xj;
			if (work[j1] > (bignum - xmax) * rec) {
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			}
		    }
		    if (j1 > 1) {
			i__1 = j1 - 1;
			d__1 = -x[j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);
			i__1 = j1 - 1;
			k = igraphidamax_(&i__1, &x[1], &c__1);
			xmax = (d__1 = x[k], abs(d__1));
		    }

		} else {

/*                 Meet 2 by 2 diagonal block   

                   Call 2 by 2 linear system solve, to take   
                   care of possible overflow by scaling factor. */

		    d__[0] = x[j1];
		    d__[1] = x[j2];
		    igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b21, &t[j1 + j1 
			    * t_dim1], ldt, &c_b21, &c_b21, d__, &c__2, &
			    c_b25, &c_b25, v, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 2;
		    }

		    if (scaloc != 1.) {
			igraphdscal_(n, &scaloc, &x[1], &c__1);
			*scale *= scaloc;
		    }
		    x[j1] = v[0];
		    x[j2] = v[1];

/*                 Scale V(1,1) (= X(J1)) and/or V(2,1) (=X(J2))   
                   to avoid overflow in updating right-hand side.   

   Computing MAX */
		    d__1 = abs(v[0]), d__2 = abs(v[1]);
		    xj = max(d__1,d__2);
		    if (xj > 1.) {
			rec = 1. / xj;
/* Computing MAX */
			d__1 = work[j1], d__2 = work[j2];
			if (max(d__1,d__2) > (bignum - xmax) * rec) {
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			}
		    }

/*                 Update right-hand side */

		    if (j1 > 1) {
			i__1 = j1 - 1;
			d__1 = -x[j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);
			i__1 = j1 - 1;
			d__1 = -x[j2];
			igraphdaxpy_(&i__1, &d__1, &t[j2 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);
			i__1 = j1 - 1;
			k = igraphidamax_(&i__1, &x[1], &c__1);
			xmax = (d__1 = x[k], abs(d__1));
		    }

		}

L30:
		;
	    }

	} else {

/*           Solve T**T*p = scale*c */

	    jnext = 1;
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (j < jnext) {
		    goto L40;
		}
		j1 = j;
		j2 = j;
		jnext = j + 1;
		if (j < *n) {
		    if (t[j + 1 + j * t_dim1] != 0.) {
			j2 = j + 1;
			jnext = j + 2;
		    }
		}

		if (j1 == j2) {

/*                 1 by 1 diagonal block   

                   Scale if necessary to avoid overflow in forming the   
                   right-hand side element by inner product. */

		    xj = (d__1 = x[j1], abs(d__1));
		    if (xmax > 1.) {
			rec = 1. / xmax;
			if (work[j1] > (bignum - xj) * rec) {
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }

		    i__2 = j1 - 1;
		    x[j1] -= igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &c__1, &x[1], &
			    c__1);

		    xj = (d__1 = x[j1], abs(d__1));
		    tjj = (d__1 = t[j1 + j1 * t_dim1], abs(d__1));
		    tmp = t[j1 + j1 * t_dim1];
		    if (tjj < smin) {
			tmp = smin;
			tjj = smin;
			*info = 1;
		    }

		    if (tjj < 1.) {
			if (xj > bignum * tjj) {
			    rec = 1. / xj;
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }
		    x[j1] /= tmp;
/* Computing MAX */
		    d__2 = xmax, d__3 = (d__1 = x[j1], abs(d__1));
		    xmax = max(d__2,d__3);

		} else {

/*                 2 by 2 diagonal block   

                   Scale if necessary to avoid overflow in forming the   
                   right-hand side elements by inner product.   

   Computing MAX */
		    d__3 = (d__1 = x[j1], abs(d__1)), d__4 = (d__2 = x[j2], 
			    abs(d__2));
		    xj = max(d__3,d__4);
		    if (xmax > 1.) {
			rec = 1. / xmax;
/* Computing MAX */
			d__1 = work[j2], d__2 = work[j1];
			if (max(d__1,d__2) > (bignum - xj) * rec) {
			    igraphdscal_(n, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }

		    i__2 = j1 - 1;
		    d__[0] = x[j1] - igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &c__1, 
			    &x[1], &c__1);
		    i__2 = j1 - 1;
		    d__[1] = x[j2] - igraphddot_(&i__2, &t[j2 * t_dim1 + 1], &c__1, 
			    &x[1], &c__1);

		    igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b21, &t[j1 + j1 *
			     t_dim1], ldt, &c_b21, &c_b21, d__, &c__2, &c_b25,
			     &c_b25, v, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 2;
		    }

		    if (scaloc != 1.) {
			igraphdscal_(n, &scaloc, &x[1], &c__1);
			*scale *= scaloc;
		    }
		    x[j1] = v[0];
		    x[j2] = v[1];
/* Computing MAX */
		    d__3 = (d__1 = x[j1], abs(d__1)), d__4 = (d__2 = x[j2], 
			    abs(d__2)), d__3 = max(d__3,d__4);
		    xmax = max(d__3,xmax);

		}
L40:
		;
	    }
	}

    } else {

/* Computing MAX */
	d__1 = eps * abs(*w);
	sminw = max(d__1,smin);
	if (notran) {

/*           Solve (T + iB)*(p+iq) = c+id */

	    jnext = *n;
	    for (j = *n; j >= 1; --j) {
		if (j > jnext) {
		    goto L70;
		}
		j1 = j;
		j2 = j;
		jnext = j - 1;
		if (j > 1) {
		    if (t[j + (j - 1) * t_dim1] != 0.) {
			j1 = j - 1;
			jnext = j - 2;
		    }
		}

		if (j1 == j2) {

/*                 1 by 1 diagonal block   

                   Scale if necessary to avoid overflow in division */

		    z__ = *w;
		    if (j1 == 1) {
			z__ = b[1];
		    }
		    xj = (d__1 = x[j1], abs(d__1)) + (d__2 = x[*n + j1], abs(
			    d__2));
		    tjj = (d__1 = t[j1 + j1 * t_dim1], abs(d__1)) + abs(z__);
		    tmp = t[j1 + j1 * t_dim1];
		    if (tjj < sminw) {
			tmp = sminw;
			tjj = sminw;
			*info = 1;
		    }

		    if (xj == 0.) {
			goto L70;
		    }

		    if (tjj < 1.) {
			if (xj > bignum * tjj) {
			    rec = 1. / xj;
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }
		    igraphdladiv_(&x[j1], &x[*n + j1], &tmp, &z__, &sr, &si);
		    x[j1] = sr;
		    x[*n + j1] = si;
		    xj = (d__1 = x[j1], abs(d__1)) + (d__2 = x[*n + j1], abs(
			    d__2));

/*                 Scale x if necessary to avoid overflow when adding a   
                   multiple of column j1 of T. */

		    if (xj > 1.) {
			rec = 1. / xj;
			if (work[j1] > (bignum - xmax) * rec) {
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			}
		    }

		    if (j1 > 1) {
			i__1 = j1 - 1;
			d__1 = -x[j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);
			i__1 = j1 - 1;
			d__1 = -x[*n + j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[*
				n + 1], &c__1);

			x[1] += b[j1] * x[*n + j1];
			x[*n + 1] -= b[j1] * x[j1];

			xmax = 0.;
			i__1 = j1 - 1;
			for (k = 1; k <= i__1; ++k) {
/* Computing MAX */
			    d__3 = xmax, d__4 = (d__1 = x[k], abs(d__1)) + (
				    d__2 = x[k + *n], abs(d__2));
			    xmax = max(d__3,d__4);
/* L50: */
			}
		    }

		} else {

/*                 Meet 2 by 2 diagonal block */

		    d__[0] = x[j1];
		    d__[1] = x[j2];
		    d__[2] = x[*n + j1];
		    d__[3] = x[*n + j2];
		    d__1 = -(*w);
		    igraphdlaln2_(&c_false, &c__2, &c__2, &sminw, &c_b21, &t[j1 + 
			    j1 * t_dim1], ldt, &c_b21, &c_b21, d__, &c__2, &
			    c_b25, &d__1, v, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 2;
		    }

		    if (scaloc != 1.) {
			i__1 = *n << 1;
			igraphdscal_(&i__1, &scaloc, &x[1], &c__1);
			*scale = scaloc * *scale;
		    }
		    x[j1] = v[0];
		    x[j2] = v[1];
		    x[*n + j1] = v[2];
		    x[*n + j2] = v[3];

/*                 Scale X(J1), .... to avoid overflow in   
                   updating right hand side.   

   Computing MAX */
		    d__1 = abs(v[0]) + abs(v[2]), d__2 = abs(v[1]) + abs(v[3])
			    ;
		    xj = max(d__1,d__2);
		    if (xj > 1.) {
			rec = 1. / xj;
/* Computing MAX */
			d__1 = work[j1], d__2 = work[j2];
			if (max(d__1,d__2) > (bignum - xmax) * rec) {
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			}
		    }

/*                 Update the right-hand side. */

		    if (j1 > 1) {
			i__1 = j1 - 1;
			d__1 = -x[j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);
			i__1 = j1 - 1;
			d__1 = -x[j2];
			igraphdaxpy_(&i__1, &d__1, &t[j2 * t_dim1 + 1], &c__1, &x[1]
				, &c__1);

			i__1 = j1 - 1;
			d__1 = -x[*n + j1];
			igraphdaxpy_(&i__1, &d__1, &t[j1 * t_dim1 + 1], &c__1, &x[*
				n + 1], &c__1);
			i__1 = j1 - 1;
			d__1 = -x[*n + j2];
			igraphdaxpy_(&i__1, &d__1, &t[j2 * t_dim1 + 1], &c__1, &x[*
				n + 1], &c__1);

			x[1] = x[1] + b[j1] * x[*n + j1] + b[j2] * x[*n + j2];
			x[*n + 1] = x[*n + 1] - b[j1] * x[j1] - b[j2] * x[j2];

			xmax = 0.;
			i__1 = j1 - 1;
			for (k = 1; k <= i__1; ++k) {
/* Computing MAX */
			    d__3 = (d__1 = x[k], abs(d__1)) + (d__2 = x[k + *
				    n], abs(d__2));
			    xmax = max(d__3,xmax);
/* L60: */
			}
		    }

		}
L70:
		;
	    }

	} else {

/*           Solve (T + iB)**T*(p+iq) = c+id */

	    jnext = 1;
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (j < jnext) {
		    goto L80;
		}
		j1 = j;
		j2 = j;
		jnext = j + 1;
		if (j < *n) {
		    if (t[j + 1 + j * t_dim1] != 0.) {
			j2 = j + 1;
			jnext = j + 2;
		    }
		}

		if (j1 == j2) {

/*                 1 by 1 diagonal block   

                   Scale if necessary to avoid overflow in forming the   
                   right-hand side element by inner product. */

		    xj = (d__1 = x[j1], abs(d__1)) + (d__2 = x[j1 + *n], abs(
			    d__2));
		    if (xmax > 1.) {
			rec = 1. / xmax;
			if (work[j1] > (bignum - xj) * rec) {
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }

		    i__2 = j1 - 1;
		    x[j1] -= igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &c__1, &x[1], &
			    c__1);
		    i__2 = j1 - 1;
		    x[*n + j1] -= igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &c__1, &x[
			    *n + 1], &c__1);
		    if (j1 > 1) {
			x[j1] -= b[j1] * x[*n + 1];
			x[*n + j1] += b[j1] * x[1];
		    }
		    xj = (d__1 = x[j1], abs(d__1)) + (d__2 = x[j1 + *n], abs(
			    d__2));

		    z__ = *w;
		    if (j1 == 1) {
			z__ = b[1];
		    }

/*                 Scale if necessary to avoid overflow in   
                   complex division */

		    tjj = (d__1 = t[j1 + j1 * t_dim1], abs(d__1)) + abs(z__);
		    tmp = t[j1 + j1 * t_dim1];
		    if (tjj < sminw) {
			tmp = sminw;
			tjj = sminw;
			*info = 1;
		    }

		    if (tjj < 1.) {
			if (xj > bignum * tjj) {
			    rec = 1. / xj;
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }
		    d__1 = -z__;
		    igraphdladiv_(&x[j1], &x[*n + j1], &tmp, &d__1, &sr, &si);
		    x[j1] = sr;
		    x[j1 + *n] = si;
/* Computing MAX */
		    d__3 = (d__1 = x[j1], abs(d__1)) + (d__2 = x[j1 + *n], 
			    abs(d__2));
		    xmax = max(d__3,xmax);

		} else {

/*                 2 by 2 diagonal block   

                   Scale if necessary to avoid overflow in forming the   
                   right-hand side element by inner product.   

   Computing MAX */
		    d__5 = (d__1 = x[j1], abs(d__1)) + (d__2 = x[*n + j1], 
			    abs(d__2)), d__6 = (d__3 = x[j2], abs(d__3)) + (
			    d__4 = x[*n + j2], abs(d__4));
		    xj = max(d__5,d__6);
		    if (xmax > 1.) {
			rec = 1. / xmax;
/* Computing MAX */
			d__1 = work[j1], d__2 = work[j2];
			if (max(d__1,d__2) > (bignum - xj) / xmax) {
			    igraphdscal_(&n2, &rec, &x[1], &c__1);
			    *scale *= rec;
			    xmax *= rec;
			}
		    }

		    i__2 = j1 - 1;
		    d__[0] = x[j1] - igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &c__1, 
			    &x[1], &c__1);
		    i__2 = j1 - 1;
		    d__[1] = x[j2] - igraphddot_(&i__2, &t[j2 * t_dim1 + 1], &c__1, 
			    &x[1], &c__1);
		    i__2 = j1 - 1;
		    d__[2] = x[*n + j1] - igraphddot_(&i__2, &t[j1 * t_dim1 + 1], &
			    c__1, &x[*n + 1], &c__1);
		    i__2 = j1 - 1;
		    d__[3] = x[*n + j2] - igraphddot_(&i__2, &t[j2 * t_dim1 + 1], &
			    c__1, &x[*n + 1], &c__1);
		    d__[0] -= b[j1] * x[*n + 1];
		    d__[1] -= b[j2] * x[*n + 1];
		    d__[2] += b[j1] * x[1];
		    d__[3] += b[j2] * x[1];

		    igraphdlaln2_(&c_true, &c__2, &c__2, &sminw, &c_b21, &t[j1 + j1 
			    * t_dim1], ldt, &c_b21, &c_b21, d__, &c__2, &
			    c_b25, w, v, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 2;
		    }

		    if (scaloc != 1.) {
			igraphdscal_(&n2, &scaloc, &x[1], &c__1);
			*scale = scaloc * *scale;
		    }
		    x[j1] = v[0];
		    x[j2] = v[1];
		    x[*n + j1] = v[2];
		    x[*n + j2] = v[3];
/* Computing MAX */
		    d__5 = (d__1 = x[j1], abs(d__1)) + (d__2 = x[*n + j1], 
			    abs(d__2)), d__6 = (d__3 = x[j2], abs(d__3)) + (
			    d__4 = x[*n + j2], abs(d__4)), d__5 = max(d__5,
			    d__6);
		    xmax = max(d__5,xmax);

		}

L80:
		;
	    }

	}

    }

    return 0;

/*     End of DLAQTR */

} /* igraphdlaqtr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlar1v.c0000644000175100001710000003716500000000000023753 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLAR1V computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn 
of the tridiagonal matrix LDLT - λI.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLAR1V + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLAR1V( N, B1, BN, LAMBDA, D, L, LD, LLD,   
                    PIVMIN, GAPTOL, Z, WANTNC, NEGCNT, ZTZ, MINGMA,   
                    R, ISUPPZ, NRMINV, RESID, RQCORR, WORK )   

         LOGICAL            WANTNC   
         INTEGER   B1, BN, N, NEGCNT, R   
         DOUBLE PRECISION   GAPTOL, LAMBDA, MINGMA, NRMINV, PIVMIN, RESID,   
        $                   RQCORR, ZTZ   
         INTEGER            ISUPPZ( * )   
         DOUBLE PRECISION   D( * ), L( * ), LD( * ), LLD( * ),   
        $                  WORK( * )   
         DOUBLE PRECISION Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLAR1V computes the (scaled) r-th column of the inverse of   
   > the sumbmatrix in rows B1 through BN of the tridiagonal matrix   
   > L D L**T - sigma I. When sigma is close to an eigenvalue, the   
   > computed vector is an accurate eigenvector. Usually, r corresponds   
   > to the index where the eigenvector is largest in magnitude.   
   > The following steps accomplish this computation :   
   > (a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,   
   > (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,   
   > (c) Computation of the diagonal elements of the inverse of   
   >     L D L**T - sigma I by combining the above transforms, and choosing   
   >     r as the index where the diagonal of the inverse is (one of the)   
   >     largest in magnitude.   
   > (d) Computation of the (scaled) r-th column of the inverse using the   
   >     twisted factorization obtained by combining the top part of the   
   >     the stationary and the bottom part of the progressive transform.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           The order of the matrix L D L**T.   
   > \endverbatim   
   >   
   > \param[in] B1   
   > \verbatim   
   >          B1 is INTEGER   
   >           First index of the submatrix of L D L**T.   
   > \endverbatim   
   >   
   > \param[in] BN   
   > \verbatim   
   >          BN is INTEGER   
   >           Last index of the submatrix of L D L**T.   
   > \endverbatim   
   >   
   > \param[in] LAMBDA   
   > \verbatim   
   >          LAMBDA is DOUBLE PRECISION   
   >           The shift. In order to compute an accurate eigenvector,   
   >           LAMBDA should be a good approximation to an eigenvalue   
   >           of L D L**T.   
   > \endverbatim   
   >   
   > \param[in] L   
   > \verbatim   
   >          L is DOUBLE PRECISION array, dimension (N-1)   
   >           The (n-1) subdiagonal elements of the unit bidiagonal matrix   
   >           L, in elements 1 to N-1.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >           The n diagonal elements of the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] LD   
   > \verbatim   
   >          LD is DOUBLE PRECISION array, dimension (N-1)   
   >           The n-1 elements L(i)*D(i).   
   > \endverbatim   
   >   
   > \param[in] LLD   
   > \verbatim   
   >          LLD is DOUBLE PRECISION array, dimension (N-1)   
   >           The n-1 elements L(i)*L(i)*D(i).   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >           The minimum pivot in the Sturm sequence.   
   > \endverbatim   
   >   
   > \param[in] GAPTOL   
   > \verbatim   
   >          GAPTOL is DOUBLE PRECISION   
   >           Tolerance that indicates when eigenvector entries are negligible   
   >           w.r.t. their contribution to the residual.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (N)   
   >           On input, all entries of Z must be set to 0.   
   >           On output, Z contains the (scaled) r-th column of the   
   >           inverse. The scaling is such that Z(R) equals 1.   
   > \endverbatim   
   >   
   > \param[in] WANTNC   
   > \verbatim   
   >          WANTNC is LOGICAL   
   >           Specifies whether NEGCNT has to be computed.   
   > \endverbatim   
   >   
   > \param[out] NEGCNT   
   > \verbatim   
   >          NEGCNT is INTEGER   
   >           If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin   
   >           in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise.   
   > \endverbatim   
   >   
   > \param[out] ZTZ   
   > \verbatim   
   >          ZTZ is DOUBLE PRECISION   
   >           The square of the 2-norm of Z.   
   > \endverbatim   
   >   
   > \param[out] MINGMA   
   > \verbatim   
   >          MINGMA is DOUBLE PRECISION   
   >           The reciprocal of the largest (in magnitude) diagonal   
   >           element of the inverse of L D L**T - sigma I.   
   > \endverbatim   
   >   
   > \param[in,out] R   
   > \verbatim   
   >          R is INTEGER   
   >           The twist index for the twisted factorization used to   
   >           compute Z.   
   >           On input, 0 <= R <= N. If R is input as 0, R is set to   
   >           the index where (L D L**T - sigma I)^{-1} is largest   
   >           in magnitude. If 1 <= R <= N, R is unchanged.   
   >           On output, R contains the twist index used to compute Z.   
   >           Ideally, R designates the position of the maximum entry in the   
   >           eigenvector.   
   > \endverbatim   
   >   
   > \param[out] ISUPPZ   
   > \verbatim   
   >          ISUPPZ is INTEGER array, dimension (2)   
   >           The support of the vector in Z, i.e., the vector Z is   
   >           nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).   
   > \endverbatim   
   >   
   > \param[out] NRMINV   
   > \verbatim   
   >          NRMINV is DOUBLE PRECISION   
   >           NRMINV = 1/SQRT( ZTZ )   
   > \endverbatim   
   >   
   > \param[out] RESID   
   > \verbatim   
   >          RESID is DOUBLE PRECISION   
   >           The residual of the FP vector.   
   >           RESID = ABS( MINGMA )/SQRT( ZTZ )   
   > \endverbatim   
   >   
   > \param[out] RQCORR   
   > \verbatim   
   >          RQCORR is DOUBLE PRECISION   
   >           The Rayleigh Quotient correction to LAMBDA.   
   >           RQCORR = MINGMA*TMP   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (4*N)   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlar1v_(integer *n, integer *b1, integer *bn, doublereal 
	*lambda, doublereal *d__, doublereal *l, doublereal *ld, doublereal *
	lld, doublereal *pivmin, doublereal *gaptol, doublereal *z__, logical 
	*wantnc, integer *negcnt, doublereal *ztz, doublereal *mingma, 
	integer *r__, integer *isuppz, doublereal *nrminv, doublereal *resid, 
	doublereal *rqcorr, doublereal *work)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal s;
    integer r1, r2;
    doublereal eps, tmp;
    integer neg1, neg2, indp, inds;
    doublereal dplus;
    extern doublereal igraphdlamch_(char *);
    extern logical igraphdisnan_(doublereal *);
    integer indlpl, indumn;
    doublereal dminus;
    logical sawnan1, sawnan2;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --work;
    --isuppz;
    --z__;
    --lld;
    --ld;
    --l;
    --d__;

    /* Function Body */
    eps = igraphdlamch_("Precision");
    if (*r__ == 0) {
	r1 = *b1;
	r2 = *bn;
    } else {
	r1 = *r__;
	r2 = *r__;
    }
/*     Storage for LPLUS */
    indlpl = 0;
/*     Storage for UMINUS */
    indumn = *n;
    inds = (*n << 1) + 1;
    indp = *n * 3 + 1;
    if (*b1 == 1) {
	work[inds] = 0.;
    } else {
	work[inds + *b1 - 1] = lld[*b1 - 1];
    }

/*     Compute the stationary transform (using the differential form)   
       until the index R2. */

    sawnan1 = FALSE_;
    neg1 = 0;
    s = work[inds + *b1 - 1] - *lambda;
    i__1 = r1 - 1;
    for (i__ = *b1; i__ <= i__1; ++i__) {
	dplus = d__[i__] + s;
	work[indlpl + i__] = ld[i__] / dplus;
	if (dplus < 0.) {
	    ++neg1;
	}
	work[inds + i__] = s * work[indlpl + i__] * l[i__];
	s = work[inds + i__] - *lambda;
/* L50: */
    }
    sawnan1 = igraphdisnan_(&s);
    if (sawnan1) {
	goto L60;
    }
    i__1 = r2 - 1;
    for (i__ = r1; i__ <= i__1; ++i__) {
	dplus = d__[i__] + s;
	work[indlpl + i__] = ld[i__] / dplus;
	work[inds + i__] = s * work[indlpl + i__] * l[i__];
	s = work[inds + i__] - *lambda;
/* L51: */
    }
    sawnan1 = igraphdisnan_(&s);

L60:
    if (sawnan1) {
/*        Runs a slower version of the above loop if a NaN is detected */
	neg1 = 0;
	s = work[inds + *b1 - 1] - *lambda;
	i__1 = r1 - 1;
	for (i__ = *b1; i__ <= i__1; ++i__) {
	    dplus = d__[i__] + s;
	    if (abs(dplus) < *pivmin) {
		dplus = -(*pivmin);
	    }
	    work[indlpl + i__] = ld[i__] / dplus;
	    if (dplus < 0.) {
		++neg1;
	    }
	    work[inds + i__] = s * work[indlpl + i__] * l[i__];
	    if (work[indlpl + i__] == 0.) {
		work[inds + i__] = lld[i__];
	    }
	    s = work[inds + i__] - *lambda;
/* L70: */
	}
	i__1 = r2 - 1;
	for (i__ = r1; i__ <= i__1; ++i__) {
	    dplus = d__[i__] + s;
	    if (abs(dplus) < *pivmin) {
		dplus = -(*pivmin);
	    }
	    work[indlpl + i__] = ld[i__] / dplus;
	    work[inds + i__] = s * work[indlpl + i__] * l[i__];
	    if (work[indlpl + i__] == 0.) {
		work[inds + i__] = lld[i__];
	    }
	    s = work[inds + i__] - *lambda;
/* L71: */
	}
    }

/*     Compute the progressive transform (using the differential form)   
       until the index R1 */

    sawnan2 = FALSE_;
    neg2 = 0;
    work[indp + *bn - 1] = d__[*bn] - *lambda;
    i__1 = r1;
    for (i__ = *bn - 1; i__ >= i__1; --i__) {
	dminus = lld[i__] + work[indp + i__];
	tmp = d__[i__] / dminus;
	if (dminus < 0.) {
	    ++neg2;
	}
	work[indumn + i__] = l[i__] * tmp;
	work[indp + i__ - 1] = work[indp + i__] * tmp - *lambda;
/* L80: */
    }
    tmp = work[indp + r1 - 1];
    sawnan2 = igraphdisnan_(&tmp);
    if (sawnan2) {
/*        Runs a slower version of the above loop if a NaN is detected */
	neg2 = 0;
	i__1 = r1;
	for (i__ = *bn - 1; i__ >= i__1; --i__) {
	    dminus = lld[i__] + work[indp + i__];
	    if (abs(dminus) < *pivmin) {
		dminus = -(*pivmin);
	    }
	    tmp = d__[i__] / dminus;
	    if (dminus < 0.) {
		++neg2;
	    }
	    work[indumn + i__] = l[i__] * tmp;
	    work[indp + i__ - 1] = work[indp + i__] * tmp - *lambda;
	    if (tmp == 0.) {
		work[indp + i__ - 1] = d__[i__] - *lambda;
	    }
/* L100: */
	}
    }

/*     Find the index (from R1 to R2) of the largest (in magnitude)   
       diagonal element of the inverse */

    *mingma = work[inds + r1 - 1] + work[indp + r1 - 1];
    if (*mingma < 0.) {
	++neg1;
    }
    if (*wantnc) {
	*negcnt = neg1 + neg2;
    } else {
	*negcnt = -1;
    }
    if (abs(*mingma) == 0.) {
	*mingma = eps * work[inds + r1 - 1];
    }
    *r__ = r1;
    i__1 = r2 - 1;
    for (i__ = r1; i__ <= i__1; ++i__) {
	tmp = work[inds + i__] + work[indp + i__];
	if (tmp == 0.) {
	    tmp = eps * work[inds + i__];
	}
	if (abs(tmp) <= abs(*mingma)) {
	    *mingma = tmp;
	    *r__ = i__ + 1;
	}
/* L110: */
    }

/*     Compute the FP vector: solve N^T v = e_r */

    isuppz[1] = *b1;
    isuppz[2] = *bn;
    z__[*r__] = 1.;
    *ztz = 1.;

/*     Compute the FP vector upwards from R */

    if (! sawnan1 && ! sawnan2) {
	i__1 = *b1;
	for (i__ = *r__ - 1; i__ >= i__1; --i__) {
	    z__[i__] = -(work[indlpl + i__] * z__[i__ + 1]);
	    if (((d__1 = z__[i__], abs(d__1)) + (d__2 = z__[i__ + 1], abs(
		    d__2))) * (d__3 = ld[i__], abs(d__3)) < *gaptol) {
		z__[i__] = 0.;
		isuppz[1] = i__ + 1;
		goto L220;
	    }
	    *ztz += z__[i__] * z__[i__];
/* L210: */
	}
L220:
	;
    } else {
/*        Run slower loop if NaN occurred. */
	i__1 = *b1;
	for (i__ = *r__ - 1; i__ >= i__1; --i__) {
	    if (z__[i__ + 1] == 0.) {
		z__[i__] = -(ld[i__ + 1] / ld[i__]) * z__[i__ + 2];
	    } else {
		z__[i__] = -(work[indlpl + i__] * z__[i__ + 1]);
	    }
	    if (((d__1 = z__[i__], abs(d__1)) + (d__2 = z__[i__ + 1], abs(
		    d__2))) * (d__3 = ld[i__], abs(d__3)) < *gaptol) {
		z__[i__] = 0.;
		isuppz[1] = i__ + 1;
		goto L240;
	    }
	    *ztz += z__[i__] * z__[i__];
/* L230: */
	}
L240:
	;
    }
/*     Compute the FP vector downwards from R in blocks of size BLKSIZ */
    if (! sawnan1 && ! sawnan2) {
	i__1 = *bn - 1;
	for (i__ = *r__; i__ <= i__1; ++i__) {
	    z__[i__ + 1] = -(work[indumn + i__] * z__[i__]);
	    if (((d__1 = z__[i__], abs(d__1)) + (d__2 = z__[i__ + 1], abs(
		    d__2))) * (d__3 = ld[i__], abs(d__3)) < *gaptol) {
		z__[i__ + 1] = 0.;
		isuppz[2] = i__;
		goto L260;
	    }
	    *ztz += z__[i__ + 1] * z__[i__ + 1];
/* L250: */
	}
L260:
	;
    } else {
/*        Run slower loop if NaN occurred. */
	i__1 = *bn - 1;
	for (i__ = *r__; i__ <= i__1; ++i__) {
	    if (z__[i__] == 0.) {
		z__[i__ + 1] = -(ld[i__ - 1] / ld[i__]) * z__[i__ - 1];
	    } else {
		z__[i__ + 1] = -(work[indumn + i__] * z__[i__]);
	    }
	    if (((d__1 = z__[i__], abs(d__1)) + (d__2 = z__[i__ + 1], abs(
		    d__2))) * (d__3 = ld[i__], abs(d__3)) < *gaptol) {
		z__[i__ + 1] = 0.;
		isuppz[2] = i__;
		goto L280;
	    }
	    *ztz += z__[i__ + 1] * z__[i__ + 1];
/* L270: */
	}
L280:
	;
    }

/*     Compute quantities for convergence test */

    tmp = 1. / *ztz;
    *nrminv = sqrt(tmp);
    *resid = abs(*mingma) * *nrminv;
    *rqcorr = *mingma * tmp;


    return 0;

/*     End of DLAR1V */

} /* igraphdlar1v_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarf.c0000644000175100001710000001645700000000000023653 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b4 = 1.;
static doublereal c_b5 = 0.;
static integer c__1 = 1;

/* > \brief \b DLARF applies an elementary reflector to a general rectangular matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARF( SIDE, M, N, V, INCV, TAU, C, LDC, WORK )   

         CHARACTER          SIDE   
         INTEGER            INCV, LDC, M, N   
         DOUBLE PRECISION   TAU   
         DOUBLE PRECISION   C( LDC, * ), V( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARF applies a real elementary reflector H to a real m by n matrix   
   > C, from either the left or the right. H is represented in the form   
   >   
   >       H = I - tau * v * v**T   
   >   
   > where tau is a real scalar and v is a real vector.   
   >   
   > If tau = 0, then H is taken to be the unit matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': form  H * C   
   >          = 'R': form  C * H   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension   
   >                     (1 + (M-1)*abs(INCV)) if SIDE = 'L'   
   >                  or (1 + (N-1)*abs(INCV)) if SIDE = 'R'   
   >          The vector v in the representation of H. V is not used if   
   >          TAU = 0.   
   > \endverbatim   
   >   
   > \param[in] INCV   
   > \verbatim   
   >          INCV is INTEGER   
   >          The increment between elements of v. INCV <> 0.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >          The value tau in the representation of H.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the m by n matrix C.   
   >          On exit, C is overwritten by the matrix H * C if SIDE = 'L',   
   >          or C * H if SIDE = 'R'.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension   
   >                         (N) if SIDE = 'L'   
   >                      or (M) if SIDE = 'R'   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlarf_(char *side, integer *m, integer *n, doublereal *v,
	 integer *incv, doublereal *tau, doublereal *c__, integer *ldc, 
	doublereal *work)
{
    /* System generated locals */
    integer c_dim1, c_offset;
    doublereal d__1;

    /* Local variables */
    integer i__;
    logical applyleft;
    extern /* Subroutine */ int igraphdger_(integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    integer lastc, lastv;
    extern integer igraphiladlc_(integer *, integer *, doublereal *, integer *), 
	    igraphiladlr_(integer *, integer *, doublereal *, integer *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --v;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    applyleft = igraphlsame_(side, "L");
    lastv = 0;
    lastc = 0;
    if (*tau != 0.) {
/*     Set up variables for scanning V.  LASTV begins pointing to the end   
       of V. */
	if (applyleft) {
	    lastv = *m;
	} else {
	    lastv = *n;
	}
	if (*incv > 0) {
	    i__ = (lastv - 1) * *incv + 1;
	} else {
	    i__ = 1;
	}
/*     Look for the last non-zero row in V. */
	while(lastv > 0 && v[i__] == 0.) {
	    --lastv;
	    i__ -= *incv;
	}
	if (applyleft) {
/*     Scan for the last non-zero column in C(1:lastv,:). */
	    lastc = igraphiladlc_(&lastv, n, &c__[c_offset], ldc);
	} else {
/*     Scan for the last non-zero row in C(:,1:lastv). */
	    lastc = igraphiladlr_(m, &lastv, &c__[c_offset], ldc);
	}
    }
/*     Note that lastc.eq.0 renders the BLAS operations null; no special   
       case is needed at this level. */
    if (applyleft) {

/*        Form  H * C */

	if (lastv > 0) {

/*           w(1:lastc,1) := C(1:lastv,1:lastc)**T * v(1:lastv,1) */

	    igraphdgemv_("Transpose", &lastv, &lastc, &c_b4, &c__[c_offset], ldc, &
		    v[1], incv, &c_b5, &work[1], &c__1);

/*           C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**T */

	    d__1 = -(*tau);
	    igraphdger_(&lastv, &lastc, &d__1, &v[1], incv, &work[1], &c__1, &c__[
		    c_offset], ldc);
	}
    } else {

/*        Form  C * H */

	if (lastv > 0) {

/*           w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1) */

	    igraphdgemv_("No transpose", &lastc, &lastv, &c_b4, &c__[c_offset], ldc,
		     &v[1], incv, &c_b5, &work[1], &c__1);

/*           C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**T */

	    d__1 = -(*tau);
	    igraphdger_(&lastc, &lastv, &d__1, &work[1], &c__1, &v[1], incv, &c__[
		    c_offset], ldc);
	}
    }
    return 0;

/*     End of DLARF */

} /* igraphdlarf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarfb.c0000644000175100001710000005560500000000000024013 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b14 = 1.;
static doublereal c_b25 = -1.;

/* > \brief \b DLARFB applies a block reflector or its transpose to a general rectangular matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARFB + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARFB( SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV,   
                            T, LDT, C, LDC, WORK, LDWORK )   

         CHARACTER          DIRECT, SIDE, STOREV, TRANS   
         INTEGER            K, LDC, LDT, LDV, LDWORK, M, N   
         DOUBLE PRECISION   C( LDC, * ), T( LDT, * ), V( LDV, * ),   
        $                   WORK( LDWORK, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARFB applies a real block reflector H or its transpose H**T to a   
   > real m by n matrix C, from either the left or the right.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply H or H**T from the Left   
   >          = 'R': apply H or H**T from the Right   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N': apply H (No transpose)   
   >          = 'T': apply H**T (Transpose)   
   > \endverbatim   
   >   
   > \param[in] DIRECT   
   > \verbatim   
   >          DIRECT is CHARACTER*1   
   >          Indicates how H is formed from a product of elementary   
   >          reflectors   
   >          = 'F': H = H(1) H(2) . . . H(k) (Forward)   
   >          = 'B': H = H(k) . . . H(2) H(1) (Backward)   
   > \endverbatim   
   >   
   > \param[in] STOREV   
   > \verbatim   
   >          STOREV is CHARACTER*1   
   >          Indicates how the vectors which define the elementary   
   >          reflectors are stored:   
   >          = 'C': Columnwise   
   >          = 'R': Rowwise   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The order of the matrix T (= the number of elementary   
   >          reflectors whose product defines the block reflector).   
   > \endverbatim   
   >   
   > \param[in] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension   
   >                                (LDV,K) if STOREV = 'C'   
   >                                (LDV,M) if STOREV = 'R' and SIDE = 'L'   
   >                                (LDV,N) if STOREV = 'R' and SIDE = 'R'   
   >          The matrix V. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is INTEGER   
   >          The leading dimension of the array V.   
   >          If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);   
   >          if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);   
   >          if STOREV = 'R', LDV >= K.   
   > \endverbatim   
   >   
   > \param[in] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,K)   
   >          The triangular k by k matrix T in the representation of the   
   >          block reflector.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= K.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the m by n matrix C.   
   >          On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LDWORK,K)   
   > \endverbatim   
   >   
   > \param[in] LDWORK   
   > \verbatim   
   >          LDWORK is INTEGER   
   >          The leading dimension of the array WORK.   
   >          If SIDE = 'L', LDWORK >= max(1,N);   
   >          if SIDE = 'R', LDWORK >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date June 2013   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The shape of the matrix V and the storage of the vectors which define   
   >  the H(i) is best illustrated by the following example with n = 5 and   
   >  k = 3. The elements equal to 1 are not stored; the corresponding   
   >  array elements are modified but restored on exit. The rest of the   
   >  array is not used.   
   >   
   >  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R':   
   >   
   >               V = (  1       )                 V = (  1 v1 v1 v1 v1 )   
   >                   ( v1  1    )                     (     1 v2 v2 v2 )   
   >                   ( v1 v2  1 )                     (        1 v3 v3 )   
   >                   ( v1 v2 v3 )   
   >                   ( v1 v2 v3 )   
   >   
   >  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R':   
   >   
   >               V = ( v1 v2 v3 )                 V = ( v1 v1  1       )   
   >                   ( v1 v2 v3 )                     ( v2 v2 v2  1    )   
   >                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )   
   >                   (     1 v3 )   
   >                   (        1 )   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlarfb_(char *side, char *trans, char *direct, char *
	storev, integer *m, integer *n, integer *k, doublereal *v, integer *
	ldv, doublereal *t, integer *ldt, doublereal *c__, integer *ldc, 
	doublereal *work, integer *ldwork)
{
    /* System generated locals */
    integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1, 
	    work_offset, i__1, i__2;

    /* Local variables */
    integer i__, j;
    extern /* Subroutine */ int igraphdgemm_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdtrmm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *);
    char transt[1];


/*  -- LAPACK auxiliary routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       June 2013   


    =====================================================================   


       Quick return if possible   

       Parameter adjustments */
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    work_dim1 = *ldwork;
    work_offset = 1 + work_dim1;
    work -= work_offset;

    /* Function Body */
    if (*m <= 0 || *n <= 0) {
	return 0;
    }

    if (igraphlsame_(trans, "N")) {
	*(unsigned char *)transt = 'T';
    } else {
	*(unsigned char *)transt = 'N';
    }

    if (igraphlsame_(storev, "C")) {

	if (igraphlsame_(direct, "F")) {

/*           Let  V =  ( V1 )    (first K rows)   
                       ( V2 )   
             where  V1  is unit lower triangular. */

	    if (igraphlsame_(side, "L")) {

/*              Form  H * C  or  H**T * C  where  C = ( C1 )   
                                                      ( C2 )   

                W := C**T * V  =  (C1**T * V1 + C2**T * V2)  (stored in WORK)   

                W := C1**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(n, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1],
			     &c__1);
/* L10: */
		}

/*              W := W * V1 */

		igraphdtrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b14,
			 &v[v_offset], ldv, &work[work_offset], ldwork);
		if (*m > *k) {

/*                 W := W + C2**T * V2 */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "No transpose", n, k, &i__1, &c_b14, &
			    c__[*k + 1 + c_dim1], ldc, &v[*k + 1 + v_dim1], 
			    ldv, &c_b14, &work[work_offset], ldwork);
		}

/*              W := W * T**T  or  W * T */

		igraphdtrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - V * W**T */

		if (*m > *k) {

/*                 C2 := C2 - V2 * W**T */

		    i__1 = *m - *k;
		    igraphdgemm_("No transpose", "Transpose", &i__1, n, k, &c_b25, &
			    v[*k + 1 + v_dim1], ldv, &work[work_offset], 
			    ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
		}

/*              W := W * V1**T */

		igraphdtrmm_("Right", "Lower", "Transpose", "Unit", n, k, &c_b14, &
			v[v_offset], ldv, &work[work_offset], ldwork);

/*              C1 := C1 - W**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
/* L20: */
		    }
/* L30: */
		}

	    } else if (igraphlsame_(side, "R")) {

/*              Form  C * H  or  C * H**T  where  C = ( C1  C2 )   

                W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK)   

                W := C1 */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(m, &c__[j * c_dim1 + 1], &c__1, &work[j * 
			    work_dim1 + 1], &c__1);
/* L40: */
		}

/*              W := W * V1 */

		igraphdtrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b14,
			 &v[v_offset], ldv, &work[work_offset], ldwork);
		if (*n > *k) {

/*                 W := W + C2 * V2 */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "No transpose", m, k, &i__1, &
			    c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc, &v[*k + 
			    1 + v_dim1], ldv, &c_b14, &work[work_offset], 
			    ldwork);
		}

/*              W := W * T  or  W * T**T */

		igraphdtrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - W * V**T */

		if (*n > *k) {

/*                 C2 := C2 - W * V2**T */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "Transpose", m, &i__1, k, &c_b25, &
			    work[work_offset], ldwork, &v[*k + 1 + v_dim1], 
			    ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
		}

/*              W := W * V1**T */

		igraphdtrmm_("Right", "Lower", "Transpose", "Unit", m, k, &c_b14, &
			v[v_offset], ldv, &work[work_offset], ldwork);

/*              C1 := C1 - W */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
/* L50: */
		    }
/* L60: */
		}
	    }

	} else {

/*           Let  V =  ( V1 )   
                       ( V2 )    (last K rows)   
             where  V2  is unit upper triangular. */

	    if (igraphlsame_(side, "L")) {

/*              Form  H * C  or  H**T * C  where  C = ( C1 )   
                                                      ( C2 )   

                W := C**T * V  =  (C1**T * V1 + C2**T * V2)  (stored in WORK)   

                W := C2**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(n, &c__[*m - *k + j + c_dim1], ldc, &work[j * 
			    work_dim1 + 1], &c__1);
/* L70: */
		}

/*              W := W * V2 */

		igraphdtrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b14,
			 &v[*m - *k + 1 + v_dim1], ldv, &work[work_offset], 
			ldwork);
		if (*m > *k) {

/*                 W := W + C1**T * V1 */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "No transpose", n, k, &i__1, &c_b14, &
			    c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
			    work[work_offset], ldwork);
		}

/*              W := W * T**T  or  W * T */

		igraphdtrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - V * W**T */

		if (*m > *k) {

/*                 C1 := C1 - V1 * W**T */

		    i__1 = *m - *k;
		    igraphdgemm_("No transpose", "Transpose", &i__1, n, k, &c_b25, &
			    v[v_offset], ldv, &work[work_offset], ldwork, &
			    c_b14, &c__[c_offset], ldc)
			    ;
		}

/*              W := W * V2**T */

		igraphdtrmm_("Right", "Upper", "Transpose", "Unit", n, k, &c_b14, &
			v[*m - *k + 1 + v_dim1], ldv, &work[work_offset], 
			ldwork);

/*              C2 := C2 - W**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[*m - *k + j + i__ * c_dim1] -= work[i__ + j * 
				work_dim1];
/* L80: */
		    }
/* L90: */
		}

	    } else if (igraphlsame_(side, "R")) {

/*              Form  C * H  or  C * H**T  where  C = ( C1  C2 )   

                W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK)   

                W := C2 */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(m, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[
			    j * work_dim1 + 1], &c__1);
/* L100: */
		}

/*              W := W * V2 */

		igraphdtrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b14,
			 &v[*n - *k + 1 + v_dim1], ldv, &work[work_offset], 
			ldwork);
		if (*n > *k) {

/*                 W := W + C1 * V1 */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "No transpose", m, k, &i__1, &
			    c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &
			    c_b14, &work[work_offset], ldwork);
		}

/*              W := W * T  or  W * T**T */

		igraphdtrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - W * V**T */

		if (*n > *k) {

/*                 C1 := C1 - W * V1**T */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "Transpose", m, &i__1, k, &c_b25, &
			    work[work_offset], ldwork, &v[v_offset], ldv, &
			    c_b14, &c__[c_offset], ldc)
			    ;
		}

/*              W := W * V2**T */

		igraphdtrmm_("Right", "Upper", "Transpose", "Unit", m, k, &c_b14, &
			v[*n - *k + 1 + v_dim1], ldv, &work[work_offset], 
			ldwork);

/*              C2 := C2 - W */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + (*n - *k + j) * c_dim1] -= work[i__ + j * 
				work_dim1];
/* L110: */
		    }
/* L120: */
		}
	    }
	}

    } else if (igraphlsame_(storev, "R")) {

	if (igraphlsame_(direct, "F")) {

/*           Let  V =  ( V1  V2 )    (V1: first K columns)   
             where  V1  is unit upper triangular. */

	    if (igraphlsame_(side, "L")) {

/*              Form  H * C  or  H**T * C  where  C = ( C1 )   
                                                      ( C2 )   

                W := C**T * V**T  =  (C1**T * V1**T + C2**T * V2**T) (stored in WORK)   

                W := C1**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(n, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1],
			     &c__1);
/* L130: */
		}

/*              W := W * V1**T */

		igraphdtrmm_("Right", "Upper", "Transpose", "Unit", n, k, &c_b14, &
			v[v_offset], ldv, &work[work_offset], ldwork);
		if (*m > *k) {

/*                 W := W + C2**T * V2**T */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "Transpose", n, k, &i__1, &c_b14, &
			    c__[*k + 1 + c_dim1], ldc, &v[(*k + 1) * v_dim1 + 
			    1], ldv, &c_b14, &work[work_offset], ldwork);
		}

/*              W := W * T**T  or  W * T */

		igraphdtrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - V**T * W**T */

		if (*m > *k) {

/*                 C2 := C2 - V2**T * W**T */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "Transpose", &i__1, n, k, &c_b25, &v[(
			    *k + 1) * v_dim1 + 1], ldv, &work[work_offset], 
			    ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
		}

/*              W := W * V1 */

		igraphdtrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b14,
			 &v[v_offset], ldv, &work[work_offset], ldwork);

/*              C1 := C1 - W**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
/* L140: */
		    }
/* L150: */
		}

	    } else if (igraphlsame_(side, "R")) {

/*              Form  C * H  or  C * H**T  where  C = ( C1  C2 )   

                W := C * V**T  =  (C1*V1**T + C2*V2**T)  (stored in WORK)   

                W := C1 */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(m, &c__[j * c_dim1 + 1], &c__1, &work[j * 
			    work_dim1 + 1], &c__1);
/* L160: */
		}

/*              W := W * V1**T */

		igraphdtrmm_("Right", "Upper", "Transpose", "Unit", m, k, &c_b14, &
			v[v_offset], ldv, &work[work_offset], ldwork);
		if (*n > *k) {

/*                 W := W + C2 * V2**T */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "Transpose", m, k, &i__1, &c_b14, &
			    c__[(*k + 1) * c_dim1 + 1], ldc, &v[(*k + 1) * 
			    v_dim1 + 1], ldv, &c_b14, &work[work_offset], 
			    ldwork);
		}

/*              W := W * T  or  W * T**T */

		igraphdtrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - W * V */

		if (*n > *k) {

/*                 C2 := C2 - W * V2 */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "No transpose", m, &i__1, k, &
			    c_b25, &work[work_offset], ldwork, &v[(*k + 1) * 
			    v_dim1 + 1], ldv, &c_b14, &c__[(*k + 1) * c_dim1 
			    + 1], ldc);
		}

/*              W := W * V1 */

		igraphdtrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b14,
			 &v[v_offset], ldv, &work[work_offset], ldwork);

/*              C1 := C1 - W */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
/* L170: */
		    }
/* L180: */
		}

	    }

	} else {

/*           Let  V =  ( V1  V2 )    (V2: last K columns)   
             where  V2  is unit lower triangular. */

	    if (igraphlsame_(side, "L")) {

/*              Form  H * C  or  H**T * C  where  C = ( C1 )   
                                                      ( C2 )   

                W := C**T * V**T  =  (C1**T * V1**T + C2**T * V2**T) (stored in WORK)   

                W := C2**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(n, &c__[*m - *k + j + c_dim1], ldc, &work[j * 
			    work_dim1 + 1], &c__1);
/* L190: */
		}

/*              W := W * V2**T */

		igraphdtrmm_("Right", "Lower", "Transpose", "Unit", n, k, &c_b14, &
			v[(*m - *k + 1) * v_dim1 + 1], ldv, &work[work_offset]
			, ldwork);
		if (*m > *k) {

/*                 W := W + C1**T * V1**T */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "Transpose", n, k, &i__1, &c_b14, &
			    c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
			    work[work_offset], ldwork);
		}

/*              W := W * T**T  or  W * T */

		igraphdtrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - V**T * W**T */

		if (*m > *k) {

/*                 C1 := C1 - V1**T * W**T */

		    i__1 = *m - *k;
		    igraphdgemm_("Transpose", "Transpose", &i__1, n, k, &c_b25, &v[
			    v_offset], ldv, &work[work_offset], ldwork, &
			    c_b14, &c__[c_offset], ldc);
		}

/*              W := W * V2 */

		igraphdtrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b14,
			 &v[(*m - *k + 1) * v_dim1 + 1], ldv, &work[
			work_offset], ldwork);

/*              C2 := C2 - W**T */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[*m - *k + j + i__ * c_dim1] -= work[i__ + j * 
				work_dim1];
/* L200: */
		    }
/* L210: */
		}

	    } else if (igraphlsame_(side, "R")) {

/*              Form  C * H  or  C * H'  where  C = ( C1  C2 )   

                W := C * V**T  =  (C1*V1**T + C2*V2**T)  (stored in WORK)   

                W := C2 */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    igraphdcopy_(m, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[
			    j * work_dim1 + 1], &c__1);
/* L220: */
		}

/*              W := W * V2**T */

		igraphdtrmm_("Right", "Lower", "Transpose", "Unit", m, k, &c_b14, &
			v[(*n - *k + 1) * v_dim1 + 1], ldv, &work[work_offset]
			, ldwork);
		if (*n > *k) {

/*                 W := W + C1 * V1**T */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "Transpose", m, k, &i__1, &c_b14, &
			    c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
			    work[work_offset], ldwork);
		}

/*              W := W * T  or  W * T**T */

		igraphdtrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b14, &t[
			t_offset], ldt, &work[work_offset], ldwork);

/*              C := C - W * V */

		if (*n > *k) {

/*                 C1 := C1 - W * V1 */

		    i__1 = *n - *k;
		    igraphdgemm_("No transpose", "No transpose", m, &i__1, k, &
			    c_b25, &work[work_offset], ldwork, &v[v_offset], 
			    ldv, &c_b14, &c__[c_offset], ldc);
		}

/*              W := W * V2 */

		igraphdtrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b14,
			 &v[(*n - *k + 1) * v_dim1 + 1], ldv, &work[
			work_offset], ldwork);

/*              C1 := C1 - W */

		i__1 = *k;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + (*n - *k + j) * c_dim1] -= work[i__ + j * 
				work_dim1];
/* L230: */
		    }
/* L240: */
		}

	    }

	}
    }

    return 0;

/*     End of DLARFB */

} /* igraphdlarfb_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarfg.c0000644000175100001710000001314700000000000024013 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARFG generates an elementary reflector (Householder matrix).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARFG + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARFG( N, ALPHA, X, INCX, TAU )   

         INTEGER            INCX, N   
         DOUBLE PRECISION   ALPHA, TAU   
         DOUBLE PRECISION   X( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARFG generates a real elementary reflector H of order n, such   
   > that   
   >   
   >       H * ( alpha ) = ( beta ),   H**T * H = I.   
   >           (   x   )   (   0  )   
   >   
   > where alpha and beta are scalars, and x is an (n-1)-element real   
   > vector. H is represented in the form   
   >   
   >       H = I - tau * ( 1 ) * ( 1 v**T ) ,   
   >                     ( v )   
   >   
   > where tau is a real scalar and v is a real (n-1)-element   
   > vector.   
   >   
   > If the elements of x are all zero, then tau = 0 and H is taken to be   
   > the unit matrix.   
   >   
   > Otherwise  1 <= tau <= 2.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the elementary reflector.   
   > \endverbatim   
   >   
   > \param[in,out] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION   
   >          On entry, the value alpha.   
   >          On exit, it is overwritten with the value beta.   
   > \endverbatim   
   >   
   > \param[in,out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension   
   >                         (1+(N-2)*abs(INCX))   
   >          On entry, the vector x.   
   >          On exit, it is overwritten with the vector v.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >          The increment between elements of X. INCX > 0.   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >          The value tau.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlarfg_(integer *n, doublereal *alpha, doublereal *x, 
	integer *incx, doublereal *tau)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1;

    /* Builtin functions */
    double d_sign(doublereal *, doublereal *);

    /* Local variables */
    integer j, knt;
    doublereal beta;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    doublereal xnorm;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
    doublereal safmin, rsafmn;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --x;

    /* Function Body */
    if (*n <= 1) {
	*tau = 0.;
	return 0;
    }

    i__1 = *n - 1;
    xnorm = igraphdnrm2_(&i__1, &x[1], incx);

    if (xnorm == 0.) {

/*        H  =  I */

	*tau = 0.;
    } else {

/*        general case */

	d__1 = igraphdlapy2_(alpha, &xnorm);
	beta = -d_sign(&d__1, alpha);
	safmin = igraphdlamch_("S") / igraphdlamch_("E");
	knt = 0;
	if (abs(beta) < safmin) {

/*           XNORM, BETA may be inaccurate; scale X and recompute them */

	    rsafmn = 1. / safmin;
L10:
	    ++knt;
	    i__1 = *n - 1;
	    igraphdscal_(&i__1, &rsafmn, &x[1], incx);
	    beta *= rsafmn;
	    *alpha *= rsafmn;
	    if (abs(beta) < safmin) {
		goto L10;
	    }

/*           New BETA is at most 1, at least SAFMIN */

	    i__1 = *n - 1;
	    xnorm = igraphdnrm2_(&i__1, &x[1], incx);
	    d__1 = igraphdlapy2_(alpha, &xnorm);
	    beta = -d_sign(&d__1, alpha);
	}
	*tau = (beta - *alpha) / beta;
	i__1 = *n - 1;
	d__1 = 1. / (*alpha - beta);
	igraphdscal_(&i__1, &d__1, &x[1], incx);

/*        If ALPHA is subnormal, it may lose relative accuracy */

	i__1 = knt;
	for (j = 1; j <= i__1; ++j) {
	    beta *= safmin;
/* L20: */
	}
	*alpha = beta;
    }

    return 0;

/*     End of DLARFG */

} /* igraphdlarfg_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarft.c0000644000175100001710000002676100000000000024036 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b7 = 1.;

/* > \brief \b DLARFT forms the triangular factor T of a block reflector H = I - vtvH   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARFT + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARFT( DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT )   

         CHARACTER          DIRECT, STOREV   
         INTEGER            K, LDT, LDV, N   
         DOUBLE PRECISION   T( LDT, * ), TAU( * ), V( LDV, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARFT forms the triangular factor T of a real block reflector H   
   > of order n, which is defined as a product of k elementary reflectors.   
   >   
   > If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;   
   >   
   > If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.   
   >   
   > If STOREV = 'C', the vector which defines the elementary reflector   
   > H(i) is stored in the i-th column of the array V, and   
   >   
   >    H  =  I - V * T * V**T   
   >   
   > If STOREV = 'R', the vector which defines the elementary reflector   
   > H(i) is stored in the i-th row of the array V, and   
   >   
   >    H  =  I - V**T * T * V   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] DIRECT   
   > \verbatim   
   >          DIRECT is CHARACTER*1   
   >          Specifies the order in which the elementary reflectors are   
   >          multiplied to form the block reflector:   
   >          = 'F': H = H(1) H(2) . . . H(k) (Forward)   
   >          = 'B': H = H(k) . . . H(2) H(1) (Backward)   
   > \endverbatim   
   >   
   > \param[in] STOREV   
   > \verbatim   
   >          STOREV is CHARACTER*1   
   >          Specifies how the vectors which define the elementary   
   >          reflectors are stored (see also Further Details):   
   >          = 'C': columnwise   
   >          = 'R': rowwise   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the block reflector H. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The order of the triangular factor T (= the number of   
   >          elementary reflectors). K >= 1.   
   > \endverbatim   
   >   
   > \param[in] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension   
   >                               (LDV,K) if STOREV = 'C'   
   >                               (LDV,N) if STOREV = 'R'   
   >          The matrix V. See further details.   
   > \endverbatim   
   >   
   > \param[in] LDV   
   > \verbatim   
   >          LDV is INTEGER   
   >          The leading dimension of the array V.   
   >          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i).   
   > \endverbatim   
   >   
   > \param[out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,K)   
   >          The k by k triangular factor T of the block reflector.   
   >          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is   
   >          lower triangular. The rest of the array is not used.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= K.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The shape of the matrix V and the storage of the vectors which define   
   >  the H(i) is best illustrated by the following example with n = 5 and   
   >  k = 3. The elements equal to 1 are not stored.   
   >   
   >  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R':   
   >   
   >               V = (  1       )                 V = (  1 v1 v1 v1 v1 )   
   >                   ( v1  1    )                     (     1 v2 v2 v2 )   
   >                   ( v1 v2  1 )                     (        1 v3 v3 )   
   >                   ( v1 v2 v3 )   
   >                   ( v1 v2 v3 )   
   >   
   >  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R':   
   >   
   >               V = ( v1 v2 v3 )                 V = ( v1 v1  1       )   
   >                   ( v1 v2 v3 )                     ( v2 v2 v2  1    )   
   >                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 )   
   >                   (     1 v3 )   
   >                   (        1 )   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlarft_(char *direct, char *storev, integer *n, integer *
	k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, 
	integer *ldt)
{
    /* System generated locals */
    integer t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3;
    doublereal d__1;

    /* Local variables */
    integer i__, j, prevlastv;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    integer lastv;
    extern /* Subroutine */ int igraphdtrmv_(char *, char *, char *, integer *, 
	    doublereal *, integer *, doublereal *, integer *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Quick return if possible   

       Parameter adjustments */
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --tau;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;

    /* Function Body */
    if (*n == 0) {
	return 0;
    }

    if (igraphlsame_(direct, "F")) {
	prevlastv = *n;
	i__1 = *k;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    prevlastv = max(i__,prevlastv);
	    if (tau[i__] == 0.) {

/*              H(i)  =  I */

		i__2 = i__;
		for (j = 1; j <= i__2; ++j) {
		    t[j + i__ * t_dim1] = 0.;
		}
	    } else {

/*              general case */

		if (igraphlsame_(storev, "C")) {
/*                 Skip any trailing zeros. */
		    i__2 = i__ + 1;
		    for (lastv = *n; lastv >= i__2; --lastv) {
			if (v[lastv + i__ * v_dim1] != 0.) {
			    goto L11;
			}
		    }
L11:
		    i__2 = i__ - 1;
		    for (j = 1; j <= i__2; ++j) {
			t[j + i__ * t_dim1] = -tau[i__] * v[i__ + j * v_dim1];
		    }
		    j = min(lastv,prevlastv);

/*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**T * V(i:j,i) */

		    i__2 = j - i__;
		    i__3 = i__ - 1;
		    d__1 = -tau[i__];
		    igraphdgemv_("Transpose", &i__2, &i__3, &d__1, &v[i__ + 1 + 
			    v_dim1], ldv, &v[i__ + 1 + i__ * v_dim1], &c__1, &
			    c_b7, &t[i__ * t_dim1 + 1], &c__1);
		} else {
/*                 Skip any trailing zeros. */
		    i__2 = i__ + 1;
		    for (lastv = *n; lastv >= i__2; --lastv) {
			if (v[i__ + lastv * v_dim1] != 0.) {
			    goto L21;
			}
		    }
L21:
		    i__2 = i__ - 1;
		    for (j = 1; j <= i__2; ++j) {
			t[j + i__ * t_dim1] = -tau[i__] * v[j + i__ * v_dim1];
		    }
		    j = min(lastv,prevlastv);

/*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**T */

		    i__2 = i__ - 1;
		    i__3 = j - i__;
		    d__1 = -tau[i__];
		    igraphdgemv_("No transpose", &i__2, &i__3, &d__1, &v[(i__ + 1) *
			     v_dim1 + 1], ldv, &v[i__ + (i__ + 1) * v_dim1], 
			    ldv, &c_b7, &t[i__ * t_dim1 + 1], &c__1);
		}

/*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i) */

		i__2 = i__ - 1;
		igraphdtrmv_("Upper", "No transpose", "Non-unit", &i__2, &t[
			t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
		t[i__ + i__ * t_dim1] = tau[i__];
		if (i__ > 1) {
		    prevlastv = max(prevlastv,lastv);
		} else {
		    prevlastv = lastv;
		}
	    }
	}
    } else {
	prevlastv = 1;
	for (i__ = *k; i__ >= 1; --i__) {
	    if (tau[i__] == 0.) {

/*              H(i)  =  I */

		i__1 = *k;
		for (j = i__; j <= i__1; ++j) {
		    t[j + i__ * t_dim1] = 0.;
		}
	    } else {

/*              general case */

		if (i__ < *k) {
		    if (igraphlsame_(storev, "C")) {
/*                    Skip any leading zeros. */
			i__1 = i__ - 1;
			for (lastv = 1; lastv <= i__1; ++lastv) {
			    if (v[lastv + i__ * v_dim1] != 0.) {
				goto L31;
			    }
			}
L31:
			i__1 = *k;
			for (j = i__ + 1; j <= i__1; ++j) {
			    t[j + i__ * t_dim1] = -tau[i__] * v[*n - *k + i__ 
				    + j * v_dim1];
			}
			j = max(lastv,prevlastv);

/*                    T(i+1:k,i) = -tau(i) * V(j:n-k+i,i+1:k)**T * V(j:n-k+i,i) */

			i__1 = *n - *k + i__ - j;
			i__2 = *k - i__;
			d__1 = -tau[i__];
			igraphdgemv_("Transpose", &i__1, &i__2, &d__1, &v[j + (i__ 
				+ 1) * v_dim1], ldv, &v[j + i__ * v_dim1], &
				c__1, &c_b7, &t[i__ + 1 + i__ * t_dim1], &
				c__1);
		    } else {
/*                    Skip any leading zeros. */
			i__1 = i__ - 1;
			for (lastv = 1; lastv <= i__1; ++lastv) {
			    if (v[i__ + lastv * v_dim1] != 0.) {
				goto L41;
			    }
			}
L41:
			i__1 = *k;
			for (j = i__ + 1; j <= i__1; ++j) {
			    t[j + i__ * t_dim1] = -tau[i__] * v[j + (*n - *k 
				    + i__) * v_dim1];
			}
			j = max(lastv,prevlastv);

/*                    T(i+1:k,i) = -tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**T */

			i__1 = *k - i__;
			i__2 = *n - *k + i__ - j;
			d__1 = -tau[i__];
			igraphdgemv_("No transpose", &i__1, &i__2, &d__1, &v[i__ + 
				1 + j * v_dim1], ldv, &v[i__ + j * v_dim1], 
				ldv, &c_b7, &t[i__ + 1 + i__ * t_dim1], &c__1);
		    }

/*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i) */

		    i__1 = *k - i__;
		    igraphdtrmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__ 
			    + 1 + (i__ + 1) * t_dim1], ldt, &t[i__ + 1 + i__ *
			     t_dim1], &c__1)
			    ;
		    if (i__ > 1) {
			prevlastv = min(prevlastv,lastv);
		    } else {
			prevlastv = lastv;
		    }
		}
		t[i__ + i__ * t_dim1] = tau[i__];
	    }
	}
    }
    return 0;

/*     End of DLARFT */

} /* igraphdlarft_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarfx.c0000644000175100001710000004620000000000000024030 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLARFX applies an elementary reflector to a general rectangular matrix, with loop unrolling whe
n the reflector has order ≤ 10.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARFX + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARFX( SIDE, M, N, V, TAU, C, LDC, WORK )   

         CHARACTER          SIDE   
         INTEGER            LDC, M, N   
         DOUBLE PRECISION   TAU   
         DOUBLE PRECISION   C( LDC, * ), V( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARFX applies a real elementary reflector H to a real m by n   
   > matrix C, from either the left or the right. H is represented in the   
   > form   
   >   
   >       H = I - tau * v * v**T   
   >   
   > where tau is a real scalar and v is a real vector.   
   >   
   > If tau = 0, then H is taken to be the unit matrix   
   >   
   > This version uses inline code if H has order < 11.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': form  H * C   
   >          = 'R': form  C * H   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C.   
   > \endverbatim   
   >   
   > \param[in] V   
   > \verbatim   
   >          V is DOUBLE PRECISION array, dimension (M) if SIDE = 'L'   
   >                                     or (N) if SIDE = 'R'   
   >          The vector v in the representation of H.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >          The value tau in the representation of H.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the m by n matrix C.   
   >          On exit, C is overwritten by the matrix H * C if SIDE = 'L',   
   >          or C * H if SIDE = 'R'.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDA >= (1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension   
   >                      (N) if SIDE = 'L'   
   >                      or (M) if SIDE = 'R'   
   >          WORK is not referenced if H has order < 11.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlarfx_(char *side, integer *m, integer *n, doublereal *
	v, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work)
{
    /* System generated locals */
    integer c_dim1, c_offset, i__1;

    /* Local variables */
    integer j;
    doublereal t1, t2, t3, t4, t5, t6, t7, t8, t9, v1, v2, v3, v4, v5, v6, v7,
	     v8, v9, t10, v10, sum;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *);
    extern logical igraphlsame_(char *, char *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --v;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    if (*tau == 0.) {
	return 0;
    }
    if (igraphlsame_(side, "L")) {

/*        Form  H * C, where H has order m. */

	switch (*m) {
	    case 1:  goto L10;
	    case 2:  goto L30;
	    case 3:  goto L50;
	    case 4:  goto L70;
	    case 5:  goto L90;
	    case 6:  goto L110;
	    case 7:  goto L130;
	    case 8:  goto L150;
	    case 9:  goto L170;
	    case 10:  goto L190;
	}

/*        Code for general M */

	igraphdlarf_(side, m, n, &v[1], &c__1, tau, &c__[c_offset], ldc, &work[1]);
	goto L410;
L10:

/*        Special code for 1 x 1 Householder */

	t1 = 1. - *tau * v[1] * v[1];
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    c__[j * c_dim1 + 1] = t1 * c__[j * c_dim1 + 1];
/* L20: */
	}
	goto L410;
L30:

/*        Special code for 2 x 2 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
/* L40: */
	}
	goto L410;
L50:

/*        Special code for 3 x 3 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
/* L60: */
	}
	goto L410;
L70:

/*        Special code for 4 x 4 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
/* L80: */
	}
	goto L410;
L90:

/*        Special code for 5 x 5 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
/* L100: */
	}
	goto L410;
L110:

/*        Special code for 6 x 6 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5] + v6 * c__[j * c_dim1 + 6];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
	    c__[j * c_dim1 + 6] -= sum * t6;
/* L120: */
	}
	goto L410;
L130:

/*        Special code for 7 x 7 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5] + v6 * c__[j * c_dim1 + 6] + v7 * c__[j * 
		    c_dim1 + 7];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
	    c__[j * c_dim1 + 6] -= sum * t6;
	    c__[j * c_dim1 + 7] -= sum * t7;
/* L140: */
	}
	goto L410;
L150:

/*        Special code for 8 x 8 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5] + v6 * c__[j * c_dim1 + 6] + v7 * c__[j * 
		    c_dim1 + 7] + v8 * c__[j * c_dim1 + 8];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
	    c__[j * c_dim1 + 6] -= sum * t6;
	    c__[j * c_dim1 + 7] -= sum * t7;
	    c__[j * c_dim1 + 8] -= sum * t8;
/* L160: */
	}
	goto L410;
L170:

/*        Special code for 9 x 9 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	v9 = v[9];
	t9 = *tau * v9;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5] + v6 * c__[j * c_dim1 + 6] + v7 * c__[j * 
		    c_dim1 + 7] + v8 * c__[j * c_dim1 + 8] + v9 * c__[j * 
		    c_dim1 + 9];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
	    c__[j * c_dim1 + 6] -= sum * t6;
	    c__[j * c_dim1 + 7] -= sum * t7;
	    c__[j * c_dim1 + 8] -= sum * t8;
	    c__[j * c_dim1 + 9] -= sum * t9;
/* L180: */
	}
	goto L410;
L190:

/*        Special code for 10 x 10 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	v9 = v[9];
	t9 = *tau * v9;
	v10 = v[10];
	t10 = *tau * v10;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j * c_dim1 + 1] + v2 * c__[j * c_dim1 + 2] + v3 * 
		    c__[j * c_dim1 + 3] + v4 * c__[j * c_dim1 + 4] + v5 * c__[
		    j * c_dim1 + 5] + v6 * c__[j * c_dim1 + 6] + v7 * c__[j * 
		    c_dim1 + 7] + v8 * c__[j * c_dim1 + 8] + v9 * c__[j * 
		    c_dim1 + 9] + v10 * c__[j * c_dim1 + 10];
	    c__[j * c_dim1 + 1] -= sum * t1;
	    c__[j * c_dim1 + 2] -= sum * t2;
	    c__[j * c_dim1 + 3] -= sum * t3;
	    c__[j * c_dim1 + 4] -= sum * t4;
	    c__[j * c_dim1 + 5] -= sum * t5;
	    c__[j * c_dim1 + 6] -= sum * t6;
	    c__[j * c_dim1 + 7] -= sum * t7;
	    c__[j * c_dim1 + 8] -= sum * t8;
	    c__[j * c_dim1 + 9] -= sum * t9;
	    c__[j * c_dim1 + 10] -= sum * t10;
/* L200: */
	}
	goto L410;
    } else {

/*        Form  C * H, where H has order n. */

	switch (*n) {
	    case 1:  goto L210;
	    case 2:  goto L230;
	    case 3:  goto L250;
	    case 4:  goto L270;
	    case 5:  goto L290;
	    case 6:  goto L310;
	    case 7:  goto L330;
	    case 8:  goto L350;
	    case 9:  goto L370;
	    case 10:  goto L390;
	}

/*        Code for general N */

	igraphdlarf_(side, m, n, &v[1], &c__1, tau, &c__[c_offset], ldc, &work[1]);
	goto L410;
L210:

/*        Special code for 1 x 1 Householder */

	t1 = 1. - *tau * v[1] * v[1];
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    c__[j + c_dim1] = t1 * c__[j + c_dim1];
/* L220: */
	}
	goto L410;
L230:

/*        Special code for 2 x 2 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
/* L240: */
	}
	goto L410;
L250:

/*        Special code for 3 x 3 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
/* L260: */
	}
	goto L410;
L270:

/*        Special code for 4 x 4 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
/* L280: */
	}
	goto L410;
L290:

/*        Special code for 5 x 5 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
/* L300: */
	}
	goto L410;
L310:

/*        Special code for 6 x 6 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5] + v6 * c__[j + c_dim1 * 6];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
	    c__[j + c_dim1 * 6] -= sum * t6;
/* L320: */
	}
	goto L410;
L330:

/*        Special code for 7 x 7 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5] + v6 * c__[j + c_dim1 * 6] + v7 * c__[
		    j + c_dim1 * 7];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
	    c__[j + c_dim1 * 6] -= sum * t6;
	    c__[j + c_dim1 * 7] -= sum * t7;
/* L340: */
	}
	goto L410;
L350:

/*        Special code for 8 x 8 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5] + v6 * c__[j + c_dim1 * 6] + v7 * c__[
		    j + c_dim1 * 7] + v8 * c__[j + (c_dim1 << 3)];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
	    c__[j + c_dim1 * 6] -= sum * t6;
	    c__[j + c_dim1 * 7] -= sum * t7;
	    c__[j + (c_dim1 << 3)] -= sum * t8;
/* L360: */
	}
	goto L410;
L370:

/*        Special code for 9 x 9 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	v9 = v[9];
	t9 = *tau * v9;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5] + v6 * c__[j + c_dim1 * 6] + v7 * c__[
		    j + c_dim1 * 7] + v8 * c__[j + (c_dim1 << 3)] + v9 * c__[
		    j + c_dim1 * 9];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
	    c__[j + c_dim1 * 6] -= sum * t6;
	    c__[j + c_dim1 * 7] -= sum * t7;
	    c__[j + (c_dim1 << 3)] -= sum * t8;
	    c__[j + c_dim1 * 9] -= sum * t9;
/* L380: */
	}
	goto L410;
L390:

/*        Special code for 10 x 10 Householder */

	v1 = v[1];
	t1 = *tau * v1;
	v2 = v[2];
	t2 = *tau * v2;
	v3 = v[3];
	t3 = *tau * v3;
	v4 = v[4];
	t4 = *tau * v4;
	v5 = v[5];
	t5 = *tau * v5;
	v6 = v[6];
	t6 = *tau * v6;
	v7 = v[7];
	t7 = *tau * v7;
	v8 = v[8];
	t8 = *tau * v8;
	v9 = v[9];
	t9 = *tau * v9;
	v10 = v[10];
	t10 = *tau * v10;
	i__1 = *m;
	for (j = 1; j <= i__1; ++j) {
	    sum = v1 * c__[j + c_dim1] + v2 * c__[j + (c_dim1 << 1)] + v3 * 
		    c__[j + c_dim1 * 3] + v4 * c__[j + (c_dim1 << 2)] + v5 * 
		    c__[j + c_dim1 * 5] + v6 * c__[j + c_dim1 * 6] + v7 * c__[
		    j + c_dim1 * 7] + v8 * c__[j + (c_dim1 << 3)] + v9 * c__[
		    j + c_dim1 * 9] + v10 * c__[j + c_dim1 * 10];
	    c__[j + c_dim1] -= sum * t1;
	    c__[j + (c_dim1 << 1)] -= sum * t2;
	    c__[j + c_dim1 * 3] -= sum * t3;
	    c__[j + (c_dim1 << 2)] -= sum * t4;
	    c__[j + c_dim1 * 5] -= sum * t5;
	    c__[j + c_dim1 * 6] -= sum * t6;
	    c__[j + c_dim1 * 7] -= sum * t7;
	    c__[j + (c_dim1 << 3)] -= sum * t8;
	    c__[j + c_dim1 * 9] -= sum * t9;
	    c__[j + c_dim1 * 10] -= sum * t10;
/* L400: */
	}
	goto L410;
    }
L410:
    return 0;

/*     End of DLARFX */

} /* igraphdlarfx_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarnv.c0000644000175100001710000001227200000000000024040 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARNV returns a vector of random numbers from a uniform or normal distribution.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARNV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARNV( IDIST, ISEED, N, X )   

         INTEGER            IDIST, N   
         INTEGER            ISEED( 4 )   
         DOUBLE PRECISION   X( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARNV returns a vector of n random real numbers from a uniform or   
   > normal distribution.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] IDIST   
   > \verbatim   
   >          IDIST is INTEGER   
   >          Specifies the distribution of the random numbers:   
   >          = 1:  uniform (0,1)   
   >          = 2:  uniform (-1,1)   
   >          = 3:  normal (0,1)   
   > \endverbatim   
   >   
   > \param[in,out] ISEED   
   > \verbatim   
   >          ISEED is INTEGER array, dimension (4)   
   >          On entry, the seed of the random number generator; the array   
   >          elements must be between 0 and 4095, and ISEED(4) must be   
   >          odd.   
   >          On exit, the seed is updated.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of random numbers to be generated.   
   > \endverbatim   
   >   
   > \param[out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (N)   
   >          The generated random numbers.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  This routine calls the auxiliary routine DLARUV to generate random   
   >  real numbers from a uniform (0,1) distribution, in batches of up to   
   >  128 using vectorisable code. The Box-Muller method is used to   
   >  transform numbers from a uniform to a normal distribution.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlarnv_(integer *idist, integer *iseed, integer *n, 
	doublereal *x)
{
    /* System generated locals */
    integer i__1, i__2, i__3;

    /* Builtin functions */
    double log(doublereal), sqrt(doublereal), cos(doublereal);

    /* Local variables */
    integer i__;
    doublereal u[128];
    integer il, iv, il2;
    extern /* Subroutine */ int igraphdlaruv_(integer *, integer *, doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --x;
    --iseed;

    /* Function Body */
    i__1 = *n;
    for (iv = 1; iv <= i__1; iv += 64) {
/* Computing MIN */
	i__2 = 64, i__3 = *n - iv + 1;
	il = min(i__2,i__3);
	if (*idist == 3) {
	    il2 = il << 1;
	} else {
	    il2 = il;
	}

/*        Call DLARUV to generate IL2 numbers from a uniform (0,1)   
          distribution (IL2 <= LV) */

	igraphdlaruv_(&iseed[1], &il2, u);

	if (*idist == 1) {

/*           Copy generated numbers */

	    i__2 = il;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		x[iv + i__ - 1] = u[i__ - 1];
/* L10: */
	    }
	} else if (*idist == 2) {

/*           Convert generated numbers to uniform (-1,1) distribution */

	    i__2 = il;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		x[iv + i__ - 1] = u[i__ - 1] * 2. - 1.;
/* L20: */
	    }
	} else if (*idist == 3) {

/*           Convert generated numbers to normal (0,1) distribution */

	    i__2 = il;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		x[iv + i__ - 1] = sqrt(log(u[(i__ << 1) - 2]) * -2.) * cos(u[(
			i__ << 1) - 1] * 6.2831853071795864769252867663);
/* L30: */
	    }
	}
/* L40: */
    }
    return 0;

/*     End of DLARNV */

} /* igraphdlarnv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarra.c0000644000175100001710000001502700000000000024020 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRA computes the splitting points with the specified threshold.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRA + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRA( N, D, E, E2, SPLTOL, TNRM,   
                             NSPLIT, ISPLIT, INFO )   

         INTEGER            INFO, N, NSPLIT   
         DOUBLE PRECISION    SPLTOL, TNRM   
         INTEGER            ISPLIT( * )   
         DOUBLE PRECISION   D( * ), E( * ), E2( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Compute the splitting points with threshold SPLTOL.   
   > DLARRA sets any "small" off-diagonal elements to zero.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix. N > 0.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the N diagonal elements of the tridiagonal   
   >          matrix T.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the first (N-1) entries contain the subdiagonal   
   >          elements of the tridiagonal matrix T; E(N) need not be set.   
   >          On exit, the entries E( ISPLIT( I ) ), 1 <= I <= NSPLIT,   
   >          are set to zero, the other entries of E are untouched.   
   > \endverbatim   
   >   
   > \param[in,out] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the first (N-1) entries contain the SQUARES of the   
   >          subdiagonal elements of the tridiagonal matrix T;   
   >          E2(N) need not be set.   
   >          On exit, the entries E2( ISPLIT( I ) ),   
   >          1 <= I <= NSPLIT, have been set to zero   
   > \endverbatim   
   >   
   > \param[in] SPLTOL   
   > \verbatim   
   >          SPLTOL is DOUBLE PRECISION   
   >          The threshold for splitting. Two criteria can be used:   
   >          SPLTOL<0 : criterion based on absolute off-diagonal value   
   >          SPLTOL>0 : criterion that preserves relative accuracy   
   > \endverbatim   
   >   
   > \param[in] TNRM   
   > \verbatim   
   >          TNRM is DOUBLE PRECISION   
   >          The norm of the matrix.   
   > \endverbatim   
   >   
   > \param[out] NSPLIT   
   > \verbatim   
   >          NSPLIT is INTEGER   
   >          The number of blocks T splits into. 1 <= NSPLIT <= N.   
   > \endverbatim   
   >   
   > \param[out] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into blocks.   
   >          The first block consists of rows/columns 1 to ISPLIT(1),   
   >          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),   
   >          etc., and the NSPLIT-th consists of rows/columns   
   >          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarra_(integer *n, doublereal *d__, doublereal *e, 
	doublereal *e2, doublereal *spltol, doublereal *tnrm, integer *nsplit,
	 integer *isplit, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal tmp1, eabs;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --isplit;
    --e2;
    --e;
    --d__;

    /* Function Body */
    *info = 0;
/*     Compute splitting points */
    *nsplit = 1;
    if (*spltol < 0.) {
/*        Criterion based on absolute off-diagonal value */
	tmp1 = abs(*spltol) * *tnrm;
	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    eabs = (d__1 = e[i__], abs(d__1));
	    if (eabs <= tmp1) {
		e[i__] = 0.;
		e2[i__] = 0.;
		isplit[*nsplit] = i__;
		++(*nsplit);
	    }
/* L9: */
	}
    } else {
/*        Criterion that guarantees relative accuracy */
	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    eabs = (d__1 = e[i__], abs(d__1));
	    if (eabs <= *spltol * sqrt((d__1 = d__[i__], abs(d__1))) * sqrt((
		    d__2 = d__[i__ + 1], abs(d__2)))) {
		e[i__] = 0.;
		e2[i__] = 0.;
		isplit[*nsplit] = i__;
		++(*nsplit);
	    }
/* L10: */
	}
    }
    isplit[*nsplit] = *n;
    return 0;

/*     End of DLARRA */

} /* igraphdlarra_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrb.c0000644000175100001710000003217500000000000024024 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRB provides limited bisection to locate eigenvalues for more accuracy.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRB + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRB( N, D, LLD, IFIRST, ILAST, RTOL1,   
                            RTOL2, OFFSET, W, WGAP, WERR, WORK, IWORK,   
                            PIVMIN, SPDIAM, TWIST, INFO )   

         INTEGER            IFIRST, ILAST, INFO, N, OFFSET, TWIST   
         DOUBLE PRECISION   PIVMIN, RTOL1, RTOL2, SPDIAM   
         INTEGER            IWORK( * )   
         DOUBLE PRECISION   D( * ), LLD( * ), W( * ),   
        $                   WERR( * ), WGAP( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Given the relatively robust representation(RRR) L D L^T, DLARRB   
   > does "limited" bisection to refine the eigenvalues of L D L^T,   
   > W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial   
   > guesses for these eigenvalues are input in W, the corresponding estimate   
   > of the error in these guesses and their gaps are input in WERR   
   > and WGAP, respectively. During bisection, intervals   
   > [left, right] are maintained by storing their mid-points and   
   > semi-widths in the arrays W and WERR respectively.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] LLD   
   > \verbatim   
   >          LLD is DOUBLE PRECISION array, dimension (N-1)   
   >          The (N-1) elements L(i)*L(i)*D(i).   
   > \endverbatim   
   >   
   > \param[in] IFIRST   
   > \verbatim   
   >          IFIRST is INTEGER   
   >          The index of the first eigenvalue to be computed.   
   > \endverbatim   
   >   
   > \param[in] ILAST   
   > \verbatim   
   >          ILAST is INTEGER   
   >          The index of the last eigenvalue to be computed.   
   > \endverbatim   
   >   
   > \param[in] RTOL1   
   > \verbatim   
   >          RTOL1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] RTOL2   
   > \verbatim   
   >          RTOL2 is DOUBLE PRECISION   
   >          Tolerance for the convergence of the bisection intervals.   
   >          An interval [LEFT,RIGHT] has converged if   
   >          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )   
   >          where GAP is the (estimated) distance to the nearest   
   >          eigenvalue.   
   > \endverbatim   
   >   
   > \param[in] OFFSET   
   > \verbatim   
   >          OFFSET is INTEGER   
   >          Offset for the arrays W, WGAP and WERR, i.e., the IFIRST-OFFSET   
   >          through ILAST-OFFSET elements of these arrays are to be used.   
   > \endverbatim   
   >   
   > \param[in,out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are   
   >          estimates of the eigenvalues of L D L^T indexed IFIRST throug   
   >          ILAST.   
   >          On output, these estimates are refined.   
   > \endverbatim   
   >   
   > \param[in,out] WGAP   
   > \verbatim   
   >          WGAP is DOUBLE PRECISION array, dimension (N-1)   
   >          On input, the (estimated) gaps between consecutive   
   >          eigenvalues of L D L^T, i.e., WGAP(I-OFFSET) is the gap between   
   >          eigenvalues I and I+1. Note that if IFIRST.EQ.ILAST   
   >          then WGAP(IFIRST-OFFSET) must be set to ZERO.   
   >          On output, these gaps are refined.   
   > \endverbatim   
   >   
   > \param[in,out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension (N)   
   >          On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are   
   >          the errors in the estimates of the corresponding elements in W.   
   >          On output, these errors are refined.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (2*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (2*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot in the Sturm sequence.   
   > \endverbatim   
   >   
   > \param[in] SPDIAM   
   > \verbatim   
   >          SPDIAM is DOUBLE PRECISION   
   >          The spectral diameter of the matrix.   
   > \endverbatim   
   >   
   > \param[in] TWIST   
   > \verbatim   
   >          TWIST is INTEGER   
   >          The twist index for the twisted factorization that is used   
   >          for the negcount.   
   >          TWIST = N: Compute negcount from L D L^T - LAMBDA I = L+ D+ L+^T   
   >          TWIST = 1: Compute negcount from L D L^T - LAMBDA I = U- D- U-^T   
   >          TWIST = R: Compute negcount from L D L^T - LAMBDA I = N(r) D(r) N(r)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          Error flag.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrb_(integer *n, doublereal *d__, doublereal *lld, 
	integer *ifirst, integer *ilast, doublereal *rtol1, doublereal *rtol2,
	 integer *offset, doublereal *w, doublereal *wgap, doublereal *werr, 
	doublereal *work, integer *iwork, doublereal *pivmin, doublereal *
	spdiam, integer *twist, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double log(doublereal);

    /* Local variables */
    integer i__, k, r__, i1, ii, ip;
    doublereal gap, mid, tmp, back, lgap, rgap, left;
    integer iter, nint, prev, next;
    doublereal cvrgd, right, width;
    extern integer igraphdlaneg_(integer *, doublereal *, doublereal *, doublereal *
	    , doublereal *, integer *);
    integer negcnt;
    doublereal mnwdth;
    integer olnint, maxitr;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   



       Parameter adjustments */
    --iwork;
    --work;
    --werr;
    --wgap;
    --w;
    --lld;
    --d__;

    /* Function Body */
    *info = 0;

    maxitr = (integer) ((log(*spdiam + *pivmin) - log(*pivmin)) / log(2.)) + 
	    2;
    mnwdth = *pivmin * 2.;

    r__ = *twist;
    if (r__ < 1 || r__ > *n) {
	r__ = *n;
    }

/*     Initialize unconverged intervals in [ WORK(2*I-1), WORK(2*I) ].   
       The Sturm Count, Count( WORK(2*I-1) ) is arranged to be I-1, while   
       Count( WORK(2*I) ) is stored in IWORK( 2*I ). The integer IWORK( 2*I-1 )   
       for an unconverged interval is set to the index of the next unconverged   
       interval, and is -1 or 0 for a converged interval. Thus a linked   
       list of unconverged intervals is set up. */

    i1 = *ifirst;
/*     The number of unconverged intervals */
    nint = 0;
/*     The last unconverged interval found */
    prev = 0;
    rgap = wgap[i1 - *offset];
    i__1 = *ilast;
    for (i__ = i1; i__ <= i__1; ++i__) {
	k = i__ << 1;
	ii = i__ - *offset;
	left = w[ii] - werr[ii];
	right = w[ii] + werr[ii];
	lgap = rgap;
	rgap = wgap[ii];
	gap = min(lgap,rgap);
/*        Make sure that [LEFT,RIGHT] contains the desired eigenvalue   
          Compute negcount from dstqds facto L+D+L+^T = L D L^T - LEFT   

          Do while( NEGCNT(LEFT).GT.I-1 ) */

	back = werr[ii];
L20:
	negcnt = igraphdlaneg_(n, &d__[1], &lld[1], &left, pivmin, &r__);
	if (negcnt > i__ - 1) {
	    left -= back;
	    back *= 2.;
	    goto L20;
	}

/*        Do while( NEGCNT(RIGHT).LT.I )   
          Compute negcount from dstqds facto L+D+L+^T = L D L^T - RIGHT */

	back = werr[ii];
L50:
	negcnt = igraphdlaneg_(n, &d__[1], &lld[1], &right, pivmin, &r__);
	if (negcnt < i__) {
	    right += back;
	    back *= 2.;
	    goto L50;
	}
	width = (d__1 = left - right, abs(d__1)) * .5;
/* Computing MAX */
	d__1 = abs(left), d__2 = abs(right);
	tmp = max(d__1,d__2);
/* Computing MAX */
	d__1 = *rtol1 * gap, d__2 = *rtol2 * tmp;
	cvrgd = max(d__1,d__2);
	if (width <= cvrgd || width <= mnwdth) {
/*           This interval has already converged and does not need refinement.   
             (Note that the gaps might change through refining the   
              eigenvalues, however, they can only get bigger.)   
             Remove it from the list. */
	    iwork[k - 1] = -1;
/*           Make sure that I1 always points to the first unconverged interval */
	    if (i__ == i1 && i__ < *ilast) {
		i1 = i__ + 1;
	    }
	    if (prev >= i1 && i__ <= *ilast) {
		iwork[(prev << 1) - 1] = i__ + 1;
	    }
	} else {
/*           unconverged interval found */
	    prev = i__;
	    ++nint;
	    iwork[k - 1] = i__ + 1;
	    iwork[k] = negcnt;
	}
	work[k - 1] = left;
	work[k] = right;
/* L75: */
    }

/*     Do while( NINT.GT.0 ), i.e. there are still unconverged intervals   
       and while (ITER.LT.MAXITR) */

    iter = 0;
L80:
    prev = i1 - 1;
    i__ = i1;
    olnint = nint;
    i__1 = olnint;
    for (ip = 1; ip <= i__1; ++ip) {
	k = i__ << 1;
	ii = i__ - *offset;
	rgap = wgap[ii];
	lgap = rgap;
	if (ii > 1) {
	    lgap = wgap[ii - 1];
	}
	gap = min(lgap,rgap);
	next = iwork[k - 1];
	left = work[k - 1];
	right = work[k];
	mid = (left + right) * .5;
/*        semiwidth of interval */
	width = right - mid;
/* Computing MAX */
	d__1 = abs(left), d__2 = abs(right);
	tmp = max(d__1,d__2);
/* Computing MAX */
	d__1 = *rtol1 * gap, d__2 = *rtol2 * tmp;
	cvrgd = max(d__1,d__2);
	if (width <= cvrgd || width <= mnwdth || iter == maxitr) {
/*           reduce number of unconverged intervals */
	    --nint;
/*           Mark interval as converged. */
	    iwork[k - 1] = 0;
	    if (i1 == i__) {
		i1 = next;
	    } else {
/*              Prev holds the last unconverged interval previously examined */
		if (prev >= i1) {
		    iwork[(prev << 1) - 1] = next;
		}
	    }
	    i__ = next;
	    goto L100;
	}
	prev = i__;

/*        Perform one bisection step */

	negcnt = igraphdlaneg_(n, &d__[1], &lld[1], &mid, pivmin, &r__);
	if (negcnt <= i__ - 1) {
	    work[k - 1] = mid;
	} else {
	    work[k] = mid;
	}
	i__ = next;
L100:
	;
    }
    ++iter;
/*     do another loop if there are still unconverged intervals   
       However, in the last iteration, all intervals are accepted   
       since this is the best we can do. */
    if (nint > 0 && iter <= maxitr) {
	goto L80;
    }


/*     At this point, all the intervals have converged */
    i__1 = *ilast;
    for (i__ = *ifirst; i__ <= i__1; ++i__) {
	k = i__ << 1;
	ii = i__ - *offset;
/*        All intervals marked by '0' have been refined. */
	if (iwork[k - 1] == 0) {
	    w[ii] = (work[k - 1] + work[k]) * .5;
	    werr[ii] = work[k] - w[ii];
	}
/* L110: */
    }

    i__1 = *ilast;
    for (i__ = *ifirst + 1; i__ <= i__1; ++i__) {
	k = i__ << 1;
	ii = i__ - *offset;
/* Computing MAX */
	d__1 = 0., d__2 = w[ii] - werr[ii] - w[ii - 1] - werr[ii - 1];
	wgap[ii - 1] = max(d__1,d__2);
/* L111: */
    }
    return 0;

/*     End of DLARRB */

} /* igraphdlarrb_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrc.c0000644000175100001710000001526500000000000024026 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRC computes the number of eigenvalues of the symmetric tridiagonal matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRC + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRC( JOBT, N, VL, VU, D, E, PIVMIN,   
                                     EIGCNT, LCNT, RCNT, INFO )   

         CHARACTER          JOBT   
         INTEGER            EIGCNT, INFO, LCNT, N, RCNT   
         DOUBLE PRECISION   PIVMIN, VL, VU   
         DOUBLE PRECISION   D( * ), E( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Find the number of eigenvalues of the symmetric tridiagonal matrix T   
   > that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T   
   > if JOBT = 'L'.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOBT   
   > \verbatim   
   >          JOBT is CHARACTER*1   
   >          = 'T':  Compute Sturm count for matrix T.   
   >          = 'L':  Compute Sturm count for matrix L D L^T.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix. N > 0.   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >          The lower and upper bounds for the eigenvalues.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          JOBT = 'T': The N diagonal elements of the tridiagonal matrix T.   
   >          JOBT = 'L': The N diagonal elements of the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          JOBT = 'T': The N-1 offdiagonal elements of the matrix T.   
   >          JOBT = 'L': The N-1 offdiagonal elements of the matrix L.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot in the Sturm sequence for T.   
   > \endverbatim   
   >   
   > \param[out] EIGCNT   
   > \verbatim   
   >          EIGCNT is INTEGER   
   >          The number of eigenvalues of the symmetric tridiagonal matrix T   
   >          that are in the interval (VL,VU]   
   > \endverbatim   
   >   
   > \param[out] LCNT   
   > \verbatim   
   >          LCNT is INTEGER   
   > \endverbatim   
   >   
   > \param[out] RCNT   
   > \verbatim   
   >          RCNT is INTEGER   
   >          The left and right negcounts of the interval.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrc_(char *jobt, integer *n, doublereal *vl, 
	doublereal *vu, doublereal *d__, doublereal *e, doublereal *pivmin, 
	integer *eigcnt, integer *lcnt, integer *rcnt, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1;

    /* Local variables */
    integer i__;
    doublereal sl, su, tmp, tmp2;
    logical matt;
    extern logical igraphlsame_(char *, char *);
    doublereal lpivot, rpivot;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --e;
    --d__;

    /* Function Body */
    *info = 0;
    *lcnt = 0;
    *rcnt = 0;
    *eigcnt = 0;
    matt = igraphlsame_(jobt, "T");
    if (matt) {
/*        Sturm sequence count on T */
	lpivot = d__[1] - *vl;
	rpivot = d__[1] - *vu;
	if (lpivot <= 0.) {
	    ++(*lcnt);
	}
	if (rpivot <= 0.) {
	    ++(*rcnt);
	}
	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing 2nd power */
	    d__1 = e[i__];
	    tmp = d__1 * d__1;
	    lpivot = d__[i__ + 1] - *vl - tmp / lpivot;
	    rpivot = d__[i__ + 1] - *vu - tmp / rpivot;
	    if (lpivot <= 0.) {
		++(*lcnt);
	    }
	    if (rpivot <= 0.) {
		++(*rcnt);
	    }
/* L10: */
	}
    } else {
/*        Sturm sequence count on L D L^T */
	sl = -(*vl);
	su = -(*vu);
	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    lpivot = d__[i__] + sl;
	    rpivot = d__[i__] + su;
	    if (lpivot <= 0.) {
		++(*lcnt);
	    }
	    if (rpivot <= 0.) {
		++(*rcnt);
	    }
	    tmp = e[i__] * d__[i__] * e[i__];

	    tmp2 = tmp / lpivot;
	    if (tmp2 == 0.) {
		sl = tmp - *vl;
	    } else {
		sl = sl * tmp2 - *vl;
	    }

	    tmp2 = tmp / rpivot;
	    if (tmp2 == 0.) {
		su = tmp - *vu;
	    } else {
		su = su * tmp2 - *vu;
	    }
/* L20: */
	}
	lpivot = d__[*n] + sl;
	rpivot = d__[*n] + su;
	if (lpivot <= 0.) {
	    ++(*lcnt);
	}
	if (rpivot <= 0.) {
	    ++(*rcnt);
	}
    }
    *eigcnt = *rcnt - *lcnt;
    return 0;

/*     end of DLARRC */

} /* igraphdlarrc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrd.c0000644000175100001710000007233400000000000024027 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;
static integer c__0 = 0;

/* > \brief \b DLARRD computes the eigenvalues of a symmetric tridiagonal matrix to suitable accuracy.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRD + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRD( RANGE, ORDER, N, VL, VU, IL, IU, GERS,   
                             RELTOL, D, E, E2, PIVMIN, NSPLIT, ISPLIT,   
                             M, W, WERR, WL, WU, IBLOCK, INDEXW,   
                             WORK, IWORK, INFO )   

         CHARACTER          ORDER, RANGE   
         INTEGER            IL, INFO, IU, M, N, NSPLIT   
         DOUBLE PRECISION    PIVMIN, RELTOL, VL, VU, WL, WU   
         INTEGER            IBLOCK( * ), INDEXW( * ),   
        $                   ISPLIT( * ), IWORK( * )   
         DOUBLE PRECISION   D( * ), E( * ), E2( * ),   
        $                   GERS( * ), W( * ), WERR( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARRD computes the eigenvalues of a symmetric tridiagonal   
   > matrix T to suitable accuracy. This is an auxiliary code to be   
   > called from DSTEMR.   
   > The user may ask for all eigenvalues, all eigenvalues   
   > in the half-open interval (VL, VU], or the IL-th through IU-th   
   > eigenvalues.   
   >   
   > To avoid overflow, the matrix must be scaled so that its   
   > largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest
   
   > accuracy, it should not be much smaller than that.   
   >   
   > See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal   
   > Matrix", Report CS41, Computer Science Dept., Stanford   
   > University, July 21, 1966.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] RANGE   
   > \verbatim   
   >          RANGE is CHARACTER*1   
   >          = 'A': ("All")   all eigenvalues will be found.   
   >          = 'V': ("Value") all eigenvalues in the half-open interval   
   >                           (VL, VU] will be found.   
   >          = 'I': ("Index") the IL-th through IU-th eigenvalues (of the   
   >                           entire matrix) will be found.   
   > \endverbatim   
   >   
   > \param[in] ORDER   
   > \verbatim   
   >          ORDER is CHARACTER*1   
   >          = 'B': ("By Block") the eigenvalues will be grouped by   
   >                              split-off block (see IBLOCK, ISPLIT) and   
   >                              ordered from smallest to largest within   
   >                              the block.   
   >          = 'E': ("Entire matrix")   
   >                              the eigenvalues for the entire matrix   
   >                              will be ordered from smallest to   
   >                              largest.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the tridiagonal matrix T.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >          If RANGE='V', the lower and upper bounds of the interval to   
   >          be searched for eigenvalues.  Eigenvalues less than or equal   
   >          to VL, or greater than VU, will not be returned.  VL < VU.   
   >          Not referenced if RANGE = 'A' or 'I'.   
   > \endverbatim   
   >   
   > \param[in] IL   
   > \verbatim   
   >          IL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IU   
   > \verbatim   
   >          IU is INTEGER   
   >          If RANGE='I', the indices (in ascending order) of the   
   >          smallest and largest eigenvalues to be returned.   
   >          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.   
   >          Not referenced if RANGE = 'A' or 'V'.   
   > \endverbatim   
   >   
   > \param[in] GERS   
   > \verbatim   
   >          GERS is DOUBLE PRECISION array, dimension (2*N)   
   >          The N Gerschgorin intervals (the i-th Gerschgorin interval   
   >          is (GERS(2*i-1), GERS(2*i)).   
   > \endverbatim   
   >   
   > \param[in] RELTOL   
   > \verbatim   
   >          RELTOL is DOUBLE PRECISION   
   >          The minimum relative width of an interval.  When an interval   
   >          is narrower than RELTOL times the larger (in   
   >          magnitude) endpoint, then it is considered to be   
   >          sufficiently small, i.e., converged.  Note: this should   
   >          always be at least radix*machine epsilon.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The n diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) off-diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) squared off-diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot allowed in the Sturm sequence for T.   
   > \endverbatim   
   >   
   > \param[in] NSPLIT   
   > \verbatim   
   >          NSPLIT is INTEGER   
   >          The number of diagonal blocks in the matrix T.   
   >          1 <= NSPLIT <= N.   
   > \endverbatim   
   >   
   > \param[in] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into submatrices.   
   >          The first submatrix consists of rows/columns 1 to ISPLIT(1),   
   >          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),   
   >          etc., and the NSPLIT-th consists of rows/columns   
   >          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.   
   >          (Only the first NSPLIT elements will actually be used, but   
   >          since the user cannot know a priori what value NSPLIT will   
   >          have, N words must be reserved for ISPLIT.)   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The actual number of eigenvalues found. 0 <= M <= N.   
   >          (See also the description of INFO=2,3.)   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          On exit, the first M elements of W will contain the   
   >          eigenvalue approximations. DLARRD computes an interval   
   >          I_j = (a_j, b_j] that includes eigenvalue j. The eigenvalue   
   >          approximation is given as the interval midpoint   
   >          W(j)= ( a_j + b_j)/2. The corresponding error is bounded by   
   >          WERR(j) = abs( a_j - b_j)/2   
   > \endverbatim   
   >   
   > \param[out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension (N)   
   >          The error bound on the corresponding eigenvalue approximation   
   >          in W.   
   > \endverbatim   
   >   
   > \param[out] WL   
   > \verbatim   
   >          WL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] WU   
   > \verbatim   
   >          WU is DOUBLE PRECISION   
   >          The interval (WL, WU] contains all the wanted eigenvalues.   
   >          If RANGE='V', then WL=VL and WU=VU.   
   >          If RANGE='A', then WL and WU are the global Gerschgorin bounds   
   >                        on the spectrum.   
   >          If RANGE='I', then WL and WU are computed by DLAEBZ from the   
   >                        index range specified.   
   > \endverbatim   
   >   
   > \param[out] IBLOCK   
   > \verbatim   
   >          IBLOCK is INTEGER array, dimension (N)   
   >          At each row/column j where E(j) is zero or small, the   
   >          matrix T is considered to split into a block diagonal   
   >          matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which   
   >          block (from 1 to the number of blocks) the eigenvalue W(i)   
   >          belongs.  (DLARRD may use the remaining N-M elements as   
   >          workspace.)   
   > \endverbatim   
   >   
   > \param[out] INDEXW   
   > \verbatim   
   >          INDEXW is INTEGER array, dimension (N)   
   >          The indices of the eigenvalues within each block (submatrix);   
   >          for example, INDEXW(i)= j and IBLOCK(i)=k imply that the   
   >          i-th eigenvalue W(i) is the j-th eigenvalue in block k.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (4*N)   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (3*N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  some or all of the eigenvalues failed to converge or   
   >                were not computed:   
   >                =1 or 3: Bisection failed to converge for some   
   >                        eigenvalues; these eigenvalues are flagged by a   
   >                        negative block number.  The effect is that the   
   >                        eigenvalues may not be as accurate as the   
   >                        absolute and relative tolerances.  This is   
   >                        generally caused by unexpectedly inaccurate   
   >                        arithmetic.   
   >                =2 or 3: RANGE='I' only: Not all of the eigenvalues   
   >                        IL:IU were found.   
   >                        Effect: M < IU+1-IL   
   >                        Cause:  non-monotonic arithmetic, causing the   
   >                                Sturm sequence to be non-monotonic.   
   >                        Cure:   recalculate, using RANGE='A', and pick   
   >                                out eigenvalues IL:IU.  In some cases,   
   >                                increasing the PARAMETER "FUDGE" may   
   >                                make things work.   
   >                = 4:    RANGE='I', and the Gershgorin interval   
   >                        initially used was too small.  No eigenvalues   
   >                        were computed.   
   >                        Probable cause: your machine has sloppy   
   >                                        floating-point arithmetic.   
   >                        Cure: Increase the PARAMETER "FUDGE",   
   >                              recompile, and try again.   
   > \endverbatim   

   > \par Internal Parameters:   
    =========================   
   >   
   > \verbatim   
   >  FUDGE   DOUBLE PRECISION, default = 2   
   >          A "fudge factor" to widen the Gershgorin intervals.  Ideally,   
   >          a value of 1 should work, but on machines with sloppy   
   >          arithmetic, this needs to be larger.  The default for   
   >          publicly released versions should be large enough to handle   
   >          the worst machine around.  Note that this has no effect   
   >          on accuracy of the solution.   
   > \endverbatim   
   >   
   > \par Contributors:   
    ==================   
   >   
   >     W. Kahan, University of California, Berkeley, USA \n   
   >     Beresford Parlett, University of California, Berkeley, USA \n   
   >     Jim Demmel, University of California, Berkeley, USA \n   
   >     Inderjit Dhillon, University of Texas, Austin, USA \n   
   >     Osni Marques, LBNL/NERSC, USA \n   
   >     Christof Voemel, University of California, Berkeley, USA \n   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlarrd_(char *range, char *order, integer *n, doublereal 
	*vl, doublereal *vu, integer *il, integer *iu, doublereal *gers, 
	doublereal *reltol, doublereal *d__, doublereal *e, doublereal *e2, 
	doublereal *pivmin, integer *nsplit, integer *isplit, integer *m, 
	doublereal *w, doublereal *werr, doublereal *wl, doublereal *wu, 
	integer *iblock, integer *indexw, doublereal *work, integer *iwork, 
	integer *info)
{
    /* System generated locals */
    integer i__1, i__2, i__3;
    doublereal d__1, d__2;

    /* Builtin functions */
    double log(doublereal);

    /* Local variables */
    integer i__, j, ib, ie, je, nb;
    doublereal gl;
    integer im, in;
    doublereal gu;
    integer iw, jee;
    doublereal eps;
    integer nwl;
    doublereal wlu, wul;
    integer nwu;
    doublereal tmp1, tmp2;
    integer iend, jblk, ioff, iout, itmp1, itmp2, jdisc;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    doublereal atoli;
    integer iwoff, itmax;
    doublereal wkill, rtoli, uflow, tnorm;
    extern doublereal igraphdlamch_(char *);
    integer ibegin;
    extern /* Subroutine */ int igraphdlaebz_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *);
    integer irange, idiscl, idumma[1];
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    integer idiscu;
    logical ncnvrg, toofew;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --iwork;
    --work;
    --indexw;
    --iblock;
    --werr;
    --w;
    --isplit;
    --e2;
    --e;
    --d__;
    --gers;

    /* Function Body */
    *info = 0;

/*     Decode RANGE */

    if (igraphlsame_(range, "A")) {
	irange = 1;
    } else if (igraphlsame_(range, "V")) {
	irange = 2;
    } else if (igraphlsame_(range, "I")) {
	irange = 3;
    } else {
	irange = 0;
    }

/*     Check for Errors */

    if (irange <= 0) {
	*info = -1;
    } else if (! (igraphlsame_(order, "B") || igraphlsame_(order, 
	    "E"))) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (irange == 2) {
	if (*vl >= *vu) {
	    *info = -5;
	}
    } else if (irange == 3 && (*il < 1 || *il > max(1,*n))) {
	*info = -6;
    } else if (irange == 3 && (*iu < min(*n,*il) || *iu > *n)) {
	*info = -7;
    }

    if (*info != 0) {
	return 0;
    }
/*     Initialize error flags */
    *info = 0;
    ncnvrg = FALSE_;
    toofew = FALSE_;
/*     Quick return if possible */
    *m = 0;
    if (*n == 0) {
	return 0;
    }
/*     Simplification: */
    if (irange == 3 && *il == 1 && *iu == *n) {
	irange = 1;
    }
/*     Get machine constants */
    eps = igraphdlamch_("P");
    uflow = igraphdlamch_("U");
/*     Special Case when N=1   
       Treat case of 1x1 matrix for quick return */
    if (*n == 1) {
	if (irange == 1 || irange == 2 && d__[1] > *vl && d__[1] <= *vu || 
		irange == 3 && *il == 1 && *iu == 1) {
	    *m = 1;
	    w[1] = d__[1];
/*           The computation error of the eigenvalue is zero */
	    werr[1] = 0.;
	    iblock[1] = 1;
	    indexw[1] = 1;
	}
	return 0;
    }
/*     NB is the minimum vector length for vector bisection, or 0   
       if only scalar is to be done. */
    nb = igraphilaenv_(&c__1, "DSTEBZ", " ", n, &c_n1, &c_n1, &c_n1, (ftnlen)6, (
	    ftnlen)1);
    if (nb <= 1) {
	nb = 0;
    }
/*     Find global spectral radius */
    gl = d__[1];
    gu = d__[1];
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MIN */
	d__1 = gl, d__2 = gers[(i__ << 1) - 1];
	gl = min(d__1,d__2);
/* Computing MAX */
	d__1 = gu, d__2 = gers[i__ * 2];
	gu = max(d__1,d__2);
/* L5: */
    }
/*     Compute global Gerschgorin bounds and spectral diameter   
   Computing MAX */
    d__1 = abs(gl), d__2 = abs(gu);
    tnorm = max(d__1,d__2);
    gl = gl - tnorm * 2. * eps * *n - *pivmin * 4.;
    gu = gu + tnorm * 2. * eps * *n + *pivmin * 4.;
/*     [JAN/28/2009] remove the line below since SPDIAM variable not use   
       SPDIAM = GU - GL   
       Input arguments for DLAEBZ:   
       The relative tolerance.  An interval (a,b] lies within   
       "relative tolerance" if  b-a < RELTOL*max(|a|,|b|), */
    rtoli = *reltol;
/*     Set the absolute tolerance for interval convergence to zero to force   
       interval convergence based on relative size of the interval.   
       This is dangerous because intervals might not converge when RELTOL is   
       small. But at least a very small number should be selected so that for   
       strongly graded matrices, the code can get relatively accurate   
       eigenvalues. */
    atoli = uflow * 4. + *pivmin * 4.;
    if (irange == 3) {
/*        RANGE='I': Compute an interval containing eigenvalues   
          IL through IU. The initial interval [GL,GU] from the global   
          Gerschgorin bounds GL and GU is refined by DLAEBZ. */
	itmax = (integer) ((log(tnorm + *pivmin) - log(*pivmin)) / log(2.)) + 
		2;
	work[*n + 1] = gl;
	work[*n + 2] = gl;
	work[*n + 3] = gu;
	work[*n + 4] = gu;
	work[*n + 5] = gl;
	work[*n + 6] = gu;
	iwork[1] = -1;
	iwork[2] = -1;
	iwork[3] = *n + 1;
	iwork[4] = *n + 1;
	iwork[5] = *il - 1;
	iwork[6] = *iu;

	igraphdlaebz_(&c__3, &itmax, n, &c__2, &c__2, &nb, &atoli, &rtoli, pivmin, &
		d__[1], &e[1], &e2[1], &iwork[5], &work[*n + 1], &work[*n + 5]
		, &iout, &iwork[1], &w[1], &iblock[1], &iinfo);
	if (iinfo != 0) {
	    *info = iinfo;
	    return 0;
	}
/*        On exit, output intervals may not be ordered by ascending negcount */
	if (iwork[6] == *iu) {
	    *wl = work[*n + 1];
	    wlu = work[*n + 3];
	    nwl = iwork[1];
	    *wu = work[*n + 4];
	    wul = work[*n + 2];
	    nwu = iwork[4];
	} else {
	    *wl = work[*n + 2];
	    wlu = work[*n + 4];
	    nwl = iwork[2];
	    *wu = work[*n + 3];
	    wul = work[*n + 1];
	    nwu = iwork[3];
	}
/*        On exit, the interval [WL, WLU] contains a value with negcount NWL,   
          and [WUL, WU] contains a value with negcount NWU. */
	if (nwl < 0 || nwl >= *n || nwu < 1 || nwu > *n) {
	    *info = 4;
	    return 0;
	}
    } else if (irange == 2) {
	*wl = *vl;
	*wu = *vu;
    } else if (irange == 1) {
	*wl = gl;
	*wu = gu;
    }
/*     Find Eigenvalues -- Loop Over blocks and recompute NWL and NWU.   
       NWL accumulates the number of eigenvalues .le. WL,   
       NWU accumulates the number of eigenvalues .le. WU */
    *m = 0;
    iend = 0;
    *info = 0;
    nwl = 0;
    nwu = 0;

    i__1 = *nsplit;
    for (jblk = 1; jblk <= i__1; ++jblk) {
	ioff = iend;
	ibegin = ioff + 1;
	iend = isplit[jblk];
	in = iend - ioff;

	if (in == 1) {
/*           1x1 block */
	    if (*wl >= d__[ibegin] - *pivmin) {
		++nwl;
	    }
	    if (*wu >= d__[ibegin] - *pivmin) {
		++nwu;
	    }
	    if (irange == 1 || *wl < d__[ibegin] - *pivmin && *wu >= d__[
		    ibegin] - *pivmin) {
		++(*m);
		w[*m] = d__[ibegin];
		werr[*m] = 0.;
/*              The gap for a single block doesn't matter for the later   
                algorithm and is assigned an arbitrary large value */
		iblock[*m] = jblk;
		indexw[*m] = 1;
	    }
/*        Disabled 2x2 case because of a failure on the following matrix   
          RANGE = 'I', IL = IU = 4   
            Original Tridiagonal, d = [   
             -0.150102010615740E+00   
             -0.849897989384260E+00   
             -0.128208148052635E-15   
              0.128257718286320E-15   
            ];   
            e = [   
             -0.357171383266986E+00   
             -0.180411241501588E-15   
             -0.175152352710251E-15   
            ];   

           ELSE IF( IN.EQ.2 ) THEN   
   *           2x2 block   
              DISC = SQRT( (HALF*(D(IBEGIN)-D(IEND)))**2 + E(IBEGIN)**2 )   
              TMP1 = HALF*(D(IBEGIN)+D(IEND))   
              L1 = TMP1 - DISC   
              IF( WL.GE. L1-PIVMIN )   
       $         NWL = NWL + 1   
              IF( WU.GE. L1-PIVMIN )   
       $         NWU = NWU + 1   
              IF( IRANGE.EQ.ALLRNG .OR. ( WL.LT.L1-PIVMIN .AND. WU.GE.   
       $          L1-PIVMIN ) ) THEN   
                 M = M + 1   
                 W( M ) = L1   
   *              The uncertainty of eigenvalues of a 2x2 matrix is very small   
                 WERR( M ) = EPS * ABS( W( M ) ) * TWO   
                 IBLOCK( M ) = JBLK   
                 INDEXW( M ) = 1   
              ENDIF   
              L2 = TMP1 + DISC   
              IF( WL.GE. L2-PIVMIN )   
       $         NWL = NWL + 1   
              IF( WU.GE. L2-PIVMIN )   
       $         NWU = NWU + 1   
              IF( IRANGE.EQ.ALLRNG .OR. ( WL.LT.L2-PIVMIN .AND. WU.GE.   
       $          L2-PIVMIN ) ) THEN   
                 M = M + 1   
                 W( M ) = L2   
   *              The uncertainty of eigenvalues of a 2x2 matrix is very small   
                 WERR( M ) = EPS * ABS( W( M ) ) * TWO   
                 IBLOCK( M ) = JBLK   
                 INDEXW( M ) = 2   
              ENDIF */
	} else {
/*           General Case - block of size IN >= 2   
             Compute local Gerschgorin interval and use it as the initial   
             interval for DLAEBZ */
	    gu = d__[ibegin];
	    gl = d__[ibegin];
	    tmp1 = 0.;
	    i__2 = iend;
	    for (j = ibegin; j <= i__2; ++j) {
/* Computing MIN */
		d__1 = gl, d__2 = gers[(j << 1) - 1];
		gl = min(d__1,d__2);
/* Computing MAX */
		d__1 = gu, d__2 = gers[j * 2];
		gu = max(d__1,d__2);
/* L40: */
	    }
/*           [JAN/28/2009]   
             change SPDIAM by TNORM in lines 2 and 3 thereafter   
             line 1: remove computation of SPDIAM (not useful anymore)   
             SPDIAM = GU - GL   
             GL = GL - FUDGE*SPDIAM*EPS*IN - FUDGE*PIVMIN   
             GU = GU + FUDGE*SPDIAM*EPS*IN + FUDGE*PIVMIN */
	    gl = gl - tnorm * 2. * eps * in - *pivmin * 2.;
	    gu = gu + tnorm * 2. * eps * in + *pivmin * 2.;

	    if (irange > 1) {
		if (gu < *wl) {
/*                 the local block contains none of the wanted eigenvalues */
		    nwl += in;
		    nwu += in;
		    goto L70;
		}
/*              refine search interval if possible, only range (WL,WU] matters */
		gl = max(gl,*wl);
		gu = min(gu,*wu);
		if (gl >= gu) {
		    goto L70;
		}
	    }
/*           Find negcount of initial interval boundaries GL and GU */
	    work[*n + 1] = gl;
	    work[*n + in + 1] = gu;
	    igraphdlaebz_(&c__1, &c__0, &in, &in, &c__1, &nb, &atoli, &rtoli, 
		    pivmin, &d__[ibegin], &e[ibegin], &e2[ibegin], idumma, &
		    work[*n + 1], &work[*n + (in << 1) + 1], &im, &iwork[1], &
		    w[*m + 1], &iblock[*m + 1], &iinfo);
	    if (iinfo != 0) {
		*info = iinfo;
		return 0;
	    }

	    nwl += iwork[1];
	    nwu += iwork[in + 1];
	    iwoff = *m - iwork[1];
/*           Compute Eigenvalues */
	    itmax = (integer) ((log(gu - gl + *pivmin) - log(*pivmin)) / log(
		    2.)) + 2;
	    igraphdlaebz_(&c__2, &itmax, &in, &in, &c__1, &nb, &atoli, &rtoli, 
		    pivmin, &d__[ibegin], &e[ibegin], &e2[ibegin], idumma, &
		    work[*n + 1], &work[*n + (in << 1) + 1], &iout, &iwork[1],
		     &w[*m + 1], &iblock[*m + 1], &iinfo);
	    if (iinfo != 0) {
		*info = iinfo;
		return 0;
	    }

/*           Copy eigenvalues into W and IBLOCK   
             Use -JBLK for block number for unconverged eigenvalues.   
             Loop over the number of output intervals from DLAEBZ */
	    i__2 = iout;
	    for (j = 1; j <= i__2; ++j) {
/*              eigenvalue approximation is middle point of interval */
		tmp1 = (work[j + *n] + work[j + in + *n]) * .5;
/*              semi length of error interval */
		tmp2 = (d__1 = work[j + *n] - work[j + in + *n], abs(d__1)) * 
			.5;
		if (j > iout - iinfo) {
/*                 Flag non-convergence. */
		    ncnvrg = TRUE_;
		    ib = -jblk;
		} else {
		    ib = jblk;
		}
		i__3 = iwork[j + in] + iwoff;
		for (je = iwork[j] + 1 + iwoff; je <= i__3; ++je) {
		    w[je] = tmp1;
		    werr[je] = tmp2;
		    indexw[je] = je - iwoff;
		    iblock[je] = ib;
/* L50: */
		}
/* L60: */
	    }

	    *m += im;
	}
L70:
	;
    }
/*     If RANGE='I', then (WL,WU) contains eigenvalues NWL+1,...,NWU   
       If NWL+1 < IL or NWU > IU, discard extra eigenvalues. */
    if (irange == 3) {
	idiscl = *il - 1 - nwl;
	idiscu = nwu - *iu;

	if (idiscl > 0) {
	    im = 0;
	    i__1 = *m;
	    for (je = 1; je <= i__1; ++je) {
/*              Remove some of the smallest eigenvalues from the left so that   
                at the end IDISCL =0. Move all eigenvalues up to the left. */
		if (w[je] <= wlu && idiscl > 0) {
		    --idiscl;
		} else {
		    ++im;
		    w[im] = w[je];
		    werr[im] = werr[je];
		    indexw[im] = indexw[je];
		    iblock[im] = iblock[je];
		}
/* L80: */
	    }
	    *m = im;
	}
	if (idiscu > 0) {
/*           Remove some of the largest eigenvalues from the right so that   
             at the end IDISCU =0. Move all eigenvalues up to the left. */
	    im = *m + 1;
	    for (je = *m; je >= 1; --je) {
		if (w[je] >= wul && idiscu > 0) {
		    --idiscu;
		} else {
		    --im;
		    w[im] = w[je];
		    werr[im] = werr[je];
		    indexw[im] = indexw[je];
		    iblock[im] = iblock[je];
		}
/* L81: */
	    }
	    jee = 0;
	    i__1 = *m;
	    for (je = im; je <= i__1; ++je) {
		++jee;
		w[jee] = w[je];
		werr[jee] = werr[je];
		indexw[jee] = indexw[je];
		iblock[jee] = iblock[je];
/* L82: */
	    }
	    *m = *m - im + 1;
	}
	if (idiscl > 0 || idiscu > 0) {
/*           Code to deal with effects of bad arithmetic. (If N(w) is   
             monotone non-decreasing, this should never happen.)   
             Some low eigenvalues to be discarded are not in (WL,WLU],   
             or high eigenvalues to be discarded are not in (WUL,WU]   
             so just kill off the smallest IDISCL/largest IDISCU   
             eigenvalues, by marking the corresponding IBLOCK = 0 */
	    if (idiscl > 0) {
		wkill = *wu;
		i__1 = idiscl;
		for (jdisc = 1; jdisc <= i__1; ++jdisc) {
		    iw = 0;
		    i__2 = *m;
		    for (je = 1; je <= i__2; ++je) {
			if (iblock[je] != 0 && (w[je] < wkill || iw == 0)) {
			    iw = je;
			    wkill = w[je];
			}
/* L90: */
		    }
		    iblock[iw] = 0;
/* L100: */
		}
	    }
	    if (idiscu > 0) {
		wkill = *wl;
		i__1 = idiscu;
		for (jdisc = 1; jdisc <= i__1; ++jdisc) {
		    iw = 0;
		    i__2 = *m;
		    for (je = 1; je <= i__2; ++je) {
			if (iblock[je] != 0 && (w[je] >= wkill || iw == 0)) {
			    iw = je;
			    wkill = w[je];
			}
/* L110: */
		    }
		    iblock[iw] = 0;
/* L120: */
		}
	    }
/*           Now erase all eigenvalues with IBLOCK set to zero */
	    im = 0;
	    i__1 = *m;
	    for (je = 1; je <= i__1; ++je) {
		if (iblock[je] != 0) {
		    ++im;
		    w[im] = w[je];
		    werr[im] = werr[je];
		    indexw[im] = indexw[je];
		    iblock[im] = iblock[je];
		}
/* L130: */
	    }
	    *m = im;
	}
	if (idiscl < 0 || idiscu < 0) {
	    toofew = TRUE_;
	}
    }

    if (irange == 1 && *m != *n || irange == 3 && *m != *iu - *il + 1) {
	toofew = TRUE_;
    }
/*     If ORDER='B', do nothing the eigenvalues are already sorted by   
          block.   
       If ORDER='E', sort the eigenvalues from smallest to largest */
    if (igraphlsame_(order, "E") && *nsplit > 1) {
	i__1 = *m - 1;
	for (je = 1; je <= i__1; ++je) {
	    ie = 0;
	    tmp1 = w[je];
	    i__2 = *m;
	    for (j = je + 1; j <= i__2; ++j) {
		if (w[j] < tmp1) {
		    ie = j;
		    tmp1 = w[j];
		}
/* L140: */
	    }
	    if (ie != 0) {
		tmp2 = werr[ie];
		itmp1 = iblock[ie];
		itmp2 = indexw[ie];
		w[ie] = w[je];
		werr[ie] = werr[je];
		iblock[ie] = iblock[je];
		indexw[ie] = indexw[je];
		w[je] = tmp1;
		werr[je] = tmp2;
		iblock[je] = itmp1;
		indexw[je] = itmp2;
	    }
/* L150: */
	}
    }

    *info = 0;
    if (ncnvrg) {
	++(*info);
    }
    if (toofew) {
	*info += 2;
    }
    return 0;

/*     End of DLARRD */

} /* igraphdlarrd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarre.c0000644000175100001710000010140600000000000024021 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__2 = 2;

/* > \brief \b DLARRE given the tridiagonal matrix T, sets small off-diagonal elements to zero and for each un
reduced block Ti, finds base representations and eigenvalues.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRE + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRE( RANGE, N, VL, VU, IL, IU, D, E, E2,   
                             RTOL1, RTOL2, SPLTOL, NSPLIT, ISPLIT, M,   
                             W, WERR, WGAP, IBLOCK, INDEXW, GERS, PIVMIN,   
                             WORK, IWORK, INFO )   

         CHARACTER          RANGE   
         INTEGER            IL, INFO, IU, M, N, NSPLIT   
         DOUBLE PRECISION  PIVMIN, RTOL1, RTOL2, SPLTOL, VL, VU   
         INTEGER            IBLOCK( * ), ISPLIT( * ), IWORK( * ),   
        $                   INDEXW( * )   
         DOUBLE PRECISION   D( * ), E( * ), E2( * ), GERS( * ),   
        $                   W( * ),WERR( * ), WGAP( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > To find the desired eigenvalues of a given real symmetric   
   > tridiagonal matrix T, DLARRE sets any "small" off-diagonal   
   > elements to zero, and for each unreduced block T_i, it finds   
   > (a) a suitable shift at one end of the block's spectrum,   
   > (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and   
   > (c) eigenvalues of each L_i D_i L_i^T.   
   > The representations and eigenvalues found are then used by   
   > DSTEMR to compute the eigenvectors of T.   
   > The accuracy varies depending on whether bisection is used to   
   > find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to   
   > conpute all and then discard any unwanted one.   
   > As an added benefit, DLARRE also outputs the n   
   > Gerschgorin intervals for the matrices L_i D_i L_i^T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] RANGE   
   > \verbatim   
   >          RANGE is CHARACTER*1   
   >          = 'A': ("All")   all eigenvalues will be found.   
   >          = 'V': ("Value") all eigenvalues in the half-open interval   
   >                           (VL, VU] will be found.   
   >          = 'I': ("Index") the IL-th through IU-th eigenvalues (of the   
   >                           entire matrix) will be found.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix. N > 0.   
   > \endverbatim   
   >   
   > \param[in,out] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >          If RANGE='V', the lower and upper bounds for the eigenvalues.   
   >          Eigenvalues less than or equal to VL, or greater than VU,   
   >          will not be returned.  VL < VU.   
   >          If RANGE='I' or ='A', DLARRE computes bounds on the desired   
   >          part of the spectrum.   
   > \endverbatim   
   >   
   > \param[in] IL   
   > \verbatim   
   >          IL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IU   
   > \verbatim   
   >          IU is INTEGER   
   >          If RANGE='I', the indices (in ascending order) of the   
   >          smallest and largest eigenvalues to be returned.   
   >          1 <= IL <= IU <= N.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the N diagonal elements of the tridiagonal   
   >          matrix T.   
   >          On exit, the N diagonal elements of the diagonal   
   >          matrices D_i.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the first (N-1) entries contain the subdiagonal   
   >          elements of the tridiagonal matrix T; E(N) need not be set.   
   >          On exit, E contains the subdiagonal elements of the unit   
   >          bidiagonal matrices L_i. The entries E( ISPLIT( I ) ),   
   >          1 <= I <= NSPLIT, contain the base points sigma_i on output.   
   > \endverbatim   
   >   
   > \param[in,out] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the first (N-1) entries contain the SQUARES of the   
   >          subdiagonal elements of the tridiagonal matrix T;   
   >          E2(N) need not be set.   
   >          On exit, the entries E2( ISPLIT( I ) ),   
   >          1 <= I <= NSPLIT, have been set to zero   
   > \endverbatim   
   >   
   > \param[in] RTOL1   
   > \verbatim   
   >          RTOL1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] RTOL2   
   > \verbatim   
   >          RTOL2 is DOUBLE PRECISION   
   >           Parameters for bisection.   
   >           An interval [LEFT,RIGHT] has converged if   
   >           RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )   
   > \endverbatim   
   >   
   > \param[in] SPLTOL   
   > \verbatim   
   >          SPLTOL is DOUBLE PRECISION   
   >          The threshold for splitting.   
   > \endverbatim   
   >   
   > \param[out] NSPLIT   
   > \verbatim   
   >          NSPLIT is INTEGER   
   >          The number of blocks T splits into. 1 <= NSPLIT <= N.   
   > \endverbatim   
   >   
   > \param[out] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into blocks.   
   >          The first block consists of rows/columns 1 to ISPLIT(1),   
   >          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),   
   >          etc., and the NSPLIT-th consists of rows/columns   
   >          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The total number of eigenvalues (of all L_i D_i L_i^T)   
   >          found.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements contain the eigenvalues. The   
   >          eigenvalues of each of the blocks, L_i D_i L_i^T, are   
   >          sorted in ascending order ( DLARRE may use the   
   >          remaining N-M elements as workspace).   
   > \endverbatim   
   >   
   > \param[out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension (N)   
   >          The error bound on the corresponding eigenvalue in W.   
   > \endverbatim   
   >   
   > \param[out] WGAP   
   > \verbatim   
   >          WGAP is DOUBLE PRECISION array, dimension (N)   
   >          The separation from the right neighbor eigenvalue in W.   
   >          The gap is only with respect to the eigenvalues of the same block   
   >          as each block has its own representation tree.   
   >          Exception: at the right end of a block we store the left gap   
   > \endverbatim   
   >   
   > \param[out] IBLOCK   
   > \verbatim   
   >          IBLOCK is INTEGER array, dimension (N)   
   >          The indices of the blocks (submatrices) associated with the   
   >          corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue   
   >          W(i) belongs to the first block from the top, =2 if W(i)   
   >          belongs to the second block, etc.   
   > \endverbatim   
   >   
   > \param[out] INDEXW   
   > \verbatim   
   >          INDEXW is INTEGER array, dimension (N)   
   >          The indices of the eigenvalues within each block (submatrix);   
   >          for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the   
   >          i-th eigenvalue W(i) is the 10-th eigenvalue in block 2   
   > \endverbatim   
   >   
   > \param[out] GERS   
   > \verbatim   
   >          GERS is DOUBLE PRECISION array, dimension (2*N)   
   >          The N Gerschgorin intervals (the i-th Gerschgorin interval   
   >          is (GERS(2*i-1), GERS(2*i)).   
   > \endverbatim   
   >   
   > \param[out] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot in the Sturm sequence for T.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (6*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (5*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          > 0:  A problem occured in DLARRE.   
   >          < 0:  One of the called subroutines signaled an internal problem.   
   >                Needs inspection of the corresponding parameter IINFO   
   >                for further information.   
   >   
   >          =-1:  Problem in DLARRD.   
   >          = 2:  No base representation could be found in MAXTRY iterations.   
   >                Increasing MAXTRY and recompilation might be a remedy.   
   >          =-3:  Problem in DLARRB when computing the refined root   
   >                representation for DLASQ2.   
   >          =-4:  Problem in DLARRB when preforming bisection on the   
   >                desired part of the spectrum.   
   >          =-5:  Problem in DLASQ2.   
   >          =-6:  Problem in DLASQ2.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The base representations are required to suffer very little   
   >  element growth and consequently define all their eigenvalues to   
   >  high relative accuracy.   
   > \endverbatim   

   > \par Contributors:   
    ==================   
   >   
   >     Beresford Parlett, University of California, Berkeley, USA \n   
   >     Jim Demmel, University of California, Berkeley, USA \n   
   >     Inderjit Dhillon, University of Texas, Austin, USA \n   
   >     Osni Marques, LBNL/NERSC, USA \n   
   >     Christof Voemel, University of California, Berkeley, USA \n   
   >   
    =====================================================================   
   Subroutine */ int igraphdlarre_(char *range, integer *n, doublereal *vl, 
	doublereal *vu, integer *il, integer *iu, doublereal *d__, doublereal 
	*e, doublereal *e2, doublereal *rtol1, doublereal *rtol2, doublereal *
	spltol, integer *nsplit, integer *isplit, integer *m, doublereal *w, 
	doublereal *werr, doublereal *wgap, integer *iblock, integer *indexw, 
	doublereal *gers, doublereal *pivmin, doublereal *work, integer *
	iwork, integer *info)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double sqrt(doublereal), log(doublereal);

    /* Local variables */
    integer i__, j;
    doublereal s1, s2;
    integer mb;
    doublereal gl;
    integer in, mm;
    doublereal gu;
    integer cnt;
    doublereal eps, tau, tmp, rtl;
    integer cnt1, cnt2;
    doublereal tmp1, eabs;
    integer iend, jblk;
    doublereal eold;
    integer indl;
    doublereal dmax__, emax;
    integer wend, idum, indu;
    doublereal rtol;
    integer iseed[4];
    doublereal avgap, sigma;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    logical norep;
    extern /* Subroutine */ int igraphdlasq2_(integer *, doublereal *, integer *);
    extern doublereal igraphdlamch_(char *);
    integer ibegin;
    logical forceb;
    integer irange;
    doublereal sgndef;
    extern /* Subroutine */ int igraphdlarra_(integer *, doublereal *, doublereal *,
	     doublereal *, doublereal *, doublereal *, integer *, integer *, 
	    integer *), igraphdlarrb_(integer *, doublereal *, doublereal *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     doublereal *, doublereal *, integer *, integer *), igraphdlarrc_(char *
	    , integer *, doublereal *, doublereal *, doublereal *, doublereal 
	    *, doublereal *, integer *, integer *, integer *, integer *);
    integer wbegin;
    extern /* Subroutine */ int igraphdlarrd_(char *, char *, integer *, doublereal 
	    *, doublereal *, integer *, integer *, doublereal *, doublereal *,
	     doublereal *, doublereal *, doublereal *, doublereal *, integer *
	    , integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *);
    doublereal safmin, spdiam;
    extern /* Subroutine */ int igraphdlarrk_(integer *, integer *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, integer *);
    logical usedqd;
    doublereal clwdth, isleft;
    extern /* Subroutine */ int igraphdlarnv_(integer *, integer *, integer *, 
	    doublereal *);
    doublereal isrght, bsrtol, dpivot;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --iwork;
    --work;
    --gers;
    --indexw;
    --iblock;
    --wgap;
    --werr;
    --w;
    --isplit;
    --e2;
    --e;
    --d__;

    /* Function Body */
    *info = 0;

/*     Decode RANGE */

    if (igraphlsame_(range, "A")) {
	irange = 1;
    } else if (igraphlsame_(range, "V")) {
	irange = 3;
    } else if (igraphlsame_(range, "I")) {
	irange = 2;
    }
    *m = 0;
/*     Get machine constants */
    safmin = igraphdlamch_("S");
    eps = igraphdlamch_("P");
/*     Set parameters */
    rtl = sqrt(eps);
    bsrtol = sqrt(eps);
/*     Treat case of 1x1 matrix for quick return */
    if (*n == 1) {
	if (irange == 1 || irange == 3 && d__[1] > *vl && d__[1] <= *vu || 
		irange == 2 && *il == 1 && *iu == 1) {
	    *m = 1;
	    w[1] = d__[1];
/*           The computation error of the eigenvalue is zero */
	    werr[1] = 0.;
	    wgap[1] = 0.;
	    iblock[1] = 1;
	    indexw[1] = 1;
	    gers[1] = d__[1];
	    gers[2] = d__[1];
	}
/*        store the shift for the initial RRR, which is zero in this case */
	e[1] = 0.;
	return 0;
    }
/*     General case: tridiagonal matrix of order > 1   

       Init WERR, WGAP. Compute Gerschgorin intervals and spectral diameter.   
       Compute maximum off-diagonal entry and pivmin. */
    gl = d__[1];
    gu = d__[1];
    eold = 0.;
    emax = 0.;
    e[*n] = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	werr[i__] = 0.;
	wgap[i__] = 0.;
	eabs = (d__1 = e[i__], abs(d__1));
	if (eabs >= emax) {
	    emax = eabs;
	}
	tmp1 = eabs + eold;
	gers[(i__ << 1) - 1] = d__[i__] - tmp1;
/* Computing MIN */
	d__1 = gl, d__2 = gers[(i__ << 1) - 1];
	gl = min(d__1,d__2);
	gers[i__ * 2] = d__[i__] + tmp1;
/* Computing MAX */
	d__1 = gu, d__2 = gers[i__ * 2];
	gu = max(d__1,d__2);
	eold = eabs;
/* L5: */
    }
/*     The minimum pivot allowed in the Sturm sequence for T   
   Computing MAX   
   Computing 2nd power */
    d__3 = emax;
    d__1 = 1., d__2 = d__3 * d__3;
    *pivmin = safmin * max(d__1,d__2);
/*     Compute spectral diameter. The Gerschgorin bounds give an   
       estimate that is wrong by at most a factor of SQRT(2) */
    spdiam = gu - gl;
/*     Compute splitting points */
    igraphdlarra_(n, &d__[1], &e[1], &e2[1], spltol, &spdiam, nsplit, &isplit[1], &
	    iinfo);
/*     Can force use of bisection instead of faster DQDS.   
       Option left in the code for future multisection work. */
    forceb = FALSE_;
/*     Initialize USEDQD, DQDS should be used for ALLRNG unless someone   
       explicitly wants bisection. */
    usedqd = irange == 1 && ! forceb;
    if (irange == 1 && ! forceb) {
/*        Set interval [VL,VU] that contains all eigenvalues */
	*vl = gl;
	*vu = gu;
    } else {
/*        We call DLARRD to find crude approximations to the eigenvalues   
          in the desired range. In case IRANGE = INDRNG, we also obtain the   
          interval (VL,VU] that contains all the wanted eigenvalues.   
          An interval [LEFT,RIGHT] has converged if   
          RIGHT-LEFT.LT.RTOL*MAX(ABS(LEFT),ABS(RIGHT))   
          DLARRD needs a WORK of size 4*N, IWORK of size 3*N */
	igraphdlarrd_(range, "B", n, vl, vu, il, iu, &gers[1], &bsrtol, &d__[1], &e[
		1], &e2[1], pivmin, nsplit, &isplit[1], &mm, &w[1], &werr[1], 
		vl, vu, &iblock[1], &indexw[1], &work[1], &iwork[1], &iinfo);
	if (iinfo != 0) {
	    *info = -1;
	    return 0;
	}
/*        Make sure that the entries M+1 to N in W, WERR, IBLOCK, INDEXW are 0 */
	i__1 = *n;
	for (i__ = mm + 1; i__ <= i__1; ++i__) {
	    w[i__] = 0.;
	    werr[i__] = 0.;
	    iblock[i__] = 0;
	    indexw[i__] = 0;
/* L14: */
	}
    }
/* **   
       Loop over unreduced blocks */
    ibegin = 1;
    wbegin = 1;
    i__1 = *nsplit;
    for (jblk = 1; jblk <= i__1; ++jblk) {
	iend = isplit[jblk];
	in = iend - ibegin + 1;
/*        1 X 1 block */
	if (in == 1) {
	    if (irange == 1 || irange == 3 && d__[ibegin] > *vl && d__[ibegin]
		     <= *vu || irange == 2 && iblock[wbegin] == jblk) {
		++(*m);
		w[*m] = d__[ibegin];
		werr[*m] = 0.;
/*              The gap for a single block doesn't matter for the later   
                algorithm and is assigned an arbitrary large value */
		wgap[*m] = 0.;
		iblock[*m] = jblk;
		indexw[*m] = 1;
		++wbegin;
	    }
/*           E( IEND ) holds the shift for the initial RRR */
	    e[iend] = 0.;
	    ibegin = iend + 1;
	    goto L170;
	}

/*        Blocks of size larger than 1x1   

          E( IEND ) will hold the shift for the initial RRR, for now set it =0 */
	e[iend] = 0.;

/*        Find local outer bounds GL,GU for the block */
	gl = d__[ibegin];
	gu = d__[ibegin];
	i__2 = iend;
	for (i__ = ibegin; i__ <= i__2; ++i__) {
/* Computing MIN */
	    d__1 = gers[(i__ << 1) - 1];
	    gl = min(d__1,gl);
/* Computing MAX */
	    d__1 = gers[i__ * 2];
	    gu = max(d__1,gu);
/* L15: */
	}
	spdiam = gu - gl;
	if (! (irange == 1 && ! forceb)) {
/*           Count the number of eigenvalues in the current block. */
	    mb = 0;
	    i__2 = mm;
	    for (i__ = wbegin; i__ <= i__2; ++i__) {
		if (iblock[i__] == jblk) {
		    ++mb;
		} else {
		    goto L21;
		}
/* L20: */
	    }
L21:
	    if (mb == 0) {
/*              No eigenvalue in the current block lies in the desired range   
                E( IEND ) holds the shift for the initial RRR */
		e[iend] = 0.;
		ibegin = iend + 1;
		goto L170;
	    } else {
/*              Decide whether dqds or bisection is more efficient */
		usedqd = (doublereal) mb > in * .5 && ! forceb;
		wend = wbegin + mb - 1;
/*              Calculate gaps for the current block   
                In later stages, when representations for individual   
                eigenvalues are different, we use SIGMA = E( IEND ). */
		sigma = 0.;
		i__2 = wend - 1;
		for (i__ = wbegin; i__ <= i__2; ++i__) {
/* Computing MAX */
		    d__1 = 0., d__2 = w[i__ + 1] - werr[i__ + 1] - (w[i__] + 
			    werr[i__]);
		    wgap[i__] = max(d__1,d__2);
/* L30: */
		}
/* Computing MAX */
		d__1 = 0., d__2 = *vu - sigma - (w[wend] + werr[wend]);
		wgap[wend] = max(d__1,d__2);
/*              Find local index of the first and last desired evalue. */
		indl = indexw[wbegin];
		indu = indexw[wend];
	    }
	}
	if (irange == 1 && ! forceb || usedqd) {
/*           Case of DQDS   
             Find approximations to the extremal eigenvalues of the block */
	    igraphdlarrk_(&in, &c__1, &gl, &gu, &d__[ibegin], &e2[ibegin], pivmin, &
		    rtl, &tmp, &tmp1, &iinfo);
	    if (iinfo != 0) {
		*info = -1;
		return 0;
	    }
/* Computing MAX */
	    d__2 = gl, d__3 = tmp - tmp1 - eps * 100. * (d__1 = tmp - tmp1, 
		    abs(d__1));
	    isleft = max(d__2,d__3);
	    igraphdlarrk_(&in, &in, &gl, &gu, &d__[ibegin], &e2[ibegin], pivmin, &
		    rtl, &tmp, &tmp1, &iinfo);
	    if (iinfo != 0) {
		*info = -1;
		return 0;
	    }
/* Computing MIN */
	    d__2 = gu, d__3 = tmp + tmp1 + eps * 100. * (d__1 = tmp + tmp1, 
		    abs(d__1));
	    isrght = min(d__2,d__3);
/*           Improve the estimate of the spectral diameter */
	    spdiam = isrght - isleft;
	} else {
/*           Case of bisection   
             Find approximations to the wanted extremal eigenvalues   
   Computing MAX */
	    d__2 = gl, d__3 = w[wbegin] - werr[wbegin] - eps * 100. * (d__1 = 
		    w[wbegin] - werr[wbegin], abs(d__1));
	    isleft = max(d__2,d__3);
/* Computing MIN */
	    d__2 = gu, d__3 = w[wend] + werr[wend] + eps * 100. * (d__1 = w[
		    wend] + werr[wend], abs(d__1));
	    isrght = min(d__2,d__3);
	}
/*        Decide whether the base representation for the current block   
          L_JBLK D_JBLK L_JBLK^T = T_JBLK - sigma_JBLK I   
          should be on the left or the right end of the current block.   
          The strategy is to shift to the end which is "more populated"   
          Furthermore, decide whether to use DQDS for the computation of   
          the eigenvalue approximations at the end of DLARRE or bisection.   
          dqds is chosen if all eigenvalues are desired or the number of   
          eigenvalues to be computed is large compared to the blocksize. */
	if (irange == 1 && ! forceb) {
/*           If all the eigenvalues have to be computed, we use dqd */
	    usedqd = TRUE_;
/*           INDL is the local index of the first eigenvalue to compute */
	    indl = 1;
	    indu = in;
/*           MB =  number of eigenvalues to compute */
	    mb = in;
	    wend = wbegin + mb - 1;
/*           Define 1/4 and 3/4 points of the spectrum */
	    s1 = isleft + spdiam * .25;
	    s2 = isrght - spdiam * .25;
	} else {
/*           DLARRD has computed IBLOCK and INDEXW for each eigenvalue   
             approximation.   
             choose sigma */
	    if (usedqd) {
		s1 = isleft + spdiam * .25;
		s2 = isrght - spdiam * .25;
	    } else {
		tmp = min(isrght,*vu) - max(isleft,*vl);
		s1 = max(isleft,*vl) + tmp * .25;
		s2 = min(isrght,*vu) - tmp * .25;
	    }
	}
/*        Compute the negcount at the 1/4 and 3/4 points */
	if (mb > 1) {
	    igraphdlarrc_("T", &in, &s1, &s2, &d__[ibegin], &e[ibegin], pivmin, &
		    cnt, &cnt1, &cnt2, &iinfo);
	}
	if (mb == 1) {
	    sigma = gl;
	    sgndef = 1.;
	} else if (cnt1 - indl >= indu - cnt2) {
	    if (irange == 1 && ! forceb) {
		sigma = max(isleft,gl);
	    } else if (usedqd) {
/*              use Gerschgorin bound as shift to get pos def matrix   
                for dqds */
		sigma = isleft;
	    } else {
/*              use approximation of the first desired eigenvalue of the   
                block as shift */
		sigma = max(isleft,*vl);
	    }
	    sgndef = 1.;
	} else {
	    if (irange == 1 && ! forceb) {
		sigma = min(isrght,gu);
	    } else if (usedqd) {
/*              use Gerschgorin bound as shift to get neg def matrix   
                for dqds */
		sigma = isrght;
	    } else {
/*              use approximation of the first desired eigenvalue of the   
                block as shift */
		sigma = min(isrght,*vu);
	    }
	    sgndef = -1.;
	}
/*        An initial SIGMA has been chosen that will be used for computing   
          T - SIGMA I = L D L^T   
          Define the increment TAU of the shift in case the initial shift   
          needs to be refined to obtain a factorization with not too much   
          element growth. */
	if (usedqd) {
/*           The initial SIGMA was to the outer end of the spectrum   
             the matrix is definite and we need not retreat. */
	    tau = spdiam * eps * *n + *pivmin * 2.;
/* Computing MAX */
	    d__1 = tau, d__2 = eps * 2. * abs(sigma);
	    tau = max(d__1,d__2);
	} else {
	    if (mb > 1) {
		clwdth = w[wend] + werr[wend] - w[wbegin] - werr[wbegin];
		avgap = (d__1 = clwdth / (doublereal) (wend - wbegin), abs(
			d__1));
		if (sgndef == 1.) {
/* Computing MAX */
		    d__1 = wgap[wbegin];
		    tau = max(d__1,avgap) * .5;
/* Computing MAX */
		    d__1 = tau, d__2 = werr[wbegin];
		    tau = max(d__1,d__2);
		} else {
/* Computing MAX */
		    d__1 = wgap[wend - 1];
		    tau = max(d__1,avgap) * .5;
/* Computing MAX */
		    d__1 = tau, d__2 = werr[wend];
		    tau = max(d__1,d__2);
		}
	    } else {
		tau = werr[wbegin];
	    }
	}

	for (idum = 1; idum <= 6; ++idum) {
/*           Compute L D L^T factorization of tridiagonal matrix T - sigma I.   
             Store D in WORK(1:IN), L in WORK(IN+1:2*IN), and reciprocals of   
             pivots in WORK(2*IN+1:3*IN) */
	    dpivot = d__[ibegin] - sigma;
	    work[1] = dpivot;
	    dmax__ = abs(work[1]);
	    j = ibegin;
	    i__2 = in - 1;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		work[(in << 1) + i__] = 1. / work[i__];
		tmp = e[j] * work[(in << 1) + i__];
		work[in + i__] = tmp;
		dpivot = d__[j + 1] - sigma - tmp * e[j];
		work[i__ + 1] = dpivot;
/* Computing MAX */
		d__1 = dmax__, d__2 = abs(dpivot);
		dmax__ = max(d__1,d__2);
		++j;
/* L70: */
	    }
/*           check for element growth */
	    if (dmax__ > spdiam * 64.) {
		norep = TRUE_;
	    } else {
		norep = FALSE_;
	    }
	    if (usedqd && ! norep) {
/*              Ensure the definiteness of the representation   
                All entries of D (of L D L^T) must have the same sign */
		i__2 = in;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    tmp = sgndef * work[i__];
		    if (tmp < 0.) {
			norep = TRUE_;
		    }
/* L71: */
		}
	    }
	    if (norep) {
/*              Note that in the case of IRANGE=ALLRNG, we use the Gerschgorin   
                shift which makes the matrix definite. So we should end up   
                here really only in the case of IRANGE = VALRNG or INDRNG. */
		if (idum == 5) {
		    if (sgndef == 1.) {
/*                    The fudged Gerschgorin shift should succeed */
			sigma = gl - spdiam * 2. * eps * *n - *pivmin * 4.;
		    } else {
			sigma = gu + spdiam * 2. * eps * *n + *pivmin * 4.;
		    }
		} else {
		    sigma -= sgndef * tau;
		    tau *= 2.;
		}
	    } else {
/*              an initial RRR is found */
		goto L83;
	    }
/* L80: */
	}
/*        if the program reaches this point, no base representation could be   
          found in MAXTRY iterations. */
	*info = 2;
	return 0;
L83:
/*        At this point, we have found an initial base representation   
          T - SIGMA I = L D L^T with not too much element growth.   
          Store the shift. */
	e[iend] = sigma;
/*        Store D and L. */
	igraphdcopy_(&in, &work[1], &c__1, &d__[ibegin], &c__1);
	i__2 = in - 1;
	igraphdcopy_(&i__2, &work[in + 1], &c__1, &e[ibegin], &c__1);
	if (mb > 1) {

/*           Perturb each entry of the base representation by a small   
             (but random) relative amount to overcome difficulties with   
             glued matrices. */

	    for (i__ = 1; i__ <= 4; ++i__) {
		iseed[i__ - 1] = 1;
/* L122: */
	    }
	    i__2 = (in << 1) - 1;
	    igraphdlarnv_(&c__2, iseed, &i__2, &work[1]);
	    i__2 = in - 1;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		d__[ibegin + i__ - 1] *= eps * 8. * work[i__] + 1.;
		e[ibegin + i__ - 1] *= eps * 8. * work[in + i__] + 1.;
/* L125: */
	    }
	    d__[iend] *= eps * 4. * work[in] + 1.;

	}

/*        Don't update the Gerschgorin intervals because keeping track   
          of the updates would be too much work in DLARRV.   
          We update W instead and use it to locate the proper Gerschgorin   
          intervals.   
          Compute the required eigenvalues of L D L' by bisection or dqds */
	if (! usedqd) {
/*           If DLARRD has been used, shift the eigenvalue approximations   
             according to their representation. This is necessary for   
             a uniform DLARRV since dqds computes eigenvalues of the   
             shifted representation. In DLARRV, W will always hold the   
             UNshifted eigenvalue approximation. */
	    i__2 = wend;
	    for (j = wbegin; j <= i__2; ++j) {
		w[j] -= sigma;
		werr[j] += (d__1 = w[j], abs(d__1)) * eps;
/* L134: */
	    }
/*           call DLARRB to reduce eigenvalue error of the approximations   
             from DLARRD */
	    i__2 = iend - 1;
	    for (i__ = ibegin; i__ <= i__2; ++i__) {
/* Computing 2nd power */
		d__1 = e[i__];
		work[i__] = d__[i__] * (d__1 * d__1);
/* L135: */
	    }
/*           use bisection to find EV from INDL to INDU */
	    i__2 = indl - 1;
	    igraphdlarrb_(&in, &d__[ibegin], &work[ibegin], &indl, &indu, rtol1, 
		    rtol2, &i__2, &w[wbegin], &wgap[wbegin], &werr[wbegin], &
		    work[(*n << 1) + 1], &iwork[1], pivmin, &spdiam, &in, &
		    iinfo);
	    if (iinfo != 0) {
		*info = -4;
		return 0;
	    }
/*           DLARRB computes all gaps correctly except for the last one   
             Record distance to VU/GU   
   Computing MAX */
	    d__1 = 0., d__2 = *vu - sigma - (w[wend] + werr[wend]);
	    wgap[wend] = max(d__1,d__2);
	    i__2 = indu;
	    for (i__ = indl; i__ <= i__2; ++i__) {
		++(*m);
		iblock[*m] = jblk;
		indexw[*m] = i__;
/* L138: */
	    }
	} else {
/*           Call dqds to get all eigs (and then possibly delete unwanted   
             eigenvalues).   
             Note that dqds finds the eigenvalues of the L D L^T representation   
             of T to high relative accuracy. High relative accuracy   
             might be lost when the shift of the RRR is subtracted to obtain   
             the eigenvalues of T. However, T is not guaranteed to define its   
             eigenvalues to high relative accuracy anyway.   
             Set RTOL to the order of the tolerance used in DLASQ2   
             This is an ESTIMATED error, the worst case bound is 4*N*EPS   
             which is usually too large and requires unnecessary work to be   
             done by bisection when computing the eigenvectors */
	    rtol = log((doublereal) in) * 4. * eps;
	    j = ibegin;
	    i__2 = in - 1;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		work[(i__ << 1) - 1] = (d__1 = d__[j], abs(d__1));
		work[i__ * 2] = e[j] * e[j] * work[(i__ << 1) - 1];
		++j;
/* L140: */
	    }
	    work[(in << 1) - 1] = (d__1 = d__[iend], abs(d__1));
	    work[in * 2] = 0.;
	    igraphdlasq2_(&in, &work[1], &iinfo);
	    if (iinfo != 0) {
/*              If IINFO = -5 then an index is part of a tight cluster   
                and should be changed. The index is in IWORK(1) and the   
                gap is in WORK(N+1) */
		*info = -5;
		return 0;
	    } else {
/*              Test that all eigenvalues are positive as expected */
		i__2 = in;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    if (work[i__] < 0.) {
			*info = -6;
			return 0;
		    }
/* L149: */
		}
	    }
	    if (sgndef > 0.) {
		i__2 = indu;
		for (i__ = indl; i__ <= i__2; ++i__) {
		    ++(*m);
		    w[*m] = work[in - i__ + 1];
		    iblock[*m] = jblk;
		    indexw[*m] = i__;
/* L150: */
		}
	    } else {
		i__2 = indu;
		for (i__ = indl; i__ <= i__2; ++i__) {
		    ++(*m);
		    w[*m] = -work[i__];
		    iblock[*m] = jblk;
		    indexw[*m] = i__;
/* L160: */
		}
	    }
	    i__2 = *m;
	    for (i__ = *m - mb + 1; i__ <= i__2; ++i__) {
/*              the value of RTOL below should be the tolerance in DLASQ2 */
		werr[i__] = rtol * (d__1 = w[i__], abs(d__1));
/* L165: */
	    }
	    i__2 = *m - 1;
	    for (i__ = *m - mb + 1; i__ <= i__2; ++i__) {
/*              compute the right gap between the intervals   
   Computing MAX */
		d__1 = 0., d__2 = w[i__ + 1] - werr[i__ + 1] - (w[i__] + werr[
			i__]);
		wgap[i__] = max(d__1,d__2);
/* L166: */
	    }
/* Computing MAX */
	    d__1 = 0., d__2 = *vu - sigma - (w[*m] + werr[*m]);
	    wgap[*m] = max(d__1,d__2);
	}
/*        proceed with next block */
	ibegin = iend + 1;
	wbegin = wend + 1;
L170:
	;
    }

    return 0;

/*     end of DLARRE */

} /* igraphdlarre_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrf.c0000644000175100001710000004001100000000000024014 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DLARRF finds a new relatively robust representation such that at least one of the eigenvalues i
s relatively isolated.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRF( N, D, L, LD, CLSTRT, CLEND,   
                            W, WGAP, WERR,   
                            SPDIAM, CLGAPL, CLGAPR, PIVMIN, SIGMA,   
                            DPLUS, LPLUS, WORK, INFO )   

         INTEGER            CLSTRT, CLEND, INFO, N   
         DOUBLE PRECISION   CLGAPL, CLGAPR, PIVMIN, SIGMA, SPDIAM   
         DOUBLE PRECISION   D( * ), DPLUS( * ), L( * ), LD( * ),   
        $          LPLUS( * ), W( * ), WGAP( * ), WERR( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Given the initial representation L D L^T and its cluster of close   
   > eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...   
   > W( CLEND ), DLARRF finds a new relatively robust representation   
   > L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the   
   > eigenvalues of L(+) D(+) L(+)^T is relatively isolated.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix (subblock, if the matrix splitted).   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of the diagonal matrix D.   
   > \endverbatim   
   >   
   > \param[in] L   
   > \verbatim   
   >          L is DOUBLE PRECISION array, dimension (N-1)   
   >          The (N-1) subdiagonal elements of the unit bidiagonal   
   >          matrix L.   
   > \endverbatim   
   >   
   > \param[in] LD   
   > \verbatim   
   >          LD is DOUBLE PRECISION array, dimension (N-1)   
   >          The (N-1) elements L(i)*D(i).   
   > \endverbatim   
   >   
   > \param[in] CLSTRT   
   > \verbatim   
   >          CLSTRT is INTEGER   
   >          The index of the first eigenvalue in the cluster.   
   > \endverbatim   
   >   
   > \param[in] CLEND   
   > \verbatim   
   >          CLEND is INTEGER   
   >          The index of the last eigenvalue in the cluster.   
   > \endverbatim   
   >   
   > \param[in] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension   
   >          dimension is >=  (CLEND-CLSTRT+1)   
   >          The eigenvalue APPROXIMATIONS of L D L^T in ascending order.   
   >          W( CLSTRT ) through W( CLEND ) form the cluster of relatively   
   >          close eigenalues.   
   > \endverbatim   
   >   
   > \param[in,out] WGAP   
   > \verbatim   
   >          WGAP is DOUBLE PRECISION array, dimension   
   >          dimension is >=  (CLEND-CLSTRT+1)   
   >          The separation from the right neighbor eigenvalue in W.   
   > \endverbatim   
   >   
   > \param[in] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension   
   >          dimension is  >=  (CLEND-CLSTRT+1)   
   >          WERR contain the semiwidth of the uncertainty   
   >          interval of the corresponding eigenvalue APPROXIMATION in W   
   > \endverbatim   
   >   
   > \param[in] SPDIAM   
   > \verbatim   
   >          SPDIAM is DOUBLE PRECISION   
   >          estimate of the spectral diameter obtained from the   
   >          Gerschgorin intervals   
   > \endverbatim   
   >   
   > \param[in] CLGAPL   
   > \verbatim   
   >          CLGAPL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] CLGAPR   
   > \verbatim   
   >          CLGAPR is DOUBLE PRECISION   
   >          absolute gap on each end of the cluster.   
   >          Set by the calling routine to protect against shifts too close   
   >          to eigenvalues outside the cluster.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot allowed in the Sturm sequence.   
   > \endverbatim   
   >   
   > \param[out] SIGMA   
   > \verbatim   
   >          SIGMA is DOUBLE PRECISION   
   >          The shift used to form L(+) D(+) L(+)^T.   
   > \endverbatim   
   >   
   > \param[out] DPLUS   
   > \verbatim   
   >          DPLUS is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of the diagonal matrix D(+).   
   > \endverbatim   
   >   
   > \param[out] LPLUS   
   > \verbatim   
   >          LPLUS is DOUBLE PRECISION array, dimension (N-1)   
   >          The first (N-1) elements of LPLUS contain the subdiagonal   
   >          elements of the unit bidiagonal matrix L(+).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (2*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          Signals processing OK (=0) or failure (=1)   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrf_(integer *n, doublereal *d__, doublereal *l, 
	doublereal *ld, integer *clstrt, integer *clend, doublereal *w, 
	doublereal *wgap, doublereal *werr, doublereal *spdiam, doublereal *
	clgapl, doublereal *clgapr, doublereal *pivmin, doublereal *sigma, 
	doublereal *dplus, doublereal *lplus, doublereal *work, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal s, bestshift, smlgrowth, eps, tmp, max1, max2, rrr1, rrr2, 
	    znm2, growthbound, fail, fact, oldp;
    integer indx;
    doublereal prod;
    integer ktry;
    doublereal fail2, avgap, ldmax, rdmax;
    integer shift;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    logical dorrr1;
    extern doublereal igraphdlamch_(char *);
    doublereal ldelta;
    logical nofail;
    doublereal mingap, lsigma, rdelta;
    extern logical igraphdisnan_(doublereal *);
    logical forcer;
    doublereal rsigma, clwdth;
    logical sawnan1, sawnan2, tryrrr1;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --work;
    --lplus;
    --dplus;
    --werr;
    --wgap;
    --w;
    --ld;
    --l;
    --d__;

    /* Function Body */
    *info = 0;
    fact = 2.;
    eps = igraphdlamch_("Precision");
    shift = 0;
    forcer = FALSE_;
/*     Note that we cannot guarantee that for any of the shifts tried,   
       the factorization has a small or even moderate element growth.   
       There could be Ritz values at both ends of the cluster and despite   
       backing off, there are examples where all factorizations tried   
       (in IEEE mode, allowing zero pivots & infinities) have INFINITE   
       element growth.   
       For this reason, we should use PIVMIN in this subroutine so that at   
       least the L D L^T factorization exists. It can be checked afterwards   
       whether the element growth caused bad residuals/orthogonality.   
       Decide whether the code should accept the best among all   
       representations despite large element growth or signal INFO=1 */
    nofail = TRUE_;

/*     Compute the average gap length of the cluster */
    clwdth = (d__1 = w[*clend] - w[*clstrt], abs(d__1)) + werr[*clend] + werr[
	    *clstrt];
    avgap = clwdth / (doublereal) (*clend - *clstrt);
    mingap = min(*clgapl,*clgapr);
/*     Initial values for shifts to both ends of cluster   
   Computing MIN */
    d__1 = w[*clstrt], d__2 = w[*clend];
    lsigma = min(d__1,d__2) - werr[*clstrt];
/* Computing MAX */
    d__1 = w[*clstrt], d__2 = w[*clend];
    rsigma = max(d__1,d__2) + werr[*clend];
/*     Use a small fudge to make sure that we really shift to the outside */
    lsigma -= abs(lsigma) * 4. * eps;
    rsigma += abs(rsigma) * 4. * eps;
/*     Compute upper bounds for how much to back off the initial shifts */
    ldmax = mingap * .25 + *pivmin * 2.;
    rdmax = mingap * .25 + *pivmin * 2.;
/* Computing MAX */
    d__1 = avgap, d__2 = wgap[*clstrt];
    ldelta = max(d__1,d__2) / fact;
/* Computing MAX */
    d__1 = avgap, d__2 = wgap[*clend - 1];
    rdelta = max(d__1,d__2) / fact;

/*     Initialize the record of the best representation found */

    s = igraphdlamch_("S");
    smlgrowth = 1. / s;
    fail = (doublereal) (*n - 1) * mingap / (*spdiam * eps);
    fail2 = (doublereal) (*n - 1) * mingap / (*spdiam * sqrt(eps));
    bestshift = lsigma;

/*     while (KTRY <= KTRYMAX) */
    ktry = 0;
    growthbound = *spdiam * 8.;
L5:
    sawnan1 = FALSE_;
    sawnan2 = FALSE_;
/*     Ensure that we do not back off too much of the initial shifts */
    ldelta = min(ldmax,ldelta);
    rdelta = min(rdmax,rdelta);
/*     Compute the element growth when shifting to both ends of the cluster   
       accept the shift if there is no element growth at one of the two ends   
       Left end */
    s = -lsigma;
    dplus[1] = d__[1] + s;
    if (abs(dplus[1]) < *pivmin) {
	dplus[1] = -(*pivmin);
/*        Need to set SAWNAN1 because refined RRR test should not be used   
          in this case */
	sawnan1 = TRUE_;
    }
    max1 = abs(dplus[1]);
    i__1 = *n - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	lplus[i__] = ld[i__] / dplus[i__];
	s = s * lplus[i__] * l[i__] - lsigma;
	dplus[i__ + 1] = d__[i__ + 1] + s;
	if ((d__1 = dplus[i__ + 1], abs(d__1)) < *pivmin) {
	    dplus[i__ + 1] = -(*pivmin);
/*           Need to set SAWNAN1 because refined RRR test should not be used   
             in this case */
	    sawnan1 = TRUE_;
	}
/* Computing MAX */
	d__2 = max1, d__3 = (d__1 = dplus[i__ + 1], abs(d__1));
	max1 = max(d__2,d__3);
/* L6: */
    }
    sawnan1 = sawnan1 || igraphdisnan_(&max1);
    if (forcer || max1 <= growthbound && ! sawnan1) {
	*sigma = lsigma;
	shift = 1;
	goto L100;
    }
/*     Right end */
    s = -rsigma;
    work[1] = d__[1] + s;
    if (abs(work[1]) < *pivmin) {
	work[1] = -(*pivmin);
/*        Need to set SAWNAN2 because refined RRR test should not be used   
          in this case */
	sawnan2 = TRUE_;
    }
    max2 = abs(work[1]);
    i__1 = *n - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	work[*n + i__] = ld[i__] / work[i__];
	s = s * work[*n + i__] * l[i__] - rsigma;
	work[i__ + 1] = d__[i__ + 1] + s;
	if ((d__1 = work[i__ + 1], abs(d__1)) < *pivmin) {
	    work[i__ + 1] = -(*pivmin);
/*           Need to set SAWNAN2 because refined RRR test should not be used   
             in this case */
	    sawnan2 = TRUE_;
	}
/* Computing MAX */
	d__2 = max2, d__3 = (d__1 = work[i__ + 1], abs(d__1));
	max2 = max(d__2,d__3);
/* L7: */
    }
    sawnan2 = sawnan2 || igraphdisnan_(&max2);
    if (forcer || max2 <= growthbound && ! sawnan2) {
	*sigma = rsigma;
	shift = 2;
	goto L100;
    }
/*     If we are at this point, both shifts led to too much element growth   
       Record the better of the two shifts (provided it didn't lead to NaN) */
    if (sawnan1 && sawnan2) {
/*        both MAX1 and MAX2 are NaN */
	goto L50;
    } else {
	if (! sawnan1) {
	    indx = 1;
	    if (max1 <= smlgrowth) {
		smlgrowth = max1;
		bestshift = lsigma;
	    }
	}
	if (! sawnan2) {
	    if (sawnan1 || max2 <= max1) {
		indx = 2;
	    }
	    if (max2 <= smlgrowth) {
		smlgrowth = max2;
		bestshift = rsigma;
	    }
	}
    }
/*     If we are here, both the left and the right shift led to   
       element growth. If the element growth is moderate, then   
       we may still accept the representation, if it passes a   
       refined test for RRR. This test supposes that no NaN occurred.   
       Moreover, we use the refined RRR test only for isolated clusters. */
    if (clwdth < mingap / 128. && min(max1,max2) < fail2 && ! sawnan1 && ! 
	    sawnan2) {
	dorrr1 = TRUE_;
    } else {
	dorrr1 = FALSE_;
    }
    tryrrr1 = TRUE_;
    if (tryrrr1 && dorrr1) {
	if (indx == 1) {
	    tmp = (d__1 = dplus[*n], abs(d__1));
	    znm2 = 1.;
	    prod = 1.;
	    oldp = 1.;
	    for (i__ = *n - 1; i__ >= 1; --i__) {
		if (prod <= eps) {
		    prod = dplus[i__ + 1] * work[*n + i__ + 1] / (dplus[i__] *
			     work[*n + i__]) * oldp;
		} else {
		    prod *= (d__1 = work[*n + i__], abs(d__1));
		}
		oldp = prod;
/* Computing 2nd power */
		d__1 = prod;
		znm2 += d__1 * d__1;
/* Computing MAX */
		d__2 = tmp, d__3 = (d__1 = dplus[i__] * prod, abs(d__1));
		tmp = max(d__2,d__3);
/* L15: */
	    }
	    rrr1 = tmp / (*spdiam * sqrt(znm2));
	    if (rrr1 <= 8.) {
		*sigma = lsigma;
		shift = 1;
		goto L100;
	    }
	} else if (indx == 2) {
	    tmp = (d__1 = work[*n], abs(d__1));
	    znm2 = 1.;
	    prod = 1.;
	    oldp = 1.;
	    for (i__ = *n - 1; i__ >= 1; --i__) {
		if (prod <= eps) {
		    prod = work[i__ + 1] * lplus[i__ + 1] / (work[i__] * 
			    lplus[i__]) * oldp;
		} else {
		    prod *= (d__1 = lplus[i__], abs(d__1));
		}
		oldp = prod;
/* Computing 2nd power */
		d__1 = prod;
		znm2 += d__1 * d__1;
/* Computing MAX */
		d__2 = tmp, d__3 = (d__1 = work[i__] * prod, abs(d__1));
		tmp = max(d__2,d__3);
/* L16: */
	    }
	    rrr2 = tmp / (*spdiam * sqrt(znm2));
	    if (rrr2 <= 8.) {
		*sigma = rsigma;
		shift = 2;
		goto L100;
	    }
	}
    }
L50:
    if (ktry < 1) {
/*        If we are here, both shifts failed also the RRR test.   
          Back off to the outside   
   Computing MAX */
	d__1 = lsigma - ldelta, d__2 = lsigma - ldmax;
	lsigma = max(d__1,d__2);
/* Computing MIN */
	d__1 = rsigma + rdelta, d__2 = rsigma + rdmax;
	rsigma = min(d__1,d__2);
	ldelta *= 2.;
	rdelta *= 2.;
	++ktry;
	goto L5;
    } else {
/*        None of the representations investigated satisfied our   
          criteria. Take the best one we found. */
	if (smlgrowth < fail || nofail) {
	    lsigma = bestshift;
	    rsigma = bestshift;
	    forcer = TRUE_;
	    goto L5;
	} else {
	    *info = 1;
	    return 0;
	}
    }
L100:
    if (shift == 1) {
    } else if (shift == 2) {
/*        store new L and D back into DPLUS, LPLUS */
	igraphdcopy_(n, &work[1], &c__1, &dplus[1], &c__1);
	i__1 = *n - 1;
	igraphdcopy_(&i__1, &work[*n + 1], &c__1, &lplus[1], &c__1);
    }
    return 0;

/*     End of DLARRF */

} /* igraphdlarrf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrj.c0000644000175100001710000002662400000000000024036 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRJ performs refinement of the initial estimates of the eigenvalues of the matrix T.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRJ + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRJ( N, D, E2, IFIRST, ILAST,   
                            RTOL, OFFSET, W, WERR, WORK, IWORK,   
                            PIVMIN, SPDIAM, INFO )   

         INTEGER            IFIRST, ILAST, INFO, N, OFFSET   
         DOUBLE PRECISION   PIVMIN, RTOL, SPDIAM   
         INTEGER            IWORK( * )   
         DOUBLE PRECISION   D( * ), E2( * ), W( * ),   
        $                   WERR( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Given the initial eigenvalue approximations of T, DLARRJ   
   > does  bisection to refine the eigenvalues of T,   
   > W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial   
   > guesses for these eigenvalues are input in W, the corresponding estimate   
   > of the error in these guesses in WERR. During bisection, intervals   
   > [left, right] are maintained by storing their mid-points and   
   > semi-widths in the arrays W and WERR respectively.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of T.   
   > \endverbatim   
   >   
   > \param[in] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N-1)   
   >          The Squares of the (N-1) subdiagonal elements of T.   
   > \endverbatim   
   >   
   > \param[in] IFIRST   
   > \verbatim   
   >          IFIRST is INTEGER   
   >          The index of the first eigenvalue to be computed.   
   > \endverbatim   
   >   
   > \param[in] ILAST   
   > \verbatim   
   >          ILAST is INTEGER   
   >          The index of the last eigenvalue to be computed.   
   > \endverbatim   
   >   
   > \param[in] RTOL   
   > \verbatim   
   >          RTOL is DOUBLE PRECISION   
   >          Tolerance for the convergence of the bisection intervals.   
   >          An interval [LEFT,RIGHT] has converged if   
   >          RIGHT-LEFT.LT.RTOL*MAX(|LEFT|,|RIGHT|).   
   > \endverbatim   
   >   
   > \param[in] OFFSET   
   > \verbatim   
   >          OFFSET is INTEGER   
   >          Offset for the arrays W and WERR, i.e., the IFIRST-OFFSET   
   >          through ILAST-OFFSET elements of these arrays are to be used.   
   > \endverbatim   
   >   
   > \param[in,out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are   
   >          estimates of the eigenvalues of L D L^T indexed IFIRST through   
   >          ILAST.   
   >          On output, these estimates are refined.   
   > \endverbatim   
   >   
   > \param[in,out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension (N)   
   >          On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are   
   >          the errors in the estimates of the corresponding elements in W.   
   >          On output, these errors are refined.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (2*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (2*N)   
   >          Workspace.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot in the Sturm sequence for T.   
   > \endverbatim   
   >   
   > \param[in] SPDIAM   
   > \verbatim   
   >          SPDIAM is DOUBLE PRECISION   
   >          The spectral diameter of T.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          Error flag.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrj_(integer *n, doublereal *d__, doublereal *e2, 
	integer *ifirst, integer *ilast, doublereal *rtol, integer *offset, 
	doublereal *w, doublereal *werr, doublereal *work, integer *iwork, 
	doublereal *pivmin, doublereal *spdiam, integer *info)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double log(doublereal);

    /* Local variables */
    integer i__, j, k, p;
    doublereal s;
    integer i1, i2, ii;
    doublereal fac, mid;
    integer cnt;
    doublereal tmp, left;
    integer iter, nint, prev, next, savi1;
    doublereal right, width, dplus;
    integer olnint, maxitr;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   



       Parameter adjustments */
    --iwork;
    --work;
    --werr;
    --w;
    --e2;
    --d__;

    /* Function Body */
    *info = 0;

    maxitr = (integer) ((log(*spdiam + *pivmin) - log(*pivmin)) / log(2.)) + 
	    2;

/*     Initialize unconverged intervals in [ WORK(2*I-1), WORK(2*I) ].   
       The Sturm Count, Count( WORK(2*I-1) ) is arranged to be I-1, while   
       Count( WORK(2*I) ) is stored in IWORK( 2*I ). The integer IWORK( 2*I-1 )   
       for an unconverged interval is set to the index of the next unconverged   
       interval, and is -1 or 0 for a converged interval. Thus a linked   
       list of unconverged intervals is set up. */

    i1 = *ifirst;
    i2 = *ilast;
/*     The number of unconverged intervals */
    nint = 0;
/*     The last unconverged interval found */
    prev = 0;
    i__1 = i2;
    for (i__ = i1; i__ <= i__1; ++i__) {
	k = i__ << 1;
	ii = i__ - *offset;
	left = w[ii] - werr[ii];
	mid = w[ii];
	right = w[ii] + werr[ii];
	width = right - mid;
/* Computing MAX */
	d__1 = abs(left), d__2 = abs(right);
	tmp = max(d__1,d__2);
/*        The following test prevents the test of converged intervals */
	if (width < *rtol * tmp) {
/*           This interval has already converged and does not need refinement.   
             (Note that the gaps might change through refining the   
              eigenvalues, however, they can only get bigger.)   
             Remove it from the list. */
	    iwork[k - 1] = -1;
/*           Make sure that I1 always points to the first unconverged interval */
	    if (i__ == i1 && i__ < i2) {
		i1 = i__ + 1;
	    }
	    if (prev >= i1 && i__ <= i2) {
		iwork[(prev << 1) - 1] = i__ + 1;
	    }
	} else {
/*           unconverged interval found */
	    prev = i__;
/*           Make sure that [LEFT,RIGHT] contains the desired eigenvalue   

             Do while( CNT(LEFT).GT.I-1 ) */

	    fac = 1.;
L20:
	    cnt = 0;
	    s = left;
	    dplus = d__[1] - s;
	    if (dplus < 0.) {
		++cnt;
	    }
	    i__2 = *n;
	    for (j = 2; j <= i__2; ++j) {
		dplus = d__[j] - s - e2[j - 1] / dplus;
		if (dplus < 0.) {
		    ++cnt;
		}
/* L30: */
	    }
	    if (cnt > i__ - 1) {
		left -= werr[ii] * fac;
		fac *= 2.;
		goto L20;
	    }

/*           Do while( CNT(RIGHT).LT.I ) */

	    fac = 1.;
L50:
	    cnt = 0;
	    s = right;
	    dplus = d__[1] - s;
	    if (dplus < 0.) {
		++cnt;
	    }
	    i__2 = *n;
	    for (j = 2; j <= i__2; ++j) {
		dplus = d__[j] - s - e2[j - 1] / dplus;
		if (dplus < 0.) {
		    ++cnt;
		}
/* L60: */
	    }
	    if (cnt < i__) {
		right += werr[ii] * fac;
		fac *= 2.;
		goto L50;
	    }
	    ++nint;
	    iwork[k - 1] = i__ + 1;
	    iwork[k] = cnt;
	}
	work[k - 1] = left;
	work[k] = right;
/* L75: */
    }
    savi1 = i1;

/*     Do while( NINT.GT.0 ), i.e. there are still unconverged intervals   
       and while (ITER.LT.MAXITR) */

    iter = 0;
L80:
    prev = i1 - 1;
    i__ = i1;
    olnint = nint;
    i__1 = olnint;
    for (p = 1; p <= i__1; ++p) {
	k = i__ << 1;
	ii = i__ - *offset;
	next = iwork[k - 1];
	left = work[k - 1];
	right = work[k];
	mid = (left + right) * .5;
/*        semiwidth of interval */
	width = right - mid;
/* Computing MAX */
	d__1 = abs(left), d__2 = abs(right);
	tmp = max(d__1,d__2);
	if (width < *rtol * tmp || iter == maxitr) {
/*           reduce number of unconverged intervals */
	    --nint;
/*           Mark interval as converged. */
	    iwork[k - 1] = 0;
	    if (i1 == i__) {
		i1 = next;
	    } else {
/*              Prev holds the last unconverged interval previously examined */
		if (prev >= i1) {
		    iwork[(prev << 1) - 1] = next;
		}
	    }
	    i__ = next;
	    goto L100;
	}
	prev = i__;

/*        Perform one bisection step */

	cnt = 0;
	s = mid;
	dplus = d__[1] - s;
	if (dplus < 0.) {
	    ++cnt;
	}
	i__2 = *n;
	for (j = 2; j <= i__2; ++j) {
	    dplus = d__[j] - s - e2[j - 1] / dplus;
	    if (dplus < 0.) {
		++cnt;
	    }
/* L90: */
	}
	if (cnt <= i__ - 1) {
	    work[k - 1] = mid;
	} else {
	    work[k] = mid;
	}
	i__ = next;
L100:
	;
    }
    ++iter;
/*     do another loop if there are still unconverged intervals   
       However, in the last iteration, all intervals are accepted   
       since this is the best we can do. */
    if (nint > 0 && iter <= maxitr) {
	goto L80;
    }


/*     At this point, all the intervals have converged */
    i__1 = *ilast;
    for (i__ = savi1; i__ <= i__1; ++i__) {
	k = i__ << 1;
	ii = i__ - *offset;
/*        All intervals marked by '0' have been refined. */
	if (iwork[k - 1] == 0) {
	    w[ii] = (work[k - 1] + work[k]) * .5;
	    werr[ii] = work[k] - w[ii];
	}
/* L110: */
    }

    return 0;

/*     End of DLARRJ */

} /* igraphdlarrj_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrk.c0000644000175100001710000001652500000000000024036 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRK + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRK( N, IW, GL, GU,   
                             D, E2, PIVMIN, RELTOL, W, WERR, INFO)   

         INTEGER   INFO, IW, N   
         DOUBLE PRECISION    PIVMIN, RELTOL, GL, GU, W, WERR   
         DOUBLE PRECISION   D( * ), E2( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARRK computes one eigenvalue of a symmetric tridiagonal   
   > matrix T to suitable accuracy. This is an auxiliary code to be   
   > called from DSTEMR.   
   >   
   > To avoid overflow, the matrix must be scaled so that its   
   > largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest
   
   > accuracy, it should not be much smaller than that.   
   >   
   > See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal   
   > Matrix", Report CS41, Computer Science Dept., Stanford   
   > University, July 21, 1966.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the tridiagonal matrix T.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] IW   
   > \verbatim   
   >          IW is INTEGER   
   >          The index of the eigenvalues to be returned.   
   > \endverbatim   
   >   
   > \param[in] GL   
   > \verbatim   
   >          GL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] GU   
   > \verbatim   
   >          GU is DOUBLE PRECISION   
   >          An upper and a lower bound on the eigenvalue.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The n diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E2   
   > \verbatim   
   >          E2 is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) squared off-diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot allowed in the Sturm sequence for T.   
   > \endverbatim   
   >   
   > \param[in] RELTOL   
   > \verbatim   
   >          RELTOL is DOUBLE PRECISION   
   >          The minimum relative width of an interval.  When an interval   
   >          is narrower than RELTOL times the larger (in   
   >          magnitude) endpoint, then it is considered to be   
   >          sufficiently small, i.e., converged.  Note: this should   
   >          always be at least radix*machine epsilon.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION   
   >          The error bound on the corresponding eigenvalue approximation   
   >          in W.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:       Eigenvalue converged   
   >          = -1:      Eigenvalue did NOT converge   
   > \endverbatim   

   > \par Internal Parameters:   
    =========================   
   >   
   > \verbatim   
   >  FUDGE   DOUBLE PRECISION, default = 2   
   >          A "fudge factor" to widen the Gershgorin intervals.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlarrk_(integer *n, integer *iw, doublereal *gl, 
	doublereal *gu, doublereal *d__, doublereal *e2, doublereal *pivmin, 
	doublereal *reltol, doublereal *w, doublereal *werr, integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double log(doublereal);

    /* Local variables */
    integer i__, it;
    doublereal mid, eps, tmp1, tmp2, left, atoli, right;
    integer itmax;
    doublereal rtoli, tnorm;
    extern doublereal igraphdlamch_(char *);
    integer negcnt;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Get machine constants   
       Parameter adjustments */
    --e2;
    --d__;

    /* Function Body */
    eps = igraphdlamch_("P");
/* Computing MAX */
    d__1 = abs(*gl), d__2 = abs(*gu);
    tnorm = max(d__1,d__2);
    rtoli = *reltol;
    atoli = *pivmin * 4.;
    itmax = (integer) ((log(tnorm + *pivmin) - log(*pivmin)) / log(2.)) + 2;
    *info = -1;
    left = *gl - tnorm * 2. * eps * *n - *pivmin * 4.;
    right = *gu + tnorm * 2. * eps * *n + *pivmin * 4.;
    it = 0;
L10:

/*     Check if interval converged or maximum number of iterations reached */

    tmp1 = (d__1 = right - left, abs(d__1));
/* Computing MAX */
    d__1 = abs(right), d__2 = abs(left);
    tmp2 = max(d__1,d__2);
/* Computing MAX */
    d__1 = max(atoli,*pivmin), d__2 = rtoli * tmp2;
    if (tmp1 < max(d__1,d__2)) {
	*info = 0;
	goto L30;
    }
    if (it > itmax) {
	goto L30;
    }

/*     Count number of negative pivots for mid-point */

    ++it;
    mid = (left + right) * .5;
    negcnt = 0;
    tmp1 = d__[1] - mid;
    if (abs(tmp1) < *pivmin) {
	tmp1 = -(*pivmin);
    }
    if (tmp1 <= 0.) {
	++negcnt;
    }

    i__1 = *n;
    for (i__ = 2; i__ <= i__1; ++i__) {
	tmp1 = d__[i__] - e2[i__ - 1] / tmp1 - mid;
	if (abs(tmp1) < *pivmin) {
	    tmp1 = -(*pivmin);
	}
	if (tmp1 <= 0.) {
	    ++negcnt;
	}
/* L20: */
    }
    if (negcnt >= *iw) {
	right = mid;
    } else {
	left = mid;
    }
    goto L10;
L30:

/*     Converged or maximum number of iterations reached */

    *w = (left + right) * .5;
    *werr = (d__1 = right - left, abs(d__1)) * .5;
    return 0;

/*     End of DLARRK */

} /* igraphdlarrk_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrr.c0000644000175100001710000001471600000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARRR performs tests to decide whether the symmetric tridiagonal matrix T warrants expensive c
omputations which guarantee high relative accuracy in the eigenvalues.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRR( N, D, E, INFO )   

         INTEGER            N, INFO   
         DOUBLE PRECISION   D( * ), E( * )   



   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Perform tests to decide whether the symmetric tridiagonal matrix T   
   > warrants expensive computations which guarantee high relative accuracy   
   > in the eigenvalues.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix. N > 0.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The N diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the first (N-1) entries contain the subdiagonal   
   >          elements of the tridiagonal matrix T; E(N) is set to ZERO.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          INFO = 0(default) : the matrix warrants computations preserving   
   >                              relative accuracy.   
   >          INFO = 1          : the matrix warrants computations guaranteeing   
   >                              only absolute accuracy.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrr_(integer *n, doublereal *d__, doublereal *e, 
	integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal eps, tmp, tmp2, rmin;
    extern doublereal igraphdlamch_(char *);
    doublereal offdig, safmin;
    logical yesrel;
    doublereal smlnum, offdig2;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   



    =====================================================================   


       As a default, do NOT go for relative-accuracy preserving computations.   
       Parameter adjustments */
    --e;
    --d__;

    /* Function Body */
    *info = 1;
    safmin = igraphdlamch_("Safe minimum");
    eps = igraphdlamch_("Precision");
    smlnum = safmin / eps;
    rmin = sqrt(smlnum);
/*     Tests for relative accuracy   

       Test for scaled diagonal dominance   
       Scale the diagonal entries to one and check whether the sum of the   
       off-diagonals is less than one   

       The sdd relative error bounds have a 1/(1- 2*x) factor in them,   
       x = max(OFFDIG + OFFDIG2), so when x is close to 1/2, no relative   
       accuracy is promised.  In the notation of the code fragment below,   
       1/(1 - (OFFDIG + OFFDIG2)) is the condition number.   
       We don't think it is worth going into "sdd mode" unless the relative   
       condition number is reasonable, not 1/macheps.   
       The threshold should be compatible with other thresholds used in the   
       code. We set  OFFDIG + OFFDIG2 <= .999 =: RELCOND, it corresponds   
       to losing at most 3 decimal digits: 1 / (1 - (OFFDIG + OFFDIG2)) <= 1000   
       instead of the current OFFDIG + OFFDIG2 < 1 */

    yesrel = TRUE_;
    offdig = 0.;
    tmp = sqrt((abs(d__[1])));
    if (tmp < rmin) {
	yesrel = FALSE_;
    }
    if (! yesrel) {
	goto L11;
    }
    i__1 = *n;
    for (i__ = 2; i__ <= i__1; ++i__) {
	tmp2 = sqrt((d__1 = d__[i__], abs(d__1)));
	if (tmp2 < rmin) {
	    yesrel = FALSE_;
	}
	if (! yesrel) {
	    goto L11;
	}
	offdig2 = (d__1 = e[i__ - 1], abs(d__1)) / (tmp * tmp2);
	if (offdig + offdig2 >= .999) {
	    yesrel = FALSE_;
	}
	if (! yesrel) {
	    goto L11;
	}
	tmp = tmp2;
	offdig = offdig2;
/* L10: */
    }
L11:
    if (yesrel) {
	*info = 0;
	return 0;
    } else {
    }


/*     *** MORE TO BE IMPLEMENTED ***   


       Test if the lower bidiagonal matrix L from T = L D L^T   
       (zero shift facto) is well conditioned   


       Test if the upper bidiagonal matrix U from T = U D U^T   
       (zero shift facto) is well conditioned.   
       In this case, the matrix needs to be flipped and, at the end   
       of the eigenvector computation, the flip needs to be applied   
       to the computed eigenvectors (and the support) */


    return 0;

/*     END OF DLARRR */

} /* igraphdlarrr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlarrv.c0000644000175100001710000012031700000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b5 = 0.;
static integer c__1 = 1;
static integer c__2 = 2;

/* > \brief \b DLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and the eigenv
alues of L D LT.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARRV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARRV( N, VL, VU, D, L, PIVMIN,   
                            ISPLIT, M, DOL, DOU, MINRGP,   
                            RTOL1, RTOL2, W, WERR, WGAP,   
                            IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ,   
                            WORK, IWORK, INFO )   

         INTEGER            DOL, DOU, INFO, LDZ, M, N   
         DOUBLE PRECISION   MINRGP, PIVMIN, RTOL1, RTOL2, VL, VU   
         INTEGER            IBLOCK( * ), INDEXW( * ), ISPLIT( * ),   
        $                   ISUPPZ( * ), IWORK( * )   
         DOUBLE PRECISION   D( * ), GERS( * ), L( * ), W( * ), WERR( * ),   
        $                   WGAP( * ), WORK( * )   
         DOUBLE PRECISION  Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARRV computes the eigenvectors of the tridiagonal matrix   
   > T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.   
   > The input eigenvalues should have been computed by DLARRE.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >          Lower and upper bounds of the interval that contains the desired   
   >          eigenvalues. VL < VU. Needed to compute gaps on the left or right   
   >          end of the extremal eigenvalues in the desired RANGE.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the N diagonal elements of the diagonal matrix D.   
   >          On exit, D may be overwritten.   
   > \endverbatim   
   >   
   > \param[in,out] L   
   > \verbatim   
   >          L is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the (N-1) subdiagonal elements of the unit   
   >          bidiagonal matrix L are in elements 1 to N-1 of L   
   >          (if the matrix is not splitted.) At the end of each block   
   >          is stored the corresponding shift as given by DLARRE.   
   >          On exit, L is overwritten.   
   > \endverbatim   
   >   
   > \param[in] PIVMIN   
   > \verbatim   
   >          PIVMIN is DOUBLE PRECISION   
   >          The minimum pivot allowed in the Sturm sequence.   
   > \endverbatim   
   >   
   > \param[in] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into blocks.   
   >          The first block consists of rows/columns 1 to   
   >          ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1   
   >          through ISPLIT( 2 ), etc.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The total number of input eigenvalues.  0 <= M <= N.   
   > \endverbatim   
   >   
   > \param[in] DOL   
   > \verbatim   
   >          DOL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] DOU   
   > \verbatim   
   >          DOU is INTEGER   
   >          If the user wants to compute only selected eigenvectors from all   
   >          the eigenvalues supplied, he can specify an index range DOL:DOU.   
   >          Or else the setting DOL=1, DOU=M should be applied.   
   >          Note that DOL and DOU refer to the order in which the eigenvalues   
   >          are stored in W.   
   >          If the user wants to compute only selected eigenpairs, then   
   >          the columns DOL-1 to DOU+1 of the eigenvector space Z contain the   
   >          computed eigenvectors. All other columns of Z are set to zero.   
   > \endverbatim   
   >   
   > \param[in] MINRGP   
   > \verbatim   
   >          MINRGP is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] RTOL1   
   > \verbatim   
   >          RTOL1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] RTOL2   
   > \verbatim   
   >          RTOL2 is DOUBLE PRECISION   
   >           Parameters for bisection.   
   >           An interval [LEFT,RIGHT] has converged if   
   >           RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )   
   > \endverbatim   
   >   
   > \param[in,out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements of W contain the APPROXIMATE eigenvalues for   
   >          which eigenvectors are to be computed.  The eigenvalues   
   >          should be grouped by split-off block and ordered from   
   >          smallest to largest within the block ( The output array   
   >          W from DLARRE is expected here ). Furthermore, they are with   
   >          respect to the shift of the corresponding root representation   
   >          for their block. On exit, W holds the eigenvalues of the   
   >          UNshifted matrix.   
   > \endverbatim   
   >   
   > \param[in,out] WERR   
   > \verbatim   
   >          WERR is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements contain the semiwidth of the uncertainty   
   >          interval of the corresponding eigenvalue in W   
   > \endverbatim   
   >   
   > \param[in,out] WGAP   
   > \verbatim   
   >          WGAP is DOUBLE PRECISION array, dimension (N)   
   >          The separation from the right neighbor eigenvalue in W.   
   > \endverbatim   
   >   
   > \param[in] IBLOCK   
   > \verbatim   
   >          IBLOCK is INTEGER array, dimension (N)   
   >          The indices of the blocks (submatrices) associated with the   
   >          corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue   
   >          W(i) belongs to the first block from the top, =2 if W(i)   
   >          belongs to the second block, etc.   
   > \endverbatim   
   >   
   > \param[in] INDEXW   
   > \verbatim   
   >          INDEXW is INTEGER array, dimension (N)   
   >          The indices of the eigenvalues within each block (submatrix);   
   >          for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the   
   >          i-th eigenvalue W(i) is the 10-th eigenvalue in the second block.   
   > \endverbatim   
   >   
   > \param[in] GERS   
   > \verbatim   
   >          GERS is DOUBLE PRECISION array, dimension (2*N)   
   >          The N Gerschgorin intervals (the i-th Gerschgorin interval   
   >          is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should   
   >          be computed from the original UNshifted matrix.   
   > \endverbatim   
   >   
   > \param[out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )   
   >          If INFO = 0, the first M columns of Z contain the   
   >          orthonormal eigenvectors of the matrix T   
   >          corresponding to the input eigenvalues, with the i-th   
   >          column of Z holding the eigenvector associated with W(i).   
   >          Note: the user must ensure that at least max(1,M) columns are   
   >          supplied in the array Z.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z.  LDZ >= 1, and if   
   >          JOBZ = 'V', LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] ISUPPZ   
   > \verbatim   
   >          ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )   
   >          The support of the eigenvectors in Z, i.e., the indices   
   >          indicating the nonzero elements in Z. The I-th eigenvector   
   >          is nonzero only in elements ISUPPZ( 2*I-1 ) through   
   >          ISUPPZ( 2*I ).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (12*N)   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (7*N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >   
   >          > 0:  A problem occured in DLARRV.   
   >          < 0:  One of the called subroutines signaled an internal problem.   
   >                Needs inspection of the corresponding parameter IINFO   
   >                for further information.   
   >   
   >          =-1:  Problem in DLARRB when refining a child's eigenvalues.   
   >          =-2:  Problem in DLARRF when computing the RRR of a child.   
   >                When a child is inside a tight cluster, it can be difficult   
   >                to find an RRR. A partial remedy from the user's point of   
   >                view is to make the parameter MINRGP smaller and recompile.   
   >                However, as the orthogonality of the computed vectors is   
   >                proportional to 1/MINRGP, the user should be aware that   
   >                he might be trading in precision when he decreases MINRGP.   
   >          =-3:  Problem in DLARRB when refining a single eigenvalue   
   >                after the Rayleigh correction was rejected.   
   >          = 5:  The Rayleigh Quotient Iteration failed to converge to   
   >                full accuracy in MAXITR steps.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdlarrv_(integer *n, doublereal *vl, doublereal *vu, 
	doublereal *d__, doublereal *l, doublereal *pivmin, integer *isplit, 
	integer *m, integer *dol, integer *dou, doublereal *minrgp, 
	doublereal *rtol1, doublereal *rtol2, doublereal *w, doublereal *werr,
	 doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers,
	 doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
	integer *iwork, integer *info)
{
    /* System generated locals */
    integer z_dim1, z_offset, i__1, i__2, i__3, i__4, i__5;
    doublereal d__1, d__2;
    logical L__1;

    /* Builtin functions */
    double log(doublereal);

    /* Local variables */
    integer minwsize, i__, j, k, p, q, miniwsize, ii;
    doublereal gl;
    integer im, in;
    doublereal gu, gap, eps, tau, tol, tmp;
    integer zto;
    doublereal ztz;
    integer iend, jblk;
    doublereal lgap;
    integer done;
    doublereal rgap, left;
    integer wend, iter;
    doublereal bstw;
    integer itmp1;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    integer indld;
    doublereal fudge;
    integer idone;
    doublereal sigma;
    integer iinfo, iindr;
    doublereal resid;
    logical eskip;
    doublereal right;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    integer nclus, zfrom;
    doublereal rqtol;
    integer iindc1, iindc2;
    extern /* Subroutine */ int igraphdlar1v_(integer *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, logical *,
	     integer *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *);
    logical stp2ii;
    doublereal lambda;
    extern doublereal igraphdlamch_(char *);
    integer ibegin, indeig;
    logical needbs;
    integer indlld;
    doublereal sgndef, mingma;
    extern /* Subroutine */ int igraphdlarrb_(integer *, doublereal *, doublereal *,
	     integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     doublereal *, doublereal *, integer *, integer *);
    integer oldien, oldncl, wbegin;
    doublereal spdiam;
    integer negcnt;
    extern /* Subroutine */ int igraphdlarrf_(integer *, doublereal *, doublereal *,
	     doublereal *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, integer *);
    integer oldcls;
    doublereal savgap;
    integer ndepth;
    doublereal ssigma;
    extern /* Subroutine */ int igraphdlaset_(char *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *);
    logical usedbs;
    integer iindwk, offset;
    doublereal gaptol;
    integer newcls, oldfst, indwrk, windex, oldlst;
    logical usedrq;
    integer newfst, newftt, parity, windmn, windpl, isupmn, newlst, zusedl;
    doublereal bstres;
    integer newsiz, zusedu, zusedw;
    doublereal nrminv, rqcorr;
    logical tryrqc;
    integer isupmx;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   

       The first N entries of WORK are reserved for the eigenvalues   
       Parameter adjustments */
    --d__;
    --l;
    --isplit;
    --w;
    --werr;
    --wgap;
    --iblock;
    --indexw;
    --gers;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --isuppz;
    --work;
    --iwork;

    /* Function Body */
    indld = *n + 1;
    indlld = (*n << 1) + 1;
    indwrk = *n * 3 + 1;
    minwsize = *n * 12;
    i__1 = minwsize;
    for (i__ = 1; i__ <= i__1; ++i__) {
	work[i__] = 0.;
/* L5: */
    }
/*     IWORK(IINDR+1:IINDR+N) hold the twist indices R for the   
       factorization used to compute the FP vector */
    iindr = 0;
/*     IWORK(IINDC1+1:IINC2+N) are used to store the clusters of the current   
       layer and the one above. */
    iindc1 = *n;
    iindc2 = *n << 1;
    iindwk = *n * 3 + 1;
    miniwsize = *n * 7;
    i__1 = miniwsize;
    for (i__ = 1; i__ <= i__1; ++i__) {
	iwork[i__] = 0;
/* L10: */
    }
    zusedl = 1;
    if (*dol > 1) {
/*        Set lower bound for use of Z */
	zusedl = *dol - 1;
    }
    zusedu = *m;
    if (*dou < *m) {
/*        Set lower bound for use of Z */
	zusedu = *dou + 1;
    }
/*     The width of the part of Z that is used */
    zusedw = zusedu - zusedl + 1;
    igraphdlaset_("Full", n, &zusedw, &c_b5, &c_b5, &z__[zusedl * z_dim1 + 1], ldz);
    eps = igraphdlamch_("Precision");
    rqtol = eps * 2.;

/*     Set expert flags for standard code. */
    tryrqc = TRUE_;
    if (*dol == 1 && *dou == *m) {
    } else {
/*        Only selected eigenpairs are computed. Since the other evalues   
          are not refined by RQ iteration, bisection has to compute to full   
          accuracy. */
	*rtol1 = eps * 4.;
	*rtol2 = eps * 4.;
    }
/*     The entries WBEGIN:WEND in W, WERR, WGAP correspond to the   
       desired eigenvalues. The support of the nonzero eigenvector   
       entries is contained in the interval IBEGIN:IEND.   
       Remark that if k eigenpairs are desired, then the eigenvectors   
       are stored in k contiguous columns of Z.   
       DONE is the number of eigenvectors already computed */
    done = 0;
    ibegin = 1;
    wbegin = 1;
    i__1 = iblock[*m];
    for (jblk = 1; jblk <= i__1; ++jblk) {
	iend = isplit[jblk];
	sigma = l[iend];
/*        Find the eigenvectors of the submatrix indexed IBEGIN   
          through IEND. */
	wend = wbegin - 1;
L15:
	if (wend < *m) {
	    if (iblock[wend + 1] == jblk) {
		++wend;
		goto L15;
	    }
	}
	if (wend < wbegin) {
	    ibegin = iend + 1;
	    goto L170;
	} else if (wend < *dol || wbegin > *dou) {
	    ibegin = iend + 1;
	    wbegin = wend + 1;
	    goto L170;
	}
/*        Find local spectral diameter of the block */
	gl = gers[(ibegin << 1) - 1];
	gu = gers[ibegin * 2];
	i__2 = iend;
	for (i__ = ibegin + 1; i__ <= i__2; ++i__) {
/* Computing MIN */
	    d__1 = gers[(i__ << 1) - 1];
	    gl = min(d__1,gl);
/* Computing MAX */
	    d__1 = gers[i__ * 2];
	    gu = max(d__1,gu);
/* L20: */
	}
	spdiam = gu - gl;
/*        OLDIEN is the last index of the previous block */
	oldien = ibegin - 1;
/*        Calculate the size of the current block */
	in = iend - ibegin + 1;
/*        The number of eigenvalues in the current block */
	im = wend - wbegin + 1;
/*        This is for a 1x1 block */
	if (ibegin == iend) {
	    ++done;
	    z__[ibegin + wbegin * z_dim1] = 1.;
	    isuppz[(wbegin << 1) - 1] = ibegin;
	    isuppz[wbegin * 2] = ibegin;
	    w[wbegin] += sigma;
	    work[wbegin] = w[wbegin];
	    ibegin = iend + 1;
	    ++wbegin;
	    goto L170;
	}
/*        The desired (shifted) eigenvalues are stored in W(WBEGIN:WEND)   
          Note that these can be approximations, in this case, the corresp.   
          entries of WERR give the size of the uncertainty interval.   
          The eigenvalue approximations will be refined when necessary as   
          high relative accuracy is required for the computation of the   
          corresponding eigenvectors. */
	igraphdcopy_(&im, &w[wbegin], &c__1, &work[wbegin], &c__1);
/*        We store in W the eigenvalue approximations w.r.t. the original   
          matrix T. */
	i__2 = im;
	for (i__ = 1; i__ <= i__2; ++i__) {
	    w[wbegin + i__ - 1] += sigma;
/* L30: */
	}
/*        NDEPTH is the current depth of the representation tree */
	ndepth = 0;
/*        PARITY is either 1 or 0 */
	parity = 1;
/*        NCLUS is the number of clusters for the next level of the   
          representation tree, we start with NCLUS = 1 for the root */
	nclus = 1;
	iwork[iindc1 + 1] = 1;
	iwork[iindc1 + 2] = im;
/*        IDONE is the number of eigenvectors already computed in the current   
          block */
	idone = 0;
/*        loop while( IDONE.LT.IM )   
          generate the representation tree for the current block and   
          compute the eigenvectors */
L40:
	if (idone < im) {
/*           This is a crude protection against infinitely deep trees */
	    if (ndepth > *m) {
		*info = -2;
		return 0;
	    }
/*           breadth first processing of the current level of the representation   
             tree: OLDNCL = number of clusters on current level */
	    oldncl = nclus;
/*           reset NCLUS to count the number of child clusters */
	    nclus = 0;

	    parity = 1 - parity;
	    if (parity == 0) {
		oldcls = iindc1;
		newcls = iindc2;
	    } else {
		oldcls = iindc2;
		newcls = iindc1;
	    }
/*           Process the clusters on the current level */
	    i__2 = oldncl;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		j = oldcls + (i__ << 1);
/*              OLDFST, OLDLST = first, last index of current cluster.   
                                 cluster indices start with 1 and are relative   
                                 to WBEGIN when accessing W, WGAP, WERR, Z */
		oldfst = iwork[j - 1];
		oldlst = iwork[j];
		if (ndepth > 0) {
/*                 Retrieve relatively robust representation (RRR) of cluster   
                   that has been computed at the previous level   
                   The RRR is stored in Z and overwritten once the eigenvectors   
                   have been computed or when the cluster is refined */
		    if (*dol == 1 && *dou == *m) {
/*                    Get representation from location of the leftmost evalue   
                      of the cluster */
			j = wbegin + oldfst - 1;
		    } else {
			if (wbegin + oldfst - 1 < *dol) {
/*                       Get representation from the left end of Z array */
			    j = *dol - 1;
			} else if (wbegin + oldfst - 1 > *dou) {
/*                       Get representation from the right end of Z array */
			    j = *dou;
			} else {
			    j = wbegin + oldfst - 1;
			}
		    }
		    igraphdcopy_(&in, &z__[ibegin + j * z_dim1], &c__1, &d__[ibegin]
			    , &c__1);
		    i__3 = in - 1;
		    igraphdcopy_(&i__3, &z__[ibegin + (j + 1) * z_dim1], &c__1, &l[
			    ibegin], &c__1);
		    sigma = z__[iend + (j + 1) * z_dim1];
/*                 Set the corresponding entries in Z to zero */
		    igraphdlaset_("Full", &in, &c__2, &c_b5, &c_b5, &z__[ibegin + j 
			    * z_dim1], ldz);
		}
/*              Compute DL and DLL of current RRR */
		i__3 = iend - 1;
		for (j = ibegin; j <= i__3; ++j) {
		    tmp = d__[j] * l[j];
		    work[indld - 1 + j] = tmp;
		    work[indlld - 1 + j] = tmp * l[j];
/* L50: */
		}
		if (ndepth > 0) {
/*                 P and Q are index of the first and last eigenvalue to compute   
                   within the current block */
		    p = indexw[wbegin - 1 + oldfst];
		    q = indexw[wbegin - 1 + oldlst];
/*                 Offset for the arrays WORK, WGAP and WERR, i.e., the P-OFFSET   
                   through the Q-OFFSET elements of these arrays are to be used.   
                    OFFSET = P-OLDFST */
		    offset = indexw[wbegin] - 1;
/*                 perform limited bisection (if necessary) to get approximate   
                   eigenvalues to the precision needed. */
		    igraphdlarrb_(&in, &d__[ibegin], &work[indlld + ibegin - 1], &p,
			     &q, rtol1, rtol2, &offset, &work[wbegin], &wgap[
			    wbegin], &werr[wbegin], &work[indwrk], &iwork[
			    iindwk], pivmin, &spdiam, &in, &iinfo);
		    if (iinfo != 0) {
			*info = -1;
			return 0;
		    }
/*                 We also recompute the extremal gaps. W holds all eigenvalues   
                   of the unshifted matrix and must be used for computation   
                   of WGAP, the entries of WORK might stem from RRRs with   
                   different shifts. The gaps from WBEGIN-1+OLDFST to   
                   WBEGIN-1+OLDLST are correctly computed in DLARRB.   
                   However, we only allow the gaps to become greater since   
                   this is what should happen when we decrease WERR */
		    if (oldfst > 1) {
/* Computing MAX */
			d__1 = wgap[wbegin + oldfst - 2], d__2 = w[wbegin + 
				oldfst - 1] - werr[wbegin + oldfst - 1] - w[
				wbegin + oldfst - 2] - werr[wbegin + oldfst - 
				2];
			wgap[wbegin + oldfst - 2] = max(d__1,d__2);
		    }
		    if (wbegin + oldlst - 1 < wend) {
/* Computing MAX */
			d__1 = wgap[wbegin + oldlst - 1], d__2 = w[wbegin + 
				oldlst] - werr[wbegin + oldlst] - w[wbegin + 
				oldlst - 1] - werr[wbegin + oldlst - 1];
			wgap[wbegin + oldlst - 1] = max(d__1,d__2);
		    }
/*                 Each time the eigenvalues in WORK get refined, we store   
                   the newly found approximation with all shifts applied in W */
		    i__3 = oldlst;
		    for (j = oldfst; j <= i__3; ++j) {
			w[wbegin + j - 1] = work[wbegin + j - 1] + sigma;
/* L53: */
		    }
		}
/*              Process the current node. */
		newfst = oldfst;
		i__3 = oldlst;
		for (j = oldfst; j <= i__3; ++j) {
		    if (j == oldlst) {
/*                    we are at the right end of the cluster, this is also the   
                      boundary of the child cluster */
			newlst = j;
		    } else if (wgap[wbegin + j - 1] >= *minrgp * (d__1 = work[
			    wbegin + j - 1], abs(d__1))) {
/*                    the right relative gap is big enough, the child cluster   
                      (NEWFST,..,NEWLST) is well separated from the following */
			newlst = j;
		    } else {
/*                    inside a child cluster, the relative gap is not   
                      big enough. */
			goto L140;
		    }
/*                 Compute size of child cluster found */
		    newsiz = newlst - newfst + 1;
/*                 NEWFTT is the place in Z where the new RRR or the computed   
                   eigenvector is to be stored */
		    if (*dol == 1 && *dou == *m) {
/*                    Store representation at location of the leftmost evalue   
                      of the cluster */
			newftt = wbegin + newfst - 1;
		    } else {
			if (wbegin + newfst - 1 < *dol) {
/*                       Store representation at the left end of Z array */
			    newftt = *dol - 1;
			} else if (wbegin + newfst - 1 > *dou) {
/*                       Store representation at the right end of Z array */
			    newftt = *dou;
			} else {
			    newftt = wbegin + newfst - 1;
			}
		    }
		    if (newsiz > 1) {

/*                    Current child is not a singleton but a cluster.   
                      Compute and store new representation of child.   


                      Compute left and right cluster gap.   

                      LGAP and RGAP are not computed from WORK because   
                      the eigenvalue approximations may stem from RRRs   
                      different shifts. However, W hold all eigenvalues   
                      of the unshifted matrix. Still, the entries in WGAP   
                      have to be computed from WORK since the entries   
                      in W might be of the same order so that gaps are not   
                      exhibited correctly for very close eigenvalues. */
			if (newfst == 1) {
/* Computing MAX */
			    d__1 = 0., d__2 = w[wbegin] - werr[wbegin] - *vl;
			    lgap = max(d__1,d__2);
			} else {
			    lgap = wgap[wbegin + newfst - 2];
			}
			rgap = wgap[wbegin + newlst - 1];

/*                    Compute left- and rightmost eigenvalue of child   
                      to high precision in order to shift as close   
                      as possible and obtain as large relative gaps   
                      as possible */

			for (k = 1; k <= 2; ++k) {
			    if (k == 1) {
				p = indexw[wbegin - 1 + newfst];
			    } else {
				p = indexw[wbegin - 1 + newlst];
			    }
			    offset = indexw[wbegin] - 1;
			    igraphdlarrb_(&in, &d__[ibegin], &work[indlld + ibegin 
				    - 1], &p, &p, &rqtol, &rqtol, &offset, &
				    work[wbegin], &wgap[wbegin], &werr[wbegin]
				    , &work[indwrk], &iwork[iindwk], pivmin, &
				    spdiam, &in, &iinfo);
/* L55: */
			}

			if (wbegin + newlst - 1 < *dol || wbegin + newfst - 1 
				> *dou) {
/*                       if the cluster contains no desired eigenvalues   
                         skip the computation of that branch of the rep. tree   

                         We could skip before the refinement of the extremal   
                         eigenvalues of the child, but then the representation   
                         tree could be different from the one when nothing is   
                         skipped. For this reason we skip at this place. */
			    idone = idone + newlst - newfst + 1;
			    goto L139;
			}

/*                    Compute RRR of child cluster.   
                      Note that the new RRR is stored in Z   

                      DLARRF needs LWORK = 2*N */
			igraphdlarrf_(&in, &d__[ibegin], &l[ibegin], &work[indld + 
				ibegin - 1], &newfst, &newlst, &work[wbegin], 
				&wgap[wbegin], &werr[wbegin], &spdiam, &lgap, 
				&rgap, pivmin, &tau, &z__[ibegin + newftt * 
				z_dim1], &z__[ibegin + (newftt + 1) * z_dim1],
				 &work[indwrk], &iinfo);
			if (iinfo == 0) {
/*                       a new RRR for the cluster was found by DLARRF   
                         update shift and store it */
			    ssigma = sigma + tau;
			    z__[iend + (newftt + 1) * z_dim1] = ssigma;
/*                       WORK() are the midpoints and WERR() the semi-width   
                         Note that the entries in W are unchanged. */
			    i__4 = newlst;
			    for (k = newfst; k <= i__4; ++k) {
				fudge = eps * 3. * (d__1 = work[wbegin + k - 
					1], abs(d__1));
				work[wbegin + k - 1] -= tau;
				fudge += eps * 4. * (d__1 = work[wbegin + k - 
					1], abs(d__1));
/*                          Fudge errors */
				werr[wbegin + k - 1] += fudge;
/*                          Gaps are not fudged. Provided that WERR is small   
                            when eigenvalues are close, a zero gap indicates   
                            that a new representation is needed for resolving   
                            the cluster. A fudge could lead to a wrong decision   
                            of judging eigenvalues 'separated' which in   
                            reality are not. This could have a negative impact   
                            on the orthogonality of the computed eigenvectors.   
   L116: */
			    }
			    ++nclus;
			    k = newcls + (nclus << 1);
			    iwork[k - 1] = newfst;
			    iwork[k] = newlst;
			} else {
			    *info = -2;
			    return 0;
			}
		    } else {

/*                    Compute eigenvector of singleton */

			iter = 0;

			tol = log((doublereal) in) * 4. * eps;

			k = newfst;
			windex = wbegin + k - 1;
/* Computing MAX */
			i__4 = windex - 1;
			windmn = max(i__4,1);
/* Computing MIN */
			i__4 = windex + 1;
			windpl = min(i__4,*m);
			lambda = work[windex];
			++done;
/*                    Check if eigenvector computation is to be skipped */
			if (windex < *dol || windex > *dou) {
			    eskip = TRUE_;
			    goto L125;
			} else {
			    eskip = FALSE_;
			}
			left = work[windex] - werr[windex];
			right = work[windex] + werr[windex];
			indeig = indexw[windex];
/*                    Note that since we compute the eigenpairs for a child,   
                      all eigenvalue approximations are w.r.t the same shift.   
                      In this case, the entries in WORK should be used for   
                      computing the gaps since they exhibit even very small   
                      differences in the eigenvalues, as opposed to the   
                      entries in W which might "look" the same. */
			if (k == 1) {
/*                       In the case RANGE='I' and with not much initial   
                         accuracy in LAMBDA and VL, the formula   
                         LGAP = MAX( ZERO, (SIGMA - VL) + LAMBDA )   
                         can lead to an overestimation of the left gap and   
                         thus to inadequately early RQI 'convergence'.   
                         Prevent this by forcing a small left gap.   
   Computing MAX */
			    d__1 = abs(left), d__2 = abs(right);
			    lgap = eps * max(d__1,d__2);
			} else {
			    lgap = wgap[windmn];
			}
			if (k == im) {
/*                       In the case RANGE='I' and with not much initial   
                         accuracy in LAMBDA and VU, the formula   
                         can lead to an overestimation of the right gap and   
                         thus to inadequately early RQI 'convergence'.   
                         Prevent this by forcing a small right gap.   
   Computing MAX */
			    d__1 = abs(left), d__2 = abs(right);
			    rgap = eps * max(d__1,d__2);
			} else {
			    rgap = wgap[windex];
			}
			gap = min(lgap,rgap);
			if (k == 1 || k == im) {
/*                       The eigenvector support can become wrong   
                         because significant entries could be cut off due to a   
                         large GAPTOL parameter in LAR1V. Prevent this. */
			    gaptol = 0.;
			} else {
			    gaptol = gap * eps;
			}
			isupmn = in;
			isupmx = 1;
/*                    Update WGAP so that it holds the minimum gap   
                      to the left or the right. This is crucial in the   
                      case where bisection is used to ensure that the   
                      eigenvalue is refined up to the required precision.   
                      The correct value is restored afterwards. */
			savgap = wgap[windex];
			wgap[windex] = gap;
/*                    We want to use the Rayleigh Quotient Correction   
                      as often as possible since it converges quadratically   
                      when we are close enough to the desired eigenvalue.   
                      However, the Rayleigh Quotient can have the wrong sign   
                      and lead us away from the desired eigenvalue. In this   
                      case, the best we can do is to use bisection. */
			usedbs = FALSE_;
			usedrq = FALSE_;
/*                    Bisection is initially turned off unless it is forced */
			needbs = ! tryrqc;
L120:
/*                    Check if bisection should be used to refine eigenvalue */
			if (needbs) {
/*                       Take the bisection as new iterate */
			    usedbs = TRUE_;
			    itmp1 = iwork[iindr + windex];
			    offset = indexw[wbegin] - 1;
			    d__1 = eps * 2.;
			    igraphdlarrb_(&in, &d__[ibegin], &work[indlld + ibegin 
				    - 1], &indeig, &indeig, &c_b5, &d__1, &
				    offset, &work[wbegin], &wgap[wbegin], &
				    werr[wbegin], &work[indwrk], &iwork[
				    iindwk], pivmin, &spdiam, &itmp1, &iinfo);
			    if (iinfo != 0) {
				*info = -3;
				return 0;
			    }
			    lambda = work[windex];
/*                       Reset twist index from inaccurate LAMBDA to   
                         force computation of true MINGMA */
			    iwork[iindr + windex] = 0;
			}
/*                    Given LAMBDA, compute the eigenvector. */
			L__1 = ! usedbs;
			igraphdlar1v_(&in, &c__1, &in, &lambda, &d__[ibegin], &l[
				ibegin], &work[indld + ibegin - 1], &work[
				indlld + ibegin - 1], pivmin, &gaptol, &z__[
				ibegin + windex * z_dim1], &L__1, &negcnt, &
				ztz, &mingma, &iwork[iindr + windex], &isuppz[
				(windex << 1) - 1], &nrminv, &resid, &rqcorr, 
				&work[indwrk]);
			if (iter == 0) {
			    bstres = resid;
			    bstw = lambda;
			} else if (resid < bstres) {
			    bstres = resid;
			    bstw = lambda;
			}
/* Computing MIN */
			i__4 = isupmn, i__5 = isuppz[(windex << 1) - 1];
			isupmn = min(i__4,i__5);
/* Computing MAX */
			i__4 = isupmx, i__5 = isuppz[windex * 2];
			isupmx = max(i__4,i__5);
			++iter;
/*                    sin alpha <= |resid|/gap   
                      Note that both the residual and the gap are   
                      proportional to the matrix, so ||T|| doesn't play   
                      a role in the quotient   

                      Convergence test for Rayleigh-Quotient iteration   
                      (omitted when Bisection has been used) */

			if (resid > tol * gap && abs(rqcorr) > rqtol * abs(
				lambda) && ! usedbs) {
/*                       We need to check that the RQCORR update doesn't   
                         move the eigenvalue away from the desired one and   
                         towards a neighbor. -> protection with bisection */
			    if (indeig <= negcnt) {
/*                          The wanted eigenvalue lies to the left */
				sgndef = -1.;
			    } else {
/*                          The wanted eigenvalue lies to the right */
				sgndef = 1.;
			    }
/*                       We only use the RQCORR if it improves the   
                         the iterate reasonably. */
			    if (rqcorr * sgndef >= 0. && lambda + rqcorr <= 
				    right && lambda + rqcorr >= left) {
				usedrq = TRUE_;
/*                          Store new midpoint of bisection interval in WORK */
				if (sgndef == 1.) {
/*                             The current LAMBDA is on the left of the true   
                               eigenvalue */
				    left = lambda;
/*                             We prefer to assume that the error estimate   
                               is correct. We could make the interval not   
                               as a bracket but to be modified if the RQCORR   
                               chooses to. In this case, the RIGHT side should   
                               be modified as follows:   
                                RIGHT = MAX(RIGHT, LAMBDA + RQCORR) */
				} else {
/*                             The current LAMBDA is on the right of the true   
                               eigenvalue */
				    right = lambda;
/*                             See comment about assuming the error estimate is   
                               correct above.   
                                LEFT = MIN(LEFT, LAMBDA + RQCORR) */
				}
				work[windex] = (right + left) * .5;
/*                          Take RQCORR since it has the correct sign and   
                            improves the iterate reasonably */
				lambda += rqcorr;
/*                          Update width of error interval */
				werr[windex] = (right - left) * .5;
			    } else {
				needbs = TRUE_;
			    }
			    if (right - left < rqtol * abs(lambda)) {
/*                             The eigenvalue is computed to bisection accuracy   
                               compute eigenvector and stop */
				usedbs = TRUE_;
				goto L120;
			    } else if (iter < 10) {
				goto L120;
			    } else if (iter == 10) {
				needbs = TRUE_;
				goto L120;
			    } else {
				*info = 5;
				return 0;
			    }
			} else {
			    stp2ii = FALSE_;
			    if (usedrq && usedbs && bstres <= resid) {
				lambda = bstw;
				stp2ii = TRUE_;
			    }
			    if (stp2ii) {
/*                          improve error angle by second step */
				L__1 = ! usedbs;
				igraphdlar1v_(&in, &c__1, &in, &lambda, &d__[ibegin]
					, &l[ibegin], &work[indld + ibegin - 
					1], &work[indlld + ibegin - 1], 
					pivmin, &gaptol, &z__[ibegin + windex 
					* z_dim1], &L__1, &negcnt, &ztz, &
					mingma, &iwork[iindr + windex], &
					isuppz[(windex << 1) - 1], &nrminv, &
					resid, &rqcorr, &work[indwrk]);
			    }
			    work[windex] = lambda;
			}

/*                    Compute FP-vector support w.r.t. whole matrix */

			isuppz[(windex << 1) - 1] += oldien;
			isuppz[windex * 2] += oldien;
			zfrom = isuppz[(windex << 1) - 1];
			zto = isuppz[windex * 2];
			isupmn += oldien;
			isupmx += oldien;
/*                    Ensure vector is ok if support in the RQI has changed */
			if (isupmn < zfrom) {
			    i__4 = zfrom - 1;
			    for (ii = isupmn; ii <= i__4; ++ii) {
				z__[ii + windex * z_dim1] = 0.;
/* L122: */
			    }
			}
			if (isupmx > zto) {
			    i__4 = isupmx;
			    for (ii = zto + 1; ii <= i__4; ++ii) {
				z__[ii + windex * z_dim1] = 0.;
/* L123: */
			    }
			}
			i__4 = zto - zfrom + 1;
			igraphdscal_(&i__4, &nrminv, &z__[zfrom + windex * z_dim1], 
				&c__1);
L125:
/*                    Update W */
			w[windex] = lambda + sigma;
/*                    Recompute the gaps on the left and right   
                      But only allow them to become larger and not   
                      smaller (which can only happen through "bad"   
                      cancellation and doesn't reflect the theory   
                      where the initial gaps are underestimated due   
                      to WERR being too crude.) */
			if (! eskip) {
			    if (k > 1) {
/* Computing MAX */
				d__1 = wgap[windmn], d__2 = w[windex] - werr[
					windex] - w[windmn] - werr[windmn];
				wgap[windmn] = max(d__1,d__2);
			    }
			    if (windex < wend) {
/* Computing MAX */
				d__1 = savgap, d__2 = w[windpl] - werr[windpl]
					 - w[windex] - werr[windex];
				wgap[windex] = max(d__1,d__2);
			    }
			}
			++idone;
		    }
/*                 here ends the code for the current child */

L139:
/*                 Proceed to any remaining child nodes */
		    newfst = j + 1;
L140:
		    ;
		}
/* L150: */
	    }
	    ++ndepth;
	    goto L40;
	}
	ibegin = iend + 1;
	wbegin = wend + 1;
L170:
	;
    }

    return 0;

/*     End of DLARRV */

} /* igraphdlarrv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlartg.c0000644000175100001710000001414700000000000024032 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARTG generates a plane rotation with real cosine and real sine.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARTG + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARTG( F, G, CS, SN, R )   

         DOUBLE PRECISION   CS, F, G, R, SN   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARTG generate a plane rotation so that   
   >   
   >    [  CS  SN  ]  .  [ F ]  =  [ R ]   where CS**2 + SN**2 = 1.   
   >    [ -SN  CS  ]     [ G ]     [ 0 ]   
   >   
   > This is a slower, more accurate version of the BLAS1 routine DROTG,   
   > with the following other differences:   
   >    F and G are unchanged on return.   
   >    If G=0, then CS=1 and SN=0.   
   >    If F=0 and (G .ne. 0), then CS=0 and SN=1 without doing any   
   >       floating point operations (saves work in DBDSQR when   
   >       there are zeros on the diagonal).   
   >   
   > If F exceeds G in magnitude, CS will be positive.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] F   
   > \verbatim   
   >          F is DOUBLE PRECISION   
   >          The first component of vector to be rotated.   
   > \endverbatim   
   >   
   > \param[in] G   
   > \verbatim   
   >          G is DOUBLE PRECISION   
   >          The second component of vector to be rotated.   
   > \endverbatim   
   >   
   > \param[out] CS   
   > \verbatim   
   >          CS is DOUBLE PRECISION   
   >          The cosine of the rotation.   
   > \endverbatim   
   >   
   > \param[out] SN   
   > \verbatim   
   >          SN is DOUBLE PRECISION   
   >          The sine of the rotation.   
   > \endverbatim   
   >   
   > \param[out] R   
   > \verbatim   
   >          R is DOUBLE PRECISION   
   >          The nonzero component of the rotated vector.   
   >   
   >  This version has a few statements commented out for thread safety   
   >  (machine parameters are computed on each entry). 10 feb 03, SJH.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlartg_(doublereal *f, doublereal *g, doublereal *cs, 
	doublereal *sn, doublereal *r__)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double log(doublereal), pow_di(doublereal *, integer *), sqrt(doublereal);

    /* Local variables */
    integer i__;
    doublereal f1, g1, eps, scale;
    integer count;
    doublereal safmn2, safmx2;
    extern doublereal igraphdlamch_(char *);
    doublereal safmin;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   

       LOGICAL            FIRST   
       SAVE               FIRST, SAFMX2, SAFMIN, SAFMN2   
       DATA               FIRST / .TRUE. /   

       IF( FIRST ) THEN */
    safmin = igraphdlamch_("S");
    eps = igraphdlamch_("E");
    d__1 = igraphdlamch_("B");
    i__1 = (integer) (log(safmin / eps) / log(igraphdlamch_("B")) / 2.);
    safmn2 = pow_di(&d__1, &i__1);
    safmx2 = 1. / safmn2;
/*        FIRST = .FALSE.   
       END IF */
    if (*g == 0.) {
	*cs = 1.;
	*sn = 0.;
	*r__ = *f;
    } else if (*f == 0.) {
	*cs = 0.;
	*sn = 1.;
	*r__ = *g;
    } else {
	f1 = *f;
	g1 = *g;
/* Computing MAX */
	d__1 = abs(f1), d__2 = abs(g1);
	scale = max(d__1,d__2);
	if (scale >= safmx2) {
	    count = 0;
L10:
	    ++count;
	    f1 *= safmn2;
	    g1 *= safmn2;
/* Computing MAX */
	    d__1 = abs(f1), d__2 = abs(g1);
	    scale = max(d__1,d__2);
	    if (scale >= safmx2) {
		goto L10;
	    }
/* Computing 2nd power */
	    d__1 = f1;
/* Computing 2nd power */
	    d__2 = g1;
	    *r__ = sqrt(d__1 * d__1 + d__2 * d__2);
	    *cs = f1 / *r__;
	    *sn = g1 / *r__;
	    i__1 = count;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		*r__ *= safmx2;
/* L20: */
	    }
	} else if (scale <= safmn2) {
	    count = 0;
L30:
	    ++count;
	    f1 *= safmx2;
	    g1 *= safmx2;
/* Computing MAX */
	    d__1 = abs(f1), d__2 = abs(g1);
	    scale = max(d__1,d__2);
	    if (scale <= safmn2) {
		goto L30;
	    }
/* Computing 2nd power */
	    d__1 = f1;
/* Computing 2nd power */
	    d__2 = g1;
	    *r__ = sqrt(d__1 * d__1 + d__2 * d__2);
	    *cs = f1 / *r__;
	    *sn = g1 / *r__;
	    i__1 = count;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		*r__ *= safmn2;
/* L40: */
	    }
	} else {
/* Computing 2nd power */
	    d__1 = f1;
/* Computing 2nd power */
	    d__2 = g1;
	    *r__ = sqrt(d__1 * d__1 + d__2 * d__2);
	    *cs = f1 / *r__;
	    *sn = g1 / *r__;
	}
	if (abs(*f) > abs(*g) && *cs < 0.) {
	    *cs = -(*cs);
	    *sn = -(*sn);
	    *r__ = -(*r__);
	}
    }
    return 0;

/*     End of DLARTG */

} /* igraphdlartg_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaruv.c0000644000175100001710000002034100000000000024043 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLARUV returns a vector of n random real numbers from a uniform distribution.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLARUV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLARUV( ISEED, N, X )   

         INTEGER            N   
         INTEGER            ISEED( 4 )   
         DOUBLE PRECISION   X( N )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLARUV returns a vector of n random real numbers from a uniform (0,1)   
   > distribution (n <= 128).   
   >   
   > This is an auxiliary routine called by DLARNV and ZLARNV.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in,out] ISEED   
   > \verbatim   
   >          ISEED is INTEGER array, dimension (4)   
   >          On entry, the seed of the random number generator; the array   
   >          elements must be between 0 and 4095, and ISEED(4) must be   
   >          odd.   
   >          On exit, the seed is updated.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of random numbers to be generated. N <= 128.   
   > \endverbatim   
   >   
   > \param[out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (N)   
   >          The generated random numbers.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  This routine uses a multiplicative congruential method with modulus   
   >  2**48 and multiplier 33952834046453 (see G.S.Fishman,   
   >  'Multiplicative congruential random number generators with modulus   
   >  2**b: an exhaustive analysis for b = 32 and a partial analysis for   
   >  b = 48', Math. Comp. 189, pp 331-344, 1990).   
   >   
   >  48-bit integers are stored in 4 integer array elements with 12 bits   
   >  per element. Hence the routine is portable across machines with   
   >  integers of 32 bits or more.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaruv_(integer *iseed, integer *n, doublereal *x)
{
    /* Initialized data */

    static integer mm[512]	/* was [128][4] */ = { 494,2637,255,2008,1253,
	    3344,4084,1739,3143,3468,688,1657,1238,3166,1292,3422,1270,2016,
	    154,2862,697,1706,491,931,1444,444,3577,3944,2184,1661,3482,657,
	    3023,3618,1267,1828,164,3798,3087,2400,2870,3876,1905,1593,1797,
	    1234,3460,328,2861,1950,617,2070,3331,769,1558,2412,2800,189,287,
	    2045,1227,2838,209,2770,3654,3993,192,2253,3491,2889,2857,2094,
	    1818,688,1407,634,3231,815,3524,1914,516,164,303,2144,3480,119,
	    3357,837,2826,2332,2089,3780,1700,3712,150,2000,3375,1621,3090,
	    3765,1149,3146,33,3082,2741,359,3316,1749,185,2784,2202,2199,1364,
	    1244,2020,3160,2785,2772,1217,1822,1245,2252,3904,2774,997,2573,
	    1148,545,322,789,1440,752,2859,123,1848,643,2405,2638,2344,46,
	    3814,913,3649,339,3808,822,2832,3078,3633,2970,637,2249,2081,4019,
	    1478,242,481,2075,4058,622,3376,812,234,641,4005,1122,3135,2640,
	    2302,40,1832,2247,2034,2637,1287,1691,496,1597,2394,2584,1843,336,
	    1472,2407,433,2096,1761,2810,566,442,41,1238,1086,603,840,3168,
	    1499,1084,3438,2408,1589,2391,288,26,512,1456,171,1677,2657,2270,
	    2587,2961,1970,1817,676,1410,3723,2803,3185,184,663,499,3784,1631,
	    1925,3912,1398,1349,1441,2224,2411,1907,3192,2786,382,37,759,2948,
	    1862,3802,2423,2051,2295,1332,1832,2405,3638,3661,327,3660,716,
	    1842,3987,1368,1848,2366,2508,3754,1766,3572,2893,307,1297,3966,
	    758,2598,3406,2922,1038,2934,2091,2451,1580,1958,2055,1507,1078,
	    3273,17,854,2916,3971,2889,3831,2621,1541,893,736,3992,787,2125,
	    2364,2460,257,1574,3912,1216,3248,3401,2124,2762,149,2245,166,466,
	    4018,1399,190,2879,153,2320,18,712,2159,2318,2091,3443,1510,449,
	    1956,2201,3137,3399,1321,2271,3667,2703,629,2365,2431,1113,3922,
	    2554,184,2099,3228,4012,1921,3452,3901,572,3309,3171,817,3039,
	    1696,1256,3715,2077,3019,1497,1101,717,51,981,1978,1813,3881,76,
	    3846,3694,1682,124,1660,3997,479,1141,886,3514,1301,3604,1888,
	    1836,1990,2058,692,1194,20,3285,2046,2107,3508,3525,3801,2549,
	    1145,2253,305,3301,1065,3133,2913,3285,1241,1197,3729,2501,1673,
	    541,2753,949,2361,1165,4081,2725,3305,3069,3617,3733,409,2157,
	    1361,3973,1865,2525,1409,3445,3577,77,3761,2149,1449,3005,225,85,
	    3673,3117,3089,1349,2057,413,65,1845,697,3085,3441,1573,3689,2941,
	    929,533,2841,4077,721,2821,2249,2397,2817,245,1913,1997,3121,997,
	    1833,2877,1633,981,2009,941,2449,197,2441,285,1473,2741,3129,909,
	    2801,421,4073,2813,2337,1429,1177,1901,81,1669,2633,2269,129,1141,
	    249,3917,2481,3941,2217,2749,3041,1877,345,2861,1809,3141,2825,
	    157,2881,3637,1465,2829,2161,3365,361,2685,3745,2325,3609,3821,
	    3537,517,3017,2141,1537 };

    /* System generated locals */
    integer i__1;

    /* Local variables */
    integer i__, i1, i2, i3, i4, it1, it2, it3, it4;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   

       Parameter adjustments */
    --iseed;
    --x;

    /* Function Body */

    i1 = iseed[1];
    i2 = iseed[2];
    i3 = iseed[3];
    i4 = iseed[4];

    i__1 = min(*n,128);
    for (i__ = 1; i__ <= i__1; ++i__) {

L20:

/*        Multiply the seed by i-th power of the multiplier modulo 2**48 */

	it4 = i4 * mm[i__ + 383];
	it3 = it4 / 4096;
	it4 -= it3 << 12;
	it3 = it3 + i3 * mm[i__ + 383] + i4 * mm[i__ + 255];
	it2 = it3 / 4096;
	it3 -= it2 << 12;
	it2 = it2 + i2 * mm[i__ + 383] + i3 * mm[i__ + 255] + i4 * mm[i__ + 
		127];
	it1 = it2 / 4096;
	it2 -= it1 << 12;
	it1 = it1 + i1 * mm[i__ + 383] + i2 * mm[i__ + 255] + i3 * mm[i__ + 
		127] + i4 * mm[i__ - 1];
	it1 %= 4096;

/*        Convert 48-bit integer to a real number in the interval (0,1) */

	x[i__] = ((doublereal) it1 + ((doublereal) it2 + ((doublereal) it3 + (
		doublereal) it4 * 2.44140625e-4) * 2.44140625e-4) * 
		2.44140625e-4) * 2.44140625e-4;

	if (x[i__] == 1.) {
/*           If a real number has n bits of precision, and the first   
             n bits of the 48-bit integer above happen to be all 1 (which   
             will occur about once every 2**n calls), then X( I ) will   
             be rounded to exactly 1.0.   
             Since X( I ) is not supposed to return exactly 0.0 or 1.0,   
             the statistically correct thing to do in this situation is   
             simply to iterate again.   
             N.B. the case X( I ) = 0.0 should not be possible. */
	    i1 += 2;
	    i2 += 2;
	    i3 += 2;
	    i4 += 2;
	    goto L20;
	}

/* L10: */
    }

/*     Return final value of seed */

    iseed[1] = it1;
    iseed[2] = it2;
    iseed[3] = it3;
    iseed[4] = it4;
    return 0;

/*     End of DLARUV */

} /* igraphdlaruv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlascl.c0000644000175100001710000002500100000000000024006 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASCL + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASCL( TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO )   

         CHARACTER          TYPE   
         INTEGER            INFO, KL, KU, LDA, M, N   
         DOUBLE PRECISION   CFROM, CTO   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASCL multiplies the M by N real matrix A by the real scalar   
   > CTO/CFROM.  This is done without over/underflow as long as the final   
   > result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that   
   > A may be full, upper triangular, lower triangular, upper Hessenberg,   
   > or banded.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] TYPE   
   > \verbatim   
   >          TYPE is CHARACTER*1   
   >          TYPE indices the storage type of the input matrix.   
   >          = 'G':  A is a full matrix.   
   >          = 'L':  A is a lower triangular matrix.   
   >          = 'U':  A is an upper triangular matrix.   
   >          = 'H':  A is an upper Hessenberg matrix.   
   >          = 'B':  A is a symmetric band matrix with lower bandwidth KL   
   >                  and upper bandwidth KU and with the only the lower   
   >                  half stored.   
   >          = 'Q':  A is a symmetric band matrix with lower bandwidth KL   
   >                  and upper bandwidth KU and with the only the upper   
   >                  half stored.   
   >          = 'Z':  A is a band matrix with lower bandwidth KL and upper   
   >                  bandwidth KU. See DGBTRF for storage details.   
   > \endverbatim   
   >   
   > \param[in] KL   
   > \verbatim   
   >          KL is INTEGER   
   >          The lower bandwidth of A.  Referenced only if TYPE = 'B',   
   >          'Q' or 'Z'.   
   > \endverbatim   
   >   
   > \param[in] KU   
   > \verbatim   
   >          KU is INTEGER   
   >          The upper bandwidth of A.  Referenced only if TYPE = 'B',   
   >          'Q' or 'Z'.   
   > \endverbatim   
   >   
   > \param[in] CFROM   
   > \verbatim   
   >          CFROM is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] CTO   
   > \verbatim   
   >          CTO is DOUBLE PRECISION   
   >   
   >          The matrix A is multiplied by CTO/CFROM. A(I,J) is computed   
   >          without over/underflow if the final result CTO*A(I,J)/CFROM   
   >          can be represented without over/underflow.  CFROM must be   
   >          nonzero.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The matrix to be multiplied by CTO/CFROM.  See TYPE for the   
   >          storage type.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          0  - successful exit   
   >          <0 - if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlascl_(char *type__, integer *kl, integer *ku, 
	doublereal *cfrom, doublereal *cto, integer *m, integer *n, 
	doublereal *a, integer *lda, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;

    /* Local variables */
    integer i__, j, k1, k2, k3, k4;
    doublereal mul, cto1;
    logical done;
    doublereal ctoc;
    extern logical igraphlsame_(char *, char *);
    integer itype;
    doublereal cfrom1;
    extern doublereal igraphdlamch_(char *);
    doublereal cfromc;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum, smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    *info = 0;

    if (igraphlsame_(type__, "G")) {
	itype = 0;
    } else if (igraphlsame_(type__, "L")) {
	itype = 1;
    } else if (igraphlsame_(type__, "U")) {
	itype = 2;
    } else if (igraphlsame_(type__, "H")) {
	itype = 3;
    } else if (igraphlsame_(type__, "B")) {
	itype = 4;
    } else if (igraphlsame_(type__, "Q")) {
	itype = 5;
    } else if (igraphlsame_(type__, "Z")) {
	itype = 6;
    } else {
	itype = -1;
    }

    if (itype == -1) {
	*info = -1;
    } else if (*cfrom == 0. || igraphdisnan_(cfrom)) {
	*info = -4;
    } else if (igraphdisnan_(cto)) {
	*info = -5;
    } else if (*m < 0) {
	*info = -6;
    } else if (*n < 0 || itype == 4 && *n != *m || itype == 5 && *n != *m) {
	*info = -7;
    } else if (itype <= 3 && *lda < max(1,*m)) {
	*info = -9;
    } else if (itype >= 4) {
/* Computing MAX */
	i__1 = *m - 1;
	if (*kl < 0 || *kl > max(i__1,0)) {
	    *info = -2;
	} else /* if(complicated condition) */ {
/* Computing MAX */
	    i__1 = *n - 1;
	    if (*ku < 0 || *ku > max(i__1,0) || (itype == 4 || itype == 5) && 
		    *kl != *ku) {
		*info = -3;
	    } else if (itype == 4 && *lda < *kl + 1 || itype == 5 && *lda < *
		    ku + 1 || itype == 6 && *lda < (*kl << 1) + *ku + 1) {
		*info = -9;
	    }
	}
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DLASCL", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0 || *m == 0) {
	return 0;
    }

/*     Get machine parameters */

    smlnum = igraphdlamch_("S");
    bignum = 1. / smlnum;

    cfromc = *cfrom;
    ctoc = *cto;

L10:
    cfrom1 = cfromc * smlnum;
    if (cfrom1 == cfromc) {
/*        CFROMC is an inf.  Multiply by a correctly signed zero for   
          finite CTOC, or a NaN if CTOC is infinite. */
	mul = ctoc / cfromc;
	done = TRUE_;
	cto1 = ctoc;
    } else {
	cto1 = ctoc / bignum;
	if (cto1 == ctoc) {
/*           CTOC is either 0 or an inf.  In both cases, CTOC itself   
             serves as the correct multiplication factor. */
	    mul = ctoc;
	    done = TRUE_;
	    cfromc = 1.;
	} else if (abs(cfrom1) > abs(ctoc) && ctoc != 0.) {
	    mul = smlnum;
	    done = FALSE_;
	    cfromc = cfrom1;
	} else if (abs(cto1) > abs(cfromc)) {
	    mul = bignum;
	    done = FALSE_;
	    ctoc = cto1;
	} else {
	    mul = ctoc / cfromc;
	    done = TRUE_;
	}
    }

    if (itype == 0) {

/*        Full matrix */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L20: */
	    }
/* L30: */
	}

    } else if (itype == 1) {

/*        Lower triangular matrix */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = j; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L40: */
	    }
/* L50: */
	}

    } else if (itype == 2) {

/*        Upper triangular matrix */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = min(j,*m);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L60: */
	    }
/* L70: */
	}

    } else if (itype == 3) {

/*        Upper Hessenberg matrix */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = j + 1;
	    i__2 = min(i__3,*m);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L80: */
	    }
/* L90: */
	}

    } else if (itype == 4) {

/*        Lower half of a symmetric band matrix */

	k3 = *kl + 1;
	k4 = *n + 1;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = k3, i__4 = k4 - j;
	    i__2 = min(i__3,i__4);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L100: */
	    }
/* L110: */
	}

    } else if (itype == 5) {

/*        Upper half of a symmetric band matrix */

	k1 = *ku + 2;
	k3 = *ku + 1;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    i__2 = k1 - j;
	    i__3 = k3;
	    for (i__ = max(i__2,1); i__ <= i__3; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L120: */
	    }
/* L130: */
	}

    } else if (itype == 6) {

/*        Band matrix */

	k1 = *kl + *ku + 2;
	k2 = *kl + 1;
	k3 = (*kl << 1) + *ku + 1;
	k4 = *kl + *ku + 1 + *m;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    i__3 = k1 - j;
/* Computing MIN */
	    i__4 = k3, i__5 = k4 - j;
	    i__2 = min(i__4,i__5);
	    for (i__ = max(i__3,k2); i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] *= mul;
/* L140: */
	    }
/* L150: */
	}

    }

    if (! done) {
	goto L10;
    }

    return 0;

/*     End of DLASCL */

} /* igraphdlascl_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaset.c0000644000175100001710000001337500000000000024033 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given val
ues.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASET + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASET( UPLO, M, N, ALPHA, BETA, A, LDA )   

         CHARACTER          UPLO   
         INTEGER            LDA, M, N   
         DOUBLE PRECISION   ALPHA, BETA   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASET initializes an m-by-n matrix A to BETA on the diagonal and   
   > ALPHA on the offdiagonals.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies the part of the matrix A to be set.   
   >          = 'U':      Upper triangular part is set; the strictly lower   
   >                      triangular part of A is not changed.   
   >          = 'L':      Lower triangular part is set; the strictly upper   
   >                      triangular part of A is not changed.   
   >          Otherwise:  All of the matrix A is set.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION   
   >          The constant to which the offdiagonal elements are to be set.   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION   
   >          The constant to which the diagonal elements are to be set.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On exit, the leading m-by-n submatrix of A is set as follows:   
   >   
   >          if UPLO = 'U', A(i,j) = ALPHA, 1<=i<=j-1, 1<=j<=n,   
   >          if UPLO = 'L', A(i,j) = ALPHA, j+1<=i<=m, 1<=j<=n,   
   >          otherwise,     A(i,j) = ALPHA, 1<=i<=m, 1<=j<=n, i.ne.j,   
   >   
   >          and, for all UPLO, A(i,i) = BETA, 1<=i<=min(m,n).   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlaset_(char *uplo, integer *m, integer *n, doublereal *
	alpha, doublereal *beta, doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j;
    extern logical igraphlsame_(char *, char *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    if (igraphlsame_(uplo, "U")) {

/*        Set the strictly upper triangular or trapezoidal part of the   
          array to ALPHA. */

	i__1 = *n;
	for (j = 2; j <= i__1; ++j) {
/* Computing MIN */
	    i__3 = j - 1;
	    i__2 = min(i__3,*m);
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] = *alpha;
/* L10: */
	    }
/* L20: */
	}

    } else if (igraphlsame_(uplo, "L")) {

/*        Set the strictly lower triangular or trapezoidal part of the   
          array to ALPHA. */

	i__1 = min(*m,*n);
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = j + 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] = *alpha;
/* L30: */
	    }
/* L40: */
	}

    } else {

/*        Set the leading m-by-n submatrix to ALPHA. */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] = *alpha;
/* L50: */
	    }
/* L60: */
	}
    }

/*     Set the first min(M,N) diagonal elements to BETA. */

    i__1 = min(*m,*n);
    for (i__ = 1; i__ <= i__1; ++i__) {
	a[i__ + i__ * a_dim1] = *beta;
/* L70: */
    }

    return 0;

/*     End of DLASET */

} /* igraphdlaset_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasq2.c0000644000175100001710000004337600000000000023751 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__2 = 2;
static integer c__10 = 10;
static integer c__3 = 3;
static integer c__4 = 4;
static integer c__11 = 11;

/* > \brief \b DLASQ2 computes all the eigenvalues of the symmetric positive definite tridiagonal matrix assoc
iated with the qd Array Z to high relative accuracy. Used by sbdsqr and sstegr.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASQ2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASQ2( N, Z, INFO )   

         INTEGER            INFO, N   
         DOUBLE PRECISION   Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASQ2 computes all the eigenvalues of the symmetric positive   
   > definite tridiagonal matrix associated with the qd array Z to high   
   > relative accuracy are computed to high relative accuracy, in the   
   > absence of denormalization, underflow and overflow.   
   >   
   > To see the relation of Z to the tridiagonal matrix, let L be a   
   > unit lower bidiagonal matrix with subdiagonals Z(2,4,6,,..) and   
   > let U be an upper bidiagonal matrix with 1's above and diagonal   
   > Z(1,3,5,,..). The tridiagonal is L*U or, if you prefer, the   
   > symmetric tridiagonal to which it is similar.   
   >   
   > Note : DLASQ2 defines a logical variable, IEEE, which is true   
   > on machines which follow ieee-754 floating-point standard in their   
   > handling of infinities and NaNs, and false otherwise. This variable   
   > is passed to DLASQ3.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >        The number of rows and columns in the matrix. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension ( 4*N )   
   >        On entry Z holds the qd array. On exit, entries 1 to N hold   
   >        the eigenvalues in decreasing order, Z( 2*N+1 ) holds the   
   >        trace, and Z( 2*N+2 ) holds the sum of the eigenvalues. If   
   >        N > 2, then Z( 2*N+3 ) holds the iteration count, Z( 2*N+4 )   
   >        holds NDIVS/NIN^2, and Z( 2*N+5 ) holds the percentage of   
   >        shifts that failed.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >        = 0: successful exit   
   >        < 0: if the i-th argument is a scalar and had an illegal   
   >             value, then INFO = -i, if the i-th argument is an   
   >             array and the j-entry had an illegal value, then   
   >             INFO = -(i*100+j)   
   >        > 0: the algorithm failed   
   >              = 1, a split was marked by a positive value in E   
   >              = 2, current block of Z not diagonalized after 100*N   
   >                   iterations (in inner while loop).  On exit Z holds   
   >                   a qd array with the same eigenvalues as the given Z.   
   >              = 3, termination criterion of outer while loop not met   
   >                   (program created more than N unreduced blocks)   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Local Variables: I0:N0 defines a current unreduced segment of Z.   
   >  The shifts are accumulated in SIGMA. Iteration count is in ITER.   
   >  Ping-pong is controlled by PP (alternates between 0 and 1).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlasq2_(integer *n, doublereal *z__, integer *info)
{
    /* System generated locals */
    integer i__1, i__2, i__3;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal d__, e, g;
    integer k;
    doublereal s, t;
    integer i0, i1, i4, n0, n1;
    doublereal dn;
    integer pp;
    doublereal dn1, dn2, dee, eps, tau, tol;
    integer ipn4;
    doublereal tol2;
    logical ieee;
    integer nbig;
    doublereal dmin__, emin, emax;
    integer kmin, ndiv, iter;
    doublereal qmin, temp, qmax, zmax;
    integer splt;
    doublereal dmin1, dmin2;
    integer nfail;
    doublereal desig, trace, sigma;
    integer iinfo;
    doublereal tempe, tempq;
    integer ttype;
    extern /* Subroutine */ int igraphdlasq3_(integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
	     integer *, integer *, integer *, logical *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    doublereal deemin;
    integer iwhila, iwhilb;
    doublereal oldemn, safmin;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphdlasrt_(char *, integer *, doublereal *, 
	    integer *);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments.   
       (in case DLASQ2 is not called by DLASQ1)   

       Parameter adjustments */
    --z__;

    /* Function Body */
    *info = 0;
    eps = igraphdlamch_("Precision");
    safmin = igraphdlamch_("Safe minimum");
    tol = eps * 100.;
/* Computing 2nd power */
    d__1 = tol;
    tol2 = d__1 * d__1;

    if (*n < 0) {
	*info = -1;
	igraphxerbla_("DLASQ2", &c__1, (ftnlen)6);
	return 0;
    } else if (*n == 0) {
	return 0;
    } else if (*n == 1) {

/*        1-by-1 case. */

	if (z__[1] < 0.) {
	    *info = -201;
	    igraphxerbla_("DLASQ2", &c__2, (ftnlen)6);
	}
	return 0;
    } else if (*n == 2) {

/*        2-by-2 case. */

	if (z__[2] < 0. || z__[3] < 0.) {
	    *info = -2;
	    igraphxerbla_("DLASQ2", &c__2, (ftnlen)6);
	    return 0;
	} else if (z__[3] > z__[1]) {
	    d__ = z__[3];
	    z__[3] = z__[1];
	    z__[1] = d__;
	}
	z__[5] = z__[1] + z__[2] + z__[3];
	if (z__[2] > z__[3] * tol2) {
	    t = (z__[1] - z__[3] + z__[2]) * .5;
	    s = z__[3] * (z__[2] / t);
	    if (s <= t) {
		s = z__[3] * (z__[2] / (t * (sqrt(s / t + 1.) + 1.)));
	    } else {
		s = z__[3] * (z__[2] / (t + sqrt(t) * sqrt(t + s)));
	    }
	    t = z__[1] + (s + z__[2]);
	    z__[3] *= z__[1] / t;
	    z__[1] = t;
	}
	z__[2] = z__[3];
	z__[6] = z__[2] + z__[1];
	return 0;
    }

/*     Check for negative data and compute sums of q's and e's. */

    z__[*n * 2] = 0.;
    emin = z__[2];
    qmax = 0.;
    zmax = 0.;
    d__ = 0.;
    e = 0.;

    i__1 = *n - 1 << 1;
    for (k = 1; k <= i__1; k += 2) {
	if (z__[k] < 0.) {
	    *info = -(k + 200);
	    igraphxerbla_("DLASQ2", &c__2, (ftnlen)6);
	    return 0;
	} else if (z__[k + 1] < 0.) {
	    *info = -(k + 201);
	    igraphxerbla_("DLASQ2", &c__2, (ftnlen)6);
	    return 0;
	}
	d__ += z__[k];
	e += z__[k + 1];
/* Computing MAX */
	d__1 = qmax, d__2 = z__[k];
	qmax = max(d__1,d__2);
/* Computing MIN */
	d__1 = emin, d__2 = z__[k + 1];
	emin = min(d__1,d__2);
/* Computing MAX */
	d__1 = max(qmax,zmax), d__2 = z__[k + 1];
	zmax = max(d__1,d__2);
/* L10: */
    }
    if (z__[(*n << 1) - 1] < 0.) {
	*info = -((*n << 1) + 199);
	igraphxerbla_("DLASQ2", &c__2, (ftnlen)6);
	return 0;
    }
    d__ += z__[(*n << 1) - 1];
/* Computing MAX */
    d__1 = qmax, d__2 = z__[(*n << 1) - 1];
    qmax = max(d__1,d__2);
    zmax = max(qmax,zmax);

/*     Check for diagonality. */

    if (e == 0.) {
	i__1 = *n;
	for (k = 2; k <= i__1; ++k) {
	    z__[k] = z__[(k << 1) - 1];
/* L20: */
	}
	igraphdlasrt_("D", n, &z__[1], &iinfo);
	z__[(*n << 1) - 1] = d__;
	return 0;
    }

    trace = d__ + e;

/*     Check for zero data. */

    if (trace == 0.) {
	z__[(*n << 1) - 1] = 0.;
	return 0;
    }

/*     Check whether the machine is IEEE conformable. */

    ieee = igraphilaenv_(&c__10, "DLASQ2", "N", &c__1, &c__2, &c__3, &c__4, (ftnlen)
	    6, (ftnlen)1) == 1 && igraphilaenv_(&c__11, "DLASQ2", "N", &c__1, &c__2,
	     &c__3, &c__4, (ftnlen)6, (ftnlen)1) == 1;

/*     Rearrange data for locality: Z=(q1,qq1,e1,ee1,q2,qq2,e2,ee2,...). */

    for (k = *n << 1; k >= 2; k += -2) {
	z__[k * 2] = 0.;
	z__[(k << 1) - 1] = z__[k];
	z__[(k << 1) - 2] = 0.;
	z__[(k << 1) - 3] = z__[k - 1];
/* L30: */
    }

    i0 = 1;
    n0 = *n;

/*     Reverse the qd-array, if warranted. */

    if (z__[(i0 << 2) - 3] * 1.5 < z__[(n0 << 2) - 3]) {
	ipn4 = i0 + n0 << 2;
	i__1 = i0 + n0 - 1 << 1;
	for (i4 = i0 << 2; i4 <= i__1; i4 += 4) {
	    temp = z__[i4 - 3];
	    z__[i4 - 3] = z__[ipn4 - i4 - 3];
	    z__[ipn4 - i4 - 3] = temp;
	    temp = z__[i4 - 1];
	    z__[i4 - 1] = z__[ipn4 - i4 - 5];
	    z__[ipn4 - i4 - 5] = temp;
/* L40: */
	}
    }

/*     Initial split checking via dqd and Li's test. */

    pp = 0;

    for (k = 1; k <= 2; ++k) {

	d__ = z__[(n0 << 2) + pp - 3];
	i__1 = (i0 << 2) + pp;
	for (i4 = (n0 - 1 << 2) + pp; i4 >= i__1; i4 += -4) {
	    if (z__[i4 - 1] <= tol2 * d__) {
		z__[i4 - 1] = -0.;
		d__ = z__[i4 - 3];
	    } else {
		d__ = z__[i4 - 3] * (d__ / (d__ + z__[i4 - 1]));
	    }
/* L50: */
	}

/*        dqd maps Z to ZZ plus Li's test. */

	emin = z__[(i0 << 2) + pp + 1];
	d__ = z__[(i0 << 2) + pp - 3];
	i__1 = (n0 - 1 << 2) + pp;
	for (i4 = (i0 << 2) + pp; i4 <= i__1; i4 += 4) {
	    z__[i4 - (pp << 1) - 2] = d__ + z__[i4 - 1];
	    if (z__[i4 - 1] <= tol2 * d__) {
		z__[i4 - 1] = -0.;
		z__[i4 - (pp << 1) - 2] = d__;
		z__[i4 - (pp << 1)] = 0.;
		d__ = z__[i4 + 1];
	    } else if (safmin * z__[i4 + 1] < z__[i4 - (pp << 1) - 2] && 
		    safmin * z__[i4 - (pp << 1) - 2] < z__[i4 + 1]) {
		temp = z__[i4 + 1] / z__[i4 - (pp << 1) - 2];
		z__[i4 - (pp << 1)] = z__[i4 - 1] * temp;
		d__ *= temp;
	    } else {
		z__[i4 - (pp << 1)] = z__[i4 + 1] * (z__[i4 - 1] / z__[i4 - (
			pp << 1) - 2]);
		d__ = z__[i4 + 1] * (d__ / z__[i4 - (pp << 1) - 2]);
	    }
/* Computing MIN */
	    d__1 = emin, d__2 = z__[i4 - (pp << 1)];
	    emin = min(d__1,d__2);
/* L60: */
	}
	z__[(n0 << 2) - pp - 2] = d__;

/*        Now find qmax. */

	qmax = z__[(i0 << 2) - pp - 2];
	i__1 = (n0 << 2) - pp - 2;
	for (i4 = (i0 << 2) - pp + 2; i4 <= i__1; i4 += 4) {
/* Computing MAX */
	    d__1 = qmax, d__2 = z__[i4];
	    qmax = max(d__1,d__2);
/* L70: */
	}

/*        Prepare for the next iteration on K. */

	pp = 1 - pp;
/* L80: */
    }

/*     Initialise variables to pass to DLASQ3. */

    ttype = 0;
    dmin1 = 0.;
    dmin2 = 0.;
    dn = 0.;
    dn1 = 0.;
    dn2 = 0.;
    g = 0.;
    tau = 0.;

    iter = 2;
    nfail = 0;
    ndiv = n0 - i0 << 1;

    i__1 = *n + 1;
    for (iwhila = 1; iwhila <= i__1; ++iwhila) {
	if (n0 < 1) {
	    goto L170;
	}

/*        While array unfinished do   

          E(N0) holds the value of SIGMA when submatrix in I0:N0   
          splits from the rest of the array, but is negated. */

	desig = 0.;
	if (n0 == *n) {
	    sigma = 0.;
	} else {
	    sigma = -z__[(n0 << 2) - 1];
	}
	if (sigma < 0.) {
	    *info = 1;
	    return 0;
	}

/*        Find last unreduced submatrix's top index I0, find QMAX and   
          EMIN. Find Gershgorin-type bound if Q's much greater than E's. */

	emax = 0.;
	if (n0 > i0) {
	    emin = (d__1 = z__[(n0 << 2) - 5], abs(d__1));
	} else {
	    emin = 0.;
	}
	qmin = z__[(n0 << 2) - 3];
	qmax = qmin;
	for (i4 = n0 << 2; i4 >= 8; i4 += -4) {
	    if (z__[i4 - 5] <= 0.) {
		goto L100;
	    }
	    if (qmin >= emax * 4.) {
/* Computing MIN */
		d__1 = qmin, d__2 = z__[i4 - 3];
		qmin = min(d__1,d__2);
/* Computing MAX */
		d__1 = emax, d__2 = z__[i4 - 5];
		emax = max(d__1,d__2);
	    }
/* Computing MAX */
	    d__1 = qmax, d__2 = z__[i4 - 7] + z__[i4 - 5];
	    qmax = max(d__1,d__2);
/* Computing MIN */
	    d__1 = emin, d__2 = z__[i4 - 5];
	    emin = min(d__1,d__2);
/* L90: */
	}
	i4 = 4;

L100:
	i0 = i4 / 4;
	pp = 0;

	if (n0 - i0 > 1) {
	    dee = z__[(i0 << 2) - 3];
	    deemin = dee;
	    kmin = i0;
	    i__2 = (n0 << 2) - 3;
	    for (i4 = (i0 << 2) + 1; i4 <= i__2; i4 += 4) {
		dee = z__[i4] * (dee / (dee + z__[i4 - 2]));
		if (dee <= deemin) {
		    deemin = dee;
		    kmin = (i4 + 3) / 4;
		}
/* L110: */
	    }
	    if (kmin - i0 << 1 < n0 - kmin && deemin <= z__[(n0 << 2) - 3] * 
		    .5) {
		ipn4 = i0 + n0 << 2;
		pp = 2;
		i__2 = i0 + n0 - 1 << 1;
		for (i4 = i0 << 2; i4 <= i__2; i4 += 4) {
		    temp = z__[i4 - 3];
		    z__[i4 - 3] = z__[ipn4 - i4 - 3];
		    z__[ipn4 - i4 - 3] = temp;
		    temp = z__[i4 - 2];
		    z__[i4 - 2] = z__[ipn4 - i4 - 2];
		    z__[ipn4 - i4 - 2] = temp;
		    temp = z__[i4 - 1];
		    z__[i4 - 1] = z__[ipn4 - i4 - 5];
		    z__[ipn4 - i4 - 5] = temp;
		    temp = z__[i4];
		    z__[i4] = z__[ipn4 - i4 - 4];
		    z__[ipn4 - i4 - 4] = temp;
/* L120: */
		}
	    }
	}

/*        Put -(initial shift) into DMIN.   

   Computing MAX */
	d__1 = 0., d__2 = qmin - sqrt(qmin) * 2. * sqrt(emax);
	dmin__ = -max(d__1,d__2);

/*        Now I0:N0 is unreduced.   
          PP = 0 for ping, PP = 1 for pong.   
          PP = 2 indicates that flipping was applied to the Z array and   
                 and that the tests for deflation upon entry in DLASQ3   
                 should not be performed. */

	nbig = (n0 - i0 + 1) * 100;
	i__2 = nbig;
	for (iwhilb = 1; iwhilb <= i__2; ++iwhilb) {
	    if (i0 > n0) {
		goto L150;
	    }

/*           While submatrix unfinished take a good dqds step. */

	    igraphdlasq3_(&i0, &n0, &z__[1], &pp, &dmin__, &sigma, &desig, &qmax, &
		    nfail, &iter, &ndiv, &ieee, &ttype, &dmin1, &dmin2, &dn, &
		    dn1, &dn2, &g, &tau);

	    pp = 1 - pp;

/*           When EMIN is very small check for splits. */

	    if (pp == 0 && n0 - i0 >= 3) {
		if (z__[n0 * 4] <= tol2 * qmax || z__[(n0 << 2) - 1] <= tol2 *
			 sigma) {
		    splt = i0 - 1;
		    qmax = z__[(i0 << 2) - 3];
		    emin = z__[(i0 << 2) - 1];
		    oldemn = z__[i0 * 4];
		    i__3 = n0 - 3 << 2;
		    for (i4 = i0 << 2; i4 <= i__3; i4 += 4) {
			if (z__[i4] <= tol2 * z__[i4 - 3] || z__[i4 - 1] <= 
				tol2 * sigma) {
			    z__[i4 - 1] = -sigma;
			    splt = i4 / 4;
			    qmax = 0.;
			    emin = z__[i4 + 3];
			    oldemn = z__[i4 + 4];
			} else {
/* Computing MAX */
			    d__1 = qmax, d__2 = z__[i4 + 1];
			    qmax = max(d__1,d__2);
/* Computing MIN */
			    d__1 = emin, d__2 = z__[i4 - 1];
			    emin = min(d__1,d__2);
/* Computing MIN */
			    d__1 = oldemn, d__2 = z__[i4];
			    oldemn = min(d__1,d__2);
			}
/* L130: */
		    }
		    z__[(n0 << 2) - 1] = emin;
		    z__[n0 * 4] = oldemn;
		    i0 = splt + 1;
		}
	    }

/* L140: */
	}

	*info = 2;

/*        Maximum number of iterations exceeded, restore the shift   
          SIGMA and place the new d's and e's in a qd array.   
          This might need to be done for several blocks */

	i1 = i0;
	n1 = n0;
L145:
	tempq = z__[(i0 << 2) - 3];
	z__[(i0 << 2) - 3] += sigma;
	i__2 = n0;
	for (k = i0 + 1; k <= i__2; ++k) {
	    tempe = z__[(k << 2) - 5];
	    z__[(k << 2) - 5] *= tempq / z__[(k << 2) - 7];
	    tempq = z__[(k << 2) - 3];
	    z__[(k << 2) - 3] = z__[(k << 2) - 3] + sigma + tempe - z__[(k << 
		    2) - 5];
	}

/*        Prepare to do this on the previous block if there is one */

	if (i1 > 1) {
	    n1 = i1 - 1;
	    while(i1 >= 2 && z__[(i1 << 2) - 5] >= 0.) {
		--i1;
	    }
	    sigma = -z__[(n1 << 2) - 1];
	    goto L145;
	}
	i__2 = *n;
	for (k = 1; k <= i__2; ++k) {
	    z__[(k << 1) - 1] = z__[(k << 2) - 3];

/*        Only the block 1..N0 is unfinished.  The rest of the e's   
          must be essentially zero, although sometimes other data   
          has been stored in them. */

	    if (k < n0) {
		z__[k * 2] = z__[(k << 2) - 1];
	    } else {
		z__[k * 2] = 0.;
	    }
	}
	return 0;

/*        end IWHILB */

L150:

/* L160: */
	;
    }

    *info = 3;
    return 0;

/*     end IWHILA */

L170:

/*     Move q's to the front. */

    i__1 = *n;
    for (k = 2; k <= i__1; ++k) {
	z__[k] = z__[(k << 2) - 3];
/* L180: */
    }

/*     Sort and compute sum of eigenvalues. */

    igraphdlasrt_("D", n, &z__[1], &iinfo);

    e = 0.;
    for (k = *n; k >= 1; --k) {
	e += z__[k];
/* L190: */
    }

/*     Store trace, sum(eigenvalues) and information on performance. */

    z__[(*n << 1) + 1] = trace;
    z__[(*n << 1) + 2] = e;
    z__[(*n << 1) + 3] = (doublereal) iter;
/* Computing 2nd power */
    i__1 = *n;
    z__[(*n << 1) + 4] = (doublereal) ndiv / (doublereal) (i__1 * i__1);
    z__[(*n << 1) + 5] = nfail * 100. / (doublereal) iter;
    return 0;

/*     End of DLASQ2 */

} /* igraphdlasq2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasq3.c0000644000175100001710000002714700000000000023750 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASQ3 checks for deflation, computes a shift and calls dqds. Used by sbdsqr.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASQ3 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASQ3( I0, N0, Z, PP, DMIN, SIGMA, DESIG, QMAX, NFAIL,   
                            ITER, NDIV, IEEE, TTYPE, DMIN1, DMIN2, DN, DN1,   
                            DN2, G, TAU )   

         LOGICAL            IEEE   
         INTEGER            I0, ITER, N0, NDIV, NFAIL, PP   
         DOUBLE PRECISION   DESIG, DMIN, DMIN1, DMIN2, DN, DN1, DN2, G,   
        $                   QMAX, SIGMA, TAU   
         DOUBLE PRECISION   Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASQ3 checks for deflation, computes a shift (TAU) and calls dqds.   
   > In case of failure it changes shifts, and tries again until output   
   > is positive.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] I0   
   > \verbatim   
   >          I0 is INTEGER   
   >         First index.   
   > \endverbatim   
   >   
   > \param[in,out] N0   
   > \verbatim   
   >          N0 is INTEGER   
   >         Last index.   
   > \endverbatim   
   >   
   > \param[in] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension ( 4*N )   
   >         Z holds the qd array.   
   > \endverbatim   
   >   
   > \param[in,out] PP   
   > \verbatim   
   >          PP is INTEGER   
   >         PP=0 for ping, PP=1 for pong.   
   >         PP=2 indicates that flipping was applied to the Z array   
   >         and that the initial tests for deflation should not be   
   >         performed.   
   > \endverbatim   
   >   
   > \param[out] DMIN   
   > \verbatim   
   >          DMIN is DOUBLE PRECISION   
   >         Minimum value of d.   
   > \endverbatim   
   >   
   > \param[out] SIGMA   
   > \verbatim   
   >          SIGMA is DOUBLE PRECISION   
   >         Sum of shifts used in current segment.   
   > \endverbatim   
   >   
   > \param[in,out] DESIG   
   > \verbatim   
   >          DESIG is DOUBLE PRECISION   
   >         Lower order part of SIGMA   
   > \endverbatim   
   >   
   > \param[in] QMAX   
   > \verbatim   
   >          QMAX is DOUBLE PRECISION   
   >         Maximum value of q.   
   > \endverbatim   
   >   
   > \param[out] NFAIL   
   > \verbatim   
   >          NFAIL is INTEGER   
   >         Number of times shift was too big.   
   > \endverbatim   
   >   
   > \param[out] ITER   
   > \verbatim   
   >          ITER is INTEGER   
   >         Number of iterations.   
   > \endverbatim   
   >   
   > \param[out] NDIV   
   > \verbatim   
   >          NDIV is INTEGER   
   >         Number of divisions.   
   > \endverbatim   
   >   
   > \param[in] IEEE   
   > \verbatim   
   >          IEEE is LOGICAL   
   >         Flag for IEEE or non IEEE arithmetic (passed to DLASQ5).   
   > \endverbatim   
   >   
   > \param[in,out] TTYPE   
   > \verbatim   
   >          TTYPE is INTEGER   
   >         Shift type.   
   > \endverbatim   
   >   
   > \param[in,out] DMIN1   
   > \verbatim   
   >          DMIN1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] DMIN2   
   > \verbatim   
   >          DMIN2 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] DN   
   > \verbatim   
   >          DN is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] DN1   
   > \verbatim   
   >          DN1 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] DN2   
   > \verbatim   
   >          DN2 is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] G   
   > \verbatim   
   >          G is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in,out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >   
   >         These are passed as arguments in order to save their values   
   >         between calls to DLASQ3.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdlasq3_(integer *i0, integer *n0, doublereal *z__, 
	integer *pp, doublereal *dmin__, doublereal *sigma, doublereal *desig,
	 doublereal *qmax, integer *nfail, integer *iter, integer *ndiv, 
	logical *ieee, integer *ttype, doublereal *dmin1, doublereal *dmin2, 
	doublereal *dn, doublereal *dn1, doublereal *dn2, doublereal *g, 
	doublereal *tau)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal s, t;
    integer j4, nn;
    doublereal eps, tol;
    integer n0in, ipn4;
    doublereal tol2, temp;
    extern /* Subroutine */ int igraphdlasq4_(integer *, integer *, doublereal *, 
	    integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     doublereal *), igraphdlasq5_(integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
	     doublereal *, doublereal *, doublereal *, doublereal *, logical *
	    , doublereal *), igraphdlasq6_(integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
	     doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern logical igraphdisnan_(doublereal *);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --z__;

    /* Function Body */
    n0in = *n0;
    eps = igraphdlamch_("Precision");
    tol = eps * 100.;
/* Computing 2nd power */
    d__1 = tol;
    tol2 = d__1 * d__1;

/*     Check for deflation. */

L10:

    if (*n0 < *i0) {
	return 0;
    }
    if (*n0 == *i0) {
	goto L20;
    }
    nn = (*n0 << 2) + *pp;
    if (*n0 == *i0 + 1) {
	goto L40;
    }

/*     Check whether E(N0-1) is negligible, 1 eigenvalue. */

    if (z__[nn - 5] > tol2 * (*sigma + z__[nn - 3]) && z__[nn - (*pp << 1) - 
	    4] > tol2 * z__[nn - 7]) {
	goto L30;
    }

L20:

    z__[(*n0 << 2) - 3] = z__[(*n0 << 2) + *pp - 3] + *sigma;
    --(*n0);
    goto L10;

/*     Check  whether E(N0-2) is negligible, 2 eigenvalues. */

L30:

    if (z__[nn - 9] > tol2 * *sigma && z__[nn - (*pp << 1) - 8] > tol2 * z__[
	    nn - 11]) {
	goto L50;
    }

L40:

    if (z__[nn - 3] > z__[nn - 7]) {
	s = z__[nn - 3];
	z__[nn - 3] = z__[nn - 7];
	z__[nn - 7] = s;
    }
    t = (z__[nn - 7] - z__[nn - 3] + z__[nn - 5]) * .5;
    if (z__[nn - 5] > z__[nn - 3] * tol2 && t != 0.) {
	s = z__[nn - 3] * (z__[nn - 5] / t);
	if (s <= t) {
	    s = z__[nn - 3] * (z__[nn - 5] / (t * (sqrt(s / t + 1.) + 1.)));
	} else {
	    s = z__[nn - 3] * (z__[nn - 5] / (t + sqrt(t) * sqrt(t + s)));
	}
	t = z__[nn - 7] + (s + z__[nn - 5]);
	z__[nn - 3] *= z__[nn - 7] / t;
	z__[nn - 7] = t;
    }
    z__[(*n0 << 2) - 7] = z__[nn - 7] + *sigma;
    z__[(*n0 << 2) - 3] = z__[nn - 3] + *sigma;
    *n0 += -2;
    goto L10;

L50:
    if (*pp == 2) {
	*pp = 0;
    }

/*     Reverse the qd-array, if warranted. */

    if (*dmin__ <= 0. || *n0 < n0in) {
	if (z__[(*i0 << 2) + *pp - 3] * 1.5 < z__[(*n0 << 2) + *pp - 3]) {
	    ipn4 = *i0 + *n0 << 2;
	    i__1 = *i0 + *n0 - 1 << 1;
	    for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		temp = z__[j4 - 3];
		z__[j4 - 3] = z__[ipn4 - j4 - 3];
		z__[ipn4 - j4 - 3] = temp;
		temp = z__[j4 - 2];
		z__[j4 - 2] = z__[ipn4 - j4 - 2];
		z__[ipn4 - j4 - 2] = temp;
		temp = z__[j4 - 1];
		z__[j4 - 1] = z__[ipn4 - j4 - 5];
		z__[ipn4 - j4 - 5] = temp;
		temp = z__[j4];
		z__[j4] = z__[ipn4 - j4 - 4];
		z__[ipn4 - j4 - 4] = temp;
/* L60: */
	    }
	    if (*n0 - *i0 <= 4) {
		z__[(*n0 << 2) + *pp - 1] = z__[(*i0 << 2) + *pp - 1];
		z__[(*n0 << 2) - *pp] = z__[(*i0 << 2) - *pp];
	    }
/* Computing MIN */
	    d__1 = *dmin2, d__2 = z__[(*n0 << 2) + *pp - 1];
	    *dmin2 = min(d__1,d__2);
/* Computing MIN */
	    d__1 = z__[(*n0 << 2) + *pp - 1], d__2 = z__[(*i0 << 2) + *pp - 1]
		    , d__1 = min(d__1,d__2), d__2 = z__[(*i0 << 2) + *pp + 3];
	    z__[(*n0 << 2) + *pp - 1] = min(d__1,d__2);
/* Computing MIN */
	    d__1 = z__[(*n0 << 2) - *pp], d__2 = z__[(*i0 << 2) - *pp], d__1 =
		     min(d__1,d__2), d__2 = z__[(*i0 << 2) - *pp + 4];
	    z__[(*n0 << 2) - *pp] = min(d__1,d__2);
/* Computing MAX */
	    d__1 = *qmax, d__2 = z__[(*i0 << 2) + *pp - 3], d__1 = max(d__1,
		    d__2), d__2 = z__[(*i0 << 2) + *pp + 1];
	    *qmax = max(d__1,d__2);
	    *dmin__ = -0.;
	}
    }

/*     Choose a shift. */

    igraphdlasq4_(i0, n0, &z__[1], pp, &n0in, dmin__, dmin1, dmin2, dn, dn1, dn2, 
	    tau, ttype, g);

/*     Call dqds until DMIN > 0. */

L70:

    igraphdlasq5_(i0, n0, &z__[1], pp, tau, sigma, dmin__, dmin1, dmin2, dn, dn1, 
	    dn2, ieee, &eps);

    *ndiv += *n0 - *i0 + 2;
    ++(*iter);

/*     Check status. */

    if (*dmin__ >= 0. && *dmin1 >= 0.) {

/*        Success. */

	goto L90;

    } else if (*dmin__ < 0. && *dmin1 > 0. && z__[(*n0 - 1 << 2) - *pp] < tol 
	    * (*sigma + *dn1) && abs(*dn) < tol * *sigma) {

/*        Convergence hidden by negative DN. */

	z__[(*n0 - 1 << 2) - *pp + 2] = 0.;
	*dmin__ = 0.;
	goto L90;
    } else if (*dmin__ < 0.) {

/*        TAU too big. Select new TAU and try again. */

	++(*nfail);
	if (*ttype < -22) {

/*           Failed twice. Play it safe. */

	    *tau = 0.;
	} else if (*dmin1 > 0.) {

/*           Late failure. Gives excellent shift. */

	    *tau = (*tau + *dmin__) * (1. - eps * 2.);
	    *ttype += -11;
	} else {

/*           Early failure. Divide by 4. */

	    *tau *= .25;
	    *ttype += -12;
	}
	goto L70;
    } else if (igraphdisnan_(dmin__)) {

/*        NaN. */

	if (*tau == 0.) {
	    goto L80;
	} else {
	    *tau = 0.;
	    goto L70;
	}
    } else {

/*        Possible underflow. Play it safe. */

	goto L80;
    }

/*     Risk of underflow. */

L80:
    igraphdlasq6_(i0, n0, &z__[1], pp, dmin__, dmin1, dmin2, dn, dn1, dn2);
    *ndiv += *n0 - *i0 + 2;
    ++(*iter);
    *tau = 0.;

L90:
    if (*tau < *sigma) {
	*desig += *tau;
	t = *sigma + *desig;
	*desig -= t - *sigma;
    } else {
	t = *sigma + *tau;
	*desig = *sigma - (t - *tau) + *desig;
    }
    *sigma = t;

    return 0;

/*     End of DLASQ3 */

} /* igraphdlasq3_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasq4.c0000644000175100001710000002613400000000000023744 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASQ4 computes an approximation to the smallest eigenvalue using values of d from the previous
 transform. Used by sbdsqr.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASQ4 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASQ4( I0, N0, Z, PP, N0IN, DMIN, DMIN1, DMIN2, DN,   
                            DN1, DN2, TAU, TTYPE, G )   

         INTEGER            I0, N0, N0IN, PP, TTYPE   
         DOUBLE PRECISION   DMIN, DMIN1, DMIN2, DN, DN1, DN2, G, TAU   
         DOUBLE PRECISION   Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASQ4 computes an approximation TAU to the smallest eigenvalue   
   > using values of d from the previous transform.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] I0   
   > \verbatim   
   >          I0 is INTEGER   
   >        First index.   
   > \endverbatim   
   >   
   > \param[in] N0   
   > \verbatim   
   >          N0 is INTEGER   
   >        Last index.   
   > \endverbatim   
   >   
   > \param[in] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension ( 4*N )   
   >        Z holds the qd array.   
   > \endverbatim   
   >   
   > \param[in] PP   
   > \verbatim   
   >          PP is INTEGER   
   >        PP=0 for ping, PP=1 for pong.   
   > \endverbatim   
   >   
   > \param[in] N0IN   
   > \verbatim   
   >          N0IN is INTEGER   
   >        The value of N0 at start of EIGTEST.   
   > \endverbatim   
   >   
   > \param[in] DMIN   
   > \verbatim   
   >          DMIN is DOUBLE PRECISION   
   >        Minimum value of d.   
   > \endverbatim   
   >   
   > \param[in] DMIN1   
   > \verbatim   
   >          DMIN1 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ).   
   > \endverbatim   
   >   
   > \param[in] DMIN2   
   > \verbatim   
   >          DMIN2 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ) and D( N0-1 ).   
   > \endverbatim   
   >   
   > \param[in] DN   
   > \verbatim   
   >          DN is DOUBLE PRECISION   
   >        d(N)   
   > \endverbatim   
   >   
   > \param[in] DN1   
   > \verbatim   
   >          DN1 is DOUBLE PRECISION   
   >        d(N-1)   
   > \endverbatim   
   >   
   > \param[in] DN2   
   > \verbatim   
   >          DN2 is DOUBLE PRECISION   
   >        d(N-2)   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >        This is the shift.   
   > \endverbatim   
   >   
   > \param[out] TTYPE   
   > \verbatim   
   >          TTYPE is INTEGER   
   >        Shift type.   
   > \endverbatim   
   >   
   > \param[in,out] G   
   > \verbatim   
   >          G is REAL   
   >        G is passed as an argument in order to save its value between   
   >        calls to DLASQ4.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  CNST1 = 9/16   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlasq4_(integer *i0, integer *n0, doublereal *z__, 
	integer *pp, integer *n0in, doublereal *dmin__, doublereal *dmin1, 
	doublereal *dmin2, doublereal *dn, doublereal *dn1, doublereal *dn2, 
	doublereal *tau, integer *ttype, doublereal *g)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    doublereal s, a2, b1, b2;
    integer i4, nn, np;
    doublereal gam, gap1, gap2;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       A negative DMIN forces the shift to take that absolute value   
       TTYPE records the type of shift.   

       Parameter adjustments */
    --z__;

    /* Function Body */
    if (*dmin__ <= 0.) {
	*tau = -(*dmin__);
	*ttype = -1;
	return 0;
    }

    nn = (*n0 << 2) + *pp;
    if (*n0in == *n0) {

/*        No eigenvalues deflated. */

	if (*dmin__ == *dn || *dmin__ == *dn1) {

	    b1 = sqrt(z__[nn - 3]) * sqrt(z__[nn - 5]);
	    b2 = sqrt(z__[nn - 7]) * sqrt(z__[nn - 9]);
	    a2 = z__[nn - 7] + z__[nn - 5];

/*           Cases 2 and 3. */

	    if (*dmin__ == *dn && *dmin1 == *dn1) {
		gap2 = *dmin2 - a2 - *dmin2 * .25;
		if (gap2 > 0. && gap2 > b2) {
		    gap1 = a2 - *dn - b2 / gap2 * b2;
		} else {
		    gap1 = a2 - *dn - (b1 + b2);
		}
		if (gap1 > 0. && gap1 > b1) {
/* Computing MAX */
		    d__1 = *dn - b1 / gap1 * b1, d__2 = *dmin__ * .5;
		    s = max(d__1,d__2);
		    *ttype = -2;
		} else {
		    s = 0.;
		    if (*dn > b1) {
			s = *dn - b1;
		    }
		    if (a2 > b1 + b2) {
/* Computing MIN */
			d__1 = s, d__2 = a2 - (b1 + b2);
			s = min(d__1,d__2);
		    }
/* Computing MAX */
		    d__1 = s, d__2 = *dmin__ * .333;
		    s = max(d__1,d__2);
		    *ttype = -3;
		}
	    } else {

/*              Case 4. */

		*ttype = -4;
		s = *dmin__ * .25;
		if (*dmin__ == *dn) {
		    gam = *dn;
		    a2 = 0.;
		    if (z__[nn - 5] > z__[nn - 7]) {
			return 0;
		    }
		    b2 = z__[nn - 5] / z__[nn - 7];
		    np = nn - 9;
		} else {
		    np = nn - (*pp << 1);
		    b2 = z__[np - 2];
		    gam = *dn1;
		    if (z__[np - 4] > z__[np - 2]) {
			return 0;
		    }
		    a2 = z__[np - 4] / z__[np - 2];
		    if (z__[nn - 9] > z__[nn - 11]) {
			return 0;
		    }
		    b2 = z__[nn - 9] / z__[nn - 11];
		    np = nn - 13;
		}

/*              Approximate contribution to norm squared from I < NN-1. */

		a2 += b2;
		i__1 = (*i0 << 2) - 1 + *pp;
		for (i4 = np; i4 >= i__1; i4 += -4) {
		    if (b2 == 0.) {
			goto L20;
		    }
		    b1 = b2;
		    if (z__[i4] > z__[i4 - 2]) {
			return 0;
		    }
		    b2 *= z__[i4] / z__[i4 - 2];
		    a2 += b2;
		    if (max(b2,b1) * 100. < a2 || .563 < a2) {
			goto L20;
		    }
/* L10: */
		}
L20:
		a2 *= 1.05;

/*              Rayleigh quotient residual bound. */

		if (a2 < .563) {
		    s = gam * (1. - sqrt(a2)) / (a2 + 1.);
		}
	    }
	} else if (*dmin__ == *dn2) {

/*           Case 5. */

	    *ttype = -5;
	    s = *dmin__ * .25;

/*           Compute contribution to norm squared from I > NN-2. */

	    np = nn - (*pp << 1);
	    b1 = z__[np - 2];
	    b2 = z__[np - 6];
	    gam = *dn2;
	    if (z__[np - 8] > b2 || z__[np - 4] > b1) {
		return 0;
	    }
	    a2 = z__[np - 8] / b2 * (z__[np - 4] / b1 + 1.);

/*           Approximate contribution to norm squared from I < NN-2. */

	    if (*n0 - *i0 > 2) {
		b2 = z__[nn - 13] / z__[nn - 15];
		a2 += b2;
		i__1 = (*i0 << 2) - 1 + *pp;
		for (i4 = nn - 17; i4 >= i__1; i4 += -4) {
		    if (b2 == 0.) {
			goto L40;
		    }
		    b1 = b2;
		    if (z__[i4] > z__[i4 - 2]) {
			return 0;
		    }
		    b2 *= z__[i4] / z__[i4 - 2];
		    a2 += b2;
		    if (max(b2,b1) * 100. < a2 || .563 < a2) {
			goto L40;
		    }
/* L30: */
		}
L40:
		a2 *= 1.05;
	    }

	    if (a2 < .563) {
		s = gam * (1. - sqrt(a2)) / (a2 + 1.);
	    }
	} else {

/*           Case 6, no information to guide us. */

	    if (*ttype == -6) {
		*g += (1. - *g) * .333;
	    } else if (*ttype == -18) {
		*g = .083250000000000005;
	    } else {
		*g = .25;
	    }
	    s = *g * *dmin__;
	    *ttype = -6;
	}

    } else if (*n0in == *n0 + 1) {

/*        One eigenvalue just deflated. Use DMIN1, DN1 for DMIN and DN. */

	if (*dmin1 == *dn1 && *dmin2 == *dn2) {

/*           Cases 7 and 8. */

	    *ttype = -7;
	    s = *dmin1 * .333;
	    if (z__[nn - 5] > z__[nn - 7]) {
		return 0;
	    }
	    b1 = z__[nn - 5] / z__[nn - 7];
	    b2 = b1;
	    if (b2 == 0.) {
		goto L60;
	    }
	    i__1 = (*i0 << 2) - 1 + *pp;
	    for (i4 = (*n0 << 2) - 9 + *pp; i4 >= i__1; i4 += -4) {
		a2 = b1;
		if (z__[i4] > z__[i4 - 2]) {
		    return 0;
		}
		b1 *= z__[i4] / z__[i4 - 2];
		b2 += b1;
		if (max(b1,a2) * 100. < b2) {
		    goto L60;
		}
/* L50: */
	    }
L60:
	    b2 = sqrt(b2 * 1.05);
/* Computing 2nd power */
	    d__1 = b2;
	    a2 = *dmin1 / (d__1 * d__1 + 1.);
	    gap2 = *dmin2 * .5 - a2;
	    if (gap2 > 0. && gap2 > b2 * a2) {
/* Computing MAX */
		d__1 = s, d__2 = a2 * (1. - a2 * 1.01 * (b2 / gap2) * b2);
		s = max(d__1,d__2);
	    } else {
/* Computing MAX */
		d__1 = s, d__2 = a2 * (1. - b2 * 1.01);
		s = max(d__1,d__2);
		*ttype = -8;
	    }
	} else {

/*           Case 9. */

	    s = *dmin1 * .25;
	    if (*dmin1 == *dn1) {
		s = *dmin1 * .5;
	    }
	    *ttype = -9;
	}

    } else if (*n0in == *n0 + 2) {

/*        Two eigenvalues deflated. Use DMIN2, DN2 for DMIN and DN.   

          Cases 10 and 11. */

	if (*dmin2 == *dn2 && z__[nn - 5] * 2. < z__[nn - 7]) {
	    *ttype = -10;
	    s = *dmin2 * .333;
	    if (z__[nn - 5] > z__[nn - 7]) {
		return 0;
	    }
	    b1 = z__[nn - 5] / z__[nn - 7];
	    b2 = b1;
	    if (b2 == 0.) {
		goto L80;
	    }
	    i__1 = (*i0 << 2) - 1 + *pp;
	    for (i4 = (*n0 << 2) - 9 + *pp; i4 >= i__1; i4 += -4) {
		if (z__[i4] > z__[i4 - 2]) {
		    return 0;
		}
		b1 *= z__[i4] / z__[i4 - 2];
		b2 += b1;
		if (b1 * 100. < b2) {
		    goto L80;
		}
/* L70: */
	    }
L80:
	    b2 = sqrt(b2 * 1.05);
/* Computing 2nd power */
	    d__1 = b2;
	    a2 = *dmin2 / (d__1 * d__1 + 1.);
	    gap2 = z__[nn - 7] + z__[nn - 9] - sqrt(z__[nn - 11]) * sqrt(z__[
		    nn - 9]) - a2;
	    if (gap2 > 0. && gap2 > b2 * a2) {
/* Computing MAX */
		d__1 = s, d__2 = a2 * (1. - a2 * 1.01 * (b2 / gap2) * b2);
		s = max(d__1,d__2);
	    } else {
/* Computing MAX */
		d__1 = s, d__2 = a2 * (1. - b2 * 1.01);
		s = max(d__1,d__2);
	    }
	} else {
	    s = *dmin2 * .25;
	    *ttype = -11;
	}
    } else if (*n0in > *n0 + 2) {

/*        Case 12, more than two eigenvalues deflated. No information. */

	s = 0.;
	*ttype = -12;
    }

    *tau = s;
    return 0;

/*     End of DLASQ4 */

} /* igraphdlasq4_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasq5.c0000644000175100001710000002723100000000000023744 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASQ5 computes one dqds transform in ping-pong form. Used by sbdsqr and sstegr.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASQ5 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASQ5( I0, N0, Z, PP, TAU, SIGMA, DMIN, DMIN1, DMIN2, DN,   
                            DNM1, DNM2, IEEE, EPS )   

         LOGICAL            IEEE   
         INTEGER            I0, N0, PP   
         DOUBLE PRECISION   DMIN, DMIN1, DMIN2, DN, DNM1, DNM2, TAU, SIGMA, EPS   
         DOUBLE PRECISION   Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASQ5 computes one dqds transform in ping-pong form, one   
   > version for IEEE machines another for non IEEE machines.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] I0   
   > \verbatim   
   >          I0 is INTEGER   
   >        First index.   
   > \endverbatim   
   >   
   > \param[in] N0   
   > \verbatim   
   >          N0 is INTEGER   
   >        Last index.   
   > \endverbatim   
   >   
   > \param[in] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension ( 4*N )   
   >        Z holds the qd array. EMIN is stored in Z(4*N0) to avoid   
   >        an extra argument.   
   > \endverbatim   
   >   
   > \param[in] PP   
   > \verbatim   
   >          PP is INTEGER   
   >        PP=0 for ping, PP=1 for pong.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION   
   >        This is the shift.   
   > \endverbatim   
   >   
   > \param[in] SIGMA   
   > \verbatim   
   >          SIGMA is DOUBLE PRECISION   
   >        This is the accumulated shift up to this step.   
   > \endverbatim   
   >   
   > \param[out] DMIN   
   > \verbatim   
   >          DMIN is DOUBLE PRECISION   
   >        Minimum value of d.   
   > \endverbatim   
   >   
   > \param[out] DMIN1   
   > \verbatim   
   >          DMIN1 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ).   
   > \endverbatim   
   >   
   > \param[out] DMIN2   
   > \verbatim   
   >          DMIN2 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ) and D( N0-1 ).   
   > \endverbatim   
   >   
   > \param[out] DN   
   > \verbatim   
   >          DN is DOUBLE PRECISION   
   >        d(N0), the last value of d.   
   > \endverbatim   
   >   
   > \param[out] DNM1   
   > \verbatim   
   >          DNM1 is DOUBLE PRECISION   
   >        d(N0-1).   
   > \endverbatim   
   >   
   > \param[out] DNM2   
   > \verbatim   
   >          DNM2 is DOUBLE PRECISION   
   >        d(N0-2).   
   > \endverbatim   
   >   
   > \param[in] IEEE   
   > \verbatim   
   >          IEEE is LOGICAL   
   >        Flag for IEEE or non IEEE arithmetic.   
   > \endverbatim   

   > \param[in] EPS   
   > \verbatim   
   >          EPS is DOUBLE PRECISION   
   >        This is the value of epsilon used.   
   > \endverbatim   
   >   
    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdlasq5_(integer *i0, integer *n0, doublereal *z__, 
	integer *pp, doublereal *tau, doublereal *sigma, doublereal *dmin__, 
	doublereal *dmin1, doublereal *dmin2, doublereal *dn, doublereal *
	dnm1, doublereal *dnm2, logical *ieee, doublereal *eps)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Local variables */
    doublereal d__;
    integer j4, j4p2;
    doublereal emin, temp, dthresh;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --z__;

    /* Function Body */
    if (*n0 - *i0 - 1 <= 0) {
	return 0;
    }

    dthresh = *eps * (*sigma + *tau);
    if (*tau < dthresh * .5) {
	*tau = 0.;
    }
    if (*tau != 0.) {
	j4 = (*i0 << 2) + *pp - 3;
	emin = z__[j4 + 4];
	d__ = z__[j4] - *tau;
	*dmin__ = d__;
	*dmin1 = -z__[j4];

	if (*ieee) {

/*        Code for IEEE arithmetic. */

	    if (*pp == 0) {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 2] = d__ + z__[j4 - 1];
		    temp = z__[j4 + 1] / z__[j4 - 2];
		    d__ = d__ * temp - *tau;
		    *dmin__ = min(*dmin__,d__);
		    z__[j4] = z__[j4 - 1] * temp;
/* Computing MIN */
		    d__1 = z__[j4];
		    emin = min(d__1,emin);
/* L10: */
		}
	    } else {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 3] = d__ + z__[j4];
		    temp = z__[j4 + 2] / z__[j4 - 3];
		    d__ = d__ * temp - *tau;
		    *dmin__ = min(*dmin__,d__);
		    z__[j4 - 1] = z__[j4] * temp;
/* Computing MIN */
		    d__1 = z__[j4 - 1];
		    emin = min(d__1,emin);
/* L20: */
		}
	    }

/*        Unroll last two steps. */

	    *dnm2 = d__;
	    *dmin2 = *dmin__;
	    j4 = (*n0 - 2 << 2) - *pp;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm2 + z__[j4p2];
	    z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	    *dnm1 = z__[j4p2 + 2] * (*dnm2 / z__[j4 - 2]) - *tau;
	    *dmin__ = min(*dmin__,*dnm1);

	    *dmin1 = *dmin__;
	    j4 += 4;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm1 + z__[j4p2];
	    z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	    *dn = z__[j4p2 + 2] * (*dnm1 / z__[j4 - 2]) - *tau;
	    *dmin__ = min(*dmin__,*dn);

	} else {

/*        Code for non IEEE arithmetic. */

	    if (*pp == 0) {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 2] = d__ + z__[j4 - 1];
		    if (d__ < 0.) {
			return 0;
		    } else {
			z__[j4] = z__[j4 + 1] * (z__[j4 - 1] / z__[j4 - 2]);
			d__ = z__[j4 + 1] * (d__ / z__[j4 - 2]) - *tau;
		    }
		    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
		    d__1 = emin, d__2 = z__[j4];
		    emin = min(d__1,d__2);
/* L30: */
		}
	    } else {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 3] = d__ + z__[j4];
		    if (d__ < 0.) {
			return 0;
		    } else {
			z__[j4 - 1] = z__[j4 + 2] * (z__[j4] / z__[j4 - 3]);
			d__ = z__[j4 + 2] * (d__ / z__[j4 - 3]) - *tau;
		    }
		    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
		    d__1 = emin, d__2 = z__[j4 - 1];
		    emin = min(d__1,d__2);
/* L40: */
		}
	    }

/*        Unroll last two steps. */

	    *dnm2 = d__;
	    *dmin2 = *dmin__;
	    j4 = (*n0 - 2 << 2) - *pp;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm2 + z__[j4p2];
	    if (*dnm2 < 0.) {
		return 0;
	    } else {
		z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
		*dnm1 = z__[j4p2 + 2] * (*dnm2 / z__[j4 - 2]) - *tau;
	    }
	    *dmin__ = min(*dmin__,*dnm1);

	    *dmin1 = *dmin__;
	    j4 += 4;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm1 + z__[j4p2];
	    if (*dnm1 < 0.) {
		return 0;
	    } else {
		z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
		*dn = z__[j4p2 + 2] * (*dnm1 / z__[j4 - 2]) - *tau;
	    }
	    *dmin__ = min(*dmin__,*dn);

	}
    } else {
/*     This is the version that sets d's to zero if they are small enough */
	j4 = (*i0 << 2) + *pp - 3;
	emin = z__[j4 + 4];
	d__ = z__[j4] - *tau;
	*dmin__ = d__;
	*dmin1 = -z__[j4];
	if (*ieee) {

/*     Code for IEEE arithmetic. */

	    if (*pp == 0) {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 2] = d__ + z__[j4 - 1];
		    temp = z__[j4 + 1] / z__[j4 - 2];
		    d__ = d__ * temp - *tau;
		    if (d__ < dthresh) {
			d__ = 0.;
		    }
		    *dmin__ = min(*dmin__,d__);
		    z__[j4] = z__[j4 - 1] * temp;
/* Computing MIN */
		    d__1 = z__[j4];
		    emin = min(d__1,emin);
/* L50: */
		}
	    } else {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 3] = d__ + z__[j4];
		    temp = z__[j4 + 2] / z__[j4 - 3];
		    d__ = d__ * temp - *tau;
		    if (d__ < dthresh) {
			d__ = 0.;
		    }
		    *dmin__ = min(*dmin__,d__);
		    z__[j4 - 1] = z__[j4] * temp;
/* Computing MIN */
		    d__1 = z__[j4 - 1];
		    emin = min(d__1,emin);
/* L60: */
		}
	    }

/*     Unroll last two steps. */

	    *dnm2 = d__;
	    *dmin2 = *dmin__;
	    j4 = (*n0 - 2 << 2) - *pp;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm2 + z__[j4p2];
	    z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	    *dnm1 = z__[j4p2 + 2] * (*dnm2 / z__[j4 - 2]) - *tau;
	    *dmin__ = min(*dmin__,*dnm1);

	    *dmin1 = *dmin__;
	    j4 += 4;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm1 + z__[j4p2];
	    z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	    *dn = z__[j4p2 + 2] * (*dnm1 / z__[j4 - 2]) - *tau;
	    *dmin__ = min(*dmin__,*dn);

	} else {

/*     Code for non IEEE arithmetic. */

	    if (*pp == 0) {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 2] = d__ + z__[j4 - 1];
		    if (d__ < 0.) {
			return 0;
		    } else {
			z__[j4] = z__[j4 + 1] * (z__[j4 - 1] / z__[j4 - 2]);
			d__ = z__[j4 + 1] * (d__ / z__[j4 - 2]) - *tau;
		    }
		    if (d__ < dthresh) {
			d__ = 0.;
		    }
		    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
		    d__1 = emin, d__2 = z__[j4];
		    emin = min(d__1,d__2);
/* L70: */
		}
	    } else {
		i__1 = *n0 - 3 << 2;
		for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
		    z__[j4 - 3] = d__ + z__[j4];
		    if (d__ < 0.) {
			return 0;
		    } else {
			z__[j4 - 1] = z__[j4 + 2] * (z__[j4] / z__[j4 - 3]);
			d__ = z__[j4 + 2] * (d__ / z__[j4 - 3]) - *tau;
		    }
		    if (d__ < dthresh) {
			d__ = 0.;
		    }
		    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
		    d__1 = emin, d__2 = z__[j4 - 1];
		    emin = min(d__1,d__2);
/* L80: */
		}
	    }

/*     Unroll last two steps. */

	    *dnm2 = d__;
	    *dmin2 = *dmin__;
	    j4 = (*n0 - 2 << 2) - *pp;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm2 + z__[j4p2];
	    if (*dnm2 < 0.) {
		return 0;
	    } else {
		z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
		*dnm1 = z__[j4p2 + 2] * (*dnm2 / z__[j4 - 2]) - *tau;
	    }
	    *dmin__ = min(*dmin__,*dnm1);

	    *dmin1 = *dmin__;
	    j4 += 4;
	    j4p2 = j4 + (*pp << 1) - 1;
	    z__[j4 - 2] = *dnm1 + z__[j4p2];
	    if (*dnm1 < 0.) {
		return 0;
	    } else {
		z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
		*dn = z__[j4p2 + 2] * (*dnm1 / z__[j4 - 2]) - *tau;
	    }
	    *dmin__ = min(*dmin__,*dn);

	}
    }

    z__[j4 + 2] = *dn;
    z__[(*n0 << 2) - *pp] = emin;
    return 0;

/*     End of DLASQ5 */

} /* igraphdlasq5_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasq6.c0000644000175100001710000001616700000000000023753 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASQ6 computes one dqd transform in ping-pong form. Used by sbdsqr and sstegr.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASQ6 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASQ6( I0, N0, Z, PP, DMIN, DMIN1, DMIN2, DN,   
                            DNM1, DNM2 )   

         INTEGER            I0, N0, PP   
         DOUBLE PRECISION   DMIN, DMIN1, DMIN2, DN, DNM1, DNM2   
         DOUBLE PRECISION   Z( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASQ6 computes one dqd (shift equal to zero) transform in   
   > ping-pong form, with protection against underflow and overflow.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] I0   
   > \verbatim   
   >          I0 is INTEGER   
   >        First index.   
   > \endverbatim   
   >   
   > \param[in] N0   
   > \verbatim   
   >          N0 is INTEGER   
   >        Last index.   
   > \endverbatim   
   >   
   > \param[in] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension ( 4*N )   
   >        Z holds the qd array. EMIN is stored in Z(4*N0) to avoid   
   >        an extra argument.   
   > \endverbatim   
   >   
   > \param[in] PP   
   > \verbatim   
   >          PP is INTEGER   
   >        PP=0 for ping, PP=1 for pong.   
   > \endverbatim   
   >   
   > \param[out] DMIN   
   > \verbatim   
   >          DMIN is DOUBLE PRECISION   
   >        Minimum value of d.   
   > \endverbatim   
   >   
   > \param[out] DMIN1   
   > \verbatim   
   >          DMIN1 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ).   
   > \endverbatim   
   >   
   > \param[out] DMIN2   
   > \verbatim   
   >          DMIN2 is DOUBLE PRECISION   
   >        Minimum value of d, excluding D( N0 ) and D( N0-1 ).   
   > \endverbatim   
   >   
   > \param[out] DN   
   > \verbatim   
   >          DN is DOUBLE PRECISION   
   >        d(N0), the last value of d.   
   > \endverbatim   
   >   
   > \param[out] DNM1   
   > \verbatim   
   >          DNM1 is DOUBLE PRECISION   
   >        d(N0-1).   
   > \endverbatim   
   >   
   > \param[out] DNM2   
   > \verbatim   
   >          DNM2 is DOUBLE PRECISION   
   >        d(N0-2).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdlasq6_(integer *i0, integer *n0, doublereal *z__, 
	integer *pp, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2,
	 doublereal *dn, doublereal *dnm1, doublereal *dnm2)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Local variables */
    doublereal d__;
    integer j4, j4p2;
    doublereal emin, temp;
    extern doublereal igraphdlamch_(char *);
    doublereal safmin;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Parameter adjustments */
    --z__;

    /* Function Body */
    if (*n0 - *i0 - 1 <= 0) {
	return 0;
    }

    safmin = igraphdlamch_("Safe minimum");
    j4 = (*i0 << 2) + *pp - 3;
    emin = z__[j4 + 4];
    d__ = z__[j4];
    *dmin__ = d__;

    if (*pp == 0) {
	i__1 = *n0 - 3 << 2;
	for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
	    z__[j4 - 2] = d__ + z__[j4 - 1];
	    if (z__[j4 - 2] == 0.) {
		z__[j4] = 0.;
		d__ = z__[j4 + 1];
		*dmin__ = d__;
		emin = 0.;
	    } else if (safmin * z__[j4 + 1] < z__[j4 - 2] && safmin * z__[j4 
		    - 2] < z__[j4 + 1]) {
		temp = z__[j4 + 1] / z__[j4 - 2];
		z__[j4] = z__[j4 - 1] * temp;
		d__ *= temp;
	    } else {
		z__[j4] = z__[j4 + 1] * (z__[j4 - 1] / z__[j4 - 2]);
		d__ = z__[j4 + 1] * (d__ / z__[j4 - 2]);
	    }
	    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
	    d__1 = emin, d__2 = z__[j4];
	    emin = min(d__1,d__2);
/* L10: */
	}
    } else {
	i__1 = *n0 - 3 << 2;
	for (j4 = *i0 << 2; j4 <= i__1; j4 += 4) {
	    z__[j4 - 3] = d__ + z__[j4];
	    if (z__[j4 - 3] == 0.) {
		z__[j4 - 1] = 0.;
		d__ = z__[j4 + 2];
		*dmin__ = d__;
		emin = 0.;
	    } else if (safmin * z__[j4 + 2] < z__[j4 - 3] && safmin * z__[j4 
		    - 3] < z__[j4 + 2]) {
		temp = z__[j4 + 2] / z__[j4 - 3];
		z__[j4 - 1] = z__[j4] * temp;
		d__ *= temp;
	    } else {
		z__[j4 - 1] = z__[j4 + 2] * (z__[j4] / z__[j4 - 3]);
		d__ = z__[j4 + 2] * (d__ / z__[j4 - 3]);
	    }
	    *dmin__ = min(*dmin__,d__);
/* Computing MIN */
	    d__1 = emin, d__2 = z__[j4 - 1];
	    emin = min(d__1,d__2);
/* L20: */
	}
    }

/*     Unroll last two steps. */

    *dnm2 = d__;
    *dmin2 = *dmin__;
    j4 = (*n0 - 2 << 2) - *pp;
    j4p2 = j4 + (*pp << 1) - 1;
    z__[j4 - 2] = *dnm2 + z__[j4p2];
    if (z__[j4 - 2] == 0.) {
	z__[j4] = 0.;
	*dnm1 = z__[j4p2 + 2];
	*dmin__ = *dnm1;
	emin = 0.;
    } else if (safmin * z__[j4p2 + 2] < z__[j4 - 2] && safmin * z__[j4 - 2] < 
	    z__[j4p2 + 2]) {
	temp = z__[j4p2 + 2] / z__[j4 - 2];
	z__[j4] = z__[j4p2] * temp;
	*dnm1 = *dnm2 * temp;
    } else {
	z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	*dnm1 = z__[j4p2 + 2] * (*dnm2 / z__[j4 - 2]);
    }
    *dmin__ = min(*dmin__,*dnm1);

    *dmin1 = *dmin__;
    j4 += 4;
    j4p2 = j4 + (*pp << 1) - 1;
    z__[j4 - 2] = *dnm1 + z__[j4p2];
    if (z__[j4 - 2] == 0.) {
	z__[j4] = 0.;
	*dn = z__[j4p2 + 2];
	*dmin__ = *dn;
	emin = 0.;
    } else if (safmin * z__[j4p2 + 2] < z__[j4 - 2] && safmin * z__[j4 - 2] < 
	    z__[j4p2 + 2]) {
	temp = z__[j4p2 + 2] / z__[j4 - 2];
	z__[j4] = z__[j4p2] * temp;
	*dn = *dnm1 * temp;
    } else {
	z__[j4] = z__[j4p2 + 2] * (z__[j4p2] / z__[j4 - 2]);
	*dn = z__[j4p2 + 2] * (*dnm1 / z__[j4 - 2]);
    }
    *dmin__ = min(*dmin__,*dn);

    z__[j4 + 2] = *dn;
    z__[(*n0 << 2) - *pp] = emin;
    return 0;

/*     End of DLASQ6 */

} /* igraphdlasq6_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasr.c0000644000175100001710000003602500000000000023661 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASR applies a sequence of plane rotations to a general rectangular matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASR( SIDE, PIVOT, DIRECT, M, N, C, S, A, LDA )   

         CHARACTER          DIRECT, PIVOT, SIDE   
         INTEGER            LDA, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( * ), S( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASR applies a sequence of plane rotations to a real matrix A,   
   > from either the left or the right.   
   >   
   > When SIDE = 'L', the transformation takes the form   
   >   
   >    A := P*A   
   >   
   > and when SIDE = 'R', the transformation takes the form   
   >   
   >    A := A*P**T   
   >   
   > where P is an orthogonal matrix consisting of a sequence of z plane   
   > rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R',   
   > and P**T is the transpose of P.   
   >   
   > When DIRECT = 'F' (Forward sequence), then   
   >   
   >    P = P(z-1) * ... * P(2) * P(1)   
   >   
   > and when DIRECT = 'B' (Backward sequence), then   
   >   
   >    P = P(1) * P(2) * ... * P(z-1)   
   >   
   > where P(k) is a plane rotation matrix defined by the 2-by-2 rotation   
   >   
   >    R(k) = (  c(k)  s(k) )   
   >         = ( -s(k)  c(k) ).   
   >   
   > When PIVOT = 'V' (Variable pivot), the rotation is performed   
   > for the plane (k,k+1), i.e., P(k) has the form   
   >   
   >    P(k) = (  1                                            )   
   >           (       ...                                     )   
   >           (              1                                )   
   >           (                   c(k)  s(k)                  )   
   >           (                  -s(k)  c(k)                  )   
   >           (                                1              )   
   >           (                                     ...       )   
   >           (                                            1  )   
   >   
   > where R(k) appears as a rank-2 modification to the identity matrix in   
   > rows and columns k and k+1.   
   >   
   > When PIVOT = 'T' (Top pivot), the rotation is performed for the   
   > plane (1,k+1), so P(k) has the form   
   >   
   >    P(k) = (  c(k)                    s(k)                 )   
   >           (         1                                     )   
   >           (              ...                              )   
   >           (                     1                         )   
   >           ( -s(k)                    c(k)                 )   
   >           (                                 1             )   
   >           (                                      ...      )   
   >           (                                             1 )   
   >   
   > where R(k) appears in rows and columns 1 and k+1.   
   >   
   > Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is   
   > performed for the plane (k,z), giving P(k) the form   
   >   
   >    P(k) = ( 1                                             )   
   >           (      ...                                      )   
   >           (             1                                 )   
   >           (                  c(k)                    s(k) )   
   >           (                         1                     )   
   >           (                              ...              )   
   >           (                                     1         )   
   >           (                 -s(k)                    c(k) )   
   >   
   > where R(k) appears in rows and columns k and z.  The rotations are   
   > performed without ever forming P(k) explicitly.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          Specifies whether the plane rotation matrix P is applied to   
   >          A on the left or the right.   
   >          = 'L':  Left, compute A := P*A   
   >          = 'R':  Right, compute A:= A*P**T   
   > \endverbatim   
   >   
   > \param[in] PIVOT   
   > \verbatim   
   >          PIVOT is CHARACTER*1   
   >          Specifies the plane for which P(k) is a plane rotation   
   >          matrix.   
   >          = 'V':  Variable pivot, the plane (k,k+1)   
   >          = 'T':  Top pivot, the plane (1,k+1)   
   >          = 'B':  Bottom pivot, the plane (k,z)   
   > \endverbatim   
   >   
   > \param[in] DIRECT   
   > \verbatim   
   >          DIRECT is CHARACTER*1   
   >          Specifies whether P is a forward or backward sequence of   
   >          plane rotations.   
   >          = 'F':  Forward, P = P(z-1)*...*P(2)*P(1)   
   >          = 'B':  Backward, P = P(1)*P(2)*...*P(z-1)   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.  If m <= 1, an immediate   
   >          return is effected.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.  If n <= 1, an   
   >          immediate return is effected.   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension   
   >                  (M-1) if SIDE = 'L'   
   >                  (N-1) if SIDE = 'R'   
   >          The cosines c(k) of the plane rotations.   
   > \endverbatim   
   >   
   > \param[in] S   
   > \verbatim   
   >          S is DOUBLE PRECISION array, dimension   
   >                  (M-1) if SIDE = 'L'   
   >                  (N-1) if SIDE = 'R'   
   >          The sines s(k) of the plane rotations.  The 2-by-2 plane   
   >          rotation part of the matrix P(k), R(k), has the form   
   >          R(k) = (  c(k)  s(k) )   
   >                 ( -s(k)  c(k) ).   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The M-by-N matrix A.  On exit, A is overwritten by P*A if   
   >          SIDE = 'R' or by A*P**T if SIDE = 'L'.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlasr_(char *side, char *pivot, char *direct, integer *m,
	 integer *n, doublereal *c__, doublereal *s, doublereal *a, integer *
	lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, info;
    doublereal temp;
    extern logical igraphlsame_(char *, char *);
    doublereal ctemp, stemp;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    --c__;
    --s;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    info = 0;
    if (! (igraphlsame_(side, "L") || igraphlsame_(side, "R"))) {
	info = 1;
    } else if (! (igraphlsame_(pivot, "V") || igraphlsame_(pivot, 
	    "T") || igraphlsame_(pivot, "B"))) {
	info = 2;
    } else if (! (igraphlsame_(direct, "F") || igraphlsame_(direct, 
	    "B"))) {
	info = 3;
    } else if (*m < 0) {
	info = 4;
    } else if (*n < 0) {
	info = 5;
    } else if (*lda < max(1,*m)) {
	info = 9;
    }
    if (info != 0) {
	igraphxerbla_("DLASR ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0) {
	return 0;
    }
    if (igraphlsame_(side, "L")) {

/*        Form  P * A */

	if (igraphlsame_(pivot, "V")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *m - 1;
		for (j = 1; j <= i__1; ++j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *n;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[j + 1 + i__ * a_dim1];
			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
				    a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
				    + i__ * a_dim1];
/* L10: */
			}
		    }
/* L20: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *m - 1; j >= 1; --j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *n;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[j + 1 + i__ * a_dim1];
			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
				    a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
				    + i__ * a_dim1];
/* L30: */
			}
		    }
/* L40: */
		}
	    }
	} else if (igraphlsame_(pivot, "T")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *m;
		for (j = 2; j <= i__1; ++j) {
		    ctemp = c__[j - 1];
		    stemp = s[j - 1];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *n;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
				    i__ * a_dim1 + 1];
			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
				    i__ * a_dim1 + 1];
/* L50: */
			}
		    }
/* L60: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *m; j >= 2; --j) {
		    ctemp = c__[j - 1];
		    stemp = s[j - 1];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *n;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
				    i__ * a_dim1 + 1];
			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
				    i__ * a_dim1 + 1];
/* L70: */
			}
		    }
/* L80: */
		}
	    }
	} else if (igraphlsame_(pivot, "B")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *m - 1;
		for (j = 1; j <= i__1; ++j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *n;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
				     + ctemp * temp;
			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
				    a_dim1] - stemp * temp;
/* L90: */
			}
		    }
/* L100: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *m - 1; j >= 1; --j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *n;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[j + i__ * a_dim1];
			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
				     + ctemp * temp;
			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
				    a_dim1] - stemp * temp;
/* L110: */
			}
		    }
/* L120: */
		}
	    }
	}
    } else if (igraphlsame_(side, "R")) {

/*        Form A * P**T */

	if (igraphlsame_(pivot, "V")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *n - 1;
		for (j = 1; j <= i__1; ++j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[i__ + (j + 1) * a_dim1];
			    a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
				     a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
				    i__ + j * a_dim1];
/* L130: */
			}
		    }
/* L140: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *n - 1; j >= 1; --j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[i__ + (j + 1) * a_dim1];
			    a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
				     a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
				    i__ + j * a_dim1];
/* L150: */
			}
		    }
/* L160: */
		}
	    }
	} else if (igraphlsame_(pivot, "T")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *n;
		for (j = 2; j <= i__1; ++j) {
		    ctemp = c__[j - 1];
		    stemp = s[j - 1];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
				    i__ + a_dim1];
			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
				    a_dim1];
/* L170: */
			}
		    }
/* L180: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *n; j >= 2; --j) {
		    ctemp = c__[j - 1];
		    stemp = s[j - 1];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
				    i__ + a_dim1];
			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
				    a_dim1];
/* L190: */
			}
		    }
/* L200: */
		}
	    }
	} else if (igraphlsame_(pivot, "B")) {
	    if (igraphlsame_(direct, "F")) {
		i__1 = *n - 1;
		for (j = 1; j <= i__1; ++j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    temp = a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
				     + ctemp * temp;
			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
				    a_dim1] - stemp * temp;
/* L210: */
			}
		    }
/* L220: */
		}
	    } else if (igraphlsame_(direct, "B")) {
		for (j = *n - 1; j >= 1; --j) {
		    ctemp = c__[j];
		    stemp = s[j];
		    if (ctemp != 1. || stemp != 0.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    temp = a[i__ + j * a_dim1];
			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
				     + ctemp * temp;
			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
				    a_dim1] - stemp * temp;
/* L230: */
			}
		    }
/* L240: */
		}
	    }
	}
    }

    return 0;

/*     End of DLASR */

} /* igraphdlasr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasrt.c0000644000175100001710000001622700000000000024047 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASRT sorts numbers in increasing or decreasing order.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASRT + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASRT( ID, N, D, INFO )   

         CHARACTER          ID   
         INTEGER            INFO, N   
         DOUBLE PRECISION   D( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > Sort the numbers in D in increasing order (if ID = 'I') or   
   > in decreasing order (if ID = 'D' ).   
   >   
   > Use Quick Sort, reverting to Insertion sort on arrays of   
   > size <= 20. Dimension of STACK limits N to about 2**32.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] ID   
   > \verbatim   
   >          ID is CHARACTER*1   
   >          = 'I': sort D in increasing order;   
   >          = 'D': sort D in decreasing order.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The length of the array D.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the array to be sorted.   
   >          On exit, D has been sorted into increasing order   
   >          (D(1) <= ... <= D(N) ) or into decreasing order   
   >          (D(1) >= ... >= D(N) ), depending on ID.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdlasrt_(char *id, integer *n, doublereal *d__, integer *
	info)
{
    /* System generated locals */
    integer i__1, i__2;

    /* Local variables */
    integer i__, j;
    doublereal d1, d2, d3;
    integer dir;
    doublereal tmp;
    integer endd;
    extern logical igraphlsame_(char *, char *);
    integer stack[64]	/* was [2][32] */;
    doublereal dmnmx;
    integer start;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    integer stkpnt;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input paramters.   

       Parameter adjustments */
    --d__;

    /* Function Body */
    *info = 0;
    dir = -1;
    if (igraphlsame_(id, "D")) {
	dir = 0;
    } else if (igraphlsame_(id, "I")) {
	dir = 1;
    }
    if (dir == -1) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DLASRT", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n <= 1) {
	return 0;
    }

    stkpnt = 1;
    stack[0] = 1;
    stack[1] = *n;
L10:
    start = stack[(stkpnt << 1) - 2];
    endd = stack[(stkpnt << 1) - 1];
    --stkpnt;
    if (endd - start <= 20 && endd - start > 0) {

/*        Do Insertion sort on D( START:ENDD ) */

	if (dir == 0) {

/*           Sort into decreasing order */

	    i__1 = endd;
	    for (i__ = start + 1; i__ <= i__1; ++i__) {
		i__2 = start + 1;
		for (j = i__; j >= i__2; --j) {
		    if (d__[j] > d__[j - 1]) {
			dmnmx = d__[j];
			d__[j] = d__[j - 1];
			d__[j - 1] = dmnmx;
		    } else {
			goto L30;
		    }
/* L20: */
		}
L30:
		;
	    }

	} else {

/*           Sort into increasing order */

	    i__1 = endd;
	    for (i__ = start + 1; i__ <= i__1; ++i__) {
		i__2 = start + 1;
		for (j = i__; j >= i__2; --j) {
		    if (d__[j] < d__[j - 1]) {
			dmnmx = d__[j];
			d__[j] = d__[j - 1];
			d__[j - 1] = dmnmx;
		    } else {
			goto L50;
		    }
/* L40: */
		}
L50:
		;
	    }

	}

    } else if (endd - start > 20) {

/*        Partition D( START:ENDD ) and stack parts, largest one first   

          Choose partition entry as median of 3 */

	d1 = d__[start];
	d2 = d__[endd];
	i__ = (start + endd) / 2;
	d3 = d__[i__];
	if (d1 < d2) {
	    if (d3 < d1) {
		dmnmx = d1;
	    } else if (d3 < d2) {
		dmnmx = d3;
	    } else {
		dmnmx = d2;
	    }
	} else {
	    if (d3 < d2) {
		dmnmx = d2;
	    } else if (d3 < d1) {
		dmnmx = d3;
	    } else {
		dmnmx = d1;
	    }
	}

	if (dir == 0) {

/*           Sort into decreasing order */

	    i__ = start - 1;
	    j = endd + 1;
L60:
L70:
	    --j;
	    if (d__[j] < dmnmx) {
		goto L70;
	    }
L80:
	    ++i__;
	    if (d__[i__] > dmnmx) {
		goto L80;
	    }
	    if (i__ < j) {
		tmp = d__[i__];
		d__[i__] = d__[j];
		d__[j] = tmp;
		goto L60;
	    }
	    if (j - start > endd - j - 1) {
		++stkpnt;
		stack[(stkpnt << 1) - 2] = start;
		stack[(stkpnt << 1) - 1] = j;
		++stkpnt;
		stack[(stkpnt << 1) - 2] = j + 1;
		stack[(stkpnt << 1) - 1] = endd;
	    } else {
		++stkpnt;
		stack[(stkpnt << 1) - 2] = j + 1;
		stack[(stkpnt << 1) - 1] = endd;
		++stkpnt;
		stack[(stkpnt << 1) - 2] = start;
		stack[(stkpnt << 1) - 1] = j;
	    }
	} else {

/*           Sort into increasing order */

	    i__ = start - 1;
	    j = endd + 1;
L90:
L100:
	    --j;
	    if (d__[j] > dmnmx) {
		goto L100;
	    }
L110:
	    ++i__;
	    if (d__[i__] < dmnmx) {
		goto L110;
	    }
	    if (i__ < j) {
		tmp = d__[i__];
		d__[i__] = d__[j];
		d__[j] = tmp;
		goto L90;
	    }
	    if (j - start > endd - j - 1) {
		++stkpnt;
		stack[(stkpnt << 1) - 2] = start;
		stack[(stkpnt << 1) - 1] = j;
		++stkpnt;
		stack[(stkpnt << 1) - 2] = j + 1;
		stack[(stkpnt << 1) - 1] = endd;
	    } else {
		++stkpnt;
		stack[(stkpnt << 1) - 2] = j + 1;
		stack[(stkpnt << 1) - 1] = endd;
		++stkpnt;
		stack[(stkpnt << 1) - 2] = start;
		stack[(stkpnt << 1) - 1] = j;
	    }
	}
    }
    if (stkpnt > 0) {
	goto L10;
    }
    return 0;

/*     End of DLASRT */

} /* igraphdlasrt_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlassq.c0000644000175100001710000001152000000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASSQ updates a sum of squares represented in scaled form.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASSQ + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASSQ( N, X, INCX, SCALE, SUMSQ )   

         INTEGER            INCX, N   
         DOUBLE PRECISION   SCALE, SUMSQ   
         DOUBLE PRECISION   X( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASSQ  returns the values  scl  and  smsq  such that   
   >   
   >    ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,   
   >   
   > where  x( i ) = X( 1 + ( i - 1 )*INCX ). The value of  sumsq  is   
   > assumed to be non-negative and  scl  returns the value   
   >   
   >    scl = max( scale, abs( x( i ) ) ).   
   >   
   > scale and sumsq must be supplied in SCALE and SUMSQ and   
   > scl and smsq are overwritten on SCALE and SUMSQ respectively.   
   >   
   > The routine makes only one pass through the vector x.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of elements to be used from the vector X.   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (N)   
   >          The vector for which a scaled sum of squares is computed.   
   >             x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >          The increment between successive values of the vector X.   
   >          INCX > 0.   
   > \endverbatim   
   >   
   > \param[in,out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION   
   >          On entry, the value  scale  in the equation above.   
   >          On exit, SCALE is overwritten with  scl , the scaling factor   
   >          for the sum of squares.   
   > \endverbatim   
   >   
   > \param[in,out] SUMSQ   
   > \verbatim   
   >          SUMSQ is DOUBLE PRECISION   
   >          On entry, the value  sumsq  in the equation above.   
   >          On exit, SUMSQ is overwritten with  smsq , the basic sum of   
   >          squares from which  scl  has been factored out.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlassq_(integer *n, doublereal *x, integer *incx, 
	doublereal *scale, doublereal *sumsq)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal d__1;

    /* Local variables */
    integer ix;
    doublereal absxi;
    extern logical igraphdisnan_(doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Parameter adjustments */
    --x;

    /* Function Body */
    if (*n > 0) {
	i__1 = (*n - 1) * *incx + 1;
	i__2 = *incx;
	for (ix = 1; i__2 < 0 ? ix >= i__1 : ix <= i__1; ix += i__2) {
	    absxi = (d__1 = x[ix], abs(d__1));
	    if (absxi > 0. || igraphdisnan_(&absxi)) {
		if (*scale < absxi) {
/* Computing 2nd power */
		    d__1 = *scale / absxi;
		    *sumsq = *sumsq * (d__1 * d__1) + 1;
		    *scale = absxi;
		} else {
/* Computing 2nd power */
		    d__1 = absxi / *scale;
		    *sumsq += d__1 * d__1;
		}
	    }
/* L10: */
	}
    }
    return 0;

/*     End of DLASSQ */

} /* igraphdlassq_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlaswp.c0000644000175100001710000001340000000000000024036 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DLASWP performs a series of row interchanges on a general rectangular matrix.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASWP + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASWP( N, A, LDA, K1, K2, IPIV, INCX )   

         INTEGER            INCX, K1, K2, LDA, N   
         INTEGER            IPIV( * )   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASWP performs a series of row interchanges on the matrix A.   
   > One row interchange is initiated for each of rows K1 through K2 of A.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the matrix of column dimension N to which the row   
   >          interchanges will be applied.   
   >          On exit, the permuted matrix.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   > \endverbatim   
   >   
   > \param[in] K1   
   > \verbatim   
   >          K1 is INTEGER   
   >          The first element of IPIV for which a row interchange will   
   >          be done.   
   > \endverbatim   
   >   
   > \param[in] K2   
   > \verbatim   
   >          K2 is INTEGER   
   >          The last element of IPIV for which a row interchange will   
   >          be done.   
   > \endverbatim   
   >   
   > \param[in] IPIV   
   > \verbatim   
   >          IPIV is INTEGER array, dimension (K2*abs(INCX))   
   >          The vector of pivot indices.  Only the elements in positions   
   >          K1 through K2 of IPIV are accessed.   
   >          IPIV(K) = L implies rows K and L are to be interchanged.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >          The increment between successive values of IPIV.  If IPIV   
   >          is negative, the pivots are applied in reverse order.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Modified by   
   >   R. C. Whaley, Computer Science Dept., Univ. of Tenn., Knoxville, USA   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlaswp_(integer *n, doublereal *a, integer *lda, integer 
	*k1, integer *k2, integer *ipiv, integer *incx)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4;

    /* Local variables */
    integer i__, j, k, i1, i2, n32, ip, ix, ix0, inc;
    doublereal temp;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Interchange row I with row IPIV(I) for each of rows K1 through K2.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --ipiv;

    /* Function Body */
    if (*incx > 0) {
	ix0 = *k1;
	i1 = *k1;
	i2 = *k2;
	inc = 1;
    } else if (*incx < 0) {
	ix0 = (1 - *k2) * *incx + 1;
	i1 = *k2;
	i2 = *k1;
	inc = -1;
    } else {
	return 0;
    }

    n32 = *n / 32 << 5;
    if (n32 != 0) {
	i__1 = n32;
	for (j = 1; j <= i__1; j += 32) {
	    ix = ix0;
	    i__2 = i2;
	    i__3 = inc;
	    for (i__ = i1; i__3 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__3) 
		    {
		ip = ipiv[ix];
		if (ip != i__) {
		    i__4 = j + 31;
		    for (k = j; k <= i__4; ++k) {
			temp = a[i__ + k * a_dim1];
			a[i__ + k * a_dim1] = a[ip + k * a_dim1];
			a[ip + k * a_dim1] = temp;
/* L10: */
		    }
		}
		ix += *incx;
/* L20: */
	    }
/* L30: */
	}
    }
    if (n32 != *n) {
	++n32;
	ix = ix0;
	i__1 = i2;
	i__3 = inc;
	for (i__ = i1; i__3 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__3) {
	    ip = ipiv[ix];
	    if (ip != i__) {
		i__2 = *n;
		for (k = n32; k <= i__2; ++k) {
		    temp = a[i__ + k * a_dim1];
		    a[i__ + k * a_dim1] = a[ip + k * a_dim1];
		    a[ip + k * a_dim1] = temp;
/* L40: */
		}
	    }
	    ix += *incx;
/* L50: */
	}
    }

    return 0;

/*     End of DLASWP */

} /* igraphdlaswp_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlasy2.c0000644000175100001710000004074600000000000023757 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__4 = 4;
static integer c__1 = 1;
static integer c__16 = 16;
static integer c__0 = 0;

/* > \brief \b DLASY2 solves the Sylvester matrix equation where the matrices are of order 1 or 2.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLASY2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLASY2( LTRANL, LTRANR, ISGN, N1, N2, TL, LDTL, TR,   
                            LDTR, B, LDB, SCALE, X, LDX, XNORM, INFO )   

         LOGICAL            LTRANL, LTRANR   
         INTEGER            INFO, ISGN, LDB, LDTL, LDTR, LDX, N1, N2   
         DOUBLE PRECISION   SCALE, XNORM   
         DOUBLE PRECISION   B( LDB, * ), TL( LDTL, * ), TR( LDTR, * ),   
        $                   X( LDX, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLASY2 solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in   
   >   
   >        op(TL)*X + ISGN*X*op(TR) = SCALE*B,   
   >   
   > where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or   
   > -1.  op(T) = T or T**T, where T**T denotes the transpose of T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] LTRANL   
   > \verbatim   
   >          LTRANL is LOGICAL   
   >          On entry, LTRANL specifies the op(TL):   
   >             = .FALSE., op(TL) = TL,   
   >             = .TRUE., op(TL) = TL**T.   
   > \endverbatim   
   >   
   > \param[in] LTRANR   
   > \verbatim   
   >          LTRANR is LOGICAL   
   >          On entry, LTRANR specifies the op(TR):   
   >            = .FALSE., op(TR) = TR,   
   >            = .TRUE., op(TR) = TR**T.   
   > \endverbatim   
   >   
   > \param[in] ISGN   
   > \verbatim   
   >          ISGN is INTEGER   
   >          On entry, ISGN specifies the sign of the equation   
   >          as described before. ISGN may only be 1 or -1.   
   > \endverbatim   
   >   
   > \param[in] N1   
   > \verbatim   
   >          N1 is INTEGER   
   >          On entry, N1 specifies the order of matrix TL.   
   >          N1 may only be 0, 1 or 2.   
   > \endverbatim   
   >   
   > \param[in] N2   
   > \verbatim   
   >          N2 is INTEGER   
   >          On entry, N2 specifies the order of matrix TR.   
   >          N2 may only be 0, 1 or 2.   
   > \endverbatim   
   >   
   > \param[in] TL   
   > \verbatim   
   >          TL is DOUBLE PRECISION array, dimension (LDTL,2)   
   >          On entry, TL contains an N1 by N1 matrix.   
   > \endverbatim   
   >   
   > \param[in] LDTL   
   > \verbatim   
   >          LDTL is INTEGER   
   >          The leading dimension of the matrix TL. LDTL >= max(1,N1).   
   > \endverbatim   
   >   
   > \param[in] TR   
   > \verbatim   
   >          TR is DOUBLE PRECISION array, dimension (LDTR,2)   
   >          On entry, TR contains an N2 by N2 matrix.   
   > \endverbatim   
   >   
   > \param[in] LDTR   
   > \verbatim   
   >          LDTR is INTEGER   
   >          The leading dimension of the matrix TR. LDTR >= max(1,N2).   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,2)   
   >          On entry, the N1 by N2 matrix B contains the right-hand   
   >          side of the equation.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of the matrix B. LDB >= max(1,N1).   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION   
   >          On exit, SCALE contains the scale factor. SCALE is chosen   
   >          less than or equal to 1 to prevent the solution overflowing.   
   > \endverbatim   
   >   
   > \param[out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension (LDX,2)   
   >          On exit, X contains the N1 by N2 solution.   
   > \endverbatim   
   >   
   > \param[in] LDX   
   > \verbatim   
   >          LDX is INTEGER   
   >          The leading dimension of the matrix X. LDX >= max(1,N1).   
   > \endverbatim   
   >   
   > \param[out] XNORM   
   > \verbatim   
   >          XNORM is DOUBLE PRECISION   
   >          On exit, XNORM is the infinity-norm of the solution.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          On exit, INFO is set to   
   >             0: successful exit.   
   >             1: TL and TR have too close eigenvalues, so TL or   
   >                TR is perturbed to get a nonsingular equation.   
   >          NOTE: In the interests of speed, this routine does not   
   >                check the inputs for errors.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleSYauxiliary   

    =====================================================================   
   Subroutine */ int igraphdlasy2_(logical *ltranl, logical *ltranr, integer *isgn, 
	integer *n1, integer *n2, doublereal *tl, integer *ldtl, doublereal *
	tr, integer *ldtr, doublereal *b, integer *ldb, doublereal *scale, 
	doublereal *x, integer *ldx, doublereal *xnorm, integer *info)
{
    /* Initialized data */

    static integer locu12[4] = { 3,4,1,2 };
    static integer locl21[4] = { 2,1,4,3 };
    static integer locu22[4] = { 4,3,2,1 };
    static logical xswpiv[4] = { FALSE_,FALSE_,TRUE_,TRUE_ };
    static logical bswpiv[4] = { FALSE_,TRUE_,FALSE_,TRUE_ };

    /* System generated locals */
    integer b_dim1, b_offset, tl_dim1, tl_offset, tr_dim1, tr_offset, x_dim1, 
	    x_offset;
    doublereal d__1, d__2, d__3, d__4, d__5, d__6, d__7, d__8;

    /* Local variables */
    integer i__, j, k;
    doublereal x2[2], l21, u11, u12;
    integer ip, jp;
    doublereal u22, t16[16]	/* was [4][4] */, gam, bet, eps, sgn, tmp[4], 
	    tau1, btmp[4], smin;
    integer ipiv;
    doublereal temp;
    integer jpiv[4];
    doublereal xmax;
    integer ipsv, jpsv;
    logical bswap;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdswap_(integer *, doublereal *, integer 
	    *, doublereal *, integer *);
    logical xswap;
    extern doublereal igraphdlamch_(char *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    doublereal smlnum;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   

       Parameter adjustments */
    tl_dim1 = *ldtl;
    tl_offset = 1 + tl_dim1;
    tl -= tl_offset;
    tr_dim1 = *ldtr;
    tr_offset = 1 + tr_dim1;
    tr -= tr_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;
    x_dim1 = *ldx;
    x_offset = 1 + x_dim1;
    x -= x_offset;

    /* Function Body   

       Do not check the input parameters for errors */

    *info = 0;

/*     Quick return if possible */

    if (*n1 == 0 || *n2 == 0) {
	return 0;
    }

/*     Set constants to control overflow */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S") / eps;
    sgn = (doublereal) (*isgn);

    k = *n1 + *n1 + *n2 - 2;
    switch (k) {
	case 1:  goto L10;
	case 2:  goto L20;
	case 3:  goto L30;
	case 4:  goto L50;
    }

/*     1 by 1: TL11*X + SGN*X*TR11 = B11 */

L10:
    tau1 = tl[tl_dim1 + 1] + sgn * tr[tr_dim1 + 1];
    bet = abs(tau1);
    if (bet <= smlnum) {
	tau1 = smlnum;
	bet = smlnum;
	*info = 1;
    }

    *scale = 1.;
    gam = (d__1 = b[b_dim1 + 1], abs(d__1));
    if (smlnum * gam > bet) {
	*scale = 1. / gam;
    }

    x[x_dim1 + 1] = b[b_dim1 + 1] * *scale / tau1;
    *xnorm = (d__1 = x[x_dim1 + 1], abs(d__1));
    return 0;

/*     1 by 2:   
       TL11*[X11 X12] + ISGN*[X11 X12]*op[TR11 TR12]  = [B11 B12]   
                                         [TR21 TR22] */

L20:

/* Computing MAX   
   Computing MAX */
    d__7 = (d__1 = tl[tl_dim1 + 1], abs(d__1)), d__8 = (d__2 = tr[tr_dim1 + 1]
	    , abs(d__2)), d__7 = max(d__7,d__8), d__8 = (d__3 = tr[(tr_dim1 <<
	     1) + 1], abs(d__3)), d__7 = max(d__7,d__8), d__8 = (d__4 = tr[
	    tr_dim1 + 2], abs(d__4)), d__7 = max(d__7,d__8), d__8 = (d__5 = 
	    tr[(tr_dim1 << 1) + 2], abs(d__5));
    d__6 = eps * max(d__7,d__8);
    smin = max(d__6,smlnum);
    tmp[0] = tl[tl_dim1 + 1] + sgn * tr[tr_dim1 + 1];
    tmp[3] = tl[tl_dim1 + 1] + sgn * tr[(tr_dim1 << 1) + 2];
    if (*ltranr) {
	tmp[1] = sgn * tr[tr_dim1 + 2];
	tmp[2] = sgn * tr[(tr_dim1 << 1) + 1];
    } else {
	tmp[1] = sgn * tr[(tr_dim1 << 1) + 1];
	tmp[2] = sgn * tr[tr_dim1 + 2];
    }
    btmp[0] = b[b_dim1 + 1];
    btmp[1] = b[(b_dim1 << 1) + 1];
    goto L40;

/*     2 by 1:   
            op[TL11 TL12]*[X11] + ISGN* [X11]*TR11  = [B11]   
              [TL21 TL22] [X21]         [X21]         [B21] */

L30:
/* Computing MAX   
   Computing MAX */
    d__7 = (d__1 = tr[tr_dim1 + 1], abs(d__1)), d__8 = (d__2 = tl[tl_dim1 + 1]
	    , abs(d__2)), d__7 = max(d__7,d__8), d__8 = (d__3 = tl[(tl_dim1 <<
	     1) + 1], abs(d__3)), d__7 = max(d__7,d__8), d__8 = (d__4 = tl[
	    tl_dim1 + 2], abs(d__4)), d__7 = max(d__7,d__8), d__8 = (d__5 = 
	    tl[(tl_dim1 << 1) + 2], abs(d__5));
    d__6 = eps * max(d__7,d__8);
    smin = max(d__6,smlnum);
    tmp[0] = tl[tl_dim1 + 1] + sgn * tr[tr_dim1 + 1];
    tmp[3] = tl[(tl_dim1 << 1) + 2] + sgn * tr[tr_dim1 + 1];
    if (*ltranl) {
	tmp[1] = tl[(tl_dim1 << 1) + 1];
	tmp[2] = tl[tl_dim1 + 2];
    } else {
	tmp[1] = tl[tl_dim1 + 2];
	tmp[2] = tl[(tl_dim1 << 1) + 1];
    }
    btmp[0] = b[b_dim1 + 1];
    btmp[1] = b[b_dim1 + 2];
L40:

/*     Solve 2 by 2 system using complete pivoting.   
       Set pivots less than SMIN to SMIN. */

    ipiv = igraphidamax_(&c__4, tmp, &c__1);
    u11 = tmp[ipiv - 1];
    if (abs(u11) <= smin) {
	*info = 1;
	u11 = smin;
    }
    u12 = tmp[locu12[ipiv - 1] - 1];
    l21 = tmp[locl21[ipiv - 1] - 1] / u11;
    u22 = tmp[locu22[ipiv - 1] - 1] - u12 * l21;
    xswap = xswpiv[ipiv - 1];
    bswap = bswpiv[ipiv - 1];
    if (abs(u22) <= smin) {
	*info = 1;
	u22 = smin;
    }
    if (bswap) {
	temp = btmp[1];
	btmp[1] = btmp[0] - l21 * temp;
	btmp[0] = temp;
    } else {
	btmp[1] -= l21 * btmp[0];
    }
    *scale = 1.;
    if (smlnum * 2. * abs(btmp[1]) > abs(u22) || smlnum * 2. * abs(btmp[0]) > 
	    abs(u11)) {
/* Computing MAX */
	d__1 = abs(btmp[0]), d__2 = abs(btmp[1]);
	*scale = .5 / max(d__1,d__2);
	btmp[0] *= *scale;
	btmp[1] *= *scale;
    }
    x2[1] = btmp[1] / u22;
    x2[0] = btmp[0] / u11 - u12 / u11 * x2[1];
    if (xswap) {
	temp = x2[1];
	x2[1] = x2[0];
	x2[0] = temp;
    }
    x[x_dim1 + 1] = x2[0];
    if (*n1 == 1) {
	x[(x_dim1 << 1) + 1] = x2[1];
	*xnorm = (d__1 = x[x_dim1 + 1], abs(d__1)) + (d__2 = x[(x_dim1 << 1) 
		+ 1], abs(d__2));
    } else {
	x[x_dim1 + 2] = x2[1];
/* Computing MAX */
	d__3 = (d__1 = x[x_dim1 + 1], abs(d__1)), d__4 = (d__2 = x[x_dim1 + 2]
		, abs(d__2));
	*xnorm = max(d__3,d__4);
    }
    return 0;

/*     2 by 2:   
       op[TL11 TL12]*[X11 X12] +ISGN* [X11 X12]*op[TR11 TR12] = [B11 B12]   
         [TL21 TL22] [X21 X22]        [X21 X22]   [TR21 TR22]   [B21 B22]   

       Solve equivalent 4 by 4 system using complete pivoting.   
       Set pivots less than SMIN to SMIN. */

L50:
/* Computing MAX */
    d__5 = (d__1 = tr[tr_dim1 + 1], abs(d__1)), d__6 = (d__2 = tr[(tr_dim1 << 
	    1) + 1], abs(d__2)), d__5 = max(d__5,d__6), d__6 = (d__3 = tr[
	    tr_dim1 + 2], abs(d__3)), d__5 = max(d__5,d__6), d__6 = (d__4 = 
	    tr[(tr_dim1 << 1) + 2], abs(d__4));
    smin = max(d__5,d__6);
/* Computing MAX */
    d__5 = smin, d__6 = (d__1 = tl[tl_dim1 + 1], abs(d__1)), d__5 = max(d__5,
	    d__6), d__6 = (d__2 = tl[(tl_dim1 << 1) + 1], abs(d__2)), d__5 = 
	    max(d__5,d__6), d__6 = (d__3 = tl[tl_dim1 + 2], abs(d__3)), d__5 =
	     max(d__5,d__6), d__6 = (d__4 = tl[(tl_dim1 << 1) + 2], abs(d__4))
	    ;
    smin = max(d__5,d__6);
/* Computing MAX */
    d__1 = eps * smin;
    smin = max(d__1,smlnum);
    btmp[0] = 0.;
    igraphdcopy_(&c__16, btmp, &c__0, t16, &c__1);
    t16[0] = tl[tl_dim1 + 1] + sgn * tr[tr_dim1 + 1];
    t16[5] = tl[(tl_dim1 << 1) + 2] + sgn * tr[tr_dim1 + 1];
    t16[10] = tl[tl_dim1 + 1] + sgn * tr[(tr_dim1 << 1) + 2];
    t16[15] = tl[(tl_dim1 << 1) + 2] + sgn * tr[(tr_dim1 << 1) + 2];
    if (*ltranl) {
	t16[4] = tl[tl_dim1 + 2];
	t16[1] = tl[(tl_dim1 << 1) + 1];
	t16[14] = tl[tl_dim1 + 2];
	t16[11] = tl[(tl_dim1 << 1) + 1];
    } else {
	t16[4] = tl[(tl_dim1 << 1) + 1];
	t16[1] = tl[tl_dim1 + 2];
	t16[14] = tl[(tl_dim1 << 1) + 1];
	t16[11] = tl[tl_dim1 + 2];
    }
    if (*ltranr) {
	t16[8] = sgn * tr[(tr_dim1 << 1) + 1];
	t16[13] = sgn * tr[(tr_dim1 << 1) + 1];
	t16[2] = sgn * tr[tr_dim1 + 2];
	t16[7] = sgn * tr[tr_dim1 + 2];
    } else {
	t16[8] = sgn * tr[tr_dim1 + 2];
	t16[13] = sgn * tr[tr_dim1 + 2];
	t16[2] = sgn * tr[(tr_dim1 << 1) + 1];
	t16[7] = sgn * tr[(tr_dim1 << 1) + 1];
    }
    btmp[0] = b[b_dim1 + 1];
    btmp[1] = b[b_dim1 + 2];
    btmp[2] = b[(b_dim1 << 1) + 1];
    btmp[3] = b[(b_dim1 << 1) + 2];

/*     Perform elimination */

    for (i__ = 1; i__ <= 3; ++i__) {
	xmax = 0.;
	for (ip = i__; ip <= 4; ++ip) {
	    for (jp = i__; jp <= 4; ++jp) {
		if ((d__1 = t16[ip + (jp << 2) - 5], abs(d__1)) >= xmax) {
		    xmax = (d__1 = t16[ip + (jp << 2) - 5], abs(d__1));
		    ipsv = ip;
		    jpsv = jp;
		}
/* L60: */
	    }
/* L70: */
	}
	if (ipsv != i__) {
	    igraphdswap_(&c__4, &t16[ipsv - 1], &c__4, &t16[i__ - 1], &c__4);
	    temp = btmp[i__ - 1];
	    btmp[i__ - 1] = btmp[ipsv - 1];
	    btmp[ipsv - 1] = temp;
	}
	if (jpsv != i__) {
	    igraphdswap_(&c__4, &t16[(jpsv << 2) - 4], &c__1, &t16[(i__ << 2) - 4], 
		    &c__1);
	}
	jpiv[i__ - 1] = jpsv;
	if ((d__1 = t16[i__ + (i__ << 2) - 5], abs(d__1)) < smin) {
	    *info = 1;
	    t16[i__ + (i__ << 2) - 5] = smin;
	}
	for (j = i__ + 1; j <= 4; ++j) {
	    t16[j + (i__ << 2) - 5] /= t16[i__ + (i__ << 2) - 5];
	    btmp[j - 1] -= t16[j + (i__ << 2) - 5] * btmp[i__ - 1];
	    for (k = i__ + 1; k <= 4; ++k) {
		t16[j + (k << 2) - 5] -= t16[j + (i__ << 2) - 5] * t16[i__ + (
			k << 2) - 5];
/* L80: */
	    }
/* L90: */
	}
/* L100: */
    }
    if (abs(t16[15]) < smin) {
	t16[15] = smin;
    }
    *scale = 1.;
    if (smlnum * 8. * abs(btmp[0]) > abs(t16[0]) || smlnum * 8. * abs(btmp[1])
	     > abs(t16[5]) || smlnum * 8. * abs(btmp[2]) > abs(t16[10]) || 
	    smlnum * 8. * abs(btmp[3]) > abs(t16[15])) {
/* Computing MAX */
	d__1 = abs(btmp[0]), d__2 = abs(btmp[1]), d__1 = max(d__1,d__2), d__2 
		= abs(btmp[2]), d__1 = max(d__1,d__2), d__2 = abs(btmp[3]);
	*scale = .125 / max(d__1,d__2);
	btmp[0] *= *scale;
	btmp[1] *= *scale;
	btmp[2] *= *scale;
	btmp[3] *= *scale;
    }
    for (i__ = 1; i__ <= 4; ++i__) {
	k = 5 - i__;
	temp = 1. / t16[k + (k << 2) - 5];
	tmp[k - 1] = btmp[k - 1] * temp;
	for (j = k + 1; j <= 4; ++j) {
	    tmp[k - 1] -= temp * t16[k + (j << 2) - 5] * tmp[j - 1];
/* L110: */
	}
/* L120: */
    }
    for (i__ = 1; i__ <= 3; ++i__) {
	if (jpiv[4 - i__ - 1] != 4 - i__) {
	    temp = tmp[4 - i__ - 1];
	    tmp[4 - i__ - 1] = tmp[jpiv[4 - i__ - 1] - 1];
	    tmp[jpiv[4 - i__ - 1] - 1] = temp;
	}
/* L130: */
    }
    x[x_dim1 + 1] = tmp[0];
    x[x_dim1 + 2] = tmp[1];
    x[(x_dim1 << 1) + 1] = tmp[2];
    x[(x_dim1 << 1) + 2] = tmp[3];
/* Computing MAX */
    d__1 = abs(tmp[0]) + abs(tmp[2]), d__2 = abs(tmp[1]) + abs(tmp[3]);
    *xnorm = max(d__1,d__2);
    return 0;

/*     End of DLASY2 */

} /* igraphdlasy2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dlatrd.c0000644000175100001710000003433000000000000024023 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b5 = -1.;
static doublereal c_b6 = 1.;
static integer c__1 = 1;
static doublereal c_b16 = 0.;

/* > \brief \b DLATRD reduces the first nb rows and columns of a symmetric/Hermitian matrix A to real tridiago
nal form by an orthogonal similarity transformation.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DLATRD + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DLATRD( UPLO, N, NB, A, LDA, E, TAU, W, LDW )   

         CHARACTER          UPLO   
         INTEGER            LDA, LDW, N, NB   
         DOUBLE PRECISION   A( LDA, * ), E( * ), TAU( * ), W( LDW, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DLATRD reduces NB rows and columns of a real symmetric matrix A to   
   > symmetric tridiagonal form by an orthogonal similarity   
   > transformation Q**T * A * Q, and returns the matrices V and W which are   
   > needed to apply the transformation to the unreduced part of A.   
   >   
   > If UPLO = 'U', DLATRD reduces the last NB rows and columns of a   
   > matrix, of which the upper triangle is supplied;   
   > if UPLO = 'L', DLATRD reduces the first NB rows and columns of a   
   > matrix, of which the lower triangle is supplied.   
   >   
   > This is an auxiliary routine called by DSYTRD.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies whether the upper or lower triangular part of the   
   >          symmetric matrix A is stored:   
   >          = 'U': Upper triangular   
   >          = 'L': Lower triangular   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] NB   
   > \verbatim   
   >          NB is INTEGER   
   >          The number of rows and columns to be reduced.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the leading   
   >          n-by-n upper triangular part of A contains the upper   
   >          triangular part of the matrix A, and the strictly lower   
   >          triangular part of A is not referenced.  If UPLO = 'L', the   
   >          leading n-by-n lower triangular part of A contains the lower   
   >          triangular part of the matrix A, and the strictly upper   
   >          triangular part of A is not referenced.   
   >          On exit:   
   >          if UPLO = 'U', the last NB columns have been reduced to   
   >            tridiagonal form, with the diagonal elements overwriting   
   >            the diagonal elements of A; the elements above the diagonal   
   >            with the array TAU, represent the orthogonal matrix Q as a   
   >            product of elementary reflectors;   
   >          if UPLO = 'L', the first NB columns have been reduced to   
   >            tridiagonal form, with the diagonal elements overwriting   
   >            the diagonal elements of A; the elements below the diagonal   
   >            with the array TAU, represent the  orthogonal matrix Q as a   
   >            product of elementary reflectors.   
   >          See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= (1,N).   
   > \endverbatim   
   >   
   > \param[out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          If UPLO = 'U', E(n-nb:n-1) contains the superdiagonal   
   >          elements of the last NB columns of the reduced matrix;   
   >          if UPLO = 'L', E(1:nb) contains the subdiagonal elements of   
   >          the first NB columns of the reduced matrix.   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          The scalar factors of the elementary reflectors, stored in   
   >          TAU(n-nb:n-1) if UPLO = 'U', and in TAU(1:nb) if UPLO = 'L'.   
   >          See Further Details.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (LDW,NB)   
   >          The n-by-nb matrix W required to update the unreduced part   
   >          of A.   
   > \endverbatim   
   >   
   > \param[in] LDW   
   > \verbatim   
   >          LDW is INTEGER   
   >          The leading dimension of the array W. LDW >= max(1,N).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  If UPLO = 'U', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(n) H(n-1) . . . H(n-nb+1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(i:n) = 0 and v(i-1) = 1; v(1:i-1) is stored on exit in A(1:i-1,i),   
   >  and tau in TAU(i-1).   
   >   
   >  If UPLO = 'L', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(1) H(2) . . . H(nb).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i) = 0 and v(i+1) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),   
   >  and tau in TAU(i).   
   >   
   >  The elements of the vectors v together form the n-by-nb matrix V   
   >  which is needed, with W, to apply the transformation to the unreduced   
   >  part of the matrix, using a symmetric rank-2k update of the form:   
   >  A := A - V*W**T - W*V**T.   
   >   
   >  The contents of A on exit are illustrated by the following examples   
   >  with n = 5 and nb = 2:   
   >   
   >  if UPLO = 'U':                       if UPLO = 'L':   
   >   
   >    (  a   a   a   v4  v5 )              (  d                  )   
   >    (      a   a   v4  v5 )              (  1   d              )   
   >    (          a   1   v5 )              (  v1  1   a          )   
   >    (              d   1  )              (  v1  v2  a   a      )   
   >    (                  d  )              (  v1  v2  a   a   a  )   
   >   
   >  where d denotes a diagonal element of the reduced matrix, a denotes   
   >  an element of the original matrix that is unchanged, and vi denotes   
   >  an element of the vector defining H(i).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdlatrd_(char *uplo, integer *n, integer *nb, doublereal *
	a, integer *lda, doublereal *e, doublereal *tau, doublereal *w, 
	integer *ldw)
{
    /* System generated locals */
    integer a_dim1, a_offset, w_dim1, w_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, iw;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    doublereal alpha;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *), igraphdaxpy_(integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *), 
	    igraphdsymv_(char *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *), igraphdlarfg_(integer *, doublereal *, doublereal *, integer *,
	     doublereal *);


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Quick return if possible   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --e;
    --tau;
    w_dim1 = *ldw;
    w_offset = 1 + w_dim1;
    w -= w_offset;

    /* Function Body */
    if (*n <= 0) {
	return 0;
    }

    if (igraphlsame_(uplo, "U")) {

/*        Reduce last NB columns of upper triangle */

	i__1 = *n - *nb + 1;
	for (i__ = *n; i__ >= i__1; --i__) {
	    iw = i__ - *n + *nb;
	    if (i__ < *n) {

/*              Update A(1:i,i) */

		i__2 = *n - i__;
		igraphdgemv_("No transpose", &i__, &i__2, &c_b5, &a[(i__ + 1) * 
			a_dim1 + 1], lda, &w[i__ + (iw + 1) * w_dim1], ldw, &
			c_b6, &a[i__ * a_dim1 + 1], &c__1);
		i__2 = *n - i__;
		igraphdgemv_("No transpose", &i__, &i__2, &c_b5, &w[(iw + 1) * 
			w_dim1 + 1], ldw, &a[i__ + (i__ + 1) * a_dim1], lda, &
			c_b6, &a[i__ * a_dim1 + 1], &c__1);
	    }
	    if (i__ > 1) {

/*              Generate elementary reflector H(i) to annihilate   
                A(1:i-2,i) */

		i__2 = i__ - 1;
		igraphdlarfg_(&i__2, &a[i__ - 1 + i__ * a_dim1], &a[i__ * a_dim1 + 
			1], &c__1, &tau[i__ - 1]);
		e[i__ - 1] = a[i__ - 1 + i__ * a_dim1];
		a[i__ - 1 + i__ * a_dim1] = 1.;

/*              Compute W(1:i-1,i) */

		i__2 = i__ - 1;
		igraphdsymv_("Upper", &i__2, &c_b6, &a[a_offset], lda, &a[i__ * 
			a_dim1 + 1], &c__1, &c_b16, &w[iw * w_dim1 + 1], &
			c__1);
		if (i__ < *n) {
		    i__2 = i__ - 1;
		    i__3 = *n - i__;
		    igraphdgemv_("Transpose", &i__2, &i__3, &c_b6, &w[(iw + 1) * 
			    w_dim1 + 1], ldw, &a[i__ * a_dim1 + 1], &c__1, &
			    c_b16, &w[i__ + 1 + iw * w_dim1], &c__1);
		    i__2 = i__ - 1;
		    i__3 = *n - i__;
		    igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &a[(i__ + 1) *
			     a_dim1 + 1], lda, &w[i__ + 1 + iw * w_dim1], &
			    c__1, &c_b6, &w[iw * w_dim1 + 1], &c__1);
		    i__2 = i__ - 1;
		    i__3 = *n - i__;
		    igraphdgemv_("Transpose", &i__2, &i__3, &c_b6, &a[(i__ + 1) * 
			    a_dim1 + 1], lda, &a[i__ * a_dim1 + 1], &c__1, &
			    c_b16, &w[i__ + 1 + iw * w_dim1], &c__1);
		    i__2 = i__ - 1;
		    i__3 = *n - i__;
		    igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &w[(iw + 1) * 
			    w_dim1 + 1], ldw, &w[i__ + 1 + iw * w_dim1], &
			    c__1, &c_b6, &w[iw * w_dim1 + 1], &c__1);
		}
		i__2 = i__ - 1;
		igraphdscal_(&i__2, &tau[i__ - 1], &w[iw * w_dim1 + 1], &c__1);
		i__2 = i__ - 1;
		alpha = tau[i__ - 1] * -.5 * igraphddot_(&i__2, &w[iw * w_dim1 + 1],
			 &c__1, &a[i__ * a_dim1 + 1], &c__1);
		i__2 = i__ - 1;
		igraphdaxpy_(&i__2, &alpha, &a[i__ * a_dim1 + 1], &c__1, &w[iw * 
			w_dim1 + 1], &c__1);
	    }

/* L10: */
	}
    } else {

/*        Reduce first NB columns of lower triangle */

	i__1 = *nb;
	for (i__ = 1; i__ <= i__1; ++i__) {

/*           Update A(i:n,i) */

	    i__2 = *n - i__ + 1;
	    i__3 = i__ - 1;
	    igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &a[i__ + a_dim1], lda,
		     &w[i__ + w_dim1], ldw, &c_b6, &a[i__ + i__ * a_dim1], &
		    c__1);
	    i__2 = *n - i__ + 1;
	    i__3 = i__ - 1;
	    igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &w[i__ + w_dim1], ldw,
		     &a[i__ + a_dim1], lda, &c_b6, &a[i__ + i__ * a_dim1], &
		    c__1);
	    if (i__ < *n) {

/*              Generate elementary reflector H(i) to annihilate   
                A(i+2:n,i) */

		i__2 = *n - i__;
/* Computing MIN */
		i__3 = i__ + 2;
		igraphdlarfg_(&i__2, &a[i__ + 1 + i__ * a_dim1], &a[min(i__3,*n) + 
			i__ * a_dim1], &c__1, &tau[i__]);
		e[i__] = a[i__ + 1 + i__ * a_dim1];
		a[i__ + 1 + i__ * a_dim1] = 1.;

/*              Compute W(i+1:n,i) */

		i__2 = *n - i__;
		igraphdsymv_("Lower", &i__2, &c_b6, &a[i__ + 1 + (i__ + 1) * a_dim1]
			, lda, &a[i__ + 1 + i__ * a_dim1], &c__1, &c_b16, &w[
			i__ + 1 + i__ * w_dim1], &c__1);
		i__2 = *n - i__;
		i__3 = i__ - 1;
		igraphdgemv_("Transpose", &i__2, &i__3, &c_b6, &w[i__ + 1 + w_dim1],
			 ldw, &a[i__ + 1 + i__ * a_dim1], &c__1, &c_b16, &w[
			i__ * w_dim1 + 1], &c__1);
		i__2 = *n - i__;
		i__3 = i__ - 1;
		igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &a[i__ + 1 + 
			a_dim1], lda, &w[i__ * w_dim1 + 1], &c__1, &c_b6, &w[
			i__ + 1 + i__ * w_dim1], &c__1);
		i__2 = *n - i__;
		i__3 = i__ - 1;
		igraphdgemv_("Transpose", &i__2, &i__3, &c_b6, &a[i__ + 1 + a_dim1],
			 lda, &a[i__ + 1 + i__ * a_dim1], &c__1, &c_b16, &w[
			i__ * w_dim1 + 1], &c__1);
		i__2 = *n - i__;
		i__3 = i__ - 1;
		igraphdgemv_("No transpose", &i__2, &i__3, &c_b5, &w[i__ + 1 + 
			w_dim1], ldw, &w[i__ * w_dim1 + 1], &c__1, &c_b6, &w[
			i__ + 1 + i__ * w_dim1], &c__1);
		i__2 = *n - i__;
		igraphdscal_(&i__2, &tau[i__], &w[i__ + 1 + i__ * w_dim1], &c__1);
		i__2 = *n - i__;
		alpha = tau[i__] * -.5 * igraphddot_(&i__2, &w[i__ + 1 + i__ * 
			w_dim1], &c__1, &a[i__ + 1 + i__ * a_dim1], &c__1);
		i__2 = *n - i__;
		igraphdaxpy_(&i__2, &alpha, &a[i__ + 1 + i__ * a_dim1], &c__1, &w[
			i__ + 1 + i__ * w_dim1], &c__1);
	    }

/* L20: */
	}
    }

    return 0;

/*     End of DLATRD */

} /* igraphdlatrd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dmout.c0000644000175100001710000002515400000000000023705 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__3 = 3;

/* -----------------------------------------------------------------------   
    Routine:    DMOUT   

    Purpose:    Real matrix output routine.   

    Usage:      CALL DMOUT (LOUT, M, N, A, LDA, IDIGIT, IFMT)   

    Arguments   
       M      - Number of rows of A.  (Input)   
       N      - Number of columns of A.  (Input)   
       A      - Real M by N matrix to be printed.  (Input)   
       LDA    - Leading dimension of A exactly as specified in the   
                dimension statement of the calling program.  (Input)   
       IFMT   - Format to be used in printing matrix A.  (Input)   
       IDIGIT - Print up to IABS(IDIGIT) decimal digits per number.  (In)   
                If IDIGIT .LT. 0, printing is done with 72 columns.   
                If IDIGIT .GT. 0, printing is done with 132 columns.   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdmout_(integer *lout, integer *m, integer *n, doublereal 
	*a, integer *lda, integer *idigit, char *ifmt, ftnlen ifmt_len)
{
    /* Initialized data */

    static char icol[1*3] = "C" "o" "l";

    /* Format strings */
    static char fmt_9999[] = "(/1x,a,/1x,a)";
    static char fmt_9998[] = "(10x,10(4x,3a1,i4,1x))";
    static char fmt_9994[] = "(1x,\002 Row\002,i4,\002:\002,1x,1p,10d12.3)";
    static char fmt_9997[] = "(10x,8(5x,3a1,i4,2x))";
    static char fmt_9993[] = "(1x,\002 Row\002,i4,\002:\002,1x,1p,8d14.5)";
    static char fmt_9996[] = "(10x,6(7x,3a1,i4,4x))";
    static char fmt_9992[] = "(1x,\002 Row\002,i4,\002:\002,1x,1p,6d18.9)";
    static char fmt_9995[] = "(10x,5(9x,3a1,i4,6x))";
    static char fmt_9991[] = "(1x,\002 Row\002,i4,\002:\002,1x,1p,5d22.13)";
    static char fmt_9990[] = "(1x,\002 \002)";

    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Builtin functions */
    integer i_len(char *, ftnlen), s_wsfe(cilist *), do_fio(integer *, char *,
	     ftnlen), e_wsfe(void);

    /* Local variables */
    integer i__, j, k1, k2, lll;
    char line[80];
    integer ndigit;

    /* Fortran I/O blocks */
    static cilist io___5 = { 0, 0, 0, fmt_9999, 0 };
    static cilist io___9 = { 0, 0, 0, fmt_9998, 0 };
    static cilist io___10 = { 0, 0, 0, fmt_9994, 0 };
    static cilist io___12 = { 0, 0, 0, fmt_9997, 0 };
    static cilist io___13 = { 0, 0, 0, fmt_9993, 0 };
    static cilist io___14 = { 0, 0, 0, fmt_9996, 0 };
    static cilist io___15 = { 0, 0, 0, fmt_9992, 0 };
    static cilist io___16 = { 0, 0, 0, fmt_9995, 0 };
    static cilist io___17 = { 0, 0, 0, fmt_9991, 0 };
    static cilist io___18 = { 0, 0, 0, fmt_9998, 0 };
    static cilist io___19 = { 0, 0, 0, fmt_9994, 0 };
    static cilist io___20 = { 0, 0, 0, fmt_9997, 0 };
    static cilist io___21 = { 0, 0, 0, fmt_9993, 0 };
    static cilist io___22 = { 0, 0, 0, fmt_9996, 0 };
    static cilist io___23 = { 0, 0, 0, fmt_9992, 0 };
    static cilist io___24 = { 0, 0, 0, fmt_9995, 0 };
    static cilist io___25 = { 0, 0, 0, fmt_9991, 0 };
    static cilist io___26 = { 0, 0, 0, fmt_9990, 0 };


/*     ...   
       ... SPECIFICATIONS FOR ARGUMENTS   
       ...   
       ... SPECIFICATIONS FOR LOCAL VARIABLES   
       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body   
       ...   
       ... FIRST EXECUTABLE STATEMENT   

   Computing MIN */
    i__1 = i_len(ifmt, ifmt_len);
    lll = min(i__1,80);
    i__1 = lll;
    for (i__ = 1; i__ <= i__1; ++i__) {
	*(unsigned char *)&line[i__ - 1] = '-';
/* L10: */
    }

    for (i__ = lll + 1; i__ <= 80; ++i__) {
	*(unsigned char *)&line[i__ - 1] = ' ';
/* L20: */
    }

    io___5.ciunit = *lout;
    s_wsfe(&io___5);
    do_fio(&c__1, ifmt, ifmt_len);
    do_fio(&c__1, line, lll);
    e_wsfe();

    if (*m <= 0 || *n <= 0 || *lda <= 0) {
	return 0;
    }
    ndigit = *idigit;
    if (*idigit == 0) {
	ndigit = 4;
    }

/* =======================================================================   
               CODE FOR OUTPUT USING 72 COLUMNS FORMAT   
   ======================================================================= */

    if (*idigit < 0) {
	ndigit = -(*idigit);
	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 5) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 4;
		k2 = min(i__2,i__3);
		io___9.ciunit = *lout;
		s_wsfe(&io___9);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___10.ciunit = *lout;
		    s_wsfe(&io___10);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L30: */
		}
/* L40: */
	    }

	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 4) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 3;
		k2 = min(i__2,i__3);
		io___12.ciunit = *lout;
		s_wsfe(&io___12);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___13.ciunit = *lout;
		    s_wsfe(&io___13);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L50: */
		}
/* L60: */
	    }

	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 3) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 2;
		k2 = min(i__2,i__3);
		io___14.ciunit = *lout;
		s_wsfe(&io___14);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___15.ciunit = *lout;
		    s_wsfe(&io___15);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L70: */
		}
/* L80: */
	    }

	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 2) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 1;
		k2 = min(i__2,i__3);
		io___16.ciunit = *lout;
		s_wsfe(&io___16);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___17.ciunit = *lout;
		    s_wsfe(&io___17);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L90: */
		}
/* L100: */
	    }
	}

/* =======================================================================   
               CODE FOR OUTPUT USING 132 COLUMNS FORMAT   
   ======================================================================= */

    } else {
	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 10) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 9;
		k2 = min(i__2,i__3);
		io___18.ciunit = *lout;
		s_wsfe(&io___18);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___19.ciunit = *lout;
		    s_wsfe(&io___19);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L110: */
		}
/* L120: */
	    }

	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 8) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 7;
		k2 = min(i__2,i__3);
		io___20.ciunit = *lout;
		s_wsfe(&io___20);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___21.ciunit = *lout;
		    s_wsfe(&io___21);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L130: */
		}
/* L140: */
	    }

	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 6) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 5;
		k2 = min(i__2,i__3);
		io___22.ciunit = *lout;
		s_wsfe(&io___22);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___23.ciunit = *lout;
		    s_wsfe(&io___23);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L150: */
		}
/* L160: */
	    }

	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 5) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 4;
		k2 = min(i__2,i__3);
		io___24.ciunit = *lout;
		s_wsfe(&io___24);
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__3, icol, (ftnlen)1);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		}
		e_wsfe();
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    io___25.ciunit = *lout;
		    s_wsfe(&io___25);
		    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
		    i__3 = k2;
		    for (j = k1; j <= i__3; ++j) {
			do_fio(&c__1, (char *)&a[i__ + j * a_dim1], (ftnlen)
				sizeof(doublereal));
		    }
		    e_wsfe();
/* L170: */
		}
/* L180: */
	    }
	}
    }
    io___26.ciunit = *lout;
    s_wsfe(&io___26);
    e_wsfe();


    return 0;
} /* igraphdmout_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnaitr.c0000644000175100001710000010214000000000000024025 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static logical c_false = FALSE_;
static doublereal c_b25 = 1.;
static doublereal c_b47 = 0.;
static doublereal c_b50 = -1.;
static integer c__2 = 2;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dnaitr   

   \Description:   
    Reverse communication interface for applying NP additional steps to   
    a K step nonsymmetric Arnoldi factorization.   

    Input:  OP*V_{k}  -  V_{k}*H = r_{k}*e_{k}^T   

            with (V_{k}^T)*B*V_{k} = I, (V_{k}^T)*B*r_{k} = 0.   

    Output: OP*V_{k+p}  -  V_{k+p}*H = r_{k+p}*e_{k+p}^T   

            with (V_{k+p}^T)*B*V_{k+p} = I, (V_{k+p}^T)*B*r_{k+p} = 0.   

    where OP and B are as in dnaupd.  The B-norm of r_{k+p} is also   
    computed and returned.   

   \Usage:   
    call dnaitr   
       ( IDO, BMAT, N, K, NP, NB, RESID, RNORM, V, LDV, H, LDH,   
         IPNTR, WORKD, INFO )   

   \Arguments   
    IDO     Integer.  (INPUT/OUTPUT)   
            Reverse communication flag.   
            -------------------------------------------------------------   
            IDO =  0: first call to the reverse communication interface   
            IDO = -1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y.   
                      This is for the restart phase to force the new   
                      starting vector into the range of OP.   
            IDO =  1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y,   
                      IPNTR(3) is the pointer into WORK for B * X.   
            IDO =  2: compute  Y = B * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y.   
            IDO = 99: done   
            -------------------------------------------------------------   
            When the routine is used in the "shift-and-invert" mode, the   
            vector B * Q is already available and do not need to be   
            recompute in forming OP * Q.   

    BMAT    Character*1.  (INPUT)   
            BMAT specifies the type of the matrix B that defines the   
            semi-inner product for the operator OP.  See dnaupd.   
            B = 'I' -> standard eigenvalue problem A*x = lambda*x   
            B = 'G' -> generalized eigenvalue problem A*x = lambda*M**x   

    N       Integer.  (INPUT)   
            Dimension of the eigenproblem.   

    K       Integer.  (INPUT)   
            Current size of V and H.   

    NP      Integer.  (INPUT)   
            Number of additional Arnoldi steps to take.   

    NB      Integer.  (INPUT)   
            Blocksize to be used in the recurrence.   
            Only work for NB = 1 right now.  The goal is to have a   
            program that implement both the block and non-block method.   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            On INPUT:  RESID contains the residual vector r_{k}.   
            On OUTPUT: RESID contains the residual vector r_{k+p}.   

    RNORM   Double precision scalar.  (INPUT/OUTPUT)   
            B-norm of the starting residual on input.   
            B-norm of the updated residual r_{k+p} on output.   

    V       Double precision N by K+NP array.  (INPUT/OUTPUT)   
            On INPUT:  V contains the Arnoldi vectors in the first K   
            columns.   
            On OUTPUT: V contains the new NP Arnoldi vectors in the next   
            NP columns.  The first K columns are unchanged.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (K+NP) by (K+NP) array.  (INPUT/OUTPUT)   
            H is used to store the generated upper Hessenberg matrix.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    IPNTR   Integer array of length 3.  (OUTPUT)   
            Pointer to mark the starting locations in the WORK for   
            vectors used by the Arnoldi iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X.   
            IPNTR(2): pointer to the current result vector Y.   
            IPNTR(3): pointer to the vector B * X when used in the   
                      shift-and-invert mode.  X is the current operand.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (REVERSE COMMUNICATION)   
            Distributed array to be used in the basic Arnoldi iteration   
            for reverse communication.  The calling program should not   
            use WORKD as temporary workspace during the iteration !!!!!!   
            On input, WORKD(1:N) = B*RESID and is used to save some   
            computation at the first step.   

    INFO    Integer.  (OUTPUT)   
            = 0: Normal exit.   
            > 0: Size of the spanning invariant subspace of OP found.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   

   \Routines called:   
       dgetv0  ARPACK routine to generate the initial vector.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dmout   ARPACK utility routine that prints matrices   
       dvout   ARPACK utility routine that prints vectors.   
       dlabad  LAPACK routine that computes machine constants.   
       dlamch  LAPACK routine that determines machine constants.   
       dlascl  LAPACK routine for careful scaling of a matrix.   
       dlanhs  LAPACK routine that computes various norms of a matrix.   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       daxpy   Level 1 BLAS that computes a vector triad.   
       dscal   Level 1 BLAS that scales a vector.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.4'   

   \SCCS Information: @(#)   
   FILE: naitr.F   SID: 2.4   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   
    The algorithm implemented is:   

    restart = .false.   
    Given V_{k} = [v_{1}, ..., v_{k}], r_{k};   
    r_{k} contains the initial residual vector even for k = 0;   
    Also assume that rnorm = || B*r_{k} || and B*r_{k} are already   
    computed by the calling program.   

    betaj = rnorm ; p_{k+1} = B*r_{k} ;   
    For  j = k+1, ..., k+np  Do   
       1) if ( betaj < tol ) stop or restart depending on j.   
          ( At present tol is zero )   
          if ( restart ) generate a new starting vector.   
       2) v_{j} = r(j-1)/betaj;  V_{j} = [V_{j-1}, v_{j}];   
          p_{j} = p_{j}/betaj   
       3) r_{j} = OP*v_{j} where OP is defined as in dnaupd   
          For shift-invert mode p_{j} = B*v_{j} is already available.   
          wnorm = || OP*v_{j} ||   
       4) Compute the j-th step residual vector.   
          w_{j} =  V_{j}^T * B * OP * v_{j}   
          r_{j} =  OP*v_{j} - V_{j} * w_{j}   
          H(:,j) = w_{j};   
          H(j,j-1) = rnorm   
          rnorm = || r_(j) ||   
          If (rnorm > 0.717*wnorm) accept step and go back to 1)   
       5) Re-orthogonalization step:   
          s = V_{j}'*B*r_{j}   
          r_{j} = r_{j} - V_{j}*s;  rnorm1 = || r_{j} ||   
          alphaj = alphaj + s_{j};   
       6) Iterative refinement step:   
          If (rnorm1 > 0.717*rnorm) then   
             rnorm = rnorm1   
             accept step and go back to 1)   
          Else   
             rnorm = rnorm1   
             If this is the first time in step 6), go to 5)   
             Else r_{j} lies in the span of V_{j} numerically.   
                Set r_{j} = 0 and rnorm = 0; go to 1)   
          EndIf   
    End Do   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdnaitr_(integer *ido, char *bmat, integer *n, integer *k,
	 integer *np, integer *nb, doublereal *resid, doublereal *rnorm, 
	doublereal *v, integer *ldv, doublereal *h__, integer *ldh, integer *
	ipntr, doublereal *workd, integer *info)
{
    /* Initialized data */

    IGRAPH_F77_SAVE logical first = TRUE_;

    /* System generated locals */
    integer h_dim1, h_offset, v_dim1, v_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    IGRAPH_F77_SAVE integer j;
    IGRAPH_F77_SAVE real t0, t1, t2, t3, t4, t5;
    integer jj;
    IGRAPH_F77_SAVE integer ipj, irj;
    integer nbx = 0;
    IGRAPH_F77_SAVE integer ivj;
    IGRAPH_F77_SAVE doublereal ulp;
    doublereal tst1;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE integer ierr, iter;
    IGRAPH_F77_SAVE doublereal unfl, ovfl;
    integer nopx = 0;
    IGRAPH_F77_SAVE integer itry;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    doublereal temp1;
    IGRAPH_F77_SAVE logical orth1, orth2, step3, step4;
    IGRAPH_F77_SAVE doublereal betaj;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdgemv_(char *, integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *);
    integer infol;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdaxpy_(integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *), igraphdmout_(integer 
	    *, integer *, integer *, doublereal *, integer *, integer *, char 
	    *, ftnlen);
    doublereal xtemp[2];
    real tmvbx = 0;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen);
    IGRAPH_F77_SAVE doublereal wnorm;
    extern /* Subroutine */ int igraphivout_(integer *, integer *, integer *, 
	    integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *, 
	    logical *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *), igraphdlabad_(doublereal *, doublereal *);
    IGRAPH_F77_SAVE doublereal rnorm1;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *);
    extern doublereal igraphdlanhs_(char *, integer *, doublereal *, integer *, 
	    doublereal *);
    extern /* Subroutine */ int igraphsecond_(real *);
    integer logfil = 0, ndigit, nitref = 0, mnaitr = 0;
    real titref = 0, tnaitr = 0;
    IGRAPH_F77_SAVE integer msglvl;
    IGRAPH_F77_SAVE doublereal smlnum;
    integer nrorth = 0;
    IGRAPH_F77_SAVE logical rstart;
    integer nrstrt = 0;
    real tmvopx = 0;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %-----------------------%   
       | Local Array Arguments |   
       %-----------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------%   
       | Data statements |   
       %-----------------%   

       Parameter adjustments */
    --workd;
    --resid;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --ipntr;

    /* Function Body   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    if (first) {

/*        %-----------------------------------------%   
          | Set machine-dependent constants for the |   
          | the splitting and deflation criterion.  |   
          | If norm(H) <= sqrt(OVFL),               |   
          | overflow should not occur.              |   
          | REFERENCE: LAPACK subroutine dlahqr     |   
          %-----------------------------------------% */

	unfl = igraphdlamch_("safe minimum");
	ovfl = 1. / unfl;
	igraphdlabad_(&unfl, &ovfl);
	ulp = igraphdlamch_("precision");
	smlnum = unfl * (*n / ulp);
	first = FALSE_;
    }

    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphsecond_(&t0);
	msglvl = mnaitr;

/*        %------------------------------%   
          | Initial call to this routine |   
          %------------------------------% */

	*info = 0;
	step3 = FALSE_;
	step4 = FALSE_;
	rstart = FALSE_;
	orth1 = FALSE_;
	orth2 = FALSE_;
	j = *k + 1;
	ipj = 1;
	irj = ipj + *n;
	ivj = irj + *n;
    }

/*     %-------------------------------------------------%   
       | When in reverse communication mode one of:      |   
       | STEP3, STEP4, ORTH1, ORTH2, RSTART              |   
       | will be .true. when ....                        |   
       | STEP3: return from computing OP*v_{j}.          |   
       | STEP4: return from computing B-norm of OP*v_{j} |   
       | ORTH1: return from computing B-norm of r_{j+1}  |   
       | ORTH2: return from computing B-norm of          |   
       |        correction to the residual vector.       |   
       | RSTART: return from OP computations needed by   |   
       |         dgetv0.                                 |   
       %-------------------------------------------------% */

    if (step3) {
	goto L50;
    }
    if (step4) {
	goto L60;
    }
    if (orth1) {
	goto L70;
    }
    if (orth2) {
	goto L90;
    }
    if (rstart) {
	goto L30;
    }

/*     %-----------------------------%   
       | Else this is the first step |   
       %-----------------------------%   

       %--------------------------------------------------------------%   
       |                                                              |   
       |        A R N O L D I     I T E R A T I O N     L O O P       |   
       |                                                              |   
       | Note:  B*r_{j-1} is already in WORKD(1:N)=WORKD(IPJ:IPJ+N-1) |   
       %--------------------------------------------------------------% */
L1000:

    if (msglvl > 1) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_naitr: generating Arnoldi vect"
		"or number", (ftnlen)40);
	igraphdvout_(&logfil, &c__1, rnorm, &ndigit, "_naitr: B-norm of the curren"
		"t residual is", (ftnlen)41);
    }

/*        %---------------------------------------------------%   
          | STEP 1: Check if the B norm of j-th residual      |   
          | vector is zero. Equivalent to determing whether   |   
          | an exact j-step Arnoldi factorization is present. |   
          %---------------------------------------------------% */

    betaj = *rnorm;
    if (*rnorm > 0.) {
	goto L40;
    }

/*           %---------------------------------------------------%   
             | Invariant subspace found, generate a new starting |   
             | vector which is orthogonal to the current Arnoldi |   
             | basis and continue the iteration.                 |   
             %---------------------------------------------------% */

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_naitr: ****** RESTART AT STEP "
		"******", (ftnlen)37);
    }

/*           %---------------------------------------------%   
             | ITRY is the loop variable that controls the |   
             | maximum amount of times that a restart is   |   
             | attempted. NRSTRT is used by stat.h         |   
             %---------------------------------------------% */

    betaj = 0.;
    ++nrstrt;
    itry = 1;
L20:
    rstart = TRUE_;
    *ido = 0;
L30:

/*           %--------------------------------------%   
             | If in reverse communication mode and |   
             | RSTART = .true. flow returns here.   |   
             %--------------------------------------% */

    igraphdgetv0_(ido, bmat, &itry, &c_false, n, &j, &v[v_offset], ldv, &resid[1], 
	    rnorm, &ipntr[1], &workd[1], &ierr);
    if (*ido != 99) {
	goto L9000;
    }
    if (ierr < 0) {
	++itry;
	if (itry <= 3) {
	    goto L20;
	}

/*              %------------------------------------------------%   
                | Give up after several restart attempts.        |   
                | Set INFO to the size of the invariant subspace |   
                | which spans OP and exit.                       |   
                %------------------------------------------------% */

	*info = j - 1;
	igraphsecond_(&t1);
	tnaitr += t1 - t0;
	*ido = 99;
	goto L9000;
    }

L40:

/*        %---------------------------------------------------------%   
          | STEP 2:  v_{j} = r_{j-1}/rnorm and p_{j} = p_{j}/rnorm  |   
          | Note that p_{j} = B*r_{j-1}. In order to avoid overflow |   
          | when reciprocating a small RNORM, test against lower    |   
          | machine bound.                                          |   
          %---------------------------------------------------------% */

    igraphdcopy_(n, &resid[1], &c__1, &v[j * v_dim1 + 1], &c__1);
    if (*rnorm >= unfl) {
	temp1 = 1. / *rnorm;
	igraphdscal_(n, &temp1, &v[j * v_dim1 + 1], &c__1);
	igraphdscal_(n, &temp1, &workd[ipj], &c__1);
    } else {

/*            %-----------------------------------------%   
              | To scale both v_{j} and p_{j} carefully |   
              | use LAPACK routine SLASCL               |   
              %-----------------------------------------% */

	igraphdlascl_("General", &i__, &i__, rnorm, &c_b25, n, &c__1, &v[j * v_dim1 
		+ 1], n, &infol);
	igraphdlascl_("General", &i__, &i__, rnorm, &c_b25, n, &c__1, &workd[ipj], 
		n, &infol);
    }

/*        %------------------------------------------------------%   
          | STEP 3:  r_{j} = OP*v_{j}; Note that p_{j} = B*v_{j} |   
          | Note that this is not quite yet r_{j}. See STEP 4    |   
          %------------------------------------------------------% */

    step3 = TRUE_;
    ++nopx;
    igraphsecond_(&t2);
    igraphdcopy_(n, &v[j * v_dim1 + 1], &c__1, &workd[ivj], &c__1);
    ipntr[1] = ivj;
    ipntr[2] = irj;
    ipntr[3] = ipj;
    *ido = 1;

/*        %-----------------------------------%   
          | Exit in order to compute OP*v_{j} |   
          %-----------------------------------% */

    goto L9000;
L50:

/*        %----------------------------------%   
          | Back from reverse communication; |   
          | WORKD(IRJ:IRJ+N-1) := OP*v_{j}   |   
          | if step3 = .true.                |   
          %----------------------------------% */

    igraphsecond_(&t3);
    tmvopx += t3 - t2;
    step3 = FALSE_;

/*        %------------------------------------------%   
          | Put another copy of OP*v_{j} into RESID. |   
          %------------------------------------------% */

    igraphdcopy_(n, &workd[irj], &c__1, &resid[1], &c__1);

/*        %---------------------------------------%   
          | STEP 4:  Finish extending the Arnoldi |   
          |          factorization to length j.   |   
          %---------------------------------------% */

    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	step4 = TRUE_;
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %-------------------------------------%   
             | Exit in order to compute B*OP*v_{j} |   
             %-------------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L60:

/*        %----------------------------------%   
          | Back from reverse communication; |   
          | WORKD(IPJ:IPJ+N-1) := B*OP*v_{j} |   
          | if step4 = .true.                |   
          %----------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    step4 = FALSE_;

/*        %-------------------------------------%   
          | The following is needed for STEP 5. |   
          | Compute the B-norm of OP*v_{j}.     |   
          %-------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	wnorm = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	wnorm = sqrt((abs(wnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	wnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }

/*        %-----------------------------------------%   
          | Compute the j-th residual corresponding |   
          | to the j step factorization.            |   
          | Use Classical Gram Schmidt and compute: |   
          | w_{j} <-  V_{j}^T * B * OP * v_{j}      |   
          | r_{j} <-  OP*v_{j} - V_{j} * w_{j}      |   
          %-----------------------------------------%   


          %------------------------------------------%   
          | Compute the j Fourier coefficients w_{j} |   
          | WORKD(IPJ:IPJ+N-1) contains B*OP*v_{j}.  |   
          %------------------------------------------% */

    igraphdgemv_("T", n, &j, &c_b25, &v[v_offset], ldv, &workd[ipj], &c__1, &c_b47, 
	    &h__[j * h_dim1 + 1], &c__1);

/*        %--------------------------------------%   
          | Orthogonalize r_{j} against V_{j}.   |   
          | RESID contains OP*v_{j}. See STEP 3. |   
          %--------------------------------------% */

    igraphdgemv_("N", n, &j, &c_b50, &v[v_offset], ldv, &h__[j * h_dim1 + 1], &c__1,
	     &c_b25, &resid[1], &c__1);

    if (j > 1) {
	h__[j + (j - 1) * h_dim1] = betaj;
    }

    igraphsecond_(&t4);

    orth1 = TRUE_;

    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[irj], &c__1);
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %----------------------------------%   
             | Exit in order to compute B*r_{j} |   
             %----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L70:

/*        %---------------------------------------------------%   
          | Back from reverse communication if ORTH1 = .true. |   
          | WORKD(IPJ:IPJ+N-1) := B*r_{j}.                    |   
          %---------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    orth1 = FALSE_;

/*        %------------------------------%   
          | Compute the B-norm of r_{j}. |   
          %------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	*rnorm = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	*rnorm = sqrt((abs(*rnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	*rnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }

/*        %-----------------------------------------------------------%   
          | STEP 5: Re-orthogonalization / Iterative refinement phase |   
          | Maximum NITER_ITREF tries.                                |   
          |                                                           |   
          |          s      = V_{j}^T * B * r_{j}                     |   
          |          r_{j}  = r_{j} - V_{j}*s                         |   
          |          alphaj = alphaj + s_{j}                          |   
          |                                                           |   
          | The stopping criteria used for iterative refinement is    |   
          | discussed in Parlett's book SEP, page 107 and in Gragg &  |   
          | Reichel ACM TOMS paper; Algorithm 686, Dec. 1990.         |   
          | Determine if we need to correct the residual. The goal is |   
          | to enforce ||v(:,1:j)^T * r_{j}|| .le. eps * || r_{j} ||  |   
          | The following test determines whether the sine of the     |   
          | angle between  OP*x and the computed residual is less     |   
          | than or equal to 0.717.                                   |   
          %-----------------------------------------------------------% */

    if (*rnorm > wnorm * .717f) {
	goto L100;
    }
    iter = 0;
    ++nrorth;

/*        %---------------------------------------------------%   
          | Enter the Iterative refinement phase. If further  |   
          | refinement is necessary, loop back here. The loop |   
          | variable is ITER. Perform a step of Classical     |   
          | Gram-Schmidt using all the Arnoldi vectors V_{j}  |   
          %---------------------------------------------------% */

L80:

    if (msglvl > 2) {
	xtemp[0] = wnorm;
	xtemp[1] = *rnorm;
	igraphdvout_(&logfil, &c__2, xtemp, &ndigit, "_naitr: re-orthonalization; "
		"wnorm and rnorm are", (ftnlen)47);
	igraphdvout_(&logfil, &j, &h__[j * h_dim1 + 1], &ndigit, "_naitr: j-th col"
		"umn of H", (ftnlen)24);
    }

/*        %----------------------------------------------------%   
          | Compute V_{j}^T * B * r_{j}.                       |   
          | WORKD(IRJ:IRJ+J-1) = v(:,1:J)'*WORKD(IPJ:IPJ+N-1). |   
          %----------------------------------------------------% */

    igraphdgemv_("T", n, &j, &c_b25, &v[v_offset], ldv, &workd[ipj], &c__1, &c_b47, 
	    &workd[irj], &c__1);

/*        %---------------------------------------------%   
          | Compute the correction to the residual:     |   
          | r_{j} = r_{j} - V_{j} * WORKD(IRJ:IRJ+J-1). |   
          | The correction to H is v(:,1:J)*H(1:J,1:J)  |   
          | + v(:,1:J)*WORKD(IRJ:IRJ+J-1)*e'_j.         |   
          %---------------------------------------------% */

    igraphdgemv_("N", n, &j, &c_b50, &v[v_offset], ldv, &workd[irj], &c__1, &c_b25, 
	    &resid[1], &c__1);
    igraphdaxpy_(&j, &c_b25, &workd[irj], &c__1, &h__[j * h_dim1 + 1], &c__1);

    orth2 = TRUE_;
    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[irj], &c__1);
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %-----------------------------------%   
             | Exit in order to compute B*r_{j}. |   
             | r_{j} is the corrected residual.  |   
             %-----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L90:

/*        %---------------------------------------------------%   
          | Back from reverse communication if ORTH2 = .true. |   
          %---------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

/*        %-----------------------------------------------------%   
          | Compute the B-norm of the corrected residual r_{j}. |   
          %-----------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	rnorm1 = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	rnorm1 = sqrt((abs(rnorm1)));
    } else if (*(unsigned char *)bmat == 'I') {
	rnorm1 = igraphdnrm2_(n, &resid[1], &c__1);
    }

    if (msglvl > 0 && iter > 0) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_naitr: Iterative refinement fo"
		"r Arnoldi residual", (ftnlen)49);
	if (msglvl > 2) {
	    xtemp[0] = *rnorm;
	    xtemp[1] = rnorm1;
	    igraphdvout_(&logfil, &c__2, xtemp, &ndigit, "_naitr: iterative refine"
		    "ment ; rnorm and rnorm1 are", (ftnlen)51);
	}
    }

/*        %-----------------------------------------%   
          | Determine if we need to perform another |   
          | step of re-orthogonalization.           |   
          %-----------------------------------------% */

    if (rnorm1 > *rnorm * .717f) {

/*           %---------------------------------------%   
             | No need for further refinement.       |   
             | The cosine of the angle between the   |   
             | corrected residual vector and the old |   
             | residual vector is greater than 0.717 |   
             | In other words the corrected residual |   
             | and the old residual vector share an  |   
             | angle of less than arcCOS(0.717)      |   
             %---------------------------------------% */

	*rnorm = rnorm1;

    } else {

/*           %-------------------------------------------%   
             | Another step of iterative refinement step |   
             | is required. NITREF is used by stat.h     |   
             %-------------------------------------------% */

	++nitref;
	*rnorm = rnorm1;
	++iter;
	if (iter <= 1) {
	    goto L80;
	}

/*           %-------------------------------------------------%   
             | Otherwise RESID is numerically in the span of V |   
             %-------------------------------------------------% */

	i__1 = *n;
	for (jj = 1; jj <= i__1; ++jj) {
	    resid[jj] = 0.;
/* L95: */
	}
	*rnorm = 0.;
    }

/*        %----------------------------------------------%   
          | Branch here directly if iterative refinement |   
          | wasn't necessary or after at most NITER_REF  |   
          | steps of iterative refinement.               |   
          %----------------------------------------------% */

L100:

    rstart = FALSE_;
    orth2 = FALSE_;

    igraphsecond_(&t5);
    titref += t5 - t4;

/*        %------------------------------------%   
          | STEP 6: Update  j = j+1;  Continue |   
          %------------------------------------% */

    ++j;
    if (j > *k + *np) {
	igraphsecond_(&t1);
	tnaitr += t1 - t0;
	*ido = 99;
	i__1 = *k + *np - 1;
	for (i__ = max(1,*k); i__ <= i__1; ++i__) {

/*              %--------------------------------------------%   
                | Check for splitting and deflation.         |   
                | Use a standard test as in the QR algorithm |   
                | REFERENCE: LAPACK subroutine dlahqr        |   
                %--------------------------------------------% */

	    tst1 = (d__1 = h__[i__ + i__ * h_dim1], abs(d__1)) + (d__2 = h__[
		    i__ + 1 + (i__ + 1) * h_dim1], abs(d__2));
	    if (tst1 == 0.) {
		i__2 = *k + *np;
		tst1 = igraphdlanhs_("1", &i__2, &h__[h_offset], ldh, &workd[*n + 1]
			);
	    }
/* Computing MAX */
	    d__2 = ulp * tst1;
	    if ((d__1 = h__[i__ + 1 + i__ * h_dim1], abs(d__1)) <= max(d__2,
		    smlnum)) {
		h__[i__ + 1 + i__ * h_dim1] = 0.;
	    }
/* L110: */
	}

	if (msglvl > 2) {
	    i__1 = *k + *np;
	    i__2 = *k + *np;
	    igraphdmout_(&logfil, &i__1, &i__2, &h__[h_offset], ldh, &ndigit, "_na"
		    "itr: Final upper Hessenberg matrix H of order K+NP", (
		    ftnlen)53);
	}

	goto L9000;
    }

/*        %--------------------------------------------------------%   
          | Loop back to extend the factorization by another step. |   
          %--------------------------------------------------------% */

    goto L1000;

/*     %---------------------------------------------------------------%   
       |                                                               |   
       |  E N D     O F     M A I N     I T E R A T I O N     L O O P  |   
       |                                                               |   
       %---------------------------------------------------------------% */

L9000:
    return 0;

/*     %---------------%   
       | End of dnaitr |   
       %---------------% */

} /* igraphdnaitr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnapps.c0000644000175100001710000006642700000000000024052 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b5 = 0.;
static doublereal c_b6 = 1.;
static integer c__1 = 1;
static doublereal c_b43 = -1.;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dnapps   

   \Description:   
    Given the Arnoldi factorization   

       A*V_{k} - V_{k}*H_{k} = r_{k+p}*e_{k+p}^T,   

    apply NP implicit shifts resulting in   

       A*(V_{k}*Q) - (V_{k}*Q)*(Q^T* H_{k}*Q) = r_{k+p}*e_{k+p}^T * Q   

    where Q is an orthogonal matrix which is the product of rotations   
    and reflections resulting from the NP bulge chage sweeps.   
    The updated Arnoldi factorization becomes:   

       A*VNEW_{k} - VNEW_{k}*HNEW_{k} = rnew_{k}*e_{k}^T.   

   \Usage:   
    call dnapps   
       ( N, KEV, NP, SHIFTR, SHIFTI, V, LDV, H, LDH, RESID, Q, LDQ,   
         WORKL, WORKD )   

   \Arguments   
    N       Integer.  (INPUT)   
            Problem size, i.e. size of matrix A.   

    KEV     Integer.  (INPUT/OUTPUT)   
            KEV+NP is the size of the input matrix H.   
            KEV is the size of the updated matrix HNEW.  KEV is only   
            updated on ouput when fewer than NP shifts are applied in   
            order to keep the conjugate pair together.   

    NP      Integer.  (INPUT)   
            Number of implicit shifts to be applied.   

    SHIFTR, Double precision array of length NP.  (INPUT)   
    SHIFTI  Real and imaginary part of the shifts to be applied.   
            Upon, entry to dnapps, the shifts must be sorted so that the   
            conjugate pairs are in consecutive locations.   

    V       Double precision N by (KEV+NP) array.  (INPUT/OUTPUT)   
            On INPUT, V contains the current KEV+NP Arnoldi vectors.   
            On OUTPUT, V contains the updated KEV Arnoldi vectors   
            in the first KEV columns of V.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (KEV+NP) by (KEV+NP) array.  (INPUT/OUTPUT)   
            On INPUT, H contains the current KEV+NP by KEV+NP upper   
            Hessenber matrix of the Arnoldi factorization.   
            On OUTPUT, H contains the updated KEV by KEV upper Hessenberg   
            matrix in the KEV leading submatrix.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            On INPUT, RESID contains the the residual vector r_{k+p}.   
            On OUTPUT, RESID is the update residual vector rnew_{k}   
            in the first KEV locations.   

    Q       Double precision KEV+NP by KEV+NP work array.  (WORKSPACE)   
            Work array used to accumulate the rotations and reflections   
            during the bulge chase sweep.   

    LDQ     Integer.  (INPUT)   
            Leading dimension of Q exactly as declared in the calling   
            program.   

    WORKL   Double precision work array of length (KEV+NP).  (WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.   

    WORKD   Double precision work array of length 2*N.  (WORKSPACE)   
            Distributed array used in the application of the accumulated   
            orthogonal matrix Q.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   

   \Routines called:   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dmout   ARPACK utility routine that prints matrices.   
       dvout   ARPACK utility routine that prints vectors.   
       dlabad  LAPACK routine that computes machine constants.   
       dlacpy  LAPACK matrix copy routine.   
       dlamch  LAPACK routine that determines machine constants.   
       dlanhs  LAPACK routine that computes various norms of a matrix.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   
       dlarf   LAPACK routine that applies Householder reflection to   
               a matrix.   
       dlarfg  LAPACK Householder reflection construction routine.   
       dlartg  LAPACK Givens rotation construction routine.   
       dlaset  LAPACK matrix initialization routine.   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       daxpy   Level 1 BLAS that computes a vector triad.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       dscal   Level 1 BLAS that scales a vector.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: napps.F   SID: 2.3   DATE OF SID: 4/20/96   RELEASE: 2   

   \Remarks   
    1. In this version, each shift is applied to all the sublocks of   
       the Hessenberg matrix H and not just to the submatrix that it   
       comes from. Deflation as in LAPACK routine dlahqr (QR algorithm   
       for upper Hessenberg matrices ) is used.   
       The subdiagonals of H are enforced to be non-negative.   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdnapps_(integer *n, integer *kev, integer *np, 
	doublereal *shiftr, doublereal *shifti, doublereal *v, integer *ldv, 
	doublereal *h__, integer *ldh, doublereal *resid, doublereal *q, 
	integer *ldq, doublereal *workl, doublereal *workd)
{
    /* Initialized data */

    IGRAPH_F77_SAVE logical first = TRUE_;

    /* System generated locals */
    integer h_dim1, h_offset, v_dim1, v_offset, q_dim1, q_offset, i__1, i__2, 
	    i__3, i__4;
    doublereal d__1, d__2;

    /* Local variables */
    doublereal c__, f, g;
    integer i__, j;
    doublereal r__, s, t, u[3];
    IGRAPH_F77_SAVE real t0, t1;
    doublereal h11, h12, h21, h22, h32;
    integer jj, ir, nr;
    doublereal tau;
    IGRAPH_F77_SAVE doublereal ulp;
    doublereal tst1;
    integer iend;
    IGRAPH_F77_SAVE doublereal unfl, ovfl;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdlarf_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *);
    logical cconj;
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *), igraphdcopy_(integer *, 
	    doublereal *, integer *, doublereal *, integer *), igraphdaxpy_(integer 
	    *, doublereal *, doublereal *, integer *, doublereal *, integer *)
	    , igraphdmout_(integer *, integer *, integer *, doublereal *, integer *,
	     integer *, char *, ftnlen), igraphdvout_(integer *, integer *, 
	    doublereal *, integer *, char *, ftnlen), igraphivout_(integer *, 
	    integer *, integer *, integer *, char *, ftnlen);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlarfg_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *);
    doublereal sigmai;
    extern doublereal igraphdlanhs_(char *, integer *, doublereal *, integer *, 
	    doublereal *);
    extern /* Subroutine */ int igraphsecond_(real *), igraphdlacpy_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *), igraphdlaset_(char *, integer *, integer *, doublereal *, 
	    doublereal *, doublereal *, integer *), igraphdlartg_(
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *);
    integer logfil, ndigit;
    doublereal sigmar;
    integer mnapps = 0, msglvl;
    real tnapps = 0.;
    integer istart;
    IGRAPH_F77_SAVE doublereal smlnum;
    integer kplusp;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %------------------------%   
       | Local Scalars & Arrays |   
       %------------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %----------------------%   
       | Intrinsics Functions |   
       %----------------------%   


       %----------------%   
       | Data statments |   
       %----------------%   

       Parameter adjustments */
    --workd;
    --resid;
    --workl;
    --shifti;
    --shiftr;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;

    /* Function Body   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    if (first) {

/*        %-----------------------------------------------%   
          | Set machine-dependent constants for the       |   
          | stopping criterion. If norm(H) <= sqrt(OVFL), |   
          | overflow should not occur.                    |   
          | REFERENCE: LAPACK subroutine dlahqr           |   
          %-----------------------------------------------% */

	unfl = igraphdlamch_("safe minimum");
	ovfl = 1. / unfl;
	igraphdlabad_(&unfl, &ovfl);
	ulp = igraphdlamch_("precision");
	smlnum = unfl * (*n / ulp);
	first = FALSE_;
    }

/*     %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------% */

    igraphsecond_(&t0);
    msglvl = mnapps;
    kplusp = *kev + *np;

/*     %--------------------------------------------%   
       | Initialize Q to the identity to accumulate |   
       | the rotations and reflections              |   
       %--------------------------------------------% */

    igraphdlaset_("All", &kplusp, &kplusp, &c_b5, &c_b6, &q[q_offset], ldq);

/*     %----------------------------------------------%   
       | Quick return if there are no shifts to apply |   
       %----------------------------------------------% */

    if (*np == 0) {
	goto L9000;
    }

/*     %----------------------------------------------%   
       | Chase the bulge with the application of each |   
       | implicit shift. Each shift is applied to the |   
       | whole matrix including each block.           |   
       %----------------------------------------------% */

    cconj = FALSE_;
    i__1 = *np;
    for (jj = 1; jj <= i__1; ++jj) {
	sigmar = shiftr[jj];
	sigmai = shifti[jj];

	if (msglvl > 2) {
	    igraphivout_(&logfil, &c__1, &jj, &ndigit, "_napps: shift number.", (
		    ftnlen)21);
	    igraphdvout_(&logfil, &c__1, &sigmar, &ndigit, "_napps: The real part "
		    "of the shift ", (ftnlen)35);
	    igraphdvout_(&logfil, &c__1, &sigmai, &ndigit, "_napps: The imaginary "
		    "part of the shift ", (ftnlen)40);
	}

/*        %-------------------------------------------------%   
          | The following set of conditionals is necessary  |   
          | in order that complex conjugate pairs of shifts |   
          | are applied together or not at all.             |   
          %-------------------------------------------------% */

	if (cconj) {

/*           %-----------------------------------------%   
             | cconj = .true. means the previous shift |   
             | had non-zero imaginary part.            |   
             %-----------------------------------------% */

	    cconj = FALSE_;
	    goto L110;
	} else if (jj < *np && abs(sigmai) > 0.) {

/*           %------------------------------------%   
             | Start of a complex conjugate pair. |   
             %------------------------------------% */

	    cconj = TRUE_;
	} else if (jj == *np && abs(sigmai) > 0.) {

/*           %----------------------------------------------%   
             | The last shift has a nonzero imaginary part. |   
             | Don't apply it; thus the order of the        |   
             | compressed H is order KEV+1 since only np-1  |   
             | were applied.                                |   
             %----------------------------------------------% */

	    ++(*kev);
	    goto L110;
	}
	istart = 1;
L20:

/*        %--------------------------------------------------%   
          | if sigmai = 0 then                               |   
          |    Apply the jj-th shift ...                     |   
          | else                                             |   
          |    Apply the jj-th and (jj+1)-th together ...    |   
          |    (Note that jj < np at this point in the code) |   
          | end                                              |   
          | to the current block of H. The next do loop      |   
          | determines the current block ;                   |   
          %--------------------------------------------------% */

	i__2 = kplusp - 1;
	for (i__ = istart; i__ <= i__2; ++i__) {

/*           %----------------------------------------%   
             | Check for splitting and deflation. Use |   
             | a standard test as in the QR algorithm |   
             | REFERENCE: LAPACK subroutine dlahqr    |   
             %----------------------------------------% */

	    tst1 = (d__1 = h__[i__ + i__ * h_dim1], abs(d__1)) + (d__2 = h__[
		    i__ + 1 + (i__ + 1) * h_dim1], abs(d__2));
	    if (tst1 == 0.) {
		i__3 = kplusp - jj + 1;
		tst1 = igraphdlanhs_("1", &i__3, &h__[h_offset], ldh, &workl[1]);
	    }
/* Computing MAX */
	    d__2 = ulp * tst1;
	    if ((d__1 = h__[i__ + 1 + i__ * h_dim1], abs(d__1)) <= max(d__2,
		    smlnum)) {
		if (msglvl > 0) {
		    igraphivout_(&logfil, &c__1, &i__, &ndigit, "_napps: matrix sp"
			    "litting at row/column no.", (ftnlen)42);
		    igraphivout_(&logfil, &c__1, &jj, &ndigit, "_napps: matrix spl"
			    "itting with shift number.", (ftnlen)43);
		    igraphdvout_(&logfil, &c__1, &h__[i__ + 1 + i__ * h_dim1], &
			    ndigit, "_napps: off diagonal element.", (ftnlen)
			    29);
		}
		iend = i__;
		h__[i__ + 1 + i__ * h_dim1] = 0.;
		goto L40;
	    }
/* L30: */
	}
	iend = kplusp;
L40:

	if (msglvl > 2) {
	    igraphivout_(&logfil, &c__1, &istart, &ndigit, "_napps: Start of curre"
		    "nt block ", (ftnlen)31);
	    igraphivout_(&logfil, &c__1, &iend, &ndigit, "_napps: End of current b"
		    "lock ", (ftnlen)29);
	}

/*        %------------------------------------------------%   
          | No reason to apply a shift to block of order 1 |   
          %------------------------------------------------% */

	if (istart == iend) {
	    goto L100;
	}

/*        %------------------------------------------------------%   
          | If istart + 1 = iend then no reason to apply a       |   
          | complex conjugate pair of shifts on a 2 by 2 matrix. |   
          %------------------------------------------------------% */

	if (istart + 1 == iend && abs(sigmai) > 0.) {
	    goto L100;
	}

	h11 = h__[istart + istart * h_dim1];
	h21 = h__[istart + 1 + istart * h_dim1];
	if (abs(sigmai) <= 0.) {

/*           %---------------------------------------------%   
             | Real-valued shift ==> apply single shift QR |   
             %---------------------------------------------% */

	    f = h11 - sigmar;
	    g = h21;

	    i__2 = iend - 1;
	    for (i__ = istart; i__ <= i__2; ++i__) {

/*              %-----------------------------------------------------%   
                | Contruct the plane rotation G to zero out the bulge |   
                %-----------------------------------------------------% */

		igraphdlartg_(&f, &g, &c__, &s, &r__);
		if (i__ > istart) {

/*                 %-------------------------------------------%   
                   | The following ensures that h(1:iend-1,1), |   
                   | the first iend-2 off diagonal of elements |   
                   | H, remain non negative.                   |   
                   %-------------------------------------------% */

		    if (r__ < 0.) {
			r__ = -r__;
			c__ = -c__;
			s = -s;
		    }
		    h__[i__ + (i__ - 1) * h_dim1] = r__;
		    h__[i__ + 1 + (i__ - 1) * h_dim1] = 0.;
		}

/*              %---------------------------------------------%   
                | Apply rotation to the left of H;  H <- G'*H |   
                %---------------------------------------------% */

		i__3 = kplusp;
		for (j = i__; j <= i__3; ++j) {
		    t = c__ * h__[i__ + j * h_dim1] + s * h__[i__ + 1 + j * 
			    h_dim1];
		    h__[i__ + 1 + j * h_dim1] = -s * h__[i__ + j * h_dim1] + 
			    c__ * h__[i__ + 1 + j * h_dim1];
		    h__[i__ + j * h_dim1] = t;
/* L50: */
		}

/*              %---------------------------------------------%   
                | Apply rotation to the right of H;  H <- H*G |   
                %---------------------------------------------%   

   Computing MIN */
		i__4 = i__ + 2;
		i__3 = min(i__4,iend);
		for (j = 1; j <= i__3; ++j) {
		    t = c__ * h__[j + i__ * h_dim1] + s * h__[j + (i__ + 1) * 
			    h_dim1];
		    h__[j + (i__ + 1) * h_dim1] = -s * h__[j + i__ * h_dim1] 
			    + c__ * h__[j + (i__ + 1) * h_dim1];
		    h__[j + i__ * h_dim1] = t;
/* L60: */
		}

/*              %----------------------------------------------------%   
                | Accumulate the rotation in the matrix Q;  Q <- Q*G |   
                %----------------------------------------------------%   

   Computing MIN */
		i__4 = j + jj;
		i__3 = min(i__4,kplusp);
		for (j = 1; j <= i__3; ++j) {
		    t = c__ * q[j + i__ * q_dim1] + s * q[j + (i__ + 1) * 
			    q_dim1];
		    q[j + (i__ + 1) * q_dim1] = -s * q[j + i__ * q_dim1] + 
			    c__ * q[j + (i__ + 1) * q_dim1];
		    q[j + i__ * q_dim1] = t;
/* L70: */
		}

/*              %---------------------------%   
                | Prepare for next rotation |   
                %---------------------------% */

		if (i__ < iend - 1) {
		    f = h__[i__ + 1 + i__ * h_dim1];
		    g = h__[i__ + 2 + i__ * h_dim1];
		}
/* L80: */
	    }

/*           %-----------------------------------%   
             | Finished applying the real shift. |   
             %-----------------------------------% */

	} else {

/*           %----------------------------------------------------%   
             | Complex conjugate shifts ==> apply double shift QR |   
             %----------------------------------------------------% */

	    h12 = h__[istart + (istart + 1) * h_dim1];
	    h22 = h__[istart + 1 + (istart + 1) * h_dim1];
	    h32 = h__[istart + 2 + (istart + 1) * h_dim1];

/*           %---------------------------------------------------------%   
             | Compute 1st column of (H - shift*I)*(H - conj(shift)*I) |   
             %---------------------------------------------------------% */

	    s = sigmar * 2.f;
	    t = igraphdlapy2_(&sigmar, &sigmai);
	    u[0] = (h11 * (h11 - s) + t * t) / h21 + h12;
	    u[1] = h11 + h22 - s;
	    u[2] = h32;

	    i__2 = iend - 1;
	    for (i__ = istart; i__ <= i__2; ++i__) {

/* Computing MIN */
		i__3 = 3, i__4 = iend - i__ + 1;
		nr = min(i__3,i__4);

/*              %-----------------------------------------------------%   
                | Construct Householder reflector G to zero out u(1). |   
                | G is of the form I - tau*( 1 u )' * ( 1 u' ).       |   
                %-----------------------------------------------------% */

		igraphdlarfg_(&nr, u, &u[1], &c__1, &tau);

		if (i__ > istart) {
		    h__[i__ + (i__ - 1) * h_dim1] = u[0];
		    h__[i__ + 1 + (i__ - 1) * h_dim1] = 0.;
		    if (i__ < iend - 1) {
			h__[i__ + 2 + (i__ - 1) * h_dim1] = 0.;
		    }
		}
		u[0] = 1.;

/*              %--------------------------------------%   
                | Apply the reflector to the left of H |   
                %--------------------------------------% */

		i__3 = kplusp - i__ + 1;
		igraphdlarf_("Left", &nr, &i__3, u, &c__1, &tau, &h__[i__ + i__ * 
			h_dim1], ldh, &workl[1]);

/*              %---------------------------------------%   
                | Apply the reflector to the right of H |   
                %---------------------------------------%   

   Computing MIN */
		i__3 = i__ + 3;
		ir = min(i__3,iend);
		igraphdlarf_("Right", &ir, &nr, u, &c__1, &tau, &h__[i__ * h_dim1 + 
			1], ldh, &workl[1]);

/*              %-----------------------------------------------------%   
                | Accumulate the reflector in the matrix Q;  Q <- Q*G |   
                %-----------------------------------------------------% */

		igraphdlarf_("Right", &kplusp, &nr, u, &c__1, &tau, &q[i__ * q_dim1 
			+ 1], ldq, &workl[1]);

/*              %----------------------------%   
                | Prepare for next reflector |   
                %----------------------------% */

		if (i__ < iend - 1) {
		    u[0] = h__[i__ + 1 + i__ * h_dim1];
		    u[1] = h__[i__ + 2 + i__ * h_dim1];
		    if (i__ < iend - 2) {
			u[2] = h__[i__ + 3 + i__ * h_dim1];
		    }
		}

/* L90: */
	    }

/*           %--------------------------------------------%   
             | Finished applying a complex pair of shifts |   
             | to the current block                       |   
             %--------------------------------------------% */

	}

L100:

/*        %---------------------------------------------------------%   
          | Apply the same shift to the next block if there is any. |   
          %---------------------------------------------------------% */

	istart = iend + 1;
	if (iend < kplusp) {
	    goto L20;
	}

/*        %---------------------------------------------%   
          | Loop back to the top to get the next shift. |   
          %---------------------------------------------% */

L110:
	;
    }

/*     %--------------------------------------------------%   
       | Perform a similarity transformation that makes   |   
       | sure that H will have non negative sub diagonals |   
       %--------------------------------------------------% */

    i__1 = *kev;
    for (j = 1; j <= i__1; ++j) {
	if (h__[j + 1 + j * h_dim1] < 0.) {
	    i__2 = kplusp - j + 1;
	    igraphdscal_(&i__2, &c_b43, &h__[j + 1 + j * h_dim1], ldh);
/* Computing MIN */
	    i__3 = j + 2;
	    i__2 = min(i__3,kplusp);
	    igraphdscal_(&i__2, &c_b43, &h__[(j + 1) * h_dim1 + 1], &c__1);
/* Computing MIN */
	    i__3 = j + *np + 1;
	    i__2 = min(i__3,kplusp);
	    igraphdscal_(&i__2, &c_b43, &q[(j + 1) * q_dim1 + 1], &c__1);
	}
/* L120: */
    }

    i__1 = *kev;
    for (i__ = 1; i__ <= i__1; ++i__) {

/*        %--------------------------------------------%   
          | Final check for splitting and deflation.   |   
          | Use a standard test as in the QR algorithm |   
          | REFERENCE: LAPACK subroutine dlahqr        |   
          %--------------------------------------------% */

	tst1 = (d__1 = h__[i__ + i__ * h_dim1], abs(d__1)) + (d__2 = h__[i__ 
		+ 1 + (i__ + 1) * h_dim1], abs(d__2));
	if (tst1 == 0.) {
	    tst1 = igraphdlanhs_("1", kev, &h__[h_offset], ldh, &workl[1]);
	}
/* Computing MAX */
	d__1 = ulp * tst1;
	if (h__[i__ + 1 + i__ * h_dim1] <= max(d__1,smlnum)) {
	    h__[i__ + 1 + i__ * h_dim1] = 0.;
	}
/* L130: */
    }

/*     %-------------------------------------------------%   
       | Compute the (kev+1)-st column of (V*Q) and      |   
       | temporarily store the result in WORKD(N+1:2*N). |   
       | This is needed in the residual update since we  |   
       | cannot GUARANTEE that the corresponding entry   |   
       | of H would be zero as in exact arithmetic.      |   
       %-------------------------------------------------% */

    if (h__[*kev + 1 + *kev * h_dim1] > 0.) {
	igraphdgemv_("N", n, &kplusp, &c_b6, &v[v_offset], ldv, &q[(*kev + 1) * 
		q_dim1 + 1], &c__1, &c_b5, &workd[*n + 1], &c__1);
    }

/*     %----------------------------------------------------------%   
       | Compute column 1 to kev of (V*Q) in backward order       |   
       | taking advantage of the upper Hessenberg structure of Q. |   
       %----------------------------------------------------------% */

    i__1 = *kev;
    for (i__ = 1; i__ <= i__1; ++i__) {
	i__2 = kplusp - i__ + 1;
	igraphdgemv_("N", n, &i__2, &c_b6, &v[v_offset], ldv, &q[(*kev - i__ + 1) * 
		q_dim1 + 1], &c__1, &c_b5, &workd[1], &c__1);
	igraphdcopy_(n, &workd[1], &c__1, &v[(kplusp - i__ + 1) * v_dim1 + 1], &
		c__1);
/* L140: */
    }

/*     %-------------------------------------------------%   
       |  Move v(:,kplusp-kev+1:kplusp) into v(:,1:kev). |   
       %-------------------------------------------------% */

    igraphdlacpy_("A", n, kev, &v[(kplusp - *kev + 1) * v_dim1 + 1], ldv, &v[
	    v_offset], ldv);

/*     %--------------------------------------------------------------%   
       | Copy the (kev+1)-st column of (V*Q) in the appropriate place |   
       %--------------------------------------------------------------% */

    if (h__[*kev + 1 + *kev * h_dim1] > 0.) {
	igraphdcopy_(n, &workd[*n + 1], &c__1, &v[(*kev + 1) * v_dim1 + 1], &c__1);
    }

/*     %-------------------------------------%   
       | Update the residual vector:         |   
       |    r <- sigmak*r + betak*v(:,kev+1) |   
       | where                               |   
       |    sigmak = (e_{kplusp}'*Q)*e_{kev} |   
       |    betak = e_{kev+1}'*H*e_{kev}     |   
       %-------------------------------------% */

    igraphdscal_(n, &q[kplusp + *kev * q_dim1], &resid[1], &c__1);
    if (h__[*kev + 1 + *kev * h_dim1] > 0.) {
	igraphdaxpy_(n, &h__[*kev + 1 + *kev * h_dim1], &v[(*kev + 1) * v_dim1 + 1],
		 &c__1, &resid[1], &c__1);
    }

    if (msglvl > 1) {
	igraphdvout_(&logfil, &c__1, &q[kplusp + *kev * q_dim1], &ndigit, "_napps:"
		" sigmak = (e_{kev+p}^T*Q)*e_{kev}", (ftnlen)40);
	igraphdvout_(&logfil, &c__1, &h__[*kev + 1 + *kev * h_dim1], &ndigit, "_na"
		"pps: betak = e_{kev+1}^T*H*e_{kev}", (ftnlen)37);
	igraphivout_(&logfil, &c__1, kev, &ndigit, "_napps: Order of the final Hes"
		"senberg matrix ", (ftnlen)45);
	if (msglvl > 2) {
	    igraphdmout_(&logfil, kev, kev, &h__[h_offset], ldh, &ndigit, "_napps:"
		    " updated Hessenberg matrix H for next iteration", (ftnlen)
		    54);
	}

    }

L9000:
    igraphsecond_(&t1);
    tnapps += t1 - t0;

    return 0;

/*     %---------------%   
       | End of dnapps |   
       %---------------% */

} /* igraphdnapps_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnaup2.c0000644000175100001710000010567300000000000023753 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b3 = .66666666666666663;
static integer c__1 = 1;
static integer c__0 = 0;
static integer c__4 = 4;
static logical c_true = TRUE_;
static integer c__2 = 2;

/* \BeginDoc   

   \Name: dnaup2   

   \Description:   
    Intermediate level interface called by dnaupd.   

   \Usage:   
    call dnaup2   
       ( IDO, BMAT, N, WHICH, NEV, NP, TOL, RESID, MODE, IUPD,   
         ISHIFT, MXITER, V, LDV, H, LDH, RITZR, RITZI, BOUNDS,   
         Q, LDQ, WORKL, IPNTR, WORKD, INFO )   

   \Arguments   

    IDO, BMAT, N, WHICH, NEV, TOL, RESID: same as defined in dnaupd.   
    MODE, ISHIFT, MXITER: see the definition of IPARAM in dnaupd.   

    NP      Integer.  (INPUT/OUTPUT)   
            Contains the number of implicit shifts to apply during   
            each Arnoldi iteration.   
            If ISHIFT=1, NP is adjusted dynamically at each iteration   
            to accelerate convergence and prevent stagnation.   
            This is also roughly equal to the number of matrix-vector   
            products (involving the operator OP) per Arnoldi iteration.   
            The logic for adjusting is contained within the current   
            subroutine.   
            If ISHIFT=0, NP is the number of shifts the user needs   
            to provide via reverse comunication. 0 < NP < NCV-NEV.   
            NP may be less than NCV-NEV for two reasons. The first, is   
            to keep complex conjugate pairs of "wanted" Ritz values   
            together. The second, is that a leading block of the current   
            upper Hessenberg matrix has split off and contains "unwanted"   
            Ritz values.   
            Upon termination of the IRA iteration, NP contains the number   
            of "converged" wanted Ritz values.   

    IUPD    Integer.  (INPUT)   
            IUPD .EQ. 0: use explicit restart instead implicit update.   
            IUPD .NE. 0: use implicit update.   

    V       Double precision N by (NEV+NP) array.  (INPUT/OUTPUT)   
            The Arnoldi basis vectors are returned in the first NEV   
            columns of V.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (NEV+NP) by (NEV+NP) array.  (OUTPUT)   
            H is used to store the generated upper Hessenberg matrix   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    RITZR,  Double precision arrays of length NEV+NP.  (OUTPUT)   
    RITZI   RITZR(1:NEV) (resp. RITZI(1:NEV)) contains the real (resp.   
            imaginary) part of the computed Ritz values of OP.   

    BOUNDS  Double precision array of length NEV+NP.  (OUTPUT)   
            BOUNDS(1:NEV) contain the error bounds corresponding to   
            the computed Ritz values.   

    Q       Double precision (NEV+NP) by (NEV+NP) array.  (WORKSPACE)   
            Private (replicated) work array used to accumulate the   
            rotation in the shift application step.   

    LDQ     Integer.  (INPUT)   
            Leading dimension of Q exactly as declared in the calling   
            program.   

    WORKL   Double precision work array of length at least   
            (NEV+NP)**2 + 3*(NEV+NP).  (INPUT/WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.  It is used in shifts calculation, shifts   
            application and convergence checking.   

            On exit, the last 3*(NEV+NP) locations of WORKL contain   
            the Ritz values (real,imaginary) and associated Ritz   
            estimates of the current Hessenberg matrix.  They are   
            listed in the same order as returned from dneigh.   

            If ISHIFT .EQ. O and IDO .EQ. 3, the first 2*NP locations   
            of WORKL are used in reverse communication to hold the user   
            supplied shifts.   

    IPNTR   Integer array of length 3.  (OUTPUT)   
            Pointer to mark the starting locations in the WORKD for   
            vectors used by the Arnoldi iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X.   
            IPNTR(2): pointer to the current result vector Y.   
            IPNTR(3): pointer to the vector B * X when used in the   
                      shift-and-invert mode.  X is the current operand.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (WORKSPACE)   
            Distributed array to be used in the basic Arnoldi iteration   
            for reverse communication.  The user should not use WORKD   
            as temporary workspace during the iteration !!!!!!!!!!   
            See Data Distribution Note in DNAUPD.   

    INFO    Integer.  (INPUT/OUTPUT)   
            If INFO .EQ. 0, a randomly initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            Error flag on output.   
            =     0: Normal return.   
            =     1: Maximum number of iterations taken.   
                     All possible eigenvalues of OP has been found.   
                     NP returns the number of converged Ritz values.   
            =     2: No shifts could be applied.   
            =    -8: Error return from LAPACK eigenvalue calculation;   
                     This should never happen.   
            =    -9: Starting vector is zero.   
            = -9999: Could not build an Arnoldi factorization.   
                     Size that was built in returned in NP.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   

   \Routines called:   
       dgetv0  ARPACK initial vector generation routine.   
       dnaitr  ARPACK Arnoldi factorization routine.   
       dnapps  ARPACK application of implicit shifts routine.   
       dnconv  ARPACK convergence of Ritz values routine.   
       dneigh  ARPACK compute Ritz values and error bounds routine.   
       dngets  ARPACK reorder Ritz values and error bounds routine.   
       dsortc  ARPACK sorting routine.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dmout   ARPACK utility routine that prints matrices   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   
       dswap   Level 1 BLAS that swaps two vectors.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: naup2.F   SID: 2.4   DATE OF SID: 7/30/96   RELEASE: 2   

   \Remarks   
       1. None   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdnaup2_(integer *ido, char *bmat, integer *n, char *
	which, integer *nev, integer *np, doublereal *tol, doublereal *resid, 
	integer *mode, integer *iupd, integer *ishift, integer *mxiter, 
	doublereal *v, integer *ldv, doublereal *h__, integer *ldh, 
	doublereal *ritzr, doublereal *ritzi, doublereal *bounds, doublereal *
	q, integer *ldq, doublereal *workl, integer *ipntr, doublereal *workd,
	 integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, q_dim1, q_offset, v_dim1, v_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double pow_dd(doublereal *, doublereal *);
    integer s_cmp(char *, char *, ftnlen, ftnlen);
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    double sqrt(doublereal);

    /* Local variables */
    IGRAPH_F77_SAVE integer j;
    IGRAPH_F77_SAVE real t0, t1, t2, t3;
    IGRAPH_F77_SAVE integer kp[4], np0, nbx, nev0;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE doublereal eps23;
    IGRAPH_F77_SAVE integer ierr, iter;
    IGRAPH_F77_SAVE doublereal temp;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    IGRAPH_F77_SAVE logical getv0, cnorm;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    IGRAPH_F77_SAVE integer nconv;
    extern /* Subroutine */ int igraphdmout_(integer *, integer *, integer *, 
	    doublereal *, integer *, integer *, char *, ftnlen);
    IGRAPH_F77_SAVE logical initv;
    IGRAPH_F77_SAVE doublereal rnorm;
    IGRAPH_F77_SAVE real tmvbx;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *
	    , logical *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    IGRAPH_F77_SAVE integer mnaup2;
    IGRAPH_F77_SAVE real tnaup2;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdneigh_(doublereal *, integer *, doublereal *,
	     integer *, doublereal *, doublereal *, doublereal *, doublereal *
	    , integer *, doublereal *, integer *);
    IGRAPH_F77_SAVE integer nevbef;
    extern /* Subroutine */ int igraphsecond_(real *);
    IGRAPH_F77_SAVE integer logfil, ndigit;
    extern /* Subroutine */ int igraphdnaitr_(integer *, char *, integer *, integer 
	    *, integer *, integer *, doublereal *, doublereal *, doublereal *,
	     integer *, doublereal *, integer *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE logical update;
    extern /* Subroutine */ int igraphdngets_(integer *, char *, integer *, integer 
	    *, doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *), igraphdnapps_(integer *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, doublereal *,
	     integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    doublereal *), igraphdnconv_(integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, integer *), igraphdsortc_(char *, logical *,
	     integer *, doublereal *, doublereal *, doublereal *);
    IGRAPH_F77_SAVE logical ushift;
    IGRAPH_F77_SAVE char wprime[2];
    IGRAPH_F77_SAVE integer msglvl, nptemp, numcnv, kplusp;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %-----------------------%   
       | Local array arguments |   
       %-----------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    --workd;
    --resid;
    --workl;
    --bounds;
    --ritzi;
    --ritzr;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;
    --ipntr;

    /* Function Body */
    if (*ido == 0) {

	igraphsecond_(&t0);

	msglvl = mnaup2;

/*        %-------------------------------------%   
          | Get the machine dependent constant. |   
          %-------------------------------------% */

	eps23 = igraphdlamch_("Epsilon-Machine");
	eps23 = pow_dd(&eps23, &c_b3);

	nev0 = *nev;
	np0 = *np;

/*        %-------------------------------------%   
          | kplusp is the bound on the largest  |   
          |        Lanczos factorization built. |   
          | nconv is the current number of      |   
          |        "converged" eigenvlues.      |   
          | iter is the counter on the current  |   
          |      iteration step.                |   
          %-------------------------------------% */

	kplusp = *nev + *np;
	nconv = 0;
	iter = 0;

/*        %---------------------------------------%   
          | Set flags for computing the first NEV |   
          | steps of the Arnoldi factorization.   |   
          %---------------------------------------% */

	getv0 = TRUE_;
	update = FALSE_;
	ushift = FALSE_;
	cnorm = FALSE_;

	if (*info != 0) {

/*           %--------------------------------------------%   
             | User provides the initial residual vector. |   
             %--------------------------------------------% */

	    initv = TRUE_;
	    *info = 0;
	} else {
	    initv = FALSE_;
	}
    }

/*     %---------------------------------------------%   
       | Get a possibly random starting vector and   |   
       | force it into the range of the operator OP. |   
       %---------------------------------------------%   

   L10: */

    if (getv0) {
	igraphdgetv0_(ido, bmat, &c__1, &initv, n, &c__1, &v[v_offset], ldv, &resid[
		1], &rnorm, &ipntr[1], &workd[1], info);

	if (*ido != 99) {
	    goto L9000;
	}

	if (rnorm == 0.) {

/*           %-----------------------------------------%   
             | The initial vector is zero. Error exit. |   
             %-----------------------------------------% */

	    *info = -9;
	    goto L1100;
	}
	getv0 = FALSE_;
	*ido = 0;
    }

/*     %-----------------------------------%   
       | Back from reverse communication : |   
       | continue with update step         |   
       %-----------------------------------% */

    if (update) {
	goto L20;
    }

/*     %-------------------------------------------%   
       | Back from computing user specified shifts |   
       %-------------------------------------------% */

    if (ushift) {
	goto L50;
    }

/*     %-------------------------------------%   
       | Back from computing residual norm   |   
       | at the end of the current iteration |   
       %-------------------------------------% */

    if (cnorm) {
	goto L100;
    }

/*     %----------------------------------------------------------%   
       | Compute the first NEV steps of the Arnoldi factorization |   
       %----------------------------------------------------------% */

    igraphdnaitr_(ido, bmat, n, &c__0, nev, mode, &resid[1], &rnorm, &v[v_offset], 
	    ldv, &h__[h_offset], ldh, &ipntr[1], &workd[1], info);

/*     %---------------------------------------------------%   
       | ido .ne. 99 implies use of reverse communication  |   
       | to compute operations involving OP and possibly B |   
       %---------------------------------------------------% */

    if (*ido != 99) {
	goto L9000;
    }

    if (*info > 0) {
	*np = *info;
	*mxiter = iter;
	*info = -9999;
	goto L1200;
    }

/*     %--------------------------------------------------------------%   
       |                                                              |   
       |           M A I N  ARNOLDI  I T E R A T I O N  L O O P       |   
       |           Each iteration implicitly restarts the Arnoldi     |   
       |           factorization in place.                            |   
       |                                                              |   
       %--------------------------------------------------------------% */

L1000:

    ++iter;

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &iter, &ndigit, "_naup2: **** Start of major "
		"iteration number ****", (ftnlen)49);
    }

/*        %-----------------------------------------------------------%   
          | Compute NP additional steps of the Arnoldi factorization. |   
          | Adjust NP since NEV might have been updated by last call  |   
          | to the shift application routine dnapps.                  |   
          %-----------------------------------------------------------% */

    *np = kplusp - *nev;

    if (msglvl > 1) {
	igraphivout_(&logfil, &c__1, nev, &ndigit, "_naup2: The length of the curr"
		"ent Arnoldi factorization", (ftnlen)55);
	igraphivout_(&logfil, &c__1, np, &ndigit, "_naup2: Extend the Arnoldi fact"
		"orization by", (ftnlen)43);
    }

/*        %-----------------------------------------------------------%   
          | Compute NP additional steps of the Arnoldi factorization. |   
          %-----------------------------------------------------------% */

    *ido = 0;
L20:
    update = TRUE_;

    igraphdnaitr_(ido, bmat, n, nev, np, mode, &resid[1], &rnorm, &v[v_offset], ldv,
	     &h__[h_offset], ldh, &ipntr[1], &workd[1], info);

/*        %---------------------------------------------------%   
          | ido .ne. 99 implies use of reverse communication  |   
          | to compute operations involving OP and possibly B |   
          %---------------------------------------------------% */

    if (*ido != 99) {
	goto L9000;
    }

    if (*info > 0) {
	*np = *info;
	*mxiter = iter;
	*info = -9999;
	goto L1200;
    }
    update = FALSE_;

    if (msglvl > 1) {
	igraphdvout_(&logfil, &c__1, &rnorm, &ndigit, "_naup2: Corresponding B-nor"
		"m of the residual", (ftnlen)44);
    }

/*        %--------------------------------------------------------%   
          | Compute the eigenvalues and corresponding error bounds |   
          | of the current upper Hessenberg matrix.                |   
          %--------------------------------------------------------% */

    igraphdneigh_(&rnorm, &kplusp, &h__[h_offset], ldh, &ritzr[1], &ritzi[1], &
	    bounds[1], &q[q_offset], ldq, &workl[1], &ierr);

    if (ierr != 0) {
	*info = -8;
	goto L1200;
    }

/*        %----------------------------------------------------%   
          | Make a copy of eigenvalues and corresponding error |   
          | bounds obtained from dneigh.                       |   
          %----------------------------------------------------%   

   Computing 2nd power */
    i__1 = kplusp;
    igraphdcopy_(&kplusp, &ritzr[1], &c__1, &workl[i__1 * i__1 + 1], &c__1);
/* Computing 2nd power */
    i__1 = kplusp;
    igraphdcopy_(&kplusp, &ritzi[1], &c__1, &workl[i__1 * i__1 + kplusp + 1], &c__1)
	    ;
/* Computing 2nd power */
    i__1 = kplusp;
    igraphdcopy_(&kplusp, &bounds[1], &c__1, &workl[i__1 * i__1 + (kplusp << 1) + 1]
	    , &c__1);

/*        %---------------------------------------------------%   
          | Select the wanted Ritz values and their bounds    |   
          | to be used in the convergence test.               |   
          | The wanted part of the spectrum and corresponding |   
          | error bounds are in the last NEV loc. of RITZR,   |   
          | RITZI and BOUNDS respectively. The variables NEV  |   
          | and NP may be updated if the NEV-th wanted Ritz   |   
          | value has a non zero imaginary part. In this case |   
          | NEV is increased by one and NP decreased by one.  |   
          | NOTE: The last two arguments of dngets are no     |   
          | longer used as of version 2.1.                    |   
          %---------------------------------------------------% */

    *nev = nev0;
    *np = np0;
    numcnv = *nev;
    igraphdngets_(ishift, which, nev, np, &ritzr[1], &ritzi[1], &bounds[1], &workl[
	    1], &workl[*np + 1]);
    if (*nev == nev0 + 1) {
	numcnv = nev0 + 1;
    }

/*        %-------------------%   
          | Convergence test. |   
          %-------------------% */

    igraphdcopy_(nev, &bounds[*np + 1], &c__1, &workl[(*np << 1) + 1], &c__1);
    igraphdnconv_(nev, &ritzr[*np + 1], &ritzi[*np + 1], &workl[(*np << 1) + 1], 
	    tol, &nconv);

    if (msglvl > 2) {
	kp[0] = *nev;
	kp[1] = *np;
	kp[2] = numcnv;
	kp[3] = nconv;
	igraphivout_(&logfil, &c__4, kp, &ndigit, "_naup2: NEV, NP, NUMCNV, NCONV "
		"are", (ftnlen)34);
	igraphdvout_(&logfil, &kplusp, &ritzr[1], &ndigit, "_naup2: Real part of t"
		"he eigenvalues of H", (ftnlen)41);
	igraphdvout_(&logfil, &kplusp, &ritzi[1], &ndigit, "_naup2: Imaginary part"
		" of the eigenvalues of H", (ftnlen)46);
	igraphdvout_(&logfil, &kplusp, &bounds[1], &ndigit, "_naup2: Ritz estimate"
		"s of the current NCV Ritz values", (ftnlen)53);
    }

/*        %---------------------------------------------------------%   
          | Count the number of unwanted Ritz values that have zero |   
          | Ritz estimates. If any Ritz estimates are equal to zero |   
          | then a leading block of H of order equal to at least    |   
          | the number of Ritz values with zero Ritz estimates has  |   
          | split off. None of these Ritz values may be removed by  |   
          | shifting. Decrease NP the number of shifts to apply. If |   
          | no shifts may be applied, then prepare to exit          |   
          %---------------------------------------------------------% */

    nptemp = *np;
    i__1 = nptemp;
    for (j = 1; j <= i__1; ++j) {
	if (bounds[j] == 0.) {
	    --(*np);
	    ++(*nev);
	}
/* L30: */
    }

    if (nconv >= numcnv || iter > *mxiter || *np == 0) {

	if (msglvl > 4) {
/* Computing 2nd power */
	    i__1 = kplusp;
	    igraphdvout_(&logfil, &kplusp, &workl[i__1 * i__1 + 1], &ndigit, "_nau"
		    "p2: Real part of the eig computed by _neigh:", (ftnlen)48)
		    ;
/* Computing 2nd power */
	    i__1 = kplusp;
	    igraphdvout_(&logfil, &kplusp, &workl[i__1 * i__1 + kplusp + 1], &
		    ndigit, "_naup2: Imag part of the eig computed by _neigh:"
		    , (ftnlen)48);
/* Computing 2nd power */
	    i__1 = kplusp;
	    igraphdvout_(&logfil, &kplusp, &workl[i__1 * i__1 + (kplusp << 1) + 1], 
		    &ndigit, "_naup2: Ritz eistmates computed by _neigh:", (
		    ftnlen)42);
	}

/*           %------------------------------------------------%   
             | Prepare to exit. Put the converged Ritz values |   
             | and corresponding bounds in RITZ(1:NCONV) and  |   
             | BOUNDS(1:NCONV) respectively. Then sort. Be    |   
             | careful when NCONV > NP                        |   
             %------------------------------------------------%   

             %------------------------------------------%   
             |  Use h( 3,1 ) as storage to communicate  |   
             |  rnorm to _neupd if needed               |   
             %------------------------------------------% */
	h__[h_dim1 + 3] = rnorm;

/*           %----------------------------------------------%   
             | To be consistent with dngets, we first do a  |   
             | pre-processing sort in order to keep complex |   
             | conjugate pairs together.  This is similar   |   
             | to the pre-processing sort used in dngets    |   
             | except that the sort is done in the opposite |   
             | order.                                       |   
             %----------------------------------------------% */

	if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SR", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LR", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SM", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LM", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SM", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LM", (ftnlen)2, (ftnlen)2);
	}

	igraphdsortc_(wprime, &c_true, &kplusp, &ritzr[1], &ritzi[1], &bounds[1]);

/*           %----------------------------------------------%   
             | Now sort Ritz values so that converged Ritz  |   
             | values appear within the first NEV locations |   
             | of ritzr, ritzi and bounds, and the most     |   
             | desired one appears at the front.            |   
             %----------------------------------------------% */

	if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SM", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LM", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SR", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LR", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "SI", (ftnlen)2, (ftnlen)2);
	}
	if (s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) == 0) {
	    s_copy(wprime, "LI", (ftnlen)2, (ftnlen)2);
	}

	igraphdsortc_(wprime, &c_true, &kplusp, &ritzr[1], &ritzi[1], &bounds[1]);

/*           %--------------------------------------------------%   
             | Scale the Ritz estimate of each Ritz value       |   
             | by 1 / max(eps23,magnitude of the Ritz value).   |   
             %--------------------------------------------------% */

	i__1 = nev0;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    d__1 = eps23, d__2 = igraphdlapy2_(&ritzr[j], &ritzi[j]);
	    temp = max(d__1,d__2);
	    bounds[j] /= temp;
/* L35: */
	}

/*           %----------------------------------------------------%   
             | Sort the Ritz values according to the scaled Ritz  |   
             | esitmates.  This will push all the converged ones  |   
             | towards the front of ritzr, ritzi, bounds          |   
             | (in the case when NCONV < NEV.)                    |   
             %----------------------------------------------------% */

	s_copy(wprime, "LR", (ftnlen)2, (ftnlen)2);
	igraphdsortc_(wprime, &c_true, &nev0, &bounds[1], &ritzr[1], &ritzi[1]);

/*           %----------------------------------------------%   
             | Scale the Ritz estimate back to its original |   
             | value.                                       |   
             %----------------------------------------------% */

	i__1 = nev0;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    d__1 = eps23, d__2 = igraphdlapy2_(&ritzr[j], &ritzi[j]);
	    temp = max(d__1,d__2);
	    bounds[j] *= temp;
/* L40: */
	}

/*           %------------------------------------------------%   
             | Sort the converged Ritz values again so that   |   
             | the "threshold" value appears at the front of  |   
             | ritzr, ritzi and bound.                        |   
             %------------------------------------------------% */

	igraphdsortc_(which, &c_true, &nconv, &ritzr[1], &ritzi[1], &bounds[1]);

	if (msglvl > 1) {
	    igraphdvout_(&logfil, &kplusp, &ritzr[1], &ndigit, "_naup2: Sorted rea"
		    "l part of the eigenvalues", (ftnlen)43);
	    igraphdvout_(&logfil, &kplusp, &ritzi[1], &ndigit, "_naup2: Sorted ima"
		    "ginary part of the eigenvalues", (ftnlen)48);
	    igraphdvout_(&logfil, &kplusp, &bounds[1], &ndigit, "_naup2: Sorted ri"
		    "tz estimates.", (ftnlen)30);
	}

/*           %------------------------------------%   
             | Max iterations have been exceeded. |   
             %------------------------------------% */

	if (iter > *mxiter && nconv < numcnv) {
	    *info = 1;
	}

/*           %---------------------%   
             | No shifts to apply. |   
             %---------------------% */

	if (*np == 0 && nconv < numcnv) {
	    *info = 2;
	}

	*np = nconv;
	goto L1100;

    } else if (nconv < numcnv && *ishift == 1) {

/*           %-------------------------------------------------%   
             | Do not have all the requested eigenvalues yet.  |   
             | To prevent possible stagnation, adjust the size |   
             | of NEV.                                         |   
             %-------------------------------------------------% */

	nevbef = *nev;
/* Computing MIN */
	i__1 = nconv, i__2 = *np / 2;
	*nev += min(i__1,i__2);
	if (*nev == 1 && kplusp >= 6) {
	    *nev = kplusp / 2;
	} else if (*nev == 1 && kplusp > 3) {
	    *nev = 2;
	}
	*np = kplusp - *nev;

/*           %---------------------------------------%   
             | If the size of NEV was just increased |   
             | resort the eigenvalues.               |   
             %---------------------------------------% */

	if (nevbef < *nev) {
	    igraphdngets_(ishift, which, nev, np, &ritzr[1], &ritzi[1], &bounds[1], 
		    &workl[1], &workl[*np + 1]);
	}

    }

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &nconv, &ndigit, "_naup2: no. of \"converge"
		"d\" Ritz values at this iter.", (ftnlen)52);
	if (msglvl > 1) {
	    kp[0] = *nev;
	    kp[1] = *np;
	    igraphivout_(&logfil, &c__2, kp, &ndigit, "_naup2: NEV and NP are", (
		    ftnlen)22);
	    igraphdvout_(&logfil, nev, &ritzr[*np + 1], &ndigit, "_naup2: \"wante"
		    "d\" Ritz values -- real part", (ftnlen)41);
	    igraphdvout_(&logfil, nev, &ritzi[*np + 1], &ndigit, "_naup2: \"wante"
		    "d\" Ritz values -- imag part", (ftnlen)41);
	    igraphdvout_(&logfil, nev, &bounds[*np + 1], &ndigit, "_naup2: Ritz es"
		    "timates of the \"wanted\" values ", (ftnlen)46);
	}
    }

    if (*ishift == 0) {

/*           %-------------------------------------------------------%   
             | User specified shifts: reverse comminucation to       |   
             | compute the shifts. They are returned in the first    |   
             | 2*NP locations of WORKL.                              |   
             %-------------------------------------------------------% */

	ushift = TRUE_;
	*ido = 3;
	goto L9000;
    }

L50:

/*        %------------------------------------%   
          | Back from reverse communication;   |   
          | User specified shifts are returned |   
          | in WORKL(1:2*NP)                   |   
          %------------------------------------% */

    ushift = FALSE_;

    if (*ishift == 0) {

/*            %----------------------------------%   
              | Move the NP shifts from WORKL to |   
              | RITZR, RITZI to free up WORKL    |   
              | for non-exact shift case.        |   
              %----------------------------------% */

	igraphdcopy_(np, &workl[1], &c__1, &ritzr[1], &c__1);
	igraphdcopy_(np, &workl[*np + 1], &c__1, &ritzi[1], &c__1);
    }

    if (msglvl > 2) {
	igraphivout_(&logfil, &c__1, np, &ndigit, "_naup2: The number of shifts to"
		" apply ", (ftnlen)38);
	igraphdvout_(&logfil, np, &ritzr[1], &ndigit, "_naup2: Real part of the sh"
		"ifts", (ftnlen)31);
	igraphdvout_(&logfil, np, &ritzi[1], &ndigit, "_naup2: Imaginary part of t"
		"he shifts", (ftnlen)36);
	if (*ishift == 1) {
	    igraphdvout_(&logfil, np, &bounds[1], &ndigit, "_naup2: Ritz estimates"
		    " of the shifts", (ftnlen)36);
	}
    }

/*        %---------------------------------------------------------%   
          | Apply the NP implicit shifts by QR bulge chasing.       |   
          | Each shift is applied to the whole upper Hessenberg     |   
          | matrix H.                                               |   
          | The first 2*N locations of WORKD are used as workspace. |   
          %---------------------------------------------------------% */

    igraphdnapps_(n, nev, np, &ritzr[1], &ritzi[1], &v[v_offset], ldv, &h__[
	    h_offset], ldh, &resid[1], &q[q_offset], ldq, &workl[1], &workd[1]
	    );

/*        %---------------------------------------------%   
          | Compute the B-norm of the updated residual. |   
          | Keep B*RESID in WORKD(1:N) to be used in    |   
          | the first step of the next call to dnaitr.  |   
          %---------------------------------------------% */

    cnorm = TRUE_;
    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[*n + 1], &c__1);
	ipntr[1] = *n + 1;
	ipntr[2] = 1;
	*ido = 2;

/*           %----------------------------------%   
             | Exit in order to compute B*RESID |   
             %----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[1], &c__1);
    }

L100:

/*        %----------------------------------%   
          | Back from reverse communication; |   
          | WORKD(1:N) := B*RESID            |   
          %----------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    if (*(unsigned char *)bmat == 'G') {
	rnorm = igraphddot_(n, &resid[1], &c__1, &workd[1], &c__1);
	rnorm = sqrt((abs(rnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	rnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }
    cnorm = FALSE_;

    if (msglvl > 2) {
	igraphdvout_(&logfil, &c__1, &rnorm, &ndigit, "_naup2: B-norm of residual "
		"for compressed factorization", (ftnlen)55);
	igraphdmout_(&logfil, nev, nev, &h__[h_offset], ldh, &ndigit, "_naup2: Com"
		"pressed upper Hessenberg matrix H", (ftnlen)44);
    }

    goto L1000;

/*     %---------------------------------------------------------------%   
       |                                                               |   
       |  E N D     O F     M A I N     I T E R A T I O N     L O O P  |   
       |                                                               |   
       %---------------------------------------------------------------% */

L1100:

    *mxiter = iter;
    *nev = numcnv;

L1200:
    *ido = 99;

/*     %------------%   
       | Error Exit |   
       %------------% */

    igraphsecond_(&t1);
    tnaup2 = t1 - t0;

L9000:

/*     %---------------%   
       | End of dnaup2 |   
       %---------------% */

    return 0;
} /* igraphdnaup2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnaupd.c0000644000175100001710000010177300000000000024032 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* \BeginDoc   

   \Name: dnaupd   

   \Description:   
    Reverse communication interface for the Implicitly Restarted Arnoldi   
    iteration. This subroutine computes approximations to a few eigenpairs   
    of a linear operator "OP" with respect to a semi-inner product defined by   
    a symmetric positive semi-definite real matrix B. B may be the identity   
    matrix. NOTE: If the linear operator "OP" is real and symmetric   
    with respect to the real positive semi-definite symmetric matrix B,   
    i.e. B*OP = (OP')*B, then subroutine ssaupd should be used instead.   

    The computed approximate eigenvalues are called Ritz values and   
    the corresponding approximate eigenvectors are called Ritz vectors.   

    dnaupd is usually called iteratively to solve one of the   
    following problems:   

    Mode 1:  A*x = lambda*x.   
             ===> OP = A  and  B = I.   

    Mode 2:  A*x = lambda*M*x, M symmetric positive definite   
             ===> OP = inv[M]*A  and  B = M.   
             ===> (If M can be factored see remark 3 below)   

    Mode 3:  A*x = lambda*M*x, M symmetric semi-definite   
             ===> OP = Real_Part{ inv[A - sigma*M]*M }  and  B = M.   
             ===> shift-and-invert mode (in real arithmetic)   
             If OP*x = amu*x, then   
             amu = 1/2 * [ 1/(lambda-sigma) + 1/(lambda-conjg(sigma)) ].   
             Note: If sigma is real, i.e. imaginary part of sigma is zero;   
                   Real_Part{ inv[A - sigma*M]*M } == inv[A - sigma*M]*M   
                   amu == 1/(lambda-sigma).   

    Mode 4:  A*x = lambda*M*x, M symmetric semi-definite   
             ===> OP = Imaginary_Part{ inv[A - sigma*M]*M }  and  B = M.   
             ===> shift-and-invert mode (in real arithmetic)   
             If OP*x = amu*x, then   
             amu = 1/2i * [ 1/(lambda-sigma) - 1/(lambda-conjg(sigma)) ].   

    Both mode 3 and 4 give the same enhancement to eigenvalues close to   
    the (complex) shift sigma.  However, as lambda goes to infinity,   
    the operator OP in mode 4 dampens the eigenvalues more strongly than   
    does OP defined in mode 3.   

    NOTE: The action of w <- inv[A - sigma*M]*v or w <- inv[M]*v   
          should be accomplished either by a direct method   
          using a sparse matrix factorization and solving   

             [A - sigma*M]*w = v  or M*w = v,   

          or through an iterative method for solving these   
          systems.  If an iterative method is used, the   
          convergence test must be more stringent than   
          the accuracy requirements for the eigenvalue   
          approximations.   

   \Usage:   
    call dnaupd   
       ( IDO, BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM,   
         IPNTR, WORKD, WORKL, LWORKL, INFO )   

   \Arguments   
    IDO     Integer.  (INPUT/OUTPUT)   
            Reverse communication flag.  IDO must be zero on the first   
            call to dnaupd.  IDO will be set internally to   
            indicate the type of operation to be performed.  Control is   
            then given back to the calling routine which has the   
            responsibility to carry out the requested operation and call   
            dnaupd with the result.  The operand is given in   
            WORKD(IPNTR(1)), the result must be put in WORKD(IPNTR(2)).   
            -------------------------------------------------------------   
            IDO =  0: first call to the reverse communication interface   
            IDO = -1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
                      This is for the initialization phase to force the   
                      starting vector into the range of OP.   
            IDO =  1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
                      In mode 3 and 4, the vector B * X is already   
                      available in WORKD(ipntr(3)).  It does not   
                      need to be recomputed in forming OP * X.   
            IDO =  2: compute  Y = B * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
            IDO =  3: compute the IPARAM(8) real and imaginary parts   
                      of the shifts where INPTR(14) is the pointer   
                      into WORKL for placing the shifts. See Remark   
                      5 below.   
            IDO = 99: done   
            -------------------------------------------------------------   

    BMAT    Character*1.  (INPUT)   
            BMAT specifies the type of the matrix B that defines the   
            semi-inner product for the operator OP.   
            BMAT = 'I' -> standard eigenvalue problem A*x = lambda*x   
            BMAT = 'G' -> generalized eigenvalue problem A*x = lambda*B*x   

    N       Integer.  (INPUT)   
            Dimension of the eigenproblem.   

    WHICH   Character*2.  (INPUT)   
            'LM' -> want the NEV eigenvalues of largest magnitude.   
            'SM' -> want the NEV eigenvalues of smallest magnitude.   
            'LR' -> want the NEV eigenvalues of largest real part.   
            'SR' -> want the NEV eigenvalues of smallest real part.   
            'LI' -> want the NEV eigenvalues of largest imaginary part.   
            'SI' -> want the NEV eigenvalues of smallest imaginary part.   

    NEV     Integer.  (INPUT)   
            Number of eigenvalues of OP to be computed. 0 < NEV < N-1.   

    TOL     Double precision scalar.  (INPUT)   
            Stopping criterion: the relative accuracy of the Ritz value   
            is considered acceptable if BOUNDS(I) .LE. TOL*ABS(RITZ(I))   
            where ABS(RITZ(I)) is the magnitude when RITZ(I) is complex.   
            DEFAULT = DLAMCH('EPS')  (machine precision as computed   
                      by the LAPACK auxiliary subroutine DLAMCH).   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            On INPUT:   
            If INFO .EQ. 0, a random initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            On OUTPUT:   
            RESID contains the final residual vector.   

    NCV     Integer.  (INPUT)   
            Number of columns of the matrix V. NCV must satisfy the two   
            inequalities 2 <= NCV-NEV and NCV <= N.   
            This will indicate how many Arnoldi vectors are generated   
            at each iteration.  After the startup phase in which NEV   
            Arnoldi vectors are generated, the algorithm generates   
            approximately NCV-NEV Arnoldi vectors at each subsequent update   
            iteration. Most of the cost in generating each Arnoldi vector is   
            in the matrix-vector operation OP*x.   
            NOTE: 2 <= NCV-NEV in order that complex conjugate pairs of Ritz   
            values are kept together. (See remark 4 below)   

    V       Double precision array N by NCV.  (OUTPUT)   
            Contains the final set of Arnoldi basis vectors.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling program.   

    IPARAM  Integer array of length 11.  (INPUT/OUTPUT)   
            IPARAM(1) = ISHIFT: method for selecting the implicit shifts.   
            The shifts selected at each iteration are used to restart   
            the Arnoldi iteration in an implicit fashion.   
            -------------------------------------------------------------   
            ISHIFT = 0: the shifts are provided by the user via   
                        reverse communication.  The real and imaginary   
                        parts of the NCV eigenvalues of the Hessenberg   
                        matrix H are returned in the part of the WORKL   
                        array corresponding to RITZR and RITZI. See remark   
                        5 below.   
            ISHIFT = 1: exact shifts with respect to the current   
                        Hessenberg matrix H.  This is equivalent to   
                        restarting the iteration with a starting vector   
                        that is a linear combination of approximate Schur   
                        vectors associated with the "wanted" Ritz values.   
            -------------------------------------------------------------   

            IPARAM(2) = No longer referenced.   

            IPARAM(3) = MXITER   
            On INPUT:  maximum number of Arnoldi update iterations allowed.   
            On OUTPUT: actual number of Arnoldi update iterations taken.   

            IPARAM(4) = NB: blocksize to be used in the recurrence.   
            The code currently works only for NB = 1.   

            IPARAM(5) = NCONV: number of "converged" Ritz values.   
            This represents the number of Ritz values that satisfy   
            the convergence criterion.   

            IPARAM(6) = IUPD   
            No longer referenced. Implicit restarting is ALWAYS used.   

            IPARAM(7) = MODE   
            On INPUT determines what type of eigenproblem is being solved.   
            Must be 1,2,3,4; See under \Description of dnaupd for the   
            four modes available.   

            IPARAM(8) = NP   
            When ido = 3 and the user provides shifts through reverse   
            communication (IPARAM(1)=0), dnaupd returns NP, the number   
            of shifts the user is to provide. 0 < NP <=NCV-NEV. See Remark   
            5 below.   

            IPARAM(9) = NUMOP, IPARAM(10) = NUMOPB, IPARAM(11) = NUMREO,   
            OUTPUT: NUMOP  = total number of OP*x operations,   
                    NUMOPB = total number of B*x operations if BMAT='G',   
                    NUMREO = total number of steps of re-orthogonalization.   

    IPNTR   Integer array of length 14.  (OUTPUT)   
            Pointer to mark the starting locations in the WORKD and WORKL   
            arrays for matrices/vectors used by the Arnoldi iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X in WORKD.   
            IPNTR(2): pointer to the current result vector Y in WORKD.   
            IPNTR(3): pointer to the vector B * X in WORKD when used in   
                      the shift-and-invert mode.   
            IPNTR(4): pointer to the next available location in WORKL   
                      that is untouched by the program.   
            IPNTR(5): pointer to the NCV by NCV upper Hessenberg matrix   
                      H in WORKL.   
            IPNTR(6): pointer to the real part of the ritz value array   
                      RITZR in WORKL.   
            IPNTR(7): pointer to the imaginary part of the ritz value array   
                      RITZI in WORKL.   
            IPNTR(8): pointer to the Ritz estimates in array WORKL associated   
                      with the Ritz values located in RITZR and RITZI in WORKL.   

            IPNTR(14): pointer to the NP shifts in WORKL. See Remark 5 below.   

            Note: IPNTR(9:13) is only referenced by dneupd. See Remark 2 below.   

            IPNTR(9):  pointer to the real part of the NCV RITZ values of the   
                       original system.   
            IPNTR(10): pointer to the imaginary part of the NCV RITZ values of   
                       the original system.   
            IPNTR(11): pointer to the NCV corresponding error bounds.   
            IPNTR(12): pointer to the NCV by NCV upper quasi-triangular   
                       Schur matrix for H.   
            IPNTR(13): pointer to the NCV by NCV matrix of eigenvectors   
                       of the upper Hessenberg matrix H. Only referenced by   
                       dneupd if RVEC = .TRUE. See Remark 2 below.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (REVERSE COMMUNICATION)   
            Distributed array to be used in the basic Arnoldi iteration   
            for reverse communication.  The user should not use WORKD   
            as temporary workspace during the iteration. Upon termination   
            WORKD(1:N) contains B*RESID(1:N). If an invariant subspace   
            associated with the converged Ritz values is desired, see remark   
            2 below, subroutine dneupd uses this output.   
            See Data Distribution Note below.   

    WORKL   Double precision work array of length LWORKL.  (OUTPUT/WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.  See Data Distribution Note below.   

    LWORKL  Integer.  (INPUT)   
            LWORKL must be at least 3*NCV**2 + 6*NCV.   

    INFO    Integer.  (INPUT/OUTPUT)   
            If INFO .EQ. 0, a randomly initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            Error flag on output.   
            =  0: Normal exit.   
            =  1: Maximum number of iterations taken.   
                  All possible eigenvalues of OP has been found. IPARAM(5)   
                  returns the number of wanted converged Ritz values.   
            =  2: No longer an informational error. Deprecated starting   
                  with release 2 of ARPACK.   
            =  3: No shifts could be applied during a cycle of the   
                  Implicitly restarted Arnoldi iteration. One possibility   
                  is to increase the size of NCV relative to NEV.   
                  See remark 4 below.   
            = -1: N must be positive.   
            = -2: NEV must be positive.   
            = -3: NCV-NEV >= 2 and less than or equal to N.   
            = -4: The maximum number of Arnoldi update iteration   
                  must be greater than zero.   
            = -5: WHICH must be one of 'LM', 'SM', 'LR', 'SR', 'LI', 'SI'   
            = -6: BMAT must be one of 'I' or 'G'.   
            = -7: Length of private work array is not sufficient.   
            = -8: Error return from LAPACK eigenvalue calculation;   
            = -9: Starting vector is zero.   
            = -10: IPARAM(7) must be 1,2,3,4.   
            = -11: IPARAM(7) = 1 and BMAT = 'G' are incompatable.   
            = -12: IPARAM(1) must be equal to 0 or 1.   
            = -9999: Could not build an Arnoldi factorization.   
                     IPARAM(5) returns the size of the current Arnoldi   
                     factorization.   

   \Remarks   
    1. The computed Ritz values are approximate eigenvalues of OP. The   
       selection of WHICH should be made with this in mind when   
       Mode = 3 and 4.  After convergence, approximate eigenvalues of the   
       original problem may be obtained with the ARPACK subroutine dneupd.   

    2. If a basis for the invariant subspace corresponding to the converged Ritz   
       values is needed, the user must call dneupd immediately following   
       completion of dnaupd. This is new starting with release 2 of ARPACK.   

    3. If M can be factored into a Cholesky factorization M = LL'   
       then Mode = 2 should not be selected.  Instead one should use   
       Mode = 1 with  OP = inv(L)*A*inv(L').  Appropriate triangular   
       linear systems should be solved with L and L' rather   
       than computing inverses.  After convergence, an approximate   
       eigenvector z of the original problem is recovered by solving   
       L'z = x  where x is a Ritz vector of OP.   

    4. At present there is no a-priori analysis to guide the selection   
       of NCV relative to NEV.  The only formal requrement is that NCV > NEV + 2.   
       However, it is recommended that NCV .ge. 2*NEV+1.  If many problems of   
       the same type are to be solved, one should experiment with increasing   
       NCV while keeping NEV fixed for a given test problem.  This will   
       usually decrease the required number of OP*x operations but it   
       also increases the work and storage required to maintain the orthogonal   
       basis vectors.  The optimal "cross-over" with respect to CPU time   
       is problem dependent and must be determined empirically.   
       See Chapter 8 of Reference 2 for further information.   

    5. When IPARAM(1) = 0, and IDO = 3, the user needs to provide the   
       NP = IPARAM(8) real and imaginary parts of the shifts in locations   
           real part                  imaginary part   
           -----------------------    --------------   
       1   WORKL(IPNTR(14))           WORKL(IPNTR(14)+NP)   
       2   WORKL(IPNTR(14)+1)         WORKL(IPNTR(14)+NP+1)   
                          .                          .   
                          .                          .   
                          .                          .   
       NP  WORKL(IPNTR(14)+NP-1)      WORKL(IPNTR(14)+2*NP-1).   

       Only complex conjugate pairs of shifts may be applied and the pairs   
       must be placed in consecutive locations. The real part of the   
       eigenvalues of the current upper Hessenberg matrix are located in   
       WORKL(IPNTR(6)) through WORKL(IPNTR(6)+NCV-1) and the imaginary part   
       in WORKL(IPNTR(7)) through WORKL(IPNTR(7)+NCV-1). They are ordered   
       according to the order defined by WHICH. The complex conjugate   
       pairs are kept together and the associated Ritz estimates are located in   
       WORKL(IPNTR(8)), WORKL(IPNTR(8)+1), ... , WORKL(IPNTR(8)+NCV-1).   

   -----------------------------------------------------------------------   

   \Data Distribution Note:   

    Fortran-D syntax:   
    ================   
    Double precision resid(n), v(ldv,ncv), workd(3*n), workl(lworkl)   
    decompose  d1(n), d2(n,ncv)   
    align      resid(i) with d1(i)   
    align      v(i,j)   with d2(i,j)   
    align      workd(i) with d1(i)     range (1:n)   
    align      workd(i) with d1(i-n)   range (n+1:2*n)   
    align      workd(i) with d1(i-2*n) range (2*n+1:3*n)   
    distribute d1(block), d2(block,:)   
    replicated workl(lworkl)   

    Cray MPP syntax:   
    ===============   
    Double precision  resid(n), v(ldv,ncv), workd(n,3), workl(lworkl)   
    shared     resid(block), v(block,:), workd(block,:)   
    replicated workl(lworkl)   

    CM2/CM5 syntax:   
    ==============   

   -----------------------------------------------------------------------   

       include   'ex-nonsym.doc'   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   
    3. B.N. Parlett & Y. Saad, "Complex Shift and Invert Strategies for   
       Real Matrices", Linear Algebra and its Applications, vol 88/89,   
       pp 575-595, (1987).   

   \Routines called:   
       dnaup2  ARPACK routine that implements the Implicitly Restarted   
               Arnoldi Iteration.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/16/93: Version '1.1'   

   \SCCS Information: @(#)   
   FILE: naupd.F   SID: 2.5   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdnaupd_(integer *ido, char *bmat, integer *n, char *
	which, integer *nev, doublereal *tol, doublereal *resid, integer *ncv,
	 doublereal *v, integer *ldv, integer *iparam, integer *ipntr, 
	doublereal *workd, doublereal *workl, integer *lworkl, integer *info)
{
    /* Format strings */
    static char fmt_1000[] = "(//,5x,\002==================================="
	    "==========\002,/5x,\002= Nonsymmetric implicit Arnoldi update co"
	    "de =\002,/5x,\002= Version Number: \002,\002 2.4\002,21x,\002 "
	    "=\002,/5x,\002= Version Date:   \002,\002 07/31/96\002,16x,\002 ="
	    "\002,/5x,\002=============================================\002,/"
	    "5x,\002= Summary of timing statistics              =\002,/5x,"
	    "\002=============================================\002,//)";
    static char fmt_1100[] = "(5x,\002Total number update iterations        "
	    "     = \002,i5,/5x,\002Total number of OP*x operations          "
	    "  = \002,i5,/5x,\002Total number of B*x operations             = "
	    "\002,i5,/5x,\002Total number of reorthogonalization steps  = "
	    "\002,i5,/5x,\002Total number of iterative refinement steps = "
	    "\002,i5,/5x,\002Total number of restart steps              = "
	    "\002,i5,/5x,\002Total time in user OP*x operation          = "
	    "\002,f12.6,/5x,\002Total time in user B*x operation           ="
	    " \002,f12.6,/5x,\002Total time in Arnoldi update routine       = "
	    "\002,f12.6,/5x,\002Total time in naup2 routine                ="
	    " \002,f12.6,/5x,\002Total time in basic Arnoldi iteration loop = "
	    "\002,f12.6,/5x,\002Total time in reorthogonalization phase    ="
	    " \002,f12.6,/5x,\002Total time in (re)start vector generation  = "
	    "\002,f12.6,/5x,\002Total time in Hessenberg eig. subproblem   ="
	    " \002,f12.6,/5x,\002Total time in getting the shifts           = "
	    "\002,f12.6,/5x,\002Total time in applying the shifts          ="
	    " \002,f12.6,/5x,\002Total time in convergence testing          = "
	    "\002,f12.6,/5x,\002Total time in computing final Ritz vectors ="
	    " \002,f12.6/)";

    /* System generated locals */
    integer v_dim1, v_offset, i__1, i__2;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(
	    void), do_fio(integer *, char *, ftnlen);

    /* Local variables */
    integer j;
    IGRAPH_F77_SAVE real t0, t1;
    IGRAPH_F77_SAVE integer nb, ih, iq, np, iw, ldh, ldq;
    integer nbx = 0;
    IGRAPH_F77_SAVE integer nev0, mode;
    integer ierr;
    IGRAPH_F77_SAVE integer iupd, next;
    integer nopx = 0;
    IGRAPH_F77_SAVE integer levec;
    real trvec, tmvbx;
    IGRAPH_F77_SAVE integer ritzi;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen);
    IGRAPH_F77_SAVE integer ritzr;
    extern /* Subroutine */ int igraphdnaup2_(integer *, char *, integer *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    integer *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
	     doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    real tnaup2, tgetv0;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphsecond_(real *);
    integer logfil, ndigit;
    real tneigh;
    integer mnaupd = 0;
    IGRAPH_F77_SAVE integer ishift;
    integer nitref;
    IGRAPH_F77_SAVE integer bounds;
    real tnaupd;
    extern /* Subroutine */ int igraphdstatn_(void);
    real titref, tnaitr;
    IGRAPH_F77_SAVE integer msglvl;
    real tngets, tnapps, tnconv;
    IGRAPH_F77_SAVE integer mxiter;
    integer nrorth = 0, nrstrt = 0;
    real tmvopx;

    /* Fortran I/O blocks */
    static cilist io___30 = { 0, 6, 0, fmt_1000, 0 };
    static cilist io___31 = { 0, 6, 0, fmt_1100, 0 };



/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    --workd;
    --resid;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --iparam;
    --ipntr;
    --workl;

    /* Function Body */
    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphdstatn_();
	igraphsecond_(&t0);
	msglvl = mnaupd;

/*        %----------------%   
          | Error checking |   
          %----------------% */

	ierr = 0;
	ishift = iparam[1];
	levec = iparam[2];
	mxiter = iparam[3];
	nb = iparam[4];

/*        %--------------------------------------------%   
          | Revision 2 performs only implicit restart. |   
          %--------------------------------------------% */

	iupd = 1;
	mode = iparam[7];

	if (*n <= 0) {
	    ierr = -1;
	} else if (*nev <= 0) {
	    ierr = -2;
	} else if (*ncv <= *nev + 1 || *ncv > *n) {
	    ierr = -3;
	} else if (mxiter <= 0) {
	    ierr = -4;
	} else if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(
		which, "SM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "LR", 
		(ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "SR", (ftnlen)2, (
		ftnlen)2) != 0 && s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) != 
		0 && s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) != 0) {
	    ierr = -5;
	} else if (*(unsigned char *)bmat != 'I' && *(unsigned char *)bmat != 
		'G') {
	    ierr = -6;
	} else /* if(complicated condition) */ {
/* Computing 2nd power */
	    i__1 = *ncv;
	    if (*lworkl < i__1 * i__1 * 3 + *ncv * 6) {
		ierr = -7;
	    } else if (mode < 1 || mode > 5) {
		ierr = -10;
	    } else if (mode == 1 && *(unsigned char *)bmat == 'G') {
		ierr = -11;
	    } else if (ishift < 0 || ishift > 1) {
		ierr = -12;
	    }
	}

/*        %------------%   
          | Error Exit |   
          %------------% */

	if (ierr != 0) {
	    *info = ierr;
	    *ido = 99;
	    goto L9000;
	}

/*        %------------------------%   
          | Set default parameters |   
          %------------------------% */

	if (nb <= 0) {
	    nb = 1;
	}
	if (*tol <= 0.) {
	    *tol = igraphdlamch_("EpsMach");
	}

/*        %----------------------------------------------%   
          | NP is the number of additional steps to      |   
          | extend the length NEV Lanczos factorization. |   
          | NEV0 is the local variable designating the   |   
          | size of the invariant subspace desired.      |   
          %----------------------------------------------% */

	np = *ncv - *nev;
	nev0 = *nev;

/*        %-----------------------------%   
          | Zero out internal workspace |   
          %-----------------------------%   

   Computing 2nd power */
	i__2 = *ncv;
	i__1 = i__2 * i__2 * 3 + *ncv * 6;
	for (j = 1; j <= i__1; ++j) {
	    workl[j] = 0.;
/* L10: */
	}

/*        %-------------------------------------------------------------%   
          | Pointer into WORKL for address of H, RITZ, BOUNDS, Q        |   
          | etc... and the remaining workspace.                         |   
          | Also update pointer to be used on output.                   |   
          | Memory is laid out as follows:                              |   
          | workl(1:ncv*ncv) := generated Hessenberg matrix             |   
          | workl(ncv*ncv+1:ncv*ncv+2*ncv) := real and imaginary        |   
          |                                   parts of ritz values      |   
          | workl(ncv*ncv+2*ncv+1:ncv*ncv+3*ncv) := error bounds        |   
          | workl(ncv*ncv+3*ncv+1:2*ncv*ncv+3*ncv) := rotation matrix Q |   
          | workl(2*ncv*ncv+3*ncv+1:3*ncv*ncv+6*ncv) := workspace       |   
          | The final workspace is needed by subroutine dneigh called   |   
          | by dnaup2. Subroutine dneigh calls LAPACK routines for      |   
          | calculating eigenvalues and the last row of the eigenvector |   
          | matrix.                                                     |   
          %-------------------------------------------------------------% */

	ldh = *ncv;
	ldq = *ncv;
	ih = 1;
	ritzr = ih + ldh * *ncv;
	ritzi = ritzr + *ncv;
	bounds = ritzi + *ncv;
	iq = bounds + *ncv;
	iw = iq + ldq * *ncv;
/* Computing 2nd power */
	i__1 = *ncv;
	next = iw + i__1 * i__1 + *ncv * 3;

	ipntr[4] = next;
	ipntr[5] = ih;
	ipntr[6] = ritzr;
	ipntr[7] = ritzi;
	ipntr[8] = bounds;
	ipntr[14] = iw;

    }

/*     %-------------------------------------------------------%   
       | Carry out the Implicitly restarted Arnoldi Iteration. |   
       %-------------------------------------------------------% */

    igraphdnaup2_(ido, bmat, n, which, &nev0, &np, tol, &resid[1], &mode, &iupd, &
	    ishift, &mxiter, &v[v_offset], ldv, &workl[ih], &ldh, &workl[
	    ritzr], &workl[ritzi], &workl[bounds], &workl[iq], &ldq, &workl[
	    iw], &ipntr[1], &workd[1], info);

/*     %--------------------------------------------------%   
       | ido .ne. 99 implies use of reverse communication |   
       | to compute operations involving OP or shifts.    |   
       %--------------------------------------------------% */

    if (*ido == 3) {
	iparam[8] = np;
    }
    if (*ido != 99) {
	goto L9000;
    }

    iparam[3] = mxiter;
    iparam[5] = np;
    iparam[9] = nopx;
    iparam[10] = nbx;
    iparam[11] = nrorth;

/*     %------------------------------------%   
       | Exit if there was an informational |   
       | error within dnaup2.               |   
       %------------------------------------% */

    if (*info < 0) {
	goto L9000;
    }
    if (*info == 2) {
	*info = 3;
    }

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &mxiter, &ndigit, "_naupd: Number of update i"
		"terations taken", (ftnlen)41);
	igraphivout_(&logfil, &c__1, &np, &ndigit, "_naupd: Number of wanted \"con"
		"verged\" Ritz values", (ftnlen)48);
	igraphdvout_(&logfil, &np, &workl[ritzr], &ndigit, "_naupd: Real part of t"
		"he final Ritz values", (ftnlen)42);
	igraphdvout_(&logfil, &np, &workl[ritzi], &ndigit, "_naupd: Imaginary part"
		" of the final Ritz values", (ftnlen)47);
	igraphdvout_(&logfil, &np, &workl[bounds], &ndigit, "_naupd: Associated Ri"
		"tz estimates", (ftnlen)33);
    }

    igraphsecond_(&t1);
    tnaupd = t1 - t0;

    if (msglvl > 0) {

/*        %--------------------------------------------------------%   
          | Version Number & Version Date are defined in version.h |   
          %--------------------------------------------------------% */

	s_wsfe(&io___30);
	e_wsfe();
	s_wsfe(&io___31);
	do_fio(&c__1, (char *)&mxiter, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nopx, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nbx, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nrorth, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nitref, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nrstrt, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&tmvopx, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tmvbx, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tnaupd, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tnaup2, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tnaitr, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&titref, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tgetv0, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tneigh, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tngets, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tnapps, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tnconv, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&trvec, (ftnlen)sizeof(real));
	e_wsfe();
    }

L9000:

    return 0;

/*     %---------------%   
       | End of dnaupd |   
       %---------------% */

} /* igraphdnaupd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnconv.c0000644000175100001710000001220400000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b3 = .66666666666666663;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dnconv   

   \Description:   
    Convergence testing for the nonsymmetric Arnoldi eigenvalue routine.   

   \Usage:   
    call dnconv   
       ( N, RITZR, RITZI, BOUNDS, TOL, NCONV )   

   \Arguments   
    N       Integer.  (INPUT)   
            Number of Ritz values to check for convergence.   

    RITZR,  Double precision arrays of length N.  (INPUT)   
    RITZI   Real and imaginary parts of the Ritz values to be checked   
            for convergence.   
    BOUNDS  Double precision array of length N.  (INPUT)   
            Ritz estimates for the Ritz values in RITZR and RITZI.   

    TOL     Double precision scalar.  (INPUT)   
            Desired backward error for a Ritz value to be considered   
            "converged".   

    NCONV   Integer scalar.  (OUTPUT)   
            Number of "converged" Ritz values.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       second  ARPACK utility routine for timing.   
       dlamch  LAPACK routine that determines machine constants.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: nconv.F   SID: 2.3   DATE OF SID: 4/20/96   RELEASE: 2   

   \Remarks   
       1. xxxx   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdnconv_(integer *n, doublereal *ritzr, doublereal *ritzi,
	 doublereal *bounds, doublereal *tol, integer *nconv)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double pow_dd(doublereal *, doublereal *);

    /* Local variables */
    integer i__;
    IGRAPH_F77_SAVE real t0, t1;
    doublereal eps23, temp;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
    extern /* Subroutine */ int igraphsecond_(real *);
    real tnconv = 0.;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   

       %---------------%   
       | Local Scalars |   
       %---------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %-------------------------------------------------------------%   
       | Convergence test: unlike in the symmetric code, I am not    |   
       | using things like refined error bounds and gap condition    |   
       | because I don't know the exact equivalent concept.          |   
       |                                                             |   
       | Instead the i-th Ritz value is considered "converged" when: |   
       |                                                             |   
       |     bounds(i) .le. ( TOL * | ritz | )                       |   
       |                                                             |   
       | for some appropriate choice of norm.                        |   
       %-------------------------------------------------------------%   

       Parameter adjustments */
    --bounds;
    --ritzi;
    --ritzr;

    /* Function Body */
    igraphsecond_(&t0);

/*     %---------------------------------%   
       | Get machine dependent constant. |   
       %---------------------------------% */

    eps23 = igraphdlamch_("Epsilon-Machine");
    eps23 = pow_dd(&eps23, &c_b3);

    *nconv = 0;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
	d__1 = eps23, d__2 = igraphdlapy2_(&ritzr[i__], &ritzi[i__]);
	temp = max(d__1,d__2);
	if (bounds[i__] <= *tol * temp) {
	    ++(*nconv);
	}
/* L20: */
    }

    igraphsecond_(&t1);
    tnconv += t1 - t0;

    return 0;

/*     %---------------%   
       | End of dnconv |   
       %---------------% */

} /* igraphdnconv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dneigh.c0000644000175100001710000003110500000000000024004 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static logical c_true = TRUE_;
static integer c__1 = 1;
static doublereal c_b18 = 1.;
static doublereal c_b20 = 0.;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dneigh   

   \Description:   
    Compute the eigenvalues of the current upper Hessenberg matrix   
    and the corresponding Ritz estimates given the current residual norm.   

   \Usage:   
    call dneigh   
       ( RNORM, N, H, LDH, RITZR, RITZI, BOUNDS, Q, LDQ, WORKL, IERR )   

   \Arguments   
    RNORM   Double precision scalar.  (INPUT)   
            Residual norm corresponding to the current upper Hessenberg   
            matrix H.   

    N       Integer.  (INPUT)   
            Size of the matrix H.   

    H       Double precision N by N array.  (INPUT)   
            H contains the current upper Hessenberg matrix.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    RITZR,  Double precision arrays of length N.  (OUTPUT)   
    RITZI   On output, RITZR(1:N) (resp. RITZI(1:N)) contains the real   
            (respectively imaginary) parts of the eigenvalues of H.   

    BOUNDS  Double precision array of length N.  (OUTPUT)   
            On output, BOUNDS contains the Ritz estimates associated with   
            the eigenvalues RITZR and RITZI.  This is equal to RNORM   
            times the last components of the eigenvectors corresponding   
            to the eigenvalues in RITZR and RITZI.   

    Q       Double precision N by N array.  (WORKSPACE)   
            Workspace needed to store the eigenvectors of H.   

    LDQ     Integer.  (INPUT)   
            Leading dimension of Q exactly as declared in the calling   
            program.   

    WORKL   Double precision work array of length N**2 + 3*N.  (WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.  This is needed to keep the full Schur form   
            of H and also in the calculation of the eigenvectors of H.   

    IERR    Integer.  (OUTPUT)   
            Error exit flag from dlaqrb or dtrevc.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dlaqrb  ARPACK routine to compute the real Schur form of an   
               upper Hessenberg matrix and last row of the Schur vectors.   
       second  ARPACK utility routine for timing.   
       dmout   ARPACK utility routine that prints matrices   
       dvout   ARPACK utility routine that prints vectors.   
       dlacpy  LAPACK matrix copy routine.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   
       dtrevc  LAPACK routine to compute the eigenvectors of a matrix   
               in upper quasi-triangular form   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   
       dscal   Level 1 BLAS that scales a vector.   


   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: neigh.F   SID: 2.3   DATE OF SID: 4/20/96   RELEASE: 2   

   \Remarks   
       None   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdneigh_(doublereal *rnorm, integer *n, doublereal *h__, 
	integer *ldh, doublereal *ritzr, doublereal *ritzi, doublereal *
	bounds, doublereal *q, integer *ldq, doublereal *workl, integer *ierr)
{
    /* System generated locals */
    integer h_dim1, h_offset, q_dim1, q_offset, i__1;
    doublereal d__1, d__2;

    /* Local variables */
    integer i__;
    IGRAPH_F77_SAVE real t0, t1;
    doublereal vl[1], temp;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    integer iconj;
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *), igraphdmout_(integer *, 
	    integer *, integer *, doublereal *, integer *, integer *, char *, 
	    ftnlen), igraphdvout_(integer *, integer *, doublereal *, integer *, 
	    char *, ftnlen);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlaqrb_(logical *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *);
    integer mneigh = 0;
    extern /* Subroutine */ int igraphsecond_(real *), igraphdlacpy_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *);
    integer logfil, ndigit;
    logical select[1];
    real tneigh = 0.;
    extern /* Subroutine */ int igraphdtrevc_(char *, char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, integer *);
    integer msglvl;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %------------------------%   
       | Local Scalars & Arrays |   
       %------------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   


       %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------%   

       Parameter adjustments */
    --workl;
    --bounds;
    --ritzi;
    --ritzr;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;

    /* Function Body */
    igraphsecond_(&t0);
    msglvl = mneigh;

    if (msglvl > 2) {
	igraphdmout_(&logfil, n, n, &h__[h_offset], ldh, &ndigit, "_neigh: Enterin"
		"g upper Hessenberg matrix H ", (ftnlen)43);
    }

/*     %-----------------------------------------------------------%   
       | 1. Compute the eigenvalues, the last components of the    |   
       |    corresponding Schur vectors and the full Schur form T  |   
       |    of the current upper Hessenberg matrix H.              |   
       | dlaqrb returns the full Schur form of H in WORKL(1:N**2)  |   
       | and the last components of the Schur vectors in BOUNDS.   |   
       %-----------------------------------------------------------% */

    igraphdlacpy_("All", n, n, &h__[h_offset], ldh, &workl[1], n);
    igraphdlaqrb_(&c_true, n, &c__1, n, &workl[1], n, &ritzr[1], &ritzi[1], &bounds[
	    1], ierr);
    if (*ierr != 0) {
	goto L9000;
    }

    if (msglvl > 1) {
	igraphdvout_(&logfil, n, &bounds[1], &ndigit, "_neigh: last row of the Sch"
		"ur matrix for H", (ftnlen)42);
    }

/*     %-----------------------------------------------------------%   
       | 2. Compute the eigenvectors of the full Schur form T and  |   
       |    apply the last components of the Schur vectors to get  |   
       |    the last components of the corresponding eigenvectors. |   
       | Remember that if the i-th and (i+1)-st eigenvalues are    |   
       | complex conjugate pairs, then the real & imaginary part   |   
       | of the eigenvector components are split across adjacent   |   
       | columns of Q.                                             |   
       %-----------------------------------------------------------% */

    igraphdtrevc_("R", "A", select, n, &workl[1], n, vl, n, &q[q_offset], ldq, n, n,
	     &workl[*n * *n + 1], ierr);

    if (*ierr != 0) {
	goto L9000;
    }

/*     %------------------------------------------------%   
       | Scale the returning eigenvectors so that their |   
       | euclidean norms are all one. LAPACK subroutine |   
       | dtrevc returns each eigenvector normalized so  |   
       | that the element of largest magnitude has      |   
       | magnitude 1; here the magnitude of a complex   |   
       | number (x,y) is taken to be |x| + |y|.         |   
       %------------------------------------------------% */

    iconj = 0;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if ((d__1 = ritzi[i__], abs(d__1)) <= 0.) {

/*           %----------------------%   
             | Real eigenvalue case |   
             %----------------------% */

	    temp = igraphdnrm2_(n, &q[i__ * q_dim1 + 1], &c__1);
	    d__1 = 1. / temp;
	    igraphdscal_(n, &d__1, &q[i__ * q_dim1 + 1], &c__1);
	} else {

/*           %-------------------------------------------%   
             | Complex conjugate pair case. Note that    |   
             | since the real and imaginary part of      |   
             | the eigenvector are stored in consecutive |   
             | columns, we further normalize by the      |   
             | square root of two.                       |   
             %-------------------------------------------% */

	    if (iconj == 0) {
		d__1 = igraphdnrm2_(n, &q[i__ * q_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &q[(i__ + 1) * q_dim1 + 1], &c__1);
		temp = igraphdlapy2_(&d__1, &d__2);
		d__1 = 1. / temp;
		igraphdscal_(n, &d__1, &q[i__ * q_dim1 + 1], &c__1);
		d__1 = 1. / temp;
		igraphdscal_(n, &d__1, &q[(i__ + 1) * q_dim1 + 1], &c__1);
		iconj = 1;
	    } else {
		iconj = 0;
	    }
	}
/* L10: */
    }

    igraphdgemv_("T", n, n, &c_b18, &q[q_offset], ldq, &bounds[1], &c__1, &c_b20, &
	    workl[1], &c__1);

    if (msglvl > 1) {
	igraphdvout_(&logfil, n, &workl[1], &ndigit, "_neigh: Last row of the eige"
		"nvector matrix for H", (ftnlen)48);
    }

/*     %----------------------------%   
       | Compute the Ritz estimates |   
       %----------------------------% */

    iconj = 0;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if ((d__1 = ritzi[i__], abs(d__1)) <= 0.) {

/*           %----------------------%   
             | Real eigenvalue case |   
             %----------------------% */

	    bounds[i__] = *rnorm * (d__1 = workl[i__], abs(d__1));
	} else {

/*           %-------------------------------------------%   
             | Complex conjugate pair case. Note that    |   
             | since the real and imaginary part of      |   
             | the eigenvector are stored in consecutive |   
             | columns, we need to take the magnitude    |   
             | of the last components of the two vectors |   
             %-------------------------------------------% */

	    if (iconj == 0) {
		bounds[i__] = *rnorm * igraphdlapy2_(&workl[i__], &workl[i__ + 1]);
		bounds[i__ + 1] = bounds[i__];
		iconj = 1;
	    } else {
		iconj = 0;
	    }
	}
/* L20: */
    }

    if (msglvl > 2) {
	igraphdvout_(&logfil, n, &ritzr[1], &ndigit, "_neigh: Real part of the eig"
		"envalues of H", (ftnlen)41);
	igraphdvout_(&logfil, n, &ritzi[1], &ndigit, "_neigh: Imaginary part of th"
		"e eigenvalues of H", (ftnlen)46);
	igraphdvout_(&logfil, n, &bounds[1], &ndigit, "_neigh: Ritz estimates for "
		"the eigenvalues of H", (ftnlen)47);
    }

    igraphsecond_(&t1);
    tneigh += t1 - t0;

L9000:
    return 0;

/*     %---------------%   
       | End of dneigh |   
       %---------------% */

} /* igraphdneigh_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dneupd.c0000644000175100001710000013641200000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b3 = .66666666666666663;
static integer c__1 = 1;
static doublereal c_b44 = 0.;
static doublereal c_b45 = 1.;
static logical c_true = TRUE_;
static doublereal c_b71 = -1.;

/* \BeginDoc   

   \Name: dneupd   

   \Description:   

    This subroutine returns the converged approximations to eigenvalues   
    of A*z = lambda*B*z and (optionally):   

        (1) The corresponding approximate eigenvectors;   

        (2) An orthonormal basis for the associated approximate   
            invariant subspace;   

        (3) Both.   

    There is negligible additional cost to obtain eigenvectors.  An orthonormal   
    basis is always computed.  There is an additional storage cost of n*nev   
    if both are requested (in this case a separate array Z must be supplied).   

    The approximate eigenvalues and eigenvectors of  A*z = lambda*B*z   
    are derived from approximate eigenvalues and eigenvectors of   
    of the linear operator OP prescribed by the MODE selection in the   
    call to DNAUPD.  DNAUPD must be called before this routine is called.   
    These approximate eigenvalues and vectors are commonly called Ritz   
    values and Ritz vectors respectively.  They are referred to as such   
    in the comments that follow.  The computed orthonormal basis for the   
    invariant subspace corresponding to these Ritz values is referred to as a   
    Schur basis.   

    See documentation in the header of the subroutine DNAUPD for   
    definition of OP as well as other terms and the relation of computed   
    Ritz values and Ritz vectors of OP with respect to the given problem   
    A*z = lambda*B*z.  For a brief description, see definitions of   
    IPARAM(7), MODE and WHICH in the documentation of DNAUPD.   

   \Usage:   
    call dneupd   
       ( RVEC, HOWMNY, SELECT, DR, DI, Z, LDZ, SIGMAR, SIGMAI, WORKEV, BMAT,   
         N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM, IPNTR, WORKD, WORKL,   
         LWORKL, INFO )   

   \Arguments:   
    RVEC    LOGICAL  (INPUT)   
            Specifies whether a basis for the invariant subspace corresponding   
            to the converged Ritz value approximations for the eigenproblem   
            A*z = lambda*B*z is computed.   

               RVEC = .FALSE.     Compute Ritz values only.   

               RVEC = .TRUE.      Compute the Ritz vectors or Schur vectors.   
                                  See Remarks below.   

    HOWMNY  Character*1  (INPUT)   
            Specifies the form of the basis for the invariant subspace   
            corresponding to the converged Ritz values that is to be computed.   

            = 'A': Compute NEV Ritz vectors;   
            = 'P': Compute NEV Schur vectors;   
            = 'S': compute some of the Ritz vectors, specified   
                   by the logical array SELECT.   

    SELECT  Logical array of dimension NCV.  (INPUT)   
            If HOWMNY = 'S', SELECT specifies the Ritz vectors to be   
            computed. To select the Ritz vector corresponding to a   
            Ritz value (DR(j), DI(j)), SELECT(j) must be set to .TRUE..   
            If HOWMNY = 'A' or 'P', SELECT is used as internal workspace.   

    DR      Double precision array of dimension NEV+1.  (OUTPUT)   
            If IPARAM(7) = 1,2 or 3 and SIGMAI=0.0  then on exit: DR contains   
            the real part of the Ritz  approximations to the eigenvalues of   
            A*z = lambda*B*z.   
            If IPARAM(7) = 3, 4 and SIGMAI is not equal to zero, then on exit:   
            DR contains the real part of the Ritz values of OP computed by   
            DNAUPD. A further computation must be performed by the user   
            to transform the Ritz values computed for OP by DNAUPD to those   
            of the original system A*z = lambda*B*z. See remark 3 below.   

    DI      Double precision array of dimension NEV+1.  (OUTPUT)   
            On exit, DI contains the imaginary part of the Ritz value   
            approximations to the eigenvalues of A*z = lambda*B*z associated   
            with DR.   

            NOTE: When Ritz values are complex, they will come in complex   
                  conjugate pairs.  If eigenvectors are requested, the   
                  corresponding Ritz vectors will also come in conjugate   
                  pairs and the real and imaginary parts of these are   
                  represented in two consecutive columns of the array Z   
                  (see below).   

    Z       Double precision N by NEV+1 array if RVEC = .TRUE. and HOWMNY = 'A'. (OUTPUT)   
            On exit, if RVEC = .TRUE. and HOWMNY = 'A', then the columns of   
            Z represent approximate eigenvectors (Ritz vectors) corresponding   
            to the NCONV=IPARAM(5) Ritz values for eigensystem   
            A*z = lambda*B*z.   

            The complex Ritz vector associated with the Ritz value   
            with positive imaginary part is stored in two consecutive   
            columns.  The first column holds the real part of the Ritz   
            vector and the second column holds the imaginary part.  The   
            Ritz vector associated with the Ritz value with negative   
            imaginary part is simply the complex conjugate of the Ritz vector   
            associated with the positive imaginary part.   

            If  RVEC = .FALSE. or HOWMNY = 'P', then Z is not referenced.   

            NOTE: If if RVEC = .TRUE. and a Schur basis is not required,   
            the array Z may be set equal to first NEV+1 columns of the Arnoldi   
            basis array V computed by DNAUPD.  In this case the Arnoldi basis   
            will be destroyed and overwritten with the eigenvector basis.   

    LDZ     Integer.  (INPUT)   
            The leading dimension of the array Z.  If Ritz vectors are   
            desired, then  LDZ >= max( 1, N ).  In any case,  LDZ >= 1.   

    SIGMAR  Double precision  (INPUT)   
            If IPARAM(7) = 3 or 4, represents the real part of the shift.   
            Not referenced if IPARAM(7) = 1 or 2.   

    SIGMAI  Double precision  (INPUT)   
            If IPARAM(7) = 3 or 4, represents the imaginary part of the shift.   
            Not referenced if IPARAM(7) = 1 or 2. See remark 3 below.   

    WORKEV  Double precision work array of dimension 3*NCV.  (WORKSPACE)   

    **** The remaining arguments MUST be the same as for the   ****   
    **** call to DNAUPD that was just completed.               ****   

    NOTE: The remaining arguments   

             BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM, IPNTR,   
             WORKD, WORKL, LWORKL, INFO   

           must be passed directly to DNEUPD following the last call   
           to DNAUPD.  These arguments MUST NOT BE MODIFIED between   
           the the last call to DNAUPD and the call to DNEUPD.   

    Three of these parameters (V, WORKL, INFO) are also output parameters:   

    V       Double precision N by NCV array.  (INPUT/OUTPUT)   

            Upon INPUT: the NCV columns of V contain the Arnoldi basis   
                        vectors for OP as constructed by DNAUPD .   

            Upon OUTPUT: If RVEC = .TRUE. the first NCONV=IPARAM(5) columns   
                         contain approximate Schur vectors that span the   
                         desired invariant subspace.  See Remark 2 below.   

            NOTE: If the array Z has been set equal to first NEV+1 columns   
            of the array V and RVEC=.TRUE. and HOWMNY= 'A', then the   
            Arnoldi basis held by V has been overwritten by the desired   
            Ritz vectors.  If a separate array Z has been passed then   
            the first NCONV=IPARAM(5) columns of V will contain approximate   
            Schur vectors that span the desired invariant subspace.   

    WORKL   Double precision work array of length LWORKL.  (OUTPUT/WORKSPACE)   
            WORKL(1:ncv*ncv+3*ncv) contains information obtained in   
            dnaupd.  They are not changed by dneupd.   
            WORKL(ncv*ncv+3*ncv+1:3*ncv*ncv+6*ncv) holds the   
            real and imaginary part of the untransformed Ritz values,   
            the upper quasi-triangular matrix for H, and the   
            associated matrix representation of the invariant subspace for H.   

            Note: IPNTR(9:13) contains the pointer into WORKL for addresses   
            of the above information computed by dneupd.   
            -------------------------------------------------------------   
            IPNTR(9):  pointer to the real part of the NCV RITZ values of the   
                       original system.   
            IPNTR(10): pointer to the imaginary part of the NCV RITZ values of   
                       the original system.   
            IPNTR(11): pointer to the NCV corresponding error bounds.   
            IPNTR(12): pointer to the NCV by NCV upper quasi-triangular   
                       Schur matrix for H.   
            IPNTR(13): pointer to the NCV by NCV matrix of eigenvectors   
                       of the upper Hessenberg matrix H. Only referenced by   
                       dneupd if RVEC = .TRUE. See Remark 2 below.   
            -------------------------------------------------------------   

    INFO    Integer.  (OUTPUT)   
            Error flag on output.   

            =  0: Normal exit.   

            =  1: The Schur form computed by LAPACK routine dlahqr   
                  could not be reordered by LAPACK routine dtrsen.   
                  Re-enter subroutine dneupd with IPARAM(5)=NCV and   
                  increase the size of the arrays DR and DI to have   
                  dimension at least dimension NCV and allocate at least NCV   
                  columns for Z. NOTE: Not necessary if Z and V share   
                  the same space. Please notify the authors if this error   
                  occurs.   

            = -1: N must be positive.   
            = -2: NEV must be positive.   
            = -3: NCV-NEV >= 2 and less than or equal to N.   
            = -5: WHICH must be one of 'LM', 'SM', 'LR', 'SR', 'LI', 'SI'   
            = -6: BMAT must be one of 'I' or 'G'.   
            = -7: Length of private work WORKL array is not sufficient.   
            = -8: Error return from calculation of a real Schur form.   
                  Informational error from LAPACK routine dlahqr.   
            = -9: Error return from calculation of eigenvectors.   
                  Informational error from LAPACK routine dtrevc.   
            = -10: IPARAM(7) must be 1,2,3,4.   
            = -11: IPARAM(7) = 1 and BMAT = 'G' are incompatible.   
            = -12: HOWMNY = 'S' not yet implemented   
            = -13: HOWMNY must be one of 'A' or 'P' if RVEC = .true.   
            = -14: DNAUPD did not find any eigenvalues to sufficient   
                   accuracy.   

   \BeginLib   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   
    3. B.N. Parlett & Y. Saad, "Complex Shift and Invert Strategies for   
       Real Matrices", Linear Algebra and its Applications, vol 88/89,   
       pp 575-595, (1987).   

   \Routines called:   
       ivout   ARPACK utility routine that prints integers.   
       dmout   ARPACK utility routine that prints matrices   
       dvout   ARPACK utility routine that prints vectors.   
       dgeqr2  LAPACK routine that computes the QR factorization of   
               a matrix.   
       dlacpy  LAPACK matrix copy routine.   
       dlahqr  LAPACK routine to compute the real Schur form of an   
               upper Hessenberg matrix.   
       dlamch  LAPACK routine that determines machine constants.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   
       dlaset  LAPACK matrix initialization routine.   
       dorm2r  LAPACK routine that applies an orthogonal matrix in   
               factored form.   
       dtrevc  LAPACK routine to compute the eigenvectors of a matrix   
               in upper quasi-triangular form.   
       dtrsen  LAPACK routine that re-orders the Schur form.   
       dtrmm   Level 3 BLAS matrix times an upper triangular matrix.   
       dger    Level 2 BLAS rank one update to a matrix.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   
       dscal   Level 1 BLAS that scales a vector.   

   \Remarks   

    1. Currently only HOWMNY = 'A' and 'P' are implemented.   

       Let X' denote the transpose of X.   

    2. Schur vectors are an orthogonal representation for the basis of   
       Ritz vectors. Thus, their numerical properties are often superior.   
       If RVEC = .TRUE. then the relationship   
               A * V(:,1:IPARAM(5)) = V(:,1:IPARAM(5)) * T, and   
       V(:,1:IPARAM(5))' * V(:,1:IPARAM(5)) = I are approximately satisfied.   
       Here T is the leading submatrix of order IPARAM(5) of the real   
       upper quasi-triangular matrix stored workl(ipntr(12)). That is,   
       T is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks;   
       each 2-by-2 diagonal block has its diagonal elements equal and its   
       off-diagonal elements of opposite sign.  Corresponding to each 2-by-2   
       diagonal block is a complex conjugate pair of Ritz values. The real   
       Ritz values are stored on the diagonal of T.   

    3. If IPARAM(7) = 3 or 4 and SIGMAI is not equal zero, then the user must   
       form the IPARAM(5) Rayleigh quotients in order to transform the Ritz   
       values computed by DNAUPD for OP to those of A*z = lambda*B*z.   
       Set RVEC = .true. and HOWMNY = 'A', and   
       compute   
             Z(:,I)' * A * Z(:,I) if DI(I) = 0.   
       If DI(I) is not equal to zero and DI(I+1) = - D(I),   
       then the desired real and imaginary parts of the Ritz value are   
             Z(:,I)' * A * Z(:,I) +  Z(:,I+1)' * A * Z(:,I+1),   
             Z(:,I)' * A * Z(:,I+1) -  Z(:,I+1)' * A * Z(:,I), respectively.   
       Another possibility is to set RVEC = .true. and HOWMNY = 'P' and   
       compute V(:,1:IPARAM(5))' * A * V(:,1:IPARAM(5)) and then an upper   
       quasi-triangular matrix of order IPARAM(5) is computed. See remark   
       2 above.   

   \Authors   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Chao Yang                    Houston, Texas   
       Dept. of Computational &   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: neupd.F   SID: 2.5   DATE OF SID: 7/31/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   
   Subroutine */ int igraphdneupd_(logical *rvec, char *howmny, logical *select, 
	doublereal *dr, doublereal *di, doublereal *z__, integer *ldz, 
	doublereal *sigmar, doublereal *sigmai, doublereal *workev, char *
	bmat, integer *n, char *which, integer *nev, doublereal *tol, 
	doublereal *resid, integer *ncv, doublereal *v, integer *ldv, integer 
	*iparam, integer *ipntr, doublereal *workd, doublereal *workl, 
	integer *lworkl, integer *info)
{
    /* System generated locals */
    integer v_dim1, v_offset, z_dim1, z_offset, i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    double pow_dd(doublereal *, doublereal *);
    integer s_cmp(char *, char *, ftnlen, ftnlen);
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    integer j, k, ih;
    doublereal vl[1]	/* was [1][1] */;
    integer ibd, ldh, ldq, iri;
    doublereal sep;
    integer irr, wri, wrr;
    extern /* Subroutine */ int igraphdger_(integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    integer mode;
    doublereal eps23;
    integer ierr;
    doublereal temp;
    integer iwev;
    char type__[6];
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    doublereal temp1;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    integer ihbds, iconj;
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    doublereal conds;
    logical reord;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    integer nconv;
    extern /* Subroutine */ int igraphdtrmm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *);
    doublereal thres;
    extern /* Subroutine */ int igraphdmout_(integer *, integer *, integer *, 
	    doublereal *, integer *, integer *, char *, ftnlen);
    integer iwork[1];
    doublereal rnorm;
    integer ritzi;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen);
    integer ritzr;
    extern /* Subroutine */ int igraphdgeqr2_(integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdorm2r_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *);
    extern doublereal igraphdlamch_(char *);
    integer iheigi, iheigr;
    extern /* Subroutine */ int igraphdlahqr_(logical *, logical *, integer *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *), igraphdlacpy_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdlaset_(char *, 
	    integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    integer *);
    integer logfil, ndigit;
    extern /* Subroutine */ int igraphdtrevc_(char *, char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, integer *, integer *, doublereal *, integer *);
    integer mneupd = 0, bounds;
    extern /* Subroutine */ int igraphdtrsen_(char *, char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
	     integer *, integer *, integer *, integer *);
    integer msglvl, ktrord, invsub, iuptri, outncv;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %------------------------%   
       | Set default parameters |   
       %------------------------%   

       Parameter adjustments */
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --workd;
    --resid;
    --di;
    --dr;
    --workev;
    --select;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --iparam;
    --ipntr;
    --workl;

    /* Function Body */
    msglvl = mneupd;
    mode = iparam[7];
    nconv = iparam[5];
    *info = 0;

/*     %---------------------------------%   
       | Get machine dependent constant. |   
       %---------------------------------% */

    eps23 = igraphdlamch_("Epsilon-Machine");
    eps23 = pow_dd(&eps23, &c_b3);

/*     %--------------%   
       | Quick return |   
       %--------------% */

    ierr = 0;

    if (nconv <= 0) {
	ierr = -14;
    } else if (*n <= 0) {
	ierr = -1;
    } else if (*nev <= 0) {
	ierr = -2;
    } else if (*ncv <= *nev + 1 || *ncv > *n) {
	ierr = -3;
    } else if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, 
	    "SM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "LR", (ftnlen)2, 
	    (ftnlen)2) != 0 && s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) != 0 
	    && s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, 
	    "SI", (ftnlen)2, (ftnlen)2) != 0) {
	ierr = -5;
    } else if (*(unsigned char *)bmat != 'I' && *(unsigned char *)bmat != 'G')
	     {
	ierr = -6;
    } else /* if(complicated condition) */ {
/* Computing 2nd power */
	i__1 = *ncv;
	if (*lworkl < i__1 * i__1 * 3 + *ncv * 6) {
	    ierr = -7;
	} else if (*(unsigned char *)howmny != 'A' && *(unsigned char *)
		howmny != 'P' && *(unsigned char *)howmny != 'S' && *rvec) {
	    ierr = -13;
	} else if (*(unsigned char *)howmny == 'S') {
	    ierr = -12;
	}
    }

    if (mode == 1 || mode == 2) {
	s_copy(type__, "REGULR", (ftnlen)6, (ftnlen)6);
    } else if (mode == 3 && *sigmai == 0.) {
	s_copy(type__, "SHIFTI", (ftnlen)6, (ftnlen)6);
    } else if (mode == 3) {
	s_copy(type__, "REALPT", (ftnlen)6, (ftnlen)6);
    } else if (mode == 4) {
	s_copy(type__, "IMAGPT", (ftnlen)6, (ftnlen)6);
    } else {
	ierr = -10;
    }
    if (mode == 1 && *(unsigned char *)bmat == 'G') {
	ierr = -11;
    }

/*     %------------%   
       | Error Exit |   
       %------------% */

    if (ierr != 0) {
	*info = ierr;
	goto L9000;
    }

/*     %--------------------------------------------------------%   
       | Pointer into WORKL for address of H, RITZ, BOUNDS, Q   |   
       | etc... and the remaining workspace.                    |   
       | Also update pointer to be used on output.              |   
       | Memory is laid out as follows:                         |   
       | workl(1:ncv*ncv) := generated Hessenberg matrix        |   
       | workl(ncv*ncv+1:ncv*ncv+2*ncv) := real and imaginary   |   
       |                                   parts of ritz values |   
       | workl(ncv*ncv+2*ncv+1:ncv*ncv+3*ncv) := error bounds   |   
       %--------------------------------------------------------%   

       %-----------------------------------------------------------%   
       | The following is used and set by DNEUPD.                  |   
       | workl(ncv*ncv+3*ncv+1:ncv*ncv+4*ncv) := The untransformed |   
       |                             real part of the Ritz values. |   
       | workl(ncv*ncv+4*ncv+1:ncv*ncv+5*ncv) := The untransformed |   
       |                        imaginary part of the Ritz values. |   
       | workl(ncv*ncv+5*ncv+1:ncv*ncv+6*ncv) := The untransformed |   
       |                           error bounds of the Ritz values |   
       | workl(ncv*ncv+6*ncv+1:2*ncv*ncv+6*ncv) := Holds the upper |   
       |                             quasi-triangular matrix for H |   
       | workl(2*ncv*ncv+6*ncv+1: 3*ncv*ncv+6*ncv) := Holds the    |   
       |       associated matrix representation of the invariant   |   
       |       subspace for H.                                     |   
       | GRAND total of NCV * ( 3 * NCV + 6 ) locations.           |   
       %-----------------------------------------------------------% */

    ih = ipntr[5];
    ritzr = ipntr[6];
    ritzi = ipntr[7];
    bounds = ipntr[8];
    ldh = *ncv;
    ldq = *ncv;
    iheigr = bounds + ldh;
    iheigi = iheigr + ldh;
    ihbds = iheigi + ldh;
    iuptri = ihbds + ldh;
    invsub = iuptri + ldh * *ncv;
    ipntr[9] = iheigr;
    ipntr[10] = iheigi;
    ipntr[11] = ihbds;
    ipntr[12] = iuptri;
    ipntr[13] = invsub;
    wrr = 1;
    wri = *ncv + 1;
    iwev = wri + *ncv;

/*     %-----------------------------------------%   
       | irr points to the REAL part of the Ritz |   
       |     values computed by _neigh before    |   
       |     exiting _naup2.                     |   
       | iri points to the IMAGINARY part of the |   
       |     Ritz values computed by _neigh      |   
       |     before exiting _naup2.              |   
       | ibd points to the Ritz estimates        |   
       |     computed by _neigh before exiting   |   
       |     _naup2.                             |   
       %-----------------------------------------% */

    irr = ipntr[14] + *ncv * *ncv;
    iri = irr + *ncv;
    ibd = iri + *ncv;

/*     %------------------------------------%   
       | RNORM is B-norm of the RESID(1:N). |   
       %------------------------------------% */

    rnorm = workl[ih + 2];
    workl[ih + 2] = 0.;

    if (*rvec) {

/*        %-------------------------------------------%   
          | Get converged Ritz value on the boundary. |   
          | Note: converged Ritz values have been     |   
          | placed in the first NCONV locations in    |   
          | workl(ritzr) and workl(ritzi).  They have |   
          | been sorted (in _naup2) according to the  |   
          | WHICH selection criterion.                |   
          %-------------------------------------------% */

	if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(which, 
		"SM", (ftnlen)2, (ftnlen)2) == 0) {
	    thres = igraphdlapy2_(&workl[ritzr], &workl[ritzi]);
	} else if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		which, "SR", (ftnlen)2, (ftnlen)2) == 0) {
	    thres = workl[ritzr];
	} else if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		which, "SI", (ftnlen)2, (ftnlen)2) == 0) {
	    thres = (d__1 = workl[ritzi], abs(d__1));
	}

	if (msglvl > 2) {
	    igraphdvout_(&logfil, &c__1, &thres, &ndigit, "_neupd: Threshold eigen"
		    "value used for re-ordering", (ftnlen)49);
	}

/*        %----------------------------------------------------------%   
          | Check to see if all converged Ritz values appear at the  |   
          | top of the upper quasi-triangular matrix computed by     |   
          | _neigh in _naup2.  This is done in the following way:    |   
          |                                                          |   
          | 1) For each Ritz value obtained from _neigh, compare it  |   
          |    with the threshold Ritz value computed above to       |   
          |    determine whether it is a wanted one.                 |   
          |                                                          |   
          | 2) If it is wanted, then check the corresponding Ritz    |   
          |    estimate to see if it has converged.  If it has, set  |   
          |    correponding entry in the logical array SELECT to     |   
          |    .TRUE..                                               |   
          |                                                          |   
          | If SELECT(j) = .TRUE. and j > NCONV, then there is a     |   
          | converged Ritz value that does not appear at the top of  |   
          | the upper quasi-triangular matrix computed by _neigh in  |   
          | _naup2.  Reordering is needed.                           |   
          %----------------------------------------------------------% */

	reord = FALSE_;
	ktrord = 0;
	i__1 = *ncv - 1;
	for (j = 0; j <= i__1; ++j) {
	    select[j + 1] = FALSE_;
	    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
		if (igraphdlapy2_(&workl[irr + j], &workl[iri + j]) >= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
		if (igraphdlapy2_(&workl[irr + j], &workl[iri + j]) <= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0) {
		if (workl[irr + j] >= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) == 0) {
		if (workl[irr + j] <= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0) {
		if ((d__1 = workl[iri + j], abs(d__1)) >= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) == 0) {
		if ((d__1 = workl[iri + j], abs(d__1)) <= thres) {
/* Computing MAX */
		    d__1 = eps23, d__2 = igraphdlapy2_(&workl[irr + j], &workl[iri 
			    + j]);
		    temp1 = max(d__1,d__2);
		    if (workl[ibd + j] <= *tol * temp1) {
			select[j + 1] = TRUE_;
		    }
		}
	    }
	    if (j + 1 > nconv) {
		reord = select[j + 1] || reord;
	    }
	    if (select[j + 1]) {
		++ktrord;
	    }
/* L10: */
	}

	if (msglvl > 2) {
	    igraphivout_(&logfil, &c__1, &ktrord, &ndigit, "_neupd: Number of spec"
		    "ified eigenvalues", (ftnlen)39);
	    igraphivout_(&logfil, &c__1, &nconv, &ndigit, "_neupd: Number of \"con"
		    "verged\" eigenvalues", (ftnlen)41);
	}

/*        %-----------------------------------------------------------%   
          | Call LAPACK routine dlahqr to compute the real Schur form |   
          | of the upper Hessenberg matrix returned by DNAUPD.        |   
          | Make a copy of the upper Hessenberg matrix.               |   
          | Initialize the Schur vector matrix Q to the identity.     |   
          %-----------------------------------------------------------% */

	i__1 = ldh * *ncv;
	igraphdcopy_(&i__1, &workl[ih], &c__1, &workl[iuptri], &c__1);
	igraphdlaset_("All", ncv, ncv, &c_b44, &c_b45, &workl[invsub], &ldq);
	igraphdlahqr_(&c_true, &c_true, ncv, &c__1, ncv, &workl[iuptri], &ldh, &
		workl[iheigr], &workl[iheigi], &c__1, ncv, &workl[invsub], &
		ldq, &ierr);
	igraphdcopy_(ncv, &workl[invsub + *ncv - 1], &ldq, &workl[ihbds], &c__1);

	if (ierr != 0) {
	    *info = -8;
	    goto L9000;
	}

	if (msglvl > 1) {
	    igraphdvout_(&logfil, ncv, &workl[iheigr], &ndigit, "_neupd: Real part"
		    " of the eigenvalues of H", (ftnlen)41);
	    igraphdvout_(&logfil, ncv, &workl[iheigi], &ndigit, "_neupd: Imaginary"
		    " part of the Eigenvalues of H", (ftnlen)46);
	    igraphdvout_(&logfil, ncv, &workl[ihbds], &ndigit, "_neupd: Last row o"
		    "f the Schur vector matrix", (ftnlen)43);
	    if (msglvl > 3) {
		igraphdmout_(&logfil, ncv, ncv, &workl[iuptri], &ldh, &ndigit, 
			"_neupd: The upper quasi-triangular matrix ", (ftnlen)
			42);
	    }
	}

	if (reord) {

/*           %-----------------------------------------------------%   
             | Reorder the computed upper quasi-triangular matrix. |   
             %-----------------------------------------------------% */

	    igraphdtrsen_("None", "V", &select[1], ncv, &workl[iuptri], &ldh, &
		    workl[invsub], &ldq, &workl[iheigr], &workl[iheigi], &
		    nconv, &conds, &sep, &workl[ihbds], ncv, iwork, &c__1, &
		    ierr);

	    if (ierr == 1) {
		*info = 1;
		goto L9000;
	    }

	    if (msglvl > 2) {
		igraphdvout_(&logfil, ncv, &workl[iheigr], &ndigit, "_neupd: Real "
			"part of the eigenvalues of H--reordered", (ftnlen)52);
		igraphdvout_(&logfil, ncv, &workl[iheigi], &ndigit, "_neupd: Imag "
			"part of the eigenvalues of H--reordered", (ftnlen)52);
		if (msglvl > 3) {
		    igraphdmout_(&logfil, ncv, ncv, &workl[iuptri], &ldq, &ndigit, 
			    "_neupd: Quasi-triangular matrix after re-orderi"
			    "ng", (ftnlen)49);
		}
	    }

	}

/*        %---------------------------------------%   
          | Copy the last row of the Schur vector |   
          | into workl(ihbds).  This will be used |   
          | to compute the Ritz estimates of      |   
          | converged Ritz values.                |   
          %---------------------------------------% */

	igraphdcopy_(ncv, &workl[invsub + *ncv - 1], &ldq, &workl[ihbds], &c__1);

/*        %----------------------------------------------------%   
          | Place the computed eigenvalues of H into DR and DI |   
          | if a spectral transformation was not used.         |   
          %----------------------------------------------------% */

	if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) == 0) {
	    igraphdcopy_(&nconv, &workl[iheigr], &c__1, &dr[1], &c__1);
	    igraphdcopy_(&nconv, &workl[iheigi], &c__1, &di[1], &c__1);
	}

/*        %----------------------------------------------------------%   
          | Compute the QR factorization of the matrix representing  |   
          | the wanted invariant subspace located in the first NCONV |   
          | columns of workl(invsub,ldq).                            |   
          %----------------------------------------------------------% */

	igraphdgeqr2_(ncv, &nconv, &workl[invsub], &ldq, &workev[1], &workev[*ncv + 
		1], &ierr);

/*        %---------------------------------------------------------%   
          | * Postmultiply V by Q using dorm2r.                     |   
          | * Copy the first NCONV columns of VQ into Z.            |   
          | * Postmultiply Z by R.                                  |   
          | The N by NCONV matrix Z is now a matrix representation  |   
          | of the approximate invariant subspace associated with   |   
          | the Ritz values in workl(iheigr) and workl(iheigi)      |   
          | The first NCONV columns of V are now approximate Schur  |   
          | vectors associated with the real upper quasi-triangular |   
          | matrix of order NCONV in workl(iuptri)                  |   
          %---------------------------------------------------------% */

	igraphdorm2r_("Right", "Notranspose", n, ncv, &nconv, &workl[invsub], &ldq, 
		&workev[1], &v[v_offset], ldv, &workd[*n + 1], &ierr);
	igraphdlacpy_("All", n, &nconv, &v[v_offset], ldv, &z__[z_offset], ldz);

	i__1 = nconv;
	for (j = 1; j <= i__1; ++j) {

/*           %---------------------------------------------------%   
             | Perform both a column and row scaling if the      |   
             | diagonal element of workl(invsub,ldq) is negative |   
             | I'm lazy and don't take advantage of the upper    |   
             | quasi-triangular form of workl(iuptri,ldq)        |   
             | Note that since Q is orthogonal, R is a diagonal  |   
             | matrix consisting of plus or minus ones           |   
             %---------------------------------------------------% */

	    if (workl[invsub + (j - 1) * ldq + j - 1] < 0.) {
		igraphdscal_(&nconv, &c_b71, &workl[iuptri + j - 1], &ldq);
		igraphdscal_(&nconv, &c_b71, &workl[iuptri + (j - 1) * ldq], &c__1);
	    }

/* L20: */
	}

	if (*(unsigned char *)howmny == 'A') {

/*           %--------------------------------------------%   
             | Compute the NCONV wanted eigenvectors of T |   
             | located in workl(iuptri,ldq).              |   
             %--------------------------------------------% */

	    i__1 = *ncv;
	    for (j = 1; j <= i__1; ++j) {
		if (j <= nconv) {
		    select[j] = TRUE_;
		} else {
		    select[j] = FALSE_;
		}
/* L30: */
	    }

	    igraphdtrevc_("Right", "Select", &select[1], ncv, &workl[iuptri], &ldq, 
		    vl, &c__1, &workl[invsub], &ldq, ncv, &outncv, &workev[1],
		     &ierr);

	    if (ierr != 0) {
		*info = -9;
		goto L9000;
	    }

/*           %------------------------------------------------%   
             | Scale the returning eigenvectors so that their |   
             | Euclidean norms are all one. LAPACK subroutine |   
             | dtrevc returns each eigenvector normalized so  |   
             | that the element of largest magnitude has      |   
             | magnitude 1;                                   |   
             %------------------------------------------------% */

	    iconj = 0;
	    i__1 = nconv;
	    for (j = 1; j <= i__1; ++j) {

		if (workl[iheigi + j - 1] == 0.) {

/*                 %----------------------%   
                   | real eigenvalue case |   
                   %----------------------% */

		    temp = igraphdnrm2_(ncv, &workl[invsub + (j - 1) * ldq], &c__1);
		    d__1 = 1. / temp;
		    igraphdscal_(ncv, &d__1, &workl[invsub + (j - 1) * ldq], &c__1);

		} else {

/*                 %-------------------------------------------%   
                   | Complex conjugate pair case. Note that    |   
                   | since the real and imaginary part of      |   
                   | the eigenvector are stored in consecutive |   
                   | columns, we further normalize by the      |   
                   | square root of two.                       |   
                   %-------------------------------------------% */

		    if (iconj == 0) {
			d__1 = igraphdnrm2_(ncv, &workl[invsub + (j - 1) * ldq], &
				c__1);
			d__2 = igraphdnrm2_(ncv, &workl[invsub + j * ldq], &c__1);
			temp = igraphdlapy2_(&d__1, &d__2);
			d__1 = 1. / temp;
			igraphdscal_(ncv, &d__1, &workl[invsub + (j - 1) * ldq], &
				c__1);
			d__1 = 1. / temp;
			igraphdscal_(ncv, &d__1, &workl[invsub + j * ldq], &c__1);
			iconj = 1;
		    } else {
			iconj = 0;
		    }

		}

/* L40: */
	    }

	    igraphdgemv_("T", ncv, &nconv, &c_b45, &workl[invsub], &ldq, &workl[
		    ihbds], &c__1, &c_b44, &workev[1], &c__1);

	    iconj = 0;
	    i__1 = nconv;
	    for (j = 1; j <= i__1; ++j) {
		if (workl[iheigi + j - 1] != 0.) {

/*                 %-------------------------------------------%   
                   | Complex conjugate pair case. Note that    |   
                   | since the real and imaginary part of      |   
                   | the eigenvector are stored in consecutive |   
                   %-------------------------------------------% */

		    if (iconj == 0) {
			workev[j] = igraphdlapy2_(&workev[j], &workev[j + 1]);
			workev[j + 1] = workev[j];
			iconj = 1;
		    } else {
			iconj = 0;
		    }
		}
/* L45: */
	    }

	    if (msglvl > 2) {
		igraphdcopy_(ncv, &workl[invsub + *ncv - 1], &ldq, &workl[ihbds], &
			c__1);
		igraphdvout_(&logfil, ncv, &workl[ihbds], &ndigit, "_neupd: Last r"
			"ow of the eigenvector matrix for T", (ftnlen)48);
		if (msglvl > 3) {
		    igraphdmout_(&logfil, ncv, ncv, &workl[invsub], &ldq, &ndigit, 
			    "_neupd: The eigenvector matrix for T", (ftnlen)
			    36);
		}
	    }

/*           %---------------------------------------%   
             | Copy Ritz estimates into workl(ihbds) |   
             %---------------------------------------% */

	    igraphdcopy_(&nconv, &workev[1], &c__1, &workl[ihbds], &c__1);

/*           %---------------------------------------------------------%   
             | Compute the QR factorization of the eigenvector matrix  |   
             | associated with leading portion of T in the first NCONV |   
             | columns of workl(invsub,ldq).                           |   
             %---------------------------------------------------------% */

	    igraphdgeqr2_(ncv, &nconv, &workl[invsub], &ldq, &workev[1], &workev[*
		    ncv + 1], &ierr);

/*           %----------------------------------------------%   
             | * Postmultiply Z by Q.                       |   
             | * Postmultiply Z by R.                       |   
             | The N by NCONV matrix Z is now contains the  |   
             | Ritz vectors associated with the Ritz values |   
             | in workl(iheigr) and workl(iheigi).          |   
             %----------------------------------------------% */

	    igraphdorm2r_("Right", "Notranspose", n, ncv, &nconv, &workl[invsub], &
		    ldq, &workev[1], &z__[z_offset], ldz, &workd[*n + 1], &
		    ierr);

	    igraphdtrmm_("Right", "Upper", "No transpose", "Non-unit", n, &nconv, &
		    c_b45, &workl[invsub], &ldq, &z__[z_offset], ldz);

	}

    } else {

/*        %------------------------------------------------------%   
          | An approximate invariant subspace is not needed.     |   
          | Place the Ritz values computed DNAUPD into DR and DI |   
          %------------------------------------------------------% */

	igraphdcopy_(&nconv, &workl[ritzr], &c__1, &dr[1], &c__1);
	igraphdcopy_(&nconv, &workl[ritzi], &c__1, &di[1], &c__1);
	igraphdcopy_(&nconv, &workl[ritzr], &c__1, &workl[iheigr], &c__1);
	igraphdcopy_(&nconv, &workl[ritzi], &c__1, &workl[iheigi], &c__1);
	igraphdcopy_(&nconv, &workl[bounds], &c__1, &workl[ihbds], &c__1);
    }

/*     %------------------------------------------------%   
       | Transform the Ritz values and possibly vectors |   
       | and corresponding error bounds of OP to those  |   
       | of A*x = lambda*B*x.                           |   
       %------------------------------------------------% */

    if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) == 0) {

	if (*rvec) {
	    igraphdscal_(ncv, &rnorm, &workl[ihbds], &c__1);
	}

    } else {

/*        %---------------------------------------%   
          |   A spectral transformation was used. |   
          | * Determine the Ritz estimates of the |   
          |   Ritz values in the original system. |   
          %---------------------------------------% */

	if (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0) {

	    if (*rvec) {
		igraphdscal_(ncv, &rnorm, &workl[ihbds], &c__1);
	    }

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		temp = igraphdlapy2_(&workl[iheigr + k - 1], &workl[iheigi + k - 1])
			;
		workl[ihbds + k - 1] = (d__1 = workl[ihbds + k - 1], abs(d__1)
			) / temp / temp;
/* L50: */
	    }

	} else if (s_cmp(type__, "REALPT", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
/* L60: */
	    }

	} else if (s_cmp(type__, "IMAGPT", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
/* L70: */
	    }

	}

/*        %-----------------------------------------------------------%   
          | *  Transform the Ritz values back to the original system. |   
          |    For TYPE = 'SHIFTI' the transformation is              |   
          |             lambda = 1/theta + sigma                      |   
          |    For TYPE = 'REALPT' or 'IMAGPT' the user must from     |   
          |    Rayleigh quotients or a projection. See remark 3 above.|   
          | NOTES:                                                    |   
          | *The Ritz vectors are not affected by the transformation. |   
          %-----------------------------------------------------------% */

	if (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		temp = igraphdlapy2_(&workl[iheigr + k - 1], &workl[iheigi + k - 1])
			;
		workl[iheigr + k - 1] = workl[iheigr + k - 1] / temp / temp + 
			*sigmar;
		workl[iheigi + k - 1] = -workl[iheigi + k - 1] / temp / temp 
			+ *sigmai;
/* L80: */
	    }

	    igraphdcopy_(&nconv, &workl[iheigr], &c__1, &dr[1], &c__1);
	    igraphdcopy_(&nconv, &workl[iheigi], &c__1, &di[1], &c__1);

	} else if (s_cmp(type__, "REALPT", (ftnlen)6, (ftnlen)6) == 0 || 
		s_cmp(type__, "IMAGPT", (ftnlen)6, (ftnlen)6) == 0) {

	    igraphdcopy_(&nconv, &workl[iheigr], &c__1, &dr[1], &c__1);
	    igraphdcopy_(&nconv, &workl[iheigi], &c__1, &di[1], &c__1);

	}

    }

    if (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0 && msglvl > 1) {
	igraphdvout_(&logfil, &nconv, &dr[1], &ndigit, "_neupd: Untransformed real"
		" part of the Ritz valuess.", (ftnlen)52);
	igraphdvout_(&logfil, &nconv, &di[1], &ndigit, "_neupd: Untransformed imag"
		" part of the Ritz valuess.", (ftnlen)52);
	igraphdvout_(&logfil, &nconv, &workl[ihbds], &ndigit, "_neupd: Ritz estima"
		"tes of untransformed Ritz values.", (ftnlen)52);
    } else if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) == 0 && msglvl > 
	    1) {
	igraphdvout_(&logfil, &nconv, &dr[1], &ndigit, "_neupd: Real parts of conv"
		"erged Ritz values.", (ftnlen)44);
	igraphdvout_(&logfil, &nconv, &di[1], &ndigit, "_neupd: Imag parts of conv"
		"erged Ritz values.", (ftnlen)44);
	igraphdvout_(&logfil, &nconv, &workl[ihbds], &ndigit, "_neupd: Associated "
		"Ritz estimates.", (ftnlen)34);
    }

/*     %-------------------------------------------------%   
       | Eigenvector Purification step. Formally perform |   
       | one of inverse subspace iteration. Only used    |   
       | for MODE = 2.                                   |   
       %-------------------------------------------------% */

    if (*rvec && *(unsigned char *)howmny == 'A' && s_cmp(type__, "SHIFTI", (
	    ftnlen)6, (ftnlen)6) == 0) {

/*        %------------------------------------------------%   
          | Purify the computed Ritz vectors by adding a   |   
          | little bit of the residual vector:             |   
          |                      T                         |   
          |          resid(:)*( e    s ) / theta           |   
          |                      NCV                       |   
          | where H s = s theta. Remember that when theta  |   
          | has nonzero imaginary part, the corresponding  |   
          | Ritz vector is stored across two columns of Z. |   
          %------------------------------------------------% */

	iconj = 0;
	i__1 = nconv;
	for (j = 1; j <= i__1; ++j) {
	    if (workl[iheigi + j - 1] == 0.) {
		workev[j] = workl[invsub + (j - 1) * ldq + *ncv - 1] / workl[
			iheigr + j - 1];
	    } else if (iconj == 0) {
		temp = igraphdlapy2_(&workl[iheigr + j - 1], &workl[iheigi + j - 1])
			;
		workev[j] = (workl[invsub + (j - 1) * ldq + *ncv - 1] * workl[
			iheigr + j - 1] + workl[invsub + j * ldq + *ncv - 1] *
			 workl[iheigi + j - 1]) / temp / temp;
		workev[j + 1] = (workl[invsub + j * ldq + *ncv - 1] * workl[
			iheigr + j - 1] - workl[invsub + (j - 1) * ldq + *ncv 
			- 1] * workl[iheigi + j - 1]) / temp / temp;
		iconj = 1;
	    } else {
		iconj = 0;
	    }
/* L110: */
	}

/*        %---------------------------------------%   
          | Perform a rank one update to Z and    |   
          | purify all the Ritz vectors together. |   
          %---------------------------------------% */

	igraphdger_(n, &nconv, &c_b45, &resid[1], &c__1, &workev[1], &c__1, &z__[
		z_offset], ldz);

    }

L9000:

    return 0;

/*     %---------------%   
       | End of DNEUPD |   
       %---------------% */

} /* igraphdneupd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dngets.c0000644000175100001710000002302600000000000024035 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static logical c_true = TRUE_;
static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dngets   

   \Description:   
    Given the eigenvalues of the upper Hessenberg matrix H,   
    computes the NP shifts AMU that are zeros of the polynomial of   
    degree NP which filters out components of the unwanted eigenvectors   
    corresponding to the AMU's based on some given criteria.   

    NOTE: call this even in the case of user specified shifts in order   
    to sort the eigenvalues, and error bounds of H for later use.   

   \Usage:   
    call dngets   
       ( ISHIFT, WHICH, KEV, NP, RITZR, RITZI, BOUNDS, SHIFTR, SHIFTI )   

   \Arguments   
    ISHIFT  Integer.  (INPUT)   
            Method for selecting the implicit shifts at each iteration.   
            ISHIFT = 0: user specified shifts   
            ISHIFT = 1: exact shift with respect to the matrix H.   

    WHICH   Character*2.  (INPUT)   
            Shift selection criteria.   
            'LM' -> want the KEV eigenvalues of largest magnitude.   
            'SM' -> want the KEV eigenvalues of smallest magnitude.   
            'LR' -> want the KEV eigenvalues of largest real part.   
            'SR' -> want the KEV eigenvalues of smallest real part.   
            'LI' -> want the KEV eigenvalues of largest imaginary part.   
            'SI' -> want the KEV eigenvalues of smallest imaginary part.   

    KEV      Integer.  (INPUT/OUTPUT)   
             INPUT: KEV+NP is the size of the matrix H.   
             OUTPUT: Possibly increases KEV by one to keep complex conjugate   
             pairs together.   

    NP       Integer.  (INPUT/OUTPUT)   
             Number of implicit shifts to be computed.   
             OUTPUT: Possibly decreases NP by one to keep complex conjugate   
             pairs together.   

    RITZR,  Double precision array of length KEV+NP.  (INPUT/OUTPUT)   
    RITZI   On INPUT, RITZR and RITZI contain the real and imaginary   
            parts of the eigenvalues of H.   
            On OUTPUT, RITZR and RITZI are sorted so that the unwanted   
            eigenvalues are in the first NP locations and the wanted   
            portion is in the last KEV locations.  When exact shifts are   
            selected, the unwanted part corresponds to the shifts to   
            be applied. Also, if ISHIFT .eq. 1, the unwanted eigenvalues   
            are further sorted so that the ones with largest Ritz values   
            are first.   

    BOUNDS  Double precision array of length KEV+NP.  (INPUT/OUTPUT)   
            Error bounds corresponding to the ordering in RITZ.   

    SHIFTR, SHIFTI  *** USE deprecated as of version 2.1. ***   


   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dsortc  ARPACK sorting routine.   
       dcopy   Level 1 BLAS that copies one vector to another .   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: ngets.F   SID: 2.3   DATE OF SID: 4/20/96   RELEASE: 2   

   \Remarks   
       1. xxxx   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdngets_(integer *ishift, char *which, integer *kev, 
	integer *np, doublereal *ritzr, doublereal *ritzi, doublereal *bounds,
	 doublereal *shiftr, doublereal *shifti)
{
    /* System generated locals */
    integer i__1;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    IGRAPH_F77_SAVE real t0, t1;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen), igraphsecond_(real *);
    integer logfil, ndigit, mngets = 0;
    extern /* Subroutine */ int igraphdsortc_(char *, logical *, integer *, 
	    doublereal *, doublereal *, doublereal *);
    integer msglvl;
    real tngets = 0.;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %----------------------%   
       | Intrinsics Functions |   
       %----------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------%   

       Parameter adjustments */
    --bounds;
    --ritzi;
    --ritzr;
    --shiftr;
    --shifti;

    /* Function Body */
    igraphsecond_(&t0);
    msglvl = mngets;

/*     %----------------------------------------------------%   
       | LM, SM, LR, SR, LI, SI case.                       |   
       | Sort the eigenvalues of H into the desired order   |   
       | and apply the resulting order to BOUNDS.           |   
       | The eigenvalues are sorted so that the wanted part |   
       | are always in the last KEV locations.              |   
       | We first do a pre-processing sort in order to keep |   
       | complex conjugate pairs together                   |   
       %----------------------------------------------------% */

    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("LR", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("SR", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    } else if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("LM", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    } else if (s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("SM", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    } else if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("LM", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    } else if (s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) == 0) {
	i__1 = *kev + *np;
	igraphdsortc_("SM", &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);
    }

    i__1 = *kev + *np;
    igraphdsortc_(which, &c_true, &i__1, &ritzr[1], &ritzi[1], &bounds[1]);

/*     %-------------------------------------------------------%   
       | Increase KEV by one if the ( ritzr(np),ritzi(np) )    |   
       | = ( ritzr(np+1),-ritzi(np+1) ) and ritz(np) .ne. zero |   
       | Accordingly decrease NP by one. In other words keep   |   
       | complex conjugate pairs together.                     |   
       %-------------------------------------------------------% */

    if (ritzr[*np + 1] - ritzr[*np] == 0. && ritzi[*np + 1] + ritzi[*np] == 
	    0.) {
	--(*np);
	++(*kev);
    }

    if (*ishift == 1) {

/*        %-------------------------------------------------------%   
          | Sort the unwanted Ritz values used as shifts so that  |   
          | the ones with largest Ritz estimates are first        |   
          | This will tend to minimize the effects of the         |   
          | forward instability of the iteration when they shifts |   
          | are applied in subroutine dnapps.                     |   
          | Be careful and use 'SR' since we want to sort BOUNDS! |   
          %-------------------------------------------------------% */

	igraphdsortc_("SR", &c_true, np, &bounds[1], &ritzr[1], &ritzi[1]);
    }

    igraphsecond_(&t1);
    tngets += t1 - t0;

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, kev, &ndigit, "_ngets: KEV is", (ftnlen)14);
	igraphivout_(&logfil, &c__1, np, &ndigit, "_ngets: NP is", (ftnlen)13);
	i__1 = *kev + *np;
	igraphdvout_(&logfil, &i__1, &ritzr[1], &ndigit, "_ngets: Eigenvalues of c"
		"urrent H matrix -- real part", (ftnlen)52);
	i__1 = *kev + *np;
	igraphdvout_(&logfil, &i__1, &ritzi[1], &ndigit, "_ngets: Eigenvalues of c"
		"urrent H matrix -- imag part", (ftnlen)52);
	i__1 = *kev + *np;
	igraphdvout_(&logfil, &i__1, &bounds[1], &ndigit, "_ngets: Ritz estimates "
		"of the current KEV+NP Ritz values", (ftnlen)56);
    }

    return 0;

/*     %---------------%   
       | End of dngets |   
       %---------------% */

} /* igraphdngets_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dnrm2.c0000644000175100001710000000711400000000000023573 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DNRM2   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         DOUBLE PRECISION FUNCTION DNRM2(N,X,INCX)   

         INTEGER INCX,N   
         DOUBLE PRECISION X(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DNRM2 returns the euclidean norm of a vector via the function   
   > name, so that   
   >   
   >    DNRM2 := sqrt( x'*x )   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  -- This version written on 25-October-1982.   
   >     Modified on 14-October-1993 to inline the call to DLASSQ.   
   >     Sven Hammarling, Nag Ltd.   
   > \endverbatim   
   >   
    ===================================================================== */
doublereal igraphdnrm2_(integer *n, doublereal *x, integer *incx)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal ret_val, d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer ix;
    doublereal ssq, norm, scale, absxi;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --x;

    /* Function Body */
    if (*n < 1 || *incx < 1) {
	norm = 0.;
    } else if (*n == 1) {
	norm = abs(x[1]);
    } else {
	scale = 0.;
	ssq = 1.;
/*        The following loop is equivalent to this call to the LAPACK   
          auxiliary routine:   
          CALL DLASSQ( N, X, INCX, SCALE, SSQ ) */

	i__1 = (*n - 1) * *incx + 1;
	i__2 = *incx;
	for (ix = 1; i__2 < 0 ? ix >= i__1 : ix <= i__1; ix += i__2) {
	    if (x[ix] != 0.) {
		absxi = (d__1 = x[ix], abs(d__1));
		if (scale < absxi) {
/* Computing 2nd power */
		    d__1 = scale / absxi;
		    ssq = ssq * (d__1 * d__1) + 1.;
		    scale = absxi;
		} else {
/* Computing 2nd power */
		    d__1 = absxi / scale;
		    ssq += d__1 * d__1;
		}
	    }
/* L10: */
	}
	norm = scale * sqrt(ssq);
    }

    ret_val = norm;
    return ret_val;

/*     End of DNRM2. */

} /* igraphdnrm2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dorg2r.c0000644000175100001710000001445100000000000023752 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DORG2R generates all or part of the orthogonal matrix Q from a QR factorization determined by s
geqrf (unblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORG2R + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORG2R( M, N, K, A, LDA, TAU, WORK, INFO )   

         INTEGER            INFO, K, LDA, M, N   
         DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORG2R generates an m by n real matrix Q with orthonormal columns,   
   > which is defined as the first n columns of a product of k elementary   
   > reflectors of order m   
   >   
   >       Q  =  H(1) H(2) . . . H(k)   
   >   
   > as returned by DGEQRF.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix Q. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix Q. M >= N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines the   
   >          matrix Q. N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the i-th column must contain the vector which   
   >          defines the elementary reflector H(i), for i = 1,2,...,k, as   
   >          returned by DGEQRF in the first k columns of its array   
   >          argument A.   
   >          On exit, the m-by-n matrix Q.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The first dimension of the array A. LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQRF.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument has an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdorg2r_(integer *m, integer *n, integer *k, doublereal *
	a, integer *lda, doublereal *tau, doublereal *work, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;
    doublereal d__1;

    /* Local variables */
    integer i__, j, l;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdlarf_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *), igraphxerbla_(char *, integer *, ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    if (*m < 0) {
	*info = -1;
    } else if (*n < 0 || *n > *m) {
	*info = -2;
    } else if (*k < 0 || *k > *n) {
	*info = -3;
    } else if (*lda < max(1,*m)) {
	*info = -5;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORG2R", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n <= 0) {
	return 0;
    }

/*     Initialise columns k+1:n to columns of the unit matrix */

    i__1 = *n;
    for (j = *k + 1; j <= i__1; ++j) {
	i__2 = *m;
	for (l = 1; l <= i__2; ++l) {
	    a[l + j * a_dim1] = 0.;
/* L10: */
	}
	a[j + j * a_dim1] = 1.;
/* L20: */
    }

    for (i__ = *k; i__ >= 1; --i__) {

/*        Apply H(i) to A(i:m,i:n) from the left */

	if (i__ < *n) {
	    a[i__ + i__ * a_dim1] = 1.;
	    i__1 = *m - i__ + 1;
	    i__2 = *n - i__;
	    igraphdlarf_("Left", &i__1, &i__2, &a[i__ + i__ * a_dim1], &c__1, &tau[
		    i__], &a[i__ + (i__ + 1) * a_dim1], lda, &work[1]);
	}
	if (i__ < *m) {
	    i__1 = *m - i__;
	    d__1 = -tau[i__];
	    igraphdscal_(&i__1, &d__1, &a[i__ + 1 + i__ * a_dim1], &c__1);
	}
	a[i__ + i__ * a_dim1] = 1. - tau[i__];

/*        Set A(1:i-1,i) to zero */

	i__1 = i__ - 1;
	for (l = 1; l <= i__1; ++l) {
	    a[l + i__ * a_dim1] = 0.;
/* L30: */
	}
/* L40: */
    }
    return 0;

/*     End of DORG2R */

} /* igraphdorg2r_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dorghr.c0000644000175100001710000001715500000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;

/* > \brief \b DORGHR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORGHR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORGHR( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO )   

         INTEGER            IHI, ILO, INFO, LDA, LWORK, N   
         DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORGHR generates a real orthogonal matrix Q which is defined as the   
   > product of IHI-ILO elementary reflectors of order N, as returned by   
   > DGEHRD:   
   >   
   > Q = H(ilo) H(ilo+1) . . . H(ihi-1).   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix Q. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >   
   >          ILO and IHI must have the same values as in the previous call   
   >          of DGEHRD. Q is equal to the unit matrix except in the   
   >          submatrix Q(ilo+1:ihi,ilo+1:ihi).   
   >          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the vectors which define the elementary reflectors,   
   >          as returned by DGEHRD.   
   >          On exit, the N-by-N orthogonal matrix Q.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A. LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEHRD.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK. LWORK >= IHI-ILO.   
   >          For optimum performance LWORK >= (IHI-ILO)*NB, where NB is   
   >          the optimal blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdorghr_(integer *n, integer *ilo, integer *ihi, 
	doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
	integer *lwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, nb, nh, iinfo;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphdorgqr_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    integer *);
    integer lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    nh = *ihi - *ilo;
    lquery = *lwork == -1;
    if (*n < 0) {
	*info = -1;
    } else if (*ilo < 1 || *ilo > max(1,*n)) {
	*info = -2;
    } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
	*info = -3;
    } else if (*lda < max(1,*n)) {
	*info = -5;
    } else if (*lwork < max(1,nh) && ! lquery) {
	*info = -8;
    }

    if (*info == 0) {
	nb = igraphilaenv_(&c__1, "DORGQR", " ", &nh, &nh, &nh, &c_n1, (ftnlen)6, (
		ftnlen)1);
	lwkopt = max(1,nh) * nb;
	work[1] = (doublereal) lwkopt;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORGHR", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	work[1] = 1.;
	return 0;
    }

/*     Shift the vectors which define the elementary reflectors one   
       column to the right, and set the first ilo and the last n-ihi   
       rows and columns to those of the unit matrix */

    i__1 = *ilo + 1;
    for (j = *ihi; j >= i__1; --j) {
	i__2 = j - 1;
	for (i__ = 1; i__ <= i__2; ++i__) {
	    a[i__ + j * a_dim1] = 0.;
/* L10: */
	}
	i__2 = *ihi;
	for (i__ = j + 1; i__ <= i__2; ++i__) {
	    a[i__ + j * a_dim1] = a[i__ + (j - 1) * a_dim1];
/* L20: */
	}
	i__2 = *n;
	for (i__ = *ihi + 1; i__ <= i__2; ++i__) {
	    a[i__ + j * a_dim1] = 0.;
/* L30: */
	}
/* L40: */
    }
    i__1 = *ilo;
    for (j = 1; j <= i__1; ++j) {
	i__2 = *n;
	for (i__ = 1; i__ <= i__2; ++i__) {
	    a[i__ + j * a_dim1] = 0.;
/* L50: */
	}
	a[j + j * a_dim1] = 1.;
/* L60: */
    }
    i__1 = *n;
    for (j = *ihi + 1; j <= i__1; ++j) {
	i__2 = *n;
	for (i__ = 1; i__ <= i__2; ++i__) {
	    a[i__ + j * a_dim1] = 0.;
/* L70: */
	}
	a[j + j * a_dim1] = 1.;
/* L80: */
    }

    if (nh > 0) {

/*        Generate Q(ilo+1:ihi,ilo+1:ihi) */

	igraphdorgqr_(&nh, &nh, &nh, &a[*ilo + 1 + (*ilo + 1) * a_dim1], lda, &tau[*
		ilo], &work[1], lwork, &iinfo);
    }
    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DORGHR */

} /* igraphdorghr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dorgqr.c0000644000175100001710000002300700000000000024046 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;

/* > \brief \b DORGQR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORGQR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORGQR( M, N, K, A, LDA, TAU, WORK, LWORK, INFO )   

         INTEGER            INFO, K, LDA, LWORK, M, N   
         DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORGQR generates an M-by-N real matrix Q with orthonormal columns,   
   > which is defined as the first N columns of a product of K elementary   
   > reflectors of order M   
   >   
   >       Q  =  H(1) H(2) . . . H(k)   
   >   
   > as returned by DGEQRF.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix Q. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix Q. M >= N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines the   
   >          matrix Q. N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the i-th column must contain the vector which   
   >          defines the elementary reflector H(i), for i = 1,2,...,k, as   
   >          returned by DGEQRF in the first k columns of its array   
   >          argument A.   
   >          On exit, the M-by-N matrix Q.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The first dimension of the array A. LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQRF.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK. LWORK >= max(1,N).   
   >          For optimum performance LWORK >= N*NB, where NB is the   
   >          optimal blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument has an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdorgqr_(integer *m, integer *n, integer *k, doublereal *
	a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, 
	integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j, l, ib, nb, ki, kk, nx, iws, nbmin, iinfo;
    extern /* Subroutine */ int igraphdorg2r_(integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *), 
	    igraphdlarfb_(char *, char *, char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), igraphdlarft_(char *, char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *), igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    integer ldwork, lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    nb = igraphilaenv_(&c__1, "DORGQR", " ", m, n, k, &c_n1, (ftnlen)6, (ftnlen)1);
    lwkopt = max(1,*n) * nb;
    work[1] = (doublereal) lwkopt;
    lquery = *lwork == -1;
    if (*m < 0) {
	*info = -1;
    } else if (*n < 0 || *n > *m) {
	*info = -2;
    } else if (*k < 0 || *k > *n) {
	*info = -3;
    } else if (*lda < max(1,*m)) {
	*info = -5;
    } else if (*lwork < max(1,*n) && ! lquery) {
	*info = -8;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORGQR", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*n <= 0) {
	work[1] = 1.;
	return 0;
    }

    nbmin = 2;
    nx = 0;
    iws = *n;
    if (nb > 1 && nb < *k) {

/*        Determine when to cross over from blocked to unblocked code.   

   Computing MAX */
	i__1 = 0, i__2 = igraphilaenv_(&c__3, "DORGQR", " ", m, n, k, &c_n1, (
		ftnlen)6, (ftnlen)1);
	nx = max(i__1,i__2);
	if (nx < *k) {

/*           Determine if workspace is large enough for blocked code. */

	    ldwork = *n;
	    iws = ldwork * nb;
	    if (*lwork < iws) {

/*              Not enough workspace to use optimal NB:  reduce NB and   
                determine the minimum value of NB. */

		nb = *lwork / ldwork;
/* Computing MAX */
		i__1 = 2, i__2 = igraphilaenv_(&c__2, "DORGQR", " ", m, n, k, &c_n1,
			 (ftnlen)6, (ftnlen)1);
		nbmin = max(i__1,i__2);
	    }
	}
    }

    if (nb >= nbmin && nb < *k && nx < *k) {

/*        Use blocked code after the last block.   
          The first kk columns are handled by the block method. */

	ki = (*k - nx - 1) / nb * nb;
/* Computing MIN */
	i__1 = *k, i__2 = ki + nb;
	kk = min(i__1,i__2);

/*        Set A(1:kk,kk+1:n) to zero. */

	i__1 = *n;
	for (j = kk + 1; j <= i__1; ++j) {
	    i__2 = kk;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		a[i__ + j * a_dim1] = 0.;
/* L10: */
	    }
/* L20: */
	}
    } else {
	kk = 0;
    }

/*     Use unblocked code for the last or only block. */

    if (kk < *n) {
	i__1 = *m - kk;
	i__2 = *n - kk;
	i__3 = *k - kk;
	igraphdorg2r_(&i__1, &i__2, &i__3, &a[kk + 1 + (kk + 1) * a_dim1], lda, &
		tau[kk + 1], &work[1], &iinfo);
    }

    if (kk > 0) {

/*        Use blocked code */

	i__1 = -nb;
	for (i__ = ki + 1; i__1 < 0 ? i__ >= 1 : i__ <= 1; i__ += i__1) {
/* Computing MIN */
	    i__2 = nb, i__3 = *k - i__ + 1;
	    ib = min(i__2,i__3);
	    if (i__ + ib <= *n) {

/*              Form the triangular factor of the block reflector   
                H = H(i) H(i+1) . . . H(i+ib-1) */

		i__2 = *m - i__ + 1;
		igraphdlarft_("Forward", "Columnwise", &i__2, &ib, &a[i__ + i__ * 
			a_dim1], lda, &tau[i__], &work[1], &ldwork);

/*              Apply H to A(i:m,i+ib:n) from the left */

		i__2 = *m - i__ + 1;
		i__3 = *n - i__ - ib + 1;
		igraphdlarfb_("Left", "No transpose", "Forward", "Columnwise", &
			i__2, &i__3, &ib, &a[i__ + i__ * a_dim1], lda, &work[
			1], &ldwork, &a[i__ + (i__ + ib) * a_dim1], lda, &
			work[ib + 1], &ldwork);
	    }

/*           Apply H to rows i:m of current block */

	    i__2 = *m - i__ + 1;
	    igraphdorg2r_(&i__2, &ib, &ib, &a[i__ + i__ * a_dim1], lda, &tau[i__], &
		    work[1], &iinfo);

/*           Set rows 1:i-1 of current block to zero */

	    i__2 = i__ + ib - 1;
	    for (j = i__; j <= i__2; ++j) {
		i__3 = i__ - 1;
		for (l = 1; l <= i__3; ++l) {
		    a[l + j * a_dim1] = 0.;
/* L30: */
		}
/* L40: */
	    }
/* L50: */
	}
    }

    work[1] = (doublereal) iws;
    return 0;

/*     End of DORGQR */

} /* igraphdorgqr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dorm2l.c0000644000175100001710000002031400000000000023745 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DORM2L multiplies a general matrix by the orthogonal matrix from a QL factorization determined 
by sgeqlf (unblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORM2L + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORM2L( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,   
                            WORK, INFO )   

         CHARACTER          SIDE, TRANS   
         INTEGER            INFO, K, LDA, LDC, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORM2L overwrites the general real m by n matrix C with   
   >   
   >       Q * C  if SIDE = 'L' and TRANS = 'N', or   
   >   
   >       Q**T * C  if SIDE = 'L' and TRANS = 'T', or   
   >   
   >       C * Q  if SIDE = 'R' and TRANS = 'N', or   
   >   
   >       C * Q**T if SIDE = 'R' and TRANS = 'T',   
   >   
   > where Q is a real orthogonal matrix defined as the product of k   
   > elementary reflectors   
   >   
   >       Q = H(k) . . . H(2) H(1)   
   >   
   > as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n   
   > if SIDE = 'R'.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left   
   >          = 'R': apply Q or Q**T from the Right   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N': apply Q  (No transpose)   
   >          = 'T': apply Q**T (Transpose)   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines   
   >          the matrix Q.   
   >          If SIDE = 'L', M >= K >= 0;   
   >          if SIDE = 'R', N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,K)   
   >          The i-th column must contain the vector which defines the   
   >          elementary reflector H(i), for i = 1,2,...,k, as returned by   
   >          DGEQLF in the last k columns of its array argument A.   
   >          A is modified by the routine but restored on exit.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          If SIDE = 'L', LDA >= max(1,M);   
   >          if SIDE = 'R', LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQLF.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the m by n matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension   
   >                                   (N) if SIDE = 'L',   
   >                                   (M) if SIDE = 'R'   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdorm2l_(char *side, char *trans, integer *m, integer *n, 
	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
	c__, integer *ldc, doublereal *work, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2;

    /* Local variables */
    integer i__, i1, i2, i3, mi, ni, nq;
    doublereal aii;
    logical left;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical notran;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    left = igraphlsame_(side, "L");
    notran = igraphlsame_(trans, "N");

/*     NQ is the order of Q */

    if (left) {
	nq = *m;
    } else {
	nq = *n;
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! notran && ! igraphlsame_(trans, "T")) {
	*info = -2;
    } else if (*m < 0) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*k < 0 || *k > nq) {
	*info = -5;
    } else if (*lda < max(1,nq)) {
	*info = -7;
    } else if (*ldc < max(1,*m)) {
	*info = -10;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORM2L", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0 || *k == 0) {
	return 0;
    }

    if (left && notran || ! left && ! notran) {
	i1 = 1;
	i2 = *k;
	i3 = 1;
    } else {
	i1 = *k;
	i2 = 1;
	i3 = -1;
    }

    if (left) {
	ni = *n;
    } else {
	mi = *m;
    }

    i__1 = i2;
    i__2 = i3;
    for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
	if (left) {

/*           H(i) is applied to C(1:m-k+i,1:n) */

	    mi = *m - *k + i__;
	} else {

/*           H(i) is applied to C(1:m,1:n-k+i) */

	    ni = *n - *k + i__;
	}

/*        Apply H(i) */

	aii = a[nq - *k + i__ + i__ * a_dim1];
	a[nq - *k + i__ + i__ * a_dim1] = 1.;
	igraphdlarf_(side, &mi, &ni, &a[i__ * a_dim1 + 1], &c__1, &tau[i__], &c__[
		c_offset], ldc, &work[1]);
	a[nq - *k + i__ + i__ * a_dim1] = aii;
/* L10: */
    }
    return 0;

/*     End of DORM2L */

} /* igraphdorm2l_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dorm2r.c0000644000175100001710000002034600000000000023760 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b DORM2R multiplies a general matrix by the orthogonal matrix from a QR factorization determined 
by sgeqrf (unblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORM2R + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORM2R( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,   
                            WORK, INFO )   

         CHARACTER          SIDE, TRANS   
         INTEGER            INFO, K, LDA, LDC, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORM2R overwrites the general real m by n matrix C with   
   >   
   >       Q * C  if SIDE = 'L' and TRANS = 'N', or   
   >   
   >       Q**T* C  if SIDE = 'L' and TRANS = 'T', or   
   >   
   >       C * Q  if SIDE = 'R' and TRANS = 'N', or   
   >   
   >       C * Q**T if SIDE = 'R' and TRANS = 'T',   
   >   
   > where Q is a real orthogonal matrix defined as the product of k   
   > elementary reflectors   
   >   
   >       Q = H(1) H(2) . . . H(k)   
   >   
   > as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n   
   > if SIDE = 'R'.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left   
   >          = 'R': apply Q or Q**T from the Right   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N': apply Q  (No transpose)   
   >          = 'T': apply Q**T (Transpose)   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines   
   >          the matrix Q.   
   >          If SIDE = 'L', M >= K >= 0;   
   >          if SIDE = 'R', N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,K)   
   >          The i-th column must contain the vector which defines the   
   >          elementary reflector H(i), for i = 1,2,...,k, as returned by   
   >          DGEQRF in the first k columns of its array argument A.   
   >          A is modified by the routine but restored on exit.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          If SIDE = 'L', LDA >= max(1,M);   
   >          if SIDE = 'R', LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQRF.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the m by n matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension   
   >                                   (N) if SIDE = 'L',   
   >                                   (M) if SIDE = 'R'   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdorm2r_(char *side, char *trans, integer *m, integer *n, 
	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
	c__, integer *ldc, doublereal *work, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2;

    /* Local variables */
    integer i__, i1, i2, i3, ic, jc, mi, ni, nq;
    doublereal aii;
    logical left;
    extern /* Subroutine */ int igraphdlarf_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical notran;


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    left = igraphlsame_(side, "L");
    notran = igraphlsame_(trans, "N");

/*     NQ is the order of Q */

    if (left) {
	nq = *m;
    } else {
	nq = *n;
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! notran && ! igraphlsame_(trans, "T")) {
	*info = -2;
    } else if (*m < 0) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*k < 0 || *k > nq) {
	*info = -5;
    } else if (*lda < max(1,nq)) {
	*info = -7;
    } else if (*ldc < max(1,*m)) {
	*info = -10;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORM2R", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0 || *k == 0) {
	return 0;
    }

    if (left && ! notran || ! left && notran) {
	i1 = 1;
	i2 = *k;
	i3 = 1;
    } else {
	i1 = *k;
	i2 = 1;
	i3 = -1;
    }

    if (left) {
	ni = *n;
	jc = 1;
    } else {
	mi = *m;
	ic = 1;
    }

    i__1 = i2;
    i__2 = i3;
    for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
	if (left) {

/*           H(i) is applied to C(i:m,1:n) */

	    mi = *m - i__ + 1;
	    ic = i__;
	} else {

/*           H(i) is applied to C(1:m,i:n) */

	    ni = *n - i__ + 1;
	    jc = i__;
	}

/*        Apply H(i) */

	aii = a[i__ + i__ * a_dim1];
	a[i__ + i__ * a_dim1] = 1.;
	igraphdlarf_(side, &mi, &ni, &a[i__ + i__ * a_dim1], &c__1, &tau[i__], &c__[
		ic + jc * c_dim1], ldc, &work[1]);
	a[i__ + i__ * a_dim1] = aii;
/* L10: */
    }
    return 0;

/*     End of DORM2R */

} /* igraphdorm2r_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dormhr.c0000644000175100001710000002372600000000000024053 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__2 = 2;

/* > \brief \b DORMHR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORMHR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORMHR( SIDE, TRANS, M, N, ILO, IHI, A, LDA, TAU, C,   
                            LDC, WORK, LWORK, INFO )   

         CHARACTER          SIDE, TRANS   
         INTEGER            IHI, ILO, INFO, LDA, LDC, LWORK, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORMHR overwrites the general real M-by-N matrix C with   
   >   
   >                 SIDE = 'L'     SIDE = 'R'   
   > TRANS = 'N':      Q * C          C * Q   
   > TRANS = 'T':      Q**T * C       C * Q**T   
   >   
   > where Q is a real orthogonal matrix of order nq, with nq = m if   
   > SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of   
   > IHI-ILO elementary reflectors, as returned by DGEHRD:   
   >   
   > Q = H(ilo) H(ilo+1) . . . H(ihi-1).   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left;   
   >          = 'R': apply Q or Q**T from the Right.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N':  No transpose, apply Q;   
   >          = 'T':  Transpose, apply Q**T.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >   
   >          ILO and IHI must have the same values as in the previous call   
   >          of DGEHRD. Q is equal to the unit matrix except in the   
   >          submatrix Q(ilo+1:ihi,ilo+1:ihi).   
   >          If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and   
   >          ILO = 1 and IHI = 0, if M = 0;   
   >          if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and   
   >          ILO = 1 and IHI = 0, if N = 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension   
   >                               (LDA,M) if SIDE = 'L'   
   >                               (LDA,N) if SIDE = 'R'   
   >          The vectors which define the elementary reflectors, as   
   >          returned by DGEHRD.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension   
   >                               (M-1) if SIDE = 'L'   
   >                               (N-1) if SIDE = 'R'   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEHRD.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the M-by-N matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   
   >          If SIDE = 'L', LWORK >= max(1,N);   
   >          if SIDE = 'R', LWORK >= max(1,M).   
   >          For optimum performance LWORK >= N*NB if SIDE = 'L', and   
   >          LWORK >= M*NB if SIDE = 'R', where NB is the optimal   
   >          blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdormhr_(char *side, char *trans, integer *m, integer *n, 
	integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *
	tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, 
	integer *info)
{
    /* System generated locals */
    address a__1[2];
    integer a_dim1, a_offset, c_dim1, c_offset, i__1[2], i__2;
    char ch__1[2];

    /* Builtin functions   
       Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);

    /* Local variables */
    integer i1, i2, nb, mi, nh, ni, nq, nw;
    logical left;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphdormqr_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *, integer *);
    integer lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    nh = *ihi - *ilo;
    left = igraphlsame_(side, "L");
    lquery = *lwork == -1;

/*     NQ is the order of Q and NW is the minimum dimension of WORK */

    if (left) {
	nq = *m;
	nw = *n;
    } else {
	nq = *n;
	nw = *m;
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T")) {
	*info = -2;
    } else if (*m < 0) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*ilo < 1 || *ilo > max(1,nq)) {
	*info = -5;
    } else if (*ihi < min(*ilo,nq) || *ihi > nq) {
	*info = -6;
    } else if (*lda < max(1,nq)) {
	*info = -8;
    } else if (*ldc < max(1,*m)) {
	*info = -11;
    } else if (*lwork < max(1,nw) && ! lquery) {
	*info = -13;
    }

    if (*info == 0) {
	if (left) {
/* Writing concatenation */
	    i__1[0] = 1, a__1[0] = side;
	    i__1[1] = 1, a__1[1] = trans;
	    s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
	    nb = igraphilaenv_(&c__1, "DORMQR", ch__1, &nh, n, &nh, &c_n1, (ftnlen)
		    6, (ftnlen)2);
	} else {
/* Writing concatenation */
	    i__1[0] = 1, a__1[0] = side;
	    i__1[1] = 1, a__1[1] = trans;
	    s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
	    nb = igraphilaenv_(&c__1, "DORMQR", ch__1, m, &nh, &nh, &c_n1, (ftnlen)
		    6, (ftnlen)2);
	}
	lwkopt = max(1,nw) * nb;
	work[1] = (doublereal) lwkopt;
    }

    if (*info != 0) {
	i__2 = -(*info);
	igraphxerbla_("DORMHR", &i__2, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0 || nh == 0) {
	work[1] = 1.;
	return 0;
    }

    if (left) {
	mi = nh;
	ni = *n;
	i1 = *ilo + 1;
	i2 = 1;
    } else {
	mi = *m;
	ni = nh;
	i1 = 1;
	i2 = *ilo + 1;
    }

    igraphdormqr_(side, trans, &mi, &ni, &nh, &a[*ilo + 1 + *ilo * a_dim1], lda, &
	    tau[*ilo], &c__[i1 + i2 * c_dim1], ldc, &work[1], lwork, &iinfo);

    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DORMHR */

} /* igraphdormhr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dormql.c0000644000175100001710000002640100000000000024047 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__2 = 2;
static integer c__65 = 65;

/* > \brief \b DORMQL   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORMQL + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORMQL( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,   
                            WORK, LWORK, INFO )   

         CHARACTER          SIDE, TRANS   
         INTEGER            INFO, K, LDA, LDC, LWORK, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORMQL overwrites the general real M-by-N matrix C with   
   >   
   >                 SIDE = 'L'     SIDE = 'R'   
   > TRANS = 'N':      Q * C          C * Q   
   > TRANS = 'T':      Q**T * C       C * Q**T   
   >   
   > where Q is a real orthogonal matrix defined as the product of k   
   > elementary reflectors   
   >   
   >       Q = H(k) . . . H(2) H(1)   
   >   
   > as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N   
   > if SIDE = 'R'.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left;   
   >          = 'R': apply Q or Q**T from the Right.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N':  No transpose, apply Q;   
   >          = 'T':  Transpose, apply Q**T.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines   
   >          the matrix Q.   
   >          If SIDE = 'L', M >= K >= 0;   
   >          if SIDE = 'R', N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,K)   
   >          The i-th column must contain the vector which defines the   
   >          elementary reflector H(i), for i = 1,2,...,k, as returned by   
   >          DGEQLF in the last k columns of its array argument A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          If SIDE = 'L', LDA >= max(1,M);   
   >          if SIDE = 'R', LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQLF.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the M-by-N matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   
   >          If SIDE = 'L', LWORK >= max(1,N);   
   >          if SIDE = 'R', LWORK >= max(1,M).   
   >          For optimum performance LWORK >= N*NB if SIDE = 'L', and   
   >          LWORK >= M*NB if SIDE = 'R', where NB is the optimal   
   >          blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdormql_(char *side, char *trans, integer *m, integer *n, 
	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
	c__, integer *ldc, doublereal *work, integer *lwork, integer *info)
{
    /* System generated locals */
    address a__1[2];
    integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2, i__3[2], i__4, 
	    i__5;
    char ch__1[2];

    /* Builtin functions   
       Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);

    /* Local variables */
    integer i__;
    doublereal t[4160]	/* was [65][64] */;
    integer i1, i2, i3, ib, nb, mi, ni, nq, nw, iws;
    logical left;
    extern logical igraphlsame_(char *, char *);
    integer nbmin, iinfo;
    extern /* Subroutine */ int igraphdorm2l_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdlarfb_(char 
	    *, char *, char *, char *, integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdlarft_(char *, char *, integer *, integer *, doublereal 
	    *, integer *, doublereal *, doublereal *, integer *), igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    logical notran;
    integer ldwork, lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    left = igraphlsame_(side, "L");
    notran = igraphlsame_(trans, "N");
    lquery = *lwork == -1;

/*     NQ is the order of Q and NW is the minimum dimension of WORK */

    if (left) {
	nq = *m;
	nw = max(1,*n);
    } else {
	nq = *n;
	nw = max(1,*m);
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! notran && ! igraphlsame_(trans, "T")) {
	*info = -2;
    } else if (*m < 0) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*k < 0 || *k > nq) {
	*info = -5;
    } else if (*lda < max(1,nq)) {
	*info = -7;
    } else if (*ldc < max(1,*m)) {
	*info = -10;
    }

    if (*info == 0) {
	if (*m == 0 || *n == 0) {
	    lwkopt = 1;
	} else {

/*           Determine the block size.  NB may be at most NBMAX, where   
             NBMAX is used to define the local array T.   

   Computing MIN   
   Writing concatenation */
	    i__3[0] = 1, a__1[0] = side;
	    i__3[1] = 1, a__1[1] = trans;
	    s_cat(ch__1, a__1, i__3, &c__2, (ftnlen)2);
	    i__1 = 64, i__2 = igraphilaenv_(&c__1, "DORMQL", ch__1, m, n, k, &c_n1, 
		    (ftnlen)6, (ftnlen)2);
	    nb = min(i__1,i__2);
	    lwkopt = nw * nb;
	}
	work[1] = (doublereal) lwkopt;

	if (*lwork < nw && ! lquery) {
	    *info = -12;
	}
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORMQL", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0) {
	return 0;
    }

    nbmin = 2;
    ldwork = nw;
    if (nb > 1 && nb < *k) {
	iws = nw * nb;
	if (*lwork < iws) {
	    nb = *lwork / ldwork;
/* Computing MAX   
   Writing concatenation */
	    i__3[0] = 1, a__1[0] = side;
	    i__3[1] = 1, a__1[1] = trans;
	    s_cat(ch__1, a__1, i__3, &c__2, (ftnlen)2);
	    i__1 = 2, i__2 = igraphilaenv_(&c__2, "DORMQL", ch__1, m, n, k, &c_n1, (
		    ftnlen)6, (ftnlen)2);
	    nbmin = max(i__1,i__2);
	}
    } else {
	iws = nw;
    }

    if (nb < nbmin || nb >= *k) {

/*        Use unblocked code */

	igraphdorm2l_(side, trans, m, n, k, &a[a_offset], lda, &tau[1], &c__[
		c_offset], ldc, &work[1], &iinfo);
    } else {

/*        Use blocked code */

	if (left && notran || ! left && ! notran) {
	    i1 = 1;
	    i2 = *k;
	    i3 = nb;
	} else {
	    i1 = (*k - 1) / nb * nb + 1;
	    i2 = 1;
	    i3 = -nb;
	}

	if (left) {
	    ni = *n;
	} else {
	    mi = *m;
	}

	i__1 = i2;
	i__2 = i3;
	for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MIN */
	    i__4 = nb, i__5 = *k - i__ + 1;
	    ib = min(i__4,i__5);

/*           Form the triangular factor of the block reflector   
             H = H(i+ib-1) . . . H(i+1) H(i) */

	    i__4 = nq - *k + i__ + ib - 1;
	    igraphdlarft_("Backward", "Columnwise", &i__4, &ib, &a[i__ * a_dim1 + 1]
		    , lda, &tau[i__], t, &c__65);
	    if (left) {

/*              H or H**T is applied to C(1:m-k+i+ib-1,1:n) */

		mi = *m - *k + i__ + ib - 1;
	    } else {

/*              H or H**T is applied to C(1:m,1:n-k+i+ib-1) */

		ni = *n - *k + i__ + ib - 1;
	    }

/*           Apply H or H**T */

	    igraphdlarfb_(side, trans, "Backward", "Columnwise", &mi, &ni, &ib, &a[
		    i__ * a_dim1 + 1], lda, t, &c__65, &c__[c_offset], ldc, &
		    work[1], &ldwork);
/* L10: */
	}
    }
    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DORMQL */

} /* igraphdormql_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dormqr.c0000644000175100001710000002633600000000000024064 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__2 = 2;
static integer c__65 = 65;

/* > \brief \b DORMQR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORMQR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,   
                            WORK, LWORK, INFO )   

         CHARACTER          SIDE, TRANS   
         INTEGER            INFO, K, LDA, LDC, LWORK, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORMQR overwrites the general real M-by-N matrix C with   
   >   
   >                 SIDE = 'L'     SIDE = 'R'   
   > TRANS = 'N':      Q * C          C * Q   
   > TRANS = 'T':      Q**T * C       C * Q**T   
   >   
   > where Q is a real orthogonal matrix defined as the product of k   
   > elementary reflectors   
   >   
   >       Q = H(1) H(2) . . . H(k)   
   >   
   > as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N   
   > if SIDE = 'R'.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left;   
   >          = 'R': apply Q or Q**T from the Right.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N':  No transpose, apply Q;   
   >          = 'T':  Transpose, apply Q**T.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >          The number of elementary reflectors whose product defines   
   >          the matrix Q.   
   >          If SIDE = 'L', M >= K >= 0;   
   >          if SIDE = 'R', N >= K >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,K)   
   >          The i-th column must contain the vector which defines the   
   >          elementary reflector H(i), for i = 1,2,...,k, as returned by   
   >          DGEQRF in the first k columns of its array argument A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          If SIDE = 'L', LDA >= max(1,M);   
   >          if SIDE = 'R', LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (K)   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DGEQRF.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the M-by-N matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   
   >          If SIDE = 'L', LWORK >= max(1,N);   
   >          if SIDE = 'R', LWORK >= max(1,M).   
   >          For optimum performance LWORK >= N*NB if SIDE = 'L', and   
   >          LWORK >= M*NB if SIDE = 'R', where NB is the optimal   
   >          blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdormqr_(char *side, char *trans, integer *m, integer *n, 
	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
	c__, integer *ldc, doublereal *work, integer *lwork, integer *info)
{
    /* System generated locals */
    address a__1[2];
    integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2, i__3[2], i__4, 
	    i__5;
    char ch__1[2];

    /* Builtin functions   
       Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);

    /* Local variables */
    integer i__;
    doublereal t[4160]	/* was [65][64] */;
    integer i1, i2, i3, ib, ic, jc, nb, mi, ni, nq, nw, iws;
    logical left;
    extern logical igraphlsame_(char *, char *);
    integer nbmin, iinfo;
    extern /* Subroutine */ int igraphdorm2r_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdlarfb_(char 
	    *, char *, char *, char *, integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdlarft_(char *, char *, integer *, integer *, doublereal 
	    *, integer *, doublereal *, doublereal *, integer *), igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    logical notran;
    integer ldwork, lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    left = igraphlsame_(side, "L");
    notran = igraphlsame_(trans, "N");
    lquery = *lwork == -1;

/*     NQ is the order of Q and NW is the minimum dimension of WORK */

    if (left) {
	nq = *m;
	nw = *n;
    } else {
	nq = *n;
	nw = *m;
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! notran && ! igraphlsame_(trans, "T")) {
	*info = -2;
    } else if (*m < 0) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*k < 0 || *k > nq) {
	*info = -5;
    } else if (*lda < max(1,nq)) {
	*info = -7;
    } else if (*ldc < max(1,*m)) {
	*info = -10;
    } else if (*lwork < max(1,nw) && ! lquery) {
	*info = -12;
    }

    if (*info == 0) {

/*        Determine the block size.  NB may be at most NBMAX, where NBMAX   
          is used to define the local array T.   

   Computing MIN   
   Writing concatenation */
	i__3[0] = 1, a__1[0] = side;
	i__3[1] = 1, a__1[1] = trans;
	s_cat(ch__1, a__1, i__3, &c__2, (ftnlen)2);
	i__1 = 64, i__2 = igraphilaenv_(&c__1, "DORMQR", ch__1, m, n, k, &c_n1, (
		ftnlen)6, (ftnlen)2);
	nb = min(i__1,i__2);
	lwkopt = max(1,nw) * nb;
	work[1] = (doublereal) lwkopt;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DORMQR", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0 || *k == 0) {
	work[1] = 1.;
	return 0;
    }

    nbmin = 2;
    ldwork = nw;
    if (nb > 1 && nb < *k) {
	iws = nw * nb;
	if (*lwork < iws) {
	    nb = *lwork / ldwork;
/* Computing MAX   
   Writing concatenation */
	    i__3[0] = 1, a__1[0] = side;
	    i__3[1] = 1, a__1[1] = trans;
	    s_cat(ch__1, a__1, i__3, &c__2, (ftnlen)2);
	    i__1 = 2, i__2 = igraphilaenv_(&c__2, "DORMQR", ch__1, m, n, k, &c_n1, (
		    ftnlen)6, (ftnlen)2);
	    nbmin = max(i__1,i__2);
	}
    } else {
	iws = nw;
    }

    if (nb < nbmin || nb >= *k) {

/*        Use unblocked code */

	igraphdorm2r_(side, trans, m, n, k, &a[a_offset], lda, &tau[1], &c__[
		c_offset], ldc, &work[1], &iinfo);
    } else {

/*        Use blocked code */

	if (left && ! notran || ! left && notran) {
	    i1 = 1;
	    i2 = *k;
	    i3 = nb;
	} else {
	    i1 = (*k - 1) / nb * nb + 1;
	    i2 = 1;
	    i3 = -nb;
	}

	if (left) {
	    ni = *n;
	    jc = 1;
	} else {
	    mi = *m;
	    ic = 1;
	}

	i__1 = i2;
	i__2 = i3;
	for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MIN */
	    i__4 = nb, i__5 = *k - i__ + 1;
	    ib = min(i__4,i__5);

/*           Form the triangular factor of the block reflector   
             H = H(i) H(i+1) . . . H(i+ib-1) */

	    i__4 = nq - i__ + 1;
	    igraphdlarft_("Forward", "Columnwise", &i__4, &ib, &a[i__ + i__ * 
		    a_dim1], lda, &tau[i__], t, &c__65)
		    ;
	    if (left) {

/*              H or H**T is applied to C(i:m,1:n) */

		mi = *m - i__ + 1;
		ic = i__;
	    } else {

/*              H or H**T is applied to C(1:m,i:n) */

		ni = *n - i__ + 1;
		jc = i__;
	    }

/*           Apply H or H**T */

	    igraphdlarfb_(side, trans, "Forward", "Columnwise", &mi, &ni, &ib, &a[
		    i__ + i__ * a_dim1], lda, t, &c__65, &c__[ic + jc * 
		    c_dim1], ldc, &work[1], &ldwork);
/* L10: */
	}
    }
    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DORMQR */

} /* igraphdormqr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dormtr.c0000644000175100001710000002551200000000000024062 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__2 = 2;

/* > \brief \b DORMTR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DORMTR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DORMTR( SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC,   
                            WORK, LWORK, INFO )   

         CHARACTER          SIDE, TRANS, UPLO   
         INTEGER            INFO, LDA, LDC, LWORK, M, N   
         DOUBLE PRECISION   A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DORMTR overwrites the general real M-by-N matrix C with   
   >   
   >                 SIDE = 'L'     SIDE = 'R'   
   > TRANS = 'N':      Q * C          C * Q   
   > TRANS = 'T':      Q**T * C       C * Q**T   
   >   
   > where Q is a real orthogonal matrix of order nq, with nq = m if   
   > SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of   
   > nq-1 elementary reflectors, as returned by DSYTRD:   
   >   
   > if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);   
   >   
   > if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'L': apply Q or Q**T from the Left;   
   >          = 'R': apply Q or Q**T from the Right.   
   > \endverbatim   
   >   
   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          = 'U': Upper triangle of A contains elementary reflectors   
   >                 from DSYTRD;   
   >          = 'L': Lower triangle of A contains elementary reflectors   
   >                 from DSYTRD.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >          = 'N':  No transpose, apply Q;   
   >          = 'T':  Transpose, apply Q**T.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension   
   >                               (LDA,M) if SIDE = 'L'   
   >                               (LDA,N) if SIDE = 'R'   
   >          The vectors which define the elementary reflectors, as   
   >          returned by DSYTRD.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.   
   >          LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'.   
   > \endverbatim   
   >   
   > \param[in] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension   
   >                               (M-1) if SIDE = 'L'   
   >                               (N-1) if SIDE = 'R'   
   >          TAU(i) must contain the scalar factor of the elementary   
   >          reflector H(i), as returned by DSYTRD.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the M-by-N matrix C.   
   >          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   
   >          If SIDE = 'L', LWORK >= max(1,N);   
   >          if SIDE = 'R', LWORK >= max(1,M).   
   >          For optimum performance LWORK >= N*NB if SIDE = 'L', and   
   >          LWORK >= M*NB if SIDE = 'R', where NB is the optimal   
   >          blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdormtr_(char *side, char *uplo, char *trans, integer *m, 
	integer *n, doublereal *a, integer *lda, doublereal *tau, doublereal *
	c__, integer *ldc, doublereal *work, integer *lwork, integer *info)
{
    /* System generated locals */
    address a__1[2];
    integer a_dim1, a_offset, c_dim1, c_offset, i__1[2], i__2, i__3;
    char ch__1[2];

    /* Builtin functions   
       Subroutine */ int s_cat(char *, char **, integer *, integer *, ftnlen);

    /* Local variables */
    integer i1, i2, nb, mi, ni, nq, nw;
    logical left;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    logical upper;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphdormql_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *, integer *), 
	    igraphdormqr_(char *, char *, integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *, integer *);
    integer lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input arguments   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --tau;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;
    --work;

    /* Function Body */
    *info = 0;
    left = igraphlsame_(side, "L");
    upper = igraphlsame_(uplo, "U");
    lquery = *lwork == -1;

/*     NQ is the order of Q and NW is the minimum dimension of WORK */

    if (left) {
	nq = *m;
	nw = *n;
    } else {
	nq = *n;
	nw = *m;
    }
    if (! left && ! igraphlsame_(side, "R")) {
	*info = -1;
    } else if (! upper && ! igraphlsame_(uplo, "L")) {
	*info = -2;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T")) {
	*info = -3;
    } else if (*m < 0) {
	*info = -4;
    } else if (*n < 0) {
	*info = -5;
    } else if (*lda < max(1,nq)) {
	*info = -7;
    } else if (*ldc < max(1,*m)) {
	*info = -10;
    } else if (*lwork < max(1,nw) && ! lquery) {
	*info = -12;
    }

    if (*info == 0) {
	if (upper) {
	    if (left) {
/* Writing concatenation */
		i__1[0] = 1, a__1[0] = side;
		i__1[1] = 1, a__1[1] = trans;
		s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
		i__2 = *m - 1;
		i__3 = *m - 1;
		nb = igraphilaenv_(&c__1, "DORMQL", ch__1, &i__2, n, &i__3, &c_n1, (
			ftnlen)6, (ftnlen)2);
	    } else {
/* Writing concatenation */
		i__1[0] = 1, a__1[0] = side;
		i__1[1] = 1, a__1[1] = trans;
		s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
		i__2 = *n - 1;
		i__3 = *n - 1;
		nb = igraphilaenv_(&c__1, "DORMQL", ch__1, m, &i__2, &i__3, &c_n1, (
			ftnlen)6, (ftnlen)2);
	    }
	} else {
	    if (left) {
/* Writing concatenation */
		i__1[0] = 1, a__1[0] = side;
		i__1[1] = 1, a__1[1] = trans;
		s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
		i__2 = *m - 1;
		i__3 = *m - 1;
		nb = igraphilaenv_(&c__1, "DORMQR", ch__1, &i__2, n, &i__3, &c_n1, (
			ftnlen)6, (ftnlen)2);
	    } else {
/* Writing concatenation */
		i__1[0] = 1, a__1[0] = side;
		i__1[1] = 1, a__1[1] = trans;
		s_cat(ch__1, a__1, i__1, &c__2, (ftnlen)2);
		i__2 = *n - 1;
		i__3 = *n - 1;
		nb = igraphilaenv_(&c__1, "DORMQR", ch__1, m, &i__2, &i__3, &c_n1, (
			ftnlen)6, (ftnlen)2);
	    }
	}
	lwkopt = max(1,nw) * nb;
	work[1] = (doublereal) lwkopt;
    }

    if (*info != 0) {
	i__2 = -(*info);
	igraphxerbla_("DORMTR", &i__2, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*m == 0 || *n == 0 || nq == 1) {
	work[1] = 1.;
	return 0;
    }

    if (left) {
	mi = *m - 1;
	ni = *n;
    } else {
	mi = *m;
	ni = *n - 1;
    }

    if (upper) {

/*        Q was determined by a call to DSYTRD with UPLO = 'U' */

	i__2 = nq - 1;
	igraphdormql_(side, trans, &mi, &ni, &i__2, &a[(a_dim1 << 1) + 1], lda, &
		tau[1], &c__[c_offset], ldc, &work[1], lwork, &iinfo);
    } else {

/*        Q was determined by a call to DSYTRD with UPLO = 'L' */

	if (left) {
	    i1 = 2;
	    i2 = 1;
	} else {
	    i1 = 1;
	    i2 = 2;
	}
	i__2 = nq - 1;
	igraphdormqr_(side, trans, &mi, &ni, &i__2, &a[a_dim1 + 2], lda, &tau[1], &
		c__[i1 + i2 * c_dim1], ldc, &work[1], lwork, &iinfo);
    }
    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DORMTR */

} /* igraphdormtr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dpotf2.c0000644000175100001710000001722400000000000023752 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b10 = -1.;
static doublereal c_b12 = 1.;

/* > \brief \b DPOTF2 computes the Cholesky factorization of a symmetric/Hermitian positive definite matrix (u
nblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DPOTF2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DPOTF2( UPLO, N, A, LDA, INFO )   

         CHARACTER          UPLO   
         INTEGER            INFO, LDA, N   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DPOTF2 computes the Cholesky factorization of a real symmetric   
   > positive definite matrix A.   
   >   
   > The factorization has the form   
   >    A = U**T * U ,  if UPLO = 'U', or   
   >    A = L  * L**T,  if UPLO = 'L',   
   > where U is an upper triangular matrix and L is lower triangular.   
   >   
   > This is the unblocked version of the algorithm, calling Level 2 BLAS.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies whether the upper or lower triangular part of the   
   >          symmetric matrix A is stored.   
   >          = 'U':  Upper triangular   
   >          = 'L':  Lower triangular   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the leading   
   >          n by n upper triangular part of A contains the upper   
   >          triangular part of the matrix A, and the strictly lower   
   >          triangular part of A is not referenced.  If UPLO = 'L', the   
   >          leading n by n lower triangular part of A contains the lower   
   >          triangular part of the matrix A, and the strictly upper   
   >          triangular part of A is not referenced.   
   >   
   >          On exit, if INFO = 0, the factor U or L from the Cholesky   
   >          factorization A = U**T *U  or A = L*L**T.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -k, the k-th argument had an illegal value   
   >          > 0: if INFO = k, the leading minor of order k is not   
   >               positive definite, and the factorization could not be   
   >               completed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doublePOcomputational   

    =====================================================================   
   Subroutine */ int igraphdpotf2_(char *uplo, integer *n, doublereal *a, integer *
	lda, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;
    doublereal d__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer j;
    doublereal ajj;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    logical upper;
    extern logical igraphdisnan_(doublereal *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    *info = 0;
    upper = igraphlsame_(uplo, "U");
    if (! upper && ! igraphlsame_(uplo, "L")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DPOTF2", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

    if (upper) {

/*        Compute the Cholesky factorization A = U**T *U. */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {

/*           Compute U(J,J) and test for non-positive-definiteness. */

	    i__2 = j - 1;
	    ajj = a[j + j * a_dim1] - igraphddot_(&i__2, &a[j * a_dim1 + 1], &c__1, 
		    &a[j * a_dim1 + 1], &c__1);
	    if (ajj <= 0. || igraphdisnan_(&ajj)) {
		a[j + j * a_dim1] = ajj;
		goto L30;
	    }
	    ajj = sqrt(ajj);
	    a[j + j * a_dim1] = ajj;

/*           Compute elements J+1:N of row J. */

	    if (j < *n) {
		i__2 = j - 1;
		i__3 = *n - j;
		igraphdgemv_("Transpose", &i__2, &i__3, &c_b10, &a[(j + 1) * a_dim1 
			+ 1], lda, &a[j * a_dim1 + 1], &c__1, &c_b12, &a[j + (
			j + 1) * a_dim1], lda);
		i__2 = *n - j;
		d__1 = 1. / ajj;
		igraphdscal_(&i__2, &d__1, &a[j + (j + 1) * a_dim1], lda);
	    }
/* L10: */
	}
    } else {

/*        Compute the Cholesky factorization A = L*L**T. */

	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {

/*           Compute L(J,J) and test for non-positive-definiteness. */

	    i__2 = j - 1;
	    ajj = a[j + j * a_dim1] - igraphddot_(&i__2, &a[j + a_dim1], lda, &a[j 
		    + a_dim1], lda);
	    if (ajj <= 0. || igraphdisnan_(&ajj)) {
		a[j + j * a_dim1] = ajj;
		goto L30;
	    }
	    ajj = sqrt(ajj);
	    a[j + j * a_dim1] = ajj;

/*           Compute elements J+1:N of column J. */

	    if (j < *n) {
		i__2 = *n - j;
		i__3 = j - 1;
		igraphdgemv_("No transpose", &i__2, &i__3, &c_b10, &a[j + 1 + 
			a_dim1], lda, &a[j + a_dim1], lda, &c_b12, &a[j + 1 + 
			j * a_dim1], &c__1);
		i__2 = *n - j;
		d__1 = 1. / ajj;
		igraphdscal_(&i__2, &d__1, &a[j + 1 + j * a_dim1], &c__1);
	    }
/* L20: */
	}
    }
    goto L40;

L30:
    *info = j;

L40:
    return 0;

/*     End of DPOTF2 */

} /* igraphdpotf2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dpotrf.c0000644000175100001710000002112400000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static doublereal c_b13 = -1.;
static doublereal c_b14 = 1.;

/* > \brief \b DPOTRF   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DPOTRF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DPOTRF( UPLO, N, A, LDA, INFO )   

         CHARACTER          UPLO   
         INTEGER            INFO, LDA, N   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DPOTRF computes the Cholesky factorization of a real symmetric   
   > positive definite matrix A.   
   >   
   > The factorization has the form   
   >    A = U**T * U,  if UPLO = 'U', or   
   >    A = L  * L**T,  if UPLO = 'L',   
   > where U is an upper triangular matrix and L is lower triangular.   
   >   
   > This is the block version of the algorithm, calling Level 3 BLAS.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          = 'U':  Upper triangle of A is stored;   
   >          = 'L':  Lower triangle of A is stored.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the leading   
   >          N-by-N upper triangular part of A contains the upper   
   >          triangular part of the matrix A, and the strictly lower   
   >          triangular part of A is not referenced.  If UPLO = 'L', the   
   >          leading N-by-N lower triangular part of A contains the lower   
   >          triangular part of the matrix A, and the strictly upper   
   >          triangular part of A is not referenced.   
   >   
   >          On exit, if INFO = 0, the factor U or L from the Cholesky   
   >          factorization A = U**T*U or A = L*L**T.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  if INFO = i, the leading minor of order i is not   
   >                positive definite, and the factorization could not be   
   >                completed.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doublePOcomputational   

    =====================================================================   
   Subroutine */ int igraphdpotrf_(char *uplo, integer *n, doublereal *a, integer *
	lda, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3, i__4;

    /* Local variables */
    integer j, jb, nb;
    extern /* Subroutine */ int igraphdgemm_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdtrsm_(char *, char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, integer *, 
	    doublereal *, integer *);
    logical upper;
    extern /* Subroutine */ int igraphdsyrk_(char *, char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
	     integer *), igraphdpotf2_(char *, integer *, 
	    doublereal *, integer *, integer *), igraphxerbla_(char *, 
	    integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    *info = 0;
    upper = igraphlsame_(uplo, "U");
    if (! upper && ! igraphlsame_(uplo, "L")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DPOTRF", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

/*     Determine the block size for this environment. */

    nb = igraphilaenv_(&c__1, "DPOTRF", uplo, n, &c_n1, &c_n1, &c_n1, (ftnlen)6, (
	    ftnlen)1);
    if (nb <= 1 || nb >= *n) {

/*        Use unblocked code. */

	igraphdpotf2_(uplo, n, &a[a_offset], lda, info);
    } else {

/*        Use blocked code. */

	if (upper) {

/*           Compute the Cholesky factorization A = U**T*U. */

	    i__1 = *n;
	    i__2 = nb;
	    for (j = 1; i__2 < 0 ? j >= i__1 : j <= i__1; j += i__2) {

/*              Update and factorize the current diagonal block and test   
                for non-positive-definiteness.   

   Computing MIN */
		i__3 = nb, i__4 = *n - j + 1;
		jb = min(i__3,i__4);
		i__3 = j - 1;
		igraphdsyrk_("Upper", "Transpose", &jb, &i__3, &c_b13, &a[j * 
			a_dim1 + 1], lda, &c_b14, &a[j + j * a_dim1], lda);
		igraphdpotf2_("Upper", &jb, &a[j + j * a_dim1], lda, info);
		if (*info != 0) {
		    goto L30;
		}
		if (j + jb <= *n) {

/*                 Compute the current block row. */

		    i__3 = *n - j - jb + 1;
		    i__4 = j - 1;
		    igraphdgemm_("Transpose", "No transpose", &jb, &i__3, &i__4, &
			    c_b13, &a[j * a_dim1 + 1], lda, &a[(j + jb) * 
			    a_dim1 + 1], lda, &c_b14, &a[j + (j + jb) * 
			    a_dim1], lda);
		    i__3 = *n - j - jb + 1;
		    igraphdtrsm_("Left", "Upper", "Transpose", "Non-unit", &jb, &
			    i__3, &c_b14, &a[j + j * a_dim1], lda, &a[j + (j 
			    + jb) * a_dim1], lda);
		}
/* L10: */
	    }

	} else {

/*           Compute the Cholesky factorization A = L*L**T. */

	    i__2 = *n;
	    i__1 = nb;
	    for (j = 1; i__1 < 0 ? j >= i__2 : j <= i__2; j += i__1) {

/*              Update and factorize the current diagonal block and test   
                for non-positive-definiteness.   

   Computing MIN */
		i__3 = nb, i__4 = *n - j + 1;
		jb = min(i__3,i__4);
		i__3 = j - 1;
		igraphdsyrk_("Lower", "No transpose", &jb, &i__3, &c_b13, &a[j + 
			a_dim1], lda, &c_b14, &a[j + j * a_dim1], lda);
		igraphdpotf2_("Lower", &jb, &a[j + j * a_dim1], lda, info);
		if (*info != 0) {
		    goto L30;
		}
		if (j + jb <= *n) {

/*                 Compute the current block column. */

		    i__3 = *n - j - jb + 1;
		    i__4 = j - 1;
		    igraphdgemm_("No transpose", "Transpose", &i__3, &jb, &i__4, &
			    c_b13, &a[j + jb + a_dim1], lda, &a[j + a_dim1], 
			    lda, &c_b14, &a[j + jb + j * a_dim1], lda);
		    i__3 = *n - j - jb + 1;
		    igraphdtrsm_("Right", "Lower", "Transpose", "Non-unit", &i__3, &
			    jb, &c_b14, &a[j + j * a_dim1], lda, &a[j + jb + 
			    j * a_dim1], lda);
		}
/* L20: */
	    }
	}
    }
    goto L40;

L30:
    *info = *info + j - 1;

L40:
    return 0;

/*     End of DPOTRF */

} /* igraphdpotrf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/drot.c0000644000175100001710000000766100000000000023530 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DROT   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DROT(N,DX,INCX,DY,INCY,C,S)   

         DOUBLE PRECISION C,S   
         INTEGER INCX,INCY,N   
         DOUBLE PRECISION DX(*),DY(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DROT applies a plane rotation.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in,out] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   
   >   
   > \param[in,out] DY   
   > \verbatim   
   >          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >         storage spacing between elements of DY   
   > \endverbatim   
   >   
   > \param[in] C   
   > \verbatim   
   >          C is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] S   
   > \verbatim   
   >          S is DOUBLE PRECISION   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdrot_(integer *n, doublereal *dx, integer *incx, 
	doublereal *dy, integer *incy, doublereal *c__, doublereal *s)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    integer i__, ix, iy;
    doublereal dtemp;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dy;
    --dx;

    /* Function Body */
    if (*n <= 0) {
	return 0;
    }
    if (*incx == 1 && *incy == 1) {

/*       code for both increments equal to 1 */

	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dtemp = *c__ * dx[i__] + *s * dy[i__];
	    dy[i__] = *c__ * dy[i__] - *s * dx[i__];
	    dx[i__] = dtemp;
	}
    } else {

/*       code for unequal increments or equal increments not equal   
           to 1 */

	ix = 1;
	iy = 1;
	if (*incx < 0) {
	    ix = (-(*n) + 1) * *incx + 1;
	}
	if (*incy < 0) {
	    iy = (-(*n) + 1) * *incy + 1;
	}
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dtemp = *c__ * dx[ix] + *s * dy[iy];
	    dy[iy] = *c__ * dy[iy] - *s * dx[ix];
	    dx[ix] = dtemp;
	    ix += *incx;
	    iy += *incy;
	}
    }
    return 0;
} /* igraphdrot_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsaitr.c0000644000175100001710000010106500000000000024037 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static logical c_false = FALSE_;
static doublereal c_b24 = 1.;
static doublereal c_b49 = 0.;
static doublereal c_b57 = -1.;
static integer c__2 = 2;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsaitr   

   \Description:   
    Reverse communication interface for applying NP additional steps to   
    a K step symmetric Arnoldi factorization.   

    Input:  OP*V_{k}  -  V_{k}*H = r_{k}*e_{k}^T   

            with (V_{k}^T)*B*V_{k} = I, (V_{k}^T)*B*r_{k} = 0.   

    Output: OP*V_{k+p}  -  V_{k+p}*H = r_{k+p}*e_{k+p}^T   

            with (V_{k+p}^T)*B*V_{k+p} = I, (V_{k+p}^T)*B*r_{k+p} = 0.   

    where OP and B are as in dsaupd.  The B-norm of r_{k+p} is also   
    computed and returned.   

   \Usage:   
    call dsaitr   
       ( IDO, BMAT, N, K, NP, MODE, RESID, RNORM, V, LDV, H, LDH,   
         IPNTR, WORKD, INFO )   

   \Arguments   
    IDO     Integer.  (INPUT/OUTPUT)   
            Reverse communication flag.   
            -------------------------------------------------------------   
            IDO =  0: first call to the reverse communication interface   
            IDO = -1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y.   
                      This is for the restart phase to force the new   
                      starting vector into the range of OP.   
            IDO =  1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y,   
                      IPNTR(3) is the pointer into WORK for B * X.   
            IDO =  2: compute  Y = B * X  where   
                      IPNTR(1) is the pointer into WORK for X,   
                      IPNTR(2) is the pointer into WORK for Y.   
            IDO = 99: done   
            -------------------------------------------------------------   
            When the routine is used in the "shift-and-invert" mode, the   
            vector B * Q is already available and does not need to be   
            recomputed in forming OP * Q.   

    BMAT    Character*1.  (INPUT)   
            BMAT specifies the type of matrix B that defines the   
            semi-inner product for the operator OP.  See dsaupd.   
            B = 'I' -> standard eigenvalue problem A*x = lambda*x   
            B = 'G' -> generalized eigenvalue problem A*x = lambda*M*x   

    N       Integer.  (INPUT)   
            Dimension of the eigenproblem.   

    K       Integer.  (INPUT)   
            Current order of H and the number of columns of V.   

    NP      Integer.  (INPUT)   
            Number of additional Arnoldi steps to take.   

    MODE    Integer.  (INPUT)   
            Signifies which form for "OP". If MODE=2 then   
            a reduction in the number of B matrix vector multiplies   
            is possible since the B-norm of OP*x is equivalent to   
            the inv(B)-norm of A*x.   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            On INPUT:  RESID contains the residual vector r_{k}.   
            On OUTPUT: RESID contains the residual vector r_{k+p}.   

    RNORM   Double precision scalar.  (INPUT/OUTPUT)   
            On INPUT the B-norm of r_{k}.   
            On OUTPUT the B-norm of the updated residual r_{k+p}.   

    V       Double precision N by K+NP array.  (INPUT/OUTPUT)   
            On INPUT:  V contains the Arnoldi vectors in the first K   
            columns.   
            On OUTPUT: V contains the new NP Arnoldi vectors in the next   
            NP columns.  The first K columns are unchanged.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (K+NP) by 2 array.  (INPUT/OUTPUT)   
            H is used to store the generated symmetric tridiagonal matrix   
            with the subdiagonal in the first column starting at H(2,1)   
            and the main diagonal in the second column.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    IPNTR   Integer array of length 3.  (OUTPUT)   
            Pointer to mark the starting locations in the WORK for   
            vectors used by the Arnoldi iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X.   
            IPNTR(2): pointer to the current result vector Y.   
            IPNTR(3): pointer to the vector B * X when used in the   
                      shift-and-invert mode.  X is the current operand.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (REVERSE COMMUNICATION)   
            Distributed array to be used in the basic Arnoldi iteration   
            for reverse communication.  The calling program should not   
            use WORKD as temporary workspace during the iteration !!!!!!   
            On INPUT, WORKD(1:N) = B*RESID where RESID is associated   
            with the K step Arnoldi factorization. Used to save some   
            computation at the first step.   
            On OUTPUT, WORKD(1:N) = B*RESID where RESID is associated   
            with the K+NP step Arnoldi factorization.   

    INFO    Integer.  (OUTPUT)   
            = 0: Normal exit.   
            > 0: Size of an invariant subspace of OP is found that is   
                 less than K + NP.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dgetv0  ARPACK routine to generate the initial vector.   
       ivout   ARPACK utility routine that prints integers.   
       dmout   ARPACK utility routine that prints matrices.   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   
       dlascl  LAPACK routine for careful scaling of a matrix.   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       daxpy   Level 1 BLAS that computes a vector triad.   
       dscal   Level 1 BLAS that scales a vector.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/93: Version ' 2.4'   

   \SCCS Information: @(#)   
   FILE: saitr.F   SID: 2.6   DATE OF SID: 8/28/96   RELEASE: 2   

   \Remarks   
    The algorithm implemented is:   

    restart = .false.   
    Given V_{k} = [v_{1}, ..., v_{k}], r_{k};   
    r_{k} contains the initial residual vector even for k = 0;   
    Also assume that rnorm = || B*r_{k} || and B*r_{k} are already   
    computed by the calling program.   

    betaj = rnorm ; p_{k+1} = B*r_{k} ;   
    For  j = k+1, ..., k+np  Do   
       1) if ( betaj < tol ) stop or restart depending on j.   
          if ( restart ) generate a new starting vector.   
       2) v_{j} = r(j-1)/betaj;  V_{j} = [V_{j-1}, v_{j}];   
          p_{j} = p_{j}/betaj   
       3) r_{j} = OP*v_{j} where OP is defined as in dsaupd   
          For shift-invert mode p_{j} = B*v_{j} is already available.   
          wnorm = || OP*v_{j} ||   
       4) Compute the j-th step residual vector.   
          w_{j} =  V_{j}^T * B * OP * v_{j}   
          r_{j} =  OP*v_{j} - V_{j} * w_{j}   
          alphaj <- j-th component of w_{j}   
          rnorm = || r_{j} ||   
          betaj+1 = rnorm   
          If (rnorm > 0.717*wnorm) accept step and go back to 1)   
       5) Re-orthogonalization step:   
          s = V_{j}'*B*r_{j}   
          r_{j} = r_{j} - V_{j}*s;  rnorm1 = || r_{j} ||   
          alphaj = alphaj + s_{j};   
       6) Iterative refinement step:   
          If (rnorm1 > 0.717*rnorm) then   
             rnorm = rnorm1   
             accept step and go back to 1)   
          Else   
             rnorm = rnorm1   
             If this is the first time in step 6), go to 5)   
             Else r_{j} lies in the span of V_{j} numerically.   
                Set r_{j} = 0 and rnorm = 0; go to 1)   
          EndIf   
    End Do   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsaitr_(integer *ido, char *bmat, integer *n, integer *k,
	 integer *np, integer *mode, doublereal *resid, doublereal *rnorm, 
	doublereal *v, integer *ldv, doublereal *h__, integer *ldh, integer *
	ipntr, doublereal *workd, integer *info)
{
    /* Initialized data */

    IGRAPH_F77_SAVE logical first = TRUE_;

    /* System generated locals */
    integer h_dim1, h_offset, v_dim1, v_offset, i__1;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__;
    IGRAPH_F77_SAVE integer j;
    IGRAPH_F77_SAVE real t0, t1, t2, t3, t4, t5;
    integer jj;
    IGRAPH_F77_SAVE integer ipj, irj;
    integer nbx = 0;
    IGRAPH_F77_SAVE integer ivj;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE integer ierr, iter;
    integer nopx = 0;
    IGRAPH_F77_SAVE integer itry;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    doublereal temp1;
    IGRAPH_F77_SAVE logical orth1, orth2, step3, step4;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdgemv_(char *, integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *);
    integer infol;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    doublereal xtemp[2];
    real tmvbx = 0;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen);
    IGRAPH_F77_SAVE doublereal wnorm;
    extern /* Subroutine */ int igraphivout_(integer *, integer *, integer *, 
	    integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *, 
	    logical *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *);
    IGRAPH_F77_SAVE doublereal rnorm1;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *), igraphsecond_(real *);
    integer logfil;
    IGRAPH_F77_SAVE doublereal safmin;
    integer ndigit = 0, nitref = 0;
    real titref = 0;
    integer msaitr = 0;
    IGRAPH_F77_SAVE integer msglvl;
    real tsaitr = 0;
    integer nrorth = 0;
    IGRAPH_F77_SAVE logical rstart;
    integer nrstrt = 0;
    real tmvopx = 0;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %-----------------------%   
       | Local Array Arguments |   
       %-----------------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %-----------------%   
       | Data statements |   
       %-----------------%   

       Parameter adjustments */
    --workd;
    --resid;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    --ipntr;

    /* Function Body   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    if (first) {
	first = FALSE_;

/*        %--------------------------------%   
          | safmin = safe minimum is such  |   
          | that 1/sfmin does not overflow |   
          %--------------------------------% */

	safmin = igraphdlamch_("safmin");
    }

    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphsecond_(&t0);
	msglvl = msaitr;

/*        %------------------------------%   
          | Initial call to this routine |   
          %------------------------------% */

	*info = 0;
	step3 = FALSE_;
	step4 = FALSE_;
	rstart = FALSE_;
	orth1 = FALSE_;
	orth2 = FALSE_;

/*        %--------------------------------%   
          | Pointer to the current step of |   
          | the factorization to build     |   
          %--------------------------------% */

	j = *k + 1;

/*        %------------------------------------------%   
          | Pointers used for reverse communication  |   
          | when using WORKD.                        |   
          %------------------------------------------% */

	ipj = 1;
	irj = ipj + *n;
	ivj = irj + *n;
    }

/*     %-------------------------------------------------%   
       | When in reverse communication mode one of:      |   
       | STEP3, STEP4, ORTH1, ORTH2, RSTART              |   
       | will be .true.                                  |   
       | STEP3: return from computing OP*v_{j}.          |   
       | STEP4: return from computing B-norm of OP*v_{j} |   
       | ORTH1: return from computing B-norm of r_{j+1}  |   
       | ORTH2: return from computing B-norm of          |   
       |        correction to the residual vector.       |   
       | RSTART: return from OP computations needed by   |   
       |         dgetv0.                                 |   
       %-------------------------------------------------% */

    if (step3) {
	goto L50;
    }
    if (step4) {
	goto L60;
    }
    if (orth1) {
	goto L70;
    }
    if (orth2) {
	goto L90;
    }
    if (rstart) {
	goto L30;
    }

/*     %------------------------------%   
       | Else this is the first step. |   
       %------------------------------%   

       %--------------------------------------------------------------%   
       |                                                              |   
       |        A R N O L D I     I T E R A T I O N     L O O P       |   
       |                                                              |   
       | Note:  B*r_{j-1} is already in WORKD(1:N)=WORKD(IPJ:IPJ+N-1) |   
       %--------------------------------------------------------------% */

L1000:

    if (msglvl > 2) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_saitr: generating Arnoldi vect"
		"or no.", (ftnlen)37);
	igraphdvout_(&logfil, &c__1, rnorm, &ndigit, "_saitr: B-norm of the curren"
		"t residual =", (ftnlen)40);
    }

/*        %---------------------------------------------------------%   
          | Check for exact zero. Equivalent to determing whether a |   
          | j-step Arnoldi factorization is present.                |   
          %---------------------------------------------------------% */

    if (*rnorm > 0.) {
	goto L40;
    }

/*           %---------------------------------------------------%   
             | Invariant subspace found, generate a new starting |   
             | vector which is orthogonal to the current Arnoldi |   
             | basis and continue the iteration.                 |   
             %---------------------------------------------------% */

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_saitr: ****** restart at step "
		"******", (ftnlen)37);
    }

/*           %---------------------------------------------%   
             | ITRY is the loop variable that controls the |   
             | maximum amount of times that a restart is   |   
             | attempted. NRSTRT is used by stat.h         |   
             %---------------------------------------------% */

    ++nrstrt;
    itry = 1;
L20:
    rstart = TRUE_;
    *ido = 0;
L30:

/*           %--------------------------------------%   
             | If in reverse communication mode and |   
             | RSTART = .true. flow returns here.   |   
             %--------------------------------------% */

    igraphdgetv0_(ido, bmat, &itry, &c_false, n, &j, &v[v_offset], ldv, &resid[1], 
	    rnorm, &ipntr[1], &workd[1], &ierr);
    if (*ido != 99) {
	goto L9000;
    }
    if (ierr < 0) {
	++itry;
	if (itry <= 3) {
	    goto L20;
	}

/*              %------------------------------------------------%   
                | Give up after several restart attempts.        |   
                | Set INFO to the size of the invariant subspace |   
                | which spans OP and exit.                       |   
                %------------------------------------------------% */

	*info = j - 1;
	igraphsecond_(&t1);
	tsaitr += t1 - t0;
	*ido = 99;
	goto L9000;
    }

L40:

/*        %---------------------------------------------------------%   
          | STEP 2:  v_{j} = r_{j-1}/rnorm and p_{j} = p_{j}/rnorm  |   
          | Note that p_{j} = B*r_{j-1}. In order to avoid overflow |   
          | when reciprocating a small RNORM, test against lower    |   
          | machine bound.                                          |   
          %---------------------------------------------------------% */

    igraphdcopy_(n, &resid[1], &c__1, &v[j * v_dim1 + 1], &c__1);
    if (*rnorm >= safmin) {
	temp1 = 1. / *rnorm;
	igraphdscal_(n, &temp1, &v[j * v_dim1 + 1], &c__1);
	igraphdscal_(n, &temp1, &workd[ipj], &c__1);
    } else {

/*            %-----------------------------------------%   
              | To scale both v_{j} and p_{j} carefully |   
              | use LAPACK routine SLASCL               |   
              %-----------------------------------------% */

	igraphdlascl_("General", &i__, &i__, rnorm, &c_b24, n, &c__1, &v[j * v_dim1 
		+ 1], n, &infol);
	igraphdlascl_("General", &i__, &i__, rnorm, &c_b24, n, &c__1, &workd[ipj], 
		n, &infol);
    }

/*        %------------------------------------------------------%   
          | STEP 3:  r_{j} = OP*v_{j}; Note that p_{j} = B*v_{j} |   
          | Note that this is not quite yet r_{j}. See STEP 4    |   
          %------------------------------------------------------% */

    step3 = TRUE_;
    ++nopx;
    igraphsecond_(&t2);
    igraphdcopy_(n, &v[j * v_dim1 + 1], &c__1, &workd[ivj], &c__1);
    ipntr[1] = ivj;
    ipntr[2] = irj;
    ipntr[3] = ipj;
    *ido = 1;

/*        %-----------------------------------%   
          | Exit in order to compute OP*v_{j} |   
          %-----------------------------------% */

    goto L9000;
L50:

/*        %-----------------------------------%   
          | Back from reverse communication;  |   
          | WORKD(IRJ:IRJ+N-1) := OP*v_{j}.   |   
          %-----------------------------------% */

    igraphsecond_(&t3);
    tmvopx += t3 - t2;

    step3 = FALSE_;

/*        %------------------------------------------%   
          | Put another copy of OP*v_{j} into RESID. |   
          %------------------------------------------% */

    igraphdcopy_(n, &workd[irj], &c__1, &resid[1], &c__1);

/*        %-------------------------------------------%   
          | STEP 4:  Finish extending the symmetric   |   
          |          Arnoldi to length j. If MODE = 2 |   
          |          then B*OP = B*inv(B)*A = A and   |   
          |          we don't need to compute B*OP.   |   
          | NOTE: If MODE = 2 WORKD(IVJ:IVJ+N-1) is   |   
          | assumed to have A*v_{j}.                  |   
          %-------------------------------------------% */

    if (*mode == 2) {
	goto L65;
    }
    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	step4 = TRUE_;
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %-------------------------------------%   
             | Exit in order to compute B*OP*v_{j} |   
             %-------------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L60:

/*        %-----------------------------------%   
          | Back from reverse communication;  |   
          | WORKD(IPJ:IPJ+N-1) := B*OP*v_{j}. |   
          %-----------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    step4 = FALSE_;

/*        %-------------------------------------%   
          | The following is needed for STEP 5. |   
          | Compute the B-norm of OP*v_{j}.     |   
          %-------------------------------------% */

L65:
    if (*mode == 2) {

/*           %----------------------------------%   
             | Note that the B-norm of OP*v_{j} |   
             | is the inv(B)-norm of A*v_{j}.   |   
             %----------------------------------% */

	wnorm = igraphddot_(n, &resid[1], &c__1, &workd[ivj], &c__1);
	wnorm = sqrt((abs(wnorm)));
    } else if (*(unsigned char *)bmat == 'G') {
	wnorm = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	wnorm = sqrt((abs(wnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	wnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }

/*        %-----------------------------------------%   
          | Compute the j-th residual corresponding |   
          | to the j step factorization.            |   
          | Use Classical Gram Schmidt and compute: |   
          | w_{j} <-  V_{j}^T * B * OP * v_{j}      |   
          | r_{j} <-  OP*v_{j} - V_{j} * w_{j}      |   
          %-----------------------------------------%   


          %------------------------------------------%   
          | Compute the j Fourier coefficients w_{j} |   
          | WORKD(IPJ:IPJ+N-1) contains B*OP*v_{j}.  |   
          %------------------------------------------% */

    if (*mode != 2) {
	igraphdgemv_("T", n, &j, &c_b24, &v[v_offset], ldv, &workd[ipj], &c__1, &
		c_b49, &workd[irj], &c__1);
    } else if (*mode == 2) {
	igraphdgemv_("T", n, &j, &c_b24, &v[v_offset], ldv, &workd[ivj], &c__1, &
		c_b49, &workd[irj], &c__1);
    }

/*        %--------------------------------------%   
          | Orthgonalize r_{j} against V_{j}.    |   
          | RESID contains OP*v_{j}. See STEP 3. |   
          %--------------------------------------% */

    igraphdgemv_("N", n, &j, &c_b57, &v[v_offset], ldv, &workd[irj], &c__1, &c_b24, 
	    &resid[1], &c__1);

/*        %--------------------------------------%   
          | Extend H to have j rows and columns. |   
          %--------------------------------------% */

    h__[j + (h_dim1 << 1)] = workd[irj + j - 1];
    if (j == 1 || rstart) {
	h__[j + h_dim1] = 0.;
    } else {
	h__[j + h_dim1] = *rnorm;
    }
    igraphsecond_(&t4);

    orth1 = TRUE_;
    iter = 0;

    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[irj], &c__1);
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %----------------------------------%   
             | Exit in order to compute B*r_{j} |   
             %----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L70:

/*        %---------------------------------------------------%   
          | Back from reverse communication if ORTH1 = .true. |   
          | WORKD(IPJ:IPJ+N-1) := B*r_{j}.                    |   
          %---------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    orth1 = FALSE_;

/*        %------------------------------%   
          | Compute the B-norm of r_{j}. |   
          %------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	*rnorm = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	*rnorm = sqrt((abs(*rnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	*rnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }

/*        %-----------------------------------------------------------%   
          | STEP 5: Re-orthogonalization / Iterative refinement phase |   
          | Maximum NITER_ITREF tries.                                |   
          |                                                           |   
          |          s      = V_{j}^T * B * r_{j}                     |   
          |          r_{j}  = r_{j} - V_{j}*s                         |   
          |          alphaj = alphaj + s_{j}                          |   
          |                                                           |   
          | The stopping criteria used for iterative refinement is    |   
          | discussed in Parlett's book SEP, page 107 and in Gragg &  |   
          | Reichel ACM TOMS paper; Algorithm 686, Dec. 1990.         |   
          | Determine if we need to correct the residual. The goal is |   
          | to enforce ||v(:,1:j)^T * r_{j}|| .le. eps * || r_{j} ||  |   
          %-----------------------------------------------------------% */

    if (*rnorm > wnorm * .717f) {
	goto L100;
    }
    ++nrorth;

/*        %---------------------------------------------------%   
          | Enter the Iterative refinement phase. If further  |   
          | refinement is necessary, loop back here. The loop |   
          | variable is ITER. Perform a step of Classical     |   
          | Gram-Schmidt using all the Arnoldi vectors V_{j}  |   
          %---------------------------------------------------% */

L80:

    if (msglvl > 2) {
	xtemp[0] = wnorm;
	xtemp[1] = *rnorm;
	igraphdvout_(&logfil, &c__2, xtemp, &ndigit, "_saitr: re-orthonalization ;"
		" wnorm and rnorm are", (ftnlen)48);
    }

/*        %----------------------------------------------------%   
          | Compute V_{j}^T * B * r_{j}.                       |   
          | WORKD(IRJ:IRJ+J-1) = v(:,1:J)'*WORKD(IPJ:IPJ+N-1). |   
          %----------------------------------------------------% */

    igraphdgemv_("T", n, &j, &c_b24, &v[v_offset], ldv, &workd[ipj], &c__1, &c_b49, 
	    &workd[irj], &c__1);

/*        %----------------------------------------------%   
          | Compute the correction to the residual:      |   
          | r_{j} = r_{j} - V_{j} * WORKD(IRJ:IRJ+J-1).  |   
          | The correction to H is v(:,1:J)*H(1:J,1:J) + |   
          | v(:,1:J)*WORKD(IRJ:IRJ+J-1)*e'_j, but only   |   
          | H(j,j) is updated.                           |   
          %----------------------------------------------% */

    igraphdgemv_("N", n, &j, &c_b57, &v[v_offset], ldv, &workd[irj], &c__1, &c_b24, 
	    &resid[1], &c__1);

    if (j == 1 || rstart) {
	h__[j + h_dim1] = 0.;
    }
    h__[j + (h_dim1 << 1)] += workd[irj + j - 1];

    orth2 = TRUE_;
    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[irj], &c__1);
	ipntr[1] = irj;
	ipntr[2] = ipj;
	*ido = 2;

/*           %-----------------------------------%   
             | Exit in order to compute B*r_{j}. |   
             | r_{j} is the corrected residual.  |   
             %-----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[ipj], &c__1);
    }
L90:

/*        %---------------------------------------------------%   
          | Back from reverse communication if ORTH2 = .true. |   
          %---------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

/*        %-----------------------------------------------------%   
          | Compute the B-norm of the corrected residual r_{j}. |   
          %-----------------------------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	rnorm1 = igraphddot_(n, &resid[1], &c__1, &workd[ipj], &c__1);
	rnorm1 = sqrt((abs(rnorm1)));
    } else if (*(unsigned char *)bmat == 'I') {
	rnorm1 = igraphdnrm2_(n, &resid[1], &c__1);
    }

    if (msglvl > 0 && iter > 0) {
	igraphivout_(&logfil, &c__1, &j, &ndigit, "_saitr: Iterative refinement fo"
		"r Arnoldi residual", (ftnlen)49);
	if (msglvl > 2) {
	    xtemp[0] = *rnorm;
	    xtemp[1] = rnorm1;
	    igraphdvout_(&logfil, &c__2, xtemp, &ndigit, "_saitr: iterative refine"
		    "ment ; rnorm and rnorm1 are", (ftnlen)51);
	}
    }

/*        %-----------------------------------------%   
          | Determine if we need to perform another |   
          | step of re-orthogonalization.           |   
          %-----------------------------------------% */

    if (rnorm1 > *rnorm * .717f) {

/*           %--------------------------------%   
             | No need for further refinement |   
             %--------------------------------% */

	*rnorm = rnorm1;

    } else {

/*           %-------------------------------------------%   
             | Another step of iterative refinement step |   
             | is required. NITREF is used by stat.h     |   
             %-------------------------------------------% */

	++nitref;
	*rnorm = rnorm1;
	++iter;
	if (iter <= 1) {
	    goto L80;
	}

/*           %-------------------------------------------------%   
             | Otherwise RESID is numerically in the span of V |   
             %-------------------------------------------------% */

	i__1 = *n;
	for (jj = 1; jj <= i__1; ++jj) {
	    resid[jj] = 0.;
/* L95: */
	}
	*rnorm = 0.;
    }

/*        %----------------------------------------------%   
          | Branch here directly if iterative refinement |   
          | wasn't necessary or after at most NITER_REF  |   
          | steps of iterative refinement.               |   
          %----------------------------------------------% */

L100:

    rstart = FALSE_;
    orth2 = FALSE_;

    igraphsecond_(&t5);
    titref += t5 - t4;

/*        %----------------------------------------------------------%   
          | Make sure the last off-diagonal element is non negative  |   
          | If not perform a similarity transformation on H(1:j,1:j) |   
          | and scale v(:,j) by -1.                                  |   
          %----------------------------------------------------------% */

    if (h__[j + h_dim1] < 0.) {
	h__[j + h_dim1] = -h__[j + h_dim1];
	if (j < *k + *np) {
	    igraphdscal_(n, &c_b57, &v[(j + 1) * v_dim1 + 1], &c__1);
	} else {
	    igraphdscal_(n, &c_b57, &resid[1], &c__1);
	}
    }

/*        %------------------------------------%   
          | STEP 6: Update  j = j+1;  Continue |   
          %------------------------------------% */

    ++j;
    if (j > *k + *np) {
	igraphsecond_(&t1);
	tsaitr += t1 - t0;
	*ido = 99;

	if (msglvl > 1) {
	    i__1 = *k + *np;
	    igraphdvout_(&logfil, &i__1, &h__[(h_dim1 << 1) + 1], &ndigit, "_saitr"
		    ": main diagonal of matrix H of step K+NP.", (ftnlen)47);
	    if (*k + *np > 1) {
		i__1 = *k + *np - 1;
		igraphdvout_(&logfil, &i__1, &h__[h_dim1 + 2], &ndigit, "_saitr: s"
			"ub diagonal of matrix H of step K+NP.", (ftnlen)46);
	    }
	}

	goto L9000;
    }

/*        %--------------------------------------------------------%   
          | Loop back to extend the factorization by another step. |   
          %--------------------------------------------------------% */

    goto L1000;

/*     %---------------------------------------------------------------%   
       |                                                               |   
       |  E N D     O F     M A I N     I T E R A T I O N     L O O P  |   
       |                                                               |   
       %---------------------------------------------------------------% */

L9000:
    return 0;

/*     %---------------%   
       | End of dsaitr |   
       %---------------% */

} /* igraphdsaitr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsapps.c0000644000175100001710000005312400000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b4 = 0.;
static doublereal c_b5 = 1.;
static integer c__1 = 1;
static doublereal c_b20 = -1.;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsapps   

   \Description:   
    Given the Arnoldi factorization   

       A*V_{k} - V_{k}*H_{k} = r_{k+p}*e_{k+p}^T,   

    apply NP shifts implicitly resulting in   

       A*(V_{k}*Q) - (V_{k}*Q)*(Q^T* H_{k}*Q) = r_{k+p}*e_{k+p}^T * Q   

    where Q is an orthogonal matrix of order KEV+NP. Q is the product of   
    rotations resulting from the NP bulge chasing sweeps.  The updated Arnoldi   
    factorization becomes:   

       A*VNEW_{k} - VNEW_{k}*HNEW_{k} = rnew_{k}*e_{k}^T.   

   \Usage:   
    call dsapps   
       ( N, KEV, NP, SHIFT, V, LDV, H, LDH, RESID, Q, LDQ, WORKD )   

   \Arguments   
    N       Integer.  (INPUT)   
            Problem size, i.e. dimension of matrix A.   

    KEV     Integer.  (INPUT)   
            INPUT: KEV+NP is the size of the input matrix H.   
            OUTPUT: KEV is the size of the updated matrix HNEW.   

    NP      Integer.  (INPUT)   
            Number of implicit shifts to be applied.   

    SHIFT   Double precision array of length NP.  (INPUT)   
            The shifts to be applied.   

    V       Double precision N by (KEV+NP) array.  (INPUT/OUTPUT)   
            INPUT: V contains the current KEV+NP Arnoldi vectors.   
            OUTPUT: VNEW = V(1:n,1:KEV); the updated Arnoldi vectors   
            are in the first KEV columns of V.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (KEV+NP) by 2 array.  (INPUT/OUTPUT)   
            INPUT: H contains the symmetric tridiagonal matrix of the   
            Arnoldi factorization with the subdiagonal in the 1st column   
            starting at H(2,1) and the main diagonal in the 2nd column.   
            OUTPUT: H contains the updated tridiagonal matrix in the   
            KEV leading submatrix.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    RESID   Double precision array of length (N).  (INPUT/OUTPUT)   
            INPUT: RESID contains the the residual vector r_{k+p}.   
            OUTPUT: RESID is the updated residual vector rnew_{k}.   

    Q       Double precision KEV+NP by KEV+NP work array.  (WORKSPACE)   
            Work array used to accumulate the rotations during the bulge   
            chase sweep.   

    LDQ     Integer.  (INPUT)   
            Leading dimension of Q exactly as declared in the calling   
            program.   

    WORKD   Double precision work array of length 2*N.  (WORKSPACE)   
            Distributed array used in the application of the accumulated   
            orthogonal matrix Q.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   

   \Routines called:   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   
       dlartg  LAPACK Givens rotation construction routine.   
       dlacpy  LAPACK matrix copy routine.   
       dlaset  LAPACK matrix initialization routine.   
       dgemv   Level 2 BLAS routine for matrix vector multiplication.   
       daxpy   Level 1 BLAS that computes a vector triad.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       dscal   Level 1 BLAS that scales a vector.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/16/93: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: sapps.F   SID: 2.5   DATE OF SID: 4/19/96   RELEASE: 2   

   \Remarks   
    1. In this version, each shift is applied to all the subblocks of   
       the tridiagonal matrix H and not just to the submatrix that it   
       comes from. This routine assumes that the subdiagonal elements   
       of H that are stored in h(1:kev+np,1) are nonegative upon input   
       and enforce this condition upon output. This version incorporates   
       deflation. See code for documentation.   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsapps_(integer *n, integer *kev, integer *np, 
	doublereal *shift, doublereal *v, integer *ldv, doublereal *h__, 
	integer *ldh, doublereal *resid, doublereal *q, integer *ldq, 
	doublereal *workd)
{
    /* Initialized data */

    IGRAPH_F77_SAVE logical first = TRUE_;

    /* System generated locals */
    integer h_dim1, h_offset, q_dim1, q_offset, v_dim1, v_offset, i__1, i__2, 
	    i__3, i__4;
    doublereal d__1, d__2;

    /* Local variables */
    doublereal c__, f, g;
    integer i__, j;
    doublereal r__, s, a1, a2, a3, a4;
    IGRAPH_F77_SAVE real t0, t1;
    integer jj;
    doublereal big;
    integer iend, itop;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *), igraphdgemv_(char *, integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *), igraphdcopy_(integer *, doublereal *, 
	    integer *, doublereal *, integer *), igraphdaxpy_(integer *, doublereal 
	    *, doublereal *, integer *, doublereal *, integer *), igraphdvout_(
	    integer *, integer *, doublereal *, integer *, char *, ftnlen), 
	    igraphivout_(integer *, integer *, integer *, integer *, char *, ftnlen)
	    ;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphsecond_(real *), igraphdlacpy_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *), igraphdlartg_(doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *), igraphdlaset_(char *, integer *, integer *,
	     doublereal *, doublereal *, doublereal *, integer *);
    IGRAPH_F77_SAVE doublereal epsmch;
    integer logfil, ndigit, msapps = 0, msglvl, istart;
    real tsapps = 0;
    integer kplusp;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   



       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %----------------------%   
       | Intrinsics Functions |   
       %----------------------%   


       %----------------%   
       | Data statments |   
       %----------------%   

       Parameter adjustments */
    --workd;
    --resid;
    --shift;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;

    /* Function Body   

       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    if (first) {
	epsmch = igraphdlamch_("Epsilon-Machine");
	first = FALSE_;
    }
    itop = 1;

/*     %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------% */

    igraphsecond_(&t0);
    msglvl = msapps;

    kplusp = *kev + *np;

/*     %----------------------------------------------%   
       | Initialize Q to the identity matrix of order |   
       | kplusp used to accumulate the rotations.     |   
       %----------------------------------------------% */

    igraphdlaset_("All", &kplusp, &kplusp, &c_b4, &c_b5, &q[q_offset], ldq);

/*     %----------------------------------------------%   
       | Quick return if there are no shifts to apply |   
       %----------------------------------------------% */

    if (*np == 0) {
	goto L9000;
    }

/*     %----------------------------------------------------------%   
       | Apply the np shifts implicitly. Apply each shift to the  |   
       | whole matrix and not just to the submatrix from which it |   
       | comes.                                                   |   
       %----------------------------------------------------------% */

    i__1 = *np;
    for (jj = 1; jj <= i__1; ++jj) {

	istart = itop;

/*        %----------------------------------------------------------%   
          | Check for splitting and deflation. Currently we consider |   
          | an off-diagonal element h(i+1,1) negligible if           |   
          |         h(i+1,1) .le. epsmch*( |h(i,2)| + |h(i+1,2)| )   |   
          | for i=1:KEV+NP-1.                                        |   
          | If above condition tests true then we set h(i+1,1) = 0.  |   
          | Note that h(1:KEV+NP,1) are assumed to be non negative.  |   
          %----------------------------------------------------------% */

L20:

/*        %------------------------------------------------%   
          | The following loop exits early if we encounter |   
          | a negligible off diagonal element.             |   
          %------------------------------------------------% */

	i__2 = kplusp - 1;
	for (i__ = istart; i__ <= i__2; ++i__) {
	    big = (d__1 = h__[i__ + (h_dim1 << 1)], abs(d__1)) + (d__2 = h__[
		    i__ + 1 + (h_dim1 << 1)], abs(d__2));
	    if (h__[i__ + 1 + h_dim1] <= epsmch * big) {
		if (msglvl > 0) {
		    igraphivout_(&logfil, &c__1, &i__, &ndigit, "_sapps: deflation"
			    " at row/column no.", (ftnlen)35);
		    igraphivout_(&logfil, &c__1, &jj, &ndigit, "_sapps: occured be"
			    "fore shift number.", (ftnlen)36);
		    igraphdvout_(&logfil, &c__1, &h__[i__ + 1 + h_dim1], &ndigit, 
			    "_sapps: the corresponding off diagonal element", 
			    (ftnlen)46);
		}
		h__[i__ + 1 + h_dim1] = 0.;
		iend = i__;
		goto L40;
	    }
/* L30: */
	}
	iend = kplusp;
L40:

	if (istart < iend) {

/*           %--------------------------------------------------------%   
             | Construct the plane rotation G'(istart,istart+1,theta) |   
             | that attempts to drive h(istart+1,1) to zero.          |   
             %--------------------------------------------------------% */

	    f = h__[istart + (h_dim1 << 1)] - shift[jj];
	    g = h__[istart + 1 + h_dim1];
	    igraphdlartg_(&f, &g, &c__, &s, &r__);

/*            %-------------------------------------------------------%   
              | Apply rotation to the left and right of H;            |   
              | H <- G' * H * G,  where G = G(istart,istart+1,theta). |   
              | This will create a "bulge".                           |   
              %-------------------------------------------------------% */

	    a1 = c__ * h__[istart + (h_dim1 << 1)] + s * h__[istart + 1 + 
		    h_dim1];
	    a2 = c__ * h__[istart + 1 + h_dim1] + s * h__[istart + 1 + (
		    h_dim1 << 1)];
	    a4 = c__ * h__[istart + 1 + (h_dim1 << 1)] - s * h__[istart + 1 + 
		    h_dim1];
	    a3 = c__ * h__[istart + 1 + h_dim1] - s * h__[istart + (h_dim1 << 
		    1)];
	    h__[istart + (h_dim1 << 1)] = c__ * a1 + s * a2;
	    h__[istart + 1 + (h_dim1 << 1)] = c__ * a4 - s * a3;
	    h__[istart + 1 + h_dim1] = c__ * a3 + s * a4;

/*            %----------------------------------------------------%   
              | Accumulate the rotation in the matrix Q;  Q <- Q*G |   
              %----------------------------------------------------%   

   Computing MIN */
	    i__3 = istart + jj;
	    i__2 = min(i__3,kplusp);
	    for (j = 1; j <= i__2; ++j) {
		a1 = c__ * q[j + istart * q_dim1] + s * q[j + (istart + 1) * 
			q_dim1];
		q[j + (istart + 1) * q_dim1] = -s * q[j + istart * q_dim1] + 
			c__ * q[j + (istart + 1) * q_dim1];
		q[j + istart * q_dim1] = a1;
/* L60: */
	    }


/*            %----------------------------------------------%   
              | The following loop chases the bulge created. |   
              | Note that the previous rotation may also be  |   
              | done within the following loop. But it is    |   
              | kept separate to make the distinction among  |   
              | the bulge chasing sweeps and the first plane |   
              | rotation designed to drive h(istart+1,1) to  |   
              | zero.                                        |   
              %----------------------------------------------% */

	    i__2 = iend - 1;
	    for (i__ = istart + 1; i__ <= i__2; ++i__) {

/*               %----------------------------------------------%   
                 | Construct the plane rotation G'(i,i+1,theta) |   
                 | that zeros the i-th bulge that was created   |   
                 | by G(i-1,i,theta). g represents the bulge.   |   
                 %----------------------------------------------% */

		f = h__[i__ + h_dim1];
		g = s * h__[i__ + 1 + h_dim1];

/*               %----------------------------------%   
                 | Final update with G(i-1,i,theta) |   
                 %----------------------------------% */

		h__[i__ + 1 + h_dim1] = c__ * h__[i__ + 1 + h_dim1];
		igraphdlartg_(&f, &g, &c__, &s, &r__);

/*               %-------------------------------------------%   
                 | The following ensures that h(1:iend-1,1), |   
                 | the first iend-2 off diagonal of elements |   
                 | H, remain non negative.                   |   
                 %-------------------------------------------% */

		if (r__ < 0.) {
		    r__ = -r__;
		    c__ = -c__;
		    s = -s;
		}

/*               %--------------------------------------------%   
                 | Apply rotation to the left and right of H; |   
                 | H <- G * H * G',  where G = G(i,i+1,theta) |   
                 %--------------------------------------------% */

		h__[i__ + h_dim1] = r__;

		a1 = c__ * h__[i__ + (h_dim1 << 1)] + s * h__[i__ + 1 + 
			h_dim1];
		a2 = c__ * h__[i__ + 1 + h_dim1] + s * h__[i__ + 1 + (h_dim1 
			<< 1)];
		a3 = c__ * h__[i__ + 1 + h_dim1] - s * h__[i__ + (h_dim1 << 1)
			];
		a4 = c__ * h__[i__ + 1 + (h_dim1 << 1)] - s * h__[i__ + 1 + 
			h_dim1];

		h__[i__ + (h_dim1 << 1)] = c__ * a1 + s * a2;
		h__[i__ + 1 + (h_dim1 << 1)] = c__ * a4 - s * a3;
		h__[i__ + 1 + h_dim1] = c__ * a3 + s * a4;

/*               %----------------------------------------------------%   
                 | Accumulate the rotation in the matrix Q;  Q <- Q*G |   
                 %----------------------------------------------------%   

   Computing MIN */
		i__4 = j + jj;
		i__3 = min(i__4,kplusp);
		for (j = 1; j <= i__3; ++j) {
		    a1 = c__ * q[j + i__ * q_dim1] + s * q[j + (i__ + 1) * 
			    q_dim1];
		    q[j + (i__ + 1) * q_dim1] = -s * q[j + i__ * q_dim1] + 
			    c__ * q[j + (i__ + 1) * q_dim1];
		    q[j + i__ * q_dim1] = a1;
/* L50: */
		}

/* L70: */
	    }

	}

/*        %--------------------------%   
          | Update the block pointer |   
          %--------------------------% */

	istart = iend + 1;

/*        %------------------------------------------%   
          | Make sure that h(iend,1) is non-negative |   
          | If not then set h(iend,1) <-- -h(iend,1) |   
          | and negate the last column of Q.         |   
          | We have effectively carried out a        |   
          | similarity on transformation H           |   
          %------------------------------------------% */

	if (h__[iend + h_dim1] < 0.) {
	    h__[iend + h_dim1] = -h__[iend + h_dim1];
	    igraphdscal_(&kplusp, &c_b20, &q[iend * q_dim1 + 1], &c__1);
	}

/*        %--------------------------------------------------------%   
          | Apply the same shift to the next block if there is any |   
          %--------------------------------------------------------% */

	if (iend < kplusp) {
	    goto L20;
	}

/*        %-----------------------------------------------------%   
          | Check if we can increase the the start of the block |   
          %-----------------------------------------------------% */

	i__2 = kplusp - 1;
	for (i__ = itop; i__ <= i__2; ++i__) {
	    if (h__[i__ + 1 + h_dim1] > 0.) {
		goto L90;
	    }
	    ++itop;
/* L80: */
	}

/*        %-----------------------------------%   
          | Finished applying the jj-th shift |   
          %-----------------------------------% */

L90:
	;
    }

/*     %------------------------------------------%   
       | All shifts have been applied. Check for  |   
       | more possible deflation that might occur |   
       | after the last shift is applied.         |   
       %------------------------------------------% */

    i__1 = kplusp - 1;
    for (i__ = itop; i__ <= i__1; ++i__) {
	big = (d__1 = h__[i__ + (h_dim1 << 1)], abs(d__1)) + (d__2 = h__[i__ 
		+ 1 + (h_dim1 << 1)], abs(d__2));
	if (h__[i__ + 1 + h_dim1] <= epsmch * big) {
	    if (msglvl > 0) {
		igraphivout_(&logfil, &c__1, &i__, &ndigit, "_sapps: deflation at "
			"row/column no.", (ftnlen)35);
		igraphdvout_(&logfil, &c__1, &h__[i__ + 1 + h_dim1], &ndigit, "_sa"
			"pps: the corresponding off diagonal element", (ftnlen)
			46);
	    }
	    h__[i__ + 1 + h_dim1] = 0.;
	}
/* L100: */
    }

/*     %-------------------------------------------------%   
       | Compute the (kev+1)-st column of (V*Q) and      |   
       | temporarily store the result in WORKD(N+1:2*N). |   
       | This is not necessary if h(kev+1,1) = 0.         |   
       %-------------------------------------------------% */

    if (h__[*kev + 1 + h_dim1] > 0.) {
	igraphdgemv_("N", n, &kplusp, &c_b5, &v[v_offset], ldv, &q[(*kev + 1) * 
		q_dim1 + 1], &c__1, &c_b4, &workd[*n + 1], &c__1);
    }

/*     %-------------------------------------------------------%   
       | Compute column 1 to kev of (V*Q) in backward order    |   
       | taking advantage that Q is an upper triangular matrix |   
       | with lower bandwidth np.                              |   
       | Place results in v(:,kplusp-kev:kplusp) temporarily.  |   
       %-------------------------------------------------------% */

    i__1 = *kev;
    for (i__ = 1; i__ <= i__1; ++i__) {
	i__2 = kplusp - i__ + 1;
	igraphdgemv_("N", n, &i__2, &c_b5, &v[v_offset], ldv, &q[(*kev - i__ + 1) * 
		q_dim1 + 1], &c__1, &c_b4, &workd[1], &c__1);
	igraphdcopy_(n, &workd[1], &c__1, &v[(kplusp - i__ + 1) * v_dim1 + 1], &
		c__1);
/* L130: */
    }

/*     %-------------------------------------------------%   
       |  Move v(:,kplusp-kev+1:kplusp) into v(:,1:kev). |   
       %-------------------------------------------------% */

    igraphdlacpy_("All", n, kev, &v[(*np + 1) * v_dim1 + 1], ldv, &v[v_offset], ldv);

/*     %--------------------------------------------%   
       | Copy the (kev+1)-st column of (V*Q) in the |   
       | appropriate place if h(kev+1,1) .ne. zero. |   
       %--------------------------------------------% */

    if (h__[*kev + 1 + h_dim1] > 0.) {
	igraphdcopy_(n, &workd[*n + 1], &c__1, &v[(*kev + 1) * v_dim1 + 1], &c__1);
    }

/*     %-------------------------------------%   
       | Update the residual vector:         |   
       |    r <- sigmak*r + betak*v(:,kev+1) |   
       | where                               |   
       |    sigmak = (e_{kev+p}'*Q)*e_{kev}  |   
       |    betak = e_{kev+1}'*H*e_{kev}     |   
       %-------------------------------------% */

    igraphdscal_(n, &q[kplusp + *kev * q_dim1], &resid[1], &c__1);
    if (h__[*kev + 1 + h_dim1] > 0.) {
	igraphdaxpy_(n, &h__[*kev + 1 + h_dim1], &v[(*kev + 1) * v_dim1 + 1], &c__1,
		 &resid[1], &c__1);
    }

    if (msglvl > 1) {
	igraphdvout_(&logfil, &c__1, &q[kplusp + *kev * q_dim1], &ndigit, "_sapps:"
		" sigmak of the updated residual vector", (ftnlen)45);
	igraphdvout_(&logfil, &c__1, &h__[*kev + 1 + h_dim1], &ndigit, "_sapps: be"
		"tak of the updated residual vector", (ftnlen)44);
	igraphdvout_(&logfil, kev, &h__[(h_dim1 << 1) + 1], &ndigit, "_sapps: upda"
		"ted main diagonal of H for next iteration", (ftnlen)53);
	if (*kev > 1) {
	    i__1 = *kev - 1;
	    igraphdvout_(&logfil, &i__1, &h__[h_dim1 + 2], &ndigit, "_sapps: updat"
		    "ed sub diagonal of H for next iteration", (ftnlen)52);
	}
    }

    igraphsecond_(&t1);
    tsapps += t1 - t0;

L9000:
    return 0;

/*     %---------------%   
       | End of dsapps |   
       %---------------% */

} /* igraphdsapps_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsaup2.c0000644000175100001710000010653500000000000023756 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b3 = .66666666666666663;
static integer c__1 = 1;
static integer c__0 = 0;
static integer c__3 = 3;
static logical c_true = TRUE_;
static integer c__2 = 2;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsaup2   

   \Description:   
    Intermediate level interface called by dsaupd.   

   \Usage:   
    call dsaup2   
       ( IDO, BMAT, N, WHICH, NEV, NP, TOL, RESID, MODE, IUPD,   
         ISHIFT, MXITER, V, LDV, H, LDH, RITZ, BOUNDS, Q, LDQ, WORKL,   
         IPNTR, WORKD, INFO )   

   \Arguments   

    IDO, BMAT, N, WHICH, NEV, TOL, RESID: same as defined in dsaupd.   
    MODE, ISHIFT, MXITER: see the definition of IPARAM in dsaupd.   

    NP      Integer.  (INPUT/OUTPUT)   
            Contains the number of implicit shifts to apply during   
            each Arnoldi/Lanczos iteration.   
            If ISHIFT=1, NP is adjusted dynamically at each iteration   
            to accelerate convergence and prevent stagnation.   
            This is also roughly equal to the number of matrix-vector   
            products (involving the operator OP) per Arnoldi iteration.   
            The logic for adjusting is contained within the current   
            subroutine.   
            If ISHIFT=0, NP is the number of shifts the user needs   
            to provide via reverse comunication. 0 < NP < NCV-NEV.   
            NP may be less than NCV-NEV since a leading block of the current   
            upper Tridiagonal matrix has split off and contains "unwanted"   
            Ritz values.   
            Upon termination of the IRA iteration, NP contains the number   
            of "converged" wanted Ritz values.   

    IUPD    Integer.  (INPUT)   
            IUPD .EQ. 0: use explicit restart instead implicit update.   
            IUPD .NE. 0: use implicit update.   

    V       Double precision N by (NEV+NP) array.  (INPUT/OUTPUT)   
            The Lanczos basis vectors.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    H       Double precision (NEV+NP) by 2 array.  (OUTPUT)   
            H is used to store the generated symmetric tridiagonal matrix   
            The subdiagonal is stored in the first column of H starting   
            at H(2,1).  The main diagonal is stored in the second column   
            of H starting at H(1,2). If dsaup2 converges store the   
            B-norm of the final residual vector in H(1,1).   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    RITZ    Double precision array of length NEV+NP.  (OUTPUT)   
            RITZ(1:NEV) contains the computed Ritz values of OP.   

    BOUNDS  Double precision array of length NEV+NP.  (OUTPUT)   
            BOUNDS(1:NEV) contain the error bounds corresponding to RITZ.   

    Q       Double precision (NEV+NP) by (NEV+NP) array.  (WORKSPACE)   
            Private (replicated) work array used to accumulate the   
            rotation in the shift application step.   

    LDQ     Integer.  (INPUT)   
            Leading dimension of Q exactly as declared in the calling   
            program.   

    WORKL   Double precision array of length at least 3*(NEV+NP).  (INPUT/WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.  It is used in the computation of the   
            tridiagonal eigenvalue problem, the calculation and   
            application of the shifts and convergence checking.   
            If ISHIFT .EQ. O and IDO .EQ. 3, the first NP locations   
            of WORKL are used in reverse communication to hold the user   
            supplied shifts.   

    IPNTR   Integer array of length 3.  (OUTPUT)   
            Pointer to mark the starting locations in the WORKD for   
            vectors used by the Lanczos iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X.   
            IPNTR(2): pointer to the current result vector Y.   
            IPNTR(3): pointer to the vector B * X when used in one of   
                      the spectral transformation modes.  X is the current   
                      operand.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (REVERSE COMMUNICATION)   
            Distributed array to be used in the basic Lanczos iteration   
            for reverse communication.  The user should not use WORKD   
            as temporary workspace during the iteration !!!!!!!!!!   
            See Data Distribution Note in dsaupd.   

    INFO    Integer.  (INPUT/OUTPUT)   
            If INFO .EQ. 0, a randomly initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            Error flag on output.   
            =     0: Normal return.   
            =     1: All possible eigenvalues of OP has been found.   
                     NP returns the size of the invariant subspace   
                     spanning the operator OP.   
            =     2: No shifts could be applied.   
            =    -8: Error return from trid. eigenvalue calculation;   
                     This should never happen.   
            =    -9: Starting vector is zero.   
            = -9999: Could not build an Lanczos factorization.   
                     Size that was built in returned in NP.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   
    3. B.N. Parlett, "The Symmetric Eigenvalue Problem". Prentice-Hall,   
       1980.   
    4. B.N. Parlett, B. Nour-Omid, "Towards a Black Box Lanczos Program",   
       Computer Physics Communications, 53 (1989), pp 169-179.   
    5. B. Nour-Omid, B.N. Parlett, T. Ericson, P.S. Jensen, "How to   
       Implement the Spectral Transformation", Math. Comp., 48 (1987),   
       pp 663-673.   
    6. R.G. Grimes, J.G. Lewis and H.D. Simon, "A Shifted Block Lanczos   
       Algorithm for Solving Sparse Symmetric Generalized Eigenproblems",   
       SIAM J. Matr. Anal. Apps.,  January (1993).   
    7. L. Reichel, W.B. Gragg, "Algorithm 686: FORTRAN Subroutines   
       for Updating the QR decomposition", ACM TOMS, December 1990,   
       Volume 16 Number 4, pp 369-377.   

   \Routines called:   
       dgetv0  ARPACK initial vector generation routine.   
       dsaitr  ARPACK Lanczos factorization routine.   
       dsapps  ARPACK application of implicit shifts routine.   
       dsconv  ARPACK convergence of Ritz values routine.   
       dseigt  ARPACK compute Ritz values and error bounds routine.   
       dsgets  ARPACK reorder Ritz values and error bounds routine.   
       dsortr  ARPACK sorting routine.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       ddot    Level 1 BLAS that computes the scalar product of two vectors.   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   
       dscal   Level 1 BLAS that scales a vector.   
       dswap   Level 1 BLAS that swaps two vectors.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/15/93: Version ' 2.4'   
       xx/xx/95: Version ' 2.4'.  (R.B. Lehoucq)   

   \SCCS Information: @(#)   
   FILE: saup2.F   SID: 2.6   DATE OF SID: 8/16/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsaup2_(integer *ido, char *bmat, integer *n, char *
	which, integer *nev, integer *np, doublereal *tol, doublereal *resid, 
	integer *mode, integer *iupd, integer *ishift, integer *mxiter, 
	doublereal *v, integer *ldv, doublereal *h__, integer *ldh, 
	doublereal *ritz, doublereal *bounds, doublereal *q, integer *ldq, 
	doublereal *workl, integer *ipntr, doublereal *workd, integer *info)
{
    /* System generated locals */
    integer h_dim1, h_offset, q_dim1, q_offset, v_dim1, v_offset, i__1, i__2, 
	    i__3;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double pow_dd(doublereal *, doublereal *);
    integer s_cmp(char *, char *, ftnlen, ftnlen);
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    double sqrt(doublereal);

    /* Local variables */
    integer j;
    IGRAPH_F77_SAVE real t0, t1, t2, t3;
    integer kp[3];
    IGRAPH_F77_SAVE integer np0;
    integer nbx = 0;
    IGRAPH_F77_SAVE integer nev0;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    IGRAPH_F77_SAVE doublereal eps23;
    integer ierr;
    IGRAPH_F77_SAVE integer iter;
    doublereal temp;
    integer nevd2;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    IGRAPH_F77_SAVE logical getv0;
    integer nevm2;
    IGRAPH_F77_SAVE logical cnorm;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdswap_(integer *, doublereal *, integer 
	    *, doublereal *, integer *);
    IGRAPH_F77_SAVE integer nconv;
    IGRAPH_F77_SAVE logical initv;
    IGRAPH_F77_SAVE doublereal rnorm;
    real tmvbx = 0.0;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen), igraphdgetv0_(integer *, char *, integer *
	    , logical *, integer *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *);
    integer msaup2 = 0;
    real tsaup2;
    extern doublereal igraphdlamch_(char *);
    integer nevbef;
    extern /* Subroutine */ int igraphsecond_(real *);
    integer logfil = 0, ndigit;
    extern /* Subroutine */ int igraphdseigt_(doublereal *, integer *, doublereal *,
	     integer *, doublereal *, doublereal *, doublereal *, integer *);
    IGRAPH_F77_SAVE logical update;
    extern /* Subroutine */ int igraphdsaitr_(integer *, char *, integer *, integer 
	    *, integer *, integer *, doublereal *, doublereal *, doublereal *,
	     integer *, doublereal *, integer *, integer *, doublereal *, 
	    integer *), igraphdsgets_(integer *, char *, integer *, integer 
	    *, doublereal *, doublereal *, doublereal *), igraphdsapps_(
	    integer *, integer *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *), igraphdsconv_(integer *, doublereal *, 
	    doublereal *, doublereal *, integer *);
    IGRAPH_F77_SAVE logical ushift;
    char wprime[2];
    IGRAPH_F77_SAVE integer msglvl;
    integer nptemp;
    extern /* Subroutine */ int igraphdsortr_(char *, logical *, integer *, 
	    doublereal *, doublereal *);
    IGRAPH_F77_SAVE integer kplusp;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    --workd;
    --resid;
    --workl;
    --bounds;
    --ritz;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;
    --ipntr;

    /* Function Body */
    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphsecond_(&t0);
	msglvl = msaup2;

/*        %---------------------------------%   
          | Set machine dependent constant. |   
          %---------------------------------% */

	eps23 = igraphdlamch_("Epsilon-Machine");
	eps23 = pow_dd(&eps23, &c_b3);

/*        %-------------------------------------%   
          | nev0 and np0 are integer variables  |   
          | hold the initial values of NEV & NP |   
          %-------------------------------------% */

	nev0 = *nev;
	np0 = *np;

/*        %-------------------------------------%   
          | kplusp is the bound on the largest  |   
          |        Lanczos factorization built. |   
          | nconv is the current number of      |   
          |        "converged" eigenvlues.      |   
          | iter is the counter on the current  |   
          |      iteration step.                |   
          %-------------------------------------% */

	kplusp = nev0 + np0;
	nconv = 0;
	iter = 0;

/*        %--------------------------------------------%   
          | Set flags for computing the first NEV steps |   
          | of the Lanczos factorization.              |   
          %--------------------------------------------% */

	getv0 = TRUE_;
	update = FALSE_;
	ushift = FALSE_;
	cnorm = FALSE_;

	if (*info != 0) {

/*        %--------------------------------------------%   
          | User provides the initial residual vector. |   
          %--------------------------------------------% */

	    initv = TRUE_;
	    *info = 0;
	} else {
	    initv = FALSE_;
	}
    }

/*     %---------------------------------------------%   
       | Get a possibly random starting vector and   |   
       | force it into the range of the operator OP. |   
       %---------------------------------------------%   

   L10: */

    if (getv0) {
	igraphdgetv0_(ido, bmat, &c__1, &initv, n, &c__1, &v[v_offset], ldv, &resid[
		1], &rnorm, &ipntr[1], &workd[1], info);

	if (*ido != 99) {
	    goto L9000;
	}

	if (rnorm == 0.) {

/*           %-----------------------------------------%   
             | The initial vector is zero. Error exit. |   
             %-----------------------------------------% */

	    *info = -9;
	    goto L1200;
	}
	getv0 = FALSE_;
	*ido = 0;
    }

/*     %------------------------------------------------------------%   
       | Back from reverse communication: continue with update step |   
       %------------------------------------------------------------% */

    if (update) {
	goto L20;
    }

/*     %-------------------------------------------%   
       | Back from computing user specified shifts |   
       %-------------------------------------------% */

    if (ushift) {
	goto L50;
    }

/*     %-------------------------------------%   
       | Back from computing residual norm   |   
       | at the end of the current iteration |   
       %-------------------------------------% */

    if (cnorm) {
	goto L100;
    }

/*     %----------------------------------------------------------%   
       | Compute the first NEV steps of the Lanczos factorization |   
       %----------------------------------------------------------% */

    igraphdsaitr_(ido, bmat, n, &c__0, &nev0, mode, &resid[1], &rnorm, &v[v_offset],
	     ldv, &h__[h_offset], ldh, &ipntr[1], &workd[1], info);

/*     %---------------------------------------------------%   
       | ido .ne. 99 implies use of reverse communication  |   
       | to compute operations involving OP and possibly B |   
       %---------------------------------------------------% */

    if (*ido != 99) {
	goto L9000;
    }

    if (*info > 0) {

/*        %-----------------------------------------------------%   
          | dsaitr was unable to build an Lanczos factorization |   
          | of length NEV0. INFO is returned with the size of   |   
          | the factorization built. Exit main loop.            |   
          %-----------------------------------------------------% */

	*np = *info;
	*mxiter = iter;
	*info = -9999;
	goto L1200;
    }

/*     %--------------------------------------------------------------%   
       |                                                              |   
       |           M A I N  LANCZOS  I T E R A T I O N  L O O P       |   
       |           Each iteration implicitly restarts the Lanczos     |   
       |           factorization in place.                            |   
       |                                                              |   
       %--------------------------------------------------------------% */

L1000:

    ++iter;

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &iter, &ndigit, "_saup2: **** Start of major "
		"iteration number ****", (ftnlen)49);
    }
    if (msglvl > 1) {
	igraphivout_(&logfil, &c__1, nev, &ndigit, "_saup2: The length of the curr"
		"ent Lanczos factorization", (ftnlen)55);
	igraphivout_(&logfil, &c__1, np, &ndigit, "_saup2: Extend the Lanczos fact"
		"orization by", (ftnlen)43);
    }

/*        %------------------------------------------------------------%   
          | Compute NP additional steps of the Lanczos factorization. |   
          %------------------------------------------------------------% */

    *ido = 0;
L20:
    update = TRUE_;

    igraphdsaitr_(ido, bmat, n, nev, np, mode, &resid[1], &rnorm, &v[v_offset], ldv,
	     &h__[h_offset], ldh, &ipntr[1], &workd[1], info);

/*        %---------------------------------------------------%   
          | ido .ne. 99 implies use of reverse communication  |   
          | to compute operations involving OP and possibly B |   
          %---------------------------------------------------% */

    if (*ido != 99) {
	goto L9000;
    }

    if (*info > 0) {

/*           %-----------------------------------------------------%   
             | dsaitr was unable to build an Lanczos factorization |   
             | of length NEV0+NP0. INFO is returned with the size  |   
             | of the factorization built. Exit main loop.         |   
             %-----------------------------------------------------% */

	*np = *info;
	*mxiter = iter;
	*info = -9999;
	goto L1200;
    }
    update = FALSE_;

    if (msglvl > 1) {
	igraphdvout_(&logfil, &c__1, &rnorm, &ndigit, "_saup2: Current B-norm of r"
		"esidual for factorization", (ftnlen)52);
    }

/*        %--------------------------------------------------------%   
          | Compute the eigenvalues and corresponding error bounds |   
          | of the current symmetric tridiagonal matrix.           |   
          %--------------------------------------------------------% */

    igraphdseigt_(&rnorm, &kplusp, &h__[h_offset], ldh, &ritz[1], &bounds[1], &
	    workl[1], &ierr);

    if (ierr != 0) {
	*info = -8;
	goto L1200;
    }

/*        %----------------------------------------------------%   
          | Make a copy of eigenvalues and corresponding error |   
          | bounds obtained from _seigt.                       |   
          %----------------------------------------------------% */

    igraphdcopy_(&kplusp, &ritz[1], &c__1, &workl[kplusp + 1], &c__1);
    igraphdcopy_(&kplusp, &bounds[1], &c__1, &workl[(kplusp << 1) + 1], &c__1);

/*        %---------------------------------------------------%   
          | Select the wanted Ritz values and their bounds    |   
          | to be used in the convergence test.               |   
          | The selection is based on the requested number of |   
          | eigenvalues instead of the current NEV and NP to  |   
          | prevent possible misconvergence.                  |   
          | * Wanted Ritz values := RITZ(NP+1:NEV+NP)         |   
          | * Shifts := RITZ(1:NP) := WORKL(1:NP)             |   
          %---------------------------------------------------% */

    *nev = nev0;
    *np = np0;
    igraphdsgets_(ishift, which, nev, np, &ritz[1], &bounds[1], &workl[1]);

/*        %-------------------%   
          | Convergence test. |   
          %-------------------% */

    igraphdcopy_(nev, &bounds[*np + 1], &c__1, &workl[*np + 1], &c__1);
    igraphdsconv_(nev, &ritz[*np + 1], &workl[*np + 1], tol, &nconv);

    if (msglvl > 2) {
	kp[0] = *nev;
	kp[1] = *np;
	kp[2] = nconv;
	igraphivout_(&logfil, &c__3, kp, &ndigit, "_saup2: NEV, NP, NCONV are", (
		ftnlen)26);
	igraphdvout_(&logfil, &kplusp, &ritz[1], &ndigit, "_saup2: The eigenvalues"
		" of H", (ftnlen)28);
	igraphdvout_(&logfil, &kplusp, &bounds[1], &ndigit, "_saup2: Ritz estimate"
		"s of the current NCV Ritz values", (ftnlen)53);
    }

/*        %---------------------------------------------------------%   
          | Count the number of unwanted Ritz values that have zero |   
          | Ritz estimates. If any Ritz estimates are equal to zero |   
          | then a leading block of H of order equal to at least    |   
          | the number of Ritz values with zero Ritz estimates has  |   
          | split off. None of these Ritz values may be removed by  |   
          | shifting. Decrease NP the number of shifts to apply. If |   
          | no shifts may be applied, then prepare to exit          |   
          %---------------------------------------------------------% */

    nptemp = *np;
    i__1 = nptemp;
    for (j = 1; j <= i__1; ++j) {
	if (bounds[j] == 0.) {
	    --(*np);
	    ++(*nev);
	}
/* L30: */
    }

    if (nconv >= nev0 || iter > *mxiter || *np == 0) {

/*           %------------------------------------------------%   
             | Prepare to exit. Put the converged Ritz values |   
             | and corresponding bounds in RITZ(1:NCONV) and  |   
             | BOUNDS(1:NCONV) respectively. Then sort. Be    |   
             | careful when NCONV > NP since we don't want to |   
             | swap overlapping locations.                    |   
             %------------------------------------------------% */

	if (s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {

/*              %-----------------------------------------------------%   
                | Both ends of the spectrum are requested.            |   
                | Sort the eigenvalues into algebraically decreasing  |   
                | order first then swap low end of the spectrum next  |   
                | to high end in appropriate locations.               |   
                | NOTE: when np < floor(nev/2) be careful not to swap |   
                | overlapping locations.                              |   
                %-----------------------------------------------------% */

	    s_copy(wprime, "SA", (ftnlen)2, (ftnlen)2);
	    igraphdsortr_(wprime, &c_true, &kplusp, &ritz[1], &bounds[1])
		    ;
	    nevd2 = *nev / 2;
	    nevm2 = *nev - nevd2;
	    if (*nev > 1) {
		i__1 = min(nevd2,*np);
/* Computing MAX */
		i__2 = kplusp - nevd2 + 1, i__3 = kplusp - *np + 1;
		igraphdswap_(&i__1, &ritz[nevm2 + 1], &c__1, &ritz[max(i__2,i__3)], 
			&c__1);
		i__1 = min(nevd2,*np);
/* Computing MAX */
		i__2 = kplusp - nevd2 + 1, i__3 = kplusp - *np;
		igraphdswap_(&i__1, &bounds[nevm2 + 1], &c__1, &bounds[max(i__2,
			i__3) + 1], &c__1);
	    }

	} else {

/*              %--------------------------------------------------%   
                | LM, SM, LA, SA case.                             |   
                | Sort the eigenvalues of H into the an order that |   
                | is opposite to WHICH, and apply the resulting    |   
                | order to BOUNDS.  The eigenvalues are sorted so  |   
                | that the wanted part are always within the first |   
                | NEV locations.                                   |   
                %--------------------------------------------------% */

	    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
		s_copy(wprime, "SM", (ftnlen)2, (ftnlen)2);
	    }
	    if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
		s_copy(wprime, "LM", (ftnlen)2, (ftnlen)2);
	    }
	    if (s_cmp(which, "LA", (ftnlen)2, (ftnlen)2) == 0) {
		s_copy(wprime, "SA", (ftnlen)2, (ftnlen)2);
	    }
	    if (s_cmp(which, "SA", (ftnlen)2, (ftnlen)2) == 0) {
		s_copy(wprime, "LA", (ftnlen)2, (ftnlen)2);
	    }

	    igraphdsortr_(wprime, &c_true, &kplusp, &ritz[1], &bounds[1])
		    ;

	}

/*           %--------------------------------------------------%   
             | Scale the Ritz estimate of each Ritz value       |   
             | by 1 / max(eps23,magnitude of the Ritz value).   |   
             %--------------------------------------------------% */

	i__1 = nev0;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    d__2 = eps23, d__3 = (d__1 = ritz[j], abs(d__1));
	    temp = max(d__2,d__3);
	    bounds[j] /= temp;
/* L35: */
	}

/*           %----------------------------------------------------%   
             | Sort the Ritz values according to the scaled Ritz  |   
             | esitmates.  This will push all the converged ones  |   
             | towards the front of ritzr, ritzi, bounds          |   
             | (in the case when NCONV < NEV.)                    |   
             %----------------------------------------------------% */

	s_copy(wprime, "LA", (ftnlen)2, (ftnlen)2);
	igraphdsortr_(wprime, &c_true, &nev0, &bounds[1], &ritz[1]);

/*           %----------------------------------------------%   
             | Scale the Ritz estimate back to its original |   
             | value.                                       |   
             %----------------------------------------------% */

	i__1 = nev0;
	for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
	    d__2 = eps23, d__3 = (d__1 = ritz[j], abs(d__1));
	    temp = max(d__2,d__3);
	    bounds[j] *= temp;
/* L40: */
	}

/*           %--------------------------------------------------%   
             | Sort the "converged" Ritz values again so that   |   
             | the "threshold" values and their associated Ritz |   
             | estimates appear at the appropriate position in  |   
             | ritz and bound.                                  |   
             %--------------------------------------------------% */

	if (s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {

/*              %------------------------------------------------%   
                | Sort the "converged" Ritz values in increasing |   
                | order.  The "threshold" values are in the      |   
                | middle.                                        |   
                %------------------------------------------------% */

	    s_copy(wprime, "LA", (ftnlen)2, (ftnlen)2);
	    igraphdsortr_(wprime, &c_true, &nconv, &ritz[1], &bounds[1]);

	} else {

/*              %----------------------------------------------%   
                | In LM, SM, LA, SA case, sort the "converged" |   
                | Ritz values according to WHICH so that the   |   
                | "threshold" value appears at the front of    |   
                | ritz.                                        |   
                %----------------------------------------------% */
	    igraphdsortr_(which, &c_true, &nconv, &ritz[1], &bounds[1]);

	}

/*           %------------------------------------------%   
             |  Use h( 1,1 ) as storage to communicate  |   
             |  rnorm to _seupd if needed               |   
             %------------------------------------------% */

	h__[h_dim1 + 1] = rnorm;

	if (msglvl > 1) {
	    igraphdvout_(&logfil, &kplusp, &ritz[1], &ndigit, "_saup2: Sorted Ritz"
		    " values.", (ftnlen)27);
	    igraphdvout_(&logfil, &kplusp, &bounds[1], &ndigit, "_saup2: Sorted ri"
		    "tz estimates.", (ftnlen)30);
	}

/*           %------------------------------------%   
             | Max iterations have been exceeded. |   
             %------------------------------------% */

	if (iter > *mxiter && nconv < *nev) {
	    *info = 1;
	}

/*           %---------------------%   
             | No shifts to apply. |   
             %---------------------% */

	if (*np == 0 && nconv < nev0) {
	    *info = 2;
	}

	*np = nconv;
	goto L1100;

    } else if (nconv < *nev && *ishift == 1) {

/*           %---------------------------------------------------%   
             | Do not have all the requested eigenvalues yet.    |   
             | To prevent possible stagnation, adjust the number |   
             | of Ritz values and the shifts.                    |   
             %---------------------------------------------------% */

	nevbef = *nev;
/* Computing MIN */
	i__1 = nconv, i__2 = *np / 2;
	*nev += min(i__1,i__2);
	if (*nev == 1 && kplusp >= 6) {
	    *nev = kplusp / 2;
	} else if (*nev == 1 && kplusp > 2) {
	    *nev = 2;
	}
	*np = kplusp - *nev;

/*           %---------------------------------------%   
             | If the size of NEV was just increased |   
             | resort the eigenvalues.               |   
             %---------------------------------------% */

	if (nevbef < *nev) {
	    igraphdsgets_(ishift, which, nev, np, &ritz[1], &bounds[1], &workl[1]);
	}

    }

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &nconv, &ndigit, "_saup2: no. of \"converge"
		"d\" Ritz values at this iter.", (ftnlen)52);
	if (msglvl > 1) {
	    kp[0] = *nev;
	    kp[1] = *np;
	    igraphivout_(&logfil, &c__2, kp, &ndigit, "_saup2: NEV and NP are", (
		    ftnlen)22);
	    igraphdvout_(&logfil, nev, &ritz[*np + 1], &ndigit, "_saup2: \"wante"
		    "d\" Ritz values.", (ftnlen)29);
	    igraphdvout_(&logfil, nev, &bounds[*np + 1], &ndigit, "_saup2: Ritz es"
		    "timates of the \"wanted\" values ", (ftnlen)46);
	}
    }

    if (*ishift == 0) {

/*           %-----------------------------------------------------%   
             | User specified shifts: reverse communication to     |   
             | compute the shifts. They are returned in the first  |   
             | NP locations of WORKL.                              |   
             %-----------------------------------------------------% */

	ushift = TRUE_;
	*ido = 3;
	goto L9000;
    }

L50:

/*        %------------------------------------%   
          | Back from reverse communication;   |   
          | User specified shifts are returned |   
          | in WORKL(1:*NP)                   |   
          %------------------------------------% */

    ushift = FALSE_;


/*        %---------------------------------------------------------%   
          | Move the NP shifts to the first NP locations of RITZ to |   
          | free up WORKL.  This is for the non-exact shift case;   |   
          | in the exact shift case, dsgets already handles this.   |   
          %---------------------------------------------------------% */

    if (*ishift == 0) {
	igraphdcopy_(np, &workl[1], &c__1, &ritz[1], &c__1);
    }

    if (msglvl > 2) {
	igraphivout_(&logfil, &c__1, np, &ndigit, "_saup2: The number of shifts to"
		" apply ", (ftnlen)38);
	igraphdvout_(&logfil, np, &workl[1], &ndigit, "_saup2: shifts selected", (
		ftnlen)23);
	if (*ishift == 1) {
	    igraphdvout_(&logfil, np, &bounds[1], &ndigit, "_saup2: corresponding "
		    "Ritz estimates", (ftnlen)36);
	}
    }

/*        %---------------------------------------------------------%   
          | Apply the NP0 implicit shifts by QR bulge chasing.      |   
          | Each shift is applied to the entire tridiagonal matrix. |   
          | The first 2*N locations of WORKD are used as workspace. |   
          | After dsapps is done, we have a Lanczos                 |   
          | factorization of length NEV.                            |   
          %---------------------------------------------------------% */

    igraphdsapps_(n, nev, np, &ritz[1], &v[v_offset], ldv, &h__[h_offset], ldh, &
	    resid[1], &q[q_offset], ldq, &workd[1]);

/*        %---------------------------------------------%   
          | Compute the B-norm of the updated residual. |   
          | Keep B*RESID in WORKD(1:N) to be used in    |   
          | the first step of the next call to dsaitr.  |   
          %---------------------------------------------% */

    cnorm = TRUE_;
    igraphsecond_(&t2);
    if (*(unsigned char *)bmat == 'G') {
	++nbx;
	igraphdcopy_(n, &resid[1], &c__1, &workd[*n + 1], &c__1);
	ipntr[1] = *n + 1;
	ipntr[2] = 1;
	*ido = 2;

/*           %----------------------------------%   
             | Exit in order to compute B*RESID |   
             %----------------------------------% */

	goto L9000;
    } else if (*(unsigned char *)bmat == 'I') {
	igraphdcopy_(n, &resid[1], &c__1, &workd[1], &c__1);
    }

L100:

/*        %----------------------------------%   
          | Back from reverse communication; |   
          | WORKD(1:N) := B*RESID            |   
          %----------------------------------% */

    if (*(unsigned char *)bmat == 'G') {
	igraphsecond_(&t3);
	tmvbx += t3 - t2;
    }

    if (*(unsigned char *)bmat == 'G') {
	rnorm = igraphddot_(n, &resid[1], &c__1, &workd[1], &c__1);
	rnorm = sqrt((abs(rnorm)));
    } else if (*(unsigned char *)bmat == 'I') {
	rnorm = igraphdnrm2_(n, &resid[1], &c__1);
    }
    cnorm = FALSE_;
/* L130: */

    if (msglvl > 2) {
	igraphdvout_(&logfil, &c__1, &rnorm, &ndigit, "_saup2: B-norm of residual "
		"for NEV factorization", (ftnlen)48);
	igraphdvout_(&logfil, nev, &h__[(h_dim1 << 1) + 1], &ndigit, "_saup2: main"
		" diagonal of compressed H matrix", (ftnlen)44);
	i__1 = *nev - 1;
	igraphdvout_(&logfil, &i__1, &h__[h_dim1 + 2], &ndigit, "_saup2: subdiagon"
		"al of compressed H matrix", (ftnlen)42);
    }

    goto L1000;

/*     %---------------------------------------------------------------%   
       |                                                               |   
       |  E N D     O F     M A I N     I T E R A T I O N     L O O P  |   
       |                                                               |   
       %---------------------------------------------------------------% */

L1100:

    *mxiter = iter;
    *nev = nconv;

L1200:
    *ido = 99;

/*     %------------%   
       | Error exit |   
       %------------% */

    igraphsecond_(&t1);
    tsaup2 = t1 - t0;

L9000:
    return 0;

/*     %---------------%   
       | End of dsaup2 |   
       %---------------% */

} /* igraphdsaup2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsaupd.c0000644000175100001710000007762200000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsaupd   

   \Description:   

    Reverse communication interface for the Implicitly Restarted Arnoldi   
    Iteration.  For symmetric problems this reduces to a variant of the Lanczos   
    method.  This method has been designed to compute approximations to a   
    few eigenpairs of a linear operator OP that is real and symmetric   
    with respect to a real positive semi-definite symmetric matrix B,   
    i.e.   

         B*OP = (OP')*B.   

    Another way to express this condition is   

         < x,OPy > = < OPx,y >  where < z,w > = z'Bw  .   

    In the standard eigenproblem B is the identity matrix.   
    ( A' denotes transpose of A)   

    The computed approximate eigenvalues are called Ritz values and   
    the corresponding approximate eigenvectors are called Ritz vectors.   

    dsaupd is usually called iteratively to solve one of the   
    following problems:   

    Mode 1:  A*x = lambda*x, A symmetric   
             ===> OP = A  and  B = I.   

    Mode 2:  A*x = lambda*M*x, A symmetric, M symmetric positive definite   
             ===> OP = inv[M]*A  and  B = M.   
             ===> (If M can be factored see remark 3 below)   

    Mode 3:  K*x = lambda*M*x, K symmetric, M symmetric positive semi-definite   
             ===> OP = (inv[K - sigma*M])*M  and  B = M.   
             ===> Shift-and-Invert mode   

    Mode 4:  K*x = lambda*KG*x, K symmetric positive semi-definite,   
             KG symmetric indefinite   
             ===> OP = (inv[K - sigma*KG])*K  and  B = K.   
             ===> Buckling mode   

    Mode 5:  A*x = lambda*M*x, A symmetric, M symmetric positive semi-definite   
             ===> OP = inv[A - sigma*M]*[A + sigma*M]  and  B = M.   
             ===> Cayley transformed mode   

    NOTE: The action of w <- inv[A - sigma*M]*v or w <- inv[M]*v   
          should be accomplished either by a direct method   
          using a sparse matrix factorization and solving   

             [A - sigma*M]*w = v  or M*w = v,   

          or through an iterative method for solving these   
          systems.  If an iterative method is used, the   
          convergence test must be more stringent than   
          the accuracy requirements for the eigenvalue   
          approximations.   

   \Usage:   
    call dsaupd   
       ( IDO, BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM,   
         IPNTR, WORKD, WORKL, LWORKL, INFO )   

   \Arguments   
    IDO     Integer.  (INPUT/OUTPUT)   
            Reverse communication flag.  IDO must be zero on the first   
            call to dsaupd.  IDO will be set internally to   
            indicate the type of operation to be performed.  Control is   
            then given back to the calling routine which has the   
            responsibility to carry out the requested operation and call   
            dsaupd with the result.  The operand is given in   
            WORKD(IPNTR(1)), the result must be put in WORKD(IPNTR(2)).   
            (If Mode = 2 see remark 5 below)   
            -------------------------------------------------------------   
            IDO =  0: first call to the reverse communication interface   
            IDO = -1: compute  Y = OP * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
                      This is for the initialization phase to force the   
                      starting vector into the range of OP.   
            IDO =  1: compute  Y = OP * X where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
                      In mode 3,4 and 5, the vector B * X is already   
                      available in WORKD(ipntr(3)).  It does not   
                      need to be recomputed in forming OP * X.   
            IDO =  2: compute  Y = B * X  where   
                      IPNTR(1) is the pointer into WORKD for X,   
                      IPNTR(2) is the pointer into WORKD for Y.   
            IDO =  3: compute the IPARAM(8) shifts where   
                      IPNTR(11) is the pointer into WORKL for   
                      placing the shifts. See remark 6 below.   
            IDO = 99: done   
            -------------------------------------------------------------   

    BMAT    Character*1.  (INPUT)   
            BMAT specifies the type of the matrix B that defines the   
            semi-inner product for the operator OP.   
            B = 'I' -> standard eigenvalue problem A*x = lambda*x   
            B = 'G' -> generalized eigenvalue problem A*x = lambda*B*x   

    N       Integer.  (INPUT)   
            Dimension of the eigenproblem.   

    WHICH   Character*2.  (INPUT)   
            Specify which of the Ritz values of OP to compute.   

            'LA' - compute the NEV largest (algebraic) eigenvalues.   
            'SA' - compute the NEV smallest (algebraic) eigenvalues.   
            'LM' - compute the NEV largest (in magnitude) eigenvalues.   
            'SM' - compute the NEV smallest (in magnitude) eigenvalues.   
            'BE' - compute NEV eigenvalues, half from each end of the   
                   spectrum.  When NEV is odd, compute one more from the   
                   high end than from the low end.   
             (see remark 1 below)   

    NEV     Integer.  (INPUT)   
            Number of eigenvalues of OP to be computed. 0 < NEV < N.   

    TOL     Double precision scalar.  (INPUT)   
            Stopping criterion: the relative accuracy of the Ritz value   
            is considered acceptable if BOUNDS(I) .LE. TOL*ABS(RITZ(I)).   
            If TOL .LE. 0. is passed a default is set:   
            DEFAULT = DLAMCH('EPS')  (machine precision as computed   
                      by the LAPACK auxiliary subroutine DLAMCH).   

    RESID   Double precision array of length N.  (INPUT/OUTPUT)   
            On INPUT:   
            If INFO .EQ. 0, a random initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            On OUTPUT:   
            RESID contains the final residual vector.   

    NCV     Integer.  (INPUT)   
            Number of columns of the matrix V (less than or equal to N).   
            This will indicate how many Lanczos vectors are generated   
            at each iteration.  After the startup phase in which NEV   
            Lanczos vectors are generated, the algorithm generates   
            NCV-NEV Lanczos vectors at each subsequent update iteration.   
            Most of the cost in generating each Lanczos vector is in the   
            matrix-vector product OP*x. (See remark 4 below).   

    V       Double precision N by NCV array.  (OUTPUT)   
            The NCV columns of V contain the Lanczos basis vectors.   

    LDV     Integer.  (INPUT)   
            Leading dimension of V exactly as declared in the calling   
            program.   

    IPARAM  Integer array of length 11.  (INPUT/OUTPUT)   
            IPARAM(1) = ISHIFT: method for selecting the implicit shifts.   
            The shifts selected at each iteration are used to restart   
            the Arnoldi iteration in an implicit fashion.   
            -------------------------------------------------------------   
            ISHIFT = 0: the shifts are provided by the user via   
                        reverse communication.  The NCV eigenvalues of   
                        the current tridiagonal matrix T are returned in   
                        the part of WORKL array corresponding to RITZ.   
                        See remark 6 below.   
            ISHIFT = 1: exact shifts with respect to the reduced   
                        tridiagonal matrix T.  This is equivalent to   
                        restarting the iteration with a starting vector   
                        that is a linear combination of Ritz vectors   
                        associated with the "wanted" Ritz values.   
            -------------------------------------------------------------   

            IPARAM(2) = LEVEC   
            No longer referenced. See remark 2 below.   

            IPARAM(3) = MXITER   
            On INPUT:  maximum number of Arnoldi update iterations allowed.   
            On OUTPUT: actual number of Arnoldi update iterations taken.   

            IPARAM(4) = NB: blocksize to be used in the recurrence.   
            The code currently works only for NB = 1.   

            IPARAM(5) = NCONV: number of "converged" Ritz values.   
            This represents the number of Ritz values that satisfy   
            the convergence criterion.   

            IPARAM(6) = IUPD   
            No longer referenced. Implicit restarting is ALWAYS used.   

            IPARAM(7) = MODE   
            On INPUT determines what type of eigenproblem is being solved.   
            Must be 1,2,3,4,5; See under \Description of dsaupd for the   
            five modes available.   

            IPARAM(8) = NP   
            When ido = 3 and the user provides shifts through reverse   
            communication (IPARAM(1)=0), dsaupd returns NP, the number   
            of shifts the user is to provide. 0 < NP <=NCV-NEV. See Remark   
            6 below.   

            IPARAM(9) = NUMOP, IPARAM(10) = NUMOPB, IPARAM(11) = NUMREO,   
            OUTPUT: NUMOP  = total number of OP*x operations,   
                    NUMOPB = total number of B*x operations if BMAT='G',   
                    NUMREO = total number of steps of re-orthogonalization.   

    IPNTR   Integer array of length 11.  (OUTPUT)   
            Pointer to mark the starting locations in the WORKD and WORKL   
            arrays for matrices/vectors used by the Lanczos iteration.   
            -------------------------------------------------------------   
            IPNTR(1): pointer to the current operand vector X in WORKD.   
            IPNTR(2): pointer to the current result vector Y in WORKD.   
            IPNTR(3): pointer to the vector B * X in WORKD when used in   
                      the shift-and-invert mode.   
            IPNTR(4): pointer to the next available location in WORKL   
                      that is untouched by the program.   
            IPNTR(5): pointer to the NCV by 2 tridiagonal matrix T in WORKL.   
            IPNTR(6): pointer to the NCV RITZ values array in WORKL.   
            IPNTR(7): pointer to the Ritz estimates in array WORKL associated   
                      with the Ritz values located in RITZ in WORKL.   
            IPNTR(11): pointer to the NP shifts in WORKL. See Remark 6 below.   

            Note: IPNTR(8:10) is only referenced by dseupd. See Remark 2.   
            IPNTR(8): pointer to the NCV RITZ values of the original system.   
            IPNTR(9): pointer to the NCV corresponding error bounds.   
            IPNTR(10): pointer to the NCV by NCV matrix of eigenvectors   
                       of the tridiagonal matrix T. Only referenced by   
                       dseupd if RVEC = .TRUE. See Remarks.   
            -------------------------------------------------------------   

    WORKD   Double precision work array of length 3*N.  (REVERSE COMMUNICATION)   
            Distributed array to be used in the basic Arnoldi iteration   
            for reverse communication.  The user should not use WORKD   
            as temporary workspace during the iteration. Upon termination   
            WORKD(1:N) contains B*RESID(1:N). If the Ritz vectors are desired   
            subroutine dseupd uses this output.   
            See Data Distribution Note below.   

    WORKL   Double precision work array of length LWORKL.  (OUTPUT/WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.  See Data Distribution Note below.   

    LWORKL  Integer.  (INPUT)   
            LWORKL must be at least NCV**2 + 8*NCV .   

    INFO    Integer.  (INPUT/OUTPUT)   
            If INFO .EQ. 0, a randomly initial residual vector is used.   
            If INFO .NE. 0, RESID contains the initial residual vector,   
                            possibly from a previous run.   
            Error flag on output.   
            =  0: Normal exit.   
            =  1: Maximum number of iterations taken.   
                  All possible eigenvalues of OP has been found. IPARAM(5)   
                  returns the number of wanted converged Ritz values.   
            =  2: No longer an informational error. Deprecated starting   
                  with release 2 of ARPACK.   
            =  3: No shifts could be applied during a cycle of the   
                  Implicitly restarted Arnoldi iteration. One possibility   
                  is to increase the size of NCV relative to NEV.   
                  See remark 4 below.   
            = -1: N must be positive.   
            = -2: NEV must be positive.   
            = -3: NCV must be greater than NEV and less than or equal to N.   
            = -4: The maximum number of Arnoldi update iterations allowed   
                  must be greater than zero.   
            = -5: WHICH must be one of 'LM', 'SM', 'LA', 'SA' or 'BE'.   
            = -6: BMAT must be one of 'I' or 'G'.   
            = -7: Length of private work array WORKL is not sufficient.   
            = -8: Error return from trid. eigenvalue calculation;   
                  Informatinal error from LAPACK routine dsteqr.   
            = -9: Starting vector is zero.   
            = -10: IPARAM(7) must be 1,2,3,4,5.   
            = -11: IPARAM(7) = 1 and BMAT = 'G' are incompatable.   
            = -12: IPARAM(1) must be equal to 0 or 1.   
            = -13: NEV and WHICH = 'BE' are incompatable.   
            = -9999: Could not build an Arnoldi factorization.   
                     IPARAM(5) returns the size of the current Arnoldi   
                     factorization. The user is advised to check that   
                     enough workspace and array storage has been allocated.   


   \Remarks   
    1. The converged Ritz values are always returned in ascending   
       algebraic order.  The computed Ritz values are approximate   
       eigenvalues of OP.  The selection of WHICH should be made   
       with this in mind when Mode = 3,4,5.  After convergence,   
       approximate eigenvalues of the original problem may be obtained   
       with the ARPACK subroutine dseupd.   

    2. If the Ritz vectors corresponding to the converged Ritz values   
       are needed, the user must call dseupd immediately following completion   
       of dsaupd. This is new starting with version 2.1 of ARPACK.   

    3. If M can be factored into a Cholesky factorization M = LL'   
       then Mode = 2 should not be selected.  Instead one should use   
       Mode = 1 with  OP = inv(L)*A*inv(L').  Appropriate triangular   
       linear systems should be solved with L and L' rather   
       than computing inverses.  After convergence, an approximate   
       eigenvector z of the original problem is recovered by solving   
       L'z = x  where x is a Ritz vector of OP.   

    4. At present there is no a-priori analysis to guide the selection   
       of NCV relative to NEV.  The only formal requrement is that NCV > NEV.   
       However, it is recommended that NCV .ge. 2*NEV.  If many problems of   
       the same type are to be solved, one should experiment with increasing   
       NCV while keeping NEV fixed for a given test problem.  This will   
       usually decrease the required number of OP*x operations but it   
       also increases the work and storage required to maintain the orthogonal   
       basis vectors.   The optimal "cross-over" with respect to CPU time   
       is problem dependent and must be determined empirically.   

    5. If IPARAM(7) = 2 then in the Reverse commuication interface the user   
       must do the following. When IDO = 1, Y = OP * X is to be computed.   
       When IPARAM(7) = 2 OP = inv(B)*A. After computing A*X the user   
       must overwrite X with A*X. Y is then the solution to the linear set   
       of equations B*Y = A*X.   

    6. When IPARAM(1) = 0, and IDO = 3, the user needs to provide the   
       NP = IPARAM(8) shifts in locations:   
       1   WORKL(IPNTR(11))   
       2   WORKL(IPNTR(11)+1)   
                          .   
                          .   
                          .   
       NP  WORKL(IPNTR(11)+NP-1).   

       The eigenvalues of the current tridiagonal matrix are located in   
       WORKL(IPNTR(6)) through WORKL(IPNTR(6)+NCV-1). They are in the   
       order defined by WHICH. The associated Ritz estimates are located in   
       WORKL(IPNTR(8)), WORKL(IPNTR(8)+1), ... , WORKL(IPNTR(8)+NCV-1).   

   -----------------------------------------------------------------------   

   \Data Distribution Note:   

    Fortran-D syntax:   
    ================   
    REAL       RESID(N), V(LDV,NCV), WORKD(3*N), WORKL(LWORKL)   
    DECOMPOSE  D1(N), D2(N,NCV)   
    ALIGN      RESID(I) with D1(I)   
    ALIGN      V(I,J)   with D2(I,J)   
    ALIGN      WORKD(I) with D1(I)     range (1:N)   
    ALIGN      WORKD(I) with D1(I-N)   range (N+1:2*N)   
    ALIGN      WORKD(I) with D1(I-2*N) range (2*N+1:3*N)   
    DISTRIBUTE D1(BLOCK), D2(BLOCK,:)   
    REPLICATED WORKL(LWORKL)   

    Cray MPP syntax:   
    ===============   
    REAL       RESID(N), V(LDV,NCV), WORKD(N,3), WORKL(LWORKL)   
    SHARED     RESID(BLOCK), V(BLOCK,:), WORKD(BLOCK,:)   
    REPLICATED WORKL(LWORKL)   


   \BeginLib   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   
    3. B.N. Parlett, "The Symmetric Eigenvalue Problem". Prentice-Hall,   
       1980.   
    4. B.N. Parlett, B. Nour-Omid, "Towards a Black Box Lanczos Program",   
       Computer Physics Communications, 53 (1989), pp 169-179.   
    5. B. Nour-Omid, B.N. Parlett, T. Ericson, P.S. Jensen, "How to   
       Implement the Spectral Transformation", Math. Comp., 48 (1987),   
       pp 663-673.   
    6. R.G. Grimes, J.G. Lewis and H.D. Simon, "A Shifted Block Lanczos   
       Algorithm for Solving Sparse Symmetric Generalized Eigenproblems",   
       SIAM J. Matr. Anal. Apps.,  January (1993).   
    7. L. Reichel, W.B. Gragg, "Algorithm 686: FORTRAN Subroutines   
       for Updating the QR decomposition", ACM TOMS, December 1990,   
       Volume 16 Number 4, pp 369-377.   
    8. R.B. Lehoucq, D.C. Sorensen, "Implementation of Some Spectral   
       Transformations in a k-Step Arnoldi Method". In Preparation.   

   \Routines called:   
       dsaup2  ARPACK routine that implements the Implicitly Restarted   
               Arnoldi Iteration.   
       dstats  ARPACK routine that initialize timing and other statistics   
               variables.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dlamch  LAPACK routine that determines machine constants.   

   \Authors   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/15/93: Version ' 2.4'   

   \SCCS Information: @(#)   
   FILE: saupd.F   SID: 2.7   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   
       1. None   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsaupd_(integer *ido, char *bmat, integer *n, char *
	which, integer *nev, doublereal *tol, doublereal *resid, integer *ncv,
	 doublereal *v, integer *ldv, integer *iparam, integer *ipntr, 
	doublereal *workd, doublereal *workl, integer *lworkl, integer *info)
{
    /* Format strings */
    static char fmt_1000[] = "(//,5x,\002==================================="
	    "=======\002,/5x,\002= Symmetric implicit Arnoldi update code "
	    "=\002,/5x,\002= Version Number:\002,\002 2.4\002,19x,\002 =\002,"
	    "/5x,\002= Version Date:  \002,\002 07/31/96\002,14x,\002 =\002,/"
	    "5x,\002==========================================\002,/5x,\002= "
	    "Summary of timing statistics           =\002,/5x,\002==========="
	    "===============================\002,//)";
    static char fmt_1100[] = "(5x,\002Total number update iterations        "
	    "     = \002,i5,/5x,\002Total number of OP*x operations          "
	    "  = \002,i5,/5x,\002Total number of B*x operations             = "
	    "\002,i5,/5x,\002Total number of reorthogonalization steps  = "
	    "\002,i5,/5x,\002Total number of iterative refinement steps = "
	    "\002,i5,/5x,\002Total number of restart steps              = "
	    "\002,i5,/5x,\002Total time in user OP*x operation          = "
	    "\002,f12.6,/5x,\002Total time in user B*x operation           ="
	    " \002,f12.6,/5x,\002Total time in Arnoldi update routine       = "
	    "\002,f12.6,/5x,\002Total time in saup2 routine                ="
	    " \002,f12.6,/5x,\002Total time in basic Arnoldi iteration loop = "
	    "\002,f12.6,/5x,\002Total time in reorthogonalization phase    ="
	    " \002,f12.6,/5x,\002Total time in (re)start vector generation  = "
	    "\002,f12.6,/5x,\002Total time in trid eigenvalue subproblem   ="
	    " \002,f12.6,/5x,\002Total time in getting the shifts           = "
	    "\002,f12.6,/5x,\002Total time in applying the shifts          ="
	    " \002,f12.6,/5x,\002Total time in convergence testing          = "
	    "\002,f12.6)";

    /* System generated locals */
    integer v_dim1, v_offset, i__1, i__2;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(
	    void), do_fio(integer *, char *, ftnlen);

    /* Local variables */
    integer j;
    IGRAPH_F77_SAVE real t0, t1;
    IGRAPH_F77_SAVE integer nb, ih, iq, np, iw, ldh, ldq;
    integer nbx = 0;
    IGRAPH_F77_SAVE integer nev0, mode, ierr, iupd, next;
    integer nopx = 0;
    IGRAPH_F77_SAVE integer ritz;
    real tmvbx;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen), igraphdsaup2_(integer *, char *, integer *
	    , char *, integer *, integer *, doublereal *, doublereal *, 
	    integer *, integer *, integer *, integer *, doublereal *, integer 
	    *, doublereal *, integer *, doublereal *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    real tgetv0, tsaup2;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphsecond_(real *);
    integer logfil, ndigit;
    IGRAPH_F77_SAVE integer ishift;
    integer nitref, msaupd = 0;
    IGRAPH_F77_SAVE integer bounds;
    real titref, tseigt, tsaupd;
    extern /* Subroutine */ int igraphdstats_(void);
    IGRAPH_F77_SAVE integer msglvl;
    real tsaitr = 0.0;
    IGRAPH_F77_SAVE integer mxiter;
    real tsgets, tsapps;
    integer nrorth = 0;
    real tsconv = 0.0;
    integer nrstrt = 0;
    real tmvopx = 0.0;

    /* Fortran I/O blocks */
    static cilist io___28 = { 0, 6, 0, fmt_1000, 0 };
    static cilist io___29 = { 0, 6, 0, fmt_1100, 0 };



/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    --workd;
    --resid;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --iparam;
    --ipntr;
    --workl;

    /* Function Body */
    if (*ido == 0) {

/*        %-------------------------------%   
          | Initialize timing statistics  |   
          | & message level for debugging |   
          %-------------------------------% */

	igraphdstats_();
	igraphsecond_(&t0);
	msglvl = msaupd;

	ierr = 0;
	ishift = iparam[1];
	mxiter = iparam[3];
	nb = iparam[4];

/*        %--------------------------------------------%   
          | Revision 2 performs only implicit restart. |   
          %--------------------------------------------% */

	iupd = 1;
	mode = iparam[7];

/*        %----------------%   
          | Error checking |   
          %----------------% */

	if (*n <= 0) {
	    ierr = -1;
	} else if (*nev <= 0) {
	    ierr = -2;
	} else if (*ncv <= *nev || *ncv > *n) {
	    ierr = -3;
	}

/*        %----------------------------------------------%   
          | NP is the number of additional steps to      |   
          | extend the length NEV Lanczos factorization. |   
          %----------------------------------------------% */

	np = *ncv - *nev;

	if (mxiter <= 0) {
	    ierr = -4;
	}
	if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, 
		"SM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "LA", (
		ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "SA", (ftnlen)2, (
		ftnlen)2) != 0 && s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) != 
		0) {
	    ierr = -5;
	}
	if (*(unsigned char *)bmat != 'I' && *(unsigned char *)bmat != 'G') {
	    ierr = -6;
	}

/* Computing 2nd power */
	i__1 = *ncv;
	if (*lworkl < i__1 * i__1 + (*ncv << 3)) {
	    ierr = -7;
	}
	if (mode < 1 || mode > 5) {
	    ierr = -10;
	} else if (mode == 1 && *(unsigned char *)bmat == 'G') {
	    ierr = -11;
	} else if (ishift < 0 || ishift > 1) {
	    ierr = -12;
	} else if (*nev == 1 && s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0)
		 {
	    ierr = -13;
	}

/*        %------------%   
          | Error Exit |   
          %------------% */

	if (ierr != 0) {
	    *info = ierr;
	    *ido = 99;
	    goto L9000;
	}

/*        %------------------------%   
          | Set default parameters |   
          %------------------------% */

	if (nb <= 0) {
	    nb = 1;
	}
	if (*tol <= 0.) {
	    *tol = igraphdlamch_("EpsMach");
	}

/*        %----------------------------------------------%   
          | NP is the number of additional steps to      |   
          | extend the length NEV Lanczos factorization. |   
          | NEV0 is the local variable designating the   |   
          | size of the invariant subspace desired.      |   
          %----------------------------------------------% */

	np = *ncv - *nev;
	nev0 = *nev;

/*        %-----------------------------%   
          | Zero out internal workspace |   
          %-----------------------------%   

   Computing 2nd power */
	i__2 = *ncv;
	i__1 = i__2 * i__2 + (*ncv << 3);
	for (j = 1; j <= i__1; ++j) {
	    workl[j] = 0.;
/* L10: */
	}

/*        %-------------------------------------------------------%   
          | Pointer into WORKL for address of H, RITZ, BOUNDS, Q  |   
          | etc... and the remaining workspace.                   |   
          | Also update pointer to be used on output.             |   
          | Memory is laid out as follows:                        |   
          | workl(1:2*ncv) := generated tridiagonal matrix        |   
          | workl(2*ncv+1:2*ncv+ncv) := ritz values               |   
          | workl(3*ncv+1:3*ncv+ncv) := computed error bounds     |   
          | workl(4*ncv+1:4*ncv+ncv*ncv) := rotation matrix Q     |   
          | workl(4*ncv+ncv*ncv+1:7*ncv+ncv*ncv) := workspace     |   
          %-------------------------------------------------------% */

	ldh = *ncv;
	ldq = *ncv;
	ih = 1;
	ritz = ih + (ldh << 1);
	bounds = ritz + *ncv;
	iq = bounds + *ncv;
/* Computing 2nd power */
	i__1 = *ncv;
	iw = iq + i__1 * i__1;
	next = iw + *ncv * 3;

	ipntr[4] = next;
	ipntr[5] = ih;
	ipntr[6] = ritz;
	ipntr[7] = bounds;
	ipntr[11] = iw;
    }

/*     %-------------------------------------------------------%   
       | Carry out the Implicitly restarted Lanczos Iteration. |   
       %-------------------------------------------------------% */

    igraphdsaup2_(ido, bmat, n, which, &nev0, &np, tol, &resid[1], &mode, &iupd, &
	    ishift, &mxiter, &v[v_offset], ldv, &workl[ih], &ldh, &workl[ritz]
	    , &workl[bounds], &workl[iq], &ldq, &workl[iw], &ipntr[1], &workd[
	    1], info);

/*     %--------------------------------------------------%   
       | ido .ne. 99 implies use of reverse communication |   
       | to compute operations involving OP or shifts.    |   
       %--------------------------------------------------% */

    if (*ido == 3) {
	iparam[8] = np;
    }
    if (*ido != 99) {
	goto L9000;
    }

    iparam[3] = mxiter;
    iparam[5] = np;
    iparam[9] = nopx;
    iparam[10] = nbx;
    iparam[11] = nrorth;

/*     %------------------------------------%   
       | Exit if there was an informational |   
       | error within dsaup2.               |   
       %------------------------------------% */

    if (*info < 0) {
	goto L9000;
    }
    if (*info == 2) {
	*info = 3;
    }

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, &mxiter, &ndigit, "_saupd: number of update i"
		"terations taken", (ftnlen)41);
	igraphivout_(&logfil, &c__1, &np, &ndigit, "_saupd: number of \"converge"
		"d\" Ritz values", (ftnlen)41);
	igraphdvout_(&logfil, &np, &workl[ritz], &ndigit, "_saupd: final Ritz valu"
		"es", (ftnlen)25);
	igraphdvout_(&logfil, &np, &workl[bounds], &ndigit, "_saupd: corresponding"
		" error bounds", (ftnlen)34);
    }

    igraphsecond_(&t1);
    tsaupd = t1 - t0;

    if (msglvl > 0) {

/*        %--------------------------------------------------------%   
          | Version Number & Version Date are defined in version.h |   
          %--------------------------------------------------------% */

	s_wsfe(&io___28);
	e_wsfe();
	s_wsfe(&io___29);
	do_fio(&c__1, (char *)&mxiter, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nopx, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nbx, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nrorth, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nitref, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&nrstrt, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&tmvopx, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tmvbx, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsaupd, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsaup2, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsaitr, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&titref, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tgetv0, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tseigt, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsgets, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsapps, (ftnlen)sizeof(real));
	do_fio(&c__1, (char *)&tsconv, (ftnlen)sizeof(real));
	e_wsfe();
    }

L9000:

    return 0;

/*     %---------------%   
       | End of dsaupd |   
       %---------------% */

} /* igraphdsaupd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dscal.c0000644000175100001710000000723600000000000023644 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSCAL   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSCAL(N,DA,DX,INCX)   

         DOUBLE PRECISION DA   
         INTEGER INCX,N   
         DOUBLE PRECISION DX(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DSCAL scales a vector by a constant.   
   >    uses unrolled loops for increment equal to 1.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DA   
   > \verbatim   
   >          DA is DOUBLE PRECISION   
   >           On entry, DA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in,out] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 3/93 to return if incx .le. 0.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdscal_(integer *n, doublereal *da, doublereal *dx, 
	integer *incx)
{
    /* System generated locals */
    integer i__1, i__2;

    /* Local variables */
    integer i__, m, mp1, nincx;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dx;

    /* Function Body */
    if (*n <= 0 || *incx <= 0) {
	return 0;
    }
    if (*incx == 1) {

/*        code for increment equal to 1   


          clean-up loop */

	m = *n % 5;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dx[i__] = *da * dx[i__];
	    }
	    if (*n < 5) {
		return 0;
	    }
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 5) {
	    dx[i__] = *da * dx[i__];
	    dx[i__ + 1] = *da * dx[i__ + 1];
	    dx[i__ + 2] = *da * dx[i__ + 2];
	    dx[i__ + 3] = *da * dx[i__ + 3];
	    dx[i__ + 4] = *da * dx[i__ + 4];
	}
    } else {

/*        code for increment not equal to 1 */

	nincx = *n * *incx;
	i__1 = nincx;
	i__2 = *incx;
	for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
	    dx[i__] = *da * dx[i__];
	}
    }
    return 0;
} /* igraphdscal_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsconv.c0000644000175100001710000001057500000000000024052 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b3 = .66666666666666663;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsconv   

   \Description:   
    Convergence testing for the symmetric Arnoldi eigenvalue routine.   

   \Usage:   
    call dsconv   
       ( N, RITZ, BOUNDS, TOL, NCONV )   

   \Arguments   
    N       Integer.  (INPUT)   
            Number of Ritz values to check for convergence.   

    RITZ    Double precision array of length N.  (INPUT)   
            The Ritz values to be checked for convergence.   

    BOUNDS  Double precision array of length N.  (INPUT)   
            Ritz estimates associated with the Ritz values in RITZ.   

    TOL     Double precision scalar.  (INPUT)   
            Desired relative accuracy for a Ritz value to be considered   
            "converged".   

    NCONV   Integer scalar.  (OUTPUT)   
            Number of "converged" Ritz values.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Routines called:   
       second  ARPACK utility routine for timing.   
       dlamch  LAPACK routine that determines machine constants.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: sconv.F   SID: 2.4   DATE OF SID: 4/19/96   RELEASE: 2   

   \Remarks   
       1. Starting with version 2.4, this routine no longer uses the   
          Parlett strategy using the gap conditions.   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsconv_(integer *n, doublereal *ritz, doublereal *bounds,
	 doublereal *tol, integer *nconv)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double pow_dd(doublereal *, doublereal *);

    /* Local variables */
    integer i__;
    IGRAPH_F77_SAVE real t0, t1;
    doublereal eps23, temp;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphsecond_(real *);
    real tsconv = 0;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %-------------------%   
       | External routines |   
       %-------------------%   

       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    --bounds;
    --ritz;

    /* Function Body */
    igraphsecond_(&t0);

    eps23 = igraphdlamch_("Epsilon-Machine");
    eps23 = pow_dd(&eps23, &c_b3);

    *nconv = 0;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {

/*        %-----------------------------------------------------%   
          | The i-th Ritz value is considered "converged"       |   
          | when: bounds(i) .le. TOL*max(eps23, abs(ritz(i)))   |   
          %-----------------------------------------------------%   

   Computing MAX */
	d__2 = eps23, d__3 = (d__1 = ritz[i__], abs(d__1));
	temp = max(d__2,d__3);
	if (bounds[i__] <= *tol * temp) {
	    ++(*nconv);
	}

/* L10: */
    }

    igraphsecond_(&t1);
    tsconv += t1 - t0;

    return 0;

/*     %---------------%   
       | End of dsconv |   
       %---------------% */

} /* igraphdsconv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dseigt.c0000644000175100001710000001477700000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dseigt   

   \Description:   
    Compute the eigenvalues of the current symmetric tridiagonal matrix   
    and the corresponding error bounds given the current residual norm.   

   \Usage:   
    call dseigt   
       ( RNORM, N, H, LDH, EIG, BOUNDS, WORKL, IERR )   

   \Arguments   
    RNORM   Double precision scalar.  (INPUT)   
            RNORM contains the residual norm corresponding to the current   
            symmetric tridiagonal matrix H.   

    N       Integer.  (INPUT)   
            Size of the symmetric tridiagonal matrix H.   

    H       Double precision N by 2 array.  (INPUT)   
            H contains the symmetric tridiagonal matrix with the   
            subdiagonal in the first column starting at H(2,1) and the   
            main diagonal in second column.   

    LDH     Integer.  (INPUT)   
            Leading dimension of H exactly as declared in the calling   
            program.   

    EIG     Double precision array of length N.  (OUTPUT)   
            On output, EIG contains the N eigenvalues of H possibly   
            unsorted.  The BOUNDS arrays are returned in the   
            same sorted order as EIG.   

    BOUNDS  Double precision array of length N.  (OUTPUT)   
            On output, BOUNDS contains the error estimates corresponding   
            to the eigenvalues EIG.  This is equal to RNORM times the   
            last components of the eigenvectors corresponding to the   
            eigenvalues in EIG.   

    WORKL   Double precision work array of length 3*N.  (WORKSPACE)   
            Private (replicated) array on each PE or array allocated on   
            the front end.   

    IERR    Integer.  (OUTPUT)   
            Error exit flag from dstqrb.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dstqrb  ARPACK routine that computes the eigenvalues and the   
               last components of the eigenvectors of a symmetric   
               and tridiagonal matrix.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dcopy   Level 1 BLAS that copies one vector to another.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.4'   

   \SCCS Information: @(#)   
   FILE: seigt.F   SID: 2.4   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   
       None   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdseigt_(doublereal *rnorm, integer *n, doublereal *h__, 
	integer *ldh, doublereal *eig, doublereal *bounds, doublereal *workl, 
	integer *ierr)
{
    /* System generated locals */
    integer h_dim1, h_offset, i__1;
    doublereal d__1;

    /* Local variables */
    integer k;
    IGRAPH_F77_SAVE real t0, t1;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdvout_(integer *, integer *, doublereal 
	    *, integer *, char *, ftnlen), igraphsecond_(real *);
    integer logfil, ndigit, mseigt = 0;
    extern /* Subroutine */ int igraphdstqrb_(integer *, doublereal *, doublereal *,
	     doublereal *, doublereal *, integer *);
    real tseigt = 0.0;
    integer msglvl;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------%   

       Parameter adjustments */
    --workl;
    --bounds;
    --eig;
    h_dim1 = *ldh;
    h_offset = 1 + h_dim1;
    h__ -= h_offset;

    /* Function Body */
    igraphsecond_(&t0);
    msglvl = mseigt;

    if (msglvl > 0) {
	igraphdvout_(&logfil, n, &h__[(h_dim1 << 1) + 1], &ndigit, "_seigt: main d"
		"iagonal of matrix H", (ftnlen)33);
	if (*n > 1) {
	    i__1 = *n - 1;
	    igraphdvout_(&logfil, &i__1, &h__[h_dim1 + 2], &ndigit, "_seigt: sub d"
		    "iagonal of matrix H", (ftnlen)32);
	}
    }

    igraphdcopy_(n, &h__[(h_dim1 << 1) + 1], &c__1, &eig[1], &c__1);
    i__1 = *n - 1;
    igraphdcopy_(&i__1, &h__[h_dim1 + 2], &c__1, &workl[1], &c__1);
    igraphdstqrb_(n, &eig[1], &workl[1], &bounds[1], &workl[*n + 1], ierr);
    if (*ierr != 0) {
	goto L9000;
    }
    if (msglvl > 1) {
	igraphdvout_(&logfil, n, &bounds[1], &ndigit, "_seigt: last row of the eig"
		"envector matrix for H", (ftnlen)48);
    }

/*     %-----------------------------------------------%   
       | Finally determine the error bounds associated |   
       | with the n Ritz values of H.                  |   
       %-----------------------------------------------% */

    i__1 = *n;
    for (k = 1; k <= i__1; ++k) {
	bounds[k] = *rnorm * (d__1 = bounds[k], abs(d__1));
/* L30: */
    }

    igraphsecond_(&t1);
    tseigt += t1 - t0;

L9000:
    return 0;

/*     %---------------%   
       | End of dseigt |   
       %---------------% */

} /* igraphdseigt_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsesrt.c0000644000175100001710000001433200000000000024055 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsesrt   

   \Description:   
    Sort the array X in the order specified by WHICH and optionally   
    apply the permutation to the columns of the matrix A.   

   \Usage:   
    call dsesrt   
       ( WHICH, APPLY, N, X, NA, A, LDA)   

   \Arguments   
    WHICH   Character*2.  (Input)   
            'LM' -> X is sorted into increasing order of magnitude.   
            'SM' -> X is sorted into decreasing order of magnitude.   
            'LA' -> X is sorted into increasing order of algebraic.   
            'SA' -> X is sorted into decreasing order of algebraic.   

    APPLY   Logical.  (Input)   
            APPLY = .TRUE.  -> apply the sorted order to A.   
            APPLY = .FALSE. -> do not apply the sorted order to A.   

    N       Integer.  (INPUT)   
            Dimension of the array X.   

    X      Double precision array of length N.  (INPUT/OUTPUT)   
            The array to be sorted.   

    NA      Integer.  (INPUT)   
            Number of rows of the matrix A.   

    A      Double precision array of length NA by N.  (INPUT/OUTPUT)   

    LDA     Integer.  (INPUT)   
            Leading dimension of A.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Routines   
       dswap  Level 1 BLAS that swaps the contents of two vectors.   

   \Authors   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/15/93: Version ' 2.1'.   
                 Adapted from the sort routine in LANSO and   
                 the ARPACK code dsortr   

   \SCCS Information: @(#)   
   FILE: sesrt.F   SID: 2.3   DATE OF SID: 4/19/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsesrt_(char *which, logical *apply, integer *n, 
	doublereal *x, integer *na, doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    integer i__, j, igap;
    doublereal temp;
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);


/*     %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1 * 0;
    a -= a_offset;

    /* Function Body */
    igap = *n / 2;

    if (s_cmp(which, "SA", (ftnlen)2, (ftnlen)2) == 0) {

/*        X is sorted into decreasing order of algebraic. */

L10:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L20:

	    if (j < 0) {
		goto L30;
	    }

	    if (x[j] < x[j + igap]) {
		temp = x[j];
		x[j] = x[j + igap];
		x[j + igap] = temp;
		if (*apply) {
		    igraphdswap_(na, &a[j * a_dim1 + 1], &c__1, &a[(j + igap) * 
			    a_dim1 + 1], &c__1);
		}
	    } else {
		goto L30;
	    }
	    j -= igap;
	    goto L20;
L30:
	    ;
	}
	igap /= 2;
	goto L10;

    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {

/*        X is sorted into decreasing order of magnitude. */

L40:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L50:

	    if (j < 0) {
		goto L60;
	    }

	    if ((d__1 = x[j], abs(d__1)) < (d__2 = x[j + igap], abs(d__2))) {
		temp = x[j];
		x[j] = x[j + igap];
		x[j + igap] = temp;
		if (*apply) {
		    igraphdswap_(na, &a[j * a_dim1 + 1], &c__1, &a[(j + igap) * 
			    a_dim1 + 1], &c__1);
		}
	    } else {
		goto L60;
	    }
	    j -= igap;
	    goto L50;
L60:
	    ;
	}
	igap /= 2;
	goto L40;

    } else if (s_cmp(which, "LA", (ftnlen)2, (ftnlen)2) == 0) {

/*        X is sorted into increasing order of algebraic. */

L70:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L80:

	    if (j < 0) {
		goto L90;
	    }

	    if (x[j] > x[j + igap]) {
		temp = x[j];
		x[j] = x[j + igap];
		x[j + igap] = temp;
		if (*apply) {
		    igraphdswap_(na, &a[j * a_dim1 + 1], &c__1, &a[(j + igap) * 
			    a_dim1 + 1], &c__1);
		}
	    } else {
		goto L90;
	    }
	    j -= igap;
	    goto L80;
L90:
	    ;
	}
	igap /= 2;
	goto L70;

    } else if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {

/*        X is sorted into increasing order of magnitude. */

L100:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L110:

	    if (j < 0) {
		goto L120;
	    }

	    if ((d__1 = x[j], abs(d__1)) > (d__2 = x[j + igap], abs(d__2))) {
		temp = x[j];
		x[j] = x[j + igap];
		x[j + igap] = temp;
		if (*apply) {
		    igraphdswap_(na, &a[j * a_dim1 + 1], &c__1, &a[(j + igap) * 
			    a_dim1 + 1], &c__1);
		}
	    } else {
		goto L120;
	    }
	    j -= igap;
	    goto L110;
L120:
	    ;
	}
	igap /= 2;
	goto L100;
    }

L9000:
    return 0;

/*     %---------------%   
       | End of dsesrt |   
       %---------------% */

} /* igraphdsesrt_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dseupd.c0000644000175100001710000012017600000000000024041 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b21 = .66666666666666663;
static integer c__1 = 1;
static integer c__2 = 2;
static logical c_true = TRUE_;
static doublereal c_b119 = 1.;

/* \BeginDoc   

   \Name: dseupd   

   \Description:   

    This subroutine returns the converged approximations to eigenvalues   
    of A*z = lambda*B*z and (optionally):   

        (1) the corresponding approximate eigenvectors,   

        (2) an orthonormal (Lanczos) basis for the associated approximate   
            invariant subspace,   

        (3) Both.   

    There is negligible additional cost to obtain eigenvectors.  An orthonormal   
    (Lanczos) basis is always computed.  There is an additional storage cost   
    of n*nev if both are requested (in this case a separate array Z must be   
    supplied).   

    These quantities are obtained from the Lanczos factorization computed   
    by DSAUPD for the linear operator OP prescribed by the MODE selection   
    (see IPARAM(7) in DSAUPD documentation.)  DSAUPD must be called before   
    this routine is called. These approximate eigenvalues and vectors are   
    commonly called Ritz values and Ritz vectors respectively.  They are   
    referred to as such in the comments that follow.   The computed orthonormal   
    basis for the invariant subspace corresponding to these Ritz values is   
    referred to as a Lanczos basis.   

    See documentation in the header of the subroutine DSAUPD for a definition   
    of OP as well as other terms and the relation of computed Ritz values   
    and vectors of OP with respect to the given problem  A*z = lambda*B*z.   

    The approximate eigenvalues of the original problem are returned in   
    ascending algebraic order.  The user may elect to call this routine   
    once for each desired Ritz vector and store it peripherally if desired.   
    There is also the option of computing a selected set of these vectors   
    with a single call.   

   \Usage:   
    call dseupd   
       ( RVEC, HOWMNY, SELECT, D, Z, LDZ, SIGMA, BMAT, N, WHICH, NEV, TOL,   
         RESID, NCV, V, LDV, IPARAM, IPNTR, WORKD, WORKL, LWORKL, INFO )   

    RVEC    LOGICAL  (INPUT)   
            Specifies whether Ritz vectors corresponding to the Ritz value   
            approximations to the eigenproblem A*z = lambda*B*z are computed.   

               RVEC = .FALSE.     Compute Ritz values only.   

               RVEC = .TRUE.      Compute Ritz vectors.   

    HOWMNY  Character*1  (INPUT)   
            Specifies how many Ritz vectors are wanted and the form of Z   
            the matrix of Ritz vectors. See remark 1 below.   
            = 'A': compute NEV Ritz vectors;   
            = 'S': compute some of the Ritz vectors, specified   
                   by the logical array SELECT.   

    SELECT  Logical array of dimension NEV.  (INPUT)   
            If HOWMNY = 'S', SELECT specifies the Ritz vectors to be   
            computed. To select the Ritz vector corresponding to a   
            Ritz value D(j), SELECT(j) must be set to .TRUE..   
            If HOWMNY = 'A' , SELECT is not referenced.   

    D       Double precision array of dimension NEV.  (OUTPUT)   
            On exit, D contains the Ritz value approximations to the   
            eigenvalues of A*z = lambda*B*z. The values are returned   
            in ascending order. If IPARAM(7) = 3,4,5 then D represents   
            the Ritz values of OP computed by dsaupd transformed to   
            those of the original eigensystem A*z = lambda*B*z. If   
            IPARAM(7) = 1,2 then the Ritz values of OP are the same   
            as the those of A*z = lambda*B*z.   

    Z       Double precision N by NEV array if HOWMNY = 'A'.  (OUTPUT)   
            On exit, Z contains the B-orthonormal Ritz vectors of the   
            eigensystem A*z = lambda*B*z corresponding to the Ritz   
            value approximations.   
            If  RVEC = .FALSE. then Z is not referenced.   
            NOTE: The array Z may be set equal to first NEV columns of the   
            Arnoldi/Lanczos basis array V computed by DSAUPD.   

    LDZ     Integer.  (INPUT)   
            The leading dimension of the array Z.  If Ritz vectors are   
            desired, then  LDZ .ge.  max( 1, N ).  In any case,  LDZ .ge. 1.   

    SIGMA   Double precision  (INPUT)   
            If IPARAM(7) = 3,4,5 represents the shift. Not referenced if   
            IPARAM(7) = 1 or 2.   


    **** The remaining arguments MUST be the same as for the   ****   
    **** call to DNAUPD that was just completed.               ****   

    NOTE: The remaining arguments   

             BMAT, N, WHICH, NEV, TOL, RESID, NCV, V, LDV, IPARAM, IPNTR,   
             WORKD, WORKL, LWORKL, INFO   

           must be passed directly to DSEUPD following the last call   
           to DSAUPD.  These arguments MUST NOT BE MODIFIED between   
           the the last call to DSAUPD and the call to DSEUPD.   

    Two of these parameters (WORKL, INFO) are also output parameters:   

    WORKL   Double precision work array of length LWORKL.  (OUTPUT/WORKSPACE)   
            WORKL(1:4*ncv) contains information obtained in   
            dsaupd.  They are not changed by dseupd.   
            WORKL(4*ncv+1:ncv*ncv+8*ncv) holds the   
            untransformed Ritz values, the computed error estimates,   
            and the associated eigenvector matrix of H.   

            Note: IPNTR(8:10) contains the pointer into WORKL for addresses   
            of the above information computed by dseupd.   
            -------------------------------------------------------------   
            IPNTR(8): pointer to the NCV RITZ values of the original system.   
            IPNTR(9): pointer to the NCV corresponding error bounds.   
            IPNTR(10): pointer to the NCV by NCV matrix of eigenvectors   
                       of the tridiagonal matrix T. Only referenced by   
                       dseupd if RVEC = .TRUE. See Remarks.   
            -------------------------------------------------------------   

    INFO    Integer.  (OUTPUT)   
            Error flag on output.   
            =  0: Normal exit.   
            = -1: N must be positive.   
            = -2: NEV must be positive.   
            = -3: NCV must be greater than NEV and less than or equal to N.   
            = -5: WHICH must be one of 'LM', 'SM', 'LA', 'SA' or 'BE'.   
            = -6: BMAT must be one of 'I' or 'G'.   
            = -7: Length of private work WORKL array is not sufficient.   
            = -8: Error return from trid. eigenvalue calculation;   
                  Information error from LAPACK routine dsteqr.   
            = -9: Starting vector is zero.   
            = -10: IPARAM(7) must be 1,2,3,4,5.   
            = -11: IPARAM(7) = 1 and BMAT = 'G' are incompatible.   
            = -12: NEV and WHICH = 'BE' are incompatible.   
            = -14: DSAUPD did not find any eigenvalues to sufficient   
                   accuracy.   
            = -15: HOWMNY must be one of 'A' or 'S' if RVEC = .true.   
            = -16: HOWMNY = 'S' not yet implemented   

   \BeginLib   

   \References:   
    1. D.C. Sorensen, "Implicit Application of Polynomial Filters in   
       a k-Step Arnoldi Method", SIAM J. Matr. Anal. Apps., 13 (1992),   
       pp 357-385.   
    2. R.B. Lehoucq, "Analysis and Implementation of an Implicitly   
       Restarted Arnoldi Iteration", Rice University Technical Report   
       TR95-13, Department of Computational and Applied Mathematics.   
    3. B.N. Parlett, "The Symmetric Eigenvalue Problem". Prentice-Hall,   
       1980.   
    4. B.N. Parlett, B. Nour-Omid, "Towards a Black Box Lanczos Program",   
       Computer Physics Communications, 53 (1989), pp 169-179.   
    5. B. Nour-Omid, B.N. Parlett, T. Ericson, P.S. Jensen, "How to   
       Implement the Spectral Transformation", Math. Comp., 48 (1987),   
       pp 663-673.   
    6. R.G. Grimes, J.G. Lewis and H.D. Simon, "A Shifted Block Lanczos   
       Algorithm for Solving Sparse Symmetric Generalized Eigenproblems",   
       SIAM J. Matr. Anal. Apps.,  January (1993).   
    7. L. Reichel, W.B. Gragg, "Algorithm 686: FORTRAN Subroutines   
       for Updating the QR decomposition", ACM TOMS, December 1990,   
       Volume 16 Number 4, pp 369-377.   

   \Remarks   
    1. The converged Ritz values are always returned in increasing   
       (algebraic) order.   

    2. Currently only HOWMNY = 'A' is implemented. It is included at this   
       stage for the user who wants to incorporate it.   

   \Routines called:   
       dsesrt  ARPACK routine that sorts an array X, and applies the   
               corresponding permutation to a matrix A.   
       dsortr  dsortr  ARPACK sorting routine.   
       ivout   ARPACK utility routine that prints integers.   
       dvout   ARPACK utility routine that prints vectors.   
       dgeqr2  LAPACK routine that computes the QR factorization of   
               a matrix.   
       dlacpy  LAPACK matrix copy routine.   
       dlamch  LAPACK routine that determines machine constants.   
       dorm2r  LAPACK routine that applies an orthogonal matrix in   
               factored form.   
       dsteqr  LAPACK routine that computes eigenvalues and eigenvectors   
               of a tridiagonal matrix.   
       dger    Level 2 BLAS rank one update to a matrix.   
       dcopy   Level 1 BLAS that copies one vector to another .   
       dnrm2   Level 1 BLAS that computes the norm of a vector.   
       dscal   Level 1 BLAS that scales a vector.   
       dswap   Level 1 BLAS that swaps the contents of two vectors.   
   \Authors   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Chao Yang                    Houston, Texas   
       Dept. of Computational &   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/15/93: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: seupd.F   SID: 2.7   DATE OF SID: 8/27/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   
   Subroutine */ int igraphdseupd_(logical *rvec, char *howmny, logical *select, 
	doublereal *d__, doublereal *z__, integer *ldz, doublereal *sigma, 
	char *bmat, integer *n, char *which, integer *nev, doublereal *tol, 
	doublereal *resid, integer *ncv, doublereal *v, integer *ldv, integer 
	*iparam, integer *ipntr, doublereal *workd, doublereal *workl, 
	integer *lworkl, integer *info)
{
    /* System generated locals */
    integer v_dim1, v_offset, z_dim1, z_offset, i__1;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    double pow_dd(doublereal *, doublereal *);

    /* Local variables */
    integer j, k, ih, iq, iw;
    doublereal kv[2];
    integer ibd, ihb, ihd, ldh, ilg, ldq, ism, irz;
    extern /* Subroutine */ int igraphdger_(integer *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    integer mode;
    doublereal eps23;
    integer ierr;
    doublereal temp;
    integer next;
    char type__[6];
    integer ritz;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    logical reord;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    integer nconv;
    doublereal rnorm;
    extern /* Subroutine */ int igraphdvout_(integer *, integer *, doublereal *, 
	    integer *, char *, ftnlen), igraphivout_(integer *, integer *, integer *
	    , integer *, char *, ftnlen), igraphdgeqr2_(integer *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *);
    doublereal bnorm2;
    extern /* Subroutine */ int igraphdorm2r_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *);
    doublereal thres1, thres2;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *);
    integer logfil, ndigit, bounds, mseupd = 0;
    extern /* Subroutine */ int igraphdsteqr_(char *, integer *, doublereal *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *);
    integer msglvl, ktrord;
    extern /* Subroutine */ int igraphdsesrt_(char *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphdsortr_(char *, logical *, integer *, doublereal *, doublereal *);
    doublereal tempbnd;
    integer leftptr, rghtptr;


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %--------------%   
       | Local Arrays |   
       %--------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %------------------------%   
       | Set default parameters |   
       %------------------------%   

       Parameter adjustments */
    --workd;
    --resid;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --d__;
    --select;
    v_dim1 = *ldv;
    v_offset = 1 + v_dim1;
    v -= v_offset;
    --iparam;
    --ipntr;
    --workl;

    /* Function Body */
    msglvl = mseupd;
    mode = iparam[7];
    nconv = iparam[5];
    *info = 0;

/*     %--------------%   
       | Quick return |   
       %--------------% */

    if (nconv == 0) {
	goto L9000;
    }
    ierr = 0;

    if (nconv <= 0) {
	ierr = -14;
    }
    if (*n <= 0) {
	ierr = -1;
    }
    if (*nev <= 0) {
	ierr = -2;
    }
    if (*ncv <= *nev || *ncv > *n) {
	ierr = -3;
    }
    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "SM", (
	    ftnlen)2, (ftnlen)2) != 0 && s_cmp(which, "LA", (ftnlen)2, (
	    ftnlen)2) != 0 && s_cmp(which, "SA", (ftnlen)2, (ftnlen)2) != 0 &&
	     s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) != 0) {
	ierr = -5;
    }
    if (*(unsigned char *)bmat != 'I' && *(unsigned char *)bmat != 'G') {
	ierr = -6;
    }
    if (*(unsigned char *)howmny != 'A' && *(unsigned char *)howmny != 'P' && 
	    *(unsigned char *)howmny != 'S' && *rvec) {
	ierr = -15;
    }
    if (*rvec && *(unsigned char *)howmny == 'S') {
	ierr = -16;
    }

/* Computing 2nd power */
    i__1 = *ncv;
    if (*rvec && *lworkl < i__1 * i__1 + (*ncv << 3)) {
	ierr = -7;
    }

    if (mode == 1 || mode == 2) {
	s_copy(type__, "REGULR", (ftnlen)6, (ftnlen)6);
    } else if (mode == 3) {
	s_copy(type__, "SHIFTI", (ftnlen)6, (ftnlen)6);
    } else if (mode == 4) {
	s_copy(type__, "BUCKLE", (ftnlen)6, (ftnlen)6);
    } else if (mode == 5) {
	s_copy(type__, "CAYLEY", (ftnlen)6, (ftnlen)6);
    } else {
	ierr = -10;
    }
    if (mode == 1 && *(unsigned char *)bmat == 'G') {
	ierr = -11;
    }
    if (*nev == 1 && s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {
	ierr = -12;
    }

/*     %------------%   
       | Error Exit |   
       %------------% */

    if (ierr != 0) {
	*info = ierr;
	goto L9000;
    }

/*     %-------------------------------------------------------%   
       | Pointer into WORKL for address of H, RITZ, BOUNDS, Q  |   
       | etc... and the remaining workspace.                   |   
       | Also update pointer to be used on output.             |   
       | Memory is laid out as follows:                        |   
       | workl(1:2*ncv) := generated tridiagonal matrix H      |   
       |       The subdiagonal is stored in workl(2:ncv).      |   
       |       The dead spot is workl(1) but upon exiting      |   
       |       dsaupd stores the B-norm of the last residual   |   
       |       vector in workl(1). We use this !!!             |   
       | workl(2*ncv+1:2*ncv+ncv) := ritz values               |   
       |       The wanted values are in the first NCONV spots. |   
       | workl(3*ncv+1:3*ncv+ncv) := computed Ritz estimates   |   
       |       The wanted values are in the first NCONV spots. |   
       | NOTE: workl(1:4*ncv) is set by dsaupd and is not      |   
       |       modified by dseupd.                             |   
       %-------------------------------------------------------%   

       %-------------------------------------------------------%   
       | The following is used and set by dseupd.              |   
       | workl(4*ncv+1:4*ncv+ncv) := used as workspace during  |   
       |       computation of the eigenvectors of H. Stores    |   
       |       the diagonal of H. Upon EXIT contains the NCV   |   
       |       Ritz values of the original system. The first   |   
       |       NCONV spots have the wanted values. If MODE =   |   
       |       1 or 2 then will equal workl(2*ncv+1:3*ncv).    |   
       | workl(5*ncv+1:5*ncv+ncv) := used as workspace during  |   
       |       computation of the eigenvectors of H. Stores    |   
       |       the subdiagonal of H. Upon EXIT contains the    |   
       |       NCV corresponding Ritz estimates of the         |   
       |       original system. The first NCONV spots have the |   
       |       wanted values. If MODE = 1,2 then will equal    |   
       |       workl(3*ncv+1:4*ncv).                           |   
       | workl(6*ncv+1:6*ncv+ncv*ncv) := orthogonal Q that is  |   
       |       the eigenvector matrix for H as returned by     |   
       |       dsteqr. Not referenced if RVEC = .False.        |   
       |       Ordering follows that of workl(4*ncv+1:5*ncv)   |   
       | workl(6*ncv+ncv*ncv+1:6*ncv+ncv*ncv+2*ncv) :=         |   
       |       Workspace. Needed by dsteqr and by dseupd.      |   
       | GRAND total of NCV*(NCV+8) locations.                 |   
       %-------------------------------------------------------% */


    ih = ipntr[5];
    ritz = ipntr[6];
    bounds = ipntr[7];
    ldh = *ncv;
    ldq = *ncv;
    ihd = bounds + ldh;
    ihb = ihd + ldh;
    iq = ihb + ldh;
    iw = iq + ldh * *ncv;
    next = iw + (*ncv << 1);
    ipntr[4] = next;
    ipntr[8] = ihd;
    ipntr[9] = ihb;
    ipntr[10] = iq;

/*     %----------------------------------------%   
       | irz points to the Ritz values computed |   
       |     by _seigt before exiting _saup2.   |   
       | ibd points to the Ritz estimates       |   
       |     computed by _seigt before exiting  |   
       |     _saup2.                            |   
       %----------------------------------------% */

    irz = ipntr[11] + *ncv;
    ibd = irz + *ncv;


/*     %---------------------------------%   
       | Set machine dependent constant. |   
       %---------------------------------% */

    eps23 = igraphdlamch_("Epsilon-Machine");
    eps23 = pow_dd(&eps23, &c_b21);

/*     %---------------------------------------%   
       | RNORM is B-norm of the RESID(1:N).    |   
       | BNORM2 is the 2 norm of B*RESID(1:N). |   
       | Upon exit of dsaupd WORKD(1:N) has    |   
       | B*RESID(1:N).                         |   
       %---------------------------------------% */

    rnorm = workl[ih];
    if (*(unsigned char *)bmat == 'I') {
	bnorm2 = rnorm;
    } else if (*(unsigned char *)bmat == 'G') {
	bnorm2 = igraphdnrm2_(n, &workd[1], &c__1);
    }

    if (*rvec) {

/*        %------------------------------------------------%   
          | Get the converged Ritz value on the boundary.  |   
          | This value will be used to dermine whether we  |   
          | need to reorder the eigenvalues and            |   
          | eigenvectors comupted by _steqr, and is        |   
          | referred to as the "threshold" value.          |   
          |                                                |   
          | A Ritz value gamma is said to be a wanted      |   
          | one, if                                        |   
          | abs(gamma) .ge. threshold, when WHICH = 'LM';  |   
          | abs(gamma) .le. threshold, when WHICH = 'SM';  |   
          | gamma      .ge. threshold, when WHICH = 'LA';  |   
          | gamma      .le. threshold, when WHICH = 'SA';  |   
          | gamma .le. thres1 .or. gamma .ge. thres2       |   
          |                            when WHICH = 'BE';  |   
          |                                                |   
          | Note: converged Ritz values and associated     |   
          | Ritz estimates have been placed in the first   |   
          | NCONV locations in workl(ritz) and             |   
          | workl(bounds) respectively. They have been     |   
          | sorted (in _saup2) according to the WHICH      |   
          | selection criterion. (Except in the case       |   
          | WHICH = 'BE', they are sorted in an increasing |   
          | order.)                                        |   
          %------------------------------------------------% */

	if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(which, 
		"SM", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(which, "LA", (
		ftnlen)2, (ftnlen)2) == 0 || s_cmp(which, "SA", (ftnlen)2, (
		ftnlen)2) == 0) {

	    thres1 = workl[ritz];

	    if (msglvl > 2) {
		igraphdvout_(&logfil, &c__1, &thres1, &ndigit, "_seupd: Threshold "
			"eigenvalue used for re-ordering", (ftnlen)49);
	    }

	} else if (s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {

/*            %------------------------------------------------%   
              | Ritz values returned from _saup2 have been     |   
              | sorted in increasing order.  Thus two          |   
              | "threshold" values (one for the small end, one |   
              | for the large end) are in the middle.          |   
              %------------------------------------------------% */

	    ism = max(*nev,nconv) / 2;
	    ilg = ism + 1;
	    thres1 = workl[ism];
	    thres2 = workl[ilg];

	    if (msglvl > 2) {
		kv[0] = thres1;
		kv[1] = thres2;
		igraphdvout_(&logfil, &c__2, kv, &ndigit, "_seupd: Threshold eigen"
			"values used for re-ordering", (ftnlen)50);
	    }

	}

/*        %----------------------------------------------------------%   
          | Check to see if all converged Ritz values appear within  |   
          | the first NCONV diagonal elements returned from _seigt.  |   
          | This is done in the following way:                       |   
          |                                                          |   
          | 1) For each Ritz value obtained from _seigt, compare it  |   
          |    with the threshold Ritz value computed above to       |   
          |    determine whether it is a wanted one.                 |   
          |                                                          |   
          | 2) If it is wanted, then check the corresponding Ritz    |   
          |    estimate to see if it has converged.  If it has, set  |   
          |    correponding entry in the logical array SELECT to     |   
          |    .TRUE..                                               |   
          |                                                          |   
          | If SELECT(j) = .TRUE. and j > NCONV, then there is a     |   
          | converged Ritz value that does not appear at the top of  |   
          | the diagonal matrix computed by _seigt in _saup2.        |   
          | Reordering is needed.                                    |   
          %----------------------------------------------------------% */

	reord = FALSE_;
	ktrord = 0;
	i__1 = *ncv - 1;
	for (j = 0; j <= i__1; ++j) {
	    select[j + 1] = FALSE_;
	    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {
		if ((d__1 = workl[irz + j], abs(d__1)) >= abs(thres1)) {
/* Computing MAX */
		    d__2 = eps23, d__3 = (d__1 = workl[irz + j], abs(d__1));
		    tempbnd = max(d__2,d__3);
		    if (workl[ibd + j] <= *tol * tempbnd) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {
		if ((d__1 = workl[irz + j], abs(d__1)) <= abs(thres1)) {
/* Computing MAX */
		    d__2 = eps23, d__3 = (d__1 = workl[irz + j], abs(d__1));
		    tempbnd = max(d__2,d__3);
		    if (workl[ibd + j] <= *tol * tempbnd) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "LA", (ftnlen)2, (ftnlen)2) == 0) {
		if (workl[irz + j] >= thres1) {
/* Computing MAX */
		    d__2 = eps23, d__3 = (d__1 = workl[irz + j], abs(d__1));
		    tempbnd = max(d__2,d__3);
		    if (workl[ibd + j] <= *tol * tempbnd) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "SA", (ftnlen)2, (ftnlen)2) == 0) {
		if (workl[irz + j] <= thres1) {
/* Computing MAX */
		    d__2 = eps23, d__3 = (d__1 = workl[irz + j], abs(d__1));
		    tempbnd = max(d__2,d__3);
		    if (workl[ibd + j] <= *tol * tempbnd) {
			select[j + 1] = TRUE_;
		    }
		}
	    } else if (s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {
		if (workl[irz + j] <= thres1 || workl[irz + j] >= thres2) {
/* Computing MAX */
		    d__2 = eps23, d__3 = (d__1 = workl[irz + j], abs(d__1));
		    tempbnd = max(d__2,d__3);
		    if (workl[ibd + j] <= *tol * tempbnd) {
			select[j + 1] = TRUE_;
		    }
		}
	    }
	    if (j + 1 > nconv) {
		reord = select[j + 1] || reord;
	    }
	    if (select[j + 1]) {
		++ktrord;
	    }
/* L10: */
	}
/*        %-------------------------------------------%   
          | If KTRORD .ne. NCONV, something is wrong. |   
          %-------------------------------------------% */

	if (msglvl > 2) {
	    igraphivout_(&logfil, &c__1, &ktrord, &ndigit, "_seupd: Number of spec"
		    "ified eigenvalues", (ftnlen)39);
	    igraphivout_(&logfil, &c__1, &nconv, &ndigit, "_seupd: Number of \"con"
		    "verged\" eigenvalues", (ftnlen)41);
	}

/*        %-----------------------------------------------------------%   
          | Call LAPACK routine _steqr to compute the eigenvalues and |   
          | eigenvectors of the final symmetric tridiagonal matrix H. |   
          | Initialize the eigenvector matrix Q to the identity.      |   
          %-----------------------------------------------------------% */

	i__1 = *ncv - 1;
	igraphdcopy_(&i__1, &workl[ih + 1], &c__1, &workl[ihb], &c__1);
	igraphdcopy_(ncv, &workl[ih + ldh], &c__1, &workl[ihd], &c__1);

	igraphdsteqr_("Identity", ncv, &workl[ihd], &workl[ihb], &workl[iq], &ldq, &
		workl[iw], &ierr);

	if (ierr != 0) {
	    *info = -8;
	    goto L9000;
	}

	if (msglvl > 1) {
	    igraphdcopy_(ncv, &workl[iq + *ncv - 1], &ldq, &workl[iw], &c__1);
	    igraphdvout_(&logfil, ncv, &workl[ihd], &ndigit, "_seupd: NCV Ritz val"
		    "ues of the final H matrix", (ftnlen)45);
	    igraphdvout_(&logfil, ncv, &workl[iw], &ndigit, "_seupd: last row of t"
		    "he eigenvector matrix for H", (ftnlen)48);
	}

	if (reord) {

/*           %---------------------------------------------%   
             | Reordered the eigenvalues and eigenvectors  |   
             | computed by _steqr so that the "converged"  |   
             | eigenvalues appear in the first NCONV       |   
             | positions of workl(ihd), and the associated |   
             | eigenvectors appear in the first NCONV      |   
             | columns.                                    |   
             %---------------------------------------------% */

	    leftptr = 1;
	    rghtptr = *ncv;

	    if (*ncv == 1) {
		goto L30;
	    }

L20:
	    if (select[leftptr]) {

/*              %-------------------------------------------%   
                | Search, from the left, for the first Ritz |   
                | value that has not converged.             |   
                %-------------------------------------------% */

		++leftptr;

	    } else if (! select[rghtptr]) {

/*              %----------------------------------------------%   
                | Search, from the right, the first Ritz value |   
                | that has converged.                          |   
                %----------------------------------------------% */

		--rghtptr;

	    } else {

/*              %----------------------------------------------%   
                | Swap the Ritz value on the left that has not |   
                | converged with the Ritz value on the right   |   
                | that has converged.  Swap the associated     |   
                | eigenvector of the tridiagonal matrix H as   |   
                | well.                                        |   
                %----------------------------------------------% */

		temp = workl[ihd + leftptr - 1];
		workl[ihd + leftptr - 1] = workl[ihd + rghtptr - 1];
		workl[ihd + rghtptr - 1] = temp;
		igraphdcopy_(ncv, &workl[iq + *ncv * (leftptr - 1)], &c__1, &workl[
			iw], &c__1);
		igraphdcopy_(ncv, &workl[iq + *ncv * (rghtptr - 1)], &c__1, &workl[
			iq + *ncv * (leftptr - 1)], &c__1);
		igraphdcopy_(ncv, &workl[iw], &c__1, &workl[iq + *ncv * (rghtptr - 
			1)], &c__1);
		++leftptr;
		--rghtptr;

	    }

	    if (leftptr < rghtptr) {
		goto L20;
	    }

L30:
	    ;
	}

	if (msglvl > 2) {
	    igraphdvout_(&logfil, ncv, &workl[ihd], &ndigit, "_seupd: The eigenval"
		    "ues of H--reordered", (ftnlen)39);
	}

/*        %----------------------------------------%   
          | Load the converged Ritz values into D. |   
          %----------------------------------------% */

	igraphdcopy_(&nconv, &workl[ihd], &c__1, &d__[1], &c__1);

    } else {

/*        %-----------------------------------------------------%   
          | Ritz vectors not required. Load Ritz values into D. |   
          %-----------------------------------------------------% */

	igraphdcopy_(&nconv, &workl[ritz], &c__1, &d__[1], &c__1);
	igraphdcopy_(ncv, &workl[ritz], &c__1, &workl[ihd], &c__1);

    }

/*     %------------------------------------------------------------------%   
       | Transform the Ritz values and possibly vectors and corresponding |   
       | Ritz estimates of OP to those of A*x=lambda*B*x. The Ritz values |   
       | (and corresponding data) are returned in ascending order.        |   
       %------------------------------------------------------------------% */

    if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) == 0) {

/*        %---------------------------------------------------------%   
          | Ascending sort of wanted Ritz values, vectors and error |   
          | bounds. Not necessary if only Ritz values are desired.  |   
          %---------------------------------------------------------% */

	if (*rvec) {
	    igraphdsesrt_("LA", rvec, &nconv, &d__[1], ncv, &workl[iq], &ldq);
	} else {
	    igraphdcopy_(ncv, &workl[bounds], &c__1, &workl[ihb], &c__1);
	}

    } else {

/*        %-------------------------------------------------------------%   
          | *  Make a copy of all the Ritz values.                      |   
          | *  Transform the Ritz values back to the original system.   |   
          |    For TYPE = 'SHIFTI' the transformation is                |   
          |             lambda = 1/theta + sigma                        |   
          |    For TYPE = 'BUCKLE' the transformation is                |   
          |             lambda = sigma * theta / ( theta - 1 )          |   
          |    For TYPE = 'CAYLEY' the transformation is                |   
          |             lambda = sigma * (theta + 1) / (theta - 1 )     |   
          |    where the theta are the Ritz values returned by dsaupd.  |   
          | NOTES:                                                      |   
          | *The Ritz vectors are not affected by the transformation.   |   
          |  They are only reordered.                                   |   
          %-------------------------------------------------------------% */

	igraphdcopy_(ncv, &workl[ihd], &c__1, &workl[iw], &c__1);
	if (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0) {
	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		workl[ihd + k - 1] = 1. / workl[ihd + k - 1] + *sigma;
/* L40: */
	    }
	} else if (s_cmp(type__, "BUCKLE", (ftnlen)6, (ftnlen)6) == 0) {
	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		workl[ihd + k - 1] = *sigma * workl[ihd + k - 1] / (workl[ihd 
			+ k - 1] - 1.);
/* L50: */
	    }
	} else if (s_cmp(type__, "CAYLEY", (ftnlen)6, (ftnlen)6) == 0) {
	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		workl[ihd + k - 1] = *sigma * (workl[ihd + k - 1] + 1.) / (
			workl[ihd + k - 1] - 1.);
/* L60: */
	    }
	}

/*        %-------------------------------------------------------------%   
          | *  Store the wanted NCONV lambda values into D.             |   
          | *  Sort the NCONV wanted lambda in WORKL(IHD:IHD+NCONV-1)   |   
          |    into ascending order and apply sort to the NCONV theta   |   
          |    values in the transformed system. We'll need this to     |   
          |    compute Ritz estimates in the original system.           |   
          | *  Finally sort the lambda's into ascending order and apply |   
          |    to Ritz vectors if wanted. Else just sort lambda's into  |   
          |    ascending order.                                         |   
          | NOTES:                                                      |   
          | *workl(iw:iw+ncv-1) contain the theta ordered so that they  |   
          |  match the ordering of the lambda. We'll use them again for |   
          |  Ritz vector purification.                                  |   
          %-------------------------------------------------------------% */

	igraphdcopy_(&nconv, &workl[ihd], &c__1, &d__[1], &c__1);
	igraphdsortr_("LA", &c_true, &nconv, &workl[ihd], &workl[iw]);
	if (*rvec) {
	    igraphdsesrt_("LA", rvec, &nconv, &d__[1], ncv, &workl[iq], &ldq);
	} else {
	    igraphdcopy_(ncv, &workl[bounds], &c__1, &workl[ihb], &c__1);
	    d__1 = bnorm2 / rnorm;
	    igraphdscal_(ncv, &d__1, &workl[ihb], &c__1);
	    igraphdsortr_("LA", &c_true, &nconv, &d__[1], &workl[ihb]);
	}

    }

/*     %------------------------------------------------%   
       | Compute the Ritz vectors. Transform the wanted |   
       | eigenvectors of the symmetric tridiagonal H by |   
       | the Lanczos basis matrix V.                    |   
       %------------------------------------------------% */

    if (*rvec && *(unsigned char *)howmny == 'A') {

/*        %----------------------------------------------------------%   
          | Compute the QR factorization of the matrix representing  |   
          | the wanted invariant subspace located in the first NCONV |   
          | columns of workl(iq,ldq).                                |   
          %----------------------------------------------------------% */

	igraphdgeqr2_(ncv, &nconv, &workl[iq], &ldq, &workl[iw + *ncv], &workl[ihb],
		 &ierr);


/*        %--------------------------------------------------------%   
          | * Postmultiply V by Q.                                 |   
          | * Copy the first NCONV columns of VQ into Z.           |   
          | The N by NCONV matrix Z is now a matrix representation |   
          | of the approximate invariant subspace associated with  |   
          | the Ritz values in workl(ihd).                         |   
          %--------------------------------------------------------% */

	igraphdorm2r_("Right", "Notranspose", n, ncv, &nconv, &workl[iq], &ldq, &
		workl[iw + *ncv], &v[v_offset], ldv, &workd[*n + 1], &ierr);
	igraphdlacpy_("All", n, &nconv, &v[v_offset], ldv, &z__[z_offset], ldz);

/*        %-----------------------------------------------------%   
          | In order to compute the Ritz estimates for the Ritz |   
          | values in both systems, need the last row of the    |   
          | eigenvector matrix. Remember, it's in factored form |   
          %-----------------------------------------------------% */

	i__1 = *ncv - 1;
	for (j = 1; j <= i__1; ++j) {
	    workl[ihb + j - 1] = 0.;
/* L65: */
	}
	workl[ihb + *ncv - 1] = 1.;
	igraphdorm2r_("Left", "Transpose", ncv, &c__1, &nconv, &workl[iq], &ldq, &
		workl[iw + *ncv], &workl[ihb], ncv, &temp, &ierr);

    } else if (*rvec && *(unsigned char *)howmny == 'S') {

/*     Not yet implemented. See remark 2 above. */

    }

    if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) == 0 && *rvec) {

	i__1 = *ncv;
	for (j = 1; j <= i__1; ++j) {
	    workl[ihb + j - 1] = rnorm * (d__1 = workl[ihb + j - 1], abs(d__1)
		    );
/* L70: */
	}

    } else if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) != 0 && *rvec) {

/*        %-------------------------------------------------%   
          | *  Determine Ritz estimates of the theta.       |   
          |    If RVEC = .true. then compute Ritz estimates |   
          |               of the theta.                     |   
          |    If RVEC = .false. then copy Ritz estimates   |   
          |              as computed by dsaupd.             |   
          | *  Determine Ritz estimates of the lambda.      |   
          %-------------------------------------------------% */

	igraphdscal_(ncv, &bnorm2, &workl[ihb], &c__1);
	if (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
/* Computing 2nd power */
		d__2 = workl[iw + k - 1];
		workl[ihb + k - 1] = (d__1 = workl[ihb + k - 1], abs(d__1)) / 
			(d__2 * d__2);
/* L80: */
	    }

	} else if (s_cmp(type__, "BUCKLE", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
/* Computing 2nd power */
		d__2 = workl[iw + k - 1] - 1.;
		workl[ihb + k - 1] = *sigma * (d__1 = workl[ihb + k - 1], abs(
			d__1)) / (d__2 * d__2);
/* L90: */
	    }

	} else if (s_cmp(type__, "CAYLEY", (ftnlen)6, (ftnlen)6) == 0) {

	    i__1 = *ncv;
	    for (k = 1; k <= i__1; ++k) {
		workl[ihb + k - 1] = (d__1 = workl[ihb + k - 1] / workl[iw + 
			k - 1] * (workl[iw + k - 1] - 1.), abs(d__1));
/* L100: */
	    }

	}

    }

    if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) != 0 && msglvl > 1) {
	igraphdvout_(&logfil, &nconv, &d__[1], &ndigit, "_seupd: Untransformed con"
		"verged Ritz values", (ftnlen)43);
	igraphdvout_(&logfil, &nconv, &workl[ihb], &ndigit, "_seupd: Ritz estimate"
		"s of the untransformed Ritz values", (ftnlen)55);
    } else if (msglvl > 1) {
	igraphdvout_(&logfil, &nconv, &d__[1], &ndigit, "_seupd: Converged Ritz va"
		"lues", (ftnlen)29);
	igraphdvout_(&logfil, &nconv, &workl[ihb], &ndigit, "_seupd: Associated Ri"
		"tz estimates", (ftnlen)33);
    }

/*     %-------------------------------------------------%   
       | Ritz vector purification step. Formally perform |   
       | one of inverse subspace iteration. Only used    |   
       | for MODE = 3,4,5. See reference 7               |   
       %-------------------------------------------------% */

    if (*rvec && (s_cmp(type__, "SHIFTI", (ftnlen)6, (ftnlen)6) == 0 || s_cmp(
	    type__, "CAYLEY", (ftnlen)6, (ftnlen)6) == 0)) {

	i__1 = nconv - 1;
	for (k = 0; k <= i__1; ++k) {
	    workl[iw + k] = workl[iq + k * ldq + *ncv - 1] / workl[iw + k];
/* L110: */
	}

    } else if (*rvec && s_cmp(type__, "BUCKLE", (ftnlen)6, (ftnlen)6) == 0) {

	i__1 = nconv - 1;
	for (k = 0; k <= i__1; ++k) {
	    workl[iw + k] = workl[iq + k * ldq + *ncv - 1] / (workl[iw + k] - 
		    1.);
/* L120: */
	}

    }

    if (s_cmp(type__, "REGULR", (ftnlen)6, (ftnlen)6) != 0) {
	igraphdger_(n, &nconv, &c_b119, &resid[1], &c__1, &workl[iw], &c__1, &z__[
		z_offset], ldz);
    }

L9000:

    return 0;

/*     %---------------%   
       | End of dseupd |   
       %---------------% */

} /* igraphdseupd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsgets.c0000644000175100001710000002156200000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static logical c_true = TRUE_;
static integer c__1 = 1;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsgets   

   \Description:   
    Given the eigenvalues of the symmetric tridiagonal matrix H,   
    computes the NP shifts AMU that are zeros of the polynomial of   
    degree NP which filters out components of the unwanted eigenvectors   
    corresponding to the AMU's based on some given criteria.   

    NOTE: This is called even in the case of user specified shifts in   
    order to sort the eigenvalues, and error bounds of H for later use.   

   \Usage:   
    call dsgets   
       ( ISHIFT, WHICH, KEV, NP, RITZ, BOUNDS, SHIFTS )   

   \Arguments   
    ISHIFT  Integer.  (INPUT)   
            Method for selecting the implicit shifts at each iteration.   
            ISHIFT = 0: user specified shifts   
            ISHIFT = 1: exact shift with respect to the matrix H.   

    WHICH   Character*2.  (INPUT)   
            Shift selection criteria.   
            'LM' -> KEV eigenvalues of largest magnitude are retained.   
            'SM' -> KEV eigenvalues of smallest magnitude are retained.   
            'LA' -> KEV eigenvalues of largest value are retained.   
            'SA' -> KEV eigenvalues of smallest value are retained.   
            'BE' -> KEV eigenvalues, half from each end of the spectrum.   
                    If KEV is odd, compute one more from the high end.   

    KEV      Integer.  (INPUT)   
            KEV+NP is the size of the matrix H.   

    NP      Integer.  (INPUT)   
            Number of implicit shifts to be computed.   

    RITZ    Double precision array of length KEV+NP.  (INPUT/OUTPUT)   
            On INPUT, RITZ contains the eigenvalues of H.   
            On OUTPUT, RITZ are sorted so that the unwanted eigenvalues   
            are in the first NP locations and the wanted part is in   
            the last KEV locations.  When exact shifts are selected, the   
            unwanted part corresponds to the shifts to be applied.   

    BOUNDS  Double precision array of length KEV+NP.  (INPUT/OUTPUT)   
            Error bounds corresponding to the ordering in RITZ.   

    SHIFTS  Double precision array of length NP.  (INPUT/OUTPUT)   
            On INPUT:  contains the user specified shifts if ISHIFT = 0.   
            On OUTPUT: contains the shifts sorted into decreasing order   
            of magnitude with respect to the Ritz estimates contained in   
            BOUNDS. If ISHIFT = 0, SHIFTS is not modified on exit.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       dsortr  ARPACK utility sorting routine.   
       ivout   ARPACK utility routine that prints integers.   
       second  ARPACK utility routine for timing.   
       dvout   ARPACK utility routine that prints vectors.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       dswap   Level 1 BLAS that swaps the contents of two vectors.   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/93: Version ' 2.1'   

   \SCCS Information: @(#)   
   FILE: sgets.F   SID: 2.4   DATE OF SID: 4/19/96   RELEASE: 2   

   \Remarks   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsgets_(integer *ishift, char *which, integer *kev, 
	integer *np, doublereal *ritz, doublereal *bounds, doublereal *shifts)
{
    /* System generated locals */
    integer i__1;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    IGRAPH_F77_SAVE real t0, t1;
    integer kevd2;
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdcopy_(integer *, doublereal *, integer 
	    *, doublereal *, integer *), igraphdvout_(integer *, integer *, 
	    doublereal *, integer *, char *, ftnlen), igraphivout_(integer *, 
	    integer *, integer *, integer *, char *, ftnlen), igraphsecond_(real *);
    integer logfil, ndigit, msgets = 0, msglvl;
    real tsgets = 0.0;
    extern /* Subroutine */ int igraphdsortr_(char *, logical *, integer *, 
	    doublereal *, doublereal *);


/*     %----------------------------------------------------%   
       | Include files for debugging and timing information |   
       %----------------------------------------------------%   


       %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %------------%   
       | Parameters |   
       %------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %----------------------%   
       | External Subroutines |   
       %----------------------%   


       %---------------------%   
       | Intrinsic Functions |   
       %---------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------%   

       %-------------------------------%   
       | Initialize timing statistics  |   
       | & message level for debugging |   
       %-------------------------------%   

       Parameter adjustments */
    --shifts;
    --bounds;
    --ritz;

    /* Function Body */
    igraphsecond_(&t0);
    msglvl = msgets;

    if (s_cmp(which, "BE", (ftnlen)2, (ftnlen)2) == 0) {

/*        %-----------------------------------------------------%   
          | Both ends of the spectrum are requested.            |   
          | Sort the eigenvalues into algebraically increasing  |   
          | order first then swap high end of the spectrum next |   
          | to low end in appropriate locations.                |   
          | NOTE: when np < floor(kev/2) be careful not to swap |   
          | overlapping locations.                              |   
          %-----------------------------------------------------% */

	i__1 = *kev + *np;
	igraphdsortr_("LA", &c_true, &i__1, &ritz[1], &bounds[1]);
	kevd2 = *kev / 2;
	if (*kev > 1) {
	    i__1 = min(kevd2,*np);
	    igraphdswap_(&i__1, &ritz[1], &c__1, &ritz[max(kevd2,*np) + 1], &c__1);
	    i__1 = min(kevd2,*np);
	    igraphdswap_(&i__1, &bounds[1], &c__1, &bounds[max(kevd2,*np) + 1], &
		    c__1);
	}

    } else {

/*        %----------------------------------------------------%   
          | LM, SM, LA, SA case.                               |   
          | Sort the eigenvalues of H into the desired order   |   
          | and apply the resulting order to BOUNDS.           |   
          | The eigenvalues are sorted so that the wanted part |   
          | are always in the last KEV locations.               |   
          %----------------------------------------------------% */

	i__1 = *kev + *np;
	igraphdsortr_(which, &c_true, &i__1, &ritz[1], &bounds[1]);
    }

    if (*ishift == 1 && *np > 0) {

/*        %-------------------------------------------------------%   
          | Sort the unwanted Ritz values used as shifts so that  |   
          | the ones with largest Ritz estimates are first.       |   
          | This will tend to minimize the effects of the         |   
          | forward instability of the iteration when the shifts  |   
          | are applied in subroutine dsapps.                     |   
          %-------------------------------------------------------% */

	igraphdsortr_("SM", &c_true, np, &bounds[1], &ritz[1]);
	igraphdcopy_(np, &ritz[1], &c__1, &shifts[1], &c__1);
    }

    igraphsecond_(&t1);
    tsgets += t1 - t0;

    if (msglvl > 0) {
	igraphivout_(&logfil, &c__1, kev, &ndigit, "_sgets: KEV is", (ftnlen)14);
	igraphivout_(&logfil, &c__1, np, &ndigit, "_sgets: NP is", (ftnlen)13);
	i__1 = *kev + *np;
	igraphdvout_(&logfil, &i__1, &ritz[1], &ndigit, "_sgets: Eigenvalues of cu"
		"rrent H matrix", (ftnlen)39);
	i__1 = *kev + *np;
	igraphdvout_(&logfil, &i__1, &bounds[1], &ndigit, "_sgets: Associated Ritz"
		" estimates", (ftnlen)33);
    }

    return 0;

/*     %---------------%   
       | End of dsgets |   
       %---------------% */

} /* igraphdsgets_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsortc.c0000644000175100001710000002161400000000000024050 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsortc   

   \Description:   
    Sorts the complex array in XREAL and XIMAG into the order   
    specified by WHICH and optionally applies the permutation to the   
    real array Y. It is assumed that if an element of XIMAG is   
    nonzero, then its negative is also an element. In other words,   
    both members of a complex conjugate pair are to be sorted and the   
    pairs are kept adjacent to each other.   

   \Usage:   
    call dsortc   
       ( WHICH, APPLY, N, XREAL, XIMAG, Y )   

   \Arguments   
    WHICH   Character*2.  (Input)   
            'LM' -> sort XREAL,XIMAG into increasing order of magnitude.   
            'SM' -> sort XREAL,XIMAG into decreasing order of magnitude.   
            'LR' -> sort XREAL into increasing order of algebraic.   
            'SR' -> sort XREAL into decreasing order of algebraic.   
            'LI' -> sort XIMAG into increasing order of magnitude.   
            'SI' -> sort XIMAG into decreasing order of magnitude.   
            NOTE: If an element of XIMAG is non-zero, then its negative   
                  is also an element.   

    APPLY   Logical.  (Input)   
            APPLY = .TRUE.  -> apply the sorted order to array Y.   
            APPLY = .FALSE. -> do not apply the sorted order to array Y.   

    N       Integer.  (INPUT)   
            Size of the arrays.   

    XREAL,  Double precision array of length N.  (INPUT/OUTPUT)   
    XIMAG   Real and imaginary part of the array to be sorted.   

    Y       Double precision array of length N.  (INPUT/OUTPUT)   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       xx/xx/92: Version ' 2.1'   
                 Adapted from the sort routine in LANSO.   

   \SCCS Information: @(#)   
   FILE: sortc.F   SID: 2.3   DATE OF SID: 4/20/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsortc_(char *which, logical *apply, integer *n, 
	doublereal *xreal, doublereal *ximag, doublereal *y)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    integer i__, j, igap;
    doublereal temp, temp1, temp2;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);


/*     %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %--------------------%   
       | External Functions |   
       %--------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    igap = *n / 2;

    if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------------%   
          | Sort XREAL,XIMAG into increasing order of magnitude. |   
          %------------------------------------------------------% */

L10:
	if (igap == 0) {
	    goto L9000;
	}

	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L20:

	    if (j < 0) {
		goto L30;
	    }

	    temp1 = igraphdlapy2_(&xreal[j], &ximag[j]);
	    temp2 = igraphdlapy2_(&xreal[j + igap], &ximag[j + igap]);

	    if (temp1 > temp2) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L30;
	    }
	    j -= igap;
	    goto L20;
L30:
	    ;
	}
	igap /= 2;
	goto L10;

    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------------%   
          | Sort XREAL,XIMAG into decreasing order of magnitude. |   
          %------------------------------------------------------% */

L40:
	if (igap == 0) {
	    goto L9000;
	}

	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L50:

	    if (j < 0) {
		goto L60;
	    }

	    temp1 = igraphdlapy2_(&xreal[j], &ximag[j]);
	    temp2 = igraphdlapy2_(&xreal[j + igap], &ximag[j + igap]);

	    if (temp1 < temp2) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L60;
	    }
	    j -= igap;
	    goto L50;
L60:
	    ;
	}
	igap /= 2;
	goto L40;

    } else if (s_cmp(which, "LR", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------%   
          | Sort XREAL into increasing order of algebraic. |   
          %------------------------------------------------% */

L70:
	if (igap == 0) {
	    goto L9000;
	}

	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L80:

	    if (j < 0) {
		goto L90;
	    }

	    if (xreal[j] > xreal[j + igap]) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L90;
	    }
	    j -= igap;
	    goto L80;
L90:
	    ;
	}
	igap /= 2;
	goto L70;

    } else if (s_cmp(which, "SR", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------%   
          | Sort XREAL into decreasing order of algebraic. |   
          %------------------------------------------------% */

L100:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L110:

	    if (j < 0) {
		goto L120;
	    }

	    if (xreal[j] < xreal[j + igap]) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L120;
	    }
	    j -= igap;
	    goto L110;
L120:
	    ;
	}
	igap /= 2;
	goto L100;

    } else if (s_cmp(which, "LI", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------%   
          | Sort XIMAG into increasing order of magnitude. |   
          %------------------------------------------------% */

L130:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L140:

	    if (j < 0) {
		goto L150;
	    }

	    if ((d__1 = ximag[j], abs(d__1)) > (d__2 = ximag[j + igap], abs(
		    d__2))) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L150;
	    }
	    j -= igap;
	    goto L140;
L150:
	    ;
	}
	igap /= 2;
	goto L130;

    } else if (s_cmp(which, "SI", (ftnlen)2, (ftnlen)2) == 0) {

/*        %------------------------------------------------%   
          | Sort XIMAG into decreasing order of magnitude. |   
          %------------------------------------------------% */

L160:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L170:

	    if (j < 0) {
		goto L180;
	    }

	    if ((d__1 = ximag[j], abs(d__1)) < (d__2 = ximag[j + igap], abs(
		    d__2))) {
		temp = xreal[j];
		xreal[j] = xreal[j + igap];
		xreal[j + igap] = temp;

		temp = ximag[j];
		ximag[j] = ximag[j + igap];
		ximag[j + igap] = temp;

		if (*apply) {
		    temp = y[j];
		    y[j] = y[j + igap];
		    y[j + igap] = temp;
		}
	    } else {
		goto L180;
	    }
	    j -= igap;
	    goto L170;
L180:
	    ;
	}
	igap /= 2;
	goto L160;
    }

L9000:
    return 0;

/*     %---------------%   
       | End of dsortc |   
       %---------------% */

} /* igraphdsortc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsortr.c0000644000175100001710000001276000000000000024071 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dsortr   

   \Description:   
    Sort the array X1 in the order specified by WHICH and optionally   
    applies the permutation to the array X2.   

   \Usage:   
    call dsortr   
       ( WHICH, APPLY, N, X1, X2 )   

   \Arguments   
    WHICH   Character*2.  (Input)   
            'LM' -> X1 is sorted into increasing order of magnitude.   
            'SM' -> X1 is sorted into decreasing order of magnitude.   
            'LA' -> X1 is sorted into increasing order of algebraic.   
            'SA' -> X1 is sorted into decreasing order of algebraic.   

    APPLY   Logical.  (Input)   
            APPLY = .TRUE.  -> apply the sorted order to X2.   
            APPLY = .FALSE. -> do not apply the sorted order to X2.   

    N       Integer.  (INPUT)   
            Size of the arrays.   

    X1      Double precision array of length N.  (INPUT/OUTPUT)   
            The array to be sorted.   

    X2      Double precision array of length N.  (INPUT/OUTPUT)   
            Only referenced if APPLY = .TRUE.   

   \EndDoc   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \Revision history:   
       12/16/93: Version ' 2.1'.   
                 Adapted from the sort routine in LANSO.   

   \SCCS Information: @(#)   
   FILE: sortr.F   SID: 2.3   DATE OF SID: 4/19/96   RELEASE: 2   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdsortr_(char *which, logical *apply, integer *n, 
	doublereal *x1, doublereal *x2)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2;

    /* Builtin functions */
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    integer i__, j, igap;
    doublereal temp;


/*     %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   


       %---------------%   
       | Local Scalars |   
       %---------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    igap = *n / 2;

    if (s_cmp(which, "SA", (ftnlen)2, (ftnlen)2) == 0) {

/*        X1 is sorted into decreasing order of algebraic. */

L10:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L20:

	    if (j < 0) {
		goto L30;
	    }

	    if (x1[j] < x1[j + igap]) {
		temp = x1[j];
		x1[j] = x1[j + igap];
		x1[j + igap] = temp;
		if (*apply) {
		    temp = x2[j];
		    x2[j] = x2[j + igap];
		    x2[j + igap] = temp;
		}
	    } else {
		goto L30;
	    }
	    j -= igap;
	    goto L20;
L30:
	    ;
	}
	igap /= 2;
	goto L10;

    } else if (s_cmp(which, "SM", (ftnlen)2, (ftnlen)2) == 0) {

/*        X1 is sorted into decreasing order of magnitude. */

L40:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L50:

	    if (j < 0) {
		goto L60;
	    }

	    if ((d__1 = x1[j], abs(d__1)) < (d__2 = x1[j + igap], abs(d__2))) 
		    {
		temp = x1[j];
		x1[j] = x1[j + igap];
		x1[j + igap] = temp;
		if (*apply) {
		    temp = x2[j];
		    x2[j] = x2[j + igap];
		    x2[j + igap] = temp;
		}
	    } else {
		goto L60;
	    }
	    j -= igap;
	    goto L50;
L60:
	    ;
	}
	igap /= 2;
	goto L40;

    } else if (s_cmp(which, "LA", (ftnlen)2, (ftnlen)2) == 0) {

/*        X1 is sorted into increasing order of algebraic. */

L70:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L80:

	    if (j < 0) {
		goto L90;
	    }

	    if (x1[j] > x1[j + igap]) {
		temp = x1[j];
		x1[j] = x1[j + igap];
		x1[j + igap] = temp;
		if (*apply) {
		    temp = x2[j];
		    x2[j] = x2[j + igap];
		    x2[j + igap] = temp;
		}
	    } else {
		goto L90;
	    }
	    j -= igap;
	    goto L80;
L90:
	    ;
	}
	igap /= 2;
	goto L70;

    } else if (s_cmp(which, "LM", (ftnlen)2, (ftnlen)2) == 0) {

/*        X1 is sorted into increasing order of magnitude. */

L100:
	if (igap == 0) {
	    goto L9000;
	}
	i__1 = *n - 1;
	for (i__ = igap; i__ <= i__1; ++i__) {
	    j = i__ - igap;
L110:

	    if (j < 0) {
		goto L120;
	    }

	    if ((d__1 = x1[j], abs(d__1)) > (d__2 = x1[j + igap], abs(d__2))) 
		    {
		temp = x1[j];
		x1[j] = x1[j + igap];
		x1[j + igap] = temp;
		if (*apply) {
		    temp = x2[j];
		    x2[j] = x2[j + igap];
		    x2[j + igap] = temp;
		}
	    } else {
		goto L120;
	    }
	    j -= igap;
	    goto L110;
L120:
	    ;
	}
	igap /= 2;
	goto L100;
    }

L9000:
    return 0;

/*     %---------------%   
       | End of dsortr |   
       %---------------% */

} /* igraphdsortr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstatn.c0000644000175100001710000000416100000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"


/*     %---------------------------------------------%   
       | Initialize statistic and timing information |   
       | for nonsymmetric Arnoldi code.              |   
       %---------------------------------------------%   

   \Author   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: statn.F   SID: 2.4   DATE OF SID: 4/20/96   RELEASE: 2   

   Subroutine */ int igraphdstatn_(void)
{
    integer nbx, nopx;
    real trvec, tmvbx, tnaup2, tgetv0, tneigh;
    integer nitref;
    real tnaupd, titref, tnaitr, tngets, tnapps, tnconv;
    integer nrorth, nrstrt;
    real tmvopx;


/*     %--------------------------------%   
       | See stat.doc for documentation |   
       %--------------------------------%   


       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */

    nopx = 0;
    nbx = 0;
    nrorth = 0;
    nitref = 0;
    nrstrt = 0;

    tnaupd = 0.f;
    tnaup2 = 0.f;
    tnaitr = 0.f;
    tneigh = 0.f;
    tngets = 0.f;
    tnapps = 0.f;
    tnconv = 0.f;
    titref = 0.f;
    tgetv0 = 0.f;
    trvec = 0.f;

/*     %----------------------------------------------------%   
       | User time including reverse communication overhead |   
       %----------------------------------------------------% */

    tmvopx = 0.f;
    tmvbx = 0.f;

    return 0;


/*     %---------------%   
       | End of dstatn |   
       %---------------% */

} /* igraphdstatn_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstats.c0000644000175100001710000000347200000000000024056 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"


/* \SCCS Information: @(#)   
   FILE: stats.F   SID: 2.1   DATE OF SID: 4/19/96   RELEASE: 2   
       %---------------------------------------------%   
       | Initialize statistic and timing information |   
       | for symmetric Arnoldi code.                 |   
       %---------------------------------------------%   
   Subroutine */ int igraphdstats_(void)
{
    integer nbx, nopx;
    real trvec, tmvbx, tgetv0, tsaup2;
    integer nitref;
    real titref, tseigt, tsaupd, tsaitr, tsgets, tsapps;
    integer nrorth;
    real tsconv;
    integer nrstrt;
    real tmvopx;

/*     %--------------------------------%   
       | See stat.doc for documentation |   
       %--------------------------------%   
       %-----------------------%   
       | Executable Statements |   
       %-----------------------% */
    nopx = 0;
    nbx = 0;
    nrorth = 0;
    nitref = 0;
    nrstrt = 0;
    tsaupd = 0.f;
    tsaup2 = 0.f;
    tsaitr = 0.f;
    tseigt = 0.f;
    tsgets = 0.f;
    tsapps = 0.f;
    tsconv = 0.f;
    titref = 0.f;
    tgetv0 = 0.f;
    trvec = 0.f;
/*     %----------------------------------------------------%   
       | User time including reverse communication overhead |   
       %----------------------------------------------------% */
    tmvopx = 0.f;
    tmvbx = 0.f;
    return 0;

/*     End of dstats */

} /* igraphdstats_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstebz.c0000644000175100001710000005747500000000000024063 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;
static integer c__0 = 0;

/* > \brief \b DSTEBZ   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSTEBZ + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSTEBZ( RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E,   
                            M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK,   
                            INFO )   

         CHARACTER          ORDER, RANGE   
         INTEGER            IL, INFO, IU, M, N, NSPLIT   
         DOUBLE PRECISION   ABSTOL, VL, VU   
         INTEGER            IBLOCK( * ), ISPLIT( * ), IWORK( * )   
         DOUBLE PRECISION   D( * ), E( * ), W( * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSTEBZ computes the eigenvalues of a symmetric tridiagonal   
   > matrix T.  The user may ask for all eigenvalues, all eigenvalues   
   > in the half-open interval (VL, VU], or the IL-th through IU-th   
   > eigenvalues.   
   >   
   > To avoid overflow, the matrix must be scaled so that its   
   > largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest
   
   > accuracy, it should not be much smaller than that.   
   >   
   > See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal   
   > Matrix", Report CS41, Computer Science Dept., Stanford   
   > University, July 21, 1966.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] RANGE   
   > \verbatim   
   >          RANGE is CHARACTER*1   
   >          = 'A': ("All")   all eigenvalues will be found.   
   >          = 'V': ("Value") all eigenvalues in the half-open interval   
   >                           (VL, VU] will be found.   
   >          = 'I': ("Index") the IL-th through IU-th eigenvalues (of the   
   >                           entire matrix) will be found.   
   > \endverbatim   
   >   
   > \param[in] ORDER   
   > \verbatim   
   >          ORDER is CHARACTER*1   
   >          = 'B': ("By Block") the eigenvalues will be grouped by   
   >                              split-off block (see IBLOCK, ISPLIT) and   
   >                              ordered from smallest to largest within   
   >                              the block.   
   >          = 'E': ("Entire matrix")   
   >                              the eigenvalues for the entire matrix   
   >                              will be ordered from smallest to   
   >                              largest.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the tridiagonal matrix T.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >   
   >          If RANGE='V', the lower and upper bounds of the interval to   
   >          be searched for eigenvalues.  Eigenvalues less than or equal   
   >          to VL, or greater than VU, will not be returned.  VL < VU.   
   >          Not referenced if RANGE = 'A' or 'I'.   
   > \endverbatim   
   >   
   > \param[in] IL   
   > \verbatim   
   >          IL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IU   
   > \verbatim   
   >          IU is INTEGER   
   >   
   >          If RANGE='I', the indices (in ascending order) of the   
   >          smallest and largest eigenvalues to be returned.   
   >          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.   
   >          Not referenced if RANGE = 'A' or 'V'.   
   > \endverbatim   
   >   
   > \param[in] ABSTOL   
   > \verbatim   
   >          ABSTOL is DOUBLE PRECISION   
   >          The absolute tolerance for the eigenvalues.  An eigenvalue   
   >          (or cluster) is considered to be located if it has been   
   >          determined to lie in an interval whose width is ABSTOL or   
   >          less.  If ABSTOL is less than or equal to zero, then ULP*|T|   
   >          will be used, where |T| means the 1-norm of T.   
   >   
   >          Eigenvalues will be computed most accurately when ABSTOL is   
   >          set to twice the underflow threshold 2*DLAMCH('S'), not zero.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The n diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) off-diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The actual number of eigenvalues found. 0 <= M <= N.   
   >          (See also the description of INFO=2,3.)   
   > \endverbatim   
   >   
   > \param[out] NSPLIT   
   > \verbatim   
   >          NSPLIT is INTEGER   
   >          The number of diagonal blocks in the matrix T.   
   >          1 <= NSPLIT <= N.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          On exit, the first M elements of W will contain the   
   >          eigenvalues.  (DSTEBZ may use the remaining N-M elements as   
   >          workspace.)   
   > \endverbatim   
   >   
   > \param[out] IBLOCK   
   > \verbatim   
   >          IBLOCK is INTEGER array, dimension (N)   
   >          At each row/column j where E(j) is zero or small, the   
   >          matrix T is considered to split into a block diagonal   
   >          matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which   
   >          block (from 1 to the number of blocks) the eigenvalue W(i)   
   >          belongs.  (DSTEBZ may use the remaining N-M elements as   
   >          workspace.)   
   > \endverbatim   
   >   
   > \param[out] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into submatrices.   
   >          The first submatrix consists of rows/columns 1 to ISPLIT(1),   
   >          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),   
   >          etc., and the NSPLIT-th consists of rows/columns   
   >          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.   
   >          (Only the first NSPLIT elements will actually be used, but   
   >          since the user cannot know a priori what value NSPLIT will   
   >          have, N words must be reserved for ISPLIT.)   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (4*N)   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (3*N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  some or all of the eigenvalues failed to converge or   
   >                were not computed:   
   >                =1 or 3: Bisection failed to converge for some   
   >                        eigenvalues; these eigenvalues are flagged by a   
   >                        negative block number.  The effect is that the   
   >                        eigenvalues may not be as accurate as the   
   >                        absolute and relative tolerances.  This is   
   >                        generally caused by unexpectedly inaccurate   
   >                        arithmetic.   
   >                =2 or 3: RANGE='I' only: Not all of the eigenvalues   
   >                        IL:IU were found.   
   >                        Effect: M < IU+1-IL   
   >                        Cause:  non-monotonic arithmetic, causing the   
   >                                Sturm sequence to be non-monotonic.   
   >                        Cure:   recalculate, using RANGE='A', and pick   
   >                                out eigenvalues IL:IU.  In some cases,   
   >                                increasing the PARAMETER "FUDGE" may   
   >                                make things work.   
   >                = 4:    RANGE='I', and the Gershgorin interval   
   >                        initially used was too small.  No eigenvalues   
   >                        were computed.   
   >                        Probable cause: your machine has sloppy   
   >                                        floating-point arithmetic.   
   >                        Cure: Increase the PARAMETER "FUDGE",   
   >                              recompile, and try again.   
   > \endverbatim   

   > \par Internal Parameters:   
    =========================   
   >   
   > \verbatim   
   >  RELFAC  DOUBLE PRECISION, default = 2.0e0   
   >          The relative tolerance.  An interval (a,b] lies within   
   >          "relative tolerance" if  b-a < RELFAC*ulp*max(|a|,|b|),   
   >          where "ulp" is the machine precision (distance from 1 to   
   >          the next larger floating point number.)   
   >   
   >  FUDGE   DOUBLE PRECISION, default = 2   
   >          A "fudge factor" to widen the Gershgorin intervals.  Ideally,   
   >          a value of 1 should work, but on machines with sloppy   
   >          arithmetic, this needs to be larger.  The default for   
   >          publicly released versions should be large enough to handle   
   >          the worst machine around.  Note that this has no effect   
   >          on accuracy of the solution.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdstebz_(char *range, char *order, integer *n, doublereal 
	*vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, 
	doublereal *d__, doublereal *e, integer *m, integer *nsplit, 
	doublereal *w, integer *iblock, integer *isplit, doublereal *work, 
	integer *iwork, integer *info)
{
    /* System generated locals */
    integer i__1, i__2, i__3;
    doublereal d__1, d__2, d__3, d__4, d__5;

    /* Builtin functions */
    double sqrt(doublereal), log(doublereal);

    /* Local variables */
    integer j, ib, jb, ie, je, nb;
    doublereal gl;
    integer im, in;
    doublereal gu;
    integer iw;
    doublereal wl, wu;
    integer nwl;
    doublereal ulp, wlu, wul;
    integer nwu;
    doublereal tmp1, tmp2;
    integer iend, ioff, iout, itmp1, jdisc;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    doublereal atoli;
    integer iwoff;
    doublereal bnorm;
    integer itmax;
    doublereal wkill, rtoli, tnorm;
    extern doublereal igraphdlamch_(char *);
    integer ibegin;
    extern /* Subroutine */ int igraphdlaebz_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *);
    integer irange, idiscl;
    doublereal safemn;
    integer idumma[1];
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    integer idiscu, iorder;
    logical ncnvrg;
    doublereal pivmin;
    logical toofew;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Parameter adjustments */
    --iwork;
    --work;
    --isplit;
    --iblock;
    --w;
    --e;
    --d__;

    /* Function Body */
    *info = 0;

/*     Decode RANGE */

    if (igraphlsame_(range, "A")) {
	irange = 1;
    } else if (igraphlsame_(range, "V")) {
	irange = 2;
    } else if (igraphlsame_(range, "I")) {
	irange = 3;
    } else {
	irange = 0;
    }

/*     Decode ORDER */

    if (igraphlsame_(order, "B")) {
	iorder = 2;
    } else if (igraphlsame_(order, "E")) {
	iorder = 1;
    } else {
	iorder = 0;
    }

/*     Check for Errors */

    if (irange <= 0) {
	*info = -1;
    } else if (iorder <= 0) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (irange == 2) {
	if (*vl >= *vu) {
	    *info = -5;
	}
    } else if (irange == 3 && (*il < 1 || *il > max(1,*n))) {
	*info = -6;
    } else if (irange == 3 && (*iu < min(*n,*il) || *iu > *n)) {
	*info = -7;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSTEBZ", &i__1, (ftnlen)6);
	return 0;
    }

/*     Initialize error flags */

    *info = 0;
    ncnvrg = FALSE_;
    toofew = FALSE_;

/*     Quick return if possible */

    *m = 0;
    if (*n == 0) {
	return 0;
    }

/*     Simplifications: */

    if (irange == 3 && *il == 1 && *iu == *n) {
	irange = 1;
    }

/*     Get machine constants   
       NB is the minimum vector length for vector bisection, or 0   
       if only scalar is to be done. */

    safemn = igraphdlamch_("S");
    ulp = igraphdlamch_("P");
    rtoli = ulp * 2.;
    nb = igraphilaenv_(&c__1, "DSTEBZ", " ", n, &c_n1, &c_n1, &c_n1, (ftnlen)6, (
	    ftnlen)1);
    if (nb <= 1) {
	nb = 0;
    }

/*     Special Case when N=1 */

    if (*n == 1) {
	*nsplit = 1;
	isplit[1] = 1;
	if (irange == 2 && (*vl >= d__[1] || *vu < d__[1])) {
	    *m = 0;
	} else {
	    w[1] = d__[1];
	    iblock[1] = 1;
	    *m = 1;
	}
	return 0;
    }

/*     Compute Splitting Points */

    *nsplit = 1;
    work[*n] = 0.;
    pivmin = 1.;

    i__1 = *n;
    for (j = 2; j <= i__1; ++j) {
/* Computing 2nd power */
	d__1 = e[j - 1];
	tmp1 = d__1 * d__1;
/* Computing 2nd power */
	d__2 = ulp;
	if ((d__1 = d__[j] * d__[j - 1], abs(d__1)) * (d__2 * d__2) + safemn 
		> tmp1) {
	    isplit[*nsplit] = j - 1;
	    ++(*nsplit);
	    work[j - 1] = 0.;
	} else {
	    work[j - 1] = tmp1;
	    pivmin = max(pivmin,tmp1);
	}
/* L10: */
    }
    isplit[*nsplit] = *n;
    pivmin *= safemn;

/*     Compute Interval and ATOLI */

    if (irange == 3) {

/*        RANGE='I': Compute the interval containing eigenvalues   
                     IL through IU.   

          Compute Gershgorin interval for entire (split) matrix   
          and use it as the initial interval */

	gu = d__[1];
	gl = d__[1];
	tmp1 = 0.;

	i__1 = *n - 1;
	for (j = 1; j <= i__1; ++j) {
	    tmp2 = sqrt(work[j]);
/* Computing MAX */
	    d__1 = gu, d__2 = d__[j] + tmp1 + tmp2;
	    gu = max(d__1,d__2);
/* Computing MIN */
	    d__1 = gl, d__2 = d__[j] - tmp1 - tmp2;
	    gl = min(d__1,d__2);
	    tmp1 = tmp2;
/* L20: */
	}

/* Computing MAX */
	d__1 = gu, d__2 = d__[*n] + tmp1;
	gu = max(d__1,d__2);
/* Computing MIN */
	d__1 = gl, d__2 = d__[*n] - tmp1;
	gl = min(d__1,d__2);
/* Computing MAX */
	d__1 = abs(gl), d__2 = abs(gu);
	tnorm = max(d__1,d__2);
	gl = gl - tnorm * 2.1 * ulp * *n - pivmin * 4.2000000000000002;
	gu = gu + tnorm * 2.1 * ulp * *n + pivmin * 2.1;

/*        Compute Iteration parameters */

	itmax = (integer) ((log(tnorm + pivmin) - log(pivmin)) / log(2.)) + 2;
	if (*abstol <= 0.) {
	    atoli = ulp * tnorm;
	} else {
	    atoli = *abstol;
	}

	work[*n + 1] = gl;
	work[*n + 2] = gl;
	work[*n + 3] = gu;
	work[*n + 4] = gu;
	work[*n + 5] = gl;
	work[*n + 6] = gu;
	iwork[1] = -1;
	iwork[2] = -1;
	iwork[3] = *n + 1;
	iwork[4] = *n + 1;
	iwork[5] = *il - 1;
	iwork[6] = *iu;

	igraphdlaebz_(&c__3, &itmax, n, &c__2, &c__2, &nb, &atoli, &rtoli, &pivmin, 
		&d__[1], &e[1], &work[1], &iwork[5], &work[*n + 1], &work[*n 
		+ 5], &iout, &iwork[1], &w[1], &iblock[1], &iinfo);

	if (iwork[6] == *iu) {
	    wl = work[*n + 1];
	    wlu = work[*n + 3];
	    nwl = iwork[1];
	    wu = work[*n + 4];
	    wul = work[*n + 2];
	    nwu = iwork[4];
	} else {
	    wl = work[*n + 2];
	    wlu = work[*n + 4];
	    nwl = iwork[2];
	    wu = work[*n + 3];
	    wul = work[*n + 1];
	    nwu = iwork[3];
	}

	if (nwl < 0 || nwl >= *n || nwu < 1 || nwu > *n) {
	    *info = 4;
	    return 0;
	}
    } else {

/*        RANGE='A' or 'V' -- Set ATOLI   

   Computing MAX */
	d__3 = abs(d__[1]) + abs(e[1]), d__4 = (d__1 = d__[*n], abs(d__1)) + (
		d__2 = e[*n - 1], abs(d__2));
	tnorm = max(d__3,d__4);

	i__1 = *n - 1;
	for (j = 2; j <= i__1; ++j) {
/* Computing MAX */
	    d__4 = tnorm, d__5 = (d__1 = d__[j], abs(d__1)) + (d__2 = e[j - 1]
		    , abs(d__2)) + (d__3 = e[j], abs(d__3));
	    tnorm = max(d__4,d__5);
/* L30: */
	}

	if (*abstol <= 0.) {
	    atoli = ulp * tnorm;
	} else {
	    atoli = *abstol;
	}

	if (irange == 2) {
	    wl = *vl;
	    wu = *vu;
	} else {
	    wl = 0.;
	    wu = 0.;
	}
    }

/*     Find Eigenvalues -- Loop Over Blocks and recompute NWL and NWU.   
       NWL accumulates the number of eigenvalues .le. WL,   
       NWU accumulates the number of eigenvalues .le. WU */

    *m = 0;
    iend = 0;
    *info = 0;
    nwl = 0;
    nwu = 0;

    i__1 = *nsplit;
    for (jb = 1; jb <= i__1; ++jb) {
	ioff = iend;
	ibegin = ioff + 1;
	iend = isplit[jb];
	in = iend - ioff;

	if (in == 1) {

/*           Special Case -- IN=1 */

	    if (irange == 1 || wl >= d__[ibegin] - pivmin) {
		++nwl;
	    }
	    if (irange == 1 || wu >= d__[ibegin] - pivmin) {
		++nwu;
	    }
	    if (irange == 1 || wl < d__[ibegin] - pivmin && wu >= d__[ibegin] 
		    - pivmin) {
		++(*m);
		w[*m] = d__[ibegin];
		iblock[*m] = jb;
	    }
	} else {

/*           General Case -- IN > 1   

             Compute Gershgorin Interval   
             and use it as the initial interval */

	    gu = d__[ibegin];
	    gl = d__[ibegin];
	    tmp1 = 0.;

	    i__2 = iend - 1;
	    for (j = ibegin; j <= i__2; ++j) {
		tmp2 = (d__1 = e[j], abs(d__1));
/* Computing MAX */
		d__1 = gu, d__2 = d__[j] + tmp1 + tmp2;
		gu = max(d__1,d__2);
/* Computing MIN */
		d__1 = gl, d__2 = d__[j] - tmp1 - tmp2;
		gl = min(d__1,d__2);
		tmp1 = tmp2;
/* L40: */
	    }

/* Computing MAX */
	    d__1 = gu, d__2 = d__[iend] + tmp1;
	    gu = max(d__1,d__2);
/* Computing MIN */
	    d__1 = gl, d__2 = d__[iend] - tmp1;
	    gl = min(d__1,d__2);
/* Computing MAX */
	    d__1 = abs(gl), d__2 = abs(gu);
	    bnorm = max(d__1,d__2);
	    gl = gl - bnorm * 2.1 * ulp * in - pivmin * 2.1;
	    gu = gu + bnorm * 2.1 * ulp * in + pivmin * 2.1;

/*           Compute ATOLI for the current submatrix */

	    if (*abstol <= 0.) {
/* Computing MAX */
		d__1 = abs(gl), d__2 = abs(gu);
		atoli = ulp * max(d__1,d__2);
	    } else {
		atoli = *abstol;
	    }

	    if (irange > 1) {
		if (gu < wl) {
		    nwl += in;
		    nwu += in;
		    goto L70;
		}
		gl = max(gl,wl);
		gu = min(gu,wu);
		if (gl >= gu) {
		    goto L70;
		}
	    }

/*           Set Up Initial Interval */

	    work[*n + 1] = gl;
	    work[*n + in + 1] = gu;
	    igraphdlaebz_(&c__1, &c__0, &in, &in, &c__1, &nb, &atoli, &rtoli, &
		    pivmin, &d__[ibegin], &e[ibegin], &work[ibegin], idumma, &
		    work[*n + 1], &work[*n + (in << 1) + 1], &im, &iwork[1], &
		    w[*m + 1], &iblock[*m + 1], &iinfo);

	    nwl += iwork[1];
	    nwu += iwork[in + 1];
	    iwoff = *m - iwork[1];

/*           Compute Eigenvalues */

	    itmax = (integer) ((log(gu - gl + pivmin) - log(pivmin)) / log(2.)
		    ) + 2;
	    igraphdlaebz_(&c__2, &itmax, &in, &in, &c__1, &nb, &atoli, &rtoli, &
		    pivmin, &d__[ibegin], &e[ibegin], &work[ibegin], idumma, &
		    work[*n + 1], &work[*n + (in << 1) + 1], &iout, &iwork[1],
		     &w[*m + 1], &iblock[*m + 1], &iinfo);

/*           Copy Eigenvalues Into W and IBLOCK   
             Use -JB for block number for unconverged eigenvalues. */

	    i__2 = iout;
	    for (j = 1; j <= i__2; ++j) {
		tmp1 = (work[j + *n] + work[j + in + *n]) * .5;

/*              Flag non-convergence. */

		if (j > iout - iinfo) {
		    ncnvrg = TRUE_;
		    ib = -jb;
		} else {
		    ib = jb;
		}
		i__3 = iwork[j + in] + iwoff;
		for (je = iwork[j] + 1 + iwoff; je <= i__3; ++je) {
		    w[je] = tmp1;
		    iblock[je] = ib;
/* L50: */
		}
/* L60: */
	    }

	    *m += im;
	}
L70:
	;
    }

/*     If RANGE='I', then (WL,WU) contains eigenvalues NWL+1,...,NWU   
       If NWL+1 < IL or NWU > IU, discard extra eigenvalues. */

    if (irange == 3) {
	im = 0;
	idiscl = *il - 1 - nwl;
	idiscu = nwu - *iu;

	if (idiscl > 0 || idiscu > 0) {
	    i__1 = *m;
	    for (je = 1; je <= i__1; ++je) {
		if (w[je] <= wlu && idiscl > 0) {
		    --idiscl;
		} else if (w[je] >= wul && idiscu > 0) {
		    --idiscu;
		} else {
		    ++im;
		    w[im] = w[je];
		    iblock[im] = iblock[je];
		}
/* L80: */
	    }
	    *m = im;
	}
	if (idiscl > 0 || idiscu > 0) {

/*           Code to deal with effects of bad arithmetic:   
             Some low eigenvalues to be discarded are not in (WL,WLU],   
             or high eigenvalues to be discarded are not in (WUL,WU]   
             so just kill off the smallest IDISCL/largest IDISCU   
             eigenvalues, by simply finding the smallest/largest   
             eigenvalue(s).   

             (If N(w) is monotone non-decreasing, this should never   
                 happen.) */

	    if (idiscl > 0) {
		wkill = wu;
		i__1 = idiscl;
		for (jdisc = 1; jdisc <= i__1; ++jdisc) {
		    iw = 0;
		    i__2 = *m;
		    for (je = 1; je <= i__2; ++je) {
			if (iblock[je] != 0 && (w[je] < wkill || iw == 0)) {
			    iw = je;
			    wkill = w[je];
			}
/* L90: */
		    }
		    iblock[iw] = 0;
/* L100: */
		}
	    }
	    if (idiscu > 0) {

		wkill = wl;
		i__1 = idiscu;
		for (jdisc = 1; jdisc <= i__1; ++jdisc) {
		    iw = 0;
		    i__2 = *m;
		    for (je = 1; je <= i__2; ++je) {
			if (iblock[je] != 0 && (w[je] > wkill || iw == 0)) {
			    iw = je;
			    wkill = w[je];
			}
/* L110: */
		    }
		    iblock[iw] = 0;
/* L120: */
		}
	    }
	    im = 0;
	    i__1 = *m;
	    for (je = 1; je <= i__1; ++je) {
		if (iblock[je] != 0) {
		    ++im;
		    w[im] = w[je];
		    iblock[im] = iblock[je];
		}
/* L130: */
	    }
	    *m = im;
	}
	if (idiscl < 0 || idiscu < 0) {
	    toofew = TRUE_;
	}
    }

/*     If ORDER='B', do nothing -- the eigenvalues are already sorted   
          by block.   
       If ORDER='E', sort the eigenvalues from smallest to largest */

    if (iorder == 1 && *nsplit > 1) {
	i__1 = *m - 1;
	for (je = 1; je <= i__1; ++je) {
	    ie = 0;
	    tmp1 = w[je];
	    i__2 = *m;
	    for (j = je + 1; j <= i__2; ++j) {
		if (w[j] < tmp1) {
		    ie = j;
		    tmp1 = w[j];
		}
/* L140: */
	    }

	    if (ie != 0) {
		itmp1 = iblock[ie];
		w[ie] = w[je];
		iblock[ie] = iblock[je];
		w[je] = tmp1;
		iblock[je] = itmp1;
	    }
/* L150: */
	}
    }

    *info = 0;
    if (ncnvrg) {
	++(*info);
    }
    if (toofew) {
	*info += 2;
    }
    return 0;

/*     End of DSTEBZ */

} /* igraphdstebz_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstein.c0000644000175100001710000003523600000000000024045 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__2 = 2;
static integer c__1 = 1;
static integer c_n1 = -1;

/* > \brief \b DSTEIN   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSTEIN + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSTEIN( N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK,   
                            IWORK, IFAIL, INFO )   

         INTEGER            INFO, LDZ, M, N   
         INTEGER            IBLOCK( * ), IFAIL( * ), ISPLIT( * ),   
        $                   IWORK( * )   
         DOUBLE PRECISION   D( * ), E( * ), W( * ), WORK( * ), Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSTEIN computes the eigenvectors of a real symmetric tridiagonal   
   > matrix T corresponding to specified eigenvalues, using inverse   
   > iteration.   
   >   
   > The maximum number of iterations allowed for each eigenvector is   
   > specified by an internal parameter MAXITS (currently set to 5).   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The n diagonal elements of the tridiagonal matrix T.   
   > \endverbatim   
   >   
   > \param[in] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The (n-1) subdiagonal elements of the tridiagonal matrix   
   >          T, in elements 1 to N-1.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of eigenvectors to be found.  0 <= M <= N.   
   > \endverbatim   
   >   
   > \param[in] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements of W contain the eigenvalues for   
   >          which eigenvectors are to be computed.  The eigenvalues   
   >          should be grouped by split-off block and ordered from   
   >          smallest to largest within the block.  ( The output array   
   >          W from DSTEBZ with ORDER = 'B' is expected here. )   
   > \endverbatim   
   >   
   > \param[in] IBLOCK   
   > \verbatim   
   >          IBLOCK is INTEGER array, dimension (N)   
   >          The submatrix indices associated with the corresponding   
   >          eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to   
   >          the first submatrix from the top, =2 if W(i) belongs to   
   >          the second submatrix, etc.  ( The output array IBLOCK   
   >          from DSTEBZ is expected here. )   
   > \endverbatim   
   >   
   > \param[in] ISPLIT   
   > \verbatim   
   >          ISPLIT is INTEGER array, dimension (N)   
   >          The splitting points, at which T breaks up into submatrices.   
   >          The first submatrix consists of rows/columns 1 to   
   >          ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1   
   >          through ISPLIT( 2 ), etc.   
   >          ( The output array ISPLIT from DSTEBZ is expected here. )   
   > \endverbatim   
   >   
   > \param[out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ, M)   
   >          The computed eigenvectors.  The eigenvector associated   
   >          with the eigenvalue W(i) is stored in the i-th column of   
   >          Z.  Any vector which fails to converge is set to its current   
   >          iterate after MAXITS iterations.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z.  LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (5*N)   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] IFAIL   
   > \verbatim   
   >          IFAIL is INTEGER array, dimension (M)   
   >          On normal exit, all elements of IFAIL are zero.   
   >          If one or more eigenvectors fail to converge after   
   >          MAXITS iterations, then their indices are stored in   
   >          array IFAIL.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit.   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   >          > 0: if INFO = i, then i eigenvectors failed to converge   
   >               in MAXITS iterations.  Their indices are stored in   
   >               array IFAIL.   
   > \endverbatim   

   > \par Internal Parameters:   
    =========================   
   >   
   > \verbatim   
   >  MAXITS  INTEGER, default = 5   
   >          The maximum number of iterations performed.   
   >   
   >  EXTRA   INTEGER, default = 2   
   >          The number of iterations performed after norm growth   
   >          criterion is satisfied, should be at least 1.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdstein_(integer *n, doublereal *d__, doublereal *e, 
	integer *m, doublereal *w, integer *iblock, integer *isplit, 
	doublereal *z__, integer *ldz, doublereal *work, integer *iwork, 
	integer *ifail, integer *info)
{
    /* System generated locals */
    integer z_dim1, z_offset, i__1, i__2, i__3;
    doublereal d__1, d__2, d__3, d__4, d__5;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, b1, j1, bn;
    doublereal xj, scl, eps, sep, nrm, tol;
    integer its;
    doublereal xjm, ztr, eps1;
    integer jblk, nblk;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    integer jmax;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    integer iseed[4], gpind, iinfo;
    extern doublereal igraphdasum_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdaxpy_(integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *);
    doublereal ortol;
    integer indrv1, indrv2, indrv3, indrv4, indrv5;
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlagtf_(integer *, doublereal *, doublereal *,
	     doublereal *, doublereal *, doublereal *, doublereal *, integer *
	    , integer *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen), igraphdlagts_(
	    integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, integer *, doublereal *, doublereal *, integer *);
    integer nrmchk;
    extern /* Subroutine */ int igraphdlarnv_(integer *, integer *, integer *, 
	    doublereal *);
    integer blksiz;
    doublereal onenrm, dtpcrt, pertol;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --d__;
    --e;
    --w;
    --iblock;
    --isplit;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --work;
    --iwork;
    --ifail;

    /* Function Body */
    *info = 0;
    i__1 = *m;
    for (i__ = 1; i__ <= i__1; ++i__) {
	ifail[i__] = 0;
/* L10: */
    }

    if (*n < 0) {
	*info = -1;
    } else if (*m < 0 || *m > *n) {
	*info = -4;
    } else if (*ldz < max(1,*n)) {
	*info = -9;
    } else {
	i__1 = *m;
	for (j = 2; j <= i__1; ++j) {
	    if (iblock[j] < iblock[j - 1]) {
		*info = -6;
		goto L30;
	    }
	    if (iblock[j] == iblock[j - 1] && w[j] < w[j - 1]) {
		*info = -5;
		goto L30;
	    }
/* L20: */
	}
L30:
	;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSTEIN", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0 || *m == 0) {
	return 0;
    } else if (*n == 1) {
	z__[z_dim1 + 1] = 1.;
	return 0;
    }

/*     Get machine constants. */

    eps = igraphdlamch_("Precision");

/*     Initialize seed for random number generator DLARNV. */

    for (i__ = 1; i__ <= 4; ++i__) {
	iseed[i__ - 1] = 1;
/* L40: */
    }

/*     Initialize pointers. */

    indrv1 = 0;
    indrv2 = indrv1 + *n;
    indrv3 = indrv2 + *n;
    indrv4 = indrv3 + *n;
    indrv5 = indrv4 + *n;

/*     Compute eigenvectors of matrix blocks. */

    j1 = 1;
    i__1 = iblock[*m];
    for (nblk = 1; nblk <= i__1; ++nblk) {

/*        Find starting and ending indices of block nblk. */

	if (nblk == 1) {
	    b1 = 1;
	} else {
	    b1 = isplit[nblk - 1] + 1;
	}
	bn = isplit[nblk];
	blksiz = bn - b1 + 1;
	if (blksiz == 1) {
	    goto L60;
	}
	gpind = b1;

/*        Compute reorthogonalization criterion and stopping criterion. */

	onenrm = (d__1 = d__[b1], abs(d__1)) + (d__2 = e[b1], abs(d__2));
/* Computing MAX */
	d__3 = onenrm, d__4 = (d__1 = d__[bn], abs(d__1)) + (d__2 = e[bn - 1],
		 abs(d__2));
	onenrm = max(d__3,d__4);
	i__2 = bn - 1;
	for (i__ = b1 + 1; i__ <= i__2; ++i__) {
/* Computing MAX */
	    d__4 = onenrm, d__5 = (d__1 = d__[i__], abs(d__1)) + (d__2 = e[
		    i__ - 1], abs(d__2)) + (d__3 = e[i__], abs(d__3));
	    onenrm = max(d__4,d__5);
/* L50: */
	}
	ortol = onenrm * .001;

	dtpcrt = sqrt(.1 / blksiz);

/*        Loop through eigenvalues of block nblk. */

L60:
	jblk = 0;
	i__2 = *m;
	for (j = j1; j <= i__2; ++j) {
	    if (iblock[j] != nblk) {
		j1 = j;
		goto L160;
	    }
	    ++jblk;
	    xj = w[j];

/*           Skip all the work if the block size is one. */

	    if (blksiz == 1) {
		work[indrv1 + 1] = 1.;
		goto L120;
	    }

/*           If eigenvalues j and j-1 are too close, add a relatively   
             small perturbation. */

	    if (jblk > 1) {
		eps1 = (d__1 = eps * xj, abs(d__1));
		pertol = eps1 * 10.;
		sep = xj - xjm;
		if (sep < pertol) {
		    xj = xjm + pertol;
		}
	    }

	    its = 0;
	    nrmchk = 0;

/*           Get random starting vector. */

	    igraphdlarnv_(&c__2, iseed, &blksiz, &work[indrv1 + 1]);

/*           Copy the matrix T so it won't be destroyed in factorization. */

	    igraphdcopy_(&blksiz, &d__[b1], &c__1, &work[indrv4 + 1], &c__1);
	    i__3 = blksiz - 1;
	    igraphdcopy_(&i__3, &e[b1], &c__1, &work[indrv2 + 2], &c__1);
	    i__3 = blksiz - 1;
	    igraphdcopy_(&i__3, &e[b1], &c__1, &work[indrv3 + 1], &c__1);

/*           Compute LU factors with partial pivoting  ( PT = LU ) */

	    tol = 0.;
	    igraphdlagtf_(&blksiz, &work[indrv4 + 1], &xj, &work[indrv2 + 2], &work[
		    indrv3 + 1], &tol, &work[indrv5 + 1], &iwork[1], &iinfo);

/*           Update iteration count. */

L70:
	    ++its;
	    if (its > 5) {
		goto L100;
	    }

/*           Normalize and scale the righthand side vector Pb.   

   Computing MAX */
	    d__2 = eps, d__3 = (d__1 = work[indrv4 + blksiz], abs(d__1));
	    scl = blksiz * onenrm * max(d__2,d__3) / igraphdasum_(&blksiz, &work[
		    indrv1 + 1], &c__1);
	    igraphdscal_(&blksiz, &scl, &work[indrv1 + 1], &c__1);

/*           Solve the system LU = Pb. */

	    igraphdlagts_(&c_n1, &blksiz, &work[indrv4 + 1], &work[indrv2 + 2], &
		    work[indrv3 + 1], &work[indrv5 + 1], &iwork[1], &work[
		    indrv1 + 1], &tol, &iinfo);

/*           Reorthogonalize by modified Gram-Schmidt if eigenvalues are   
             close enough. */

	    if (jblk == 1) {
		goto L90;
	    }
	    if ((d__1 = xj - xjm, abs(d__1)) > ortol) {
		gpind = j;
	    }
	    if (gpind != j) {
		i__3 = j - 1;
		for (i__ = gpind; i__ <= i__3; ++i__) {
		    ztr = -igraphddot_(&blksiz, &work[indrv1 + 1], &c__1, &z__[b1 + 
			    i__ * z_dim1], &c__1);
		    igraphdaxpy_(&blksiz, &ztr, &z__[b1 + i__ * z_dim1], &c__1, &
			    work[indrv1 + 1], &c__1);
/* L80: */
		}
	    }

/*           Check the infinity norm of the iterate. */

L90:
	    jmax = igraphidamax_(&blksiz, &work[indrv1 + 1], &c__1);
	    nrm = (d__1 = work[indrv1 + jmax], abs(d__1));

/*           Continue for additional iterations after norm reaches   
             stopping criterion. */

	    if (nrm < dtpcrt) {
		goto L70;
	    }
	    ++nrmchk;
	    if (nrmchk < 3) {
		goto L70;
	    }

	    goto L110;

/*           If stopping criterion was not satisfied, update info and   
             store eigenvector number in array ifail. */

L100:
	    ++(*info);
	    ifail[*info] = j;

/*           Accept iterate as jth eigenvector. */

L110:
	    scl = 1. / igraphdnrm2_(&blksiz, &work[indrv1 + 1], &c__1);
	    jmax = igraphidamax_(&blksiz, &work[indrv1 + 1], &c__1);
	    if (work[indrv1 + jmax] < 0.) {
		scl = -scl;
	    }
	    igraphdscal_(&blksiz, &scl, &work[indrv1 + 1], &c__1);
L120:
	    i__3 = *n;
	    for (i__ = 1; i__ <= i__3; ++i__) {
		z__[i__ + j * z_dim1] = 0.;
/* L130: */
	    }
	    i__3 = blksiz;
	    for (i__ = 1; i__ <= i__3; ++i__) {
		z__[b1 + i__ - 1 + j * z_dim1] = work[indrv1 + i__];
/* L140: */
	    }

/*           Save the shift to check eigenvalue spacing at next   
             iteration. */

	    xjm = xj;

/* L150: */
	}
L160:
	;
    }

    return 0;

/*     End of DSTEIN */

} /* igraphdstein_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstemr.c0000644000175100001710000007000500000000000024046 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b18 = .001;

/* > \brief \b DSTEMR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSTEMR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSTEMR( JOBZ, RANGE, N, D, E, VL, VU, IL, IU,   
                            M, W, Z, LDZ, NZC, ISUPPZ, TRYRAC, WORK, LWORK,   
                            IWORK, LIWORK, INFO )   

         CHARACTER          JOBZ, RANGE   
         LOGICAL            TRYRAC   
         INTEGER            IL, INFO, IU, LDZ, NZC, LIWORK, LWORK, M, N   
         DOUBLE PRECISION VL, VU   
         INTEGER            ISUPPZ( * ), IWORK( * )   
         DOUBLE PRECISION   D( * ), E( * ), W( * ), WORK( * )   
         DOUBLE PRECISION   Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSTEMR computes selected eigenvalues and, optionally, eigenvectors   
   > of a real symmetric tridiagonal matrix T. Any such unreduced matrix has   
   > a well defined set of pairwise different real eigenvalues, the corresponding   
   > real eigenvectors are pairwise orthogonal.   
   >   
   > The spectrum may be computed either completely or partially by specifying   
   > either an interval (VL,VU] or a range of indices IL:IU for the desired   
   > eigenvalues.   
   >   
   > Depending on the number of desired eigenvalues, these are computed either   
   > by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are   
   > computed by the use of various suitable L D L^T factorizations near clusters   
   > of close eigenvalues (referred to as RRRs, Relatively Robust   
   > Representations). An informal sketch of the algorithm follows.   
   >   
   > For each unreduced block (submatrix) of T,   
   >    (a) Compute T - sigma I  = L D L^T, so that L and D   
   >        define all the wanted eigenvalues to high relative accuracy.   
   >        This means that small relative changes in the entries of D and L   
   >        cause only small relative changes in the eigenvalues and   
   >        eigenvectors. The standard (unfactored) representation of the   
   >        tridiagonal matrix T does not have this property in general.   
   >    (b) Compute the eigenvalues to suitable accuracy.   
   >        If the eigenvectors are desired, the algorithm attains full   
   >        accuracy of the computed eigenvalues only right before   
   >        the corresponding vectors have to be computed, see steps c) and d).   
   >    (c) For each cluster of close eigenvalues, select a new   
   >        shift close to the cluster, find a new factorization, and refine   
   >        the shifted eigenvalues to suitable accuracy.   
   >    (d) For each eigenvalue with a large enough relative separation compute   
   >        the corresponding eigenvector by forming a rank revealing twisted   
   >        factorization. Go back to (c) for any clusters that remain.   
   >   
   > For more details, see:   
   > - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations   
   >   to compute orthogonal eigenvectors of symmetric tridiagonal matrices,"   
   >   Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.   
   > - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and   
   >   Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,   
   >   2004.  Also LAPACK Working Note 154.   
   > - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric   
   >   tridiagonal eigenvalue/eigenvector problem",   
   >   Computer Science Division Technical Report No. UCB/CSD-97-971,   
   >   UC Berkeley, May 1997.   
   >   
   > Further Details   
   > 1.DSTEMR works only on machines which follow IEEE-754   
   > floating-point standard in their handling of infinities and NaNs.   
   > This permits the use of efficient inner loops avoiding a check for   
   > zero divisors.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOBZ   
   > \verbatim   
   >          JOBZ is CHARACTER*1   
   >          = 'N':  Compute eigenvalues only;   
   >          = 'V':  Compute eigenvalues and eigenvectors.   
   > \endverbatim   
   >   
   > \param[in] RANGE   
   > \verbatim   
   >          RANGE is CHARACTER*1   
   >          = 'A': all eigenvalues will be found.   
   >          = 'V': all eigenvalues in the half-open interval (VL,VU]   
   >                 will be found.   
   >          = 'I': the IL-th through IU-th eigenvalues will be found.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the N diagonal elements of the tridiagonal matrix   
   >          T. On exit, D is overwritten.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the (N-1) subdiagonal elements of the tridiagonal   
   >          matrix T in elements 1 to N-1 of E. E(N) need not be set on   
   >          input, but is used internally as workspace.   
   >          On exit, E is overwritten.   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >   
   >          If RANGE='V', the lower and upper bounds of the interval to   
   >          be searched for eigenvalues. VL < VU.   
   >          Not referenced if RANGE = 'A' or 'I'.   
   > \endverbatim   
   >   
   > \param[in] IL   
   > \verbatim   
   >          IL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IU   
   > \verbatim   
   >          IU is INTEGER   
   >   
   >          If RANGE='I', the indices (in ascending order) of the   
   >          smallest and largest eigenvalues to be returned.   
   >          1 <= IL <= IU <= N, if N > 0.   
   >          Not referenced if RANGE = 'A' or 'V'.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The total number of eigenvalues found.  0 <= M <= N.   
   >          If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements contain the selected eigenvalues in   
   >          ascending order.   
   > \endverbatim   
   >   
   > \param[out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )   
   >          If JOBZ = 'V', and if INFO = 0, then the first M columns of Z   
   >          contain the orthonormal eigenvectors of the matrix T   
   >          corresponding to the selected eigenvalues, with the i-th   
   >          column of Z holding the eigenvector associated with W(i).   
   >          If JOBZ = 'N', then Z is not referenced.   
   >          Note: the user must ensure that at least max(1,M) columns are   
   >          supplied in the array Z; if RANGE = 'V', the exact value of M   
   >          is not known in advance and can be computed with a workspace   
   >          query by setting NZC = -1, see below.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z.  LDZ >= 1, and if   
   >          JOBZ = 'V', then LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] NZC   
   > \verbatim   
   >          NZC is INTEGER   
   >          The number of eigenvectors to be held in the array Z.   
   >          If RANGE = 'A', then NZC >= max(1,N).   
   >          If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].   
   >          If RANGE = 'I', then NZC >= IU-IL+1.   
   >          If NZC = -1, then a workspace query is assumed; the   
   >          routine calculates the number of columns of the array Z that   
   >          are needed to hold the eigenvectors.   
   >          This value is returned as the first entry of the Z array, and   
   >          no error message related to NZC is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] ISUPPZ   
   > \verbatim   
   >          ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )   
   >          The support of the eigenvectors in Z, i.e., the indices   
   >          indicating the nonzero elements in Z. The i-th computed eigenvector   
   >          is nonzero only in elements ISUPPZ( 2*i-1 ) through   
   >          ISUPPZ( 2*i ). This is relevant in the case when the matrix   
   >          is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0.   
   > \endverbatim   
   >   
   > \param[in,out] TRYRAC   
   > \verbatim   
   >          TRYRAC is LOGICAL   
   >          If TRYRAC.EQ..TRUE., indicates that the code should check whether   
   >          the tridiagonal matrix defines its eigenvalues to high relative   
   >          accuracy.  If so, the code uses relative-accuracy preserving   
   >          algorithms that might be (a bit) slower depending on the matrix.   
   >          If the matrix does not define its eigenvalues to high relative   
   >          accuracy, the code can uses possibly faster algorithms.   
   >          If TRYRAC.EQ..FALSE., the code is not required to guarantee   
   >          relatively accurate eigenvalues and can use the fastest possible   
   >          techniques.   
   >          On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix   
   >          does not define its eigenvalues to high relative accuracy.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LWORK)   
   >          On exit, if INFO = 0, WORK(1) returns the optimal   
   >          (and minimal) LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK. LWORK >= max(1,18*N)   
   >          if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (LIWORK)   
   >          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.   
   > \endverbatim   
   >   
   > \param[in] LIWORK   
   > \verbatim   
   >          LIWORK is INTEGER   
   >          The dimension of the array IWORK.  LIWORK >= max(1,10*N)   
   >          if the eigenvectors are desired, and LIWORK >= max(1,8*N)   
   >          if only the eigenvalues are to be computed.   
   >          If LIWORK = -1, then a workspace query is assumed; the   
   >          routine only calculates the optimal size of the IWORK array,   
   >          returns this value as the first entry of the IWORK array, and   
   >          no error message related to LIWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          On exit, INFO   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  if INFO = 1X, internal error in DLARRE,   
   >                if INFO = 2X, internal error in DLARRV.   
   >                Here, the digit X = ABS( IINFO ) < 10, where IINFO is   
   >                the nonzero error code returned by DLARRE or   
   >                DLARRV, respectively.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2013   

   > \ingroup doubleOTHERcomputational   

   > \par Contributors:   
    ==================   
   >   
   > Beresford Parlett, University of California, Berkeley, USA \n   
   > Jim Demmel, University of California, Berkeley, USA \n   
   > Inderjit Dhillon, University of Texas, Austin, USA \n   
   > Osni Marques, LBNL/NERSC, USA \n   
   > Christof Voemel, University of California, Berkeley, USA   

    =====================================================================   
   Subroutine */ int igraphdstemr_(char *jobz, char *range, integer *n, doublereal *
	d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
	integer *iu, integer *m, doublereal *w, doublereal *z__, integer *ldz,
	 integer *nzc, integer *isuppz, logical *tryrac, doublereal *work, 
	integer *lwork, integer *iwork, integer *liwork, integer *info)
{
    /* System generated locals */
    integer z_dim1, z_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j;
    doublereal r1, r2;
    integer jj;
    doublereal cs;
    integer in;
    doublereal sn, wl, wu;
    integer iil, iiu;
    doublereal eps, tmp;
    integer indd, iend, jblk, wend;
    doublereal rmin, rmax;
    integer itmp;
    doublereal tnrm;
    extern /* Subroutine */ int igraphdlae2_(doublereal *, doublereal *, doublereal 
	    *, doublereal *, doublereal *);
    integer inde2, itmp2;
    doublereal rtol1, rtol2;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    doublereal scale;
    integer indgp;
    extern logical igraphlsame_(char *, char *);
    integer iinfo, iindw, ilast;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdswap_(integer *, doublereal *, integer 
	    *, doublereal *, integer *);
    integer lwmin;
    logical wantz;
    extern /* Subroutine */ int igraphdlaev2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *);
    extern doublereal igraphdlamch_(char *);
    logical alleig;
    integer ibegin;
    logical indeig;
    integer iindbl;
    logical valeig;
    extern /* Subroutine */ int igraphdlarrc_(char *, integer *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
	     integer *, integer *, integer *), igraphdlarre_(char *, 
	    integer *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, integer *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, integer *);
    integer wbegin;
    doublereal safmin;
    extern /* Subroutine */ int igraphdlarrj_(integer *, doublereal *, doublereal *,
	     integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
	     integer *), igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum;
    integer inderr, iindwk, indgrs, offset;
    extern doublereal igraphdlanst_(char *, integer *, doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlarrr_(integer *, doublereal *, doublereal *,
	     integer *), igraphdlarrv_(integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
	    integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *), igraphdlasrt_(char *, integer *, doublereal *, 
	    integer *);
    doublereal thresh;
    integer iinspl, ifirst, indwrk, liwmin, nzcmin;
    doublereal pivmin;
    integer nsplit;
    doublereal smlnum;
    logical lquery, zquery;


/*  -- LAPACK computational routine (version 3.5.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2013   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --d__;
    --e;
    --w;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --isuppz;
    --work;
    --iwork;

    /* Function Body */
    wantz = igraphlsame_(jobz, "V");
    alleig = igraphlsame_(range, "A");
    valeig = igraphlsame_(range, "V");
    indeig = igraphlsame_(range, "I");

    lquery = *lwork == -1 || *liwork == -1;
    zquery = *nzc == -1;
/*     DSTEMR needs WORK of size 6*N, IWORK of size 3*N.   
       In addition, DLARRE needs WORK of size 6*N, IWORK of size 5*N.   
       Furthermore, DLARRV needs WORK of size 12*N, IWORK of size 7*N. */
    if (wantz) {
	lwmin = *n * 18;
	liwmin = *n * 10;
    } else {
/*        need less workspace if only the eigenvalues are wanted */
	lwmin = *n * 12;
	liwmin = *n << 3;
    }
    wl = 0.;
    wu = 0.;
    iil = 0;
    iiu = 0;
    nsplit = 0;
    if (valeig) {
/*        We do not reference VL, VU in the cases RANGE = 'I','A'   
          The interval (WL, WU] contains all the wanted eigenvalues.   
          It is either given by the user or computed in DLARRE. */
	wl = *vl;
	wu = *vu;
    } else if (indeig) {
/*        We do not reference IL, IU in the cases RANGE = 'V','A' */
	iil = *il;
	iiu = *iu;
    }

    *info = 0;
    if (! (wantz || igraphlsame_(jobz, "N"))) {
	*info = -1;
    } else if (! (alleig || valeig || indeig)) {
	*info = -2;
    } else if (*n < 0) {
	*info = -3;
    } else if (valeig && *n > 0 && wu <= wl) {
	*info = -7;
    } else if (indeig && (iil < 1 || iil > *n)) {
	*info = -8;
    } else if (indeig && (iiu < iil || iiu > *n)) {
	*info = -9;
    } else if (*ldz < 1 || wantz && *ldz < *n) {
	*info = -13;
    } else if (*lwork < lwmin && ! lquery) {
	*info = -17;
    } else if (*liwork < liwmin && ! lquery) {
	*info = -19;
    }

/*     Get machine constants. */

    safmin = igraphdlamch_("Safe minimum");
    eps = igraphdlamch_("Precision");
    smlnum = safmin / eps;
    bignum = 1. / smlnum;
    rmin = sqrt(smlnum);
/* Computing MIN */
    d__1 = sqrt(bignum), d__2 = 1. / sqrt(sqrt(safmin));
    rmax = min(d__1,d__2);

    if (*info == 0) {
	work[1] = (doublereal) lwmin;
	iwork[1] = liwmin;

	if (wantz && alleig) {
	    nzcmin = *n;
	} else if (wantz && valeig) {
	    igraphdlarrc_("T", n, vl, vu, &d__[1], &e[1], &safmin, &nzcmin, &itmp, &
		    itmp2, info);
	} else if (wantz && indeig) {
	    nzcmin = iiu - iil + 1;
	} else {
/*           WANTZ .EQ. FALSE. */
	    nzcmin = 0;
	}
	if (zquery && *info == 0) {
	    z__[z_dim1 + 1] = (doublereal) nzcmin;
	} else if (*nzc < nzcmin && ! zquery) {
	    *info = -14;
	}
    }
    if (*info != 0) {

	i__1 = -(*info);
	igraphxerbla_("DSTEMR", &i__1, (ftnlen)6);

	return 0;
    } else if (lquery || zquery) {
	return 0;
    }

/*     Handle N = 0, 1, and 2 cases immediately */

    *m = 0;
    if (*n == 0) {
	return 0;
    }

    if (*n == 1) {
	if (alleig || indeig) {
	    *m = 1;
	    w[1] = d__[1];
	} else {
	    if (wl < d__[1] && wu >= d__[1]) {
		*m = 1;
		w[1] = d__[1];
	    }
	}
	if (wantz && ! zquery) {
	    z__[z_dim1 + 1] = 1.;
	    isuppz[1] = 1;
	    isuppz[2] = 1;
	}
	return 0;
    }

    if (*n == 2) {
	if (! wantz) {
	    igraphdlae2_(&d__[1], &e[1], &d__[2], &r1, &r2);
	} else if (wantz && ! zquery) {
	    igraphdlaev2_(&d__[1], &e[1], &d__[2], &r1, &r2, &cs, &sn);
	}
	if (alleig || valeig && r2 > wl && r2 <= wu || indeig && iil == 1) {
	    ++(*m);
	    w[*m] = r2;
	    if (wantz && ! zquery) {
		z__[*m * z_dim1 + 1] = -sn;
		z__[*m * z_dim1 + 2] = cs;
/*              Note: At most one of SN and CS can be zero. */
		if (sn != 0.) {
		    if (cs != 0.) {
			isuppz[(*m << 1) - 1] = 1;
			isuppz[*m * 2] = 2;
		    } else {
			isuppz[(*m << 1) - 1] = 1;
			isuppz[*m * 2] = 1;
		    }
		} else {
		    isuppz[(*m << 1) - 1] = 2;
		    isuppz[*m * 2] = 2;
		}
	    }
	}
	if (alleig || valeig && r1 > wl && r1 <= wu || indeig && iiu == 2) {
	    ++(*m);
	    w[*m] = r1;
	    if (wantz && ! zquery) {
		z__[*m * z_dim1 + 1] = cs;
		z__[*m * z_dim1 + 2] = sn;
/*              Note: At most one of SN and CS can be zero. */
		if (sn != 0.) {
		    if (cs != 0.) {
			isuppz[(*m << 1) - 1] = 1;
			isuppz[*m * 2] = 2;
		    } else {
			isuppz[(*m << 1) - 1] = 1;
			isuppz[*m * 2] = 1;
		    }
		} else {
		    isuppz[(*m << 1) - 1] = 2;
		    isuppz[*m * 2] = 2;
		}
	    }
	}
    } else {
/*     Continue with general N */
	indgrs = 1;
	inderr = (*n << 1) + 1;
	indgp = *n * 3 + 1;
	indd = (*n << 2) + 1;
	inde2 = *n * 5 + 1;
	indwrk = *n * 6 + 1;

	iinspl = 1;
	iindbl = *n + 1;
	iindw = (*n << 1) + 1;
	iindwk = *n * 3 + 1;

/*        Scale matrix to allowable range, if necessary.   
          The allowable range is related to the PIVMIN parameter; see the   
          comments in DLARRD.  The preference for scaling small values   
          up is heuristic; we expect users' matrices not to be close to the   
          RMAX threshold. */

	scale = 1.;
	tnrm = igraphdlanst_("M", n, &d__[1], &e[1]);
	if (tnrm > 0. && tnrm < rmin) {
	    scale = rmin / tnrm;
	} else if (tnrm > rmax) {
	    scale = rmax / tnrm;
	}
	if (scale != 1.) {
	    igraphdscal_(n, &scale, &d__[1], &c__1);
	    i__1 = *n - 1;
	    igraphdscal_(&i__1, &scale, &e[1], &c__1);
	    tnrm *= scale;
	    if (valeig) {
/*              If eigenvalues in interval have to be found,   
                scale (WL, WU] accordingly */
		wl *= scale;
		wu *= scale;
	    }
	}

/*        Compute the desired eigenvalues of the tridiagonal after splitting   
          into smaller subblocks if the corresponding off-diagonal elements   
          are small   
          THRESH is the splitting parameter for DLARRE   
          A negative THRESH forces the old splitting criterion based on the   
          size of the off-diagonal. A positive THRESH switches to splitting   
          which preserves relative accuracy. */

	if (*tryrac) {
/*           Test whether the matrix warrants the more expensive relative approach. */
	    igraphdlarrr_(n, &d__[1], &e[1], &iinfo);
	} else {
/*           The user does not care about relative accurately eigenvalues */
	    iinfo = -1;
	}
/*        Set the splitting criterion */
	if (iinfo == 0) {
	    thresh = eps;
	} else {
	    thresh = -eps;
/*           relative accuracy is desired but T does not guarantee it */
	    *tryrac = FALSE_;
	}

	if (*tryrac) {
/*           Copy original diagonal, needed to guarantee relative accuracy */
	    igraphdcopy_(n, &d__[1], &c__1, &work[indd], &c__1);
	}
/*        Store the squares of the offdiagonal values of T */
	i__1 = *n - 1;
	for (j = 1; j <= i__1; ++j) {
/* Computing 2nd power */
	    d__1 = e[j];
	    work[inde2 + j - 1] = d__1 * d__1;
/* L5: */
	}
/*        Set the tolerance parameters for bisection */
	if (! wantz) {
/*           DLARRE computes the eigenvalues to full precision. */
	    rtol1 = eps * 4.;
	    rtol2 = eps * 4.;
	} else {
/*           DLARRE computes the eigenvalues to less than full precision.   
             DLARRV will refine the eigenvalue approximations, and we can   
             need less accurate initial bisection in DLARRE.   
             Note: these settings do only affect the subset case and DLARRE */
	    rtol1 = sqrt(eps);
/* Computing MAX */
	    d__1 = sqrt(eps) * .005, d__2 = eps * 4.;
	    rtol2 = max(d__1,d__2);
	}
	igraphdlarre_(range, n, &wl, &wu, &iil, &iiu, &d__[1], &e[1], &work[inde2], 
		&rtol1, &rtol2, &thresh, &nsplit, &iwork[iinspl], m, &w[1], &
		work[inderr], &work[indgp], &iwork[iindbl], &iwork[iindw], &
		work[indgrs], &pivmin, &work[indwrk], &iwork[iindwk], &iinfo);
	if (iinfo != 0) {
	    *info = abs(iinfo) + 10;
	    return 0;
	}
/*        Note that if RANGE .NE. 'V', DLARRE computes bounds on the desired   
          part of the spectrum. All desired eigenvalues are contained in   
          (WL,WU] */
	if (wantz) {

/*           Compute the desired eigenvectors corresponding to the computed   
             eigenvalues */

	    igraphdlarrv_(n, &wl, &wu, &d__[1], &e[1], &pivmin, &iwork[iinspl], m, &
		    c__1, m, &c_b18, &rtol1, &rtol2, &w[1], &work[inderr], &
		    work[indgp], &iwork[iindbl], &iwork[iindw], &work[indgrs],
		     &z__[z_offset], ldz, &isuppz[1], &work[indwrk], &iwork[
		    iindwk], &iinfo);
	    if (iinfo != 0) {
		*info = abs(iinfo) + 20;
		return 0;
	    }
	} else {
/*           DLARRE computes eigenvalues of the (shifted) root representation   
             DLARRV returns the eigenvalues of the unshifted matrix.   
             However, if the eigenvectors are not desired by the user, we need   
             to apply the corresponding shifts from DLARRE to obtain the   
             eigenvalues of the original matrix. */
	    i__1 = *m;
	    for (j = 1; j <= i__1; ++j) {
		itmp = iwork[iindbl + j - 1];
		w[j] += e[iwork[iinspl + itmp - 1]];
/* L20: */
	    }
	}

	if (*tryrac) {
/*           Refine computed eigenvalues so that they are relatively accurate   
             with respect to the original matrix T. */
	    ibegin = 1;
	    wbegin = 1;
	    i__1 = iwork[iindbl + *m - 1];
	    for (jblk = 1; jblk <= i__1; ++jblk) {
		iend = iwork[iinspl + jblk - 1];
		in = iend - ibegin + 1;
		wend = wbegin - 1;
/*              check if any eigenvalues have to be refined in this block */
L36:
		if (wend < *m) {
		    if (iwork[iindbl + wend] == jblk) {
			++wend;
			goto L36;
		    }
		}
		if (wend < wbegin) {
		    ibegin = iend + 1;
		    goto L39;
		}
		offset = iwork[iindw + wbegin - 1] - 1;
		ifirst = iwork[iindw + wbegin - 1];
		ilast = iwork[iindw + wend - 1];
		rtol2 = eps * 4.;
		igraphdlarrj_(&in, &work[indd + ibegin - 1], &work[inde2 + ibegin - 
			1], &ifirst, &ilast, &rtol2, &offset, &w[wbegin], &
			work[inderr + wbegin - 1], &work[indwrk], &iwork[
			iindwk], &pivmin, &tnrm, &iinfo);
		ibegin = iend + 1;
		wbegin = wend + 1;
L39:
		;
	    }
	}

/*        If matrix was scaled, then rescale eigenvalues appropriately. */

	if (scale != 1.) {
	    d__1 = 1. / scale;
	    igraphdscal_(m, &d__1, &w[1], &c__1);
	}
    }

/*     If eigenvalues are not in increasing order, then sort them,   
       possibly along with eigenvectors. */

    if (nsplit > 1 || *n == 2) {
	if (! wantz) {
	    igraphdlasrt_("I", m, &w[1], &iinfo);
	    if (iinfo != 0) {
		*info = 3;
		return 0;
	    }
	} else {
	    i__1 = *m - 1;
	    for (j = 1; j <= i__1; ++j) {
		i__ = 0;
		tmp = w[j];
		i__2 = *m;
		for (jj = j + 1; jj <= i__2; ++jj) {
		    if (w[jj] < tmp) {
			i__ = jj;
			tmp = w[jj];
		    }
/* L50: */
		}
		if (i__ != 0) {
		    w[i__] = w[j];
		    w[j] = tmp;
		    if (wantz) {
			igraphdswap_(n, &z__[i__ * z_dim1 + 1], &c__1, &z__[j * 
				z_dim1 + 1], &c__1);
			itmp = isuppz[(i__ << 1) - 1];
			isuppz[(i__ << 1) - 1] = isuppz[(j << 1) - 1];
			isuppz[(j << 1) - 1] = itmp;
			itmp = isuppz[i__ * 2];
			isuppz[i__ * 2] = isuppz[j * 2];
			isuppz[j * 2] = itmp;
		    }
		}
/* L60: */
	    }
	}
    }


    work[1] = (doublereal) lwmin;
    iwork[1] = liwmin;
    return 0;

/*     End of DSTEMR */

} /* igraphdstemr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsteqr.c0000644000175100001710000004051400000000000024054 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b9 = 0.;
static doublereal c_b10 = 1.;
static integer c__0 = 0;
static integer c__1 = 1;
static integer c__2 = 2;

/* > \brief \b DSTEQR   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSTEQR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO )   

         CHARACTER          COMPZ   
         INTEGER            INFO, LDZ, N   
         DOUBLE PRECISION   D( * ), E( * ), WORK( * ), Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSTEQR computes all eigenvalues and, optionally, eigenvectors of a   
   > symmetric tridiagonal matrix using the implicit QL or QR method.   
   > The eigenvectors of a full or band symmetric matrix can also be found   
   > if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to   
   > tridiagonal form.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] COMPZ   
   > \verbatim   
   >          COMPZ is CHARACTER*1   
   >          = 'N':  Compute eigenvalues only.   
   >          = 'V':  Compute eigenvalues and eigenvectors of the original   
   >                  symmetric matrix.  On entry, Z must contain the   
   >                  orthogonal matrix used to reduce the original matrix   
   >                  to tridiagonal form.   
   >          = 'I':  Compute eigenvalues and eigenvectors of the   
   >                  tridiagonal matrix.  Z is initialized to the identity   
   >                  matrix.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the diagonal elements of the tridiagonal matrix.   
   >          On exit, if INFO = 0, the eigenvalues in ascending order.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, the (n-1) subdiagonal elements of the tridiagonal   
   >          matrix.   
   >          On exit, E has been destroyed.   
   > \endverbatim   
   >   
   > \param[in,out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ, N)   
   >          On entry, if  COMPZ = 'V', then Z contains the orthogonal   
   >          matrix used in the reduction to tridiagonal form.   
   >          On exit, if INFO = 0, then if  COMPZ = 'V', Z contains the   
   >          orthonormal eigenvectors of the original symmetric matrix,   
   >          and if COMPZ = 'I', Z contains the orthonormal eigenvectors   
   >          of the symmetric tridiagonal matrix.   
   >          If COMPZ = 'N', then Z is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z.  LDZ >= 1, and if   
   >          eigenvectors are desired, then  LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (max(1,2*N-2))   
   >          If COMPZ = 'N', then WORK is not referenced.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  the algorithm has failed to find all the eigenvalues in   
   >                a total of 30*N iterations; if INFO = i, then i   
   >                elements of E have not converged to zero; on exit, D   
   >                and E contain the elements of a symmetric tridiagonal   
   >                matrix which is orthogonally similar to the original   
   >                matrix.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdsteqr_(char *compz, integer *n, doublereal *d__, 
	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
	integer *info)
{
    /* System generated locals */
    integer z_dim1, z_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal), d_sign(doublereal *, doublereal *);

    /* Local variables */
    doublereal b, c__, f, g;
    integer i__, j, k, l, m;
    doublereal p, r__, s;
    integer l1, ii, mm, lm1, mm1, nm1;
    doublereal rt1, rt2, eps;
    integer lsv;
    doublereal tst, eps2;
    integer lend, jtot;
    extern /* Subroutine */ int igraphdlae2_(doublereal *, doublereal *, doublereal 
	    *, doublereal *, doublereal *);
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdlasr_(char *, char *, char *, integer *, 
	    integer *, doublereal *, doublereal *, doublereal *, integer *);
    doublereal anorm;
    extern /* Subroutine */ int igraphdswap_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdlaev2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *);
    integer lendm1, lendp1;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
    integer iscale;
    extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *), igraphdlaset_(char *, integer *, integer 
	    *, doublereal *, doublereal *, doublereal *, integer *);
    doublereal safmin;
    extern /* Subroutine */ int igraphdlartg_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *);
    doublereal safmax;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    extern doublereal igraphdlanst_(char *, integer *, doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlasrt_(char *, integer *, doublereal *, 
	    integer *);
    integer lendsv;
    doublereal ssfmin;
    integer nmaxit, icompz;
    doublereal ssfmax;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --d__;
    --e;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --work;

    /* Function Body */
    *info = 0;

    if (igraphlsame_(compz, "N")) {
	icompz = 0;
    } else if (igraphlsame_(compz, "V")) {
	icompz = 1;
    } else if (igraphlsame_(compz, "I")) {
	icompz = 2;
    } else {
	icompz = -1;
    }
    if (icompz < 0) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*ldz < 1 || icompz > 0 && *ldz < max(1,*n)) {
	*info = -6;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSTEQR", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

    if (*n == 1) {
	if (icompz == 2) {
	    z__[z_dim1 + 1] = 1.;
	}
	return 0;
    }

/*     Determine the unit roundoff and over/underflow thresholds. */

    eps = igraphdlamch_("E");
/* Computing 2nd power */
    d__1 = eps;
    eps2 = d__1 * d__1;
    safmin = igraphdlamch_("S");
    safmax = 1. / safmin;
    ssfmax = sqrt(safmax) / 3.;
    ssfmin = sqrt(safmin) / eps2;

/*     Compute the eigenvalues and eigenvectors of the tridiagonal   
       matrix. */

    if (icompz == 2) {
	igraphdlaset_("Full", n, n, &c_b9, &c_b10, &z__[z_offset], ldz);
    }

    nmaxit = *n * 30;
    jtot = 0;

/*     Determine where the matrix splits and choose QL or QR iteration   
       for each block, according to whether top or bottom diagonal   
       element is smaller. */

    l1 = 1;
    nm1 = *n - 1;

L10:
    if (l1 > *n) {
	goto L160;
    }
    if (l1 > 1) {
	e[l1 - 1] = 0.;
    }
    if (l1 <= nm1) {
	i__1 = nm1;
	for (m = l1; m <= i__1; ++m) {
	    tst = (d__1 = e[m], abs(d__1));
	    if (tst == 0.) {
		goto L30;
	    }
	    if (tst <= sqrt((d__1 = d__[m], abs(d__1))) * sqrt((d__2 = d__[m 
		    + 1], abs(d__2))) * eps) {
		e[m] = 0.;
		goto L30;
	    }
/* L20: */
	}
    }
    m = *n;

L30:
    l = l1;
    lsv = l;
    lend = m;
    lendsv = lend;
    l1 = m + 1;
    if (lend == l) {
	goto L10;
    }

/*     Scale submatrix in rows and columns L to LEND */

    i__1 = lend - l + 1;
    anorm = igraphdlanst_("M", &i__1, &d__[l], &e[l]);
    iscale = 0;
    if (anorm == 0.) {
	goto L10;
    }
    if (anorm > ssfmax) {
	iscale = 1;
	i__1 = lend - l + 1;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &e[l], n, 
		info);
    } else if (anorm < ssfmin) {
	iscale = 2;
	i__1 = lend - l + 1;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &e[l], n, 
		info);
    }

/*     Choose between QL and QR iteration */

    if ((d__1 = d__[lend], abs(d__1)) < (d__2 = d__[l], abs(d__2))) {
	lend = lsv;
	l = lendsv;
    }

    if (lend > l) {

/*        QL Iteration   

          Look for small subdiagonal element. */

L40:
	if (l != lend) {
	    lendm1 = lend - 1;
	    i__1 = lendm1;
	    for (m = l; m <= i__1; ++m) {
/* Computing 2nd power */
		d__2 = (d__1 = e[m], abs(d__1));
		tst = d__2 * d__2;
		if (tst <= eps2 * (d__1 = d__[m], abs(d__1)) * (d__2 = d__[m 
			+ 1], abs(d__2)) + safmin) {
		    goto L60;
		}
/* L50: */
	    }
	}

	m = lend;

L60:
	if (m < lend) {
	    e[m] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L80;
	}

/*        If remaining matrix is 2-by-2, use DLAE2 or SLAEV2   
          to compute its eigensystem. */

	if (m == l + 1) {
	    if (icompz > 0) {
		igraphdlaev2_(&d__[l], &e[l], &d__[l + 1], &rt1, &rt2, &c__, &s);
		work[l] = c__;
		work[*n - 1 + l] = s;
		igraphdlasr_("R", "V", "B", n, &c__2, &work[l], &work[*n - 1 + l], &
			z__[l * z_dim1 + 1], ldz);
	    } else {
		igraphdlae2_(&d__[l], &e[l], &d__[l + 1], &rt1, &rt2);
	    }
	    d__[l] = rt1;
	    d__[l + 1] = rt2;
	    e[l] = 0.;
	    l += 2;
	    if (l <= lend) {
		goto L40;
	    }
	    goto L140;
	}

	if (jtot == nmaxit) {
	    goto L140;
	}
	++jtot;

/*        Form shift. */

	g = (d__[l + 1] - p) / (e[l] * 2.);
	r__ = igraphdlapy2_(&g, &c_b10);
	g = d__[m] - p + e[l] / (g + d_sign(&r__, &g));

	s = 1.;
	c__ = 1.;
	p = 0.;

/*        Inner loop */

	mm1 = m - 1;
	i__1 = l;
	for (i__ = mm1; i__ >= i__1; --i__) {
	    f = s * e[i__];
	    b = c__ * e[i__];
	    igraphdlartg_(&g, &f, &c__, &s, &r__);
	    if (i__ != m - 1) {
		e[i__ + 1] = r__;
	    }
	    g = d__[i__ + 1] - p;
	    r__ = (d__[i__] - g) * s + c__ * 2. * b;
	    p = s * r__;
	    d__[i__ + 1] = g + p;
	    g = c__ * r__ - b;

/*           If eigenvectors are desired, then save rotations. */

	    if (icompz > 0) {
		work[i__] = c__;
		work[*n - 1 + i__] = -s;
	    }

/* L70: */
	}

/*        If eigenvectors are desired, then apply saved rotations. */

	if (icompz > 0) {
	    mm = m - l + 1;
	    igraphdlasr_("R", "V", "B", n, &mm, &work[l], &work[*n - 1 + l], &z__[l 
		    * z_dim1 + 1], ldz);
	}

	d__[l] -= p;
	e[l] = g;
	goto L40;

/*        Eigenvalue found. */

L80:
	d__[l] = p;

	++l;
	if (l <= lend) {
	    goto L40;
	}
	goto L140;

    } else {

/*        QR Iteration   

          Look for small superdiagonal element. */

L90:
	if (l != lend) {
	    lendp1 = lend + 1;
	    i__1 = lendp1;
	    for (m = l; m >= i__1; --m) {
/* Computing 2nd power */
		d__2 = (d__1 = e[m - 1], abs(d__1));
		tst = d__2 * d__2;
		if (tst <= eps2 * (d__1 = d__[m], abs(d__1)) * (d__2 = d__[m 
			- 1], abs(d__2)) + safmin) {
		    goto L110;
		}
/* L100: */
	    }
	}

	m = lend;

L110:
	if (m > lend) {
	    e[m - 1] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L130;
	}

/*        If remaining matrix is 2-by-2, use DLAE2 or SLAEV2   
          to compute its eigensystem. */

	if (m == l - 1) {
	    if (icompz > 0) {
		igraphdlaev2_(&d__[l - 1], &e[l - 1], &d__[l], &rt1, &rt2, &c__, &s)
			;
		work[m] = c__;
		work[*n - 1 + m] = s;
		igraphdlasr_("R", "V", "F", n, &c__2, &work[m], &work[*n - 1 + m], &
			z__[(l - 1) * z_dim1 + 1], ldz);
	    } else {
		igraphdlae2_(&d__[l - 1], &e[l - 1], &d__[l], &rt1, &rt2);
	    }
	    d__[l - 1] = rt1;
	    d__[l] = rt2;
	    e[l - 1] = 0.;
	    l += -2;
	    if (l >= lend) {
		goto L90;
	    }
	    goto L140;
	}

	if (jtot == nmaxit) {
	    goto L140;
	}
	++jtot;

/*        Form shift. */

	g = (d__[l - 1] - p) / (e[l - 1] * 2.);
	r__ = igraphdlapy2_(&g, &c_b10);
	g = d__[m] - p + e[l - 1] / (g + d_sign(&r__, &g));

	s = 1.;
	c__ = 1.;
	p = 0.;

/*        Inner loop */

	lm1 = l - 1;
	i__1 = lm1;
	for (i__ = m; i__ <= i__1; ++i__) {
	    f = s * e[i__];
	    b = c__ * e[i__];
	    igraphdlartg_(&g, &f, &c__, &s, &r__);
	    if (i__ != m) {
		e[i__ - 1] = r__;
	    }
	    g = d__[i__] - p;
	    r__ = (d__[i__ + 1] - g) * s + c__ * 2. * b;
	    p = s * r__;
	    d__[i__] = g + p;
	    g = c__ * r__ - b;

/*           If eigenvectors are desired, then save rotations. */

	    if (icompz > 0) {
		work[i__] = c__;
		work[*n - 1 + i__] = s;
	    }

/* L120: */
	}

/*        If eigenvectors are desired, then apply saved rotations. */

	if (icompz > 0) {
	    mm = l - m + 1;
	    igraphdlasr_("R", "V", "F", n, &mm, &work[m], &work[*n - 1 + m], &z__[m 
		    * z_dim1 + 1], ldz);
	}

	d__[l] -= p;
	e[lm1] = g;
	goto L90;

/*        Eigenvalue found. */

L130:
	d__[l] = p;

	--l;
	if (l >= lend) {
	    goto L90;
	}
	goto L140;

    }

/*     Undo scaling if necessary */

L140:
    if (iscale == 1) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("G", &c__0, &c__0, &ssfmax, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
	i__1 = lendsv - lsv;
	igraphdlascl_("G", &c__0, &c__0, &ssfmax, &anorm, &i__1, &c__1, &e[lsv], n, 
		info);
    } else if (iscale == 2) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("G", &c__0, &c__0, &ssfmin, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
	i__1 = lendsv - lsv;
	igraphdlascl_("G", &c__0, &c__0, &ssfmin, &anorm, &i__1, &c__1, &e[lsv], n, 
		info);
    }

/*     Check for no convergence to an eigenvalue after a total   
       of N*MAXIT iterations. */

    if (jtot < nmaxit) {
	goto L10;
    }
    i__1 = *n - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if (e[i__] != 0.) {
	    ++(*info);
	}
/* L150: */
    }
    goto L190;

/*     Order eigenvalues and eigenvectors. */

L160:
    if (icompz == 0) {

/*        Use Quick Sort */

	igraphdlasrt_("I", n, &d__[1], info);

    } else {

/*        Use Selection Sort to minimize swaps of eigenvectors */

	i__1 = *n;
	for (ii = 2; ii <= i__1; ++ii) {
	    i__ = ii - 1;
	    k = i__;
	    p = d__[i__];
	    i__2 = *n;
	    for (j = ii; j <= i__2; ++j) {
		if (d__[j] < p) {
		    k = j;
		    p = d__[j];
		}
/* L170: */
	    }
	    if (k != i__) {
		d__[k] = d__[i__];
		d__[i__] = p;
		igraphdswap_(n, &z__[i__ * z_dim1 + 1], &c__1, &z__[k * z_dim1 + 1],
			 &c__1);
	    }
/* L180: */
	}
    }

L190:
    return 0;

/*     End of DSTEQR */

} /* igraphdsteqr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsterf.c0000644000175100001710000002610000000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__0 = 0;
static integer c__1 = 1;
static doublereal c_b33 = 1.;

/* > \brief \b DSTERF   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSTERF + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSTERF( N, D, E, INFO )   

         INTEGER            INFO, N   
         DOUBLE PRECISION   D( * ), E( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSTERF computes all eigenvalues of a symmetric tridiagonal matrix   
   > using the Pal-Walker-Kahan variant of the QL or QR algorithm.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          On entry, the n diagonal elements of the tridiagonal matrix.   
   >          On exit, if INFO = 0, the eigenvalues in ascending order.   
   > \endverbatim   
   >   
   > \param[in,out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          On entry, the (n-1) subdiagonal elements of the tridiagonal   
   >          matrix.   
   >          On exit, E has been destroyed.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  the algorithm failed to find all of the eigenvalues in   
   >                a total of 30*N iterations; if INFO = i, then i   
   >                elements of E have not converged to zero.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdsterf_(integer *n, doublereal *d__, doublereal *e, 
	integer *info)
{
    /* System generated locals */
    integer i__1;
    doublereal d__1, d__2, d__3;

    /* Builtin functions */
    double sqrt(doublereal), d_sign(doublereal *, doublereal *);

    /* Local variables */
    doublereal c__;
    integer i__, l, m;
    doublereal p, r__, s;
    integer l1;
    doublereal bb, rt1, rt2, eps, rte;
    integer lsv;
    doublereal eps2, oldc;
    integer lend;
    doublereal rmax;
    integer jtot;
    extern /* Subroutine */ int igraphdlae2_(doublereal *, doublereal *, doublereal 
	    *, doublereal *, doublereal *);
    doublereal gamma, alpha, sigma, anorm;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
    integer iscale;
    extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *);
    doublereal oldgam, safmin;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal safmax;
    extern doublereal igraphdlanst_(char *, integer *, doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlasrt_(char *, integer *, doublereal *, 
	    integer *);
    integer lendsv;
    doublereal ssfmin;
    integer nmaxit;
    doublereal ssfmax;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --e;
    --d__;

    /* Function Body */
    *info = 0;

/*     Quick return if possible */

    if (*n < 0) {
	*info = -1;
	i__1 = -(*info);
	igraphxerbla_("DSTERF", &i__1, (ftnlen)6);
	return 0;
    }
    if (*n <= 1) {
	return 0;
    }

/*     Determine the unit roundoff for this environment. */

    eps = igraphdlamch_("E");
/* Computing 2nd power */
    d__1 = eps;
    eps2 = d__1 * d__1;
    safmin = igraphdlamch_("S");
    safmax = 1. / safmin;
    ssfmax = sqrt(safmax) / 3.;
    ssfmin = sqrt(safmin) / eps2;
    rmax = igraphdlamch_("O");

/*     Compute the eigenvalues of the tridiagonal matrix. */

    nmaxit = *n * 30;
    sigma = 0.;
    jtot = 0;

/*     Determine where the matrix splits and choose QL or QR iteration   
       for each block, according to whether top or bottom diagonal   
       element is smaller. */

    l1 = 1;

L10:
    if (l1 > *n) {
	goto L170;
    }
    if (l1 > 1) {
	e[l1 - 1] = 0.;
    }
    i__1 = *n - 1;
    for (m = l1; m <= i__1; ++m) {
	if ((d__3 = e[m], abs(d__3)) <= sqrt((d__1 = d__[m], abs(d__1))) * 
		sqrt((d__2 = d__[m + 1], abs(d__2))) * eps) {
	    e[m] = 0.;
	    goto L30;
	}
/* L20: */
    }
    m = *n;

L30:
    l = l1;
    lsv = l;
    lend = m;
    lendsv = lend;
    l1 = m + 1;
    if (lend == l) {
	goto L10;
    }

/*     Scale submatrix in rows and columns L to LEND */

    i__1 = lend - l + 1;
    anorm = igraphdlanst_("M", &i__1, &d__[l], &e[l]);
    iscale = 0;
    if (anorm == 0.) {
	goto L10;
    }
    if (anorm > ssfmax) {
	iscale = 1;
	i__1 = lend - l + 1;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &e[l], n, 
		info);
    } else if (anorm < ssfmin) {
	iscale = 2;
	i__1 = lend - l + 1;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("G", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &e[l], n, 
		info);
    }

    i__1 = lend - 1;
    for (i__ = l; i__ <= i__1; ++i__) {
/* Computing 2nd power */
	d__1 = e[i__];
	e[i__] = d__1 * d__1;
/* L40: */
    }

/*     Choose between QL and QR iteration */

    if ((d__1 = d__[lend], abs(d__1)) < (d__2 = d__[l], abs(d__2))) {
	lend = lsv;
	l = lendsv;
    }

    if (lend >= l) {

/*        QL Iteration   

          Look for small subdiagonal element. */

L50:
	if (l != lend) {
	    i__1 = lend - 1;
	    for (m = l; m <= i__1; ++m) {
		if ((d__2 = e[m], abs(d__2)) <= eps2 * (d__1 = d__[m] * d__[m 
			+ 1], abs(d__1))) {
		    goto L70;
		}
/* L60: */
	    }
	}
	m = lend;

L70:
	if (m < lend) {
	    e[m] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L90;
	}

/*        If remaining matrix is 2 by 2, use DLAE2 to compute its   
          eigenvalues. */

	if (m == l + 1) {
	    rte = sqrt(e[l]);
	    igraphdlae2_(&d__[l], &rte, &d__[l + 1], &rt1, &rt2);
	    d__[l] = rt1;
	    d__[l + 1] = rt2;
	    e[l] = 0.;
	    l += 2;
	    if (l <= lend) {
		goto L50;
	    }
	    goto L150;
	}

	if (jtot == nmaxit) {
	    goto L150;
	}
	++jtot;

/*        Form shift. */

	rte = sqrt(e[l]);
	sigma = (d__[l + 1] - p) / (rte * 2.);
	r__ = igraphdlapy2_(&sigma, &c_b33);
	sigma = p - rte / (sigma + d_sign(&r__, &sigma));

	c__ = 1.;
	s = 0.;
	gamma = d__[m] - sigma;
	p = gamma * gamma;

/*        Inner loop */

	i__1 = l;
	for (i__ = m - 1; i__ >= i__1; --i__) {
	    bb = e[i__];
	    r__ = p + bb;
	    if (i__ != m - 1) {
		e[i__ + 1] = s * r__;
	    }
	    oldc = c__;
	    c__ = p / r__;
	    s = bb / r__;
	    oldgam = gamma;
	    alpha = d__[i__];
	    gamma = c__ * (alpha - sigma) - s * oldgam;
	    d__[i__ + 1] = oldgam + (alpha - gamma);
	    if (c__ != 0.) {
		p = gamma * gamma / c__;
	    } else {
		p = oldc * bb;
	    }
/* L80: */
	}

	e[l] = s * p;
	d__[l] = sigma + gamma;
	goto L50;

/*        Eigenvalue found. */

L90:
	d__[l] = p;

	++l;
	if (l <= lend) {
	    goto L50;
	}
	goto L150;

    } else {

/*        QR Iteration   

          Look for small superdiagonal element. */

L100:
	i__1 = lend + 1;
	for (m = l; m >= i__1; --m) {
	    if ((d__2 = e[m - 1], abs(d__2)) <= eps2 * (d__1 = d__[m] * d__[m 
		    - 1], abs(d__1))) {
		goto L120;
	    }
/* L110: */
	}
	m = lend;

L120:
	if (m > lend) {
	    e[m - 1] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L140;
	}

/*        If remaining matrix is 2 by 2, use DLAE2 to compute its   
          eigenvalues. */

	if (m == l - 1) {
	    rte = sqrt(e[l - 1]);
	    igraphdlae2_(&d__[l], &rte, &d__[l - 1], &rt1, &rt2);
	    d__[l] = rt1;
	    d__[l - 1] = rt2;
	    e[l - 1] = 0.;
	    l += -2;
	    if (l >= lend) {
		goto L100;
	    }
	    goto L150;
	}

	if (jtot == nmaxit) {
	    goto L150;
	}
	++jtot;

/*        Form shift. */

	rte = sqrt(e[l - 1]);
	sigma = (d__[l - 1] - p) / (rte * 2.);
	r__ = igraphdlapy2_(&sigma, &c_b33);
	sigma = p - rte / (sigma + d_sign(&r__, &sigma));

	c__ = 1.;
	s = 0.;
	gamma = d__[m] - sigma;
	p = gamma * gamma;

/*        Inner loop */

	i__1 = l - 1;
	for (i__ = m; i__ <= i__1; ++i__) {
	    bb = e[i__];
	    r__ = p + bb;
	    if (i__ != m) {
		e[i__ - 1] = s * r__;
	    }
	    oldc = c__;
	    c__ = p / r__;
	    s = bb / r__;
	    oldgam = gamma;
	    alpha = d__[i__ + 1];
	    gamma = c__ * (alpha - sigma) - s * oldgam;
	    d__[i__] = oldgam + (alpha - gamma);
	    if (c__ != 0.) {
		p = gamma * gamma / c__;
	    } else {
		p = oldc * bb;
	    }
/* L130: */
	}

	e[l - 1] = s * p;
	d__[l] = sigma + gamma;
	goto L100;

/*        Eigenvalue found. */

L140:
	d__[l] = p;

	--l;
	if (l >= lend) {
	    goto L100;
	}
	goto L150;

    }

/*     Undo scaling if necessary */

L150:
    if (iscale == 1) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("G", &c__0, &c__0, &ssfmax, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
    }
    if (iscale == 2) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("G", &c__0, &c__0, &ssfmin, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
    }

/*     Check for no convergence to an eigenvalue after a total   
       of N*MAXIT iterations. */

    if (jtot < nmaxit) {
	goto L10;
    }
    i__1 = *n - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if (e[i__] != 0.) {
	    ++(*info);
	}
/* L160: */
    }
    goto L180;

/*     Sort eigenvalues in increasing order. */

L170:
    igraphdlasrt_("I", n, &d__[1], info);

L180:
    return 0;

/*     End of DSTERF */

} /* igraphdsterf_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dstqrb.c0000644000175100001710000004211500000000000024050 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__0 = 0;
static integer c__1 = 1;
static doublereal c_b31 = 1.;

/* -----------------------------------------------------------------------   
   \BeginDoc   

   \Name: dstqrb   

   \Description:   
    Computes all eigenvalues and the last component of the eigenvectors   
    of a symmetric tridiagonal matrix using the implicit QL or QR method.   

    This is mostly a modification of the LAPACK routine dsteqr.   
    See Remarks.   

   \Usage:   
    call dstqrb   
       ( N, D, E, Z, WORK, INFO )   

   \Arguments   
    N       Integer.  (INPUT)   
            The number of rows and columns in the matrix.  N >= 0.   

    D       Double precision array, dimension (N).  (INPUT/OUTPUT)   
            On entry, D contains the diagonal elements of the   
            tridiagonal matrix.   
            On exit, D contains the eigenvalues, in ascending order.   
            If an error exit is made, the eigenvalues are correct   
            for indices 1,2,...,INFO-1, but they are unordered and   
            may not be the smallest eigenvalues of the matrix.   

    E       Double precision array, dimension (N-1).  (INPUT/OUTPUT)   
            On entry, E contains the subdiagonal elements of the   
            tridiagonal matrix in positions 1 through N-1.   
            On exit, E has been destroyed.   

    Z       Double precision array, dimension (N).  (OUTPUT)   
            On exit, Z contains the last row of the orthonormal   
            eigenvector matrix of the symmetric tridiagonal matrix.   
            If an error exit is made, Z contains the last row of the   
            eigenvector matrix associated with the stored eigenvalues.   

    WORK    Double precision array, dimension (max(1,2*N-2)).  (WORKSPACE)   
            Workspace used in accumulating the transformation for   
            computing the last components of the eigenvectors.   

    INFO    Integer.  (OUTPUT)   
            = 0:  normal return.   
            < 0:  if INFO = -i, the i-th argument had an illegal value.   
            > 0:  if INFO = +i, the i-th eigenvalue has not converged   
                                after a total of  30*N  iterations.   

   \Remarks   
    1. None.   

   -----------------------------------------------------------------------   

   \BeginLib   

   \Local variables:   
       xxxxxx  real   

   \Routines called:   
       daxpy   Level 1 BLAS that computes a vector triad.   
       dcopy   Level 1 BLAS that copies one vector to another.   
       dswap   Level 1 BLAS that swaps the contents of two vectors.   
       lsame   LAPACK character comparison routine.   
       dlae2   LAPACK routine that computes the eigenvalues of a 2-by-2   
               symmetric matrix.   
       dlaev2  LAPACK routine that eigendecomposition of a 2-by-2 symmetric   
               matrix.   
       dlamch  LAPACK routine that determines machine constants.   
       dlanst  LAPACK routine that computes the norm of a matrix.   
       dlapy2  LAPACK routine to compute sqrt(x**2+y**2) carefully.   
       dlartg  LAPACK Givens rotation construction routine.   
       dlascl  LAPACK routine for careful scaling of a matrix.   
       dlaset  LAPACK matrix initialization routine.   
       dlasr   LAPACK routine that applies an orthogonal transformation to   
               a matrix.   
       dlasrt  LAPACK sorting routine.   
       dsteqr  LAPACK routine that computes eigenvalues and eigenvectors   
               of a symmetric tridiagonal matrix.   
       xerbla  LAPACK error handler routine.   

   \Authors   
       Danny Sorensen               Phuong Vu   
       Richard Lehoucq              CRPC / Rice University   
       Dept. of Computational &     Houston, Texas   
       Applied Mathematics   
       Rice University   
       Houston, Texas   

   \SCCS Information: @(#)   
   FILE: stqrb.F   SID: 2.5   DATE OF SID: 8/27/96   RELEASE: 2   

   \Remarks   
       1. Starting with version 2.5, this routine is a modified version   
          of LAPACK version 2.0 subroutine SSTEQR. No lines are deleted,   
          only commeted out and new lines inserted.   
          All lines commented out have "c$$$" at the beginning.   
          Note that the LAPACK version 1.0 subroutine SSTEQR contained   
          bugs.   

   \EndLib   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdstqrb_(integer *n, doublereal *d__, doublereal *e, 
	doublereal *z__, doublereal *work, integer *info)
{
    /* System generated locals */
    integer i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal), d_sign(doublereal *, doublereal *);

    /* Local variables */
    doublereal b, c__, f, g;
    integer i__, j, k, l, m;
    doublereal p, r__, s;
    integer l1, ii, mm, lm1, mm1, nm1;
    doublereal rt1, rt2, eps;
    integer lsv;
    doublereal tst, eps2;
    integer lend, jtot;
    extern /* Subroutine */ int igraphdlae2_(doublereal *, doublereal *, doublereal 
	    *, doublereal *, doublereal *), igraphdlasr_(char *, char *, char *, 
	    integer *, integer *, doublereal *, doublereal *, doublereal *, 
	    integer *);
    doublereal anorm;
    extern /* Subroutine */ int igraphdlaev2_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *, doublereal *, 
	    doublereal *);
    integer lendm1, lendp1;
    extern doublereal igraphdlapy2_(doublereal *, doublereal *), igraphdlamch_(char *);
    integer iscale;
    extern /* Subroutine */ int igraphdlascl_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, integer *);
    doublereal safmin;
    extern /* Subroutine */ int igraphdlartg_(doublereal *, doublereal *, 
	    doublereal *, doublereal *, doublereal *);
    doublereal safmax;
    extern doublereal igraphdlanst_(char *, integer *, doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlasrt_(char *, integer *, doublereal *, 
	    integer *);
    integer lendsv, nmaxit, icompz;
    doublereal ssfmax, ssfmin;


/*     %------------------%   
       | Scalar Arguments |   
       %------------------%   


       %-----------------%   
       | Array Arguments |   
       %-----------------%   



       test the input parameters.   

       Parameter adjustments */
    --work;
    --z__;
    --e;
    --d__;

    /* Function Body */
    *info = 0;

/* $$$      IF( LSAME( COMPZ, 'N' ) ) THEN   
   $$$         ICOMPZ = 0   
   $$$      ELSE IF( LSAME( COMPZ, 'V' ) ) THEN   
   $$$         ICOMPZ = 1   
   $$$      ELSE IF( LSAME( COMPZ, 'I' ) ) THEN   
   $$$         ICOMPZ = 2   
   $$$      ELSE   
   $$$         ICOMPZ = -1   
   $$$      END IF   
   $$$      IF( ICOMPZ.LT.0 ) THEN   
   $$$         INFO = -1   
   $$$      ELSE IF( N.LT.0 ) THEN   
   $$$         INFO = -2   
   $$$      ELSE IF( ( LDZ.LT.1 ) .OR. ( ICOMPZ.GT.0 .AND. LDZ.LT.MAX( 1,   
   $$$     $         N ) ) ) THEN   
   $$$         INFO = -6   
   $$$      END IF   
   $$$      IF( INFO.NE.0 ) THEN   
   $$$         CALL XERBLA( 'SSTEQR', -INFO )   
   $$$         RETURN   
   $$$      END IF   

      *** New starting with version 2.5 *** */

    icompz = 2;
/*    *************************************   

       quick return if possible */

    if (*n == 0) {
	return 0;
    }

    if (*n == 1) {
	if (icompz == 2) {
	    z__[1] = 1.;
	}
	return 0;
    }

/*     determine the unit roundoff and over/underflow thresholds. */

    eps = igraphdlamch_("e");
/* Computing 2nd power */
    d__1 = eps;
    eps2 = d__1 * d__1;
    safmin = igraphdlamch_("s");
    safmax = 1. / safmin;
    ssfmax = sqrt(safmax) / 3.;
    ssfmin = sqrt(safmin) / eps2;

/*     compute the eigenvalues and eigenvectors of the tridiagonal   
       matrix.   

   $$      if( icompz.eq.2 )   
   $$$     $   call dlaset( 'full', n, n, zero, one, z, ldz )   

       *** New starting with version 2.5 *** */

    if (icompz == 2) {
	i__1 = *n - 1;
	for (j = 1; j <= i__1; ++j) {
	    z__[j] = 0.;
/* L5: */
	}
	z__[*n] = 1.;
    }
/*     ************************************* */

    nmaxit = *n * 30;
    jtot = 0;

/*     determine where the matrix splits and choose ql or qr iteration   
       for each block, according to whether top or bottom diagonal   
       element is smaller. */

    l1 = 1;
    nm1 = *n - 1;

L10:
    if (l1 > *n) {
	goto L160;
    }
    if (l1 > 1) {
	e[l1 - 1] = 0.;
    }
    if (l1 <= nm1) {
	i__1 = nm1;
	for (m = l1; m <= i__1; ++m) {
	    tst = (d__1 = e[m], abs(d__1));
	    if (tst == 0.) {
		goto L30;
	    }
	    if (tst <= sqrt((d__1 = d__[m], abs(d__1))) * sqrt((d__2 = d__[m 
		    + 1], abs(d__2))) * eps) {
		e[m] = 0.;
		goto L30;
	    }
/* L20: */
	}
    }
    m = *n;

L30:
    l = l1;
    lsv = l;
    lend = m;
    lendsv = lend;
    l1 = m + 1;
    if (lend == l) {
	goto L10;
    }

/*     scale submatrix in rows and columns l to lend */

    i__1 = lend - l + 1;
    anorm = igraphdlanst_("i", &i__1, &d__[l], &e[l]);
    iscale = 0;
    if (anorm == 0.) {
	goto L10;
    }
    if (anorm > ssfmax) {
	iscale = 1;
	i__1 = lend - l + 1;
	igraphdlascl_("g", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("g", &c__0, &c__0, &anorm, &ssfmax, &i__1, &c__1, &e[l], n, 
		info);
    } else if (anorm < ssfmin) {
	iscale = 2;
	i__1 = lend - l + 1;
	igraphdlascl_("g", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &d__[l], n, 
		info);
	i__1 = lend - l;
	igraphdlascl_("g", &c__0, &c__0, &anorm, &ssfmin, &i__1, &c__1, &e[l], n, 
		info);
    }

/*     choose between ql and qr iteration */

    if ((d__1 = d__[lend], abs(d__1)) < (d__2 = d__[l], abs(d__2))) {
	lend = lsv;
	l = lendsv;
    }

    if (lend > l) {

/*        ql iteration   

          look for small subdiagonal element. */

L40:
	if (l != lend) {
	    lendm1 = lend - 1;
	    i__1 = lendm1;
	    for (m = l; m <= i__1; ++m) {
/* Computing 2nd power */
		d__2 = (d__1 = e[m], abs(d__1));
		tst = d__2 * d__2;
		if (tst <= eps2 * (d__1 = d__[m], abs(d__1)) * (d__2 = d__[m 
			+ 1], abs(d__2)) + safmin) {
		    goto L60;
		}
/* L50: */
	    }
	}

	m = lend;

L60:
	if (m < lend) {
	    e[m] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L80;
	}

/*        if remaining matrix is 2-by-2, use dlae2 or dlaev2   
          to compute its eigensystem. */

	if (m == l + 1) {
	    if (icompz > 0) {
		igraphdlaev2_(&d__[l], &e[l], &d__[l + 1], &rt1, &rt2, &c__, &s);
		work[l] = c__;
		work[*n - 1 + l] = s;
/* $$$               call dlasr( 'r', 'v', 'b', n, 2, work( l ),   
   $$$     $                     work( n-1+l ), z( 1, l ), ldz )   

                *** New starting with version 2.5 *** */

		tst = z__[l + 1];
		z__[l + 1] = c__ * tst - s * z__[l];
		z__[l] = s * tst + c__ * z__[l];
/*              ************************************* */
	    } else {
		igraphdlae2_(&d__[l], &e[l], &d__[l + 1], &rt1, &rt2);
	    }
	    d__[l] = rt1;
	    d__[l + 1] = rt2;
	    e[l] = 0.;
	    l += 2;
	    if (l <= lend) {
		goto L40;
	    }
	    goto L140;
	}

	if (jtot == nmaxit) {
	    goto L140;
	}
	++jtot;

/*        form shift. */

	g = (d__[l + 1] - p) / (e[l] * 2.);
	r__ = igraphdlapy2_(&g, &c_b31);
	g = d__[m] - p + e[l] / (g + d_sign(&r__, &g));

	s = 1.;
	c__ = 1.;
	p = 0.;

/*        inner loop */

	mm1 = m - 1;
	i__1 = l;
	for (i__ = mm1; i__ >= i__1; --i__) {
	    f = s * e[i__];
	    b = c__ * e[i__];
	    igraphdlartg_(&g, &f, &c__, &s, &r__);
	    if (i__ != m - 1) {
		e[i__ + 1] = r__;
	    }
	    g = d__[i__ + 1] - p;
	    r__ = (d__[i__] - g) * s + c__ * 2. * b;
	    p = s * r__;
	    d__[i__ + 1] = g + p;
	    g = c__ * r__ - b;

/*           if eigenvectors are desired, then save rotations. */

	    if (icompz > 0) {
		work[i__] = c__;
		work[*n - 1 + i__] = -s;
	    }

/* L70: */
	}

/*        if eigenvectors are desired, then apply saved rotations. */

	if (icompz > 0) {
	    mm = m - l + 1;
/* $$$            call dlasr( 'r', 'v', 'b', n, mm, work( l ), work( n-1+l ),   
   $$$     $                  z( 1, l ), ldz )   

               *** New starting with version 2.5 *** */

	    igraphdlasr_("r", "v", "b", &c__1, &mm, &work[l], &work[*n - 1 + l], &
		    z__[l], &c__1);
/*             ************************************* */
	}

	d__[l] -= p;
	e[l] = g;
	goto L40;

/*        eigenvalue found. */

L80:
	d__[l] = p;

	++l;
	if (l <= lend) {
	    goto L40;
	}
	goto L140;

    } else {

/*        qr iteration   

          look for small superdiagonal element. */

L90:
	if (l != lend) {
	    lendp1 = lend + 1;
	    i__1 = lendp1;
	    for (m = l; m >= i__1; --m) {
/* Computing 2nd power */
		d__2 = (d__1 = e[m - 1], abs(d__1));
		tst = d__2 * d__2;
		if (tst <= eps2 * (d__1 = d__[m], abs(d__1)) * (d__2 = d__[m 
			- 1], abs(d__2)) + safmin) {
		    goto L110;
		}
/* L100: */
	    }
	}

	m = lend;

L110:
	if (m > lend) {
	    e[m - 1] = 0.;
	}
	p = d__[l];
	if (m == l) {
	    goto L130;
	}

/*        if remaining matrix is 2-by-2, use dlae2 or dlaev2   
          to compute its eigensystem. */

	if (m == l - 1) {
	    if (icompz > 0) {
		igraphdlaev2_(&d__[l - 1], &e[l - 1], &d__[l], &rt1, &rt2, &c__, &s)
			;
/* $$$               work( m ) = c   
   $$$               work( n-1+m ) = s   
   $$$               call dlasr( 'r', 'v', 'f', n, 2, work( m ),   
   $$$     $                     work( n-1+m ), z( 1, l-1 ), ldz )   

                 *** New starting with version 2.5 *** */

		tst = z__[l];
		z__[l] = c__ * tst - s * z__[l - 1];
		z__[l - 1] = s * tst + c__ * z__[l - 1];
/*               ************************************* */
	    } else {
		igraphdlae2_(&d__[l - 1], &e[l - 1], &d__[l], &rt1, &rt2);
	    }
	    d__[l - 1] = rt1;
	    d__[l] = rt2;
	    e[l - 1] = 0.;
	    l += -2;
	    if (l >= lend) {
		goto L90;
	    }
	    goto L140;
	}

	if (jtot == nmaxit) {
	    goto L140;
	}
	++jtot;

/*        form shift. */

	g = (d__[l - 1] - p) / (e[l - 1] * 2.);
	r__ = igraphdlapy2_(&g, &c_b31);
	g = d__[m] - p + e[l - 1] / (g + d_sign(&r__, &g));

	s = 1.;
	c__ = 1.;
	p = 0.;

/*        inner loop */

	lm1 = l - 1;
	i__1 = lm1;
	for (i__ = m; i__ <= i__1; ++i__) {
	    f = s * e[i__];
	    b = c__ * e[i__];
	    igraphdlartg_(&g, &f, &c__, &s, &r__);
	    if (i__ != m) {
		e[i__ - 1] = r__;
	    }
	    g = d__[i__] - p;
	    r__ = (d__[i__ + 1] - g) * s + c__ * 2. * b;
	    p = s * r__;
	    d__[i__] = g + p;
	    g = c__ * r__ - b;

/*           if eigenvectors are desired, then save rotations. */

	    if (icompz > 0) {
		work[i__] = c__;
		work[*n - 1 + i__] = s;
	    }

/* L120: */
	}

/*        if eigenvectors are desired, then apply saved rotations. */

	if (icompz > 0) {
	    mm = l - m + 1;
/* $$$            call dlasr( 'r', 'v', 'f', n, mm, work( m ), work( n-1+m ),   
   $$$     $                  z( 1, m ), ldz )   

             *** New starting with version 2.5 *** */

	    igraphdlasr_("r", "v", "f", &c__1, &mm, &work[m], &work[*n - 1 + m], &
		    z__[m], &c__1);
/*           ************************************* */
	}

	d__[l] -= p;
	e[lm1] = g;
	goto L90;

/*        eigenvalue found. */

L130:
	d__[l] = p;

	--l;
	if (l >= lend) {
	    goto L90;
	}
	goto L140;

    }

/*     undo scaling if necessary */

L140:
    if (iscale == 1) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("g", &c__0, &c__0, &ssfmax, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
	i__1 = lendsv - lsv;
	igraphdlascl_("g", &c__0, &c__0, &ssfmax, &anorm, &i__1, &c__1, &e[lsv], n, 
		info);
    } else if (iscale == 2) {
	i__1 = lendsv - lsv + 1;
	igraphdlascl_("g", &c__0, &c__0, &ssfmin, &anorm, &i__1, &c__1, &d__[lsv], 
		n, info);
	i__1 = lendsv - lsv;
	igraphdlascl_("g", &c__0, &c__0, &ssfmin, &anorm, &i__1, &c__1, &e[lsv], n, 
		info);
    }

/*     check for no convergence to an eigenvalue after a total   
       of n*maxit iterations. */

    if (jtot < nmaxit) {
	goto L10;
    }
    i__1 = *n - 1;
    for (i__ = 1; i__ <= i__1; ++i__) {
	if (e[i__] != 0.) {
	    ++(*info);
	}
/* L150: */
    }
    goto L190;

/*     order eigenvalues and eigenvectors. */

L160:
    if (icompz == 0) {

/*        use quick sort */

	igraphdlasrt_("i", n, &d__[1], info);

    } else {

/*        use selection sort to minimize swaps of eigenvectors */

	i__1 = *n;
	for (ii = 2; ii <= i__1; ++ii) {
	    i__ = ii - 1;
	    k = i__;
	    p = d__[i__];
	    i__2 = *n;
	    for (j = ii; j <= i__2; ++j) {
		if (d__[j] < p) {
		    k = j;
		    p = d__[j];
		}
/* L170: */
	    }
	    if (k != i__) {
		d__[k] = d__[i__];
		d__[i__] = p;
/* $$$               call dswap( n, z( 1, i ), 1, z( 1, k ), 1 )   
             *** New starting with version 2.5 *** */

		p = z__[k];
		z__[k] = z__[i__];
		z__[i__] = p;
/*           ************************************* */
	    }
/* L180: */
	}
    }

L190:
    return 0;

/*     %---------------%   
       | End of dstqrb |   
       %---------------% */

} /* igraphdstqrb_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dswap.c0000644000175100001710000001003500000000000023663 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSWAP   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSWAP(N,DX,INCX,DY,INCY)   

         INTEGER INCX,INCY,N   
         DOUBLE PRECISION DX(*),DY(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    DSWAP interchanges two vectors.   
   >    uses unrolled loops for increments equal to 1.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in,out] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of DX   
   > \endverbatim   
   >   
   > \param[in,out] DY   
   > \verbatim   
   >          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >         storage spacing between elements of DY   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup double_blas_level1   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdswap_(integer *n, doublereal *dx, integer *incx, 
	doublereal *dy, integer *incy)
{
    /* System generated locals */
    integer i__1;

    /* Local variables */
    integer i__, m, ix, iy, mp1;
    doublereal dtemp;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dy;
    --dx;

    /* Function Body */
    if (*n <= 0) {
	return 0;
    }
    if (*incx == 1 && *incy == 1) {

/*       code for both increments equal to 1   


         clean-up loop */

	m = *n % 3;
	if (m != 0) {
	    i__1 = m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		dtemp = dx[i__];
		dx[i__] = dy[i__];
		dy[i__] = dtemp;
	    }
	    if (*n < 3) {
		return 0;
	    }
	}
	mp1 = m + 1;
	i__1 = *n;
	for (i__ = mp1; i__ <= i__1; i__ += 3) {
	    dtemp = dx[i__];
	    dx[i__] = dy[i__];
	    dy[i__] = dtemp;
	    dtemp = dx[i__ + 1];
	    dx[i__ + 1] = dy[i__ + 1];
	    dy[i__ + 1] = dtemp;
	    dtemp = dx[i__ + 2];
	    dx[i__ + 2] = dy[i__ + 2];
	    dy[i__ + 2] = dtemp;
	}
    } else {

/*       code for unequal increments or equal increments not equal   
           to 1 */

	ix = 1;
	iy = 1;
	if (*incx < 0) {
	    ix = (-(*n) + 1) * *incx + 1;
	}
	if (*incy < 0) {
	    iy = (-(*n) + 1) * *incy + 1;
	}
	i__1 = *n;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    dtemp = dx[ix];
	    dx[ix] = dy[iy];
	    dy[iy] = dtemp;
	    ix += *incx;
	    iy += *incy;
	}
    }
    return 0;
} /* igraphdswap_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsyevr.c0000644000175100001710000006416500000000000024076 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__10 = 10;
static integer c__1 = 1;
static integer c__2 = 2;
static integer c__3 = 3;
static integer c__4 = 4;
static integer c_n1 = -1;

/* > \brief  DSYEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY mat
rices   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSYEVR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSYEVR( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU,   
                            ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK,   
                            IWORK, LIWORK, INFO )   

         CHARACTER          JOBZ, RANGE, UPLO   
         INTEGER            IL, INFO, IU, LDA, LDZ, LIWORK, LWORK, M, N   
         DOUBLE PRECISION   ABSTOL, VL, VU   
         INTEGER            ISUPPZ( * ), IWORK( * )   
         DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * ), Z( LDZ, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYEVR computes selected eigenvalues and, optionally, eigenvectors   
   > of a real symmetric matrix A.  Eigenvalues and eigenvectors can be   
   > selected by specifying either a range of values or a range of   
   > indices for the desired eigenvalues.   
   >   
   > DSYEVR first reduces the matrix A to tridiagonal form T with a call   
   > to DSYTRD.  Then, whenever possible, DSYEVR calls DSTEMR to compute   
   > the eigenspectrum using Relatively Robust Representations.  DSTEMR   
   > computes eigenvalues by the dqds algorithm, while orthogonal   
   > eigenvectors are computed from various "good" L D L^T representations   
   > (also known as Relatively Robust Representations). Gram-Schmidt   
   > orthogonalization is avoided as far as possible. More specifically,   
   > the various steps of the algorithm are as follows.   
   >   
   > For each unreduced block (submatrix) of T,   
   >    (a) Compute T - sigma I  = L D L^T, so that L and D   
   >        define all the wanted eigenvalues to high relative accuracy.   
   >        This means that small relative changes in the entries of D and L   
   >        cause only small relative changes in the eigenvalues and   
   >        eigenvectors. The standard (unfactored) representation of the   
   >        tridiagonal matrix T does not have this property in general.   
   >    (b) Compute the eigenvalues to suitable accuracy.   
   >        If the eigenvectors are desired, the algorithm attains full   
   >        accuracy of the computed eigenvalues only right before   
   >        the corresponding vectors have to be computed, see steps c) and d).   
   >    (c) For each cluster of close eigenvalues, select a new   
   >        shift close to the cluster, find a new factorization, and refine   
   >        the shifted eigenvalues to suitable accuracy.   
   >    (d) For each eigenvalue with a large enough relative separation compute   
   >        the corresponding eigenvector by forming a rank revealing twisted   
   >        factorization. Go back to (c) for any clusters that remain.   
   >   
   > The desired accuracy of the output can be specified by the input   
   > parameter ABSTOL.   
   >   
   > For more details, see DSTEMR's documentation and:   
   > - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations   
   >   to compute orthogonal eigenvectors of symmetric tridiagonal matrices,"   
   >   Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.   
   > - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and   
   >   Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,   
   >   2004.  Also LAPACK Working Note 154.   
   > - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric   
   >   tridiagonal eigenvalue/eigenvector problem",   
   >   Computer Science Division Technical Report No. UCB/CSD-97-971,   
   >   UC Berkeley, May 1997.   
   >   
   >   
   > Note 1 : DSYEVR calls DSTEMR when the full spectrum is requested   
   > on machines which conform to the ieee-754 floating point standard.   
   > DSYEVR calls DSTEBZ and SSTEIN on non-ieee machines and   
   > when partial spectrum requests are made.   
   >   
   > Normal execution of DSTEMR may create NaNs and infinities and   
   > hence may abort due to a floating point exception in environments   
   > which do not handle NaNs and infinities in the ieee standard default   
   > manner.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOBZ   
   > \verbatim   
   >          JOBZ is CHARACTER*1   
   >          = 'N':  Compute eigenvalues only;   
   >          = 'V':  Compute eigenvalues and eigenvectors.   
   > \endverbatim   
   >   
   > \param[in] RANGE   
   > \verbatim   
   >          RANGE is CHARACTER*1   
   >          = 'A': all eigenvalues will be found.   
   >          = 'V': all eigenvalues in the half-open interval (VL,VU]   
   >                 will be found.   
   >          = 'I': the IL-th through IU-th eigenvalues will be found.   
   >          For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and   
   >          DSTEIN are called   
   > \endverbatim   
   >   
   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          = 'U':  Upper triangle of A is stored;   
   >          = 'L':  Lower triangle of A is stored.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA, N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the   
   >          leading N-by-N upper triangular part of A contains the   
   >          upper triangular part of the matrix A.  If UPLO = 'L',   
   >          the leading N-by-N lower triangular part of A contains   
   >          the lower triangular part of the matrix A.   
   >          On exit, the lower triangle (if UPLO='L') or the upper   
   >          triangle (if UPLO='U') of A, including the diagonal, is   
   >          destroyed.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION   
   > \endverbatim   
   >   
   > \param[in] VU   
   > \verbatim   
   >          VU is DOUBLE PRECISION   
   >          If RANGE='V', the lower and upper bounds of the interval to   
   >          be searched for eigenvalues. VL < VU.   
   >          Not referenced if RANGE = 'A' or 'I'.   
   > \endverbatim   
   >   
   > \param[in] IL   
   > \verbatim   
   >          IL is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IU   
   > \verbatim   
   >          IU is INTEGER   
   >          If RANGE='I', the indices (in ascending order) of the   
   >          smallest and largest eigenvalues to be returned.   
   >          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.   
   >          Not referenced if RANGE = 'A' or 'V'.   
   > \endverbatim   
   >   
   > \param[in] ABSTOL   
   > \verbatim   
   >          ABSTOL is DOUBLE PRECISION   
   >          The absolute error tolerance for the eigenvalues.   
   >          An approximate eigenvalue is accepted as converged   
   >          when it is determined to lie in an interval [a,b]   
   >          of width less than or equal to   
   >   
   >                  ABSTOL + EPS *   max( |a|,|b| ) ,   
   >   
   >          where EPS is the machine precision.  If ABSTOL is less than   
   >          or equal to zero, then  EPS*|T|  will be used in its place,   
   >          where |T| is the 1-norm of the tridiagonal matrix obtained   
   >          by reducing A to tridiagonal form.   
   >   
   >          See "Computing Small Singular Values of Bidiagonal Matrices   
   >          with Guaranteed High Relative Accuracy," by Demmel and   
   >          Kahan, LAPACK Working Note #3.   
   >   
   >          If high relative accuracy is important, set ABSTOL to   
   >          DLAMCH( 'Safe minimum' ).  Doing so will guarantee that   
   >          eigenvalues are computed to high relative accuracy when   
   >          possible in future releases.  The current code does not   
   >          make any guarantees about high relative accuracy, but   
   >          future releases will. See J. Barlow and J. Demmel,   
   >          "Computing Accurate Eigensystems of Scaled Diagonally   
   >          Dominant Matrices", LAPACK Working Note #7, for a discussion   
   >          of which matrices define their eigenvalues to high relative   
   >          accuracy.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The total number of eigenvalues found.  0 <= M <= N.   
   >          If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.   
   > \endverbatim   
   >   
   > \param[out] W   
   > \verbatim   
   >          W is DOUBLE PRECISION array, dimension (N)   
   >          The first M elements contain the selected eigenvalues in   
   >          ascending order.   
   > \endverbatim   
   >   
   > \param[out] Z   
   > \verbatim   
   >          Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))   
   >          If JOBZ = 'V', then if INFO = 0, the first M columns of Z   
   >          contain the orthonormal eigenvectors of the matrix A   
   >          corresponding to the selected eigenvalues, with the i-th   
   >          column of Z holding the eigenvector associated with W(i).   
   >          If JOBZ = 'N', then Z is not referenced.   
   >          Note: the user must ensure that at least max(1,M) columns are   
   >          supplied in the array Z; if RANGE = 'V', the exact value of M   
   >          is not known in advance and an upper bound must be used.   
   >          Supplying N columns is always safe.   
   > \endverbatim   
   >   
   > \param[in] LDZ   
   > \verbatim   
   >          LDZ is INTEGER   
   >          The leading dimension of the array Z.  LDZ >= 1, and if   
   >          JOBZ = 'V', LDZ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] ISUPPZ   
   > \verbatim   
   >          ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )   
   >          The support of the eigenvectors in Z, i.e., the indices   
   >          indicating the nonzero elements in Z. The i-th eigenvector   
   >          is nonzero only in elements ISUPPZ( 2*i-1 ) through   
   >          ISUPPZ( 2*i ).   
   >          Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.  LWORK >= max(1,26*N).   
   >          For optimal efficiency, LWORK >= (NB+6)*N,   
   >          where NB is the max of the blocksize for DSYTRD and DORMTR   
   >          returned by ILAENV.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (MAX(1,LIWORK))   
   >          On exit, if INFO = 0, IWORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LIWORK   
   > \verbatim   
   >          LIWORK is INTEGER   
   >          The dimension of the array IWORK.  LIWORK >= max(1,10*N).   
   >   
   >          If LIWORK = -1, then a workspace query is assumed; the   
   >          routine only calculates the optimal size of the IWORK array,   
   >          returns this value as the first entry of the IWORK array, and   
   >          no error message related to LIWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          > 0:  Internal error   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleSYeigen   

   > \par Contributors:   
    ==================   
   >   
   >     Inderjit Dhillon, IBM Almaden, USA \n   
   >     Osni Marques, LBNL/NERSC, USA \n   
   >     Ken Stanley, Computer Science Division, University of   
   >       California at Berkeley, USA \n   
   >     Jason Riedy, Computer Science Division, University of   
   >       California at Berkeley, USA \n   
   >   
    =====================================================================   
   Subroutine */ int igraphdsyevr_(char *jobz, char *range, char *uplo, integer *n, 
	doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *
	il, integer *iu, doublereal *abstol, integer *m, doublereal *w, 
	doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
	integer *lwork, integer *iwork, integer *liwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, z_dim1, z_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, nb, jj;
    doublereal eps, vll, vuu, tmp1;
    integer indd, inde;
    doublereal anrm;
    integer imax;
    doublereal rmin, rmax;
    integer inddd, indee;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    doublereal sigma;
    extern logical igraphlsame_(char *, char *);
    integer iinfo;
    char order[1];
    integer indwk;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *), igraphdswap_(integer *, doublereal *, integer 
	    *, doublereal *, integer *);
    integer lwmin;
    logical lower, wantz;
    extern doublereal igraphdlamch_(char *);
    logical alleig, indeig;
    integer iscale, ieeeok, indibl, indifl;
    logical valeig;
    doublereal safmin;
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal abstll, bignum;
    integer indtau, indisp;
    extern /* Subroutine */ int igraphdstein_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *, integer *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *, integer *), 
	    igraphdsterf_(integer *, doublereal *, doublereal *, integer *);
    integer indiwo, indwkn;
    extern doublereal igraphdlansy_(char *, char *, integer *, doublereal *, 
	    integer *, doublereal *);
    extern /* Subroutine */ int igraphdstebz_(char *, char *, integer *, doublereal 
	    *, doublereal *, integer *, integer *, doublereal *, doublereal *,
	     doublereal *, integer *, integer *, doublereal *, integer *, 
	    integer *, doublereal *, integer *, integer *), 
	    igraphdstemr_(char *, char *, integer *, doublereal *, doublereal *, 
	    doublereal *, doublereal *, integer *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, integer *, integer *, 
	    logical *, doublereal *, integer *, integer *, integer *, integer 
	    *);
    integer liwmin;
    logical tryrac;
    extern /* Subroutine */ int igraphdormtr_(char *, char *, char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *, integer *);
    integer llwrkn, llwork, nsplit;
    doublereal smlnum;
    extern /* Subroutine */ int igraphdsytrd_(char *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
	     integer *, integer *);
    integer lwkopt;
    logical lquery;


/*  -- LAPACK driver routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


   =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --w;
    z_dim1 = *ldz;
    z_offset = 1 + z_dim1;
    z__ -= z_offset;
    --isuppz;
    --work;
    --iwork;

    /* Function Body */
    ieeeok = igraphilaenv_(&c__10, "DSYEVR", "N", &c__1, &c__2, &c__3, &c__4, (
	    ftnlen)6, (ftnlen)1);

    lower = igraphlsame_(uplo, "L");
    wantz = igraphlsame_(jobz, "V");
    alleig = igraphlsame_(range, "A");
    valeig = igraphlsame_(range, "V");
    indeig = igraphlsame_(range, "I");

    lquery = *lwork == -1 || *liwork == -1;

/* Computing MAX */
    i__1 = 1, i__2 = *n * 26;
    lwmin = max(i__1,i__2);
/* Computing MAX */
    i__1 = 1, i__2 = *n * 10;
    liwmin = max(i__1,i__2);

    *info = 0;
    if (! (wantz || igraphlsame_(jobz, "N"))) {
	*info = -1;
    } else if (! (alleig || valeig || indeig)) {
	*info = -2;
    } else if (! (lower || igraphlsame_(uplo, "U"))) {
	*info = -3;
    } else if (*n < 0) {
	*info = -4;
    } else if (*lda < max(1,*n)) {
	*info = -6;
    } else {
	if (valeig) {
	    if (*n > 0 && *vu <= *vl) {
		*info = -8;
	    }
	} else if (indeig) {
	    if (*il < 1 || *il > max(1,*n)) {
		*info = -9;
	    } else if (*iu < min(*n,*il) || *iu > *n) {
		*info = -10;
	    }
	}
    }
    if (*info == 0) {
	if (*ldz < 1 || wantz && *ldz < *n) {
	    *info = -15;
	} else if (*lwork < lwmin && ! lquery) {
	    *info = -18;
	} else if (*liwork < liwmin && ! lquery) {
	    *info = -20;
	}
    }

    if (*info == 0) {
	nb = igraphilaenv_(&c__1, "DSYTRD", uplo, n, &c_n1, &c_n1, &c_n1, (ftnlen)6,
		 (ftnlen)1);
/* Computing MAX */
	i__1 = nb, i__2 = igraphilaenv_(&c__1, "DORMTR", uplo, n, &c_n1, &c_n1, &
		c_n1, (ftnlen)6, (ftnlen)1);
	nb = max(i__1,i__2);
/* Computing MAX */
	i__1 = (nb + 1) * *n;
	lwkopt = max(i__1,lwmin);
	work[1] = (doublereal) lwkopt;
	iwork[1] = liwmin;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSYEVR", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    *m = 0;
    if (*n == 0) {
	work[1] = 1.;
	return 0;
    }

    if (*n == 1) {
	work[1] = 7.;
	if (alleig || indeig) {
	    *m = 1;
	    w[1] = a[a_dim1 + 1];
	} else {
	    if (*vl < a[a_dim1 + 1] && *vu >= a[a_dim1 + 1]) {
		*m = 1;
		w[1] = a[a_dim1 + 1];
	    }
	}
	if (wantz) {
	    z__[z_dim1 + 1] = 1.;
	    isuppz[1] = 1;
	    isuppz[2] = 1;
	}
	return 0;
    }

/*     Get machine constants. */

    safmin = igraphdlamch_("Safe minimum");
    eps = igraphdlamch_("Precision");
    smlnum = safmin / eps;
    bignum = 1. / smlnum;
    rmin = sqrt(smlnum);
/* Computing MIN */
    d__1 = sqrt(bignum), d__2 = 1. / sqrt(sqrt(safmin));
    rmax = min(d__1,d__2);

/*     Scale matrix to allowable range, if necessary. */

    iscale = 0;
    abstll = *abstol;
    if (valeig) {
	vll = *vl;
	vuu = *vu;
    }
    anrm = igraphdlansy_("M", uplo, n, &a[a_offset], lda, &work[1]);
    if (anrm > 0. && anrm < rmin) {
	iscale = 1;
	sigma = rmin / anrm;
    } else if (anrm > rmax) {
	iscale = 1;
	sigma = rmax / anrm;
    }
    if (iscale == 1) {
	if (lower) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *n - j + 1;
		igraphdscal_(&i__2, &sigma, &a[j + j * a_dim1], &c__1);
/* L10: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		igraphdscal_(&j, &sigma, &a[j * a_dim1 + 1], &c__1);
/* L20: */
	    }
	}
	if (*abstol > 0.) {
	    abstll = *abstol * sigma;
	}
	if (valeig) {
	    vll = *vl * sigma;
	    vuu = *vu * sigma;
	}
    }
/*     Initialize indices into workspaces.  Note: The IWORK indices are   
       used only if DSTERF or DSTEMR fail.   
       WORK(INDTAU:INDTAU+N-1) stores the scalar factors of the   
       elementary reflectors used in DSYTRD. */
    indtau = 1;
/*     WORK(INDD:INDD+N-1) stores the tridiagonal's diagonal entries. */
    indd = indtau + *n;
/*     WORK(INDE:INDE+N-1) stores the off-diagonal entries of the   
       tridiagonal matrix from DSYTRD. */
    inde = indd + *n;
/*     WORK(INDDD:INDDD+N-1) is a copy of the diagonal entries over   
       -written by DSTEMR (the DSTERF path copies the diagonal to W). */
    inddd = inde + *n;
/*     WORK(INDEE:INDEE+N-1) is a copy of the off-diagonal entries over   
       -written while computing the eigenvalues in DSTERF and DSTEMR. */
    indee = inddd + *n;
/*     INDWK is the starting offset of the left-over workspace, and   
       LLWORK is the remaining workspace size. */
    indwk = indee + *n;
    llwork = *lwork - indwk + 1;
/*     IWORK(INDIBL:INDIBL+M-1) corresponds to IBLOCK in DSTEBZ and   
       stores the block indices of each of the M<=N eigenvalues. */
    indibl = 1;
/*     IWORK(INDISP:INDISP+NSPLIT-1) corresponds to ISPLIT in DSTEBZ and   
       stores the starting and finishing indices of each block. */
    indisp = indibl + *n;
/*     IWORK(INDIFL:INDIFL+N-1) stores the indices of eigenvectors   
       that corresponding to eigenvectors that fail to converge in   
       DSTEIN.  This information is discarded; if any fail, the driver   
       returns INFO > 0. */
    indifl = indisp + *n;
/*     INDIWO is the offset of the remaining integer workspace. */
    indiwo = indifl + *n;

/*     Call DSYTRD to reduce symmetric matrix to tridiagonal form. */

    igraphdsytrd_(uplo, n, &a[a_offset], lda, &work[indd], &work[inde], &work[
	    indtau], &work[indwk], &llwork, &iinfo);

/*     If all eigenvalues are desired   
       then call DSTERF or DSTEMR and DORMTR. */

    if ((alleig || indeig && *il == 1 && *iu == *n) && ieeeok == 1) {
	if (! wantz) {
	    igraphdcopy_(n, &work[indd], &c__1, &w[1], &c__1);
	    i__1 = *n - 1;
	    igraphdcopy_(&i__1, &work[inde], &c__1, &work[indee], &c__1);
	    igraphdsterf_(n, &w[1], &work[indee], info);
	} else {
	    i__1 = *n - 1;
	    igraphdcopy_(&i__1, &work[inde], &c__1, &work[indee], &c__1);
	    igraphdcopy_(n, &work[indd], &c__1, &work[inddd], &c__1);

	    if (*abstol <= *n * 2. * eps) {
		tryrac = TRUE_;
	    } else {
		tryrac = FALSE_;
	    }
	    igraphdstemr_(jobz, "A", n, &work[inddd], &work[indee], vl, vu, il, iu, 
		    m, &w[1], &z__[z_offset], ldz, n, &isuppz[1], &tryrac, &
		    work[indwk], lwork, &iwork[1], liwork, info);



/*        Apply orthogonal matrix used in reduction to tridiagonal   
          form to eigenvectors returned by DSTEIN. */

	    if (wantz && *info == 0) {
		indwkn = inde;
		llwrkn = *lwork - indwkn + 1;
		igraphdormtr_("L", uplo, "N", n, m, &a[a_offset], lda, &work[indtau]
			, &z__[z_offset], ldz, &work[indwkn], &llwrkn, &iinfo);
	    }
	}


	if (*info == 0) {
/*           Everything worked.  Skip DSTEBZ/DSTEIN.  IWORK(:) are   
             undefined. */
	    *m = *n;
	    goto L30;
	}
	*info = 0;
    }

/*     Otherwise, call DSTEBZ and, if eigenvectors are desired, DSTEIN.   
       Also call DSTEBZ and DSTEIN if DSTEMR fails. */

    if (wantz) {
	*(unsigned char *)order = 'B';
    } else {
	*(unsigned char *)order = 'E';
    }
    igraphdstebz_(range, order, n, &vll, &vuu, il, iu, &abstll, &work[indd], &work[
	    inde], m, &nsplit, &w[1], &iwork[indibl], &iwork[indisp], &work[
	    indwk], &iwork[indiwo], info);

    if (wantz) {
	igraphdstein_(n, &work[indd], &work[inde], m, &w[1], &iwork[indibl], &iwork[
		indisp], &z__[z_offset], ldz, &work[indwk], &iwork[indiwo], &
		iwork[indifl], info);

/*        Apply orthogonal matrix used in reduction to tridiagonal   
          form to eigenvectors returned by DSTEIN. */

	indwkn = inde;
	llwrkn = *lwork - indwkn + 1;
	igraphdormtr_("L", uplo, "N", n, m, &a[a_offset], lda, &work[indtau], &z__[
		z_offset], ldz, &work[indwkn], &llwrkn, &iinfo);
    }

/*     If matrix was scaled, then rescale eigenvalues appropriately.   

    Jump here if DSTEMR/DSTEIN succeeded. */
L30:
    if (iscale == 1) {
	if (*info == 0) {
	    imax = *m;
	} else {
	    imax = *info - 1;
	}
	d__1 = 1. / sigma;
	igraphdscal_(&imax, &d__1, &w[1], &c__1);
    }

/*     If eigenvalues are not in order, then sort them, along with   
       eigenvectors.  Note: We do not sort the IFAIL portion of IWORK.   
       It may not be initialized (if DSTEMR/DSTEIN succeeded), and we do   
       not return this detailed information to the user. */

    if (wantz) {
	i__1 = *m - 1;
	for (j = 1; j <= i__1; ++j) {
	    i__ = 0;
	    tmp1 = w[j];
	    i__2 = *m;
	    for (jj = j + 1; jj <= i__2; ++jj) {
		if (w[jj] < tmp1) {
		    i__ = jj;
		    tmp1 = w[jj];
		}
/* L40: */
	    }

	    if (i__ != 0) {
		w[i__] = w[j];
		w[j] = tmp1;
		igraphdswap_(n, &z__[i__ * z_dim1 + 1], &c__1, &z__[j * z_dim1 + 1],
			 &c__1);
	    }
/* L50: */
	}
    }

/*     Set WORK(1) to optimal workspace size. */

    work[1] = (doublereal) lwkopt;
    iwork[1] = liwmin;

    return 0;

/*     End of DSYEVR */

} /* igraphdsyevr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsymv.c0000644000175100001710000002300200000000000023705 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSYMV   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSYMV(UPLO,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY)   

         DOUBLE PRECISION ALPHA,BETA   
         INTEGER INCX,INCY,LDA,N   
         CHARACTER UPLO   
         DOUBLE PRECISION A(LDA,*),X(*),Y(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYMV  performs the matrix-vector  operation   
   >   
   >    y := alpha*A*x + beta*y,   
   >   
   > where alpha and beta are scalars, x and y are n element vectors and   
   > A is an n by n symmetric matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the upper or lower   
   >           triangular part of the array A is to be referenced as   
   >           follows:   
   >   
   >              UPLO = 'U' or 'u'   Only the upper triangular part of A   
   >                                  is to be referenced.   
   >   
   >              UPLO = 'L' or 'l'   Only the lower triangular part of A   
   >                                  is to be referenced.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the order of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry with  UPLO = 'U' or 'u', the leading n by n   
   >           upper triangular part of the array A must contain the upper   
   >           triangular part of the symmetric matrix and the strictly   
   >           lower triangular part of A is not referenced.   
   >           Before entry with UPLO = 'L' or 'l', the leading n by n   
   >           lower triangular part of the array A must contain the lower   
   >           triangular part of the symmetric matrix and the strictly   
   >           upper triangular part of A is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the n   
   >           element vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION.   
   >           On entry, BETA specifies the scalar beta. When BETA is   
   >           supplied as zero then Y need not be set on input.   
   > \endverbatim   
   >   
   > \param[in,out] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCY ) ).   
   >           Before entry, the incremented array Y must contain the n   
   >           element vector y. On exit, Y is overwritten by the updated   
   >           vector y.   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >           On entry, INCY specifies the increment for the elements of   
   >           Y. INCY must not be zero.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level2   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >  The vector and matrix arguments are not referenced when N = 0, or M = 0   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsymv_(char *uplo, integer *n, doublereal *alpha, 
	doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal 
	*beta, doublereal *y, integer *incy)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, iy, jx, jy, kx, ky, info;
    doublereal temp1, temp2;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level2 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --x;
    --y;

    /* Function Body */
    info = 0;
    if (! igraphlsame_(uplo, "U") && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (*n < 0) {
	info = 2;
    } else if (*lda < max(1,*n)) {
	info = 5;
    } else if (*incx == 0) {
	info = 7;
    } else if (*incy == 0) {
	info = 10;
    }
    if (info != 0) {
	igraphxerbla_("DSYMV ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0 || *alpha == 0. && *beta == 1.) {
	return 0;
    }

/*     Set up the start points in  X  and  Y. */

    if (*incx > 0) {
	kx = 1;
    } else {
	kx = 1 - (*n - 1) * *incx;
    }
    if (*incy > 0) {
	ky = 1;
    } else {
	ky = 1 - (*n - 1) * *incy;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through the triangular part   
       of A.   

       First form  y := beta*y. */

    if (*beta != 1.) {
	if (*incy == 1) {
	    if (*beta == 0.) {
		i__1 = *n;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[i__] = 0.;
/* L10: */
		}
	    } else {
		i__1 = *n;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[i__] = *beta * y[i__];
/* L20: */
		}
	    }
	} else {
	    iy = ky;
	    if (*beta == 0.) {
		i__1 = *n;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[iy] = 0.;
		    iy += *incy;
/* L30: */
		}
	    } else {
		i__1 = *n;
		for (i__ = 1; i__ <= i__1; ++i__) {
		    y[iy] = *beta * y[iy];
		    iy += *incy;
/* L40: */
		}
	    }
	}
    }
    if (*alpha == 0.) {
	return 0;
    }
    if (igraphlsame_(uplo, "U")) {

/*        Form  y  when A is stored in upper triangle. */

	if (*incx == 1 && *incy == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp1 = *alpha * x[j];
		temp2 = 0.;
		i__2 = j - 1;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    y[i__] += temp1 * a[i__ + j * a_dim1];
		    temp2 += a[i__ + j * a_dim1] * x[i__];
/* L50: */
		}
		y[j] = y[j] + temp1 * a[j + j * a_dim1] + *alpha * temp2;
/* L60: */
	    }
	} else {
	    jx = kx;
	    jy = ky;
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp1 = *alpha * x[jx];
		temp2 = 0.;
		ix = kx;
		iy = ky;
		i__2 = j - 1;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    y[iy] += temp1 * a[i__ + j * a_dim1];
		    temp2 += a[i__ + j * a_dim1] * x[ix];
		    ix += *incx;
		    iy += *incy;
/* L70: */
		}
		y[jy] = y[jy] + temp1 * a[j + j * a_dim1] + *alpha * temp2;
		jx += *incx;
		jy += *incy;
/* L80: */
	    }
	}
    } else {

/*        Form  y  when A is stored in lower triangle. */

	if (*incx == 1 && *incy == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp1 = *alpha * x[j];
		temp2 = 0.;
		y[j] += temp1 * a[j + j * a_dim1];
		i__2 = *n;
		for (i__ = j + 1; i__ <= i__2; ++i__) {
		    y[i__] += temp1 * a[i__ + j * a_dim1];
		    temp2 += a[i__ + j * a_dim1] * x[i__];
/* L90: */
		}
		y[j] += *alpha * temp2;
/* L100: */
	    }
	} else {
	    jx = kx;
	    jy = ky;
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		temp1 = *alpha * x[jx];
		temp2 = 0.;
		y[jy] += temp1 * a[j + j * a_dim1];
		ix = jx;
		iy = jy;
		i__2 = *n;
		for (i__ = j + 1; i__ <= i__2; ++i__) {
		    ix += *incx;
		    iy += *incy;
		    y[iy] += temp1 * a[i__ + j * a_dim1];
		    temp2 += a[i__ + j * a_dim1] * x[ix];
/* L110: */
		}
		y[jy] += *alpha * temp2;
		jx += *incx;
		jy += *incy;
/* L120: */
	    }
	}
    }

    return 0;

/*     End of DSYMV . */

} /* igraphdsymv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsyr2.c0000644000175100001710000002145500000000000023620 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSYR2   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSYR2(UPLO,N,ALPHA,X,INCX,Y,INCY,A,LDA)   

         DOUBLE PRECISION ALPHA   
         INTEGER INCX,INCY,LDA,N   
         CHARACTER UPLO   
         DOUBLE PRECISION A(LDA,*),X(*),Y(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYR2  performs the symmetric rank 2 operation   
   >   
   >    A := alpha*x*y**T + alpha*y*x**T + A,   
   >   
   > where alpha is a scalar, x and y are n element vectors and A is an n   
   > by n symmetric matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the upper or lower   
   >           triangular part of the array A is to be referenced as   
   >           follows:   
   >   
   >              UPLO = 'U' or 'u'   Only the upper triangular part of A   
   >                                  is to be referenced.   
   >   
   >              UPLO = 'L' or 'l'   Only the lower triangular part of A   
   >                                  is to be referenced.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the order of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the n   
   >           element vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   
   >   
   > \param[in] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCY ) ).   
   >           Before entry, the incremented array Y must contain the n   
   >           element vector y.   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >           On entry, INCY specifies the increment for the elements of   
   >           Y. INCY must not be zero.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry with  UPLO = 'U' or 'u', the leading n by n   
   >           upper triangular part of the array A must contain the upper   
   >           triangular part of the symmetric matrix and the strictly   
   >           lower triangular part of A is not referenced. On exit, the   
   >           upper triangular part of the array A is overwritten by the   
   >           upper triangular part of the updated matrix.   
   >           Before entry with UPLO = 'L' or 'l', the leading n by n   
   >           lower triangular part of the array A must contain the lower   
   >           triangular part of the symmetric matrix and the strictly   
   >           upper triangular part of A is not referenced. On exit, the   
   >           lower triangular part of the array A is overwritten by the   
   >           lower triangular part of the updated matrix.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, n ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level2   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsyr2_(char *uplo, integer *n, doublereal *alpha, 
	doublereal *x, integer *incx, doublereal *y, integer *incy, 
	doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, iy, jx, jy, kx, ky, info;
    doublereal temp1, temp2;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level2 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --x;
    --y;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    info = 0;
    if (! igraphlsame_(uplo, "U") && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (*n < 0) {
	info = 2;
    } else if (*incx == 0) {
	info = 5;
    } else if (*incy == 0) {
	info = 7;
    } else if (*lda < max(1,*n)) {
	info = 9;
    }
    if (info != 0) {
	igraphxerbla_("DSYR2 ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0 || *alpha == 0.) {
	return 0;
    }

/*     Set up the start points in X and Y if the increments are not both   
       unity. */

    if (*incx != 1 || *incy != 1) {
	if (*incx > 0) {
	    kx = 1;
	} else {
	    kx = 1 - (*n - 1) * *incx;
	}
	if (*incy > 0) {
	    ky = 1;
	} else {
	    ky = 1 - (*n - 1) * *incy;
	}
	jx = kx;
	jy = ky;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through the triangular part   
       of A. */

    if (igraphlsame_(uplo, "U")) {

/*        Form  A  when A is stored in the upper triangle. */

	if (*incx == 1 && *incy == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (x[j] != 0. || y[j] != 0.) {
		    temp1 = *alpha * y[j];
		    temp2 = *alpha * x[j];
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			a[i__ + j * a_dim1] = a[i__ + j * a_dim1] + x[i__] * 
				temp1 + y[i__] * temp2;
/* L10: */
		    }
		}
/* L20: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (x[jx] != 0. || y[jy] != 0.) {
		    temp1 = *alpha * y[jy];
		    temp2 = *alpha * x[jx];
		    ix = kx;
		    iy = ky;
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			a[i__ + j * a_dim1] = a[i__ + j * a_dim1] + x[ix] * 
				temp1 + y[iy] * temp2;
			ix += *incx;
			iy += *incy;
/* L30: */
		    }
		}
		jx += *incx;
		jy += *incy;
/* L40: */
	    }
	}
    } else {

/*        Form  A  when A is stored in the lower triangle. */

	if (*incx == 1 && *incy == 1) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (x[j] != 0. || y[j] != 0.) {
		    temp1 = *alpha * y[j];
		    temp2 = *alpha * x[j];
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			a[i__ + j * a_dim1] = a[i__ + j * a_dim1] + x[i__] * 
				temp1 + y[i__] * temp2;
/* L50: */
		    }
		}
/* L60: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (x[jx] != 0. || y[jy] != 0.) {
		    temp1 = *alpha * y[jy];
		    temp2 = *alpha * x[jx];
		    ix = jx;
		    iy = jy;
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			a[i__ + j * a_dim1] = a[i__ + j * a_dim1] + x[ix] * 
				temp1 + y[iy] * temp2;
			ix += *incx;
			iy += *incy;
/* L70: */
		    }
		}
		jx += *incx;
		jy += *incy;
/* L80: */
	    }
	}
    }

    return 0;

/*     End of DSYR2 . */

} /* igraphdsyr2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsyr2k.c0000644000175100001710000003207300000000000023771 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSYR2K   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSYR2K(UPLO,TRANS,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)   

         DOUBLE PRECISION ALPHA,BETA   
         INTEGER K,LDA,LDB,LDC,N   
         CHARACTER TRANS,UPLO   
         DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYR2K  performs one of the symmetric rank 2k operations   
   >   
   >    C := alpha*A*B**T + alpha*B*A**T + beta*C,   
   >   
   > or   
   >   
   >    C := alpha*A**T*B + alpha*B**T*A + beta*C,   
   >   
   > where  alpha and beta  are scalars, C is an  n by n  symmetric matrix   
   > and  A and B  are  n by k  matrices  in the  first  case  and  k by n   
   > matrices in the second case.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On  entry,   UPLO  specifies  whether  the  upper  or  lower   
   >           triangular  part  of the  array  C  is to be  referenced  as   
   >           follows:   
   >   
   >              UPLO = 'U' or 'u'   Only the  upper triangular part of  C   
   >                                  is to be referenced.   
   >   
   >              UPLO = 'L' or 'l'   Only the  lower triangular part of  C   
   >                                  is to be referenced.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >           On entry,  TRANS  specifies the operation to be performed as   
   >           follows:   
   >   
   >              TRANS = 'N' or 'n'   C := alpha*A*B**T + alpha*B*A**T +   
   >                                        beta*C.   
   >   
   >              TRANS = 'T' or 't'   C := alpha*A**T*B + alpha*B**T*A +   
   >                                        beta*C.   
   >   
   >              TRANS = 'C' or 'c'   C := alpha*A**T*B + alpha*B**T*A +   
   >                                        beta*C.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry,  N specifies the order of the matrix C.  N must be   
   >           at least zero.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >           On entry with  TRANS = 'N' or 'n',  K  specifies  the number   
   >           of  columns  of the  matrices  A and B,  and on  entry  with   
   >           TRANS = 'T' or 't' or 'C' or 'c',  K  specifies  the  number   
   >           of rows of the matrices  A and B.  K must be at least  zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, ka ), where ka is   
   >           k  when  TRANS = 'N' or 'n',  and is  n  otherwise.   
   >           Before entry with  TRANS = 'N' or 'n',  the  leading  n by k   
   >           part of the array  A  must contain the matrix  A,  otherwise   
   >           the leading  k by n  part of the array  A  must contain  the   
   >           matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'   
   >           then  LDA must be at least  max( 1, n ), otherwise  LDA must   
   >           be at least  max( 1, k ).   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension ( LDB, kb ), where kb is   
   >           k  when  TRANS = 'N' or 'n',  and is  n  otherwise.   
   >           Before entry with  TRANS = 'N' or 'n',  the  leading  n by k   
   >           part of the array  B  must contain the matrix  B,  otherwise   
   >           the leading  k by n  part of the array  B  must contain  the   
   >           matrix B.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >           On entry, LDB specifies the first dimension of B as declared   
   >           in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'   
   >           then  LDB must be at least  max( 1, n ), otherwise  LDB must   
   >           be at least  max( 1, k ).   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION.   
   >           On entry, BETA specifies the scalar beta.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension ( LDC, N )   
   >           Before entry  with  UPLO = 'U' or 'u',  the leading  n by n   
   >           upper triangular part of the array C must contain the upper   
   >           triangular part  of the  symmetric matrix  and the strictly   
   >           lower triangular part of C is not referenced.  On exit, the   
   >           upper triangular part of the array  C is overwritten by the   
   >           upper triangular part of the updated matrix.   
   >           Before entry  with  UPLO = 'L' or 'l',  the leading  n by n   
   >           lower triangular part of the array C must contain the lower   
   >           triangular part  of the  symmetric matrix  and the strictly   
   >           upper triangular part of C is not referenced.  On exit, the   
   >           lower triangular part of the array  C is overwritten by the   
   >           lower triangular part of the updated matrix.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >           On entry, LDC specifies the first dimension of C as declared   
   >           in  the  calling  (sub)  program.   LDC  must  be  at  least   
   >           max( 1, n ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level3   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 3 Blas routine.   
   >   
   >   
   >  -- Written on 8-February-1989.   
   >     Jack Dongarra, Argonne National Laboratory.   
   >     Iain Duff, AERE Harwell.   
   >     Jeremy Du Croz, Numerical Algorithms Group Ltd.   
   >     Sven Hammarling, Numerical Algorithms Group Ltd.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsyr2k_(char *uplo, char *trans, integer *n, integer *k, 
	doublereal *alpha, doublereal *a, integer *lda, doublereal *b, 
	integer *ldb, doublereal *beta, doublereal *c__, integer *ldc)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2, 
	    i__3;

    /* Local variables */
    integer i__, j, l, info;
    doublereal temp1, temp2;
    extern logical igraphlsame_(char *, char *);
    integer nrowa;
    logical upper;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level3 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;

    /* Function Body */
    if (igraphlsame_(trans, "N")) {
	nrowa = *n;
    } else {
	nrowa = *k;
    }
    upper = igraphlsame_(uplo, "U");

    info = 0;
    if (! upper && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T") && ! igraphlsame_(trans, "C")) {
	info = 2;
    } else if (*n < 0) {
	info = 3;
    } else if (*k < 0) {
	info = 4;
    } else if (*lda < max(1,nrowa)) {
	info = 7;
    } else if (*ldb < max(1,nrowa)) {
	info = 9;
    } else if (*ldc < max(1,*n)) {
	info = 12;
    }
    if (info != 0) {
	igraphxerbla_("DSYR2K", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0 || (*alpha == 0. || *k == 0) && *beta == 1.) {
	return 0;
    }

/*     And when  alpha.eq.zero. */

    if (*alpha == 0.) {
	if (upper) {
	    if (*beta == 0.) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L10: */
		    }
/* L20: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L30: */
		    }
/* L40: */
		}
	    }
	} else {
	    if (*beta == 0.) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L50: */
		    }
/* L60: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L70: */
		    }
/* L80: */
		}
	    }
	}
	return 0;
    }

/*     Start the operations. */

    if (igraphlsame_(trans, "N")) {

/*        Form  C := alpha*A*B**T + alpha*B*A**T + C. */

	if (upper) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L90: */
		    }
		} else if (*beta != 1.) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L100: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    if (a[j + l * a_dim1] != 0. || b[j + l * b_dim1] != 0.) {
			temp1 = *alpha * b[j + l * b_dim1];
			temp2 = *alpha * a[j + l * a_dim1];
			i__3 = j;
			for (i__ = 1; i__ <= i__3; ++i__) {
			    c__[i__ + j * c_dim1] = c__[i__ + j * c_dim1] + a[
				    i__ + l * a_dim1] * temp1 + b[i__ + l * 
				    b_dim1] * temp2;
/* L110: */
			}
		    }
/* L120: */
		}
/* L130: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L140: */
		    }
		} else if (*beta != 1.) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L150: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    if (a[j + l * a_dim1] != 0. || b[j + l * b_dim1] != 0.) {
			temp1 = *alpha * b[j + l * b_dim1];
			temp2 = *alpha * a[j + l * a_dim1];
			i__3 = *n;
			for (i__ = j; i__ <= i__3; ++i__) {
			    c__[i__ + j * c_dim1] = c__[i__ + j * c_dim1] + a[
				    i__ + l * a_dim1] * temp1 + b[i__ + l * 
				    b_dim1] * temp2;
/* L160: */
			}
		    }
/* L170: */
		}
/* L180: */
	    }
	}
    } else {

/*        Form  C := alpha*A**T*B + alpha*B**T*A + C. */

	if (upper) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = j;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp1 = 0.;
		    temp2 = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp1 += a[l + i__ * a_dim1] * b[l + j * b_dim1];
			temp2 += b[l + i__ * b_dim1] * a[l + j * a_dim1];
/* L190: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp1 + *alpha * 
				temp2;
		    } else {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1] 
				+ *alpha * temp1 + *alpha * temp2;
		    }
/* L200: */
		}
/* L210: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *n;
		for (i__ = j; i__ <= i__2; ++i__) {
		    temp1 = 0.;
		    temp2 = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp1 += a[l + i__ * a_dim1] * b[l + j * b_dim1];
			temp2 += b[l + i__ * b_dim1] * a[l + j * a_dim1];
/* L220: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp1 + *alpha * 
				temp2;
		    } else {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1] 
				+ *alpha * temp1 + *alpha * temp2;
		    }
/* L230: */
		}
/* L240: */
	    }
	}
    }

    return 0;

/*     End of DSYR2K. */

} /* igraphdsyr2k_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsyrk.c0000644000175100001710000002644200000000000023712 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DSYRK   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DSYRK(UPLO,TRANS,N,K,ALPHA,A,LDA,BETA,C,LDC)   

         DOUBLE PRECISION ALPHA,BETA   
         INTEGER K,LDA,LDC,N   
         CHARACTER TRANS,UPLO   
         DOUBLE PRECISION A(LDA,*),C(LDC,*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYRK  performs one of the symmetric rank k operations   
   >   
   >    C := alpha*A*A**T + beta*C,   
   >   
   > or   
   >   
   >    C := alpha*A**T*A + beta*C,   
   >   
   > where  alpha and beta  are scalars, C is an  n by n  symmetric matrix   
   > and  A  is an  n by k  matrix in the first case and a  k by n  matrix   
   > in the second case.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On  entry,   UPLO  specifies  whether  the  upper  or  lower   
   >           triangular  part  of the  array  C  is to be  referenced  as   
   >           follows:   
   >   
   >              UPLO = 'U' or 'u'   Only the  upper triangular part of  C   
   >                                  is to be referenced.   
   >   
   >              UPLO = 'L' or 'l'   Only the  lower triangular part of  C   
   >                                  is to be referenced.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >           On entry,  TRANS  specifies the operation to be performed as   
   >           follows:   
   >   
   >              TRANS = 'N' or 'n'   C := alpha*A*A**T + beta*C.   
   >   
   >              TRANS = 'T' or 't'   C := alpha*A**T*A + beta*C.   
   >   
   >              TRANS = 'C' or 'c'   C := alpha*A**T*A + beta*C.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry,  N specifies the order of the matrix C.  N must be   
   >           at least zero.   
   > \endverbatim   
   >   
   > \param[in] K   
   > \verbatim   
   >          K is INTEGER   
   >           On entry with  TRANS = 'N' or 'n',  K  specifies  the number   
   >           of  columns   of  the   matrix   A,   and  on   entry   with   
   >           TRANS = 'T' or 't' or 'C' or 'c',  K  specifies  the  number   
   >           of rows of the matrix  A.  K must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, ka ), where ka is   
   >           k  when  TRANS = 'N' or 'n',  and is  n  otherwise.   
   >           Before entry with  TRANS = 'N' or 'n',  the  leading  n by k   
   >           part of the array  A  must contain the matrix  A,  otherwise   
   >           the leading  k by n  part of the array  A  must contain  the   
   >           matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'   
   >           then  LDA must be at least  max( 1, n ), otherwise  LDA must   
   >           be at least  max( 1, k ).   
   > \endverbatim   
   >   
   > \param[in] BETA   
   > \verbatim   
   >          BETA is DOUBLE PRECISION.   
   >           On entry, BETA specifies the scalar beta.   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension ( LDC, N )   
   >           Before entry  with  UPLO = 'U' or 'u',  the leading  n by n   
   >           upper triangular part of the array C must contain the upper   
   >           triangular part  of the  symmetric matrix  and the strictly   
   >           lower triangular part of C is not referenced.  On exit, the   
   >           upper triangular part of the array  C is overwritten by the   
   >           upper triangular part of the updated matrix.   
   >           Before entry  with  UPLO = 'L' or 'l',  the leading  n by n   
   >           lower triangular part of the array C must contain the lower   
   >           triangular part  of the  symmetric matrix  and the strictly   
   >           upper triangular part of C is not referenced.  On exit, the   
   >           lower triangular part of the array  C is overwritten by the   
   >           lower triangular part of the updated matrix.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >           On entry, LDC specifies the first dimension of C as declared   
   >           in  the  calling  (sub)  program.   LDC  must  be  at  least   
   >           max( 1, n ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level3   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 3 Blas routine.   
   >   
   >  -- Written on 8-February-1989.   
   >     Jack Dongarra, Argonne National Laboratory.   
   >     Iain Duff, AERE Harwell.   
   >     Jeremy Du Croz, Numerical Algorithms Group Ltd.   
   >     Sven Hammarling, Numerical Algorithms Group Ltd.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsyrk_(char *uplo, char *trans, integer *n, integer *k, 
	doublereal *alpha, doublereal *a, integer *lda, doublereal *beta, 
	doublereal *c__, integer *ldc)
{
    /* System generated locals */
    integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j, l, info;
    doublereal temp;
    extern logical igraphlsame_(char *, char *);
    integer nrowa;
    logical upper;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level3 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;

    /* Function Body */
    if (igraphlsame_(trans, "N")) {
	nrowa = *n;
    } else {
	nrowa = *k;
    }
    upper = igraphlsame_(uplo, "U");

    info = 0;
    if (! upper && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T") && ! igraphlsame_(trans, "C")) {
	info = 2;
    } else if (*n < 0) {
	info = 3;
    } else if (*k < 0) {
	info = 4;
    } else if (*lda < max(1,nrowa)) {
	info = 7;
    } else if (*ldc < max(1,*n)) {
	info = 10;
    }
    if (info != 0) {
	igraphxerbla_("DSYRK ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0 || (*alpha == 0. || *k == 0) && *beta == 1.) {
	return 0;
    }

/*     And when  alpha.eq.zero. */

    if (*alpha == 0.) {
	if (upper) {
	    if (*beta == 0.) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L10: */
		    }
/* L20: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L30: */
		    }
/* L40: */
		}
	    }
	} else {
	    if (*beta == 0.) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L50: */
		    }
/* L60: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L70: */
		    }
/* L80: */
		}
	    }
	}
	return 0;
    }

/*     Start the operations. */

    if (igraphlsame_(trans, "N")) {

/*        Form  C := alpha*A*A**T + beta*C. */

	if (upper) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L90: */
		    }
		} else if (*beta != 1.) {
		    i__2 = j;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L100: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    if (a[j + l * a_dim1] != 0.) {
			temp = *alpha * a[j + l * a_dim1];
			i__3 = j;
			for (i__ = 1; i__ <= i__3; ++i__) {
			    c__[i__ + j * c_dim1] += temp * a[i__ + l * 
				    a_dim1];
/* L110: */
			}
		    }
/* L120: */
		}
/* L130: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (*beta == 0.) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = 0.;
/* L140: */
		    }
		} else if (*beta != 1.) {
		    i__2 = *n;
		    for (i__ = j; i__ <= i__2; ++i__) {
			c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
/* L150: */
		    }
		}
		i__2 = *k;
		for (l = 1; l <= i__2; ++l) {
		    if (a[j + l * a_dim1] != 0.) {
			temp = *alpha * a[j + l * a_dim1];
			i__3 = *n;
			for (i__ = j; i__ <= i__3; ++i__) {
			    c__[i__ + j * c_dim1] += temp * a[i__ + l * 
				    a_dim1];
/* L160: */
			}
		    }
/* L170: */
		}
/* L180: */
	    }
	}
    } else {

/*        Form  C := alpha*A**T*A + beta*C. */

	if (upper) {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = j;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    temp = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp += a[l + i__ * a_dim1] * a[l + j * a_dim1];
/* L190: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp;
		    } else {
			c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
				i__ + j * c_dim1];
		    }
/* L200: */
		}
/* L210: */
	    }
	} else {
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		i__2 = *n;
		for (i__ = j; i__ <= i__2; ++i__) {
		    temp = 0.;
		    i__3 = *k;
		    for (l = 1; l <= i__3; ++l) {
			temp += a[l + i__ * a_dim1] * a[l + j * a_dim1];
/* L220: */
		    }
		    if (*beta == 0.) {
			c__[i__ + j * c_dim1] = *alpha * temp;
		    } else {
			c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
				i__ + j * c_dim1];
		    }
/* L230: */
		}
/* L240: */
	    }
	}
    }

    return 0;

/*     End of DSYRK . */

} /* igraphdsyrk_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsytd2.c0000644000175100001710000002701100000000000023760 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static doublereal c_b8 = 0.;
static doublereal c_b14 = -1.;

/* > \brief \b DSYTD2 reduces a symmetric matrix to real symmetric tridiagonal form by an orthogonal similarit
y transformation (unblocked algorithm).   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSYTD2 + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSYTD2( UPLO, N, A, LDA, D, E, TAU, INFO )   

         CHARACTER          UPLO   
         INTEGER            INFO, LDA, N   
         DOUBLE PRECISION   A( LDA, * ), D( * ), E( * ), TAU( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYTD2 reduces a real symmetric matrix A to symmetric tridiagonal   
   > form T by an orthogonal similarity transformation: Q**T * A * Q = T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          Specifies whether the upper or lower triangular part of the   
   >          symmetric matrix A is stored:   
   >          = 'U':  Upper triangular   
   >          = 'L':  Lower triangular   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the leading   
   >          n-by-n upper triangular part of A contains the upper   
   >          triangular part of the matrix A, and the strictly lower   
   >          triangular part of A is not referenced.  If UPLO = 'L', the   
   >          leading n-by-n lower triangular part of A contains the lower   
   >          triangular part of the matrix A, and the strictly upper   
   >          triangular part of A is not referenced.   
   >          On exit, if UPLO = 'U', the diagonal and first superdiagonal   
   >          of A are overwritten by the corresponding elements of the   
   >          tridiagonal matrix T, and the elements above the first   
   >          superdiagonal, with the array TAU, represent the orthogonal   
   >          matrix Q as a product of elementary reflectors; if UPLO   
   >          = 'L', the diagonal and first subdiagonal of A are over-   
   >          written by the corresponding elements of the tridiagonal   
   >          matrix T, and the elements below the first subdiagonal, with   
   >          the array TAU, represent the orthogonal matrix Q as a product   
   >          of elementary reflectors. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The diagonal elements of the tridiagonal matrix T:   
   >          D(i) = A(i,i).   
   > \endverbatim   
   >   
   > \param[out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The off-diagonal elements of the tridiagonal matrix T:   
   >          E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'.   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          The scalar factors of the elementary reflectors (see Further   
   >          Details).   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup doubleSYcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  If UPLO = 'U', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(n-1) . . . H(2) H(1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in   
   >  A(1:i-1,i+1), and tau in TAU(i).   
   >   
   >  If UPLO = 'L', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(1) H(2) . . . H(n-1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),   
   >  and tau in TAU(i).   
   >   
   >  The contents of A on exit are illustrated by the following examples   
   >  with n = 5:   
   >   
   >  if UPLO = 'U':                       if UPLO = 'L':   
   >   
   >    (  d   e   v2  v3  v4 )              (  d                  )   
   >    (      d   e   v3  v4 )              (  e   d              )   
   >    (          d   e   v4 )              (  v1  e   d          )   
   >    (              d   e  )              (  v1  v2  e   d      )   
   >    (                  d  )              (  v1  v2  v3  e   d  )   
   >   
   >  where d and e denote diagonal and off-diagonal elements of T, and vi   
   >  denotes an element of the vector defining H(i).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsytd2_(char *uplo, integer *n, doublereal *a, integer *
	lda, doublereal *d__, doublereal *e, doublereal *tau, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    doublereal taui;
    extern /* Subroutine */ int igraphdsyr2_(char *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    doublereal alpha;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdaxpy_(integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *);
    logical upper;
    extern /* Subroutine */ int igraphdsymv_(char *, integer *, doublereal *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, integer *), igraphdlarfg_(integer *, doublereal *,
	     doublereal *, integer *, doublereal *), igraphxerbla_(char *, integer *
	    , ftnlen);


/*  -- LAPACK computational routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --d__;
    --e;
    --tau;

    /* Function Body */
    *info = 0;
    upper = igraphlsame_(uplo, "U");
    if (! upper && ! igraphlsame_(uplo, "L")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSYTD2", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n <= 0) {
	return 0;
    }

    if (upper) {

/*        Reduce the upper triangle of A */

	for (i__ = *n - 1; i__ >= 1; --i__) {

/*           Generate elementary reflector H(i) = I - tau * v * v**T   
             to annihilate A(1:i-1,i+1) */

	    igraphdlarfg_(&i__, &a[i__ + (i__ + 1) * a_dim1], &a[(i__ + 1) * a_dim1 
		    + 1], &c__1, &taui);
	    e[i__] = a[i__ + (i__ + 1) * a_dim1];

	    if (taui != 0.) {

/*              Apply H(i) from both sides to A(1:i,1:i) */

		a[i__ + (i__ + 1) * a_dim1] = 1.;

/*              Compute  x := tau * A * v  storing x in TAU(1:i) */

		igraphdsymv_(uplo, &i__, &taui, &a[a_offset], lda, &a[(i__ + 1) * 
			a_dim1 + 1], &c__1, &c_b8, &tau[1], &c__1);

/*              Compute  w := x - 1/2 * tau * (x**T * v) * v */

		alpha = taui * -.5 * igraphddot_(&i__, &tau[1], &c__1, &a[(i__ + 1) 
			* a_dim1 + 1], &c__1);
		igraphdaxpy_(&i__, &alpha, &a[(i__ + 1) * a_dim1 + 1], &c__1, &tau[
			1], &c__1);

/*              Apply the transformation as a rank-2 update:   
                   A := A - v * w**T - w * v**T */

		igraphdsyr2_(uplo, &i__, &c_b14, &a[(i__ + 1) * a_dim1 + 1], &c__1, 
			&tau[1], &c__1, &a[a_offset], lda);

		a[i__ + (i__ + 1) * a_dim1] = e[i__];
	    }
	    d__[i__ + 1] = a[i__ + 1 + (i__ + 1) * a_dim1];
	    tau[i__] = taui;
/* L10: */
	}
	d__[1] = a[a_dim1 + 1];
    } else {

/*        Reduce the lower triangle of A */

	i__1 = *n - 1;
	for (i__ = 1; i__ <= i__1; ++i__) {

/*           Generate elementary reflector H(i) = I - tau * v * v**T   
             to annihilate A(i+2:n,i) */

	    i__2 = *n - i__;
/* Computing MIN */
	    i__3 = i__ + 2;
	    igraphdlarfg_(&i__2, &a[i__ + 1 + i__ * a_dim1], &a[min(i__3,*n) + i__ *
		     a_dim1], &c__1, &taui);
	    e[i__] = a[i__ + 1 + i__ * a_dim1];

	    if (taui != 0.) {

/*              Apply H(i) from both sides to A(i+1:n,i+1:n) */

		a[i__ + 1 + i__ * a_dim1] = 1.;

/*              Compute  x := tau * A * v  storing y in TAU(i:n-1) */

		i__2 = *n - i__;
		igraphdsymv_(uplo, &i__2, &taui, &a[i__ + 1 + (i__ + 1) * a_dim1], 
			lda, &a[i__ + 1 + i__ * a_dim1], &c__1, &c_b8, &tau[
			i__], &c__1);

/*              Compute  w := x - 1/2 * tau * (x**T * v) * v */

		i__2 = *n - i__;
		alpha = taui * -.5 * igraphddot_(&i__2, &tau[i__], &c__1, &a[i__ + 
			1 + i__ * a_dim1], &c__1);
		i__2 = *n - i__;
		igraphdaxpy_(&i__2, &alpha, &a[i__ + 1 + i__ * a_dim1], &c__1, &tau[
			i__], &c__1);

/*              Apply the transformation as a rank-2 update:   
                   A := A - v * w**T - w * v**T */

		i__2 = *n - i__;
		igraphdsyr2_(uplo, &i__2, &c_b14, &a[i__ + 1 + i__ * a_dim1], &c__1,
			 &tau[i__], &c__1, &a[i__ + 1 + (i__ + 1) * a_dim1], 
			lda);

		a[i__ + 1 + i__ * a_dim1] = e[i__];
	    }
	    d__[i__] = a[i__ + i__ * a_dim1];
	    tau[i__] = taui;
/* L20: */
	}
	d__[*n] = a[*n + *n * a_dim1];
    }

    return 0;

/*     End of DSYTD2 */

} /* igraphdsytd2_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dsytrd.c0000644000175100001710000003244700000000000024071 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;
static doublereal c_b22 = -1.;
static doublereal c_b23 = 1.;

/* > \brief \b DSYTRD   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DSYTRD + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DSYTRD( UPLO, N, A, LDA, D, E, TAU, WORK, LWORK, INFO )   

         CHARACTER          UPLO   
         INTEGER            INFO, LDA, LWORK, N   
         DOUBLE PRECISION   A( LDA, * ), D( * ), E( * ), TAU( * ),   
        $                   WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DSYTRD reduces a real symmetric matrix A to real symmetric   
   > tridiagonal form T by an orthogonal similarity transformation:   
   > Q**T * A * Q = T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >          = 'U':  Upper triangle of A is stored;   
   >          = 'L':  Lower triangle of A is stored.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix A.  N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          On entry, the symmetric matrix A.  If UPLO = 'U', the leading   
   >          N-by-N upper triangular part of A contains the upper   
   >          triangular part of the matrix A, and the strictly lower   
   >          triangular part of A is not referenced.  If UPLO = 'L', the   
   >          leading N-by-N lower triangular part of A contains the lower   
   >          triangular part of the matrix A, and the strictly upper   
   >          triangular part of A is not referenced.   
   >          On exit, if UPLO = 'U', the diagonal and first superdiagonal   
   >          of A are overwritten by the corresponding elements of the   
   >          tridiagonal matrix T, and the elements above the first   
   >          superdiagonal, with the array TAU, represent the orthogonal   
   >          matrix Q as a product of elementary reflectors; if UPLO   
   >          = 'L', the diagonal and first subdiagonal of A are over-   
   >          written by the corresponding elements of the tridiagonal   
   >          matrix T, and the elements below the first subdiagonal, with   
   >          the array TAU, represent the orthogonal matrix Q as a product   
   >          of elementary reflectors. See Further Details.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A.  LDA >= max(1,N).   
   > \endverbatim   
   >   
   > \param[out] D   
   > \verbatim   
   >          D is DOUBLE PRECISION array, dimension (N)   
   >          The diagonal elements of the tridiagonal matrix T:   
   >          D(i) = A(i,i).   
   > \endverbatim   
   >   
   > \param[out] E   
   > \verbatim   
   >          E is DOUBLE PRECISION array, dimension (N-1)   
   >          The off-diagonal elements of the tridiagonal matrix T:   
   >          E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'.   
   > \endverbatim   
   >   
   > \param[out] TAU   
   > \verbatim   
   >          TAU is DOUBLE PRECISION array, dimension (N-1)   
   >          The scalar factors of the elementary reflectors (see Further   
   >          Details).   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.  LWORK >= 1.   
   >          For optimum performance LWORK >= N*NB, where NB is the   
   >          optimal blocksize.   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleSYcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  If UPLO = 'U', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(n-1) . . . H(2) H(1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in   
   >  A(1:i-1,i+1), and tau in TAU(i).   
   >   
   >  If UPLO = 'L', the matrix Q is represented as a product of elementary   
   >  reflectors   
   >   
   >     Q = H(1) H(2) . . . H(n-1).   
   >   
   >  Each H(i) has the form   
   >   
   >     H(i) = I - tau * v * v**T   
   >   
   >  where tau is a real scalar, and v is a real vector with   
   >  v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),   
   >  and tau in TAU(i).   
   >   
   >  The contents of A on exit are illustrated by the following examples   
   >  with n = 5:   
   >   
   >  if UPLO = 'U':                       if UPLO = 'L':   
   >   
   >    (  d   e   v2  v3  v4 )              (  d                  )   
   >    (      d   e   v3  v4 )              (  e   d              )   
   >    (          d   e   v4 )              (  v1  e   d          )   
   >    (              d   e  )              (  v1  v2  e   d      )   
   >    (                  d  )              (  v1  v2  v3  e   d  )   
   >   
   >  where d and e denote diagonal and off-diagonal elements of T, and vi   
   >  denotes an element of the vector defining H(i).   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdsytrd_(char *uplo, integer *n, doublereal *a, integer *
	lda, doublereal *d__, doublereal *e, doublereal *tau, doublereal *
	work, integer *lwork, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j, nb, kk, nx, iws;
    extern logical igraphlsame_(char *, char *);
    integer nbmin, iinfo;
    logical upper;
    extern /* Subroutine */ int igraphdsytd2_(char *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, doublereal *, integer *), igraphdsyr2k_(char *, char *, integer *, integer *, doublereal 
	    *, doublereal *, integer *, doublereal *, integer *, doublereal *,
	     doublereal *, integer *), igraphdlatrd_(char *, 
	    integer *, integer *, doublereal *, integer *, doublereal *, 
	    doublereal *, doublereal *, integer *), igraphxerbla_(char *, 
	    integer *, ftnlen);
    extern integer igraphilaenv_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *, ftnlen, ftnlen);
    integer ldwork, lwkopt;
    logical lquery;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Test the input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --d__;
    --e;
    --tau;
    --work;

    /* Function Body */
    *info = 0;
    upper = igraphlsame_(uplo, "U");
    lquery = *lwork == -1;
    if (! upper && ! igraphlsame_(uplo, "L")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*lda < max(1,*n)) {
	*info = -4;
    } else if (*lwork < 1 && ! lquery) {
	*info = -9;
    }

    if (*info == 0) {

/*        Determine the block size. */

	nb = igraphilaenv_(&c__1, "DSYTRD", uplo, n, &c_n1, &c_n1, &c_n1, (ftnlen)6,
		 (ftnlen)1);
	lwkopt = *n * nb;
	work[1] = (doublereal) lwkopt;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DSYTRD", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	work[1] = 1.;
	return 0;
    }

    nx = *n;
    iws = 1;
    if (nb > 1 && nb < *n) {

/*        Determine when to cross over from blocked to unblocked code   
          (last block is always handled by unblocked code).   

   Computing MAX */
	i__1 = nb, i__2 = igraphilaenv_(&c__3, "DSYTRD", uplo, n, &c_n1, &c_n1, &
		c_n1, (ftnlen)6, (ftnlen)1);
	nx = max(i__1,i__2);
	if (nx < *n) {

/*           Determine if workspace is large enough for blocked code. */

	    ldwork = *n;
	    iws = ldwork * nb;
	    if (*lwork < iws) {

/*              Not enough workspace to use optimal NB:  determine the   
                minimum value of NB, and reduce NB or force use of   
                unblocked code by setting NX = N.   

   Computing MAX */
		i__1 = *lwork / ldwork;
		nb = max(i__1,1);
		nbmin = igraphilaenv_(&c__2, "DSYTRD", uplo, n, &c_n1, &c_n1, &c_n1,
			 (ftnlen)6, (ftnlen)1);
		if (nb < nbmin) {
		    nx = *n;
		}
	    }
	} else {
	    nx = *n;
	}
    } else {
	nb = 1;
    }

    if (upper) {

/*        Reduce the upper triangle of A.   
          Columns 1:kk are handled by the unblocked method. */

	kk = *n - (*n - nx + nb - 1) / nb * nb;
	i__1 = kk + 1;
	i__2 = -nb;
	for (i__ = *n - nb + 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += 
		i__2) {

/*           Reduce columns i:i+nb-1 to tridiagonal form and form the   
             matrix W which is needed to update the unreduced part of   
             the matrix */

	    i__3 = i__ + nb - 1;
	    igraphdlatrd_(uplo, &i__3, &nb, &a[a_offset], lda, &e[1], &tau[1], &
		    work[1], &ldwork);

/*           Update the unreduced submatrix A(1:i-1,1:i-1), using an   
             update of the form:  A := A - V*W**T - W*V**T */

	    i__3 = i__ - 1;
	    igraphdsyr2k_(uplo, "No transpose", &i__3, &nb, &c_b22, &a[i__ * a_dim1 
		    + 1], lda, &work[1], &ldwork, &c_b23, &a[a_offset], lda);

/*           Copy superdiagonal elements back into A, and diagonal   
             elements into D */

	    i__3 = i__ + nb - 1;
	    for (j = i__; j <= i__3; ++j) {
		a[j - 1 + j * a_dim1] = e[j - 1];
		d__[j] = a[j + j * a_dim1];
/* L10: */
	    }
/* L20: */
	}

/*        Use unblocked code to reduce the last or only block */

	igraphdsytd2_(uplo, &kk, &a[a_offset], lda, &d__[1], &e[1], &tau[1], &iinfo);
    } else {

/*        Reduce the lower triangle of A */

	i__2 = *n - nx;
	i__1 = nb;
	for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__1) {

/*           Reduce columns i:i+nb-1 to tridiagonal form and form the   
             matrix W which is needed to update the unreduced part of   
             the matrix */

	    i__3 = *n - i__ + 1;
	    igraphdlatrd_(uplo, &i__3, &nb, &a[i__ + i__ * a_dim1], lda, &e[i__], &
		    tau[i__], &work[1], &ldwork);

/*           Update the unreduced submatrix A(i+ib:n,i+ib:n), using   
             an update of the form:  A := A - V*W**T - W*V**T */

	    i__3 = *n - i__ - nb + 1;
	    igraphdsyr2k_(uplo, "No transpose", &i__3, &nb, &c_b22, &a[i__ + nb + 
		    i__ * a_dim1], lda, &work[nb + 1], &ldwork, &c_b23, &a[
		    i__ + nb + (i__ + nb) * a_dim1], lda);

/*           Copy subdiagonal elements back into A, and diagonal   
             elements into D */

	    i__3 = i__ + nb - 1;
	    for (j = i__; j <= i__3; ++j) {
		a[j + 1 + j * a_dim1] = e[j];
		d__[j] = a[j + j * a_dim1];
/* L30: */
	    }
/* L40: */
	}

/*        Use unblocked code to reduce the last or only block */

	i__1 = *n - i__ + 1;
	igraphdsytd2_(uplo, &i__1, &a[i__ + i__ * a_dim1], lda, &d__[i__], &e[i__], 
		&tau[i__], &iinfo);
    }

    work[1] = (doublereal) lwkopt;
    return 0;

/*     End of DSYTRD */

} /* igraphdsytrd_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrevc.c0000644000175100001710000010642000000000000024040 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static logical c_false = FALSE_;
static integer c__1 = 1;
static doublereal c_b22 = 1.;
static doublereal c_b25 = 0.;
static integer c__2 = 2;
static logical c_true = TRUE_;

/* > \brief \b DTREVC   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DTREVC + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DTREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,   
                            LDVR, MM, M, WORK, INFO )   

         CHARACTER          HOWMNY, SIDE   
         INTEGER            INFO, LDT, LDVL, LDVR, M, MM, N   
         LOGICAL            SELECT( * )   
         DOUBLE PRECISION   T( LDT, * ), VL( LDVL, * ), VR( LDVR, * ),   
        $                   WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTREVC computes some or all of the right and/or left eigenvectors of   
   > a real upper quasi-triangular matrix T.   
   > Matrices of this type are produced by the Schur factorization of   
   > a real general matrix:  A = Q*T*Q**T, as computed by DHSEQR.   
   >   
   > The right eigenvector x and the left eigenvector y of T corresponding   
   > to an eigenvalue w are defined by:   
   >   
   >    T*x = w*x,     (y**T)*T = w*(y**T)   
   >   
   > where y**T denotes the transpose of y.   
   > The eigenvalues are not input to this routine, but are read directly   
   > from the diagonal blocks of T.   
   >   
   > This routine returns the matrices X and/or Y of right and left   
   > eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an   
   > input matrix.  If Q is the orthogonal factor that reduces a matrix   
   > A to Schur form T, then Q*X and Q*Y are the matrices of right and   
   > left eigenvectors of A.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >          = 'R':  compute right eigenvectors only;   
   >          = 'L':  compute left eigenvectors only;   
   >          = 'B':  compute both right and left eigenvectors.   
   > \endverbatim   
   >   
   > \param[in] HOWMNY   
   > \verbatim   
   >          HOWMNY is CHARACTER*1   
   >          = 'A':  compute all right and/or left eigenvectors;   
   >          = 'B':  compute all right and/or left eigenvectors,   
   >                  backtransformed by the matrices in VR and/or VL;   
   >          = 'S':  compute selected right and/or left eigenvectors,   
   >                  as indicated by the logical array SELECT.   
   > \endverbatim   
   >   
   > \param[in,out] SELECT   
   > \verbatim   
   >          SELECT is LOGICAL array, dimension (N)   
   >          If HOWMNY = 'S', SELECT specifies the eigenvectors to be   
   >          computed.   
   >          If w(j) is a real eigenvalue, the corresponding real   
   >          eigenvector is computed if SELECT(j) is .TRUE..   
   >          If w(j) and w(j+1) are the real and imaginary parts of a   
   >          complex eigenvalue, the corresponding complex eigenvector is   
   >          computed if either SELECT(j) or SELECT(j+1) is .TRUE., and   
   >          on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to   
   >          .FALSE..   
   >          Not referenced if HOWMNY = 'A' or 'B'.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          The upper quasi-triangular matrix T in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION array, dimension (LDVL,MM)   
   >          On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must   
   >          contain an N-by-N matrix Q (usually the orthogonal matrix Q   
   >          of Schur vectors returned by DHSEQR).   
   >          On exit, if SIDE = 'L' or 'B', VL contains:   
   >          if HOWMNY = 'A', the matrix Y of left eigenvectors of T;   
   >          if HOWMNY = 'B', the matrix Q*Y;   
   >          if HOWMNY = 'S', the left eigenvectors of T specified by   
   >                           SELECT, stored consecutively in the columns   
   >                           of VL, in the same order as their   
   >                           eigenvalues.   
   >          A complex eigenvector corresponding to a complex eigenvalue   
   >          is stored in two consecutive columns, the first holding the   
   >          real part, and the second the imaginary part.   
   >          Not referenced if SIDE = 'R'.   
   > \endverbatim   
   >   
   > \param[in] LDVL   
   > \verbatim   
   >          LDVL is INTEGER   
   >          The leading dimension of the array VL.  LDVL >= 1, and if   
   >          SIDE = 'L' or 'B', LDVL >= N.   
   > \endverbatim   
   >   
   > \param[in,out] VR   
   > \verbatim   
   >          VR is DOUBLE PRECISION array, dimension (LDVR,MM)   
   >          On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must   
   >          contain an N-by-N matrix Q (usually the orthogonal matrix Q   
   >          of Schur vectors returned by DHSEQR).   
   >          On exit, if SIDE = 'R' or 'B', VR contains:   
   >          if HOWMNY = 'A', the matrix X of right eigenvectors of T;   
   >          if HOWMNY = 'B', the matrix Q*X;   
   >          if HOWMNY = 'S', the right eigenvectors of T specified by   
   >                           SELECT, stored consecutively in the columns   
   >                           of VR, in the same order as their   
   >                           eigenvalues.   
   >          A complex eigenvector corresponding to a complex eigenvalue   
   >          is stored in two consecutive columns, the first holding the   
   >          real part and the second the imaginary part.   
   >          Not referenced if SIDE = 'L'.   
   > \endverbatim   
   >   
   > \param[in] LDVR   
   > \verbatim   
   >          LDVR is INTEGER   
   >          The leading dimension of the array VR.  LDVR >= 1, and if   
   >          SIDE = 'R' or 'B', LDVR >= N.   
   > \endverbatim   
   >   
   > \param[in] MM   
   > \verbatim   
   >          MM is INTEGER   
   >          The number of columns in the arrays VL and/or VR. MM >= M.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of columns in the arrays VL and/or VR actually   
   >          used to store the eigenvectors.   
   >          If HOWMNY = 'A' or 'B', M is set to N.   
   >          Each selected real eigenvector occupies one column and each   
   >          selected complex eigenvector occupies two columns.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (3*N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The algorithm used in this program is basically backward (forward)   
   >  substitution, with scaling to make the the code robust against   
   >  possible overflow.   
   >   
   >  Each eigenvector is normalized so that the element of largest   
   >  magnitude has magnitude 1; here the magnitude of a complex number   
   >  (x,y) is taken to be |x| + |y|.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrevc_(char *side, char *howmny, logical *select, 
	integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *
	ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, 
	doublereal *work, integer *info)
{
    /* System generated locals */
    integer t_dim1, t_offset, vl_dim1, vl_offset, vr_dim1, vr_offset, i__1, 
	    i__2, i__3;
    doublereal d__1, d__2, d__3, d__4;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, k;
    doublereal x[4]	/* was [2][2] */;
    integer j1, j2, n2, ii, ki, ip, is;
    doublereal wi, wr, rec, ulp, beta, emax;
    logical pair;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    logical allv;
    integer ierr;
    doublereal unfl, ovfl, smin;
    logical over;
    doublereal vmax;
    integer jnxt;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    doublereal scale;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphdgemv_(char *, integer *, integer *, 
	    doublereal *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, doublereal *, integer *);
    doublereal remax;
    extern /* Subroutine */ int igraphdcopy_(integer *, doublereal *, integer *, 
	    doublereal *, integer *);
    logical leftv, bothv;
    extern /* Subroutine */ int igraphdaxpy_(integer *, doublereal *, doublereal *, 
	    integer *, doublereal *, integer *);
    doublereal vcrit;
    logical somev;
    doublereal xnorm;
    extern /* Subroutine */ int igraphdlaln2_(logical *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, doublereal *,
	     doublereal *, doublereal *, integer *, doublereal *, doublereal *
	    , doublereal *, integer *, doublereal *, doublereal *, integer *),
	     igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern integer igraphidamax_(integer *, doublereal *, integer *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum;
    logical rightv;
    doublereal smlnum;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Decode and test the input parameters   

       Parameter adjustments */
    --select;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    vl_dim1 = *ldvl;
    vl_offset = 1 + vl_dim1;
    vl -= vl_offset;
    vr_dim1 = *ldvr;
    vr_offset = 1 + vr_dim1;
    vr -= vr_offset;
    --work;

    /* Function Body */
    bothv = igraphlsame_(side, "B");
    rightv = igraphlsame_(side, "R") || bothv;
    leftv = igraphlsame_(side, "L") || bothv;

    allv = igraphlsame_(howmny, "A");
    over = igraphlsame_(howmny, "B");
    somev = igraphlsame_(howmny, "S");

    *info = 0;
    if (! rightv && ! leftv) {
	*info = -1;
    } else if (! allv && ! over && ! somev) {
	*info = -2;
    } else if (*n < 0) {
	*info = -4;
    } else if (*ldt < max(1,*n)) {
	*info = -6;
    } else if (*ldvl < 1 || leftv && *ldvl < *n) {
	*info = -8;
    } else if (*ldvr < 1 || rightv && *ldvr < *n) {
	*info = -10;
    } else {

/*        Set M to the number of columns required to store the selected   
          eigenvectors, standardize the array SELECT if necessary, and   
          test MM. */

	if (somev) {
	    *m = 0;
	    pair = FALSE_;
	    i__1 = *n;
	    for (j = 1; j <= i__1; ++j) {
		if (pair) {
		    pair = FALSE_;
		    select[j] = FALSE_;
		} else {
		    if (j < *n) {
			if (t[j + 1 + j * t_dim1] == 0.) {
			    if (select[j]) {
				++(*m);
			    }
			} else {
			    pair = TRUE_;
			    if (select[j] || select[j + 1]) {
				select[j] = TRUE_;
				*m += 2;
			    }
			}
		    } else {
			if (select[*n]) {
			    ++(*m);
			}
		    }
		}
/* L10: */
	    }
	} else {
	    *m = *n;
	}

	if (*mm < *m) {
	    *info = -11;
	}
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DTREVC", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0) {
	return 0;
    }

/*     Set the constants to control overflow. */

    unfl = igraphdlamch_("Safe minimum");
    ovfl = 1. / unfl;
    igraphdlabad_(&unfl, &ovfl);
    ulp = igraphdlamch_("Precision");
    smlnum = unfl * (*n / ulp);
    bignum = (1. - ulp) / smlnum;

/*     Compute 1-norm of each column of strictly upper triangular   
       part of T to control overflow in triangular solver. */

    work[1] = 0.;
    i__1 = *n;
    for (j = 2; j <= i__1; ++j) {
	work[j] = 0.;
	i__2 = j - 1;
	for (i__ = 1; i__ <= i__2; ++i__) {
	    work[j] += (d__1 = t[i__ + j * t_dim1], abs(d__1));
/* L20: */
	}
/* L30: */
    }

/*     Index IP is used to specify the real or complex eigenvalue:   
         IP = 0, real eigenvalue,   
              1, first of conjugate complex pair: (wr,wi)   
             -1, second of conjugate complex pair: (wr,wi) */

    n2 = *n << 1;

    if (rightv) {

/*        Compute right eigenvectors. */

	ip = 0;
	is = *m;
	for (ki = *n; ki >= 1; --ki) {

	    if (ip == 1) {
		goto L130;
	    }
	    if (ki == 1) {
		goto L40;
	    }
	    if (t[ki + (ki - 1) * t_dim1] == 0.) {
		goto L40;
	    }
	    ip = -1;

L40:
	    if (somev) {
		if (ip == 0) {
		    if (! select[ki]) {
			goto L130;
		    }
		} else {
		    if (! select[ki - 1]) {
			goto L130;
		    }
		}
	    }

/*           Compute the KI-th eigenvalue (WR,WI). */

	    wr = t[ki + ki * t_dim1];
	    wi = 0.;
	    if (ip != 0) {
		wi = sqrt((d__1 = t[ki + (ki - 1) * t_dim1], abs(d__1))) * 
			sqrt((d__2 = t[ki - 1 + ki * t_dim1], abs(d__2)));
	    }
/* Computing MAX */
	    d__1 = ulp * (abs(wr) + abs(wi));
	    smin = max(d__1,smlnum);

	    if (ip == 0) {

/*              Real right eigenvector */

		work[ki + *n] = 1.;

/*              Form right-hand side */

		i__1 = ki - 1;
		for (k = 1; k <= i__1; ++k) {
		    work[k + *n] = -t[k + ki * t_dim1];
/* L50: */
		}

/*              Solve the upper quasi-triangular system:   
                   (T(1:KI-1,1:KI-1) - WR)*X = SCALE*WORK. */

		jnxt = ki - 1;
		for (j = ki - 1; j >= 1; --j) {
		    if (j > jnxt) {
			goto L60;
		    }
		    j1 = j;
		    j2 = j;
		    jnxt = j - 1;
		    if (j > 1) {
			if (t[j + (j - 1) * t_dim1] != 0.) {
			    j1 = j - 1;
			    jnxt = j - 2;
			}
		    }

		    if (j1 == j2) {

/*                    1-by-1 diagonal block */

			igraphdlaln2_(&c_false, &c__1, &c__1, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &c_b25, x, &c__2, &scale, &xnorm, 
				&ierr);

/*                    Scale X(1,1) to avoid overflow when updating   
                      the right-hand side. */

			if (xnorm > 1.) {
			    if (work[j] > bignum / xnorm) {
				x[0] /= xnorm;
				scale /= xnorm;
			    }
			}

/*                    Scale if necessary */

			if (scale != 1.) {
			    igraphdscal_(&ki, &scale, &work[*n + 1], &c__1);
			}
			work[j + *n] = x[0];

/*                    Update right-hand side */

			i__1 = j - 1;
			d__1 = -x[0];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				*n + 1], &c__1);

		    } else {

/*                    2-by-2 diagonal block */

			igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b22, &t[j - 
				1 + (j - 1) * t_dim1], ldt, &c_b22, &c_b22, &
				work[j - 1 + *n], n, &wr, &c_b25, x, &c__2, &
				scale, &xnorm, &ierr);

/*                    Scale X(1,1) and X(2,1) to avoid overflow when   
                      updating the right-hand side. */

			if (xnorm > 1.) {
/* Computing MAX */
			    d__1 = work[j - 1], d__2 = work[j];
			    beta = max(d__1,d__2);
			    if (beta > bignum / xnorm) {
				x[0] /= xnorm;
				x[1] /= xnorm;
				scale /= xnorm;
			    }
			}

/*                    Scale if necessary */

			if (scale != 1.) {
			    igraphdscal_(&ki, &scale, &work[*n + 1], &c__1);
			}
			work[j - 1 + *n] = x[0];
			work[j + *n] = x[1];

/*                    Update right-hand side */

			i__1 = j - 2;
			d__1 = -x[0];
			igraphdaxpy_(&i__1, &d__1, &t[(j - 1) * t_dim1 + 1], &c__1, 
				&work[*n + 1], &c__1);
			i__1 = j - 2;
			d__1 = -x[1];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				*n + 1], &c__1);
		    }
L60:
		    ;
		}

/*              Copy the vector x or Q*x to VR and normalize. */

		if (! over) {
		    igraphdcopy_(&ki, &work[*n + 1], &c__1, &vr[is * vr_dim1 + 1], &
			    c__1);

		    ii = igraphidamax_(&ki, &vr[is * vr_dim1 + 1], &c__1);
		    remax = 1. / (d__1 = vr[ii + is * vr_dim1], abs(d__1));
		    igraphdscal_(&ki, &remax, &vr[is * vr_dim1 + 1], &c__1);

		    i__1 = *n;
		    for (k = ki + 1; k <= i__1; ++k) {
			vr[k + is * vr_dim1] = 0.;
/* L70: */
		    }
		} else {
		    if (ki > 1) {
			i__1 = ki - 1;
			igraphdgemv_("N", n, &i__1, &c_b22, &vr[vr_offset], ldvr, &
				work[*n + 1], &c__1, &work[ki + *n], &vr[ki * 
				vr_dim1 + 1], &c__1);
		    }

		    ii = igraphidamax_(n, &vr[ki * vr_dim1 + 1], &c__1);
		    remax = 1. / (d__1 = vr[ii + ki * vr_dim1], abs(d__1));
		    igraphdscal_(n, &remax, &vr[ki * vr_dim1 + 1], &c__1);
		}

	    } else {

/*              Complex right eigenvector.   

                Initial solve   
                  [ (T(KI-1,KI-1) T(KI-1,KI) ) - (WR + I* WI)]*X = 0.   
                  [ (T(KI,KI-1)   T(KI,KI)   )               ] */

		if ((d__1 = t[ki - 1 + ki * t_dim1], abs(d__1)) >= (d__2 = t[
			ki + (ki - 1) * t_dim1], abs(d__2))) {
		    work[ki - 1 + *n] = 1.;
		    work[ki + n2] = wi / t[ki - 1 + ki * t_dim1];
		} else {
		    work[ki - 1 + *n] = -wi / t[ki + (ki - 1) * t_dim1];
		    work[ki + n2] = 1.;
		}
		work[ki + *n] = 0.;
		work[ki - 1 + n2] = 0.;

/*              Form right-hand side */

		i__1 = ki - 2;
		for (k = 1; k <= i__1; ++k) {
		    work[k + *n] = -work[ki - 1 + *n] * t[k + (ki - 1) * 
			    t_dim1];
		    work[k + n2] = -work[ki + n2] * t[k + ki * t_dim1];
/* L80: */
		}

/*              Solve upper quasi-triangular system:   
                (T(1:KI-2,1:KI-2) - (WR+i*WI))*X = SCALE*(WORK+i*WORK2) */

		jnxt = ki - 2;
		for (j = ki - 2; j >= 1; --j) {
		    if (j > jnxt) {
			goto L90;
		    }
		    j1 = j;
		    j2 = j;
		    jnxt = j - 1;
		    if (j > 1) {
			if (t[j + (j - 1) * t_dim1] != 0.) {
			    j1 = j - 1;
			    jnxt = j - 2;
			}
		    }

		    if (j1 == j2) {

/*                    1-by-1 diagonal block */

			igraphdlaln2_(&c_false, &c__1, &c__2, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &wi, x, &c__2, &scale, &xnorm, &
				ierr);

/*                    Scale X(1,1) and X(1,2) to avoid overflow when   
                      updating the right-hand side. */

			if (xnorm > 1.) {
			    if (work[j] > bignum / xnorm) {
				x[0] /= xnorm;
				x[2] /= xnorm;
				scale /= xnorm;
			    }
			}

/*                    Scale if necessary */

			if (scale != 1.) {
			    igraphdscal_(&ki, &scale, &work[*n + 1], &c__1);
			    igraphdscal_(&ki, &scale, &work[n2 + 1], &c__1);
			}
			work[j + *n] = x[0];
			work[j + n2] = x[2];

/*                    Update the right-hand side */

			i__1 = j - 1;
			d__1 = -x[0];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				*n + 1], &c__1);
			i__1 = j - 1;
			d__1 = -x[2];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				n2 + 1], &c__1);

		    } else {

/*                    2-by-2 diagonal block */

			igraphdlaln2_(&c_false, &c__2, &c__2, &smin, &c_b22, &t[j - 
				1 + (j - 1) * t_dim1], ldt, &c_b22, &c_b22, &
				work[j - 1 + *n], n, &wr, &wi, x, &c__2, &
				scale, &xnorm, &ierr);

/*                    Scale X to avoid overflow when updating   
                      the right-hand side. */

			if (xnorm > 1.) {
/* Computing MAX */
			    d__1 = work[j - 1], d__2 = work[j];
			    beta = max(d__1,d__2);
			    if (beta > bignum / xnorm) {
				rec = 1. / xnorm;
				x[0] *= rec;
				x[2] *= rec;
				x[1] *= rec;
				x[3] *= rec;
				scale *= rec;
			    }
			}

/*                    Scale if necessary */

			if (scale != 1.) {
			    igraphdscal_(&ki, &scale, &work[*n + 1], &c__1);
			    igraphdscal_(&ki, &scale, &work[n2 + 1], &c__1);
			}
			work[j - 1 + *n] = x[0];
			work[j + *n] = x[1];
			work[j - 1 + n2] = x[2];
			work[j + n2] = x[3];

/*                    Update the right-hand side */

			i__1 = j - 2;
			d__1 = -x[0];
			igraphdaxpy_(&i__1, &d__1, &t[(j - 1) * t_dim1 + 1], &c__1, 
				&work[*n + 1], &c__1);
			i__1 = j - 2;
			d__1 = -x[1];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				*n + 1], &c__1);
			i__1 = j - 2;
			d__1 = -x[2];
			igraphdaxpy_(&i__1, &d__1, &t[(j - 1) * t_dim1 + 1], &c__1, 
				&work[n2 + 1], &c__1);
			i__1 = j - 2;
			d__1 = -x[3];
			igraphdaxpy_(&i__1, &d__1, &t[j * t_dim1 + 1], &c__1, &work[
				n2 + 1], &c__1);
		    }
L90:
		    ;
		}

/*              Copy the vector x or Q*x to VR and normalize. */

		if (! over) {
		    igraphdcopy_(&ki, &work[*n + 1], &c__1, &vr[(is - 1) * vr_dim1 
			    + 1], &c__1);
		    igraphdcopy_(&ki, &work[n2 + 1], &c__1, &vr[is * vr_dim1 + 1], &
			    c__1);

		    emax = 0.;
		    i__1 = ki;
		    for (k = 1; k <= i__1; ++k) {
/* Computing MAX */
			d__3 = emax, d__4 = (d__1 = vr[k + (is - 1) * vr_dim1]
				, abs(d__1)) + (d__2 = vr[k + is * vr_dim1], 
				abs(d__2));
			emax = max(d__3,d__4);
/* L100: */
		    }

		    remax = 1. / emax;
		    igraphdscal_(&ki, &remax, &vr[(is - 1) * vr_dim1 + 1], &c__1);
		    igraphdscal_(&ki, &remax, &vr[is * vr_dim1 + 1], &c__1);

		    i__1 = *n;
		    for (k = ki + 1; k <= i__1; ++k) {
			vr[k + (is - 1) * vr_dim1] = 0.;
			vr[k + is * vr_dim1] = 0.;
/* L110: */
		    }

		} else {

		    if (ki > 2) {
			i__1 = ki - 2;
			igraphdgemv_("N", n, &i__1, &c_b22, &vr[vr_offset], ldvr, &
				work[*n + 1], &c__1, &work[ki - 1 + *n], &vr[(
				ki - 1) * vr_dim1 + 1], &c__1);
			i__1 = ki - 2;
			igraphdgemv_("N", n, &i__1, &c_b22, &vr[vr_offset], ldvr, &
				work[n2 + 1], &c__1, &work[ki + n2], &vr[ki * 
				vr_dim1 + 1], &c__1);
		    } else {
			igraphdscal_(n, &work[ki - 1 + *n], &vr[(ki - 1) * vr_dim1 
				+ 1], &c__1);
			igraphdscal_(n, &work[ki + n2], &vr[ki * vr_dim1 + 1], &
				c__1);
		    }

		    emax = 0.;
		    i__1 = *n;
		    for (k = 1; k <= i__1; ++k) {
/* Computing MAX */
			d__3 = emax, d__4 = (d__1 = vr[k + (ki - 1) * vr_dim1]
				, abs(d__1)) + (d__2 = vr[k + ki * vr_dim1], 
				abs(d__2));
			emax = max(d__3,d__4);
/* L120: */
		    }
		    remax = 1. / emax;
		    igraphdscal_(n, &remax, &vr[(ki - 1) * vr_dim1 + 1], &c__1);
		    igraphdscal_(n, &remax, &vr[ki * vr_dim1 + 1], &c__1);
		}
	    }

	    --is;
	    if (ip != 0) {
		--is;
	    }
L130:
	    if (ip == 1) {
		ip = 0;
	    }
	    if (ip == -1) {
		ip = 1;
	    }
/* L140: */
	}
    }

    if (leftv) {

/*        Compute left eigenvectors. */

	ip = 0;
	is = 1;
	i__1 = *n;
	for (ki = 1; ki <= i__1; ++ki) {

	    if (ip == -1) {
		goto L250;
	    }
	    if (ki == *n) {
		goto L150;
	    }
	    if (t[ki + 1 + ki * t_dim1] == 0.) {
		goto L150;
	    }
	    ip = 1;

L150:
	    if (somev) {
		if (! select[ki]) {
		    goto L250;
		}
	    }

/*           Compute the KI-th eigenvalue (WR,WI). */

	    wr = t[ki + ki * t_dim1];
	    wi = 0.;
	    if (ip != 0) {
		wi = sqrt((d__1 = t[ki + (ki + 1) * t_dim1], abs(d__1))) * 
			sqrt((d__2 = t[ki + 1 + ki * t_dim1], abs(d__2)));
	    }
/* Computing MAX */
	    d__1 = ulp * (abs(wr) + abs(wi));
	    smin = max(d__1,smlnum);

	    if (ip == 0) {

/*              Real left eigenvector. */

		work[ki + *n] = 1.;

/*              Form right-hand side */

		i__2 = *n;
		for (k = ki + 1; k <= i__2; ++k) {
		    work[k + *n] = -t[ki + k * t_dim1];
/* L160: */
		}

/*              Solve the quasi-triangular system:   
                   (T(KI+1:N,KI+1:N) - WR)**T*X = SCALE*WORK */

		vmax = 1.;
		vcrit = bignum;

		jnxt = ki + 1;
		i__2 = *n;
		for (j = ki + 1; j <= i__2; ++j) {
		    if (j < jnxt) {
			goto L170;
		    }
		    j1 = j;
		    j2 = j;
		    jnxt = j + 1;
		    if (j < *n) {
			if (t[j + 1 + j * t_dim1] != 0.) {
			    j2 = j + 1;
			    jnxt = j + 2;
			}
		    }

		    if (j1 == j2) {

/*                    1-by-1 diagonal block   

                      Scale if necessary to avoid overflow when forming   
                      the right-hand side. */

			if (work[j] > vcrit) {
			    rec = 1. / vmax;
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + *n], &c__1);
			    vmax = 1.;
			    vcrit = bignum;
			}

			i__3 = j - ki - 1;
			work[j + *n] -= igraphddot_(&i__3, &t[ki + 1 + j * t_dim1], 
				&c__1, &work[ki + 1 + *n], &c__1);

/*                    Solve (T(J,J)-WR)**T*X = WORK */

			igraphdlaln2_(&c_false, &c__1, &c__1, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &c_b25, x, &c__2, &scale, &xnorm, 
				&ierr);

/*                    Scale if necessary */

			if (scale != 1.) {
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + *n], &c__1);
			}
			work[j + *n] = x[0];
/* Computing MAX */
			d__2 = (d__1 = work[j + *n], abs(d__1));
			vmax = max(d__2,vmax);
			vcrit = bignum / vmax;

		    } else {

/*                    2-by-2 diagonal block   

                      Scale if necessary to avoid overflow when forming   
                      the right-hand side.   

   Computing MAX */
			d__1 = work[j], d__2 = work[j + 1];
			beta = max(d__1,d__2);
			if (beta > vcrit) {
			    rec = 1. / vmax;
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + *n], &c__1);
			    vmax = 1.;
			    vcrit = bignum;
			}

			i__3 = j - ki - 1;
			work[j + *n] -= igraphddot_(&i__3, &t[ki + 1 + j * t_dim1], 
				&c__1, &work[ki + 1 + *n], &c__1);

			i__3 = j - ki - 1;
			work[j + 1 + *n] -= igraphddot_(&i__3, &t[ki + 1 + (j + 1) *
				 t_dim1], &c__1, &work[ki + 1 + *n], &c__1);

/*                    Solve   
                        [T(J,J)-WR   T(J,J+1)     ]**T * X = SCALE*( WORK1 )   
                        [T(J+1,J)    T(J+1,J+1)-WR]                ( WORK2 ) */

			igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &c_b25, x, &c__2, &scale, &xnorm, 
				&ierr);

/*                    Scale if necessary */

			if (scale != 1.) {
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + *n], &c__1);
			}
			work[j + *n] = x[0];
			work[j + 1 + *n] = x[1];

/* Computing MAX */
			d__3 = (d__1 = work[j + *n], abs(d__1)), d__4 = (d__2 
				= work[j + 1 + *n], abs(d__2)), d__3 = max(
				d__3,d__4);
			vmax = max(d__3,vmax);
			vcrit = bignum / vmax;

		    }
L170:
		    ;
		}

/*              Copy the vector x or Q*x to VL and normalize. */

		if (! over) {
		    i__2 = *n - ki + 1;
		    igraphdcopy_(&i__2, &work[ki + *n], &c__1, &vl[ki + is * 
			    vl_dim1], &c__1);

		    i__2 = *n - ki + 1;
		    ii = igraphidamax_(&i__2, &vl[ki + is * vl_dim1], &c__1) + ki - 
			    1;
		    remax = 1. / (d__1 = vl[ii + is * vl_dim1], abs(d__1));
		    i__2 = *n - ki + 1;
		    igraphdscal_(&i__2, &remax, &vl[ki + is * vl_dim1], &c__1);

		    i__2 = ki - 1;
		    for (k = 1; k <= i__2; ++k) {
			vl[k + is * vl_dim1] = 0.;
/* L180: */
		    }

		} else {

		    if (ki < *n) {
			i__2 = *n - ki;
			igraphdgemv_("N", n, &i__2, &c_b22, &vl[(ki + 1) * vl_dim1 
				+ 1], ldvl, &work[ki + 1 + *n], &c__1, &work[
				ki + *n], &vl[ki * vl_dim1 + 1], &c__1);
		    }

		    ii = igraphidamax_(n, &vl[ki * vl_dim1 + 1], &c__1);
		    remax = 1. / (d__1 = vl[ii + ki * vl_dim1], abs(d__1));
		    igraphdscal_(n, &remax, &vl[ki * vl_dim1 + 1], &c__1);

		}

	    } else {

/*              Complex left eigenvector.   

                 Initial solve:   
                   ((T(KI,KI)    T(KI,KI+1) )**T - (WR - I* WI))*X = 0.   
                   ((T(KI+1,KI) T(KI+1,KI+1))                ) */

		if ((d__1 = t[ki + (ki + 1) * t_dim1], abs(d__1)) >= (d__2 = 
			t[ki + 1 + ki * t_dim1], abs(d__2))) {
		    work[ki + *n] = wi / t[ki + (ki + 1) * t_dim1];
		    work[ki + 1 + n2] = 1.;
		} else {
		    work[ki + *n] = 1.;
		    work[ki + 1 + n2] = -wi / t[ki + 1 + ki * t_dim1];
		}
		work[ki + 1 + *n] = 0.;
		work[ki + n2] = 0.;

/*              Form right-hand side */

		i__2 = *n;
		for (k = ki + 2; k <= i__2; ++k) {
		    work[k + *n] = -work[ki + *n] * t[ki + k * t_dim1];
		    work[k + n2] = -work[ki + 1 + n2] * t[ki + 1 + k * t_dim1]
			    ;
/* L190: */
		}

/*              Solve complex quasi-triangular system:   
                ( T(KI+2,N:KI+2,N) - (WR-i*WI) )*X = WORK1+i*WORK2 */

		vmax = 1.;
		vcrit = bignum;

		jnxt = ki + 2;
		i__2 = *n;
		for (j = ki + 2; j <= i__2; ++j) {
		    if (j < jnxt) {
			goto L200;
		    }
		    j1 = j;
		    j2 = j;
		    jnxt = j + 1;
		    if (j < *n) {
			if (t[j + 1 + j * t_dim1] != 0.) {
			    j2 = j + 1;
			    jnxt = j + 2;
			}
		    }

		    if (j1 == j2) {

/*                    1-by-1 diagonal block   

                      Scale if necessary to avoid overflow when   
                      forming the right-hand side elements. */

			if (work[j] > vcrit) {
			    rec = 1. / vmax;
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + *n], &c__1);
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + n2], &c__1);
			    vmax = 1.;
			    vcrit = bignum;
			}

			i__3 = j - ki - 2;
			work[j + *n] -= igraphddot_(&i__3, &t[ki + 2 + j * t_dim1], 
				&c__1, &work[ki + 2 + *n], &c__1);
			i__3 = j - ki - 2;
			work[j + n2] -= igraphddot_(&i__3, &t[ki + 2 + j * t_dim1], 
				&c__1, &work[ki + 2 + n2], &c__1);

/*                    Solve (T(J,J)-(WR-i*WI))*(X11+i*X12)= WK+I*WK2 */

			d__1 = -wi;
			igraphdlaln2_(&c_false, &c__1, &c__2, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &d__1, x, &c__2, &scale, &xnorm, &
				ierr);

/*                    Scale if necessary */

			if (scale != 1.) {
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + *n], &c__1);
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + n2], &c__1);
			}
			work[j + *n] = x[0];
			work[j + n2] = x[2];
/* Computing MAX */
			d__3 = (d__1 = work[j + *n], abs(d__1)), d__4 = (d__2 
				= work[j + n2], abs(d__2)), d__3 = max(d__3,
				d__4);
			vmax = max(d__3,vmax);
			vcrit = bignum / vmax;

		    } else {

/*                    2-by-2 diagonal block   

                      Scale if necessary to avoid overflow when forming   
                      the right-hand side elements.   

   Computing MAX */
			d__1 = work[j], d__2 = work[j + 1];
			beta = max(d__1,d__2);
			if (beta > vcrit) {
			    rec = 1. / vmax;
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + *n], &c__1);
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &rec, &work[ki + n2], &c__1);
			    vmax = 1.;
			    vcrit = bignum;
			}

			i__3 = j - ki - 2;
			work[j + *n] -= igraphddot_(&i__3, &t[ki + 2 + j * t_dim1], 
				&c__1, &work[ki + 2 + *n], &c__1);

			i__3 = j - ki - 2;
			work[j + n2] -= igraphddot_(&i__3, &t[ki + 2 + j * t_dim1], 
				&c__1, &work[ki + 2 + n2], &c__1);

			i__3 = j - ki - 2;
			work[j + 1 + *n] -= igraphddot_(&i__3, &t[ki + 2 + (j + 1) *
				 t_dim1], &c__1, &work[ki + 2 + *n], &c__1);

			i__3 = j - ki - 2;
			work[j + 1 + n2] -= igraphddot_(&i__3, &t[ki + 2 + (j + 1) *
				 t_dim1], &c__1, &work[ki + 2 + n2], &c__1);

/*                    Solve 2-by-2 complex linear equation   
                        ([T(j,j)   T(j,j+1)  ]**T-(wr-i*wi)*I)*X = SCALE*B   
                        ([T(j+1,j) T(j+1,j+1)]               ) */

			d__1 = -wi;
			igraphdlaln2_(&c_true, &c__2, &c__2, &smin, &c_b22, &t[j + 
				j * t_dim1], ldt, &c_b22, &c_b22, &work[j + *
				n], n, &wr, &d__1, x, &c__2, &scale, &xnorm, &
				ierr);

/*                    Scale if necessary */

			if (scale != 1.) {
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + *n], &c__1);
			    i__3 = *n - ki + 1;
			    igraphdscal_(&i__3, &scale, &work[ki + n2], &c__1);
			}
			work[j + *n] = x[0];
			work[j + n2] = x[2];
			work[j + 1 + *n] = x[1];
			work[j + 1 + n2] = x[3];
/* Computing MAX */
			d__1 = abs(x[0]), d__2 = abs(x[2]), d__1 = max(d__1,
				d__2), d__2 = abs(x[1]), d__1 = max(d__1,d__2)
				, d__2 = abs(x[3]), d__1 = max(d__1,d__2);
			vmax = max(d__1,vmax);
			vcrit = bignum / vmax;

		    }
L200:
		    ;
		}

/*              Copy the vector x or Q*x to VL and normalize. */

		if (! over) {
		    i__2 = *n - ki + 1;
		    igraphdcopy_(&i__2, &work[ki + *n], &c__1, &vl[ki + is * 
			    vl_dim1], &c__1);
		    i__2 = *n - ki + 1;
		    igraphdcopy_(&i__2, &work[ki + n2], &c__1, &vl[ki + (is + 1) * 
			    vl_dim1], &c__1);

		    emax = 0.;
		    i__2 = *n;
		    for (k = ki; k <= i__2; ++k) {
/* Computing MAX */
			d__3 = emax, d__4 = (d__1 = vl[k + is * vl_dim1], abs(
				d__1)) + (d__2 = vl[k + (is + 1) * vl_dim1], 
				abs(d__2));
			emax = max(d__3,d__4);
/* L220: */
		    }
		    remax = 1. / emax;
		    i__2 = *n - ki + 1;
		    igraphdscal_(&i__2, &remax, &vl[ki + is * vl_dim1], &c__1);
		    i__2 = *n - ki + 1;
		    igraphdscal_(&i__2, &remax, &vl[ki + (is + 1) * vl_dim1], &c__1)
			    ;

		    i__2 = ki - 1;
		    for (k = 1; k <= i__2; ++k) {
			vl[k + is * vl_dim1] = 0.;
			vl[k + (is + 1) * vl_dim1] = 0.;
/* L230: */
		    }
		} else {
		    if (ki < *n - 1) {
			i__2 = *n - ki - 1;
			igraphdgemv_("N", n, &i__2, &c_b22, &vl[(ki + 2) * vl_dim1 
				+ 1], ldvl, &work[ki + 2 + *n], &c__1, &work[
				ki + *n], &vl[ki * vl_dim1 + 1], &c__1);
			i__2 = *n - ki - 1;
			igraphdgemv_("N", n, &i__2, &c_b22, &vl[(ki + 2) * vl_dim1 
				+ 1], ldvl, &work[ki + 2 + n2], &c__1, &work[
				ki + 1 + n2], &vl[(ki + 1) * vl_dim1 + 1], &
				c__1);
		    } else {
			igraphdscal_(n, &work[ki + *n], &vl[ki * vl_dim1 + 1], &
				c__1);
			igraphdscal_(n, &work[ki + 1 + n2], &vl[(ki + 1) * vl_dim1 
				+ 1], &c__1);
		    }

		    emax = 0.;
		    i__2 = *n;
		    for (k = 1; k <= i__2; ++k) {
/* Computing MAX */
			d__3 = emax, d__4 = (d__1 = vl[k + ki * vl_dim1], abs(
				d__1)) + (d__2 = vl[k + (ki + 1) * vl_dim1], 
				abs(d__2));
			emax = max(d__3,d__4);
/* L240: */
		    }
		    remax = 1. / emax;
		    igraphdscal_(n, &remax, &vl[ki * vl_dim1 + 1], &c__1);
		    igraphdscal_(n, &remax, &vl[(ki + 1) * vl_dim1 + 1], &c__1);

		}

	    }

	    ++is;
	    if (ip != 0) {
		++is;
	    }
L250:
	    if (ip == -1) {
		ip = 0;
	    }
	    if (ip == 1) {
		ip = -1;
	    }

/* L260: */
	}

    }

    return 0;

/*     End of DTREVC */

} /* igraphdtrevc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrexc.c0000644000175100001710000003025500000000000024044 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static integer c__2 = 2;

/* > \brief \b DTREXC   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DTREXC + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DTREXC( COMPQ, N, T, LDT, Q, LDQ, IFST, ILST, WORK,   
                            INFO )   

         CHARACTER          COMPQ   
         INTEGER            IFST, ILST, INFO, LDQ, LDT, N   
         DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTREXC reorders the real Schur factorization of a real matrix   
   > A = Q*T*Q**T, so that the diagonal block of T with row index IFST is   
   > moved to row ILST.   
   >   
   > The real Schur form T is reordered by an orthogonal similarity   
   > transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors   
   > is updated by postmultiplying it with Z.   
   >   
   > T must be in Schur canonical form (as returned by DHSEQR), that is,   
   > block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each   
   > 2-by-2 diagonal block has its diagonal elements equal and its   
   > off-diagonal elements of opposite sign.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] COMPQ   
   > \verbatim   
   >          COMPQ is CHARACTER*1   
   >          = 'V':  update the matrix Q of Schur vectors;   
   >          = 'N':  do not update Q.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          On entry, the upper quasi-triangular matrix T, in Schur   
   >          Schur canonical form.   
   >          On exit, the reordered upper quasi-triangular matrix, again   
   >          in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] Q   
   > \verbatim   
   >          Q is DOUBLE PRECISION array, dimension (LDQ,N)   
   >          On entry, if COMPQ = 'V', the matrix Q of Schur vectors.   
   >          On exit, if COMPQ = 'V', Q has been postmultiplied by the   
   >          orthogonal transformation matrix Z which reorders T.   
   >          If COMPQ = 'N', Q is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDQ   
   > \verbatim   
   >          LDQ is INTEGER   
   >          The leading dimension of the array Q.  LDQ >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] IFST   
   > \verbatim   
   >          IFST is INTEGER   
   > \endverbatim   
   >   
   > \param[in,out] ILST   
   > \verbatim   
   >          ILST is INTEGER   
   >   
   >          Specify the reordering of the diagonal blocks of T.   
   >          The block with row index IFST is moved to row ILST, by a   
   >          sequence of transpositions between adjacent blocks.   
   >          On exit, if IFST pointed on entry to the second row of a   
   >          2-by-2 block, it is changed to point to the first row; ILST   
   >          always points to the first row of the block in its final   
   >          position (which may differ from its input value by +1 or -1).   
   >          1 <= IFST <= N; 1 <= ILST <= N.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0:  successful exit   
   >          < 0:  if INFO = -i, the i-th argument had an illegal value   
   >          = 1:  two adjacent blocks were too close to swap (the problem   
   >                is very ill-conditioned); T may have been partially   
   >                reordered, and ILST points to the first row of the   
   >                current position of the block being moved.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

    =====================================================================   
   Subroutine */ int igraphdtrexc_(char *compq, integer *n, doublereal *t, integer *
	ldt, doublereal *q, integer *ldq, integer *ifst, integer *ilst, 
	doublereal *work, integer *info)
{
    /* System generated locals */
    integer q_dim1, q_offset, t_dim1, t_offset, i__1;

    /* Local variables */
    integer nbf, nbl, here;
    extern logical igraphlsame_(char *, char *);
    logical wantq;
    extern /* Subroutine */ int igraphdlaexc_(logical *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *, integer *, integer 
	    *, doublereal *, integer *), igraphxerbla_(char *, integer *, ftnlen);
    integer nbnext;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Decode and test the input arguments.   

       Parameter adjustments */
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;
    --work;

    /* Function Body */
    *info = 0;
    wantq = igraphlsame_(compq, "V");
    if (! wantq && ! igraphlsame_(compq, "N")) {
	*info = -1;
    } else if (*n < 0) {
	*info = -2;
    } else if (*ldt < max(1,*n)) {
	*info = -4;
    } else if (*ldq < 1 || wantq && *ldq < max(1,*n)) {
	*info = -6;
    } else if (*ifst < 1 || *ifst > *n) {
	*info = -7;
    } else if (*ilst < 1 || *ilst > *n) {
	*info = -8;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DTREXC", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n <= 1) {
	return 0;
    }

/*     Determine the first row of specified block   
       and find out it is 1 by 1 or 2 by 2. */

    if (*ifst > 1) {
	if (t[*ifst + (*ifst - 1) * t_dim1] != 0.) {
	    --(*ifst);
	}
    }
    nbf = 1;
    if (*ifst < *n) {
	if (t[*ifst + 1 + *ifst * t_dim1] != 0.) {
	    nbf = 2;
	}
    }

/*     Determine the first row of the final block   
       and find out it is 1 by 1 or 2 by 2. */

    if (*ilst > 1) {
	if (t[*ilst + (*ilst - 1) * t_dim1] != 0.) {
	    --(*ilst);
	}
    }
    nbl = 1;
    if (*ilst < *n) {
	if (t[*ilst + 1 + *ilst * t_dim1] != 0.) {
	    nbl = 2;
	}
    }

    if (*ifst == *ilst) {
	return 0;
    }

    if (*ifst < *ilst) {

/*        Update ILST */

	if (nbf == 2 && nbl == 1) {
	    --(*ilst);
	}
	if (nbf == 1 && nbl == 2) {
	    ++(*ilst);
	}

	here = *ifst;

L10:

/*        Swap block with next one below */

	if (nbf == 1 || nbf == 2) {

/*           Current block either 1 by 1 or 2 by 2 */

	    nbnext = 1;
	    if (here + nbf + 1 <= *n) {
		if (t[here + nbf + 1 + (here + nbf) * t_dim1] != 0.) {
		    nbnext = 2;
		}
	    }
	    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &here, &
		    nbf, &nbnext, &work[1], info);
	    if (*info != 0) {
		*ilst = here;
		return 0;
	    }
	    here += nbnext;

/*           Test if 2 by 2 block breaks into two 1 by 1 blocks */

	    if (nbf == 2) {
		if (t[here + 1 + here * t_dim1] == 0.) {
		    nbf = 3;
		}
	    }

	} else {

/*           Current block consists of two 1 by 1 blocks each of which   
             must be swapped individually */

	    nbnext = 1;
	    if (here + 3 <= *n) {
		if (t[here + 3 + (here + 2) * t_dim1] != 0.) {
		    nbnext = 2;
		}
	    }
	    i__1 = here + 1;
	    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &i__1, &
		    c__1, &nbnext, &work[1], info);
	    if (*info != 0) {
		*ilst = here;
		return 0;
	    }
	    if (nbnext == 1) {

/*              Swap two 1 by 1 blocks, no problems possible */

		igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			here, &c__1, &nbnext, &work[1], info);
		++here;
	    } else {

/*              Recompute NBNEXT in case 2 by 2 split */

		if (t[here + 2 + (here + 1) * t_dim1] == 0.) {
		    nbnext = 1;
		}
		if (nbnext == 2) {

/*                 2 by 2 Block did not split */

		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    here, &c__1, &nbnext, &work[1], info);
		    if (*info != 0) {
			*ilst = here;
			return 0;
		    }
		    here += 2;
		} else {

/*                 2 by 2 Block did split */

		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    here, &c__1, &c__1, &work[1], info);
		    i__1 = here + 1;
		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    i__1, &c__1, &c__1, &work[1], info);
		    here += 2;
		}
	    }
	}
	if (here < *ilst) {
	    goto L10;
	}

    } else {

	here = *ifst;
L20:

/*        Swap block with next one above */

	if (nbf == 1 || nbf == 2) {

/*           Current block either 1 by 1 or 2 by 2 */

	    nbnext = 1;
	    if (here >= 3) {
		if (t[here - 1 + (here - 2) * t_dim1] != 0.) {
		    nbnext = 2;
		}
	    }
	    i__1 = here - nbnext;
	    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &i__1, &
		    nbnext, &nbf, &work[1], info);
	    if (*info != 0) {
		*ilst = here;
		return 0;
	    }
	    here -= nbnext;

/*           Test if 2 by 2 block breaks into two 1 by 1 blocks */

	    if (nbf == 2) {
		if (t[here + 1 + here * t_dim1] == 0.) {
		    nbf = 3;
		}
	    }

	} else {

/*           Current block consists of two 1 by 1 blocks each of which   
             must be swapped individually */

	    nbnext = 1;
	    if (here >= 3) {
		if (t[here - 1 + (here - 2) * t_dim1] != 0.) {
		    nbnext = 2;
		}
	    }
	    i__1 = here - nbnext;
	    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &i__1, &
		    nbnext, &c__1, &work[1], info);
	    if (*info != 0) {
		*ilst = here;
		return 0;
	    }
	    if (nbnext == 1) {

/*              Swap two 1 by 1 blocks, no problems possible */

		igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			here, &nbnext, &c__1, &work[1], info);
		--here;
	    } else {

/*              Recompute NBNEXT in case 2 by 2 split */

		if (t[here + (here - 1) * t_dim1] == 0.) {
		    nbnext = 1;
		}
		if (nbnext == 2) {

/*                 2 by 2 Block did not split */

		    i__1 = here - 1;
		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    i__1, &c__2, &c__1, &work[1], info);
		    if (*info != 0) {
			*ilst = here;
			return 0;
		    }
		    here += -2;
		} else {

/*                 2 by 2 Block did split */

		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    here, &c__1, &c__1, &work[1], info);
		    i__1 = here - 1;
		    igraphdlaexc_(&wantq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    i__1, &c__1, &c__1, &work[1], info);
		    here += -2;
		}
	    }
	}
	if (here > *ilst) {
	    goto L20;
	}
    }
    *ilst = here;

    return 0;

/*     End of DTREXC */

} /* igraphdtrexc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrmm.c0000644000175100001710000003167200000000000023702 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DTRMM   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DTRMM(SIDE,UPLO,TRANSA,DIAG,M,N,ALPHA,A,LDA,B,LDB)   

         DOUBLE PRECISION ALPHA   
         INTEGER LDA,LDB,M,N   
         CHARACTER DIAG,SIDE,TRANSA,UPLO   
         DOUBLE PRECISION A(LDA,*),B(LDB,*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRMM  performs one of the matrix-matrix operations   
   >   
   >    B := alpha*op( A )*B,   or   B := alpha*B*op( A ),   
   >   
   > where  alpha  is a scalar,  B  is an m by n matrix,  A  is a unit, or   
   > non-unit,  upper or lower triangular matrix  and  op( A )  is one  of   
   >   
   >    op( A ) = A   or   op( A ) = A**T.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >           On entry,  SIDE specifies whether  op( A ) multiplies B from   
   >           the left or right as follows:   
   >   
   >              SIDE = 'L' or 'l'   B := alpha*op( A )*B.   
   >   
   >              SIDE = 'R' or 'r'   B := alpha*B*op( A ).   
   > \endverbatim   
   >   
   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the matrix A is an upper or   
   >           lower triangular matrix as follows:   
   >   
   >              UPLO = 'U' or 'u'   A is an upper triangular matrix.   
   >   
   >              UPLO = 'L' or 'l'   A is a lower triangular matrix.   
   > \endverbatim   
   >   
   > \param[in] TRANSA   
   > \verbatim   
   >          TRANSA is CHARACTER*1   
   >           On entry, TRANSA specifies the form of op( A ) to be used in   
   >           the matrix multiplication as follows:   
   >   
   >              TRANSA = 'N' or 'n'   op( A ) = A.   
   >   
   >              TRANSA = 'T' or 't'   op( A ) = A**T.   
   >   
   >              TRANSA = 'C' or 'c'   op( A ) = A**T.   
   > \endverbatim   
   >   
   > \param[in] DIAG   
   > \verbatim   
   >          DIAG is CHARACTER*1   
   >           On entry, DIAG specifies whether or not A is unit triangular   
   >           as follows:   
   >   
   >              DIAG = 'U' or 'u'   A is assumed to be unit triangular.   
   >   
   >              DIAG = 'N' or 'n'   A is not assumed to be unit   
   >                                  triangular.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry, M specifies the number of rows of B. M must be at   
   >           least zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the number of columns of B.  N must be   
   >           at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry,  ALPHA specifies the scalar  alpha. When  alpha is   
   >           zero then  A is not referenced and  B need not be set before   
   >           entry.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >           A is DOUBLE PRECISION array, dimension ( LDA, k ), where k is m   
   >           when  SIDE = 'L' or 'l'  and is  n  when  SIDE = 'R' or 'r'.   
   >           Before entry  with  UPLO = 'U' or 'u',  the  leading  k by k   
   >           upper triangular part of the array  A must contain the upper   
   >           triangular matrix  and the strictly lower triangular part of   
   >           A is not referenced.   
   >           Before entry  with  UPLO = 'L' or 'l',  the  leading  k by k   
   >           lower triangular part of the array  A must contain the lower   
   >           triangular matrix  and the strictly upper triangular part of   
   >           A is not referenced.   
   >           Note that when  DIAG = 'U' or 'u',  the diagonal elements of   
   >           A  are not referenced either,  but are assumed to be  unity.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program.  When  SIDE = 'L' or 'l'  then   
   >           LDA  must be at least  max( 1, m ),  when  SIDE = 'R' or 'r'   
   >           then LDA must be at least max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension ( LDB, N )   
   >           Before entry,  the leading  m by n part of the array  B must   
   >           contain the matrix  B,  and  on exit  is overwritten  by the   
   >           transformed matrix.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >           On entry, LDB specifies the first dimension of B as declared   
   >           in  the  calling  (sub)  program.   LDB  must  be  at  least   
   >           max( 1, m ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level3   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 3 Blas routine.   
   >   
   >  -- Written on 8-February-1989.   
   >     Jack Dongarra, Argonne National Laboratory.   
   >     Iain Duff, AERE Harwell.   
   >     Jeremy Du Croz, Numerical Algorithms Group Ltd.   
   >     Sven Hammarling, Numerical Algorithms Group Ltd.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrmm_(char *side, char *uplo, char *transa, char *diag, 
	integer *m, integer *n, doublereal *alpha, doublereal *a, integer *
	lda, doublereal *b, integer *ldb)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j, k, info;
    doublereal temp;
    logical lside;
    extern logical igraphlsame_(char *, char *);
    integer nrowa;
    logical upper;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical nounit;


/*  -- Reference BLAS level3 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;

    /* Function Body */
    lside = igraphlsame_(side, "L");
    if (lside) {
	nrowa = *m;
    } else {
	nrowa = *n;
    }
    nounit = igraphlsame_(diag, "N");
    upper = igraphlsame_(uplo, "U");

    info = 0;
    if (! lside && ! igraphlsame_(side, "R")) {
	info = 1;
    } else if (! upper && ! igraphlsame_(uplo, "L")) {
	info = 2;
    } else if (! igraphlsame_(transa, "N") && ! igraphlsame_(transa,
	     "T") && ! igraphlsame_(transa, "C")) {
	info = 3;
    } else if (! igraphlsame_(diag, "U") && ! igraphlsame_(diag, 
	    "N")) {
	info = 4;
    } else if (*m < 0) {
	info = 5;
    } else if (*n < 0) {
	info = 6;
    } else if (*lda < max(1,nrowa)) {
	info = 9;
    } else if (*ldb < max(1,*m)) {
	info = 11;
    }
    if (info != 0) {
	igraphxerbla_("DTRMM ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0) {
	return 0;
    }

/*     And when  alpha.eq.zero. */

    if (*alpha == 0.) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		b[i__ + j * b_dim1] = 0.;
/* L10: */
	    }
/* L20: */
	}
	return 0;
    }

/*     Start the operations. */

    if (lside) {
	if (igraphlsame_(transa, "N")) {

/*           Form  B := alpha*A*B. */

	    if (upper) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (k = 1; k <= i__2; ++k) {
			if (b[k + j * b_dim1] != 0.) {
			    temp = *alpha * b[k + j * b_dim1];
			    i__3 = k - 1;
			    for (i__ = 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] += temp * a[i__ + k * 
					a_dim1];
/* L30: */
			    }
			    if (nounit) {
				temp *= a[k + k * a_dim1];
			    }
			    b[k + j * b_dim1] = temp;
			}
/* L40: */
		    }
/* L50: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    for (k = *m; k >= 1; --k) {
			if (b[k + j * b_dim1] != 0.) {
			    temp = *alpha * b[k + j * b_dim1];
			    b[k + j * b_dim1] = temp;
			    if (nounit) {
				b[k + j * b_dim1] *= a[k + k * a_dim1];
			    }
			    i__2 = *m;
			    for (i__ = k + 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] += temp * a[i__ + k * 
					a_dim1];
/* L60: */
			    }
			}
/* L70: */
		    }
/* L80: */
		}
	    }
	} else {

/*           Form  B := alpha*A**T*B. */

	    if (upper) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    for (i__ = *m; i__ >= 1; --i__) {
			temp = b[i__ + j * b_dim1];
			if (nounit) {
			    temp *= a[i__ + i__ * a_dim1];
			}
			i__2 = i__ - 1;
			for (k = 1; k <= i__2; ++k) {
			    temp += a[k + i__ * a_dim1] * b[k + j * b_dim1];
/* L90: */
			}
			b[i__ + j * b_dim1] = *alpha * temp;
/* L100: */
		    }
/* L110: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			temp = b[i__ + j * b_dim1];
			if (nounit) {
			    temp *= a[i__ + i__ * a_dim1];
			}
			i__3 = *m;
			for (k = i__ + 1; k <= i__3; ++k) {
			    temp += a[k + i__ * a_dim1] * b[k + j * b_dim1];
/* L120: */
			}
			b[i__ + j * b_dim1] = *alpha * temp;
/* L130: */
		    }
/* L140: */
		}
	    }
	}
    } else {
	if (igraphlsame_(transa, "N")) {

/*           Form  B := alpha*B*A. */

	    if (upper) {
		for (j = *n; j >= 1; --j) {
		    temp = *alpha;
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    i__1 = *m;
		    for (i__ = 1; i__ <= i__1; ++i__) {
			b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
/* L150: */
		    }
		    i__1 = j - 1;
		    for (k = 1; k <= i__1; ++k) {
			if (a[k + j * a_dim1] != 0.) {
			    temp = *alpha * a[k + j * a_dim1];
			    i__2 = *m;
			    for (i__ = 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] += temp * b[i__ + k * 
					b_dim1];
/* L160: */
			    }
			}
/* L170: */
		    }
/* L180: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    temp = *alpha;
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
/* L190: */
		    }
		    i__2 = *n;
		    for (k = j + 1; k <= i__2; ++k) {
			if (a[k + j * a_dim1] != 0.) {
			    temp = *alpha * a[k + j * a_dim1];
			    i__3 = *m;
			    for (i__ = 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] += temp * b[i__ + k * 
					b_dim1];
/* L200: */
			    }
			}
/* L210: */
		    }
/* L220: */
		}
	    }
	} else {

/*           Form  B := alpha*B*A**T. */

	    if (upper) {
		i__1 = *n;
		for (k = 1; k <= i__1; ++k) {
		    i__2 = k - 1;
		    for (j = 1; j <= i__2; ++j) {
			if (a[j + k * a_dim1] != 0.) {
			    temp = *alpha * a[j + k * a_dim1];
			    i__3 = *m;
			    for (i__ = 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] += temp * b[i__ + k * 
					b_dim1];
/* L230: */
			    }
			}
/* L240: */
		    }
		    temp = *alpha;
		    if (nounit) {
			temp *= a[k + k * a_dim1];
		    }
		    if (temp != 1.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
/* L250: */
			}
		    }
/* L260: */
		}
	    } else {
		for (k = *n; k >= 1; --k) {
		    i__1 = *n;
		    for (j = k + 1; j <= i__1; ++j) {
			if (a[j + k * a_dim1] != 0.) {
			    temp = *alpha * a[j + k * a_dim1];
			    i__2 = *m;
			    for (i__ = 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] += temp * b[i__ + k * 
					b_dim1];
/* L270: */
			    }
			}
/* L280: */
		    }
		    temp = *alpha;
		    if (nounit) {
			temp *= a[k + k * a_dim1];
		    }
		    if (temp != 1.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
/* L290: */
			}
		    }
/* L300: */
		}
	    }
	}
    }

    return 0;

/*     End of DTRMM . */

} /* igraphdtrmm_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrmv.c0000644000175100001710000002344400000000000023711 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DTRMV   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DTRMV(UPLO,TRANS,DIAG,N,A,LDA,X,INCX)   

         INTEGER INCX,LDA,N   
         CHARACTER DIAG,TRANS,UPLO   
         DOUBLE PRECISION A(LDA,*),X(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRMV  performs one of the matrix-vector operations   
   >   
   >    x := A*x,   or   x := A**T*x,   
   >   
   > where x is an n element vector and  A is an n by n unit, or non-unit,   
   > upper or lower triangular matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the matrix is an upper or   
   >           lower triangular matrix as follows:   
   >   
   >              UPLO = 'U' or 'u'   A is an upper triangular matrix.   
   >   
   >              UPLO = 'L' or 'l'   A is a lower triangular matrix.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >           On entry, TRANS specifies the operation to be performed as   
   >           follows:   
   >   
   >              TRANS = 'N' or 'n'   x := A*x.   
   >   
   >              TRANS = 'T' or 't'   x := A**T*x.   
   >   
   >              TRANS = 'C' or 'c'   x := A**T*x.   
   > \endverbatim   
   >   
   > \param[in] DIAG   
   > \verbatim   
   >          DIAG is CHARACTER*1   
   >           On entry, DIAG specifies whether or not A is unit   
   >           triangular as follows:   
   >   
   >              DIAG = 'U' or 'u'   A is assumed to be unit triangular.   
   >   
   >              DIAG = 'N' or 'n'   A is not assumed to be unit   
   >                                  triangular.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the order of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry with  UPLO = 'U' or 'u', the leading n by n   
   >           upper triangular part of the array A must contain the upper   
   >           triangular matrix and the strictly lower triangular part of   
   >           A is not referenced.   
   >           Before entry with UPLO = 'L' or 'l', the leading n by n   
   >           lower triangular part of the array A must contain the lower   
   >           triangular matrix and the strictly upper triangular part of   
   >           A is not referenced.   
   >           Note that when  DIAG = 'U' or 'u', the diagonal elements of   
   >           A are not referenced either, but are assumed to be unity.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in,out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the n   
   >           element vector x. On exit, X is overwritten with the   
   >           transformed vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level2   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >  The vector and matrix arguments are not referenced when N = 0, or M = 0   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrmv_(char *uplo, char *trans, char *diag, integer *n, 
	doublereal *a, integer *lda, doublereal *x, integer *incx)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, jx, kx, info;
    doublereal temp;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical nounit;


/*  -- Reference BLAS level2 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --x;

    /* Function Body */
    info = 0;
    if (! igraphlsame_(uplo, "U") && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T") && ! igraphlsame_(trans, "C")) {
	info = 2;
    } else if (! igraphlsame_(diag, "U") && ! igraphlsame_(diag, 
	    "N")) {
	info = 3;
    } else if (*n < 0) {
	info = 4;
    } else if (*lda < max(1,*n)) {
	info = 6;
    } else if (*incx == 0) {
	info = 8;
    }
    if (info != 0) {
	igraphxerbla_("DTRMV ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0) {
	return 0;
    }

    nounit = igraphlsame_(diag, "N");

/*     Set up the start point in X if the increment is not unity. This   
       will be  ( N - 1 )*INCX  too small for descending loops. */

    if (*incx <= 0) {
	kx = 1 - (*n - 1) * *incx;
    } else if (*incx != 1) {
	kx = 1;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through A. */

    if (igraphlsame_(trans, "N")) {

/*        Form  x := A*x. */

	if (igraphlsame_(uplo, "U")) {
	    if (*incx == 1) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (x[j] != 0.) {
			temp = x[j];
			i__2 = j - 1;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    x[i__] += temp * a[i__ + j * a_dim1];
/* L10: */
			}
			if (nounit) {
			    x[j] *= a[j + j * a_dim1];
			}
		    }
/* L20: */
		}
	    } else {
		jx = kx;
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (x[jx] != 0.) {
			temp = x[jx];
			ix = kx;
			i__2 = j - 1;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    x[ix] += temp * a[i__ + j * a_dim1];
			    ix += *incx;
/* L30: */
			}
			if (nounit) {
			    x[jx] *= a[j + j * a_dim1];
			}
		    }
		    jx += *incx;
/* L40: */
		}
	    }
	} else {
	    if (*incx == 1) {
		for (j = *n; j >= 1; --j) {
		    if (x[j] != 0.) {
			temp = x[j];
			i__1 = j + 1;
			for (i__ = *n; i__ >= i__1; --i__) {
			    x[i__] += temp * a[i__ + j * a_dim1];
/* L50: */
			}
			if (nounit) {
			    x[j] *= a[j + j * a_dim1];
			}
		    }
/* L60: */
		}
	    } else {
		kx += (*n - 1) * *incx;
		jx = kx;
		for (j = *n; j >= 1; --j) {
		    if (x[jx] != 0.) {
			temp = x[jx];
			ix = kx;
			i__1 = j + 1;
			for (i__ = *n; i__ >= i__1; --i__) {
			    x[ix] += temp * a[i__ + j * a_dim1];
			    ix -= *incx;
/* L70: */
			}
			if (nounit) {
			    x[jx] *= a[j + j * a_dim1];
			}
		    }
		    jx -= *incx;
/* L80: */
		}
	    }
	}
    } else {

/*        Form  x := A**T*x. */

	if (igraphlsame_(uplo, "U")) {
	    if (*incx == 1) {
		for (j = *n; j >= 1; --j) {
		    temp = x[j];
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    for (i__ = j - 1; i__ >= 1; --i__) {
			temp += a[i__ + j * a_dim1] * x[i__];
/* L90: */
		    }
		    x[j] = temp;
/* L100: */
		}
	    } else {
		jx = kx + (*n - 1) * *incx;
		for (j = *n; j >= 1; --j) {
		    temp = x[jx];
		    ix = jx;
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    for (i__ = j - 1; i__ >= 1; --i__) {
			ix -= *incx;
			temp += a[i__ + j * a_dim1] * x[ix];
/* L110: */
		    }
		    x[jx] = temp;
		    jx -= *incx;
/* L120: */
		}
	    }
	} else {
	    if (*incx == 1) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    temp = x[j];
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    i__2 = *n;
		    for (i__ = j + 1; i__ <= i__2; ++i__) {
			temp += a[i__ + j * a_dim1] * x[i__];
/* L130: */
		    }
		    x[j] = temp;
/* L140: */
		}
	    } else {
		jx = kx;
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    temp = x[jx];
		    ix = jx;
		    if (nounit) {
			temp *= a[j + j * a_dim1];
		    }
		    i__2 = *n;
		    for (i__ = j + 1; i__ <= i__2; ++i__) {
			ix += *incx;
			temp += a[i__ + j * a_dim1] * x[ix];
/* L150: */
		    }
		    x[jx] = temp;
		    jx += *incx;
/* L160: */
		}
	    }
	}
    }

    return 0;

/*     End of DTRMV . */

} /* igraphdtrmv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrsen.c0000644000175100001710000004673000000000000024057 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c_n1 = -1;

/* > \brief \b DTRSEN   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DTRSEN + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DTRSEN( JOB, COMPQ, SELECT, N, T, LDT, Q, LDQ, WR, WI,   
                            M, S, SEP, WORK, LWORK, IWORK, LIWORK, INFO )   

         CHARACTER          COMPQ, JOB   
         INTEGER            INFO, LDQ, LDT, LIWORK, LWORK, M, N   
         DOUBLE PRECISION   S, SEP   
         LOGICAL            SELECT( * )   
         INTEGER            IWORK( * )   
         DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WI( * ), WORK( * ),   
        $                   WR( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRSEN reorders the real Schur factorization of a real matrix   
   > A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in   
   > the leading diagonal blocks of the upper quasi-triangular matrix T,   
   > and the leading columns of Q form an orthonormal basis of the   
   > corresponding right invariant subspace.   
   >   
   > Optionally the routine computes the reciprocal condition numbers of   
   > the cluster of eigenvalues and/or the invariant subspace.   
   >   
   > T must be in Schur canonical form (as returned by DHSEQR), that is,   
   > block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each   
   > 2-by-2 diagonal block has its diagonal elements equal and its   
   > off-diagonal elements of opposite sign.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is CHARACTER*1   
   >          Specifies whether condition numbers are required for the   
   >          cluster of eigenvalues (S) or the invariant subspace (SEP):   
   >          = 'N': none;   
   >          = 'E': for eigenvalues only (S);   
   >          = 'V': for invariant subspace only (SEP);   
   >          = 'B': for both eigenvalues and invariant subspace (S and   
   >                 SEP).   
   > \endverbatim   
   >   
   > \param[in] COMPQ   
   > \verbatim   
   >          COMPQ is CHARACTER*1   
   >          = 'V': update the matrix Q of Schur vectors;   
   >          = 'N': do not update Q.   
   > \endverbatim   
   >   
   > \param[in] SELECT   
   > \verbatim   
   >          SELECT is LOGICAL array, dimension (N)   
   >          SELECT specifies the eigenvalues in the selected cluster. To   
   >          select a real eigenvalue w(j), SELECT(j) must be set to   
   >          .TRUE.. To select a complex conjugate pair of eigenvalues   
   >          w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,   
   >          either SELECT(j) or SELECT(j+1) or both must be set to   
   >          .TRUE.; a complex conjugate pair of eigenvalues must be   
   >          either both included in the cluster or both excluded.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T. N >= 0.   
   > \endverbatim   
   >   
   > \param[in,out] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          On entry, the upper quasi-triangular matrix T, in Schur   
   >          canonical form.   
   >          On exit, T is overwritten by the reordered matrix T, again in   
   >          Schur canonical form, with the selected eigenvalues in the   
   >          leading diagonal blocks.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] Q   
   > \verbatim   
   >          Q is DOUBLE PRECISION array, dimension (LDQ,N)   
   >          On entry, if COMPQ = 'V', the matrix Q of Schur vectors.   
   >          On exit, if COMPQ = 'V', Q has been postmultiplied by the   
   >          orthogonal transformation matrix which reorders T; the   
   >          leading M columns of Q form an orthonormal basis for the   
   >          specified invariant subspace.   
   >          If COMPQ = 'N', Q is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDQ   
   > \verbatim   
   >          LDQ is INTEGER   
   >          The leading dimension of the array Q.   
   >          LDQ >= 1; and if COMPQ = 'V', LDQ >= N.   
   > \endverbatim   
   >   
   > \param[out] WR   
   > \verbatim   
   >          WR is DOUBLE PRECISION array, dimension (N)   
   > \endverbatim   
   > \param[out] WI   
   > \verbatim   
   >          WI is DOUBLE PRECISION array, dimension (N)   
   >   
   >          The real and imaginary parts, respectively, of the reordered   
   >          eigenvalues of T. The eigenvalues are stored in the same   
   >          order as on the diagonal of T, with WR(i) = T(i,i) and, if   
   >          T(i:i+1,i:i+1) is a 2-by-2 diagonal block, WI(i) > 0 and   
   >          WI(i+1) = -WI(i). Note that if a complex eigenvalue is   
   >          sufficiently ill-conditioned, then its value may differ   
   >          significantly from its value before reordering.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The dimension of the specified invariant subspace.   
   >          0 < = M <= N.   
   > \endverbatim   
   >   
   > \param[out] S   
   > \verbatim   
   >          S is DOUBLE PRECISION   
   >          If JOB = 'E' or 'B', S is a lower bound on the reciprocal   
   >          condition number for the selected cluster of eigenvalues.   
   >          S cannot underestimate the true reciprocal condition number   
   >          by more than a factor of sqrt(N). If M = 0 or N, S = 1.   
   >          If JOB = 'N' or 'V', S is not referenced.   
   > \endverbatim   
   >   
   > \param[out] SEP   
   > \verbatim   
   >          SEP is DOUBLE PRECISION   
   >          If JOB = 'V' or 'B', SEP is the estimated reciprocal   
   >          condition number of the specified invariant subspace. If   
   >          M = 0 or N, SEP = norm(T).   
   >          If JOB = 'N' or 'E', SEP is not referenced.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))   
   >          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is INTEGER   
   >          The dimension of the array WORK.   
   >          If JOB = 'N', LWORK >= max(1,N);   
   >          if JOB = 'E', LWORK >= max(1,M*(N-M));   
   >          if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).   
   >   
   >          If LWORK = -1, then a workspace query is assumed; the routine   
   >          only calculates the optimal size of the WORK array, returns   
   >          this value as the first entry of the WORK array, and no error   
   >          message related to LWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (MAX(1,LIWORK))   
   >          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.   
   > \endverbatim   
   >   
   > \param[in] LIWORK   
   > \verbatim   
   >          LIWORK is INTEGER   
   >          The dimension of the array IWORK.   
   >          If JOB = 'N' or 'E', LIWORK >= 1;   
   >          if JOB = 'V' or 'B', LIWORK >= max(1,M*(N-M)).   
   >   
   >          If LIWORK = -1, then a workspace query is assumed; the   
   >          routine only calculates the optimal size of the IWORK array,   
   >          returns this value as the first entry of the IWORK array, and   
   >          no error message related to LIWORK is issued by XERBLA.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   >          = 1: reordering of T failed because some eigenvalues are too   
   >               close to separate (the problem is very ill-conditioned);   
   >               T may have been partially reordered, and WR and WI   
   >               contain the eigenvalues in the same order as in T; S and   
   >               SEP (if requested) are set to zero.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date April 2012   

   > \ingroup doubleOTHERcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  DTRSEN first collects the selected eigenvalues by computing an   
   >  orthogonal transformation Z to move them to the top left corner of T.   
   >  In other words, the selected eigenvalues are the eigenvalues of T11   
   >  in:   
   >   
   >          Z**T * T * Z = ( T11 T12 ) n1   
   >                         (  0  T22 ) n2   
   >                            n1  n2   
   >   
   >  where N = n1+n2 and Z**T means the transpose of Z. The first n1 columns   
   >  of Z span the specified invariant subspace of T.   
   >   
   >  If T has been obtained from the real Schur factorization of a matrix   
   >  A = Q*T*Q**T, then the reordered real Schur factorization of A is given   
   >  by A = (Q*Z)*(Z**T*T*Z)*(Q*Z)**T, and the first n1 columns of Q*Z span   
   >  the corresponding invariant subspace of A.   
   >   
   >  The reciprocal condition number of the average of the eigenvalues of   
   >  T11 may be returned in S. S lies between 0 (very badly conditioned)   
   >  and 1 (very well conditioned). It is computed as follows. First we   
   >  compute R so that   
   >   
   >                         P = ( I  R ) n1   
   >                             ( 0  0 ) n2   
   >                               n1 n2   
   >   
   >  is the projector on the invariant subspace associated with T11.   
   >  R is the solution of the Sylvester equation:   
   >   
   >                        T11*R - R*T22 = T12.   
   >   
   >  Let F-norm(M) denote the Frobenius-norm of M and 2-norm(M) denote   
   >  the two-norm of M. Then S is computed as the lower bound   
   >   
   >                      (1 + F-norm(R)**2)**(-1/2)   
   >   
   >  on the reciprocal of 2-norm(P), the true reciprocal condition number.   
   >  S cannot underestimate 1 / 2-norm(P) by more than a factor of   
   >  sqrt(N).   
   >   
   >  An approximate error bound for the computed average of the   
   >  eigenvalues of T11 is   
   >   
   >                         EPS * norm(T) / S   
   >   
   >  where EPS is the machine precision.   
   >   
   >  The reciprocal condition number of the right invariant subspace   
   >  spanned by the first n1 columns of Z (or of Q*Z) is returned in SEP.   
   >  SEP is defined as the separation of T11 and T22:   
   >   
   >                     sep( T11, T22 ) = sigma-min( C )   
   >   
   >  where sigma-min(C) is the smallest singular value of the   
   >  n1*n2-by-n1*n2 matrix   
   >   
   >     C  = kprod( I(n2), T11 ) - kprod( transpose(T22), I(n1) )   
   >   
   >  I(m) is an m by m identity matrix, and kprod denotes the Kronecker   
   >  product. We estimate sigma-min(C) by the reciprocal of an estimate of   
   >  the 1-norm of inverse(C). The true reciprocal 1-norm of inverse(C)   
   >  cannot differ from sigma-min(C) by more than a factor of sqrt(n1*n2).   
   >   
   >  When SEP is small, small changes in T can cause large changes in   
   >  the invariant subspace. An approximate bound on the maximum angular   
   >  error in the computed right invariant subspace is   
   >   
   >                      EPS * norm(T) / SEP   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrsen_(char *job, char *compq, logical *select, integer 
	*n, doublereal *t, integer *ldt, doublereal *q, integer *ldq, 
	doublereal *wr, doublereal *wi, integer *m, doublereal *s, doublereal 
	*sep, doublereal *work, integer *lwork, integer *iwork, integer *
	liwork, integer *info)
{
    /* System generated locals */
    integer q_dim1, q_offset, t_dim1, t_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer k, n1, n2, kk, nn, ks;
    doublereal est;
    integer kase;
    logical pair;
    integer ierr;
    logical swap;
    doublereal scale;
    extern logical igraphlsame_(char *, char *);
    integer isave[3], lwmin = 0;
    logical wantq, wants;
    doublereal rnorm;
    extern /* Subroutine */ int igraphdlacn2_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *, integer *, integer *);
    extern doublereal igraphdlange_(char *, integer *, integer *, doublereal *, 
	    integer *, doublereal *);
    extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphxerbla_(char *, integer *, ftnlen);
    logical wantbh;
    extern /* Subroutine */ int igraphdtrexc_(char *, integer *, doublereal *, 
	    integer *, doublereal *, integer *, integer *, integer *, 
	    doublereal *, integer *);
    integer liwmin;
    logical wantsp, lquery;
    extern /* Subroutine */ int igraphdtrsyl_(char *, char *, integer *, integer *, 
	    integer *, doublereal *, integer *, doublereal *, integer *, 
	    doublereal *, integer *, doublereal *, integer *);


/*  -- LAPACK computational routine (version 3.4.1) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       April 2012   


    =====================================================================   


       Decode and test the input parameters   

       Parameter adjustments */
    --select;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    q_dim1 = *ldq;
    q_offset = 1 + q_dim1;
    q -= q_offset;
    --wr;
    --wi;
    --work;
    --iwork;

    /* Function Body */
    wantbh = igraphlsame_(job, "B");
    wants = igraphlsame_(job, "E") || wantbh;
    wantsp = igraphlsame_(job, "V") || wantbh;
    wantq = igraphlsame_(compq, "V");

    *info = 0;
    lquery = *lwork == -1;
    if (! igraphlsame_(job, "N") && ! wants && ! wantsp) {
	*info = -1;
    } else if (! igraphlsame_(compq, "N") && ! wantq) {
	*info = -2;
    } else if (*n < 0) {
	*info = -4;
    } else if (*ldt < max(1,*n)) {
	*info = -6;
    } else if (*ldq < 1 || wantq && *ldq < *n) {
	*info = -8;
    } else {

/*        Set M to the dimension of the specified invariant subspace,   
          and test LWORK and LIWORK. */

	*m = 0;
	pair = FALSE_;
	i__1 = *n;
	for (k = 1; k <= i__1; ++k) {
	    if (pair) {
		pair = FALSE_;
	    } else {
		if (k < *n) {
		    if (t[k + 1 + k * t_dim1] == 0.) {
			if (select[k]) {
			    ++(*m);
			}
		    } else {
			pair = TRUE_;
			if (select[k] || select[k + 1]) {
			    *m += 2;
			}
		    }
		} else {
		    if (select[*n]) {
			++(*m);
		    }
		}
	    }
/* L10: */
	}

	n1 = *m;
	n2 = *n - *m;
	nn = n1 * n2;

	if (wantsp) {
/* Computing MAX */
	    i__1 = 1, i__2 = nn << 1;
	    lwmin = max(i__1,i__2);
	    liwmin = max(1,nn);
	} else if (igraphlsame_(job, "N")) {
	    lwmin = max(1,*n);
	    liwmin = 1;
	} else if (igraphlsame_(job, "E")) {
	    lwmin = max(1,nn);
	    liwmin = 1;
	}

	if (*lwork < lwmin && ! lquery) {
	    *info = -15;
	} else if (*liwork < liwmin && ! lquery) {
	    *info = -17;
	}
    }

    if (*info == 0) {
	work[1] = (doublereal) lwmin;
	iwork[1] = liwmin;
    }

    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DTRSEN", &i__1, (ftnlen)6);
	return 0;
    } else if (lquery) {
	return 0;
    }

/*     Quick return if possible. */

    if (*m == *n || *m == 0) {
	if (wants) {
	    *s = 1.;
	}
	if (wantsp) {
	    *sep = igraphdlange_("1", n, n, &t[t_offset], ldt, &work[1]);
	}
	goto L40;
    }

/*     Collect the selected blocks at the top-left corner of T. */

    ks = 0;
    pair = FALSE_;
    i__1 = *n;
    for (k = 1; k <= i__1; ++k) {
	if (pair) {
	    pair = FALSE_;
	} else {
	    swap = select[k];
	    if (k < *n) {
		if (t[k + 1 + k * t_dim1] != 0.) {
		    pair = TRUE_;
		    swap = swap || select[k + 1];
		}
	    }
	    if (swap) {
		++ks;

/*              Swap the K-th block to position KS. */

		ierr = 0;
		kk = k;
		if (k != ks) {
		    igraphdtrexc_(compq, n, &t[t_offset], ldt, &q[q_offset], ldq, &
			    kk, &ks, &work[1], &ierr);
		}
		if (ierr == 1 || ierr == 2) {

/*                 Blocks too close to swap: exit. */

		    *info = 1;
		    if (wants) {
			*s = 0.;
		    }
		    if (wantsp) {
			*sep = 0.;
		    }
		    goto L40;
		}
		if (pair) {
		    ++ks;
		}
	    }
	}
/* L20: */
    }

    if (wants) {

/*        Solve Sylvester equation for R:   

             T11*R - R*T22 = scale*T12 */

	igraphdlacpy_("F", &n1, &n2, &t[(n1 + 1) * t_dim1 + 1], ldt, &work[1], &n1);
	igraphdtrsyl_("N", "N", &c_n1, &n1, &n2, &t[t_offset], ldt, &t[n1 + 1 + (n1 
		+ 1) * t_dim1], ldt, &work[1], &n1, &scale, &ierr);

/*        Estimate the reciprocal of the condition number of the cluster   
          of eigenvalues. */

	rnorm = igraphdlange_("F", &n1, &n2, &work[1], &n1, &work[1]);
	if (rnorm == 0.) {
	    *s = 1.;
	} else {
	    *s = scale / (sqrt(scale * scale / rnorm + rnorm) * sqrt(rnorm));
	}
    }

    if (wantsp) {

/*        Estimate sep(T11,T22). */

	est = 0.;
	kase = 0;
L30:
	igraphdlacn2_(&nn, &work[nn + 1], &work[1], &iwork[1], &est, &kase, isave);
	if (kase != 0) {
	    if (kase == 1) {

/*              Solve  T11*R - R*T22 = scale*X. */

		igraphdtrsyl_("N", "N", &c_n1, &n1, &n2, &t[t_offset], ldt, &t[n1 + 
			1 + (n1 + 1) * t_dim1], ldt, &work[1], &n1, &scale, &
			ierr);
	    } else {

/*              Solve T11**T*R - R*T22**T = scale*X. */

		igraphdtrsyl_("T", "T", &c_n1, &n1, &n2, &t[t_offset], ldt, &t[n1 + 
			1 + (n1 + 1) * t_dim1], ldt, &work[1], &n1, &scale, &
			ierr);
	    }
	    goto L30;
	}

	*sep = scale / est;
    }

L40:

/*     Store the output eigenvalues in WR and WI. */

    i__1 = *n;
    for (k = 1; k <= i__1; ++k) {
	wr[k] = t[k + k * t_dim1];
	wi[k] = 0.;
/* L50: */
    }
    i__1 = *n - 1;
    for (k = 1; k <= i__1; ++k) {
	if (t[k + 1 + k * t_dim1] != 0.) {
	    wi[k] = sqrt((d__1 = t[k + (k + 1) * t_dim1], abs(d__1))) * sqrt((
		    d__2 = t[k + 1 + k * t_dim1], abs(d__2)));
	    wi[k + 1] = -wi[k];
	}
/* L60: */
    }

    work[1] = (doublereal) lwmin;
    iwork[1] = liwmin;

    return 0;

/*     End of DTRSEN */

} /* igraphdtrsen_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrsm.c0000644000175100001710000003334000000000000023702 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DTRSM   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DTRSM(SIDE,UPLO,TRANSA,DIAG,M,N,ALPHA,A,LDA,B,LDB)   

         DOUBLE PRECISION ALPHA   
         INTEGER LDA,LDB,M,N   
         CHARACTER DIAG,SIDE,TRANSA,UPLO   
         DOUBLE PRECISION A(LDA,*),B(LDB,*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRSM  solves one of the matrix equations   
   >   
   >    op( A )*X = alpha*B,   or   X*op( A ) = alpha*B,   
   >   
   > where alpha is a scalar, X and B are m by n matrices, A is a unit, or   
   > non-unit,  upper or lower triangular matrix  and  op( A )  is one  of   
   >   
   >    op( A ) = A   or   op( A ) = A**T.   
   >   
   > The matrix X is overwritten on B.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SIDE   
   > \verbatim   
   >          SIDE is CHARACTER*1   
   >           On entry, SIDE specifies whether op( A ) appears on the left   
   >           or right of X as follows:   
   >   
   >              SIDE = 'L' or 'l'   op( A )*X = alpha*B.   
   >   
   >              SIDE = 'R' or 'r'   X*op( A ) = alpha*B.   
   > \endverbatim   
   >   
   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the matrix A is an upper or   
   >           lower triangular matrix as follows:   
   >   
   >              UPLO = 'U' or 'u'   A is an upper triangular matrix.   
   >   
   >              UPLO = 'L' or 'l'   A is a lower triangular matrix.   
   > \endverbatim   
   >   
   > \param[in] TRANSA   
   > \verbatim   
   >          TRANSA is CHARACTER*1   
   >           On entry, TRANSA specifies the form of op( A ) to be used in   
   >           the matrix multiplication as follows:   
   >   
   >              TRANSA = 'N' or 'n'   op( A ) = A.   
   >   
   >              TRANSA = 'T' or 't'   op( A ) = A**T.   
   >   
   >              TRANSA = 'C' or 'c'   op( A ) = A**T.   
   > \endverbatim   
   >   
   > \param[in] DIAG   
   > \verbatim   
   >          DIAG is CHARACTER*1   
   >           On entry, DIAG specifies whether or not A is unit triangular   
   >           as follows:   
   >   
   >              DIAG = 'U' or 'u'   A is assumed to be unit triangular.   
   >   
   >              DIAG = 'N' or 'n'   A is not assumed to be unit   
   >                                  triangular.   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry, M specifies the number of rows of B. M must be at   
   >           least zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the number of columns of B.  N must be   
   >           at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry,  ALPHA specifies the scalar  alpha. When  alpha is   
   >           zero then  A is not referenced and  B need not be set before   
   >           entry.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, k ),   
   >           where k is m when SIDE = 'L' or 'l'   
   >             and k is n when SIDE = 'R' or 'r'.   
   >           Before entry  with  UPLO = 'U' or 'u',  the  leading  k by k   
   >           upper triangular part of the array  A must contain the upper   
   >           triangular matrix  and the strictly lower triangular part of   
   >           A is not referenced.   
   >           Before entry  with  UPLO = 'L' or 'l',  the  leading  k by k   
   >           lower triangular part of the array  A must contain the lower   
   >           triangular matrix  and the strictly upper triangular part of   
   >           A is not referenced.   
   >           Note that when  DIAG = 'U' or 'u',  the diagonal elements of   
   >           A  are not referenced either,  but are assumed to be  unity.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program.  When  SIDE = 'L' or 'l'  then   
   >           LDA  must be at least  max( 1, m ),  when  SIDE = 'R' or 'r'   
   >           then LDA must be at least max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in,out] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension ( LDB, N )   
   >           Before entry,  the leading  m by n part of the array  B must   
   >           contain  the  right-hand  side  matrix  B,  and  on exit  is   
   >           overwritten by the solution matrix  X.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >           On entry, LDB specifies the first dimension of B as declared   
   >           in  the  calling  (sub)  program.   LDB  must  be  at  least   
   >           max( 1, m ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level3   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 3 Blas routine.   
   >   
   >   
   >  -- Written on 8-February-1989.   
   >     Jack Dongarra, Argonne National Laboratory.   
   >     Iain Duff, AERE Harwell.   
   >     Jeremy Du Croz, Numerical Algorithms Group Ltd.   
   >     Sven Hammarling, Numerical Algorithms Group Ltd.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrsm_(char *side, char *uplo, char *transa, char *diag, 
	integer *m, integer *n, doublereal *alpha, doublereal *a, integer *
	lda, doublereal *b, integer *ldb)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;

    /* Local variables */
    integer i__, j, k, info;
    doublereal temp;
    logical lside;
    extern logical igraphlsame_(char *, char *);
    integer nrowa;
    logical upper;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical nounit;


/*  -- Reference BLAS level3 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;

    /* Function Body */
    lside = igraphlsame_(side, "L");
    if (lside) {
	nrowa = *m;
    } else {
	nrowa = *n;
    }
    nounit = igraphlsame_(diag, "N");
    upper = igraphlsame_(uplo, "U");

    info = 0;
    if (! lside && ! igraphlsame_(side, "R")) {
	info = 1;
    } else if (! upper && ! igraphlsame_(uplo, "L")) {
	info = 2;
    } else if (! igraphlsame_(transa, "N") && ! igraphlsame_(transa,
	     "T") && ! igraphlsame_(transa, "C")) {
	info = 3;
    } else if (! igraphlsame_(diag, "U") && ! igraphlsame_(diag, 
	    "N")) {
	info = 4;
    } else if (*m < 0) {
	info = 5;
    } else if (*n < 0) {
	info = 6;
    } else if (*lda < max(1,nrowa)) {
	info = 9;
    } else if (*ldb < max(1,*m)) {
	info = 11;
    }
    if (info != 0) {
	igraphxerbla_("DTRSM ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0) {
	return 0;
    }

/*     And when  alpha.eq.zero. */

    if (*alpha == 0.) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__2 = *m;
	    for (i__ = 1; i__ <= i__2; ++i__) {
		b[i__ + j * b_dim1] = 0.;
/* L10: */
	    }
/* L20: */
	}
	return 0;
    }

/*     Start the operations. */

    if (lside) {
	if (igraphlsame_(transa, "N")) {

/*           Form  B := alpha*inv( A )*B. */

	    if (upper) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (*alpha != 1.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + j * b_dim1] = *alpha * b[i__ + j * b_dim1]
				    ;
/* L30: */
			}
		    }
		    for (k = *m; k >= 1; --k) {
			if (b[k + j * b_dim1] != 0.) {
			    if (nounit) {
				b[k + j * b_dim1] /= a[k + k * a_dim1];
			    }
			    i__2 = k - 1;
			    for (i__ = 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] -= b[k + j * b_dim1] * a[
					i__ + k * a_dim1];
/* L40: */
			    }
			}
/* L50: */
		    }
/* L60: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (*alpha != 1.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + j * b_dim1] = *alpha * b[i__ + j * b_dim1]
				    ;
/* L70: */
			}
		    }
		    i__2 = *m;
		    for (k = 1; k <= i__2; ++k) {
			if (b[k + j * b_dim1] != 0.) {
			    if (nounit) {
				b[k + j * b_dim1] /= a[k + k * a_dim1];
			    }
			    i__3 = *m;
			    for (i__ = k + 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] -= b[k + j * b_dim1] * a[
					i__ + k * a_dim1];
/* L80: */
			    }
			}
/* L90: */
		    }
/* L100: */
		}
	    }
	} else {

/*           Form  B := alpha*inv( A**T )*B. */

	    if (upper) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    i__2 = *m;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			temp = *alpha * b[i__ + j * b_dim1];
			i__3 = i__ - 1;
			for (k = 1; k <= i__3; ++k) {
			    temp -= a[k + i__ * a_dim1] * b[k + j * b_dim1];
/* L110: */
			}
			if (nounit) {
			    temp /= a[i__ + i__ * a_dim1];
			}
			b[i__ + j * b_dim1] = temp;
/* L120: */
		    }
/* L130: */
		}
	    } else {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    for (i__ = *m; i__ >= 1; --i__) {
			temp = *alpha * b[i__ + j * b_dim1];
			i__2 = *m;
			for (k = i__ + 1; k <= i__2; ++k) {
			    temp -= a[k + i__ * a_dim1] * b[k + j * b_dim1];
/* L140: */
			}
			if (nounit) {
			    temp /= a[i__ + i__ * a_dim1];
			}
			b[i__ + j * b_dim1] = temp;
/* L150: */
		    }
/* L160: */
		}
	    }
	}
    } else {
	if (igraphlsame_(transa, "N")) {

/*           Form  B := alpha*B*inv( A ). */

	    if (upper) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (*alpha != 1.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + j * b_dim1] = *alpha * b[i__ + j * b_dim1]
				    ;
/* L170: */
			}
		    }
		    i__2 = j - 1;
		    for (k = 1; k <= i__2; ++k) {
			if (a[k + j * a_dim1] != 0.) {
			    i__3 = *m;
			    for (i__ = 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] -= a[k + j * a_dim1] * b[
					i__ + k * b_dim1];
/* L180: */
			    }
			}
/* L190: */
		    }
		    if (nounit) {
			temp = 1. / a[j + j * a_dim1];
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
/* L200: */
			}
		    }
/* L210: */
		}
	    } else {
		for (j = *n; j >= 1; --j) {
		    if (*alpha != 1.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    b[i__ + j * b_dim1] = *alpha * b[i__ + j * b_dim1]
				    ;
/* L220: */
			}
		    }
		    i__1 = *n;
		    for (k = j + 1; k <= i__1; ++k) {
			if (a[k + j * a_dim1] != 0.) {
			    i__2 = *m;
			    for (i__ = 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] -= a[k + j * a_dim1] * b[
					i__ + k * b_dim1];
/* L230: */
			    }
			}
/* L240: */
		    }
		    if (nounit) {
			temp = 1. / a[j + j * a_dim1];
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
/* L250: */
			}
		    }
/* L260: */
		}
	    }
	} else {

/*           Form  B := alpha*B*inv( A**T ). */

	    if (upper) {
		for (k = *n; k >= 1; --k) {
		    if (nounit) {
			temp = 1. / a[k + k * a_dim1];
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
/* L270: */
			}
		    }
		    i__1 = k - 1;
		    for (j = 1; j <= i__1; ++j) {
			if (a[j + k * a_dim1] != 0.) {
			    temp = a[j + k * a_dim1];
			    i__2 = *m;
			    for (i__ = 1; i__ <= i__2; ++i__) {
				b[i__ + j * b_dim1] -= temp * b[i__ + k * 
					b_dim1];
/* L280: */
			    }
			}
/* L290: */
		    }
		    if (*alpha != 1.) {
			i__1 = *m;
			for (i__ = 1; i__ <= i__1; ++i__) {
			    b[i__ + k * b_dim1] = *alpha * b[i__ + k * b_dim1]
				    ;
/* L300: */
			}
		    }
/* L310: */
		}
	    } else {
		i__1 = *n;
		for (k = 1; k <= i__1; ++k) {
		    if (nounit) {
			temp = 1. / a[k + k * a_dim1];
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
/* L320: */
			}
		    }
		    i__2 = *n;
		    for (j = k + 1; j <= i__2; ++j) {
			if (a[j + k * a_dim1] != 0.) {
			    temp = a[j + k * a_dim1];
			    i__3 = *m;
			    for (i__ = 1; i__ <= i__3; ++i__) {
				b[i__ + j * b_dim1] -= temp * b[i__ + k * 
					b_dim1];
/* L330: */
			    }
			}
/* L340: */
		    }
		    if (*alpha != 1.) {
			i__2 = *m;
			for (i__ = 1; i__ <= i__2; ++i__) {
			    b[i__ + k * b_dim1] = *alpha * b[i__ + k * b_dim1]
				    ;
/* L350: */
			}
		    }
/* L360: */
		}
	    }
	}
    }

    return 0;

/*     End of DTRSM . */

} /* igraphdtrsm_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrsna.c0000644000175100001710000005240700000000000024051 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static logical c_true = TRUE_;
static logical c_false = FALSE_;

/* > \brief \b DTRSNA   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DTRSNA + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DTRSNA( JOB, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,   
                            LDVR, S, SEP, MM, M, WORK, LDWORK, IWORK,   
                            INFO )   

         CHARACTER          HOWMNY, JOB   
         INTEGER            INFO, LDT, LDVL, LDVR, LDWORK, M, MM, N   
         LOGICAL            SELECT( * )   
         INTEGER            IWORK( * )   
         DOUBLE PRECISION   S( * ), SEP( * ), T( LDT, * ), VL( LDVL, * ),   
        $                   VR( LDVR, * ), WORK( LDWORK, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRSNA estimates reciprocal condition numbers for specified   
   > eigenvalues and/or right eigenvectors of a real upper   
   > quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q   
   > orthogonal).   
   >   
   > T must be in Schur canonical form (as returned by DHSEQR), that is,   
   > block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each   
   > 2-by-2 diagonal block has its diagonal elements equal and its   
   > off-diagonal elements of opposite sign.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] JOB   
   > \verbatim   
   >          JOB is CHARACTER*1   
   >          Specifies whether condition numbers are required for   
   >          eigenvalues (S) or eigenvectors (SEP):   
   >          = 'E': for eigenvalues only (S);   
   >          = 'V': for eigenvectors only (SEP);   
   >          = 'B': for both eigenvalues and eigenvectors (S and SEP).   
   > \endverbatim   
   >   
   > \param[in] HOWMNY   
   > \verbatim   
   >          HOWMNY is CHARACTER*1   
   >          = 'A': compute condition numbers for all eigenpairs;   
   >          = 'S': compute condition numbers for selected eigenpairs   
   >                 specified by the array SELECT.   
   > \endverbatim   
   >   
   > \param[in] SELECT   
   > \verbatim   
   >          SELECT is LOGICAL array, dimension (N)   
   >          If HOWMNY = 'S', SELECT specifies the eigenpairs for which   
   >          condition numbers are required. To select condition numbers   
   >          for the eigenpair corresponding to a real eigenvalue w(j),   
   >          SELECT(j) must be set to .TRUE.. To select condition numbers   
   >          corresponding to a complex conjugate pair of eigenvalues w(j)   
   >          and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be   
   >          set to .TRUE..   
   >          If HOWMNY = 'A', SELECT is not referenced.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix T. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] T   
   > \verbatim   
   >          T is DOUBLE PRECISION array, dimension (LDT,N)   
   >          The upper quasi-triangular matrix T, in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDT   
   > \verbatim   
   >          LDT is INTEGER   
   >          The leading dimension of the array T. LDT >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in] VL   
   > \verbatim   
   >          VL is DOUBLE PRECISION array, dimension (LDVL,M)   
   >          If JOB = 'E' or 'B', VL must contain left eigenvectors of T   
   >          (or of any Q*T*Q**T with Q orthogonal), corresponding to the   
   >          eigenpairs specified by HOWMNY and SELECT. The eigenvectors   
   >          must be stored in consecutive columns of VL, as returned by   
   >          DHSEIN or DTREVC.   
   >          If JOB = 'V', VL is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDVL   
   > \verbatim   
   >          LDVL is INTEGER   
   >          The leading dimension of the array VL.   
   >          LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N.   
   > \endverbatim   
   >   
   > \param[in] VR   
   > \verbatim   
   >          VR is DOUBLE PRECISION array, dimension (LDVR,M)   
   >          If JOB = 'E' or 'B', VR must contain right eigenvectors of T   
   >          (or of any Q*T*Q**T with Q orthogonal), corresponding to the   
   >          eigenpairs specified by HOWMNY and SELECT. The eigenvectors   
   >          must be stored in consecutive columns of VR, as returned by   
   >          DHSEIN or DTREVC.   
   >          If JOB = 'V', VR is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDVR   
   > \verbatim   
   >          LDVR is INTEGER   
   >          The leading dimension of the array VR.   
   >          LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N.   
   > \endverbatim   
   >   
   > \param[out] S   
   > \verbatim   
   >          S is DOUBLE PRECISION array, dimension (MM)   
   >          If JOB = 'E' or 'B', the reciprocal condition numbers of the   
   >          selected eigenvalues, stored in consecutive elements of the   
   >          array. For a complex conjugate pair of eigenvalues two   
   >          consecutive elements of S are set to the same value. Thus   
   >          S(j), SEP(j), and the j-th columns of VL and VR all   
   >          correspond to the same eigenpair (but not in general the   
   >          j-th eigenpair, unless all eigenpairs are selected).   
   >          If JOB = 'V', S is not referenced.   
   > \endverbatim   
   >   
   > \param[out] SEP   
   > \verbatim   
   >          SEP is DOUBLE PRECISION array, dimension (MM)   
   >          If JOB = 'V' or 'B', the estimated reciprocal condition   
   >          numbers of the selected eigenvectors, stored in consecutive   
   >          elements of the array. For a complex eigenvector two   
   >          consecutive elements of SEP are set to the same value. If   
   >          the eigenvalues cannot be reordered to compute SEP(j), SEP(j)   
   >          is set to 0; this can only occur when the true value would be   
   >          very small anyway.   
   >          If JOB = 'E', SEP is not referenced.   
   > \endverbatim   
   >   
   > \param[in] MM   
   > \verbatim   
   >          MM is INTEGER   
   >          The number of elements in the arrays S (if JOB = 'E' or 'B')   
   >           and/or SEP (if JOB = 'V' or 'B'). MM >= M.   
   > \endverbatim   
   >   
   > \param[out] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of elements of the arrays S and/or SEP actually   
   >          used to store the estimated condition numbers.   
   >          If HOWMNY = 'A', M is set to N.   
   > \endverbatim   
   >   
   > \param[out] WORK   
   > \verbatim   
   >          WORK is DOUBLE PRECISION array, dimension (LDWORK,N+6)   
   >          If JOB = 'E', WORK is not referenced.   
   > \endverbatim   
   >   
   > \param[in] LDWORK   
   > \verbatim   
   >          LDWORK is INTEGER   
   >          The leading dimension of the array WORK.   
   >          LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N.   
   > \endverbatim   
   >   
   > \param[out] IWORK   
   > \verbatim   
   >          IWORK is INTEGER array, dimension (2*(N-1))   
   >          If JOB = 'E', IWORK is not referenced.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleOTHERcomputational   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The reciprocal of the condition number of an eigenvalue lambda is   
   >  defined as   
   >   
   >          S(lambda) = |v**T*u| / (norm(u)*norm(v))   
   >   
   >  where u and v are the right and left eigenvectors of T corresponding   
   >  to lambda; v**T denotes the transpose of v, and norm(u)   
   >  denotes the Euclidean norm. These reciprocal condition numbers always   
   >  lie between zero (very badly conditioned) and one (very well   
   >  conditioned). If n = 1, S(lambda) is defined to be 1.   
   >   
   >  An approximate error bound for a computed eigenvalue W(i) is given by   
   >   
   >                      EPS * norm(T) / S(i)   
   >   
   >  where EPS is the machine precision.   
   >   
   >  The reciprocal of the condition number of the right eigenvector u   
   >  corresponding to lambda is defined as follows. Suppose   
   >   
   >              T = ( lambda  c  )   
   >                  (   0    T22 )   
   >   
   >  Then the reciprocal condition number is   
   >   
   >          SEP( lambda, T22 ) = sigma-min( T22 - lambda*I )   
   >   
   >  where sigma-min denotes the smallest singular value. We approximate   
   >  the smallest singular value by the reciprocal of an estimate of the   
   >  one-norm of the inverse of T22 - lambda*I. If n = 1, SEP(1) is   
   >  defined to be abs(T(1,1)).   
   >   
   >  An approximate error bound for a computed right eigenvector VR(i)   
   >  is given by   
   >   
   >                      EPS * norm(T) / SEP(i)   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdtrsna_(char *job, char *howmny, logical *select, 
	integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *
	ldvl, doublereal *vr, integer *ldvr, doublereal *s, doublereal *sep, 
	integer *mm, integer *m, doublereal *work, integer *ldwork, integer *
	iwork, integer *info)
{
    /* System generated locals */
    integer t_dim1, t_offset, vl_dim1, vl_offset, vr_dim1, vr_offset, 
	    work_dim1, work_offset, i__1, i__2;
    doublereal d__1, d__2;

    /* Builtin functions */
    double sqrt(doublereal);

    /* Local variables */
    integer i__, j, k, n2;
    doublereal cs;
    integer nn, ks;
    doublereal sn, mu, eps, est;
    integer kase;
    doublereal cond;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    logical pair;
    integer ierr;
    doublereal dumm, prod;
    integer ifst;
    doublereal lnrm;
    integer ilst;
    doublereal rnrm;
    extern doublereal igraphdnrm2_(integer *, doublereal *, integer *);
    doublereal prod1, prod2, scale, delta;
    extern logical igraphlsame_(char *, char *);
    integer isave[3];
    logical wants;
    doublereal dummy[1];
    extern /* Subroutine */ int igraphdlacn2_(integer *, doublereal *, doublereal *,
	     integer *, doublereal *, integer *, integer *);
    extern doublereal igraphdlapy2_(doublereal *, doublereal *);
    extern /* Subroutine */ int igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *);
    extern /* Subroutine */ int igraphdlacpy_(char *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *), 
	    igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum;
    logical wantbh;
    extern /* Subroutine */ int igraphdlaqtr_(logical *, logical *, integer *, 
	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
	     doublereal *, doublereal *, integer *), igraphdtrexc_(char *, integer *
	    , doublereal *, integer *, doublereal *, integer *, integer *, 
	    integer *, doublereal *, integer *);
    logical somcon;
    doublereal smlnum;
    logical wantsp;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Decode and test the input parameters   

       Parameter adjustments */
    --select;
    t_dim1 = *ldt;
    t_offset = 1 + t_dim1;
    t -= t_offset;
    vl_dim1 = *ldvl;
    vl_offset = 1 + vl_dim1;
    vl -= vl_offset;
    vr_dim1 = *ldvr;
    vr_offset = 1 + vr_dim1;
    vr -= vr_offset;
    --s;
    --sep;
    work_dim1 = *ldwork;
    work_offset = 1 + work_dim1;
    work -= work_offset;
    --iwork;

    /* Function Body */
    wantbh = igraphlsame_(job, "B");
    wants = igraphlsame_(job, "E") || wantbh;
    wantsp = igraphlsame_(job, "V") || wantbh;

    somcon = igraphlsame_(howmny, "S");

    *info = 0;
    if (! wants && ! wantsp) {
	*info = -1;
    } else if (! igraphlsame_(howmny, "A") && ! somcon) {
	*info = -2;
    } else if (*n < 0) {
	*info = -4;
    } else if (*ldt < max(1,*n)) {
	*info = -6;
    } else if (*ldvl < 1 || wants && *ldvl < *n) {
	*info = -8;
    } else if (*ldvr < 1 || wants && *ldvr < *n) {
	*info = -10;
    } else {

/*        Set M to the number of eigenpairs for which condition numbers   
          are required, and test MM. */

	if (somcon) {
	    *m = 0;
	    pair = FALSE_;
	    i__1 = *n;
	    for (k = 1; k <= i__1; ++k) {
		if (pair) {
		    pair = FALSE_;
		} else {
		    if (k < *n) {
			if (t[k + 1 + k * t_dim1] == 0.) {
			    if (select[k]) {
				++(*m);
			    }
			} else {
			    pair = TRUE_;
			    if (select[k] || select[k + 1]) {
				*m += 2;
			    }
			}
		    } else {
			if (select[*n]) {
			    ++(*m);
			}
		    }
		}
/* L10: */
	    }
	} else {
	    *m = *n;
	}

	if (*mm < *m) {
	    *info = -13;
	} else if (*ldwork < 1 || wantsp && *ldwork < *n) {
	    *info = -16;
	}
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DTRSNA", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    if (*n == 0) {
	return 0;
    }

    if (*n == 1) {
	if (somcon) {
	    if (! select[1]) {
		return 0;
	    }
	}
	if (wants) {
	    s[1] = 1.;
	}
	if (wantsp) {
	    sep[1] = (d__1 = t[t_dim1 + 1], abs(d__1));
	}
	return 0;
    }

/*     Get machine constants */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S") / eps;
    bignum = 1. / smlnum;
    igraphdlabad_(&smlnum, &bignum);

    ks = 0;
    pair = FALSE_;
    i__1 = *n;
    for (k = 1; k <= i__1; ++k) {

/*        Determine whether T(k,k) begins a 1-by-1 or 2-by-2 block. */

	if (pair) {
	    pair = FALSE_;
	    goto L60;
	} else {
	    if (k < *n) {
		pair = t[k + 1 + k * t_dim1] != 0.;
	    }
	}

/*        Determine whether condition numbers are required for the k-th   
          eigenpair. */

	if (somcon) {
	    if (pair) {
		if (! select[k] && ! select[k + 1]) {
		    goto L60;
		}
	    } else {
		if (! select[k]) {
		    goto L60;
		}
	    }
	}

	++ks;

	if (wants) {

/*           Compute the reciprocal condition number of the k-th   
             eigenvalue. */

	    if (! pair) {

/*              Real eigenvalue. */

		prod = igraphddot_(n, &vr[ks * vr_dim1 + 1], &c__1, &vl[ks * 
			vl_dim1 + 1], &c__1);
		rnrm = igraphdnrm2_(n, &vr[ks * vr_dim1 + 1], &c__1);
		lnrm = igraphdnrm2_(n, &vl[ks * vl_dim1 + 1], &c__1);
		s[ks] = abs(prod) / (rnrm * lnrm);
	    } else {

/*              Complex eigenvalue. */

		prod1 = igraphddot_(n, &vr[ks * vr_dim1 + 1], &c__1, &vl[ks * 
			vl_dim1 + 1], &c__1);
		prod1 += igraphddot_(n, &vr[(ks + 1) * vr_dim1 + 1], &c__1, &vl[(ks 
			+ 1) * vl_dim1 + 1], &c__1);
		prod2 = igraphddot_(n, &vl[ks * vl_dim1 + 1], &c__1, &vr[(ks + 1) * 
			vr_dim1 + 1], &c__1);
		prod2 -= igraphddot_(n, &vl[(ks + 1) * vl_dim1 + 1], &c__1, &vr[ks *
			 vr_dim1 + 1], &c__1);
		d__1 = igraphdnrm2_(n, &vr[ks * vr_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vr[(ks + 1) * vr_dim1 + 1], &c__1);
		rnrm = igraphdlapy2_(&d__1, &d__2);
		d__1 = igraphdnrm2_(n, &vl[ks * vl_dim1 + 1], &c__1);
		d__2 = igraphdnrm2_(n, &vl[(ks + 1) * vl_dim1 + 1], &c__1);
		lnrm = igraphdlapy2_(&d__1, &d__2);
		cond = igraphdlapy2_(&prod1, &prod2) / (rnrm * lnrm);
		s[ks] = cond;
		s[ks + 1] = cond;
	    }
	}

	if (wantsp) {

/*           Estimate the reciprocal condition number of the k-th   
             eigenvector.   

             Copy the matrix T to the array WORK and swap the diagonal   
             block beginning at T(k,k) to the (1,1) position. */

	    igraphdlacpy_("Full", n, n, &t[t_offset], ldt, &work[work_offset], 
		    ldwork);
	    ifst = k;
	    ilst = 1;
	    igraphdtrexc_("No Q", n, &work[work_offset], ldwork, dummy, &c__1, &
		    ifst, &ilst, &work[(*n + 1) * work_dim1 + 1], &ierr);

	    if (ierr == 1 || ierr == 2) {

/*              Could not swap because blocks not well separated */

		scale = 1.;
		est = bignum;
	    } else {

/*              Reordering successful */

		if (work[work_dim1 + 2] == 0.) {

/*                 Form C = T22 - lambda*I in WORK(2:N,2:N). */

		    i__2 = *n;
		    for (i__ = 2; i__ <= i__2; ++i__) {
			work[i__ + i__ * work_dim1] -= work[work_dim1 + 1];
/* L20: */
		    }
		    n2 = 1;
		    nn = *n - 1;
		} else {

/*                 Triangularize the 2 by 2 block by unitary   
                   transformation U = [  cs   i*ss ]   
                                      [ i*ss   cs  ].   
                   such that the (1,1) position of WORK is complex   
                   eigenvalue lambda with positive imaginary part. (2,2)   
                   position of WORK is the complex eigenvalue lambda   
                   with negative imaginary  part. */

		    mu = sqrt((d__1 = work[(work_dim1 << 1) + 1], abs(d__1))) 
			    * sqrt((d__2 = work[work_dim1 + 2], abs(d__2)));
		    delta = igraphdlapy2_(&mu, &work[work_dim1 + 2]);
		    cs = mu / delta;
		    sn = -work[work_dim1 + 2] / delta;

/*                 Form   

                   C**T = WORK(2:N,2:N) + i*[rwork(1) ..... rwork(n-1) ]   
                                            [   mu                     ]   
                                            [         ..               ]   
                                            [             ..           ]   
                                            [                  mu      ]   
                   where C**T is transpose of matrix C,   
                   and RWORK is stored starting in the N+1-st column of   
                   WORK. */

		    i__2 = *n;
		    for (j = 3; j <= i__2; ++j) {
			work[j * work_dim1 + 2] = cs * work[j * work_dim1 + 2]
				;
			work[j + j * work_dim1] -= work[work_dim1 + 1];
/* L30: */
		    }
		    work[(work_dim1 << 1) + 2] = 0.;

		    work[(*n + 1) * work_dim1 + 1] = mu * 2.;
		    i__2 = *n - 1;
		    for (i__ = 2; i__ <= i__2; ++i__) {
			work[i__ + (*n + 1) * work_dim1] = sn * work[(i__ + 1)
				 * work_dim1 + 1];
/* L40: */
		    }
		    n2 = 2;
		    nn = *n - 1 << 1;
		}

/*              Estimate norm(inv(C**T)) */

		est = 0.;
		kase = 0;
L50:
		igraphdlacn2_(&nn, &work[(*n + 2) * work_dim1 + 1], &work[(*n + 4) *
			 work_dim1 + 1], &iwork[1], &est, &kase, isave);
		if (kase != 0) {
		    if (kase == 1) {
			if (n2 == 1) {

/*                       Real eigenvalue: solve C**T*x = scale*c. */

			    i__2 = *n - 1;
			    igraphdlaqtr_(&c_true, &c_true, &i__2, &work[(work_dim1 
				    << 1) + 2], ldwork, dummy, &dumm, &scale, 
				    &work[(*n + 4) * work_dim1 + 1], &work[(*
				    n + 6) * work_dim1 + 1], &ierr);
			} else {

/*                       Complex eigenvalue: solve   
                         C**T*(p+iq) = scale*(c+id) in real arithmetic. */

			    i__2 = *n - 1;
			    igraphdlaqtr_(&c_true, &c_false, &i__2, &work[(
				    work_dim1 << 1) + 2], ldwork, &work[(*n + 
				    1) * work_dim1 + 1], &mu, &scale, &work[(*
				    n + 4) * work_dim1 + 1], &work[(*n + 6) * 
				    work_dim1 + 1], &ierr);
			}
		    } else {
			if (n2 == 1) {

/*                       Real eigenvalue: solve C*x = scale*c. */

			    i__2 = *n - 1;
			    igraphdlaqtr_(&c_false, &c_true, &i__2, &work[(
				    work_dim1 << 1) + 2], ldwork, dummy, &
				    dumm, &scale, &work[(*n + 4) * work_dim1 
				    + 1], &work[(*n + 6) * work_dim1 + 1], &
				    ierr);
			} else {

/*                       Complex eigenvalue: solve   
                         C*(p+iq) = scale*(c+id) in real arithmetic. */

			    i__2 = *n - 1;
			    igraphdlaqtr_(&c_false, &c_false, &i__2, &work[(
				    work_dim1 << 1) + 2], ldwork, &work[(*n + 
				    1) * work_dim1 + 1], &mu, &scale, &work[(*
				    n + 4) * work_dim1 + 1], &work[(*n + 6) * 
				    work_dim1 + 1], &ierr);

			}
		    }

		    goto L50;
		}
	    }

	    sep[ks] = scale / max(est,smlnum);
	    if (pair) {
		sep[ks + 1] = sep[ks];
	    }
	}

	if (pair) {
	    ++ks;
	}

L60:
	;
    }
    return 0;

/*     End of DTRSNA */

} /* igraphdtrsna_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrsv.c0000644000175100001710000002342300000000000023714 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DTRSV   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DTRSV(UPLO,TRANS,DIAG,N,A,LDA,X,INCX)   

         INTEGER INCX,LDA,N   
         CHARACTER DIAG,TRANS,UPLO   
         DOUBLE PRECISION A(LDA,*),X(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRSV  solves one of the systems of equations   
   >   
   >    A*x = b,   or   A**T*x = b,   
   >   
   > where b and x are n element vectors and A is an n by n unit, or   
   > non-unit, upper or lower triangular matrix.   
   >   
   > No test for singularity or near-singularity is included in this   
   > routine. Such tests must be performed before calling this routine.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] UPLO   
   > \verbatim   
   >          UPLO is CHARACTER*1   
   >           On entry, UPLO specifies whether the matrix is an upper or   
   >           lower triangular matrix as follows:   
   >   
   >              UPLO = 'U' or 'u'   A is an upper triangular matrix.   
   >   
   >              UPLO = 'L' or 'l'   A is a lower triangular matrix.   
   > \endverbatim   
   >   
   > \param[in] TRANS   
   > \verbatim   
   >          TRANS is CHARACTER*1   
   >           On entry, TRANS specifies the equations to be solved as   
   >           follows:   
   >   
   >              TRANS = 'N' or 'n'   A*x = b.   
   >   
   >              TRANS = 'T' or 't'   A**T*x = b.   
   >   
   >              TRANS = 'C' or 'c'   A**T*x = b.   
   > \endverbatim   
   >   
   > \param[in] DIAG   
   > \verbatim   
   >          DIAG is CHARACTER*1   
   >           On entry, DIAG specifies whether or not A is unit   
   >           triangular as follows:   
   >   
   >              DIAG = 'U' or 'u'   A is assumed to be unit triangular.   
   >   
   >              DIAG = 'N' or 'n'   A is not assumed to be unit   
   >                                  triangular.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the order of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry with  UPLO = 'U' or 'u', the leading n by n   
   >           upper triangular part of the array A must contain the upper   
   >           triangular matrix and the strictly lower triangular part of   
   >           A is not referenced.   
   >           Before entry with UPLO = 'L' or 'l', the leading n by n   
   >           lower triangular part of the array A must contain the lower   
   >           triangular matrix and the strictly upper triangular part of   
   >           A is not referenced.   
   >           Note that when  DIAG = 'U' or 'u', the diagonal elements of   
   >           A are not referenced either, but are assumed to be unity.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, n ).   
   > \endverbatim   
   >   
   > \param[in,out] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the n   
   >           element right-hand side vector b. On exit, X is overwritten   
   >           with the solution vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   >   
   >  Level 2 Blas routine.   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup double_blas_level1   

    =====================================================================   
   Subroutine */ int igraphdtrsv_(char *uplo, char *trans, char *diag, integer *n, 
	doublereal *a, integer *lda, doublereal *x, integer *incx)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, jx, kx, info;
    doublereal temp;
    extern logical igraphlsame_(char *, char *);
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    logical nounit;


/*  -- Reference BLAS level1 routine (version 3.7.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    --x;

    /* Function Body */
    info = 0;
    if (! igraphlsame_(uplo, "U") && ! igraphlsame_(uplo, "L")) {
	info = 1;
    } else if (! igraphlsame_(trans, "N") && ! igraphlsame_(trans, 
	    "T") && ! igraphlsame_(trans, "C")) {
	info = 2;
    } else if (! igraphlsame_(diag, "U") && ! igraphlsame_(diag, 
	    "N")) {
	info = 3;
    } else if (*n < 0) {
	info = 4;
    } else if (*lda < max(1,*n)) {
	info = 6;
    } else if (*incx == 0) {
	info = 8;
    }
    if (info != 0) {
	igraphxerbla_("DTRSV ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*n == 0) {
	return 0;
    }

    nounit = igraphlsame_(diag, "N");

/*     Set up the start point in X if the increment is not unity. This   
       will be  ( N - 1 )*INCX  too small for descending loops. */

    if (*incx <= 0) {
	kx = 1 - (*n - 1) * *incx;
    } else if (*incx != 1) {
	kx = 1;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through A. */

    if (igraphlsame_(trans, "N")) {

/*        Form  x := inv( A )*x. */

	if (igraphlsame_(uplo, "U")) {
	    if (*incx == 1) {
		for (j = *n; j >= 1; --j) {
		    if (x[j] != 0.) {
			if (nounit) {
			    x[j] /= a[j + j * a_dim1];
			}
			temp = x[j];
			for (i__ = j - 1; i__ >= 1; --i__) {
			    x[i__] -= temp * a[i__ + j * a_dim1];
/* L10: */
			}
		    }
/* L20: */
		}
	    } else {
		jx = kx + (*n - 1) * *incx;
		for (j = *n; j >= 1; --j) {
		    if (x[jx] != 0.) {
			if (nounit) {
			    x[jx] /= a[j + j * a_dim1];
			}
			temp = x[jx];
			ix = jx;
			for (i__ = j - 1; i__ >= 1; --i__) {
			    ix -= *incx;
			    x[ix] -= temp * a[i__ + j * a_dim1];
/* L30: */
			}
		    }
		    jx -= *incx;
/* L40: */
		}
	    }
	} else {
	    if (*incx == 1) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (x[j] != 0.) {
			if (nounit) {
			    x[j] /= a[j + j * a_dim1];
			}
			temp = x[j];
			i__2 = *n;
			for (i__ = j + 1; i__ <= i__2; ++i__) {
			    x[i__] -= temp * a[i__ + j * a_dim1];
/* L50: */
			}
		    }
/* L60: */
		}
	    } else {
		jx = kx;
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    if (x[jx] != 0.) {
			if (nounit) {
			    x[jx] /= a[j + j * a_dim1];
			}
			temp = x[jx];
			ix = jx;
			i__2 = *n;
			for (i__ = j + 1; i__ <= i__2; ++i__) {
			    ix += *incx;
			    x[ix] -= temp * a[i__ + j * a_dim1];
/* L70: */
			}
		    }
		    jx += *incx;
/* L80: */
		}
	    }
	}
    } else {

/*        Form  x := inv( A**T )*x. */

	if (igraphlsame_(uplo, "U")) {
	    if (*incx == 1) {
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    temp = x[j];
		    i__2 = j - 1;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			temp -= a[i__ + j * a_dim1] * x[i__];
/* L90: */
		    }
		    if (nounit) {
			temp /= a[j + j * a_dim1];
		    }
		    x[j] = temp;
/* L100: */
		}
	    } else {
		jx = kx;
		i__1 = *n;
		for (j = 1; j <= i__1; ++j) {
		    temp = x[jx];
		    ix = kx;
		    i__2 = j - 1;
		    for (i__ = 1; i__ <= i__2; ++i__) {
			temp -= a[i__ + j * a_dim1] * x[ix];
			ix += *incx;
/* L110: */
		    }
		    if (nounit) {
			temp /= a[j + j * a_dim1];
		    }
		    x[jx] = temp;
		    jx += *incx;
/* L120: */
		}
	    }
	} else {
	    if (*incx == 1) {
		for (j = *n; j >= 1; --j) {
		    temp = x[j];
		    i__1 = j + 1;
		    for (i__ = *n; i__ >= i__1; --i__) {
			temp -= a[i__ + j * a_dim1] * x[i__];
/* L130: */
		    }
		    if (nounit) {
			temp /= a[j + j * a_dim1];
		    }
		    x[j] = temp;
/* L140: */
		}
	    } else {
		kx += (*n - 1) * *incx;
		jx = kx;
		for (j = *n; j >= 1; --j) {
		    temp = x[jx];
		    ix = kx;
		    i__1 = j + 1;
		    for (i__ = *n; i__ >= i__1; --i__) {
			temp -= a[i__ + j * a_dim1] * x[ix];
			ix -= *incx;
/* L150: */
		    }
		    if (nounit) {
			temp /= a[j + j * a_dim1];
		    }
		    x[jx] = temp;
		    jx -= *incx;
/* L160: */
		}
	    }
	}
    }

    return 0;

/*     End of DTRSV . */

} /* igraphdtrsv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dtrsyl.c0000644000175100001710000011414200000000000024072 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static logical c_false = FALSE_;
static integer c__2 = 2;
static doublereal c_b26 = 1.;
static doublereal c_b30 = 0.;
static logical c_true = TRUE_;

/* > \brief \b DTRSYL   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download DTRSYL + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE DTRSYL( TRANA, TRANB, ISGN, M, N, A, LDA, B, LDB, C,   
                            LDC, SCALE, INFO )   

         CHARACTER          TRANA, TRANB   
         INTEGER            INFO, ISGN, LDA, LDB, LDC, M, N   
         DOUBLE PRECISION   SCALE   
         DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), C( LDC, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DTRSYL solves the real Sylvester matrix equation:   
   >   
   >    op(A)*X + X*op(B) = scale*C or   
   >    op(A)*X - X*op(B) = scale*C,   
   >   
   > where op(A) = A or A**T, and  A and B are both upper quasi-   
   > triangular. A is M-by-M and B is N-by-N; the right hand side C and   
   > the solution X are M-by-N; and scale is an output scale factor, set   
   > <= 1 to avoid overflow in X.   
   >   
   > A and B must be in Schur canonical form (as returned by DHSEQR), that   
   > is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks;   
   > each 2-by-2 diagonal block has its diagonal elements equal and its   
   > off-diagonal elements of opposite sign.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] TRANA   
   > \verbatim   
   >          TRANA is CHARACTER*1   
   >          Specifies the option op(A):   
   >          = 'N': op(A) = A    (No transpose)   
   >          = 'T': op(A) = A**T (Transpose)   
   >          = 'C': op(A) = A**H (Conjugate transpose = Transpose)   
   > \endverbatim   
   >   
   > \param[in] TRANB   
   > \verbatim   
   >          TRANB is CHARACTER*1   
   >          Specifies the option op(B):   
   >          = 'N': op(B) = B    (No transpose)   
   >          = 'T': op(B) = B**T (Transpose)   
   >          = 'C': op(B) = B**H (Conjugate transpose = Transpose)   
   > \endverbatim   
   >   
   > \param[in] ISGN   
   > \verbatim   
   >          ISGN is INTEGER   
   >          Specifies the sign in the equation:   
   >          = +1: solve op(A)*X + X*op(B) = scale*C   
   >          = -1: solve op(A)*X - X*op(B) = scale*C   
   > \endverbatim   
   >   
   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The order of the matrix A, and the number of rows in the   
   >          matrices X and C. M >= 0.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The order of the matrix B, and the number of columns in the   
   >          matrices X and C. N >= 0.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,M)   
   >          The upper quasi-triangular matrix A, in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A. LDA >= max(1,M).   
   > \endverbatim   
   >   
   > \param[in] B   
   > \verbatim   
   >          B is DOUBLE PRECISION array, dimension (LDB,N)   
   >          The upper quasi-triangular matrix B, in Schur canonical form.   
   > \endverbatim   
   >   
   > \param[in] LDB   
   > \verbatim   
   >          LDB is INTEGER   
   >          The leading dimension of the array B. LDB >= max(1,N).   
   > \endverbatim   
   >   
   > \param[in,out] C   
   > \verbatim   
   >          C is DOUBLE PRECISION array, dimension (LDC,N)   
   >          On entry, the M-by-N right hand side matrix C.   
   >          On exit, C is overwritten by the solution matrix X.   
   > \endverbatim   
   >   
   > \param[in] LDC   
   > \verbatim   
   >          LDC is INTEGER   
   >          The leading dimension of the array C. LDC >= max(1,M)   
   > \endverbatim   
   >   
   > \param[out] SCALE   
   > \verbatim   
   >          SCALE is DOUBLE PRECISION   
   >          The scale factor, scale, set <= 1 to avoid overflow in X.   
   > \endverbatim   
   >   
   > \param[out] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          = 0: successful exit   
   >          < 0: if INFO = -i, the i-th argument had an illegal value   
   >          = 1: A and B have common or very close eigenvalues; perturbed   
   >               values were used to solve the equation (but the matrices   
   >               A and B are unchanged).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup doubleSYcomputational   

    =====================================================================   
   Subroutine */ int igraphdtrsyl_(char *trana, char *tranb, integer *isgn, integer 
	*m, integer *n, doublereal *a, integer *lda, doublereal *b, integer *
	ldb, doublereal *c__, integer *ldc, doublereal *scale, integer *info)
{
    /* System generated locals */
    integer a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2, 
	    i__3, i__4;
    doublereal d__1, d__2;

    /* Local variables */
    integer j, k, l;
    doublereal x[4]	/* was [2][2] */;
    integer k1, k2, l1, l2;
    doublereal a11, db, da11, vec[4]	/* was [2][2] */, dum[1], eps, sgn;
    extern doublereal igraphddot_(integer *, doublereal *, integer *, doublereal *, 
	    integer *);
    integer ierr;
    doublereal smin, suml, sumr;
    extern /* Subroutine */ int igraphdscal_(integer *, doublereal *, doublereal *, 
	    integer *);
    extern logical igraphlsame_(char *, char *);
    integer knext, lnext;
    doublereal xnorm;
    extern /* Subroutine */ int igraphdlaln2_(logical *, integer *, integer *, 
	    doublereal *, doublereal *, doublereal *, integer *, doublereal *,
	     doublereal *, doublereal *, integer *, doublereal *, doublereal *
	    , doublereal *, integer *, doublereal *, doublereal *, integer *),
	     igraphdlasy2_(logical *, logical *, integer *, integer *, integer *, 
	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
	    integer *), igraphdlabad_(doublereal *, doublereal *);
    extern doublereal igraphdlamch_(char *), igraphdlange_(char *, integer *, 
	    integer *, doublereal *, integer *, doublereal *);
    doublereal scaloc;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);
    doublereal bignum;
    logical notrna, notrnb;
    doublereal smlnum;


/*  -- LAPACK computational routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    =====================================================================   


       Decode and Test input parameters   

       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;
    b_dim1 = *ldb;
    b_offset = 1 + b_dim1;
    b -= b_offset;
    c_dim1 = *ldc;
    c_offset = 1 + c_dim1;
    c__ -= c_offset;

    /* Function Body */
    notrna = igraphlsame_(trana, "N");
    notrnb = igraphlsame_(tranb, "N");

    *info = 0;
    if (! notrna && ! igraphlsame_(trana, "T") && ! igraphlsame_(
	    trana, "C")) {
	*info = -1;
    } else if (! notrnb && ! igraphlsame_(tranb, "T") && ! 
	    igraphlsame_(tranb, "C")) {
	*info = -2;
    } else if (*isgn != 1 && *isgn != -1) {
	*info = -3;
    } else if (*m < 0) {
	*info = -4;
    } else if (*n < 0) {
	*info = -5;
    } else if (*lda < max(1,*m)) {
	*info = -7;
    } else if (*ldb < max(1,*n)) {
	*info = -9;
    } else if (*ldc < max(1,*m)) {
	*info = -11;
    }
    if (*info != 0) {
	i__1 = -(*info);
	igraphxerbla_("DTRSYL", &i__1, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible */

    *scale = 1.;
    if (*m == 0 || *n == 0) {
	return 0;
    }

/*     Set constants to control overflow */

    eps = igraphdlamch_("P");
    smlnum = igraphdlamch_("S");
    bignum = 1. / smlnum;
    igraphdlabad_(&smlnum, &bignum);
    smlnum = smlnum * (doublereal) (*m * *n) / eps;
    bignum = 1. / smlnum;

/* Computing MAX */
    d__1 = smlnum, d__2 = eps * igraphdlange_("M", m, m, &a[a_offset], lda, dum), d__1 = max(d__1,d__2), d__2 = eps * igraphdlange_("M", n, n, 
	    &b[b_offset], ldb, dum);
    smin = max(d__1,d__2);

    sgn = (doublereal) (*isgn);

    if (notrna && notrnb) {

/*        Solve    A*X + ISGN*X*B = scale*C.   

          The (K,L)th block of X is determined starting from   
          bottom-left corner column by column by   

           A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)   

          Where   
                    M                         L-1   
          R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(J,L)].   
                  I=K+1                       J=1   

          Start column loop (index = L)   
          L1 (L2) : column index of the first (first) row of X(K,L). */

	lnext = 1;
	i__1 = *n;
	for (l = 1; l <= i__1; ++l) {
	    if (l < lnext) {
		goto L60;
	    }
	    if (l == *n) {
		l1 = l;
		l2 = l;
	    } else {
		if (b[l + 1 + l * b_dim1] != 0.) {
		    l1 = l;
		    l2 = l + 1;
		    lnext = l + 2;
		} else {
		    l1 = l;
		    l2 = l;
		    lnext = l + 1;
		}
	    }

/*           Start row loop (index = K)   
             K1 (K2): row index of the first (last) row of X(K,L). */

	    knext = *m;
	    for (k = *m; k >= 1; --k) {
		if (k > knext) {
		    goto L50;
		}
		if (k == 1) {
		    k1 = k;
		    k2 = k;
		} else {
		    if (a[k + (k - 1) * a_dim1] != 0.) {
			k1 = k - 1;
			k2 = k;
			knext = k - 2;
		    } else {
			k1 = k;
			k2 = k;
			knext = k - 1;
		    }
		}

		if (l1 == l2 && k1 == k2) {
		    i__2 = *m - k1;
/* Computing MIN */
		    i__3 = k1 + 1;
/* Computing MIN */
		    i__4 = k1 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);
		    scaloc = 1.;

		    a11 = a[k1 + k1 * a_dim1] + sgn * b[l1 + l1 * b_dim1];
		    da11 = abs(a11);
		    if (da11 <= smin) {
			a11 = smin;
			da11 = smin;
			*info = 1;
		    }
		    db = abs(vec[0]);
		    if (da11 < 1. && db > 1.) {
			if (db > bignum * da11) {
			    scaloc = 1. / db;
			}
		    }
		    x[0] = vec[0] * scaloc / a11;

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L10: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];

		} else if (l1 == l2 && k1 != k2) {

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k2 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    d__1 = -sgn * b[l1 + l1 * b_dim1];
		    igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b26, &a[k1 + k1 
			    * a_dim1], lda, &c_b26, &c_b26, vec, &c__2, &d__1,
			     &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L20: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k2 + l1 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 == k2) {

		    i__2 = *m - k1;
/* Computing MIN */
		    i__3 = k1 + 1;
/* Computing MIN */
		    i__4 = k1 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = sgn * (c__[k1 + l1 * c_dim1] - (suml + sgn * 
			    sumr));

		    i__2 = *m - k1;
/* Computing MIN */
		    i__3 = k1 + 1;
/* Computing MIN */
		    i__4 = k1 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l2 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = sgn * (c__[k1 + l2 * c_dim1] - (suml + sgn * 
			    sumr));

		    d__1 = -sgn * a[k1 + k1 * a_dim1];
		    igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b26, &b[l1 + l1 *
			     b_dim1], ldb, &c_b26, &c_b26, vec, &c__2, &d__1, 
			    &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L30: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 != k2) {

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k1 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l2 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[2] = c__[k1 + l2 * c_dim1] - (suml + sgn * sumr);

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k2 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l1 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = *m - k2;
/* Computing MIN */
		    i__3 = k2 + 1;
/* Computing MIN */
		    i__4 = k2 + 1;
		    suml = igraphddot_(&i__2, &a[k2 + min(i__3,*m) * a_dim1], lda, &
			    c__[min(i__4,*m) + l2 * c_dim1], &c__1);
		    i__2 = l1 - 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[3] = c__[k2 + l2 * c_dim1] - (suml + sgn * sumr);

		    igraphdlasy2_(&c_false, &c_false, isgn, &c__2, &c__2, &a[k1 + 
			    k1 * a_dim1], lda, &b[l1 + l1 * b_dim1], ldb, vec,
			     &c__2, &scaloc, x, &c__2, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L40: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[2];
		    c__[k2 + l1 * c_dim1] = x[1];
		    c__[k2 + l2 * c_dim1] = x[3];
		}

L50:
		;
	    }

L60:
	    ;
	}

    } else if (! notrna && notrnb) {

/*        Solve    A**T *X + ISGN*X*B = scale*C.   

          The (K,L)th block of X is determined starting from   
          upper-left corner column by column by   

            A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)   

          Where   
                     K-1        T                    L-1   
            R(K,L) = SUM [A(I,K)**T*X(I,L)] +ISGN*SUM [X(K,J)*B(J,L)]   
                     I=1                          J=1   

          Start column loop (index = L)   
          L1 (L2): column index of the first (last) row of X(K,L) */

	lnext = 1;
	i__1 = *n;
	for (l = 1; l <= i__1; ++l) {
	    if (l < lnext) {
		goto L120;
	    }
	    if (l == *n) {
		l1 = l;
		l2 = l;
	    } else {
		if (b[l + 1 + l * b_dim1] != 0.) {
		    l1 = l;
		    l2 = l + 1;
		    lnext = l + 2;
		} else {
		    l1 = l;
		    l2 = l;
		    lnext = l + 1;
		}
	    }

/*           Start row loop (index = K)   
             K1 (K2): row index of the first (last) row of X(K,L) */

	    knext = 1;
	    i__2 = *m;
	    for (k = 1; k <= i__2; ++k) {
		if (k < knext) {
		    goto L110;
		}
		if (k == *m) {
		    k1 = k;
		    k2 = k;
		} else {
		    if (a[k + 1 + k * a_dim1] != 0.) {
			k1 = k;
			k2 = k + 1;
			knext = k + 2;
		    } else {
			k1 = k;
			k2 = k;
			knext = k + 1;
		    }
		}

		if (l1 == l2 && k1 == k2) {
		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);
		    scaloc = 1.;

		    a11 = a[k1 + k1 * a_dim1] + sgn * b[l1 + l1 * b_dim1];
		    da11 = abs(a11);
		    if (da11 <= smin) {
			a11 = smin;
			da11 = smin;
			*info = 1;
		    }
		    db = abs(vec[0]);
		    if (da11 < 1. && db > 1.) {
			if (db > bignum * da11) {
			    scaloc = 1. / db;
			}
		    }
		    x[0] = vec[0] * scaloc / a11;

		    if (scaloc != 1.) {
			i__3 = *n;
			for (j = 1; j <= i__3; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L70: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];

		} else if (l1 == l2 && k1 != k2) {

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k2 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k2 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    d__1 = -sgn * b[l1 + l1 * b_dim1];
		    igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b26, &a[k1 + k1 *
			     a_dim1], lda, &c_b26, &c_b26, vec, &c__2, &d__1, 
			    &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__3 = *n;
			for (j = 1; j <= i__3; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L80: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k2 + l1 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 == k2) {

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = sgn * (c__[k1 + l1 * c_dim1] - (suml + sgn * 
			    sumr));

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = sgn * (c__[k1 + l2 * c_dim1] - (suml + sgn * 
			    sumr));

		    d__1 = -sgn * a[k1 + k1 * a_dim1];
		    igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b26, &b[l1 + l1 *
			     b_dim1], ldb, &c_b26, &c_b26, vec, &c__2, &d__1, 
			    &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__3 = *n;
			for (j = 1; j <= i__3; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L90: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 != k2) {

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k1 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k1 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[2] = c__[k1 + l2 * c_dim1] - (suml + sgn * sumr);

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k2 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k2 + c_dim1], ldc, &b[l1 * 
			    b_dim1 + 1], &c__1);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__3 = k1 - 1;
		    suml = igraphddot_(&i__3, &a[k2 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__3 = l1 - 1;
		    sumr = igraphddot_(&i__3, &c__[k2 + c_dim1], ldc, &b[l2 * 
			    b_dim1 + 1], &c__1);
		    vec[3] = c__[k2 + l2 * c_dim1] - (suml + sgn * sumr);

		    igraphdlasy2_(&c_true, &c_false, isgn, &c__2, &c__2, &a[k1 + k1 
			    * a_dim1], lda, &b[l1 + l1 * b_dim1], ldb, vec, &
			    c__2, &scaloc, x, &c__2, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__3 = *n;
			for (j = 1; j <= i__3; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L100: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[2];
		    c__[k2 + l1 * c_dim1] = x[1];
		    c__[k2 + l2 * c_dim1] = x[3];
		}

L110:
		;
	    }
L120:
	    ;
	}

    } else if (! notrna && ! notrnb) {

/*        Solve    A**T*X + ISGN*X*B**T = scale*C.   

          The (K,L)th block of X is determined starting from   
          top-right corner column by column by   

             A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)   

          Where   
                       K-1                            N   
              R(K,L) = SUM [A(I,K)**T*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].   
                       I=1                          J=L+1   

          Start column loop (index = L)   
          L1 (L2): column index of the first (last) row of X(K,L) */

	lnext = *n;
	for (l = *n; l >= 1; --l) {
	    if (l > lnext) {
		goto L180;
	    }
	    if (l == 1) {
		l1 = l;
		l2 = l;
	    } else {
		if (b[l + (l - 1) * b_dim1] != 0.) {
		    l1 = l - 1;
		    l2 = l;
		    lnext = l - 2;
		} else {
		    l1 = l;
		    l2 = l;
		    lnext = l - 1;
		}
	    }

/*           Start row loop (index = K)   
             K1 (K2): row index of the first (last) row of X(K,L) */

	    knext = 1;
	    i__1 = *m;
	    for (k = 1; k <= i__1; ++k) {
		if (k < knext) {
		    goto L170;
		}
		if (k == *m) {
		    k1 = k;
		    k2 = k;
		} else {
		    if (a[k + 1 + k * a_dim1] != 0.) {
			k1 = k;
			k2 = k + 1;
			knext = k + 2;
		    } else {
			k1 = k;
			k2 = k;
			knext = k + 1;
		    }
		}

		if (l1 == l2 && k1 == k2) {
		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l1;
/* Computing MIN */
		    i__3 = l1 + 1;
/* Computing MIN */
		    i__4 = l1 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);
		    scaloc = 1.;

		    a11 = a[k1 + k1 * a_dim1] + sgn * b[l1 + l1 * b_dim1];
		    da11 = abs(a11);
		    if (da11 <= smin) {
			a11 = smin;
			da11 = smin;
			*info = 1;
		    }
		    db = abs(vec[0]);
		    if (da11 < 1. && db > 1.) {
			if (db > bignum * da11) {
			    scaloc = 1. / db;
			}
		    }
		    x[0] = vec[0] * scaloc / a11;

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L130: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];

		} else if (l1 == l2 && k1 != k2) {

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k2 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    d__1 = -sgn * b[l1 + l1 * b_dim1];
		    igraphdlaln2_(&c_true, &c__2, &c__1, &smin, &c_b26, &a[k1 + k1 *
			     a_dim1], lda, &c_b26, &c_b26, vec, &c__2, &d__1, 
			    &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L140: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k2 + l1 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 == k2) {

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[0] = sgn * (c__[k1 + l1 * c_dim1] - (suml + sgn * 
			    sumr));

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l2 + min(i__4,*n) * b_dim1], ldb);
		    vec[1] = sgn * (c__[k1 + l2 * c_dim1] - (suml + sgn * 
			    sumr));

		    d__1 = -sgn * a[k1 + k1 * a_dim1];
		    igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b26, &b[l1 + l1 
			    * b_dim1], ldb, &c_b26, &c_b26, vec, &c__2, &d__1,
			     &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L150: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 != k2) {

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k1 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k1 + min(i__3,*n) * c_dim1], ldc,
			     &b[l2 + min(i__4,*n) * b_dim1], ldb);
		    vec[2] = c__[k1 + l2 * c_dim1] - (suml + sgn * sumr);

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k2 * a_dim1 + 1], &c__1, &c__[l1 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + min(i__3,*n) * c_dim1], ldc,
			     &b[l1 + min(i__4,*n) * b_dim1], ldb);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__2 = k1 - 1;
		    suml = igraphddot_(&i__2, &a[k2 * a_dim1 + 1], &c__1, &c__[l2 * 
			    c_dim1 + 1], &c__1);
		    i__2 = *n - l2;
/* Computing MIN */
		    i__3 = l2 + 1;
/* Computing MIN */
		    i__4 = l2 + 1;
		    sumr = igraphddot_(&i__2, &c__[k2 + min(i__3,*n) * c_dim1], ldc,
			     &b[l2 + min(i__4,*n) * b_dim1], ldb);
		    vec[3] = c__[k2 + l2 * c_dim1] - (suml + sgn * sumr);

		    igraphdlasy2_(&c_true, &c_true, isgn, &c__2, &c__2, &a[k1 + k1 *
			     a_dim1], lda, &b[l1 + l1 * b_dim1], ldb, vec, &
			    c__2, &scaloc, x, &c__2, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__2 = *n;
			for (j = 1; j <= i__2; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L160: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[2];
		    c__[k2 + l1 * c_dim1] = x[1];
		    c__[k2 + l2 * c_dim1] = x[3];
		}

L170:
		;
	    }
L180:
	    ;
	}

    } else if (notrna && ! notrnb) {

/*        Solve    A*X + ISGN*X*B**T = scale*C.   

          The (K,L)th block of X is determined starting from   
          bottom-right corner column by column by   

              A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)   

          Where   
                        M                          N   
              R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].   
                      I=K+1                      J=L+1   

          Start column loop (index = L)   
          L1 (L2): column index of the first (last) row of X(K,L) */

	lnext = *n;
	for (l = *n; l >= 1; --l) {
	    if (l > lnext) {
		goto L240;
	    }
	    if (l == 1) {
		l1 = l;
		l2 = l;
	    } else {
		if (b[l + (l - 1) * b_dim1] != 0.) {
		    l1 = l - 1;
		    l2 = l;
		    lnext = l - 2;
		} else {
		    l1 = l;
		    l2 = l;
		    lnext = l - 1;
		}
	    }

/*           Start row loop (index = K)   
             K1 (K2): row index of the first (last) row of X(K,L) */

	    knext = *m;
	    for (k = *m; k >= 1; --k) {
		if (k > knext) {
		    goto L230;
		}
		if (k == 1) {
		    k1 = k;
		    k2 = k;
		} else {
		    if (a[k + (k - 1) * a_dim1] != 0.) {
			k1 = k - 1;
			k2 = k;
			knext = k - 2;
		    } else {
			k1 = k;
			k2 = k;
			knext = k - 1;
		    }
		}

		if (l1 == l2 && k1 == k2) {
		    i__1 = *m - k1;
/* Computing MIN */
		    i__2 = k1 + 1;
/* Computing MIN */
		    i__3 = k1 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l1;
/* Computing MIN */
		    i__2 = l1 + 1;
/* Computing MIN */
		    i__3 = l1 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);
		    scaloc = 1.;

		    a11 = a[k1 + k1 * a_dim1] + sgn * b[l1 + l1 * b_dim1];
		    da11 = abs(a11);
		    if (da11 <= smin) {
			a11 = smin;
			da11 = smin;
			*info = 1;
		    }
		    db = abs(vec[0]);
		    if (da11 < 1. && db > 1.) {
			if (db > bignum * da11) {
			    scaloc = 1. / db;
			}
		    }
		    x[0] = vec[0] * scaloc / a11;

		    if (scaloc != 1.) {
			i__1 = *n;
			for (j = 1; j <= i__1; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L190: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];

		} else if (l1 == l2 && k1 != k2) {

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k2 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k2 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    d__1 = -sgn * b[l1 + l1 * b_dim1];
		    igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b26, &a[k1 + k1 
			    * a_dim1], lda, &c_b26, &c_b26, vec, &c__2, &d__1,
			     &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__1 = *n;
			for (j = 1; j <= i__1; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L200: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k2 + l1 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 == k2) {

		    i__1 = *m - k1;
/* Computing MIN */
		    i__2 = k1 + 1;
/* Computing MIN */
		    i__3 = k1 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[0] = sgn * (c__[k1 + l1 * c_dim1] - (suml + sgn * 
			    sumr));

		    i__1 = *m - k1;
/* Computing MIN */
		    i__2 = k1 + 1;
/* Computing MIN */
		    i__3 = k1 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l2 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l2 + min(i__3,*n) * b_dim1], ldb);
		    vec[1] = sgn * (c__[k1 + l2 * c_dim1] - (suml + sgn * 
			    sumr));

		    d__1 = -sgn * a[k1 + k1 * a_dim1];
		    igraphdlaln2_(&c_false, &c__2, &c__1, &smin, &c_b26, &b[l1 + l1 
			    * b_dim1], ldb, &c_b26, &c_b26, vec, &c__2, &d__1,
			     &c_b30, x, &c__2, &scaloc, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__1 = *n;
			for (j = 1; j <= i__1; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L210: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[1];

		} else if (l1 != l2 && k1 != k2) {

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[0] = c__[k1 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k1 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l2 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k1 + min(i__2,*n) * c_dim1], ldc,
			     &b[l2 + min(i__3,*n) * b_dim1], ldb);
		    vec[2] = c__[k1 + l2 * c_dim1] - (suml + sgn * sumr);

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k2 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l1 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k2 + min(i__2,*n) * c_dim1], ldc,
			     &b[l1 + min(i__3,*n) * b_dim1], ldb);
		    vec[1] = c__[k2 + l1 * c_dim1] - (suml + sgn * sumr);

		    i__1 = *m - k2;
/* Computing MIN */
		    i__2 = k2 + 1;
/* Computing MIN */
		    i__3 = k2 + 1;
		    suml = igraphddot_(&i__1, &a[k2 + min(i__2,*m) * a_dim1], lda, &
			    c__[min(i__3,*m) + l2 * c_dim1], &c__1);
		    i__1 = *n - l2;
/* Computing MIN */
		    i__2 = l2 + 1;
/* Computing MIN */
		    i__3 = l2 + 1;
		    sumr = igraphddot_(&i__1, &c__[k2 + min(i__2,*n) * c_dim1], ldc,
			     &b[l2 + min(i__3,*n) * b_dim1], ldb);
		    vec[3] = c__[k2 + l2 * c_dim1] - (suml + sgn * sumr);

		    igraphdlasy2_(&c_false, &c_true, isgn, &c__2, &c__2, &a[k1 + k1 
			    * a_dim1], lda, &b[l1 + l1 * b_dim1], ldb, vec, &
			    c__2, &scaloc, x, &c__2, &xnorm, &ierr);
		    if (ierr != 0) {
			*info = 1;
		    }

		    if (scaloc != 1.) {
			i__1 = *n;
			for (j = 1; j <= i__1; ++j) {
			    igraphdscal_(m, &scaloc, &c__[j * c_dim1 + 1], &c__1);
/* L220: */
			}
			*scale *= scaloc;
		    }
		    c__[k1 + l1 * c_dim1] = x[0];
		    c__[k1 + l2 * c_dim1] = x[2];
		    c__[k2 + l1 * c_dim1] = x[1];
		    c__[k2 + l2 * c_dim1] = x[3];
		}

L230:
		;
	    }
L240:
	    ;
	}

    }

    return 0;

/*     End of DTRSYL */

} /* igraphdtrsyl_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/dvout.c0000644000175100001710000001711000000000000023707 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
    Routine:    DVOUT   

    Purpose:    Real vector output routine.   

    Usage:      CALL DVOUT (LOUT, N, SX, IDIGIT, IFMT)   

    Arguments   
       N      - Length of array SX.  (Input)   
       SX     - Real array to be printed.  (Input)   
       IFMT   - Format to be used in printing array SX.  (Input)   
       IDIGIT - Print up to IABS(IDIGIT) decimal digits per number.  (In)   
                If IDIGIT .LT. 0, printing is done with 72 columns.   
                If IDIGIT .GT. 0, printing is done with 132 columns.   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphdvout_(integer *lout, integer *n, doublereal *sx, 
	integer *idigit, char *ifmt, ftnlen ifmt_len)
{
    /* Format strings */
    static char fmt_9999[] = "(/1x,a,/1x,a)";
    static char fmt_9998[] = "(1x,i4,\002 - \002,i4,\002:\002,1p,10d12.3)";
    static char fmt_9997[] = "(1x,i4,\002 - \002,i4,\002:\002,1x,1p,8d14.5)";
    static char fmt_9996[] = "(1x,i4,\002 - \002,i4,\002:\002,1x,1p,6d18.9)";
    static char fmt_9995[] = "(1x,i4,\002 - \002,i4,\002:\002,1x,1p,5d24.13)";
    static char fmt_9994[] = "(1x,\002 \002)";

    /* System generated locals */
    integer i__1, i__2, i__3;

    /* Builtin functions */
    integer i_len(char *, ftnlen), s_wsfe(cilist *), do_fio(integer *, char *,
	     ftnlen), e_wsfe(void);

    /* Local variables */
    integer i__, k1, k2, lll;
    char line[80];
    integer ndigit;

    /* Fortran I/O blocks */
    static cilist io___4 = { 0, 0, 0, fmt_9999, 0 };
    static cilist io___8 = { 0, 0, 0, fmt_9998, 0 };
    static cilist io___9 = { 0, 0, 0, fmt_9997, 0 };
    static cilist io___10 = { 0, 0, 0, fmt_9996, 0 };
    static cilist io___11 = { 0, 0, 0, fmt_9995, 0 };
    static cilist io___12 = { 0, 0, 0, fmt_9998, 0 };
    static cilist io___13 = { 0, 0, 0, fmt_9997, 0 };
    static cilist io___14 = { 0, 0, 0, fmt_9996, 0 };
    static cilist io___15 = { 0, 0, 0, fmt_9995, 0 };
    static cilist io___16 = { 0, 0, 0, fmt_9994, 0 };


/*     ...   
       ... SPECIFICATIONS FOR ARGUMENTS   
       ...   
       ... SPECIFICATIONS FOR LOCAL VARIABLES   
       ...   
       ... FIRST EXECUTABLE STATEMENT   


       Parameter adjustments */
    --sx;

    /* Function Body   
   Computing MIN */
    i__1 = i_len(ifmt, ifmt_len);
    lll = min(i__1,80);
    i__1 = lll;
    for (i__ = 1; i__ <= i__1; ++i__) {
	*(unsigned char *)&line[i__ - 1] = '-';
/* L10: */
    }

    for (i__ = lll + 1; i__ <= 80; ++i__) {
	*(unsigned char *)&line[i__ - 1] = ' ';
/* L20: */
    }

    io___4.ciunit = *lout;
    s_wsfe(&io___4);
    do_fio(&c__1, ifmt, ifmt_len);
    do_fio(&c__1, line, lll);
    e_wsfe();

    if (*n <= 0) {
	return 0;
    }
    ndigit = *idigit;
    if (*idigit == 0) {
	ndigit = 4;
    }

/* =======================================================================   
               CODE FOR OUTPUT USING 72 COLUMNS FORMAT   
   ======================================================================= */

    if (*idigit < 0) {
	ndigit = -(*idigit);
	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 5) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 4;
		k2 = min(i__2,i__3);
		io___8.ciunit = *lout;
		s_wsfe(&io___8);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L30: */
	    }
	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 4) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 3;
		k2 = min(i__2,i__3);
		io___9.ciunit = *lout;
		s_wsfe(&io___9);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L40: */
	    }
	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 3) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 2;
		k2 = min(i__2,i__3);
		io___10.ciunit = *lout;
		s_wsfe(&io___10);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L50: */
	    }
	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 2) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 1;
		k2 = min(i__2,i__3);
		io___11.ciunit = *lout;
		s_wsfe(&io___11);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L60: */
	    }
	}

/* =======================================================================   
               CODE FOR OUTPUT USING 132 COLUMNS FORMAT   
   ======================================================================= */

    } else {
	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 10) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 9;
		k2 = min(i__2,i__3);
		io___12.ciunit = *lout;
		s_wsfe(&io___12);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L70: */
	    }
	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 8) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 7;
		k2 = min(i__2,i__3);
		io___13.ciunit = *lout;
		s_wsfe(&io___13);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L80: */
	    }
	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 6) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 5;
		k2 = min(i__2,i__3);
		io___14.ciunit = *lout;
		s_wsfe(&io___14);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L90: */
	    }
	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 5) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 4;
		k2 = min(i__2,i__3);
		io___15.ciunit = *lout;
		s_wsfe(&io___15);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&sx[i__], (ftnlen)sizeof(doublereal)
			    );
		}
		e_wsfe();
/* L100: */
	    }
	}
    }
    io___16.ciunit = *lout;
    s_wsfe(&io___16);
    e_wsfe();
    return 0;
} /* igraphdvout_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/fortran_intrinsics.c0000644000175100001710000000244100000000000026467 0ustar00runnerdocker00000000000000/* -*- mode: C -*-  */
/*
   IGraph library.
   Copyright (C) 2011-12  Gabor Csardi 
   334 Harvard street, Cambridge MA, 02139 USA

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301 USA

*/

#include 

double digitsdbl_(double *x) {
    return (double) DBL_MANT_DIG;
}

double epsilondbl_(double *x) {
    return DBL_EPSILON;
}

double hugedbl_(double *x) {
    return DBL_MAX;
}

double tinydbl_(double *x) {
    return DBL_MIN;
}

int maxexponentdbl_(double *x) {
    return DBL_MAX_EXP;
}

int minexponentdbl_(double *x) {
    return DBL_MIN_EXP;
}

double radixdbl_(double *x) {
    return (double) FLT_RADIX;
}

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/idamax.c0000644000175100001710000000654400000000000024022 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b IDAMAX   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         INTEGER FUNCTION IDAMAX(N,DX,INCX)   

         INTEGER INCX,N   
         DOUBLE PRECISION DX(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >    IDAMAX finds the index of the first element having maximum absolute value.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >         number of elements in input vector(s)   
   > \endverbatim   
   >   
   > \param[in] DX   
   > \verbatim   
   >          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >         storage spacing between elements of SX   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2017   

   > \ingroup aux_blas   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >     jack dongarra, linpack, 3/11/78.   
   >     modified 3/93 to return if incx .le. 0.   
   >     modified 12/3/93, array(1) declarations changed to array(*)   
   > \endverbatim   
   >   
    ===================================================================== */
integer igraphidamax_(integer *n, doublereal *dx, integer *incx)
{
    /* System generated locals */
    integer ret_val, i__1;
    doublereal d__1;

    /* Local variables */
    integer i__, ix;
    doublereal dmax__;


/*  -- Reference BLAS level1 routine (version 3.8.0) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2017   


    =====================================================================   

       Parameter adjustments */
    --dx;

    /* Function Body */
    ret_val = 0;
    if (*n < 1 || *incx <= 0) {
	return ret_val;
    }
    ret_val = 1;
    if (*n == 1) {
	return ret_val;
    }
    if (*incx == 1) {

/*        code for increment equal to 1 */

	dmax__ = abs(dx[1]);
	i__1 = *n;
	for (i__ = 2; i__ <= i__1; ++i__) {
	    if ((d__1 = dx[i__], abs(d__1)) > dmax__) {
		ret_val = i__;
		dmax__ = (d__1 = dx[i__], abs(d__1));
	    }
	}
    } else {

/*        code for increment not equal to 1 */

	ix = 1;
	dmax__ = abs(dx[1]);
	ix += *incx;
	i__1 = *n;
	for (i__ = 2; i__ <= i__1; ++i__) {
	    if ((d__1 = dx[ix], abs(d__1)) > dmax__) {
		ret_val = i__;
		dmax__ = (d__1 = dx[ix], abs(d__1));
	    }
	    ix += *incx;
	}
    }
    return ret_val;
} /* igraphidamax_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/ieeeck.c0000644000175100001710000001151500000000000023776 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b IEEECK   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download IEEECK + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER          FUNCTION IEEECK( ISPEC, ZERO, ONE )   

         INTEGER            ISPEC   
         REAL               ONE, ZERO   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > IEEECK is called from the ILAENV to verify that Infinity and   
   > possibly NaN arithmetic is safe (i.e. will not trap).   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] ISPEC   
   > \verbatim   
   >          ISPEC is INTEGER   
   >          Specifies whether to test just for inifinity arithmetic   
   >          or whether to test for infinity and NaN arithmetic.   
   >          = 0: Verify infinity arithmetic only.   
   >          = 1: Verify infinity and NaN arithmetic.   
   > \endverbatim   
   >   
   > \param[in] ZERO   
   > \verbatim   
   >          ZERO is REAL   
   >          Must contain the value 0.0   
   >          This is passed to prevent the compiler from optimizing   
   >          away this code.   
   > \endverbatim   
   >   
   > \param[in] ONE   
   > \verbatim   
   >          ONE is REAL   
   >          Must contain the value 1.0   
   >          This is passed to prevent the compiler from optimizing   
   >          away this code.   
   >   
   >  RETURN VALUE:  INTEGER   
   >          = 0:  Arithmetic failed to produce the correct answers   
   >          = 1:  Arithmetic produced the correct answers   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
integer igraphieeeck_(integer *ispec, real *zero, real *one)
{
    /* System generated locals */
    integer ret_val;

    /* Local variables */
    real nan1, nan2, nan3, nan4, nan5, nan6, neginf, posinf, negzro, newzro;


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    ===================================================================== */

    ret_val = 1;

    posinf = *one / *zero;
    if (posinf <= *one) {
	ret_val = 0;
	return ret_val;
    }

    neginf = -(*one) / *zero;
    if (neginf >= *zero) {
	ret_val = 0;
	return ret_val;
    }

    negzro = *one / (neginf + *one);
    if (negzro != *zero) {
	ret_val = 0;
	return ret_val;
    }

    neginf = *one / negzro;
    if (neginf >= *zero) {
	ret_val = 0;
	return ret_val;
    }

    newzro = negzro + *zero;
    if (newzro != *zero) {
	ret_val = 0;
	return ret_val;
    }

    posinf = *one / newzro;
    if (posinf <= *one) {
	ret_val = 0;
	return ret_val;
    }

    neginf *= posinf;
    if (neginf >= *zero) {
	ret_val = 0;
	return ret_val;
    }

    posinf *= posinf;
    if (posinf <= *one) {
	ret_val = 0;
	return ret_val;
    }




/*     Return if we were only asked to check infinity arithmetic */

    if (*ispec == 0) {
	return ret_val;
    }

    nan1 = posinf + neginf;

    nan2 = posinf / neginf;

    nan3 = posinf / posinf;

    nan4 = posinf * *zero;

    nan5 = neginf * negzro;

    nan6 = nan5 * *zero;

    if (nan1 == nan1) {
	ret_val = 0;
	return ret_val;
    }

    if (nan2 == nan2) {
	ret_val = 0;
	return ret_val;
    }

    if (nan3 == nan3) {
	ret_val = 0;
	return ret_val;
    }

    if (nan4 == nan4) {
	ret_val = 0;
	return ret_val;
    }

    if (nan5 == nan5) {
	ret_val = 0;
	return ret_val;
    }

    if (nan6 == nan6) {
	ret_val = 0;
	return ret_val;
    }

    return ret_val;
} /* igraphieeeck_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/iladlc.c0000644000175100001710000000713000000000000023777 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b ILADLC scans a matrix for its last non-zero column.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download ILADLC + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER FUNCTION ILADLC( M, N, A, LDA )   

         INTEGER            M, N, LDA   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > ILADLC scans A for its last non-zero column.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The m by n matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A. LDA >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
integer igraphiladlc_(integer *m, integer *n, doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, ret_val, i__1;

    /* Local variables */
    integer i__;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Quick test for the common case where one corner is non-zero.   
       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    if (*n == 0) {
	ret_val = *n;
    } else if (a[*n * a_dim1 + 1] != 0. || a[*m + *n * a_dim1] != 0.) {
	ret_val = *n;
    } else {
/*     Now scan each column from the end, returning with the first non-zero. */
	for (ret_val = *n; ret_val >= 1; --ret_val) {
	    i__1 = *m;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (a[i__ + ret_val * a_dim1] != 0.) {
		    return ret_val;
		}
	    }
	}
    }
    return ret_val;
} /* igraphiladlc_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/iladlr.c0000644000175100001710000000710200000000000024015 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b ILADLR scans a matrix for its last non-zero row.   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download ILADLR + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER FUNCTION ILADLR( M, N, A, LDA )   

         INTEGER            M, N, LDA   
         DOUBLE PRECISION   A( LDA, * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > ILADLR scans A for its last non-zero row.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >          The number of rows of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >          The number of columns of the matrix A.   
   > \endverbatim   
   >   
   > \param[in] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension (LDA,N)   
   >          The m by n matrix A.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >          The leading dimension of the array A. LDA >= max(1,M).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date September 2012   

   > \ingroup auxOTHERauxiliary   

    ===================================================================== */
integer igraphiladlr_(integer *m, integer *n, doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, ret_val, i__1;

    /* Local variables */
    integer i__, j;


/*  -- LAPACK auxiliary routine (version 3.4.2) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       September 2012   


    =====================================================================   


       Quick test for the common case where one corner is non-zero.   
       Parameter adjustments */
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    if (*m == 0) {
	ret_val = *m;
    } else if (a[*m + a_dim1] != 0. || a[*m + *n * a_dim1] != 0.) {
	ret_val = *m;
    } else {
/*     Scan up each column tracking the last zero row seen. */
	ret_val = 0;
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    i__ = *m;
	    while(a[max(i__,1) + j * a_dim1] == 0. && i__ >= 1) {
		--i__;
	    }
	    ret_val = max(ret_val,i__);
	}
    }
    return ret_val;
} /* igraphiladlr_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/ilaenv.c0000644000175100001710000005225400000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;
static real c_b163 = 0.f;
static real c_b164 = 1.f;
static integer c__0 = 0;

/* > \brief \b ILAENV   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download ILAENV + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER FUNCTION ILAENV( ISPEC, NAME, OPTS, N1, N2, N3, N4 )   

         CHARACTER*( * )    NAME, OPTS   
         INTEGER            ISPEC, N1, N2, N3, N4   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > ILAENV is called from the LAPACK routines to choose problem-dependent   
   > parameters for the local environment.  See ISPEC for a description of   
   > the parameters.   
   >   
   > ILAENV returns an INTEGER   
   > if ILAENV >= 0: ILAENV returns the value of the parameter specified by ISPEC   
   > if ILAENV < 0:  if ILAENV = -k, the k-th argument had an illegal value.   
   >   
   > This version provides a set of parameters which should give good,   
   > but not optimal, performance on many of the currently available   
   > computers.  Users are encouraged to modify this subroutine to set   
   > the tuning parameters for their particular machine using the option   
   > and problem size information in the arguments.   
   >   
   > This routine will not function correctly if it is converted to all   
   > lower case.  Converting it to all upper case is allowed.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] ISPEC   
   > \verbatim   
   >          ISPEC is INTEGER   
   >          Specifies the parameter to be returned as the value of   
   >          ILAENV.   
   >          = 1: the optimal blocksize; if this value is 1, an unblocked   
   >               algorithm will give the best performance.   
   >          = 2: the minimum block size for which the block routine   
   >               should be used; if the usable block size is less than   
   >               this value, an unblocked routine should be used.   
   >          = 3: the crossover point (in a block routine, for N less   
   >               than this value, an unblocked routine should be used)   
   >          = 4: the number of shifts, used in the nonsymmetric   
   >               eigenvalue routines (DEPRECATED)   
   >          = 5: the minimum column dimension for blocking to be used;   
   >               rectangular blocks must have dimension at least k by m,   
   >               where k is given by ILAENV(2,...) and m by ILAENV(5,...)   
   >          = 6: the crossover point for the SVD (when reducing an m by n   
   >               matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds   
   >               this value, a QR factorization is used first to reduce   
   >               the matrix to a triangular form.)   
   >          = 7: the number of processors   
   >          = 8: the crossover point for the multishift QR method   
   >               for nonsymmetric eigenvalue problems (DEPRECATED)   
   >          = 9: maximum size of the subproblems at the bottom of the   
   >               computation tree in the divide-and-conquer algorithm   
   >               (used by xGELSD and xGESDD)   
   >          =10: ieee NaN arithmetic can be trusted not to trap   
   >          =11: infinity arithmetic can be trusted not to trap   
   >          12 <= ISPEC <= 16:   
   >               xHSEQR or one of its subroutines,   
   >               see IPARMQ for detailed explanation   
   > \endverbatim   
   >   
   > \param[in] NAME   
   > \verbatim   
   >          NAME is CHARACTER*(*)   
   >          The name of the calling subroutine, in either upper case or   
   >          lower case.   
   > \endverbatim   
   >   
   > \param[in] OPTS   
   > \verbatim   
   >          OPTS is CHARACTER*(*)   
   >          The character options to the subroutine NAME, concatenated   
   >          into a single character string.  For example, UPLO = 'U',   
   >          TRANS = 'T', and DIAG = 'N' for a triangular routine would   
   >          be specified as OPTS = 'UTN'.   
   > \endverbatim   
   >   
   > \param[in] N1   
   > \verbatim   
   >          N1 is INTEGER   
   > \endverbatim   
   >   
   > \param[in] N2   
   > \verbatim   
   >          N2 is INTEGER   
   > \endverbatim   
   >   
   > \param[in] N3   
   > \verbatim   
   >          N3 is INTEGER   
   > \endverbatim   
   >   
   > \param[in] N4   
   > \verbatim   
   >          N4 is INTEGER   
   >          Problem dimensions for the subroutine NAME; these may not all   
   >          be required.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  The following conventions have been used when calling ILAENV from the   
   >  LAPACK routines:   
   >  1)  OPTS is a concatenation of all of the character options to   
   >      subroutine NAME, in the same order that they appear in the   
   >      argument list for NAME, even if they are not used in determining   
   >      the value of the parameter specified by ISPEC.   
   >  2)  The problem dimensions N1, N2, N3, N4 are specified in the order   
   >      that they appear in the argument list for NAME.  N1 is used   
   >      first, N2 second, and so on, and unused problem dimensions are   
   >      passed a value of -1.   
   >  3)  The parameter value returned by ILAENV is checked for validity in   
   >      the calling subroutine.  For example, ILAENV is used to retrieve   
   >      the optimal blocksize for STRTRI as follows:   
   >   
   >      NB = ILAENV( 1, 'STRTRI', UPLO // DIAG, N, -1, -1, -1 )   
   >      IF( NB.LE.1 ) NB = MAX( 1, N )   
   > \endverbatim   
   >   
    ===================================================================== */
integer igraphilaenv_(integer *ispec, char *name__, char *opts, integer *n1, 
	integer *n2, integer *n3, integer *n4, ftnlen name_len, ftnlen 
	opts_len)
{
    /* System generated locals */
    integer ret_val;

    /* Builtin functions   
       Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    integer s_cmp(char *, char *, ftnlen, ftnlen);

    /* Local variables */
    integer i__;
    char c1[1], c2[2], c3[3], c4[2];
    integer ic, nb, iz, nx;
    logical cname;
    integer nbmin;
    logical sname;
    extern integer igraphieeeck_(integer *, real *, real *);
    char subnam[6];
    extern integer igraphiparmq_(integer *, char *, char *, integer *, integer *, 
	    integer *, integer *);


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    ===================================================================== */


    switch (*ispec) {
	case 1:  goto L10;
	case 2:  goto L10;
	case 3:  goto L10;
	case 4:  goto L80;
	case 5:  goto L90;
	case 6:  goto L100;
	case 7:  goto L110;
	case 8:  goto L120;
	case 9:  goto L130;
	case 10:  goto L140;
	case 11:  goto L150;
	case 12:  goto L160;
	case 13:  goto L160;
	case 14:  goto L160;
	case 15:  goto L160;
	case 16:  goto L160;
    }

/*     Invalid value for ISPEC */

    ret_val = -1;
    return ret_val;

L10:

/*     Convert NAME to upper case if the first character is lower case. */

    ret_val = 1;
    s_copy(subnam, name__, (ftnlen)6, name_len);
    ic = *(unsigned char *)subnam;
    iz = 'Z';
    if (iz == 90 || iz == 122) {

/*        ASCII character set */

	if (ic >= 97 && ic <= 122) {
	    *(unsigned char *)subnam = (char) (ic - 32);
	    for (i__ = 2; i__ <= 6; ++i__) {
		ic = *(unsigned char *)&subnam[i__ - 1];
		if (ic >= 97 && ic <= 122) {
		    *(unsigned char *)&subnam[i__ - 1] = (char) (ic - 32);
		}
/* L20: */
	    }
	}

    } else if (iz == 233 || iz == 169) {

/*        EBCDIC character set */

	if (ic >= 129 && ic <= 137 || ic >= 145 && ic <= 153 || ic >= 162 && 
		ic <= 169) {
	    *(unsigned char *)subnam = (char) (ic + 64);
	    for (i__ = 2; i__ <= 6; ++i__) {
		ic = *(unsigned char *)&subnam[i__ - 1];
		if (ic >= 129 && ic <= 137 || ic >= 145 && ic <= 153 || ic >= 
			162 && ic <= 169) {
		    *(unsigned char *)&subnam[i__ - 1] = (char) (ic + 64);
		}
/* L30: */
	    }
	}

    } else if (iz == 218 || iz == 250) {

/*        Prime machines:  ASCII+128 */

	if (ic >= 225 && ic <= 250) {
	    *(unsigned char *)subnam = (char) (ic - 32);
	    for (i__ = 2; i__ <= 6; ++i__) {
		ic = *(unsigned char *)&subnam[i__ - 1];
		if (ic >= 225 && ic <= 250) {
		    *(unsigned char *)&subnam[i__ - 1] = (char) (ic - 32);
		}
/* L40: */
	    }
	}
    }

    *(unsigned char *)c1 = *(unsigned char *)subnam;
    sname = *(unsigned char *)c1 == 'S' || *(unsigned char *)c1 == 'D';
    cname = *(unsigned char *)c1 == 'C' || *(unsigned char *)c1 == 'Z';
    if (! (cname || sname)) {
	return ret_val;
    }
    s_copy(c2, subnam + 1, (ftnlen)2, (ftnlen)2);
    s_copy(c3, subnam + 3, (ftnlen)3, (ftnlen)3);
    s_copy(c4, c3 + 1, (ftnlen)2, (ftnlen)2);

    switch (*ispec) {
	case 1:  goto L50;
	case 2:  goto L60;
	case 3:  goto L70;
    }

L50:

/*     ISPEC = 1:  block size   

       In these examples, separate code is provided for setting NB for   
       real and complex.  We assume that NB will take the same value in   
       single or double precision. */

    nb = 1;

    if (s_cmp(c2, "GE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	} else if (s_cmp(c3, "QRF", (ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, 
		"RQF", (ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, "LQF", (ftnlen)
		3, (ftnlen)3) == 0 || s_cmp(c3, "QLF", (ftnlen)3, (ftnlen)3) 
		== 0) {
	    if (sname) {
		nb = 32;
	    } else {
		nb = 32;
	    }
	} else if (s_cmp(c3, "HRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 32;
	    } else {
		nb = 32;
	    }
	} else if (s_cmp(c3, "BRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 32;
	    } else {
		nb = 32;
	    }
	} else if (s_cmp(c3, "TRI", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	}
    } else if (s_cmp(c2, "PO", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	}
    } else if (s_cmp(c2, "SY", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	} else if (sname && s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 32;
	} else if (sname && s_cmp(c3, "GST", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 64;
	}
    } else if (cname && s_cmp(c2, "HE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 64;
	} else if (s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 32;
	} else if (s_cmp(c3, "GST", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 64;
	}
    } else if (sname && s_cmp(c2, "OR", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nb = 32;
	    }
	} else if (*(unsigned char *)c3 == 'M') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nb = 32;
	    }
	}
    } else if (cname && s_cmp(c2, "UN", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nb = 32;
	    }
	} else if (*(unsigned char *)c3 == 'M') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nb = 32;
	    }
	}
    } else if (s_cmp(c2, "GB", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		if (*n4 <= 64) {
		    nb = 1;
		} else {
		    nb = 32;
		}
	    } else {
		if (*n4 <= 64) {
		    nb = 1;
		} else {
		    nb = 32;
		}
	    }
	}
    } else if (s_cmp(c2, "PB", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		if (*n2 <= 64) {
		    nb = 1;
		} else {
		    nb = 32;
		}
	    } else {
		if (*n2 <= 64) {
		    nb = 1;
		} else {
		    nb = 32;
		}
	    }
	}
    } else if (s_cmp(c2, "TR", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRI", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	}
    } else if (s_cmp(c2, "LA", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "UUM", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nb = 64;
	    } else {
		nb = 64;
	    }
	}
    } else if (sname && s_cmp(c2, "ST", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "EBZ", (ftnlen)3, (ftnlen)3) == 0) {
	    nb = 1;
	}
    }
    ret_val = nb;
    return ret_val;

L60:

/*     ISPEC = 2:  minimum block size */

    nbmin = 2;
    if (s_cmp(c2, "GE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "QRF", (ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, "RQF", (
		ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, "LQF", (ftnlen)3, (
		ftnlen)3) == 0 || s_cmp(c3, "QLF", (ftnlen)3, (ftnlen)3) == 0)
		 {
	    if (sname) {
		nbmin = 2;
	    } else {
		nbmin = 2;
	    }
	} else if (s_cmp(c3, "HRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nbmin = 2;
	    } else {
		nbmin = 2;
	    }
	} else if (s_cmp(c3, "BRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nbmin = 2;
	    } else {
		nbmin = 2;
	    }
	} else if (s_cmp(c3, "TRI", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nbmin = 2;
	    } else {
		nbmin = 2;
	    }
	}
    } else if (s_cmp(c2, "SY", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRF", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nbmin = 8;
	    } else {
		nbmin = 8;
	    }
	} else if (sname && s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nbmin = 2;
	}
    } else if (cname && s_cmp(c2, "HE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nbmin = 2;
	}
    } else if (sname && s_cmp(c2, "OR", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nbmin = 2;
	    }
	} else if (*(unsigned char *)c3 == 'M') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nbmin = 2;
	    }
	}
    } else if (cname && s_cmp(c2, "UN", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nbmin = 2;
	    }
	} else if (*(unsigned char *)c3 == 'M') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nbmin = 2;
	    }
	}
    }
    ret_val = nbmin;
    return ret_val;

L70:

/*     ISPEC = 3:  crossover point */

    nx = 0;
    if (s_cmp(c2, "GE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "QRF", (ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, "RQF", (
		ftnlen)3, (ftnlen)3) == 0 || s_cmp(c3, "LQF", (ftnlen)3, (
		ftnlen)3) == 0 || s_cmp(c3, "QLF", (ftnlen)3, (ftnlen)3) == 0)
		 {
	    if (sname) {
		nx = 128;
	    } else {
		nx = 128;
	    }
	} else if (s_cmp(c3, "HRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nx = 128;
	    } else {
		nx = 128;
	    }
	} else if (s_cmp(c3, "BRD", (ftnlen)3, (ftnlen)3) == 0) {
	    if (sname) {
		nx = 128;
	    } else {
		nx = 128;
	    }
	}
    } else if (s_cmp(c2, "SY", (ftnlen)2, (ftnlen)2) == 0) {
	if (sname && s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nx = 32;
	}
    } else if (cname && s_cmp(c2, "HE", (ftnlen)2, (ftnlen)2) == 0) {
	if (s_cmp(c3, "TRD", (ftnlen)3, (ftnlen)3) == 0) {
	    nx = 32;
	}
    } else if (sname && s_cmp(c2, "OR", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nx = 128;
	    }
	}
    } else if (cname && s_cmp(c2, "UN", (ftnlen)2, (ftnlen)2) == 0) {
	if (*(unsigned char *)c3 == 'G') {
	    if (s_cmp(c4, "QR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "RQ", 
		    (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "LQ", (ftnlen)2, (
		    ftnlen)2) == 0 || s_cmp(c4, "QL", (ftnlen)2, (ftnlen)2) ==
		     0 || s_cmp(c4, "HR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(
		    c4, "TR", (ftnlen)2, (ftnlen)2) == 0 || s_cmp(c4, "BR", (
		    ftnlen)2, (ftnlen)2) == 0) {
		nx = 128;
	    }
	}
    }
    ret_val = nx;
    return ret_val;

L80:

/*     ISPEC = 4:  number of shifts (used by xHSEQR) */

    ret_val = 6;
    return ret_val;

L90:

/*     ISPEC = 5:  minimum column dimension (not used) */

    ret_val = 2;
    return ret_val;

L100:

/*     ISPEC = 6:  crossover point for SVD (used by xGELSS and xGESVD) */

    ret_val = (integer) ((real) min(*n1,*n2) * 1.6f);
    return ret_val;

L110:

/*     ISPEC = 7:  number of processors (not used) */

    ret_val = 1;
    return ret_val;

L120:

/*     ISPEC = 8:  crossover point for multishift (used by xHSEQR) */

    ret_val = 50;
    return ret_val;

L130:

/*     ISPEC = 9:  maximum size of the subproblems at the bottom of the   
                   computation tree in the divide-and-conquer algorithm   
                   (used by xGELSD and xGESDD) */

    ret_val = 25;
    return ret_val;

L140:

/*     ISPEC = 10: ieee NaN arithmetic can be trusted not to trap   

       ILAENV = 0 */
    ret_val = 1;
    if (ret_val == 1) {
	ret_val = igraphieeeck_(&c__1, &c_b163, &c_b164);
    }
    return ret_val;

L150:

/*     ISPEC = 11: infinity arithmetic can be trusted not to trap   

       ILAENV = 0 */
    ret_val = 1;
    if (ret_val == 1) {
	ret_val = igraphieeeck_(&c__0, &c_b163, &c_b164);
    }
    return ret_val;

L160:

/*     12 <= ISPEC <= 16: xHSEQR or one of its subroutines. */

    ret_val = igraphiparmq_(ispec, name__, opts, n1, n2, n3, n4)
	    ;
    return ret_val;

/*     End of ILAENV */

} /* igraphilaenv_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/iparmq.c0000644000175100001710000003011500000000000024037 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b IPARMQ   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download IPARMQ + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         INTEGER FUNCTION IPARMQ( ISPEC, NAME, OPTS, N, ILO, IHI, LWORK )   

         INTEGER            IHI, ILO, ISPEC, LWORK, N   
         CHARACTER          NAME*( * ), OPTS*( * )   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   >      This program sets problem and machine dependent parameters   
   >      useful for xHSEQR and its subroutines. It is called whenever   
   >      ILAENV is called with 12 <= ISPEC <= 16   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] ISPEC   
   > \verbatim   
   >          ISPEC is integer scalar   
   >              ISPEC specifies which tunable parameter IPARMQ should   
   >              return.   
   >   
   >              ISPEC=12: (INMIN)  Matrices of order nmin or less   
   >                        are sent directly to xLAHQR, the implicit   
   >                        double shift QR algorithm.  NMIN must be   
   >                        at least 11.   
   >   
   >              ISPEC=13: (INWIN)  Size of the deflation window.   
   >                        This is best set greater than or equal to   
   >                        the number of simultaneous shifts NS.   
   >                        Larger matrices benefit from larger deflation   
   >                        windows.   
   >   
   >              ISPEC=14: (INIBL) Determines when to stop nibbling and   
   >                        invest in an (expensive) multi-shift QR sweep.   
   >                        If the aggressive early deflation subroutine   
   >                        finds LD converged eigenvalues from an order   
   >                        NW deflation window and LD.GT.(NW*NIBBLE)/100,   
   >                        then the next QR sweep is skipped and early   
   >                        deflation is applied immediately to the   
   >                        remaining active diagonal block.  Setting   
   >                        IPARMQ(ISPEC=14) = 0 causes TTQRE to skip a   
   >                        multi-shift QR sweep whenever early deflation   
   >                        finds a converged eigenvalue.  Setting   
   >                        IPARMQ(ISPEC=14) greater than or equal to 100   
   >                        prevents TTQRE from skipping a multi-shift   
   >                        QR sweep.   
   >   
   >              ISPEC=15: (NSHFTS) The number of simultaneous shifts in   
   >                        a multi-shift QR iteration.   
   >   
   >              ISPEC=16: (IACC22) IPARMQ is set to 0, 1 or 2 with the   
   >                        following meanings.   
   >                        0:  During the multi-shift QR sweep,   
   >                            xLAQR5 does not accumulate reflections and   
   >                            does not use matrix-matrix multiply to   
   >                            update the far-from-diagonal matrix   
   >                            entries.   
   >                        1:  During the multi-shift QR sweep,   
   >                            xLAQR5 and/or xLAQRaccumulates reflections and uses   
   >                            matrix-matrix multiply to update the   
   >                            far-from-diagonal matrix entries.   
   >                        2:  During the multi-shift QR sweep.   
   >                            xLAQR5 accumulates reflections and takes   
   >                            advantage of 2-by-2 block structure during   
   >                            matrix-matrix multiplies.   
   >                        (If xTRMM is slower than xGEMM, then   
   >                        IPARMQ(ISPEC=16)=1 may be more efficient than   
   >                        IPARMQ(ISPEC=16)=2 despite the greater level of   
   >                        arithmetic work implied by the latter choice.)   
   > \endverbatim   
   >   
   > \param[in] NAME   
   > \verbatim   
   >          NAME is character string   
   >               Name of the calling subroutine   
   > \endverbatim   
   >   
   > \param[in] OPTS   
   > \verbatim   
   >          OPTS is character string   
   >               This is a concatenation of the string arguments to   
   >               TTQRE.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is integer scalar   
   >               N is the order of the Hessenberg matrix H.   
   > \endverbatim   
   >   
   > \param[in] ILO   
   > \verbatim   
   >          ILO is INTEGER   
   > \endverbatim   
   >   
   > \param[in] IHI   
   > \verbatim   
   >          IHI is INTEGER   
   >               It is assumed that H is already upper triangular   
   >               in rows and columns 1:ILO-1 and IHI+1:N.   
   > \endverbatim   
   >   
   > \param[in] LWORK   
   > \verbatim   
   >          LWORK is integer scalar   
   >               The amount of workspace available.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >       Little is known about how best to choose these parameters.   
   >       It is possible to use different values of the parameters   
   >       for each of CHSEQR, DHSEQR, SHSEQR and ZHSEQR.   
   >   
   >       It is probably best to choose different parameters for   
   >       different matrices and different parameters at different   
   >       times during the iteration, but this has not been   
   >       implemented --- yet.   
   >   
   >   
   >       The best choices of most of the parameters depend   
   >       in an ill-understood way on the relative execution   
   >       rate of xLAQR3 and xLAQR5 and on the nature of each   
   >       particular eigenvalue problem.  Experiment may be the   
   >       only practical way to determine which choices are most   
   >       effective.   
   >   
   >       Following is a list of default values supplied by IPARMQ.   
   >       These defaults may be adjusted in order to attain better   
   >       performance in any particular computational environment.   
   >   
   >       IPARMQ(ISPEC=12) The xLAHQR vs xLAQR0 crossover point.   
   >                        Default: 75. (Must be at least 11.)   
   >   
   >       IPARMQ(ISPEC=13) Recommended deflation window size.   
   >                        This depends on ILO, IHI and NS, the   
   >                        number of simultaneous shifts returned   
   >                        by IPARMQ(ISPEC=15).  The default for   
   >                        (IHI-ILO+1).LE.500 is NS.  The default   
   >                        for (IHI-ILO+1).GT.500 is 3*NS/2.   
   >   
   >       IPARMQ(ISPEC=14) Nibble crossover point.  Default: 14.   
   >   
   >       IPARMQ(ISPEC=15) Number of simultaneous shifts, NS.   
   >                        a multi-shift QR iteration.   
   >   
   >                        If IHI-ILO+1 is ...   
   >   
   >                        greater than      ...but less    ... the   
   >                        or equal to ...      than        default is   
   >   
   >                                0               30       NS =   2+   
   >                               30               60       NS =   4+   
   >                               60              150       NS =  10   
   >                              150              590       NS =  **   
   >                              590             3000       NS =  64   
   >                             3000             6000       NS = 128   
   >                             6000             infinity   NS = 256   
   >   
   >                    (+)  By default matrices of this order are   
   >                         passed to the implicit double shift routine   
   >                         xLAHQR.  See IPARMQ(ISPEC=12) above.   These   
   >                         values of NS are used only in case of a rare   
   >                         xLAHQR failure.   
   >   
   >                    (**) The asterisks (**) indicate an ad-hoc   
   >                         function increasing from 10 to 64.   
   >   
   >       IPARMQ(ISPEC=16) Select structured matrix multiply.   
   >                        (See ISPEC=16 above for details.)   
   >                        Default: 3.   
   > \endverbatim   
   >   
    ===================================================================== */
integer igraphiparmq_(integer *ispec, char *name__, char *opts, integer *n, integer 
	*ilo, integer *ihi, integer *lwork)
{
    /* System generated locals */
    integer ret_val, i__1, i__2;
    real r__1;

    /* Builtin functions */
    double log(doublereal);
    integer i_nint(real *);

    /* Local variables */
    integer nh, ns;


/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


    ================================================================ */
    if (*ispec == 15 || *ispec == 13 || *ispec == 16) {

/*        ==== Set the number simultaneous shifts ==== */

	nh = *ihi - *ilo + 1;
	ns = 2;
	if (nh >= 30) {
	    ns = 4;
	}
	if (nh >= 60) {
	    ns = 10;
	}
	if (nh >= 150) {
/* Computing MAX */
	    r__1 = log((real) nh) / log(2.f);
	    i__1 = 10, i__2 = nh / i_nint(&r__1);
	    ns = max(i__1,i__2);
	}
	if (nh >= 590) {
	    ns = 64;
	}
	if (nh >= 3000) {
	    ns = 128;
	}
	if (nh >= 6000) {
	    ns = 256;
	}
/* Computing MAX */
	i__1 = 2, i__2 = ns - ns % 2;
	ns = max(i__1,i__2);
    }

    if (*ispec == 12) {


/*        ===== Matrices of order smaller than NMIN get sent   
          .     to xLAHQR, the classic double shift algorithm.   
          .     This must be at least 11. ==== */

	ret_val = 75;

    } else if (*ispec == 14) {

/*        ==== INIBL: skip a multi-shift qr iteration and   
          .    whenever aggressive early deflation finds   
          .    at least (NIBBLE*(window size)/100) deflations. ==== */

	ret_val = 14;

    } else if (*ispec == 15) {

/*        ==== NSHFTS: The number of simultaneous shifts ===== */

	ret_val = ns;

    } else if (*ispec == 13) {

/*        ==== NW: deflation window size.  ==== */

	if (nh <= 500) {
	    ret_val = ns;
	} else {
	    ret_val = ns * 3 / 2;
	}

    } else if (*ispec == 16) {

/*        ==== IACC22: Whether to accumulate reflections   
          .     before updating the far-from-diagonal elements   
          .     and whether to use 2-by-2 block structure while   
          .     doing it.  A small amount of work could be saved   
          .     by making this choice dependent also upon the   
          .     NH=IHI-ILO+1. */

	ret_val = 0;
	if (ns >= 14) {
	    ret_val = 1;
	}
	if (ns >= 14) {
	    ret_val = 2;
	}

    } else {
/*        ===== invalid value of ispec ===== */
	ret_val = -1;

    }

/*     ==== End of IPARMQ ==== */

    return ret_val;
} /* igraphiparmq_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/ivout.c0000644000175100001710000001676200000000000023730 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* -----------------------------------------------------------------------   
    Routine:    IVOUT   

    Purpose:    Integer vector output routine.   

    Usage:      CALL IVOUT (LOUT, N, IX, IDIGIT, IFMT)   

    Arguments   
       N      - Length of array IX. (Input)   
       IX     - Integer array to be printed. (Input)   
       IFMT   - Format to be used in printing array IX. (Input)   
       IDIGIT - Print up to ABS(IDIGIT) decimal digits / number. (Input)   
                If IDIGIT .LT. 0, printing is done with 72 columns.   
                If IDIGIT .GT. 0, printing is done with 132 columns.   

   -----------------------------------------------------------------------   

   Subroutine */ int igraphivout_(integer *lout, integer *n, integer *ix, integer *
	idigit, char *ifmt, ftnlen ifmt_len)
{
    /* Format strings */
    static char fmt_2000[] = "(/1x,a/1x,a)";
    static char fmt_1000[] = "(1x,i4,\002 - \002,i4,\002:\002,20(1x,i5))";
    static char fmt_1001[] = "(1x,i4,\002 - \002,i4,\002:\002,15(1x,i7))";
    static char fmt_1002[] = "(1x,i4,\002 - \002,i4,\002:\002,10(1x,i11))";
    static char fmt_1003[] = "(1x,i4,\002 - \002,i4,\002:\002,7(1x,i15))";
    static char fmt_1004[] = "(1x,\002 \002)";

    /* System generated locals */
    integer i__1, i__2, i__3;

    /* Builtin functions */
    integer i_len(char *, ftnlen), s_wsfe(cilist *), do_fio(integer *, char *,
	     ftnlen), e_wsfe(void);

    /* Local variables */
    integer i__, k1, k2, lll;
    char line[80];
    integer ndigit;

    /* Fortran I/O blocks */
    static cilist io___4 = { 0, 0, 0, fmt_2000, 0 };
    static cilist io___8 = { 0, 0, 0, fmt_1000, 0 };
    static cilist io___9 = { 0, 0, 0, fmt_1001, 0 };
    static cilist io___10 = { 0, 0, 0, fmt_1002, 0 };
    static cilist io___11 = { 0, 0, 0, fmt_1003, 0 };
    static cilist io___12 = { 0, 0, 0, fmt_1000, 0 };
    static cilist io___13 = { 0, 0, 0, fmt_1001, 0 };
    static cilist io___14 = { 0, 0, 0, fmt_1002, 0 };
    static cilist io___15 = { 0, 0, 0, fmt_1003, 0 };
    static cilist io___16 = { 0, 0, 0, fmt_1004, 0 };


/*     ...   
       ... SPECIFICATIONS FOR ARGUMENTS   
       ...   
       ... SPECIFICATIONS FOR LOCAL VARIABLES   
       ...   
       ... SPECIFICATIONS INTRINSICS   


       Parameter adjustments */
    --ix;

    /* Function Body   
   Computing MIN */
    i__1 = i_len(ifmt, ifmt_len);
    lll = min(i__1,80);
    i__1 = lll;
    for (i__ = 1; i__ <= i__1; ++i__) {
	*(unsigned char *)&line[i__ - 1] = '-';
/* L1: */
    }

    for (i__ = lll + 1; i__ <= 80; ++i__) {
	*(unsigned char *)&line[i__ - 1] = ' ';
/* L2: */
    }

    io___4.ciunit = *lout;
    s_wsfe(&io___4);
    do_fio(&c__1, ifmt, ifmt_len);
    do_fio(&c__1, line, lll);
    e_wsfe();

    if (*n <= 0) {
	return 0;
    }
    ndigit = *idigit;
    if (*idigit == 0) {
	ndigit = 4;
    }

/* =======================================================================   
               CODE FOR OUTPUT USING 72 COLUMNS FORMAT   
   ======================================================================= */

    if (*idigit < 0) {

	ndigit = -(*idigit);
	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 10) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 9;
		k2 = min(i__2,i__3);
		io___8.ciunit = *lout;
		s_wsfe(&io___8);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L10: */
	    }

	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 7) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 6;
		k2 = min(i__2,i__3);
		io___9.ciunit = *lout;
		s_wsfe(&io___9);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L30: */
	    }

	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 5) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 4;
		k2 = min(i__2,i__3);
		io___10.ciunit = *lout;
		s_wsfe(&io___10);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L50: */
	    }

	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 3) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 2;
		k2 = min(i__2,i__3);
		io___11.ciunit = *lout;
		s_wsfe(&io___11);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L70: */
	    }
	}

/* =======================================================================   
               CODE FOR OUTPUT USING 132 COLUMNS FORMAT   
   ======================================================================= */

    } else {

	if (ndigit <= 4) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 20) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 19;
		k2 = min(i__2,i__3);
		io___12.ciunit = *lout;
		s_wsfe(&io___12);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L90: */
	    }

	} else if (ndigit <= 6) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 15) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 14;
		k2 = min(i__2,i__3);
		io___13.ciunit = *lout;
		s_wsfe(&io___13);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L110: */
	    }

	} else if (ndigit <= 10) {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 10) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 9;
		k2 = min(i__2,i__3);
		io___14.ciunit = *lout;
		s_wsfe(&io___14);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L130: */
	    }

	} else {
	    i__1 = *n;
	    for (k1 = 1; k1 <= i__1; k1 += 7) {
/* Computing MIN */
		i__2 = *n, i__3 = k1 + 6;
		k2 = min(i__2,i__3);
		io___15.ciunit = *lout;
		s_wsfe(&io___15);
		do_fio(&c__1, (char *)&k1, (ftnlen)sizeof(integer));
		do_fio(&c__1, (char *)&k2, (ftnlen)sizeof(integer));
		i__2 = k2;
		for (i__ = k1; i__ <= i__2; ++i__) {
		    do_fio(&c__1, (char *)&ix[i__], (ftnlen)sizeof(integer));
		}
		e_wsfe();
/* L150: */
	    }
	}
    }
    io___16.ciunit = *lout;
    s_wsfe(&io___16);
    e_wsfe();


    return 0;
} /* igraphivout_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/len_trim.c0000644000175100001710000000160300000000000024357 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"


/*  -- LEN_TRIM is Fortran 95, so we use a replacement here */

integer igraphlen_trim__(char *s, ftnlen s_len)
{
    /* System generated locals */
    integer ret_val;

    /* Builtin functions */
    integer i_len(char *, ftnlen);




    for (ret_val = i_len(s, s_len); ret_val >= 1; --ret_val) {
	if (*(unsigned char *)&s[ret_val - 1] != ' ') {
	    return ret_val;
	}
    }
    return ret_val;
} /* igraphlen_trim__ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/lsame.c0000644000175100001710000000713500000000000023655 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b LSAME   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         LOGICAL FUNCTION LSAME(CA,CB)   

         CHARACTER CA,CB   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > LSAME returns .TRUE. if CA is the same letter as CB regardless of   
   > case.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] CA   
   > \verbatim   
   >          CA is CHARACTER*1   
   > \endverbatim   
   >   
   > \param[in] CB   
   > \verbatim   
   >          CB is CHARACTER*1   
   >          CA and CB specify the single characters to be compared.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date December 2016   

   > \ingroup aux_blas   

    ===================================================================== */
logical igraphlsame_(char *ca, char *cb)
{
    /* System generated locals */
    logical ret_val;

    /* Local variables */
    integer inta, intb, zcode;


/*  -- Reference BLAS level1 routine (version 3.1) --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       December 2016   


   =====================================================================   


       Test if the characters are equal */

    ret_val = *(unsigned char *)ca == *(unsigned char *)cb;
    if (ret_val) {
	return ret_val;
    }

/*     Now test for equivalence if both characters are alphabetic. */

    zcode = 'Z';

/*     Use 'Z' rather than 'A' so that ASCII can be detected on Prime   
       machines, on which ICHAR returns a value with bit 8 set.   
       ICHAR('A') on Prime machines returns 193 which is the same as   
       ICHAR('A') on an EBCDIC machine. */

    inta = *(unsigned char *)ca;
    intb = *(unsigned char *)cb;

    if (zcode == 90 || zcode == 122) {

/*        ASCII is assumed - ZCODE is the ASCII code of either lower or   
          upper case 'Z'. */

	if (inta >= 97 && inta <= 122) {
	    inta += -32;
	}
	if (intb >= 97 && intb <= 122) {
	    intb += -32;
	}

    } else if (zcode == 233 || zcode == 169) {

/*        EBCDIC is assumed - ZCODE is the EBCDIC code of either lower or   
          upper case 'Z'. */

	if (inta >= 129 && inta <= 137 || inta >= 145 && inta <= 153 || inta 
		>= 162 && inta <= 169) {
	    inta += 64;
	}
	if (intb >= 129 && intb <= 137 || intb >= 145 && intb <= 153 || intb 
		>= 162 && intb <= 169) {
	    intb += 64;
	}

    } else if (zcode == 218 || zcode == 250) {

/*        ASCII is assumed, on Prime machines - ZCODE is the ASCII code   
          plus 128 of either lower or upper case 'Z'. */

	if (inta >= 225 && inta <= 250) {
	    inta += -32;
	}
	if (intb >= 225 && intb <= 250) {
	    intb += -32;
	}
    }
    ret_val = inta == intb;

/*     RETURN   

       End of LSAME */

    return ret_val;
} /* igraphlsame_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/second.c0000644000175100001710000000210000000000000024012 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Subroutine */ int igraphsecond_(real *t)
{
    real t1;
    extern doublereal etime_(real *);
    real tarray[2];



/*  -- LAPACK auxiliary routine (preliminary version) --   
       Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,   
       Courant Institute, Argonne National Lab, and Rice University   
       July 26, 1991   

    Purpose   
    =======   

    SECOND returns the user time for a process in seconds.   
    This version gets the time from the system function ETIME. */


    t1 = etime_(tarray);
    *t = tarray[0];
    return 0;

/*     End of SECOND */

} /* igraphsecond_ */

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/stat.h0000644000175100001710000000000000000000000023514 0ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/lapack/xerbla.c0000644000175100001710000000714700000000000024034 0ustar00runnerdocker00000000000000/*  -- translated by f2c (version 20191129).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* Table of constant values */

static integer c__1 = 1;

/* > \brief \b XERBLA   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

   > \htmlonly   
   > Download XERBLA + dependencies   
   >    
   > [TGZ]   
   >    
   > [ZIP]   
   >    
   > [TXT]   
   > \endhtmlonly   

    Definition:   
    ===========   

         SUBROUTINE XERBLA( SRNAME, INFO )   

         CHARACTER*(*)      SRNAME   
         INTEGER            INFO   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > XERBLA  is an error handler for the LAPACK routines.   
   > It is called by an LAPACK routine if an input parameter has an   
   > invalid value.  A message is printed and execution stops.   
   >   
   > Installers may consider modifying the STOP statement in order to   
   > call system-specific exception-handling facilities.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] SRNAME   
   > \verbatim   
   >          SRNAME is CHARACTER*(*)   
   >          The name of the routine which called XERBLA.   
   > \endverbatim   
   >   
   > \param[in] INFO   
   > \verbatim   
   >          INFO is INTEGER   
   >          The position of the invalid parameter in the parameter list   
   >          of the calling routine.   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \date November 2011   

   > \ingroup auxOTHERauxiliary   

    =====================================================================   
   Subroutine */ int igraphxerbla_(char *srname, integer *info, ftnlen srname_len)
{
    /* Format strings */
    static char fmt_9999[] = "(\002 ** On entry to \002,a,\002 parameter num"
	    "ber \002,i2,\002 had \002,\002an illegal value\002)";

    /* Builtin functions */
    integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void);
    /* Subroutine */ int s_stop(char *, ftnlen);

    /* Local variables */
    extern integer igraphlen_trim__(char *, ftnlen);

    /* Fortran I/O blocks */
    static cilist io___1 = { 0, 6, 0, fmt_9999, 0 };



/*  -- LAPACK auxiliary routine (version 3.4.0) --   
    -- LAPACK is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   
       November 2011   


   ===================================================================== */


    s_wsfe(&io___1);
    do_fio(&c__1, srname, igraphlen_trim__(srname, srname_len));
    do_fio(&c__1, (char *)&(*info), (ftnlen)sizeof(integer));
    e_wsfe();

    s_stop("", (ftnlen)0);


/*     End of XERBLA */

    return 0;
} /* igraphxerbla_ */

././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7111437
igraph-0.9.9/vendor/source/igraph/vendor/mini-gmp/0000755000175100001710000000000000000000000022664 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/mini-gmp/CMakeLists.txt0000644000175100001710000000147400000000000025432 0ustar00runnerdocker00000000000000# Declare the files needed to compile mini-gmp
add_library(
  gmp_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  mini-gmp.c
)

target_include_directories(
  gmp_vendored
  PRIVATE
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET gmp_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

use_all_warnings(gmp_vendored)

if(MSVC)
  target_compile_options(
    gmp_vendored PRIVATE
    /wd4100  # unreferenced formal parameter
    /wd4127  # conditional expression is constant
    /wd4146  # unary minus operator applied to unsigned type
    /wd4189  # local variable is initialized but not referenced
  )
else()
  target_compile_options(
    gmp_vendored PRIVATE
    $<$:-Wno-unused-variable>
  )
endif()

././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/mini-gmp/mini-gmp.c0000644000175100001710000025722200000000000024557 0ustar00runnerdocker00000000000000/* mini-gmp, a minimalistic implementation of a GNU GMP subset.

   Contributed to the GNU project by Niels Möller

Copyright 1991-1997, 1999-2019 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 2 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the GNU MP Library.  If not,
see https://www.gnu.org/licenses/.  */

/* NOTE: All functions in this file which are not declared in
   mini-gmp.h are internal, and are not intended to be compatible
   with GMP or with future versions of mini-gmp. */

/* Much of the material copied from GMP files, including: gmp-impl.h,
   longlong.h, mpn/generic/add_n.c, mpn/generic/addmul_1.c,
   mpn/generic/lshift.c, mpn/generic/mul_1.c,
   mpn/generic/mul_basecase.c, mpn/generic/rshift.c,
   mpn/generic/sbpi1_div_qr.c, mpn/generic/sub_n.c,
   mpn/generic/submul_1.c. */

#include 
#include 
#include 
#include 
#include 
#include 

#include "mini-gmp.h"

#if !defined(MINI_GMP_DONT_USE_FLOAT_H)
#include 
#endif

#include "igraph_error.h"


/* Macros */
#define GMP_LIMB_BITS (sizeof(mp_limb_t) * CHAR_BIT)

#define GMP_LIMB_MAX ((mp_limb_t) ~ (mp_limb_t) 0)
#define GMP_LIMB_HIGHBIT ((mp_limb_t) 1 << (GMP_LIMB_BITS - 1))

#define GMP_HLIMB_BIT ((mp_limb_t) 1 << (GMP_LIMB_BITS / 2))
#define GMP_LLIMB_MASK (GMP_HLIMB_BIT - 1)

#define GMP_ULONG_BITS (sizeof(unsigned long) * CHAR_BIT)
#define GMP_ULONG_HIGHBIT ((unsigned long) 1 << (GMP_ULONG_BITS - 1))

#define GMP_ABS(x) ((x) >= 0 ? (x) : -(x))
#define GMP_NEG_CAST(T,x) (-((T)((x) + 1) - 1))

#define GMP_MIN(a, b) ((a) < (b) ? (a) : (b))
#define GMP_MAX(a, b) ((a) > (b) ? (a) : (b))

#define GMP_CMP(a,b) (((a) > (b)) - ((a) < (b)))

#if defined(DBL_MANT_DIG) && FLT_RADIX == 2
#define GMP_DBL_MANT_BITS DBL_MANT_DIG
#else
#define GMP_DBL_MANT_BITS (53)
#endif

/* Return non-zero if xp,xsize and yp,ysize overlap.
   If xp+xsize<=yp there's no overlap, or if yp+ysize<=xp there's no
   overlap.  If both these are false, there's an overlap. */
#define GMP_MPN_OVERLAP_P(xp, xsize, yp, ysize)				\
  ((xp) + (xsize) > (yp) && (yp) + (ysize) > (xp))

#define gmp_assert_nocarry(x) do { \
    mp_limb_t __cy = (x);	   \
    assert (__cy == 0);		   \
  } while (0)

#define gmp_clz(count, x) do {						\
    mp_limb_t __clz_x = (x);						\
    unsigned __clz_c = 0;						\
    int LOCAL_SHIFT_BITS = 8;						\
    if (GMP_LIMB_BITS > LOCAL_SHIFT_BITS)				\
      for (;								\
	   (__clz_x & ((mp_limb_t) 0xff << (GMP_LIMB_BITS - 8))) == 0;	\
	   __clz_c += 8)						\
	{ __clz_x <<= LOCAL_SHIFT_BITS;	}				\
    for (; (__clz_x & GMP_LIMB_HIGHBIT) == 0; __clz_c++)		\
      __clz_x <<= 1;							\
    (count) = __clz_c;							\
  } while (0)

#define gmp_ctz(count, x) do {						\
    mp_limb_t __ctz_x = (x);						\
    unsigned __ctz_c = 0;						\
    gmp_clz (__ctz_c, __ctz_x & - __ctz_x);				\
    (count) = GMP_LIMB_BITS - 1 - __ctz_c;				\
  } while (0)

#define gmp_add_ssaaaa(sh, sl, ah, al, bh, bl) \
  do {									\
    mp_limb_t __x;							\
    __x = (al) + (bl);							\
    (sh) = (ah) + (bh) + (__x < (al));					\
    (sl) = __x;								\
  } while (0)

#define gmp_sub_ddmmss(sh, sl, ah, al, bh, bl) \
  do {									\
    mp_limb_t __x;							\
    __x = (al) - (bl);							\
    (sh) = (ah) - (bh) - ((al) < (bl));					\
    (sl) = __x;								\
  } while (0)

#define gmp_umul_ppmm(w1, w0, u, v)					\
  do {									\
    int LOCAL_GMP_LIMB_BITS = GMP_LIMB_BITS;				\
    if (sizeof(unsigned int) * CHAR_BIT >= 2 * GMP_LIMB_BITS)		\
      {									\
	unsigned int __ww = (unsigned int) (u) * (v);			\
	w0 = (mp_limb_t) __ww;						\
	w1 = (mp_limb_t) (__ww >> LOCAL_GMP_LIMB_BITS);			\
      }									\
    else if (GMP_ULONG_BITS >= 2 * GMP_LIMB_BITS)			\
      {									\
	unsigned long int __ww = (unsigned long int) (u) * (v);		\
	w0 = (mp_limb_t) __ww;						\
	w1 = (mp_limb_t) (__ww >> LOCAL_GMP_LIMB_BITS);			\
      }									\
    else {								\
      mp_limb_t __x0, __x1, __x2, __x3;					\
      unsigned __ul, __vl, __uh, __vh;					\
      mp_limb_t __u = (u), __v = (v);					\
									\
      __ul = __u & GMP_LLIMB_MASK;					\
      __uh = __u >> (GMP_LIMB_BITS / 2);				\
      __vl = __v & GMP_LLIMB_MASK;					\
      __vh = __v >> (GMP_LIMB_BITS / 2);				\
									\
      __x0 = (mp_limb_t) __ul * __vl;					\
      __x1 = (mp_limb_t) __ul * __vh;					\
      __x2 = (mp_limb_t) __uh * __vl;					\
      __x3 = (mp_limb_t) __uh * __vh;					\
									\
      __x1 += __x0 >> (GMP_LIMB_BITS / 2);/* this can't give carry */	\
      __x1 += __x2;		/* but this indeed can */		\
      if (__x1 < __x2)		/* did we get it? */			\
	__x3 += GMP_HLIMB_BIT;	/* yes, add it in the proper pos. */	\
									\
      (w1) = __x3 + (__x1 >> (GMP_LIMB_BITS / 2));			\
      (w0) = (__x1 << (GMP_LIMB_BITS / 2)) + (__x0 & GMP_LLIMB_MASK);	\
    }									\
  } while (0)

#define gmp_udiv_qrnnd_preinv(q, r, nh, nl, d, di)			\
  do {									\
    mp_limb_t _qh, _ql, _r, _mask;					\
    gmp_umul_ppmm (_qh, _ql, (nh), (di));				\
    gmp_add_ssaaaa (_qh, _ql, _qh, _ql, (nh) + 1, (nl));		\
    _r = (nl) - _qh * (d);						\
    _mask = -(mp_limb_t) (_r > _ql); /* both > and >= are OK */		\
    _qh += _mask;							\
    _r += _mask & (d);							\
    if (_r >= (d))							\
      {									\
	_r -= (d);							\
	_qh++;								\
      }									\
									\
    (r) = _r;								\
    (q) = _qh;								\
  } while (0)

#define gmp_udiv_qr_3by2(q, r1, r0, n2, n1, n0, d1, d0, dinv)		\
  do {									\
    mp_limb_t _q0, _t1, _t0, _mask;					\
    gmp_umul_ppmm ((q), _q0, (n2), (dinv));				\
    gmp_add_ssaaaa ((q), _q0, (q), _q0, (n2), (n1));			\
									\
    /* Compute the two most significant limbs of n - q'd */		\
    (r1) = (n1) - (d1) * (q);						\
    gmp_sub_ddmmss ((r1), (r0), (r1), (n0), (d1), (d0));		\
    gmp_umul_ppmm (_t1, _t0, (d0), (q));				\
    gmp_sub_ddmmss ((r1), (r0), (r1), (r0), _t1, _t0);			\
    (q)++;								\
									\
    /* Conditionally adjust q and the remainders */			\
    _mask = - (mp_limb_t) ((r1) >= _q0);				\
    (q) += _mask;							\
    gmp_add_ssaaaa ((r1), (r0), (r1), (r0), _mask & (d1), _mask & (d0)); \
    if ((r1) >= (d1))							\
      {									\
	if ((r1) > (d1) || (r0) >= (d0))				\
	  {								\
	    (q)++;							\
	    gmp_sub_ddmmss ((r1), (r0), (r1), (r0), (d1), (d0));	\
	  }								\
      }									\
  } while (0)

/* Swap macros. */
#define MP_LIMB_T_SWAP(x, y)						\
  do {									\
    mp_limb_t __mp_limb_t_swap__tmp = (x);				\
    (x) = (y);								\
    (y) = __mp_limb_t_swap__tmp;					\
  } while (0)
#define MP_SIZE_T_SWAP(x, y)						\
  do {									\
    mp_size_t __mp_size_t_swap__tmp = (x);				\
    (x) = (y);								\
    (y) = __mp_size_t_swap__tmp;					\
  } while (0)
#define MP_BITCNT_T_SWAP(x,y)			\
  do {						\
    mp_bitcnt_t __mp_bitcnt_t_swap__tmp = (x);	\
    (x) = (y);					\
    (y) = __mp_bitcnt_t_swap__tmp;		\
  } while (0)
#define MP_PTR_SWAP(x, y)						\
  do {									\
    mp_ptr __mp_ptr_swap__tmp = (x);					\
    (x) = (y);								\
    (y) = __mp_ptr_swap__tmp;						\
  } while (0)
#define MP_SRCPTR_SWAP(x, y)						\
  do {									\
    mp_srcptr __mp_srcptr_swap__tmp = (x);				\
    (x) = (y);								\
    (y) = __mp_srcptr_swap__tmp;					\
  } while (0)

#define MPN_PTR_SWAP(xp,xs, yp,ys)					\
  do {									\
    MP_PTR_SWAP (xp, yp);						\
    MP_SIZE_T_SWAP (xs, ys);						\
  } while(0)
#define MPN_SRCPTR_SWAP(xp,xs, yp,ys)					\
  do {									\
    MP_SRCPTR_SWAP (xp, yp);						\
    MP_SIZE_T_SWAP (xs, ys);						\
  } while(0)

#define MPZ_PTR_SWAP(x, y)						\
  do {									\
    mpz_ptr __mpz_ptr_swap__tmp = (x);					\
    (x) = (y);								\
    (y) = __mpz_ptr_swap__tmp;						\
  } while (0)
#define MPZ_SRCPTR_SWAP(x, y)						\
  do {									\
    mpz_srcptr __mpz_srcptr_swap__tmp = (x);				\
    (x) = (y);								\
    (y) = __mpz_srcptr_swap__tmp;					\
  } while (0)

const int mp_bits_per_limb = GMP_LIMB_BITS;


/* Memory allocation and other helper functions. */
static void
gmp_die (const char *msg)
{
  /*
  fprintf (stderr, "%s\n", msg);
  abort();
  */
  IGRAPH_FATAL(msg);
}

static void *
gmp_default_alloc (size_t size)
{
  void *p;

  assert (size > 0);

  p = malloc (size);
  if (!p)
    gmp_die("gmp_default_alloc: Virtual memory exhausted.");

  return p;
}

static void *
gmp_default_realloc (void *old, size_t unused_old_size, size_t new_size)
{
  void * p;

  p = realloc (old, new_size);

  if (!p)
    gmp_die("gmp_default_realloc: Virtual memory exhausted.");

  return p;
}

static void
gmp_default_free (void *p, size_t unused_size)
{
  free (p);
}

static void * (*gmp_allocate_func) (size_t) = gmp_default_alloc;
static void * (*gmp_reallocate_func) (void *, size_t, size_t) = gmp_default_realloc;
static void (*gmp_free_func) (void *, size_t) = gmp_default_free;

void
mp_get_memory_functions (void *(**alloc_func) (size_t),
			 void *(**realloc_func) (void *, size_t, size_t),
			 void (**free_func) (void *, size_t))
{
  if (alloc_func)
    *alloc_func = gmp_allocate_func;

  if (realloc_func)
    *realloc_func = gmp_reallocate_func;

  if (free_func)
    *free_func = gmp_free_func;
}

void
mp_set_memory_functions (void *(*alloc_func) (size_t),
			 void *(*realloc_func) (void *, size_t, size_t),
			 void (*free_func) (void *, size_t))
{
  if (!alloc_func)
    alloc_func = gmp_default_alloc;
  if (!realloc_func)
    realloc_func = gmp_default_realloc;
  if (!free_func)
    free_func = gmp_default_free;

  gmp_allocate_func = alloc_func;
  gmp_reallocate_func = realloc_func;
  gmp_free_func = free_func;
}

#define gmp_xalloc(size) ((*gmp_allocate_func)((size)))
#define gmp_free(p) ((*gmp_free_func) ((p), 0))

static mp_ptr
gmp_xalloc_limbs (mp_size_t size)
{
  return (mp_ptr) gmp_xalloc (size * sizeof (mp_limb_t));
}

static mp_ptr
gmp_xrealloc_limbs (mp_ptr old, mp_size_t size)
{
  assert (size > 0);
  return (mp_ptr) (*gmp_reallocate_func) (old, 0, size * sizeof (mp_limb_t));
}


/* MPN interface */

void
mpn_copyi (mp_ptr d, mp_srcptr s, mp_size_t n)
{
  mp_size_t i;
  for (i = 0; i < n; i++)
    d[i] = s[i];
}

void
mpn_copyd (mp_ptr d, mp_srcptr s, mp_size_t n)
{
  while (--n >= 0)
    d[n] = s[n];
}

int
mpn_cmp (mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  while (--n >= 0)
    {
      if (ap[n] != bp[n])
	return ap[n] > bp[n] ? 1 : -1;
    }
  return 0;
}

static int
mpn_cmp4 (mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn)
{
  if (an != bn)
    return an < bn ? -1 : 1;
  else
    return mpn_cmp (ap, bp, an);
}

static mp_size_t
mpn_normalized_size (mp_srcptr xp, mp_size_t n)
{
  while (n > 0 && xp[n-1] == 0)
    --n;
  return n;
}

int
mpn_zero_p(mp_srcptr rp, mp_size_t n)
{
  return mpn_normalized_size (rp, n) == 0;
}

void
mpn_zero (mp_ptr rp, mp_size_t n)
{
  while (--n >= 0)
    rp[n] = 0;
}

mp_limb_t
mpn_add_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b)
{
  mp_size_t i;

  assert (n > 0);
  i = 0;
  do
    {
      mp_limb_t r = ap[i] + b;
      /* Carry out */
      b = (r < b);
      rp[i] = r;
    }
  while (++i < n);

  return b;
}

mp_limb_t
mpn_add_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mp_size_t i;
  mp_limb_t cy;

  for (i = 0, cy = 0; i < n; i++)
    {
      mp_limb_t a, b, r;
      a = ap[i]; b = bp[i];
      r = a + cy;
      cy = (r < cy);
      r += b;
      cy += (r < b);
      rp[i] = r;
    }
  return cy;
}

mp_limb_t
mpn_add (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn)
{
  mp_limb_t cy;

  assert (an >= bn);

  cy = mpn_add_n (rp, ap, bp, bn);
  if (an > bn)
    cy = mpn_add_1 (rp + bn, ap + bn, an - bn, cy);
  return cy;
}

mp_limb_t
mpn_sub_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b)
{
  mp_size_t i;

  assert (n > 0);

  i = 0;
  do
    {
      mp_limb_t a = ap[i];
      /* Carry out */
      mp_limb_t cy = a < b;
      rp[i] = a - b;
      b = cy;
    }
  while (++i < n);

  return b;
}

mp_limb_t
mpn_sub_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mp_size_t i;
  mp_limb_t cy;

  for (i = 0, cy = 0; i < n; i++)
    {
      mp_limb_t a, b;
      a = ap[i]; b = bp[i];
      b += cy;
      cy = (b < cy);
      cy += (a < b);
      rp[i] = a - b;
    }
  return cy;
}

mp_limb_t
mpn_sub (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn)
{
  mp_limb_t cy;

  assert (an >= bn);

  cy = mpn_sub_n (rp, ap, bp, bn);
  if (an > bn)
    cy = mpn_sub_1 (rp + bn, ap + bn, an - bn, cy);
  return cy;
}

mp_limb_t
mpn_mul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

mp_limb_t
mpn_addmul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl, rl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      rl = *rp;
      lpl = rl + lpl;
      cl += lpl < rl;
      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

mp_limb_t
mpn_submul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl, rl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      rl = *rp;
      lpl = rl - lpl;
      cl += lpl > rl;
      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

mp_limb_t
mpn_mul (mp_ptr rp, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
{
  assert (un >= vn);
  assert (vn >= 1);
  assert (!GMP_MPN_OVERLAP_P(rp, un + vn, up, un));
  assert (!GMP_MPN_OVERLAP_P(rp, un + vn, vp, vn));

  /* We first multiply by the low order limb. This result can be
     stored, not added, to rp. We also avoid a loop for zeroing this
     way. */

  rp[un] = mpn_mul_1 (rp, up, un, vp[0]);

  /* Now accumulate the product of up[] and the next higher limb from
     vp[]. */

  while (--vn >= 1)
    {
      rp += 1, vp += 1;
      rp[un] = mpn_addmul_1 (rp, up, un, vp[0]);
    }
  return rp[un];
}

void
mpn_mul_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mpn_mul (rp, ap, n, bp, n);
}

void
mpn_sqr (mp_ptr rp, mp_srcptr ap, mp_size_t n)
{
  mpn_mul (rp, ap, n, ap, n);
}

mp_limb_t
mpn_lshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  up += n;
  rp += n;

  tnc = GMP_LIMB_BITS - cnt;
  low_limb = *--up;
  retval = low_limb >> tnc;
  high_limb = (low_limb << cnt);

  while (--n != 0)
    {
      low_limb = *--up;
      *--rp = high_limb | (low_limb >> tnc);
      high_limb = (low_limb << cnt);
    }
  *--rp = high_limb;

  return retval;
}

mp_limb_t
mpn_rshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  tnc = GMP_LIMB_BITS - cnt;
  high_limb = *up++;
  retval = (high_limb << tnc);
  low_limb = high_limb >> cnt;

  while (--n != 0)
    {
      high_limb = *up++;
      *rp++ = low_limb | (high_limb << tnc);
      low_limb = high_limb >> cnt;
    }
  *rp = low_limb;

  return retval;
}

static mp_bitcnt_t
mpn_common_scan (mp_limb_t limb, mp_size_t i, mp_srcptr up, mp_size_t un,
		 mp_limb_t ux)
{
  unsigned cnt;

  assert (ux == 0 || ux == GMP_LIMB_MAX);
  assert (0 <= i && i <= un );

  while (limb == 0)
    {
      i++;
      if (i == un)
	return (ux == 0 ? ~(mp_bitcnt_t) 0 : un * GMP_LIMB_BITS);
      limb = ux ^ up[i];
    }
  gmp_ctz (cnt, limb);
  return (mp_bitcnt_t) i * GMP_LIMB_BITS + cnt;
}

mp_bitcnt_t
mpn_scan1 (mp_srcptr ptr, mp_bitcnt_t bit)
{
  mp_size_t i;
  i = bit / GMP_LIMB_BITS;

  return mpn_common_scan ( ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)),
			  i, ptr, i, 0);
}

mp_bitcnt_t
mpn_scan0 (mp_srcptr ptr, mp_bitcnt_t bit)
{
  mp_size_t i;
  i = bit / GMP_LIMB_BITS;

  return mpn_common_scan (~ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)),
			  i, ptr, i, GMP_LIMB_MAX);
}

void
mpn_com (mp_ptr rp, mp_srcptr up, mp_size_t n)
{
  while (--n >= 0)
    *rp++ = ~ *up++;
}

mp_limb_t
mpn_neg (mp_ptr rp, mp_srcptr up, mp_size_t n)
{
  while (*up == 0)
    {
      *rp = 0;
      if (!--n)
	return 0;
      ++up; ++rp;
    }
  *rp = - *up;
  mpn_com (++rp, ++up, --n);
  return 1;
}


/* MPN division interface. */

/* The 3/2 inverse is defined as

     m = floor( (B^3-1) / (B u1 + u0)) - B
*/
mp_limb_t
mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0)
{
  mp_limb_t r, m;

  {
    mp_limb_t p, ql;
    unsigned ul, uh, qh;

    /* For notation, let b denote the half-limb base, so that B = b^2.
       Split u1 = b uh + ul. */
    ul = u1 & GMP_LLIMB_MASK;
    uh = u1 >> (GMP_LIMB_BITS / 2);

    /* Approximation of the high half of quotient. Differs from the 2/1
       inverse of the half limb uh, since we have already subtracted
       u0. */
    qh = (u1 ^ GMP_LIMB_MAX) / uh;

    /* Adjust to get a half-limb 3/2 inverse, i.e., we want

       qh' = floor( (b^3 - 1) / u) - b = floor ((b^3 - b u - 1) / u
	   = floor( (b (~u) + b-1) / u),

       and the remainder

       r = b (~u) + b-1 - qh (b uh + ul)
       = b (~u - qh uh) + b-1 - qh ul

       Subtraction of qh ul may underflow, which implies adjustments.
       But by normalization, 2 u >= B > qh ul, so we need to adjust by
       at most 2.
    */

    r = ((~u1 - (mp_limb_t) qh * uh) << (GMP_LIMB_BITS / 2)) | GMP_LLIMB_MASK;

    p = (mp_limb_t) qh * ul;
    /* Adjustment steps taken from udiv_qrnnd_c */
    if (r < p)
      {
	qh--;
	r += u1;
	if (r >= u1) /* i.e. we didn't get carry when adding to r */
	  if (r < p)
	    {
	      qh--;
	      r += u1;
	    }
      }
    r -= p;

    /* Low half of the quotient is

       ql = floor ( (b r + b-1) / u1).

       This is a 3/2 division (on half-limbs), for which qh is a
       suitable inverse. */

    p = (r >> (GMP_LIMB_BITS / 2)) * qh + r;
    /* Unlike full-limb 3/2, we can add 1 without overflow. For this to
       work, it is essential that ql is a full mp_limb_t. */
    ql = (p >> (GMP_LIMB_BITS / 2)) + 1;

    /* By the 3/2 trick, we don't need the high half limb. */
    r = (r << (GMP_LIMB_BITS / 2)) + GMP_LLIMB_MASK - ql * u1;

    if (r >= (GMP_LIMB_MAX & (p << (GMP_LIMB_BITS / 2))))
      {
	ql--;
	r += u1;
      }
    m = ((mp_limb_t) qh << (GMP_LIMB_BITS / 2)) + ql;
    if (r >= u1)
      {
	m++;
	r -= u1;
      }
  }

  /* Now m is the 2/1 inverse of u1. If u0 > 0, adjust it to become a
     3/2 inverse. */
  if (u0 > 0)
    {
      mp_limb_t th, tl;
      r = ~r;
      r += u0;
      if (r < u0)
	{
	  m--;
	  if (r >= u1)
	    {
	      m--;
	      r -= u1;
	    }
	  r -= u1;
	}
      gmp_umul_ppmm (th, tl, u0, m);
      r += th;
      if (r < th)
	{
	  m--;
	  m -= ((r > u1) | ((r == u1) & (tl > u0)));
	}
    }

  return m;
}

struct gmp_div_inverse
{
  /* Normalization shift count. */
  unsigned shift;
  /* Normalized divisor (d0 unused for mpn_div_qr_1) */
  mp_limb_t d1, d0;
  /* Inverse, for 2/1 or 3/2. */
  mp_limb_t di;
};

static void
mpn_div_qr_1_invert (struct gmp_div_inverse *inv, mp_limb_t d)
{
  unsigned shift;

  assert (d > 0);
  gmp_clz (shift, d);
  inv->shift = shift;
  inv->d1 = d << shift;
  inv->di = mpn_invert_limb (inv->d1);
}

static void
mpn_div_qr_2_invert (struct gmp_div_inverse *inv,
		     mp_limb_t d1, mp_limb_t d0)
{
  unsigned shift;

  assert (d1 > 0);
  gmp_clz (shift, d1);
  inv->shift = shift;
  if (shift > 0)
    {
      d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift));
      d0 <<= shift;
    }
  inv->d1 = d1;
  inv->d0 = d0;
  inv->di = mpn_invert_3by2 (d1, d0);
}

static void
mpn_div_qr_invert (struct gmp_div_inverse *inv,
		   mp_srcptr dp, mp_size_t dn)
{
  assert (dn > 0);

  if (dn == 1)
    mpn_div_qr_1_invert (inv, dp[0]);
  else if (dn == 2)
    mpn_div_qr_2_invert (inv, dp[1], dp[0]);
  else
    {
      unsigned shift;
      mp_limb_t d1, d0;

      d1 = dp[dn-1];
      d0 = dp[dn-2];
      assert (d1 > 0);
      gmp_clz (shift, d1);
      inv->shift = shift;
      if (shift > 0)
	{
	  d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift));
	  d0 = (d0 << shift) | (dp[dn-3] >> (GMP_LIMB_BITS - shift));
	}
      inv->d1 = d1;
      inv->d0 = d0;
      inv->di = mpn_invert_3by2 (d1, d0);
    }
}

/* Not matching current public gmp interface, rather corresponding to
   the sbpi1_div_* functions. */
static mp_limb_t
mpn_div_qr_1_preinv (mp_ptr qp, mp_srcptr np, mp_size_t nn,
		     const struct gmp_div_inverse *inv)
{
  mp_limb_t d, di;
  mp_limb_t r;
  mp_ptr tp = NULL;

  if (inv->shift > 0)
    {
      /* Shift, reusing qp area if possible. In-place shift if qp == np. */
      tp = qp ? qp : gmp_xalloc_limbs (nn);
      r = mpn_lshift (tp, np, nn, inv->shift);
      np = tp;
    }
  else
    r = 0;

  d = inv->d1;
  di = inv->di;
  while (--nn >= 0)
    {
      mp_limb_t q;

      gmp_udiv_qrnnd_preinv (q, r, r, np[nn], d, di);
      if (qp)
	qp[nn] = q;
    }
  if ((inv->shift > 0) && (tp != qp))
    gmp_free (tp);

  return r >> inv->shift;
}

static void
mpn_div_qr_2_preinv (mp_ptr qp, mp_ptr np, mp_size_t nn,
		     const struct gmp_div_inverse *inv)
{
  unsigned shift;
  mp_size_t i;
  mp_limb_t d1, d0, di, r1, r0;

  assert (nn >= 2);
  shift = inv->shift;
  d1 = inv->d1;
  d0 = inv->d0;
  di = inv->di;

  if (shift > 0)
    r1 = mpn_lshift (np, np, nn, shift);
  else
    r1 = 0;

  r0 = np[nn - 1];

  i = nn - 2;
  do
    {
      mp_limb_t n0, q;
      n0 = np[i];
      gmp_udiv_qr_3by2 (q, r1, r0, r1, r0, n0, d1, d0, di);

      if (qp)
	qp[i] = q;
    }
  while (--i >= 0);

  if (shift > 0)
    {
      assert ((r0 & (GMP_LIMB_MAX >> (GMP_LIMB_BITS - shift))) == 0);
      r0 = (r0 >> shift) | (r1 << (GMP_LIMB_BITS - shift));
      r1 >>= shift;
    }

  np[1] = r1;
  np[0] = r0;
}

static void
mpn_div_qr_pi1 (mp_ptr qp,
		mp_ptr np, mp_size_t nn, mp_limb_t n1,
		mp_srcptr dp, mp_size_t dn,
		mp_limb_t dinv)
{
  mp_size_t i;

  mp_limb_t d1, d0;
  mp_limb_t cy, cy1;
  mp_limb_t q;

  assert (dn > 2);
  assert (nn >= dn);

  d1 = dp[dn - 1];
  d0 = dp[dn - 2];

  assert ((d1 & GMP_LIMB_HIGHBIT) != 0);
  /* Iteration variable is the index of the q limb.
   *
   * We divide 
   * by            
   */

  i = nn - dn;
  do
    {
      mp_limb_t n0 = np[dn-1+i];

      if (n1 == d1 && n0 == d0)
	{
	  q = GMP_LIMB_MAX;
	  mpn_submul_1 (np+i, dp, dn, q);
	  n1 = np[dn-1+i];	/* update n1, last loop's value will now be invalid */
	}
      else
	{
	  gmp_udiv_qr_3by2 (q, n1, n0, n1, n0, np[dn-2+i], d1, d0, dinv);

	  cy = mpn_submul_1 (np + i, dp, dn-2, q);

	  cy1 = n0 < cy;
	  n0 = n0 - cy;
	  cy = n1 < cy1;
	  n1 = n1 - cy1;
	  np[dn-2+i] = n0;

	  if (cy != 0)
	    {
	      n1 += d1 + mpn_add_n (np + i, np + i, dp, dn - 1);
	      q--;
	    }
	}

      if (qp)
	qp[i] = q;
    }
  while (--i >= 0);

  np[dn - 1] = n1;
}

static void
mpn_div_qr_preinv (mp_ptr qp, mp_ptr np, mp_size_t nn,
		   mp_srcptr dp, mp_size_t dn,
		   const struct gmp_div_inverse *inv)
{
  assert (dn > 0);
  assert (nn >= dn);

  if (dn == 1)
    np[0] = mpn_div_qr_1_preinv (qp, np, nn, inv);
  else if (dn == 2)
    mpn_div_qr_2_preinv (qp, np, nn, inv);
  else
    {
      mp_limb_t nh;
      unsigned shift;

      assert (inv->d1 == dp[dn-1]);
      assert (inv->d0 == dp[dn-2]);
      assert ((inv->d1 & GMP_LIMB_HIGHBIT) != 0);

      shift = inv->shift;
      if (shift > 0)
	nh = mpn_lshift (np, np, nn, shift);
      else
	nh = 0;

      mpn_div_qr_pi1 (qp, np, nn, nh, dp, dn, inv->di);

      if (shift > 0)
	gmp_assert_nocarry (mpn_rshift (np, np, dn, shift));
    }
}

static void
mpn_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
{
  struct gmp_div_inverse inv;
  mp_ptr tp = NULL;

  assert (dn > 0);
  assert (nn >= dn);

  mpn_div_qr_invert (&inv, dp, dn);
  if (dn > 2 && inv.shift > 0)
    {
      tp = gmp_xalloc_limbs (dn);
      gmp_assert_nocarry (mpn_lshift (tp, dp, dn, inv.shift));
      dp = tp;
    }
  mpn_div_qr_preinv (qp, np, nn, dp, dn, &inv);
  if (tp)
    gmp_free (tp);
}


/* MPN base conversion. */
static unsigned
mpn_base_power_of_two_p (unsigned b)
{
  switch (b)
    {
    case 2: return 1;
    case 4: return 2;
    case 8: return 3;
    case 16: return 4;
    case 32: return 5;
    case 64: return 6;
    case 128: return 7;
    case 256: return 8;
    default: return 0;
    }
}

struct mpn_base_info
{
  /* bb is the largest power of the base which fits in one limb, and
     exp is the corresponding exponent. */
  unsigned exp;
  mp_limb_t bb;
};

static void
mpn_get_base_info (struct mpn_base_info *info, mp_limb_t b)
{
  mp_limb_t m;
  mp_limb_t p;
  unsigned exp;

  m = GMP_LIMB_MAX / b;
  for (exp = 1, p = b; p <= m; exp++)
    p *= b;

  info->exp = exp;
  info->bb = p;
}

static mp_bitcnt_t
mpn_limb_size_in_base_2 (mp_limb_t u)
{
  unsigned shift;

  assert (u > 0);
  gmp_clz (shift, u);
  return GMP_LIMB_BITS - shift;
}

static size_t
mpn_get_str_bits (unsigned char *sp, unsigned bits, mp_srcptr up, mp_size_t un)
{
  unsigned char mask;
  size_t sn, j;
  mp_size_t i;
  unsigned shift;

  sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1])
	+ bits - 1) / bits;

  mask = (1U << bits) - 1;

  for (i = 0, j = sn, shift = 0; j-- > 0;)
    {
      unsigned char digit = up[i] >> shift;

      shift += bits;

      if (shift >= GMP_LIMB_BITS && ++i < un)
	{
	  shift -= GMP_LIMB_BITS;
	  digit |= up[i] << (bits - shift);
	}
      sp[j] = digit & mask;
    }
  return sn;
}

/* We generate digits from the least significant end, and reverse at
   the end. */
static size_t
mpn_limb_get_str (unsigned char *sp, mp_limb_t w,
		  const struct gmp_div_inverse *binv)
{
  mp_size_t i;
  for (i = 0; w > 0; i++)
    {
      mp_limb_t h, l, r;

      h = w >> (GMP_LIMB_BITS - binv->shift);
      l = w << binv->shift;

      gmp_udiv_qrnnd_preinv (w, r, h, l, binv->d1, binv->di);
      assert ((r & (GMP_LIMB_MAX >> (GMP_LIMB_BITS - binv->shift))) == 0);
      r >>= binv->shift;

      sp[i] = r;
    }
  return i;
}

static size_t
mpn_get_str_other (unsigned char *sp,
		   int base, const struct mpn_base_info *info,
		   mp_ptr up, mp_size_t un)
{
  struct gmp_div_inverse binv;
  size_t sn;
  size_t i;

  mpn_div_qr_1_invert (&binv, base);

  sn = 0;

  if (un > 1)
    {
      struct gmp_div_inverse bbinv;
      mpn_div_qr_1_invert (&bbinv, info->bb);

      do
	{
	  mp_limb_t w;
	  size_t done;
	  w = mpn_div_qr_1_preinv (up, up, un, &bbinv);
	  un -= (up[un-1] == 0);
	  done = mpn_limb_get_str (sp + sn, w, &binv);

	  for (sn += done; done < info->exp; done++)
	    sp[sn++] = 0;
	}
      while (un > 1);
    }
  sn += mpn_limb_get_str (sp + sn, up[0], &binv);

  /* Reverse order */
  for (i = 0; 2*i + 1 < sn; i++)
    {
      unsigned char t = sp[i];
      sp[i] = sp[sn - i - 1];
      sp[sn - i - 1] = t;
    }

  return sn;
}

size_t
mpn_get_str (unsigned char *sp, int base, mp_ptr up, mp_size_t un)
{
  unsigned bits;

  assert (un > 0);
  assert (up[un-1] > 0);

  bits = mpn_base_power_of_two_p (base);
  if (bits)
    return mpn_get_str_bits (sp, bits, up, un);
  else
    {
      struct mpn_base_info info;

      mpn_get_base_info (&info, base);
      return mpn_get_str_other (sp, base, &info, up, un);
    }
}

static mp_size_t
mpn_set_str_bits (mp_ptr rp, const unsigned char *sp, size_t sn,
		  unsigned bits)
{
  mp_size_t rn;
  size_t j;
  unsigned shift;

  for (j = sn, rn = 0, shift = 0; j-- > 0; )
    {
      if (shift == 0)
	{
	  rp[rn++] = sp[j];
	  shift += bits;
	}
      else
	{
	  rp[rn-1] |= (mp_limb_t) sp[j] << shift;
	  shift += bits;
	  if (shift >= GMP_LIMB_BITS)
	    {
	      shift -= GMP_LIMB_BITS;
	      if (shift > 0)
		rp[rn++] = (mp_limb_t) sp[j] >> (bits - shift);
	    }
	}
    }
  rn = mpn_normalized_size (rp, rn);
  return rn;
}

/* Result is usually normalized, except for all-zero input, in which
   case a single zero limb is written at *RP, and 1 is returned. */
static mp_size_t
mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn,
		   mp_limb_t b, const struct mpn_base_info *info)
{
  mp_size_t rn;
  mp_limb_t w;
  unsigned k;
  size_t j;

  assert (sn > 0);

  k = 1 + (sn - 1) % info->exp;

  j = 0;
  w = sp[j++];
  while (--k != 0)
    w = w * b + sp[j++];

  rp[0] = w;

  for (rn = 1; j < sn;)
    {
      mp_limb_t cy;

      w = sp[j++];
      for (k = 1; k < info->exp; k++)
	w = w * b + sp[j++];

      cy = mpn_mul_1 (rp, rp, rn, info->bb);
      cy += mpn_add_1 (rp, rp, rn, w);
      if (cy > 0)
	rp[rn++] = cy;
    }
  assert (j == sn);

  return rn;
}

mp_size_t
mpn_set_str (mp_ptr rp, const unsigned char *sp, size_t sn, int base)
{
  unsigned bits;

  if (sn == 0)
    return 0;

  bits = mpn_base_power_of_two_p (base);
  if (bits)
    return mpn_set_str_bits (rp, sp, sn, bits);
  else
    {
      struct mpn_base_info info;

      mpn_get_base_info (&info, base);
      return mpn_set_str_other (rp, sp, sn, base, &info);
    }
}


/* MPZ interface */
void
mpz_init (mpz_t r)
{
  static const mp_limb_t dummy_limb = GMP_LIMB_MAX & 0xc1a0;

  r->_mp_alloc = 0;
  r->_mp_size = 0;
  r->_mp_d = (mp_ptr) &dummy_limb;
}

/* The utility of this function is a bit limited, since many functions
   assigns the result variable using mpz_swap. */
void
mpz_init2 (mpz_t r, mp_bitcnt_t bits)
{
  mp_size_t rn;

  bits -= (bits != 0);		/* Round down, except if 0 */
  rn = 1 + bits / GMP_LIMB_BITS;

  r->_mp_alloc = rn;
  r->_mp_size = 0;
  r->_mp_d = gmp_xalloc_limbs (rn);
}

void
mpz_clear (mpz_t r)
{
  if (r->_mp_alloc)
    gmp_free (r->_mp_d);
}

static mp_ptr
mpz_realloc (mpz_t r, mp_size_t size)
{
  size = GMP_MAX (size, 1);

  if (r->_mp_alloc)
    r->_mp_d = gmp_xrealloc_limbs (r->_mp_d, size);
  else
    r->_mp_d = gmp_xalloc_limbs (size);
  r->_mp_alloc = size;

  if (GMP_ABS (r->_mp_size) > size)
    r->_mp_size = 0;

  return r->_mp_d;
}

/* Realloc for an mpz_t WHAT if it has less than NEEDED limbs.  */
#define MPZ_REALLOC(z,n) ((n) > (z)->_mp_alloc			\
			  ? mpz_realloc(z,n)			\
			  : (z)->_mp_d)

/* MPZ assignment and basic conversions. */
void
mpz_set_si (mpz_t r, signed long int x)
{
  if (x >= 0)
    mpz_set_ui (r, x);
  else /* (x < 0) */
    if (GMP_LIMB_BITS < GMP_ULONG_BITS)
      {
	mpz_set_ui (r, GMP_NEG_CAST (unsigned long int, x));
	mpz_neg (r, r);
      }
  else
    {
      r->_mp_size = -1;
      MPZ_REALLOC (r, 1)[0] = GMP_NEG_CAST (unsigned long int, x);
    }
}

void
mpz_set_ui (mpz_t r, unsigned long int x)
{
  if (x > 0)
    {
      r->_mp_size = 1;
      MPZ_REALLOC (r, 1)[0] = x;
      if (GMP_LIMB_BITS < GMP_ULONG_BITS)
	{
	  int LOCAL_GMP_LIMB_BITS = GMP_LIMB_BITS;
	  while (x >>= LOCAL_GMP_LIMB_BITS)
	    {
	      ++ r->_mp_size;
	      MPZ_REALLOC (r, r->_mp_size)[r->_mp_size - 1] = x;
	    }
	}
    }
  else
    r->_mp_size = 0;
}

void
mpz_set (mpz_t r, const mpz_t x)
{
  /* Allow the NOP r == x */
  if (r != x)
    {
      mp_size_t n;
      mp_ptr rp;

      n = GMP_ABS (x->_mp_size);
      rp = MPZ_REALLOC (r, n);

      mpn_copyi (rp, x->_mp_d, n);
      r->_mp_size = x->_mp_size;
    }
}

void
mpz_init_set_si (mpz_t r, signed long int x)
{
  mpz_init (r);
  mpz_set_si (r, x);
}

void
mpz_init_set_ui (mpz_t r, unsigned long int x)
{
  mpz_init (r);
  mpz_set_ui (r, x);
}

void
mpz_init_set (mpz_t r, const mpz_t x)
{
  mpz_init (r);
  mpz_set (r, x);
}

int
mpz_fits_slong_p (const mpz_t u)
{
  return (LONG_MAX + LONG_MIN == 0 || mpz_cmp_ui (u, LONG_MAX) <= 0) &&
    mpz_cmpabs_ui (u, GMP_NEG_CAST (unsigned long int, LONG_MIN)) <= 0;
}

static int
mpn_absfits_ulong_p (mp_srcptr up, mp_size_t un)
{
  int ulongsize = GMP_ULONG_BITS / GMP_LIMB_BITS;
  mp_limb_t ulongrem = 0;

  if (GMP_ULONG_BITS % GMP_LIMB_BITS != 0)
    ulongrem = (mp_limb_t) (ULONG_MAX >> GMP_LIMB_BITS * ulongsize) + 1;

  return un <= ulongsize || (up[ulongsize] < ulongrem && un == ulongsize + 1);
}

int
mpz_fits_ulong_p (const mpz_t u)
{
  mp_size_t us = u->_mp_size;

  return us >= 0 && mpn_absfits_ulong_p (u->_mp_d, us);
}

long int
mpz_get_si (const mpz_t u)
{
  unsigned long r = mpz_get_ui (u);
  unsigned long c = -LONG_MAX - LONG_MIN;

  if (u->_mp_size < 0)
    /* This expression is necessary to properly handle -LONG_MIN */
    return -(long) c - (long) ((r - c) & LONG_MAX);
  else
    return (long) (r & LONG_MAX);
}

unsigned long int
mpz_get_ui (const mpz_t u)
{
  if (GMP_LIMB_BITS < GMP_ULONG_BITS)
    {
      int LOCAL_GMP_LIMB_BITS = GMP_LIMB_BITS;
      unsigned long r = 0;
      mp_size_t n = GMP_ABS (u->_mp_size);
      n = GMP_MIN (n, 1 + (mp_size_t) (GMP_ULONG_BITS - 1) / GMP_LIMB_BITS);
      while (--n >= 0)
	r = (r << LOCAL_GMP_LIMB_BITS) + u->_mp_d[n];
      return r;
    }

  return u->_mp_size == 0 ? 0 : u->_mp_d[0];
}

size_t
mpz_size (const mpz_t u)
{
  return GMP_ABS (u->_mp_size);
}

mp_limb_t
mpz_getlimbn (const mpz_t u, mp_size_t n)
{
  if (n >= 0 && n < GMP_ABS (u->_mp_size))
    return u->_mp_d[n];
  else
    return 0;
}

void
mpz_realloc2 (mpz_t x, mp_bitcnt_t n)
{
  mpz_realloc (x, 1 + (n - (n != 0)) / GMP_LIMB_BITS);
}

mp_srcptr
mpz_limbs_read (mpz_srcptr x)
{
  return x->_mp_d;
}

mp_ptr
mpz_limbs_modify (mpz_t x, mp_size_t n)
{
  assert (n > 0);
  return MPZ_REALLOC (x, n);
}

mp_ptr
mpz_limbs_write (mpz_t x, mp_size_t n)
{
  return mpz_limbs_modify (x, n);
}

void
mpz_limbs_finish (mpz_t x, mp_size_t xs)
{
  mp_size_t xn;
  xn = mpn_normalized_size (x->_mp_d, GMP_ABS (xs));
  x->_mp_size = xs < 0 ? -xn : xn;
}

static mpz_srcptr
mpz_roinit_normal_n (mpz_t x, mp_srcptr xp, mp_size_t xs)
{
  x->_mp_alloc = 0;
  x->_mp_d = (mp_ptr) xp;
  x->_mp_size = xs;
  return x;
}

mpz_srcptr
mpz_roinit_n (mpz_t x, mp_srcptr xp, mp_size_t xs)
{
  mpz_roinit_normal_n (x, xp, xs);
  mpz_limbs_finish (x, xs);
  return x;
}


/* Conversions and comparison to double. */
void
mpz_set_d (mpz_t r, double x)
{
  int sign;
  mp_ptr rp;
  mp_size_t rn, i;
  double B;
  double Bi;
  mp_limb_t f;

  /* x != x is true when x is a NaN, and x == x * 0.5 is true when x is
     zero or infinity. */
  if (x != x || x == x * 0.5)
    {
      r->_mp_size = 0;
      return;
    }

  sign = x < 0.0 ;
  if (sign)
    x = - x;

  if (x < 1.0)
    {
      r->_mp_size = 0;
      return;
    }
  B = 4.0 * (double) (GMP_LIMB_HIGHBIT >> 1);
  Bi = 1.0 / B;
  for (rn = 1; x >= B; rn++)
    x *= Bi;

  rp = MPZ_REALLOC (r, rn);

  f = (mp_limb_t) x;
  x -= f;
  assert (x < 1.0);
  i = rn-1;
  rp[i] = f;
  while (--i >= 0)
    {
      x = B * x;
      f = (mp_limb_t) x;
      x -= f;
      assert (x < 1.0);
      rp[i] = f;
    }

  r->_mp_size = sign ? - rn : rn;
}

void
mpz_init_set_d (mpz_t r, double x)
{
  mpz_init (r);
  mpz_set_d (r, x);
}

double
mpz_get_d (const mpz_t u)
{
  int m;
  mp_limb_t l;
  mp_size_t un;
  double x;
  double B = 4.0 * (double) (GMP_LIMB_HIGHBIT >> 1);

  un = GMP_ABS (u->_mp_size);

  if (un == 0)
    return 0.0;

  l = u->_mp_d[--un];
  gmp_clz (m, l);
  m = m + GMP_DBL_MANT_BITS - GMP_LIMB_BITS;
  if (m < 0)
    l &= GMP_LIMB_MAX << -m;

  for (x = l; --un >= 0;)
    {
      x = B*x;
      if (m > 0) {
	l = u->_mp_d[un];
	m -= GMP_LIMB_BITS;
	if (m < 0)
	  l &= GMP_LIMB_MAX << -m;
	x += l;
      }
    }

  if (u->_mp_size < 0)
    x = -x;

  return x;
}

int
mpz_cmpabs_d (const mpz_t x, double d)
{
  mp_size_t xn;
  double B, Bi;
  mp_size_t i;

  xn = x->_mp_size;
  d = GMP_ABS (d);

  if (xn != 0)
    {
      xn = GMP_ABS (xn);

      B = 4.0 * (double) (GMP_LIMB_HIGHBIT >> 1);
      Bi = 1.0 / B;

      /* Scale d so it can be compared with the top limb. */
      for (i = 1; i < xn; i++)
	d *= Bi;

      if (d >= B)
	return -1;

      /* Compare floor(d) to top limb, subtract and cancel when equal. */
      for (i = xn; i-- > 0;)
	{
	  mp_limb_t f, xl;

	  f = (mp_limb_t) d;
	  xl = x->_mp_d[i];
	  if (xl > f)
	    return 1;
	  else if (xl < f)
	    return -1;
	  d = B * (d - f);
	}
    }
  return - (d > 0.0);
}

int
mpz_cmp_d (const mpz_t x, double d)
{
  if (x->_mp_size < 0)
    {
      if (d >= 0.0)
	return -1;
      else
	return -mpz_cmpabs_d (x, d);
    }
  else
    {
      if (d < 0.0)
	return 1;
      else
	return mpz_cmpabs_d (x, d);
    }
}


/* MPZ comparisons and the like. */
int
mpz_sgn (const mpz_t u)
{
  return GMP_CMP (u->_mp_size, 0);
}

int
mpz_cmp_si (const mpz_t u, long v)
{
  mp_size_t usize = u->_mp_size;

  if (v >= 0)
    return mpz_cmp_ui (u, v);
  else if (usize >= 0)
    return 1;
  else
    return - mpz_cmpabs_ui (u, GMP_NEG_CAST (unsigned long int, v));
}

int
mpz_cmp_ui (const mpz_t u, unsigned long v)
{
  mp_size_t usize = u->_mp_size;

  if (usize < 0)
    return -1;
  else
    return mpz_cmpabs_ui (u, v);
}

int
mpz_cmp (const mpz_t a, const mpz_t b)
{
  mp_size_t asize = a->_mp_size;
  mp_size_t bsize = b->_mp_size;

  if (asize != bsize)
    return (asize < bsize) ? -1 : 1;
  else if (asize >= 0)
    return mpn_cmp (a->_mp_d, b->_mp_d, asize);
  else
    return mpn_cmp (b->_mp_d, a->_mp_d, -asize);
}

int
mpz_cmpabs_ui (const mpz_t u, unsigned long v)
{
  mp_size_t un = GMP_ABS (u->_mp_size);

  if (! mpn_absfits_ulong_p (u->_mp_d, un))
    return 1;
  else
    {
      unsigned long uu = mpz_get_ui (u);
      return GMP_CMP(uu, v);
    }
}

int
mpz_cmpabs (const mpz_t u, const mpz_t v)
{
  return mpn_cmp4 (u->_mp_d, GMP_ABS (u->_mp_size),
		   v->_mp_d, GMP_ABS (v->_mp_size));
}

void
mpz_abs (mpz_t r, const mpz_t u)
{
  mpz_set (r, u);
  r->_mp_size = GMP_ABS (r->_mp_size);
}

void
mpz_neg (mpz_t r, const mpz_t u)
{
  mpz_set (r, u);
  r->_mp_size = -r->_mp_size;
}

void
mpz_swap (mpz_t u, mpz_t v)
{
  MP_SIZE_T_SWAP (u->_mp_size, v->_mp_size);
  MP_SIZE_T_SWAP (u->_mp_alloc, v->_mp_alloc);
  MP_PTR_SWAP (u->_mp_d, v->_mp_d);
}


/* MPZ addition and subtraction */


void
mpz_add_ui (mpz_t r, const mpz_t a, unsigned long b)
{
  mpz_t bb;
  mpz_init_set_ui (bb, b);
  mpz_add (r, a, bb);
  mpz_clear (bb);
}

void
mpz_sub_ui (mpz_t r, const mpz_t a, unsigned long b)
{
  mpz_ui_sub (r, b, a);
  mpz_neg (r, r);
}

void
mpz_ui_sub (mpz_t r, unsigned long a, const mpz_t b)
{
  mpz_neg (r, b);
  mpz_add_ui (r, r, a);
}

static mp_size_t
mpz_abs_add (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t an = GMP_ABS (a->_mp_size);
  mp_size_t bn = GMP_ABS (b->_mp_size);
  mp_ptr rp;
  mp_limb_t cy;

  if (an < bn)
    {
      MPZ_SRCPTR_SWAP (a, b);
      MP_SIZE_T_SWAP (an, bn);
    }

  rp = MPZ_REALLOC (r, an + 1);
  cy = mpn_add (rp, a->_mp_d, an, b->_mp_d, bn);

  rp[an] = cy;

  return an + cy;
}

static mp_size_t
mpz_abs_sub (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t an = GMP_ABS (a->_mp_size);
  mp_size_t bn = GMP_ABS (b->_mp_size);
  int cmp;
  mp_ptr rp;

  cmp = mpn_cmp4 (a->_mp_d, an, b->_mp_d, bn);
  if (cmp > 0)
    {
      rp = MPZ_REALLOC (r, an);
      gmp_assert_nocarry (mpn_sub (rp, a->_mp_d, an, b->_mp_d, bn));
      return mpn_normalized_size (rp, an);
    }
  else if (cmp < 0)
    {
      rp = MPZ_REALLOC (r, bn);
      gmp_assert_nocarry (mpn_sub (rp, b->_mp_d, bn, a->_mp_d, an));
      return -mpn_normalized_size (rp, bn);
    }
  else
    return 0;
}

void
mpz_add (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t rn;

  if ( (a->_mp_size ^ b->_mp_size) >= 0)
    rn = mpz_abs_add (r, a, b);
  else
    rn = mpz_abs_sub (r, a, b);

  r->_mp_size = a->_mp_size >= 0 ? rn : - rn;
}

void
mpz_sub (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t rn;

  if ( (a->_mp_size ^ b->_mp_size) >= 0)
    rn = mpz_abs_sub (r, a, b);
  else
    rn = mpz_abs_add (r, a, b);

  r->_mp_size = a->_mp_size >= 0 ? rn : - rn;
}


/* MPZ multiplication */
void
mpz_mul_si (mpz_t r, const mpz_t u, long int v)
{
  if (v < 0)
    {
      mpz_mul_ui (r, u, GMP_NEG_CAST (unsigned long int, v));
      mpz_neg (r, r);
    }
  else
    mpz_mul_ui (r, u, v);
}

void
mpz_mul_ui (mpz_t r, const mpz_t u, unsigned long int v)
{
  mpz_t vv;
  mpz_init_set_ui (vv, v);
  mpz_mul (r, u, vv);
  mpz_clear (vv);
  return;
}

void
mpz_mul (mpz_t r, const mpz_t u, const mpz_t v)
{
  int sign;
  mp_size_t un, vn, rn;
  mpz_t t;
  mp_ptr tp;

  un = u->_mp_size;
  vn = v->_mp_size;

  if (un == 0 || vn == 0)
    {
      r->_mp_size = 0;
      return;
    }

  sign = (un ^ vn) < 0;

  un = GMP_ABS (un);
  vn = GMP_ABS (vn);

  mpz_init2 (t, (un + vn) * GMP_LIMB_BITS);

  tp = t->_mp_d;
  if (un >= vn)
    mpn_mul (tp, u->_mp_d, un, v->_mp_d, vn);
  else
    mpn_mul (tp, v->_mp_d, vn, u->_mp_d, un);

  rn = un + vn;
  rn -= tp[rn-1] == 0;

  t->_mp_size = sign ? - rn : rn;
  mpz_swap (r, t);
  mpz_clear (t);
}

void
mpz_mul_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bits)
{
  mp_size_t un, rn;
  mp_size_t limbs;
  unsigned shift;
  mp_ptr rp;

  un = GMP_ABS (u->_mp_size);
  if (un == 0)
    {
      r->_mp_size = 0;
      return;
    }

  limbs = bits / GMP_LIMB_BITS;
  shift = bits % GMP_LIMB_BITS;

  rn = un + limbs + (shift > 0);
  rp = MPZ_REALLOC (r, rn);
  if (shift > 0)
    {
      mp_limb_t cy = mpn_lshift (rp + limbs, u->_mp_d, un, shift);
      rp[rn-1] = cy;
      rn -= (cy == 0);
    }
  else
    mpn_copyd (rp + limbs, u->_mp_d, un);

  mpn_zero (rp, limbs);

  r->_mp_size = (u->_mp_size < 0) ? - rn : rn;
}

void
mpz_addmul_ui (mpz_t r, const mpz_t u, unsigned long int v)
{
  mpz_t t;
  mpz_init_set_ui (t, v);
  mpz_mul (t, u, t);
  mpz_add (r, r, t);
  mpz_clear (t);
}

void
mpz_submul_ui (mpz_t r, const mpz_t u, unsigned long int v)
{
  mpz_t t;
  mpz_init_set_ui (t, v);
  mpz_mul (t, u, t);
  mpz_sub (r, r, t);
  mpz_clear (t);
}

void
mpz_addmul (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t t;
  mpz_init (t);
  mpz_mul (t, u, v);
  mpz_add (r, r, t);
  mpz_clear (t);
}

void
mpz_submul (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t t;
  mpz_init (t);
  mpz_mul (t, u, v);
  mpz_sub (r, r, t);
  mpz_clear (t);
}


/* MPZ division */
enum mpz_div_round_mode { GMP_DIV_FLOOR, GMP_DIV_CEIL, GMP_DIV_TRUNC };

/* Allows q or r to be zero. Returns 1 iff remainder is non-zero. */
static int
mpz_div_qr (mpz_t q, mpz_t r,
	    const mpz_t n, const mpz_t d, enum mpz_div_round_mode mode)
{
  mp_size_t ns, ds, nn, dn, qs;
  ns = n->_mp_size;
  ds = d->_mp_size;

  if (ds == 0)
    gmp_die("mpz_div_qr: Divide by zero.");

  if (ns == 0)
    {
      if (q)
	q->_mp_size = 0;
      if (r)
	r->_mp_size = 0;
      return 0;
    }

  nn = GMP_ABS (ns);
  dn = GMP_ABS (ds);

  qs = ds ^ ns;

  if (nn < dn)
    {
      if (mode == GMP_DIV_CEIL && qs >= 0)
	{
	  /* q = 1, r = n - d */
	  if (r)
	    mpz_sub (r, n, d);
	  if (q)
	    mpz_set_ui (q, 1);
	}
      else if (mode == GMP_DIV_FLOOR && qs < 0)
	{
	  /* q = -1, r = n + d */
	  if (r)
	    mpz_add (r, n, d);
	  if (q)
	    mpz_set_si (q, -1);
	}
      else
	{
	  /* q = 0, r = d */
	  if (r)
	    mpz_set (r, n);
	  if (q)
	    q->_mp_size = 0;
	}
      return 1;
    }
  else
    {
      mp_ptr np, qp;
      mp_size_t qn, rn;
      mpz_t tq, tr;

      mpz_init_set (tr, n);
      np = tr->_mp_d;

      qn = nn - dn + 1;

      if (q)
	{
	  mpz_init2 (tq, qn * GMP_LIMB_BITS);
	  qp = tq->_mp_d;
	}
      else
	qp = NULL;

      mpn_div_qr (qp, np, nn, d->_mp_d, dn);

      if (qp)
	{
	  qn -= (qp[qn-1] == 0);

	  tq->_mp_size = qs < 0 ? -qn : qn;
	}
      rn = mpn_normalized_size (np, dn);
      tr->_mp_size = ns < 0 ? - rn : rn;

      if (mode == GMP_DIV_FLOOR && qs < 0 && rn != 0)
	{
	  if (q)
	    mpz_sub_ui (tq, tq, 1);
	  if (r)
	    mpz_add (tr, tr, d);
	}
      else if (mode == GMP_DIV_CEIL && qs >= 0 && rn != 0)
	{
	  if (q)
	    mpz_add_ui (tq, tq, 1);
	  if (r)
	    mpz_sub (tr, tr, d);
	}

      if (q)
	{
	  mpz_swap (tq, q);
	  mpz_clear (tq);
	}
      if (r)
	mpz_swap (tr, r);

      mpz_clear (tr);

      return rn != 0;
    }
}

void
mpz_cdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, r, n, d, GMP_DIV_CEIL);
}

void
mpz_fdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, r, n, d, GMP_DIV_FLOOR);
}

void
mpz_tdiv_qr (mpz_t q, mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, r, n, d, GMP_DIV_TRUNC);
}

void
mpz_cdiv_q (mpz_t q, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, NULL, n, d, GMP_DIV_CEIL);
}

void
mpz_fdiv_q (mpz_t q, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, NULL, n, d, GMP_DIV_FLOOR);
}

void
mpz_tdiv_q (mpz_t q, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (q, NULL, n, d, GMP_DIV_TRUNC);
}

void
mpz_cdiv_r (mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (NULL, r, n, d, GMP_DIV_CEIL);
}

void
mpz_fdiv_r (mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (NULL, r, n, d, GMP_DIV_FLOOR);
}

void
mpz_tdiv_r (mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (NULL, r, n, d, GMP_DIV_TRUNC);
}

void
mpz_mod (mpz_t r, const mpz_t n, const mpz_t d)
{
  mpz_div_qr (NULL, r, n, d, d->_mp_size >= 0 ? GMP_DIV_FLOOR : GMP_DIV_CEIL);
}

static void
mpz_div_q_2exp (mpz_t q, const mpz_t u, mp_bitcnt_t bit_index,
		enum mpz_div_round_mode mode)
{
  mp_size_t un, qn;
  mp_size_t limb_cnt;
  mp_ptr qp;
  int adjust;

  un = u->_mp_size;
  if (un == 0)
    {
      q->_mp_size = 0;
      return;
    }
  limb_cnt = bit_index / GMP_LIMB_BITS;
  qn = GMP_ABS (un) - limb_cnt;
  bit_index %= GMP_LIMB_BITS;

  if (mode == ((un > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* un != 0 here. */
    /* Note: Below, the final indexing at limb_cnt is valid because at
       that point we have qn > 0. */
    adjust = (qn <= 0
	      || !mpn_zero_p (u->_mp_d, limb_cnt)
	      || (u->_mp_d[limb_cnt]
		  & (((mp_limb_t) 1 << bit_index) - 1)));
  else
    adjust = 0;

  if (qn <= 0)
    qn = 0;
  else
    {
      qp = MPZ_REALLOC (q, qn);

      if (bit_index != 0)
	{
	  mpn_rshift (qp, u->_mp_d + limb_cnt, qn, bit_index);
	  qn -= qp[qn - 1] == 0;
	}
      else
	{
	  mpn_copyi (qp, u->_mp_d + limb_cnt, qn);
	}
    }

  q->_mp_size = qn;

  if (adjust)
    mpz_add_ui (q, q, 1);
  if (un < 0)
    mpz_neg (q, q);
}

static void
mpz_div_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bit_index,
		enum mpz_div_round_mode mode)
{
  mp_size_t us, un, rn;
  mp_ptr rp;
  mp_limb_t mask;

  us = u->_mp_size;
  if (us == 0 || bit_index == 0)
    {
      r->_mp_size = 0;
      return;
    }
  rn = (bit_index + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
  assert (rn > 0);

  rp = MPZ_REALLOC (r, rn);
  un = GMP_ABS (us);

  mask = GMP_LIMB_MAX >> (rn * GMP_LIMB_BITS - bit_index);

  if (rn > un)
    {
      /* Quotient (with truncation) is zero, and remainder is
	 non-zero */
      if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */
	{
	  /* Have to negate and sign extend. */
	  mp_size_t i;

	  gmp_assert_nocarry (! mpn_neg (rp, u->_mp_d, un));
	  for (i = un; i < rn - 1; i++)
	    rp[i] = GMP_LIMB_MAX;

	  rp[rn-1] = mask;
	  us = -us;
	}
      else
	{
	  /* Just copy */
	  if (r != u)
	    mpn_copyi (rp, u->_mp_d, un);

	  rn = un;
	}
    }
  else
    {
      if (r != u)
	mpn_copyi (rp, u->_mp_d, rn - 1);

      rp[rn-1] = u->_mp_d[rn-1] & mask;

      if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */
	{
	  /* If r != 0, compute 2^{bit_count} - r. */
	  mpn_neg (rp, rp, rn);

	  rp[rn-1] &= mask;

	  /* us is not used for anything else, so we can modify it
	     here to indicate flipped sign. */
	  us = -us;
	}
    }
  rn = mpn_normalized_size (rp, rn);
  r->_mp_size = us < 0 ? -rn : rn;
}

void
mpz_cdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_q_2exp (r, u, cnt, GMP_DIV_CEIL);
}

void
mpz_fdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_q_2exp (r, u, cnt, GMP_DIV_FLOOR);
}

void
mpz_tdiv_q_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_q_2exp (r, u, cnt, GMP_DIV_TRUNC);
}

void
mpz_cdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_r_2exp (r, u, cnt, GMP_DIV_CEIL);
}

void
mpz_fdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_r_2exp (r, u, cnt, GMP_DIV_FLOOR);
}

void
mpz_tdiv_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t cnt)
{
  mpz_div_r_2exp (r, u, cnt, GMP_DIV_TRUNC);
}

void
mpz_divexact (mpz_t q, const mpz_t n, const mpz_t d)
{
  gmp_assert_nocarry (mpz_div_qr (q, NULL, n, d, GMP_DIV_TRUNC));
}

int
mpz_divisible_p (const mpz_t n, const mpz_t d)
{
  return mpz_div_qr (NULL, NULL, n, d, GMP_DIV_TRUNC) == 0;
}

int
mpz_congruent_p (const mpz_t a, const mpz_t b, const mpz_t m)
{
  mpz_t t;
  int res;

  /* a == b (mod 0) iff a == b */
  if (mpz_sgn (m) == 0)
    return (mpz_cmp (a, b) == 0);

  mpz_init (t);
  mpz_sub (t, a, b);
  res = mpz_divisible_p (t, m);
  mpz_clear (t);

  return res;
}

static unsigned long
mpz_div_qr_ui (mpz_t q, mpz_t r,
	       const mpz_t n, unsigned long d, enum mpz_div_round_mode mode)
{
  unsigned long ret;
  mpz_t rr, dd;

  mpz_init (rr);
  mpz_init_set_ui (dd, d);
  mpz_div_qr (q, rr, n, dd, mode);
  mpz_clear (dd);
  ret = mpz_get_ui (rr);

  if (r)
    mpz_swap (r, rr);
  mpz_clear (rr);

  return ret;
}

unsigned long
mpz_cdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, r, n, d, GMP_DIV_CEIL);
}

unsigned long
mpz_fdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, r, n, d, GMP_DIV_FLOOR);
}

unsigned long
mpz_tdiv_qr_ui (mpz_t q, mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, r, n, d, GMP_DIV_TRUNC);
}

unsigned long
mpz_cdiv_q_ui (mpz_t q, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_CEIL);
}

unsigned long
mpz_fdiv_q_ui (mpz_t q, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_FLOOR);
}

unsigned long
mpz_tdiv_q_ui (mpz_t q, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_TRUNC);
}

unsigned long
mpz_cdiv_r_ui (mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_CEIL);
}
unsigned long
mpz_fdiv_r_ui (mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_FLOOR);
}
unsigned long
mpz_tdiv_r_ui (mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_TRUNC);
}

unsigned long
mpz_cdiv_ui (const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_CEIL);
}

unsigned long
mpz_fdiv_ui (const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_FLOOR);
}

unsigned long
mpz_tdiv_ui (const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_TRUNC);
}

unsigned long
mpz_mod_ui (mpz_t r, const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, r, n, d, GMP_DIV_FLOOR);
}

void
mpz_divexact_ui (mpz_t q, const mpz_t n, unsigned long d)
{
  gmp_assert_nocarry (mpz_div_qr_ui (q, NULL, n, d, GMP_DIV_TRUNC));
}

int
mpz_divisible_ui_p (const mpz_t n, unsigned long d)
{
  return mpz_div_qr_ui (NULL, NULL, n, d, GMP_DIV_TRUNC) == 0;
}


/* GCD */
static mp_limb_t
mpn_gcd_11 (mp_limb_t u, mp_limb_t v)
{
  unsigned shift;

  assert ( (u | v) > 0);

  if (u == 0)
    return v;
  else if (v == 0)
    return u;

  gmp_ctz (shift, u | v);

  u >>= shift;
  v >>= shift;

  if ( (u & 1) == 0)
    MP_LIMB_T_SWAP (u, v);

  while ( (v & 1) == 0)
    v >>= 1;

  while (u != v)
    {
      if (u > v)
	{
	  u -= v;
	  do
	    u >>= 1;
	  while ( (u & 1) == 0);
	}
      else
	{
	  v -= u;
	  do
	    v >>= 1;
	  while ( (v & 1) == 0);
	}
    }
  return u << shift;
}

unsigned long
mpz_gcd_ui (mpz_t g, const mpz_t u, unsigned long v)
{
  mpz_t t;
  mpz_init_set_ui(t, v);
  mpz_gcd (t, u, t);
  if (v > 0)
    v = mpz_get_ui (t);

  if (g)
    mpz_swap (t, g);

  mpz_clear (t);

  return v;
}

static mp_bitcnt_t
mpz_make_odd (mpz_t r)
{
  mp_bitcnt_t shift;

  assert (r->_mp_size > 0);
  /* Count trailing zeros, equivalent to mpn_scan1, because we know that there is a 1 */
  shift = mpn_common_scan (r->_mp_d[0], 0, r->_mp_d, 0, 0);
  mpz_tdiv_q_2exp (r, r, shift);

  return shift;
}

void
mpz_gcd (mpz_t g, const mpz_t u, const mpz_t v)
{
  mpz_t tu, tv;
  mp_bitcnt_t uz, vz, gz;

  if (u->_mp_size == 0)
    {
      mpz_abs (g, v);
      return;
    }
  if (v->_mp_size == 0)
    {
      mpz_abs (g, u);
      return;
    }

  mpz_init (tu);
  mpz_init (tv);

  mpz_abs (tu, u);
  uz = mpz_make_odd (tu);
  mpz_abs (tv, v);
  vz = mpz_make_odd (tv);
  gz = GMP_MIN (uz, vz);

  if (tu->_mp_size < tv->_mp_size)
    mpz_swap (tu, tv);

  mpz_tdiv_r (tu, tu, tv);
  if (tu->_mp_size == 0)
    {
      mpz_swap (g, tv);
    }
  else
    for (;;)
      {
	int c;

	mpz_make_odd (tu);
	c = mpz_cmp (tu, tv);
	if (c == 0)
	  {
	    mpz_swap (g, tu);
	    break;
	  }
	if (c < 0)
	  mpz_swap (tu, tv);

	if (tv->_mp_size == 1)
	  {
	    mp_limb_t vl = tv->_mp_d[0];
	    mp_limb_t ul = mpz_tdiv_ui (tu, vl);
	    mpz_set_ui (g, mpn_gcd_11 (ul, vl));
	    break;
	  }
	mpz_sub (tu, tu, tv);
      }
  mpz_clear (tu);
  mpz_clear (tv);
  mpz_mul_2exp (g, g, gz);
}

void
mpz_gcdext (mpz_t g, mpz_t s, mpz_t t, const mpz_t u, const mpz_t v)
{
  mpz_t tu, tv, s0, s1, t0, t1;
  mp_bitcnt_t uz, vz, gz;
  mp_bitcnt_t power;

  if (u->_mp_size == 0)
    {
      /* g = 0 u + sgn(v) v */
      signed long sign = mpz_sgn (v);
      mpz_abs (g, v);
      if (s)
	s->_mp_size = 0;
      if (t)
	mpz_set_si (t, sign);
      return;
    }

  if (v->_mp_size == 0)
    {
      /* g = sgn(u) u + 0 v */
      signed long sign = mpz_sgn (u);
      mpz_abs (g, u);
      if (s)
	mpz_set_si (s, sign);
      if (t)
	t->_mp_size = 0;
      return;
    }

  mpz_init (tu);
  mpz_init (tv);
  mpz_init (s0);
  mpz_init (s1);
  mpz_init (t0);
  mpz_init (t1);

  mpz_abs (tu, u);
  uz = mpz_make_odd (tu);
  mpz_abs (tv, v);
  vz = mpz_make_odd (tv);
  gz = GMP_MIN (uz, vz);

  uz -= gz;
  vz -= gz;

  /* Cofactors corresponding to odd gcd. gz handled later. */
  if (tu->_mp_size < tv->_mp_size)
    {
      mpz_swap (tu, tv);
      MPZ_SRCPTR_SWAP (u, v);
      MPZ_PTR_SWAP (s, t);
      MP_BITCNT_T_SWAP (uz, vz);
    }

  /* Maintain
   *
   * u = t0 tu + t1 tv
   * v = s0 tu + s1 tv
   *
   * where u and v denote the inputs with common factors of two
   * eliminated, and det (s0, t0; s1, t1) = 2^p. Then
   *
   * 2^p tu =  s1 u - t1 v
   * 2^p tv = -s0 u + t0 v
   */

  /* After initial division, tu = q tv + tu', we have
   *
   * u = 2^uz (tu' + q tv)
   * v = 2^vz tv
   *
   * or
   *
   * t0 = 2^uz, t1 = 2^uz q
   * s0 = 0,    s1 = 2^vz
   */

  mpz_setbit (t0, uz);
  mpz_tdiv_qr (t1, tu, tu, tv);
  mpz_mul_2exp (t1, t1, uz);

  mpz_setbit (s1, vz);
  power = uz + vz;

  if (tu->_mp_size > 0)
    {
      mp_bitcnt_t shift;
      shift = mpz_make_odd (tu);
      mpz_mul_2exp (t0, t0, shift);
      mpz_mul_2exp (s0, s0, shift);
      power += shift;

      for (;;)
	{
	  int c;
	  c = mpz_cmp (tu, tv);
	  if (c == 0)
	    break;

	  if (c < 0)
	    {
	      /* tv = tv' + tu
	       *
	       * u = t0 tu + t1 (tv' + tu) = (t0 + t1) tu + t1 tv'
	       * v = s0 tu + s1 (tv' + tu) = (s0 + s1) tu + s1 tv' */

	      mpz_sub (tv, tv, tu);
	      mpz_add (t0, t0, t1);
	      mpz_add (s0, s0, s1);

	      shift = mpz_make_odd (tv);
	      mpz_mul_2exp (t1, t1, shift);
	      mpz_mul_2exp (s1, s1, shift);
	    }
	  else
	    {
	      mpz_sub (tu, tu, tv);
	      mpz_add (t1, t0, t1);
	      mpz_add (s1, s0, s1);

	      shift = mpz_make_odd (tu);
	      mpz_mul_2exp (t0, t0, shift);
	      mpz_mul_2exp (s0, s0, shift);
	    }
	  power += shift;
	}
    }

  /* Now tv = odd part of gcd, and -s0 and t0 are corresponding
     cofactors. */

  mpz_mul_2exp (tv, tv, gz);
  mpz_neg (s0, s0);

  /* 2^p g = s0 u + t0 v. Eliminate one factor of two at a time. To
     adjust cofactors, we need u / g and v / g */

  mpz_divexact (s1, v, tv);
  mpz_abs (s1, s1);
  mpz_divexact (t1, u, tv);
  mpz_abs (t1, t1);

  while (power-- > 0)
    {
      /* s0 u + t0 v = (s0 - v/g) u - (t0 + u/g) v */
      if (mpz_odd_p (s0) || mpz_odd_p (t0))
	{
	  mpz_sub (s0, s0, s1);
	  mpz_add (t0, t0, t1);
	}
      assert (mpz_even_p (t0) && mpz_even_p (s0));
      mpz_tdiv_q_2exp (s0, s0, 1);
      mpz_tdiv_q_2exp (t0, t0, 1);
    }

  /* Arrange so that |s| < |u| / 2g */
  mpz_add (s1, s0, s1);
  if (mpz_cmpabs (s0, s1) > 0)
    {
      mpz_swap (s0, s1);
      mpz_sub (t0, t0, t1);
    }
  if (u->_mp_size < 0)
    mpz_neg (s0, s0);
  if (v->_mp_size < 0)
    mpz_neg (t0, t0);

  mpz_swap (g, tv);
  if (s)
    mpz_swap (s, s0);
  if (t)
    mpz_swap (t, t0);

  mpz_clear (tu);
  mpz_clear (tv);
  mpz_clear (s0);
  mpz_clear (s1);
  mpz_clear (t0);
  mpz_clear (t1);
}

void
mpz_lcm (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t g;

  if (u->_mp_size == 0 || v->_mp_size == 0)
    {
      r->_mp_size = 0;
      return;
    }

  mpz_init (g);

  mpz_gcd (g, u, v);
  mpz_divexact (g, u, g);
  mpz_mul (r, g, v);

  mpz_clear (g);
  mpz_abs (r, r);
}

void
mpz_lcm_ui (mpz_t r, const mpz_t u, unsigned long v)
{
  if (v == 0 || u->_mp_size == 0)
    {
      r->_mp_size = 0;
      return;
    }

  v /= mpz_gcd_ui (NULL, u, v);
  mpz_mul_ui (r, u, v);

  mpz_abs (r, r);
}

int
mpz_invert (mpz_t r, const mpz_t u, const mpz_t m)
{
  mpz_t g, tr;
  int invertible;

  if (u->_mp_size == 0 || mpz_cmpabs_ui (m, 1) <= 0)
    return 0;

  mpz_init (g);
  mpz_init (tr);

  mpz_gcdext (g, tr, NULL, u, m);
  invertible = (mpz_cmp_ui (g, 1) == 0);

  if (invertible)
    {
      if (tr->_mp_size < 0)
	{
	  if (m->_mp_size >= 0)
	    mpz_add (tr, tr, m);
	  else
	    mpz_sub (tr, tr, m);
	}
      mpz_swap (r, tr);
    }

  mpz_clear (g);
  mpz_clear (tr);
  return invertible;
}


/* Higher level operations (sqrt, pow and root) */

void
mpz_pow_ui (mpz_t r, const mpz_t b, unsigned long e)
{
  unsigned long bit;
  mpz_t tr;
  mpz_init_set_ui (tr, 1);

  bit = GMP_ULONG_HIGHBIT;
  do
    {
      mpz_mul (tr, tr, tr);
      if (e & bit)
	mpz_mul (tr, tr, b);
      bit >>= 1;
    }
  while (bit > 0);

  mpz_swap (r, tr);
  mpz_clear (tr);
}

void
mpz_ui_pow_ui (mpz_t r, unsigned long blimb, unsigned long e)
{
  mpz_t b;

  mpz_init_set_ui (b, blimb);
  mpz_pow_ui (r, b, e);
  mpz_clear (b);
}

void
mpz_powm (mpz_t r, const mpz_t b, const mpz_t e, const mpz_t m)
{
  mpz_t tr;
  mpz_t base;
  mp_size_t en, mn;
  mp_srcptr mp;
  struct gmp_div_inverse minv;
  unsigned shift;
  mp_ptr tp = NULL;

  en = GMP_ABS (e->_mp_size);
  mn = GMP_ABS (m->_mp_size);
  if (mn == 0)
    gmp_die ("mpz_powm: Zero modulo.");

  if (en == 0)
    {
      mpz_set_ui (r, 1);
      return;
    }

  mp = m->_mp_d;
  mpn_div_qr_invert (&minv, mp, mn);
  shift = minv.shift;

  if (shift > 0)
    {
      /* To avoid shifts, we do all our reductions, except the final
	 one, using a *normalized* m. */
      minv.shift = 0;

      tp = gmp_xalloc_limbs (mn);
      gmp_assert_nocarry (mpn_lshift (tp, mp, mn, shift));
      mp = tp;
    }

  mpz_init (base);

  if (e->_mp_size < 0)
    {
      if (!mpz_invert (base, b, m))
	gmp_die ("mpz_powm: Negative exponent and non-invertible base.");
    }
  else
    {
      mp_size_t bn;
      mpz_abs (base, b);

      bn = base->_mp_size;
      if (bn >= mn)
	{
	  mpn_div_qr_preinv (NULL, base->_mp_d, base->_mp_size, mp, mn, &minv);
	  bn = mn;
	}

      /* We have reduced the absolute value. Now take care of the
	 sign. Note that we get zero represented non-canonically as
	 m. */
      if (b->_mp_size < 0)
	{
	  mp_ptr bp = MPZ_REALLOC (base, mn);
	  gmp_assert_nocarry (mpn_sub (bp, mp, mn, bp, bn));
	  bn = mn;
	}
      base->_mp_size = mpn_normalized_size (base->_mp_d, bn);
    }
  mpz_init_set_ui (tr, 1);

  while (--en >= 0)
    {
      mp_limb_t w = e->_mp_d[en];
      mp_limb_t bit;

      bit = GMP_LIMB_HIGHBIT;
      do
	{
	  mpz_mul (tr, tr, tr);
	  if (w & bit)
	    mpz_mul (tr, tr, base);
	  if (tr->_mp_size > mn)
	    {
	      mpn_div_qr_preinv (NULL, tr->_mp_d, tr->_mp_size, mp, mn, &minv);
	      tr->_mp_size = mpn_normalized_size (tr->_mp_d, mn);
	    }
	  bit >>= 1;
	}
      while (bit > 0);
    }

  /* Final reduction */
  if (tr->_mp_size >= mn)
    {
      minv.shift = shift;
      mpn_div_qr_preinv (NULL, tr->_mp_d, tr->_mp_size, mp, mn, &minv);
      tr->_mp_size = mpn_normalized_size (tr->_mp_d, mn);
    }
  if (tp)
    gmp_free (tp);

  mpz_swap (r, tr);
  mpz_clear (tr);
  mpz_clear (base);
}

void
mpz_powm_ui (mpz_t r, const mpz_t b, unsigned long elimb, const mpz_t m)
{
  mpz_t e;

  mpz_init_set_ui (e, elimb);
  mpz_powm (r, b, e, m);
  mpz_clear (e);
}

/* x=trunc(y^(1/z)), r=y-x^z */
void
mpz_rootrem (mpz_t x, mpz_t r, const mpz_t y, unsigned long z)
{
  int sgn;
  mpz_t t, u;

  sgn = y->_mp_size < 0;
  if ((~z & sgn) != 0)
    gmp_die ("mpz_rootrem: Negative argument, with even root.");
  if (z == 0)
    gmp_die ("mpz_rootrem: Zeroth root.");

  if (mpz_cmpabs_ui (y, 1) <= 0) {
    if (x)
      mpz_set (x, y);
    if (r)
      r->_mp_size = 0;
    return;
  }

  mpz_init (u);
  mpz_init (t);
  mpz_setbit (t, mpz_sizeinbase (y, 2) / z + 1);

  if (z == 2) /* simplify sqrt loop: z-1 == 1 */
    do {
      mpz_swap (u, t);			/* u = x */
      mpz_tdiv_q (t, y, u);		/* t = y/x */
      mpz_add (t, t, u);		/* t = y/x + x */
      mpz_tdiv_q_2exp (t, t, 1);	/* x'= (y/x + x)/2 */
    } while (mpz_cmpabs (t, u) < 0);	/* |x'| < |x| */
  else /* z != 2 */ {
    mpz_t v;

    mpz_init (v);
    if (sgn)
      mpz_neg (t, t);

    do {
      mpz_swap (u, t);			/* u = x */
      mpz_pow_ui (t, u, z - 1);		/* t = x^(z-1) */
      mpz_tdiv_q (t, y, t);		/* t = y/x^(z-1) */
      mpz_mul_ui (v, u, z - 1);		/* v = x*(z-1) */
      mpz_add (t, t, v);		/* t = y/x^(z-1) + x*(z-1) */
      mpz_tdiv_q_ui (t, t, z);		/* x'=(y/x^(z-1) + x*(z-1))/z */
    } while (mpz_cmpabs (t, u) < 0);	/* |x'| < |x| */

    mpz_clear (v);
  }

  if (r) {
    mpz_pow_ui (t, u, z);
    mpz_sub (r, y, t);
  }
  if (x)
    mpz_swap (x, u);
  mpz_clear (u);
  mpz_clear (t);
}

int
mpz_root (mpz_t x, const mpz_t y, unsigned long z)
{
  int res;
  mpz_t r;

  mpz_init (r);
  mpz_rootrem (x, r, y, z);
  res = r->_mp_size == 0;
  mpz_clear (r);

  return res;
}

/* Compute s = floor(sqrt(u)) and r = u - s^2. Allows r == NULL */
void
mpz_sqrtrem (mpz_t s, mpz_t r, const mpz_t u)
{
  mpz_rootrem (s, r, u, 2);
}

void
mpz_sqrt (mpz_t s, const mpz_t u)
{
  mpz_rootrem (s, NULL, u, 2);
}

int
mpz_perfect_square_p (const mpz_t u)
{
  if (u->_mp_size <= 0)
    return (u->_mp_size == 0);
  else
    return mpz_root (NULL, u, 2);
}

int
mpn_perfect_square_p (mp_srcptr p, mp_size_t n)
{
  mpz_t t;

  assert (n > 0);
  assert (p [n-1] != 0);
  return mpz_root (NULL, mpz_roinit_normal_n (t, p, n), 2);
}

mp_size_t
mpn_sqrtrem (mp_ptr sp, mp_ptr rp, mp_srcptr p, mp_size_t n)
{
  mpz_t s, r, u;
  mp_size_t res;

  assert (n > 0);
  assert (p [n-1] != 0);

  mpz_init (r);
  mpz_init (s);
  mpz_rootrem (s, r, mpz_roinit_normal_n (u, p, n), 2);

  assert (s->_mp_size == (n+1)/2);
  mpn_copyd (sp, s->_mp_d, s->_mp_size);
  mpz_clear (s);
  res = r->_mp_size;
  if (rp)
    mpn_copyd (rp, r->_mp_d, res);
  mpz_clear (r);
  return res;
}

/* Combinatorics */

void
mpz_mfac_uiui (mpz_t x, unsigned long n, unsigned long m)
{
  mpz_set_ui (x, n + (n == 0));
  if (m + 1 < 2) return;
  while (n > m + 1)
    mpz_mul_ui (x, x, n -= m);
}

void
mpz_2fac_ui (mpz_t x, unsigned long n)
{
  mpz_mfac_uiui (x, n, 2);
}

void
mpz_fac_ui (mpz_t x, unsigned long n)
{
  mpz_mfac_uiui (x, n, 1);
}

void
mpz_bin_uiui (mpz_t r, unsigned long n, unsigned long k)
{
  mpz_t t;

  mpz_set_ui (r, k <= n);

  if (k > (n >> 1))
    k = (k <= n) ? n - k : 0;

  mpz_init (t);
  mpz_fac_ui (t, k);

  for (; k > 0; --k)
    mpz_mul_ui (r, r, n--);

  mpz_divexact (r, r, t);
  mpz_clear (t);
}


/* Primality testing */

/* Computes Kronecker (a/b) with odd b, a!=0 and GCD(a,b) = 1 */
/* Adapted from JACOBI_BASE_METHOD==4 in mpn/generic/jacbase.c */
static int
gmp_jacobi_coprime (mp_limb_t a, mp_limb_t b)
{
  int c, bit = 0;

  assert (b & 1);
  assert (a != 0);
  /* assert (mpn_gcd_11 (a, b) == 1); */

  /* Below, we represent a and b shifted right so that the least
     significant one bit is implicit. */
  b >>= 1;

  gmp_ctz(c, a);
  a >>= 1;

  do
    {
      a >>= c;
      /* (2/b) = -1 if b = 3 or 5 mod 8 */
      bit ^= c & (b ^ (b >> 1));
      if (a < b)
	{
	  bit ^= a & b;
	  a = b - a;
	  b -= a;
	}
      else
	{
	  a -= b;
	  assert (a != 0);
	}

      gmp_ctz(c, a);
      ++c;
    }
  while (b > 0);

  return bit & 1 ? -1 : 1;
}

static void
gmp_lucas_step_k_2k (mpz_t V, mpz_t Qk, const mpz_t n)
{
  mpz_mod (Qk, Qk, n);
  /* V_{2k} <- V_k ^ 2 - 2Q^k */
  mpz_mul (V, V, V);
  mpz_submul_ui (V, Qk, 2);
  mpz_tdiv_r (V, V, n);
  /* Q^{2k} = (Q^k)^2 */
  mpz_mul (Qk, Qk, Qk);
}

/* Computes V_k, Q^k (mod n) for the Lucas' sequence */
/* with P=1, Q=Q; k = (n>>b0)|1. */
/* Requires an odd n > 4; b0 > 0; -2*Q must not overflow a long */
/* Returns (U_k == 0) and sets V=V_k and Qk=Q^k. */
static int
gmp_lucas_mod (mpz_t V, mpz_t Qk, long Q,
	       mp_bitcnt_t b0, const mpz_t n)
{
  mp_bitcnt_t bs;
  mpz_t U;
  int res;

  assert (b0 > 0);
  assert (Q <= - (LONG_MIN / 2));
  assert (Q >= - (LONG_MAX / 2));
  assert (mpz_cmp_ui (n, 4) > 0);
  assert (mpz_odd_p (n));

  mpz_init_set_ui (U, 1); /* U1 = 1 */
  mpz_set_ui (V, 1); /* V1 = 1 */
  mpz_set_si (Qk, Q);

  for (bs = mpz_sizeinbase (n, 2) - 1; --bs >= b0;)
    {
      /* U_{2k} <- U_k * V_k */
      mpz_mul (U, U, V);
      /* V_{2k} <- V_k ^ 2 - 2Q^k */
      /* Q^{2k} = (Q^k)^2 */
      gmp_lucas_step_k_2k (V, Qk, n);

      /* A step k->k+1 is performed if the bit in $n$ is 1	*/
      /* mpz_tstbit(n,bs) or the bit is 0 in $n$ but	*/
      /* should be 1 in $n+1$ (bs == b0)			*/
      if (b0 == bs || mpz_tstbit (n, bs))
	{
	  /* Q^{k+1} <- Q^k * Q */
	  mpz_mul_si (Qk, Qk, Q);
	  /* U_{k+1} <- (U_k + V_k) / 2 */
	  mpz_swap (U, V); /* Keep in V the old value of U_k */
	  mpz_add (U, U, V);
	  /* We have to compute U/2, so we need an even value, */
	  /* equivalent (mod n) */
	  if (mpz_odd_p (U))
	    mpz_add (U, U, n);
	  mpz_tdiv_q_2exp (U, U, 1);
	  /* V_{k+1} <-(D*U_k + V_k) / 2 =
			U_{k+1} + (D-1)/2*U_k = U_{k+1} - 2Q*U_k */
	  mpz_mul_si (V, V, -2*Q);
	  mpz_add (V, U, V);
	  mpz_tdiv_r (V, V, n);
	}
      mpz_tdiv_r (U, U, n);
    }

  res = U->_mp_size == 0;
  mpz_clear (U);
  return res;
}

/* Performs strong Lucas' test on x, with parameters suggested */
/* for the BPSW test. Qk is only passed to recycle a variable. */
/* Requires GCD (x,6) = 1.*/
static int
gmp_stronglucas (const mpz_t x, mpz_t Qk)
{
  mp_bitcnt_t b0;
  mpz_t V, n;
  mp_limb_t maxD, D; /* The absolute value is stored. */
  long Q;
  mp_limb_t tl;

  /* Test on the absolute value. */
  mpz_roinit_normal_n (n, x->_mp_d, GMP_ABS (x->_mp_size));

  assert (mpz_odd_p (n));
  /* assert (mpz_gcd_ui (NULL, n, 6) == 1); */
  if (mpz_root (Qk, n, 2))
    return 0; /* A square is composite. */

  /* Check Ds up to square root (in case, n is prime)
     or avoid overflows */
  maxD = (Qk->_mp_size == 1) ? Qk->_mp_d [0] - 1 : GMP_LIMB_MAX;

  D = 3;
  /* Search a D such that (D/n) = -1 in the sequence 5,-7,9,-11,.. */
  /* For those Ds we have (D/n) = (n/|D|) */
  do
    {
      if (D >= maxD)
	return 1 + (D != GMP_LIMB_MAX); /* (1 + ! ~ D) */
      D += 2;
      tl = mpz_tdiv_ui (n, D);
      if (tl == 0)
	return 0;
    }
  while (gmp_jacobi_coprime (tl, D) == 1);

  mpz_init (V);

  /* n-(D/n) = n+1 = d*2^{b0}, with d = (n>>b0) | 1 */
  b0 = mpz_scan0 (n, 0);

  /* D= P^2 - 4Q; P = 1; Q = (1-D)/4 */
  Q = (D & 2) ? (long) (D >> 2) + 1 : -(long) (D >> 2);

  if (! gmp_lucas_mod (V, Qk, Q, b0, n))	/* If Ud != 0 */
    while (V->_mp_size != 0 && --b0 != 0)	/* while Vk != 0 */
      /* V <- V ^ 2 - 2Q^k */
      /* Q^{2k} = (Q^k)^2 */
      gmp_lucas_step_k_2k (V, Qk, n);

  mpz_clear (V);
  return (b0 != 0);
}

static int
gmp_millerrabin (const mpz_t n, const mpz_t nm1, mpz_t y,
		 const mpz_t q, mp_bitcnt_t k)
{
  assert (k > 0);

  /* Caller must initialize y to the base. */
  mpz_powm (y, y, q, n);

  if (mpz_cmp_ui (y, 1) == 0 || mpz_cmp (y, nm1) == 0)
    return 1;

  while (--k > 0)
    {
      mpz_powm_ui (y, y, 2, n);
      if (mpz_cmp (y, nm1) == 0)
	return 1;
      /* y == 1 means that the previous y was a non-trivial square root
	 of 1 (mod n). y == 0 means that n is a power of the base.
	 In either case, n is not prime. */
      if (mpz_cmp_ui (y, 1) <= 0)
	return 0;
    }
  return 0;
}

/* This product is 0xc0cfd797, and fits in 32 bits. */
#define GMP_PRIME_PRODUCT \
  (3UL*5UL*7UL*11UL*13UL*17UL*19UL*23UL*29UL)

/* Bit (p+1)/2 is set, for each odd prime <= 61 */
#define GMP_PRIME_MASK 0xc96996dcUL

int
mpz_probab_prime_p (const mpz_t n, int reps)
{
  mpz_t nm1;
  mpz_t q;
  mpz_t y;
  mp_bitcnt_t k;
  int is_prime;
  int j;

  /* Note that we use the absolute value of n only, for compatibility
     with the real GMP. */
  if (mpz_even_p (n))
    return (mpz_cmpabs_ui (n, 2) == 0) ? 2 : 0;

  /* Above test excludes n == 0 */
  assert (n->_mp_size != 0);

  if (mpz_cmpabs_ui (n, 64) < 0)
    return (GMP_PRIME_MASK >> (n->_mp_d[0] >> 1)) & 2;

  if (mpz_gcd_ui (NULL, n, GMP_PRIME_PRODUCT) != 1)
    return 0;

  /* All prime factors are >= 31. */
  if (mpz_cmpabs_ui (n, 31*31) < 0)
    return 2;

  mpz_init (nm1);
  mpz_init (q);

  /* Find q and k, where q is odd and n = 1 + 2**k * q.  */
  mpz_abs (nm1, n);
  nm1->_mp_d[0] -= 1;
  k = mpz_scan1 (nm1, 0);
  mpz_tdiv_q_2exp (q, nm1, k);

  /* BPSW test */
  mpz_init_set_ui (y, 2);
  is_prime = gmp_millerrabin (n, nm1, y, q, k) && gmp_stronglucas (n, y);
  reps -= 24; /* skip the first 24 repetitions */

  /* Use Miller-Rabin, with a deterministic sequence of bases, a[j] =
     j^2 + j + 41 using Euler's polynomial. We potentially stop early,
     if a[j] >= n - 1. Since n >= 31*31, this can happen only if reps >
     30 (a[30] == 971 > 31*31 == 961). */

  for (j = 0; is_prime & (j < reps); j++)
    {
      mpz_set_ui (y, (unsigned long) j*j+j+41);
      if (mpz_cmp (y, nm1) >= 0)
	{
	  /* Don't try any further bases. This "early" break does not affect
	     the result for any reasonable reps value (<=5000 was tested) */
	  assert (j >= 30);
	  break;
	}
      is_prime = gmp_millerrabin (n, nm1, y, q, k);
    }
  mpz_clear (nm1);
  mpz_clear (q);
  mpz_clear (y);

  return is_prime;
}


/* Logical operations and bit manipulation. */

/* Numbers are treated as if represented in two's complement (and
   infinitely sign extended). For a negative values we get the two's
   complement from -x = ~x + 1, where ~ is bitwise complement.
   Negation transforms

     xxxx10...0

   into

     yyyy10...0

   where yyyy is the bitwise complement of xxxx. So least significant
   bits, up to and including the first one bit, are unchanged, and
   the more significant bits are all complemented.

   To change a bit from zero to one in a negative number, subtract the
   corresponding power of two from the absolute value. This can never
   underflow. To change a bit from one to zero, add the corresponding
   power of two, and this might overflow. E.g., if x = -001111, the
   two's complement is 110001. Clearing the least significant bit, we
   get two's complement 110000, and -010000. */

int
mpz_tstbit (const mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t limb_index;
  unsigned shift;
  mp_size_t ds;
  mp_size_t dn;
  mp_limb_t w;
  int bit;

  ds = d->_mp_size;
  dn = GMP_ABS (ds);
  limb_index = bit_index / GMP_LIMB_BITS;
  if (limb_index >= dn)
    return ds < 0;

  shift = bit_index % GMP_LIMB_BITS;
  w = d->_mp_d[limb_index];
  bit = (w >> shift) & 1;

  if (ds < 0)
    {
      /* d < 0. Check if any of the bits below is set: If so, our bit
	 must be complemented. */
      if (shift > 0 && (mp_limb_t) (w << (GMP_LIMB_BITS - shift)) > 0)
	return bit ^ 1;
      while (--limb_index >= 0)
	if (d->_mp_d[limb_index] > 0)
	  return bit ^ 1;
    }
  return bit;
}

static void
mpz_abs_add_bit (mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t dn, limb_index;
  mp_limb_t bit;
  mp_ptr dp;

  dn = GMP_ABS (d->_mp_size);

  limb_index = bit_index / GMP_LIMB_BITS;
  bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS);

  if (limb_index >= dn)
    {
      mp_size_t i;
      /* The bit should be set outside of the end of the number.
	 We have to increase the size of the number. */
      dp = MPZ_REALLOC (d, limb_index + 1);

      dp[limb_index] = bit;
      for (i = dn; i < limb_index; i++)
	dp[i] = 0;
      dn = limb_index + 1;
    }
  else
    {
      mp_limb_t cy;

      dp = d->_mp_d;

      cy = mpn_add_1 (dp + limb_index, dp + limb_index, dn - limb_index, bit);
      if (cy > 0)
	{
	  dp = MPZ_REALLOC (d, dn + 1);
	  dp[dn++] = cy;
	}
    }

  d->_mp_size = (d->_mp_size < 0) ? - dn : dn;
}

static void
mpz_abs_sub_bit (mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t dn, limb_index;
  mp_ptr dp;
  mp_limb_t bit;

  dn = GMP_ABS (d->_mp_size);
  dp = d->_mp_d;

  limb_index = bit_index / GMP_LIMB_BITS;
  bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS);

  assert (limb_index < dn);

  gmp_assert_nocarry (mpn_sub_1 (dp + limb_index, dp + limb_index,
				 dn - limb_index, bit));
  dn = mpn_normalized_size (dp, dn);
  d->_mp_size = (d->_mp_size < 0) ? - dn : dn;
}

void
mpz_setbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (!mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_add_bit (d, bit_index);
      else
	mpz_abs_sub_bit (d, bit_index);
    }
}

void
mpz_clrbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_sub_bit (d, bit_index);
      else
	mpz_abs_add_bit (d, bit_index);
    }
}

void
mpz_combit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (mpz_tstbit (d, bit_index) ^ (d->_mp_size < 0))
    mpz_abs_sub_bit (d, bit_index);
  else
    mpz_abs_add_bit (d, bit_index);
}

void
mpz_com (mpz_t r, const mpz_t u)
{
  mpz_add_ui (r, u, 1);
  mpz_neg (r, r);
}

void
mpz_and (mpz_t r, const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, rn, i;
  mp_ptr up, vp, rp;

  mp_limb_t ux, vx, rx;
  mp_limb_t uc, vc, rc;
  mp_limb_t ul, vl, rl;

  un = GMP_ABS (u->_mp_size);
  vn = GMP_ABS (v->_mp_size);
  if (un < vn)
    {
      MPZ_SRCPTR_SWAP (u, v);
      MP_SIZE_T_SWAP (un, vn);
    }
  if (vn == 0)
    {
      r->_mp_size = 0;
      return;
    }

  uc = u->_mp_size < 0;
  vc = v->_mp_size < 0;
  rc = uc & vc;

  ux = -uc;
  vx = -vc;
  rx = -rc;

  /* If the smaller input is positive, higher limbs don't matter. */
  rn = vx ? un : vn;

  rp = MPZ_REALLOC (r, rn + (mp_size_t) rc);

  up = u->_mp_d;
  vp = v->_mp_d;

  i = 0;
  do
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      vl = (vp[i] ^ vx) + vc;
      vc = vl < vc;

      rl = ( (ul & vl) ^ rx) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  while (++i < vn);
  assert (vc == 0);

  for (; i < rn; i++)
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      rl = ( (ul & vx) ^ rx) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  if (rc)
    rp[rn++] = rc;
  else
    rn = mpn_normalized_size (rp, rn);

  r->_mp_size = rx ? -rn : rn;
}

void
mpz_ior (mpz_t r, const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, rn, i;
  mp_ptr up, vp, rp;

  mp_limb_t ux, vx, rx;
  mp_limb_t uc, vc, rc;
  mp_limb_t ul, vl, rl;

  un = GMP_ABS (u->_mp_size);
  vn = GMP_ABS (v->_mp_size);
  if (un < vn)
    {
      MPZ_SRCPTR_SWAP (u, v);
      MP_SIZE_T_SWAP (un, vn);
    }
  if (vn == 0)
    {
      mpz_set (r, u);
      return;
    }

  uc = u->_mp_size < 0;
  vc = v->_mp_size < 0;
  rc = uc | vc;

  ux = -uc;
  vx = -vc;
  rx = -rc;

  /* If the smaller input is negative, by sign extension higher limbs
     don't matter. */
  rn = vx ? vn : un;

  rp = MPZ_REALLOC (r, rn + (mp_size_t) rc);

  up = u->_mp_d;
  vp = v->_mp_d;

  i = 0;
  do
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      vl = (vp[i] ^ vx) + vc;
      vc = vl < vc;

      rl = ( (ul | vl) ^ rx) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  while (++i < vn);
  assert (vc == 0);

  for (; i < rn; i++)
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      rl = ( (ul | vx) ^ rx) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  if (rc)
    rp[rn++] = rc;
  else
    rn = mpn_normalized_size (rp, rn);

  r->_mp_size = rx ? -rn : rn;
}

void
mpz_xor (mpz_t r, const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, i;
  mp_ptr up, vp, rp;

  mp_limb_t ux, vx, rx;
  mp_limb_t uc, vc, rc;
  mp_limb_t ul, vl, rl;

  un = GMP_ABS (u->_mp_size);
  vn = GMP_ABS (v->_mp_size);
  if (un < vn)
    {
      MPZ_SRCPTR_SWAP (u, v);
      MP_SIZE_T_SWAP (un, vn);
    }
  if (vn == 0)
    {
      mpz_set (r, u);
      return;
    }

  uc = u->_mp_size < 0;
  vc = v->_mp_size < 0;
  rc = uc ^ vc;

  ux = -uc;
  vx = -vc;
  rx = -rc;

  rp = MPZ_REALLOC (r, un + (mp_size_t) rc);

  up = u->_mp_d;
  vp = v->_mp_d;

  i = 0;
  do
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      vl = (vp[i] ^ vx) + vc;
      vc = vl < vc;

      rl = (ul ^ vl ^ rx) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  while (++i < vn);
  assert (vc == 0);

  for (; i < un; i++)
    {
      ul = (up[i] ^ ux) + uc;
      uc = ul < uc;

      rl = (ul ^ ux) + rc;
      rc = rl < rc;
      rp[i] = rl;
    }
  if (rc)
    rp[un++] = rc;
  else
    un = mpn_normalized_size (rp, un);

  r->_mp_size = rx ? -un : un;
}

static unsigned
gmp_popcount_limb (mp_limb_t x)
{
  unsigned c;

  /* Do 16 bits at a time, to avoid limb-sized constants. */
  int LOCAL_SHIFT_BITS = 16;
  for (c = 0; x > 0;)
    {
      unsigned w = x - ((x >> 1) & 0x5555);
      w = ((w >> 2) & 0x3333) + (w & 0x3333);
      w =  (w >> 4) + w;
      w = ((w >> 8) & 0x000f) + (w & 0x000f);
      c += w;
      if (GMP_LIMB_BITS > LOCAL_SHIFT_BITS)
	x >>= LOCAL_SHIFT_BITS;
      else
	x = 0;
    }
  return c;
}

mp_bitcnt_t
mpn_popcount (mp_srcptr p, mp_size_t n)
{
  mp_size_t i;
  mp_bitcnt_t c;

  for (c = 0, i = 0; i < n; i++)
    c += gmp_popcount_limb (p[i]);

  return c;
}

mp_bitcnt_t
mpz_popcount (const mpz_t u)
{
  mp_size_t un;

  un = u->_mp_size;

  if (un < 0)
    return ~(mp_bitcnt_t) 0;

  return mpn_popcount (u->_mp_d, un);
}

mp_bitcnt_t
mpz_hamdist (const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, i;
  mp_limb_t uc, vc, ul, vl, comp;
  mp_srcptr up, vp;
  mp_bitcnt_t c;

  un = u->_mp_size;
  vn = v->_mp_size;

  if ( (un ^ vn) < 0)
    return ~(mp_bitcnt_t) 0;

  comp = - (uc = vc = (un < 0));
  if (uc)
    {
      assert (vn < 0);
      un = -un;
      vn = -vn;
    }

  up = u->_mp_d;
  vp = v->_mp_d;

  if (un < vn)
    MPN_SRCPTR_SWAP (up, un, vp, vn);

  for (i = 0, c = 0; i < vn; i++)
    {
      ul = (up[i] ^ comp) + uc;
      uc = ul < uc;

      vl = (vp[i] ^ comp) + vc;
      vc = vl < vc;

      c += gmp_popcount_limb (ul ^ vl);
    }
  assert (vc == 0);

  for (; i < un; i++)
    {
      ul = (up[i] ^ comp) + uc;
      uc = ul < uc;

      c += gmp_popcount_limb (ul ^ comp);
    }

  return c;
}

mp_bitcnt_t
mpz_scan1 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

  us = u->_mp_size;
  un = GMP_ABS (us);
  i = starting_bit / GMP_LIMB_BITS;

  /* Past the end there's no 1 bits for u>=0, or an immediate 1 bit
     for u<0. Notice this test picks up any u==0 too. */
  if (i >= un)
    return (us >= 0 ? ~(mp_bitcnt_t) 0 : starting_bit);

  up = u->_mp_d;
  ux = 0;
  limb = up[i];

  if (starting_bit != 0)
    {
      if (us < 0)
	{
	  ux = mpn_zero_p (up, i);
	  limb = ~ limb + ux;
	  ux = - (mp_limb_t) (limb >= ux);
	}

      /* Mask to 0 all bits before starting_bit, thus ignoring them. */
      limb &= GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS);
    }

  return mpn_common_scan (limb, i, up, un, ux);
}

mp_bitcnt_t
mpz_scan0 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

  us = u->_mp_size;
  ux = - (mp_limb_t) (us >= 0);
  un = GMP_ABS (us);
  i = starting_bit / GMP_LIMB_BITS;

  /* When past end, there's an immediate 0 bit for u>=0, or no 0 bits for
     u<0.  Notice this test picks up all cases of u==0 too. */
  if (i >= un)
    return (ux ? starting_bit : ~(mp_bitcnt_t) 0);

  up = u->_mp_d;
  limb = up[i] ^ ux;

  if (ux == 0)
    limb -= mpn_zero_p (up, i); /* limb = ~(~limb + zero_p) */

  /* Mask all bits before starting_bit, thus ignoring them. */
  limb &= GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS);

  return mpn_common_scan (limb, i, up, un, ux);
}


/* MPZ base conversion. */

size_t
mpz_sizeinbase (const mpz_t u, int base)
{
  mp_size_t un;
  mp_srcptr up;
  mp_ptr tp;
  mp_bitcnt_t bits;
  struct gmp_div_inverse bi;
  size_t ndigits;

  assert (base >= 2);
  assert (base <= 62);

  un = GMP_ABS (u->_mp_size);
  if (un == 0)
    return 1;

  up = u->_mp_d;

  bits = (un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1]);
  switch (base)
    {
    case 2:
      return bits;
    case 4:
      return (bits + 1) / 2;
    case 8:
      return (bits + 2) / 3;
    case 16:
      return (bits + 3) / 4;
    case 32:
      return (bits + 4) / 5;
      /* FIXME: Do something more clever for the common case of base
	 10. */
    }

  tp = gmp_xalloc_limbs (un);
  mpn_copyi (tp, up, un);
  mpn_div_qr_1_invert (&bi, base);

  ndigits = 0;
  do
    {
      ndigits++;
      mpn_div_qr_1_preinv (tp, tp, un, &bi);
      un -= (tp[un-1] == 0);
    }
  while (un > 0);

  gmp_free (tp);
  return ndigits;
}

char *
mpz_get_str (char *sp, int base, const mpz_t u)
{
  unsigned bits;
  const char *digits;
  mp_size_t un;
  size_t i, sn;

  digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  if (base > 1)
    {
      if (base <= 36)
	digits = "0123456789abcdefghijklmnopqrstuvwxyz";
      else if (base > 62)
	return NULL;
    }
  else if (base >= -1)
    base = 10;
  else
    {
      base = -base;
      if (base > 36)
	return NULL;
    }

  sn = 1 + mpz_sizeinbase (u, base);
  if (!sp)
    sp = (char *) gmp_xalloc (1 + sn);

  un = GMP_ABS (u->_mp_size);

  if (un == 0)
    {
      sp[0] = '0';
      sp[1] = '\0';
      return sp;
    }

  i = 0;

  if (u->_mp_size < 0)
    sp[i++] = '-';

  bits = mpn_base_power_of_two_p (base);

  if (bits)
    /* Not modified in this case. */
    sn = i + mpn_get_str_bits ((unsigned char *) sp + i, bits, u->_mp_d, un);
  else
    {
      struct mpn_base_info info;
      mp_ptr tp;

      mpn_get_base_info (&info, base);
      tp = gmp_xalloc_limbs (un);
      mpn_copyi (tp, u->_mp_d, un);

      sn = i + mpn_get_str_other ((unsigned char *) sp + i, base, &info, tp, un);
      gmp_free (tp);
    }

  for (; i < sn; i++)
    sp[i] = digits[(unsigned char) sp[i]];

  sp[sn] = '\0';
  return sp;
}

int
mpz_set_str (mpz_t r, const char *sp, int base)
{
  unsigned bits, value_of_a;
  mp_size_t rn, alloc;
  mp_ptr rp;
  size_t dn;
  int sign;
  unsigned char *dp;

  assert (base == 0 || (base >= 2 && base <= 62));

  while (isspace( (unsigned char) *sp))
    sp++;

  sign = (*sp == '-');
  sp += sign;

  if (base == 0)
    {
      if (sp[0] == '0')
	{
	  if (sp[1] == 'x' || sp[1] == 'X')
	    {
	      base = 16;
	      sp += 2;
	    }
	  else if (sp[1] == 'b' || sp[1] == 'B')
	    {
	      base = 2;
	      sp += 2;
	    }
	  else
	    base = 8;
	}
      else
	base = 10;
    }

  if (!*sp)
    {
      r->_mp_size = 0;
      return -1;
    }
  dp = (unsigned char *) gmp_xalloc (strlen (sp));

  value_of_a = (base > 36) ? 36 : 10;
  for (dn = 0; *sp; sp++)
    {
      unsigned digit;

      if (isspace ((unsigned char) *sp))
	continue;
      else if (*sp >= '0' && *sp <= '9')
	digit = *sp - '0';
      else if (*sp >= 'a' && *sp <= 'z')
	digit = *sp - 'a' + value_of_a;
      else if (*sp >= 'A' && *sp <= 'Z')
	digit = *sp - 'A' + 10;
      else
	digit = base; /* fail */

      if (digit >= (unsigned) base)
	{
	  gmp_free (dp);
	  r->_mp_size = 0;
	  return -1;
	}

      dp[dn++] = digit;
    }

  if (!dn)
    {
      gmp_free (dp);
      r->_mp_size = 0;
      return -1;
    }
  bits = mpn_base_power_of_two_p (base);

  if (bits > 0)
    {
      alloc = (dn * bits + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
      rp = MPZ_REALLOC (r, alloc);
      rn = mpn_set_str_bits (rp, dp, dn, bits);
    }
  else
    {
      struct mpn_base_info info;
      mpn_get_base_info (&info, base);
      alloc = (dn + info.exp - 1) / info.exp;
      rp = MPZ_REALLOC (r, alloc);
      rn = mpn_set_str_other (rp, dp, dn, base, &info);
      /* Normalization, needed for all-zero input. */
      assert (rn > 0);
      rn -= rp[rn-1] == 0;
    }
  assert (rn <= alloc);
  gmp_free (dp);

  r->_mp_size = sign ? - rn : rn;

  return 0;
}

int
mpz_init_set_str (mpz_t r, const char *sp, int base)
{
  mpz_init (r);
  return mpz_set_str (r, sp, base);
}

size_t
mpz_out_str (FILE *stream, int base, const mpz_t x)
{
  char *str;
  size_t len;

  str = mpz_get_str (NULL, base, x);
  if (!str)
    return 0;
  len = strlen (str);
  len = fwrite (str, 1, len, stream);
  gmp_free (str);
  return len;
}


static int
gmp_detect_endian (void)
{
  static const int i = 2;
  const unsigned char *p = (const unsigned char *) &i;
  return 1 - *p;
}

/* Import and export. Does not support nails. */
void
mpz_import (mpz_t r, size_t count, int order, size_t size, int endian,
	    size_t nails, const void *src)
{
  const unsigned char *p;
  ptrdiff_t word_step;
  mp_ptr rp;
  mp_size_t rn;

  /* The current (partial) limb. */
  mp_limb_t limb;
  /* The number of bytes already copied to this limb (starting from
     the low end). */
  size_t bytes;
  /* The index where the limb should be stored, when completed. */
  mp_size_t i;

  if (nails != 0)
    gmp_die ("mpz_import: Nails not supported.");

  assert (order == 1 || order == -1);
  assert (endian >= -1 && endian <= 1);

  if (endian == 0)
    endian = gmp_detect_endian ();

  p = (unsigned char *) src;

  word_step = (order != endian) ? 2 * size : 0;

  /* Process bytes from the least significant end, so point p at the
     least significant word. */
  if (order == 1)
    {
      p += size * (count - 1);
      word_step = - word_step;
    }

  /* And at least significant byte of that word. */
  if (endian == 1)
    p += (size - 1);

  rn = (size * count + sizeof(mp_limb_t) - 1) / sizeof(mp_limb_t);
  rp = MPZ_REALLOC (r, rn);

  for (limb = 0, bytes = 0, i = 0; count > 0; count--, p += word_step)
    {
      size_t j;
      for (j = 0; j < size; j++, p -= (ptrdiff_t) endian)
	{
	  limb |= (mp_limb_t) *p << (bytes++ * CHAR_BIT);
	  if (bytes == sizeof(mp_limb_t))
	    {
	      rp[i++] = limb;
	      bytes = 0;
	      limb = 0;
	    }
	}
    }
  assert (i + (bytes > 0) == rn);
  if (limb != 0)
    rp[i++] = limb;
  else
    i = mpn_normalized_size (rp, i);

  r->_mp_size = i;
}

void *
mpz_export (void *r, size_t *countp, int order, size_t size, int endian,
	    size_t nails, const mpz_t u)
{
  size_t count;
  mp_size_t un;

  if (nails != 0)
    gmp_die ("mpz_import: Nails not supported.");

  assert (order == 1 || order == -1);
  assert (endian >= -1 && endian <= 1);
  assert (size > 0 || u->_mp_size == 0);

  un = u->_mp_size;
  count = 0;
  if (un != 0)
    {
      size_t k;
      unsigned char *p;
      ptrdiff_t word_step;
      /* The current (partial) limb. */
      mp_limb_t limb;
      /* The number of bytes left to do in this limb. */
      size_t bytes;
      /* The index where the limb was read. */
      mp_size_t i;

      un = GMP_ABS (un);

      /* Count bytes in top limb. */
      limb = u->_mp_d[un-1];
      assert (limb != 0);

      k = (GMP_LIMB_BITS <= CHAR_BIT);
      if (!k)
	{
	  do {
	    int LOCAL_CHAR_BIT = CHAR_BIT;
	    k++; limb >>= LOCAL_CHAR_BIT;
	  } while (limb != 0);
	}
      /* else limb = 0; */

      count = (k + (un-1) * sizeof (mp_limb_t) + size - 1) / size;

      if (!r)
	r = gmp_xalloc (count * size);

      if (endian == 0)
	endian = gmp_detect_endian ();

      p = (unsigned char *) r;

      word_step = (order != endian) ? 2 * size : 0;

      /* Process bytes from the least significant end, so point p at the
	 least significant word. */
      if (order == 1)
	{
	  p += size * (count - 1);
	  word_step = - word_step;
	}

      /* And at least significant byte of that word. */
      if (endian == 1)
	p += (size - 1);

      for (bytes = 0, i = 0, k = 0; k < count; k++, p += word_step)
	{
	  size_t j;
	  for (j = 0; j < size; ++j, p -= (ptrdiff_t) endian)
	    {
	      if (sizeof (mp_limb_t) == 1)
		{
		  if (i < un)
		    *p = u->_mp_d[i++];
		  else
		    *p = 0;
		}
	      else
		{
		  int LOCAL_CHAR_BIT = CHAR_BIT;
		  if (bytes == 0)
		    {
		      if (i < un)
			limb = u->_mp_d[i++];
		      bytes = sizeof (mp_limb_t);
		    }
		  *p = limb;
		  limb >>= LOCAL_CHAR_BIT;
		  bytes--;
		}
	    }
	}
      assert (i == un);
      assert (k == count);
    }

  if (countp)
    *countp = count;

  return r;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/mini-gmp/mini-gmp.h0000644000175100001710000002643400000000000024563 0ustar00runnerdocker00000000000000/* mini-gmp, a minimalistic implementation of a GNU GMP subset.

Copyright 2011-2015, 2017, 2019-2020 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 2 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the GNU MP Library.  If not,
see https://www.gnu.org/licenses/.  */

/* About mini-gmp: This is a minimal implementation of a subset of the
   GMP interface. It is intended for inclusion into applications which
   have modest bignums needs, as a fallback when the real GMP library
   is not installed.

   This file defines the public interface. */

#ifndef __MINI_GMP_H__
#define __MINI_GMP_H__

/* For size_t */
#include 

#if defined (__cplusplus)
extern "C" {
#endif

void mp_set_memory_functions (void *(*) (size_t),
			      void *(*) (void *, size_t, size_t),
			      void (*) (void *, size_t));

void mp_get_memory_functions (void *(**) (size_t),
			      void *(**) (void *, size_t, size_t),
			      void (**) (void *, size_t));

#ifndef MINI_GMP_LIMB_TYPE
#define MINI_GMP_LIMB_TYPE long
#endif

typedef unsigned MINI_GMP_LIMB_TYPE mp_limb_t;
typedef long mp_size_t;
typedef unsigned long mp_bitcnt_t;

typedef mp_limb_t *mp_ptr;
typedef const mp_limb_t *mp_srcptr;

typedef struct
{
  int _mp_alloc;		/* Number of *limbs* allocated and pointed
				   to by the _mp_d field.  */
  int _mp_size;			/* abs(_mp_size) is the number of limbs the
				   last field points to.  If _mp_size is
				   negative this is a negative number.  */
  mp_limb_t *_mp_d;		/* Pointer to the limbs.  */
} __mpz_struct;

typedef __mpz_struct mpz_t[1];

typedef __mpz_struct *mpz_ptr;
typedef const __mpz_struct *mpz_srcptr;

extern const int mp_bits_per_limb;

void mpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void mpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
void mpn_zero (mp_ptr, mp_size_t);

int mpn_cmp (mp_srcptr, mp_srcptr, mp_size_t);
int mpn_zero_p (mp_srcptr, mp_size_t);

mp_limb_t mpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);

mp_limb_t mpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);

mp_limb_t mpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void mpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void mpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
int mpn_perfect_square_p (mp_srcptr, mp_size_t);
mp_size_t mpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);

mp_limb_t mpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t mpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);

mp_bitcnt_t mpn_scan0 (mp_srcptr, mp_bitcnt_t);
mp_bitcnt_t mpn_scan1 (mp_srcptr, mp_bitcnt_t);

void mpn_com (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_neg (mp_ptr, mp_srcptr, mp_size_t);

mp_bitcnt_t mpn_popcount (mp_srcptr, mp_size_t);

mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t);
#define mpn_invert_limb(x) mpn_invert_3by2 ((x), 0)

size_t mpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_size_t mpn_set_str (mp_ptr, const unsigned char *, size_t, int);

void mpz_init (mpz_t);
void mpz_init2 (mpz_t, mp_bitcnt_t);
void mpz_clear (mpz_t);

#define mpz_odd_p(z)   (((z)->_mp_size != 0) & (int) (z)->_mp_d[0])
#define mpz_even_p(z)  (! mpz_odd_p (z))

int mpz_sgn (const mpz_t);
int mpz_cmp_si (const mpz_t, long);
int mpz_cmp_ui (const mpz_t, unsigned long);
int mpz_cmp (const mpz_t, const mpz_t);
int mpz_cmpabs_ui (const mpz_t, unsigned long);
int mpz_cmpabs (const mpz_t, const mpz_t);
int mpz_cmp_d (const mpz_t, double);
int mpz_cmpabs_d (const mpz_t, double);

void mpz_abs (mpz_t, const mpz_t);
void mpz_neg (mpz_t, const mpz_t);
void mpz_swap (mpz_t, mpz_t);

void mpz_add_ui (mpz_t, const mpz_t, unsigned long);
void mpz_add (mpz_t, const mpz_t, const mpz_t);
void mpz_sub_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_sub (mpz_t, unsigned long, const mpz_t);
void mpz_sub (mpz_t, const mpz_t, const mpz_t);

void mpz_mul_si (mpz_t, const mpz_t, long int);
void mpz_mul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_mul (mpz_t, const mpz_t, const mpz_t);
void mpz_mul_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_addmul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_addmul (mpz_t, const mpz_t, const mpz_t);
void mpz_submul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_submul (mpz_t, const mpz_t, const mpz_t);

void mpz_cdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_r (mpz_t, const mpz_t, const mpz_t);

void mpz_cdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_cdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);

void mpz_mod (mpz_t, const mpz_t, const mpz_t);

void mpz_divexact (mpz_t, const mpz_t, const mpz_t);

int mpz_divisible_p (const mpz_t, const mpz_t);
int mpz_congruent_p (const mpz_t, const mpz_t, const mpz_t);

unsigned long mpz_cdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_fdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_tdiv_ui (const mpz_t, unsigned long);

unsigned long mpz_mod_ui (mpz_t, const mpz_t, unsigned long);

void mpz_divexact_ui (mpz_t, const mpz_t, unsigned long);

int mpz_divisible_ui_p (const mpz_t, unsigned long);

unsigned long mpz_gcd_ui (mpz_t, const mpz_t, unsigned long);
void mpz_gcd (mpz_t, const mpz_t, const mpz_t);
void mpz_gcdext (mpz_t, mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_lcm_ui (mpz_t, const mpz_t, unsigned long);
void mpz_lcm (mpz_t, const mpz_t, const mpz_t);
int mpz_invert (mpz_t, const mpz_t, const mpz_t);

void mpz_sqrtrem (mpz_t, mpz_t, const mpz_t);
void mpz_sqrt (mpz_t, const mpz_t);
int mpz_perfect_square_p (const mpz_t);

void mpz_pow_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_pow_ui (mpz_t, unsigned long, unsigned long);
void mpz_powm (mpz_t, const mpz_t, const mpz_t, const mpz_t);
void mpz_powm_ui (mpz_t, const mpz_t, unsigned long, const mpz_t);

void mpz_rootrem (mpz_t, mpz_t, const mpz_t, unsigned long);
int mpz_root (mpz_t, const mpz_t, unsigned long);

void mpz_fac_ui (mpz_t, unsigned long);
void mpz_2fac_ui (mpz_t, unsigned long);
void mpz_mfac_uiui (mpz_t, unsigned long, unsigned long);
void mpz_bin_uiui (mpz_t, unsigned long, unsigned long);

int mpz_probab_prime_p (const mpz_t, int);

int mpz_tstbit (const mpz_t, mp_bitcnt_t);
void mpz_setbit (mpz_t, mp_bitcnt_t);
void mpz_clrbit (mpz_t, mp_bitcnt_t);
void mpz_combit (mpz_t, mp_bitcnt_t);

void mpz_com (mpz_t, const mpz_t);
void mpz_and (mpz_t, const mpz_t, const mpz_t);
void mpz_ior (mpz_t, const mpz_t, const mpz_t);
void mpz_xor (mpz_t, const mpz_t, const mpz_t);

mp_bitcnt_t mpz_popcount (const mpz_t);
mp_bitcnt_t mpz_hamdist (const mpz_t, const mpz_t);
mp_bitcnt_t mpz_scan0 (const mpz_t, mp_bitcnt_t);
mp_bitcnt_t mpz_scan1 (const mpz_t, mp_bitcnt_t);

int mpz_fits_slong_p (const mpz_t);
int mpz_fits_ulong_p (const mpz_t);
long int mpz_get_si (const mpz_t);
unsigned long int mpz_get_ui (const mpz_t);
double mpz_get_d (const mpz_t);
size_t mpz_size (const mpz_t);
mp_limb_t mpz_getlimbn (const mpz_t, mp_size_t);

void mpz_realloc2 (mpz_t, mp_bitcnt_t);
mp_srcptr mpz_limbs_read (mpz_srcptr);
mp_ptr mpz_limbs_modify (mpz_t, mp_size_t);
mp_ptr mpz_limbs_write (mpz_t, mp_size_t);
void mpz_limbs_finish (mpz_t, mp_size_t);
mpz_srcptr mpz_roinit_n (mpz_t, mp_srcptr, mp_size_t);

#define MPZ_ROINIT_N(xp, xs) {{0, (xs),(xp) }}

void mpz_set_si (mpz_t, signed long int);
void mpz_set_ui (mpz_t, unsigned long int);
void mpz_set (mpz_t, const mpz_t);
void mpz_set_d (mpz_t, double);

void mpz_init_set_si (mpz_t, signed long int);
void mpz_init_set_ui (mpz_t, unsigned long int);
void mpz_init_set (mpz_t, const mpz_t);
void mpz_init_set_d (mpz_t, double);

size_t mpz_sizeinbase (const mpz_t, int);
char *mpz_get_str (char *, int, const mpz_t);
int mpz_set_str (mpz_t, const char *, int);
int mpz_init_set_str (mpz_t, const char *, int);

/* This long list taken from gmp.h. */
/* For reference, "defined(EOF)" cannot be used here.  In g++ 2.95.4,
    defines EOF but not FILE.  */
#if defined (FILE)                                              \
  || defined (H_STDIO)                                          \
  || defined (_H_STDIO)               /* AIX */                 \
  || defined (_STDIO_H)               /* glibc, Sun, SCO */     \
  || defined (_STDIO_H_)              /* BSD, OSF */            \
  || defined (__STDIO_H)              /* Borland */             \
  || defined (__STDIO_H__)            /* IRIX */                \
  || defined (_STDIO_INCLUDED)        /* HPUX */                \
  || defined (__dj_include_stdio_h_)  /* DJGPP */               \
  || defined (_FILE_DEFINED)          /* Microsoft */           \
  || defined (__STDIO__)              /* Apple MPW MrC */       \
  || defined (_MSL_STDIO_H)           /* Metrowerks */          \
  || defined (_STDIO_H_INCLUDED)      /* QNX4 */		\
  || defined (_ISO_STDIO_ISO_H)       /* Sun C++ */		\
  || defined (__STDIO_LOADED)         /* VMS */			\
  || defined (__DEFINED_FILE)         /* musl */
size_t mpz_out_str (FILE *, int, const mpz_t);
#endif

void mpz_import (mpz_t, size_t, int, size_t, int, size_t, const void *);
void *mpz_export (void *, size_t *, int, size_t, int, size_t, const mpz_t);

#if defined (__cplusplus)
}
#endif
#endif /* __MINI_GMP_H__ */
././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1641822589.7151437
igraph-0.9.9/vendor/source/igraph/vendor/plfit/0000755000175100001710000000000000000000000022265 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/CMakeLists.txt0000644000175100001710000000170200000000000025025 0ustar00runnerdocker00000000000000# Declare the files needed to compile our vendored plfit copy
add_library(
  plfit_vendored
  OBJECT
  EXCLUDE_FROM_ALL
  gss.c
  hzeta.c
  kolmogorov.c
  lbfgs.c
  mt.c
  options.c
  platform.c
  plfit.c
  plfit_error.c
  rbinom.c
  sampling.c
)

target_include_directories(
  plfit_vendored
  PRIVATE
  ${PROJECT_SOURCE_DIR}/include
  ${PROJECT_BINARY_DIR}/include
  PUBLIC
  ${CMAKE_CURRENT_SOURCE_DIR}
)

if (BUILD_SHARED_LIBS)
  set_property(TARGET plfit_vendored PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()

# Since these are included as object files, they should call the
# function as is (without visibility specification)
target_compile_definitions(plfit_vendored PRIVATE IGRAPH_STATIC)

use_all_warnings(plfit_vendored)

if (MSVC)
  target_compile_options(
    plfit_vendored PRIVATE
    /wd4100
  ) # disable unreferenced parameter warning
endif()

if(IGRAPH_OPENMP_SUPPORT)
  target_link_libraries(plfit_vendored PRIVATE OpenMP::OpenMP_C)
endif()
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/arithmetic_ansi.h0000644000175100001710000000654700000000000025615 0ustar00runnerdocker00000000000000/*
 *      ANSI C implementation of vector operations.
 *
 * Copyright (c) 2007-2010 Naoaki Okazaki
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* $Id: arithmetic_ansi.h 65 2010-01-29 12:19:16Z naoaki $ */

#include 
#include 

#if     LBFGS_FLOAT == 32 && LBFGS_IEEE_FLOAT
#define fsigndiff(x, y) (((*(uint32_t*)(x)) ^ (*(uint32_t*)(y))) & 0x80000000U)
#else
#define fsigndiff(x, y) (*(x) * (*(y) / fabs(*(y))) < 0.)
#endif/*LBFGS_IEEE_FLOAT*/

inline static void* vecalloc(size_t size)
{
    void *memblock = malloc(size);
    if (memblock) {
        memset(memblock, 0, size);
    }
    return memblock;
}

inline static void vecfree(void *memblock)
{
    free(memblock);
}

inline static void vecset(lbfgsfloatval_t *x, const lbfgsfloatval_t c, const int n)
{
    int i;
    
    for (i = 0;i < n;++i) {
        x[i] = c;
    }
}

inline static void veccpy(lbfgsfloatval_t *y, const lbfgsfloatval_t *x, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        y[i] = x[i];
    }
}

inline static void vecncpy(lbfgsfloatval_t *y, const lbfgsfloatval_t *x, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        y[i] = -x[i];
    }
}

inline static void vecadd(lbfgsfloatval_t *y, const lbfgsfloatval_t *x, const lbfgsfloatval_t c, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        y[i] += c * x[i];
    }
}

inline static void vecdiff(lbfgsfloatval_t *z, const lbfgsfloatval_t *x, const lbfgsfloatval_t *y, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        z[i] = x[i] - y[i];
    }
}

inline static void vecscale(lbfgsfloatval_t *y, const lbfgsfloatval_t c, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        y[i] *= c;
    }
}

inline static void vecmul(lbfgsfloatval_t *y, const lbfgsfloatval_t *x, const int n)
{
    int i;

    for (i = 0;i < n;++i) {
        y[i] *= x[i];
    }
}

inline static void vecdot(lbfgsfloatval_t* s, const lbfgsfloatval_t *x, const lbfgsfloatval_t *y, const int n)
{
    int i;
    *s = 0.;
    for (i = 0;i < n;++i) {
        *s += x[i] * y[i];
    }
}

inline static void vec2norm(lbfgsfloatval_t* s, const lbfgsfloatval_t *x, const int n)
{
    vecdot(s, x, x, n);
    *s = (lbfgsfloatval_t)sqrt(*s);
}

inline static void vec2norminv(lbfgsfloatval_t* s, const lbfgsfloatval_t *x, const int n)
{
    vec2norm(s, x, n);
    *s = (lbfgsfloatval_t)(1.0 / *s);
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/arithmetic_sse_double.h0000644000175100001710000002113600000000000026776 0ustar00runnerdocker00000000000000/*
 *      SSE2 implementation of vector oprations (64bit double).
 *
 * Copyright (c) 2007-2010 Naoaki Okazaki
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* $Id: arithmetic_sse_double.h 65 2010-01-29 12:19:16Z naoaki $ */

#include 

#if !defined(__APPLE__)
#include 
#endif

#include 

#if     1400 <= _MSC_VER
#include 
#endif/*1400 <= _MSC_VER*/

#if     HAVE_EMMINTRIN_H
#include 
#endif/*HAVE_EMMINTRIN_H*/

inline static void* vecalloc(size_t size)
{
#ifdef	_MSC_VER
    void *memblock = _aligned_malloc(size, 16);
#elif defined(__APPLE__)
	/* Memory on Mac OS X is already aligned to 16 bytes */
	void *memblock = malloc(size);
#else
    void *memblock = memalign(16, size);
#endif
    if (memblock != NULL) {
        memset(memblock, 0, size);
    }
    return memblock;
}

inline static void vecfree(void *memblock)
{
#ifdef	_MSC_VER
    _aligned_free(memblock);
#else
    free(memblock);
#endif
}

#define fsigndiff(x, y) \
    ((_mm_movemask_pd(_mm_set_pd(*(x), *(y))) + 1) & 0x002)

#define vecset(x, c, n) \
{ \
    int i; \
    __m128d XMM0 = _mm_set1_pd(c); \
    for (i = 0;i < (n);i += 8) { \
        _mm_store_pd((x)+i  , XMM0); \
        _mm_store_pd((x)+i+2, XMM0); \
        _mm_store_pd((x)+i+4, XMM0); \
        _mm_store_pd((x)+i+6, XMM0); \
    } \
}

#define veccpy(y, x, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 8) { \
        __m128d XMM0 = _mm_load_pd((x)+i  ); \
        __m128d XMM1 = _mm_load_pd((x)+i+2); \
        __m128d XMM2 = _mm_load_pd((x)+i+4); \
        __m128d XMM3 = _mm_load_pd((x)+i+6); \
        _mm_store_pd((y)+i  , XMM0); \
        _mm_store_pd((y)+i+2, XMM1); \
        _mm_store_pd((y)+i+4, XMM2); \
        _mm_store_pd((y)+i+6, XMM3); \
    } \
}

#define vecncpy(y, x, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 8) { \
        __m128d XMM0 = _mm_setzero_pd(); \
        __m128d XMM1 = _mm_setzero_pd(); \
        __m128d XMM2 = _mm_setzero_pd(); \
        __m128d XMM3 = _mm_setzero_pd(); \
        __m128d XMM4 = _mm_load_pd((x)+i  ); \
        __m128d XMM5 = _mm_load_pd((x)+i+2); \
        __m128d XMM6 = _mm_load_pd((x)+i+4); \
        __m128d XMM7 = _mm_load_pd((x)+i+6); \
        XMM0 = _mm_sub_pd(XMM0, XMM4); \
        XMM1 = _mm_sub_pd(XMM1, XMM5); \
        XMM2 = _mm_sub_pd(XMM2, XMM6); \
        XMM3 = _mm_sub_pd(XMM3, XMM7); \
        _mm_store_pd((y)+i  , XMM0); \
        _mm_store_pd((y)+i+2, XMM1); \
        _mm_store_pd((y)+i+4, XMM2); \
        _mm_store_pd((y)+i+6, XMM3); \
    } \
}

#define vecadd(y, x, c, n) \
{ \
    int i; \
    __m128d XMM7 = _mm_set1_pd(c); \
    for (i = 0;i < (n);i += 4) { \
        __m128d XMM0 = _mm_load_pd((x)+i  ); \
        __m128d XMM1 = _mm_load_pd((x)+i+2); \
        __m128d XMM2 = _mm_load_pd((y)+i  ); \
        __m128d XMM3 = _mm_load_pd((y)+i+2); \
        XMM0 = _mm_mul_pd(XMM0, XMM7); \
        XMM1 = _mm_mul_pd(XMM1, XMM7); \
        XMM2 = _mm_add_pd(XMM2, XMM0); \
        XMM3 = _mm_add_pd(XMM3, XMM1); \
        _mm_store_pd((y)+i  , XMM2); \
        _mm_store_pd((y)+i+2, XMM3); \
    } \
}

#define vecdiff(z, x, y, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 8) { \
        __m128d XMM0 = _mm_load_pd((x)+i  ); \
        __m128d XMM1 = _mm_load_pd((x)+i+2); \
        __m128d XMM2 = _mm_load_pd((x)+i+4); \
        __m128d XMM3 = _mm_load_pd((x)+i+6); \
        __m128d XMM4 = _mm_load_pd((y)+i  ); \
        __m128d XMM5 = _mm_load_pd((y)+i+2); \
        __m128d XMM6 = _mm_load_pd((y)+i+4); \
        __m128d XMM7 = _mm_load_pd((y)+i+6); \
        XMM0 = _mm_sub_pd(XMM0, XMM4); \
        XMM1 = _mm_sub_pd(XMM1, XMM5); \
        XMM2 = _mm_sub_pd(XMM2, XMM6); \
        XMM3 = _mm_sub_pd(XMM3, XMM7); \
        _mm_store_pd((z)+i  , XMM0); \
        _mm_store_pd((z)+i+2, XMM1); \
        _mm_store_pd((z)+i+4, XMM2); \
        _mm_store_pd((z)+i+6, XMM3); \
    } \
}

#define vecscale(y, c, n) \
{ \
    int i; \
    __m128d XMM7 = _mm_set1_pd(c); \
    for (i = 0;i < (n);i += 4) { \
        __m128d XMM0 = _mm_load_pd((y)+i  ); \
        __m128d XMM1 = _mm_load_pd((y)+i+2); \
        XMM0 = _mm_mul_pd(XMM0, XMM7); \
        XMM1 = _mm_mul_pd(XMM1, XMM7); \
        _mm_store_pd((y)+i  , XMM0); \
        _mm_store_pd((y)+i+2, XMM1); \
    } \
}

#define vecmul(y, x, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 8) { \
        __m128d XMM0 = _mm_load_pd((x)+i  ); \
        __m128d XMM1 = _mm_load_pd((x)+i+2); \
        __m128d XMM2 = _mm_load_pd((x)+i+4); \
        __m128d XMM3 = _mm_load_pd((x)+i+6); \
        __m128d XMM4 = _mm_load_pd((y)+i  ); \
        __m128d XMM5 = _mm_load_pd((y)+i+2); \
        __m128d XMM6 = _mm_load_pd((y)+i+4); \
        __m128d XMM7 = _mm_load_pd((y)+i+6); \
        XMM4 = _mm_mul_pd(XMM4, XMM0); \
        XMM5 = _mm_mul_pd(XMM5, XMM1); \
        XMM6 = _mm_mul_pd(XMM6, XMM2); \
        XMM7 = _mm_mul_pd(XMM7, XMM3); \
        _mm_store_pd((y)+i  , XMM4); \
        _mm_store_pd((y)+i+2, XMM5); \
        _mm_store_pd((y)+i+4, XMM6); \
        _mm_store_pd((y)+i+6, XMM7); \
    } \
}



#if     3 <= __SSE__
/*
    Horizontal add with haddps SSE3 instruction. The work register (rw)
    is unused.
 */
#define __horizontal_sum(r, rw) \
    r = _mm_hadd_ps(r, r); \
    r = _mm_hadd_ps(r, r);

#else
/*
    Horizontal add with SSE instruction. The work register (rw) is used.
 */
#define __horizontal_sum(r, rw) \
    rw = r; \
    r = _mm_shuffle_ps(r, rw, _MM_SHUFFLE(1, 0, 3, 2)); \
    r = _mm_add_ps(r, rw); \
    rw = r; \
    r = _mm_shuffle_ps(r, rw, _MM_SHUFFLE(2, 3, 0, 1)); \
    r = _mm_add_ps(r, rw);

#endif

#define vecdot(s, x, y, n) \
{ \
    int i; \
    __m128d XMM0 = _mm_setzero_pd(); \
    __m128d XMM1 = _mm_setzero_pd(); \
    __m128d XMM2, XMM3, XMM4, XMM5; \
    for (i = 0;i < (n);i += 4) { \
        XMM2 = _mm_load_pd((x)+i  ); \
        XMM3 = _mm_load_pd((x)+i+2); \
        XMM4 = _mm_load_pd((y)+i  ); \
        XMM5 = _mm_load_pd((y)+i+2); \
        XMM2 = _mm_mul_pd(XMM2, XMM4); \
        XMM3 = _mm_mul_pd(XMM3, XMM5); \
        XMM0 = _mm_add_pd(XMM0, XMM2); \
        XMM1 = _mm_add_pd(XMM1, XMM3); \
    } \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    XMM1 = _mm_shuffle_pd(XMM0, XMM0, _MM_SHUFFLE2(1, 1)); \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    _mm_store_sd((s), XMM0); \
}

#define vec2norm(s, x, n) \
{ \
    int i; \
    __m128d XMM0 = _mm_setzero_pd(); \
    __m128d XMM1 = _mm_setzero_pd(); \
    __m128d XMM2, XMM3, XMM4, XMM5; \
    for (i = 0;i < (n);i += 4) { \
        XMM2 = _mm_load_pd((x)+i  ); \
        XMM3 = _mm_load_pd((x)+i+2); \
        XMM4 = XMM2; \
        XMM5 = XMM3; \
        XMM2 = _mm_mul_pd(XMM2, XMM4); \
        XMM3 = _mm_mul_pd(XMM3, XMM5); \
        XMM0 = _mm_add_pd(XMM0, XMM2); \
        XMM1 = _mm_add_pd(XMM1, XMM3); \
    } \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    XMM1 = _mm_shuffle_pd(XMM0, XMM0, _MM_SHUFFLE2(1, 1)); \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    XMM0 = _mm_sqrt_pd(XMM0); \
    _mm_store_sd((s), XMM0); \
}


#define vec2norminv(s, x, n) \
{ \
    int i; \
    __m128d XMM0 = _mm_setzero_pd(); \
    __m128d XMM1 = _mm_setzero_pd(); \
    __m128d XMM2, XMM3, XMM4, XMM5; \
    for (i = 0;i < (n);i += 4) { \
        XMM2 = _mm_load_pd((x)+i  ); \
        XMM3 = _mm_load_pd((x)+i+2); \
        XMM4 = XMM2; \
        XMM5 = XMM3; \
        XMM2 = _mm_mul_pd(XMM2, XMM4); \
        XMM3 = _mm_mul_pd(XMM3, XMM5); \
        XMM0 = _mm_add_pd(XMM0, XMM2); \
        XMM1 = _mm_add_pd(XMM1, XMM3); \
    } \
    XMM2 = _mm_set1_pd(1.0); \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    XMM1 = _mm_shuffle_pd(XMM0, XMM0, _MM_SHUFFLE2(1, 1)); \
    XMM0 = _mm_add_pd(XMM0, XMM1); \
    XMM0 = _mm_sqrt_pd(XMM0); \
    XMM2 = _mm_div_pd(XMM2, XMM0); \
    _mm_store_sd((s), XMM2); \
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/arithmetic_sse_float.h0000644000175100001710000002122500000000000026630 0ustar00runnerdocker00000000000000/*
 *      SSE/SSE3 implementation of vector oprations (32bit float).
 *
 * Copyright (c) 2007-2010 Naoaki Okazaki
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* $Id: arithmetic_sse_float.h 65 2010-01-29 12:19:16Z naoaki $ */

#include 

#if !defined(__APPLE__)
#include 
#endif

#include 

#if     1400 <= _MSC_VER
#include 
#endif/*_MSC_VER*/

#if     HAVE_XMMINTRIN_H
#include 
#endif/*HAVE_XMMINTRIN_H*/

#if     LBFGS_FLOAT == 32 && LBFGS_IEEE_FLOAT
#define fsigndiff(x, y) (((*(uint32_t*)(x)) ^ (*(uint32_t*)(y))) & 0x80000000U)
#else
#define fsigndiff(x, y) (*(x) * (*(y) / fabs(*(y))) < 0.)
#endif/*LBFGS_IEEE_FLOAT*/

inline static void* vecalloc(size_t size)
{
    void *memblock = _aligned_malloc(size, 16);
    if (memblock != NULL) {
        memset(memblock, 0, size);
    }
    return memblock;
}

inline static void vecfree(void *memblock)
{
    _aligned_free(memblock);
}

#define vecset(x, c, n) \
{ \
    int i; \
    __m128 XMM0 = _mm_set_ps1(c); \
    for (i = 0;i < (n);i += 16) { \
        _mm_store_ps((x)+i   , XMM0); \
        _mm_store_ps((x)+i+ 4, XMM0); \
        _mm_store_ps((x)+i+ 8, XMM0); \
        _mm_store_ps((x)+i+12, XMM0); \
    } \
}

#define veccpy(y, x, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 16) { \
        __m128 XMM0 = _mm_load_ps((x)+i   ); \
        __m128 XMM1 = _mm_load_ps((x)+i+ 4); \
        __m128 XMM2 = _mm_load_ps((x)+i+ 8); \
        __m128 XMM3 = _mm_load_ps((x)+i+12); \
        _mm_store_ps((y)+i   , XMM0); \
        _mm_store_ps((y)+i+ 4, XMM1); \
        _mm_store_ps((y)+i+ 8, XMM2); \
        _mm_store_ps((y)+i+12, XMM3); \
    } \
}

#define vecncpy(y, x, n) \
{ \
    int i; \
    const uint32_t mask = 0x80000000; \
    __m128 XMM4 = _mm_load_ps1((float*)&mask); \
    for (i = 0;i < (n);i += 16) { \
        __m128 XMM0 = _mm_load_ps((x)+i   ); \
        __m128 XMM1 = _mm_load_ps((x)+i+ 4); \
        __m128 XMM2 = _mm_load_ps((x)+i+ 8); \
        __m128 XMM3 = _mm_load_ps((x)+i+12); \
        XMM0 = _mm_xor_ps(XMM0, XMM4); \
        XMM1 = _mm_xor_ps(XMM1, XMM4); \
        XMM2 = _mm_xor_ps(XMM2, XMM4); \
        XMM3 = _mm_xor_ps(XMM3, XMM4); \
        _mm_store_ps((y)+i   , XMM0); \
        _mm_store_ps((y)+i+ 4, XMM1); \
        _mm_store_ps((y)+i+ 8, XMM2); \
        _mm_store_ps((y)+i+12, XMM3); \
    } \
}

#define vecadd(y, x, c, n) \
{ \
    int i; \
    __m128 XMM7 = _mm_set_ps1(c); \
    for (i = 0;i < (n);i += 8) { \
        __m128 XMM0 = _mm_load_ps((x)+i  ); \
        __m128 XMM1 = _mm_load_ps((x)+i+4); \
        __m128 XMM2 = _mm_load_ps((y)+i  ); \
        __m128 XMM3 = _mm_load_ps((y)+i+4); \
        XMM0 = _mm_mul_ps(XMM0, XMM7); \
        XMM1 = _mm_mul_ps(XMM1, XMM7); \
        XMM2 = _mm_add_ps(XMM2, XMM0); \
        XMM3 = _mm_add_ps(XMM3, XMM1); \
        _mm_store_ps((y)+i  , XMM2); \
        _mm_store_ps((y)+i+4, XMM3); \
    } \
}

#define vecdiff(z, x, y, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 16) { \
        __m128 XMM0 = _mm_load_ps((x)+i   ); \
        __m128 XMM1 = _mm_load_ps((x)+i+ 4); \
        __m128 XMM2 = _mm_load_ps((x)+i+ 8); \
        __m128 XMM3 = _mm_load_ps((x)+i+12); \
        __m128 XMM4 = _mm_load_ps((y)+i   ); \
        __m128 XMM5 = _mm_load_ps((y)+i+ 4); \
        __m128 XMM6 = _mm_load_ps((y)+i+ 8); \
        __m128 XMM7 = _mm_load_ps((y)+i+12); \
        XMM0 = _mm_sub_ps(XMM0, XMM4); \
        XMM1 = _mm_sub_ps(XMM1, XMM5); \
        XMM2 = _mm_sub_ps(XMM2, XMM6); \
        XMM3 = _mm_sub_ps(XMM3, XMM7); \
        _mm_store_ps((z)+i   , XMM0); \
        _mm_store_ps((z)+i+ 4, XMM1); \
        _mm_store_ps((z)+i+ 8, XMM2); \
        _mm_store_ps((z)+i+12, XMM3); \
    } \
}

#define vecscale(y, c, n) \
{ \
    int i; \
    __m128 XMM7 = _mm_set_ps1(c); \
    for (i = 0;i < (n);i += 8) { \
        __m128 XMM0 = _mm_load_ps((y)+i  ); \
        __m128 XMM1 = _mm_load_ps((y)+i+4); \
        XMM0 = _mm_mul_ps(XMM0, XMM7); \
        XMM1 = _mm_mul_ps(XMM1, XMM7); \
        _mm_store_ps((y)+i  , XMM0); \
        _mm_store_ps((y)+i+4, XMM1); \
    } \
}

#define vecmul(y, x, n) \
{ \
    int i; \
    for (i = 0;i < (n);i += 16) { \
        __m128 XMM0 = _mm_load_ps((x)+i   ); \
        __m128 XMM1 = _mm_load_ps((x)+i+ 4); \
        __m128 XMM2 = _mm_load_ps((x)+i+ 8); \
        __m128 XMM3 = _mm_load_ps((x)+i+12); \
        __m128 XMM4 = _mm_load_ps((y)+i   ); \
        __m128 XMM5 = _mm_load_ps((y)+i+ 4); \
        __m128 XMM6 = _mm_load_ps((y)+i+ 8); \
        __m128 XMM7 = _mm_load_ps((y)+i+12); \
        XMM4 = _mm_mul_ps(XMM4, XMM0); \
        XMM5 = _mm_mul_ps(XMM5, XMM1); \
        XMM6 = _mm_mul_ps(XMM6, XMM2); \
        XMM7 = _mm_mul_ps(XMM7, XMM3); \
        _mm_store_ps((y)+i   , XMM4); \
        _mm_store_ps((y)+i+ 4, XMM5); \
        _mm_store_ps((y)+i+ 8, XMM6); \
        _mm_store_ps((y)+i+12, XMM7); \
    } \
}



#if     3 <= __SSE__
/*
    Horizontal add with haddps SSE3 instruction. The work register (rw)
    is unused.
 */
#define __horizontal_sum(r, rw) \
    r = _mm_hadd_ps(r, r); \
    r = _mm_hadd_ps(r, r);

#else
/*
    Horizontal add with SSE instruction. The work register (rw) is used.
 */
#define __horizontal_sum(r, rw) \
    rw = r; \
    r = _mm_shuffle_ps(r, rw, _MM_SHUFFLE(1, 0, 3, 2)); \
    r = _mm_add_ps(r, rw); \
    rw = r; \
    r = _mm_shuffle_ps(r, rw, _MM_SHUFFLE(2, 3, 0, 1)); \
    r = _mm_add_ps(r, rw);

#endif

#define vecdot(s, x, y, n) \
{ \
    int i; \
    __m128 XMM0 = _mm_setzero_ps(); \
    __m128 XMM1 = _mm_setzero_ps(); \
    __m128 XMM2, XMM3, XMM4, XMM5; \
    for (i = 0;i < (n);i += 8) { \
        XMM2 = _mm_load_ps((x)+i  ); \
        XMM3 = _mm_load_ps((x)+i+4); \
        XMM4 = _mm_load_ps((y)+i  ); \
        XMM5 = _mm_load_ps((y)+i+4); \
        XMM2 = _mm_mul_ps(XMM2, XMM4); \
        XMM3 = _mm_mul_ps(XMM3, XMM5); \
        XMM0 = _mm_add_ps(XMM0, XMM2); \
        XMM1 = _mm_add_ps(XMM1, XMM3); \
    } \
    XMM0 = _mm_add_ps(XMM0, XMM1); \
    __horizontal_sum(XMM0, XMM1); \
    _mm_store_ss((s), XMM0); \
}

#define vec2norm(s, x, n) \
{ \
    int i; \
    __m128 XMM0 = _mm_setzero_ps(); \
    __m128 XMM1 = _mm_setzero_ps(); \
    __m128 XMM2, XMM3; \
    for (i = 0;i < (n);i += 8) { \
        XMM2 = _mm_load_ps((x)+i  ); \
        XMM3 = _mm_load_ps((x)+i+4); \
        XMM2 = _mm_mul_ps(XMM2, XMM2); \
        XMM3 = _mm_mul_ps(XMM3, XMM3); \
        XMM0 = _mm_add_ps(XMM0, XMM2); \
        XMM1 = _mm_add_ps(XMM1, XMM3); \
    } \
    XMM0 = _mm_add_ps(XMM0, XMM1); \
    __horizontal_sum(XMM0, XMM1); \
    XMM2 = XMM0; \
    XMM1 = _mm_rsqrt_ss(XMM0); \
    XMM3 = XMM1; \
    XMM1 = _mm_mul_ss(XMM1, XMM1); \
    XMM1 = _mm_mul_ss(XMM1, XMM3); \
    XMM1 = _mm_mul_ss(XMM1, XMM0); \
    XMM1 = _mm_mul_ss(XMM1, _mm_set_ss(-0.5f)); \
    XMM3 = _mm_mul_ss(XMM3, _mm_set_ss(1.5f)); \
    XMM3 = _mm_add_ss(XMM3, XMM1); \
    XMM3 = _mm_mul_ss(XMM3, XMM2); \
    _mm_store_ss((s), XMM3); \
}

#define vec2norminv(s, x, n) \
{ \
    int i; \
    __m128 XMM0 = _mm_setzero_ps(); \
    __m128 XMM1 = _mm_setzero_ps(); \
    __m128 XMM2, XMM3; \
    for (i = 0;i < (n);i += 16) { \
        XMM2 = _mm_load_ps((x)+i  ); \
        XMM3 = _mm_load_ps((x)+i+4); \
        XMM2 = _mm_mul_ps(XMM2, XMM2); \
        XMM3 = _mm_mul_ps(XMM3, XMM3); \
        XMM0 = _mm_add_ps(XMM0, XMM2); \
        XMM1 = _mm_add_ps(XMM1, XMM3); \
    } \
    XMM0 = _mm_add_ps(XMM0, XMM1); \
    __horizontal_sum(XMM0, XMM1); \
    XMM2 = XMM0; \
    XMM1 = _mm_rsqrt_ss(XMM0); \
    XMM3 = XMM1; \
    XMM1 = _mm_mul_ss(XMM1, XMM1); \
    XMM1 = _mm_mul_ss(XMM1, XMM3); \
    XMM1 = _mm_mul_ss(XMM1, XMM0); \
    XMM1 = _mm_mul_ss(XMM1, _mm_set_ss(-0.5f)); \
    XMM3 = _mm_mul_ss(XMM3, _mm_set_ss(1.5f)); \
    XMM3 = _mm_add_ss(XMM3, XMM1); \
    _mm_store_ss((s), XMM3); \
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/gss.c0000644000175100001710000000662200000000000023233 0ustar00runnerdocker00000000000000/* gss.c
 *
 * Copyright (C) 2012 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include 
#include 
#include 
#include "plfit_error.h"
#include "gss.h"
#include "platform.h"

/**
 * \def PHI
 *
 * The golden ratio, i.e. 1+sqrt(5)/2
 */
#define PHI 1.618033988749895

/**
 * \def RESPHI
 *
 * Constant defined as 2 - \c PHI
 */
#define RESPHI 0.3819660112501051

/**
 * \const _defparam
 *
 * Default parameters for the GSS algorithm.
 */
static const gss_parameter_t _defparam = {
    /* .epsilon = */  DBL_MIN,
	/* .on_error = */ GSS_ERROR_STOP
};

/**
 * Stores whether the last optimization run triggered a warning or not.
 */
static unsigned short int gss_i_warning_flag = 0;

void gss_parameter_init(gss_parameter_t *param) {
    memcpy(param, &_defparam, sizeof(*param));
}

unsigned short int gss_get_warning_flag() {
	return gss_i_warning_flag;
}

#define TERMINATE {        \
    if (_min) {            \
        *(_min) = min;     \
    }                      \
    if (_fmin) {           \
        *(_fmin) = fmin;   \
    }                      \
}

#define EVALUATE(x, fx) { \
    fx = proc_evaluate(instance, x); \
    if (fmin > fx) { \
        min = x;     \
        fmin = fx;   \
    } \
    if (proc_progress) { \
        retval = proc_progress(instance, x, fx, min, fmin, \
                (a < b) ? a : b, (a < b) ? b : a, k); \
        if (retval) { \
			TERMINATE;            \
            return PLFIT_SUCCESS; \
        } \
    } \
}

int gss(double a, double b, double *_min, double *_fmin,
        gss_evaluate_t proc_evaluate, gss_progress_t proc_progress,
        void* instance, const gss_parameter_t *_param) {
    double c, d, min;
    double fa, fb, fc, fd, fmin;
    int k = 0;
    int retval;
    unsigned short int successful = 1;

    gss_parameter_t param = _param ? (*_param) : _defparam;

	gss_i_warning_flag = 0;

    if (a > b) {
        c = a; a = b; b = c;
    }

    min = a;
    fmin = proc_evaluate(instance, a);

    c = a + RESPHI*(b-a);

    EVALUATE(a, fa);
    EVALUATE(b, fb);
    EVALUATE(c, fc);

    if (fc >= fa || fc >= fb) {
		if (param.on_error == GSS_ERROR_STOP) {
			return PLFIT_FAILURE;
		} else {
			gss_i_warning_flag = 1;
		}
	}

    while (fabs(a-b) > param.epsilon) {
        k++;

        d = c + RESPHI*(b-c);
        EVALUATE(d, fd);

        if (fd >= fa || fd >= fb) {
			if (param.on_error == GSS_ERROR_STOP) {
				successful = 0;
				break;
			} else {
				gss_i_warning_flag = 1;
			}
        }

        if (fc <= fd) {
            b = a; a = d;
        } else {
            a = c; c = d; fc = fd;
        }
    }

    if (successful) {
        c = (a+b) / 2.0;
        k++;
        EVALUATE(c, fc);
		TERMINATE;
    }

    return successful ? PLFIT_SUCCESS : PLFIT_FAILURE;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/gss.h0000644000175100001710000001365400000000000023243 0ustar00runnerdocker00000000000000/* gss.h
 *
 * Copyright (C) 2012 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __GSS_H__
#define __GSS_H__

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

/**
 * Enum specifying what the search should do when the function is not U-shaped.
 */
typedef enum {
	GSS_ERROR_STOP,              /**< Stop and return an error code */
	GSS_ERROR_WARN               /**< Continue and set the warning flag */
} gss_error_handling_t;

/**
 * Parameter settings for a golden section search.
 */
typedef struct {
    double epsilon;
	gss_error_handling_t on_error;
} gss_parameter_t;

/**
 * Callback interface to provide objective function evaluations for the golden
 * section search.
 *
 * The gss() function calls this function to obtain the values of the objective
 * function when needed. A client program must implement this function to evaluate
 * the value of the objective function, given the location.
 *
 * @param  instance    The user data sent for the gss() function by the client.
 * @param  x           The current value of the variable.
 * @retval double      The value of the objective function for the current
 *                      variable.
 */
typedef double (*gss_evaluate_t)(void *instance, double x);

/**
 * Callback interface to receive the progress of the optimization process for
 * the golden section search.
 *
 * The gss() function calls this function for each iteration. Implementing
 * this function, a client program can store or display the current progress
 * of the optimization process.
 *
 * @param  instance    The user data sent for the gss() function by the client.
 * @param  x           The current value of the variable.
 * @param  fx          The value of the objective function at x.
 * @param  min         The location of the minimum value of the objective
 *                     function found so far.
 * @param  fmin        The minimum value of the objective function found so far.
 * @param  left        The left side of the current bracket.
 * @param  right       The right side of the current bracket.
 * @param  k           The index of the current iteration.
 * @retval int         Zero to continue the optimization process. Returning a
 *                     non-zero value will cancel the optimization process.
 */
typedef int (*gss_progress_t)(void *instance, double x, double fx, double min,
        double fmin, double left, double right, int k);

/**
 * Start a golden section search optimization.
 *
 * @param  a    The left side of the bracket to start from
 * @param  b    The right side of the bracket to start from
 * @param  min  The pointer to the variable that receives the location of the
 *              final value of the objective function. This argument can be set to
 *              \c NULL if the location of the final value of the objective
 *              function is unnecessary.
 * @param  fmin The pointer to the variable that receives the final value of
 *              the objective function. This argument can be st to \c NULL if the
 *              final value of the objective function is unnecessary.
 * @param  proc_evaluate  The callback function to evaluate the objective
 *                        function at a given location.
 * @param  proc_progress  The callback function to receive the progress (the
 *                        last evaluated location, the value of the objective
 *                        function at that location, the width of the current
 *                        bracket, the minimum found so far and the step
 *                        count). This argument can be set to \c NULL if
 *                        a progress report is unnecessary.
 * @param  instance    A user data for the client program. The callback
 *                     functions will receive the value of this argument.
 * @param  param       The pointer to a structure representing parameters for
 *                     GSS algorithm. A client program can set this parameter
 *                     to \c NULL to use the default parameters.
 *                     Call the \ref gss_parameter_init() function to fill a
 *                     structure with the default values.
 * @retval int         The status code. This function returns zero if the
 *                     minimization process terminates without an error. A
 *                     non-zero value indicates an error; in particular,
 *                     \c PLFIT_FAILURE means that the function is not
 *                     U-shaped.
 */
int gss(double a, double b, double *min, double *fmin,
        gss_evaluate_t proc_evaluate, gss_progress_t proc_progress,
        void* instance, const gss_parameter_t *_param);

/**
 * Return the state of the warning flag.
 *
 * The warning flag is 1 if the last optimization was run on a function that
 * was not U-shaped.
 */
unsigned short int gss_get_warning_flag();

/**
 * Initialize GSS parameters to the default values.
 *
 * Call this function to fill a parameter structure with the default values
 * and overwrite parameter values if necessary.
 *
 * @param  param       The pointer to the parameter structure.
 */
void gss_parameter_init(gss_parameter_t *param);

__END_DECLS

#endif /* __GSS_H__ */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/hzeta.c0000644000175100001710000005215600000000000023555 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=2 sts=2 et: */

/* This file was imported from a private scientific library
 * based on GSL coined Home Scientific Libray (HSL) by its author
 * Jerome Benoit; this very material is itself inspired from the
 * material written by G. Jungan and distributed by GSL.
 * Ultimately, some modifications were done in order to render the
 * imported material independent from the rest of GSL.
 */

/* `hsl/specfunc/hzeta.c' C source file
// HSL - Home Scientific Library
// Copyright (C) 2017-2018  Jerome Benoit
//
// HSL is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

/*
// The material in this file is mainly inspired by the material written by
// G. Jungan and distributed under GPLv2 by the GNU Scientific Library (GSL)
// ( https://www.gnu.org/software/gsl/ [specfunc/zeta.c]), itself inspired by
// the material written by Moshier and distributed in the Cephes Mathematical
// Library ( http://www.moshier.net/ [zeta.c]).
//
// More specifically, hsl_sf_hzeta_e is a slightly modifed clone of
// gsl_sf_hzeta_e as found in GSL 2.4; the remaining is `inspired by'.
// [Sooner or later a _Working_Note_ may be deposited at ResearchGate
// ( https://www.researchgate.net/profile/Jerome_Benoit )]
*/

/* Author:  Jerome G. Benoit < jgmbenoit _at_ rezozer _dot_ net > */

#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif

#include 
#include 
#include "hzeta.h"
#include "plfit_error.h"
#include "platform.h"   /* because of NAN */

/* imported from gsl_machine.h */

#define GSL_LOG_DBL_MIN (-7.0839641853226408e+02)
#define GSL_LOG_DBL_MAX 7.0978271289338397e+02
#define GSL_DBL_EPSILON 2.2204460492503131e-16

/* imported from gsl_math.h */

#ifndef M_LOG2E
#define M_LOG2E    1.44269504088896340735992468100      /* log_2 (e) */
#endif

/* imported from gsl_sf_result.h */

struct gsl_sf_result_struct {
  double val;
  double err;
};
typedef struct gsl_sf_result_struct gsl_sf_result;

/* imported and adapted from hsl/specfunc/specfunc_def.h */

#define HSL_SF_EVAL_RESULT(FnE) \
	gsl_sf_result result; \
	FnE ; \
	return (result.val);

#define HSL_SF_EVAL_TUPLE_RESULT(FnET) \
	gsl_sf_result result0; \
	gsl_sf_result result1; \
	FnET ; \
	*tuple1=result1.val; \
	*tuple0=result0.val; \
	return (result0.val);

/* */


#define HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT 10
#define HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER 32

#define HSL_SF_LNHZETA_EULERMACLAURIN_SERIES_SHIFT_MAX 256

// B_{2j}/(2j)
static
double hsl_sf_hzeta_eulermaclaurin_series_coeffs[HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER+1]={
	+1.0,
	+1.0/12.0,
	-1.0/720.0,
	+1.0/30240.0,
	-1.0/1209600.0,
	+1.0/47900160.0,
	-691.0/1307674368000.0,
	+1.0/74724249600.0,
	-3.38968029632258286683019539125e-13,
	+8.58606205627784456413590545043e-15,
	-2.17486869855806187304151642387e-16,
	+5.50900282836022951520265260890e-18,
	-1.39544646858125233407076862641e-19,
	+3.53470703962946747169322997780e-21,
	-8.95351742703754685040261131811e-23,
	+2.26795245233768306031095073887e-24,
	-5.74479066887220244526388198761e-26,
	+1.45517247561486490186626486727e-27,
	-3.68599494066531017818178247991e-29,
	+9.33673425709504467203255515279e-31,
	-2.36502241570062993455963519637e-32,
	+5.99067176248213430465991239682e-34,
	-1.51745488446829026171081313586e-35,
	+3.84375812545418823222944529099e-37,
	-9.73635307264669103526762127925e-39,
	+2.46624704420068095710640028029e-40,
	-6.24707674182074369314875679472e-42,
	+1.58240302446449142975108170683e-43,
	-4.00827368594893596853001219052e-45,
	+1.01530758555695563116307139454e-46,
	-2.57180415824187174992481940976e-48,
	+6.51445603523381493155843485864e-50,
	-1.65013099068965245550609878048e-51
	}; // hsl_sf_hzeta_eulermaclaurin_series_coeffs

// 4\zeta(2j)/(2\pi)^(2j)
static
double hsl_sf_hzeta_eulermaclaurin_series_majorantratios[HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER+1]={
	-2.0,
	+1.0/6.0,
	+1.0/360.0,
	+1.0/15120.0,
	+1.0/604800.0,
	+1.0/23950080.0,
	+691.0/653837184000.0,
	+1.0/37362124800.0,
	+3617.0/5335311421440000.0,
	+1.71721241125556891282718109009e-14,
	+4.34973739711612374608303284773e-16,
	+1.10180056567204590304053052178e-17,
	+2.79089293716250466814153725281e-19,
	+7.06941407925893494338645995561e-21,
	+1.79070348540750937008052226362e-22,
	+4.53590490467536612062190147774e-24,
	+1.14895813377444048905277639752e-25,
	+2.91034495122972980373252973454e-27,
	+7.37198988133062035636356495982e-29,
	+1.86734685141900893440651103056e-30,
	+4.73004483140125986911927039274e-32,
	+1.19813435249642686093198247936e-33,
	+3.03490976893658052342162627173e-35,
	+7.68751625090837646445889058198e-37,
	+1.94727061452933820705352425585e-38,
	+4.93249408840136191421280056051e-40,
	+1.24941534836414873862975135893e-41,
	+3.16480604892898285950216341362e-43,
	+8.01654737189787193706002438098e-45,
	+2.03061517111391126232614278906e-46,
	+5.14360831648374349984963881946e-48,
	+1.30289120704676298631168697172e-49,
	+3.30026198137930491101219756091e-51
	}; // hsl_sf_hzeta_eulermaclaurin_series_majorantratios


extern
int hsl_sf_hzeta_e(const double s, const double q, gsl_sf_result * result) {

	/* CHECK_POINTER(result) */

	if ((s <= 1.0) || (q <= 0.0)) {
		PLFIT_ERROR("s must be larger than 1.0 and q must be larger than zero", PLFIT_EINVAL);
		}
	else {
		const double max_bits=54.0; // max_bits=\lceil{s}\rceil with \zeta(s,2)=\zeta(s)-1=GSL_DBL_EPSILON
		const double ln_term0=-s*log(q);
		if (ln_term0 < GSL_LOG_DBL_MIN+1.0) {
			PLFIT_ERROR("underflow", PLFIT_UNDRFLOW);
			}
		else if (GSL_LOG_DBL_MAX-1.0 < ln_term0) {
			PLFIT_ERROR("overflow", PLFIT_OVERFLOW);
			}
#if 1
		else if (((max_bits < s) && (q < 1.0)) || ((0.5*max_bits < s) && (q < 0.25))) {
			result->val=pow(q,-s);
			result->err=2.0*GSL_DBL_EPSILON*fabs(result->val);
			return (PLFIT_SUCCESS);
			}
		else if ((0.5*max_bits < s) && (q < 1.0)) {
			const double a0=pow(q,-s);
			const double p1=pow(q/(1.0+q),s);
			const double p2=pow(q/(2.0+q),s);
			const double ans=a0*(1.0+p1+p2);
			result->val=ans;
			result->err=GSL_DBL_EPSILON*(2.0+0.5*s)*fabs(result->val);
			return (PLFIT_SUCCESS);
			}
#endif
		else { // Euler-Maclaurin summation formula
			const double qshift=HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+q;
			const double inv_qshift=1.0/qshift;
			const double sqr_inv_qshift=inv_qshift*inv_qshift;
			const double inv_sm1=1.0/(s-1.0);
			const double pmax=pow(qshift,-s);
			double terms[HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER+1]={NAN};
			double delta=NAN;
			double tscp=s;
			double scp=tscp;
			double pcp=pmax*inv_qshift;
			double ratio=scp*pcp;
			size_t n=0;
			size_t j=0;
			double ans=0.0;
			double mjr=NAN;

			for(j=0;jval=+ans;
			result->err=2.0*((HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+1.0)*GSL_DBL_EPSILON*fabs(ans)+mjr);
			return (PLFIT_SUCCESS);
			}
		}

}

extern
double hsl_sf_hzeta(const double s, const double q) {
	HSL_SF_EVAL_RESULT(hsl_sf_hzeta_e(s,q,&result)); }

extern
int hsl_sf_hzeta_deriv_e(const double s, const double q, gsl_sf_result * result) {

	/* CHECK_POINTER(result) */

	if ((s <= 1.0) || (q <= 0.0)) {
		PLFIT_ERROR("s must be larger than 1.0 and q must be larger than zero", PLFIT_EINVAL);
		}
	else {
		const double ln_hz_term0=-s*log(q);
		if (ln_hz_term0 < GSL_LOG_DBL_MIN+1.0) {
			PLFIT_ERROR("underflow", PLFIT_UNDRFLOW);
			}
		else if (GSL_LOG_DBL_MAX-1.0 < ln_hz_term0) {
			PLFIT_ERROR("overflow", PLFIT_OVERFLOW);
			}
		else { // Euler-Maclaurin summation formula
			const double qshift=HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+q;
			const double inv_qshift=1.0/qshift;
			const double sqr_inv_qshift=inv_qshift*inv_qshift;
			const double inv_sm1=1.0/(s-1.0);
			const double pmax=pow(qshift,-s);
			const double lmax=log(qshift);
			double terms[HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER+1]={NAN};
			double delta=NAN;
			double tscp=s;
			double scp=tscp;
			double pcp=pmax*inv_qshift;
			double lcp=lmax-1.0/s;
			double ratio=scp*pcp*lcp;
			double qs=NAN;
			size_t n=0;
			size_t j=0;
			double ans=0.0;
			double mjr=NAN;

			for(j=0,qs=q;jval=-ans;
			result->err=2.0*((HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+1.0)*GSL_DBL_EPSILON*fabs(ans)+mjr);
			return (PLFIT_SUCCESS);
			}
		}

}

extern
double hsl_sf_hzeta_deriv(const double s, const double q) {
	HSL_SF_EVAL_RESULT(hsl_sf_hzeta_deriv_e(s,q,&result)); }

extern
int hsl_sf_hzeta_deriv2_e(const double s, const double q, gsl_sf_result * result) {

	/* CHECK_POINTER(result) */

	if ((s <= 1.0) || (q <= 0.0)) {
		PLFIT_ERROR("s must be larger than 1.0 and q must be larger than zero", PLFIT_EINVAL);
		}
	else {
		const double ln_hz_term0=-s*log(q);
		if (ln_hz_term0 < GSL_LOG_DBL_MIN+1.0) {
			PLFIT_ERROR("underflow", PLFIT_UNDRFLOW);
			}
		else if (GSL_LOG_DBL_MAX-1.0 < ln_hz_term0) {
			PLFIT_ERROR("overflow", PLFIT_OVERFLOW);
			}
		else { // Euler-Maclaurin summation formula
			const double qshift=HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+q;
			const double inv_qshift=1.0/qshift;
			const double sqr_inv_qshift=inv_qshift*inv_qshift;
			const double inv_sm1=1.0/(s-1.0);
			const double pmax=pow(qshift,-s);
			const double lmax=log(qshift);
			const double lmax_p_inv_sm1=lmax+inv_sm1;
			const double sqr_inv_sm1=inv_sm1*inv_sm1;
			const double sqr_lmax=lmax*lmax;
			const double sqr_lmax_p_inv_sm1=lmax_p_inv_sm1*lmax_p_inv_sm1;
			double terms[HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+HSL_SF_HZETA_EULERMACLAURIN_SERIES_ORDER+1]={NAN};
			double delta=NAN;
			double tscp=s;
			double slcp=NAN;
			double plcp=NAN;
			double scp=tscp;
			double pcp=pmax*inv_qshift;
			double lcp=1.0/s-lmax;
			double sqr_lcp=lmax*(lmax-2.0/s);
			double ratio=scp*pcp*sqr_lcp;
			double qs=NAN;
			double lqs=NAN;
			size_t n=0;
			size_t j=0;
			double ans=0.0;
			double mjr=NAN;

			for(j=0,qs=q;jval=+ans;
			result->err=2.0*((HSL_SF_HZETA_EULERMACLAURIN_SERIES_SHIFT+1.0)*GSL_DBL_EPSILON*fabs(ans)+mjr);
			return (PLFIT_SUCCESS);
			}
		}

}

extern
double hsl_sf_hzeta_deriv2(const double s, const double q) {
	HSL_SF_EVAL_RESULT(hsl_sf_hzeta_deriv2_e(s,q,&result)); }

static inline
double hsl_sf_hZeta0_zed(const double s, const double q) {
#if 1
	const long double ld_q=(long double)(q);
	const long double ld_s=(long double)(s);
	const long double ld_log1prq=log1pl(1.0L/ld_q);
	const long double ld_epsilon=expm1l(-ld_s*ld_log1prq);
	const long double ld_z=ld_s+(ld_q+0.5L*ld_s+0.5L)*ld_epsilon;
	const double z=(double)(ld_z);
#else
	double z=s+(q+0.5*s+0.5)*expm1(-s*log1p(1.0/q));
#endif
	return (z); }

// Z_{0}(s,a) = a^s \left(\frac{1}{2}+\frac{a}{s-1}\right)^{-1} \zeta(s,a) - 1
// Z_{0}(s,a) = O\left(\frac{(s-1)s}{6a^{2}}\right)
static
int hsl_sf_hZeta0(const double s, const double q, double * value, double * abserror) {
	const double criterion=ceil(10.0*s-q);
	const size_t shift=(criterion<0.0)?0:
		(criterionval=log1p(ln_hZeta0_value);
			result->err=(2.0*GSL_DBL_EPSILON*ln_hz_coeff+hZeta0_abserror)/(1.0+ln_hZeta0_value);
			}

		if (result_deriv) {
			const double ld_hz_coeff2=1.0+inv_sm1*M_LOG2E;
			const double ld_hz_coeff1=1.0+inv_qsm1*ld_hz_coeff2;
			double hZeta1_value=NAN;
			double hZeta1_abserror=NAN;
			hsl_sf_hZeta1(s,2.0,M_LN2,&hZeta1_value,&hZeta1_abserror,NULL);
			hZeta0_value*=hz_coeff1;
			hZeta0_value+=hz_coeff0;
			hZeta1_value+=1.0;
			hZeta1_value*=-M_LN2*ld_hz_coeff1;
			result_deriv->val=hZeta1_value/hZeta0_value;
			result_deriv->err=2.0*GSL_DBL_EPSILON*fabs(result_deriv->val)+(hZeta0_abserror+hZeta1_abserror);
			}
		}
	else {
		const double ln_q=log(q);
		double hZeta0_value=NAN;
		double hZeta0_abserror=NAN;
		hsl_sf_hZeta0(s,q,&hZeta0_value,&hZeta0_abserror);
		if (result) {
			const double ln_hz_term0=-s*ln_q;
			const double ln_hz_term1=log(0.5+q/(s-1.0));
			result->val=ln_hz_term0+ln_hz_term1+log1p(hZeta0_value);
			result->err=2.0*GSL_DBL_EPSILON*(fabs(ln_hz_term0)+fabs(ln_hz_term1))+hZeta0_abserror/(1.0+hZeta0_value);
			}
		if (result_deriv) {
			double hZeta1_value=NAN;
			double hZeta1_abserror=NAN;
			double ld_hz_coeff1=NAN;
			hsl_sf_hZeta1(s,q,ln_q,&hZeta1_value,&hZeta1_abserror,&ld_hz_coeff1);
			result_deriv->val=-ln_q*ld_hz_coeff1*(1.0+hZeta1_value)/(1.0+hZeta0_value);
			result_deriv->err=2.0*GSL_DBL_EPSILON*fabs(result_deriv->val)+(hZeta0_abserror+hZeta1_abserror);
			}
		}

	return (PLFIT_SUCCESS); }

extern
double hsl_sf_lnhzeta_deriv_tuple(const double s, const double q, double * tuple0, double * tuple1) {
	HSL_SF_EVAL_TUPLE_RESULT(hsl_sf_lnhzeta_deriv_tuple_e(s,q,&result0,&result1)); }

extern
int hsl_sf_lnhzeta_e(const double s, const double q, gsl_sf_result * result) {
	return (hsl_sf_lnhzeta_deriv_tuple_e(s,q,result,NULL)); }

extern
double hsl_sf_lnhzeta(const double s, const double q) {
	HSL_SF_EVAL_RESULT(hsl_sf_lnhzeta_e(s,q,&result)); }

extern
int hsl_sf_lnhzeta_deriv_e(const double s, const double q, gsl_sf_result * result) {
	return (hsl_sf_lnhzeta_deriv_tuple_e(s,q,NULL,result)); }

extern
double hsl_sf_lnhzeta_deriv(const double s, const double q) {
	HSL_SF_EVAL_RESULT(hsl_sf_lnhzeta_deriv_e(s,q,&result)); }

//
// End of file `hsl/specfunc/hzeta.c'.
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/hzeta.h0000644000175100001710000000567700000000000023570 0ustar00runnerdocker00000000000000/* This file was imported from a private scientific library
 * based on GSL coined Home Scientific Libray (HSL) by its author
 * Jerome Benoit; this very material is itself inspired from the
 * material written by G. Jungan and distributed by GSL.
 * Ultimately, some modifications were done in order to render the
 * imported material independent from the rest of GSL.
 */

/* `hsl/hsl_sf_zeta.h' C header file
// HSL - Home Scientific Library
// Copyright (C) 2005-2018  Jerome Benoit
//
// HSL is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

/* For futher details, see its source conterpart src/hzeta.c */

/* Author:  Jerome G. Benoit < jgmbenoit _at_ rezozer _dot_ net > */

#ifndef __HZETA_H__
#define __HZETA_H__

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS


/* Hurwitz Zeta Function
 * zeta(s,q) = Sum[ (k+q)^(-s), {k,0,Infinity} ]
 *
 * s > 1.0, q > 0.0
 */
double hsl_sf_hzeta(const double s, const double q);

/* First Derivative of Hurwitz Zeta Function
 * zeta'(s,q) = - Sum[ Ln(k+q)/(k+q)^(s), {k,0,Infinity} ]
 *
 * s > 1.0, q > 0.0
 */
double hsl_sf_hzeta_deriv(const double s, const double q);

/* Second Derivative of Hurwitz Zeta Function
 * zeta''(s,q) = + Sum[ Ln(k+q)^2/(k+q)^(s), {k,0,Infinity} ]
 *
 * s > 1.0, q > 0.0
 */
double hsl_sf_hzeta_deriv2(const double s, const double q);

/* Logarithm of Hurwitz Zeta Function
 * lnzeta(s,q) = ln(zeta(s,q))
 *
 * s > 1.0, q > 0.0 (and q >> 1)
 */
double hsl_sf_lnhzeta(const double s, const double q);

/* Logarithmic Derivative of Hurwitz Zeta Function
 * lnzeta'(s,q) = zeta'(s,q)/zeta(s,q)
 *
 * s > 1.0, q > 0.0 (and q >> 1)
 */
double hsl_sf_lnhzeta_deriv(const double s, const double q);

/* Logarithm and Logarithmic Derivative of Hurwitz Zeta Function:
 * nonredundant computation version:
 * - lnzeta(s,q) and lnzeta'(s,q) are stored in *deriv0 and *deriv1, respectively;
 * - the return value and the value stored in *deriv0 are the same;
 * - deriv0 and deriv1 must be effective pointers, that is, not the NULL pointer.
 *
 * s > 1.0, q > 0.0 (and q >> 1)
 */
double hsl_sf_lnhzeta_deriv_tuple(const double s, const double q, double * deriv0, double * deriv1);


__END_DECLS

#endif // __HZETA_H__
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/kolmogorov.c0000644000175100001710000000356100000000000024634 0ustar00runnerdocker00000000000000/* kolmogorov.c
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include 
#include "kolmogorov.h"

double plfit_kolmogorov(double z) {
    const double fj[4] = { -2, -8, -18, -32 };
    const double w = 2.50662827;
    const double c1 = -1.2337005501361697;   /* -pi^2 / 8 */
    const double c2 = -11.103304951225528;   /*  9*c1 */
    const double c3 = -30.842513753404244;   /* 25*c1 */

    double u = fabs(z);
    double v;

    if (u < 0.2)
        return 1;

    if (u < 0.755) {
        v = 1.0 / (u*u);
        return 1 - w * (exp(c1*v) + exp(c2*v) + exp(c3*v)) / u;
    }

    if (u < 6.8116) {
        double r[4] = { 0, 0, 0, 0 };
        long int maxj = (long int)(3.0 / u + 0.5);
        long int j;

        if (maxj < 1)
            maxj = 1;

        v = u*u;
        for (j = 0; j < maxj; j++) {
            r[j] = exp(fj[j] * v);
        }

        return 2*(r[0] - r[1] + r[2] - r[3]);
    }

    return 0;
}

double plfit_ks_test_one_sample_p(double d, size_t n) {
    return plfit_kolmogorov(d * sqrt((double) n));
}

double plfit_ks_test_two_sample_p(double d, size_t n1, size_t n2) {
    return plfit_kolmogorov(d * sqrt(n1*n2 / ((double)(n1+n2))));
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/kolmogorov.h0000644000175100001710000000234200000000000024635 0ustar00runnerdocker00000000000000/* kolmogorov.h
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __KOLMOGOROV_H__
#define __KOLMOGOROV_H__

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

#include 

__BEGIN_DECLS

double plfit_kolmogorov(double z);
double plfit_ks_test_one_sample_p(double d, size_t n);
double plfit_ks_test_two_sample_p(double d, size_t n1, size_t n2);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/lbfgs.c0000644000175100001710000012036400000000000023534 0ustar00runnerdocker00000000000000/*
 *      Limited memory BFGS (L-BFGS).
 *
 * Copyright (c) 1990, Jorge Nocedal
 * Copyright (c) 2007-2010 Naoaki Okazaki
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* $Id: lbfgs.c 65 2010-01-29 12:19:16Z naoaki $ */

/*
This library is a C port of the FORTRAN implementation of Limited-memory
Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) method written by Jorge Nocedal.
The original FORTRAN source code is available at:
http://www.ece.northwestern.edu/~nocedal/lbfgs.html

The L-BFGS algorithm is described in:
    - Jorge Nocedal.
      Updating Quasi-Newton Matrices with Limited Storage.
      Mathematics of Computation, Vol. 35, No. 151, pp. 773--782, 1980.
    - Dong C. Liu and Jorge Nocedal.
      On the limited memory BFGS method for large scale optimization.
      Mathematical Programming B, Vol. 45, No. 3, pp. 503-528, 1989.

The line search algorithms used in this implementation are described in:
    - John E. Dennis and Robert B. Schnabel.
      Numerical Methods for Unconstrained Optimization and Nonlinear
      Equations, Englewood Cliffs, 1983.
    - Jorge J. More and David J. Thuente.
      Line search algorithm with guaranteed sufficient decrease.
      ACM Transactions on Mathematical Software (TOMS), Vol. 20, No. 3,
      pp. 286-307, 1994.

This library also implements Orthant-Wise Limited-memory Quasi-Newton (OWL-QN)
method presented in:
    - Galen Andrew and Jianfeng Gao.
      Scalable training of L1-regularized log-linear models.
      In Proceedings of the 24th International Conference on Machine
      Learning (ICML 2007), pp. 33-40, 2007.

I would like to thank the original author, Jorge Nocedal, who has been
distributing the effieicnt and explanatory implementation in an open source
licence.
*/

#ifdef  HAVE_CONFIG_H
#include "config.h"
#endif/*HAVE_CONFIG_H*/

#ifndef _MSC_VER
#include 
#endif

#include 
#include 
#include 

#include "lbfgs.h"
#include "platform.h"

#ifdef  _MSC_VER
#define inline  __inline
typedef unsigned int uint32_t;
#endif/*_MSC_VER*/

#if     defined(USE_SSE) && defined(__SSE2__) && LBFGS_FLOAT == 64
/* Use SSE2 optimization for 64bit double precision. */
#include "arithmetic_sse_double.h"

#elif   defined(USE_SSE) && defined(__SSE__) && LBFGS_FLOAT == 32
/* Use SSE optimization for 32bit float precision. */
#include "arithmetic_sse_float.h"

#else
/* No CPU specific optimization. */
#include "arithmetic_ansi.h"

#endif

#define min2(a, b)      ((a) <= (b) ? (a) : (b))
#define max2(a, b)      ((a) >= (b) ? (a) : (b))
#define max3(a, b, c)   max2(max2((a), (b)), (c));

#define is_aligned(p, bytes) \
	(((uintptr_t)(const void*)(p)) % (bytes) == 0)

struct tag_callback_data {
    int n;
    void *instance;
    lbfgs_evaluate_t proc_evaluate;
    lbfgs_progress_t proc_progress;
};
typedef struct tag_callback_data callback_data_t;

struct tag_iteration_data {
    lbfgsfloatval_t alpha;
    lbfgsfloatval_t *s;     /* [n] */
    lbfgsfloatval_t *y;     /* [n] */
    lbfgsfloatval_t ys;     /* vecdot(y, s) */
};
typedef struct tag_iteration_data iteration_data_t;

static const lbfgs_parameter_t _defparam = {
    6, 1e-5, 0, 1e-5,
    0, LBFGS_LINESEARCH_DEFAULT, 40,
    1e-20, 1e20, 1e-4, 0.9, 0.9, 1.0e-16,
    0.0, 0, -1,
};

/* Forward function declarations. */

typedef int (*line_search_proc)(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wa,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    );
    
static int line_search_backtracking(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wa,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    );

static int line_search_backtracking_owlqn(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wp,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    );

static int line_search_morethuente(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wa,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    );

static int update_trial_interval(
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *fx,
    lbfgsfloatval_t *dx,
    lbfgsfloatval_t *y,
    lbfgsfloatval_t *fy,
    lbfgsfloatval_t *dy,
    lbfgsfloatval_t *t,
    lbfgsfloatval_t *ft,
    lbfgsfloatval_t *dt,
    const lbfgsfloatval_t tmin,
    const lbfgsfloatval_t tmax,
    int *brackt
    );

static lbfgsfloatval_t owlqn_x1norm(
    const lbfgsfloatval_t* x,
    const int start,
    const int n
    );

static void owlqn_pseudo_gradient(
    lbfgsfloatval_t* pg,
    const lbfgsfloatval_t* x,
    const lbfgsfloatval_t* g,
    const int n,
    const lbfgsfloatval_t c,
    const int start,
    const int end
    );

static void owlqn_project(
    lbfgsfloatval_t* d,
    const lbfgsfloatval_t* sign,
    const int start,
    const int end
    );


#if     defined(USE_SSE) && (defined(__SSE__) || defined(__SSE2__))
static int round_out_variables(int n)
{
    n += 7;
    n /= 8;
    n *= 8;
    return n;
}
#endif/*defined(USE_SSE)*/

lbfgsfloatval_t* lbfgs_malloc(int n)
{
#if     defined(USE_SSE) && (defined(__SSE__) || defined(__SSE2__))
    n = round_out_variables(n);
#endif/*defined(USE_SSE)*/
    return (lbfgsfloatval_t*)vecalloc(sizeof(lbfgsfloatval_t) * (size_t) n);
}

void lbfgs_free(lbfgsfloatval_t *x)
{
    vecfree(x);
}

void lbfgs_parameter_init(lbfgs_parameter_t *param)
{
    memcpy(param, &_defparam, sizeof(*param));
}

int lbfgs(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *ptr_fx,
    lbfgs_evaluate_t proc_evaluate,
    lbfgs_progress_t proc_progress,
    void *instance,
    lbfgs_parameter_t *_param
    )
{
    int ret;
    int i, j, k, ls, end, bound;
    lbfgsfloatval_t step;

    /* Constant parameters and their default values. */
    lbfgs_parameter_t param = (_param != NULL) ? (*_param) : _defparam;
    const int m = param.m;

    lbfgsfloatval_t *xp = NULL;
    lbfgsfloatval_t *g = NULL, *gp = NULL, *pg = NULL;
    lbfgsfloatval_t *d = NULL, *w = NULL, *pf = NULL;
    iteration_data_t *lm = NULL, *it = NULL;
    lbfgsfloatval_t ys, yy;
    lbfgsfloatval_t xnorm, gnorm, beta;
    lbfgsfloatval_t fx = 0.;
    lbfgsfloatval_t rate = 0.;
    line_search_proc linesearch = line_search_morethuente;

    /* Construct a callback data. */
    callback_data_t cd;
    cd.n = n;
    cd.instance = instance;
    cd.proc_evaluate = proc_evaluate;
    cd.proc_progress = proc_progress;

#if     defined(USE_SSE) && (defined(__SSE__) || defined(__SSE2__))
    /* Round out the number of variables. */
    n = round_out_variables(n);
#endif/*defined(USE_SSE)*/

    /* Check the input parameters for errors. */
    if (n <= 0) {
        return LBFGSERR_INVALID_N;
    }
#if     defined(USE_SSE) && (defined(__SSE__) || defined(__SSE2__))
    if (n % 8 != 0) {
        return LBFGSERR_INVALID_N_SSE;
    }
    if (!is_aligned(x, 16)) {
        return LBFGSERR_INVALID_X_SSE;
    }
#endif/*defined(USE_SSE)*/
    if (param.epsilon < 0.) {
        return LBFGSERR_INVALID_EPSILON;
    }
    if (param.past < 0) {
        return LBFGSERR_INVALID_TESTPERIOD;
    }
    if (param.delta < 0.) {
        return LBFGSERR_INVALID_DELTA;
    }
    if (param.min_step < 0.) {
        return LBFGSERR_INVALID_MINSTEP;
    }
    if (param.max_step < param.min_step) {
        return LBFGSERR_INVALID_MAXSTEP;
    }
    if (param.ftol < 0.) {
        return LBFGSERR_INVALID_FTOL;
    }
    if (param.linesearch == LBFGS_LINESEARCH_BACKTRACKING_WOLFE ||
        param.linesearch == LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE) {
        if (param.wolfe <= param.ftol || 1. <= param.wolfe) {
            return LBFGSERR_INVALID_WOLFE;
        }
    }
    if (param.gtol < 0.) {
        return LBFGSERR_INVALID_GTOL;
    }
    if (param.xtol < 0.) {
        return LBFGSERR_INVALID_XTOL;
    }
    if (param.max_linesearch <= 0) {
        return LBFGSERR_INVALID_MAXLINESEARCH;
    }
    if (param.orthantwise_c < 0.) {
        return LBFGSERR_INVALID_ORTHANTWISE;
    }
    if (param.orthantwise_start < 0 || n < param.orthantwise_start) {
        return LBFGSERR_INVALID_ORTHANTWISE_START;
    }
    if (param.orthantwise_end < 0) {
        param.orthantwise_end = n;
    }
    if (n < param.orthantwise_end) {
        return LBFGSERR_INVALID_ORTHANTWISE_END;
    }
    if (param.orthantwise_c != 0.) {
        switch (param.linesearch) {
        case LBFGS_LINESEARCH_BACKTRACKING:
            linesearch = line_search_backtracking_owlqn;
            break;
        default:
            /* Only the backtracking method is available. */
            return LBFGSERR_INVALID_LINESEARCH;
        }
    } else {
        switch (param.linesearch) {
        case LBFGS_LINESEARCH_MORETHUENTE:
            linesearch = line_search_morethuente;
            break;
        case LBFGS_LINESEARCH_BACKTRACKING_ARMIJO:
        case LBFGS_LINESEARCH_BACKTRACKING_WOLFE:
        case LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE:
            linesearch = line_search_backtracking;
            break;
        default:
            return LBFGSERR_INVALID_LINESEARCH;
        }
    }

    /* Allocate working space. */
    xp = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
    g = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
    gp = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
    d = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
    w = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
    if (xp == NULL || g == NULL || gp == NULL || d == NULL || w == NULL) {
        ret = LBFGSERR_OUTOFMEMORY;
        goto lbfgs_exit;
    }

    if (param.orthantwise_c != 0.) {
        /* Allocate working space for OW-LQN. */
        pg = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
        if (pg == NULL) {
            ret = LBFGSERR_OUTOFMEMORY;
            goto lbfgs_exit;
        }
    }

    /* Allocate limited memory storage. */
    lm = (iteration_data_t*)vecalloc((size_t) m * sizeof(iteration_data_t));
    if (lm == NULL) {
        ret = LBFGSERR_OUTOFMEMORY;
        goto lbfgs_exit;
    }

    /* Initialize the limited memory. */
    for (i = 0;i < m;++i) {
        it = &lm[i];
        it->alpha = 0;
        it->ys = 0;
        it->s = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
        it->y = (lbfgsfloatval_t*)vecalloc((size_t) n * sizeof(lbfgsfloatval_t));
        if (it->s == NULL || it->y == NULL) {
            ret = LBFGSERR_OUTOFMEMORY;
            goto lbfgs_exit;
        }
    }

    /* Allocate an array for storing previous values of the objective function. */
    if (0 < param.past) {
        pf = (lbfgsfloatval_t*)vecalloc((size_t) param.past * sizeof(lbfgsfloatval_t));
    }

    /* Evaluate the function value and its gradient. */
    fx = cd.proc_evaluate(cd.instance, x, g, cd.n, 0);
    if (0. != param.orthantwise_c) {
        /* Compute the L1 norm of the variable and add it to the object value. */
        xnorm = owlqn_x1norm(x, param.orthantwise_start, param.orthantwise_end);
        fx += xnorm * param.orthantwise_c;
        owlqn_pseudo_gradient(
            pg, x, g, n,
            param.orthantwise_c, param.orthantwise_start, param.orthantwise_end
            );
    }

    /* Store the initial value of the objective function. */
    if (pf != NULL) {
        pf[0] = fx;
    }

    /*
        Compute the direction;
        we assume the initial hessian matrix H_0 as the identity matrix.
     */
    if (param.orthantwise_c == 0.) {
        vecncpy(d, g, n);
    } else {
        vecncpy(d, pg, n);
    }

    /*
       Make sure that the initial variables are not a minimizer.
     */
    vec2norm(&xnorm, x, n);
    if (param.orthantwise_c == 0.) {
        vec2norm(&gnorm, g, n);
    } else {
        vec2norm(&gnorm, pg, n);
    }
    if (xnorm < 1.0) xnorm = 1.0;
    if (gnorm / xnorm <= param.epsilon) {
        ret = LBFGS_ALREADY_MINIMIZED;
        goto lbfgs_exit;
    }

    /* Compute the initial step:
        step = 1.0 / sqrt(vecdot(d, d, n))
     */
    vec2norminv(&step, d, n);

    k = 1;
    end = 0;
    for (;;) {
        /* Store the current position and gradient vectors. */
        veccpy(xp, x, n);
        veccpy(gp, g, n);

        /* Search for an optimal step. */
        if (param.orthantwise_c == 0.) {
            ls = linesearch(n, x, &fx, g, d, &step, xp, gp, w, &cd, ¶m);
        } else {
            ls = linesearch(n, x, &fx, g, d, &step, xp, pg, w, &cd, ¶m);
            owlqn_pseudo_gradient(
                pg, x, g, n,
                param.orthantwise_c, param.orthantwise_start, param.orthantwise_end
                );
        }
        if (ls < 0) {
            /* Revert to the previous point. */
            veccpy(x, xp, n);
            veccpy(g, gp, n);
            ret = ls;
            goto lbfgs_exit;
        }

        /* Compute x and g norms. */
        vec2norm(&xnorm, x, n);
        if (param.orthantwise_c == 0.) {
            vec2norm(&gnorm, g, n);
        } else {
            vec2norm(&gnorm, pg, n);
        }

        /* Report the progress. */
        if (cd.proc_progress) {
            ret = cd.proc_progress(cd.instance, x, g, fx, xnorm, gnorm, step, cd.n, k, ls);
            if (ret) {
                goto lbfgs_exit;
            }
        }

        /*
            Convergence test.
            The criterion is given by the following formula:
                |g(x)| / \max(1, |x|) < \epsilon
         */
        if (xnorm < 1.0) xnorm = 1.0;
        if (gnorm / xnorm <= param.epsilon) {
            /* Convergence. */
            ret = LBFGS_SUCCESS;
            break;
        }

        /*
            Test for stopping criterion.
            The criterion is given by the following formula:
                (f(past_x) - f(x)) / f(x) < \delta
         */
        if (pf != NULL) {
            /* We don't test the stopping criterion while k < past. */
            if (param.past <= k) {
                /* Compute the relative improvement from the past. */
                rate = (pf[k % param.past] - fx) / fx;

                /* The stopping criterion. */
                if (rate < param.delta) {
                    ret = LBFGS_STOP;
                    break;
                }
            }

            /* Store the current value of the objective function. */
            pf[k % param.past] = fx;
        }

        if (param.max_iterations != 0 && param.max_iterations < k+1) {
            /* Maximum number of iterations. */
            ret = LBFGSERR_MAXIMUMITERATION;
            break;
        }

        /*
            Update vectors s and y:
                s_{k+1} = x_{k+1} - x_{k} = \step * d_{k}.
                y_{k+1} = g_{k+1} - g_{k}.
         */
        it = &lm[end];
        vecdiff(it->s, x, xp, n);
        vecdiff(it->y, g, gp, n);

        /*
            Compute scalars ys and yy:
                ys = y^t \cdot s = 1 / \rho.
                yy = y^t \cdot y.
            Notice that yy is used for scaling the hessian matrix H_0 (Cholesky factor).
         */
        vecdot(&ys, it->y, it->s, n);
        vecdot(&yy, it->y, it->y, n);
        it->ys = ys;

        /*
            Recursive formula to compute dir = -(H \cdot g).
                This is described in page 779 of:
                Jorge Nocedal.
                Updating Quasi-Newton Matrices with Limited Storage.
                Mathematics of Computation, Vol. 35, No. 151,
                pp. 773--782, 1980.
         */
        bound = (m <= k) ? m : k;
        ++k;
        end = (end + 1) % m;

        /* Compute the steepest direction. */
        if (param.orthantwise_c == 0.) {
            /* Compute the negative of gradients. */
            vecncpy(d, g, n);
        } else {
            vecncpy(d, pg, n);
        }

        j = end;
        for (i = 0;i < bound;++i) {
            j = (j + m - 1) % m;    /* if (--j == -1) j = m-1; */
            it = &lm[j];
            /* \alpha_{j} = \rho_{j} s^{t}_{j} \cdot q_{k+1}. */
            vecdot(&it->alpha, it->s, d, n);
            it->alpha /= it->ys;
            /* q_{i} = q_{i+1} - \alpha_{i} y_{i}. */
            vecadd(d, it->y, -it->alpha, n);
        }

        vecscale(d, ys / yy, n);

        for (i = 0;i < bound;++i) {
            it = &lm[j];
            /* \beta_{j} = \rho_{j} y^t_{j} \cdot \gamma_{i}. */
            vecdot(&beta, it->y, d, n);
            beta /= it->ys;
            /* \gamma_{i+1} = \gamma_{i} + (\alpha_{j} - \beta_{j}) s_{j}. */
            vecadd(d, it->s, it->alpha - beta, n);
            j = (j + 1) % m;        /* if (++j == m) j = 0; */
        }

        /*
            Constrain the search direction for orthant-wise updates.
         */
        if (param.orthantwise_c != 0.) {
            for (i = param.orthantwise_start;i < param.orthantwise_end;++i) {
                if (d[i] * pg[i] >= 0) {
                    d[i] = 0;
                }
            }
        }

        /*
            Now the search direction d is ready. We try step = 1 first.
         */
        step = 1.0;
    }

lbfgs_exit:
    /* Return the final value of the objective function. */
    if (ptr_fx != NULL) {
        *ptr_fx = fx;
    }

    vecfree(pf);

    /* Free memory blocks used by this function. */
    if (lm != NULL) {
        for (i = 0;i < m;++i) {
            vecfree(lm[i].s);
            vecfree(lm[i].y);
        }
        vecfree(lm);
    }
    vecfree(pg);
    vecfree(w);
    vecfree(d);
    vecfree(gp);
    vecfree(g);
    vecfree(xp);

    return ret;
}



static int line_search_backtracking(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wp,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    )
{
    int count = 0;
    lbfgsfloatval_t width, dg;
    lbfgsfloatval_t finit, dginit = 0., dgtest;
    const lbfgsfloatval_t dec = 0.5, inc = 2.1;

    /* Check the input parameters for errors. */
    if (*stp <= 0.) {
        return LBFGSERR_INVALIDPARAMETERS;
    }

    /* Compute the initial gradient in the search direction. */
    vecdot(&dginit, g, s, n);

    /* Make sure that s points to a descent direction. */
    if (0 < dginit) {
        return LBFGSERR_INCREASEGRADIENT;
    }

    /* The initial value of the objective function. */
    finit = *f;
    dgtest = param->ftol * dginit;

    for (;;) {
        veccpy(x, xp, n);
        vecadd(x, s, *stp, n);

        /* Evaluate the function and gradient values. */
        *f = cd->proc_evaluate(cd->instance, x, g, cd->n, *stp);

        ++count;

        if (*f > finit + *stp * dgtest) {
            width = dec;
        } else {
            /* The sufficient decrease condition (Armijo condition). */
            if (param->linesearch == LBFGS_LINESEARCH_BACKTRACKING_ARMIJO) {
                /* Exit with the Armijo condition. */
                return count;
	        }

	        /* Check the Wolfe condition. */
	        vecdot(&dg, g, s, n);
	        if (dg < param->wolfe * dginit) {
    		    width = inc;
	        } else {
		        if(param->linesearch == LBFGS_LINESEARCH_BACKTRACKING_WOLFE) {
		            /* Exit with the regular Wolfe condition. */
		            return count;
		        }

		        /* Check the strong Wolfe condition. */
		        if(dg > -param->wolfe * dginit) {
		            width = dec;
		        } else {
		            /* Exit with the strong Wolfe condition. */
		            return count;
		        }
            }
        }

        if (*stp < param->min_step) {
            /* The step is the minimum value. */
            return LBFGSERR_MINIMUMSTEP;
        }
        if (*stp > param->max_step) {
            /* The step is the maximum value. */
            return LBFGSERR_MAXIMUMSTEP;
        }
        if (param->max_linesearch <= count) {
            /* Maximum number of iteration. */
            return LBFGSERR_MAXIMUMLINESEARCH;
        }

        (*stp) *= width;
    }
}



static int line_search_backtracking_owlqn(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wp,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    )
{
    int i, count = 0;
    lbfgsfloatval_t width = 0.5, norm = 0.;
    lbfgsfloatval_t finit = *f, dgtest;

    /* Check the input parameters for errors. */
    if (*stp <= 0.) {
        return LBFGSERR_INVALIDPARAMETERS;
    }

    /* Choose the orthant for the new point. */
    for (i = 0;i < n;++i) {
        wp[i] = (xp[i] == 0.) ? -gp[i] : xp[i];
    }

    for (;;) {
        /* Update the current point. */
        veccpy(x, xp, n);
        vecadd(x, s, *stp, n);

        /* The current point is projected onto the orthant. */
        owlqn_project(x, wp, param->orthantwise_start, param->orthantwise_end);

        /* Evaluate the function and gradient values. */
        *f = cd->proc_evaluate(cd->instance, x, g, cd->n, *stp);

        /* Compute the L1 norm of the variables and add it to the object value. */
        norm = owlqn_x1norm(x, param->orthantwise_start, param->orthantwise_end);
        *f += norm * param->orthantwise_c;

        ++count;

        dgtest = 0.;
        for (i = 0;i < n;++i) {
            dgtest += (x[i] - xp[i]) * gp[i];
        }

        if (*f <= finit + param->ftol * dgtest) {
            /* The sufficient decrease condition. */
            return count;
        }

        if (*stp < param->min_step) {
            /* The step is the minimum value. */
            return LBFGSERR_MINIMUMSTEP;
        }
        if (*stp > param->max_step) {
            /* The step is the maximum value. */
            return LBFGSERR_MAXIMUMSTEP;
        }
        if (param->max_linesearch <= count) {
            /* Maximum number of iteration. */
            return LBFGSERR_MAXIMUMLINESEARCH;
        }

        (*stp) *= width;
    }
}



static int line_search_morethuente(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *f,
    lbfgsfloatval_t *g,
    lbfgsfloatval_t *s,
    lbfgsfloatval_t *stp,
    const lbfgsfloatval_t* xp,
    const lbfgsfloatval_t* gp,
    lbfgsfloatval_t *wa,
    callback_data_t *cd,
    const lbfgs_parameter_t *param
    )
{
    int count = 0;
    int brackt, stage1, uinfo = 0;
    lbfgsfloatval_t dg;
    lbfgsfloatval_t stx, fx, dgx;
    lbfgsfloatval_t sty, fy, dgy;
    lbfgsfloatval_t fxm, dgxm, fym, dgym, fm, dgm;
    lbfgsfloatval_t finit, ftest1, dginit, dgtest;
    lbfgsfloatval_t width, prev_width;
    lbfgsfloatval_t stmin, stmax;

    /* Check the input parameters for errors. */
    if (*stp <= 0.) {
        return LBFGSERR_INVALIDPARAMETERS;
    }

    /* Compute the initial gradient in the search direction. */
    vecdot(&dginit, g, s, n);

    /* Make sure that s points to a descent direction. */
    if (0 < dginit) {
        return LBFGSERR_INCREASEGRADIENT;
    }

    /* Initialize local variables. */
    brackt = 0;
    stage1 = 1;
    finit = *f;
    dgtest = param->ftol * dginit;
    width = param->max_step - param->min_step;
    prev_width = 2.0 * width;

    /*
        The variables stx, fx, dgx contain the values of the step,
        function, and directional derivative at the best step.
        The variables sty, fy, dgy contain the value of the step,
        function, and derivative at the other endpoint of
        the interval of uncertainty.
        The variables stp, f, dg contain the values of the step,
        function, and derivative at the current step.
    */
    stx = sty = 0.;
    fx = fy = finit;
    dgx = dgy = dginit;

    for (;;) {
        /*
            Set the minimum and maximum steps to correspond to the
            present interval of uncertainty.
         */
        if (brackt) {
            stmin = min2(stx, sty);
            stmax = max2(stx, sty);
        } else {
            stmin = stx;
            stmax = *stp + 4.0 * (*stp - stx);
        }

        /* Clip the step in the range of [stpmin, stpmax]. */
        if (*stp < param->min_step) *stp = param->min_step;
        if (param->max_step < *stp) *stp = param->max_step;

        /*
            If an unusual termination is to occur then let
            stp be the lowest point obtained so far.
         */
        if ((brackt && ((*stp <= stmin || stmax <= *stp) || param->max_linesearch <= count + 1 || uinfo != 0)) || (brackt && (stmax - stmin <= param->xtol * stmax))) {
            *stp = stx;
        }

        /*
            Compute the current value of x:
                x <- x + (*stp) * s.
         */
        veccpy(x, xp, n);
        vecadd(x, s, *stp, n);

        /* Evaluate the function and gradient values. */
        *f = cd->proc_evaluate(cd->instance, x, g, cd->n, *stp);
        vecdot(&dg, g, s, n);

        ftest1 = finit + *stp * dgtest;
        ++count;

        /* Test for errors and convergence. */
        if (brackt && ((*stp <= stmin || stmax <= *stp) || uinfo != 0)) {
            /* Rounding errors prevent further progress. */
            return LBFGSERR_ROUNDING_ERROR;
        }
        if (*stp == param->max_step && *f <= ftest1 && dg <= dgtest) {
            /* The step is the maximum value. */
            return LBFGSERR_MAXIMUMSTEP;
        }
        if (*stp == param->min_step && (ftest1 < *f || dgtest <= dg)) {
            /* The step is the minimum value. */
            return LBFGSERR_MINIMUMSTEP;
        }
        if (brackt && (stmax - stmin) <= param->xtol * stmax) {
            /* Relative width of the interval of uncertainty is at most xtol. */
            return LBFGSERR_WIDTHTOOSMALL;
        }
        if (param->max_linesearch <= count) {
            /* Maximum number of iteration. */
            return LBFGSERR_MAXIMUMLINESEARCH;
        }
        if (*f <= ftest1 && fabs(dg) <= param->gtol * (-dginit)) {
            /* The sufficient decrease condition and the directional derivative condition hold. */
            return count;
        }

        /*
            In the first stage we seek a step for which the modified
            function has a nonpositive value and nonnegative derivative.
         */
        if (stage1 && *f <= ftest1 && min2(param->ftol, param->gtol) * dginit <= dg) {
            stage1 = 0;
        }

        /*
            A modified function is used to predict the step only if
            we have not obtained a step for which the modified
            function has a nonpositive function value and nonnegative
            derivative, and if a lower function value has been
            obtained but the decrease is not sufficient.
         */
        if (stage1 && ftest1 < *f && *f <= fx) {
            /* Define the modified function and derivative values. */
            fm = *f - *stp * dgtest;
            fxm = fx - stx * dgtest;
            fym = fy - sty * dgtest;
            dgm = dg - dgtest;
            dgxm = dgx - dgtest;
            dgym = dgy - dgtest;

            /*
                Call update_trial_interval() to update the interval of
                uncertainty and to compute the new step.
             */
            uinfo = update_trial_interval(
                &stx, &fxm, &dgxm,
                &sty, &fym, &dgym,
                stp, &fm, &dgm,
                stmin, stmax, &brackt
                );

            /* Reset the function and gradient values for f. */
            fx = fxm + stx * dgtest;
            fy = fym + sty * dgtest;
            dgx = dgxm + dgtest;
            dgy = dgym + dgtest;
        } else {
            /*
                Call update_trial_interval() to update the interval of
                uncertainty and to compute the new step.
             */
            uinfo = update_trial_interval(
                &stx, &fx, &dgx,
                &sty, &fy, &dgy,
                stp, f, &dg,
                stmin, stmax, &brackt
                );
        }

        /*
            Force a sufficient decrease in the interval of uncertainty.
         */
        if (brackt) {
            if (0.66 * prev_width <= fabs(sty - stx)) {
                *stp = stx + 0.5 * (sty - stx);
            }
            prev_width = width;
            width = fabs(sty - stx);
        }
    }
}



/**
 * Define the local variables for computing minimizers.
 */
#define USES_MINIMIZER \
    lbfgsfloatval_t a, d, gamma, theta, p, q, r, s;

/**
 * Find a minimizer of an interpolated cubic function.
 *  @param  cm      The minimizer of the interpolated cubic.
 *  @param  u       The value of one point, u.
 *  @param  fu      The value of f(u).
 *  @param  du      The value of f'(u).
 *  @param  v       The value of another point, v.
 *  @param  fv      The value of f(v).
 *  @param  du      The value of f'(v).
 */
#define CUBIC_MINIMIZER(cm, u, fu, du, v, fv, dv) \
    d = (v) - (u); \
    theta = ((fu) - (fv)) * 3 / d + (du) + (dv); \
    p = fabs(theta); \
    q = fabs(du); \
    r = fabs(dv); \
    s = max3(p, q, r); \
    /* gamma = s*sqrt((theta/s)**2 - (du/s) * (dv/s)) */ \
    a = theta / s; \
    gamma = s * sqrt(a * a - ((du) / s) * ((dv) / s)); \
    if ((v) < (u)) gamma = -gamma; \
    p = gamma - (du) + theta; \
    q = gamma - (du) + gamma + (dv); \
    r = p / q; \
    (cm) = (u) + r * d;

/**
 * Find a minimizer of an interpolated cubic function.
 *  @param  cm      The minimizer of the interpolated cubic.
 *  @param  u       The value of one point, u.
 *  @param  fu      The value of f(u).
 *  @param  du      The value of f'(u).
 *  @param  v       The value of another point, v.
 *  @param  fv      The value of f(v).
 *  @param  du      The value of f'(v).
 *  @param  xmin    The maximum value.
 *  @param  xmin    The minimum value.
 */
#define CUBIC_MINIMIZER2(cm, u, fu, du, v, fv, dv, xmin, xmax) \
    d = (v) - (u); \
    theta = ((fu) - (fv)) * 3 / d + (du) + (dv); \
    p = fabs(theta); \
    q = fabs(du); \
    r = fabs(dv); \
    s = max3(p, q, r); \
    /* gamma = s*sqrt((theta/s)**2 - (du/s) * (dv/s)) */ \
    a = theta / s; \
    gamma = s * sqrt(max2(0, a * a - ((du) / s) * ((dv) / s))); \
    if ((u) < (v)) gamma = -gamma; \
    p = gamma - (dv) + theta; \
    q = gamma - (dv) + gamma + (du); \
    r = p / q; \
    if (r < 0. && gamma != 0.) { \
        (cm) = (v) - r * d; \
    } else if (a < 0) { \
        (cm) = (xmax); \
    } else { \
        (cm) = (xmin); \
    }

/**
 * Find a minimizer of an interpolated quadratic function.
 *  @param  qm      The minimizer of the interpolated quadratic.
 *  @param  u       The value of one point, u.
 *  @param  fu      The value of f(u).
 *  @param  du      The value of f'(u).
 *  @param  v       The value of another point, v.
 *  @param  fv      The value of f(v).
 */
#define QUARD_MINIMIZER(qm, u, fu, du, v, fv) \
    a = (v) - (u); \
    (qm) = (u) + (du) / (((fu) - (fv)) / a + (du)) / 2 * a;

/**
 * Find a minimizer of an interpolated quadratic function.
 *  @param  qm      The minimizer of the interpolated quadratic.
 *  @param  u       The value of one point, u.
 *  @param  du      The value of f'(u).
 *  @param  v       The value of another point, v.
 *  @param  dv      The value of f'(v).
 */
#define QUARD_MINIMIZER2(qm, u, du, v, dv) \
    a = (u) - (v); \
    (qm) = (v) + (dv) / ((dv) - (du)) * a;

/**
 * Update a safeguarded trial value and interval for line search.
 *
 *  The parameter x represents the step with the least function value.
 *  The parameter t represents the current step. This function assumes
 *  that the derivative at the point of x in the direction of the step.
 *  If the bracket is set to true, the minimizer has been bracketed in
 *  an interval of uncertainty with endpoints between x and y.
 *
 *  @param  x       The pointer to the value of one endpoint.
 *  @param  fx      The pointer to the value of f(x).
 *  @param  dx      The pointer to the value of f'(x).
 *  @param  y       The pointer to the value of another endpoint.
 *  @param  fy      The pointer to the value of f(y).
 *  @param  dy      The pointer to the value of f'(y).
 *  @param  t       The pointer to the value of the trial value, t.
 *  @param  ft      The pointer to the value of f(t).
 *  @param  dt      The pointer to the value of f'(t).
 *  @param  tmin    The minimum value for the trial value, t.
 *  @param  tmax    The maximum value for the trial value, t.
 *  @param  brackt  The pointer to the predicate if the trial value is
 *                  bracketed.
 *  @retval int     Status value. Zero indicates a normal termination.
 *  
 *  @see
 *      Jorge J. More and David J. Thuente. Line search algorithm with
 *      guaranteed sufficient decrease. ACM Transactions on Mathematical
 *      Software (TOMS), Vol 20, No 3, pp. 286-307, 1994.
 */
static int update_trial_interval(
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *fx,
    lbfgsfloatval_t *dx,
    lbfgsfloatval_t *y,
    lbfgsfloatval_t *fy,
    lbfgsfloatval_t *dy,
    lbfgsfloatval_t *t,
    lbfgsfloatval_t *ft,
    lbfgsfloatval_t *dt,
    const lbfgsfloatval_t tmin,
    const lbfgsfloatval_t tmax,
    int *brackt
    )
{
    int bound;
    int dsign = fsigndiff(dt, dx);
    lbfgsfloatval_t mc; /* minimizer of an interpolated cubic. */
    lbfgsfloatval_t mq; /* minimizer of an interpolated quadratic. */
    lbfgsfloatval_t newt;   /* new trial value. */
    USES_MINIMIZER;     /* for CUBIC_MINIMIZER and QUARD_MINIMIZER. */

    /* Check the input parameters for errors. */
    if (*brackt) {
        if (*t <= min2(*x, *y) || max2(*x, *y) <= *t) {
            /* The trival value t is out of the interval. */
            return LBFGSERR_OUTOFINTERVAL;
        }
        if (0. <= *dx * (*t - *x)) {
            /* The function must decrease from x. */
            return LBFGSERR_INCREASEGRADIENT;
        }
        if (tmax < tmin) {
            /* Incorrect tmin and tmax specified. */
            return LBFGSERR_INCORRECT_TMINMAX;
        }
    }

    /*
        Trial value selection.
     */
    if (*fx < *ft) {
        /*
            Case 1: a higher function value.
            The minimum is brackt. If the cubic minimizer is closer
            to x than the quadratic one, the cubic one is taken, else
            the average of the minimizers is taken.
         */
        *brackt = 1;
        bound = 1;
        CUBIC_MINIMIZER(mc, *x, *fx, *dx, *t, *ft, *dt);
        QUARD_MINIMIZER(mq, *x, *fx, *dx, *t, *ft);
        if (fabs(mc - *x) < fabs(mq - *x)) {
            newt = mc;
        } else {
            newt = mc + 0.5 * (mq - mc);
        }
    } else if (dsign) {
        /*
            Case 2: a lower function value and derivatives of
            opposite sign. The minimum is brackt. If the cubic
            minimizer is closer to x than the quadratic (secant) one,
            the cubic one is taken, else the quadratic one is taken.
         */
        *brackt = 1;
        bound = 0;
        CUBIC_MINIMIZER(mc, *x, *fx, *dx, *t, *ft, *dt);
        QUARD_MINIMIZER2(mq, *x, *dx, *t, *dt);
        if (fabs(mc - *t) > fabs(mq - *t)) {
            newt = mc;
        } else {
            newt = mq;
        }
    } else if (fabs(*dt) < fabs(*dx)) {
        /*
            Case 3: a lower function value, derivatives of the
            same sign, and the magnitude of the derivative decreases.
            The cubic minimizer is only used if the cubic tends to
            infinity in the direction of the minimizer or if the minimum
            of the cubic is beyond t. Otherwise the cubic minimizer is
            defined to be either tmin or tmax. The quadratic (secant)
            minimizer is also computed and if the minimum is brackt
            then the the minimizer closest to x is taken, else the one
            farthest away is taken.
         */
        bound = 1;
        CUBIC_MINIMIZER2(mc, *x, *fx, *dx, *t, *ft, *dt, tmin, tmax);
        QUARD_MINIMIZER2(mq, *x, *dx, *t, *dt);
        if (*brackt) {
            if (fabs(*t - mc) < fabs(*t - mq)) {
                newt = mc;
            } else {
                newt = mq;
            }
        } else {
            if (fabs(*t - mc) > fabs(*t - mq)) {
                newt = mc;
            } else {
                newt = mq;
            }
        }
    } else {
        /*
            Case 4: a lower function value, derivatives of the
            same sign, and the magnitude of the derivative does
            not decrease. If the minimum is not brackt, the step
            is either tmin or tmax, else the cubic minimizer is taken.
         */
        bound = 0;
        if (*brackt) {
            CUBIC_MINIMIZER(newt, *t, *ft, *dt, *y, *fy, *dy);
        } else if (*x < *t) {
            newt = tmax;
        } else {
            newt = tmin;
        }
    }

    /*
        Update the interval of uncertainty. This update does not
        depend on the new step or the case analysis above.

        - Case a: if f(x) < f(t),
            x <- x, y <- t.
        - Case b: if f(t) <= f(x) && f'(t)*f'(x) > 0,
            x <- t, y <- y.
        - Case c: if f(t) <= f(x) && f'(t)*f'(x) < 0, 
            x <- t, y <- x.
     */
    if (*fx < *ft) {
        /* Case a */
        *y = *t;
        *fy = *ft;
        *dy = *dt;
    } else {
        /* Case c */
        if (dsign) {
            *y = *x;
            *fy = *fx;
            *dy = *dx;
        }
        /* Cases b and c */
        *x = *t;
        *fx = *ft;
        *dx = *dt;
    }

    /* Clip the new trial value in [tmin, tmax]. */
    if (tmax < newt) newt = tmax;
    if (newt < tmin) newt = tmin;

    /*
        Redefine the new trial value if it is close to the upper bound
        of the interval.
     */
    if (*brackt && bound) {
        mq = *x + 0.66 * (*y - *x);
        if (*x < *y) {
            if (mq < newt) newt = mq;
        } else {
            if (newt < mq) newt = mq;
        }
    }

    /* Return the new trial value. */
    *t = newt;
    return 0;
}





static lbfgsfloatval_t owlqn_x1norm(
    const lbfgsfloatval_t* x,
    const int start,
    const int n
    )
{
    int i;
    lbfgsfloatval_t norm = 0.;

    for (i = start;i < n;++i) {
        norm += fabs(x[i]);
    }

    return norm;
}

static void owlqn_pseudo_gradient(
    lbfgsfloatval_t* pg,
    const lbfgsfloatval_t* x,
    const lbfgsfloatval_t* g,
    const int n,
    const lbfgsfloatval_t c,
    const int start,
    const int end
    )
{
    int i;

    /* Compute the negative of gradients. */
    for (i = 0;i < start;++i) {
        pg[i] = g[i];
    }

    /* Compute the psuedo-gradients. */
    for (i = start;i < end;++i) {
        if (x[i] < 0.) {
            /* Differentiable. */
            pg[i] = g[i] - c;
        } else if (0. < x[i]) {
            /* Differentiable. */
            pg[i] = g[i] + c;
        } else {
            if (g[i] < -c) {
                /* Take the right partial derivative. */
                pg[i] = g[i] + c;
            } else if (c < g[i]) {
                /* Take the left partial derivative. */
                pg[i] = g[i] - c;
            } else {
                pg[i] = 0.;
            }
        }
    }

    for (i = end;i < n;++i) {
        pg[i] = g[i];
    }
}

static void owlqn_project(
    lbfgsfloatval_t* d,
    const lbfgsfloatval_t* sign,
    const int start,
    const int end
    )
{
    int i;

    for (i = start;i < end;++i) {
        if (d[i] * sign[i] <= 0) {
            d[i] = 0;
        }
    }
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/lbfgs.h0000644000175100001710000007627600000000000023555 0ustar00runnerdocker00000000000000/*
 *      C library of Limited memory BFGS (L-BFGS).
 *
 * Copyright (c) 1990, Jorge Nocedal
 * Copyright (c) 2007-2010 Naoaki Okazaki
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* $Id: lbfgs.h 65 2010-01-29 12:19:16Z naoaki $ */

#ifndef __LBFGS_H__
#define __LBFGS_H__

#ifdef  __cplusplus
extern "C" {
#endif/*__cplusplus*/

/*
 * The default precision of floating point values is 64bit (double).
 */
#ifndef LBFGS_FLOAT
#define LBFGS_FLOAT     64
#endif/*LBFGS_FLOAT*/

/*
 * Activate optimization routines for IEEE754 floating point values.
 */
#ifndef LBFGS_IEEE_FLOAT
#define LBFGS_IEEE_FLOAT    1
#endif/*LBFGS_IEEE_FLOAT*/

#if     LBFGS_FLOAT == 32
typedef float lbfgsfloatval_t;

#elif   LBFGS_FLOAT == 64
typedef double lbfgsfloatval_t;

#else
#error "libLBFGS supports single (float; LBFGS_FLOAT = 32) or double (double; LBFGS_FLOAT=64) precision only."

#endif


/** 
 * \addtogroup liblbfgs_api libLBFGS API
 * @{
 *
 *  The libLBFGS API.
 */

/**
 * Return values of lbfgs().
 * 
 *  Roughly speaking, a negative value indicates an error.
 */
enum {
    /** L-BFGS reaches convergence. */
    LBFGS_SUCCESS = 0,
    LBFGS_CONVERGENCE = 0,
    LBFGS_STOP,
    /** The initial variables already minimize the objective function. */
    LBFGS_ALREADY_MINIMIZED,

    /** Unknown error. */
    LBFGSERR_UNKNOWNERROR = -1024,
    /** Logic error. */
    LBFGSERR_LOGICERROR,
    /** Insufficient memory. */
    LBFGSERR_OUTOFMEMORY,
    /** The minimization process has been canceled. */
    LBFGSERR_CANCELED,
    /** Invalid number of variables specified. */
    LBFGSERR_INVALID_N,
    /** Invalid number of variables (for SSE) specified. */
    LBFGSERR_INVALID_N_SSE,
    /** The array x must be aligned to 16 (for SSE). */
    LBFGSERR_INVALID_X_SSE,
    /** Invalid parameter lbfgs_parameter_t::epsilon specified. */
    LBFGSERR_INVALID_EPSILON,
    /** Invalid parameter lbfgs_parameter_t::past specified. */
    LBFGSERR_INVALID_TESTPERIOD,
    /** Invalid parameter lbfgs_parameter_t::delta specified. */
    LBFGSERR_INVALID_DELTA,
    /** Invalid parameter lbfgs_parameter_t::linesearch specified. */
    LBFGSERR_INVALID_LINESEARCH,
    /** Invalid parameter lbfgs_parameter_t::max_step specified. */
    LBFGSERR_INVALID_MINSTEP,
    /** Invalid parameter lbfgs_parameter_t::max_step specified. */
    LBFGSERR_INVALID_MAXSTEP,
    /** Invalid parameter lbfgs_parameter_t::ftol specified. */
    LBFGSERR_INVALID_FTOL,
    /** Invalid parameter lbfgs_parameter_t::wolfe specified. */
    LBFGSERR_INVALID_WOLFE,
    /** Invalid parameter lbfgs_parameter_t::gtol specified. */
    LBFGSERR_INVALID_GTOL,
    /** Invalid parameter lbfgs_parameter_t::xtol specified. */
    LBFGSERR_INVALID_XTOL,
    /** Invalid parameter lbfgs_parameter_t::max_linesearch specified. */
    LBFGSERR_INVALID_MAXLINESEARCH,
    /** Invalid parameter lbfgs_parameter_t::orthantwise_c specified. */
    LBFGSERR_INVALID_ORTHANTWISE,
    /** Invalid parameter lbfgs_parameter_t::orthantwise_start specified. */
    LBFGSERR_INVALID_ORTHANTWISE_START,
    /** Invalid parameter lbfgs_parameter_t::orthantwise_end specified. */
    LBFGSERR_INVALID_ORTHANTWISE_END,
    /** The line-search step went out of the interval of uncertainty. */
    LBFGSERR_OUTOFINTERVAL,
    /** A logic error occurred; alternatively, the interval of uncertainty
        became too small. */
    LBFGSERR_INCORRECT_TMINMAX,
    /** A rounding error occurred; alternatively, no line-search step
        satisfies the sufficient decrease and curvature conditions. */
    LBFGSERR_ROUNDING_ERROR,
    /** The line-search step became smaller than lbfgs_parameter_t::min_step. */
    LBFGSERR_MINIMUMSTEP,
    /** The line-search step became larger than lbfgs_parameter_t::max_step. */
    LBFGSERR_MAXIMUMSTEP,
    /** The line-search routine reaches the maximum number of evaluations. */
    LBFGSERR_MAXIMUMLINESEARCH,
    /** The algorithm routine reaches the maximum number of iterations. */
    LBFGSERR_MAXIMUMITERATION,
    /** Relative width of the interval of uncertainty is at most
        lbfgs_parameter_t::xtol. */
    LBFGSERR_WIDTHTOOSMALL,
    /** A logic error (negative line-search step) occurred. */
    LBFGSERR_INVALIDPARAMETERS,
    /** The current search direction increases the objective function value. */
    LBFGSERR_INCREASEGRADIENT,
};

/**
 * Line search algorithms.
 */
enum {
    /** The default algorithm (MoreThuente method). */
    LBFGS_LINESEARCH_DEFAULT = 0,
    /** MoreThuente method proposd by More and Thuente. */
    LBFGS_LINESEARCH_MORETHUENTE = 0,
    /**
     * Backtracking method with the Armijo condition.
     *  The backtracking method finds the step length such that it satisfies
     *  the sufficient decrease (Armijo) condition,
     *    - f(x + a * d) <= f(x) + lbfgs_parameter_t::ftol * a * g(x)^T d,
     *
     *  where x is the current point, d is the current search direction, and
     *  a is the step length.
     */
    LBFGS_LINESEARCH_BACKTRACKING_ARMIJO = 1,
    /** The backtracking method with the defualt (regular Wolfe) condition. */
    LBFGS_LINESEARCH_BACKTRACKING = 2,
    /**
     * Backtracking method with regular Wolfe condition.
     *  The backtracking method finds the step length such that it satisfies
     *  both the Armijo condition (LBFGS_LINESEARCH_BACKTRACKING_ARMIJO)
     *  and the curvature condition,
     *    - g(x + a * d)^T d >= lbfgs_parameter_t::wolfe * g(x)^T d,
     *
     *  where x is the current point, d is the current search direction, and
     *  a is the step length.
     */
    LBFGS_LINESEARCH_BACKTRACKING_WOLFE = 2,
    /**
     * Backtracking method with strong Wolfe condition.
     *  The backtracking method finds the step length such that it satisfies
     *  both the Armijo condition (LBFGS_LINESEARCH_BACKTRACKING_ARMIJO)
     *  and the following condition,
     *    - |g(x + a * d)^T d| <= lbfgs_parameter_t::wolfe * |g(x)^T d|,
     *
     *  where x is the current point, d is the current search direction, and
     *  a is the step length.
     */
    LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE = 3,
};

/**
 * L-BFGS optimization parameters.
 *  Call lbfgs_parameter_init() function to initialize parameters to the
 *  default values.
 */
typedef struct {
    /**
     * The number of corrections to approximate the inverse hessian matrix.
     *  The L-BFGS routine stores the computation results of previous \ref m
     *  iterations to approximate the inverse hessian matrix of the current
     *  iteration. This parameter controls the size of the limited memories
     *  (corrections). The default value is \c 6. Values less than \c 3 are
     *  not recommended. Large values will result in excessive computing time.
     */
    int             m;

    /**
     * Epsilon for convergence test.
     *  This parameter determines the accuracy with which the solution is to
     *  be found. A minimization terminates when
     *      ||g|| < \ref epsilon * max(1, ||x||),
     *  where ||.|| denotes the Euclidean (L2) norm. The default value is
     *  \c 1e-5.
     */
    lbfgsfloatval_t epsilon;

    /**
     * Distance for delta-based convergence test.
     *  This parameter determines the distance, in iterations, to compute
     *  the rate of decrease of the objective function. If the value of this
     *  parameter is zero, the library does not perform the delta-based
     *  convergence test. The default value is \c 0.
     */
    int             past;

    /**
     * Delta for convergence test.
     *  This parameter determines the minimum rate of decrease of the
     *  objective function. The library stops iterations when the
     *  following condition is met:
     *      (f' - f) / f < \ref delta,
     *  where f' is the objective value of \ref past iterations ago, and f is
     *  the objective value of the current iteration.
     *  The default value is \c 0.
     */
    lbfgsfloatval_t delta;

    /**
     * The maximum number of iterations.
     *  The lbfgs() function terminates an optimization process with
     *  ::LBFGSERR_MAXIMUMITERATION status code when the iteration count
     *  exceedes this parameter. Setting this parameter to zero continues an
     *  optimization process until a convergence or error. The default value
     *  is \c 0.
     */
    int             max_iterations;

    /**
     * The line search algorithm.
     *  This parameter specifies a line search algorithm to be used by the
     *  L-BFGS routine.
     */
    int             linesearch;

    /**
     * The maximum number of trials for the line search.
     *  This parameter controls the number of function and gradients evaluations
     *  per iteration for the line search routine. The default value is \c 20.
     */
    int             max_linesearch;

    /**
     * The minimum step of the line search routine.
     *  The default value is \c 1e-20. This value need not be modified unless
     *  the exponents are too large for the machine being used, or unless the
     *  problem is extremely badly scaled (in which case the exponents should
     *  be increased).
     */
    lbfgsfloatval_t min_step;

    /**
     * The maximum step of the line search.
     *  The default value is \c 1e+20. This value need not be modified unless
     *  the exponents are too large for the machine being used, or unless the
     *  problem is extremely badly scaled (in which case the exponents should
     *  be increased).
     */
    lbfgsfloatval_t max_step;

    /**
     * A parameter to control the accuracy of the line search routine.
     *  The default value is \c 1e-4. This parameter should be greater
     *  than zero and smaller than \c 0.5.
     */
    lbfgsfloatval_t ftol;

    /**
     * A coefficient for the Wolfe condition.
     *  This parameter is valid only when the backtracking line-search
     *  algorithm is used with the Wolfe condition,
     *  ::LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE or
     *  ::LBFGS_LINESEARCH_BACKTRACKING_WOLFE .
     *  The default value is \c 0.9. This parameter should be greater
     *  the \ref ftol parameter and smaller than \c 1.0.
     */
    lbfgsfloatval_t wolfe;

    /**
     * A parameter to control the accuracy of the line search routine.
     *  The default value is \c 0.9. If the function and gradient
     *  evaluations are inexpensive with respect to the cost of the
     *  iteration (which is sometimes the case when solving very large
     *  problems) it may be advantageous to set this parameter to a small
     *  value. A typical small value is \c 0.1. This parameter shuold be
     *  greater than the \ref ftol parameter (\c 1e-4) and smaller than
     *  \c 1.0.
     */
    lbfgsfloatval_t gtol;

    /**
     * The machine precision for floating-point values.
     *  This parameter must be a positive value set by a client program to
     *  estimate the machine precision. The line search routine will terminate
     *  with the status code (::LBFGSERR_ROUNDING_ERROR) if the relative width
     *  of the interval of uncertainty is less than this parameter.
     */
    lbfgsfloatval_t xtol;

    /**
     * Coeefficient for the L1 norm of variables.
     *  This parameter should be set to zero for standard minimization
     *  problems. Setting this parameter to a positive value activates
     *  Orthant-Wise Limited-memory Quasi-Newton (OWL-QN) method, which
     *  minimizes the objective function F(x) combined with the L1 norm |x|
     *  of the variables, {F(x) + C |x|}. This parameter is the coeefficient
     *  for the |x|, i.e., C. As the L1 norm |x| is not differentiable at
     *  zero, the library modifies function and gradient evaluations from
     *  a client program suitably; a client program thus have only to return
     *  the function value F(x) and gradients G(x) as usual. The default value
     *  is zero.
     */
    lbfgsfloatval_t orthantwise_c;

    /**
     * Start index for computing L1 norm of the variables.
     *  This parameter is valid only for OWL-QN method
     *  (i.e., \ref orthantwise_c != 0). This parameter b (0 <= b < N)
     *  specifies the index number from which the library computes the
     *  L1 norm of the variables x,
     *      |x| := |x_{b}| + |x_{b+1}| + ... + |x_{N}| .
     *  In other words, variables x_1, ..., x_{b-1} are not used for
     *  computing the L1 norm. Setting b (0 < b < N), one can protect
     *  variables, x_1, ..., x_{b-1} (e.g., a bias term of logistic
     *  regression) from being regularized. The default value is zero.
     */
    int             orthantwise_start;

    /**
     * End index for computing L1 norm of the variables.
     *  This parameter is valid only for OWL-QN method
     *  (i.e., \ref orthantwise_c != 0). This parameter e (0 < e <= N)
     *  specifies the index number at which the library stops computing the
     *  L1 norm of the variables x,
     */
    int             orthantwise_end;
} lbfgs_parameter_t;


/**
 * Callback interface to provide objective function and gradient evaluations.
 *
 *  The lbfgs() function call this function to obtain the values of objective
 *  function and its gradients when needed. A client program must implement
 *  this function to evaluate the values of the objective function and its
 *  gradients, given current values of variables.
 *  
 *  @param  instance    The user data sent for lbfgs() function by the client.
 *  @param  x           The current values of variables.
 *  @param  g           The gradient vector. The callback function must compute
 *                      the gradient values for the current variables.
 *  @param  n           The number of variables.
 *  @param  step        The current step of the line search routine.
 *  @retval lbfgsfloatval_t The value of the objective function for the current
 *                          variables.
 */
typedef lbfgsfloatval_t (*lbfgs_evaluate_t)(
    void *instance,
    const lbfgsfloatval_t *x,
    lbfgsfloatval_t *g,
    const int n,
    const lbfgsfloatval_t step
    );

/**
 * Callback interface to receive the progress of the optimization process.
 *
 *  The lbfgs() function call this function for each iteration. Implementing
 *  this function, a client program can store or display the current progress
 *  of the optimization process.
 *
 *  @param  instance    The user data sent for lbfgs() function by the client.
 *  @param  x           The current values of variables.
 *  @param  g           The current gradient values of variables.
 *  @param  fx          The current value of the objective function.
 *  @param  xnorm       The Euclidean norm of the variables.
 *  @param  gnorm       The Euclidean norm of the gradients.
 *  @param  step        The line-search step used for this iteration.
 *  @param  n           The number of variables.
 *  @param  k           The iteration count.
 *  @param  ls          The number of evaluations called for this iteration.
 *  @retval int         Zero to continue the optimization process. Returning a
 *                      non-zero value will cancel the optimization process.
 */
typedef int (*lbfgs_progress_t)(
    void *instance,
    const lbfgsfloatval_t *x,
    const lbfgsfloatval_t *g,
    const lbfgsfloatval_t fx,
    const lbfgsfloatval_t xnorm,
    const lbfgsfloatval_t gnorm,
    const lbfgsfloatval_t step,
    int n,
    int k,
    int ls
    );

/*
A user must implement a function compatible with ::lbfgs_evaluate_t (evaluation
callback) and pass the pointer to the callback function to lbfgs() arguments.
Similarly, a user can implement a function compatible with ::lbfgs_progress_t
(progress callback) to obtain the current progress (e.g., variables, function
value, ||G||, etc) and to cancel the iteration process if necessary.
Implementation of a progress callback is optional: a user can pass \c NULL if
progress notification is not necessary.

In addition, a user must preserve two requirements:
    - The number of variables must be multiples of 16 (this is not 4).
    - The memory block of variable array ::x must be aligned to 16.

This algorithm terminates an optimization
when:

    ||G|| < \epsilon \cdot \max(1, ||x||) .

In this formula, ||.|| denotes the Euclidean norm.
*/

/**
 * Start a L-BFGS optimization.
 *
 *  @param  n           The number of variables.
 *  @param  x           The array of variables. A client program can set
 *                      default values for the optimization and receive the
 *                      optimization result through this array. This array
 *                      must be allocated by ::lbfgs_malloc function
 *                      for libLBFGS built with SSE/SSE2 optimization routine
 *                      enabled. The library built without SSE/SSE2
 *                      optimization does not have such a requirement.
 *  @param  ptr_fx      The pointer to the variable that receives the final
 *                      value of the objective function for the variables.
 *                      This argument can be set to \c NULL if the final
 *                      value of the objective function is unnecessary.
 *  @param  proc_evaluate   The callback function to provide function and
 *                          gradient evaluations given a current values of
 *                          variables. A client program must implement a
 *                          callback function compatible with \ref
 *                          lbfgs_evaluate_t and pass the pointer to the
 *                          callback function.
 *  @param  proc_progress   The callback function to receive the progress
 *                          (the number of iterations, the current value of
 *                          the objective function) of the minimization
 *                          process. This argument can be set to \c NULL if
 *                          a progress report is unnecessary.
 *  @param  instance    A user data for the client program. The callback
 *                      functions will receive the value of this argument.
 *  @param  param       The pointer to a structure representing parameters for
 *                      L-BFGS optimization. A client program can set this
 *                      parameter to \c NULL to use the default parameters.
 *                      Call lbfgs_parameter_init() function to fill a
 *                      structure with the default values.
 *  @retval int         The status code. This function returns zero if the
 *                      minimization process terminates without an error. A
 *                      non-zero value indicates an error.
 */
int lbfgs(
    int n,
    lbfgsfloatval_t *x,
    lbfgsfloatval_t *ptr_fx,
    lbfgs_evaluate_t proc_evaluate,
    lbfgs_progress_t proc_progress,
    void *instance,
    lbfgs_parameter_t *param
    );

/**
 * Initialize L-BFGS parameters to the default values.
 *
 *  Call this function to fill a parameter structure with the default values
 *  and overwrite parameter values if necessary.
 *
 *  @param  param       The pointer to the parameter structure.
 */
void lbfgs_parameter_init(lbfgs_parameter_t *param);

/**
 * Allocate an array for variables.
 *
 *  This function allocates an array of variables for the convenience of
 *  ::lbfgs function; the function has a requreiemt for a variable array
 *  when libLBFGS is built with SSE/SSE2 optimization routines. A user does
 *  not have to use this function for libLBFGS built without SSE/SSE2
 *  optimization.
 *  
 *  @param  n           The number of variables.
 */
lbfgsfloatval_t* lbfgs_malloc(int n);

/**
 * Free an array of variables.
 *  
 *  @param  x           The array of variables allocated by ::lbfgs_malloc
 *                      function.
 */
void lbfgs_free(lbfgsfloatval_t *x);

/** @} */

#ifdef  __cplusplus
}
#endif/*__cplusplus*/



/**
@mainpage libLBFGS: a library of Limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS)

@section intro Introduction

This library is a C port of the implementation of Limited-memory
Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) method written by Jorge Nocedal.
The original FORTRAN source code is available at:
http://www.ece.northwestern.edu/~nocedal/lbfgs.html

The L-BFGS method solves the unconstrainted minimization problem,


    minimize F(x), x = (x1, x2, ..., xN),



only if the objective function F(x) and its gradient G(x) are computable. The
well-known Newton's method requires computation of the inverse of the hessian
matrix of the objective function. However, the computational cost for the
inverse hessian matrix is expensive especially when the objective function
takes a large number of variables. The L-BFGS method iteratively finds a
minimizer by approximating the inverse hessian matrix by information from last
m iterations. This innovation saves the memory storage and computational time
drastically for large-scaled problems.

Among the various ports of L-BFGS, this library provides several features:
- Optimization with L1-norm (Orthant-Wise Limited-memory Quasi-Newton
  (OWL-QN) method):
  In addition to standard minimization problems, the library can minimize
  a function F(x) combined with L1-norm |x| of the variables,
  {F(x) + C |x|}, where C is a constant scalar parameter. This feature is
  useful for estimating parameters of sparse log-linear models (e.g.,
  logistic regression and maximum entropy) with L1-regularization (or
  Laplacian prior).
- Clean C code:
  Unlike C codes generated automatically by f2c (Fortran 77 into C converter),
  this port includes changes based on my interpretations, improvements,
  optimizations, and clean-ups so that the ported code would be well-suited
  for a C code. In addition to comments inherited from the original code,
  a number of comments were added through my interpretations.
- Callback interface:
  The library receives function and gradient values via a callback interface.
  The library also notifies the progress of the optimization by invoking a
  callback function. In the original implementation, a user had to set
  function and gradient values every time the function returns for obtaining
  updated values.
- Thread safe:
  The library is thread-safe, which is the secondary gain from the callback
  interface.
- Cross platform. The source code can be compiled on Microsoft Visual
  Studio 2005, GNU C Compiler (gcc), etc.
- Configurable precision: A user can choose single-precision (float)
  or double-precision (double) accuracy by changing ::LBFGS_FLOAT macro.
- SSE/SSE2 optimization:
  This library includes SSE/SSE2 optimization (written in compiler intrinsics)
  for vector arithmetic operations on Intel/AMD processors. The library uses
  SSE for float values and SSE2 for double values. The SSE/SSE2 optimization
  routine is disabled by default.

This library is used by:
- CRFsuite: A fast implementation of Conditional Random Fields (CRFs)
- Classias: A collection of machine-learning algorithms for classification
- mlegp: an R package for maximum likelihood estimates for Gaussian processes
- imaging2: the imaging2 class library
- Algorithm::LBFGS - Perl extension for L-BFGS
- YAP-LBFGS (an interface to call libLBFGS from YAP Prolog)

@section download Download

- Source code

libLBFGS is distributed under the term of the
MIT license.

@section changelog History
- Version 1.9 (2010-01-29):
    - Fixed a mistake in checking the validity of the parameters "ftol" and
      "wolfe"; this was discovered by Kevin S. Van Horn.
- Version 1.8 (2009-07-13):
    - Accepted the patch submitted by Takashi Imamichi;
      the backtracking method now has three criteria for choosing the step
      length:
        - ::LBFGS_LINESEARCH_BACKTRACKING_ARMIJO: sufficient decrease (Armijo)
          condition only
        - ::LBFGS_LINESEARCH_BACKTRACKING_WOLFE: regular Wolfe condition
          (sufficient decrease condition + curvature condition)
        - ::LBFGS_LINESEARCH_BACKTRACKING_STRONG_WOLFE: strong Wolfe condition
    - Updated the documentation to explain the above three criteria.
- Version 1.7 (2009-02-28):
    - Improved OWL-QN routines for stability.
    - Removed the support of OWL-QN method in MoreThuente algorithm because
      it accidentally fails in early stages of iterations for some objectives.
      Because of this change, the OW-LQN method must be used with the
      backtracking algorithm (::LBFGS_LINESEARCH_BACKTRACKING), or the
      library returns ::LBFGSERR_INVALID_LINESEARCH.
    - Renamed line search algorithms as follows:
        - ::LBFGS_LINESEARCH_BACKTRACKING: regular Wolfe condition.
        - ::LBFGS_LINESEARCH_BACKTRACKING_LOOSE: regular Wolfe condition.
        - ::LBFGS_LINESEARCH_BACKTRACKING_STRONG: strong Wolfe condition.
    - Source code clean-up.
- Version 1.6 (2008-11-02):
    - Improved line-search algorithm with strong Wolfe condition, which was
      contributed by Takashi Imamichi. This routine is now default for
      ::LBFGS_LINESEARCH_BACKTRACKING. The previous line search algorithm
      with regular Wolfe condition is still available as
      ::LBFGS_LINESEARCH_BACKTRACKING_LOOSE.
    - Configurable stop index for L1-norm computation. A member variable
      ::lbfgs_parameter_t::orthantwise_end was added to specify the index
      number at which the library stops computing the L1 norm of the
      variables. This is useful to prevent some variables from being
      regularized by the OW-LQN method.
    - A sample program written in C++ (sample/sample.cpp).
- Version 1.5 (2008-07-10):
    - Configurable starting index for L1-norm computation. A member variable
      ::lbfgs_parameter_t::orthantwise_start was added to specify the index
      number from which the library computes the L1 norm of the variables.
      This is useful to prevent some variables from being regularized by the
      OWL-QN method.
    - Fixed a zero-division error when the initial variables have already
      been a minimizer (reported by Takashi Imamichi). In this case, the
      library returns ::LBFGS_ALREADY_MINIMIZED status code.
    - Defined ::LBFGS_SUCCESS status code as zero; removed unused constants,
      LBFGSFALSE and LBFGSTRUE.
    - Fixed a compile error in an implicit down-cast.
- Version 1.4 (2008-04-25):
    - Configurable line search algorithms. A member variable
      ::lbfgs_parameter_t::linesearch was added to choose either MoreThuente
      method (::LBFGS_LINESEARCH_MORETHUENTE) or backtracking algorithm
      (::LBFGS_LINESEARCH_BACKTRACKING).
    - Fixed a bug: the previous version did not compute psuedo-gradients
      properly in the line search routines for OWL-QN. This bug might quit
      an iteration process too early when the OWL-QN routine was activated
      (0 < ::lbfgs_parameter_t::orthantwise_c).
    - Configure script for POSIX environments.
    - SSE/SSE2 optimizations with GCC.
    - New functions ::lbfgs_malloc and ::lbfgs_free to use SSE/SSE2 routines
      transparently. It is uncessary to use these functions for libLBFGS built
      without SSE/SSE2 routines; you can still use any memory allocators if
      SSE/SSE2 routines are disabled in libLBFGS.
- Version 1.3 (2007-12-16):
    - An API change. An argument was added to lbfgs() function to receive the
      final value of the objective function. This argument can be set to
      \c NULL if the final value is unnecessary.
    - Fixed a null-pointer bug in the sample code (reported by Takashi Imamichi).
    - Added build scripts for Microsoft Visual Studio 2005 and GCC.
    - Added README file.
- Version 1.2 (2007-12-13):
    - Fixed a serious bug in orthant-wise L-BFGS.
      An important variable was used without initialization.
- Version 1.1 (2007-12-01):
    - Implemented orthant-wise L-BFGS.
    - Implemented lbfgs_parameter_init() function.
    - Fixed several bugs.
    - API documentation.
- Version 1.0 (2007-09-20):
    - Initial release.

@section api Documentation

- @ref liblbfgs_api "libLBFGS API"

@section sample Sample code

@include sample.c

@section ack Acknowledgements

The L-BFGS algorithm is described in:
    - Jorge Nocedal.
      Updating Quasi-Newton Matrices with Limited Storage.
      Mathematics of Computation, Vol. 35, No. 151, pp. 773--782, 1980.
    - Dong C. Liu and Jorge Nocedal.
      On the limited memory BFGS method for large scale optimization.
      Mathematical Programming B, Vol. 45, No. 3, pp. 503-528, 1989.

The line search algorithms used in this implementation are described in:
    - John E. Dennis and Robert B. Schnabel.
      Numerical Methods for Unconstrained Optimization and Nonlinear
      Equations, Englewood Cliffs, 1983.
    - Jorge J. More and David J. Thuente.
      Line search algorithm with guaranteed sufficient decrease.
      ACM Transactions on Mathematical Software (TOMS), Vol. 20, No. 3,
      pp. 286-307, 1994.

This library also implements Orthant-Wise Limited-memory Quasi-Newton (OWL-QN)
method presented in:
    - Galen Andrew and Jianfeng Gao.
      Scalable training of L1-regularized log-linear models.
      In Proceedings of the 24th International Conference on Machine
      Learning (ICML 2007), pp. 33-40, 2007.

Special thanks go to:
    - Yoshimasa Tsuruoka and Daisuke Okanohara for technical information about
      OWL-QN
    - Takashi Imamichi for the useful enhancements of the backtracking method

Finally I would like to thank the original author, Jorge Nocedal, who has been
distributing the effieicnt and explanatory implementation in an open source
licence.

@section reference Reference

- L-BFGS by Jorge Nocedal.
- Orthant-Wise Limited-memory Quasi-Newton Optimizer for L1-regularized Objectives by Galen Andrew.
- C port (via f2c) by Taku Kudo.
- C#/C++/Delphi/VisualBasic6 port in ALGLIB.
- Computational Crystallography Toolbox includes
  scitbx::lbfgs.
*/

#endif/*__LBFGS_H__*/
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/mt.c0000644000175100001710000000513300000000000023053 0ustar00runnerdocker00000000000000/* mt.c
 *
 * Mersenne Twister random number generator, based on the implementation of
 * Michael Brundage (which has been placed in the public domain).
 *
 * Author: Tamas Nepusz (original by Michael Brundage)
 *
 * See the following URL for the original implementation:
 * http://www.qbrundage.com/michaelb/pubs/essays/random_number_generation.html
 *
 * This file has been placed in the public domain.
 */

#include 

#include "igraph_random.h"

#include "plfit_mt.h"

static uint16_t get_random_uint16() {
    return RNG_INT31() & 0xFFFF;
}

void plfit_mt_init(plfit_mt_rng_t* rng) {
    plfit_mt_init_from_rng(rng, 0);
}

void plfit_mt_init_from_rng(plfit_mt_rng_t* rng, plfit_mt_rng_t* seeder) {
    int i;

    if (seeder == 0) {
        for (i = 0; i < PLFIT_MT_LEN; i++) {
            /* RAND_MAX is guaranteed to be at least 32767, so we can use two
             * calls to rand() to produce a random 32-bit number */
            rng->mt_buffer[i] = (get_random_uint16() << 16) + get_random_uint16();
        }
    } else {
        for (i = 0; i < PLFIT_MT_LEN; i++) {
            rng->mt_buffer[i] = plfit_mt_random(seeder);
        }
    }

    rng->mt_index = 0;
}

#define MT_IA           397
#define MT_IB           (PLFIT_MT_LEN - MT_IA)
#define UPPER_MASK      0x80000000
#define LOWER_MASK      0x7FFFFFFF
#define MATRIX_A        0x9908B0DF
#define TWIST(b,i,j)    ((b)[i] & UPPER_MASK) | ((b)[j] & LOWER_MASK)
#define MAGIC(s)        (((s)&1)*MATRIX_A)

uint32_t plfit_mt_random(plfit_mt_rng_t* rng) {
    uint32_t * b = rng->mt_buffer;
    int idx = rng->mt_index;
    uint32_t s;
    int i;
	
    if (idx == PLFIT_MT_LEN * sizeof(uint32_t)) {
        idx = 0;
        i = 0;
        for (; i < MT_IB; i++) {
            s = TWIST(b, i, i+1);
            b[i] = b[i + MT_IA] ^ (s >> 1) ^ MAGIC(s);
        }
        for (; i < PLFIT_MT_LEN-1; i++) {
            s = TWIST(b, i, i+1);
            b[i] = b[i - MT_IB] ^ (s >> 1) ^ MAGIC(s);
        }
        
        s = TWIST(b, PLFIT_MT_LEN-1, 0);
        b[PLFIT_MT_LEN-1] = b[MT_IA-1] ^ (s >> 1) ^ MAGIC(s);
    }

    rng->mt_index = idx + sizeof(uint32_t);
    return *(uint32_t *)((unsigned char *)b + idx);
    /*
    Matsumoto and Nishimura additionally confound the bits returned to the caller
    but this doesn't increase the randomness, and slows down the generator by
    as much as 25%.  So I omit these operations here.
    
    r ^= (r >> 11);
    r ^= (r << 7) & 0x9D2C5680;
    r ^= (r << 15) & 0xEFC60000;
    r ^= (r >> 18);
    */
}


double plfit_mt_uniform_01(plfit_mt_rng_t* rng) {
    return ((double)plfit_mt_random(rng)) / PLFIT_MT_RAND_MAX;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/options.c0000644000175100001710000000336000000000000024126 0ustar00runnerdocker00000000000000/* options.c
 *
 * Copyright (C) 2012 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "plfit_error.h"
#include "plfit.h"

const plfit_continuous_options_t plfit_continuous_default_options = {
    /* .finite_size_correction = */ 0,
    /* .xmin_method = */ PLFIT_DEFAULT_CONTINUOUS_METHOD,
    /* .p_value_method = */ PLFIT_DEFAULT_P_VALUE_METHOD,
    /* .p_value_precision = */ 0.01,
    /* .rng = */ 0
};

const plfit_discrete_options_t plfit_discrete_default_options = {
    /* .finite_size_correction = */ 0,
    /* .alpha_method = */ PLFIT_DEFAULT_DISCRETE_METHOD,
    /* .alpha = */ {
        /* .min = */ 1.01,
        /* .max = */ 5,
        /* .step = */ 0.01
    },
    /* .p_value_method = */ PLFIT_DEFAULT_P_VALUE_METHOD,
    /* .p_value_precision = */ 0.01,
    /* .rng = */ 0
};

int plfit_continuous_options_init(plfit_continuous_options_t* options) {
	*options = plfit_continuous_default_options;
	return PLFIT_SUCCESS;
}

int plfit_discrete_options_init(plfit_discrete_options_t* options) {
	*options = plfit_discrete_default_options;
	return PLFIT_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/platform.c0000644000175100001710000000211300000000000024252 0ustar00runnerdocker00000000000000/* platform.c
 *
 * Copyright (C) 2014 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "platform.h"

#ifdef _MSC_VER

inline double _plfit_fmin(double a, double b) {
	return (a < b) ? a : b;
}

inline double _plfit_round(double x) {
	return floor(x+0.5);
}

#endif

/* Dummy function to prevent a warning when compiling with Clang - the file
 * would contain no symbols */
void _plfit_i_unused() {}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/platform.h0000644000175100001710000000306400000000000024265 0ustar00runnerdocker00000000000000/* platform.h
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __PLATFORM_H__
#define __PLATFORM_H__

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

#include 

__BEGIN_DECLS

#ifdef _MSC_VER
#include 

#define snprintf _snprintf
#define inline  __inline

#ifndef isfinite
#  define isfinite(x) _finite(x)
#endif

extern double _plfit_fmin(double a, double b);
extern double _plfit_round(double x);

#define fmin _plfit_fmin
#define round _plfit_round

#endif /* _MSC_VER */

#ifndef isnan
#  define isnan(x) ((x) != (x))
#endif

#ifndef INFINITY
#  define INFINITY (1.0/0.0)
#endif

#ifndef NAN
#  define NAN ((double)0.0 / (double)DBL_MIN)
#endif

__END_DECLS

#endif /* __PLATFORM_H__ */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit.c0000644000175100001710000012442100000000000023553 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=4 sts=4 et: */
/* plfit.c
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include "plfit_error.h"
#include "gss.h"
#include "lbfgs.h"
#include "platform.h"
#include "plfit.h"
#include "kolmogorov.h"
#include "plfit_sampling.h"
#include "hzeta.h"

/* #define PLFIT_DEBUG */

#define DATA_POINTS_CHECK \
    if (n <= 0) { \
        PLFIT_ERROR("no data points", PLFIT_EINVAL); \
    }

#define XMIN_CHECK_ZERO \
    if (xmin <= 0) { \
        PLFIT_ERROR("xmin must be greater than zero", PLFIT_EINVAL); \
    }
#define XMIN_CHECK_ONE \
    if (xmin < 1) { \
        PLFIT_ERROR("xmin must be at least 1", PLFIT_EINVAL); \
    }

static int plfit_i_resample_continuous(double* xs_head, size_t num_smaller,
        size_t n, double alpha, double xmin, size_t num_samples, plfit_mt_rng_t* rng,
        double* result);
static int plfit_i_resample_discrete(double* xs_head, size_t num_smaller,
        size_t n, double alpha, double xmin, size_t num_samples, plfit_mt_rng_t* rng,
        double* result);

static int double_comparator(const void *a, const void *b) {
    const double *da = (const double*)a;
    const double *db = (const double*)b;
    return (*da > *db) - (*da < *db);
}

static int plfit_i_copy_and_sort(double* xs, size_t n, double** result) {
    *result = (double*)malloc(sizeof(double) * n);
    if (*result == 0) {
        PLFIT_ERROR("cannot create sorted copy of input data", PLFIT_ENOMEM);
    }

    memcpy(*result, xs, sizeof(double) * n);
    qsort(*result, n, sizeof(double), double_comparator);

    return PLFIT_SUCCESS;
}

/**
 * Given an unsorted array of doubles, counts how many elements there are that
 * are smaller than a given value.
 *
 * \param  begin          pointer to the beginning of the array
 * \param  end            pointer to the first element after the end of the array
 * \param  xmin           the threshold value
 *
 * \return the nubmer of elements in the array that are smaller than the given
 *         value.
 */
static size_t count_smaller(double* begin, double* end, double xmin) {
    double* p;
    size_t counter = 0;

    for (p = begin; p < end; p++) {
        if (*p < xmin) {
            counter++;
        }
    }

    return counter;
}

/**
 * Given an unsorted array of doubles, return another array that contains the
 * elements that are smaller than a given value
 *
 * \param  begin          pointer to the beginning of the array
 * \param  end            pointer to the first element after the end of the array
 * \param  xmin           the threshold value
 * \param  result_length  if not \c NULL, the number of unique elements in the
 *                        given array is returned here
 *
 * \return pointer to the head of the new array or 0 if there is not enough
 * memory
 */
static double* extract_smaller(double* begin, double* end, double xmin,
        size_t* result_length) {
    size_t counter = count_smaller(begin, end, xmin);
    double *p, *result;

    result = calloc(counter, sizeof(double));
    if (result == 0)
        return 0;

    for (p = result; begin < end; begin++) {
        if (*begin < xmin) {
            *p = *begin;
            p++;
        }
    }

    if (result_length) {
        *result_length = counter;
    }

    return result;
}

/**
 * Given a sorted array of doubles, return another array that contains pointers
 * into the array for the start of each block of identical elements.
 *
 * \param  begin          pointer to the beginning of the array
 * \param  end            pointer to the first element after the end of the array
 * \param  result_length  if not \c NULL, the number of unique elements in the
 *                        given array is returned here. It is left unchanged if
 *                        the function returns with an error.
 *
 * \return pointer to the head of the new array or 0 if there is not enough
 * memory
 */
static double** unique_element_pointers(double* begin, double* end, size_t* result_length) {
    double* ptr = begin;
    double** result;
    double prev_x;
    size_t num_elts = 15;
    size_t used_elts = 0;

    /* Special case: empty array */
    if (begin == end) {
        result = calloc(1, sizeof(double*));
        if (result != 0) {
            result[0] = 0;
            if (result_length != 0) {
                *result_length = 0;
            }
        }
        return result;
    }

    /* Allocate initial result array, including the guard element */
    result = calloc(num_elts+1, sizeof(double*));
    if (result == 0)
        return 0;

    prev_x = *begin;
    result[used_elts++] = begin;

    /* Process the input array */
    for (ptr = begin+1; ptr < end; ptr++) {
        if (*ptr == prev_x)
            continue;

        /* New block found */
        if (used_elts >= num_elts) {
            /* Array full; allocate a new chunk */
            num_elts = num_elts*2 + 1;
            result = realloc(result, sizeof(double*) * (num_elts+1));
            if (result == 0)
                return 0;
        }

        /* Store the new element */
        result[used_elts++] = ptr;
        prev_x = *ptr;
    }

    /* Calculate the result length */
    if (result_length != 0) {
        *result_length = used_elts;
    }

    /* Add the guard entry to the end of the result */
    result[used_elts++] = 0;

    return result;
}

static void plfit_i_perform_finite_size_correction(plfit_result_t* result, size_t n) {
    result->alpha = result->alpha * (n-1) / n + 1.0 / n;
}

/********** Continuous power law distribution fitting **********/

static void plfit_i_logsum_less_than_continuous(double* begin, double* end,
        double xmin, double* result, size_t* m) {
    double logsum = 0.0;
    size_t count = 0;

    for (; begin != end; begin++) {
        if (*begin >= xmin) {
            count++;
            logsum += log(*begin / xmin);
        }
    }

    *m = count;
    *result = logsum;
}

static double plfit_i_logsum_continuous(double* begin, double* end, double xmin) {
    double logsum = 0.0;
    for (; begin != end; begin++)
        logsum += log(*begin / xmin);
    return logsum;
}

static int plfit_i_estimate_alpha_continuous(double* xs, size_t n,
        double xmin, double* alpha) {
    double result;
    size_t m;

    XMIN_CHECK_ZERO;

    plfit_i_logsum_less_than_continuous(xs, xs+n, xmin, &result, &m);

    if (m == 0) {
        PLFIT_ERROR("no data point was larger than xmin", PLFIT_EINVAL);
    }

    *alpha = 1 + m / result;

    return PLFIT_SUCCESS;
}

static int plfit_i_estimate_alpha_continuous_sorted(double* xs, size_t n,
        double xmin, double* alpha) {
    double* end = xs+n;

    XMIN_CHECK_ZERO;

    for (; xs != end && *xs < xmin; xs++);
    if (xs == end) {
        PLFIT_ERROR("no data point was larger than xmin", PLFIT_EINVAL);
    }

    *alpha = 1 + (end-xs) / plfit_i_logsum_continuous(xs, end, xmin);

    return PLFIT_SUCCESS;
}

static int plfit_i_ks_test_continuous(double* xs, double* xs_end,
        const double alpha, const double xmin, double* D) {
    /* Assumption: xs is sorted and cut off at xmin so the first element is
     * always larger than or equal to xmin. */
    double result = 0, n;
    int m = 0;

    n = xs_end - xs;

    while (xs < xs_end) {
        double d = fabs(1-pow(xmin / *xs, alpha-1) - m / n);

        if (d > result)
            result = d;

        xs++; m++;
    }

    *D = result;

    return PLFIT_SUCCESS;
}

static int plfit_i_calculate_p_value_continuous(double* xs, size_t n,
        const plfit_continuous_options_t *options, plfit_bool_t xmin_fixed,
        plfit_result_t *result) {
    long int num_trials;
    long int successes = 0;
    double *xs_head;
    size_t num_smaller;
    plfit_continuous_options_t options_no_p_value = *options;
    int retval = PLFIT_SUCCESS;

    if (options->p_value_method == PLFIT_P_VALUE_SKIP) {
        result->p = NAN;
        return PLFIT_SUCCESS;
    }

    if (options->p_value_method == PLFIT_P_VALUE_APPROXIMATE) {
        num_smaller = count_smaller(xs, xs + n, result->xmin);
        result->p = plfit_ks_test_one_sample_p(result->D, n - num_smaller);
        return PLFIT_SUCCESS;
    }

    options_no_p_value.p_value_method = PLFIT_P_VALUE_SKIP;
    num_trials = (long int)(0.25 / options->p_value_precision / options->p_value_precision);
    if (num_trials <= 0) {
        PLFIT_ERROR("invalid p-value precision", PLFIT_EINVAL);
    }

    /* Extract the head of xs that contains elements smaller than xmin */
    xs_head = extract_smaller(xs, xs+n, result->xmin, &num_smaller);
    if (xs_head == 0)
        PLFIT_ERROR("cannot calculate exact p-value", PLFIT_ENOMEM);

#ifdef _OPENMP
#pragma omp parallel
#endif
    {
        /* Parallel section starts here. If we are compiling using OpenMP, each
         * thread will use its own RNG that is seeded from the master RNG. If
         * we are compiling without OpenMP, there is only one thread and it uses
         * the master RNG. This section must be critical to ensure that only one
         * thread is using the master RNG at the same time. */
#ifdef _OPENMP
        plfit_mt_rng_t private_rng;
#endif
        plfit_mt_rng_t *p_rng;
        double *ys;
        long int i;
        plfit_result_t result_synthetic;

#ifdef _OPENMP
#pragma omp critical
        {
            p_rng = &private_rng;
            plfit_mt_init_from_rng(p_rng, options->rng);
        }
#else
        p_rng = options->rng;
#endif

        /* Allocate memory to sample into */
        ys = calloc(n, sizeof(double));
        if (ys == 0) {
            retval = PLFIT_ENOMEM;
        } else {
            /* The main for loop starts here. */
#ifdef _OPENMP
#pragma omp for reduction(+:successes)
#endif
            for (i = 0; i < num_trials; i++) {
                plfit_i_resample_continuous(xs_head, num_smaller, n, result->alpha,
                        result->xmin, n, p_rng, ys);
                if (xmin_fixed) {
                    plfit_estimate_alpha_continuous(ys, n, result->xmin,
                                &options_no_p_value, &result_synthetic);
                } else {
                    plfit_continuous(ys, n, &options_no_p_value, &result_synthetic);
                }
                if (result_synthetic.D > result->D)
                    successes++;
            }
            free(ys);
        }

        /* End of parallelized part */
    }

    free(xs_head);

    if (retval == PLFIT_SUCCESS) {
        result->p = successes / ((double)num_trials);
    } else {
        PLFIT_ERROR("cannot calculate exact p-value", retval);
    }

    return retval;
}

int plfit_log_likelihood_continuous(double* xs, size_t n, double alpha,
        double xmin, double* L) {
    double logsum, c;
    size_t m;

    if (alpha <= 1) {
        PLFIT_ERROR("alpha must be greater than one", PLFIT_EINVAL);
    }
    XMIN_CHECK_ZERO;

    c = (alpha - 1) / xmin;
    plfit_i_logsum_less_than_continuous(xs, xs+n, xmin, &logsum, &m);
    *L = -alpha * logsum + log(c) * m;

    return PLFIT_SUCCESS;
}

int plfit_estimate_alpha_continuous_sorted(double* xs, size_t n, double xmin,
        const plfit_continuous_options_t* options, plfit_result_t *result) {
    double *begin, *end;

    if (!options)
        options = &plfit_continuous_default_options;

    begin = xs;
    end = xs + n;
    while (begin < end && *begin < xmin)
        begin++;

    PLFIT_CHECK(plfit_i_estimate_alpha_continuous_sorted(begin, end-begin,
                xmin, &result->alpha));
    PLFIT_CHECK(plfit_i_ks_test_continuous(begin, end, result->alpha,
                xmin, &result->D));

    if (options->finite_size_correction)
        plfit_i_perform_finite_size_correction(result, end-begin);
    result->xmin = xmin;

    PLFIT_CHECK(plfit_log_likelihood_continuous(begin, end-begin, result->alpha,
                result->xmin, &result->L));
    PLFIT_CHECK(plfit_i_calculate_p_value_continuous(xs, n, options, 1, result));

    return PLFIT_SUCCESS;
}

int plfit_estimate_alpha_continuous(double* xs, size_t n, double xmin,
        const plfit_continuous_options_t* options, plfit_result_t *result) {
    double *xs_copy;

    if (!options)
        options = &plfit_continuous_default_options;

    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &xs_copy));
    PLFIT_CHECK(plfit_estimate_alpha_continuous_sorted(xs_copy, n, xmin,
                options, result));
    free(xs_copy);

    return PLFIT_SUCCESS;
}

typedef struct {
    double *begin;        /**< Pointer to the beginning of the array holding the data */
    double *end;          /**< Pointer to after the end of the array holding the data */
    double **probes;      /**< Pointers to the elements of the array that will be probed */
    size_t num_probes;    /**< Number of probes */
    plfit_result_t last;  /**< Result of the last evaluation */
} plfit_continuous_xmin_opt_data_t;

static double plfit_i_continuous_xmin_opt_evaluate(void* instance, double x) {
    plfit_continuous_xmin_opt_data_t* data = (plfit_continuous_xmin_opt_data_t*)instance;
    double* begin = data->probes[(long int)x];

    data->last.xmin = *begin;

#ifdef PLFIT_DEBUG
    printf("Trying with probes[%ld] = %.4f\n", (long int)x, *begin);
#endif

    plfit_i_estimate_alpha_continuous_sorted(begin, data->end-begin, *begin,
            &data->last.alpha);
    plfit_i_ks_test_continuous(begin, data->end, data->last.alpha, *begin,
            &data->last.D);

    return data->last.D;
}

static int plfit_i_continuous_xmin_opt_progress(void* instance, double x, double fx,
        double min, double fmin, double left, double right, int k) {
#ifdef PLFIT_DEBUG
    printf("Iteration #%d: [%.4f; %.4f), x=%.4f, fx=%.4f, min=%.4f, fmin=%.4f\n",
            k, left, right, x, fx, min, fmin);
#endif

    /* Continue only if `left' and `right' point to different integers */
    return (int)left == (int)right;
}

static int plfit_i_continuous_xmin_opt_linear_scan(
        plfit_continuous_xmin_opt_data_t* opt_data, plfit_result_t* best_result,
        size_t* best_n) {
    /* this must be signed because OpenMP with Windows MSVC needs signed for
     * loop index variables. ssize_t will not work because that is a POSIX
     * extension */
    ptrdiff_t i = 0; /* initialize to work around incorrect warning issued by Clang 9.0 */
    plfit_result_t global_best_result;
    size_t global_best_n;

    /* Prepare some variables */
    global_best_n = 0;
    global_best_result.D = DBL_MAX;
    global_best_result.xmin = 0;
    global_best_result.alpha = 0;

    /* Due to the OpenMP parallelization, we do things as follows. Each
     * OpenMP thread will search for the best D-score on its own and store
     * the result in a private local_best_result variable. The end of the
     * parallel block contains a critical section that threads will enter
     * one by one and compare their private local_best_result with a
     * global_best that is shared among the threads.
     */
#ifdef _OPENMP
#pragma omp parallel shared(global_best_result, global_best_n) private(i) firstprivate(opt_data)
#endif
    {
        /* These variables are private since they are declared within the
         * parallel block */
        plfit_result_t local_best_result;
        plfit_continuous_xmin_opt_data_t local_opt_data = *opt_data;
        size_t local_best_n;

        /* Initialize the local_best_result and local_best_n variables */
        local_best_n = 0;
        local_best_result.D = DBL_MAX;
        local_best_result.xmin = 0;
        local_best_result.alpha = 0;
        local_best_result.p = NAN;
        local_best_result.L = NAN;

        /* The range of the for loop below is divided among the threads.
         * nowait means that there will be no implicit barrier at the end
         * of the loop so threads that get there earlier can enter the
         * critical section without waiting for the others */
#ifdef _OPENMP
#pragma omp for nowait schedule(dynamic,10)
#endif
        for (i = 0; i < local_opt_data.num_probes-1; i++) {
            plfit_i_continuous_xmin_opt_evaluate(&local_opt_data, i);
            if (local_opt_data.last.D < local_best_result.D) {
#ifdef PLFIT_DEBUG
                printf("Found new local best at %g with D=%g\n",
                        local_opt_data.last.xmin, local_opt_data.last.D);
#endif
                local_best_result = local_opt_data.last;
                local_best_n = local_opt_data.end - local_opt_data.probes[i] + 1;
            }
        }

        /* Critical section that finds the global best result from the
         * local ones collected by each thread */
#ifdef _OPENMP
#pragma omp critical
#endif
        if (local_best_result.D < global_best_result.D) {
            global_best_result = local_best_result;
            global_best_n = local_best_n;
#ifdef PLFIT_DEBUG
            printf("Found new global best at %g with D=%g\n", global_best_result.xmin,
                    global_best_result.D);
#endif
        }
    }

    *best_result = global_best_result;
    *best_n = global_best_n;

#ifdef PLFIT_DEBUG
    printf("Returning global best: %g\n", best_result->xmin);
#endif

    return PLFIT_SUCCESS;
}

int plfit_continuous(double* xs, size_t n, const plfit_continuous_options_t* options,
        plfit_result_t* result) {
    gss_parameter_t gss_param;
    plfit_continuous_xmin_opt_data_t opt_data;
    plfit_result_t best_result = {
        /* alpha = */ NAN,
        /* xmin = */ NAN,
        /* L = */ NAN,
        /* D = */ NAN,
        /* p = */ NAN
    };

    int success;
    size_t i, best_n, num_uniques = 0;
    double x, *px, **uniques;

    DATA_POINTS_CHECK;

    /* Sane defaults */
    best_n = n;
    if (!options)
        options = &plfit_continuous_default_options;

    /* Make a copy of xs and sort it */
    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &opt_data.begin));
    opt_data.end = opt_data.begin + n;

    /* Create an array containing pointers to the unique elements of the input. From
     * each block of unique elements, we add the pointer to the first one. */
    uniques = unique_element_pointers(opt_data.begin, opt_data.end, &num_uniques);
    if (uniques == 0)
        PLFIT_ERROR("cannot fit continuous power-law", PLFIT_ENOMEM);

    /* We will now determine the best xmin that yields the lowest D-score. The
     * 'success' variable will denote whether the search procedure we tried was
     * successful. If it is false after having exhausted all options, we fall
     * back to a linear search. */
    success = 0;
    switch (options->xmin_method) {
        case PLFIT_GSS_OR_LINEAR:
            /* Try golden section search first. */
            if (num_uniques > 5) {
                opt_data.probes = uniques;
                opt_data.num_probes = num_uniques;
                gss_parameter_init(&gss_param);
                success = (gss(0, opt_data.num_probes-5, &x, 0,
                        plfit_i_continuous_xmin_opt_evaluate,
                        plfit_i_continuous_xmin_opt_progress, &opt_data, &gss_param) == 0);
                if (success) {
                    px = opt_data.probes[(int)x];
                    best_n = opt_data.end-px+1;
                    best_result = opt_data.last;
                }
            }
            break;

        case PLFIT_STRATIFIED_SAMPLING:
            if (num_uniques >= 50) {
                /* Try stratified sampling to narrow down the interval where the minimum
                 * is likely to reside. We check 10% of the unique items, distributed
                 * evenly, find the one with the lowest D-score, and then check the
                 * area around it more thoroughly. */
                const size_t subdivision_length = 10;
                size_t num_strata = num_uniques / subdivision_length;
                double **strata = calloc(num_strata, sizeof(double*));
                int error_code;

                for (i = 0; i < num_strata; i++) {
                    strata[i] = uniques[i * subdivision_length];
                }

                opt_data.probes = strata;
                opt_data.num_probes = num_strata;
                error_code = plfit_i_continuous_xmin_opt_linear_scan(&opt_data, &best_result, &best_n);
                if (error_code != PLFIT_SUCCESS) {
                    free(strata);
                    return error_code;
                }

                opt_data.num_probes = 0;
                for (i = 0; i < num_strata; i++) {
                    if (*strata[i] == best_result.xmin) {
                        /* Okay, scan more thoroughly from strata[i-1] to strata[i+1],
                         * which is from uniques[(i-1)*subdivision_length] to
                         * uniques[(i+1)*subdivision_length */
                        opt_data.probes = uniques + (i > 0 ? (i-1)*subdivision_length : 0);
                        opt_data.num_probes = 0;
                        if (i != 0)
                            opt_data.num_probes += subdivision_length;
                        if (i != num_strata-1)
                            opt_data.num_probes += subdivision_length;
                        break;
                    }
                }

                free(strata);
                if (opt_data.num_probes > 0) {
                    /* Do a strict linear scan in the subrange determined above */
                    PLFIT_CHECK(
                        plfit_i_continuous_xmin_opt_linear_scan(
                            &opt_data, &best_result, &best_n
                        )
                    ); 
                    success = 1;
                } else {
                    /* This should not happen, but we handle it anyway */
                    success = 0;
                }
            }
            break;

        default:
            /* Just use the linear search */
            break;
    }

    if (!success) {
        /* More advanced search methods failed or were skipped; try linear search */
        opt_data.probes = uniques;
        opt_data.num_probes = num_uniques;
        PLFIT_CHECK(plfit_i_continuous_xmin_opt_linear_scan(&opt_data, &best_result, &best_n));
        success = 1;
    }

    /* Get rid of the uniques array, we don't need it any more */
    free(uniques);

    /* Sort out the result */
    *result = best_result;
    if (options->finite_size_correction)
        plfit_i_perform_finite_size_correction(result, best_n);

    PLFIT_CHECK(plfit_log_likelihood_continuous(opt_data.begin + n - best_n, best_n,
            result->alpha, result->xmin, &result->L));
    PLFIT_CHECK(plfit_i_calculate_p_value_continuous(opt_data.begin, n, options, 0, result));

    /* Get rid of the copied data as well */
    free(opt_data.begin);

    return PLFIT_SUCCESS;
}

/********** Discrete power law distribution fitting **********/

typedef struct {
    size_t m;
    double logsum;
    double xmin;
} plfit_i_estimate_alpha_discrete_data_t;

static double plfit_i_logsum_discrete(double* begin, double* end, double xmin) {
    double logsum = 0.0;
    for (; begin != end; begin++)
        logsum += log(*begin);
    return logsum;
}

static void plfit_i_logsum_less_than_discrete(double* begin, double* end, double xmin,
        double* logsum, size_t* m) {
    double result = 0.0;
    size_t count = 0;

    for (; begin != end; begin++) {
        if (*begin < xmin)
            continue;

        result += log(*begin);
        count++;
    }

    *logsum = result;
    *m = count;
}

static lbfgsfloatval_t plfit_i_estimate_alpha_discrete_lbfgs_evaluate(
        void* instance, const lbfgsfloatval_t* x,
        lbfgsfloatval_t* g, const int n,
        const lbfgsfloatval_t step) {
    plfit_i_estimate_alpha_discrete_data_t* data;
    lbfgsfloatval_t result;
    double dx = step;
    double huge = 1e10;     /* pseudo-infinity; apparently DBL_MAX does not work */
    double lnhzeta_x=NAN;
    double lnhzeta_deriv_x=NAN;

    data = (plfit_i_estimate_alpha_discrete_data_t*)instance;

#ifdef PLFIT_DEBUG
    printf("- Evaluating at %.4f (step = %.4f, xmin = %.4f)\n", *x, step, data->xmin);
#endif

    if (isnan(*x)) {
        g[0] = huge;
        return huge;
    }

    /* Find the delta X value to estimate the gradient */
    if (dx > 0.001 || dx == 0)
        dx = 0.001;
    else if (dx < -0.001)
        dx = -0.001;

    /* Is x[0] in its valid range? */
    if (x[0] <= 1.0) {
        /* The Hurwitz zeta function is infinite in this case */
        g[0] = (dx > 0) ? -huge : huge;
        return huge;
    }
    if (x[0] + dx <= 1.0) {
        g[0] = huge;
        result = x[0] * data->logsum + data->m * hsl_sf_lnhzeta(x[0], data->xmin);
    } else {
        hsl_sf_lnhzeta_deriv_tuple(x[0], data->xmin, &lnhzeta_x, &lnhzeta_deriv_x);
        g[0] = data->logsum + data->m * lnhzeta_deriv_x;
        result = x[0] * data->logsum + data->m * lnhzeta_x;
    }

#ifdef PLFIT_DEBUG
    printf("  - Gradient: %.4f\n", g[0]);
    printf("  - Result: %.4f\n", result);
#endif

    return result;
}

static int plfit_i_estimate_alpha_discrete_lbfgs_progress(void* instance,
        const lbfgsfloatval_t* x, const lbfgsfloatval_t* g,
        const lbfgsfloatval_t fx, const lbfgsfloatval_t xnorm,
        const lbfgsfloatval_t gnorm, const lbfgsfloatval_t step,
        int n, int k, int ls) {
    return 0;
}

static int plfit_i_estimate_alpha_discrete_linear_scan(double* xs, size_t n,
        double xmin, double* alpha, const plfit_discrete_options_t* options,
        plfit_bool_t sorted) {
    double curr_alpha, best_alpha, L, L_max;
    double logsum;
    size_t m;

    XMIN_CHECK_ONE;
    if (options->alpha.min <= 1.0) {
        PLFIT_ERROR("alpha.min must be greater than 1.0", PLFIT_EINVAL);
    }
    if (options->alpha.max < options->alpha.min) {
        PLFIT_ERROR("alpha.max must be greater than alpha.min", PLFIT_EINVAL);
    }
    if (options->alpha.step <= 0) {
        PLFIT_ERROR("alpha.step must be positive", PLFIT_EINVAL);
    }

    if (sorted) {
        logsum = plfit_i_logsum_discrete(xs, xs+n, xmin);
        m = n;
    } else {
        plfit_i_logsum_less_than_discrete(xs, xs+n, xmin, &logsum, &m);
    }

    best_alpha = options->alpha.min; L_max = -DBL_MAX;
    for (curr_alpha = options->alpha.min; curr_alpha <= options->alpha.max;
            curr_alpha += options->alpha.step) {
        L = -curr_alpha * logsum - m * hsl_sf_lnhzeta(curr_alpha, xmin);
        if (L > L_max) {
            L_max = L;
            best_alpha = curr_alpha;
        }
    }

    *alpha = best_alpha;

    return PLFIT_SUCCESS;
}

static int plfit_i_estimate_alpha_discrete_lbfgs(double* xs, size_t n, double xmin,
        double* alpha, const plfit_discrete_options_t* options, plfit_bool_t sorted) {
    lbfgs_parameter_t param;
    lbfgsfloatval_t* variables;
    plfit_i_estimate_alpha_discrete_data_t data;
    int ret;

    XMIN_CHECK_ONE;

    /* Initialize algorithm parameters */
    lbfgs_parameter_init(¶m);
    param.max_iterations = 0;   /* proceed until infinity */

    /* Set up context for optimization */
    data.xmin = xmin;
    if (sorted) {
        data.logsum = plfit_i_logsum_discrete(xs, xs+n, xmin);
        data.m = n;
    } else {
        plfit_i_logsum_less_than_discrete(xs, xs+n, xmin, &data.logsum, &data.m);
    }

    /* Allocate space for the single alpha variable */
    variables = lbfgs_malloc(1);
    variables[0] = 3.0;       /* initial guess */

    /* Optimization */
    ret = lbfgs(1, variables, /* ptr_fx = */ 0,
            plfit_i_estimate_alpha_discrete_lbfgs_evaluate,
            plfit_i_estimate_alpha_discrete_lbfgs_progress,
            &data, ¶m);

    if (ret < 0 &&
        ret != LBFGSERR_ROUNDING_ERROR &&
        ret != LBFGSERR_MAXIMUMLINESEARCH &&
        ret != LBFGSERR_MINIMUMSTEP &&
        ret != LBFGSERR_CANCELED) {
        char buf[4096];
        snprintf(buf, 4096, "L-BFGS optimization signaled an error (error code = %d)", ret);
        lbfgs_free(variables);
        PLFIT_ERROR(buf, PLFIT_FAILURE);
    }
    *alpha = variables[0];

    /* Deallocate the variable array */
    lbfgs_free(variables);

    return PLFIT_SUCCESS;
}

static int plfit_i_estimate_alpha_discrete_fast(double* xs, size_t n, double xmin,
        double* alpha, const plfit_discrete_options_t* options, plfit_bool_t sorted) {
    plfit_continuous_options_t cont_options;

    if (!options)
        options = &plfit_discrete_default_options;

    plfit_continuous_options_init(&cont_options);
    cont_options.finite_size_correction = options->finite_size_correction;

    XMIN_CHECK_ONE;

    if (sorted) {
        return plfit_i_estimate_alpha_continuous_sorted(xs, n, xmin-0.5, alpha);
    } else {
        return plfit_i_estimate_alpha_continuous(xs, n, xmin-0.5, alpha);
    }
}

static int plfit_i_estimate_alpha_discrete(double* xs, size_t n, double xmin,
        double* alpha, const plfit_discrete_options_t* options,
        plfit_bool_t sorted) {
    switch (options->alpha_method) {
        case PLFIT_LBFGS:
            PLFIT_CHECK(plfit_i_estimate_alpha_discrete_lbfgs(xs, n, xmin, alpha,
                        options, sorted));
            break;

        case PLFIT_LINEAR_SCAN:
            PLFIT_CHECK(plfit_i_estimate_alpha_discrete_linear_scan(xs, n, xmin,
                        alpha, options, sorted));
            break;

        case PLFIT_PRETEND_CONTINUOUS:
            PLFIT_CHECK(plfit_i_estimate_alpha_discrete_fast(xs, n, xmin,
                        alpha, options, sorted));
            break;

        default:
            PLFIT_ERROR("unknown optimization method specified", PLFIT_EINVAL);
    }

    return PLFIT_SUCCESS;
}

static int plfit_i_ks_test_discrete(double* xs, double* xs_end, const double alpha,
        const double xmin, double* D) {
    /* Assumption: xs is sorted and cut off at xmin so the first element is
     * always larger than or equal to xmin. */
    double result = 0, n, lnhzeta, x;
    int m = 0;

    n = xs_end - xs;
    lnhzeta = hsl_sf_lnhzeta(alpha, xmin);

    while (xs < xs_end) {
        double d;

        x = *xs;

        /* Re the next line: this used to be the following:
         *
         * fabs( 1 - hzeta(alpha, x) / hzeta(alpha, xmin) - m / n)
         *
         * However, using the Hurwitz zeta directly sometimes yields
         * underflows (see Github pull request #17 and related issues).
         * hzeta(alpha, x) / hzeta(alpha, xmin) can be replaced with
         * exp(lnhzeta(alpha, x) - lnhzeta(alpha, xmin)), but then
         * we have 1 - exp(something), which is better to calculate
         * with a dedicated expm1() function.
         */
        d = fabs( expm1( hsl_sf_lnhzeta(alpha, x) - lnhzeta ) + m / n);

        if (d > result)
            result = d;

        do {
            xs++; m++;
        } while (xs < xs_end && *xs == x);
    }

    *D = result;

    return PLFIT_SUCCESS;
}

static int plfit_i_calculate_p_value_discrete(double* xs, size_t n,
        const plfit_discrete_options_t* options, plfit_bool_t xmin_fixed,
        plfit_result_t *result) {
    long int num_trials;
    long int successes = 0;
    double *xs_head;
    size_t num_smaller;
    plfit_discrete_options_t options_no_p_value = *options;
    int retval = PLFIT_SUCCESS;

    if (options->p_value_method == PLFIT_P_VALUE_SKIP) {
        /* skipping p-value calculation */
        result->p = NAN;
        return PLFIT_SUCCESS;
    }

    if (options->p_value_method == PLFIT_P_VALUE_APPROXIMATE) {
        /* p-value approximation; most likely an upper bound */
        num_smaller = count_smaller(xs, xs + n, result->xmin);
        result->p = plfit_ks_test_one_sample_p(result->D, n - num_smaller);
        return PLFIT_SUCCESS;
    }

    options_no_p_value.p_value_method = PLFIT_P_VALUE_SKIP;
    num_trials = (long int)(0.25 / options->p_value_precision / options->p_value_precision);
    if (num_trials <= 0) {
        PLFIT_ERROR("invalid p-value precision", PLFIT_EINVAL);
    }

    /* Extract the head of xs that contains elements smaller than xmin */
    xs_head = extract_smaller(xs, xs+n, result->xmin, &num_smaller);
    if (xs_head == 0)
        PLFIT_ERROR("cannot calculate exact p-value", PLFIT_ENOMEM);

#ifdef _OPENMP
#pragma omp parallel
#endif
    {
        /* Parallel section starts here. If we are compiling using OpenMP, each
         * thread will use its own RNG that is seeded from the master RNG. If
         * we are compiling without OpenMP, there is only one thread and it uses
         * the master RNG. This section must be critical to ensure that only one
         * thread is using the master RNG at the same time. */
#ifdef _OPENMP
        plfit_mt_rng_t private_rng;
#endif
        plfit_mt_rng_t *p_rng;
        double *ys;
        long int i;
        plfit_result_t result_synthetic;

#ifdef _OPENMP
#pragma omp critical
        {
            p_rng = &private_rng;
            plfit_mt_init_from_rng(p_rng, options->rng);
        }
#else
        p_rng = options->rng;
#endif

        /* Allocate memory to sample into */
        ys = calloc(n, sizeof(double));
        if (ys == 0) {
            retval = PLFIT_ENOMEM;
        } else {
            /* The main for loop starts here. */
#ifdef _OPENMP
#pragma omp for reduction(+:successes)
#endif
            for (i = 0; i < num_trials; i++) {
                plfit_i_resample_discrete(xs_head, num_smaller, n, result->alpha,
                        result->xmin, n, p_rng, ys);
                if (xmin_fixed) {
                    plfit_estimate_alpha_discrete(ys, n, result->xmin,
                                &options_no_p_value, &result_synthetic);
                } else {
                    plfit_discrete(ys, n, &options_no_p_value, &result_synthetic);
                }
                if (result_synthetic.D > result->D)
                    successes++;
            }

            free(ys);
        }

        /* End of parallelized part */
    }

    free(xs_head);

    if (retval == PLFIT_SUCCESS) {
        result->p = successes / ((double)num_trials);
    } else {
        PLFIT_ERROR("cannot calculate exact p-value", retval);
    }

    return retval;
}

int plfit_log_likelihood_discrete(double* xs, size_t n, double alpha, double xmin, double* L) {
    double result;
    size_t m;

    if (alpha <= 1) {
        PLFIT_ERROR("alpha must be greater than one", PLFIT_EINVAL);
    }
    XMIN_CHECK_ONE;

    plfit_i_logsum_less_than_discrete(xs, xs+n, xmin, &result, &m);
    result = - alpha * result - m * hsl_sf_lnhzeta(alpha, xmin);

    *L = result;

    return PLFIT_SUCCESS;
}

int plfit_estimate_alpha_discrete(double* xs, size_t n, double xmin,
        const plfit_discrete_options_t* options, plfit_result_t *result) {
    double *xs_copy, *begin, *end;

    if (!options)
        options = &plfit_discrete_default_options;

    /* Check the validity of the input parameters */
    DATA_POINTS_CHECK;
    if (options->alpha_method == PLFIT_LINEAR_SCAN) {
        if (options->alpha.min <= 1.0) {
            PLFIT_ERROR("alpha.min must be greater than 1.0", PLFIT_EINVAL);
        }
        if (options->alpha.max < options->alpha.min) {
            PLFIT_ERROR("alpha.max must be greater than alpha.min", PLFIT_EINVAL);
        }
        if (options->alpha.step <= 0) {
            PLFIT_ERROR("alpha.step must be positive", PLFIT_EINVAL);
        }
    }

    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &xs_copy));

    begin = xs_copy; end = xs_copy + n;
    while (begin < end && *begin < xmin)
        begin++;

    PLFIT_CHECK(plfit_i_estimate_alpha_discrete(begin, end-begin, xmin, &result->alpha,
                options, /* sorted = */ 1));
    PLFIT_CHECK(plfit_i_ks_test_discrete(begin, end, result->alpha, xmin, &result->D));

    result->xmin = xmin;
    if (options->finite_size_correction)
        plfit_i_perform_finite_size_correction(result, end-begin);

    PLFIT_CHECK(plfit_log_likelihood_discrete(begin, end-begin, result->alpha,
                result->xmin, &result->L));
    PLFIT_CHECK(plfit_i_calculate_p_value_discrete(xs, n, options, 1, result));

    free(xs_copy);

    return PLFIT_SUCCESS;
}

int plfit_discrete(double* xs, size_t n, const plfit_discrete_options_t* options,
        plfit_result_t* result) {
    double curr_D, curr_alpha;
    plfit_result_t best_result;
    double *xs_copy, *px, *end, *end_xmin, prev_x;
    size_t best_n;
    int m;

    if (!options)
        options = &plfit_discrete_default_options;

    /* Check the validity of the input parameters */
    DATA_POINTS_CHECK;
    if (options->alpha_method == PLFIT_LINEAR_SCAN) {
        if (options->alpha.min <= 1.0) {
            PLFIT_ERROR("alpha.min must be greater than 1.0", PLFIT_EINVAL);
        }
        if (options->alpha.max < options->alpha.min) {
            PLFIT_ERROR("alpha.max must be greater than alpha.min", PLFIT_EINVAL);
        }
        if (options->alpha.step <= 0) {
            PLFIT_ERROR("alpha.step must be positive", PLFIT_EINVAL);
        }
    }

    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &xs_copy));

    best_result.D = DBL_MAX;
    best_result.xmin = 1;
    best_result.alpha = 1;
    best_n = 0;

    /* Skip initial values from xs_copy until we get to a positive element or
     * until we reach the end of the array */
    px = xs_copy; end = px + n; end_xmin = end - 1;
    while (px < end && *px < 1) {
        px++;
    }

    /* Make sure there are at least three distinct values if possible */
    m = px - xs_copy;
    prev_x = *end_xmin;
    while (end_xmin > px && *end_xmin == prev_x) {
        end_xmin--;
    }
    prev_x = *end_xmin;
    while (end_xmin > px && *end_xmin == prev_x) {
        end_xmin--;
    }

    prev_x = 0;
    end_xmin++;
    while (px < end_xmin) {
        while (px < end_xmin && *px == prev_x) {
            px++; m++;
        }

        PLFIT_CHECK(
            plfit_i_estimate_alpha_discrete(
                px, n-m, *px, &curr_alpha, options, /* sorted = */ 1
            )
        );
        PLFIT_CHECK(
            plfit_i_ks_test_discrete(px, end, curr_alpha, *px, &curr_D)
        );

        if (curr_D < best_result.D) {
            best_result.alpha = curr_alpha;
            best_result.xmin = *px;
            best_result.D = curr_D;
            best_n = n-m;
        }

        prev_x = *px;
        px++; m++;
    }

    *result = best_result;
    if (options->finite_size_correction)
        plfit_i_perform_finite_size_correction(result, best_n);

    PLFIT_CHECK(plfit_log_likelihood_discrete(xs_copy+(n-best_n), best_n,
                result->alpha, result->xmin, &result->L));
    PLFIT_CHECK(plfit_i_calculate_p_value_discrete(xs_copy, n, options, 0, result));

    free(xs_copy);

    return PLFIT_SUCCESS;
}

/***** resampling routines to generate synthetic replicates ****/

static int plfit_i_resample_continuous(double* xs_head, size_t num_smaller,
        size_t n, double alpha, double xmin, size_t num_samples, plfit_mt_rng_t* rng,
        double* result)
{
    size_t num_orig_samples, i;

    /* Calculate how many samples have to be drawn from xs_head */
    num_orig_samples = (size_t) plfit_rbinom(num_samples, num_smaller / (double)n, rng);

    /* Draw the samples from xs_head */
    for (i = 0; i < num_orig_samples; i++, result++) {
        *result = xs_head[(size_t)plfit_runif(0, num_smaller, rng)];
    }

    /* Draw the remaining samples from the fitted distribution */
    PLFIT_CHECK(plfit_rpareto_array(xmin, alpha-1, num_samples-num_orig_samples, rng,
            result));

    return PLFIT_SUCCESS;
}

int plfit_resample_continuous(double* xs, size_t n, double alpha, double xmin,
        size_t num_samples, plfit_mt_rng_t* rng, double* result) {
    double *xs_head;
    size_t num_smaller = 0;
    int retval;

    /* Extract the head of xs that contains elements smaller than xmin */
    xs_head = extract_smaller(xs, xs+n, xmin, &num_smaller);
    if (xs_head == 0)
        PLFIT_ERROR("cannot resample continuous dataset", PLFIT_ENOMEM);

    retval = plfit_i_resample_continuous(xs_head, num_smaller, n, alpha, xmin,
                num_samples, rng, result);

    /* Free xs_head; we don't need it any more */
    free(xs_head);

    return retval;
}

static int plfit_i_resample_discrete(double* xs_head, size_t num_smaller, size_t n,
        double alpha, double xmin, size_t num_samples, plfit_mt_rng_t* rng,
        double* result)
{
    size_t num_orig_samples, i;

    /* Calculate how many samples have to be drawn from xs_head */
    num_orig_samples = (size_t) plfit_rbinom(num_samples, num_smaller / (double)n, rng);

    /* Draw the samples from xs_head */
    for (i = 0; i < num_orig_samples; i++, result++) {
        *result = xs_head[(size_t)plfit_runif(0, num_smaller, rng)];
    }

    /* Draw the remaining samples from the fitted distribution */
    PLFIT_CHECK(plfit_rzeta_array((long int)xmin, alpha,
                num_samples-num_orig_samples, rng, result));

    return PLFIT_SUCCESS;
}

int plfit_resample_discrete(double* xs, size_t n, double alpha, double xmin,
        size_t num_samples, plfit_mt_rng_t* rng, double* result) {
    double *xs_head;
    size_t num_smaller = 0;
    int retval;

    /* Extract the head of xs that contains elements smaller than xmin */
    xs_head = extract_smaller(xs, xs+n, xmin, &num_smaller);
    if (xs_head == 0)
        PLFIT_ERROR("cannot resample discrete dataset", PLFIT_ENOMEM);

    retval = plfit_i_resample_discrete(xs_head, num_smaller, n, alpha, xmin,
                num_samples, rng, result);

    /* Free xs_head; we don't need it any more */
    free(xs_head);

    return retval;
}

/******** calculating the p-value of a fitted model only *******/

int plfit_calculate_p_value_continuous(double* xs, size_t n,
        const plfit_continuous_options_t* options, plfit_bool_t xmin_fixed,
        plfit_result_t *result) {
    double* xs_copy;

    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &xs_copy));
    PLFIT_CHECK(plfit_i_calculate_p_value_continuous(xs_copy, n, options,
                xmin_fixed, result));
    free(xs_copy);

    return PLFIT_SUCCESS;
}

int plfit_calculate_p_value_discrete(double* xs, size_t n,
        const plfit_discrete_options_t* options, plfit_bool_t xmin_fixed,
        plfit_result_t *result) {
    double* xs_copy;

    PLFIT_CHECK(plfit_i_copy_and_sort(xs, n, &xs_copy));
    PLFIT_CHECK(plfit_i_calculate_p_value_discrete(xs_copy, n, options,
                xmin_fixed, result));
    free(xs_copy);

    return PLFIT_SUCCESS;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit.h0000644000175100001710000001136300000000000023560 0ustar00runnerdocker00000000000000/* vim:set ts=4 sw=4 sts=4 et: */
/* plfit.h
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __PLFIT_H__
#define __PLFIT_H__

#include 
#include "plfit_mt.h"
#include "plfit_version.h"

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

typedef unsigned short int plfit_bool_t;

typedef enum {
    PLFIT_LINEAR_ONLY,
    PLFIT_STRATIFIED_SAMPLING,
    PLFIT_GSS_OR_LINEAR,
    PLFIT_DEFAULT_CONTINUOUS_METHOD = PLFIT_STRATIFIED_SAMPLING
} plfit_continuous_method_t;

typedef enum {
    PLFIT_LBFGS,
    PLFIT_LINEAR_SCAN,
    PLFIT_PRETEND_CONTINUOUS,
    PLFIT_DEFAULT_DISCRETE_METHOD = PLFIT_LBFGS
} plfit_discrete_method_t;

typedef enum {
    PLFIT_P_VALUE_SKIP,
    PLFIT_P_VALUE_APPROXIMATE,
    PLFIT_P_VALUE_EXACT,
    PLFIT_DEFAULT_P_VALUE_METHOD = PLFIT_P_VALUE_EXACT
} plfit_p_value_method_t;

typedef struct _plfit_result_t {
    double alpha;     /* fitted power-law exponent */
    double xmin;      /* cutoff where the power-law behaviour kicks in */
    double L;         /* log-likelihood of the sample */
    double D;         /* test statistic for the KS test */
    double p;         /* p-value of the KS test */
} plfit_result_t;

/********** structure that holds the options of plfit **********/

typedef struct _plfit_continuous_options_t {
    plfit_bool_t finite_size_correction;
    plfit_continuous_method_t xmin_method;
    plfit_p_value_method_t p_value_method;
    double p_value_precision;
    plfit_mt_rng_t* rng;
} plfit_continuous_options_t;

typedef struct _plfit_discrete_options_t {
    plfit_bool_t finite_size_correction;
    plfit_discrete_method_t alpha_method;
    struct {
        double min;
        double max;
        double step;
    } alpha;
    plfit_p_value_method_t p_value_method;
    double p_value_precision;
    plfit_mt_rng_t* rng;
} plfit_discrete_options_t;

int plfit_continuous_options_init(plfit_continuous_options_t* options);
int plfit_discrete_options_init(plfit_discrete_options_t* options);

extern const plfit_continuous_options_t plfit_continuous_default_options;
extern const plfit_discrete_options_t plfit_discrete_default_options;

/********** continuous power law distribution fitting **********/

int plfit_log_likelihood_continuous(double* xs, size_t n, double alpha,
        double xmin, double* l);
int plfit_estimate_alpha_continuous(double* xs, size_t n, double xmin,
        const plfit_continuous_options_t* options, plfit_result_t* result);
int plfit_continuous(double* xs, size_t n,
        const plfit_continuous_options_t* options, plfit_result_t* result);

/*********** discrete power law distribution fitting ***********/

int plfit_estimate_alpha_discrete(double* xs, size_t n, double xmin,
        const plfit_discrete_options_t* options, plfit_result_t *result);
int plfit_log_likelihood_discrete(double* xs, size_t n, double alpha, double xmin, double* l);
int plfit_discrete(double* xs, size_t n, const plfit_discrete_options_t* options,
        plfit_result_t* result);

/***** resampling routines to generate synthetic replicates ****/

int plfit_resample_continuous(double* xs, size_t n, double alpha, double xmin,
        size_t num_samples, plfit_mt_rng_t* rng, double* result);
int plfit_resample_discrete(double* xs, size_t n, double alpha, double xmin,
        size_t num_samples, plfit_mt_rng_t* rng, double* result);

/******** calculating the p-value of a fitted model only *******/

int plfit_calculate_p_value_continuous(double* xs, size_t n,
        const plfit_continuous_options_t* options, plfit_bool_t xmin_fixed,
        plfit_result_t *result);
int plfit_calculate_p_value_discrete(double* xs, size_t n,
        const plfit_discrete_options_t* options, plfit_bool_t xmin_fixed,
        plfit_result_t *result);

/************* calculating descriptive statistics **************/

int plfit_moments(double* data, size_t n, double* mean, double* variance,
        double* skewness, double* kurtosis);

__END_DECLS

#endif /* __PLFIT_H__ */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit_error.c0000644000175100001710000000402300000000000024757 0ustar00runnerdocker00000000000000/* error.c
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include 
#include 
#include "plfit_error.h"
#include "platform.h"

static char *plfit_i_error_strings[] = {
    "No error",
    "Failed",
    "Invalid value",
    "Underflow",
    "Overflow",
    "Not enough memory"
};

#ifndef USING_R
static plfit_error_handler_t* plfit_error_handler = plfit_error_handler_printignore;
#else
/* This is overwritten, anyway */
static plfit_error_handler_t* plfit_error_handler = plfit_error_handler_ignore;
#endif

const char* plfit_strerror(const int plfit_errno) {
  return plfit_i_error_strings[plfit_errno];
}

plfit_error_handler_t* plfit_set_error_handler(plfit_error_handler_t* new_handler) {
    plfit_error_handler_t* old_handler = plfit_error_handler;
    plfit_error_handler = new_handler;
    return old_handler;
}

void plfit_error(const char *reason, const char *file, int line,
        int plfit_errno) {
    plfit_error_handler(reason, file, line, plfit_errno);
}

#ifndef USING_R
void plfit_error_handler_printignore(const char *reason, const char *file, int line,
        int plfit_errno) {
    fprintf(stderr, "Error at %s:%i : %s, %s\n", file, line, reason,
            plfit_strerror(plfit_errno));
}
#endif

void plfit_error_handler_ignore(const char* reason, const char* file, int line,
		int plfit_errno) {
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit_error.h0000644000175100001710000000473400000000000024775 0ustar00runnerdocker00000000000000/* plfit_error.h
 *
 * Copyright (C) 2010-2011 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __ERROR_H__
#define __ERROR_H__

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

enum {
	PLFIT_SUCCESS  = 0,
	PLFIT_FAILURE  = 1,
	PLFIT_EINVAL   = 2,
	PLFIT_UNDRFLOW = 3,
	PLFIT_OVERFLOW = 4,
	PLFIT_ENOMEM   = 5
};

#if (defined(__GNUC__) && GCC_VERSION_MAJOR >= 3)
#  define PLFIT_UNLIKELY(a) __builtin_expect((a), 0)
#  define PLFIT_LIKELY(a)   __builtin_expect((a), 1)
#else
#  define PLFIT_UNLIKELY(a) a
#  define PLFIT_LIKELY(a)   a
#endif

#define PLFIT_CHECK(a) \
	do {\
		int plfit_i_ret=(a); \
		if (PLFIT_UNLIKELY(plfit_i_ret != PLFIT_SUCCESS)) {\
			return plfit_i_ret; \
		} \
	} while(0)

#define PLFIT_ERROR(reason,plfit_errno) \
	do {\
		plfit_error (reason, __FILE__, __LINE__, plfit_errno) ; \
		return plfit_errno ; \
	} while (0)

typedef void plfit_error_handler_t(const char*, const char*, int, int);

extern plfit_error_handler_t plfit_error_handler_abort;
extern plfit_error_handler_t plfit_error_handler_ignore;
extern plfit_error_handler_t plfit_error_handler_printignore;

plfit_error_handler_t* plfit_set_error_handler(plfit_error_handler_t* new_handler);

void plfit_error(const char *reason, const char *file, int line, int plfit_errno);
const char* plfit_strerror(const int plfit_errno);

void plfit_error_handler_abort(const char *reason, const char *file, int line,
		int plfit_errno);
void plfit_error_handler_ignore(const char *reason, const char *file, int line,
		int plfit_errno);
void plfit_error_handler_printignore(const char *reason, const char *file, int line,
		int plfit_errno);

__END_DECLS

#endif /* __ERROR_H__ */
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit_mt.h0000644000175100001710000000547200000000000024264 0ustar00runnerdocker00000000000000/* plfit_mt.h
 *
 * Mersenne Twister random number generator, based on the implementation of
 * Michael Brundage (which has been placed in the public domain).
 *
 * Author: Tamas Nepusz (original by Michael Brundage)
 *
 * See the following URL for the original implementation:
 * http://www.qbrundage.com/michaelb/pubs/essays/random_number_generation.html
 *
 * This file has been placed in the public domain.
 */

#ifndef __PLFIT_MT_H__
#define __PLFIT_MT_H__

/* VS 2010, i.e. _MSC_VER == 1600, already has stdint.h */
#if defined(_MSC_VER) && _MSC_VER < 1600
#  define uint32_t unsigned __int32
#else
#  include 
#endif

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

#define PLFIT_MT_LEN       624

/**
 * \def PLFIT_MT_RAND_MAX
 *
 * The maximum random number that \c plfit_mt_random() can generate.
 */
#define PLFIT_MT_RAND_MAX 0xFFFFFFFF

/**
 * Struct that stores the internal state of a Mersenne Twister random number
 * generator.
 */
typedef struct {
    int mt_index;
    uint32_t mt_buffer[PLFIT_MT_LEN];
} plfit_mt_rng_t;

/**
 * \brief Initializes a Mersenne Twister random number generator.
 *
 * The random number generator is seeded with random 32-bit numbers obtained
 * from the \em built-in random number generator using consecutive calls to
 * \c rand().
 *
 * \param  rng  the random number generator to initialize
 */
void plfit_mt_init(plfit_mt_rng_t* rng);

/**
 * \brief Initializes a Mersenne Twister random number generator, seeding it
 *        from another one.
 *
 * The random number generator is seeded with random 32-bit numbers obtained
 * from another, initialized Mersenne Twister random number generator.
 *
 * \param  rng     the random number generator to initialize
 * \param  seeder  the random number generator that will seed the one being
 *                 initialized. When null, the random number generator will
 *                 be initialized from the built-in RNG as if \ref plfit_mt_init()
 *                 was called.
 */
void plfit_mt_init_from_rng(plfit_mt_rng_t* rng, plfit_mt_rng_t* seeder);

/**
 * \brief Returns the next 32-bit random number from the given Mersenne Twister
 * random number generator.
 *
 * \param  rng  the random number generator to use
 * \return the next 32-bit random number from the generator
 */
uint32_t plfit_mt_random(plfit_mt_rng_t* rng);

/**
 * \brief Returns a uniformly distributed double from the interval [0;1)
 * based on the next value of the given Mersenne Twister random number
 * generator.
 *
 * \param  rng  the random number generator to use
 * \return a uniformly distributed random number from the interval [0;1)
 */
double plfit_mt_uniform_01(plfit_mt_rng_t* rng);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit_sampling.h0000644000175100001710000001415700000000000025456 0ustar00runnerdocker00000000000000/* plfit_sampling.h
 *
 * Copyright (C) 2012 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef __SAMPLING_H__
#define __SAMPLING_H__

#include 
#include "plfit_mt.h"

#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

__BEGIN_DECLS

/**
 * Draws a sample from a binomial distribution with the given count and
 * probability values.
 *
 * This function is borrowed from R; see the corresponding license in
 * \c rbinom.c. The return value is always an integer.
 *
 * The function is \em not thread-safe.
 *
 * \param  n    the number of trials
 * \param  p    the success probability of each trial
 * \param  rng  the Mersenne Twister random number generator to use
 * \return the value drawn from the given binomial distribution.
 */
double plfit_rbinom(double n, double p, plfit_mt_rng_t* rng);

/**
 * Draws a sample from a Pareto distribution with the given minimum value and
 * power-law exponent.
 *
 * \param  xmin    the minimum value of the distribution. Must be positive.
 * \param  alpha   the exponent. Must be positive
 * \param  rng     the Mersenne Twister random number generator to use
 *
 * \return the sample or NaN if one of the parameters is invalid
 */
extern double plfit_rpareto(double xmin, double alpha, plfit_mt_rng_t* rng);

/**
 * Draws a given number of samples from a Pareto distribution with the given
 * minimum value and power-law exponent.
 *
 * \param  xmin    the minimum value of the distribution. Must be positive.
 * \param  alpha   the exponent. Must be positive
 * \param  n       the number of samples to draw
 * \param  rng     the Mersenne Twister random number generator to use
 * \param  result  the array where the result should be written. It must
 *                 have enough space to store n items
 *
 * \return \c PLFIT_EINVAL if one of the parameters is invalid, zero otherwise
 */
int plfit_rpareto_array(double xmin, double alpha, size_t n, plfit_mt_rng_t* rng,
        double* result);

/**
 * Draws a sample from a zeta distribution with the given minimum value and
 * power-law exponent.
 *
 * \param  xmin    the minimum value of the distribution. Must be positive.
 * \param  alpha   the exponent. Must be positive
 * \param  rng     the Mersenne Twister random number generator to use
 *
 * \return the sample or NaN if one of the parameters is invalid
 */
extern double plfit_rzeta(long int xmin, double alpha, plfit_mt_rng_t* rng);

/**
 * Draws a given number of samples from a zeta distribution with the given
 * minimum value and power-law exponent.
 *
 * \param  xmin    the minimum value of the distribution. Must be positive.
 * \param  alpha   the exponent. Must be positive
 * \param  n       the number of samples to draw
 * \param  rng     the Mersenne Twister random number generator to use
 * \param  result  the array where the result should be written. It must
 *                 have enough space to store n items
 *
 * \return \c PLFIT_EINVAL if one of the parameters is invalid, zero otherwise
 */
int plfit_rzeta_array(long int xmin, double alpha, size_t n, plfit_mt_rng_t* rng,
        double* result);

/**
 * Draws a sample from a uniform distribution with the given lower and
 * upper bounds.
 *
 * The lower bound is inclusive, the uppoer bound is not.
 *
 * \param  lo   the lower bound
 * \param  hi   the upper bound
 * \param  rng  the Mersenne Twister random number generator to use
 * \return the value drawn from the given uniform distribution.
 */
extern double plfit_runif(double lo, double hi, plfit_mt_rng_t* rng);

/**
 * Draws a sample from a uniform distribution over the [0; 1) interval.
 *
 * The interval is closed from the left and open from the right.
 *
 * \param  rng  the Mersenne Twister random number generator to use
 * \return the value drawn from the given uniform distribution.
 */
extern double plfit_runif_01(plfit_mt_rng_t* rng);

/**
 * Random sampler using Walker's alias method.
 */
typedef struct {
    long int num_bins;            /**< Number of bins */
    long int* indexes;            /**< Index of the "other" element in each bin */
    double* probs;                /**< Probability of drawing the "own" element from a bin */
} plfit_walker_alias_sampler_t;

/**
 * \brief Initializes the sampler with item probabilities.
 *
 * \param  sampler  the sampler to initialize
 * \param  ps   pointer to an array containing a value proportional to the
 *              sampling probability of each item in the set being sampled.
 * \param  n    the number of items in the array
 * \return error code
 */
int plfit_walker_alias_sampler_init(plfit_walker_alias_sampler_t* sampler,
        double* ps, size_t n);

/**
 * \brief Destroys an initialized sampler and frees the allocated memory.
 *
 * \param  sampler  the sampler to destroy
 */
void plfit_walker_alias_sampler_destroy(plfit_walker_alias_sampler_t* sampler);

/**
 * \brief Draws a given number of samples from the sampler and writes them
 *        to a given array.
 *
 * \param  sampler  the sampler to use
 * \param  xs       pointer to an array where the sampled items should be
 *                  written
 * \param  n        the number of samples to draw
 * \param  rng      the Mersenne Twister random number generator to use
 * \return error code
 */
int plfit_walker_alias_sampler_sample(const plfit_walker_alias_sampler_t* sampler,
        long int* xs, size_t n, plfit_mt_rng_t* rng);

__END_DECLS

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/plfit_version.h0000644000175100001710000000170700000000000025326 0ustar00runnerdocker00000000000000/* plfit_version.h
 *
 * Copyright (C) 2021 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef PLFIT_VERSION_H
#define PLFIT_VERSION_H

#define PLFIT_VERSION_MAJOR 0
#define PLFIT_VERSION_MINOR 9
#define PLFIT_VERSION_PATCH 3
#define PLFIT_VERSION_STRING "0.9.3"

#endif
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/rbinom.c0000644000175100001710000001305400000000000023722 0ustar00runnerdocker00000000000000/*
 *  Mathlib : A C Library of Special Functions
 *  Copyright (C) 1998 Ross Ihaka
 *  Copyright (C) 2000-2002 The R Core Team
 *  Copyright (C) 2007 The R Foundation
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 *
 *  SYNOPSIS
 *
 *	#include 
 *	double rbinom(double nin, double pp)
 *
 *  DESCRIPTION
 *
 *	Random variates from the binomial distribution.
 *
 *  REFERENCE
 *
 *	Kachitvichyanukul, V. and Schmeiser, B. W. (1988).
 *	Binomial random variate generation.
 *	Communications of the ACM 31, 216-222.
 *	(Algorithm BTPEC).
 */

/*
 * Modifications for this file were performed by Tamas Nepusz to make it fit
 * better with plfit. The license of the original file applies to the
 * modifications as well.
 */

#include 
#include 
#include 
#include "plfit_sampling.h"
#include "platform.h"

#define repeat for(;;)

double plfit_rbinom(double nin, double pp, plfit_mt_rng_t* rng)
{
    /* FIXME: These should become THREAD_specific globals : */

    static double c, fm, npq, p1, p2, p3, p4, qn;
    static double xl, xll, xlr, xm, xr;

    static double psave = -1.0;
    static int nsave = -1;
    static int m;

    double f, f1, f2, u, v, w, w2, x, x1, x2, z, z2;
    double p, q, np, g, r, al, alv, amaxp, ffm, ynorm;
    int i, ix, k, n;

    if (!isfinite(nin)) return NAN;
    r = floor(nin + 0.5);
    if (r != nin) return NAN;
    if (!isfinite(pp) ||
	/* n=0, p=0, p=1 are not errors */
	r < 0 || pp < 0. || pp > 1.) return NAN;

    if (r == 0 || pp == 0.) return 0;
    if (pp == 1.) return r;

    n = (int) r;

    p = fmin(pp, 1. - pp);
    q = 1. - p;
    np = n * p;
    r = p / q;
    g = r * (n + 1);

    /* Setup, perform only when parameters change [using static (globals): */

    /* FIXING: Want this thread safe
       -- use as little (thread globals) as possible
    */
    if (pp != psave || n != nsave) {
	psave = pp;
	nsave = n;
	if (np < 30.0) {
	    /* inverse cdf logic for mean less than 30 */
	    qn = pow(q, (double) n);
	    goto L_np_small;
	} else {
	    ffm = np + p;
	    m = (int) ffm;
	    fm = m;
	    npq = np * q;
	    p1 = (int)(2.195 * sqrt(npq) - 4.6 * q) + 0.5;
	    xm = fm + 0.5;
	    xl = xm - p1;
	    xr = xm + p1;
	    c = 0.134 + 20.5 / (15.3 + fm);
	    al = (ffm - xl) / (ffm - xl * p);
	    xll = al * (1.0 + 0.5 * al);
	    al = (xr - ffm) / (xr * q);
	    xlr = al * (1.0 + 0.5 * al);
	    p2 = p1 * (1.0 + c + c);
	    p3 = p2 + c / xll;
	    p4 = p3 + c / xlr;
	}
    } else if (n == nsave) {
	if (np < 30.0)
	    goto L_np_small;
    }

    /*-------------------------- np = n*p >= 30 : ------------------- */
    repeat {
      u = plfit_runif_01(rng) * p4;
      v = plfit_runif_01(rng);
      /* triangular region */
      if (u <= p1) {
	  ix = (int)(xm - p1 * v + u);
	  goto finis;
      }
      /* parallelogram region */
      if (u <= p2) {
	  x = xl + (u - p1) / c;
	  v = v * c + 1.0 - fabs(xm - x) / p1;
	  if (v > 1.0 || v <= 0.)
	      continue;
	  ix = (int) x;
      } else {
	  if (u > p3) {	/* right tail */
	      ix = (int)(xr - log(v) / xlr);
	      if (ix > n)
		  continue;
	      v = v * (u - p3) * xlr;
	  } else {/* left tail */
	      ix = (int)(xl + log(v) / xll);
	      if (ix < 0)
		  continue;
	      v = v * (u - p2) * xll;
	  }
      }
      /* determine appropriate way to perform accept/reject test */
      k = abs(ix - m);
      if (k <= 20 || k >= npq / 2 - 1) {
	  /* explicit evaluation */
	  f = 1.0;
	  if (m < ix) {
	      for (i = m + 1; i <= ix; i++)
		  f *= (g / i - r);
	  } else if (m != ix) {
	      for (i = ix + 1; i <= m; i++)
		  f /= (g / i - r);
	  }
	  if (v <= f)
	      goto finis;
      } else {
	  /* squeezing using upper and lower bounds on log(f(x)) */
	  amaxp = (k / npq) * ((k * (k / 3. + 0.625) + 0.1666666666666) / npq + 0.5);
	  ynorm = -k * k / (2.0 * npq);
	  alv = log(v);
	  if (alv < ynorm - amaxp)
	      goto finis;
	  if (alv <= ynorm + amaxp) {
	      /* stirling's formula to machine accuracy */
	      /* for the final acceptance/rejection test */
	      x1 = ix + 1;
	      f1 = fm + 1.0;
	      z = n + 1 - fm;
	      w = n - ix + 1.0;
	      z2 = z * z;
	      x2 = x1 * x1;
	      f2 = f1 * f1;
	      w2 = w * w;
	      if (alv <= xm * log(f1 / x1) + (n - m + 0.5) * log(z / w) + (ix - m) * log(w * p / (x1 * q)) + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / f2) / f2) / f2) / f2) / f1 / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / z2) / z2) / z2) / z2) / z / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / x2) / x2) / x2) / x2) / x1 / 166320.0 + (13860.0 - (462.0 - (132.0 - (99.0 - 140.0 / w2) / w2) / w2) / w2) / w / 166320.)
		  goto finis;
	  }
      }
  }

 L_np_small:
    /*---------------------- np = n*p < 30 : ------------------------- */

  repeat {
     ix = 0;
     f = qn;
     u = plfit_runif_01(rng);
     repeat {
	 if (u < f)
	     goto finis;
	 if (ix > 110)
	     break;
	 u -= f;
	 ix++;
	 f *= (g / ix - r);
     }
  }
 finis:
    if (psave > 0.5)
	 ix = n - ix;
  return (double)ix;
}
././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1641822586.0
igraph-0.9.9/vendor/source/igraph/vendor/plfit/sampling.c0000644000175100001710000002251600000000000024251 0ustar00runnerdocker00000000000000/* sampling.c
 *
 * Copyright (C) 2012 Tamas Nepusz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include 
#include 

#include "igraph_random.h"

#include "plfit_error.h"
#include "plfit_sampling.h"
#include "platform.h"

inline double plfit_runif(double lo, double hi, plfit_mt_rng_t* rng) {
    if (rng == 0) {
        return RNG_UNIF(lo, hi);
    }
    return lo + plfit_mt_uniform_01(rng) * (hi-lo);
}

inline double plfit_runif_01(plfit_mt_rng_t* rng) {
    if (rng == 0) {
        return RNG_UNIF01();
    }
    return plfit_mt_uniform_01(rng);
}

inline double plfit_rpareto(double xmin, double alpha, plfit_mt_rng_t* rng) {
    if (alpha <= 0 || xmin <= 0)
        return NAN;

    /* 1-u is used in the base here because we want to avoid the case of
     * sampling zero */
    return pow(1-plfit_runif_01(rng), -1.0 / alpha) * xmin;
}

int plfit_rpareto_array(double xmin, double alpha, size_t n, plfit_mt_rng_t* rng,
        double* result) {
    double gamma;

    if (alpha <= 0 || xmin <= 0)
        return PLFIT_EINVAL;

    if (result == 0 || n == 0)
        return PLFIT_SUCCESS;

    gamma = -1.0 / alpha;
    while (n > 0) {
        /* 1-u is used in the base here because we want to avoid the case of
         * sampling zero */
        *result = pow(1-plfit_runif_01(rng), gamma) * xmin;
        result++; n--;
    }

    return PLFIT_SUCCESS;
}

inline double plfit_rzeta(long int xmin, double alpha, plfit_mt_rng_t* rng) {
    double u, v, t;
    long int x;
    double alpha_minus_1 = alpha-1;
    double minus_1_over_alpha_minus_1 = -1.0 / (alpha-1);
    double b;
    double one_over_b_minus_1;

    if (alpha <= 0 || xmin < 1)
        return NAN;

    xmin = (long int) round(xmin);

    /* Rejection sampling for the win. We use Y=floor(U^{-1/alpha} * xmin) as the
     * envelope distribution, similarly to Chapter X.6 of Luc Devroye's book
     * (where xmin is assumed to be 1): http://luc.devroye.org/chapter_ten.pdf
     *
     * Some notes that should help me recover what I was doing:
     *
     * p_i = 1/zeta(alpha, xmin) * i^-alpha
     * q_i = (xmin/i)^{alpha-1} - (xmin/(i+1))^{alpha-1}
     *     = (i/xmin)^{1-alpha} - ((i+1)/xmin)^{1-alpha}
     *     = [i^{1-alpha} - (i+1)^{1-alpha}] / xmin^{1-alpha}
     *
     * p_i / q_i attains its maximum at xmin=i, so the rejection constant is:
     *
     * c = p_xmin / q_xmin
     *
     * We have to accept the sample if V <= (p_i / q_i) * (q_xmin / p_xmin) =
     * (i/xmin)^-alpha * [xmin^{1-alpha} - (xmin+1)^{1-alpha}] / [i^{1-alpha} - (i+1)^{1-alpha}] =
     * [xmin - xmin^alpha / (xmin+1)^{alpha-1}] / [i - i^alpha / (i+1)^{alpha-1}] =
     * xmin/i * [1-(xmin/(xmin+1))^{alpha-1}]/[1-(i/(i+1))^{alpha-1}]
     *
     * In other words (and substituting i with X, which is the same),
     *
     * V * (X/xmin) <= [1 - (1+1/xmin)^{1-alpha}] / [1 - (1+1/i)^{1-alpha}]
     *
     * Let b := (1+1/xmin)^{alpha-1} and let T := (1+1/i)^{alpha-1}. Then:
     *
     * V * (X/xmin) <= [(b-1)/b] / [(T-1)/T]
     * V * (X/xmin) * (T-1) / (b-1) <= T / b
     *
     * which is the same as in Devroye's book, except for the X/xmin term, and
     * the definition of b.
     */
    b = pow(1 + 1.0/xmin, alpha_minus_1);
    one_over_b_minus_1 = 1.0/(b-1);
    do {
        do {
            u = plfit_runif_01(rng);
            v = plfit_runif_01(rng);
            /* 1-u is used in the base here because we want to avoid the case of
             * having zero in x */
            x = (long int) floor(pow(1-u, minus_1_over_alpha_minus_1) * xmin);
        } while (x < xmin);
        t = pow((x+1.0)/x, alpha_minus_1);
    } while (v*x*(t-1)*one_over_b_minus_1*b > t*xmin);

    return x;
}

int plfit_rzeta_array(long int xmin, double alpha, size_t n, plfit_mt_rng_t* rng,
        double* result) {
    double u, v, t;
    long int x;
    double alpha_minus_1 = alpha-1;
    double minus_1_over_alpha_minus_1 = -1.0 / (alpha-1);
    double b, one_over_b_minus_1;

    if (alpha <= 0 || xmin < 1)
        return PLFIT_EINVAL;

    if (result == 0 || n == 0)
        return PLFIT_SUCCESS;

    /* See the comments in plfit_rzeta for an explanation of the algorithm
     * below. */
    xmin = (long int) round(xmin);
    b = pow(1 + 1.0/xmin, alpha_minus_1);
    one_over_b_minus_1 = 1.0/(b-1);

    while (n > 0) {
        do {
            do {
                u = plfit_runif_01(rng);
                v = plfit_runif_01(rng);
                /* 1-u is used in the base here because we want to avoid the case of
                 * having zero in x */
                x = (long int) floor(pow(1-u, minus_1_over_alpha_minus_1) * xmin);
            } while (x < xmin);     /* handles overflow as well */
            t = pow((x+1.0)/x, alpha_minus_1);
        } while (v*x*(t-1)*one_over_b_minus_1*b > t*xmin);
        *result = x;
        if (x < 0) return PLFIT_EINVAL;
        result++; n--;
    }

    return PLFIT_SUCCESS;
}

int plfit_walker_alias_sampler_init(plfit_walker_alias_sampler_t* sampler,
        double* ps, size_t n) {
    double *p, *p2, *ps_end;
    double sum;
    long int *short_sticks, *long_sticks;
    long int num_short_sticks, num_long_sticks;
    long int i;

    if (n > LONG_MAX) {
        return PLFIT_EINVAL;
    }

    sampler->num_bins = (long int) n;

    ps_end = ps + n;

    /* Initialize indexes and probs */
    sampler->indexes = (long int*)calloc(n, sizeof(long int));
    if (sampler->indexes == 0) {
        return PLFIT_ENOMEM;
    }
    sampler->probs   = (double*)calloc(n, sizeof(double));
    if (sampler->probs == 0) {
        free(sampler->indexes);
        return PLFIT_ENOMEM;
    }

    /* Normalize the probability vector; count how many short and long sticks
     * are there initially */
    for (sum = 0.0, p = ps; p != ps_end; p++) {
        sum += *p;
    }
    sum = n / sum;

    num_short_sticks = num_long_sticks = 0;
    for (p = ps, p2 = sampler->probs; p != ps_end; p++, p2++) {
        *p2 = *p * sum;
        if (*p2 < 1) {
            num_short_sticks++;
        } else if (*p2 > 1) {
            num_long_sticks++;
        }
    }

    /* Allocate space for short & long stick indexes */
    long_sticks = (long int*)calloc(num_long_sticks, sizeof(long int));
    if (long_sticks == 0) {
        free(sampler->probs);
        free(sampler->indexes);
        return PLFIT_ENOMEM;
    }
    short_sticks = (long int*)calloc(num_long_sticks, sizeof(long int));
    if (short_sticks == 0) {
        free(sampler->probs);
        free(sampler->indexes);
        free(long_sticks);
        return PLFIT_ENOMEM;
    }

    /* Initialize short_sticks and long_sticks */
    num_short_sticks = num_long_sticks = 0;
    for (i = 0, p = sampler->probs; i < n; i++, p++) {
        if (*p < 1) {
            short_sticks[num_short_sticks++] = i;
        } else if (*p > 1) {
            long_sticks[num_long_sticks++] = i;
        }
    }

    /* Prepare the index table */
    while (num_short_sticks && num_long_sticks) {
        long int short_index, long_index;
        short_index = short_sticks[--num_short_sticks];
        long_index = long_sticks[num_long_sticks-1];
        sampler->indexes[short_index] = long_index;
        sampler->probs[long_index] =     /* numerical stability */
            (sampler->probs[long_index] + sampler->probs[short_index]) - 1;
        if (sampler->probs[long_index] < 1) {
            short_sticks[num_short_sticks++] = long_index;
            num_long_sticks--;
        }
    }

    /* Fix numerical stability issues */
    while (num_long_sticks) {
        i = long_sticks[--num_long_sticks];
        sampler->probs[i] = 1;
    }
    while (num_short_sticks) {
        i = short_sticks[--num_short_sticks];
        sampler->probs[i] = 1;
    }

    free(short_sticks);
    free(long_sticks);

    return PLFIT_SUCCESS;
}


void plfit_walker_alias_sampler_destroy(plfit_walker_alias_sampler_t* sampler) {
    if (sampler->indexes) {
        free(sampler->indexes);
        sampler->indexes = 0;
    }
    if (sampler->probs) {
        free(sampler->probs);
        sampler->probs = 0;
    }
}


int plfit_walker_alias_sampler_sample(const plfit_walker_alias_sampler_t* sampler,
        long int *xs, size_t n, plfit_mt_rng_t* rng) {
    double u;
    long int j;
    long int *x;

    x = xs;

    if (rng == 0) {
        /* Using built-in RNG */
        while (n > 0) {
            u = RNG_UNIF01();
            j = RNG_INTEGER(0, sampler->num_bins - 1);
            *x = (u < sampler->probs[j]) ? j : sampler->indexes[j];
            n--; x++;
        }
    } else {
        /* Using Mersenne Twister */
        while (n > 0) {
            u = plfit_mt_uniform_01(rng);
            j = plfit_mt_random(rng) % sampler->num_bins;
            *x = (u < sampler->probs[j]) ? j : sampler->indexes[j];
            n--; x++;
        }
    }

    return PLFIT_SUCCESS;
}